From b1e711e5aeb8f0c8c16ec16efb12852812db3ac2 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sun, 15 Oct 2023 21:56:22 +0800
Subject: [PATCH 0001/1315] Avoid `Style()` during broadcast whenever possible.
 (#51708)

On master, `combine_styles(bc::Broadcasted)` calls
`BroadcastStyle(typeof(bc))`, which seems bad after #49395 as it has a
`Style()` call by default.
---
 base/broadcast.jl | 4 ++++
 test/broadcast.jl | 3 +++
 2 files changed, 7 insertions(+)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index 43044f9b7d6ed..145be717cbd58 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -419,6 +419,10 @@ function combine_styles end
 
 combine_styles() = DefaultArrayStyle{0}()
 combine_styles(c) = result_style(BroadcastStyle(typeof(c)))
+function combine_styles(bc::Broadcasted)
+    bc.style isa Union{Nothing,Unknown} || return bc.style
+    throw(ArgumentError("Broadcasted{Unknown} wrappers do not have a style assigned"))
+end
 combine_styles(c1, c2) = result_style(combine_styles(c1), combine_styles(c2))
 @inline combine_styles(c1, c2, cs...) = result_style(combine_styles(c1), combine_styles(c2, cs...))
 
diff --git a/test/broadcast.jl b/test/broadcast.jl
index 269adc9f7276d..0a111f9523d60 100644
--- a/test/broadcast.jl
+++ b/test/broadcast.jl
@@ -1153,6 +1153,9 @@ Base.BroadcastStyle(a::MyBroadcastStyleWithField, b::MyBroadcastStyleWithField)
         MyBroadcastStyleWithField(1)
     @test_throws ErrorException Broadcast.result_style(MyBroadcastStyleWithField(1),
                                                        MyBroadcastStyleWithField(2))
+    dest = [0, 0]
+    dest .= Broadcast.Broadcasted(MyBroadcastStyleWithField(1), +, (1:2, 2:3))
+    @test dest == [3, 5]
 end
 
 # test that `Broadcast` definition is defined as total and eligible for concrete evaluation

From 4a1d74edc509efc1aec4ace991d86a04fb1d75fc Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Sun, 15 Oct 2023 10:45:26 -0400
Subject: [PATCH 0002/1315] Add versions to all stdlibs (#51696)

For upgradeable stdlibs we need versions numbers,
let's add them now instead of after excision.
---
 stdlib/Artifacts/Project.toml        | 1 +
 stdlib/Base64/Project.toml           | 1 +
 stdlib/CRC32c/Project.toml           | 1 +
 stdlib/Dates/Project.toml            | 1 +
 stdlib/FileWatching/Project.toml     | 1 +
 stdlib/Future/Project.toml           | 1 +
 stdlib/InteractiveUtils/Project.toml | 1 +
 stdlib/LibGit2/Project.toml          | 1 +
 stdlib/Libdl/Project.toml            | 1 +
 stdlib/LinearAlgebra/Project.toml    | 1 +
 stdlib/Logging/Project.toml          | 1 +
 stdlib/Markdown/Project.toml         | 1 +
 stdlib/Mmap/Project.toml             | 1 +
 stdlib/Printf/Project.toml           | 1 +
 stdlib/Profile/Project.toml          | 1 +
 stdlib/REPL/Project.toml             | 1 +
 stdlib/Random/Project.toml           | 1 +
 stdlib/Serialization/Project.toml    | 1 +
 stdlib/SharedArrays/Project.toml     | 1 +
 stdlib/Sockets/Project.toml          | 1 +
 stdlib/Test/Project.toml             | 1 +
 stdlib/UUIDs/Project.toml            | 1 +
 stdlib/Unicode/Project.toml          | 2 +-
 23 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/stdlib/Artifacts/Project.toml b/stdlib/Artifacts/Project.toml
index 7251b79cea8c1..c4e5cc031375c 100644
--- a/stdlib/Artifacts/Project.toml
+++ b/stdlib/Artifacts/Project.toml
@@ -1,5 +1,6 @@
 name = "Artifacts"
 uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/Base64/Project.toml b/stdlib/Base64/Project.toml
index 68d63837fc385..14796beb7e21a 100644
--- a/stdlib/Base64/Project.toml
+++ b/stdlib/Base64/Project.toml
@@ -1,5 +1,6 @@
 name = "Base64"
 uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/CRC32c/Project.toml b/stdlib/CRC32c/Project.toml
index c1de88cbc7c52..d3ab5ff019503 100644
--- a/stdlib/CRC32c/Project.toml
+++ b/stdlib/CRC32c/Project.toml
@@ -1,5 +1,6 @@
 name = "CRC32c"
 uuid = "8bf52ea8-c179-5cab-976a-9e18b702a9bc"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/Dates/Project.toml b/stdlib/Dates/Project.toml
index fe225055bad98..45da6ad1a0152 100644
--- a/stdlib/Dates/Project.toml
+++ b/stdlib/Dates/Project.toml
@@ -1,5 +1,6 @@
 name = "Dates"
 uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
+version = "1.11.0"
 
 [deps]
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
diff --git a/stdlib/FileWatching/Project.toml b/stdlib/FileWatching/Project.toml
index 1da637fd4259d..5edcfdadd085d 100644
--- a/stdlib/FileWatching/Project.toml
+++ b/stdlib/FileWatching/Project.toml
@@ -1,5 +1,6 @@
 name = "FileWatching"
 uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/Future/Project.toml b/stdlib/Future/Project.toml
index ffdbaf94b9853..c09489812ce01 100644
--- a/stdlib/Future/Project.toml
+++ b/stdlib/Future/Project.toml
@@ -1,5 +1,6 @@
 name = "Future"
 uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"
+version = "1.11.0"
 
 [deps]
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
diff --git a/stdlib/InteractiveUtils/Project.toml b/stdlib/InteractiveUtils/Project.toml
index e13902375e005..53cc9218eff5d 100644
--- a/stdlib/InteractiveUtils/Project.toml
+++ b/stdlib/InteractiveUtils/Project.toml
@@ -1,5 +1,6 @@
 name = "InteractiveUtils"
 uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+version = "1.11.0"
 
 [deps]
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
diff --git a/stdlib/LibGit2/Project.toml b/stdlib/LibGit2/Project.toml
index 1205716369e09..83d359d6a4f1a 100644
--- a/stdlib/LibGit2/Project.toml
+++ b/stdlib/LibGit2/Project.toml
@@ -1,5 +1,6 @@
 name = "LibGit2"
 uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
+version = "1.11.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
diff --git a/stdlib/Libdl/Project.toml b/stdlib/Libdl/Project.toml
index 26e5bf0cdefd7..7fab4b9334260 100644
--- a/stdlib/Libdl/Project.toml
+++ b/stdlib/Libdl/Project.toml
@@ -1,5 +1,6 @@
 name = "Libdl"
 uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/LinearAlgebra/Project.toml b/stdlib/LinearAlgebra/Project.toml
index 46653aa795209..892de0397c219 100644
--- a/stdlib/LinearAlgebra/Project.toml
+++ b/stdlib/LinearAlgebra/Project.toml
@@ -1,5 +1,6 @@
 name = "LinearAlgebra"
 uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+version = "1.11.0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/stdlib/Logging/Project.toml b/stdlib/Logging/Project.toml
index af931e68e07d1..ce69112733d5e 100644
--- a/stdlib/Logging/Project.toml
+++ b/stdlib/Logging/Project.toml
@@ -1,5 +1,6 @@
 name = "Logging"
 uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/Markdown/Project.toml b/stdlib/Markdown/Project.toml
index 229e58749d233..b40de17b9422d 100644
--- a/stdlib/Markdown/Project.toml
+++ b/stdlib/Markdown/Project.toml
@@ -1,5 +1,6 @@
 name = "Markdown"
 uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
+version = "1.11.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
diff --git a/stdlib/Mmap/Project.toml b/stdlib/Mmap/Project.toml
index f3dab686d2eaa..ce4b65ccbb06a 100644
--- a/stdlib/Mmap/Project.toml
+++ b/stdlib/Mmap/Project.toml
@@ -1,5 +1,6 @@
 name = "Mmap"
 uuid = "a63ad114-7e13-5084-954f-fe012c677804"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/Printf/Project.toml b/stdlib/Printf/Project.toml
index 9fa4e3633cae1..019b7e94ef9bd 100644
--- a/stdlib/Printf/Project.toml
+++ b/stdlib/Printf/Project.toml
@@ -1,5 +1,6 @@
 name = "Printf"
 uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+version = "1.11.0"
 
 [deps]
 Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
diff --git a/stdlib/Profile/Project.toml b/stdlib/Profile/Project.toml
index 334d475832b6d..8e50b474f1cd3 100644
--- a/stdlib/Profile/Project.toml
+++ b/stdlib/Profile/Project.toml
@@ -1,5 +1,6 @@
 name = "Profile"
 uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
+version = "1.11.0"
 
 [deps]
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
diff --git a/stdlib/REPL/Project.toml b/stdlib/REPL/Project.toml
index 2c3ab32fdc327..77eca2bfe4240 100644
--- a/stdlib/REPL/Project.toml
+++ b/stdlib/REPL/Project.toml
@@ -1,5 +1,6 @@
 name = "REPL"
 uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+version = "1.11.0"
 
 [deps]
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
diff --git a/stdlib/Random/Project.toml b/stdlib/Random/Project.toml
index f86f0a54f8ba4..5a9cc2dfc4cb7 100644
--- a/stdlib/Random/Project.toml
+++ b/stdlib/Random/Project.toml
@@ -1,5 +1,6 @@
 name = "Random"
 uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+version = "1.11.0"
 
 [deps]
 SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce"
diff --git a/stdlib/Serialization/Project.toml b/stdlib/Serialization/Project.toml
index 4a2f7874e3124..97e898d731c7d 100644
--- a/stdlib/Serialization/Project.toml
+++ b/stdlib/Serialization/Project.toml
@@ -1,5 +1,6 @@
 name = "Serialization"
 uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/SharedArrays/Project.toml b/stdlib/SharedArrays/Project.toml
index 588785347c73d..46e5332f8d89d 100644
--- a/stdlib/SharedArrays/Project.toml
+++ b/stdlib/SharedArrays/Project.toml
@@ -1,5 +1,6 @@
 name = "SharedArrays"
 uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
+version = "1.11.0"
 
 [deps]
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
diff --git a/stdlib/Sockets/Project.toml b/stdlib/Sockets/Project.toml
index 5afb89b29f126..6a395465722f2 100644
--- a/stdlib/Sockets/Project.toml
+++ b/stdlib/Sockets/Project.toml
@@ -1,5 +1,6 @@
 name = "Sockets"
 uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/Test/Project.toml b/stdlib/Test/Project.toml
index ee1ae15fd7154..f04b4f976196f 100644
--- a/stdlib/Test/Project.toml
+++ b/stdlib/Test/Project.toml
@@ -1,5 +1,6 @@
 name = "Test"
 uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+version = "1.11.0"
 
 [deps]
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
diff --git a/stdlib/UUIDs/Project.toml b/stdlib/UUIDs/Project.toml
index 11dbcda5c4944..4eb31dc9572c0 100644
--- a/stdlib/UUIDs/Project.toml
+++ b/stdlib/UUIDs/Project.toml
@@ -1,5 +1,6 @@
 name = "UUIDs"
 uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+version = "1.11.0"
 
 [deps]
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
diff --git a/stdlib/Unicode/Project.toml b/stdlib/Unicode/Project.toml
index 5e3040ce9e3db..a01833870644e 100644
--- a/stdlib/Unicode/Project.toml
+++ b/stdlib/Unicode/Project.toml
@@ -1,6 +1,6 @@
 name = "Unicode"
 uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
-
+version = "1.11.0"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

From 0acca3c35524cff5c3dd65c25d1b104e62db22cb Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 15 Oct 2023 15:21:33 -0400
Subject: [PATCH 0003/1315] Optimize away try/catch blocks that are known not
 to trigger (#51674)

This leverages the support from #51590 to delete any try catch block
that is known not to be triggered (either because the try-body is empty
to because we have proven `:nothrow` for all contained statements).
---
 base/compiler/abstractinterpretation.jl | 41 ++++++++-------
 base/compiler/optimize.jl               | 55 ++++++++++++--------
 base/compiler/ssair/ir.jl               | 15 ++++++
 base/compiler/ssair/slot2ssa.jl         |  3 +-
 base/compiler/typelattice.jl            | 18 -------
 src/codegen.cpp                         | 11 ++--
 test/compiler/inference.jl              | 69 +++++++++++++++++++++++++
 7 files changed, 149 insertions(+), 63 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index bfddc2d6927b3..00e9ef48d9fe2 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2981,6 +2981,20 @@ function update_bestguess!(interp::AbstractInterpreter, frame::InferenceState,
     end
 end
 
+function propagate_to_error_handler!(frame::InferenceState, currpc::Int, W::BitSet, 𝕃ᵢ::AbstractLattice, currstate::VarTable)
+    # If this statement potentially threw, propagate the currstate to the
+    # exception handler, BEFORE applying any state changes.
+    cur_hand = frame.handler_at[currpc]
+    if cur_hand != 0
+        enter = frame.src.code[cur_hand]::Expr
+        l = enter.args[1]::Int
+        exceptbb = block_for_inst(frame.cfg, l)
+        if update_bbstate!(𝕃ᵢ, frame, exceptbb, currstate)
+            push!(W, exceptbb)
+        end
+    end
+end
+
 # make as much progress on `frame` as possible (without handling cycles)
 function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
     @assert !is_inferred(frame)
@@ -3037,6 +3051,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                     if nothrow
                         add_curr_ssaflag!(frame, IR_FLAG_NOTHROW)
                     else
+                        propagate_to_error_handler!(frame, currpc, W, 𝕃ᵢ, currstate)
                         merge_effects!(interp, frame, EFFECTS_THROWS)
                     end
 
@@ -3107,12 +3122,9 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                     ssavaluetypes[frame.currpc] = Any
                     @goto find_next_bb
                 elseif isexpr(stmt, :enter)
-                    # Propagate entry info to exception handler
-                    l = stmt.args[1]::Int
-                    catchbb = block_for_inst(frame.cfg, l)
-                    if update_bbstate!(𝕃ᵢ, frame, catchbb, currstate)
-                        push!(W, catchbb)
-                    end
+                    ssavaluetypes[currpc] = Any
+                    @goto fallthrough
+                elseif isexpr(stmt, :leave)
                     ssavaluetypes[currpc] = Any
                     @goto fallthrough
                 end
@@ -3121,26 +3133,15 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             # Process non control-flow statements
             (; changes, type) = abstract_eval_basic_statement(interp,
                 stmt, currstate, frame)
+            if (get_curr_ssaflag(frame) & IR_FLAG_NOTHROW) != IR_FLAG_NOTHROW
+                propagate_to_error_handler!(frame, currpc, W, 𝕃ᵢ, currstate)
+            end
             if type === Bottom
                 ssavaluetypes[currpc] = Bottom
                 @goto find_next_bb
             end
             if changes !== nothing
                 stoverwrite1!(currstate, changes)
-                let cur_hand = frame.handler_at[currpc], l, enter
-                    while cur_hand != 0
-                        enter = frame.src.code[cur_hand]::Expr
-                        l = enter.args[1]::Int
-                        exceptbb = block_for_inst(frame.cfg, l)
-                        # propagate new type info to exception handler
-                        # the handling for Expr(:enter) propagates all changes from before the try/catch
-                        # so this only needs to propagate any changes
-                        if stupdate1!(𝕃ᵢ, states[exceptbb]::VarTable, changes)
-                            push!(W, exceptbb)
-                        end
-                        cur_hand = frame.handler_at[cur_hand]
-                    end
-                end
             end
             if type === nothing
                 ssavaluetypes[currpc] = Any
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 4a0f7d8071553..a1ff740b5b83d 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -839,27 +839,35 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
     code = copy_exprargs(ci.code)
     for i = 1:length(code)
         expr = code[i]
-        if !(i in sv.unreachable) && isa(expr, GotoIfNot)
-            # Replace this live GotoIfNot with:
-            # - no-op if :nothrow and the branch target is unreachable
-            # - cond if :nothrow and both targets are unreachable
-            # - typeassert if must-throw
-            block = block_for_inst(sv.cfg, i)
-            if ssavaluetypes[i] === Bottom
-                destblock = block_for_inst(sv.cfg, expr.dest)
-                cfg_delete_edge!(sv.cfg, block, block + 1)
-                ((block + 1) != destblock) && cfg_delete_edge!(sv.cfg, block, destblock)
-                expr = Expr(:call, Core.typeassert, expr.cond, Bool)
-            elseif i + 1 in sv.unreachable
-                @assert (ci.ssaflags[i] & IR_FLAG_NOTHROW) != 0
-                cfg_delete_edge!(sv.cfg, block, block + 1)
-                expr = GotoNode(expr.dest)
-            elseif expr.dest in sv.unreachable
-                @assert (ci.ssaflags[i] & IR_FLAG_NOTHROW) != 0
-                cfg_delete_edge!(sv.cfg, block, block_for_inst(sv.cfg, expr.dest))
-                expr = nothing
+        if !(i in sv.unreachable)
+            if isa(expr, GotoIfNot)
+                # Replace this live GotoIfNot with:
+                # - no-op if :nothrow and the branch target is unreachable
+                # - cond if :nothrow and both targets are unreachable
+                # - typeassert if must-throw
+                block = block_for_inst(sv.cfg, i)
+                if ssavaluetypes[i] === Bottom
+                    destblock = block_for_inst(sv.cfg, expr.dest)
+                    cfg_delete_edge!(sv.cfg, block, block + 1)
+                    ((block + 1) != destblock) && cfg_delete_edge!(sv.cfg, block, destblock)
+                    expr = Expr(:call, Core.typeassert, expr.cond, Bool)
+                elseif i + 1 in sv.unreachable
+                    @assert (ci.ssaflags[i] & IR_FLAG_NOTHROW) != 0
+                    cfg_delete_edge!(sv.cfg, block, block + 1)
+                    expr = GotoNode(expr.dest)
+                elseif expr.dest in sv.unreachable
+                    @assert (ci.ssaflags[i] & IR_FLAG_NOTHROW) != 0
+                    cfg_delete_edge!(sv.cfg, block, block_for_inst(sv.cfg, expr.dest))
+                    expr = nothing
+                end
+                code[i] = expr
+            elseif isexpr(expr, :enter)
+                catchdest = expr.args[1]::Int
+                if catchdest in sv.unreachable
+                    cfg_delete_edge!(sv.cfg, block_for_inst(sv.cfg, i), block_for_inst(sv.cfg, catchdest))
+                    code[i] = nothing
+                end
             end
-            code[i] = expr
         end
     end
 
@@ -1239,7 +1247,12 @@ function renumber_ir_elements!(body::Vector{Any}, ssachangemap::Vector{Int}, lab
             end
             if el.head === :enter
                 tgt = el.args[1]::Int
-                el.args[1] = tgt + labelchangemap[tgt]
+                was_deleted = labelchangemap[tgt] == typemin(Int)
+                if was_deleted
+                    body[i] = nothing
+                else
+                    el.args[1] = tgt + labelchangemap[tgt]
+                end
             elseif !is_meta_expr_head(el.head)
                 args = el.args
                 for i = 1:length(args)
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 1e01e0f476daa..3f8160a088e8d 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1364,6 +1364,21 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
                 ssa_rename[idx] = nothing
                 return result_idx
             end
+        elseif isexpr(stmt, :leave)
+            let i = 1
+                while i <= length(stmt.args)
+                    if stmt.args[i] === nothing
+                        deleteat!(stmt.args, i)
+                    else
+                        i += 1
+                    end
+                end
+            end
+            if isempty(stmt.args)
+                # This :leave is dead
+                ssa_rename[idx] = nothing
+                return result_idx
+            end
         end
         typ = inst[:type]
         if isa(typ, Const) && is_inlineable_constant(typ.val)
diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl
index 39e092332aae6..1f682d9168413 100644
--- a/base/compiler/ssair/slot2ssa.jl
+++ b/base/compiler/ssair/slot2ssa.jl
@@ -875,7 +875,8 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
                 new_code[idx] = GotoIfNot(stmt.cond, new_dest)
             end
         elseif isexpr(stmt, :enter)
-            new_code[idx] = Expr(:enter, block_for_inst(cfg, stmt.args[1]::Int))
+            except_bb = block_for_inst(cfg, stmt.args[1]::Int)
+            new_code[idx] = Expr(:enter, except_bb)
             ssavalmap[idx] = SSAValue(idx) # Slot to store token for pop_exception
         elseif isexpr(stmt, :leave) || isexpr(stmt, :(=)) || isa(stmt, ReturnNode) ||
             isexpr(stmt, :meta) || isa(stmt, NewvarNode)
diff --git a/base/compiler/typelattice.jl b/base/compiler/typelattice.jl
index df6022609d612..0c44a610f8f95 100644
--- a/base/compiler/typelattice.jl
+++ b/base/compiler/typelattice.jl
@@ -759,24 +759,6 @@ function stupdate!(lattice::AbstractLattice, state::VarTable, changes::VarTable)
     return changed
 end
 
-function stupdate1!(lattice::AbstractLattice, state::VarTable, change::StateUpdate)
-    changeid = slot_id(change.var)
-    for i = 1:length(state)
-        invalidated = invalidate_slotwrapper(state[i], changeid, change.conditional)
-        if invalidated !== nothing
-            state[i] = invalidated
-        end
-    end
-    # and update the type of it
-    newtype = change.vtype
-    oldtype = state[changeid]
-    if schanged(lattice, newtype, oldtype)
-        state[changeid] = smerge(lattice, oldtype, newtype)
-        return true
-    end
-    return false
-end
-
 function stoverwrite!(state::VarTable, newstate::VarTable)
     for i = 1:length(state)
         state[i] = newstate[i]
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 940f235bf59fc..402924c4b778b 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -5180,14 +5180,19 @@ static void emit_ssaval_assign(jl_codectx_t &ctx, ssize_t ssaidx_0based, jl_valu
     ctx.ssavalue_assigned[ssaidx_0based] = true;
 }
 
-static void emit_varinfo_assign(jl_codectx_t &ctx, jl_varinfo_t &vi, jl_cgval_t rval_info, jl_value_t *l=NULL)
+static void emit_varinfo_assign(jl_codectx_t &ctx, jl_varinfo_t &vi, jl_cgval_t rval_info, jl_value_t *l=NULL, bool allow_mismatch=false)
 {
     if (!vi.used || vi.value.typ == jl_bottom_type)
         return;
 
     // convert rval-type to lval-type
     jl_value_t *slot_type = vi.value.typ;
-    rval_info = convert_julia_type(ctx, rval_info, slot_type);
+    // If allow_mismatch is set, type mismatches will not result in traps.
+    // This is used for upsilon nodes, where the destination can have a narrower
+    // type than the store, if inference determines that the store is never read.
+    Value *dummy = NULL;
+    Value **skip = allow_mismatch ? &dummy : NULL;
+    rval_info = convert_julia_type(ctx, rval_info, slot_type, skip);
     if (rval_info.typ == jl_bottom_type)
         return;
 
@@ -5284,7 +5289,7 @@ static void emit_upsilonnode(jl_codectx_t &ctx, ssize_t phic, jl_value_t *val)
             // was unreachable and dead
             val = NULL;
         else
-            emit_varinfo_assign(ctx, vi, rval_info);
+            emit_varinfo_assign(ctx, vi, rval_info, NULL, true);
     }
     if (!val) {
         if (vi.boxroot) {
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 619e6f6f87a53..afda3c1793031 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5284,3 +5284,72 @@ end
 @test only(Base.return_types((x,f) -> getfield(x, f), (An51317, Symbol))) === Int
 @test only(Base.return_types(x -> getfield(x, :b), (A51317,))) === Union{}
 @test only(Base.return_types(x -> getfield(x, :b), (An51317,))) === Union{}
+
+# Don't visit the catch block for empty try/catch
+function completely_dead_try_catch()
+    try
+    catch
+        return 2.0
+    end
+    return 1
+end
+@test Base.return_types(completely_dead_try_catch) |> only === Int
+@test fully_eliminated(completely_dead_try_catch)
+
+function nothrow_try_catch()
+    try
+        1+1
+    catch
+        return 2.0
+    end
+    return 1
+end
+@test Base.return_types(nothrow_try_catch) |> only === Int
+@test fully_eliminated(nothrow_try_catch)
+
+may_error(b) = Base.inferencebarrier(b) && error()
+function phic_type1()
+    a = 1
+    try
+        may_error(false)
+        a = 1.0
+    catch
+        return a
+    end
+    return 2
+end
+@test Base.return_types(phic_type1) |> only === Int
+@test phic_type1() === 2
+
+function phic_type2()
+    a = 1
+    try
+        may_error(false)
+        a = 1.0
+        may_error(false)
+    catch
+        return a
+    end
+    return 2
+end
+@test Base.return_types(phic_type2) |> only === Union{Int, Float64}
+@test phic_type2() === 2
+
+function phic_type3()
+    a = 1
+    try
+        may_error(false)
+        a = 1.0
+        may_error(false)
+        if Base.inferencebarrier(false)
+            a = Ref(1)
+        elseif Base.inferencebarrier(false)
+            a = nothing
+        end
+    catch
+        return a
+    end
+    return 2
+end
+@test Base.return_types(phic_type3) |> only === Union{Int, Float64}
+@test phic_type3() === 2

From ff03e5116d452d0e6e5970a50c187d468febf594 Mon Sep 17 00:00:00 2001
From: Paul Berg <paul@plutojl.org>
Date: Mon, 16 Oct 2023 02:41:46 +0200
Subject: [PATCH 0004/1315] Allow using `ReturnNode()` in `@generated` code
 (#51715)

IRTools.jl currently tries to use `ReturnNode()` to model unreachable
block terminators but it fails in `find_ssavalue_uses`. This PR adds a
check to enable using `ReturnNode()` in untyped code.

One other alternative for frontends is to use an instruction known to
terminate (`Core.throw`) instead. See
https://github.com/FluxML/IRTools.jl/pull/115 for more context.
---
 base/compiler/utilities.jl |  1 +
 test/staged.jl             | 29 +++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index bdc0156efd824..78079e6174f29 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -390,6 +390,7 @@ function find_ssavalue_uses(body::Vector{Any}, nvals::Int)
     for line in 1:length(body)
         e = body[line]
         if isa(e, ReturnNode)
+            isdefined(e, :val) || continue
             e = e.val
         elseif isa(e, GotoIfNot)
             e = e.cond
diff --git a/test/staged.jl b/test/staged.jl
index 5204f5f6ca777..76d02c1938e4d 100644
--- a/test/staged.jl
+++ b/test/staged.jl
@@ -346,3 +346,32 @@ let world = Base.get_world_counter()
     @test all(lin->lin.method === :sin, src.linetable)
     @test sin_generated(42) == sin(42)
 end
+
+# Allow passing unreachable insts in generated codeinfo
+let
+    dummy() = return
+    dummy_m = which(dummy, Tuple{})
+
+    src = Base.uncompressed_ir(dummy_m)
+    src.code = Any[
+        # block 1
+        Core.ReturnNode(nothing),
+        # block 2
+        Core.ReturnNode(),
+    ]
+    nstmts = length(src.code)
+    nslots = 1
+    src.ssavaluetypes = nstmts
+    src.codelocs = fill(Int32(1), nstmts)
+    src.ssaflags = fill(Int32(0), nstmts)
+    src.slotflags = fill(0, nslots)
+    src.slottypes = Any[Any]
+
+    @eval function f_unreachable()
+        $(Expr(:meta, :generated, Returns(src)))
+        $(Expr(:meta, :generated_only))
+    end
+
+    ir, _ = Base.code_ircode(f_unreachable, ()) |> only
+    @test length(ir.cfg.blocks) == 1
+end

From 0c4af3288e8a4aab71c39b6ee5174964101e0704 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sun, 15 Oct 2023 20:34:52 -0500
Subject: [PATCH 0005/1315] Fix typos [nfc] (#51709)

---
 HISTORY.md                                    |   2 +-
 NEWS.md                                       |   2 +-
 base/broadcast.jl                             |   2 +-
 base/client.jl                                |   2 +-
 base/compiler/abstractinterpretation.jl       |   6 +-
 base/compiler/abstractlattice.jl              |   2 +-
 base/compiler/inferencestate.jl               |   4 +-
 base/compiler/ssair/show.jl                   |   2 +-
 base/compiler/tfuncs.jl                       |   2 +-
 base/dict.jl                                  |   2 +-
 base/hamt.jl                                  |   4 +-
 base/libc.jl                                  |   2 +-
 base/reflection.jl                            |   2 +-
 base/reinterpretarray.jl                      |   2 +-
 base/sort.jl                                  |   4 +-
 base/strings/string.jl                        |   2 +-
 base/toml_parser.jl                           |   6 +-
 base/version.jl                               |   2 +-
 contrib/generate_precompile.jl                |   2 +-
 .../frameworkapp/JuliaLauncher/AppDelegate.m  |   2 +-
 deps/valgrind/valgrind.h                      |   2 +-
 doc/src/base/scopedvalues.md                  |   6 +-
 doc/src/devdocs/pkgimg.md                     |   2 +-
 doc/src/index.md                              |   2 +-
 doc/src/manual/command-line-interface.md      |   2 +-
 doc/src/manual/modules.md                     |   2 +-
 doc/src/manual/noteworthy-differences.md      |   2 +-
 doc/src/manual/strings.md                     |   2 +-
 src/aotcompile.cpp                            |   2 +-
 src/cgutils.cpp                               |   2 +-
 src/codegen.cpp                               |   2 +-
 src/flisp/read.c                              |   2 +-
 src/gc-heap-snapshot.cpp                      |   2 +-
 src/gc.c                                      |   4 +-
 src/intrinsics.cpp                            |   2 +-
 src/jitlayers.cpp                             |   2 +-
 src/julia_internal.h                          |   4 +-
 src/llvm-alloc-helpers.cpp                    |   2 +-
 src/llvm-late-gc-lowering.cpp                 |   6 +-
 src/llvm-lower-handlers.cpp                   |   2 +-
 src/signal-handling.c                         |   2 +-
 src/stackwalk.c                               |   2 +-
 src/subtype.c                                 |  14 +-
 stdlib/Dates/docs/src/index.md                |   4 +-
 stdlib/InteractiveUtils/test/highlighting.jl  | 184 +++++++++---------
 stdlib/LibGit2/src/callbacks.jl               |   4 +-
 stdlib/LinearAlgebra/src/generic.jl           |   4 +-
 stdlib/LinearAlgebra/src/lu.jl                |   2 +-
 stdlib/LinearAlgebra/test/dense.jl            |   2 +-
 stdlib/LinearAlgebra/test/triangular.jl       |   2 +-
 stdlib/Printf/src/Printf.jl                   |   2 +-
 stdlib/REPL/src/latex_symbols.jl              |   8 +-
 stdlib/REPL/src/precompile.jl                 |   4 +-
 stdlib/REPL/test/replcompletions.jl           |   2 +-
 stdlib/Random/docs/src/index.md               |   2 +-
 stdlib/SuiteSparse_jll/test/runtests.jl       |   2 +-
 stdlib/TOML/test/toml_test.jl                 |   2 +-
 stdlib/Test/src/Test.jl                       |   2 +-
 stdlib/Test/test/runtests.jl                  |  30 +--
 test/clangsa/GCPushPop.cpp                    |   2 +-
 test/cmdlineargs.jl                           |   2 +-
 test/compiler/inference.jl                    |  22 +--
 test/compiler/inline.jl                       |   2 +-
 test/compiler/invalidation.jl                 |  20 +-
 test/core.jl                                  |   2 +-
 test/gcext/gcext.c                            |   2 +-
 test/intrinsics.jl                            |   2 +-
 test/misc.jl                                  |   4 +-
 test/operators.jl                             |   2 +-
 test/testhelpers/DualNumbers.jl               |   2 +-
 70 files changed, 221 insertions(+), 221 deletions(-)

diff --git a/HISTORY.md b/HISTORY.md
index 6a4373cdbf337..1d46189c74c51 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -98,7 +98,7 @@ Standard library changes
   ([#46196]).
 * Adjoints and transposes of `Factorization` objects are no longer wrapped in `Adjoint`
   and `Transpose` wrappers, respectively. Instead, they are wrapped in
-  `AdjointFactorization` and `TranposeFactorization` types, which themselves subtype
+  `AdjointFactorization` and `TransposeFactorization` types, which themselves subtype
   `Factorization` ([#46874]).
 * New functions `hermitianpart` and `hermitianpart!` for extracting the Hermitian
   (real symmetric) part of a matrix ([#31836]).
diff --git a/NEWS.md b/NEWS.md
index c8ed757ef3fd7..bab64a2d195ac 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -22,7 +22,7 @@ Command-line option changes
 ---------------------------
 
 * The entry point for Julia has been standardized to `Main.main(ARGS)`. This must be explicitly opted into using the `@main` macro
-(see the docstring for futher details). When opted-in, and julia is invoked to run a script or expression
+(see the docstring for further details). When opted-in, and julia is invoked to run a script or expression
 (i.e. using `julia script.jl` or `julia -e expr`), julia will subsequently run the `Main.main` function automatically.
 This is intended to unify script and compilation workflows, where code loading may happen
 in the compiler and execution of `Main.main` may happen in the resulting executable. For interactive use, there is no semantic
diff --git a/base/broadcast.jl b/base/broadcast.jl
index 145be717cbd58..97e69cc680358 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -379,7 +379,7 @@ make_makeargs(args::Tuple) = _make_makeargs(args, 1)[1]
 end
 _make_makeargs(::Tuple{}, n::Int) = (), n
 
-# A help struct to store the flattened index staticly
+# A help struct to store the flattened index statically
 struct Pick{N} <: Function end
 (::Pick{N})(@nospecialize(args::Tuple)) where {N} = args[N]
 
diff --git a/base/client.jl b/base/client.jl
index 79541f2c106b1..69f35d3fdd4fc 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -613,7 +613,7 @@ In the `julia` driver, if `Main.main` is marked as an entrypoint, it will be aut
 the completion of script execution.
 
 The `@main` macro may be used standalone or as part of the function definition, though in the latter
-case, parenthese are required. In particular, the following are equivalent:
+case, parentheses are required. In particular, the following are equivalent:
 
 ```
 function (@main)(ARGS)
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 00e9ef48d9fe2..bbbff8e250e8b 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1150,7 +1150,7 @@ function semi_concrete_eval_call(interp::AbstractInterpreter,
             if !(isa(rt, Type) && hasintersect(rt, Bool))
                 ir = irsv.ir
                 # TODO (#48913) enable double inlining pass when there are any calls
-                # that are newly resovled by irinterp
+                # that are newly resolved by irinterp
                 # state = InliningState(interp)
                 # ir = ssa_inlining_pass!(irsv.ir, state, propagate_inbounds(irsv))
                 effects = result.effects
@@ -1219,7 +1219,7 @@ end
                             conditional_argtypes::ConditionalArgtypes)
 
 The implementation is able to forward `Conditional` of `conditional_argtypes`,
-as well as the other general extended lattice inforamtion.
+as well as the other general extended lattice information.
 """
 function matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance,
                                  conditional_argtypes::ConditionalArgtypes)
@@ -2309,7 +2309,7 @@ function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo, sv::Infere
     si = StmtInfo(!call_result_unused(sv, sv.currpc))
     (; rt, effects, info) = abstract_call(interp, arginfo, si, sv)
     sv.stmt_info[sv.currpc] = info
-    # mark this call statement as DCE-elgible
+    # mark this call statement as DCE-eligible
     # TODO better to do this in a single pass based on the `info` object at the end of abstractinterpret?
     return RTEffects(rt, effects)
 end
diff --git a/base/compiler/abstractlattice.jl b/base/compiler/abstractlattice.jl
index c1229124d1cec..18b6a5473abd0 100644
--- a/base/compiler/abstractlattice.jl
+++ b/base/compiler/abstractlattice.jl
@@ -260,7 +260,7 @@ end
 Appropriately converts inferred type of a return value `rt` to such a type
 that we know we can store in the cache and is valid and good inter-procedurally,
 E.g. if `rt isa Conditional` then `rt` should be converted to `InterConditional`
-or the other cachable lattice element.
+or the other cacheable lattice element.
 
 External lattice `𝕃ᵢ::ExternalLattice` may overload:
 - `widenreturn(𝕃ᵢ::ExternalLattice, @nospecialize(rt), info::BestguessInfo)`
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 9546d9ef79184..6a6aba1076449 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -338,8 +338,8 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
     # 3: (expr)    # == 1
     # 3: (leave %1) # == 1
     # 4: (expr)    # == 0
-    # then we can find all trys by walking backwards from :enter statements,
-    # and all catches by looking at the statement after the :enter
+    # then we can find all `try`s by walking backwards from :enter statements,
+    # and all `catch`es by looking at the statement after the :enter
     n = length(code)
     empty!(ip)
     ip.offset = 0 # for _bits_findnext
diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl
index e9e2aa75f755e..67698fbc89aaa 100644
--- a/base/compiler/ssair/show.jl
+++ b/base/compiler/ssair/show.jl
@@ -250,7 +250,7 @@ We get:
   └──      return %3                      │
 ```
 
-Even though we were in the `f` scope since the first statement, it tooks us two statements
+Even though we were in the `f` scope since the first statement, it took us two statements
 to catch up and print the intermediate scopes. Which scope is printed is indicated both
 by the indentation of the method name and by an increased thickness of the appropriate
 line for the scope.
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 7f7766e44a164..d332c88bd240c 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -1655,7 +1655,7 @@ function apply_type_nothrow(𝕃::AbstractLattice, argtypes::Vector{Any}, @nospe
     (headtype === Union) && return true
     isa(rt, Const) && return true
     u = headtype
-    # TODO: implement optimization for isvarargtype(u) and istuple occurences (which are valid but are not UnionAll)
+    # TODO: implement optimization for isvarargtype(u) and istuple occurrences (which are valid but are not UnionAll)
     for i = 2:length(argtypes)
         isa(u, UnionAll) || return false
         ai = widenconditional(argtypes[i])
diff --git a/base/dict.jl b/base/dict.jl
index d4efe268f641a..b2797db8dc059 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -896,7 +896,7 @@ end
 
 `PersistentDict` is a dictionary implemented as an hash array mapped trie,
 which is optimal for situations where you need persistence, each operation
-returns a new dictonary separate from the previous one, but the underlying
+returns a new dictionary separate from the previous one, but the underlying
 implementation is space-efficient and may share storage across multiple
 separate dictionaries.
 
diff --git a/base/hamt.jl b/base/hamt.jl
index 3c95d974800fa..d801352fce6c5 100644
--- a/base/hamt.jl
+++ b/base/hamt.jl
@@ -29,11 +29,11 @@ export HAMT
 #
 # At each level we use a 32bit bitmap to store which elements are occupied.
 # Since our storage is "sparse" we need to map from index in [0,31] to
-# the actual storage index. We mask the bitmap wiht (1 << i) - 1 and count
+# the actual storage index. We mask the bitmap with (1 << i) - 1 and count
 # the ones in the result. The number of set ones (+1) gives us the index
 # into the storage array.
 #
-# HAMT can be both persitent and non-persistent.
+# HAMT can be both persistent and non-persistent.
 # The `path` function searches for a matching entries, and for persistency
 # optionally copies the path so that it can be safely mutated.
 
diff --git a/base/libc.jl b/base/libc.jl
index 25d1e4c495804..f74f7b4ca5230 100644
--- a/base/libc.jl
+++ b/base/libc.jl
@@ -6,7 +6,7 @@ Interface to libc, the C standard library.
 """ Libc
 
 import Base: transcode, windowserror, show
-# these need to be defined seperately for bootstrapping but belong to Libc
+# these need to be defined separately for bootstrapping but belong to Libc
 import Base: memcpy, memmove, memset, memcmp
 import Core.Intrinsics: bitcast
 
diff --git a/base/reflection.jl b/base/reflection.jl
index 6204a4cb44482..469bd8e1b40a3 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1354,7 +1354,7 @@ struct CodegenParams
     using the `swiftself` convention, which in the ordinary case means that the
     pointer is kept in a register and accesses are thus very fast. If this option
     is disabled, the task local state pointer must be loaded from thread local
-    stroage, which incurs a small amount of additional overhead. The option is enabled by
+    storage, which incurs a small amount of additional overhead. The option is enabled by
     default.
     """
     gcstack_arg::Cint
diff --git a/base/reinterpretarray.jl b/base/reinterpretarray.jl
index 3844edc331c7c..a4aa66c7f3533 100644
--- a/base/reinterpretarray.jl
+++ b/base/reinterpretarray.jl
@@ -672,7 +672,7 @@ end
 """
     CyclePadding(padding, total_size)
 
-Cylces an iterator of `Padding` structs, restarting the padding at `total_size`.
+Cycles an iterator of `Padding` structs, restarting the padding at `total_size`.
 E.g. if `padding` is all the padding in a struct and `total_size` is the total
 aligned size of that array, `CyclePadding` will correspond to the padding in an
 infinite vector of such structs.
diff --git a/base/sort.jl b/base/sort.jl
index ceea7365a08b2..95909f90ad8e5 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -1299,7 +1299,7 @@ Next, we [`ConsiderCountingSort`](@ref). If the range the input is small compare
 length, we apply [`CountingSort`](@ref).
 
 Next, we [`ConsiderRadixSort`](@ref). This is similar to the dispatch to counting sort,
-but we conside rthe number of _bits_ in the range, rather than the range itself.
+but we consider the number of _bits_ in the range, rather than the range itself.
 Consequently, we apply [`RadixSort`](@ref) for any reasonably long inputs that reach this
 stage.
 
@@ -1367,7 +1367,7 @@ algorithms).
 Elements are first transformed with the function `by` and then compared
 according to either the function `lt` or the ordering `order`. Finally, the
 resulting order is reversed if `rev=true` (this preserves forward stability:
-elements that compare equal are not reversed). The current implemention applies
+elements that compare equal are not reversed). The current implementation applies
 the `by` transformation before each comparison rather than once per element.
 
 Passing an `lt` other than `isless` along with an `order` other than
diff --git a/base/strings/string.jl b/base/strings/string.jl
index fefaf5d79ea3a..bb3a292c26b1d 100644
--- a/base/strings/string.jl
+++ b/base/strings/string.jl
@@ -247,7 +247,7 @@ end
 
            Shifts | 0  4 10 14 18 24  8 20 12 26
 
-    The shifts that represent each state were derived using teh SMT solver Z3, to ensure when encoded into
+    The shifts that represent each state were derived using the SMT solver Z3, to ensure when encoded into
     the rows the correct shift was a result.
 
     Each character class row is encoding 10 states with shifts as defined above. By shifting the bitsof a row by
diff --git a/base/toml_parser.jl b/base/toml_parser.jl
index 18166b03e23b3..086b7d99580c0 100644
--- a/base/toml_parser.jl
+++ b/base/toml_parser.jl
@@ -80,7 +80,7 @@ mutable struct Parser
     # Filled in in case we are parsing a file to improve error messages
     filepath::Union{String, Nothing}
 
-    # Get's populated with the Dates stdlib if it exists
+    # Gets populated with the Dates stdlib if it exists
     Dates::Union{Module, Nothing}
 end
 
@@ -367,7 +367,7 @@ end
 @inline peek(l::Parser) = l.current_char
 
 # Return true if the character was accepted. When a character
-# is accepted it get's eaten and we move to the next character
+# is accepted it gets eaten and we move to the next character
 @inline function accept(l::Parser, f::Union{Function, Char})::Bool
     c = peek(l)
     c == EOF_CHAR && return false
@@ -665,7 +665,7 @@ end
 #########
 
 function push!!(v::Vector, el)
-    # Since these types are typically non-inferrable, they are a big invalidation risk,
+    # Since these types are typically non-inferable, they are a big invalidation risk,
     # and since it's used by the package-loading infrastructure the cost of invalidation
     # is high. Therefore, this is written to reduce the "exposed surface area": e.g., rather
     # than writing `T[el]` we write it as `push!(Vector{T}(undef, 1), el)` so that there
diff --git a/base/version.jl b/base/version.jl
index a966135a071e2..730ae47a27363 100644
--- a/base/version.jl
+++ b/base/version.jl
@@ -11,7 +11,7 @@ const VInt = UInt32
 Version number type which follows the specifications of
 [semantic versioning (semver)](https://semver.org/), composed of major, minor
 and patch numeric values, followed by pre-release and build
-alpha-numeric annotations.
+alphanumeric annotations.
 
 `VersionNumber` objects can be compared with all of the standard comparison
 operators (`==`, `<`, `<=`, etc.), with the result following semver rules.
diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index 582e5410a4b3d..4ba93483730ac 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-# Prevent this from putting anyting into the Main namespace
+# Prevent this from putting anything into the Main namespace
 @eval Module() begin
 
 if Threads.maxthreadid() != 1
diff --git a/contrib/mac/frameworkapp/JuliaLauncher/AppDelegate.m b/contrib/mac/frameworkapp/JuliaLauncher/AppDelegate.m
index db2f13b485189..1d20d6ed3efa1 100644
--- a/contrib/mac/frameworkapp/JuliaLauncher/AppDelegate.m
+++ b/contrib/mac/frameworkapp/JuliaLauncher/AppDelegate.m
@@ -51,7 +51,7 @@ + (ExecSandboxController *)sharedController {
 
 @end
 
-/// Location of an installed variant of Julia (frameowrk or nix hier).
+/// Location of an installed variant of Julia (framework or nix hier).
 @interface JuliaVariant : NSObject
 @property(readonly, nullable) NSBundle *bundle;
 @property(readonly, nonnull) NSURL *juliaexe;
diff --git a/deps/valgrind/valgrind.h b/deps/valgrind/valgrind.h
index 2e07a49d91dfa..b33fd70fab672 100644
--- a/deps/valgrind/valgrind.h
+++ b/deps/valgrind/valgrind.h
@@ -1065,7 +1065,7 @@ typedef
 
 /* Use these to write the name of your wrapper.  NOTE: duplicates
    VG_WRAP_FUNCTION_Z{U,Z} in pub_tool_redir.h.  NOTE also: inserts
-   the default behaviour equivalance class tag "0000" into the name.
+   the default behaviour equivalence class tag "0000" into the name.
    See pub_tool_redir.h for details -- normally you don't need to
    think about this, though. */
 
diff --git a/doc/src/base/scopedvalues.md b/doc/src/base/scopedvalues.md
index 5c3318259ca55..0de29308c5df8 100644
--- a/doc/src/base/scopedvalues.md
+++ b/doc/src/base/scopedvalues.md
@@ -140,7 +140,7 @@ end
 
 @sync begin
     # If we instead pass a unique dictionary to each
-    # task we can access the dictonaries race free.
+    # task we can access the dictionaries race free.
     with(sval_dict => Dict()) do
         @spawn (sval_dict[][:a] = 3)
     end
@@ -166,7 +166,7 @@ const LEVEL = ScopedValue(:GUEST)
 function serve(request, response)
     level = isAdmin(request) ? :ADMIN : :GUEST
     with(LEVEL => level) do
-        Threads.@spawn handle(request, respone)
+        Threads.@spawn handle(request, response)
     end
 end
 
@@ -194,7 +194,7 @@ const sval_dict = ScopedValue(Dict())
 
 # If you want to add new values to the dict, instead of replacing
 # it, unshare the values explicitly. In this example we use `merge`
-# to unshare the state of the dictonary in parent scope.
+# to unshare the state of the dictionary in parent scope.
 @sync begin
     with(sval_dict => merge(sval_dict[], Dict(:a => 10))) do
         @spawn @show sval_dict[][:a]
diff --git a/doc/src/devdocs/pkgimg.md b/doc/src/devdocs/pkgimg.md
index 0e2cffd91a26f..64f4e640b7c19 100644
--- a/doc/src/devdocs/pkgimg.md
+++ b/doc/src/devdocs/pkgimg.md
@@ -33,7 +33,7 @@ Dynamic libraries on macOS need to link against `-lSystem`. On recent macOS vers
 To that effect we link with `-undefined dynamic_lookup`.
 
 ## [Package images optimized for multiple microarchitectures](@id pkgimgs-multi-versioning)
-Similar to [multi-versioning](@ref sysimg-multi-versioning) for system images, package images support multi-versioning. If you are in a heterogenous environment, with a unified cache,
+Similar to [multi-versioning](@ref sysimg-multi-versioning) for system images, package images support multi-versioning. If you are in a heterogeneous environment, with a unified cache,
 you can set the environment variable `JULIA_CPU_TARGET=generic` to multi-version the object caches.
 
 ## Flags that impact package image creation and selection
diff --git a/doc/src/index.md b/doc/src/index.md
index bb758d14b4cf2..8c88af424e8e3 100644
--- a/doc/src/index.md
+++ b/doc/src/index.md
@@ -34,7 +34,7 @@ Markdown.parse("""
 
 ## [Important Links](@id man-important-links)
 
-Below is a non-exhasutive list of links that will be useful as you learn and use the Julia programming language.
+Below is a non-exhaustive list of links that will be useful as you learn and use the Julia programming language.
 
 - [Julia Homepage](https://julialang.org)
 - [Download Julia](https://julialang.org/downloads/)
diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index 7427cfc4a950a..c69d221a80f2e 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -104,7 +104,7 @@ $
 ```
 
 However, note that the current best practice recommendation is to not mix application and reusable library
-code in the same package. Helper applications may be distributed as separate pacakges or as scripts with
+code in the same package. Helper applications may be distributed as separate packages or as scripts with
 separate `main` entry points in a package's `bin` folder.
 
 ## Parallel mode
diff --git a/doc/src/manual/modules.md b/doc/src/manual/modules.md
index 6ed8e3c8bc8e0..b329dbc91b923 100644
--- a/doc/src/manual/modules.md
+++ b/doc/src/manual/modules.md
@@ -106,7 +106,7 @@ modules. We will see how to manage name clashes below.
 
 To mark a name as public without exporting it into the namespace of folks who call `using NiceStuff`,
 one can use `public` instead of `export`. This marks the public name(s) as part of the public API,
-but does not have any namespace implications. The `public` keyword is only availiable in Julia 1.11
+but does not have any namespace implications. The `public` keyword is only available in Julia 1.11
 and above. To maintain compatibility with Julia 1.10 and below, use the `@compat` macro from the
 [Compat](https://github.com/JuliaLang/Compat.jl) package.
 
diff --git a/doc/src/manual/noteworthy-differences.md b/doc/src/manual/noteworthy-differences.md
index 6c55bee59cadf..12dc4fdfddd24 100644
--- a/doc/src/manual/noteworthy-differences.md
+++ b/doc/src/manual/noteworthy-differences.md
@@ -392,7 +392,7 @@ For users coming to Julia from R, these are some noteworthy differences:
     paths to the `Base.LOAD_PATH` array.
     * Packages from directory-based repositories do not require the `Pkg.add()` tool prior to
       being loaded with `import` or `using`. They are simply available to the project.
-    * Directory-based package repositories are the **quickest solution** to developping local
+    * Directory-based package repositories are the **quickest solution** to developing local
       libraries of "software modules".
 
 ### Julia &hArr; C/C++: Assembling modules
diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md
index fca4fc75d9e0f..9c4fde5b8a701 100644
--- a/doc/src/manual/strings.md
+++ b/doc/src/manual/strings.md
@@ -1144,7 +1144,7 @@ Version numbers can easily be expressed with non-standard string literals of the
 Version number literals create [`VersionNumber`](@ref) objects which follow the
 specifications of [semantic versioning](https://semver.org/),
 and therefore are composed of major, minor and patch numeric values, followed by pre-release and
-build alpha-numeric annotations. For example, `v"0.2.1-rc1+win64"` is broken into major version
+build alphanumeric annotations. For example, `v"0.2.1-rc1+win64"` is broken into major version
 `0`, minor version `2`, patch version `1`, pre-release `rc1` and build `win64`. When entering
 a version literal, everything except the major version number is optional, therefore e.g.  `v"0.2"`
 is equivalent to `v"0.2.0"` (with empty pre-release/build annotations), `v"2"` is equivalent to
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index ae9ebca7a8b7a..fab53fa4de14c 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1124,7 +1124,7 @@ static auto serializeModule(const Module &M) {
 // Modules are deserialized lazily by LLVM, to avoid deserializing
 // unnecessary functions. We take advantage of this by serializing
 // the entire module once, then deleting the bodies of functions
-// that are not in this partition. Once unnecesary functions are
+// that are not in this partition. Once unnecessary functions are
 // deleted, we then materialize the entire module to make use-lists
 // consistent.
 static void materializePreserved(Module &M, Partition &partition) {
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 63f5e2be5ddbb..f086c7fd0b0bd 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -3167,7 +3167,7 @@ static jl_value_t *static_constant_instance(const llvm::DataLayout &DL, Constant
     if (const auto *CC = dyn_cast<ConstantAggregate>(constant))
         nargs = CC->getNumOperands();
     else if (const auto *CAZ = dyn_cast<ConstantAggregateZero>(constant)) {
-        // SVE: Elsewhere we use `getMinKownValue`
+        // SVE: Elsewhere we use `getMinKnownValue`
         nargs = CAZ->getElementCount().getFixedValue();
     }
     else if (const auto *CDS = dyn_cast<ConstantDataSequential>(constant))
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 402924c4b778b..33730ad9cf74b 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -6354,7 +6354,7 @@ static Function* gen_cfun_wrapper(
                 BasicBlock *unboxedBB = BasicBlock::Create(ctx.builder.getContext(), "maybe-unboxed", cw);
                 BasicBlock *isanyBB = BasicBlock::Create(ctx.builder.getContext(), "any", cw);
                 BasicBlock *afterBB = BasicBlock::Create(ctx.builder.getContext(), "after", cw);
-                Value *isrtboxed = ctx.builder.CreateIsNull(val); // XXX: this is the wrong condition and should be inspecting runtime_dt intead
+                Value *isrtboxed = ctx.builder.CreateIsNull(val); // XXX: this is the wrong condition and should be inspecting runtime_dt instead
                 ctx.builder.CreateCondBr(isrtboxed, boxedBB, loadBB);
                 ctx.builder.SetInsertPoint(boxedBB);
                 Value *p1 = ctx.builder.CreateBitCast(val, ctx.types().T_pjlvalue);
diff --git a/src/flisp/read.c b/src/flisp/read.c
index 9a480e0536c7a..7a6039323a988 100644
--- a/src/flisp/read.c
+++ b/src/flisp/read.c
@@ -303,7 +303,7 @@ static uint32_t peek(fl_context_t *fl_ctx)
             fl_ctx->readtokval = fixnum(x);
         }
         else if (c == '!') {
-            // #! single line comment for shbang script support
+            // #! single line comment for shebang script support
             do {
                 ch = ios_getc(readF(fl_ctx));
             } while (ch != IOS_EOF && (char)ch != '\n');
diff --git a/src/gc-heap-snapshot.cpp b/src/gc-heap-snapshot.cpp
index 51bc5ab61610e..1875a22f64ff6 100644
--- a/src/gc-heap-snapshot.cpp
+++ b/src/gc-heap-snapshot.cpp
@@ -71,7 +71,7 @@ struct Node {
     size_t id; // This should be a globally-unique counter, but we use the memory address
     size_t self_size;
     size_t trace_node_id;  // This is ALWAYS 0 in Javascript heap-snapshots.
-    // whether the from_node is attached or dettached from the main application state
+    // whether the from_node is attached or detached from the main application state
     // https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/include/v8-profiler.h#L739-L745
     int detachedness;  // 0 - unknown, 1 - attached, 2 - detached
     SmallVector<Edge, 0> edges;
diff --git a/src/gc.c b/src/gc.c
index 42a9daa01a747..b030be9848f0b 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -2811,7 +2811,7 @@ void gc_drain_own_chunkqueue(jl_ptls_t ptls, jl_gc_markqueue_t *mq)
 }
 
 // Main mark loop. Stack (allocated on the heap) of `jl_value_t *`
-// is used to keep track of processed items. Maintaning this stack (instead of
+// is used to keep track of processed items. Maintaining this stack (instead of
 // native one) avoids stack overflow when marking deep objects and
 // makes it easier to implement parallel marking via work-stealing
 JL_EXTENSION NOINLINE void gc_mark_loop_serial(jl_ptls_t ptls)
@@ -2846,7 +2846,7 @@ void gc_mark_and_steal(jl_ptls_t ptls)
         goto pop;
     }
     // Note that for the stealing heuristics, we try to
-    // steal chunks much more agressively than pointers,
+    // steal chunks much more aggressively than pointers,
     // since we know chunks will likely expand into a lot
     // of work for the mark loop
     steal : {
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index e8a7c0f333c12..57eacd141744a 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -1197,7 +1197,7 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
     for (size_t i = 0; i < nargs; ++i) {
         jl_cgval_t arg = emit_expr(ctx, args[i + 1]);
         if (arg.typ == jl_bottom_type) {
-            // intrinsics generally don't handle buttom values, so bail out early
+            // intrinsics generally don't handle bottom values, so bail out early
             return jl_cgval_t();
         }
         argv[i] = arg;
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 62d1a8612ce60..42239ecf2de3c 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -794,7 +794,7 @@ struct JITObjectInfo {
 class JLDebuginfoPlugin : public ObjectLinkingLayer::Plugin {
     std::mutex PluginMutex;
     std::map<MaterializationResponsibility *, std::unique_ptr<JITObjectInfo>> PendingObjs;
-    // Resources from distinct MaterializationResponsibilitys can get merged
+    // Resources from distinct `MaterializationResponsibility`s can get merged
     // after emission, so we can have multiple debug objects per resource key.
     std::map<ResourceKey, SmallVector<std::unique_ptr<JITObjectInfo>, 0>> RegisteredObjs;
 
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 7883844d908f8..204674c6d495a 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -211,13 +211,13 @@ void jl_unlock_stackwalk(int lockret) JL_NOTSAFEPOINT JL_NOTSAFEPOINT_LEAVE;
 static inline uint64_t cycleclock(void) JL_NOTSAFEPOINT
 {
 #if defined(_CPU_X86_64_)
-    // This is nopl 0(%rax, %rax, 1), but assembler are incosistent about whether
+    // This is nopl 0(%rax, %rax, 1), but assembler are inconsistent about whether
     // they emit that as a 4 or 5 byte sequence and we need to be guaranteed to use
     // the 5 byte one.
 #define NOP5_OVERRIDE_NOP ".byte 0x0f, 0x1f, 0x44, 0x00, 0x00\n\t"
     uint64_t low, high;
     // This instruction sequence is promised by rr to be patchable. rr can usually
-    // also patch `rdtsc` in regular code, but without the preceeding nop, there could
+    // also patch `rdtsc` in regular code, but without the preceding nop, there could
     // be an interfering branch into the middle of rr's patch region. Using this
     // sequence prevents a massive rr-induced slowdown if the compiler happens to emit
     // an unlucky pattern. See https://github.com/rr-debugger/rr/pull/3580.
diff --git a/src/llvm-alloc-helpers.cpp b/src/llvm-alloc-helpers.cpp
index d24c08b4b4930..665c0b1d2e00e 100644
--- a/src/llvm-alloc-helpers.cpp
+++ b/src/llvm-alloc-helpers.cpp
@@ -325,7 +325,7 @@ void jl_alloc::runEscapeAnalysis(llvm::Instruction *I, EscapeAnalysisRequiredArg
                 else {
                     next_offset = apoffset.getLimitedValue();
                     if (next_offset > UINT32_MAX) {
-                        LLVM_DEBUG(dbgs() << "GEP inst exceeeds 32-bit offset\n");
+                        LLVM_DEBUG(dbgs() << "GEP inst exceeds 32-bit offset\n");
                         next_offset = UINT32_MAX;
                     }
                 }
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index fa666ad464cda..10b2209945081 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -140,7 +140,7 @@ using namespace llvm;
       not sunk into the gc frame. Nevertheless performing such sinking can still
       be profitable. Since all arguments to a jlcall are guaranteed to be live
       at that call in some gc slot, we can attempt to rearrange the slots within
-      the gc-frame, or re-use slots not assigned at that particular location
+      the gc-frame, or reuse slots not assigned at that particular location
       for the gcframe. However, even without this optimization, stack frames
       are at most two times larger than optimal (because regular stack coloring
       can merge the jlcall allocas).
@@ -2117,7 +2117,7 @@ struct PEOIterator {
         }
         if (NextElement == -1)
             return NextElement;
-        // Make sure not to try to re-use this later.
+        // Make sure not to try to reuse this later.
         Elements[NextElement].weight = (unsigned)-1;
         // Raise neighbors
         for (int Neighbor : Neighbors[NextElement]) {
@@ -2395,7 +2395,7 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S, bool *CFGModified) {
                 // Now, finally, set the tag. We do this in IR instead of in the C alloc
                 // function, to provide possible optimization opportunities. (I think? TBH
                 // the most recent editor of this code is not entirely clear on why we
-                // prefer to set the tag in the generated code. Providing optimziation
+                // prefer to set the tag in the generated code. Providing optimization
                 // opportunities is the most likely reason; the tradeoff is slightly
                 // larger code size and increased compilation time, compiling this
                 // instruction at every allocation site, rather than once in the C alloc
diff --git a/src/llvm-lower-handlers.cpp b/src/llvm-lower-handlers.cpp
index 2e2b5955fcf67..15866d0855fc1 100644
--- a/src/llvm-lower-handlers.cpp
+++ b/src/llvm-lower-handlers.cpp
@@ -60,7 +60,7 @@ using namespace llvm;
  *                 \                 /
  *              br i1 %cond, %left2, %right2
  *                 /                 \
- *           jl_pop_hander          ret
+ *           jl_pop_handler          ret
  *           ret
  *
  *    The frontend doesn't emit structures like this. However, the optimizer
diff --git a/src/signal-handling.c b/src/signal-handling.c
index 284ad359f3799..6c2702a5604d6 100644
--- a/src/signal-handling.c
+++ b/src/signal-handling.c
@@ -429,7 +429,7 @@ void jl_task_frame_noreturn(jl_task_t *ct) JL_NOTSAFEPOINT
         ct->ptls->in_pure_callback = 0;
         ct->ptls->in_finalizer = 0;
         ct->ptls->defer_signal = 0;
-        jl_atomic_store_release(&ct->ptls->gc_state, 0); // forceably exit GC (if we were in it) or safe into unsafe, without the mandatory safepoint
+        jl_atomic_store_release(&ct->ptls->gc_state, 0); // forcibly exit GC (if we were in it) or safe into unsafe, without the mandatory safepoint
     }
 }
 
diff --git a/src/stackwalk.c b/src/stackwalk.c
index 1289e7d08657e..dc963094853d2 100644
--- a/src/stackwalk.c
+++ b/src/stackwalk.c
@@ -1022,7 +1022,7 @@ static void jl_rec_backtrace(jl_task_t *t) JL_NOTSAFEPOINT
         mc->__r14 = ((uint64_t*)mctx)[5];
         mc->__r15 = ((uint64_t*)mctx)[6];
         mc->__rip = ((uint64_t*)mctx)[7];
-        // added in libsystem_plaform 177.200.16 (macOS Mojave 10.14.3)
+        // added in libsystem_platform 177.200.16 (macOS Mojave 10.14.3)
         // prior to that _os_ptr_munge_token was (hopefully) typically 0,
         // so x ^ 0 == x and this is a no-op
         mc->__rbp = _OS_PTR_UNMUNGE(mc->__rbp);
diff --git a/src/subtype.c b/src/subtype.c
index d8177f0fd21ff..766e0e703f480 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -2810,9 +2810,9 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
 
     // I. Handle indirect innervars (make them behave like direct innervars).
     //   1) record if btemp->lb/ub has indirect innervars.
-    //   2) subtitute `vb->var` with `varval`/`varval`
+    //   2) substitute `vb->var` with `varval`/`varval`
     //   note: We only store the innervar in the outmost `varbinding`,
-    //       thus we must check all inner env to ensure the recording/subtitution
+    //       thus we must check all inner env to ensure the recording/substitution
     //       is complete
     int len = current_env_length(e);
     int8_t *blinding_has_innerdep = (int8_t *)alloca(len);
@@ -2852,9 +2852,9 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
                     }
                 }
                 if (!has_innerdep) continue;
-                int need_subtitution = 0;
+                int need_substitution = 0;
                 if (ilb != ivar->lb || iub != ivar->ub) {
-                    need_subtitution = 1;
+                    need_substitution = 1;
                     nivar = (jl_value_t *)jl_new_typevar(ivar->name, ilb, iub);
                     jl_array_ptr_set(btemp->innervars, i, nivar);
                     if (jl_has_typevar(res, ivar))
@@ -2863,12 +2863,12 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
                 int envind = 0;
                 for (jl_varbinding_t *btemp2 = e->vars; btemp2 != btemp->prev; btemp2 = btemp2->prev) {
                     if (jl_has_typevar(btemp2->lb, ivar)) {
-                        if (need_subtitution)
+                        if (need_substitution)
                             btemp2->lb = jl_substitute_var(btemp2->lb, ivar, nivar);
                         blinding_has_innerdep[envind] |= 1;
                     }
                     if (jl_has_typevar(btemp2->ub, ivar)) {
-                        if (need_subtitution)
+                        if (need_substitution)
                             btemp2->ub = jl_substitute_var(btemp2->ub, ivar, nivar);
                         blinding_has_innerdep[envind] |= 2;
                     }
@@ -3637,7 +3637,7 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
                 if (xlb == xub && ylb == yub &&
                     jl_has_typevar(xlb, (jl_tvar_t *)y) &&
                     jl_has_typevar(ylb, (jl_tvar_t *)x)) {
-                    // specical case for e.g.
+                    // special case for e.g.
                     // 1) Val{Y}<:X<:Val{Y} && Val{X}<:Y<:Val{X}
                     // 2) Y<:X<:Y && Val{X}<:Y<:Val{X} => Val{Y}<:Y<:Val{Y}
                     ccheck = 0;
diff --git a/stdlib/Dates/docs/src/index.md b/stdlib/Dates/docs/src/index.md
index aa46f7b827f10..5d3fe4fd50f00 100644
--- a/stdlib/Dates/docs/src/index.md
+++ b/stdlib/Dates/docs/src/index.md
@@ -343,12 +343,12 @@ First the mapping is loaded into the `LOCALES` variable:
 julia> french_months = ["janvier", "février", "mars", "avril", "mai", "juin",
                         "juillet", "août", "septembre", "octobre", "novembre", "décembre"];
 
-julia> french_monts_abbrev = ["janv","févr","mars","avril","mai","juin",
+julia> french_months_abbrev = ["janv","févr","mars","avril","mai","juin",
                               "juil","août","sept","oct","nov","déc"];
 
 julia> french_days = ["lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"];
 
-julia> Dates.LOCALES["french"] = Dates.DateLocale(french_months, french_monts_abbrev, french_days, [""]);
+julia> Dates.LOCALES["french"] = Dates.DateLocale(french_months, french_months_abbrev, french_days, [""]);
 ```
 
  The above mentioned functions can then be used to perform the queries:
diff --git a/stdlib/InteractiveUtils/test/highlighting.jl b/stdlib/InteractiveUtils/test/highlighting.jl
index bac52e2945b5e..b72c9dbe72795 100644
--- a/stdlib/InteractiveUtils/test/highlighting.jl
+++ b/stdlib/InteractiveUtils/test/highlighting.jl
@@ -72,7 +72,7 @@ end
     @test occursin("\e", String(take!(io)))
 end
 
-function hilight_llvm(s)
+function highlight_llvm(s)
     io = IOBuffer()
     InteractiveUtils.print_llvm(IOContext(io, :color=>true), s)
     r = String(take!(io))
@@ -82,7 +82,7 @@ function hilight_llvm(s)
     flush(stdout)
     r
 end
-function hilight_native(s, arch)
+function highlight_native(s, arch)
     io = IOBuffer()
     InteractiveUtils.print_native(IOContext(io, :color=>true), s, arch)
     r = String(take!(io))
@@ -92,8 +92,8 @@ function hilight_native(s, arch)
     flush(stdout)
     r
 end
-hilight_x86(s) = hilight_native(s, :x86)
-hilight_arm(s) = hilight_native(s, :arm)
+highlight_x86(s) = highlight_native(s, :x86)
+highlight_arm(s) = highlight_native(s, :arm)
 
 function esc_code(s)
     io = IOBuffer()
@@ -124,41 +124,41 @@ const XU = B * "}" * XB
 
 @testset "LLVM IR" begin
     @testset "comment" begin
-        @test hilight_llvm("; comment ; // # ") == "$(C); comment ; // # $(XC)\n"
+        @test highlight_llvm("; comment ; // # ") == "$(C); comment ; // # $(XC)\n"
     end
-    @testset "lavel" begin
-        @test hilight_llvm("top:") == "$(L)top:$(XL)\n"
+    @testset "label" begin
+        @test highlight_llvm("top:") == "$(L)top:$(XL)\n"
 
-        @test hilight_llvm("L7:\t\t; preds = %top") ==
+        @test highlight_llvm("L7:\t\t; preds = %top") ==
             "$(L)L7:$(XL)\t\t$(C); preds = %top$(XC)\n"
     end
     @testset "define" begin
-        @test hilight_llvm("define double @julia_func_1234(float) {") ==
+        @test highlight_llvm("define double @julia_func_1234(float) {") ==
             "$(K)define$(XK) $(T)double$(XT) " *
             "$(F)@julia_func_1234$(XF)$P$(T)float$(XT)$XP $U\n"
 
-        @test hilight_llvm("}") == "$XU\n"
+        @test highlight_llvm("}") == "$XU\n"
     end
 
     @testset "declare" begin
-        @test hilight_llvm("declare i32 @jl_setjmp(i8*) #2") ==
+        @test highlight_llvm("declare i32 @jl_setjmp(i8*) #2") ==
             "$(K)declare$(XK) $(T)i32$(XT) " *
             "$(F)@jl_setjmp$(XF)$P$(T)i8$(XT)$(D)*$(XD)$XP $(D)#2$(XD)\n"
     end
 
     @testset "type" begin
-        @test hilight_llvm("%jl_value_t = type opaque") ==
+        @test highlight_llvm("%jl_value_t = type opaque") ==
             "$(V)%jl_value_t$(XV) $EQU $(K)type$(XK) $(T)opaque$(XT)\n"
     end
 
     @testset "target" begin
         datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12:13"
-        @test hilight_llvm("target datalayout = \"$datalayout\"") ==
+        @test highlight_llvm("target datalayout = \"$datalayout\"") ==
             "$(K)target$(XK) $(K)datalayout$(XK) $EQU $(V)\"$datalayout\"$(XV)\n"
     end
 
     @testset "attributes" begin
-        @test hilight_llvm(
+        @test highlight_llvm(
             """attributes #1 = { uwtable "frame-pointer"="all" }""") ==
             "$(K)attributes$(XK) $(D)#1$(XD) $EQU " *
             "$U $(K)uwtable$(XK) $(V)\"frame-pointer\"$(XV)$EQU" *
@@ -166,57 +166,57 @@ const XU = B * "}" * XB
     end
 
     @testset "terminator" begin
-        @test hilight_llvm("  ret i8 %12") ==
+        @test highlight_llvm("  ret i8 %12") ==
             "  $(I)ret$(XI) $(T)i8$(XT) $(V)%12$(XV)\n"
 
-        @test hilight_llvm("  br i1 %2, label %L6, label %L4") ==
+        @test highlight_llvm("  br i1 %2, label %L6, label %L4") ==
             "  $(I)br$(XI) $(T)i1$(XT) $(V)%2$(XV)$COM " *
             "$(T)label$(XT) $(L)%L6$(XL)$COM $(T)label$(XT) $(L)%L4$(XL)\n"
 
-        @test hilight_llvm("  br label %L5") ==
+        @test highlight_llvm("  br label %L5") ==
             "  $(I)br$(XI) $(T)label$(XT) $(L)%L5$(XL)\n"
 
-        @test hilight_llvm("  unreachable") == "  $(I)unreachable$(XI)\n"
+        @test highlight_llvm("  unreachable") == "  $(I)unreachable$(XI)\n"
     end
 
     @testset "arithmetic" begin
-        @test hilight_llvm("   %11 = add nuw nsw i64 %value_phi10, 1") ==
+        @test highlight_llvm("   %11 = add nuw nsw i64 %value_phi10, 1") ==
             "   $(V)%11$(XV) $EQU $(I)add$(XI) $(K)nuw$(XK) $(K)nsw$(XK) " *
             "$(T)i64$(XT) $(V)%value_phi10$(XV)$COM $(N)1$(XN)\n"
 
-        @test hilight_llvm("   %13 = fadd double %12, -2.000000e+00") ==
+        @test highlight_llvm("   %13 = fadd double %12, -2.000000e+00") ==
             "   $(V)%13$(XV) $EQU $(I)fadd$(XI) " *
             "$(T)double$(XT) $(V)%12$(XV)$COM $(N)-2.000000e+00$(XN)\n"
 
-        @test hilight_llvm("      %21 = fmul contract double %20, 0x0123456789ABCDEF") ==
+        @test highlight_llvm("      %21 = fmul contract double %20, 0x0123456789ABCDEF") ==
             "      $(V)%21$(XV) $EQU $(I)fmul$(XI) $(K)contract$(XK) " *
             "$(T)double$(XT) $(V)%20$(XV)$COM $(N)0x0123456789ABCDEF$(XN)\n"
     end
 
     @testset "bitwise" begin
-        @test hilight_llvm("   %31 = shl i64 %value_phi4, 52") ==
+        @test highlight_llvm("   %31 = shl i64 %value_phi4, 52") ==
             "   $(V)%31$(XV) $EQU " *
             "$(I)shl$(XI) $(T)i64$(XT) $(V)%value_phi4$(XV)$COM $(N)52$(XN)\n"
     end
 
     @testset "aggregate" begin
-        @test hilight_llvm("    %4 = extractvalue { i64, i1 } %1, 0") ==
+        @test highlight_llvm("    %4 = extractvalue { i64, i1 } %1, 0") ==
             "    $(V)%4$(XV) $EQU $(I)extractvalue$(XI) " *
             "$U $(T)i64$(XT)$COM $(T)i1$(XT) $XU $(V)%1$(XV)$COM $(N)0$(XN)\n"
     end
 
     @testset "memory access" begin
-        @test hilight_llvm("  %dims = alloca [1 x i64], align 8") ==
+        @test highlight_llvm("  %dims = alloca [1 x i64], align 8") ==
             "  $(V)%dims$(XV) $EQU $(I)alloca$(XI) " *
             "$S$(N)1$(XN) $(D)x$(XD) $(T)i64$(XT)$XS$COM $(K)align$(XK) $(N)8$(XN)\n"
 
-        @test hilight_llvm("    %51 = load i32," *
+        @test highlight_llvm("    %51 = load i32," *
                            " i32* inttoptr (i64 226995504 to i32*), align 16") ==
             "    $(V)%51$(XV) $EQU $(I)load$(XI) $(T)i32$(XT)$COM " *
             "$(T)i32$(XT)$(D)*$(XD) $(K)inttoptr$(XK) $P$(T)i64$(XT) $(N)226995504$(XN) " *
             "$(K)to$(XK) $(T)i32$(XT)$(D)*$(XD)$XP$COM $(K)align$(XK) $(N)16$(XN)\n"
 
-        @test hilight_llvm("    %53 = load %jl_value_t addrspace(10)*, " *
+        @test highlight_llvm("    %53 = load %jl_value_t addrspace(10)*, " *
                            "%jl_value_t addrspace(10)* addrspace(11)* %52, align 8") ==
             "    $(V)%53$(XV) $EQU $(I)load$(XI) $(V)%jl_value_t$(XV) " *
             "$(K)addrspace$(XK)$P$(N)10$(XN)$XP$(D)*$(XD)$COM " *
@@ -224,37 +224,37 @@ const XU = B * "}" * XB
             "$(K)addrspace$(XK)$P$(N)11$(XN)$XP$(D)*$(XD) " *
             "$(V)%52$(XV)$COM $(K)align$(XK) $(N)8$(XN)\n"
 
-        @test hilight_llvm("    store i64 %61, i64 addrspace(11)* %60, align 8") ==
+        @test highlight_llvm("    store i64 %61, i64 addrspace(11)* %60, align 8") ==
             "    $(I)store$(XI) $(T)i64$(XT) $(V)%61$(XV)$COM " *
             "$(T)i64$(XT) $(K)addrspace$(XK)$P$(N)11$(XN)$XP$(D)*$(XD) " *
             "$(V)%60$(XV)$COM $(K)align$(XK) $(N)8$(XN)\n"
 
-        @test hilight_llvm("  store volatile %jl_value_t addrspace(10)** %62, " *
+        @test highlight_llvm("  store volatile %jl_value_t addrspace(10)** %62, " *
                            "%jl_value_t addrspace(10)*** %63, align 8") ==
             "  $(I)store$(XI) $(K)volatile$(XK) $(V)%jl_value_t$(XV) " *
             "$(K)addrspace$(XK)$P$(N)10$(XN)$XP$(D)**$(XD) $(V)%62$(XV)$COM " *
             "$(V)%jl_value_t$(XV) $(K)addrspace$(XK)$P$(N)10$(XN)$XP$(D)***$(XD) " *
             "$(V)%63$(XV)$COM $(K)align$(XK) $(N)8$(XN)\n"
 
-        @test hilight_llvm("     %71 = getelementptr i8, i8* %70, i64 8") ==
+        @test highlight_llvm("     %71 = getelementptr i8, i8* %70, i64 8") ==
             "     $(V)%71$(XV) $EQU $(I)getelementptr$(XI) $(T)i8$(XT)$COM " *
             "$(T)i8$(XT)$(D)*$(XD) $(V)%70$(XV)$COM $(T)i64$(XT) $(N)8$(XN)\n"
     end
 
     @testset "conversion" begin
-        @test hilight_llvm("  %22 = zext i1 %21 to i8") ==
+        @test highlight_llvm("  %22 = zext i1 %21 to i8") ==
             "  $(V)%22$(XV) $EQU $(I)zext$(XI) $(T)i1$(XT) $(V)%21$(XV) " *
             "$(K)to$(XK) $(T)i8$(XT)\n"
 
-        @test hilight_llvm("     %24 = sitofp i64 %23 to double") ==
+        @test highlight_llvm("     %24 = sitofp i64 %23 to double") ==
             "     $(V)%24$(XV) $EQU $(I)sitofp$(XI) $(T)i64$(XT) $(V)%23$(XV) " *
             "$(K)to$(XK) $(T)double$(XT)\n"
 
-        @test hilight_llvm("  %26 = ptrtoint i8* %25 to i64") ==
+        @test highlight_llvm("  %26 = ptrtoint i8* %25 to i64") ==
             "  $(V)%26$(XV) $EQU $(I)ptrtoint$(XI) $(T)i8$(XT)$(D)*$(XD) " *
             "$(V)%25$(XV) $(K)to$(XK) $(T)i64$(XT)\n"
 
-        @test hilight_llvm("  %28 = bitcast %jl_value_t addrspace(10)* %27 " *
+        @test highlight_llvm("  %28 = bitcast %jl_value_t addrspace(10)* %27 " *
                            "to [2 x i16] addrspace(10)*") ==
             "  $(V)%28$(XV) $EQU $(I)bitcast$(XI) $(V)%jl_value_t$(XV) " *
             "$(K)addrspace$(XK)$P$(N)10$(XN)$XP$(D)*$(XD) $(V)%27$(XV) " *
@@ -263,20 +263,20 @@ const XU = B * "}" * XB
     end
 
     @testset "other" begin
-        @test hilight_llvm("  %31 = icmp slt i64 %30, 0") ==
+        @test highlight_llvm("  %31 = icmp slt i64 %30, 0") ==
             "  $(V)%31$(XV) $EQU $(I)icmp$(XI) $(I)slt$(XI) " *
             "$(T)i64$(XT) $(V)%30$(XV)$COM $(N)0$(XN)\n"
 
-        @test hilight_llvm("  %value_phi34 = phi double [ %33, %L50 ], [ %32, %L60 ]") ==
+        @test highlight_llvm("  %value_phi34 = phi double [ %33, %L50 ], [ %32, %L60 ]") ==
             "  $(V)%value_phi34$(XV) $EQU $(I)phi$(XI) $(T)double$(XT) " *
             "$S $(V)%33$(XV)$COM $(L)%L50$(XL) $XS$COM " *
             "$S $(V)%32$(XV)$COM $(L)%L60$(XL) $XS\n"
 
-        @test hilight_llvm("   %.v = select i1 %35, i64 %36, i64 63") ==
+        @test highlight_llvm("   %.v = select i1 %35, i64 %36, i64 63") ==
             "   $(V)%.v$(XV) $EQU $(I)select$(XI) $(T)i1$(XT) $(V)%35$(XV)$COM " *
             "$(T)i64$(XT) $(V)%36$(XV)$COM $(T)i64$(XT) $(N)63$(XN)\n"
 
-        @test hilight_llvm("   %38 = call i64 @llvm.cttz.i64(i64 %37, i1 false)") ==
+        @test highlight_llvm("   %38 = call i64 @llvm.cttz.i64(i64 %37, i1 false)") ==
             "   $(V)%38$(XV) $EQU $(I)call$(XI) $(T)i64$(XT) " *
             "$(F)@llvm.cttz.i64$(XF)$P$(T)i64$(XT) $(V)%37$(XV)$COM " *
             "$(T)i1$(XT) $(K)false$(XK)$XP\n"
@@ -285,133 +285,133 @@ end
 
 @testset "x86 ASM" begin
     @testset "comment" begin
-        @test hilight_x86("; comment ; // # ") == "$(C); comment ; // # $(XC)\n"
+        @test highlight_x86("; comment ; // # ") == "$(C); comment ; // # $(XC)\n"
     end
     @testset "label" begin
-        @test hilight_x86("L123:") == "$(L)L123:$(XL)\n"
+        @test highlight_x86("L123:") == "$(L)L123:$(XL)\n"
     end
     @testset "directive" begin
-        @test hilight_x86("\t.text") == "\t$(D).text$(XD)\n"
+        @test highlight_x86("\t.text") == "\t$(D).text$(XD)\n"
     end
 
     @testset "0-operand" begin
         # AT&T
-        @test hilight_x86("\tretq") == "\t$(I)retq$(XI)\n"
+        @test highlight_x86("\tretq") == "\t$(I)retq$(XI)\n"
 
         # Intel
-        @test hilight_x86("\tret") == "\t$(I)ret$(XI)\n"
+        @test highlight_x86("\tret") == "\t$(I)ret$(XI)\n"
     end
     @testset "1-operand" begin
         # AT&T
-        @test hilight_x86("\tpopq\t%rax") == "\t$(I)popq$(XI)\t$(V)%rax$(XV)\n"
+        @test highlight_x86("\tpopq\t%rax") == "\t$(I)popq$(XI)\t$(V)%rax$(XV)\n"
 
-        @test hilight_x86("\tpushl\t\$4294967295\t# imm = 0xFFFFFFFF") ==
+        @test highlight_x86("\tpushl\t\$4294967295\t# imm = 0xFFFFFFFF") ==
             "\t$(I)pushl$(XI)\t$(N)\$4294967295$(XN)\t$(C)# imm = 0xFFFFFFFF$(XC)\n"
 
-        @test hilight_x86("\tja\tL234") == "\t$(I)ja$(XI)\t$(L)L234$(XL)\n"
+        @test highlight_x86("\tja\tL234") == "\t$(I)ja$(XI)\t$(L)L234$(XL)\n"
 
-        @test hilight_x86("\tnopw\t%cs:(%rax,%rax)") ==
+        @test highlight_x86("\tnopw\t%cs:(%rax,%rax)") ==
             "\t$(I)nopw$(XI)\t$(V)%cs$(XV)$COL$P$(V)%rax$(XV)$COM$(V)%rax$(XV)$XP\n"
 
         # Intel
-        @test hilight_x86("\tpop\trax") == "\t$(I)pop$(XI)\t$(V)rax$(XV)\n"
+        @test highlight_x86("\tpop\trax") == "\t$(I)pop$(XI)\t$(V)rax$(XV)\n"
 
-        @test hilight_x86("\tpush\t4294967295") ==
+        @test highlight_x86("\tpush\t4294967295") ==
             "\t$(I)push$(XI)\t$(N)4294967295$(XN)\n"
 
-        @test hilight_x86("\tja\tL234") == "\t$(I)ja$(XI)\t$(L)L234$(XL)\n"
+        @test highlight_x86("\tja\tL234") == "\t$(I)ja$(XI)\t$(L)L234$(XL)\n"
 
-        @test hilight_x86("\tnop\tword ptr cs:[rax + rax]") ==
+        @test highlight_x86("\tnop\tword ptr cs:[rax + rax]") ==
             "\t$(I)nop$(XI)\t$(K)word$(XK) $(K)ptr$(XK) " *
             "$(V)cs$(XV)$COL$S$(V)rax$(XV) $(D)+$(XD) $(V)rax$(XV)$XS\n"
     end
     @testset "2-operand" begin
         # AT&T
-        @test hilight_x86("\tshrq\t\$63, %rcx") ==
+        @test highlight_x86("\tshrq\t\$63, %rcx") ==
             "\t$(I)shrq$(XI)\t$(N)\$63$(XN)$COM $(V)%rcx$(XV)\n"
 
-        @test hilight_x86("\tvmovsd\t(%rsi,%rdx,8), %xmm1\t# xmm1 = mem[0],zero") ==
+        @test highlight_x86("\tvmovsd\t(%rsi,%rdx,8), %xmm1\t# xmm1 = mem[0],zero") ==
             "\t$(I)vmovsd$(XI)\t$P$(V)%rsi$(XV)$COM$(V)%rdx$(XV)$COM$(N)8$(XN)$XP" *
             "$COM $(V)%xmm1$(XV)\t$(C)# xmm1 = mem[0],zero$(XC)\n"
 
-        @test hilight_x86("\tmovabsq\t\$\"#string#338\", %rax") ==
+        @test highlight_x86("\tmovabsq\t\$\"#string#338\", %rax") ==
             "\t$(I)movabsq$(XI)\t$(F)\$\"#string#338\"$(XF)$COM $(V)%rax$(XV)\n"
 
         # Intel
-        @test hilight_x86("\tshr\trcx, 63") ==
+        @test highlight_x86("\tshr\trcx, 63") ==
             "\t$(I)shr$(XI)\t$(V)rcx$(XV)$COM $(N)63$(XN)\n"
 
-        @test hilight_x86(
+        @test highlight_x86(
             "\tvmovsd\txmm1, dword ptr [rsi + 8*rdx]\t# xmm1 = mem[0],zero") ==
             "\t$(I)vmovsd$(XI)\t$(V)xmm1$(XV)$COM $(K)dword$(XK) $(K)ptr$(XK) " *
             "$S$(V)rsi$(XV) $(D)+$(XD) $(N)8$(XN)$(D)*$(XD)$(V)rdx$(XV)$XS" *
             "\t$(C)# xmm1 = mem[0],zero$(XC)\n"
 
-        @test hilight_x86("\tmovabs\trax, offset \"#string#338\"") ==
+        @test highlight_x86("\tmovabs\trax, offset \"#string#338\"") ==
             "\t$(I)movabs$(XI)\t$(V)rax$(XV)$COM " *
             "$(K)offset$(XK) $(F)\"#string#338\"$(XF)\n"
     end
     @testset "3-operand" begin
         # AT&T
-        @test hilight_x86("\tvaddsd\t(%rax), %xmm0, %xmm0") ==
+        @test highlight_x86("\tvaddsd\t(%rax), %xmm0, %xmm0") ==
             "\t$(I)vaddsd$(XI)\t$P$(V)%rax$(XV)$XP$COM " *
             "$(V)%xmm0$(XV)$COM $(V)%xmm0$(XV)\n"
 
         # Intel
-        @test hilight_x86("\tvaddsd\txmm0, xmm0, qword ptr [rax]") ==
+        @test highlight_x86("\tvaddsd\txmm0, xmm0, qword ptr [rax]") ==
             "\t$(I)vaddsd$(XI)\t$(V)xmm0$(XV)$COM $(V)xmm0$(XV)$COM " *
             "$(K)qword$(XK) $(K)ptr$(XK) $S$(V)rax$(XV)$XS\n"
     end
     @testset "4-operand" begin
         # AT&T
-        @test hilight_x86("\tvroundsd\t\$4, %xmm1, %xmm1, %xmm1") ==
+        @test highlight_x86("\tvroundsd\t\$4, %xmm1, %xmm1, %xmm1") ==
             "\t$(I)vroundsd$(XI)\t$(N)\$4$(XN)$COM " *
             "$(V)%xmm1$(XV)$COM $(V)%xmm1$(XV)$COM $(V)%xmm1$(XV)\n"
 
         # Intel
-        @test hilight_x86("\tvroundsd\txmm1, xmm1, xmm1, 4") ==
+        @test highlight_x86("\tvroundsd\txmm1, xmm1, xmm1, 4") ==
             "\t$(I)vroundsd$(XI)\t" *
             "$(V)xmm1$(XV)$COM $(V)xmm1$(XV)$COM $(V)xmm1$(XV)$COM $(N)4$(XN)\n"
     end
     @testset "AVX-512" begin
         # AT&T
-        @test hilight_x86("\tvmovaps\t(%eax), %zmm0") ==
+        @test highlight_x86("\tvmovaps\t(%eax), %zmm0") ==
             "\t$(I)vmovaps$(XI)\t$P$(V)%eax$(XV)$XP$COM $(V)%zmm0$(XV)\n"
 
-        @test hilight_x86("\tvpaddd\t%zmm3, %zmm1, %zmm1 {%k1}") ==
+        @test highlight_x86("\tvpaddd\t%zmm3, %zmm1, %zmm1 {%k1}") ==
             "\t$(I)vpaddd$(XI)\t$(V)%zmm3$(XV)$COM $(V)%zmm1$(XV)$COM " *
             "$(V)%zmm1$(XV) $U$(V)%k1$(XV)$XU\n"
 
-        @test hilight_x86("\tvdivpd\t%zmm3, %zmm1, %zmm0 {%k1} {z}") ==
+        @test highlight_x86("\tvdivpd\t%zmm3, %zmm1, %zmm0 {%k1} {z}") ==
             "\t$(I)vdivpd$(XI)\t$(V)%zmm3$(XV)$COM $(V)%zmm1$(XV)$COM " *
             "$(V)%zmm0$(XV) $U$(V)%k1$(XV)$XU $U$(K)z$(XK)$XU\n"
 
-        @test hilight_x86("\tvdivps\t(%ebx){1to16}, %zmm5, %zmm4") ==
+        @test highlight_x86("\tvdivps\t(%ebx){1to16}, %zmm5, %zmm4") ==
             "\t$(I)vdivps$(XI)\t$P$(V)%ebx$(XV)$XP$U$(K)1to16$(XK)$XU$COM " *
             "$(V)%zmm5$(XV)$COM $(V)%zmm4$(XV)\n"
 
-        @test hilight_x86("\tvcvtsd2si\t{rn-sae}, %xmm0, %eax") ==
+        @test highlight_x86("\tvcvtsd2si\t{rn-sae}, %xmm0, %eax") ==
             "\t$(I)vcvtsd2si$(XI)\t$U$(K)rn-sae$(XK)$XU$COM " *
             "$(V)%xmm0$(XV)$COM $(V)%eax$(XV)\n"
 
         # Intel
-        @test hilight_x86("\tvmovaps\tzmm0, zmmword ptr [eax]") ==
+        @test highlight_x86("\tvmovaps\tzmm0, zmmword ptr [eax]") ==
             "\t$(I)vmovaps$(XI)\t$(V)zmm0$(XV)$COM " *
             "$(K)zmmword$(XK) $(K)ptr$(XK) $S$(V)eax$(XV)$XS\n"
 
-        @test hilight_x86("\tvpaddd\tzmm1 {k1}, zmm1, zmm3") ==
+        @test highlight_x86("\tvpaddd\tzmm1 {k1}, zmm1, zmm3") ==
             "\t$(I)vpaddd$(XI)\t$(V)zmm1$(XV) $U$(V)k1$(XV)$XU$COM " *
             "$(V)zmm1$(XV)$COM $(V)zmm3$(XV)\n"
 
-        @test hilight_x86("\tvdivpd\tzmm0 {k1} {z}, zmm1, zmm3") ==
+        @test highlight_x86("\tvdivpd\tzmm0 {k1} {z}, zmm1, zmm3") ==
             "\t$(I)vdivpd$(XI)\t$(V)zmm0$(XV) $U$(V)k1$(XV)$XU $U$(K)z$(XK)$XU$COM " *
             "$(V)zmm1$(XV)$COM $(V)zmm3$(XV)\n"
 
-        @test hilight_x86("\tvdivps\tzmm4, zmm5, dword ptr [ebx]{1to16}") ==
+        @test highlight_x86("\tvdivps\tzmm4, zmm5, dword ptr [ebx]{1to16}") ==
             "\t$(I)vdivps$(XI)\t$(V)zmm4$(XV)$COM $(V)zmm5$(XV)$COM " *
             "$(K)dword$(XK) $(K)ptr$(XK) $S$(V)ebx$(XV)$XS$U$(K)1to16$(XK)$XU\n"
 
-        @test hilight_x86("\tvcvtsd2si\teax, xmm0$(XV), {rn-sae}") ==
+        @test highlight_x86("\tvcvtsd2si\teax, xmm0$(XV), {rn-sae}") ==
             "\t$(I)vcvtsd2si$(XI)\t$(V)eax$(XV)$COM " *
             "$(V)xmm0$(XV)$COM $U$(K)rn-sae$(XK)$XU\n"
     end
@@ -419,74 +419,74 @@ end
 
 @testset "ARM ASM" begin
     @testset "comment" begin
-        @test hilight_arm("; comment ; // # ") == "$(C); comment ; // # $(XC)\n"
+        @test highlight_arm("; comment ; // # ") == "$(C); comment ; // # $(XC)\n"
     end
     @testset "label" begin
-        @test hilight_arm("L45:") == "$(L)L45:$(XL)\n"
+        @test highlight_arm("L45:") == "$(L)L45:$(XL)\n"
     end
     @testset "directive" begin
-        @test hilight_arm("\t.text") == "\t$(D).text$(XD)\n"
+        @test highlight_arm("\t.text") == "\t$(D).text$(XD)\n"
     end
 
     @testset "0-operand" begin
-        @test hilight_arm("\tret") == "\t$(I)ret$(XI)\n"
+        @test highlight_arm("\tret") == "\t$(I)ret$(XI)\n"
     end
     @testset "1-operand" begin
-        @test hilight_arm("\tbl\t0x12") == "\t$(I)bl$(XI)\t$(N)0x12$(XN)\n"
+        @test highlight_arm("\tbl\t0x12") == "\t$(I)bl$(XI)\t$(N)0x12$(XN)\n"
 
-        @test hilight_arm("\tb\tL345") == "\t$(I)b$(XI)\t$(L)L345$(XL)\n"
+        @test highlight_arm("\tb\tL345") == "\t$(I)b$(XI)\t$(L)L345$(XL)\n"
 
-        @test hilight_arm("\tb.gt\tL67") == "\t$(I)b.gt$(XI)\t$(L)L67$(XL)\n"
+        @test highlight_arm("\tb.gt\tL67") == "\t$(I)b.gt$(XI)\t$(L)L67$(XL)\n"
 
-        @test hilight_arm("\tpop\t{r11, pc}") ==
+        @test highlight_arm("\tpop\t{r11, pc}") ==
             "\t$(I)pop$(XI)\t$U$(V)r11$(XV)$COM $(V)pc$(XV)$XU\n"
     end
     @testset "2-operand" begin
-        @test hilight_arm("\tcmp\tx10, #2047\t// =2047") ==
+        @test highlight_arm("\tcmp\tx10, #2047\t// =2047") ==
             "\t$(I)cmp$(XI)\t$(V)x10$(XV)$COM $(N)#2047$(XN)\t$(C)// =2047$(XC)\n"
 
-        @test hilight_arm("\tldr\td1, [x10]") ==
+        @test highlight_arm("\tldr\td1, [x10]") ==
             "\t$(I)ldr$(XI)\t$(V)d1$(XV)$COM $S$(V)x10$(XV)$XS\n"
 
-        @test hilight_arm("\tstr\tx30, [sp, #-16]!") ==
+        @test highlight_arm("\tstr\tx30, [sp, #-16]!") ==
             "\t$(I)str$(XI)\t$(V)x30$(XV)$COM " *
             "$S$(V)sp$(XV)$COM $(N)#-16$(XN)$XS$(K)!$(XK)\n"
 
-        @test hilight_arm("\tmov\tv0.16b, v1.16b") ==
+        @test highlight_arm("\tmov\tv0.16b, v1.16b") ==
             "\t$(I)mov$(XI)\t$(V)v0.16b$(XV)$COM $(V)v1.16b$(XV)\n"
     end
     @testset "3-operand" begin
-        @test hilight_arm("\tfmul\td2, d0, d2") ==
+        @test highlight_arm("\tfmul\td2, d0, d2") ==
             "\t$(I)fmul$(XI)\t$(V)d2$(XV)$COM $(V)d0$(XV)$COM $(V)d2$(XV)\n"
 
-        @test hilight_arm("\tmovk\tx10, #65535, lsl #32") ==
+        @test highlight_arm("\tmovk\tx10, #65535, lsl #32") ==
             "\t$(I)movk$(XI)\t$(V)x10$COM $(N)#65535$(XN)$COM $(K)lsl$(XK) $(N)#32$(XN)\n"
 
-        @test hilight_arm("\tcneg\tx8, x8, ge") ==
+        @test highlight_arm("\tcneg\tx8, x8, ge") ==
             "\t$(I)cneg$(XI)\t$(V)x8$(XV)$COM $(V)x8$(XV)$COM $(K)ge$(XK)\n"
     end
     @testset "4-operand" begin
-        @test hilight_arm("\tadd\tx8, x9, x8, lsl #52") ==
+        @test highlight_arm("\tadd\tx8, x9, x8, lsl #52") ==
             "\t$(I)add$(XI)\t$(V)x8$(XV)$COM $(V)x9$(XV)$COM $(V)x8$(XV)$COM " *
             "$(K)lsl$(XK) $(N)#52$(XN)\n"
 
-        @test hilight_arm("\tfcsel\td1, d0, d1, eq") ==
+        @test highlight_arm("\tfcsel\td1, d0, d1, eq") ==
             "\t$(I)fcsel$(XI)\t" *
             "$(V)d1$(XV)$COM $(V)d0$(XV)$COM $(V)d1$(XV)$COM $(K)eq$(XK)\n"
     end
     @testset "NEON" begin
-        hilight_arm("\tvmul.f32\tq8, q9, q8") ==
+        highlight_arm("\tvmul.f32\tq8, q9, q8") ==
             "\t$(I)vmul.f32$(XI)\t$(V)q8$(XV)$COM $(V)q9$(XV)$COM $(V)q8$(XV)\n"
-        hilight_arm("\tvcvt.s32.f64\ts2, d20") ==
+        highlight_arm("\tvcvt.s32.f64\ts2, d20") ==
             "\t$(I)vcvt.s32.f64$(XI)\t$(V)s2$(XV)$COM $(V)d20$(XV)\n"
-        hilight_arm("\tvld1.32\t{d18, d19}, [r1]") ==
+        highlight_arm("\tvld1.32\t{d18, d19}, [r1]") ==
             "\t$(I)vld1.32$(XI)\t$U$(V)d18$(XV)$COM $(V)d19$(XV)$XU$COM $S$(V)r1$(XV)$XS\n"
     end
     @testset "SVE" begin
-        hilight_arm("\tld1d\tz1.d, p0/z, [x0, x4, lsl #3]") ==
+        highlight_arm("\tld1d\tz1.d, p0/z, [x0, x4, lsl #3]") ==
             "\t$(I)ld1d$(XI)\t$(V)z1.d$(XV)$COM " *
             "$(V)p0$(XV)$(K)/z$(XK)$COM " *
             "$S$(V)x0$(XV)$COM $(V)x4$(XV)$COM $(K)lsl$(XK) $(N)#3$(XN)$XS\n"
-        hilight_arm("\tb.first\tL123") == "\t$(I)b.first$(XI)\t$(L)L123$(XL)"
+        highlight_arm("\tb.first\tL123") == "\t$(I)b.first$(XI)\t$(L)L123$(XL)"
     end
 end
diff --git a/stdlib/LibGit2/src/callbacks.jl b/stdlib/LibGit2/src/callbacks.jl
index f4df26cdc30d8..b4fb29716e609 100644
--- a/stdlib/LibGit2/src/callbacks.jl
+++ b/stdlib/LibGit2/src/callbacks.jl
@@ -292,7 +292,7 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Cvoid}}, url_ptr::Cstring,
             cred = explicit
 
             # Copy explicit credentials to avoid mutating approved credentials.
-            # invalidation fix from cred being non-inferrable
+            # invalidation fix from cred being non-inferable
             p.credential = Base.invokelatest(deepcopy, cred)
 
             if isa(cred, SSHCredential)
@@ -307,7 +307,7 @@ function credentials_callback(libgit2credptr::Ptr{Ptr{Cvoid}}, url_ptr::Cstring,
 
             # Perform a deepcopy as we do not want to mutate approved cached credentials
             if haskey(cache, cred_id)
-                # invalidation fix from cache[cred_id] being non-inferrable
+                # invalidation fix from cache[cred_id] being non-inferable
                 p.credential = Base.invokelatest(deepcopy, cache[cred_id])
             end
         end
diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl
index 8fb79354c5656..9ab961461e76f 100644
--- a/stdlib/LinearAlgebra/src/generic.jl
+++ b/stdlib/LinearAlgebra/src/generic.jl
@@ -755,8 +755,8 @@ This is equivalent to [`norm`](@ref).
 @inline opnorm(x::Number, p::Real=2) = norm(x, p)
 
 """
-    opnorm(A::Adjoint{<:Any,<:AbstracVector}, q::Real=2)
-    opnorm(A::Transpose{<:Any,<:AbstracVector}, q::Real=2)
+    opnorm(A::Adjoint{<:Any,<:AbstractVector}, q::Real=2)
+    opnorm(A::Transpose{<:Any,<:AbstractVector}, q::Real=2)
 
 For Adjoint/Transpose-wrapped vectors, return the operator ``q``-norm of `A`, which is
 equivalent to the `p`-norm with value `p = q/(q-1)`. They coincide at `p = q = 2`.
diff --git a/stdlib/LinearAlgebra/src/lu.jl b/stdlib/LinearAlgebra/src/lu.jl
index 109def9fddb2c..4afb855117c14 100644
--- a/stdlib/LinearAlgebra/src/lu.jl
+++ b/stdlib/LinearAlgebra/src/lu.jl
@@ -76,7 +76,7 @@ Base.iterate(S::LU, ::Val{:done}) = nothing
 adjoint(F::LU{<:Real}) = TransposeFactorization(F)
 transpose(F::LU{<:Real}) = TransposeFactorization(F)
 
-# the following method is meant to catch calls to lu!(A::LAPACKArray) without a pivoting stategy
+# the following method is meant to catch calls to lu!(A::LAPACKArray) without a pivoting strategy
 lu!(A::StridedMatrix{<:BlasFloat}; check::Bool = true) = lu!(A, RowMaximum(); check=check)
 function lu!(A::StridedMatrix{T}, ::RowMaximum; check::Bool = true) where {T<:BlasFloat}
     lpt = LAPACK.getrf!(A; check)
diff --git a/stdlib/LinearAlgebra/test/dense.jl b/stdlib/LinearAlgebra/test/dense.jl
index c2ab5df107527..b11ab5ece9c21 100644
--- a/stdlib/LinearAlgebra/test/dense.jl
+++ b/stdlib/LinearAlgebra/test/dense.jl
@@ -878,7 +878,7 @@ end
     end
 end
 
-@testset "matrix logarithm is type-inferrable" for elty in (Float32,Float64,ComplexF32,ComplexF64)
+@testset "matrix logarithm is type-inferable" for elty in (Float32,Float64,ComplexF32,ComplexF64)
     A1 = randn(elty, 4, 4)
     @inferred Union{Matrix{elty},Matrix{complex(elty)}} log(A1)
 end
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index aaf433c95b7b0..e0ba443ece7df 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -564,7 +564,7 @@ end
     end
 end
 
-@testset "check matrix logarithm type-inferrable" for elty in (Float32,Float64,ComplexF32,ComplexF64)
+@testset "check matrix logarithm type-inferable" for elty in (Float32,Float64,ComplexF32,ComplexF64)
     A = UpperTriangular(exp(triu(randn(elty, n, n))))
     @inferred Union{typeof(A),typeof(complex(A))} log(A)
     @test exp(Matrix(log(A))) ≈ A
diff --git a/stdlib/Printf/src/Printf.jl b/stdlib/Printf/src/Printf.jl
index cb336a8d9c18b..8d2d97ddd6b32 100644
--- a/stdlib/Printf/src/Printf.jl
+++ b/stdlib/Printf/src/Printf.jl
@@ -237,7 +237,7 @@ function Format(f::AbstractString)
         !(b in b"diouxXDOUeEfFgGaAcCsSpn") && throw(InvalidFormatStringError("'$(Char(b))' is not a valid type specifier", f, last_percent_pos, pos-1))
         type = Val{Char(b)}
         if type <: Ints && precision > 0
-            # note - we should also set zero to false if dynamic precison > 0
+            # note - we should also set zero to false if dynamic precision > 0
             # this is taken care of in fmt() for Ints
             zero = false
         elseif (type <: Strings || type <: Chars) && !parsedprecdigits
diff --git a/stdlib/REPL/src/latex_symbols.jl b/stdlib/REPL/src/latex_symbols.jl
index 9e71819f6562b..ddd110de8b714 100644
--- a/stdlib/REPL/src/latex_symbols.jl
+++ b/stdlib/REPL/src/latex_symbols.jl
@@ -2623,10 +2623,10 @@ const latex_symbols = Dict(
     "\\4/5" => "⅘", # vulgar fraction four fifths
     "\\1/6" => "⅙", # vulgar fraction one sixth
     "\\5/6" => "⅚", # vulgar fraction five sixths
-    "\\1/8" => "⅛", # vulgar fraction one eigth
-    "\\3/8" => "⅜", # vulgar fraction three eigths
-    "\\5/8" => "⅝", # vulgar fraction five eigths
-    "\\7/8" => "⅞", # vulgar fraction seventh eigths
+    "\\1/8" => "⅛", # vulgar fraction one eighth
+    "\\3/8" => "⅜", # vulgar fraction three eighths
+    "\\5/8" => "⅝", # vulgar fraction five eighths
+    "\\7/8" => "⅞", # vulgar fraction seventh eighths
     "\\1/" => "⅟", # fraction numerator one
     "\\0/3" => "↉", # vulgar fraction zero thirds
     "\\1/4" => "¼", # vulgar fraction one quarter
diff --git a/stdlib/REPL/src/precompile.jl b/stdlib/REPL/src/precompile.jl
index 2e75bd69e197b..1b22eb77953a3 100644
--- a/stdlib/REPL/src/precompile.jl
+++ b/stdlib/REPL/src/precompile.jl
@@ -51,7 +51,7 @@ $UP_ARROW$DOWN_ARROW$CTRL_C
 f(x) = x03
 f(1,2)
 [][1]
-cd("complet_path\t\t$CTRL_C
+cd("complete_path\t\t$CTRL_C
 """
 
 julia_exepath() = joinpath(Sys.BINDIR, Base.julia_exename())
@@ -148,7 +148,7 @@ generate_precompile_statements() = try
 
         open(precompile_file, "r") do io
             while true
-                # We need to allways call eof(io) for bytesavailable(io) to work
+                # We need to always call eof(io) for bytesavailable(io) to work
                 eof(io) && istaskdone(repl_inputter) && eof(io) && break
                 if bytesavailable(io) == 0
                     sleep(0.1)
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index ef1cf8814af74..96a190e9f41ea 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -1980,7 +1980,7 @@ let (c, r, res) = test_complete_context("getkeyelem(mutable_const_prop).value.")
 end
 
 # JuliaLang/julia/#51548
-# don't return wrong result due to mutable inconsistentcy
+# don't return wrong result due to mutable inconsistency
 function issue51548(T, a)
     # if we fold `xs = getindex(T)` to `xs::Const(Vector{T}())`, then we may wrongly
     # constant-fold `isempty(xs)::Const(true)` and return wrong result
diff --git a/stdlib/Random/docs/src/index.md b/stdlib/Random/docs/src/index.md
index fbf0b60fc6a24..70d27dc021875 100644
--- a/stdlib/Random/docs/src/index.md
+++ b/stdlib/Random/docs/src/index.md
@@ -215,7 +215,7 @@ and that we *always* want to build an alias table, regardless of the number of v
 Random.eltype(::Type{<:DiscreteDistribution}) = Int
 
 function Random.Sampler(::Type{<:AbstractRNG}, distribution::DiscreteDistribution, ::Repetition)
-    SamplerSimple(disribution, make_alias_table(distribution.probabilities))
+    SamplerSimple(distribution, make_alias_table(distribution.probabilities))
 end
 ```
 should be defined to return a sampler with pre-computed data, then
diff --git a/stdlib/SuiteSparse_jll/test/runtests.jl b/stdlib/SuiteSparse_jll/test/runtests.jl
index d6d82a73e4a57..922da55fa1881 100644
--- a/stdlib/SuiteSparse_jll/test/runtests.jl
+++ b/stdlib/SuiteSparse_jll/test/runtests.jl
@@ -5,7 +5,7 @@ using Test, SuiteSparse_jll
 # SuiteSparse only uses SUITESPARSE_MAIN_VERSION and SUITESPARSE_SUB_VERSION to compute its version
 # The SUITESPARSE_SUBSUB_VERSION is not used
 # TODO before release: update to 7020 or above when upstreamed.
-# This should be safe and unecessary since we specify exact version of the BB JLL.
+# This should be safe and unnecessary since we specify exact version of the BB JLL.
 @testset "SuiteSparse_jll" begin
     @test ccall((:SuiteSparse_version, libsuitesparseconfig), Cint, (Ptr{Cint},), C_NULL) > 7000
 end
diff --git a/stdlib/TOML/test/toml_test.jl b/stdlib/TOML/test/toml_test.jl
index f4670058223a1..c22c01acf1870 100644
--- a/stdlib/TOML/test/toml_test.jl
+++ b/stdlib/TOML/test/toml_test.jl
@@ -36,7 +36,7 @@ end
 
 function check_valid(f)
     jsn = try jsn2data(@eval include($f * ".jl"))
-    # Some files cannot be reprsented with julias DateTime (timezones)
+    # Some files cannot be represented with julias DateTime (timezones)
     catch
         return false
     end
diff --git a/stdlib/Test/src/Test.jl b/stdlib/Test/src/Test.jl
index 0844aa9807bb1..7e416df91864e 100644
--- a/stdlib/Test/src/Test.jl
+++ b/stdlib/Test/src/Test.jl
@@ -1459,7 +1459,7 @@ parent test set (with the context object appended to any failing tests.)
     `@testset let` requires at least Julia 1.9.
 
 !!! compat "Julia 1.10"
-    Multiple `let` assignements are supported since Julia 1.10.
+    Multiple `let` assignments are supported since Julia 1.10.
 
 ## Examples
 ```jldoctest
diff --git a/stdlib/Test/test/runtests.jl b/stdlib/Test/test/runtests.jl
index 7c4edc4b9d93b..92ca8900882ce 100644
--- a/stdlib/Test/test/runtests.jl
+++ b/stdlib/Test/test/runtests.jl
@@ -659,15 +659,15 @@ end
 @test tss.foo == 3
 
 # test @inferred
-uninferrable_function(i) = (1, "1")[i]
-uninferrable_small_union(i) = (1, nothing)[i]
-@test_throws ErrorException @inferred(uninferrable_function(1))
+uninferable_function(i) = (1, "1")[i]
+uninferable_small_union(i) = (1, nothing)[i]
+@test_throws ErrorException @inferred(uninferable_function(1))
 @test @inferred(identity(1)) == 1
-@test @inferred(Nothing, uninferrable_small_union(1)) === 1
-@test @inferred(Nothing, uninferrable_small_union(2)) === nothing
-@test_throws ErrorException @inferred(Missing, uninferrable_small_union(1))
-@test_throws ErrorException @inferred(Missing, uninferrable_small_union(2))
-@test_throws ArgumentError @inferred(nothing, uninferrable_small_union(1))
+@test @inferred(Nothing, uninferable_small_union(1)) === 1
+@test @inferred(Nothing, uninferable_small_union(2)) === nothing
+@test_throws ErrorException @inferred(Missing, uninferable_small_union(1))
+@test_throws ErrorException @inferred(Missing, uninferable_small_union(2))
+@test_throws ArgumentError @inferred(nothing, uninferable_small_union(1))
 
 # Ensure @inferred only evaluates the arguments once
 inferred_test_global = 0
@@ -692,12 +692,12 @@ end
 
 # Issue #17105
 # @inferred with kwargs
-inferrable_kwtest(x; y=1) = 2x
-uninferrable_kwtest(x; y=1) = 2x+y
-@test (@inferred inferrable_kwtest(1)) == 2
-@test (@inferred inferrable_kwtest(1; y=1)) == 2
-@test (@inferred uninferrable_kwtest(1)) == 3
-@test (@inferred uninferrable_kwtest(1; y=2)) == 4
+inferable_kwtest(x; y=1) = 2x
+uninferable_kwtest(x; y=1) = 2x+y
+@test (@inferred inferable_kwtest(1)) == 2
+@test (@inferred inferable_kwtest(1; y=1)) == 2
+@test (@inferred uninferable_kwtest(1)) == 3
+@test (@inferred uninferable_kwtest(1; y=2)) == 4
 
 @test_throws ErrorException @testset "$(error())" for i in 1:10
 end
@@ -1193,7 +1193,7 @@ h25835(;x=1,y=1) = x isa Int ? x*y : (rand(Bool) ? 1.0 : 1)
     @test @inferred(f25835(x=nothing)) == ()
     @test @inferred(f25835(x=1)) == (1,)
 
-    # A global argument should make this uninferrable
+    # A global argument should make this uninferable
     global y25835 = 1
     @test f25835(x=y25835) == (1,)
     @test_throws ErrorException @inferred((()->f25835(x=y25835))()) == (1,)
diff --git a/test/clangsa/GCPushPop.cpp b/test/clangsa/GCPushPop.cpp
index a62c1501bf323..72e0494a7d936 100644
--- a/test/clangsa/GCPushPop.cpp
+++ b/test/clangsa/GCPushPop.cpp
@@ -18,7 +18,7 @@ void missingPop2() {
 } // expected-warning{{Non-popped GC frame present at end of function}}
   // expected-note@-1{{Non-popped GC frame present at end of function}}
 
-void superflousPop() {
+void superfluousPop() {
   JL_GC_POP(); // expected-warning{{JL_GC_POP without corresponding push}}
 }              // expected-note@-1{{JL_GC_POP without corresponding push}}
 
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 2e3598d0a1597..95d65de0c01f2 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -148,7 +148,7 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
                     "JULIA_LOAD_PATH" => ";;;:::",
                     "JULIA_DEPOT_PATH" => ";;;:::",
                     "HOME" => homedir()))
-        # TODO: ideally, `@which`, etc. would still work, but Julia can't handle `using $InterativeUtils`
+        # TODO: ideally, `@which`, etc. would still work, but Julia can't handle `using $InteractiveUtils`
         @test v == ("REPL: 3\n", true)
     end
     @testset let v = readchomperrors(`$exename -i -e '
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index afda3c1793031..8ed034b391b5e 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -236,7 +236,7 @@ tuplemerge_test(Tuple{}, Tuple{Complex, Vararg{Union{ComplexF32, ComplexF64}}},
 @test Core.Compiler.tmerge(Union{Nothing, AbstractFloat}, Integer) == Union{Nothing, AbstractFloat, Integer}
 
 # test that recursively more complicated types don't widen all the way to Any when there is a useful valid type upper bound
-# Specificially test with base types of a trivial type, a simple union, a complicated union, and a tuple.
+# Specifically test with base types of a trivial type, a simple union, a complicated union, and a tuple.
 for T in (Nothing, Base.BitInteger, Union{Int, Int32, Int16, Int8}, Tuple{Int, Int})
     Ta, Tb = T, T
     for i in 1:10
@@ -2403,7 +2403,7 @@ isaint(a) = isa(a, Int)
     end
     return 0
 end |> only === Int
-# handle multiple call-site refinment targets
+# handle multiple call-site refinement targets
 isasome(_) = true
 isasome(::Nothing) = false
 @test_broken Base.return_types((AliasableField{Union{Int,Nothing}},); interp=MustAliasInterpreter()) do a
@@ -5129,7 +5129,7 @@ let 𝕃 = Core.Compiler.SimpleInferenceLattice.instance
     end isa Vector
 end
 
-# `getindex(::SimpleVector, ::Int)` shuold be concrete-evaluated
+# `getindex(::SimpleVector, ::Int)` should be concrete-evaluated
 @eval Base.return_types() do
     $(Core.svec(1,Int,nothing))[2]
 end |> only == Type{Int}
@@ -5255,14 +5255,14 @@ let TV = TypeVar(:T)
 end
 
 # use `Vararg` type constraints
-use_vararg_constrant1(args::Vararg{T,N}) where {T,N} = Val(T), Val(N)
-@test only(Base.return_types(use_vararg_constrant1, Tuple{Int,Int})) == Tuple{Val{Int},Val{2}}
-use_vararg_constrant2(args::Vararg{T,N}) where {T,N} = Val(T), N
-@test only(Base.return_types(use_vararg_constrant2, Tuple{Vararg{Int}})) == Tuple{Val{Int},Int}
-use_vararg_constrant3(args::NTuple{N,T}) where {T,N} = Val(T), Val(N)
-@test only(Base.return_types(use_vararg_constrant3, Tuple{Tuple{Int,Int}})) == Tuple{Val{Int},Val{2}}
-use_vararg_constrant4(args::NTuple{N,T}) where {T,N} = Val(T), N
-@test only(Base.return_types(use_vararg_constrant4, Tuple{NTuple{N,Int}} where N)) == Tuple{Val{Int},Int}
+use_vararg_constraint1(args::Vararg{T,N}) where {T,N} = Val(T), Val(N)
+@test only(Base.return_types(use_vararg_constraint1, Tuple{Int,Int})) == Tuple{Val{Int},Val{2}}
+use_vararg_constraint2(args::Vararg{T,N}) where {T,N} = Val(T), N
+@test only(Base.return_types(use_vararg_constraint2, Tuple{Vararg{Int}})) == Tuple{Val{Int},Int}
+use_vararg_constraint3(args::NTuple{N,T}) where {T,N} = Val(T), Val(N)
+@test only(Base.return_types(use_vararg_constraint3, Tuple{Tuple{Int,Int}})) == Tuple{Val{Int},Val{2}}
+use_vararg_constraint4(args::NTuple{N,T}) where {T,N} = Val(T), N
+@test only(Base.return_types(use_vararg_constraint4, Tuple{NTuple{N,Int}} where N)) == Tuple{Val{Int},Int}
 
 # issue 51228
 global whatever_unknown_value51228
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 07d4c7bf363a8..0fce3e1b6f0d8 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -1710,7 +1710,7 @@ let getfield_tfunc(@nospecialize xs...) =
 end
 @test fully_eliminated(Base.ismutable, Tuple{Base.RefValue})
 
-# TODO: Remove compute sparams for vararg_retrival
+# TODO: Remove compute sparams for vararg_retrieval
 fvarargN_inline(x::Tuple{Vararg{Int, N}}) where {N} = N
 fvarargN_inline(args...) = fvarargN_inline(args)
 let src = code_typed1(fvarargN_inline, (Tuple{Vararg{Int}},))
diff --git a/test/compiler/invalidation.jl b/test/compiler/invalidation.jl
index 848d475b85b69..10e239cfc363f 100644
--- a/test/compiler/invalidation.jl
+++ b/test/compiler/invalidation.jl
@@ -173,13 +173,13 @@ end
 # we can avoid adding backedge even if the callee's return type is not the top
 # when the return value is not used within the caller
 begin take!(GLOBAL_BUFFER)
-    pr48932_callee_inferrable(x) = (print(GLOBAL_BUFFER, x); Base.inferencebarrier(1)::Int)
-    pr48932_caller_unuse(x) = (pr48932_callee_inferrable(Base.inferencebarrier(x)); nothing)
+    pr48932_callee_inferable(x) = (print(GLOBAL_BUFFER, x); Base.inferencebarrier(1)::Int)
+    pr48932_caller_unuse(x) = (pr48932_callee_inferable(Base.inferencebarrier(x)); nothing)
 
     # assert that type and effects information inferred from `pr48932_callee(::Any)` are the top
-    let rt = only(Base.return_types(pr48932_callee_inferrable, (Any,)))
+    let rt = only(Base.return_types(pr48932_callee_inferable, (Any,)))
         @test rt === Int
-        effects = Base.infer_effects(pr48932_callee_inferrable, (Any,))
+        effects = Base.infer_effects(pr48932_callee_inferable, (Any,))
         @test Core.Compiler.Effects(effects) == Core.Compiler.Effects()
     end
 
@@ -190,10 +190,10 @@ begin take!(GLOBAL_BUFFER)
             @inline pr48932_caller_unuse(x)
         end |> only
         @test rt === Nothing
-        @test any(iscall((src, pr48932_callee_inferrable)), src.code)
+        @test any(iscall((src, pr48932_callee_inferable)), src.code)
     end
     @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_callee_inferrable
+        mi.def.name === :pr48932_callee_inferable
     end
     @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
         mi.def.name === :pr48932_caller_unuse
@@ -201,11 +201,11 @@ begin take!(GLOBAL_BUFFER)
     @test isnothing(pr48932_caller_unuse(42))
     @test "42" == String(take!(GLOBAL_BUFFER))
 
-    # test that we didn't add the backedge from `pr48932_callee_inferrable` to `pr48932_caller_unuse`:
-    # this redefinition below should invalidate the cache of `pr48932_callee_inferrable` but not that of `pr48932_caller_unuse`
-    pr48932_callee_inferrable(x) = (print(GLOBAL_BUFFER, "foo"); x)
+    # test that we didn't add the backedge from `pr48932_callee_inferable` to `pr48932_caller_unuse`:
+    # this redefinition below should invalidate the cache of `pr48932_callee_inferable` but not that of `pr48932_caller_unuse`
+    pr48932_callee_inferable(x) = (print(GLOBAL_BUFFER, "foo"); x)
     @test !any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_callee_inferrable
+        mi.def.name === :pr48932_callee_inferable
     end
     @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
         mi.def.name === :pr48932_caller_unuse
diff --git a/test/core.jl b/test/core.jl
index af9a896de59f8..c552678b19603 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8023,7 +8023,7 @@ for T in (Int, String, Symbol, Module)
 end
 @test !Core.Compiler.is_consistent(Base.infer_effects(objectid, (Ref{Int},)))
 @test !Core.Compiler.is_consistent(Base.infer_effects(objectid, (Tuple{Ref{Int}},)))
-# objectid for datatypes is inconsistant for types that have unbound type parameters.
+# objectid for datatypes is inconsistent for types that have unbound type parameters.
 @test !Core.Compiler.is_consistent(Base.infer_effects(objectid, (DataType,)))
 @test !Core.Compiler.is_consistent(Base.infer_effects(objectid, (Tuple{Vector{Int}},)))
 
diff --git a/test/gcext/gcext.c b/test/gcext/gcext.c
index 90b5ee82d80b5..d5bf91ec8c9ab 100644
--- a/test/gcext/gcext.c
+++ b/test/gcext/gcext.c
@@ -32,7 +32,7 @@ static inline int lt_ptr(void *a, void *b)
     return (uintptr_t)a < (uintptr_t)b;
 }
 
-/* align pointer to full word if mis-aligned */
+/* align pointer to full word if misaligned */
 static inline void *align_ptr(void *p)
 {
     uintptr_t u = (uintptr_t)p;
diff --git a/test/intrinsics.jl b/test/intrinsics.jl
index 3c49afe2c4d7e..d67dad33e60cc 100644
--- a/test/intrinsics.jl
+++ b/test/intrinsics.jl
@@ -182,7 +182,7 @@ end
 
 if Sys.ARCH == :aarch64 ||  Sys.ARCH === :powerpc64le || Sys.ARCH === :ppc64le
     # On AArch64 we are following the `_Float16` ABI. Buthe these functions expect `Int16`.
-    # TODO: SHould we have `Chalf == Int16` and `Cfloat16 == Float16`?
+    # TODO: Should we have `Chalf == Int16` and `Cfloat16 == Float16`?
     extendhfsf2(x::Float16) = ccall("extern __extendhfsf2", llvmcall, Float32, (UInt16,), reinterpret(UInt16, x))
     gnu_h2f_ieee(x::Float16) = ccall("extern __gnu_h2f_ieee", llvmcall, Float32, (UInt16,), reinterpret(UInt16, x))
     truncsfhf2(x::Float32) = reinterpret(Float16, ccall("extern __truncsfhf2", llvmcall, UInt16, (Float32,), x))
diff --git a/test/misc.jl b/test/misc.jl
index 79b684badf1e0..249175a0ed1d3 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1058,7 +1058,7 @@ Base.setindex!(xs::InvokeXs2, @nospecialize(v::Any), idx::Int) = xs.xs[idx] = v
         @test @invoke(f2(1::Real)) === Integer
     end
 
-    # when argment's type annotation is omitted, it should be specified as `Core.Typeof(x)`
+    # when argument's type annotation is omitted, it should be specified as `Core.Typeof(x)`
     let f(_) = Any
         f(x::Integer) = Integer
         @test f(1) === Integer
@@ -1353,7 +1353,7 @@ end
 end
 
 # Test that read fault on a prot-none region does not incorrectly give
-# ReadOnlyMemoryEror, but rather crashes the program
+# ReadOnlyMemoryError, but rather crashes the program
 const MAP_ANONYMOUS_PRIVATE = Sys.isbsd() ? 0x1002 : 0x22
 let script = :(
         let ptr = Ptr{Cint}(ccall(:jl_mmap, Ptr{Cvoid},
diff --git a/test/operators.jl b/test/operators.jl
index cf72d83ab0076..95006235692a0 100644
--- a/test/operators.jl
+++ b/test/operators.jl
@@ -195,7 +195,7 @@ end
     @test repr(uppercase ∘ first) == "uppercase ∘ first"
     @test sprint(show, "text/plain", uppercase ∘ first) == "uppercase ∘ first"
 
-    # test keyword ags in composition
+    # test keyword args in composition
     function kwf(a;b,c); a + b + c; end
     @test (abs2 ∘ kwf)(1,b=2,c=3) == 36
 
diff --git a/test/testhelpers/DualNumbers.jl b/test/testhelpers/DualNumbers.jl
index 9f62e3bf0d429..5c481aef47f76 100644
--- a/test/testhelpers/DualNumbers.jl
+++ b/test/testhelpers/DualNumbers.jl
@@ -41,6 +41,6 @@ Base.sqrt(x::Dual) = Dual(sqrt(x.val), x.eps/(2sqrt(x.val)))
 Base.isless(x::Dual, y::Dual) = x.val < y.val
 Base.isless(x::Real, y::Dual) = x < y.val
 Base.isinf(x::Dual) = isinf(x.val) & isfinite(x.eps)
-Base.real(x::Dual) = x # since we curently only consider Dual{<:Real}
+Base.real(x::Dual) = x # since we currently only consider Dual{<:Real}
 
 end # module

From 258ac4614f589cb46436c12b2fa12030efd0cca3 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sun, 15 Oct 2023 19:09:11 -0700
Subject: [PATCH 0006/1315] Add note about sysimage `__init__`s running before
 startup.jl (#51623)

What caught me out in https://github.com/JuliaLang/julia/issues/51620
---
 doc/src/manual/environment-variables.md | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/environment-variables.md b/doc/src/manual/environment-variables.md
index 344c272fd80a5..2fc1dcbb2f32b 100644
--- a/doc/src/manual/environment-variables.md
+++ b/doc/src/manual/environment-variables.md
@@ -16,8 +16,19 @@ including those which include `JULIA` in their names.
 
 !!! note
 
-    Some variables, such as [`JULIA_NUM_THREADS`](@ref JULIA_NUM_THREADS) and [`JULIA_PROJECT`](@ref JULIA_PROJECT), need to be set before Julia
-    starts, therefore adding these to `~/.julia/config/startup.jl` is too late in the startup process.
+    It is recommended to avoid changing environment variables during runtime,
+    such as within a `~/.julia/config/startup.jl`.
+
+    One reason is that some julia language variables, such as [`JULIA_NUM_THREADS`](@ref JULIA_NUM_THREADS)
+    and [`JULIA_PROJECT`](@ref JULIA_PROJECT), need to be set before Julia starts.
+
+    Similarly, `__init__()` functions of user modules in the sysimage (via PackageCompiler) are
+    run before `startup.jl`, so setting environment variables in a `startup.jl` may be too late for
+    user code.
+
+    Further, changing environment variables during runtime can introduce data races into
+    otherwise benign code.
+
     In Bash, environment variables can either be set manually by running, e.g.,
     `export JULIA_NUM_THREADS=4` before starting Julia, or by adding the same command to
     `~/.bashrc` or `~/.bash_profile` to set the variable each time Bash is started.

From b0c6781676f08bc0150018cd5ed54d71bb0c49c2 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Mon, 16 Oct 2023 08:09:42 -0400
Subject: [PATCH 0007/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20SparseArrays=20stdlib=20from=204e6776a=20to=200f8bbda=20(#51?=
 =?UTF-8?q?678)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: SparseArrays
URL: https://github.com/JuliaSparse/SparseArrays.jl.git
Stdlib branch: main
Julia branch: master
Old commit: 4e6776a
New commit: 0f8bbda
Julia version: 1.11.0-DEV
SparseArrays version: 1.11.0
Bump invoked by: @ViralBShah
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaSparse/SparseArrays.jl/compare/4e6776a825f2a26c3c580f9b77ba230a6598d7dd...0f8bbdac9c2d805f32faed90f4d8b8c8514aa478

```
$ git log --oneline 4e6776a..0f8bbda
0f8bbda Interpolate SparseVector in display test (#455)
d884072 Merge pull request #427 from JuliaSparse/jishnub/sparsevecshow
9e68b7e Merge branch 'main' into jishnub/sparsevecshow
12a1c30 remove unnecessary inequality change
4217641 don't set Documenter compat
e86b148 Adapt to Documenter v1 (#444)
8c72535 Merge branch 'main' into jishnub/sparsevecshow
8c20ba1 Test for truncation
8f925f8 Interpolate Int in expected string
c53e1f2 interpolate struct in display test
33d4bf5 Undef show with MIME text/plain
034d234 Hook into new factorization dispatch mechanisms (#437)
248d0e6 Merge branch 'main' into jishnub/sparsevecshow
713ab9b Fix documentation of `findall` behaviour (#452)
cb9b31f rowvals instead of nonzeroinds
05ac950 Add example for UMFPACK control vector (#449)
605237e Add JL_UMFPACK_PIVOT_TOLERANCE to umfpack.jl (#447)
5dac134 Use a single header wrapper for all platforms. (#446)
47e26dd Explicit types in test RHS
c123952 Interpolate vectors in show test
b309da7 Explicit types
d21fc79 Add test for showing a vector of sparsevec
3e918e4 Restore unfilled sparsevec display
b533818 Don't add SparseArrays to docs/Project.toml
4449100 Remove commented out method
728e116 ignore docs/build
99a0db2 Merge show methods
ac5c8ed Switch from internal 5-arg `searchsorted*` methods to views (#440)
ada9edd sparse vector views remain sparse (#416)
c93065c Improved the dot product between two vectors and a sparse matrix (#410)
2fae1a1 Correctly set zeros with `fill!(::SubArray)` and fix its return value (#433)
03ed9e3 Code quality cleanup (#438)
559a74e Merge branch 'main' into jishnub/sparsevecshow
8944160 fix empty show
e72223d One-line show for SparseVector
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 stdlib/SparseArrays.version                                     | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/sha512
 delete mode 100644 deps/checksums/SparseArrays-4e6776a825f2a26c3c580f9b77ba230a6598d7dd.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-4e6776a825f2a26c3c580f9b77ba230a6598d7dd.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/md5 b/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/md5
new file mode 100644
index 0000000000000..91cf02d3d1d50
--- /dev/null
+++ b/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/md5
@@ -0,0 +1 @@
+69978c0844e0b4e780ae98c491e2fef4
diff --git a/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/sha512 b/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/sha512
new file mode 100644
index 0000000000000..45782edfc0689
--- /dev/null
+++ b/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/sha512
@@ -0,0 +1 @@
+96391c3e79cc7eb580c7f61814c808110b5b1f5f65135509bf55fcd93c007257a126c6511fa97975d88cacec1d2c0722c2cc66b43f974278375ef976870af63c
diff --git a/deps/checksums/SparseArrays-4e6776a825f2a26c3c580f9b77ba230a6598d7dd.tar.gz/md5 b/deps/checksums/SparseArrays-4e6776a825f2a26c3c580f9b77ba230a6598d7dd.tar.gz/md5
deleted file mode 100644
index fe0a7d8a02a91..0000000000000
--- a/deps/checksums/SparseArrays-4e6776a825f2a26c3c580f9b77ba230a6598d7dd.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-610ecdfc1624f4dba575d1ca78c02f01
diff --git a/deps/checksums/SparseArrays-4e6776a825f2a26c3c580f9b77ba230a6598d7dd.tar.gz/sha512 b/deps/checksums/SparseArrays-4e6776a825f2a26c3c580f9b77ba230a6598d7dd.tar.gz/sha512
deleted file mode 100644
index 5626ac97ada1f..0000000000000
--- a/deps/checksums/SparseArrays-4e6776a825f2a26c3c580f9b77ba230a6598d7dd.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-fb6fc223f2bc0abfdc082805100351a46fb1c56d16079ea1d608d114f86a701243f5aa448b7e251f735125389baed94e632385f3e560c789136a6848e5f39c81
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 96024ba41da82..91a67c5bddc9f 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 4e6776a825f2a26c3c580f9b77ba230a6598d7dd
+SPARSEARRAYS_SHA1 = 0f8bbdac9c2d805f32faed90f4d8b8c8514aa478
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From 4d36da7768ea403284cb7364366a941cfba40642 Mon Sep 17 00:00:00 2001
From: KronosTheLate <61620837+KronosTheLate@users.noreply.github.com>
Date: Mon, 16 Oct 2023 17:01:46 +0200
Subject: [PATCH 0008/1315] Improve dostring for error(msg...) (#51721)

This PR slightly modifies the docstring for the second method defined
for `error`, as the docstring for this method a) seems quite imprecise,
and b) is identical to that of `error(::AbstractString)`.
---
 base/error.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/error.jl b/base/error.jl
index 4e9be0e172d61..fa020f4823cbd 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -37,7 +37,7 @@ error(s::AbstractString) = throw(ErrorException(s))
 """
     error(msg...)
 
-Raise an `ErrorException` with the given message.
+Raise an `ErrorException` with a message constructed by `string(msg...)`.
 """
 function error(s::Vararg{Any,N}) where {N}
     @noinline

From 6ec149f3b19a0d1ba597ee20780856cd5ae31867 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 16 Oct 2023 09:53:47 -0700
Subject: [PATCH 0009/1315] Lower Pidfile stale_age multiplier. Add pidfile to
 cache log message. (#51714)

---
 base/loading.jl                     | 19 +++++++++-------
 stdlib/FileWatching/src/pidfile.jl  | 21 +++++++++--------
 stdlib/FileWatching/test/pidfile.jl | 35 ++++++++++++++++++++---------
 3 files changed, 48 insertions(+), 27 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index a10c7b35d0e18..4eca0ea0e1200 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -3053,14 +3053,17 @@ global parse_pidfile_hook
 # the same package cannot be precompiled from different projects and/or different preferences at the same time.
 compilecache_pidfile_path(pkg::PkgId) = compilecache_path(pkg, UInt64(0); project="") * ".pidfile"
 
+const compilecache_pidlock_stale_age = 10
+
 # Allows processes to wait if another process is precompiling a given source already.
-# The lock file mtime will be updated when held every `stale_age/2` seconds.
+# The lock file mtime will be updated when held at most every `stale_age/2` seconds, with expected
+# variance of 10 seconds or more being infrequent but not unusual.
 # After `stale_age` seconds beyond the mtime of the lock file, the lock file is deleted and
-# precompilation will proceed if
-#  - the locking process no longer exists
-#  - the lock is held by another host, since processes cannot be checked remotely
-# or after `stale_age * 25` seconds if the process does still exist.
-function maybe_cachefile_lock(f, pkg::PkgId, srcpath::String; stale_age=10)
+# precompilation will proceed if the locking process no longer exists or after `stale_age * 5`
+# seconds if the process does still exist.
+# If the lock is held by another host, it will conservatively wait `stale_age * 5`
+# seconds since processes cannot be checked remotely
+function maybe_cachefile_lock(f, pkg::PkgId, srcpath::String; stale_age=compilecache_pidlock_stale_age)
     if @isdefined(mkpidlock_hook) && @isdefined(trymkpidlock_hook) && @isdefined(parse_pidfile_hook)
         pidfile = compilecache_pidfile_path(pkg)
         cachefile = invokelatest(trymkpidlock_hook, f, pidfile; stale_age)
@@ -3068,9 +3071,9 @@ function maybe_cachefile_lock(f, pkg::PkgId, srcpath::String; stale_age=10)
             pid, hostname, age = invokelatest(parse_pidfile_hook, pidfile)
             verbosity = isinteractive() ? CoreLogging.Info : CoreLogging.Debug
             if isempty(hostname) || hostname == gethostname()
-                @logmsg verbosity "Waiting for another process (pid: $pid) to finish precompiling $pkg"
+                @logmsg verbosity "Waiting for another process (pid: $pid) to finish precompiling $pkg. Pidfile: $pidfile"
             else
-                @logmsg verbosity "Waiting for another machine (hostname: $hostname, pid: $pid) to finish precompiling $pkg"
+                @logmsg verbosity "Waiting for another machine (hostname: $hostname, pid: $pid) to finish precompiling $pkg. Pidfile: $pidfile"
             end
             # wait until the lock is available, but don't actually acquire it
             # returning nothing indicates a process waited for another
diff --git a/stdlib/FileWatching/src/pidfile.jl b/stdlib/FileWatching/src/pidfile.jl
index 93217311c3183..ada725e63094b 100644
--- a/stdlib/FileWatching/src/pidfile.jl
+++ b/stdlib/FileWatching/src/pidfile.jl
@@ -33,7 +33,8 @@ Optional keyword arguments:
  - `mode`: file access mode (modified by the process umask). Defaults to world-readable.
  - `poll_interval`: Specify the maximum time to between attempts (if `watch_file` doesn't work)
  - `stale_age`: Delete an existing pidfile (ignoring the lock) if it is older than this many seconds, based on its mtime.
-     The file won't be deleted until 25x longer than this if the pid in the file appears that it may be valid.
+     The file won't be deleted until 5x longer than this if the pid in the file appears that it may be valid.
+     Or 25x longer if `refresh` is overridden to 0 to disable lock refreshing.
      By default this is disabled (`stale_age` = 0), but a typical recommended value would be about 3-5x an
      estimated normal completion time.
  - `refresh`: Keeps a lock from becoming stale by updating the mtime every interval of time that passes.
@@ -64,7 +65,7 @@ mutable struct LockMonitor
         atdir, atname = splitdir(at)
         isempty(atdir) && (atdir = pwd())
         at = realpath(atdir) * path_separator * atname
-        fd = open_exclusive(at; stale_age=stale_age, kwopts...)
+        fd = open_exclusive(at; stale_age, refresh, kwopts...)
         update = nothing
         try
             write_pidfile(fd, pid)
@@ -185,15 +186,16 @@ function isvalidpid(hostname::AbstractString, pid::Cuint)
 end
 
 """
-    stale_pidfile(path::String, stale_age::Real) :: Bool
+    stale_pidfile(path::String, stale_age::Real, refresh::Real) :: Bool
 
 Helper function for `open_exclusive` for deciding if a pidfile is stale.
 """
-function stale_pidfile(path::String, stale_age::Real)
+function stale_pidfile(path::String, stale_age::Real, refresh::Real)
     pid, hostname, age = parse_pidfile(path)
     age < -stale_age && @warn "filesystem time skew detected" path=path
+    longer_factor = refresh == 0 ? 25 : 5
     if age > stale_age
-        if (age > stale_age * 25) || !isvalidpid(hostname, pid)
+        if (age > stale_age * longer_factor) || !isvalidpid(hostname, pid)
             return true
         end
     end
@@ -220,7 +222,7 @@ struct PidlockedError <: Exception
 end
 
 """
-    open_exclusive(path::String; mode, poll_interval, wait, stale_age) :: File
+    open_exclusive(path::String; mode, poll_interval, wait, stale_age, refresh) :: File
 
 Create a new a file for read-write advisory-exclusive access.
 If `wait` is `false` then error out if the lock files exist
@@ -232,13 +234,14 @@ function open_exclusive(path::String;
                         mode::Integer = 0o444 #= read-only =#,
                         poll_interval::Real = 10 #= seconds =#,
                         wait::Bool = true #= return on failure if false =#,
-                        stale_age::Real = 0 #= disabled =#)
+                        stale_age::Real = 0 #= disabled =#,
+                        refresh::Real = stale_age/2)
     # fast-path: just try to open it
     file = tryopen_exclusive(path, mode)
     file === nothing || return file
     if !wait
         if file === nothing && stale_age > 0
-            if stale_age > 0 && stale_pidfile(path, stale_age)
+            if stale_age > 0 && stale_pidfile(path, stale_age, refresh)
                 @warn "attempting to remove probably stale pidfile" path=path
                 tryrmopenfile(path)
             end
@@ -264,7 +267,7 @@ function open_exclusive(path::String;
         file = tryopen_exclusive(path, mode)
         file === nothing || return file
         Base.wait(t) # sleep for a bit before trying again
-        if stale_age > 0 && stale_pidfile(path, stale_age)
+        if stale_age > 0 && stale_pidfile(path, stale_age, refresh)
             # if the file seems stale, try to remove it before attempting again
             # set stale_age to zero so we won't attempt again, even if the attempt fails
             stale_age -= stale_age
diff --git a/stdlib/FileWatching/test/pidfile.jl b/stdlib/FileWatching/test/pidfile.jl
index c2cb0c88a1b1e..3464a24175632 100644
--- a/stdlib/FileWatching/test/pidfile.jl
+++ b/stdlib/FileWatching/test/pidfile.jl
@@ -203,18 +203,33 @@ end
 
 @assert !ispath("pidfile")
 @testset "open_exclusive: break lock" begin
-    # test for stale_age
-    t = @elapsed f = open_exclusive("pidfile", poll_interval=3, stale_age=10)::File
-    try
-        write_pidfile(f, getpid())
-    finally
+    @testset "using stale_age without lock refreshing" begin
+        t = @elapsed f = open_exclusive("pidfile", poll_interval=3, stale_age=10, refresh=0)::File
+        try
+            write_pidfile(f, getpid())
+        finally
+            close(f)
+        end
+        @test t < 2
+        t = @elapsed f = open_exclusive("pidfile", poll_interval=3, stale_age=1, refresh=0)::File
         close(f)
+        @test 20 < t < 50
+        rm("pidfile")
+    end
+
+    @testset "using stale_age with lock refreshing on (default)" begin
+        t = @elapsed f = open_exclusive("pidfile", poll_interval=3, stale_age=10)::File
+        try
+            write_pidfile(f, getpid())
+        finally
+            close(f)
+        end
+        @test t < 2
+        t = @elapsed f = open_exclusive("pidfile", poll_interval=3, stale_age=5)::File
+        close(f)
+        @test 20 < t < 50
+        rm("pidfile")
     end
-    @test t < 2
-    t = @elapsed f = open_exclusive("pidfile", poll_interval=3, stale_age=1)::File
-    close(f)
-    @test 20 < t < 50
-    rm("pidfile")
 
     t = @elapsed f = open_exclusive("pidfile", poll_interval=3, stale_age=10)::File
     close(f)

From d5cde522e2274ea8dddd93c3ee224a1e5d7cfe96 Mon Sep 17 00:00:00 2001
From: "Viral B. Shah" <ViralBShah@users.noreply.github.com>
Date: Mon, 16 Oct 2023 16:16:08 -0400
Subject: [PATCH 0010/1315] Bump SparseArrays to pull in SuiteSparse 7.2.1
 (#51725)

Upgrade SuiteSparse to 7.2.1
Upgrade SparseArrays.jl to the latest master

---------

Co-authored-by: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 deps/checksums/suitesparse                    | 70 +++++++++----------
 deps/libsuitesparse.mk                        |  2 +-
 deps/libsuitesparse.version                   |  5 +-
 stdlib/SparseArrays.version                   |  2 +-
 stdlib/SuiteSparse_jll/Project.toml           |  4 +-
 11 files changed, 44 insertions(+), 45 deletions(-)
 delete mode 100644 deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/sha512
 create mode 100644 deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/sha512
 create mode 100644 deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
 create mode 100644 deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/md5 b/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/md5
deleted file mode 100644
index 91cf02d3d1d50..0000000000000
--- a/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-69978c0844e0b4e780ae98c491e2fef4
diff --git a/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/sha512 b/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/sha512
deleted file mode 100644
index 45782edfc0689..0000000000000
--- a/deps/checksums/SparseArrays-0f8bbdac9c2d805f32faed90f4d8b8c8514aa478.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-96391c3e79cc7eb580c7f61814c808110b5b1f5f65135509bf55fcd93c007257a126c6511fa97975d88cacec1d2c0722c2cc66b43f974278375ef976870af63c
diff --git a/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/md5 b/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/md5
new file mode 100644
index 0000000000000..12314ebe27beb
--- /dev/null
+++ b/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/md5
@@ -0,0 +1 @@
+6427ffc68076c0555b0d3a02eaf88160
diff --git a/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/sha512 b/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/sha512
new file mode 100644
index 0000000000000..5c7602b6707cc
--- /dev/null
+++ b/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/sha512
@@ -0,0 +1 @@
+7a4c6dae45b739bb1b22c53c8b2b32fc765995767580338218a99f671749bbd5c5d9b61f45718c3b80e153b524737501141481ede2a6f24856de1c028f07ad3a
diff --git a/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5 b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
new file mode 100644
index 0000000000000..2f81a0d9191b5
--- /dev/null
+++ b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
@@ -0,0 +1 @@
+46541001073d1c3c85e18d910f8308f3
diff --git a/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512 b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512
new file mode 100644
index 0000000000000..e2eb44845e276
--- /dev/null
+++ b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512
@@ -0,0 +1 @@
+f7470a447b934ca9315e216a07b97e363f11bc93186f9aa057b20b2d05092c58ae4f1b733de362de4a0730861c00be4ca5588d0b3ba65f018c1798b9122b9672
diff --git a/deps/checksums/suitesparse b/deps/checksums/suitesparse
index ad571d8be1f28..7578826fe3f0e 100644
--- a/deps/checksums/suitesparse
+++ b/deps/checksums/suitesparse
@@ -1,36 +1,34 @@
-SuiteSparse-7.2.0.tar.gz/md5/a751b1161f03eb6bd8bd7b9c9be74b67
-SuiteSparse-7.2.0.tar.gz/sha512/62fc796a77f2a8c95cd688a4fa0e39c19d7ccfafde7a6623d62ca6928cee68ac9863a0f721959a1d5a07e62888ab621a4b1cb4f63371f4ac10f4ffe513241340
-SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5/46541001073d1c3c85e18d910f8308f3
-SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512/f7470a447b934ca9315e216a07b97e363f11bc93186f9aa057b20b2d05092c58ae4f1b733de362de4a0730861c00be4ca5588d0b3ba65f018c1798b9122b9672
-SuiteSparse.v7.2.0+1.aarch64-apple-darwin.tar.gz/md5/1a10261e5bed293a66849c7a50605a1c
-SuiteSparse.v7.2.0+1.aarch64-apple-darwin.tar.gz/sha512/11ecce872aac1f30a3d4ce870920ebb03c7828d0fd740c3789d3f65c3f91ed3682372e9807b0593e2850ae9024450306451ee2e03866afee16b4169e4b5de1c6
-SuiteSparse.v7.2.0+1.aarch64-linux-gnu.tar.gz/md5/65e2e7ae54e94e00b306d17a1d08ed34
-SuiteSparse.v7.2.0+1.aarch64-linux-gnu.tar.gz/sha512/7714598448c6f98a7d931822f9ddb661a903342d4c8384648c1b7457511794ff95ad64266c9377a4a5856dcb1fb8864cb05eab1c7787fca58802473270313570
-SuiteSparse.v7.2.0+1.aarch64-linux-musl.tar.gz/md5/95eb68e02c04d075d6ecc974c3b44457
-SuiteSparse.v7.2.0+1.aarch64-linux-musl.tar.gz/sha512/1d7835106cd5baef701a3b670778a757d97ab9933f7da909e1e5521150f7e44bee30cf4dc7c1e9f57731366db0fca1b91d1cdfddbc53b7cc7457ca11534be6d7
-SuiteSparse.v7.2.0+1.armv6l-linux-gnueabihf.tar.gz/md5/5f627cc9c9d4d70e2f0d749e09926b1a
-SuiteSparse.v7.2.0+1.armv6l-linux-gnueabihf.tar.gz/sha512/5ae4b79b418b45d954bfb578ac384afd6fff10a602d16d8b503997ba15251a7db0e12da66061ffd27c23b7459ff56b4a5d200c7c8aaa4a33c608a88752535c15
-SuiteSparse.v7.2.0+1.armv6l-linux-musleabihf.tar.gz/md5/61b5ee7e2b50665caf15e7c4f7353048
-SuiteSparse.v7.2.0+1.armv6l-linux-musleabihf.tar.gz/sha512/854c0165bceeb8202aeeaa16e6ba1f643e8cb9bf0561816cf2c44d1c7334ba7c376ee9e9085316439ca7e27dd4e37814f4916382096a5889c6bb656d22a7fb8d
-SuiteSparse.v7.2.0+1.armv7l-linux-gnueabihf.tar.gz/md5/618b9687ce30e630a52f72a8f34cfb9f
-SuiteSparse.v7.2.0+1.armv7l-linux-gnueabihf.tar.gz/sha512/add77a8842faf6515d94dc1d000784247d13f0211a9bb3f98edbc65b5f8994c0101940875fa050ca7a4605aaf33ec14daeaaf6b837673b3b4c600d4c5c0f4876
-SuiteSparse.v7.2.0+1.armv7l-linux-musleabihf.tar.gz/md5/b84d7f98b953772517689478d6bfc121
-SuiteSparse.v7.2.0+1.armv7l-linux-musleabihf.tar.gz/sha512/2c461eb23194bf61d3166abd8eb308dc643d865ff07466a88a580aa5a040f3c4fbfeadf7c78e1a3ce737fe0602909ff2b25be439741d36a780a260ccfdc6ed83
-SuiteSparse.v7.2.0+1.i686-linux-gnu.tar.gz/md5/3a38deddb5c1952584782378892d9579
-SuiteSparse.v7.2.0+1.i686-linux-gnu.tar.gz/sha512/5d6a9090c1c275c2bdcdc8d510c6372913109c1a775819354922c0d0afc2bc13a27950ed0e8cb8e05bc94d245220e322d93879054e5082814b7796b305981987
-SuiteSparse.v7.2.0+1.i686-linux-musl.tar.gz/md5/8076c50a73ab08ce0b9374956c2dbf29
-SuiteSparse.v7.2.0+1.i686-linux-musl.tar.gz/sha512/e54bcfe7eb9b266514a35a3c48676b7a792b59830e44bfcd5dfcf35be790f534cc31bd2e63ce4da1a22fcb3b0afb0ebebcc94f0e596806d6e832c3f68195cc5b
-SuiteSparse.v7.2.0+1.i686-w64-mingw32.tar.gz/md5/45ac2448ac7a1a9c67114ea58e8ceacf
-SuiteSparse.v7.2.0+1.i686-w64-mingw32.tar.gz/sha512/ed65a4071144c0096dfa768f26fd6216d4554c606a981658675d42f201865032972d9ce252dca5dc8a4a7ab0e33411c77bba9287e8013bdb0907ed6cb63d576f
-SuiteSparse.v7.2.0+1.powerpc64le-linux-gnu.tar.gz/md5/64845ee8bb2f3f44a0837297e47e412d
-SuiteSparse.v7.2.0+1.powerpc64le-linux-gnu.tar.gz/sha512/5f935e497db4ebbcdfb96603a7ee9c6c520d7f4df04f65952305ceff4271ab637079e9144b98044c5f159b4bed0963df8c95ed1578d2828f1a2356e6d34d7042
-SuiteSparse.v7.2.0+1.x86_64-apple-darwin.tar.gz/md5/fb8b00d4ca63004fe8ab8c159128e01f
-SuiteSparse.v7.2.0+1.x86_64-apple-darwin.tar.gz/sha512/bcfb18c11be4b1147ff857e2ad0c881c9fc4ae16db8e88fb6e7e0448418c1fc4bff9ea8f1e6aa7202c277273c44c1afb3cc6c2bfcaa0735c7c09052f033248c7
-SuiteSparse.v7.2.0+1.x86_64-linux-gnu.tar.gz/md5/043594ee1cb90fd47b36acfa829fffb8
-SuiteSparse.v7.2.0+1.x86_64-linux-gnu.tar.gz/sha512/6a5bb3c85bb7e97b915f7dd40e8be1ed1bbbd5c756ef510deaecc8505b95bd42f3662f82e25c80055947060e0429e2ce427d4ff67b434acbe28d46b88279c65f
-SuiteSparse.v7.2.0+1.x86_64-linux-musl.tar.gz/md5/67c6d3a7fd8635a43bd86b2b1e986978
-SuiteSparse.v7.2.0+1.x86_64-linux-musl.tar.gz/sha512/d46be3f60102fc69707c3e7cc3d693c7ecb4d4307c636afde61e5fab3c46fcf32564716a11d2cfe47b4e541422d5b6e13fbcc3e8749764527b4f4132e8ce17fc
-SuiteSparse.v7.2.0+1.x86_64-unknown-freebsd.tar.gz/md5/124057f8455c9710fd1e6b4b4b469fb0
-SuiteSparse.v7.2.0+1.x86_64-unknown-freebsd.tar.gz/sha512/da0e56a8b1cf3967275cb64aea0b939d8982392f9ca1c3b268607e37c0b9bebbd456172c507c6dc2293989a0fe8df04ba1fea67442a4bb738cc8d894bea457a5
-SuiteSparse.v7.2.0+1.x86_64-w64-mingw32.tar.gz/md5/0f99c67d25c0fdd0f3c3e11f18925c43
-SuiteSparse.v7.2.0+1.x86_64-w64-mingw32.tar.gz/sha512/32fcd894cb4197970aa311f7bd12ccb91df7bbe27e389e793a2d3565c9c5c36c751f6dfa37e155cd2c2245be52f0a872dba032b78dc45c45d3fd7d7f2eeb773e
+SuiteSparse-7.2.1.tar.gz/md5/c341b4b2943b6d99ec147dc36ae64d51
+SuiteSparse-7.2.1.tar.gz/sha512/6385b699d2f109e8473bb58e95705671b8a5c2f1b281d17bba9f396a94b2e783700c4c64f4ab9495a4a64e23ba279052616054045783b4b8c8eb28a8f4f6be28
+SuiteSparse.v7.2.1+1.aarch64-apple-darwin.tar.gz/md5/1bd9c850b5bb6de56f4dfd0633ce7a6c
+SuiteSparse.v7.2.1+1.aarch64-apple-darwin.tar.gz/sha512/f0e932fa2b6d2843fd75c1e151b8304ed2521b679c732301877495d9a2437ec693ba0ebaaf52cb3a4f5c01bcd8c972a27b1080071c9c77462901fa4dec7de787
+SuiteSparse.v7.2.1+1.aarch64-linux-gnu.tar.gz/md5/ff52a5ef6546bbea2ce2d73db2821522
+SuiteSparse.v7.2.1+1.aarch64-linux-gnu.tar.gz/sha512/f5c2a54e40b36fc0489140397e6324bbd1050a87949fd9be3837012825c3becbef66258d28c286d0c45b0447361b2ddf736370402ed928b909e0fb7c5f4ee69c
+SuiteSparse.v7.2.1+1.aarch64-linux-musl.tar.gz/md5/2baa4103f4070f66d6278fc001317372
+SuiteSparse.v7.2.1+1.aarch64-linux-musl.tar.gz/sha512/17bc9b020850d9cc652d49987c3faa57204ed3beecd04ea812fd03b4f60f541ba7b250fa70c801a8ec3c440f3562a4771a3742299f0d4eb770e58010c43a3823
+SuiteSparse.v7.2.1+1.armv6l-linux-gnueabihf.tar.gz/md5/cdc1c60e50f6551a52e57ac71440564a
+SuiteSparse.v7.2.1+1.armv6l-linux-gnueabihf.tar.gz/sha512/9209f86ac97c061755169412565055847be4890140a389a92468297507cee240219d910bbcef94c52926771a4152762cfa05cfa33c26d31351d68265e5719bd3
+SuiteSparse.v7.2.1+1.armv6l-linux-musleabihf.tar.gz/md5/cd5e177e660d793426e4c4aeb2f9269c
+SuiteSparse.v7.2.1+1.armv6l-linux-musleabihf.tar.gz/sha512/a8a5ca739999a16336b2c98ec88873e00349720b5d966d643d5665338b1f9c8077352d87fac41a165cb65793ae5fb686e954b3eaa3f751aa8d002388a0ce6a13
+SuiteSparse.v7.2.1+1.armv7l-linux-gnueabihf.tar.gz/md5/eb43136009b370e93c6ab4c1b0eec40c
+SuiteSparse.v7.2.1+1.armv7l-linux-gnueabihf.tar.gz/sha512/e20a308911a36037c9b6da3c060f8624b1ff84b0e23cbd62189f62e989f6a5307b07a6286d95459e0886a8d16fd59ad5a34607dd2c644f7bedc786dd6567670c
+SuiteSparse.v7.2.1+1.armv7l-linux-musleabihf.tar.gz/md5/19f9246fc6c8bd2c7a4d2df498725abe
+SuiteSparse.v7.2.1+1.armv7l-linux-musleabihf.tar.gz/sha512/d2cba310fe33ddb11d9ada37ce04905dfc3f058a1cbf7b53ca1dc31c2c51bcf930a4976c39d55bfdacb19195ff772acb1c6876238640a6ed6277777934a8b53f
+SuiteSparse.v7.2.1+1.i686-linux-gnu.tar.gz/md5/8ff91e530528c8761411b8d9be56d1f0
+SuiteSparse.v7.2.1+1.i686-linux-gnu.tar.gz/sha512/42bd937fb1c476164b923b5093d3df3fc3cdd4e3bc148616ba48027d4616479d674a4c8f7291cf7004a43834508b459630f4cafbd90850d10402d53faa34e714
+SuiteSparse.v7.2.1+1.i686-linux-musl.tar.gz/md5/49bc8f22a227748680734d89f64a4cf7
+SuiteSparse.v7.2.1+1.i686-linux-musl.tar.gz/sha512/b78b84d330a8f22e7d9fdd72fe621e9830c1afd908946d4101705f05546aa892b2f5ef87988dec39ccd81cbe4dbeb95adc277d096d60e106485c5b6f81cf4403
+SuiteSparse.v7.2.1+1.i686-w64-mingw32.tar.gz/md5/cd593a3c801ba72bf6d77788c7ca06b9
+SuiteSparse.v7.2.1+1.i686-w64-mingw32.tar.gz/sha512/0b49795ed5cb773a5930d305e65d53ff35ff1d1ee0a84e8762f56ca442c2421752b50b667646fd6a977c0684c2214996011f405ff1c7fd6eeaf16d08262d7d05
+SuiteSparse.v7.2.1+1.powerpc64le-linux-gnu.tar.gz/md5/3858c87b8f62844520ff61c72d7b5a25
+SuiteSparse.v7.2.1+1.powerpc64le-linux-gnu.tar.gz/sha512/ea505fe14155ee69a715339fe7075603c04458d5c7f65fecb92bea69a86117b1d21da75dab832ac0f6cc9aa64bfa6d7f50cb679fefa9ec5b4d4d8826d3137ff9
+SuiteSparse.v7.2.1+1.x86_64-apple-darwin.tar.gz/md5/241dec5338e04fbf6084cec90bbd2f76
+SuiteSparse.v7.2.1+1.x86_64-apple-darwin.tar.gz/sha512/8477d2102be709aa2f74325df91aab4f9c894c8f516cd17d3780aab66bcbf920fa5771fa7e130a63793f94b99c6cfc4db6ab22e6a33a55670e25e36472770d59
+SuiteSparse.v7.2.1+1.x86_64-linux-gnu.tar.gz/md5/c6b6fa99a21a9000892d51b821f304a7
+SuiteSparse.v7.2.1+1.x86_64-linux-gnu.tar.gz/sha512/ad2e1200d0418c531758672b64e849c81cfe74ca73cff0e1a47797e73dbc4675c9a2ec855af628dddef58b135412d06fa18c15565c94de5e1e6d15e3b150ecbd
+SuiteSparse.v7.2.1+1.x86_64-linux-musl.tar.gz/md5/6c14129471a9c92464d36ae00f4c5a08
+SuiteSparse.v7.2.1+1.x86_64-linux-musl.tar.gz/sha512/e9051ceb7d551019deb16480b493d1ac5b622fe86c7e19b1023eb12af28d42f25e911e1e44870c35849d8f95d78e8e28c38699cde1fab250dac32818ebc58a2b
+SuiteSparse.v7.2.1+1.x86_64-unknown-freebsd.tar.gz/md5/ab0f6a9b7789f21aba5ea10659b03ed3
+SuiteSparse.v7.2.1+1.x86_64-unknown-freebsd.tar.gz/sha512/cc9136bfda474914107e68f97a200d46f81a1f36ea51c4e482ef04e818d3ac10d14b2895eef59b2570f6115261e987bd076dd8f9be0e6d2dc77931d3257db142
+SuiteSparse.v7.2.1+1.x86_64-w64-mingw32.tar.gz/md5/e804d9ed593d739326865dc1f60d5800
+SuiteSparse.v7.2.1+1.x86_64-w64-mingw32.tar.gz/sha512/20c9ac62cd41b19e0b9605c8f9a8bece9089f7f69e2cf57ace3058215acefe8cf9ce39d3c05010223443bfc45b1efb8391be677a1b5e9a59bbdfe89f89553f71
diff --git a/deps/libsuitesparse.mk b/deps/libsuitesparse.mk
index 10161f08ecf5b..fa1eda94b5c4f 100644
--- a/deps/libsuitesparse.mk
+++ b/deps/libsuitesparse.mk
@@ -29,7 +29,7 @@ LIBSUITESPARSE_CMAKE_FLAGS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
 endif
 
 $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER).tar.gz: | $(SRCCACHE)
-	$(JLDOWNLOAD) $@ https://github.com/Wimmerer/SuiteSparse/archive/v$(LIBSUITESPARSE_VER).tar.gz
+	$(JLDOWNLOAD) $@ https://github.com/DrTimothyAldenDavis/SuiteSparse/archive/v$(LIBSUITESPARSE_VER).tar.gz
 
 $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER).tar.gz
 	$(JLCHECKSUM) $<
diff --git a/deps/libsuitesparse.version b/deps/libsuitesparse.version
index 867e52304477c..eea10d4f2beb8 100644
--- a/deps/libsuitesparse.version
+++ b/deps/libsuitesparse.version
@@ -2,6 +2,5 @@
 LIBSUITESPARSE_JLL_NAME := SuiteSparse
 
 ## source build
-LIBSUITESPARSE_VER := 7.2.0
-LIBSUITESPARSE_BRANCH=guard-CXX_Standard
-LIBSUITESPARSE_SHA1=1b4edf467637dbf33a26eee9a6c20afa40c7c5ea
+LIBSUITESPARSE_VER := 7.2.1
+LIBSUITESPARSE_SHA1=d6c84f7416eaee0d23d61c6c49ad1b73235d2ea2
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 91a67c5bddc9f..10357d46ab030 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 0f8bbdac9c2d805f32faed90f4d8b8c8514aa478
+SPARSEARRAYS_SHA1 = 3582898a4efd3f504d39076f5a162b9ed1ebcdb2
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1
diff --git a/stdlib/SuiteSparse_jll/Project.toml b/stdlib/SuiteSparse_jll/Project.toml
index 6c23952e5c6b6..ccd1d06d9a7bb 100644
--- a/stdlib/SuiteSparse_jll/Project.toml
+++ b/stdlib/SuiteSparse_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "SuiteSparse_jll"
 uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
-version = "7.2.0+1"
+version = "7.2.1+1"
 
 [deps]
 libblastrampoline_jll = "8e850b90-86db-534c-a0d3-1478176c7d93"
@@ -9,7 +9,7 @@ Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 
 [compat]
-julia = "1.9"
+julia = "1.10"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

From ab94a242f6e56438f86a1babab7721db45b7feed Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 16 Oct 2023 17:15:25 -0400
Subject: [PATCH 0011/1315] clean up identifiers defined in `Main` (#51411)

Loaded packages do not need explicit bindings, and the name
`MainInclude` does not need to be visible.

I noticed that `Main` tab completes to `MainInclude`, which is not great
since it's an implementation detail. It's also a bit messy that
`InteractiveUtils` appears in `varinfo()`. This is not necessary to
access its functionality.

The only behavior change from this is that adding a method to `include`
or `eval` in Main used to work since these were explicitly imported.
This now gives the "must be explicitly imported to be extended" error,
which I consider a big improvement. Nobody should be doing that anyway.
---
 base/client.jl          | 19 +++++++------------
 base/sysimg.jl          |  7 +++----
 stdlib/REPL/src/REPL.jl |  2 +-
 3 files changed, 11 insertions(+), 17 deletions(-)

diff --git a/base/client.jl b/base/client.jl
index 69f35d3fdd4fc..5e7cd19ea480f 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -261,8 +261,8 @@ function exec_options(opts)
     distributed_mode = (opts.worker == 1) || (opts.nprocs > 0) || (opts.machine_file != C_NULL)
     if distributed_mode
         let Distributed = require(PkgId(UUID((0x8ba89e20_285c_5b6f, 0x9357_94700520ee1b)), "Distributed"))
-            Core.eval(Main, :(const Distributed = $Distributed))
-            Core.eval(Main, :(using .Distributed))
+            Core.eval(MainInclude, :(const Distributed = $Distributed))
+            Core.eval(Main, :(using Base.MainInclude.Distributed))
         end
 
         invokelatest(Main.Distributed.process_opts, opts)
@@ -380,19 +380,18 @@ _atreplinit(repl) = invokelatest(__atreplinit, repl)
 
 function load_InteractiveUtils(mod::Module=Main)
     # load interactive-only libraries
-    if !isdefined(mod, :InteractiveUtils)
+    if !isdefined(MainInclude, :InteractiveUtils)
         try
             let InteractiveUtils = require(PkgId(UUID(0xb77e0a4c_d291_57a0_90e8_8db25a27a240), "InteractiveUtils"))
-                Core.eval(mod, :(const InteractiveUtils = $InteractiveUtils))
-                Core.eval(mod, :(using .InteractiveUtils))
-                return InteractiveUtils
+                Core.eval(MainInclude, :(const InteractiveUtils = $InteractiveUtils))
             end
         catch ex
             @warn "Failed to import InteractiveUtils into module $mod" exception=(ex, catch_backtrace())
+            return nothing
         end
-        return nothing
     end
-    return getfield(mod, :InteractiveUtils)
+    Core.eval(mod, :(using Base.MainInclude.InteractiveUtils))
+    return MainInclude.InteractiveUtils
 end
 
 function load_REPL()
@@ -511,10 +510,6 @@ A variable referring to the last thrown errors, automatically imported to the in
 The thrown errors are collected in a stack of exceptions.
 """
 global err = nothing
-
-# weakly exposes ans and err variables to Main
-export ans, err
-
 end
 
 """
diff --git a/base/sysimg.jl b/base/sysimg.jl
index 1bdbe60479e91..bf8de0bc3f75e 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -4,10 +4,6 @@ Core.include(Main, "Base.jl")
 
 using .Base
 
-# Set up Main module
-using Base.MainInclude # ans, err, and sometimes Out
-import Base.MainInclude: eval, include
-
 # Ensure this file is also tracked
 pushfirst!(Base._included_files, (@__MODULE__, abspath(@__FILE__)))
 
@@ -78,7 +74,10 @@ let
     empty!(LOAD_PATH)
     Base.init_load_path() # want to be able to find external packages in userimg.jl
 
+    # Set up Main module
     ccall(:jl_clear_implicit_imports, Cvoid, (Any,), Main)
+    eval(Main, :(using Base.MainInclude: eval, include, ans, err))
+
     tot_time_userimg = @elapsed (isfile("userimg.jl") && Base.include(Main, "userimg.jl"))
 
     tot_time_base = (Base.end_base_include - Base.start_base_include) * 10.0^(-9)
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index 25b2ff00602d6..fe324345a3e17 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -1490,8 +1490,8 @@ function capture_result(n::Ref{Int}, @nospecialize(x))
     mod = Base.MainInclude
     if !isdefined(mod, :Out)
         @eval mod global Out
-        @eval mod export Out
         setglobal!(mod, :Out, Dict{Int, Any}())
+        @eval Main using Base.MainInclude: Out
     end
     if x !== getglobal(mod, :Out) && x !== nothing # remove this?
         getglobal(mod, :Out)[n] = x

From bbcbac9752ad54faf960fa26d2f105fc8ae7771e Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 16 Oct 2023 17:16:45 -0400
Subject: [PATCH 0012/1315] support `public` in fallback/legacy parser (#51575)

---
 base/exports.jl      | 117 +++++++++++++++++++++----------------------
 src/ast.scm          |   2 +-
 src/jlfrontend.scm   |   2 +-
 src/julia-parser.scm |  21 ++++++--
 test/syntax.jl       |  23 +++++++++
 5 files changed, 99 insertions(+), 66 deletions(-)

diff --git a/base/exports.jl b/base/exports.jl
index de9e2b8cf1b93..81296f7d34b18 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1072,83 +1072,82 @@ export
 
     @main
 
-# TODO: use normal syntax once JuliaSyntax.jl becomes available at this point in bootstrapping
-eval(Expr(:public,
+public
 # Modules
-    :Checked,
-    :Filesystem,
-    :Order,
-    :Sort,
+    Checked,
+    Filesystem,
+    Order,
+    Sort,
 
 # Types
-    :AbstractLock,
-    :AsyncCondition,
-    :CodeUnits,
-    :Event,
-    :Fix1,
-    :Fix2,
-    :Generator,
-    :ImmutableDict,
-    :OneTo,
-    :UUID,
+    AbstractLock,
+    AsyncCondition,
+    CodeUnits,
+    Event,
+    Fix1,
+    Fix2,
+    Generator,
+    ImmutableDict,
+    OneTo,
+    UUID,
 
 # Semaphores
-    :Semaphore,
-    :acquire,
-    :release,
+    Semaphore,
+    acquire,
+    release,
 
 # collections
-    :IteratorEltype,
-    :IteratorSize,
-    :to_index,
-    :vect,
-    :isdone,
-    :front,
-    :rest,
-    :split_rest,
-    :tail,
-    :checked_length,
+    IteratorEltype,
+    IteratorSize,
+    to_index,
+    vect,
+    isdone,
+    front,
+    rest,
+    split_rest,
+    tail,
+    checked_length,
 
 # Loading
-    :DL_LOAD_PATH,
-    :load_path,
-    :active_project,
+    DL_LOAD_PATH,
+    load_path,
+    active_project,
 
 # Reflection and introspection
-    :isambiguous,
-    :isexpr,
-    :isidentifier,
-    :issingletontype,
-    :identify_package,
-    :locate_package,
-    :moduleroot,
-    :jit_total_bytes,
-    :summarysize,
-    :isexported,
-    :ispublic,
+    isambiguous,
+    isexpr,
+    isidentifier,
+    issingletontype,
+    identify_package,
+    locate_package,
+    moduleroot,
+    jit_total_bytes,
+    summarysize,
+    isexported,
+    ispublic,
 
 # Opperators
-    :operator_associativity,
-    :operator_precedence,
-    :isbinaryoperator,
-    :isoperator,
-    :isunaryoperator,
+    operator_associativity,
+    operator_precedence,
+    isbinaryoperator,
+    isoperator,
+    isunaryoperator,
 
 # C interface
-    :cconvert,
-    :unsafe_convert,
+    cconvert,
+    unsafe_convert,
 
 # Error handling
-    :exit_on_sigint,
-    :windowserror,
+    exit_on_sigint,
+    windowserror,
 
 # Macros
-    Symbol("@assume_effects"),
-    Symbol("@constprop"),
-    Symbol("@locals"),
-    Symbol("@propagate_inbounds"),
+    @assume_effects,
+    @constprop,
+    @locals,
+    @propagate_inbounds,
 
 # misc
-    :notnothing,
-    :runtests,
-    :text_colors))
+    notnothing,
+    runtests,
+    text_colors
diff --git a/src/ast.scm b/src/ast.scm
index 87db8449b3992..abfce314fc569 100644
--- a/src/ast.scm
+++ b/src/ast.scm
@@ -249,7 +249,7 @@
            ;; misc syntax forms
            ((import using)
             (string (car e) " " (string.join (map deparse-import-path (cdr e)) ", ")))
-           ((global local export) (string (car e) " " (string.join (map deparse (cdr e)) ", ")))
+           ((global local export public) (string (car e) " " (string.join (map deparse (cdr e)) ", ")))
            ((const)        (string "const " (deparse (cadr e))))
            ((top)          (deparse (cadr e)))
            ((core)         (string "Core." (deparse (cadr e))))
diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index 23c3acf7973c7..34a8f5405676a 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -140,7 +140,7 @@
 
 (define (toplevel-only-expr? e)
   (and (pair? e)
-       (or (memq (car e) '(toplevel line module import using export
+       (or (memq (car e) '(toplevel line module import using export public
                                     error incomplete))
            (and (memq (car e) '(global const)) (every symbol? (cdr e))))))
 
diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index 210ba8f0ae07b..fb20717add65d 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -716,7 +716,7 @@
 
 ;; ";" at the top level produces a sequence of top level expressions
 (define (parse-stmts s)
-  (let ((ex (parse-Nary s (lambda (s) (parse-docstring s parse-eq))
+  (let ((ex (parse-Nary s (lambda (s) (parse-public s parse-eq))
                         '(#\;) 'toplevel (lambda (x) (eqv? x #\newline)) #f)))
     ;; check for unparsed junk after an expression
     (let ((t (peek-token s)))
@@ -1608,18 +1608,18 @@
        ((module baremodule)
         (let* ((name (parse-unary-prefix s))
                (loc  (line-number-node s))
-               (body (parse-block s (lambda (s) (parse-docstring s parse-eq)))))
+               (body (parse-block s (lambda (s) (parse-public s parse-eq)))))
           (if (reserved-word? name)
               (error (string "invalid module name \"" name "\"")))
           (expect-end s word)
           (list 'module (if (eq? word 'module) '(true) '(false)) name
                 `(block ,loc ,@(cdr body)))))
-       ((export)
+       ((export public)
         (let ((es (map macrocall-to-atsym
                        (parse-comma-separated s parse-unary-prefix))))
           (if (not (every symbol-or-interpolate? es))
-              (error "invalid \"export\" statement"))
-          `(export ,@es)))
+              (error (string "invalid \"" word "\" statement")))
+          `(,word ,@es)))
        ((import using)
         (parse-imports s word))
        ((do)
@@ -2664,6 +2664,17 @@
            ;; string interpolation
            (eq? (car e) 'string))))
 
+(define (parse-public s production)
+  (if (eq? (peek-token s) 'public)
+      (let ((spc (ts:space? s)))
+        (take-token s)
+        (if (memv (peek-token s) '(#\( = #\[))
+            (begin ;; TODO: deprecation warning here
+                   (ts:put-back! s 'public spc)
+                   (parse-docstring s production))
+            (parse-resword s 'public)))
+      (parse-docstring s production)))
+
 (define (parse-docstring s production)
   (let ((startloc (line-number-node s)) ; be sure to use the line number from the head of the docstring
         (ex       (production s)))
diff --git a/test/syntax.jl b/test/syntax.jl
index 17ade72112ec0..f6b66d4882021 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -3536,3 +3536,26 @@ end
 @test_throws ErrorException("syntax: Attempted to use slot marked unused") @eval function funused50518(::Float64)
     $(Symbol("#unused#"))
 end
+
+@testset "public keyword" begin
+    p(str) = Base.remove_linenums!(Meta.parse(str))
+    # tests ported from JuliaSyntax.jl
+    @test p("function f(public)\n    public + 3\nend") == Expr(:function, Expr(:call, :f, :public), Expr(:block, Expr(:call, :+, :public, 3)))
+    @test p("public A, B") == Expr(:public, :A, :B)
+    @test p("if true \n public *= 4 \n end") == Expr(:if, true, Expr(:block, Expr(:*=, :public, 4)))
+    @test p("module Mod\n public A, B \n end") == Expr(:module, true, :Mod, Expr(:block, Expr(:public, :A, :B)))
+    @test p("module Mod2\n a = 3; b = 6; public a, b\n end") == Expr(:module, true, :Mod2, Expr(:block, Expr(:(=), :a, 3), Expr(:(=), :b, 6), Expr(:public, :a, :b)))
+    @test p("a = 3; b = 6; public a, b") == Expr(:toplevel, Expr(:(=), :a, 3), Expr(:(=), :b, 6), Expr(:public, :a, :b))
+    @test_throws Meta.ParseError p("begin \n public A, B \n end")
+    @test_throws Meta.ParseError p("if true \n public A, B \n end")
+    @test_throws Meta.ParseError p("public export=true foo, bar")
+    @test_throws Meta.ParseError p("public experimental=true foo, bar")
+    @test p("public(x::String) = false") == Expr(:(=), Expr(:call, :public, Expr(:(::), :x, :String)), Expr(:block, false))
+    @test p("module M; export @a; end") == Expr(:module, true, :M, Expr(:block, Expr(:export, :var"@a")))
+    @test p("module M; public @a; end") == Expr(:module, true, :M, Expr(:block, Expr(:public, :var"@a")))
+    @test p("module M; export ⤈; end") == Expr(:module, true, :M, Expr(:block, Expr(:export, :⤈)))
+    @test p("module M; public ⤈; end") == Expr(:module, true, :M, Expr(:block, Expr(:public, :⤈)))
+    @test p("public = 4") == Expr(:(=), :public, 4)
+    @test p("public[7] = 5") == Expr(:(=), Expr(:ref, :public, 7), 5)
+    @test p("public() = 6") == Expr(:(=), Expr(:call, :public), Expr(:block, 6))
+end

From d42415ae79613970ca366c207d478988b31332e6 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Tue, 17 Oct 2023 04:40:01 -0400
Subject: [PATCH 0013/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20b02fb9597=20to=20ffb6edf03=20(#51732)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: b02fb9597
New commit: ffb6edf03
Julia version: 1.11.0-DEV
Pkg version: 1.11.0
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/b02fb95979c71dc5834aad739ad61622cccf4a16...ffb6edf0306a651240b71641fb4aa5ab8cc7659b

```
$ git log --oneline b02fb9597..ffb6edf03
ffb6edf03 cache pidlock tweaks (#3654)
550eadd7e Pin registry for MetaGraph tests (#3666)
ee39026b8 Remove test that depends on Random being in the sysimg (#3656)
561508db2 CI: Increase the CI timeout. Update actions. Fix double precompilation. (#3665)
7c7ed63b1 Remove change UUID script it should be uncessary on Julia v1.11-dev (#3655)
a8648f7c8 Precompile: Fix algorithmic complexity of cycle detection (#3651)
0e0cf4514 Switch datastructure Vector -> Set for algorithmic complexity (#3652)
894cc3f78 respect if load-time precompile is disabled (#3648)
3ffd1cf73 Make auto GC message use printpkgstyle (#3633)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/md5     | 1 -
 .../Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/sha512  | 1 -
 .../Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5     | 1 +
 .../Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512

diff --git a/deps/checksums/Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/md5 b/deps/checksums/Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/md5
deleted file mode 100644
index 141318a4aa0eb..0000000000000
--- a/deps/checksums/Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-540f9de36245fc3d52ff40a97b4d73d9
diff --git a/deps/checksums/Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/sha512 b/deps/checksums/Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/sha512
deleted file mode 100644
index 4b2a864ef3951..0000000000000
--- a/deps/checksums/Pkg-b02fb95979c71dc5834aad739ad61622cccf4a16.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-207d82ea9f376c30e5d8680dfaf82f3a9f8f40789313e46fcedf3f6911608be2b6e7cb63ab115eb45549413ba03e2da0d08d5fadd47ed1b46d0a544877a67ce9
diff --git a/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5 b/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5
new file mode 100644
index 0000000000000..d0689b2900b94
--- /dev/null
+++ b/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5
@@ -0,0 +1 @@
+7debd8f3b98285c9837b6715fe2e1802
diff --git a/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512 b/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512
new file mode 100644
index 0000000000000..6b45b3b24cd68
--- /dev/null
+++ b/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512
@@ -0,0 +1 @@
+6f3b71ac68899c265d59edf3376f224f8a64b63ac0a9a08f05652789f9bc8e670365e0f0758c357b8a8bdf08a08c75c27f1d1a63d062795ae67793a686d4acfe
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index c39a6c331a37f..b5928ddf64786 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = b02fb95979c71dc5834aad739ad61622cccf4a16
+PKG_SHA1 = ffb6edf0306a651240b71641fb4aa5ab8cc7659b
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From ac7eecb24a3f7ed952ecd5274d18e9d2407c0701 Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Tue, 17 Oct 2023 12:46:23 +0200
Subject: [PATCH 0014/1315] Fix LinearAlgebra/diagonal test (#51733)

---
 stdlib/LinearAlgebra/test/diagonal.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 11d506cf64bf8..1b1aa37af2d31 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -792,7 +792,7 @@ end
     evecs = [ [[ 1/sqrt(2)+0im, 1/sqrt(2)*im ]]  [[ 1/sqrt(2)+0im, -1/sqrt(2)*im ]]  [[ 0.0, 0.0 ]]       [[ 0.0, 0.0 ]]      [[ 0.0, 0.0]];
               [[ 0.0, 0.0, 0.0 ]]                [[ 0.0, 0.0, 0.0 ]]                 [[ 1.0, 0.0, 0.0 ]]  [[ 0.0, 1.0, 0.0 ]] [[ 0.0, 0.0, 1.0]] ]
     @test eigD.values == evals
-    @test eigD.vectors == evecs
+    @test eigD.vectors ≈ evecs
     @test D * eigD.vectors ≈ eigD.vectors * Diagonal(eigD.values)
 end
 

From a0f16291a6d265437cad4e3a5a674b7b52999d9d Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Tue, 17 Oct 2023 13:30:24 +0200
Subject: [PATCH 0015/1315] docs: `Base.Order.Ordering`: consistency with
 #48363 and #48387 (#51683)

"Total order" -> "strict weak order".
---
 base/ordering.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/ordering.jl b/base/ordering.jl
index 13f5eceb2d4dc..36d8e90064eba 100644
--- a/base/ordering.jl
+++ b/base/ordering.jl
@@ -21,7 +21,8 @@ export # not exported by Base
 """
     Base.Order.Ordering
 
-Abstract type which represents a total order on some set of elements.
+Abstract type which represents a strict weak order on some set of elements. See
+[`sort!`](@ref) for more.
 
 Use [`Base.Order.lt`](@ref) to compare two elements according to the ordering.
 """

From 2e54092e0ebda81422d1a8239ad6dc9a9516b0d5 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Tue, 17 Oct 2023 08:31:23 -0300
Subject: [PATCH 0016/1315] Use currently unused LLVM statistics (#51685)

These variables missed being incremented
---
 src/jitlayers.cpp     | 1 +
 src/llvm-simdloop.cpp | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 42239ecf2de3c..e3f30f7d22d58 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1324,6 +1324,7 @@ namespace {
                         }
                     }
                 }
+                ++ModulesOptimized;
                 switch (PoolIdx) {
                     case 0:
                         ++OptO0;
diff --git a/src/llvm-simdloop.cpp b/src/llvm-simdloop.cpp
index 62fb26ac163a4..c4981c33f088d 100644
--- a/src/llvm-simdloop.cpp
+++ b/src/llvm-simdloop.cpp
@@ -191,7 +191,7 @@ static bool processLoop(Loop &L, OptimizationRemarkEmitter &ORE, ScalarEvolution
     LLVM_DEBUG(dbgs() << "LSL: simd: " << simd << " ivdep: " << ivdep << "\n");
     if (!simd && !ivdep)
         return false;
-
+    ++TotalMarkedLoops;
     LLVMContext &Context = L.getHeader()->getContext();
     LoopID = MDNode::get(Context, MDs);
     // Set operand 0 to refer to the loop id itself

From 214ac5185f5f6eb489fa6dbb0118508670f70d42 Mon Sep 17 00:00:00 2001
From: Eric Hanson <5846501+ericphanson@users.noreply.github.com>
Date: Tue, 17 Oct 2023 13:40:33 +0200
Subject: [PATCH 0017/1315] add `Printf.Format` and `Printf.format` to manual
 (#51723)

---
 stdlib/Printf/docs/src/index.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/stdlib/Printf/docs/src/index.md b/stdlib/Printf/docs/src/index.md
index 48e38e2b2ce5b..7a5bae778ea36 100644
--- a/stdlib/Printf/docs/src/index.md
+++ b/stdlib/Printf/docs/src/index.md
@@ -3,4 +3,6 @@
 ```@docs
 Printf.@printf
 Printf.@sprintf
+Printf.Format
+Printf.format
 ```

From 66cdf15f26a0dcd1dc0c4880e6491ccb9b95796c Mon Sep 17 00:00:00 2001
From: Justin Walker <2695841+just-walk@users.noreply.github.com>
Date: Tue, 17 Oct 2023 06:41:38 -0500
Subject: [PATCH 0018/1315] Add note in constructor doc about infix notation
 (#51610)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When reading the documentation---and later, when I was doing an Exercism
example implementing the complex numbers---it wasn't clear to me how
certain symbols could work as infix operators. The Julia documentation
uses ⊘ for rational division in its example, but it doesn't say why this
works for `1 ⊘ 2`. I just added a note to clarify this.
---
 doc/src/manual/constructors.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/src/manual/constructors.md b/doc/src/manual/constructors.md
index 6ec206dade335..27e2c9396c437 100644
--- a/doc/src/manual/constructors.md
+++ b/doc/src/manual/constructors.md
@@ -491,6 +491,7 @@ operator, which provides a syntax for writing rationals (e.g. `1 ⊘ 2`). Julia'
 type uses the [`//`](@ref) operator for this purpose. Before these definitions, `⊘`
 is a completely undefined operator with only syntax and no meaning. Afterwards, it behaves just
 as described in [Rational Numbers](@ref) -- its entire behavior is defined in these few lines.
+Note that the infix use of `⊘` works because Julia has a set of symbols that are recognized to be infix operators.
 The first and most basic definition just makes `a ⊘ b` construct a `OurRational` by applying the
 `OurRational` constructor to `a` and `b` when they are integers. When one of the operands of `⊘`
 is already a rational number, we construct a new rational for the resulting ratio slightly differently;

From 09dd7d7d0bd0e39d68acba9e2b86a84ddff02565 Mon Sep 17 00:00:00 2001
From: Benjamin Lorenz <benlorenz@users.noreply.github.com>
Date: Tue, 17 Oct 2023 14:44:29 +0200
Subject: [PATCH 0019/1315] REPL: remove 'oops.' for non Markdown help strings
 (#51734)

This was added in
https://github.com/JuliaLang/julia/pull/50105/files#diff-625b68d89f9d5b3eaa175971271a3cce315a0d1e0597d03c9ab0bd7a0b020648R196
---
 stdlib/REPL/src/docview.jl | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stdlib/REPL/src/docview.jl b/stdlib/REPL/src/docview.jl
index cc3a7fe980190..84323f2072b1e 100644
--- a/stdlib/REPL/src/docview.jl
+++ b/stdlib/REPL/src/docview.jl
@@ -193,7 +193,6 @@ function insert_internal_warning(md::Markdown.MD, internal_access::Set{Pair{Modu
     md
 end
 function insert_internal_warning(other, internal_access::Set{Pair{Module,Symbol}})
-    println("oops.")
     other
 end
 

From 4d2d8490bdee8f457948b949441e95a69a775217 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 17 Oct 2023 19:03:23 +0530
Subject: [PATCH 0020/1315] Dots in displaying views of sparse/structured
 arrays (#51679)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

With this, views of sparse/structured arrays are printed with dots as
well:
```julia
julia> D = Diagonal(1:4)
4×4 Diagonal{Int64, UnitRange{Int64}}:
 1  ⋅  ⋅  ⋅
 ⋅  2  ⋅  ⋅
 ⋅  ⋅  3  ⋅
 ⋅  ⋅  ⋅  4

julia> view(D, 1:3, 1:3)
3×3 view(::Diagonal{Int64, UnitRange{Int64}}, 1:3, 1:3) with eltype Int64:
 1  ⋅  ⋅
 ⋅  2  ⋅
 ⋅  ⋅  3

julia> S = sparse([1,2,2,2,3], [1,1,2,2,4], [5, -19, 73, 12, -7])
3×4 SparseMatrixCSC{Int64, Int64} with 4 stored entries:
   5   ⋅  ⋅   ⋅
 -19  85  ⋅   ⋅
   ⋅   ⋅  ⋅  -7

julia> view(S, 1:3, 1:3)
3×3 view(::SparseMatrixCSC{Int64, Int64}, 1:3, 1:3) with eltype Int64:
   5   ⋅  ⋅
 -19  85  ⋅
   ⋅   ⋅  ⋅
```
---
 base/subarray.jl |  7 +++++++
 test/subarray.jl | 31 +++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/base/subarray.jl b/base/subarray.jl
index 901410e908d1e..57014d5c86856 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -494,3 +494,10 @@ function _indices_sub(i1::AbstractArray, I...)
 end
 
 has_offset_axes(S::SubArray) = has_offset_axes(S.indices...)
+
+function replace_in_print_matrix(S::SubArray{<:Any,2,<:AbstractMatrix}, i::Integer, j::Integer, s::AbstractString)
+    replace_in_print_matrix(S.parent, reindex(S.indices, (i,j))..., s)
+end
+function replace_in_print_matrix(S::SubArray{<:Any,1,<:AbstractVector}, i::Integer, j::Integer, s::AbstractString)
+    replace_in_print_matrix(S.parent, reindex(S.indices, (i,))..., j, s)
+end
diff --git a/test/subarray.jl b/test/subarray.jl
index 1137c265fa126..442e6f485f5b1 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -769,3 +769,34 @@ end
     @test view(m, 1:2, 3, 1, 1) == m[1:2, 3]
     @test parent(view(m, 1:2, 3, 1, 1)) === m
 end
+
+@testset "replace_in_print_matrix" begin
+    struct MyIdentity <: AbstractMatrix{Bool}
+        n :: Int
+    end
+    Base.size(M::MyIdentity) = (M.n, M.n)
+    function Base.getindex(M::MyIdentity, i::Int, j::Int)
+        checkbounds(M, i, j)
+        i == j
+    end
+    function Base.replace_in_print_matrix(M::MyIdentity, i::Integer, j::Integer, s::AbstractString)
+        i == j ? s : Base.replace_with_centered_mark(s)
+    end
+    V = view(MyIdentity(3), 1:2, 1:3)
+    @test sprint(show, "text/plain", V) == "$(summary(V)):\n 1  ⋅  ⋅\n ⋅  1  ⋅"
+
+    struct OneElVec <: AbstractVector{Bool}
+        n :: Int
+        ind :: Int
+    end
+    Base.size(M::OneElVec) = (M.n,)
+    function Base.getindex(M::OneElVec, i::Int)
+        checkbounds(M, i)
+        i == M.ind
+    end
+    function Base.replace_in_print_matrix(M::OneElVec, i::Integer, j::Integer, s::AbstractString)
+        i == M.ind ? s : Base.replace_with_centered_mark(s)
+    end
+    V = view(OneElVec(6, 2), 1:5)
+    @test sprint(show, "text/plain", V) == "$(summary(V)):\n ⋅\n 1\n ⋅\n ⋅\n ⋅"
+end

From 86cbb604f853acef34b84416735e1c2640a45d4e Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 18 Oct 2023 06:19:01 +0900
Subject: [PATCH 0021/1315] inference: use `jl_method_get_table` for
 `get_nospecializeinfer_sig` (#51735)

This allows `@nospecializeinfer` to be functional for `@overlay`ed
methods, making it more aligned with `get_compileable_sig` too.
---
 base/compiler/utilities.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 78079e6174f29..bce430b055bed 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -164,7 +164,7 @@ end
 
 function get_nospecializeinfer_sig(method::Method, @nospecialize(atype), sparams::SimpleVector)
     isa(atype, DataType) || return method.sig
-    mt = ccall(:jl_method_table_for, Any, (Any,), atype)
+    mt = ccall(:jl_method_get_table, Any, (Any,), method)
     mt === nothing && return method.sig
     return ccall(:jl_normalize_to_compilable_sig, Any, (Any, Any, Any, Any, Cint),
         mt, atype, sparams, method, #=int return_if_compileable=#0)

From 0b31e8b9e9c9093e88cc6610765cfccb21cde499 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 18 Oct 2023 17:56:27 +0900
Subject: [PATCH 0022/1315] EA: allow tests to run for out-of-tree build
 (#51752)

---
 test/compiler/EscapeAnalysis/EscapeAnalysis.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/compiler/EscapeAnalysis/EscapeAnalysis.jl b/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
index b598388a3d138..04729ab818420 100644
--- a/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
+++ b/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
@@ -1,6 +1,6 @@
 module test_EA
 
-const use_core_compiler = false
+const use_core_compiler = true
 
 if use_core_compiler
     const EscapeAnalysis = Core.Compiler.EscapeAnalysis

From e36f65f0f66c1306574f7ec577479bf381fa088c Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 18 Oct 2023 09:54:22 -0400
Subject: [PATCH 0023/1315] codegen: fix gc rooting bug (#51744)

ccall was not creating roots for the contents of struct values which
contained roots on the stack, as expected to align with `GC.@preserve`,
and causing many segfaults for #51319
---
 src/ccall.cpp            |  2 +-
 src/cgutils.cpp          | 30 +++++++++++++++++++++---------
 src/codegen.cpp          | 20 ++++++++------------
 test/compiler/codegen.jl |  6 +++---
 4 files changed, 33 insertions(+), 25 deletions(-)

diff --git a/src/ccall.cpp b/src/ccall.cpp
index fafb71efaf52d..9eb672e3047fb 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1393,7 +1393,7 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         if (jl_is_long(argi_root))
             continue;
         jl_cgval_t arg_root = emit_expr(ctx, argi_root);
-        Value *gc_root = get_gc_root_for(arg_root);
+        Value *gc_root = get_gc_root_for(ctx, arg_root);
         if (gc_root)
             gc_uses.push_back(gc_root);
     }
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index f086c7fd0b0bd..c71c78da4c829 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -314,19 +314,34 @@ static Value *emit_pointer_from_objref(jl_codectx_t &ctx, Value *V)
     return Call;
 }
 
-static Value *get_gc_root_for(const jl_cgval_t &x)
+static Value *emit_unbox(jl_codectx_t &ctx, Type *to, const jl_cgval_t &x, jl_value_t *jt);
+static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value* dest, MDNode *tbaa_dest, unsigned alignment, bool isVolatile=false);
+
+static Value *get_gc_root_for(jl_codectx_t &ctx, const jl_cgval_t &x)
 {
-    if (x.Vboxed)
+    if (x.constant || x.typ == jl_bottom_type)
+        return nullptr;
+    if (x.Vboxed) // superset of x.isboxed
         return x.Vboxed;
-    if (x.ispointer() && !x.constant) {
+    assert(!x.isboxed);
+#ifndef NDEBUG
+    if (x.ispointer()) {
         assert(x.V);
         if (PointerType *T = dyn_cast<PointerType>(x.V->getType())) {
-            if (T->getAddressSpace() == AddressSpace::Tracked ||
-                T->getAddressSpace() == AddressSpace::Derived) {
-                return x.V;
+            assert(T->getAddressSpace() != AddressSpace::Tracked);
+            if (T->getAddressSpace() == AddressSpace::Derived) {
+                // n.b. this IR would not be valid after LLVM-level inlining,
+                // since codegen does not have a way to determine the whether
+                // this argument value needs to be re-rooted
             }
         }
     }
+#endif
+    if (jl_is_concrete_immutable(x.typ) && !jl_is_pointerfree(x.typ)) {
+        Type *T = julia_type_to_llvm(ctx, x.typ);
+        return emit_unbox(ctx, T, x, x.typ);
+    }
+    // nothing here to root, move along
     return nullptr;
 }
 
@@ -1786,9 +1801,6 @@ static Value *emit_bounds_check(jl_codectx_t &ctx, const jl_cgval_t &ainfo, jl_v
     return im1;
 }
 
-static Value *emit_unbox(jl_codectx_t &ctx, Type *to, const jl_cgval_t &x, jl_value_t *jt);
-static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value* dest, MDNode *tbaa_dest, unsigned alignment, bool isVolatile=false);
-
 static void emit_write_barrier(jl_codectx_t&, Value*, ArrayRef<Value*>);
 static void emit_write_barrier(jl_codectx_t&, Value*, Value*);
 static void emit_write_multibarrier(jl_codectx_t&, Value*, Value*, jl_value_t*);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 33730ad9cf74b..e37de75b7c5bc 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -3064,9 +3064,12 @@ static Value *emit_bits_compare(jl_codectx_t &ctx, jl_cgval_t arg1, jl_cgval_t a
             varg2 = emit_pointer_from_objref(ctx, varg2);
             Value *gc_uses[2];
             int nroots = 0;
-            if ((gc_uses[nroots] = get_gc_root_for(arg1)))
+            // these roots may seem a bit overkill, but we want to make sure
+            // that a!=b implies (a,)!=(b,) even if a and b are unused and
+            // therefore could be freed and then the memory for a reused for b
+            if ((gc_uses[nroots] = get_gc_root_for(ctx, arg1)))
                 nroots++;
-            if ((gc_uses[nroots] = get_gc_root_for(arg2)))
+            if ((gc_uses[nroots] = get_gc_root_for(ctx, arg2)))
                 nroots++;
             OperandBundleDef OpBundle("jl_roots", makeArrayRef(gc_uses, nroots));
             auto answer = ctx.builder.CreateCall(prepare_call(memcmp_func), {
@@ -5863,16 +5866,9 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
         }
         SmallVector<Value*, 0> vals;
         for (size_t i = 0; i < nargs; ++i) {
-            const jl_cgval_t &ai = argv[i];
-            if (ai.constant || ai.typ == jl_bottom_type)
-                continue;
-            if (ai.isboxed) {
-                vals.push_back(ai.Vboxed);
-            }
-            else if (jl_is_concrete_immutable(ai.typ) && !jl_is_pointerfree(ai.typ)) {
-                Type *at = julia_type_to_llvm(ctx, ai.typ);
-                vals.push_back(emit_unbox(ctx, at, ai, ai.typ));
-            }
+            Value *gc_root = get_gc_root_for(ctx, argv[i]);
+            if (gc_root)
+                vals.push_back(gc_root);
         }
         Value *token = vals.empty()
             ? (Value*)ConstantTokenNone::get(ctx.builder.getContext())
diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl
index bb0592c86c654..3b517201ce67d 100644
--- a/test/compiler/codegen.jl
+++ b/test/compiler/codegen.jl
@@ -581,13 +581,13 @@ end
     end
     @test occursin("llvm.julia.gc_preserve_begin", get_llvm(f3, Tuple{Bool}, true, false, false))
 
-    # unions of immutables (JuliaLang/julia#39501)
+    # PhiNode of unions of immutables (JuliaLang/julia#39501)
     function f2(cond)
-        val = cond ? 1 : 1f0
+        val = cond ? 1 : ""
         GC.@preserve val begin end
         return cond
     end
-    @test !occursin("llvm.julia.gc_preserve_begin", get_llvm(f2, Tuple{Bool}, true, false, false))
+    @test occursin("llvm.julia.gc_preserve_begin", get_llvm(f2, Tuple{Bool}, true, false, false))
     # make sure the fix for the above doesn't regress #34241
     function f4(cond)
         val = cond ? ([1],) : ([1f0],)

From 3cc4fdc7a11b99a253fb1d4b1b420bb52ac95b69 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Wed, 18 Oct 2023 10:05:54 -0400
Subject: [PATCH 0024/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20ffb6edf03=20to=20af5392db5=20(#51749)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: ffb6edf03
New commit: af5392db5
Julia version: 1.11.0-DEV
Pkg version: 1.11.0
Bump invoked by: @DilumAluthge
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/ffb6edf0306a651240b71641fb4aa5ab8cc7659b...af5392db53e1a45aa31bd93b507e163fc0205893

```
$ git log --oneline ffb6edf03..af5392db5
af5392db5 Precompilation workload: restore the original depot and load paths (#3668)
b39ba05f3 Precompilation workload: set `"JULIA_PKG_UNPACK_REGISTRY" => nothing` (#3662)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5     | 1 +
 .../Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512  | 1 +
 .../Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5     | 1 -
 .../Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512  | 1 -
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512

diff --git a/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5 b/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5
new file mode 100644
index 0000000000000..b10919c082900
--- /dev/null
+++ b/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5
@@ -0,0 +1 @@
+65413e890729029a25b147ffc242a23f
diff --git a/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512 b/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512
new file mode 100644
index 0000000000000..20ee4dcd235d8
--- /dev/null
+++ b/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512
@@ -0,0 +1 @@
+f8ddfd14a1f1124a08cb8334ab58caf9f628e561b4523ea6e27880da191f359fa1e5c46db09cf8ad0c62736b241085b448314e6af243a34df3901b85fc8fe89f
diff --git a/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5 b/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5
deleted file mode 100644
index d0689b2900b94..0000000000000
--- a/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-7debd8f3b98285c9837b6715fe2e1802
diff --git a/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512 b/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512
deleted file mode 100644
index 6b45b3b24cd68..0000000000000
--- a/deps/checksums/Pkg-ffb6edf0306a651240b71641fb4aa5ab8cc7659b.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-6f3b71ac68899c265d59edf3376f224f8a64b63ac0a9a08f05652789f9bc8e670365e0f0758c357b8a8bdf08a08c75c27f1d1a63d062795ae67793a686d4acfe
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index b5928ddf64786..1d900ed01c9f0 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = ffb6edf0306a651240b71641fb4aa5ab8cc7659b
+PKG_SHA1 = af5392db53e1a45aa31bd93b507e163fc0205893
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 101e475645df961c904ef5ed9995fb3268e468d5 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 18 Oct 2023 15:57:05 -0400
Subject: [PATCH 0025/1315] ignore mightalias for empty objects (#51761)

There is no bytes that overlap, so it is safe to use these without
needing to make an explicit copy of nothing.
---
 base/abstractarray.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 0171c38bc9c0b..f2329478fbe74 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1507,7 +1507,7 @@ Perform a conservative test to check if arrays `A` and `B` might share the same
 By default, this simply checks if either of the arrays reference the same memory
 regions, as identified by their [`Base.dataids`](@ref).
 """
-mightalias(A::AbstractArray, B::AbstractArray) = !isbits(A) && !isbits(B) && !_isdisjoint(dataids(A), dataids(B))
+mightalias(A::AbstractArray, B::AbstractArray) = !isbits(A) && !isbits(B) && !isempty(A) && !isempty(B) && !_isdisjoint(dataids(A), dataids(B))
 mightalias(x, y) = false
 
 _isdisjoint(as::Tuple{}, bs::Tuple{}) = true

From 8a889ffcd235ac75720205b0cd7446c9b66eb664 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Wed, 18 Oct 2023 16:32:39 -0400
Subject: [PATCH 0026/1315] limit TimeType subtraction (#51743)

Disallow some type combinations that don't make sense.

---------

Co-authored-by: Ben Baumgold <4933671+baumgold@users.noreply.github.com>
---
 stdlib/Dates/src/arithmetic.jl  | 6 ++++--
 stdlib/Dates/test/arithmetic.jl | 4 +---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/stdlib/Dates/src/arithmetic.jl b/stdlib/Dates/src/arithmetic.jl
index a847f749d0154..23a76f5ed75d6 100644
--- a/stdlib/Dates/src/arithmetic.jl
+++ b/stdlib/Dates/src/arithmetic.jl
@@ -6,8 +6,10 @@
 
 # TimeType arithmetic
 (+)(x::TimeType) = x
-(-)(x::T, y::T) where {T<:TimeType} = x.instant - y.instant
-(-)(x::TimeType, y::TimeType) = -(promote(x, y)...)
+(-)(x::Date, y::Date) = x.instant - y.instant
+(-)(x::Time, y::Time) = x.instant - y.instant
+(-)(x::DateTime, y::DateTime) = x.instant - y.instant
+(-)(x::AbstractDateTime, y::AbstractDateTime) = -(promote(x, y)...)
 
 # Date-Time arithmetic
 """
diff --git a/stdlib/Dates/test/arithmetic.jl b/stdlib/Dates/test/arithmetic.jl
index 110eea6d00235..129e9a60bf490 100644
--- a/stdlib/Dates/test/arithmetic.jl
+++ b/stdlib/Dates/test/arithmetic.jl
@@ -12,9 +12,7 @@ using Dates
 end
 
 @testset "TimeType arithmetic" begin
-    a = Date(2023, 5, 1)
-    b = DateTime(2023, 5, 2)
-    @test b - a == Day(1)
+    @test_throws MethodError DateTime(2023, 5, 2) - Date(2023, 5, 1)
 end
 
 @testset "Wrapping arithmetic for Months" begin

From 47d5c021539d4d3bd305d7104b40720217022827 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 19 Oct 2023 01:34:31 -0400
Subject: [PATCH 0027/1315] Fix inlining logic for :invoke exprs (#51766)

This code path isn't currently used in Base, but is reached in external
abstract interpreters and wasn't correctly handling ConstantCase returns
from `resolve_todo`.
---
 base/compiler/ssair/inlining.jl | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 0a5b5c6580595..ed46c4aafbdbf 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1008,8 +1008,12 @@ function handle_single_case!(todo::Vector{Pair{Int,Any}},
     elseif isa(case, InvokeCase)
         is_foldable_nothrow(case.effects) && inline_const_if_inlineable!(ir[SSAValue(idx)]) && return nothing
         isinvoke && rewrite_invoke_exprargs!(stmt)
-        stmt.head = :invoke
-        pushfirst!(stmt.args, case.invoke)
+        if stmt.head === :invoke
+            stmt.args[1] = case.invoke
+        else
+            stmt.head = :invoke
+            pushfirst!(stmt.args, case.invoke)
+        end
         ir[SSAValue(idx)][:flag] |= flags_for_effects(case.effects)
     elseif case === nothing
         # Do, well, nothing
@@ -1643,13 +1647,11 @@ function handle_finalizer_call!(ir::IRCode, idx::Int, stmt::Expr, info::Finalize
     return nothing
 end
 
-function handle_invoke_expr!(todo::Vector{Pair{Int,Any}},
+function handle_invoke_expr!(todo::Vector{Pair{Int,Any}}, ir::IRCode,
     idx::Int, stmt::Expr, @nospecialize(info::CallInfo), flag::UInt32, sig::Signature, state::InliningState)
     mi = stmt.args[1]::MethodInstance
     case = resolve_todo(mi, sig.argtypes, info, flag, state)
-    if case !== nothing
-        push!(todo, idx=>(case::InliningTodo))
-    end
+    handle_single_case!(todo, ir, idx, stmt, case, false)
     return nothing
 end
 
@@ -1677,7 +1679,7 @@ function assemble_inline_todo!(ir::IRCode, state::InliningState)
         # `NativeInterpreter` won't need this, but provide a support for `:invoke` exprs here
         # for external `AbstractInterpreter`s that may run the inlining pass multiple times
         if isexpr(stmt, :invoke)
-            handle_invoke_expr!(todo, idx, stmt, info, flag, sig, state)
+            handle_invoke_expr!(todo, ir, idx, stmt, info, flag, sig, state)
             continue
         end
 

From 4ef353c6e4ad5156ad65cb40c3a2a61fbd324b59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Thu, 19 Oct 2023 09:37:16 +0100
Subject: [PATCH 0028/1315] Put mingw32 `*.a` files in `private_libdir`
 (#51698)

This avoid that these files are picked up during julia's build process,
and are instead only used to link pkgimages, as intended.

Co-authored-by: Tim Besard <tim.besard@gmail.com>
---
 Make.inc                                      |   2 +-
 Makefile                                      |   9 +-
 base/linking.jl                               |   6 +-
 deps/checksums/compilersupportlibraries       | 184 +++++++++---------
 deps/csl.mk                                   |  16 ++
 .../CompilerSupportLibraries_jll/Project.toml |   4 +-
 6 files changed, 117 insertions(+), 104 deletions(-)

diff --git a/Make.inc b/Make.inc
index 0f170734127ed..8d5aa5ce86dfe 100644
--- a/Make.inc
+++ b/Make.inc
@@ -1248,7 +1248,7 @@ LIBGFORTRAN_VERSION := $(subst libgfortran,,$(filter libgfortran%,$(subst -,$(SP
 # shipped with CSL. Although we do not depend on any of the symbols, it is entirely
 # possible that a user might choose to install a library which depends on symbols provided
 # by a newer libstdc++. Without runtime detection, those libraries would break.
-CSL_NEXT_GLIBCXX_VERSION=GLIBCXX_3\.4\.31|GLIBCXX_3\.5\.|GLIBCXX_4\.
+CSL_NEXT_GLIBCXX_VERSION=GLIBCXX_3\.4\.33|GLIBCXX_3\.5\.|GLIBCXX_4\.
 
 
 # This is the set of projects that BinaryBuilder dependencies are hooked up for.
diff --git a/Makefile b/Makefile
index d205a4cf8deb8..68a316b0a32ae 100644
--- a/Makefile
+++ b/Makefile
@@ -288,16 +288,13 @@ else ifeq ($(JULIA_BUILD_MODE),debug)
 	-$(INSTALL_M) $(build_libdir)/libjulia-debug.dll.a $(DESTDIR)$(libdir)/
 	-$(INSTALL_M) $(build_libdir)/libjulia-internal-debug.dll.a $(DESTDIR)$(libdir)/
 endif
+	-$(INSTALL_M) $(wildcard $(build_private_libdir)/*.a) $(DESTDIR)$(private_libdir)/
 
-	# We have a single exception; we want 7z.dll to live in private_libexecdir, not bindir, so that 7z.exe can find it.
+	# We have a single exception; we want 7z.dll to live in private_libexecdir,
+	# not bindir, so that 7z.exe can find it.
 	-mv $(DESTDIR)$(bindir)/7z.dll $(DESTDIR)$(private_libexecdir)/
 	-$(INSTALL_M) $(build_bindir)/libopenlibm.dll.a $(DESTDIR)$(libdir)/
 	-$(INSTALL_M) $(build_libdir)/libssp.dll.a $(DESTDIR)$(libdir)/
-	# The rest are compiler dependencies, as an example memcpy is exported by msvcrt
-	# These are files from mingw32 and required for creating shared libraries like our caches.
-	-$(INSTALL_M) $(build_libdir)/libgcc_s.a $(DESTDIR)$(libdir)/
-	-$(INSTALL_M) $(build_libdir)/libgcc.a $(DESTDIR)$(libdir)/
-	-$(INSTALL_M) $(build_libdir)/libmsvcrt.a $(DESTDIR)$(libdir)/
 else
 
 # Copy over .dSYM directories directly for Darwin
diff --git a/base/linking.jl b/base/linking.jl
index fd21ce74c9268..2d68ea730c0fb 100644
--- a/base/linking.jl
+++ b/base/linking.jl
@@ -150,16 +150,16 @@ else
 end
 
 function link_image_cmd(path, out)
-    LIBDIR = "-L$(libdir())"
     PRIVATE_LIBDIR = "-L$(private_libdir())"
     SHLIBDIR = "-L$(shlibdir())"
-    LIBS = is_debug() ? ("-ljulia-debug", "-ljulia-internal-debug") : ("-ljulia", "-ljulia-internal")
+    LIBS = is_debug() ? ("-ljulia-debug", "-ljulia-internal-debug") :
+                        ("-ljulia", "-ljulia-internal")
     @static if Sys.iswindows()
         LIBS = (LIBS..., "-lopenlibm", "-lssp", "-lgcc_s", "-lgcc", "-lmsvcrt")
     end
 
     V = VERBOSE[] ? "--verbose" : ""
-    `$(ld()) $V $SHARED -o $out $WHOLE_ARCHIVE $path $NO_WHOLE_ARCHIVE $LIBDIR $PRIVATE_LIBDIR $SHLIBDIR $LIBS`
+    `$(ld()) $V $SHARED -o $out $WHOLE_ARCHIVE $path $NO_WHOLE_ARCHIVE $PRIVATE_LIBDIR $SHLIBDIR $LIBS`
 end
 
 function link_image(path, out, internal_stderr::IO=stderr, internal_stdout::IO=stdout)
diff --git a/deps/checksums/compilersupportlibraries b/deps/checksums/compilersupportlibraries
index 0908c34e13a58..2dcfecfb56b26 100644
--- a/deps/checksums/compilersupportlibraries
+++ b/deps/checksums/compilersupportlibraries
@@ -1,92 +1,92 @@
-CompilerSupportLibraries.v1.0.5+1.aarch64-apple-darwin-libgfortran5.tar.gz/md5/20ebaad57850393b6ac9fa924e511fe4
-CompilerSupportLibraries.v1.0.5+1.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/020de4d8b0ff6bedbadaa305ff8445e6849f12053762ea4aa68412d1ec763dbd86f479587a2fbb862487f1feb04d976c38099ddf3887817a3d32b3f029cf85b1
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran3.tar.gz/md5/3908fa1a2f739b330e787468c9bfb5c8
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/1741e3403ac7aa99e7cfd9a01222c4153ed300f47cc1b347e1af1a6cd07a82caaa54b9cfbebae8751440420551621cc6524504413446d104f9493dff2c081853
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran4.tar.gz/md5/2444dbb7637b32cf543675cc12330878
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/8537f0b243df8544350c884021b21c585fd302e8dd462a30a6ee84c7a36a049133262e5d1bc362f972066b8e8d6a091c32c3b746bab1feb9fccf2e7cca65756c
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran5.tar.gz/md5/d79c1434594c0c5e7d6be798bf52c99e
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/7e71accc401a45b51b298702fb4c79a2fc856c7b28f0935f6ad3a0db5381c55fe5432daff371842930d718024b7c6c1d80e2bd09d397145203673bebbe3496ae
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran3.tar.gz/md5/f212059053d99558a9b0bf54b20180e1
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran3.tar.gz/sha512/5c104b1282cec8a944e5d008f44a4d60f4394fd5d797fec7d1f487d13e7328cd9c88ec4916dabf18596d87160756bda914e4f8c5a356b5577f9349d0d9e976d6
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran4.tar.gz/md5/3e3b3795ee93ef317223050e803a9875
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran4.tar.gz/sha512/85d3c955e15f66bfe8bfec2f28c9160bc03d4d531ea4ffe6bc6b51e0d69ccea3ab67a16ca752dabc870861c407381c4519d75c6be3832e8dccd6122ec8c6ed75
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran5.tar.gz/md5/cf2d1315f6a348af2e6c065e2a286e7a
-CompilerSupportLibraries.v1.0.5+1.aarch64-linux-musl-libgfortran5.tar.gz/sha512/58420377bc77aa7678034ee5f708eb6be7db359faef2c2638869765453633da9bf455512bd88e95b38ae0428ecc4053561517b176b2371129bdaef9d8d5dadfd
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/f5c09ed7e0eeb8d345d328f950582f26
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/9c657f55c8fcdeb404be168a3a63a5e84304730fe34f25673d92cdae4b0a1fcc6a877ee1433f060e1be854c7811d66632e32510a2ed591d88330f1340b9c20de
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/c685518aca4721cd8621d510e2039683
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b760468c6377dcd2b8dd50200daaabe604006afc070984d78152b2becd0680b59036c9a6e91dea490121bd85b58d285bfc1e1cf696d29af236528400101de36c
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/8faf5c8ad62ab10f71dd2ec9683053e2
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/921239f241a5c89710cf07272d7f6c3f10201a7533068ed1e9643f9fb2f439e1bb765a4966d913829866ee0ce4f1589d30d06e4b5c1361e3c016a9473f087177
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/b38fcb70691ac2621379d298eef8c79e
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/06c7f64257ce721f5941f6e50a0d2717cdc9394fc532ded19ce3eaacd5e92a416969534227562e4fee04d2b6340c650d8bc9779e14519b90038bc41e8d1f5ce3
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/cdfab2c7bc41765caf4441c3caeed761
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/7109d4a7b32c00309c42685f54a86fc2cc63c0c00f65584ad296b6e44ad3320eed1aaf49684a8831841cdffa5555d72f89272fb722a780596e27ef020528026b
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/441980ebd23d72772cbe603f1c275336
-CompilerSupportLibraries.v1.0.5+1.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/e273d9f1af259a3080df8f173e1808a1ade976a943aba97216bf59a96178e7c052e7a048b0ceee53ab486ed577a2ecb92579857be2f7b29e76322ee1f13c9d76
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/f5c09ed7e0eeb8d345d328f950582f26
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/9c657f55c8fcdeb404be168a3a63a5e84304730fe34f25673d92cdae4b0a1fcc6a877ee1433f060e1be854c7811d66632e32510a2ed591d88330f1340b9c20de
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/c685518aca4721cd8621d510e2039683
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b760468c6377dcd2b8dd50200daaabe604006afc070984d78152b2becd0680b59036c9a6e91dea490121bd85b58d285bfc1e1cf696d29af236528400101de36c
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/8faf5c8ad62ab10f71dd2ec9683053e2
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/921239f241a5c89710cf07272d7f6c3f10201a7533068ed1e9643f9fb2f439e1bb765a4966d913829866ee0ce4f1589d30d06e4b5c1361e3c016a9473f087177
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/b38fcb70691ac2621379d298eef8c79e
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/06c7f64257ce721f5941f6e50a0d2717cdc9394fc532ded19ce3eaacd5e92a416969534227562e4fee04d2b6340c650d8bc9779e14519b90038bc41e8d1f5ce3
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/cdfab2c7bc41765caf4441c3caeed761
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/7109d4a7b32c00309c42685f54a86fc2cc63c0c00f65584ad296b6e44ad3320eed1aaf49684a8831841cdffa5555d72f89272fb722a780596e27ef020528026b
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/441980ebd23d72772cbe603f1c275336
-CompilerSupportLibraries.v1.0.5+1.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/e273d9f1af259a3080df8f173e1808a1ade976a943aba97216bf59a96178e7c052e7a048b0ceee53ab486ed577a2ecb92579857be2f7b29e76322ee1f13c9d76
-CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran3.tar.gz/md5/6decf8fd5afb50451771c761e63a8917
-CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran3.tar.gz/sha512/4984724bcc847724b1bc005b6f760a18b68147f7d5402d0faf4e28fc0d14fa10975368a951f9caf2a8856500046dec8343043274557d58269e77492b929a9e4b
-CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran4.tar.gz/md5/39d1e8a3baa144c018d3eaf7f3806482
-CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran4.tar.gz/sha512/fc4d429279c5a93b6c28b6e911b1e7cfd1c1cfe46f11f2e901b3832ce90d45f49d3d29f0ef18518a94af6cc8651f67c4ed81672680f9281ada390440b172a2af
-CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran5.tar.gz/md5/37dabd9cd224c9fed9633dedccb6c565
-CompilerSupportLibraries.v1.0.5+1.i686-linux-gnu-libgfortran5.tar.gz/sha512/b253149e72eef9486888fbaace66e9b6945f4477f6b818f64f3047331165b0e2bc17aa6e3fc8c88686a72e478eb62c8f53883415d5419db448d8016fa3a1da5e
-CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran3.tar.gz/md5/afdd32bfadd465848e6be458817a44ae
-CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran3.tar.gz/sha512/eebd679c499143014514c7c9d1875dedbbab9e3af51526c4dd445a9e3dbade95d24522da8bbad0a50ab400755e47b018828b324c4ad7705e212ccd990e34439a
-CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran4.tar.gz/md5/bc4a0f0b7cea328f7e8850583774496b
-CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran4.tar.gz/sha512/82285b67946212b49cddf6259f2c60ff5469f8c5263ccefe44f1d93ace98ab68e2c152e1b54434b2f075fd8d192c06d5451bc8cca26d951ad15f3453102f02b5
-CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran5.tar.gz/md5/177f0232abce8d523882530ed7a93092
-CompilerSupportLibraries.v1.0.5+1.i686-linux-musl-libgfortran5.tar.gz/sha512/db80acf0f2434f28ee7680e1beb34f564940071815d1ad89fb5913cbd9ac24da528e826d0d54be6265a7340ebd661b6d308ed79d96b67fa5d8c98dc3f1bee8d6
-CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran3.tar.gz/md5/f5795dada5360eb8422f45150b13bae9
-CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran3.tar.gz/sha512/6acd1bf7c81631cef9b8b0576ccece08723c5ae2f49de2487d3aefd25f9a0ad49df09e3782735267997d40687b04b85c89e00f6889b026af599bf1bbe91803a1
-CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran4.tar.gz/md5/5e590f83161913f0145ba8d496b2504b
-CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran4.tar.gz/sha512/4a3f36588afcdef26173764597054068e26f2376e6126a9a94c46b258b5d7a29951d47b5e1ba24df6c3d139bbc4decc5c501a266811692d7fadadc7bd7b6960d
-CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran5.tar.gz/md5/27da4a7c890fe1427c33fe214cc5feaf
-CompilerSupportLibraries.v1.0.5+1.i686-w64-mingw32-libgfortran5.tar.gz/sha512/310ad00f053f9f3ec715ce2e8d20446f397728dff5acc787ea9c9332346607a3d42b678099c424e6d6e5294acddf2aa26051de657b48d34abfd04486951bf241
-CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/4e5e4b23dc87450738da33926a07511d
-CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/fc09879d94b750e75775d8b64a41ab9924d675fb53c5700467604412928fe7f5cb21911da0f64898d2463fa77ffbaf4c96c397b9060f4746eec152747930cddc
-CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/9a92138ed69aa317a932a615c6e62d69
-CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/0b7785379936a2a209b074177b1424dd7e00b29b5165f564e799b0aa4e06a582e9d616525d97274ba2507cb88192028f1ac485d3f99bdc7ee53fc63c1a7e85de
-CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/8ffee3d6de5197c7a1f354d72c8238fa
-CompilerSupportLibraries.v1.0.5+1.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/deadc4d7224c84f9b82dc956b69e815c44ae036802838365d870ab9f58c8bcf8ce0645f2f387c8ff344ac2108fc8e7e1ee907fa55e93c91aa5d9fd921bf3fdcb
-CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran3.tar.gz/md5/87449e72e3f33dbb69b7053cdc2649d4
-CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/5ce02ad10c6f4686a476eb2a5de2988cd8b482f5e693db2880c84ad1c82f468ef03fe01b9d0feefe5d4ee741d1d16643d36b144e6261ed32311b3b6f312fac2f
-CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran4.tar.gz/md5/0407cde92cfa42fa89ac83217ca0ec16
-CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/032c831f1166a336551138939ac40eb2c68a048ce786c0c1403b879a20c1b706caac16d22560b2c7f2b3d6373986c347188675674116005ca251336ee048d09f
-CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran5.tar.gz/md5/23418763b808371ee94772a90d501f4d
-CompilerSupportLibraries.v1.0.5+1.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/7867b843551457b11bda7821dd384c1c1cf23b80a308b2058a693de7b7da099f0b37eb0a6de2b84c04b625a68c60eea55138e200d5d6ec6f6af09bd7ce406a96
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran3.tar.gz/md5/e3d33ae03c18affea74699bdc1fabb68
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/42013f4921de5a69ad857195ce5c19ad1bca3c920d79699e5501f1f4534ab132fabd422362b2b5056f5d182215d6c069db5df460bafa700903faf962cc00f77b
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran4.tar.gz/md5/d40c1e8c0393213c6057c53a12f44175
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/fe7baa4de7490065ab7b953cc12f41462a24bcb49d0a4a64b23249e98e7569b19bb1cb455af2f76090e34066a7d3cdd7a48cae6515ce6c7a5c8486b0cacc5106
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran5.tar.gz/md5/48541b90f715c4c86ee4da0570275947
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/7f2683fb98e80f12629f4ed3bea9fd59d32b7e7a9ed1699e782d8e238ff0915ecc61bf00adaf4597cfe41caf82cdca0f9be250f595f5f0bea6d8f77dba99eaf4
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran3.tar.gz/md5/4547059eb905995667be48bf85d49911
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran3.tar.gz/sha512/7400fdabc924434ab4a4949248c3603887ac06ffd2f205ae33e14495d86cd4f816bbd1999eeafa0257f518df1e7f7c522f596e847a71dbfbfccff4859f50acc7
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran4.tar.gz/md5/46267543cad6584d7b7b9fcc8f18f21d
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran4.tar.gz/sha512/0353d7d724be48d4185d3c181692970b7996f53f6a01723072aa5c94b53a8c5055faeed30df51659c252a46f4b941dec0cb24569323e3c85c166f14c5b7c8e9e
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran5.tar.gz/md5/14dba2897a6e9d370fa9091c045375fc
-CompilerSupportLibraries.v1.0.5+1.x86_64-linux-musl-libgfortran5.tar.gz/sha512/10b79f9c059839f5b57fa8d2a381a034c4067262c4088bd354d14ea56bec097878069383aa9cfadaa09d73bd20fc348fb61662d863a8d62cb25d7af6b8e29858
-CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/1f069e9c832fa1e9c7c8d51e3e841f5c
-CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/877ed9953bc167ade224fc503a2b639c7c333d420804ccf0d3b1637e29bdaf8c608a8f7accb3ec7983d6881c4b00729a1327a121c741022aff1e627cdffb52ce
-CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/3e542990ca4192dcecf2e8b8b17e8580
-CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/0b9cf0f431a5de28bc11af31d965beaf6774d4e83cb3877fdca630d0327312eb966485d6a99d62b0212f505a6714c23fc7ac1ed17ec619baff13941f6ce7519c
-CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/b09302632fda815a1248884a82a6f95a
-CompilerSupportLibraries.v1.0.5+1.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/7a64ae14e40d285bbcd27a0f54ba6ad0a108ee4f4fed7c99d3a876a70578445e0c7108fa945f3f5a0b202cf95e533b96eedaf7641ded6e9869af77db98075709
-CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/0c2fc6fae4ebe293a7f0dc1e91f6531a
-CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/fdb0ad061cacad0557fde3ec216fd3666284f24ad6a86f4a4b6f946dccb112c9704f52edba86f3b17d84c824affbcfef740720348ef227380cf6017811bda80b
-CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/005e608dbef2b5cdb7624702ccc426be
-CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/8bb2bcd0a6b1901e8a9be20f505bead5c78ecafbe5a8271cd13385553e5744e0c7bff62976ac9e7d74b8f3bd467603d4c0f5658e6b120bb23066c15e0a644ed4
-CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/d6c2c7ad72bff7f7e5c43678d716a57a
-CompilerSupportLibraries.v1.0.5+1.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/36f5eba1b0be440797467cb7104652b74709913d2bad1b08ee2dc70f450fb8eab81b28f2b0bc8dfc238b3c46982c69aac831b4fad5bcee4e9dd114852fcb4a0b
+CompilerSupportLibraries.v1.1.0+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/20ebaad57850393b6ac9fa924e511fe4
+CompilerSupportLibraries.v1.1.0+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/020de4d8b0ff6bedbadaa305ff8445e6849f12053762ea4aa68412d1ec763dbd86f479587a2fbb862487f1feb04d976c38099ddf3887817a3d32b3f029cf85b1
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/e084a4374be45ba52279682c640449bc
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/d4aedf5c08e13fd9596476330f69e374af64373f7bca0e4df6cbb4d1710d695dce23f2655ee368c3df2049b7b0ca1848c9e01a437fadc0eb08937c6a7cdf2a27
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/6b3975f25be16ea1370ef0bf353ac752
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/d6298517be1ce350a61d1c1a1bf9b27a541382aa8ccf3e86eeadd7c47e2fe88facd17139a3878adb939df869a330264a942d280e3468d53b61325df7e31daaad
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/7134b79b71059d4da79224df1ca0853e
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/e66590a37e756ff33a84514a7ca2bbe2e1517f3e901bc66e40139e8a318d6cd8e329e0c2a7c557ea39e6db2f56802d485ab81b87be1373717b78474b1c7bf7d7
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/fd37789f5745a17cc9a85902cebf4698
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/9ff4e9be39f115af2e5bb6a5c88b3940f15a010952cebf39da22e7a5c6744be2f905bebccba092db0a89cf82e8c0e1a3e61b74d4204d2a6648b5469f3ccb0d12
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/e9286ae9299c57d5df7b795997b4adf5
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/ea64858481095e0374be330aa2ac84b394bc3e5351b9326137c9cd5d15e6bec47d6e5f672a216572dcb80c3aa6fcb08950cc10157c264f429a93c235028d79a4
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/b19c6cbc5b2a62ea76dea64b0f8ae488
+CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/090d659f7e4a7034117e2bb2dcad0ef544cdca898bf032222cdb81d32af6e6528be842d2cf55839fe397c2ace05dd4ce920cf98cc96324ae18832016516e6cc3
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/26fb41031e1b797373aea7a7c4d7be3c
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8fd0b6c990681789caec528067b4bcb9661f9c0a5e0268927d4e88565fa7005db3b592fb8e7830cf32b3fb4ce54d6db747dfde896f93bd38f65b7a1290a2399a
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/6ed3f3e94f662177c3cf3c3734a5c1ec
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b8165630cced0f7880cb6fd6263cf39bbbbda668eccc94219720078a85a641c3b1b20648960041aa3a51108ab6df087b909c572d0690aacf8b99dc5496ff7db6
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/86060cbbe966a59f18f92a9b2fab95d4
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/0aa0ca0ff3a4d541c7a9599ca1adae7391fdd3fa841f3055ecb8635096d0d95a0763758d7533c887b38a655af55174dfcb63f470147b28a256b75a85c8e47801
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/4acf6f8929fb8ec9fdb8a0f1af06260d
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/3b2e0a5f62bd93434d07848c3045479a1a05bd8589dc976a5680e13805db5adcd9abdcca82edee7b28b4c4a9413ce795784a8a0f0a8fb7346a439322c27c96d9
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/a75a927c3e14bee6dca29b4907def681
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/7853fd187f9289a8282d34112b5277bad13abe9dd9b6c796498db2f1a080b2c81faa6119df9ececd09725a019bf99706894765c9c20f618e359adc153c3181a2
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/ba8545cc20e6c602a0526a3b1fc1d2f1
+CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/7a7f3a7761deb068efc00ffc5d4bf4df365cb27674ce73abbe2305b678285161f1526f4facbe27fc11076d99b2079976507f78f5b463bd9057ed008e9d52f9cf
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/26fb41031e1b797373aea7a7c4d7be3c
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8fd0b6c990681789caec528067b4bcb9661f9c0a5e0268927d4e88565fa7005db3b592fb8e7830cf32b3fb4ce54d6db747dfde896f93bd38f65b7a1290a2399a
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/6ed3f3e94f662177c3cf3c3734a5c1ec
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b8165630cced0f7880cb6fd6263cf39bbbbda668eccc94219720078a85a641c3b1b20648960041aa3a51108ab6df087b909c572d0690aacf8b99dc5496ff7db6
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/86060cbbe966a59f18f92a9b2fab95d4
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/0aa0ca0ff3a4d541c7a9599ca1adae7391fdd3fa841f3055ecb8635096d0d95a0763758d7533c887b38a655af55174dfcb63f470147b28a256b75a85c8e47801
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/4acf6f8929fb8ec9fdb8a0f1af06260d
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/3b2e0a5f62bd93434d07848c3045479a1a05bd8589dc976a5680e13805db5adcd9abdcca82edee7b28b4c4a9413ce795784a8a0f0a8fb7346a439322c27c96d9
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/a75a927c3e14bee6dca29b4907def681
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/7853fd187f9289a8282d34112b5277bad13abe9dd9b6c796498db2f1a080b2c81faa6119df9ececd09725a019bf99706894765c9c20f618e359adc153c3181a2
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/ba8545cc20e6c602a0526a3b1fc1d2f1
+CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/7a7f3a7761deb068efc00ffc5d4bf4df365cb27674ce73abbe2305b678285161f1526f4facbe27fc11076d99b2079976507f78f5b463bd9057ed008e9d52f9cf
+CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran3.tar.gz/md5/39dc387fd58ef02c461c7906ceb110e3
+CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/1296ac707fdad620c65256686523f2b027c8359f54d1f8354ef5d1ba514992c7269aad26b706575509b5e29d0ad3dec1c7d32fe3bcff0d723d6a4890819eca46
+CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran4.tar.gz/md5/21a76d54d875ef09db2cdce77d328c2e
+CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/9c6bf15338ffbc7113c536e145e53bfaa693007b971f83ee2db820d7d54018bd1cfdbedb6bbce000ee7aaadad1561e91f5ac0e0519bbfccbc3bc57fdfc0eb7e7
+CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran5.tar.gz/md5/f028f2c94f28201701ef6ba4fec9abc9
+CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/c231af1bb0fd4f733278f883837fddf574689bbd7c4dd46cfcd1478d784cbeae1fd785d7cf9f4b0f98cda08819b63a20d5026c6beb892a188fc979b7893697bc
+CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran3.tar.gz/md5/184436dc05207a653f13aae3d82a2e1b
+CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran3.tar.gz/sha512/b6e1f969528a168de087f472eebd23a4daf907aa48f7c5b42c35960b1cae3e6ca8f512982d69b757f39d6dc07b46f74c84e549cb22354a2f55d1265cba7b7013
+CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran4.tar.gz/md5/545bee22cb35d1c4c1381009e72eebca
+CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran4.tar.gz/sha512/78a65b9e7cda79cd648a1ae09daea970eba9d04fd5ea41bc1e37b065cf5c53974f759590292876f57c7f65139be66a6c381aa6756cdda7b36845cfed1bb7fddc
+CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran5.tar.gz/md5/3f1a08601a6a7bbd4ecfa36c8f6abbd9
+CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran5.tar.gz/sha512/0e225e0a7b651f6b3fbccf760d08d66f2d8af1e329d14ef67fd3968a46905e062edcf75f60d7540f0cd7dabcd3ac9130fa0f63e198869bdc6a9aabd391652805
+CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/9cfea65fa6c1b587d9b4b84ee64af166
+CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/b30e24982d4140c312759b8c26d4b72845fc1fa4d7fdf49ccfe9994f7bbf1815ed006a228f6a2185c5b8f9d596d0b04debd1d8392e705c530e5177a22c7c081d
+CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/af99905c4f054fe13842559f7201b3ad
+CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/96513ff22dc16cc259ad392862f1765218474bff24e561f14c1e0d349a6bc433952d9b7b73236b56722fd971e0b864b178d8a9f8d9499de4595bc9857ef17a95
+CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/1be078cd374d3b501b20d9ce679009ee
+CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/63097283c987dc439f02d72a6f70423acd962e4da25acc04185e654c7f16a617e34ad7efabd624fd2e70119e79e4d4806f76286d36d56c353f9e53814e75d3e4
+CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/156ae44ab4172903ad40932ca78a57ed
+CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/e800c20342dd9886c4c3f57e92278d6d41c544adba202ef3f5a6a4f8211fbbd8fab65f169adf7320b7be8a2ea02c0aa1afedbaf0b3f9afbfb691759aaaaccc4c
+CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/cb01c02fdcbd319784034744172e1eb9
+CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/0ba635d39958672a0a55069521e20ca6c0f9c81a9f55c360f6043acb415709edb72bfe8d0e83c25cdf9ace8a9e9ba10e39457e234e3905c988eb95e0e0ecff3d
+CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/f9592263c6e72228c492ed2ed216f29e
+CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/cbe29742959906e3fe9a356991ca1f09d4d8cc2a02a9af8624b3e02b4ab59e33bc05082826f7c67c73c6b91cc8e1e5c4a0c275c21c5f8eab8b58ed942cdcb55c
+CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/8f0db2ff4688c3f9e1337a28976d833a
+CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/98502e07499ad9e22147a977b1fe55320e75b6229c3993f1cd1b71e47a09ae6bf78e2341ce978ea72d33b111d09b813a332bfe8f4f6dfb669509c300fcec2561
+CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/980a1b8e6262c4a7b8f86b84f7234043
+CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/c0755d4fbb1b6fd7755d7508d7df929feabe7e5778661397ef0205e21aa3be565b39ccc2a08ed0d958e812c0c759be68ef52de09fe92ebab6da342b309a0810d
+CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/4b3cdb65e6114c77fd1e51da69e41afa
+CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/803cb771875d94eda554bade8197b31aab988ab0c957a2f8853d82d01418be9fee7d9d4b7ef6f5b7fc8d1825ab22083a71d467eb976d5076fc5d73a9a7a30440
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/36638a444b185954bf12169edace1914
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/33f657775258d0da1a57fc03c5e8ed203946944581ebf70af7b0205f9bff7fcd4f2bde5b6fa3b01659c51f106d0e6df5c7533ab8d3372c4895675854688e01dc
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/36ac52a361fd0f4be5c66572345af7a4
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/802bd8089bb2a3b5959a47dbade2199b46c247d0a793cbf6fcbc97b9a1dccd6d8585ac7694ae4bef1dc3ba21796ae5b53f995c8793ccd7316e8fde68ac121f83
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/5911da90a0fc86d665aa86cba12e9d61
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/c966936dfd272d9706aa51ed44abcb8cded899b0caa8b12ee787a0fb1569fa90a1cba89c9a9b83e05c0993facc615feb851399f4799c06956ae3064d172c964d
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/5f42a52e72f0e79530d71733a93811bf
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/51078ef0e447bb181003a50b899b39a9d1ee8ecc92fc293f5a358d836ddf21d03dc44433ae28aa21fdf756c2912b2d3f1e374a5ba108c8c34552fcf32f93fd0b
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/f3bbee1114cb85c266a45f64632c6911
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/102e638f49ff0f62644f15a931c71a16b96f02f4c90d1b8bd378e0d7c54f4e8a150cdb5ffdbc3dcbafb83131bef84f9071cb77e8debdd98d8929c7b65401fc54
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/ff2b0ebdc7ef83cf8b48bd2ae76c6430
+CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/0730ecf1b9476612cadc3f3e7c1b227a1967edc091c88cd0cc19477079d1739fd5e7b1022ff686c0c6a2404edaebfb02c810dcfc1aa4187e7ecddb54998ad96c
+CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/35642304a9a2f435cf5214b2715198fe
+CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/a67f41ba31c99a064f504f508711537f9e90089ca5352bfc2698c3fcd3e499ca716f07ffeac4fb1b88c2c934f7f380f262af8c863d3b16ac7e805d5c805ab358
+CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/01df0fbb265e5ff1a480a7a5e23b0835
+CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/57a79f2b8e846c1514dcb18420f26ae2889962040f410b746836cab4395749155fa9cd9d00d4c25954c0ffa72f9f3823b1b50688a20ddf675301f64e0d4b5c7e
+CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/1f1f6380ce8815cc9cedcea0b40860e7
+CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/a88ea8af8c8df792861812bfdf7f1bcaae31582ab78ce78b47a0dc6fd57b93441c0471f529ce23877131ac9701c6eed72ce89241746e18271f3686fbd718138c
+CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/5eab740e86bfa7656f6a08038fe2fa63
+CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/3dc6b7ec39ff7dcb71478376c86ce34a35a62f049f6203722c5414b7b635ff1b412e02d8d24c13c123d18b2e914780da4639538676694e342a1a6b507691ef25
+CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/9718c79244ed31c367e715f1f563b8cd
+CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/eec2380c4e182f4e923142736a2c4aaf11a525a5f966fed7e4ec4b431ee28f3842a4e73495df116604f74b419e6d398576ee3dd21d3c0c53b92167dcfd0f6b84
+CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/58d7b0b79a22f3aade7e4f39eec898e7
+CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/efecc0ca09ec6b7b8898c2ffd333c7e0a6a44706d72ac0e5010409aba92ee70a88b6fd77434bedafe0e013561f8d0c74b5a274808a6c9499f6a3005a7691785f
diff --git a/deps/csl.mk b/deps/csl.mk
index 37956ba5c3505..aaebc8f50c053 100644
--- a/deps/csl.mk
+++ b/deps/csl.mk
@@ -104,4 +104,20 @@ distclean-csl: clean-csl
 
 else
 $(eval $(call bb-install,csl,CSL,true))
+ifeq ($(OS),WINNT)
+install-csl:
+	mkdir -p $(build_private_libdir)/
+	cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libgcc_s.a $(build_private_libdir)/
+	cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libgcc.a $(build_private_libdir)/
+	cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libmsvcrt.a $(build_private_libdir)/
+	cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libssp.dll.a $(build_private_libdir)/
+endif
+endif
+ifeq ($(OS),WINNT)
+uninstall-csl: uninstall-gcc-libraries
+uninstall-gcc-libraries:
+	-rm -f $(build_private_libdir)/libgcc_s.a
+	-rm -f $(build_private_libdir)/libgcc.a
+	-rm -f $(build_private_libdir)/libmsvcrt.a
+	-rm -f $(build_private_libdir)/libssp.dll.a
 endif
diff --git a/stdlib/CompilerSupportLibraries_jll/Project.toml b/stdlib/CompilerSupportLibraries_jll/Project.toml
index 6256c69d9bc10..3e15ff6b87b71 100644
--- a/stdlib/CompilerSupportLibraries_jll/Project.toml
+++ b/stdlib/CompilerSupportLibraries_jll/Project.toml
@@ -2,9 +2,9 @@ name = "CompilerSupportLibraries_jll"
 uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"
 
 # NOTE: When updating this, also make sure to update the value
-# `CSL_NEXT_GLIBCXX_VERSION` in `deps/csl.mk`, to properly disable
+# `CSL_NEXT_GLIBCXX_VERSION` in `Make.inc`, to properly disable
 # automatic usage of BB-built CSLs on extremely up-to-date systems!
-version = "1.0.5+1"
+version = "1.1.0+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 86305e3423b33ac80f186090a838d5ce22a01075 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 19 Oct 2023 10:38:01 -0400
Subject: [PATCH 0029/1315] allow more module declaration formats in module
 check (#51689)

---
 base/loading.jl |  4 ++--
 test/loading.jl | 14 ++++++++++++--
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 4eca0ea0e1200..25fe8144b71d6 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2252,7 +2252,7 @@ end
 Checks that a package entry file `srcpath` has a module declaration, and that it is before any using/import statements.
 """
 function check_src_module_wrap(pkg::PkgId, srcpath::String)
-    module_rgx = r"^\s*(?:@\w*\s*)*(?:bare)?module\s"
+    module_rgx = r"^(|end |\"\"\" )\s*(?:@)*(?:bare)?module\s"
     load_rgx = r"\b(?:using|import)\s"
     load_seen = false
     inside_string = false
@@ -2262,7 +2262,7 @@ function check_src_module_wrap(pkg::PkgId, srcpath::String)
             inside_string = !inside_string
         end
         inside_string && continue
-        if startswith(s, module_rgx)
+        if contains(s, module_rgx)
             if load_seen
                 throw(ErrorException("Package $pkg source file $srcpath has a using/import before a module declaration."))
             end
diff --git a/test/loading.jl b/test/loading.jl
index d7e967f209eaa..0ee3e3985cc84 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1223,8 +1223,18 @@ end
         @test Base.check_src_module_wrap(p, fpath)
 
         write(fpath, """
-        # using foo
-        module Foo
+        \"\"\"
+        Foo
+        \"\"\" module Foo
+        using Bar
+        end
+        """)
+        @test Base.check_src_module_wrap(p, fpath)
+
+        write(fpath, """
+        @doc let x = 1
+            x
+        end module Foo
         using Bar
         end
         """)

From cd8298400ff12c3a8b77d4eeb9415c9336c7305b Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Thu, 19 Oct 2023 17:12:15 +0200
Subject: [PATCH 0030/1315] fix `--bug-report=rr` (#51750)

This option is currently broken on nightly due to world age errors
---
 base/client.jl      | 2 +-
 test/cmdlineargs.jl | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/base/client.jl b/base/client.jl
index 5e7cd19ea480f..d66933e27e4d1 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -246,7 +246,7 @@ function exec_options(opts)
             # If we're doing a bug report, don't load anything else. We will
             # spawn a child in which to execute these options.
             let InteractiveUtils = load_InteractiveUtils()
-                InteractiveUtils.report_bug(arg)
+                invokelatest(InteractiveUtils.report_bug, arg)
             end
             return nothing
         else
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 95d65de0c01f2..fc6016da960c4 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -994,3 +994,9 @@ end
 # Test import from module
 @test readchomp(`$(Base.julia_cmd()) -e 'module Hello; export main; (@main)(ARGS) = println("hello"); end; using .Hello'`) == "hello"
 @test readchomp(`$(Base.julia_cmd()) -e 'module Hello; export main; (@main)(ARGS) = println("hello"); end; import .Hello'`) == ""
+
+# test --bug-report=rr
+if Sys.islinux() && Sys.ARCH in (:i686, :x86_64, :aarch64) # rr is only available on these platforms
+    # TODO: get this to work on CI
+    @test_skip success(setenv(`$(Base.julia_cmd()) --bug-report=rr-local -e 'exit()'`, "JULIA_RR_RECORD_ARGS" => "-n"))
+end

From d432821e0b869cae47e59d2541eee1243ee75630 Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Fri, 20 Oct 2023 02:16:42 +0200
Subject: [PATCH 0031/1315] fix return type of `exec_options` (#51787)

Should fix the failures observed in JuliaLang/BugReporting.jl#141. Test
for this is in #51776 which depends on afromentioned PR which depends on
this fix.
---
 base/client.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/client.jl b/base/client.jl
index d66933e27e4d1..7339bf0870990 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -248,7 +248,7 @@ function exec_options(opts)
             let InteractiveUtils = load_InteractiveUtils()
                 invokelatest(InteractiveUtils.report_bug, arg)
             end
-            return nothing
+            return false
         else
             @warn "Unexpected command -$cmd'$arg'"
         end

From f2df1b41b85843120a9715449eb5ff555a4a172d Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Fri, 20 Oct 2023 02:56:22 +0200
Subject: [PATCH 0032/1315] Make precompile files relocatable (#49866)

String replacement with `@depot` when serializing out happens with any
paths that are located inside a `DEPOT_PATH` (first match wins). If no
match, then we emit the absolute file path as before. Right now we only
emit one token `@depot`.

String replacement of `@depot` when loading happens now on a `.ji` file
basis and only if all the listed include dependencies can be resolved to
files located in one and the same depot on `DEPOT_PATH` (again, first
match wins). If we can't resolve, then the cache is invalided with
`stale_cachefile`.
---
 base/loading.jl                               | 200 ++++++++++++------
 base/sysimg.jl                                |   5 +-
 doc/src/manual/modules.md                     |  10 +-
 src/precompile.c                              |  34 ++-
 src/staticdata.c                              |   5 +-
 src/staticdata_utils.c                        |  26 ++-
 test/.gitignore                               |   2 +
 test/Makefile                                 |  26 ++-
 test/RelocationTestPkg1/Project.toml          |   4 +
 .../src/RelocationTestPkg1.jl                 |   5 +
 test/RelocationTestPkg1/src/foo.txt           |   0
 test/RelocationTestPkg2/Project.toml          |   4 +
 .../src/RelocationTestPkg2.jl                 |   6 +
 test/RelocationTestPkg2/src/foo.txt           |   0
 test/choosetests.jl                           |   2 +-
 test/precompile.jl                            |  16 +-
 test/relocatedepot.jl                         | 104 +++++++++
 test/testenv.jl                               |   2 +
 18 files changed, 360 insertions(+), 91 deletions(-)
 create mode 100644 test/RelocationTestPkg1/Project.toml
 create mode 100644 test/RelocationTestPkg1/src/RelocationTestPkg1.jl
 create mode 100644 test/RelocationTestPkg1/src/foo.txt
 create mode 100644 test/RelocationTestPkg2/Project.toml
 create mode 100644 test/RelocationTestPkg2/src/RelocationTestPkg2.jl
 create mode 100644 test/RelocationTestPkg2/src/foo.txt
 create mode 100644 test/relocatedepot.jl

diff --git a/base/loading.jl b/base/loading.jl
index 25fe8144b71d6..1f6bb5442540a 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -371,7 +371,7 @@ its `PkgId`, or `nothing` if it cannot be found.
 If only the `name` argument is provided, it searches each environment in the
 stack and its named direct dependencies.
 
-There `where` argument provides the context from where to search for the
+The `where` argument provides the context from where to search for the
 package: in this case it first checks if the name matches the context itself,
 otherwise it searches all recursive dependencies (from the resolved manifest of
 each environment) until it locates the context `where`, and from there
@@ -1503,7 +1503,7 @@ function _tryrequire_from_serialized(pkg::PkgId, path::String, ocachepath::Union
     io = open(path, "r")
     try
         iszero(isvalid_cache_header(io)) && return ArgumentError("Invalid header in cache file $path.")
-        _, _, depmodnames, _, _, _, clone_targets, _ = parse_cache_header(io)
+        _, _, depmodnames, _, _, _, clone_targets, _ = parse_cache_header(io, path)
         pkgimage = !isempty(clone_targets)
         if pkgimage
             ocachepath !== nothing || return ArgumentError("Expected ocachepath to be provided")
@@ -1660,9 +1660,9 @@ const include_callbacks = Any[]
 
 # used to optionally track dependencies when requiring a module:
 const _concrete_dependencies = Pair{PkgId,UInt128}[] # these dependency versions are "set in stone", and the process should try to avoid invalidating them
-const _require_dependencies = Any[] # a list of (mod, path, mtime) tuples that are the file dependencies of the module currently being precompiled
+const _require_dependencies = Any[] # a list of (mod, abspath, fsize, hash, mtime) tuples that are the file dependencies of the module currently being precompiled
 const _track_dependencies = Ref(false) # set this to true to track the list of file dependencies
-function _include_dependency(mod::Module, _path::AbstractString)
+function _include_dependency(mod::Module, _path::AbstractString; track_content=true)
     prev = source_path(nothing)
     if prev === nothing
         path = abspath(_path)
@@ -1671,7 +1671,15 @@ function _include_dependency(mod::Module, _path::AbstractString)
     end
     if _track_dependencies[]
         @lock require_lock begin
-        push!(_require_dependencies, (mod, path, mtime(path)))
+            if track_content
+                @assert isfile(path) "can only hash files"
+                # use mtime=-1.0 here so that fsize==0 && mtime==0.0 corresponds to a missing include_dependency
+                push!(_require_dependencies,
+                      (mod, path, filesize(path), open(_crc32c, path, "r"), -1.0))
+            else
+                push!(_require_dependencies,
+                      (mod, path, UInt64(0), UInt32(0), mtime(path)))
+            end
         end
     end
     return path, prev
@@ -1688,7 +1696,7 @@ This is only needed if your module depends on a path that is not used via [`incl
 no effect outside of compilation.
 """
 function include_dependency(path::AbstractString)
-    _include_dependency(Main, path)
+    _include_dependency(Main, path, track_content=false)
     return nothing
 end
 
@@ -1787,7 +1795,8 @@ function __require(into::Module, mod::Symbol)
         end
         uuidkey, env = uuidkey_env
         if _track_dependencies[]
-            push!(_require_dependencies, (into, binpack(uuidkey), 0.0))
+            path = binpack(uuidkey)
+            push!(_require_dependencies, (into, path, UInt64(0), UInt32(0), 0.0))
         end
         return _require_prelocked(uuidkey, env)
     finally
@@ -2580,14 +2589,46 @@ function isvalid_pkgimage_crc(f::IOStream, ocachefile::String)
     expected_crc_so == crc_so
 end
 
-struct CacheHeaderIncludes
-    id::PkgId
+mutable struct CacheHeaderIncludes
+    const id::PkgId
     filename::String
-    mtime::Float64
-    modpath::Vector{String}   # seemingly not needed in Base, but used by Revise
+    const fsize::UInt64
+    const hash::UInt32
+    const mtime::Float64
+    const modpath::Vector{String}   # seemingly not needed in Base, but used by Revise
+end
+
+function replace_depot_path(path::AbstractString)
+    for depot in DEPOT_PATH
+        if startswith(path, depot)
+            path = replace(path, depot => "@depot")
+            break
+        end
+    end
+    return path
+end
+
+# Find depot in DEPOT_PATH for which all @depot tags from the `includes`
+# can be replaced so that they point to a file on disk each.
+# Return nothing when no depot matched.
+function resolve_depot(includes)
+    if any(includes) do inc
+            !startswith(inc, "@depot")
+        end
+        return :missing_depot_tag
+    end
+    for depot in DEPOT_PATH
+        if all(includes) do inc
+                isfile(replace(inc, r"^@depot" => depot))
+            end
+            return depot
+        end
+    end
+    return :no_depot_found
 end
 
-function parse_cache_header(f::IO)
+
+function parse_cache_header(f::IO, cachefile::AbstractString)
     flags = read(f, UInt8)
     modules = Vector{Pair{PkgId, UInt64}}()
     while true
@@ -2598,7 +2639,7 @@ function parse_cache_header(f::IO)
         build_id = read(f, UInt64) # build UUID (mostly just a timestamp)
         push!(modules, PkgId(uuid, sym) => build_id)
     end
-    totbytes = read(f, Int64) # total bytes for file dependencies + preferences
+    totbytes = Int64(read(f, UInt64)) # total bytes for file dependencies + preferences
     # read the list of requirements
     # and split the list into include and requires statements
     includes = CacheHeaderIncludes[]
@@ -2611,6 +2652,10 @@ function parse_cache_header(f::IO)
         end
         depname = String(read(f, n2))
         totbytes -= n2
+        fsize = read(f, UInt64)
+        totbytes -= 8
+        hash = read(f, UInt32)
+        totbytes -= 4
         mtime = read(f, Float64)
         totbytes -= 8
         n1 = read(f, Int32)
@@ -2633,7 +2678,7 @@ function parse_cache_header(f::IO)
         if depname[1] == '\0'
             push!(requires, modkey => binunpack(depname))
         else
-            push!(includes, CacheHeaderIncludes(modkey, depname, mtime, modpath))
+            push!(includes, CacheHeaderIncludes(modkey, depname, fsize, hash, mtime, modpath))
         end
     end
     prefs = String[]
@@ -2665,69 +2710,90 @@ function parse_cache_header(f::IO)
     l = read(f, Int32)
     clone_targets = read(f, l)
 
-    return modules, (includes, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags
+    # determine path for @depot replacement from srctext files only, e.g. ignore any include_dependency files
+    srcfiles = srctext_files(f, srctextpos, includes)
+    depot = resolve_depot(srcfiles)
+    keepidx = Int[]
+    for (i, chi) in enumerate(includes)
+        chi.filename ∈ srcfiles && push!(keepidx, i)
+    end
+    if depot === :no_depot_found
+        throw(ArgumentError("""
+              Failed to determine depot from srctext files in cache file $cachefile.
+              - Make sure you have adjusted DEPOT_PATH in case you relocated depots."""))
+    elseif depot === :missing_depot_tag
+        @debug "Missing @depot tag for include dependencies in cache file $cachefile."
+    else
+        for inc in includes
+            inc.filename = replace(inc.filename, r"^@depot" => depot)
+        end
+    end
+    includes_srcfiles_only = includes[keepidx]
+
+    return modules, (includes, includes_srcfiles_only, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags
 end
 
-function parse_cache_header(cachefile::String; srcfiles_only::Bool=false)
+function parse_cache_header(cachefile::String)
     io = open(cachefile, "r")
     try
         iszero(isvalid_cache_header(io)) && throw(ArgumentError("Invalid header in cache file $cachefile."))
-        ret = parse_cache_header(io)
-        srcfiles_only || return ret
-        _, (includes, _), _, srctextpos, _... = ret
-        srcfiles = srctext_files(io, srctextpos)
-        delidx = Int[]
-        for (i, chi) in enumerate(includes)
-            chi.filename ∈ srcfiles || push!(delidx, i)
-        end
-        deleteat!(includes, delidx)
+        ret = parse_cache_header(io, cachefile)
         return ret
     finally
         close(io)
     end
 end
 
-preferences_hash(f::IO) = parse_cache_header(f)[6]
+preferences_hash(f::IO, cachefile::AbstractString) = parse_cache_header(f, cachefile)[6]
 function preferences_hash(cachefile::String)
     io = open(cachefile, "r")
     try
         if iszero(isvalid_cache_header(io))
             throw(ArgumentError("Invalid header in cache file $cachefile."))
         end
-        return preferences_hash(io)
+        return preferences_hash(io, cachefile)
     finally
         close(io)
     end
 end
 
-function cache_dependencies(f::IO)
-    _, (includes, _), modules, _... = parse_cache_header(f)
-    return modules, map(chi -> (chi.filename, chi.mtime), includes)  # return just filename and mtime
+function cache_dependencies(f::IO, cachefile::AbstractString)
+    _, (includes, _, _), modules, _... = parse_cache_header(f, cachefile)
+    return modules, map(chi -> chi.filename, includes)  # return just filename
 end
 
 function cache_dependencies(cachefile::String)
     io = open(cachefile, "r")
     try
         iszero(isvalid_cache_header(io)) && throw(ArgumentError("Invalid header in cache file $cachefile."))
-        return cache_dependencies(io)
+        return cache_dependencies(io, cachefile)
     finally
         close(io)
     end
 end
 
-function read_dependency_src(io::IO, filename::AbstractString)
-    srctextpos = parse_cache_header(io)[4]
+function read_dependency_src(io::IO, cachefile::AbstractString, filename::AbstractString)
+    _, (includes, _, _), _, srctextpos, _, _, _, _ = parse_cache_header(io, cachefile)
     srctextpos == 0 && error("no source-text stored in cache file")
     seek(io, srctextpos)
-    return _read_dependency_src(io, filename)
+    return _read_dependency_src(io, filename, includes)
 end
 
-function _read_dependency_src(io::IO, filename::AbstractString)
+function _read_dependency_src(io::IO, filename::AbstractString, includes::Vector{CacheHeaderIncludes}=CacheHeaderIncludes[])
     while !eof(io)
         filenamelen = read(io, Int32)
         filenamelen == 0 && break
-        fn = String(read(io, filenamelen))
+        depotfn = String(read(io, filenamelen))
         len = read(io, UInt64)
+        fn = if !startswith(depotfn, "@depot")
+            depotfn
+        else
+            basefn = replace(depotfn, r"^@depot" => "")
+            idx = findfirst(includes) do inc
+                endswith(inc.filename, basefn)
+            end
+            isnothing(idx) ? depotfn : includes[idx].filename
+        end
         if fn == filename
             return String(read(io, len))
         end
@@ -2740,22 +2806,22 @@ function read_dependency_src(cachefile::String, filename::AbstractString)
     io = open(cachefile, "r")
     try
         iszero(isvalid_cache_header(io)) && throw(ArgumentError("Invalid header in cache file $cachefile."))
-        return read_dependency_src(io, filename)
+        return read_dependency_src(io, cachefile, filename)
     finally
         close(io)
     end
 end
 
-function srctext_files(f::IO, srctextpos::Int64)
+function srctext_files(f::IO, srctextpos::Int64, includes::Vector{CacheHeaderIncludes})
     files = Set{String}()
     srctextpos == 0 && return files
     seek(f, srctextpos)
     while !eof(f)
         filenamelen = read(f, Int32)
         filenamelen == 0 && break
-        fn = String(read(f, filenamelen))
+        filename = String(read(f, filenamelen))
         len = read(f, UInt64)
-        push!(files, fn)
+        push!(files, filename)
         seek(f, position(f) + len)
     end
     return files
@@ -3098,7 +3164,7 @@ end
             @debug "Rejecting cache file $cachefile due to it containing an invalid cache header"
             return true # invalid cache file
         end
-        modules, (includes, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags = parse_cache_header(io)
+        modules, (includes, _, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags = parse_cache_header(io, cachefile)
         if isempty(modules)
             return true # ignore empty file
         end
@@ -3141,7 +3207,7 @@ end
         if build_id != UInt128(0)
             id_build = (UInt128(checksum) << 64) | id.second
             if id_build != build_id
-                @debug "Ignoring cache file $cachefile for $modkey ($((UUID(id_build)))) since it is does not provide desired build_id ($((UUID(build_id))))"
+                @debug "Ignoring cache file $cachefile for $modkey ($((UUID(id_build)))) since it does not provide desired build_id ($((UUID(build_id))))"
                 return true
             end
         end
@@ -3179,13 +3245,13 @@ end
         # check if this file is going to provide one of our concrete dependencies
         # or if it provides a version that conflicts with our concrete dependencies
         # or neither
-        skip_timecheck = false
+        skip_check = false
         for (req_key, req_build_id) in _concrete_dependencies
             build_id = get(modules, req_key, UInt64(0))
             if build_id !== UInt64(0)
                 build_id |= UInt128(checksum) << 64
                 if build_id === req_build_id
-                    skip_timecheck = true
+                    skip_check = true
                     break
                 end
                 @debug "Rejecting cache file $cachefile because it provides the wrong build_id (got $((UUID(build_id)))) for $req_key (want $(UUID(req_build_id)))"
@@ -3193,40 +3259,54 @@ end
             end
         end
 
-        # now check if this file is fresh relative to its source files
-        if !skip_timecheck
+        # now check if this file's content hash has changed relative to its source files
+        if !skip_check
             if !samefile(includes[1].filename, modpath) && !samefile(fixup_stdlib_path(includes[1].filename), modpath)
                 @debug "Rejecting cache file $cachefile because it is for file $(includes[1].filename) not file $modpath"
                 return true # cache file was compiled from a different path
             end
             for (modkey, req_modkey) in requires
                 # verify that `require(modkey, name(req_modkey))` ==> `req_modkey`
-                if identify_package(modkey, req_modkey.name) != req_modkey
-                    @debug "Rejecting cache file $cachefile because uuid mapping for $modkey => $req_modkey has changed"
+                pkg = identify_package(modkey, req_modkey.name)
+                if pkg != req_modkey
+                    @debug "Rejecting cache file $cachefile because uuid mapping for $modkey => $req_modkey has changed, expected $modkey => $pkg"
                     return true
                 end
             end
             for chi in includes
-                f, ftime_req = chi.filename, chi.mtime
+                f, fsize_req, hash_req, ftime_req = chi.filename, chi.fsize, chi.hash, chi.mtime
                 if !ispath(f)
                     _f = fixup_stdlib_path(f)
                     if isfile(_f) && startswith(_f, Sys.STDLIB)
-                        # mtime is changed by extraction
                         continue
                     end
                     @debug "Rejecting stale cache file $cachefile because file $f does not exist"
                     return true
                 end
-                ftime = mtime(f)
-                is_stale = ( ftime != ftime_req ) &&
-                           ( ftime != floor(ftime_req) ) &&           # Issue #13606, PR #13613: compensate for Docker images rounding mtimes
-                           ( ftime != ceil(ftime_req) ) &&            # PR: #47433 Compensate for CirceCI's truncating of timestamps in its caching
-                           ( ftime != trunc(ftime_req, digits=6) ) && # Issue #20837, PR #20840: compensate for GlusterFS truncating mtimes to microseconds
-                           ( ftime != 1.0 )  &&                       # PR #43090: provide compatibility with Nix mtime.
-                           !( 0 < (ftime_req - ftime) < 1e-6 )        # PR #45552: Compensate for Windows tar giving mtimes that may be incorrect by up to one microsecond
-                if is_stale
-                    @debug "Rejecting stale cache file $cachefile (mtime $ftime_req) because file $f (mtime $ftime) has changed"
-                    return true
+                if ftime_req >= 0.0
+                    # this is an include_dependency for which we only recorded the mtime
+                    ftime = mtime(f)
+                    is_stale = ( ftime != ftime_req ) &&
+                               ( ftime != floor(ftime_req) ) &&           # Issue #13606, PR #13613: compensate for Docker images rounding mtimes
+                               ( ftime != ceil(ftime_req) ) &&            # PR: #47433 Compensate for CirceCI's truncating of timestamps in its caching
+                               ( ftime != trunc(ftime_req, digits=6) ) && # Issue #20837, PR #20840: compensate for GlusterFS truncating mtimes to microseconds
+                               ( ftime != 1.0 )  &&                       # PR #43090: provide compatibility with Nix mtime.
+                               !( 0 < (ftime_req - ftime) < 1e-6 )        # PR #45552: Compensate for Windows tar giving mtimes that may be incorrect by up to one microsecond
+                    if is_stale
+                        @debug "Rejecting stale cache file $cachefile because mtime of include_dependency $f has changed (mtime $ftime, before $ftime_req)"
+                        return true
+                    end
+                else
+                    fsize = filesize(f)
+                    if fsize != fsize_req
+                        @debug "Rejecting stale cache file $cachefile because file size of $f has changed (file size $fsize, before $fsize_req)"
+                        return true
+                    end
+                    hash = open(_crc32c, f, "r")
+                    if hash != hash_req
+                        @debug "Rejecting stale cache file $cachefile because hash of $f has changed (hash $hash, before $hash_req)"
+                        return true
+                    end
                 end
             end
         end
diff --git a/base/sysimg.jl b/base/sysimg.jl
index bf8de0bc3f75e..a4bf21786c633 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -59,8 +59,9 @@ let
             print_time(stdlib, tt)
         end
         for dep in Base._require_dependencies
-            dep[3] == 0.0 && continue
-            push!(Base._included_files, dep[1:2])
+            mod, path, fsize, mtime = dep[1], dep[2], dep[3], dep[5]
+            (fsize == 0 || mtime == 0.0) && continue
+            push!(Base._included_files, (mod, path))
         end
         empty!(Base._require_dependencies)
         Base._track_dependencies[] = false
diff --git a/doc/src/manual/modules.md b/doc/src/manual/modules.md
index b329dbc91b923..4be08edc56f38 100644
--- a/doc/src/manual/modules.md
+++ b/doc/src/manual/modules.md
@@ -447,10 +447,12 @@ recompiled upon `using` or `import`. Dependencies are modules it
 imports, the Julia build, files it includes, or explicit dependencies declared by [`include_dependency(path)`](@ref)
 in the module file(s).
 
-For file dependencies, a change is determined by examining whether the modification time (`mtime`)
-of each file loaded by `include` or added explicitly by `include_dependency` is unchanged, or equal
-to the modification time truncated to the nearest second (to accommodate systems that can't copy
-mtime with sub-second accuracy). It also takes into account whether the path to the file chosen
+For file dependencies loaded by `include`, a change is determined by examining whether the
+file size (`fsize`) or content (condensed into a hash) is unchanged.
+For file dependencies loaded by `include_dependency` a change is determined by examining whether the modification time (`mtime`)
+is unchanged, or equal to the modification time truncated to the nearest second
+(to accommodate systems that can't copy mtime with sub-second accuracy).
+It also takes into account whether the path to the file chosen
 by the search logic in `require` matches the path that had created the precompile file. It also takes
 into account the set of dependencies already loaded into the current process and won't recompile those
 modules, even if their files change or disappear, in order to avoid creating incompatibilities between
diff --git a/src/precompile.c b/src/precompile.c
index f6266e252f609..ad33dcd9b6d65 100644
--- a/src/precompile.c
+++ b/src/precompile.c
@@ -36,26 +36,43 @@ void write_srctext(ios_t *f, jl_array_t *udeps, int64_t srctextpos) {
         //   char*: src text
         // At the end we write int32(0) as a terminal sentinel.
         size_t len = jl_array_len(udeps);
+        static jl_value_t *replace_depot_func = NULL;
+        if (!replace_depot_func)
+            replace_depot_func = jl_get_global(jl_base_module, jl_symbol("replace_depot_path"));
         ios_t srctext;
+        jl_value_t *deptuple = NULL;
+        JL_GC_PUSH2(&deptuple, &udeps);
         for (size_t i = 0; i < len; i++) {
-            jl_value_t *deptuple = jl_array_ptr_ref(udeps, i);
+            deptuple = jl_array_ptr_ref(udeps, i);
             jl_value_t *depmod = jl_fieldref(deptuple, 0);  // module
             // Dependencies declared with `include_dependency` are excluded
             // because these may not be Julia code (and could be huge)
             if (depmod != (jl_value_t*)jl_main_module) {
-                jl_value_t *dep = jl_fieldref(deptuple, 1);  // file abspath
-                const char *depstr = jl_string_data(dep);
-                if (!depstr[0])
+                jl_value_t *abspath = jl_fieldref(deptuple, 1);  // file abspath
+                const char *abspathstr = jl_string_data(abspath);
+                if (!abspathstr[0])
                     continue;
-                ios_t *srctp = ios_file(&srctext, depstr, 1, 0, 0, 0);
+                ios_t *srctp = ios_file(&srctext, abspathstr, 1, 0, 0, 0);
                 if (!srctp) {
                     jl_printf(JL_STDERR, "WARNING: could not cache source text for \"%s\".\n",
-                            jl_string_data(dep));
+                              abspathstr);
                     continue;
                 }
-                size_t slen = jl_string_len(dep);
+
+                jl_value_t **replace_depot_args;
+                JL_GC_PUSHARGS(replace_depot_args, 2);
+                replace_depot_args[0] = replace_depot_func;
+                replace_depot_args[1] = abspath;
+                jl_task_t *ct = jl_current_task;
+                size_t last_age = ct->world_age;
+                ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
+                jl_value_t *depalias = (jl_value_t*)jl_apply(replace_depot_args, 2);
+                ct->world_age = last_age;
+                JL_GC_POP();
+
+                size_t slen = jl_string_len(depalias);
                 write_int32(f, slen);
-                ios_write(f, depstr, slen);
+                ios_write(f, jl_string_data(depalias), slen);
                 posfile = ios_pos(f);
                 write_uint64(f, 0);   // placeholder for length of this file in bytes
                 uint64_t filelen = (uint64_t) ios_copyall(f, &srctext);
@@ -65,6 +82,7 @@ void write_srctext(ios_t *f, jl_array_t *udeps, int64_t srctextpos) {
                 ios_seek_end(f);
             }
         }
+        JL_GC_POP();
     }
     write_int32(f, 0); // mark the end of the source text
 }
diff --git a/src/staticdata.c b/src/staticdata.c
index c684bee4c485b..69226408f711b 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -2691,8 +2691,9 @@ static void jl_write_header_for_incremental(ios_t *f, jl_array_t *worklist, jl_a
     write_uint8(f, jl_cache_flags());
     // write description of contents (name, uuid, buildid)
     write_worklist_for_header(f, worklist);
-    // Determine unique (module, abspath, mtime) dependencies for the files defining modules in the worklist
-    // (see Base._require_dependencies). These get stored in `udeps` and written to the ji-file header.
+    // Determine unique (module, abspath, fsize, hash, mtime) dependencies for the files defining modules in the worklist
+    // (see Base._require_dependencies). These get stored in `udeps` and written to the ji-file header
+    // (abspath will be converted to a relocateable @depot path before writing, cf. Base.replace_depot_path).
     // Also write Preferences.
     // last word of the dependency list is the end of the data / start of the srctextpos
     *srctextpos = write_dependency_list(f, worklist, udeps);  // srctextpos: position of srctext entry in header index (update later)
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index a4cbc3fd5ebc4..047042795d128 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -706,6 +706,10 @@ static int64_t write_dependency_list(ios_t *s, jl_array_t* worklist, jl_array_t
     jl_array_t *udeps = (*udepsp = deps && unique_func ? (jl_array_t*)jl_apply(uniqargs, 2) : NULL);
     ct->world_age = last_age;
 
+    static jl_value_t *replace_depot_func = NULL;
+    if (!replace_depot_func)
+        replace_depot_func = jl_get_global(jl_base_module, jl_symbol("replace_depot_path"));
+
     // write a placeholder for total size so that we can quickly seek past all of the
     // dependencies if we don't need them
     initial_pos = ios_pos(s);
@@ -713,11 +717,25 @@ static int64_t write_dependency_list(ios_t *s, jl_array_t* worklist, jl_array_t
     size_t i, l = udeps ? jl_array_len(udeps) : 0;
     for (i = 0; i < l; i++) {
         jl_value_t *deptuple = jl_array_ptr_ref(udeps, i);
-        jl_value_t *dep = jl_fieldref(deptuple, 1);              // file abspath
-        size_t slen = jl_string_len(dep);
+        jl_value_t *abspath = jl_fieldref(deptuple, 1);
+
+        jl_value_t **replace_depot_args;
+        JL_GC_PUSHARGS(replace_depot_args, 2);
+        replace_depot_args[0] = replace_depot_func;
+        replace_depot_args[1] = abspath;
+        ct = jl_current_task;
+        size_t last_age = ct->world_age;
+        ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
+        jl_value_t *depalias = (jl_value_t*)jl_apply(replace_depot_args, 2);
+        ct->world_age = last_age;
+        JL_GC_POP();
+
+        size_t slen = jl_string_len(depalias);
         write_int32(s, slen);
-        ios_write(s, jl_string_data(dep), slen);
-        write_float64(s, jl_unbox_float64(jl_fieldref(deptuple, 2)));  // mtime
+        ios_write(s, jl_string_data(depalias), slen);
+        write_uint64(s, jl_unbox_uint64(jl_fieldref(deptuple, 2)));    // fsize
+        write_uint32(s, jl_unbox_uint32(jl_fieldref(deptuple, 3)));    // hash
+        write_float64(s, jl_unbox_float64(jl_fieldref(deptuple, 4)));  // mtime
         jl_module_t *depmod = (jl_module_t*)jl_fieldref(deptuple, 0);  // evaluating module
         jl_module_t *depmod_top = depmod;
         while (depmod_top->parent != jl_main_module && depmod_top->parent != depmod_top)
diff --git a/test/.gitignore b/test/.gitignore
index a1af9ae3d44bf..fc55a0df3a173 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -2,3 +2,5 @@
 /ccalltest
 /ccalltest.s
 /libccalltest.*
+/relocatedepot
+/RelocationTestPkg2/src/foo.txt
diff --git a/test/Makefile b/test/Makefile
index 88dbe5b2b4ed6..d8605341ff9b9 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -14,7 +14,7 @@ unexport JULIA_BINDIR :=
 TESTGROUPS = unicode strings compiler
 TESTS = all default stdlib $(TESTGROUPS) \
 		$(patsubst $(STDLIBDIR)/%/,%,$(dir $(wildcard $(STDLIBDIR)/*/.))) \
-		$(filter-out runtests testdefs, \
+		$(filter-out runtests testdefs relocatedepot, \
 			$(patsubst $(SRCDIR)/%.jl,%,$(wildcard $(SRCDIR)/*.jl))) \
 		$(foreach group,$(TESTGROUPS), \
 			$(patsubst $(SRCDIR)/%.jl,%,$(wildcard $(SRCDIR)/$(group)/*.jl)))
@@ -34,6 +34,28 @@ $(addprefix revise-, $(TESTS)): revise-% :
 	@cd $(SRCDIR) && \
     $(call PRINT_JULIA, $(call spawn,$(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
 
+relocatedepot:
+	@rm -rf $(SRCDIR)/relocatedepot
+	@cd $(SRCDIR) && \
+	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
+	@mkdir $(SRCDIR)/relocatedepot
+	@cp -R $(build_datarootdir)/julia $(SRCDIR)/relocatedepot
+	@cp -R $(SRCDIR)/RelocationTestPkg1 $(SRCDIR)/relocatedepot
+	@cp -R $(SRCDIR)/RelocationTestPkg2 $(SRCDIR)/relocatedepot
+	@cd $(SRCDIR) && \
+	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading RELOCATEDEPOT="" JULIA_DEPOT_PATH=$(SRCDIR)/relocatedepot/julia $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
+
+revise-relocatedepot: revise-% :
+	@rm -rf $(SRCDIR)/relocatedepot
+	@cd $(SRCDIR) && \
+	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
+	@mkdir $(SRCDIR)/relocatedepot
+	@cp -R $(build_datarootdir)/julia $(SRCDIR)/relocatedepot
+	@cp -R $(SRCDIR)/RelocationTestPkg1 $(SRCDIR)/relocatedepot
+	@cp -R $(SRCDIR)/RelocationTestPkg2 $(SRCDIR)/relocatedepot
+	@cd $(SRCDIR) && \
+	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading RELOCATEDEPOT="" JULIA_DEPOT_PATH=$(SRCDIR)/relocatedepot/julia $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
+
 embedding:
 	@$(MAKE) -C $(SRCDIR)/$@ check $(EMBEDDING_ARGS)
 
@@ -47,4 +69,4 @@ clean:
 	@$(MAKE) -C embedding $@ $(EMBEDDING_ARGS)
 	@$(MAKE) -C gcext $@ $(GCEXT_ARGS)
 
-.PHONY: $(TESTS) $(addprefix revise-, $(TESTS)) embedding gcext clangsa clean
+.PHONY: $(TESTS) $(addprefix revise-, $(TESTS)) relocatedepot revise-relocatedepot embedding gcext clangsa clean
diff --git a/test/RelocationTestPkg1/Project.toml b/test/RelocationTestPkg1/Project.toml
new file mode 100644
index 0000000000000..826980207d508
--- /dev/null
+++ b/test/RelocationTestPkg1/Project.toml
@@ -0,0 +1,4 @@
+name = "RelocationTestPkg1"
+uuid = "854e1adb-5a97-46bf-a391-1cfe05ac726d"
+authors = ["flo "]
+version = "0.1.0"
diff --git a/test/RelocationTestPkg1/src/RelocationTestPkg1.jl b/test/RelocationTestPkg1/src/RelocationTestPkg1.jl
new file mode 100644
index 0000000000000..a86543a61b3f8
--- /dev/null
+++ b/test/RelocationTestPkg1/src/RelocationTestPkg1.jl
@@ -0,0 +1,5 @@
+module RelocationTestPkg1
+
+greet() = print("Hello World!")
+
+end # module RelocationTestPkg1
diff --git a/test/RelocationTestPkg1/src/foo.txt b/test/RelocationTestPkg1/src/foo.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/test/RelocationTestPkg2/Project.toml b/test/RelocationTestPkg2/Project.toml
new file mode 100644
index 0000000000000..68da889785215
--- /dev/null
+++ b/test/RelocationTestPkg2/Project.toml
@@ -0,0 +1,4 @@
+name = "RelocationTestPkg2"
+uuid = "8d933983-b090-4b0b-a37e-c34793f459d1"
+authors = ["flo "]
+version = "0.1.0"
diff --git a/test/RelocationTestPkg2/src/RelocationTestPkg2.jl b/test/RelocationTestPkg2/src/RelocationTestPkg2.jl
new file mode 100644
index 0000000000000..0d8b5e15edf06
--- /dev/null
+++ b/test/RelocationTestPkg2/src/RelocationTestPkg2.jl
@@ -0,0 +1,6 @@
+module RelocationTestPkg2
+
+include_dependency("foo.txt")
+greet() = print("Hello World!")
+
+end # module RelocationTestPkg2
diff --git a/test/RelocationTestPkg2/src/foo.txt b/test/RelocationTestPkg2/src/foo.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/test/choosetests.jl b/test/choosetests.jl
index 2f77b11767dee..221a49b710d8b 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -24,7 +24,7 @@ const TESTNAMES = [
         "some", "meta", "stacktraces", "docs", "gc",
         "misc", "threads", "stress", "binaryplatforms", "atexit",
         "enums", "cmdlineargs", "int", "interpreter",
-        "checked", "bitset", "floatfuncs", "precompile",
+        "checked", "bitset", "floatfuncs", "precompile", "relocatedepot",
         "boundscheck", "error", "ambiguous", "cartesian", "osutils",
         "channels", "iostream", "secretbuffer", "specificity",
         "reinterpretarray", "syntax", "corelogging", "missing", "asyncmap",
diff --git a/test/precompile.jl b/test/precompile.jl
index 671535c360625..fc4ab2490c4a8 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -381,8 +381,8 @@ precompile_test_harness(false) do dir
         @test string(Base.Docs.doc(Foo.Bar.bar)) == "bar function\n"
         @test string(Base.Docs.doc(Foo.Bar)) == "Bar module\n"
 
-        modules, (deps, requires), required_modules, _... = Base.parse_cache_header(cachefile)
-        discard_module = mod_fl_mt -> (mod_fl_mt.filename, mod_fl_mt.mtime)
+        modules, (deps, _, requires), required_modules, _... = Base.parse_cache_header(cachefile)
+        discard_module = mod_fl_mt -> mod_fl_mt.filename
         @test modules == [ Base.PkgId(Foo) => Base.module_build_id(Foo) % UInt64 ]
         @test map(x -> x.filename, deps) == [ Foo_file, joinpath(dir, "foo.jl"), joinpath(dir, "bar.jl") ]
         @test requires == [ Base.PkgId(Foo) => Base.PkgId(string(FooBase_module)),
@@ -422,7 +422,7 @@ precompile_test_harness(false) do dir
         @test Dict(modules) == modules_ok
 
         @test discard_module.(deps) == deps1
-        modules, (deps, requires), required_modules, _... = Base.parse_cache_header(cachefile; srcfiles_only=true)
+        modules, (_, deps, requires), required_modules, _... = Base.parse_cache_header(cachefile)
         @test map(x -> x.filename, deps) == [Foo_file]
 
         @test current_task()(0x01, 0x4000, 0x30031234) == 2
@@ -485,7 +485,7 @@ precompile_test_harness(false) do dir
         """)
     Nest = Base.require(Main, Nest_module)
     cachefile = joinpath(cachedir, "$Nest_module.ji")
-    modules, (deps, requires), required_modules, _... = Base.parse_cache_header(cachefile)
+    modules, (deps, _, requires), required_modules, _... = Base.parse_cache_header(cachefile)
     @test last(deps).modpath == ["NestInner"]
 
     UsesB_module = :UsesB4b3a94a1a081a8cb
@@ -507,7 +507,7 @@ precompile_test_harness(false) do dir
         """)
     UsesB = Base.require(Main, UsesB_module)
     cachefile = joinpath(cachedir, "$UsesB_module.ji")
-    modules, (deps, requires), required_modules, _... = Base.parse_cache_header(cachefile)
+    modules, (deps, _, requires), required_modules, _... = Base.parse_cache_header(cachefile)
     id1, id2 = only(requires)
     @test Base.pkgorigins[id1].cachepath == cachefile
     @test Base.pkgorigins[id2].cachepath == joinpath(cachedir, "$B_module.ji")
@@ -584,12 +584,12 @@ precompile_test_harness(false) do dir
     fb_uuid = Base.module_build_id(FooBar)
     sleep(2); touch(FooBar_file)
     insert!(DEPOT_PATH, 1, dir2)
-    @test Base.stale_cachefile(FooBar_file, joinpath(cachedir, "FooBar.ji")) === true
+    @test Base.stale_cachefile(FooBar_file, joinpath(cachedir, "FooBar.ji")) isa Tsc
     @eval using FooBar1
     @test !isfile(joinpath(cachedir2, "FooBar.ji"))
     @test !isfile(joinpath(cachedir, "FooBar1.ji"))
     @test isfile(joinpath(cachedir2, "FooBar1.ji"))
-    @test Base.stale_cachefile(FooBar_file, joinpath(cachedir, "FooBar.ji")) === true
+    @test Base.stale_cachefile(FooBar_file, joinpath(cachedir, "FooBar.ji")) isa Tsc
     @test Base.stale_cachefile(FooBar1_file, joinpath(cachedir2, "FooBar1.ji")) isa Tsc
     @test fb_uuid == Base.module_build_id(FooBar)
     fb_uuid1 = Base.module_build_id(FooBar1)
@@ -1712,7 +1712,7 @@ precompile_test_harness("PkgCacheInspector") do load_path
         try
             # isvalid_cache_header returns checksum id or zero
             Base.isvalid_cache_header(io) == 0 && throw(ArgumentError("Invalid header in cache file $cachefile."))
-            depmodnames = Base.parse_cache_header(io)[3]
+            depmodnames = Base.parse_cache_header(io, cachefile)[3]
             Base.isvalid_file_crc(io) || throw(ArgumentError("Invalid checksum in cache file $cachefile."))
         finally
             close(io)
diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
new file mode 100644
index 0000000000000..91f03d59cc168
--- /dev/null
+++ b/test/relocatedepot.jl
@@ -0,0 +1,104 @@
+using Test
+using Logging
+
+
+include("testenv.jl")
+
+
+function test_harness(@nospecialize(fn))
+    load_path = copy(LOAD_PATH)
+    depot_path = copy(DEPOT_PATH)
+    try
+        fn()
+    finally
+        copy!(LOAD_PATH, load_path)
+        copy!(DEPOT_PATH, depot_path)
+    end
+end
+
+
+if !test_relocated_depot
+
+    @testset "precompile RelocationTestPkg1" begin
+        pkgname = "RelocationTestPkg1"
+        test_harness() do
+            push!(LOAD_PATH, @__DIR__)
+            push!(DEPOT_PATH, @__DIR__)
+            pkg = Base.identify_package(pkgname)
+            cachefiles = Base.find_all_in_cache_path(pkg)
+            rm.(cachefiles, force=true)
+            @test Base.isprecompiled(pkg) == false
+            Base.require(pkg) # precompile
+            @test Base.isprecompiled(pkg, ignore_loaded=true) == true
+        end
+    end
+
+    @testset "precompile RelocationTestPkg2 (contains include_dependency)" begin
+        pkgname = "RelocationTestPkg2"
+        test_harness() do
+            push!(LOAD_PATH, @__DIR__)
+            push!(DEPOT_PATH, @__DIR__)
+            pkg = Base.identify_package(pkgname)
+            cachefiles = Base.find_all_in_cache_path(pkg)
+            rm.(cachefiles, force=true)
+            @test Base.isprecompiled(pkg) == false
+            touch(joinpath(@__DIR__, pkgname, "src", "foo.txt"))
+            Base.require(pkg) # precompile
+            @info "SERS OIDA"
+            @test Base.isprecompiled(pkg, ignore_loaded=true) == true
+        end
+    end
+
+else
+
+    # must come before any of the load tests, because the will recompile and generate new cache files
+    @testset "attempt loading precompiled pkgs when depot is missing" begin
+        test_harness() do
+            empty!(LOAD_PATH)
+            push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
+            for pkgname in ("RelocationTestPkg1", "RelocationTestPkg2")
+                pkg = Base.identify_package(pkgname)
+                cachefile = only(Base.find_all_in_cache_path(pkg))
+                @info cachefile
+                @test_throws ArgumentError("""
+                  Failed to determine depot from srctext files in cache file $cachefile.
+                  - Make sure you have adjusted DEPOT_PATH in case you relocated depots.""") Base.isprecompiled(pkg)
+            end
+        end
+    end
+
+    @testset "load stdlib from test/relocatedepot" begin
+        test_harness() do
+            push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot"))
+            # stdlib should be already precompiled
+            pkg = Base.identify_package("DelimitedFiles")
+            @test Base.isprecompiled(pkg) == true
+        end
+    end
+
+    @testset "load RelocationTestPkg1 from test/relocatedepot" begin
+        pkgname = "RelocationTestPkg1"
+        test_harness() do
+            push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot"))
+            pkg = Base.identify_package(pkgname)
+            @test Base.isprecompiled(pkg) == true
+            Base.require(pkg) # re-precompile
+            @test Base.isprecompiled(pkg) == true
+        end
+    end
+
+    @testset "load RelocationTestPkg2 (contains include_dependency) from test/relocatedepot" begin
+        pkgname = "RelocationTestPkg2"
+        test_harness() do
+            push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot"))
+            pkg = Base.identify_package(pkgname)
+            @test Base.isprecompiled(pkg) == false # moving depot changes mtime of include_dependency
+            Base.require(pkg) # re-precompile
+            @test Base.isprecompiled(pkg) == true
+        end
+    end
+
+end
diff --git a/test/testenv.jl b/test/testenv.jl
index 6f99291e01138..3ef1126e0e927 100644
--- a/test/testenv.jl
+++ b/test/testenv.jl
@@ -35,6 +35,8 @@ if !@isdefined(testenv_defined)
         const rr_exename = ``
     end
 
+    const test_relocated_depot = haskey(ENV, "RELOCATEDEPOT")
+
     function addprocs_with_testenv(X; rr_allowed=true, kwargs...)
         exename = rr_allowed ? `$rr_exename $test_exename` : test_exename
         if X isa Integer

From 795d8d7a033cb711f5914b0da7587ab55edb0f39 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 20 Oct 2023 07:26:06 +0200
Subject: [PATCH 0033/1315] fix parallel peakflop usage (#51757)

This is required now once Distributed is not in the sysimage.

Fixes https://github.com/JuliaLang/julia/issues/51756
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index ca95214b1bbd1..b372ef26a46d4 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -619,7 +619,9 @@ function peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3
     if parallel
         let Distributed = Base.require(Base.PkgId(
                 Base.UUID((0x8ba89e20_285c_5b6f, 0x9357_94700520ee1b)), "Distributed"))
-            return sum(Distributed.pmap(peakflops, fill(n, Distributed.nworkers())))
+            nworkers = @invokelatest Distributed.nworkers()
+            results = @invokelatest Distributed.pmap(peakflops, fill(n, nworkers))
+            return sum(results)
         end
     else
         return 2*Float64(n)^3 / minimum(t)

From f8f573dc0ddb10a9ca33d3e624f6e806fb68afb3 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Fri, 20 Oct 2023 00:31:14 -0500
Subject: [PATCH 0034/1315] Fix reference in manual (#51741)

---
 doc/src/manual/multi-threading.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/multi-threading.md b/doc/src/manual/multi-threading.md
index f3b65c74b31d3..b1495192e752c 100644
--- a/doc/src/manual/multi-threading.md
+++ b/doc/src/manual/multi-threading.md
@@ -450,7 +450,8 @@ threads in Julia:
     method, and module definitions in parallel.
   * Be aware that finalizers registered by a library may break if threads are enabled.
     This may require some transitional work across the ecosystem before threading
-    can be widely adopted with confidence. See the next section for further details.
+    can be widely adopted with confidence. See the section on
+    [the safe use of finalizers](@ref man-finalizers) for further details.
 
 ## [Task Migration](@id man-task-migration)
 
@@ -466,7 +467,7 @@ and therefore should not be used to index into a vector of buffers or stateful o
     Task migration was introduced in Julia 1.7. Before this tasks always remained on the same thread that they were
     started on.
 
-## Safe use of Finalizers
+## [Safe use of Finalizers](@id man-finalizers)
 
 Because finalizers can interrupt any code, they must be very careful in how
 they interact with any global state. Unfortunately, the main reason that

From ef3bf66d5e1d60c9b604eb6e01539eb1c3aced90 Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Fri, 20 Oct 2023 10:21:56 +0200
Subject: [PATCH 0035/1315] Use a single Float16 ABI. (#51666)

Currently, Julia uses 2 different Float16 ABIs, depending on the host compiler used to
compile Julia: either pass as integer, or pass as LLVM's native `half`. Since the runtime
intrinsics are implemented in C using `uint16`, this necessitated conversions around the
runtime functions (`gnu_h2f_ieee`, `truncdfhf2`, etc) that the compiler may emit calls to.

This PR switches to always using the 'native' ABIs that platforms have for Float16,
by removing the conversions around runtime calls, and defining our runtime intrinsics
using the native `_Float16` type. Availability of this type depends on the platform, and
the compiler version, so we also define fallbacks that mimick the platform-specific
calling convention.
---
 base/ctypes.jl           |   4 +
 src/APInt-C.cpp          |   9 +-
 src/abi_ppc64le.cpp      |   8 +-
 src/abi_x86_64.cpp       |   3 +-
 src/aotcompile.cpp       |   9 +-
 src/codegen.cpp          |  55 ---------
 src/jitlayers.cpp        |   5 +-
 src/julia_internal.h     |  20 +---
 src/llvm-version.h       |   9 --
 src/runtime_intrinsics.c | 253 ++++++++++++++++++++++++++-------------
 test/intrinsics.jl       |  22 +---
 11 files changed, 207 insertions(+), 190 deletions(-)

diff --git a/base/ctypes.jl b/base/ctypes.jl
index 26640ed82bef5..45f01b684902f 100644
--- a/base/ctypes.jl
+++ b/base/ctypes.jl
@@ -113,3 +113,7 @@ const Cfloat = Float32
 Equivalent to the native `double` c-type ([`Float64`](@ref)).
 """
 const Cdouble = Float64
+
+
+# we have no `Float16` alias, because C does not define a standard fp16 type. Julia follows
+# the _Float16 C ABI; if that becomes standard, we can add an appropriate alias here.
diff --git a/src/APInt-C.cpp b/src/APInt-C.cpp
index f06d4362bf958..7ff68edb0868c 100644
--- a/src/APInt-C.cpp
+++ b/src/APInt-C.cpp
@@ -313,10 +313,13 @@ void LLVMByteSwap(unsigned numbits, integerPart *pa, integerPart *pr) {
     ASSIGN(r, a)
 }
 
+extern "C" float julia_half_to_float(uint16_t ival) JL_NOTSAFEPOINT;
+extern "C" uint16_t julia_float_to_half(float param) JL_NOTSAFEPOINT;
+
 void LLVMFPtoInt(unsigned numbits, void *pa, unsigned onumbits, integerPart *pr, bool isSigned, bool *isExact) {
     double Val;
     if (numbits == 16)
-        Val = julia__gnu_h2f_ieee(*(uint16_t*)pa);
+        Val = julia_half_to_float(*(uint16_t*)pa);
     else if (numbits == 32)
         Val = *(float*)pa;
     else if (numbits == 64)
@@ -391,7 +394,7 @@ void LLVMSItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPar
         val = a.roundToDouble(true);
     }
     if (onumbits == 16)
-        *(uint16_t*)pr = julia__gnu_f2h_ieee(val);
+        *(uint16_t*)pr = julia_float_to_half(val);
     else if (onumbits == 32)
         *(float*)pr = val;
     else if (onumbits == 64)
@@ -408,7 +411,7 @@ void LLVMUItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPar
         val = a.roundToDouble(false);
     }
     if (onumbits == 16)
-        *(uint16_t*)pr = julia__gnu_f2h_ieee(val);
+        *(uint16_t*)pr = julia_float_to_half(val);
     else if (onumbits == 32)
         *(float*)pr = val;
     else if (onumbits == 64)
diff --git a/src/abi_ppc64le.cpp b/src/abi_ppc64le.cpp
index 2e18acdbd4f4b..44d110422a099 100644
--- a/src/abi_ppc64le.cpp
+++ b/src/abi_ppc64le.cpp
@@ -118,7 +118,12 @@ bool needPassByRef(jl_datatype_t *dt, AttrBuilder &ab, LLVMContext &ctx, Type *T
 Type *preferred_llvm_type(jl_datatype_t *dt, bool isret, LLVMContext &ctx) const override
 {
     // Arguments are either scalar or passed by value
-    size_t size = jl_datatype_size(dt);
+
+    // LLVM passes Float16 in floating-point registers, but this doesn't match the ABI.
+    // No C compiler seems to support _Float16 yet, so in the meantime, pass as i16
+    if (dt == jl_float16_type || dt == jl_bfloat16_type)
+        return Type::getInt16Ty(ctx);
+
     // don't need to change bitstypes
     if (!jl_datatype_nfields(dt))
         return NULL;
@@ -143,6 +148,7 @@ Type *preferred_llvm_type(jl_datatype_t *dt, bool isret, LLVMContext &ctx) const
     }
     // rewrite integer-sized (non-HFA) struct to an array
     // the bitsize of the integer gives the desired alignment
+    size_t size = jl_datatype_size(dt);
     if (size > 8) {
         if (jl_datatype_align(dt) <= 8) {
             Type  *T_int64 = Type::getInt64Ty(ctx);
diff --git a/src/abi_x86_64.cpp b/src/abi_x86_64.cpp
index 7800c44b4d3ae..5938e1e5778a2 100644
--- a/src/abi_x86_64.cpp
+++ b/src/abi_x86_64.cpp
@@ -118,7 +118,8 @@ struct Classification {
 void classifyType(Classification& accum, jl_datatype_t *dt, uint64_t offset) const
 {
     // Floating point types
-    if (dt == jl_float64_type || dt == jl_float32_type || dt == jl_bfloat16_type) {
+    if (dt == jl_float64_type || dt == jl_float32_type || dt == jl_float16_type ||
+        dt == jl_bfloat16_type) {
         accum.addField(offset, Sse);
     }
     // Misc types
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index fab53fa4de14c..2e1a9d2418eaa 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -986,8 +986,6 @@ struct ShardTimers {
     }
 };
 
-void emitFloat16Wrappers(Module &M, bool external);
-
 struct AOTOutputs {
     SmallVector<char, 0> unopt, opt, obj, asm_;
 };
@@ -1047,11 +1045,12 @@ static AOTOutputs add_output_impl(Module &M, TargetMachine &SourceTM, ShardTimer
         // no need to inject aliases if we have no functions
 
         if (inject_aliases) {
-#if JULIA_FLOAT16_ABI == 1
             // We would like to emit an alias or an weakref alias to redirect these symbols
             // but LLVM doesn't let us emit a GlobalAlias to a declaration...
             // So for now we inject a definition of these functions that calls our runtime
             // functions. We do so after optimization to avoid cloning these functions.
+
+            // Float16 conversion routines
             injectCRTAlias(M, "__gnu_h2f_ieee", "julia__gnu_h2f_ieee",
                     FunctionType::get(Type::getFloatTy(M.getContext()), { Type::getHalfTy(M.getContext()) }, false));
             injectCRTAlias(M, "__extendhfsf2", "julia__gnu_h2f_ieee",
@@ -1062,10 +1061,8 @@ static AOTOutputs add_output_impl(Module &M, TargetMachine &SourceTM, ShardTimer
                     FunctionType::get(Type::getHalfTy(M.getContext()), { Type::getFloatTy(M.getContext()) }, false));
             injectCRTAlias(M, "__truncdfhf2", "julia__truncdfhf2",
                     FunctionType::get(Type::getHalfTy(M.getContext()), { Type::getDoubleTy(M.getContext()) }, false));
-#else
-            emitFloat16Wrappers(M, false);
-#endif
 
+            // BFloat16 conversion routines
             injectCRTAlias(M, "__truncsfbf2", "julia__truncsfbf2",
                     FunctionType::get(Type::getBFloatTy(M.getContext()), { Type::getFloatTy(M.getContext()) }, false));
             injectCRTAlias(M, "__truncsdbf2", "julia__truncdfbf2",
diff --git a/src/codegen.cpp b/src/codegen.cpp
index e37de75b7c5bc..dbb7d5aa498dc 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -9144,58 +9144,6 @@ static JuliaVariable *julia_const_gv(jl_value_t *val)
     return nullptr;
 }
 
-// Handle FLOAT16 ABI v2
-#if JULIA_FLOAT16_ABI == 2
-static void makeCastCall(Module &M, StringRef wrapperName, StringRef calledName, FunctionType *FTwrapper, FunctionType *FTcalled, bool external)
-{
-    Function *calledFun = M.getFunction(calledName);
-    if (!calledFun) {
-        calledFun = Function::Create(FTcalled, Function::ExternalLinkage, calledName, M);
-    }
-    auto linkage = external ? Function::ExternalLinkage : Function::InternalLinkage;
-    auto wrapperFun = Function::Create(FTwrapper, linkage, wrapperName, M);
-    wrapperFun->addFnAttr(Attribute::AlwaysInline);
-    llvm::IRBuilder<> builder(BasicBlock::Create(M.getContext(), "top", wrapperFun));
-    SmallVector<Value *, 4> CallArgs;
-    if (wrapperFun->arg_size() != calledFun->arg_size()){
-        llvm::errs() << "FATAL ERROR: Can't match wrapper to called function";
-        abort();
-    }
-    for (auto wrapperArg = wrapperFun->arg_begin(), calledArg = calledFun->arg_begin();
-            wrapperArg != wrapperFun->arg_end() && calledArg != calledFun->arg_end(); ++wrapperArg, ++calledArg)
-    {
-        CallArgs.push_back(builder.CreateBitCast(wrapperArg, calledArg->getType()));
-    }
-    auto val = builder.CreateCall(calledFun, CallArgs);
-    auto retval = builder.CreateBitCast(val,wrapperFun->getReturnType());
-    builder.CreateRet(retval);
-}
-
-void emitFloat16Wrappers(Module &M, bool external)
-{
-    auto &ctx = M.getContext();
-    makeCastCall(M, "__gnu_h2f_ieee", "julia__gnu_h2f_ieee", FunctionType::get(Type::getFloatTy(ctx), { Type::getHalfTy(ctx) }, false),
-                FunctionType::get(Type::getFloatTy(ctx), { Type::getInt16Ty(ctx) }, false), external);
-    makeCastCall(M, "__extendhfsf2", "julia__gnu_h2f_ieee", FunctionType::get(Type::getFloatTy(ctx), { Type::getHalfTy(ctx) }, false),
-                FunctionType::get(Type::getFloatTy(ctx), { Type::getInt16Ty(ctx) }, false), external);
-    makeCastCall(M, "__gnu_f2h_ieee", "julia__gnu_f2h_ieee", FunctionType::get(Type::getHalfTy(ctx), { Type::getFloatTy(ctx) }, false),
-                FunctionType::get(Type::getInt16Ty(ctx), { Type::getFloatTy(ctx) }, false), external);
-    makeCastCall(M, "__truncsfhf2", "julia__gnu_f2h_ieee", FunctionType::get(Type::getHalfTy(ctx), { Type::getFloatTy(ctx) }, false),
-                FunctionType::get(Type::getInt16Ty(ctx), { Type::getFloatTy(ctx) }, false), external);
-    makeCastCall(M, "__truncdfhf2", "julia__truncdfhf2", FunctionType::get(Type::getHalfTy(ctx), { Type::getDoubleTy(ctx) }, false),
-                FunctionType::get(Type::getInt16Ty(ctx), { Type::getDoubleTy(ctx) }, false), external);
-}
-
-static void init_f16_funcs(void)
-{
-    auto ctx = jl_ExecutionEngine->acquireContext();
-    auto TSM =  jl_create_ts_module("F16Wrappers", ctx);
-    auto aliasM = TSM.getModuleUnlocked();
-    emitFloat16Wrappers(*aliasM, true);
-    jl_ExecutionEngine->addModule(std::move(TSM));
-}
-#endif
-
 static void init_jit_functions(void)
 {
     add_named_global(jl_small_typeof_var, &jl_small_typeof);
@@ -9438,9 +9386,6 @@ extern "C" JL_DLLEXPORT_CODEGEN void jl_init_codegen_impl(void)
     jl_init_llvm();
     // Now that the execution engine exists, initialize all modules
     init_jit_functions();
-#if JULIA_FLOAT16_ABI == 2
-    init_f16_funcs();
-#endif
 }
 
 extern "C" JL_DLLEXPORT_CODEGEN void jl_teardown_codegen_impl() JL_NOTSAFEPOINT
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index e3f30f7d22d58..7eed240529e20 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1729,13 +1729,14 @@ JuliaOJIT::JuliaOJIT()
     ExternalJD.addToLinkOrder(JD, orc::JITDylibLookupFlags::MatchExportedSymbolsOnly);
 
     orc::SymbolAliasMap jl_crt = {
-#if JULIA_FLOAT16_ABI == 1
+        // Float16 conversion routines
         { mangle("__gnu_h2f_ieee"), { mangle("julia__gnu_h2f_ieee"), JITSymbolFlags::Exported } },
         { mangle("__extendhfsf2"),  { mangle("julia__gnu_h2f_ieee"), JITSymbolFlags::Exported } },
         { mangle("__gnu_f2h_ieee"), { mangle("julia__gnu_f2h_ieee"), JITSymbolFlags::Exported } },
         { mangle("__truncsfhf2"),   { mangle("julia__gnu_f2h_ieee"), JITSymbolFlags::Exported } },
         { mangle("__truncdfhf2"),   { mangle("julia__truncdfhf2"),   JITSymbolFlags::Exported } },
-#endif
+
+        // BFloat16 conversion routines
         { mangle("__truncsfbf2"),   { mangle("julia__truncsfbf2"),   JITSymbolFlags::Exported } },
         { mangle("__truncdfbf2"),   { mangle("julia__truncdfbf2"),   JITSymbolFlags::Exported } },
     };
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 204674c6d495a..4f326216d8daf 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1661,20 +1661,12 @@ jl_sym_t *_jl_symbol(const char *str, size_t len) JL_NOTSAFEPOINT;
 #define JL_WEAK_SYMBOL_DEFAULT(sym) NULL
 #endif
 
-JL_DLLEXPORT float julia__gnu_h2f_ieee(uint16_t param) JL_NOTSAFEPOINT;
-JL_DLLEXPORT uint16_t julia__gnu_f2h_ieee(float param) JL_NOTSAFEPOINT;
-JL_DLLEXPORT uint16_t julia__truncdfhf2(double param) JL_NOTSAFEPOINT;
-JL_DLLEXPORT float julia__truncsfbf2(float param) JL_NOTSAFEPOINT;
-JL_DLLEXPORT float julia__truncdfbf2(double param) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT double julia__extendhfdf2(uint16_t n) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT int32_t julia__fixhfsi(uint16_t n) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT int64_t julia__fixhfdi(uint16_t n) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT uint32_t julia__fixunshfsi(uint16_t n) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT uint64_t julia__fixunshfdi(uint16_t n) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT uint16_t julia__floatsihf(int32_t n) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT uint16_t julia__floatdihf(int64_t n) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT uint16_t julia__floatunsihf(uint32_t n) JL_NOTSAFEPOINT;
-//JL_DLLEXPORT uint16_t julia__floatundihf(uint64_t n) JL_NOTSAFEPOINT;
+//JL_DLLEXPORT float julia__gnu_h2f_ieee(half param) JL_NOTSAFEPOINT;
+//JL_DLLEXPORT half julia__gnu_f2h_ieee(float param) JL_NOTSAFEPOINT;
+//JL_DLLEXPORT half julia__truncdfhf2(double param) JL_NOTSAFEPOINT;
+//JL_DLLEXPORT float julia__truncsfbf2(float param) JL_NOTSAFEPOINT;
+//JL_DLLEXPORT float julia__truncdfbf2(double param) JL_NOTSAFEPOINT;
+//JL_DLLEXPORT double julia__extendhfdf2(half n) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len);
 
diff --git a/src/llvm-version.h b/src/llvm-version.h
index 01638b8d44a6e..7b8dfbbae92d6 100644
--- a/src/llvm-version.h
+++ b/src/llvm-version.h
@@ -18,15 +18,6 @@
 #define JL_LLVM_OPAQUE_POINTERS 1
 #endif
 
-// Pre GCC 12 libgcc defined the ABI for Float16->Float32
-// to take an i16. GCC 12 silently changed the ABI to now pass
-// Float16 in Float32 registers.
-#if JL_LLVM_VERSION < 150000 || defined(_CPU_PPC64_) || defined(_CPU_PPC_)
-#define JULIA_FLOAT16_ABI 1
-#else
-#define JULIA_FLOAT16_ABI 2
-#endif
-
 #ifdef __cplusplus
 #if defined(__GNUC__) && (__GNUC__ >= 9)
 // Added in GCC 9, this warning is annoying
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index b42b7d9832383..588c0359f70be 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -5,8 +5,6 @@
 //
 // this file assumes a little-endian processor, although that isn't too hard to fix
 // it also assumes two's complement negative numbers, which might be a bit harder to fix
-//
-// TODO: add half-float support
 
 #include "APInt-C.h"
 #include "julia.h"
@@ -14,7 +12,7 @@
 
 const unsigned int host_char_bit = 8;
 
-// float16 intrinsics
+// float16 conversion helpers
 
 static inline float half_to_float(uint16_t ival) JL_NOTSAFEPOINT
 {
@@ -185,94 +183,189 @@ static inline uint16_t float_to_half(float param) JL_NOTSAFEPOINT
     return h;
 }
 
-JL_DLLEXPORT float julia__gnu_h2f_ieee(uint16_t param)
+static inline uint16_t double_to_half(double param) JL_NOTSAFEPOINT
 {
+    float temp = (float)param;
+    uint32_t tempi;
+    memcpy(&tempi, &temp, sizeof(temp));
+
+    // if Float16(res) is subnormal
+    if ((tempi&0x7fffffffu) < 0x38800000u) {
+        // shift so that the mantissa lines up where it would for normal Float16
+        uint32_t shift = 113u-((tempi & 0x7f800000u)>>23u);
+        if (shift<23u) {
+            tempi |= 0x00800000; // set implicit bit
+            tempi >>= shift;
+        }
+    }
+
+    // if we are halfway between 2 Float16 values
+    if ((tempi & 0x1fffu) == 0x1000u) {
+        memcpy(&tempi, &temp, sizeof(temp));
+        // adjust the value by 1 ULP in the direction that will make Float16(temp) give the right answer
+        tempi += (fabs(temp) < fabs(param)) - (fabs(param) < fabs(temp));
+        memcpy(&temp, &tempi, sizeof(temp));
+    }
+
+    return float_to_half(temp);
+}
+
+// x86-specific helpers for emulating the (B)Float16 ABI
+#if defined(_CPU_X86_) || defined(_CPU_X86_64_)
+#include <xmmintrin.h>
+static inline __m128 return_in_xmm(uint16_t input) JL_NOTSAFEPOINT {
+    __m128 xmm_output;
+    asm (
+        "movd %[input], %%xmm0\n\t"
+        "movss %%xmm0, %[xmm_output]\n\t"
+        : [xmm_output] "=x" (xmm_output)
+        : [input] "r" ((uint32_t)input)
+        : "xmm0"
+    );
+    return xmm_output;
+}
+static inline uint16_t take_from_xmm(__m128 xmm_input) JL_NOTSAFEPOINT {
+    uint32_t output;
+    asm (
+        "movss %[xmm_input], %%xmm0\n\t"
+        "movd %%xmm0, %[output]\n\t"
+        : [output] "=r" (output)
+        : [xmm_input] "x" (xmm_input)
+        : "xmm0"
+    );
+    return (uint16_t)output;
+}
+#endif
+
+// float16 conversion API
+
+// for use in APInt (without the ABI shenanigans from below)
+uint16_t julia_float_to_half(float param) {
+    return float_to_half(param);
+}
+float julia_half_to_float(uint16_t param) {
     return half_to_float(param);
 }
 
-JL_DLLEXPORT uint16_t julia__gnu_f2h_ieee(float param)
+// starting with GCC 12 and Clang 15, we have _Float16 on most platforms
+// (but not on Windows; this may be a bug in the MSYS2 GCC compilers)
+#if ((defined(__GNUC__) && __GNUC__ > 11) || \
+     (defined(__clang__) && __clang_major__ > 14)) && \
+    !defined(_CPU_PPC64_) && !defined(_CPU_PPC_) && \
+    !defined(_OS_WINDOWS_)
+    #define FLOAT16_TYPE _Float16
+    #define FLOAT16_TO_UINT16(x) (*(uint16_t*)&(x))
+    #define FLOAT16_FROM_UINT16(x) (*(_Float16*)&(x))
+// on older compilers, we need to emulate the platform-specific ABI
+#elif defined(_CPU_X86_) || (defined(_CPU_X86_64_) && !defined(_OS_WINDOWS_))
+    // on x86, we can use __m128; except on Windows where x64 calling
+    // conventions expect to pass __m128 by reference.
+    #define FLOAT16_TYPE __m128
+    #define FLOAT16_TO_UINT16(x) take_from_xmm(x)
+    #define FLOAT16_FROM_UINT16(x) return_in_xmm(x)
+#elif defined(_CPU_PPC64_) || defined(_CPU_PPC_)
+    // on PPC, pass Float16 as if it were an integer, similar to the old x86 ABI
+    // before _Float16
+    #define FLOAT16_TYPE uint16_t
+    #define FLOAT16_TO_UINT16(x) (x)
+    #define FLOAT16_FROM_UINT16(x) (x)
+#else
+    // otherwise, pass using floating-point calling conventions
+    #define FLOAT16_TYPE float
+    #define FLOAT16_TO_UINT16(x) ((uint16_t)*(uint32_t*)&(x))
+    #define FLOAT16_FROM_UINT16(x) ({ uint32_t tmp = (uint32_t)(x); *(float*)&tmp; })
+#endif
+
+JL_DLLEXPORT float julia__gnu_h2f_ieee(FLOAT16_TYPE param)
 {
-    return float_to_half(param);
+    uint16_t param16 = FLOAT16_TO_UINT16(param);
+    return half_to_float(param16);
 }
 
-JL_DLLEXPORT uint16_t julia__truncdfhf2(double param)
+JL_DLLEXPORT FLOAT16_TYPE julia__gnu_f2h_ieee(float param)
 {
-    float res = (float)param;
-    uint32_t resi;
-    memcpy(&resi, &res, sizeof(res));
-    if ((resi&0x7fffffffu) < 0x38800000u){ // if Float16(res) is subnormal
-        // shift so that the mantissa lines up where it would for normal Float16
-        uint32_t shift = 113u-((resi & 0x7f800000u)>>23u);
-        if (shift<23u) {
-            resi |= 0x00800000; // set implicit bit
-            resi >>= shift;
-        }
-    }
-    if ((resi & 0x1fffu) == 0x1000u) { // if we are halfway between 2 Float16 values
-        memcpy(&resi, &res, sizeof(res));
-        // adjust the value by 1 ULP in the direction that will make Float16(res) give the right answer
-        resi += (fabs(res) < fabs(param)) - (fabs(param) < fabs(res));
-        memcpy(&res, &resi, sizeof(res));
-    }
-    return float_to_half(res);
+    uint16_t res = float_to_half(param);
+    return FLOAT16_FROM_UINT16(res);
 }
 
-JL_DLLEXPORT float julia__truncsfbf2(float param) JL_NOTSAFEPOINT
+JL_DLLEXPORT FLOAT16_TYPE julia__truncdfhf2(double param)
 {
-    uint16_t result;
+    uint16_t res = double_to_half(param);
+    return FLOAT16_FROM_UINT16(res);
+}
 
+
+// bfloat16 conversion helpers
+
+static inline uint16_t float_to_bfloat(float param) JL_NOTSAFEPOINT
+{
     if (isnan(param))
-        result = 0x7fc0;
-    else {
-        uint32_t bits = *((uint32_t*) &param);
+        return 0x7fc0;
 
-        // round to nearest even
-        bits += 0x7fff + ((bits >> 16) & 1);
-        result = (uint16_t)(bits >> 16);
-    }
+    uint32_t bits = *((uint32_t*) &param);
 
-    // on x86, bfloat16 needs to be returned in XMM. only GCC 13 provides the necessary ABI
-    // support in the form of the __bf16 type; older versions only provide __bfloat16 which
-    // is simply a typedef for short (i16). so use float, which is passed in XMM too.
-    uint32_t result_32bit = (uint32_t)result;
-    return *(float*)&result_32bit;
+    // round to nearest even
+    bits += 0x7fff + ((bits >> 16) & 1);
+    return (uint16_t)(bits >> 16);
 }
 
-JL_DLLEXPORT float julia__truncdfbf2(double param) JL_NOTSAFEPOINT
+static inline uint16_t double_to_bfloat(double param) JL_NOTSAFEPOINT
 {
-    float res = (float)param;
-    uint32_t resi;
-    memcpy(&resi, &res, sizeof(res));
+    float temp = (float)param;
+    uint32_t tempi;
+    memcpy(&tempi, &temp, sizeof(temp));
 
     // bfloat16 uses the same exponent as float32, so we don't need special handling
     // for subnormals when truncating float64 to bfloat16.
 
-    if ((resi & 0x1ffu) == 0x100u) { // if we are halfway between 2 bfloat16 values
-        // adjust the value by 1 ULP in the direction that will make bfloat16(res) give the right answer
-        resi += (fabs(res) < fabs(param)) - (fabs(param) < fabs(res));
-        memcpy(&res, &resi, sizeof(res));
+    // if we are halfway between 2 bfloat16 values
+    if ((tempi & 0x1ffu) == 0x100u) {
+        // adjust the value by 1 ULP in the direction that will make bfloat16(temp) give the right answer
+        tempi += (fabs(temp) < fabs(param)) - (fabs(param) < fabs(temp));
+        memcpy(&temp, &tempi, sizeof(temp));
     }
-    return julia__truncsfbf2(res);
-}
-
-//JL_DLLEXPORT double julia__extendhfdf2(uint16_t n) { return (double)julia__gnu_h2f_ieee(n); }
-//JL_DLLEXPORT int32_t julia__fixhfsi(uint16_t n) { return (int32_t)julia__gnu_h2f_ieee(n); }
-//JL_DLLEXPORT int64_t julia__fixhfdi(uint16_t n) { return (int64_t)julia__gnu_h2f_ieee(n); }
-//JL_DLLEXPORT uint32_t julia__fixunshfsi(uint16_t n) { return (uint32_t)julia__gnu_h2f_ieee(n); }
-//JL_DLLEXPORT uint64_t julia__fixunshfdi(uint16_t n) { return (uint64_t)julia__gnu_h2f_ieee(n); }
-//JL_DLLEXPORT uint16_t julia__floatsihf(int32_t n) { return julia__gnu_f2h_ieee((float)n); }
-//JL_DLLEXPORT uint16_t julia__floatdihf(int64_t n) { return julia__gnu_f2h_ieee((float)n); }
-//JL_DLLEXPORT uint16_t julia__floatunsihf(uint32_t n) { return julia__gnu_f2h_ieee((float)n); }
-//JL_DLLEXPORT uint16_t julia__floatundihf(uint64_t n) { return julia__gnu_f2h_ieee((float)n); }
-//HANDLE_LIBCALL(F16, F128, __extendhftf2)
-//HANDLE_LIBCALL(F16, F80, __extendhfxf2)
-//HANDLE_LIBCALL(F80, F16, __truncxfhf2)
-//HANDLE_LIBCALL(F128, F16, __trunctfhf2)
-//HANDLE_LIBCALL(PPCF128, F16, __trunctfhf2)
-//HANDLE_LIBCALL(F16, I128, __fixhfti)
-//HANDLE_LIBCALL(F16, I128, __fixunshfti)
-//HANDLE_LIBCALL(I128, F16, __floattihf)
-//HANDLE_LIBCALL(I128, F16, __floatuntihf)
+
+    return float_to_bfloat(temp);
+}
+
+// bfloat16 conversion API
+
+// starting with GCC 13 and Clang 17, we have __bf16 on most platforms
+// (but not on Windows; this may be a bug in the MSYS2 GCC compilers)
+#if ((defined(__GNUC__) && __GNUC__ > 12) || \
+     (defined(__clang__) && __clang_major__ > 16)) && \
+    !defined(_CPU_PPC64_) && !defined(_CPU_PPC_) && \
+    !defined(_OS_WINDOWS_)
+    #define BFLOAT16_TYPE __bf16
+    #define BFLOAT16_TO_UINT16(x) (*(uint16_t*)&(x))
+    #define BFLOAT16_FROM_UINT16(x) (*(__bf16*)&(x))
+// on older compilers, we need to emulate the platform-specific ABI.
+// for more details, see similar code above that deals with Float16.
+#elif defined(_CPU_X86_) || (defined(_CPU_X86_64_) && !defined(_OS_WINDOWS_))
+    #define BFLOAT16_TYPE __m128
+    #define BFLOAT16_TO_UINT16(x) take_from_xmm(x)
+    #define BFLOAT16_FROM_UINT16(x) return_in_xmm(x)
+#elif defined(_CPU_PPC64_) || defined(_CPU_PPC_)
+    #define BFLOAT16_TYPE uint16_t
+    #define BFLOAT16_TO_UINT16(x) (x)
+    #define BFLOAT16_FROM_UINT16(x) (x)
+#else
+    #define BFLOAT16_TYPE float
+    #define BFLOAT16_TO_UINT16(x) ((uint16_t)*(uint32_t*)&(x))
+    #define BFLOAT16_FROM_UINT16(x) ({ uint32_t tmp = (uint32_t)(x); *(float*)&tmp; })
+#endif
+
+JL_DLLEXPORT BFLOAT16_TYPE julia__truncsfbf2(float param) JL_NOTSAFEPOINT
+{
+    uint16_t res = float_to_bfloat(param);
+    return BFLOAT16_FROM_UINT16(res);
+}
+
+JL_DLLEXPORT BFLOAT16_TYPE julia__truncdfbf2(double param) JL_NOTSAFEPOINT
+{
+    uint16_t res = double_to_bfloat(param);
+    return BFLOAT16_FROM_UINT16(res);
+}
 
 
 // run time version of bitcast intrinsic
@@ -643,11 +736,11 @@ static inline void name(unsigned osize, void *pa, void *pr) JL_NOTSAFEPOINT \
 static inline void name(unsigned osize, void *pa, void *pr) JL_NOTSAFEPOINT \
 { \
     uint16_t a = *(uint16_t*)pa; \
-    float A = julia__gnu_h2f_ieee(a); \
+    float A = half_to_float(a); \
     if (osize == 16) { \
         float R; \
         OP(&R, A); \
-        *(uint16_t*)pr = julia__gnu_f2h_ieee(R); \
+        *(uint16_t*)pr = float_to_half(R); \
     } else { \
         OP((uint16_t*)pr, A); \
     } \
@@ -671,11 +764,11 @@ static void jl_##name##16(unsigned runtime_nbits, void *pa, void *pb, void *pr)
 { \
     uint16_t a = *(uint16_t*)pa; \
     uint16_t b = *(uint16_t*)pb; \
-    float A = julia__gnu_h2f_ieee(a); \
-    float B = julia__gnu_h2f_ieee(b); \
+    float A = half_to_float(a); \
+    float B = half_to_float(b); \
     runtime_nbits = 16; \
     float R = OP(A, B); \
-    *(uint16_t*)pr = julia__gnu_f2h_ieee(R); \
+    *(uint16_t*)pr = float_to_half(R); \
 }
 
 // float or integer inputs, bool output
@@ -696,8 +789,8 @@ static int jl_##name##16(unsigned runtime_nbits, void *pa, void *pb) JL_NOTSAFEP
 { \
     uint16_t a = *(uint16_t*)pa; \
     uint16_t b = *(uint16_t*)pb; \
-    float A = julia__gnu_h2f_ieee(a); \
-    float B = julia__gnu_h2f_ieee(b); \
+    float A = half_to_float(a); \
+    float B = half_to_float(b); \
     runtime_nbits = 16; \
     return OP(A, B); \
 }
@@ -737,12 +830,12 @@ static void jl_##name##16(unsigned runtime_nbits, void *pa, void *pb, void *pc,
     uint16_t a = *(uint16_t*)pa; \
     uint16_t b = *(uint16_t*)pb; \
     uint16_t c = *(uint16_t*)pc; \
-    float A = julia__gnu_h2f_ieee(a); \
-    float B = julia__gnu_h2f_ieee(b); \
-    float C = julia__gnu_h2f_ieee(c); \
+    float A = half_to_float(a); \
+    float B = half_to_float(b); \
+    float C = half_to_float(c); \
     runtime_nbits = 16; \
     float R = OP(A, B, C); \
-    *(uint16_t*)pr = julia__gnu_f2h_ieee(R); \
+    *(uint16_t*)pr = float_to_half(R); \
 }
 
 
@@ -1412,7 +1505,7 @@ cvt_iintrinsic(LLVMFPtoUI, fptoui)
         if (!(osize < 8 * sizeof(a))) \
             jl_error("fptrunc: output bitsize must be < input bitsize"); \
         else if (osize == 16) \
-            *(uint16_t*)pr = julia__gnu_f2h_ieee(a); \
+            *(uint16_t*)pr = float_to_half(a); \
         else if (osize == 32) \
             *(float*)pr = a; \
         else if (osize == 64) \
diff --git a/test/intrinsics.jl b/test/intrinsics.jl
index d67dad33e60cc..8e4ab932f5eb6 100644
--- a/test/intrinsics.jl
+++ b/test/intrinsics.jl
@@ -180,28 +180,12 @@ end
     @test_intrinsic Core.Intrinsics.fptoui UInt Float16(3.3) UInt(3)
 end
 
-if Sys.ARCH == :aarch64 ||  Sys.ARCH === :powerpc64le || Sys.ARCH === :ppc64le
-    # On AArch64 we are following the `_Float16` ABI. Buthe these functions expect `Int16`.
-    # TODO: Should we have `Chalf == Int16` and `Cfloat16 == Float16`?
-    extendhfsf2(x::Float16) = ccall("extern __extendhfsf2", llvmcall, Float32, (UInt16,), reinterpret(UInt16, x))
-    gnu_h2f_ieee(x::Float16) = ccall("extern __gnu_h2f_ieee", llvmcall, Float32, (UInt16,), reinterpret(UInt16, x))
-    truncsfhf2(x::Float32) = reinterpret(Float16, ccall("extern __truncsfhf2", llvmcall, UInt16, (Float32,), x))
-    gnu_f2h_ieee(x::Float32) = reinterpret(Float16, ccall("extern __gnu_f2h_ieee", llvmcall, UInt16, (Float32,), x))
-    truncdfhf2(x::Float64) = reinterpret(Float16, ccall("extern __truncdfhf2", llvmcall, UInt16, (Float64,), x))
-else
-    extendhfsf2(x::Float16) = ccall("extern __extendhfsf2", llvmcall, Float32, (Float16,), x)
-    gnu_h2f_ieee(x::Float16) = ccall("extern __gnu_h2f_ieee", llvmcall, Float32, (Float16,), x)
-    truncsfhf2(x::Float32) = ccall("extern __truncsfhf2", llvmcall, Float16, (Float32,), x)
-    gnu_f2h_ieee(x::Float32) = ccall("extern __gnu_f2h_ieee", llvmcall, Float16, (Float32,), x)
-    truncdfhf2(x::Float64) = ccall("extern __truncdfhf2", llvmcall, Float16, (Float64,), x)
-end
-
 @testset "Float16 intrinsics (crt)" begin
-    @test extendhfsf2(Float16(3.3)) == 3.3007812f0
+    gnu_h2f_ieee(x::Float16) = ccall("julia__gnu_h2f_ieee", Float32, (Float16,), x)
+    gnu_f2h_ieee(x::Float32) = ccall("julia__gnu_f2h_ieee", Float16, (Float32,), x)
+
     @test gnu_h2f_ieee(Float16(3.3)) == 3.3007812f0
-    @test truncsfhf2(3.3f0) == Float16(3.3)
     @test gnu_f2h_ieee(3.3f0) == Float16(3.3)
-    @test truncdfhf2(3.3) == Float16(3.3)
 end
 
 using Base.Experimental: @force_compile

From 01f6c4c8b86f62af923a600327f9b6be1a905193 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Fri, 20 Oct 2023 10:08:35 -0300
Subject: [PATCH 0036/1315] Fix remove-addrspaces pass in the presence of
 globals with addrspaces (#51782)

This fixes an assertion that might trigger if we run this pass on sysimg
modules.
---
 src/llvm-remove-addrspaces.cpp       | 4 ++--
 test/llvmpasses/remove-addrspaces.ll | 6 ++++++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/llvm-remove-addrspaces.cpp b/src/llvm-remove-addrspaces.cpp
index b0a68ade4c42b..4b25821f43efb 100644
--- a/src/llvm-remove-addrspaces.cpp
+++ b/src/llvm-remove-addrspaces.cpp
@@ -335,7 +335,7 @@ bool removeAddrspaces(Module &M, AddrspaceRemapFunction ASRemapper)
 
         GlobalVariable *NGV = cast<GlobalVariable>(VMap[GV]);
         if (GV->hasInitializer())
-            NGV->setInitializer(MapValue(GV->getInitializer(), VMap));
+            NGV->setInitializer(MapValue(GV->getInitializer(), VMap, RF_None, &TypeRemapper, &Materializer));
 
         SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
         GV->getAllMetadata(MDs);
@@ -400,7 +400,7 @@ bool removeAddrspaces(Module &M, AddrspaceRemapFunction ASRemapper)
     for (GlobalAlias *GA : Aliases) {
         GlobalAlias *NGA = cast<GlobalAlias>(VMap[GA]);
         if (const Constant *C = GA->getAliasee())
-            NGA->setAliasee(MapValue(C, VMap));
+            NGA->setAliasee(MapValue(C, VMap, RF_None, &TypeRemapper, &Materializer));
 
         GA->setAliasee(nullptr);
     }
diff --git a/test/llvmpasses/remove-addrspaces.ll b/test/llvmpasses/remove-addrspaces.ll
index b0415671e2d93..90043a7d85cf4 100644
--- a/test/llvmpasses/remove-addrspaces.ll
+++ b/test/llvmpasses/remove-addrspaces.ll
@@ -5,6 +5,12 @@
 ; RUN: opt -enable-new-pm=1 --opaque-pointers=1 --load-pass-plugin=libjulia-codegen%shlibext -passes='RemoveJuliaAddrspaces' -S %s | FileCheck %s --check-prefixes=CHECK,OPAQUE
 
 
+; COM: check that package image fptrs work
+@pjlsys_BoundsError_32 = internal global {} addrspace(10)* ({}***, {} addrspace(10)*, [1 x i64] addrspace(11)*)* null
+; CHECK: @pjlsys_BoundsError_32 = internal global
+; TYPED-SAME: {}* ({}***, {}*, [1 x i64]*)* null
+; OPAQUE-SAME: ptr null
+
 define i64 @getindex({} addrspace(10)* nonnull align 16 dereferenceable(40)) {
 ; CHECK-LABEL: @getindex
 top:

From 7489a3190432d0a9e77372dd6b6801c3e1589238 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sat, 29 Apr 2023 17:09:05 +0800
Subject: [PATCH 0037/1315] Allow SubString construction without index shift

---
 base/strings/substring.jl | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/base/strings/substring.jl b/base/strings/substring.jl
index 792925f24b12b..dfd8770b08d47 100644
--- a/base/strings/substring.jl
+++ b/base/strings/substring.jl
@@ -36,9 +36,18 @@ struct SubString{T<:AbstractString} <: AbstractString
         end
         return new(s, i-1, nextind(s,j)-i)
     end
+    function SubString{T}(s::T, i::Int, j::Int, ::Val{:noshift}) where T<:AbstractString
+        @boundscheck begin
+            si, sj = i + 1, prevind(s, j + i + 1)
+            @inbounds isvalid(s, si) || string_index_err(s, si)
+            @inbounds isvalid(s, sj) || string_index_err(s, sj)
+        end
+        new(s, i, j)
+    end
 end
 
 @propagate_inbounds SubString(s::T, i::Int, j::Int) where {T<:AbstractString} = SubString{T}(s, i, j)
+@propagate_inbounds SubString(s::T, i::Int, j::Int, v::Val{:noshift}) where {T<:AbstractString} = SubString{T}(s, i, j, v)
 @propagate_inbounds SubString(s::AbstractString, i::Integer, j::Integer=lastindex(s)) = SubString(s, Int(i), Int(j))
 @propagate_inbounds SubString(s::AbstractString, r::AbstractUnitRange{<:Integer}) = SubString(s, first(r), last(r))
 

From 7bf226bf8a3c4a99a01e596a6a4c2de6b21ffd40 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sat, 29 Apr 2023 17:10:36 +0800
Subject: [PATCH 0038/1315] Parametrize RegexMatch string type

This allows for the construction of matches built on non-String
AbstractStrings.
---
 base/regex.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/regex.jl b/base/regex.jl
index 3e161806c50ea..88f43629bd084 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -212,9 +212,9 @@ julia> hr
 "11"
 ```
 """
-struct RegexMatch <: AbstractMatch
-    match::SubString{String}
-    captures::Vector{Union{Nothing,SubString{String}}}
+struct RegexMatch{S<:AbstractString} <: AbstractMatch
+    match::SubString{S}
+    captures::Vector{Union{Nothing,SubString{S}}}
     offset::Int
     offsets::Vector{Int}
     regex::Regex
@@ -418,7 +418,7 @@ function match(re::Regex, str::Union{SubString{String}, String}, idx::Integer,
                                         SubString(str, unsafe_load(p,2i+1)+1,
                                                   prevind(str, unsafe_load(p,2i+2)+1)) for i=1:n]
     off = Int[ unsafe_load(p,2i+1)+1 for i=1:n ]
-    result = RegexMatch(mat, cap, unsafe_load(p,1)+1, off, re)
+    result = RegexMatch{String}(mat, cap, unsafe_load(p,1)+1, off, re)
     PCRE.free_match_data(data)
     return result
 end

From 6113e1c338b23c16424b8f077b8f3b31f828067b Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sat, 29 Apr 2023 17:53:44 +0800
Subject: [PATCH 0039/1315] Introduce Styled{String,Char}
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These new types allow for arbitrary properties to be attached to regions
of an AbstractString or AbstractChar.

The most common expected use of this is for styled content, where the
styling is attached as special properties. This has the major benefit of
separating styling from content, allowing both to be treated better —
functions that operate on the content won't need variants that work
around styling, and operations that interact with the styling will have
many less edge cases (e.g. printing a substring and having to work
around unterminated ANSI styling codes).

Other use cases are also enabled by this, such as text links and the
preserving of line information in string processing.
---
 base/exports.jl         |   3 +
 base/regex.jl           |  49 ++++-
 base/strings/basic.jl   |  20 +-
 base/strings/io.jl      |  23 +++
 base/strings/strings.jl |   1 +
 base/strings/styled.jl  | 432 ++++++++++++++++++++++++++++++++++++++++
 base/strings/util.jl    |  16 +-
 7 files changed, 524 insertions(+), 20 deletions(-)
 create mode 100644 base/strings/styled.jl

diff --git a/base/exports.jl b/base/exports.jl
index 81296f7d34b18..87b52189983ad 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -92,6 +92,8 @@ export
     StridedMatrix,
     StridedVecOrMat,
     StridedVector,
+    StyledChar,
+    StyledString,
     SubArray,
     SubString,
     SubstitutionString,
@@ -629,6 +631,7 @@ export
     split,
     string,
     strip,
+    styledstring,
     textwidth,
     thisind,
     titlecase,
diff --git a/base/regex.jl b/base/regex.jl
index 88f43629bd084..61a138de1ee78 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -220,6 +220,10 @@ struct RegexMatch{S<:AbstractString} <: AbstractMatch
     regex::Regex
 end
 
+RegexMatch(match::SubString{S}, captures::Vector{Union{Nothing,SubString{S}}},
+           offset::Union{Int, UInt}, offsets::Vector{Int}, regex::Regex) where {S<:AbstractString} =
+    RegexMatch{S}(match, captures, offset, offsets, regex)
+
 """
     keys(m::RegexMatch) -> Vector
 
@@ -418,11 +422,37 @@ function match(re::Regex, str::Union{SubString{String}, String}, idx::Integer,
                                         SubString(str, unsafe_load(p,2i+1)+1,
                                                   prevind(str, unsafe_load(p,2i+2)+1)) for i=1:n]
     off = Int[ unsafe_load(p,2i+1)+1 for i=1:n ]
-    result = RegexMatch{String}(mat, cap, unsafe_load(p,1)+1, off, re)
+    result = RegexMatch(mat, cap, unsafe_load(p,1)+1, off, re)
     PCRE.free_match_data(data)
     return result
 end
 
+function _styledmatch(m::RegexMatch{S}, str::StyledString{S}) where {S<:AbstractString}
+    RegexMatch{StyledString{S}}(
+        (@inbounds SubString{StyledString{S}}(
+            str, m.match.offset, m.match.ncodeunits, Val(:noshift))),
+        Union{Nothing,SubString{StyledString{S}}}[
+            if !isnothing(cap)
+                (@inbounds SubString{StyledString{S}}(
+                    str, cap.offset, cap.ncodeunits, Val(:noshift)))
+            end for cap in m.captures],
+        m.offset, m.offsets, m.regex)
+end
+
+function match(re::Regex, str::StyledString)
+    m = match(re, str.string)
+    if !isnothing(m)
+        _styledmatch(m, str)
+    end
+end
+
+function match(re::Regex, str::StyledString, idx::Integer, add_opts::UInt32=UInt32(0))
+    m = match(re, str.string, idx, add_opts)
+    if !isnothing(m)
+        _styledmatch(m, str)
+    end
+end
+
 match(r::Regex, s::AbstractString) = match(r, s, firstindex(s))
 match(r::Regex, s::AbstractString, i::Integer) = throw(ArgumentError(
     "regex matching is only available for the String type; use String(s) to convert"
@@ -671,18 +701,19 @@ function _replace(io, repl_s::SubstitutionString, str, r, re)
     end
 end
 
-struct RegexMatchIterator
+struct RegexMatchIterator{S <: AbstractString}
     regex::Regex
-    string::String
+    string::S
     overlap::Bool
 
-    function RegexMatchIterator(regex::Regex, string::AbstractString, ovr::Bool=false)
-        new(regex, string, ovr)
-    end
+    RegexMatchIterator(regex::Regex, string::AbstractString, ovr::Bool=false) =
+        new{String}(regex, String(string), ovr)
+    RegexMatchIterator(regex::Regex, string::StyledString, ovr::Bool=false) =
+        new{StyledString{String}}(regex, StyledString(String(string.string), string.properties), ovr)
 end
 compile(itr::RegexMatchIterator) = (compile(itr.regex); itr)
-eltype(::Type{RegexMatchIterator}) = RegexMatch
-IteratorSize(::Type{RegexMatchIterator}) = SizeUnknown()
+eltype(::Type{<:RegexMatchIterator}) = RegexMatch
+IteratorSize(::Type{<:RegexMatchIterator}) = SizeUnknown()
 
 function iterate(itr::RegexMatchIterator, (offset,prevempty)=(1,false))
     opts_nonempty = UInt32(PCRE.ANCHORED | PCRE.NOTEMPTY_ATSTART)
@@ -727,7 +758,7 @@ julia> rx = r"a.a"
 r"a.a"
 
 julia> m = eachmatch(rx, "a1a2a3a")
-Base.RegexMatchIterator(r"a.a", "a1a2a3a", false)
+Base.RegexMatchIterator{String}(r"a.a", "a1a2a3a", false)
 
 julia> collect(m)
 2-element Vector{RegexMatch}:
diff --git a/base/strings/basic.jl b/base/strings/basic.jl
index d2bc157aefd94..468ee4476da7e 100644
--- a/base/strings/basic.jl
+++ b/base/strings/basic.jl
@@ -241,9 +241,10 @@ end
 """
     *(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString
 
-Concatenate strings and/or characters, producing a [`String`](@ref). This is equivalent
-to calling the [`string`](@ref) function on the arguments. Concatenation of built-in
-string types always produces a value of type `String` but other string types may choose
+Concatenate strings and/or characters, producing a [`String`](@ref) or
+[`StyledString`](@ref) (as appropriate). This is equivalent to calling the
+[`string`](@ref) or [`styledstring`](@ref) function on the arguments. Concatenation of built-in string
+types always produces a value of type `String` but other string types may choose
 to return a string of a different type as appropriate.
 
 # Examples
@@ -255,7 +256,15 @@ julia> 'j' * "ulia"
 "julia"
 ```
 """
-(*)(s1::Union{AbstractChar, AbstractString}, ss::Union{AbstractChar, AbstractString}...) = string(s1, ss...)
+function (*)(s1::Union{AbstractChar, AbstractString}, ss::Union{AbstractChar, AbstractString}...)
+    isstyled = s1 isa StyledString || s1 isa StyledChar ||
+        any(s -> s isa StyledString || s isa StyledChar, ss)
+    if isstyled
+        styledstring(s1, ss...)
+    else
+        string(s1, ss...)
+    end
+end
 
 one(::Union{T,Type{T}}) where {T<:AbstractString} = convert(T, "")
 
@@ -309,7 +318,8 @@ end
     ==(a::AbstractString, b::AbstractString) -> Bool
 
 Test whether two strings are equal character by character (technically, Unicode
-code point by code point).
+code point by code point). Should either string be a [`StyledString`](@ref) the
+string properties must match too.
 
 # Examples
 ```jldoctest
diff --git a/base/strings/io.jl b/base/strings/io.jl
index 987a64798d3da..d15bcf412f121 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -764,3 +764,26 @@ function String(chars::AbstractVector{<:AbstractChar})
         end
     end
 end
+
+function StyledString(chars::AbstractVector{C}) where {C<:AbstractChar}
+    str = if C <: StyledChar
+        String(getfield.(chars, :char))
+    else
+        sprint(sizehint=length(chars)) do io
+            for c in chars
+                print(io, c)
+            end
+        end
+    end
+    props = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
+    point = 1
+    for c in chars
+        if c isa StyledChar
+            for prop in c.properties
+                push!(props, (point:point, prop))
+            end
+        end
+        point += ncodeunits(c)
+    end
+    StyledString(str, props)
+end
diff --git a/base/strings/strings.jl b/base/strings/strings.jl
index d995d8535e24b..17f329bedb208 100644
--- a/base/strings/strings.jl
+++ b/base/strings/strings.jl
@@ -1,5 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+include("strings/styled.jl")
 include("strings/search.jl")
 include("strings/unicode.jl")
 
diff --git a/base/strings/styled.jl b/base/strings/styled.jl
new file mode 100644
index 0000000000000..d1a6e58ece3c4
--- /dev/null
+++ b/base/strings/styled.jl
@@ -0,0 +1,432 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+"""
+    StyledString{S <: AbstractString} <: AbstractString
+
+A string with annotated regions (often styling information).
+
+More specifically, this is a thin wrapper around any other [`AbstractString`](@ref),
+which adds arbitrary named annotations to regions of the wrapped string.
+
+See also [`StyledChar`](@ref), [`styledstring`](@ref), [`S""`](@ref @S_str), and [`Face`](@ref).
+
+# Constructors
+
+In most cases the easiest way to construct a `StyledString` is via the
+[`S""`](@ref @S_str) string macro (which see), however a number of constructors
+are also availible.
+
+```julia
+StyledString(s::S<:AbstractString) -> StyledString{S}
+StyledString(s::S<:AbstractString, props::Pair{Symbol, <:Any}...)
+StyledString(s::S<:AbstractString, properties::Vector{Tuple{UnitRange{Int}, Pair{Symbol, <:Any}}})
+```
+
+A StyledString can also be created with [`styledstring`](@ref), which acts much
+like [`string`](@ref) but preserves any styling present in the arguments.
+
+# Examples
+
+```jldoctest
+julia> StyledString("hello there", :face => :italic)
+"hello there"
+
+julia> StyledString("more text", :tag => 1)
+"more text"
+```
+"""
+struct StyledString{S <: AbstractString} <: AbstractString
+    string::S
+    properties::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+end
+
+"""
+    StyledChar{S <: AbstractChar} <: AbstractChar
+
+A Char annotated by properties (often styling information).
+
+More specifically, this is a thin wrapper around any other [`AbstractChar`](@ref),
+which adds arbitrary named annotations to the wrapped character.
+
+# Constructors
+
+```julia
+StyledChar(s::S) -> StyledChar{S}
+StyledChar(s::S, props::Pair{Symbol, <:Any}...)
+StyledChar(s::S, properties::Vector{Pair{Symbol, <:Any}})
+```
+
+# Examples
+
+```jldoctest
+julia> StyledChar('j', :face => :blue)
+'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
+
+julia> StyledChar('j', :tag => :1)
+'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
+```
+"""
+struct StyledChar{C <: AbstractChar} <: AbstractChar
+    char::C
+    properties::Vector{Pair{Symbol, Any}}
+end
+
+## Constructors ##
+
+StyledString(s::AbstractString, prop::Pair{Symbol, <:Any}, props::Pair{Symbol, <:Any}...) =
+    StyledString(s, firstindex(s):lastindex(s), prop, props...)
+
+StyledString(s::AbstractString, region::UnitRange{Int}, props::Pair{Symbol, <:Any}...) =
+    StyledString(s, [(region, Pair{Symbol, Any}(first(p), last(p)))
+                      for p in props])
+
+StyledString(s::AbstractString, props::Vector{<:Pair{Symbol, <:Any}}) =
+    StyledString(s, [(firstindex(s):lastindex(s), p) for p in props])
+
+# Constructors called with overly-specialised arguments
+
+StyledString(s::AbstractString, props::Vector{<:Tuple{UnitRange{Int}, <:Pair{Symbol, <:Any}}}) =
+    StyledString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}(props))
+
+StyledChar(c::AbstractChar, prop::Pair{Symbol, <:Any}, props::Pair{Symbol, <:Any}...) =
+    StyledChar(c, Vector{Pair{Symbol, Any}}(vcat(prop, props...)))
+
+# Constructors to avoid recursive wrapping
+
+StyledString(s::StyledString, props::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}) =
+    StyledString(s.string, vcat(s.properties, props))
+
+StyledChar(c::StyledChar, props::Vector{Pair{Symbol, Any}}) =
+    StyledChar(c.char, vcat(s.properties, props))
+
+# To avoid pointless overhead
+String(s::StyledString{String}) = s.string
+
+## Conversion/promotion ##
+
+convert(::Type{StyledString}, s::StyledString) = s
+convert(::Type{StyledString{S}}, s::S) where {S <: AbstractString} =
+    StyledString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
+convert(::Type{StyledString}, s::S) where {S <: AbstractString} =
+    convert(StyledString{S}, s)
+StyledString(s::S) where {S <: AbstractString} = convert(StyledString{S}, s)
+
+convert(::Type{StyledChar}, c::StyledChar) = c
+convert(::Type{StyledChar{C}}, c::C) where { C <: AbstractChar } =
+    StyledChar{C}(c, Vector{Pair{Symbol, Any}}())
+convert(::Type{StyledChar}, c::C) where { C <: AbstractChar } =
+    convert(StyledChar{C}, c)
+
+StyledChar(c::AbstractChar) = convert(StyledChar, c)
+StyledChar(c::UInt32) = convert(StyledChar, Char(c))
+StyledChar{C}(c::UInt32) where {C <: AbstractChar} = convert(StyledChar, C(c))
+
+promote_rule(::Type{<:StyledString}, ::Type{<:AbstractString}) = StyledString
+
+## AbstractString interface ##
+
+ncodeunits(s::StyledString) = ncodeunits(s.string)
+codeunits(s::StyledString) = codeunits(s.string)
+codeunit(s::StyledString) = codeunit(s.string)
+codeunit(s::StyledString, i::Integer) = codeunit(s.string, i)
+isvalid(s::StyledString, i::Integer) = isvalid(s.string, i)
+@propagate_inbounds iterate(s::StyledString, i::Integer=firstindex(s)) =
+    if i <= lastindex(s.string); (s[i], nextind(s, i)) end
+eltype(::Type{<:StyledString{S}}) where {S} = StyledChar{eltype(S)}
+firstindex(s::StyledString) = firstindex(s.string)
+lastindex(s::StyledString) = lastindex(s.string)
+
+function getindex(s::StyledString, i::Integer)
+    @boundscheck checkbounds(s, i)
+    @inbounds if isvalid(s, i)
+        StyledChar(s.string[i], textproperties(s, i))
+    else
+        string_index_err(s, i)
+    end
+end
+
+## AbstractChar interface ##
+
+ncodeunits(c::StyledChar) = ncodeunits(c.char)
+codepoint(c::StyledChar) = codepoint(c.char)
+
+# Avoid the iteration fallback with comparison
+cmp(a::StyledString, b::AbstractString) = cmp(a.string, b)
+cmp(a::AbstractString, b::StyledString) = cmp(a, b.string)
+# To avoid method ambiguity
+cmp(a::StyledString, b::StyledString) = cmp(a.string, b.string)
+
+==(a::StyledString, b::StyledString) =
+    a.string == b.string && a.properties == b.properties
+
+==(a::StyledString, b::AbstractString) = isempty(a.properties) && a.string == b
+==(a::AbstractString, b::StyledString) = isempty(b.properties) && a == b.string
+
+"""
+    styledstring(values...)
+
+Create a `StyledString` from any number of `values` using their
+[`print`](@ref)ed representation.
+
+This acts like [`string`](@ref), but takes care to preserve any properties
+present (in the form of [`StyledString`](@ref) or [`StyledChar`](@ref) values).
+
+See also [`StyledString`](@ref), [`StyledChar`](@ref), and [`S""`](@ref @S_str).
+
+## Examples
+
+```
+julia> styledstring("now a StyledString")
+"now a StyledString"
+
+julia> styledstring(S"{yellow:styled text}", ", and unstyled")
+"styled text, and unstyled"
+```
+"""
+function styledstring(xs...)
+    isempty(xs) && return StyledString("")
+    size = mapreduce(_str_sizehint, +, xs)
+    s = IOContext(IOBuffer(sizehint=size), :color => true)
+    properties = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    for x in xs
+        if x isa StyledString
+            for (region, prop) in x.properties
+                push!(properties, (s.io.size .+ (region), prop))
+            end
+            print(s, x.string)
+        elseif x isa SubString{<:StyledString}
+            for (substr, props) in eachstyle(x)
+                region = s.io.size .+ (1+substr.offset:prevind(substr.string, 1+substr.offset+substr.ncodeunits)) .- x.offset
+                for prop in props
+                    push!(properties, (region, prop))
+                end
+            end
+            print(s, SubString(x.string.string, x.offset, x.ncodeunits, Val(:noshift)))
+        elseif x isa StyledChar
+            for prop in x.properties
+                push!(properties, (1+s.io.size:1+s.io.size, prop))
+            end
+            print(s, x.char)
+        else
+            print(s, x)
+        end
+    end
+    str = String(resize!(s.io.data, s.io.size))
+    StyledString(str, properties)
+end
+
+"""
+    styledstring_optimize!(str::StyledString)
+
+Merge contiguous identical properties in `str`.
+"""
+function styledstring_optimize!(s::StyledString)
+    last_seen = Dict{Pair{Symbol, Any}, Int}()
+    i = 1
+    while i <= length(s.properties)
+        region, keyval = s.properties[i]
+        prev = get(last_seen, keyval, 0)
+        if prev > 0
+            lregion, _ = s.properties[prev]
+            if last(lregion) + 1 == first(region)
+                s.properties[prev] =
+                    setindex(s.properties[prev],
+                             first(lregion):last(region),
+                             1)
+                deleteat!(s.properties, i)
+            else
+                delete!(last_seen, keyval)
+            end
+        else
+            last_seen[keyval] = i
+            i += 1
+        end
+    end
+    s
+end
+
+styledstring(s::StyledString) = s
+styledstring(c::StyledChar) = StyledString(string(c.char), c.properties)
+
+StyledString(s::SubString{<:StyledString}) = styledstring(s)
+
+function join(iterator, delim::StyledString, last=delim)
+    xs = zip(iterator, Iterators.repeated(delim)) |> Iterators.flatten |> collect
+    xs = xs[1:end-1]
+    if length(xs) > 1
+        xs[end-1] = last
+    end
+    styledstring(xs...)
+end
+
+function repeat(str::StyledString, r::Integer)
+    r == 0 && return one(StyledString)
+    r == 1 && return str
+    unstyled = repeat(str.string, r)
+    properties = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    len = ncodeunits(str)
+    fullregion = firstindex(str):lastindex(str)
+    for (region, prop) in str.properties
+        if region == fullregion
+            push!(properties, (firstindex(unstyled):lastindex(unstyled), prop))
+        end
+    end
+    for offset in 0:len:(r-1)*len
+        for (region, prop) in str.properties
+            if region != fullregion
+                push!(properties, (region .+ offset, prop))
+            end
+        end
+    end
+    StyledString(unstyled, properties) |> styledstring_optimize!
+end
+
+repeat(str::SubString{<:StyledString}, r::Integer) =
+    repeat(StyledString(str), r)
+
+function repeat(c::StyledChar, r::Integer)
+    str = repeat(c.char, r)
+    fullregion = firstindex(str):lastindex(str)
+    StyledString(str, [(fullregion, prop) for prop in c.properties])
+end
+
+function reverse(s::StyledString)
+    StyledString(reverse(s.string),
+                 [(UnitRange(1 + lastindex(s) - last(region),
+                             1 + lastindex(s) - first(region)),
+                   prop)
+                  for (region, prop) in s.properties])
+end
+
+# TODO optimise?
+reverse(s::SubString{<:StyledString}) = reverse(StyledString(s))
+
+# TODO implement `replace(::StyledString, ...)`
+
+## End AbstractString interface ##
+
+"""
+    textproperty!(s::StyledString, [range::UnitRange{Int}], prop::Symbol, val)
+    textproperty!(s::SubString{StyledString}, [range::UnitRange{Int}], prop::Symbol, val)
+
+Set `prop` to `val` in `s`, over either `range` if specified or the whole string.
+"""
+function textproperty!(s::StyledString, range::UnitRange{Int}, prop::Symbol, val)
+    indices = searchsorted(s.properties, (range,), by=first)
+    propindex = filter(i -> first(s.properties[i][2]) === prop, indices)
+    if length(propindex) == 1
+        if val === nothing
+            deleteat!(s.properties, first(propindex))
+        else
+            s.properties[first(propindex)] = (range, Pair{Symbol, Any}(prop, val))
+        end
+    else
+        splice!(s.properties, indices, [(range, Pair{Symbol, Any}(prop, val))])
+    end
+    s
+end
+
+textproperty!(ss::StyledString, prop::Symbol, value) =
+    textproperty!(ss, firstindex(ss):lastindex(ss), prop, value)
+
+textproperty!(s::SubString{<:StyledString}, range::UnitRange{Int}, prop::Symbol, value) =
+    (textproperty!(s.string, s.offset .+ (range), prop, value); s)
+
+textproperty!(s::SubString{<:StyledString}, prop::Symbol, value) =
+    (textproperty!(s.string, s.offset .+ (1:s.ncodeunits), prop, value); s)
+
+# TODO optimise
+"""
+    textproperties(s::StyledString, i::Integer)
+    textproperties(s::SubString{StyledString}, i::Integer)
+
+Get the text properties that apply to `s` at index `i`.
+"""
+function textproperties(s::StyledString, i::Integer)
+    props = filter(prop -> !isempty(intersect(i:i, first(prop))),
+                   s.properties)
+    last.(props)
+end
+
+textproperties(s::SubString{<:StyledString}, i::Integer) =
+    textproperties(s.string, s.offset + i)
+
+"""
+    textproperties(c::StyledChar)
+
+Get the properties that apply to `c`.
+"""
+textproperties(c::StyledChar) = c.properties
+
+## Iterating over styles ##
+
+struct StyleIterator{S <: AbstractString}
+    str::S
+    regions::Vector{UnitRange{Int}}
+    styles::Vector{Vector{Pair{Symbol, Any}}}
+end
+
+length(si::StyleIterator) = length(si.regions)
+
+@propagate_inbounds function iterate(si::StyleIterator, i::Integer=1)
+    if i <= length(si.regions)
+        @inbounds ((SubString(si.str, si.regions[i]), si.styles[i]), i+1)
+    end
+end
+
+eltype(::StyleIterator{S}) where { S <: AbstractString} =
+    Tuple{SubString{S}, Vector{Pair{Symbol, Any}}}
+
+"""
+    eachstyle(s::StyledString{S})
+    eachstyle(s::SubString{StyledString{S}})
+
+Identify the contiguous substrings of `s` with a constant style, and return
+an iterator which provides each substring and the applicable styles as a
+`Tuple{SubString{S}, Vector{Pair{Symbol, Any}}}`.
+
+# Examples
+
+```jldoctest
+julia> eachstyle(StyledString("hey there", [(1:3, :face => :bold),
+                                            (5:9, :face => :italic)])) |> collect
+3-element Vector{Tuple{SubString{String}, Vector{Pair{Symbol, Any}}}}:
+ ("hey", [:face => :bold])
+ (" ", [])
+ ("there", [:face => :italic])
+```
+"""
+function eachstyle(s::StyledString, region::UnitRange{Int}=firstindex(s):lastindex(s))
+    isempty(s) || isempty(region) &&
+        return StyleIterator(s, Vector{UnitRange{Int}}(), Vector{Vector{Pair{Symbol, Any}}}())
+    regions = Vector{UnitRange{Int}}()
+    styles = Vector{Vector{Pair{Symbol, Any}}}()
+    changepoints = filter(c -> c in region,
+                          Iterators.flatten((first(region), nextind(s, last(region)))
+                                            for region in first.(s.properties)) |>
+                                                unique |> sort)
+    isempty(changepoints) &&
+        return StyleIterator(s.string, [region], [textproperties(s, first(region))])
+    function registerchange!(start, stop)
+        push!(regions, start:stop)
+        push!(styles, textproperties(s, start))
+    end
+    if first(region) < first(changepoints)
+        registerchange!(first(region), prevind(s, first(changepoints)))
+    end
+    for (start, stop) in zip(changepoints, changepoints[2:end])
+        registerchange!(start, prevind(s, stop))
+    end
+    if last(changepoints) <= last(region)
+        registerchange!(last(changepoints), last(region))
+    end
+    StyleIterator(s.string, regions, styles)
+end
+
+function eachstyle(s::SubString{<:StyledString}, region::UnitRange{Int}=firstindex(s):lastindex(s))
+    if isempty(s)
+        StyleIterator(s, Vector{UnitRange{Int}}(), Vector{Vector{Pair{Symbol, Any}}}())
+    else
+        eachstyle(s.string, first(region)+s.offset:last(region)+s.offset)
+    end
+end
diff --git a/base/strings/util.jl b/base/strings/util.jl
index 890afaf62b2ee..337131d823824 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -458,13 +458,15 @@ function lpad(
     s::Union{AbstractChar,AbstractString},
     n::Integer,
     p::Union{AbstractChar,AbstractString}=' ',
-) :: String
+)
+    stringfn = if any(isa.((s, p), Union{StyledString, StyledChar, SubString{<:StyledString}}))
+        styledstring else string end
     n = Int(n)::Int
     m = signed(n) - Int(textwidth(s))::Int
-    m ≤ 0 && return string(s)
+    m ≤ 0 && return stringfn(s)
     l = textwidth(p)
     q, r = divrem(m, l)
-    r == 0 ? string(p^q, s) : string(p^q, first(p, r), s)
+    r == 0 ? stringfn(p^q, s) : stringfn(p^q, first(p, r), s)
 end
 
 """
@@ -488,13 +490,15 @@ function rpad(
     s::Union{AbstractChar,AbstractString},
     n::Integer,
     p::Union{AbstractChar,AbstractString}=' ',
-) :: String
+)
+    stringfn = if any(isa.((s, p), Union{StyledString, StyledChar, SubString{<:StyledString}}))
+        styledstring else string end
     n = Int(n)::Int
     m = signed(n) - Int(textwidth(s))::Int
-    m ≤ 0 && return string(s)
+    m ≤ 0 && return stringfn(s)
     l = textwidth(p)
     q, r = divrem(m, l)
-    r == 0 ? string(s, p^q) : string(s, p^q, first(p, r))
+    r == 0 ? stringfn(s, p^q) : stringfn(s, p^q, first(p, r))
 end
 
 """

From c505b047ac44b2bbd4e536bef6b84cb11531abff Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Tue, 2 May 2023 00:24:06 +0800
Subject: [PATCH 0040/1315] Introduce text faces

To easy text styling, a "Face" type is introduced which bundles a
collection of stylistic attributes together (essentially constituting a
typeface). This builds on the recently added Styled{String,Char} types,
and together allow for an ergonomic way of handling styled text.
---
 base/client.jl          |  15 ++
 base/exports.jl         |   3 +
 base/strings/faces.jl   | 561 ++++++++++++++++++++++++++++++++++++++++
 base/strings/strings.jl |   1 +
 4 files changed, 580 insertions(+)
 create mode 100644 base/strings/faces.jl

diff --git a/base/client.jl b/base/client.jl
index 7339bf0870990..ac7fabe19a458 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -394,6 +394,19 @@ function load_InteractiveUtils(mod::Module=Main)
     return MainInclude.InteractiveUtils
 end
 
+"""
+    loadfaces!(facetoml::IO)
+
+Parse `facetoml` as TOML, and load all faces described.
+The loading is done with `loadfaces!`, which see.
+
+Face entries should be of the following form:
+```toml
+[face_name]
+property = "value"
+"""
+loadfaces!(facetoml::IO) = loadfaces!(TOML.parse(TOML.Parser(facetoml)))
+
 function load_REPL()
     # load interactive-only libraries
     try
@@ -416,6 +429,8 @@ function run_main_repl(interactive::Bool, quiet::Bool, banner::Symbol, history_f
         end
     end
     # TODO cleanup REPL_MODULE_REF
+    userfaces = joinpath(first(DEPOT_PATH), "config", "faces.toml")
+    isfile(userfaces) && open(loadfaces!, userfaces)
 
     if !fallback_repl && interactive && isassigned(REPL_MODULE_REF)
         invokelatest(REPL_MODULE_REF[]) do REPL
diff --git a/base/exports.jl b/base/exports.jl
index 87b52189983ad..93b7ee8181065 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -50,6 +50,7 @@ export
     Dims,
     Enum,
     ExponentialBackOff,
+    Face,
     IndexCartesian,
     IndexLinear,
     IndexStyle,
@@ -582,6 +583,7 @@ export
     ∪,
 
 # strings
+    addface!,
     ascii,
     bitstring,
     bytes2hex,
@@ -610,6 +612,7 @@ export
     isspace,
     isuppercase,
     isxdigit,
+    loadfaces!,
     lowercase,
     lowercasefirst,
     isvalid,
diff --git a/base/strings/faces.jl b/base/strings/faces.jl
new file mode 100644
index 0000000000000..c5b82bb7da1d7
--- /dev/null
+++ b/base/strings/faces.jl
@@ -0,0 +1,561 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+const RGBTuple = NamedTuple{(:r, :g, :b), NTuple{3, UInt8}}
+
+"""
+    struct SimpleColor
+
+A basic representation of a color, intended for string styling purposes.
+It can either contain a named color (like `:red`), or an `RGBTuple` which
+is a NamedTuple specifying an `r`, `g`, `b` color with a bit-depth of 8.
+
+# Constructors
+
+```julia
+SimpleColor(name::Symbol)  # e.g. :red
+SimpleColor(rgb::RGBTuple) # e.g. (r=1, b=2, g=3)
+SimpleColor(r::Integer, b::Integer, b::Integer)
+SimpleColor(rgb::UInt32)   # e.g. 0x123456
+```
+
+Also see `tryparse(SimpleColor, rgb::String)`.
+"""
+struct SimpleColor
+    value::Union{Symbol, RGBTuple}
+end
+
+SimpleColor(r::Integer, g::Integer, b::Integer) = SimpleColor((; r=UInt8(r), g=UInt8(g), b=UInt8(b)))
+SimpleColor(rgb::UInt32) = SimpleColor(reverse(reinterpret(UInt8, [rgb]))[2:end]...)
+
+"""
+    tryparse(::Type{SimpleColor}, rgb::String)
+
+Attempt to parse `rgb` as a `SimpleColor`. If `rgb` starts with
+`#` and has a length of 7, it is converted into a `RGBTuple`-backed `SimpleColor`.
+If `rgb` starts with `a`-`z`, `rgb` is interpreted as a color name
+and converted to a `Symbol`-backed `SimpleColor`.
+
+Otherwise, `nothing` is returned.
+
+# Examples
+
+```jldoctest
+julia> tryparse(SimpleColor, "blue")
+SimpleColor(:blue)
+
+julia> tryparse(SimpleColor, "#9558b2")
+SimpleColor((r = 0x95, g = 0x58, b = 0xb2))
+
+julia> tryparse(SimpleColor, "#nocolor")
+```
+"""
+function tryparse(::Type{SimpleColor}, rgb::String)
+    if ncodeunits(rgb) == 7 && first(rgb) == '#' &&
+        all(∈(('#',) ∪ ('0':'9') ∪ ('a':'f') ∪ ('A':'F')), rgb)
+        SimpleColor(parse(UInt8, rgb[2:3], base=16),
+                    parse(UInt8, rgb[4:5], base=16),
+                    parse(UInt8, rgb[6:7], base=16))
+    elseif startswith(rgb, 'a':'z') || startswith(rgb, 'A':'Z')
+        SimpleColor(Symbol(rgb))
+    else
+        nothing
+    end
+end
+
+"""
+    parse(::Type{SimpleColor}, rgb::String)
+
+An analogue of `tryparse(SimpleColor, rgb::String)` (which see),
+that raises an error instead of returning `nothing`.
+"""
+function parse(::Type{SimpleColor}, rgb::String)
+    color = tryparse(SimpleColor, rgb)
+    !isnothing(color) ||
+        throw(ArgumentError("invalid color \"$rgb\""))
+    color
+end
+
+"""
+A [`Face`](@ref) is a collection of graphical attributes for displaying text.
+Faces control how text is displayed in the terminal, and possibly other
+places too.
+
+Most of the time, a [`Face`](@ref) will be stored in the global faces dicts as a
+unique association with a *face name* Symbol, and will be most often referred to
+by this name instead of the [`Face`](@ref) object itself.
+
+# Attributes
+
+All attributes can be set via the keyword constructor, and default to `nothing`.
+
+- `height` (an `Int` or `Float64`): The height in either deci-pt (when an `Int`),
+  or as a factor of the base size (when a `Float64`).
+- `weight` (a `Symbol`): One of the symbols (from faintest to densest)
+  `:thin`, `:extralight`, `:light`, `:semilight`, `:normal`,
+  `:medium`, `:semibold`, `:bold`, `:extrabold`, or `:black`.
+  In terminals any weight greater than `:normal` is displayed as bold,
+  and in terminals that support variable-brightness text, any weight
+  less than `:normal` is displayed as faint.
+- `slant` (a `Symbol`): One of the symbols `:italic`, `:oblique`, or `:normal`.
+- `foreground` (a `SimpleColor`): The text foreground color.
+- `background` (a `SimpleColor`): The text background color.
+- `underline`, the text underline, which takes one of the following forms:
+  - a `Bool`: Whether the text should be underlined or not.\\
+  - a `SimpleColor`: The text should be underlined with this color.\\
+  - a `Tuple{Nothing, Symbol}`: The text should be underlined using the style
+    set by the Symbol, one of `:straight`, `:double`, `:curly`, `:dotted`,
+    or `:dashed`.\\
+  - a `Tuple{SimpleColor, Symbol}`: The text should be underlined in the specified
+    SimpleColor, and using the style specified by the Symbol, as before.
+- `strikethrough` (a `Bool`): Whether the text should be struck through.
+- `inverse` (a `Bool`): Whether the foreground and background colors should be
+  inverted.
+- `inherit` (a `Vector{Symbol}`): Names of faces to inherit from,
+  with earlier faces taking priority. All faces inherit from the `:default` face.
+"""
+struct Face
+    font::Union{Nothing, String}
+    height::Union{Nothing, Int, Float64}
+    weight::Union{Nothing, Symbol}
+    slant::Union{Nothing, Symbol}
+    foreground::Union{Nothing, SimpleColor}
+    background::Union{Nothing, SimpleColor}
+    underline::Union{Nothing, Bool, SimpleColor,
+                     Tuple{<:Union{Nothing, SimpleColor}, Symbol}}
+    strikethrough::Union{Nothing, Bool}
+    inverse::Union{Nothing, Bool}
+    inherit::Vector{Symbol}
+end
+
+function Face(; font::Union{Nothing, String} = nothing,
+              height::Union{Nothing, Int, Float64} = nothing,
+              weight::Union{Nothing, Symbol} = nothing,
+              slant::Union{Nothing, Symbol} = nothing,
+              foreground::Union{Nothing, SimpleColor, Symbol, RGBTuple, UInt32} = nothing,
+              background::Union{Nothing, SimpleColor, Symbol, RGBTuple, UInt32} = nothing,
+              underline::Union{Nothing, Bool, SimpleColor,
+                               Symbol, RGBTuple, UInt32,
+                               Tuple{<:Union{Nothing, SimpleColor, Symbol, RGBTuple, UInt32}, Symbol}
+                               } = nothing,
+              strikethrough::Union{Nothing, Bool} = nothing,
+              inverse::Union{Nothing, Bool} = nothing,
+              inherit::Union{Symbol, Vector{Symbol}} = Symbol[],
+              _...) # Simply ignore unrecognised keyword arguments.
+    ascolor(::Nothing) = nothing
+    ascolor(c::SimpleColor) = c
+    ascolor(c::Union{Symbol, RGBTuple, UInt32}) = SimpleColor(c)
+    Face(font, height, weight, slant,
+         ascolor(foreground), ascolor(background),
+         if underline isa Tuple
+             (ascolor(underline[1]), underline[2])
+         elseif underline isa Symbol || underline isa RGBTuple || underline isa UInt32
+             ascolor(underline)
+         else
+             underline
+         end,
+         strikethrough,
+         inverse,
+         if inherit isa Symbol
+             [inherit]
+         else inherit end)
+end
+
+==(a::Face, b::Face) =
+    getfield.(Ref(a), fieldnames(Face)) ==
+    getfield.(Ref(b), fieldnames(Face))
+
+"""
+Globally named [`Face`](@ref)s.
+
+`default` gives the initial values of the faces, and `current` holds the active
+(potentially modified) set of faces. This two-set system allows for any
+modifications to the active faces to be undone.
+"""
+const FACES = let default = Dict{Symbol, Face}(
+    # Default is special, it must be completely specified
+    # and everything inherits from it.
+    :default => Face(
+        "monospace", 120,      # font, height
+        :normal, :normal,      # weight, slant
+        SimpleColor(:default), # foreground
+        SimpleColor(:default), # background
+        false, false, false,   # underline, strikethrough, overline
+        Symbol[]),              # inherit
+    # Property faces
+    :bold => Face(weight=:bold),
+    :italic => Face(slant=:italic),
+    :underline => Face(underline=true),
+    :strikethrough => Face(strikethrough=true),
+    :inverse => Face(inverse=true),
+    # Basic color faces
+    :black => Face(foreground=:black),
+    :red => Face(foreground=:red),
+    :green => Face(foreground=:green),
+    :yellow => Face(foreground=:yellow),
+    :blue => Face(foreground=:blue),
+    :magenta => Face(foreground=:magenta),
+    :cyan => Face(foreground=:cyan),
+    :white => Face(foreground=:white),
+    :bright_black => Face(foreground=:bright_black),
+    :grey => Face(foreground=:bright_black),
+    :gray => Face(foreground=:bright_black),
+    :bright_red => Face(foreground=:bright_red),
+    :bright_green => Face(foreground=:bright_green),
+    :bright_yellow => Face(foreground=:bright_yellow),
+    :bright_blue => Face(foreground=:bright_blue),
+    :bright_magenta => Face(foreground=:bright_magenta),
+    :bright_cyan => Face(foreground=:bright_cyan),
+    :bright_white => Face(foreground=:bright_white),
+    # Useful common faces
+    :shadow => Face(foreground=:bright_black),
+    :region => Face(background=0x3a3a3a),
+    :emphasis => Face(foreground=:blue),
+    :highlight => Face(inherit=:emphasis, inverse=true),
+    :code => Face(foreground=:cyan),
+    # Styles of generic content categories
+    :error => Face(foreground=:bright_red),
+    :warning => Face(foreground=:yellow),
+    :success => Face(foreground=:green),
+    :info => Face(foreground=:bright_cyan),
+    :note => Face(foreground=:grey),
+    :tip => Face(foreground=:bright_green))
+    (; default, current=Ref(copy(default)))
+end
+
+## Adding and resetting faces ##
+
+"""
+    addface!(name::Symbol => default::Face)
+
+Create a new face by the name `name`. So long as no face already exists by this
+name, `default` is added to both `FACES``.default` and (a copy of) to
+`FACES`.`current`, with the current value returned.
+
+Should the face `name` already exist, `nothing` is returned.
+
+# Examples
+
+```jldoctest
+julia> addface!(:mypkg_myface => Face(slant=:italic, underline=true))
+Face (sample)
+         slant: italic
+     underline: true
+```
+"""
+function addface!((name, default)::Pair{Symbol, Face})
+    if !haskey(FACES.default, name)
+        FACES.default[name] = default
+        FACES.current[][name] = if haskey(FACES.current[], name)
+            merge(deepcopy(default), FACES.current[][name])
+        else
+            deepcopy(default)
+        end
+    end
+end
+
+"""
+    resetfaces!()
+
+Reset the current global face dictionary to the default value.
+"""
+function resetfaces!()
+    FACES.current[] = copy(FACES.default)
+end
+
+"""
+    resetfaces!(name::Symbol)
+
+Reset the face `name` to its default value, which is returned.
+
+If the face `name` does not exist, nothing is done and `nothing` returned.
+In the unlikely event that the face `name` does not have a default value,
+it is deleted, a warning message is printed, and `nothing` returned.
+"""
+function resetfaces!(name::Symbol)
+    if !haskey(FACES.current[], name)
+    elseif haskey(FACES.current[], name)
+        FACES.current[][name] = copy(FACES.default[name])
+    else # This shouldn't happen
+        delete!(FACES.current[], name)
+        println(stderr,
+                """! The face $name was reset, but it had no default value, and so has been deleted instead!",
+                     This should not have happened, perhaps the face was added without using `addface!`?""")
+    end
+end
+
+"""
+    withfaces(f, kv::Pair...)
+
+Execute `f` with `FACES``.current` temporarily modified by zero or more
+`:name => val` arguments `kv`. `withfaces` is generally used via the
+`withfaces(kv...) do ... end` syntax. A value of `nothing` can be used to
+temporarily unset an face (if if has been set). When `withfaces` returns, the
+original `FACES``.current` has been restored.
+
+    !!! warning
+    Changing faces is not thread-safe.
+
+# Examples
+
+```jldoctest
+julia> withfaces(:yellow => Face(foreground=:red), :green => :blue) do
+           println(S"{yellow:red} and {green:blue} mixed make {magenta:purple}")
+       end
+"red and blue mixed make purple"
+```
+"""
+function withfaces(f, keyvals::Pair{Symbol, <:Union{Face, Symbol, Nothing}}...)
+    old = Dict{Symbol, Union{Face, Nothing}}()
+    for (name, face) in keyvals
+        old[name] = get(FACES.current[], name, nothing)
+        if face isa Face
+            FACES.current[][name] = face
+        elseif face isa Symbol
+            FACES.current[][name] =
+                @something(get(old, face, nothing), get(FACES.current[], face, Face()))
+        elseif haskey(FACES.current[], name)
+            delete!(FACES.current[], name)
+        end
+    end
+    try f()
+    finally
+        for (name, face) in old
+            if isnothing(face)
+                delete!(FACES.current[], name)
+            else
+                FACES.current[][name] = face
+            end
+        end
+    end
+end
+
+"""
+    withfaces(f, altfaces::Dict{Symbol, Face})
+
+Execute `f` with `FACES``.current` temporarily swapped out with `altfaces`
+When `withfaces` returns, the original `FACES``.current` has been restored.
+
+    !!! warning
+    Changing faces is not thread-safe.
+"""
+function withfaces(f, altfaces::Dict{Symbol, Face})
+    oldfaces, FACES.current[] = FACES.current[], altfaces
+    try f()
+    finally
+        FACES.current[] = oldfaces
+    end
+end
+
+withfaces(f) = f()
+
+## Face combination and inheritance ##
+
+"""
+    merge(initial::Face, others::Face...)
+
+Merge the properties of the `initial` face and `others`, with
+later faces taking priority.
+"""
+function merge(a::Face, b::Face)
+    if isempty(a.inherit)
+        Face(ifelse(isnothing(b.font),          a.font,          b.font),
+             if isnothing(b.height)      a.height
+             elseif isnothing(a.height)  b.height
+             elseif b.height isa Int     b.height
+             elseif a.height isa Int     round(Int, a.height * b.height)
+             else a.height * b.height end,
+             ifelse(isnothing(b.weight),        a.weight,        b.weight),
+             ifelse(isnothing(b.slant),         a.slant,         b.slant),
+             ifelse(isnothing(b.foreground),    a.foreground,    b.foreground),
+             ifelse(isnothing(b.background),    a.background,    b.background),
+             ifelse(isnothing(b.underline),     a.underline,     b.underline),
+             ifelse(isnothing(b.strikethrough), a.strikethrough, b.strikethrough),
+             ifelse(isnothing(b.inverse),       a.inverse,       b.inverse),
+             b.inherit)
+    else
+        a_noinherit = Face(
+            a.font, a.height, a.weight, a.slant, a.foreground, a.background,
+            a.underline, a.strikethrough, a.inverse, Symbol[])
+        a_inheritance = map(fname -> get(FACES.current[], fname, Face()), Iterators.reverse(a.inherit))
+        a_resolved = merge(foldl(merge, a_inheritance), a_noinherit)
+        merge(a_resolved, b)
+    end
+end
+
+merge(a::Face, b::Face, others::Face...) = merge(merge(a, b), others...)
+
+## Getting the combined face from a set of properties ##
+
+"""
+    getface(faces)
+
+Obtain the final merged face from `faces`, an iterator of
+[`Face`](@ref)s, face name `Symbol`s, and lists thereof.
+"""
+function getface(faces)
+    isempty(faces) && return FACES.current[][:default]
+    mergedface(face::Face) = face
+    mergedface(face::Symbol) = get(FACES.current[], face, Face())
+    mergedface(faces::Vector) = mapfoldl(mergedface, merge, Iterators.reverse(faces))
+    combined = mapfoldl(mergedface, merge, Iterators.reverse(faces))::Face
+    if !isempty(combined.inherit)
+        combined = merge(combined, Face())
+    end
+    merge(FACES.current[][:default], combined)
+end
+
+"""
+    getface(styles::Vector{Pair{Symbol, Any}})
+
+Combine all of the `:face` styles with `getfaces`.
+"""
+function getface(styles::Vector{Pair{Symbol, Any}})
+    faces = (last(prop) for prop in styles if first(prop) === :face)
+    getface(faces)
+end
+
+getface(face::Face) = merge(FACES.current[][:default], merge(face, Face()))
+getface(face::Symbol) = getface(get(FACES.current[], face, Face()))
+
+"""
+    getface()
+
+Obtain the default face.
+"""
+getface() = FACES.current[][:default]
+
+## Face/StyledString integration ##
+
+"""
+    getface(s::StyledString, i::Integer)
+
+Get the merged [`Face`](@ref) that applies to `s` at index `i`.
+"""
+getface(s::StyledString, i::Integer) =
+    getface(textproperties(s, i))
+
+"""
+    getface(c::StyledChar)
+
+Get the merged [`Face`](@ref) that applies to `c`.
+"""
+getface(c::StyledChar) = getface(c.properties)
+
+"""
+    face!(s::Union{<:StyledString, <:SubString{<:StyledString}},
+          [range::UnitRange{Int},] face::Union{Symbol, Face})
+
+Apply `face` to `s`, along `range` if specified, or the whole of `s`.
+"""
+face!(s::Union{<:StyledString, <:SubString{<:StyledString}},
+      range::UnitRange{Int}, face::Union{Symbol, Face}) =
+          textproperty!(s, range, :face, face)
+
+face!(s::Union{<:StyledString, <:SubString{<:StyledString}},
+      face::Union{Symbol, Face}) =
+          textproperty!(s, firstindex(s):lastindex(s), :face, face)
+
+## Reading face definitions from a dictionary ##
+
+"""
+    loadfaces!(name::Symbol => update::Face)
+
+Merge the face `name` in `FACES``.current` with `update`. If the face `name` does
+not already exist in `FACES``.current`, then it is set to `update.`
+
+# Examples
+
+```jldoctest
+julia> loadfaces!(:red => Face(foreground=0xff0000))
+Face (sample)
+    foreground: ■ #ff0000
+```
+"""
+function loadfaces!((name, update)::Pair{Symbol, Face})
+    if haskey(FACES.current[], name)
+        FACES.current[][name] = merge(FACES.current[][name], update)
+    else
+        FACES.current[][name] = update
+    end
+end
+
+function loadfaces!((name, _)::Pair{Symbol, Nothing})
+    if haskey(FACES.current[], name)
+        resetfaces!(name)
+    end
+end
+
+"""
+    loadfaces!(faces::Dict{String, Any})
+
+For each face specified in `Dict`, load it to `FACES``.current`.
+"""
+function loadfaces!(faces::Dict{String, Any}, prefix::Union{String, Nothing}=nothing)
+    for (name, spec) in faces
+        fullname = if isnothing(prefix)
+            name
+        else
+            string(prefix, '_', name)
+        end
+        fspec = filter((_, v)::Pair -> !(v isa Dict), spec)
+        fnest = filter((_, v)::Pair -> v isa Dict, spec)
+        !isempty(fspec) &&
+            loadfaces!(Symbol(fullname) => convert(Face, fspec))
+        !isempty(fnest) &&
+            loadfaces!(fnest, fullname)
+    end
+end
+
+function convert(::Type{Face}, spec::Dict)
+    Face(if haskey(spec, "font") && spec["font"] isa String
+             spec["font"] end,
+         if haskey(spec, "height") && (spec["height"] isa Int || spec["height"] isa Float64)
+             spec["height"]
+         end,
+         if haskey(spec, "weight") && spec["weight"] isa String
+             Symbol(spec["weight"])
+         elseif haskey(spec, "bold") && spec["bold"] isa Bool
+             ifelse(spec["bold"], :bold, :normal)
+         end,
+         if haskey(spec, "slant") && spec["slant"] isa String
+             Symbol(spec["slant"])
+         elseif haskey(spec, "italic") && spec["italic"] isa Bool
+             ifelse(spec["italic"], :italic, :normal)
+         end,
+         if haskey(spec, "foreground") && spec["foreground"] isa String
+             tryparse(SimpleColor, spec["foreground"])
+         elseif haskey(spec, "fg") && spec["fg"] isa String
+             tryparse(SimpleColor, spec["fg"])
+         end,
+         if haskey(spec, "background") && spec["background"] isa String
+             tryparse(SimpleColor, spec["background"])
+         elseif haskey(spec, "bg") && spec["bg"] isa String
+             tryparse(SimpleColor, spec["bg"])
+         end,
+         if !haskey(spec, "underline")
+         elseif spec["underline"] isa Bool
+             spec["underline"]
+         elseif spec["underline"] isa String
+             tryparse(SimpleColor, spec["underline"])
+         elseif spec["underline"] isa Vector && length(spec["underline"]) == 2
+             color = tryparse(SimpleColor, spec["underline"][1])
+             (color, Symbol(spec["underline"][2]))
+         end,
+         if !haskey(spec, "strikethrough")
+         elseif spec["strikethrough"] isa Bool
+             spec["strikethrough"]
+         elseif spec["strikethrough"] isa String
+             tryparse(SimpleColor, spec["strikethrough"])
+         end,
+         if haskey(spec, "inverse") && spec["inverse"] isa Bool
+             spec["inverse"] end,
+         if !haskey(spec, "inherit")
+             Symbol[]
+         elseif spec["inherit"] isa String
+             [Symbol(spec["inherit"])]
+         elseif spec["inherit"] isa Vector{String}
+             Symbol.(spec["inherit"])
+         else
+             Symbol[]
+         end)
+end
diff --git a/base/strings/strings.jl b/base/strings/strings.jl
index 17f329bedb208..5e1e91b319b17 100644
--- a/base/strings/strings.jl
+++ b/base/strings/strings.jl
@@ -1,6 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 include("strings/styled.jl")
+include("strings/faces.jl")
 include("strings/search.jl")
 include("strings/unicode.jl")
 

From eada39b4e162b32454f967333b3557ece60293ee Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Tue, 2 May 2023 00:29:46 +0800
Subject: [PATCH 0041/1315] Introduce a styled string macro (@S_str)

To make specifying StyledStrings easier, the @S_str macro is added to
convert a minimalistic style markup to either a constant StyledString or
a StyledString-generating expression.

This macro was not easy to write, but seems to work well in practice.
---
 base/exports.jl       |   1 +
 base/strings/faces.jl | 254 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 255 insertions(+)

diff --git a/base/exports.jl b/base/exports.jl
index 93b7ee8181065..d2b6995318789 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1018,6 +1018,7 @@ export
     @b_str,    # byte vector
     @r_str,    # regex
     @s_str,    # regex substitution string
+    @S_str,    # styled string
     @v_str,    # version number
     @raw_str,  # raw string with no interpolation/unescaping
     @NamedTuple,
diff --git a/base/strings/faces.jl b/base/strings/faces.jl
index c5b82bb7da1d7..69f5d43a6aa8e 100644
--- a/base/strings/faces.jl
+++ b/base/strings/faces.jl
@@ -559,3 +559,257 @@ function convert(::Type{Face}, spec::Dict)
              Symbol[]
          end)
 end
+
+## Style macro ##
+
+"""
+    @S_str -> StyledString
+
+Construct a styled string. Within the string, `{<specs>:<content>}` structures
+apply the formatting to `<content>`, according to the list of comma-separated
+specifications `<specs>`. Each spec can either take the form of a face name,
+an inline face specification, or a `key=value` pair. The value must be wrapped
+by `{...}` should it contain any of the characters `,=:{}`.
+
+String interpolation with `\$` functions in the same way as regular strings,
+except quotes need to be escaped. Faces, keys, and values can also be
+interpolated with `\$`.
+
+# Example
+
+```julia
+S"The {bold:{italic:quick} {(foreground=#cd853f):brown} fox} jumped over \
+the {link={https://en.wikipedia.org/wiki/Laziness}:lazy} dog"
+```
+"""
+macro S_str(raw_content::String)
+    parts = Any[]
+    content = unescape_string(raw_content, ('{', '}', '$', '\n'))
+    content_bytes = Vector{UInt8}(content)
+    s = Iterators.Stateful(zip(eachindex(content), content))
+    offset = 0
+    point = 1
+    escape = false
+    active_styles = Vector{Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}}()
+    pending_styles = Vector{Tuple{UnitRange{Int}, Union{Symbol, Expr, Pair{Symbol, Any}}}}()
+    interpolated = false
+    function addpart(stop::Int)
+        str = String(content_bytes[point:stop+offset+ncodeunits(content[stop])-1])
+        push!(parts,
+              if isempty(pending_styles) && isempty(active_styles)
+                  str
+              else
+                  styles = Expr[]
+                  relevant_styles = Iterators.filter(
+                      (start, _)::Tuple -> start <= stop + offset + 1,
+                      Iterators.flatten(active_styles))
+                  for (start, prop) in relevant_styles
+                      range = (start - point):(stop - point + offset + 1)
+                      push!(styles, Expr(:tuple, range, prop))
+                  end
+                  for (range, prop) in pending_styles
+                      if !isempty(range)
+                          push!(styles, Expr(:tuple, range .- point, prop))
+                      end
+                  end
+                  empty!(pending_styles)
+                  if isempty(styles)
+                      str
+                  else
+                      :(StyledString($str, $(Expr(:vect, styles...))))
+                  end
+              end)
+        point = nextind(content, stop) + offset
+    end
+    function addpart(start::Int, expr, stop::Int)
+        if point < start
+            addpart(start)
+        end
+        if isempty(active_styles)
+            push!(parts, expr)
+        else
+            push!(parts,
+                  :(StyledString(string($expr),
+                                 $(last.(Iterators.flatten(active_styles))...))))
+            map!.((_, prop)::Tuple -> (nextind(content, stop + offset), prop), active_styles, active_styles)
+        end
+    end
+    for (i, char) in s
+        if char == '\\'
+            escape = true
+        elseif escape
+            if char in ('{', '}', '$')
+                deleteat!(content_bytes, i + offset - 1)
+                offset -= 1
+            elseif char == '\n'
+                deleteat!(content_bytes, i+offset-1:i+offset)
+                offset -= 2
+            end
+            escape = false
+        elseif char == '$'
+            # Interpolation
+            expr, nexti = Meta.parseatom(content, i + 1)
+            deleteat!(content_bytes, i + offset)
+            offset -= 1
+            nchars = length(content[i:prevind(content, nexti)])
+            for _ in 1:min(length(s), nchars-1)
+                popfirst!(s)
+            end
+            addpart(i, expr, nexti)
+            point = nexti + offset
+            interpolated = true
+        elseif char == '{'
+            # Property declaration parsing and application
+            properties = true
+            hasvalue = false
+            newstyles = Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}()
+            while properties
+                if !isnothing(peek(s)) && last(peek(s)) == '('
+                    # Inline face
+                    popfirst!(s)
+                    specstr = Iterators.takewhile(c -> last(c) != ')', s) |>
+                        collect .|> last |> String
+                    spec = map(split(specstr, ',')) do spec
+                        spec = rstrip(spec)
+                        kv = split(spec, '=', limit=2)
+                        if length(kv) == 2
+                            kv[1] => @something(tryparse(Bool, kv[2]),
+                                                String(kv[2]))
+                        else "" => "" end
+                    end |> Dict
+                    push!(newstyles,
+                          (nextind(content, i + offset),
+                           Pair{Symbol, Any}(:face, convert(Face, spec))))
+                    if isnothing(peek(s)) || last(popfirst!(s)) != ','
+                        properties = false
+                    end
+                else
+                    # Face symbol or key=value pair
+                    key = if isempty(s)
+                        break
+                    elseif last(peek(s)) == '$'
+                        interpolated = true
+                        j, _ = popfirst!(s)
+                        expr, nextj = Meta.parseatom(content, j + 1)
+                        nchars = length(content[j:prevind(content, nextj)])
+                        for _ in 1:min(length(s), nchars-1)
+                            popfirst!(s)
+                        end
+                        if !isempty(s)
+                            _, c = popfirst!(s)
+                            if c == ':'
+                                properties = false
+                            elseif c == '='
+                                hasvalue = true
+                            end
+                        end
+                        expr
+                    else
+                        Iterators.takewhile(
+                            function(c)
+                                if last(c) == ':' # Start of content
+                                    properties = false
+                                elseif last(c) == '=' # Start of value
+                                    hasvalue = true
+                                    false
+                                elseif last(c) == ',' # Next key
+                                    false
+                                else true end
+                            end, s) |> collect .|> last |> String
+                    end
+                    if hasvalue
+                        hasvalue = false
+                        value = if !isnothing(peek(s))
+                            if last(peek(s)) == '{'
+                                # Grab {}-wrapped value
+                                popfirst!(s)
+                                isescaped = false
+                                val = Vector{Char}()
+                                while (next = popfirst!(s)) |> !isnothing
+                                    (_, c) = next
+                                    if isescaped && c ∈ ('\\', '}')
+                                        push!(val, c)
+                                    elseif isescaped
+                                        push!(val, '\\', c)
+                                    elseif c == '}'
+                                        break
+                                    else
+                                        push!(val, c)
+                                    end
+                                end
+                                String(val)
+                            elseif last(peek(s)) == '$'
+                                j, _ = popfirst!(s)
+                                expr, nextj = Meta.parseatom(content, j + 1)
+                                nchars = length(content[j:prevind(content, nextj)])
+                                for _ in 1:min(length(s), nchars-1)
+                                    popfirst!(s)
+                                end
+                                interpolated = true
+                                expr
+                            else
+                                # Grab up to next value, or start of content.
+                                Iterators.takewhile(
+                                    function (c)
+                                        if last(c) == ':'
+                                            properties = false
+                                        elseif last(c) == ','
+                                            false
+                                        else true end
+                                    end, s) |> collect .|> last |> String
+                            end
+                        end
+                        push!(newstyles,
+                              (nextind(content, i + offset),
+                               if key isa String && !(value isa Symbol || value isa Expr)
+                                   Pair{Symbol, Any}(Symbol(key), value)
+                               elseif key isa Expr || key isa Symbol
+                                   :(Pair{Symbol, Any}($key, $value))
+                               else
+                                   :(Pair{Symbol, Any}(
+                                       $(QuoteNode(Symbol(key))), $value))
+                               end))
+                    elseif key !== "" # No value, hence a Face property
+                        push!(newstyles,
+                              (nextind(content, i + offset),
+                               if key isa Symbol || key isa Expr
+                                   :(Pair{Symbol, Any}(:face, $key))
+                               else # Face symbol
+                                   Pair{Symbol, Any}(:face, Symbol(key))
+                               end))
+                    end
+                end
+            end
+            push!(active_styles, newstyles)
+            # Adjust content_bytes/offset based on how much the index
+            # has been incremented in the processing of the
+            # style declaration(s).
+            if !isnothing(peek(s))
+                nexti = first(peek(s))
+                deleteat!(content_bytes, i+offset:nexti+offset-1)
+                offset -= nexti - i
+            end
+        elseif char == '}' && !isempty(active_styles)
+            # Close off most recent active style
+            for (start, prop) in pop!(active_styles)
+                push!(pending_styles, (start:i+offset, prop))
+            end
+            deleteat!(content_bytes, i + offset)
+            offset -= 1
+        end
+    end
+    # Ensure that any trailing unstyled content is added
+    if point <= lastindex(content) + offset
+        addpart(lastindex(content))
+    end
+    if !isempty(active_styles)
+        println(stderr, "WARNING: Styled string macro in module ", __module__,
+                " at ", something(__source__.file, ""), ':', string(__source__.line),
+                " contains unterminated styled constructs.")
+    end
+    if interpolated
+        :(styledstring($(parts...))) |> esc
+    else
+        styledstring(map(eval, parts)...)
+    end
+end

From 13f32f1510d659abff9254c3f50876823cd7993d Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Tue, 2 May 2023 00:45:44 +0800
Subject: [PATCH 0042/1315] Implement styled printing of StyledStrings

Printing StyledStrings is more complicated than using the printstyled
function as a Face supports a much richer set of attributes, and
StyledString allows for attributes to be nested and overlapping.

With the aid of and the newly added terminfo, we can now print a
StyledString in all it's glory, up to the capabilities of the current
terminal, gracefully degrading italic to underline, and 24-bit colors to
8-bit.
---
 base/strings/io.jl | 269 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 269 insertions(+)

diff --git a/base/strings/io.jl b/base/strings/io.jl
index d15bcf412f121..57c1ab1c3dd4e 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -787,3 +787,272 @@ function StyledString(chars::AbstractVector{C}) where {C<:AbstractChar}
     end
     StyledString(str, props)
 end
+
+## Styled printing ##
+
+"""
+A mapping between ANSI named colours and indices in the standard 256-color
+table. The standard colors are 0-7, and high intensity colors 8-15.
+
+The high intensity colors are prefixed by "bright_". The "bright_black" color is
+given two aliases: "grey" and "gray".
+"""
+const ANSI_4BIT_COLORS = Dict{Symbol, Int}(
+    :black => 0,
+    :red => 1,
+    :green => 2,
+    :yellow => 3,
+    :blue => 4,
+    :magenta => 5,
+    :cyan => 6,
+    :white => 7,
+    :bright_black => 8,
+    :grey => 8,
+    :gray => 8,
+    :bright_red => 9,
+    :bright_green => 10,
+    :bright_yellow => 11,
+    :bright_blue => 12,
+    :bright_magenta => 13,
+    :bright_cyan => 14,
+    :bright_white => 15)
+
+"""
+    ansi_4bit_color_code(color::Symbol, background::Bool=false)
+
+Provide the color code (30-37, 40-47, 90-97, 100-107) for `color`, as a string.
+When `background` is set the background variant will be provided, otherwise
+the provided code is for setting the foreground color.
+"""
+function ansi_4bit_color_code(color::Symbol, background::Bool=false)
+    if haskey(ANSI_4BIT_COLORS, color)
+        code = ANSI_4BIT_COLORS[color]
+        code >= 8 && (code += 52)
+        background && (code += 10)
+        string(code + 30)
+    else
+        ifelse(background, "49", "39")
+    end
+end
+
+"""
+    termcolor8bit(io::IO, color::RGBTuple, category::Char)
+
+Print to `io` the best 8-bit SGR color code that sets the `category` color to
+be close to `color`.
+"""
+function termcolor8bit(io::IO, (; r, g, b)::RGBTuple, category::Char)
+    # Magic numbers? Lots.
+    cdistsq(r1, g1, b1) = (r1 - r)^2 + (g1 - g)^2 + (b1 - b)^2
+    to6cube(value) = if value < 48; 1
+    elseif value < 114; 2
+    else 1 + (value - 35) ÷ 40 end
+    r6cube, g6cube, b6cube = to6cube(r), to6cube(g), to6cube(b)
+    sixcube = (0, 95, 135, 175, 215, 255)
+    rnear, gnear, bnear = sixcube[r6cube], sixcube[g6cube], sixcube[b6cube]
+    colorcode = if r == rnear && g == gnear && b == bnear
+        16 + 35 * r6cube + 6 * g6cube + b6cube
+    else
+        grey_avg = Int(r + g + b) ÷ 3
+        grey_index = if grey_avg > 238 23 else (grey_avg - 3) ÷ 10 end
+        grey = 8 + 10 * grey_index
+        if cdistsq(grey, grey, grey) <= cdistsq(rnear, gnear, bnear)
+            232 + grey
+        else
+            16 + 35 * r6cube + 6 * g6cube + b6cube
+        end
+    end
+    print(io, "\e[", category, "8;5;", string(colorcode), 'm')
+end
+
+"""
+    termcolor24bit(io::IO, color::RGBTuple, category::Char)
+
+Print to `io` the 24-bit SGR color code to set the `category`8 slot to `color`.
+"""
+function termcolor24bit(io::IO, color::RGBTuple, category::Char)
+    print(io, "\e[", category, "8;2;",
+          string(color.r), ';',
+          string(color.g), ';',
+          string(color.b), 'm')
+end
+
+"""
+    termcolor(io::IO, color::SimpleColor, category::Char)
+
+Print to `io` the SGR code to set the `category`'s slot to `color`,
+where `category` is set as follows:
+- `'3'` sets the foreground color
+- `'4'` sets the background color
+- `'5'` sets the underline color
+
+If `color` is a `SimpleColor{Symbol}`, the value should be a a member of
+`ANSI_4BIT_COLORS`. Any other value will cause the color to be reset.
+
+If `color` is a `SimpleColor{RGBTuple}` and `get_have_truecolor()` returns true,
+24-bit color is used. Otherwise, an 8-bit approximation of `color` is used.
+"""
+function termcolor(io::IO, color::SimpleColor, category::Char)
+    if color.value isa RGBTuple
+        if get_have_truecolor()
+            termcolor24bit(io, color.value, category)
+        else
+            termcolor8bit(io, color.value, category)
+        end
+    elseif (fg = get(FACES.current[], color.value, getface()).foreground) != SimpleColor(color.value)
+        termcolor(io, fg, category)
+    else
+        print(io, "\e[",
+              if category == '3' || category == '4'
+                  ansi_4bit_color_code(color.value, category == '4')
+              elseif category == '5'
+                  if haskey(ANSI_4BIT_COLORS, color.value)
+                      string("58;5;", ANSI_4BIT_COLORS[color.value])
+                  else "59" end
+              end,
+              'm')
+    end
+end
+
+"""
+    termcolor(io::IO, ::Nothing, category::Char)
+
+Print to `io` the SGR code to reset the color for `category`.
+"""
+termcolor(io::IO, ::Nothing, category::Char) =
+    print(io, "\e[", category, '9', 'm')
+
+const ANSI_STYLE_CODES = (
+    bold_weight = "\e[1m",
+    dim_weight = "\e[2m",
+    normal_weight = "\e[22m",
+    start_italics = "\e[3m",
+    end_italics = "\e[23m",
+    start_underline = "\e[4m",
+    end_underline = "\e[24m",
+    start_reverse = "\e[7m",
+    end_reverse = "\e[27m",
+    start_strikethrough = "\e[9m",
+    end_strikethrough = "\e[29m"
+)
+
+function termstyle(io::IO, face::Face, lastface::Face=getface())
+    face.foreground == lastface.foreground ||
+        termcolor(io, face.foreground, '3')
+    face.background == lastface.background ||
+        termcolor(io, face.background, '4')
+    face.weight == lastface.weight ||
+        print(io, if face.weight ∈ (:medium, :semibold, :bold, :extrabold, :black)
+                  get(current_terminfo, :bold, "\e[1m")
+              elseif face.weight ∈ (:semilight, :light, :extralight, :thin)
+                  get(current_terminfo, :dim, "")
+              else # :normal
+                  ANSI_STYLE_CODES.normal_weight
+              end)
+    face.slant == lastface.slant ||
+        if haskey(current_terminfo, :enter_italics_mode)
+            print(io, ifelse(face.slant ∈ (:italic, :oblique),
+                             ANSI_STYLE_CODES.start_italics,
+                             ANSI_STYLE_CODES.end_italics))
+        elseif face.slant ∈ (:italic, :oblique) && face.underline ∈ (nothing, false)
+            print(io, ANSI_STYLE_CODES.start_underline)
+        elseif face.slant ∉ (:italic, :oblique) && lastface.underline ∈ (nothing, false)
+            print(io, ANSI_STYLE_CODES.end_underline)
+        end
+    # Kitty fancy underlines, see <https://sw.kovidgoyal.net/kitty/underlines>
+    # Supported in Kitty, VTE, iTerm2, Alacritty, and Wezterm.
+    face.underline == lastface.underline ||
+        if get(current_terminfo, :Su, false) # Color/style capabilities
+            if face.underline isa Tuple # Color and style
+                color, style = face.underline
+                print(io, "\e[4:",
+                        if style == :straight;   '1'
+                        elseif style == :double; '2'
+                        elseif style == :curly;  '3'
+                        elseif style == :dotted; '4'
+                        elseif style == :dashed; '5'
+                        else '0' end, 'm')
+                !isnothing(color) && termcolor(io, color, '5')
+            elseif face.underline isa SimpleColor
+                if !(lastface.underline isa SimpleColor || lastface.underline == true)
+                    print(io, ANSI_STYLE_CODES.start_underline)
+                end
+                termcolor(io, face.underline, '5')
+            else
+                if lastface.underline isa SimpleColor || lastface.underline isa Tuple && first(lastface.underline) isa SimpleColor
+                    termcolor(io, SimpleColor(:none), '5')
+                end
+                print(io, ifelse(face.underline == true,
+                                ANSI_STYLE_CODES.start_underline,
+                                ANSI_STYLE_CODES.end_underline))
+            end
+        else
+            print(io, ifelse(face.underline !== false,
+                             ANSI_STYLE_CODES.start_underline,
+                             ANSI_STYLE_CODES.end_underline))
+        end
+    face.strikethrough == lastface.strikethrough || !haskey(current_terminfo, :smxx) ||
+        print(io, ifelse(face.strikethrough === true,
+                         ANSI_STYLE_CODES.start_strikethrough,
+                         ANSI_STYLE_CODES.end_strikethrough))
+    face.inverse == lastface.inverse || !haskey(current_terminfo, :enter_reverse_mode) ||
+        print(io, ifelse(face.inverse === true,
+                         ANSI_STYLE_CODES.start_reverse,
+                         ANSI_STYLE_CODES.end_reverse))
+end
+
+function _ansi_writer(io::IO, s::Union{<:StyledString, SubString{<:StyledString}},
+                      string_writer::Function)
+    if get(io, :color, false)::Bool
+        for (str, styles) in eachstyle(s)
+            face = getface(styles)
+            link = let idx=findfirst(==(:link) ∘ first, styles)
+                if !isnothing(idx)
+                    string(last(styles[idx]))::String
+                end end
+            !isnothing(link) && write(io, "\e]8;;", link, "\e\\")
+            termstyle(io, face, lastface)
+            string_writer(io, str)
+            !isnothing(link) && write(io, "\e]8;;\e\\")
+            lastface = face
+        end
+        termstyle(io, getface(), lastface)
+    elseif s isa StyledString
+        string_writer(io, s.string)
+    elseif s isa SubString
+        string_writer(
+            io, SubString(s.string.string, s.offset, s.ncodeunits, Val(:noshift)))
+    end
+end
+
+write(io::IO, s::Union{<:StyledString, SubString{<:StyledString}}) =
+    _ansi_writer(io, s, write)
+
+print(io::IO, s::Union{<:StyledString, SubString{<:StyledString}}) =
+    (write(io, s); nothing)
+
+escape_string(io::IO, s::Union{<:StyledString, SubString{<:StyledString}},
+              esc = ""; keep = ()) =
+    (_ansi_writer(io, s, (io, s) -> escape_string(io, s, esc; keep)); nothing)
+
+function write(io::IO, c::StyledChar)
+    if get(io, :color, false) == true
+        termstyle(io, getface(c), getface())
+        print(io, c.char)
+        termstyle(io, getface(), getface(c))
+    else
+        print(io, c.char)
+    end
+end
+
+print(io::IO, c::StyledChar) = (write(io, c); nothing)
+
+function show(io::IO, c::StyledChar)
+    if get(io, :color, false) == true
+        out = IOBuffer()
+        show(out, c.char)
+        print(io, ''', StyledString(String(take!(out)[2:end-1]), c.properties), ''')
+    else
+        show(io, c.char)
+    end
+end

From ea24b5371368047dcaa11ebbcbdf64cd6eee6174 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Tue, 2 May 2023 18:28:13 +0800
Subject: [PATCH 0043/1315] Buffer styled printing

When printing directly to stdout, there is a non-negligible overhead
compared to simply printing to an IOBuffer. Testing indicates 3
allocations per print argument, and benchmarks reveal a ~2x increase in
allocations overall and much as a 10x increase in execution time.

Thus, it seems worthwhile to use a temporary buffer in all cases.
---
 base/strings/io.jl | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/base/strings/io.jl b/base/strings/io.jl
index 57c1ab1c3dd4e..446d44398128a 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -1004,19 +1004,22 @@ end
 function _ansi_writer(io::IO, s::Union{<:StyledString, SubString{<:StyledString}},
                       string_writer::Function)
     if get(io, :color, false)::Bool
+        buf = IOBuffer() # Avoid the overhead in repeatadly printing to `stdout`
+        lastface::Face = FACES.current[][:default]
         for (str, styles) in eachstyle(s)
             face = getface(styles)
             link = let idx=findfirst(==(:link) ∘ first, styles)
                 if !isnothing(idx)
                     string(last(styles[idx]))::String
                 end end
-            !isnothing(link) && write(io, "\e]8;;", link, "\e\\")
-            termstyle(io, face, lastface)
-            string_writer(io, str)
-            !isnothing(link) && write(io, "\e]8;;\e\\")
+            !isnothing(link) && write(buf, "\e]8;;", link, "\e\\")
+            termstyle(buf, face, lastface)
+            string_writer(buf, str)
+            !isnothing(link) && write(buf, "\e]8;;\e\\")
             lastface = face
         end
-        termstyle(io, getface(), lastface)
+        termstyle(buf, getface(), lastface)
+        write(io, take!(buf))
     elseif s isa StyledString
         string_writer(io, s.string)
     elseif s isa SubString

From 98e9af49325ce27560fbb50c607e27b06d192f23 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 18 May 2023 19:07:57 +0800
Subject: [PATCH 0044/1315] Add text/html show method for styled strings

---
 base/strings/io.jl | 175 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 175 insertions(+)

diff --git a/base/strings/io.jl b/base/strings/io.jl
index 446d44398128a..8f1ae565243dd 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -1059,3 +1059,178 @@ function show(io::IO, c::StyledChar)
         show(io, c.char)
     end
 end
+
+"""
+A mapping between ANSI named colors and 8-bit colors for use in HTML
+representations.
+"""
+const HTML_BASIC_COLORS = Dict{Symbol, SimpleColor}(
+    :black => SimpleColor(0x00, 0x00, 0x00),
+    :red => SimpleColor(0x80, 0x00, 0x00),
+    :green => SimpleColor(0x00, 0x80, 0x00),
+    :yellow => SimpleColor(0x80, 0x80, 0x00),
+    :blue => SimpleColor(0x00, 0x00, 0x80),
+    :magenta => SimpleColor(0x80, 0x00, 0x80),
+    :cyan => SimpleColor(0x00, 0x80, 0x80),
+    :white => SimpleColor(0xc0, 0xc0, 0xc0),
+    :bright_black => SimpleColor(0x80, 0x80, 0x80),
+    :grey => SimpleColor(0x80, 0x80, 0x80),
+    :gray => SimpleColor(0x80, 0x80, 0x80),
+    :bright_red => SimpleColor(0xff, 0x00, 0x00),
+    :bright_green => SimpleColor(0x00, 0xff, 0x00),
+    :bright_yellow => SimpleColor(0xff, 0xff, 0x00),
+    :bright_blue => SimpleColor(0x00, 0x00, 0xff),
+    :bright_magenta => SimpleColor(0xff, 0x00, 0xff),
+    :bright_cyan => SimpleColor(0x00, 0xff, 0xff),
+    :bright_white => SimpleColor(0xff, 0xff, 0xff))
+
+function htmlcolor(io::IO, color::SimpleColor)
+    if color.value isa Symbol
+        if color.value === :default
+            print(io, "initial")
+        elseif (fg = get(FACES.current[], color.value, getface()).foreground) != SimpleColor(color.value)
+            htmlcolor(io, fg)
+        else
+            htmlcolor(io, get(HTML_BASIC_COLORS, color.value, SimpleColor(:default)))
+        end
+    else
+        (; r, g, b) = color.value
+        print(io, '#')
+        r < 0x10 && print(io, '0')
+        print(io, string(r, base=16))
+        g < 0x10 && print(io, '0')
+        print(io, string(g, base=16))
+        b < 0x10 && print(io, '0')
+        print(io, string(b, base=16))
+    end
+end
+
+const HTML_WEIGHT_MAP = Dict{Symbol, Int}(
+    :thin => 100,
+    :extralight => 200,
+    :light => 300,
+    :semilight => 300,
+    :normal => 400,
+    :medium => 500,
+    :semibold => 600,
+    :bold => 700,
+    :extrabold => 800,
+    :black => 900)
+
+function htmlstyle(io::IO, face::Face, lastface::Face=getface())
+    print(io, "<span style=\"")
+    face.font == lastface.font ||
+        print(io, "font-family: \"",
+              replace(face.font, '"' => "&quot;", ''' => "&#39;"), '"')
+    face.height == lastface.height ||
+        print(io, "font-size: ", string(face.height ÷ 10), "pt;")
+    face.weight == lastface.weight ||
+        print(io, "font-weight: ", get(HTML_WEIGHT_MAP, face.weight, 400), ';')
+    face.slant == lastface.slant ||
+        print(io, "font-style: ", String(face.slant), ';')
+    foreground, background =
+        ifelse(face.inverse === true,
+               (face.background, face.foreground),
+               (face.foreground, face.background))
+    lastforeground, lastbackground =
+        ifelse(lastface.inverse === true,
+               (lastface.background, lastface.foreground),
+               (lastface.foreground, lastface.background))
+    if foreground != lastforeground
+        print(io, "color: ")
+        htmlcolor(io, foreground)
+        print(io, ';')
+    end
+    if background != lastbackground
+        print(io, "background-color: ")
+        htmlcolor(io, background)
+        print(io, ';')
+    end
+    face.underline == lastface.underline ||
+        if face.underline isa Tuple # Color and style
+            color, style = face.underline
+            print(io, "text-decoration: ")
+            if !isnothing(color)
+                htmlcolor(io, color)
+                print(io, ' ')
+            end
+            print(io, if style == :straight "solid  "
+                  elseif style == :double   "double "
+                  elseif style == :curly    "wavy   "
+                  elseif style == :dotted   "dotted "
+                  elseif style == :dashed   "dashed "
+                  else "" end)
+            print(io, "underline;")
+        elseif face.underline isa SimpleColor
+            print(io, "text-decoration: ")
+            htmlcolor(io, face.underline)
+            if lastface.underline isa Tuple && last(lastface.underline) != :straight
+                print(io, " solid")
+            end
+            print(io, " underline;")
+        else # must be a Bool
+            print(io, "text-decoration: ")
+            if lastface.underline isa SimpleColor
+                print(io, "currentcolor ")
+            elseif lastface.underline isa Tuple
+                first(lastface.underline) isa SimpleColor &&
+                    print(io, "currentcolor ")
+                last(lastface.underline) != :straight &&
+                    print(io, "straight ")
+            end
+            print(io, ifelse(face.underline, "underline;", "none;"))
+        end
+    face.strikethrough == lastface.strikethrough ||
+        print(io, ifelse(face.strikethrough,
+                         "text-decoration: line-through",
+                         ifelse(face.underline === false,
+                                "text-decoration: none", "")))
+    print(io, "\">")
+end
+
+function show(io::IO, ::MIME"text/html", s::Union{<:StyledString, SubString{<:StyledString}}; wrap::Symbol=:pre)
+    htmlescape(str) = replace(str, '&' => "&amp;", '<' => "&lt;", '>' => "&gt;")
+    buf = IOBuffer() # Avoid potential overhead in repeatadly printing a more complex IO
+    wrap == :none ||
+        print(buf, '<', String(wrap), '>')
+    lastface::Face = getface()
+    stylestackdepth = 0
+    for (str, styles) in eachstyle(s)
+        face = getface(styles)
+        link = let idx=findfirst(==(:link) ∘ first, styles)
+            if !isnothing(idx)
+                string(last(styles[idx]))::String
+            end end
+        !isnothing(link) && print(buf, "<a href=\"", link, "\">")
+        if face == getface()
+            print(buf, "</span>" ^ stylestackdepth)
+            stylestackdepth = 0
+        elseif (lastface.inverse, lastface.foreground, lastface.background) !=
+            (face.inverse, face.foreground, face.background)
+            # We can't un-inherit colors well, so we just need to reset and apply
+            print(buf, "</span>" ^ stylestackdepth)
+            htmlstyle(buf, face, getface())
+            stylestackdepth = 1
+        else
+            htmlstyle(buf, face, lastface)
+            stylestackdepth += 1
+        end
+        if wrap == :p
+            newpara = false
+            for para in eachsplit(str, "\n\n")
+                newpara && print(buf, "</p>\n<p>")
+                print(buf, htmlescape(para))
+                newpara = true
+            end
+        else
+            print(buf, htmlescape(str))
+        end
+        !isnothing(link) && print(buf, "</a>")
+        lastface = face
+    end
+    print(buf, "</span>" ^ stylestackdepth)
+    wrap == :none ||
+        print(buf, "</", String(wrap), '>')
+    write(io, take!(buf))
+    nothing
+end

From c214350944bfdb1e1dc9048cce8a3b1e393b28f4 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sun, 3 Sep 2023 17:19:03 +0800
Subject: [PATCH 0045/1315] Custom show methods for faces and simplecolor

This is just nicer to look at in the REPL
---
 base/strings/faces.jl | 93 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/base/strings/faces.jl b/base/strings/faces.jl
index 69f5d43a6aa8e..2ca44a05ec85e 100644
--- a/base/strings/faces.jl
+++ b/base/strings/faces.jl
@@ -164,6 +164,99 @@ end
     getfield.(Ref(a), fieldnames(Face)) ==
     getfield.(Ref(b), fieldnames(Face))
 
+function show(io::IO, ::MIME"text/plain", color::SimpleColor)
+    skiptype = get(io, :typeinfo, nothing) === SimpleColor
+    skiptype || show(io, SimpleColor)
+    skiptype || print(io, '(')
+    if get(io, :color, false)::Bool
+        print(io, StyledString("■", :face => Face(foreground=color)), ' ')
+    end
+    if color.value isa Symbol
+        print(io, color.value)
+    else # rgb tuple
+        print(io, '#', join(lpad.(string.(values(color.value), base=16), 2, '0')))
+    end
+    skiptype || print(io, ')')
+    nothing
+end
+
+function show(io::IO, ::MIME"text/plain", face::Face)
+    if get(io, :compact, false)::Bool
+        show(io, Face)
+        if get(io, :color, false)::Bool
+            # Could do S"({$face:sample})", but S_str isn't defined yet
+            print(io, StyledString("(sample)", [(2:7, :face => face)]))
+        else
+            print(io, '(')
+            isfirst = true
+            for field in setdiff(fieldnames(Face), (:inherit,))
+                if !isnothing(getfield(face, field))
+                    if isfirst; isfirst = false else print(io, ", ") end
+                    print(io, field, '=')
+                    show(io, getfield(face, field))
+                end
+            end
+            if !isempty(face.inherit)
+                if isfirst; isfirst = false else print(io, ", ") end
+                print(io, "inherit=")
+                show(IOContext(io, :typeinfo => Vector{Symbol}), face.inherit)
+            end
+            print(io, ')')
+        end
+    else
+        show(io, Face)
+        print(io, StyledString(" (sample)", [(3:8, :face => face)]))
+        showcolor(io, color) = show(IOContext(io, :typeinfo => SimpleColor),
+                                    MIME("text/plain"), color)
+        setfields = Pair{Symbol, Any}[]
+        isempty(setfields) || print(io, ":")
+        fieldnamepad = 14
+        for field in (:font, :height, :weight, :slant)
+            if !isnothing(getfield(face, field))
+                print(io, '\n', lpad(String(field), fieldnamepad, ' '), ": ",
+                      getfield(face, field))
+            end
+        end
+        for field in (:foreground, :background)
+            if !isnothing(getfield(face, field))
+                print(io, '\n', lpad(String(field), fieldnamepad, ' '), ": ")
+                showcolor(io, getfield(face, field))
+            end
+        end
+        if !isnothing(face.underline)
+            print(io, '\n', lpad("underline", fieldnamepad, ' '), ": ")
+            if face.underline isa Bool
+                print(io, face.underline)
+            elseif face.underline isa SimpleColor
+                showcolor(io, face.underline)
+            elseif face.underline isa Tuple{Nothing, Symbol}
+                print(io, last(face.underline))
+            elseif face.underline isa Tuple{SimpleColor, Symbol}
+                showcolor(io, first(face.underline))
+                print(io, ", ", last(face.underline))
+            end
+        end
+        for field in (:strikethrough, :inverse)
+            if !isnothing(getfield(face, field))
+                print(io, '\n', lpad(String(field), fieldnamepad, ' '), ": ",
+                      getfield(face, field))
+            end
+        end
+        if !isempty(face.inherit)
+            print(io, '\n', lpad("inherit", fieldnamepad, ' '), ": ")
+            isfirst = true
+            for iface in face.inherit
+                if isfirst; isfirst = false else print(io, ", ") end
+                print(io, iface, '(', StyledString("*", :face => iface), ')')
+            end
+        end
+    end
+end
+
+function show(io::IO, face::Face)
+    show(IOContext(io, :compact => true), MIME("text/plain"), face)
+end
+
 """
 Globally named [`Face`](@ref)s.
 

From 96e3d6bbab80eaaef8ec087d6b962bc522c2b5cc Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Mon, 4 Sep 2023 21:59:54 +0800
Subject: [PATCH 0046/1315] Load terminfo during exec_options

This way should any styled printing occur, regardless of whether a REPL
session is started, it will be handled correctly based on the current
terminal.
---
 base/client.jl | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/base/client.jl b/base/client.jl
index ac7fabe19a458..aa02e48cd47d8 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -271,6 +271,10 @@ function exec_options(opts)
     interactiveinput = (repl || is_interactive::Bool) && isa(stdin, TTY)
     is_interactive::Bool |= interactiveinput
 
+    # load terminfo in for styled printing
+    term_env = get(ENV, "TERM", @static Sys.iswindows() ? "" : "dumb")
+    global current_terminfo = load_terminfo(term_env)
+
     # load ~/.julia/config/startup.jl file
     if startup
         try
@@ -435,7 +439,6 @@ function run_main_repl(interactive::Bool, quiet::Bool, banner::Symbol, history_f
     if !fallback_repl && interactive && isassigned(REPL_MODULE_REF)
         invokelatest(REPL_MODULE_REF[]) do REPL
             term_env = get(ENV, "TERM", @static Sys.iswindows() ? "" : "dumb")
-            global current_terminfo = load_terminfo(term_env)
             term = REPL.Terminals.TTYTerminal(term_env, stdin, stdout, stderr)
             banner == :no || Base.banner(term, short=banner==:short)
             if term.term_type == "dumb"

From 4a9128d6b8db5fe4473d3d422e76f25068df5b4d Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sat, 9 Sep 2023 20:25:44 +0800
Subject: [PATCH 0047/1315] Overhaul S"" macro
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous S"" macro was essentially one giant for loop with a helper
function.  When adding support for inline face value interpolation, it
was clear that that approach was unmaintainable.  As a result, the
implementation has been completely rewritten.  The new S"" macro is more
maintainable, featureful, and correct — now with a documented EBNF
grammar and more validation during expansion.
---
 base/strings/faces.jl | 720 +++++++++++++++++++++++++++++++-----------
 1 file changed, 528 insertions(+), 192 deletions(-)

diff --git a/base/strings/faces.jl b/base/strings/faces.jl
index 2ca44a05ec85e..c48fbca7f68fb 100644
--- a/base/strings/faces.jl
+++ b/base/strings/faces.jl
@@ -674,235 +674,571 @@ interpolated with `\$`.
 S"The {bold:{italic:quick} {(foreground=#cd853f):brown} fox} jumped over \
 the {link={https://en.wikipedia.org/wiki/Laziness}:lazy} dog"
 ```
+
+# Extended help
+
+This macro can be described by the following EBNF grammar:
+
+```ebnf
+styledstring = { styled | interpolated | escaped | plain } ;
+
+specialchar = '{' | '}' | '\$' | '\\\"' ;
+anychar = [\u0-\u1fffff] ;
+plain = { anychar - specialchar } ;
+escaped = '\\\\', specialchar ;
+
+interpolated = '\$', ? expr ? | '\$(', ? expr ?, ')' ;
+
+styled = '{', ws, properties, ':', content, '}' ;
+content = { interpolated | escaped | plain | styled } ;
+properties = property | properties, ws, ',', ws, property
+property = face | inlineface | keyvalue ;
+ws = { ' ' | '\\t' | '\\n' } ; (* whitespace *)
+
+face = facename | interpolated ;
+facename = [A-Za-z0-9_]+ ;
+
+inlineface = '(', ws, [ faceprop ], { ws, ',', faceprop }, ws, ')' ;
+faceprop = [a-z]+, ws, '=', ws, ( [^,)]+ | interpolated) ;
+
+keyvalue = key, ws, '=', ws, value ;
+key = ( [^\${}=,:], [^=,:]* ) | interpolated ;
+value = simplevalue | curlybraced | interpolated ;
+curlybraced = '{' { escaped | plain } '}' ;
+simplevalue = [^\${},:], [^,:]* ;
+```
+
+The above grammar for `inlineface` is simplified, as the actual implementation
+is a bit more sophisticated. The full behaviour is given below.
+
+```ebnf
+faceprop = ( 'face', ws, '=', ws, ( ? string ? | interpolated ) ) |
+           ( 'height', ws, '=', ws, ( ? number ? | interpolated ) ) |
+           ( 'weight', ws, '=', ws, ( symbol | interpolated ) ) |
+           ( 'slant', ws, '=', ws, ( symbol | interpolated ) ) |
+           ( ( 'foreground' | 'fg' | 'background' | 'bg' ),
+               ws, '=', ws, ( simplecolor | interpolated ) ) |
+           ( 'underline', ws, '=', ws, ( underline | interpolated ) ) |
+           ( 'strikethrough', ws, '=', ws, ( bool | interpolated ) ) |
+           ( 'inverse', ws, '=', ws, ( bool | interpolated ) ) |
+           ( 'inherit', ws, '=', ws, ( inherit | interpolated ) ) ;
+
+nothing = 'nothing' ;
+bool = 'true' | 'false' ;
+symbol = [^ ,)]+ ;
+hexcolor = ('#' | '0x'), [0-9a-f]{6} ;
+simplecolor = hexcolor | symbol | nothing ;
+
+underline = nothing | bool | simplecolor | underlinestyled;
+underlinestyled = '(', whitespace, ('' | nothing | simplecolor), whitespace,
+                  ',', whitespace, symbol, whitespace ')' ;
+
+inherit = ( '[', inheritval, { ',', inheritval }, ']' ) | inheritval;
+inheritval = whitespace, ':'?, symbol ;
+```
 """
 macro S_str(raw_content::String)
-    parts = Any[]
-    content = unescape_string(raw_content, ('{', '}', '$', '\n'))
-    content_bytes = Vector{UInt8}(content)
-    s = Iterators.Stateful(zip(eachindex(content), content))
-    offset = 0
-    point = 1
-    escape = false
-    active_styles = Vector{Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}}()
-    pending_styles = Vector{Tuple{UnitRange{Int}, Union{Symbol, Expr, Pair{Symbol, Any}}}}()
-    interpolated = false
-    function addpart(stop::Int)
-        str = String(content_bytes[point:stop+offset+ncodeunits(content[stop])-1])
-        push!(parts,
-              if isempty(pending_styles) && isempty(active_styles)
+    #------------------
+    # Helper functions
+    #------------------
+
+    # If this were a module, I'd define the following struct.
+
+    #= struct State
+    content::String         # the (unescaped) input string
+    bytes::Vector{UInt8}    # bytes of `content`
+    s::Iterators.Stateful   # (index, char) interator of `content`
+    parts::Vector{Any}      # the final result
+    active_styles::Vector{  # unterminated batches of styles
+    Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}}
+    pending_styles::Vector{ # terminated styles that have yet to be applied
+    Tuple{UnitRange{Int}, Union{Symbol, Expr, Pair{Symbol, Any}}}}
+    offset::Ref{Int}        # drift in the `content` index as structures are absorbed
+    point::Ref{Int}         # current index in `content`
+    escape::Ref{Bool}       # whether the last char was an escape char
+    interpolated::Ref{Bool} # whether any string interpolation occurs
+    end =#
+
+    # Instead we'll just use a `NamedTuple`
+    state = let content = unescape_string(raw_content, ('{', '}', '$', '\n'))
+        (; content, bytes = Vector{UInt8}(content),
+         s = Iterators.Stateful(zip(eachindex(content), content)),
+         parts = Any[],
+         active_styles = Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}[],
+         pending_styles = Tuple{UnitRange{Int}, Union{Symbol, Expr, Pair{Symbol, Any}}}[],
+         offset = Ref(0), point = Ref(1), escape = Ref(false), interpolated = Ref(false))
+    end
+
+    # Value restrictions we can check against
+    valid_weights = ("thin", "extralight", "light", "semilight", "normal",
+                     "medium", "semibold", "bold", "extrabold", "black")
+    valid_slants = ("italic", "oblique", "normal")
+    valid_underline_styles = ("straight", "double", "curly", "dotted", "dashed")
+    valid_colornames =
+        ("black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
+         "grey", "gray", "bright_black", "bright_red", "bright_green", "bright_yellow",
+         "bright_blue", "bright_magenta", "bright_cyan", "bright_white")
+
+    function stywarn(state, message::String)
+        println(stderr, "WARNING: Styled string macro in module ", __module__,
+                " at ", something(__source__.file, ""),
+                ':', string(__source__.line),
+                something(if !isempty(state.s)
+                              i, chr = peek(state.s)
+                              " (just before '$chr' [$i])"
+                          end, ""),
+                ", ", message, '.')
+    end
+
+    function addpart!(state, stop::Int)
+        if state.point[] > stop+state.offset[]+ncodeunits(state.content[stop])-1
+            return state.point[] = nextind(state.content, stop) + state.offset[]
+        end
+        str = String(state.bytes[
+            state.point[]:stop+state.offset[]+ncodeunits(state.content[stop])-1])
+        push!(state.parts,
+              if isempty(state.pending_styles) && isempty(state.active_styles)
                   str
               else
                   styles = Expr[]
                   relevant_styles = Iterators.filter(
-                      (start, _)::Tuple -> start <= stop + offset + 1,
-                      Iterators.flatten(active_styles))
+                      (start, _)::Tuple -> start <= stop + state.offset[] + 1,
+                      Iterators.flatten(state.active_styles))
                   for (start, prop) in relevant_styles
-                      range = (start - point):(stop - point + offset + 1)
+                      range = (start - state.point[]):(stop - state.point[] + state.offset[] + 1)
                       push!(styles, Expr(:tuple, range, prop))
                   end
-                  for (range, prop) in pending_styles
+                  sort!(state.pending_styles, by = first)
+                  for (range, prop) in state.pending_styles
                       if !isempty(range)
-                          push!(styles, Expr(:tuple, range .- point, prop))
+                          push!(styles, Expr(:tuple, range .- state.point[], prop))
                       end
                   end
-                  empty!(pending_styles)
+                  empty!(state.pending_styles)
                   if isempty(styles)
                       str
                   else
-                      :(StyledString($str, $(Expr(:vect, styles...))))
+                      :($StyledString($str, $(Expr(:vect, styles...))))
                   end
               end)
-        point = nextind(content, stop) + offset
+        state.point[] = nextind(state.content, stop) + state.offset[]
     end
-    function addpart(start::Int, expr, stop::Int)
-        if point < start
-            addpart(start)
+
+    function addpart!(state, start::Int, expr, stop::Int)
+        if state.point[] < start
+            addpart!(state, start)
         end
-        if isempty(active_styles)
-            push!(parts, expr)
+        if isempty(state.active_styles)
+            push!(state.parts, expr)
         else
-            push!(parts,
-                  :(StyledString(string($expr),
-                                 $(last.(Iterators.flatten(active_styles))...))))
-            map!.((_, prop)::Tuple -> (nextind(content, stop + offset), prop), active_styles, active_styles)
+            push!(state.parts,
+                  :($StyledString(string($expr),
+                                  $(last.(Iterators.flatten(state.active_styles))...))))
+            map!.((_, prop)::Tuple -> (stop + state.offset[] + 1, prop),
+                  state.active_styles, state.active_styles)
+        end
+    end
+
+    function escaped!(state, i, char)
+        if char in ('{', '}', '$', '\\')
+            deleteat!(state.bytes, i + state.offset[] - 1)
+            state.offset[] -= ncodeunits('\\')
+        elseif char == '\n'
+            deleteat!(state.bytes, i+state.offset[]-1:i+state.offset[])
+            state.offset[] -= ncodeunits("\\\n")
         end
+        state.escape[] = false
+    end
+
+    function interpolated!(state, i, _)
+        expr, nexti = readexpr!(state, i + ncodeunits('$'))
+        deleteat!(state.bytes, i + state.offset[])
+        state.offset[] -= ncodeunits('$')
+        addpart!(state, i, expr, nexti)
+        state.point[] = nexti + state.offset[]
+        state.interpolated[] = true
     end
-    for (i, char) in s
-        if char == '\\'
-            escape = true
-        elseif escape
-            if char in ('{', '}', '$')
-                deleteat!(content_bytes, i + offset - 1)
-                offset -= 1
-            elseif char == '\n'
-                deleteat!(content_bytes, i+offset-1:i+offset)
-                offset -= 2
+
+    function readexpr!(state, pos::Int)
+        expr, nextpos = Meta.parseatom(state.content, pos)
+        nchars = length(state.content[pos:prevind(state.content, nextpos)])
+        for _ in 1:min(length(state.s), nchars)
+            popfirst!(state.s)
+        end
+        expr, nextpos
+    end
+
+    readexpr!(state) = readexpr!(state, first(popfirst!(state.s)) + 1)
+
+    function skipwhitespace!(state)
+        isempty(state.s) && return
+        while last(peek(state.s)) ∈ (' ', '\t', '\n')
+            popfirst!(state.s)
+        end
+    end
+
+    function begin_style!(state, i, char)
+        hasvalue = false
+        newstyles = Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}()
+        while read_property!(state, i, char, newstyles) end
+        push!(state.active_styles, newstyles)
+        # Adjust bytes/offset based on how much the index
+        # has been incremented in the processing of the
+        # style declaration(s).
+        if !isempty(state.s)
+            nexti = first(peek(state.s))
+            deleteat!(state.bytes, i+state.offset[]:nexti+state.offset[]-1)
+            state.offset[] -= nexti - i
+        end
+    end
+
+    function end_style!(state, i, char)
+        # Close off most recent active style
+        for (start, prop) in pop!(state.active_styles)
+            push!(state.pending_styles, (start:i+state.offset[], prop))
+        end
+        deleteat!(state.bytes, i + state.offset[])
+        state.offset[] -= ncodeunits('}')
+    end
+
+    function read_property!(state, i, char, newstyles)
+        skipwhitespace!(state)
+        isempty(state.s) && return false
+        nextchar = last(peek(state.s))
+        if nextchar == ':'
+            popfirst!(state.s)
+            return false
+        elseif nextchar == '('
+            read_inlineface!(state, i, char, newstyles)
+        else
+            read_face_or_keyval!(state, i, char, newstyles)
+        end
+        isempty(state.s) && return false
+        nextchar = last(peek(state.s))
+        if nextchar == ','
+            popfirst!(state.s)
+            true
+        elseif nextchar == ':'
+            true
+        elseif nextchar ∈ (' ', '\t', '\n')
+            skipwhitespace!(state)
+            true
+        else
+            stywarn(state, "malformed styled string construct")
+            false
+        end
+    end
+
+    function read_inlineface!(state, i, char, newstyles)
+        # Substructure parsing helper functions
+        function readalph!(state, lastchar)
+            Iterators.takewhile(
+                c -> 'a' <= (lastchar = last(c)) <= 'z', state.s) |>
+                    collect .|> last |> String, lastchar
+        end
+        function readsymbol!(state, lastchar)
+            Iterators.takewhile(
+                c -> (lastchar = last(c)) ∉ (' ', '\t', '\n', ',', ')'), state.s) |>
+                    collect .|> last |> String, lastchar
+        end
+        function parsecolor(color::String)
+            if color == "nothing"
+            elseif startswith(color, '#') && length(color) == 7
+                tryparse(SimpleColor, color)
+            elseif startswith(color, "0x") && length(color) == 8
+                tryparse(SimpleColor, '#' * color[3:end])
+            else
+                color ∈ valid_colornames ||
+                    stywarn(state, "unrecognised named color '$color' (should be $(join(valid_colornames, ", ", ", or ")))")
+                SimpleColor(Symbol(color))
             end
-            escape = false
-        elseif char == '$'
-            # Interpolation
-            expr, nexti = Meta.parseatom(content, i + 1)
-            deleteat!(content_bytes, i + offset)
-            offset -= 1
-            nchars = length(content[i:prevind(content, nexti)])
-            for _ in 1:min(length(s), nchars-1)
-                popfirst!(s)
+        end
+        function nextnonwhitespace!(state, lastchar)
+            if lastchar ∈ (' ', '\t', '\n')
+                skipwhitespace!(state)
+                _, lastchar = popfirst!(state.s)
             end
-            addpart(i, expr, nexti)
-            point = nexti + offset
-            interpolated = true
-        elseif char == '{'
-            # Property declaration parsing and application
-            properties = true
-            hasvalue = false
-            newstyles = Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}()
-            while properties
-                if !isnothing(peek(s)) && last(peek(s)) == '('
-                    # Inline face
-                    popfirst!(s)
-                    specstr = Iterators.takewhile(c -> last(c) != ')', s) |>
-                        collect .|> last |> String
-                    spec = map(split(specstr, ',')) do spec
-                        spec = rstrip(spec)
-                        kv = split(spec, '=', limit=2)
-                        if length(kv) == 2
-                            kv[1] => @something(tryparse(Bool, kv[2]),
-                                                String(kv[2]))
-                        else "" => "" end
-                    end |> Dict
-                    push!(newstyles,
-                          (nextind(content, i + offset),
-                           Pair{Symbol, Any}(:face, convert(Face, spec))))
-                    if isnothing(peek(s)) || last(popfirst!(s)) != ','
-                        properties = false
+            lastchar
+        end
+        function read_underline!(state, lastchar)
+            if last(peek(state.s)) == '('
+                popfirst!(state.s)
+                skipwhitespace!(state)
+                ucolor_str, ucolor = if last(peek(state.s)) == ','
+                    lastchar = last(popfirst!(state.s))
+                    "", nothing
+                else
+                    word, lastchar = readsymbol!(state, lastchar)
+                    word, parsecolor(word)
+                end
+                lastchar = nextnonwhitespace!(state, lastchar)
+                if !isempty(state) && lastchar == ','
+                    skipwhitespace!(state)
+                    ustyle, lastchar = readalph!(state, lastchar)
+                    lastchar = nextnonwhitespace!(state, lastchar)
+                    if lastchar == ')'
+                        lastchar = last(popfirst!(state.s))
+                    else
+                        stywarn(state, "malformed underline value, should be (<color>, <style>)")
                     end
                 else
-                    # Face symbol or key=value pair
-                    key = if isempty(s)
+                    stywarn(state, "malformed underline value, should be (<color>, <style>)")
+                    ustyle = "straight"
+                end
+                ustyle ∈ valid_underline_styles ||
+                    stywarn(state, "unrecognised underline style '$ustyle' (should be $(join(valid_underline_styles, ", ", ", or ")))")
+                Expr(:tuple, ucolor, QuoteNode(Symbol(ustyle)))
+            else
+                word, lastchar = readsymbol!(state, lastchar)
+                if word ∈ ("", "nothing")
+                elseif word == "true"
+                    true
+                elseif word == "false"
+                    false
+                else
+                    parsecolor(word)
+                end
+            end, lastchar
+        end
+        function read_inherit!(state, lastchar)
+            inherit = Symbol[]
+            if last(peek(state.s)) == ':'
+                popfirst!(state.s)
+                facename, lastchar = readsymbol!(state, lastchar)
+                push!(inherit, Symbol(facename))
+            elseif last(peek(state.s)) == '['
+                popfirst!(state.s)
+                readvec = true
+                while readvec
+                    skipwhitespace!(state)
+                    nextchar = last(peek(state.s))
+                    if nextchar == ':'
+                        popfirst!(state.s)
+                    elseif nextchar == ']'
+                        popfirst!(state.s)
+                        lastchar = last(popfirst!(state.s))
                         break
-                    elseif last(peek(s)) == '$'
-                        interpolated = true
-                        j, _ = popfirst!(s)
-                        expr, nextj = Meta.parseatom(content, j + 1)
-                        nchars = length(content[j:prevind(content, nextj)])
-                        for _ in 1:min(length(s), nchars-1)
-                            popfirst!(s)
-                        end
-                        if !isempty(s)
-                            _, c = popfirst!(s)
-                            if c == ':'
-                                properties = false
-                            elseif c == '='
-                                hasvalue = true
-                            end
-                        end
-                        expr
-                    else
-                        Iterators.takewhile(
-                            function(c)
-                                if last(c) == ':' # Start of content
-                                    properties = false
-                                elseif last(c) == '=' # Start of value
-                                    hasvalue = true
-                                    false
-                                elseif last(c) == ',' # Next key
-                                    false
-                                else true end
-                            end, s) |> collect .|> last |> String
                     end
-                    if hasvalue
-                        hasvalue = false
-                        value = if !isnothing(peek(s))
-                            if last(peek(s)) == '{'
-                                # Grab {}-wrapped value
-                                popfirst!(s)
-                                isescaped = false
-                                val = Vector{Char}()
-                                while (next = popfirst!(s)) |> !isnothing
-                                    (_, c) = next
-                                    if isescaped && c ∈ ('\\', '}')
-                                        push!(val, c)
-                                    elseif isescaped
-                                        push!(val, '\\', c)
-                                    elseif c == '}'
-                                        break
-                                    else
-                                        push!(val, c)
-                                    end
-                                end
-                                String(val)
-                            elseif last(peek(s)) == '$'
-                                j, _ = popfirst!(s)
-                                expr, nextj = Meta.parseatom(content, j + 1)
-                                nchars = length(content[j:prevind(content, nextj)])
-                                for _ in 1:min(length(s), nchars-1)
-                                    popfirst!(s)
-                                end
-                                interpolated = true
-                                expr
-                            else
-                                # Grab up to next value, or start of content.
-                                Iterators.takewhile(
-                                    function (c)
-                                        if last(c) == ':'
-                                            properties = false
-                                        elseif last(c) == ','
-                                            false
-                                        else true end
-                                    end, s) |> collect .|> last |> String
-                            end
-                        end
-                        push!(newstyles,
-                              (nextind(content, i + offset),
-                               if key isa String && !(value isa Symbol || value isa Expr)
-                                   Pair{Symbol, Any}(Symbol(key), value)
-                               elseif key isa Expr || key isa Symbol
-                                   :(Pair{Symbol, Any}($key, $value))
-                               else
-                                   :(Pair{Symbol, Any}(
-                                       $(QuoteNode(Symbol(key))), $value))
-                               end))
-                    elseif key !== "" # No value, hence a Face property
-                        push!(newstyles,
-                              (nextind(content, i + offset),
-                               if key isa Symbol || key isa Expr
-                                   :(Pair{Symbol, Any}(:face, $key))
-                               else # Face symbol
-                                   Pair{Symbol, Any}(:face, Symbol(key))
-                               end))
+                    facename = Iterators.takewhile(
+                        c -> (lastchar = last(c)) ∉ (',', ']', ')'), state.s) |>
+                            collect .|> last |> String
+                    push!(inherit, Symbol(rstrip(facename)))
+                    if lastchar != ','
+                        break
                     end
                 end
+            else
+                facename = Iterators.takewhile(
+                    c -> (lastchar = last(c)) ∉ (',', ']', ')'), state.s) |>
+                        collect .|> last |> String
+                push!(inherit, Symbol(rstrip(facename)))
             end
-            push!(active_styles, newstyles)
-            # Adjust content_bytes/offset based on how much the index
-            # has been incremented in the processing of the
-            # style declaration(s).
-            if !isnothing(peek(s))
-                nexti = first(peek(s))
-                deleteat!(content_bytes, i+offset:nexti+offset-1)
-                offset -= nexti - i
+            inherit, lastchar
+        end
+        # Get on with the parsing now
+        popfirst!(state.s)
+        kwargs = Expr[]
+        needseval = false
+        lastchar = '('
+        while !isempty(state.s) && lastchar != ')'
+            skipwhitespace!(state)
+            str_key, lastchar = readalph!(state, lastchar)
+            key = Symbol(str_key)
+            # Check for '=', and skip over surrounding whitespace
+            if lastchar != '='
+                skipwhitespace!(state)
+                isempty(state.s) && break
+                last(peek(state.s)) == '=' || break
+                popfirst!(state.s)
+            end
+            skipwhitespace!(state)
+            isempty(state.s) && break
+            # Aliases
+            key == :fg && (key = :foreground)
+            key == :bg && (key = :background)
+            # Parse value
+            val = if (nextchar = last(peek(state.s))) == '$'
+                expr, _ = readexpr!(state)
+                lastchar = last(popfirst!(state.s))
+                state.interpolated[] = true
+                needseval = true
+                expr
+            elseif key == :face
+                if nextchar == '"'
+                    first(readexpr!(state, first(peek(state.s))))
+                else
+                    Iterators.takewhile(
+                        c -> (lastchar = last(c)) ∉ (',', ')'), state.s) |>
+                            collect .|> last |> String
+                end
+            elseif key == :height
+                if nextchar == '.' || nextchar ∈ '0':'9'
+                    num = first(readexpr!(state, first(peek(state.s))))
+                    lastchar = last(popfirst!(state.s))
+                    ifelse(num isa Number, num, nothing)
+                else
+                    invalid, lastchar = readsymbol!(state, lastchar)
+                    stywarn(state, "invalid height $invalid, should be a natural number or positive float")
+                end
+            elseif key ∈ (:weight, :slant)
+                v, lastchar = readalph!(state, lastchar)
+                if key == :weight && v ∉ valid_weights
+                    stywarn(state, "unrecognised weight '$v' (should be $(join(valid_weights, ", ", ", or ")))")
+                elseif key == :slant && v ∉ valid_slants
+                    stywarn(state, "unrecognised slant '$v' (should be $(join(valid_slants, ", ", ", or ")))")
+                end
+                Symbol(v) |> QuoteNode
+            elseif key ∈ (:foreground, :background)
+                color, lastchar = readsymbol!(state, lastchar)
+                parsecolor(color)
+            elseif key ∈ (:strikethrough, :inverse)
+                flag, lastchar = readalph!(state, lastchar)
+                if flag == "true"
+                    true
+                elseif flag == "false"
+                    false
+                end
+            elseif key == :underline
+                ul, lastchar = read_underline!(state, lastchar)
+                ul
+            elseif key == :inherit
+                inherit, lastchar = read_inherit!(state, lastchar)
+                inherit
+            else
+                stywarn(state, "uses unrecognised face key '$key'")
             end
-        elseif char == '}' && !isempty(active_styles)
-            # Close off most recent active style
-            for (start, prop) in pop!(active_styles)
-                push!(pending_styles, (start:i+offset, prop))
+            if !any(k -> first(k.args) == key, kwargs)
+                push!(kwargs, Expr(:kw, key, val))
+            else
+                stywarn(state, "contains repeated face key '$key'")
             end
-            deleteat!(content_bytes, i + offset)
-            offset -= 1
+            isempty(state.s) || last(peek(state.s)) != ',' || break
         end
+        face = Expr(:call, Face, kwargs...)
+        push!(newstyles,
+              (i + state.offset[] + 1,
+               if needseval
+                   :(Pair{Symbol, Any}(:face, $face))
+               else
+                   Pair{Symbol, Any}(:face, eval(face))
+               end))
     end
-    # Ensure that any trailing unstyled content is added
-    if point <= lastindex(content) + offset
-        addpart(lastindex(content))
+
+    function read_face_or_keyval!(state, i, char, newstyles)
+        function read_curlywrapped!(state)
+            popfirst!(state.s) # first '{'
+            chars = Char[]
+            escaped = false
+            while !isempty(state.s)
+                _, c = popfirst!(state.s)
+                if escaped && c ∈ ('\\', '{', '}', '$')
+                    push!(chars, c)
+                    escaped = false
+                elseif escaped
+                    push!(chars, '\\', c)
+                    escaped = false
+                elseif c == '\\'
+                    escaped = true
+                elseif c == '}'
+                    break
+                else
+                    push!(chars, c)
+                end
+            end
+            String(chars)
+        end
+        # this isn't the 'last' char yet, but it will be
+        key = if last(peek(state.s)) == '$'
+            expr, _ = readexpr!(state)
+            state.interpolated[] = true
+            needseval = true
+            expr
+        else
+            chars = Char[]
+            while (next = peek(state.s)) |> !isnothing && last(next) ∉ (',', '=', ':')
+                popfirst!(state.s)
+                push!(chars, last(next))
+            end
+            String(chars)
+        end
+        skipwhitespace!(state)
+        if isempty(state.s)
+        elseif last(peek(state.s)) == '='
+            popfirst!(state.s)
+            nextchar = last(peek(state.s))
+            if nextchar ∈ (' ', '\t', '\n')
+                skipwhitespace!(state)
+                nextchar = last(peek(state.s))
+            end
+            value = if isempty(state.s) ""
+            elseif nextchar == '{'
+                read_curlywrapped!(state)
+            elseif nextchar == '$'
+                expr, _ = readexpr!(state)
+                state.interpolated[] = true
+                needseval = true
+                expr
+            else
+                chars = Char[]
+                while (next = peek(state.s)) |> !isnothing && last(next) ∉ (',', ':')
+                    popfirst!(state.s)
+                    push!(chars, last(next))
+                end
+                String(chars)
+            end
+            push!(newstyles,
+                  (i + state.offset[] + ncodeunits('{'),
+                   if key isa String && !(value isa Symbol || value isa Expr)
+                       Pair{Symbol, Any}(Symbol(key), value)
+                   elseif key isa Expr || key isa Symbol
+                       :(Pair{Symbol, Any}($key, $value))
+                   else
+                       :(Pair{Symbol, Any}(
+                           $(QuoteNode(Symbol(key))), $value))
+                   end))
+        elseif key !== ""
+            push!(newstyles,
+                  (i + state.offset[] + ncodeunits('{'),
+                   if key isa Symbol || key isa Expr
+                       :(Pair{Symbol, Any}(:face, $key))
+                   else # Face symbol
+                       Pair{Symbol, Any}(:face, Symbol(key))
+                   end))
+        end
     end
-    if !isempty(active_styles)
-        println(stderr, "WARNING: Styled string macro in module ", __module__,
-                " at ", something(__source__.file, ""), ':', string(__source__.line),
-                " contains unterminated styled constructs.")
+
+    function run_state_machine!(state)
+        # Run the state machine
+        for (i, char) in state.s
+            if char == '\\'
+                state.escape[] = true
+            elseif state.escape[]
+                escaped!(state, i, char)
+            elseif char == '$'
+                interpolated!(state, i, char)
+            elseif char == '{'
+                begin_style!(state, i, char)
+            elseif char == '}' && !isempty(state.active_styles)
+                end_style!(state, i, char)
+            end
+        end
+        # Ensure that any trailing unstyled content is added
+        if state.point[] <= lastindex(state.content) + state.offset[]
+            addpart!(state, lastindex(state.content))
+        end
+        if !isempty(state.active_styles)
+            stywarn(state, "contains unterminated styled constructs")
+        end
     end
-    if interpolated
-        :(styledstring($(parts...))) |> esc
+
+    #------------------
+    # The actual body of the macro
+    #------------------
+
+    run_state_machine!(state)
+    if state.interpolated[]
+        :($styledstring($(state.parts...))) |> esc
     else
-        styledstring(map(eval, parts)...)
+        styledstring(map(eval, state.parts)...) |> styledstring_optimize!
     end
 end

From 0569c57befe7015c4ba66150c863e5888b5d222c Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sun, 10 Sep 2023 12:58:06 +0800
Subject: [PATCH 0048/1315] Tests for styled strings and faces

---
 test/choosetests.jl    |   2 +-
 test/strings/faces.jl  | 191 +++++++++++++++++++++++++++++++++++++++++
 test/strings/styled.jl |  99 +++++++++++++++++++++
 3 files changed, 291 insertions(+), 1 deletion(-)
 create mode 100644 test/strings/faces.jl
 create mode 100644 test/strings/styled.jl

diff --git a/test/choosetests.jl b/test/choosetests.jl
index 221a49b710d8b..406e59fd82fa6 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -151,7 +151,7 @@ function choosetests(choices = [])
 
     filtertests!(tests, "unicode", ["unicode/utf8"])
     filtertests!(tests, "strings", ["strings/basic", "strings/search", "strings/util",
-                   "strings/io", "strings/types"])
+                   "strings/io", "strings/types", "strings/styled", "strings/faces"])
     # do subarray before sparse but after linalg
     filtertests!(tests, "subarray")
     filtertests!(tests, "compiler", [
diff --git a/test/strings/faces.jl b/test/strings/faces.jl
new file mode 100644
index 0000000000000..6a3242e0aca30
--- /dev/null
+++ b/test/strings/faces.jl
@@ -0,0 +1,191 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+@testset "SimpleColor" begin
+    @test Base.SimpleColor(:hey).value == :hey # no error
+    @test Base.SimpleColor(0x01, 0x02, 0x03).value == (r=0x01, g=0x02, b=0x03)
+    @test Base.SimpleColor((r=0x01, g=0x02, b=0x03)).value == (r=0x01, g=0x02, b=0x03)
+    @test Base.SimpleColor(0x010203).value == (r=0x01, g=0x02, b=0x03)
+    @test tryparse(Base.SimpleColor, "hey") == Base.SimpleColor(:hey)
+    @test tryparse(Base.SimpleColor, "#010203") == Base.SimpleColor(0x010203)
+    @test tryparse(Base.SimpleColor, "#12345g") === nothing
+    @test tryparse(Base.SimpleColor, "!not a color") === nothing
+    @test_throws ArgumentError parse(Base.SimpleColor, "!not a color")
+end
+
+@testset "Faces" begin
+    # Construction
+    @test Base.Face() ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, nothing, nothing, nothing, Symbol[])
+    @test Base.Face(font="font") ==
+        Base.Face("font", nothing, nothing, nothing, nothing,
+             nothing, nothing, nothing, nothing, Symbol[])
+    @test Base.Face(height=1) ==
+        Base.Face(nothing, 1, nothing, nothing, nothing,
+             nothing, nothing, nothing, nothing, Symbol[])
+    @test Base.Face(weight=:bold) ==
+        Base.Face(nothing, nothing, :bold, nothing, nothing,
+             nothing, nothing, nothing, nothing, Symbol[])
+    @test Base.Face(slant=:italic) ==
+        Base.Face(nothing, nothing, nothing, :italic, nothing,
+             nothing, nothing, nothing, nothing, Symbol[])
+    @test Base.Face(foreground=Base.SimpleColor(:red)) ==
+        Base.Face(nothing, nothing, nothing, nothing, Base.SimpleColor(:red),
+             nothing, nothing, nothing, nothing, Symbol[])
+    @test Base.Face(foreground=:red) ==
+        Base.Face(nothing, nothing, nothing, nothing, Base.SimpleColor(:red),
+             nothing, nothing, nothing, nothing, Symbol[])
+    @test Base.Face(foreground=0xff0000) ==
+        Base.Face(nothing, nothing, nothing, nothing, Base.SimpleColor(0xff0000),
+             nothing, nothing, nothing, nothing, Symbol[])
+    @test Base.Face(background=Base.SimpleColor(:red)) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             Base.SimpleColor(:red), nothing, nothing, nothing, Symbol[])
+    @test Base.Face(background=:red) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             Base.SimpleColor(:red), nothing, nothing, nothing, Symbol[])
+    @test Base.Face(background=0xff0000) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             Base.SimpleColor(0xff0000), nothing, nothing, nothing, Symbol[])
+    @test Base.Face(underline=true) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, true, nothing, nothing, Symbol[])
+    @test Base.Face(underline=:red) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, Base.SimpleColor(:red), nothing, nothing, Symbol[])
+    @test Base.Face(underline=(nothing, :curly)) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, (nothing, :curly), nothing, nothing, Symbol[])
+    @test Base.Face(underline=(:red, :curly)) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, (Base.SimpleColor(:red), :curly), nothing, nothing, Symbol[])
+    @test Base.Face(strikethrough=true) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, nothing, true, nothing, Symbol[])
+    @test Base.Face(inverse=true) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, nothing, nothing, true, Symbol[])
+    @test Base.Face(inherit=:singleface) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, nothing, nothing, nothing, [:singleface])
+    @test Base.Face(inherit=[:many, :faces]) ==
+        Base.Face(nothing, nothing, nothing, nothing, nothing,
+             nothing, nothing, nothing, nothing, [:many, :faces])
+    @test Base.Face() == Base.Face()
+    @test Base.Face(height=1) == Base.Face(height=1)
+    @test Base.Face(height=1) != Base.Face(height=2)
+    @test Base.Face(inherit=:a) != Base.Face(inherit=:b)
+    # Adding a face then resetting
+    @test Base.loadfaces!(:testface => Base.Face(font="test")) == Base.Face(font="test")
+    @test get(Base.FACES.current[], :testface, nothing) == Base.Face(font="test")
+    @test Base.loadfaces!(:bold => Base.Face(weight=:extrabold)) == Base.Face(weight=:extrabold)
+    @test get(Base.FACES.current[], :bold, nothing) == Base.Face(weight=:extrabold)
+    @test Base.loadfaces!(:testface => Base.Face(height=2.0)) == Base.Face(font="test", height=2.0)
+    @test get(Base.FACES.current[], :testface, nothing) == Base.Face(font="test", height=2.0)
+    # Loading from TOML (a Dict)
+    @test Base.loadfaces!(Dict{String, Any}("anotherface" =>
+        Dict{String, Any}("font" => "afont",
+                          "height" => 123,
+                          "weight" => "semibold",
+                          "slant" => "oblique",
+                          "foreground" => "green",
+                          "background" => "magenta",
+                          "underline" => ["blue", "curly"],
+                          "strikethrough" => true,
+                          "inverse" => true,
+                          "inherit" => ["iface"]))) isa Any
+    @test get(Base.FACES.current[], :anotherface, nothing) ==
+        Base.Face(font = "afont", height = 123, weight = :semibold,
+             slant = :oblique, foreground = :green, background = :magenta,
+             underline = (:blue, :curly), strikethrough = true,
+             inverse = true, inherit = [:iface])
+    Base.resetfaces!()
+    @test get(Base.FACES.current[], :bold, nothing) == Base.Face(weight=:bold)
+    @test haskey(Base.FACES.current[], :testface) == false
+    @test haskey(Base.FACES.current[], :anotherface) == false
+    # `withfaces`
+    @test Base.withfaces(() -> get(Base.FACES.current[], :testface, nothing),
+                    :testface => Base.Face(font="test")) == Base.Face(font="test")
+    @test haskey(Base.FACES.current[], :testface) == false
+    # Basic merging
+    let f1 = Base.Face(height=140, weight=:bold, inherit=[:a])
+        f2 = Base.Face(height=1.5, weight=:light, inherit=[:b])
+        f3 = Base.Face(height=1.2, slant=:italic)
+        @test merge(f1, f2, f3) == Base.Face(height=252, weight=:light, slant=:italic)
+        @test merge(f3, f2, f1) == Base.Face(height=140, weight=:bold, slant=:italic, inherit=[:a])
+        @test merge(f3, f1) == Base.Face(height=140, weight=:bold, slant=:italic, inherit=[:a])
+        @test merge(f3, f2) == Base.Face(height=1.5*1.2, weight=:light, slant=:italic, inherit=[:b])
+    end
+    # Merging, inheritence, and canonicalisation
+    let aface = Base.Face(font="a", height=1.2)
+        bface = Base.Face(font="b", height=1.1, weight=:light, inherit=:a)
+        cface = Base.Face(font="c", foreground=:red, inherit=:b)
+        dface = Base.Face(font="d", foreground=:blue, weight=:bold)
+        eface = Base.Face(font="e", inherit = [:c, :d])
+        fface = Base.Face(font="f", inherit = [:d, :c])
+        Base.loadfaces!(:a => aface)
+        Base.loadfaces!(:b => bface)
+        Base.loadfaces!(:c => cface)
+        Base.loadfaces!(:d => dface)
+        Base.loadfaces!(:e => eface)
+        Base.loadfaces!(:f => fface)
+        @test Base.getface(:c) == merge(Base.FACES.current[][:default], aface, bface, cface, Base.Face())
+        @test Base.getface(:b) == merge(Base.FACES.current[][:default], aface, bface, Base.Face())
+        @test Base.getface(:a) == merge(Base.FACES.current[][:default], aface, Base.Face())
+        @test Base.getface([:c]) == Base.getface(:c)
+        @test Base.getface(bface) == Base.getface(:b)
+        @test Base.getface(cface) == Base.getface(:c)
+        @test Base.getface([:c, :d]).foreground.value == :red
+        @test Base.getface(:e).foreground.value == :red
+        @test Base.getface([:d, :c]).foreground.value == :blue
+        @test Base.getface(:f).foreground.value == :blue
+        Base.resetfaces!()
+    end
+end
+
+@testset "Styled string macro" begin
+    # Preservation of an unstyled string
+    @test S"some string" == StyledString("some string")
+    # Basic styled constructs
+    @test S"{thing=val:some} string" == StyledString("some string", [(1:4, :thing => "val")])
+    @test S"some {thing=val:string}" == StyledString("some string", [(6:11, :thing => "val")])
+    @test S"some {a=1:s}trin{b=2:g}" == StyledString("some string", [(6:6, :a => "1"), (11:11, :b => "2")])
+    @test S"{thing=val with spaces:some} string" == StyledString("some string", [(1:4, :thing => "val with spaces")])
+    @test S"{aface:some} string" == StyledString("some string", [(1:4, :face => :aface)])
+    @test S"{aface,bface:some} string" ==
+        StyledString("some string", [(1:4, :face => :aface), (1:4, :face => :bface)])
+    # Inline face attributes
+    @test S"{(slant=italic):some} string" ==
+        StyledString("some string", [(1:4, :face => Base.Face(slant=:italic))])
+    @test S"{(foreground=magenta,background=#555555):some} string" ==
+        StyledString("some string", [(1:4, :face => Base.Face(foreground=:magenta, background=0x555555))])
+    # Curly bracket escaping
+    @test S"some \{string" == StyledString("some {string")
+    @test S"some string\}" == StyledString("some string}")
+    @test S"some \{string\}" == StyledString("some {string}")
+    @test S"some \{str:ing\}" == StyledString("some {str:ing}")
+    @test S"some \{{bold:string}\}" == StyledString("some {string}", [(7:12, :face => :bold)])
+    @test S"some {bold:string \{other\}}" == StyledString("some string {other}", [(6:19, :face => :bold)])
+    # Nesting
+    @test S"{bold:nest{italic:ed st{red:yling}}}" ==
+        StyledString("nested styling", [(1:14, :face => :bold), (5:14, :face => :italic), (10:14, :face => :red)])
+    # Production of a `StyledString` value instead of an expression when possible
+    @test StyledString("val") == @macroexpand S"val"
+    @test StyledString("val", :face => :style) == @macroexpand S"{style:val}"
+    # Interpolation
+    @test :($styledstring(val)) == @macroexpand S"$val"
+    @test :($styledstring("a", val)) == @macroexpand S"a$val"
+    @test :($styledstring("a", val, "b")) == @macroexpand S"a$(val)b"
+    @test :($styledstring($StyledString(string(val), $(Pair{Symbol, Any}(:face, :style))))) ==
+        @macroexpand S"{style:$val}"
+    @test :($styledstring($StyledString("val", [($(1:3), Pair{Symbol, Any}(:face, face))]))) ==
+        @macroexpand S"{$face:val}"
+    @test :($styledstring($StyledString("val", [($(1:3), Pair{Symbol, Any}(key, "val"))]))) ==
+        @macroexpand S"{$key=val:val}"
+    @test :($styledstring($StyledString("val", [($(1:3), Pair{Symbol, Any}(key, val))]))) ==
+        @macroexpand S"{$key=$val:val}"
+    @test :($styledstring($StyledString(string(val), Pair{Symbol, Any}(key, val)))) ==
+        @macroexpand S"{$key=$val:$val}"
+    @test :($styledstring($StyledString("val", [($(1:3), Pair{Symbol, Any}(:face, $(Base.Face)(foreground = color)))]))) ==
+        @macroexpand S"{(foreground=$color):val}"
+end
diff --git a/test/strings/styled.jl b/test/strings/styled.jl
new file mode 100644
index 0000000000000..6cdfba082eeda
--- /dev/null
+++ b/test/strings/styled.jl
@@ -0,0 +1,99 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+@testset "StyledString" begin
+    str = StyledString("some string")
+    @test str == StyledString(str.string, Tuple{UnitRange{Int64}, Pair{Symbol, Any}}[])
+    @test length(str) == 11
+    @test ncodeunits(str) == 11
+    @test eltype(str) == StyledChar{eltype(str.string)}
+    @test first(str) == StyledChar(first(str.string), Pair{Symbol, Any}[])
+    @test str[1:4] isa SubString{typeof(str)}
+    @test str[1:4] == StyledString("some")
+    @test "a" * str == StyledString("asome string")
+    @test str * "a" == StyledString("some stringa")
+    @test str * str == StyledString("some stringsome string")
+    Base.textproperty!(str, 1:4, :thing, 0x01)
+    Base.textproperty!(str, 5:11, :other, 0x02)
+    Base.textproperty!(str, 1:11, :all, 0x03)
+    @test str[3:4] == SubString(str, 3, 4)
+    @test StyledString(str[3:4]) ==
+        StyledString("me", [(1:2, :thing => 0x01), (1:2, :all => 0x03)])
+    @test str == StyledString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    @test str != StyledString("some string")
+    @test str != StyledString("some string", [(1:1, :thing => 0x01), (5:5, :other => 0x02), (11:11, :all => 0x03)])
+    @test str != StyledString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (5:11, :other => 0x12)])
+    @test str != StyledString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    let allstrings =
+        ['a', StyledChar('a'), StyledChar('a', :aaa => 0x04),
+        "a string", StyledString("a string"),
+        StyledString("a string", [(1:2, :hmm => '%')])]
+        for str1 in repeat(allstrings, 2)
+            for str2 in repeat(allstrings, 2)
+                @test String(str1 * str2) ==
+                    String(string(str1, str2)) ==
+                    String(string(str1)) * String(string(str2))
+                @test styledstring(str1 * str2) ==
+                    styledstring(str1, str2) ==
+                    styledstring(str1) * styledstring(str2)
+            end
+        end
+    end
+    @test collect(Base.eachstyle(str)) ==
+        [("some", [:thing => 0x01, :all => 0x03]),
+        (" string", [:all => 0x03, :other => 0x02])]
+    @test ==(Base.styledstring_optimize!(
+        StyledString("abc", [(1:1, :val => 1),
+                             (2:2, :val => 2),
+                             (2:2, :val => 1),
+                             (3:3, :val => 2)])),
+             StyledString("abc", [(1:2, :val => 1),
+                                  (2:3, :val => 2)]))
+end
+
+@testset "StyledChar" begin
+    chr = StyledChar('c')
+    @test chr == StyledChar(chr.char, Pair{Symbol, Any}[])
+    str = StyledString("hmm", [(1:1, :attr => "h0h0"),
+                               (1:2, :attr => "h0m1"),
+                               (2:3, :attr => "m1m2")])
+    @test str[1] == StyledChar('h', Pair{Symbol, Any}[:attr => "h0h0"])
+    @test str[2] == StyledChar('m', Pair{Symbol, Any}[:attr => "h0m1", :attr => "m1m2"])
+    @test str[3] == StyledChar('m', Pair{Symbol, Any}[:attr => "m1m2"])
+end
+
+@testset "Styling preservation" begin
+    str = StyledString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    @test match(r".e", str).match == str[3:4]
+    @test  match(r"(.e)", str).captures == [str[3:4]]
+    let m0 = match(r"(.)e", str)
+        m1 = first(eachmatch(r"(.)e", str))
+        for f in fieldnames(RegexMatch)
+            @test getfield(m0, f) == getfield(m1, f)
+        end
+    end
+    @test lpad(str, 12) ==
+        StyledString(" some string", [(2:5, :thing => 0x01),
+                                      (2:12, :all => 0x03),
+                                      (6:12, :other => 0x02)])
+    @test rpad(str, 12) ==
+        StyledString("some string ", [(1:4, :thing => 0x01),
+                                      (1:11, :all => 0x03),
+                                      (5:11, :other => 0x02)])
+    str1 = StyledString("test", [(1:4, :tag => 5)])
+    str2 = StyledString("case", [(2:3, :tag => "oomph")])
+    @test join([str1, str1], StyledString(" ")) ==
+        StyledString("test test",
+                     [(1:4, :tag => 5),
+                      (6:9, :tag => 5)])
+    @test join([str1, str1], StyledString(" ", [(1:1, :tag => 2)])) ==
+        StyledString("test test",
+                     [(1:4, :tag => 5),
+                      (5:5, :tag => 2),
+                      (6:9, :tag => 5)])
+    @test repeat(str1, 2) == StyledString("testtest", [(1:8, :tag => 5)])
+    @test repeat(str2, 2) == StyledString("casecase", [(2:3, :tag => "oomph"),
+                                                       (6:7, :tag => "oomph")])
+    @test repeat(str1[1], 3) == StyledString("ttt", [(1:3, :tag => 5)])
+    @test reverse(str1) == StyledString("tset", [(1:4, :tag => 5)])
+    @test reverse(str2) == StyledString("esac", [(2:3, :tag => "oomph")])
+end

From 5aaff189acc1d229d05c42718b3ffa28f73b40f9 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sun, 10 Sep 2023 13:13:49 +0800
Subject: [PATCH 0049/1315] Add StyledStrings, Faces, and @S_str to NEWS

---
 NEWS.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index bab64a2d195ac..f8f1a5d159dd8 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -8,6 +8,18 @@ New language features
   difference between `public` and `export` is that `public` names do not become
   available when `using` a package/module. ([#50105])
 * `ScopedValue` implement dynamic scope with inheritance across tasks ([#50958]).
+* A new `AbstractString` type, `StyledString`, is introduced that allows for
+  (arbitrary) regional annotations to be attached to an underlying string. This is
+  very useful for allowing styling information to be encoded separately, and along
+  with `Faces` provides a much more sophisticated approach for styling that
+  `printstyled`. There is also a new `StyledChar` type, that is the equivalent
+  new `AbstractChar` type.
+* The new `Faces` struct serves as a container for text styling information
+  (think typeface), and comes with a framework to provide a convenient,
+  extensible (via `addface!`), and customisable (see `loadfaces!`) approach to
+  styled content.
+* The new `@S_str` string macro provides a convenient way of creating a
+  `StyledString` with various faces or other attributes applied.
 
 Language changes
 ----------------

From f8192fe29c934a5d6422d9f3e83bd719df28c1b6 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sun, 10 Sep 2023 20:17:15 +0800
Subject: [PATCH 0050/1315] Document StyledStrings and Faces

---
 doc/src/base/strings.md   |   7 ++
 doc/src/manual/strings.md | 230 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 237 insertions(+)

diff --git a/doc/src/base/strings.md b/doc/src/base/strings.md
index 979ba1157fb23..4d847c14d0845 100644
--- a/doc/src/base/strings.md
+++ b/doc/src/base/strings.md
@@ -17,6 +17,13 @@ Core.String(::AbstractString)
 Base.SubString
 Base.LazyString
 Base.@lazy_str
+Base.StyledString
+Base.StyledChar
+Base.styledstring
+Base.Face
+Base.@S_str
+Base.addface!
+Base.loadfaces!
 Base.transcode
 Base.unsafe_string
 Base.ncodeunits(::AbstractString)
diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md
index 9c4fde5b8a701..e904edbea83ea 100644
--- a/doc/src/manual/strings.md
+++ b/doc/src/manual/strings.md
@@ -1203,3 +1203,233 @@ Notice that the first two backslashes appear verbatim in the output, since they
 precede a quote character.
 However, the next backslash character escapes the backslash that follows it, and the
 last backslash escapes a quote, since these backslashes appear before a quote.
+
+## [Styling](@id man-styling)
+
+When working with strings, formatting and styling often appear as a secondary
+concern.
+
+!!! note
+    For instance, when printing to a terminal you might want to sprinkle [ANSI
+    escape
+    sequences](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters)
+    in the output, when outputting HTML styling constructs (`<span style="...">`,
+    etc.) serve a similar purpose, and so on. It is possible to simply insert the
+    raw styling constructs into the string next to the content itself, but it
+    quickly becomes apparent that this is not well suited for anything but the most
+    basic use-cases. Not all terminals support the same ANSI codes, the styling
+    constructs need to be painstakingly removed when calculating the width of
+    already-styled content, and that's before you even get into handling
+    multiple output formats.
+
+Instead of leaving this headache to be widely experienced downstream, it is
+tackled head-on by the introduction of a special string type
+([`StyledString`](@ref)). This string type wraps any other string type and
+allows for formating information to be applied to regions (e.g. characters 1
+through to 7 are bold and red).
+
+Regions of a string are styled by applying [`Face`](@ref)s to them —a
+structure that holds styling information— (think "typeface"). As a
+convenience, it is possible to name a face in the global faces dictionary
+instead of giving the [`Face`](@ref) directly.
+
+Along with these capabilities, we also provide a convenient way for constructing
+[`StyledString`](@ref)s, detailed in [Styled String Literals](@ref man-styled-string-literals).
+
+```jldoctest
+julia> S"{yellow:hello} {blue:there}"
+"hello there" # prints with colour in the REPL
+```
+
+### [Styled Strings](@id man-styled-strings)
+
+[`StyledString`](@ref)s wrap another string and overlay a list of tagged
+regions. All generic string operations are applied to the underlying string.
+When possible though, styling information is maintained (e.g. when
+[`split`](@ref)ting a [`StyledString`](@ref)).
+
+To concatenate printable values and styled strings together (maintaining styling
+information), the [`styledstring`](@ref) function can be used (as a counterpart
+to [`string`](@ref)).
+
+```jldoctest
+julia> str = StyledString("hello there",
+               [(1:5, :face => :yellow), (7:11, :face => :blue)])
+"hello there"
+
+julia> collect(Base.eachstyle(str))
+3-element Vector{Tuple{SubString{String}, Vector{Pair{Symbol, Any}}}}:
+ ("hello", [:face => :yellow])
+ (" ", [])
+ ("there", [:face => :blue])
+
+julia> length(str)
+11
+
+julia> lpad(str, 14)
+"   hello there"
+
+julia> typeof(lpad(str, 7))
+StyledString{String}
+
+julia> str2 = StyledString(" julia", [(2:6, :face => :magenta)])
+
+julia> styledstring(str, str2)
+"hello there julia"
+
+julia> str * str2 == styledstring(str, str2) # *-concatination still works
+true
+
+julia> collect(Base.eachstyle(str * str2))
+5-element Vector{Tuple{SubString{String}, Vector{Pair{Symbol, Any}}}}:
+ ("hello", [:face => :yellow])
+ (" ", [])
+ ("there", [:face => :blue])
+ (" ", [])
+ ("julia", [:face => :magenta])
+```
+
+#### Advanced uses
+
+While styling is the focus here, the system is actually more general. It allows
+for arbitrary annotations to be added to regions of the underlying string. Each
+annotation is in the form of a `tag::Symbol => value::Any` tagged value. You can
+tag any information you want, such as source location the string was extracted
+from, or an alternative form of some text, but the most obvious use case is to
+hold styling information (which use a `:face` tag).
+
+### [Faces](@id man-faces)
+
+#### The `Face` type
+
+A [`Face`](@ref) specifies details of a typeface that text can be set in. It
+covers a set of basic attributes that generalise well across different formats,
+namely:
+
+- `height`
+- `weight`
+- `slant`
+- `foreground`
+- `background`
+- `underline`
+- `strikethrough`
+- `inverse`
+- `inherit`
+
+For details on the particular forms these attributes take, see the
+[`Face`](@ref) docstring, but of particular interest is `inherit` as it allows
+you to _inherit_ attributes from other [`Face`](@ref)s.
+
+#### The global `FACES` dictionary
+
+To make referring to particular styles more convenient, there is a global
+`Dict{Symbol, Face}` that allows for [`Face`](@ref)s to be referred to simply by
+name. Packages can add faces to this dictionary via the [`Base.addface!`](@ref)
+function, and the loaded faces can be easily [customised](@ref man-face-toml).
+
+!!! warning
+    Any package registering new faces should ensure that they are prefixed
+    by the package name, i.e. follow the format `mypackage_myface`.
+    This is important for predictability, and to prevent name clashes.
+
+There is one set of exemptions to the package-prefix rule, the set of basic
+faces that are part of the default value of the faces dictionary.
+
+##### [Basic faces](@id man-basic-faces)
+
+Basic faces are intended represent a general idea, that is widely applicable.
+
+For setting some text with a certain attribute, we have the `bold`, `italic`,
+`underline`, `strikethrough`, and `inverse` faces.
+
+There are also named faces for the 16 terminal colours: `black`, `red`, `green`,
+`yellow`, `blue`, `magenta`, `cyan`, `white`, `bright_black`/`grey`/`gray`,
+`bright_red`, `bright_green`, `bright_blue`, `bright_magenta`, `bright_cyan`,
+and `bright_white`.
+
+For shadowed text (i.e. dim but there) there is the `shadow` face. To indicate a
+selected region, there is the `region` face. Similarly for emphasis and
+highlighting the `emphasis` and `highlight` faces are defined. There is also
+`code` for code-like text.
+
+For visually indicating the severity of messages the `error`, `warning`,
+`success`, `info`, `note`, and `tip` faces are defined.
+
+#### [Customisation of faces (`Faces.toml`)](@id man-face-toml)
+
+It is good for the name faces in the global face dictionary to be customizable.
+Theming and aesthetics are nice, and it is important for accessibility reasons
+too. A TOML file can be parsed into a list of [`Face`](@ref) specifications that
+are merged with the pre-existing entry in the face dictionary.
+
+A [`Face`](@ref) is represented in TOML like so:
+
+```toml
+[facename]
+attribute = "value"
+...
+
+[package.facename]
+attribute = "value"
+```
+
+For example, if the `shadow` face is too hard to read it can be made brighter
+like so:
+
+```toml
+[shadow]
+foreground = "white"
+```
+
+#### Applying faces to a `StyledString`
+
+By convention, the `:face` attributes of a [`StyledString`](@ref) hold
+information on the [`Face`](@ref)s that currently apply. This can be given in
+multiple forms, as a single `Symbol` naming a [`Face`](@ref)s in the global face
+dictionary, a [`Face`](@ref) itself, or a vector of either.
+
+The `show(::IO, ::MIME"text/plain", ::StyledString)` and `show(::IO,
+::MIME"text/html", ::StyledString)` methods both look at the `:face` attributes
+and merge them all together when determining the overall styling.
+
+We can supply `:face` attributes to a `StyledString` during construction, add
+them to the properties list afterwards, or use the convenient [Styled String
+literals](@ref man-styled-string-literals).
+
+```jldoctest
+julia> str1 = StyledString("blue text", [(1:9, :face => Face(foreground=:blue))])
+"blue text"
+
+julia> str2 = StyledString("blue text", :face => Face(foreground=:blue))
+"blue text"
+
+julia> str1 == str2
+true
+
+julia> sprint(show, MIME("text/plain"), str1, context = :color => true)
+"\"\e[34mblue text\e[39m\""
+
+julia> sprint(show, MIME("text/html"), str1, context = :color => true)
+"<pre><span style=\"color: #000080;\">blue text</span></pre>"
+```
+
+## [Styled String Literals](@id man-styled-string-literals)
+
+To ease construction of [`StyledString`](@ref)s with [`Face`](@ref)s applied,
+the [`S"..."`](@ref @S_str) styled string literal allows for the content and
+attributes to be easily expressed together via a custom grammar.
+
+Within a [`S"..."`](@ref @S_str) literal, curly parenthesis are considered
+special characters and must be escaped in normal usage (`\{`, `\}`). This allows
+them to be used to express annotations with (nestable) `{annotations...:text}`
+constructs.
+
+The `annotations...` component is a comma-separated list of three types of annotations.
+- Face names
+- Inline `Face` expressions `(key=val,...)`
+- `key=value` pairs
+
+Interpolation is possible everywhere except for inline face keys.
+
+For more information on the grammar, see the extended help of the
+[`S"..."`](@ref @S_str) docstring.

From 00013807a74d3c87e0d29a5c41746d1809716061 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Fri, 6 Oct 2023 00:52:15 +0800
Subject: [PATCH 0051/1315] =?UTF-8?q?Put=20styling=20in=20new=20stdlib;=20?=
 =?UTF-8?q?Styled=20=E2=86=92=20Tagged=20rename?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

After discussion on Triage, we've decided that the base
Styled{String,Char} types will be renamed to Tagged{String,Char} to
better indicate their versatility and kept in base, with everything else
moved out to a new StyledStrings standard library.
---
 NEWS.md                                       |   25 +-
 base/client.jl                                |   16 -
 base/exports.jl                               |   14 +-
 base/regex.jl                                 |   24 +-
 base/strings/basic.jl                         |   14 +-
 base/strings/faces.jl                         | 1244 -----------------
 base/strings/io.jl                            |  483 +------
 base/strings/strings.jl                       |    3 +-
 base/strings/styled.jl                        |  432 ------
 base/strings/tagged.jl                        |  354 +++++
 base/strings/util.jl                          |    8 +-
 .../md5                                       |    1 +
 .../sha512                                    |    1 +
 doc/src/base/strings.md                       |   12 +-
 doc/src/manual/strings.md                     |  232 +--
 pkgimage.mk                                   |    1 +
 stdlib/.gitignore                             |    2 +
 stdlib/Makefile                               |    2 +-
 stdlib/StyledStrings.version                  |    4 +
 stdlib/stdlib.mk                              |    2 +-
 test/choosetests.jl                           |    2 +-
 test/strings/faces.jl                         |  191 ---
 test/strings/styled.jl                        |   99 --
 test/strings/tagged.jl                        |   99 ++
 24 files changed, 569 insertions(+), 2696 deletions(-)
 delete mode 100644 base/strings/faces.jl
 delete mode 100644 base/strings/styled.jl
 create mode 100644 base/strings/tagged.jl
 create mode 100644 deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/sha512
 create mode 100644 stdlib/StyledStrings.version
 delete mode 100644 test/strings/faces.jl
 delete mode 100644 test/strings/styled.jl
 create mode 100644 test/strings/tagged.jl

diff --git a/NEWS.md b/NEWS.md
index f8f1a5d159dd8..3f12583f76c66 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -8,18 +8,11 @@ New language features
   difference between `public` and `export` is that `public` names do not become
   available when `using` a package/module. ([#50105])
 * `ScopedValue` implement dynamic scope with inheritance across tasks ([#50958]).
-* A new `AbstractString` type, `StyledString`, is introduced that allows for
+* A new `AbstractString` type, `TaggedString`, is introduced that allows for
   (arbitrary) regional annotations to be attached to an underlying string. This is
-  very useful for allowing styling information to be encoded separately, and along
-  with `Faces` provides a much more sophisticated approach for styling that
-  `printstyled`. There is also a new `StyledChar` type, that is the equivalent
-  new `AbstractChar` type.
-* The new `Faces` struct serves as a container for text styling information
-  (think typeface), and comes with a framework to provide a convenient,
-  extensible (via `addface!`), and customisable (see `loadfaces!`) approach to
-  styled content.
-* The new `@S_str` string macro provides a convenient way of creating a
-  `StyledString` with various faces or other attributes applied.
+  very useful for allowing styling information to be encoded separately, and is
+  used extensively in the new `StyledStrings` standard library. There is also a
+  new `TaggedChar` type, that is the equivalent new `AbstractChar` type.
 
 Language changes
 ----------------
@@ -63,6 +56,16 @@ New library features
 Standard library changes
 ------------------------
 
+#### StyledStrings
+
+* A new standard library for handling styling in a more comprehensive and structured way.
+* The new `Faces` struct serves as a container for text styling information
+  (think typeface), and comes with a framework to provide a convenient,
+  extensible (via `addface!`), and customisable (with a user's `Faces.toml` and `loadfaces!`) approach to
+  styled content.
+* The new `@styled_str` string macro provides a convenient way of creating a
+  `TaggedString` with various faces or other attributes applied.
+
 #### Package Manager
 
 #### LinearAlgebra
diff --git a/base/client.jl b/base/client.jl
index aa02e48cd47d8..d55c2695e11e8 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -398,19 +398,6 @@ function load_InteractiveUtils(mod::Module=Main)
     return MainInclude.InteractiveUtils
 end
 
-"""
-    loadfaces!(facetoml::IO)
-
-Parse `facetoml` as TOML, and load all faces described.
-The loading is done with `loadfaces!`, which see.
-
-Face entries should be of the following form:
-```toml
-[face_name]
-property = "value"
-"""
-loadfaces!(facetoml::IO) = loadfaces!(TOML.parse(TOML.Parser(facetoml)))
-
 function load_REPL()
     # load interactive-only libraries
     try
@@ -433,9 +420,6 @@ function run_main_repl(interactive::Bool, quiet::Bool, banner::Symbol, history_f
         end
     end
     # TODO cleanup REPL_MODULE_REF
-    userfaces = joinpath(first(DEPOT_PATH), "config", "faces.toml")
-    isfile(userfaces) && open(loadfaces!, userfaces)
-
     if !fallback_repl && interactive && isassigned(REPL_MODULE_REF)
         invokelatest(REPL_MODULE_REF[]) do REPL
             term_env = get(ENV, "TERM", @static Sys.iswindows() ? "" : "dumb")
diff --git a/base/exports.jl b/base/exports.jl
index d2b6995318789..6b8448459028d 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -50,7 +50,6 @@ export
     Dims,
     Enum,
     ExponentialBackOff,
-    Face,
     IndexCartesian,
     IndexLinear,
     IndexStyle,
@@ -93,8 +92,6 @@ export
     StridedMatrix,
     StridedVecOrMat,
     StridedVector,
-    StyledChar,
-    StyledString,
     SubArray,
     SubString,
     SubstitutionString,
@@ -583,7 +580,6 @@ export
     ∪,
 
 # strings
-    addface!,
     ascii,
     bitstring,
     bytes2hex,
@@ -612,7 +608,6 @@ export
     isspace,
     isuppercase,
     isxdigit,
-    loadfaces!,
     lowercase,
     lowercasefirst,
     isvalid,
@@ -634,7 +629,6 @@ export
     split,
     string,
     strip,
-    styledstring,
     textwidth,
     thisind,
     titlecase,
@@ -1018,7 +1012,6 @@ export
     @b_str,    # byte vector
     @r_str,    # regex
     @s_str,    # regex substitution string
-    @S_str,    # styled string
     @v_str,    # version number
     @raw_str,  # raw string with no interpolation/unescaping
     @NamedTuple,
@@ -1096,8 +1089,15 @@ public
     Generator,
     ImmutableDict,
     OneTo,
+    TaggedString,
+    TaggedChar,
     UUID,
 
+# Tagged strings
+    textproperties,
+    textproperty!,
+    taggedstring,
+
 # Semaphores
     Semaphore,
     acquire,
diff --git a/base/regex.jl b/base/regex.jl
index 61a138de1ee78..bfdeffaec7d66 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -427,35 +427,35 @@ function match(re::Regex, str::Union{SubString{String}, String}, idx::Integer,
     return result
 end
 
-function _styledmatch(m::RegexMatch{S}, str::StyledString{S}) where {S<:AbstractString}
-    RegexMatch{StyledString{S}}(
-        (@inbounds SubString{StyledString{S}}(
+function _taggedmatch(m::RegexMatch{S}, str::TaggedString{S}) where {S<:AbstractString}
+    RegexMatch{TaggedString{S}}(
+        (@inbounds SubString{TaggedString{S}}(
             str, m.match.offset, m.match.ncodeunits, Val(:noshift))),
-        Union{Nothing,SubString{StyledString{S}}}[
+        Union{Nothing,SubString{TaggedString{S}}}[
             if !isnothing(cap)
-                (@inbounds SubString{StyledString{S}}(
+                (@inbounds SubString{TaggedString{S}}(
                     str, cap.offset, cap.ncodeunits, Val(:noshift)))
             end for cap in m.captures],
         m.offset, m.offsets, m.regex)
 end
 
-function match(re::Regex, str::StyledString)
+function match(re::Regex, str::TaggedString)
     m = match(re, str.string)
     if !isnothing(m)
-        _styledmatch(m, str)
+        _taggedmatch(m, str)
     end
 end
 
-function match(re::Regex, str::StyledString, idx::Integer, add_opts::UInt32=UInt32(0))
+function match(re::Regex, str::TaggedString, idx::Integer, add_opts::UInt32=UInt32(0))
     m = match(re, str.string, idx, add_opts)
     if !isnothing(m)
-        _styledmatch(m, str)
+        _taggedmatch(m, str)
     end
 end
 
 match(r::Regex, s::AbstractString) = match(r, s, firstindex(s))
 match(r::Regex, s::AbstractString, i::Integer) = throw(ArgumentError(
-    "regex matching is only available for the String type; use String(s) to convert"
+    "regex matching is only available for the String and TaggedString types; use String(s) to convert"
 ))
 
 findnext(re::Regex, str::Union{String,SubString}, idx::Integer) = _findnext_re(re, str, idx, C_NULL)
@@ -708,8 +708,8 @@ struct RegexMatchIterator{S <: AbstractString}
 
     RegexMatchIterator(regex::Regex, string::AbstractString, ovr::Bool=false) =
         new{String}(regex, String(string), ovr)
-    RegexMatchIterator(regex::Regex, string::StyledString, ovr::Bool=false) =
-        new{StyledString{String}}(regex, StyledString(String(string.string), string.properties), ovr)
+    RegexMatchIterator(regex::Regex, string::TaggedString, ovr::Bool=false) =
+        new{TaggedString{String}}(regex, TaggedString(String(string.string), string.properties), ovr)
 end
 compile(itr::RegexMatchIterator) = (compile(itr.regex); itr)
 eltype(::Type{<:RegexMatchIterator}) = RegexMatch
diff --git a/base/strings/basic.jl b/base/strings/basic.jl
index 468ee4476da7e..640e715bee3fc 100644
--- a/base/strings/basic.jl
+++ b/base/strings/basic.jl
@@ -242,8 +242,8 @@ end
     *(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString
 
 Concatenate strings and/or characters, producing a [`String`](@ref) or
-[`StyledString`](@ref) (as appropriate). This is equivalent to calling the
-[`string`](@ref) or [`styledstring`](@ref) function on the arguments. Concatenation of built-in string
+[`TaggedString`](@ref) (as appropriate). This is equivalent to calling the
+[`string`](@ref) or [`taggedstring`](@ref) function on the arguments. Concatenation of built-in string
 types always produces a value of type `String` but other string types may choose
 to return a string of a different type as appropriate.
 
@@ -257,10 +257,10 @@ julia> 'j' * "ulia"
 ```
 """
 function (*)(s1::Union{AbstractChar, AbstractString}, ss::Union{AbstractChar, AbstractString}...)
-    isstyled = s1 isa StyledString || s1 isa StyledChar ||
-        any(s -> s isa StyledString || s isa StyledChar, ss)
-    if isstyled
-        styledstring(s1, ss...)
+    istagged = s1 isa TaggedString || s1 isa TaggedChar ||
+        any(s -> s isa TaggedString || s isa TaggedChar, ss)
+    if istagged
+        taggedstring(s1, ss...)
     else
         string(s1, ss...)
     end
@@ -318,7 +318,7 @@ end
     ==(a::AbstractString, b::AbstractString) -> Bool
 
 Test whether two strings are equal character by character (technically, Unicode
-code point by code point). Should either string be a [`StyledString`](@ref) the
+code point by code point). Should either string be a [`TaggedString`](@ref) the
 string properties must match too.
 
 # Examples
diff --git a/base/strings/faces.jl b/base/strings/faces.jl
deleted file mode 100644
index c48fbca7f68fb..0000000000000
--- a/base/strings/faces.jl
+++ /dev/null
@@ -1,1244 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-const RGBTuple = NamedTuple{(:r, :g, :b), NTuple{3, UInt8}}
-
-"""
-    struct SimpleColor
-
-A basic representation of a color, intended for string styling purposes.
-It can either contain a named color (like `:red`), or an `RGBTuple` which
-is a NamedTuple specifying an `r`, `g`, `b` color with a bit-depth of 8.
-
-# Constructors
-
-```julia
-SimpleColor(name::Symbol)  # e.g. :red
-SimpleColor(rgb::RGBTuple) # e.g. (r=1, b=2, g=3)
-SimpleColor(r::Integer, b::Integer, b::Integer)
-SimpleColor(rgb::UInt32)   # e.g. 0x123456
-```
-
-Also see `tryparse(SimpleColor, rgb::String)`.
-"""
-struct SimpleColor
-    value::Union{Symbol, RGBTuple}
-end
-
-SimpleColor(r::Integer, g::Integer, b::Integer) = SimpleColor((; r=UInt8(r), g=UInt8(g), b=UInt8(b)))
-SimpleColor(rgb::UInt32) = SimpleColor(reverse(reinterpret(UInt8, [rgb]))[2:end]...)
-
-"""
-    tryparse(::Type{SimpleColor}, rgb::String)
-
-Attempt to parse `rgb` as a `SimpleColor`. If `rgb` starts with
-`#` and has a length of 7, it is converted into a `RGBTuple`-backed `SimpleColor`.
-If `rgb` starts with `a`-`z`, `rgb` is interpreted as a color name
-and converted to a `Symbol`-backed `SimpleColor`.
-
-Otherwise, `nothing` is returned.
-
-# Examples
-
-```jldoctest
-julia> tryparse(SimpleColor, "blue")
-SimpleColor(:blue)
-
-julia> tryparse(SimpleColor, "#9558b2")
-SimpleColor((r = 0x95, g = 0x58, b = 0xb2))
-
-julia> tryparse(SimpleColor, "#nocolor")
-```
-"""
-function tryparse(::Type{SimpleColor}, rgb::String)
-    if ncodeunits(rgb) == 7 && first(rgb) == '#' &&
-        all(∈(('#',) ∪ ('0':'9') ∪ ('a':'f') ∪ ('A':'F')), rgb)
-        SimpleColor(parse(UInt8, rgb[2:3], base=16),
-                    parse(UInt8, rgb[4:5], base=16),
-                    parse(UInt8, rgb[6:7], base=16))
-    elseif startswith(rgb, 'a':'z') || startswith(rgb, 'A':'Z')
-        SimpleColor(Symbol(rgb))
-    else
-        nothing
-    end
-end
-
-"""
-    parse(::Type{SimpleColor}, rgb::String)
-
-An analogue of `tryparse(SimpleColor, rgb::String)` (which see),
-that raises an error instead of returning `nothing`.
-"""
-function parse(::Type{SimpleColor}, rgb::String)
-    color = tryparse(SimpleColor, rgb)
-    !isnothing(color) ||
-        throw(ArgumentError("invalid color \"$rgb\""))
-    color
-end
-
-"""
-A [`Face`](@ref) is a collection of graphical attributes for displaying text.
-Faces control how text is displayed in the terminal, and possibly other
-places too.
-
-Most of the time, a [`Face`](@ref) will be stored in the global faces dicts as a
-unique association with a *face name* Symbol, and will be most often referred to
-by this name instead of the [`Face`](@ref) object itself.
-
-# Attributes
-
-All attributes can be set via the keyword constructor, and default to `nothing`.
-
-- `height` (an `Int` or `Float64`): The height in either deci-pt (when an `Int`),
-  or as a factor of the base size (when a `Float64`).
-- `weight` (a `Symbol`): One of the symbols (from faintest to densest)
-  `:thin`, `:extralight`, `:light`, `:semilight`, `:normal`,
-  `:medium`, `:semibold`, `:bold`, `:extrabold`, or `:black`.
-  In terminals any weight greater than `:normal` is displayed as bold,
-  and in terminals that support variable-brightness text, any weight
-  less than `:normal` is displayed as faint.
-- `slant` (a `Symbol`): One of the symbols `:italic`, `:oblique`, or `:normal`.
-- `foreground` (a `SimpleColor`): The text foreground color.
-- `background` (a `SimpleColor`): The text background color.
-- `underline`, the text underline, which takes one of the following forms:
-  - a `Bool`: Whether the text should be underlined or not.\\
-  - a `SimpleColor`: The text should be underlined with this color.\\
-  - a `Tuple{Nothing, Symbol}`: The text should be underlined using the style
-    set by the Symbol, one of `:straight`, `:double`, `:curly`, `:dotted`,
-    or `:dashed`.\\
-  - a `Tuple{SimpleColor, Symbol}`: The text should be underlined in the specified
-    SimpleColor, and using the style specified by the Symbol, as before.
-- `strikethrough` (a `Bool`): Whether the text should be struck through.
-- `inverse` (a `Bool`): Whether the foreground and background colors should be
-  inverted.
-- `inherit` (a `Vector{Symbol}`): Names of faces to inherit from,
-  with earlier faces taking priority. All faces inherit from the `:default` face.
-"""
-struct Face
-    font::Union{Nothing, String}
-    height::Union{Nothing, Int, Float64}
-    weight::Union{Nothing, Symbol}
-    slant::Union{Nothing, Symbol}
-    foreground::Union{Nothing, SimpleColor}
-    background::Union{Nothing, SimpleColor}
-    underline::Union{Nothing, Bool, SimpleColor,
-                     Tuple{<:Union{Nothing, SimpleColor}, Symbol}}
-    strikethrough::Union{Nothing, Bool}
-    inverse::Union{Nothing, Bool}
-    inherit::Vector{Symbol}
-end
-
-function Face(; font::Union{Nothing, String} = nothing,
-              height::Union{Nothing, Int, Float64} = nothing,
-              weight::Union{Nothing, Symbol} = nothing,
-              slant::Union{Nothing, Symbol} = nothing,
-              foreground::Union{Nothing, SimpleColor, Symbol, RGBTuple, UInt32} = nothing,
-              background::Union{Nothing, SimpleColor, Symbol, RGBTuple, UInt32} = nothing,
-              underline::Union{Nothing, Bool, SimpleColor,
-                               Symbol, RGBTuple, UInt32,
-                               Tuple{<:Union{Nothing, SimpleColor, Symbol, RGBTuple, UInt32}, Symbol}
-                               } = nothing,
-              strikethrough::Union{Nothing, Bool} = nothing,
-              inverse::Union{Nothing, Bool} = nothing,
-              inherit::Union{Symbol, Vector{Symbol}} = Symbol[],
-              _...) # Simply ignore unrecognised keyword arguments.
-    ascolor(::Nothing) = nothing
-    ascolor(c::SimpleColor) = c
-    ascolor(c::Union{Symbol, RGBTuple, UInt32}) = SimpleColor(c)
-    Face(font, height, weight, slant,
-         ascolor(foreground), ascolor(background),
-         if underline isa Tuple
-             (ascolor(underline[1]), underline[2])
-         elseif underline isa Symbol || underline isa RGBTuple || underline isa UInt32
-             ascolor(underline)
-         else
-             underline
-         end,
-         strikethrough,
-         inverse,
-         if inherit isa Symbol
-             [inherit]
-         else inherit end)
-end
-
-==(a::Face, b::Face) =
-    getfield.(Ref(a), fieldnames(Face)) ==
-    getfield.(Ref(b), fieldnames(Face))
-
-function show(io::IO, ::MIME"text/plain", color::SimpleColor)
-    skiptype = get(io, :typeinfo, nothing) === SimpleColor
-    skiptype || show(io, SimpleColor)
-    skiptype || print(io, '(')
-    if get(io, :color, false)::Bool
-        print(io, StyledString("■", :face => Face(foreground=color)), ' ')
-    end
-    if color.value isa Symbol
-        print(io, color.value)
-    else # rgb tuple
-        print(io, '#', join(lpad.(string.(values(color.value), base=16), 2, '0')))
-    end
-    skiptype || print(io, ')')
-    nothing
-end
-
-function show(io::IO, ::MIME"text/plain", face::Face)
-    if get(io, :compact, false)::Bool
-        show(io, Face)
-        if get(io, :color, false)::Bool
-            # Could do S"({$face:sample})", but S_str isn't defined yet
-            print(io, StyledString("(sample)", [(2:7, :face => face)]))
-        else
-            print(io, '(')
-            isfirst = true
-            for field in setdiff(fieldnames(Face), (:inherit,))
-                if !isnothing(getfield(face, field))
-                    if isfirst; isfirst = false else print(io, ", ") end
-                    print(io, field, '=')
-                    show(io, getfield(face, field))
-                end
-            end
-            if !isempty(face.inherit)
-                if isfirst; isfirst = false else print(io, ", ") end
-                print(io, "inherit=")
-                show(IOContext(io, :typeinfo => Vector{Symbol}), face.inherit)
-            end
-            print(io, ')')
-        end
-    else
-        show(io, Face)
-        print(io, StyledString(" (sample)", [(3:8, :face => face)]))
-        showcolor(io, color) = show(IOContext(io, :typeinfo => SimpleColor),
-                                    MIME("text/plain"), color)
-        setfields = Pair{Symbol, Any}[]
-        isempty(setfields) || print(io, ":")
-        fieldnamepad = 14
-        for field in (:font, :height, :weight, :slant)
-            if !isnothing(getfield(face, field))
-                print(io, '\n', lpad(String(field), fieldnamepad, ' '), ": ",
-                      getfield(face, field))
-            end
-        end
-        for field in (:foreground, :background)
-            if !isnothing(getfield(face, field))
-                print(io, '\n', lpad(String(field), fieldnamepad, ' '), ": ")
-                showcolor(io, getfield(face, field))
-            end
-        end
-        if !isnothing(face.underline)
-            print(io, '\n', lpad("underline", fieldnamepad, ' '), ": ")
-            if face.underline isa Bool
-                print(io, face.underline)
-            elseif face.underline isa SimpleColor
-                showcolor(io, face.underline)
-            elseif face.underline isa Tuple{Nothing, Symbol}
-                print(io, last(face.underline))
-            elseif face.underline isa Tuple{SimpleColor, Symbol}
-                showcolor(io, first(face.underline))
-                print(io, ", ", last(face.underline))
-            end
-        end
-        for field in (:strikethrough, :inverse)
-            if !isnothing(getfield(face, field))
-                print(io, '\n', lpad(String(field), fieldnamepad, ' '), ": ",
-                      getfield(face, field))
-            end
-        end
-        if !isempty(face.inherit)
-            print(io, '\n', lpad("inherit", fieldnamepad, ' '), ": ")
-            isfirst = true
-            for iface in face.inherit
-                if isfirst; isfirst = false else print(io, ", ") end
-                print(io, iface, '(', StyledString("*", :face => iface), ')')
-            end
-        end
-    end
-end
-
-function show(io::IO, face::Face)
-    show(IOContext(io, :compact => true), MIME("text/plain"), face)
-end
-
-"""
-Globally named [`Face`](@ref)s.
-
-`default` gives the initial values of the faces, and `current` holds the active
-(potentially modified) set of faces. This two-set system allows for any
-modifications to the active faces to be undone.
-"""
-const FACES = let default = Dict{Symbol, Face}(
-    # Default is special, it must be completely specified
-    # and everything inherits from it.
-    :default => Face(
-        "monospace", 120,      # font, height
-        :normal, :normal,      # weight, slant
-        SimpleColor(:default), # foreground
-        SimpleColor(:default), # background
-        false, false, false,   # underline, strikethrough, overline
-        Symbol[]),              # inherit
-    # Property faces
-    :bold => Face(weight=:bold),
-    :italic => Face(slant=:italic),
-    :underline => Face(underline=true),
-    :strikethrough => Face(strikethrough=true),
-    :inverse => Face(inverse=true),
-    # Basic color faces
-    :black => Face(foreground=:black),
-    :red => Face(foreground=:red),
-    :green => Face(foreground=:green),
-    :yellow => Face(foreground=:yellow),
-    :blue => Face(foreground=:blue),
-    :magenta => Face(foreground=:magenta),
-    :cyan => Face(foreground=:cyan),
-    :white => Face(foreground=:white),
-    :bright_black => Face(foreground=:bright_black),
-    :grey => Face(foreground=:bright_black),
-    :gray => Face(foreground=:bright_black),
-    :bright_red => Face(foreground=:bright_red),
-    :bright_green => Face(foreground=:bright_green),
-    :bright_yellow => Face(foreground=:bright_yellow),
-    :bright_blue => Face(foreground=:bright_blue),
-    :bright_magenta => Face(foreground=:bright_magenta),
-    :bright_cyan => Face(foreground=:bright_cyan),
-    :bright_white => Face(foreground=:bright_white),
-    # Useful common faces
-    :shadow => Face(foreground=:bright_black),
-    :region => Face(background=0x3a3a3a),
-    :emphasis => Face(foreground=:blue),
-    :highlight => Face(inherit=:emphasis, inverse=true),
-    :code => Face(foreground=:cyan),
-    # Styles of generic content categories
-    :error => Face(foreground=:bright_red),
-    :warning => Face(foreground=:yellow),
-    :success => Face(foreground=:green),
-    :info => Face(foreground=:bright_cyan),
-    :note => Face(foreground=:grey),
-    :tip => Face(foreground=:bright_green))
-    (; default, current=Ref(copy(default)))
-end
-
-## Adding and resetting faces ##
-
-"""
-    addface!(name::Symbol => default::Face)
-
-Create a new face by the name `name`. So long as no face already exists by this
-name, `default` is added to both `FACES``.default` and (a copy of) to
-`FACES`.`current`, with the current value returned.
-
-Should the face `name` already exist, `nothing` is returned.
-
-# Examples
-
-```jldoctest
-julia> addface!(:mypkg_myface => Face(slant=:italic, underline=true))
-Face (sample)
-         slant: italic
-     underline: true
-```
-"""
-function addface!((name, default)::Pair{Symbol, Face})
-    if !haskey(FACES.default, name)
-        FACES.default[name] = default
-        FACES.current[][name] = if haskey(FACES.current[], name)
-            merge(deepcopy(default), FACES.current[][name])
-        else
-            deepcopy(default)
-        end
-    end
-end
-
-"""
-    resetfaces!()
-
-Reset the current global face dictionary to the default value.
-"""
-function resetfaces!()
-    FACES.current[] = copy(FACES.default)
-end
-
-"""
-    resetfaces!(name::Symbol)
-
-Reset the face `name` to its default value, which is returned.
-
-If the face `name` does not exist, nothing is done and `nothing` returned.
-In the unlikely event that the face `name` does not have a default value,
-it is deleted, a warning message is printed, and `nothing` returned.
-"""
-function resetfaces!(name::Symbol)
-    if !haskey(FACES.current[], name)
-    elseif haskey(FACES.current[], name)
-        FACES.current[][name] = copy(FACES.default[name])
-    else # This shouldn't happen
-        delete!(FACES.current[], name)
-        println(stderr,
-                """! The face $name was reset, but it had no default value, and so has been deleted instead!",
-                     This should not have happened, perhaps the face was added without using `addface!`?""")
-    end
-end
-
-"""
-    withfaces(f, kv::Pair...)
-
-Execute `f` with `FACES``.current` temporarily modified by zero or more
-`:name => val` arguments `kv`. `withfaces` is generally used via the
-`withfaces(kv...) do ... end` syntax. A value of `nothing` can be used to
-temporarily unset an face (if if has been set). When `withfaces` returns, the
-original `FACES``.current` has been restored.
-
-    !!! warning
-    Changing faces is not thread-safe.
-
-# Examples
-
-```jldoctest
-julia> withfaces(:yellow => Face(foreground=:red), :green => :blue) do
-           println(S"{yellow:red} and {green:blue} mixed make {magenta:purple}")
-       end
-"red and blue mixed make purple"
-```
-"""
-function withfaces(f, keyvals::Pair{Symbol, <:Union{Face, Symbol, Nothing}}...)
-    old = Dict{Symbol, Union{Face, Nothing}}()
-    for (name, face) in keyvals
-        old[name] = get(FACES.current[], name, nothing)
-        if face isa Face
-            FACES.current[][name] = face
-        elseif face isa Symbol
-            FACES.current[][name] =
-                @something(get(old, face, nothing), get(FACES.current[], face, Face()))
-        elseif haskey(FACES.current[], name)
-            delete!(FACES.current[], name)
-        end
-    end
-    try f()
-    finally
-        for (name, face) in old
-            if isnothing(face)
-                delete!(FACES.current[], name)
-            else
-                FACES.current[][name] = face
-            end
-        end
-    end
-end
-
-"""
-    withfaces(f, altfaces::Dict{Symbol, Face})
-
-Execute `f` with `FACES``.current` temporarily swapped out with `altfaces`
-When `withfaces` returns, the original `FACES``.current` has been restored.
-
-    !!! warning
-    Changing faces is not thread-safe.
-"""
-function withfaces(f, altfaces::Dict{Symbol, Face})
-    oldfaces, FACES.current[] = FACES.current[], altfaces
-    try f()
-    finally
-        FACES.current[] = oldfaces
-    end
-end
-
-withfaces(f) = f()
-
-## Face combination and inheritance ##
-
-"""
-    merge(initial::Face, others::Face...)
-
-Merge the properties of the `initial` face and `others`, with
-later faces taking priority.
-"""
-function merge(a::Face, b::Face)
-    if isempty(a.inherit)
-        Face(ifelse(isnothing(b.font),          a.font,          b.font),
-             if isnothing(b.height)      a.height
-             elseif isnothing(a.height)  b.height
-             elseif b.height isa Int     b.height
-             elseif a.height isa Int     round(Int, a.height * b.height)
-             else a.height * b.height end,
-             ifelse(isnothing(b.weight),        a.weight,        b.weight),
-             ifelse(isnothing(b.slant),         a.slant,         b.slant),
-             ifelse(isnothing(b.foreground),    a.foreground,    b.foreground),
-             ifelse(isnothing(b.background),    a.background,    b.background),
-             ifelse(isnothing(b.underline),     a.underline,     b.underline),
-             ifelse(isnothing(b.strikethrough), a.strikethrough, b.strikethrough),
-             ifelse(isnothing(b.inverse),       a.inverse,       b.inverse),
-             b.inherit)
-    else
-        a_noinherit = Face(
-            a.font, a.height, a.weight, a.slant, a.foreground, a.background,
-            a.underline, a.strikethrough, a.inverse, Symbol[])
-        a_inheritance = map(fname -> get(FACES.current[], fname, Face()), Iterators.reverse(a.inherit))
-        a_resolved = merge(foldl(merge, a_inheritance), a_noinherit)
-        merge(a_resolved, b)
-    end
-end
-
-merge(a::Face, b::Face, others::Face...) = merge(merge(a, b), others...)
-
-## Getting the combined face from a set of properties ##
-
-"""
-    getface(faces)
-
-Obtain the final merged face from `faces`, an iterator of
-[`Face`](@ref)s, face name `Symbol`s, and lists thereof.
-"""
-function getface(faces)
-    isempty(faces) && return FACES.current[][:default]
-    mergedface(face::Face) = face
-    mergedface(face::Symbol) = get(FACES.current[], face, Face())
-    mergedface(faces::Vector) = mapfoldl(mergedface, merge, Iterators.reverse(faces))
-    combined = mapfoldl(mergedface, merge, Iterators.reverse(faces))::Face
-    if !isempty(combined.inherit)
-        combined = merge(combined, Face())
-    end
-    merge(FACES.current[][:default], combined)
-end
-
-"""
-    getface(styles::Vector{Pair{Symbol, Any}})
-
-Combine all of the `:face` styles with `getfaces`.
-"""
-function getface(styles::Vector{Pair{Symbol, Any}})
-    faces = (last(prop) for prop in styles if first(prop) === :face)
-    getface(faces)
-end
-
-getface(face::Face) = merge(FACES.current[][:default], merge(face, Face()))
-getface(face::Symbol) = getface(get(FACES.current[], face, Face()))
-
-"""
-    getface()
-
-Obtain the default face.
-"""
-getface() = FACES.current[][:default]
-
-## Face/StyledString integration ##
-
-"""
-    getface(s::StyledString, i::Integer)
-
-Get the merged [`Face`](@ref) that applies to `s` at index `i`.
-"""
-getface(s::StyledString, i::Integer) =
-    getface(textproperties(s, i))
-
-"""
-    getface(c::StyledChar)
-
-Get the merged [`Face`](@ref) that applies to `c`.
-"""
-getface(c::StyledChar) = getface(c.properties)
-
-"""
-    face!(s::Union{<:StyledString, <:SubString{<:StyledString}},
-          [range::UnitRange{Int},] face::Union{Symbol, Face})
-
-Apply `face` to `s`, along `range` if specified, or the whole of `s`.
-"""
-face!(s::Union{<:StyledString, <:SubString{<:StyledString}},
-      range::UnitRange{Int}, face::Union{Symbol, Face}) =
-          textproperty!(s, range, :face, face)
-
-face!(s::Union{<:StyledString, <:SubString{<:StyledString}},
-      face::Union{Symbol, Face}) =
-          textproperty!(s, firstindex(s):lastindex(s), :face, face)
-
-## Reading face definitions from a dictionary ##
-
-"""
-    loadfaces!(name::Symbol => update::Face)
-
-Merge the face `name` in `FACES``.current` with `update`. If the face `name` does
-not already exist in `FACES``.current`, then it is set to `update.`
-
-# Examples
-
-```jldoctest
-julia> loadfaces!(:red => Face(foreground=0xff0000))
-Face (sample)
-    foreground: ■ #ff0000
-```
-"""
-function loadfaces!((name, update)::Pair{Symbol, Face})
-    if haskey(FACES.current[], name)
-        FACES.current[][name] = merge(FACES.current[][name], update)
-    else
-        FACES.current[][name] = update
-    end
-end
-
-function loadfaces!((name, _)::Pair{Symbol, Nothing})
-    if haskey(FACES.current[], name)
-        resetfaces!(name)
-    end
-end
-
-"""
-    loadfaces!(faces::Dict{String, Any})
-
-For each face specified in `Dict`, load it to `FACES``.current`.
-"""
-function loadfaces!(faces::Dict{String, Any}, prefix::Union{String, Nothing}=nothing)
-    for (name, spec) in faces
-        fullname = if isnothing(prefix)
-            name
-        else
-            string(prefix, '_', name)
-        end
-        fspec = filter((_, v)::Pair -> !(v isa Dict), spec)
-        fnest = filter((_, v)::Pair -> v isa Dict, spec)
-        !isempty(fspec) &&
-            loadfaces!(Symbol(fullname) => convert(Face, fspec))
-        !isempty(fnest) &&
-            loadfaces!(fnest, fullname)
-    end
-end
-
-function convert(::Type{Face}, spec::Dict)
-    Face(if haskey(spec, "font") && spec["font"] isa String
-             spec["font"] end,
-         if haskey(spec, "height") && (spec["height"] isa Int || spec["height"] isa Float64)
-             spec["height"]
-         end,
-         if haskey(spec, "weight") && spec["weight"] isa String
-             Symbol(spec["weight"])
-         elseif haskey(spec, "bold") && spec["bold"] isa Bool
-             ifelse(spec["bold"], :bold, :normal)
-         end,
-         if haskey(spec, "slant") && spec["slant"] isa String
-             Symbol(spec["slant"])
-         elseif haskey(spec, "italic") && spec["italic"] isa Bool
-             ifelse(spec["italic"], :italic, :normal)
-         end,
-         if haskey(spec, "foreground") && spec["foreground"] isa String
-             tryparse(SimpleColor, spec["foreground"])
-         elseif haskey(spec, "fg") && spec["fg"] isa String
-             tryparse(SimpleColor, spec["fg"])
-         end,
-         if haskey(spec, "background") && spec["background"] isa String
-             tryparse(SimpleColor, spec["background"])
-         elseif haskey(spec, "bg") && spec["bg"] isa String
-             tryparse(SimpleColor, spec["bg"])
-         end,
-         if !haskey(spec, "underline")
-         elseif spec["underline"] isa Bool
-             spec["underline"]
-         elseif spec["underline"] isa String
-             tryparse(SimpleColor, spec["underline"])
-         elseif spec["underline"] isa Vector && length(spec["underline"]) == 2
-             color = tryparse(SimpleColor, spec["underline"][1])
-             (color, Symbol(spec["underline"][2]))
-         end,
-         if !haskey(spec, "strikethrough")
-         elseif spec["strikethrough"] isa Bool
-             spec["strikethrough"]
-         elseif spec["strikethrough"] isa String
-             tryparse(SimpleColor, spec["strikethrough"])
-         end,
-         if haskey(spec, "inverse") && spec["inverse"] isa Bool
-             spec["inverse"] end,
-         if !haskey(spec, "inherit")
-             Symbol[]
-         elseif spec["inherit"] isa String
-             [Symbol(spec["inherit"])]
-         elseif spec["inherit"] isa Vector{String}
-             Symbol.(spec["inherit"])
-         else
-             Symbol[]
-         end)
-end
-
-## Style macro ##
-
-"""
-    @S_str -> StyledString
-
-Construct a styled string. Within the string, `{<specs>:<content>}` structures
-apply the formatting to `<content>`, according to the list of comma-separated
-specifications `<specs>`. Each spec can either take the form of a face name,
-an inline face specification, or a `key=value` pair. The value must be wrapped
-by `{...}` should it contain any of the characters `,=:{}`.
-
-String interpolation with `\$` functions in the same way as regular strings,
-except quotes need to be escaped. Faces, keys, and values can also be
-interpolated with `\$`.
-
-# Example
-
-```julia
-S"The {bold:{italic:quick} {(foreground=#cd853f):brown} fox} jumped over \
-the {link={https://en.wikipedia.org/wiki/Laziness}:lazy} dog"
-```
-
-# Extended help
-
-This macro can be described by the following EBNF grammar:
-
-```ebnf
-styledstring = { styled | interpolated | escaped | plain } ;
-
-specialchar = '{' | '}' | '\$' | '\\\"' ;
-anychar = [\u0-\u1fffff] ;
-plain = { anychar - specialchar } ;
-escaped = '\\\\', specialchar ;
-
-interpolated = '\$', ? expr ? | '\$(', ? expr ?, ')' ;
-
-styled = '{', ws, properties, ':', content, '}' ;
-content = { interpolated | escaped | plain | styled } ;
-properties = property | properties, ws, ',', ws, property
-property = face | inlineface | keyvalue ;
-ws = { ' ' | '\\t' | '\\n' } ; (* whitespace *)
-
-face = facename | interpolated ;
-facename = [A-Za-z0-9_]+ ;
-
-inlineface = '(', ws, [ faceprop ], { ws, ',', faceprop }, ws, ')' ;
-faceprop = [a-z]+, ws, '=', ws, ( [^,)]+ | interpolated) ;
-
-keyvalue = key, ws, '=', ws, value ;
-key = ( [^\${}=,:], [^=,:]* ) | interpolated ;
-value = simplevalue | curlybraced | interpolated ;
-curlybraced = '{' { escaped | plain } '}' ;
-simplevalue = [^\${},:], [^,:]* ;
-```
-
-The above grammar for `inlineface` is simplified, as the actual implementation
-is a bit more sophisticated. The full behaviour is given below.
-
-```ebnf
-faceprop = ( 'face', ws, '=', ws, ( ? string ? | interpolated ) ) |
-           ( 'height', ws, '=', ws, ( ? number ? | interpolated ) ) |
-           ( 'weight', ws, '=', ws, ( symbol | interpolated ) ) |
-           ( 'slant', ws, '=', ws, ( symbol | interpolated ) ) |
-           ( ( 'foreground' | 'fg' | 'background' | 'bg' ),
-               ws, '=', ws, ( simplecolor | interpolated ) ) |
-           ( 'underline', ws, '=', ws, ( underline | interpolated ) ) |
-           ( 'strikethrough', ws, '=', ws, ( bool | interpolated ) ) |
-           ( 'inverse', ws, '=', ws, ( bool | interpolated ) ) |
-           ( 'inherit', ws, '=', ws, ( inherit | interpolated ) ) ;
-
-nothing = 'nothing' ;
-bool = 'true' | 'false' ;
-symbol = [^ ,)]+ ;
-hexcolor = ('#' | '0x'), [0-9a-f]{6} ;
-simplecolor = hexcolor | symbol | nothing ;
-
-underline = nothing | bool | simplecolor | underlinestyled;
-underlinestyled = '(', whitespace, ('' | nothing | simplecolor), whitespace,
-                  ',', whitespace, symbol, whitespace ')' ;
-
-inherit = ( '[', inheritval, { ',', inheritval }, ']' ) | inheritval;
-inheritval = whitespace, ':'?, symbol ;
-```
-"""
-macro S_str(raw_content::String)
-    #------------------
-    # Helper functions
-    #------------------
-
-    # If this were a module, I'd define the following struct.
-
-    #= struct State
-    content::String         # the (unescaped) input string
-    bytes::Vector{UInt8}    # bytes of `content`
-    s::Iterators.Stateful   # (index, char) interator of `content`
-    parts::Vector{Any}      # the final result
-    active_styles::Vector{  # unterminated batches of styles
-    Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}}
-    pending_styles::Vector{ # terminated styles that have yet to be applied
-    Tuple{UnitRange{Int}, Union{Symbol, Expr, Pair{Symbol, Any}}}}
-    offset::Ref{Int}        # drift in the `content` index as structures are absorbed
-    point::Ref{Int}         # current index in `content`
-    escape::Ref{Bool}       # whether the last char was an escape char
-    interpolated::Ref{Bool} # whether any string interpolation occurs
-    end =#
-
-    # Instead we'll just use a `NamedTuple`
-    state = let content = unescape_string(raw_content, ('{', '}', '$', '\n'))
-        (; content, bytes = Vector{UInt8}(content),
-         s = Iterators.Stateful(zip(eachindex(content), content)),
-         parts = Any[],
-         active_styles = Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}[],
-         pending_styles = Tuple{UnitRange{Int}, Union{Symbol, Expr, Pair{Symbol, Any}}}[],
-         offset = Ref(0), point = Ref(1), escape = Ref(false), interpolated = Ref(false))
-    end
-
-    # Value restrictions we can check against
-    valid_weights = ("thin", "extralight", "light", "semilight", "normal",
-                     "medium", "semibold", "bold", "extrabold", "black")
-    valid_slants = ("italic", "oblique", "normal")
-    valid_underline_styles = ("straight", "double", "curly", "dotted", "dashed")
-    valid_colornames =
-        ("black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
-         "grey", "gray", "bright_black", "bright_red", "bright_green", "bright_yellow",
-         "bright_blue", "bright_magenta", "bright_cyan", "bright_white")
-
-    function stywarn(state, message::String)
-        println(stderr, "WARNING: Styled string macro in module ", __module__,
-                " at ", something(__source__.file, ""),
-                ':', string(__source__.line),
-                something(if !isempty(state.s)
-                              i, chr = peek(state.s)
-                              " (just before '$chr' [$i])"
-                          end, ""),
-                ", ", message, '.')
-    end
-
-    function addpart!(state, stop::Int)
-        if state.point[] > stop+state.offset[]+ncodeunits(state.content[stop])-1
-            return state.point[] = nextind(state.content, stop) + state.offset[]
-        end
-        str = String(state.bytes[
-            state.point[]:stop+state.offset[]+ncodeunits(state.content[stop])-1])
-        push!(state.parts,
-              if isempty(state.pending_styles) && isempty(state.active_styles)
-                  str
-              else
-                  styles = Expr[]
-                  relevant_styles = Iterators.filter(
-                      (start, _)::Tuple -> start <= stop + state.offset[] + 1,
-                      Iterators.flatten(state.active_styles))
-                  for (start, prop) in relevant_styles
-                      range = (start - state.point[]):(stop - state.point[] + state.offset[] + 1)
-                      push!(styles, Expr(:tuple, range, prop))
-                  end
-                  sort!(state.pending_styles, by = first)
-                  for (range, prop) in state.pending_styles
-                      if !isempty(range)
-                          push!(styles, Expr(:tuple, range .- state.point[], prop))
-                      end
-                  end
-                  empty!(state.pending_styles)
-                  if isempty(styles)
-                      str
-                  else
-                      :($StyledString($str, $(Expr(:vect, styles...))))
-                  end
-              end)
-        state.point[] = nextind(state.content, stop) + state.offset[]
-    end
-
-    function addpart!(state, start::Int, expr, stop::Int)
-        if state.point[] < start
-            addpart!(state, start)
-        end
-        if isempty(state.active_styles)
-            push!(state.parts, expr)
-        else
-            push!(state.parts,
-                  :($StyledString(string($expr),
-                                  $(last.(Iterators.flatten(state.active_styles))...))))
-            map!.((_, prop)::Tuple -> (stop + state.offset[] + 1, prop),
-                  state.active_styles, state.active_styles)
-        end
-    end
-
-    function escaped!(state, i, char)
-        if char in ('{', '}', '$', '\\')
-            deleteat!(state.bytes, i + state.offset[] - 1)
-            state.offset[] -= ncodeunits('\\')
-        elseif char == '\n'
-            deleteat!(state.bytes, i+state.offset[]-1:i+state.offset[])
-            state.offset[] -= ncodeunits("\\\n")
-        end
-        state.escape[] = false
-    end
-
-    function interpolated!(state, i, _)
-        expr, nexti = readexpr!(state, i + ncodeunits('$'))
-        deleteat!(state.bytes, i + state.offset[])
-        state.offset[] -= ncodeunits('$')
-        addpart!(state, i, expr, nexti)
-        state.point[] = nexti + state.offset[]
-        state.interpolated[] = true
-    end
-
-    function readexpr!(state, pos::Int)
-        expr, nextpos = Meta.parseatom(state.content, pos)
-        nchars = length(state.content[pos:prevind(state.content, nextpos)])
-        for _ in 1:min(length(state.s), nchars)
-            popfirst!(state.s)
-        end
-        expr, nextpos
-    end
-
-    readexpr!(state) = readexpr!(state, first(popfirst!(state.s)) + 1)
-
-    function skipwhitespace!(state)
-        isempty(state.s) && return
-        while last(peek(state.s)) ∈ (' ', '\t', '\n')
-            popfirst!(state.s)
-        end
-    end
-
-    function begin_style!(state, i, char)
-        hasvalue = false
-        newstyles = Vector{Tuple{Int, Union{Symbol, Expr, Pair{Symbol, Any}}}}()
-        while read_property!(state, i, char, newstyles) end
-        push!(state.active_styles, newstyles)
-        # Adjust bytes/offset based on how much the index
-        # has been incremented in the processing of the
-        # style declaration(s).
-        if !isempty(state.s)
-            nexti = first(peek(state.s))
-            deleteat!(state.bytes, i+state.offset[]:nexti+state.offset[]-1)
-            state.offset[] -= nexti - i
-        end
-    end
-
-    function end_style!(state, i, char)
-        # Close off most recent active style
-        for (start, prop) in pop!(state.active_styles)
-            push!(state.pending_styles, (start:i+state.offset[], prop))
-        end
-        deleteat!(state.bytes, i + state.offset[])
-        state.offset[] -= ncodeunits('}')
-    end
-
-    function read_property!(state, i, char, newstyles)
-        skipwhitespace!(state)
-        isempty(state.s) && return false
-        nextchar = last(peek(state.s))
-        if nextchar == ':'
-            popfirst!(state.s)
-            return false
-        elseif nextchar == '('
-            read_inlineface!(state, i, char, newstyles)
-        else
-            read_face_or_keyval!(state, i, char, newstyles)
-        end
-        isempty(state.s) && return false
-        nextchar = last(peek(state.s))
-        if nextchar == ','
-            popfirst!(state.s)
-            true
-        elseif nextchar == ':'
-            true
-        elseif nextchar ∈ (' ', '\t', '\n')
-            skipwhitespace!(state)
-            true
-        else
-            stywarn(state, "malformed styled string construct")
-            false
-        end
-    end
-
-    function read_inlineface!(state, i, char, newstyles)
-        # Substructure parsing helper functions
-        function readalph!(state, lastchar)
-            Iterators.takewhile(
-                c -> 'a' <= (lastchar = last(c)) <= 'z', state.s) |>
-                    collect .|> last |> String, lastchar
-        end
-        function readsymbol!(state, lastchar)
-            Iterators.takewhile(
-                c -> (lastchar = last(c)) ∉ (' ', '\t', '\n', ',', ')'), state.s) |>
-                    collect .|> last |> String, lastchar
-        end
-        function parsecolor(color::String)
-            if color == "nothing"
-            elseif startswith(color, '#') && length(color) == 7
-                tryparse(SimpleColor, color)
-            elseif startswith(color, "0x") && length(color) == 8
-                tryparse(SimpleColor, '#' * color[3:end])
-            else
-                color ∈ valid_colornames ||
-                    stywarn(state, "unrecognised named color '$color' (should be $(join(valid_colornames, ", ", ", or ")))")
-                SimpleColor(Symbol(color))
-            end
-        end
-        function nextnonwhitespace!(state, lastchar)
-            if lastchar ∈ (' ', '\t', '\n')
-                skipwhitespace!(state)
-                _, lastchar = popfirst!(state.s)
-            end
-            lastchar
-        end
-        function read_underline!(state, lastchar)
-            if last(peek(state.s)) == '('
-                popfirst!(state.s)
-                skipwhitespace!(state)
-                ucolor_str, ucolor = if last(peek(state.s)) == ','
-                    lastchar = last(popfirst!(state.s))
-                    "", nothing
-                else
-                    word, lastchar = readsymbol!(state, lastchar)
-                    word, parsecolor(word)
-                end
-                lastchar = nextnonwhitespace!(state, lastchar)
-                if !isempty(state) && lastchar == ','
-                    skipwhitespace!(state)
-                    ustyle, lastchar = readalph!(state, lastchar)
-                    lastchar = nextnonwhitespace!(state, lastchar)
-                    if lastchar == ')'
-                        lastchar = last(popfirst!(state.s))
-                    else
-                        stywarn(state, "malformed underline value, should be (<color>, <style>)")
-                    end
-                else
-                    stywarn(state, "malformed underline value, should be (<color>, <style>)")
-                    ustyle = "straight"
-                end
-                ustyle ∈ valid_underline_styles ||
-                    stywarn(state, "unrecognised underline style '$ustyle' (should be $(join(valid_underline_styles, ", ", ", or ")))")
-                Expr(:tuple, ucolor, QuoteNode(Symbol(ustyle)))
-            else
-                word, lastchar = readsymbol!(state, lastchar)
-                if word ∈ ("", "nothing")
-                elseif word == "true"
-                    true
-                elseif word == "false"
-                    false
-                else
-                    parsecolor(word)
-                end
-            end, lastchar
-        end
-        function read_inherit!(state, lastchar)
-            inherit = Symbol[]
-            if last(peek(state.s)) == ':'
-                popfirst!(state.s)
-                facename, lastchar = readsymbol!(state, lastchar)
-                push!(inherit, Symbol(facename))
-            elseif last(peek(state.s)) == '['
-                popfirst!(state.s)
-                readvec = true
-                while readvec
-                    skipwhitespace!(state)
-                    nextchar = last(peek(state.s))
-                    if nextchar == ':'
-                        popfirst!(state.s)
-                    elseif nextchar == ']'
-                        popfirst!(state.s)
-                        lastchar = last(popfirst!(state.s))
-                        break
-                    end
-                    facename = Iterators.takewhile(
-                        c -> (lastchar = last(c)) ∉ (',', ']', ')'), state.s) |>
-                            collect .|> last |> String
-                    push!(inherit, Symbol(rstrip(facename)))
-                    if lastchar != ','
-                        break
-                    end
-                end
-            else
-                facename = Iterators.takewhile(
-                    c -> (lastchar = last(c)) ∉ (',', ']', ')'), state.s) |>
-                        collect .|> last |> String
-                push!(inherit, Symbol(rstrip(facename)))
-            end
-            inherit, lastchar
-        end
-        # Get on with the parsing now
-        popfirst!(state.s)
-        kwargs = Expr[]
-        needseval = false
-        lastchar = '('
-        while !isempty(state.s) && lastchar != ')'
-            skipwhitespace!(state)
-            str_key, lastchar = readalph!(state, lastchar)
-            key = Symbol(str_key)
-            # Check for '=', and skip over surrounding whitespace
-            if lastchar != '='
-                skipwhitespace!(state)
-                isempty(state.s) && break
-                last(peek(state.s)) == '=' || break
-                popfirst!(state.s)
-            end
-            skipwhitespace!(state)
-            isempty(state.s) && break
-            # Aliases
-            key == :fg && (key = :foreground)
-            key == :bg && (key = :background)
-            # Parse value
-            val = if (nextchar = last(peek(state.s))) == '$'
-                expr, _ = readexpr!(state)
-                lastchar = last(popfirst!(state.s))
-                state.interpolated[] = true
-                needseval = true
-                expr
-            elseif key == :face
-                if nextchar == '"'
-                    first(readexpr!(state, first(peek(state.s))))
-                else
-                    Iterators.takewhile(
-                        c -> (lastchar = last(c)) ∉ (',', ')'), state.s) |>
-                            collect .|> last |> String
-                end
-            elseif key == :height
-                if nextchar == '.' || nextchar ∈ '0':'9'
-                    num = first(readexpr!(state, first(peek(state.s))))
-                    lastchar = last(popfirst!(state.s))
-                    ifelse(num isa Number, num, nothing)
-                else
-                    invalid, lastchar = readsymbol!(state, lastchar)
-                    stywarn(state, "invalid height $invalid, should be a natural number or positive float")
-                end
-            elseif key ∈ (:weight, :slant)
-                v, lastchar = readalph!(state, lastchar)
-                if key == :weight && v ∉ valid_weights
-                    stywarn(state, "unrecognised weight '$v' (should be $(join(valid_weights, ", ", ", or ")))")
-                elseif key == :slant && v ∉ valid_slants
-                    stywarn(state, "unrecognised slant '$v' (should be $(join(valid_slants, ", ", ", or ")))")
-                end
-                Symbol(v) |> QuoteNode
-            elseif key ∈ (:foreground, :background)
-                color, lastchar = readsymbol!(state, lastchar)
-                parsecolor(color)
-            elseif key ∈ (:strikethrough, :inverse)
-                flag, lastchar = readalph!(state, lastchar)
-                if flag == "true"
-                    true
-                elseif flag == "false"
-                    false
-                end
-            elseif key == :underline
-                ul, lastchar = read_underline!(state, lastchar)
-                ul
-            elseif key == :inherit
-                inherit, lastchar = read_inherit!(state, lastchar)
-                inherit
-            else
-                stywarn(state, "uses unrecognised face key '$key'")
-            end
-            if !any(k -> first(k.args) == key, kwargs)
-                push!(kwargs, Expr(:kw, key, val))
-            else
-                stywarn(state, "contains repeated face key '$key'")
-            end
-            isempty(state.s) || last(peek(state.s)) != ',' || break
-        end
-        face = Expr(:call, Face, kwargs...)
-        push!(newstyles,
-              (i + state.offset[] + 1,
-               if needseval
-                   :(Pair{Symbol, Any}(:face, $face))
-               else
-                   Pair{Symbol, Any}(:face, eval(face))
-               end))
-    end
-
-    function read_face_or_keyval!(state, i, char, newstyles)
-        function read_curlywrapped!(state)
-            popfirst!(state.s) # first '{'
-            chars = Char[]
-            escaped = false
-            while !isempty(state.s)
-                _, c = popfirst!(state.s)
-                if escaped && c ∈ ('\\', '{', '}', '$')
-                    push!(chars, c)
-                    escaped = false
-                elseif escaped
-                    push!(chars, '\\', c)
-                    escaped = false
-                elseif c == '\\'
-                    escaped = true
-                elseif c == '}'
-                    break
-                else
-                    push!(chars, c)
-                end
-            end
-            String(chars)
-        end
-        # this isn't the 'last' char yet, but it will be
-        key = if last(peek(state.s)) == '$'
-            expr, _ = readexpr!(state)
-            state.interpolated[] = true
-            needseval = true
-            expr
-        else
-            chars = Char[]
-            while (next = peek(state.s)) |> !isnothing && last(next) ∉ (',', '=', ':')
-                popfirst!(state.s)
-                push!(chars, last(next))
-            end
-            String(chars)
-        end
-        skipwhitespace!(state)
-        if isempty(state.s)
-        elseif last(peek(state.s)) == '='
-            popfirst!(state.s)
-            nextchar = last(peek(state.s))
-            if nextchar ∈ (' ', '\t', '\n')
-                skipwhitespace!(state)
-                nextchar = last(peek(state.s))
-            end
-            value = if isempty(state.s) ""
-            elseif nextchar == '{'
-                read_curlywrapped!(state)
-            elseif nextchar == '$'
-                expr, _ = readexpr!(state)
-                state.interpolated[] = true
-                needseval = true
-                expr
-            else
-                chars = Char[]
-                while (next = peek(state.s)) |> !isnothing && last(next) ∉ (',', ':')
-                    popfirst!(state.s)
-                    push!(chars, last(next))
-                end
-                String(chars)
-            end
-            push!(newstyles,
-                  (i + state.offset[] + ncodeunits('{'),
-                   if key isa String && !(value isa Symbol || value isa Expr)
-                       Pair{Symbol, Any}(Symbol(key), value)
-                   elseif key isa Expr || key isa Symbol
-                       :(Pair{Symbol, Any}($key, $value))
-                   else
-                       :(Pair{Symbol, Any}(
-                           $(QuoteNode(Symbol(key))), $value))
-                   end))
-        elseif key !== ""
-            push!(newstyles,
-                  (i + state.offset[] + ncodeunits('{'),
-                   if key isa Symbol || key isa Expr
-                       :(Pair{Symbol, Any}(:face, $key))
-                   else # Face symbol
-                       Pair{Symbol, Any}(:face, Symbol(key))
-                   end))
-        end
-    end
-
-    function run_state_machine!(state)
-        # Run the state machine
-        for (i, char) in state.s
-            if char == '\\'
-                state.escape[] = true
-            elseif state.escape[]
-                escaped!(state, i, char)
-            elseif char == '$'
-                interpolated!(state, i, char)
-            elseif char == '{'
-                begin_style!(state, i, char)
-            elseif char == '}' && !isempty(state.active_styles)
-                end_style!(state, i, char)
-            end
-        end
-        # Ensure that any trailing unstyled content is added
-        if state.point[] <= lastindex(state.content) + state.offset[]
-            addpart!(state, lastindex(state.content))
-        end
-        if !isempty(state.active_styles)
-            stywarn(state, "contains unterminated styled constructs")
-        end
-    end
-
-    #------------------
-    # The actual body of the macro
-    #------------------
-
-    run_state_machine!(state)
-    if state.interpolated[]
-        :($styledstring($(state.parts...))) |> esc
-    else
-        styledstring(map(eval, state.parts)...) |> styledstring_optimize!
-    end
-end
diff --git a/base/strings/io.jl b/base/strings/io.jl
index 8f1ae565243dd..7f762b75473ff 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -353,9 +353,31 @@ function join(io::IO, iterator, delim="")
     end
 end
 
-join(iterator) = sprint(join, iterator)
-join(iterator, delim) = sprint(join, iterator, delim)
-join(iterator, delim, last) = sprint(join, iterator, delim, last)
+# TODO: If/when we have `TaggedIO`, we can revisit this and
+# implement it more nicely.
+function join_tagged(iterator, delim="", last=delim)
+    xs = zip(iterator, Iterators.repeated(delim)) |> Iterators.flatten |> collect
+    xs = xs[1:end-1]
+    if length(xs) > 1
+        xs[end-1] = last
+    end
+    taggedstring(xs...)::TaggedString{String}
+end
+
+function _join_maybe_tagged(args...)
+    if any(function (arg)
+               t = eltype(arg)
+               !(t == Union{}) && (t <: TaggedString || t <: TaggedChar)
+           end, args)
+        join_tagged(args...)
+    else
+        sprint(join, args...)
+    end
+end
+
+join(iterator) = _join_maybe_tagged(iterator)
+join(iterator, delim) = _join_maybe_tagged(iterator, delim)
+join(iterator, delim, last) = _join_maybe_tagged(iterator, delim, last)
 
 ## string escaping & unescaping ##
 
@@ -765,8 +787,8 @@ function String(chars::AbstractVector{<:AbstractChar})
     end
 end
 
-function StyledString(chars::AbstractVector{C}) where {C<:AbstractChar}
-    str = if C <: StyledChar
+function TaggedString(chars::AbstractVector{C}) where {C<:AbstractChar}
+    str = if C <: TaggedChar
         String(getfield.(chars, :char))
     else
         sprint(sizehint=length(chars)) do io
@@ -778,459 +800,12 @@ function StyledString(chars::AbstractVector{C}) where {C<:AbstractChar}
     props = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
     point = 1
     for c in chars
-        if c isa StyledChar
+        if c isa TaggedChar
             for prop in c.properties
                 push!(props, (point:point, prop))
             end
         end
         point += ncodeunits(c)
     end
-    StyledString(str, props)
-end
-
-## Styled printing ##
-
-"""
-A mapping between ANSI named colours and indices in the standard 256-color
-table. The standard colors are 0-7, and high intensity colors 8-15.
-
-The high intensity colors are prefixed by "bright_". The "bright_black" color is
-given two aliases: "grey" and "gray".
-"""
-const ANSI_4BIT_COLORS = Dict{Symbol, Int}(
-    :black => 0,
-    :red => 1,
-    :green => 2,
-    :yellow => 3,
-    :blue => 4,
-    :magenta => 5,
-    :cyan => 6,
-    :white => 7,
-    :bright_black => 8,
-    :grey => 8,
-    :gray => 8,
-    :bright_red => 9,
-    :bright_green => 10,
-    :bright_yellow => 11,
-    :bright_blue => 12,
-    :bright_magenta => 13,
-    :bright_cyan => 14,
-    :bright_white => 15)
-
-"""
-    ansi_4bit_color_code(color::Symbol, background::Bool=false)
-
-Provide the color code (30-37, 40-47, 90-97, 100-107) for `color`, as a string.
-When `background` is set the background variant will be provided, otherwise
-the provided code is for setting the foreground color.
-"""
-function ansi_4bit_color_code(color::Symbol, background::Bool=false)
-    if haskey(ANSI_4BIT_COLORS, color)
-        code = ANSI_4BIT_COLORS[color]
-        code >= 8 && (code += 52)
-        background && (code += 10)
-        string(code + 30)
-    else
-        ifelse(background, "49", "39")
-    end
-end
-
-"""
-    termcolor8bit(io::IO, color::RGBTuple, category::Char)
-
-Print to `io` the best 8-bit SGR color code that sets the `category` color to
-be close to `color`.
-"""
-function termcolor8bit(io::IO, (; r, g, b)::RGBTuple, category::Char)
-    # Magic numbers? Lots.
-    cdistsq(r1, g1, b1) = (r1 - r)^2 + (g1 - g)^2 + (b1 - b)^2
-    to6cube(value) = if value < 48; 1
-    elseif value < 114; 2
-    else 1 + (value - 35) ÷ 40 end
-    r6cube, g6cube, b6cube = to6cube(r), to6cube(g), to6cube(b)
-    sixcube = (0, 95, 135, 175, 215, 255)
-    rnear, gnear, bnear = sixcube[r6cube], sixcube[g6cube], sixcube[b6cube]
-    colorcode = if r == rnear && g == gnear && b == bnear
-        16 + 35 * r6cube + 6 * g6cube + b6cube
-    else
-        grey_avg = Int(r + g + b) ÷ 3
-        grey_index = if grey_avg > 238 23 else (grey_avg - 3) ÷ 10 end
-        grey = 8 + 10 * grey_index
-        if cdistsq(grey, grey, grey) <= cdistsq(rnear, gnear, bnear)
-            232 + grey
-        else
-            16 + 35 * r6cube + 6 * g6cube + b6cube
-        end
-    end
-    print(io, "\e[", category, "8;5;", string(colorcode), 'm')
-end
-
-"""
-    termcolor24bit(io::IO, color::RGBTuple, category::Char)
-
-Print to `io` the 24-bit SGR color code to set the `category`8 slot to `color`.
-"""
-function termcolor24bit(io::IO, color::RGBTuple, category::Char)
-    print(io, "\e[", category, "8;2;",
-          string(color.r), ';',
-          string(color.g), ';',
-          string(color.b), 'm')
-end
-
-"""
-    termcolor(io::IO, color::SimpleColor, category::Char)
-
-Print to `io` the SGR code to set the `category`'s slot to `color`,
-where `category` is set as follows:
-- `'3'` sets the foreground color
-- `'4'` sets the background color
-- `'5'` sets the underline color
-
-If `color` is a `SimpleColor{Symbol}`, the value should be a a member of
-`ANSI_4BIT_COLORS`. Any other value will cause the color to be reset.
-
-If `color` is a `SimpleColor{RGBTuple}` and `get_have_truecolor()` returns true,
-24-bit color is used. Otherwise, an 8-bit approximation of `color` is used.
-"""
-function termcolor(io::IO, color::SimpleColor, category::Char)
-    if color.value isa RGBTuple
-        if get_have_truecolor()
-            termcolor24bit(io, color.value, category)
-        else
-            termcolor8bit(io, color.value, category)
-        end
-    elseif (fg = get(FACES.current[], color.value, getface()).foreground) != SimpleColor(color.value)
-        termcolor(io, fg, category)
-    else
-        print(io, "\e[",
-              if category == '3' || category == '4'
-                  ansi_4bit_color_code(color.value, category == '4')
-              elseif category == '5'
-                  if haskey(ANSI_4BIT_COLORS, color.value)
-                      string("58;5;", ANSI_4BIT_COLORS[color.value])
-                  else "59" end
-              end,
-              'm')
-    end
-end
-
-"""
-    termcolor(io::IO, ::Nothing, category::Char)
-
-Print to `io` the SGR code to reset the color for `category`.
-"""
-termcolor(io::IO, ::Nothing, category::Char) =
-    print(io, "\e[", category, '9', 'm')
-
-const ANSI_STYLE_CODES = (
-    bold_weight = "\e[1m",
-    dim_weight = "\e[2m",
-    normal_weight = "\e[22m",
-    start_italics = "\e[3m",
-    end_italics = "\e[23m",
-    start_underline = "\e[4m",
-    end_underline = "\e[24m",
-    start_reverse = "\e[7m",
-    end_reverse = "\e[27m",
-    start_strikethrough = "\e[9m",
-    end_strikethrough = "\e[29m"
-)
-
-function termstyle(io::IO, face::Face, lastface::Face=getface())
-    face.foreground == lastface.foreground ||
-        termcolor(io, face.foreground, '3')
-    face.background == lastface.background ||
-        termcolor(io, face.background, '4')
-    face.weight == lastface.weight ||
-        print(io, if face.weight ∈ (:medium, :semibold, :bold, :extrabold, :black)
-                  get(current_terminfo, :bold, "\e[1m")
-              elseif face.weight ∈ (:semilight, :light, :extralight, :thin)
-                  get(current_terminfo, :dim, "")
-              else # :normal
-                  ANSI_STYLE_CODES.normal_weight
-              end)
-    face.slant == lastface.slant ||
-        if haskey(current_terminfo, :enter_italics_mode)
-            print(io, ifelse(face.slant ∈ (:italic, :oblique),
-                             ANSI_STYLE_CODES.start_italics,
-                             ANSI_STYLE_CODES.end_italics))
-        elseif face.slant ∈ (:italic, :oblique) && face.underline ∈ (nothing, false)
-            print(io, ANSI_STYLE_CODES.start_underline)
-        elseif face.slant ∉ (:italic, :oblique) && lastface.underline ∈ (nothing, false)
-            print(io, ANSI_STYLE_CODES.end_underline)
-        end
-    # Kitty fancy underlines, see <https://sw.kovidgoyal.net/kitty/underlines>
-    # Supported in Kitty, VTE, iTerm2, Alacritty, and Wezterm.
-    face.underline == lastface.underline ||
-        if get(current_terminfo, :Su, false) # Color/style capabilities
-            if face.underline isa Tuple # Color and style
-                color, style = face.underline
-                print(io, "\e[4:",
-                        if style == :straight;   '1'
-                        elseif style == :double; '2'
-                        elseif style == :curly;  '3'
-                        elseif style == :dotted; '4'
-                        elseif style == :dashed; '5'
-                        else '0' end, 'm')
-                !isnothing(color) && termcolor(io, color, '5')
-            elseif face.underline isa SimpleColor
-                if !(lastface.underline isa SimpleColor || lastface.underline == true)
-                    print(io, ANSI_STYLE_CODES.start_underline)
-                end
-                termcolor(io, face.underline, '5')
-            else
-                if lastface.underline isa SimpleColor || lastface.underline isa Tuple && first(lastface.underline) isa SimpleColor
-                    termcolor(io, SimpleColor(:none), '5')
-                end
-                print(io, ifelse(face.underline == true,
-                                ANSI_STYLE_CODES.start_underline,
-                                ANSI_STYLE_CODES.end_underline))
-            end
-        else
-            print(io, ifelse(face.underline !== false,
-                             ANSI_STYLE_CODES.start_underline,
-                             ANSI_STYLE_CODES.end_underline))
-        end
-    face.strikethrough == lastface.strikethrough || !haskey(current_terminfo, :smxx) ||
-        print(io, ifelse(face.strikethrough === true,
-                         ANSI_STYLE_CODES.start_strikethrough,
-                         ANSI_STYLE_CODES.end_strikethrough))
-    face.inverse == lastface.inverse || !haskey(current_terminfo, :enter_reverse_mode) ||
-        print(io, ifelse(face.inverse === true,
-                         ANSI_STYLE_CODES.start_reverse,
-                         ANSI_STYLE_CODES.end_reverse))
-end
-
-function _ansi_writer(io::IO, s::Union{<:StyledString, SubString{<:StyledString}},
-                      string_writer::Function)
-    if get(io, :color, false)::Bool
-        buf = IOBuffer() # Avoid the overhead in repeatadly printing to `stdout`
-        lastface::Face = FACES.current[][:default]
-        for (str, styles) in eachstyle(s)
-            face = getface(styles)
-            link = let idx=findfirst(==(:link) ∘ first, styles)
-                if !isnothing(idx)
-                    string(last(styles[idx]))::String
-                end end
-            !isnothing(link) && write(buf, "\e]8;;", link, "\e\\")
-            termstyle(buf, face, lastface)
-            string_writer(buf, str)
-            !isnothing(link) && write(buf, "\e]8;;\e\\")
-            lastface = face
-        end
-        termstyle(buf, getface(), lastface)
-        write(io, take!(buf))
-    elseif s isa StyledString
-        string_writer(io, s.string)
-    elseif s isa SubString
-        string_writer(
-            io, SubString(s.string.string, s.offset, s.ncodeunits, Val(:noshift)))
-    end
-end
-
-write(io::IO, s::Union{<:StyledString, SubString{<:StyledString}}) =
-    _ansi_writer(io, s, write)
-
-print(io::IO, s::Union{<:StyledString, SubString{<:StyledString}}) =
-    (write(io, s); nothing)
-
-escape_string(io::IO, s::Union{<:StyledString, SubString{<:StyledString}},
-              esc = ""; keep = ()) =
-    (_ansi_writer(io, s, (io, s) -> escape_string(io, s, esc; keep)); nothing)
-
-function write(io::IO, c::StyledChar)
-    if get(io, :color, false) == true
-        termstyle(io, getface(c), getface())
-        print(io, c.char)
-        termstyle(io, getface(), getface(c))
-    else
-        print(io, c.char)
-    end
-end
-
-print(io::IO, c::StyledChar) = (write(io, c); nothing)
-
-function show(io::IO, c::StyledChar)
-    if get(io, :color, false) == true
-        out = IOBuffer()
-        show(out, c.char)
-        print(io, ''', StyledString(String(take!(out)[2:end-1]), c.properties), ''')
-    else
-        show(io, c.char)
-    end
-end
-
-"""
-A mapping between ANSI named colors and 8-bit colors for use in HTML
-representations.
-"""
-const HTML_BASIC_COLORS = Dict{Symbol, SimpleColor}(
-    :black => SimpleColor(0x00, 0x00, 0x00),
-    :red => SimpleColor(0x80, 0x00, 0x00),
-    :green => SimpleColor(0x00, 0x80, 0x00),
-    :yellow => SimpleColor(0x80, 0x80, 0x00),
-    :blue => SimpleColor(0x00, 0x00, 0x80),
-    :magenta => SimpleColor(0x80, 0x00, 0x80),
-    :cyan => SimpleColor(0x00, 0x80, 0x80),
-    :white => SimpleColor(0xc0, 0xc0, 0xc0),
-    :bright_black => SimpleColor(0x80, 0x80, 0x80),
-    :grey => SimpleColor(0x80, 0x80, 0x80),
-    :gray => SimpleColor(0x80, 0x80, 0x80),
-    :bright_red => SimpleColor(0xff, 0x00, 0x00),
-    :bright_green => SimpleColor(0x00, 0xff, 0x00),
-    :bright_yellow => SimpleColor(0xff, 0xff, 0x00),
-    :bright_blue => SimpleColor(0x00, 0x00, 0xff),
-    :bright_magenta => SimpleColor(0xff, 0x00, 0xff),
-    :bright_cyan => SimpleColor(0x00, 0xff, 0xff),
-    :bright_white => SimpleColor(0xff, 0xff, 0xff))
-
-function htmlcolor(io::IO, color::SimpleColor)
-    if color.value isa Symbol
-        if color.value === :default
-            print(io, "initial")
-        elseif (fg = get(FACES.current[], color.value, getface()).foreground) != SimpleColor(color.value)
-            htmlcolor(io, fg)
-        else
-            htmlcolor(io, get(HTML_BASIC_COLORS, color.value, SimpleColor(:default)))
-        end
-    else
-        (; r, g, b) = color.value
-        print(io, '#')
-        r < 0x10 && print(io, '0')
-        print(io, string(r, base=16))
-        g < 0x10 && print(io, '0')
-        print(io, string(g, base=16))
-        b < 0x10 && print(io, '0')
-        print(io, string(b, base=16))
-    end
-end
-
-const HTML_WEIGHT_MAP = Dict{Symbol, Int}(
-    :thin => 100,
-    :extralight => 200,
-    :light => 300,
-    :semilight => 300,
-    :normal => 400,
-    :medium => 500,
-    :semibold => 600,
-    :bold => 700,
-    :extrabold => 800,
-    :black => 900)
-
-function htmlstyle(io::IO, face::Face, lastface::Face=getface())
-    print(io, "<span style=\"")
-    face.font == lastface.font ||
-        print(io, "font-family: \"",
-              replace(face.font, '"' => "&quot;", ''' => "&#39;"), '"')
-    face.height == lastface.height ||
-        print(io, "font-size: ", string(face.height ÷ 10), "pt;")
-    face.weight == lastface.weight ||
-        print(io, "font-weight: ", get(HTML_WEIGHT_MAP, face.weight, 400), ';')
-    face.slant == lastface.slant ||
-        print(io, "font-style: ", String(face.slant), ';')
-    foreground, background =
-        ifelse(face.inverse === true,
-               (face.background, face.foreground),
-               (face.foreground, face.background))
-    lastforeground, lastbackground =
-        ifelse(lastface.inverse === true,
-               (lastface.background, lastface.foreground),
-               (lastface.foreground, lastface.background))
-    if foreground != lastforeground
-        print(io, "color: ")
-        htmlcolor(io, foreground)
-        print(io, ';')
-    end
-    if background != lastbackground
-        print(io, "background-color: ")
-        htmlcolor(io, background)
-        print(io, ';')
-    end
-    face.underline == lastface.underline ||
-        if face.underline isa Tuple # Color and style
-            color, style = face.underline
-            print(io, "text-decoration: ")
-            if !isnothing(color)
-                htmlcolor(io, color)
-                print(io, ' ')
-            end
-            print(io, if style == :straight "solid  "
-                  elseif style == :double   "double "
-                  elseif style == :curly    "wavy   "
-                  elseif style == :dotted   "dotted "
-                  elseif style == :dashed   "dashed "
-                  else "" end)
-            print(io, "underline;")
-        elseif face.underline isa SimpleColor
-            print(io, "text-decoration: ")
-            htmlcolor(io, face.underline)
-            if lastface.underline isa Tuple && last(lastface.underline) != :straight
-                print(io, " solid")
-            end
-            print(io, " underline;")
-        else # must be a Bool
-            print(io, "text-decoration: ")
-            if lastface.underline isa SimpleColor
-                print(io, "currentcolor ")
-            elseif lastface.underline isa Tuple
-                first(lastface.underline) isa SimpleColor &&
-                    print(io, "currentcolor ")
-                last(lastface.underline) != :straight &&
-                    print(io, "straight ")
-            end
-            print(io, ifelse(face.underline, "underline;", "none;"))
-        end
-    face.strikethrough == lastface.strikethrough ||
-        print(io, ifelse(face.strikethrough,
-                         "text-decoration: line-through",
-                         ifelse(face.underline === false,
-                                "text-decoration: none", "")))
-    print(io, "\">")
-end
-
-function show(io::IO, ::MIME"text/html", s::Union{<:StyledString, SubString{<:StyledString}}; wrap::Symbol=:pre)
-    htmlescape(str) = replace(str, '&' => "&amp;", '<' => "&lt;", '>' => "&gt;")
-    buf = IOBuffer() # Avoid potential overhead in repeatadly printing a more complex IO
-    wrap == :none ||
-        print(buf, '<', String(wrap), '>')
-    lastface::Face = getface()
-    stylestackdepth = 0
-    for (str, styles) in eachstyle(s)
-        face = getface(styles)
-        link = let idx=findfirst(==(:link) ∘ first, styles)
-            if !isnothing(idx)
-                string(last(styles[idx]))::String
-            end end
-        !isnothing(link) && print(buf, "<a href=\"", link, "\">")
-        if face == getface()
-            print(buf, "</span>" ^ stylestackdepth)
-            stylestackdepth = 0
-        elseif (lastface.inverse, lastface.foreground, lastface.background) !=
-            (face.inverse, face.foreground, face.background)
-            # We can't un-inherit colors well, so we just need to reset and apply
-            print(buf, "</span>" ^ stylestackdepth)
-            htmlstyle(buf, face, getface())
-            stylestackdepth = 1
-        else
-            htmlstyle(buf, face, lastface)
-            stylestackdepth += 1
-        end
-        if wrap == :p
-            newpara = false
-            for para in eachsplit(str, "\n\n")
-                newpara && print(buf, "</p>\n<p>")
-                print(buf, htmlescape(para))
-                newpara = true
-            end
-        else
-            print(buf, htmlescape(str))
-        end
-        !isnothing(link) && print(buf, "</a>")
-        lastface = face
-    end
-    print(buf, "</span>" ^ stylestackdepth)
-    wrap == :none ||
-        print(buf, "</", String(wrap), '>')
-    write(io, take!(buf))
-    nothing
+    TaggedString(str, props)
 end
diff --git a/base/strings/strings.jl b/base/strings/strings.jl
index 5e1e91b319b17..4d14cfbcf9891 100644
--- a/base/strings/strings.jl
+++ b/base/strings/strings.jl
@@ -1,7 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-include("strings/styled.jl")
-include("strings/faces.jl")
+include("strings/tagged.jl")
 include("strings/search.jl")
 include("strings/unicode.jl")
 
diff --git a/base/strings/styled.jl b/base/strings/styled.jl
deleted file mode 100644
index d1a6e58ece3c4..0000000000000
--- a/base/strings/styled.jl
+++ /dev/null
@@ -1,432 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-"""
-    StyledString{S <: AbstractString} <: AbstractString
-
-A string with annotated regions (often styling information).
-
-More specifically, this is a thin wrapper around any other [`AbstractString`](@ref),
-which adds arbitrary named annotations to regions of the wrapped string.
-
-See also [`StyledChar`](@ref), [`styledstring`](@ref), [`S""`](@ref @S_str), and [`Face`](@ref).
-
-# Constructors
-
-In most cases the easiest way to construct a `StyledString` is via the
-[`S""`](@ref @S_str) string macro (which see), however a number of constructors
-are also availible.
-
-```julia
-StyledString(s::S<:AbstractString) -> StyledString{S}
-StyledString(s::S<:AbstractString, props::Pair{Symbol, <:Any}...)
-StyledString(s::S<:AbstractString, properties::Vector{Tuple{UnitRange{Int}, Pair{Symbol, <:Any}}})
-```
-
-A StyledString can also be created with [`styledstring`](@ref), which acts much
-like [`string`](@ref) but preserves any styling present in the arguments.
-
-# Examples
-
-```jldoctest
-julia> StyledString("hello there", :face => :italic)
-"hello there"
-
-julia> StyledString("more text", :tag => 1)
-"more text"
-```
-"""
-struct StyledString{S <: AbstractString} <: AbstractString
-    string::S
-    properties::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
-end
-
-"""
-    StyledChar{S <: AbstractChar} <: AbstractChar
-
-A Char annotated by properties (often styling information).
-
-More specifically, this is a thin wrapper around any other [`AbstractChar`](@ref),
-which adds arbitrary named annotations to the wrapped character.
-
-# Constructors
-
-```julia
-StyledChar(s::S) -> StyledChar{S}
-StyledChar(s::S, props::Pair{Symbol, <:Any}...)
-StyledChar(s::S, properties::Vector{Pair{Symbol, <:Any}})
-```
-
-# Examples
-
-```jldoctest
-julia> StyledChar('j', :face => :blue)
-'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
-
-julia> StyledChar('j', :tag => :1)
-'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
-```
-"""
-struct StyledChar{C <: AbstractChar} <: AbstractChar
-    char::C
-    properties::Vector{Pair{Symbol, Any}}
-end
-
-## Constructors ##
-
-StyledString(s::AbstractString, prop::Pair{Symbol, <:Any}, props::Pair{Symbol, <:Any}...) =
-    StyledString(s, firstindex(s):lastindex(s), prop, props...)
-
-StyledString(s::AbstractString, region::UnitRange{Int}, props::Pair{Symbol, <:Any}...) =
-    StyledString(s, [(region, Pair{Symbol, Any}(first(p), last(p)))
-                      for p in props])
-
-StyledString(s::AbstractString, props::Vector{<:Pair{Symbol, <:Any}}) =
-    StyledString(s, [(firstindex(s):lastindex(s), p) for p in props])
-
-# Constructors called with overly-specialised arguments
-
-StyledString(s::AbstractString, props::Vector{<:Tuple{UnitRange{Int}, <:Pair{Symbol, <:Any}}}) =
-    StyledString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}(props))
-
-StyledChar(c::AbstractChar, prop::Pair{Symbol, <:Any}, props::Pair{Symbol, <:Any}...) =
-    StyledChar(c, Vector{Pair{Symbol, Any}}(vcat(prop, props...)))
-
-# Constructors to avoid recursive wrapping
-
-StyledString(s::StyledString, props::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}) =
-    StyledString(s.string, vcat(s.properties, props))
-
-StyledChar(c::StyledChar, props::Vector{Pair{Symbol, Any}}) =
-    StyledChar(c.char, vcat(s.properties, props))
-
-# To avoid pointless overhead
-String(s::StyledString{String}) = s.string
-
-## Conversion/promotion ##
-
-convert(::Type{StyledString}, s::StyledString) = s
-convert(::Type{StyledString{S}}, s::S) where {S <: AbstractString} =
-    StyledString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
-convert(::Type{StyledString}, s::S) where {S <: AbstractString} =
-    convert(StyledString{S}, s)
-StyledString(s::S) where {S <: AbstractString} = convert(StyledString{S}, s)
-
-convert(::Type{StyledChar}, c::StyledChar) = c
-convert(::Type{StyledChar{C}}, c::C) where { C <: AbstractChar } =
-    StyledChar{C}(c, Vector{Pair{Symbol, Any}}())
-convert(::Type{StyledChar}, c::C) where { C <: AbstractChar } =
-    convert(StyledChar{C}, c)
-
-StyledChar(c::AbstractChar) = convert(StyledChar, c)
-StyledChar(c::UInt32) = convert(StyledChar, Char(c))
-StyledChar{C}(c::UInt32) where {C <: AbstractChar} = convert(StyledChar, C(c))
-
-promote_rule(::Type{<:StyledString}, ::Type{<:AbstractString}) = StyledString
-
-## AbstractString interface ##
-
-ncodeunits(s::StyledString) = ncodeunits(s.string)
-codeunits(s::StyledString) = codeunits(s.string)
-codeunit(s::StyledString) = codeunit(s.string)
-codeunit(s::StyledString, i::Integer) = codeunit(s.string, i)
-isvalid(s::StyledString, i::Integer) = isvalid(s.string, i)
-@propagate_inbounds iterate(s::StyledString, i::Integer=firstindex(s)) =
-    if i <= lastindex(s.string); (s[i], nextind(s, i)) end
-eltype(::Type{<:StyledString{S}}) where {S} = StyledChar{eltype(S)}
-firstindex(s::StyledString) = firstindex(s.string)
-lastindex(s::StyledString) = lastindex(s.string)
-
-function getindex(s::StyledString, i::Integer)
-    @boundscheck checkbounds(s, i)
-    @inbounds if isvalid(s, i)
-        StyledChar(s.string[i], textproperties(s, i))
-    else
-        string_index_err(s, i)
-    end
-end
-
-## AbstractChar interface ##
-
-ncodeunits(c::StyledChar) = ncodeunits(c.char)
-codepoint(c::StyledChar) = codepoint(c.char)
-
-# Avoid the iteration fallback with comparison
-cmp(a::StyledString, b::AbstractString) = cmp(a.string, b)
-cmp(a::AbstractString, b::StyledString) = cmp(a, b.string)
-# To avoid method ambiguity
-cmp(a::StyledString, b::StyledString) = cmp(a.string, b.string)
-
-==(a::StyledString, b::StyledString) =
-    a.string == b.string && a.properties == b.properties
-
-==(a::StyledString, b::AbstractString) = isempty(a.properties) && a.string == b
-==(a::AbstractString, b::StyledString) = isempty(b.properties) && a == b.string
-
-"""
-    styledstring(values...)
-
-Create a `StyledString` from any number of `values` using their
-[`print`](@ref)ed representation.
-
-This acts like [`string`](@ref), but takes care to preserve any properties
-present (in the form of [`StyledString`](@ref) or [`StyledChar`](@ref) values).
-
-See also [`StyledString`](@ref), [`StyledChar`](@ref), and [`S""`](@ref @S_str).
-
-## Examples
-
-```
-julia> styledstring("now a StyledString")
-"now a StyledString"
-
-julia> styledstring(S"{yellow:styled text}", ", and unstyled")
-"styled text, and unstyled"
-```
-"""
-function styledstring(xs...)
-    isempty(xs) && return StyledString("")
-    size = mapreduce(_str_sizehint, +, xs)
-    s = IOContext(IOBuffer(sizehint=size), :color => true)
-    properties = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
-    for x in xs
-        if x isa StyledString
-            for (region, prop) in x.properties
-                push!(properties, (s.io.size .+ (region), prop))
-            end
-            print(s, x.string)
-        elseif x isa SubString{<:StyledString}
-            for (substr, props) in eachstyle(x)
-                region = s.io.size .+ (1+substr.offset:prevind(substr.string, 1+substr.offset+substr.ncodeunits)) .- x.offset
-                for prop in props
-                    push!(properties, (region, prop))
-                end
-            end
-            print(s, SubString(x.string.string, x.offset, x.ncodeunits, Val(:noshift)))
-        elseif x isa StyledChar
-            for prop in x.properties
-                push!(properties, (1+s.io.size:1+s.io.size, prop))
-            end
-            print(s, x.char)
-        else
-            print(s, x)
-        end
-    end
-    str = String(resize!(s.io.data, s.io.size))
-    StyledString(str, properties)
-end
-
-"""
-    styledstring_optimize!(str::StyledString)
-
-Merge contiguous identical properties in `str`.
-"""
-function styledstring_optimize!(s::StyledString)
-    last_seen = Dict{Pair{Symbol, Any}, Int}()
-    i = 1
-    while i <= length(s.properties)
-        region, keyval = s.properties[i]
-        prev = get(last_seen, keyval, 0)
-        if prev > 0
-            lregion, _ = s.properties[prev]
-            if last(lregion) + 1 == first(region)
-                s.properties[prev] =
-                    setindex(s.properties[prev],
-                             first(lregion):last(region),
-                             1)
-                deleteat!(s.properties, i)
-            else
-                delete!(last_seen, keyval)
-            end
-        else
-            last_seen[keyval] = i
-            i += 1
-        end
-    end
-    s
-end
-
-styledstring(s::StyledString) = s
-styledstring(c::StyledChar) = StyledString(string(c.char), c.properties)
-
-StyledString(s::SubString{<:StyledString}) = styledstring(s)
-
-function join(iterator, delim::StyledString, last=delim)
-    xs = zip(iterator, Iterators.repeated(delim)) |> Iterators.flatten |> collect
-    xs = xs[1:end-1]
-    if length(xs) > 1
-        xs[end-1] = last
-    end
-    styledstring(xs...)
-end
-
-function repeat(str::StyledString, r::Integer)
-    r == 0 && return one(StyledString)
-    r == 1 && return str
-    unstyled = repeat(str.string, r)
-    properties = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
-    len = ncodeunits(str)
-    fullregion = firstindex(str):lastindex(str)
-    for (region, prop) in str.properties
-        if region == fullregion
-            push!(properties, (firstindex(unstyled):lastindex(unstyled), prop))
-        end
-    end
-    for offset in 0:len:(r-1)*len
-        for (region, prop) in str.properties
-            if region != fullregion
-                push!(properties, (region .+ offset, prop))
-            end
-        end
-    end
-    StyledString(unstyled, properties) |> styledstring_optimize!
-end
-
-repeat(str::SubString{<:StyledString}, r::Integer) =
-    repeat(StyledString(str), r)
-
-function repeat(c::StyledChar, r::Integer)
-    str = repeat(c.char, r)
-    fullregion = firstindex(str):lastindex(str)
-    StyledString(str, [(fullregion, prop) for prop in c.properties])
-end
-
-function reverse(s::StyledString)
-    StyledString(reverse(s.string),
-                 [(UnitRange(1 + lastindex(s) - last(region),
-                             1 + lastindex(s) - first(region)),
-                   prop)
-                  for (region, prop) in s.properties])
-end
-
-# TODO optimise?
-reverse(s::SubString{<:StyledString}) = reverse(StyledString(s))
-
-# TODO implement `replace(::StyledString, ...)`
-
-## End AbstractString interface ##
-
-"""
-    textproperty!(s::StyledString, [range::UnitRange{Int}], prop::Symbol, val)
-    textproperty!(s::SubString{StyledString}, [range::UnitRange{Int}], prop::Symbol, val)
-
-Set `prop` to `val` in `s`, over either `range` if specified or the whole string.
-"""
-function textproperty!(s::StyledString, range::UnitRange{Int}, prop::Symbol, val)
-    indices = searchsorted(s.properties, (range,), by=first)
-    propindex = filter(i -> first(s.properties[i][2]) === prop, indices)
-    if length(propindex) == 1
-        if val === nothing
-            deleteat!(s.properties, first(propindex))
-        else
-            s.properties[first(propindex)] = (range, Pair{Symbol, Any}(prop, val))
-        end
-    else
-        splice!(s.properties, indices, [(range, Pair{Symbol, Any}(prop, val))])
-    end
-    s
-end
-
-textproperty!(ss::StyledString, prop::Symbol, value) =
-    textproperty!(ss, firstindex(ss):lastindex(ss), prop, value)
-
-textproperty!(s::SubString{<:StyledString}, range::UnitRange{Int}, prop::Symbol, value) =
-    (textproperty!(s.string, s.offset .+ (range), prop, value); s)
-
-textproperty!(s::SubString{<:StyledString}, prop::Symbol, value) =
-    (textproperty!(s.string, s.offset .+ (1:s.ncodeunits), prop, value); s)
-
-# TODO optimise
-"""
-    textproperties(s::StyledString, i::Integer)
-    textproperties(s::SubString{StyledString}, i::Integer)
-
-Get the text properties that apply to `s` at index `i`.
-"""
-function textproperties(s::StyledString, i::Integer)
-    props = filter(prop -> !isempty(intersect(i:i, first(prop))),
-                   s.properties)
-    last.(props)
-end
-
-textproperties(s::SubString{<:StyledString}, i::Integer) =
-    textproperties(s.string, s.offset + i)
-
-"""
-    textproperties(c::StyledChar)
-
-Get the properties that apply to `c`.
-"""
-textproperties(c::StyledChar) = c.properties
-
-## Iterating over styles ##
-
-struct StyleIterator{S <: AbstractString}
-    str::S
-    regions::Vector{UnitRange{Int}}
-    styles::Vector{Vector{Pair{Symbol, Any}}}
-end
-
-length(si::StyleIterator) = length(si.regions)
-
-@propagate_inbounds function iterate(si::StyleIterator, i::Integer=1)
-    if i <= length(si.regions)
-        @inbounds ((SubString(si.str, si.regions[i]), si.styles[i]), i+1)
-    end
-end
-
-eltype(::StyleIterator{S}) where { S <: AbstractString} =
-    Tuple{SubString{S}, Vector{Pair{Symbol, Any}}}
-
-"""
-    eachstyle(s::StyledString{S})
-    eachstyle(s::SubString{StyledString{S}})
-
-Identify the contiguous substrings of `s` with a constant style, and return
-an iterator which provides each substring and the applicable styles as a
-`Tuple{SubString{S}, Vector{Pair{Symbol, Any}}}`.
-
-# Examples
-
-```jldoctest
-julia> eachstyle(StyledString("hey there", [(1:3, :face => :bold),
-                                            (5:9, :face => :italic)])) |> collect
-3-element Vector{Tuple{SubString{String}, Vector{Pair{Symbol, Any}}}}:
- ("hey", [:face => :bold])
- (" ", [])
- ("there", [:face => :italic])
-```
-"""
-function eachstyle(s::StyledString, region::UnitRange{Int}=firstindex(s):lastindex(s))
-    isempty(s) || isempty(region) &&
-        return StyleIterator(s, Vector{UnitRange{Int}}(), Vector{Vector{Pair{Symbol, Any}}}())
-    regions = Vector{UnitRange{Int}}()
-    styles = Vector{Vector{Pair{Symbol, Any}}}()
-    changepoints = filter(c -> c in region,
-                          Iterators.flatten((first(region), nextind(s, last(region)))
-                                            for region in first.(s.properties)) |>
-                                                unique |> sort)
-    isempty(changepoints) &&
-        return StyleIterator(s.string, [region], [textproperties(s, first(region))])
-    function registerchange!(start, stop)
-        push!(regions, start:stop)
-        push!(styles, textproperties(s, start))
-    end
-    if first(region) < first(changepoints)
-        registerchange!(first(region), prevind(s, first(changepoints)))
-    end
-    for (start, stop) in zip(changepoints, changepoints[2:end])
-        registerchange!(start, prevind(s, stop))
-    end
-    if last(changepoints) <= last(region)
-        registerchange!(last(changepoints), last(region))
-    end
-    StyleIterator(s.string, regions, styles)
-end
-
-function eachstyle(s::SubString{<:StyledString}, region::UnitRange{Int}=firstindex(s):lastindex(s))
-    if isempty(s)
-        StyleIterator(s, Vector{UnitRange{Int}}(), Vector{Vector{Pair{Symbol, Any}}}())
-    else
-        eachstyle(s.string, first(region)+s.offset:last(region)+s.offset)
-    end
-end
diff --git a/base/strings/tagged.jl b/base/strings/tagged.jl
new file mode 100644
index 0000000000000..b9b9740dc8a32
--- /dev/null
+++ b/base/strings/tagged.jl
@@ -0,0 +1,354 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+"""
+    TaggedString{S <: AbstractString} <: AbstractString
+
+A string with annotated regions (often styling information).
+
+More specifically, this is a thin wrapper around any other [`AbstractString`](@ref),
+allows arbitary tagged values to be attached to regions of the wrapped string.
+
+Each tag takes the form of a `Pair{Symbol, <:Any}`, the first value being the
+tag name, and the second the value. A single region can be annotated with the
+same tag multiple times.
+
+See also [`TaggedChar`](@ref), [`taggedstring`](@ref), [`textproperties`](@ref), and
+[`textproperty!`](@ref).
+
+!!! warning
+    While the constructors are part of the Base public API, the fields
+    of `TaggedString` are not. This is to allow for potential future
+    changes in the implementation of this type. Instead use the
+    [`textproperties`](@ref), and [`textproperty!`](@ref) getter/setter
+    functions.
+
+# Constructors
+
+```julia
+TaggedString(s::S<:AbstractString) -> TaggedString{S}
+TaggedString(s::S<:AbstractString, properties::Vector{Tuple{UnitRange{Int}, Pair{Symbol, <:Any}}})
+```
+
+A TaggedString can also be created with [`taggedstring`](@ref), which acts much
+like [`string`](@ref) but preserves any tags present in the arguments.
+"""
+struct TaggedString{S <: AbstractString} <: AbstractString
+    string::S
+    properties::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+end
+
+"""
+    TaggedChar{S <: AbstractChar} <: AbstractChar
+
+A Char annotated with tags.
+
+More specifically, this is a thin wrapper around any other [`AbstractChar`](@ref),
+which adds arbitrary tags to the wrapped character.
+
+See also: [`TaggedString`](@ref), [`taggedstring`](@ref), `textproperties`, and
+`textproperty!`.
+
+!!! warning
+    While the constructors are part of the Base public API, the fields
+    of `TaggedChar` are not. This it to allow for potential future
+    changes in the implementation of this type. Instead use the
+    [`textproperties`](@ref), and [`textproperty!`](@ref) getter/setter
+    functions.
+
+# Constructors
+
+```julia
+TaggedChar(s::S) -> TaggedChar{S}
+TaggedChar(s::S, properties::Vector{Pair{Symbol, <:Any}})
+```
+
+# Examples
+
+```julia-repl
+julia> TaggedChar('j', :tag => 1)
+'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
+```
+"""
+struct TaggedChar{C <: AbstractChar} <: AbstractChar
+    char::C
+    properties::Vector{Pair{Symbol, Any}}
+end
+
+## Constructors ##
+
+# When called with overly-specialised arguments
+
+TaggedString(s::AbstractString, props::Vector{<:Tuple{UnitRange{Int}, <:Pair{Symbol, <:Any}}}) =
+    TaggedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}(props))
+
+TaggedChar(c::AbstractChar, props::Vector{<:Pair{Symbol, <:Any}}) =
+    TaggedChar(c, Vector{Pair{Symbol, Any}}(props))
+
+# Constructors to avoid recursive wrapping
+
+TaggedString(s::TaggedString, props::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}) =
+    TaggedString(s.string, vcat(s.properties, props))
+
+TaggedChar(c::TaggedChar, props::Vector{Pair{Symbol, Any}}) =
+    TaggedChar(c.char, vcat(s.properties, props))
+
+String(s::TaggedString{String}) = s.string # To avoid pointless overhead
+
+## Conversion/promotion ##
+
+convert(::Type{TaggedString}, s::TaggedString) = s
+convert(::Type{TaggedString{S}}, s::S) where {S <: AbstractString} =
+    TaggedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
+convert(::Type{TaggedString}, s::S) where {S <: AbstractString} =
+    convert(TaggedString{S}, s)
+TaggedString(s::S) where {S <: AbstractString} = convert(TaggedString{S}, s)
+
+convert(::Type{TaggedChar}, c::TaggedChar) = c
+convert(::Type{TaggedChar{C}}, c::C) where { C <: AbstractChar } =
+    TaggedChar{C}(c, Vector{Pair{Symbol, Any}}())
+convert(::Type{TaggedChar}, c::C) where { C <: AbstractChar } =
+    convert(TaggedChar{C}, c)
+
+TaggedChar(c::AbstractChar) = convert(TaggedChar, c)
+TaggedChar(c::UInt32) = convert(TaggedChar, Char(c))
+TaggedChar{C}(c::UInt32) where {C <: AbstractChar} = convert(TaggedChar, C(c))
+
+promote_rule(::Type{<:TaggedString}, ::Type{<:AbstractString}) = TaggedString
+
+## AbstractString interface ##
+
+ncodeunits(s::TaggedString) = ncodeunits(s.string)
+codeunits(s::TaggedString) = codeunits(s.string)
+codeunit(s::TaggedString) = codeunit(s.string)
+codeunit(s::TaggedString, i::Integer) = codeunit(s.string, i)
+isvalid(s::TaggedString, i::Integer) = isvalid(s.string, i)
+@propagate_inbounds iterate(s::TaggedString, i::Integer=firstindex(s)) =
+    if i <= lastindex(s.string); (s[i], nextind(s, i)) end
+eltype(::Type{<:TaggedString{S}}) where {S} = TaggedChar{eltype(S)}
+firstindex(s::TaggedString) = firstindex(s.string)
+lastindex(s::TaggedString) = lastindex(s.string)
+
+function getindex(s::TaggedString, i::Integer)
+    @boundscheck checkbounds(s, i)
+    @inbounds if isvalid(s, i)
+        TaggedChar(s.string[i], textproperties(s, i))
+    else
+        string_index_err(s, i)
+    end
+end
+
+## AbstractChar interface ##
+
+ncodeunits(c::TaggedChar) = ncodeunits(c.char)
+codepoint(c::TaggedChar) = codepoint(c.char)
+
+# Avoid the iteration fallback with comparison
+cmp(a::TaggedString, b::AbstractString) = cmp(a.string, b)
+cmp(a::AbstractString, b::TaggedString) = cmp(a, b.string)
+# To avoid method ambiguity
+cmp(a::TaggedString, b::TaggedString) = cmp(a.string, b.string)
+
+==(a::TaggedString, b::TaggedString) =
+    a.string == b.string && a.properties == b.properties
+
+==(a::TaggedString, b::AbstractString) = isempty(a.properties) && a.string == b
+==(a::AbstractString, b::TaggedString) = isempty(b.properties) && a == b.string
+
+"""
+    taggedstring(values...)
+
+Create a `TaggedString` from any number of `values` using their
+[`print`](@ref)ed representation.
+
+This acts like [`string`](@ref), but takes care to preserve any properties
+present (in the form of [`TaggedString`](@ref) or [`TaggedChar`](@ref) values).
+
+See also [`TaggedString`](@ref) and [`TaggedChar`](@ref).
+
+## Examples
+
+```
+julia> taggedstring("now a TaggedString")
+"now a TaggedString"
+
+julia> taggedstring(TaggedString("tagged", [(1:6, :tag => 1)]), ", and untagged")
+"tagged, and untagged"
+```
+"""
+function taggedstring(xs...)
+    isempty(xs) && return TaggedString("")
+    size = mapreduce(_str_sizehint, +, xs)
+    s = IOContext(IOBuffer(sizehint=size), :color => true)
+    properties = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    for x in xs
+        if x isa TaggedString
+            for (region, prop) in x.properties
+                push!(properties, (s.io.size .+ (region), prop))
+            end
+            print(s, x.string)
+        elseif x isa SubString{<:TaggedString}
+            for (region, prop) in x.string.properties
+                start, stop = first(region), last(region)
+                if start <= x.offset + x.ncodeunits && stop > x.offset
+                    rstart = s.io.size + max(0, start - x.offset) + 1
+                    rstop = s.io.size + min(stop, x.offset + x.ncodeunits) - x.offset
+                    push!(properties, (rstart:rstop, prop))
+                end
+            end
+            print(s, SubString(x.string.string, x.offset, x.ncodeunits, Val(:noshift)))
+        elseif x isa TaggedChar
+            for prop in x.properties
+                push!(properties, (1+s.io.size:1+s.io.size, prop))
+            end
+            print(s, x.char)
+        else
+            print(s, x)
+        end
+    end
+    str = String(resize!(s.io.data, s.io.size))
+    TaggedString(str, properties)
+end
+
+taggedstring(s::TaggedString) = s
+taggedstring(c::TaggedChar) =
+    TaggedString(string(c.char), [(1:ncodeunits(c), c.properties)])
+
+TaggedString(s::SubString{<:TaggedString}) = taggedstring(s)
+
+"""
+    taggedstring_optimize!(str::TaggedString)
+
+Merge contiguous identical tags in `str`.
+"""
+function taggedstring_optimize!(s::TaggedString)
+    last_seen = Dict{Pair{Symbol, Any}, Int}()
+    i = 1
+    while i <= length(s.properties)
+        region, keyval = s.properties[i]
+        prev = get(last_seen, keyval, 0)
+        if prev > 0
+            lregion, _ = s.properties[prev]
+            if last(lregion) + 1 == first(region)
+                s.properties[prev] =
+                    setindex(s.properties[prev],
+                             first(lregion):last(region),
+                             1)
+                deleteat!(s.properties, i)
+            else
+                delete!(last_seen, keyval)
+            end
+        else
+            last_seen[keyval] = i
+            i += 1
+        end
+    end
+    s
+end
+
+function repeat(str::TaggedString, r::Integer)
+    r == 0 && return one(TaggedString)
+    r == 1 && return str
+    untagged = repeat(str.string, r)
+    properties = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    len = ncodeunits(str)
+    fullregion = firstindex(str):lastindex(str)
+    for (region, prop) in str.properties
+        if region == fullregion
+            push!(properties, (firstindex(untagged):lastindex(untagged), prop))
+        end
+    end
+    for offset in 0:len:(r-1)*len
+        for (region, prop) in str.properties
+            if region != fullregion
+                push!(properties, (region .+ offset, prop))
+            end
+        end
+    end
+    TaggedString(untagged, properties) |> taggedstring_optimize!
+end
+
+repeat(str::SubString{<:TaggedString}, r::Integer) =
+    repeat(TaggedString(str), r)
+
+function repeat(c::TaggedChar, r::Integer)
+    str = repeat(c.char, r)
+    fullregion = firstindex(str):lastindex(str)
+    TaggedString(str, [(fullregion, prop) for prop in c.properties])
+end
+
+function reverse(s::TaggedString)
+    lastind = lastindex(s)
+    TaggedString(reverse(s.string),
+                 [(UnitRange(1 + lastind - last(region),
+                             1 + lastind - first(region)),
+                   prop)
+                  for (region, prop) in s.properties])
+end
+
+# TODO optimise?
+reverse(s::SubString{<:TaggedString}) = reverse(TaggedString(s))
+
+# TODO implement `replace(::TaggedString, ...)`
+
+## End AbstractString interface ##
+
+"""
+    textproperty!(str::TaggedString, [range::UnitRange{Int}], tag::Symbol, value)
+    textproperty!(str::SubString{TaggedString}, [range::UnitRange{Int}], tag::Symbol, value)
+
+Add `tag` with `value` in `str`, over `range` if specified or the whole
+string otherwise.
+"""
+function textproperty!(s::TaggedString, range::UnitRange{Int}, tag::Symbol, val)
+    indices = searchsorted(s.properties, (range,), by=first)
+    tagindex = filter(i -> first(s.properties[i][2]) === tag, indices)
+    if length(tagindex) == 1
+        if val === nothing
+            deleteat!(s.properties, first(tagindex))
+        else
+            s.properties[first(tagindex)] = (range, Pair{Symbol, Any}(tag, val))
+        end
+    else
+        splice!(s.properties, indices, [(range, Pair{Symbol, Any}(tag, val))])
+    end
+    s
+end
+
+textproperty!(ss::TaggedString, tag::Symbol, value) =
+    textproperty!(ss, firstindex(ss):lastindex(ss), tag, value)
+
+textproperty!(s::SubString{<:TaggedString}, range::UnitRange{Int}, tag::Symbol, value) =
+    (textproperty!(s.string, s.offset .+ (range), tag, value); s)
+
+textproperty!(s::SubString{<:TaggedString}, tag::Symbol, value) =
+    (textproperty!(s.string, s.offset .+ (1:s.ncodeunits), tag, value); s)
+
+"""
+    textproperties(s::TaggedString, i::Integer)
+    textproperties(s::SubString{TaggedString}, i::Integer)
+
+Get the text properties that apply to `s` at index `i`.
+"""
+function textproperties(s::TaggedString, i::Integer)
+    # TODO optimise
+    props = filter(tag -> !isempty(intersect(i:i, first(tag))),
+                   s.properties)
+    last.(props)
+end
+
+textproperties(s::SubString{<:TaggedString}, i::Integer) =
+    textproperties(s.string, s.offset + i)
+
+"""
+    textproperties(c::TaggedChar)
+
+Get the properties that apply to `c`.
+"""
+textproperties(c::TaggedChar) = c.properties
+
+"""
+    textproperty!(char::TaggedChar, tag::Symbol, value)
+
+ Add a `tag` with `value` to `char`.
+"""
+textproperty!(c::TaggedString, tag::Symbol, value)
diff --git a/base/strings/util.jl b/base/strings/util.jl
index 337131d823824..226c0e3e3cc8e 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -459,8 +459,8 @@ function lpad(
     n::Integer,
     p::Union{AbstractChar,AbstractString}=' ',
 )
-    stringfn = if any(isa.((s, p), Union{StyledString, StyledChar, SubString{<:StyledString}}))
-        styledstring else string end
+    stringfn = if any(isa.((s, p), Union{TaggedString, TaggedChar, SubString{<:TaggedString}}))
+        taggedstring else string end
     n = Int(n)::Int
     m = signed(n) - Int(textwidth(s))::Int
     m ≤ 0 && return stringfn(s)
@@ -491,8 +491,8 @@ function rpad(
     n::Integer,
     p::Union{AbstractChar,AbstractString}=' ',
 )
-    stringfn = if any(isa.((s, p), Union{StyledString, StyledChar, SubString{<:StyledString}}))
-        styledstring else string end
+    stringfn = if any(isa.((s, p), Union{TaggedString, TaggedChar, SubString{<:TaggedString}}))
+        taggedstring else string end
     n = Int(n)::Int
     m = signed(n) - Int(textwidth(s))::Int
     m ≤ 0 && return stringfn(s)
diff --git a/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/md5 b/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/md5
new file mode 100644
index 0000000000000..99f97b403aaae
--- /dev/null
+++ b/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/md5
@@ -0,0 +1 @@
+0c4ac1a2aa9d46afeffd3db5ef022ddc
diff --git a/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/sha512 b/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/sha512
new file mode 100644
index 0000000000000..048c38006e7cb
--- /dev/null
+++ b/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/sha512
@@ -0,0 +1 @@
+6fab5fb2bb79d1aa5dad6ae38e69c0f9bf07541d69511cc78305a8524fab891d97b103f96834be4e6b5e4f302f6abdc2736e34ddca324dcd98021a192962d0ad
diff --git a/doc/src/base/strings.md b/doc/src/base/strings.md
index 4d847c14d0845..8495b712eb494 100644
--- a/doc/src/base/strings.md
+++ b/doc/src/base/strings.md
@@ -17,13 +17,11 @@ Core.String(::AbstractString)
 Base.SubString
 Base.LazyString
 Base.@lazy_str
-Base.StyledString
-Base.StyledChar
-Base.styledstring
-Base.Face
-Base.@S_str
-Base.addface!
-Base.loadfaces!
+Base.TaggedString
+Base.TaggedChar
+Base.taggedstring
+Base.textproperties
+Base.textproperty!
 Base.transcode
 Base.unsafe_string
 Base.ncodeunits(::AbstractString)
diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md
index e904edbea83ea..d29358d2a56ff 100644
--- a/doc/src/manual/strings.md
+++ b/doc/src/manual/strings.md
@@ -1204,65 +1204,31 @@ precede a quote character.
 However, the next backslash character escapes the backslash that follows it, and the
 last backslash escapes a quote, since these backslashes appear before a quote.
 
-## [Styling](@id man-styling)
-
-When working with strings, formatting and styling often appear as a secondary
-concern.
-
-!!! note
-    For instance, when printing to a terminal you might want to sprinkle [ANSI
-    escape
-    sequences](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters)
-    in the output, when outputting HTML styling constructs (`<span style="...">`,
-    etc.) serve a similar purpose, and so on. It is possible to simply insert the
-    raw styling constructs into the string next to the content itself, but it
-    quickly becomes apparent that this is not well suited for anything but the most
-    basic use-cases. Not all terminals support the same ANSI codes, the styling
-    constructs need to be painstakingly removed when calculating the width of
-    already-styled content, and that's before you even get into handling
-    multiple output formats.
-
-Instead of leaving this headache to be widely experienced downstream, it is
-tackled head-on by the introduction of a special string type
-([`StyledString`](@ref)). This string type wraps any other string type and
-allows for formating information to be applied to regions (e.g. characters 1
-through to 7 are bold and red).
-
-Regions of a string are styled by applying [`Face`](@ref)s to them —a
-structure that holds styling information— (think "typeface"). As a
-convenience, it is possible to name a face in the global faces dictionary
-instead of giving the [`Face`](@ref) directly.
-
-Along with these capabilities, we also provide a convenient way for constructing
-[`StyledString`](@ref)s, detailed in [Styled String Literals](@ref man-styled-string-literals).
 
-```jldoctest
-julia> S"{yellow:hello} {blue:there}"
-"hello there" # prints with colour in the REPL
-```
+## [Tagged Strings](@id man-tagged-strings)
 
-### [Styled Strings](@id man-styled-strings)
+It is sometimes useful to be able to hold metadata relating to regions of a
+string. A [`TaggedString`](@ref Base.TaggedString) wraps another string and
+allows for regions of it to be annotated with tagged values (`:tag => value`).
+All generic string operations are applied to the underlying string. However,
+when possible, styling information is preserved. This means you can manipulate a
+[`TaggedString`](@ref Base.TaggedString) —taking substrings, padding them,
+concatenating them with other strings— and the metadata annotations will "come
+along for the ride".
 
-[`StyledString`](@ref)s wrap another string and overlay a list of tagged
-regions. All generic string operations are applied to the underlying string.
-When possible though, styling information is maintained (e.g. when
-[`split`](@ref)ting a [`StyledString`](@ref)).
+This string type is fundamental to the [StyledStrings stdlib](@ref
+stdlib-styledstrings), which uses `:face`-tagged annotations to hold styling
+information.
 
-To concatenate printable values and styled strings together (maintaining styling
-information), the [`styledstring`](@ref) function can be used (as a counterpart
-to [`string`](@ref)).
+When concatenating a [`TaggedString`](@ref Base.TaggedString), take care to use
+[`taggedstring`](@ref Base.taggedstring) instead of [`string`](@ref) if you want
+to keep the tagged string annotations.
 
 ```jldoctest
-julia> str = StyledString("hello there",
-               [(1:5, :face => :yellow), (7:11, :face => :blue)])
+julia> str = Base.TaggedString("hello there",
+               [(1:5, :word => :greeting), (7:11, :tag => 1)])
 "hello there"
 
-julia> collect(Base.eachstyle(str))
-3-element Vector{Tuple{SubString{String}, Vector{Pair{Symbol, Any}}}}:
- ("hello", [:face => :yellow])
- (" ", [])
- ("there", [:face => :blue])
-
 julia> length(str)
 11
 
@@ -1270,166 +1236,18 @@ julia> lpad(str, 14)
 "   hello there"
 
 julia> typeof(lpad(str, 7))
-StyledString{String}
+Base.TaggedString{String}
 
-julia> str2 = StyledString(" julia", [(2:6, :face => :magenta)])
+julia> str2 = Base.TaggedString(" julia", [(2:6, :face => :magenta)])
+" julia"
 
-julia> styledstring(str, str2)
+julia> Base.taggedstring(str, str2)
 "hello there julia"
 
-julia> str * str2 == styledstring(str, str2) # *-concatination still works
+julia> str * str2 == Base.taggedstring(str, str2) # *-concatination still works
 true
-
-julia> collect(Base.eachstyle(str * str2))
-5-element Vector{Tuple{SubString{String}, Vector{Pair{Symbol, Any}}}}:
- ("hello", [:face => :yellow])
- (" ", [])
- ("there", [:face => :blue])
- (" ", [])
- ("julia", [:face => :magenta])
 ```
 
-#### Advanced uses
-
-While styling is the focus here, the system is actually more general. It allows
-for arbitrary annotations to be added to regions of the underlying string. Each
-annotation is in the form of a `tag::Symbol => value::Any` tagged value. You can
-tag any information you want, such as source location the string was extracted
-from, or an alternative form of some text, but the most obvious use case is to
-hold styling information (which use a `:face` tag).
-
-### [Faces](@id man-faces)
-
-#### The `Face` type
-
-A [`Face`](@ref) specifies details of a typeface that text can be set in. It
-covers a set of basic attributes that generalise well across different formats,
-namely:
-
-- `height`
-- `weight`
-- `slant`
-- `foreground`
-- `background`
-- `underline`
-- `strikethrough`
-- `inverse`
-- `inherit`
-
-For details on the particular forms these attributes take, see the
-[`Face`](@ref) docstring, but of particular interest is `inherit` as it allows
-you to _inherit_ attributes from other [`Face`](@ref)s.
-
-#### The global `FACES` dictionary
-
-To make referring to particular styles more convenient, there is a global
-`Dict{Symbol, Face}` that allows for [`Face`](@ref)s to be referred to simply by
-name. Packages can add faces to this dictionary via the [`Base.addface!`](@ref)
-function, and the loaded faces can be easily [customised](@ref man-face-toml).
-
-!!! warning
-    Any package registering new faces should ensure that they are prefixed
-    by the package name, i.e. follow the format `mypackage_myface`.
-    This is important for predictability, and to prevent name clashes.
-
-There is one set of exemptions to the package-prefix rule, the set of basic
-faces that are part of the default value of the faces dictionary.
-
-##### [Basic faces](@id man-basic-faces)
-
-Basic faces are intended represent a general idea, that is widely applicable.
-
-For setting some text with a certain attribute, we have the `bold`, `italic`,
-`underline`, `strikethrough`, and `inverse` faces.
-
-There are also named faces for the 16 terminal colours: `black`, `red`, `green`,
-`yellow`, `blue`, `magenta`, `cyan`, `white`, `bright_black`/`grey`/`gray`,
-`bright_red`, `bright_green`, `bright_blue`, `bright_magenta`, `bright_cyan`,
-and `bright_white`.
-
-For shadowed text (i.e. dim but there) there is the `shadow` face. To indicate a
-selected region, there is the `region` face. Similarly for emphasis and
-highlighting the `emphasis` and `highlight` faces are defined. There is also
-`code` for code-like text.
-
-For visually indicating the severity of messages the `error`, `warning`,
-`success`, `info`, `note`, and `tip` faces are defined.
-
-#### [Customisation of faces (`Faces.toml`)](@id man-face-toml)
-
-It is good for the name faces in the global face dictionary to be customizable.
-Theming and aesthetics are nice, and it is important for accessibility reasons
-too. A TOML file can be parsed into a list of [`Face`](@ref) specifications that
-are merged with the pre-existing entry in the face dictionary.
-
-A [`Face`](@ref) is represented in TOML like so:
-
-```toml
-[facename]
-attribute = "value"
-...
-
-[package.facename]
-attribute = "value"
-```
-
-For example, if the `shadow` face is too hard to read it can be made brighter
-like so:
-
-```toml
-[shadow]
-foreground = "white"
-```
-
-#### Applying faces to a `StyledString`
-
-By convention, the `:face` attributes of a [`StyledString`](@ref) hold
-information on the [`Face`](@ref)s that currently apply. This can be given in
-multiple forms, as a single `Symbol` naming a [`Face`](@ref)s in the global face
-dictionary, a [`Face`](@ref) itself, or a vector of either.
-
-The `show(::IO, ::MIME"text/plain", ::StyledString)` and `show(::IO,
-::MIME"text/html", ::StyledString)` methods both look at the `:face` attributes
-and merge them all together when determining the overall styling.
-
-We can supply `:face` attributes to a `StyledString` during construction, add
-them to the properties list afterwards, or use the convenient [Styled String
-literals](@ref man-styled-string-literals).
-
-```jldoctest
-julia> str1 = StyledString("blue text", [(1:9, :face => Face(foreground=:blue))])
-"blue text"
-
-julia> str2 = StyledString("blue text", :face => Face(foreground=:blue))
-"blue text"
-
-julia> str1 == str2
-true
-
-julia> sprint(show, MIME("text/plain"), str1, context = :color => true)
-"\"\e[34mblue text\e[39m\""
-
-julia> sprint(show, MIME("text/html"), str1, context = :color => true)
-"<pre><span style=\"color: #000080;\">blue text</span></pre>"
-```
-
-## [Styled String Literals](@id man-styled-string-literals)
-
-To ease construction of [`StyledString`](@ref)s with [`Face`](@ref)s applied,
-the [`S"..."`](@ref @S_str) styled string literal allows for the content and
-attributes to be easily expressed together via a custom grammar.
-
-Within a [`S"..."`](@ref @S_str) literal, curly parenthesis are considered
-special characters and must be escaped in normal usage (`\{`, `\}`). This allows
-them to be used to express annotations with (nestable) `{annotations...:text}`
-constructs.
-
-The `annotations...` component is a comma-separated list of three types of annotations.
-- Face names
-- Inline `Face` expressions `(key=val,...)`
-- `key=value` pairs
-
-Interpolation is possible everywhere except for inline face keys.
-
-For more information on the grammar, see the extended help of the
-[`S"..."`](@ref @S_str) docstring.
+The annotations of a [`TaggedString`](@ref Base.TaggedString) can be accessed
+and modified via the [`annotations`](@ref Base.annotations) and
+[`annotate!`](@ref Base.annotate!) functions.
diff --git a/pkgimage.mk b/pkgimage.mk
index 9a91488955420..0b46531cfa137 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -70,6 +70,7 @@ $(eval $(call stdlib_builder,Serialization,))
 $(eval $(call stdlib_builder,Sockets,))
 $(eval $(call stdlib_builder,Unicode,))
 $(eval $(call stdlib_builder,Profile,))
+$(eval $(call stdlib_builder,StyledStrings,))
 
 # 1-depth packages
 $(eval $(call stdlib_builder,GMP_jll,Artifacts Libdl))
diff --git a/stdlib/.gitignore b/stdlib/.gitignore
index f76eb3df57145..ce744aa43d9f5 100644
--- a/stdlib/.gitignore
+++ b/stdlib/.gitignore
@@ -25,6 +25,8 @@
 /LazyArtifacts
 /Distributed-*
 /Distributed
+/StyledStrings-*
+/StyledStrings
 /*_jll/StdlibArtifacts.toml
 /*/Manifest.toml
 /*.image
diff --git a/stdlib/Makefile b/stdlib/Makefile
index 6b09344ac422d..1c8a2849d75f1 100644
--- a/stdlib/Makefile
+++ b/stdlib/Makefile
@@ -47,7 +47,7 @@ STDLIBS = Artifacts Base64 CRC32c Dates FileWatching \
           $(JLL_NAMES)
 
 STDLIBS_EXT = Pkg Statistics LazyArtifacts LibCURL DelimitedFiles Downloads ArgTools \
-              Tar NetworkOptions SuiteSparse SparseArrays SHA Distributed
+              Tar NetworkOptions SuiteSparse SparseArrays StyledStrings SHA Distributed
 
 $(foreach module, $(STDLIBS_EXT), $(eval $(call stdlib-external,$(module),$(shell echo $(module) | tr a-z A-Z))))
 
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
new file mode 100644
index 0000000000000..9f7a781306d72
--- /dev/null
+++ b/stdlib/StyledStrings.version
@@ -0,0 +1,4 @@
+STYLEDSTRINGS_BRANCH = main
+STYLEDSTRINGS_SHA1 = 745385d0ac8559b67111f96050f937e1bc70bf71
+STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
+STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1
diff --git a/stdlib/stdlib.mk b/stdlib/stdlib.mk
index 99bdefc66fa90..696b24a8f8bf1 100644
--- a/stdlib/stdlib.mk
+++ b/stdlib/stdlib.mk
@@ -6,7 +6,7 @@ INDEPENDENT_STDLIBS := \
 	ArgTools Base64 CRC32c Dates DelimitedFiles Distributed Downloads Future \
 	InteractiveUtils LazyArtifacts LibGit2 LibCURL Logging Markdown Mmap \
 	NetworkOptions Profile Printf Pkg REPL Serialization SharedArrays SparseArrays \
-	Statistics Tar Test TOML Unicode UUIDs \
+	Statistics StyledStrings Tar Test TOML Unicode UUIDs \
 	dSFMT_jll GMP_jll libLLVM_jll LLD_jll LLVMLibUnwind_jll LibUnwind_jll LibUV_jll \
 	LibCURL_jll LibSSH2_jll LibGit2_jll nghttp2_jll  MozillaCACerts_jll MbedTLS_jll \
 	MPFR_jll OpenLibm_jll PCRE2_jll p7zip_jll Zlib_jll
diff --git a/test/choosetests.jl b/test/choosetests.jl
index 406e59fd82fa6..75cdd2fe5bc95 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -151,7 +151,7 @@ function choosetests(choices = [])
 
     filtertests!(tests, "unicode", ["unicode/utf8"])
     filtertests!(tests, "strings", ["strings/basic", "strings/search", "strings/util",
-                   "strings/io", "strings/types", "strings/styled", "strings/faces"])
+                   "strings/io", "strings/types", "strings/tagged"])
     # do subarray before sparse but after linalg
     filtertests!(tests, "subarray")
     filtertests!(tests, "compiler", [
diff --git a/test/strings/faces.jl b/test/strings/faces.jl
deleted file mode 100644
index 6a3242e0aca30..0000000000000
--- a/test/strings/faces.jl
+++ /dev/null
@@ -1,191 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-@testset "SimpleColor" begin
-    @test Base.SimpleColor(:hey).value == :hey # no error
-    @test Base.SimpleColor(0x01, 0x02, 0x03).value == (r=0x01, g=0x02, b=0x03)
-    @test Base.SimpleColor((r=0x01, g=0x02, b=0x03)).value == (r=0x01, g=0x02, b=0x03)
-    @test Base.SimpleColor(0x010203).value == (r=0x01, g=0x02, b=0x03)
-    @test tryparse(Base.SimpleColor, "hey") == Base.SimpleColor(:hey)
-    @test tryparse(Base.SimpleColor, "#010203") == Base.SimpleColor(0x010203)
-    @test tryparse(Base.SimpleColor, "#12345g") === nothing
-    @test tryparse(Base.SimpleColor, "!not a color") === nothing
-    @test_throws ArgumentError parse(Base.SimpleColor, "!not a color")
-end
-
-@testset "Faces" begin
-    # Construction
-    @test Base.Face() ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, nothing, nothing, nothing, Symbol[])
-    @test Base.Face(font="font") ==
-        Base.Face("font", nothing, nothing, nothing, nothing,
-             nothing, nothing, nothing, nothing, Symbol[])
-    @test Base.Face(height=1) ==
-        Base.Face(nothing, 1, nothing, nothing, nothing,
-             nothing, nothing, nothing, nothing, Symbol[])
-    @test Base.Face(weight=:bold) ==
-        Base.Face(nothing, nothing, :bold, nothing, nothing,
-             nothing, nothing, nothing, nothing, Symbol[])
-    @test Base.Face(slant=:italic) ==
-        Base.Face(nothing, nothing, nothing, :italic, nothing,
-             nothing, nothing, nothing, nothing, Symbol[])
-    @test Base.Face(foreground=Base.SimpleColor(:red)) ==
-        Base.Face(nothing, nothing, nothing, nothing, Base.SimpleColor(:red),
-             nothing, nothing, nothing, nothing, Symbol[])
-    @test Base.Face(foreground=:red) ==
-        Base.Face(nothing, nothing, nothing, nothing, Base.SimpleColor(:red),
-             nothing, nothing, nothing, nothing, Symbol[])
-    @test Base.Face(foreground=0xff0000) ==
-        Base.Face(nothing, nothing, nothing, nothing, Base.SimpleColor(0xff0000),
-             nothing, nothing, nothing, nothing, Symbol[])
-    @test Base.Face(background=Base.SimpleColor(:red)) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             Base.SimpleColor(:red), nothing, nothing, nothing, Symbol[])
-    @test Base.Face(background=:red) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             Base.SimpleColor(:red), nothing, nothing, nothing, Symbol[])
-    @test Base.Face(background=0xff0000) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             Base.SimpleColor(0xff0000), nothing, nothing, nothing, Symbol[])
-    @test Base.Face(underline=true) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, true, nothing, nothing, Symbol[])
-    @test Base.Face(underline=:red) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, Base.SimpleColor(:red), nothing, nothing, Symbol[])
-    @test Base.Face(underline=(nothing, :curly)) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, (nothing, :curly), nothing, nothing, Symbol[])
-    @test Base.Face(underline=(:red, :curly)) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, (Base.SimpleColor(:red), :curly), nothing, nothing, Symbol[])
-    @test Base.Face(strikethrough=true) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, nothing, true, nothing, Symbol[])
-    @test Base.Face(inverse=true) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, nothing, nothing, true, Symbol[])
-    @test Base.Face(inherit=:singleface) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, nothing, nothing, nothing, [:singleface])
-    @test Base.Face(inherit=[:many, :faces]) ==
-        Base.Face(nothing, nothing, nothing, nothing, nothing,
-             nothing, nothing, nothing, nothing, [:many, :faces])
-    @test Base.Face() == Base.Face()
-    @test Base.Face(height=1) == Base.Face(height=1)
-    @test Base.Face(height=1) != Base.Face(height=2)
-    @test Base.Face(inherit=:a) != Base.Face(inherit=:b)
-    # Adding a face then resetting
-    @test Base.loadfaces!(:testface => Base.Face(font="test")) == Base.Face(font="test")
-    @test get(Base.FACES.current[], :testface, nothing) == Base.Face(font="test")
-    @test Base.loadfaces!(:bold => Base.Face(weight=:extrabold)) == Base.Face(weight=:extrabold)
-    @test get(Base.FACES.current[], :bold, nothing) == Base.Face(weight=:extrabold)
-    @test Base.loadfaces!(:testface => Base.Face(height=2.0)) == Base.Face(font="test", height=2.0)
-    @test get(Base.FACES.current[], :testface, nothing) == Base.Face(font="test", height=2.0)
-    # Loading from TOML (a Dict)
-    @test Base.loadfaces!(Dict{String, Any}("anotherface" =>
-        Dict{String, Any}("font" => "afont",
-                          "height" => 123,
-                          "weight" => "semibold",
-                          "slant" => "oblique",
-                          "foreground" => "green",
-                          "background" => "magenta",
-                          "underline" => ["blue", "curly"],
-                          "strikethrough" => true,
-                          "inverse" => true,
-                          "inherit" => ["iface"]))) isa Any
-    @test get(Base.FACES.current[], :anotherface, nothing) ==
-        Base.Face(font = "afont", height = 123, weight = :semibold,
-             slant = :oblique, foreground = :green, background = :magenta,
-             underline = (:blue, :curly), strikethrough = true,
-             inverse = true, inherit = [:iface])
-    Base.resetfaces!()
-    @test get(Base.FACES.current[], :bold, nothing) == Base.Face(weight=:bold)
-    @test haskey(Base.FACES.current[], :testface) == false
-    @test haskey(Base.FACES.current[], :anotherface) == false
-    # `withfaces`
-    @test Base.withfaces(() -> get(Base.FACES.current[], :testface, nothing),
-                    :testface => Base.Face(font="test")) == Base.Face(font="test")
-    @test haskey(Base.FACES.current[], :testface) == false
-    # Basic merging
-    let f1 = Base.Face(height=140, weight=:bold, inherit=[:a])
-        f2 = Base.Face(height=1.5, weight=:light, inherit=[:b])
-        f3 = Base.Face(height=1.2, slant=:italic)
-        @test merge(f1, f2, f3) == Base.Face(height=252, weight=:light, slant=:italic)
-        @test merge(f3, f2, f1) == Base.Face(height=140, weight=:bold, slant=:italic, inherit=[:a])
-        @test merge(f3, f1) == Base.Face(height=140, weight=:bold, slant=:italic, inherit=[:a])
-        @test merge(f3, f2) == Base.Face(height=1.5*1.2, weight=:light, slant=:italic, inherit=[:b])
-    end
-    # Merging, inheritence, and canonicalisation
-    let aface = Base.Face(font="a", height=1.2)
-        bface = Base.Face(font="b", height=1.1, weight=:light, inherit=:a)
-        cface = Base.Face(font="c", foreground=:red, inherit=:b)
-        dface = Base.Face(font="d", foreground=:blue, weight=:bold)
-        eface = Base.Face(font="e", inherit = [:c, :d])
-        fface = Base.Face(font="f", inherit = [:d, :c])
-        Base.loadfaces!(:a => aface)
-        Base.loadfaces!(:b => bface)
-        Base.loadfaces!(:c => cface)
-        Base.loadfaces!(:d => dface)
-        Base.loadfaces!(:e => eface)
-        Base.loadfaces!(:f => fface)
-        @test Base.getface(:c) == merge(Base.FACES.current[][:default], aface, bface, cface, Base.Face())
-        @test Base.getface(:b) == merge(Base.FACES.current[][:default], aface, bface, Base.Face())
-        @test Base.getface(:a) == merge(Base.FACES.current[][:default], aface, Base.Face())
-        @test Base.getface([:c]) == Base.getface(:c)
-        @test Base.getface(bface) == Base.getface(:b)
-        @test Base.getface(cface) == Base.getface(:c)
-        @test Base.getface([:c, :d]).foreground.value == :red
-        @test Base.getface(:e).foreground.value == :red
-        @test Base.getface([:d, :c]).foreground.value == :blue
-        @test Base.getface(:f).foreground.value == :blue
-        Base.resetfaces!()
-    end
-end
-
-@testset "Styled string macro" begin
-    # Preservation of an unstyled string
-    @test S"some string" == StyledString("some string")
-    # Basic styled constructs
-    @test S"{thing=val:some} string" == StyledString("some string", [(1:4, :thing => "val")])
-    @test S"some {thing=val:string}" == StyledString("some string", [(6:11, :thing => "val")])
-    @test S"some {a=1:s}trin{b=2:g}" == StyledString("some string", [(6:6, :a => "1"), (11:11, :b => "2")])
-    @test S"{thing=val with spaces:some} string" == StyledString("some string", [(1:4, :thing => "val with spaces")])
-    @test S"{aface:some} string" == StyledString("some string", [(1:4, :face => :aface)])
-    @test S"{aface,bface:some} string" ==
-        StyledString("some string", [(1:4, :face => :aface), (1:4, :face => :bface)])
-    # Inline face attributes
-    @test S"{(slant=italic):some} string" ==
-        StyledString("some string", [(1:4, :face => Base.Face(slant=:italic))])
-    @test S"{(foreground=magenta,background=#555555):some} string" ==
-        StyledString("some string", [(1:4, :face => Base.Face(foreground=:magenta, background=0x555555))])
-    # Curly bracket escaping
-    @test S"some \{string" == StyledString("some {string")
-    @test S"some string\}" == StyledString("some string}")
-    @test S"some \{string\}" == StyledString("some {string}")
-    @test S"some \{str:ing\}" == StyledString("some {str:ing}")
-    @test S"some \{{bold:string}\}" == StyledString("some {string}", [(7:12, :face => :bold)])
-    @test S"some {bold:string \{other\}}" == StyledString("some string {other}", [(6:19, :face => :bold)])
-    # Nesting
-    @test S"{bold:nest{italic:ed st{red:yling}}}" ==
-        StyledString("nested styling", [(1:14, :face => :bold), (5:14, :face => :italic), (10:14, :face => :red)])
-    # Production of a `StyledString` value instead of an expression when possible
-    @test StyledString("val") == @macroexpand S"val"
-    @test StyledString("val", :face => :style) == @macroexpand S"{style:val}"
-    # Interpolation
-    @test :($styledstring(val)) == @macroexpand S"$val"
-    @test :($styledstring("a", val)) == @macroexpand S"a$val"
-    @test :($styledstring("a", val, "b")) == @macroexpand S"a$(val)b"
-    @test :($styledstring($StyledString(string(val), $(Pair{Symbol, Any}(:face, :style))))) ==
-        @macroexpand S"{style:$val}"
-    @test :($styledstring($StyledString("val", [($(1:3), Pair{Symbol, Any}(:face, face))]))) ==
-        @macroexpand S"{$face:val}"
-    @test :($styledstring($StyledString("val", [($(1:3), Pair{Symbol, Any}(key, "val"))]))) ==
-        @macroexpand S"{$key=val:val}"
-    @test :($styledstring($StyledString("val", [($(1:3), Pair{Symbol, Any}(key, val))]))) ==
-        @macroexpand S"{$key=$val:val}"
-    @test :($styledstring($StyledString(string(val), Pair{Symbol, Any}(key, val)))) ==
-        @macroexpand S"{$key=$val:$val}"
-    @test :($styledstring($StyledString("val", [($(1:3), Pair{Symbol, Any}(:face, $(Base.Face)(foreground = color)))]))) ==
-        @macroexpand S"{(foreground=$color):val}"
-end
diff --git a/test/strings/styled.jl b/test/strings/styled.jl
deleted file mode 100644
index 6cdfba082eeda..0000000000000
--- a/test/strings/styled.jl
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-@testset "StyledString" begin
-    str = StyledString("some string")
-    @test str == StyledString(str.string, Tuple{UnitRange{Int64}, Pair{Symbol, Any}}[])
-    @test length(str) == 11
-    @test ncodeunits(str) == 11
-    @test eltype(str) == StyledChar{eltype(str.string)}
-    @test first(str) == StyledChar(first(str.string), Pair{Symbol, Any}[])
-    @test str[1:4] isa SubString{typeof(str)}
-    @test str[1:4] == StyledString("some")
-    @test "a" * str == StyledString("asome string")
-    @test str * "a" == StyledString("some stringa")
-    @test str * str == StyledString("some stringsome string")
-    Base.textproperty!(str, 1:4, :thing, 0x01)
-    Base.textproperty!(str, 5:11, :other, 0x02)
-    Base.textproperty!(str, 1:11, :all, 0x03)
-    @test str[3:4] == SubString(str, 3, 4)
-    @test StyledString(str[3:4]) ==
-        StyledString("me", [(1:2, :thing => 0x01), (1:2, :all => 0x03)])
-    @test str == StyledString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
-    @test str != StyledString("some string")
-    @test str != StyledString("some string", [(1:1, :thing => 0x01), (5:5, :other => 0x02), (11:11, :all => 0x03)])
-    @test str != StyledString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (5:11, :other => 0x12)])
-    @test str != StyledString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
-    let allstrings =
-        ['a', StyledChar('a'), StyledChar('a', :aaa => 0x04),
-        "a string", StyledString("a string"),
-        StyledString("a string", [(1:2, :hmm => '%')])]
-        for str1 in repeat(allstrings, 2)
-            for str2 in repeat(allstrings, 2)
-                @test String(str1 * str2) ==
-                    String(string(str1, str2)) ==
-                    String(string(str1)) * String(string(str2))
-                @test styledstring(str1 * str2) ==
-                    styledstring(str1, str2) ==
-                    styledstring(str1) * styledstring(str2)
-            end
-        end
-    end
-    @test collect(Base.eachstyle(str)) ==
-        [("some", [:thing => 0x01, :all => 0x03]),
-        (" string", [:all => 0x03, :other => 0x02])]
-    @test ==(Base.styledstring_optimize!(
-        StyledString("abc", [(1:1, :val => 1),
-                             (2:2, :val => 2),
-                             (2:2, :val => 1),
-                             (3:3, :val => 2)])),
-             StyledString("abc", [(1:2, :val => 1),
-                                  (2:3, :val => 2)]))
-end
-
-@testset "StyledChar" begin
-    chr = StyledChar('c')
-    @test chr == StyledChar(chr.char, Pair{Symbol, Any}[])
-    str = StyledString("hmm", [(1:1, :attr => "h0h0"),
-                               (1:2, :attr => "h0m1"),
-                               (2:3, :attr => "m1m2")])
-    @test str[1] == StyledChar('h', Pair{Symbol, Any}[:attr => "h0h0"])
-    @test str[2] == StyledChar('m', Pair{Symbol, Any}[:attr => "h0m1", :attr => "m1m2"])
-    @test str[3] == StyledChar('m', Pair{Symbol, Any}[:attr => "m1m2"])
-end
-
-@testset "Styling preservation" begin
-    str = StyledString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
-    @test match(r".e", str).match == str[3:4]
-    @test  match(r"(.e)", str).captures == [str[3:4]]
-    let m0 = match(r"(.)e", str)
-        m1 = first(eachmatch(r"(.)e", str))
-        for f in fieldnames(RegexMatch)
-            @test getfield(m0, f) == getfield(m1, f)
-        end
-    end
-    @test lpad(str, 12) ==
-        StyledString(" some string", [(2:5, :thing => 0x01),
-                                      (2:12, :all => 0x03),
-                                      (6:12, :other => 0x02)])
-    @test rpad(str, 12) ==
-        StyledString("some string ", [(1:4, :thing => 0x01),
-                                      (1:11, :all => 0x03),
-                                      (5:11, :other => 0x02)])
-    str1 = StyledString("test", [(1:4, :tag => 5)])
-    str2 = StyledString("case", [(2:3, :tag => "oomph")])
-    @test join([str1, str1], StyledString(" ")) ==
-        StyledString("test test",
-                     [(1:4, :tag => 5),
-                      (6:9, :tag => 5)])
-    @test join([str1, str1], StyledString(" ", [(1:1, :tag => 2)])) ==
-        StyledString("test test",
-                     [(1:4, :tag => 5),
-                      (5:5, :tag => 2),
-                      (6:9, :tag => 5)])
-    @test repeat(str1, 2) == StyledString("testtest", [(1:8, :tag => 5)])
-    @test repeat(str2, 2) == StyledString("casecase", [(2:3, :tag => "oomph"),
-                                                       (6:7, :tag => "oomph")])
-    @test repeat(str1[1], 3) == StyledString("ttt", [(1:3, :tag => 5)])
-    @test reverse(str1) == StyledString("tset", [(1:4, :tag => 5)])
-    @test reverse(str2) == StyledString("esac", [(2:3, :tag => "oomph")])
-end
diff --git a/test/strings/tagged.jl b/test/strings/tagged.jl
new file mode 100644
index 0000000000000..7c93741168a2e
--- /dev/null
+++ b/test/strings/tagged.jl
@@ -0,0 +1,99 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+@testset "TaggedString" begin
+    str = Base.TaggedString("some string")
+    @test str == Base.TaggedString(str.string, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[])
+    @test length(str) == 11
+    @test ncodeunits(str) == 11
+    @test eltype(str) == Base.TaggedChar{eltype(str.string)}
+    @test first(str) == Base.TaggedChar(first(str.string), Pair{Symbol, Any}[])
+    @test str[1:4] isa SubString{typeof(str)}
+    @test str[1:4] == Base.TaggedString("some")
+    @test "a" * str == Base.TaggedString("asome string")
+    @test str * "a" == Base.TaggedString("some stringa")
+    @test str * str == Base.TaggedString("some stringsome string")
+    Base.textproperty!(str, 1:4, :thing, 0x01)
+    Base.textproperty!(str, 5:11, :other, 0x02)
+    Base.textproperty!(str, 1:11, :all, 0x03)
+    @test str[3:4] == SubString(str, 3, 4)
+    @test Base.TaggedString(str[3:4]) ==
+        Base.TaggedString("me", [(1:2, :thing => 0x01), (1:2, :all => 0x03)])
+    @test str == Base.TaggedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    @test str != Base.TaggedString("some string")
+    @test str != Base.TaggedString("some string", [(1:1, :thing => 0x01), (5:5, :other => 0x02), (11:11, :all => 0x03)])
+    @test str != Base.TaggedString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (5:11, :other => 0x12)])
+    @test str != Base.TaggedString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    let allstrings =
+        ['a', Base.TaggedChar('a'), Base.TaggedChar('a', [:aaa => 0x04]),
+        "a string", Base.TaggedString("a string"),
+        Base.TaggedString("a string", [(1:2, :hmm => '%')])]
+        for str1 in repeat(allstrings, 2)
+            for str2 in repeat(allstrings, 2)
+                @test String(str1 * str2) ==
+                    String(string(str1, str2)) ==
+                    String(string(str1)) * String(string(str2))
+                @test Base.taggedstring(str1 * str2) ==
+                    Base.taggedstring(str1, str2) ==
+                    Base.taggedstring(str1) * Base.taggedstring(str2)
+            end
+        end
+    end
+    # @test collect(Base.eachstyle(str)) ==
+    #     [("some", [:thing => 0x01, :all => 0x03]),
+    #     (" string", [:all => 0x03, :other => 0x02])]
+    @test ==(Base.taggedstring_optimize!(
+        Base.TaggedString("abc", [(1:1, :val => 1),
+                             (2:2, :val => 2),
+                             (2:2, :val => 1),
+                             (3:3, :val => 2)])),
+             Base.TaggedString("abc", [(1:2, :val => 1),
+                                  (2:3, :val => 2)]))
+end
+
+@testset "TaggedChar" begin
+    chr = Base.TaggedChar('c')
+    @test chr == Base.TaggedChar(chr.char, Pair{Symbol, Any}[])
+    str = Base.TaggedString("hmm", [(1:1, :attr => "h0h0"),
+                               (1:2, :attr => "h0m1"),
+                               (2:3, :attr => "m1m2")])
+    @test str[1] == Base.TaggedChar('h', Pair{Symbol, Any}[:attr => "h0h0"])
+    @test str[2] == Base.TaggedChar('m', Pair{Symbol, Any}[:attr => "h0m1", :attr => "m1m2"])
+    @test str[3] == Base.TaggedChar('m', Pair{Symbol, Any}[:attr => "m1m2"])
+end
+
+@testset "Styling preservation" begin
+    str = Base.TaggedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    @test match(r".e", str).match == str[3:4]
+    @test  match(r"(.e)", str).captures == [str[3:4]]
+    let m0 = match(r"(.)e", str)
+        m1 = first(eachmatch(r"(.)e", str))
+        for f in fieldnames(RegexMatch)
+            @test getfield(m0, f) == getfield(m1, f)
+        end
+    end
+    @test lpad(str, 12) ==
+        Base.TaggedString(" some string", [(2:5, :thing => 0x01),
+                                      (2:12, :all => 0x03),
+                                      (6:12, :other => 0x02)])
+    @test rpad(str, 12) ==
+        Base.TaggedString("some string ", [(1:4, :thing => 0x01),
+                                      (1:11, :all => 0x03),
+                                      (5:11, :other => 0x02)])
+    str1 = Base.TaggedString("test", [(1:4, :tag => 5)])
+    str2 = Base.TaggedString("case", [(2:3, :tag => "oomph")])
+    @test join([str1, str1], Base.TaggedString(" ")) ==
+        Base.TaggedString("test test",
+                     [(1:4, :tag => 5),
+                      (6:9, :tag => 5)])
+    @test join([str1, str1], Base.TaggedString(" ", [(1:1, :tag => 2)])) ==
+        Base.TaggedString("test test",
+                     [(1:4, :tag => 5),
+                      (5:5, :tag => 2),
+                      (6:9, :tag => 5)])
+    @test repeat(str1, 2) == Base.TaggedString("testtest", [(1:8, :tag => 5)])
+    @test repeat(str2, 2) == Base.TaggedString("casecase", [(2:3, :tag => "oomph"),
+                                                       (6:7, :tag => "oomph")])
+    @test repeat(str1[1], 3) == Base.TaggedString("ttt", [(1:3, :tag => 5)])
+    @test reverse(str1) == Base.TaggedString("tset", [(1:4, :tag => 5)])
+    @test reverse(str2) == Base.TaggedString("esac", [(2:3, :tag => "oomph")])
+end

From 994719386dcd516685561443fe6e7f4d3ce60cd0 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sat, 7 Oct 2023 13:56:36 +0800
Subject: [PATCH 0052/1315] Converge TaggedString terminology: use annotations

Instead of having a split between Tags/Annotations/Text properties
(regions of the string are annotated with tagged values, and this is a
property of the text), just have Tags/Annotations.

In line with this, the "properties" field of TaggedString/TaggedChar is
renamed to "annotations", and the getter/setter functions are renamed:
- textproperties -> annotations
- textproperty! -> annotate!

While we're at it, improve the docstrings and functions a bit.
---
 base/exports.jl                               |   4 +-
 base/regex.jl                                 |   2 +-
 base/strings/tagged.jl                        | 220 ++++++++++--------
 .../md5                                       |   1 +
 .../sha512                                    |   1 +
 .../md5                                       |   1 -
 .../sha512                                    |   1 -
 doc/src/base/strings.md                       |   4 +-
 stdlib/StyledStrings.version                  |   2 +-
 test/strings/tagged.jl                        |   6 +-
 10 files changed, 138 insertions(+), 104 deletions(-)
 create mode 100644 deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/sha512
 delete mode 100644 deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/sha512

diff --git a/base/exports.jl b/base/exports.jl
index 6b8448459028d..55ad69196bac3 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1094,9 +1094,9 @@ public
     UUID,
 
 # Tagged strings
-    textproperties,
-    textproperty!,
     taggedstring,
+    annotate!,
+    annotations,
 
 # Semaphores
     Semaphore,
diff --git a/base/regex.jl b/base/regex.jl
index bfdeffaec7d66..5316c98492ede 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -709,7 +709,7 @@ struct RegexMatchIterator{S <: AbstractString}
     RegexMatchIterator(regex::Regex, string::AbstractString, ovr::Bool=false) =
         new{String}(regex, String(string), ovr)
     RegexMatchIterator(regex::Regex, string::TaggedString, ovr::Bool=false) =
-        new{TaggedString{String}}(regex, TaggedString(String(string.string), string.properties), ovr)
+        new{TaggedString{String}}(regex, TaggedString(String(string.string), string.annotations), ovr)
 end
 compile(itr::RegexMatchIterator) = (compile(itr.regex); itr)
 eltype(::Type{<:RegexMatchIterator}) = RegexMatch
diff --git a/base/strings/tagged.jl b/base/strings/tagged.jl
index b9b9740dc8a32..8435361a81450 100644
--- a/base/strings/tagged.jl
+++ b/base/strings/tagged.jl
@@ -3,63 +3,85 @@
 """
     TaggedString{S <: AbstractString} <: AbstractString
 
-A string with annotated regions (often styling information).
+A string with metadata, in the form of annotated regions.
+
+More specifically, this is a simple wrapper around any other
+[`AbstractString`](@ref) that allows for regions of the wrapped string to be
+annotated with tagged values.
+
+```text
+                        C
+                    ┌───┸─────────┐
+  "this is an example tagged string"
+  └──┰────────┼─────┘      │
+     A        └───┰────────┘
+                  B
+```
 
-More specifically, this is a thin wrapper around any other [`AbstractString`](@ref),
-allows arbitary tagged values to be attached to regions of the wrapped string.
+The above diagram represents a `TaggedString` where three ranges have been
+annotated (labeled `A`, `B`, and `C`). Each annotation must take the form of a
+`Pair{Symbol, <:Any}`, where a `Symbol` "tag" is used to label `Any` "value".
 
-Each tag takes the form of a `Pair{Symbol, <:Any}`, the first value being the
-tag name, and the second the value. A single region can be annotated with the
-same tag multiple times.
+Tags do not need to be unique, the same region can be annotated with the same
+tag multiple times.
 
-See also [`TaggedChar`](@ref), [`taggedstring`](@ref), [`textproperties`](@ref), and
-[`textproperty!`](@ref).
+See also [`TaggedChar`](@ref), [`taggedstring`](@ref), [`annotations`](@ref), and
+[`annotate!`](@ref).
 
 !!! warning
     While the constructors are part of the Base public API, the fields
     of `TaggedString` are not. This is to allow for potential future
     changes in the implementation of this type. Instead use the
-    [`textproperties`](@ref), and [`textproperty!`](@ref) getter/setter
+    [`annotations`](@ref), and [`annotate!`](@ref) getter/setter
     functions.
 
 # Constructors
 
 ```julia
 TaggedString(s::S<:AbstractString) -> TaggedString{S}
-TaggedString(s::S<:AbstractString, properties::Vector{Tuple{UnitRange{Int}, Pair{Symbol, <:Any}}})
+TaggedString(s::S<:AbstractString, annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, <:Any}}})
 ```
 
 A TaggedString can also be created with [`taggedstring`](@ref), which acts much
 like [`string`](@ref) but preserves any tags present in the arguments.
+
+# Example
+
+```julia-repl
+julia> TaggedString("this is an example tagged string",
+                    [(1:18, :A => 1), (12:25, :B => 2), (18:32, :C => 3)])
+"this is an example tagged string"
+```
 """
 struct TaggedString{S <: AbstractString} <: AbstractString
     string::S
-    properties::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+    annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
 end
 
 """
     TaggedChar{S <: AbstractChar} <: AbstractChar
 
-A Char annotated with tags.
+A Char annotated with tagged values.
 
-More specifically, this is a thin wrapper around any other [`AbstractChar`](@ref),
-which adds arbitrary tags to the wrapped character.
+More specifically, this is a simple wrapper around any other
+[`AbstractChar`](@ref), which holds a list of arbitrary tagged values
+(`Pair{Symbol, <:Any}`) with the wrapped character.
 
-See also: [`TaggedString`](@ref), [`taggedstring`](@ref), `textproperties`, and
-`textproperty!`.
+See also: [`TaggedString`](@ref), [`taggedstring`](@ref), `annotations`,
+and `annotate!`.
 
 !!! warning
     While the constructors are part of the Base public API, the fields
     of `TaggedChar` are not. This it to allow for potential future
     changes in the implementation of this type. Instead use the
-    [`textproperties`](@ref), and [`textproperty!`](@ref) getter/setter
+    [`annotations`](@ref), and [`annotate!`](@ref) getter/setter
     functions.
 
 # Constructors
 
 ```julia
 TaggedChar(s::S) -> TaggedChar{S}
-TaggedChar(s::S, properties::Vector{Pair{Symbol, <:Any}})
+TaggedChar(s::S, annotations::Vector{Pair{Symbol, <:Any}})
 ```
 
 # Examples
@@ -71,26 +93,26 @@ julia> TaggedChar('j', :tag => 1)
 """
 struct TaggedChar{C <: AbstractChar} <: AbstractChar
     char::C
-    properties::Vector{Pair{Symbol, Any}}
+    annotations::Vector{Pair{Symbol, Any}}
 end
 
 ## Constructors ##
 
 # When called with overly-specialised arguments
 
-TaggedString(s::AbstractString, props::Vector{<:Tuple{UnitRange{Int}, <:Pair{Symbol, <:Any}}}) =
-    TaggedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}(props))
+TaggedString(s::AbstractString, annots::Vector{<:Tuple{UnitRange{Int}, <:Pair{Symbol, <:Any}}}) =
+    TaggedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}(annots))
 
-TaggedChar(c::AbstractChar, props::Vector{<:Pair{Symbol, <:Any}}) =
-    TaggedChar(c, Vector{Pair{Symbol, Any}}(props))
+TaggedChar(c::AbstractChar, annots::Vector{<:Pair{Symbol, <:Any}}) =
+    TaggedChar(c, Vector{Pair{Symbol, Any}}(annots))
 
 # Constructors to avoid recursive wrapping
 
-TaggedString(s::TaggedString, props::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}) =
-    TaggedString(s.string, vcat(s.properties, props))
+TaggedString(s::TaggedString, annots::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}) =
+    TaggedString(s.string, vcat(s.annotations, annots))
 
-TaggedChar(c::TaggedChar, props::Vector{Pair{Symbol, Any}}) =
-    TaggedChar(c.char, vcat(s.properties, props))
+TaggedChar(c::TaggedChar, annots::Vector{Pair{Symbol, Any}}) =
+    TaggedChar(c.char, vcat(s.annotations, annots))
 
 String(s::TaggedString{String}) = s.string # To avoid pointless overhead
 
@@ -131,7 +153,7 @@ lastindex(s::TaggedString) = lastindex(s.string)
 function getindex(s::TaggedString, i::Integer)
     @boundscheck checkbounds(s, i)
     @inbounds if isvalid(s, i)
-        TaggedChar(s.string[i], textproperties(s, i))
+        TaggedChar(s.string[i], annotations(s, i))
     else
         string_index_err(s, i)
     end
@@ -149,10 +171,10 @@ cmp(a::AbstractString, b::TaggedString) = cmp(a, b.string)
 cmp(a::TaggedString, b::TaggedString) = cmp(a.string, b.string)
 
 ==(a::TaggedString, b::TaggedString) =
-    a.string == b.string && a.properties == b.properties
+    a.string == b.string && a.annotations == b.annotations
 
-==(a::TaggedString, b::AbstractString) = isempty(a.properties) && a.string == b
-==(a::AbstractString, b::TaggedString) = isempty(b.properties) && a == b.string
+==(a::TaggedString, b::AbstractString) = isempty(a.annotations) && a.string == b
+==(a::AbstractString, b::TaggedString) = isempty(b.annotations) && a == b.string
 
 """
     taggedstring(values...)
@@ -160,7 +182,7 @@ cmp(a::TaggedString, b::TaggedString) = cmp(a.string, b.string)
 Create a `TaggedString` from any number of `values` using their
 [`print`](@ref)ed representation.
 
-This acts like [`string`](@ref), but takes care to preserve any properties
+This acts like [`string`](@ref), but takes care to preserve any annotations
 present (in the form of [`TaggedString`](@ref) or [`TaggedChar`](@ref) values).
 
 See also [`TaggedString`](@ref) and [`TaggedChar`](@ref).
@@ -179,26 +201,26 @@ function taggedstring(xs...)
     isempty(xs) && return TaggedString("")
     size = mapreduce(_str_sizehint, +, xs)
     s = IOContext(IOBuffer(sizehint=size), :color => true)
-    properties = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
     for x in xs
         if x isa TaggedString
-            for (region, prop) in x.properties
-                push!(properties, (s.io.size .+ (region), prop))
+            for (region, annot) in x.annotations
+                push!(annotations, (s.io.size .+ (region), annot))
             end
             print(s, x.string)
         elseif x isa SubString{<:TaggedString}
-            for (region, prop) in x.string.properties
+            for (region, annot) in x.string.annotations
                 start, stop = first(region), last(region)
                 if start <= x.offset + x.ncodeunits && stop > x.offset
                     rstart = s.io.size + max(0, start - x.offset) + 1
                     rstop = s.io.size + min(stop, x.offset + x.ncodeunits) - x.offset
-                    push!(properties, (rstart:rstop, prop))
+                    push!(annotations, (rstart:rstop, annot))
                 end
             end
             print(s, SubString(x.string.string, x.offset, x.ncodeunits, Val(:noshift)))
         elseif x isa TaggedChar
-            for prop in x.properties
-                push!(properties, (1+s.io.size:1+s.io.size, prop))
+            for annot in x.annotations
+                push!(annotations, (1+s.io.size:1+s.io.size, annot))
             end
             print(s, x.char)
         else
@@ -206,12 +228,12 @@ function taggedstring(xs...)
         end
     end
     str = String(resize!(s.io.data, s.io.size))
-    TaggedString(str, properties)
+    TaggedString(str, annotations)
 end
 
 taggedstring(s::TaggedString) = s
 taggedstring(c::TaggedChar) =
-    TaggedString(string(c.char), [(1:ncodeunits(c), c.properties)])
+    TaggedString(string(c.char), [(1:ncodeunits(c), annot) for annot in c.annotations])
 
 TaggedString(s::SubString{<:TaggedString}) = taggedstring(s)
 
@@ -223,17 +245,17 @@ Merge contiguous identical tags in `str`.
 function taggedstring_optimize!(s::TaggedString)
     last_seen = Dict{Pair{Symbol, Any}, Int}()
     i = 1
-    while i <= length(s.properties)
-        region, keyval = s.properties[i]
+    while i <= length(s.annotations)
+        region, keyval = s.annotations[i]
         prev = get(last_seen, keyval, 0)
         if prev > 0
-            lregion, _ = s.properties[prev]
+            lregion, _ = s.annotations[prev]
             if last(lregion) + 1 == first(region)
-                s.properties[prev] =
-                    setindex(s.properties[prev],
+                s.annotations[prev] =
+                    setindex(s.annotations[prev],
                              first(lregion):last(region),
                              1)
-                deleteat!(s.properties, i)
+                deleteat!(s.annotations, i)
             else
                 delete!(last_seen, keyval)
             end
@@ -249,22 +271,22 @@ function repeat(str::TaggedString, r::Integer)
     r == 0 && return one(TaggedString)
     r == 1 && return str
     untagged = repeat(str.string, r)
-    properties = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
     len = ncodeunits(str)
     fullregion = firstindex(str):lastindex(str)
-    for (region, prop) in str.properties
+    for (region, annot) in str.annotations
         if region == fullregion
-            push!(properties, (firstindex(untagged):lastindex(untagged), prop))
+            push!(annotations, (firstindex(untagged):lastindex(untagged), annot))
         end
     end
     for offset in 0:len:(r-1)*len
-        for (region, prop) in str.properties
+        for (region, annot) in str.annotations
             if region != fullregion
-                push!(properties, (region .+ offset, prop))
+                push!(annotations, (region .+ offset, annot))
             end
         end
     end
-    TaggedString(untagged, properties) |> taggedstring_optimize!
+    TaggedString(untagged, annotations) |> taggedstring_optimize!
 end
 
 repeat(str::SubString{<:TaggedString}, r::Integer) =
@@ -273,7 +295,7 @@ repeat(str::SubString{<:TaggedString}, r::Integer) =
 function repeat(c::TaggedChar, r::Integer)
     str = repeat(c.char, r)
     fullregion = firstindex(str):lastindex(str)
-    TaggedString(str, [(fullregion, prop) for prop in c.properties])
+    TaggedString(str, [(fullregion, annot) for annot in c.annotations])
 end
 
 function reverse(s::TaggedString)
@@ -281,8 +303,8 @@ function reverse(s::TaggedString)
     TaggedString(reverse(s.string),
                  [(UnitRange(1 + lastind - last(region),
                              1 + lastind - first(region)),
-                   prop)
-                  for (region, prop) in s.properties])
+                   annot)
+                  for (region, annot) in s.annotations])
 end
 
 # TODO optimise?
@@ -293,62 +315,74 @@ reverse(s::SubString{<:TaggedString}) = reverse(TaggedString(s))
 ## End AbstractString interface ##
 
 """
-    textproperty!(str::TaggedString, [range::UnitRange{Int}], tag::Symbol, value)
-    textproperty!(str::SubString{TaggedString}, [range::UnitRange{Int}], tag::Symbol, value)
+    annotate!(str::TaggedString, [range::UnitRange{Int}], tag::Symbol => value)
+    annotate!(str::SubString{TaggedString}, [range::UnitRange{Int}], tag::Symbol => value)
 
-Add `tag` with `value` in `str`, over `range` if specified or the whole
-string otherwise.
+Annotate a `range` of `str` (or the entire string) with a tagged value (`tag` =>
+`value`). To remove existing `tag` annotations, use a value of `nothing`.
 """
-function textproperty!(s::TaggedString, range::UnitRange{Int}, tag::Symbol, val)
-    indices = searchsorted(s.properties, (range,), by=first)
-    tagindex = filter(i -> first(s.properties[i][2]) === tag, indices)
-    if length(tagindex) == 1
-        if val === nothing
-            deleteat!(s.properties, first(tagindex))
-        else
-            s.properties[first(tagindex)] = (range, Pair{Symbol, Any}(tag, val))
+function annotate!(s::TaggedString, range::UnitRange{Int}, @nospecialize(tagval::Pair{Symbol, <:Any}))
+    tag, val = tagval
+    indices = searchsorted(s.annotations, (range,), by=first)
+    if val === nothing
+        tagindex = filter(i -> first(s.annotations[i][2]) === tag, indices)
+        for index in Iterators.reverse(tagindex)
+            deleteat!(s.annotations, index)
         end
     else
-        splice!(s.properties, indices, [(range, Pair{Symbol, Any}(tag, val))])
+        splice!(s.annotations, indices, [(range, Pair{Symbol, Any}(tag, val))])
     end
     s
 end
 
-textproperty!(ss::TaggedString, tag::Symbol, value) =
-    textproperty!(ss, firstindex(ss):lastindex(ss), tag, value)
+annotate!(ss::TaggedString, @nospecialize(tagval::Pair{Symbol, <:Any})) =
+    annotate!(ss, firstindex(ss):lastindex(ss), tagval)
 
-textproperty!(s::SubString{<:TaggedString}, range::UnitRange{Int}, tag::Symbol, value) =
-    (textproperty!(s.string, s.offset .+ (range), tag, value); s)
+annotate!(s::SubString{<:TaggedString}, range::UnitRange{Int}, @nospecialize(tagval::Pair{Symbol, <:Any})) =
+    (annotate!(s.string, s.offset .+ (range), tagval); s)
 
-textproperty!(s::SubString{<:TaggedString}, tag::Symbol, value) =
-    (textproperty!(s.string, s.offset .+ (1:s.ncodeunits), tag, value); s)
+annotate!(s::SubString{<:TaggedString}, @nospecialize(tagval::Pair{Symbol, <:Any})) =
+    (annotate!(s.string, s.offset .+ (1:s.ncodeunits), tagval); s)
 
 """
-    textproperties(s::TaggedString, i::Integer)
-    textproperties(s::SubString{TaggedString}, i::Integer)
+    annotate!(char::TaggedChar, tag::Symbol => value)
 
-Get the text properties that apply to `s` at index `i`.
+Annotate `char` with the pair `tag => value`.
 """
-function textproperties(s::TaggedString, i::Integer)
-    # TODO optimise
-    props = filter(tag -> !isempty(intersect(i:i, first(tag))),
-                   s.properties)
-    last.(props)
-end
-
-textproperties(s::SubString{<:TaggedString}, i::Integer) =
-    textproperties(s.string, s.offset + i)
+annotate!(c::TaggedChar, @nospecialize(tagval::Pair{Symbol, <:Any})) =
+    (push!(c.annotations, tagval); c)
 
 """
-    textproperties(c::TaggedChar)
+    annotations(str::TaggedString, [position::Union{Integer, UnitRange}])
+    annotations(str::SubString{TaggedString}, [position::Union{Integer, UnitRange}])
+
+Get all annotations that apply to `str`. Should `position` be provided, only
+annotations that overlap with `position` will be returned.
 
-Get the properties that apply to `c`.
+See also: `annotate!`.
 """
-textproperties(c::TaggedChar) = c.properties
+annotations(s::TaggedString) = s.annotations
+
+annotations(s::SubString{<:TaggedString}) =
+    annotations(s, s.offset+1:s.offset+s.ncodeunits)
+
+function annotations(s::TaggedString, pos::UnitRange{<:Integer})
+    # TODO optimise
+    annots = filter(tag -> !isempty(intersect(pos, first(tag))),
+                    s.annotations)
+    last.(annots)
+end
+
+annotations(s::TaggedString, pos::Integer) = annotations(s, pos:pos)
+
+annotations(s::SubString{<:TaggedString}, pos::Integer) =
+    annotations(s.string, s.offset + pos)
+annotations(s::SubString{<:TaggedString}, pos::UnitRange{<:Integer}) =
+    annotations(s.string, first(pos)+s.offset:last(pos)+s.offset)
 
 """
-    textproperty!(char::TaggedChar, tag::Symbol, value)
+    annotations(chr::TaggedChar)
 
- Add a `tag` with `value` to `char`.
+Get all annotations of `chr`.
 """
-textproperty!(c::TaggedString, tag::Symbol, value)
+annotations(c::TaggedChar) = c.annotations
diff --git a/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/md5 b/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/md5
new file mode 100644
index 0000000000000..8a7dc7653ee71
--- /dev/null
+++ b/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/md5
@@ -0,0 +1 @@
+30489ddcd3e8e407e9d4bca38c1a1124
diff --git a/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/sha512 b/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/sha512
new file mode 100644
index 0000000000000..9e5d031bf612e
--- /dev/null
+++ b/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/sha512
@@ -0,0 +1 @@
+f4b786436786ce76dc86f5838233030678587e31320bdb5e642c7ee11b15bcbfb6a8fd82481975403a86dce8073d2560484f794cedc2a3aa63477567beeedb1a
diff --git a/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/md5 b/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/md5
deleted file mode 100644
index 99f97b403aaae..0000000000000
--- a/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-0c4ac1a2aa9d46afeffd3db5ef022ddc
diff --git a/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/sha512 b/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/sha512
deleted file mode 100644
index 048c38006e7cb..0000000000000
--- a/deps/checksums/StyledStrings-745385d0ac8559b67111f96050f937e1bc70bf71.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-6fab5fb2bb79d1aa5dad6ae38e69c0f9bf07541d69511cc78305a8524fab891d97b103f96834be4e6b5e4f302f6abdc2736e34ddca324dcd98021a192962d0ad
diff --git a/doc/src/base/strings.md b/doc/src/base/strings.md
index 8495b712eb494..44ec0fe275b97 100644
--- a/doc/src/base/strings.md
+++ b/doc/src/base/strings.md
@@ -20,8 +20,8 @@ Base.@lazy_str
 Base.TaggedString
 Base.TaggedChar
 Base.taggedstring
-Base.textproperties
-Base.textproperty!
+Base.annotations
+Base.annotate!
 Base.transcode
 Base.unsafe_string
 Base.ncodeunits(::AbstractString)
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index 9f7a781306d72..3baf10de2f453 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = 745385d0ac8559b67111f96050f937e1bc70bf71
+STYLEDSTRINGS_SHA1 = 0540bdfe126aff87fcfe27f5509a76ccbf582182
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1
diff --git a/test/strings/tagged.jl b/test/strings/tagged.jl
index 7c93741168a2e..229fc53ef9e77 100644
--- a/test/strings/tagged.jl
+++ b/test/strings/tagged.jl
@@ -12,9 +12,9 @@
     @test "a" * str == Base.TaggedString("asome string")
     @test str * "a" == Base.TaggedString("some stringa")
     @test str * str == Base.TaggedString("some stringsome string")
-    Base.textproperty!(str, 1:4, :thing, 0x01)
-    Base.textproperty!(str, 5:11, :other, 0x02)
-    Base.textproperty!(str, 1:11, :all, 0x03)
+    Base.annotate!(str, 1:4, :thing => 0x01)
+    Base.annotate!(str, 5:11, :other => 0x02)
+    Base.annotate!(str, 1:11, :all => 0x03)
     @test str[3:4] == SubString(str, 3, 4)
     @test Base.TaggedString(str[3:4]) ==
         Base.TaggedString("me", [(1:2, :thing => 0x01), (1:2, :all => 0x03)])

From e5cd9b6b3888c907247917534c414a8a0344facf Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sun, 15 Oct 2023 21:30:11 +0800
Subject: [PATCH 0053/1315] =?UTF-8?q?Rename=20(Tagged=20=E2=86=92=20Annota?=
 =?UTF-8?q?ted)String,=20etc.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In response to further naming discussion. Please, please, let this be
the last rename.

Along the way we have some docstring improvements and stricter macro
construction in the StyledStrings stdlib (erroring on invalid syntax,
instead of warning), with more informative messages.
---
 NEWS.md                                       |  17 +-
 base/exports.jl                               |   8 +-
 base/regex.jl                                 |  24 +-
 base/strings/annotated.jl                     | 388 ++++++++++++++++++
 base/strings/basic.jl                         |  14 +-
 base/strings/io.jl                            |  26 +-
 base/strings/strings.jl                       |   2 +-
 base/strings/tagged.jl                        | 388 ------------------
 base/strings/util.jl                          |   8 +-
 .../md5                                       |   1 -
 .../sha512                                    |   1 -
 .../md5                                       |   1 +
 .../sha512                                    |   1 +
 doc/src/base/strings.md                       |   6 +-
 doc/src/manual/strings.md                     |  30 +-
 stdlib/StyledStrings.version                  |   2 +-
 test/choosetests.jl                           |   2 +-
 test/strings/annotated.jl                     |  99 +++++
 test/strings/tagged.jl                        |  99 -----
 19 files changed, 559 insertions(+), 558 deletions(-)
 create mode 100644 base/strings/annotated.jl
 delete mode 100644 base/strings/tagged.jl
 delete mode 100644 deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/sha512
 create mode 100644 deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/sha512
 create mode 100644 test/strings/annotated.jl
 delete mode 100644 test/strings/tagged.jl

diff --git a/NEWS.md b/NEWS.md
index 3f12583f76c66..fb6d79ec78836 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -8,11 +8,11 @@ New language features
   difference between `public` and `export` is that `public` names do not become
   available when `using` a package/module. ([#50105])
 * `ScopedValue` implement dynamic scope with inheritance across tasks ([#50958]).
-* A new `AbstractString` type, `TaggedString`, is introduced that allows for
-  (arbitrary) regional annotations to be attached to an underlying string. This is
-  very useful for allowing styling information to be encoded separately, and is
-  used extensively in the new `StyledStrings` standard library. There is also a
-  new `TaggedChar` type, that is the equivalent new `AbstractChar` type.
+* A new `AbstractString` type, `AnnotatedString`, is introduced that allows for
+  regional annotations to be attached to an underlying string. This type is
+  particularly useful for holding styling information, and is used extensively
+  in the new `StyledStrings` standard library. There is also a new `AnnotatedChar`
+  type, that is the equivalent new `AbstractChar` type.
 
 Language changes
 ----------------
@@ -60,11 +60,12 @@ Standard library changes
 
 * A new standard library for handling styling in a more comprehensive and structured way.
 * The new `Faces` struct serves as a container for text styling information
-  (think typeface), and comes with a framework to provide a convenient,
-  extensible (via `addface!`), and customisable (with a user's `Faces.toml` and `loadfaces!`) approach to
+  (think typeface, as well as color and decoration), and comes with a framework
+  to provide a convenient, extensible (via `addface!`), and customisable (with a
+  user's `Faces.toml` and `loadfaces!`) approach to
   styled content.
 * The new `@styled_str` string macro provides a convenient way of creating a
-  `TaggedString` with various faces or other attributes applied.
+  `AnnotatedString` with various faces or other attributes applied.
 
 #### Package Manager
 
diff --git a/base/exports.jl b/base/exports.jl
index 55ad69196bac3..b6f7ea0d6ad35 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1089,12 +1089,12 @@ public
     Generator,
     ImmutableDict,
     OneTo,
-    TaggedString,
-    TaggedChar,
+    AnnotatedString,
+    AnnotatedChar,
     UUID,
 
-# Tagged strings
-    taggedstring,
+# Annotated strings
+    annotatedstring,
     annotate!,
     annotations,
 
diff --git a/base/regex.jl b/base/regex.jl
index 5316c98492ede..78eefa1741b0c 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -427,35 +427,35 @@ function match(re::Regex, str::Union{SubString{String}, String}, idx::Integer,
     return result
 end
 
-function _taggedmatch(m::RegexMatch{S}, str::TaggedString{S}) where {S<:AbstractString}
-    RegexMatch{TaggedString{S}}(
-        (@inbounds SubString{TaggedString{S}}(
+function _annotatedmatch(m::RegexMatch{S}, str::AnnotatedString{S}) where {S<:AbstractString}
+    RegexMatch{AnnotatedString{S}}(
+        (@inbounds SubString{AnnotatedString{S}}(
             str, m.match.offset, m.match.ncodeunits, Val(:noshift))),
-        Union{Nothing,SubString{TaggedString{S}}}[
+        Union{Nothing,SubString{AnnotatedString{S}}}[
             if !isnothing(cap)
-                (@inbounds SubString{TaggedString{S}}(
+                (@inbounds SubString{AnnotatedString{S}}(
                     str, cap.offset, cap.ncodeunits, Val(:noshift)))
             end for cap in m.captures],
         m.offset, m.offsets, m.regex)
 end
 
-function match(re::Regex, str::TaggedString)
+function match(re::Regex, str::AnnotatedString)
     m = match(re, str.string)
     if !isnothing(m)
-        _taggedmatch(m, str)
+        _annotatedmatch(m, str)
     end
 end
 
-function match(re::Regex, str::TaggedString, idx::Integer, add_opts::UInt32=UInt32(0))
+function match(re::Regex, str::AnnotatedString, idx::Integer, add_opts::UInt32=UInt32(0))
     m = match(re, str.string, idx, add_opts)
     if !isnothing(m)
-        _taggedmatch(m, str)
+        _annotatedmatch(m, str)
     end
 end
 
 match(r::Regex, s::AbstractString) = match(r, s, firstindex(s))
 match(r::Regex, s::AbstractString, i::Integer) = throw(ArgumentError(
-    "regex matching is only available for the String and TaggedString types; use String(s) to convert"
+    "regex matching is only available for the String and AnnotatedString types; use String(s) to convert"
 ))
 
 findnext(re::Regex, str::Union{String,SubString}, idx::Integer) = _findnext_re(re, str, idx, C_NULL)
@@ -708,8 +708,8 @@ struct RegexMatchIterator{S <: AbstractString}
 
     RegexMatchIterator(regex::Regex, string::AbstractString, ovr::Bool=false) =
         new{String}(regex, String(string), ovr)
-    RegexMatchIterator(regex::Regex, string::TaggedString, ovr::Bool=false) =
-        new{TaggedString{String}}(regex, TaggedString(String(string.string), string.annotations), ovr)
+    RegexMatchIterator(regex::Regex, string::AnnotatedString, ovr::Bool=false) =
+        new{AnnotatedString{String}}(regex, AnnotatedString(String(string.string), string.annotations), ovr)
 end
 compile(itr::RegexMatchIterator) = (compile(itr.regex); itr)
 eltype(::Type{<:RegexMatchIterator}) = RegexMatch
diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
new file mode 100644
index 0000000000000..2df0ece80da1f
--- /dev/null
+++ b/base/strings/annotated.jl
@@ -0,0 +1,388 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+"""
+    AnnotatedString{S <: AbstractString} <: AbstractString
+
+A string with metadata, in the form of annotated regions.
+
+More specifically, this is a simple wrapper around any other
+[`AbstractString`](@ref) that allows for regions of the wrapped string to be
+annotated with labeled values.
+
+```text
+                           C
+                    ┌──────┸─────────┐
+  "this is an example annotated string"
+  └──┰────────┼─────┘         │
+     A        └─────┰─────────┘
+                    B
+```
+
+The above diagram represents a `AnnotatedString` where three ranges have been
+annotated (labeled `A`, `B`, and `C`). Each annotation holds a label (`Symbol`)
+and a value (`Any`), paired together as a `Pair{Symbol, <:Any}`.
+
+Labels do not need to be unique, the same region can hold multiple annotations
+with the same label.
+
+See also [`AnnotatedChar`](@ref), [`annotatedstring`](@ref),
+[`annotations`](@ref), and [`annotate!`](@ref).
+
+!!! warning
+    While the constructors are part of the Base public API, the fields
+    of `AnnotatedString` are not. This is to allow for potential future
+    changes in the implementation of this type. Instead use the
+    [`annotations`](@ref), and [`annotate!`](@ref) getter/setter
+    functions.
+
+# Constructors
+
+```julia
+AnnotatedString(s::S<:AbstractString) -> AnnotatedString{S}
+AnnotatedString(s::S<:AbstractString, annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, <:Any}}})
+```
+
+A AnnotatedString can also be created with [`annotatedstring`](@ref), which acts much
+like [`string`](@ref) but preserves any annotations present in the arguments.
+
+# Example
+
+```julia-repl
+julia> AnnotatedString("this is an example annotated string",
+                    [(1:18, :A => 1), (12:28, :B => 2), (18:35, :C => 3)])
+"this is an example annotated string"
+```
+"""
+struct AnnotatedString{S <: AbstractString} <: AbstractString
+    string::S
+    annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+end
+
+"""
+    AnnotatedChar{S <: AbstractChar} <: AbstractChar
+
+A Char with annotations.
+
+More specifically, this is a simple wrapper around any other
+[`AbstractChar`](@ref), which holds a list of arbitrary labeled annotations
+(`Pair{Symbol, <:Any}`) with the wrapped character.
+
+See also: [`AnnotatedString`](@ref), [`annotatedstring`](@ref), `annotations`,
+and `annotate!`.
+
+!!! warning
+    While the constructors are part of the Base public API, the fields
+    of `AnnotatedChar` are not. This it to allow for potential future
+    changes in the implementation of this type. Instead use the
+    [`annotations`](@ref), and [`annotate!`](@ref) getter/setter
+    functions.
+
+# Constructors
+
+```julia
+AnnotatedChar(s::S) -> AnnotatedChar{S}
+AnnotatedChar(s::S, annotations::Vector{Pair{Symbol, <:Any}})
+```
+
+# Examples
+
+```julia-repl
+julia> AnnotatedChar('j', :label => 1)
+'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
+```
+"""
+struct AnnotatedChar{C <: AbstractChar} <: AbstractChar
+    char::C
+    annotations::Vector{Pair{Symbol, Any}}
+end
+
+## Constructors ##
+
+# When called with overly-specialised arguments
+
+AnnotatedString(s::AbstractString, annots::Vector{<:Tuple{UnitRange{Int}, <:Pair{Symbol, <:Any}}}) =
+    AnnotatedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}(annots))
+
+AnnotatedChar(c::AbstractChar, annots::Vector{<:Pair{Symbol, <:Any}}) =
+    AnnotatedChar(c, Vector{Pair{Symbol, Any}}(annots))
+
+# Constructors to avoid recursive wrapping
+
+AnnotatedString(s::AnnotatedString, annots::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}) =
+    AnnotatedString(s.string, vcat(s.annotations, annots))
+
+AnnotatedChar(c::AnnotatedChar, annots::Vector{Pair{Symbol, Any}}) =
+    AnnotatedChar(c.char, vcat(s.annotations, annots))
+
+String(s::AnnotatedString{String}) = s.string # To avoid pointless overhead
+
+## Conversion/promotion ##
+
+convert(::Type{AnnotatedString}, s::AnnotatedString) = s
+convert(::Type{AnnotatedString{S}}, s::S) where {S <: AbstractString} =
+    AnnotatedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
+convert(::Type{AnnotatedString}, s::S) where {S <: AbstractString} =
+    convert(AnnotatedString{S}, s)
+AnnotatedString(s::S) where {S <: AbstractString} = convert(AnnotatedString{S}, s)
+
+convert(::Type{AnnotatedChar}, c::AnnotatedChar) = c
+convert(::Type{AnnotatedChar{C}}, c::C) where { C <: AbstractChar } =
+    AnnotatedChar{C}(c, Vector{Pair{Symbol, Any}}())
+convert(::Type{AnnotatedChar}, c::C) where { C <: AbstractChar } =
+    convert(AnnotatedChar{C}, c)
+
+AnnotatedChar(c::AbstractChar) = convert(AnnotatedChar, c)
+AnnotatedChar(c::UInt32) = convert(AnnotatedChar, Char(c))
+AnnotatedChar{C}(c::UInt32) where {C <: AbstractChar} = convert(AnnotatedChar, C(c))
+
+promote_rule(::Type{<:AnnotatedString}, ::Type{<:AbstractString}) = AnnotatedString
+
+## AbstractString interface ##
+
+ncodeunits(s::AnnotatedString) = ncodeunits(s.string)
+codeunits(s::AnnotatedString) = codeunits(s.string)
+codeunit(s::AnnotatedString) = codeunit(s.string)
+codeunit(s::AnnotatedString, i::Integer) = codeunit(s.string, i)
+isvalid(s::AnnotatedString, i::Integer) = isvalid(s.string, i)
+@propagate_inbounds iterate(s::AnnotatedString, i::Integer=firstindex(s)) =
+    if i <= lastindex(s.string); (s[i], nextind(s, i)) end
+eltype(::Type{<:AnnotatedString{S}}) where {S} = AnnotatedChar{eltype(S)}
+firstindex(s::AnnotatedString) = firstindex(s.string)
+lastindex(s::AnnotatedString) = lastindex(s.string)
+
+function getindex(s::AnnotatedString, i::Integer)
+    @boundscheck checkbounds(s, i)
+    @inbounds if isvalid(s, i)
+        AnnotatedChar(s.string[i], annotations(s, i))
+    else
+        string_index_err(s, i)
+    end
+end
+
+## AbstractChar interface ##
+
+ncodeunits(c::AnnotatedChar) = ncodeunits(c.char)
+codepoint(c::AnnotatedChar) = codepoint(c.char)
+
+# Avoid the iteration fallback with comparison
+cmp(a::AnnotatedString, b::AbstractString) = cmp(a.string, b)
+cmp(a::AbstractString, b::AnnotatedString) = cmp(a, b.string)
+# To avoid method ambiguity
+cmp(a::AnnotatedString, b::AnnotatedString) = cmp(a.string, b.string)
+
+==(a::AnnotatedString, b::AnnotatedString) =
+    a.string == b.string && a.annotations == b.annotations
+
+==(a::AnnotatedString, b::AbstractString) = isempty(a.annotations) && a.string == b
+==(a::AbstractString, b::AnnotatedString) = isempty(b.annotations) && a == b.string
+
+"""
+    annotatedstring(values...)
+
+Create a `AnnotatedString` from any number of `values` using their
+[`print`](@ref)ed representation.
+
+This acts like [`string`](@ref), but takes care to preserve any annotations
+present (in the form of [`AnnotatedString`](@ref) or [`AnnotatedChar`](@ref) values).
+
+See also [`AnnotatedString`](@ref) and [`AnnotatedChar`](@ref).
+
+## Examples
+
+```julia-repl
+julia> annotatedstring("now a AnnotatedString")
+"now a AnnotatedString"
+
+julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label => 1)]), ", and unannotated")
+"annotated, and unannotated"
+```
+"""
+function annotatedstring(xs...)
+    isempty(xs) && return AnnotatedString("")
+    size = mapreduce(_str_sizehint, +, xs)
+    s = IOContext(IOBuffer(sizehint=size), :color => true)
+    annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    for x in xs
+        if x isa AnnotatedString
+            for (region, annot) in x.annotations
+                push!(annotations, (s.io.size .+ (region), annot))
+            end
+            print(s, x.string)
+        elseif x isa SubString{<:AnnotatedString}
+            for (region, annot) in x.string.annotations
+                start, stop = first(region), last(region)
+                if start <= x.offset + x.ncodeunits && stop > x.offset
+                    rstart = s.io.size + max(0, start - x.offset) + 1
+                    rstop = s.io.size + min(stop, x.offset + x.ncodeunits) - x.offset
+                    push!(annotations, (rstart:rstop, annot))
+                end
+            end
+            print(s, SubString(x.string.string, x.offset, x.ncodeunits, Val(:noshift)))
+        elseif x isa AnnotatedChar
+            for annot in x.annotations
+                push!(annotations, (1+s.io.size:1+s.io.size, annot))
+            end
+            print(s, x.char)
+        else
+            print(s, x)
+        end
+    end
+    str = String(resize!(s.io.data, s.io.size))
+    AnnotatedString(str, annotations)
+end
+
+annotatedstring(s::AnnotatedString) = s
+annotatedstring(c::AnnotatedChar) =
+    AnnotatedString(string(c.char), [(1:ncodeunits(c), annot) for annot in c.annotations])
+
+AnnotatedString(s::SubString{<:AnnotatedString}) = annotatedstring(s)
+
+"""
+    annotatedstring_optimize!(str::AnnotatedString)
+
+Merge contiguous identical annotations in `str`.
+"""
+function annotatedstring_optimize!(s::AnnotatedString)
+    last_seen = Dict{Pair{Symbol, Any}, Int}()
+    i = 1
+    while i <= length(s.annotations)
+        region, keyval = s.annotations[i]
+        prev = get(last_seen, keyval, 0)
+        if prev > 0
+            lregion, _ = s.annotations[prev]
+            if last(lregion) + 1 == first(region)
+                s.annotations[prev] =
+                    setindex(s.annotations[prev],
+                             first(lregion):last(region),
+                             1)
+                deleteat!(s.annotations, i)
+            else
+                delete!(last_seen, keyval)
+            end
+        else
+            last_seen[keyval] = i
+            i += 1
+        end
+    end
+    s
+end
+
+function repeat(str::AnnotatedString, r::Integer)
+    r == 0 && return one(AnnotatedString)
+    r == 1 && return str
+    unannot = repeat(str.string, r)
+    annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
+    len = ncodeunits(str)
+    fullregion = firstindex(str):lastindex(str)
+    for (region, annot) in str.annotations
+        if region == fullregion
+            push!(annotations, (firstindex(unannot):lastindex(unannot), annot))
+        end
+    end
+    for offset in 0:len:(r-1)*len
+        for (region, annot) in str.annotations
+            if region != fullregion
+                push!(annotations, (region .+ offset, annot))
+            end
+        end
+    end
+    AnnotatedString(unannot, annotations) |> annotatedstring_optimize!
+end
+
+repeat(str::SubString{<:AnnotatedString}, r::Integer) =
+    repeat(AnnotatedString(str), r)
+
+function repeat(c::AnnotatedChar, r::Integer)
+    str = repeat(c.char, r)
+    fullregion = firstindex(str):lastindex(str)
+    AnnotatedString(str, [(fullregion, annot) for annot in c.annotations])
+end
+
+function reverse(s::AnnotatedString)
+    lastind = lastindex(s)
+    AnnotatedString(reverse(s.string),
+                 [(UnitRange(1 + lastind - last(region),
+                             1 + lastind - first(region)),
+                   annot)
+                  for (region, annot) in s.annotations])
+end
+
+# TODO optimise?
+reverse(s::SubString{<:AnnotatedString}) = reverse(AnnotatedString(s))
+
+# TODO implement `replace(::AnnotatedString, ...)`
+
+## End AbstractString interface ##
+
+"""
+    annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol => value)
+    annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol => value)
+
+Annotate a `range` of `str` (or the entire string) with a labeled value (`label` => `value`).
+To remove existing `label` annotations, use a value of `nothing`.
+"""
+function annotate!(s::AnnotatedString, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any}))
+    label, val = labelval
+    indices = searchsorted(s.annotations, (range,), by=first)
+    if val === nothing
+        labelindex = filter(i -> first(s.annotations[i][2]) === label, indices)
+        for index in Iterators.reverse(labelindex)
+            deleteat!(s.annotations, index)
+        end
+    else
+        splice!(s.annotations, indices, [(range, Pair{Symbol, Any}(label, val))])
+    end
+    s
+end
+
+annotate!(ss::AnnotatedString, @nospecialize(labelval::Pair{Symbol, <:Any})) =
+    annotate!(ss, firstindex(ss):lastindex(ss), labelval)
+
+annotate!(s::SubString{<:AnnotatedString}, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any})) =
+    (annotate!(s.string, s.offset .+ (range), labelval); s)
+
+annotate!(s::SubString{<:AnnotatedString}, @nospecialize(labelval::Pair{Symbol, <:Any})) =
+    (annotate!(s.string, s.offset .+ (1:s.ncodeunits), labelval); s)
+
+"""
+    annotate!(char::AnnotatedChar, label::Symbol => value)
+
+Annotate `char` with the pair `label => value`.
+"""
+annotate!(c::AnnotatedChar, @nospecialize(labelval::Pair{Symbol, <:Any})) =
+    (push!(c.annotations, labelval); c)
+
+"""
+    annotations(str::AnnotatedString, [position::Union{Integer, UnitRange}])
+    annotations(str::SubString{AnnotatedString}, [position::Union{Integer, UnitRange}])
+
+Get all annotations that apply to `str`. Should `position` be provided, only
+annotations that overlap with `position` will be returned.
+
+See also: `annotate!`.
+"""
+annotations(s::AnnotatedString) = s.annotations
+
+annotations(s::SubString{<:AnnotatedString}) =
+    annotations(s, s.offset+1:s.offset+s.ncodeunits)
+
+function annotations(s::AnnotatedString, pos::UnitRange{<:Integer})
+    # TODO optimise
+    annots = filter(label -> !isempty(intersect(pos, first(label))),
+                    s.annotations)
+    last.(annots)
+end
+
+annotations(s::AnnotatedString, pos::Integer) = annotations(s, pos:pos)
+
+annotations(s::SubString{<:AnnotatedString}, pos::Integer) =
+    annotations(s.string, s.offset + pos)
+annotations(s::SubString{<:AnnotatedString}, pos::UnitRange{<:Integer}) =
+    annotations(s.string, first(pos)+s.offset:last(pos)+s.offset)
+
+"""
+    annotations(chr::AnnotatedChar)
+
+Get all annotations of `chr`.
+"""
+annotations(c::AnnotatedChar) = c.annotations
diff --git a/base/strings/basic.jl b/base/strings/basic.jl
index 640e715bee3fc..330cff1cf8f00 100644
--- a/base/strings/basic.jl
+++ b/base/strings/basic.jl
@@ -242,8 +242,8 @@ end
     *(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString
 
 Concatenate strings and/or characters, producing a [`String`](@ref) or
-[`TaggedString`](@ref) (as appropriate). This is equivalent to calling the
-[`string`](@ref) or [`taggedstring`](@ref) function on the arguments. Concatenation of built-in string
+[`AnnotatedString`](@ref) (as appropriate). This is equivalent to calling the
+[`string`](@ref) or [`annotatedstring`](@ref) function on the arguments. Concatenation of built-in string
 types always produces a value of type `String` but other string types may choose
 to return a string of a different type as appropriate.
 
@@ -257,10 +257,10 @@ julia> 'j' * "ulia"
 ```
 """
 function (*)(s1::Union{AbstractChar, AbstractString}, ss::Union{AbstractChar, AbstractString}...)
-    istagged = s1 isa TaggedString || s1 isa TaggedChar ||
-        any(s -> s isa TaggedString || s isa TaggedChar, ss)
-    if istagged
-        taggedstring(s1, ss...)
+    isannotated = s1 isa AnnotatedString || s1 isa AnnotatedChar ||
+        any(s -> s isa AnnotatedString || s isa AnnotatedChar, ss)
+    if isannotated
+        annotatedstring(s1, ss...)
     else
         string(s1, ss...)
     end
@@ -318,7 +318,7 @@ end
     ==(a::AbstractString, b::AbstractString) -> Bool
 
 Test whether two strings are equal character by character (technically, Unicode
-code point by code point). Should either string be a [`TaggedString`](@ref) the
+code point by code point). Should either string be a [`AnnotatedString`](@ref) the
 string properties must match too.
 
 # Examples
diff --git a/base/strings/io.jl b/base/strings/io.jl
index 7f762b75473ff..c45d0ac84640e 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -353,31 +353,31 @@ function join(io::IO, iterator, delim="")
     end
 end
 
-# TODO: If/when we have `TaggedIO`, we can revisit this and
+# TODO: If/when we have `AnnotatedIO`, we can revisit this and
 # implement it more nicely.
-function join_tagged(iterator, delim="", last=delim)
+function join_annotated(iterator, delim="", last=delim)
     xs = zip(iterator, Iterators.repeated(delim)) |> Iterators.flatten |> collect
     xs = xs[1:end-1]
     if length(xs) > 1
         xs[end-1] = last
     end
-    taggedstring(xs...)::TaggedString{String}
+    annotatedstring(xs...)::AnnotatedString{String}
 end
 
-function _join_maybe_tagged(args...)
+function _join_maybe_annotated(args...)
     if any(function (arg)
                t = eltype(arg)
-               !(t == Union{}) && (t <: TaggedString || t <: TaggedChar)
+               !(t == Union{}) && (t <: AnnotatedString || t <: AnnotatedChar)
            end, args)
-        join_tagged(args...)
+        join_annotated(args...)
     else
         sprint(join, args...)
     end
 end
 
-join(iterator) = _join_maybe_tagged(iterator)
-join(iterator, delim) = _join_maybe_tagged(iterator, delim)
-join(iterator, delim, last) = _join_maybe_tagged(iterator, delim, last)
+join(iterator) = _join_maybe_annotated(iterator)
+join(iterator, delim) = _join_maybe_annotated(iterator, delim)
+join(iterator, delim, last) = _join_maybe_annotated(iterator, delim, last)
 
 ## string escaping & unescaping ##
 
@@ -787,8 +787,8 @@ function String(chars::AbstractVector{<:AbstractChar})
     end
 end
 
-function TaggedString(chars::AbstractVector{C}) where {C<:AbstractChar}
-    str = if C <: TaggedChar
+function AnnotatedString(chars::AbstractVector{C}) where {C<:AbstractChar}
+    str = if C <: AnnotatedChar
         String(getfield.(chars, :char))
     else
         sprint(sizehint=length(chars)) do io
@@ -800,12 +800,12 @@ function TaggedString(chars::AbstractVector{C}) where {C<:AbstractChar}
     props = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
     point = 1
     for c in chars
-        if c isa TaggedChar
+        if c isa AnnotatedChar
             for prop in c.properties
                 push!(props, (point:point, prop))
             end
         end
         point += ncodeunits(c)
     end
-    TaggedString(str, props)
+    AnnotatedString(str, props)
 end
diff --git a/base/strings/strings.jl b/base/strings/strings.jl
index 4d14cfbcf9891..8dae311f475b4 100644
--- a/base/strings/strings.jl
+++ b/base/strings/strings.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-include("strings/tagged.jl")
+include("strings/annotated.jl")
 include("strings/search.jl")
 include("strings/unicode.jl")
 
diff --git a/base/strings/tagged.jl b/base/strings/tagged.jl
deleted file mode 100644
index 8435361a81450..0000000000000
--- a/base/strings/tagged.jl
+++ /dev/null
@@ -1,388 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-"""
-    TaggedString{S <: AbstractString} <: AbstractString
-
-A string with metadata, in the form of annotated regions.
-
-More specifically, this is a simple wrapper around any other
-[`AbstractString`](@ref) that allows for regions of the wrapped string to be
-annotated with tagged values.
-
-```text
-                        C
-                    ┌───┸─────────┐
-  "this is an example tagged string"
-  └──┰────────┼─────┘      │
-     A        └───┰────────┘
-                  B
-```
-
-The above diagram represents a `TaggedString` where three ranges have been
-annotated (labeled `A`, `B`, and `C`). Each annotation must take the form of a
-`Pair{Symbol, <:Any}`, where a `Symbol` "tag" is used to label `Any` "value".
-
-Tags do not need to be unique, the same region can be annotated with the same
-tag multiple times.
-
-See also [`TaggedChar`](@ref), [`taggedstring`](@ref), [`annotations`](@ref), and
-[`annotate!`](@ref).
-
-!!! warning
-    While the constructors are part of the Base public API, the fields
-    of `TaggedString` are not. This is to allow for potential future
-    changes in the implementation of this type. Instead use the
-    [`annotations`](@ref), and [`annotate!`](@ref) getter/setter
-    functions.
-
-# Constructors
-
-```julia
-TaggedString(s::S<:AbstractString) -> TaggedString{S}
-TaggedString(s::S<:AbstractString, annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, <:Any}}})
-```
-
-A TaggedString can also be created with [`taggedstring`](@ref), which acts much
-like [`string`](@ref) but preserves any tags present in the arguments.
-
-# Example
-
-```julia-repl
-julia> TaggedString("this is an example tagged string",
-                    [(1:18, :A => 1), (12:25, :B => 2), (18:32, :C => 3)])
-"this is an example tagged string"
-```
-"""
-struct TaggedString{S <: AbstractString} <: AbstractString
-    string::S
-    annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
-end
-
-"""
-    TaggedChar{S <: AbstractChar} <: AbstractChar
-
-A Char annotated with tagged values.
-
-More specifically, this is a simple wrapper around any other
-[`AbstractChar`](@ref), which holds a list of arbitrary tagged values
-(`Pair{Symbol, <:Any}`) with the wrapped character.
-
-See also: [`TaggedString`](@ref), [`taggedstring`](@ref), `annotations`,
-and `annotate!`.
-
-!!! warning
-    While the constructors are part of the Base public API, the fields
-    of `TaggedChar` are not. This it to allow for potential future
-    changes in the implementation of this type. Instead use the
-    [`annotations`](@ref), and [`annotate!`](@ref) getter/setter
-    functions.
-
-# Constructors
-
-```julia
-TaggedChar(s::S) -> TaggedChar{S}
-TaggedChar(s::S, annotations::Vector{Pair{Symbol, <:Any}})
-```
-
-# Examples
-
-```julia-repl
-julia> TaggedChar('j', :tag => 1)
-'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)
-```
-"""
-struct TaggedChar{C <: AbstractChar} <: AbstractChar
-    char::C
-    annotations::Vector{Pair{Symbol, Any}}
-end
-
-## Constructors ##
-
-# When called with overly-specialised arguments
-
-TaggedString(s::AbstractString, annots::Vector{<:Tuple{UnitRange{Int}, <:Pair{Symbol, <:Any}}}) =
-    TaggedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}(annots))
-
-TaggedChar(c::AbstractChar, annots::Vector{<:Pair{Symbol, <:Any}}) =
-    TaggedChar(c, Vector{Pair{Symbol, Any}}(annots))
-
-# Constructors to avoid recursive wrapping
-
-TaggedString(s::TaggedString, annots::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}) =
-    TaggedString(s.string, vcat(s.annotations, annots))
-
-TaggedChar(c::TaggedChar, annots::Vector{Pair{Symbol, Any}}) =
-    TaggedChar(c.char, vcat(s.annotations, annots))
-
-String(s::TaggedString{String}) = s.string # To avoid pointless overhead
-
-## Conversion/promotion ##
-
-convert(::Type{TaggedString}, s::TaggedString) = s
-convert(::Type{TaggedString{S}}, s::S) where {S <: AbstractString} =
-    TaggedString(s, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
-convert(::Type{TaggedString}, s::S) where {S <: AbstractString} =
-    convert(TaggedString{S}, s)
-TaggedString(s::S) where {S <: AbstractString} = convert(TaggedString{S}, s)
-
-convert(::Type{TaggedChar}, c::TaggedChar) = c
-convert(::Type{TaggedChar{C}}, c::C) where { C <: AbstractChar } =
-    TaggedChar{C}(c, Vector{Pair{Symbol, Any}}())
-convert(::Type{TaggedChar}, c::C) where { C <: AbstractChar } =
-    convert(TaggedChar{C}, c)
-
-TaggedChar(c::AbstractChar) = convert(TaggedChar, c)
-TaggedChar(c::UInt32) = convert(TaggedChar, Char(c))
-TaggedChar{C}(c::UInt32) where {C <: AbstractChar} = convert(TaggedChar, C(c))
-
-promote_rule(::Type{<:TaggedString}, ::Type{<:AbstractString}) = TaggedString
-
-## AbstractString interface ##
-
-ncodeunits(s::TaggedString) = ncodeunits(s.string)
-codeunits(s::TaggedString) = codeunits(s.string)
-codeunit(s::TaggedString) = codeunit(s.string)
-codeunit(s::TaggedString, i::Integer) = codeunit(s.string, i)
-isvalid(s::TaggedString, i::Integer) = isvalid(s.string, i)
-@propagate_inbounds iterate(s::TaggedString, i::Integer=firstindex(s)) =
-    if i <= lastindex(s.string); (s[i], nextind(s, i)) end
-eltype(::Type{<:TaggedString{S}}) where {S} = TaggedChar{eltype(S)}
-firstindex(s::TaggedString) = firstindex(s.string)
-lastindex(s::TaggedString) = lastindex(s.string)
-
-function getindex(s::TaggedString, i::Integer)
-    @boundscheck checkbounds(s, i)
-    @inbounds if isvalid(s, i)
-        TaggedChar(s.string[i], annotations(s, i))
-    else
-        string_index_err(s, i)
-    end
-end
-
-## AbstractChar interface ##
-
-ncodeunits(c::TaggedChar) = ncodeunits(c.char)
-codepoint(c::TaggedChar) = codepoint(c.char)
-
-# Avoid the iteration fallback with comparison
-cmp(a::TaggedString, b::AbstractString) = cmp(a.string, b)
-cmp(a::AbstractString, b::TaggedString) = cmp(a, b.string)
-# To avoid method ambiguity
-cmp(a::TaggedString, b::TaggedString) = cmp(a.string, b.string)
-
-==(a::TaggedString, b::TaggedString) =
-    a.string == b.string && a.annotations == b.annotations
-
-==(a::TaggedString, b::AbstractString) = isempty(a.annotations) && a.string == b
-==(a::AbstractString, b::TaggedString) = isempty(b.annotations) && a == b.string
-
-"""
-    taggedstring(values...)
-
-Create a `TaggedString` from any number of `values` using their
-[`print`](@ref)ed representation.
-
-This acts like [`string`](@ref), but takes care to preserve any annotations
-present (in the form of [`TaggedString`](@ref) or [`TaggedChar`](@ref) values).
-
-See also [`TaggedString`](@ref) and [`TaggedChar`](@ref).
-
-## Examples
-
-```
-julia> taggedstring("now a TaggedString")
-"now a TaggedString"
-
-julia> taggedstring(TaggedString("tagged", [(1:6, :tag => 1)]), ", and untagged")
-"tagged, and untagged"
-```
-"""
-function taggedstring(xs...)
-    isempty(xs) && return TaggedString("")
-    size = mapreduce(_str_sizehint, +, xs)
-    s = IOContext(IOBuffer(sizehint=size), :color => true)
-    annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
-    for x in xs
-        if x isa TaggedString
-            for (region, annot) in x.annotations
-                push!(annotations, (s.io.size .+ (region), annot))
-            end
-            print(s, x.string)
-        elseif x isa SubString{<:TaggedString}
-            for (region, annot) in x.string.annotations
-                start, stop = first(region), last(region)
-                if start <= x.offset + x.ncodeunits && stop > x.offset
-                    rstart = s.io.size + max(0, start - x.offset) + 1
-                    rstop = s.io.size + min(stop, x.offset + x.ncodeunits) - x.offset
-                    push!(annotations, (rstart:rstop, annot))
-                end
-            end
-            print(s, SubString(x.string.string, x.offset, x.ncodeunits, Val(:noshift)))
-        elseif x isa TaggedChar
-            for annot in x.annotations
-                push!(annotations, (1+s.io.size:1+s.io.size, annot))
-            end
-            print(s, x.char)
-        else
-            print(s, x)
-        end
-    end
-    str = String(resize!(s.io.data, s.io.size))
-    TaggedString(str, annotations)
-end
-
-taggedstring(s::TaggedString) = s
-taggedstring(c::TaggedChar) =
-    TaggedString(string(c.char), [(1:ncodeunits(c), annot) for annot in c.annotations])
-
-TaggedString(s::SubString{<:TaggedString}) = taggedstring(s)
-
-"""
-    taggedstring_optimize!(str::TaggedString)
-
-Merge contiguous identical tags in `str`.
-"""
-function taggedstring_optimize!(s::TaggedString)
-    last_seen = Dict{Pair{Symbol, Any}, Int}()
-    i = 1
-    while i <= length(s.annotations)
-        region, keyval = s.annotations[i]
-        prev = get(last_seen, keyval, 0)
-        if prev > 0
-            lregion, _ = s.annotations[prev]
-            if last(lregion) + 1 == first(region)
-                s.annotations[prev] =
-                    setindex(s.annotations[prev],
-                             first(lregion):last(region),
-                             1)
-                deleteat!(s.annotations, i)
-            else
-                delete!(last_seen, keyval)
-            end
-        else
-            last_seen[keyval] = i
-            i += 1
-        end
-    end
-    s
-end
-
-function repeat(str::TaggedString, r::Integer)
-    r == 0 && return one(TaggedString)
-    r == 1 && return str
-    untagged = repeat(str.string, r)
-    annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
-    len = ncodeunits(str)
-    fullregion = firstindex(str):lastindex(str)
-    for (region, annot) in str.annotations
-        if region == fullregion
-            push!(annotations, (firstindex(untagged):lastindex(untagged), annot))
-        end
-    end
-    for offset in 0:len:(r-1)*len
-        for (region, annot) in str.annotations
-            if region != fullregion
-                push!(annotations, (region .+ offset, annot))
-            end
-        end
-    end
-    TaggedString(untagged, annotations) |> taggedstring_optimize!
-end
-
-repeat(str::SubString{<:TaggedString}, r::Integer) =
-    repeat(TaggedString(str), r)
-
-function repeat(c::TaggedChar, r::Integer)
-    str = repeat(c.char, r)
-    fullregion = firstindex(str):lastindex(str)
-    TaggedString(str, [(fullregion, annot) for annot in c.annotations])
-end
-
-function reverse(s::TaggedString)
-    lastind = lastindex(s)
-    TaggedString(reverse(s.string),
-                 [(UnitRange(1 + lastind - last(region),
-                             1 + lastind - first(region)),
-                   annot)
-                  for (region, annot) in s.annotations])
-end
-
-# TODO optimise?
-reverse(s::SubString{<:TaggedString}) = reverse(TaggedString(s))
-
-# TODO implement `replace(::TaggedString, ...)`
-
-## End AbstractString interface ##
-
-"""
-    annotate!(str::TaggedString, [range::UnitRange{Int}], tag::Symbol => value)
-    annotate!(str::SubString{TaggedString}, [range::UnitRange{Int}], tag::Symbol => value)
-
-Annotate a `range` of `str` (or the entire string) with a tagged value (`tag` =>
-`value`). To remove existing `tag` annotations, use a value of `nothing`.
-"""
-function annotate!(s::TaggedString, range::UnitRange{Int}, @nospecialize(tagval::Pair{Symbol, <:Any}))
-    tag, val = tagval
-    indices = searchsorted(s.annotations, (range,), by=first)
-    if val === nothing
-        tagindex = filter(i -> first(s.annotations[i][2]) === tag, indices)
-        for index in Iterators.reverse(tagindex)
-            deleteat!(s.annotations, index)
-        end
-    else
-        splice!(s.annotations, indices, [(range, Pair{Symbol, Any}(tag, val))])
-    end
-    s
-end
-
-annotate!(ss::TaggedString, @nospecialize(tagval::Pair{Symbol, <:Any})) =
-    annotate!(ss, firstindex(ss):lastindex(ss), tagval)
-
-annotate!(s::SubString{<:TaggedString}, range::UnitRange{Int}, @nospecialize(tagval::Pair{Symbol, <:Any})) =
-    (annotate!(s.string, s.offset .+ (range), tagval); s)
-
-annotate!(s::SubString{<:TaggedString}, @nospecialize(tagval::Pair{Symbol, <:Any})) =
-    (annotate!(s.string, s.offset .+ (1:s.ncodeunits), tagval); s)
-
-"""
-    annotate!(char::TaggedChar, tag::Symbol => value)
-
-Annotate `char` with the pair `tag => value`.
-"""
-annotate!(c::TaggedChar, @nospecialize(tagval::Pair{Symbol, <:Any})) =
-    (push!(c.annotations, tagval); c)
-
-"""
-    annotations(str::TaggedString, [position::Union{Integer, UnitRange}])
-    annotations(str::SubString{TaggedString}, [position::Union{Integer, UnitRange}])
-
-Get all annotations that apply to `str`. Should `position` be provided, only
-annotations that overlap with `position` will be returned.
-
-See also: `annotate!`.
-"""
-annotations(s::TaggedString) = s.annotations
-
-annotations(s::SubString{<:TaggedString}) =
-    annotations(s, s.offset+1:s.offset+s.ncodeunits)
-
-function annotations(s::TaggedString, pos::UnitRange{<:Integer})
-    # TODO optimise
-    annots = filter(tag -> !isempty(intersect(pos, first(tag))),
-                    s.annotations)
-    last.(annots)
-end
-
-annotations(s::TaggedString, pos::Integer) = annotations(s, pos:pos)
-
-annotations(s::SubString{<:TaggedString}, pos::Integer) =
-    annotations(s.string, s.offset + pos)
-annotations(s::SubString{<:TaggedString}, pos::UnitRange{<:Integer}) =
-    annotations(s.string, first(pos)+s.offset:last(pos)+s.offset)
-
-"""
-    annotations(chr::TaggedChar)
-
-Get all annotations of `chr`.
-"""
-annotations(c::TaggedChar) = c.annotations
diff --git a/base/strings/util.jl b/base/strings/util.jl
index 226c0e3e3cc8e..fae40cb568842 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -459,8 +459,8 @@ function lpad(
     n::Integer,
     p::Union{AbstractChar,AbstractString}=' ',
 )
-    stringfn = if any(isa.((s, p), Union{TaggedString, TaggedChar, SubString{<:TaggedString}}))
-        taggedstring else string end
+    stringfn = if any(isa.((s, p), Union{AnnotatedString, AnnotatedChar, SubString{<:AnnotatedString}}))
+        annotatedstring else string end
     n = Int(n)::Int
     m = signed(n) - Int(textwidth(s))::Int
     m ≤ 0 && return stringfn(s)
@@ -491,8 +491,8 @@ function rpad(
     n::Integer,
     p::Union{AbstractChar,AbstractString}=' ',
 )
-    stringfn = if any(isa.((s, p), Union{TaggedString, TaggedChar, SubString{<:TaggedString}}))
-        taggedstring else string end
+    stringfn = if any(isa.((s, p), Union{AnnotatedString, AnnotatedChar, SubString{<:AnnotatedString}}))
+        annotatedstring else string end
     n = Int(n)::Int
     m = signed(n) - Int(textwidth(s))::Int
     m ≤ 0 && return stringfn(s)
diff --git a/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/md5 b/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/md5
deleted file mode 100644
index 8a7dc7653ee71..0000000000000
--- a/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-30489ddcd3e8e407e9d4bca38c1a1124
diff --git a/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/sha512 b/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/sha512
deleted file mode 100644
index 9e5d031bf612e..0000000000000
--- a/deps/checksums/StyledStrings-0540bdfe126aff87fcfe27f5509a76ccbf582182.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-f4b786436786ce76dc86f5838233030678587e31320bdb5e642c7ee11b15bcbfb6a8fd82481975403a86dce8073d2560484f794cedc2a3aa63477567beeedb1a
diff --git a/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/md5 b/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/md5
new file mode 100644
index 0000000000000..5d9fdfb8ebd7e
--- /dev/null
+++ b/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/md5
@@ -0,0 +1 @@
+311f5b6b7e109fea852303ec09324b00
diff --git a/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/sha512 b/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/sha512
new file mode 100644
index 0000000000000..8a3c1c9238514
--- /dev/null
+++ b/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/sha512
@@ -0,0 +1 @@
+fbf4b2fdde4fd2c2bb321b915d9833ea34952aec1bf9fdcf51e229e6bae5fc0fbfd30db31e410c634955144c6a4295289a313185621e2c5f16b06f22a049739f
diff --git a/doc/src/base/strings.md b/doc/src/base/strings.md
index 44ec0fe275b97..2504f3dbd583a 100644
--- a/doc/src/base/strings.md
+++ b/doc/src/base/strings.md
@@ -17,9 +17,9 @@ Core.String(::AbstractString)
 Base.SubString
 Base.LazyString
 Base.@lazy_str
-Base.TaggedString
-Base.TaggedChar
-Base.taggedstring
+Base.AnnotatedString
+Base.AnnotatedChar
+Base.annotatedstring
 Base.annotations
 Base.annotate!
 Base.transcode
diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md
index d29358d2a56ff..ec146125024b8 100644
--- a/doc/src/manual/strings.md
+++ b/doc/src/manual/strings.md
@@ -1205,28 +1205,28 @@ However, the next backslash character escapes the backslash that follows it, and
 last backslash escapes a quote, since these backslashes appear before a quote.
 
 
-## [Tagged Strings](@id man-tagged-strings)
+## [Annotated Strings](@id man-annotated-strings)
 
 It is sometimes useful to be able to hold metadata relating to regions of a
-string. A [`TaggedString`](@ref Base.TaggedString) wraps another string and
-allows for regions of it to be annotated with tagged values (`:tag => value`).
+string. A [`AnnotatedString`](@ref Base.AnnotatedString) wraps another string and
+allows for regions of it to be annotated with labelled values (`:label => value`).
 All generic string operations are applied to the underlying string. However,
 when possible, styling information is preserved. This means you can manipulate a
-[`TaggedString`](@ref Base.TaggedString) —taking substrings, padding them,
+[`AnnotatedString`](@ref Base.AnnotatedString) —taking substrings, padding them,
 concatenating them with other strings— and the metadata annotations will "come
 along for the ride".
 
 This string type is fundamental to the [StyledStrings stdlib](@ref
-stdlib-styledstrings), which uses `:face`-tagged annotations to hold styling
+stdlib-styledstrings), which uses `:face`-labelled annotations to hold styling
 information.
 
-When concatenating a [`TaggedString`](@ref Base.TaggedString), take care to use
-[`taggedstring`](@ref Base.taggedstring) instead of [`string`](@ref) if you want
-to keep the tagged string annotations.
+When concatenating a [`AnnotatedString`](@ref Base.AnnotatedString), take care to use
+[`annotatedstring`](@ref Base.annotatedstring) instead of [`string`](@ref) if you want
+to keep the string annotations.
 
 ```jldoctest
-julia> str = Base.TaggedString("hello there",
-               [(1:5, :word => :greeting), (7:11, :tag => 1)])
+julia> str = Base.AnnotatedString("hello there",
+               [(1:5, :word => :greeting), (7:11, :label => 1)])
 "hello there"
 
 julia> length(str)
@@ -1236,18 +1236,18 @@ julia> lpad(str, 14)
 "   hello there"
 
 julia> typeof(lpad(str, 7))
-Base.TaggedString{String}
+Base.AnnotatedString{String}
 
-julia> str2 = Base.TaggedString(" julia", [(2:6, :face => :magenta)])
+julia> str2 = Base.AnnotatedString(" julia", [(2:6, :face => :magenta)])
 " julia"
 
-julia> Base.taggedstring(str, str2)
+julia> Base.annotatedstring(str, str2)
 "hello there julia"
 
-julia> str * str2 == Base.taggedstring(str, str2) # *-concatination still works
+julia> str * str2 == Base.annotatedstring(str, str2) # *-concatenation still works
 true
 ```
 
-The annotations of a [`TaggedString`](@ref Base.TaggedString) can be accessed
+The annotations of a [`AnnotatedString`](@ref Base.AnnotatedString) can be accessed
 and modified via the [`annotations`](@ref Base.annotations) and
 [`annotate!`](@ref Base.annotate!) functions.
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index 3baf10de2f453..bca2e9dca3e67 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = 0540bdfe126aff87fcfe27f5509a76ccbf582182
+STYLEDSTRINGS_SHA1 = 61e7b105b157b40807ed0b4840166a25b0948549
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1
diff --git a/test/choosetests.jl b/test/choosetests.jl
index 75cdd2fe5bc95..beed4e15a58df 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -151,7 +151,7 @@ function choosetests(choices = [])
 
     filtertests!(tests, "unicode", ["unicode/utf8"])
     filtertests!(tests, "strings", ["strings/basic", "strings/search", "strings/util",
-                   "strings/io", "strings/types", "strings/tagged"])
+                   "strings/io", "strings/types", "strings/annotated"])
     # do subarray before sparse but after linalg
     filtertests!(tests, "subarray")
     filtertests!(tests, "compiler", [
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
new file mode 100644
index 0000000000000..324c1ccb495f6
--- /dev/null
+++ b/test/strings/annotated.jl
@@ -0,0 +1,99 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+@testset "AnnotatedString" begin
+    str = Base.AnnotatedString("some string")
+    @test str == Base.AnnotatedString(str.string, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[])
+    @test length(str) == 11
+    @test ncodeunits(str) == 11
+    @test eltype(str) == Base.AnnotatedChar{eltype(str.string)}
+    @test first(str) == Base.AnnotatedChar(first(str.string), Pair{Symbol, Any}[])
+    @test str[1:4] isa SubString{typeof(str)}
+    @test str[1:4] == Base.AnnotatedString("some")
+    @test "a" * str == Base.AnnotatedString("asome string")
+    @test str * "a" == Base.AnnotatedString("some stringa")
+    @test str * str == Base.AnnotatedString("some stringsome string")
+    Base.annotate!(str, 1:4, :thing => 0x01)
+    Base.annotate!(str, 5:11, :other => 0x02)
+    Base.annotate!(str, 1:11, :all => 0x03)
+    @test str[3:4] == SubString(str, 3, 4)
+    @test Base.AnnotatedString(str[3:4]) ==
+        Base.AnnotatedString("me", [(1:2, :thing => 0x01), (1:2, :all => 0x03)])
+    @test str == Base.AnnotatedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    @test str != Base.AnnotatedString("some string")
+    @test str != Base.AnnotatedString("some string", [(1:1, :thing => 0x01), (5:5, :other => 0x02), (11:11, :all => 0x03)])
+    @test str != Base.AnnotatedString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (5:11, :other => 0x12)])
+    @test str != Base.AnnotatedString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    let allstrings =
+        ['a', Base.AnnotatedChar('a'), Base.AnnotatedChar('a', [:aaa => 0x04]),
+        "a string", Base.AnnotatedString("a string"),
+        Base.AnnotatedString("a string", [(1:2, :hmm => '%')])]
+        for str1 in repeat(allstrings, 2)
+            for str2 in repeat(allstrings, 2)
+                @test String(str1 * str2) ==
+                    String(string(str1, str2)) ==
+                    String(string(str1)) * String(string(str2))
+                @test Base.annotatedstring(str1 * str2) ==
+                    Base.annotatedstring(str1, str2) ==
+                    Base.annotatedstring(str1) * Base.annotatedstring(str2)
+            end
+        end
+    end
+    # @test collect(Base.eachstyle(str)) ==
+    #     [("some", [:thing => 0x01, :all => 0x03]),
+    #     (" string", [:all => 0x03, :other => 0x02])]
+    @test ==(Base.annotatedstring_optimize!(
+        Base.AnnotatedString("abc", [(1:1, :val => 1),
+                             (2:2, :val => 2),
+                             (2:2, :val => 1),
+                             (3:3, :val => 2)])),
+             Base.AnnotatedString("abc", [(1:2, :val => 1),
+                                  (2:3, :val => 2)]))
+end
+
+@testset "AnnotatedChar" begin
+    chr = Base.AnnotatedChar('c')
+    @test chr == Base.AnnotatedChar(chr.char, Pair{Symbol, Any}[])
+    str = Base.AnnotatedString("hmm", [(1:1, :attr => "h0h0"),
+                               (1:2, :attr => "h0m1"),
+                               (2:3, :attr => "m1m2")])
+    @test str[1] == Base.AnnotatedChar('h', Pair{Symbol, Any}[:attr => "h0h0"])
+    @test str[2] == Base.AnnotatedChar('m', Pair{Symbol, Any}[:attr => "h0m1", :attr => "m1m2"])
+    @test str[3] == Base.AnnotatedChar('m', Pair{Symbol, Any}[:attr => "m1m2"])
+end
+
+@testset "Styling preservation" begin
+    str = Base.AnnotatedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    @test match(r".e", str).match == str[3:4]
+    @test  match(r"(.e)", str).captures == [str[3:4]]
+    let m0 = match(r"(.)e", str)
+        m1 = first(eachmatch(r"(.)e", str))
+        for f in fieldnames(RegexMatch)
+            @test getfield(m0, f) == getfield(m1, f)
+        end
+    end
+    @test lpad(str, 12) ==
+        Base.AnnotatedString(" some string", [(2:5, :thing => 0x01),
+                                      (2:12, :all => 0x03),
+                                      (6:12, :other => 0x02)])
+    @test rpad(str, 12) ==
+        Base.AnnotatedString("some string ", [(1:4, :thing => 0x01),
+                                      (1:11, :all => 0x03),
+                                      (5:11, :other => 0x02)])
+    str1 = Base.AnnotatedString("test", [(1:4, :label => 5)])
+    str2 = Base.AnnotatedString("case", [(2:3, :label => "oomph")])
+    @test join([str1, str1], Base.AnnotatedString(" ")) ==
+        Base.AnnotatedString("test test",
+                     [(1:4, :label => 5),
+                      (6:9, :label => 5)])
+    @test join([str1, str1], Base.AnnotatedString(" ", [(1:1, :label => 2)])) ==
+        Base.AnnotatedString("test test",
+                     [(1:4, :label => 5),
+                      (5:5, :label => 2),
+                      (6:9, :label => 5)])
+    @test repeat(str1, 2) == Base.AnnotatedString("testtest", [(1:8, :label => 5)])
+    @test repeat(str2, 2) == Base.AnnotatedString("casecase", [(2:3, :label => "oomph"),
+                                                       (6:7, :label => "oomph")])
+    @test repeat(str1[1], 3) == Base.AnnotatedString("ttt", [(1:3, :label => 5)])
+    @test reverse(str1) == Base.AnnotatedString("tset", [(1:4, :label => 5)])
+    @test reverse(str2) == Base.AnnotatedString("esac", [(2:3, :label => "oomph")])
+end
diff --git a/test/strings/tagged.jl b/test/strings/tagged.jl
deleted file mode 100644
index 229fc53ef9e77..0000000000000
--- a/test/strings/tagged.jl
+++ /dev/null
@@ -1,99 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-@testset "TaggedString" begin
-    str = Base.TaggedString("some string")
-    @test str == Base.TaggedString(str.string, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[])
-    @test length(str) == 11
-    @test ncodeunits(str) == 11
-    @test eltype(str) == Base.TaggedChar{eltype(str.string)}
-    @test first(str) == Base.TaggedChar(first(str.string), Pair{Symbol, Any}[])
-    @test str[1:4] isa SubString{typeof(str)}
-    @test str[1:4] == Base.TaggedString("some")
-    @test "a" * str == Base.TaggedString("asome string")
-    @test str * "a" == Base.TaggedString("some stringa")
-    @test str * str == Base.TaggedString("some stringsome string")
-    Base.annotate!(str, 1:4, :thing => 0x01)
-    Base.annotate!(str, 5:11, :other => 0x02)
-    Base.annotate!(str, 1:11, :all => 0x03)
-    @test str[3:4] == SubString(str, 3, 4)
-    @test Base.TaggedString(str[3:4]) ==
-        Base.TaggedString("me", [(1:2, :thing => 0x01), (1:2, :all => 0x03)])
-    @test str == Base.TaggedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
-    @test str != Base.TaggedString("some string")
-    @test str != Base.TaggedString("some string", [(1:1, :thing => 0x01), (5:5, :other => 0x02), (11:11, :all => 0x03)])
-    @test str != Base.TaggedString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (5:11, :other => 0x12)])
-    @test str != Base.TaggedString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
-    let allstrings =
-        ['a', Base.TaggedChar('a'), Base.TaggedChar('a', [:aaa => 0x04]),
-        "a string", Base.TaggedString("a string"),
-        Base.TaggedString("a string", [(1:2, :hmm => '%')])]
-        for str1 in repeat(allstrings, 2)
-            for str2 in repeat(allstrings, 2)
-                @test String(str1 * str2) ==
-                    String(string(str1, str2)) ==
-                    String(string(str1)) * String(string(str2))
-                @test Base.taggedstring(str1 * str2) ==
-                    Base.taggedstring(str1, str2) ==
-                    Base.taggedstring(str1) * Base.taggedstring(str2)
-            end
-        end
-    end
-    # @test collect(Base.eachstyle(str)) ==
-    #     [("some", [:thing => 0x01, :all => 0x03]),
-    #     (" string", [:all => 0x03, :other => 0x02])]
-    @test ==(Base.taggedstring_optimize!(
-        Base.TaggedString("abc", [(1:1, :val => 1),
-                             (2:2, :val => 2),
-                             (2:2, :val => 1),
-                             (3:3, :val => 2)])),
-             Base.TaggedString("abc", [(1:2, :val => 1),
-                                  (2:3, :val => 2)]))
-end
-
-@testset "TaggedChar" begin
-    chr = Base.TaggedChar('c')
-    @test chr == Base.TaggedChar(chr.char, Pair{Symbol, Any}[])
-    str = Base.TaggedString("hmm", [(1:1, :attr => "h0h0"),
-                               (1:2, :attr => "h0m1"),
-                               (2:3, :attr => "m1m2")])
-    @test str[1] == Base.TaggedChar('h', Pair{Symbol, Any}[:attr => "h0h0"])
-    @test str[2] == Base.TaggedChar('m', Pair{Symbol, Any}[:attr => "h0m1", :attr => "m1m2"])
-    @test str[3] == Base.TaggedChar('m', Pair{Symbol, Any}[:attr => "m1m2"])
-end
-
-@testset "Styling preservation" begin
-    str = Base.TaggedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
-    @test match(r".e", str).match == str[3:4]
-    @test  match(r"(.e)", str).captures == [str[3:4]]
-    let m0 = match(r"(.)e", str)
-        m1 = first(eachmatch(r"(.)e", str))
-        for f in fieldnames(RegexMatch)
-            @test getfield(m0, f) == getfield(m1, f)
-        end
-    end
-    @test lpad(str, 12) ==
-        Base.TaggedString(" some string", [(2:5, :thing => 0x01),
-                                      (2:12, :all => 0x03),
-                                      (6:12, :other => 0x02)])
-    @test rpad(str, 12) ==
-        Base.TaggedString("some string ", [(1:4, :thing => 0x01),
-                                      (1:11, :all => 0x03),
-                                      (5:11, :other => 0x02)])
-    str1 = Base.TaggedString("test", [(1:4, :tag => 5)])
-    str2 = Base.TaggedString("case", [(2:3, :tag => "oomph")])
-    @test join([str1, str1], Base.TaggedString(" ")) ==
-        Base.TaggedString("test test",
-                     [(1:4, :tag => 5),
-                      (6:9, :tag => 5)])
-    @test join([str1, str1], Base.TaggedString(" ", [(1:1, :tag => 2)])) ==
-        Base.TaggedString("test test",
-                     [(1:4, :tag => 5),
-                      (5:5, :tag => 2),
-                      (6:9, :tag => 5)])
-    @test repeat(str1, 2) == Base.TaggedString("testtest", [(1:8, :tag => 5)])
-    @test repeat(str2, 2) == Base.TaggedString("casecase", [(2:3, :tag => "oomph"),
-                                                       (6:7, :tag => "oomph")])
-    @test repeat(str1[1], 3) == Base.TaggedString("ttt", [(1:3, :tag => 5)])
-    @test reverse(str1) == Base.TaggedString("tset", [(1:4, :tag => 5)])
-    @test reverse(str2) == Base.TaggedString("esac", [(2:3, :tag => "oomph")])
-end

From 6d1c0a067fddfc30b4f3e7cff1b6e5869095292b Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Fri, 20 Oct 2023 22:07:00 +0200
Subject: [PATCH 0054/1315] add simple smokescreen test for `--bug-report`
 (#51776)

follow-up PR to #51750 since BugReporting was broken at the time
---
 test/cmdlineargs.jl | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index fc6016da960c4..aa54efab2c835 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -997,6 +997,10 @@ end
 
 # test --bug-report=rr
 if Sys.islinux() && Sys.ARCH in (:i686, :x86_64, :aarch64) # rr is only available on these platforms
-    # TODO: get this to work on CI
-    @test_skip success(setenv(`$(Base.julia_cmd()) --bug-report=rr-local -e 'exit()'`, "JULIA_RR_RECORD_ARGS" => "-n"))
+    mktempdir() do temp_trace_dir
+        @test success(pipeline(setenv(`$(Base.julia_cmd()) --bug-report=rr-local -e 'exit()'`,
+                                      "JULIA_RR_RECORD_ARGS" => "-n --nested=ignore",
+                                      "_RR_TRACE_DIR" => temp_trace_dir);
+                               #=stdout, stderr=#))
+    end
 end

From f71228d939114a84c0c82f0740785f764a2c38ef Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Fri, 20 Oct 2023 16:24:56 -0400
Subject: [PATCH 0055/1315] fix unicode indexing in parse(Complex, string)
 (#51758)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This fixes a string-indexing bug introduced in #24713 (Julia 0.7).
Sometimes, this would cause `parse(Complex{T}, string)` to throw a
`StringIndexError` rather than an `ArgumentError`, e.g. for
`parse(ComplexF64, "3 β+ 4im")` or `parse(ComplexF64, "3 + 4αm")`. (As
far as I can tell, it can never cause parsing to fail for valid
strings.)

The source of the error is that if `i` is the index of an ASCII
character in a string `s`, then `s[i+1]` is valid (even if the next
character is non-ASCII) but `s[i-1]` is invalid if the previous
character is non-ASCII.
---
 base/parse.jl | 10 +++++-----
 test/parse.jl |  2 ++
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/base/parse.jl b/base/parse.jl
index f6a93e56369b7..ab1adb7c30895 100644
--- a/base/parse.jl
+++ b/base/parse.jl
@@ -321,14 +321,14 @@ function tryparse_internal(::Type{Complex{T}}, s::Union{String,SubString{String}
     if i₊ == i # leading ± sign
         i₊ = something(findnext(in(('+','-')), s, i₊+1), 0)
     end
-    if i₊ != 0 && s[i₊-1] in ('e','E') # exponent sign
+    if i₊ != 0 && s[prevind(s, i₊)] in ('e','E') # exponent sign
         i₊ = something(findnext(in(('+','-')), s, i₊+1), 0)
     end
 
     # find trailing im/i/j
     iᵢ = something(findprev(in(('m','i','j')), s, e), 0)
     if iᵢ > 0 && s[iᵢ] == 'm' # im
-        iᵢ -= 1
+        iᵢ = prevind(s, iᵢ)
         if s[iᵢ] != 'i'
             raise && throw(ArgumentError("expected trailing \"im\", found only \"m\""))
             return nothing
@@ -337,7 +337,7 @@ function tryparse_internal(::Type{Complex{T}}, s::Union{String,SubString{String}
 
     if i₊ == 0 # purely real or imaginary value
         if iᵢ > i && !(iᵢ == i+1 && s[i] in ('+','-')) # purely imaginary (not "±inf")
-            x = tryparse_internal(T, s, i, iᵢ-1, raise)
+            x = tryparse_internal(T, s, i, prevind(s, iᵢ), raise)
             x === nothing && return nothing
             return Complex{T}(zero(x),x)
         else # purely real
@@ -353,11 +353,11 @@ function tryparse_internal(::Type{Complex{T}}, s::Union{String,SubString{String}
     end
 
     # parse real part
-    re = tryparse_internal(T, s, i, i₊-1, raise)
+    re = tryparse_internal(T, s, i, prevind(s, i₊), raise)
     re === nothing && return nothing
 
     # parse imaginary part
-    im = tryparse_internal(T, s, i₊+1, iᵢ-1, raise)
+    im = tryparse_internal(T, s, i₊+1, prevind(s, iᵢ), raise)
     im === nothing && return nothing
 
     return Complex{T}(re, s[i₊]=='-' ? -im : im)
diff --git a/test/parse.jl b/test/parse.jl
index 69092b2c4188d..e2b94a45cc446 100644
--- a/test/parse.jl
+++ b/test/parse.jl
@@ -296,6 +296,8 @@ end
         @test_throws ArgumentError parse(Complex{T}, bad)
     end
     @test_throws ArgumentError parse(Complex{Int}, "3 + 4.2im")
+    @test_throws ArgumentError parse(ComplexF64, "3 β+ 4im")
+    @test_throws ArgumentError parse(ComplexF64, "3 + 4αm")
 end
 
 @testset "parse and tryparse type inference" begin

From fb01dd28a5fbabdae6cb5f23c8493db9a377fda3 Mon Sep 17 00:00:00 2001
From: Nathan Zimmerberg <39104088+nhz2@users.noreply.github.com>
Date: Sat, 21 Oct 2023 16:20:35 -0400
Subject: [PATCH 0056/1315] Throw OverflowError on typemin(Int)//(-1) (#51085)

Fixes #32443

Currently `typemin(Int)//(-1) == typemin(Int)//(1)`, ignoring an
overflow.

As noted by @JeffreySarnoff in
[#32443](https://github.com/JuliaLang/julia/issues/32443#issuecomment-506816722)
This should throw an error instead of silently overflowing.

To fix this I am using `checked_neg` instead of `-` in the Rational
constructor.

With this PR `(-one(T))//typemin(T)` will now also throw an
`OverflowError` instead of an `ArgumentError`
---
 base/rational.jl |  6 ++----
 test/rational.jl | 11 ++++++++---
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/base/rational.jl b/base/rational.jl
index cfa1e257bc539..4671478f0b0d3 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -17,12 +17,10 @@ end
 unsafe_rational(num::T, den::T) where {T<:Integer} = unsafe_rational(T, num, den)
 unsafe_rational(num::Integer, den::Integer) = unsafe_rational(promote(num, den)...)
 
-@noinline __throw_rational_argerror_typemin(T) = throw(ArgumentError("invalid rational: denominator can't be typemin($T)"))
 function checked_den(::Type{T}, num::T, den::T) where T<:Integer
     if signbit(den)
-        den = -den
-        signbit(den) && __throw_rational_argerror_typemin(typeof(den))
-        num = -num
+        den = checked_neg(den)
+        num = checked_neg(num)
     end
     return unsafe_rational(T, num, den)
 end
diff --git a/test/rational.jl b/test/rational.jl
index 4b29618bd15e0..9efbc931650c4 100644
--- a/test/rational.jl
+++ b/test/rational.jl
@@ -28,8 +28,8 @@ using Test
     @test (1//typemax(Int)) / (1//typemax(Int)) == 1
     @test_throws OverflowError (1//2)^63
     @test inv((1+typemin(Int))//typemax(Int)) == -1
-    @test_throws ArgumentError inv(typemin(Int)//typemax(Int))
-    @test_throws ArgumentError Rational(0x1, typemin(Int32))
+    @test_throws OverflowError inv(typemin(Int)//typemax(Int))
+    @test_throws OverflowError Rational(0x1, typemin(Int32))
 
     @test @inferred(rationalize(Int, 3.0, 0.0)) === 3//1
     @test @inferred(rationalize(Int, 3.0, 0)) === 3//1
@@ -43,10 +43,15 @@ using Test
     # issue 26823
     @test_throws InexactError rationalize(Int, NaN)
     # issue 32569
-    @test_throws ArgumentError 1 // typemin(Int)
+    @test_throws OverflowError 1 // typemin(Int)
     @test_throws ArgumentError 0 // 0
     @test -2 // typemin(Int) == -1 // (typemin(Int) >> 1)
     @test 2 // typemin(Int) == 1 // (typemin(Int) >> 1)
+    # issue 32443
+    @test Int8(-128)//Int8(1) == -128
+    @test_throws OverflowError Int8(-128)//Int8(-1)
+    @test_throws OverflowError Int8(-1)//Int8(-128)
+    @test Int8(-128)//Int8(-2) == 64
 
     @test_throws InexactError Rational(UInt(1), typemin(Int32))
     @test iszero(Rational{Int}(UInt(0), 1))

From fa66820901a71fbd6bf9c9bf8040ee38c78513a1 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sun, 22 Oct 2023 19:42:56 -0400
Subject: [PATCH 0057/1315] REPLCompletions: only complete kwargs in kwarg
 position (#51801)

---
 stdlib/REPL/src/REPLCompletions.jl  |  8 ++++++--
 stdlib/REPL/test/replcompletions.jl | 14 +++++++-------
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 04e376b013114..6eb12c71dcb07 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -970,8 +970,12 @@ function complete_keyword_argument(partial, last_idx, context_module)
     end
 
     suggestions = Completion[KeywordArgumentCompletion(kwarg) for kwarg in kwargs]
-    append!(suggestions, complete_symbol(nothing, last_word, Returns(true), context_module))
-    append!(suggestions, complete_keyval(last_word))
+
+    # Only add these if not in kwarg space. i.e. not in `foo(; `
+    if kwargs_flag == 0
+        append!(suggestions, complete_symbol(nothing, last_word, Returns(true), context_module))
+        append!(suggestions, complete_keyval(last_word))
+    end
 
     return sort!(suggestions, by=completion_text), wordrange
 end
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 96a190e9f41ea..128bd4827ca92 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -1457,22 +1457,22 @@ end
     c, r = test_complete("CompletionFoo.kwtest3(a;foob")
     @test c == ["foobar="]
     c, r = test_complete("CompletionFoo.kwtest3(a; le")
-    @test "length" ∈ c # provide this kind of completion in case the user wants to splat a variable
+    @test "length" ∉ c
     @test "length=" ∈ c
     @test "len2=" ∈ c
     @test "len2" ∉ c
     c, r = test_complete("CompletionFoo.kwtest3.(a;\nlength")
-    @test "length" ∈ c
+    @test "length" ∉ c
     @test "length=" ∈ c
     c, r = test_complete("CompletionFoo.kwtest3(a, length=4, l")
     @test "length" ∈ c
     @test "length=" ∉ c # since it was already used, do not suggest it again
     @test "len2=" ∈ c
     c, r = test_complete("CompletionFoo.kwtest3(a; kwargs..., fo")
-    @test "foreach" ∈ c # provide this kind of completion in case the user wants to splat a variable
+    @test "foreach" ∉ c
     @test "foobar=" ∈ c
     c, r = test_complete("CompletionFoo.kwtest3(a; another!kwarg=0, le")
-    @test "length" ∈ c
+    @test "length" ∉ c
     @test "length=" ∈ c # the first method could be called and `anotherkwarg` slurped
     @test "len2=" ∈ c
     c, r = test_complete("CompletionFoo.kwtest3(a; another!")
@@ -1486,7 +1486,7 @@ end
     c, r = test_complete_foo("kwtest3(blabla; unknown=4, namedar")
     @test c == ["namedarg="]
     c, r = test_complete_foo("kwtest3(blabla; named")
-    @test "named" ∈ c
+    @test "named" ∉ c
     @test "namedarg=" ∈ c
     @test "len2" ∉ c
     c, r = test_complete_foo("kwtest3(blabla; named.")
@@ -1494,11 +1494,11 @@ end
     c, r = test_complete_foo("kwtest3(blabla; named..., another!")
     @test c == ["another!kwarg="]
     c, r = test_complete_foo("kwtest3(blabla; named..., len")
-    @test "length" ∈ c
+    @test "length" ∉ c
     @test "length=" ∈ c
     @test "len2=" ∈ c
     c, r = test_complete_foo("kwtest3(1+3im; named")
-    @test "named" ∈ c
+    @test "named" ∉ c
     # TODO: @test "namedarg=" ∉ c
     @test "len2" ∉ c
     c, r = test_complete_foo("kwtest3(1+3im; named.")

From 0617fecfad3015b7896eba6c34b21364629d2ce6 Mon Sep 17 00:00:00 2001
From: u7581147 <141328479+u7581147@users.noreply.github.com>
Date: Mon, 23 Oct 2023 18:50:22 +1100
Subject: [PATCH 0058/1315] Added tests for the artifact_hash() function in
 Artifacts.jl (#51815)

The code in `Artifacts.jl` has some missing test coverage.

![image](https://github.com/JuliaLang/julia/assets/141328479/a19d3c37-104b-4c5f-abc9-11925fbccbbc)
---
 stdlib/Artifacts/test/runtests.jl | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/stdlib/Artifacts/test/runtests.jl b/stdlib/Artifacts/test/runtests.jl
index 67117217be549..e65c936f08b8a 100644
--- a/stdlib/Artifacts/test/runtests.jl
+++ b/stdlib/Artifacts/test/runtests.jl
@@ -1,4 +1,5 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
+import Base: SHA1
 
 using Artifacts, Test, Base.BinaryPlatforms
 using Artifacts: with_artifacts_directory, pack_platform!, unpack_platform
@@ -120,6 +121,23 @@ end
     end
 end
 
+@testset "artifact_hash()" begin
+    # Use the Linus OS on an ARMv7L architecture for the tests to make tests reproducible
+    armv7l_linux = Platform("armv7l", "linux")
+
+    # Check the first key in Artifacts.toml is hashed correctly
+    @test artifact_hash("HelloWorldC", joinpath(@__DIR__, "Artifacts.toml"); platform=armv7l_linux) ==
+            SHA1("5a8288c8a30578c0d0f24a9cded29579517ce7a8")
+
+    # Check the second key in Artifacts.toml is hashed correctly
+    @test artifact_hash("socrates", joinpath(@__DIR__, "Artifacts.toml"); platform=armv7l_linux) ==
+            SHA1("43563e7631a7eafae1f9f8d9d332e3de44ad7239")
+
+    # Check artifact_hash() works for any AbstractString
+    @test artifact_hash(SubString("HelloWorldC0", 1, 11), joinpath(@__DIR__, "Artifacts.toml"); platform=armv7l_linux) ==
+            SHA1("5a8288c8a30578c0d0f24a9cded29579517ce7a8")
+end
+
 @testset "select_downloadable_artifacts()" begin
     armv7l_linux = Platform("armv7l", "linux")
     artifacts = select_downloadable_artifacts(joinpath(@__DIR__, "Artifacts.toml"); platform=armv7l_linux)

From 0b5430646c1991c51308a6ca13cbc17baa2f99ae Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Mon, 23 Oct 2023 15:51:51 +0800
Subject: [PATCH 0059/1315] Fix off-by-one error in annotated string concat
 (#51803)

A new unit test is also added for the edge-case found, and a few details
of the test string adjusted to make it easier to reason about at a
glance.

-----

This seems to have slipped into #49586 when the `annotatedstring`
function had to be refactored to no longer use `eachstyle` (which was
moved into the stdlib), and escaped the unit tests for index corectness.
---
 base/strings/annotated.jl |  2 +-
 test/strings/annotated.jl | 23 +++++++++++++++--------
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 2df0ece80da1f..c0f3623f41696 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -212,7 +212,7 @@ function annotatedstring(xs...)
             for (region, annot) in x.string.annotations
                 start, stop = first(region), last(region)
                 if start <= x.offset + x.ncodeunits && stop > x.offset
-                    rstart = s.io.size + max(0, start - x.offset) + 1
+                    rstart = s.io.size + max(0, start - x.offset - 1) + 1
                     rstop = s.io.size + min(stop, x.offset + x.ncodeunits) - x.offset
                     push!(annotations, (rstart:rstop, annot))
                 end
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index 324c1ccb495f6..d3ed9d47af432 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -13,16 +13,23 @@
     @test str * "a" == Base.AnnotatedString("some stringa")
     @test str * str == Base.AnnotatedString("some stringsome string")
     Base.annotate!(str, 1:4, :thing => 0x01)
-    Base.annotate!(str, 5:11, :other => 0x02)
+    Base.annotate!(str, 6:11, :other => 0x02)
     Base.annotate!(str, 1:11, :all => 0x03)
+    #  :thing :other
+    #  ┌┸─┐ ┌──┸─┐
+    # "some string"
+    #  └───┰─────┘
+    #     :all
     @test str[3:4] == SubString(str, 3, 4)
     @test Base.AnnotatedString(str[3:4]) ==
         Base.AnnotatedString("me", [(1:2, :thing => 0x01), (1:2, :all => 0x03)])
-    @test str == Base.AnnotatedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    @test Base.AnnotatedString(str[3:6]) ==
+        Base.AnnotatedString("me s", [(1:2, :thing => 0x01), (1:4, :all => 0x03), (4:4, :other => 0x02)])
+    @test str == Base.AnnotatedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (6:11, :other => 0x02)])
     @test str != Base.AnnotatedString("some string")
-    @test str != Base.AnnotatedString("some string", [(1:1, :thing => 0x01), (5:5, :other => 0x02), (11:11, :all => 0x03)])
-    @test str != Base.AnnotatedString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (5:11, :other => 0x12)])
-    @test str != Base.AnnotatedString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    @test str != Base.AnnotatedString("some string", [(1:1, :thing => 0x01), (6:6, :other => 0x02), (11:11, :all => 0x03)])
+    @test str != Base.AnnotatedString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (6:11, :other => 0x12)])
+    @test str != Base.AnnotatedString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (6:11, :other => 0x02)])
     let allstrings =
         ['a', Base.AnnotatedChar('a'), Base.AnnotatedChar('a', [:aaa => 0x04]),
         "a string", Base.AnnotatedString("a string"),
@@ -62,7 +69,7 @@ end
 end
 
 @testset "Styling preservation" begin
-    str = Base.AnnotatedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (5:11, :other => 0x02)])
+    str = Base.AnnotatedString("some string", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (6:11, :other => 0x02)])
     @test match(r".e", str).match == str[3:4]
     @test  match(r"(.e)", str).captures == [str[3:4]]
     let m0 = match(r"(.)e", str)
@@ -74,11 +81,11 @@ end
     @test lpad(str, 12) ==
         Base.AnnotatedString(" some string", [(2:5, :thing => 0x01),
                                       (2:12, :all => 0x03),
-                                      (6:12, :other => 0x02)])
+                                      (7:12, :other => 0x02)])
     @test rpad(str, 12) ==
         Base.AnnotatedString("some string ", [(1:4, :thing => 0x01),
                                       (1:11, :all => 0x03),
-                                      (5:11, :other => 0x02)])
+                                      (6:11, :other => 0x02)])
     str1 = Base.AnnotatedString("test", [(1:4, :label => 5)])
     str2 = Base.AnnotatedString("case", [(2:3, :label => "oomph")])
     @test join([str1, str1], Base.AnnotatedString(" ")) ==

From 37611b407da73b13ec3b520e15fcc39f17293ba5 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Mon, 23 Oct 2023 05:17:54 -0300
Subject: [PATCH 0060/1315] Don't make pkgimages global editable (#51781)

---
 base/loading.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/loading.jl b/base/loading.jl
index 1f6bb5442540a..bb6ab6e870262 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2497,7 +2497,7 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
                 # Ensure that the user can execute the `.so` we're generating
                 # Note that on windows, `filemode(path)` typically returns `0o666`, so this
                 # addition of the execute bit for the user is doubly needed.
-                chmod(tmppath_so, filemode(path) & 0o777 | 0o333)
+                chmod(tmppath_so, filemode(path) & 0o777 | 0o331)
             end
 
             # prune the directory with cache files

From cf00550f955abd408bf0f478882c57887522f67e Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Mon, 23 Oct 2023 14:19:11 +0200
Subject: [PATCH 0061/1315] fix eltype for partition iterators of substrings
 (#51773)

Fixes https://github.com/JuliaLang/julia/issues/51771

The convert method that asserts in #51771 is arguably still faulty
though.
---
 base/strings/util.jl | 2 ++
 test/iterators.jl    | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/base/strings/util.jl b/base/strings/util.jl
index fae40cb568842..a3f8e9a4773a6 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -575,6 +575,8 @@ end
 
 # Specialization for partition(s,n) to return a SubString
 eltype(::Type{PartitionIterator{T}}) where {T<:AbstractString} = SubString{T}
+# SubStrings do not nest
+eltype(::Type{PartitionIterator{T}}) where {T<:SubString} = T
 
 function iterate(itr::PartitionIterator{<:AbstractString}, state = firstindex(itr.c))
     state > ncodeunits(itr.c) && return nothing
diff --git a/test/iterators.jl b/test/iterators.jl
index 59588bdac9684..a60ec32bb9ac0 100644
--- a/test/iterators.jl
+++ b/test/iterators.jl
@@ -1001,3 +1001,7 @@ end
     end
     @test v == ()
 end
+
+@testset "collect partition substring" begin
+    @test collect(Iterators.partition(lstrip("01111", '0'), 2)) == ["11", "11"]
+end

From 0be0b389e300c05abde796f68abbdd95b938f7ad Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Mon, 23 Oct 2023 08:24:31 -0400
Subject: [PATCH 0062/1315] support Unicode 15.1 via utf8proc 2.9.0 (#51799)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Similar to #47392, support [Unicode
15.1](https://www.unicode.org/versions/Unicode15.1.0/) by bumping
utf8proc to 2.9.0 (https://github.com/JuliaStrings/utf8proc/issues/253).

This allows us to use [118 exciting new emoji
characters](https://blog.emojipedia.org/whats-new-in-unicode-15-1-and-emoji-15-1/)
as identifiers, including "edible mushroom" `"\U1f344\u200d\U1f7eb"`
(but still no superscript "q").

Interestingly, they also updated the [Unicode recommendations on
programming-language identifiers
(UAX#31)](https://www.unicode.org/reports/tr31/tr31-39.html#Mathematical_Compatibility_Notation_Profile)
to finally "bless" identifiers beginning with `∂` and `∇` and/or ending
with numeric sub/superscripts. They still don't recommend nearly the
range of identifiers accepted by Julia, however.
---
 NEWS.md                 | 1 +
 deps/checksums/utf8proc | 4 ++--
 deps/utf8proc.version   | 4 ++--
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index fb6d79ec78836..50d1816704da1 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -8,6 +8,7 @@ New language features
   difference between `public` and `export` is that `public` names do not become
   available when `using` a package/module. ([#50105])
 * `ScopedValue` implement dynamic scope with inheritance across tasks ([#50958]).
+* Support for Unicode 15.1 ([#51799]).
 * A new `AbstractString` type, `AnnotatedString`, is introduced that allows for
   regional annotations to be attached to an underlying string. This type is
   particularly useful for holding styling information, and is used extensively
diff --git a/deps/checksums/utf8proc b/deps/checksums/utf8proc
index c1b2a6779e555..543c1805afbd8 100644
--- a/deps/checksums/utf8proc
+++ b/deps/checksums/utf8proc
@@ -1,2 +1,2 @@
-utf8proc-1cb28a66ca79a0845e99433fd1056257456cef8b.tar.gz/md5/aff37aadd1b02cad3259683e8a5f4543
-utf8proc-1cb28a66ca79a0845e99433fd1056257456cef8b.tar.gz/sha512/3ee433e5577e01f334aa4224275dfb7ee6ae7c785013df3eee6fc0488218d3bc895649811589edf57461c6520ad70437fbf6a376959a6a6f70bd920eb01c5001
+utf8proc-34db3f7954e9298e89f42641ac78e0450f80a70d.tar.gz/md5/e70e4fd2c914b4d4c0e3f0e2ca6c96d4
+utf8proc-34db3f7954e9298e89f42641ac78e0450f80a70d.tar.gz/sha512/0037f144e1150abd1b330d8a0c3a46c8352903acc9f4c8aad6bddd1370b19cc34551f8def58752cdff4eaace3efe54180bc11439a0e35c5ccad2fec4678c017e
diff --git a/deps/utf8proc.version b/deps/utf8proc.version
index 659b995e8abaf..a026ca858cfd3 100644
--- a/deps/utf8proc.version
+++ b/deps/utf8proc.version
@@ -1,2 +1,2 @@
-UTF8PROC_BRANCH=v2.8.0
-UTF8PROC_SHA1=1cb28a66ca79a0845e99433fd1056257456cef8b
+UTF8PROC_BRANCH=v2.9.0
+UTF8PROC_SHA1=34db3f7954e9298e89f42641ac78e0450f80a70d

From abd00d09ce37c2e1a09efde6bb5a588f7b33cd72 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Mon, 23 Oct 2023 23:31:32 -0300
Subject: [PATCH 0063/1315] Add version string to sysimg triple (#51830)

---
 src/aotcompile.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 2e1a9d2418eaa..6f55319e60b7d 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1500,7 +1500,13 @@ void jl_dump_native_impl(void *native_code,
         TheTriple.setObjectFormat(Triple::COFF);
     } else if (TheTriple.isOSDarwin()) {
         TheTriple.setObjectFormat(Triple::MachO);
-        TheTriple.setOS(llvm::Triple::MacOSX);
+        SmallString<16> Str;
+        Str += "macosx";
+        if (TheTriple.isAArch64())
+            Str += "11.0.0"; // Update this if MACOSX_VERSION_MIN changes
+        else
+            Str += "10.14.0";
+        TheTriple.setOSName(Str);
     }
     Optional<Reloc::Model> RelocModel;
     if (TheTriple.isOSLinux() || TheTriple.isOSFreeBSD()) {

From b197197a51cb1d4eea5c3e3fed0ae3419449a6d6 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Tue, 24 Oct 2023 03:11:54 -0500
Subject: [PATCH 0064/1315] Fix typo in range display (#51832)

Thanks ScottPJones for finding this.

Co-authored-by: Lilith Hafner <Lilith.Hafner@gmail.com>
---
 base/range.jl  | 2 +-
 test/ranges.jl | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/base/range.jl b/base/range.jl
index 13a8bd2701ae5..d3be5b8931015 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -597,7 +597,7 @@ function show(io::IO, r::LinRange{T}) where {T}
     print(io, "LinRange{")
     show(io, T)
     print(io, "}(")
-    ioc = IOContext(io, :typeinto=>T)
+    ioc = IOContext(io, :typeinfo=>T)
     show(ioc, first(r))
     print(io, ", ")
     show(ioc, last(r))
diff --git a/test/ranges.jl b/test/ranges.jl
index 4f88d991181db..2176e0cae7247 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -1286,6 +1286,8 @@ end
 
     @test sprint(show, UnitRange(1, 2)) == "1:2"
     @test sprint(show, StepRange(1, 2, 5)) == "1:2:5"
+
+    @test sprint(show, LinRange{Float32}(1.5, 2.5, 10)) == "LinRange{Float32}(1.5, 2.5, 10)"
 end
 
 @testset "Issue 11049, and related" begin

From 9352d9ebca64a1a8e8f584720af0e7bb1b5a9d23 Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Tue, 24 Oct 2023 10:12:30 +0200
Subject: [PATCH 0065/1315] Revert "clean up identifiers defined in `Main`
 (#51411)" (#51825)

This reverts commit ab94a242f6e56438f86a1babab7721db45b7feed.

Ref
https://github.com/JuliaLang/julia/pull/51411#issuecomment-1765402688
fixes https://github.com/JuliaLang/julia/issues/51823
---
 base/client.jl                      | 19 ++++++++++++-------
 base/sysimg.jl                      |  7 ++++---
 stdlib/REPL/src/REPL.jl             |  2 +-
 stdlib/REPL/test/replcompletions.jl |  3 +++
 test/client.jl                      |  5 +++++
 5 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/base/client.jl b/base/client.jl
index d55c2695e11e8..6f4b3273420f3 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -261,8 +261,8 @@ function exec_options(opts)
     distributed_mode = (opts.worker == 1) || (opts.nprocs > 0) || (opts.machine_file != C_NULL)
     if distributed_mode
         let Distributed = require(PkgId(UUID((0x8ba89e20_285c_5b6f, 0x9357_94700520ee1b)), "Distributed"))
-            Core.eval(MainInclude, :(const Distributed = $Distributed))
-            Core.eval(Main, :(using Base.MainInclude.Distributed))
+            Core.eval(Main, :(const Distributed = $Distributed))
+            Core.eval(Main, :(using .Distributed))
         end
 
         invokelatest(Main.Distributed.process_opts, opts)
@@ -384,18 +384,19 @@ _atreplinit(repl) = invokelatest(__atreplinit, repl)
 
 function load_InteractiveUtils(mod::Module=Main)
     # load interactive-only libraries
-    if !isdefined(MainInclude, :InteractiveUtils)
+    if !isdefined(mod, :InteractiveUtils)
         try
             let InteractiveUtils = require(PkgId(UUID(0xb77e0a4c_d291_57a0_90e8_8db25a27a240), "InteractiveUtils"))
-                Core.eval(MainInclude, :(const InteractiveUtils = $InteractiveUtils))
+                Core.eval(mod, :(const InteractiveUtils = $InteractiveUtils))
+                Core.eval(mod, :(using .InteractiveUtils))
+                return InteractiveUtils
             end
         catch ex
             @warn "Failed to import InteractiveUtils into module $mod" exception=(ex, catch_backtrace())
-            return nothing
         end
+        return nothing
     end
-    Core.eval(mod, :(using Base.MainInclude.InteractiveUtils))
-    return MainInclude.InteractiveUtils
+    return getfield(mod, :InteractiveUtils)
 end
 
 function load_REPL()
@@ -512,6 +513,10 @@ A variable referring to the last thrown errors, automatically imported to the in
 The thrown errors are collected in a stack of exceptions.
 """
 global err = nothing
+
+# weakly exposes ans and err variables to Main
+export ans, err
+
 end
 
 """
diff --git a/base/sysimg.jl b/base/sysimg.jl
index a4bf21786c633..31efa933c1104 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -4,6 +4,10 @@ Core.include(Main, "Base.jl")
 
 using .Base
 
+# Set up Main module
+using Base.MainInclude # ans, err, and sometimes Out
+import Base.MainInclude: eval, include
+
 # Ensure this file is also tracked
 pushfirst!(Base._included_files, (@__MODULE__, abspath(@__FILE__)))
 
@@ -75,10 +79,7 @@ let
     empty!(LOAD_PATH)
     Base.init_load_path() # want to be able to find external packages in userimg.jl
 
-    # Set up Main module
     ccall(:jl_clear_implicit_imports, Cvoid, (Any,), Main)
-    eval(Main, :(using Base.MainInclude: eval, include, ans, err))
-
     tot_time_userimg = @elapsed (isfile("userimg.jl") && Base.include(Main, "userimg.jl"))
 
     tot_time_base = (Base.end_base_include - Base.start_base_include) * 10.0^(-9)
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index fe324345a3e17..25b2ff00602d6 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -1490,8 +1490,8 @@ function capture_result(n::Ref{Int}, @nospecialize(x))
     mod = Base.MainInclude
     if !isdefined(mod, :Out)
         @eval mod global Out
+        @eval mod export Out
         setglobal!(mod, :Out, Dict{Int, Any}())
-        @eval Main using Base.MainInclude: Out
     end
     if x !== getglobal(mod, :Out) && x !== nothing # remove this?
         getglobal(mod, :Out)[n] = x
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 128bd4827ca92..28b3ef5de2ed7 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2089,3 +2089,6 @@ let t = REPLCompletions.repl_eval_ex(:(`a b`), @__MODULE__; limit_aggressive_inf
     @test t isa Core.Const
     @test t.val == `a b`
 end
+
+# issue #51823
+@test "include" in test_complete_context("inc", Main)[1]
diff --git a/test/client.jl b/test/client.jl
index 0649ab3241d62..b2877001d235e 100644
--- a/test/client.jl
+++ b/test/client.jl
@@ -52,3 +52,8 @@ end
         ERROR: ErrorException
         """s, err_str)
 end
+
+@testset "defining `ans` and `err`" begin
+    @test eval(:(ans = 1)) == 1
+    @test eval(:(err = 1)) == 1
+end

From 09078586880830ee4564a075a16d658b3b393ac4 Mon Sep 17 00:00:00 2001
From: Eric Hanson <5846501+ericphanson@users.noreply.github.com>
Date: Tue, 24 Oct 2023 10:13:23 +0200
Subject: [PATCH 0066/1315] [Printf] mark format and Format with public keyword
 (#51797)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

followup to https://github.com/JuliaLang/julia/pull/51723 to prevent
```julia
  │ Warning
  │
  │  The following bindings may be internal; they may change or be removed in future versions:
  │
  │    •  Printf.Format
```
---
 stdlib/Printf/src/Printf.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/stdlib/Printf/src/Printf.jl b/stdlib/Printf/src/Printf.jl
index 8d2d97ddd6b32..ae9bf45786295 100644
--- a/stdlib/Printf/src/Printf.jl
+++ b/stdlib/Printf/src/Printf.jl
@@ -6,6 +6,8 @@ using Base.Ryu
 
 export @printf, @sprintf
 
+public format, Format
+
 # format specifier categories
 const Ints = Union{Val{'d'}, Val{'i'}, Val{'u'}, Val{'x'}, Val{'X'}, Val{'o'}}
 const Floats = Union{Val{'e'}, Val{'E'}, Val{'f'}, Val{'F'}, Val{'g'}, Val{'G'}, Val{'a'}, Val{'A'}}

From 17a36eeb06192b9c878cdaa8436ede23f61acfa0 Mon Sep 17 00:00:00 2001
From: Paul Berg <paul@plutojl.org>
Date: Tue, 24 Oct 2023 10:14:07 +0200
Subject: [PATCH 0067/1315] Make local scope for `else` blocks in
 `try`/`catch`/`else` (#51785)

[Docs](https://docs.julialang.org/en/v1/manual/control-flow/#else-Clauses)
state:

> The try, catch, else, and finally clauses each introduce their own
> scope blocks.

But it is currently not the case for `else` blocks

```julia
julia> try
       catch
       else
           z = 1
       end
1

julia> z
1
```

This change actually makes `else` blocks have their own scope block:

```julia
julia> try
       catch
       else
           z = 1
       end
1

julia> z
ERROR: UndefVarError: `z` not defined
```
---
 src/julia-syntax.scm |  2 +-
 test/syntax.jl       | 16 ++++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 8c3dce77bc6fc..87a40d2bf3804 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1424,7 +1424,7 @@
                 (scope-block ,finalb)))))
           ((length> e 3)
            (and (length> e 6) (error "invalid \"try\" form"))
-           (let ((elseb (if (length= e 6) (cdddddr e) '())))
+           (let ((elseb (if (length= e 6) `((scope-block ,@(cdddddr e))) '())))
              (expand-forms
                `(,(if (null? elseb) 'trycatch 'trycatchelse)
                  (scope-block ,tryb)
diff --git a/test/syntax.jl b/test/syntax.jl
index f6b66d4882021..67916e8d37d8c 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -3187,6 +3187,22 @@ end
     end
     @test err == 5 + 6
     @test x == 1
+
+    x = 0
+    try
+    catch
+    else
+        x = 1
+    end
+    @test x == 1
+
+    try
+    catch
+    else
+        tryelse_in_local_scope = true
+    end
+
+    @test !@isdefined(tryelse_in_local_scope)
 end
 
 @test_parseerror """

From d38348b47616394799c7856e119cdc43418c4885 Mon Sep 17 00:00:00 2001
From: matthias314 <56549971+matthias314@users.noreply.github.com>
Date: Tue, 24 Oct 2023 04:14:28 -0400
Subject: [PATCH 0068/1315] delete unused local variable in `@generated`
 (#51778)

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 base/expr.jl | 1 -
 1 file changed, 1 deletion(-)

diff --git a/base/expr.jl b/base/expr.jl
index 94dd28fe2ebb5..0f7dc76395930 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -1029,7 +1029,6 @@ macro generated(f)
     if isa(f, Expr) && (f.head === :function || is_short_function_def(f))
         body = f.args[2]
         lno = body.args[1]
-        tmp = gensym("tmp")
         return Expr(:escape,
                     Expr(f.head, f.args[1],
                          Expr(:block,

From 5e4330926aee261553b89eddc3b6df905c14571c Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 24 Oct 2023 10:17:56 +0200
Subject: [PATCH 0069/1315] make Meta-M with a empty prompt return the
 contextual module to Main (#51616)

---
 NEWS.md                       |  1 +
 stdlib/REPL/docs/src/index.md |  6 +++---
 stdlib/REPL/src/LineEdit.jl   | 20 ++++++++++++++------
 3 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 50d1816704da1..eed82068823be 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -87,6 +87,7 @@ Standard library changes
 
 * Tab complete hints now show in lighter text while typing in the repl. To disable
   set `Base.active_repl.options.hint_tab_completes = false` ([#51229])
+* Meta-M with an empty prompt now returns the contextual module of the REPL to `Main`.
 
 #### SuiteSparse
 
diff --git a/stdlib/REPL/docs/src/index.md b/stdlib/REPL/docs/src/index.md
index d1064d9c063b4..bee94354e57e1 100644
--- a/stdlib/REPL/docs/src/index.md
+++ b/stdlib/REPL/docs/src/index.md
@@ -577,8 +577,8 @@ Main
 
 It is possible to change this contextual module via the function
 `REPL.activate(m)` where `m` is a `Module` or by typing the module in the REPL
-and pressing the keybinding Alt-m (the cursor must be on the module name). The
-active module is shown in the prompt:
+and pressing the keybinding Alt-m (the cursor must be on the module name). The `Main` module can be "activated" with an empty prompt plus the keybinding. The
+active module is shown in the prompt (unless it is `Main`):
 
 ```julia-repl
 julia> using REPL
@@ -598,7 +598,7 @@ julia> Core<Alt-m> # using the keybinding to change module
 
 (Core) julia>
 
-(Core) julia> Main<Alt-m> # going back to Main via keybinding
+(Core) julia> <Alt-m> # going back to Main via keybinding
 
 julia>
 ```
diff --git a/stdlib/REPL/src/LineEdit.jl b/stdlib/REPL/src/LineEdit.jl
index efe893870d46e..2fdeb707043b0 100644
--- a/stdlib/REPL/src/LineEdit.jl
+++ b/stdlib/REPL/src/LineEdit.jl
@@ -1475,14 +1475,22 @@ current_word_with_dots(s::MIState) = current_word_with_dots(buffer(s))
 
 function activate_module(s::MIState)
     word = current_word_with_dots(s);
-    isempty(word) && return beep(s)
-    try
-        mod = Base.Core.eval(Base.active_module(), Base.Meta.parse(word))
-        REPL.activate(mod)
-        edit_clear(s)
-    catch
+    mod = if isempty(word)
+        edit_insert(s, ' ') # makes the `edit_clear` below actually update the prompt
+        Main
+    else
+        try
+            Base.Core.eval(Base.active_module(), Base.Meta.parse(word))
+        catch
+            nothing
+        end
+    end
+    if !(mod isa Module)
         beep(s)
+        return
     end
+    REPL.activate(mod)
+    edit_clear(s)
 end
 
 history_prev(::EmptyHistoryProvider) = ("", false)

From 855ec0c7d022aa2ecd8050c5f9ccd708697e014f Mon Sep 17 00:00:00 2001
From: Praneeth Jain <praneethjain005@gmail.com>
Date: Tue, 24 Oct 2023 17:32:32 +0530
Subject: [PATCH 0070/1315] test: add test case for uncovered line in
 accumulate.jl (#51835)

The `accumulate` function had missing code coverage for one dimensional
arrays with an `init` value.

![image](https://github.com/JuliaLang/julia/assets/49565677/a53850c3-4559-4400-8ce2-e653812ec14e)
I have added two tests for this case.
---
 test/arrayops.jl | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/test/arrayops.jl b/test/arrayops.jl
index ba02847094b0e..90a529a6d98c3 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -2724,7 +2724,7 @@ end
 end
 
 @testset "accumulate, accumulate!" begin
-    @test accumulate(+, [1,2,3]) == [1, 3, 6]
+    @test accumulate(+, [1, 2, 3]) == [1, 3, 6]
     @test accumulate(min, [1 2; 3 4], dims=1) == [1 2; 1 2]
     @test accumulate(max, [1 2; 3 0], dims=2) == [1 2; 3 3]
     @test accumulate(+, Bool[]) == Int[]
@@ -2741,12 +2741,15 @@ end
     @test accumulate(min, [1 0; 0 1], dims=1) == [1 0; 0 0]
     @test accumulate(min, [1 0; 0 1], dims=2) == [1 0; 0 0]
 
+    @test accumulate(+, [1, 2, 3], dims=1, init=1) == [2, 4, 7]
+    @test accumulate(*, [1, 4, 2], dims=1, init=2) == [2, 8, 16]
+
     @test accumulate(min, [3 2 1; 3 2 1], dims=2) == [3 2 1; 3 2 1]
     @test accumulate(min, [3 2 1; 3 2 1], dims=2, init=2) == [2 2 1; 2 2 1]
 
     @test isa(accumulate(+, Int[]), Vector{Int})
     @test isa(accumulate(+, Int[]; init=1.), Vector{Float64})
-    @test accumulate(+, [1,2]; init=1) == [2, 4]
+    @test accumulate(+, [1, 2]; init=1) == [2, 4]
     arr = randn(4)
     @test accumulate(*, arr; init=1) ≈ accumulate(*, arr)
 
@@ -2790,7 +2793,7 @@ end
 
     # asymmetric operation
     op(x,y) = 2x+y
-    @test accumulate(op, [10,20, 30]) == [10, op(10, 20), op(op(10, 20), 30)] == [10, 40, 110]
+    @test accumulate(op, [10, 20, 30]) == [10, op(10, 20), op(op(10, 20), 30)] == [10, 40, 110]
     @test accumulate(op, [10 20 30], dims=2) == [10 op(10, 20) op(op(10, 20), 30)] == [10 40 110]
 
     #25506

From a75c7091f5480247fc8fe2592e526ce842e9cec1 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Tue, 24 Oct 2023 08:02:30 -0500
Subject: [PATCH 0071/1315] [nfc] Move comment in docview.jl (#51737)

---
 stdlib/REPL/src/docview.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stdlib/REPL/src/docview.jl b/stdlib/REPL/src/docview.jl
index 84323f2072b1e..41608a793be5e 100644
--- a/stdlib/REPL/src/docview.jl
+++ b/stdlib/REPL/src/docview.jl
@@ -193,6 +193,8 @@ function insert_internal_warning(md::Markdown.MD, internal_access::Set{Pair{Modu
     md
 end
 function insert_internal_warning(other, internal_access::Set{Pair{Module,Symbol}})
+    # We don't know how to insert an internal symbol warning into non-markdown
+    # content, so we don't.
     other
 end
 
@@ -241,8 +243,6 @@ function doc(binding::Binding, sig::Type = Union{})
         md = catdoc(mapany(parsedoc, results)...)
         # Save metadata in the generated markdown.
         if isa(md, Markdown.MD)
-            # We don't know how to insert an internal symbol warning into non-markdown
-            # content, so we don't.
             md.meta[:results] = results
             md.meta[:binding] = binding
             md.meta[:typesig] = sig

From a6d9df76bce04653738ee25896d62aea67d36787 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Tue, 24 Oct 2023 08:05:18 -0500
Subject: [PATCH 0072/1315] Only warn in helpmode on successful nonpublic
 access (#51346)

---
 stdlib/REPL/src/docview.jl  | 2 +-
 stdlib/REPL/test/docview.jl | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/stdlib/REPL/src/docview.jl b/stdlib/REPL/src/docview.jl
index 41608a793be5e..8551c5f38fcd3 100644
--- a/stdlib/REPL/src/docview.jl
+++ b/stdlib/REPL/src/docview.jl
@@ -166,7 +166,7 @@ struct Logged{F}
     collection::Set{Pair{Module,Symbol}}
 end
 function (la::Logged)(m::Module, s::Symbol)
-    m !== la.mod && !Base.ispublic(m, s) && push!(la.collection, m => s)
+    m !== la.mod && Base.isdefined(m, s) && !Base.ispublic(m, s) && push!(la.collection, m => s)
     la.f(m, s)
 end
 (la::Logged)(args...) = la.f(args...)
diff --git a/stdlib/REPL/test/docview.jl b/stdlib/REPL/test/docview.jl
index d7caf7eef7d7c..897a69a9266ab 100644
--- a/stdlib/REPL/test/docview.jl
+++ b/stdlib/REPL/test/docview.jl
@@ -132,3 +132,6 @@ module InternalWarningsTests
         @test docstring("A.B3") == "No docstring or readme file found for public module `$(@__MODULE__).A.B3`.\n\nModule does not have any public names.\n"
     end
 end
+
+# Issue #51344, don't print "internal binding" warning for non-existent bindings.
+@test string(eval(REPL.helpmode("Base.no_such_symbol"))) == "No documentation found.\n\nBinding `Base.no_such_symbol` does not exist.\n"

From 2d8325b684be778115d65def8efa3946b82944cf Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Tue, 24 Oct 2023 08:25:36 -0500
Subject: [PATCH 0073/1315] Run `crate-ci/typos` in CI (#51704)

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .github/workflows/Typos.yml | 56 +++++++++++++++++++++++++++++++++++++
 NEWS.md                     |  3 ++
 typos.toml                  |  2 ++
 3 files changed, 61 insertions(+)
 create mode 100644 .github/workflows/Typos.yml
 create mode 100644 typos.toml

diff --git a/.github/workflows/Typos.yml b/.github/workflows/Typos.yml
new file mode 100644
index 0000000000000..f9fa20fff5d12
--- /dev/null
+++ b/.github/workflows/Typos.yml
@@ -0,0 +1,56 @@
+name: Typos
+
+permissions: {}
+
+on: [pull_request]
+
+jobs:
+  typos-check:
+    name: Check for new typos
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Checkout the JuliaLang/julia repository
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Check spelling with typos
+        #uses: crate-ci/typos@master
+        env:
+          GH_TOKEN: "${{ github.token }}"
+        run: |
+          git fetch --depth=1 origin ${{ github.base_ref }}
+          OLD_FILES=$(git diff-index --name-only --diff-filter=ad FETCH_HEAD)
+          NEW_FILES=$(git diff-index --name-only --diff-filter=d FETCH_HEAD)
+
+          mkdir -p "${{ runner.temp }}/typos"
+          RELEASE_ASSET_URL="$(
+            gh api /repos/crate-ci/typos/releases/latest \
+            --jq '."assets"[] | select(."name" | test("^typos-.+-x86_64-unknown-linux-musl\\.tar\\.gz$")) | ."browser_download_url"'
+          )"
+          wget --secure-protocol=TLSv1_3 --max-redirect=1 --retry-on-host-error --retry-connrefused --tries=3 \
+            --quiet --output-document=- "${RELEASE_ASSET_URL}" \
+            | tar -xz -C "${{ runner.temp }}/typos" ./typos
+          "${{ runner.temp }}/typos/typos" --version
+
+          echo -n $NEW_FILES | xargs "${{ runner.temp }}/typos/typos" --format json >> ${{ runner.temp }}/new_typos.jsonl || true
+          git checkout FETCH_HEAD -- $OLD_FILES
+          echo -n $OLD_FILES | xargs "${{ runner.temp }}/typos/typos" --format json >> ${{ runner.temp }}/old_typos.jsonl  || true
+
+          python -c '
+          import sys, json
+          old = set()
+          with open(sys.argv[1]) as old_file:
+            for line in old_file:
+              old.add(json.loads(line)["typo"])
+          clean = True
+          with open(sys.argv[2]) as new_file:
+            for line in new_file:
+              new = json.loads(line)
+              if new["typo"] not in old:
+                if len(new["typo"]) > 6: # Short typos might be false positives. Long are probably real.
+                  clean = False
+                print("::warning file={},line={},col={}::perhaps \"{}\" should be \"{}\".".format(
+                  new["path"], new["line_num"], new["byte_offset"],
+                  new["typo"], " or ".join(new["corrections"])))
+          sys.exit(1 if not clean else 0)' "${{ runner.temp }}/old_typos.jsonl" "${{ runner.temp }}/new_typos.jsonl"
diff --git a/NEWS.md b/NEWS.md
index eed82068823be..69769c8b3fc9d 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -125,5 +125,8 @@ External dependencies
 Tooling Improvements
 --------------------
 
+* CI now performs limited automatic typo detection on all PRs. If you merge a PR with a
+  failing typo CI check, then the reported typos will be automatically ignored in future CI
+  runs on PRs that edit those same files. ([#51704])
 
 <!--- generated by NEWS-update.jl: -->
diff --git a/typos.toml b/typos.toml
new file mode 100644
index 0000000000000..b9a9311946bc4
--- /dev/null
+++ b/typos.toml
@@ -0,0 +1,2 @@
+[default]
+extend-ignore-words-re = ["^[a-zA-Z]?[a-zA-Z]?[a-zA-Z]?[a-zA-Z]?$"]

From df39cee3d8723d04b8ba73b13e59d45d195e8f0b Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 24 Oct 2023 10:54:04 -0500
Subject: [PATCH 0074/1315] replace many unsafe_convert methods with safer
 cconvert ones (#51764)

This seems the correct way to define most conversions, since the unsafe
logic should typically be isolated to a few areas, and everywhere else
just defines conversions to it. This ensures the root is preserved even
if the user later makes unexpected changes to the parent object
(although the length might have later become inconsistent at that point,
so it is not a guaranteed fix for memory issues).
---
 base/abstractarray.jl                    |  4 ++--
 base/c.jl                                | 11 +++++++----
 base/permuteddimsarray.jl                |  4 +---
 base/pointer.jl                          |  9 ++++++---
 base/refpointer.jl                       | 15 +++++++--------
 base/reinterpretarray.jl                 |  2 +-
 base/reshapedarray.jl                    | 10 +++++++---
 base/secretbuffer.jl                     |  7 ++++---
 base/strings/basic.jl                    |  4 ++--
 base/subarray.jl                         |  7 +++++--
 stdlib/InteractiveUtils/src/clipboard.jl |  2 +-
 stdlib/LinearAlgebra/src/adjtrans.jl     |  4 ++--
 stdlib/LinearAlgebra/test/blas.jl        |  2 +-
 stdlib/Random/src/DSFMT.jl               |  8 +++++---
 stdlib/SharedArrays/src/SharedArrays.jl  |  6 +++---
 test/arrayops.jl                         |  6 +++++-
 test/strings/basic.jl                    |  2 +-
 test/testhelpers/OffsetArrays.jl         |  2 +-
 18 files changed, 61 insertions(+), 44 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index f2329478fbe74..4f8b74abf2486 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1229,10 +1229,10 @@ end
 # note: the following type definitions don't mean any AbstractArray is convertible to
 # a data Ref. they just map the array element type to the pointer type for
 # convenience in cases that work.
-pointer(x::AbstractArray{T}) where {T} = unsafe_convert(Ptr{T}, x)
+pointer(x::AbstractArray{T}) where {T} = unsafe_convert(Ptr{T}, cconvert(Ptr{T}, x))
 function pointer(x::AbstractArray{T}, i::Integer) where T
     @inline
-    unsafe_convert(Ptr{T}, x) + Int(_memory_offset(x, i))::Int
+    pointer(x) + Int(_memory_offset(x, i))::Int
 end
 
 # The distance from pointer(x) to the element at x[I...] in bytes
diff --git a/base/c.jl b/base/c.jl
index bdcb030d799e0..748adb3e93615 100644
--- a/base/c.jl
+++ b/base/c.jl
@@ -200,7 +200,7 @@ cconvert(::Type{Cstring}, s::AbstractString) =
 function cconvert(::Type{Cwstring}, s::AbstractString)
     v = transcode(Cwchar_t, String(s))
     push!(v, 0)
-    return v
+    return cconvert(Cwstring, v)
 end
 
 eltype(::Type{Cstring}) = Cchar
@@ -218,16 +218,19 @@ function unsafe_convert(::Type{Cstring}, s::String)
     return Cstring(p)
 end
 
-function unsafe_convert(::Type{Cwstring}, v::Vector{Cwchar_t})
+unsafe_convert(::Type{Cstring}, s::Union{Vector{UInt8},Vector{Int8}}) = Cstring(unsafe_convert(Ptr{Cvoid}, s))
+
+function cconvert(::Type{Cwstring}, v::Vector{Cwchar_t})
     for i = 1:length(v)-1
         v[i] == 0 &&
             throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(v))"))
     end
     v[end] == 0 ||
         throw(ArgumentError("C string data must be NUL terminated: $(repr(v))"))
-    p = unsafe_convert(Ptr{Cwchar_t}, v)
-    return Cwstring(p)
+    return cconvert(Ptr{Cwchar_t}, v)
 end
+unsafe_convert(::Type{Cwstring}, s) = Cwstring(unsafe_convert(Ptr{Cwchar_t}, s))
+unsafe_convert(::Type{Cwstring}, s::Cwstring) = s
 
 # symbols are guaranteed not to contain embedded NUL
 cconvert(::Type{Cstring}, s::Symbol) = s
diff --git a/base/permuteddimsarray.jl b/base/permuteddimsarray.jl
index 41c3636b40216..a4335609c7d7f 100644
--- a/base/permuteddimsarray.jl
+++ b/base/permuteddimsarray.jl
@@ -49,10 +49,8 @@ Base.parent(A::PermutedDimsArray) = A.parent
 Base.size(A::PermutedDimsArray{T,N,perm}) where {T,N,perm} = genperm(size(parent(A)), perm)
 Base.axes(A::PermutedDimsArray{T,N,perm}) where {T,N,perm} = genperm(axes(parent(A)), perm)
 Base.has_offset_axes(A::PermutedDimsArray) = Base.has_offset_axes(A.parent)
-
 Base.similar(A::PermutedDimsArray, T::Type, dims::Base.Dims) = similar(parent(A), T, dims)
-
-Base.unsafe_convert(::Type{Ptr{T}}, A::PermutedDimsArray{T}) where {T} = Base.unsafe_convert(Ptr{T}, parent(A))
+Base.cconvert(::Type{Ptr{T}}, A::PermutedDimsArray{T}) where {T} = Base.cconvert(Ptr{T}, parent(A))
 
 # It's OK to return a pointer to the first element, and indeed quite
 # useful for wrapping C routines that require a different storage
diff --git a/base/pointer.jl b/base/pointer.jl
index a47f1e38edb9b..5bb5682a6d0d8 100644
--- a/base/pointer.jl
+++ b/base/pointer.jl
@@ -54,17 +54,20 @@ See also [`cconvert`](@ref)
 """
 function unsafe_convert end
 
+# convert strings to String etc. to pass as pointers
+cconvert(::Type{Ptr{UInt8}}, s::AbstractString) = String(s)
+cconvert(::Type{Ptr{Int8}}, s::AbstractString) = String(s)
 unsafe_convert(::Type{Ptr{UInt8}}, x::Symbol) = ccall(:jl_symbol_name, Ptr{UInt8}, (Any,), x)
 unsafe_convert(::Type{Ptr{Int8}}, x::Symbol) = ccall(:jl_symbol_name, Ptr{Int8}, (Any,), x)
 unsafe_convert(::Type{Ptr{UInt8}}, s::String) = ccall(:jl_string_ptr, Ptr{UInt8}, (Any,), s)
 unsafe_convert(::Type{Ptr{Int8}}, s::String) = ccall(:jl_string_ptr, Ptr{Int8}, (Any,), s)
-# convert strings to String etc. to pass as pointers
-cconvert(::Type{Ptr{UInt8}}, s::AbstractString) = String(s)
-cconvert(::Type{Ptr{Int8}}, s::AbstractString) = String(s)
 
 unsafe_convert(::Type{Ptr{T}}, a::Array{T}) where {T} = ccall(:jl_array_ptr, Ptr{T}, (Any,), a)
 unsafe_convert(::Type{Ptr{S}}, a::AbstractArray{T}) where {S,T} = convert(Ptr{S}, unsafe_convert(Ptr{T}, a))
 unsafe_convert(::Type{Ptr{T}}, a::AbstractArray{T}) where {T} = error("conversion to pointer not defined for $(typeof(a))")
+# TODO: add this deprecation to give a better error:
+# cconvert(::Type{<:Ptr}, a::AbstractArray) = error("conversion to pointer not defined for $(typeof(a))")
+# unsafe_convert(::Type{Ptr{T}}, a::AbstractArray{T}) where {T} = error("missing call to cconvert for call to unsafe_convert for AbstractArray")
 
 # unsafe pointer to array conversions
 """
diff --git a/base/refpointer.jl b/base/refpointer.jl
index b89b474e8714c..072323658e40d 100644
--- a/base/refpointer.jl
+++ b/base/refpointer.jl
@@ -148,13 +148,12 @@ if is_primary_base_module
     Ref(x::Ptr{T}, i::Integer) where {T} = x + (i - 1) * Core.sizeof(T)
 
     # convert Arrays to pointer arrays for ccall
-    function Ref{P}(a::Array{<:Union{Ptr,Cwstring,Cstring}}) where P<:Union{Ptr,Cwstring,Cstring}
-        return RefArray(a) # effectively a no-op
-    end
+    # For example `["a", "b"]` to Ptr{Cstring} for `char **argv`
     function Ref{P}(a::Array{T}) where P<:Union{Ptr,Cwstring,Cstring} where T
-        if (!isbitstype(T) && T <: eltype(P))
+        if (isbitstype(T) ? T <: Ptr || T <: Union{Cwstring,Cstring} : T <: eltype(P))
             # this Array already has the right memory layout for the requested Ref
-            return RefArray(a,1,false) # root something, so that this function is type-stable
+            # but the wrong eltype for the constructor
+            return RefArray{P,typeof(a),Nothing}(a, 1, nothing) # effectively a no-op
         else
             ptrs = Vector{P}(undef, length(a)+1)
             roots = Vector{Any}(undef, length(a))
@@ -164,14 +163,14 @@ if is_primary_base_module
                 roots[i] = root
             end
             ptrs[length(a)+1] = C_NULL
-            return RefArray(ptrs,1,roots)
+            return RefArray{P,typeof(ptrs),typeof(roots)}(ptrs, 1, roots)
         end
     end
     Ref(x::AbstractArray, i::Integer) = RefArray(x, i)
 end
 
-cconvert(::Type{Ptr{P}}, a::Array{<:Ptr}) where {P<:Ptr} = a
-cconvert(::Type{Ref{P}}, a::Array{<:Ptr}) where {P<:Ptr} = a
+cconvert(::Type{Ptr{P}}, a::Array{P}) where {P<:Union{Ptr,Cwstring,Cstring}} = a
+cconvert(::Type{Ref{P}}, a::Array{P}) where {P<:Union{Ptr,Cwstring,Cstring}} = a
 cconvert(::Type{Ptr{P}}, a::Array) where {P<:Union{Ptr,Cwstring,Cstring}} = Ref{P}(a)
 cconvert(::Type{Ref{P}}, a::Array) where {P<:Union{Ptr,Cwstring,Cstring}} = Ref{P}(a)
 
diff --git a/base/reinterpretarray.jl b/base/reinterpretarray.jl
index a4aa66c7f3533..16d2716c7a2eb 100644
--- a/base/reinterpretarray.jl
+++ b/base/reinterpretarray.jl
@@ -350,7 +350,7 @@ axes(a::NonReshapedReinterpretArray{T,0}) where {T} = ()
 has_offset_axes(a::ReinterpretArray) = has_offset_axes(a.parent)
 
 elsize(::Type{<:ReinterpretArray{T}}) where {T} = sizeof(T)
-unsafe_convert(::Type{Ptr{T}}, a::ReinterpretArray{T,N,S} where N) where {T,S} = Ptr{T}(unsafe_convert(Ptr{S},a.parent))
+cconvert(::Type{Ptr{T}}, a::ReinterpretArray{T,N,S} where N) where {T,S} = cconvert(Ptr{S}, a.parent)
 
 @inline @propagate_inbounds function getindex(a::NonReshapedReinterpretArray{T,0,S}) where {T,S}
     if isprimitivetype(T) && isprimitivetype(S)
diff --git a/base/reshapedarray.jl b/base/reshapedarray.jl
index bcb47a9359392..f65fa7c63cceb 100644
--- a/base/reshapedarray.jl
+++ b/base/reshapedarray.jl
@@ -293,7 +293,7 @@ setindex!(A::ReshapedRange, val, index::ReshapedIndex) = _rs_setindex!_err()
 
 @noinline _rs_setindex!_err() = error("indexed assignment fails for a reshaped range; consider calling collect")
 
-unsafe_convert(::Type{Ptr{T}}, a::ReshapedArray{T}) where {T} = unsafe_convert(Ptr{T}, parent(a))
+cconvert(::Type{Ptr{T}}, a::ReshapedArray{T}) where {T} = cconvert(Ptr{T}, parent(a))
 
 # Add a few handy specializations to further speed up views of reshaped ranges
 const ReshapedUnitRange{T,N,A<:AbstractUnitRange} = ReshapedArray{T,N,A,Tuple{}}
@@ -304,9 +304,13 @@ compute_offset1(parent::AbstractVector, stride1::Integer, I::Tuple{ReshapedRange
     (@inline; first(I[1]) - first(axes1(I[1]))*stride1)
 substrides(strds::NTuple{N,Int}, I::Tuple{ReshapedUnitRange, Vararg{Any}}) where N =
     (size_to_strides(strds[1], size(I[1])...)..., substrides(tail(strds), tail(I))...)
-unsafe_convert(::Type{Ptr{T}}, V::SubArray{T,N,P,<:Tuple{Vararg{Union{RangeIndex,ReshapedUnitRange}}}}) where {T,N,P} =
-    unsafe_convert(Ptr{T}, V.parent) + (first_index(V)-1)*sizeof(T)
 
+# cconvert(::Type{<:Ptr}, V::SubArray{T,N,P,<:Tuple{Vararg{Union{RangeIndex,ReshapedUnitRange}}}}) where {T,N,P} = V
+function unsafe_convert(::Type{Ptr{S}}, V::SubArray{T,N,P,<:Tuple{Vararg{Union{RangeIndex,ReshapedUnitRange}}}}) where {S,T,N,P}
+    parent = V.parent
+    p = cconvert(Ptr{T}, parent) # XXX: this should occur in cconvert, the result is not GC-rooted
+    return Ptr{S}(unsafe_convert(Ptr{T}, p) + (first_index(V)-1)*sizeof(T))
+end
 
 _checkcontiguous(::Type{Bool}, A::AbstractArray) = false
 # `strides(A::DenseArray)` calls `size_to_strides` by default.
diff --git a/base/secretbuffer.jl b/base/secretbuffer.jl
index eedfd8cbe84c1..cc3f0b234688f 100644
--- a/base/secretbuffer.jl
+++ b/base/secretbuffer.jl
@@ -140,8 +140,7 @@ function write(io::IO, s::SecretBuffer)
     return nb
 end
 
-cconvert(::Type{Cstring}, s::SecretBuffer) = unsafe_convert(Cstring, s)
-function unsafe_convert(::Type{Cstring}, s::SecretBuffer)
+function cconvert(::Type{Cstring}, s::SecretBuffer)
     # Ensure that no nuls appear in the valid region
     if any(==(0x00), s.data[i] for i in 1:s.size)
         throw(ArgumentError("`SecretBuffers` containing nul bytes cannot be converted to C strings"))
@@ -152,8 +151,10 @@ function unsafe_convert(::Type{Cstring}, s::SecretBuffer)
     write(s, '\0')
     s.ptr = p
     s.size -= 1
-    return Cstring(unsafe_convert(Ptr{Cchar}, s.data))
+    return s.data
 end
+# optional shim for manual calls to unsafe_convert:
+#   unsafe_convert(::Type{Cstring}, s::SecretBuffer) = unsafe_convert(Cstring, cconvert(Cstring, s))
 
 seek(io::SecretBuffer, n::Integer) = (io.ptr = max(min(n+1, io.size+1), 1); io)
 seekend(io::SecretBuffer) = seek(io, io.size+1)
diff --git a/base/strings/basic.jl b/base/strings/basic.jl
index 330cff1cf8f00..5fc5dea24da8d 100644
--- a/base/strings/basic.jl
+++ b/base/strings/basic.jl
@@ -800,8 +800,8 @@ IndexStyle(::Type{<:CodeUnits}) = IndexLinear()
 
 write(io::IO, s::CodeUnits) = write(io, s.s)
 
-unsafe_convert(::Type{Ptr{T}},    s::CodeUnits{T}) where {T} = unsafe_convert(Ptr{T}, s.s)
-unsafe_convert(::Type{Ptr{Int8}}, s::CodeUnits{UInt8}) = unsafe_convert(Ptr{Int8}, s.s)
+cconvert(::Type{Ptr{T}},    s::CodeUnits{T}) where {T} = cconvert(Ptr{T}, s.s)
+cconvert(::Type{Ptr{Int8}}, s::CodeUnits{UInt8}) = cconvert(Ptr{Int8}, s.s)
 
 """
     codeunits(s::AbstractString)
diff --git a/base/subarray.jl b/base/subarray.jl
index 57014d5c86856..aa4d0c7c04645 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -466,8 +466,11 @@ find_extended_inds(::ScalarIndex, I...) = (@inline; find_extended_inds(I...))
 find_extended_inds(i1, I...) = (@inline; (i1, find_extended_inds(I...)...))
 find_extended_inds() = ()
 
-function unsafe_convert(::Type{Ptr{T}}, V::SubArray{T,N,P,<:Tuple{Vararg{RangeIndex}}}) where {T,N,P}
-    return unsafe_convert(Ptr{T}, V.parent) + _memory_offset(V.parent, map(first, V.indices)...)
+# cconvert(::Type{<:Ptr}, V::SubArray{T,N,P,<:Tuple{Vararg{RangeIndex}}}) where {T,N,P} = V
+function unsafe_convert(::Type{Ptr{S}}, V::SubArray{T,N,P,<:Tuple{Vararg{RangeIndex}}}) where {S,T,N,P}
+    parent = V.parent
+    p = cconvert(Ptr{T}, parent) # XXX: this should occur in cconvert, the result is not GC-rooted
+    return Ptr{S}(unsafe_convert(Ptr{T}, p) + _memory_offset(parent, map(first, V.indices)...))
 end
 
 pointer(V::FastSubArray, i::Int) = pointer(V.parent, V.offset1 + V.stride1*i)
diff --git a/stdlib/InteractiveUtils/src/clipboard.jl b/stdlib/InteractiveUtils/src/clipboard.jl
index c2abda9a60cc3..6bcd61584a2b8 100644
--- a/stdlib/InteractiveUtils/src/clipboard.jl
+++ b/stdlib/InteractiveUtils/src/clipboard.jl
@@ -100,7 +100,7 @@ elseif Sys.iswindows()
         pdata == C_NULL && return cleanup(:GlobalAlloc)
         plock = ccall((:GlobalLock, "kernel32"), stdcall, Ptr{UInt16}, (Ptr{UInt16},), pdata)
         plock == C_NULL && return cleanup(:GlobalLock)
-        GC.@preserve x_u16 memcpy(plock, Base.unsafe_convert(Ptr{UInt16}, x_u16), sizeof(x_u16))
+        GC.@preserve x_u16 memcpy(plock, Base.unsafe_convert(Ptr{UInt16}, Base.cconvert(Ptr{UInt16}, x_u16)), sizeof(x_u16))
         unlock = ccall((:GlobalUnlock, "kernel32"), stdcall, Cint, (Ptr{UInt16},), pdata)
         (unlock == 0 && Libc.GetLastError() == 0) || return cleanup(:GlobalUnlock) # this should never fail
         pset = ccall((:SetClipboardData, "user32"), stdcall, Ptr{UInt16}, (Cuint, Ptr{UInt16}), 13, pdata) # CF_UNICODETEXT
diff --git a/stdlib/LinearAlgebra/src/adjtrans.jl b/stdlib/LinearAlgebra/src/adjtrans.jl
index b3a06f8e7414b..c8b02f7a10a76 100644
--- a/stdlib/LinearAlgebra/src/adjtrans.jl
+++ b/stdlib/LinearAlgebra/src/adjtrans.jl
@@ -344,8 +344,8 @@ Base.strides(A::Transpose{<:Any, <:AbstractVector}) = (stride(A.parent, 2), stri
 Base.strides(A::Adjoint{<:Real, <:AbstractMatrix}) = reverse(strides(A.parent))
 Base.strides(A::Transpose{<:Any, <:AbstractMatrix}) = reverse(strides(A.parent))
 
-Base.unsafe_convert(::Type{Ptr{T}}, A::Adjoint{<:Real, <:AbstractVecOrMat}) where {T} = Base.unsafe_convert(Ptr{T}, A.parent)
-Base.unsafe_convert(::Type{Ptr{T}}, A::Transpose{<:Any, <:AbstractVecOrMat}) where {T} = Base.unsafe_convert(Ptr{T}, A.parent)
+Base.cconvert(::Type{Ptr{T}}, A::Adjoint{<:Real, <:AbstractVecOrMat}) where {T} = Base.cconvert(Ptr{T}, A.parent)
+Base.cconvert(::Type{Ptr{T}}, A::Transpose{<:Any, <:AbstractVecOrMat}) where {T} = Base.cconvert(Ptr{T}, A.parent)
 
 Base.elsize(::Type{<:Adjoint{<:Real, P}}) where {P<:AbstractVecOrMat} = Base.elsize(P)
 Base.elsize(::Type{<:Transpose{<:Any, P}}) where {P<:AbstractVecOrMat} = Base.elsize(P)
diff --git a/stdlib/LinearAlgebra/test/blas.jl b/stdlib/LinearAlgebra/test/blas.jl
index 4252d9ee7938b..4d6b6ccc3b647 100644
--- a/stdlib/LinearAlgebra/test/blas.jl
+++ b/stdlib/LinearAlgebra/test/blas.jl
@@ -532,7 +532,7 @@ Base.getindex(A::WrappedArray, i::Int) = A.A[i]
 Base.getindex(A::WrappedArray{T, N}, I::Vararg{Int, N}) where {T, N} = A.A[I...]
 Base.setindex!(A::WrappedArray, v, i::Int) = setindex!(A.A, v, i)
 Base.setindex!(A::WrappedArray{T, N}, v, I::Vararg{Int, N}) where {T, N} = setindex!(A.A, v, I...)
-Base.unsafe_convert(::Type{Ptr{T}}, A::WrappedArray{T}) where T = Base.unsafe_convert(Ptr{T}, A.A)
+Base.cconvert(::Type{Ptr{T}}, A::WrappedArray{T}) where T = Base.cconvert(Ptr{T}, A.A)
 
 Base.strides(A::WrappedArray) = strides(A.A)
 Base.elsize(::Type{WrappedArray{T,N}}) where {T,N} = Base.elsize(Array{T,N})
diff --git a/stdlib/Random/src/DSFMT.jl b/stdlib/Random/src/DSFMT.jl
index e63b0b502f84e..25155b4e8575d 100644
--- a/stdlib/Random/src/DSFMT.jl
+++ b/stdlib/Random/src/DSFMT.jl
@@ -195,9 +195,11 @@ function dsfmt_jump(s::DSFMT_state, jp::GF2X)
     work = zeros(Int32, JN32)
     rwork = reinterpret(UInt64, work)
     dsfmt = Vector{UInt64}(undef, nval >> 1)
-    GC.@preserve dsfmt val begin
-        pdsfmt = Base.unsafe_convert(Ptr{Cvoid}, dsfmt)
-        pval = Base.unsafe_convert(Ptr{Cvoid}, val)
+    dsfmtref = Base.cconvert(Ptr{Cvoid}, dsfmt)
+    valref = Base.cconvert(Ptr{Cvoid}, val)
+    GC.@preserve dsfmtref valref begin
+        pdsfmt = Base.unsafe_convert(Ptr{Cvoid}, dsfmtref)
+        pval = Base.unsafe_convert(Ptr{Cvoid}, valref)
         Base.Libc.memcpy(pdsfmt, pval, (nval - 1) * sizeof(Int32))
     end
     dsfmt[end] = UInt64(N*2)
diff --git a/stdlib/SharedArrays/src/SharedArrays.jl b/stdlib/SharedArrays/src/SharedArrays.jl
index f9f701c61fcea..93ce396277af7 100644
--- a/stdlib/SharedArrays/src/SharedArrays.jl
+++ b/stdlib/SharedArrays/src/SharedArrays.jl
@@ -8,7 +8,7 @@ module SharedArrays
 using Mmap, Distributed, Random
 
 import Base: length, size, elsize, ndims, IndexStyle, reshape, convert, deepcopy_internal,
-             show, getindex, setindex!, fill!, similar, reduce, map!, copyto!, unsafe_convert
+             show, getindex, setindex!, fill!, similar, reduce, map!, copyto!, cconvert
 import Random
 using Serialization
 using Serialization: serialize_cycle_header, serialize_type, writetag, UNDEFREF_TAG, serialize, deserialize
@@ -358,8 +358,8 @@ for each worker process.
 """
 localindices(S::SharedArray) = S.pidx > 0 ? range_1dim(S, S.pidx) : 1:0
 
-unsafe_convert(::Type{Ptr{T}}, S::SharedArray{T}) where {T} = unsafe_convert(Ptr{T}, sdata(S))
-unsafe_convert(::Type{Ptr{T}}, S::SharedArray   ) where {T} = unsafe_convert(Ptr{T}, sdata(S))
+cconvert(::Type{Ptr{T}}, S::SharedArray{T}) where {T} = cconvert(Ptr{T}, sdata(S))
+cconvert(::Type{Ptr{T}}, S::SharedArray   ) where {T} = cconvert(Ptr{T}, sdata(S))
 
 function SharedArray(A::Array)
     S = SharedArray{eltype(A),ndims(A)}(size(A))
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 90a529a6d98c3..bf8484c398166 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -115,7 +115,10 @@ end
         @test convert(Array{Int,1}, r) == [2,3,4]
         @test_throws MethodError convert(Array{Int,2}, r)
         @test convert(Array{Int}, r) == [2,3,4]
-        @test Base.unsafe_convert(Ptr{Int}, r) == Base.unsafe_convert(Ptr{Int}, s)
+        let rc = Base.cconvert(Ptr{Int}, r), rs = Base.cconvert(Ptr{Int}, s)
+            @test rc == rs
+            @test Base.unsafe_convert(Ptr{Int}, rc) == Base.unsafe_convert(Ptr{Int}, rs)
+        end
         @test isa(r, StridedArray)  # issue #22411
     end
     @testset "linearslow" begin
@@ -131,6 +134,7 @@ end
         @test convert(Array{Int,1}, r) == [2,3,5]
         @test_throws MethodError convert(Array{Int,2}, r)
         @test convert(Array{Int}, r) == [2,3,5]
+        # @test_throws ErrorException Base.cconvert(Ptr{Int}, r) broken=true
         @test_throws ErrorException Base.unsafe_convert(Ptr{Int}, r)
         r[2] = -1
         @test a[3] == -1
diff --git a/test/strings/basic.jl b/test/strings/basic.jl
index 13f2f5197187a..225a41bf12be9 100644
--- a/test/strings/basic.jl
+++ b/test/strings/basic.jl
@@ -1164,7 +1164,7 @@ end
     code_units = Base.CodeUnits("abc")
     @test Base.IndexStyle(Base.CodeUnits) == IndexLinear()
     @test Base.elsize(code_units) == sizeof(UInt8)
-    @test Base.unsafe_convert(Ptr{Int8}, code_units) == Base.unsafe_convert(Ptr{Int8}, code_units.s)
+    @test Base.unsafe_convert(Ptr{Int8}, Base.cconvert(Ptr{UInt8}, code_units)) == Base.unsafe_convert(Ptr{Int8}, Base.cconvert(Ptr{Int8}, code_units.s))
 end
 
 @testset "LazyString" begin
diff --git a/test/testhelpers/OffsetArrays.jl b/test/testhelpers/OffsetArrays.jl
index 2402a46c3494e..f8da243da6b63 100644
--- a/test/testhelpers/OffsetArrays.jl
+++ b/test/testhelpers/OffsetArrays.jl
@@ -642,7 +642,7 @@ Base.copy(A::OffsetArray) = parent_call(copy, A)
 
 Base.strides(A::OffsetArray) = strides(parent(A))
 Base.elsize(::Type{OffsetArray{T,N,A}}) where {T,N,A} = Base.elsize(A)
-@inline Base.unsafe_convert(::Type{Ptr{T}}, A::OffsetArray{T}) where {T} = Base.unsafe_convert(Ptr{T}, parent(A))
+Base.cconvert(::Type{Ptr{T}}, A::OffsetArray{T}) where {T} = Base.cconvert(Ptr{T}, parent(A))
 
 # For fast broadcasting: ref https://discourse.julialang.org/t/why-is-there-a-performance-hit-on-broadcasting-with-offsetarrays/32194
 Base.dataids(A::OffsetArray) = Base.dataids(parent(A))

From f0a28e9a45a34f1c524b3cf02cbbac1351f1da81 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 24 Oct 2023 16:07:08 -0500
Subject: [PATCH 0075/1315] add unsetindex support to more copyto methods
 (#51760)

This is not-quite-public API, but since we have this for Array-to-Array
copies, this tries to ensure it also does generically the same behavior
for Memory-to-Array and Array-to-Memory as well.
---
 base/abstractarray.jl | 41 +++++++++++++++++++++++++++++++----------
 1 file changed, 31 insertions(+), 10 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 4f8b74abf2486..4956439123505 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1080,13 +1080,22 @@ function copyto_unaliased!(deststyle::IndexStyle, dest::AbstractArray, srcstyle:
         if srcstyle isa IndexLinear
             # Single-index implementation
             @inbounds for i in srcinds
-                dest[i + Δi] = src[i]
+                if isassigned(src, i)
+                    dest[i + Δi] = src[i]
+                else
+                    _unsetindex!(dest, i + Δi)
+                end
             end
         else
             # Dual-index implementation
             i = idf - 1
-            @inbounds for a in src
-                dest[i+=1] = a
+            @inbounds for a in eachindex(src)
+                i += 1
+                if isassigned(src, a)
+                    dest[i] = src[a]
+                else
+                    _unsetindex!(dest, i)
+                end
             end
         end
     else
@@ -1094,14 +1103,22 @@ function copyto_unaliased!(deststyle::IndexStyle, dest::AbstractArray, srcstyle:
         if iterdest == itersrc
             # Shared-iterator implementation
             for I in iterdest
-                @inbounds dest[I] = src[I]
+                if isassigned(src, I)
+                    @inbounds dest[I] = src[I]
+                else
+                    _unsetindex!(dest, I)
+                end
             end
         else
             # Dual-iterator implementation
             ret = iterate(iterdest)
-            @inbounds for a in src
+            @inbounds for a in itersrc
                 idx, state = ret::NTuple{2,Any}
-                dest[idx] = a
+                if isassigned(src, a)
+                    dest[idx] = src[a]
+                else
+                    _unsetindex!(dest, idx)
+                end
                 ret = iterate(iterdest, state)
             end
         end
@@ -1120,8 +1137,8 @@ function copyto!(dest::AbstractArray, dstart::Integer, src::AbstractArray, sstar
 end
 
 function copyto!(dest::AbstractArray, dstart::Integer,
-               src::AbstractArray, sstart::Integer,
-               n::Integer)
+                 src::AbstractArray, sstart::Integer,
+                 n::Integer)
     n == 0 && return dest
     n < 0 && throw(ArgumentError(LazyString("tried to copy n=",
         n," elements, but n should be non-negative")))
@@ -1130,7 +1147,11 @@ function copyto!(dest::AbstractArray, dstart::Integer,
     (checkbounds(Bool, srcinds, sstart)  && checkbounds(Bool, srcinds, sstart+n-1))  || throw(BoundsError(src,  sstart:sstart+n-1))
     src′ = unalias(dest, src)
     @inbounds for i = 0:n-1
-        dest[dstart+i] = src′[sstart+i]
+        if isassigned(src′, sstart+i)
+            dest[dstart+i] = src′[sstart+i]
+        else
+            _unsetindex!(dest, dstart+i)
+        end
     end
     return dest
 end
@@ -1141,7 +1162,7 @@ function copy(a::AbstractArray)
 end
 
 function copyto!(B::AbstractVecOrMat{R}, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
-               A::AbstractVecOrMat{S}, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) where {R,S}
+                 A::AbstractVecOrMat{S}, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) where {R,S}
     if length(ir_dest) != length(ir_src)
         throw(ArgumentError(LazyString("source and destination must have same size (got ",
             length(ir_src)," and ",length(ir_dest),")")))

From a43fcbc82850624fc169762f18585d1ad69e39c9 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 25 Oct 2023 09:10:52 +0900
Subject: [PATCH 0076/1315] post-opt: run full scan within
 `check_inconsistency!` (#51846)

Otherwise we fail to scan all statements.

fix #51837
---
 base/compiler/optimize.jl |  4 ++--
 test/compiler/effects.jl  | 12 ++++++++++++
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index a1ff740b5b83d..342711555b416 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -656,7 +656,6 @@ end
 
 function ((; sv)::ScanStmt)(inst::Instruction, idx::Int, lstmt::Int, bb::Int)
     stmt = inst[:stmt]
-    flag = inst[:flag]
 
     if isexpr(stmt, :enter)
         # try/catch not yet modeled
@@ -707,9 +706,10 @@ function ((; sv)::ScanStmt)(inst::Instruction, idx::Int, lstmt::Int, bb::Int)
 end
 
 function check_inconsistentcy!(sv::PostOptAnalysisState, scanner::BBScanner)
-    scan!(ScanStmt(sv), scanner, true)
+    scan!(ScanStmt(sv), scanner, false)
     complete!(sv.tpdum); push!(scanner.bb_ip, 1)
     populate_def_use_map!(sv.tpdum, scanner)
+
     (; ir, inconsistent, tpdum) = sv
     stmt_ip = BitSetBoundedMinPrioritySet(length(ir.stmts))
     for def in sv.inconsistent
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 6200e40f7510d..98451f696d8ba 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1130,3 +1130,15 @@ let effects = Base.infer_effects(x -> `a $x`, (Any,))
     @test !Core.Compiler.is_noub(effects)
     @test !Core.Compiler.is_consistent(effects)
 end
+
+function issue51837(; openquotechar::Char, newlinechar::Char)
+    ncodeunits(openquotechar) == 1 || throw(ArgumentError("`openquotechar` must be a single-byte character"))
+    if !isnothing(newlinechar)
+        ncodeunits(newlinechar) > 1 && throw(ArgumentError("`newlinechar` must be a single-byte character."))
+    end
+    return nothing
+end
+@test Base.infer_effects() do openquotechar::Char, newlinechar::Char
+    issue51837(; openquotechar, newlinechar)
+end |> !Core.Compiler.is_nothrow
+@test_throws ArgumentError issue51837(; openquotechar='α', newlinechar='\n')

From 3c21e32f625ac7284d116509993f65af871ee5be Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 25 Oct 2023 00:52:01 -0500
Subject: [PATCH 0077/1315] inference: fix infinite recursion of nested
 Generators (#51845)

It seems this case has already been fixed by other improvements, so we
no longer need this hack, which is now causing problems.

Fixes #51694
---
 base/compiler/typelimits.jl | 13 -------------
 base/compiler/utilities.jl  |  2 --
 test/compiler/inference.jl  | 10 ++++++++++
 3 files changed, 10 insertions(+), 15 deletions(-)

diff --git a/base/compiler/typelimits.jl b/base/compiler/typelimits.jl
index 406a5494d2f20..55502bfb75d2b 100644
--- a/base/compiler/typelimits.jl
+++ b/base/compiler/typelimits.jl
@@ -295,22 +295,9 @@ function type_more_complex(@nospecialize(t), @nospecialize(c), sources::SimpleVe
             else
                 tupledepth = 0
             end
-            isgenerator = (t.name.name === :Generator && t.name.module === _topmod(t.name.module))
             for i = 1:length(tP)
                 tPi = tP[i]
                 cPi = cP[i + ntail]
-                if isgenerator
-                    let tPi = unwrap_unionall(tPi),
-                        cPi = unwrap_unionall(cPi)
-                        if isa(tPi, DataType) && isa(cPi, DataType) &&
-                            !isabstracttype(tPi) && !isabstracttype(cPi) &&
-                                sym_isless(cPi.name.name, tPi.name.name)
-                            # allow collect on (anonymous) Generators to nest, provided that their functions are appropriately ordered
-                            # TODO: is there a better way?
-                            continue
-                        end
-                    end
-                end
                 type_more_complex(tPi, cPi, sources, depth + 1, tupledepth, 0) && return true
             end
             return false
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index bce430b055bed..d27e1bd00ce56 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -66,8 +66,6 @@ end
 is_meta_expr_head(head::Symbol) = head === :boundscheck || head === :meta || head === :loopinfo
 is_meta_expr(@nospecialize x) = isa(x, Expr) && is_meta_expr_head(x.head)
 
-sym_isless(a::Symbol, b::Symbol) = ccall(:strcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}), a, b) < 0
-
 function is_self_quoting(@nospecialize(x))
     return isa(x,Number) || isa(x,AbstractString) || isa(x,Tuple) || isa(x,Type) ||
         isa(x,Char) || x === nothing || isa(x,Function)
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 8ed034b391b5e..a2e1276b7348a 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -98,6 +98,16 @@ end
 @test !Core.Compiler.type_more_complex(Tuple{Vararg{Tuple{}}}, Tuple{Vararg{Tuple}}, Core.svec(), 0, 0, 0)
 @test  Core.Compiler.type_more_complex(Tuple{Vararg{Tuple}}, Tuple{Vararg{Tuple{}}}, Core.svec(), 0, 0, 0)
 
+# issue #51694
+@test Core.Compiler.type_more_complex(
+       Base.Generator{Base.Iterators.Flatten{Array{Bool, 1}}, typeof(identity)},
+       Base.Generator{Array{Bool, 1}, typeof(identity)},
+       Core.svec(), 0, 0, 0)
+@test Core.Compiler.type_more_complex(
+       Base.Generator{Base.Iterators.Flatten{Base.Generator{Array{Bool, 1}, typeof(identity)}}, typeof(identity)},
+       Base.Generator{Array{Bool, 1}, typeof(identity)},
+       Core.svec(), 0, 0, 0)
+
 let # 40336
     t = Type{Type{Type{Int}}}
     c = Type{Type{Int}}

From 3b1ba62bd27e0dabbd2ec0a6c000edb8138c5915 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 25 Oct 2023 15:45:45 +0900
Subject: [PATCH 0078/1315] [REPLCompletions] allow symbol completions within
 incomplete macrocall expression (#51834)

fix #51827

---------

Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
---
 stdlib/REPL/src/REPLCompletions.jl  |  5 +++++
 stdlib/REPL/test/replcompletions.jl | 12 ++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 6eb12c71dcb07..290a26ea4f6f3 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -1053,6 +1053,11 @@ function complete_identifiers!(suggestions::Vector{Completion}, @nospecialize(ff
             if isinfix
                 ex = ex.args[end]
             end
+        elseif isexpr(ex, :macrocall) && length(ex.args) > 1
+            # allow symbol completions within potentially incomplete macrocalls
+            if s[end] ≠ '`' && s[end] ≠ ')'
+                ex = ex.args[end]
+            end
         end
     end
     append!(suggestions, complete_symbol(ex, name, ffunc, context_module))
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 28b3ef5de2ed7..9f174f4be51ac 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2085,6 +2085,18 @@ for (s, compl) in (("2*CompletionFoo.nam", "named"),
     @test only(c) == compl
 end
 
+# allows symbol completion within incomplete :macrocall
+# https://github.com/JuliaLang/julia/issues/51827
+macro issue51827(args...)
+    length(args) ≥ 2 || error("@issue51827: incomplete arguments")
+    return args
+end
+let s = "@issue51827 Base.ac"
+    c, r, res = test_complete_context(s)
+    @test res
+    @test "acquire" in c
+end
+
 let t = REPLCompletions.repl_eval_ex(:(`a b`), @__MODULE__; limit_aggressive_inference=true)
     @test t isa Core.Const
     @test t.val == `a b`

From bb138fa8d89b1636254098b81f53b51b2cd58128 Mon Sep 17 00:00:00 2001
From: John Lapeyre <jlapeyre@users.noreply.github.com>
Date: Wed, 25 Oct 2023 03:08:58 -0400
Subject: [PATCH 0079/1315] Improve efficiency of minimum/maximum(::Diagonal)
 (#30236)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

```
julia> DM = Diagonal(rand(100));

julia> @btime minimum($DM);    # before
  27.987 μs (0 allocations: 0 bytes)

julia> @btime minimum($DM);    # after
  246.091 ns (0 allocations: 0 bytes)
```
---
 stdlib/LinearAlgebra/src/diagonal.jl  | 12 ++++++++++++
 stdlib/LinearAlgebra/test/diagonal.jl |  6 ++++++
 2 files changed, 18 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index c58f2f8d3b665..ebc0d1cd0e59b 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -161,6 +161,18 @@ end
     r
 end
 
+function Base.minimum(D::Diagonal{T}) where T <: Number
+    mindiag = minimum(D.diag)
+    size(D, 1) > 1 && return (min(zero(T), mindiag))
+    return mindiag
+end
+
+function Base.maximum(D::Diagonal{T}) where T <: Number
+    maxdiag = Base.maximum(D.diag)
+    size(D, 1) > 1 && return (max(zero(T), maxdiag))
+    return maxdiag
+end
+
 @inline function getindex(D::Diagonal, i::Int, j::Int)
     @boundscheck checkbounds(D, i, j)
     if i == j
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 1b1aa37af2d31..caefc7889a8d6 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -108,6 +108,12 @@ Random.seed!(1)
         for func in (det, tr)
             @test func(D) ≈ func(DM) atol=n^2*eps(relty)*(1+(elty<:Complex))
         end
+
+        if eltype(D) <: Real
+            @test minimum(D) ≈ minimum(DM)
+            @test maximum(D) ≈ maximum(DM)
+        end
+
         if relty <: BlasFloat
             for func in (exp, cis, sinh, cosh, tanh, sech, csch, coth)
                 @test func(D) ≈ func(DM) atol=n^3*eps(relty)

From a1ccf53e8bbe7678037a76c8c822e0059c60d9fa Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Wed, 25 Oct 2023 10:53:24 +0200
Subject: [PATCH 0080/1315] Add BFloat16 runtime intrinsics. (#51790)

After switching to LLVM for BFloat16 in #51470 (i.e., relying on
`Intrinsics.sub_float` etc instead of hand-rolling bit-twiddling
implementations), we also need to provide fallback runtime
implementations for these intrinsics. This is too bad; I had hoped to
put as much BFloat16-related things as possible in BFloat16s.jl.

This required modifying the unary operator preprocessor macros in order
to differentiate between Float16 and BFloat16; I didn't generalize that to
all intrinsics as the code is hairy enough already (and it's currently
only useful for fptrunc/fpext).
---
 src/runtime_intrinsics.c | 133 +++++++++++++++++++++++++++++++--------
 1 file changed, 107 insertions(+), 26 deletions(-)

diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index 588c0359f70be..0c4021570ef21 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -328,6 +328,14 @@ static inline uint16_t double_to_bfloat(double param) JL_NOTSAFEPOINT
     return float_to_bfloat(temp);
 }
 
+static inline float bfloat_to_float(uint16_t param) JL_NOTSAFEPOINT
+{
+    uint32_t bits = ((uint32_t)param) << 16;
+    float result;
+    memcpy(&result, &bits, sizeof(result));
+    return result;
+}
+
 // bfloat16 conversion API
 
 // starting with GCC 13 and Clang 17, we have __bf16 on most platforms
@@ -726,25 +734,39 @@ static inline unsigned jl_##name##nbits(unsigned runtime_nbits, void *pa) JL_NOT
 // nbits::number of bits in the *input*
 // c_type::c_type corresponding to nbits
 #define un_fintrinsic_ctype(OP, name, c_type) \
-static inline void name(unsigned osize, void *pa, void *pr) JL_NOTSAFEPOINT \
+static inline void name(unsigned osize, jl_value_t *ty, void *pa, void *pr) JL_NOTSAFEPOINT \
 { \
     c_type a = *(c_type*)pa; \
-    OP((c_type*)pr, a); \
+    OP(ty, (c_type*)pr, a); \
 }
 
 #define un_fintrinsic_half(OP, name) \
-static inline void name(unsigned osize, void *pa, void *pr) JL_NOTSAFEPOINT \
+static inline void name(unsigned osize, jl_value_t *ty, void *pa, void *pr) JL_NOTSAFEPOINT \
 { \
     uint16_t a = *(uint16_t*)pa; \
     float A = half_to_float(a); \
     if (osize == 16) { \
         float R; \
-        OP(&R, A); \
+        OP(ty, &R, A); \
         *(uint16_t*)pr = float_to_half(R); \
     } else { \
-        OP((uint16_t*)pr, A); \
+        OP(ty, (uint16_t*)pr, A); \
     } \
-    }
+}
+
+#define un_fintrinsic_bfloat(OP, name) \
+static inline void name(unsigned osize, jl_value_t *ty, void *pa, void *pr) JL_NOTSAFEPOINT \
+{ \
+    uint16_t a = *(uint16_t*)pa; \
+    float A = bfloat_to_float(a); \
+    if (osize == 16) { \
+        float R; \
+        OP(ty, &R, A); \
+        *(uint16_t*)pr = float_to_bfloat(R); \
+    } else { \
+        OP(ty, (uint16_t*)pr, A); \
+    } \
+}
 
 // float or integer inputs
 // OP::Function macro(inputa, inputb)
@@ -769,6 +791,19 @@ static void jl_##name##16(unsigned runtime_nbits, void *pa, void *pb, void *pr)
     runtime_nbits = 16; \
     float R = OP(A, B); \
     *(uint16_t*)pr = float_to_half(R); \
+    *(uint16_t*)pr = float_to_half(R); \
+}
+
+#define bi_intrinsic_bfloat(OP, name) \
+static void jl_##name##bf16(unsigned runtime_nbits, void *pa, void *pb, void *pr) JL_NOTSAFEPOINT \
+{ \
+    uint16_t a = *(uint16_t*)pa; \
+    uint16_t b = *(uint16_t*)pb; \
+    float A = bfloat_to_float(a); \
+    float B = bfloat_to_float(b); \
+    runtime_nbits = 16; \
+    float R = OP(A, B); \
+    *(uint16_t*)pr = float_to_bfloat(R); \
 }
 
 // float or integer inputs, bool output
@@ -795,6 +830,17 @@ static int jl_##name##16(unsigned runtime_nbits, void *pa, void *pb) JL_NOTSAFEP
     return OP(A, B); \
 }
 
+#define bool_intrinsic_bfloat(OP, name) \
+static int jl_##name##bf16(unsigned runtime_nbits, void *pa, void *pb) JL_NOTSAFEPOINT \
+{ \
+    uint16_t a = *(uint16_t*)pa; \
+    uint16_t b = *(uint16_t*)pb; \
+    float A = bfloat_to_float(a); \
+    float B = bfloat_to_float(b); \
+    runtime_nbits = 16; \
+    return OP(A, B); \
+}
+
 
 // integer inputs, with precondition test
 // OP::Function macro(inputa, inputb)
@@ -836,6 +882,21 @@ static void jl_##name##16(unsigned runtime_nbits, void *pa, void *pb, void *pc,
     runtime_nbits = 16; \
     float R = OP(A, B, C); \
     *(uint16_t*)pr = float_to_half(R); \
+    *(uint16_t*)pr = float_to_half(R); \
+}
+
+#define ter_intrinsic_bfloat(OP, name) \
+static void jl_##name##bf16(unsigned runtime_nbits, void *pa, void *pb, void *pc, void *pr) JL_NOTSAFEPOINT \
+{ \
+    uint16_t a = *(uint16_t*)pa; \
+    uint16_t b = *(uint16_t*)pb; \
+    uint16_t c = *(uint16_t*)pc; \
+    float A = bfloat_to_float(a); \
+    float B = bfloat_to_float(b); \
+    float C = bfloat_to_float(c); \
+    runtime_nbits = 16; \
+    float R = OP(A, B, C); \
+    *(uint16_t*)pr = float_to_bfloat(R); \
 }
 
 
@@ -980,12 +1041,13 @@ static inline jl_value_t *jl_intrinsic_cvt(jl_value_t *ty, jl_value_t *a, const
 // floating point
 
 #define un_fintrinsic_withtype(OP, name) \
+un_fintrinsic_bfloat(OP, jl_##name##bf16) \
 un_fintrinsic_half(OP, jl_##name##16) \
 un_fintrinsic_ctype(OP, jl_##name##32, float) \
 un_fintrinsic_ctype(OP, jl_##name##64, double) \
 JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *ty, jl_value_t *a) \
 { \
-    return jl_fintrinsic_1(ty, a, #name, jl_##name##16, jl_##name##32, jl_##name##64); \
+    return jl_fintrinsic_1(ty, a, #name, jl_##name##bf16, jl_##name##16, jl_##name##32, jl_##name##64); \
 }
 
 #define un_fintrinsic(OP, name) \
@@ -995,9 +1057,9 @@ JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a) \
     return jl_##name##_withtype(jl_typeof(a), a); \
 }
 
-typedef void (fintrinsic_op1)(unsigned, void*, void*);
+typedef void (fintrinsic_op1)(unsigned, jl_value_t*, void*, void*);
 
-static inline jl_value_t *jl_fintrinsic_1(jl_value_t *ty, jl_value_t *a, const char *name, fintrinsic_op1 *halfop, fintrinsic_op1 *floatop, fintrinsic_op1 *doubleop)
+static inline jl_value_t *jl_fintrinsic_1(jl_value_t *ty, jl_value_t *a, const char *name, fintrinsic_op1 *bfloatop, fintrinsic_op1 *halfop, fintrinsic_op1 *floatop, fintrinsic_op1 *doubleop)
 {
     jl_task_t *ct = jl_current_task;
     if (!jl_is_primitivetype(jl_typeof(a)))
@@ -1011,13 +1073,16 @@ static inline jl_value_t *jl_fintrinsic_1(jl_value_t *ty, jl_value_t *a, const c
     switch (sz) {
     /* choose the right size c-type operation based on the input */
     case 2:
-        halfop(sz2 * host_char_bit, pa, pr);
+        if (jl_typeof(a) == (jl_value_t*)jl_float16_type)
+            halfop(sz2 * host_char_bit, ty, pa, pr);
+        else /*if (jl_typeof(a) == (jl_value_t*)jl_bfloat16_type)*/
+            bfloatop(sz2 * host_char_bit, ty, pa, pr);
         break;
     case 4:
-        floatop(sz2 * host_char_bit, pa, pr);
+        floatop(sz2 * host_char_bit, ty, pa, pr);
         break;
     case 8:
-        doubleop(sz2 * host_char_bit, pa, pr);
+        doubleop(sz2 * host_char_bit, ty, pa, pr);
         break;
     default:
         jl_errorf("%s: runtime floating point intrinsics are not implemented for bit sizes other than 16, 32 and 64", name);
@@ -1189,6 +1254,7 @@ static inline jl_value_t *jl_intrinsiclambda_checkeddiv(jl_value_t *ty, void *pa
 // floating point
 
 #define bi_fintrinsic(OP, name) \
+    bi_intrinsic_bfloat(OP, name) \
     bi_intrinsic_half(OP, name) \
     bi_intrinsic_ctype(OP, name, 32, float) \
     bi_intrinsic_ctype(OP, name, 64, double) \
@@ -1206,7 +1272,10 @@ JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
     switch (sz) { \
     /* choose the right size c-type operation */ \
     case 2: \
-        jl_##name##16(16, pa, pb, pr); \
+        if ((jl_datatype_t*)ty == jl_float16_type) \
+            jl_##name##16(16, pa, pb, pr); \
+        else /*if ((jl_datatype_t*)ty == jl_bfloat16_type)*/ \
+            jl_##name##bf16(16, pa, pb, pr); \
         break; \
     case 4: \
         jl_##name##32(32, pa, pb, pr); \
@@ -1221,6 +1290,7 @@ JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
 }
 
 #define bool_fintrinsic(OP, name) \
+    bool_intrinsic_bfloat(OP, name) \
     bool_intrinsic_half(OP, name) \
     bool_intrinsic_ctype(OP, name, 32, float) \
     bool_intrinsic_ctype(OP, name, 64, double) \
@@ -1237,7 +1307,10 @@ JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
     switch (sz) { \
     /* choose the right size c-type operation */ \
     case 2: \
-        cmp = jl_##name##16(16, pa, pb); \
+        if ((jl_datatype_t*)ty == jl_float16_type) \
+            cmp = jl_##name##16(16, pa, pb); \
+        else /*if ((jl_datatype_t*)ty == jl_bfloat16_type)*/ \
+            cmp = jl_##name##bf16(16, pa, pb); \
         break; \
     case 4: \
         cmp = jl_##name##32(32, pa, pb); \
@@ -1252,6 +1325,7 @@ JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
 }
 
 #define ter_fintrinsic(OP, name) \
+    ter_intrinsic_bfloat(OP, name) \
     ter_intrinsic_half(OP, name) \
     ter_intrinsic_ctype(OP, name, 32, float) \
     ter_intrinsic_ctype(OP, name, 64, double) \
@@ -1269,7 +1343,10 @@ JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b, jl_value_t *c)
     switch (sz) { \
     /* choose the right size c-type operation */ \
     case 2: \
-        jl_##name##16(16, pa, pb, pc, pr); \
+        if ((jl_datatype_t*)ty == jl_float16_type) \
+            jl_##name##16(16, pa, pb, pc, pr); \
+        else /*if ((jl_datatype_t*)ty == jl_bfloat16_type)*/ \
+            jl_##name##bf16(16, pa, pb, pc, pr); \
         break; \
     case 4: \
         jl_##name##32(32, pa, pb, pc, pr); \
@@ -1285,7 +1362,7 @@ JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b, jl_value_t *c)
 
 // arithmetic
 #define neg(a) -a
-#define neg_float(pr, a) *pr = -a
+#define neg_float(ty, pr, a) *pr = -a
 un_iintrinsic_fast(LLVMNeg, neg, neg_int, u)
 #define add(a,b) a + b
 bi_iintrinsic_fast(LLVMAdd, add, add_int, u)
@@ -1501,18 +1578,22 @@ cvt_iintrinsic(LLVMUItoFP, uitofp)
 cvt_iintrinsic(LLVMFPtoSI, fptosi)
 cvt_iintrinsic(LLVMFPtoUI, fptoui)
 
-#define fptrunc(pr, a) \
+#define fptrunc(tr, pr, a) \
         if (!(osize < 8 * sizeof(a))) \
             jl_error("fptrunc: output bitsize must be < input bitsize"); \
-        else if (osize == 16) \
-            *(uint16_t*)pr = float_to_half(a); \
+        else if (osize == 16) { \
+            if ((jl_datatype_t*)tr == jl_float16_type) \
+                *(uint16_t*)pr = float_to_half(a); \
+            else /*if ((jl_datatype_t*)tr == jl_bfloat16_type)*/ \
+                *(uint16_t*)pr = float_to_bfloat(a); \
+        } \
         else if (osize == 32) \
             *(float*)pr = a; \
         else if (osize == 64) \
             *(double*)pr = a; \
         else \
             jl_error("fptrunc: runtime floating point intrinsics are not implemented for bit sizes other than 16, 32 and 64");
-#define fpext(pr, a) \
+#define fpext(tr, pr, a) \
         if (!(osize >= 8 * sizeof(a))) \
             jl_error("fpext: output bitsize must be >= input bitsize"); \
         if (osize == 32) \
@@ -1569,12 +1650,12 @@ checked_iintrinsic_div(LLVMRem_uov, checked_urem_int, u)
 #define flipsign(a, b) \
         (b >= 0) ? a : -a
 bi_iintrinsic_fast(jl_LLVMFlipSign, flipsign, flipsign_int,  )
-#define abs_float(pr, a)      *pr = fp_select(a, fabs)
-#define ceil_float(pr, a)     *pr = fp_select(a, ceil)
-#define floor_float(pr, a)    *pr = fp_select(a, floor)
-#define trunc_float(pr, a)    *pr = fp_select(a, trunc)
-#define rint_float(pr, a)     *pr = fp_select(a, rint)
-#define sqrt_float(pr, a)     *pr = fp_select(a, sqrt)
+#define abs_float(ty, pr, a)      *pr = fp_select(a, fabs)
+#define ceil_float(ty, pr, a)     *pr = fp_select(a, ceil)
+#define floor_float(ty, pr, a)    *pr = fp_select(a, floor)
+#define trunc_float(ty, pr, a)    *pr = fp_select(a, trunc)
+#define rint_float(ty, pr, a)     *pr = fp_select(a, rint)
+#define sqrt_float(ty, pr, a)     *pr = fp_select(a, sqrt)
 #define copysign_float(a, b)  fp_select2(a, b, copysign)
 
 un_fintrinsic(abs_float,abs_float)

From 1705fe848c83190ab9d43d92bf62680558e1f16e Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Wed, 25 Oct 2023 17:30:20 +0800
Subject: [PATCH 0081/1315] Make `read!(::IO,::StridedArray)` call
 `unsafe_read` if possible (#42593)

This PR makes `read!(s::IO,a::StridedArray)` call `unsafe_read`, if `a`
has continous memory layout.
Since most of the checks are type-based, I think this does speed up,
esspecially when `lock = true`.

BTW, the above dispatch for `read!(s::IO, a::Array{UInt8})` in L762
seems unnecessary, should we drop it?

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/io.jl       | 103 ++++++++++++++++++++++++++++++++---------------
 test/iostream.jl |  18 +++++++++
 2 files changed, 89 insertions(+), 32 deletions(-)

diff --git a/base/io.jl b/base/io.jl
index be43a954c621e..bc87f5df9be7b 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -794,38 +794,43 @@ function write(s::IO, A::AbstractArray)
         error("`write` is not supported on non-isbits arrays")
     end
     nb = 0
+    r = Ref{eltype(A)}()
     for a in A
-        nb += write(s, a)
+        r[] = a
+        nb += @noinline unsafe_write(s, r, sizeof(r)) # r must be heap-allocated
     end
     return nb
 end
 
-function write(s::IO, a::Array)
-    if isbitstype(eltype(a))
-        return GC.@preserve a unsafe_write(s, pointer(a), sizeof(a))
-    else
+function write(s::IO, A::StridedArray)
+    if !isbitstype(eltype(A))
         error("`write` is not supported on non-isbits arrays")
     end
-end
-
-function write(s::IO, a::SubArray{T,N,<:Array}) where {T,N}
-    if !isbitstype(T) || !isa(a, StridedArray)
-        return invoke(write, Tuple{IO, AbstractArray}, s, a)
+    _checkcontiguous(Bool, A) &&
+        return GC.@preserve A unsafe_write(s, pointer(A), elsize(A) * length(A))
+    sz::Dims = size(A)
+    st::Dims = strides(A)
+    msz, mst, n = merge_adjacent_dim(sz, st)
+    mst == 1 || return invoke(write, Tuple{IO, AbstractArray}, s, A)
+    n == ndims(A) &&
+        return GC.@preserve A unsafe_write(s, pointer(A), elsize(A) * length(A))
+    sz′, st′ = tail(sz), tail(st)
+    while n > 1
+        sz′ = (tail(sz′)..., 1)
+        st′ = (tail(st′)..., 0)
+        n -= 1
     end
-    elsz = elsize(a)
-    colsz = size(a,1) * elsz
-    GC.@preserve a if stride(a,1) != 1
-        for idxs in CartesianIndices(size(a))
-            unsafe_write(s, pointer(a, idxs), elsz)
-        end
-        return elsz * length(a)
-    elseif N <= 1
-        return unsafe_write(s, pointer(a, 1), colsz)
-    else
-        for colstart in CartesianIndices((1, size(a)[2:end]...))
-            unsafe_write(s, pointer(a, colstart), colsz)
+    GC.@preserve A begin
+        nb = 0
+        iter = CartesianIndices(sz′)
+        for I in iter
+            p = pointer(A)
+            for i in 1:length(sz′)
+                p += elsize(A) * st′[i] * (I[i] - 1)
+            end
+            nb += unsafe_write(s, p, elsize(A) * msz)
         end
-        return colsz * trailingsize(a,2)
+        return nb
     end
 end
 
@@ -866,20 +871,54 @@ end
 read(s::IO, ::Type{Bool}) = (read(s, UInt8) != 0)
 read(s::IO, ::Type{Ptr{T}}) where {T} = convert(Ptr{T}, read(s, UInt))
 
-function read!(s::IO, a::Array{UInt8})
-    GC.@preserve a unsafe_read(s, pointer(a), sizeof(a))
-    return a
+function read!(s::IO, A::AbstractArray{T}) where {T}
+    if isbitstype(T) && _checkcontiguous(Bool, A)
+        GC.@preserve A unsafe_read(s, pointer(A), elsize(A) * length(A))
+    else
+        if isbitstype(T)
+            r = Ref{T}()
+            for i in eachindex(A)
+                @noinline unsafe_read(s, r, sizeof(r)) # r must be heap-allocated
+                A[i] = r[]
+            end
+        else
+            for i in eachindex(A)
+                A[i] = read(s, T)
+            end
+        end
+    end
+    return A
 end
 
-function read!(s::IO, a::AbstractArray{T}) where T
-    if isbitstype(T) && (a isa Array || a isa FastContiguousSubArray{T,<:Any,<:Array{T}})
-        GC.@preserve a unsafe_read(s, pointer(a), sizeof(a))
+function read!(s::IO, A::StridedArray{T}) where {T}
+    if !isbitstype(T) || _checkcontiguous(Bool, A)
+        return invoke(read!, Tuple{IO, AbstractArray}, s, A)
+    end
+    sz::Dims = size(A)
+    st::Dims = strides(A)
+    msz, mst, n = merge_adjacent_dim(sz, st)
+    mst == 1 || return invoke(read!, Tuple{IO, AbstractArray}, s, A)
+    if n == ndims(A)
+        GC.@preserve A unsafe_read(s, pointer(A), elsize(A) * length(A))
     else
-        for i in eachindex(a)
-            a[i] = read(s, T)
+        sz′, st′ = tail(sz), tail(st)
+        while n > 1
+            sz′ = (tail(sz′)..., 1)
+            st′ = (tail(st′)..., 0)
+            n -= 1
+        end
+        GC.@preserve A begin
+            iter = CartesianIndices(sz′)
+            for I in iter
+                p = pointer(A)
+                for i in 1:length(sz′)
+                    p += elsize(A) * st′[i] * (I[i] - 1)
+                end
+                unsafe_read(s, p, elsize(A) * msz)
+            end
         end
     end
-    return a
+    return A
 end
 
 function read(io::IO, ::Type{Char})
diff --git a/test/iostream.jl b/test/iostream.jl
index bc4751fb1fca7..4ba2423f0f558 100644
--- a/test/iostream.jl
+++ b/test/iostream.jl
@@ -119,6 +119,24 @@ end
     end
 end
 
+@testset "read!/write(::IO, A::StridedArray)" begin
+    s1 = reshape(view(rand(UInt8, 16), 1:16), 2, 2, 2, 2)
+    s2 = view(s1, 1:2, 1:2, 1:2, 1:2)
+    s3 = view(s1, 1:2, 1:2, 1, 1:2)
+    mktemp() do path, io
+        b = Vector{UInt8}(undef, 17)
+        for s::StridedArray in (s3, s1, s2)
+            @test write(io, s) == length(s)
+            seek(io, 0)
+            @test readbytes!(io, b) == length(s)
+            seek(io, 0)
+            @test view(b, 1:length(s)) == vec(s)
+            @test read!(io, fill!(deepcopy(s), 0)) == s
+            seek(io, 0)
+        end
+    end
+end
+
 @test Base.open_flags(read=false, write=true, append=false) == (read=false, write=true, create=true, truncate=true, append=false)
 
 @testset "issue #30978" begin

From 34934736fa4dcb30697ac1b23d11d5ad394d6a4d Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Wed, 25 Oct 2023 13:57:16 +0200
Subject: [PATCH 0082/1315] LLVM: Activate typed pointers through the API
 instead of a global option. (#51840)

This allows other users of LLVM to use opaque pointers with their
contexts.

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 src/codegen.cpp   | 11 +++--------
 src/jitlayers.cpp |  6 ++++++
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/codegen.cpp b/src/codegen.cpp
index dbb7d5aa498dc..d6b84f6ced0ad 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -9310,17 +9310,12 @@ extern "C" void jl_init_llvm(void)
     if (clopt && clopt->getNumOccurrences() == 0)
         cl::ProvidePositionalOption(clopt, "4", 1);
 
-#if JL_LLVM_VERSION >= 150000
+    // we want the opaque-pointers to be opt-in, per LLVMContext, for this release
+    // so change the default value back to pre-14.x, without changing the NumOccurrences flag for it
     clopt = llvmopts.lookup("opaque-pointers");
     if (clopt && clopt->getNumOccurrences() == 0) {
-#ifdef JL_LLVM_OPAQUE_POINTERS
-        cl::ProvidePositionalOption(clopt, "true", 1);
-#else
-        cl::ProvidePositionalOption(clopt, "false", 1);
-#endif
+        clopt->addOccurrence(1, clopt->ArgStr, "false", true);
     }
-#endif
-
     jl_ExecutionEngine = new JuliaOJIT();
 
     bool jl_using_gdb_jitevents = false;
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 7eed240529e20..616ec05d4c362 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1629,6 +1629,12 @@ JuliaOJIT::JuliaOJIT()
     DLSymOpt(std::make_unique<DLSymOptimizer>(false)),
     ContextPool([](){
         auto ctx = std::make_unique<LLVMContext>();
+        if (!ctx->hasSetOpaquePointersValue())
+#ifndef JL_LLVM_OPAQUE_POINTERS
+            ctx->setOpaquePointers(false);
+#else
+            ctx->setOpaquePointers(true);
+#endif
         return orc::ThreadSafeContext(std::move(ctx));
     }),
 #ifdef JL_USE_JITLINK

From c54a3f2b83bfca5f79a1b482abaa9b8e7f0da9ce Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 25 Oct 2023 10:16:47 -0500
Subject: [PATCH 0083/1315] allow finalizers to take any locks and yield during
 exit (#51848)

This aligns their behavior with manual calls to `finalize(o)`, and
prepares for a future time in which these functions are always run on a
separate thread. This means that they can wait to acquire locks in this
context, which otherwise would have been denied to them.
---
 src/gc.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index b030be9848f0b..baa533011ad65 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -425,7 +425,7 @@ JL_DLLEXPORT void jl_gc_init_finalizer_rng_state(void)
     jl_rng_split(finalizer_rngState, jl_current_task->rngState);
 }
 
-static void run_finalizers(jl_task_t *ct)
+static void run_finalizers(jl_task_t *ct, int finalizers_thread)
 {
     // Racy fast path:
     // The race here should be OK since the race can only happen if
@@ -453,7 +453,7 @@ static void run_finalizers(jl_task_t *ct)
 
     // This releases the finalizers lock.
     int8_t was_in_finalizer = ct->ptls->in_finalizer;
-    ct->ptls->in_finalizer = 1;
+    ct->ptls->in_finalizer = !finalizers_thread;
     jl_gc_run_finalizers_in_list(ct, &copied_list);
     ct->ptls->in_finalizer = was_in_finalizer;
     arraylist_free(&copied_list);
@@ -467,7 +467,7 @@ JL_DLLEXPORT void jl_gc_run_pending_finalizers(jl_task_t *ct)
         ct = jl_current_task;
     jl_ptls_t ptls = ct->ptls;
     if (!ptls->in_finalizer && ptls->locks.len == 0 && ptls->finalizers_inhibited == 0) {
-        run_finalizers(ct);
+        run_finalizers(ct, 0);
     }
 }
 
@@ -560,7 +560,7 @@ void jl_gc_run_all_finalizers(jl_task_t *ct)
     JL_UNLOCK_NOGC(&finalizers_lock);
     gc_n_threads = 0;
     gc_all_tls_states = NULL;
-    run_finalizers(ct);
+    run_finalizers(ct, 1);
 }
 
 void jl_gc_add_finalizer_(jl_ptls_t ptls, void *v, void *f) JL_NOTSAFEPOINT
@@ -3588,7 +3588,7 @@ JL_DLLEXPORT void jl_gc_collect(jl_gc_collection_t collection)
     // or wait for finalizers on other threads without dead lock).
     if (!ptls->finalizers_inhibited && ptls->locks.len == 0) {
         JL_TIMING(GC, GC_Finalizers);
-        run_finalizers(ct);
+        run_finalizers(ct, 0);
     }
     JL_PROBE_GC_FINALIZER();
 

From d0c42840f6ff509421a3f0d28ebe5bd80c625cc3 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 25 Oct 2023 12:34:51 -0500
Subject: [PATCH 0084/1315] add missing wait during Timer and AsyncCondition
 close (#51847)

Can cause spurious warnings about not closing these properly and
unexpected events to appear after `close` returns.
---
 base/asyncevent.jl | 39 ++++++++++++++++++++++++++++++++-------
 test/channels.jl   |  6 +++---
 2 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/base/asyncevent.jl b/base/asyncevent.jl
index 498fb054ecd02..791c78b5a32ce 100644
--- a/base/asyncevent.jl
+++ b/base/asyncevent.jl
@@ -118,14 +118,18 @@ end
 unsafe_convert(::Type{Ptr{Cvoid}}, t::Timer) = t.handle
 unsafe_convert(::Type{Ptr{Cvoid}}, async::AsyncCondition) = async.handle
 
+# if this returns true, the object has been signaled
+# if this returns false, the object is closed
 function _trywait(t::Union{Timer, AsyncCondition})
     set = t.set
     if set
         # full barrier now for AsyncCondition
         t isa Timer || Core.Intrinsics.atomic_fence(:acquire_release)
     else
-        t.isopen || return false
-        t.handle == C_NULL && return false
+        if !isopen(t)
+            close(t) # wait for the close to complete
+            return false
+        end
         iolock_begin()
         set = t.set
         if !set
@@ -133,7 +137,7 @@ function _trywait(t::Union{Timer, AsyncCondition})
             lock(t.cond)
             try
                 set = t.set
-                if !set && t.isopen && t.handle != C_NULL
+                if !set && t.handle != C_NULL # wait for set or handle, but not the isopen flag
                     iolock_end()
                     set = wait(t.cond)
                     unlock(t.cond)
@@ -160,10 +164,28 @@ end
 isopen(t::Union{Timer, AsyncCondition}) = t.isopen && t.handle != C_NULL
 
 function close(t::Union{Timer, AsyncCondition})
+    t.handle == C_NULL && return # short-circuit path
     iolock_begin()
-    if isopen(t)
-        @atomic :monotonic t.isopen = false
-        ccall(:jl_close_uv, Cvoid, (Ptr{Cvoid},), t)
+    if t.handle != C_NULL
+        if t.isopen
+            @atomic :monotonic t.isopen = false
+            ccall(:jl_close_uv, Cvoid, (Ptr{Cvoid},), t)
+        end
+        # implement _trywait here without the auto-reset function, just waiting for the final close signal
+        preserve_handle(t)
+        lock(t.cond)
+        try
+            while t.handle != C_NULL
+                iolock_end()
+                wait(t.cond)
+                unlock(t.cond)
+                iolock_begin()
+                lock(t.cond)
+            end
+        finally
+            unlock(t.cond)
+            unpreserve_handle(t)
+        end
     end
     iolock_end()
     nothing
@@ -220,7 +242,10 @@ function uv_timercb(handle::Ptr{Cvoid})
         @atomic :monotonic t.set = true
         if ccall(:uv_timer_get_repeat, UInt64, (Ptr{Cvoid},), t) == 0
             # timer is stopped now
-            close(t)
+            if t.isopen
+                @atomic :monotonic t.isopen = false
+                ccall(:jl_close_uv, Cvoid, (Ptr{Cvoid},), t)
+            end
         end
         notify(t.cond, true)
     finally
diff --git a/test/channels.jl b/test/channels.jl
index 36fec7b842de1..82689e8d08d28 100644
--- a/test/channels.jl
+++ b/test/channels.jl
@@ -457,8 +457,8 @@ end
         Sys.iswindows() && Base.process_events() # schedule event (windows?)
         close(async) # and close
         @test !isopen(async)
-        @test tc[] == 2
-        @test tc[] == 2
+        @test tc[] == 3
+        @test tc[] == 3
         yield() # consume event & then close
         @test tc[] == 3
         sleep(0.1) # no further events
@@ -479,7 +479,7 @@ end
         close(async)
         @test !isopen(async)
         Base.process_events() # and close
-        @test tc[] == 0
+        @test tc[] == 1
         yield() # consume event & then close
         @test tc[] == 1
         sleep(0.1) # no further events

From bde62adff7dd98fefc14482da92713484a748846 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 25 Oct 2023 17:20:16 -0400
Subject: [PATCH 0085/1315] fix for invalid caching of CodeInfo from
 typeinf_ext (#51872)

When inference decided it was not necessary to cache the object, it also
skipped all of the work required to make the code valid, which
typeinf_ext depends upon. This resulted in caching invalid data, causing
effects tests to break unpredictably. This change ensures that we always
update the InferenceState with the final result (when `must_be_codeinf`
is true), so that typeinf_ext can get the correct results out of it for
internal codegen use. Previously we were disregarding that flag in some
cases.

Fixes one of the issues uncovered in #51860
---
 base/compiler/typeinfer.jl | 61 ++++++++++++++++----------------------
 src/aotcompile.cpp         |  2 +-
 src/gf.c                   | 10 +++++++
 src/jitlayers.cpp          |  3 +-
 src/jl_exported_funcs.inc  |  1 -
 src/julia_internal.h       |  2 ++
 6 files changed, 40 insertions(+), 39 deletions(-)

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index f246289b5bea0..cebf178504a68 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -218,28 +218,28 @@ function typeinf(interp::NativeInterpreter, frame::InferenceState)
 end
 typeinf(interp::AbstractInterpreter, frame::InferenceState) = _typeinf(interp, frame)
 
-function finish!(interp::AbstractInterpreter, caller::InferenceResult)
-    # If we didn't transform the src for caching, we may have to transform
-    # it anyway for users like typeinf_ext. Do that here.
-    opt = caller.src
-    if opt isa OptimizationState{typeof(interp)} # implies `may_optimize(interp) === true`
-        if opt.ir !== nothing
-            if caller.must_be_codeinf
-                caller.src = ir_to_codeinf!(opt)
-            elseif is_inlineable(opt.src)
-                # TODO: If the CFG is too big, inlining becomes more expensive and if we're going to
-                # use this IR over and over, it's worth simplifying it. Round trips through
-                # CodeInstance do this implicitly, since they recompute the CFG, so try to
-                # match that behavior here.
-                # ir = cfg_simplify!(opt.ir)
-                caller.src = opt.ir
-            else
-                # Not cached and not inlineable - drop the ir
-                caller.src = nothing
-            end
-        end
+function finish!(interp::AbstractInterpreter, caller::InferenceState)
+    result = caller.result
+    valid_worlds = result.valid_worlds
+    if last(valid_worlds) >= get_world_counter()
+        # if we aren't cached, we don't need this edge
+        # but our caller might, so let's just make it anyways
+        store_backedges(result, caller.stmt_edges[1])
+    end
+    opt = result.src
+    if opt isa OptimizationState && result.must_be_codeinf
+        result.src = opt = ir_to_codeinf!(opt)
     end
-    return caller.src
+    if opt isa CodeInfo
+        opt.min_world = first(valid_worlds)
+        opt.max_world = last(valid_worlds)
+        caller.src = opt
+    else
+        # In this case caller.src is invalid for clients (such as typeinf_ext) to use
+        # but that is what !must_be_codeinf permits
+        # This is hopefully unreachable when must_be_codeinf is true
+    end
+    return
 end
 
 function _typeinf(interp::AbstractInterpreter, frame::InferenceState)
@@ -266,17 +266,12 @@ function _typeinf(interp::AbstractInterpreter, frame::InferenceState)
         end
     end
     for caller in frames
-        (; result ) = caller
-        valid_worlds = result.valid_worlds
-        if last(valid_worlds) >= get_world_counter()
-            # if we aren't cached, we don't need this edge
-            # but our caller might, so let's just make it anyways
-            store_backedges(result, caller.stmt_edges[1])
-        end
+        finish!(caller.interp, caller)
         if caller.cached
-            cache_result!(caller.interp, result)
+            cache_result!(caller.interp, caller.result)
         end
-        finish!(caller.interp, result)
+        # n.b. We do not drop result.src here, even though that wastes memory while it is still in the local cache
+        # since the user might have requested call-site inlining of it.
     end
     empty!(frames)
     return true
@@ -367,13 +362,7 @@ end
 function transform_result_for_cache(interp::AbstractInterpreter,
     linfo::MethodInstance, valid_worlds::WorldRange, result::InferenceResult)
     inferred_result = result.src
-    if inferred_result isa OptimizationState{typeof(interp)}
-        # TODO respect must_be_codeinf setting here?
-        result.src = inferred_result = ir_to_codeinf!(inferred_result)
-    end
     if inferred_result isa CodeInfo
-        inferred_result.min_world = first(valid_worlds)
-        inferred_result.max_world = last(valid_worlds)
         inferred_result = maybe_compress_codeinfo(interp, linfo, inferred_result)
     end
     # The global cache can only handle objects that codegen understands
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 6f55319e60b7d..1a7c7e0f5b2f7 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -246,7 +246,7 @@ static void jl_ci_cache_lookup(const jl_cgparams_t &cgparams, jl_method_instance
         else {
             *src_out = jl_type_infer(mi, world, 0);
             if (*src_out) {
-                codeinst = jl_get_method_inferred(mi, (*src_out)->rettype, (*src_out)->min_world, (*src_out)->max_world);
+                codeinst = jl_get_codeinst_for_src(mi, *src_out);
                 if ((*src_out)->inferred) {
                     jl_value_t *null = nullptr;
                     jl_atomic_cmpswap_relaxed(&codeinst->inferred, &null, jl_nothing);
diff --git a/src/gf.c b/src/gf.c
index 407d9c517a55b..3caaa71924864 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -472,6 +472,16 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
     return codeinst;
 }
 
+JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
+        jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_code_info_t *src)
+{
+    // TODO: copy backedges from src to mi
+    size_t max_world = src->max_world;
+    if (max_world >= jl_atomic_load_acquire(&jl_world_counter))
+        max_world = ~(size_t)0;
+    return jl_get_method_inferred(mi, src->rettype, src->min_world, max_world);
+}
+
 JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
         jl_method_instance_t *mi, jl_value_t *rettype,
         jl_value_t *inferred_const, jl_value_t *inferred,
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 616ec05d4c362..fbc4b35310797 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -507,6 +507,7 @@ jl_code_instance_t *jl_generate_fptr_impl(jl_method_instance_t *mi JL_PROPAGATES
             // see if it is inferred, or try to infer it for ourself.
             // (but don't bother with typeinf on macros or toplevel thunks)
             src = jl_type_infer(mi, world, 0);
+            codeinst = nullptr;
         }
     }
     jl_code_instance_t *compiled = jl_method_compiled(mi, world);
@@ -515,7 +516,7 @@ jl_code_instance_t *jl_generate_fptr_impl(jl_method_instance_t *mi JL_PROPAGATES
     }
     else if (src && jl_is_code_info(src)) {
         if (!codeinst) {
-            codeinst = jl_get_method_inferred(mi, src->rettype, src->min_world, src->max_world);
+            codeinst = jl_get_codeinst_for_src(mi, src);
             if (src->inferred) {
                 jl_value_t *null = nullptr;
                 jl_atomic_cmpswap_relaxed(&codeinst->inferred, &null, jl_nothing);
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index c503eeb4407b3..4ac04d6d0fccd 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -226,7 +226,6 @@
     XX(jl_get_JIT) \
     XX(jl_get_julia_bin) \
     XX(jl_get_julia_bindir) \
-    XX(jl_get_method_inferred) \
     XX(jl_get_module_compile) \
     XX(jl_get_module_infer) \
     XX(jl_get_module_of_binding) \
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 4f326216d8daf..0e1a02b03ec28 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -635,6 +635,8 @@ JL_DLLEXPORT jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t
 JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
         jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_value_t *rettype,
         size_t min_world, size_t max_world);
+JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
+        jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_code_info_t *src);
 jl_method_instance_t *jl_get_unspecialized_from_mi(jl_method_instance_t *method JL_PROPAGATES_ROOT);
 jl_method_instance_t *jl_get_unspecialized(jl_method_t *def JL_PROPAGATES_ROOT);
 

From 193ead2af033e24890e3c52840d51e92d3b54d2f Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 25 Oct 2023 17:22:20 -0400
Subject: [PATCH 0086/1315] improve error message for invoke (#51831)

This is effectively a type-assert, but the error message sounded
confusing and internal without the context of what it got and what it
expected to get.

Refs: #51826

after:
`ERROR: TypeError: in invoke: argument type error, expected Tuple{Int64,
Vararg{Int64}}, got a value of type Tuple{DataType, Int64}`
---
 src/builtins.c | 2 +-
 test/core.jl   | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/builtins.c b/src/builtins.c
index 2defeb4b3d833..25e63b9900a12 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1402,7 +1402,7 @@ JL_CALLABLE(jl_f_invoke)
     if (!jl_is_tuple_type(jl_unwrap_unionall(args[1])))
         jl_type_error("invoke", (jl_value_t*)jl_anytuple_type_type, args[1]);
     if (!jl_tuple_isa(&args[2], nargs - 2, (jl_datatype_t*)argtypes))
-        jl_error("invoke: argument type error");
+        jl_type_error("invoke: argument type error", argtypes, jl_f_tuple(NULL, &args[2], nargs - 2));
     jl_value_t *res = jl_gf_invoke(argtypes, args[0], &args[2], nargs - 1);
     JL_GC_POP();
     return res;
diff --git a/test/core.jl b/test/core.jl
index c552678b19603..959d17b405b49 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -5188,9 +5188,9 @@ let x = 1
     @noinline g18444(a) = (x += 1; a[])
     f18444_1(a) = invoke(sin, Tuple{Int}, g18444(a))
     f18444_2(a) = invoke(sin, Tuple{Integer}, g18444(a))
-    @test_throws ErrorException("invoke: argument type error") f18444_1(Ref{Any}(1.0))
+    @test_throws "TypeError: in invoke: argument type error, expected" f18444_1(Ref{Any}(1.0))
     @test x == 2
-    @test_throws ErrorException("invoke: argument type error") f18444_2(Ref{Any}(1.0))
+    @test_throws "TypeError: in invoke: argument type error, expected" f18444_2(Ref{Any}(1.0))
     @test x == 3
     @test f18444_1(Ref{Any}(1)) === sin(1)
     @test x == 4

From 946ab7192df6e5ddf488c9f3038b4f51c43568e9 Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Wed, 25 Oct 2023 23:27:47 +0200
Subject: [PATCH 0087/1315] Assert that `exit` never returns (#51857)

Closes #51856
---
 base/initdefs.jl           | 2 +-
 test/compiler/inference.jl | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/base/initdefs.jl b/base/initdefs.jl
index c04a97971eff2..debbb45428e99 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -25,7 +25,7 @@ Stop the program with an exit code. The default exit code is zero, indicating th
 program completed successfully. In an interactive session, `exit()` can be called with
 the keyboard shortcut `^D`.
 """
-exit(n) = ccall(:jl_exit, Cvoid, (Int32,), n)
+exit(n) = ccall(:jl_exit, Union{}, (Int32,), n)
 exit() = exit(0)
 
 const roottask = current_task()
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index a2e1276b7348a..f01d11695f4d1 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5363,3 +5363,11 @@ function phic_type3()
 end
 @test Base.return_types(phic_type3) |> only === Union{Int, Float64}
 @test phic_type3() === 2
+
+# Test that `exit` returns `Union{}` (issue #51856)
+function test_exit_bottom(s)
+    n = tryparse(Int, s)
+    isnothing(n) && exit()
+    n
+end
+@test only(Base.return_types(test_exit_bottom, Tuple{String})) == Int

From 6e5dd5903c2954be1b8b004d34668903e5ab7131 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Wed, 25 Oct 2023 18:28:16 -0300
Subject: [PATCH 0088/1315] replace jl_gc_wb_binding with jl_gc_wb (#51854)

`jl_gc_wb_binding` has become a thin wrapper around `jl_gc_wb` now that
`jl_binding_t` is first class.

Replace it with `jl_gc_wb` to clean-up the write-barrier uses a bit.
---
 src/builtins.c       | 2 +-
 src/julia_internal.h | 5 -----
 src/module.c         | 6 +++---
 src/toplevel.c       | 2 +-
 4 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/src/builtins.c b/src/builtins.c
index 25e63b9900a12..295c71ccdd23b 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1298,7 +1298,7 @@ JL_CALLABLE(jl_f_set_binding_type)
         jl_errorf("cannot set type for global %s.%s. It already has a value or is already set to a different type.",
                   jl_symbol_name(m->name), jl_symbol_name(s));
     }
-    jl_gc_wb_binding(b, ty);
+    jl_gc_wb(b, ty);
     return jl_nothing;
 }
 
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 0e1a02b03ec28..7e7483536030f 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -578,11 +578,6 @@ void jl_gc_add_finalizer_(jl_ptls_t ptls, void *v, void *f) JL_NOTSAFEPOINT;
 
 void gc_setmark_buf(jl_ptls_t ptls, void *buf, uint8_t, size_t) JL_NOTSAFEPOINT;
 
-STATIC_INLINE void jl_gc_wb_binding(jl_binding_t *bnd, void *val) JL_NOTSAFEPOINT // val isa jl_value_t*
-{
-    jl_gc_wb(bnd, val);
-}
-
 STATIC_INLINE void jl_gc_wb_buf(void *parent, void *bufptr, size_t minsz) JL_NOTSAFEPOINT // parent isa jl_value_t*
 {
     // if parent is marked and buf is not
diff --git a/src/module.c b/src/module.c
index 4cda3479adba1..c4b8437da4f01 100644
--- a/src/module.c
+++ b/src/module.c
@@ -810,7 +810,7 @@ JL_DLLEXPORT void jl_set_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var
         if (constp = bp->constp, bp->constp = 1, constp == 0) {
             jl_value_t *old = NULL;
             if (jl_atomic_cmpswap(&bp->value, &old, val)) {
-                jl_gc_wb_binding(bp, val);
+                jl_gc_wb(bp, val);
                 return;
             }
         }
@@ -899,7 +899,7 @@ JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_module_t *mod, jl_sy
     if (b->constp) {
         jl_value_t *old = NULL;
         if (jl_atomic_cmpswap(&b->value, &old, rhs)) {
-            jl_gc_wb_binding(b, rhs);
+            jl_gc_wb(b, rhs);
             return;
         }
         if (jl_egal(rhs, old))
@@ -913,7 +913,7 @@ JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_module_t *mod, jl_sy
                        jl_symbol_name(mod->name), jl_symbol_name(var));
     }
     jl_atomic_store_release(&b->value, rhs);
-    jl_gc_wb_binding(b, rhs);
+    jl_gc_wb(b, rhs);
 }
 
 JL_DLLEXPORT void jl_declare_constant(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var)
diff --git a/src/toplevel.c b/src/toplevel.c
index ca2033e58727d..a5918c23b4faa 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -167,7 +167,7 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
             jl_printf(JL_STDERR, "WARNING: replacing module %s.\n", jl_symbol_name(name));
             old = jl_atomic_exchange(&b->value, (jl_value_t*)newm);
         }
-        jl_gc_wb_binding(b, newm);
+        jl_gc_wb(b, newm);
         if (old != NULL) {
             // create a hidden gc root for the old module
             JL_LOCK(&jl_modules_mutex);

From b5a531aa25a0a21e2b235bbef6f0cefccfe8c638 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Wed, 25 Oct 2023 18:38:34 -0300
Subject: [PATCH 0089/1315] Make the static analyzer happier in aarch64-darwin
 (#51861)

---
 src/debug-registry.h |  5 +++--
 src/debuginfo.cpp    |  4 ++--
 src/stackwalk.c      | 10 +++++-----
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/debug-registry.h b/src/debug-registry.h
index 568a6156b5f29..f30049eb5b210 100644
--- a/src/debug-registry.h
+++ b/src/debug-registry.h
@@ -88,8 +88,9 @@ class JITDebugInfoRegistry
 
     struct libc_frames_t {
 #if defined(_OS_DARWIN_) && defined(LLVM_SHLIB)
-        std::atomic<void(*)(void*)> libc_register_frame_{nullptr};
-        std::atomic<void(*)(void*)> libc_deregister_frame_{nullptr};
+        typedef void (*frame_register_func)(void *) JL_NOTSAFEPOINT;
+        std::atomic<frame_register_func> libc_register_frame_{nullptr};
+        std::atomic<frame_register_func> libc_deregister_frame_{nullptr};
 
         void libc_register_frame(const char *Entry) JL_NOTSAFEPOINT;
 
diff --git a/src/debuginfo.cpp b/src/debuginfo.cpp
index 393b14c727b54..e8ab8507761fd 100644
--- a/src/debuginfo.cpp
+++ b/src/debuginfo.cpp
@@ -549,7 +549,7 @@ static int lookup_pointer(
 #if defined(_OS_DARWIN_) && defined(LLVM_SHLIB)
 
 void JITDebugInfoRegistry::libc_frames_t::libc_register_frame(const char *Entry) {
-    auto libc_register_frame_ = jl_atomic_load_relaxed(&this->libc_register_frame_);
+    frame_register_func libc_register_frame_ = jl_atomic_load_relaxed(&this->libc_register_frame_);
     if (!libc_register_frame_) {
         libc_register_frame_ = (void(*)(void*))dlsym(RTLD_NEXT, "__register_frame");
         jl_atomic_store_release(&this->libc_register_frame_, libc_register_frame_);
@@ -562,7 +562,7 @@ void JITDebugInfoRegistry::libc_frames_t::libc_register_frame(const char *Entry)
 }
 
 void JITDebugInfoRegistry::libc_frames_t::libc_deregister_frame(const char *Entry) {
-    auto libc_deregister_frame_ = jl_atomic_load_relaxed(&this->libc_deregister_frame_);
+    frame_register_func libc_deregister_frame_  = jl_atomic_load_relaxed(&this->libc_deregister_frame_);
     if (!libc_deregister_frame_) {
         libc_deregister_frame_ = (void(*)(void*))dlsym(RTLD_NEXT, "__deregister_frame");
         jl_atomic_store_release(&this->libc_deregister_frame_, libc_deregister_frame_);
diff --git a/src/stackwalk.c b/src/stackwalk.c
index dc963094853d2..6cf42e079f6ca 100644
--- a/src/stackwalk.c
+++ b/src/stackwalk.c
@@ -791,7 +791,7 @@ _os_tsd_get_direct(unsigned long slot)
 // Unconditionally defined ptrauth_strip (instead of using the ptrauth.h header)
 // since libsystem will likely be compiled with -mbranch-protection, and we currently are not.
 // code from https://github.com/llvm/llvm-project/blob/7714e0317520207572168388f22012dd9e152e9e/compiler-rt/lib/sanitizer_common/sanitizer_ptrauth.h
-static inline uint64_t ptrauth_strip(uint64_t __value, unsigned int __key) {
+static inline uint64_t ptrauth_strip(uint64_t __value, unsigned int __key) JL_NOTSAFEPOINT {
   // On the stack the link register is protected with Pointer
   // Authentication Code when compiled with -mbranch-protection.
   // Let's strip the PAC unconditionally because xpaclri is in the NOP space,
@@ -809,7 +809,7 @@ static inline uint64_t ptrauth_strip(uint64_t __value, unsigned int __key) {
 
 __attribute__((always_inline, pure))
 static __inline__ void**
-_os_tsd_get_base(void)
+_os_tsd_get_base(void) JL_NOTSAFEPOINT
 {
 #if defined(__arm__)
     uintptr_t tsd;
@@ -831,7 +831,7 @@ _os_tsd_get_base(void)
 #ifdef _os_tsd_get_base
 __attribute__((always_inline))
 static __inline__ void*
-_os_tsd_get_direct(unsigned long slot)
+_os_tsd_get_direct(unsigned long slot) JL_NOTSAFEPOINT
 {
     return _os_tsd_get_base()[slot];
 }
@@ -839,14 +839,14 @@ _os_tsd_get_direct(unsigned long slot)
 
 __attribute__((always_inline, pure))
 static __inline__ uintptr_t
-_os_ptr_munge_token(void)
+_os_ptr_munge_token(void) JL_NOTSAFEPOINT
 {
     return (uintptr_t)_os_tsd_get_direct(__TSD_PTR_MUNGE);
 }
 
 __attribute__((always_inline, pure))
 JL_UNUSED static __inline__ uintptr_t
-_os_ptr_munge(uintptr_t ptr)
+_os_ptr_munge(uintptr_t ptr) JL_NOTSAFEPOINT
 {
     return ptr ^ _os_ptr_munge_token();
 }

From 702730bcb5e120bad33494644cbc4b7adb5805c7 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Thu, 26 Oct 2023 16:52:31 +0800
Subject: [PATCH 0090/1315] Fix field access overlooked by rename (#51866)

In e5cd9b6b3888c, the properties field was renamed to annotations, but
the code here was not updated.

This was missed because there was no test for the
`AnnotatedString(::AbstractVector{AbstractChar})` method, which is also
corrected here.
---
 base/strings/io.jl        | 8 ++++----
 test/strings/annotated.jl | 2 ++
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/base/strings/io.jl b/base/strings/io.jl
index c45d0ac84640e..441b39693096f 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -797,15 +797,15 @@ function AnnotatedString(chars::AbstractVector{C}) where {C<:AbstractChar}
             end
         end
     end
-    props = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
+    annots = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
     point = 1
     for c in chars
         if c isa AnnotatedChar
-            for prop in c.properties
-                push!(props, (point:point, prop))
+            for annot in c.annotations
+                push!(annots, (point:point, annot))
             end
         end
         point += ncodeunits(c)
     end
-    AnnotatedString(str, props)
+    AnnotatedString(str, annots)
 end
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index d3ed9d47af432..be70578d149f5 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -30,6 +30,8 @@
     @test str != Base.AnnotatedString("some string", [(1:1, :thing => 0x01), (6:6, :other => 0x02), (11:11, :all => 0x03)])
     @test str != Base.AnnotatedString("some string", [(1:4, :thing => 0x11), (1:11, :all => 0x13), (6:11, :other => 0x12)])
     @test str != Base.AnnotatedString("some thingg", [(1:4, :thing => 0x01), (1:11, :all => 0x03), (6:11, :other => 0x02)])
+    @test Base.AnnotatedString([Base.AnnotatedChar('a', [:a => 1]), Base.AnnotatedChar('b', [:b => 2])]) ==
+        Base.AnnotatedString("ab", [(1:1, :a => 1), (2:2, :b => 2)])
     let allstrings =
         ['a', Base.AnnotatedChar('a'), Base.AnnotatedChar('a', [:aaa => 0x04]),
         "a string", Base.AnnotatedString("a string"),

From 44238459414c4ec66e1cad032f49a7e9cb12cfee Mon Sep 17 00:00:00 2001
From: Jerry Ling <proton@jling.dev>
Date: Thu, 26 Oct 2023 04:54:26 -0400
Subject: [PATCH 0091/1315] Fix comments numbering in arrayshow.jl (#51862)

---
 base/arrayshow.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/arrayshow.jl b/base/arrayshow.jl
index a05a8d4dac51c..db639a88876e8 100644
--- a/base/arrayshow.jl
+++ b/base/arrayshow.jl
@@ -364,13 +364,13 @@ function show(io::IO, ::MIME"text/plain", X::AbstractArray)
     if isempty(X) && (get(io, :compact, false)::Bool || X isa Vector)
         return show(io, X)
     end
-    # 0) show summary before setting :compact
+    # 1) show summary before setting :compact
     summary(io, X)
     isempty(X) && return
     print(io, ":")
     show_circular(io, X) && return
 
-    # 1) compute new IOContext
+    # 2) compute new IOContext
     if !haskey(io, :compact) && length(axes(X, 2)) > 1
         io = IOContext(io, :compact => true)
     end
@@ -385,7 +385,7 @@ function show(io::IO, ::MIME"text/plain", X::AbstractArray)
         println(io)
     end
 
-    # 2) update typeinfo
+    # 3) update typeinfo
     #
     # it must come after printing the summary, which can exploit :typeinfo itself
     # (e.g. views)
@@ -394,7 +394,7 @@ function show(io::IO, ::MIME"text/plain", X::AbstractArray)
     # checking for current :typeinfo (this could be changed in the future)
     io = IOContext(io, :typeinfo => eltype(X))
 
-    # 2) show actual content
+    # 4) show actual content
     recur_io = IOContext(io, :SHOWN_SET => X)
     print_array(recur_io, X)
 end

From 6900ee19fc90b35830691536c9aa0802525c6e6e Mon Sep 17 00:00:00 2001
From: Yuto Horikawa <hyrodium@gmail.com>
Date: Thu, 26 Oct 2023 17:55:15 +0900
Subject: [PATCH 0092/1315] Better `sinc` docstring (#51858)

There are two types for the `sinc` function, unnormalized
$\frac{\sin(x)}{x}$ and normalized $\frac{\sin(\pi x)}{\pi x}$.
(https://en.wikipedia.org/wiki/Sinc_function)
This PR updates the docstring and clarify which of these definition is
used.

Related:
https://github.com/JuliaLang/julia/issues/36954#issuecomment-1296954308,
https://github.com/JuliaLang/julia/pull/51551
---
 base/special/trig.jl | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/base/special/trig.jl b/base/special/trig.jl
index 50d3d69585217..99b4ca91608f2 100644
--- a/base/special/trig.jl
+++ b/base/special/trig.jl
@@ -1065,7 +1065,7 @@ isinf_real(x::Number) = false
 """
     sinc(x)
 
-Compute ``\\sin(\\pi x) / (\\pi x)`` if ``x \\neq 0``, and ``1`` if ``x = 0``.
+Compute normalized sinc function ``\\operatorname{sinc}(x) = \\sin(\\pi x) / (\\pi x)`` if ``x \\neq 0``, and ``1`` if ``x = 0``.
 
 See also [`cosc`](@ref), its derivative.
 """
@@ -1084,6 +1084,8 @@ _sinc(x::ComplexF16) = ComplexF16(_sinc(ComplexF32(x)))
 
 Compute ``\\cos(\\pi x) / x - \\sin(\\pi x) / (\\pi x^2)`` if ``x \\neq 0``, and ``0`` if
 ``x = 0``. This is the derivative of `sinc(x)`.
+
+See also [`sinc`](@ref).
 """
 cosc(x::Number) = _cosc(float(x))
 function _cosc(x::Number)

From 3c4bccd93b2b7d9954ebd3ab43268a3e13185775 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Thu, 26 Oct 2023 10:56:07 +0200
Subject: [PATCH 0093/1315] docs: delete misleading `::Function` annotation in
 the `ntuple` doc (#51836)

The first argument is not actually restricted to `Function` types.
---
 base/ntuple.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/ntuple.jl b/base/ntuple.jl
index 7391b86154ac4..4720e7a3915a8 100644
--- a/base/ntuple.jl
+++ b/base/ntuple.jl
@@ -3,7 +3,7 @@
 # `ntuple`, for constructing tuples of a given length
 
 """
-    ntuple(f::Function, n::Integer)
+    ntuple(f, n::Integer)
 
 Create a tuple of length `n`, computing each element as `f(i)`,
 where `i` is the index of the element.

From 342d05df673782df12c89d42e3c6f446d116f86a Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 26 Oct 2023 11:07:05 -0300
Subject: [PATCH 0094/1315] Use correct module when printing code_llvm for
 opaque closures (#51865)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 src/aotcompile.cpp     | 2 +-
 test/opaque_closure.jl | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 1a7c7e0f5b2f7..3490ae71e54ce 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1895,7 +1895,7 @@ void jl_get_llvmf_defn_impl(jl_llvmf_dump_t* dump, jl_method_instance_t *mi, siz
                         elty = p->getType()->getNonOpaquePointerElementType();
                     }
                     // For pretty printing, when LLVM inlines the global initializer into its loads
-                    auto alias = GlobalAlias::create(elty, 0, GlobalValue::PrivateLinkage, global.second->getName() + ".jit", p, m.getModuleUnlocked());
+                    auto alias = GlobalAlias::create(elty, 0, GlobalValue::PrivateLinkage, global.second->getName() + ".jit", p, global.second->getParent());
                     global.second->setInitializer(ConstantExpr::getBitCast(alias, global.second->getValueType()));
                     global.second->setConstant(true);
                     global.second->setLinkage(GlobalValue::PrivateLinkage);
diff --git a/test/opaque_closure.jl b/test/opaque_closure.jl
index e809013ba31be..a1a1e2ea53aad 100644
--- a/test/opaque_closure.jl
+++ b/test/opaque_closure.jl
@@ -347,3 +347,5 @@ let ir = Base.code_ircode((Int,Int)) do x, y
     code_llvm(io, oc, (Int,Int))
     @test occursin("j_*_", String(take!(io)))
 end
+
+code_llvm(()) do; Base.Experimental.@opaque(@noinline x::Int->println(x))(1) end #Shouldn't crash

From 837522aadd3d96397a15337aff65c3adbb3d8630 Mon Sep 17 00:00:00 2001
From: u7581147 <141328479+u7581147@users.noreply.github.com>
Date: Fri, 27 Oct 2023 02:11:50 +1100
Subject: [PATCH 0095/1315] Added tests for load_overrides() in Artifacts.jl
 (#51833)

Fixes #48551
Continued from #51815
The `load_overrides()` method in `Artifacts.jl` has a large untested
branch. This PR increases the test coverage for this method.


![image](https://github.com/JuliaLang/julia/assets/141328479/a9744e25-e79f-4664-8522-320dd29c4c50)

https://app.codecov.io/gh/JuliaLang/julia/blob/master/stdlib%2FArtifacts%2Fsrc%2FArtifacts.jl#L121
---
 stdlib/Artifacts/test/runtests.jl | 81 ++++++++++++++++++++++++++++++-
 1 file changed, 80 insertions(+), 1 deletion(-)

diff --git a/stdlib/Artifacts/test/runtests.jl b/stdlib/Artifacts/test/runtests.jl
index e65c936f08b8a..57b7e018e327a 100644
--- a/stdlib/Artifacts/test/runtests.jl
+++ b/stdlib/Artifacts/test/runtests.jl
@@ -2,12 +2,91 @@
 import Base: SHA1
 
 using Artifacts, Test, Base.BinaryPlatforms
-using Artifacts: with_artifacts_directory, pack_platform!, unpack_platform
+using Artifacts: with_artifacts_directory, pack_platform!, unpack_platform, load_overrides
+using TOML
 
 # prepare for the package tests by ensuring the required artifacts are downloaded now
 artifacts_dir = mktempdir()
 run(addenv(`$(Base.julia_cmd()) --color=no $(joinpath(@__DIR__, "refresh_artifacts.jl")) $(artifacts_dir)`, "TERM"=>"dumb"))
 
+@testset "Load Overrides" begin
+    """
+        create_test_overrides_toml(temp_dir::String)
+
+    Create "Overrides.toml" in the given `temp_dir`.
+    """
+    function create_test_overrides_toml(temp_dir::String)
+        # Define the overrides
+        overrides = Dict(
+            "78f35e74ff113f02274ce60dab6e92b4546ef806" => "/path/to/replacement",
+            "c76f8cda85f83a06d17de6c57aabf9e294eb2537" => "fb886e813a4aed4147d5979fcdf27457d20aa35d",
+            "d57dbccd-ca19-4d82-b9b8-9d660942965b" => Dict(
+                "c_simple" => "/path/to/c_simple_dir",
+                "libfoo" => "fb886e813a4aed4147d5979fcdf27457d20aa35d"
+            )
+        )
+
+        # Get the artifacts directory
+        artifacts_dir = joinpath(temp_dir, "artifacts")
+
+        # Ensure the artifacts directory exists
+        isdir(artifacts_dir) || mkdir(artifacts_dir)
+
+        # Get the path to the Overrides.toml file
+        overrides_path = joinpath(artifacts_dir, "Overrides.toml")
+
+        # Create the Overrides.toml file
+        open(overrides_path, "w") do io
+            TOML.print(io, overrides)
+        end
+    end
+
+    # Specify the expected test result when depot path does not exist or no overriding happened
+    empty_output = Dict{Symbol, Any}(
+        :UUID => Dict{Base.UUID, Dict{String, Union{SHA1, String}}}(),
+        :hash => Dict{SHA1, Union{SHA1, String}}()
+    )
+
+    # Specify the expected test result when overriding happened
+    expected_output = Dict{Symbol, Any}(
+        :UUID => Dict{Base.UUID, Dict{String, Union{SHA1, String}}}(Base.UUID("d57dbccd-ca19-4d82-b9b8-9d660942965b") => Dict("c_simple" => "/path/to/c_simple_dir", "libfoo" => SHA1("fb886e813a4aed4147d5979fcdf27457d20aa35d"))),
+        :hash => Dict{SHA1, Union{SHA1, String}}(SHA1("78f35e74ff113f02274ce60dab6e92b4546ef806") => "/path/to/replacement", SHA1("c76f8cda85f83a06d17de6c57aabf9e294eb2537") => SHA1("fb886e813a4aed4147d5979fcdf27457d20aa35d"))
+    )
+
+    # Test `load_overrides()` works with *no* "Overrides.toml" file
+    @test load_overrides() == empty_output
+
+    # Create a temporary directory
+    mktempdir() do temp_dir
+        # Back up the old `DEPOT_PATH``
+        old_depot_path = copy(Base.DEPOT_PATH)
+
+        # Set `DEPOT_PATH` to that directory
+        empty!(Base.DEPOT_PATH)
+        push!(Base.DEPOT_PATH, temp_dir)
+
+        try
+            # Create "Overrides.toml" for the test
+            create_test_overrides_toml(temp_dir)
+
+            # Test `load_overrides()` works *with* "Overrides.toml" file but non-nothing ARTIFACT_OVERRIDES[]
+            @test load_overrides() == empty_output
+
+            # Test `load_overrides()` works *with* "Overrides.toml" file with force parameter, which overrides even when `ARTIFACT_OVERRIDES[] !== nothing``
+            @test load_overrides(force=true) == expected_output
+        finally # Make sure `DEPOT_PATH` will be restored to the status quo in the event of a bug
+            # Restore the old `DEPOT_PATH` to avoid messing with any other code
+            empty!(Base.DEPOT_PATH)
+            append!(Base.DEPOT_PATH, old_depot_path)
+        end
+    end
+    # Temporary directory and test "Overrides.toml" file will be automatically deleted when out of scope
+    # This means after this block, the system *should* behave like this test never happened.
+
+    # Test the "Overrides.toml" file is cleared back to the status quo
+    @test load_overrides(force=true) == empty_output
+end
+
 @testset "Artifact Paths" begin
     mktempdir() do tempdir
         with_artifacts_directory(tempdir) do

From 75881a9edd8a2d4b46664f27fae98c6ec16f6e38 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Thu, 26 Oct 2023 16:39:57 -0400
Subject: [PATCH 0096/1315] Bump LLVM to 15.0.7-9 (#51863)

Contains a fix for AMDGPU.jl
---
 deps/checksums/clang            | 216 ++++++++--------
 deps/checksums/lld              | 216 ++++++++--------
 deps/checksums/llvm             | 436 ++++++++++++++++----------------
 deps/clang.version              |   2 +-
 deps/lld.version                |   2 +-
 deps/llvm-tools.version         |   4 +-
 deps/llvm.version               |   8 +-
 stdlib/LLD_jll/Project.toml     |   2 +-
 stdlib/libLLVM_jll/Project.toml |   2 +-
 9 files changed, 444 insertions(+), 444 deletions(-)

diff --git a/deps/checksums/clang b/deps/checksums/clang
index 685d7403b5815..f0f458c6cce9a 100644
--- a/deps/checksums/clang
+++ b/deps/checksums/clang
@@ -1,108 +1,108 @@
-Clang.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/3994ef8cee2fe488709909f5fffdc091
-Clang.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/0713994930b87768dbddeaf5ce5143380e83bfdf3e0e10aa1ba0337fa0ccfc3c84fa05786cccc2b2461d0bf3bf7dee45e18b4f7146c62ae624705f4d3e43df1e
-Clang.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/dd097ca34e16abfcee18ec6b955f0d3b
-Clang.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/446f31dbca35a307faec0a779737129c7878ce8c879637265120114f4c68365a6593e1f692c76ff160f5b264a0bb0e9b9f157315ee138ddebdcda1e6e9d3c030
-Clang.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/96a5a51c74d4d74ce9a5f7701f7da325
-Clang.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/d27e8931b89aaea97bf10a7bb9d9608a14537e352bbfdb496f0ef9537599f47ce11e519f77912a6befe96189a26c423a8359b1543b39558ec9648a82196c9057
-Clang.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/2bf9499f0016a6d3f192e9b982587fdc
-Clang.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/956cc2c49b49a0d56575c8192e8bc8a3378d484ffafb3fc78f2f8d4331f1070a6fa8111c6bcd63d579a0e54546a3d5134a3c760c609a962e2a586d7b0d48646c
-Clang.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/28ea22de73f4c555edeeb4ff22ce6099
-Clang.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/88491ec5f0c51e3a6b4b2b6877e9e8437f8b3145a22f8dfb05269f9ddf72c1b8eca496b650ce2e9a26101ad48d2e79d01b4b4a48883fb547d4445b24ab79bfd5
-Clang.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/9058d021eb893fb11313a04359d1d2b0
-Clang.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/5fd93a2278b3d3c6f6a1836722b97ccd099f17a36da900b8bd54f0b399bc9ee42e847bc094058c3f3ce77dfc6950b5cef9b4571f5941857280a370af16c8b7b3
-Clang.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/8ac220c9570fa66c2f13d9247dcfb324
-Clang.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/977077fd338912c2fdbb88f4bcf1591b6b4f648d6e7c9ba2783b331eb67da2e6b9b29f85446500f6dfb15c9e05af8fe9128dbf3e77dfa69bd597999873769e8d
-Clang.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/f017a86ee8803f2099b04ecf254e8157
-Clang.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/c773d0c07234b03c71a1c2862f373f76d4c898fdbad35342c2e687a2afadaa220daad759afa5f88aa7eaab3d0d05f1e8eefcfd374bc1c92ddf638d42d20b74fa
-Clang.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/80af25bf64203daaccc72f2274b60681
-Clang.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/913f8ee4c7f9618227673db0aad7e5e98f0fccb8a1faa84778ec84ab10ee8fe4d59a8115582420459de67b8667f3f4681bde59dab6dfa70ddeb8ff8b7fd1add2
-Clang.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/5b79fba21be10d03476c52ad0888d562
-Clang.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/075e074a0f460be27fddd32069dcf4ee48aacbdf480ea74356692b3d98808868a18166ae5e689b17faa6b0ae1f1453bb63d98ed119afd3f44a8e662fa602a57e
-Clang.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/90a9224695634cc70cc39b603cc8bc57
-Clang.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/c1e388b838723b5251e6bf068a1790f83ccfe618be2e138b397d0a40c4f85f717bf01e8a46bbab48a91f182caef8e3fc291ec71a56df95fa60446a8858ac904b
-Clang.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/6f2ec0e8aaaeb7c9e0c1d826010886ba
-Clang.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/eb33e93ff5f3e32051c08c0aa42f1cc691dc364683ac484bb292f190911c879226282cea758224c9fea1bfcb934e4abbf4edd07666d9a2dee63d0ba40c2b3b47
-Clang.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/2e8b81ef8017987c5ace824d524545cb
-Clang.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/76d1cfba99747038542946680dad02d9deb4fb6dafde6def13e95c393da5d5f5f2aa30889377c6f3a869963075b9181b3d7652016202767768e880f2fdea827d
-Clang.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/7556ca721d4e90e64a266c4b59fefc48
-Clang.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/8df1651aaa87364fe47da4fc993551a9f9ba575ca88c749b92d6586390e19c8b059c20081e4b76426b23cc1140d1bd38c216855d968f3dc01505e29dc5760367
-Clang.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/fd294a76698157d71a3a64f4f4e442e5
-Clang.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/71466cd9d0b46686af10e124bb026e02af240b5ad5f3844fa5c0bb152ee334a56d41e5c82c8b2e3778ea409f5dbc1074afe5a8121fcb157745420a2fcc3465f3
-Clang.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/a2ad561f1a41ed993fc2edebbe1a6b3b
-Clang.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/51ed85190a1bdf89d0f5fe361381b0e0b773be05f510ac7b77747948f49dea49807d3d46cb3e948d22785884b8b92dcbf36d202087d2c2628fce6c73c6cd9789
-Clang.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/98829294d5c6327582a8f9b1d7232083
-Clang.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/d570b28e6a11d02467075e82931f8529671acd5e61992f462729d690810953535be31dcfe6fbdb3add0e00799809bf3afb529d227820c7f176e6193c24da7853
-Clang.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/bd173830434f85d17e4857b7ffdb2dd1
-Clang.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/ff66a8b1085d67521aa58f766b7bfad2c19ec89add9a67be2c5984a7a5ff5aacf60d54e0448ce70ca80d9a7d972624b9a2be530f767c87ed6839f709a482a7aa
-Clang.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/34b020d23cd5b34ae47b2b0473822f14
-Clang.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/250d55dfb02be3cfc4eeca0da386590d9fb0b9d6759360732b72b8663f4a3c843cd9e23ea08b8d272945fa64230e57f9a5bcdc4399dda2db54e51961e7c9f3e6
-Clang.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/b3c76e91d6b43c7794b6ddb9d300d8f4
-Clang.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/efbbcf2cfff1918e58fd850d99eec1e28cdaa11730b722a416e5da233a8fd0be685259052d5e9adf32c2c2364a4f96540a0175a44b8dc8d6ec872ef12394b9f2
-Clang.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/81ae8ac294b1656b188dc437a7de6b10
-Clang.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/1eac2968698b759bba3467205843183ed7279f24ae06f2d47b1cd4965c115d0b9f578ff7e0a6006883a462ad97c1829f3d706767de77a05d159bafa183064f84
-Clang.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/581efd97263d337031ee761326320489
-Clang.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/ae28a7743146eba68831e0f1929f87596117ebf64d9284585c1909ed1b78a60e102618e4232b37017543351208e0d1183d81e0bbf737c7930bd35dd146c9a2bb
-Clang.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/34342cc1e94435ddac6ffc7ec89471f9
-Clang.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/2e06c7a4b79a45d2139cadc3c10c4dbc086e6cf20b5f2ce90b50aad9bab6ffa4b55eef3dc9e40b495329a2a1eb9d0948b29a4495dc8a3cd56ce500087b9e63c6
-Clang.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/de880e4c673351c777509ccfdc0a2579
-Clang.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/e1becf694f1edbce097eaff7349c8a2ca8a1dda265c01a40549acf0dbcbbdf3c23d515236b114e6ec124f85e6bde380850ba72029de37cd36d59789936a21e83
-Clang.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/93a4565b236d905021ab84b0a6c9fd34
-Clang.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/d7c5b5e6fb627c2e19c72e42dcbcd8de9784dee522057d9fcdb03b0bba127de5517d72da8ca120c3cafabcfe6ac016526a7fbc090258119f5f6252d26d2c0c17
-Clang.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/31d9e5992d969548f67b9478abfb1575
-Clang.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/28ed4cdf1a289ece1defb2d4f19cb03ad07963f8e9df62073fbde3adaf943e78085a6f2d03b6cbd3f00f10f61a3499f964e104c2c1ee73167965b84be0bca901
-Clang.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/8b6ffb09acc5d80408362b2705629db4
-Clang.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/d69bd543be8848c9349014f216af7ff1cb32401cf1b0a060a3687259cb56518933f65ac8ce24eca74e2bfc79a1900bc638ed1428e7823672d088efee8aa70387
-Clang.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/6dc4752e4987fbf9afc49b0a5a0b62f4
-Clang.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/7617ac0ad1496549f6a38d33414cbbd74b72dbb54758f24ffc88a42226cfb607babba73b7e33d9558bff2d208bac3ee8f3b2594990d5e5fda49819eff3ad0d05
-Clang.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/47cccd1ef2565df7196afe4da7659380
-Clang.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/9d25f2d0634e2b4f5b8d9e4fb57c65c7d5956cadc24bbdb67a62095f2e6378aba3a8f16a0bc3aea6656c97aa035b3179645e352ff1a0b01cb89a773e9edc0b89
-Clang.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/4e3fdf880b91a5fdbdcdff34386ee8de
-Clang.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b02b3a7db9796d45d9d1bf1fc95495c71f6575a70ebf7f4d9d249bf117eb8bdbaa100b2d4e867f82da1b9f9d13ae0d7f68097d1b085b0b6f3826ed21723cc709
-Clang.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/859e942a9b7d0ee2fb626552e87586ad
-Clang.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/23f4ecd6a2b4967d41a7a7ee18d3930b4c5e9dd4894a75c2f85e59be0c66bc0fccc7931e051258f36290affd64b6fa37b925ed53a68a0d0cb937a66a6ebfd263
-Clang.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/f1c4a569ea5705e9eb5c1807f4053c4a
-Clang.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/73cbb461b39b25b9af334487cea4f16ede9d82ea615671a72d9cce28f9069c3f872f8caa85a3ca61d75919424cd03259a9ac7cbc6c245e1aee2f9afbeef37d7a
-Clang.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/f1750649bc2102333fee60be64cfcebc
-Clang.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/9c512417ebdc0662a1003978f454d28ec5ddb059270172878a0ca62cc1b85a4e7b7a873d8361f52d0e89372f625f9238404f4b850618ff808592107803e80632
-Clang.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/d88610eb9c37cd5e438087b41960658c
-Clang.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/79b241c911a38d363e86761500fd2fba3a439feda270132ec364bcf02189c3a97cfafdf73ef41e00364f8bf5e2ead602cdf5c5a699126e8a372bd3696d7f4b1f
-Clang.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/7b0878064a5f8ba1953f5e76c4b63c18
-Clang.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/542f057b2c3d6e829f34a615d7c9c021d793ce3723512b70f7e140640175b237a9669bd9f24563eede1dc5e25e37fa8910b1769ed344af9ea4d21bebc6638801
-Clang.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/e797f5d917b08bdae66fdcab4f8367b5
-Clang.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/40a379b2de5eafa8f202b258b8620bf82fb3eae384337120149ae17c7affa7e166a6b4fb77fb4ce94808c152efdf270ec22f03a2ca57aee27799ccc3c684b88c
-Clang.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/1fb0bda6cad1591b1b40752efaa1f198
-Clang.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0ff8a3d9fc53e5733b9ea9ea30a4c0023fc926704d2dc747a1802343e5c45f6cabed9fd3207cb146218bf8f71b4de79d708c3f169fa13e3eb35dde591509d84a
-Clang.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7e2922fc9c5e3f93b73af4b2f8502f7b
-Clang.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b7656c67cbe9d6cfcd0837a4646819d9dcad83ab0907a570f8e66894f2650cbaa43c78796435b16bf28878b39e1c9254772b5aaa996f6a5629159c7c63caf26b
-Clang.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/795b7f564282b22c2ef2cece8162044c
-Clang.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/035781d34cc8ddb7e41eb3d46651589ab519cc4fbe0ba0de8d3602b1353027ad4826b619a33de5c033b85f4261471f6f4bd1e62164c07f945a731bd579919e08
-Clang.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/4430f9cbe83a8d97a993dfe7a4b3b044
-Clang.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/19e4ae8d491734b15fac101cbdbaf652cc37d420f64dcf127bd0fac6eb381fa040312f9c3b836f80fd9d6cb67a1951598dacd9abd826a227e639a685e086637f
-Clang.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/9ccb6fc99b35c72b6e566f3d2336c686
-Clang.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/af926692bcca26ea35450bb2794b94f6694ffbffbf54342f403dc47270e983ee697c06dbaefc143ecd0954100736586838987f51f8259e160b0ca06688514889
-Clang.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ce36f48d88d7dad1aef44c11b30aebf8
-Clang.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/fbbf65977c5924830ff4c1c2c6d824a3635d09d4ee9304888030b8eca1bd7c06d8c053521068f663df932379cb3b7f0772589f7cca56156dd7053e6722d29953
-Clang.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2b68c2057aeca1564106dab565fe876b
-Clang.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/64c8be7c227fa52c9d90353d5ab72c179c8974b0bc048d6f5793d0ac08110b98c54e2e3f65416986b7049904cf86b5a865cf3de4423d7b0906b4e85a0dcacd21
-Clang.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/04a0a842bc490c440ec65927c285059f
-Clang.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/82dc5eba9a795fe8d0e5c660aad1d902cde8c304ddfeb794d55a7b8decc97d27b648f658bb749b3bc25d2d50771febb0b481198459fc739c1d6944542c2b64f0
-Clang.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/1742d997df9bc95ddc7791e0f3ba49c8
-Clang.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/5187a9fddf31ea260d6d46f613d96c79b3c77bb8c7dd2752bc8d7becb7b7210a3d9ce195b2f03d466760bb4e52dee0beda22f238097e1472dbed04170b14e2c4
-Clang.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/79e68396face36fc162ab27b99714b34
-Clang.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/80f22d1bca302debb3e01213da099e5378eb3c1ff8684dbc8efca9145a27d1542a9a065e328c76148465dbb42268dad028004f38215289bbd862fc2cb12abf81
-Clang.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/e2f7246f9e8ebd73e21186f18985755d
-Clang.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/6dcaa68abe3abff6f3e288aa34ce3591a8e92d933187715cb9bc7362947fefeba3ce1b3629efdcdcb1fa3be111f7614a10b4f0b73f3ed54f46d6d9791612305e
-Clang.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/15a21dc979f82c71a2d743f76a539c5d
-Clang.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/684b9d596c4e0c4567841cc913ba91671030765edea4642c1883d87c12ddc2a2e4ec82931b2024a66e37c48820aeedd1fc41982930396cf657596d8d3970bf09
-Clang.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/82d172f6be5b1ae34fb92f85f962b9d5
-Clang.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/62c39f038d7a616986314ec3da0ebc59cbed5a6cbac73becfae5a037e734922f4ab59e45a25c8c31242660fe4409023a1191c7311d0af1303d6170ec87d97413
-Clang.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/89c040d2773aa3f40fc1b0965d19b201
-Clang.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/adb704fc2545d766da18766b2e3b6353f9865dac7e46a54e5d83b6886ca5ba8a091a8ceed86fe12bbfc0b3dc12b990dcf1389ba8d27ffe1bf8291c9855ca69b0
-Clang.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/b4c8315bcdb815f012e8c31913a06367
-Clang.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/0bf975521b50c2049bc24b363ae1aa7273471ff20ffbb3d6084561c6c83fd7f08d5ce882ab976d6ec5cffac74cc5ca1c0bf888afdbd8c0c42abc3a6d61a73969
-Clang.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/bbb5fd33559714a6cdc89472a78279e3
-Clang.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/d5635f4b34a21a39c52a494c8baa138d15b9455b08ca7d0882cb8920b5d272ae3b6f3a5f5f1ab7cafb53fd4c93d2bf9b7f1028b09c40e4991ae2e2b04669bad2
-Clang.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/f0a7ba2ba8ba4ef2a75e4e2d9fe5e6ca
-Clang.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/0148d0fa525f35a1b8835bfcb7f7ddfb498d118762f960b678d236d5c6b2b16b104d6a56ec2763617ada8faba68d3572d61b73d263fd7dbbbc1111359262828d
-Clang.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/7c1a2ade54354864e5d7064e6192a111
-Clang.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/abc8121210650568f4c3e84902f2ffb43f2d660c0b0efeebdcf15d11a87d6a6d0409f4db74d58acf4dea58e3167729e34c82170f65ee1735f4db47c487f723e1
+Clang.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/f11d13e193ab5e18c88652012d0313fd
+Clang.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/513a14b0a99695ef330c1109e53d2f9ebd44f9d189e2fac691f4dd3502dea0b1437dbad58fecfc99549d64c90237f5143a0d31b8d05dbd747eb9d2570ed85763
+Clang.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/97c7f0c55a0943ef658960aa6b8ad6fe
+Clang.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/7a655675d0d3b3a18f031effbfcd60b171d880ebbe14c64d82f3017e537d56deb19e7a613dbfe619dbd4e8c9db1a2d4e14eefa984f11efd086332eed5d141d06
+Clang.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/3ae704a7c7be76ce32bba7c29ef34bc7
+Clang.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/93550af832e64603431a4e87ef90af227f9e376184a839e073ccb8880399b83bb748f4dc0525a69ddcf2bae0a31a010bd27884a9b8f9462f8439899080bd83f7
+Clang.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/6bebcf58049da1baa3689f9b5b4c0508
+Clang.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/68dce1abe90fd6df3facf19f0e430f27a3d27426c6d5673b82e671a252e08f3bed435bbf571e0c203cb95f2b5311dfb948f9a4da81eeec4f53b3c27dd692b049
+Clang.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/ac81a4b721024af1f63a006047b23d61
+Clang.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/48673b058ceb6c022f553c567ee303154cc587adfb6d5e2c60bf3594a47515cfee01bf6abda54a9f54e49b3bbc40bef372f2cd25e4eca4966834fdf5cc1ce150
+Clang.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/51ec3b7ad77d6a525a433cd9044046f7
+Clang.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b67f6c782734d5a1b3bac8b4f93d0bbe49cc2a1fde095c1d13517d19b1631a926f31291c92058d560b4cd69a6161891b1808ad8f6f6e30e8c103e7183d5f59d8
+Clang.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/bb3218601635220ded4b8285d991b88a
+Clang.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/0c60978c8b09a9cfdb7042dbfa61b5147748e968c08508df535a26b8d6ce199837b2ca7aee483d940ddb60aa601a191247e31c89e89d9f1eb427e28358a8c0cb
+Clang.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/53631f7d2506def52ff0bdc9b60e703c
+Clang.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/5a0362e15e3ab1b39e88ebf1c5fd8c179e72d784516d6fdf0139180f3e59806ae07f0bf11f92d0313baf3340b77d872d8f6ce04f1d9f2fe1ba15cbf4b7ae3c61
+Clang.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/8a4061b3454b411f05c8c375b3af4f44
+Clang.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/2ee66b4a16821f0fc5f8a2aad92017f71767d5f12374425162c0ba9440ad40082780f21114f61e51ee35be4f0eccd8d61e28c964e2b724046c572945e9410740
+Clang.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/eb3d9c2224594d96c2b735ebb420f24a
+Clang.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/1ea760423afcb28d306f1bcd67d25d1bdc88dee21445f397bfe5b2fdddd84c8343fc4e5fbedb006640546b28643946aff766d7660e75e2d25c3fde51f64e35d7
+Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/ee4b539db8439cf3eb480f4f86b67588
+Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/fe73b6d62a39e8724bf3cc7ddad385958ef1fc80bce8a6c7a4f57c4bb383736b2ed4a59da228683101bf2f16d4673d9012a30973c22b4b9dbad4be75872a4a95
+Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/27e36fa4a5173cdb6179c27299e80128
+Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/9b078f25921f2208fb2cf7ffadeb7f451be772527a6a9a268f44c20a17b8369b9e0b7f55b48ca38ccfa77f9f2a4209a6168001300ebf63ae09a50bc19e1a5403
+Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/76086701d89bd10682c0f937571af5be
+Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/0d637913b61dcab5aa32e7d2b1315e1d597114f9c5a9dd8f9c50bf26ca8260cd76a9cf4e4992bf7a502ce6ae682222a41f6d44e5a5676f329837d4ec5151dddd
+Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/9151fa6e2a3d3cf51f1ccc0023ea7e23
+Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/56ebc1653607e623d4a1ecba4a66865b069b548a5d3ff3410e712da6e20e9ae222d5ed6fafe50c924fdd927a6052cc02287aeb5a49fd6a404d7ead243f04d230
+Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/cc22ad5247ded68dd2b22f49d9a9da0b
+Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9f42403c94ec2978f252a38215b0feeb9e2e1131a777bab52bfdec1fbd0399e12008e4012254a53c92b31e7db4d9dcaccd47be40f37d5e23596648ba89e77f9f
+Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/ac2fbc3060d46a0ff2b1536db0d87461
+Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/a5db6ffeabaeaf20cb8b9b61530094fcca442de249265f9bd5d62067aab663fc42ed65ee87fea91e427648340e3a8a739a6b38363ced69aa2c6f50bc2a14dee9
+Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/916988129901ce50be35b29ca2969ba4
+Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/e37769b80134a14ffca04f85e4a82b36c61395f1459a0122fd07505561aefe0fa8e681d428bfd58fe4c40bb8d4c201e8fc7a1029de2527eb78728ab8d0513981
+Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/d57074a9cd8d0a99db44026a75bbed52
+Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/2bd80d0d5ee6d3fa14d1c5e1c5838f5fef13f0d31012ed0ecaefce66f35d2918faad2444eeedddc64a699b1843b705d002f95ef7f8d82a2dbbe55fe1ff545591
+Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/2aeda3d3dbb3c4d294d3cdfad028aca5
+Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/597ac2c8fa1e00f157af7555f82f7f011a74f6e24ec6dbfca31f5e104b67d6fc157f59b03689afe16cc35f3b8840a22867766d17b92750891e5fcdd0b6027ffd
+Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/8318580861648c955f488eed4c2beb87
+Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/6b4f85bfa1bc804666c8e25f15c49dd67c665a261e6a5e79b1d72f079a9cb02ce4c929855e342aa0c0a08fb7ff8891eb93468dc4dad598367eac0314823d398f
+Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/d8c1f0aaa04b0a7b8795477a67fad0c0
+Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/5ca6f1ab1e17a4e4712397be9dd040641ee8583c21670a2c26881bd917b1d54420d193efe039ea1aa929b7647b0672838c9309d011c733aa5d060598a985a84b
+Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/6dccafa2ab530b162b42948e4e089fc3
+Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/c4a9e1703a1b4c4f7753d16d1dd9cb6159c7199a9217ff01ae2e5b29bf1cbc4eb7e3c9549afe84c23cb767bf095d2f19635dd6451bbf16e7716561b317f6adbc
+Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/cf3a71a9368cafd9c90d0949069715ef
+Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/b3a6fd1bc2ce52a96915e8095a0ccaf9c9234446336249cf796fe2853f5a95808de7bdec126032135ef4ed202dd83058a055fae95dc06a7c4aef575715d17177
+Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/f15f065e1e759d94576373023cfda5e7
+Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/94903b6220ceb155f1407e822e0449584f9a39ed899c753146736884cebf054b3ce0fc3da657ece6e9573b2699829ebce8b5737c329e67e78fc12fda7a6bbbed
+Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/7047338e3cdff0e9bd52d04160ef0ac2
+Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/fa48444ab31826eb06a9eca8c209d7beef952b11e1448bfc2e4dd1906ac5a12fa84fd0f048069cbdecf0ddebf6fe12bfc44d2dd6c117d3d17befb17d05ef0efb
+Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/3497b263dc6af14911baf3457f0e002d
+Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/44853f230ed408744fb79911f7fa94843a6dc034dd52ecae86710325f9c6ce635771bd3e54b573f021d30542cf1a72cc92a338454633990c25ef51eb741cd63a
+Clang.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/9ecbe0287e26e692377b249e7b56943e
+Clang.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/ac1ad5ea8e31d68231fa83d54bb8bc63d14b906682590e209fb50dbb6bb41349c1683fa08f4cdcd381f0c05eb7b80443af26e3557110fceb075f392f6cba3acf
+Clang.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/83a7ace018fd7c1ff108b74f71064e00
+Clang.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/8ccb3e34e6d5e92b30024877db4df2d697420a3318eda2413442d10b7e8541a25ffe1b8b4133d37882ed6ddbd0ef7aff984315946538946484150f5b8d7307c1
+Clang.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2ebc196f9c8d210d7e99f9674cf92c38
+Clang.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d6a236854893629a5e318dd3b4cfc99ae75849fa3677c466d06355a3e6ba002db07fc0cee74ab2abf17a56cb58b37bb58e65d9c1f760d1d900dab35372afadc3
+Clang.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/48f329f4721bb4a5c805291449f397b6
+Clang.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/5e781a7e1ca0a8fdf8065d1ca9b5ecc6f2b85cb3ce6544d7aace5d86c7dccfb25ad46caf39b9231def435c0a61f7466638c3de5878bb20830fbf77e25d39347a
+Clang.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/b44457db229714204cdc46862511a8f9
+Clang.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/fab8fa3518106d833aa03e83b17db2e19d57894d5061459376a13de9c825ca3d500d0ea5dede65455f0cd35e00e8e92ed2da9c7c6f085cc0d6b0efd9b755c9b1
+Clang.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/16821bd1660dddb0b807023a00106fc0
+Clang.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/30a3ff94e6a41a719d3b8cec64d9445f69f5ec697b2496dd0f637ae6ed3d6398df34bed47676d1ca8d96a9d83bb59c803246c64d65cbcc19f1c4536c4a83a010
+Clang.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/1d1640575d3ae6ec8c8119c01d48e4d0
+Clang.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/0094a40618ccaa6a1abb5f90f8ded22b9b13f3e1fdb49d71e5cd32666a96ccc02fe2555101b747eb2599178428841d97f273e9f275a2f7ec1666337788a50898
+Clang.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/c2e562ab1853b204ae278286bd08a174
+Clang.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/d668546ab19a6f101aa5fdf3ac81010663b3d1b05870ab413e6ca227901b4653c4ad7f198ed1f97ab33b7c679d4589451f7ba2acc0d17033f9402ab48c8179b9
+Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/259877c60e0bd46d38fa6f442e3adc2a
+Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/697fbb22251008dc0af7b85cd4aaf7213e7ab1c1c546df0d5df1a5e9bd7ee7d3acf7008059ffe6ad904719c520aaa7e11464b4bf639f5c15a752ba1ebeadc45e
+Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/7a3e2d4a5e1e81ff723629f0f4213623
+Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/6d5cb30265751e4486ac0ff8f46bcc305cc52129130ef2f2d79fb000ec375a402de80302ba42ce381342e52e31e3827dd3958bc4cb125e28b1890b0b6ff16f45
+Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/fc86537fbf358dbb05142e34a60a6677
+Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/14915a943536fde5a27e26d3b1d067739cd456f274f16772fa3e5dd114813a73b556663e406ce5370b3ca7ece201dae74db5c9c76e26488611b2e551e26a71c4
+Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/5efc569392f8892668f4b7c6b23f4234
+Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/01a7a29a9587ea9b0bf78cfec86a4f458466dd9fa3237a9caf55c96ab58fde10c60d5d8148b00cdff7cb74d43b93a806d704ca064aeb631d4cff3f2a5b63e547
+Clang.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/9b9db8d4a19045a4f9f9f6d443564bfa
+Clang.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/d32d1f731752e1f39fd5cd5c671d439249092ca2a7002c1d29ad152a273a56df03c197489dc7c52a3a2b94b7368934f93f3602cfe5a50eb949a8cfa902f4edfe
+Clang.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/e05b07aca51f3f463b2d77cce7fc3e50
+Clang.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/c17c396462785ebac988c52679517edddf15ccaa46357c4b8e21c939c4a23aa82503f5fada360d003e087b03b0978141780af8504dc7d87c61e0f41ea0a5cc43
+Clang.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/b28a8a689f053b5bc2427f9f2843a82f
+Clang.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/e7acc5e7eaff6fe784ed94240f4b9a7e3cd550b9c8cfd5bac7c9e8b6697a78ef876c52a2e593caa09938b629734361c30317ec748366fe26800c7b0419e86cc5
+Clang.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/12551be7929fb3bd8cbe3bc6346d17e5
+Clang.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/0c3650ddf008768300b4da3119667207c78bdef2dcb185d0986cf5c0eac87d59a772261de97f8afe2e872178f98bb0483f81e577d7398dbbef8d1cc01c97bf87
+Clang.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/38ae5bb94d4bfd9ae0cdd4adc7c46241
+Clang.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/035735f1724f93dd96fa60c0fb64453f309e3628da2a7373a76418a22c74d5770e99ac52d460559420454bd4d4e95d0291bd35308c542f3b4004efd61a528646
+Clang.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/5e2744c263f84a40e78526ab456b625a
+Clang.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/d3eebce8107972f693b2aac8d27ca724e8c0de382c3bf9ab2063590ef694c3177d2c7e9cc73bb359fe480413c817ce24df4994cb2f7cd14c325baa8e329ce84a
+Clang.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/5b35d50b46f46f84937207cbbe53f361
+Clang.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/7b1ff511a59e93aba410c2fae82c12a732efa8c6978e48a2d0ba480e3f5bed305c30b25a169555e4f23d2fc4c257e2a04150bb17b19c28469825e549c7a0ffcc
+Clang.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/89d5bc6e2ed559b89b1e69a062b2b0bf
+Clang.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/658da15ad6615e406e2f4117d6c447ca819383a2add6c236c8e57f150742ab4512c2f198b92c3d51f4236745aa40b8bf63d0b78f6ed0f3c748771717bc8eceba
+Clang.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/4a18a0ea6afd7708adb6023e92f81549
+Clang.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/2bc99affd9098c10ea35a90245006f25c10249616cea5395974502e5c82a5c48569e064c5c2436ed01348675b2b590b50fc6d493407ddf63a953309c225705b9
+Clang.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/f257257f8c4b05983e802bb32701ab3e
+Clang.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/3090e623585702693ea93b17564f5393f54a839f3e655aaea3461dc8cf6ba71a5191cc87a7043da4bde1c1bd5a7caeadc36b99c64e524e60c85aa95557a9b07e
+Clang.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/8550b772d168d5b8ef760c58bdf6897a
+Clang.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/bc35342a4587dff85acfd059415790b2a05bdfcf4e5657aabfce48fed34fc1ced89eb5924f4a03159736da2538954e049f2293ed307912d50e47aab3118b7fc7
+Clang.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/8c2124c8edc3e8e0d48b4cc55247b6b7
+Clang.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/a9282c87c8bb658f3f52ee2fa8c8636dded015b456d42a8edfec9f395185180b783b9dbe75d6bad4dc977571dcafcdeff162d5bb100f447c883b135246d8324e
+Clang.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/a4cbc590373f57422eef9f29d4174b87
+Clang.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/3286759915cc733f7aa3784e9cfa0e88c69a2fc6c3bf1bd34f401f7ada9db63c51f51e138c0086a4eeaafa8fa36bc90e11a56f57857daa4772e9c4d45ad5fc9a
+Clang.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/ebd1348b93fa59b64750230ae6c84977
+Clang.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/10f742b2db05da287ab7eea5d2c75f4c6dfd7798f2f5b13a6ec1da166aedf5d591a40bcc2df3383072eaf12584901e56f177d8fbfcbbc5b3b0db06e2d829c4cd
+Clang.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/739f8ba3cdc2afb4e03b9f03d4872cd5
+Clang.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/25df8931176dd77881494d94ecd52c4fccabf72e8d34d646016fc3cd3eb151a59cf994a796fd1f7bb776f62ca51cd03640c1c1817c857c117445e2c1ba3c8c41
+Clang.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/62714b3305623018e2c8c774509a8514
+Clang.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/cc95aed610963b63aaa7267c0d77fd57e29e19730d369135a27a9b3956837f34197b69af8239d38498cd004e9723ad78d279ed159aeef655dfb173f426420375
diff --git a/deps/checksums/lld b/deps/checksums/lld
index 590e2f3cf878e..6936b85224dc4 100644
--- a/deps/checksums/lld
+++ b/deps/checksums/lld
@@ -1,108 +1,108 @@
-LLD.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/0edc0983135da9e37b18fa3fe6d56237
-LLD.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/2adbb4eb76e72be28951c96140070b6d16c5144f689631d51b56365549a5d38535c1dbb5e351a6bdac4648ba52da02297591874193b1c16e7078060c99d23f04
-LLD.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/59b06fca083f1a5e9bf9517ae4f6a4d6
-LLD.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/7f1dc641df9288dfcd887239b86e7fe2871220b9d7f877b24b3197ab73d2176c4533decbea427b09e8f70ddc6c7570d31f5682eaed7215193e95f323769276a8
-LLD.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/c97e607a661b9ff571eba4238ec649dd
-LLD.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/7c7add8a0fac379b580a19a02966adca4932bd4573ba0111262544c0d935fc121c5aadaeadc97f9564331202b08c7366ceb170bb2b318db3425c157772d283ea
-LLD.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/d55ebbd25b97a4e4628fad1e04782056
-LLD.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/681729b4d10d8f66b0cdb89ca4500ee8a417561cc886608d06af0809d946bdf7cf5c6bda2b6d5d577bae3a15dc347568a3d7d7428568f86ca61327041026fbd2
-LLD.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/78b06e5a351e6eab372ae29d393ffdcf
-LLD.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/37a8b5fa3491ec8ae74da88e81a0c229d38166acbb46ff3f5a819034c40fa59ca2ebf4c0ed58e615baf7bf7da789ba86114738252501cfbd842be95cc2104dd4
-LLD.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7ba5b76c83d746a3c62354bf753db697
-LLD.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1fa403c8923487e2d6a8e8c1d86c2ea955ed32bcde2328cb1167a315cdcf704af896505e9c44b750ffca9e3ae66e805f60831136eb79fe1c6d58eaf81a78b1a4
-LLD.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/f052208026a0fd5120ea838843b244ac
-LLD.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/fd9ff2d5836300bcf76e4aeefb1e57860b3203fab0c32e668dce3e636dc362876d0fba1f2c23bf55a342ac17294c73e839a8eaf065d64d4397582dc212b8b9f4
-LLD.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/4d1077835df0f592a168c140ffe6299e
-LLD.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/8dfd44113b817f607bc38ac1b4ffb192be340c826b9bc8f9d41e92e0f0333d8fc4227f93aaed16a4b9e94a5ec8b79628f2d3a73fb644684a595921f36ccfbeb8
-LLD.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/0f31939f4ff00c572eb392b6e70aab38
-LLD.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/581441087ad4869cfdba13808b2d6adaf929ea1b38ce96c357f276d77c3e63439f8edbb822c8f41770cb61fc08837d7eed2466d187683bc44f2cb3c553e2e60e
-LLD.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/ca767173044b5a19a86c6a890dda3b05
-LLD.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/0577785079039b534fd736ea7a51d9b5176693d81e0bcda4fccd760d7c1218042999b6a38b973a903c0ef68e57dfb3b86e9e2f9e307dbaf603997a853f34eed3
-LLD.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/89bb950f17a5b792a6e60ef98450a6b4
-LLD.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/54bb68159743cd14ac0fce7f218a66ff6bf29e626df8dbdbd6e8581699d9b1d357a3c10d86c6822bde7299c14728bc55480f91cefd041d1de61cc179ed347b9a
-LLD.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/735e4dda5f8cc06934f6bda59eab21d6
-LLD.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/a9b91beed959804b9e121fee786f28808a7670fc5d2728688cca1c7e0fe56e82e47d95712e38fdfc42e02030896843c4b3df9928eb34c2aca9ac02262427c76c
-LLD.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/30a95179bef252aaca41984daa54c680
-LLD.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/0302db3c04396a30d1f6ab8d8d585bbe3a9e70342f068747ddb875b024c173bb9bb34518da7e76a10d3a325dfd741118f36f67fb83251bdb8a9901c4799ad79f
-LLD.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/4386c746c5d9b1408dbe7df04bc6a08d
-LLD.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/d71c6ebf5d3eb42368ab336cf8520afcd05470308ea117fe95797171e5c573948412ce777f62cbd45ee99ffa59cc769c276a60393a22fecffbeaf8b77b50ea35
-LLD.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/49287977de61b100979355e458c8970c
-LLD.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/85ed3b2c7d2478a307a393a2003e694fc3097cc6812143abb3cbdd73a7d36bcb6f06a7d341ea639b9849f714c2d8f418a8b96035ed1c19a3957b42d005c0427a
-LLD.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/80a97341c9537b8a58c7df23f86d5cf4
-LLD.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/5774b246ae820de4230a1f4f65bd683145dad5cbc4d326fd75649e06e773c74c2cffd48108a79ee0cc93175786450b6d50f7ac532e6f68961c18fe6119ef94f5
-LLD.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/6f84d6858aecdfd95726a37c9b6a0e0f
-LLD.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/2cdac9a810c777ec6d85093926292c75e4287f83b7224246f6fa248e3874a2078c46377cd5ccb0f36a5e25b139691f1111d705079e89ea4215c9bc8659414094
-LLD.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/d40f0956cc36aa7846630755a672a91c
-LLD.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/01368311a0ecfbe3f23514115f0bce7ce816c878815d937f3fa067b9daab07da0c02f520a96ad793212e5056bfb6294dd0129dae75f274dfeb48191e504c5322
-LLD.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/689120b8091b9da8cc9528c96f5c5df2
-LLD.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/ab78810af7d77116a4973b5825d5090133218cf08d5d77be14f83e028821e83493a112adf71094cc208f74cf4deabda63d7fff98866cc0304793aec9b27b7222
-LLD.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/5627ccf1677c48b7ef8ac9e5faac1d20
-LLD.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/454d2636cd72974c79c2d907e56e3c69c30c3fff78b199591c9ebe4f14d04c40c4bd7331f8dc2c957c37e214da8d28ef3a47ed8d3dd4ca9d480d52bab3429b39
-LLD.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/8f50e5f684c41845308c123f8e45a0d5
-LLD.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/21baf8a00fa65473ff6cf7ef2974ef88cd5b0eadd06ff85598de10d09425074297bcff3472ef001047a5440065a2de2fc6b1eefe3a32c7c1b3e3261165dc063c
-LLD.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/c2e0a5f58e38a9acf2c3914177ceb827
-LLD.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/2a1653d171a2ff08bde55c53973e62955fe9d9629388ae014a645d3199d8f4bcf0fb923d06812ccd62e224032b261c8ebed56ebebed750acbc87671203d7aee5
-LLD.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/fa3959aa413a2b707d8831edd2bd7867
-LLD.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/8b74fef916a72c2f4933c21d3344410c7e03e64265a44dd62cf2ef2ac0feeafeb2b443eafa5dad3d3d0028be96b9424ff67b16391f1b3a2185826de68921adab
-LLD.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/b0751bf7eba4f7f7a28dc22993eac9cc
-LLD.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/7510f7349b06365e9cd260229e7b8c84da26bac072c5fe9a4e59484d82a0753d4ecf1066ffe41343f881a682590dc9ee4ef4a49cd83dba45c21b8d76dfb80f67
-LLD.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5abfe9e960bab4c8a44f41aaccaf936b
-LLD.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/efda0e0a35e2774af2f2df53f89d61f146a5730086d40865d448b009c833934b23ea4b296c3dc3f2039527b72ef40493fdee6f7c630484f64cec2d1aebf4a4c1
-LLD.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/bfe87378e965050b1b20e993c8b13a53
-LLD.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/ef2fd5e81f349673417bffd68c4122a87c09caed3f6f8f0235bc70b75deca7363cad68276aa708fb9ad8f7edd249d49f78d9f5fe7b226b62e8604c7bd3d4b9cc
-LLD.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/4ee16f57d7dc060007250e17ffd55817
-LLD.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/27fd3a21bac676feb2c2c2363c027cf12988c70d889174e52c6bc1fcb4a93241f4bae85d5750ceba5fa971611700a9d15e3e02803cc14382cf6a1ab2918b719c
-LLD.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/06699da5617371442b0539203152405d
-LLD.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/83ba6300d5669b52c1913440598a2577106ea73e0b83549a5b3b0f081a94b6b8ca9fc05687d2be4b60c2d6a524bafd43b839082f0eee58b4685758061b229fde
-LLD.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/a051688aa3a6383b4be4faa4f4aee985
-LLD.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/2059c6ac6579c4720e7167cd547b679a9c1a27a2c68174ed543be935ee23122234b3f2a4555de0abab3a982aba73d1751db336f3e28005ce8e4659d61f9269aa
-LLD.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/600baa66310cf348ef3b4351ada014f4
-LLD.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/52b4718993d8abdca8ab701e86022367655d7927dabb8f3a8e41e43dbc90a9af78caf8abd37907a79b0f05017b6f0ef72314a187dab5bdac8ef7996e74c96e2d
-LLD.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/e1e12162e5c63141dd95fca83cf1be64
-LLD.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/ce21d1cfa4af89fee1cb13587e15d355f179d38a4a9b4ffb9f357d46fe9b7fed4a5cad801ddf75d66b71d77170427609a51144450f83c8dd59af5c02fb0a9017
-LLD.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/932639f712fb881f621e5bb369921132
-LLD.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/86426de75c4fd1e1d56e1bee08bb6447be0c7417f8492639158f436caa5794862dd3b2981f26f1828852f35806dd2177fbdaacbee67ea849e8de597948b276b9
-LLD.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/2ff9f42465eb6e845ed6b7567b9d14d8
-LLD.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/a19b985b28a642b9a40ef25d02d4e94608b7e5c9925db5202e9d34ca8258e0b02d758de5bbeed63f958602f7fb59b70c4f32434a59008af3f0dd1b757a20e2bf
-LLD.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/6de812afa415af04eb9d806adbd4b2ed
-LLD.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/c6799fb148f8b019d0b05fa707d58ac7f449347290fc3f47458cb84e0bef704fd179e6d29d2efdeb0c35e4ee799284f5850b1ec5c04ccfad45b38e058e449554
-LLD.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/331d844c447f564171345009764321a1
-LLD.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/978349a74fc5498408a5318c87ec6d25c01268b9d21fb85e6bb601243ad0d33be8501b181d1f9ab7663433a740912f5bcb7160caf1011b1a2c84fdd51e0fce78
-LLD.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8595a49c49e851973fffae7c4062911d
-LLD.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f707e514843a206b53f380c7bd8d4d8203cc62219344c1234416462dc1cb3d3f8a7452ddfd0f07178d43dfb193b4402a018cc465dc76b43b687fd20fa1ea5222
-LLD.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/5b4463e81c156dabe3d182c42eb647e1
-LLD.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/995db577d4a78d62cfcfca3f1fafb333ff26548b41d8aa8d763e4705dcdfe8005e2f68873faba4040599a6d15821a523261d0451d75fdf6e1c5224e8e777a71e
-LLD.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/d2f9f08cc952c0639f7ef1073c8630d6
-LLD.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b1cab7b813fe0f7c26c55261e8561295cbdf1e812db3844b87605fb527d09855f2bef4a40ddb0a7cd354c7cbb626293d4d4012f33acc242f9af4abe1dbbbeeb7
-LLD.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/e82e3b67a073cfa6b019bf5604eabf2a
-LLD.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/9bb18adf78afa9dfa0054e6511f5750a9e2fa9138aeb1bd83f7a51d37d031e2f3c151463ea8f682dc7130cb98fafae0b84c60d3befe27f9d0d3dc3334ef82420
-LLD.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/56da3cbe81ddff089ccf6b6392a9396c
-LLD.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/2af483a1761022dcad414fa7cec7fb5c6fd54be28185e49539f4824cb0b6acdc1cfa5c78de31268dbdc444201936c5a6d2e04f39ef6f0b9fb184985ba4e3daa2
-LLD.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/15cbf5eaf89c7b834ee19629387515a5
-LLD.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/75ce7c398bdfd57af2c09dfc946b024d5a72e90575ed92f28e015e620ca89e421dfc9a391f4a78277c3e06c38dd696d572c5601a2b1866e521dbc2fc5a60da56
-LLD.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/b895da29b6082cdff6f0324179352fdf
-LLD.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/e89a97dfd6c345158e3e12cdf97d33c22f849e5438401cf5a3670c0d1cf0252ca03e4c52475a42c3e6c2b2d689c2f53fc5cb7c925a23167ac51fa1a5e01e3d7f
-LLD.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/7edda2d8c2eaadec2d262ded2456934a
-LLD.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0b1d60840d638c0b0269b901a3f5198e18e244da338aef2fb49b474b3601d44a2b4dec13e258909985e363ef8a8749838b01dd195e05a266ca36e6d9f274ef17
-LLD.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/e26138e3491a053ea9a998dd00ad728b
-LLD.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1215861fa52b1ee21196bbce0e99912b25f887f5734e0c2628ac78c1af5fdf57c4d7cf099cddcd7031a26c60cf141aeea66a0147428008cb485c207e90801835
-LLD.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/a1e786ac775517b8b483bbe3f6571d37
-LLD.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/3937f156fc2fb8eecb13444c71f380753c16b08f29124228808c91ea4258ee2195219c4a9b601d4468cc24bd584403c16175518a620bd94a7dadff868b3771d7
-LLD.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/976d840de14ef6ee2c0a538197fe8f10
-LLD.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/7f58f975dc3d69f502537aca79509bbc3c4f5da2ff8ddb1c7e27180a6bb2123713eb42da61cfabd7a48a31fc464fd74554b34935dfdb3ec095d14ff443f514f3
-LLD.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/ab0295ba327cfa6b9a252b0e7a4b50a5
-LLD.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/7c750916d4157ba0a37cd1277a0f8faf32123dfc626ea76f848a7c567fd889a7801f8402a307c190ab34fc21b156f2a23967abc9972fc103e5847a200ffc7305
-LLD.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/6827f38ed653f33953ff7ae510a517d5
-LLD.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/f01c655f6433ec6808b62872b8fb4c5a2d8e187643c11f0b4f5c06e2302e462353b516f431c1e26ee60b579c0f8c8c6385f018db3011c619745a39f9ef263436
-LLD.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/d444e6188476c8b7bb6026aac6ea0a1f
-LLD.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/69510929896bcfdc4377b180ed206617f96e1fa13fe9f8ccb18d78958c3f9f951a2ff8ada9d1217a02407819caed5308d91bf8fd72434ba347f548c9ba000a5e
-LLD.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/728e79f334e5151fe5595711763baca7
-LLD.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/2501a5cae4e61302e44f06fb7d38d15a776d750c6e99c30f89e1464e836a29c735d40972d48d19f1b38aac3f487cfb532d71ce9db2df8bfddd03d1fea5f3750a
-LLD.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/2b64bfd4bb5f6be4783144c53eaba27f
-LLD.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/237d512962f0a3f8b98352a645141e788c1722adc761d63a4f0754dc79871912a2302a66bfdfbe80683ff3c6783dee0b4cf31beb50c5f76b6d97c978197b5a3d
-LLD.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/c23d2716a9ab651f64908da8fdaf7780
-LLD.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/78d6b3ebd845910dba5f147132378931f7e844a31dbc09a64222eca2c2f610b4e0134d9be184b9c80aef3aa2f4ac4d83de6bca7d1ec08fc775b066b67bc2a0f3
-LLD.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/adb8cf2411501b6faaec1a9a4204bd7e
-LLD.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/af9f3cd4f585b2c82dce53429b08d270c2be5114098bff8363a1777f82bfb15c40f59d4fdccb8ac06327d8114669a3beaa16ba8653027a911e654a9425c8963c
-LLD.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/1839c9ccde51b3d0830a365ede764dd6
-LLD.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/63b34855470c6838412e158334cbaad9214db8f4b7bdfcd6508c19fb891249adc7e89b0fc50ab52bcec17fb2603a68570a839700fd5ad9d1dd9b1b929bf08f12
+LLD.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/2515c9282eb379601ab7087dba9c121d
+LLD.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/0d0a6bee7fa181fe84bdcf75342397416bce00a3f6d40f0df34e9a0c4814a3e15aefb4a8fb1f8f63b2b4f2e8f41691398fc545d67c3783577840379a07d6002b
+LLD.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/988278a56d1709f9a52d4e59fc7b1dd6
+LLD.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/96f5c8ccdefa8dff272236af684b430c60bded64ddb9d2d814e9420992fd8c25e6938f155be8c47bccf3717ceff8213ba7b33642dc2c15866e70163bc13af1a2
+LLD.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/4760ca32d06be9bed2f18d8ce397bc84
+LLD.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/e4178ed3826c513be62ab51f10e9660afc5bdd7802f8d2a8130de4a8c948640525f85ad946758626946d63f55325004feefce2af08b6aa90aa0a908c24d47b9c
+LLD.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/7b88bdfb8fa1f3160b60b02fa0b7fee4
+LLD.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/05a5815ea20948a41ee506911a6d0c7e03d0a169b8c714720de466b48483bfd887960c454946878ac8040f64fcbd36f30657419b8b7051f7c67b2f9e5067b8f1
+LLD.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/4ef7e0fef18afef96790a1d8d85c8ece
+LLD.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/68813d3f7c10d64696435abd8d978257b5edd51b0aa8f8325a4add5dc4abcd9e14452bd208c1bc8396336d2fd7d7037b1b8b4f56cd995cb65406949afa0fb4b9
+LLD.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/128fd145cf30d49d24293866923d25cc
+LLD.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/faaea140bd122019e4914d5a6fca1af30a5dfbc5015c4650ac9734d489fe51db46428b3f58983c381b7d56802a1487ebe66d3b8536ebfa3d7b9a527eb7e5357d
+LLD.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/d78d58fc905b18232cbcce6521740756
+LLD.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/65190392bd91801269d7f65437da95ca98665264c9815223ee32bf6dd95d3abbf3c2404184d7b3d04ff37907dc901dc827cc92e63b58d119d42b08736728ed11
+LLD.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/0853474ca6d0150937b882578d488abf
+LLD.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/38a4898aff7d41553c2dabb4e81a0e8ba373ef4b7a6536281772aba4a1ae6f7df7b3ef80bc7e65c8e3c4f609462ea8ff96eac21822d7d17e043e020332ab325b
+LLD.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/81809aff70e22c183da2d369bdccc667
+LLD.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/eb291e31221a227c370d60c6ff7ab609ad4766a0b0e107bfac049d798873398d78206ef69fb5a1cccd14f8827cbbe15e12fca1882d14adbb2ecfe6f096411b21
+LLD.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/c9865ba23de7443bb0a135898eac573d
+LLD.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/1af80988614295b11b4263d1e27d182c6646137fb76b295524fa82ff5012a3333df8a07992c155ed2eb285d0b7c402560348ff7716dd31978edad5ead95a295b
+LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d02a04c53ffc1426243b848dfa9c00fd
+LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/0a1b933af79f045a8538b4a694c02014ac8c3017ed76b5e675c77fcb3b01371cbecf0260fe92e1f141388bff8be6ef271b6e889837051e66c08f14198df87022
+LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/911765f28d1e96d8540ad52a8a6a0ca8
+LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/55705692f7be598160fae7b8663d8f4394e40a016b0caf99132c1799081dc8f6f296abcc23505966a8a1247a468dc95e27fb072448ed7eb90a8ef022410a9898
+LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/7dbbcbcfceabb11f227f5f8a3fcbc15b
+LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/08912bd251628d429986b4e032d9ac0e6e3608318e8c3c3207ce241ffcfadfb7ab1d6b17065ee88965730ab3090e26014231ed3ae7681c5512a0cab8c1455bf2
+LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/01b0d73f4cff765c20fe3dea05b0b925
+LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/10e30133f5b68e7d425c9407d80c6b2704ebf2e4df7cf0594f0f6fad3d4dfac47dc7268503bd97e1fb679971b622116c95f4d66d502c4ffd5a0be995e014ae65
+LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a162866a5d4830debf30e1a7e594cb37
+LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/28fd908126506cfdec748947a34de59943215ed922299ceb2cbdbcfcd75559fd3e8c0f8eb656fab05dde0a94aa73475643e71db0140c18e885d60b0474fa50fb
+LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/a937f25494a6221ba62caf1863067bf4
+LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/74bbc42376571135ea3f37bbb9ccb54c3c7cf4d5181a7e5ce958e2eb85071859510247b8c2d1ccf1435b5e93820c66c5fc0751457b318530fba388e69ca7e40e
+LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/46cbfd0c17be90082e03e9b365b6528e
+LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/5d2d9d6fbc4439c6aa6e5af196c900efd66c65e91c06d2f88ec7a58d0a4a23d6659b9ba655f6c17450ff09cac73d6816012bc1b56907238ba6e4b8fef18cc553
+LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/dba008662626e1ffff3be471a6f336c4
+LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/03ef05fa73d8d867f619e7268266ba8afdbe1b91cdd1afba04f48889bd69152bbb73ebf7cb4b465472d5851ff764ba50c033ea7da1430f32647fd3c32504f033
+LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/fe5707850e6572458579a652b62ef375
+LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9575326ae0110aa0f6d6e6611628b40b49db19c2397154fe66aa8ce538ddeb517abbbe72f20f71a3e4de588d730916b556ab949ebf04c45e3c79c03519b73064
+LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/46ca92e8392d0e66189add3e07e0176e
+LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/b62ecc665d731a4e5397efcba784853dd94a5b0ca2b036c17f17910531ed96b5cb07332f13383f27ec9751a0066d6cce1f4f77a1f06f42629060e3017e280195
+LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/4ad63e824cf246445ae363145efc5977
+LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/914c388e41b467b59b5cd3f53a135662c689f62c367e0b010d7faa01a94338b36c3ca23115b37562bcbb2060914603646999351efb2672992d393135bda8debf
+LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/64964540adbc4da2d9b3734ffb3b5414
+LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/19190d022c9aa733b2a3be1ad523c291ee187569ace0594eb2d18959486e91aa56e8440f3ee715801ed7214bab6cd348679f2851c6418f6133f84479a5980587
+LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/014f16cfe047ba26323d730171b63efa
+LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/0eb6a94107b88675a9cb5c6e514f9b326a6d8067ff32062e10ab63961eccd6b44fe784b888caf0e5b1a297641b2a9f943caccbce18df76a100b1183b6fb78177
+LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/3041df8d07f840a18f9a3712ba165a11
+LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/01954c0c500eb2dc85a896fd0604672a432c86781a1a25818bf6849e350e5e0751a0d3e124a5dcc3cc5ddfd6130816f00024b5bf0bf062c3fa143b27f7cfc7cf
+LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/00c8d0195d3bb52158e25d96f9667cf0
+LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/504b79e64929b8f21b05e9fbaa4a2eb60b565ba6b4ade3369dc1e38678bc094344f4ffdde657b41c062e951f97701c6ed58841b66f2060a21274202e2cbbfc69
+LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/a81af919513dc7103d5f65748e99a932
+LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/9d6c0311113d998a2e2f93afaad2b0155bae6e37dcaa0778879259d61ce1d37d54ccb169c06dc7911f63b0184499cf208a72d4b330198cf5282df15baa307bdd
+LLD.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/39bc3ee14a07b7a19149e74ef678b2d1
+LLD.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/19ae60bf3efe9347eb7fb510437d0aa97039bba7f9ac0e0ca50fb5222348c6e8fa74920960d97e421306c9764921f3b00e6e79410bfd355719304709b3424a3c
+LLD.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ae563cfd3b9ce5ca8de3d63c9f956d29
+LLD.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/11b036eafb2f2037382af2a6e76901ecfef70c120f2b33d7d9621d2047cade9082e184580c684e1d6a70f92d2c33fcb75a8fcd78ce047e04d57165d532e191c9
+LLD.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2fb700351f0a990f8b61ee854b1cf52b
+LLD.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/474cb28550056d2a51d95ad6ae806f032a872e69d72eddcf039cbfed21d1d3c182caad73a720f11c2173f20c63043e352d618761a15535ec3e8071b3fdd88cd3
+LLD.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/5ccc80802c4053ad1a5fe351b45d33f3
+LLD.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b7349862fb03d4c29b1018ad7ef90ce056e8d40a3340b10af754a1cbb06d4ab494d7837c274de2a7e13028d3b044f11c39ca3bbe969569adf4557e6402191993
+LLD.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/bd4b518e05a13241809a0cdefe05cf3a
+LLD.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/6c327220fad9cbaec397078232c6e800cdc824d6706a4453ec03e016baf0a86ef2c082df2b980196d1b10ebd2d22c74fbb7b92cd90e7fd902372a3a176630bfb
+LLD.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/ff60ea3e401a5315560d77990eb1261d
+LLD.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/f018c307b47779cc97368762e1edfa63e0f9c354166eefe706f2c398599b30be7041161e08ea5276b75a826c8bceaf250330e1231591b96ca430bf674c51dbb1
+LLD.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/9ff7c7f20eaf5ab1a8053037e5b50e23
+LLD.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/f3508b68727c2c7890928975fa4387009edcce957f6942c1ac9db0554c7b3dc3c6d9b22bbe543910d7354717bb292d30d4468f48b9451adb0f305ececfd5a528
+LLD.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/48f6fe99a0d2f67ef378b06ffa6a1386
+LLD.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/59096b2f9067d49e9eefa3d5e4356e0bf0a6cb2c7b8fc477ebc74603f2ba0c6a5e7c44b65080fa73ad4d2ebe4377b9788e370e311cafaabd2a95f76be383c240
+LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/adbac48e6ea29783d7e0e0a34b0a74f1
+LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/c589a430dc42d2f2fa8334dcc6a992e2776d4a3d1e76c435759b99b200117710c4afbac56e02d7c0a6285817e404a62b11833b570eacafb1ef871cec0c3c7c30
+LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/a215122469aca265bff80e6c8948aaa2
+LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/519f835a62ba7c3e27169d94e95f3a2671a82ce37ab67af79061b1ae15811d6974f6e0788a9979d510cef4aa2e444ce90b358c8655265b26b4c569e3899700ae
+LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/6cdeb73fb0f6a1d305111382b1074b16
+LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/8a86e431e5d6ddedc52a38bafadafef4cdfeeea2b3be34793ffefe240ae1a0347adae2a4efe783a493377fe8fc30a0646e68a1acd868bcee9e50a2b486611a42
+LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/d8b6577c4f0c6286641599cb0a0b7abc
+LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/fb6262eb94adfb3ed1e81c69706600d00e267176d40c3ae6247dd7c0cdb4248d041083a5ad7c83fd9f307352f4a22d1d3b10274b4d43c4fd5c47a68189f22de2
+LLD.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/60bd90c33a864d74a6c2e16a43599e78
+LLD.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/1f6b39e41a892cbaf1435d6ffc4ed8f80c2418f1a7f6feeb1175b38620e8294b00a96213e5c3c13ca33dd2e57493b03cc4417fb786e98577fe35224a0d4fe8fb
+LLD.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/0b003a8140dba5e1c0f4dcc9dc56f83d
+LLD.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/f56334c7d2bf42390feb02e3b4e4261940fcf731a5d6083d9d8d52f75006f72866b8271951f2ce8a0208ed624fb45f5254978e12ae805b75a391b9130fd3af68
+LLD.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/5e755233a506d16ee5b83e84bc776351
+LLD.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/4ab51f3375fd33857e3ab7d58f8d59f3038747a40e14473236b830fb8924f8e8460e44dd9a26c545e6b0f236591d72fb23f0ad0d59ebf60ccd3dbf268922bb23
+LLD.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/fb0cc1fefe0795f3b401959a2ff2ec42
+LLD.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/de8899449b864b698db37acffcf94e4f9dc14b920b108b4289c3bf1dbae87d0374361e83242f7f964983117f2978d2c7ba1509111395c063b70de57ee71ff632
+LLD.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/d86e2f57b0b19326c99d8bb24ce70238
+LLD.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/e0cc6552b92f9246b19032d18a0a2edfc65950cabab3ddd8a5d24eb56b34bd735a3d1875714a8cf1a7771fe3cf3845de53d99198ecf3c3298d152e1598f57c5b
+LLD.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/b7a713da29369a24ab4c293280527552
+LLD.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/de33a4d3134c339c7669275018e18bd1ee34b64fd58dd7ac509fffdfcd364732fc8c2319a6664cbbefd9f2461b5e83538adf3214564c7cf932cf705de6fef709
+LLD.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/6b2a3d6b923387a5667ac8f2347f1351
+LLD.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/d4a6df10c8d537866e85676b116c1ae6140c1169cee866ea1b5c45831f3610f872a85eef9e925651dcd9070cec53ae297de93870f29a582e8bb83678b0d3bd7a
+LLD.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/b0179804d9ba8ee1567558264c18263e
+LLD.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/d836ed00ca3486496488d7913de68609dd664924da65ae5bfc1df2ace7a7a8c79674340e219c3d1ca62e9c9d4d7f3deb4b56b3e19b19ce2cee2ba33a07bbfe32
+LLD.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/af12ad9a93df90946b85872ac6b9ef79
+LLD.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/894a5f2f3599cf9a88260bf07fb0ef382ba829e9bd8aef98770adeef995f524e8f8e35e5877181371a02a2e9035f9b5cf995532299dbd645ce946739900be711
+LLD.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/b1161814ecafd0897ec8bba22a9dfb8c
+LLD.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/e1c6b33320c50d68914b530add1d5321baf385f19a4392bd1babae98abb2ec8b155e18015d712f6e33f7c9c08c8a27b565ffb986989373c98773bf4991a8b963
+LLD.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/75ab6b8e7ddfedf97d5a97027be1d390
+LLD.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/56c8dc096650756c0dcbcbcab1fd528755873b8fd4e502c0179ff83dd01c4832f7b8a2b474b62bd2fe7eb2550daeb9bc4999906e84fd99598b15a199c5c83443
+LLD.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/45b91d8869d97e7ba12cd125fb2ccda5
+LLD.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/e88eeb4d357cdf57a739803897fec1365cd43cb57d62f54b479031b1c2d1ae52511397c4c66f1cc1465580f077e5b121275bd70c5fac29c841cbaab599679173
+LLD.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/c2e9acb2ad5943920e045baea06d1ff1
+LLD.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/07eca55d28508fa500a7a93d3fc599460f4c894bd6c1979507a725f066d5d17b692e501d56861dee9bbf002629e3841d48eef2b65b3120ef05d3daefdba8f19a
+LLD.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/1b3227e17ea0a65c2879439094e2bc2f
+LLD.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/68b939ee717f9f751359e6ef4141ec4608be6926f72158b8f02128876fc97be8c255b7a27f8a89906de8e9f5f3f77eb0b83861ff46d614c2a33f349a254179ff
+LLD.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/f2280fb244942fc505285aa415359409
+LLD.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/770abd9b2be1adec57442b4bde0dbc1dedbf78e60a8589e3e146bb44b2af3fe48cbc8ddd7036a8c0eeafed81b45c5d0dcd3a298876e98a1b0039a77a210f6778
+LLD.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/b12f9686b2bf8bf1022ddfe5647cc32c
+LLD.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/bf6738aa1f8cbf749fb110fadabb23e02a137c5e55e8ca0e1cec94b517ca6a314affc3da4899cc6e6f58a7f920dc87e4de939069590b5e516176bde07458df43
diff --git a/deps/checksums/llvm b/deps/checksums/llvm
index f9bc921b4a8ee..c0386f3377a85 100644
--- a/deps/checksums/llvm
+++ b/deps/checksums/llvm
@@ -1,111 +1,111 @@
-LLVM.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/8b23ac6a55ad8a8a911af1cd2be84f7c
-LLVM.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/60df009ecef6b7d435fc198dd477e9198e1f96d89b3c583b06af5b6b938b9f4d545f75f09d0daee93f94448f6fef36ca2e0b541e1179280e6d918b02c619291f
-LLVM.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/649c61e6bb2ddc619d2f967d923a62d6
-LLVM.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/864910013f659f473def2a5df78adf5c13f6f84f400d3b87c5660ef51a97c86520a73cc6072db2ed739f3e7e3e2d326f34634bc9ab432edbab59baaf2085f4bf
-LLVM.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/2bae4d31c56385e73f3cf667e5cb5582
-LLVM.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/27f8479a639434329fc5e67326df2c22aacee61237cb1eb1bf9938a58b1dcf883ea0476a066dd284047388a42a3b676c37b2c800f97feab694edf091aa10a8b7
-LLVM.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/040485a871ce0036fb19f3e9ab9ed1f6
-LLVM.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/0472ab3fb75efe1b67ba8c34cd9b36377ef9206506f741ea9a6289d3dad4ba4d0560578661bf9e433b51c03c77a9de5ed23df37e160a9225bcb50c27e5431e76
-LLVM.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/12f54c1888f00373ea1e8fcafffbc313
-LLVM.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/fc246d39c1711cc041b014a77e8b0c9fbbdf86c92a1c027e35a152d18bf6cc72d8b059c65457851ce240a5c745ebd39934ed6ce6f553d408ec8ad4078135c746
-LLVM.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7065ccae75d0e16876aec6d96de41409
-LLVM.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1c0bdce88797baca3188be7927d7694861bc491b4ad7970e485332ecf36b28e121a57e3a4ffbe83f6919f00da66d04d7809c589b8f9bf4b9940b15cc5c1590e0
-LLVM.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/708f78fb147a1a5455b1f0e27e0a8946
-LLVM.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/f7aa0dab1f2b0a7dc5324ef1ed9969e31334245938f2954425eaea2c034072d844a3c9eed8b522bf1794a22d822117d6beff6c23872c875dcbcdd7cc719a6d61
-LLVM.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/eaf4c42566b3ffbd6c3fa3fdab126d0a
-LLVM.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/7d60771a1795fe328c8f5fb534580d34016f6dcd85c268e94d6ed8af7e68fc74e3bb25ed8262bef4100b9341dea180a2961d1705e453d37dc5d6a01ff9b00ae8
-LLVM.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/f4ed6360b1e46be18392900cf5e6e413
-LLVM.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/0dbc3f7954ef085bff00cf1a7d18bf338bd76f67ab98d972a486942ade7f11a6c9761a4605ae653402d867c543a065d6c238bd6a375852544e89eb9f9cc6c335
-LLVM.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/b8cfc0edd85f79fe0ee22b84b9271d62
-LLVM.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/8f8b5111223d433bbbb7ec48df5436ee5a4c21c4cd57fab1b6a4121d72230251998035c9d62993d442af279e3d393afa2df1c161af2762420ec149ee16f01833
-LLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/5cff8a24ca2d1da58ea709d34c33decd
-LLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/2c20fef573744dacafc6333687be408b474c9773c558fe08ff1702d1957aac3bc99dd9998866651bf9af7473214d1be236273725501cf9f5c38d1807f1605456
-LLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/2721d242b457748e3f8301b085282c3c
-LLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/8a73828ebd84e683f9a043007bba955ca85deec608d9602fe29ef18fc999b4959bc8e87c865bcd060adb8b4c15f8cb04113027b37c3b4e075cc8c7946831a52d
-LLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/8c8171ed600e466b022a96956fb93e69
-LLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/48798715ab9866528d55b0c75a9aa6a87e03b771c3a29b0f3d88bc8d89845ee8f39ddeb6232a0337eb1491092322fb7617e5ebef1e55c0bc4c46f05ed115a0f8
-LLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/8343d87440928bdc76f0209eb905fac6
-LLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/e20a0fb7e3cff62832ba840782b84c12ce8ac38cbcd0eff82dbc6a6ab5cd58c59cb760f5b85e4e60dec63aa274e8e43035c5e1fa5e77639d607971690487b3a4
-LLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/f6a415de133867e9045c5821ae2bb286
-LLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/acd4c6a31f998f506c747f3d8d4ddae393f6a58a282a928913d4eab850147e485e99fc953d4847d00555a1bde295255eed530e4dcf1dbd46e62d2c0a4df9c4c3
-LLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/4164c3a46ea05eeda4c471b290b9c782
-LLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/c19df17b57f67d2dd281f1939462250aca5b6cfd99598b0dd45eb76ba46f4b02c4e3ccc8e09ca57843c12de822a94df88d5593a34b401050f148452986094ec2
-LLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/1d3bd6f4770fba34a9f1b14a3871665c
-LLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/686a8be7a96e37b91d70bd06259a8a61b6e8d2fbb3b28d9252b987b7ed58ae476a4cb1b773b143d41dc6de23a7b969cedf35c9b8070052a7b9882503379d4f6f
-LLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/3783a3c99a4c8c27ae367e5bb717cf3a
-LLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/34bc40f96d054487022879477eb826ce769b507c90de9c481107f582a1c995a9af9172d1d017eb30e6a9875f68877c26b76fd3ec48a4338c9e5608d970d012f5
-LLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/b6d3fd4b5460fb336ccf71ed4f27112c
-LLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9558ed5556c8c0ef5f3882f76bf4f4f5ba8bb642eecd3a6f9f7d4ad82c0d9a15038e8fda0e613eb614b747ef045e3bdb1cc3cad6a674627e9f54e56abac67daf
-LLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/37ef614a98b59a8100ead9a5a0b3a369
-LLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/02f99b72dd23aeaeb5326c555e26f2090c311c8b111e3b203235ac503faa3d8499afda2e3541d0744dbbd8b6451c50d377b09ff7dfe37d3934b931e31b643640
-LLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/f0b6cfc6d392e597e305a77985949bbe
-LLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/9e2487984369a573e000b92899888ec845cb76dc20aaf200eaa1f52dbaedc8311c4161f3c9febce47b077be86aa8780c6d9c550f508c6b4949d76d236ecefcea
-LLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/a369c3db68953d38d71d2e342ebb72d4
-LLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/e0a4f18dd056578b690903dddc971aa91f91b194758a4ec69422f4834dd1c85224bdfd2b95d6f801cd4d23aa26c09a104452266ba8d61b5f1a429b57b2f597b4
-LLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/ab49be8073da48f3a353346fd6d9a833
-LLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/3f0a76b3940a918bf8206529a15d538db59e4c419cdeb4af0f338d343912d5708bf89ff89435a95b7ea42d3d36a83616a2f45bd21e1e8e4a067df5be22898ba8
-LLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/493df42ef5cae32a099ca7ee2c2dfb1d
-LLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/ac27639cd6273f6dd38bad0db9bba82f1dd299d9260c6877cc4b876d4f82fd518c758aeeea58b389e790eb7e212d0976fd1af1741e7854e8c287c4a381c5f0dd
-LLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/529256ff2095f50c1c57356819122ed5
-LLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/3922fb3a3419ee319392c68124550824e6644e7a638d39ac2831b6595c1e1fdce6934eaadb74415dc81f6ab349714e5443f746a61c0d8927c78b51987dc95a32
-LLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/82216b18dcc9148c3cdc00bdaed163f2
-LLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/c212134793544ba37247842c733b540055bb987b0854194d038f90dabbdf9ab5df6ca1e64c7e85d8071263d0b8f1d2feb99ac9d842b731551aa58ee2be2618ea
-LLVM.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/465288c493241318c5947f756319d2ae
-LLVM.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/4ef949ced9cf6c9f30c56388a8e53eb67c528e0635bb3c00d1dd204c8b8f74e72a6bc2104745dcfecf7c653ce1499d86c3a7acac98b565546b3826230710b92d
-LLVM.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/0437433a85900470209cde06ee185e9f
-LLVM.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/efa646ae330dcb5d4dc40a8e91a51248b55811d090111deddd415e22d8d7f26009dd4a124756dcdb9df4d83804f11576b786758692a5e82ceaefc88de3b9b00d
-LLVM.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/895eedc69041096b1643f66976f2a51b
-LLVM.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/dab5fcbd7e48e60c7d16031930e954a83a87e705ac72cba3f660bd569fa8b6a05d7ddf2551eb8e5f163d385c31ce197ca519e47e6ccf85982c6ae7072c6a301d
-LLVM.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/083c0b15d8747cedfd617a9127792ca6
-LLVM.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/427d8caba92e5bc3f88b9f33ca951fdb01dd6ce94bd852af61cd94f3476c35e82f9c387989c5847af8ae65d5e9ddfb6efc4afdcb57320bac1115b3ef23e9563b
-LLVM.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/0e0a82a95205bc58a31ac24a7d479d84
-LLVM.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/4472eb1cf1386d6754ee9fe2aed514b656ce34c0fcf478e3dd0532e3010e2fbd82b905060382eb661e7daa48d1e44e4606b1bf3625f539bcadff3f13497ac5c1
-LLVM.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/91639f25324ac04119751f1c4b09c0ec
-LLVM.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/a07270a19a7d8ba5dfdf8ddfb089ea19101ef9386b3d418353c9fb7d2812b3b6bb68dd3e170fccc0f2ae7a7c7cb5a0bbead36580249726346a04f028ff4f94d6
-LLVM.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/6eee5cd139347f0dc6c0100a1fe34e78
-LLVM.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/2e8e4a14e0822b5078ee1dd5580a136f2e75f9e58a065b83cb857f7f2e17a5f462c6ef8a41b383c3c9ddc54e31876709472a53787b5b285332802babe9a41744
-LLVM.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/b4df578f69f7ff1a43c73b92f8b2fc08
-LLVM.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/c965c4b42b6b22650f329d1187a27523e2e1ea6032de11f1cdb6a54b79871aaa260716e84e38ea5c8692930e1aa6927f5f82617a096bcfa10e3666e37cda50ce
-LLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/ff278e2aa1a91a9bd6dc0d240ce23e3b
-LLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/5903a1cb350391f7e15ad81ed9c0690b43e267c5b061e011c61badbf324be544287869fbb4c2d68415c4621ecc37cc798762cbde34ccb64194547d63cb3a980b
-LLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/a02b1dea41d86fd28411798b535f7674
-LLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/7b6c94d8e60985206a7e6faefaca1dfab04a1a1378e8b52cd981726f6b6558caba23b716d44824fdb9fb54c16ec478e8de4296db9b2ef0be67680784ed26831c
-LLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/1d1f3db1b9a23c5948a5b982b46e5de6
-LLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d741dcb76c3a143fe3b000999a627ba4a3abd36d738028e739e96c861be661cd1de12f5c7ee7e03826b1109aea11e80371d18865fb5332d1834f4dcf0ceca245
-LLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/3ed7af8b8e34820a83a8459edeb3843d
-LLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/eaab7e410cb433f2b83e6b38671a6e7489556865cc7007ce1588c8fcb0421c64dda480be231f96b30ce6fa75c2d9e99fbdb2a6293fa108ed9bc0599d2ca2ca63
-LLVM.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/88003e4d20bce7d175d8e4db003e0eeb
-LLVM.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/aed46b6b3aacf7ef373f9812da24edaf71ff1a382299e5f15eaffec605bb308fb3732846b9dde6d3afdeaa010de61773ba0e725d41e3b160fab37d2d0cf389cd
-LLVM.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/ef75e04e4946bb58091eb1a57b08ace2
-LLVM.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/7e6ff0a8d511f19eb868d61fa50ff8c0014da4ea50ad960603f0851a6c09a693a66baea4563af6cdcf2f2fcd018bf2456a9e9479b9278c656ef64f0a08aa11ae
-LLVM.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/95a8b1fe9135120ee5fba2441ad16f2c
-LLVM.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/167dcff24d6144a4e211ee473b389d5fb4daa51d4ddbd98655456d3bee6c00554b91580a627ca5355e5c2d38a9a326f13c13454de64c0cc32a1f214a52b21400
-LLVM.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ba2fd64dcb09926f754fdde94ec5cde1
-LLVM.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/fac4e6ab8875aa94cf6cf2065d718403b733954c18b0f5dee11148b70ecafabd92ff23155224ba5628c743fe963ee82a376ba9025f8ec8ca199a66412855ecd2
-LLVM.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/f80738de98ca42cfc8c4ef141ec7cf0c
-LLVM.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/ddf7670f555db3916933ea202672c7ffb51d254422af801ae928fa3618b3b7db1f7513710576dabd52f219cb2791e19803b5a4f3470f7ea05f71b0b04b03aaf4
-LLVM.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/a502a8057b19bebe8aac1c42d9cda20f
-LLVM.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/6e20328737c46fae6204cca68b16fa72e55c4b00fbaf8470b4847a869741fc0e2cef0da2ed9507fc4980678500dffbd42ccfe9f173321dee633bb0cf5adbe57e
-LLVM.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/3b06471de330c6f4a53012711c7c9d72
-LLVM.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/c19a9a2d8e4d3bca25a1568b0fdc01653b0b467dadc68967c4ab88512b4b78cab2e829fcfcd3d1e7139ad5bc3fab62dfdfd50be57f0d0099de383d820dafd306
-LLVM.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/06a632eb722009eb4bbd49689b49a8a8
-LLVM.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/67969cd09ab313b395cdf9f614dffeeda1ab72b2fa9e68057bc8dae9bad36d39443569b91ad88bbab9a6309a8084e09d40dff76d5d4bd261a1553afd5c3dd6c8
-LLVM.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/bc000f09920a305fea5b32cf2d1bebd4
-LLVM.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/580a3b12d7620d4c3148f988125d081b3fc76defb0e78702286806e08dcecf2b9c41ad8071334ff1e4e9ee4155d8949d07c57e8470109c01acecd2b37a07083b
-LLVM.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/6cd4cf2922f69efe968637d240bcfd62
-LLVM.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/7a23f48faf2c4e85247c684bc43239a21ea0732c980b4d46b50df27857f143cdfc081bca867a5692b086d32ff9031a230d496c0231d3ccb5fe3f48beb6ad480e
-LLVM.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/e7c54d9144ba36f697cd9be10e8e59cd
-LLVM.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/bd96434dd2a79b335bd7169222bf5bd78fdc00eeb7ef2f364bb5ec71071d68846a0ba6b51d5b182522e6ff577d8e3d7ca3c014962cbc04ef5a04a7157887cd6d
-LLVM.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/22005a7066939bef459f0fa7ad8508a4
-LLVM.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/2742a12f8a9054d6aa70fa823d2cae8126fc7a591849259e92b87b2e6b90ad7d21ffd855d34e08999600a5e2b591492502788d2ebd0a2564325ecc1860607b50
-LLVM.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/bdc275515045127ff9883802963b3baf
-LLVM.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/0fbed47ab0a14116a4b1f2b866ae65b5c81cc08007150750964eee8ac09a2a90afb0ba35d5d6447a33c75dd68755990a85e8874588faf84e7c1174b0c4f61c18
-LLVM.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/657059eb6dc68b3fdc56ea167ebede2d
-LLVM.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/ebdd42af6d04bd98d9bb50dbdb36b9f5087d9d303d5671e96395ee6dad248402bceab5b4765f0fea7a8381ad3fcc17aae7379206903c8e4624a4dadd5eec3faf
-LLVM.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/e6e68533173f74000ee4c1c84c579a28
-LLVM.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/8599d6ae2f84272ee4e8b176ae517ab3d2d25b7617c0520ee70cc33fdce9030a76205d3d9abc3f21c83e33258c78d52a31e0bab50a85f2050c4f3660eee378e1
-LLVM.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/8add628662e5b234c20a7dc986749dbc
-LLVM.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/047ce72373190ac36654d6c931d00a0b766d0fc5bbc8e9dc787ab9c97e7691908c61d9edb13ee1608b38b10662dd8a584a019bde36c339c5164b1bb8e23837d8
+LLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/a70ce2a3f17c7f1a5ca012cb54824961
+LLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/fe882bdeac640beba174498dfd2ecb388db1fa1265555047588d0ad250bc673088b9611bfdfc14689e65fc874b60e91474f912600c395a25c81b53e69f298f7d
+LLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/dfe8b093925d73e04b8fe20ab1f03db9
+LLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/09dbe669fd5cb3680e1ede7e3f2bd2efa50d30a231a459ef498f172c9066ee2360d9012bb080abaa880aa38a01db9808ba5ac656edf395857b3ed683e688c514
+LLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/5ef95fa3fa21127f2445652c22dece6e
+LLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/e5c3e014a987ec0b7699941ca1543035cd8b1d67f3498826fc2df48944579ab008a8edd8b8bffed8ba0ffeb543e815e8a26495de028ad86cb5a1aaa160338866
+LLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/1a9e4424b89695dec44dd683557e2849
+LLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/6de91e4ba3a8c8cdb04f6c829890a6bb74ddae1fb90076000ac11031746129ff818910adf7f9e6300550efd190b9fda5f2493ff3e4bef3fdac8ca3bf97e6ccaa
+LLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/0b05b71ad4721dea3815e1e2454d0133
+LLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/a191e2d7a4dd3a967fdf7b1e8f27a5ac2a0738008026351a27bb2aa188b2cb086b18848c99ad73ad2e1a350863137619c9bc1a51371baab29f1f1698e15d03d1
+LLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/a80354c67defce5ad7b989c4f3366008
+LLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/82fd3e66b46ec56d2affeae043462d01933ea20677ce44f7d1e25a3983ba2e34c018a7287125a55e62d9a3346bd330a2df8c3c94326a393ef04a9d8f01beecdf
+LLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/e0400469dbc86855fae49afa2de33734
+LLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/52acee4ac93c17596e430865ce877c92afaaae194d616af930003e51972dc05348d0019325af83d0949b7188e3043d7f8b893837a65751cf55ecf4985cde8fcc
+LLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/39e6aed193941fa8cb05140071443492
+LLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/c9e565abbcc25a3cd731ff1af92de94c3fadd83e6ebed8c9d9d25b259b32f22014404027fcd433484ee0eef2b5bbc9398f218a805f8205cb5dfa61257a034c90
+LLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/ed14d5afbf2b8b3654a683ad1e04af31
+LLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/4124a866e55f5b397d1ead170548c13e004105b2947ec0c8ecb20d021c6eba2206cefb63fb005e899c338583b56c9a0bd17c94724ceac7edae844a84a77c0a8f
+LLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/8361fcfe223d65680625c5a20159dae7
+LLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/385be5df02cb44746365da98feaf7caa2360cd3203fcb4f63809dd88c52c90a479b4ddad592b46f1fce025fb305aaa7b1a02ceb57059f598c95495cdaf52da66
+LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a3852342bd1ae33e7af332008c279654
+LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/a6b97c22ba365176ad17071b91546fc361b28ac03f1ef521f41106eaa1f66daa06a90d7d483e8e64bcf9778a9ed74ffb2cea908f1d53e8000886554a2674cf59
+LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/4175eea371b3c2087838761f90af9e80
+LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/ad6d824d03d262098348f04a8de59354b8cba1ead11c3b3c48b74dbf78b5e03219f6cfd7cc9eb48bd13b624a20fb524560565bc06290620d0583c4218fd8ce4d
+LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/b58769dd16d41cc232e0af0745db0c0d
+LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/aa3a9dd18439977ee2a9946325e873bfc65f01d8787ac9ac42f44b6780e0d8908c072ea410679dd463bf08ce539154bdf5a5139d6ce8032462137126abfaeb25
+LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/f06631ff471f4abc3ac775f4160c7d43
+LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/67ab50784ff858cc705ed2748898b1892c21a9ce21065cead4a62c2361c7a9f053e562ee27a629348ebe66f41fe078aadeca67526c0ed70148bab7369d8bfdb0
+LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/9a3cf1e8cbdfe3ed895defe91c184107
+LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/d1fb7496f60d152c35e5974b15958f96ef30eae118d2fa09fe48058db4310ddaf88a20eeea995b6fb882412ee9d23760e087836f7f93b3ac64818f5badfa3dba
+LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/743bfb035a17bbc85de8202e46631fd9
+LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/86a737660325089d9973ff1de39d471d54cd2994ab3b8b24dfffc5ce2db2188ed11af4c4cbb7d6eee2c55760d736b00974eec7352c36ed5afaaeec65b83c2f72
+LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/6a64360208288c31ea44ac4f7f6e7f73
+LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/186da02c1bea8f65e9107bf1712db4b93acc78622c0a57534e7c342e40ffbc7fb4daf675e66879ae2a58835657a673f3fa61b08452fbb809838ca65469f75aba
+LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/50af8192ae03a8c2586a6e3c66490df1
+LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/44e41c8064bba44705bdf1ac8e31a795cfe86c6697f48c26b8b87fcc0dad1083bd4ea203894a06530cf59ee646259694dd7732c7d3d99c7c1632c8ea3be56635
+LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a2263b7edb6ca4d1654d264169fc1a34
+LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/c95c8bb2eb823eae849d04235bd2754c0368fbb91933deb4103cbdad4f49437f2dfa9a59a656fd6b5e7016de189ead3961e5c2bcaa60b0511d8b9667e84bddf7
+LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/72fd40f0f2a14d6dda0ab0ea76587b3b
+LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/1ab3af3fdb4442f6b9dd1b954ccc775f4815159c3af913c6101319d76715c691216818f9c35e6d92be95d457f198d7dde6b4fc81fe8af71f47a1dcaa74a35ae6
+LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/29329543013995dedb79661591fdbe08
+LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/40f75b4409a5def7f41b39c4e4cdb31dc81ed027005281da2ec8ed5ebbd477929d2a1aa1177c33b6c981ef6616194e0b267fc5d9d0e8717c05e7bbea490ff257
+LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/2f21a287b77d37fdfd03d20e21ed1378
+LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/24a396cf3d963f476a02939e8d666112ef2fcab1883e46243ef166dc13bf354356fd1db9ca8081a2107ea08d015bfec3456f8a4ee33b029b8b7958db7d631400
+LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/0289c0b501b8bcb693a1c92e10613727
+LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/ed91a1785a193f1ad88f4c25467916a9c97cdff470b6bf86b640e296193d338f1ccbf380f1a89751b7be31ed12485665d0a77abf31b879a789582f5196f50406
+LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/2b01d3ed13d8d6c2f1981f6ae2969405
+LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/eba25bf68431d480df175706a6a02612aeb38cfbea08b9171e6da019b4bdb1f5fad2f357a7b1cdd1b06353558e371868bd5678275cf5cfaef3095f261f401134
+LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/0721db7911f73b5806d467d769ea7a8c
+LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/f38d2e09f01b566a845e067514cd653ace5398578148cd8700d27077abd4d3d71cab29aa9025dd7e7f0383b0307c5a88a0666b3978600d2ea3840a5bccdd22bf
+LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/bdfe5c46ef0b04930c5ab2595945e5d3
+LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/ad783a4b1b1f5d54e740cf42840d7ed24ff9d2e512900c08ea16356def2c8158d5d1c70f3026f8cb5a0b4b4802857c6f5090dd83ea871f9d5d3c4a7a22cf0e73
+LLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/f72efb9dba006c308cc791389b6eabc4
+LLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/dce1dd64311f840fadfba85a52f41a8a4eeb90244a1261de5360cc911cdc19371a0f12b7d67384ea251105a6eedc91a4fc615b87f63fd9ecb6a4d2ae9346cc53
+LLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8fd06e11639cacc71ba363017cc9a82f
+LLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/6f32b44bd4e910aca8a9359eeedc8fd038001e0eaf0c12b34c07fed78546ca6d06ac54e0a1cb43846b19a1c7389729616fcf1f39db41450fc5cb7e54a8572129
+LLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2ad4cda8bb5528f1b187fc66f5c74aea
+LLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/199fafa07917f05b4b9f3e18a8a59235aa3491c79ffe1b54ac4acee41b90df8bb630e789584c8bfce6d60c454e5c7b24c7b424db63458de0916dffa3b28ced21
+LLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/781bd8b1e041bc05600e4d0fe70fe125
+LLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/02bda3d17a509980e3a1b1464e64ea80879e0759eb5c5f706c913164af5bf83b19da96f05adcbebdc02566ee953e69adc41da7d752e41533ae6781d22daf4404
+LLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/6a09756d6d1c4a2fdafad07a55a4199d
+LLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/f55038c9446cf6f2fd305e26097ca208766ea4a5ef0e875510b43390fc749b1a123376aa629287dd2df0608160c37bc8c5d7579c2c63abbd798839b5e628dcc8
+LLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/39f7f5a20d035a78305f0923009b4bc8
+LLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/22ecc841945137e2dcfaffef5cdb51fa19a9b7554367f4c0735f2d9399adef591af234b0c9aced763fd8f8135dbfad5f04dc915175af8c7f1853a961e67e3f85
+LLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/ddb8c15c549c4dd1d886f0e3e3b01c9e
+LLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/c484efa3ca5fc9e1e570a97b02f06ce7470ef46fb445f04118dee460682194de2363b55b0d7217c4535bcd0fc2dc5d7f032a91de75ed028c37fedb8955f1275f
+LLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/6f9957228785593507affbb5751d855f
+LLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/ee45945e4133c12b16d12ffc761eadbf218f2d527e54722d48aab60f6574f57c13f21846f2d786a9389eeeb32908fb11c438e38a2932b1711c9cfd880ee5440f
+LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/c51b915e22e90204f7309fbdffcfe8a1
+LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/5a44fea5b9caa9c933350d29b23c8819f0ad040d62c7235f4612fa8ddc51c352803c7b9a4c92d7eace8543e7138cfea639e68e8529208291dfd443c4810a397e
+LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/28d9ad7228add4db7a12545df5d1a35d
+LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/6b7e3b6a4523a66237dc26563b8706769cc6b7228fbf61e4e6804678ced42243434e42c7c92421bafa88c0bd761fc8a57cb0c5225ab3c00a83c719edb2d7776d
+LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/256222a8980ee3d8aeae284ceb9e9704
+LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/fa61dbf7051ec054e2e85e6d486ef8522536512a092ff10f0d46fe975aa3e2ba3d7e8ec98b3bc99d7d066b5c694f07b97c46ea42ecac9119d108e403ed05c83f
+LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/ff364000aa8025b973923dbc89f419b9
+LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/0c90ea208dac7f3e96f4547565cce4a965cf27eabe79e1bc557593524e9f723eef8e4a1cbad1fab9004a1b94d34e8a71622fed40feed693240d1c923cf1be18f
+LLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/95b33cdcd79b499f8d862c85a81acf71
+LLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/8f89c44f53b5561a8d949089bb3237e1f82952f45cc540c42e3f784c399ac0435edca90ad08966a200dbe194026fd459c63750aba930e11cc6da5e2ec1cbd475
+LLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/1693403dc93ca962bd081ad8271c569d
+LLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/8364ef2a49fbf6442b32279326e5494491a501e466105842f8ccb7d9b259b91fdbd296d0984222d56cc9e4be87464b9d6f279553a967a148b2a6fac662ee6d68
+LLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/859698c3451608193f1bacbd3d893a12
+LLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/284094eaa0b76092cb62ea1a55ca03d983f1b1a904ce52aad12b4dd6adfd139d738e8dd9df0f004c544f905d5454dc166e9e783646c7b60367fbd2788a108ba7
+LLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/95c7e9fb2a344e6ac0252878fc12a7b5
+LLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/b023f2b762efd971c825bb1d34d591caa198ec8ea75742beab0b0bcecd50173a09fdfdd1dc5e8aa448ea5244c2c1c34218c96005452b95461cdd26c76619ac53
+LLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/43de4986e07102480c22658cb3ae8592
+LLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/4a55b9983d19f1b012d80303291420a0e98e9d61644ddc94b694faac7e0dd575a45417d177ee822d9fc9f001c23e5b6ca3c9feee0e49f34088f657cae7278cc4
+LLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/8698009378fe086c50243d908d45a085
+LLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/f264e5663d65cf6856547fde0e6800b8b828ae77c49cf87c73226bedbd95f71f4c12598bd26b0a47e3424bf710a79650b255935eb5e82c4e3b7c6845066c77d8
+LLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/1ebed3977c754042d3fad1c8a2b5c471
+LLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/b374a6cc383df97c71ed16503d8af7e0713217705a5b38fe9b137eb2c0df1a69f28fe7e8a96e496ce8cc63546e63ae262fca139fdffa0cfcef3c9b2b0a412f7d
+LLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/7a7440b35ed8484efb1a7a66929e7a68
+LLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/9856dd0395ff5340f3c3d4198f901dd11e024af72cb61cf146aa177c18c06926b00b9848248c1d360f8b550d8f0a7b291966ca089591655aff865519d152bf4e
+LLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/8a3b05772a16c58fd37df033adfb68ca
+LLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/62ca5be9abcd355e18ee3ea3d120dae336076b84ab877d2a796e8f138f9d9084353b592c221762d6e4af7beb64587497d4e27edbc6b371afdbc09e926fcb23cd
+LLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/9e88bc5575372bde26d67342b375d41f
+LLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/e1b377008b3ff6626608410eb6d6cd77cae32a73ff3e2bd042cb9212529089c80223aee8196fc04966072e1dcad46ba4d980a80426f0b5247da3e4087dc7fa24
+LLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/749af273a95500e67ee926c30bc6bbe4
+LLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/961550ab92e51cdabffe31c4210953f49dffdb962a29ac3f02b64f523e70434a0c0c842077d2eb9bf064b52fb14eae0c345e80c3d602c7ac49ef982222c2abfe
+LLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/65052109742b92529cddde9c21003e9b
+LLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/7e7992f8ac36b427a3639c58109743d7c7134f42eff768bab248a33c7d890e731704de949d107c63b30d1644497eaa230150c575d059fce50e2eea2a9f8c2ee5
+LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/0655017c0caa7d90e1d36b2bf5f6672b
+LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/1b78ebd6dbf6b83045f9d4df7b45b84e930cc905b1cdc2204ccc5b550230fde3c1e61eae60edd3821cf9d0854a072d03975956a188fc6f64d50cfe62046cfcb3
+LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/755c270d98e648dff4e1a53bf6c11e94
+LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/3bb2bba0bf41f0d5a6cd92b7fd4f39e2b336f10f3011b0240b14c5e90769d6d77f6d0efa81f577e6801748cd20da525c0f4b21449c5d8c014f7f94ec30490670
+LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/006b00b828e176f8f29f292fcc247297
+LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/519e9d529e27111522eb5ab7c1b12b14c7a0063c4d1d74a5522fd387f52f7349b975ceb23c687b39837752afefe154ceb325d206fe376813f5be626f8f7552f7
+LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/f5644910d8072e24ec4e0126721a01bd
+LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/b8bc06cd12e56d2d82db8f960172a99af1aba51748eef369cf95cad57107b95cdf3c21f534b48cfdea714e0e23df1a29ea82d961a69060b3649c0b043c20021f
 LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/md5/b95ad4844e649bf46db43683b55b9f4f
 LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/sha512/15e0996aebe6db91fe58121001aa7ea4b23685ead3c26b5d89afae34b535e34b4e801a971f4854d8e1a1fbc805cece06272470622eef863e225358113a127913
 LLVMLibUnwind.v12.0.1+0.aarch64-linux-gnu.tar.gz/md5/6d8783dc9b86c9884e0877f0d8ac4167
@@ -138,115 +138,115 @@ LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/md5/54ac594b4c8e7f261034a8
 LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/sha512/a43756afd92081e6dd7244d162862fc318b41ca110a5e8be6e4ee2d8fdfd8fb0f79961ae55e48913e055779791bd1c0ecd34fd59281fb66b3c4f24a1f44128f0
 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/md5/83cf8fc2a085a73b8af4245a82b7d32f
 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/sha512/297a5c7b33bd3f57878871eccb3b9879ea5549639523a1b9db356b710cafb232906a74d668315340d60ba0c5087d3400f14ab92c3704e32e062e6b546abf7df6
-libLLVM.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/6f46148833fa386b55dd92e946561c85
-libLLVM.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/ea1912f9a75c07374bc9c22c7b8b4321a0700f4ea196d29169e14a648a30d164897215ef4c4c6478810e5c5cdc76b1f2937fec4e6b0bb3e4f579bae06a219d0e
-libLLVM.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/0f2558df8ed485a93837e790bc646018
-libLLVM.v15.0.7+8.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/e7f962c4dd9675b6abec6129e7fa460ba3ba4bbe9eead4f9327a1db5fc9c64651d7424f9439ef396f0546f8e232bdc34eb625df0fa36bdfaed0e6b7af4dd0070
-libLLVM.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/3317b67ebfb01c8d3dcb17c04d0f5ee5
-libLLVM.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/383ec73210e00b02b3fe3f247bfe81a8c81668d3faf59c0ba9b0f032c41603807cb65808f28fc8a91dcf7cf72f3f5fa3bc68277bcb17cd35ec758ba3dd8ec857
-libLLVM.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/f49e5ae9b0eb96cddeb3d68bec320d7b
-libLLVM.v15.0.7+8.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/e2cf6ef242479bc781f6ea70d7123b087370bad917c8f398757ba32d9446ef3b8c3d3b813be2c1ad3a8945dce1464551b57d3bc40a2e063199dfe555ad697dc8
-libLLVM.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/e8eb2e0bc1b0693fbdf01c9dbe0e0170
-libLLVM.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/245a157bd6b49ece87075d6250315f419506262c43ad6c5c76340d60ca1eedb00dab77c6588b91bb5cd8033e7ed1d97c21d801f8359486c9c350ded3bfae7642
-libLLVM.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/60dea992b59646da2d719185f32f4a7e
-libLLVM.v15.0.7+8.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/7fcd64e51c87de8683923460d4596e406c5775d2ec6b7f4111bcb0689692dee09584622ecfae17ce91d1632f03a37cc9d43696190a5b92e916f4b8d4d0a50003
-libLLVM.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/86385feda64011d17952300a29a28a46
-libLLVM.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/2cf9f4934932b39a4a0195eab39f28c718c7cb5b830a425bddeb2f0a643fe6a74c7754483324f57e876ca8b92b5cfa1aaca802a44dc9ebcde86d8875c0493952
-libLLVM.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/72cd1154871445247a6af96536ae1b51
-libLLVM.v15.0.7+8.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/b35740ff38e77c2b718f151e3ef55831bb4145d164c9c74bb78b7cce94693a6accb39cc747c67171cc43c72fff6cc72b3a19ba73e4dc8cf127ffe61f640ceac0
-libLLVM.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/8dd9a908e0d94695352762d87bb5cfd4
-libLLVM.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/3d9fbede7af089548bca9348c5ad13f146386ee4e2391223b4f9d299f9a52f7062dc758ab098805e481f434a5057ed37cb031d48de7fc3eb3137699f5540587e
-libLLVM.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/f55864a3ee48940270502c637412dd58
-libLLVM.v15.0.7+8.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/c52bca8cb48cee54ad86bb86696f489d6a6d471238e49affb9af70b0e88ec6a4af57391a72f88fbea31f7c597a066d57978b1d3ea63a29cfae559457c66f6e06
-libLLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/20d1d88a807f96b469032e5c932c0696
-libLLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/d6cdc9746c81c504faa968638ea9d7fd9ded72ad0abdcf6c5adb8bcd127126d35506c2b6b3bedb977736a76318edb5c899ba555ff1d05df21f797a8f9a4e5122
-libLLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/b4d7d4ebce4c7bbe3ac11cca0017a67a
-libLLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/bb388db416d805ef5fbdbf4d2210d4b2188d6eae2c864692cfb1da7ba89de772423667e4648889db7cf43d9127aa13f77981d0b99ef321ff3f09faf7fd4b8bb9
-libLLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/b9382496b307f7e72fb12d394eef4e39
-libLLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/122a5f8daf1240c5d7b4f1926292311a3d287c4461516ee3321d1657ff3c9ca5caff54a1298f0d2a2b4c19627a57d626a4fb4455921862d87fe5897d672bdfae
-libLLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/bd564398619c3338e509e2f9ef7d7ba0
-libLLVM.v15.0.7+8.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/a54812732e95604031ef1fb420057ed40b909e211a68d5a533be617556c7c41e4022dea35fc6b8c81d8cb1227e4086d46b345cfcb6022dad9efc456ed85d7825
-libLLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/39daf88d35f518325138f8562dec70dd
-libLLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/2b2fd30a04cbdcffa57d12ea2785e3016456fbf1dfe99b74a1628ce213bdc28d65f8c6937175c700c0df4f5f8f1c257ef71f27d1d5cca2c5efe5598c893d5011
-libLLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/af88ec70f786750081d2948b6b9fd0ba
-libLLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/f2a6bf3d74ddd06115d4791bd7ed833fc9ff1c24c0a317d7756d181f7cc59d21da73e085abb7ab0b46a12b0cbe4656df0e9e509b057cdf7d3d0cae2304f6b39c
-libLLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5dfdae75a373ef890d7e6c004cb16b2d
-libLLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/3993609a2199c78cc12f430f76c2c3b58b0d6f208271bc474e3869d9f505fadfa61e1c2c5774ca5190c7886cad68507fff9a0f6d11641106507fc4b5e3bc8a41
-libLLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/e426a70337cf4e38ba22f64c9adbabd0
-libLLVM.v15.0.7+8.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/c5ac86c22d016adf70e77970ae976a5081a85ebe1943a46fcb93be53f85f82e4aaa724e41b450306d0cf50dc4eb64367059737b6c828eab554f6166774201310
-libLLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/523077c1c0fedd6d5e62536e933b2c8a
-libLLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/246df1e0d1a038ea2cb77a9678ed0e13f568ca35bc2c751547b9e871163c0dd7e18ea321c88eb6c9b2ccce9ec4347c29c69e5cbc41dbbd43d23d7a658ca5fc15
-libLLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/23aa72bc1511ff8f4c09a2bdf70085a7
-libLLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/4d1d46652e98e75925478a86bc3b2e613ce54d3e99cbd75fecc637dab70a72187c36a979e2124592cb764d867c39555c013497fc3438103aa320fb7e45247254
-libLLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/ba162cc558297ef830f94323e351aae0
-libLLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/f98f1c74f5fb3a1e8936692c0b9c57fb8da1ae8fcbe187e019d61ff6691cbcdb03e7f53b5254bd219856bc3dc4408cb29926744f6086a13c3a32e66c1a79f422
-libLLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/9b364f0c1f2bf550d5908407120ab68a
-libLLVM.v15.0.7+8.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/c7bb0a90cb24352926c6a0d3599490db75f84e907697f48d1ac099767f4d3480e94a6e19995bd16d2c26c7cac1309bb579f71208899ce83aa617ec06cea2847f
-libLLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/06ff2d8850863f47c6d7391d9bdc4cd9
-libLLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/6d03c53673b072ba1936124b681219ca474f7d269dbeb3c0278ea88aeba5949a5af5388f3776f9bf5c1f05fef81922c9720d16fbb57737bd9b83925206f46cf1
-libLLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/7d37c75e75b9fa3e5db8cc2422a65b90
-libLLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/ffdb947940a033a01d0568f25018c125a743f3c71ce46565965ddbad52bd88596092190070c827aa6f7e70e22338e5d5162dfcb008deb80734f59d35437b41ed
-libLLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/c31df5def85016f499c1a7daedf006ef
-libLLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/d1b7220c0037450ec6efc4a2119c4dc4b9c48a20281c60b923f33bd80a9d146a69270983fe15cd8623ccfbac6c4bc4f4df3b44ad36cbcf86da8086f932e4da4d
-libLLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/a178f55baca2221e71a0badc79b49bd2
-libLLVM.v15.0.7+8.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/d613e2744c59b845b8893eba4a4579750d9dd4bf4375837aadd963f051475dcbf074d254dc8eacec2f4b2f77a9c1cca68f88b7948df8065910b1b0752dd2004b
-libLLVM.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/2c5cd46b8a66d959807f4b285f5a221c
-libLLVM.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/43061164687d44c1aa92f11198e218af19e96b1fc6519a2f41a2626302b3089beda58d24040e3220424e718366c761c41a064479411c8c923eea1708b4bb4c77
-libLLVM.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/1a0850a7e8c88088a6c26a50cd746396
-libLLVM.v15.0.7+8.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/57bb6a55f7b84488d72195e1420826e94f082541fdaa0f981da1abcd8b1fb4f0a12f1398d786abd51943c6920513914e9476a05c7477b2e003e30a068304f0ae
-libLLVM.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/538b7f590bfe5145c39c06aed74c845f
-libLLVM.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/98e59c9a2354f4881b61bc23ebc34c2f70e6394a54cbc6735a56f59688e248db85b8a674e1e4a2a60bb8802f23213767c17985c44eb530743132d3366b0ed2ce
-libLLVM.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/854ce5a05f524762390216637048a2c5
-libLLVM.v15.0.7+8.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/028714472e5e5ae01b667f1058dc704b051030c8c95ef4816aae1118aea6442f44d824e48c13cf4111f81ea151a7dd951aad40e4c05208730da4a4f9f4e52c3f
-libLLVM.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/dc6aabdb3fff4b33a9eb75ace7e6615e
-libLLVM.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/457a1f6d28b287033f501247499c4a9871be7db7880b65f34ab615846c06759fcbb9b4643a6692f670d56bb2346311806475fc7bb82a699755ea6410dd999d37
-libLLVM.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/0578542bbde3db752171f9420ce30d74
-libLLVM.v15.0.7+8.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/93a8310e3b5bf85bcc7d1b20ee836805eb087a318bde258d5117babb877689e05d5a0d66e8c00946544b6e07a322c2af5bfd1499927cc325a98fb5b6aefdbed3
-libLLVM.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/c2b7dec7d566c3f110f84a69e781866b
-libLLVM.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/44652389f9aeea2a8ba4e49bf78fa7d11ef3579205f178af844567e8e999917d737e233fe74a31cb3bf9a49847e364824109634e6683b75096b3f45a9fb4150d
-libLLVM.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/1c13dbb8577ad9e7020059a474560286
-libLLVM.v15.0.7+8.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/1d3e4a06f3d6ae3afa976713ad8937a51c4e9fd0b544c1e9f8c74ae8579dba29fd8e77eb8acec0873dec8ec58fa91bfa6738212a504769807a758caa1f203b2e
-libLLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/ba4c9eceaa281a177f1f8b878bde35e6
-libLLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/c0f8fecd3f6e1b342a075630ef0fbcd76d964e9bac08ac5e8a48ab0686c0ab91d327c263e045056a66b93f44346a0624af1687ea36d7f3c41c94d23d33c0d2ef
-libLLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/396cd763186100f920279ea551db8d09
-libLLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/c79d60d522b4c186b51b7ea50fa8916ec63f64941225d535f8cceb25e3732458291260186684d098776091f8ba235c7c890fc635e8f39ac3c603aeb7c84f0782
-libLLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/8288ec83ada261b340994f5ea62c2efb
-libLLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/c612e99e655dec48f0c1b2b28d5aa999c3ba8e83f7796a1f2807074ceccdb08a8b6a5e3554eacfc3ba7a99aeeb8c6b28217cdc957937e344a94636920cf288e0
-libLLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/039c44655a46ee04f7de2b184bba432a
-libLLVM.v15.0.7+8.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/a47b840e221933001b9366aa90b5862f25eced86bead68164b98ac3b095a1a948a9d89a6d2f9e7db2fabf40df4de211b5ff5d7d10fc3572c24470764d14a559e
-libLLVM.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/036be0a300369212fe943134678ba985
-libLLVM.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/7dc49931b9775372385a61cd9de441dae567df791c83adcdacd45602e8cb64848895b26e8c53476fe53d86d21a06a00c21623eba4ef71ca97a545bc4fc2c5b18
-libLLVM.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/747b5946945160209c2e5705a0ab0bcd
-libLLVM.v15.0.7+8.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/da1b2b543c648e322a1d87d2294a0cf87f4ae4c1c5b5708a3de6bfd29ffd589f970fa8f01182017db1743bc53d6726f9118438efef07484c7388ff0b0918c99b
-libLLVM.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/b5eebac2361874017e0908dd2b655953
-libLLVM.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/b3e1b05afb00e44d1b6b1ce9adc6934e2f2caf1d8bc8d112a7aee5526a39cf77d52b256b888bdc54ac848a98aa2714c6a8beca5603fff62e974595f2c2ce1b25
-libLLVM.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/16864fadbf7366031ec0f5aa69a295ac
-libLLVM.v15.0.7+8.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/2099f8f4167f7a96ad2e9145e2c4e26d201aececd8a34d21c1e21b3865e8c63192cfef6e012863a6920b55d7865143527aba17805412b122f1fa0e2ff304b515
-libLLVM.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/3146935cca2cf625311fda3df6860aef
-libLLVM.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/745310983881e2839797b3da1f56e4adc115f34ac932215546ee1bbc869baecea1be077b546c9a68dd0fddb89551dea19ff181c691892e572f86ada885da3bfc
-libLLVM.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7c3ba44af8f1fecd3c370614fda602dd
-libLLVM.v15.0.7+8.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/ddf418ea2dbfbb61ce4c977e0b0ae29137e378458fab37b5fc18db8a7d196663d7012e28161efbaaa75824ad0bd0c16841625349d89c8e3f7738d973e760cd27
-libLLVM.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/b7985ca8dc4eb2b89239ce6e0083db89
-libLLVM.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/babb426085a330434ffca6e55d1b237b780754845e4699621ef581b2cdbd803c0e0a0b3f91693f76848ba2cf1f177b6c342ebbd459d9926d6a4e0b7f4184de18
-libLLVM.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/cc912aceddbfdd5278f302dff233aacc
-libLLVM.v15.0.7+8.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/fbdd72353b76cab6c82af9e19e7f2abc7b5e19c634abb66d25cda0276c79e4c75f14eeaa8de6f03197a3b69cab130f0693bc3b17f144bed476a2e14268f2a5cb
-libLLVM.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/e9bc3f99cf16ad7e37b6f8692610c0c5
-libLLVM.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/b7e0b1b1804d3641e8763eb35d08e1f9c9c2bdbcf9d129d1fae5835067d5b6ccda1acf0888b686c5e8a268b14fa455f52451e3cb6909446c9d053d3d1d261fb2
-libLLVM.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/ba454f84baa9f746de63e22714c740f2
-libLLVM.v15.0.7+8.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/2b61a1a6693c7899fd9af8630c9eb45b54b6c84519e50828d80a6f7eb88dfb3df6ee4d473f8e30ca11a0e1db2c096711164dc08cc61707277f7beb1902930f43
-libLLVM.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/1ebc12781d75fa94145bb6c7a2ba235e
-libLLVM.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/43898f026a1f43ef035999654555afe4410425f2b6f56341100115e2a66825843fe93777c10ba052d60562a64a1150095fca4181a1c09f0820baa83736611627
-libLLVM.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/7259f7a15909745b0176c7bec2d5bb8e
-libLLVM.v15.0.7+8.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/fcf10dcc6bc0bfd4389859db1ab6a827fcc15368cbd42f1f50a2b7a3e752c4cd2676e65fcd69bf0eb42579293d303d770e06c6d10150ff17d7fdd6fc71d0155f
-libLLVM.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/9ebab83ab97a6cfef7d745e799ce39bd
-libLLVM.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/8892e553f08507b07b62e4c7859f3499a47e3eed5fe773e61c9c2831150fd49a06fc25e164b7053873c97830755d478c5527d23598ce674eb2e13246a64d00a8
-libLLVM.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/11915b49d288c71d78bab5c114bbd5dc
-libLLVM.v15.0.7+8.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/0b38cca2f9492dabbd49a411660fea39e70c53ba105db7f8eb6a616d108ab8dee4b015b79a2cb34e75b91af5941d5f9acb2630f233ef9edd4f99118302a68537
-libLLVM.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/e2de9f36a69100387209f59f99bd54a8
-libLLVM.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/641aa82ab684656ae82f12b19bf3d090080d62d3c933525f23607a85da0ed1f1dbdf02c30120994e52a447abf86552fb2a3e0ab70f718c4baafc9bc8b01fb17f
-libLLVM.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/596a32ac2f4a2e4aedcef09cea7541a6
-libLLVM.v15.0.7+8.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/2ad659ebede4fbd2b09d487bd4efdf050988da7267797c4b884387f35c5e02cc0dbf93f56e51316dbdca3e8ffd6a7d9120c2cf10387fd1fead4a05d81366d83e
-llvm-julia-15.0.7-7.tar.gz/md5/20678ba77ec517e16df67b6683fe1fd6
-llvm-julia-15.0.7-7.tar.gz/sha512/dd18b1d1817d7bff23bbd9598eb691e2d65ef679666e7219e4137223e739b62d5f4ef11d8c42474438b954026e0c3f0c5e350d3df23d8b4b294765d8d7788802
+libLLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/119e6752a47c65f2eb26becb92b0d1b6
+libLLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/f83e594967feaf6b5aea1b81db28f36386f2c33b28c63454123c4563e235526cad50446d153d0cafc41a39252fb13c62b9a9d9489429bb263e61d9ba54712a62
+libLLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/946e446b392d33f6c42a3d6f8d854079
+libLLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/f5fd00286b65101b644837fae104c24cd8c99c79aa5b952c0fb3855a25377626295cd839cdecab7b839e3a75d5b2b852fc3a886c71fe0f5f4ab78ad348609c45
+libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/55f9c6f7a51f5310da2d0205ce181c26
+libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/89cdb450885dbb4f511ffe3939afbee607bcc2e8568e5ce6ac34bb36431db3c7c8ca3e9d59a27e2ccccddda13ecc3c5d5ffe7a19ae63f909718a731f5c27067b
+libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8600b413e657ad169370d2e07d168aa7
+libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/ca35d96928ae93ed36ab8274c67e5e8a9a971d2b11a3363313f3160579871856cf5c92a8246edc404e10bd44a21c1dbe66941995d87af5efe34b10882aae1df1
+libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/504427a6bf7adf4178891c37a2cbee09
+libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/3a4e40d3ce7ab47987ef604275759cadc171a168638781e74396e2cd48bb6a8a8bc0983ccbe099c2bbb43584d405df63a214d5426830863db773487733688121
+libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/75dbde809013a444c1d9db1556b7e14b
+libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/37a72c7dc0333fb6be67023447e82a8f98ec3b74c64a3f08b5b047feb585fa8f35cf397ab3db3eef512ff0a7ace6556c3c4e685df7ff22dd095515b77b3ef8ca
+libLLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/e92dafe7f987c44f2a860db03bb6df05
+libLLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/31bc73561d6ee24bf8eaad8b7cbbcf1a3713814058a3db47624a05ce572e407241cb7857a851a4f12f93be0df4f2341102e0d68c8371505fd36ce19069e48918
+libLLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/6b978e264a0a1131907c817d4f259534
+libLLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/bdb4976a3d4fdde5885f930a411da895600ef1ef76c8c0f5d6929c9495062600dc422e87f7fea4af12e169f508740fb0701df50ba7e9c4c1c332387a9b7d4c6d
+libLLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/ab22578145e661333b4e4d7369e5ff7f
+libLLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/4598533c15224a1543fcdd84edbf11ef9611dc4cb22e16f4bef66ffec65e5a9b5a0993bea9bfe25c7af4bb0447af0f31ec82b1eca01cd96d8065bf82007e58b2
+libLLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/9ceb4fc78861ca7d687646350a3d18b8
+libLLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/158f0bf1cf555e5c0b79c1bb8ab9cf8a2c434236f5795c70e9c08c2b5c01da4d88a59cf61a1215f40e4046d3875dcfe2fe89c56e9f6ca7088d10c1fc044de22c
+libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/0172fc1ff16552478bf00bbb480b08a2
+libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/710d392dbd708208eb0e2149d87603e2aa4fa99722d50fef2e2ed8c9ba5fbb3b4dff3208a1ee390635eb885aab91a7b228083424a9ca320578b25d8e391d0a8a
+libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/c9583dd988c03827d08afb42342a4893
+libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/0954a6c774befd092d59ae228b7a48cfc509fc89e215e79958f460ab2dadc5f7fbd46e00d9c3f0032ab96cd0300aab4f6cdb92488cdf8619513f82cf56f512a0
+libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5fbe9ce9d7cad44dc57757ce537e098f
+libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/b275a24bcc051c25fe57f042518749afae00df2ce61491a70227a7e2e5fdd793e069597a1d19d148462149e3bc0e7d7f5d6b578187dae4e791ae70fbe063e14c
+libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/42b7d81dc8084eeb385c22cd4b43e34b
+libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/75ca00734dd52ef00f3603bb8b89d9ffbb45ff145d2557c460dc856802d814e3ff8e02af1179a18ee32edb0552ccd4fcb44cf5b23b682af164969433916c2d47
+libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a138c265db068e53752ed917ef9afeab
+libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/b66106cc2d348b262d097158ecc0a5ce604460b2de6e1f2c04c24f30a3e7a4103a2c775f0ac1b9f9ba2ad23c8b9a472d0dcb5a266222149deb6fe77611a245a1
+libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/d1e2420d0c90443a2e9ed805e7f36bdd
+libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/641f40c2bc485a09f69c38afed880987562549342a71d8626daceb444d76d71d2ec7bcdfd23e870cc9e216791be223599d29e885856a8be4f394b59750b23a0b
+libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/03e52f6937072c2bb6ec1fe6e62e6181
+libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/30399baaaf445c45b70f0fd4c95b7d9b63b0f0b2213d4817913b2ea28c35cd1906c398c8cfd9fffde077fcebc43445d6b5bd992ecbe9859e74a3122318ef3628
+libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/12301c5764dd64d924ef617547dc9b8a
+libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/3d11ba6018f67712483cbb9c52e686d69000b39964e908e13e6695832eb1e6e9f8c764669cbe487fc8a9ef11b4619bddbc9da42210f43e4f60984813cd81b1b7
+libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/06c8c80bff9e49ee05f8024f527b925a
+libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/671c47b9f03856641eb0e24cb4d08fdfc2993bc739d5cf11857b0bbad517fab490b2259501d2efad84efd295ad7bcdfa9d0b4991425f7bfc2538b13f7958b556
+libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/a7d88848fd4ef9dff68aa4f1294a272a
+libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/25e243b38a1a5bcc1c01f9fcb69d7fa08ded91856de0c626bad22d472c3af77c3ac91d4dbbfef198fb90d21a7cc100eb461f66a21764adbd867fcb889121aa9b
+libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/c6cc7b104317544312531f2acda37610
+libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/e732b0af56e5c0efb9bf15996bb398ba6ed49bd5a97517b742d54cd16415830e6bbdf4427ea6e07f316c720a31a279220e72e360128cbcd867520a8322690594
+libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/2318d50e1541d7d319ee23ce1eed268d
+libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/3ff0a6d43cf26af45e51d966a4212cd3a7b4127cb7dfe6742ead34c489f1a6487c06721591db4e26848b0d42abd49b0a970231f2a1d655c46686f163c7fd3c0a
+libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/560bdfdfef0fcab6cb71eefe82412f30
+libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/8d1960d83544e4f6c1a421f4f74f17cf05503c52cd3b5bc2f3dd544aeb7b533af812e1ec1dc113a68396ea66adba5ce01019c97507f8115ec087c95456cb8bb8
+libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/b4765514e48975aa73a9694f3bdca5e5
+libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/085aa81d1542b50b247120b08866775ce3a13dd23e9b649282c902bd2ba8d4581a4571c09d241340a29bc8413a7e749c5f37c1063af4f5b450cf5b271be1e24e
+libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/78000c16b21ae1b67610976a26ef201f
+libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/1a053a22f183b7b04b4ce8fbcc24393612ace7479a60b73f2a58f54b1ae8632fb9679daf10662347d17ece27d4f64be10d28a6b7f21cedb1131c174754e77660
+libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/12ec163e43b1247a37b3edd5662b0317
+libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/44a8a3a68f63a2858a190d2e6ab80952d233f1c86adcb9e6acb23a7f7719ac710a3aadc89053433baf33b435db191b67132f52ccb1ac0f731aa5088400f7a7b4
+libLLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/41bda0ee2f4bc2fbd5b9ee19648249c6
+libLLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/df36876b425dc1ad4639171c61bb82ad0f13405e192cff4d015dd98a2360970ccf096a865c0e8ffc94db829f928ce6323fe54c2db58532b5417ff36da69a1023
+libLLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/335e0c093c6df8d38a0543c5ac7da915
+libLLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/384bb24b12d99896ee617bb54c5a76714df667b41de39dc83bbcfd7e94c8aa2e0e8af9f82570c828f395cf363fbb7b8989413618b0222da373bbeb37a60925ac
+libLLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/6255fd402da3174d3256558b719b0ed2
+libLLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/df45f55a4c9f0b235dd741e85e7c353300fdc3dc7b0746b1627b2925d14aba8420ffd669529441b8decd8227dca7821e3efb7c5311368cafd2ef1e1c985a5546
+libLLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/c07fd8ab5524bdc8480bc3255b36b44f
+libLLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/015cdc9f78ad1caa90d22abe46314e7ef685ef6da3fc842de5dc641edecb6e41a1329ecd6a9b1450ab50649318320ec0960ae5baad1724c5d938ed97e6fcda17
+libLLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/f7f778128d4bf9982a4b2d8fadece45f
+libLLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/622eabb90a99c34b02784303cb09a9ae2670d839f9ca0307c7034abe7e03ac2dc637eb60c084f4cc59e88b184a9dc174493e812b40a4935b05dcab8b4ae23f1e
+libLLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/899150cd028d99652e2e390c9afefff3
+libLLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/834d8ce87a58e876c5589ab05389ddfb7dd898cc90a2a8138f31d5bb65d01821a4da4ad70b747b506cca6119cdf70146aa7448307655681aeb7e58012dabdc2f
+libLLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/152a7b0c440560edfe0e20a5c8eedb15
+libLLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/344f2ecd173d198d3bfaa7400f46de57822219345234157ae9c901d929e0a32628339989eafeaff716763d26b4c66ca9cb5f55696fa3ad9f236d537f21e26b0b
+libLLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/3755794024285e1a3e9dd716e5a0c47b
+libLLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/245c5cfce819dcc128925bd40ebc3b39eb2b9760a400c3604168a13434ab6ca96e9067df19acaabc031205d59996e677bc1d804be3c63e7d9a0a88fee6e4d518
+libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/fedb5c68002a0827e4172ba59ebd3efb
+libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/4137e0254c8176a9e5ac1d36160a27c1a0d67ec1c21970e115cdea831211ae1258fdfa8f8f7382bfccd08b467777421458e74274979f1e1c2c4c163cb9e51d06
+libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/b6ce8039dd59ade65a12087fc9a507ea
+libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/06a351fa2e1dfe1d762908bfbc9c350b15758be77766b8c2fbe9d3208f4385304fce31051966c3073e3cb8aba7a1c15aac12b725fa8b552fb30ac3ebe69f7379
+libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/fb15051e20aa736d745c75af41e1ac72
+libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/4bdb341710510e07a2a7151f2f612229269b12d6bd6b3f61d9ecf5ae02001bee1e24cf0fa29ca36f105f5b003544b95c47858da59c201e49ba3a067dad7abc7d
+libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/4fcb319068cd0dce43619eee69c3ae04
+libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/f576e9d47a6b12026d7b765b28fbe8fc88a64fa0d4d4b76640cfcc25648ba1894d0bed31a1c23c3a2086d9fc9db7e17c944c9f22cca3d8142656b12cabe1556d
+libLLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/b4a3dcd7838f363c67ffccf926e2607d
+libLLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/1b72a72de7a14a15a9748820c44f75f3ec6b0ef59f25e9a0a3416205014076f4503781a8738770af2fa3b02ca8445be09bd873bf1d37fb56ad92ba690624f4d0
+libLLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/3af7ad02cfedb3ae47b3bc9748abe5d0
+libLLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/18e6a2bbafa7f7381b5a063db3769aedf952f21bb97e6d26a7b55fced146cfd34ab16d300ca9d42be8d703e4e91426b21174f119fb0348179651d1689ff07c7b
+libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/f6f5e31aa1047ab6afce0ffcac90ac14
+libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/d4235fb8858d5f696e0ac6252d54e7ae54abe18336f6e962631c83feeb6a1c1c87cb3a65900dc4d41a2f2ecf4eaf63a914392c151d26003aa5ae6b1858d417c6
+libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/34a53675cb20a6c2114091dc4b500202
+libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/ec81f180f3241c4936a0374b5eee9e1336bb16dd69b403c9c8a4d2bec6207a197a55d0d6b487b7ec694d18db09267f7cbee4efb09b13d32d57927381b5dd09dd
+libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/5a392fd27d729a834fff3536dd3a11b0
+libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/152a79331508858070bfa62444c45a66eba488522739369886c277cf597e3b7e5d24b74b371b87e3c92383aea3ffa259a18f6d216f27388babf5baf46a3bf352
+libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/d275153e2738e0517d42e9dd1594c1f5
+libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/16362cc75e79e7f19819a2d6b46af96d4ce152bf3a733eb5b573932ad09b3c46700036839978e5f968e14d7c6e5e96b53b051bbe0e1f644421bf8cb1078d3010
+libLLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/8f6f6f101db3da2a422239db48d80228
+libLLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/82950bb2b6e3f4cf4832c73df72753246476ae0c923fe2d1c0abfaee52bdf47dd307e478594163a50633c248d7b86b64ff43a6fd0601616425b0d44eaae1cf55
+libLLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/dcf7c1df5048db10ff97ac0639a4e567
+libLLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/99bfab8c2f954c889b63623e9426bd6e378b51a3bd414c6ce844e8464f026ca21de2e6cdfa313e678b6bf93a62af39b39bfeeb4154e7362604dd5216323fae4e
+libLLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/4475f2fe1521a0cc8213a7ef53052a3b
+libLLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/82a0f70ffa92e7f43d8c07a0c64dc5ef0d628b3150c285d87926e49bf66017f1ca4cd8a372b1c9842154c8e47db933e95305626501f481d2b837119e843cea7a
+libLLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/0f13558877d79581c2d302fc2480fd2b
+libLLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/cc8343fabdc2569982b65c55dca33c290b3d72ebcd7126006fd13f1b216d2803c502f6a5e9839c69d22e642031db711b2dca23ccf1ca3b7c481c55dda1159630
+libLLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/854190a61038ca020a18ef5fa5cdd0a1
+libLLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/f39ec16b2e8aef564b8cc7e523ab2b38de7f18705915140f1769e003bab3871259c8ba3403c0896b3cd78b2cf30bcf2c2d2f5f649329dd35c0e4fc706cee203e
+libLLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/3c58b4d61518cf6a53b1035f4fc9b13e
+libLLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/b706427edd2fe21ca527da587f1cac37b0e36857c6006b1263115bf3e6eb9bc4524b7afd68aebad42d28eafb22fde8c373c460e31a123e8ae4cde3b2fb249d7b
+libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/1d5d1f85a7ad52636b550fd0c449130a
+libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/4bb34be432bcb752561068b9b99756910bcce1ebc91a54761fc67ce08536e807d61cfa238a0df02026e1a4131cfb2feb1137f449fb16aac76eb4697befd94a6c
+libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/b39be2b3fd55154523d6cefc9eec82c9
+libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/ee38ba17a790caeb3997e872eaea2dc81a2e9cfbb70caf900c65052be859ce798b008d545b1cc3c0025d880e069fe4287a37862f1920c4e0c7abbd11a811a080
+libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/4197b06616c8a56ea25dd16fc5cb3b68
+libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/cf2a1868f0b68b76b00bf97bf9ea89f5054ab89e5177b112b8c958ec1c9545bc6ed912c3b4b5038368cd6447ec295d3ae0fe6b9abc4f53c91239644a3bd1a95c
+libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/608053656f194352fb58dd00a3168a41
+libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/8f4688db666fd2342f57887aeb64b85cf000321c6cd9d27f9a685d61136a27055cff426d3eda1a8beaafb8a178250ba0e4736f435baf3e6f1cf31e20720a3a8d
+llvm-julia-15.0.7-9.tar.gz/md5/930ebd05cf54da65ae2142aa2833e2be
+llvm-julia-15.0.7-9.tar.gz/sha512/f9f4d2e28379470f7b7785be2782f8295aaee2c1587d7678fa1f43747a1dabff6b065e4ce778def2ebf6471595b6c072a9650b4a61d019e34fde8a1fb7bdee5a
 llvmunwind-12.0.1.tar.xz/md5/4ec327cee517fdb1f6a20e83748e2c7b
 llvmunwind-12.0.1.tar.xz/sha512/847b6ba03010a43f4fdbfdc49bf16d18fd18474d01584712e651b11191814bf7c1cf53475021d9ee447ed78413202b4ed97973d7bdd851d3e49f8d06f55a7af4
diff --git a/deps/clang.version b/deps/clang.version
index 4c5f1ecc02062..18e40bbd2c434 100644
--- a/deps/clang.version
+++ b/deps/clang.version
@@ -1,4 +1,4 @@
 ## jll artifact
 # Clang (paired with LLVM, only here as a JLL download)
 CLANG_JLL_NAME := Clang
-CLANG_JLL_VER  := 15.0.7+8
+CLANG_JLL_VER  := 15.0.7+9
diff --git a/deps/lld.version b/deps/lld.version
index 64e8aca55fe84..106ffc05fecf3 100644
--- a/deps/lld.version
+++ b/deps/lld.version
@@ -1,3 +1,3 @@
 ## jll artifact
 LLD_JLL_NAME := LLD
-LLD_JLL_VER := 15.0.7+8
+LLD_JLL_VER := 15.0.7+9
diff --git a/deps/llvm-tools.version b/deps/llvm-tools.version
index da7a4ec18bdcc..d7ae53fca1fc1 100644
--- a/deps/llvm-tools.version
+++ b/deps/llvm-tools.version
@@ -1,5 +1,5 @@
 ## jll artifact
 # LLVM_tools (downloads LLVM_jll to get things like `lit` and `opt`)
 LLVM_TOOLS_JLL_NAME := LLVM
-LLVM_TOOLS_JLL_VER := 15.0.7+8
-LLVM_TOOLS_ASSERT_JLL_VER := 15.0.7+8
+LLVM_TOOLS_JLL_VER := 15.0.7+9
+LLVM_TOOLS_ASSERT_JLL_VER := 15.0.7+9
diff --git a/deps/llvm.version b/deps/llvm.version
index 52a3a11e1c145..ba0b900233bfb 100644
--- a/deps/llvm.version
+++ b/deps/llvm.version
@@ -2,14 +2,14 @@
 
 ## jll artifact
 LLVM_JLL_NAME := libLLVM
-LLVM_ASSERT_JLL_VER := 15.0.7+8
+LLVM_ASSERT_JLL_VER := 15.0.7+9
 ## source build
 # Version number of LLVM
 LLVM_VER := 15.0.7
 # Git branch name in `LLVM_GIT_URL` repository
-LLVM_BRANCH=julia-15.0.7-7
+LLVM_BRANCH=julia-15.0.7-9
 # Git ref in `LLVM_GIT_URL` repository
-LLVM_SHA1=julia-15.0.7-7
+LLVM_SHA1=julia-15.0.7-9
 
 ## Following options are used to automatically fetch patchset from Julia's fork.  This is
 ## useful if you want to build an external LLVM while still applying Julia's patches.
@@ -20,4 +20,4 @@ LLVM_JULIA_DIFF_GITHUB_REPO := https://github.com/llvm/llvm-project
 # Base GitHub ref for generating the diff.
 LLVM_BASE_REF := llvm:llvmorg-15.0.7
 # Julia fork's GitHub ref for generating the diff.
-LLVM_JULIA_REF := JuliaLang:julia-15.0.7-7
+LLVM_JULIA_REF := JuliaLang:julia-15.0.7-9
diff --git a/stdlib/LLD_jll/Project.toml b/stdlib/LLD_jll/Project.toml
index 0a0cd4aa6924f..30d0c6625a28e 100644
--- a/stdlib/LLD_jll/Project.toml
+++ b/stdlib/LLD_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LLD_jll"
 uuid = "d55e3150-da41-5e91-b323-ecfd1eec6109"
-version = "15.0.7+8"
+version = "15.0.7+9"
 
 [deps]
 Zlib_jll = "83775a58-1f1d-513f-b197-d71354ab007a"
diff --git a/stdlib/libLLVM_jll/Project.toml b/stdlib/libLLVM_jll/Project.toml
index b0bd480fc99fc..a8e628438e170 100644
--- a/stdlib/libLLVM_jll/Project.toml
+++ b/stdlib/libLLVM_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "libLLVM_jll"
 uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
-version = "15.0.7+8"
+version = "15.0.7+9"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 342d71846bfda057f832f95c3d0eb672ecf9179c Mon Sep 17 00:00:00 2001
From: adienes <51664769+adienes@users.noreply.github.com>
Date: Thu, 26 Oct 2023 17:54:43 -0400
Subject: [PATCH 0097/1315] `reverse(zip(its...))` now checks lengths of
 constituent iterators for equality (#50435)

fixes https://github.com/JuliaLang/julia/issues/45085, fixes
https://github.com/JuliaLang/julia/issues/25583, as per suggested by
@Moelf

Despite the fact that this might cause code to fail that previously
worked, I think this is a bugfix not a breaking change.

In particular, `Iterators.reverse` says:
> Given an iterator itr, then reverse(itr) is an iterator over the same
collection but in the reverse order

And in many cases, the previous behavior of `reverse(::Zip)` would _not_
return "the same collection"
---
 base/iterators.jl | 23 ++++++++++++++++++++++-
 test/iterators.jl |  4 ++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/base/iterators.jl b/base/iterators.jl
index 937d61f156514..24595d29ecc90 100644
--- a/base/iterators.jl
+++ b/base/iterators.jl
@@ -387,6 +387,22 @@ function _zip_min_length(is)
     end
 end
 _zip_min_length(is::Tuple{}) = nothing
+
+# For a collection of iterators `is`, returns a tuple (b, n), where
+# `b` is true when every component of `is` has a statically-known finite
+# length and all such lengths are equal. Otherwise, `b` is false.
+# `n` is an implementation detail, and will be the `length` of the first
+# iterator if it is statically-known and finite. Otherwise, `n` is `nothing`.
+function _zip_lengths_finite_equal(is)
+    i = is[1]
+    if IteratorSize(i) isa Union{IsInfinite, SizeUnknown}
+        return (false, nothing)
+    else
+        b, n = _zip_lengths_finite_equal(tail(is))
+        return (b && (n === nothing || n == length(i)), length(i))
+    end
+end
+_zip_lengths_finite_equal(is::Tuple{}) = (true, nothing)
 size(z::Zip) = _promote_tuple_shape(Base.map(size, z.is)...)
 axes(z::Zip) = _promote_tuple_shape(Base.map(axes, z.is)...)
 _promote_tuple_shape((a,)::Tuple{OneTo}, (b,)::Tuple{OneTo}) = (intersect(a, b),)
@@ -468,8 +484,13 @@ zip_iteratoreltype() = HasEltype()
 zip_iteratoreltype(a) = a
 zip_iteratoreltype(a, tail...) = and_iteratoreltype(a, zip_iteratoreltype(tail...))
 
-reverse(z::Zip) = Zip(Base.map(reverse, z.is)) # n.b. we assume all iterators are the same length
 last(z::Zip) = getindex.(z.is, minimum(Base.map(lastindex, z.is)))
+function reverse(z::Zip)
+    if !first(_zip_lengths_finite_equal(z.is))
+        throw(ArgumentError("Cannot reverse zipped iterators of unknown, infinite, or unequal lengths"))
+    end
+    Zip(Base.map(reverse, z.is))
+end
 
 # filter
 
diff --git a/test/iterators.jl b/test/iterators.jl
index a60ec32bb9ac0..46e7c8b454335 100644
--- a/test/iterators.jl
+++ b/test/iterators.jl
@@ -11,6 +11,10 @@ using Dates: Date, Day
 # issue #4718
 @test collect(Iterators.filter(x->x[1], zip([true, false, true, false],"abcd"))) == [(true,'a'),(true,'c')]
 
+# issue #45085
+@test_throws ArgumentError Iterators.reverse(zip("abc", "abcd"))
+@test_throws ArgumentError Iterators.reverse(zip("abc", Iterators.cycle("ab")))
+
 let z = zip(1:2)
     @test size(z) == (2,)
     @test collect(z) == [(1,), (2,)]

From a41e2b158f040ff3d6cba35c1db1226514f1ad6f Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Thu, 26 Oct 2023 21:27:10 -0400
Subject: [PATCH 0098/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20af5392db5=20to=2075960e509=20(#51893)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5     | 1 +
 .../Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512  | 1 +
 .../Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5     | 1 -
 .../Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512  | 1 -
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512

diff --git a/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5 b/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5
new file mode 100644
index 0000000000000..d218458a1a63d
--- /dev/null
+++ b/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5
@@ -0,0 +1 @@
+7205b17150edf9c43262cab72fc551a7
diff --git a/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512 b/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512
new file mode 100644
index 0000000000000..09ea6e3bf8ea8
--- /dev/null
+++ b/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512
@@ -0,0 +1 @@
+24c05fae25133170fbbad28c1113b5ebc54a748d985f8a00bd57ee5c6c79954c7f5a84f2c460d2e67f88fe1bd8896f398c7ae3ed416ec36dea2a481cf1a416e5
diff --git a/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5 b/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5
deleted file mode 100644
index b10919c082900..0000000000000
--- a/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-65413e890729029a25b147ffc242a23f
diff --git a/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512 b/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512
deleted file mode 100644
index 20ee4dcd235d8..0000000000000
--- a/deps/checksums/Pkg-af5392db53e1a45aa31bd93b507e163fc0205893.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-f8ddfd14a1f1124a08cb8334ab58caf9f628e561b4523ea6e27880da191f359fa1e5c46db09cf8ad0c62736b241085b448314e6af243a34df3901b85fc8fe89f
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 1d900ed01c9f0..4345d2e869025 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = af5392db53e1a45aa31bd93b507e163fc0205893
+PKG_SHA1 = 75960e509763979f6aac7cf31942f70dd85b3b10
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 841d54a3b414b3c7394d307867b5ddb7c7dad588 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 27 Oct 2023 10:11:42 -0400
Subject: [PATCH 0099/1315] strings: improve performance of nextind (#51671)

The recursion (for invalid bytes) was preventing inlining, as was the
length of the function. For ASCII data, the cost of the call far exceeds
the cost of decoding the data.

Closes #51624
---
 base/compiler/optimize.jl |  8 ++++-
 base/strings/string.jl    | 63 +++++++++++++++++++++++----------------
 2 files changed, 44 insertions(+), 27 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 342711555b416..74722f2538424 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -1101,7 +1101,13 @@ function statement_cost(ex::Expr, line::Int, src::Union{CodeInfo, IRCode}, sptyp
             return 0
         end
         return error_path ? params.inline_error_path_cost : params.inline_nonleaf_penalty
-    elseif head === :foreigncall || head === :invoke || head === :invoke_modify
+    elseif head === :foreigncall
+        foreigncall = ex.args[1]
+        if foreigncall isa QuoteNode && foreigncall.value === :jl_string_ptr
+            return 1
+        end
+        return 20
+    elseif head === :invoke || head === :invoke_modify
         # Calls whose "return type" is Union{} do not actually return:
         # they are errors. Since these are not part of the typical
         # run-time of the function, we omit them from
diff --git a/base/strings/string.jl b/base/strings/string.jl
index bb3a292c26b1d..9f5995c25c558 100644
--- a/base/strings/string.jl
+++ b/base/strings/string.jl
@@ -157,15 +157,18 @@ typemin(::String) = typemin(String)
     @boundscheck between(i, 1, n) || throw(BoundsError(s, i))
     @inbounds b = codeunit(s, i)
     (b & 0xc0 == 0x80) & (i-1 > 0) || return i
-    @inbounds b = codeunit(s, i-1)
-    between(b, 0b11000000, 0b11110111) && return i-1
-    (b & 0xc0 == 0x80) & (i-2 > 0) || return i
-    @inbounds b = codeunit(s, i-2)
-    between(b, 0b11100000, 0b11110111) && return i-2
-    (b & 0xc0 == 0x80) & (i-3 > 0) || return i
-    @inbounds b = codeunit(s, i-3)
-    between(b, 0b11110000, 0b11110111) && return i-3
-    return i
+    (@noinline function _thisind_continued(s, i, n) # mark the rest of the function as a slow-path
+        local b
+        @inbounds b = codeunit(s, i-1)
+        between(b, 0b11000000, 0b11110111) && return i-1
+        (b & 0xc0 == 0x80) & (i-2 > 0) || return i
+        @inbounds b = codeunit(s, i-2)
+        between(b, 0b11100000, 0b11110111) && return i-2
+        (b & 0xc0 == 0x80) & (i-3 > 0) || return i
+        @inbounds b = codeunit(s, i-3)
+        between(b, 0b11110000, 0b11110111) && return i-3
+        return i
+    end)(s, i, n)
 end
 
 @propagate_inbounds nextind(s::String, i::Int) = _nextind_str(s, i)
@@ -176,23 +179,31 @@ end
     n = ncodeunits(s)
     @boundscheck between(i, 1, n) || throw(BoundsError(s, i))
     @inbounds l = codeunit(s, i)
-    (l < 0x80) | (0xf8 ≤ l) && return i+1
-    if l < 0xc0
-        i′ = @inbounds thisind(s, i)
-        return i′ < i ? @inbounds(nextind(s, i′)) : i+1
-    end
-    # first continuation byte
-    (i += 1) > n && return i
-    @inbounds b = codeunit(s, i)
-    b & 0xc0 ≠ 0x80 && return i
-    ((i += 1) > n) | (l < 0xe0) && return i
-    # second continuation byte
-    @inbounds b = codeunit(s, i)
-    b & 0xc0 ≠ 0x80 && return i
-    ((i += 1) > n) | (l < 0xf0) && return i
-    # third continuation byte
-    @inbounds b = codeunit(s, i)
-    ifelse(b & 0xc0 ≠ 0x80, i, i+1)
+    between(l, 0x80, 0xf7) || return i+1
+    (@noinline function _nextind_continued(s, i, n, l) # mark the rest of the function as a slow-path
+        if l < 0xc0
+            # handle invalid codeunit index by scanning back to the start of this index
+            # (which may be the same as this index)
+            i′ = @inbounds thisind(s, i)
+            i′ >= i && return i+1
+            i = i′
+            @inbounds l = codeunit(s, i)
+            (l < 0x80) | (0xf8 ≤ l) && return i+1
+            @assert l >= 0xc0
+        end
+        # first continuation byte
+        (i += 1) > n && return i
+        @inbounds b = codeunit(s, i)
+        b & 0xc0 ≠ 0x80 && return i
+        ((i += 1) > n) | (l < 0xe0) && return i
+        # second continuation byte
+        @inbounds b = codeunit(s, i)
+        b & 0xc0 ≠ 0x80 && return i
+        ((i += 1) > n) | (l < 0xf0) && return i
+        # third continuation byte
+        @inbounds b = codeunit(s, i)
+        return ifelse(b & 0xc0 ≠ 0x80, i, i+1)
+    end)(s, i, n, l)
 end
 
 ## checking UTF-8 & ACSII validity ##

From 58030da3bc4e6790d7bafe66d5f37b382dd6df3c Mon Sep 17 00:00:00 2001
From: Guillaume Dalle <22795598+gdalle@users.noreply.github.com>
Date: Fri, 27 Oct 2023 16:34:09 +0200
Subject: [PATCH 0100/1315] Add aliasing warnings to docstrings for mutating
 functions in Base (#50824)

---
 base/Base.jl                |  6 ++++++
 base/abstractarray.jl       |  6 ++++++
 base/abstractset.jl         |  8 ++++++++
 base/accumulate.jl          |  8 ++++++++
 base/array.jl               |  6 ++++++
 base/asyncmap.jl            |  2 ++
 base/combinatorics.jl       |  4 ++++
 base/multidimensional.jl    |  5 +++--
 base/reducedim.jl           | 22 ++++++++++++++++++++--
 base/sort.jl                |  4 ++++
 doc/src/manual/functions.md |  3 +++
 11 files changed, 70 insertions(+), 4 deletions(-)

diff --git a/base/Base.jl b/base/Base.jl
index b440fda78a90a..a4a955c0abde9 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -115,6 +115,12 @@ 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")
diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 4956439123505..42d1129c418c5 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -905,6 +905,8 @@ If `dst` and `src` are of the same type, `dst == src` should hold after
 the call. If `dst` and `src` are multidimensional arrays, they must have
 equal [`axes`](@ref).
 
+$(_DOCS_ALIASING_WARNING)
+
 See also [`copyto!`](@ref).
 
 !!! compat "Julia 1.1"
@@ -1391,6 +1393,8 @@ _unsafe_ind2sub(sz, i) = (@inline; _ind2sub(sz, i))
 Store values from array `X` within some subset of `A` as specified by `inds`.
 The syntax `A[inds...] = X` is equivalent to `(setindex!(A, X, inds...); X)`.
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> A = zeros(2,2);
@@ -3365,6 +3369,8 @@ end
 Like [`map`](@ref), but stores the result in `destination` rather than a new
 collection. `destination` must be at least as large as the smallest collection.
 
+$(_DOCS_ALIASING_WARNING)
+
 See also: [`map`](@ref), [`foreach`](@ref), [`zip`](@ref), [`copyto!`](@ref).
 
 # Examples
diff --git a/base/abstractset.jl b/base/abstractset.jl
index 45801eac1209d..38f7a63fd4536 100644
--- a/base/abstractset.jl
+++ b/base/abstractset.jl
@@ -65,6 +65,8 @@ const ∪ = union
 Construct the [`union`](@ref) of passed in sets and overwrite `s` with the result.
 Maintain order with arrays.
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> a = Set([3, 4, 5]);
@@ -182,6 +184,8 @@ const ∩ = intersect
 
 Intersect all passed in sets and overwrite `s` with the result.
 Maintain order with arrays.
+
+$(_DOCS_ALIASING_WARNING)
 """
 function intersect!(s::AbstractSet, itrs...)
     for x in itrs
@@ -218,6 +222,8 @@ setdiff(s) = union(s)
 Remove from set `s` (in-place) each element of each iterable from `itrs`.
 Maintain order with arrays.
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> a = Set([1, 3, 4, 5]);
@@ -272,6 +278,8 @@ symdiff(s) = symdiff!(copy(s))
 Construct the symmetric difference of the passed in sets, and overwrite `s` with the result.
 When `s` is an array, the order is maintained.
 Note that in this case the multiplicity of elements matters.
+
+$(_DOCS_ALIASING_WARNING)
 """
 function symdiff!(s::AbstractSet, itrs...)
     for x in itrs
diff --git a/base/accumulate.jl b/base/accumulate.jl
index eeb9759e125c7..a2d8a1d368d86 100644
--- a/base/accumulate.jl
+++ b/base/accumulate.jl
@@ -42,6 +42,8 @@ end
     cumsum!(B, A; dims::Integer)
 
 Cumulative sum of `A` along the dimension `dims`, storing the result in `B`. See also [`cumsum`](@ref).
+
+$(_DOCS_ALIASING_WARNING)
 """
 cumsum!(B::AbstractArray{T}, A; dims::Integer) where {T} =
     accumulate!(add_sum, B, A, dims=dims)
@@ -150,6 +152,8 @@ cumsum(itr) = accumulate(add_sum, itr)
 
 Cumulative product of `A` along the dimension `dims`, storing the result in `B`.
 See also [`cumprod`](@ref).
+
+$(_DOCS_ALIASING_WARNING)
 """
 cumprod!(B::AbstractArray{T}, A; dims::Integer) where {T} =
     accumulate!(mul_prod, B, A, dims=dims)
@@ -159,6 +163,8 @@ cumprod!(B::AbstractArray{T}, A; dims::Integer) where {T} =
 
 Cumulative product of a vector `x`, storing the result in `y`.
 See also [`cumprod`](@ref).
+
+$(_DOCS_ALIASING_WARNING)
 """
 cumprod!(y::AbstractVector, x::AbstractVector) = cumprod!(y, x, dims=1)
 
@@ -301,6 +307,8 @@ Cumulative operation `op` on `A` along the dimension `dims`, storing the result
 Providing `dims` is optional for vectors.  If the keyword argument `init` is given, its
 value is used to instantiate the accumulation.
 
+$(_DOCS_ALIASING_WARNING)
+
 See also [`accumulate`](@ref), [`cumsum!`](@ref), [`cumprod!`](@ref).
 
 # Examples
diff --git a/base/array.jl b/base/array.jl
index b0e9d99f8a46d..f4e74118b6f2c 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -322,6 +322,8 @@ source and `do` in the destination (1-indexed).
 The `unsafe` prefix on this function indicates that no validation is performed to ensure
 that N is inbounds on either array. Incorrect usage may corrupt or segfault your program, in
 the same manner as C.
+
+$(_DOCS_ALIASING_WARNING)
 """
 function unsafe_copyto!(dest::Array{T}, doffs, src::Array{T}, soffs, n) where T
     t1 = @_gc_preserve_begin dest
@@ -1784,6 +1786,8 @@ place of the removed items; in this case, `indices` must be a `AbstractUnitRange
 To insert `replacement` before an index `n` without removing any items, use
 `splice!(collection, n:n-1, replacement)`.
 
+$(_DOCS_ALIASING_WARNING)
+
 !!! compat "Julia 1.5"
     Prior to Julia 1.5, `indices` must always be a `UnitRange`.
 
@@ -2762,6 +2766,8 @@ Remove the items at all the indices which are not given by `inds`,
 and return the modified `a`.
 Items which are kept are shifted to fill the resulting gaps.
 
+$(_DOCS_ALIASING_WARNING)
+
 `inds` must be an iterator of sorted and unique integer indices.
 See also [`deleteat!`](@ref).
 
diff --git a/base/asyncmap.jl b/base/asyncmap.jl
index be16ba1b27610..c81afbb7e9115 100644
--- a/base/asyncmap.jl
+++ b/base/asyncmap.jl
@@ -394,6 +394,8 @@ length(itr::AsyncGenerator) = length(itr.collector.enumerator)
 
 Like [`asyncmap`](@ref), but stores output in `results` rather than
 returning a collection.
+
+$(_DOCS_ALIASING_WARNING)
 """
 function asyncmap!(f, r, c1, c...; ntasks=0, batch_size=nothing)
     foreach(identity, AsyncCollector(f, r, c1, c...; ntasks=ntasks, batch_size=batch_size))
diff --git a/base/combinatorics.jl b/base/combinatorics.jl
index 519c8f723e728..5afd96dc1dc4a 100644
--- a/base/combinatorics.jl
+++ b/base/combinatorics.jl
@@ -147,6 +147,8 @@ it is even faster to write into a pre-allocated output array with `u .= @view v[
 (Even though `permute!` overwrites `v` in-place, it internally requires some allocation
 to keep track of which elements have been moved.)
 
+$(_DOCS_ALIASING_WARNING)
+
 See also [`invpermute!`](@ref).
 
 # Examples
@@ -176,6 +178,8 @@ Note that if you have a pre-allocated output array (e.g. `u = similar(v)`),
 it is quicker to instead employ `u[p] = v`.  (`invpermute!` internally
 allocates a copy of the data.)
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> A = [1, 1, 3, 4];
diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 93fe4fedde039..9e0ad293345f4 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -1169,8 +1169,7 @@ circshift!(dest::AbstractArray, src, ::Tuple{}) = copyto!(dest, src)
 Circularly shift, i.e. rotate, the data in `src`, storing the result in
 `dest`. `shifts` specifies the amount to shift in each dimension.
 
-The `dest` array must be distinct from the `src` array (they cannot
-alias each other).
+$(_DOCS_ALIASING_WARNING)
 
 See also [`circshift`](@ref).
 """
@@ -1228,6 +1227,8 @@ their indices; any offset results in a (circular) wraparound. If the
 arrays have overlapping indices, then on the domain of the overlap
 `dest` agrees with `src`.
 
+$(_DOCS_ALIASING_WARNING)
+
 See also: [`circshift`](@ref).
 
 # Examples
diff --git a/base/reducedim.jl b/base/reducedim.jl
index c1c58ccdfefed..f5a22940310cf 100644
--- a/base/reducedim.jl
+++ b/base/reducedim.jl
@@ -448,6 +448,8 @@ _count(f, A::AbstractArrayOrBroadcasted, dims, init) = mapreduce(_bool(f), add_s
 Count the number of elements in `A` for which `f` returns `true` over the
 singleton dimensions of `r`, writing the result into `r` in-place.
 
+$(_DOCS_ALIASING_WARNING)
+
 !!! compat "Julia 1.5"
     inplace `count!` was added in Julia 1.5.
 
@@ -525,8 +527,8 @@ sum(f, A::AbstractArray; dims)
     sum!(r, A)
 
 Sum elements of `A` over the singleton dimensions of `r`, and write results to `r`.
-Note that since the sum! function is intended to operate without making any allocations,
-the target should not alias with the source.
+
+$(_DOCS_ALIASING_WARNING)
 
 # Examples
 ```jldoctest
@@ -601,6 +603,8 @@ prod(f, A::AbstractArray; dims)
 
 Multiply elements of `A` over the singleton dimensions of `r`, and write results to `r`.
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
@@ -678,6 +682,8 @@ maximum(f, A::AbstractArray; dims)
 
 Compute the maximum value of `A` over the singleton dimensions of `r`, and write results to `r`.
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
@@ -755,6 +761,8 @@ minimum(f, A::AbstractArray; dims)
 
 Compute the minimum value of `A` over the singleton dimensions of `r`, and write results to `r`.
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
@@ -820,6 +828,8 @@ extrema(f, A::AbstractArray; dims)
 
 Compute the minimum and maximum value of `A` over the singleton dimensions of `r`, and write results to `r`.
 
+$(_DOCS_ALIASING_WARNING)
+
 !!! compat "Julia 1.8"
     This method requires Julia 1.8 or later.
 
@@ -895,6 +905,8 @@ all(::Function, ::AbstractArray; dims)
 
 Test whether all values in `A` along the singleton dimensions of `r` are `true`, and write results to `r`.
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> A = [true false; true false]
@@ -968,6 +980,8 @@ any(::Function, ::AbstractArray; dims)
 Test whether any values in `A` along the singleton dimensions of `r` are `true`, and write
 results to `r`.
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> A = [true false; true false]
@@ -1085,6 +1099,8 @@ end
 Find the minimum of `A` and the corresponding linear index along singleton
 dimensions of `rval` and `rind`, and store the results in `rval` and `rind`.
 `NaN` is treated as less than all other values except `missing`.
+
+$(_DOCS_ALIASING_WARNING)
 """
 function findmin!(rval::AbstractArray, rind::AbstractArray, A::AbstractArray;
                   init::Bool=true)
@@ -1156,6 +1172,8 @@ end
 Find the maximum of `A` and the corresponding linear index along singleton
 dimensions of `rval` and `rind`, and store the results in `rval` and `rind`.
 `NaN` is treated as greater than all other values except `missing`.
+
+$(_DOCS_ALIASING_WARNING)
 """
 function findmax!(rval::AbstractArray, rind::AbstractArray, A::AbstractArray;
                   init::Bool=true)
diff --git a/base/sort.jl b/base/sort.jl
index 95909f90ad8e5..f411a240e4e9b 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -1587,6 +1587,8 @@ v[ix[k]] == partialsort(v, k)
 The return value is the `k`th element of `ix` if `k` is an integer, or view into `ix` if `k` is
 a range.
 
+$(Base._DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> v = [3, 1, 2, 1];
@@ -1711,6 +1713,8 @@ end
 Like [`sortperm`](@ref), but accepts a preallocated index vector or array `ix` with the same `axes` as `A`.
 `ix` is initialized to contain the values `LinearIndices(A)`.
 
+$(Base._DOCS_ALIASING_WARNING)
+
 !!! compat "Julia 1.9"
     The method accepting `dims` requires at least Julia 1.9.
 
diff --git a/doc/src/manual/functions.md b/doc/src/manual/functions.md
index 3719dfc568913..dd8db7281d87e 100644
--- a/doc/src/manual/functions.md
+++ b/doc/src/manual/functions.md
@@ -102,6 +102,9 @@ As a common convention in Julia (not a syntactic requirement), such a function w
 [typically be named `f!(x, y)`](@ref man-punctuation) rather than `f(x, y)`, as a visual reminder at
 the call site that at least one of the arguments (often the first one) is being mutated.
 
+!!! warning "Shared memory between arguments"
+    The behavior of a mutating function can be unexpected when a mutated argument shares memory with another argument, a situation known as aliasing (e.g. when one is a view of the other).
+    Unless the function docstring explicitly indicates that aliasing produces the expected result, it is the responsibility of the caller to ensure proper behavior on such inputs.
 
 ## Argument-type declarations
 

From 909bceae8a60969dfceba4924142e5efee459d47 Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Fri, 27 Oct 2023 10:41:18 -0400
Subject: [PATCH 0101/1315] implement Memory{T} as a new backend for Array{T}
 (#51319)

See <https://hackmd.io/@vtjnash/rkzazi7an> for the Julep describing this
change.

Also makes memory allocation ccalls safer, for catching Serialization
and deepcopy bugs in packages.

Fixes https://github.com/JuliaLang/julia/issues/24909

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/Base.jl                                  |   58 +-
 base/abstractarray.jl                         |   11 +-
 base/array.jl                                 |  451 ++++--
 base/bitarray.jl                              |    2 +-
 base/bitset.jl                                |    6 +-
 base/boot.jl                                  |  160 +-
 base/c.jl                                     |  333 +----
 base/cmem.jl                                  |    4 +
 base/compiler/abstractinterpretation.jl       |    4 +-
 base/compiler/compiler.jl                     |    1 +
 base/compiler/optimize.jl                     |   10 +-
 .../ssair/EscapeAnalysis/EscapeAnalysis.jl    |  294 +---
 base/compiler/ssair/inlining.jl               |    2 +-
 base/compiler/tfuncs.jl                       |  381 +++--
 base/compiler/typelattice.jl                  |    2 +-
 base/compiler/utilities.jl                    |    2 +-
 base/deepcopy.jl                              |   35 +-
 base/dict.jl                                  |   34 +-
 base/docs/basedocs.jl                         |   38 +
 base/docs/intrinsicsdocs.jl                   |   62 +
 base/essentials.jl                            |   46 +-
 base/experimental.jl                          |    7 +-
 base/expr.jl                                  |    3 +-
 base/genericmemory.jl                         |  272 ++++
 base/iddict.jl                                |   10 +-
 base/namedtuple.jl                            |    4 +-
 base/pointer.jl                               |   34 +-
 base/promotion.jl                             |    2 +-
 base/reflection.jl                            |   59 +-
 base/refpointer.jl                            |    8 +-
 base/reshapedarray.jl                         |   18 +-
 base/secretbuffer.jl                          |   12 +-
 base/strings/cstring.jl                       |  314 ++++
 base/summarysize.jl                           |   12 +-
 contrib/generate_precompile.jl                |    1 +
 doc/make.jl                                   |    1 +
 doc/src/base/arrays.md                        |    2 +
 doc/src/base/c.md                             |    2 +-
 doc/src/devdocs/builtins.md                   |   18 +
 doc/src/devdocs/isbitsunionarrays.md          |   10 +-
 doc/src/devdocs/llvm.md                       |    4 +-
 doc/src/devdocs/object.md                     |    5 +-
 doc/src/devdocs/types.md                      |    2 +
 doc/src/manual/embedding.md                   |   11 +-
 src/Makefile                                  |    4 +-
 src/abi_aarch64.cpp                           |    4 +-
 src/abi_arm.cpp                               |    2 +-
 src/abi_ppc64le.cpp                           |    2 +-
 src/abi_win32.cpp                             |    4 +-
 src/abi_x86_64.cpp                            |    2 +-
 src/aotcompile.cpp                            |    4 +-
 src/array.c                                   | 1325 +++--------------
 src/ast.c                                     |   16 +-
 src/builtin_proto.h                           |    9 +-
 src/builtins.c                                |  243 ++-
 src/ccall.cpp                                 |   84 +-
 src/cgutils.cpp                               |  873 ++++++-----
 src/clangsa/GCChecker.cpp                     |    2 +
 src/codegen.cpp                               |  672 ++++-----
 src/common_symbols1.inc                       |  120 +-
 src/common_symbols2.inc                       |  411 +++--
 src/datatype.c                                |  251 ++--
 src/dlload.c                                  |    2 +-
 src/gc-debug.c                                |   37 +-
 src/gc-stacks.c                               |    4 +-
 src/gc.c                                      |  200 ++-
 src/gc.h                                      |   18 +-
 src/gen_sysimg_symtab.jl                      |   10 +-
 src/genericmemory.c                           |  620 ++++++++
 src/gf.c                                      |   79 +-
 src/iddict.c                                  |   44 +-
 src/init.c                                    |    9 +-
 src/interpreter.c                             |   14 +-
 src/intrinsics.cpp                            |   16 +-
 src/intrinsics.h                              |    2 -
 src/ircode.c                                  |  261 ++--
 src/jitlayers.cpp                             |    2 +-
 src/jl_exported_data.inc                      |   14 +
 src/jl_exported_funcs.inc                     |   21 +-
 src/jlapi.c                                   |    9 +-
 src/jltypes.c                                 |  204 ++-
 src/julia.h                                   |  398 +++--
 src/julia_internal.h                          |   20 +-
 src/llvm-alloc-opt.cpp                        |   11 +-
 src/llvm-codegen-shared.h                     |    2 +-
 src/llvm-late-gc-lowering.cpp                 |  163 +-
 src/llvm-pass-helpers.cpp                     |    3 +-
 src/llvm-pass-helpers.h                       |    1 +
 src/method.c                                  |   43 +-
 src/module.c                                  |   10 +-
 src/precompile.c                              |    6 +-
 src/precompile_utils.c                        |   10 +-
 src/processor.cpp                             |    2 +-
 src/rtutils.c                                 |  103 +-
 src/runtime_intrinsics.c                      |    6 -
 src/serialize.h                               |    3 +-
 src/simplevector.c                            |    2 +-
 src/smallintset.c                             |   34 +-
 src/stackwalk.c                               |   16 +-
 src/staticdata.c                              |  400 +++--
 src/staticdata_utils.c                        |  116 +-
 src/subtype.c                                 |    4 +-
 src/sys.c                                     |   10 +-
 src/toplevel.c                                |   34 +-
 src/typemap.c                                 |  201 +--
 stdlib/Base64/src/buffer.jl                   |    6 +-
 stdlib/Mmap/src/Mmap.jl                       |   10 +-
 stdlib/Profile/test/allocs.jl                 |   13 +-
 stdlib/Serialization/src/Serialization.jl     |   78 +-
 test/abstractarray.jl                         |   12 +-
 test/cmdlineargs.jl                           |   10 +-
 .../compiler/EscapeAnalysis/EscapeAnalysis.jl |  235 +--
 test/compiler/codegen.jl                      |   37 +-
 test/compiler/effects.jl                      |  117 +-
 test/compiler/inference.jl                    |   92 +-
 test/compiler/inline.jl                       |   38 +-
 test/compiler/irpasses.jl                     |   13 +-
 test/compiler/ssair.jl                        |    2 +-
 test/core.jl                                  |  601 ++++----
 test/embedding/embedding.c                    |    6 +-
 test/errorshow.jl                             |    2 +-
 test/llvmpasses/names.jl                      |   28 -
 test/llvmpasses/pipeline-o2.jl                |    8 +-
 test/offsetarray.jl                           |    8 +-
 test/precompile.jl                            |   57 +-
 test/reflection.jl                            |   13 +-
 test/show.jl                                  |    8 +-
 test/sorting.jl                               |   14 +-
 128 files changed, 5996 insertions(+), 5351 deletions(-)
 create mode 100644 base/docs/intrinsicsdocs.jl
 create mode 100644 base/genericmemory.jl
 create mode 100644 base/strings/cstring.jl
 create mode 100644 doc/src/devdocs/builtins.md
 create mode 100644 src/genericmemory.c

diff --git a/base/Base.jl b/base/Base.jl
index a4a955c0abde9..24f07dfef6de7 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -6,10 +6,19 @@ 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)
-const _included_files = Array{Tuple{Module,String},1}(Core.undef, 1)
+# 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)
-    ccall(:jl_array_grow_end, Cvoid, (Any, UInt), _included_files, UInt(1))
-    Core.arrayset(true, _included_files, (mod, ccall(:jl_prepend_cwd, Any, (Any,), path)), arraylen(_included_files))
+    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)
@@ -31,6 +40,7 @@ macro noinline() Expr(:meta, :noinline) end
 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
 
@@ -192,23 +202,22 @@ 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
@@ -224,6 +233,17 @@ function strcat(x::String, y::String)
 end
 include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "build_h.jl"))     # include($BUILDROOT/base/build_h.jl)
 include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "version_git.jl")) # include($BUILDROOT/base/version_git.jl)
+# Initialize DL_LOAD_PATH as early as possible.  We are defining things here in
+# a slightly more verbose fashion than usual, because we're running so early.
+const DL_LOAD_PATH = String[]
+let os = ccall(:jl_get_UNAME, Any, ())
+    if os === :Darwin || os === :Apple
+        if Base.DARWIN_FRAMEWORK
+            push!(DL_LOAD_PATH, "@loader_path/Frameworks")
+        end
+        push!(DL_LOAD_PATH, "@loader_path")
+    end
+end
 
 # numeric operations
 include("hashing.jl")
@@ -271,24 +291,24 @@ include("set.jl")
 
 # Strings
 include("char.jl")
+function array_new_memory(mem::Memory{UInt8}, newlen::Int)
+    # add an optimization to array_new_memory for StringVector
+    if (@assume_effects :total @ccall jl_genericmemory_owner(mem::Any,)::Any) isa String
+        # If data is in a String, keep it that way.
+        # When implemented, this could use jl_gc_expand_string(oldstr, newlen) as an optimization
+        str = _string_n(newlen)
+        return (@assume_effects :total !:consistent @ccall jl_string_to_genericmemory(str::Any,)::Memory{UInt8})
+    else
+        # TODO: when implemented, this should use a memory growing call
+        return typeof(mem)(undef, newlen)
+    end
+end
 include("strings/basic.jl")
 include("strings/string.jl")
 include("strings/substring.jl")
-
-# Initialize DL_LOAD_PATH as early as possible.  We are defining things here in
-# a slightly more verbose fashion than usual, because we're running so early.
-const DL_LOAD_PATH = String[]
-let os = ccall(:jl_get_UNAME, Any, ())
-    if os === :Darwin || os === :Apple
-        if Base.DARWIN_FRAMEWORK
-            push!(DL_LOAD_PATH, "@loader_path/Frameworks")
-        end
-        push!(DL_LOAD_PATH, "@loader_path")
-    end
-end
+include("strings/cstring.jl")
 
 include("osutils.jl")
-include("c.jl")
 
 # Core I/O
 include("io.jl")
diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 42d1129c418c5..881070ff7aa00 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -268,8 +268,8 @@ julia> ndims(A)
 3
 ```
 """
-ndims(::AbstractArray{T,N}) where {T,N} = N
-ndims(::Type{<:AbstractArray{<:Any,N}}) where {N} = N
+ndims(::AbstractArray{T,N}) where {T,N} = N::Int
+ndims(::Type{<:AbstractArray{<:Any,N}}) where {N} = N::Int
 ndims(::Type{Union{}}, slurp...) = throw(ArgumentError("Union{} does not have elements"))
 
 """
@@ -731,8 +731,6 @@ end
 checkbounds_indices(::Type{Bool}, IA::Tuple, ::Tuple{}) = (@inline; all(x->length(x)==1, IA))
 checkbounds_indices(::Type{Bool}, ::Tuple{}, ::Tuple{}) = true
 
-throw_boundserror(A, I) = (@noinline; throw(BoundsError(A, I)))
-
 # check along a single dimension
 """
     checkindex(Bool, inds::AbstractUnitRange, index)
@@ -1451,6 +1449,8 @@ function _setindex!(::IndexCartesian, A::AbstractArray, v, I::Vararg{Int,M}) whe
     r
 end
 
+_unsetindex!(A::AbstractArray, i::Integer) = _unsetindex!(A, to_index(i))
+
 """
     parent(A)
 
@@ -1556,7 +1556,8 @@ their component parts.  A typical definition for an array that wraps a parent is
 `Base.dataids(C::CustomArray) = dataids(C.parent)`.
 """
 dataids(A::AbstractArray) = (UInt(objectid(A)),)
-dataids(A::Array) = (UInt(pointer(A)),)
+dataids(A::Memory) = (B = ccall(:jl_genericmemory_owner, Any, (Any,), A); (UInt(pointer(B isa typeof(A) ? B : A)),))
+dataids(A::Array) = dataids(A.ref.mem)
 dataids(::AbstractRange) = ()
 dataids(x) = ()
 
diff --git a/base/array.jl b/base/array.jl
index f4e74118b6f2c..920e51d37be22 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -120,8 +120,6 @@ const DenseVecOrMat{T} = Union{DenseVector{T}, DenseMatrix{T}}
 
 ## Basic functions ##
 
-using Core: arraysize, arrayset, const_arrayref
-
 """
     @_safeindex
 
@@ -137,13 +135,13 @@ end
 function _safeindex(__module__, ex)
     isa(ex, Expr) || return ex
     if ex.head === :(=)
-        lhs = arrayref(true, ex.args, 1)
+        lhs = ex.args[1]
         if isa(lhs, Expr) && lhs.head === :ref # xs[i] = x
-            rhs = arrayref(true, ex.args, 2)
-            xs = arrayref(true, lhs.args, 1)
+            rhs = ex.args[2]
+            xs = lhs.args[1]
             args = Vector{Any}(undef, length(lhs.args)-1)
             for i = 2:length(lhs.args)
-                arrayset(true, args, _safeindex(__module__, arrayref(true, lhs.args, i)), i-1)
+                args[i-1] = _safeindex(__module__, lhs.args[i])
             end
             return Expr(:call, GlobalRef(__module__, :__inbounds_setindex!), xs, _safeindex(__module__, rhs), args...)
         end
@@ -152,7 +150,7 @@ function _safeindex(__module__, ex)
     end
     args = Vector{Any}(undef, length(ex.args))
     for i = 1:length(ex.args)
-        arrayset(true, args, _safeindex(__module__, arrayref(true, ex.args, i)), i)
+        args[i] = _safeindex(__module__, ex.args[i])
     end
     return Expr(ex.head, args...)
 end
@@ -187,12 +185,15 @@ function vect(X...)
     return T[X...]
 end
 
-size(a::Array, d::Integer) = arraysize(a, d isa Int ? d : convert(Int, d))
-size(a::Vector) = (arraysize(a,1),)
-size(a::Matrix) = (arraysize(a,1), arraysize(a,2))
-size(a::Array{<:Any,N}) where {N} = (@inline; ntuple(M -> size(a, M), Val(N))::Dims)
+size(a::Array, d::Integer) = size(a, Int(d)::Int)
+function size(a::Array, d::Int)
+    d < 1 && error("arraysize: dimension out of range")
+    sz = getfield(a, :size)
+    return d > length(sz) ? 1 : getfield(sz, d, false) # @inbounds
+end
+size(a::Array) = getfield(a, :size)
 
-asize_from(a::Array, n) = n > ndims(a) ? () : (arraysize(a,n), asize_from(a, n+1)...)
+asize_from(a::Array, n) = n > ndims(a) ? () : (size(a,n), asize_from(a, n+1)...)
 
 allocatedinline(@nospecialize T::Type) = (@_total_meta; ccall(:jl_stored_inline, Cint, (Any,), T) != Cint(0))
 
@@ -210,49 +211,18 @@ julia> Base.isbitsunion(Union{Float64, String})
 false
 ```
 """
-isbitsunion(u::Union) = allocatedinline(u)
-isbitsunion(x) = false
+isbitsunion(u::Type) = u isa Union && allocatedinline(u)
 
-function _unsetindex!(A::Array{T}, i::Int) where {T}
+function _unsetindex!(A::Array, i::Int)
     @inline
     @boundscheck checkbounds(A, i)
-    t = @_gc_preserve_begin A
-    p = Ptr{Ptr{Cvoid}}(pointer(A, i))
-    if !allocatedinline(T)
-        Intrinsics.atomic_pointerset(p, C_NULL, :monotonic)
-    elseif T isa DataType
-        if !datatype_pointerfree(T)
-            for j = 1:Core.sizeof(Ptr{Cvoid}):Core.sizeof(T)
-                Intrinsics.atomic_pointerset(p + j - 1, C_NULL, :monotonic)
-            end
-        end
-    end
-    @_gc_preserve_end t
+    @inbounds _unsetindex!(GenericMemoryRef(A.ref, i))
     return A
 end
 
 
-"""
-    Base.bitsunionsize(U::Union) -> Int
-
-For a `Union` of [`isbitstype`](@ref) types, return the size of the largest type; assumes `Base.isbitsunion(U) == true`.
-
-# Examples
-```jldoctest
-julia> Base.bitsunionsize(Union{Float64, UInt8})
-8
-
-julia> Base.bitsunionsize(Union{Float64, UInt8, Int128})
-16
-```
-"""
-function bitsunionsize(u::Union)
-    isinline, sz, _ = uniontype_layout(u)
-    @assert isinline
-    return sz
-end
-
-elsize(@nospecialize _::Type{A}) where {T,A<:Array{T}} = aligned_sizeof(T)
+# TODO: deprecate this (aligned_sizeof and/or elsize and/or sizeof(Some{T}) are more correct)
+elsize(::Type{A}) where {T,A<:Array{T}} = aligned_sizeof(T)
 function elsize(::Type{Ptr{T}}) where T
     # this only must return something valid for values which satisfy is_valid_intrinsic_elptr(T),
     # which includes Any and most concrete datatypes
@@ -261,15 +231,23 @@ function elsize(::Type{Ptr{T}}) where T
     return LLT_ALIGN(Core.sizeof(T), datatype_alignment(T))
 end
 elsize(::Type{Union{}}, slurp...) = 0
-sizeof(a::Array) = Core.sizeof(a)
+
+sizeof(a::Array) = length(a) * elsize(typeof(a)) # n.b. this ignores bitsunion bytes, as a historical fact
 
 function isassigned(a::Array, i::Int...)
     @inline
     @boundscheck checkbounds(Bool, a, i...) || return false
-    ii = (_sub2ind(size(a), i...) % UInt) - 1
-    ccall(:jl_array_isassigned, Cint, (Any, UInt), a, ii) == 1
+    ii = _sub2ind(size(a), i...)
+    return @inbounds isassigned(memoryref(a.ref, ii, false))
 end
 
+function isassigned(a::Vector, i::Int) # slight compiler simplification for the most common case
+    @inline
+    @boundscheck checkbounds(Bool, a, i) || return false
+    return @inbounds isassigned(memoryref(a.ref, i, false))
+end
+
+
 ## copy ##
 
 """
@@ -289,30 +267,6 @@ function unsafe_copyto!(dest::Ptr{T}, src::Ptr{T}, n) where T
     return dest
 end
 
-
-function _unsafe_copyto!(dest, doffs, src, soffs, n)
-    destp = pointer(dest, doffs)
-    srcp = pointer(src, soffs)
-    @inbounds if destp < srcp || destp > srcp + n
-        for i = 1:n
-            if isassigned(src, soffs + i - 1)
-                dest[doffs + i - 1] = src[soffs + i - 1]
-            else
-                _unsetindex!(dest, doffs + i - 1)
-            end
-        end
-    else
-        for i = n:-1:1
-            if isassigned(src, soffs + i - 1)
-                dest[doffs + i - 1] = src[soffs + i - 1]
-            else
-                _unsetindex!(dest, doffs + i - 1)
-            end
-        end
-    end
-    return dest
-end
-
 """
     unsafe_copyto!(dest::Array, do, src::Array, so, N)
 
@@ -325,34 +279,12 @@ the same manner as C.
 
 $(_DOCS_ALIASING_WARNING)
 """
-function unsafe_copyto!(dest::Array{T}, doffs, src::Array{T}, soffs, n) where T
-    t1 = @_gc_preserve_begin dest
-    t2 = @_gc_preserve_begin src
-    destp = pointer(dest, doffs)
-    srcp = pointer(src, soffs)
-    if !allocatedinline(T)
-        ccall(:jl_array_ptr_copy, Cvoid, (Any, Ptr{Cvoid}, Any, Ptr{Cvoid}, Int),
-              dest, destp, src, srcp, n)
-    elseif isbitstype(T)
-        memmove(destp, srcp, n * aligned_sizeof(T))
-    elseif isbitsunion(T)
-        memmove(destp, srcp, n * aligned_sizeof(T))
-        # copy selector bytes
-        memmove(
-              ccall(:jl_array_typetagdata, Ptr{UInt8}, (Any,), dest) + doffs - 1,
-              ccall(:jl_array_typetagdata, Ptr{UInt8}, (Any,), src) + soffs - 1,
-              n)
-    else
-        _unsafe_copyto!(dest, doffs, src, soffs, n)
-    end
-    @_gc_preserve_end t2
-    @_gc_preserve_end t1
+function unsafe_copyto!(dest::Array, doffs, src::Array, soffs, n)
+    n == 0 && return dest
+    unsafe_copyto!(GenericMemoryRef(dest.ref, doffs), GenericMemoryRef(src.ref, soffs), n)
     return dest
 end
 
-unsafe_copyto!(dest::Array, doffs, src::Array, soffs, n) =
-    _unsafe_copyto!(dest, doffs, src, soffs, n)
-
 """
     copyto!(dest, do, src, so, N)
 
@@ -408,7 +340,11 @@ See also [`copy!`](@ref Base.copy!), [`copyto!`](@ref), [`deepcopy`](@ref).
 """
 copy
 
-copy(a::T) where {T<:Array} = ccall(:jl_array_copy, Ref{T}, (Any,), a)
+@eval function copy(a::Array{T}) where {T}
+    ref = a.ref
+    newmem = ccall(:jl_genericmemory_copy_slice, Ref{Memory{T}}, (Any, Ptr{Cvoid}, Int), ref.mem, ref.ptr_or_offset, length(a))
+    return $(Expr(:new, :(typeof(a)), :(Core.memoryref(newmem)), :(a.size)))
+end
 
 ## Constructors ##
 
@@ -471,8 +407,9 @@ end
 getindex(::Type{Any}) = Vector{Any}()
 
 function fill!(a::Union{Array{UInt8}, Array{Int8}}, x::Integer)
-    t = @_gc_preserve_begin a
-    p = unsafe_convert(Ptr{Cvoid}, a)
+    ref = a.ref
+    t = @_gc_preserve_begin ref
+    p = unsafe_convert(Ptr{Cvoid}, ref)
     memset(p, x isa eltype(a) ? x : convert(eltype(a), x), length(a))
     @_gc_preserve_end t
     return a
@@ -942,7 +879,7 @@ end
 
 ## Iteration ##
 
-iterate(A::Array, i=1) = (@inline; (i % UInt) - 1 < length(A) ? (@inbounds A[i], i + 1) : nothing)
+iterate(A::Array, i=1) = (@inline; (i - 1)%UInt < length(A)%UInt ? (@inbounds A[i], i + 1) : nothing)
 
 ## Indexing: getindex ##
 
@@ -967,6 +904,12 @@ julia> getindex(A, "a")
 """
 function getindex end
 
+function getindex(A::Array, i1::Int, i2::Int, I::Int...)
+    @inline
+    @boundscheck checkbounds(A, i1, i2, I...) # generally _to_linear_index requires bounds checking
+    return @inbounds A[_to_linear_index(A, i1, i2, I...)]
+end
+
 # Faster contiguous indexing using copyto! for AbstractUnitRange and Colon
 function getindex(A::Array, I::AbstractUnitRange{<:Integer})
     @inline
@@ -1018,15 +961,30 @@ Dict{String, Int64} with 2 entries:
 """
 function setindex! end
 
-@eval setindex!(A::Array{T}, x, i1::Int) where {T} =
-    arrayset($(Expr(:boundscheck)), A, x isa T ? x : convert(T,x)::T, i1)
-@eval setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T} =
-    (@inline; arrayset($(Expr(:boundscheck)), A, x isa T ? x : convert(T,x)::T, i1, i2, I...))
+function setindex!(A::Array{T}, x, i::Int) where {T}
+    @boundscheck (i - 1)%UInt < length(A)%UInt || throw_boundserror(A, (i,))
+    memoryrefset!(memoryref(A.ref, i, false), x isa T ? x : convert(T,x)::T, :not_atomic, false)
+    return A
+end
+function setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T}
+    @inline
+    @boundscheck checkbounds(A, i1, i2, I...) # generally _to_linear_index requires bounds checking
+    memoryrefset!(memoryref(A.ref, _to_linear_index(A, i1, i2, I...), false), x isa T ? x : convert(T,x)::T, :not_atomic, false)
+    return A
+end
 
-__inbounds_setindex!(A::Array{T}, x, i1::Int) where {T} =
-    arrayset(false, A, convert(T,x)::T, i1)
-__inbounds_setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T} =
-    (@inline; arrayset(false, A, convert(T,x)::T, i1, i2, I...))
+function __inbounds_setindex!(A::Array{T}, x, i::Int) where {T}
+    @inline
+    val = x isa T ? x : convert(T,x)::T
+    memoryrefset!(memoryref(A.ref, i, false), val, :not_atomic, false)
+    return A
+end
+function __inbounds_setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T}
+    @inline
+    val = x isa T ? x : convert(T,x)::T
+    memoryrefset!(memoryref(A.ref, _to_linear_index(A, i1, i2, I...), false), val, :not_atomic, false)
+    return A
+end
 
 # This is redundant with the abstract fallbacks but needed and helpful for bootstrap
 function setindex!(A::Array, X::AbstractArray, I::AbstractVector{Int})
@@ -1065,24 +1023,184 @@ function setindex!(A::Array{T}, X::Array{T}, c::Colon) where T
     return A
 end
 
-# efficiently grow an array
-
-_growbeg!(a::Vector, delta::Integer) =
-    ccall(:jl_array_grow_beg, Cvoid, (Any, UInt), a, delta)
-_growend!(a::Vector, delta::Integer) =
-    ccall(:jl_array_grow_end, Cvoid, (Any, UInt), a, delta)
-_growat!(a::Vector, i::Integer, delta::Integer) =
-    ccall(:jl_array_grow_at, Cvoid, (Any, Int, UInt), a, i - 1, delta)
+# Pick new memory size for efficiently growing an array
+# TODO: This should know about the size of our GC pools
+# Specifically we are wasting ~10% of memory for small arrays
+# by not picking memory sizes that max out a GC pool
+function overallocation(maxsize)
+    maxsize < 8 && return 8;
+    # compute maxsize = maxsize + 4*maxsize^(7/8) + maxsize/8
+    # for small n, we grow faster than O(n)
+    # for large n, we grow at O(n/8)
+    # and as we reach O(memory) for memory>>1MB,
+    # this means we end by adding about 10% of memory each time
+    exp2 = sizeof(maxsize) * 8 - Core.Intrinsics.ctlz_int(maxsize)
+    maxsize += (1 << div(exp2 * 7, 8)) * 4 + div(maxsize, 8)
+    return maxsize
+end
+
+array_new_memory(mem::Memory, newlen::Int) = typeof(mem)(undef, newlen) # when implemented, this should attempt to first expand mem
+
+function _growbeg!(a::Vector, delta::Integer)
+    delta = Int(delta)
+    delta == 0 && return # avoid attempting to index off the end
+    delta >= 0 || throw(ArgumentError("grow requires delta >= 0"))
+    ref = a.ref
+    mem = ref.mem
+    len = length(a)
+    offset = memoryrefoffset(ref)
+    newlen = len + delta
+    setfield!(a, :size, (newlen,))
+    # if offset is far enough advanced to fit data in existing memory without copying
+    if delta <= offset - 1
+        setfield!(a, :ref, @inbounds GenericMemoryRef(ref, 1 - delta))
+    else
+        @noinline (function()
+        memlen = length(mem)
+        # since we will allocate the array in the middle of the memory we need at least 2*delta extra space
+        # the +1 is because I didn't want to have an off by 1 error.
+        newmemlen = max(overallocation(memlen), len + 2 * delta + 1)
+        newoffset = div(newmemlen - newlen, 2) + 1
+        # If there is extra data after the end of the array we can use that space so long as there is enough
+        # space at the end that there won't be quadratic behavior with a mix of growth from both ends.
+        # Specifically, we want to ensure that we will only do this operation once before
+        # increasing the size of the array, and that we leave enough space at both the beginning and the end.
+        if newoffset + newlen < memlen
+            newoffset = div(memlen - newlen, 2) + 1
+            newmem = mem
+        else
+            newmem = array_new_memory(mem, newmemlen)
+        end
+        unsafe_copyto!(newmem, newoffset + delta, mem, offset, len)
+        setfield!(a, :ref, @inbounds GenericMemoryRef(newmem, newoffset))
+        end)()
+    end
+    return
+end
 
-# efficiently delete part of an array
+function _growend!(a::Vector, delta::Integer)
+    delta = Int(delta)
+    delta >= 0 || throw(ArgumentError("grow requires delta >= 0"))
+    ref = a.ref
+    mem = ref.mem
+    memlen = length(mem)
+    len = length(a)
+    newlen = len + delta
+    offset = memoryrefoffset(ref)
+    setfield!(a, :size, (newlen,))
+    newmemlen = offset + newlen - 1
+    if memlen < newmemlen
+        @noinline (function()
+        if offset - 1 > div(5 * newlen, 4)
+            # If the offset is far enough that we can copy without resizing
+            # while maintaining proportional spacing on both ends of the array
+            # note that this branch prevents infinite growth when doing combinations
+            # of push! and popfirst! (i.e. when using a Vector as a queue)
+            newmem = mem
+            newoffset = div(newlen, 8) + 1
+        else
+            # grow either by our computed overallocation factor
+            # or exactly the requested size, whichever is larger
+            # TODO we should possibly increase the offset if the current offset is nonzero.
+            newmemlen2 = max(overallocation(memlen), newmemlen)
+            newmem = array_new_memory(mem, newmemlen2)
+            newoffset = offset
+        end
+        newref = @inbounds GenericMemoryRef(newmem, newoffset)
+        unsafe_copyto!(newref, ref, len)
+        setfield!(a, :ref, newref)
+        end)()
+    end
+    return
+end
 
-_deletebeg!(a::Vector, delta::Integer) =
-    ccall(:jl_array_del_beg, Cvoid, (Any, UInt), a, delta)
-_deleteend!(a::Vector, delta::Integer) =
-    ccall(:jl_array_del_end, Cvoid, (Any, UInt), a, delta)
-_deleteat!(a::Vector, i::Integer, delta::Integer) =
-    ccall(:jl_array_del_at, Cvoid, (Any, Int, UInt), a, i - 1, delta)
+function _growat!(a::Vector, i::Integer, delta::Integer)
+    delta = Int(delta)
+    i = Int(i)
+    i == 1 && return _growbeg!(a, delta)
+    len = length(a)
+    i == len + 1 && return _growend!(a, delta)
+    delta >= 0 || throw(ArgumentError("grow requires delta >= 0"))
+    1 < i <= len || throw(BoundsError(a, i))
+    ref = a.ref
+    mem = ref.mem
+    memlen = length(mem)
+    newlen = len + delta
+    offset = memoryrefoffset(ref)
+    setfield!(a, :size, (newlen,))
+    newmemlen = offset + newlen - 1
+
+    # which side would we rather grow into?
+    prefer_start = i <= div(len, 2)
+    # if offset is far enough advanced to fit data in beginning of the memory
+    if prefer_start && delta <= offset - 1
+        newref = @inbounds GenericMemoryRef(mem, offset - delta)
+        unsafe_copyto!(newref, ref, i)
+        setfield!(a, :ref, newref)
+        for j in i:i+delta-1
+            @inbounds _unsetindex!(a, j)
+        end
+    elseif !prefer_start && memlen >= newmemlen
+        unsafe_copyto!(mem, offset - 1 + delta + i, mem, offset - 1 + i, len - i + 1)
+        for j in i:i+delta-1
+            @inbounds _unsetindex!(a, j)
+        end
+    else
+        # since we will allocate the array in the middle of the memory we need at least 2*delta extra space
+        # the +1 is because I didn't want to have an off by 1 error.
+        newmemlen = max(overallocation(memlen), len+2*delta+1)
+        newoffset = (newmemlen - newlen) ÷ 2 + 1
+        newmem = array_new_memory(mem, newmemlen)
+        newref = @inbounds GenericMemoryRef(newmem, newoffset)
+        unsafe_copyto!(newref, ref, i-1)
+        unsafe_copyto!(newmem, newoffset + delta + i - 1, mem, offset + i - 1, len - i + 1)
+        setfield!(a, :ref, newref)
+    end
+end
 
+# efficiently delete part of an array
+function _deletebeg!(a::Vector, delta::Integer)
+    delta = Int(delta)
+    len = length(a)
+    0 <= delta <= len || throw(ArgumentError("_deletebeg! requires delta in 0:length(a)"))
+    for i in 1:delta
+        @inbounds _unsetindex!(a, i)
+    end
+    newlen = len - delta
+    if newlen != 0 # if newlen==0 we could accidentally index past the memory
+        newref = @inbounds GenericMemoryRef(a.ref, delta + 1)
+        setfield!(a, :ref, newref)
+    end
+    setfield!(a, :size, (newlen,))
+    return
+end
+function _deleteend!(a::Vector, delta::Integer)
+    delta = Int(delta)
+    len = length(a)
+    0 <= delta <= len || throw(ArgumentError("_deleteend! requires delta in 0:length(a)"))
+    newlen = len - delta
+    for i in newlen+1:len
+        @inbounds _unsetindex!(a, i)
+    end
+    setfield!(a, :size, (newlen,))
+    return
+end
+function _deleteat!(a::Vector, i::Integer, delta::Integer)
+    i = Int(i)
+    len = length(a)
+    0 <= delta || throw(ArgumentError("_deleteat! requires delta >= 0"))
+    1 <= i <= len || throw(BoundsError(a, i))
+    i + delta <= len + 1 || throw(BoundsError(a, i + delta - 1))
+    newa = a
+    if 2*i + delta <= len
+        unsafe_copyto!(newa, 1 + delta, a, 1, i - 1)
+        _deletebeg!(a, delta)
+    else
+        unsafe_copyto!(newa, i, a, i + delta, len + 1 - delta - i)
+        _deleteend!(a, delta)
+    end
+    return
+end
 ## Dequeue functionality ##
 
 """
@@ -1348,7 +1466,30 @@ For types that support `sizehint!`,
 function sizehint! end
 
 function sizehint!(a::Vector, sz::Integer)
-    ccall(:jl_array_sizehint, Cvoid, (Any, UInt), a, sz)
+    len = length(a)
+    ref = a.ref
+    mem = ref.mem
+    memlen = length(mem)
+    offset = memoryrefoffset(ref)
+    sz = max(Int(sz), offset + len - 1)
+    if sz <= memlen
+        # if we don't save at least 1/8th memlen then its not worth it to shrink
+        if memlen - sz <= div(memlen, 8)
+            return a
+        end
+        newmem = array_new_memory(mem, sz)
+        if len == 0
+            newref = GenericMemoryRef(newmem)
+        else
+            unsafe_copyto!(newmem, offset, mem, offset, len)
+            newref = @inbounds GenericMemoryRef(newmem, offset)
+        end
+        setfield!(a, :ref, newref)
+    else
+        inc = sz - len;
+        _growend!(a, inc)
+        setfield!(a, :size, (len,)) # undo the size change from _growend!
+    end
     a
 end
 
@@ -1640,17 +1781,19 @@ struct Nowhere; end
 push!(::Nowhere, _) = nothing
 _growend!(::Nowhere, _) = nothing
 
-@inline function _push_deleted!(dltd, a::Vector, ind)
-    if @inbounds isassigned(a, ind)
-        push!(dltd, @inbounds a[ind])
+function _push_deleted!(dltd, a::Vector, ind)
+    @_propagate_inbounds_meta
+    if isassigned(a, ind)
+        push!(dltd, a[ind])
     else
         _growend!(dltd, 1)
     end
 end
 
-@inline function _copy_item!(a::Vector, p, q)
-    if @inbounds isassigned(a, q)
-        @inbounds a[p] = a[q]
+function _copy_item!(a::Vector, p, q)
+    @_propagate_inbounds_meta
+    if isassigned(a, q)
+        a[p] = a[q]
     else
         _unsetindex!(a, p)
     end
@@ -1662,7 +1805,7 @@ function _deleteat!(a::Vector, inds, dltd=Nowhere())
     y === nothing && return a
     (p, s) = y
     checkbounds(a, p)
-    _push_deleted!(dltd, a, p)
+    @inbounds _push_deleted!(dltd, a, p)
     q = p+1
     while true
         y = iterate(inds, s)
@@ -1676,14 +1819,14 @@ function _deleteat!(a::Vector, inds, dltd=Nowhere())
             end
         end
         while q < i
-            _copy_item!(a, p, q)
+            @inbounds _copy_item!(a, p, q)
             p += 1; q += 1
         end
-        _push_deleted!(dltd, a, i)
+        @inbounds _push_deleted!(dltd, a, i)
         q = i+1
     end
     while q <= n
-        _copy_item!(a, p, q)
+        @inbounds _copy_item!(a, p, q)
         p += 1; q += 1
     end
     _deleteend!(a, n-p+1)
@@ -1696,7 +1839,7 @@ function deleteat!(a::Vector, inds::AbstractVector{Bool})
     length(inds) == n || throw(BoundsError(a, inds))
     p = 1
     for (q, i) in enumerate(inds)
-        _copy_item!(a, p, q)
+        @inbounds _copy_item!(a, p, q)
         p += !i
     end
     _deleteend!(a, n-p+1)
@@ -1848,10 +1991,12 @@ end
 
 # use memcmp for cmp on byte arrays
 function cmp(a::Array{UInt8,1}, b::Array{UInt8,1})
-    ta = @_gc_preserve_begin a
-    tb = @_gc_preserve_begin b
-    pa = unsafe_convert(Ptr{Cvoid}, a)
-    pb = unsafe_convert(Ptr{Cvoid}, b)
+    aref = a.ref
+    bref = b.ref
+    ta = @_gc_preserve_begin aref
+    tb = @_gc_preserve_begin bref
+    pa = unsafe_convert(Ptr{Cvoid}, aref)
+    pb = unsafe_convert(Ptr{Cvoid}, bref)
     c = memcmp(pa, pb, min(length(a),length(b)))
     @_gc_preserve_end ta
     @_gc_preserve_end tb
@@ -1862,10 +2007,12 @@ const BitIntegerArray{N} = Union{map(T->Array{T,N}, BitInteger_types)...} where
 # use memcmp for == on bit integer types
 function ==(a::Arr, b::Arr) where {Arr <: BitIntegerArray}
     if size(a) == size(b)
-        ta = @_gc_preserve_begin a
-        tb = @_gc_preserve_begin b
-        pa = unsafe_convert(Ptr{Cvoid}, a)
-        pb = unsafe_convert(Ptr{Cvoid}, b)
+        aref = a.ref
+        bref = b.ref
+        ta = @_gc_preserve_begin aref
+        tb = @_gc_preserve_begin bref
+        pa = unsafe_convert(Ptr{Cvoid}, aref)
+        pb = unsafe_convert(Ptr{Cvoid}, bref)
         c = memcmp(pa, pb, sizeof(eltype(Arr)) * length(a))
         @_gc_preserve_end ta
         @_gc_preserve_end tb
@@ -1878,11 +2025,13 @@ end
 function ==(a::Arr, b::Arr) where Arr <: BitIntegerArray{1}
     len = length(a)
     if len == length(b)
-        ta = @_gc_preserve_begin a
-        tb = @_gc_preserve_begin b
+        aref = a.ref
+        bref = b.ref
+        ta = @_gc_preserve_begin aref
+        tb = @_gc_preserve_begin bref
         T = eltype(Arr)
-        pa = unsafe_convert(Ptr{T}, a)
-        pb = unsafe_convert(Ptr{T}, b)
+        pa = unsafe_convert(Ptr{T}, aref)
+        pb = unsafe_convert(Ptr{T}, bref)
         c = memcmp(pa, pb, sizeof(T) * len)
         @_gc_preserve_end ta
         @_gc_preserve_end tb
diff --git a/base/bitarray.jl b/base/bitarray.jl
index 746dce493f4c0..4411fc9323826 100644
--- a/base/bitarray.jl
+++ b/base/bitarray.jl
@@ -807,7 +807,7 @@ prepend!(B::BitVector, items) = prepend!(B, BitArray(items))
 prepend!(A::Vector{Bool}, items::BitVector) = prepend!(A, Array(items))
 
 function sizehint!(B::BitVector, sz::Integer)
-    ccall(:jl_array_sizehint, Cvoid, (Any, UInt), B.chunks, num_bit_chunks(sz))
+    sizehint!(B.chunks, num_bit_chunks(sz))
     return B
 end
 
diff --git a/base/bitset.jl b/base/bitset.jl
index 240be822fa263..0e26fc28acbd0 100644
--- a/base/bitset.jl
+++ b/base/bitset.jl
@@ -15,7 +15,11 @@ mutable struct BitSet <: AbstractSet{Int}
     # 1st stored Int equals 64*offset
     offset::Int
 
-    BitSet() = new(resize!(Vector{UInt64}(undef, 4), 0), NO_OFFSET)
+    function BitSet()
+        a = Vector{UInt64}(undef, 4) # start with some initial space for holding 0:255 without additional allocations later
+        setfield!(a, :size, (0,)) # aka `empty!(a)` inlined
+        return new(a, NO_OFFSET)
+   end
 end
 
 """
diff --git a/base/boot.jl b/base/boot.jl
index 7f7f4cf02422d..98eceb1414ecc 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -52,8 +52,26 @@
 #abstract type AbstractArray{T,N} end
 #abstract type DenseArray{T,N} <: AbstractArray{T,N} end
 
+#primitive type AddrSpace{Backend::Module} 8 end
+#const CPU = bitcast(AddrSpace{Core}, 0x00)
+
+#struct GenericMemory{kind::Symbol, T, AS::AddrSpace}
+#   length::Int
+#   const data::Ptr{Cvoid} # make this GenericPtr{addrspace, Cvoid}
+#   Union{ # hidden data
+#       elements :: NTuple{length, T}
+#       owner :: Any
+#   }
+#end
+
+# struct GenericMemoryRef{kind::Symbol, T, AS::AddrSpace}
+#    mem::Memory{kind, T, AS}
+#    data::Ptr{Cvoid} # make this GenericPtr{addrspace, Cvoid}
+#end
+
 #mutable struct Array{T,N} <: DenseArray{T,N}
-## opaque
+#  ref::MemoryRef{T}
+#  size::NTuple{N,Int}
 #end
 
 #mutable struct Module
@@ -173,8 +191,8 @@ export
     Tuple, Type, UnionAll, TypeVar, Union, Nothing, Cvoid,
     AbstractArray, DenseArray, NamedTuple, Pair,
     # special objects
-    Function, Method,
-    Module, Symbol, Task, Array, UndefInitializer, undef, WeakRef, VecElement,
+    Function, Method, Array, Memory, MemoryRef, GenericMemory, GenericMemoryRef,
+    Module, Symbol, Task, UndefInitializer, undef, WeakRef, VecElement,
     # numeric types
     Number, Real, Integer, Bool, Ref, Ptr,
     AbstractFloat, Float16, Float32, Float64,
@@ -358,13 +376,15 @@ struct UndefKeywordError <: Exception
     var::Symbol
 end
 
+const typemax_UInt = Intrinsics.sext_int(UInt, 0xFF)
+const typemax_Int = Core.Intrinsics.udiv_int(Core.Intrinsics.sext_int(Int, 0xFF), 2)
+
 struct MethodError <: Exception
     f
     args
     world::UInt
     MethodError(@nospecialize(f), @nospecialize(args), world::UInt) = new(f, args, world)
 end
-const typemax_UInt = ccall(:jl_typemax_uint, Any, (Any,), UInt)
 MethodError(@nospecialize(f), @nospecialize(args)) = MethodError(f, args, typemax_UInt)
 
 struct AssertionError <: Exception
@@ -473,34 +493,107 @@ const NTuple{N,T} = Tuple{Vararg{T,N}}
 ## primitive Array constructors
 struct UndefInitializer end
 const undef = UndefInitializer()
+
+# type and dimensionality specified
+(self::Type{GenericMemory{kind,T,addrspace}})(::UndefInitializer, m::Int) where {T,addrspace,kind} =
+    if isdefined(self, :instance) && m === 0
+        self.instance
+    else
+        ccall(:jl_alloc_genericmemory, Ref{GenericMemory{kind,T,addrspace}}, (Any, Int), self, m)
+    end
+(self::Type{GenericMemory{kind,T,addrspace}})(::UndefInitializer, d::NTuple{1,Int}) where {T,kind,addrspace} = self(undef, getfield(d,1))
+# empty vector constructor
+(self::Type{GenericMemory{kind,T,addrspace}})() where {T,kind,addrspace} = self(undef, 0)
+# copy constructors
+
+const Memory{T} = GenericMemory{:not_atomic, T, CPU}
+const MemoryRef{T} = GenericMemoryRef{:not_atomic, T, CPU}
+GenericMemoryRef(mem::GenericMemory) = memoryref(mem)
+eval(Core, :(GenericMemoryRef(ref::GenericMemoryRef, i::Integer) = memoryref(ref, Int(i), $(Expr(:boundscheck)))))
+eval(Core, :(GenericMemoryRef(mem::GenericMemory, i::Integer) = memoryref(memoryref(mem), Int(i), $(Expr(:boundscheck)))))
+MemoryRef(mem::Memory) = memoryref(mem)
+eval(Core, :(MemoryRef(ref::MemoryRef, i::Integer) = memoryref(ref, Int(i), $(Expr(:boundscheck)))))
+eval(Core, :(MemoryRef(mem::Memory, i::Integer) = memoryref(memoryref(mem), Int(i), $(Expr(:boundscheck)))))
+MemoryRef{T}(mem::Memory{T}) where {T} = memoryref(mem)
+eval(Core, :(MemoryRef{T}(ref::MemoryRef{T}, i::Integer) where {T} = memoryref(ref, Int(i), $(Expr(:boundscheck)))))
+eval(Core, :(MemoryRef{T}(mem::Memory{T}, i::Integer) where {T} = memoryref(memoryref(mem), Int(i), $(Expr(:boundscheck)))))
+
+# construction helpers for Array
+new_as_memoryref(self::Type{GenericMemoryRef{isatomic,T,addrspace}}, m::Int) where {T,isatomic,addrspace} = memoryref(fieldtype(self, :mem)(undef, m))
+
+# checked-multiply intrinsic function for dimensions
+_checked_mul_dims() = 1, false
+_checked_mul_dims(m::Int) = m, Intrinsics.ule_int(typemax_Int, m) # equivalently: (m + 1) < 1
+function _checked_mul_dims(m::Int, n::Int)
+    b = Intrinsics.checked_smul_int(m, n)
+    a = getfield(b, 1)
+    ovflw = getfield(b, 2)
+    ovflw = Intrinsics.or_int(ovflw, Intrinsics.ule_int(typemax_Int, m))
+    ovflw = Intrinsics.or_int(ovflw, Intrinsics.ule_int(typemax_Int, n))
+    return a, ovflw
+end
+function _checked_mul_dims(m::Int, d::Int...)
+   @_foldable_meta # the compiler needs to know this loop terminates
+   a = m
+   i = 1
+   ovflw = false
+   while Intrinsics.sle_int(i, nfields(d))
+     di = getfield(d, i)
+     b = Intrinsics.checked_smul_int(a, di)
+     ovflw = Intrinsics.or_int(ovflw, getfield(b, 2))
+     ovflw = Intrinsics.or_int(ovflw, Intrinsics.ule_int(typemax_Int, di))
+     a = getfield(b, 1)
+     i = Intrinsics.add_int(i, 1)
+   end
+   return a, ovflw
+end
+
+# convert a set of dims to a length, with overflow checking
+checked_dims() = 1
+checked_dims(m::Int) = m # defer this check to Memory constructor instead
+function checked_dims(d::Int...)
+    b = _checked_mul_dims(d...)
+    getfield(b, 2) && throw(ArgumentError("invalid Array dimensions"))
+    return getfield(b, 1)
+end
+
 # type and dimensionality specified, accepting dims as series of Ints
-Array{T,1}(::UndefInitializer, m::Int) where {T} =
-    ccall(:jl_alloc_array_1d, Array{T,1}, (Any, Int), Array{T,1}, m)
-Array{T,2}(::UndefInitializer, m::Int, n::Int) where {T} =
-    ccall(:jl_alloc_array_2d, Array{T,2}, (Any, Int, Int), Array{T,2}, m, n)
-Array{T,3}(::UndefInitializer, m::Int, n::Int, o::Int) where {T} =
-    ccall(:jl_alloc_array_3d, Array{T,3}, (Any, Int, Int, Int), Array{T,3}, m, n, o)
-Array{T,N}(::UndefInitializer, d::Vararg{Int,N}) where {T,N} =
-    ccall(:jl_new_array, Array{T,N}, (Any, Any), Array{T,N}, d)
+eval(Core, :(function (self::Type{Array{T,1}})(::UndefInitializer, m::Int) where {T}
+    @noinline
+    mem = fieldtype(fieldtype(self, :ref), :mem)(undef, m)
+    return $(Expr(:new, :self, :(memoryref(mem)), :((m,))))
+end))
+eval(Core, :(function (self::Type{Array{T,2}})(::UndefInitializer, m::Int, n::Int) where {T}
+    @noinline
+    return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(m, n))), :((m, n))))
+end))
+eval(Core, :(function (self::Type{Array{T,3}})(::UndefInitializer, m::Int, n::Int, o::Int) where {T}
+    @noinline
+    return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(m, n, o))), :((m, n, o))))
+end))
+eval(Core, :(function (self::Type{Array{T, N}})(::UndefInitializer, d::Vararg{Int, N}) where {T, N}
+    @noinline
+    return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(d...))), :d))
+end))
 # type and dimensionality specified, accepting dims as tuples of Ints
-Array{T,1}(::UndefInitializer, d::NTuple{1,Int}) where {T} = Array{T,1}(undef, getfield(d,1))
-Array{T,2}(::UndefInitializer, d::NTuple{2,Int}) where {T} = Array{T,2}(undef, getfield(d,1), getfield(d,2))
-Array{T,3}(::UndefInitializer, d::NTuple{3,Int}) where {T} = Array{T,3}(undef, getfield(d,1), getfield(d,2), getfield(d,3))
-Array{T,N}(::UndefInitializer, d::NTuple{N,Int}) where {T,N} = ccall(:jl_new_array, Array{T,N}, (Any, Any), Array{T,N}, d)
+(self::Type{Array{T,1}})(::UndefInitializer, d::NTuple{1, Int}) where {T} = self(undef, getfield(d, 1))
+(self::Type{Array{T,2}})(::UndefInitializer, d::NTuple{2, Int}) where {T} = self(undef, getfield(d, 1), getfield(d, 2))
+(self::Type{Array{T,3}})(::UndefInitializer, d::NTuple{3, Int}) where {T} = self(undef, getfield(d, 1), getfield(d, 2), getfield(d, 3))
+(self::Type{Array{T,N}})(::UndefInitializer, d::NTuple{N, Int}) where {T, N} = self(undef, d...)
 # type but not dimensionality specified
-Array{T}(::UndefInitializer, m::Int) where {T} = Array{T,1}(undef, m)
-Array{T}(::UndefInitializer, m::Int, n::Int) where {T} = Array{T,2}(undef, m, n)
-Array{T}(::UndefInitializer, m::Int, n::Int, o::Int) where {T} = Array{T,3}(undef, m, n, o)
-Array{T}(::UndefInitializer, d::NTuple{N,Int}) where {T,N} = Array{T,N}(undef, d)
+Array{T}(::UndefInitializer, m::Int) where {T} = Array{T, 1}(undef, m)
+Array{T}(::UndefInitializer, m::Int, n::Int) where {T} = Array{T, 2}(undef, m, n)
+Array{T}(::UndefInitializer, m::Int, n::Int, o::Int) where {T} = Array{T, 3}(undef, m, n, o)
+Array{T}(::UndefInitializer, d::NTuple{N, Int}) where {T, N} = Array{T, N}(undef, d)
 # empty vector constructor
-Array{T,1}() where {T} = Array{T,1}(undef, 0)
+(self::Type{Array{T, 1}})() where {T} = self(undef, 0)
 
-(Array{T,N} where T)(x::AbstractArray{S,N}) where {S,N} = Array{S,N}(x)
+(Array{T, N} where T)(x::AbstractArray{S, N}) where {S, N} = Array{S, N}(x)
 
-Array(A::AbstractArray{T,N})    where {T,N}   = Array{T,N}(A)
-Array{T}(A::AbstractArray{S,N}) where {T,N,S} = Array{T,N}(A)
+Array(A::AbstractArray{T, N})    where {T, N}   = Array{T, N}(A)
+Array{T}(A::AbstractArray{S, N}) where {T, N, S} = Array{T, N}(A)
 
-AbstractArray{T}(A::AbstractArray{S,N}) where {T,S,N} = AbstractArray{T,N}(A)
+AbstractArray{T}(A::AbstractArray{S, N}) where {T, S, N} = AbstractArray{T, N}(A)
 
 # primitive Symbol constructors
 
@@ -515,9 +608,9 @@ function Symbol(s::String)
     @noinline
     return _Symbol(ccall(:jl_string_ptr, Ptr{UInt8}, (Any,), s), sizeof(s), s)
 end
-function Symbol(a::Array{UInt8,1})
+function Symbol(a::Array{UInt8, 1})
     @noinline
-    return _Symbol(ccall(:jl_array_ptr, Ptr{UInt8}, (Any,), a), Intrinsics.arraylen(a), a)
+    return _Symbol(bitcast(Ptr{UInt8}, a.ref.ptr_or_offset), getfield(a.size, 1), a.ref.mem)
 end
 Symbol(s::Symbol) = s
 
@@ -798,8 +891,8 @@ if Int === Int32
 Int64(x::Ptr) = Int64(UInt32(x))
 UInt64(x::Ptr) = UInt64(UInt32(x))
 end
-Ptr{T}(x::Union{Int,UInt,Ptr}) where {T} = bitcast(Ptr{T}, x)
-Ptr{T}() where {T} = Ptr{T}(0)
+(PT::Type{Ptr{T}} where T)(x::Union{Int,UInt,Ptr}=0) = bitcast(PT, x)
+(AS::Type{AddrSpace{Backend}} where Backend)(x::UInt8) = bitcast(AS, x)
 
 Signed(x::UInt8)    = Int8(x)
 Unsigned(x::Int8)   = UInt8(x)
@@ -857,4 +950,13 @@ function _hasmethod(@nospecialize(tt)) # this function has a special tfunc
     return Intrinsics.not_int(ccall(:jl_gf_invoke_lookup, Any, (Any, Any, UInt), tt, nothing, world) === nothing)
 end
 
+
+# for backward compat
+arrayref(inbounds::Bool, A::Array, i::Int...) = Main.Base.getindex(A, i...)
+const_arrayref(inbounds::Bool, A::Array, i::Int...) = Main.Base.getindex(A, i...)
+arrayset(inbounds::Bool, A::Array{T}, x::Any, i::Int...) where {T} = Main.Base.setindex!(A, x::T, i...)
+arraysize(a::Array) = a.size
+arraysize(a::Array, i::Int) = sle_int(i, nfields(a.size)) ? getfield(a.size, i) : 1
+export arrayref, arrayset, arraysize, const_arrayref
+
 ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Core, true)
diff --git a/base/c.jl b/base/c.jl
index 748adb3e93615..1182033802aad 100644
--- a/base/c.jl
+++ b/base/c.jl
@@ -2,7 +2,7 @@
 
 # definitions related to C interface
 
-import Core.Intrinsics: cglobal, bitcast
+import Core.Intrinsics: cglobal
 
 """
     cglobal((symbol, library) [, type=Cvoid])
@@ -91,7 +91,7 @@ Equivalent to the native `char` c-type.
 Cchar
 
 # The ccall here is equivalent to Sys.iswindows(), but that's not defined yet
-@static if ccall(:jl_get_UNAME, Any, ()) === :NT
+if ccall(:jl_get_UNAME, Any, ()) === :NT
     const Clong = Int32
     const Culong = UInt32
     const Cwchar_t = UInt16
@@ -122,32 +122,7 @@ Equivalent to the native `wchar_t` c-type ([`Int32`](@ref)).
 """
 Cwchar_t
 
-"""
-    Cwstring
-
-A C-style string composed of the native wide character type
-[`Cwchar_t`](@ref)s. `Cwstring`s are NUL-terminated. For
-C-style strings composed of the native character
-type, see [`Cstring`](@ref). For more information
-about string interoperability with C, see the
-[manual](@ref man-bits-types).
-
-"""
-Cwstring
-
-"""
-    Cstring
-
-A C-style string composed of the native character type
-[`Cchar`](@ref)s. `Cstring`s are NUL-terminated. For
-C-style strings composed of the native wide character
-type, see [`Cwstring`](@ref). For more information
-about string interoperability with C, see the
-[manual](@ref man-bits-types).
-"""
-Cstring
-
-@static if ccall(:jl_get_UNAME, Any, ()) !== :NT
+if ccall(:jl_get_UNAME, Any, ()) !== :NT
     const sizeof_mode_t = ccall(:jl_sizeof_mode_t, Cint, ())
     if sizeof_mode_t == 2
         const Cmode_t = Int16
@@ -155,295 +130,11 @@ Cstring
         const Cmode_t = Int32
     elseif sizeof_mode_t == 8
         const Cmode_t = Int64
+    else
+        error("invalid sizeof mode_t")
     end
 end
 
-# construction from pointers
-Cstring(p::Union{Ptr{Int8},Ptr{UInt8},Ptr{Cvoid}}) = bitcast(Cstring, p)
-Cwstring(p::Union{Ptr{Cwchar_t},Ptr{Cvoid}})       = bitcast(Cwstring, p)
-Ptr{T}(p::Cstring) where {T<:Union{Int8,UInt8,Cvoid}} = bitcast(Ptr{T}, p)
-Ptr{T}(p::Cwstring) where {T<:Union{Cwchar_t,Cvoid}}  = bitcast(Ptr{Cwchar_t}, p)
-
-convert(::Type{Cstring}, p::Union{Ptr{Int8},Ptr{UInt8},Ptr{Cvoid}}) = Cstring(p)
-convert(::Type{Cwstring}, p::Union{Ptr{Cwchar_t},Ptr{Cvoid}}) = Cwstring(p)
-convert(::Type{Ptr{T}}, p::Cstring) where {T<:Union{Int8,UInt8,Cvoid}} = Ptr{T}(p)
-convert(::Type{Ptr{T}}, p::Cwstring) where {T<:Union{Cwchar_t,Cvoid}} = Ptr{T}(p)
-
-"""
-    pointer(array [, index])
-
-Get the native address of an array or string, optionally at a given location `index`.
-
-This function is "unsafe". Be careful to ensure that a Julia reference to
-`array` exists as long as this pointer will be used. The [`GC.@preserve`](@ref)
-macro should be used to protect the `array` argument from garbage collection
-within a given block of code.
-
-Calling [`Ref(array[, index])`](@ref Ref) is generally preferable to this function as it guarantees validity.
-"""
-function pointer end
-
-pointer(p::Cstring) = convert(Ptr{Cchar}, p)
-pointer(p::Cwstring) = convert(Ptr{Cwchar_t}, p)
-
-# comparisons against pointers (mainly to support `cstr==C_NULL`)
-==(x::Union{Cstring,Cwstring}, y::Ptr) = pointer(x) == y
-==(x::Ptr, y::Union{Cstring,Cwstring}) = x == pointer(y)
-
-unsafe_string(s::Cstring) = unsafe_string(convert(Ptr{UInt8}, s))
-
-# convert strings to String etc. to pass as pointers
-cconvert(::Type{Cstring}, s::String) = s
-cconvert(::Type{Cstring}, s::AbstractString) =
-    cconvert(Cstring, String(s)::String)
-
-function cconvert(::Type{Cwstring}, s::AbstractString)
-    v = transcode(Cwchar_t, String(s))
-    push!(v, 0)
-    return cconvert(Cwstring, v)
-end
-
-eltype(::Type{Cstring}) = Cchar
-eltype(::Type{Cwstring}) = Cwchar_t
-
-containsnul(p::Ptr, len) =
-    C_NULL != ccall(:memchr, Ptr{Cchar}, (Ptr{Cchar}, Cint, Csize_t), p, 0, len)
-containsnul(s::String) = containsnul(unsafe_convert(Ptr{Cchar}, s), sizeof(s))
-containsnul(s::AbstractString) = '\0' in s
-
-function unsafe_convert(::Type{Cstring}, s::String)
-    p = unsafe_convert(Ptr{Cchar}, s)
-    containsnul(p, sizeof(s)) &&
-        throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(s))"))
-    return Cstring(p)
-end
-
-unsafe_convert(::Type{Cstring}, s::Union{Vector{UInt8},Vector{Int8}}) = Cstring(unsafe_convert(Ptr{Cvoid}, s))
-
-function cconvert(::Type{Cwstring}, v::Vector{Cwchar_t})
-    for i = 1:length(v)-1
-        v[i] == 0 &&
-            throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(v))"))
-    end
-    v[end] == 0 ||
-        throw(ArgumentError("C string data must be NUL terminated: $(repr(v))"))
-    return cconvert(Ptr{Cwchar_t}, v)
-end
-unsafe_convert(::Type{Cwstring}, s) = Cwstring(unsafe_convert(Ptr{Cwchar_t}, s))
-unsafe_convert(::Type{Cwstring}, s::Cwstring) = s
-
-# symbols are guaranteed not to contain embedded NUL
-cconvert(::Type{Cstring}, s::Symbol) = s
-unsafe_convert(::Type{Cstring}, s::Symbol) = Cstring(unsafe_convert(Ptr{Cchar}, s))
-
-@static if ccall(:jl_get_UNAME, Any, ()) === :NT
-"""
-    Base.cwstring(s)
-
-Converts a string `s` to a NUL-terminated `Vector{Cwchar_t}`, suitable for passing to C
-functions expecting a `Ptr{Cwchar_t}`. The main advantage of using this over the implicit
-conversion provided by [`Cwstring`](@ref) is if the function is called multiple times with the
-same argument.
-
-This is only available on Windows.
-"""
-function cwstring(s::AbstractString)
-    bytes = codeunits(String(s))
-    0 in bytes && throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(s))"))
-    return push!(transcode(UInt16, bytes), 0)
-end
-end
-
-# transcoding between data in UTF-8 and UTF-16 for Windows APIs,
-# and also UTF-32 for APIs using Cwchar_t on other platforms.
-
-"""
-    transcode(T, src)
-
-Convert string data between Unicode encodings. `src` is either a
-`String` or a `Vector{UIntXX}` of UTF-XX code units, where
-`XX` is 8, 16, or 32. `T` indicates the encoding of the return value:
-`String` to return a (UTF-8 encoded) `String` or `UIntXX`
-to return a `Vector{UIntXX}` of UTF-`XX` data. (The alias [`Cwchar_t`](@ref)
-can also be used as the integer type, for converting `wchar_t*` strings
-used by external C libraries.)
-
-The `transcode` function succeeds as long as the input data can be
-reasonably represented in the target encoding; it always succeeds for
-conversions between UTF-XX encodings, even for invalid Unicode data.
-
-Only conversion to/from UTF-8 is currently supported.
-
-# Examples
-```jldoctest
-julia> str = "αβγ"
-"αβγ"
-
-julia> transcode(UInt16, str)
-3-element Vector{UInt16}:
- 0x03b1
- 0x03b2
- 0x03b3
-
-julia> transcode(String, transcode(UInt16, str))
-"αβγ"
-```
-"""
-function transcode end
-
-transcode(::Type{T}, src::AbstractVector{T}) where {T<:Union{UInt8,UInt16,UInt32,Int32}} = src
-transcode(::Type{T}, src::String) where {T<:Union{Int32,UInt32}} = T[T(c) for c in src]
-transcode(::Type{T}, src::AbstractVector{UInt8}) where {T<:Union{Int32,UInt32}} =
-    transcode(T, String(Vector(src)))
-transcode(::Type{T}, src::CodeUnits{UInt8,String}) where {T<:Union{Int32,UInt32}} =
-    transcode(T, String(src))
-
-function transcode(::Type{UInt8}, src::Vector{<:Union{Int32,UInt32}})
-    buf = IOBuffer()
-    for c in src
-        print(buf, Char(c))
-    end
-    take!(buf)
-end
-transcode(::Type{String}, src::String) = src
-transcode(T, src::String) = transcode(T, codeunits(src))
-transcode(::Type{String}, src) = String(transcode(UInt8, src))
-
-function transcode(::Type{UInt16}, src::AbstractVector{UInt8})
-    require_one_based_indexing(src)
-    dst = UInt16[]
-    i, n = 1, length(src)
-    n > 0 || return dst
-    sizehint!(dst, 2n)
-    a = src[1]
-    while true
-        if i < n && -64 <= a % Int8 <= -12 # multi-byte character
-            b = src[i += 1]
-            if -64 <= (b % Int8) || a == 0xf4 && 0x8f < b
-                # invalid UTF-8 (non-continuation or too-high code point)
-                push!(dst, a)
-                a = b; continue
-            elseif a < 0xe0 # 2-byte UTF-8
-                push!(dst, xor(0x3080, UInt16(a) << 6, b))
-            elseif i < n # 3/4-byte character
-                c = src[i += 1]
-                if -64 <= (c % Int8) # invalid UTF-8 (non-continuation)
-                    push!(dst, a, b)
-                    a = c; continue
-                elseif a < 0xf0 # 3-byte UTF-8
-                    push!(dst, xor(0x2080, UInt16(a) << 12, UInt16(b) << 6, c))
-                elseif i < n
-                    d = src[i += 1]
-                    if -64 <= (d % Int8) # invalid UTF-8 (non-continuation)
-                        push!(dst, a, b, c)
-                        a = d; continue
-                    elseif a == 0xf0 && b < 0x90 # overlong encoding
-                        push!(dst, xor(0x2080, UInt16(b) << 12, UInt16(c) << 6, d))
-                    else # 4-byte UTF-8
-                        push!(dst, 0xe5b8 + (UInt16(a) << 8) + (UInt16(b) << 2) + (c >> 4),
-                                   xor(0xdc80, UInt16(c & 0xf) << 6, d))
-                    end
-                else # too short
-                    push!(dst, a, b, c)
-                    break
-                end
-            else # too short
-                push!(dst, a, b)
-                break
-            end
-        else # ASCII or invalid UTF-8 (continuation byte or too-high code point)
-            push!(dst, a)
-        end
-        i < n || break
-        a = src[i += 1]
-    end
-    return dst
-end
-
-function transcode(::Type{UInt8}, src::AbstractVector{UInt16})
-    require_one_based_indexing(src)
-    n = length(src)
-    n == 0 && return UInt8[]
-
-    # Precompute m = sizeof(dst).   This involves annoying duplication
-    # of the loop over the src array.   However, this is not just an
-    # optimization: it is problematic for security reasons to grow
-    # dst dynamically, because Base.winprompt uses this function to
-    # convert passwords to UTF-8 and we don't want to make unintentional
-    # copies of the password data.
-    a = src[1]
-    i, m = 1, 0
-    while true
-        if a < 0x80
-            m += 1
-        elseif a < 0x800 # 2-byte UTF-8
-            m += 2
-        elseif a & 0xfc00 == 0xd800 && i < length(src)
-            b = src[i += 1]
-            if (b & 0xfc00) == 0xdc00 # 2-unit UTF-16 sequence => 4-byte UTF-8
-                m += 4
-            else
-                m += 3
-                a = b; continue
-            end
-        else
-            # 1-unit high UTF-16 or unpaired high surrogate
-            # either way, encode as 3-byte UTF-8 code point
-            m += 3
-        end
-        i < n || break
-        a = src[i += 1]
-    end
-
-    dst = StringVector(m)
-    a = src[1]
-    i, j = 1, 0
-    while true
-        if a < 0x80 # ASCII
-            dst[j += 1] = a % UInt8
-        elseif a < 0x800 # 2-byte UTF-8
-            dst[j += 1] = 0xc0 | ((a >> 6) % UInt8)
-            dst[j += 1] = 0x80 | ((a % UInt8) & 0x3f)
-        elseif a & 0xfc00 == 0xd800 && i < n
-            b = src[i += 1]
-            if (b & 0xfc00) == 0xdc00
-                # 2-unit UTF-16 sequence => 4-byte UTF-8
-                a += 0x2840
-                dst[j += 1] = 0xf0 | ((a >> 8) % UInt8)
-                dst[j += 1] = 0x80 | ((a % UInt8) >> 2)
-                dst[j += 1] = xor(0xf0, ((a % UInt8) << 4) & 0x3f, (b >> 6) % UInt8)
-                dst[j += 1] = 0x80 | ((b % UInt8) & 0x3f)
-            else
-                dst[j += 1] = 0xe0 | ((a >> 12) % UInt8)
-                dst[j += 1] = 0x80 | (((a >> 6) % UInt8) & 0x3f)
-                dst[j += 1] = 0x80 | ((a % UInt8) & 0x3f)
-                a = b; continue
-            end
-        else
-            # 1-unit high UTF-16 or unpaired high surrogate
-            # either way, encode as 3-byte UTF-8 code point
-            dst[j += 1] = 0xe0 | ((a >> 12) % UInt8)
-            dst[j += 1] = 0x80 | (((a >> 6) % UInt8) & 0x3f)
-            dst[j += 1] = 0x80 | ((a % UInt8) & 0x3f)
-        end
-        i < n || break
-        a = src[i += 1]
-    end
-    return dst
-end
-
-function unsafe_string(p::Ptr{T}, length::Integer) where {T<:Union{UInt16,UInt32,Cwchar_t}}
-    transcode(String, unsafe_wrap(Array, p, length; own=false))
-end
-function unsafe_string(cw::Cwstring)
-    p = convert(Ptr{Cwchar_t}, cw)
-    n = 1
-    while unsafe_load(p, n) != 0
-        n += 1
-    end
-    return unsafe_string(p, n - 1)
-end
-
 # deferring (or un-deferring) ctrl-c handler for external C code that
 # is not interrupt safe (see also issue #2622).  The sigatomic_begin/end
 # functions should always be called in matched pairs, ideally via:
@@ -579,21 +270,21 @@ The above input outputs this:
 """
 function ccall_macro_parse(expr::Expr)
     # setup and check for errors
-    if !Meta.isexpr(expr, :(::))
+    if !isexpr(expr, :(::))
         throw(ArgumentError("@ccall needs a function signature with a return type"))
     end
     rettype = expr.args[2]
 
     call = expr.args[1]
-    if !Meta.isexpr(call, :call)
+    if !isexpr(call, :call)
         throw(ArgumentError("@ccall has to take a function call"))
     end
 
     # get the function symbols
     func = let f = call.args[1]
-        if Meta.isexpr(f, :.)
+        if isexpr(f, :.)
             :(($(f.args[2]), $(f.args[1])))
-        elseif Meta.isexpr(f, :$)
+        elseif isexpr(f, :$)
             f
         elseif f isa Symbol
             QuoteNode(f)
@@ -606,7 +297,7 @@ function ccall_macro_parse(expr::Expr)
     varargs = nothing
     argstart = 2
     callargs = call.args
-    if length(callargs) >= 2 && Meta.isexpr(callargs[2], :parameters)
+    if length(callargs) >= 2 && isexpr(callargs[2], :parameters)
         argstart = 3
         varargs = callargs[2].args
     end
@@ -616,7 +307,7 @@ function ccall_macro_parse(expr::Expr)
     types = []
 
     function pusharg!(arg)
-        if !Meta.isexpr(arg, :(::))
+        if !isexpr(arg, :(::))
             throw(ArgumentError("args in @ccall need type annotations. '$arg' doesn't have one."))
         end
         push!(args, arg.args[1])
@@ -646,7 +337,7 @@ function ccall_macro_lower(convention, func, rettype, types, args, nreq)
     statements = []
 
     # if interpolation was used, ensure the value is a function pointer at runtime.
-    if Meta.isexpr(func, :$)
+    if isexpr(func, :$)
         push!(statements, Expr(:(=), :func, esc(func.args[1])))
         name = QuoteNode(func.args[1])
         func = :func
diff --git a/base/cmem.jl b/base/cmem.jl
index 8b0b99b3a6ebd..dd4cbc30585f2 100644
--- a/base/cmem.jl
+++ b/base/cmem.jl
@@ -10,6 +10,7 @@ Call `memcpy` from the C standard library.
 
 """
 function memcpy(dst::Ptr, src::Ptr, n::Integer)
+    @_terminates_globally_meta
     ccall(:memcpy, Ptr{Cvoid}, (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), dst, src, n)
 end
 
@@ -23,6 +24,7 @@ Call `memmove` from the C standard library.
 
 """
 function memmove(dst::Ptr, src::Ptr, n::Integer)
+    @_terminates_globally_meta
     ccall(:memmove, Ptr{Cvoid}, (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), dst, src, n)
 end
 
@@ -36,6 +38,7 @@ Call `memset` from the C standard library.
 
 """
 function memset(p::Ptr, val, n::Integer)
+    @_terminates_globally_meta
     ccall(:memset, Ptr{Cvoid}, (Ptr{Cvoid}, Cint, Csize_t), p, val, n)
 end
 
@@ -49,5 +52,6 @@ Call `memcmp` from the C standard library.
 
 """
 function memcmp(a::Ptr, b::Ptr, n::Integer)
+    @_terminates_globally_meta
     ccall(:memcmp, Cint, (Ptr{Cvoid}, Ptr{Cvoid}, Csize_t), a, b, n % Csize_t) % Int
 end
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index bbbff8e250e8b..d3d7d82a1e150 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1419,7 +1419,7 @@ function precise_container_type(interp::AbstractInterpreter, @nospecialize(itft)
         return AbstractIterationResult(Any[Vararg{Any}], nothing)
     elseif tti0 === Any
         return AbstractIterationResult(Any[Vararg{Any}], nothing, Effects())
-    elseif tti0 <: Array
+    elseif tti0 <: Array || tti0 <: GenericMemory
         if eltype(tti0) === Union{}
             return AbstractIterationResult(Any[], nothing)
         end
@@ -1686,7 +1686,7 @@ end
         thentype = Bottom
     elseif rt === Const(true)
         elsetype = Bottom
-    elseif elsetype isa Type && isdefined(typeof(c.val), :instance) # can only widen a if it is a singleton
+    elseif elsetype isa Type && issingletontype(typeof(c.val)) # can only widen a if it is a singleton
         elsetype = typesubtract(elsetype, typeof(c.val), max_union_splitting)
     end
     return ConditionalTypes(thentype, elsetype)
diff --git a/base/compiler/compiler.jl b/base/compiler/compiler.jl
index 31db9a5551c2b..997e6989312f3 100644
--- a/base/compiler/compiler.jl
+++ b/base/compiler/compiler.jl
@@ -104,6 +104,7 @@ include("strings/lazy.jl")
 
 # core array operations
 include("indices.jl")
+include("genericmemory.jl")
 include("array.jl")
 include("abstractarray.jl")
 
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 74722f2538424..de05e837a419e 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -1079,12 +1079,12 @@ function statement_cost(ex::Expr, line::Int, src::Union{CodeInfo, IRCode}, sptyp
                 # tuple iteration/destructuring makes that impossible
                 # return plus_saturate(argcost, isknowntype(extyp) ? 1 : params.inline_nonleaf_penalty)
                 return 0
-            elseif (f === Core.arrayref || f === Core.const_arrayref) && length(ex.args) >= 3
-                atyp = argextype(ex.args[3], src, sptypes)
-                return isknowntype(atyp) ? 4 : error_path ? params.inline_error_path_cost : params.inline_nonleaf_penalty
-            elseif f === Core.arrayset && length(ex.args) >= 3
+            elseif (f === Core.memoryrefget || f === Core.memoryref_isassigned) && length(ex.args) >= 3
                 atyp = argextype(ex.args[2], src, sptypes)
-                return isknowntype(atyp) ? 8 : error_path ? params.inline_error_path_cost : params.inline_nonleaf_penalty
+                return isknowntype(atyp) ? 1 : error_path ? params.inline_error_path_cost : params.inline_nonleaf_penalty
+            elseif f === Core.memoryrefset! && length(ex.args) >= 3
+                atyp = argextype(ex.args[2], src, sptypes)
+                return isknowntype(atyp) ? 5 : error_path ? params.inline_error_path_cost : params.inline_nonleaf_penalty
             elseif f === typeassert && isconstType(widenconst(argextype(ex.args[3], src, sptypes)))
                 return 1
             end
diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index 6a6994d497d8e..a770a4a92146c 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -15,9 +15,7 @@ const _TOP_MOD = ccall(:jl_base_relative_to, Any, (Any,), EscapeAnalysis)::Modul
 # imports
 import ._TOP_MOD: ==, getindex, setindex!
 # usings
-using Core:
-    MethodMatch, SimpleVector,
-    arrayref, arrayset, arraysize, ifelse, sizeof
+using Core: MethodMatch, SimpleVector, ifelse, sizeof
 using Core.IR
 using ._TOP_MOD:     # Base definitions
     @__MODULE__, @assert, @eval, @goto, @inbounds, @inline, @label, @noinline,
@@ -27,8 +25,7 @@ using ._TOP_MOD:     # Base definitions
     unwrap_unionall, !, !=, !==, &, *, +, -, :, <, <<, =>, >, |, ∈, ∉, ∩, ∪, ≠, ≤, ≥, ⊆
 using Core.Compiler: # Core.Compiler specific definitions
     Bottom, IRCode, IR_FLAG_NOTHROW, InferenceResult, SimpleInferenceLattice,
-    alloc_array_ndims, argextype, array_builtin_common_typecheck, arrayset_typecheck,
-    check_effect_free!, fieldcount_noerror, hasintersect, intrinsic_nothrow,
+    argextype, check_effect_free!, fieldcount_noerror, hasintersect, intrinsic_nothrow,
     is_meta_expr_head, isbitstype, isexpr, println, setfield!_nothrow, singleton_type,
     try_compute_field, try_compute_fieldidx, widenconst, ⊑
 
@@ -737,39 +734,6 @@ function compute_frameinfo(ir::IRCode)
             leave_block = stmt.args[1]::Int
             leave_pc = first(ir.cfg.blocks[leave_block].stmts)
             push!(tryregions, idx:leave_pc)
-        elseif isexpr(stmt, :foreigncall)
-            args = stmt.args
-            name = args[1]
-            nn = normalize(name)
-            isa(nn, Symbol) || @goto next_stmt
-            ndims = alloc_array_ndims(nn)
-            ndims === nothing && @goto next_stmt
-            if ndims ≠ 0
-                length(args) ≥ ndims+6 || @goto next_stmt
-                dims = Int[]
-                for i in 1:ndims
-                    dim = argextype(args[i+6], ir)
-                    isa(dim, Const) || @goto next_stmt
-                    dim = dim.val
-                    isa(dim, Int) || @goto next_stmt
-                    push!(dims, dim)
-                end
-            else
-                length(args) ≥ 7 || @goto next_stmt
-                dims = argextype(args[7], ir)
-                if isa(dims, Const)
-                    dims = dims.val
-                    isa(dims, Tuple{Vararg{Int}}) || @goto next_stmt
-                    dims = collect(Int, dims)
-                else
-                    dims === Tuple{} || @goto next_stmt
-                    dims = Int[]
-                end
-            end
-            if arrayinfo === nothing
-                arrayinfo = ArrayInfo()
-            end
-            arrayinfo[idx] = dims
         elseif arrayinfo !== nothing
             # TODO this super limited alias analysis is able to handle only very simple cases
             # this should be replaced with a proper forward dimension analysis
@@ -1163,19 +1127,6 @@ function escape_foreigncall!(astate::AnalysisState, pc::Int, args::Vector{Any})
     name = args[1]
     nn = normalize(name)
     if isa(nn, Symbol)
-        boundserror_ninds = array_resize_info(nn)
-        if boundserror_ninds !== nothing
-            boundserror, ninds = boundserror_ninds
-            escape_array_resize!(boundserror, ninds, astate, pc, args)
-            return
-        end
-        if is_array_copy(nn)
-            escape_array_copy!(astate, pc, args)
-            return
-        elseif is_array_isassigned(nn)
-            escape_array_isassigned!(astate, pc, args)
-            return
-        end
         # if nn === :jl_gc_add_finalizer_th
         #     # TODO add `FinalizerEscape` ?
         # end
@@ -1510,139 +1461,6 @@ function escape_builtin!(::typeof(setfield!), astate::AnalysisState, pc::Int, ar
     end
 end
 
-function escape_builtin!(::typeof(arrayref), astate::AnalysisState, pc::Int, args::Vector{Any})
-    length(args) ≥ 4 || return false
-    # check potential thrown escapes from this arrayref call
-    argtypes = Any[argextype(args[i], astate.ir) for i in 2:length(args)]
-    boundcheckt = argtypes[1]
-    aryt = argtypes[2]
-    if !array_builtin_common_typecheck(boundcheckt, aryt, argtypes, 3)
-        add_thrown_escapes!(astate, pc, args, 2)
-    end
-    ary = args[3]
-    inbounds = isa(boundcheckt, Const) && !boundcheckt.val::Bool
-    inbounds || add_escape_change!(astate, ary, ThrownEscape(pc))
-    # we don't track precise index information about this array and thus don't know what values
-    # can be referenced here: directly propagate the escape information imposed on the return
-    # value of this `arrayref` call to the array itself as the most conservative propagation
-    # but also with updated index information
-    estate = astate.estate
-    if isa(ary, SSAValue) || isa(ary, Argument)
-        aryinfo = estate[ary]
-    else
-        # unanalyzable object, so the return value is also unanalyzable
-        add_escape_change!(astate, SSAValue(pc), ⊤)
-        return true
-    end
-    AliasInfo = aryinfo.AliasInfo
-    if isa(AliasInfo, Bool)
-        AliasInfo && @goto conservative_propagation
-        # AliasInfo of this array hasn't been analyzed yet: set AliasInfo now
-        idx = array_nd_index(astate, ary, args[4:end])
-        if isa(idx, Int)
-            AliasInfo = IndexableElements(IdDict{Int,AInfo}())
-            @goto record_indexable_use
-        end
-        AliasInfo = Unindexable()
-        @goto record_unindexable_use
-    elseif isa(AliasInfo, IndexableElements)
-        idx = array_nd_index(astate, ary, args[4:end])
-        if !isa(idx, Int)
-            AliasInfo = merge_to_unindexable(AliasInfo)
-            @goto record_unindexable_use
-        end
-        @label record_indexable_use
-        info = get!(()->AInfo(), AliasInfo.infos, idx)
-        push!(info, LocalUse(pc))
-        add_escape_change!(astate, ary, EscapeInfo(aryinfo, AliasInfo)) # update with new AliasInfo
-    elseif isa(AliasInfo, Unindexable)
-        @label record_unindexable_use
-        push!(AliasInfo.info, LocalUse(pc))
-        add_escape_change!(astate, ary, EscapeInfo(aryinfo, AliasInfo)) # update with new AliasInfo
-    else
-        # this object has been used as struct, but it is used as array here (thus should throw)
-        # update ary's element information and just handle this case conservatively
-        aryinfo = escape_unanalyzable_obj!(astate, ary, aryinfo)
-        @label conservative_propagation
-        # at the extreme case, an element of `ary` may point to `ary` itself
-        # so add the alias change here as the most conservative propagation
-        add_alias_change!(astate, ary, SSAValue(pc))
-    end
-    return true
-end
-
-function escape_builtin!(::typeof(arrayset), astate::AnalysisState, pc::Int, args::Vector{Any})
-    length(args) ≥ 5 || return false
-    # check potential escapes from this arrayset call
-    # NOTE here we essentially only need to account for TypeError, assuming that
-    # UndefRefError or BoundsError don't capture any of the arguments here
-    argtypes = Any[argextype(args[i], astate.ir) for i in 2:length(args)]
-    boundcheckt = argtypes[1]
-    aryt = argtypes[2]
-    valt = argtypes[3]
-    if !(array_builtin_common_typecheck(boundcheckt, aryt, argtypes, 4) &&
-         arrayset_typecheck(aryt, valt))
-        add_thrown_escapes!(astate, pc, args, 2)
-    end
-    ary = args[3]
-    val = args[4]
-    inbounds = isa(boundcheckt, Const) && !boundcheckt.val::Bool
-    inbounds || add_escape_change!(astate, ary, ThrownEscape(pc))
-    # we don't track precise index information about this array and won't record what value
-    # is being assigned here: directly propagate the escape information of this array to
-    # the value being assigned as the most conservative propagation
-    estate = astate.estate
-    if isa(ary, SSAValue) || isa(ary, Argument)
-        aryinfo = estate[ary]
-    else
-        # unanalyzable object (e.g. obj::GlobalRef): escape field value conservatively
-        add_escape_change!(astate, val, ⊤)
-        return true
-    end
-    AliasInfo = aryinfo.AliasInfo
-    if isa(AliasInfo, Bool)
-        AliasInfo && @goto conservative_propagation
-        # AliasInfo of this array hasn't been analyzed yet: set AliasInfo now
-        idx = array_nd_index(astate, ary, args[5:end])
-        if isa(idx, Int)
-            AliasInfo = IndexableElements(IdDict{Int,AInfo}())
-            @goto escape_indexable_def
-        end
-        AliasInfo = Unindexable()
-        @goto escape_unindexable_def
-    elseif isa(AliasInfo, IndexableElements)
-        idx = array_nd_index(astate, ary, args[5:end])
-        if !isa(idx, Int)
-            AliasInfo = merge_to_unindexable(AliasInfo)
-            @goto escape_unindexable_def
-        end
-        @label escape_indexable_def
-        info = get!(()->AInfo(), AliasInfo.infos, idx)
-        add_alias_escapes!(astate, val, info)
-        push!(info, LocalDef(pc))
-        add_escape_change!(astate, ary, EscapeInfo(aryinfo, AliasInfo)) # update with new AliasInfo
-        # propagate the escape information of this array ignoring elements information
-        add_escape_change!(astate, val, ignore_aliasinfo(aryinfo))
-    elseif isa(AliasInfo, Unindexable)
-        @label escape_unindexable_def
-        add_alias_escapes!(astate, val, AliasInfo.info)
-        push!(AliasInfo.info, LocalDef(pc))
-        add_escape_change!(astate, ary, EscapeInfo(aryinfo, AliasInfo)) # update with new AliasInfo
-        # propagate the escape information of this array ignoring elements information
-        add_escape_change!(astate, val, ignore_aliasinfo(aryinfo))
-    else
-        # this object has been used as struct, but it is used as array here (thus should throw)
-        # update ary's element information and just handle this case conservatively
-        aryinfo = escape_unanalyzable_obj!(astate, ary, aryinfo)
-        @label conservative_propagation
-        add_alias_change!(astate, val, ary)
-    end
-    # also propagate escape information imposed on the return value of this `arrayset`
-    ssainfo = estate[SSAValue(pc)]
-    add_escape_change!(astate, ary, ssainfo)
-    return true
-end
-
 # NOTE this function models and thus should be synced with the implementation of:
 # size_t array_nd_index(jl_array_t *a, jl_value_t **args, size_t nidxs, ...)
 function array_nd_index(astate::AnalysisState, @nospecialize(ary), args::Vector{Any}, nidxs::Int = length(args))
@@ -1676,63 +1494,6 @@ function array_nd_index(astate::AnalysisState, @nospecialize(ary), args::Vector{
     return i
 end
 
-function escape_builtin!(::typeof(arraysize), astate::AnalysisState, pc::Int, args::Vector{Any})
-    length(args) == 3 || return false
-    ary = args[2]
-    dim = args[3]
-    if !arraysize_typecheck(ary, dim, astate.ir)
-        add_escape_change!(astate, ary, ThrownEscape(pc))
-        add_escape_change!(astate, dim, ThrownEscape(pc))
-    end
-    # NOTE we may still see "arraysize: dimension out of range", but it doesn't capture anything
-    return true
-end
-
-function arraysize_typecheck(@nospecialize(ary), @nospecialize(dim), ir::IRCode)
-    aryt = argextype(ary, ir)
-    aryt ⊑ Array || return false
-    dimt = argextype(dim, ir)
-    dimt ⊑ Int || return false
-    return true
-end
-
-# returns nothing if this isn't array resizing operation,
-# otherwise returns true if it can throw BoundsError and false if not
-function array_resize_info(name::Symbol)
-    if name === :jl_array_grow_beg || name === :jl_array_grow_end
-        return false, 1
-    elseif name === :jl_array_del_beg || name === :jl_array_del_end
-        return true, 1
-    elseif name === :jl_array_grow_at || name === :jl_array_del_at
-        return true, 2
-    else
-        return nothing
-    end
-end
-
-# NOTE may potentially throw "cannot resize array with shared data" error,
-# but just ignore it since it doesn't capture anything
-function escape_array_resize!(boundserror::Bool, ninds::Int,
-    astate::AnalysisState, pc::Int, args::Vector{Any})
-    length(args) ≥ 6+ninds || return add_fallback_changes!(astate, pc, args)
-    ary = args[6]
-    aryt = argextype(ary, astate.ir)
-    aryt ⊑ Array || return add_fallback_changes!(astate, pc, args)
-    for i in 1:ninds
-        ind = args[i+6]
-        indt = argextype(ind, astate.ir)
-        indt ⊑ Integer || return add_fallback_changes!(astate, pc, args)
-    end
-    if boundserror
-        # this array resizing can potentially throw `BoundsError`, impose it now
-        add_escape_change!(astate, ary, ThrownEscape(pc))
-    end
-    # give up indexing analysis whenever we see array resizing
-    # (since we track array dimensions only globally)
-    mark_unindexable!(astate, ary)
-    add_liveness_changes!(astate, pc, args, 6)
-end
-
 function mark_unindexable!(astate::AnalysisState, @nospecialize(ary))
     isa(ary, SSAValue) || return
     aryinfo = astate.estate[ary]
@@ -1742,8 +1503,6 @@ function mark_unindexable!(astate::AnalysisState, @nospecialize(ary))
     add_escape_change!(astate, ary, EscapeInfo(aryinfo, AliasInfo))
 end
 
-is_array_copy(name::Symbol) = name === :jl_array_copy
-
 # FIXME this implementation is very conservative, improve the accuracy and solve broken test cases
 function escape_array_copy!(astate::AnalysisState, pc::Int, args::Vector{Any})
     length(args) ≥ 6 || return add_fallback_changes!(astate, pc, args)
@@ -1760,53 +1519,4 @@ function escape_array_copy!(astate::AnalysisState, pc::Int, args::Vector{Any})
     add_liveness_changes!(astate, pc, args, 6)
 end
 
-is_array_isassigned(name::Symbol) = name === :jl_array_isassigned
-
-function escape_array_isassigned!(astate::AnalysisState, pc::Int, args::Vector{Any})
-    if !array_isassigned_nothrow(args, astate.ir)
-        add_thrown_escapes!(astate, pc, args)
-    end
-    add_liveness_changes!(astate, pc, args, 6)
-end
-
-function array_isassigned_nothrow(args::Vector{Any}, src::IRCode)
-    # if !validate_foreigncall_args(args,
-    #     :jl_array_isassigned, Cint, svec(Any,Csize_t), 0, :ccall)
-    #     return false
-    # end
-    length(args) ≥ 7 || return false
-    arytype = argextype(args[6], src)
-    arytype ⊑ Array || return false
-    idxtype = argextype(args[7], src)
-    idxtype ⊑ Csize_t || return false
-    return true
-end
-
-# # COMBAK do we want to enable this (and also backport this to Base for array allocations?)
-# using Core.Compiler: Cint, svec
-# function validate_foreigncall_args(args::Vector{Any},
-#     name::Symbol, @nospecialize(rt), argtypes::SimpleVector, nreq::Int, convention::Symbol)
-#     length(args) ≥ 5 || return false
-#     normalize(args[1]) === name || return false
-#     args[2] === rt || return false
-#     args[3] === argtypes || return false
-#     args[4] === vararg || return false
-#     normalize(args[5]) === convention || return false
-#     return true
-# end
-#
-# using Core: ImmutableArray, arrayfreeze, mutating_arrayfreeze, arraythaw
-#
-# escape_builtin!(::typeof(arrayfreeze), astate::AnalysisState, pc::Int, args::Vector{Any}) =
-#     is_safe_immutable_array_op(Array, astate, args)
-# escape_builtin!(::typeof(mutating_arrayfreeze), astate::AnalysisState, pc::Int, args::Vector{Any}) =
-#     is_safe_immutable_array_op(Array, astate, args)
-# escape_builtin!(::typeof(arraythaw), astate::AnalysisState, pc::Int, args::Vector{Any}) =
-#     is_safe_immutable_array_op(ImmutableArray, astate, args)
-# function is_safe_immutable_array_op(@nospecialize(arytype), astate::AnalysisState, args::Vector{Any})
-#     length(args) == 2 || return false
-#     argextype(args[2], astate.ir) ⊑ arytype || return false
-#     return true
-# end
-
 end # baremodule EscapeAnalysis
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index ed46c4aafbdbf..75eb467776236 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -758,7 +758,7 @@ function rewrite_apply_exprargs!(todo::Vector{Pair{Int,Any}},
                         ti = ti.parameters[2]::DataType # checked by `is_valid_type_for_apply_rewrite`
                     end
                     for p in ti.parameters
-                        if isa(p, DataType) && isdefined(p, :instance)
+                        if issingletontype(p)
                             # replace singleton types with their equivalent Const object
                             p = Const(p.instance)
                         elseif isconstType(p)
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index d332c88bd240c..cf6af02ba020a 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -291,7 +291,7 @@ add_tfunc(checked_umul_int, 2, 2, chk_tfunc, 5)
 # -----------
 
 @nospecs function llvmcall_tfunc(𝕃::AbstractLattice, fptr, rt, at, a...)
-    return instanceof_tfunc(rt, true)[1]
+    return instanceof_tfunc(rt)[1]
 end
 add_tfunc(Core.Intrinsics.llvmcall, 3, INT_INF, llvmcall_tfunc, 10)
 
@@ -303,7 +303,6 @@ end
 add_tfunc(Core.Intrinsics.cglobal, 1, 2, cglobal_tfunc, 5)
 
 add_tfunc(Core.Intrinsics.have_fma, 1, 1, @nospecs((𝕃::AbstractLattice, x)->Bool), 1)
-add_tfunc(Core.Intrinsics.arraylen, 1, 1, @nospecs((𝕃::AbstractLattice, x)->Int), 4)
 
 # builtin functions
 # =================
@@ -488,8 +487,8 @@ function sizeof_nothrow(@nospecialize(x))
 end
 
 function _const_sizeof(@nospecialize(x))
-    # Constant Vector does not have constant size
-    isa(x, Vector) && return Int
+    # Constant GenericMemory does not have constant size
+    isa(x, GenericMemory) && return Int
     size = try
             Core.sizeof(x)
         catch ex
@@ -612,22 +611,6 @@ end
 end
 add_tfunc(Core._typevar, 3, 3, typevar_tfunc, 100)
 
-@nospecs function arraysize_tfunc(𝕃::AbstractLattice, ary, dim)
-    hasintersect(widenconst(ary), Array) || return Bottom
-    hasintersect(widenconst(dim), Int) || return Bottom
-    return Int
-end
-add_tfunc(arraysize, 2, 2, arraysize_tfunc, 4)
-
-@nospecs function arraysize_nothrow(ary, dim)
-    ary ⊑ Array || return false
-    if isa(dim, Const)
-        dimval = dim.val
-        return isa(dimval, Int) && dimval > 0
-    end
-    return false
-end
-
 struct MemoryOrder x::Cint end
 const MEMORY_ORDER_UNSPECIFIED = MemoryOrder(-2)
 const MEMORY_ORDER_INVALID     = MemoryOrder(-1)
@@ -709,7 +692,7 @@ end
         unw = unwrap_unionall(a)
         if isa(unw, DataType) && unw.name === Ptr.body.name
             T = unw.parameters[1]
-            valid_as_lattice(T, true) || return Bottom
+            valid_as_lattice(T) || return Bottom
             return rewrap_unionall(ccall(:jl_apply_cmpswap_type, Any, (Any,), T), a)
         end
     end
@@ -1305,17 +1288,19 @@ end
     fcnt = fieldcount_noerror(typ)
     fcnt === nothing && return false
     0 < fidx ≤ fcnt || return true # no undefined behavior if thrown
+    fidx ≤ datatype_min_ninitialized(typ) && return true # always defined
     ftyp = fieldtype(typ, fidx)
-    is_undefref_fieldtype(ftyp) && return true
-    return fidx ≤ datatype_min_ninitialized(typ)
+    is_undefref_fieldtype(ftyp) && return true # always initialized
+    return false
 end
-# checks if a field of this type will not be initialized with undefined value
-# and the access to that uninitialized field will cause and `UndefRefError`, e.g.,
+# checks if a field of this type is guaranteed to be defined to a value
+# and that access to an uninitialized field will cause an `UndefRefError` or return zero
 # - is_undefref_fieldtype(String) === true
 # - is_undefref_fieldtype(Integer) === true
 # - is_undefref_fieldtype(Any) === true
 # - is_undefref_fieldtype(Int) === false
 # - is_undefref_fieldtype(Union{Int32,Int64}) === false
+# - is_undefref_fieldtype(T) === false
 function is_undefref_fieldtype(@nospecialize ftyp)
     return !has_free_typevars(ftyp) && !allocatedinline(ftyp)
 end
@@ -1985,45 +1970,80 @@ function tuple_tfunc(𝕃::AbstractLattice, argtypes::Vector{Any})
     return anyinfo ? PartialStruct(typ, argtypes) : typ
 end
 
-@nospecs function arrayref_tfunc(𝕃::AbstractLattice, boundscheck, ary, idxs...)
-    return _arrayref_tfunc(𝕃, boundscheck, ary, idxs)
+@nospecs function memoryrefget_tfunc(𝕃::AbstractLattice, mem, order, boundscheck)
+    return _memoryrefget_tfunc(𝕃, mem, order, boundscheck)
 end
-@nospecs function _arrayref_tfunc(𝕃::AbstractLattice, boundscheck, ary, @nospecialize idxs::Tuple)
-    isempty(idxs) && return Bottom
-    array_builtin_common_errorcheck(boundscheck, ary, idxs) || return Bottom
-    return array_elmtype(ary)
+@nospecs function _memoryrefget_tfunc(𝕃::AbstractLattice, mem, order, boundscheck)
+    memoryref_builtin_common_errorcheck(mem, order, boundscheck) || return Bottom
+    return memoryref_elemtype(mem)
 end
-add_tfunc(arrayref, 3, INT_INF, arrayref_tfunc, 20)
-add_tfunc(const_arrayref, 3, INT_INF, arrayref_tfunc, 20)
+add_tfunc(memoryrefget, 3, 3, memoryrefget_tfunc, 20)
 
-@nospecs function arrayset_tfunc(𝕃::AbstractLattice, boundscheck, ary, item, idxs...)
-    hasintersect(widenconst(item), _arrayref_tfunc(𝕃, boundscheck, ary, idxs)) || return Bottom
-    return ary
+@nospecs function memoryrefset!_tfunc(𝕃::AbstractLattice, mem, item, order, boundscheck)
+    hasintersect(widenconst(item), _memoryrefget_tfunc(𝕃, mem, order, boundscheck)) || return Bottom
+    return mem
 end
-add_tfunc(arrayset, 4, INT_INF, arrayset_tfunc, 20)
+add_tfunc(memoryrefset!, 4, 4, memoryrefset!_tfunc, 20)
 
-@nospecs function array_builtin_common_errorcheck(boundscheck, ary, @nospecialize idxs::Tuple)
-    hasintersect(widenconst(boundscheck), Bool) || return false
-    hasintersect(widenconst(ary), Array) || return false
-    for i = 1:length(idxs)
-        idx = getfield(idxs, i)
-        idx = isvarargtype(idx) ? unwrapva(idx) : widenconst(idx)
-        hasintersect(idx, Int) || return false
+@nospecs function memoryref_isassigned_tfunc(𝕃::AbstractLattice, mem, order, boundscheck)
+    return _memoryref_isassigned_tfunc(𝕃, mem, order, boundscheck)
+end
+@nospecs function _memoryref_isassigned_tfunc(𝕃::AbstractLattice, mem, order, boundscheck)
+    memoryref_builtin_common_errorcheck(mem, order, boundscheck) || return Bottom
+    return Bool
+end
+add_tfunc(memoryref_isassigned, 3, 3, memoryref_isassigned_tfunc, 20)
+
+@nospecs function memoryref_tfunc(𝕃::AbstractLattice, mem)
+    a = widenconst(mem)
+    if !has_free_typevars(a)
+        unw = unwrap_unionall(a)
+        if isa(unw, DataType) && unw.name === GenericMemory.body.body.body.name
+            A = unw.parameters[1]
+            T = unw.parameters[2]
+            AS = unw.parameters[3]
+            T isa Type || T isa TypeVar || return Bottom
+            return rewrap_unionall(GenericMemoryRef{A, T, AS}, a)
+        end
     end
+    return GenericMemoryRef
+end
+@nospecs function memoryref_tfunc(𝕃::AbstractLattice, ref, idx)
+    memoryref_tfunc(𝕃, ref, idx, Const(true))
+end
+@nospecs function memoryref_tfunc(𝕃::AbstractLattice, ref, idx, boundscheck)
+    memoryref_builtin_common_errorcheck(ref, Const(:not_atomic), boundscheck) || return Bottom
+    hasintersect(widenconst(idx), Int) || return Bottom
+    return ref
+end
+add_tfunc(memoryref, 1, 3, memoryref_tfunc, 1)
+
+@nospecs function memoryrefoffset_tfunc(𝕃::AbstractLattice, mem)
+    hasintersect(widenconst(mem), GenericMemoryRef) || return Bottom
+    return Int
+end
+add_tfunc(memoryrefoffset, 1, 1, memoryrefoffset_tfunc, 5)
+
+
+
+@nospecs function memoryref_builtin_common_errorcheck(mem, order, boundscheck)
+    hasintersect(widenconst(mem), GenericMemoryRef) || return false
+    hasintersect(widenconst(order), Symbol) || return false
+    hasintersect(widenconst(boundscheck), Bool) || return false
     return true
 end
 
-function array_elmtype(@nospecialize ary)
-    a = widenconst(ary)
-    if !has_free_typevars(a) && a <: Array
-        a0 = a
-        if isa(a, UnionAll)
-            a = unwrap_unionall(a0)
+function memoryref_elemtype(@nospecialize mem)
+    m = widenconst(mem)
+    if !has_free_typevars(m) && m <: GenericMemoryRef
+        m0 = m
+        if isa(m, UnionAll)
+            m = unwrap_unionall(m0)
         end
-        if isa(a, DataType)
-            T = a.parameters[1]
+        if isa(m, DataType)
+            T = m.parameters[2]
             valid_as_lattice(T, true) || return Bottom
-            return rewrap_unionall(T, a0)
+            return rewrap_unionall(T, m0)
         end
     end
     return Any
@@ -2048,67 +2068,100 @@ end
 
 # whether getindex for the elements can potentially throw UndefRef
 function array_type_undefable(@nospecialize(arytype))
+    arytype = unwrap_unionall(arytype)
     if isa(arytype, Union)
         return array_type_undefable(arytype.a) || array_type_undefable(arytype.b)
-    elseif isa(arytype, UnionAll)
-        return true
+    elseif arytype isa DataType
+        elmtype = memoryref_elemtype(arytype)
+        # TODO: use arraytype layout instead to derive this
+        return !((elmtype isa DataType && isbitstype(elmtype)) || (elmtype isa Union && isbitsunion(elmtype)))
+    end
+    return true
+end
+
+@nospecs function memoryset_typecheck(memtype, elemtype)
+    # Check that we can determine the element type
+    isa(memtype, DataType) || return false
+    elemtype_expected = memoryref_elemtype(memtype)
+    elemtype_expected === Union{} && return false
+    # Check that the element type is compatible with the element we're assigning
+    elemtype ⊑ elemtype_expected || return false
+    return true
+end
+
+function memoryref_builtin_common_nothrow(argtypes::Vector{Any})
+    if length(argtypes) == 1
+        memtype = widenconst(argtypes[1])
+        return memtype ⊑ GenericMemory
     else
-        elmtype = (arytype::DataType).parameters[1]
-        return !(elmtype isa Type && (isbitstype(elmtype) || isbitsunion(elmtype)))
+        if length(argtypes) == 2
+            boundscheck = Const(true)
+        elseif length(argtypes) == 3
+            boundscheck = argtypes[3]
+        else
+            return false
+        end
+        memtype = widenconst(argtypes[1])
+        idx = widenconst(argtypes[2])
+        idx ⊑ Int || return false
+        boundscheck ⊑ Bool || return false
+        memtype ⊑ GenericMemoryRef || return false
+        # If we have @inbounds (last argument is false), we're allowed to assume
+        # we don't throw bounds errors.
+        if isa(boundscheck, Const)
+            boundscheck.val::Bool || return true
+        end
+        # Else we can't really say anything here
+        # TODO: In the future we may be able to track the minimum length though inference.
+        return false
     end
 end
 
-function array_builtin_common_nothrow(argtypes::Vector{Any}, isarrayref::Bool)
-    first_idx_idx = isarrayref ? 3 : 4
-    length(argtypes) ≥ first_idx_idx || return false
-    boundscheck = argtypes[1]
-    arytype = argtypes[2]
-    array_builtin_common_typecheck(boundscheck, arytype, argtypes, first_idx_idx) || return false
-    if isarrayref
+function memoryrefop_builtin_common_nothrow(argtypes::Vector{Any}, @nospecialize f)
+    ismemoryset = f === memoryrefset!
+    nargs = ismemoryset ? 4 : 3
+    length(argtypes) == nargs || return false
+    order = argtypes[2 + ismemoryset]
+    boundscheck = argtypes[3 + ismemoryset]
+    memtype = widenconst(argtypes[1])
+    memoryref_builtin_common_typecheck(boundscheck, memtype, order) || return false
+    if ismemoryset
+        # Additionally check element type compatibility
+        memoryset_typecheck(memtype, argtypes[2]) || return false
+    elseif f === memoryrefget
         # If we could potentially throw undef ref errors, bail out now.
-        arytype = widenconst(arytype)
-        array_type_undefable(arytype) && return false
+        array_type_undefable(memtype) && return false
     end
-    # If we have @inbounds (first argument is false), we're allowed to assume
+    # If we have @inbounds (last argument is false), we're allowed to assume
     # we don't throw bounds errors.
     if isa(boundscheck, Const)
         boundscheck.val::Bool || return true
     end
     # Else we can't really say anything here
-    # TODO: In the future we may be able to track the shapes of arrays though
-    # inference.
+    # TODO: In the future we may be able to track the minimum length though inference.
     return false
 end
 
-@nospecs function array_builtin_common_typecheck(boundscheck, arytype,
-    argtypes::Vector{Any}, first_idx_idx::Int)
-    (boundscheck ⊑ Bool && arytype ⊑ Array) || return false
-    for i = first_idx_idx:length(argtypes)
-        argtypes[i] ⊑ Int || return false
-    end
-    return true
+@nospecs function memoryref_builtin_common_typecheck(boundscheck, memtype, order)
+    return boundscheck ⊑ Bool && memtype ⊑ GenericMemoryRef && order ⊑ Symbol
 end
 
-@nospecs function arrayset_typecheck(arytype, elmtype)
-    # Check that we can determine the element type
-    arytype = widenconst(arytype)
-    isa(arytype, DataType) || return false
-    elmtype_expected = arytype.parameters[1]
-    isa(elmtype_expected, Type) || return false
-    # Check that the element type is compatible with the element we're assigning
-    elmtype ⊑ elmtype_expected || return false
-    return true
-end
 
 # Query whether the given builtin is guaranteed not to throw given the argtypes
 @nospecs function _builtin_nothrow(𝕃::AbstractLattice, f, argtypes::Vector{Any}, rt)
     ⊑ = Core.Compiler.:⊑(𝕃)
-    if f === arrayset
-        array_builtin_common_nothrow(argtypes, #=isarrayref=#false) || return false
-        # Additionally check element type compatibility
-        return arrayset_typecheck(argtypes[2], argtypes[3])
-    elseif f === arrayref || f === const_arrayref
-        return array_builtin_common_nothrow(argtypes, #=isarrayref=#true)
+    if f === memoryref
+        return memoryref_builtin_common_nothrow(argtypes)
+    elseif f === memoryrefoffset
+        length(argtypes) == 1 || return false
+        memtype = widenconst(argtypes[1])
+        return memtype ⊑ GenericMemoryRef
+    elseif f === memoryrefset!
+        return memoryrefop_builtin_common_nothrow(argtypes, f)
+    elseif f === memoryrefget
+        return memoryrefop_builtin_common_nothrow(argtypes, f)
+    elseif f === memoryref_isassigned
+        return memoryrefop_builtin_common_nothrow(argtypes, f)
     elseif f === Core._expr
         length(argtypes) >= 1 || return false
         return argtypes[1] ⊑ Symbol
@@ -2118,10 +2171,7 @@ end
     # the correct number of arguments.
     na = length(argtypes)
     (na ≠ 0 && isvarargtype(argtypes[end])) && return false
-    if f === arraysize
-        na == 2 || return false
-        return arraysize_nothrow(argtypes[1], argtypes[2])
-    elseif f === Core._typevar
+    if f === Core._typevar
         na == 3 || return false
         return typevar_nothrow(𝕃, argtypes[1], argtypes[2], argtypes[3])
     elseif f === invoke
@@ -2224,9 +2274,10 @@ const _EFFECT_FREE_BUILTINS = [
     isa,
     UnionAll,
     getfield,
-    arrayref,
-    arraysize,
-    const_arrayref,
+    memoryref,
+    memoryrefoffset,
+    memoryrefget,
+    memoryref_isassigned,
     isdefined,
     Core.sizeof,
     Core.ifelse,
@@ -2247,7 +2298,6 @@ const _INACCESSIBLEMEM_BUILTINS = Any[
     svec,
     fieldtype,
     isa,
-    isdefined,
     nfields,
     throw,
     tuple,
@@ -2259,9 +2309,11 @@ const _INACCESSIBLEMEM_BUILTINS = Any[
 ]
 
 const _ARGMEM_BUILTINS = Any[
-    arrayref,
-    arrayset,
-    arraysize,
+    memoryref,
+    memoryrefoffset,
+    memoryrefget,
+    memoryref_isassigned,
+    memoryrefset!,
     modifyfield!,
     replacefield!,
     setfield!,
@@ -2409,8 +2461,6 @@ function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argin
         return getfield_effects(𝕃, arginfo, rt)
     end
 
-    # TODO taint `:noub` for `arrayref` and `arrayset` here
-
     # if this builtin call deterministically throws,
     # don't bother to taint the other effects other than :nothrow:
     # note this is safe only if we accounted for :noub already
@@ -2434,14 +2484,16 @@ function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argin
     else
         if contains_is(_CONSISTENT_BUILTINS, f)
             consistent = ALWAYS_TRUE
-        elseif f === arrayref || f === arrayset || f === arraysize
+        elseif f === memoryref || f === memoryrefoffset
+            consistent = ALWAYS_TRUE
+        elseif f === memoryrefget || f === memoryrefset! || f === memoryref_isassigned
             consistent = CONSISTENT_IF_INACCESSIBLEMEMONLY
         elseif f === Core._typevar
             consistent = CONSISTENT_IF_NOTRETURNED
         else
             consistent = ALWAYS_FALSE
         end
-        if f === setfield! || f === arrayset
+        if f === setfield! || f === memoryrefset!
             effect_free = EFFECT_FREE_IF_INACCESSIBLEMEMONLY
         elseif contains_is(_EFFECT_FREE_BUILTINS, f) || contains_is(_PURE_BUILTINS, f)
             effect_free = ALWAYS_TRUE
@@ -2570,9 +2622,6 @@ function intrinsic_nothrow(f::IntrinsicFunction, argtypes::Vector{Any})
         isprimitivetype(eT) || return false
         return argtypes[2] ⊑ eT && argtypes[3] ⊑ Int && argtypes[4] ⊑ Int
     end
-    if f === Intrinsics.arraylen
-        return argtypes[1] ⊑ Array
-    end
     if f === Intrinsics.bitcast
         ty, isexact, isconcrete = instanceof_tfunc(argtypes[1], true)
         xty = widenconst(argtypes[2])
@@ -2610,7 +2659,6 @@ function is_pure_intrinsic_infer(f::IntrinsicFunction)
     return !(f === Intrinsics.pointerref || # this one is volatile
              f === Intrinsics.pointerset || # this one is never effect-free
              f === Intrinsics.llvmcall ||   # this one is never effect-free
-             f === Intrinsics.arraylen ||   # this one is volatile
              f === Intrinsics.sqrt_llvm_fast ||  # this one may differ at runtime (by a few ulps)
              f === Intrinsics.have_fma ||  # this one depends on the runtime environment
              f === Intrinsics.cglobal)  # cglobal lookup answer changes at runtime
@@ -2631,18 +2679,12 @@ function intrinsic_effects(f::IntrinsicFunction, argtypes::Vector{Any})
 
     if contains_is(_INCONSISTENT_INTRINSICS, f)
         consistent = ALWAYS_FALSE
-    elseif f === arraylen
-        consistent = CONSISTENT_IF_INACCESSIBLEMEMONLY
     else
         consistent = ALWAYS_TRUE
     end
     effect_free = !(f === Intrinsics.pointerset) ? ALWAYS_TRUE : ALWAYS_FALSE
     nothrow = (isempty(argtypes) || !isvarargtype(argtypes[end])) && intrinsic_nothrow(f, argtypes)
-    if f === arraylen
-        inaccessiblememonly = INACCESSIBLEMEM_OR_ARGMEMONLY
-    else
-        inaccessiblememonly = ALWAYS_TRUE
-    end
+    inaccessiblememonly = ALWAYS_TRUE
     return Effects(EFFECTS_TOTAL; consistent, effect_free, nothrow, inaccessiblememonly)
 end
 
@@ -2911,90 +2953,29 @@ function foreigncall_effects(@specialize(abstract_eval), e::Expr)
     args = e.args
     name = args[1]
     isa(name, QuoteNode) && (name = name.value)
-    isa(name, Symbol) || return EFFECTS_UNKNOWN
-    ndims = alloc_array_ndims(name)
-    if ndims !== nothing
-        if ndims ≠ 0
-            return alloc_array_effects(abstract_eval, args, ndims)
-        else
-            return new_array_effects(abstract_eval, args)
-        end
-    end
-    if is_array_resize(name)
-        return array_resize_effects()
+    if name === :jl_alloc_genericmemory
+        nothrow = new_genericmemory_nothrow(abstract_eval, args)
+        return Effects(EFFECTS_TOTAL; consistent=CONSISTENT_IF_NOTRETURNED, nothrow)
     end
     return EFFECTS_UNKNOWN
 end
 
-function is_array_resize(name::Symbol)
-    return name === :jl_array_grow_beg || name === :jl_array_grow_end ||
-           name === :jl_array_del_beg || name === :jl_array_del_end ||
-           name === :jl_array_grow_at || name === :jl_array_del_at
-end
-
-function array_resize_effects()
-    return Effects(EFFECTS_TOTAL;
-        effect_free = EFFECT_FREE_IF_INACCESSIBLEMEMONLY,
-        nothrow = false,
-        inaccessiblememonly = INACCESSIBLEMEM_OR_ARGMEMONLY)
-end
-
-function alloc_array_ndims(name::Symbol)
-    if name === :jl_alloc_array_1d
-        return 1
-    elseif name === :jl_alloc_array_2d
-        return 2
-    elseif name === :jl_alloc_array_3d
-        return 3
-    elseif name === :jl_new_array
-        return 0
-    end
-    return nothing
-end
-
-function alloc_array_effects(@specialize(abstract_eval), args::Vector{Any}, ndims::Int)
-    nothrow = alloc_array_nothrow(abstract_eval, args, ndims)
-    return Effects(EFFECTS_TOTAL; consistent=CONSISTENT_IF_NOTRETURNED, nothrow)
-end
-
-function alloc_array_nothrow(@specialize(abstract_eval), args::Vector{Any}, ndims::Int)
-    length(args) ≥ ndims+FOREIGNCALL_ARG_START || return false
-    atype = instanceof_tfunc(abstract_eval(args[FOREIGNCALL_ARG_START]))[1]
-    dims = Csize_t[]
-    for i in 1:ndims
-        dim = abstract_eval(args[i+FOREIGNCALL_ARG_START])
-        isa(dim, Const) || return false
-        dimval = dim.val
-        isa(dimval, Int) || return false
-        push!(dims, reinterpret(Csize_t, dimval))
-    end
-    return _new_array_nothrow(atype, ndims, dims)
-end
-
-function new_array_effects(@specialize(abstract_eval), args::Vector{Any})
-    nothrow = new_array_nothrow(abstract_eval, args)
-    return Effects(EFFECTS_TOTAL; consistent=CONSISTENT_IF_NOTRETURNED, nothrow)
-end
-
-function new_array_nothrow(@specialize(abstract_eval), args::Vector{Any})
-    length(args) ≥ FOREIGNCALL_ARG_START+1 || return false
-    atype = instanceof_tfunc(abstract_eval(args[FOREIGNCALL_ARG_START]))[1]
-    dims = abstract_eval(args[FOREIGNCALL_ARG_START+1])
-    isa(dims, Const) || return dims === Tuple{}
-    dimsval = dims.val
-    isa(dimsval, Tuple{Vararg{Int}}) || return false
-    ndims = nfields(dimsval)
-    isa(ndims, Int) || return false
-    dims = Csize_t[reinterpret(Csize_t, dimval) for dimval in dimsval]
-    return _new_array_nothrow(atype, ndims, dims)
-end
-
-function _new_array_nothrow(@nospecialize(atype), ndims::Int, dims::Vector{Csize_t})
-    isa(atype, DataType) || return false
-    eltype = atype.parameters[1]
-    iskindtype(typeof(eltype)) || return false
-    elsz = aligned_sizeof(eltype)
-    return ccall(:jl_array_validate_dims, Cint,
-        (Ptr{Csize_t}, Ptr{Csize_t}, UInt32, Ptr{Csize_t}, Csize_t),
-        #=nel=#RefValue{Csize_t}(), #=tot=#RefValue{Csize_t}(), ndims, dims, elsz) == 0
+function new_genericmemory_nothrow(@nospecialize(abstract_eval), args::Vector{Any})
+    length(args) ≥ 1+FOREIGNCALL_ARG_START || return false
+    mtype = instanceof_tfunc(abstract_eval(args[FOREIGNCALL_ARG_START]))[1]
+    isa(mtype, DataType) || return false
+    isdefined(mtype, :instance) || return false
+    elsz = Int(datatype_layoutsize(mtype))
+    arrayelem = datatype_arrayelem(mtype)
+    dim = abstract_eval(args[1+FOREIGNCALL_ARG_START])
+    isa(dim, Const) || return false
+    dimval = dim.val
+    isa(dimval, Int) || return false
+    0 < dimval < typemax(Int) || return false
+    tot, ovflw = Intrinsics.checked_smul_int(dimval, elsz)
+    ovflw && return false
+    isboxed = 1; isunion = 2
+    tot, ovflw = Intrinsics.checked_sadd_int(tot, arrayelem == isunion ? 1 + dimval : 1)
+    ovflw && return false
+    return true
 end
diff --git a/base/compiler/typelattice.jl b/base/compiler/typelattice.jl
index 0c44a610f8f95..5987c30be2b91 100644
--- a/base/compiler/typelattice.jl
+++ b/base/compiler/typelattice.jl
@@ -323,7 +323,7 @@ end
 
 @nospecializeinfer function isalreadyconst(@nospecialize t)
     isa(t, Const) && return true
-    isa(t, DataType) && isdefined(t, :instance) && return true
+    issingletontype(t) && return true
     return isconstType(t)
 end
 
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index d27e1bd00ce56..175675f2c81cc 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -89,7 +89,7 @@ function count_const_size(@nospecialize(x), count_self::Bool = true)
     sz = count_self ? sizeof(dt) : 0
     sz > MAX_INLINE_CONST_SIZE && return MAX_INLINE_CONST_SIZE + 1
     dtfd = DataTypeFieldDesc(dt)
-    for i = 1:nfields(x)
+    for i = 1:Int(datatype_nfields(dt))
         isdefined(x, i) || continue
         f = getfield(x, i)
         if !dtfd[i].isptr && datatype_pointerfree(typeof(f))
diff --git a/base/deepcopy.jl b/base/deepcopy.jl
index b35510aa1e7ae..e0cb6c5e781fa 100644
--- a/base/deepcopy.jl
+++ b/base/deepcopy.jl
@@ -88,30 +88,51 @@ function deepcopy_internal(@nospecialize(x), stackdict::IdDict)
     return y::T
 end
 
-function deepcopy_internal(x::Array, stackdict::IdDict)
+function deepcopy_internal(x::Memory, stackdict::IdDict)
     if haskey(stackdict, x)
         return stackdict[x]::typeof(x)
     end
-    _deepcopy_array_t(x, eltype(x), stackdict)
+    _deepcopy_memory_t(x, eltype(x), stackdict)
 end
 
-function _deepcopy_array_t(@nospecialize(x::Array), T, stackdict::IdDict)
+function _deepcopy_memory_t(@nospecialize(x::Memory), T, stackdict::IdDict)
     if isbitstype(T)
         return (stackdict[x]=copy(x))
     end
-    dest = similar(x)
+    dest = typeof(x)(undef, length(x))
     stackdict[x] = dest
+    xr = Core.memoryref(x)
+    dr = Core.memoryref(dest)
     for i = 1:length(x)
-        if ccall(:jl_array_isassigned, Cint, (Any, Csize_t), x, i-1) != 0
-            xi = ccall(:jl_arrayref, Any, (Any, Csize_t), x, i-1)
+        xi = Core.memoryref(xr, i, false)
+        if Core.memoryref_isassigned(xi, :not_atomic, false)
+            xi = Core.memoryrefget(xi, :not_atomic, false)
             if !isbits(xi)
                 xi = deepcopy_internal(xi, stackdict)::typeof(xi)
             end
-            ccall(:jl_arrayset, Cvoid, (Any, Any, Csize_t), dest, xi, i-1)
+            di = Core.memoryref(dr, i, false)
+            di = Core.memoryrefset!(di, xi, :not_atomic, false)
         end
     end
     return dest
 end
+@eval function deepcopy_internal(x::Array{T, N}, stackdict::IdDict) where {T, N}
+    if haskey(stackdict, x)
+        return stackdict[x]::typeof(x)
+    end
+    stackdict[x] = $(Expr(:new, :(Array{T, N}), :(deepcopy_internal(x.ref, stackdict)), :(x.size)))
+end
+function deepcopy_internal(x::GenericMemoryRef, stackdict::IdDict)
+    if haskey(stackdict, x)
+        return stackdict[x]::typeof(x)
+    end
+    mem = getfield(x, :mem)
+    dest = GenericMemoryRef(deepcopy_internal(mem, stackdict)::typeof(mem))
+    i = memoryrefoffset(x)
+    i == 1 || (dest = Core.memoryref(dest, i, true))
+    return dest
+end
+
 
 function deepcopy_internal(x::Union{Dict,IdDict}, stackdict::IdDict)
     if haskey(stackdict, x)
diff --git a/base/dict.jl b/base/dict.jl
index b2797db8dc059..da165c145bbb1 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -64,9 +64,9 @@ Dict{String, Int64} with 2 entries:
 """
 mutable struct Dict{K,V} <: AbstractDict{K,V}
     # Metadata: empty => 0x00, removed => 0x7f, full => 0b1[7 most significant hash bits]
-    slots::Vector{UInt8}
-    keys::Array{K,1}
-    vals::Array{V,1}
+    slots::Memory{UInt8}
+    keys::Memory{K}
+    vals::Memory{V}
     ndel::Int
     count::Int
     age::UInt
@@ -75,13 +75,15 @@ mutable struct Dict{K,V} <: AbstractDict{K,V}
 
     function Dict{K,V}() where V where K
         n = 16
-        new(zeros(UInt8,n), Vector{K}(undef, n), Vector{V}(undef, n), 0, 0, 0, n, 0)
+        slots = Memory{UInt8}(undef,n)
+        fill!(slots, 0x0)
+        new(slots, Memory{K}(undef, n), Memory{V}(undef, n), 0, 0, 0, n, 0)
     end
     function Dict{K,V}(d::Dict{K,V}) where V where K
         new(copy(d.slots), copy(d.keys), copy(d.vals), d.ndel, d.count, d.age,
             d.idxfloor, d.maxprobe)
     end
-    function Dict{K, V}(slots, keys, vals, ndel, count, age, idxfloor, maxprobe) where {K, V}
+    function Dict{K, V}(slots::Memory{UInt8}, keys::Memory{K}, vals::Memory{V}, ndel::Int, count::Int, age::UInt, idxfloor::Int, maxprobe::Int) where {K, V}
         new(slots, keys, vals, ndel, count, age, idxfloor, maxprobe)
     end
 end
@@ -179,18 +181,20 @@ end
     h.age += 1
     h.idxfloor = 1
     if h.count == 0
-        resize!(h.slots, newsz)
+        # TODO: tryresize
+        h.slots = Memory{UInt8}(undef, newsz)
         fill!(h.slots, 0x0)
-        resize!(h.keys, newsz)
-        resize!(h.vals, newsz)
+        h.keys = Memory{K}(undef, newsz)
+        h.vals = Memory{V}(undef, newsz)
         h.ndel = 0
         h.maxprobe = 0
         return h
     end
 
-    slots = zeros(UInt8,newsz)
-    keys = Vector{K}(undef, newsz)
-    vals = Vector{V}(undef, newsz)
+    slots = Memory{UInt8}(undef, newsz)
+    fill!(slots, 0x0)
+    keys = Memory{K}(undef, newsz)
+    vals = Memory{V}(undef, newsz)
     age0 = h.age
     count = 0
     maxprobe = 0
@@ -256,10 +260,10 @@ Dict{String, Int64}()
 function empty!(h::Dict{K,V}) where V where K
     fill!(h.slots, 0x0)
     sz = length(h.slots)
-    empty!(h.keys)
-    empty!(h.vals)
-    resize!(h.keys, sz)
-    resize!(h.vals, sz)
+    for i in 1:sz
+        _unsetindex!(h.keys, i)
+        _unsetindex!(h.vals, i)
+    end
     h.ndel = 0
     h.count = 0
     h.maxprobe = 0
diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index b9102f01b7d0c..795d3ef1ee5d3 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -2420,6 +2420,42 @@ false
 """
 isdefined
 
+"""
+    Memory{T}(undef, n)
+
+Construct an uninitialized [`Memory{T}`](@ref) of length `n`. All Memory
+objects of length 0 might alias, since there is no reachable mutable content
+from them.
+
+# Examples
+```julia-repl
+julia> Memory{Float64}(undef, 3)
+3-element Memory{Float64}:
+ 6.90966e-310
+ 6.90966e-310
+ 6.90966e-310
+```
+"""
+Memory{T}(::UndefInitializer, n)
+
+"""
+    MemoryRef(memory)
+
+Construct a MemoryRef from a memory object. This does not fail, but the
+resulting memory may point out-of-bounds if the memory is empty.
+"""
+MemoryRef(::Memory)
+
+"""
+    MemoryRef(::Memory, index::Integer)
+    MemoryRef(::MemoryRef, index::Integer)
+
+Construct a MemoryRef from a memory object and an offset index (1-based) which
+can also be negative. This always returns an inbounds object, and will throw an
+error if that is not possible (because the index would result in a shift
+out-of-bounds of the underlying memory).
+"""
+MemoryRef(::Union{Memory,MemoryRef}, ::Integer)
 
 """
     Vector{T}(undef, n)
@@ -3373,4 +3409,6 @@ The current differences are:
 """
 Core.finalizer
 
+Base.include(BaseDocs, "intrinsicsdocs.jl")
+
 end
diff --git a/base/docs/intrinsicsdocs.jl b/base/docs/intrinsicsdocs.jl
new file mode 100644
index 0000000000000..effc9e859becf
--- /dev/null
+++ b/base/docs/intrinsicsdocs.jl
@@ -0,0 +1,62 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+"""
+    Core.IR
+
+The Core.IR module exports the IR object model.
+"""
+Core.IR
+
+"""
+    Core.IntrinsicFunction <: Core.Builtin <: Function
+
+The Core.IntrinsicFunction function define some basic primitives for what defines the
+abilities and behaviors of a Julia program
+"""
+Core.IntrinsicFunction
+
+"""
+    Core.Intrinsics
+
+The Core.Intrinsics module holds the Core.IntrinsicFunction objects.
+"""
+Core.Intrinsics
+
+"""
+    Core.memoryref(::GenericMemory)
+    Core.memoryref(::GenericMemoryRef, index::Int, [boundscheck::Bool])
+
+Return a GenericMemoryRef for a GenericMemory. See [`MemoryRef`](@ref).
+"""
+Core.memoryref
+
+"""
+    Core..memoryrefoffset(::GenericMemoryRef)
+
+Return the offset index that was used to construct the MemoryRef. See [`Core.memoryref`](@ref).
+"""
+Core.memoryrefoffset
+
+"""
+    Core.memoryrefget(::GenericMemoryRef, ordering::Symbol, boundscheck::Bool)
+
+Return the value stored at the MemoryRef, throwing a BoundsError if the Memory is empty. See `ref[]`.
+The memory ordering specified must be compatible with the `isatomic` parameter.
+"""
+Core.memoryrefget
+
+"""
+    Core.memoryrefset!(::GenericMemoryRef, value, ordering::Symbol, boundscheck::Bool)
+
+Store the value to the MemoryRef, throwing a BoundsError if the Memory is empty. See `ref[] = value`.
+The memory ordering specified must be compatible with the `isatomic` parameter.
+"""
+Core.memoryrefset!
+
+"""
+    Core.memoryref_isassigned(::GenericMemoryRef, ordering::Symbol, boundscheck::Bool)
+
+Return whether there is a value stored at the MemoryRef, returning false if the Memory is empty. See [`isassigned(::Base.RefValue)`](@ref), [`Core.memoryrefget`](@ref).
+The memory ordering specified must be compatible with the `isatomic` parameter.
+"""
+Core.memoryref_isassigned
diff --git a/base/essentials.jl b/base/essentials.jl
index 4323052d540da..ece48a0e772ee 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -1,17 +1,22 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-import Core: CodeInfo, SimpleVector, donotdelete, compilerbarrier, arrayref
+using Core: CodeInfo, SimpleVector, donotdelete, compilerbarrier, memoryref, memoryrefget, memoryrefset!
 
 const Callable = Union{Function,Type}
 
 const Bottom = Union{}
 
 # Define minimal array interface here to help code used in macros:
-length(a::Array) = arraylen(a)
+length(a::Array{T, 0}) where {T} = 1
+length(a::Array{T, 1}) where {T} = getfield(a, :size)[1]
+length(a::Array) = getfield(getfield(getfield(a, :ref), :mem), :length)
+length(a::GenericMemory) = getfield(a, :length)
+throw_boundserror(A, I) = (@noinline; throw(BoundsError(A, I)))
 
-# This is more complicated than it needs to be in order to get Win64 through bootstrap
-eval(:(getindex(A::Array, i1::Int) = arrayref($(Expr(:boundscheck)), A, i1)))
-eval(:(getindex(A::Array, i1::Int, i2::Int, I::Int...) = (@inline; arrayref($(Expr(:boundscheck)), A, i1, i2, I...))))
+eval(:(getindex(A::GenericMemory{:not_atomic}, i::Int) = memoryrefget(memoryref(memoryref(A), i, $(Expr(:boundscheck))), :not_atomic, false)))
+eval(:(getindex(A::GenericMemoryRef{:not_atomic}) = memoryrefget(A, :not_atomic, $(Expr(:boundscheck)))))
+
+# multidimensional getindex will be defined later on
 
 ==(a::GlobalRef, b::GlobalRef) = a.mod === b.mod && a.name === b.name
 
@@ -247,6 +252,18 @@ macro _terminates_locally_meta()
         #=:inaccessiblememonly=#false,
         #=:noub=#false))
 end
+# can be used in place of `@assume_effects :terminates_globally` (supposed to be used for bootstrapping)
+macro _terminates_globally_meta()
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
+        #=:consistent=#false,
+        #=:effect_free=#false,
+        #=:nothrow=#false,
+        #=:terminates_globally=#true,
+        #=:terminates_locally=#true,
+        #=:notaskstate=#false,
+        #=:inaccessiblememonly=#false,
+        #=:noub=#false))
+end
 # can be used in place of `@assume_effects :effect_free :terminates_locally` (supposed to be used for bootstrapping)
 macro _effect_free_terminates_locally_meta()
     return _is_internal(__module__) && Expr(:meta, Expr(:purity,
@@ -653,9 +670,6 @@ julia> ifelse(1 > 2, 1, 2)
 """
 ifelse(condition::Bool, x, y) = Core.ifelse(condition, x, y)
 
-# simple Array{Any} operations needed for bootstrap
-@eval setindex!(A::Array{Any}, @nospecialize(x), i::Int) = arrayset($(Expr(:boundscheck)), A, x, i)
-
 """
     esc(e)
 
@@ -771,6 +785,22 @@ macro goto(name::Symbol)
     return esc(Expr(:symbolicgoto, name))
 end
 
+# linear indexing
+eval(:(function getindex(A::Array, i::Int)
+        @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) || throw_boundserror(A, (i,))
+        memoryrefget(memoryref(getfield(A, :ref), i, false), :not_atomic, false)
+    end))
+# simple Array{Any} operations needed for bootstrap
+function setindex!(A::Array{Any}, @nospecialize(x), i::Int)
+    @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) || throw_boundserror(A, (i,))
+    memoryrefset!(memoryref(getfield(A, :ref), i, false), x, :not_atomic, false)
+    return A
+end
+@eval setindex!(A::Memory{Any}, @nospecialize(x), i::Int) = (memoryrefset!(memoryref(memoryref(A), i, $(Expr(:boundscheck))), x, :not_atomic, $(Expr(:boundscheck))); A)
+@eval setindex!(A::MemoryRef{T}, x) where {T} = memoryrefset!(A, convert(T, x), :not_atomic, $(Expr(:boundscheck)))
+@eval setindex!(A::MemoryRef{Any}, @nospecialize(x)) = memoryrefset!(A, x, :not_atomic, $(Expr(:boundscheck)))
+
+
 # SimpleVector
 
 getindex(v::SimpleVector, i::Int) = (@_foldable_meta; Core._svec_ref(v, i))
diff --git a/base/experimental.jl b/base/experimental.jl
index 133171b78271d..abcd52ffcc43f 100644
--- a/base/experimental.jl
+++ b/base/experimental.jl
@@ -9,7 +9,7 @@
 """
 module Experimental
 
-using Base: Threads, sync_varname, is_function_def
+using Base: Threads, sync_varname, is_function_def, @propagate_inbounds
 using Base.Meta
 
 """
@@ -28,10 +28,7 @@ end
 Base.IndexStyle(::Type{<:Const}) = IndexLinear()
 Base.size(C::Const) = size(C.a)
 Base.axes(C::Const) = axes(C.a)
-@eval Base.getindex(A::Const, i1::Int) =
-    (Base.@inline; Core.const_arrayref($(Expr(:boundscheck)), A.a, i1))
-@eval Base.getindex(A::Const, i1::Int, i2::Int, I::Int...) =
-  (Base.@inline; Core.const_arrayref($(Expr(:boundscheck)), A.a, i1, i2, I...))
+@propagate_inbounds Base.getindex(A::Const, i1::Int, I::Int...) = A.a[i1, I...]
 
 """
     @aliasscope expr
diff --git a/base/expr.jl b/base/expr.jl
index 0f7dc76395930..4e418d140e5a6 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -716,7 +716,8 @@ macro assume_effects(args...)
     end
     (consistent, effect_free, nothrow, terminates_globally, terminates_locally, notaskstate, inaccessiblememonly, noub) =
         (false, false, false, false, false, false, false, false, false)
-    for org_setting in args[1:idx]
+    for i in 1:idx
+        org_setting = args[i]
         (setting, val) = compute_assumed_setting(org_setting)
         if setting === :consistent
             consistent = val
diff --git a/base/genericmemory.jl b/base/genericmemory.jl
new file mode 100644
index 0000000000000..e9ec11292ed77
--- /dev/null
+++ b/base/genericmemory.jl
@@ -0,0 +1,272 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+## genericmemory.jl: Managed Memory
+
+"""
+    GenericMemory{kind::Symbol, T, addrspace::Int} <: AbstractVector{T}
+
+One-dimensional dense array with elements of type `T`.
+"""
+GenericMemory
+"""
+    Memory{T} == GenericMemory{:not_atomic, T, Core.CPU}
+
+One-dimensional dense array with elements of type `T`.
+"""
+Memory
+
+## Basic functions ##
+
+using Core: memoryrefoffset, memoryref_isassigned # import more functions which were not essential
+
+size(a::GenericMemory, d::Int) =
+    d < 1 ? error("dimension out of range") :
+    d == 1 ? length(a) :
+    1
+size(a::GenericMemory, d::Integer) =  size(a, convert(d, Int))
+size(a::GenericMemory) = (length(a),)
+
+pointer(mem::GenericMemory, i::Int) = (@_propagate_inbounds_meta; unsafe_convert(Ptr{Cvoid}, GenericMemoryRef(mem, i))) # boundschecked, even for i==1
+pointer(mem::GenericMemoryRef) = unsafe_convert(Ptr{Cvoid}, mem) # no bounds check, even for empty array
+
+_unsetindex!(A::Memory, i::Int) =  (@_propagate_inbounds_meta; _unsetindex!(GenericMemoryRef(A, i)); A)
+function _unsetindex!(A::MemoryRef{T}) where T
+    @_terminates_locally_meta
+    @_propagate_inbounds_meta
+    @inline
+    @boundscheck GenericMemoryRef(A, 1)
+    mem = A.mem
+    MemT = typeof(mem)
+    arrayelem = datatype_arrayelem(MemT)
+    elsz = datatype_layoutsize(MemT)
+    isboxed = 1; isunion = 2
+    t = @_gc_preserve_begin mem
+    p = Ptr{Ptr{Cvoid}}(@inbounds pointer(A))
+    if arrayelem == isboxed
+        Intrinsics.atomic_pointerset(p, C_NULL, :monotonic)
+    elseif arrayelem != isunion
+        if !datatype_pointerfree(T::DataType)
+            for j = 1:Core.sizeof(Ptr{Cvoid}):elsz
+                Intrinsics.atomic_pointerset(p + j - 1, C_NULL, :monotonic)
+            end
+        end
+    end
+    @_gc_preserve_end t
+    return A
+end
+
+elsize(@nospecialize _::Type{A}) where {T,A<:GenericMemory{<:Any,T}} = aligned_sizeof(T)
+sizeof(a::GenericMemory) = Core.sizeof(a)
+
+# multi arg case will be overwritten later. This is needed for bootstrapping
+function isassigned(a::Memory, i::Int)
+    @inline
+    @boundscheck (i - 1)%UInt < length(a)%UInt || return false
+    return @inbounds memoryref_isassigned(GenericMemoryRef(a, i), :not_atomic, false)
+end
+
+@eval isassigned(a::GenericMemoryRef) = memoryref_isassigned(a, :not_atomic, $(Expr(:boundscheck)))
+
+## copy ##
+@eval function unsafe_copyto!(dest::MemoryRef{T}, src::MemoryRef{T}, n) where {T}
+    @_terminates_globally_meta
+    n == 0 && return dest
+    @boundscheck GenericMemoryRef(dest, n), GenericMemoryRef(src, n)
+    ccall(:jl_genericmemory_copyto, Cvoid, (Any, Ptr{Cvoid}, Any, Ptr{Cvoid}, Int), dest.mem, dest.ptr_or_offset, src.mem, src.ptr_or_offset, Int(n))
+    return dest
+end
+
+function unsafe_copyto!(dest::GenericMemoryRef, src::GenericMemoryRef, n)
+    n == 0 && return dest
+    @boundscheck GenericMemoryRef(dest, n), GenericMemoryRef(src, n)
+    unsafe_copyto!(dest.mem, memoryrefoffset(dest), src.mem, memoryrefoffset(src), n)
+    return dest
+end
+
+function unsafe_copyto!(dest::Memory{T}, doffs, src::Memory{T}, soffs, n) where{T}
+    n == 0 && return dest
+    unsafe_copyto!(GenericMemoryRef(dest, doffs), GenericMemoryRef(src, soffs), n)
+    return dest
+end
+
+function unsafe_copyto!(dest::Memory, doffs, src::Memory, soffs, n)
+    @_terminates_locally_meta
+    n == 0 && return dest
+    # use pointer math to determine if they are deemed to alias
+    destp = pointer(dest, doffs)
+    srcp = pointer(src, soffs)
+    endp = pointer(src, soffs + n - 1)
+    @inbounds if destp < srcp || destp > endp
+        for i = 1:n
+            if isassigned(src, soffs + i - 1)
+                dest[doffs + i - 1] = src[soffs + i - 1]
+            else
+                _unsetindex!(dest, doffs + i - 1)
+            end
+        end
+    else
+        for i = n:-1:1
+            if isassigned(src, soffs + i - 1)
+                dest[doffs + i - 1] = src[soffs + i - 1]
+            else
+                _unsetindex!(dest, doffs + i - 1)
+            end
+        end
+    end
+    return dest
+end
+
+copy(a::T) where {T<:Memory} = ccall(:jl_genericmemory_copy, Ref{T}, (Any,), a)
+
+## Constructors ##
+
+similar(a::Memory{T}) where {T}                   = Memory{T}(undef, length(a))
+similar(a::Memory{T}, S::Type) where {T}          = Memory{S}(undef, length(a))
+similar(a::Memory{T}, m::Int) where {T}           = Memory{T}(undef, m)
+similar(a::Memory, T::Type, dims::Dims{1})        = Memory{T}(undef, dims[1])
+similar(a::Memory{T}, dims::Dims{1}) where {T}    = Memory{T}(undef, dims[1])
+
+function fill!(a::Union{Memory{UInt8}, Memory{Int8}}, x::Integer)
+    t = @_gc_preserve_begin a
+    p = unsafe_convert(Ptr{Cvoid}, a)
+    T = eltype(a)
+    memset(p, x isa T ? x : convert(T, x), length(a))
+    @_gc_preserve_end t
+    return a
+end
+
+## Conversions ##
+
+convert(::Type{T}, a::AbstractArray) where {T<:GenericMemory} = a isa T ? a : T(a)::T
+
+promote_rule(a::Type{Memory{T}}, b::Type{Memory{S}}) where {T,S} = el_same(promote_type(T,S), a, b)
+promote_rule(a::Type{GenericMemory{:atomic,T,Core.CPU}}, b::Type{GenericMemory{:atomic,S,Core.CPU}}) where {T,S} = el_same(promote_type(T,S), a, b)
+
+## Constructors ##
+
+if nameof(@__MODULE__) === :Base  # avoid method overwrite
+# constructors should make copies
+Memory{T}(x::AbstractArray{S,1}) where {T,S} = copyto_axcheck!(Memory{T}(undef, size(x)), x)
+end
+
+## copying iterators to containers
+
+## Iteration ##
+
+iterate(A::Memory, i=1) = (@inline; (i - 1)%UInt < length(A)%UInt ? (@inbounds A[i], i + 1) : nothing)
+
+## Indexing: getindex ##
+
+# Faster contiguous indexing using copyto! for AbstractUnitRange and Colon
+function getindex(A::Memory, I::AbstractUnitRange{<:Integer})
+    @inline
+    @boundscheck checkbounds(A, I)
+    lI = length(I)
+    X = similar(A, axes(I))
+    if lI > 0
+        copyto!(X, firstindex(X), A, first(I), lI)
+    end
+    return X
+end
+
+# getindex for carrying out logical indexing for AbstractUnitRange{Bool} as Bool <: Integer
+getindex(a::Memory, r::AbstractUnitRange{Bool}) = getindex(a, to_index(r))
+
+getindex(A::Memory, c::Colon) = copy(A)
+
+## Indexing: setindex! ##
+
+@eval begin
+function setindex!(A::Memory{T}, x, i1::Int) where {T}
+    val = x isa T ? x : convert(T,x)::T
+    ref = memoryref(memoryref(A), i1, $(Expr(:boundscheck)))
+    memoryrefset!(ref, val, :not_atomic, $(Expr(:boundscheck)))
+    return A
+end
+end
+function setindex!(A::Memory{T}, x, i1::Int, i2::Int, I::Int...) where {T}
+    @inline
+    @boundscheck (i2 == 1 && all(==(1), I)) || throw_boundserror(A, (i1, i2, I...))
+    setindex!(A, x, i1)
+end
+
+function __inbounds_setindex!(A::Memory{T}, x, i1::Int) where {T}
+    val = x isa T ? x : convert(T,x)::T
+    ref = memoryref(memoryref(A), i1, false)
+    memoryrefset!(ref, val, :not_atomic, false)
+    return A
+end
+function __inbounds_setindex!(A::Memory{T}, x, i1::Int, i2::Int, I::Int...) where {T}
+    @boundscheck (i2 == 1 && all(==(1), I)) || throw_boundserror(A, (i1, i2, I...))
+    __inbounds_setindex(A, x, i1)
+end
+
+# Faster contiguous setindex! with copyto!
+function setindex!(A::Memory{T}, X::Memory{T}, I::AbstractUnitRange{Int}) where T
+    @inline
+    @boundscheck checkbounds(A, I)
+    lI = length(I)
+    @boundscheck setindex_shape_check(X, lI)
+    if lI > 0
+        unsafe_copyto!(A, first(I), X, 1, lI)
+    end
+    return A
+end
+function setindex!(A::Memory{T}, X::Memory{T}, c::Colon) where T
+    @inline
+    lI = length(A)
+    @boundscheck setindex_shape_check(X, lI)
+    if lI > 0
+        unsafe_copyto!(A, 1, X, 1, lI)
+    end
+    return A
+end
+
+# use memcmp for cmp on byte arrays
+function cmp(a::Memory{UInt8}, b::Memory{UInt8})
+    ta = @_gc_preserve_begin a
+    tb = @_gc_preserve_begin b
+    pa = unsafe_convert(Ptr{Cvoid}, a)
+    pb = unsafe_convert(Ptr{Cvoid}, b)
+    c = memcmp(pa, pb, min(length(a),length(b)))
+    @_gc_preserve_end ta
+    @_gc_preserve_end tb
+    return c < 0 ? -1 : c > 0 ? +1 : cmp(length(a),length(b))
+end
+
+const BitIntegerMemory{N} = Union{map(T->Memory{T}, BitInteger_types)...}
+# use memcmp for == on bit integer types
+function ==(a::M, b::M) where {M <: BitIntegerMemory}
+    if length(a) == length(b)
+        ta = @_gc_preserve_begin a
+        tb = @_gc_preserve_begin b
+        pa = unsafe_convert(Ptr{Cvoid}, a)
+        pb = unsafe_convert(Ptr{Cvoid}, b)
+        c = memcmp(pa, pb, sizeof(eltype(M)) * length(a))
+        @_gc_preserve_end ta
+        @_gc_preserve_end tb
+        return c == 0
+    else
+        return false
+    end
+end
+
+function findall(pred::Fix2{typeof(in),<:Union{Memory{<:Real},Real}}, x::Memory{<:Real})
+    if issorted(x, Sort.Forward) && issorted(pred.x, Sort.Forward)
+        return _sortedfindin(x, pred.x)
+    else
+        return _findin(x, pred.x)
+    end
+end
+
+# Copying subregions
+function indcopy(sz::Dims, I::GenericMemory)
+    n = length(I)
+    s = sz[n]
+    for i = n+1:length(sz)
+        s *= sz[i]
+    end
+    dst = eltype(I)[_findin(I[i], i < n ? (1:sz[i]) : (1:s)) for i = 1:n]
+    src = eltype(I)[I[i][_findin(I[i], i < n ? (1:sz[i]) : (1:s))] for i = 1:n]
+    dst, src
+end
diff --git a/base/iddict.jl b/base/iddict.jl
index 01ff213305d7b..a4d3d439f03c9 100644
--- a/base/iddict.jl
+++ b/base/iddict.jl
@@ -24,10 +24,10 @@ IdDict{Any, String} with 3 entries:
 ```
 """
 mutable struct IdDict{K,V} <: AbstractDict{K,V}
-    ht::Vector{Any}
+    ht::Memory{Any}
     count::Int
     ndel::Int
-    IdDict{K,V}() where {K, V} = new{K,V}(Vector{Any}(undef, 32), 0, 0)
+    IdDict{K,V}() where {K, V} = new{K,V}(Memory{Any}(undef, 32), 0, 0)
 
     function IdDict{K,V}(itr) where {K, V}
         d = IdDict{K,V}()
@@ -69,7 +69,7 @@ end
 empty(d::IdDict, ::Type{K}, ::Type{V}) where {K, V} = IdDict{K,V}()
 
 function rehash!(d::IdDict, newsz = length(d.ht)%UInt)
-    d.ht = ccall(:jl_idtable_rehash, Vector{Any}, (Any, Csize_t), d.ht, newsz)
+    d.ht = ccall(:jl_idtable_rehash, Memory{Any}, (Any, Csize_t), d.ht, newsz)
     d
 end
 
@@ -93,7 +93,7 @@ function setindex!(d::IdDict{K,V}, @nospecialize(val), @nospecialize(key)) where
         d.ndel = 0
     end
     inserted = RefValue{Cint}(0)
-    d.ht = ccall(:jl_eqtable_put, Array{Any,1}, (Any, Any, Any, Ptr{Cint}), d.ht, key, val, inserted)
+    d.ht = ccall(:jl_eqtable_put, Memory{Any}, (Any, Any, Any, Ptr{Cint}), d.ht, key, val, inserted)
     d.count += inserted[]
     return d
 end
@@ -133,7 +133,7 @@ function delete!(d::IdDict{K}, @nospecialize(key)) where K
 end
 
 function empty!(d::IdDict)
-    resize!(d.ht, 32)
+    d.ht = Memory{Any}(undef, 32)
     ht = d.ht
     t = @_gc_preserve_begin ht
     memset(unsafe_convert(Ptr{Cvoid}, ht), 0, sizeof(ht))
diff --git a/base/namedtuple.jl b/base/namedtuple.jl
index 36ec56a4e0a2a..5863cb462010c 100644
--- a/base/namedtuple.jl
+++ b/base/namedtuple.jl
@@ -291,7 +291,7 @@ end
     names = merge_names(an, bn)
     types = merge_types(names, typeof(a), typeof(b))
     n = length(names)
-    A = Vector{Any}(undef, n)
+    A = Memory{Any}(undef, n)
     for i=1:n
         n = names[i]
         A[i] = getfield(sym_in(n, bn) ? b : a, n)
@@ -408,7 +408,7 @@ end
     isempty(names) && return (;)
     types = diff_types(a, names)
     n = length(names)
-    A = Vector{Any}(undef, n)
+    A = Memory{Any}(undef, n)
     for i=1:n
         n = names[i]
         A[i] = getfield(a, n)
diff --git a/base/pointer.jl b/base/pointer.jl
index 5bb5682a6d0d8..86513c076ade6 100644
--- a/base/pointer.jl
+++ b/base/pointer.jl
@@ -62,13 +62,32 @@ unsafe_convert(::Type{Ptr{Int8}}, x::Symbol) = ccall(:jl_symbol_name, Ptr{Int8},
 unsafe_convert(::Type{Ptr{UInt8}}, s::String) = ccall(:jl_string_ptr, Ptr{UInt8}, (Any,), s)
 unsafe_convert(::Type{Ptr{Int8}}, s::String) = ccall(:jl_string_ptr, Ptr{Int8}, (Any,), s)
 
-unsafe_convert(::Type{Ptr{T}}, a::Array{T}) where {T} = ccall(:jl_array_ptr, Ptr{T}, (Any,), a)
+cconvert(::Type{<:Ptr}, a::Array) = getfield(a, :ref)
 unsafe_convert(::Type{Ptr{S}}, a::AbstractArray{T}) where {S,T} = convert(Ptr{S}, unsafe_convert(Ptr{T}, a))
 unsafe_convert(::Type{Ptr{T}}, a::AbstractArray{T}) where {T} = error("conversion to pointer not defined for $(typeof(a))")
 # TODO: add this deprecation to give a better error:
 # cconvert(::Type{<:Ptr}, a::AbstractArray) = error("conversion to pointer not defined for $(typeof(a))")
 # unsafe_convert(::Type{Ptr{T}}, a::AbstractArray{T}) where {T} = error("missing call to cconvert for call to unsafe_convert for AbstractArray")
 
+cconvert(::Type{<:Ptr}, a::GenericMemory) = a
+unsafe_convert(::Type{Ptr{Cvoid}}, a::GenericMemory{T}) where {T} = getfield(a, :ptr)
+unsafe_convert(::Type{Ptr{T}}, a::GenericMemory) where {T} = convert(Ptr{T}, getfield(a, :ptr))
+
+function unsafe_convert(::Type{Ptr{Cvoid}}, a::GenericMemoryRef{<:Any,T,Core.CPU}) where {T}
+    mem = getfield(a, :mem)
+    offset = getfield(a, :ptr_or_offset)
+    MemT = typeof(mem)
+    arrayelem = datatype_arrayelem(MemT)
+    elsz = datatype_layoutsize(MemT)
+    isboxed = 1; isunion = 2
+    if arrayelem == isunion || elsz == 0
+        offset = UInt(offset) * elsz
+        offset += unsafe_convert(Ptr{Cvoid}, mem)
+    end
+    return offset
+end
+unsafe_convert(::Type{Ptr{T}}, a::GenericMemoryRef) where {T} = convert(Ptr{T}, unsafe_convert(Ptr{Cvoid}, a))
+
 # unsafe pointer to array conversions
 """
     unsafe_wrap(Array, pointer::Ptr{T}, dims; own = false)
@@ -95,10 +114,21 @@ function unsafe_wrap(::Union{Type{Array},Type{Array{T}},Type{Array{T,1}}},
     ccall(:jl_ptr_to_array_1d, Array{T,1},
           (Any, Ptr{Cvoid}, Csize_t, Cint), Array{T,1}, p, d, own)
 end
-unsafe_wrap(Atype::Union{Type{Array},Type{Array{T}},Type{Array{T,N}}},
+function unsafe_wrap(::Union{Type{GenericMemory{kind,<:Any,Core.CPU}},Type{GenericMemory{kind,T,Core.CPU}}},
+                     p::Ptr{T}, dims::Tuple{Int}; own::Bool = false) where {kind,T}
+    ccall(:jl_ptr_to_genericmemory, Ref{GenericMemory{kind,T,Core.CPU}},
+          (Any, Ptr{Cvoid}, Csize_t, Cint), GenericMemory{kind,T,Core.CPU}, p, dim[1], own)
+end
+function unsafe_wrap(::Union{Type{GenericMemory{kind,<:Any,Core.CPU}},Type{GenericMemory{kind,T,Core.CPU}}},
+                     p::Ptr{T}, d::Integer; own::Bool = false) where {kind,T}
+    ccall(:jl_ptr_to_genericmemory, Ref{GenericMemory{kind,T,Core.CPU}},
+          (Any, Ptr{Cvoid}, Csize_t, Cint), GenericMemory{kind,T,Core.CPU}, p, d, own)
+end
+unsafe_wrap(Atype::Union{Type{Array},Type{Array{T}},Type{Array{T,N}},Type{GenericMemory{kind,<:Any,Core.CPU}},Type{GenericMemory{kind,T,Core.CPU}}} where {kind},
             p::Ptr{T}, dims::NTuple{N,<:Integer}; own::Bool = false) where {T,N} =
     unsafe_wrap(Atype, p, convert(Tuple{Vararg{Int}}, dims), own = own)
 
+
 """
     unsafe_load(p::Ptr{T}, i::Integer=1)
     unsafe_load(p::Ptr{T}, order::Symbol)
diff --git a/base/promotion.jl b/base/promotion.jl
index bc081b15c7a31..a1438267763ae 100644
--- a/base/promotion.jl
+++ b/base/promotion.jl
@@ -120,7 +120,7 @@ function typejoin(@nospecialize(a), @nospecialize(b))
                     aprimary = aprimary::UnionAll
                     # pushfirst!(vars, aprimary.var)
                     _growbeg!(vars, 1)
-                    arrayset(false, vars, aprimary.var, 1)
+                    vars[1] = aprimary.var
                     aprimary = aprimary.body
                 end
             end
diff --git a/base/reflection.jl b/base/reflection.jl
index 469bd8e1b40a3..7bb77b316b434 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -430,13 +430,16 @@ struct DataTypeLayout
     flags::UInt16
     # haspadding : 1;
     # fielddesc_type : 2;
+    # arrayelem_isboxed : 1;
+    # arrayelem_isunion : 1;
 end
 
 """
     Base.datatype_alignment(dt::DataType) -> Int
 
 Memory allocation minimum alignment for instances of this type.
-Can be called on any `isconcretetype`.
+Can be called on any `isconcretetype`, although for Memory it will give the
+alignment of the elements, not the whole object.
 """
 function datatype_alignment(dt::DataType)
     @_foldable_meta
@@ -478,7 +481,8 @@ gc_alignment(T::Type) = gc_alignment(Core.sizeof(T))
     Base.datatype_haspadding(dt::DataType) -> Bool
 
 Return whether the fields of instances of this type are packed in memory,
-with no intervening padding bytes.
+with no intervening padding bits (defined as bits whose value does not uniquely
+impact the egal test when applied to the struct fields).
 Can be called on any `isconcretetype`.
 """
 function datatype_haspadding(dt::DataType)
@@ -489,9 +493,10 @@ function datatype_haspadding(dt::DataType)
 end
 
 """
-    Base.datatype_nfields(dt::DataType) -> Bool
+    Base.datatype_nfields(dt::DataType) -> UInt32
 
-Return the number of fields known to this datatype's layout.
+Return the number of fields known to this datatype's layout. This may be
+different from the number of actual fields of the type for opaque types.
 Can be called on any `isconcretetype`.
 """
 function datatype_nfields(dt::DataType)
@@ -529,6 +534,31 @@ function datatype_fielddesc_type(dt::DataType)
     return (flags >> 1) & 3
 end
 
+"""
+    Base.datatype_arrayelem(dt::DataType) -> Int
+
+Return the behavior of the trailing array types allocations.
+Can be called on any `isconcretetype`, but only meaningful on `Memory`.
+
+0 = inlinealloc
+1 = isboxed
+2 = isbitsunion
+"""
+function datatype_arrayelem(dt::DataType)
+    @_foldable_meta
+    dt.layout == C_NULL && throw(UndefRefError())
+    flags = unsafe_load(convert(Ptr{DataTypeLayout}, dt.layout)).flags
+    return (flags >> 3) & 3
+end
+
+function datatype_layoutsize(dt::DataType)
+    @_foldable_meta
+    dt.layout == C_NULL && throw(UndefRefError())
+    size = unsafe_load(convert(Ptr{DataTypeLayout}, dt.layout)).size
+    return size % Int
+end
+
+
 # For type stability, we only expose a single struct that describes everything
 struct FieldDesc
     isforeign::Bool
@@ -555,7 +585,7 @@ end
 
 function getindex(dtfd::DataTypeFieldDesc, i::Int)
     layout_ptr = convert(Ptr{DataTypeLayout}, dtfd.dt.layout)
-    fd_ptr = layout_ptr + sizeof(DataTypeLayout)
+    fd_ptr = layout_ptr + Core.sizeof(DataTypeLayout)
     layout = unsafe_load(layout_ptr)
     fielddesc_type = (layout.flags >> 1) & 3
     nfields = layout.nfields
@@ -830,10 +860,10 @@ end
     Base.issingletontype(T)
 
 Determine whether type `T` has exactly one possible instance; for example, a
-struct type with no fields.
-If `T` is not a type, then return `false`.
+struct type with no fields except other singleton values.
+If `T` is not a concrete type, then return `false`.
 """
-issingletontype(@nospecialize(t)) = (@_total_meta; isa(t, DataType) && isdefined(t, :instance))
+issingletontype(@nospecialize(t)) = (@_total_meta; isa(t, DataType) && isdefined(t, :instance) && datatype_layoutsize(t) == 0 && datatype_pointerfree(t))
 
 """
     typeintersect(T::Type, S::Type)
@@ -1194,11 +1224,11 @@ function visit(f, mt::Core.MethodTable)
     nothing
 end
 function visit(f, mc::Core.TypeMapLevel)
-    function avisit(f, e::Array{Any,1})
+    function avisit(f, e::Memory{Any})
         for i in 2:2:length(e)
             isassigned(e, i) || continue
             ei = e[i]
-            if ei isa Vector{Any}
+            if ei isa Memory{Any}
                 for j in 2:2:length(ei)
                     isassigned(ei, j) || continue
                     visit(f, ei[j])
@@ -1209,16 +1239,16 @@ function visit(f, mc::Core.TypeMapLevel)
         end
     end
     if mc.targ !== nothing
-        avisit(f, mc.targ::Vector{Any})
+        avisit(f, mc.targ::Memory{Any})
     end
     if mc.arg1 !== nothing
-        avisit(f, mc.arg1::Vector{Any})
+        avisit(f, mc.arg1::Memory{Any})
     end
     if mc.tname !== nothing
-        avisit(f, mc.tname::Vector{Any})
+        avisit(f, mc.tname::Memory{Any})
     end
     if mc.name1 !== nothing
-        avisit(f, mc.name1::Vector{Any})
+        avisit(f, mc.name1::Memory{Any})
     end
     mc.list !== nothing && visit(f, mc.list)
     mc.any !== nothing && visit(f, mc.any)
@@ -2234,6 +2264,7 @@ See also: [`hasproperty`](@ref), [`hasfield`](@ref).
 propertynames(x) = fieldnames(typeof(x))
 propertynames(m::Module) = names(m)
 propertynames(x, private::Bool) = propertynames(x) # ignore private flag by default
+propertynames(x::Array) = () # hide the fields from tab completion to discourage calling `x.size` instead of `size(x)`, even though they are equivalent
 
 """
     hasproperty(x, s::Symbol)
diff --git a/base/refpointer.jl b/base/refpointer.jl
index 072323658e40d..ce2c6fc00560d 100644
--- a/base/refpointer.jl
+++ b/base/refpointer.jl
@@ -150,7 +150,9 @@ if is_primary_base_module
     # convert Arrays to pointer arrays for ccall
     # For example `["a", "b"]` to Ptr{Cstring} for `char **argv`
     function Ref{P}(a::Array{T}) where P<:Union{Ptr,Cwstring,Cstring} where T
-        if (isbitstype(T) ? T <: Ptr || T <: Union{Cwstring,Cstring} : T <: eltype(P))
+        if P == T
+            return getfield(a, :ref)
+        elseif (isbitstype(T) ? T <: Ptr || T <: Union{Cwstring,Cstring} : T <: eltype(P))
             # this Array already has the right memory layout for the requested Ref
             # but the wrong eltype for the constructor
             return RefArray{P,typeof(a),Nothing}(a, 1, nothing) # effectively a no-op
@@ -169,8 +171,8 @@ if is_primary_base_module
     Ref(x::AbstractArray, i::Integer) = RefArray(x, i)
 end
 
-cconvert(::Type{Ptr{P}}, a::Array{P}) where {P<:Union{Ptr,Cwstring,Cstring}} = a
-cconvert(::Type{Ref{P}}, a::Array{P}) where {P<:Union{Ptr,Cwstring,Cstring}} = a
+cconvert(::Type{Ptr{P}}, a::Array{P}) where {P<:Union{Ptr,Cwstring,Cstring}} = getfield(a, :ref)
+cconvert(::Type{Ref{P}}, a::Array{P}) where {P<:Union{Ptr,Cwstring,Cstring}} = getfield(a, :ref)
 cconvert(::Type{Ptr{P}}, a::Array) where {P<:Union{Ptr,Cwstring,Cstring}} = Ref{P}(a)
 cconvert(::Type{Ref{P}}, a::Array) where {P<:Union{Ptr,Cwstring,Cstring}} = Ref{P}(a)
 
diff --git a/base/reshapedarray.jl b/base/reshapedarray.jl
index f65fa7c63cceb..e8a832d119a26 100644
--- a/base/reshapedarray.jl
+++ b/base/reshapedarray.jl
@@ -37,20 +37,30 @@ eltype(::Type{<:ReshapedArrayIterator{I}}) where {I} = @isdefined(I) ? ReshapedI
 
 ## reshape(::Array, ::Dims) returns an Array, except for isbitsunion eltypes (issue #28611)
 # reshaping to same # of dimensions
-function reshape(a::Array{T,M}, dims::NTuple{N,Int}) where {T,N,M}
+@eval function reshape(a::Array{T,M}, dims::NTuple{N,Int}) where {T,N,M}
     throw_dmrsa(dims, len) =
         throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $len"))
-
-    if prod(dims) != length(a)
+    len = Core.checked_dims(dims...) # make sure prod(dims) doesn't overflow (and because of the comparison to length(a))
+    if len != length(a)
         throw_dmrsa(dims, length(a))
     end
     isbitsunion(T) && return ReshapedArray(a, dims, ())
     if N == M && dims == size(a)
         return a
     end
-    ccall(:jl_reshape_array, Array{T,N}, (Any, Any, Any), Array{T,N}, a, dims)
+    ref = a.ref
+    if M == 1 && N !== 1
+        mem = ref.mem::Memory{T}
+        if !(ref === GenericMemoryRef(mem) && len === mem.length)
+            mem = ccall(:jl_genericmemory_slice, Memory{T}, (Any, Ptr{Cvoid}, Int), mem, ref.ptr_or_offset, len)
+            ref = GenericMemoryRef(mem)::typeof(ref)
+        end
+    end
+    # or we could use `a = Array{T,N}(undef, ntuple(0, Val(N))); a.ref = ref; a.size = dims; return a` here
+    return $(Expr(:new, :(Array{T,N}), :ref, :dims))
 end
 
+
 """
     reshape(A, dims...) -> AbstractArray
     reshape(A, dims) -> AbstractArray
diff --git a/base/secretbuffer.jl b/base/secretbuffer.jl
index cc3f0b234688f..28bd35ac2e93a 100644
--- a/base/secretbuffer.jl
+++ b/base/secretbuffer.jl
@@ -29,12 +29,12 @@ true
 ```
 """
 mutable struct SecretBuffer <: IO
-    data::Vector{UInt8}
+    data::Memory{UInt8}
     size::Int
     ptr::Int
 
     function SecretBuffer(; sizehint=128)
-        s = new(Vector{UInt8}(undef, sizehint), 0, 1)
+        s = new(Memory{UInt8}(undef, sizehint), 0, 1)
         finalizer(final_shred!, s)
         return s
     end
@@ -49,7 +49,7 @@ Strings are bad at keeping secrets because they are unable to be securely
 zeroed or destroyed. Therefore, avoid using this constructor with secret data.
 Instead of starting with a string, either construct the `SecretBuffer`
 incrementally with `SecretBuffer()` and [`write`](@ref), or use a `Vector{UInt8}` with
-the `Base.SecretBuffer!(::Vector{UInt8})` constructor.
+the `Base.SecretBuffer!(::AbstractVector{UInt8})` constructor.
 """
 SecretBuffer(str::AbstractString) = SecretBuffer(String(str))
 function SecretBuffer(str::String)
@@ -68,7 +68,7 @@ convert(::Type{SecretBuffer}, s::AbstractString) = SecretBuffer(String(s))
 
 Initialize a new `SecretBuffer` from `data`, securely zeroing `data` afterwards.
 """
-function SecretBuffer!(d::Vector{UInt8})
+function SecretBuffer!(d::AbstractVector{UInt8})
     len = length(d)
     s = SecretBuffer(sizehint=len)
     for i in 1:len
@@ -106,7 +106,7 @@ show(io::IO, s::SecretBuffer) = print(io, "SecretBuffer(\"*******\")")
 ==(s1::SecretBuffer, s2::SecretBuffer) = (s1.ptr == s2.ptr) && (s1.size == s2.size) && (UInt8(0) == _bufcmp(s1.data, s2.data, min(s1.size, s2.size)))
 # Also attempt a constant time buffer comparison algorithm — the length of the secret might be
 # inferred by a timing attack, but not its values.
-@noinline function _bufcmp(data1::Vector{UInt8}, data2::Vector{UInt8}, sz::Int)
+@noinline function _bufcmp(data1::Memory{UInt8}, data2::Memory{UInt8}, sz::Int)
     res = UInt8(0)
     for i = 1:sz
         res |= xor(data1[i], data2[i])
@@ -121,7 +121,7 @@ hash(s::SecretBuffer, h::UInt) = hash(_sb_hash, h)
 function write(io::SecretBuffer, b::UInt8)
     if io.ptr > length(io.data)
         # We need to resize! the array: do this manually to ensure no copies are left behind
-        newdata = Vector{UInt8}(undef, (io.size+16)*2)
+        newdata = Memory{UInt8}(undef, (io.size+16)*2)
         copyto!(newdata, io.data)
         securezero!(io.data)
         io.data = newdata
diff --git a/base/strings/cstring.jl b/base/strings/cstring.jl
new file mode 100644
index 0000000000000..3a377ab0e7b1e
--- /dev/null
+++ b/base/strings/cstring.jl
@@ -0,0 +1,314 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+import Core.Intrinsics: bitcast
+
+"""
+    Cwstring
+
+A C-style string composed of the native wide character type
+[`Cwchar_t`](@ref)s. `Cwstring`s are NUL-terminated. For
+C-style strings composed of the native character
+type, see [`Cstring`](@ref). For more information
+about string interoperability with C, see the
+[manual](@ref man-bits-types).
+
+"""
+Cwstring
+
+"""
+    Cstring
+
+A C-style string composed of the native character type
+[`Cchar`](@ref)s. `Cstring`s are NUL-terminated. For
+C-style strings composed of the native wide character
+type, see [`Cwstring`](@ref). For more information
+about string interoperability with C, see the
+[manual](@ref man-bits-types).
+"""
+Cstring
+
+# construction from pointers
+Cstring(p::Union{Ptr{Int8},Ptr{UInt8},Ptr{Cvoid}}) = bitcast(Cstring, p)
+Cwstring(p::Union{Ptr{Cwchar_t},Ptr{Cvoid}})       = bitcast(Cwstring, p)
+Ptr{T}(p::Cstring) where {T<:Union{Int8,UInt8,Cvoid}} = bitcast(Ptr{T}, p)
+Ptr{T}(p::Cwstring) where {T<:Union{Cwchar_t,Cvoid}}  = bitcast(Ptr{Cwchar_t}, p)
+
+convert(::Type{Cstring}, p::Union{Ptr{Int8},Ptr{UInt8},Ptr{Cvoid}}) = Cstring(p)
+convert(::Type{Cwstring}, p::Union{Ptr{Cwchar_t},Ptr{Cvoid}}) = Cwstring(p)
+convert(::Type{Ptr{T}}, p::Cstring) where {T<:Union{Int8,UInt8,Cvoid}} = Ptr{T}(p)
+convert(::Type{Ptr{T}}, p::Cwstring) where {T<:Union{Cwchar_t,Cvoid}} = Ptr{T}(p)
+
+"""
+    pointer(array [, index])
+
+Get the native address of an array or string, optionally at a given location `index`.
+
+This function is "unsafe". Be careful to ensure that a Julia reference to
+`array` exists as long as this pointer will be used. The [`GC.@preserve`](@ref)
+macro should be used to protect the `array` argument from garbage collection
+within a given block of code.
+
+Calling [`Ref(array[, index])`](@ref Ref) is generally preferable to this function as it guarantees validity.
+"""
+function pointer end
+
+pointer(p::Cstring) = convert(Ptr{Cchar}, p)
+pointer(p::Cwstring) = convert(Ptr{Cwchar_t}, p)
+
+# comparisons against pointers (mainly to support `cstr==C_NULL`)
+==(x::Union{Cstring,Cwstring}, y::Ptr) = pointer(x) == y
+==(x::Ptr, y::Union{Cstring,Cwstring}) = x == pointer(y)
+
+unsafe_string(s::Cstring) = unsafe_string(convert(Ptr{UInt8}, s))
+
+# convert strings to String etc. to pass as pointers
+cconvert(::Type{Cstring}, s::String) = s
+cconvert(::Type{Cstring}, s::AbstractString) =
+    cconvert(Cstring, String(s)::String)
+
+function cconvert(::Type{Cwstring}, s::AbstractString)
+    v = transcode(Cwchar_t, String(s))
+    push!(v, 0)
+    return cconvert(Cwstring, v)
+end
+
+eltype(::Type{Cstring}) = Cchar
+eltype(::Type{Cwstring}) = Cwchar_t
+
+containsnul(p::Ptr, len) =
+    C_NULL != ccall(:memchr, Ptr{Cchar}, (Ptr{Cchar}, Cint, Csize_t), p, 0, len)
+containsnul(s::String) = containsnul(unsafe_convert(Ptr{Cchar}, s), sizeof(s))
+containsnul(s::AbstractString) = '\0' in s
+
+function unsafe_convert(::Type{Cstring}, s::String)
+    p = unsafe_convert(Ptr{Cchar}, s)
+    containsnul(p, sizeof(s)) &&
+        throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(s))"))
+    return Cstring(p)
+end
+
+unsafe_convert(::Type{Cstring}, s::Union{Memory{UInt8},Memory{Int8}}) = Cstring(unsafe_convert(Ptr{Cvoid}, s))
+
+function cconvert(::Type{Cwstring}, v::Vector{Cwchar_t})
+    for i = 1:length(v)-1
+        v[i] == 0 &&
+            throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(v))"))
+    end
+    v[end] == 0 ||
+        throw(ArgumentError("C string data must be NUL terminated: $(repr(v))"))
+    return cconvert(Ptr{Cwchar_t}, v)
+end
+unsafe_convert(::Type{Cwstring}, s) = Cwstring(unsafe_convert(Ptr{Cwchar_t}, s))
+unsafe_convert(::Type{Cwstring}, s::Cwstring) = s
+
+# symbols are guaranteed not to contain embedded NUL
+cconvert(::Type{Cstring}, s::Symbol) = s
+unsafe_convert(::Type{Cstring}, s::Symbol) = Cstring(unsafe_convert(Ptr{Cchar}, s))
+
+if ccall(:jl_get_UNAME, Any, ()) === :NT
+"""
+    Base.cwstring(s)
+
+Converts a string `s` to a NUL-terminated `Vector{Cwchar_t}`, suitable for passing to C
+functions expecting a `Ptr{Cwchar_t}`. The main advantage of using this over the implicit
+conversion provided by [`Cwstring`](@ref) is if the function is called multiple times with the
+same argument.
+
+This is only available on Windows.
+"""
+function cwstring(s::AbstractString)
+    bytes = codeunits(String(s))
+    0 in bytes && throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(s))"))
+    return push!(transcode(UInt16, bytes), 0)
+end
+end
+
+# transcoding between data in UTF-8 and UTF-16 for Windows APIs,
+# and also UTF-32 for APIs using Cwchar_t on other platforms.
+
+"""
+    transcode(T, src)
+
+Convert string data between Unicode encodings. `src` is either a
+`String` or a `Vector{UIntXX}` of UTF-XX code units, where
+`XX` is 8, 16, or 32. `T` indicates the encoding of the return value:
+`String` to return a (UTF-8 encoded) `String` or `UIntXX`
+to return a `Vector{UIntXX}` of UTF-`XX` data. (The alias [`Cwchar_t`](@ref)
+can also be used as the integer type, for converting `wchar_t*` strings
+used by external C libraries.)
+
+The `transcode` function succeeds as long as the input data can be
+reasonably represented in the target encoding; it always succeeds for
+conversions between UTF-XX encodings, even for invalid Unicode data.
+
+Only conversion to/from UTF-8 is currently supported.
+
+# Examples
+```jldoctest
+julia> str = "αβγ"
+"αβγ"
+
+julia> transcode(UInt16, str)
+3-element Vector{UInt16}:
+ 0x03b1
+ 0x03b2
+ 0x03b3
+
+julia> transcode(String, transcode(UInt16, str))
+"αβγ"
+```
+"""
+function transcode end
+
+transcode(::Type{T}, src::AbstractVector{T}) where {T<:Union{UInt8,UInt16,UInt32,Int32}} = src
+transcode(::Type{T}, src::String) where {T<:Union{Int32,UInt32}} = T[T(c) for c in src]
+transcode(::Type{T}, src::AbstractVector{UInt8}) where {T<:Union{Int32,UInt32}} =
+    transcode(T, String(Vector(src)))
+transcode(::Type{T}, src::CodeUnits{UInt8,String}) where {T<:Union{Int32,UInt32}} =
+    transcode(T, String(src))
+
+function transcode(::Type{UInt8}, src::Vector{<:Union{Int32,UInt32}})
+    buf = IOBuffer()
+    for c in src
+        print(buf, Char(c))
+    end
+    take!(buf)
+end
+transcode(::Type{String}, src::String) = src
+transcode(T, src::String) = transcode(T, codeunits(src))
+transcode(::Type{String}, src) = String(transcode(UInt8, src))
+
+function transcode(::Type{UInt16}, src::AbstractVector{UInt8})
+    require_one_based_indexing(src)
+    dst = UInt16[]
+    i, n = 1, length(src)
+    n > 0 || return dst
+    sizehint!(dst, 2n)
+    a = src[1]
+    while true
+        if i < n && -64 <= a % Int8 <= -12 # multi-byte character
+            b = src[i += 1]
+            if -64 <= (b % Int8) || a == 0xf4 && 0x8f < b
+                # invalid UTF-8 (non-continuation or too-high code point)
+                push!(dst, a)
+                a = b; continue
+            elseif a < 0xe0 # 2-byte UTF-8
+                push!(dst, xor(0x3080, UInt16(a) << 6, b))
+            elseif i < n # 3/4-byte character
+                c = src[i += 1]
+                if -64 <= (c % Int8) # invalid UTF-8 (non-continuation)
+                    push!(dst, a, b)
+                    a = c; continue
+                elseif a < 0xf0 # 3-byte UTF-8
+                    push!(dst, xor(0x2080, UInt16(a) << 12, UInt16(b) << 6, c))
+                elseif i < n
+                    d = src[i += 1]
+                    if -64 <= (d % Int8) # invalid UTF-8 (non-continuation)
+                        push!(dst, a, b, c)
+                        a = d; continue
+                    elseif a == 0xf0 && b < 0x90 # overlong encoding
+                        push!(dst, xor(0x2080, UInt16(b) << 12, UInt16(c) << 6, d))
+                    else # 4-byte UTF-8
+                        push!(dst, 0xe5b8 + (UInt16(a) << 8) + (UInt16(b) << 2) + (c >> 4),
+                                   xor(0xdc80, UInt16(c & 0xf) << 6, d))
+                    end
+                else # too short
+                    push!(dst, a, b, c)
+                    break
+                end
+            else # too short
+                push!(dst, a, b)
+                break
+            end
+        else # ASCII or invalid UTF-8 (continuation byte or too-high code point)
+            push!(dst, a)
+        end
+        i < n || break
+        a = src[i += 1]
+    end
+    return dst
+end
+
+function transcode(::Type{UInt8}, src::AbstractVector{UInt16})
+    require_one_based_indexing(src)
+    n = length(src)
+    n == 0 && return UInt8[]
+
+    # Precompute m = sizeof(dst).   This involves annoying duplication
+    # of the loop over the src array.   However, this is not just an
+    # optimization: it is problematic for security reasons to grow
+    # dst dynamically, because Base.winprompt uses this function to
+    # convert passwords to UTF-8 and we don't want to make unintentional
+    # copies of the password data.
+    a = src[1]
+    i, m = 1, 0
+    while true
+        if a < 0x80
+            m += 1
+        elseif a < 0x800 # 2-byte UTF-8
+            m += 2
+        elseif a & 0xfc00 == 0xd800 && i < length(src)
+            b = src[i += 1]
+            if (b & 0xfc00) == 0xdc00 # 2-unit UTF-16 sequence => 4-byte UTF-8
+                m += 4
+            else
+                m += 3
+                a = b; continue
+            end
+        else
+            # 1-unit high UTF-16 or unpaired high surrogate
+            # either way, encode as 3-byte UTF-8 code point
+            m += 3
+        end
+        i < n || break
+        a = src[i += 1]
+    end
+
+    dst = StringVector(m)
+    a = src[1]
+    i, j = 1, 0
+    while true
+        if a < 0x80 # ASCII
+            dst[j += 1] = a % UInt8
+        elseif a < 0x800 # 2-byte UTF-8
+            dst[j += 1] = 0xc0 | ((a >> 6) % UInt8)
+            dst[j += 1] = 0x80 | ((a % UInt8) & 0x3f)
+        elseif a & 0xfc00 == 0xd800 && i < n
+            b = src[i += 1]
+            if (b & 0xfc00) == 0xdc00
+                # 2-unit UTF-16 sequence => 4-byte UTF-8
+                a += 0x2840
+                dst[j += 1] = 0xf0 | ((a >> 8) % UInt8)
+                dst[j += 1] = 0x80 | ((a % UInt8) >> 2)
+                dst[j += 1] = xor(0xf0, ((a % UInt8) << 4) & 0x3f, (b >> 6) % UInt8)
+                dst[j += 1] = 0x80 | ((b % UInt8) & 0x3f)
+            else
+                dst[j += 1] = 0xe0 | ((a >> 12) % UInt8)
+                dst[j += 1] = 0x80 | (((a >> 6) % UInt8) & 0x3f)
+                dst[j += 1] = 0x80 | ((a % UInt8) & 0x3f)
+                a = b; continue
+            end
+        else
+            # 1-unit high UTF-16 or unpaired high surrogate
+            # either way, encode as 3-byte UTF-8 code point
+            dst[j += 1] = 0xe0 | ((a >> 12) % UInt8)
+            dst[j += 1] = 0x80 | (((a >> 6) % UInt8) & 0x3f)
+            dst[j += 1] = 0x80 | ((a % UInt8) & 0x3f)
+        end
+        i < n || break
+        a = src[i += 1]
+    end
+    return dst
+end
+
+function unsafe_string(p::Ptr{T}, length::Integer) where {T<:Union{UInt16,UInt32,Cwchar_t}}
+    transcode(String, unsafe_wrap(Array, p, length; own=false))
+end
+function unsafe_string(cw::Cwstring)
+    p = convert(Ptr{Cwchar_t}, cw)
+    n = 1
+    while unsafe_load(p, n) != 0
+        n += 1
+    end
+    return unsafe_string(p, n - 1)
+end
diff --git a/base/summarysize.jl b/base/summarysize.jl
index 9bbae187cab12..2505824768099 100644
--- a/base/summarysize.jl
+++ b/base/summarysize.jl
@@ -26,7 +26,7 @@ julia> Base.summarysize(1.0)
 8
 
 julia> Base.summarysize(Ref(rand(100)))
-848
+864
 
 julia> sizeof(Ref(rand(100)))
 8
@@ -49,9 +49,9 @@ function summarysize(obj;
             if isassigned(x, i)
                 val = x[i]
             end
-        elseif isa(x, Array)
+        elseif isa(x, GenericMemory)
             nf = length(x)
-            if ccall(:jl_array_isassigned, Cint, (Any, UInt), x, i - 1) != 0
+            if @inbounds @inline isassigned(x, i)
                 val = x[i]
             end
         else
@@ -126,14 +126,14 @@ function (ss::SummarySize)(obj::Core.TypeName)
     return Core.sizeof(obj) + (isdefined(obj, :mt) ? ss(obj.mt) : 0)
 end
 
-function (ss::SummarySize)(obj::Array)
+function (ss::SummarySize)(obj::GenericMemory)
     haskey(ss.seen, obj) ? (return 0) : (ss.seen[obj] = true)
-    headersize = 4*sizeof(Int) + 8 + max(0, ndims(obj)-2)*sizeof(Int)
+    headersize = 2*sizeof(Int)
     size::Int = headersize
     datakey = unsafe_convert(Ptr{Cvoid}, obj)
     if !haskey(ss.seen, datakey)
         ss.seen[datakey] = true
-        dsize = Core.sizeof(obj)
+        dsize = sizeof(obj)
         T = eltype(obj)
         if isbitsunion(T)
             # add 1 union selector byte for each element
diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index 4ba93483730ac..82c9ea2aba037 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -308,6 +308,7 @@ generate_precompile_statements() = try # Make sure `ansi_enablecursor` is printe
             yield() # Make clock spinning
             print_state("step3" => string("R$n_succeeded", failed > 0 ? " ($failed failed)" : ""))
         catch ex
+            @show backtrace()
             # See #28808
             @warn "Failed to precompile expression" form=statement exception=ex _module=nothing _file=nothing _line=0
         end
diff --git a/doc/make.jl b/doc/make.jl
index 0ae74a55aceee..f59c9bb54e8b0 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -158,6 +158,7 @@ DevDocs = [
         "devdocs/gc-sa.md",
         "devdocs/gc.md",
         "devdocs/jit.md",
+        "devdocs/builtins.md",
     ],
     "Developing/debugging Julia's C code" => [
         "devdocs/backtraces.md",
diff --git a/doc/src/base/arrays.md b/doc/src/base/arrays.md
index 6585f98360585..ada748fdbe713 100644
--- a/doc/src/base/arrays.md
+++ b/doc/src/base/arrays.md
@@ -30,6 +30,8 @@ Base.StridedArray
 Base.StridedVector
 Base.StridedMatrix
 Base.StridedVecOrMat
+Base.Memory
+Base.MemoryRef
 Base.Slices
 Base.RowSlices
 Base.ColumnSlices
diff --git a/doc/src/base/c.md b/doc/src/base/c.md
index e221a6432542f..bf7e2577029fe 100644
--- a/doc/src/base/c.md
+++ b/doc/src/base/c.md
@@ -14,7 +14,7 @@ Base.unsafe_modify!
 Base.unsafe_replace!
 Base.unsafe_swap!
 Base.unsafe_copyto!{T}(::Ptr{T}, ::Ptr{T}, ::Any)
-Base.unsafe_copyto!{T}(::Array{T}, ::Any, ::Array{T}, ::Any, ::Any)
+Base.unsafe_copyto!(::Array, ::Any, ::Array, ::Any, ::Any)
 Base.copyto!
 Base.pointer
 Base.unsafe_wrap{T,N}(::Union{Type{Array},Type{Array{T}},Type{Array{T,N}}}, ::Ptr{T}, ::NTuple{N,Int})
diff --git a/doc/src/devdocs/builtins.md b/doc/src/devdocs/builtins.md
new file mode 100644
index 0000000000000..eef5cbd04dd8c
--- /dev/null
+++ b/doc/src/devdocs/builtins.md
@@ -0,0 +1,18 @@
+# [Core.Builtins](@id lib-builtins)
+
+## Builtin Function APIs
+
+The following Builtin function APIs are considered unstable, but provide the basic
+definitions for what defines the abilities and behaviors of a Julia program. They are
+typically accessed through a higher level generic API.
+
+```@docs
+Core.memoryref
+Core.memoryrefoffset
+Core.memoryrefget
+Core.memoryrefset!
+Core.memoryref_isassigned
+Core.IntrinsicFunction
+Core.Intrinsics
+Core.IR
+```
diff --git a/doc/src/devdocs/isbitsunionarrays.md b/doc/src/devdocs/isbitsunionarrays.md
index 2a25c033ec9fd..f01afe50985ec 100644
--- a/doc/src/devdocs/isbitsunionarrays.md
+++ b/doc/src/devdocs/isbitsunionarrays.md
@@ -18,6 +18,12 @@ Lastly, a value of `0x00` signals that the `nothing` value will be returned for
 type with a single type instance, it technically has a size of 0. The type tag byte for a type's Union field is stored
 directly after the field's computed Union memory.
 
-## isbits Union Arrays
+## isbits Union Memory
 
-Julia can now also store "isbits Union" values inline in an Array, as opposed to requiring an indirection box. The optimization is accomplished by storing an extra "type tag array" of bytes, one byte per array element, alongside the bytes of the actual array data. This type tag array serves the same function as the type field case: its value signals the type of the actual stored Union value in the array. In terms of layout, a Julia Array can include extra "buffer" space before and after its actual data values, which are tracked in the `a->offset` and `a->maxsize` fields of the `jl_array_t*` type. The "type tag array" is treated exactly as another `jl_array_t*`, but which shares the same `a->offset`, `a->maxsize`, and `a->len` fields. So the formula to access an isbits Union Array's type tag bytes is `a->data + (a->maxsize - a->offset) * a->elsize + a->offset`; i.e. the Array's `a->data` pointer is already shifted by `a->offset`, so correcting for that, we follow the data all the way to the max of what it can hold `a->maxsize`, then adjust by `a->offset` more bytes to account for any present "front buffering" the array might be doing. This layout in particular allows for very efficient resizing operations as the type tag data only ever has to move when the actual array's data has to move.
+Julia can now also store "isbits Union" values inline in a Memory, as opposed to requiring
+an indirection box. The optimization is accomplished by storing an extra "type tag memory"
+of bytes, one byte per element, alongside the bytes of the actual data. This type tag memory
+serves the same function as the type field case: its value signals the type of the actual
+stored Union value. The "type tag memory" directly follows the regular data space. So the
+formula to access an isbits Union Array's type tag bytes is `a->data + a->length *
+a->elsize`.
diff --git a/doc/src/devdocs/llvm.md b/doc/src/devdocs/llvm.md
index 82ab97f47ff57..170a812c09994 100644
--- a/doc/src/devdocs/llvm.md
+++ b/doc/src/devdocs/llvm.md
@@ -341,8 +341,8 @@ ccall(:foo, Cvoid, (Ptr{Float64},), A)
 In lowering, the compiler will insert a conversion from the array to the
 pointer which drops the reference to the array value. However, we of course
 need to make sure that the array does stay alive while we're doing the
-[`ccall`](@ref). To understand how this is done, first recall the lowering of the
-above code:
+[`ccall`](@ref). To understand how this is done, lets look at a hypothetical
+approximate possible lowering of the above code:
 ```julia
 return $(Expr(:foreigncall, :(:foo), Cvoid, svec(Ptr{Float64}), 0, :(:ccall), Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(A)), :(A)))
 ```
diff --git a/doc/src/devdocs/object.md b/doc/src/devdocs/object.md
index caba6c3f12190..a2f72d623ab21 100644
--- a/doc/src/devdocs/object.md
+++ b/doc/src/devdocs/object.md
@@ -163,11 +163,8 @@ Arrays:
 
 ```c
 jl_array_t *jl_new_array(jl_value_t *atype, jl_tuple_t *dims);
-jl_array_t *jl_new_arrayv(jl_value_t *atype, ...);
 jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr);
-jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr, size_t nc);
-jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr, size_t nc, size_t z);
-jl_array_t *jl_alloc_vec_any(size_t n);
+jl_array_t *jl_alloc_array_nd(jl_value_t *atype, size_t *dims, size_t ndims);
 ```
 
 Note that many of these have alternative allocation functions for various special-purposes. The
diff --git a/doc/src/devdocs/types.md b/doc/src/devdocs/types.md
index c3afc26600c65..42bdf251ac82f 100644
--- a/doc/src/devdocs/types.md
+++ b/doc/src/devdocs/types.md
@@ -100,6 +100,8 @@ UnionAll
       lb: Union{}
       ub: Any
     body: Array{T, N} <: DenseArray{T, N}
+      ref::MemoryRef{T}
+      size::NTuple{N, Int64}
 ```
 
 This indicates that `Array` actually names a `UnionAll` type. There is one `UnionAll` type for
diff --git a/doc/src/manual/embedding.md b/doc/src/manual/embedding.md
index 2b6e48c533849..60a768788bbb7 100644
--- a/doc/src/manual/embedding.md
+++ b/doc/src/manual/embedding.md
@@ -436,7 +436,7 @@ For example:
 
 ```c
 jl_array_t *some_array = ...; // e.g. a Vector{Any}
-void **data = (void**)jl_array_data(some_array);
+void **data = jl_array_data(some_array, void*);
 jl_value_t *some_value = ...;
 data[0] = some_value;
 jl_gc_wb(some_array, some_value);
@@ -487,13 +487,13 @@ referenced.
 In order to access the data of `x`, we can use `jl_array_data`:
 
 ```c
-double *xData = (double*)jl_array_data(x);
+double *xData = jl_array_data(x, double);
 ```
 
 Now we can fill the array:
 
 ```c
-for(size_t i=0; i<jl_array_len(x); i++)
+for (size_t i = 0; i < jl_array_nrows(x); i++)
     xData[i] = i;
 ```
 
@@ -527,10 +527,11 @@ that creates a 2D array and accesses its properties:
 ```c
 // Create 2D array of float64 type
 jl_value_t *array_type = jl_apply_array_type((jl_value_t*)jl_float64_type, 2);
-jl_array_t *x  = jl_alloc_array_2d(array_type, 10, 5);
+int dims[] = {10,5};
+jl_array_t *x  = jl_alloc_array_nd(array_type, dims, 2);
 
 // Get array pointer
-double *p = (double*)jl_array_data(x);
+double *p = jl_array_data(x, double);
 // Get number of dimensions
 int ndims = jl_array_ndims(x);
 // Get the size of the i-th dim
diff --git a/src/Makefile b/src/Makefile
index 906c4357a7d6e..6060cefa7a3bc 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -42,7 +42,7 @@ endif
 
 SRCS := \
 	jltypes gf typemap smallintset ast builtins module interpreter symbol \
-	dlload sys init task array staticdata toplevel jl_uv datatype \
+	dlload sys init task array genericmemory staticdata toplevel jl_uv datatype \
 	simplevector runtime_intrinsics precompile jloptions mtarraylist \
 	threading partr stackwalk gc gc-debug gc-pages gc-stacks gc-alloc-profiler method \
 	jlapi signal-handling safepoint timing subtype rtutils gc-heap-snapshot \
@@ -336,7 +336,7 @@ $(BUILDDIR)/processor.o $(BUILDDIR)/processor.dbg.obj: $(addprefix $(SRCDIR)/,pr
 $(BUILDDIR)/signal-handling.o $(BUILDDIR)/signal-handling.dbg.obj: $(addprefix $(SRCDIR)/,signals-*.c)
 $(BUILDDIR)/staticdata.o $(BUILDDIR)/staticdata.dbg.obj: $(SRCDIR)/staticdata_utils.c $(SRCDIR)/precompile_utils.c $(SRCDIR)/processor.h $(SRCDIR)/builtin_proto.h
 $(BUILDDIR)/toplevel.o $(BUILDDIR)/toplevel.dbg.obj: $(SRCDIR)/builtin_proto.h
-$(BUILDDIR)/ircode.o $(BUILDDIR)/ircode.dbg.obj: $(SRCDIR)/serialize.h
+$(BUILDDIR)/ircode.o $(BUILDDIR)/ircode.dbg.obj: $(SRCDIR)/serialize.h $(SRCDIR)/common_symbols1.inc $(SRCDIR)/common_symbols2.inc
 $(BUILDDIR)/pipeline.o $(BUILDDIR)/pipeline.dbg.obj: $(SRCDIR)/passes.h $(SRCDIR)/jitlayers.h
 
 $(addprefix $(BUILDDIR)/,threading.o threading.dbg.obj gc.o gc.dbg.obj init.c init.dbg.obj task.o task.dbg.obj): $(addprefix $(SRCDIR)/,threading.h)
diff --git a/src/abi_aarch64.cpp b/src/abi_aarch64.cpp
index 514c3c5a81a6d..7c31b6606139a 100644
--- a/src/abi_aarch64.cpp
+++ b/src/abi_aarch64.cpp
@@ -88,7 +88,7 @@ Type *get_llvm_fptype(jl_datatype_t *dt, LLVMContext &ctx) const
 Type *get_llvm_fp_or_vectype(jl_datatype_t *dt, LLVMContext &ctx) const
 {
     // Assume jl_is_datatype(dt) && !jl_is_abstracttype(dt)
-    if (dt->name->mutabl || dt->layout->npointers || dt->layout->haspadding)
+    if (dt->name->mutabl || dt->layout->npointers || dt->layout->flags.haspadding)
         return nullptr;
     return dt->layout->nfields ? get_llvm_vectype(dt, ctx) : get_llvm_fptype(dt, ctx);
 }
@@ -184,7 +184,7 @@ Type *isHFAorHVA(jl_datatype_t *dt, size_t &nele, LLVMContext &ctx) const
     // uniquely addressable members.
     // Maximum HFA and HVA size is 64 bytes (4 x fp128 or 16bytes vector)
     size_t dsz = jl_datatype_size(dt);
-    if (dsz > 64 || !dt->layout || dt->layout->npointers || dt->layout->haspadding)
+    if (dsz > 64 || !dt->layout || dt->layout->npointers || dt->layout->flags.haspadding)
         return NULL;
     nele = 0;
     ElementType eltype;
diff --git a/src/abi_arm.cpp b/src/abi_arm.cpp
index 441aa95b1fdf6..68f980d7b40da 100644
--- a/src/abi_arm.cpp
+++ b/src/abi_arm.cpp
@@ -82,7 +82,7 @@ size_t isLegalHA(jl_datatype_t *dt, Type *&base, LLVMContext &ctx) const
     if (jl_is_structtype(dt)) {
         // Fast path checks before descending the type hierarchy
         // (4 x 128b vector == 64B max size)
-        if (jl_datatype_size(dt) > 64 || dt->layout->npointers || dt->layout->haspadding)
+        if (jl_datatype_size(dt) > 64 || dt->layout->npointers || dt->layout->flags.haspadding)
             return 0;
 
         base = NULL;
diff --git a/src/abi_ppc64le.cpp b/src/abi_ppc64le.cpp
index 44d110422a099..1f10817cfeeee 100644
--- a/src/abi_ppc64le.cpp
+++ b/src/abi_ppc64le.cpp
@@ -44,7 +44,7 @@ struct ABI_PPC64leLayout : AbiLayout {
 // count the homogeneous floating aggregate size (saturating at max count of 8)
 unsigned isHFA(jl_datatype_t *ty, jl_datatype_t **ty0, bool *hva) const
 {
-    if (jl_datatype_size(ty) > 128 || ty->layout->npointers || ty->layout->haspadding)
+    if (jl_datatype_size(ty) > 128 || ty->layout->npointers || ty->layout->flags.haspadding)
         return 9;
 
     size_t i, l = ty->layout->nfields;
diff --git a/src/abi_win32.cpp b/src/abi_win32.cpp
index 078d9b6df4e44..ccfc6a16ebee3 100644
--- a/src/abi_win32.cpp
+++ b/src/abi_win32.cpp
@@ -52,7 +52,7 @@ bool use_sret(jl_datatype_t *dt, LLVMContext &ctx) override
 bool needPassByRef(jl_datatype_t *dt, AttrBuilder &ab, LLVMContext &ctx, Type *Ty) override
 {
     // Use pass by reference for all structs
-    if (dt->layout->nfields > 0) {
+    if (dt->layout->nfields > 0 || dt->layout->npointers) {
         ab.addByValAttr(Ty);
         return true;
     }
@@ -63,7 +63,7 @@ Type *preferred_llvm_type(jl_datatype_t *dt, bool isret, LLVMContext &ctx) const
 {
     // Arguments are either scalar or passed by value
     // rewrite integer sized (non-sret) struct to the corresponding integer
-    if (!dt->layout->nfields)
+    if (!dt->layout->nfields && !dt->layout->npointers)
         return NULL;
     return Type::getIntNTy(ctx, jl_datatype_nbits(dt));
 }
diff --git a/src/abi_x86_64.cpp b/src/abi_x86_64.cpp
index 5938e1e5778a2..6a853421dbccd 100644
--- a/src/abi_x86_64.cpp
+++ b/src/abi_x86_64.cpp
@@ -148,7 +148,7 @@ void classifyType(Classification& accum, jl_datatype_t *dt, uint64_t offset) con
         accum.addField(offset, Sse);
     }
     // Other struct types
-    else if (jl_datatype_size(dt) <= 16 && dt->layout) {
+    else if (jl_datatype_size(dt) <= 16 && dt->layout && !jl_is_layout_opaque(dt->layout)) {
         size_t i;
         for (i = 0; i < jl_datatype_nfields(dt); ++i) {
             jl_value_t *ty = jl_field_type(dt, i);
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 3490ae71e54ce..a83001e77f0fa 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -269,7 +269,7 @@ void *jl_create_native_impl(jl_array_t *methods, LLVMOrcThreadSafeModuleRef llvm
 {
     JL_TIMING(NATIVE_AOT, NATIVE_Create);
     ++CreateNativeCalls;
-    CreateNativeMax.updateMax(jl_array_len(methods));
+    CreateNativeMax.updateMax(jl_array_nrows(methods));
     if (cgparams == NULL)
         cgparams = &jl_default_cgparams;
     jl_native_code_desc_t *data = new jl_native_code_desc_t;
@@ -317,7 +317,7 @@ void *jl_create_native_impl(jl_array_t *methods, LLVMOrcThreadSafeModuleRef llvm
         if (policy != CompilationPolicy::Default && params.world == jl_typeinf_world)
             continue;
         size_t i, l;
-        for (i = 0, l = jl_array_len(methods); i < l; i++) {
+        for (i = 0, l = jl_array_nrows(methods); i < l; i++) {
             // each item in this list is either a MethodInstance indicating something
             // to compile, or an svec(rettype, sig) describing a C-callable alias to create.
             jl_value_t *item = jl_array_ptr_ref(methods, i);
diff --git a/src/array.c b/src/array.c
index 65efbb7e9df19..2c6505b9d6e04 100644
--- a/src/array.c
+++ b/src/array.c
@@ -16,66 +16,6 @@
 extern "C" {
 #endif
 
-// similar to MEMDEBUG's purpose, this ensures there is a garbage byte after a
-// most UInt8 arrays (even String-backed) so that almost any C string
-// processing on it is guaranteed to run too far and return some garbage
-// answers to warn the user of their bug.
-#ifdef NDEBUG
-#define JL_ARRAY_MEMDEBUG_TERMINATOR 0
-#else
-#define JL_ARRAY_MEMDEBUG_TERMINATOR 1
-#endif
-
-#define JL_ARRAY_ALIGN(jl_value, nbytes) LLT_ALIGN(jl_value, nbytes)
-
-static inline void arrayassign_safe(int hasptr, jl_value_t *parent, char *dst, const jl_value_t *src, size_t nb) JL_NOTSAFEPOINT
-{
-    // array can assume more alignment than a field would normally have
-    assert(nb >= jl_datatype_size(jl_typeof(src))); // nb might move some undefined bits, but we should be okay with that
-    if (hasptr) {
-        size_t nptr = nb / sizeof(void*);
-        memmove_refs((void**)dst, (void* const*)src, nptr);
-        jl_gc_multi_wb(parent, src);
-    }
-    else {
-        switch (nb) {
-        case  0: break;
-        case  1: *(uint8_t*)dst  = *(uint8_t*)src;  break;
-        case  2: *(uint16_t*)dst = *(uint16_t*)src; break;
-        case  4: *(uint32_t*)dst = *(uint32_t*)src; break;
-        case  8: *(uint64_t*)dst = *(uint64_t*)src; break;
-        case 16:
-            memcpy(jl_assume_aligned(dst, 16), jl_assume_aligned(src, 16), 16);
-            break;
-        default: memcpy(dst, src, nb);
-        }
-    }
-}
-
-static inline void memmove_safe(int hasptr, char *dst, const char *src, size_t nb) JL_NOTSAFEPOINT
-{
-    if (hasptr)
-        memmove_refs((void**)dst, (void**)src, nb / sizeof(void*));
-    else
-        memmove(dst, src, nb);
-}
-
-// array constructors ---------------------------------------------------------
-JL_DLLEXPORT char *jl_array_typetagdata(jl_array_t *a) JL_NOTSAFEPOINT
-{
-    assert(jl_array_isbitsunion(a));
-    return ((char*)jl_array_data(a)) + ((jl_array_ndims(a) == 1 ? (a->maxsize - a->offset) : jl_array_len(a)) * a->elsize) + a->offset;
-}
-
-STATIC_INLINE jl_value_t *jl_array_owner(jl_array_t *a JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
-{
-    if (a->flags.how == 3) {
-        a = (jl_array_t*)jl_array_data_owner(a);
-        assert(jl_is_string(a) || a->flags.how != 3);
-    }
-    return (jl_value_t*)a;
-}
-
 #if defined(_P64) && defined(UINT128MAX)
 typedef __uint128_t wideint_t;
 #else
@@ -84,142 +24,27 @@ typedef uint64_t wideint_t;
 
 #define MAXINTVAL (((size_t)-1)>>1)
 
-JL_DLLEXPORT int jl_array_validate_dims(size_t *nel, size_t *tot, uint32_t ndims, size_t *dims, size_t elsz)
+JL_DLLEXPORT int jl_array_validate_dims(size_t *nel, uint32_t ndims, size_t *dims)
 {
     size_t i;
     size_t _nel = 1;
-    for(i=0; i < ndims; i++) {
+    for (i = 0; i < ndims; i++) {
         size_t di = dims[i];
         wideint_t prod = (wideint_t)_nel * (wideint_t)di;
         if (prod >= (wideint_t) MAXINTVAL || di >= MAXINTVAL)
             return 1;
         _nel = prod;
     }
-    wideint_t prod = (wideint_t)elsz * (wideint_t)_nel;
-    if (prod >= (wideint_t) MAXINTVAL)
-        return 2;
     *nel = _nel;
-    *tot = (size_t)prod;
     return 0;
 }
 
-static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
-                               int8_t isunboxed, int8_t hasptr, int8_t isunion, int8_t zeroinit, size_t elsz)
-{
-    jl_task_t *ct = jl_current_task;
-    size_t i, tot, nel;
-    void *data;
-    jl_array_t *a;
-    assert(isunboxed || elsz == sizeof(void*));
-    assert(atype == NULL || isunion == jl_is_uniontype(jl_tparam0(atype)));
-    int validated = jl_array_validate_dims(&nel, &tot, ndims, dims, elsz);
-    if (validated == 1)
-        jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
-    else if (validated == 2)
-        jl_error("invalid Array size");
-    if (isunboxed) {
-        if (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1 && !isunion) {
-            // extra byte for all julia allocated byte arrays
-            tot++;
-        }
-        if (isunion) {
-            // an extra byte for each isbits union array element, stored after a->maxsize
-            tot += nel;
-        }
-    }
-
-    int ndimwords = jl_array_ndimwords(ndims);
-    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
-    if (tot <= ARRAY_INLINE_NBYTES) {
-        // align data area
-        if (tot >= ARRAY_CACHE_ALIGN_THRESHOLD)
-            tsz = JL_ARRAY_ALIGN(tsz, JL_CACHE_BYTE_ALIGNMENT);
-        else if (isunboxed && elsz >= 4)
-            tsz = JL_ARRAY_ALIGN(tsz, JL_SMALL_BYTE_ALIGNMENT);
-        size_t doffs = tsz;
-        tsz += tot;
-        // jl_array_t is large enough that objects will always be aligned 16
-        a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
-        assert(((size_t)a & 15) == 0);
-        // No allocation or safepoint allowed after this
-        a->flags.how = 0;
-        data = (char*)a + doffs;
-    }
-    else {
-        data = jl_gc_managed_malloc(tot);
-        // Allocate the Array **after** allocating the data
-        // to make sure the array is still young
-        a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
-        // No allocation or safepoint allowed after this
-        a->flags.how = 2;
-        jl_gc_track_malloced_array(ct->ptls, a);
-    }
-    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
-
-    if (zeroinit)
-        memset(data, 0, tot);
-    if (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1 && !isunion) {
-        ((char*)data)[tot - 1] = 0xfe;
-        msan_allocated_memory(&((char*)data)[tot - 1], 1);
-    }
-    a->data = data;
-    a->length = nel;
-    a->flags.ndims = ndims;
-    a->flags.ptrarray = !isunboxed;
-    a->flags.hasptr = hasptr;
-    a->elsize = elsz;
-    a->flags.isshared = 0;
-    a->flags.isaligned = 1;
-    a->offset = 0;
-    if (ndims == 1) {
-        a->nrows = nel;
-        a->maxsize = nel;
-    }
-    else if (a->flags.ndims != ndims) {
-        jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
-    }
-    else {
-        size_t *adims = &a->nrows;
-        for (i = 0; i < ndims; i++)
-            adims[i] = dims[i];
-    }
-
-    return a;
-}
-
-static inline jl_array_t *_new_array(jl_value_t *atype, uint32_t ndims, size_t *dims)
-{
-    jl_value_t *eltype = jl_tparam0(atype);
-    size_t elsz = 0, al = 0;
-    if (!jl_is_kind(jl_typeof(eltype)))
-        jl_type_error_rt("Array", "element type", (jl_value_t*)jl_type_type, eltype);
-    int isunboxed = jl_islayout_inline(eltype, &elsz, &al);
-    int isunion = jl_is_uniontype(eltype);
-    int hasptr = isunboxed && (jl_is_datatype(eltype) && ((jl_datatype_t*)eltype)->layout->npointers > 0);
-    if (!isunboxed) {
-        elsz = sizeof(void*);
-        al = elsz;
-    }
-    else {
-        elsz = LLT_ALIGN(elsz, al);
-    }
-    int zi = !isunboxed || hasptr || isunion || (jl_is_datatype(eltype) && ((jl_datatype_t*)eltype)->zeroinit);
-
-    return _new_array_(atype, ndims, dims, isunboxed, hasptr, isunion, zi, elsz);
-}
-
-jl_array_t *jl_new_array_for_deserialization(jl_value_t *atype, uint32_t ndims, size_t *dims,
-                                             int isunboxed, int hasptr, int isunion, int elsz)
-{
-    return _new_array_(atype, ndims, dims, isunboxed, hasptr, isunion, 0, (size_t)elsz);
-}
-
 #ifndef JL_NDEBUG
 static inline int is_ntuple_long(jl_value_t *v)
 {
     if (!jl_is_tuple(v))
         return 0;
-    jl_value_t *tt = jl_typeof(v);
+    jl_value_t *tt = (jl_value_t*)jl_typetagof(v);
     size_t i, nfields = jl_nparams(tt);
     for (i = 0; i < nfields; i++) {
         if (jl_tparam(tt, i) != (jl_value_t*)jl_long_type) {
@@ -230,315 +55,129 @@ static inline int is_ntuple_long(jl_value_t *v)
 }
 #endif
 
-JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
-                                          jl_value_t *_dims)
+#define jl_array_elsize(a) (((jl_datatype_t*)jl_typetagof((a)->ref.mem))->layout->size)
+
+static char *jl_array_typetagdata(jl_array_t *a) JL_NOTSAFEPOINT
 {
-    jl_task_t *ct = jl_current_task;
-    assert(jl_types_equal(jl_tparam0(jl_typeof(data)), jl_tparam0(atype)));
+    assert(jl_genericmemory_isbitsunion(a->ref.mem));
+    return jl_genericmemory_typetagdata(a->ref.mem) + (uintptr_t)a->ref.ptr_or_offset;
+}
 
-    size_t ndims = jl_nfields(_dims);
-    assert(is_ntuple_long(_dims));
-    size_t *dims = (size_t*)_dims;
-    int ndimwords = jl_array_ndimwords(ndims);
-    int tsz = sizeof(jl_array_t) + ndimwords * sizeof(size_t) + sizeof(void*);
+STATIC_INLINE jl_array_t *_new_array(jl_value_t *atype, jl_genericmemory_t *mem, const jl_datatype_layout_t *layout, uint32_t ndims, size_t *dims)
+{
+    jl_task_t *ct = jl_current_task;
+    size_t i;
+    int tsz = sizeof(jl_array_t) + ndims*sizeof(size_t);
     jl_array_t *a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
-    // No allocation or safepoint allowed after this
-    // copy data (except dims) from the old object
-    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
-    a->flags.ndims = ndims;
-    a->offset = 0;
-    a->data = NULL;
-    a->flags.isaligned = data->flags.isaligned;
-    a->elsize = data->elsize;
-    a->flags.ptrarray = data->flags.ptrarray;
-    a->flags.hasptr = data->flags.hasptr;
-
-    // if data is itself a shared wrapper,
-    // owner should point back to the original array
-    jl_array_t *owner = (jl_array_t*)jl_array_owner(data);
-    jl_array_data_owner(a) = (jl_value_t*)owner;
-
-    a->flags.how = 3;
-    a->data = data->data;
-    a->flags.isshared = 1;
-    data->flags.isshared = 1;
+    a->ref.mem = mem;
+    if (layout->flags.arrayelem_isunion || layout->size == 0)
+        a->ref.ptr_or_offset = 0;
+    else
+        a->ref.ptr_or_offset = mem->ptr;
+    for (i = 0; i < ndims; i++)
+        a->dimsize[i] = dims[i];
+    return a;
+}
 
-    if (ndims == 1) {
-        size_t l = dims[0];
-        a->length = l;
-        a->nrows = l;
-        a->maxsize = l;
-    }
-    else if (a->flags.ndims != ndims) {
+STATIC_INLINE jl_array_t *new_array(jl_value_t *atype, uint32_t ndims, size_t *dims)
+{
+    size_t nel;
+    if (jl_array_validate_dims(&nel, ndims, dims) || *(size_t*)jl_tparam1(atype) != ndims)
         jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
-    }
-    else {
-        size_t *adims = &a->nrows;
-        size_t l = 1;
-        wideint_t prod;
-        for (size_t i = 0; i < ndims; i++) {
-            adims[i] = dims[i];
-            prod = (wideint_t)l * (wideint_t)adims[i];
-            if (prod > (wideint_t) MAXINTVAL)
-                jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
-            l = prod;
-        }
-        a->length = l;
-    }
-
+    jl_value_t *mtype = jl_field_type_concrete((jl_datatype_t*)jl_field_type_concrete((jl_datatype_t*)atype, 0), 1);
+    // extra byte for all julia allocated byte vectors
+    jl_genericmemory_t *mem = jl_alloc_genericmemory(mtype, nel);
+    JL_GC_PUSH1(&mem);
+    jl_array_t *a = _new_array(atype, mem, ((jl_datatype_t*)mtype)->layout, ndims, dims);
+    JL_GC_POP();
     return a;
 }
 
+jl_genericmemory_t *_new_genericmemory_(jl_value_t *mtype, size_t nel, int8_t isunion, int8_t zeroinit, size_t elsz);
+
+JL_DLLEXPORT jl_genericmemory_t *jl_string_to_genericmemory(jl_value_t *str);
+
 JL_DLLEXPORT jl_array_t *jl_string_to_array(jl_value_t *str)
 {
     jl_task_t *ct = jl_current_task;
-    jl_array_t *a;
-
-    int ndimwords = jl_array_ndimwords(1);
-    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t) + sizeof(void*);
-    a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, jl_array_uint8_type);
-    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
-    a->flags.ndims = 1;
-    a->offset = 0;
-    a->data = jl_string_data(str);
-    a->flags.isaligned = 0;
-    a->elsize = 1;
-    a->flags.ptrarray = 0;
-    a->flags.hasptr = 0;
-    jl_array_data_owner(a) = str;
-    a->flags.how = 3;
-    a->flags.isshared = 1;
-    size_t l = jl_string_len(str);
-    a->length = l;
-    a->nrows = a->maxsize = l;
+    jl_genericmemory_t *mem = jl_string_to_genericmemory(str);
+    JL_GC_PUSH1(&mem);
+    int ndimwords = 1;
+    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
+    jl_array_t *a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, jl_array_uint8_type);
+    a->ref.mem = mem;
+    a->ref.ptr_or_offset = mem->ptr;
+    a->dimsize[0] = mem->length;
+    JL_GC_POP();
     return a;
 }
 
-// own_buffer != 0 iff GC should call free() on this pointer eventually
 JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
                                             size_t nel, int own_buffer)
 {
-    jl_task_t *ct = jl_current_task;
-    jl_array_t *a;
-    jl_value_t *eltype = jl_tparam0(atype);
-
-    int isunboxed = jl_stored_inline(eltype);
-    if (isunboxed && jl_is_uniontype(eltype))
-        jl_exceptionf(jl_argumenterror_type,
-                      "unsafe_wrap: unspecified layout for union element type");
-    size_t elsz;
-    unsigned align;
-    if (isunboxed) {
-        elsz = jl_datatype_size(eltype);
-        align = jl_datatype_align(eltype);
-    }
-    else {
-        align = elsz = sizeof(void*);
-    }
-    if (((uintptr_t)data) & ((align > JL_HEAP_ALIGNMENT ? JL_HEAP_ALIGNMENT : align) - 1))
-        jl_exceptionf(jl_argumenterror_type,
-                      "unsafe_wrap: pointer %p is not properly aligned to %u bytes", data, align);
-
-    int ndimwords = jl_array_ndimwords(1);
-    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
-    a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
-    // No allocation or safepoint allowed after this
-    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
-    a->data = data;
-    a->length = nel;
-    a->elsize = LLT_ALIGN(elsz, align);
-    a->flags.ptrarray = !isunboxed;
-    a->flags.hasptr = isunboxed && (jl_is_datatype(eltype) && ((jl_datatype_t*)eltype)->layout->npointers > 0);
-    a->flags.ndims = 1;
-    a->flags.isshared = 1;
-    a->flags.isaligned = 0;  // TODO: allow passing memalign'd buffers
-    if (own_buffer) {
-        a->flags.how = 2;
-        jl_gc_track_malloced_array(ct->ptls, a);
-        jl_gc_count_allocd(nel*elsz);
-    }
-    else {
-        a->flags.how = 0;
-    }
-
-    a->nrows = nel;
-    a->maxsize = nel;
-    a->offset = 0;
+    if (*(size_t*)jl_tparam1(atype) != 1)
+        jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
+    jl_value_t *mtype = jl_field_type_concrete((jl_datatype_t*)jl_field_type_concrete((jl_datatype_t*)atype, 0), 1);
+    jl_genericmemory_t *mem = jl_ptr_to_genericmemory(mtype, data, nel, own_buffer);
+    JL_GC_PUSH1(&mem);
+    jl_array_t *a = _new_array(atype, mem, ((jl_datatype_t*)mtype)->layout, 1, &nel);
+    JL_GC_POP();
     return a;
 }
 
 JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
                                          jl_value_t *_dims, int own_buffer)
 {
-    jl_task_t *ct = jl_current_task;
-    size_t nel = 1;
-    jl_array_t *a;
     size_t ndims = jl_nfields(_dims);
-    wideint_t prod;
     assert(is_ntuple_long(_dims));
     size_t *dims = (size_t*)_dims;
-    for (size_t i = 0; i < ndims; i++) {
-        prod = (wideint_t)nel * (wideint_t)dims[i];
-        if (prod > (wideint_t) MAXINTVAL)
-            jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
-        nel = prod;
-    }
-    if (__unlikely(ndims == 1))
-        return jl_ptr_to_array_1d(atype, data, nel, own_buffer);
-    jl_value_t *eltype = jl_tparam0(atype);
-
-    int isunboxed = jl_stored_inline(eltype);
-    if (isunboxed && jl_is_uniontype(eltype))
-        jl_exceptionf(jl_argumenterror_type,
-                      "unsafe_wrap: unspecified layout for union element type");
-    size_t elsz;
-    unsigned align;
-    if (isunboxed) {
-        elsz = jl_datatype_size(eltype);
-        align = jl_datatype_align(eltype);
-    }
-    else {
-        align = elsz = sizeof(void*);
-    }
-    if (((uintptr_t)data) & ((align > JL_HEAP_ALIGNMENT ? JL_HEAP_ALIGNMENT : align) - 1))
-        jl_exceptionf(jl_argumenterror_type,
-                      "unsafe_wrap: pointer %p is not properly aligned to %u bytes", data, align);
-
-    int ndimwords = jl_array_ndimwords(ndims);
-    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
-    a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, atype);
-    // No allocation or safepoint allowed after this
-    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
-    a->data = data;
-    a->length = nel;
-    a->elsize = LLT_ALIGN(elsz, align);
-    a->flags.ptrarray = !isunboxed;
-    a->flags.hasptr = isunboxed && (jl_is_datatype(eltype) && ((jl_datatype_t*)eltype)->layout->npointers > 0);
-    a->flags.ndims = ndims;
-    a->offset = 0;
-    a->flags.isshared = 1;
-    a->flags.isaligned = 0;
-    if (own_buffer) {
-        a->flags.how = 2;
-        jl_gc_track_malloced_array(ct->ptls, a);
-        jl_gc_count_allocd(nel*elsz);
-    }
-    else {
-        a->flags.how = 0;
-    }
-
-    assert(ndims != 1); // handled above
-    if (a->flags.ndims != ndims)
+    size_t nel;
+    if (jl_array_validate_dims(&nel, ndims, dims) || *(size_t*)jl_tparam1(atype) != ndims)
         jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
-    memcpy(&a->nrows, dims, ndims * sizeof(size_t));
-    return a;
-}
-
-JL_DLLEXPORT jl_array_t *jl_new_array(jl_value_t *atype, jl_value_t *_dims)
-{
-    size_t ndims = jl_nfields(_dims);
-    assert(is_ntuple_long(_dims));
-    return _new_array(atype, ndims, (size_t*)_dims);
-}
-
-JL_DLLEXPORT jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr)
-{
-    return _new_array(atype, 1, &nr);
-}
-
-JL_DLLEXPORT jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr,
-                                           size_t nc)
-{
-    size_t d[2] = {nr, nc};
-    return _new_array(atype, 2, &d[0]);
-}
-
-JL_DLLEXPORT jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr,
-                                           size_t nc, size_t z)
-{
-    size_t d[3] = {nr, nc, z};
-    return _new_array(atype, 3, &d[0]);
-}
-
-JL_DLLEXPORT jl_array_t *jl_pchar_to_array(const char *str, size_t len)
-{
-    jl_array_t *a = jl_alloc_array_1d(jl_array_uint8_type, len);
-    memcpy(a->data, str, len);
+    jl_value_t *mtype = jl_field_type_concrete((jl_datatype_t*)jl_field_type_concrete((jl_datatype_t*)atype, 0), 1);
+    jl_genericmemory_t *mem = jl_ptr_to_genericmemory(mtype, data, nel, own_buffer);
+    JL_GC_PUSH1(&mem);
+    jl_array_t *a = _new_array(atype, mem, ((jl_datatype_t*)mtype)->layout, ndims, dims);
+    JL_GC_POP();
     return a;
 }
 
 JL_DLLEXPORT jl_value_t *jl_array_to_string(jl_array_t *a)
 {
-    size_t len = jl_array_len(a);
+    size_t len = jl_array_nrows(a); // only for Vector
     if (len == 0) {
         // this may seem like purely an optimization (which it also is), but it
         // also ensures that calling `String(a)` doesn't corrupt a previous
         // string also created the same way, where `a = StringVector(_)`.
         return jl_an_empty_string;
     }
-    if (a->flags.how == 3 && a->offset == 0 && a->elsize == 1 &&
-        (jl_array_ndims(a) != 1 ||
-         ((a->maxsize + sizeof(void*) + 1 <= GC_MAX_SZCLASS) == (len + sizeof(void*) + 1 <= GC_MAX_SZCLASS)))) {
-        jl_value_t *o = jl_array_data_owner(a);
-        if (jl_is_string(o)) {
-            a->flags.isshared = 1;
-            *(size_t*)o = len;
-            a->nrows = 0;
-            a->length = 0;
-            a->maxsize = 0;
-            if (jl_string_data(o)[len] != '\0')
-                jl_string_data(o)[len] = '\0';
-            return o;
-        }
-    }
-    a->nrows = 0;
-    a->length = 0;
-    a->maxsize = 0;
-    return jl_pchar_to_string((const char*)jl_array_data(a), len);
+    jl_value_t *str;
+    if (a->ref.ptr_or_offset == a->ref.mem->ptr)
+        str = jl_genericmemory_to_string(a->ref.mem, len);
+    else
+        str = jl_pchar_to_string(jl_array_data(a, char), len);
+    a->ref.mem = (jl_genericmemory_t*)((jl_datatype_t*)jl_memory_uint8_type)->instance;
+    a->ref.ptr_or_offset = a->ref.mem->ptr;
+    a->dimsize[0] = 0;
+    return str;
 }
 
-JL_DLLEXPORT jl_value_t *jl_alloc_string(size_t len)
+JL_DLLEXPORT jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr)
 {
-    if (len == 0)
-        return jl_an_empty_string;
-    size_t sz = sizeof(size_t) + len + 1; // add space for trailing \nul protector and size
-    if (sz < len) // overflow
-        jl_throw(jl_memory_exception);
-    jl_task_t *ct = jl_current_task;
-    jl_value_t *s;
-    jl_ptls_t ptls = ct->ptls;
-    const size_t allocsz = sz + sizeof(jl_taggedvalue_t);
-    if (sz <= GC_MAX_SZCLASS) {
-        int pool_id = jl_gc_szclass_align8(allocsz);
-        jl_gc_pool_t *p = &ptls->heap.norm_pools[pool_id];
-        int osize = jl_gc_sizeclasses[pool_id];
-        // We call `jl_gc_pool_alloc_noinline` instead of `jl_gc_pool_alloc` to avoid double-counting in
-        // the Allocations Profiler. (See https://github.com/JuliaLang/julia/pull/43868 for more details.)
-        s = jl_gc_pool_alloc_noinline(ptls, (char*)p - (char*)ptls, osize);
-    }
-    else {
-        if (allocsz < sz) // overflow in adding offs, size was "negative"
-            jl_throw(jl_memory_exception);
-        s = jl_gc_big_alloc_noinline(ptls, allocsz);
-    }
-    jl_set_typetagof(s, jl_string_tag, 0);
-    maybe_record_alloc_to_profile(s, len, jl_string_type);
-    *(size_t*)s = len;
-    jl_string_data(s)[len] = 0;
-    return s;
+    return new_array(atype, 1, &nr);
 }
 
-JL_DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len)
+JL_DLLEXPORT jl_array_t *jl_alloc_array_nd(jl_value_t *atype, size_t *dims, size_t ndims)
 {
-    jl_value_t *s = jl_alloc_string(len);
-    if (len > 0)
-        memcpy(jl_string_data(s), str, len);
-    return s;
+    return new_array(atype, ndims, dims);
 }
 
-JL_DLLEXPORT jl_value_t *jl_cstr_to_string(const char *str)
+JL_DLLEXPORT jl_array_t *jl_pchar_to_array(const char *str, size_t len)
 {
-    return jl_pchar_to_string(str, strlen(str));
+    jl_array_t *a = jl_alloc_array_1d(jl_array_uint8_type, len);
+    assert(jl_array_data(a, char));
+    memcpy(jl_array_data(a, char), str, len);
+    return a;
 }
 
 JL_DLLEXPORT jl_array_t *jl_alloc_vec_any(size_t n)
@@ -555,744 +194,164 @@ JL_DLLEXPORT jl_value_t *jl_apply_array_type(jl_value_t *type, size_t dim)
     return ret;
 }
 
-// array primitives -----------------------------------------------------------
-
-JL_DLLEXPORT jl_value_t *jl_ptrarrayref(jl_array_t *a JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT
-{
-    assert(i < jl_array_len(a));
-    assert(a->flags.ptrarray);
-    jl_value_t *elt = jl_atomic_load_relaxed(((_Atomic(jl_value_t*)*)a->data) + i);
-    if (elt == NULL)
-        jl_throw(jl_undefref_exception);
-    return elt;
-}
-
-
-JL_DLLEXPORT jl_value_t *jl_arrayref(jl_array_t *a, size_t i)
-{
-    if (a->flags.ptrarray)
-        return jl_ptrarrayref(a, i);
-    assert(i < jl_array_len(a));
-    jl_value_t *eltype = (jl_value_t*)jl_tparam0(jl_typeof(a));
-    if (jl_is_uniontype(eltype)) {
-        // isbits union selector bytes are always stored directly after the last array element
-        uint8_t sel = jl_array_typetagdata(a)[i];
-        eltype = jl_nth_union_component(eltype, sel);
-        if (jl_is_datatype_singleton((jl_datatype_t*)eltype))
-            return ((jl_datatype_t*)eltype)->instance;
-    }
-    jl_value_t *r = undefref_check((jl_datatype_t*)eltype, jl_new_bits(eltype, &((char*)a->data)[i * a->elsize]));
-    if (__unlikely(r == NULL))
-        jl_throw(jl_undefref_exception);
-    return r;
-}
-
-JL_DLLEXPORT int jl_array_isassigned(jl_array_t *a, size_t i)
-{
-    if (a->flags.ptrarray) {
-        return jl_atomic_load_relaxed(((_Atomic(jl_value_t*)*)jl_array_data(a)) + i) != NULL;
-    }
-    else if (a->flags.hasptr) {
-         jl_datatype_t *eltype = (jl_datatype_t*)jl_tparam0(jl_typeof(a));
-         assert(eltype->layout->first_ptr >= 0);
-         jl_value_t **elem = (jl_value_t**)((char*)a->data + i * a->elsize);
-         return elem[eltype->layout->first_ptr] != NULL;
-    }
-    return 1;
-}
-
-JL_DLLEXPORT void jl_arrayset(jl_array_t *a JL_ROOTING_ARGUMENT, jl_value_t *rhs JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, size_t i)
-{
-    assert(i < jl_array_len(a));
-    jl_value_t *eltype = jl_tparam0(jl_typeof(a));
-    if (eltype != (jl_value_t*)jl_any_type) {
-        JL_GC_PUSH1(&rhs);
-        if (!jl_isa(rhs, eltype))
-            jl_type_error("arrayset", eltype, rhs);
-        JL_GC_POP();
-    }
-    if (!a->flags.ptrarray) {
-        int hasptr;
-        if (jl_is_uniontype(eltype)) {
-            uint8_t *psel = &((uint8_t*)jl_array_typetagdata(a))[i];
-            unsigned nth = 0;
-            if (!jl_find_union_component(eltype, jl_typeof(rhs), &nth))
-                assert(0 && "invalid arrayset to isbits union");
-            *psel = nth;
-            if (jl_is_datatype_singleton((jl_datatype_t*)jl_typeof(rhs)))
-                return;
-            hasptr = 0;
-        }
-        else {
-            hasptr = a->flags.hasptr;
-        }
-        arrayassign_safe(hasptr, jl_array_owner(a), &((char*)a->data)[i * a->elsize], rhs, a->elsize);
-    }
-    else {
-        jl_atomic_store_release(((_Atomic(jl_value_t*)*)a->data) + i, rhs);
-        jl_gc_wb(jl_array_owner(a), rhs);
-    }
-}
-
-JL_DLLEXPORT void jl_arrayunset(jl_array_t *a, size_t i)
-{
-    if (i >= jl_array_len(a))
-        jl_bounds_error_int((jl_value_t*)a, i + 1);
-    if (a->flags.ptrarray)
-        jl_atomic_store_relaxed(((_Atomic(jl_value_t*)*)a->data) + i, NULL);
-    else if (a->flags.hasptr) {
-        size_t elsize = a->elsize;
-        jl_assume(elsize >= sizeof(void*) && elsize % sizeof(void*) == 0);
-        memset((char*)a->data + elsize * i, 0, elsize);
-    }
-}
-
-// at this size and bigger, allocate resized array data with malloc directly
-// instead of managing them separately as gc objects
-#define MALLOC_THRESH 1048576
-
-// Resize the buffer to a max size of `newlen`
-// The buffer can either be newly allocated or realloc'd, the return
-// value is 1 if a new buffer is allocated and 0 if it is realloc'd.
-// the caller needs to take care of moving the data from the old buffer
-// to the new one if necessary.
-// When this function returns, the `->data` pointer always points to
-// the **beginning** of the new buffer.
-static int NOINLINE array_resize_buffer(jl_array_t *a, size_t newlen)
-{
-    jl_task_t *ct = jl_current_task;
-    assert(!a->flags.isshared || a->flags.how == 3);
-    size_t elsz = a->elsize;
-    size_t nbytes = newlen * elsz;
-    size_t oldnbytes = a->maxsize * elsz;
-    size_t oldoffsnb = a->offset * elsz;
-    size_t oldlen = a->nrows;
-    int isbitsunion = jl_array_isbitsunion(a);
-    assert(nbytes >= oldnbytes);
-    if (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1 && !isbitsunion) {
-        nbytes++;
-        oldnbytes++;
-    }
-    if (isbitsunion) {
-        nbytes += newlen;
-        oldnbytes += a->maxsize;
-    }
-    int newbuf = 0;
-    if (a->flags.how == 2) {
-        // already malloc'd - use realloc
-        char *olddata = (char*)a->data - oldoffsnb;
-        a->data = jl_gc_managed_realloc(olddata, nbytes, oldnbytes,
-                                        a->flags.isaligned, (jl_value_t*)a);
-    }
-    else if (a->flags.how == 3 && jl_is_string(jl_array_data_owner(a)) && !isbitsunion) {
-        // if data is in a String, keep it that way
-        jl_value_t *s;
-        if (a->flags.isshared) {
-            s = jl_alloc_string(nbytes - (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1));
-            newbuf = 1;
-        }
-        else {
-            s = jl_gc_realloc_string(jl_array_data_owner(a), nbytes - (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1));
-        }
-        jl_array_data_owner(a) = s;
-        jl_gc_wb(a, s);
-        a->data = jl_string_data(s);
-    }
-    else {
-        newbuf = 1;
-        if (nbytes >= MALLOC_THRESH) {
-            a->data = jl_gc_managed_malloc(nbytes);
-            jl_gc_track_malloced_array(ct->ptls, a);
-            a->flags.how = 2;
-            a->flags.isaligned = 1;
-        }
-        else {
-            a->data = jl_gc_alloc_buf(ct->ptls, nbytes);
-            a->flags.how = 1;
-            jl_gc_wb_buf(a, a->data, nbytes);
-        }
-    }
-    if (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1 && !isbitsunion) {
-        memset((char*)a->data + oldnbytes - 1, 0xfe, nbytes - oldnbytes + 1);
-        msan_allocated_memory((char*)a->data + oldnbytes - 1, nbytes - oldnbytes + 1);
-    }
-    (void)oldlen;
-    assert(oldlen == a->nrows &&
-           "Race condition detected: recursive resizing on the same array.");
-    a->flags.isshared = 0;
-    a->maxsize = newlen;
-    return newbuf;
-}
-
-static void NOINLINE array_try_unshare(jl_array_t *a)
-{
-    if (a->flags.isshared) {
-        if (a->flags.how != 3)
-            jl_error("cannot resize array with shared data");
-        // allow resizing when data is shared with a String
-        if (jl_is_string(jl_array_data_owner(a)))
-            return;
-        assert(a->offset == 0);
-        size_t len = a->maxsize;
-        size_t nbytes = len * a->elsize;
-        if (jl_array_isbitsunion(a)) {
-            nbytes += len;
-        }
-        char *olddata = (char*)a->data;
-        int newbuf = array_resize_buffer(a, len);
-        assert(newbuf);
-        (void)newbuf;
-        memcpy(a->data, olddata, nbytes);
-    }
-}
-
-size_t overallocation(size_t maxsize)
-{
-    if (maxsize < 8)
-        return 8;
-    // compute maxsize = maxsize + 4*maxsize^(7/8) + maxsize/8
-    // for small n, we grow faster than O(n)
-    // for large n, we grow at O(n/8)
-    // and as we reach O(memory) for memory>>1MB,
-    // this means we end by adding about 10% of memory each time
-    int exp2 = sizeof(maxsize) * 8 -
-#ifdef _P64
-        __builtin_clzll(maxsize);
-#else
-        __builtin_clz(maxsize);
-#endif
-    maxsize += ((size_t)1 << (exp2 * 7 / 8)) * 4 + maxsize / 8;
-    return maxsize;
-}
-
-STATIC_INLINE void jl_array_grow_at_beg(jl_array_t *a, size_t idx, size_t inc,
-                                        size_t n)
+JL_DLLEXPORT void jl_array_grow_end(jl_array_t *a, size_t inc)
 {
-    // designed to handle the case of growing and shrinking at both ends
-    if (__unlikely(a->flags.isshared)) {
-        if (a->flags.how != 3)
-            jl_error("cannot resize array with shared data");
-        if (inc == 0) {
-            // If inc > 0, it will always trigger the slow path and unshare the
-            // buffer
-            array_try_unshare(a);
-            return;
-        }
-    }
+    size_t n = jl_array_nrows(a);
+    size_t elsz = jl_array_elsize(a);
+    char *data = jl_array_data(a,char);
+    jl_value_t *mtype = (jl_value_t*)jl_typetagof(a->ref.mem);
+    int isbitsunion = jl_genericmemory_isbitsunion(a->ref.mem);
     size_t newnrows = n + inc;
-    size_t elsz = a->elsize;
-    size_t nbinc = inc * elsz;
-    char *data = (char*)a->data;
-    char *newdata;
-    char *typetagdata;
-    char *newtypetagdata = NULL;
-    int isbitsunion = jl_array_isbitsunion(a);
-    if (isbitsunion) typetagdata = jl_array_typetagdata(a);
-    if (a->offset >= inc) {
-        // already have enough space in a->offset
-        newdata = data - nbinc;
-        a->offset -= inc;
-        if (isbitsunion) newtypetagdata = typetagdata - inc;
-        if (idx > 0) {
-            // inserting new elements after 1st element
-            memmove_safe(a->flags.hasptr, newdata, data, idx * elsz);
-            if (isbitsunion) {
-                memmove(newtypetagdata, typetagdata, idx);
-                memset(newtypetagdata + idx, 0, inc);
-            }
-        }
-    }
-    else {
-        // not enough room for requested growth from existing a->offset
-        size_t oldoffset = a->offset;
-        size_t oldoffsnb = oldoffset * elsz;
-        size_t oldmaxsize = a->maxsize;
-        size_t nb1 = idx * elsz;
-        if (inc > (a->maxsize - n) / 2 - (a->maxsize - n) / 20) {
-            // not enough room for requested growth from end of array
-            size_t newlen = inc * 2;
-            while (n + 2 * inc > newlen - a->offset)
-                newlen *= 2;
-            size_t newmaxsize = overallocation(a->maxsize);
-            if (newlen < newmaxsize)
-                newlen = newmaxsize;
-            size_t newoffset = (newlen - newnrows) / 2;
-            if (!array_resize_buffer(a, newlen)) {
-                data = (char*)a->data + oldoffsnb;
-            }
-            newdata = (char*)a->data + newoffset * elsz;
-            if (isbitsunion) {
-                typetagdata = data + (oldmaxsize - oldoffset) * elsz + oldoffset;
-                newtypetagdata = newdata + (a->maxsize - newoffset) * elsz + newoffset;
-                memmove(newtypetagdata, typetagdata, idx);
-                memset(newtypetagdata + idx, 0, inc);
-                memmove(newtypetagdata + idx + inc, typetagdata + idx, n - idx);
-            }
-            // We could use memcpy if resizing allocates a new buffer,
-            // hopefully it's not a particularly important optimization.
-            if (idx > 0 && newdata < data) {
-                memmove_safe(a->flags.hasptr, newdata, data, nb1);
-            }
-            memmove_safe(a->flags.hasptr, newdata + nbinc + nb1, data + nb1, n * elsz - nb1);
-            if (idx > 0 && newdata > data) {
-                memmove_safe(a->flags.hasptr, newdata, data, nb1);
-            }
-            a->offset = newoffset;
-        }
-        else {
-            // use extra space between a->nrows & a->maxsize
-            a->offset = (a->maxsize - newnrows) / 2;
-            newdata = data - oldoffsnb + a->offset * elsz;
-            if (isbitsunion) newtypetagdata = newdata + (a->maxsize - a->offset) * elsz + a->offset;
-            if (idx > 0 && newdata < data) {
-                memmove_safe(a->flags.hasptr, newdata, data, nb1);
-                if (isbitsunion) {
-                    memmove(newtypetagdata, typetagdata, idx);
-                    memset(newtypetagdata + idx, 0, inc);
-                }
-            }
-            memmove_safe(a->flags.hasptr, newdata + nbinc + nb1, data + nb1, n * elsz - nb1);
-            if (isbitsunion) memmove(newtypetagdata + idx + inc, typetagdata + idx, n - idx);
-            if (idx > 0 && newdata > data) {
-                memmove_safe(a->flags.hasptr, newdata, data, nb1);
-                if (isbitsunion) {
-                    memmove(newtypetagdata, typetagdata, idx);
-                    memset(newtypetagdata + idx, 0, inc);
-                }
-            }
-        }
-    }
-    a->length = newnrows;
-    a->nrows = newnrows;
-    a->data = newdata;
-    if (jl_is_array_zeroinit(a)) {
-        memset(newdata + idx * elsz, 0, nbinc);
-    }
-    if (newtypetagdata) {
-        memset(newtypetagdata + idx, 0, inc);
-    }
-}
-
-STATIC_INLINE void jl_array_grow_at_end(jl_array_t *a, size_t idx,
-                                        size_t inc, size_t n)
-{
-    // optimized for the case of only growing and shrinking at the end
-    if (__unlikely(a->flags.isshared)) {
-        if (a->flags.how != 3)
-            jl_error("cannot resize array with shared data");
-        if (inc == 0) {
-            // If inc > 0, it will always trigger the slow path and unshare the
-            // buffer
-            array_try_unshare(a);
-            return;
-        }
+    if (!isbitsunion && elsz == 0) {
+        jl_genericmemory_t *newmem = jl_alloc_genericmemory(mtype, MAXINTVAL - 1);
+        a->ref.mem = newmem;
+        jl_gc_wb(a, newmem);
+        a->dimsize[0] = newnrows;
+        return;
     }
-    size_t elsz = a->elsize;
-    char *data = (char*)a->data;
-    char *typetagdata;
-    char *newtypetagdata;
-    int isbitsunion = jl_array_isbitsunion(a);
-    if (isbitsunion) typetagdata = jl_array_typetagdata(a);
-    int has_gap = n > idx;
-    size_t reqmaxsize = a->offset + n + inc;
-    if (__unlikely(reqmaxsize > a->maxsize)) {
-        size_t nb1 = idx * elsz;
-        size_t nbinc = inc * elsz;
-        // grow either by our computed overallocation factor or exactly the requested size,
-        // whichever is larger
-        size_t newmaxsize = overallocation(a->maxsize);
+    size_t oldoffset = isbitsunion ? (size_t)data : (data - (char*)a->ref.mem->ptr) / elsz;
+    if (isbitsunion)
+        data = (char*)a->ref.mem->ptr + oldoffset * elsz;
+    size_t oldmaxsize = a->ref.mem->length;
+    size_t reqmaxsize = oldoffset + newnrows;
+    if (__unlikely(reqmaxsize > oldmaxsize)) {
+        size_t newmaxsize;
+        if (oldmaxsize < 4) // typical sequence: 0, // 4, // 6, 9, 13, 19, 28, 42, // 50, 60, 72, ...
+            newmaxsize = 4;
+        else if (oldmaxsize < 48)
+            newmaxsize = oldmaxsize*3/2; // grow by 50%
+        else
+            newmaxsize = oldmaxsize*6/5; // grow by 20%
         if (newmaxsize < reqmaxsize)
             newmaxsize = reqmaxsize;
-        size_t oldmaxsize = a->maxsize;
-        int newbuf = array_resize_buffer(a, newmaxsize);
-        char *newdata = (char*)a->data + a->offset * elsz;
-        if (isbitsunion) newtypetagdata = newdata + (a->maxsize - a->offset) * elsz + a->offset;
-        if (newbuf) {
-            memcpy(newdata, data, nb1);
-            if (isbitsunion) {
-                memcpy(newtypetagdata, typetagdata, idx);
-                if (has_gap) memcpy(newtypetagdata + idx + inc, typetagdata + idx, n - idx);
-                memset(newtypetagdata + idx, 0, inc);
-            }
-            if (has_gap) memcpy(newdata + nb1 + nbinc, data + nb1, n * elsz - nb1);
-        }
-        else {
-            if (isbitsunion) {
-                typetagdata = newdata + (oldmaxsize - a->offset) * elsz + a->offset;
-                if (has_gap) memmove(newtypetagdata + idx + inc, typetagdata + idx, n - idx);
-                memmove(newtypetagdata, typetagdata, idx);
-                memset(newtypetagdata + idx, 0, inc);
-            }
-            if (has_gap) memmove_safe(a->flags.hasptr, newdata + nb1 + nbinc, newdata + nb1, n * elsz - nb1);
-        }
-        a->data = data = newdata;
-    }
-    else if (has_gap) {
+        // TODO: round this up to newmaxsize < GC_MAX_SZCLASS ? jl_gc_sizeclasses[jl_gc_szclass(newmaxsize)] : LLT_ALIGN(newmaxsize, 4096), after accounting for the object header (24 bytes)
+        jl_genericmemory_t *newmem = jl_alloc_genericmemory(mtype, newmaxsize);
+        char *newdata = (char*)newmem->ptr + oldoffset * elsz;
+        memcpy(newdata, data, n * elsz);
         if (isbitsunion) {
-            memmove(typetagdata + idx + inc, typetagdata + idx, n - idx);
-            memset(typetagdata + idx, 0, inc);
+            char *typetagdata = jl_array_typetagdata(a);
+            char *newtypetagdata = (char*)newmem->ptr + newmaxsize * elsz + oldoffset;
+            memcpy(newtypetagdata, typetagdata, n);
         }
-        size_t nb1 = idx * elsz;
-        memmove_safe(a->flags.hasptr, data + nb1 + inc * elsz, data + nb1, n * elsz - nb1);
-    }
-    else {
-        // there was enough room for requested growth already in a->maxsize
+        a->ref.mem = newmem;
+        jl_gc_wb(a, newmem);
         if (isbitsunion)
-            memset(typetagdata + idx, 0, inc);
-    }
-    size_t newnrows = n + inc;
-    a->length = newnrows;
-    a->nrows = newnrows;
-    if (jl_is_array_zeroinit(a)) {
-        memset(data + idx * elsz, 0, inc * elsz);
+            a->ref.ptr_or_offset = (void*)oldoffset;
+        else
+            a->ref.ptr_or_offset = newdata;
     }
+    a->dimsize[0] = newnrows;
 }
 
-JL_DLLEXPORT void jl_array_grow_at(jl_array_t *a, ssize_t idx, size_t inc)
-{
-    // No need to explicitly unshare.
-    // Shared arrays are guaranteed to trigger the slow path for growing.
-    size_t n = jl_array_nrows(a);
-    if (idx < 0 || idx > n)
-        jl_bounds_error_int((jl_value_t*)a, idx + 1);
-    if (idx + 1 < n / 2) {
-        jl_array_grow_at_beg(a, idx, inc, n);
-    }
-    else {
-        jl_array_grow_at_end(a, idx, inc, n);
-    }
-}
-
-JL_DLLEXPORT void jl_array_grow_end(jl_array_t *a, size_t inc)
-{
-    size_t n = jl_array_nrows(a);
-    jl_array_grow_at_end(a, n, inc, n);
-}
-
-JL_DLLEXPORT void jl_array_grow_beg(jl_array_t *a, size_t inc)
-{
-    size_t n = jl_array_nrows(a);
-    jl_array_grow_at_beg(a, 0, inc, n);
-}
-
-STATIC_INLINE void jl_array_shrink(jl_array_t *a, size_t dec)
-{
-    //if we don't manage this array return
-    if (a->flags.how == 0) return;
-
-    size_t elsz = a->elsize;
-    size_t newbytes = (a->maxsize - dec) * a->elsize;
-    size_t oldnbytes = (a->maxsize) * a->elsize;
-    int isbitsunion = jl_array_isbitsunion(a);
-    if (isbitsunion) {
-        newbytes += a->maxsize - dec;
-        oldnbytes += a->maxsize;
-    }
-
-    if (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1 && !isbitsunion) {
-        newbytes++;
-        oldnbytes++;
-    }
-    char *originalptr = ((char*) a->data) - a->offset * a->elsize;
-    if (a->flags.how == 1) {
-        //this is a julia-allocated buffer that needs to be marked
-        char *typetagdata;
-        char *newtypetagdata;
-        if (isbitsunion) {
-            typetagdata = (char*)malloc_s(a->nrows);
-            memcpy(typetagdata, jl_array_typetagdata(a), a->nrows);
-        }
-        jl_task_t *ct = jl_current_task;
-        char *originaldata = (char*) a->data - a->offset * a->elsize;
-        char *newdata = (char*)jl_gc_alloc_buf(ct->ptls, newbytes);
-        jl_gc_wb_buf(a, newdata, newbytes);
-        a->maxsize -= dec;
-        if (isbitsunion) {
-            newtypetagdata = jl_array_typetagdata(a);
-            memcpy(newtypetagdata, typetagdata, a->nrows);
-            free(typetagdata);
-        }
-        memcpy(newdata, originaldata, newbytes);
-        a->data = newdata + a->offset * elsz;
-    }
-    else if (a->flags.how == 2) {
-        //malloc-allocated pointer this array object manages
-        char *typetagdata;
-        char *newtypetagdata;
-        if (isbitsunion) {
-            typetagdata = (char*)malloc_s(a->nrows);
-            memcpy(typetagdata, jl_array_typetagdata(a), a->nrows);
-        }
-        size_t oldoffsnb = a->offset * elsz;
-        a->data = ((char*)jl_gc_managed_realloc(originalptr, newbytes, oldnbytes,
-                a->flags.isaligned, (jl_value_t*) a)) + oldoffsnb;
-        a->maxsize -= dec;
-        if (isbitsunion) {
-            newtypetagdata = jl_array_typetagdata(a);
-            memcpy(newtypetagdata, typetagdata, a->nrows);
-            free(typetagdata);
-        }
-    }
-    else if (a->flags.how == 3) {
-        //this has has a pointer to the object that owns the data
-    }
-}
-
-static size_t jl_array_limit_offset(jl_array_t *a, size_t offset)
-{
-    // make sure offset doesn't grow forever due to deleting at beginning
-    // and growing at end
-    if (offset >= 13 * a->maxsize / 20)
-        offset = 17 * (a->maxsize - a->nrows) / 100;
-#ifdef _P64
-    while (offset > (size_t)UINT32_MAX) {
-        offset /= 2;
-    }
-#endif
-    return offset;
-}
-
-STATIC_INLINE void jl_array_del_at_beg(jl_array_t *a, size_t idx, size_t dec,
-                                       size_t n)
-{
-    // no error checking
-    // assume inbounds, assume unshared
-    size_t elsz = a->elsize;
-    size_t offset = a->offset;
-    int isbitsunion = jl_array_isbitsunion(a);
-    offset += dec;
-    a->length = n - dec;
-    a->nrows = n - dec;
-    size_t newoffs = jl_array_limit_offset(a, offset);
-    assert(newoffs <= offset);
-    size_t nbdec = dec * elsz;
-    if (__unlikely(newoffs != offset) || idx > 0) {
-        char *olddata = (char*)a->data;
-        char *newdata = olddata - (a->offset - newoffs) * elsz;
-        char *typetagdata = NULL;
-        char *newtypetagdata = NULL;
-        if (isbitsunion) {
-            typetagdata = jl_array_typetagdata(a);
-            newtypetagdata = typetagdata - (a->offset - newoffs);
-        }
-
-        size_t nb1 = idx * elsz; // size in bytes of the first block
-        size_t nbtotal = a->nrows * elsz; // size in bytes of the new array
-        // Implicit '\0' for byte arrays
-        if (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1 && !isbitsunion)
-            nbtotal++;
-        if (idx > 0) {
-            memmove_safe(a->flags.hasptr, newdata, olddata, nb1);
-            if (isbitsunion) memmove(newtypetagdata, typetagdata, idx);
-        }
-        // Move the rest of the data if the offset changed
-        if (newoffs != offset) {
-            memmove_safe(a->flags.hasptr, newdata + nb1, olddata + nb1 + nbdec, nbtotal - nb1);
-            if (isbitsunion) memmove(newtypetagdata + idx, typetagdata + idx + dec, a->nrows - idx);
-        }
-        a->data = newdata;
-    }
-    else {
-        char *data = (char*)a->data;
-        a->data = data + nbdec;
-    }
-    a->offset = newoffs;
-}
-
-STATIC_INLINE void jl_array_del_at_end(jl_array_t *a, size_t idx, size_t dec,
-                                       size_t n)
+JL_DLLEXPORT void jl_array_del_end(jl_array_t *a, size_t dec)
 {
-    // no error checking
     // assume inbounds, assume unshared
-    char *data = (char*)a->data;
-    size_t elsz = a->elsize;
-    int isbitsunion = jl_array_isbitsunion(a);
-    size_t last = idx + dec;
-    if (n > last) {
-        memmove_safe(a->flags.hasptr, data + idx * elsz, data + last * elsz, (n - last) * elsz);
-        if (isbitsunion) {
-            char *typetagdata = jl_array_typetagdata(a);
-            memmove(typetagdata + idx, typetagdata + last, n - last);
-        }
-    }
-    n -= dec;
-    if (JL_ARRAY_MEMDEBUG_TERMINATOR && elsz == 1 && !isbitsunion) {
-        data[n] = 0xfe;
-        msan_allocated_memory(&data[n], 1);
-    }
-    a->nrows = n;
-    a->length = n;
-}
-
-JL_DLLEXPORT void jl_array_del_at(jl_array_t *a, ssize_t idx, size_t dec)
-{
     size_t n = jl_array_nrows(a);
-    size_t last = idx + dec;
-    if (__unlikely(idx < 0))
-        jl_bounds_error_int((jl_value_t*)a, idx + 1);
-    if (__unlikely(last > n))
-        jl_bounds_error_int((jl_value_t*)a, last);
-    // The unsharing needs to happen before we modify the buffer
-    if (__unlikely(a->flags.isshared))
-        array_try_unshare(a);
-    if (idx < n - last) {
-        jl_array_del_at_beg(a, idx, dec, n);
-    }
-    else {
-        jl_array_del_at_end(a, idx, dec, n);
-    }
-}
-
-JL_DLLEXPORT void jl_array_del_beg(jl_array_t *a, size_t dec)
-{
-    size_t n = jl_array_nrows(a);
-    if (__unlikely(dec > n))
-        jl_bounds_error_int((jl_value_t*)a, dec);
-    if (__unlikely(a->flags.isshared))
-        array_try_unshare(a);
-    if (dec == 0)
+    if (__unlikely(n < dec))
+        jl_bounds_error_int((jl_value_t*)a, 0);
+    if (__unlikely(dec == 0))
         return;
-    jl_array_del_at_beg(a, 0, dec, n);
+    n -= dec;
+    a->dimsize[0] = n;
+    // don't leave behind deleted data
+    if (jl_is_genericmemory_zeroinit(a->ref.mem) && !jl_genericmemory_isbitsunion(a->ref.mem)) {
+        size_t elsz = jl_array_elsize(a);
+        memset(jl_array_data(a,char) + n * elsz, 0, elsz * dec);
+    }
 }
 
-JL_DLLEXPORT void jl_array_del_end(jl_array_t *a, size_t dec)
+JL_DLLEXPORT void jl_array_ptr_1d_push(jl_array_t *a, jl_value_t *item)
 {
+    assert(jl_typetagis(a, jl_array_any_type));
+    jl_array_grow_end(a, 1);
     size_t n = jl_array_nrows(a);
-    if (__unlikely(n < dec))
-        jl_bounds_error_int((jl_value_t*)a, 0);
-    if (__unlikely(a->flags.isshared))
-        array_try_unshare(a);
-    if (dec == 0)
-        return;
-    jl_array_del_at_end(a, n - dec, dec, n);
+    jl_array_ptr_set(a, n - 1, item);
 }
 
-JL_DLLEXPORT void jl_array_sizehint(jl_array_t *a, size_t sz)
+JL_DLLEXPORT void jl_array_ptr_1d_append(jl_array_t *a, jl_array_t *a2)
 {
+    assert(jl_typetagis(a, jl_array_any_type));
+    assert(jl_typetagis(a2, jl_array_any_type));
+    size_t i;
     size_t n = jl_array_nrows(a);
-
-    size_t min = a->offset + a->length;
-    sz = (sz < min) ? min : sz;
-
-    if (sz <= a->maxsize) {
-        size_t dec = a->maxsize - sz;
-        //if we don't save at least an eighth of maxsize then its not worth it to shrink
-        if (dec <= a->maxsize / 8) return;
-        jl_array_shrink(a, dec);
-    }
-    else {
-        size_t inc = sz - n;
-        jl_array_grow_end(a, inc);
-
-        a->nrows = n;
-        a->length = n;
+    size_t n2 = jl_array_nrows(a2);
+    jl_array_grow_end(a, n2);
+    for (i = 0; i < n2; i++) {
+        jl_array_ptr_set(a, n + i, jl_array_ptr_ref(a2, i));
     }
 }
 
+JL_DLLEXPORT jl_genericmemory_t *jl_genericmemory_copy_slice(jl_genericmemory_t *mem, void *data, size_t len);
+
 JL_DLLEXPORT jl_array_t *jl_array_copy(jl_array_t *ary)
 {
-    size_t elsz = ary->elsize;
     size_t len = jl_array_len(ary);
-    int isunion = jl_is_uniontype(jl_tparam0(jl_typeof(ary)));
-    jl_array_t *new_ary = _new_array_(jl_typeof(ary), jl_array_ndims(ary),
-                                      &ary->nrows, !ary->flags.ptrarray,
-                                      ary->flags.hasptr, isunion, 0, elsz);
-    memcpy(new_ary->data, ary->data, len * elsz);
-    // ensure isbits union arrays copy their selector bytes correctly
-    if (jl_array_isbitsunion(ary))
-        memcpy(jl_array_typetagdata(new_ary), jl_array_typetagdata(ary), len);
+    jl_genericmemory_t *mem = jl_genericmemory_copy_slice(ary->ref.mem, ary->ref.ptr_or_offset, len);
+    JL_GC_PUSH1(&mem);
+    jl_array_t *new_ary = _new_array((jl_value_t*)jl_typetagof(ary), mem, ((jl_datatype_t*)jl_typetagof(ary->ref.mem))->layout, jl_array_ndims(ary), &ary->dimsize[0]);
+    JL_GC_POP();
     return new_ary;
 }
 
-// Copy element by element until we hit a young object, at which point
-// we can finish by using `memmove`.
-static NOINLINE ssize_t jl_array_ptr_copy_forward(jl_value_t *owner,
-                                                  void **src_p, void **dest_p,
-                                                  ssize_t n) JL_NOTSAFEPOINT
+JL_DLLEXPORT jl_value_t *jl_alloc_string(size_t len)
 {
-    _Atomic(void*) *src_pa = (_Atomic(void*)*)src_p;
-    _Atomic(void*) *dest_pa = (_Atomic(void*)*)dest_p;
-    for (ssize_t i = 0; i < n; i++) {
-        void *val = jl_atomic_load_relaxed(src_pa + i);
-        jl_atomic_store_release(dest_pa + i, val);
-        // `val` is young or old-unmarked
-        if (val && !(jl_astaggedvalue(val)->bits.gc & GC_MARKED)) {
-            jl_gc_queue_root(owner);
-            return i;
-        }
+    if (len == 0)
+        return jl_an_empty_string;
+    size_t sz = sizeof(size_t) + len + 1; // add space for trailing \nul protector and size
+    if (sz < len) // overflow
+        jl_throw(jl_memory_exception);
+    jl_task_t *ct = jl_current_task;
+    jl_value_t *s;
+    jl_ptls_t ptls = ct->ptls;
+    const size_t allocsz = sz + sizeof(jl_taggedvalue_t);
+    if (sz <= GC_MAX_SZCLASS) {
+        int pool_id = jl_gc_szclass_align8(allocsz);
+        jl_gc_pool_t *p = &ptls->heap.norm_pools[pool_id];
+        int osize = jl_gc_sizeclasses[pool_id];
+        // We call `jl_gc_pool_alloc_noinline` instead of `jl_gc_pool_alloc` to avoid double-counting in
+        // the Allocations Profiler. (See https://github.com/JuliaLang/julia/pull/43868 for more details.)
+        s = jl_gc_pool_alloc_noinline(ptls, (char*)p - (char*)ptls, osize);
     }
-    return n;
-}
-
-static NOINLINE ssize_t jl_array_ptr_copy_backward(jl_value_t *owner,
-                                                   void **src_p, void **dest_p,
-                                                   ssize_t n) JL_NOTSAFEPOINT
-{
-    _Atomic(void*) *src_pa = (_Atomic(void*)*)src_p;
-    _Atomic(void*) *dest_pa = (_Atomic(void*)*)dest_p;
-    for (ssize_t i = 0; i < n; i++) {
-        void *val = jl_atomic_load_relaxed(src_pa + n - i - 1);
-        jl_atomic_store_release(dest_pa + n - i - 1, val);
-        // `val` is young or old-unmarked
-        if (val && !(jl_astaggedvalue(val)->bits.gc & GC_MARKED)) {
-            jl_gc_queue_root(owner);
-            return i;
-        }
+    else {
+        if (allocsz < sz) // overflow in adding offs, size was "negative"
+            jl_throw(jl_memory_exception);
+        s = jl_gc_big_alloc_noinline(ptls, allocsz);
     }
-    return n;
+    jl_set_typetagof(s, jl_string_tag, 0);
+    maybe_record_alloc_to_profile(s, len, jl_string_type);
+    *(size_t*)s = len;
+    jl_string_data(s)[len] = 0;
+    return s;
 }
 
-// Unsafe, assume inbounds and that dest and src have the same eltype
-JL_DLLEXPORT void jl_array_ptr_copy(jl_array_t *dest, void **dest_p,
-                                    jl_array_t *src, void **src_p, ssize_t n) JL_NOTSAFEPOINT
+JL_DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len)
 {
-    assert(dest->flags.ptrarray && src->flags.ptrarray);
-    jl_value_t *owner = jl_array_owner(dest);
-    // Destination is old and doesn't refer to any young object
-    if (__unlikely(jl_astaggedvalue(owner)->bits.gc == GC_OLD_MARKED)) {
-        jl_value_t *src_owner = jl_array_owner(src);
-        // Source is young or being promoted or might refer to young objects
-        // (i.e. source is not an old object that doesn't have wb triggered)
-        if (jl_astaggedvalue(src_owner)->bits.gc != GC_OLD_MARKED) {
-            ssize_t done;
-            if (dest_p < src_p || dest_p > src_p + n) {
-                done = jl_array_ptr_copy_forward(owner, src_p, dest_p, n);
-                dest_p += done;
-                src_p += done;
-            }
-            else {
-                done = jl_array_ptr_copy_backward(owner, src_p, dest_p, n);
-            }
-            n -= done;
-        }
-    }
-    memmove_refs(dest_p, src_p, n);
+    jl_value_t *s = jl_alloc_string(len);
+    if (len > 0)
+        memcpy(jl_string_data(s), str, len);
+    return s;
 }
 
-JL_DLLEXPORT void jl_array_ptr_1d_push(jl_array_t *a, jl_value_t *item)
+JL_DLLEXPORT jl_value_t *jl_cstr_to_string(const char *str)
 {
-    assert(jl_typetagis(a, jl_array_any_type));
-    jl_array_grow_end(a, 1);
-    size_t n = jl_array_nrows(a);
-    jl_array_ptr_set(a, n - 1, item);
+    return jl_pchar_to_string(str, strlen(str));
 }
 
-JL_DLLEXPORT void jl_array_ptr_1d_append(jl_array_t *a, jl_array_t *a2)
-{
-    assert(jl_typetagis(a, jl_array_any_type));
-    assert(jl_typetagis(a2, jl_array_any_type));
-    size_t i;
-    size_t n = jl_array_nrows(a);
-    size_t n2 = jl_array_nrows(a2);
-    jl_array_grow_end(a, n2);
-    for (i = 0; i < n2; i++) {
-        jl_array_ptr_set(a, n + i, jl_array_ptr_ref(a2, i));
-    }
-}
 
-JL_DLLEXPORT jl_value_t *(jl_array_data_owner)(jl_array_t *a) JL_NOTSAFEPOINT
+// deprecated and unused internally, but some packages (notably OrderedCollections.jl) have not yet started to use the modern Base.unsetindex API
+JL_DLLEXPORT void jl_arrayunset(jl_array_t *a, size_t i)
 {
-    return jl_array_data_owner(a);
+    if (i >= jl_array_len(a))
+        jl_bounds_error_int((jl_value_t*)a, i + 1);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(a->ref.mem))->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        jl_atomic_store_relaxed(jl_array_data(a,_Atomic(jl_value_t*)) + i, NULL);
+    }
+    else if (layout->first_ptr >= 0) {
+        size_t elsize = layout->size;
+        jl_assume(elsize >= sizeof(void*) && elsize % sizeof(void*) == 0);
+        memset(jl_array_data(a,char) + elsize * i, 0, elsize);
+    }
 }
 
 #ifdef __cplusplus
diff --git a/src/ast.c b/src/ast.c
index 600b1a229ea80..89ee3f70bf2fd 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -650,9 +650,9 @@ static value_t julia_to_scm(fl_context_t *fl_ctx, jl_value_t *v)
 static void array_to_list(fl_context_t *fl_ctx, jl_array_t *a, value_t *pv, int check_valid)
 {
     value_t temp;
-    for(long i=jl_array_len(a)-1; i >= 0; i--) {
+    for (long i = jl_array_nrows(a) - 1; i >= 0; i--) {
         *pv = fl_cons(fl_ctx, fl_ctx->NIL, *pv);
-        temp = julia_to_scm_(fl_ctx, jl_array_ptr_ref(a,i), check_valid);
+        temp = julia_to_scm_(fl_ctx, jl_array_ptr_ref(a, i), check_valid);
         // note: must be separate statement
         car_(*pv) = temp;
     }
@@ -880,7 +880,7 @@ JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
         JL_GC_PUSH2(&new_ci, &new_code);
         new_ci = jl_copy_code_info(new_ci);
         new_code = jl_array_copy(new_ci->code);
-        size_t clen = jl_array_len(new_code);
+        size_t clen = jl_array_nrows(new_code);
         for (int i = 0; i < clen; ++i) {
             jl_array_ptr_set(new_code, i, jl_copy_ast(
                 jl_array_ptr_ref(new_code, i)
@@ -913,7 +913,7 @@ JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
     }
     if (jl_is_expr(expr)) {
         jl_expr_t *e = (jl_expr_t*)expr;
-        size_t i, l = jl_array_len(e->args);
+        size_t i, l = jl_array_nrows(e->args);
         jl_expr_t *ne = jl_exprn(e->head, l);
         JL_GC_PUSH2(&ne, &expr);
         for (i = 0; i < l; i++) {
@@ -991,11 +991,11 @@ JL_DLLEXPORT int jl_operator_precedence(char *sym)
 
 int jl_has_meta(jl_array_t *body, jl_sym_t *sym) JL_NOTSAFEPOINT
 {
-    size_t i, l = jl_array_len(body);
+    size_t i, l = jl_array_nrows(body);
     for (i = 0; i < l; i++) {
         jl_expr_t *stmt = (jl_expr_t*)jl_array_ptr_ref(body, i);
         if (jl_is_expr((jl_value_t*)stmt) && stmt->head == jl_meta_sym) {
-            size_t i, l = jl_array_len(stmt->args);
+            size_t i, l = jl_array_nrows(stmt->args);
             for (i = 0; i < l; i++)
                 if (jl_array_ptr_ref(stmt->args, i) == (jl_value_t*)sym)
                     return 1;
@@ -1060,7 +1060,7 @@ static jl_value_t *jl_invoke_julia_macro(jl_array_t *args, jl_module_t *inmodule
 {
     jl_task_t *ct = jl_current_task;
     JL_TIMING(MACRO_INVOCATION, MACRO_INVOCATION);
-    size_t nargs = jl_array_len(args) + 1;
+    size_t nargs = jl_array_nrows(args) + 1;
     JL_NARGSV("macrocall", 3); // macro name, location, and module
     jl_value_t **margs;
     JL_GC_PUSHARGS(margs, nargs);
@@ -1199,7 +1199,7 @@ static jl_value_t *jl_expand_macros(jl_value_t *expr, jl_module_t *inmodule, str
     }
 
     size_t i;
-    for (i = 0; i < jl_array_len(e->args); i++) {
+    for (i = 0; i < jl_array_nrows(e->args); i++) {
         jl_value_t *a = jl_array_ptr_ref(e->args, i);
         jl_value_t *a2 = jl_expand_macros(a, inmodule, macroctx, onelevel, world, throw_load_error);
         if (a != a2)
diff --git a/src/builtin_proto.h b/src/builtin_proto.h
index 64e3fbd1af366..e6e91207b2fdb 100644
--- a/src/builtin_proto.h
+++ b/src/builtin_proto.h
@@ -25,14 +25,15 @@ DECLARE_BUILTIN(applicable);
 DECLARE_BUILTIN(_apply_iterate);
 DECLARE_BUILTIN(_apply_pure);
 DECLARE_BUILTIN(apply_type);
-DECLARE_BUILTIN(arrayref);
-DECLARE_BUILTIN(arrayset);
-DECLARE_BUILTIN(arraysize);
+DECLARE_BUILTIN(memoryref);
+DECLARE_BUILTIN(memoryrefoffset);
+DECLARE_BUILTIN(memoryrefget);
+DECLARE_BUILTIN(memoryrefset);
+DECLARE_BUILTIN(memoryref_isassigned);
 DECLARE_BUILTIN(_call_in_world);
 DECLARE_BUILTIN(_call_in_world_total);
 DECLARE_BUILTIN(_call_latest);
 DECLARE_BUILTIN(replacefield);
-DECLARE_BUILTIN(const_arrayref);
 DECLARE_BUILTIN(_expr);
 DECLARE_BUILTIN(fieldtype);
 DECLARE_BUILTIN(getfield);
diff --git a/src/builtins.c b/src/builtins.c
index 295c71ccdd23b..70899e4d4853a 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -115,7 +115,7 @@ static int NOINLINE compare_fields(const jl_value_t *a, const jl_value_t *b, jl_
                     continue; // skip this field (it is #undef)
                 }
             }
-            if (!ft->layout->haspadding) {
+            if (!ft->layout->flags.haspadding) {
                 if (!bits_equal(ao, bo, ft->layout->size))
                     return 0;
             }
@@ -284,7 +284,7 @@ inline int jl_egal__bits(const jl_value_t *a JL_MAYBE_UNROOTED, const jl_value_t
     if (sz == 0)
         return 1;
     size_t nf = jl_datatype_nfields(dt);
-    if (nf == 0 || !dt->layout->haspadding)
+    if (nf == 0 || !dt->layout->flags.haspadding)
         return bits_equal(a, b, sz);
     return compare_fields(a, b, dt);
 }
@@ -391,7 +391,7 @@ static uintptr_t immut_id_(jl_datatype_t *dt, jl_value_t *v, uintptr_t h) JL_NOT
     if (sz == 0)
         return ~h;
     size_t f, nf = jl_datatype_nfields(dt);
-    if (nf == 0 || (!dt->layout->haspadding && dt->layout->npointers == 0)) {
+    if (nf == 0 || (!dt->layout->flags.haspadding && dt->layout->npointers == 0)) {
         // operate element-wise if there are unused bits inside,
         // otherwise just take the whole data block at once
         // a few select pointers (notably symbol) also have special hash values
@@ -511,21 +511,18 @@ JL_CALLABLE(jl_f_sizeof)
     }
     if (jl_is_datatype(x)) {
         jl_datatype_t *dx = (jl_datatype_t*)x;
-        if (dx->layout == NULL) {
+        if (!jl_struct_try_layout(dx)) {
             if (dx->name->abstract)
                 jl_errorf("Abstract type %s does not have a definite size.", jl_symbol_name(dx->name->name));
             else
                 jl_errorf("Argument is an incomplete %s type and does not have a definite size.", jl_symbol_name(dx->name->name));
         }
-        if (jl_is_layout_opaque(dx->layout))
+        if (jl_is_layout_opaque(dx->layout)) // includes all GenericMemory{kind,T}
             jl_errorf("Type %s does not have a definite size.", jl_symbol_name(dx->name->name));
         return jl_box_long(jl_datatype_size(x));
     }
     if (x == jl_bottom_type)
         jl_error("The empty type does not have a definite size since it does not have instances.");
-    if (jl_is_array(x)) {
-        return jl_box_long(jl_array_len(x) * ((jl_array_t*)x)->elsize);
-    }
     if (jl_is_string(x))
         return jl_box_long(jl_string_len(x));
     if (jl_is_symbol(x))
@@ -535,7 +532,10 @@ JL_CALLABLE(jl_f_sizeof)
     jl_datatype_t *dt = (jl_datatype_t*)jl_typeof(x);
     assert(jl_is_datatype(dt));
     assert(!dt->name->abstract);
-    return jl_box_long(jl_datatype_size(dt));
+    size_t sz = dt->layout->size;
+    if (jl_is_genericmemory(x))
+        sz = (sz + (dt->layout->flags.arrayelem_isunion ? 1 : 0)) * ((jl_genericmemory_t*)x)->length;
+    return jl_box_long(sz);
 }
 
 JL_CALLABLE(jl_f_issubtype)
@@ -607,6 +607,12 @@ STATIC_INLINE void _grow_to(jl_value_t **root, jl_value_t ***oldargs, jl_svec_t
     *n_alloc = newalloc;
 }
 
+
+static jl_value_t *jl_arrayref(jl_array_t *a, size_t i)
+{
+    return jl_memoryrefget(jl_memoryrefindex(a->ref, i));
+}
+
 static jl_value_t *do_apply(jl_value_t **args, uint32_t nargs, jl_value_t *iterate)
 {
     jl_function_t *f = args[0];
@@ -615,6 +621,17 @@ static jl_value_t *do_apply(jl_value_t **args, uint32_t nargs, jl_value_t *itera
         if (f == jl_builtin_svec) {
             if (jl_is_svec(args[1]))
                 return args[1];
+            if (jl_is_genericmemory(args[1])) {
+                jl_genericmemory_t *mem = (jl_genericmemory_t*)args[1];
+                size_t n = mem->length;
+                jl_svec_t *t = jl_alloc_svec(n);
+                JL_GC_PUSH1(&t);
+                for (size_t i = 0; i < n; i++) {
+                    jl_svecset(t, i, jl_genericmemoryref(mem, i));
+                }
+                JL_GC_POP();
+                return (jl_value_t*)t;
+            }
             if (jl_is_array(args[1])) {
                 size_t n = jl_array_len(args[1]);
                 jl_svec_t *t = jl_alloc_svec(n);
@@ -641,6 +658,9 @@ static jl_value_t *do_apply(jl_value_t **args, uint32_t nargs, jl_value_t *itera
         else if (jl_is_tuple(args[i]) || jl_is_namedtuple(args[i])) {
             precount += jl_nfields(args[i]);
         }
+        else if (jl_is_genericmemory(args[i])) {
+            precount += ((jl_genericmemory_t*)args[i])->length;
+        }
         else if (jl_is_array(args[i])) {
             precount += jl_array_len(args[i]);
         }
@@ -709,13 +729,40 @@ static jl_value_t *do_apply(jl_value_t **args, uint32_t nargs, jl_value_t *itera
                     jl_gc_wb(arg_heap, newargs[n - 1]);
             }
         }
+        else if (jl_is_genericmemory(ai)) {
+            jl_genericmemory_t *mem = (jl_genericmemory_t*)ai;
+            size_t j, al = mem->length;
+            precount = (precount > al) ? precount - al : 0;
+            _grow_to(&roots[0], &newargs, &arg_heap, &n_alloc, n + precount + al, extra);
+            assert(newargs != NULL); // inform GCChecker that we didn't write a NULL here
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(mem))->layout;
+            if (layout->flags.arrayelem_isboxed) {
+                for (j = 0; j < al; j++) {
+                    jl_value_t *arg = jl_genericmemory_ptr_ref(mem, j);
+                    // apply with array splatting may have embedded NULL value (#11772)
+                    if (__unlikely(arg == NULL))
+                        jl_throw(jl_undefref_exception);
+                    newargs[n++] = arg;
+                    if (arg_heap)
+                        jl_gc_wb(arg_heap, arg);
+                }
+            }
+            else {
+                for (j = 0; j < al; j++) {
+                    newargs[n++] = jl_genericmemoryref(mem, j);
+                    if (arg_heap)
+                        jl_gc_wb(arg_heap, newargs[n - 1]);
+                }
+            }
+        }
         else if (jl_is_array(ai)) {
             jl_array_t *aai = (jl_array_t*)ai;
             size_t j, al = jl_array_len(aai);
             precount = (precount > al) ? precount - al : 0;
             _grow_to(&roots[0], &newargs, &arg_heap, &n_alloc, n + precount + al, extra);
             assert(newargs != NULL); // inform GCChecker that we didn't write a NULL here
-            if (aai->flags.ptrarray) {
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(aai->ref.mem))->layout;
+            if (layout->flags.arrayelem_isboxed) {
                 for (j = 0; j < al; j++) {
                     jl_value_t *arg = jl_array_ptr_ref(aai, j);
                     // apply with array splatting may have embedded NULL value (#11772)
@@ -1463,70 +1510,115 @@ JL_CALLABLE(jl_f__typevar)
     return (jl_value_t *)jl_new_typevar((jl_sym_t*)args[0], args[1], args[2]);
 }
 
-// arrays ---------------------------------------------------------------------
+// genericmemory ---------------------------------------------------------------------
 
-JL_CALLABLE(jl_f_arraysize)
+JL_CALLABLE(jl_f_memoryref)
 {
-    JL_NARGS(arraysize, 2, 2);
-    JL_TYPECHK(arraysize, array, args[0]);
-    jl_array_t *a = (jl_array_t*)args[0];
-    size_t nd = jl_array_ndims(a);
-    JL_TYPECHK(arraysize, long, args[1]);
-    int dno = jl_unbox_long(args[1]);
-    if (dno < 1)
-        jl_error("arraysize: dimension out of range");
-    if (dno > nd)
-        return jl_box_long(1);
-    return jl_box_long((&a->nrows)[dno-1]);
-}
-
-static size_t array_nd_index(jl_array_t *a, jl_value_t **args, size_t nidxs,
-                             const char *fname)
-{
-    size_t i = 0;
-    size_t k, stride = 1;
-    size_t nd = jl_array_ndims(a);
-    for (k = 0; k < nidxs; k++) {
-        if (!jl_is_long(args[k]))
-            jl_type_error(fname, (jl_value_t*)jl_long_type, args[k]);
-        size_t ii = jl_unbox_long(args[k]) - 1;
-        i += ii * stride;
-        size_t d = (k >= nd) ? 1 : jl_array_dim(a, k);
-        if (k < nidxs - 1 && ii >= d)
-            jl_bounds_error_v((jl_value_t*)a, args, nidxs);
-        stride *= d;
+    JL_NARGS(memoryref, 1, 3);
+    if (nargs == 1) {
+        JL_TYPECHK(memoryref, genericmemory, args[0]);
+        jl_genericmemory_t *m = (jl_genericmemory_t*)args[0];
+        jl_value_t *typ = jl_apply_type((jl_value_t*)jl_genericmemoryref_type, jl_svec_data(((jl_datatype_t*)jl_typetagof(m))->parameters), 3);
+        JL_GC_PROMISE_ROOTED(typ); // it is a concrete type
+        const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
+        if (layout->flags.arrayelem_isunion || layout->size == 0)
+            return (jl_value_t*)jl_new_memoryref(typ, m, 0);
+        return (jl_value_t*)jl_new_memoryref(typ, m, m->ptr);
+    }
+    else {
+        JL_TYPECHK(memoryref, genericmemoryref, args[0]);
+        JL_TYPECHK(memoryref, long, args[1]);
+        if (nargs == 3)
+            JL_TYPECHK(memoryref, bool, args[2]);
+        jl_genericmemoryref_t *m = (jl_genericmemoryref_t*)args[0];
+        size_t i = jl_unbox_long(args[1]) - 1;
+        const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m->mem))->layout;
+        char *data = (char*)m->ptr_or_offset;
+        if (layout->flags.arrayelem_isboxed) {
+            if (((data - (char*)m->mem->ptr) / sizeof(jl_value_t*)) + i >= m->mem->length)
+                jl_bounds_error((jl_value_t*)m, args[1]);
+            data += sizeof(jl_value_t*) * i;
+        }
+        else if (layout->flags.arrayelem_isunion || layout->size == 0) {
+            if ((size_t)data + i >= m->mem->length)
+                jl_bounds_error((jl_value_t*)m, args[1]);
+            data += i;
+        }
+        else {
+            if (((data - (char*)m->mem->ptr) / layout->size) + i >= m->mem->length)
+                jl_bounds_error((jl_value_t*)m, args[1]);
+            data += layout->size * i;
+        }
+        return (jl_value_t*)jl_new_memoryref((jl_value_t*)jl_typetagof(m), m->mem, data);
     }
-    for (; k < nd; k++)
-        stride *= jl_array_dim(a, k);
-    if (i >= stride)
-        jl_bounds_error_v((jl_value_t*)a, args, nidxs);
-    return i;
-}
-
-JL_CALLABLE(jl_f_arrayref)
-{
-    JL_NARGSV(arrayref, 3);
-    JL_TYPECHK(arrayref, bool, args[0]);
-    JL_TYPECHK(arrayref, array, args[1]);
-    jl_array_t *a = (jl_array_t*)args[1];
-    size_t i = array_nd_index(a, &args[2], nargs - 2, "arrayref");
-    return jl_arrayref(a, i);
 }
 
-JL_CALLABLE(jl_f_const_arrayref)
+JL_CALLABLE(jl_f_memoryrefoffset)
 {
-    return jl_f_arrayref(F, args, nargs);
+    JL_NARGS(memoryrefoffset, 1, 1);
+    JL_TYPECHK(memoryref, genericmemoryref, args[0]);
+    jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    size_t offset;
+    if (layout->flags.arrayelem_isboxed) {
+        offset = (((char*)m.ptr_or_offset - (char*)m.mem->ptr) / sizeof(jl_value_t*));
+    }
+    else if (layout->flags.arrayelem_isunion || layout->size == 0) {
+        offset = (size_t)m.ptr_or_offset;
+    }
+    else {
+        offset = ((char*)m.ptr_or_offset - (char*)m.mem->ptr) / layout->size;
+    }
+    return (jl_value_t*)jl_box_long(offset + 1);
+}
+
+JL_CALLABLE(jl_f_memoryrefget)
+{
+    JL_NARGS(memoryrefget, 3, 3);
+    JL_TYPECHK(memoryrefget, genericmemoryref, args[0]);
+    JL_TYPECHK(memoryrefget, symbol, args[1]);
+    JL_TYPECHK(memoryrefget, bool, args[2]);
+    jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
+    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem));
+    if (isatomic == jl_false)
+        if (args[1] != (jl_value_t*)jl_not_atomic_sym)
+            jl_atomic_error("memoryrefget!: non-atomic memory cannot be accessed atomically");
+    if (m.mem->length == 0)
+        jl_bounds_error_int((jl_value_t*)m.mem, 1);
+    return jl_memoryrefget(m);
+}
+
+JL_CALLABLE(jl_f_memoryrefset)
+{
+    JL_NARGS(memoryrefset!, 4, 4);
+    JL_TYPECHK(memoryrefset!, genericmemoryref, args[0]);
+    JL_TYPECHK(memoryrefset!, symbol, args[2]);
+    JL_TYPECHK(memoryrefset!, bool, args[3]);
+    jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
+    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem));
+    if (isatomic == jl_false)
+        if (args[2] != (jl_value_t*)jl_not_atomic_sym)
+            jl_atomic_error("memoryrefset!: non-atomic memory cannot be written atomically");
+    if (m.mem->length == 0)
+        jl_bounds_error_int((jl_value_t*)m.mem, 1);
+    jl_memoryrefset(m, args[1]);
+    return args[0];
 }
 
-JL_CALLABLE(jl_f_arrayset)
+JL_CALLABLE(jl_f_memoryref_isassigned)
 {
-    JL_NARGSV(arrayset, 4);
-    JL_TYPECHK(arrayset, bool, args[0]);
-    JL_TYPECHK(arrayset, array, args[1]);
-    jl_array_t *a = (jl_array_t*)args[1];
-    size_t i = array_nd_index(a, &args[3], nargs - 3, "arrayset");
-    jl_arrayset(a, args[2], i);
-    return args[1];
+    JL_NARGS(memoryref_isassigned, 3, 3);
+    JL_TYPECHK(memoryref_isassigned, genericmemoryref, args[0]);
+    JL_TYPECHK(memoryref_isassigned, symbol, args[1]);
+    JL_TYPECHK(memoryref_isassigned, bool, args[2]);
+    jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
+    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem));
+    if (isatomic == jl_false)
+        if (args[1] != (jl_value_t*)jl_not_atomic_sym)
+            jl_atomic_error("memoryref_isassigned!: non-atomic memory cannot be accessed atomically");
+    if (m.mem->length == 0)
+        return jl_false;
+    return jl_memoryref_isassigned(m);
 }
 
 // type definition ------------------------------------------------------------
@@ -1719,7 +1811,7 @@ static int references_name(jl_value_t *p, jl_typename_t *name, int affects_layou
         jl_datatype_t *dp = (jl_datatype_t*)p;
         if (affects_layout && dp->name == name)
             return 1;
-        affects_layout = ((jl_datatype_t*)jl_unwrap_unionall(dp->name->wrapper))->layout == NULL;
+        affects_layout = jl_is_genericmemory_type(dp) || ((jl_datatype_t*)jl_unwrap_unionall(dp->name->wrapper))->layout == NULL;
         // and even if it has a layout, the fields themselves might trigger layouts if they use tparam i
         // rather than checking this for each field, we just assume it applies
         if (!affects_layout && freevars && jl_field_names(dp) != jl_emptysvec) {
@@ -2024,11 +2116,12 @@ void jl_init_primitives(void) JL_GC_DISABLED
     add_builtin_func("get_binding_type", jl_f_get_binding_type);
     add_builtin_func("set_binding_type!", jl_f_set_binding_type);
 
-    // array primitives
-    jl_builtin_arrayref = add_builtin_func("arrayref", jl_f_arrayref);
-    jl_builtin_const_arrayref = add_builtin_func("const_arrayref", jl_f_arrayref);
-    jl_builtin_arrayset = add_builtin_func("arrayset", jl_f_arrayset);
-    jl_builtin_arraysize = add_builtin_func("arraysize", jl_f_arraysize);
+    // memory primitives
+    jl_builtin_memoryref = add_builtin_func("memoryref", jl_f_memoryref);
+    jl_builtin_memoryrefoffset = add_builtin_func("memoryrefoffset", jl_f_memoryrefoffset);
+    jl_builtin_memoryrefget = add_builtin_func("memoryrefget", jl_f_memoryrefget);
+    jl_builtin_memoryrefset = add_builtin_func("memoryrefset!", jl_f_memoryrefset);
+    jl_builtin_memoryref_isassigned = add_builtin_func("memoryref_isassigned", jl_f_memoryref_isassigned);
 
     // method table utils
     jl_builtin_applicable = add_builtin_func("applicable", jl_f_applicable);
@@ -2092,15 +2185,19 @@ void jl_init_primitives(void) JL_GC_DISABLED
     add_builtin("Builtin", (jl_value_t*)jl_builtin_type);
     add_builtin("MethodInstance", (jl_value_t*)jl_method_instance_type);
     add_builtin("CodeInfo", (jl_value_t*)jl_code_info_type);
-    add_builtin("Ref", (jl_value_t*)jl_ref_type);
-    add_builtin("Ptr", (jl_value_t*)jl_pointer_type);
     add_builtin("LLVMPtr", (jl_value_t*)jl_llvmpointer_type);
     add_builtin("Task", (jl_value_t*)jl_task_type);
     add_builtin("OpaqueClosure", (jl_value_t*)jl_opaque_closure_type);
 
+    add_builtin("AddrSpace", (jl_value_t*)jl_addrspace_type);
+    add_builtin("Ref", (jl_value_t*)jl_ref_type);
+    add_builtin("Ptr", (jl_value_t*)jl_pointer_type);
+    //add_builtin("GenericPtr", (jl_value_t*)jl_genericpointer_type);
     add_builtin("AbstractArray", (jl_value_t*)jl_abstractarray_type);
     add_builtin("DenseArray", (jl_value_t*)jl_densearray_type);
     add_builtin("Array", (jl_value_t*)jl_array_type);
+    add_builtin("GenericMemory", (jl_value_t*)jl_genericmemory_type);
+    add_builtin("GenericMemoryRef", (jl_value_t*)jl_genericmemoryref_type);
 
     add_builtin("Expr", (jl_value_t*)jl_expr_type);
     add_builtin("LineNumberNode", (jl_value_t*)jl_linenumbernode_type);
diff --git a/src/ccall.cpp b/src/ccall.cpp
index 9eb672e3047fb..ff7ea305c0c05 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -29,14 +29,15 @@ TRANSFORMED_CCALL_STAT(jl_sigatomic_begin);
 TRANSFORMED_CCALL_STAT(jl_sigatomic_end);
 TRANSFORMED_CCALL_STAT(jl_svec_len);
 TRANSFORMED_CCALL_STAT(jl_svec_ref);
-TRANSFORMED_CCALL_STAT(jl_array_isassigned);
 TRANSFORMED_CCALL_STAT(jl_string_ptr);
 TRANSFORMED_CCALL_STAT(jl_symbol_name);
+TRANSFORMED_CCALL_STAT(jl_genericmemory_owner);
 TRANSFORMED_CCALL_STAT(memcpy);
 TRANSFORMED_CCALL_STAT(memset);
 TRANSFORMED_CCALL_STAT(memmove);
 TRANSFORMED_CCALL_STAT(jl_object_id);
 #undef TRANSFORMED_CCALL_STAT
+extern "C" JL_DLLEXPORT jl_value_t *ijl_genericmemory_owner(jl_genericmemory_t *m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
 
 STATISTIC(EmittedCCalls, "Number of ccalls emitted");
 STATISTIC(DeferredCCallLookups, "Number of ccalls looked up at runtime");
@@ -748,7 +749,7 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
     jl_value_t *ir_arg = args[1];
     JL_GC_PUSH4(&ir, &rt, &at, &entry);
     if (jl_is_ssavalue(ir_arg))
-        ir_arg = jl_arrayref((jl_array_t*)ctx.source->code, ((jl_ssavalue_t*)ir_arg)->id - 1);
+        ir_arg = jl_array_ptr_ref((jl_array_t*)ctx.source->code, ((jl_ssavalue_t*)ir_arg)->id - 1);
     ir = static_eval(ctx, ir_arg);
     if (!ir) {
         emit_error(ctx, "error statically evaluating llvm IR argument");
@@ -756,7 +757,7 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
         return jl_cgval_t();
     }
     if (jl_is_ssavalue(args[2]) && !jl_is_long(ctx.source->ssavaluetypes)) {
-        jl_value_t *rtt = jl_arrayref((jl_array_t*)ctx.source->ssavaluetypes, ((jl_ssavalue_t*)args[2])->id - 1);
+        jl_value_t *rtt = jl_array_ptr_ref((jl_array_t*)ctx.source->ssavaluetypes, ((jl_ssavalue_t*)args[2])->id - 1);
         if (jl_is_type_type(rtt))
             rt = jl_tparam0(rtt);
     }
@@ -769,7 +770,7 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
         }
     }
     if (jl_is_ssavalue(args[3]) && !jl_is_long(ctx.source->ssavaluetypes)) {
-        jl_value_t *att = jl_arrayref((jl_array_t*)ctx.source->ssavaluetypes, ((jl_ssavalue_t*)args[3])->id - 1);
+        jl_value_t *att = jl_array_ptr_ref((jl_array_t*)ctx.source->ssavaluetypes, ((jl_ssavalue_t*)args[3])->id - 1);
         if (jl_is_type_type(att))
             at = jl_tparam0(att);
     }
@@ -913,7 +914,7 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
         }
         else {
             auto Buf = MemoryBuffer::getMemBuffer(
-                StringRef((char *)jl_array_data(ir), jl_array_len(ir)), "llvmcall",
+                StringRef(jl_array_data(ir, char), jl_array_nrows(ir)), "llvmcall",
                 /*RequiresNullTerminator*/ false);
             Expected<std::unique_ptr<Module>> ModuleOrErr =
                 parseBitcodeFile(*Buf, ctx.builder.getContext());
@@ -1141,7 +1142,8 @@ std::string generate_func_sig(const char *fname)
         }
 
         Type *pat;
-        if (!jl_is_datatype(tti) || ((jl_datatype_t*)tti)->layout == NULL || jl_is_layout_opaque(((jl_datatype_t*)tti)->layout)) {
+        // n.b. `Array` used as argument type just passes a julia object reference
+        if (!jl_is_datatype(tti) || ((jl_datatype_t*)tti)->layout == NULL || jl_is_array_type(tti) || jl_is_layout_opaque(((jl_datatype_t*)tti)->layout)) {
             tti = (jl_value_t*)jl_voidpointer_type; // passed as pointer
         }
 
@@ -1272,7 +1274,7 @@ static const std::string verify_ccall_sig(jl_value_t *&rt, jl_value_t *at,
     JL_TYPECHK(ccall, type, rt);
     JL_TYPECHK(ccall, simplevector, at);
 
-    if (rt == (jl_value_t*)jl_any_type || jl_is_array_type(rt) ||
+    if (rt == (jl_value_t*)jl_any_type || jl_is_array_type(rt) || jl_is_genericmemory_type(rt) ||
             (jl_is_datatype(rt) && ((jl_datatype_t*)rt)->layout != NULL &&
              jl_is_layout_opaque(((jl_datatype_t*)rt)->layout))) {
         // n.b. `Array` used as return type just returns a julia object reference
@@ -1350,11 +1352,6 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         return jl_cgval_t();
     }
 
-    auto ccallarg = [=] (size_t i) {
-        assert(i < nccallargs && i + fc_args_start <= nargs);
-        return args[fc_args_start + i];
-    };
-
     auto _is_libjulia_func = [&] (uintptr_t ptr, StringRef name) {
         if ((uintptr_t)fptr == ptr)
             return true;
@@ -1381,7 +1378,8 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
     SmallVector<jl_cgval_t, 4> argv(nccallargs);
     for (size_t i = 0; i < nccallargs; i++) {
         // Julia (expression) value of current parameter
-        jl_value_t *argi = ccallarg(i);
+        assert(i < nccallargs && i + fc_args_start <= nargs);
+        jl_value_t *argi = args[fc_args_start + i];
         argv[i] = emit_expr(ctx, argi);
     }
 
@@ -1459,16 +1457,7 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
     // some special functions
     bool isVa = nreqargs > 0;
     (void)isVa; // prevent compiler warning
-    if (is_libjulia_func(jl_array_ptr)) {
-        ++CCALL_STAT(jl_array_ptr);
-        assert(lrt == ctx.types().T_size);
-        assert(!isVa && !llvmcall && nccallargs == 1);
-        const jl_cgval_t &ary = argv[0];
-        JL_GC_POP();
-        return mark_or_box_ccall_result(ctx, ctx.builder.CreatePtrToInt(emit_unsafe_arrayptr(ctx, ary), lrt),
-                                        retboxed, rt, unionall, static_rt);
-    }
-    else if (is_libjulia_func(jl_value_ptr)) {
+    if (is_libjulia_func(jl_value_ptr)) {
         ++CCALL_STAT(jl_value_ptr);
         assert(retboxed ? lrt == ctx.types().T_prjlvalue : lrt == ctx.types().T_size);
         assert(!isVa && !llvmcall && nccallargs == 1);
@@ -1744,47 +1733,6 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         JL_GC_POP();
         return mark_or_box_ccall_result(ctx, load, retboxed, rt, unionall, static_rt);
     }
-    else if (is_libjulia_func(jl_array_isassigned) &&
-             argv[1].typ == (jl_value_t*)jl_ulong_type) {
-        ++CCALL_STAT(jl_array_isassigned);
-        assert(!isVa && !llvmcall && nccallargs == 2);
-        jl_value_t *aryex = ccallarg(0);
-        const jl_cgval_t &aryv = argv[0];
-        const jl_cgval_t &idxv = argv[1];
-        jl_datatype_t *arydt = (jl_datatype_t*)jl_unwrap_unionall(aryv.typ);
-        if (jl_is_array_type(arydt)) {
-            jl_value_t *ety = jl_tparam0(arydt);
-            bool ptrarray = !jl_stored_inline(ety);
-            if (!ptrarray && !jl_type_hasptr(ety)) {
-                JL_GC_POP();
-                return mark_or_box_ccall_result(ctx, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 1),
-                                                false, rt, unionall, static_rt);
-            }
-            else if (!jl_has_free_typevars(ety)) {
-                Value *idx = emit_unbox(ctx, ctx.types().T_size, idxv, (jl_value_t*)jl_ulong_type);
-                Value *arrayptr = emit_bitcast(ctx, emit_arrayptr(ctx, aryv, aryex), ctx.types().T_pprjlvalue);
-                if (!ptrarray) {
-                    size_t elsz = jl_datatype_size(ety);
-                    unsigned align = jl_datatype_align(ety);
-                    size_t stride = LLT_ALIGN(elsz, align) / sizeof(jl_value_t*);
-                    if (stride != 1)
-                        idx = ctx.builder.CreateMul(idx, ConstantInt::get(ctx.types().T_size, stride));
-                    idx = ctx.builder.CreateAdd(idx, ConstantInt::get(ctx.types().T_size, ((jl_datatype_t*)ety)->layout->first_ptr));
-                    setName(ctx.emission_context, idx, "array_idx");
-                }
-                Value *slot_addr = ctx.builder.CreateInBoundsGEP(ctx.types().T_prjlvalue, arrayptr, idx);
-                setName(ctx.emission_context, slot_addr, "array_slot_addr");
-                LoadInst *load = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, slot_addr, Align(sizeof(void*)));
-                setName(ctx.emission_context, load, "array_slot");
-                load->setAtomic(AtomicOrdering::Unordered);
-                jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_ptrarraybuf);
-                ai.decorateInst(load);
-                Value *res = ctx.builder.CreateZExt(ctx.builder.CreateICmpNE(load, Constant::getNullValue(ctx.types().T_prjlvalue)), getInt32Ty(ctx.builder.getContext()));
-                JL_GC_POP();
-                return mark_or_box_ccall_result(ctx, res, retboxed, rt, unionall, static_rt);
-            }
-        }
-    }
     else if (is_libjulia_func(jl_string_ptr)) {
         ++CCALL_STAT(jl_string_ptr);
         assert(lrt == ctx.types().T_size);
@@ -1814,6 +1762,14 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         JL_GC_POP();
         return mark_or_box_ccall_result(ctx, strp, retboxed, rt, unionall, static_rt);
     }
+    else if (is_libjulia_func(jl_genericmemory_owner) || is_libjulia_func(ijl_genericmemory_owner)) {
+        ++CCALL_STAT(jl_genericmemory_owner);
+        assert(lrt == ctx.types().T_prjlvalue);
+        assert(!isVa && !llvmcall && nccallargs == 1);
+        Value *obj = emit_genericmemoryowner(ctx, boxed(ctx, argv[0]));
+        JL_GC_POP();
+        return mark_julia_type(ctx, obj, true, jl_any_type);
+    }
     else if (is_libjulia_func(memcpy) && (rt == (jl_value_t*)jl_nothing_type || jl_is_cpointer_type(rt))) {
         ++CCALL_STAT(memcpy);
         const jl_cgval_t &dst = argv[0];
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index c71c78da4c829..7590722f82826 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -28,13 +28,8 @@ STATISTIC(EmittedGetfieldKnowns, "Number of known getfield calls emitted");
 STATISTIC(EmittedSetfield, "Number of setfield calls emitted");
 STATISTIC(EmittedUnionLoads, "Number of union loads emitted");
 STATISTIC(EmittedVarargsLength, "Number of varargs length calls emitted");
-STATISTIC(EmittedArraysize, "Number of arraysize calls emitted");
-STATISTIC(EmittedArraylen, "Number of array length calls emitted");
-STATISTIC(EmittedArrayptr, "Number of array data pointer loads emitted");
-STATISTIC(EmittedArrayflags, "Number of arrayflags calls emitted");
-STATISTIC(EmittedArrayNDims, "Number of array ndims calls emitted");
+STATISTIC(EmittedArrayptr, "Number of array ptr calls emitted");
 STATISTIC(EmittedArrayElsize, "Number of array elsize calls emitted");
-STATISTIC(EmittedArrayOffset, "Number of array offset calls emitted");
 STATISTIC(EmittedArrayNdIndex, "Number of array nd index calls emitted");
 STATISTIC(EmittedBoxes, "Number of box operations emitted");
 STATISTIC(EmittedCPointerChecks, "Number of C pointer checks emitted");
@@ -130,7 +125,7 @@ static Value *stringConstPtr(
     Value *zero = ConstantInt::get(Type::getInt32Ty(irbuilder.getContext()), 0);
     Value *Args[] = { zero, zero };
     auto gep = irbuilder.CreateInBoundsGEP(gv->getValueType(),
-                                       // Addrspacecast in case globals are in non-0 AS
+                                       // AddrSpaceCast in case globals are in non-0 AS
                                        irbuilder.CreateAddrSpaceCast(gv, gv->getValueType()->getPointerTo(0)),
                                        Args);
     setName(emission_context, gep, "string_const_ptr");
@@ -213,7 +208,7 @@ static DIType *_julia_type_to_di(jl_codegen_params_t *ctx, jl_debugcache_t &debu
         uint64_t SizeInBits = jl_datatype_nbits(jdt);
         ditype = dbuilder->createBasicType(tname, SizeInBits, llvm::dwarf::DW_ATE_unsigned);
     }
-    else if (jl_is_structtype(jt) && !jl_is_layout_opaque(jdt->layout)) {
+    else if (jl_is_structtype(jt) && !jl_is_layout_opaque(jdt->layout) && !jl_is_array_type(jdt)) {
         size_t ntypes = jl_datatype_nfields(jdt);
         SmallVector<llvm::Metadata*, 0> Elements(ntypes);
         for (unsigned i = 0; i < ntypes; i++) {
@@ -459,11 +454,7 @@ static Constant *literal_pointer_val_slot(jl_codectx_t &ctx, jl_value_t *p)
 
 static size_t dereferenceable_size(jl_value_t *jt)
 {
-    if (jl_is_array_type(jt)) {
-        // Array has at least this much data
-        return sizeof(jl_array_t);
-    }
-    else if (jl_is_datatype(jt) && jl_struct_try_layout((jl_datatype_t*)jt)) {
+    if (jl_is_datatype(jt) && jl_struct_try_layout((jl_datatype_t*)jt)) {
         return jl_datatype_size(jt);
     }
     return 0;
@@ -472,10 +463,6 @@ static size_t dereferenceable_size(jl_value_t *jt)
 // Return the min required / expected alignment of jltype (on the stack or heap)
 static unsigned julia_alignment(jl_value_t *jt)
 {
-    if (jl_is_array_type(jt)) {
-        // Array always has this alignment
-        return JL_SMALL_BYTE_ALIGNMENT;
-    }
     if (jt == (jl_value_t*)jl_datatype_type) {
         // types are never allocated in julia code/on the stack
         // and this is the guarantee we have for the GC bits
@@ -710,6 +697,37 @@ static unsigned jl_field_align(jl_datatype_t *dt, size_t i)
     return std::min({al, (unsigned)jl_datatype_align(dt), (unsigned)JL_HEAP_ALIGNMENT});
 }
 
+static llvm::StructType* get_jlmemoryref(llvm::LLVMContext &C, unsigned AS) {
+    return llvm::StructType::get(C, {
+            llvm::PointerType::get(llvm::Type::getInt8Ty(C), AS),
+            JuliaType::get_prjlvalue_ty(C),
+            });
+}
+static llvm::StructType* get_jlmemoryboxedref(llvm::LLVMContext &C, unsigned AS) {
+    return llvm::StructType::get(C, {
+            llvm::PointerType::get(JuliaType::get_prjlvalue_ty(C), AS),
+            JuliaType::get_prjlvalue_ty(C),
+            });
+}
+static llvm::StructType* get_jlmemoryunionref(llvm::LLVMContext &C, llvm::Type *T_size) {
+    return llvm::StructType::get(C, {
+            T_size, // offset
+            JuliaType::get_prjlvalue_ty(C),
+            });
+}
+static StructType *get_memoryref_type(LLVMContext &ctxt, Type *T_size, const jl_datatype_layout_t *layout, unsigned AS)
+{
+    // TODO: try to remove this slightly odd special case
+    bool isboxed = layout->flags.arrayelem_isboxed;
+    bool isunion = layout->flags.arrayelem_isunion;
+    bool isghost = layout->size == 0;
+    if (isboxed)
+        return get_jlmemoryboxedref(ctxt, AS);
+    if (isunion || isghost)
+        return get_jlmemoryunionref(ctxt, T_size);
+    return get_jlmemoryref(ctxt, AS);
+}
+
 static Type *_julia_struct_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt, jl_value_t *jt, bool *isboxed, bool llvmcall)
 {
     // this function converts a Julia Type into the equivalent LLVM struct
@@ -721,7 +739,13 @@ static Type *_julia_struct_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt,
     if (jl_is_primitivetype(jt))
         return bitstype_to_llvm(jt, ctxt, llvmcall);
     jl_datatype_t *jst = (jl_datatype_t*)jt;
-    if (jl_is_structtype(jt) && !(jst->layout && jl_is_layout_opaque(jst->layout))) {
+    if (jl_is_structtype(jt) && !(jst->layout && jl_is_layout_opaque(jst->layout)) && !jl_is_array_type(jst) && !jl_is_genericmemory_type(jst)) {
+        if (jl_is_genericmemoryref_type(jst)) {
+            jl_value_t *mty_dt = jl_field_type_concrete(jst, 1);
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
+            Type *T_size = bitstype_to_llvm((jl_value_t*)jl_long_type, ctxt);
+            return get_memoryref_type(ctxt, T_size, layout, 0);
+        }
         bool isTuple = jl_is_tuple_type(jt);
         jl_svec_t *ftypes = jl_get_fieldtypes(jst);
         size_t i, ntypes = jl_svec_len(ftypes);
@@ -768,8 +792,9 @@ static Type *_julia_struct_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt,
                 // We may need to insert padding first to get to the right offset
                 size_t fsz = 0, al = 0;
                 bool isptr = !jl_islayout_inline(ty, &fsz, &al);
-                assert(!isptr && fsz == jl_field_size(jst, i) - 1); (void)isptr;
-                if (fsz > 0) {
+                assert(!isptr && fsz < jl_field_size(jst, i)); (void)isptr;
+                size_t fsz1 = jl_field_size(jst, i) - 1;
+                if (fsz1 > 0) {
                     if (al > MAX_ALIGN) {
                         Type *AlignmentType;
                         AlignmentType = ArrayType::get(FixedVectorType::get(getInt8Ty(ctxt), al), 0);
@@ -777,8 +802,8 @@ static Type *_julia_struct_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt,
                         al = MAX_ALIGN;
                     }
                     Type *AlignmentType = IntegerType::get(ctxt, 8 * al);
-                    unsigned NumATy = fsz / al;
-                    unsigned remainder = fsz % al;
+                    unsigned NumATy = fsz1 / al;
+                    unsigned remainder = fsz1 % al;
                     assert(al == 1 || NumATy > 0);
                     while (NumATy--)
                         latypes.push_back(AlignmentType);
@@ -1055,20 +1080,6 @@ static void emit_memcpy(jl_codectx_t &ctx, Value *dst, jl_aliasinfo_t const &dst
     emit_memcpy_llvm(ctx, dst, dst_ai, data_pointer(ctx, src), src_ai, sz, align_dst, align_src, is_volatile);
 }
 
-static LoadInst *emit_nthptr_recast(jl_codectx_t &ctx, Value *v, Value *idx, MDNode *tbaa, Type *type)
-{
-    // p = (jl_value_t**)v; *(type*)&p[n]
-    Value *vptr = ctx.builder.CreateInBoundsGEP(
-            ctx.types().T_prjlvalue,
-            emit_bitcast(ctx, maybe_decay_tracked(ctx, v), ctx.types().T_pprjlvalue),
-            idx);
-    setName(ctx.emission_context, vptr, "arraysize_ptr");
-    LoadInst *load = ctx.builder.CreateLoad(type, emit_bitcast(ctx, vptr, PointerType::get(type, 0)));
-    jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
-    ai.decorateInst(load);
-    return load;
-}
-
 static Value *emit_tagfrom(jl_codectx_t &ctx, jl_datatype_t *dt)
 {
     if (dt->smalltag)
@@ -1196,7 +1207,8 @@ static Value *emit_datatype_nfields(jl_codectx_t &ctx, Value *dt)
     return nfields;
 }
 
-static Value *emit_datatype_size(jl_codectx_t &ctx, Value *dt)
+// emit the size field from the layout of a dt
+static Value *emit_datatype_size(jl_codectx_t &ctx, Value *dt, bool add_isunion=false)
 {
     jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_const);
     Value *Ptr = emit_bitcast(ctx, decay_derived(ctx, dt), getInt32PtrTy(ctx.builder.getContext())->getPointerTo());
@@ -1204,9 +1216,18 @@ static Value *emit_datatype_size(jl_codectx_t &ctx, Value *dt)
     Ptr = ctx.builder.CreateInBoundsGEP(getInt32PtrTy(ctx.builder.getContext()), Ptr, Idx);
     Ptr = ai.decorateInst(ctx.builder.CreateAlignedLoad(getInt32PtrTy(ctx.builder.getContext()), Ptr, Align(sizeof(int32_t*))));
     Idx = ConstantInt::get(ctx.types().T_size, offsetof(jl_datatype_layout_t, size) / sizeof(int32_t));
-    Ptr = ctx.builder.CreateInBoundsGEP(getInt32Ty(ctx.builder.getContext()), Ptr, Idx);
-    auto Size = ai.decorateInst(ctx.builder.CreateAlignedLoad(getInt32Ty(ctx.builder.getContext()), Ptr, Align(sizeof(int32_t))));
+    Value *SizePtr = ctx.builder.CreateInBoundsGEP(getInt32Ty(ctx.builder.getContext()), Ptr, Idx);
+    Value *Size = ai.decorateInst(ctx.builder.CreateAlignedLoad(getInt32Ty(ctx.builder.getContext()), SizePtr, Align(sizeof(int32_t))));
     setName(ctx.emission_context, Size, "datatype_size");
+    if (add_isunion) {
+        Idx = ConstantInt::get(ctx.types().T_size, offsetof(jl_datatype_layout_t, flags) / sizeof(int16_t));
+        Value *FlagPtr = ctx.builder.CreateInBoundsGEP(getInt16Ty(ctx.builder.getContext()), emit_bitcast(ctx, Ptr, getInt16PtrTy(ctx.builder.getContext())), Idx);
+        Value *Flag = ai.decorateInst(ctx.builder.CreateAlignedLoad(getInt16Ty(ctx.builder.getContext()), FlagPtr, Align(sizeof(int16_t))));
+        Flag = ctx.builder.CreateLShr(Flag, 4);
+        Flag = ctx.builder.CreateAnd(Flag, ConstantInt::get(Flag->getType(), 1));
+        Flag = ctx.builder.CreateZExt(Flag, Size->getType());
+        Size = ctx.builder.CreateAdd(Size, Flag);
+    }
     return Size;
 }
 
@@ -1761,7 +1782,6 @@ static bool bounds_check_enabled(jl_codectx_t &ctx, jl_value_t *inbounds) {
 static Value *emit_bounds_check(jl_codectx_t &ctx, const jl_cgval_t &ainfo, jl_value_t *ty, Value *i, Value *len, jl_value_t *boundscheck)
 {
     Value *im1 = ctx.builder.CreateSub(i, ConstantInt::get(ctx.types().T_size, 1));
-#if CHECK_BOUNDS==1
     if (bounds_check_enabled(ctx, boundscheck)) {
         ++EmittedBoundschecks;
         Value *ok = ctx.builder.CreateICmpULT(im1, len);
@@ -1797,10 +1817,18 @@ static Value *emit_bounds_check(jl_codectx_t &ctx, const jl_cgval_t &ainfo, jl_v
         ctx.f->getBasicBlockList().push_back(passBB);
         ctx.builder.SetInsertPoint(passBB);
     }
-#endif
     return im1;
 }
 
+static Value *CreateSimplifiedExtractValue(jl_codectx_t &ctx, Value *Agg, ArrayRef<unsigned> Idxs)
+{
+    // aka IRBuilder<InstSimplifyFolder>
+    SimplifyQuery SQ(jl_Module->getDataLayout()); // not actually used, but required by API
+    if (Value *Inst = simplifyExtractValueInst(Agg, Idxs, SQ))
+        return Inst;
+    return ctx.builder.CreateExtractValue(Agg, Idxs);
+}
+
 static void emit_write_barrier(jl_codectx_t&, Value*, ArrayRef<Value*>);
 static void emit_write_barrier(jl_codectx_t&, Value*, Value*);
 static void emit_write_multibarrier(jl_codectx_t&, Value*, Value*, jl_value_t*);
@@ -1908,14 +1936,34 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j
         emit_memcpy(ctx, intcast, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), data, jl_aliasinfo_t::fromTBAA(ctx, tbaa), nb, alignment, intcast->getAlign().value());
     }
     else {
-        LoadInst *load = ctx.builder.CreateAlignedLoad(elty, data, Align(alignment), false);
-        load->setOrdering(Order);
-        if (isboxed)
-            maybe_mark_load_dereferenceable(load, true, jltype);
-        jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
-        ai.scope = MDNode::concatenate(aliasscope, ai.scope);
-        ai.decorateInst(load);
-        instr = load;
+        if (!isboxed && jl_is_genericmemoryref_type(jltype)) {
+            // load these FCA as individual fields, so LLVM does not need to split them later
+            Value *fld0 = ctx.builder.CreateStructGEP(elty, data, 0);
+            LoadInst *load0 = ctx.builder.CreateAlignedLoad(elty->getStructElementType(0), fld0, Align(alignment), false);
+            load0->setOrdering(Order);
+            jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
+            ai.scope = MDNode::concatenate(aliasscope, ai.scope);
+            ai.decorateInst(load0);
+            Value *fld1 = ctx.builder.CreateStructGEP(elty, data, 1);
+            LoadInst *load1 = ctx.builder.CreateAlignedLoad(elty->getStructElementType(1), fld1, Align(alignment), false);
+            static_assert(offsetof(jl_genericmemoryref_t, ptr_or_offset) == 0, "wrong field order");
+            maybe_mark_load_dereferenceable(load1, true, sizeof(void*)*2, alignof(void*));
+            load1->setOrdering(Order);
+            ai.decorateInst(load1);
+            instr = Constant::getNullValue(elty);
+            instr = ctx.builder.CreateInsertValue(instr, load0, 0);
+            instr = ctx.builder.CreateInsertValue(instr, load1, 1);
+        }
+        else {
+            LoadInst *load = ctx.builder.CreateAlignedLoad(elty, data, Align(alignment), false);
+            load->setOrdering(Order);
+            if (isboxed)
+                maybe_mark_load_dereferenceable(load, true, jltype);
+            jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
+            ai.scope = MDNode::concatenate(aliasscope, ai.scope);
+            ai.decorateInst(load);
+            instr = load;
+        }
         if (elty != realelty)
             instr = ctx.builder.CreateTrunc(instr, realelty);
         if (intcast) {
@@ -2079,7 +2127,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             }
             else if (!isboxed) {
                 assert(jl_is_concrete_type(jltype));
-                needloop = ((jl_datatype_t*)jltype)->layout->haspadding;
+                needloop = ((jl_datatype_t*)jltype)->layout->flags.haspadding;
                 Value *SameType = emit_isa(ctx, cmp, jltype, Twine()).first;
                 if (SameType != ConstantInt::getTrue(ctx.builder.getContext())) {
                     BasicBlock *SkipBB = BasicBlock::Create(ctx.builder.getContext(), "skip_xchg", ctx.f);
@@ -2508,6 +2556,29 @@ static jl_cgval_t emit_unionload(jl_codectx_t &ctx, Value *addr, Value *ptindex,
     return mark_julia_slot(fsz > 0 ? addr : nullptr, jfty, tindex, tbaa);
 }
 
+static MDNode *best_field_tbaa(jl_codectx_t &ctx, const jl_cgval_t &strct, jl_datatype_t *jt, unsigned idx, size_t byte_offset)
+{
+    auto tbaa = strct.tbaa;
+    if (tbaa == ctx.tbaa().tbaa_datatype)
+        if (byte_offset != offsetof(jl_datatype_t, types))
+            return ctx.tbaa().tbaa_const;
+    if (tbaa == ctx.tbaa().tbaa_array) {
+        if (jl_is_genericmemory_type(jt)) {
+            if (idx == 0)
+                return ctx.tbaa().tbaa_memorylen;
+            if (idx == 1)
+                return ctx.tbaa().tbaa_memoryptr;
+        }
+        else if (jl_is_array_type(jt)) {
+            if (idx == 0)
+                return ctx.tbaa().tbaa_arrayptr;
+            if (idx == 1)
+                return ctx.tbaa().tbaa_arraysize;
+        }
+    }
+    return tbaa;
+}
+
 // If `nullcheck` is not NULL and a pointer NULL check is necessary
 // store the pointer to be checked in `*nullcheck` instead of checking it
 static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &strct,
@@ -2540,10 +2611,8 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
     size_t nfields = jl_datatype_nfields(jt);
     bool maybe_null = idx >= nfields - (unsigned)jt->name->n_uninitialized;
     size_t byte_offset = jl_field_offset(jt, idx);
-    auto tbaa = strct.tbaa;
-    if (tbaa == ctx.tbaa().tbaa_datatype && byte_offset != offsetof(jl_datatype_t, types))
-        tbaa = ctx.tbaa().tbaa_const;
     if (strct.ispointer()) {
+        auto tbaa = best_field_tbaa(ctx, strct, jt, idx, byte_offset);
         Value *staddr = data_pointer(ctx, strct);
         bool isboxed;
         Type *lt = julia_type_to_llvm(ctx, (jl_value_t*)jt, &isboxed);
@@ -2590,14 +2659,15 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
             size_t fsz = 0, al = 0;
             int union_max = jl_islayout_inline(jfty, &fsz, &al);
             bool isptr = (union_max == 0);
-            assert(!isptr && fsz == jl_field_size(jt, idx) - 1); (void)isptr;
+            assert(!isptr && fsz < jl_field_size(jt, idx)); (void)isptr;
+            size_t fsz1 = jl_field_size(jt, idx) - 1;
             Value *ptindex;
             if (isboxed) {
                 ptindex = ctx.builder.CreateConstInBoundsGEP1_32(
-                    getInt8Ty(ctx.builder.getContext()), emit_bitcast(ctx, staddr, getInt8PtrTy(ctx.builder.getContext())), byte_offset + fsz);
+                    getInt8Ty(ctx.builder.getContext()), emit_bitcast(ctx, staddr, getInt8PtrTy(ctx.builder.getContext())), byte_offset + fsz1);
             }
             else {
-                ptindex = emit_struct_gep(ctx, cast<StructType>(lt), staddr, byte_offset + fsz);
+                ptindex = emit_struct_gep(ctx, cast<StructType>(lt), staddr, byte_offset + fsz1);
             }
             auto val = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, !jl_field_isconst(jt, idx), union_max, ctx.tbaa().tbaa_unionselbyte);
             if (val.V && val.V != addr) {
@@ -2714,404 +2784,103 @@ static Value *emit_n_varargs(jl_codectx_t &ctx)
 #endif
 }
 
-static bool arraytype_constdim(jl_value_t *ty, size_t *dim)
+static Value *emit_genericmemoryelsize(jl_codectx_t &ctx, Value *v, jl_value_t *typ, bool add_isunion)
 {
-    if (jl_is_array_type(ty) && jl_is_long(jl_tparam1(ty))) {
-        *dim = jl_unbox_long(jl_tparam1(ty));
-        return true;
+    ++EmittedArrayElsize;
+    jl_datatype_t *sty = (jl_datatype_t*)jl_unwrap_unionall(typ);
+    if (jl_is_datatype(sty) && !jl_has_free_typevars((jl_value_t*)sty) && sty->layout) {
+        if (jl_is_genericmemoryref_type(sty))
+            sty = (jl_datatype_t*)jl_field_type_concrete(sty, 1);
+        size_t sz = sty->layout->size;
+        if (sty->layout->flags.arrayelem_isunion)
+            sz++;
+        return ConstantInt::get(ctx.types().T_size, sz);
+    }
+    else {
+        v = emit_bitcast(ctx, v, ctx.types().T_prjlvalue);
+        Value *t = emit_typeof(ctx, v, false, false, true);
+        Value *elsize = emit_datatype_size(ctx, t, add_isunion);
+        return ctx.builder.CreateZExt(elsize, ctx.types().T_size);
     }
-    return false;
-}
-
-static bool arraytype_constshape(jl_value_t *ty)
-{
-    size_t dim;
-    if (!arraytype_constdim(ty, &dim))
-        return false;
-    return dim != 1;
 }
 
-static bool arraytype_constelsize(jl_datatype_t *ty, size_t *elsz)
+static ssize_t genericmemoryype_constelsize(jl_value_t *typ)
 {
-    assert(jl_is_array_type(ty));
-    jl_value_t *ety = jl_tparam0(ty);
-    if (jl_has_free_typevars(ety))
-        return false;
-    // `jl_islayout_inline` requires `*elsz` and `al` to be initialized.
-    size_t al = 0;
-    *elsz = 0;
-    int union_max = jl_islayout_inline(ety, elsz, &al);
-    bool isboxed = (union_max == 0);
-    if (isboxed) {
-        *elsz = sizeof(void*);
-    }
-    else if (jl_is_primitivetype(ety)) {
-        // Primitive types should use the array element size, but
-        // this can be different from the type's size
-        *elsz = LLT_ALIGN(*elsz, al);
+    jl_datatype_t *sty = (jl_datatype_t*)jl_unwrap_unionall(typ);
+    if (jl_is_datatype(sty) && !jl_has_free_typevars((jl_value_t*)sty) && sty->layout) {
+        if (jl_is_array_type(sty))
+            sty = (jl_datatype_t*)jl_field_type_concrete(sty, 0);
+        if (jl_is_genericmemoryref_type(sty))
+            sty = (jl_datatype_t*)jl_field_type_concrete(sty, 1);
+        return sty->layout->size;
     }
-    return true;
+    return -1;
 }
 
-static intptr_t arraytype_maxsize(jl_value_t *ty)
+static intptr_t genericmemoryype_maxsize(jl_value_t *ty) // the maxsize is strictly less than the return value
 {
-    if (!jl_is_array_type(ty))
-        return INTPTR_MAX;
-    size_t elsz;
-    if (arraytype_constelsize((jl_datatype_t*)ty, &elsz) || elsz == 0)
+    ssize_t elsz = genericmemoryype_constelsize(ty);
+    if (elsz <= 1)
         return INTPTR_MAX;
     return INTPTR_MAX / elsz;
 }
 
-static Value *emit_arraylen(jl_codectx_t &ctx, const jl_cgval_t &tinfo);
-
-static Value *emit_arraysize(jl_codectx_t &ctx, const jl_cgval_t &tinfo, Value *dim)
+static Value *emit_genericmemorylen(jl_codectx_t &ctx, Value *addr, jl_value_t *typ)
 {
-    size_t ndim;
-    MDNode *tbaa = ctx.tbaa().tbaa_arraysize;
-    if (arraytype_constdim(tinfo.typ, &ndim)) {
-        if (ndim == 0)
-            return ConstantInt::get(ctx.types().T_size, 1);
-        if (ndim == 1) {
-            if (auto d = dyn_cast<ConstantInt>(dim)) {
-                if (d->getZExtValue() == 1) {
-                    return emit_arraylen(ctx, tinfo);
-                }
-            }
-        }
-        if (ndim > 1) {
-            if (tinfo.constant && isa<ConstantInt>(dim)) {
-                auto n = cast<ConstantInt>(dim)->getZExtValue() - 1;
-                return ConstantInt::get(ctx.types().T_size, jl_array_dim(tinfo.constant, n));
-            }
-            tbaa = ctx.tbaa().tbaa_const;
-        }
-    }
-    ++EmittedArraysize;
-    Value *t = boxed(ctx, tinfo);
-    int o = offsetof(jl_array_t, nrows) / sizeof(void*) - 1;
-    auto load = emit_nthptr_recast(ctx,
-            t,
-            ctx.builder.CreateAdd(dim, ConstantInt::get(dim->getType(), o)),
-            tbaa, ctx.types().T_size);
-    setName(ctx.emission_context, load, "arraysize");
-    MDBuilder MDB(ctx.builder.getContext());
-    auto rng = MDB.createRange(Constant::getNullValue(ctx.types().T_size), ConstantInt::get(ctx.types().T_size, arraytype_maxsize(tinfo.typ)));
-    load->setMetadata(LLVMContext::MD_range, rng);
-    return load;
-}
-
-static Value *emit_arraysize(jl_codectx_t &ctx, const jl_cgval_t &tinfo, int dim)
-{
-    return emit_arraysize(ctx, tinfo, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), dim));
-}
-
-static Value *emit_vectormaxsize(jl_codectx_t &ctx, const jl_cgval_t &ary)
-{
-    return emit_arraysize(ctx, ary, 2); // maxsize aliases ncols in memory layout for vector
-}
-
-static Value *emit_arraylen_prim(jl_codectx_t &ctx, const jl_cgval_t &tinfo)
-{
-    size_t ndim;
-    jl_value_t *ty = tinfo.typ;
-    MDNode *tbaa = ctx.tbaa().tbaa_arraylen;
-    if (arraytype_constdim(ty, &ndim)) {
-        if (ndim == 0)
-            return ConstantInt::get(ctx.types().T_size, 1);
-        if (ndim != 1) {
-            if (tinfo.constant)
-                return ConstantInt::get(ctx.types().T_size, jl_array_len(tinfo.constant));
-            tbaa = ctx.tbaa().tbaa_const;
-        }
-    }
-    ++EmittedArraylen;
-    Value *t = boxed(ctx, tinfo);
-    Value *addr = ctx.builder.CreateStructGEP(ctx.types().T_jlarray,
-            emit_bitcast(ctx, decay_derived(ctx, t), ctx.types().T_pjlarray),
-            1); //index (not offset) of length field in ctx.types().T_pjlarray
-    if (tinfo.V)
-        setName(ctx.emission_context, addr, tinfo.V->getName() + ".length_ptr");
-    else
-        setName(ctx.emission_context, addr, ".length_ptr");
-    LoadInst *len = ctx.builder.CreateAlignedLoad(ctx.types().T_size, addr, ctx.types().alignof_ptr);
-    if (tinfo.V)
-        setName(ctx.emission_context, len, tinfo.V->getName() + ".length");
-    else
-        setName(ctx.emission_context, len, ".length");
-    len->setOrdering(AtomicOrdering::NotAtomic);
+    addr = emit_bitcast(ctx, decay_derived(ctx, addr), ctx.types().T_jlgenericmemory->getPointerTo()),
+    addr = ctx.builder.CreateStructGEP(ctx.types().T_jlgenericmemory, addr, 0);
+    LoadInst *LI = ctx.builder.CreateAlignedLoad(ctx.types().T_jlgenericmemory->getElementType(0), addr, Align(sizeof(size_t)));
+    jl_aliasinfo_t aliasinfo_mem = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_memorylen);
+    aliasinfo_mem.decorateInst(LI);
     MDBuilder MDB(ctx.builder.getContext());
-    auto rng = MDB.createRange(Constant::getNullValue(ctx.types().T_size), ConstantInt::get(ctx.types().T_size, arraytype_maxsize(tinfo.typ)));
-    len->setMetadata(LLVMContext::MD_range, rng);
-    jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
-    return ai.decorateInst(len);
-}
-
-static Value *emit_arraylen(jl_codectx_t &ctx, const jl_cgval_t &tinfo)
-{
-    return emit_arraylen_prim(ctx, tinfo);
+    auto rng = MDB.createRange(Constant::getNullValue(ctx.types().T_size), ConstantInt::get(ctx.types().T_size, genericmemoryype_maxsize(typ)));
+    LI->setMetadata(LLVMContext::MD_range, rng);
+    return LI;
 }
 
-static Value *emit_arrayptr_internal(jl_codectx_t &ctx, const jl_cgval_t &tinfo, Value *t, unsigned AS, bool isboxed)
+static Value *emit_genericmemoryptr(jl_codectx_t &ctx, Value *mem, const jl_datatype_layout_t *layout, unsigned AS)
 {
     ++EmittedArrayptr;
-    auto asarray = emit_bitcast(ctx, t, ctx.types().T_pjlarray);
-    Value *addr = ctx.builder.CreateStructGEP(ctx.types().T_jlarray,
-                                              asarray, 0);
-    if (addr != asarray) {
-        if (tinfo.V)
-            setName(ctx.emission_context, addr, tinfo.V->getName() + ".data_ptr");
-        else
-            setName(ctx.emission_context, addr, ".data_ptr");
-    }
-    // Normally allocated array of 0 dimension always have a inline pointer.
-    // However, we can't rely on that here since arrays can also be constructed from C pointers.
-    PointerType *PT = cast<PointerType>(addr->getType());
-    PointerType *PPT = cast<PointerType>(ctx.types().T_jlarray->getElementType(0));
-    PointerType *LoadT = PPT;
-
-    if (isboxed) {
-        LoadT = PointerType::get(ctx.types().T_prjlvalue, AS);
-    }
-    else if (AS != PPT->getAddressSpace()) {
-        LoadT = PointerType::getWithSamePointeeType(PPT, AS);
-    }
-    if (LoadT != PPT) {
-        const auto Ty = PointerType::get(LoadT, PT->getAddressSpace());
-        addr = ctx.builder.CreateBitCast(addr, Ty);
-    }
-
-    LoadInst *LI = ctx.builder.CreateAlignedLoad(LoadT, addr, Align(sizeof(char *)));
-    if (tinfo.V)
-        setName(ctx.emission_context, LI, tinfo.V->getName() + ".data");
-    else
-        setName(ctx.emission_context, LI, ".data");
+    PointerType *PT = cast<PointerType>(mem->getType());
+    assert(PT == ctx.types().T_prjlvalue);
+    Value *addr = emit_bitcast(ctx, mem, ctx.types().T_jlgenericmemory->getPointerTo(PT->getAddressSpace()));
+    addr = ctx.builder.CreateStructGEP(ctx.types().T_jlgenericmemory, addr, 1);
+    setName(ctx.emission_context, addr, ".data_ptr");
+    PointerType *PPT = cast<PointerType>(ctx.types().T_jlgenericmemory->getElementType(1));
+    LoadInst *LI = ctx.builder.CreateAlignedLoad(PPT, addr, Align(sizeof(char*)));
     LI->setOrdering(AtomicOrdering::NotAtomic);
     LI->setMetadata(LLVMContext::MD_nonnull, MDNode::get(ctx.builder.getContext(), None));
-    jl_aliasinfo_t aliasinfo = jl_aliasinfo_t::fromTBAA(ctx, arraytype_constshape(tinfo.typ) ? ctx.tbaa().tbaa_const : ctx.tbaa().tbaa_arrayptr);
+    jl_aliasinfo_t aliasinfo = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_const);
     aliasinfo.decorateInst(LI);
-
-    return LI;
-}
-
-static Value *emit_arrayptr(jl_codectx_t &ctx, const jl_cgval_t &tinfo, bool isboxed = false)
-{
-    Value *t = boxed(ctx, tinfo);
-    return emit_arrayptr_internal(ctx, tinfo, decay_derived(ctx, t), AddressSpace::Loaded, isboxed);
-}
-
-static Value *emit_unsafe_arrayptr(jl_codectx_t &ctx, const jl_cgval_t &tinfo, bool isboxed = false)
-{
-    Value *t = boxed(ctx, tinfo);
-    t = emit_pointer_from_objref(ctx, decay_derived(ctx, t));
-    return emit_arrayptr_internal(ctx, tinfo, t, 0, isboxed);
-}
-
-static Value *emit_arrayptr(jl_codectx_t &ctx, const jl_cgval_t &tinfo, jl_value_t *ex, bool isboxed = false)
-{
-    return emit_arrayptr(ctx, tinfo, isboxed);
-}
-
-static Value *emit_arraysize(jl_codectx_t &ctx, const jl_cgval_t &tinfo, jl_value_t *ex, int dim)
-{
-    return emit_arraysize(ctx, tinfo, dim);
-}
-
-static Value *emit_arrayflags(jl_codectx_t &ctx, const jl_cgval_t &tinfo)
-{
-    ++EmittedArrayflags;
-    Value *t = boxed(ctx, tinfo);
-    int arrayflag_field = 2;
-    Value *addr = ctx.builder.CreateStructGEP(
-            ctx.types().T_jlarray,
-            emit_bitcast(ctx, decay_derived(ctx, t), ctx.types().T_pjlarray),
-            arrayflag_field);
-    if (tinfo.V)
-        setName(ctx.emission_context, addr, tinfo.V->getName() + ".flags_ptr");
-    else
-        setName(ctx.emission_context, addr, ".flags_ptr");
-    jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_arrayflags);
-    auto flags = ai.decorateInst(ctx.builder.CreateAlignedLoad(getInt16Ty(ctx.builder.getContext()), addr, Align(sizeof(int16_t))));
-    if (tinfo.V)
-        setName(ctx.emission_context, flags, tinfo.V->getName() + ".flags");
-    else
-        setName(ctx.emission_context, flags, ".flags");
-    return flags;
-}
-
-static Value *emit_arrayndims(jl_codectx_t &ctx, const jl_cgval_t &ary)
-{
-    ++EmittedArrayNDims;
-    Value *flags = emit_arrayflags(ctx, ary);
-    auto name = flags->getName();
-    cast<LoadInst>(flags)->setMetadata(LLVMContext::MD_invariant_load, MDNode::get(ctx.builder.getContext(), None));
-    flags = ctx.builder.CreateLShr(flags, 2);
-    flags = ctx.builder.CreateAnd(flags, 0x1FF); // (1<<9) - 1
-    setName(ctx.emission_context, flags, name + ".ndims");
-    return flags;
-}
-
-static Value *emit_arrayelsize(jl_codectx_t &ctx, const jl_cgval_t &tinfo)
-{
-    ++EmittedArrayElsize;
-    Value *t = boxed(ctx, tinfo);
-    int elsize_field = 3;
-    Value *addr = ctx.builder.CreateStructGEP(ctx.types().T_jlarray,
-            emit_bitcast(ctx, decay_derived(ctx, t), ctx.types().T_pjlarray),
-            elsize_field);
-    if (tinfo.V)
-        setName(ctx.emission_context, addr, tinfo.V->getName() + ".elsize_ptr");
-    else
-        setName(ctx.emission_context, addr, ".elsize_ptr");
-    jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_const);
-    auto elsize = ai.decorateInst(ctx.builder.CreateAlignedLoad(getInt16Ty(ctx.builder.getContext()), addr, Align(sizeof(int16_t))));
-    if (tinfo.V)
-        setName(ctx.emission_context, elsize, tinfo.V->getName() + ".elsize");
-    else
-        setName(ctx.emission_context, elsize, ".elsize");
-    return elsize;
-}
-
-static Value *emit_arrayoffset(jl_codectx_t &ctx, const jl_cgval_t &tinfo, int nd)
-{
-    ++EmittedArrayOffset;
-    if (nd != -1 && nd != 1) // only Vector can have an offset
-        return ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 0);
-    Value *t = boxed(ctx, tinfo);
-    int offset_field = 4;
-
-    Value *addr = ctx.builder.CreateStructGEP(
-            ctx.types().T_jlarray,
-            emit_bitcast(ctx, decay_derived(ctx, t), ctx.types().T_pjlarray),
-            offset_field);
-    if (tinfo.V)
-        setName(ctx.emission_context, addr, tinfo.V->getName() + ".offset_ptr");
-    else
-        setName(ctx.emission_context, addr, ".offset_ptr");
-    jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_arrayoffset);
-    auto offset = ai.decorateInst(ctx.builder.CreateAlignedLoad(getInt32Ty(ctx.builder.getContext()), addr, Align(sizeof(int32_t))));
-    if (tinfo.V)
-        setName(ctx.emission_context, offset, tinfo.V->getName() + ".offset");
-    else
-        setName(ctx.emission_context, offset, ".offset");
-    return offset;
-}
-
-// Returns the size of the array represented by `tinfo` for the given dimension `dim` if
-// `dim` is a valid dimension, otherwise returns constant one.
-static Value *emit_arraysize_for_unsafe_dim(jl_codectx_t &ctx,
-        const jl_cgval_t &tinfo, jl_value_t *ex, size_t dim, size_t nd)
-{
-    return dim > nd ? ConstantInt::get(ctx.types().T_size, 1) : emit_arraysize(ctx, tinfo, ex, dim);
+    Value *ptr = LI;
+    if (AS) {
+        assert(AS == AddressSpace::Loaded);
+        ptr = ctx.builder.CreateCall(prepare_call(gc_loaded_func), { mem, ptr });
+    }
+    if (!layout->flags.arrayelem_isboxed)
+        ptr = ctx.builder.CreateBitCast(ptr, PointerType::get(getInt8Ty(ctx.builder.getContext()), AS));
+    return ptr;
 }
 
-// `nd == -1` means the dimension is unknown.
-static Value *emit_array_nd_index(
-        jl_codectx_t &ctx, const jl_cgval_t &ainfo, jl_value_t *ex, ssize_t nd,
-        const jl_cgval_t *argv, size_t nidxs, jl_value_t *inbounds)
+static Value *emit_genericmemoryowner(jl_codectx_t &ctx, Value *t)
 {
-    ++EmittedArrayNdIndex;
-    Value *a = boxed(ctx, ainfo);
-    Value *i = Constant::getNullValue(ctx.types().T_size);
-    Value *stride = ConstantInt::get(ctx.types().T_size, 1);
-#if CHECK_BOUNDS==1
-    bool bc = bounds_check_enabled(ctx, inbounds);
-    BasicBlock *failBB = NULL, *endBB = NULL;
-    if (bc) {
-        failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
-        endBB = BasicBlock::Create(ctx.builder.getContext(), "idxend");
-    }
-#endif
-    SmallVector<Value *, 0> idxs(nidxs);
-    for (size_t k = 0; k < nidxs; k++) {
-        idxs[k] = emit_unbox(ctx, ctx.types().T_size, argv[k], (jl_value_t*)jl_long_type); // type asserted by caller
-    }
-    Value *ii = NULL;
-    for (size_t k = 0; k < nidxs; k++) {
-        ii = ctx.builder.CreateSub(idxs[k], ConstantInt::get(ctx.types().T_size, 1));
-        i = ctx.builder.CreateAdd(i, ctx.builder.CreateMul(ii, stride));
-        if (k < nidxs - 1) {
-            assert(nd >= 0);
-            Value *d = emit_arraysize_for_unsafe_dim(ctx, ainfo, ex, k + 1, nd);
-#if CHECK_BOUNDS==1
-            if (bc) {
-                BasicBlock *okBB = BasicBlock::Create(ctx.builder.getContext(), "ib");
-                // if !(i < d) goto error
-                auto bc = ctx.builder.CreateICmpULT(ii, d);
-                setName(ctx.emission_context, bc, "inbounds");
-                ctx.builder.CreateCondBr(bc, okBB, failBB);
-                ctx.f->getBasicBlockList().push_back(okBB);
-                ctx.builder.SetInsertPoint(okBB);
-            }
-#endif
-            stride = ctx.builder.CreateMul(stride, d);
-            setName(ctx.emission_context, stride, "stride");
-        }
-    }
-#if CHECK_BOUNDS==1
-    if (bc) {
-        // We have already emitted a bounds check for each index except for
-        // the last one which we therefore have to do here.
-        if (nidxs == 1) {
-            // Linear indexing: Check against the entire linear span of the array
-            Value *alen = emit_arraylen(ctx, ainfo);
-            auto bc = ctx.builder.CreateICmpULT(i, alen);
-            setName(ctx.emission_context, bc, "inbounds");
-            ctx.builder.CreateCondBr(bc, endBB, failBB);
-        } else if (nidxs >= (size_t)nd){
-            // No dimensions were omitted; just check the last remaining index
-            assert(nd >= 0);
-            Value *last_index = ii;
-            Value *last_dimension = emit_arraysize_for_unsafe_dim(ctx, ainfo, ex, nidxs, nd);
-            auto bc = ctx.builder.CreateICmpULT(last_index, last_dimension);
-            setName(ctx.emission_context, bc, "inbounds");
-            ctx.builder.CreateCondBr(bc, endBB, failBB);
-        } else {
-            // There were fewer indices than dimensions; check the last remaining index
-            BasicBlock *checktrailingdimsBB = BasicBlock::Create(ctx.builder.getContext(), "dimsib");
-            assert(nd >= 0);
-            Value *last_index = ii;
-            Value *last_dimension = emit_arraysize_for_unsafe_dim(ctx, ainfo, ex, nidxs, nd);
-            auto bc = ctx.builder.CreateICmpULT(last_index, last_dimension);
-            setName(ctx.emission_context, bc, "inbounds");
-            ctx.builder.CreateCondBr(bc, checktrailingdimsBB, failBB);
-            ctx.f->getBasicBlockList().push_back(checktrailingdimsBB);
-            ctx.builder.SetInsertPoint(checktrailingdimsBB);
-            // And then also make sure that all dimensions that weren't explicitly
-            // indexed into have size 1
-            for (size_t k = nidxs+1; k < (size_t)nd; k++) {
-                BasicBlock *dimsokBB = BasicBlock::Create(ctx.builder.getContext(), "dimsok");
-                Value *dim = emit_arraysize_for_unsafe_dim(ctx, ainfo, ex, k, nd);
-                auto bc = ctx.builder.CreateICmpEQ(dim, ConstantInt::get(ctx.types().T_size, 1));
-                setName(ctx.emission_context, bc, "inbounds");
-                ctx.builder.CreateCondBr(bc, dimsokBB, failBB);
-                ctx.f->getBasicBlockList().push_back(dimsokBB);
-                ctx.builder.SetInsertPoint(dimsokBB);
-            }
-            Value *dim = emit_arraysize_for_unsafe_dim(ctx, ainfo, ex, nd, nd);
-            auto bc2 = ctx.builder.CreateICmpEQ(dim, ConstantInt::get(ctx.types().T_size, 1));
-            setName(ctx.emission_context, bc2, "inbounds");
-            ctx.builder.CreateCondBr(bc2, endBB, failBB);
-        }
-
-        ctx.f->getBasicBlockList().push_back(failBB);
-        ctx.builder.SetInsertPoint(failBB);
-        // CreateAlloca is OK here since we are on an error branch
-        Value *tmp = ctx.builder.CreateAlloca(ctx.types().T_size, ConstantInt::get(ctx.types().T_size, nidxs));
-        setName(ctx.emission_context, tmp, "errorbox");
-        for (size_t k = 0; k < nidxs; k++) {
-            ctx.builder.CreateAlignedStore(idxs[k], ctx.builder.CreateInBoundsGEP(ctx.types().T_size, tmp, ConstantInt::get(ctx.types().T_size, k)), ctx.types().alignof_ptr);
-        }
-        ctx.builder.CreateCall(prepare_call(jlboundserrorv_func),
-            { mark_callee_rooted(ctx, a), tmp, ConstantInt::get(ctx.types().T_size, nidxs) });
-        ctx.builder.CreateUnreachable();
-
-        ctx.f->getBasicBlockList().push_back(endBB);
-        ctx.builder.SetInsertPoint(endBB);
-    }
-#endif
-
-    return i;
+    Value *m = emit_bitcast(ctx, decay_derived(ctx, t), ctx.types().T_jlgenericmemory->getPointerTo(0));
+    Value *addr = ctx.builder.CreateStructGEP(ctx.types().T_jlgenericmemory, m, 1);
+    Type *T_data = ctx.types().T_jlgenericmemory->getElementType(1);
+    LoadInst *LI = ctx.builder.CreateAlignedLoad(T_data, addr, Align(sizeof(char*)));
+    LI->setOrdering(AtomicOrdering::NotAtomic);
+    LI->setMetadata(LLVMContext::MD_nonnull, MDNode::get(ctx.builder.getContext(), None));
+    jl_aliasinfo_t aliasinfo_mem = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_memoryown);
+    aliasinfo_mem.decorateInst(LI);
+    addr = ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue, emit_bitcast(ctx, m, LI->getType()), JL_SMALL_BYTE_ALIGNMENT / sizeof(void*));
+    Value *foreign = ctx.builder.CreateICmpNE(addr, decay_derived(ctx, LI));
+    return emit_guarded_test(ctx, foreign, t, [&] {
+            addr = ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_jlgenericmemory, m, 1);
+            LoadInst *owner = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, emit_bitcast(ctx, addr, ctx.types().T_pprjlvalue), Align(sizeof(void*)));
+            jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_const);
+            ai.decorateInst(owner);
+            return ctx.builder.CreateSelect(ctx.builder.CreateIsNull(owner), t, owner);
+        });
 }
 
 // --- boxing ---
@@ -3186,7 +2955,7 @@ static jl_value_t *static_constant_instance(const llvm::DataLayout &DL, Constant
         nargs = CDS->getNumElements();
     else
         return NULL;
-    assert(nargs > 0 && jst->instance == NULL);
+    assert(nargs > 0 && !jl_is_datatype_singleton(jst));
     if (nargs != jl_datatype_nfields(jst))
         return NULL;
 
@@ -3289,15 +3058,14 @@ static Value *_boxed_special(jl_codectx_t &ctx, const jl_cgval_t &vinfo, Type *t
     else if (jb == jl_char_type)
         box = call_with_attrs(ctx, box_char_func, as_value(ctx, t, vinfo));
     else if (jb == jl_ssavalue_type) {
-        unsigned zero = 0;
         Value *v = as_value(ctx, t, vinfo);
         assert(v->getType() == ctx.emission_context.llvmtypes[jl_ssavalue_type]);
-        v = ctx.builder.CreateExtractValue(v, makeArrayRef(&zero, 1));
+        v = ctx.builder.CreateExtractValue(v, 0);
         box = call_with_attrs(ctx, box_ssavalue_func, v);
     }
     else if (!jb->name->abstract && jl_datatype_nbits(jb) == 0) {
         // singleton
-        assert(jb->instance != NULL);
+        assert(jl_is_datatype_singleton(jb));
         return track_pjlvalue(ctx, literal_pointer_val(ctx, jb->instance));
     }
     if (box) {
@@ -3791,6 +3559,7 @@ static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
     ++EmittedSetfield;
     assert(strct.ispointer());
     size_t byte_offset = jl_field_offset(sty, idx0);
+    auto tbaa = best_field_tbaa(ctx, strct, sty, idx0, byte_offset);
     Value *addr = data_pointer(ctx, strct);
     if (byte_offset > 0) {
         addr = ctx.builder.CreateInBoundsGEP(
@@ -3804,14 +3573,15 @@ static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
         size_t fsz = 0, al = 0;
         int union_max = jl_islayout_inline(jfty, &fsz, &al);
         bool isptr = (union_max == 0);
-        assert(!isptr && fsz == jl_field_size(sty, idx0) - 1); (void)isptr;
+        assert(!isptr && fsz < jl_field_size(sty, idx0)); (void)isptr;
+        size_t fsz1 = jl_field_size(sty, idx0) - 1;
         // compute tindex from rhs
         jl_cgval_t rhs_union = convert_julia_type(ctx, rhs, jfty);
         if (rhs_union.typ == jl_bottom_type)
             return jl_cgval_t();
         Value *ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()),
                 emit_bitcast(ctx, addr, getInt8PtrTy(ctx.builder.getContext())),
-                ConstantInt::get(ctx.types().T_size, fsz));
+                ConstantInt::get(ctx.types().T_size, fsz1));
         setNameWithField(ctx.emission_context, ptindex, get_objname, sty, idx0, Twine(".tindex_ptr"));
         if (needlock)
             emit_lockstate_value(ctx, strct, true);
@@ -3823,7 +3593,7 @@ static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
         }
         jl_cgval_t oldval = rhs;
         if (!issetfield)
-            oldval = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, strct.tbaa, true, union_max, ctx.tbaa().tbaa_unionselbyte);
+            oldval = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, true, union_max, ctx.tbaa().tbaa_unionselbyte);
         Value *Success = NULL;
         BasicBlock *DoneBB = NULL;
         if (isreplacefield || ismodifyfield) {
@@ -3846,7 +3616,7 @@ static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
                 if (needlock)
                     emit_lockstate_value(ctx, strct, true);
                 cmp = oldval;
-                oldval = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, strct.tbaa, true, union_max, ctx.tbaa().tbaa_unionselbyte);
+                oldval = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, true, union_max, ctx.tbaa().tbaa_unionselbyte);
             }
             BasicBlock *XchgBB = BasicBlock::Create(ctx.builder.getContext(), "xchg", ctx.f);
             DoneBB = BasicBlock::Create(ctx.builder.getContext(), "done_xchg", ctx.f);
@@ -3860,7 +3630,7 @@ static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
         ai.decorateInst(ctx.builder.CreateAlignedStore(tindex, ptindex, Align(1)));
         // copy data
         if (!rhs.isghost) {
-            emit_unionmove(ctx, addr, strct.tbaa, rhs, nullptr);
+            emit_unionmove(ctx, addr, tbaa, rhs, nullptr);
         }
         if (isreplacefield || ismodifyfield) {
             ctx.builder.CreateBr(DoneBB);
@@ -3892,7 +3662,7 @@ static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
         bool isboxed = jl_field_isptr(sty, idx0);
         size_t nfields = jl_datatype_nfields(sty);
         bool maybe_null = idx0 >= nfields - (unsigned)sty->name->n_uninitialized;
-        return typed_store(ctx, addr, NULL, rhs, cmp, jfty, strct.tbaa, nullptr,
+        return typed_store(ctx, addr, NULL, rhs, cmp, jfty, tbaa, nullptr,
             wb ? boxed(ctx, strct) : nullptr,
             isboxed, Order, FailOrder, align,
             needlock, issetfield, isreplacefield, isswapfield, ismodifyfield, maybe_null, modifyop, fname);
@@ -4007,23 +3777,24 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                     tindex = ctx.builder.CreateNUWSub(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 1));
                     size_t fsz = 0, al = 0;
                     bool isptr = !jl_islayout_inline(jtype, &fsz, &al);
-                    assert(!isptr && fsz == jl_field_size(sty, i) - 1); (void)isptr;
+                    assert(!isptr && fsz < jl_field_size(sty, i)); (void)isptr;
+                    size_t fsz1 = jl_field_size(sty, i) - 1;
                     if (init_as_value) {
                         // If you wanted to implement init_as_value,
                         // would need to emit the union-move into temporary memory,
                         // then load it and combine with the tindex.
                         // But more efficient to just store it directly.
-                        unsigned ptindex = convert_struct_offset(ctx, lt, offs + fsz);
-                        if (fsz > 0 && !fval_info.isghost) {
+                        unsigned ptindex = convert_struct_offset(ctx, lt, offs + fsz1);
+                        if (fsz1 > 0 && !fval_info.isghost) {
                             Type *ET = IntegerType::get(ctx.builder.getContext(), 8 * al);
                             assert(lt->getStructElementType(llvm_idx) == ET);
                             AllocaInst *lv = emit_static_alloca(ctx, ET);
                             setName(ctx.emission_context, lv, "unioninit");
-                            lv->setOperand(0, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), (fsz + al - 1) / al));
+                            lv->setOperand(0, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), (fsz1 + al - 1) / al));
                             emit_unionmove(ctx, lv, ctx.tbaa().tbaa_stack, fval_info, nullptr);
                             // emit all of the align-sized words
                             unsigned i = 0;
-                            for (; i < fsz / al; i++) {
+                            for (; i < fsz1 / al; i++) {
                                 Value *fldp = ctx.builder.CreateConstInBoundsGEP1_32(ET, lv, i);
                                 jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack);
                                 Value *fldv = ai.decorateInst(ctx.builder.CreateAlignedLoad(ET, fldp, Align(al)));
@@ -4047,7 +3818,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                             fval = ctx.builder.CreateInsertValue(strct, fval, makeArrayRef(llvm_idx));
                     }
                     else {
-                        Value *ptindex = emit_struct_gep(ctx, lt, strct, offs + fsz);
+                        Value *ptindex = emit_struct_gep(ctx, lt, strct, offs + fsz1);
                         jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_unionselbyte);
                         ai.decorateInst(ctx.builder.CreateAlignedStore(tindex, ptindex, Align(1)));
                         if (!rhs_union.isghost)
@@ -4182,6 +3953,218 @@ static int compare_cgparams(const jl_cgparams_t *a, const jl_cgparams_t *b)
 }
 #endif
 
+static jl_cgval_t _emit_memoryref(jl_codectx_t &ctx, Value *mem, Value *data, const jl_datatype_layout_t *layout, jl_value_t *typ)
+{
+    //jl_cgval_t argv[] = {
+    //    mark_julia_type(ctx, mem, true, jl_any_type),
+    //    mark_julia_type(ctx, data, false, jl_voidpointer_type)
+    //};
+    //return emit_new_struct(ctx, typ, 3, argv);
+    Value *ref = Constant::getNullValue(get_memoryref_type(ctx.builder.getContext(), ctx.types().T_size, layout, 0));
+    ref = ctx.builder.CreateInsertValue(ref, data, 0);
+    ref = ctx.builder.CreateInsertValue(ref, mem, 1);
+    return mark_julia_type(ctx, ref, false, typ);
+}
+
+static jl_cgval_t _emit_memoryref(jl_codectx_t &ctx, const jl_cgval_t &mem, const jl_datatype_layout_t *layout, jl_value_t *typ)
+{
+    bool isboxed = layout->flags.arrayelem_isboxed;
+    bool isunion = layout->flags.arrayelem_isunion;
+    bool isghost = layout->size == 0;
+    Value *data = (!isboxed && isunion) || isghost ? ConstantInt::get(ctx.types().T_size, 0) : emit_genericmemoryptr(ctx, boxed(ctx, mem), layout, 0);
+    return _emit_memoryref(ctx, boxed(ctx, mem), data, layout, typ);
+}
+
+static Value *emit_memoryref_FCA(jl_codectx_t &ctx, const jl_cgval_t &ref, const jl_datatype_layout_t *layout)
+{
+    if (ref.ispointer()) {
+        LLVMContext &C = ctx.builder.getContext();
+        Type *type = get_memoryref_type(C, ctx.types().T_size, layout, 0);
+        LoadInst *load = ctx.builder.CreateLoad(type, emit_bitcast(ctx, data_pointer(ctx, ref), PointerType::get(type, 0)));
+        jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ref.tbaa);
+        ai.decorateInst(load);
+        return load;
+    }
+    else {
+        return ref.V;
+    }
+}
+
+static jl_cgval_t emit_memoryref(jl_codectx_t &ctx, const jl_cgval_t &ref, jl_cgval_t idx, jl_value_t *inbounds, const jl_datatype_layout_t *layout)
+{
+    ++EmittedArrayNdIndex;
+    emit_typecheck(ctx, idx, (jl_value_t*)jl_long_type, "memoryref");
+    idx = update_julia_type(ctx, idx, (jl_value_t*)jl_long_type);
+    if (idx.typ == jl_bottom_type)
+        return jl_cgval_t();
+    Value *V = emit_memoryref_FCA(ctx, ref, layout);
+    Value *data = CreateSimplifiedExtractValue(ctx, V, 0);
+    Value *mem = CreateSimplifiedExtractValue(ctx, V, 1);
+    Value *i = emit_unbox(ctx, ctx.types().T_size, idx, (jl_value_t*)jl_long_type);
+    Value *offset = ctx.builder.CreateSub(i, ConstantInt::get(ctx.types().T_size, 1));
+    Value *elsz = emit_genericmemoryelsize(ctx, mem, ref.typ, false);
+    bool bc = bounds_check_enabled(ctx, inbounds);
+#if 1
+    Value *ovflw = nullptr;
+#endif
+    Value *newdata;
+    bool isboxed = layout->flags.arrayelem_isboxed;
+    bool isunion = layout->flags.arrayelem_isunion;
+    bool isghost = layout->size == 0;
+    if ((!isboxed && isunion) || isghost) {
+        newdata = ctx.builder.CreateAdd(data, offset);
+        if (bc) {
+            BasicBlock *failBB, *endBB;
+            failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
+            endBB = BasicBlock::Create(ctx.builder.getContext(), "idxend");
+            Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
+            Value *inbound = ctx.builder.CreateICmpULT(newdata, mlen);
+            ctx.builder.CreateCondBr(inbound, endBB, failBB);
+            ctx.f->getBasicBlockList().push_back(failBB);
+            ctx.builder.SetInsertPoint(failBB);
+            ctx.builder.CreateCall(prepare_call(jlboundserror_func),
+                { mark_callee_rooted(ctx, boxed(ctx, ref)), i });
+            ctx.builder.CreateUnreachable();
+            ctx.f->getBasicBlockList().push_back(endBB);
+            ctx.builder.SetInsertPoint(endBB);
+        }
+    }
+    else {
+        Value *boffset;
+#if 0
+        if (bc) {
+            auto *MulF = Intrinsic::getDeclaration(jl_Module, Intrinsic::smul_with_overflow, offset->getType());
+            CallInst *Mul = ctx.builder.CreateCall(MulF, {offset, elsz});
+            boffset = ctx.builder.CreateExtractValue(Mul, 0);
+            ovflw = ctx.builder.CreateExtractValue(Mul, 1);
+        }
+        else
+#else
+        if (bc) {
+            // n.b. we could boundscheck that -len<=offset<=len instead of using smul.ovflw,
+            // since we know that len*elsz does not overflow,
+            // and we can further rearrange that as ovflw = !( offset+len < len+len ) as unsigned math
+            Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
+            ovflw = ctx.builder.CreateICmpUGE(ctx.builder.CreateAdd(offset, mlen), ctx.builder.CreateNUWAdd(mlen, mlen));
+        }
+#endif
+            boffset = ctx.builder.CreateMul(offset, elsz);
+#if 0 // TODO: if opaque-pointers?
+        newdata = emit_bitcast(ctx, data, getInt8PtrTy(ctx.builder.getContext()));
+        newdata = ctx.builder.CreateGEP(getInt8Ty(ctx.builder.getContext()), newdata, boffset);
+#else
+        Type *elty = isboxed ? ctx.types().T_prjlvalue : julia_type_to_llvm(ctx, jl_tparam1(ref.typ));
+        newdata = emit_bitcast(ctx, data, elty->getPointerTo(0));
+        newdata = ctx.builder.CreateInBoundsGEP(elty, newdata, offset);
+        (void)boffset; // LLVM is very bad at handling GEP with types different from the load
+#endif
+        newdata = emit_bitcast(ctx, newdata, data->getType());
+        if (bc) {
+            BasicBlock *failBB, *endBB;
+            failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
+            endBB = BasicBlock::Create(ctx.builder.getContext(), "idxend");
+            Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
+            Value *mptr = emit_genericmemoryptr(ctx, mem, layout, 0);
+            mptr = emit_bitcast(ctx, mptr, newdata->getType());
+#if 0
+            Value *mend = emit_bitcast(ctx, mptr, getInt8PtrTy(ctx.builder.getContext()));
+            Value *blen = ctx.builder.CreateMul(mlen, elsz, "", true, true);
+            mend = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), mend, blen);
+            mend = emit_bitcast(ctx, mend, newdata->getType());
+            Value *inbound = ctx.builder.CreateAnd(
+                    ctx.builder.CreateICmpULE(mptr, newdata),
+                    ctx.builder.CreateICmpULT(newdata, mend));
+            inbound = ctx.builder.CreateAnd(
+                    ctx.builder.CreateNot(ovflw),
+                    inbound);
+#elif 1
+            Value *bidx0 = ctx.builder.CreateSub(
+                ctx.builder.CreatePtrToInt(newdata, ctx.types().T_size),
+                ctx.builder.CreatePtrToInt(mptr, ctx.types().T_size));
+            Value *blen = ctx.builder.CreateMul(mlen, elsz, "", true, true);
+            Value *inbound = ctx.builder.CreateICmpULT(bidx0, blen);
+            inbound = ctx.builder.CreateAnd(ctx.builder.CreateNot(ovflw), inbound);
+#else
+            Value *idx0; // (newdata - mptr) / elsz
+            idx0 = ctx.builder.CreateSub(
+                ctx.builder.CreatePtrToInt(newdata, ctx.types().T_size),
+                ctx.builder.CreatePtrToInt(mptr, ctx.types().T_size));
+            idx0 = ctx.builder.CreateExactUDiv(idx0, elsz);
+            Value *inbound = ctx.builder.CreateICmpULT(idx0, mlen);
+#endif
+            ctx.builder.CreateCondBr(inbound, endBB, failBB);
+            ctx.f->getBasicBlockList().push_back(failBB);
+            ctx.builder.SetInsertPoint(failBB);
+            ctx.builder.CreateCall(prepare_call(jlboundserror_func),
+                { mark_callee_rooted(ctx, boxed(ctx, ref)), i });
+            ctx.builder.CreateUnreachable();
+            ctx.f->getBasicBlockList().push_back(endBB);
+            ctx.builder.SetInsertPoint(endBB);
+        }
+    }
+    return _emit_memoryref(ctx, mem, newdata, layout, ref.typ);
+}
+
+static jl_cgval_t emit_memoryref_offset(jl_codectx_t &ctx, const jl_cgval_t &ref, const jl_datatype_layout_t *layout)
+{
+    Value *offset;
+    Value *V = emit_memoryref_FCA(ctx, ref, layout);
+    Value *data = CreateSimplifiedExtractValue(ctx, V, 0);
+    if (layout->flags.arrayelem_isunion || layout->size == 0) {
+        offset = data;
+    }
+    else {
+        Value *mem = CreateSimplifiedExtractValue(ctx, V, 1);
+        Value *mptr = emit_genericmemoryptr(ctx, mem, layout, 0);
+        mptr = emit_bitcast(ctx, mptr, mem->getType());
+        // (data - mptr) / elsz
+        offset = ctx.builder.CreateSub(
+            ctx.builder.CreatePtrToInt(data, ctx.types().T_size),
+            ctx.builder.CreatePtrToInt(mptr, ctx.types().T_size));
+        Value *elsz = emit_genericmemoryelsize(ctx, mem, ref.typ, false);
+        offset = ctx.builder.CreateExactUDiv(offset, elsz);
+    }
+    offset = ctx.builder.CreateAdd(offset, ConstantInt::get(ctx.types().T_size, 1));
+    return mark_julia_type(ctx, offset, false, jl_long_type);
+}
+
+static Value *emit_memoryref_mem(jl_codectx_t &ctx, const jl_cgval_t &ref, const jl_datatype_layout_t *layout)
+{
+    Value *V = emit_memoryref_FCA(ctx, ref, layout);
+    return CreateSimplifiedExtractValue(ctx, V, 1);
+}
+
+static Value *emit_memoryref_ptr(jl_codectx_t &ctx, const jl_cgval_t &ref, const jl_datatype_layout_t *layout)
+{
+    assert(!layout->flags.arrayelem_isunion && layout->size != 0);
+    Value *newref = emit_memoryref_FCA(ctx, ref, layout);
+    Value *data = CreateSimplifiedExtractValue(ctx, newref, 0);
+    unsigned AS = AddressSpace::Loaded;
+    Value *mem = CreateSimplifiedExtractValue(ctx, newref, 1);
+    // rebuild GEP on data, so that we manually hoist this gc_loaded_func call over it, back to the original load
+    // we should add this to llvm-julia-licm too, so we can attempt hoisting over PhiNodes too (which aren't defined yet here)
+    IRBuilder<>::InsertPointGuard resetIP(ctx.builder);
+    SmallVector<GetElementPtrInst*,0> GEPlist;
+    data = data->stripPointerCastsSameRepresentation();
+    while (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(data)) { // ignoring bitcast will not be required with opaque pointers
+        GEPlist.push_back(GEP);
+        data = GEP->getPointerOperand()->stripPointerCastsSameRepresentation();
+    }
+    data = ctx.builder.CreateBitCast(data, ctx.types().T_pprjlvalue);
+    data = ctx.builder.CreateCall(prepare_call(gc_loaded_func), { mem, data });
+    if (!GEPlist.empty()) {
+        for (auto &GEP : make_range(GEPlist.rbegin(), GEPlist.rend())) {
+            data = ctx.builder.CreateBitCast(data, PointerType::get(GEP->getSourceElementType(), AS));
+            Instruction *GEP2 = GEP->clone();
+            GEP2->mutateType(PointerType::get(GEP->getResultElementType(), AS));
+            GEP2->setOperand(GetElementPtrInst::getPointerOperandIndex(), data);
+            ctx.builder.Insert(GEP2);
+            data = GEP2;
+        }
+    }
+    return data;
+}
+
 // Reset us back to codegen debug type
 #undef DEBUG_TYPE
 #define DEBUG_TYPE "julia_irgen_codegen"
diff --git a/src/clangsa/GCChecker.cpp b/src/clangsa/GCChecker.cpp
index 1dcb7f5a754d7..8aa0ef009f4eb 100644
--- a/src/clangsa/GCChecker.cpp
+++ b/src/clangsa/GCChecker.cpp
@@ -806,6 +806,8 @@ bool GCChecker::isGCTrackedType(QualType QT) {
                    Name.endswith_lower("jl_expr_t") ||
                    Name.endswith_lower("jl_code_info_t") ||
                    Name.endswith_lower("jl_array_t") ||
+                   Name.endswith_lower("jl_genericmemory_t") ||
+                   //Name.endswith_lower("jl_genericmemoryref_t") ||
                    Name.endswith_lower("jl_method_t") ||
                    Name.endswith_lower("jl_method_instance_t") ||
                    Name.endswith_lower("jl_tupletype_t") ||
diff --git a/src/codegen.cpp b/src/codegen.cpp
index d6b84f6ced0ad..4b5197e81365d 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -40,6 +40,7 @@
 #include <llvm/IR/Attributes.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/MDBuilder.h>
+#include <llvm/Analysis/InstructionSimplify.h>
 
 // support
 #include <llvm/ADT/SmallBitVector.h>
@@ -290,6 +291,7 @@ struct jl_typecache_t {
     Type *T_prjlvalue;
     Type *T_ppjlvalue;
     Type *T_pprjlvalue;
+    StructType *T_jlgenericmemory;
     StructType *T_jlarray;
     Type *T_pjlarray;
     FunctionType *T_jlfunc;
@@ -305,9 +307,10 @@ struct jl_typecache_t {
 
     jl_typecache_t() :
         T_jlvalue(nullptr), T_pjlvalue(nullptr), T_prjlvalue(nullptr),
-        T_ppjlvalue(nullptr), T_pprjlvalue(nullptr), T_jlarray(nullptr),
-        T_pjlarray(nullptr), T_jlfunc(nullptr), T_jlfuncparams(nullptr),
-        T_sigatomic(nullptr), T_ppint8(nullptr), initialized(false) {}
+        T_ppjlvalue(nullptr), T_pprjlvalue(nullptr),
+        T_jlgenericmemory(nullptr), T_jlarray(nullptr), T_pjlarray(nullptr),
+        T_jlfunc(nullptr), T_jlfuncparams(nullptr), T_sigatomic(nullptr), T_ppint8(nullptr),
+        initialized(false) {}
 
     void initialize(LLVMContext &context, const DataLayout &DL) {
         if (initialized) {
@@ -331,14 +334,11 @@ struct jl_typecache_t {
         T_jlfuncparams = JuliaType::get_jlfuncparams_ty(context);
         assert(T_jlfuncparams != NULL);
 
-        Type *vaelts[] = {PointerType::get(getInt8Ty(context), AddressSpace::Loaded)
-                        , T_size
-                        , getInt16Ty(context)
-                        , getInt16Ty(context)
-                        , getInt32Ty(context)
+        T_jlgenericmemory = StructType::get(context, { T_size, T_pprjlvalue /* [, real-owner] */ });
+        Type *vaelts[] = { PointerType::get(getInt8Ty(context), AddressSpace::Loaded),
+                           PointerType::get(T_jlgenericmemory, AddressSpace::Tracked),
+                           // dimsize[ndims]
         };
-        static_assert(sizeof(jl_array_flags_t) == sizeof(int16_t),
-                    "Size of jl_array_flags_t is not the same as int16_t");
         T_jlarray = StructType::get(context, makeArrayRef(vaelts));
         T_pjlarray = PointerType::get(T_jlarray, 0);
     }
@@ -354,19 +354,19 @@ struct jl_tbaacache_t {
     MDNode *tbaa_unionselbyte;   // a selector byte in isbits Union struct fields
     MDNode *tbaa_data;       // Any user data that `pointerset/ref` are allowed to alias
     MDNode *tbaa_binding;        // jl_binding_t::value
-    MDNode *tbaa_value;          // jl_value_t, that is not jl_array_t
+    MDNode *tbaa_value;          // jl_value_t, that is not jl_array_t or jl_genericmemory_t
     MDNode *tbaa_mutab;              // mutable type
     MDNode *tbaa_datatype;               // datatype
     MDNode *tbaa_immut;              // immutable type
     MDNode *tbaa_ptrarraybuf;    // Data in an array of boxed values
     MDNode *tbaa_arraybuf;       // Data in an array of POD
-    MDNode *tbaa_array;      // jl_array_t
-    MDNode *tbaa_arrayptr;       // The pointer inside a jl_array_t
+    MDNode *tbaa_array;      // jl_array_t or jl_genericmemory_t
+    MDNode *tbaa_arrayptr;       // The pointer inside a jl_array_t (to memoryref)
     MDNode *tbaa_arraysize;      // A size in a jl_array_t
-    MDNode *tbaa_arraylen;       // The len in a jl_array_t
-    MDNode *tbaa_arrayflags;     // The flags in a jl_array_t
-    MDNode *tbaa_arrayoffset;     // The offset in a jl_array_t
-    MDNode *tbaa_arrayselbyte;   // a selector byte in a isbits Union jl_array_t
+    MDNode *tbaa_arrayselbyte;   // a selector byte in a isbits Union jl_genericmemory_t
+    MDNode *tbaa_memoryptr;      // The pointer inside a jl_genericmemory_t
+    MDNode *tbaa_memorylen;      // The length in a jl_genericmemory_t
+    MDNode *tbaa_memoryown;      // The owner in a foreign jl_genericmemory_t
     MDNode *tbaa_const;      // Memory that is immutable by the time LLVM can see it
     bool initialized;
 
@@ -375,8 +375,8 @@ struct jl_tbaacache_t {
                     tbaa_value(nullptr), tbaa_mutab(nullptr), tbaa_datatype(nullptr),
                     tbaa_immut(nullptr), tbaa_ptrarraybuf(nullptr), tbaa_arraybuf(nullptr),
                     tbaa_array(nullptr), tbaa_arrayptr(nullptr), tbaa_arraysize(nullptr),
-                    tbaa_arraylen(nullptr), tbaa_arrayflags(nullptr), tbaa_arrayoffset(nullptr),
-                    tbaa_arrayselbyte(nullptr), tbaa_const(nullptr), initialized(false) {}
+                    tbaa_arrayselbyte(nullptr), tbaa_memoryptr(nullptr), tbaa_memorylen(nullptr), tbaa_memoryown(nullptr),
+                    tbaa_const(nullptr), initialized(false) {}
 
     auto tbaa_make_child(MDBuilder &mbuilder, const char *name, MDNode *parent = nullptr, bool isConstant = false) {
         MDNode *scalar = mbuilder.createTBAAScalarTypeNode(name, parent ? parent : tbaa_root);
@@ -414,11 +414,11 @@ struct jl_tbaacache_t {
         std::tie(tbaa_array, tbaa_array_scalar) = tbaa_make_child(mbuilder, "jtbaa_array");
         tbaa_arrayptr = tbaa_make_child(mbuilder, "jtbaa_arrayptr", tbaa_array_scalar).first;
         tbaa_arraysize = tbaa_make_child(mbuilder, "jtbaa_arraysize", tbaa_array_scalar).first;
-        tbaa_arraylen = tbaa_make_child(mbuilder, "jtbaa_arraylen", tbaa_array_scalar).first;
-        tbaa_arrayflags = tbaa_make_child(mbuilder, "jtbaa_arrayflags", tbaa_array_scalar).first;
-        tbaa_arrayoffset = tbaa_make_child(mbuilder, "jtbaa_arrayoffset", tbaa_array_scalar).first;
-        tbaa_const = tbaa_make_child(mbuilder, "jtbaa_const", nullptr, true).first;
         tbaa_arrayselbyte = tbaa_make_child(mbuilder, "jtbaa_arrayselbyte", tbaa_array_scalar).first;
+        tbaa_memoryptr = tbaa_make_child(mbuilder, "jtbaa_memoryptr", tbaa_array_scalar, true).first;
+        tbaa_memorylen = tbaa_make_child(mbuilder, "jtbaa_memorylen", tbaa_array_scalar, true).first;
+        tbaa_memoryown = tbaa_make_child(mbuilder, "jtbaa_memoryown", tbaa_array_scalar, true).first;
+        tbaa_const = tbaa_make_child(mbuilder, "jtbaa_const", nullptr, true).first;
     }
 };
 
@@ -431,7 +431,7 @@ struct jl_noaliascache_t {
         MDNode *gcframe;        // GC frame
         MDNode *stack;          // Stack slot
         MDNode *data;           // Any user data that `pointerset/ref` are allowed to alias
-        MDNode *type_metadata;  // Non-user-accessible type metadata incl. size, union selectors, etc.
+        MDNode *type_metadata;  // Non-user-accessible type metadata incl. union selectors, etc.
         MDNode *constant;       // Memory that is immutable by the time LLVM can see it
 
         jl_regions_t(): gcframe(nullptr), stack(nullptr), data(nullptr), type_metadata(nullptr), constant(nullptr) {}
@@ -605,11 +605,13 @@ static inline void add_named_global(StringRef name, T *addr)
     add_named_global(name, (void*)(uintptr_t)addr);
 }
 
-AttributeSet Attributes(LLVMContext &C, std::initializer_list<Attribute::AttrKind> attrkinds)
+AttributeSet Attributes(LLVMContext &C, std::initializer_list<Attribute::AttrKind> attrkinds, std::initializer_list<Attribute> extra={})
 {
-    SmallVector<Attribute, 8> attrs(attrkinds.size());
+    SmallVector<Attribute, 8> attrs(attrkinds.size() + extra.size());
     for (size_t i = 0; i < attrkinds.size(); i++)
         attrs[i] = Attribute::get(C, attrkinds.begin()[i]);
+    for (size_t i = 0; i < extra.size(); i++)
+        attrs[attrkinds.size() + i] = extra.begin()[i];
     return AttributeSet::get(C, makeArrayRef(attrs));
 }
 
@@ -1196,18 +1198,6 @@ static const auto sync_gc_total_bytes_func = new JuliaFunction<>{
             {getInt64Ty(C)}, false); },
     nullptr,
 };
-static const auto jlarray_data_owner_func = new JuliaFunction<>{
-    XSTR(jl_array_data_owner),
-    [](LLVMContext &C) {
-        auto T_prjlvalue = JuliaType::get_prjlvalue_ty(C);
-        return FunctionType::get(T_prjlvalue,
-            {T_prjlvalue}, false);
-    },
-    [](LLVMContext &C) { return AttributeList::get(C,
-            Attributes(C, {Attribute::ReadOnly, Attribute::NoUnwind}),
-            Attributes(C, {Attribute::NonNull}),
-            None); },
-};
 #define BOX_FUNC(ct,at,attrs)                                                    \
 static const auto box_##ct##_func = new JuliaFunction<>{                           \
     XSTR(jl_box_##ct),                                                           \
@@ -1257,7 +1247,7 @@ static const auto except_enter_func = new JuliaFunction<>{
     "julia.except_enter",
     [](LLVMContext &C) { return FunctionType::get(getInt32Ty(C), false); },
     [](LLVMContext &C) { return AttributeList::get(C,
-            AttributeSet::get(C, makeArrayRef({Attribute::get(C, Attribute::ReturnsTwice)})),
+            Attributes(C, {Attribute::ReturnsTwice}),
             AttributeSet(),
             None); },
 };
@@ -1266,10 +1256,27 @@ static const auto pointer_from_objref_func = new JuliaFunction<>{
     [](LLVMContext &C) { return FunctionType::get(JuliaType::get_pjlvalue_ty(C),
             {PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::Derived)}, false); },
     [](LLVMContext &C) { return AttributeList::get(C,
-            AttributeSet::get(C, makeArrayRef({Attribute::get(C, Attribute::ReadNone), Attribute::get(C, Attribute::NoUnwind)})),
+            Attributes(C, {Attribute::ReadNone, Attribute::NoUnwind}),
             Attributes(C, {Attribute::NonNull}),
             None); },
 };
+static const auto gc_loaded_func = new JuliaFunction<>{
+    "julia.gc_loaded",
+    // # memory(none) nosync nounwind speculatable willreturn norecurse
+    // declare nonnull noundef ptr(Loaded) @"julia.gc_loaded"(ptr(Tracked) nocapture nonnull noundef readnone, ptr nonnull noundef readnone)
+    //  top:
+    //   %metadata GC base pointer is ptr(Tracked)
+    //   ret addrspacecast ptr to ptr(Loaded)
+    [](LLVMContext &C) { return FunctionType::get(PointerType::get(JuliaType::get_prjlvalue_ty(C), AddressSpace::Loaded),
+            {JuliaType::get_prjlvalue_ty(C), PointerType::get(JuliaType::get_prjlvalue_ty(C), 0)}, false); },
+    [](LLVMContext &C) {
+        AttributeSet FnAttrs = Attributes(C, {Attribute::ReadNone, Attribute::NoSync, Attribute::NoUnwind, Attribute::Speculatable, Attribute::WillReturn, Attribute::NoRecurse});
+        AttributeSet RetAttrs = Attributes(C, {Attribute::NonNull, Attribute::NoUndef});
+        return AttributeList::get(C, FnAttrs, RetAttrs,
+                { Attributes(C, {Attribute::NonNull, Attribute::NoUndef, Attribute::ReadNone, Attribute::NoCapture}),
+                  Attributes(C, {Attribute::NonNull, Attribute::NoUndef, Attribute::ReadNone}) }); },
+};
+
 
 // julia.call represents a call with julia calling convention, it is used as
 //
@@ -1336,10 +1343,10 @@ static const auto &builtin_func_map() {
           { jl_f_nfields_addr,            new JuliaFunction<>{XSTR(jl_f_nfields), get_func_sig, get_func_attrs} },
           { jl_f__expr_addr,              new JuliaFunction<>{XSTR(jl_f__expr), get_func_sig, get_func_attrs} },
           { jl_f__typevar_addr,           new JuliaFunction<>{XSTR(jl_f__typevar), get_func_sig, get_func_attrs} },
-          { jl_f_arrayref_addr,           new JuliaFunction<>{XSTR(jl_f_arrayref), get_func_sig, get_func_attrs} },
-          { jl_f_const_arrayref_addr,     new JuliaFunction<>{XSTR(jl_f_const_arrayref), get_func_sig, get_func_attrs} },
-          { jl_f_arrayset_addr,           new JuliaFunction<>{XSTR(jl_f_arrayset), get_func_sig, get_func_attrs} },
-          { jl_f_arraysize_addr,          new JuliaFunction<>{XSTR(jl_f_arraysize), get_func_sig, get_func_attrs} },
+          { jl_f_memoryref_addr,          new JuliaFunction<>{XSTR(jl_f_memoryref), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefoffset_addr,    new JuliaFunction<>{XSTR(jl_f_memoryrefoffset), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefset_addr,       new JuliaFunction<>{XSTR(jl_f_memoryrefset), get_func_sig, get_func_attrs} },
+          { jl_f_memoryref_isassigned_addr,new JuliaFunction<>{XSTR(jl_f_memoryref_isassigned), get_func_sig, get_func_attrs} },
           { jl_f_apply_type_addr,         new JuliaFunction<>{XSTR(jl_f_apply_type), get_func_sig, get_func_attrs} },
           { jl_f_donotdelete_addr,        new JuliaFunction<>{XSTR(jl_f_donotdelete), get_donotdelete_sig, get_donotdelete_func_attrs} },
           { jl_f_compilerbarrier_addr,    new JuliaFunction<>{XSTR(jl_f_compilerbarrier), get_func_sig, get_func_attrs} },
@@ -1383,6 +1390,8 @@ static MDNode *best_tbaa(jl_tbaacache_t &tbaa_cache, jl_value_t *jt) {
         return tbaa_cache.tbaa_value;
     if (jl_is_abstracttype(jt))
         return tbaa_cache.tbaa_value;
+    if (jl_is_genericmemory_type(jt) || jl_is_array_type(jt))
+        return tbaa_cache.tbaa_array;
     // If we're here, we know all subtypes are (im)mutable, even if we
     // don't know what the exact type is
     return jl_is_mutable(jt) ? tbaa_cache.tbaa_mutab : tbaa_cache.tbaa_immut;
@@ -1889,9 +1898,9 @@ static void undef_derived_strct(jl_codectx_t &ctx, Value *ptr, jl_datatype_t *st
     size_t first_offset = sty->layout->nfields ? jl_field_offset(sty, 0) : 0;
     if (first_offset != 0)
         ctx.builder.CreateMemSet(ptr, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0), first_offset, MaybeAlign(0));
-    size_t i, np = sty->layout->npointers;
-    if (np == 0)
+    if (sty->layout->first_ptr < 0)
         return;
+    size_t i, np = sty->layout->npointers;
     auto T_prjlvalue = JuliaType::get_prjlvalue_ty(ctx.builder.getContext());
     ptr = ctx.builder.CreateBitCast(ptr, T_prjlvalue->getPointerTo(ptr->getType()->getPointerAddressSpace()));
     for (i = 0; i < np; i++) {
@@ -2834,7 +2843,7 @@ static void general_use_analysis(jl_codectx_t &ctx, jl_value_t *expr, callback &
     }
     else if (jl_is_phicnode(expr)) {
         jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(expr, 0);
-        size_t i, elen = jl_array_len(values);
+        size_t i, elen = jl_array_nrows(values);
         for (i = 0; i < elen; i++) {
             jl_value_t *v = jl_array_ptr_ref(values, i);
             general_use_analysis(ctx, v, f);
@@ -2842,7 +2851,7 @@ static void general_use_analysis(jl_codectx_t &ctx, jl_value_t *expr, callback &
     }
     else if (jl_is_phinode(expr)) {
         jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(expr, 1);
-        size_t i, elen = jl_array_len(values);
+        size_t i, elen = jl_array_nrows(values);
         for (i = 0; i < elen; i++) {
             jl_value_t *v = jl_array_ptr_ref(values, i);
             if (v)
@@ -3055,7 +3064,7 @@ static Value *emit_bits_compare(jl_codectx_t &ctx, jl_cgval_t arg1, jl_cgval_t a
     if (at->isAggregateType()) { // Struct or Array
         jl_datatype_t *sty = (jl_datatype_t*)arg1.typ;
         size_t sz = jl_datatype_size(sty);
-        if (sz > 512 && !sty->layout->haspadding) {
+        if (sz > 512 && !sty->layout->flags.haspadding) {
             Value *varg1 = arg1.ispointer() ? data_pointer(ctx, arg1) :
                 value_to_pointer(ctx, arg1).V;
             Value *varg2 = arg2.ispointer() ? data_pointer(ctx, arg2) :
@@ -3480,272 +3489,282 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         return true;
     }
 
-    else if (f == jl_builtin_arraysize && nargs == 2) {
-        const jl_cgval_t &ary = argv[1];
-        const jl_cgval_t &idx = argv[2];
-        jl_value_t *aty = jl_unwrap_unionall(ary.typ);
-        if (jl_is_array_type(aty) && idx.typ == (jl_value_t*)jl_long_type) {
-            jl_value_t *ndp = jl_tparam1(aty);
-            if (jl_is_long(ndp)) {
-                size_t ndims = jl_unbox_long(ndp);
-                if (idx.constant) {
-                    uint32_t idx_const = (uint32_t)jl_unbox_long(idx.constant);
-                    if (idx_const > 0 && idx_const <= ndims) {
-                        jl_value_t *ary_ex = jl_exprarg(ex, 1);
-                        *ret = mark_julia_type(ctx, emit_arraysize(ctx, ary, ary_ex, idx_const), false, jl_long_type);
-                        return true;
-                    }
-                    else if (idx_const > ndims) {
-                        *ret = mark_julia_type(ctx, ConstantInt::get(ctx.types().T_size, 1), false, jl_long_type);
-                        return true;
-                    }
+    else if (f == jl_builtin_memoryref && nargs == 1) {
+        const jl_cgval_t &mem = argv[1];
+        jl_datatype_t *mty_dt = (jl_datatype_t*)jl_unwrap_unionall(mem.typ);
+        if (jl_is_genericmemory_type(mty_dt) && jl_is_concrete_type((jl_value_t*)mty_dt)) {
+            jl_value_t *typ = jl_apply_type((jl_value_t*)jl_genericmemoryref_type, jl_svec_data(mty_dt->parameters), jl_svec_len(mty_dt->parameters));
+            const jl_datatype_layout_t *layout = mty_dt->layout;
+            *ret = _emit_memoryref(ctx, mem, layout, typ);
+            return true;
+        }
+    }
+
+    else if (f == jl_builtin_memoryref && (nargs == 2 || nargs == 3)) {
+        const jl_cgval_t &ref = argv[1];
+        jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
+        if (jl_is_genericmemoryref_type(mty_dt) && jl_is_concrete_type(mty_dt)) {
+            mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
+            jl_value_t *boundscheck = nargs == 3 ? argv[3].constant : nullptr;
+            if (nargs == 3)
+                emit_typecheck(ctx, argv[3], (jl_value_t*)jl_bool_type, "memoryref");
+            *ret = emit_memoryref(ctx, ref, argv[2], boundscheck, layout);
+            return true;
+        }
+    }
+
+    else if (f == jl_builtin_memoryrefoffset && nargs == 1) {
+        const jl_cgval_t &ref = argv[1];
+        jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
+        if (jl_is_genericmemoryref_type(mty_dt) && jl_is_concrete_type(mty_dt)) {
+            mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
+            *ret = emit_memoryref_offset(ctx, ref, layout);
+            return true;
+        }
+    }
+
+    else if (f == jl_builtin_memoryrefget && nargs == 3) {
+        const jl_cgval_t &ref = argv[1];
+        jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
+        if (jl_is_genericmemoryref_type(mty_dt) && jl_is_concrete_type(mty_dt)) {
+            jl_value_t *isatomic = jl_tparam0(mty_dt); (void)isatomic; // TODO
+            jl_value_t *ety = jl_tparam1(mty_dt);
+            jl_value_t *addrspace = jl_tparam2(mty_dt); (void)addrspace; // TODO
+            mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
+            jl_value_t *order = argv[2].constant;
+            if (order != (jl_value_t*)jl_not_atomic_sym)
+                return false;
+            jl_value_t *boundscheck = argv[3].constant;
+            emit_typecheck(ctx, argv[3], (jl_value_t*)jl_bool_type, "memoryref");
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
+            Value *mem = emit_memoryref_mem(ctx, ref, layout);
+            Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
+            if (bounds_check_enabled(ctx, boundscheck)) {
+                BasicBlock *failBB, *endBB;
+                failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
+                endBB = BasicBlock::Create(ctx.builder.getContext(), "load");
+                ctx.builder.CreateCondBr(ctx.builder.CreateIsNull(mlen), failBB, endBB);
+                ctx.f->getBasicBlockList().push_back(failBB);
+                ctx.builder.SetInsertPoint(failBB);
+                ctx.builder.CreateCall(prepare_call(jlboundserror_func), { mark_callee_rooted(ctx, mem), ConstantInt::get(ctx.types().T_size, 1) });
+                ctx.builder.CreateUnreachable();
+                ctx.f->getBasicBlockList().push_back(endBB);
+                ctx.builder.SetInsertPoint(endBB);
+            }
+            bool isboxed = layout->flags.arrayelem_isboxed;
+            bool isunion = layout->flags.arrayelem_isunion;
+            size_t elsz = layout->size;
+            size_t al = layout->alignment;
+            if (!isboxed && !isunion && elsz == 0) {
+                assert(jl_is_datatype(ety) && jl_is_datatype_singleton((jl_datatype_t*)ety));
+                *ret = ghostValue(ctx, ety);
+            }
+            else if (isunion) {
+                Value *V = emit_memoryref_FCA(ctx, ref, layout);
+                Value *idx0 = CreateSimplifiedExtractValue(ctx, V, 0);
+                Value *mem = CreateSimplifiedExtractValue(ctx, V, 1);
+                Value *data = emit_genericmemoryptr(ctx, mem, layout, AddressSpace::Loaded);
+                Value *ptindex;
+                if (elsz == 0) {
+                    ptindex = data;
                 }
                 else {
-                    Value *idx_dyn = emit_unbox(ctx, ctx.types().T_size, idx, (jl_value_t*)jl_long_type);
-                    auto positive = ctx.builder.CreateICmpSGT(idx_dyn, Constant::getNullValue(ctx.types().T_size));
-                    setName(ctx.emission_context, positive, "ispositive");
-                    error_unless(ctx, positive, "arraysize: dimension out of range");
-                    BasicBlock *outBB = BasicBlock::Create(ctx.builder.getContext(), "outofrange", ctx.f);
-                    BasicBlock *inBB = BasicBlock::Create(ctx.builder.getContext(), "inrange");
-                    BasicBlock *ansBB = BasicBlock::Create(ctx.builder.getContext(), "arraysize");
-                    auto oor = ctx.builder.CreateICmpSLE(idx_dyn,
-                                ConstantInt::get(ctx.types().T_size, ndims));
-                    setName(ctx.emission_context, oor, "sizeddim");
-                    ctx.builder.CreateCondBr(oor, inBB, outBB);
-                    ctx.builder.SetInsertPoint(outBB);
-                    Value *v_one = ConstantInt::get(ctx.types().T_size, 1);
-                    ctx.builder.CreateBr(ansBB);
-                    ctx.f->getBasicBlockList().push_back(inBB);
-                    ctx.builder.SetInsertPoint(inBB);
-                    Value *v_sz = emit_arraysize(ctx, ary, idx_dyn);
-                    ctx.builder.CreateBr(ansBB);
-                    inBB = ctx.builder.GetInsertBlock(); // could have changed
-                    ctx.f->getBasicBlockList().push_back(ansBB);
-                    ctx.builder.SetInsertPoint(ansBB);
-                    PHINode *result = ctx.builder.CreatePHI(ctx.types().T_size, 2);
-                    result->addIncoming(v_one, outBB);
-                    result->addIncoming(v_sz, inBB);
-                    setName(ctx.emission_context, result, "arraysize");
-                    *ret = mark_julia_type(ctx, result, false, jl_long_type);
-                    return true;
+                    Type *AT = ArrayType::get(IntegerType::get(ctx.builder.getContext(), 8 * al), (elsz + al - 1) / al);
+                    data = emit_bitcast(ctx, data, AT->getPointerTo());
+                    // isbits union selector bytes are stored after mem->length bytes
+                    ptindex = ctx.builder.CreateInBoundsGEP(AT, data, mlen);
+                    data = ctx.builder.CreateInBoundsGEP(AT, data, idx0);
                 }
+                ptindex = emit_bitcast(ctx, ptindex, getInt8PtrTy(ctx.builder.getContext()));
+                ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), ptindex, idx0);
+                size_t elsz_c = 0, al_c = 0;
+                int union_max = jl_islayout_inline(ety, &elsz_c, &al_c);
+                assert(union_max && LLT_ALIGN(elsz_c, al_c) == elsz && al_c == al);
+                *ret = emit_unionload(ctx, data, ptindex, ety, elsz_c, al, ctx.tbaa().tbaa_arraybuf, true, union_max, ctx.tbaa().tbaa_arrayselbyte);
+            }
+            else {
+                *ret = typed_load(ctx,
+                        emit_memoryref_ptr(ctx, ref, layout),
+                        nullptr, ety,
+                        isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf,
+                        ctx.noalias().aliasscope.current,
+                        isboxed,
+                        AtomicOrdering::NotAtomic);
             }
+            return true;
         }
     }
 
-    else if ((f == jl_builtin_arrayref || f == jl_builtin_const_arrayref) && nargs >= 3) {
-        const jl_cgval_t &ary = argv[2];
-        bool indices_ok = true;
-        for (size_t i = 3; i <= nargs; i++) {
-            if (argv[i].typ != (jl_value_t*)jl_long_type) {
-                indices_ok = false;
-                break;
+    else if (f == jl_builtin_memoryrefset && nargs == 4) {
+        const jl_cgval_t &ref = argv[1];
+        jl_cgval_t val = argv[2];
+        jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
+        if (jl_is_genericmemoryref_type(mty_dt) && jl_is_concrete_type(mty_dt)) {
+            jl_value_t *isatomic = jl_tparam0(mty_dt); (void)isatomic; // TODO
+            jl_value_t *ety = jl_tparam1(mty_dt);
+            jl_value_t *addrspace = jl_tparam2(mty_dt); (void)addrspace; // TODO
+            mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
+            jl_value_t *order = argv[3].constant;
+            if (order != (jl_value_t*)jl_not_atomic_sym)
+                return false;
+            jl_value_t *boundscheck = argv[4].constant;
+            emit_typecheck(ctx, argv[4], (jl_value_t*)jl_bool_type, "memoryset");
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
+            Value *mem = emit_memoryref_mem(ctx, ref, layout);
+            Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
+            if (bounds_check_enabled(ctx, boundscheck)) {
+                BasicBlock *failBB, *endBB;
+                failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
+                endBB = BasicBlock::Create(ctx.builder.getContext(), "load");
+                ctx.builder.CreateCondBr(ctx.builder.CreateIsNull(mlen), failBB, endBB);
+                ctx.f->getBasicBlockList().push_back(failBB);
+                ctx.builder.SetInsertPoint(failBB);
+                ctx.builder.CreateCall(prepare_call(jlboundserror_func), { mark_callee_rooted(ctx, mem), ConstantInt::get(ctx.types().T_size, 1) });
+                ctx.builder.CreateUnreachable();
+                ctx.f->getBasicBlockList().push_back(endBB);
+                ctx.builder.SetInsertPoint(endBB);
+            }
+            emit_typecheck(ctx, val, ety, "memoryset");
+            val = update_julia_type(ctx, val, ety);
+            if (val.typ == jl_bottom_type)
+                return true;
+            bool isboxed = layout->flags.arrayelem_isboxed;
+            bool isunion = layout->flags.arrayelem_isunion;
+            size_t elsz = layout->size;
+            size_t al = layout->alignment;
+            if (isboxed)
+               ety = (jl_value_t*)jl_any_type;
+            if (!isboxed && !isunion && elsz == 0) {
+                assert(jl_is_datatype(ety) && jl_datatype_size(ety) == 0);
+                // no-op
             }
-        }
-        jl_value_t *aty_dt = jl_unwrap_unionall(ary.typ);
-        if (jl_is_array_type(aty_dt) && indices_ok) {
-            jl_value_t *ety = jl_tparam0(aty_dt);
-            jl_value_t *ndp = jl_tparam1(aty_dt);
-            if (!jl_has_free_typevars(ety) && (jl_is_long(ndp) || nargs == 3)) {
-                jl_value_t *ary_ex = jl_exprarg(ex, 2);
-                size_t elsz = 0, al = 0;
-                int union_max = jl_islayout_inline(ety, &elsz, &al);
-                bool isboxed = (union_max == 0);
-                if (isboxed)
-                    ety = (jl_value_t*)jl_any_type;
-                ssize_t nd = jl_is_long(ndp) ? jl_unbox_long(ndp) : -1;
-                jl_value_t *boundscheck = argv[1].constant;
-                emit_typecheck(ctx, argv[1], (jl_value_t*)jl_bool_type, "arrayref");
-                Value *idx = emit_array_nd_index(ctx, ary, ary_ex, nd, &argv[3], nargs - 2, boundscheck);
-                auto get_arrayname = [&]() {
-                    return ary.V ? ary.V->getName() : StringRef("");
-                };
-                if (!isboxed && jl_is_datatype(ety) && jl_datatype_size(ety) == 0) {
-                    assert(((jl_datatype_t*)ety)->instance != NULL);
-                    *ret = ghostValue(ctx, ety);
+            else {
+                Value *V = emit_memoryref_FCA(ctx, ref, layout);
+                Value *data_owner = NULL; // owner object against which the write barrier must check
+                if (isboxed || layout->first_ptr >= 0) { // if elements are just bits, don't need a write barrier
+                    data_owner = emit_genericmemoryowner(ctx, CreateSimplifiedExtractValue(ctx, V, 1));
                 }
-                else if (!isboxed && jl_is_uniontype(ety)) {
-                    Value *data = emit_arrayptr(ctx, ary, ary_ex);
-                    Value *offset = emit_arrayoffset(ctx, ary, nd);
+                if (isunion) {
+                    Value *idx0 = CreateSimplifiedExtractValue(ctx, V, 0);
+                    Value *mem = CreateSimplifiedExtractValue(ctx, V, 1);
+                    Value *data = emit_genericmemoryptr(ctx, mem, layout, AddressSpace::Loaded);
+                    Type *AT = ArrayType::get(IntegerType::get(ctx.builder.getContext(), 8 * al), (elsz + al - 1) / al);
+                    data = emit_bitcast(ctx, data, AT->getPointerTo());
+                    // compute tindex from val
+                    jl_cgval_t rhs_union = convert_julia_type(ctx, val, ety);
+                    Value *tindex = compute_tindex_unboxed(ctx, rhs_union, ety);
+                    tindex = ctx.builder.CreateNUWSub(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 1));
                     Value *ptindex;
                     if (elsz == 0) {
                         ptindex = data;
                     }
                     else {
-                        Type *AT = ArrayType::get(IntegerType::get(ctx.builder.getContext(), 8 * al), (elsz + al - 1) / al);
                         data = emit_bitcast(ctx, data, AT->getPointerTo());
-                        // isbits union selector bytes are stored after a->maxsize
-                        Value *ndims = (nd == -1 ? emit_arrayndims(ctx, ary) : ConstantInt::get(getInt16Ty(ctx.builder.getContext()), nd));
-                        Value *is_vector = ctx.builder.CreateICmpEQ(ndims, ConstantInt::get(getInt16Ty(ctx.builder.getContext()), 1));
-                        setName(ctx.emission_context, is_vector, get_arrayname() + ".isvec");
-                        Value *selidx_v = ctx.builder.CreateSub(emit_vectormaxsize(ctx, ary), ctx.builder.CreateZExt(offset, ctx.types().T_size));
-                        setName(ctx.emission_context, selidx_v, get_arrayname() + ".vec_selidx");
-                        Value *selidx_m = emit_arraylen(ctx, ary);
-                        Value *selidx = ctx.builder.CreateSelect(is_vector, selidx_v, selidx_m);
-                        setName(ctx.emission_context, selidx, get_arrayname() + ".selidx");
-                        ptindex = ctx.builder.CreateInBoundsGEP(AT, data, selidx);
-                        data = ctx.builder.CreateInBoundsGEP(AT, data, idx);
-                        setName(ctx.emission_context, data, get_arrayname() + ".data_ptr");
+                        // isbits union selector bytes are stored after mem->length
+                        ptindex = ctx.builder.CreateInBoundsGEP(AT, data, mlen);
+                        data = ctx.builder.CreateInBoundsGEP(AT, data, idx0);
                     }
                     ptindex = emit_bitcast(ctx, ptindex, getInt8PtrTy(ctx.builder.getContext()));
-                    ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), ptindex, offset);
-                    ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), ptindex, idx);
-                    setName(ctx.emission_context, ptindex, get_arrayname() + ".tindex_ptr");
-                    *ret = emit_unionload(ctx, data, ptindex, ety, elsz, al, ctx.tbaa().tbaa_arraybuf, true, union_max, ctx.tbaa().tbaa_arrayselbyte);
-                    if (ret->V)
-                        setName(ctx.emission_context, ret->V, get_arrayname() + ".ref");
+                    ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), ptindex, idx0);
+                    jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_arrayselbyte);
+                    ai.decorateInst(ctx.builder.CreateStore(tindex, ptindex));
+                    if (elsz > 0 && (!jl_is_datatype(val.typ) || jl_datatype_size(val.typ) > 0)) {
+                        // copy data (if any)
+                        emit_unionmove(ctx, data, ctx.tbaa().tbaa_arraybuf, val, nullptr);
+                    }
                 }
                 else {
-                    MDNode *aliasscope = (f == jl_builtin_const_arrayref) ? ctx.noalias().aliasscope.current : nullptr;
-                    *ret = typed_load(ctx,
-                            emit_arrayptr(ctx, ary, ary_ex),
-                            idx, ety,
-                            isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf,
-                            aliasscope,
-                            isboxed,
-                            AtomicOrdering::NotAtomic);
-                    if (ret->V)
-                        setName(ctx.emission_context, ret->V, get_arrayname() + ".ref");
+                    typed_store(ctx,
+                                emit_memoryref_ptr(ctx, ref, layout),
+                                nullptr, val, jl_cgval_t(), ety,
+                                isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf,
+                                ctx.noalias().aliasscope.current,
+                                data_owner,
+                                isboxed,
+                                isboxed ? AtomicOrdering::Release : AtomicOrdering::NotAtomic, // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
+                                /*FailOrder*/AtomicOrdering::NotAtomic, // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
+                                0,
+                                false,
+                                true,
+                                false,
+                                false,
+                                false,
+                                false,
+                                nullptr,
+                                "");
                 }
-                return true;
             }
+            *ret = ref;
+            return true;
         }
     }
 
-    else if (f == jl_builtin_arrayset && nargs >= 4) {
-        const jl_cgval_t &ary = argv[2];
-        jl_cgval_t val = argv[3];
-        bool indices_ok = true;
-        for (size_t i = 4; i <= nargs; i++) {
-            if (argv[i].typ != (jl_value_t*)jl_long_type) {
-                indices_ok = false;
-                break;
-            }
-        }
-        jl_value_t *aty_dt = jl_unwrap_unionall(ary.typ);
-        if (jl_is_array_type(aty_dt) && indices_ok) {
-            jl_value_t *ety = jl_tparam0(aty_dt);
-            jl_value_t *ndp = jl_tparam1(aty_dt);
-            if (!jl_has_free_typevars(ety) && (jl_is_long(ndp) || nargs == 4)) {
-                emit_typecheck(ctx, val, ety, "arrayset");
-                val = update_julia_type(ctx, val, ety);
-                if (val.typ == jl_bottom_type)
-                    return true;
-                size_t elsz = 0, al = 0;
-                int union_max = jl_islayout_inline(ety, &elsz, &al);
-                bool isboxed = (union_max == 0);
-                if (isboxed)
-                    ety = (jl_value_t*)jl_any_type;
-                jl_value_t *ary_ex = jl_exprarg(ex, 2);
-                ssize_t nd = jl_is_long(ndp) ? jl_unbox_long(ndp) : -1;
-                jl_value_t *boundscheck = argv[1].constant;
-                emit_typecheck(ctx, argv[1], (jl_value_t*)jl_bool_type, "arrayset");
-                Value *idx = emit_array_nd_index(ctx, ary, ary_ex, nd, &argv[4], nargs - 3, boundscheck);
-                if (!isboxed && jl_is_datatype(ety) && jl_datatype_size(ety) == 0) {
-                    // no-op
+    else if (f == jl_builtin_memoryref_isassigned && nargs == 3) {
+        const jl_cgval_t &ref = argv[1];
+        jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
+        if (jl_is_genericmemoryref_type(mty_dt) && jl_is_concrete_type(mty_dt)) {
+            jl_value_t *isatomic = jl_tparam0(mty_dt); (void)isatomic; // TODO
+            mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
+            jl_value_t *order = argv[2].constant;
+            if (order != (jl_value_t*)jl_not_atomic_sym)
+                return false;
+            jl_value_t *boundscheck = argv[3].constant;
+            emit_typecheck(ctx, argv[3], (jl_value_t*)jl_bool_type, "memory_isassigned");
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
+            Value *mem = emit_memoryref_mem(ctx, ref, layout);
+            Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
+            Value *oob = bounds_check_enabled(ctx, boundscheck) ? ctx.builder.CreateIsNull(mlen) : nullptr;
+            bool isboxed = layout->flags.arrayelem_isboxed;
+            if (isboxed || layout->first_ptr >= 0) {
+                PHINode *result = nullptr;
+                if (oob) {
+                    BasicBlock *passBB, *endBB, *fromBB;
+                    passBB = BasicBlock::Create(ctx.builder.getContext(), "load");
+                    endBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
+                    ctx.f->getBasicBlockList().push_back(passBB);
+                    ctx.f->getBasicBlockList().push_back(endBB);
+                    fromBB = ctx.builder.CreateCondBr(oob, endBB, passBB)->getParent();
+                    ctx.builder.SetInsertPoint(endBB);
+                    result = ctx.builder.CreatePHI(getInt1Ty(ctx.builder.getContext()), 2);
+                    result->addIncoming(ConstantInt::get(result->getType(), 0), fromBB);
+                    setName(ctx.emission_context, result, "arraysize");
+                    ctx.builder.SetInsertPoint(passBB);
                 }
-                else {
-                    PHINode *data_owner = NULL; // owner object against which the write barrier must check
-                    if (isboxed || (jl_is_datatype(ety) && ((jl_datatype_t*)ety)->layout->npointers > 0)) { // if elements are just bits, don't need a write barrier
-                        Value *aryv = boxed(ctx, ary);
-                        Value *flags = emit_arrayflags(ctx, ary);
-                        // the owner of the data is ary itself except if ary->how == 3
-                        flags = ctx.builder.CreateAnd(flags, 3);
-                        Value *is_owned = ctx.builder.CreateICmpEQ(flags, ConstantInt::get(getInt16Ty(ctx.builder.getContext()), 3));
-                        setName(ctx.emission_context, is_owned, "has_owner");
-                        BasicBlock *curBB = ctx.builder.GetInsertBlock();
-                        BasicBlock *ownedBB = BasicBlock::Create(ctx.builder.getContext(), "array_owned", ctx.f);
-                        BasicBlock *mergeBB = BasicBlock::Create(ctx.builder.getContext(), "merge_own", ctx.f);
-                        ctx.builder.CreateCondBr(is_owned, ownedBB, mergeBB);
-                        ctx.builder.SetInsertPoint(ownedBB);
-                        // load owner pointer
-                        Instruction *own_ptr;
-                        if (jl_is_long(ndp)) {
-                            own_ptr = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue,
-                                    ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue,
-                                        emit_bitcast(ctx, decay_derived(ctx, aryv), ctx.types().T_pprjlvalue),
-                                        jl_array_data_owner_offset(nd) / sizeof(jl_value_t*)),
-                                    Align(sizeof(void*)));
-                            setName(ctx.emission_context, own_ptr, "external_owner");
-                            jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_const);
-                            ai.decorateInst(maybe_mark_load_dereferenceable(own_ptr, false, (jl_value_t*)jl_array_any_type));
-                        }
-                        else {
-                            own_ptr = ctx.builder.CreateCall(
-                                prepare_call(jlarray_data_owner_func),
-                                {aryv});
-                        }
-                        ctx.builder.CreateBr(mergeBB);
-                        ctx.builder.SetInsertPoint(mergeBB);
-                        data_owner = ctx.builder.CreatePHI(ctx.types().T_prjlvalue, 2);
-                        data_owner->addIncoming(aryv, curBB);
-                        data_owner->addIncoming(own_ptr, ownedBB);
-                        setName(ctx.emission_context, data_owner, "data_owner");
-                    }
-                    if (!isboxed && jl_is_uniontype(ety)) {
-                        Type *AT = ArrayType::get(IntegerType::get(ctx.builder.getContext(), 8 * al), (elsz + al - 1) / al);
-                        Value *data = emit_bitcast(ctx, emit_arrayptr(ctx, ary, ary_ex), AT->getPointerTo());
-                        Value *offset = emit_arrayoffset(ctx, ary, nd);
-                        // compute tindex from val
-                        jl_cgval_t rhs_union = convert_julia_type(ctx, val, ety);
-                        Value *tindex = compute_tindex_unboxed(ctx, rhs_union, ety);
-                        tindex = ctx.builder.CreateNUWSub(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 1));
-                        Value *ptindex;
-                        if (elsz == 0) {
-                            ptindex = data;
-                        }
-                        else {
-                            Value *ndims = (nd == -1 ? emit_arrayndims(ctx, ary) : ConstantInt::get(getInt16Ty(ctx.builder.getContext()), nd));
-                            Value *is_vector = ctx.builder.CreateICmpEQ(ndims, ConstantInt::get(getInt16Ty(ctx.builder.getContext()), 1));
-                            setName(ctx.emission_context, is_vector, "is_vector");
-                            Value *selidx_v = ctx.builder.CreateSub(emit_vectormaxsize(ctx, ary), ctx.builder.CreateZExt(offset, ctx.types().T_size));
-                            setName(ctx.emission_context, selidx_v, "selidx_v");
-                            Value *selidx_m = emit_arraylen(ctx, ary);
-                            Value *selidx = ctx.builder.CreateSelect(is_vector, selidx_v, selidx_m);
-                            setName(ctx.emission_context, selidx, "selidx");
-                            ptindex = ctx.builder.CreateInBoundsGEP(AT, data, selidx);
-                            setName(ctx.emission_context, ptindex, "ptindex");
-                            data = ctx.builder.CreateInBoundsGEP(AT, data, idx);
-                            setName(ctx.emission_context, data, "data");
-                        }
-                        ptindex = emit_bitcast(ctx, ptindex, getInt8PtrTy(ctx.builder.getContext()));
-                        ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), ptindex, offset);
-                        ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), ptindex, idx);
-                        setName(ctx.emission_context, ptindex, "ptindex");
-                        jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_arrayselbyte);
-                        ai.decorateInst(ctx.builder.CreateStore(tindex, ptindex));
-                        if (elsz > 0 && (!jl_is_datatype(val.typ) || jl_datatype_size(val.typ) > 0)) {
-                            // copy data (if any)
-                            emit_unionmove(ctx, data, ctx.tbaa().tbaa_arraybuf, val, nullptr);
-                        }
-                    }
-                    else {
-                        typed_store(ctx,
-                                    emit_arrayptr(ctx, ary, ary_ex, isboxed),
-                                    idx, val, jl_cgval_t(), ety,
-                                    isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf,
-                                    ctx.noalias().aliasscope.current,
-                                    data_owner,
-                                    isboxed,
-                                    isboxed ? AtomicOrdering::Release : AtomicOrdering::NotAtomic, // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
-                                    /*FailOrder*/AtomicOrdering::NotAtomic, // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
-                                    0,
-                                    false,
-                                    true,
-                                    false,
-                                    false,
-                                    false,
-                                    false,
-                                    nullptr,
-                                    "");
-                    }
+                Value *elem = emit_memoryref_ptr(ctx, ref, layout);
+                elem = emit_bitcast(ctx, elem, ctx.types().T_pprjlvalue);
+                if (!isboxed)
+                    elem = ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue, elem, layout->first_ptr);
+                // emit this using the same type as jl_builtin_memoryrefget
+                // so that LLVM may be able to load-load forward them and fold the result
+                auto tbaa = isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf;
+                jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
+                LoadInst *fldv = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, elem, ctx.types().alignof_ptr);
+                //fldv->setOrdering(AtomicOrdering::Unordered);
+                ai.decorateInst(fldv);
+                Value *isdef = ctx.builder.CreateIsNotNull(fldv);
+                setName(ctx.emission_context, isdef, "memoryref_isassigned");
+                if (oob) {
+                    assert(result);
+                    result->addIncoming(isdef, ctx.builder.CreateBr(result->getParent())->getParent());
+                    ctx.builder.SetInsertPoint(result->getParent());
+                    isdef = result;
                 }
-                *ret = ary;
-                return true;
+                *ret = mark_julia_type(ctx, isdef, false, jl_bool_type);
             }
+            else if (oob) {
+                Value *isdef = ctx.builder.CreateNot(oob);
+                *ret = mark_julia_type(ctx, isdef, false, jl_bool_type);
+            }
+            else {
+                *ret = mark_julia_const(ctx, jl_true);
+            }
+            return true;
         }
     }
 
+
     else if (f == jl_builtin_getfield && (nargs == 2 || nargs == 3 || nargs == 4)) {
         const jl_cgval_t &obj = argv[1];
         const jl_cgval_t &fld = argv[2];
@@ -4043,19 +4062,11 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
             *ret = mark_julia_type(ctx, len, false, jl_long_type);
             return true;
         }
-        else if (jl_is_array_type(sty)) {
-            auto len = emit_arraylen(ctx, obj);
-            Value *elsize;
-            size_t elsz;
-            if (arraytype_constelsize(sty, &elsz)) {
-                elsize = ConstantInt::get(ctx.types().T_size, elsz);
-            }
-            else {
-                elsize = ctx.builder.CreateZExt(emit_arrayelsize(ctx, obj), ctx.types().T_size);
-            }
+        else if (jl_is_genericmemory_type(sty)) {
+            Value *v = boxed(ctx, obj);
+            auto len = emit_genericmemorylen(ctx, v, (jl_value_t*)sty);
+            auto elsize = emit_genericmemoryelsize(ctx, v, obj.typ, true);
             *ret = mark_julia_type(ctx, ctx.builder.CreateMul(len, elsize), false, jl_long_type);
-            if (ret->V)
-                setName(ctx.emission_context, ret->V, "sizeof");
             return true;
         }
     }
@@ -4150,10 +4161,8 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         else if (jl_field_isptr(stt, fieldidx) || jl_type_hasptr(jl_field_type(stt, fieldidx))) {
             Value *fldv;
             size_t offs = jl_field_offset(stt, fieldidx) / sizeof(jl_value_t*);
-            auto tbaa = obj.tbaa;
-            if (tbaa == ctx.tbaa().tbaa_datatype && offs != offsetof(jl_datatype_t, types))
-                tbaa = ctx.tbaa().tbaa_const;
             if (obj.ispointer()) {
+                auto tbaa = best_field_tbaa(ctx, obj, stt, fieldidx, offs);
                 if (!jl_field_isptr(stt, fieldidx))
                     offs += ((jl_datatype_t*)jl_field_type(stt, fieldidx))->layout->first_ptr;
                 Value *ptr = emit_bitcast(ctx, data_pointer(ctx, obj), ctx.types().T_pprjlvalue);
@@ -4439,7 +4448,7 @@ static jl_cgval_t emit_call_specfun_boxed(jl_codectx_t &ctx, jl_value_t *jlretty
 
 static jl_cgval_t emit_invoke(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt)
 {
-    jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
+    jl_value_t **args = jl_array_data(ex->args, jl_value_t*);
     size_t arglen = jl_array_dim0(ex->args);
     size_t nargs = arglen - 1;
     assert(arglen >= 2);
@@ -4561,7 +4570,7 @@ static jl_cgval_t emit_invoke(jl_codectx_t &ctx, const jl_cgval_t &lival, const
 static jl_cgval_t emit_invoke_modify(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt)
 {
     ++EmittedInvokes;
-    jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
+    jl_value_t **args = jl_array_data(ex->args, jl_value_t*);
     size_t arglen = jl_array_dim0(ex->args);
     size_t nargs = arglen - 1;
     assert(arglen >= 2);
@@ -4625,7 +4634,7 @@ static jl_cgval_t emit_specsig_oc_call(jl_codectx_t &ctx, jl_value_t *oc_type, j
 static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt, bool is_promotable)
 {
     ++EmittedCalls;
-    jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
+    jl_value_t **args = jl_array_data(ex->args, jl_value_t*);
     size_t nargs = jl_array_dim0(ex->args);
     assert(nargs >= 1);
     jl_cgval_t f = emit_expr(ctx, args[0]);
@@ -5087,9 +5096,9 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
         if (dest) {
             Instruction *phi = dest->clone();
             phi->insertAfter(dest);
-            PHINode *Tindex_phi = PHINode::Create(getInt8Ty(ctx.builder.getContext()), jl_array_len(edges), "tindex_phi");
+            PHINode *Tindex_phi = PHINode::Create(getInt8Ty(ctx.builder.getContext()), jl_array_nrows(edges), "tindex_phi");
             BB->getInstList().insert(InsertPt, Tindex_phi);
-            PHINode *ptr_phi = PHINode::Create(ctx.types().T_prjlvalue, jl_array_len(edges), "ptr_phi");
+            PHINode *ptr_phi = PHINode::Create(ctx.types().T_prjlvalue, jl_array_nrows(edges), "ptr_phi");
             BB->getInstList().insert(InsertPt, ptr_phi);
             Value *isboxed = ctx.builder.CreateICmpNE(
                     ctx.builder.CreateAnd(Tindex_phi, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
@@ -5107,7 +5116,7 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
             return;
         }
         else if (allunbox) {
-            PHINode *Tindex_phi = PHINode::Create(getInt8Ty(ctx.builder.getContext()), jl_array_len(edges), "tindex_phi");
+            PHINode *Tindex_phi = PHINode::Create(getInt8Ty(ctx.builder.getContext()), jl_array_nrows(edges), "tindex_phi");
             BB->getInstList().insert(InsertPt, Tindex_phi);
             jl_cgval_t val = mark_julia_slot(NULL, phiType, Tindex_phi, ctx.tbaa().tbaa_stack);
             ctx.PhiNodes.push_back(std::make_tuple(val, BB, dest, (PHINode*)NULL, r));
@@ -5121,7 +5130,7 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
     // The frontend should really not emit this, but we allow it
     // for convenience.
     if (type_is_ghost(vtype)) {
-        assert(jl_is_datatype(phiType) && ((jl_datatype_t*)phiType)->instance);
+        assert(jl_is_datatype(phiType) && jl_is_datatype_singleton((jl_datatype_t*)phiType));
         // Skip adding it to the PhiNodes list, since we didn't create one.
         ctx.SAvalues[idx] = mark_julia_const(ctx, ((jl_datatype_t*)phiType)->instance);
         ctx.ssavalue_assigned[idx] = true;
@@ -5141,7 +5150,7 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
         slot = mark_julia_slot(phi, phiType, NULL, ctx.tbaa().tbaa_stack);
     }
     else {
-        value_phi = PHINode::Create(vtype, jl_array_len(edges), "value_phi");
+        value_phi = PHINode::Create(vtype, jl_array_nrows(edges), "value_phi");
         BB->getInstList().insert(InsertPt, value_phi);
         slot = mark_julia_type(ctx, value_phi, isboxed, phiType);
     }
@@ -5385,7 +5394,7 @@ static void emit_stmtpos(jl_codectx_t &ctx, jl_value_t *expr, int ssaval_result)
         return;
     }
     jl_expr_t *ex = (jl_expr_t*)expr;
-    jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
+    jl_value_t **args = jl_array_data(ex->args, jl_value_t*);
     jl_sym_t *head = ex->head;
     if (head == jl_meta_sym || head == jl_inbounds_sym || head == jl_coverageeffect_sym
             || head == jl_aliasscope_sym || head == jl_popaliasscope_sym || head == jl_inline_sym || head == jl_noinline_sym) {
@@ -5546,8 +5555,8 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
     }
 
     jl_expr_t *ex = (jl_expr_t*)expr;
-    jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
-    size_t nargs = jl_array_len(ex->args);
+    jl_value_t **args = jl_array_data(ex->args, jl_value_t*);
+    size_t nargs = jl_array_nrows(ex->args);
     jl_sym_t *head = ex->head;
     // this is object-disoriented.
     // however, this is a good way to do it because it should *not* be easy
@@ -6032,7 +6041,7 @@ static void emit_cfunc_invalidate(
             myargs[i] = mark_julia_const(ctx, jl_tparam0(jt));
         }
         else if (type_is_ghost(et)) {
-            assert(jl_is_datatype(jt) && ((jl_datatype_t*)jt)->instance);
+            assert(jl_is_datatype(jt) && jl_is_datatype_singleton((jl_datatype_t*)jt));
             myargs[i] = mark_julia_const(ctx, ((jl_datatype_t*)jt)->instance);
         }
         else {
@@ -6343,7 +6352,7 @@ static Function* gen_cfun_wrapper(
                     *closure_types = jl_alloc_vec_any(0);
                 jl_array_ptr_1d_push(*closure_types, jargty);
                 Value *runtime_dt = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue,
-                        ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue, nestPtr, jl_array_len(*closure_types)),
+                        ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue, nestPtr, jl_array_nrows(*closure_types)),
                         Align(sizeof(void*)));
                 BasicBlock *boxedBB = BasicBlock::Create(ctx.builder.getContext(), "isboxed", cw);
                 BasicBlock *loadBB = BasicBlock::Create(ctx.builder.getContext(), "need-load", cw);
@@ -6410,7 +6419,7 @@ static Function* gen_cfun_wrapper(
                         *closure_types = jl_alloc_vec_any(0);
                     jl_array_ptr_1d_push(*closure_types, jargty);
                     Value *runtime_dt = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue,
-                            ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue, nestPtr, jl_array_len(*closure_types)),
+                            ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue, nestPtr, jl_array_nrows(*closure_types)),
                             Align(sizeof(void*)));
                     Value *strct = box_ccall_result(ctx, val, runtime_dt, jargty);
                     inputarg = mark_julia_type(ctx, strct, true, jargty_proper);
@@ -6784,7 +6793,7 @@ static jl_cgval_t emit_cfunction(jl_codectx_t &ctx, jl_value_t *output_type, con
         jl_svec_t *fill = jl_emptysvec;
         if (closure_types) {
             assert(ctx.spvals_ptr);
-            size_t n = jl_array_len(closure_types);
+            size_t n = jl_array_nrows(closure_types);
             jl_svec_t *fill = jl_alloc_svec_uninit(n);
             for (size_t i = 0; i < n; i++) {
                 jl_svecset(fill, i, jl_array_ptr_ref(closure_types, i));
@@ -7075,7 +7084,7 @@ static jl_returninfo_t get_specsig_function(jl_codectx_t &ctx, Module *M, Value
         rt = julia_type_to_llvm(ctx, jlrettype, &retboxed);
         assert(!retboxed);
         if (rt != getVoidTy(ctx.builder.getContext()) && deserves_sret(jlrettype, rt)) {
-            auto tracked = CountTrackedPointers(rt);
+            auto tracked = CountTrackedPointers(rt, true);
             assert(!tracked.derived);
             if (tracked.count && !tracked.all)
                 props.return_roots = tracked.count;
@@ -7349,7 +7358,7 @@ static jl_llvm_functions_t
         toplineno = lam->def.method->line;
         ctx.file = jl_symbol_name(lam->def.method->file);
     }
-    else if (jl_array_len(src->linetable) > 0) {
+    else if (jl_array_nrows(src->linetable) > 0) {
         jl_value_t *locinfo = jl_array_ptr_ref(src->linetable, 0);
         ctx.file = jl_symbol_name((jl_sym_t*)jl_fieldref_noalloc(locinfo, 2));
         toplineno = jl_unbox_int32(jl_fieldref(locinfo, 3));
@@ -7364,7 +7373,7 @@ static jl_llvm_functions_t
         debug_enabled = false;
 
     // step 2. process var-info lists to see what vars need boxing
-    int n_ssavalues = jl_is_long(src->ssavaluetypes) ? jl_unbox_long(src->ssavaluetypes) : jl_array_len(src->ssavaluetypes);
+    int n_ssavalues = jl_is_long(src->ssavaluetypes) ? jl_unbox_long(src->ssavaluetypes) : jl_array_nrows(src->ssavaluetypes);
     size_t vinfoslen = jl_array_dim0(src->slotflags);
     ctx.slots.resize(vinfoslen, jl_varinfo_t(ctx.builder.getContext()));
     assert(lam->specTypes); // the specTypes field should always be assigned
@@ -7394,7 +7403,7 @@ static jl_llvm_functions_t
         // OpaqueClosure implicitly loads the env
         if (i == 0 && ctx.is_opaque_closure) {
             if (jl_is_array(src->slottypes)) {
-                ty = jl_arrayref((jl_array_t*)src->slottypes, i);
+                ty = jl_array_ptr_ref((jl_array_t*)src->slottypes, i);
             }
             else {
                 ty = (jl_value_t*)jl_any_type;
@@ -7491,7 +7500,7 @@ static jl_llvm_functions_t
         // case the apply-generic call can re-use the original box for the return
         int retarg = [stmts, nreq]() {
             int retarg = -1;
-            for (size_t i = 0; i < jl_array_len(stmts); ++i) {
+            for (size_t i = 0; i < jl_array_nrows(stmts); ++i) {
                 jl_value_t *stmt = jl_array_ptr_ref(stmts, i);
                 if (jl_is_returnnode(stmt)) {
                     stmt = jl_returnnode_value(stmt);
@@ -7794,7 +7803,7 @@ static jl_llvm_functions_t
     // yield to them.
     // Also count ssavalue uses.
     {
-        for (size_t i = 0; i < jl_array_len(stmts); ++i) {
+        for (size_t i = 0; i < jl_array_nrows(stmts); ++i) {
             jl_value_t *stmt = jl_array_ptr_ref(stmts, i);
 
             auto scan_ssavalue = [&](jl_value_t *val) {
@@ -7808,7 +7817,7 @@ static jl_llvm_functions_t
 
             if (jl_is_phicnode(stmt)) {
                 jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(stmt, 0);
-                for (size_t j = 0; j < jl_array_len(values); ++j) {
+                for (size_t j = 0; j < jl_array_nrows(values); ++j) {
                     jl_value_t *val = jl_array_ptr_ref(values, j);
                     assert(jl_is_ssavalue(val));
                     upsilon_to_phic[((jl_ssavalue_t*)val)->id] = i;
@@ -8075,7 +8084,7 @@ static jl_llvm_functions_t
     SmallVector<DebugLineTable, 0> linetable;
     { // populate the linetable data format
         assert(jl_is_array(src->linetable));
-        size_t nlocs = jl_array_len(src->linetable);
+        size_t nlocs = jl_array_nrows(src->linetable);
         std::map<std::tuple<StringRef, StringRef>, DISubprogram*> subprograms;
         linetable.resize(nlocs + 1);
         DebugLineTable &topinfo = linetable[0];
@@ -8147,7 +8156,7 @@ static jl_llvm_functions_t
     SmallVector<Metadata*, 0> scope_stack;
     SmallVector<MDNode*, 0> scope_list_stack;
     {
-        size_t nstmts = jl_array_len(stmts);
+        size_t nstmts = jl_array_nrows(stmts);
         aliasscopes.resize(nstmts + 1, nullptr);
         MDBuilder mbuilder(ctx.builder.getContext());
         MDNode *alias_domain = mbuilder.createAliasScopeDomain(ctx.name);
@@ -8317,8 +8326,8 @@ static jl_llvm_functions_t
                     branch_targets.insert(i + 2);
             } else if (jl_is_phinode(stmt)) {
                 jl_array_t *edges = (jl_array_t*)jl_fieldref_noalloc(stmt, 0);
-                for (size_t j = 0; j < jl_array_len(edges); ++j) {
-                    size_t edge = ((int32_t*)jl_array_data(edges))[j];
+                for (size_t j = 0; j < jl_array_nrows(edges); ++j) {
+                    size_t edge = jl_array_data(edges, int32_t)[j];
                     if (edge == i)
                         branch_targets.insert(i + 1);
                 }
@@ -8347,7 +8356,7 @@ static jl_llvm_functions_t
 
     find_next_stmt(0);
     while (cursor != -1) {
-        int32_t debuginfoloc = ((int32_t*)jl_array_data(src->codelocs))[cursor];
+        int32_t debuginfoloc = jl_array_data(src->codelocs, int32_t)[cursor];
         if (debuginfoloc > 0) {
             if (debug_enabled)
                 ctx.builder.SetCurrentDebugLocation(linetable[debuginfoloc].loc);
@@ -8510,7 +8519,7 @@ static jl_llvm_functions_t
             continue;
         }
         else if (expr && expr->head == jl_enter_sym) {
-            jl_value_t **args = (jl_value_t**)jl_array_data(expr->args);
+            jl_value_t **args = jl_array_data(expr->args, jl_value_t*);
 
             assert(jl_is_long(args[0]));
             int lname = jl_unbox_long(args[0]);
@@ -8563,8 +8572,8 @@ static jl_llvm_functions_t
         jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(r, 1);
         PHINode *TindexN = cast_or_null<PHINode>(phi_result.TIndex);
         DenseSet<BasicBlock*> preds;
-        for (size_t i = 0; i < jl_array_len(edges); ++i) {
-            size_t edge = ((int32_t*)jl_array_data(edges))[i];
+        for (size_t i = 0; i < jl_array_nrows(edges); ++i) {
+            size_t edge = jl_array_data(edges, int32_t)[i];
             jl_value_t *value = jl_array_ptr_ref(values, i);
             // This edge value is undef, handle it the same as if the edge wasn't listed at all
             if (!value)
@@ -8583,7 +8592,7 @@ static jl_llvm_functions_t
                 // Only codegen this branch once for each PHI (the expression must be the same on all branches)
 #ifndef NDEBUG
                 for (size_t j = 0; j < i; ++j) {
-                    size_t j_edge = ((int32_t*)jl_array_data(edges))[j];
+                    size_t j_edge = jl_array_data(edges, int32_t)[j];
                     if (j_edge == edge) {
                         assert(jl_egal(value, jl_array_ptr_ref(values, j)));
                     }
@@ -9215,7 +9224,6 @@ static void init_jit_functions(void)
     add_named_global(jlfieldindex_func, &jl_field_index);
     add_named_global(diff_gc_total_bytes_func, &jl_gc_diff_total_bytes);
     add_named_global(sync_gc_total_bytes_func, &jl_gc_sync_total_bytes);
-    add_named_global(jlarray_data_owner_func, &jl_array_data_owner);
     add_named_global(gcroot_flush_func, (void*)NULL);
     add_named_global(gc_preserve_begin_func, (void*)NULL);
     add_named_global(gc_preserve_end_func, (void*)NULL);
diff --git a/src/common_symbols1.inc b/src/common_symbols1.inc
index 547d5d0eabede..f54be52729a4f 100644
--- a/src/common_symbols1.inc
+++ b/src/common_symbols1.inc
@@ -1,98 +1,92 @@
 jl_symbol("="),
 jl_symbol("getproperty"),
-jl_symbol("apply_type"),
 jl_symbol("getfield"),
+jl_symbol("apply_type"),
+jl_symbol("==="),
 jl_symbol("getindex"),
 jl_symbol("convert"),
-jl_symbol("==="),
-jl_symbol("iterate"),
 jl_symbol("=="),
 jl_symbol("new"),
-jl_symbol("foreigncall"),
 jl_symbol("int.jl"),
-jl_symbol("throw"),
-jl_symbol("nothing"),
-jl_symbol("essentials.jl"),
 jl_symbol("+"),
-jl_symbol("unsafe_convert"),
+jl_symbol("boot.jl"),
+jl_symbol("essentials.jl"),
+jl_symbol("ccall"),
+jl_symbol("foreigncall"),
+jl_symbol("iterate"),
 jl_symbol("not_int"),
+jl_symbol("Base.jl"),
 jl_symbol("-"),
-jl_symbol("boot.jl"),
-jl_symbol("number.jl"),
+jl_symbol("throw"),
+jl_symbol("promotion.jl"),
 jl_symbol("length"),
 jl_symbol("<"),
-jl_symbol("cconvert"),
-jl_symbol("Base.jl"),
-jl_symbol("promotion.jl"),
-jl_symbol("tuple.jl"),
-jl_symbol("static_parameter"),
-jl_symbol("isempty"),
-jl_symbol("<="),
-jl_symbol("array.jl"),
+jl_symbol("isa"),
 jl_symbol("operators.jl"),
-jl_symbol("NamedTuple"),
+jl_symbol("number.jl"),
+jl_symbol("unsafe_convert"),
+jl_symbol("tuple.jl"),
+jl_symbol("nothing"),
 jl_symbol("bitcast"),
-jl_symbol("!"),
+jl_symbol("NamedTuple"),
 jl_symbol("indexed_iterate"),
-jl_symbol("sle_int"),
 jl_symbol("bool.jl"),
-jl_symbol("Ptr"),
-jl_symbol("size"),
+jl_symbol("!"),
+jl_symbol("isempty"),
+jl_symbol("<="),
+jl_symbol("cconvert"),
 jl_symbol("add_int"),
+jl_symbol("static_parameter"),
+jl_symbol("array.jl"),
 jl_symbol("slt_int"),
-jl_symbol("*"),
-jl_symbol("range.jl"),
-jl_symbol("abstractarray.jl"),
 jl_symbol("!="),
-jl_symbol("isa"),
-jl_symbol("setindex!"),
-jl_symbol("string"),
-jl_symbol("ifelse"),
-jl_symbol(":"),
-jl_symbol(">"),
-jl_symbol("_apply_iterate"),
 jl_symbol("UInt64"),
+jl_symbol("range.jl"),
+jl_symbol("sle_int"),
+jl_symbol("size"),
 jl_symbol("&"),
-jl_symbol("max"),
+jl_symbol("abstractarray.jl"),
 jl_symbol("rem"),
-jl_symbol("sub_int"),
-jl_symbol(">="),
-jl_symbol("UInt8"),
-jl_symbol("iterators.jl"),
+jl_symbol(">"),
 jl_symbol("Int64"),
-jl_symbol("pairs"),
+jl_symbol("sub_int"),
+jl_symbol("*"),
 jl_symbol("and_int"),
+jl_symbol("string"),
+jl_symbol(">="),
+jl_symbol("Ptr"),
+jl_symbol("toInt64"),
 jl_symbol("last"),
-jl_symbol("typeof"),
-jl_symbol("arrayref"),
 jl_symbol("pointer.jl"),
-jl_symbol("toInt64"),
-jl_symbol("arraylen"),
+jl_symbol("reinterpret"),
+jl_symbol("first"),
+jl_symbol("pairs"),
+jl_symbol("_apply_iterate"),
 jl_symbol("typeassert"),
-jl_symbol("map"),
+jl_symbol(":"),
+jl_symbol("UInt8"),
+jl_symbol("setindex!"),
+jl_symbol("isdefined"),
+jl_symbol("typeof"),
+jl_symbol("promote"),
 jl_symbol("kwcall"),
-jl_symbol("ArgumentError"),
+jl_symbol("unsigned"),
+jl_symbol("_promote"),
+jl_symbol("toUInt64"),
+jl_symbol("map"),
 jl_symbol("lshr_int"),
+jl_symbol("gc_preserve_begin"),
+jl_symbol("gc_preserve_end"),
+jl_symbol("trunc_int"),
+jl_symbol("ArgumentError"),
 jl_symbol("axes"),
-jl_symbol("reinterpret"),
+jl_symbol("ult_int"),
+jl_symbol("UInt"),
+jl_symbol("zext_int"),
+jl_symbol("strings/string.jl"),
+jl_symbol("ifelse"),
 jl_symbol("Array"),
-jl_symbol("first"),
-jl_symbol("trunc_int"),
-jl_symbol("OneTo"),
-jl_symbol("haskey"),
-jl_symbol("Int"),
-jl_symbol("oneto"),
 jl_symbol("eq_int"),
 jl_symbol("throw_inexacterror"),
-jl_symbol("toUInt64"),
-jl_symbol("arraysize"),
-jl_symbol("UInt"),
+jl_symbol("|"),
 jl_symbol("setproperty!"),
-jl_symbol("check_top_bit"),
-jl_symbol("promote"),
-jl_symbol("unsigned"),
-jl_symbol("is_top_bit_set"),
-jl_symbol("structdiff"),
-jl_symbol("undef"),
-jl_symbol("sizeof"),
-jl_symbol("String"),
diff --git a/src/common_symbols2.inc b/src/common_symbols2.inc
index b5a334172dd76..6850fcd3033d1 100644
--- a/src/common_symbols2.inc
+++ b/src/common_symbols2.inc
@@ -1,254 +1,249 @@
-jl_symbol("namedtuple.jl"),
-jl_symbol("pop"),
-jl_symbol("inbounds"),
-jl_symbol("strings/string.jl"),
-jl_symbol("Ref"),
-jl_symbol("Vector"),
-jl_symbol("kwerr"),
-jl_symbol("_promote"),
 jl_symbol("sext_int"),
-jl_symbol("pointer"),
-jl_symbol("similar"),
-jl_symbol("arrayset"),
+jl_symbol("String"),
+jl_symbol("Int"),
+jl_symbol("iterators.jl"),
+jl_symbol("Colon"),
+jl_symbol("unchecked_oneto"),
+jl_symbol("structdiff"),
+jl_symbol("UnitRange"),
+jl_symbol("unitrange_last"),
+jl_symbol("sizeof"),
+jl_symbol("check_top_bit"),
+jl_symbol("is_top_bit_set"),
+jl_symbol("data"),
+jl_symbol("kwerr"),
 jl_symbol("axes1"),
 jl_symbol("eachindex"),
-jl_symbol("|"),
-jl_symbol("ult_int"),
-jl_symbol("lastindex"),
-jl_symbol("setfield!"),
-jl_symbol("UnitRange"),
-jl_symbol("push!"),
+jl_symbol("or_int"),
 jl_symbol("Bool"),
-jl_symbol("Colon"),
+jl_symbol("setfield!"),
 jl_symbol("fieldtype"),
-jl_symbol("unitrange_last"),
-jl_symbol("bitarray.jl"),
-jl_symbol("<<"),
-jl_symbol("zext_int"),
-jl_symbol("Tuple"),
+jl_symbol("Ref"),
+jl_symbol("pointer"),
+jl_symbol("max"),
+jl_symbol("push!"),
+jl_symbol("lastindex"),
 jl_symbol("reflection.jl"),
-jl_symbol("TypeError"),
-jl_symbol("print"),
-jl_symbol("eltype"),
+jl_symbol("<<"),
+jl_symbol("similar"),
+jl_symbol("Vector"),
+jl_symbol("UInt32"),
 jl_symbol(">>"),
-jl_symbol("strings/basic.jl"),
-jl_symbol("gc_preserve_begin"),
-jl_symbol("require_one_based_indexing"),
-jl_symbol("gc_preserve_end"),
-jl_symbol("DimensionMismatch"),
-jl_symbol("indices.jl"),
-jl_symbol("Cvoid"),
-jl_symbol("oftype"),
-jl_symbol("zero"),
-jl_symbol("float.jl"),
-jl_symbol("Any"),
-jl_symbol("checkbounds"),
-jl_symbol("or_int"),
-jl_symbol("isdefined"),
 jl_symbol("dict.jl"),
+jl_symbol("checkbounds"),
+jl_symbol("undef"),
+jl_symbol("jl_string_ptr"),
+jl_symbol("error"),
 jl_symbol("strings/io.jl"),
-jl_symbol("shl_int"),
-jl_symbol("copy"),
-jl_symbol("macro expansion"),
-jl_symbol("abstractdict.jl"),
+jl_symbol("strings/substring.jl"),
+jl_symbol("bitarray.jl"),
+jl_symbol("strings/basic.jl"),
+jl_symbol("merge"),
+jl_symbol("TypeError"),
+jl_symbol("keyword argument"),
 jl_symbol("in"),
-jl_symbol("io.jl"),
-jl_symbol("BlasInt"),
-jl_symbol("Float64"),
+jl_symbol("print"),
+jl_symbol("macro expansion"),
 jl_symbol("mul_int"),
-jl_symbol("UInt32"),
+jl_symbol("shl_int"),
 jl_symbol("C_NULL"),
+jl_symbol("oftype"),
+jl_symbol("_growend!"),
+jl_symbol("Any"),
+jl_symbol("__inbounds_setindex!"),
+jl_symbol("Tuple"),
+jl_symbol("float.jl"),
+jl_symbol("ncodeunits"),
 jl_symbol("Integer"),
+jl_symbol("io.jl"),
+jl_symbol("eltype"),
+jl_symbol("name"),
+jl_symbol("parent"),
 jl_symbol("!=="),
-jl_symbol("merge"),
-jl_symbol("BoundsError"),
-jl_symbol("broadcasted"),
-jl_symbol("Cint"),
-jl_symbol("min"),
-jl_symbol("libblastrampoline"),
 jl_symbol("iszero"),
+jl_symbol("min"),
+jl_symbol("DimensionMismatch"),
 jl_symbol("refvalue.jl"),
-jl_symbol("stride"),
-jl_symbol("error"),
-jl_symbol("ncodeunits"),
-jl_symbol("LinearIndices"),
-jl_symbol("Clong"),
-jl_symbol("pair.jl"),
-jl_symbol("_growend!"),
-jl_symbol("char.jl"),
-jl_symbol("copyto!"),
-jl_symbol("get"),
-jl_symbol("tail"),
-jl_symbol("real"),
 jl_symbol("Union"),
-jl_symbol("multidimensional.jl"),
-jl_symbol("enter"),
-jl_symbol("leave"),
+jl_symbol("BlasInt"),
+jl_symbol("unsafe_load"),
+jl_symbol("indices.jl"),
+jl_symbol("x"),
+jl_symbol("require_one_based_indexing"),
+jl_symbol("namedtuple.jl"),
+jl_symbol("tail"),
+jl_symbol("Float64"),
+jl_symbol("head"),
+jl_symbol("Cvoid"),
+jl_symbol("copy"),
+jl_symbol("libblastrampoline"),
+jl_symbol("get"),
+jl_symbol("neg_int"),
+jl_symbol("stop"),
+jl_symbol("zero"),
 jl_symbol("add_ptr"),
-jl_symbol("chkstride1"),
+jl_symbol("toUInt32"),
+jl_symbol("ptr"),
+jl_symbol("char.jl"),
+jl_symbol("trunc"),
+jl_symbol("not_atomic"),
+jl_symbol("enter"),
+jl_symbol("Pair"),
+jl_symbol("jl_value_ptr"),
 jl_symbol("Expr"),
-jl_symbol("write"),
-jl_symbol("broadcast.jl"),
+jl_symbol("broadcasted"),
+jl_symbol("pointerref"),
+jl_symbol("multidimensional.jl"),
+jl_symbol("Generator"),
+jl_symbol("leave"),
+jl_symbol("memoryref"),
 jl_symbol("show.jl"),
+jl_symbol("pointer_from_objref"),
+jl_symbol("memoryrefget"),
+jl_symbol("reduce.jl"),
+jl_symbol("stride"),
+jl_symbol("pair.jl"),
+jl_symbol("_string"),
+jl_symbol("cmem.jl"),
+jl_symbol("generator.jl"),
+jl_symbol("broadcast.jl"),
 jl_symbol("none"),
-jl_symbol("Generator"),
+jl_symbol("copyto!"),
+jl_symbol("chkstride1"),
+jl_symbol("value"),
+jl_symbol("write"),
+jl_symbol("identity"),
+jl_symbol("real"),
+jl_symbol("start"),
+jl_symbol("Cint"),
+jl_symbol("fill!"),
+jl_symbol("checkindex"),
+jl_symbol("keys"),
+jl_symbol("BoundsError"),
+jl_symbol("vals"),
+jl_symbol("Symbol"),
+jl_symbol("strings/util.jl"),
 jl_symbol("Int32"),
-jl_symbol("materialize"),
+jl_symbol("ht_keyindex"),
+jl_symbol("io"),
+jl_symbol("~"),
+jl_symbol("AssertionError"),
+jl_symbol("abstractdict.jl"),
 jl_symbol("show"),
-jl_symbol("lock"),
-jl_symbol("unsafe_load"),
-jl_symbol("gmp.jl"),
 jl_symbol("mpfr.jl"),
-jl_symbol("Symbol"),
-jl_symbol("Pair"),
-jl_symbol("resize!"),
-jl_symbol("neg_int"),
-jl_symbol("strings/substring.jl"),
-jl_symbol("AssertionError"),
-jl_symbol("identity"),
-jl_symbol("one"),
-jl_symbol("reduce.jl"),
-jl_symbol("libcholmod"),
 jl_symbol("isless"),
+jl_symbol("args"),
+jl_symbol("lock"),
 jl_symbol("reducedim.jl"),
+jl_symbol("gmp.jl"),
+jl_symbol("offset"),
+jl_symbol("resize!"),
+jl_symbol("throw_boundserror"),
+jl_symbol("Clong"),
+jl_symbol("_call_latest"),
+jl_symbol("argtail"),
+jl_symbol("compiler/ssair/ir.jl"),
+jl_symbol("sub_ptr"),
+jl_symbol("materialize"),
 jl_symbol("checksquare"),
-jl_symbol("sort.jl"),
-jl_symbol("generator.jl"),
-jl_symbol("pointer_from_objref"),
-jl_symbol("Float32"),
-jl_symbol("chklapackerror"),
-jl_symbol("parent"),
-jl_symbol("task.jl"),
+jl_symbol("LinearIndices"),
+jl_symbol("ule_int"),
+jl_symbol("dict"),
 jl_symbol("div"),
-jl_symbol("cholmod_common"),
-jl_symbol("ht_keyindex"),
-jl_symbol("pop_exception"),
-jl_symbol("c.jl"),
-jl_symbol("firstindex"),
-jl_symbol("some.jl"),
-jl_symbol("iobuffer.jl"),
-jl_symbol("sub_ptr"),
-jl_symbol("vect"),
-jl_symbol("unsafe_string"),
-jl_symbol("llvmcall"),
-jl_symbol("checkindex"),
-jl_symbol("_call_latest"),
+jl_symbol("chklapackerror"),
+jl_symbol("count"),
+jl_symbol("Float32"),
+jl_symbol("genericmemory.jl"),
+jl_symbol("print_to_string"),
 jl_symbol("rethrow"),
-jl_symbol("pointerref"),
+jl_symbol("sort.jl"),
+jl_symbol("boundscheck"),
 jl_symbol("println"),
-jl_symbol("keys"),
-jl_symbol("RefValue"),
+jl_symbol("loading.jl"),
+jl_symbol("collect"),
+jl_symbol("ashr_int"),
 jl_symbol("_expr"),
-jl_symbol("toUInt32"),
-jl_symbol("ismissing"),
-jl_symbol("throw_boundserror"),
-jl_symbol("IteratorSize"),
-jl_symbol("iddict.jl"),
+jl_symbol("iobuffer.jl"),
+jl_symbol("DataType"),
+jl_symbol("Dict"),
+jl_symbol("unsafe_string"),
+jl_symbol("RefValue"),
+jl_symbol("step"),
 jl_symbol("to_shape"),
-jl_symbol("Csize_t"),
-jl_symbol("~"),
-jl_symbol("argtail"),
-jl_symbol("include"),
-jl_symbol("set.jl"),
-jl_symbol("isequal"),
+jl_symbol("pop_exception"),
+jl_symbol("Memory"),
+jl_symbol("KeyError"),
+jl_symbol("chunks"),
 jl_symbol("refpointer.jl"),
-jl_symbol("=>"),
-jl_symbol("Val"),
-jl_symbol("Base"),
+jl_symbol("llvmcall"),
+jl_symbol("c.jl"),
+jl_symbol("set.jl"),
+jl_symbol("abs"),
+jl_symbol("checked_trunc_uint"),
+jl_symbol("Type"),
 jl_symbol("%"),
-jl_symbol("collect"),
-jl_symbol("Type##kw"),
-jl_symbol("typemax"),
-jl_symbol("fill!"),
-jl_symbol("ule_int"),
-jl_symbol("atomics.jl"),
-jl_symbol("libgit2"),
+jl_symbol("len"),
 jl_symbol("BigFloat"),
-jl_symbol("ashr_int"),
-jl_symbol("boundscheck"),
-jl_symbol("abs"),
-jl_symbol("^"),
-jl_symbol("ensure_initialized"),
-jl_symbol("_array_for"),
-jl_symbol("strings/util.jl"),
-jl_symbol("Dict"),
+jl_symbol("isequal"),
+jl_symbol("vect"),
+jl_symbol("sprint"),
+jl_symbol("mode"),
+jl_symbol("expr.jl"),
 jl_symbol("Nothing"),
-jl_symbol("compiler/ssair/ir.jl"),
+jl_symbol("Val"),
+jl_symbol("IteratorSize"),
+jl_symbol("=>"),
+jl_symbol("haskey"),
+jl_symbol("iddict.jl"),
 jl_symbol("unsafe_write"),
-jl_symbol("util.jl"),
+jl_symbol("val"),
+jl_symbol("flags"),
+jl_symbol("task.jl"),
+jl_symbol("UnionAll"),
+jl_symbol("memset"),
+jl_symbol("xor"),
+jl_symbol("jl_alloc_genericmemory"),
+jl_symbol("uplo"),
 jl_symbol("toInt32"),
-jl_symbol("loading.jl"),
-jl_symbol("value"),
-jl_symbol("expr.jl"),
-jl_symbol("print_to_string"),
+jl_symbol("Base"),
+jl_symbol("atomics.jl"),
+jl_symbol("uuid"),
+jl_symbol("one"),
+jl_symbol("math.jl"),
+jl_symbol("position"),
+jl_symbol("typemax"),
+jl_symbol("all"),
+jl_symbol("error.jl"),
+jl_symbol("path.jl"),
+jl_symbol("^"),
+jl_symbol("nextind"),
+jl_symbol("include"),
 jl_symbol("the_exception"),
-jl_symbol("nonzeros"),
-jl_symbol("<:"),
-jl_symbol("KeyError"),
-jl_symbol("xor"),
-jl_symbol("logging.jl"),
+jl_symbol("ensure_initialized"),
+jl_symbol("Const"),
+jl_symbol("UInt128"),
+jl_symbol("codeunit"),
 jl_symbol("stat.jl"),
-jl_symbol("close"),
-jl_symbol("adjoint"),
-jl_symbol("meta"),
-jl_symbol("path.jl"),
-jl_symbol("round"),
-jl_symbol("Cstring"),
-jl_symbol("SizeUnknown"),
-jl_symbol("esc"),
-jl_symbol("missing.jl"),
+jl_symbol("gcutils.jl"),
+jl_symbol("UndefRefError"),
+jl_symbol("diag"),
 jl_symbol("throw_undef_if_not"),
-jl_symbol("error.jl"),
-jl_symbol("Type"),
-jl_symbol("mul!"),
-jl_symbol("math.jl"),
-jl_symbol("unsafe_trunc"),
 jl_symbol("missing"),
-jl_symbol("subarray.jl"),
-jl_symbol("noinline"),
 jl_symbol("isnan"),
-jl_symbol("ldiv!"),
-jl_symbol("DataType"),
-jl_symbol("codeunit"),
-jl_symbol("condition.jl"),
-jl_symbol("step"),
-jl_symbol("copyast"),
-jl_symbol("bitset.jl"),
-jl_symbol("float"),
+jl_symbol("Enums.jl"),
+jl_symbol("logging.jl"),
+jl_symbol("_deleteend!"),
+jl_symbol("indices"),
+jl_symbol("compiler/utilities.jl"),
+jl_symbol("Pairs"),
+jl_symbol("<:"),
+jl_symbol("compiler/tfuncs.jl"),
+jl_symbol("close"),
+jl_symbol("subarray.jl"),
 jl_symbol("fastmath.jl"),
+jl_symbol("invokelatest"),
+jl_symbol("jl_array_del_end"),
 jl_symbol("_mod64"),
-jl_symbol("_div64"),
-jl_symbol("all"),
-jl_symbol("parse"),
-jl_symbol("joinpath"),
-jl_symbol("nextind"),
+jl_symbol("parameters"),
+jl_symbol("monotonic"),
 jl_symbol("regex.jl"),
-jl_symbol("Enums.jl"),
-jl_symbol("promote_type"),
-jl_symbol("Cdouble"),
-jl_symbol("ComplexF32"),
-jl_symbol("read"),
-jl_symbol("intfuncs.jl"),
-jl_symbol("Complex"),
-jl_symbol("_deleteend!"),
-jl_symbol("stat"),
-jl_symbol("UnionAll"),
-jl_symbol("special/trig.jl"),
-jl_symbol("UInt128"),
-jl_symbol("_copyto_impl!"),
-jl_symbol("stream.jl"),
-jl_symbol("lmul!"),
-jl_symbol("repr"),
-jl_symbol("promote_rule"),
-jl_symbol("xor_int"),
-jl_symbol("complex.jl"),
-jl_symbol("transpose"),
-jl_symbol(">>>"),
-jl_symbol("cholmod_sparse"),
-jl_symbol("filemode"),
-jl_symbol("ComplexF64"),
-jl_symbol("SparseMatrixCSC"),
-jl_symbol("view"),
-jl_symbol("GitError"),
-jl_symbol("zeros"),
-jl_symbol("InexactError"),
diff --git a/src/datatype.c b/src/datatype.c
index 905959fb80e0a..7fa712b6c8ddf 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -49,7 +49,7 @@ JL_DLLEXPORT jl_methtable_t *jl_new_method_table(jl_sym_t *name, jl_module_t *mo
     mt->name = jl_demangle_typename(name);
     mt->module = module;
     jl_atomic_store_relaxed(&mt->defs, jl_nothing);
-    jl_atomic_store_relaxed(&mt->leafcache, (jl_array_t*)jl_an_empty_vec_any);
+    jl_atomic_store_relaxed(&mt->leafcache, (jl_genericmemory_t*)jl_an_empty_memory_any);
     jl_atomic_store_relaxed(&mt->cache, jl_nothing);
     jl_atomic_store_relaxed(&mt->max_args, 0);
     mt->backedges = NULL;
@@ -134,10 +134,10 @@ static uint32_t _hash_layout_djb2(uintptr_t _layout, void *unused) JL_NOTSAFEPOI
     size_t own_size = sizeof(jl_datatype_layout_t);
     const char *fields = jl_dt_layout_fields(layout);
     assert(fields);
-    size_t fields_size = layout->nfields * jl_fielddesc_size(layout->fielddesc_type);
+    size_t fields_size = layout->nfields * jl_fielddesc_size(layout->flags.fielddesc_type);
     const char *pointers = jl_dt_layout_ptrs(layout);
     assert(pointers);
-    size_t pointers_size = (layout->npointers << layout->fielddesc_type);
+    size_t pointers_size = layout->first_ptr < 0 ? 0 : (layout->npointers << layout->flags.fielddesc_type);
 
     uint_t hash = 5381;
     hash = _hash_djb2(hash, (char *)layout, own_size);
@@ -155,12 +155,12 @@ static int layout_eq(void *_l1, void *_l2, void *unused) JL_NOTSAFEPOINT
         return 0;
     const char *f1 = jl_dt_layout_fields(l1);
     const char *f2 = jl_dt_layout_fields(l2);
-    size_t fields_size = l1->nfields * jl_fielddesc_size(l1->fielddesc_type);
+    size_t fields_size = l1->nfields * jl_fielddesc_size(l1->flags.fielddesc_type);
     if (memcmp(f1, f2, fields_size))
         return 0;
     const char *p1 = jl_dt_layout_ptrs(l1);
     const char *p2 = jl_dt_layout_ptrs(l2);
-    size_t pointers_size = (l1->npointers << l1->fielddesc_type);
+    size_t pointers_size = l1->first_ptr < 0 ? 0 : (l1->npointers << l1->flags.fielddesc_type);
     if (memcmp(p1, p2, pointers_size))
         return 0;
     return 1;
@@ -179,6 +179,7 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t sz,
                                            uint32_t npointers,
                                            uint32_t alignment,
                                            int haspadding,
+                                           int arrayelem,
                                            jl_fielddesc32_t desc[],
                                            uint32_t pointers[]) JL_NOTSAFEPOINT
 {
@@ -186,32 +187,34 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t sz,
 
     // compute the smallest fielddesc type that can hold the layout description
     int fielddesc_type = 0;
+    uint32_t max_size = 0;
+    uint32_t max_offset = 0;
     if (nfields > 0) {
-        uint32_t max_size = 0;
-        uint32_t max_offset = desc[nfields - 1].offset;
-        if (npointers > 0 && pointers[npointers - 1] > max_offset)
-            max_offset = pointers[npointers - 1];
+        max_offset = desc[nfields - 1].offset;
         for (size_t i = 0; i < nfields; i++) {
             if (desc[i].size > max_size)
                 max_size = desc[i].size;
         }
-        jl_fielddesc8_t maxdesc8 = { 0, max_size, max_offset };
-        jl_fielddesc16_t maxdesc16 = { 0, max_size, max_offset };
-        jl_fielddesc32_t maxdesc32 = { 0, max_size, max_offset };
-        if (maxdesc8.size != max_size || maxdesc8.offset != max_offset) {
-            fielddesc_type = 1;
-            if (maxdesc16.size != max_size || maxdesc16.offset != max_offset) {
-                fielddesc_type = 2;
-                if (maxdesc32.size != max_size || maxdesc32.offset != max_offset) {
-                    assert(0); // should have been verified by caller
-                }
+    }
+    if (npointers > 0 && pointers[npointers - 1] > max_offset)
+        max_offset = pointers[npointers - 1];
+    jl_fielddesc8_t maxdesc8 = { 0, max_size, max_offset };
+    jl_fielddesc16_t maxdesc16 = { 0, max_size, max_offset };
+    jl_fielddesc32_t maxdesc32 = { 0, max_size, max_offset };
+    if (maxdesc8.size != max_size || maxdesc8.offset != max_offset) {
+        fielddesc_type = 1;
+        if (maxdesc16.size != max_size || maxdesc16.offset != max_offset) {
+            fielddesc_type = 2;
+            if (maxdesc32.size != max_size || maxdesc32.offset != max_offset) {
+                assert(0); // should have been verified by caller
             }
         }
     }
+    int32_t first_ptr = (npointers > 0 ? (int32_t)pointers[0] : -1);
 
     // allocate a new descriptor, on the stack if possible.
     size_t fields_size = nfields * jl_fielddesc_size(fielddesc_type);
-    size_t pointers_size = (npointers << fielddesc_type);
+    size_t pointers_size = first_ptr < 0 ? 0 : (npointers << fielddesc_type);
     size_t flddesc_sz = sizeof(jl_datatype_layout_t) + fields_size + pointers_size;
     int should_malloc = flddesc_sz >= jl_page_size;
     jl_datatype_layout_t *mallocmem = (jl_datatype_layout_t *)(should_malloc ? malloc(flddesc_sz) : NULL);
@@ -221,11 +224,13 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t sz,
     flddesc->size = sz;
     flddesc->nfields = nfields;
     flddesc->alignment = alignment;
-    flddesc->haspadding = haspadding;
-    flddesc->fielddesc_type = fielddesc_type;
-    flddesc->padding = 0;
+    flddesc->flags.haspadding = haspadding;
+    flddesc->flags.fielddesc_type = fielddesc_type;
+    flddesc->flags.arrayelem_isboxed = arrayelem == 1;
+    flddesc->flags.arrayelem_isunion = arrayelem == 2;
+    flddesc->flags.padding = 0;
     flddesc->npointers = npointers;
-    flddesc->first_ptr = (npointers > 0 ? pointers[0] : -1);
+    flddesc->first_ptr = first_ptr;
 
     // fill out the fields of the new descriptor
     jl_fielddesc8_t *desc8 = (jl_fielddesc8_t *)jl_dt_layout_fields(flddesc);
@@ -248,18 +253,20 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t sz,
             desc32[i].isptr = desc[i].isptr;
         }
     }
-    uint8_t *ptrs8 = (uint8_t *)jl_dt_layout_ptrs(flddesc);
-    uint16_t *ptrs16 = (uint16_t *)jl_dt_layout_ptrs(flddesc);
-    uint32_t *ptrs32 = (uint32_t *)jl_dt_layout_ptrs(flddesc);
-    for (size_t i = 0; i < npointers; i++) {
-        if (fielddesc_type == 0) {
-            ptrs8[i] = pointers[i];
-        }
-        else if (fielddesc_type == 1) {
-            ptrs16[i] = pointers[i];
-        }
-        else {
-            ptrs32[i] = pointers[i];
+    if (first_ptr >= 0) {
+        uint8_t *ptrs8 = (uint8_t *)jl_dt_layout_ptrs(flddesc);
+        uint16_t *ptrs16 = (uint16_t *)jl_dt_layout_ptrs(flddesc);
+        uint32_t *ptrs32 = (uint32_t *)jl_dt_layout_ptrs(flddesc);
+        for (size_t i = 0; i < npointers; i++) {
+            if (fielddesc_type == 0) {
+                ptrs8[i] = pointers[i];
+            }
+            else if (fielddesc_type == 1) {
+                ptrs16[i] = pointers[i];
+            }
+            else {
+                ptrs32[i] = pointers[i];
+            }
         }
     }
 
@@ -318,23 +325,23 @@ unsigned jl_special_vector_alignment(size_t nfields, jl_value_t *t)
 
 STATIC_INLINE int jl_is_datatype_make_singleton(jl_datatype_t *d) JL_NOTSAFEPOINT
 {
-    return (!d->name->abstract && jl_datatype_size(d) == 0 && d != jl_symbol_type && d->name != jl_array_typename &&
-            d->isconcretetype && !d->name->mutabl);
+    return d->isconcretetype && jl_datatype_size(d) == 0 && d->layout->npointers == 0 && !d->name->mutabl; // implies jl_is_layout_opaque
 }
 
 STATIC_INLINE void jl_maybe_allocate_singleton_instance(jl_datatype_t *st) JL_NOTSAFEPOINT
 {
+    // It's possible for st to already have an ->instance if it was redefined
+    if (st->instance)
+        return;
     if (jl_is_datatype_make_singleton(st)) {
-        // It's possible for st to already have an ->instance if it was redefined
-        if (!st->instance)
-            st->instance = jl_gc_permobj(0, st);
+        st->instance = jl_gc_permobj(0, st);
     }
 }
 
 // return whether all concrete subtypes of this type have the same layout
 int jl_struct_try_layout(jl_datatype_t *dt)
 {
-    if (dt->layout)
+    if (dt->layout || jl_is_genericmemory_type(dt))
         return 1;
     else if (!jl_has_fixed_layout(dt))
         return 0;
@@ -352,7 +359,7 @@ int jl_datatype_isinlinealloc(jl_datatype_t *ty, int pointerfree)
                 return 0;
             if (ty->name->n_uninitialized != 0)
                 return 0;
-            if (ty->layout->fielddesc_type > 1) // GC only implements support for 8 and 16 (not array32)
+            if (ty->layout->flags.fielddesc_type > 1) // GC only implements support for 8 and 16 (not array32)
                 return 0;
         }
         return 1;
@@ -478,6 +485,85 @@ static int is_type_identityfree(jl_value_t *t)
     return 0;
 }
 
+// make a copy of the layout of st, but with nfields=0
+void jl_get_genericmemory_layout(jl_datatype_t *st)
+{
+    jl_value_t *isatomic = jl_tparam0(st);
+    jl_value_t *eltype = jl_tparam1(st);
+    jl_value_t *addrspace = jl_tparam2(st);
+    if (!jl_is_typevar(eltype) && !jl_is_type(eltype)) {
+        // this is expected to have a layout, but since it is not constructable, we don't care too much what it is
+        static const jl_datatype_layout_t opaque_ptr_layout = {0, 0, 1, -1, sizeof(void*), {0}};
+        st->layout = &opaque_ptr_layout;
+        st->has_concrete_subtype = 0;
+        return;
+    }
+
+    size_t elsz = 0, al = 0;
+    int isunboxed = jl_islayout_inline(eltype, &elsz, &al);
+    int isunion = isunboxed && jl_is_uniontype(eltype);
+    int haspadding = 1; // we may want to eventually actually compute this
+    int nfields = 0; // aka jl_is_layout_opaque
+    int npointers = 1;
+    int zi;
+    uint32_t first_ptr = -1;
+    uint32_t *pointers = &first_ptr;
+
+    if (isunboxed) {
+        elsz = LLT_ALIGN(elsz, al);
+        if (isunion) {
+            zi = 1;
+        }
+        else {
+            assert(jl_is_datatype(eltype));
+            zi = ((jl_datatype_t*)eltype)->zeroinit;
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)eltype)->layout;
+            if (layout->first_ptr >= 0) {
+                first_ptr = layout->first_ptr;
+                npointers = layout->npointers;
+                if (layout->flags.fielddesc_type == 2) {
+                    pointers = (uint32_t*)jl_dt_layout_ptrs(layout);
+                }
+                else {
+                    pointers = (uint32_t*)alloca(npointers * sizeof(uint32_t));
+                    for (int j = 0; j < npointers; j++) {
+                        pointers[j] = jl_ptr_offset((jl_datatype_t*)eltype, j);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        elsz = sizeof(void*);
+        al = elsz;
+        zi = 1;
+    }
+
+    int arrayelem;
+    if (!isunboxed)
+        arrayelem = 1;
+    else if (isunion)
+        arrayelem = 2;
+    else
+        arrayelem = 0;
+    assert(!st->layout);
+    st->layout = jl_get_layout(elsz, nfields, npointers, al, haspadding, arrayelem, NULL, pointers);
+    st->zeroinit = zi;
+    //st->has_concrete_subtype = 1;
+    //st->isbitstype = 0;
+    //st->ismutationfree = 0;
+    //st->isidentityfree = 0;
+
+    if (isatomic == (jl_value_t*)jl_not_atomic_sym && jl_is_addrspacecore(addrspace) && jl_unbox_uint8(addrspace) == 0) {
+        jl_genericmemory_t *zeroinst = (jl_genericmemory_t*)jl_gc_permobj(LLT_ALIGN(sizeof(jl_genericmemory_t), JL_SMALL_BYTE_ALIGNMENT) + (elsz ? elsz : isunion), st);
+        zeroinst->length = 0;
+        zeroinst->ptr = (char*)zeroinst + JL_SMALL_BYTE_ALIGNMENT;
+        memset(zeroinst->ptr, 0, elsz ? elsz : isunion);
+        assert(!st->instance);
+        st->instance = (jl_value_t*)zeroinst;
+    }
+}
+
 void jl_compute_field_offsets(jl_datatype_t *st)
 {
     const uint64_t max_offset = (((uint64_t)1) << 32) - 1;
@@ -492,6 +578,10 @@ void jl_compute_field_offsets(jl_datatype_t *st)
         st->zeroinit = 0;
         st->has_concrete_subtype = 1;
     }
+    if (st->name == jl_genericmemory_typename) {
+        jl_get_genericmemory_layout(st);
+        return;
+    }
     int isbitstype = st->isconcretetype && st->name->mayinlinealloc;
     int ismutationfree = !w->layout || !jl_is_layout_opaque(w->layout);
     int isidentityfree = !st->name->mutabl;
@@ -501,7 +591,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
         st->layout = w->layout;
         st->zeroinit = w->zeroinit;
         st->has_concrete_subtype = w->has_concrete_subtype;
-        if (!jl_is_layout_opaque(st->layout)) { // e.g. jl_array_typename
+        if (!jl_is_layout_opaque(st->layout)) { // e.g. jl_simplevector_type
             st->isbitstype = isbitstype && st->layout->npointers == 0;
             jl_maybe_allocate_singleton_instance(st);
         }
@@ -514,18 +604,18 @@ void jl_compute_field_offsets(jl_datatype_t *st)
         // if we have no fields, we can trivially skip the rest
         if (st == jl_symbol_type || st == jl_string_type) {
             // opaque layout - heap-allocated blob
-            static const jl_datatype_layout_t opaque_byte_layout = {0, 0, 1, -1, 1, 0, 0};
+            static const jl_datatype_layout_t opaque_byte_layout = {0, 0, 1, -1, 1, {0}};
             st->layout = &opaque_byte_layout;
             return;
         }
-        else if (st == jl_simplevector_type || st == jl_module_type || st->name == jl_array_typename) {
-            static const jl_datatype_layout_t opaque_ptr_layout = {0, 0, 1, -1, sizeof(void*), 0, 0};
+        else if (st == jl_simplevector_type || st == jl_module_type) {
+            static const jl_datatype_layout_t opaque_ptr_layout = {0, 0, 1, -1, sizeof(void*), {0}};
             st->layout = &opaque_ptr_layout;
             return;
         }
         else {
             // reuse the same layout for all singletons
-            static const jl_datatype_layout_t singleton_layout = {0, 0, 0, -1, 1, 0, 0};
+            static const jl_datatype_layout_t singleton_layout = {0, 0, 0, -1, 1, {0}};
             st->layout = &singleton_layout;
         }
     }
@@ -586,7 +676,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
                 }
                 else {
                     uint32_t fld_npointers = ((jl_datatype_t*)fld)->layout->npointers;
-                    if (((jl_datatype_t*)fld)->layout->haspadding)
+                    if (((jl_datatype_t*)fld)->layout->flags.haspadding)
                         haspadding = 1;
                     if (i >= nfields - st->name->n_uninitialized && fld_npointers &&
                         fld_npointers * sizeof(void*) != fsz) {
@@ -670,7 +760,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
             }
         }
         assert(ptr_i == npointers);
-        st->layout = jl_get_layout(sz, nfields, npointers, alignm, haspadding, desc, pointers);
+        st->layout = jl_get_layout(sz, nfields, npointers, alignm, haspadding, 0, desc, pointers);
         if (should_malloc) {
             free(desc);
             if (npointers)
@@ -710,7 +800,7 @@ JL_DLLEXPORT jl_datatype_t *jl_new_datatype(
     jl_typename_t *tn = NULL;
     JL_GC_PUSH2(&t, &tn);
 
-    assert(parameters);
+    assert(parameters && fnames);
 
     // init enough before possibly calling jl_new_typename_in
     t = jl_new_uninitialized_datatype();
@@ -832,7 +922,7 @@ JL_DLLEXPORT jl_datatype_t *jl_new_primitivetype(jl_value_t *name, jl_module_t *
     bt->ismutationfree = 1;
     bt->isidentityfree = 1;
     bt->isbitstype = (parameters == jl_emptysvec);
-    bt->layout = jl_get_layout(nbytes, 0, 0, alignm, 0, NULL, NULL);
+    bt->layout = jl_get_layout(nbytes, 0, 0, alignm, 0, 0, NULL, NULL);
     bt->instance = NULL;
     return bt;
 }
@@ -853,10 +943,12 @@ JL_DLLEXPORT jl_datatype_t * jl_new_foreign_type(jl_sym_t *name,
     layout->size = large ? GC_MAX_SZCLASS+1 : 0;
     layout->nfields = 0;
     layout->alignment = sizeof(void *);
-    layout->haspadding = 1;
     layout->npointers = haspointers;
-    layout->fielddesc_type = 3;
-    layout->padding = 0;
+    layout->flags.haspadding = 1;
+    layout->flags.fielddesc_type = 3;
+    layout->flags.padding = 0;
+    layout->flags.arrayelem_isboxed = 0;
+    layout->flags.arrayelem_isunion = 0;
     jl_fielddescdyn_t * desc =
       (jl_fielddescdyn_t *) ((char *)layout + sizeof(*layout));
     desc->markfunc = markfunc;
@@ -884,7 +976,7 @@ JL_DLLEXPORT int jl_reinit_foreign_type(jl_datatype_t *dt,
 
 JL_DLLEXPORT int jl_is_foreign_type(jl_datatype_t *dt)
 {
-    return jl_is_datatype(dt) && dt->layout && dt->layout->fielddesc_type == 3;
+    return jl_is_datatype(dt) && dt->layout && dt->layout->flags.fielddesc_type == 3;
 }
 
 // bits constructors ----------------------------------------------------------
@@ -1136,7 +1228,7 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t
     }
     else if (nb == 1) {
         uint8_t *y8 = (uint8_t*)y;
-        assert(!dt->layout->haspadding);
+        assert(!dt->layout->flags.haspadding);
         if (dt == et) {
             *y8 = *(uint8_t*)expected;
             uint8_t z8 = *(uint8_t*)src;
@@ -1149,7 +1241,7 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t
     }
     else if (nb == 2) {
         uint16_t *y16 = (uint16_t*)y;
-        assert(!dt->layout->haspadding);
+        assert(!dt->layout->flags.haspadding);
         if (dt == et) {
             *y16 = *(uint16_t*)expected;
             uint16_t z16 = *(uint16_t*)src;
@@ -1167,7 +1259,7 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t
             uint32_t z32 = zext_read32(src, nb);
             while (1) {
                 success = jl_atomic_cmpswap((_Atomic(uint32_t)*)dst, y32, z32);
-                if (success || !dt->layout->haspadding || !jl_egal__bits(y, expected, dt))
+                if (success || !dt->layout->flags.haspadding || !jl_egal__bits(y, expected, dt))
                     break;
             }
         }
@@ -1184,7 +1276,7 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t
             uint64_t z64 = zext_read64(src, nb);
             while (1) {
                 success = jl_atomic_cmpswap((_Atomic(uint64_t)*)dst, y64, z64);
-                if (success || !dt->layout->haspadding || !jl_egal__bits(y, expected, dt))
+                if (success || !dt->layout->flags.haspadding || !jl_egal__bits(y, expected, dt))
                     break;
             }
         }
@@ -1202,7 +1294,7 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t
             jl_uint128_t z128 = zext_read128(src, nb);
             while (1) {
                 success = jl_atomic_cmpswap((_Atomic(jl_uint128_t)*)dst, y128, z128);
-                if (success || !dt->layout->haspadding || !jl_egal__bits(y, expected, dt))
+                if (success || !dt->layout->flags.haspadding || !jl_egal__bits(y, expected, dt))
                     break;
             }
         }
@@ -1227,18 +1319,6 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t
     return y;
 }
 
-// used by boot.jl
-JL_DLLEXPORT jl_value_t *jl_typemax_uint(jl_datatype_t *bt)
-{
-    uint64_t data = 0xffffffffffffffffULL;
-    jl_task_t *ct = jl_current_task;
-    jl_value_t *v = jl_gc_alloc(ct->ptls, sizeof(size_t), bt);
-    if (bt->smalltag)
-        jl_set_typetagof(v, bt->smalltag, 0);
-    memcpy(v, &data, sizeof(size_t));
-    return v;
-}
-
 #define PERMBOXN_FUNC(nb)                                               \
     jl_value_t *jl_permbox##nb(jl_datatype_t *t, uintptr_t tag, uint##nb##_t x) \
     {   /* n.b. t must be a concrete isbits datatype of the right size */ \
@@ -1359,6 +1439,9 @@ void jl_init_int32_int64_cache(void)
     for(i=0; i < NBOX_C; i++) {
         boxed_int32_cache[i]  = jl_permbox32(jl_int32_type, jl_int32_tag, i-NBOX_C/2);
         boxed_int64_cache[i]  = jl_permbox64(jl_int64_type, jl_int64_tag, i-NBOX_C/2);
+        boxed_uint16_cache[i] = jl_permbox16(jl_uint16_type, jl_uint16_tag, i);
+        boxed_uint64_cache[i] = jl_permbox64(jl_uint64_type, jl_uint64_tag, i);
+        boxed_uint32_cache[i] = jl_permbox32(jl_uint32_type, jl_uint32_tag, i);
 #ifdef _P64
         boxed_ssavalue_cache[i] = jl_permbox64(jl_ssavalue_type, 0, i);
         boxed_slotnumber_cache[i] = jl_permbox64(jl_slotnumber_type, 0, i);
@@ -1383,9 +1466,6 @@ void jl_init_box_caches(void)
     }
     for (i = 0; i < NBOX_C; i++) {
         boxed_int16_cache[i]  = jl_permbox16(jl_int16_type, jl_int16_tag, i-NBOX_C/2);
-        boxed_uint16_cache[i] = jl_permbox16(jl_uint16_type, jl_uint16_tag, i);
-        boxed_uint32_cache[i] = jl_permbox32(jl_uint32_type, jl_uint32_tag, i);
-        boxed_uint64_cache[i] = jl_permbox64(jl_uint64_type, jl_uint64_tag, i);
     }
 }
 
@@ -1401,10 +1481,11 @@ JL_DLLEXPORT jl_value_t *jl_box_bool(int8_t x)
 JL_DLLEXPORT jl_value_t *jl_new_struct(jl_datatype_t *type, ...)
 {
     jl_task_t *ct = jl_current_task;
-    if (type->instance != NULL) return type->instance;
-    if (!jl_is_datatype(type) || !type->isconcretetype || type->layout == NULL) {
+    if (!jl_is_datatype(type) || !type->isconcretetype || type->layout == NULL || jl_is_layout_opaque(type->layout)) {
         jl_type_error("new", (jl_value_t*)jl_datatype_type, (jl_value_t*)type);
     }
+    if (type->instance != NULL)
+        return type->instance;
     va_list args;
     size_t i, nf = jl_datatype_nfields(type);
     va_start(args, type);
@@ -1424,7 +1505,7 @@ JL_DLLEXPORT jl_value_t *jl_new_struct(jl_datatype_t *type, ...)
 JL_DLLEXPORT jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args, uint32_t na)
 {
     jl_task_t *ct = jl_current_task;
-    if (!jl_is_datatype(type) || !type->isconcretetype || type->layout == NULL) {
+    if (!jl_is_datatype(type) || !type->isconcretetype || type->layout == NULL || jl_is_layout_opaque(type->layout)) {
         jl_type_error("new", (jl_value_t*)jl_datatype_type, (jl_value_t*)type);
     }
     size_t nf = jl_datatype_nfields(type);
@@ -1463,7 +1544,7 @@ JL_DLLEXPORT jl_value_t *jl_new_structt(jl_datatype_t *type, jl_value_t *tup)
     jl_task_t *ct = jl_current_task;
     if (!jl_is_tuple(tup))
         jl_type_error("new", (jl_value_t*)jl_tuple_type, tup);
-    if (!jl_is_datatype(type) || !type->isconcretetype || type->layout == NULL)
+    if (!jl_is_datatype(type) || !type->isconcretetype || type->layout == NULL || jl_is_layout_opaque(type->layout))
         jl_type_error("new", (jl_value_t *)jl_datatype_type, (jl_value_t *)type);
     size_t nargs = jl_nfields(tup);
     size_t nf = jl_datatype_nfields(type);
@@ -1510,10 +1591,11 @@ JL_DLLEXPORT jl_value_t *jl_new_structt(jl_datatype_t *type, jl_value_t *tup)
 JL_DLLEXPORT jl_value_t *jl_new_struct_uninit(jl_datatype_t *type)
 {
     jl_task_t *ct = jl_current_task;
-    if (type->instance != NULL) return type->instance;
-    if (!jl_is_datatype(type) || type->layout == NULL) {
+    if (!jl_is_datatype(type) || !type->isconcretetype || type->layout == NULL || jl_is_layout_opaque(type->layout)) {
         jl_type_error("new", (jl_value_t*)jl_datatype_type, (jl_value_t*)type);
     }
+    if (type->instance != NULL)
+        return type->instance;
     size_t size = jl_datatype_size(type);
     jl_value_t *jv = jl_gc_alloc(ct->ptls, size, type);
     if (type->smalltag) // TODO: do we need this?
@@ -1623,7 +1705,7 @@ static inline void memassign_safe(int hasptr, jl_value_t *parent, char *dst, con
         // assert that although dst might have some undefined bits, the src heap box should be okay with that
         assert(LLT_ALIGN(nb, sizeof(void*)) == LLT_ALIGN(jl_datatype_size(jl_typeof(src)), sizeof(void*)));
         size_t nptr = nb / sizeof(void*);
-        memmove_refs((void**)dst, (void**)src, nptr);
+        memmove_refs((_Atomic(void*)*)dst, (_Atomic(void*)*)src, nptr);
         jl_gc_multi_wb(parent, src);
         src = (jl_value_t*)((char*)src + nptr * sizeof(void*));
         dst = dst + nptr * sizeof(void*);
@@ -1722,6 +1804,7 @@ jl_value_t *swap_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_
         }
         else {
             hasptr = ((jl_datatype_t*)ty)->layout->npointers > 0;
+            r = NULL;
         }
         size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
         int needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
@@ -1902,7 +1985,7 @@ jl_value_t *replace_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_val
             memcpy((char*)r, (char*)v + offs, fsz); // copy field, including union bits
             if (success) {
                 size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
-                if (((jl_datatype_t*)rty)->layout->haspadding)
+                if (((jl_datatype_t*)rty)->layout->flags.haspadding)
                     success = jl_egal__bits(r, expected, (jl_datatype_t*)rty);
                 else
                     success = memcmp((char*)r, (char*)expected, fsz) == 0;
diff --git a/src/dlload.c b/src/dlload.c
index 8124605880b5e..f2ba02e14c5d1 100644
--- a/src/dlload.c
+++ b/src/dlload.c
@@ -312,7 +312,7 @@ JL_DLLEXPORT void *jl_load_dynamic_library(const char *modname, unsigned flags,
         jl_array_t *DL_LOAD_PATH = (jl_array_t*)(b ? jl_atomic_load_relaxed(&b->value) : NULL);
         if (DL_LOAD_PATH != NULL) {
             size_t j;
-            for (j = 0; j < jl_array_len(DL_LOAD_PATH); j++) {
+            for (j = 0; j < jl_array_nrows(DL_LOAD_PATH); j++) {
                 char *dl_path = jl_string_data(jl_array_ptr_data(DL_LOAD_PATH)[j]);
                 size_t len = strlen(dl_path);
                 if (len == 0)
diff --git a/src/gc-debug.c b/src/gc-debug.c
index 7145531828853..87861a5d89b9c 100644
--- a/src/gc-debug.c
+++ b/src/gc-debug.c
@@ -616,8 +616,7 @@ void objprofile_count(void *ty, int old, int sz)
         ty = (void*)jl_buff_tag;
     }
     else if (ty != (void*)jl_buff_tag && ty != jl_malloc_tag &&
-             jl_typeof(ty) == (jl_value_t*)jl_datatype_type &&
-             ((jl_datatype_t*)ty)->instance) {
+             jl_is_datatype(ty) && jl_is_datatype_singleton((jl_datatype_t*)ty)) {
         ty = jl_singleton_tag;
     }
     void **bp = ptrhash_bp(&obj_counts[old], ty);
@@ -894,29 +893,29 @@ void gc_time_big_end(void)
                    t_ms, big_freed, big_total, big_reset);
 }
 
-static int64_t mallocd_array_total;
-static int64_t mallocd_array_freed;
-static int64_t mallocd_array_sweep_start;
+static int64_t mallocd_memory_total;
+static int64_t mallocd_memory_freed;
+static int64_t mallocd_memory_sweep_start;
 
-void gc_time_mallocd_array_start(void)
+void gc_time_mallocd_memory_start(void)
 {
-    mallocd_array_total = 0;
-    mallocd_array_freed = 0;
-    mallocd_array_sweep_start = jl_hrtime();
+    mallocd_memory_total = 0;
+    mallocd_memory_freed = 0;
+    mallocd_memory_sweep_start = jl_hrtime();
 }
 
-void gc_time_count_mallocd_array(int bits)
+void gc_time_count_mallocd_memory(int bits)
 {
-    mallocd_array_total++;
-    mallocd_array_freed += !gc_marked(bits);
+    mallocd_memory_total++;
+    mallocd_memory_freed += !gc_marked(bits);
 }
 
-void gc_time_mallocd_array_end(void)
+void gc_time_mallocd_memory_end(void)
 {
-    double t_ms = jl_ns2ms(jl_hrtime() - mallocd_array_sweep_start);
+    double t_ms = jl_ns2ms(jl_hrtime() - mallocd_memory_sweep_start);
     jl_safe_printf("GC sweep arrays %.2f ms "
                    "(freed %" PRId64 " / %" PRId64 ")\n",
-                   t_ms, mallocd_array_freed, mallocd_array_total);
+                   t_ms, mallocd_memory_freed, mallocd_memory_total);
 }
 
 void gc_time_mark_pause(int64_t t0, int64_t scanned_bytes,
@@ -1111,7 +1110,7 @@ void gc_stats_big_obj(void)
         while (ma != NULL) {
             if (gc_marked(jl_astaggedvalue(ma->a)->bits.gc)) {
                 nused++;
-                nbytes += jl_array_nbytes(ma->a);
+                nbytes += jl_genericmemory_nbytes((jl_genericmemory_t*)ma->a);
             }
             ma = ma->next;
         }
@@ -1203,12 +1202,6 @@ int gc_slot_to_arrayidx(void *obj, void *_slot) JL_NOTSAFEPOINT
         start = (char*)jl_svec_data(obj);
         len = jl_svec_len(obj);
     }
-    else if (vt->name == jl_array_typename) {
-        jl_array_t *a = (jl_array_t*)obj;
-        start = (char*)a->data;
-        len = jl_array_len(a);
-        elsize = a->elsize;
-    }
     if (slot < start || slot >= start + elsize * len)
         return -1;
     return (slot - start) / elsize;
diff --git a/src/gc-stacks.c b/src/gc-stacks.c
index 6f97323f22528..86c1c8a573a68 100644
--- a/src/gc-stacks.c
+++ b/src/gc-stacks.c
@@ -298,7 +298,7 @@ JL_DLLEXPORT jl_array_t *jl_live_tasks(void)
         if (t->stkbuf != NULL) {
             if (j == l)
                 goto restart;
-            ((void**)jl_array_data(a))[j++] = t;
+            jl_array_data(a,void*)[j++] = t;
         }
         small_arraylist_t *live_tasks = &ptls2->heap.live_tasks;
         size_t n = mtarraylist_length(live_tasks);
@@ -307,7 +307,7 @@ JL_DLLEXPORT jl_array_t *jl_live_tasks(void)
             if (t->stkbuf != NULL) {
                 if (j == l)
                     goto restart;
-                ((void**)jl_array_data(a))[j++] = t;
+                jl_array_data(a,void*)[j++] = t;
             }
         }
     }
diff --git a/src/gc.c b/src/gc.c
index baa533011ad65..0c046aa680e9c 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1129,10 +1129,9 @@ static void sweep_big(jl_ptls_t ptls, int sweep_full) JL_NOTSAFEPOINT
     gc_time_big_end();
 }
 
-// tracking Arrays with malloc'd storage
+// tracking Memorys with malloc'd storage
 
-void jl_gc_track_malloced_array(jl_ptls_t ptls, jl_array_t *a) JL_NOTSAFEPOINT
-{
+void jl_gc_track_malloced_genericmemory(jl_ptls_t ptls, jl_genericmemory_t *m, int isaligned){
     // This is **NOT** a GC safe point.
     mallocarray_t *ma;
     if (ptls->heap.mafreelist == NULL) {
@@ -1142,11 +1141,12 @@ void jl_gc_track_malloced_array(jl_ptls_t ptls, jl_array_t *a) JL_NOTSAFEPOINT
         ma = ptls->heap.mafreelist;
         ptls->heap.mafreelist = ma->next;
     }
-    ma->a = a;
+    ma->a = (jl_value_t*)((uintptr_t)m | !!isaligned);
     ma->next = ptls->heap.mallocarrays;
     ptls->heap.mallocarrays = ma;
 }
 
+
 void jl_gc_count_allocd(size_t sz) JL_NOTSAFEPOINT
 {
     jl_ptls_t ptls = jl_current_task->ptls;
@@ -1215,38 +1215,37 @@ void jl_gc_reset_alloc_count(void) JL_NOTSAFEPOINT
     reset_thread_gc_counts();
 }
 
-size_t jl_array_nbytes(jl_array_t *a) JL_NOTSAFEPOINT
+size_t jl_genericmemory_nbytes(jl_genericmemory_t *m) JL_NOTSAFEPOINT
 {
-    size_t sz = 0;
-    int isbitsunion = jl_array_isbitsunion(a);
-    if (jl_array_ndims(a) == 1)
-        sz = a->elsize * a->maxsize + ((a->elsize == 1 && !isbitsunion) ? 1 : 0);
-    else
-        sz = a->elsize * jl_array_len(a);
-    if (isbitsunion)
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
+    size_t sz = layout->size * m->length;
+    if (layout->flags.arrayelem_isunion)
         // account for isbits Union array selector bytes
-        sz += jl_array_len(a);
+        sz += m->length;
     return sz;
 }
 
-static void jl_gc_free_array(jl_array_t *a) JL_NOTSAFEPOINT
+
+static void jl_gc_free_memory(jl_value_t *v, int isaligned) JL_NOTSAFEPOINT
 {
-    if (a->flags.how == 2) {
-        char *d = (char*)a->data - a->offset*a->elsize;
-        if (a->flags.isaligned)
-            jl_free_aligned(d);
-        else
-            free(d);
-        jl_atomic_store_relaxed(&gc_heap_stats.heap_size,
-            jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - jl_array_nbytes(a));
-        gc_num.freed += jl_array_nbytes(a);
-        gc_num.freecall++;
-    }
+    assert(jl_is_genericmemory(v));
+    jl_genericmemory_t *m = (jl_genericmemory_t*)v;
+    assert(jl_genericmemory_how(m) == 1 || jl_genericmemory_how(m) == 2);
+    char *d = (char*)m->ptr;
+    if (isaligned)
+        jl_free_aligned(d);
+    else
+        free(d);
+    jl_atomic_store_relaxed(&gc_heap_stats.heap_size,
+        jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - jl_genericmemory_nbytes(m));
+    gc_num.freed += jl_genericmemory_nbytes(m);
+    gc_num.freecall++;
+    gc_num.freecall++;
 }
 
-static void sweep_malloced_arrays(void) JL_NOTSAFEPOINT
+static void sweep_malloced_memory(void) JL_NOTSAFEPOINT
 {
-    gc_time_mallocd_array_start();
+    gc_time_mallocd_memory_start();
     assert(gc_n_threads);
     for (int t_i = 0; t_i < gc_n_threads; t_i++) {
         jl_ptls_t ptls2 = gc_all_tls_states[t_i];
@@ -1255,23 +1254,24 @@ static void sweep_malloced_arrays(void) JL_NOTSAFEPOINT
             mallocarray_t **pma = &ptls2->heap.mallocarrays;
             while (ma != NULL) {
                 mallocarray_t *nxt = ma->next;
-                int bits = jl_astaggedvalue(ma->a)->bits.gc;
+                jl_value_t *a = (jl_value_t*)((uintptr_t)ma->a & ~1);
+                int bits = jl_astaggedvalue(a)->bits.gc;
                 if (gc_marked(bits)) {
                     pma = &ma->next;
                 }
                 else {
                     *pma = nxt;
-                    assert(ma->a->flags.how == 2);
-                    jl_gc_free_array(ma->a);
+                    int isaligned = (uintptr_t)ma->a & 1;
+                    jl_gc_free_memory(a, isaligned);
                     ma->next = ptls2->heap.mafreelist;
                     ptls2->heap.mafreelist = ma;
                 }
-                gc_time_count_mallocd_array(bits);
+                gc_time_count_mallocd_memory(bits);
                 ma = nxt;
             }
         }
     }
-    gc_time_mallocd_array_end();
+    gc_time_mallocd_memory_end();
 }
 
 // pool allocation
@@ -1539,7 +1539,7 @@ STATIC_INLINE void gc_sweep_pool_page(jl_gc_page_stack_t *allocd, jl_gc_page_sta
 // sweep over all memory that is being used and not in a pool
 static void gc_sweep_other(jl_ptls_t ptls, int sweep_full) JL_NOTSAFEPOINT
 {
-    sweep_malloced_arrays();
+    sweep_malloced_memory();
     sweep_big(ptls, sweep_full);
 }
 
@@ -1755,11 +1755,8 @@ JL_DLLEXPORT void jl_gc_queue_root(const jl_value_t *ptr)
     ptls->heap.remset_nptr++; // conservative
 }
 
-void jl_gc_queue_multiroot(const jl_value_t *parent, const jl_value_t *ptr) JL_NOTSAFEPOINT
+void jl_gc_queue_multiroot(const jl_value_t *parent, const void *ptr, jl_datatype_t *dt) JL_NOTSAFEPOINT
 {
-    // first check if this is really necessary
-    // TODO: should we store this info in one of the extra gc bits?
-    jl_datatype_t *dt = (jl_datatype_t*)jl_typeof(ptr);
     const jl_datatype_layout_t *ly = dt->layout;
     uint32_t npointers = ly->npointers;
     //if (npointers == 0) // this was checked by the caller
@@ -1775,14 +1772,14 @@ void jl_gc_queue_multiroot(const jl_value_t *parent, const jl_value_t *ptr) JL_N
     const uint32_t *ptrs32 = (const uint32_t*)jl_dt_layout_ptrs(ly);
     for (size_t i = 1; i < npointers; i++) {
         uint32_t fld;
-        if (ly->fielddesc_type == 0) {
+        if (ly->flags.fielddesc_type == 0) {
             fld = ptrs8[i];
         }
-        else if (ly->fielddesc_type == 1) {
+        else if (ly->flags.fielddesc_type == 1) {
             fld = ptrs16[i];
         }
         else {
-            assert(ly->fielddesc_type == 2);
+            assert(ly->flags.fielddesc_type == 2);
             fld = ptrs32[i];
         }
         jl_value_t *ptrf = ((jl_value_t**)ptr)[fld];
@@ -2058,6 +2055,7 @@ STATIC_INLINE void gc_mark_objarray(jl_ptls_t ptls, jl_value_t *obj_parent, jl_v
     jl_gc_markqueue_t *mq = &ptls->mark_queue;
     jl_value_t *new_obj;
     // Decide whether need to chunk objary
+    assert(step > 0);
     (void)jl_assume(step > 0);
     if ((nptr & 0x2) == 0x2) {
         // pre-scan this object: most of this object should be old, so look for
@@ -2118,14 +2116,14 @@ STATIC_INLINE void gc_mark_objarray(jl_ptls_t ptls, jl_value_t *obj_parent, jl_v
 }
 
 // Mark array with 8bit field descriptors
-STATIC_INLINE void gc_mark_array8(jl_ptls_t ptls, jl_value_t *ary8_parent, jl_value_t **ary8_begin,
-                    jl_value_t **ary8_end, uint8_t *elem_begin, uint8_t *elem_end,
+STATIC_INLINE void gc_mark_memory8(jl_ptls_t ptls, jl_value_t *ary8_parent, jl_value_t **ary8_begin,
+                    jl_value_t **ary8_end, uint8_t *elem_begin, uint8_t *elem_end, uintptr_t elsize,
                     uintptr_t nptr) JL_NOTSAFEPOINT
 {
     jl_gc_markqueue_t *mq = &ptls->mark_queue;
     jl_value_t *new_obj;
-    size_t elsize = ((jl_array_t *)ary8_parent)->elsize / sizeof(jl_value_t *);
     assert(elsize > 0);
+    (void)jl_assume(elsize > 0);
     // Decide whether need to chunk objary
     if ((nptr & 0x2) == 0x2) {
         // pre-scan this object: most of this object should be old, so look for
@@ -2165,7 +2163,7 @@ STATIC_INLINE void gc_mark_array8(jl_ptls_t ptls, jl_value_t *ary8_parent, jl_va
         // case 2: lowest two bits of `nptr` are already set to 0x3, so won't change after
         // scanning the array elements
         if ((nptr & 0x2) != 0x2 || (nptr & 0x3) == 0x3) {
-            jl_gc_chunk_t c = {GC_ary8_chunk, ary8_parent, scan_end, ary8_end, elem_begin, elem_end, 0, nptr};
+            jl_gc_chunk_t c = {GC_ary8_chunk, ary8_parent, scan_end, ary8_end, elem_begin, elem_end, elsize, nptr};
             gc_chunkqueue_push(mq, &c);
             pushed_chunk = 1;
         }
@@ -2185,7 +2183,7 @@ STATIC_INLINE void gc_mark_array8(jl_ptls_t ptls, jl_value_t *ary8_parent, jl_va
     }
     if (too_big) {
         if (!pushed_chunk) {
-            jl_gc_chunk_t c = {GC_ary8_chunk, ary8_parent, scan_end, ary8_end, elem_begin, elem_end, 0, nptr};
+            jl_gc_chunk_t c = {GC_ary8_chunk, ary8_parent, scan_end, ary8_end, elem_begin, elem_end, elsize, nptr};
             gc_chunkqueue_push(mq, &c);
         }
     }
@@ -2195,14 +2193,14 @@ STATIC_INLINE void gc_mark_array8(jl_ptls_t ptls, jl_value_t *ary8_parent, jl_va
 }
 
 // Mark array with 16bit field descriptors
-STATIC_INLINE void gc_mark_array16(jl_ptls_t ptls, jl_value_t *ary16_parent, jl_value_t **ary16_begin,
-                     jl_value_t **ary16_end, uint16_t *elem_begin, uint16_t *elem_end,
+STATIC_INLINE void gc_mark_memory16(jl_ptls_t ptls, jl_value_t *ary16_parent, jl_value_t **ary16_begin,
+                     jl_value_t **ary16_end, uint16_t *elem_begin, uint16_t *elem_end, size_t elsize,
                      uintptr_t nptr) JL_NOTSAFEPOINT
 {
     jl_gc_markqueue_t *mq = &ptls->mark_queue;
     jl_value_t *new_obj;
-    size_t elsize = ((jl_array_t *)ary16_parent)->elsize / sizeof(jl_value_t *);
     assert(elsize > 0);
+    (void)jl_assume(elsize > 0);
     // Decide whether need to chunk objary
     if ((nptr & 0x2) == 0x2) {
         // pre-scan this object: most of this object should be old, so look for
@@ -2281,8 +2279,8 @@ STATIC_INLINE void gc_mark_chunk(jl_ptls_t ptls, jl_gc_markqueue_t *mq, jl_gc_ch
             jl_value_t **obj_end = c->end;
             uint32_t step = c->step;
             uintptr_t nptr = c->nptr;
-            gc_mark_objarray(ptls, obj_parent, obj_begin, obj_end, step,
-                             nptr);
+            gc_mark_objarray(ptls, obj_parent, obj_begin, obj_end,
+                             step, nptr);
             break;
         }
         case GC_ary8_chunk: {
@@ -2291,9 +2289,10 @@ STATIC_INLINE void gc_mark_chunk(jl_ptls_t ptls, jl_gc_markqueue_t *mq, jl_gc_ch
             jl_value_t **ary8_end = c->end;
             uint8_t *elem_begin = (uint8_t *)c->elem_begin;
             uint8_t *elem_end = (uint8_t *)c->elem_end;
+            size_t elsize = c->step;
             uintptr_t nptr = c->nptr;
-            gc_mark_array8(ptls, ary8_parent, ary8_begin, ary8_end, elem_begin, elem_end,
-                           nptr);
+            gc_mark_memory8(ptls, ary8_parent, ary8_begin, ary8_end, elem_begin, elem_end,
+                           elsize, nptr);
             break;
         }
         case GC_ary16_chunk: {
@@ -2302,9 +2301,10 @@ STATIC_INLINE void gc_mark_chunk(jl_ptls_t ptls, jl_gc_markqueue_t *mq, jl_gc_ch
             jl_value_t **ary16_end = c->end;
             uint16_t *elem_begin = (uint16_t *)c->elem_begin;
             uint16_t *elem_end = (uint16_t *)c->elem_end;
+            size_t elsize = c->step;
             uintptr_t nptr = c->nptr;
-            gc_mark_array16(ptls, ary16_parent, ary16_begin, ary16_end, elem_begin, elem_end,
-                            nptr);
+            gc_mark_memory16(ptls, ary16_parent, ary16_begin, ary16_end, elem_begin, elem_end,
+                            elsize, nptr);
             break;
         }
         case GC_finlist_chunk: {
@@ -2588,7 +2588,7 @@ FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_
                     gc_mark_excstack(ptls, excstack, itr);
                 }
                 const jl_datatype_layout_t *layout = jl_task_type->layout;
-                assert(layout->fielddesc_type == 0);
+                assert(layout->flags.fielddesc_type == 0);
                 assert(layout->nfields > 0);
                 uint32_t npointers = layout->npointers;
                 char *obj8_parent = (char *)ta;
@@ -2627,72 +2627,64 @@ FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_
                 gc_dump_queue_and_abort(ptls, vt);
         }
         jl_datatype_t *vt = (jl_datatype_t *)vtag;
-        if (vt->name == jl_array_typename) {
-            jl_array_t *a = (jl_array_t *)new_obj;
-            jl_array_flags_t flags = a->flags;
+        if (vt->name == jl_genericmemory_typename) {
+            jl_genericmemory_t *m = (jl_genericmemory_t*)new_obj;
+            int pooled = 1; // The jl_genericmemory_t itself is always pooled-size, even with data attached to it
             if (update_meta) {
-                if (flags.pooled)
+                if (pooled)
                     gc_setmark_pool(ptls, o, bits);
                 else
                     gc_setmark_big(ptls, o, bits);
             }
             else if (foreign_alloc) {
-                objprofile_count(vt, bits == GC_OLD_MARKED, sizeof(jl_array_t));
+                objprofile_count(vt, bits == GC_OLD_MARKED, sizeof(jl_genericmemory_t));
             }
-            if (flags.how == 0) {
-                void *data_ptr = (char*)a + sizeof(jl_array_t) +jl_array_ndimwords(a->flags.ndims) * sizeof(size_t);
-                gc_heap_snapshot_record_hidden_edge(new_obj, data_ptr, jl_array_nbytes(a), 2);
+            int how = jl_genericmemory_how(m);
+            if (how == 0 || how == 2) {
+                gc_heap_snapshot_record_hidden_edge(new_obj, m->ptr, jl_genericmemory_nbytes(m), how == 0 ? 2 : 0);
             }
-            if (flags.how == 1) {
-                void *val_buf = jl_astaggedvalue((char*)a->data - a->offset * a->elsize);
-                verify_parent1("array", new_obj, &val_buf, "buffer ('loc' addr is meaningless)");
-                gc_heap_snapshot_record_hidden_edge(new_obj, jl_valueof(val_buf), jl_array_nbytes(a), flags.pooled);
-                (void)val_buf;
-                gc_setmark_buf_(ptls, (char*)a->data - a->offset * a->elsize,
-                                bits, jl_array_nbytes(a));
-            }
-            else if (flags.how == 2) {
+            else if (how == 1) {
                 if (update_meta || foreign_alloc) {
                     objprofile_count(jl_malloc_tag, bits == GC_OLD_MARKED,
-                                     jl_array_nbytes(a));
-                    gc_heap_snapshot_record_hidden_edge(new_obj, a->data, jl_array_nbytes(a), flags.pooled);
+                                     jl_genericmemory_nbytes(m));
+                    size_t nb = jl_genericmemory_nbytes(m);
+                    gc_heap_snapshot_record_hidden_edge(new_obj, m->ptr, nb, 0);
                     if (bits == GC_OLD_MARKED) {
-                        ptls->gc_cache.perm_scanned_bytes += jl_array_nbytes(a);
+                        ptls->gc_cache.perm_scanned_bytes += nb;
                     }
                     else {
-                        ptls->gc_cache.scanned_bytes += jl_array_nbytes(a);
+                        ptls->gc_cache.scanned_bytes += nb;
                     }
                 }
             }
-            else if (flags.how == 3) {
-                jl_value_t *owner = jl_array_data_owner(a);
+            else if (how == 3) {
+                jl_value_t *owner = jl_genericmemory_data_owner_field(m);
                 uintptr_t nptr = (1 << 2) | (bits & GC_OLD);
                 gc_try_claim_and_push(mq, owner, &nptr);
                 gc_heap_snapshot_record_internal_array_edge(new_obj, owner);
                 gc_mark_push_remset(ptls, new_obj, nptr);
                 return;
             }
-            if (!a->data || jl_array_len(a) == 0)
+            if (m->length == 0)
                 return;
-            if (flags.ptrarray) {
-                if ((jl_datatype_t *)jl_tparam0(vt) == jl_symbol_type)
+            const jl_datatype_layout_t *layout = vt->layout;
+            if (layout->flags.arrayelem_isboxed) {
+                if ((jl_datatype_t*)jl_tparam1(vt) == jl_symbol_type)
                     return;
-                size_t l = jl_array_len(a);
                 jl_value_t *objary_parent = new_obj;
-                jl_value_t **objary_begin = (jl_value_t **)a->data;
-                jl_value_t **objary_end = objary_begin + l;
+                jl_value_t **objary_begin = (jl_value_t **)m->ptr;
+                jl_value_t **objary_end = objary_begin + m->length;
                 uint32_t step = 1;
-                uintptr_t nptr = (l << 2) | (bits & GC_OLD);
+                uintptr_t nptr = (m->length << 2) | (bits & GC_OLD);
                 gc_mark_objarray(ptls, objary_parent, objary_begin, objary_end, step, nptr);
             }
-            else if (flags.hasptr) {
-                jl_datatype_t *et = (jl_datatype_t *)jl_tparam0(vt);
-                const jl_datatype_layout_t *layout = et->layout;
+            else if (layout->first_ptr >= 0) {
+                const jl_datatype_layout_t *layout = vt->layout;
                 unsigned npointers = layout->npointers;
-                unsigned elsize = a->elsize / sizeof(jl_value_t *);
-                size_t l = jl_array_len(a);
+                unsigned elsize = layout->size / sizeof(jl_value_t*);
+                size_t l = m->length;
                 jl_value_t *objary_parent = new_obj;
-                jl_value_t **objary_begin = (jl_value_t **)a->data;
+                jl_value_t **objary_begin = (jl_value_t**)m->ptr;
                 jl_value_t **objary_end = objary_begin + l * elsize;
                 uint32_t step = elsize;
                 uintptr_t nptr = ((l * npointers) << 2) | (bits & GC_OLD);
@@ -2700,17 +2692,17 @@ FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_
                     objary_begin += layout->first_ptr;
                     gc_mark_objarray(ptls, objary_parent, objary_begin, objary_end, step, nptr);
                 }
-                else if (layout->fielddesc_type == 0) {
-                    uint8_t *obj8_begin = (uint8_t *)jl_dt_layout_ptrs(layout);
+                else if (layout->flags.fielddesc_type == 0) {
+                    uint8_t *obj8_begin = (uint8_t*)jl_dt_layout_ptrs(layout);
                     uint8_t *obj8_end = obj8_begin + npointers;
-                    gc_mark_array8(ptls, objary_parent, objary_begin, objary_end, obj8_begin,
-                                   obj8_end, nptr);
+                    gc_mark_memory8(ptls, objary_parent, objary_begin, objary_end, obj8_begin, obj8_end,
+                                   elsize, nptr);
                 }
-                else if (layout->fielddesc_type == 1) {
-                    uint16_t *obj16_begin = (uint16_t *)jl_dt_layout_ptrs(layout);
+                else if (layout->flags.fielddesc_type == 1) {
+                    uint16_t *obj16_begin = (uint16_t*)jl_dt_layout_ptrs(layout);
                     uint16_t *obj16_end = obj16_begin + npointers;
-                    gc_mark_array16(ptls, objary_parent, objary_begin, objary_end, obj16_begin,
-                                    obj16_end, nptr);
+                    gc_mark_memory16(ptls, objary_parent, objary_begin, objary_end, obj16_begin, obj16_end,
+                                    elsize, nptr);
                 }
                 else {
                     assert(0 && "unimplemented");
@@ -2730,9 +2722,9 @@ FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_
         if (npointers == 0)
             return;
         uintptr_t nptr = (npointers << 2 | (bits & GC_OLD));
-        assert((layout->nfields > 0 || layout->fielddesc_type == 3) &&
+        assert((layout->nfields > 0 || layout->flags.fielddesc_type == 3) &&
                "opaque types should have been handled specially");
-        if (layout->fielddesc_type == 0) {
+        if (layout->flags.fielddesc_type == 0) {
             char *obj8_parent = (char *)new_obj;
             uint8_t *obj8_begin = (uint8_t *)jl_dt_layout_ptrs(layout);
             uint8_t *obj8_end = obj8_begin + npointers;
@@ -2745,7 +2737,7 @@ FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_
                     gc_ptr_queue_push(mq, new_obj);
             }
         }
-        else if (layout->fielddesc_type == 1) {
+        else if (layout->flags.fielddesc_type == 1) {
             char *obj16_parent = (char *)new_obj;
             uint16_t *obj16_begin = (uint16_t *)jl_dt_layout_ptrs(layout);
             uint16_t *obj16_end = obj16_begin + npointers;
@@ -2758,7 +2750,7 @@ FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_
                     gc_ptr_queue_push(mq, new_obj);
             }
         }
-        else if (layout->fielddesc_type == 2) {
+        else if (layout->flags.fielddesc_type == 2) {
             // This is very uncommon
             // Do not do store to load forwarding to save some code size
             char *obj32_parent = (char *)new_obj;
@@ -2774,7 +2766,7 @@ FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_
             }
         }
         else {
-            assert(layout->fielddesc_type == 3);
+            assert(layout->flags.fielddesc_type == 3);
             jl_fielddescdyn_t *desc = (jl_fielddescdyn_t *)jl_dt_layout_fields(layout);
             int old = jl_astaggedvalue(new_obj)->bits.gc & 2;
             uintptr_t young = desc->markfunc(ptls, new_obj);
diff --git a/src/gc.h b/src/gc.h
index 7985a3ddd43ef..4830d2d123c5d 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -137,10 +137,10 @@ JL_EXTENSION typedef struct _bigval_t {
     // must be 64-byte aligned here, in 32 & 64 bit modes
 } bigval_t;
 
-// data structure for tracking malloc'd arrays.
+// data structure for tracking malloc'd arrays and genericmemory.
 
 typedef struct _mallocarray_t {
-    jl_array_t *a;
+    jl_value_t *a;
     struct _mallocarray_t *next;
 } mallocarray_t;
 
@@ -498,9 +498,9 @@ void gc_time_big_start(void) JL_NOTSAFEPOINT;
 void gc_time_count_big(int old_bits, int bits) JL_NOTSAFEPOINT;
 void gc_time_big_end(void) JL_NOTSAFEPOINT;
 
-void gc_time_mallocd_array_start(void) JL_NOTSAFEPOINT;
-void gc_time_count_mallocd_array(int bits) JL_NOTSAFEPOINT;
-void gc_time_mallocd_array_end(void) JL_NOTSAFEPOINT;
+void gc_time_mallocd_memory_start(void) JL_NOTSAFEPOINT;
+void gc_time_count_mallocd_memory(int bits) JL_NOTSAFEPOINT;
+void gc_time_mallocd_memory_end(void) JL_NOTSAFEPOINT;
 
 void gc_time_mark_pause(int64_t t0, int64_t scanned_bytes,
                         int64_t perm_scanned_bytes);
@@ -527,12 +527,12 @@ STATIC_INLINE void gc_time_count_big(int old_bits, int bits) JL_NOTSAFEPOINT
     (void)bits;
 }
 #define gc_time_big_end()
-#define gc_time_mallocd_array_start()
-STATIC_INLINE void gc_time_count_mallocd_array(int bits) JL_NOTSAFEPOINT
+#define gc_time_mallocd_memory_start()
+STATIC_INLINE void gc_time_count_mallocd_memory(int bits) JL_NOTSAFEPOINT
 {
     (void)bits;
 }
-#define gc_time_mallocd_array_end()
+#define gc_time_mallocd_memory_end()
 #define gc_time_mark_pause(t0, scanned_bytes, perm_scanned_bytes)
 #define gc_time_sweep_pause(gc_end_t, actual_allocd, live_bytes,        \
                             estimate_freed, sweep_full)
@@ -651,7 +651,7 @@ void gc_stats_big_obj(void);
 // For debugging
 void gc_count_pool(void);
 
-size_t jl_array_nbytes(jl_array_t *a) JL_NOTSAFEPOINT;
+size_t jl_genericmemory_nbytes(jl_genericmemory_t *a) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT void jl_enable_gc_logging(int enable);
 JL_DLLEXPORT uint32_t jl_get_num_stack_mappings(void);
diff --git a/src/gen_sysimg_symtab.jl b/src/gen_sysimg_symtab.jl
index 8f03cc1560767..a91f2f994194c 100644
--- a/src/gen_sysimg_symtab.jl
+++ b/src/gen_sysimg_symtab.jl
@@ -15,12 +15,6 @@ function _eachmethod(f, m::Module, visited, vmt)
             x = getfield(m, nm)
             if isa(x, Module) && !in(x, visited)
                 _eachmethod(f, x, visited, vmt)
-            elseif isa(x, Function)
-                mt = typeof(x).name.mt
-                if !in(mt, vmt)
-                    push!(vmt, mt)
-                    Base.visit(f, mt)
-                end
             elseif isa(x, Type)
                 x = Base.unwrap_unionall(x)
                 if isa(x, DataType) && isdefined(x.name, :mt)
@@ -69,5 +63,5 @@ function outputline(io, name)
     println(io, "jl_symbol(\"", name, "\"),")
 end
 
-open(f->foreach(l->outputline(f,l), take(syms, 100)), "common_symbols1.inc", "w")
-open(f->foreach(l->outputline(f,l), take(drop(syms, 100), 254)), "common_symbols2.inc", "w")
+open(f->foreach(l->outputline(f,l), take(syms, 94)), "common_symbols1.inc", "w")
+open(f->foreach(l->outputline(f,l), take(drop(syms, 94), 254)), "common_symbols2.inc", "w")
diff --git a/src/genericmemory.c b/src/genericmemory.c
new file mode 100644
index 0000000000000..24b2bac6b2ac1
--- /dev/null
+++ b/src/genericmemory.c
@@ -0,0 +1,620 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+/*
+  GenericMemory{kind, T} constructors and primitives
+*/
+#include <stdlib.h>
+#include <string.h>
+#ifdef _OS_WINDOWS_
+#include <malloc.h>
+#endif
+#include "julia.h"
+#include "julia_internal.h"
+#include "julia_assert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static inline void genericmemoryassign_safe(int hasptr, jl_value_t *parent, char *dst, const jl_value_t *src) JL_NOTSAFEPOINT
+{
+    size_t nb = jl_datatype_size(jl_typeof(src)); // make sure to shrink-wrap this copy
+    if (hasptr) {
+        size_t nptr = nb / sizeof(void*);
+        memmove_refs((_Atomic(void*)*)dst, (_Atomic(void*)*)src, nptr);
+        jl_gc_multi_wb(parent, src);
+    }
+    else {
+        // genericmemory can assume more alignment than a field would normally have
+        switch (nb) {
+        case  0: break;
+        case  1: *(uint8_t*)dst  = *(uint8_t*)src;  break;
+        case  2: *(uint16_t*)dst = *(uint16_t*)src; break;
+        case  4: *(uint32_t*)dst = *(uint32_t*)src; break;
+        case  8: *(uint64_t*)dst = *(uint64_t*)src; break;
+        case 16:
+            memcpy(jl_assume_aligned(dst, 16), jl_assume_aligned(src, 16), 16);
+            break;
+        default: memcpy(dst, src, nb);
+        }
+    }
+}
+
+// genericmemory constructors ---------------------------------------------------------
+JL_DLLEXPORT char *jl_genericmemory_typetagdata(jl_genericmemory_t *m) JL_NOTSAFEPOINT
+{
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
+    assert(layout->flags.arrayelem_isunion);
+    return (char*)m->ptr + m->length * layout->size;
+}
+
+#if defined(_P64) && defined(UINT128MAX)
+typedef __uint128_t wideint_t;
+#else
+typedef uint64_t wideint_t;
+#endif
+
+#define MAXINTVAL (((size_t)-1)>>1)
+
+jl_genericmemory_t *_new_genericmemory_(jl_value_t *mtype, size_t nel, int8_t isunion, int8_t zeroinit, size_t elsz)
+{
+    jl_task_t *ct = jl_current_task;
+    char *data;
+    jl_genericmemory_t *m;
+    if (nel == 0) // zero-sized allocation optimization
+        return (jl_genericmemory_t*)((jl_datatype_t*)mtype)->instance;
+    wideint_t prod = (wideint_t)nel * elsz;
+    if (isunion) {
+        // an extra byte for each isbits union memory element, stored at m->ptr + m->length
+        prod += nel;
+    }
+    if (nel >= MAXINTVAL || prod >= (wideint_t) MAXINTVAL)
+        jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory size");
+    size_t tot = (size_t)prod + LLT_ALIGN(sizeof(jl_genericmemory_t),JL_SMALL_BYTE_ALIGNMENT);
+
+    int pooled = tot <= GC_MAX_SZCLASS;
+    if (!pooled) {
+        data = (char*)jl_gc_managed_malloc(prod);
+        tot = sizeof(jl_genericmemory_t) + sizeof(void*);
+    }
+    m = (jl_genericmemory_t*)jl_gc_alloc(ct->ptls, tot, mtype);
+    if (pooled) {
+        data = (char*)m + JL_SMALL_BYTE_ALIGNMENT;
+    }
+    else {
+        int isaligned = 1; // jl_gc_managed_malloc is always aligned
+        jl_gc_track_malloced_genericmemory(ct->ptls, m, isaligned);
+        jl_genericmemory_data_owner_field(m) = (jl_value_t*)m;
+    }
+    m->length = nel;
+    m->ptr = data;
+
+    if (zeroinit)
+        memset(data, 0, (size_t)prod);
+    return m;
+}
+
+JL_DLLEXPORT jl_genericmemory_t *jl_alloc_genericmemory(jl_value_t *mtype, size_t nel)
+{
+    assert(jl_is_datatype(mtype));
+    jl_genericmemory_t *m = (jl_genericmemory_t*)((jl_datatype_t*)mtype)->instance;
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)mtype)->layout;
+    if (m == NULL) {
+        if (jl_tparam0((jl_datatype_t*)mtype) != (jl_value_t*)jl_not_atomic_sym)
+            jl_error("GenericMemory kind must be :not_atomic");
+        jl_value_t *addrspace = jl_tparam2((jl_datatype_t*)mtype);
+        if (!jl_is_addrspacecore(addrspace) || jl_unbox_uint8(addrspace) != 0)
+            jl_error("GenericMemory addrspace must be Core.CPU");
+        if (!((jl_datatype_t*)mtype)->has_concrete_subtype || layout == NULL)
+            jl_type_error_rt("GenericMemory", "element type", (jl_value_t*)jl_type_type, jl_tparam1(mtype));
+        abort(); // this is checked already by jl_get_genericmemory_layout
+    }
+    assert(jl_tparam0((jl_datatype_t*)mtype) == (jl_value_t*)jl_not_atomic_sym);
+    assert(((jl_datatype_t*)mtype)->has_concrete_subtype && layout != NULL);
+    if (nel == 0) // zero-sized allocation optimization fast path
+        return m;
+
+    size_t elsz = layout->size;
+    int isboxed = layout->flags.arrayelem_isboxed;
+    int isunion = layout->flags.arrayelem_isunion;
+    int zi = ((jl_datatype_t*)mtype)->zeroinit;
+    if (isboxed)
+        elsz = sizeof(void*);
+    return _new_genericmemory_(mtype, nel, isunion, zi, elsz);
+}
+
+JL_DLLEXPORT jl_genericmemory_t *jl_string_to_genericmemory(jl_value_t *str)
+{
+    jl_task_t *ct = jl_current_task;
+    int tsz = sizeof(jl_genericmemory_t) + sizeof(void*);
+    jl_genericmemory_t *m = (jl_genericmemory_t*)jl_gc_alloc(ct->ptls, tsz, jl_memory_uint8_type);
+    m->length = jl_string_len(str);
+    m->ptr = jl_string_data(str);
+    jl_genericmemory_data_owner_field(m) = str;
+    return m;
+}
+
+// own_buffer != 0 iff GC should call free() on this pointer eventually
+JL_DLLEXPORT jl_genericmemory_t *jl_ptr_to_genericmemory(jl_value_t *mtype, void *data,
+                                                         size_t nel, int own_buffer)
+{
+    jl_task_t *ct = jl_current_task;
+    assert(jl_is_datatype(mtype));
+    jl_genericmemory_t *m = (jl_genericmemory_t*)((jl_datatype_t*)mtype)->instance;
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)mtype)->layout;
+    if (m == NULL) {
+        if (jl_tparam0((jl_datatype_t*)mtype) != (jl_value_t*)jl_not_atomic_sym)
+            jl_error("GenericMemory kind must be :not_atomic");
+        jl_value_t *addrspace = jl_tparam2((jl_datatype_t*)mtype);
+        if (!jl_is_addrspacecore(addrspace) || jl_unbox_uint8(addrspace) != 0)
+            jl_error("GenericMemory addrspace must be Core.CPU");
+        if (!((jl_datatype_t*)mtype)->has_concrete_subtype || layout == NULL)
+            jl_type_error_rt("GenericMemory", "element type", (jl_value_t*)jl_type_type, jl_tparam1(mtype));
+        abort();
+    }
+    assert(jl_tparam0((jl_datatype_t*)mtype) == (jl_value_t*)jl_not_atomic_sym);
+    assert(((jl_datatype_t*)mtype)->has_concrete_subtype && layout != NULL);
+    //if (nel == 0) {// zero-sized allocation optimization fast path
+    //    if (own_buffer)
+    //        free(data);
+    //    return m;
+    //}
+
+    size_t elsz = layout->size;
+    size_t align = layout->alignment;
+    int isboxed = layout->flags.arrayelem_isboxed;
+    int isunion = layout->flags.arrayelem_isunion;
+    if (isboxed)
+        elsz = sizeof(void*);
+    if (isunion)
+        jl_exceptionf(jl_argumenterror_type,
+                      "unsafe_wrap: unspecified layout for union element type");
+    if (((uintptr_t)data) & ((align > JL_HEAP_ALIGNMENT ? JL_HEAP_ALIGNMENT : align) - 1))
+        jl_exceptionf(jl_argumenterror_type,
+                      "unsafe_wrap: pointer %p is not properly aligned to %u bytes", data, align);
+    wideint_t prod = (wideint_t)nel * elsz;
+    if (isunion) {
+        // an extra byte for each isbits union memory element, stored at m->ptr + m->length
+        prod += nel;
+    }
+    if (nel >= MAXINTVAL || prod >= (wideint_t) MAXINTVAL)
+        jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory size");
+    int tsz = sizeof(jl_genericmemory_t) + sizeof(void*);
+    m = (jl_genericmemory_t*)jl_gc_alloc(ct->ptls, tsz, mtype);
+    m->ptr = data;
+    m->length = nel;
+    jl_genericmemory_data_owner_field(m) = NULL;
+    int isaligned = 0;  // TODO: allow passing memalign'd buffers
+    if (own_buffer) {
+        jl_gc_track_malloced_genericmemory(ct->ptls, m, isaligned);
+        jl_gc_count_allocd(nel*elsz);
+    }
+    return m;
+}
+
+JL_DLLEXPORT jl_genericmemory_t *jl_new_genericmemory(jl_value_t *mtype, jl_value_t *nel)
+{
+    return jl_alloc_genericmemory(mtype, jl_unbox_long(nel));
+}
+
+JL_DLLEXPORT jl_genericmemory_t *jl_pchar_to_genericmemory(const char *str, size_t len)
+{
+    jl_genericmemory_t *m = jl_alloc_genericmemory(jl_memory_uint8_type, len);
+    memcpy(m->ptr, str, len);
+    return m;
+}
+
+JL_DLLEXPORT jl_value_t *jl_genericmemory_to_string(jl_genericmemory_t *m, size_t len)
+{
+    assert(len <= m->length);
+    if (len == 0) {
+        // this may seem like purely an optimization (which it also is), but it
+        // also ensures that calling `String(m)` doesn't corrupt a previous
+        // string also created the same way, where `m = StringVector(_)`.
+        return jl_an_empty_string;
+    }
+    int how = jl_genericmemory_how(m);
+    size_t mlength = m->length;
+    m->length = 0;
+    if (how != 0) {
+        jl_value_t *o = jl_genericmemory_data_owner_field(m);
+        jl_genericmemory_data_owner_field(m) = NULL;
+        if (how == 3 &&
+             ((mlength + sizeof(void*) + 1 <= GC_MAX_SZCLASS) == (len + sizeof(void*) + 1 <= GC_MAX_SZCLASS))) {
+            if (jl_string_data(o)[len] != '\0')
+                jl_string_data(o)[len] = '\0';
+            if (*(size_t*)o != len)
+                *(size_t*)o = len;
+            return o;
+        }
+        JL_GC_PUSH1(&o);
+        jl_value_t *str = jl_pchar_to_string((const char*)m->ptr, len);
+        JL_GC_POP();
+        return str;
+    }
+    return jl_pchar_to_string((const char*)m->ptr, len);
+}
+
+JL_DLLEXPORT jl_genericmemory_t *jl_alloc_memory_any(size_t n)
+{
+    return jl_alloc_genericmemory(jl_memory_any_type, n);
+}
+
+JL_DLLEXPORT jl_genericmemory_t *jl_genericmemory_slice(jl_genericmemory_t *mem, void *data, size_t len)
+{
+    // Given a GenericMemoryRef represented as `jl_genericmemory_ref ref = {data, mem}`,
+    // return a new GenericMemory that only accesses the slice from the given GenericMemoryRef to
+    // the given length if this is possible to return. This allows us to make
+    // `length(Array)==length(Array.ref.mem)`, for simplification of this.
+    jl_datatype_t *dt = (jl_datatype_t*)jl_typetagof(mem);
+    const jl_datatype_layout_t *layout = dt->layout;
+    // repeated checks here ensure the values cannot overflow, since we know mem->length is a reasonable value
+    if (len > mem->length)
+        jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory slice"); // TODO: make a BoundsError
+    if (layout->flags.arrayelem_isunion) {
+        if (!((size_t)data == 0 && mem->length == len))
+            jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory slice"); // only exact slices are supported
+        data = mem->ptr;
+    }
+    else if (layout->size == 0) {
+        if ((size_t)data > mem->length || (size_t)data + len > mem->length)
+            jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory slice"); // TODO: make a BoundsError
+        data = mem->ptr;
+    }
+    else {
+        if (data < mem->ptr || (char*)data > (char*)mem->ptr + mem->length * layout->size || (char*)data + len * layout->size > (char*)mem->ptr + mem->length * layout->size)
+            jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory slice"); // TODO: make a BoundsError
+    }
+    jl_task_t *ct = jl_current_task;
+    jl_genericmemory_t *newmem = (jl_genericmemory_t*)jl_gc_alloc(ct->ptls, sizeof(jl_genericmemory_t) + sizeof(void*), dt);
+    newmem->length = len;
+    newmem->ptr = data;
+    jl_genericmemory_data_owner_field(newmem) = jl_genericmemory_owner(mem);
+    return newmem;
+}
+
+JL_DLLEXPORT void jl_genericmemory_copyto(jl_genericmemory_t *dest, char* destdata,
+                                          jl_genericmemory_t *src, char* srcdata,
+                                          size_t n) JL_NOTSAFEPOINT
+{
+    jl_datatype_t *dt = (jl_datatype_t*)jl_typetagof(dest);
+    if (dt != (jl_datatype_t*)jl_typetagof(src))
+        jl_exceptionf(jl_argumenterror_type, "jl_genericmemory_copyto requires source and dest to have same type");
+    const jl_datatype_layout_t *layout = dt->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        _Atomic(void*) * dest_p = (_Atomic(void*)*)destdata;
+        _Atomic(void*) * src_p = (_Atomic(void*)*)srcdata;
+        jl_value_t *owner = jl_genericmemory_owner(dest);
+        if (__unlikely(jl_astaggedvalue(owner)->bits.gc == GC_OLD_MARKED)) {
+            jl_value_t *src_owner = jl_genericmemory_owner(src);
+            ssize_t done = 0;
+            if (jl_astaggedvalue(src_owner)->bits.gc != GC_OLD_MARKED) {
+                if (dest_p < src_p || dest_p > src_p + n) {
+                    for (; done < n; done++) { // copy forwards
+                        void *val = jl_atomic_load_relaxed(src_p + done);
+                        jl_atomic_store_release(dest_p + done, val);
+                        // `val` is young or old-unmarked
+                        if (val && !(jl_astaggedvalue(val)->bits.gc & GC_MARKED)) {
+                            jl_gc_queue_root(owner);
+                            break;
+                        }
+                    }
+                    src_p += done;
+                    dest_p += done;
+                } else {
+                    for (; done < n; done++) { // copy backwards
+                        void *val = jl_atomic_load_relaxed(src_p + n - done - 1);
+                        jl_atomic_store_release(dest_p + n - done - 1, val);
+                        // `val` is young or old-unmarked
+                        if (val && !(jl_astaggedvalue(val)->bits.gc & GC_MARKED)) {
+                            jl_gc_queue_root(owner);
+                            break;
+                        }
+                    }
+                }
+                n -= done;
+            }
+        }
+        return memmove_refs(dest_p, src_p, n);
+    }
+    size_t elsz = layout->size;
+    char *src_p = srcdata;
+    int isbitsunion = layout->flags.arrayelem_isunion;
+    if (isbitsunion) {
+        char *sourcetypetagdata = jl_genericmemory_typetagdata(src);
+        char *desttypetagdata = jl_genericmemory_typetagdata(dest);
+        memmove(desttypetagdata+(size_t)destdata, sourcetypetagdata+(size_t)srcdata, n);
+        srcdata = (char*)src->ptr + elsz*(size_t)srcdata;
+        destdata = (char*)dest->ptr + elsz*(size_t)destdata;
+    }
+    if (layout->first_ptr != -1) {
+        memmove_refs((_Atomic(void*)*)destdata, (_Atomic(void*)*)srcdata, n * elsz / sizeof(void*));
+        jl_value_t *owner = jl_genericmemory_owner(dest);
+        if (__unlikely(jl_astaggedvalue(owner)->bits.gc == GC_OLD_MARKED)) {
+            jl_value_t *src_owner = jl_genericmemory_owner(src);
+            if (jl_astaggedvalue(src_owner)->bits.gc != GC_OLD_MARKED) {
+                dt = (jl_datatype_t*)jl_tparam1(dt);
+                for (size_t done = 0; done < n; done++) { // copy forwards
+                    char* s = (char*)src_p+done*elsz;
+                    if (*((jl_value_t**)s+layout->first_ptr) != NULL)
+                        jl_gc_queue_multiroot(owner, s, dt);
+                }
+            }
+        }
+    }
+    else {
+        memmove(destdata, srcdata, n * elsz);
+    }
+}
+
+
+// genericmemory primitives -----------------------------------------------------------
+
+JL_DLLEXPORT jl_value_t *jl_ptrmemref(jl_genericmemory_t *m JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT
+{
+    assert(i < m->length);
+    assert(((jl_datatype_t*)jl_typetagof(m))->layout->flags.arrayelem_isboxed);
+    jl_value_t *elt = jl_atomic_load_relaxed(((_Atomic(jl_value_t*)*)m->ptr) + i);
+    if (elt == NULL)
+        jl_throw(jl_undefref_exception);
+    return elt;
+}
+
+JL_DLLEXPORT jl_value_t *jl_genericmemoryref(jl_genericmemory_t *m, size_t i)
+{
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
+    if (layout->flags.arrayelem_isboxed)
+        return jl_ptrmemref(m, i);
+    assert(i < m->length);
+    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m)); (void)isatomic; // TODO
+    jl_value_t *eltype = jl_tparam1(jl_typetagof(m));
+    if (layout->flags.arrayelem_isunion) {
+        // isbits union selector bytes are always stored directly after the last memory element
+        uint8_t sel = jl_genericmemory_typetagdata(m)[i];
+        eltype = jl_nth_union_component(eltype, sel);
+        if (jl_is_datatype_singleton((jl_datatype_t*)eltype))
+            return ((jl_datatype_t*)eltype)->instance;
+    }
+    jl_value_t *r = undefref_check((jl_datatype_t*)eltype, jl_new_bits(eltype, &((char*)m->ptr)[i * layout->size]));
+    if (__unlikely(r == NULL))
+        jl_throw(jl_undefref_exception);
+    return r;
+}
+
+JL_DLLEXPORT int jl_genericmemory_isassigned(jl_genericmemory_t *m, size_t i)
+{
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        return jl_atomic_load_relaxed(((_Atomic(jl_value_t*)*)m->ptr) + i) != NULL;
+    }
+    else if (layout->first_ptr >= 0) {
+         jl_value_t **elem = (jl_value_t**)((char*)m->ptr + i * layout->size);
+         return elem[layout->first_ptr] != NULL;
+    }
+    return 1;
+}
+
+JL_DLLEXPORT void jl_genericmemoryset(jl_genericmemory_t *m JL_ROOTING_ARGUMENT, jl_value_t *rhs JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, size_t i)
+{
+    assert(i < m->length);
+    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m)); (void)isatomic; // TODO
+    jl_value_t *eltype = jl_tparam1(jl_typetagof(m));
+    if (eltype != (jl_value_t*)jl_any_type && !jl_typeis(rhs, eltype)) {
+        JL_GC_PUSH1(&rhs);
+        if (!jl_isa(rhs, eltype))
+            jl_type_error("genericmemoryset", eltype, rhs);
+        JL_GC_POP();
+    }
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        jl_atomic_store_release(((_Atomic(jl_value_t*)*)m->ptr) + i, rhs);
+        jl_gc_wb(jl_genericmemory_owner(m), rhs);
+    }
+    else {
+        int hasptr;
+        if (jl_is_uniontype(eltype)) {
+            uint8_t *psel = &((uint8_t*)jl_genericmemory_typetagdata(m))[i];
+            unsigned nth = 0;
+            if (!jl_find_union_component(eltype, jl_typeof(rhs), &nth))
+                assert(0 && "invalid genericmemoryset to isbits union");
+            *psel = nth;
+            if (jl_is_datatype_singleton((jl_datatype_t*)jl_typeof(rhs)))
+                return;
+            hasptr = 0;
+        }
+        else {
+            hasptr = layout->first_ptr >= 0;
+        }
+        genericmemoryassign_safe(hasptr, jl_genericmemory_owner(m), &((char*)m->ptr)[i * layout->size], rhs);
+    }
+}
+
+JL_DLLEXPORT void jl_genericmemoryunset(jl_genericmemory_t *m, size_t i)
+{
+    if (i >= m->length)
+        jl_bounds_error_int((jl_value_t*)m, i + 1);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
+    if (layout->flags.arrayelem_isboxed)
+        jl_atomic_store_relaxed(((_Atomic(jl_value_t*)*)m->ptr) + i, NULL);
+    else if (layout->first_ptr >= 0) {
+        size_t elsize = layout->size;
+        jl_assume(elsize >= sizeof(void*) && elsize % sizeof(void*) == 0);
+        memset((char*)m->ptr + elsize * i, 0, elsize);
+    }
+}
+
+JL_DLLEXPORT jl_genericmemory_t *jl_genericmemory_copy_slice(jl_genericmemory_t *mem, void *data, size_t len)
+{
+    jl_value_t *mtype = (jl_value_t*)jl_typetagof(mem);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)mtype)->layout;
+    size_t elsz = layout->size;
+    int isunion = layout->flags.arrayelem_isunion;
+    jl_genericmemory_t *new_mem = _new_genericmemory_(mtype, len, isunion, 0, elsz);
+    if (isunion) {
+        memcpy(new_mem->ptr, (char*)mem->ptr + (size_t)data * elsz, len * elsz);
+        memcpy(jl_genericmemory_typetagdata(new_mem), jl_genericmemory_typetagdata(mem) + (size_t)data, len);
+    }
+    else if (layout->first_ptr != -1) {
+        memmove_refs((_Atomic(void*)*)new_mem->ptr, (_Atomic(void*)*)data, len * elsz / sizeof(void*));
+    }
+    else if (data != NULL) {
+        memcpy(new_mem->ptr, data, len * elsz);
+    }
+    return new_mem;
+}
+
+JL_DLLEXPORT jl_genericmemory_t *jl_genericmemory_copy(jl_genericmemory_t *mem)
+{
+    jl_value_t *mtype = (jl_value_t*)jl_typetagof(mem);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)mtype)->layout;
+    return jl_genericmemory_copy_slice(mem, layout->flags.arrayelem_isunion || layout->size == 0 ? (void*)0 : mem->ptr, mem->length);
+}
+
+JL_DLLEXPORT jl_value_t *(jl_genericmemory_data_owner)(jl_genericmemory_t *m) JL_NOTSAFEPOINT
+{
+    return jl_genericmemory_data_owner_field(m);
+}
+
+jl_genericmemoryref_t *jl_new_memoryref(jl_value_t *typ, jl_genericmemory_t *mem, void *data)
+{
+    jl_task_t *ct = jl_current_task;
+    jl_genericmemoryref_t *m = (jl_genericmemoryref_t*)jl_gc_alloc(ct->ptls, sizeof(jl_genericmemoryref_t), typ);
+    m->mem = mem;
+    m->ptr_or_offset = data;
+    return m;
+}
+
+// memoryref primitives
+JL_DLLEXPORT jl_genericmemoryref_t jl_memoryrefindex(jl_genericmemoryref_t m JL_ROOTING_ARGUMENT, size_t idx)
+{
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    if ((layout->flags.arrayelem_isboxed || !layout->flags.arrayelem_isunion) && layout->size != 0) {
+        m.ptr_or_offset = (void*)((char*)m.ptr_or_offset + idx * layout->size);
+        assert((char*)m.ptr_or_offset - (char*)m.mem->ptr < layout->size * m.mem->length);
+    }
+    else {
+        m.ptr_or_offset = (void*)((size_t)m.ptr_or_offset + idx);
+        assert((size_t)m.ptr_or_offset < m.mem->length);
+    }
+    return m;
+}
+
+JL_DLLEXPORT jl_value_t *jl_ptrmemrefget(jl_genericmemoryref_t m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
+{
+    assert((char*)m.ptr_or_offset - (char*)m.mem->ptr < sizeof(jl_value_t*) * m.mem->length);
+    assert(((jl_datatype_t*)jl_typetagof(m.mem))->layout->flags.arrayelem_isboxed);
+    jl_value_t *elt = jl_atomic_load_relaxed((_Atomic(jl_value_t*)*)m.ptr_or_offset);
+    if (elt == NULL)
+        jl_throw(jl_undefref_exception);
+    return elt;
+}
+
+JL_DLLEXPORT jl_value_t *jl_memoryrefget(jl_genericmemoryref_t m)
+{
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    if (layout->flags.arrayelem_isboxed)
+        return jl_ptrmemrefget(m);
+    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem)); (void)isatomic; // TODO
+    jl_value_t *eltype = jl_tparam1(jl_typetagof(m.mem));
+    char *data = (char*)m.ptr_or_offset;
+    if (layout->flags.arrayelem_isunion) {
+        assert(jl_is_uniontype(eltype));
+        size_t i = (size_t)data;
+        assert(i < m.mem->length);
+        // isbits union selector bytes are always stored directly after the last memory element
+        uint8_t sel = jl_genericmemory_typetagdata(m.mem)[i];
+        eltype = jl_nth_union_component(eltype, sel);
+        data = (char*)m.mem->ptr + i * layout->size;
+    }
+    if (layout->size == 0) {
+        assert(jl_is_datatype_singleton((jl_datatype_t*)eltype));
+        return ((jl_datatype_t*)eltype)->instance;
+    }
+    assert(data - (char*)m.mem->ptr < layout->size * m.mem->length);
+    jl_value_t *r = undefref_check((jl_datatype_t*)eltype, jl_new_bits(eltype, data));
+    if (__unlikely(r == NULL))
+        jl_throw(jl_undefref_exception);
+    return r;
+}
+
+static int _jl_memoryref_isassigned(jl_genericmemoryref_t m)
+{
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        return jl_atomic_load_relaxed((_Atomic(jl_value_t*)*)m.ptr_or_offset) != NULL;
+    }
+    else if (layout->first_ptr >= 0) {
+         jl_value_t **elem = (jl_value_t**)m.ptr_or_offset;
+         return elem[layout->first_ptr] != NULL;
+    }
+    return 1;
+}
+
+JL_DLLEXPORT jl_value_t *jl_memoryref_isassigned(jl_genericmemoryref_t m)
+{
+    return _jl_memoryref_isassigned(m) ? jl_true : jl_false;
+}
+
+JL_DLLEXPORT void jl_memoryrefset(jl_genericmemoryref_t m JL_ROOTING_ARGUMENT, jl_value_t *rhs JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED)
+{
+    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem)); (void)isatomic; // TODO
+    jl_value_t *eltype = jl_tparam1(jl_typetagof(m.mem));
+    if (eltype != (jl_value_t*)jl_any_type && !jl_typeis(rhs, eltype)) {
+        JL_GC_PUSH1(&rhs);
+        if (!jl_isa(rhs, eltype))
+            jl_type_error("memoryrefset!", eltype, rhs);
+        JL_GC_POP();
+    }
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        assert((char*)m.ptr_or_offset - (char*)m.mem->ptr < sizeof(jl_value_t*) * m.mem->length);
+        jl_atomic_store_release((_Atomic(jl_value_t*)*)m.ptr_or_offset, rhs);
+        jl_gc_wb(jl_genericmemory_owner(m.mem), rhs);
+    }
+    else {
+        int hasptr;
+        char *data = (char*)m.ptr_or_offset;
+        if (layout->flags.arrayelem_isunion) {
+            assert(jl_is_uniontype(eltype));
+            size_t i = (size_t)data;
+            assert(i < m.mem->length);
+            uint8_t *psel = (uint8_t*)jl_genericmemory_typetagdata(m.mem) + i;
+            unsigned nth = 0;
+            if (!jl_find_union_component(eltype, jl_typeof(rhs), &nth))
+                assert(0 && "invalid genericmemoryset to isbits union");
+            *psel = nth;
+            hasptr = 0;
+            data = (char*)m.mem->ptr + i * layout->size;
+        }
+        else {
+            hasptr = layout->first_ptr >= 0;
+        }
+        if (layout->size != 0) {
+            assert(data - (char*)m.mem->ptr < layout->size * m.mem->length);
+            genericmemoryassign_safe(hasptr, jl_genericmemory_owner(m.mem), data, rhs);
+        }
+    }
+}
+
+JL_DLLEXPORT void jl_memoryrefunset(jl_genericmemoryref_t m)
+{
+    if (m.mem->length == 0)
+        jl_bounds_error_int((jl_value_t*)m.mem, 1);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        jl_atomic_store_relaxed((_Atomic(jl_value_t*)*)m.ptr_or_offset, NULL);
+    }
+    else if (layout->first_ptr >= 0) {
+        size_t elsize = layout->size;
+        jl_assume(elsize >= sizeof(void*) && elsize % sizeof(void*) == 0);
+        memset(m.ptr_or_offset, 0, elsize);
+    }
+}
+
+JL_DLLEXPORT jl_value_t *ijl_genericmemory_owner(jl_genericmemory_t *m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
+{
+    return jl_genericmemory_owner(m);
+}
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/gf.c b/src/gf.c
index 3caaa71924864..f6c9041731082 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -625,7 +625,7 @@ int jl_foreach_reachable_mtable(int (*visit)(jl_methtable_t *mt, void *env), voi
     if (mod_array) {
         JL_GC_PUSH1(&mod_array);
         int i;
-        for (i = 0; i < jl_array_len(mod_array); i++) {
+        for (i = 0; i < jl_array_nrows(mod_array); i++) {
             jl_module_t *m = (jl_module_t*)jl_array_ptr_ref(mod_array, i);
             assert(jl_is_module(m));
             if (m->parent == m) // some toplevel modules (really just Base) aren't actually
@@ -650,7 +650,7 @@ static int reset_mt_caches(jl_methtable_t *mt, void *env)
     // removes all method caches
     // this might not be entirely safe (GC or MT), thus we only do it very early in bootstrapping
     if (!mt->frozen) { // make sure not to reset builtin functions
-        jl_atomic_store_release(&mt->leafcache, (jl_array_t*)jl_an_empty_vec_any);
+        jl_atomic_store_release(&mt->leafcache, (jl_genericmemory_t*)jl_an_empty_memory_any);
         jl_atomic_store_release(&mt->cache, jl_nothing);
     }
     jl_typemap_visitor(jl_atomic_load_relaxed(&mt->defs), get_method_unspec_list, env);
@@ -674,7 +674,7 @@ JL_DLLEXPORT void jl_set_typeinf_func(jl_value_t *f)
         JL_GC_PUSH1(&unspec);
         jl_foreach_reachable_mtable(reset_mt_caches, (void*)unspec);
         size_t i, l;
-        for (i = 0, l = jl_array_len(unspec); i < l; i++) {
+        for (i = 0, l = jl_array_nrows(unspec); i < l; i++) {
             jl_method_instance_t *mi = (jl_method_instance_t*)jl_array_ptr_ref(unspec, i);
             if (jl_rettype_inferred(mi, world, world) == jl_nothing)
                 jl_type_infer(mi, world, 1);
@@ -1223,7 +1223,7 @@ static int concretesig_equal(jl_value_t *tt, jl_value_t *simplesig) JL_NOTSAFEPO
     return 1;
 }
 
-static inline jl_typemap_entry_t *lookup_leafcache(jl_array_t *leafcache JL_PROPAGATES_ROOT, jl_value_t *tt, size_t world) JL_NOTSAFEPOINT
+static inline jl_typemap_entry_t *lookup_leafcache(jl_genericmemory_t *leafcache JL_PROPAGATES_ROOT, jl_value_t *tt, size_t world) JL_NOTSAFEPOINT
 {
     jl_typemap_entry_t *entry = (jl_typemap_entry_t*)jl_eqtable_get(leafcache, (jl_value_t*)tt, NULL);
     if (entry) {
@@ -1250,7 +1250,7 @@ static jl_method_instance_t *cache_method(
     int8_t offs = mt ? jl_cachearg_offset(mt) : 1;
     { // scope block
         if (mt) {
-            jl_array_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
+            jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
             jl_typemap_entry_t *entry = lookup_leafcache(leafcache, (jl_value_t*)tt, world);
             if (entry)
                 return entry->func.linfo;
@@ -1316,7 +1316,7 @@ static jl_method_instance_t *cache_method(
         }
         else {
             int unmatched_tvars = 0;
-            size_t i, l = jl_array_len(temp);
+            size_t i, l = jl_array_nrows(temp);
             for (i = 0; i < l; i++) {
                 jl_method_match_t *matc = (jl_method_match_t*)jl_array_ptr_ref(temp, i);
                 if (matc->method == definition)
@@ -1349,7 +1349,7 @@ static jl_method_instance_t *cache_method(
             guardsigs = jl_alloc_svec(guards);
             temp3 = (jl_value_t*)guardsigs;
             guards = 0;
-            for (i = 0, l = jl_array_len(temp); i < l; i++) {
+            for (i = 0, l = jl_array_nrows(temp); i < l; i++) {
                 jl_method_match_t *matc = (jl_method_match_t*)jl_array_ptr_ref(temp, i);
                 jl_method_t *other = matc->method;
                 if (other != definition) {
@@ -1430,11 +1430,11 @@ static jl_method_instance_t *cache_method(
                 jl_cache_type_(tt);
             JL_UNLOCK(&typecache_lock); // Might GC
         }
-        jl_array_t *oldcache = jl_atomic_load_relaxed(&mt->leafcache);
+        jl_genericmemory_t *oldcache = jl_atomic_load_relaxed(&mt->leafcache);
         jl_typemap_entry_t *old = (jl_typemap_entry_t*)jl_eqtable_get(oldcache, (jl_value_t*)tt, jl_nothing);
         jl_atomic_store_relaxed(&newentry->next, old);
         jl_gc_wb(newentry, old);
-        jl_array_t *newcache = (jl_array_t*)jl_eqtable_put(jl_atomic_load_relaxed(&mt->leafcache), (jl_value_t*)tt, (jl_value_t*)newentry, NULL);
+        jl_genericmemory_t *newcache = jl_eqtable_put(jl_atomic_load_relaxed(&mt->leafcache), (jl_value_t*)tt, (jl_value_t*)newentry, NULL);
         if (newcache != oldcache) {
             jl_atomic_store_release(&mt->leafcache, newcache);
             jl_gc_wb(mt, newcache);
@@ -1455,7 +1455,7 @@ static jl_method_instance_t *jl_mt_assoc_by_type(jl_methtable_t *mt JL_PROPAGATE
     // caller must hold the mt->writelock
     assert(tt->isdispatchtuple || tt->hasfreetypevars);
     if (tt->isdispatchtuple) {
-        jl_array_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
+        jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
         jl_typemap_entry_t *entry = lookup_leafcache(leafcache, (jl_value_t*)tt, world);
         if (entry)
             return entry->func.linfo;
@@ -1619,7 +1619,7 @@ static void invalidate_external(jl_method_instance_t *mi, size_t max_world) {
         // AbstractInterpreter allows for MethodInstances to be present in non-local caches
         // inform those caches about the invalidation.
         JL_TRY {
-            size_t i, l = jl_array_len(callbacks);
+            size_t i, l = jl_array_nrows(callbacks);
             jl_value_t **args;
             JL_GC_PUSHARGS(args, 3);
             // these arguments are constant per call
@@ -1682,7 +1682,7 @@ static void invalidate_method_instance(void (*f)(jl_code_instance_t*), jl_method
     if (backedges) {
         JL_GC_PUSH1(&backedges);
         replaced->backedges = NULL;
-        size_t i = 0, l = jl_array_len(backedges);
+        size_t i = 0, l = jl_array_nrows(backedges);
         jl_method_instance_t *replaced;
         while (i < l) {
             i = get_next_edge(backedges, i, NULL, &replaced);
@@ -1703,7 +1703,7 @@ static void invalidate_backedges(void (*f)(jl_code_instance_t*), jl_method_insta
         // invalidate callers (if any)
         replaced_mi->backedges = NULL;
         JL_GC_PUSH1(&backedges);
-        size_t i = 0, l = jl_array_len(backedges);
+        size_t i = 0, l = jl_array_nrows(backedges);
         jl_method_instance_t *replaced;
         while (i < l) {
             i = get_next_edge(backedges, i, NULL, &replaced);
@@ -1735,7 +1735,7 @@ JL_DLLEXPORT void jl_method_instance_add_backedge(jl_method_instance_t *callee,
         jl_gc_wb(callee, callee->backedges);
     }
     else {
-        size_t i = 0, l = jl_array_len(callee->backedges);
+        size_t i = 0, l = jl_array_nrows(callee->backedges);
         for (i = 0; i < l; i++) {
             // optimized version of while (i < l) i = get_next_edge(callee->backedges, i, &invokeTypes, &mi);
             jl_value_t *mi = jl_array_ptr_ref(callee->backedges, i);
@@ -1769,7 +1769,7 @@ JL_DLLEXPORT void jl_method_table_add_backedge(jl_methtable_t *mt, jl_value_t *t
     }
     else {
         // TODO: use jl_cache_type_(tt) like cache_method does, instead of a linear scan
-        size_t i, l = jl_array_len(mt->backedges);
+        size_t i, l = jl_array_nrows(mt->backedges);
         for (i = 1; i < l; i += 2) {
             if (jl_types_equal(jl_array_ptr_ref(mt->backedges, i - 1), typ)) {
                 if (jl_array_ptr_ref(mt->backedges, i) == caller) {
@@ -1800,7 +1800,7 @@ static int invalidate_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
         jl_method_instance_t *mi = oldentry->func.linfo;
         int intersects = 0;
         jl_method_instance_t **d = (jl_method_instance_t**)jl_array_ptr_data(env->shadowed);
-        size_t i, n = jl_array_len(env->shadowed);
+        size_t i, n = jl_array_nrows(env->shadowed);
         for (i = 0; i < n; i++) {
             if (mi == d[i]) {
                 intersects = 1;
@@ -1882,10 +1882,10 @@ static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *m
     mt_cache_env.shadowed = NULL;
     mt_cache_env.invalidated = 0;
     jl_typemap_visitor(jl_atomic_load_relaxed(&mt->cache), disable_mt_cache, (void*)&mt_cache_env);
-    jl_array_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
-    size_t i, l = jl_array_len(leafcache);
+    jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
+    size_t i, l = leafcache->length;
     for (i = 1; i < l; i += 2) {
-        jl_typemap_entry_t *oldentry = (jl_typemap_entry_t*)jl_array_ptr_ref(leafcache, i);
+        jl_typemap_entry_t *oldentry = (jl_typemap_entry_t*)jl_genericmemory_ptr_ref(leafcache, i);
         if (oldentry) {
             while ((jl_value_t*)oldentry != jl_nothing) {
                 if (oldentry->max_world == ~(size_t)0)
@@ -2033,11 +2033,11 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
         else {
             assert(jl_is_array(oldvalue));
             d = (jl_method_t**)jl_array_ptr_data(oldvalue);
-            n = jl_array_len(oldvalue);
+            n = jl_array_nrows(oldvalue);
         }
         if (mt->backedges) {
             jl_value_t **backedges = jl_array_ptr_data(mt->backedges);
-            size_t i, na = jl_array_len(mt->backedges);
+            size_t i, na = jl_array_nrows(mt->backedges);
             size_t ins = 0;
             for (i = 1; i < na; i += 2) {
                 jl_value_t *backedgetyp = backedges[i - 1];
@@ -2132,7 +2132,7 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
                         // but ignore invoke-type edges
                         jl_array_t *backedges = mi->backedges;
                         if (backedges) {
-                            size_t ib = 0, insb = 0, nb = jl_array_len(backedges);
+                            size_t ib = 0, insb = 0, nb = jl_array_nrows(backedges);
                             jl_value_t *invokeTypes;
                             jl_method_instance_t *caller;
                             while (ib < nb) {
@@ -2168,7 +2168,7 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
                     }
                 }
             }
-            if (jl_array_len(oldmi)) {
+            if (jl_array_nrows(oldmi)) {
                 // search mt->cache and leafcache and drop anything that might overlap with the new method
                 // this is very cheap, so we don't mind being fairly conservative at over-approximating this
                 struct invalidate_mt_env mt_cache_env;
@@ -2178,10 +2178,10 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
                 mt_cache_env.invalidated = 0;
 
                 jl_typemap_visitor(jl_atomic_load_relaxed(&mt->cache), invalidate_mt_cache, (void*)&mt_cache_env);
-                jl_array_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
-                size_t i, l = jl_array_len(leafcache);
+                jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
+                size_t i, l = leafcache->length;
                 for (i = 1; i < l; i += 2) {
-                    jl_value_t *entry = jl_array_ptr_ref(leafcache, i);
+                    jl_value_t *entry = jl_genericmemory_ptr_ref(leafcache, i);
                     if (entry) {
                         while (entry != jl_nothing) {
                             invalidate_mt_cache((jl_typemap_entry_t*)entry, (void*)&mt_cache_env);
@@ -2254,7 +2254,7 @@ jl_method_instance_t *jl_method_lookup(jl_value_t **args, size_t nargs, size_t w
     if (entry)
         return entry->func.linfo;
     jl_tupletype_t *tt = arg_type_tuple(args[0], &args[1], nargs);
-    jl_array_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
+    jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
     entry = lookup_leafcache(leafcache, (jl_value_t*)tt, world);
     if (entry)
         return entry->func.linfo;
@@ -2699,7 +2699,7 @@ jl_method_instance_t *jl_get_specialization1(jl_tupletype_t *types JL_PROPAGATES
         *min_valid = min_valid2;
     if (*max_valid > max_valid2)
         *max_valid = max_valid2;
-    if (matches == jl_nothing || jl_array_len(matches) != 1 || ambig)
+    if (matches == jl_nothing || jl_array_nrows(matches) != 1 || ambig)
         return NULL;
     JL_GC_PUSH1(&matches);
     jl_method_match_t *match = (jl_method_match_t*)jl_array_ptr_ref(matches, 0);
@@ -2725,7 +2725,7 @@ static jl_method_instance_t *jl_get_compile_hint_specialization(jl_tupletype_t *
         *min_valid = min_valid2;
     if (*max_valid > max_valid2)
         *max_valid = max_valid2;
-    size_t i, n = jl_array_len(matches);
+    size_t i, n = jl_array_nrows(matches);
     if (n == 0)
         return NULL;
     JL_GC_PUSH1(&matches);
@@ -3029,9 +3029,9 @@ STATIC_INLINE jl_method_instance_t *jl_lookup_generic_(jl_value_t *F, jl_value_t
         // if no method was found in the associative cache, check the full cache
         JL_TIMING(METHOD_LOOKUP_FAST, METHOD_LOOKUP_FAST);
         mt = jl_gf_mtable(F);
-        jl_array_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
+        jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
         entry = NULL;
-        if (leafcache != (jl_array_t*)jl_an_empty_vec_any &&
+        if (leafcache != (jl_genericmemory_t*)jl_an_empty_memory_any &&
                 jl_typetagis(jl_atomic_load_relaxed(&mt->cache), jl_typemap_level_type)) {
             // hashing args is expensive, but looking at mt->cache is probably even more expensive
             tt = lookup_arg_type_tuple(F, args, nargs);
@@ -3115,7 +3115,7 @@ static jl_method_match_t *_gf_invoke_lookup(jl_value_t *types JL_PROPAGATES_ROOT
     if (mt == jl_nothing)
         mt = NULL;
     jl_value_t *matches = ml_matches((jl_methtable_t*)mt, (jl_tupletype_t*)types, 1, 0, 0, world, 1, min_valid, max_valid, NULL);
-    if (matches == jl_nothing || jl_array_len(matches) != 1)
+    if (matches == jl_nothing || jl_array_nrows(matches) != 1)
         return NULL;
     jl_method_match_t *matc = (jl_method_match_t*)jl_array_ptr_ref(matches, 0);
     return matc;
@@ -3230,7 +3230,8 @@ jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_
     jl_gc_wb(ftype->name->mt, name);
     jl_set_const(module, tname, (jl_value_t*)ftype);
     jl_value_t *f = jl_new_struct(ftype);
-    ftype->instance = f; jl_gc_wb(ftype, f);
+    ftype->instance = f;
+    jl_gc_wb(ftype, f);
     JL_GC_POP();
     return (jl_function_t*)f;
 }
@@ -3305,7 +3306,7 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
     closure->matc = make_method_match((jl_tupletype_t*)closure->match.ti,
         closure->match.env, meth,
         closure->match.issubty ? FULLY_COVERS : NOT_FULLY_COVERS);
-    size_t len = jl_array_len(closure->t);
+    size_t len = jl_array_nrows(closure->t);
     if (len == 0) {
         closure->t = (jl_value_t*)jl_alloc_vec_any(1);
         jl_array_ptr_set(closure->t, 0, (jl_value_t*)closure->matc);
@@ -3392,7 +3393,7 @@ static int sort_mlmatches(jl_array_t *t, size_t idx, arraylist_t *visited, array
     // First visit all "strong" edges where the child is definitely better.
     // This likely won't hit any cycles, but might (because morespecific is not transitive).
     // Along the way, record if we hit any ambiguities-we may need to track those later.
-    for (size_t childidx = 0; childidx < jl_array_len(t); childidx++) {
+    for (size_t childidx = 0; childidx < jl_array_nrows(t); childidx++) {
         if (childidx == idx)
             continue;
         int child_cycle = (size_t)visited->items[childidx];
@@ -3637,7 +3638,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
     if (mt) {
         // check the leaf cache if this type can be in there
         if (((jl_datatype_t*)unw)->isdispatchtuple) {
-            jl_array_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
+            jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
             jl_typemap_entry_t *entry = lookup_leafcache(leafcache, (jl_value_t*)type, world);
             if (entry) {
                 jl_method_instance_t *mi = entry->func.linfo;
@@ -3708,7 +3709,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
     *max_valid = env.match.max_valid;
     // done with many of these values now
     env.match.ti = NULL; env.matc = NULL; env.match.env = NULL; search.env = NULL;
-    size_t i, j, len = jl_array_len(env.t);
+    size_t i, j, len = jl_array_nrows(env.t);
     jl_method_match_t *minmax = NULL;
     int minmax_ambig = 0;
     int all_subtypes = 1;
@@ -3854,7 +3855,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
                     jl_method_match_t *matc = (jl_method_match_t*)jl_array_ptr_ref(env.t, idx);
                     jl_method_t *m = matc->method;
                     int subt = matc->fully_covers == FULLY_COVERS; // jl_subtype((jl_value_t*)type, (jl_value_t*)m->sig)
-                    for (size_t idx2 = 0; idx2 < jl_array_len(env.t); idx2++) {
+                    for (size_t idx2 = 0; idx2 < jl_array_nrows(env.t); idx2++) {
                         if (idx2 == idx)
                             continue;
                         // laborious test, checking for existence and coverage of another method (m3)
@@ -3936,7 +3937,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
             arraylist_push(&result, minmax);
             j++;
         }
-        memcpy(jl_array_data(env.t), result.items, j * sizeof(jl_method_match_t*));
+        memcpy(jl_array_data(env.t, jl_method_match_t*), result.items, j * sizeof(jl_method_match_t*));
         arraylist_free(&result);
         if (j != len)
             jl_array_del_end((jl_array_t*)env.t, len - j);
diff --git a/src/iddict.c b/src/iddict.c
index 1fa8a67d1ae96..43ce6c7aa7377 100644
--- a/src/iddict.c
+++ b/src/iddict.c
@@ -1,6 +1,6 @@
 // This file is a part of Julia. License is MIT: https://julialang.org/license
 
-#define hash_size(h) (jl_array_len(h) / 2)
+#define hash_size(h) (h->length / 2)
 
 // compute empirical max-probe for a given size
 #define max_probe(size) ((size) <= 1024 ? 16 : (size) >> 6)
@@ -8,15 +8,15 @@
 #define keyhash(k) jl_object_id_(jl_typeof(k), k)
 #define h2index(hv, sz) (size_t)(((hv) & ((sz)-1)) * 2)
 
-static inline int jl_table_assign_bp(jl_array_t **pa, jl_value_t *key, jl_value_t *val);
+static inline int jl_table_assign_bp(jl_genericmemory_t **pa, jl_value_t *key, jl_value_t *val);
 
-JL_DLLEXPORT jl_array_t *jl_idtable_rehash(jl_array_t *a, size_t newsz)
+JL_DLLEXPORT jl_genericmemory_t *jl_idtable_rehash(jl_genericmemory_t *a, size_t newsz)
 {
-    size_t sz = jl_array_len(a);
+    size_t sz = a->length;
     size_t i;
-    jl_value_t **ol = (jl_value_t **)a->data;
-    jl_array_t *newa = jl_alloc_vec_any(newsz);
-    // keep the original array in the original slot since we need `ol`
+    jl_value_t **ol = (jl_value_t **) a->ptr;
+    jl_genericmemory_t *newa = jl_alloc_memory_any(newsz);
+    // keep the original memory in the original slot since we need `ol`
     // to be valid in the loop below.
     JL_GC_PUSH2(&newa, &a);
     for (i = 0; i < sz; i += 2) {
@@ -30,20 +30,20 @@ JL_DLLEXPORT jl_array_t *jl_idtable_rehash(jl_array_t *a, size_t newsz)
     return newa;
 }
 
-static inline int jl_table_assign_bp(jl_array_t **pa, jl_value_t *key, jl_value_t *val)
+static inline int jl_table_assign_bp(jl_genericmemory_t **pa, jl_value_t *key, jl_value_t *val)
 {
     // pa points to a **un**rooted address
     uint_t hv;
-    jl_array_t *a = *pa;
+    jl_genericmemory_t *a = *pa;
     size_t orig, index, iter, empty_slot;
     size_t newsz, sz = hash_size(a);
     if (sz == 0) {
-        a = jl_alloc_vec_any(HT_N_INLINE);
+        a = jl_alloc_memory_any(HT_N_INLINE);
         sz = hash_size(a);
         *pa = a;
     }
     size_t maxprobe = max_probe(sz);
-    _Atomic(jl_value_t*) *tab = (_Atomic(jl_value_t*)*)a->data;
+    _Atomic(jl_value_t*) *tab = (_Atomic(jl_value_t*)*) a->ptr;
 
     hv = keyhash(key);
     while (1) {
@@ -92,7 +92,7 @@ static inline int jl_table_assign_bp(jl_array_t **pa, jl_value_t *key, jl_value_
         /* quadruple size, rehash, retry the insert */
         /* it's important to grow the table really fast; otherwise we waste */
         /* lots of time rehashing all the keys over and over. */
-        sz = jl_array_len(a);
+        sz = a -> length;
         if (sz < HT_N_INLINE)
             newsz = HT_N_INLINE;
         else if (sz >= (1 << 19) || (sz <= (1 << 8)))
@@ -102,20 +102,20 @@ static inline int jl_table_assign_bp(jl_array_t **pa, jl_value_t *key, jl_value_
         *pa = jl_idtable_rehash(*pa, newsz);
 
         a = *pa;
-        tab = (_Atomic(jl_value_t*)*)a->data;
+        tab =  (_Atomic(jl_value_t*)*) a->ptr;
         sz = hash_size(a);
         maxprobe = max_probe(sz);
     }
 }
 
 /* returns bp if key is in hash, otherwise NULL */
-inline _Atomic(jl_value_t*) *jl_table_peek_bp(jl_array_t *a, jl_value_t *key) JL_NOTSAFEPOINT
+inline _Atomic(jl_value_t*) *jl_table_peek_bp(jl_genericmemory_t *a, jl_value_t *key) JL_NOTSAFEPOINT
 {
     size_t sz = hash_size(a);
     if (sz == 0)
         return NULL;
     size_t maxprobe = max_probe(sz);
-    _Atomic(jl_value_t*) *tab = (_Atomic(jl_value_t*)*)a->data;
+    _Atomic(jl_value_t*) *tab = (_Atomic(jl_value_t*)*) a->ptr;
     uint_t hv = keyhash(key);
     size_t index = h2index(hv, sz);
     sz *= 2;
@@ -142,7 +142,7 @@ inline _Atomic(jl_value_t*) *jl_table_peek_bp(jl_array_t *a, jl_value_t *key) JL
 }
 
 JL_DLLEXPORT
-jl_array_t *jl_eqtable_put(jl_array_t *h, jl_value_t *key, jl_value_t *val, int *p_inserted)
+jl_genericmemory_t *jl_eqtable_put(jl_genericmemory_t *h, jl_value_t *key, jl_value_t *val, int *p_inserted)
 {
     int inserted = jl_table_assign_bp(&h, key, val);
     if (p_inserted)
@@ -153,20 +153,20 @@ jl_array_t *jl_eqtable_put(jl_array_t *h, jl_value_t *key, jl_value_t *val, int
 // Note: lookup in the IdDict is permitted concurrently, if you avoid deletions,
 // and assuming you do use an external lock around all insertions
 JL_DLLEXPORT
-jl_value_t *jl_eqtable_get(jl_array_t *h, jl_value_t *key, jl_value_t *deflt) JL_NOTSAFEPOINT
+jl_value_t *jl_eqtable_get(jl_genericmemory_t *h, jl_value_t *key, jl_value_t *deflt) JL_NOTSAFEPOINT
 {
     _Atomic(jl_value_t*) *bp = jl_table_peek_bp(h, key);
     return (bp == NULL) ? deflt : jl_atomic_load_relaxed(bp);
 }
 
-jl_value_t *jl_eqtable_getkey(jl_array_t *h, jl_value_t *key, jl_value_t *deflt) JL_NOTSAFEPOINT
+jl_value_t *jl_eqtable_getkey(jl_genericmemory_t *h, jl_value_t *key, jl_value_t *deflt) JL_NOTSAFEPOINT
 {
     _Atomic(jl_value_t*) *bp = jl_table_peek_bp(h, key);
     return (bp == NULL) ? deflt : jl_atomic_load_relaxed(bp - 1);
 }
 
 JL_DLLEXPORT
-jl_value_t *jl_eqtable_pop(jl_array_t *h, jl_value_t *key, jl_value_t *deflt, int *found)
+jl_value_t *jl_eqtable_pop(jl_genericmemory_t *h, jl_value_t *key, jl_value_t *deflt, int *found)
 {
     _Atomic(jl_value_t*) *bp = jl_table_peek_bp(h, key);
     if (found)
@@ -180,12 +180,12 @@ jl_value_t *jl_eqtable_pop(jl_array_t *h, jl_value_t *key, jl_value_t *deflt, in
 }
 
 JL_DLLEXPORT
-size_t jl_eqtable_nextind(jl_array_t *t, size_t i)
+size_t jl_eqtable_nextind(jl_genericmemory_t *t, size_t i)
 {
     if (i & 1)
         i++;
-    size_t alen = jl_array_dim0(t);
-    while (i < alen && ((void **)t->data)[i + 1] == NULL)
+    size_t alen = t->length;
+    while (i < alen && ((void**) t->ptr)[i + 1] == NULL)
         i += 2;
     if (i >= alen)
         return (size_t)-1;
diff --git a/src/init.c b/src/init.c
index a046b4e6dcb21..fef3e73bd2d06 100644
--- a/src/init.c
+++ b/src/init.c
@@ -850,21 +850,18 @@ static NOINLINE void _finish_julia_init(JL_IMAGE_SEARCH rel, jl_ptls_t ptls, jl_
         jl_options.cpu_target = "native";
     jl_init_codegen();
 
+    jl_init_common_symbols();
     if (jl_options.image_file) {
         jl_restore_system_image(jl_options.image_file);
     } else {
         jl_init_types();
-        jl_global_roots_table = jl_alloc_vec_any(0);
+        jl_global_roots_table = jl_alloc_memory_any(0);
     }
 
-    jl_init_common_symbols();
     jl_init_flisp();
     jl_init_serializer();
 
     if (!jl_options.image_file) {
-        jl_core_module = jl_new_module(jl_symbol("Core"), NULL);
-        jl_core_module->parent = jl_core_module;
-        jl_type_typename->mt->module = jl_core_module;
         jl_top_module = jl_core_module;
         jl_init_intrinsic_functions();
         jl_init_primitives();
@@ -892,7 +889,7 @@ static NOINLINE void _finish_julia_init(JL_IMAGE_SEARCH rel, jl_ptls_t ptls, jl_
         jl_array_t *init_order = jl_module_init_order;
         JL_GC_PUSH1(&init_order);
         jl_module_init_order = NULL;
-        int i, l = jl_array_len(init_order);
+        int i, l = jl_array_nrows(init_order);
         for (i = 0; i < l; i++) {
             jl_value_t *mod = jl_array_ptr_ref(init_order, i);
             jl_module_run_initializer((jl_module_t*)mod);
diff --git a/src/interpreter.c b/src/interpreter.c
index 4192ee9c9ca45..573b4f81f8ff4 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -161,12 +161,12 @@ jl_value_t *jl_eval_globalref(jl_globalref_t *g)
 
 static int jl_source_nslots(jl_code_info_t *src) JL_NOTSAFEPOINT
 {
-    return jl_array_len(src->slotflags);
+    return jl_array_nrows(src->slotflags);
 }
 
 static int jl_source_nssavalues(jl_code_info_t *src) JL_NOTSAFEPOINT
 {
-    return jl_is_long(src->ssavaluetypes) ? jl_unbox_long(src->ssavaluetypes) : jl_array_len(src->ssavaluetypes);
+    return jl_is_long(src->ssavaluetypes) ? jl_unbox_long(src->ssavaluetypes) : jl_array_nrows(src->ssavaluetypes);
 }
 
 static void eval_stmt_value(jl_value_t *stmt, interpreter_state *s)
@@ -217,7 +217,7 @@ static jl_value_t *eval_value(jl_value_t *e, interpreter_state *s)
         return e;
     jl_expr_t *ex = (jl_expr_t*)e;
     jl_value_t **args = jl_array_ptr_data(ex->args);
-    size_t nargs = jl_array_len(ex->args);
+    size_t nargs = jl_array_nrows(ex->args);
     jl_sym_t *head = ex->head;
     if (head == jl_call_sym) {
         return do_call(args, nargs, s);
@@ -386,8 +386,8 @@ static size_t eval_phi(jl_array_t *stmts, interpreter_state *s, size_t ns, size_
             //   %2 = phi ...
             //   %3 = phi (1)[1 => %a], (2)[2 => %b]
             // from = 1, to = closest = 2, i = 1 --> edge = 2, edge_from = 2, from = 2
-            for (unsigned j = 0; j < jl_array_len(edges); ++j) {
-                size_t edge_from = ((int32_t*)jl_array_data(edges))[j]; // 1-indexed
+            for (unsigned j = 0; j < jl_array_nrows(edges); ++j) {
+                size_t edge_from = jl_array_data(edges, int32_t)[j]; // 1-indexed
                 if (edge_from == from + 1) {
                     if (edge == -1)
                         edge = j;
@@ -444,7 +444,7 @@ static size_t eval_phi(jl_array_t *stmts, interpreter_state *s, size_t ns, size_
 static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip, int toplevel)
 {
     jl_handler_t __eh;
-    size_t ns = jl_array_len(stmts);
+    size_t ns = jl_array_nrows(stmts);
     jl_task_t *ct = jl_current_task;
 
     while (1) {
@@ -528,7 +528,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
                     if (!jl_is_phicnode(phicnode))
                         break;
                     jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(phicnode, 0);
-                    for (size_t i = 0; i < jl_array_len(values); ++i) {
+                    for (size_t i = 0; i < jl_array_nrows(values); ++i) {
                         jl_value_t *val = jl_array_ptr_ref(values, i);
                         assert(jl_is_ssavalue(val));
                         size_t upsilon = ((jl_ssavalue_t*)val)->id - 1;
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index 57eacd141744a..0c0196e09b034 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -15,7 +15,6 @@ STATISTIC(EmittedCoercedUnboxes, "Number of unbox coercions emitted");
 STATISTIC(EmittedUnboxes, "Number of unboxes emitted");
 STATISTIC(EmittedRuntimeCalls, "Number of runtime intrinsic calls emitted");
 STATISTIC(EmittedIntrinsics, "Number of intrinsic calls emitted");
-STATISTIC(Emitted_arraylen, "Number of arraylen calls emitted");
 STATISTIC(Emitted_pointerref, "Number of pointerref calls emitted");
 STATISTIC(Emitted_pointerset, "Number of pointerset calls emitted");
 STATISTIC(Emitted_atomic_fence, "Number of atomic_fence calls emitted");
@@ -245,8 +244,8 @@ static Constant *julia_const_to_llvm(jl_codectx_t &ctx, const void *ptr, jl_data
         if (jl_is_uniontype(ft)) {
             // compute the same type layout as julia_struct_to_llvm
             size_t fsz = 0, al = 0;
-            (void)jl_islayout_inline(ft, &fsz, &al);
-            fsz = jl_field_size(bt, i);
+            (void)jl_islayout_inline(ft, &fsz, &al); // compute al
+            fsz = jl_field_size(bt, i); // get LLT_ALIGN(fsz+1,al)
             uint8_t sel = ((const uint8_t*)ptr)[offs + fsz - 1];
             jl_value_t *active_ty = jl_nth_union_component(ft, sel);
             size_t active_sz = jl_datatype_size(active_ty);
@@ -537,7 +536,7 @@ static jl_cgval_t generic_bitcast(jl_codectx_t &ctx, const jl_cgval_t *argv)
         }
         else {
             Value *size = emit_datatype_size(ctx, typ);
-            auto sizecheck = ctx.builder.CreateICmpEQ(size, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), nb));
+            auto sizecheck = ctx.builder.CreateICmpEQ(size, ConstantInt::get(size->getType(), nb));
             setName(ctx.emission_context, sizecheck, "sizecheck");
             error_unless(ctx,
                     sizecheck,
@@ -1207,15 +1206,6 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
     // return emit_runtime_call(ctx, f, argv, nargs);
 
     switch (f) {
-    case arraylen: {
-        ++Emitted_arraylen;
-        assert(nargs == 1);
-        const jl_cgval_t &x = argv[0];
-        jl_value_t *typ = jl_unwrap_unionall(x.typ);
-        if (!jl_is_datatype(typ) || ((jl_datatype_t*)typ)->name != jl_array_typename)
-            return emit_runtime_call(ctx, f, argv.data(), nargs);
-        return mark_julia_type(ctx, emit_arraylen(ctx, x), false, jl_long_type);
-    }
     case pointerref:
         ++Emitted_pointerref;
         assert(nargs == 3);
diff --git a/src/intrinsics.h b/src/intrinsics.h
index 93747faa74160..805aa914b5366 100644
--- a/src/intrinsics.h
+++ b/src/intrinsics.h
@@ -99,8 +99,6 @@
     /*  c interface */ \
     ADD_I(cglobal, 2) \
     ALIAS(llvmcall, llvmcall) \
-    /*  object access */ \
-    ADD_I(arraylen, 1) \
     /*  cpu feature tests */ \
     ADD_I(have_fma, 1) \
     /*  hidden intrinsics */ \
diff --git a/src/ircode.c b/src/ircode.c
index 508326c96314a..e660b8a463aa0 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -59,6 +59,7 @@ jl_value_t *jl_deser_symbol(uint8_t tag)
 
 // --- encoding ---
 
+static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal) JL_GC_DISABLED;
 #define jl_encode_value(s, v) jl_encode_value_((s), (jl_value_t*)(v), 0)
 
 static void tagged_root(rle_reference *rr, jl_ircode_state *s, int i)
@@ -70,7 +71,7 @@ static void tagged_root(rle_reference *rr, jl_ircode_state *s, int i)
 static void literal_val_id(rle_reference *rr, jl_ircode_state *s, jl_value_t *v) JL_GC_DISABLED
 {
     jl_array_t *rs = s->method->roots;
-    int i, l = jl_array_len(rs);
+    int i, l = jl_array_nrows(rs);
     if (jl_is_symbol(v) || jl_is_concrete_type(v)) {
         for (i = 0; i < l; i++) {
             if (jl_array_ptr_ref(rs, i) == v)
@@ -84,7 +85,7 @@ static void literal_val_id(rle_reference *rr, jl_ircode_state *s, jl_value_t *v)
         }
     }
     jl_add_method_root(s->method, jl_precompile_toplevel_module, v);
-    return tagged_root(rr, s, jl_array_len(rs) - 1);
+    return tagged_root(rr, s, jl_array_nrows(rs) - 1);
 }
 
 static void jl_encode_int32(jl_ircode_state *s, int32_t x)
@@ -121,6 +122,44 @@ static void jl_encode_as_indexed_root(jl_ircode_state *s, jl_value_t *v)
     }
 }
 
+static void jl_encode_memory_slice(jl_ircode_state *s, jl_genericmemory_t *mem, size_t offset, size_t len) JL_GC_DISABLED
+{
+    jl_datatype_t *t = (jl_datatype_t*)jl_typetagof(mem);
+    size_t i;
+    const jl_datatype_layout_t *layout = t->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        for (i = 0; i < len; i++) {
+            jl_value_t *e = jl_genericmemory_ptr_ref(mem, offset + i);
+            jl_encode_value(s, e);
+        }
+    }
+    else if (layout->first_ptr >= 0) {
+        uint16_t elsz = layout->size;
+        size_t j, np = layout->npointers;
+        const char *data = (const char*)mem->ptr + offset * elsz;
+        for (i = 0; i < len; i++) {
+            const char *start = data;
+            for (j = 0; j < np; j++) {
+                uint32_t ptr = jl_ptr_offset(t, j);
+                const jl_value_t *const *fld = &((const jl_value_t *const *)data)[ptr];
+                if ((const char*)fld != start)
+                    ios_write(s->s, start, (const char*)fld - start);
+                JL_GC_PROMISE_ROOTED(*fld);
+                jl_encode_value(s, *fld);
+                start = (const char*)&fld[1];
+            }
+            data += elsz;
+            if (data != start)
+                ios_write(s->s, start, data - start);
+        }
+    }
+    else {
+        ios_write(s->s, (char*)mem->ptr + offset * layout->size, len * layout->size);
+        if (jl_genericmemory_isbitsunion(mem))
+            ios_write(s->s, jl_genericmemory_typetagdata(mem) + offset, len);
+    }
+}
+
 static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal) JL_GC_DISABLED
 {
     size_t i;
@@ -203,7 +242,7 @@ static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal)
     }
     else if (jl_is_expr(v)) {
         jl_expr_t *e = (jl_expr_t*)v;
-        size_t l = jl_array_len(e->args);
+        size_t l = jl_array_nrows(e->args);
         if (e->head == jl_call_sym) {
             if (l == 2) {
                 write_uint8(s->s, TAG_CALL1);
@@ -235,31 +274,31 @@ static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal)
     else if (jl_is_phinode(v)) {
         jl_array_t *edges = (jl_array_t*)jl_fieldref_noalloc(v, 0);
         jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(v, 1);
-        size_t l = jl_array_len(edges);
-        if (l <= 255 && jl_array_len(values) == l) {
+        size_t l = jl_array_nrows(edges);
+        if (l <= 255 && jl_array_nrows(values) == l) {
             write_uint8(s->s, TAG_PHINODE);
             write_uint8(s->s, (uint8_t)l);
         }
         else {
             write_uint8(s->s, TAG_LONG_PHINODE);
             write_int32(s->s, l);
-            write_int32(s->s, jl_array_len(values));
+            write_int32(s->s, jl_array_nrows(values));
         }
         for (i = 0; i < l; i++) {
-            int32_t e = ((int32_t*)jl_array_data(edges))[i];
+            int32_t e = jl_array_data(edges, int32_t)[i];
             if (e <= 20)
                 jl_encode_value(s, jl_box_int32(e));
             else
                 jl_encode_int32(s, e);
         }
-        l = jl_array_len(values);
+        l = jl_array_nrows(values);
         for (i = 0; i < l; i++) {
             jl_encode_value(s, jl_array_ptr_ref(values, i));
         }
     }
     else if (jl_is_phicnode(v)) {
         jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(v, 0);
-        size_t l = jl_array_len(values);
+        size_t l = jl_array_nrows(values);
         if (l <= 255) {
             write_uint8(s->s, TAG_PHICNODE);
             write_uint8(s->s, (uint8_t)l);
@@ -337,52 +376,34 @@ static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal)
     }
     else if (as_literal && jl_is_array(v)) {
         jl_array_t *ar = (jl_array_t*)v;
-        jl_value_t *et = jl_tparam0(jl_typeof(ar));
-        int isunion = jl_is_uniontype(et);
-        if (ar->flags.ndims == 1 && ar->elsize <= 0x1f) {
+        if (jl_array_ndims(ar) == 1) {
             write_uint8(s->s, TAG_ARRAY1D);
-            write_uint8(s->s, (ar->flags.ptrarray << 7) | (ar->flags.hasptr << 6) | (isunion << 5) | (ar->elsize & 0x1f));
         }
         else {
             write_uint8(s->s, TAG_ARRAY);
-            write_uint16(s->s, ar->flags.ndims);
-            write_uint16(s->s, (ar->flags.ptrarray << 15) | (ar->flags.hasptr << 14) | (isunion << 13) | (ar->elsize & 0x1fff));
+            write_uint16(s->s, jl_array_ndims(ar));
         }
-        for (i = 0; i < ar->flags.ndims; i++)
-            jl_encode_value(s, jl_box_long(jl_array_dim(ar,i)));
+        for (i = 0; i < jl_array_ndims(ar); i++)
+            jl_encode_value(s, jl_box_long(jl_array_dim(ar, i)));
         jl_encode_value(s, jl_typeof(ar));
         size_t l = jl_array_len(ar);
-        if (ar->flags.ptrarray) {
-            for (i = 0; i < l; i++) {
-                jl_value_t *e = jl_array_ptr_ref(v, i);
-                jl_encode_value(s, e);
-            }
-        }
-        else if (ar->flags.hasptr) {
-            const char *data = (const char*)jl_array_data(ar);
-            uint16_t elsz = ar->elsize;
-            size_t j, np = ((jl_datatype_t*)et)->layout->npointers;
-            for (i = 0; i < l; i++) {
-                const char *start = data;
-                for (j = 0; j < np; j++) {
-                    uint32_t ptr = jl_ptr_offset((jl_datatype_t*)et, j);
-                    const jl_value_t *const *fld = &((const jl_value_t *const *)data)[ptr];
-                    if ((const char*)fld != start)
-                        ios_write(s->s, start, (const char*)fld - start);
-                    JL_GC_PROMISE_ROOTED(*fld);
-                    jl_encode_value(s, *fld);
-                    start = (const char*)&fld[1];
-                }
-                data += elsz;
-                if (data != start)
-                    ios_write(s->s, start, data - start);
-            }
-        }
-        else {
-            ios_write(s->s, (char*)jl_array_data(ar), l * ar->elsize);
-            if (jl_array_isbitsunion(ar))
-                ios_write(s->s, jl_array_typetagdata(ar), l);
-        }
+        const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(ar->ref.mem))->layout;
+        size_t offset;
+        if (layout->flags.arrayelem_isunion || layout->size == 0)
+            offset = (uintptr_t)ar->ref.ptr_or_offset;
+        else
+            offset = (char*)ar->ref.ptr_or_offset - (char*)ar->ref.mem->ptr;
+        jl_encode_memory_slice(s, ar->ref.mem, offset, l);
+    }
+    else if (as_literal && jl_is_genericmemory(v)) {
+        jl_genericmemory_t* m = (jl_genericmemory_t*)v;
+        write_uint8(s->s, TAG_MEMORYT);
+        jl_encode_value(s, (jl_datatype_t*)jl_typetagof(v));
+        jl_encode_value(s, jl_box_long(m->length));
+        jl_encode_memory_slice(s, m, 0, m->length);
+    }
+    else if (as_literal && jl_is_layout_opaque(((jl_datatype_t*)jl_typeof(v))->layout)) {
+        assert(0 && "not legal to store this as literal");
     }
     else if (as_literal || jl_is_uniontype(v) || jl_is_newvarnode(v) || jl_is_linenode(v) ||
              jl_is_upsilonnode(v) || jl_is_pinode(v) || jl_is_slotnumber(v) || jl_is_ssavalue(v) ||
@@ -466,52 +487,27 @@ static jl_value_t *jl_decode_value_svec(jl_ircode_state *s, uint8_t tag) JL_GC_D
     return (jl_value_t*)sv;
 }
 
-static jl_value_t *jl_decode_value_array(jl_ircode_state *s, uint8_t tag) JL_GC_DISABLED
+static jl_value_t *jl_decode_value_memory(jl_ircode_state *s, jl_value_t *mty, size_t nel) JL_GC_DISABLED
 {
-    int16_t i, ndims;
-    int isptr, isunion, hasptr, elsize;
-    if (tag == TAG_ARRAY1D) {
-        ndims = 1;
-        elsize = read_uint8(s->s);
-        isptr = (elsize >> 7) & 1;
-        hasptr = (elsize >> 6) & 1;
-        isunion = (elsize >> 5) & 1;
-        elsize = elsize & 0x1f;
-    }
-    else {
-        ndims = read_uint16(s->s);
-        elsize = read_uint16(s->s);
-        isptr = (elsize >> 15) & 1;
-        hasptr = (elsize >> 14) & 1;
-        isunion = (elsize >> 13) & 1;
-        elsize = elsize & 0x1fff;
-    }
-    size_t *dims = (size_t*)alloca(ndims * sizeof(size_t));
-    for (i = 0; i < ndims; i++) {
-        dims[i] = jl_unbox_long(jl_decode_value(s));
-    }
-    jl_array_t *a = jl_new_array_for_deserialization(
-            (jl_value_t*)NULL, ndims, dims, !isptr, hasptr, isunion, elsize);
-    jl_value_t *aty = jl_decode_value(s);
-    jl_set_typeof(a, aty);
-    if (a->flags.ptrarray) {
-        jl_value_t **data = (jl_value_t**)jl_array_data(a);
-        size_t i, numel = jl_array_len(a);
+    jl_genericmemory_t *m = jl_alloc_genericmemory(mty, nel);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty)->layout;
+    if (layout->flags.arrayelem_isboxed) {
+        jl_value_t **data = (jl_value_t**)m->ptr;
+        size_t i, numel = m->length;
         for (i = 0; i < numel; i++) {
             data[i] = jl_decode_value(s);
         }
-        assert(jl_astaggedvalue(a)->bits.gc == GC_CLEAN); // gc is disabled
-    }
-    else if (a->flags.hasptr) {
-        size_t i, numel = jl_array_len(a);
-        char *data = (char*)jl_array_data(a);
-        uint16_t elsz = a->elsize;
-        jl_datatype_t *et = (jl_datatype_t*)jl_tparam0(jl_typeof(a));
-        size_t j, np = et->layout->npointers;
+        assert(jl_astaggedvalue(m)->bits.gc == GC_CLEAN); // gc is disabled
+    }
+    else if (layout->first_ptr >= 0) {
+        size_t i, numel = m->length;
+        char *data = (char*)m->ptr;
+        uint16_t elsz = layout->size;
+        size_t j, np = layout->npointers;
         for (i = 0; i < numel; i++) {
             char *start = data;
             for (j = 0; j < np; j++) {
-                uint32_t ptr = jl_ptr_offset(et, j);
+                uint32_t ptr = jl_ptr_offset((jl_datatype_t*)mty, j);
                 jl_value_t **fld = &((jl_value_t**)data)[ptr];
                 if ((char*)fld != start)
                     ios_readall(s->s, start, (const char*)fld - start);
@@ -522,13 +518,39 @@ static jl_value_t *jl_decode_value_array(jl_ircode_state *s, uint8_t tag) JL_GC_
             if (data != start)
                 ios_readall(s->s, start, data - start);
         }
-        assert(jl_astaggedvalue(a)->bits.gc == GC_CLEAN); // gc is disabled
+        assert(jl_astaggedvalue(m)->bits.gc == GC_CLEAN); // gc is disabled
     }
     else {
-        size_t extra = jl_array_isbitsunion(a) ? jl_array_len(a) : 0;
-        size_t tot = jl_array_len(a) * a->elsize + extra;
-        ios_readall(s->s, (char*)jl_array_data(a), tot);
+        size_t extra = jl_genericmemory_isbitsunion(m) ? m->length : 0;
+        size_t tot = m->length * layout->size + extra;
+        ios_readall(s->s, (char*)m->ptr, tot);
     }
+    return (jl_value_t*)m;
+}
+
+JL_DLLEXPORT jl_array_t *jl_alloc_array_nd(jl_value_t *atype, size_t *dims, size_t ndims);
+
+static jl_value_t *jl_decode_value_array(jl_ircode_state *s, uint8_t tag) JL_GC_DISABLED
+{
+    int16_t i, ndims;
+    if (tag == TAG_ARRAY1D)
+        ndims = 1;
+    else
+        ndims = read_uint16(s->s);
+    size_t *dims = (size_t*)alloca(ndims * sizeof(size_t));
+    size_t len = 1;
+    for (i = 0; i < ndims; i++) {
+        dims[i] = jl_unbox_long(jl_decode_value(s));
+        len *= dims[i];
+    }
+    jl_value_t *aty = jl_decode_value(s);
+    jl_array_t *a = jl_alloc_array_nd(aty, dims, ndims);
+    a->ref.mem = (jl_genericmemory_t*)jl_decode_value_memory(s, jl_field_type_concrete((jl_datatype_t*)jl_field_type_concrete((jl_datatype_t*)aty, 0), 1), len);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(a->ref.mem))->layout;
+    if (layout->flags.arrayelem_isunion || layout->size == 0)
+        a->ref.ptr_or_offset = (void*)0;
+    else
+        a->ref.ptr_or_offset = a->ref.mem->ptr;
     return (jl_value_t*)a;
 }
 
@@ -553,7 +575,7 @@ static jl_value_t *jl_decode_value_expr(jl_ircode_state *s, uint8_t tag) JL_GC_D
     if (head == NULL)
         head = (jl_sym_t*)jl_decode_value(s);
     jl_expr_t *e = jl_exprn(head, len);
-    jl_value_t **data = (jl_value_t**)(e->args->data);
+    jl_value_t **data = jl_array_ptr_data(e->args);
     for (i = 0; i < len; i++) {
         data[i] = jl_decode_value(s);
     }
@@ -573,11 +595,11 @@ static jl_value_t *jl_decode_value_phi(jl_ircode_state *s, uint8_t tag) JL_GC_DI
     jl_array_t *e = jl_alloc_array_1d(jl_array_int32_type, len_e);
     jl_array_t *v = jl_alloc_vec_any(len_v);
     jl_value_t *phi = jl_new_struct(jl_phinode_type, e, v);
-    int32_t *data_e = (int32_t*)(e->data);
+    int32_t *data_e = jl_array_data(e, int32_t);
     for (i = 0; i < len_e; i++) {
         data_e[i] = jl_unbox_int32(jl_decode_value(s));
     }
-    jl_value_t **data_v = (jl_value_t**)(v->data);
+    jl_value_t **data_v = jl_array_ptr_data(v);
     for (i = 0; i < len_v; i++) {
         data_v[i] = jl_decode_value(s);
     }
@@ -593,7 +615,7 @@ static jl_value_t *jl_decode_value_phic(jl_ircode_state *s, uint8_t tag) JL_GC_D
         len = read_int32(s->s);
     jl_array_t *v = jl_alloc_vec_any(len);
     jl_value_t *phic = jl_new_struct(jl_phicnode_type, v);
-    jl_value_t **data = (jl_value_t**)(v->data);
+    jl_value_t **data = jl_array_ptr_data(v);
     for (i = 0; i < len; i++) {
         data[i] = jl_decode_value(s);
     }
@@ -678,6 +700,8 @@ static jl_value_t *jl_decode_value(jl_ircode_state *s) JL_GC_DISABLED
         return v;
     case TAG_ARRAY: JL_FALLTHROUGH; case TAG_ARRAY1D:
         return jl_decode_value_array(s, tag);
+    case TAG_MEMORYT:
+        return jl_decode_value_memory(s, jl_decode_value(s), jl_unbox_long(jl_decode_value(s)));
     case TAG_EXPR:      JL_FALLTHROUGH;
     case TAG_LONG_EXPR: JL_FALLTHROUGH;
     case TAG_CALL1:     JL_FALLTHROUGH;
@@ -792,10 +816,10 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
     write_uint8(s.s, code->purity.bits);
     write_uint16(s.s, code->inlining_cost);
 
-    size_t nslots = jl_array_len(code->slotflags);
+    size_t nslots = jl_array_nrows(code->slotflags);
     assert(nslots >= m->nargs && nslots < INT32_MAX); // required by generated functions
     write_int32(s.s, nslots);
-    ios_write(s.s, (char*)jl_array_data(code->slotflags), nslots);
+    ios_write(s.s, jl_array_data(code->slotflags, const char), nslots);
 
     // N.B.: The layout of everything before this point is explicitly referenced
     // by the various jl_ir_ accessors. Make sure to adjust those if you change
@@ -825,20 +849,20 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
     else
         jl_encode_value(&s, jl_nothing);
 
-    size_t nstmt = jl_array_len(code->code);
-    assert(nstmt == jl_array_len(code->codelocs));
-    if (jl_array_len(code->linetable) < 256) {
+    size_t nstmt = jl_array_nrows(code->code);
+    assert(nstmt == jl_array_nrows(code->codelocs));
+    if (jl_array_nrows(code->linetable) < 256) {
         for (i = 0; i < nstmt; i++) {
-            write_uint8(s.s, ((int32_t*)jl_array_data(code->codelocs))[i]);
+            write_uint8(s.s, jl_array_data(code->codelocs, int32_t)[i]);
         }
     }
-    else if (jl_array_len(code->linetable) < 65536) {
+    else if (jl_array_nrows(code->linetable) < 65536) {
         for (i = 0; i < nstmt; i++) {
-            write_uint16(s.s, ((int32_t*)jl_array_data(code->codelocs))[i]);
+            write_uint16(s.s, jl_array_data(code->codelocs, int32_t)[i]);
         }
     }
     else {
-        ios_write(s.s, (char*)jl_array_data(code->codelocs), nstmt * sizeof(int32_t));
+        ios_write(s.s, (char*)jl_array_data(code->codelocs, int32_t), nstmt * sizeof(int32_t));
     }
 
     write_uint8(s.s, s.relocatability);
@@ -846,7 +870,7 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
     ios_flush(s.s);
     jl_string_t *v = jl_pchar_to_string(s.s->buf, s.s->size);
     ios_close(s.s);
-    if (jl_array_len(m->roots) == 0) {
+    if (jl_array_nrows(m->roots) == 0) {
         m->roots = NULL;
     }
     JL_GC_PUSH1(&v);
@@ -892,7 +916,7 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
 
     size_t nslots = read_int32(&src);
     code->slotflags = jl_alloc_array_1d(jl_array_uint8_type, nslots);
-    ios_readall(s.s, (char*)jl_array_data(code->slotflags), nslots);
+    ios_readall(s.s, jl_array_data(code->slotflags, char), nslots);
 
     for (i = 0; i < 6; i++) {
         if (i == 1)  // skip codelocs
@@ -909,20 +933,20 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
         slotnames = m->slot_syms;
     code->slotnames = jl_uncompress_argnames(slotnames);
 
-    size_t nstmt = jl_array_len(code->code);
+    size_t nstmt = jl_array_nrows(code->code);
     code->codelocs = (jl_value_t*)jl_alloc_array_1d(jl_array_int32_type, nstmt);
-    if (jl_array_len(code->linetable) < 256) {
+    if (jl_array_nrows(code->linetable) < 256) {
         for (i = 0; i < nstmt; i++) {
-            ((int32_t*)jl_array_data(code->codelocs))[i] = read_uint8(s.s);
+            jl_array_data(code->codelocs, int32_t)[i] = read_uint8(s.s);
         }
     }
-    else if (jl_array_len(code->linetable) < 65536) {
+    else if (jl_array_nrows(code->linetable) < 65536) {
         for (i = 0; i < nstmt; i++) {
-            ((int32_t*)jl_array_data(code->codelocs))[i] = read_uint16(s.s);
+            jl_array_data(code->codelocs, int32_t)[i] = read_uint16(s.s);
         }
     }
     else {
-        ios_readall(s.s, (char*)jl_array_data(code->codelocs), nstmt * sizeof(int32_t));
+        ios_readall(s.s, (char*)jl_array_data(code->codelocs, int32_t), nstmt * sizeof(int32_t));
     }
 
     (void) read_uint8(s.s);   // relocatability
@@ -984,7 +1008,7 @@ JL_DLLEXPORT uint16_t jl_ir_inlining_cost(jl_string_t *data)
 
 JL_DLLEXPORT jl_value_t *jl_compress_argnames(jl_array_t *syms)
 {
-    size_t nsyms = jl_array_len(syms);
+    size_t nsyms = jl_array_nrows(syms);
     size_t i, len = 0;
     for (i = 0; i < nsyms; i++) {
         jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(syms, i);
@@ -1012,7 +1036,7 @@ JL_DLLEXPORT ssize_t jl_ir_nslots(jl_value_t *data)
 {
     if (jl_is_code_info(data)) {
         jl_code_info_t *func = (jl_code_info_t*)data;
-        return jl_array_len(func->slotnames);
+        return jl_array_nrows(func->slotnames);
     }
     else {
         assert(jl_is_string(data));
@@ -1024,8 +1048,10 @@ JL_DLLEXPORT ssize_t jl_ir_nslots(jl_value_t *data)
 JL_DLLEXPORT uint8_t jl_ir_slotflag(jl_string_t *data, size_t i)
 {
     assert(i < jl_ir_nslots(data));
-    if (jl_is_code_info(data))
-        return ((uint8_t*)((jl_code_info_t*)data)->slotflags->data)[i];
+    if (jl_is_code_info(data)) {
+        jl_array_t *slotflags = ((jl_code_info_t*)data)->slotflags;
+        return jl_array_data(slotflags, uint8_t)[i];
+    }
     assert(jl_is_string(data));
     return jl_string_data(data)[2 + sizeof(uint16_t) + sizeof(int32_t) + i];
 }
@@ -1118,6 +1144,8 @@ void jl_init_serializer(void)
                      jl_uint32_type, jl_uint64_type,
                      jl_type_type_mt, jl_nonfunction_mt,
                      jl_opaque_closure_type,
+                     jl_memory_any_type,
+                     jl_memory_uint8_type,
 
                      ct->ptls->root_task,
 
@@ -1135,6 +1163,7 @@ void jl_init_serializer(void)
     deser_tag[TAG_SLOTNUMBER] = (jl_value_t*)jl_slotnumber_type;
     deser_tag[TAG_SVEC] = (jl_value_t*)jl_simplevector_type;
     deser_tag[TAG_ARRAY] = (jl_value_t*)jl_array_type;
+    deser_tag[TAG_MEMORYT] = (jl_value_t*)jl_genericmemory_type;
     deser_tag[TAG_EXPR] = (jl_value_t*)jl_expr_type;
     deser_tag[TAG_PHINODE] = (jl_value_t*)jl_phinode_type;
     deser_tag[TAG_PHICNODE] = (jl_value_t*)jl_phicnode_type;
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index fbc4b35310797..6c362fafcc756 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -436,7 +436,7 @@ void jl_extern_c_impl(jl_value_t *declrt, jl_tupletype_t *sigt)
         jl_type_error("@ccallable", (jl_value_t*)jl_anytuple_type_type, (jl_value_t*)sigt);
     // check that f is a guaranteed singleton type
     jl_datatype_t *ft = (jl_datatype_t*)jl_tparam0(sigt);
-    if (!jl_is_datatype(ft) || ft->instance == NULL)
+    if (!jl_is_datatype(ft) || !jl_is_datatype_singleton(ft))
         jl_error("@ccallable: function object must be a singleton");
 
     // compute / validate return type
diff --git a/src/jl_exported_data.inc b/src/jl_exported_data.inc
index aa23b9d7b8205..11617bea9ec65 100644
--- a/src/jl_exported_data.inc
+++ b/src/jl_exported_data.inc
@@ -4,8 +4,12 @@
 #define JL_EXPORTED_DATA_POINTERS(XX) \
     XX(jl_abstractarray_type) \
     XX(jl_abstractstring_type) \
+    XX(jl_addrspace_type) \
+    XX(jl_addrspace_typename) \
+    XX(jl_addrspacecore_type) \
     XX(jl_an_empty_string) \
     XX(jl_an_empty_vec_any) \
+    XX(jl_an_empty_memory_any) \
     XX(jl_anytuple_type) \
     XX(jl_anytuple_type_type) \
     XX(jl_any_type) \
@@ -64,7 +68,17 @@
     XX(jl_llvmpointer_typename) \
     XX(jl_loaderror_type) \
     XX(jl_main_module) \
+    XX(jl_memory_any_type) \
     XX(jl_memory_exception) \
+    XX(jl_genericmemory_type) \
+    XX(jl_genericmemory_typename) \
+    XX(jl_memory_uint8_type) \
+    XX(jl_memory_uint64_type) \
+    XX(jl_memoryref_any_type) \
+    XX(jl_genericmemoryref_type) \
+    XX(jl_genericmemoryref_typename) \
+    XX(jl_memoryref_uint8_type) \
+    XX(jl_memoryref_uint64_type) \
     XX(jl_methoderror_type) \
     XX(jl_method_instance_type) \
     XX(jl_method_match_type) \
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 4ac04d6d0fccd..f8a756ad216f7 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -6,8 +6,6 @@
     XX(jl_adopt_thread) \
     XX(jl_alignment) \
     XX(jl_alloc_array_1d) \
-    XX(jl_alloc_array_2d) \
-    XX(jl_alloc_array_3d) \
     XX(jl_alloc_string) \
     XX(jl_alloc_svec) \
     XX(jl_alloc_svec_uninit) \
@@ -21,29 +19,15 @@
     XX(jl_apply_type1) \
     XX(jl_apply_type2) \
     XX(jl_argument_datatype) \
-    XX(jl_arraylen) \
-    XX(jl_arrayref) \
-    XX(jl_arrayset) \
-    XX(jl_arrayunset) \
-    XX(jl_array_copy) \
-    XX(jl_array_del_at) \
-    XX(jl_array_del_beg) \
     XX(jl_array_del_end) \
     XX(jl_array_eltype) \
-    XX(jl_array_grow_at) \
-    XX(jl_array_grow_beg) \
     XX(jl_array_grow_end) \
-    XX(jl_array_isassigned) \
     XX(jl_array_ptr) \
     XX(jl_array_ptr_1d_append) \
     XX(jl_array_ptr_1d_push) \
-    XX(jl_array_ptr_copy) \
+    XX(jl_genericmemory_owner) \
     XX(jl_array_rank) \
-    XX(jl_array_size) \
-    XX(jl_array_sizehint) \
     XX(jl_array_to_string) \
-    XX(jl_array_typetagdata) \
-    XX(jl_array_validate_dims) \
     XX(jl_atexit_hook) \
     XX(jl_atomic_bool_cmpswap_bits) \
     XX(jl_atomic_cmpswap_bits) \
@@ -341,7 +325,6 @@
     XX(jl_module_uuid) \
     XX(jl_native_alignment) \
     XX(jl_nb_available) \
-    XX(jl_new_array) \
     XX(jl_new_bits) \
     XX(jl_new_codeinst) \
     XX(jl_new_code_info_uninit) \
@@ -393,7 +376,6 @@
     XX(jl_profile_maxlen_data) \
     XX(jl_profile_start_timer) \
     XX(jl_profile_stop_timer) \
-    XX(jl_ptrarrayref) \
     XX(jl_ptr_to_array) \
     XX(jl_ptr_to_array_1d) \
     XX(jl_queue_work) \
@@ -404,7 +386,6 @@
     XX(jl_read_verify_header) \
     XX(jl_realloc) \
     XX(jl_register_newmeth_tracer) \
-    XX(jl_reshape_array) \
     XX(jl_resolve_globals_in_ir) \
     XX(jl_restore_excstack) \
     XX(jl_restore_incremental) \
diff --git a/src/jlapi.c b/src/jlapi.c
index 29be3b9e6179c..6003aa5cee7d4 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -41,12 +41,12 @@ JL_DLLEXPORT void jl_set_ARGS(int argc, char **argv)
             jl_set_const(jl_core_module, jl_symbol("ARGS"), (jl_value_t*)args);
             JL_GC_POP();
         }
-        assert(jl_array_len(args) == 0);
+        assert(jl_array_nrows(args) == 0);
         jl_array_grow_end(args, argc);
         int i;
         for (i = 0; i < argc; i++) {
             jl_value_t *s = (jl_value_t*)jl_cstr_to_string(argv[i]);
-            jl_arrayset(args, s, i);
+            jl_array_ptr_set(args, i, s);
         }
     }
 }
@@ -165,8 +165,11 @@ JL_DLLEXPORT int jl_array_rank(jl_value_t *a)
     return jl_array_ndims(a);
 }
 
-JL_DLLEXPORT size_t jl_array_size(jl_value_t *a, int d)
+JL_DLLEXPORT size_t jl_array_size(jl_array_t *a, int d)
 {
+    // n.b this functions only use was to violate the vector abstraction, so we have to continue to emulate that
+    if (d >= jl_array_ndims(a))
+        return a->ref.mem->length;
     return jl_array_dim(a, d);
 }
 
diff --git a/src/jltypes.c b/src/jltypes.c
index 33b52158488a3..154fa49953f34 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -65,7 +65,9 @@ static int layout_uses_free_typevars(jl_value_t *v, jl_typeenv_t *env)
         }
         if (jl_is_datatype(v)) {
             jl_datatype_t *dt = (jl_datatype_t*)v;
-            if (dt->layout || dt->isconcretetype || !dt->name->mayinlinealloc)
+            if (dt->isconcretetype)
+                return 0;
+            if (dt->layout || !dt->name->mayinlinealloc)
                 return 0;
             if (dt->name == jl_namedtuple_typename)
                 return layout_uses_free_typevars(jl_tparam0(dt), env) || layout_uses_free_typevars(jl_tparam1(dt), env);
@@ -290,7 +292,13 @@ JL_DLLEXPORT int jl_has_typevar_from_unionall(jl_value_t *t, jl_unionall_t *ua)
 
 int jl_has_fixed_layout(jl_datatype_t *dt)
 {
-    if (dt->layout || dt->isconcretetype)
+    if (dt->isconcretetype)
+        return 1;
+    if (jl_is_genericmemory_type(dt)) { // GenericMemory{kind,addrspace,T} uses T for final layout, which is a parameter not a field however
+        // optionally: return !layout_uses_free_typevars(jl_tparam1(dt), env);
+        return 0;
+    }
+    if (dt->layout)
         return 1;
     if (dt->name->abstract)
         return 0;
@@ -313,15 +321,15 @@ int jl_has_fixed_layout(jl_datatype_t *dt)
 int jl_type_mappable_to_c(jl_value_t *ty)
 {
     assert(!jl_is_typevar(ty) && jl_is_type(ty));
+    if (jl_is_array_type(ty) || jl_is_genericmemory_type(ty) ||
+        (jl_is_datatype(ty) && ((jl_datatype_t*)ty)->layout != NULL &&
+            jl_is_layout_opaque(((jl_datatype_t*)ty)->layout)))
+        return 1; // as boxed
     if (jl_is_structtype(ty))
         return jl_has_fixed_layout((jl_datatype_t*)ty) && ((jl_datatype_t*)ty)->name->atomicfields == NULL;
     if (jl_is_primitivetype(ty))
-        return 1;
-    if (ty == (jl_value_t*)jl_any_type || ty == (jl_value_t*)jl_bottom_type)
-        return 1; // as boxed
-    if (jl_is_abstract_ref_type(ty) || jl_is_array_type(ty) ||
-        (jl_is_datatype(ty) && ((jl_datatype_t*)ty)->layout != NULL &&
-            jl_is_layout_opaque(((jl_datatype_t*)ty)->layout)))
+        return 1; // as isbits
+    if (ty == (jl_value_t*)jl_any_type || ty == (jl_value_t*)jl_bottom_type || jl_is_abstract_ref_type(ty))
         return 1; // as boxed
     return 0; // refuse to map Union and UnionAll to C
 }
@@ -1408,6 +1416,15 @@ JL_DLLEXPORT jl_value_t *jl_apply_type2(jl_value_t *tc, jl_value_t *p1, jl_value
     return jl_apply_type(tc, args, 2);
 }
 
+JL_DLLEXPORT jl_value_t *jl_apply_type3(jl_value_t *tc, jl_value_t *p1, jl_value_t *p2, jl_value_t *p3)
+{
+    jl_value_t *args[3];
+    args[0] = p1;
+    args[1] = p2;
+    args[2] = p3;
+    return jl_apply_type(tc, args, 3);
+}
+
 jl_datatype_t *jl_apply_modify_type(jl_value_t *dt)
 {
     jl_datatype_t *rettyp = (jl_datatype_t*)jl_apply_type2(jl_pair_type, dt, dt);
@@ -2094,6 +2111,14 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
             ndt->types = jl_emptysvec; // XXX: this is essentially always false
         }
     }
+    else if (tn == jl_genericmemoryref_typename || tn == jl_genericmemory_typename) {
+        jl_value_t *isatomic = jl_svecref(p, 0);
+        if (!jl_is_typevar(isatomic) && !jl_is_symbol(isatomic))
+            jl_type_error_rt("GenericMemory", "isatomic parameter", (jl_value_t*)jl_symbol_type, isatomic);
+        jl_value_t *addrspace = jl_svecref(p, 2);
+        if (!jl_is_typevar(addrspace) && !jl_is_addrspace(addrspace))
+            jl_type_error_rt("GenericMemory", "addrspace parameter", (jl_value_t*)jl_addrspace_type, addrspace);
+    }
 
     jl_datatype_t *primarydt = ((jl_datatype_t*)jl_unwrap_unionall(tn->wrapper));
     jl_precompute_memoized_dt(ndt, cacheable);
@@ -2498,7 +2523,7 @@ void jl_reinstantiate_inner_types(jl_datatype_t *t) // can throw!
     if (partial == NULL)
         return;
     if (n == 0) {
-        assert(jl_array_len(partial) == 0);
+        assert(jl_array_nrows(partial) == 0);
         return;
     }
 
@@ -2509,7 +2534,7 @@ void jl_reinstantiate_inner_types(jl_datatype_t *t) // can throw!
         env[i].prev = i == 0 ? NULL : &env[i - 1];
     }
 
-    for (j = 0; j < jl_array_len(partial); j++) {
+    for (j = 0; j < jl_array_nrows(partial); j++) {
         jl_datatype_t *ndt = (jl_datatype_t*)jl_array_ptr_ref(partial, j);
         if (ndt == NULL)
             continue;
@@ -2522,7 +2547,7 @@ void jl_reinstantiate_inner_types(jl_datatype_t *t) // can throw!
     }
 
     if (t->types != jl_emptysvec) {
-        for (j = 0; j < jl_array_len(partial); j++) {
+        for (j = 0; j < jl_array_nrows(partial); j++) {
             jl_datatype_t *ndt = (jl_datatype_t*)jl_array_ptr_ref(partial, j);
             if (ndt == NULL)
                 continue;
@@ -2865,7 +2890,59 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_function_type->name->mt = NULL; // subtypes of Function have independent method tables
     jl_builtin_type->name->mt = NULL;  // so they don't share the Any type table
 
-    jl_svec_t *tv = jl_svec2(tvar("T"), tvar("N"));
+    jl_svec_t *tv;
+
+    jl_module_type =
+        jl_new_datatype(jl_symbol("Module"), core, jl_any_type, jl_emptysvec,
+                        jl_emptysvec, jl_emptysvec, jl_emptysvec, 0, 1, 0);
+    XX(module);
+    assert(jl_module_type->instance == NULL);
+    jl_compute_field_offsets(jl_module_type);
+
+    jl_binding_type =
+        jl_new_datatype(jl_symbol("Binding"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(5, "value", "globalref", "owner", "ty", "flags"),
+                        jl_svec(5, jl_any_type, jl_any_type/*jl_globalref_type*/, jl_any_type/*jl_binding_type*/, jl_type_type, jl_uint8_type),
+                        jl_emptysvec, 0, 1, 0);
+    const static uint32_t binding_atomicfields[] = { 0x0015 }; // Set fields 1, 3, 4 as atomic
+    jl_binding_type->name->atomicfields = binding_atomicfields;
+    const static uint32_t binding_constfields[] = { 0x0002 }; // Set fields 2 as constant
+    jl_binding_type->name->constfields = binding_constfields;
+
+    jl_globalref_type =
+        jl_new_datatype(jl_symbol("GlobalRef"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(3, "mod", "name", "binding"),
+                        jl_svec(3, jl_module_type, jl_symbol_type, jl_binding_type),
+                        jl_emptysvec, 0, 0, 3);
+
+    core = jl_new_module(jl_symbol("Core"), NULL);
+    core->parent = core;
+    jl_type_typename->mt->module = core;
+    jl_core_module = core;
+    core = NULL; // not ready yet to use
+
+    tv = jl_svec1(tvar("Backend"));
+    jl_addrspace_typename =
+        jl_new_primitivetype((jl_value_t*)jl_symbol("AddrSpace"), core, jl_any_type, tv, 8)->name;
+    jl_addrspace_type = (jl_unionall_t*)jl_addrspace_typename->wrapper;
+    jl_addrspacecore_type = (jl_datatype_t*)jl_apply_type1((jl_value_t*)jl_addrspace_type, (jl_value_t*)jl_core_module);
+    jl_value_t *cpumem = jl_permbox8(jl_addrspacecore_type, 0, 0);
+
+    tv = jl_svec1(tvar("T"));
+    jl_ref_type = (jl_unionall_t*)
+        jl_new_abstracttype((jl_value_t*)jl_symbol("Ref"), core, jl_any_type, tv)->name->wrapper;
+
+    tv = jl_svec1(tvar("T"));
+    jl_pointer_typename =
+        jl_new_primitivetype((jl_value_t*)jl_symbol("Ptr"), core,
+                             (jl_datatype_t*)jl_apply_type((jl_value_t*)jl_ref_type, jl_svec_data(tv), 1),
+                             tv,
+                             sizeof(void*) * 8)->name;
+    jl_pointer_type = (jl_unionall_t*)jl_pointer_typename->wrapper;
+    jl_value_t *pointer_void = jl_apply_type1((jl_value_t*)jl_pointer_type, (jl_value_t*)jl_nothing_type);
+    jl_voidpointer_type = (jl_datatype_t*)pointer_void;
+
+    tv = jl_svec2(tvar("T"), tvar("N"));
     jl_abstractarray_type = (jl_unionall_t*)
         jl_new_abstracttype((jl_value_t*)jl_symbol("AbstractArray"), core,
                             jl_any_type, tv)->name->wrapper;
@@ -2876,13 +2953,44 @@ void jl_init_types(void) JL_GC_DISABLED
                             (jl_datatype_t*)jl_apply_type((jl_value_t*)jl_abstractarray_type, jl_svec_data(tv), 2),
                             tv)->name->wrapper;
 
+    tv = jl_svec(3, tvar("isatomic"), tvar("T"), tvar("addrspace"));
+    jl_datatype_t *jl_memory_supertype = (jl_datatype_t*)jl_apply_type2((jl_value_t*)jl_densearray_type, jl_svecref(tv, 1), jl_box_long(1));
+    jl_datatype_t *memory_datatype =
+        jl_new_datatype(jl_symbol("GenericMemory"), core, jl_memory_supertype, tv,
+                        jl_perm_symsvec(2, "length", "ptr"),
+                        jl_svec(2, jl_long_type, pointer_void),
+                        jl_emptysvec, 0, 1, 2);
+    jl_genericmemory_typename = memory_datatype->name;
+    jl_genericmemory_type = (jl_unionall_t*)jl_genericmemory_typename->wrapper;
+    const static uint32_t memory_constfields[1] = { 0x00000003 }; // (1<<1)|(1<<0)
+    memory_datatype->name->constfields = memory_constfields;
+    memory_datatype->ismutationfree = 0;
+
+    jl_datatype_t *jl_memoryref_supertype = (jl_datatype_t*)jl_apply_type1((jl_value_t*)jl_ref_type, jl_svecref(tv, 1));
+    jl_datatype_t *memoryref_datatype =
+        jl_new_datatype(jl_symbol("GenericMemoryRef"), core, jl_memoryref_supertype, tv,
+                        jl_perm_symsvec(2, "ptr_or_offset", "mem"),
+                        jl_svec(2, pointer_void, memory_datatype),
+                        jl_emptysvec, 0, 0, 2);
+    jl_genericmemoryref_typename = memoryref_datatype->name;
+    jl_genericmemoryref_type = (jl_unionall_t*)jl_genericmemoryref_typename->wrapper;
+    memoryref_datatype->ismutationfree = 0;
+
+    jl_memory_any_type = jl_apply_type3((jl_value_t*)jl_genericmemory_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_any_type, cpumem);
+    jl_memory_uint8_type = jl_apply_type3((jl_value_t*)jl_genericmemory_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_uint8_type, cpumem);
+    jl_memoryref_any_type = jl_apply_type3((jl_value_t*)jl_genericmemoryref_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_any_type, cpumem);
+    jl_memoryref_uint8_type = jl_apply_type3((jl_value_t*)jl_genericmemoryref_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_uint8_type, cpumem);
+
     tv = jl_svec2(tvar("T"), tvar("N"));
-    jl_array_type = (jl_unionall_t*)
-        jl_new_datatype(jl_symbol("Array"), core,
+    jl_array_typename = jl_new_datatype(jl_symbol("Array"), core,
                         (jl_datatype_t*)jl_apply_type((jl_value_t*)jl_densearray_type, jl_svec_data(tv), 2),
-                        tv, jl_emptysvec, jl_emptysvec, jl_emptysvec, 0, 1, 0)->name->wrapper;
-    jl_array_typename = ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_array_type))->name;
-    jl_compute_field_offsets((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_array_type));
+                        tv,
+                        jl_perm_symsvec(2, "ref", "size"),
+                        jl_svec(2,
+                            jl_apply_type3((jl_value_t*)jl_genericmemoryref_type, (jl_value_t*)jl_not_atomic_sym, jl_svecref(tv, 0), cpumem),
+                            jl_apply_type1((jl_value_t*)jl_tuple_type, (jl_value_t*)jl_wrap_vararg((jl_value_t*)jl_long_type, jl_svecref(tv, 1), 0))),
+                            jl_emptysvec, 0, 1, 2)->name;
+    jl_array_type = (jl_unionall_t*)jl_array_typename->wrapper;
 
     jl_array_any_type = jl_apply_type2((jl_value_t*)jl_array_type, (jl_value_t*)jl_any_type, jl_box_long(1));
     jl_array_symbol_type = jl_apply_type2((jl_value_t*)jl_array_type, (jl_value_t*)jl_symbol_type, jl_box_long(1));
@@ -2891,8 +2999,18 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_array_int32_type = jl_apply_type2((jl_value_t*)jl_array_type, (jl_value_t*)jl_int32_type, jl_box_long(1));
     jl_array_uint64_type = jl_apply_type2((jl_value_t*)jl_array_type, (jl_value_t*)jl_uint64_type, jl_box_long(1));
     jl_an_empty_vec_any = (jl_value_t*)jl_alloc_vec_any(0); // used internally
-    jl_atomic_store_relaxed(&jl_nonfunction_mt->leafcache, (jl_array_t*)jl_an_empty_vec_any);
-    jl_atomic_store_relaxed(&jl_type_type_mt->leafcache, (jl_array_t*)jl_an_empty_vec_any);
+    jl_an_empty_memory_any = (jl_value_t*)jl_alloc_memory_any(0); // used internally
+    jl_atomic_store_relaxed(&jl_nonfunction_mt->leafcache, (jl_genericmemory_t*)jl_an_empty_memory_any);
+    jl_atomic_store_relaxed(&jl_type_type_mt->leafcache, (jl_genericmemory_t*)jl_an_empty_memory_any);
+
+    // finish initializing module Core
+    core = jl_core_module;
+    jl_atomic_store_relaxed(&core->bindingkeyset, (jl_array_t*)jl_an_empty_vec_any);
+    // export own name, so "using Foo" makes "Foo" itself visible
+    jl_set_const(core, core->name, (jl_value_t*)core);
+    jl_module_public(core, core->name, 1);
+    jl_set_const(core, jl_symbol("CPU"), (jl_value_t*)cpumem);
+    core = NULL;
 
     jl_expr_type =
         jl_new_datatype(jl_symbol("Expr"), core,
@@ -2901,13 +3019,6 @@ void jl_init_types(void) JL_GC_DISABLED
                         jl_svec(2, jl_symbol_type, jl_array_any_type),
                         jl_emptysvec, 0, 1, 2);
 
-    jl_module_type =
-        jl_new_datatype(jl_symbol("Module"), core, jl_any_type, jl_emptysvec,
-                        jl_emptysvec, jl_emptysvec, jl_emptysvec, 0, 1, 0);
-    XX(module);
-    jl_module_type->instance = NULL;
-    jl_compute_field_offsets(jl_module_type);
-
     jl_value_t *symornothing[2] = { (jl_value_t*)jl_symbol_type, (jl_value_t*)jl_void_type };
     jl_linenumbernode_type =
         jl_new_datatype(jl_symbol("LineNumberNode"), core, jl_any_type, jl_emptysvec,
@@ -3201,17 +3312,6 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_intrinsic_type = jl_new_primitivetype((jl_value_t*)jl_symbol("IntrinsicFunction"), core,
                                              jl_builtin_type, jl_emptysvec, 32);
 
-    tv = jl_svec1(tvar("T"));
-    jl_ref_type = (jl_unionall_t*)
-        jl_new_abstracttype((jl_value_t*)jl_symbol("Ref"), core, jl_any_type, tv)->name->wrapper;
-
-    tv = jl_svec1(tvar("T"));
-    jl_pointer_type = (jl_unionall_t*)
-        jl_new_primitivetype((jl_value_t*)jl_symbol("Ptr"), core,
-                             (jl_datatype_t*)jl_apply_type((jl_value_t*)jl_ref_type, jl_svec_data(tv), 1), tv,
-                             sizeof(void*)*8)->name->wrapper;
-    jl_pointer_typename = ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_pointer_type))->name;
-
     // LLVMPtr{T, AS} where {T, AS}
     jl_tvar_t *elvar = tvar("T");
     tv = jl_svec2(elvar, tvar("AS"));
@@ -3283,24 +3383,6 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_value_t *listt = jl_new_struct(jl_uniontype_type, jl_task_type, jl_nothing_type);
     jl_svecset(jl_task_type->types, 0, listt);
 
-    jl_binding_type =
-        jl_new_datatype(jl_symbol("Binding"), core, jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(5, "value", "globalref", "owner", "ty", "flags"),
-                        jl_svec(5, jl_any_type, jl_any_type/*jl_globalref_type*/, jl_any_type/*jl_binding_type*/, jl_type_type, jl_uint8_type),
-                        jl_emptysvec, 0, 1, 0);
-    const static uint32_t binding_atomicfields[] = { 0x0015 }; // Set fields 1, 3, 4 as atomic
-    jl_binding_type->name->atomicfields = binding_atomicfields;
-    const static uint32_t binding_constfields[] = { 0x0002 }; // Set fields 2 as constant
-    jl_binding_type->name->constfields = binding_constfields;
-
-    jl_globalref_type =
-        jl_new_datatype(jl_symbol("GlobalRef"), core, jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(3, "mod", "name", "binding"),
-                        jl_svec(3, jl_module_type, jl_symbol_type, jl_binding_type),
-                        jl_emptysvec, 0, 0, 3);
-
-    jl_value_t *pointer_void = jl_apply_type1((jl_value_t*)jl_pointer_type, (jl_value_t*)jl_nothing_type);
-    jl_voidpointer_type = (jl_datatype_t*)pointer_void;
     tv = jl_svec2(tvar("A"), tvar("R"));
     jl_opaque_closure_type = (jl_unionall_t*)jl_new_datatype(jl_symbol("OpaqueClosure"), core, jl_function_type, tv,
         // N.B.: OpaqueClosure call code relies on specptr being field 5.
@@ -3349,7 +3431,6 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_compute_field_offsets(jl_uniontype_type);
     jl_compute_field_offsets(jl_tvar_type);
     jl_compute_field_offsets(jl_methtable_type);
-    jl_compute_field_offsets(jl_module_type);
     jl_compute_field_offsets(jl_method_instance_type);
     jl_compute_field_offsets(jl_code_instance_type);
     jl_compute_field_offsets(jl_unionall_type);
@@ -3361,6 +3442,8 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_symbol_type->ismutationfree = jl_symbol_type->isidentityfree = 1;
     jl_simplevector_type->ismutationfree = jl_simplevector_type->isidentityfree = 1;
     jl_datatype_type->ismutationfree = 1;
+    assert(((jl_datatype_t*)jl_array_any_type)->ismutationfree == 0);
+    assert(((jl_datatype_t*)jl_array_uint8_type)->ismutationfree == 0);
 
     // Technically not ismutationfree, but there's a separate system to deal
     // with mutations for global state.
@@ -3368,15 +3451,6 @@ void jl_init_types(void) JL_GC_DISABLED
     // Module object identity is determined by its name and parent name.
     jl_module_type->isidentityfree = 1;
 
-    // Array's mutable data is hidden, so we need to override it
-    ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_array_type))->ismutationfree = 0;
-    ((jl_datatype_t*)jl_array_any_type)->ismutationfree = 0;
-    ((jl_datatype_t*)jl_array_symbol_type)->ismutationfree = 0;
-    ((jl_datatype_t*)jl_array_uint8_type)->ismutationfree = 0;
-    ((jl_datatype_t*)jl_array_uint32_type)->ismutationfree = 0;
-    ((jl_datatype_t*)jl_array_int32_type)->ismutationfree = 0;
-    ((jl_datatype_t*)jl_array_uint64_type)->ismutationfree = 0;
-
     // override the preferred layout for a couple types
     jl_lineinfonode_type->name->mayinlinealloc = 0; // FIXME: assumed to be a pointer by codegen
 
diff --git a/src/julia.h b/src/julia.h
index bcef58d647c38..05f3c936fe3d1 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -13,6 +13,7 @@
 #undef jl_setjmp
 #undef jl_longjmp
 #undef jl_egal
+#undef jl_genericmemory_owner
 #endif
 
 #include "julia_fasttls.h"
@@ -120,7 +121,8 @@ JL_DLLEXPORT jl_taggedvalue_t *_jl_astaggedvalue(jl_value_t *v JL_PROPAGATES_ROO
 jl_value_t *_jl_valueof(jl_taggedvalue_t *tv JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
 #define jl_valueof(v) _jl_valueof((jl_taggedvalue_t*)(v))
 JL_DLLEXPORT jl_value_t *_jl_typeof(jl_value_t *v JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
-#define jl_typeof(v) _jl_typeof((jl_value_t*)(v))
+#define jl_typeof(v) (_jl_typeof((jl_value_t*)(v)))
+#define jl_typetagof(v) ((uintptr_t)_jl_typeof((jl_value_t*)(v)))
 #else
 #define jl_astaggedvalue(v)                                             \
     ((jl_taggedvalue_t*)((char*)(v) - sizeof(jl_taggedvalue_t)))
@@ -128,6 +130,8 @@ JL_DLLEXPORT jl_value_t *_jl_typeof(jl_value_t *v JL_PROPAGATES_ROOT) JL_NOTSAFE
     ((jl_value_t*)((char*)(v) + sizeof(jl_taggedvalue_t)))
 #define jl_typeof(v)                                                    \
     jl_to_typeof(jl_typetagof(v))
+#define jl_typetagof(v)                                                 \
+    ((jl_astaggedvalue(v)->header) & ~(uintptr_t)15)
 #endif
 static inline void jl_set_typeof(void *v, void *t) JL_NOTSAFEPOINT
 {
@@ -135,8 +139,6 @@ static inline void jl_set_typeof(void *v, void *t) JL_NOTSAFEPOINT
     jl_taggedvalue_t *tag = jl_astaggedvalue(v);
     jl_atomic_store_relaxed((_Atomic(jl_value_t*)*)&tag->type, (jl_value_t*)t);
 }
-#define jl_typetagof(v)                                                 \
-    ((jl_astaggedvalue(v)->header) & ~(uintptr_t)15)
 #define jl_typeis(v,t) (jl_typeof(v)==(jl_value_t*)(t))
 #define jl_typetagis(v,t) (jl_typetagof(v)==(uintptr_t)(t))
 #define jl_set_typetagof(v,t,gc) (jl_set_typeof((v), (void*)(((uintptr_t)(t) << 4) | (gc))))
@@ -167,47 +169,36 @@ typedef struct {
     // jl_value_t *data[];
 } jl_svec_t;
 
-typedef struct {
-    /*
-      how - allocation style
-      0 = data is inlined, or a foreign pointer we don't manage
-      1 = julia-allocated buffer that needs to be marked
-      2 = malloc-allocated pointer this array object manages
-      3 = has a pointer to the object that owns the data
-    */
-    uint16_t how:2;
-    uint16_t ndims:9;
-    uint16_t pooled:1;
-    uint16_t ptrarray:1; // representation is pointer array
-    uint16_t hasptr:1; // representation has embedded pointers
-    uint16_t isshared:1; // data is shared by multiple Arrays
-    uint16_t isaligned:1; // data allocated with memalign
-} jl_array_flags_t;
-
 JL_EXTENSION typedef struct {
     JL_DATA_TYPE
-    void *data;
     size_t length;
-    jl_array_flags_t flags;
-    uint16_t elsize;  // element size including alignment (dim 1 memory stride)
-    uint32_t offset;  // for 1-d only. does not need to get big.
-    size_t nrows;
-    union {
-        // 1d
-        size_t maxsize;
-        // Nd
-        size_t ncols;
-    };
-    // other dim sizes go here for ndims > 2
+    void *ptr;
+    // followed by padding and inline data, or owner pointer
+#ifdef _P64
+    // union {
+    //     jl_value_t *owner;
+    //     T inl[];
+    // };
+#else
+    //
+    // jl_value_t *owner;
+    // size_t padding[1];
+    // T inl[];
+#endif
+} jl_genericmemory_t;
+
+JL_EXTENSION typedef struct {
+    JL_DATA_TYPE
+    void *ptr_or_offset;
+    jl_genericmemory_t *mem;
+} jl_genericmemoryref_t;
 
-    // followed by alignment padding and inline data, or owner pointer
+JL_EXTENSION typedef struct {
+    JL_DATA_TYPE
+    jl_genericmemoryref_t ref;
+    size_t dimsize[]; // length for 1-D, otherwise length is mem->length
 } jl_array_t;
 
-// compute # of extra words needed to store dimensions
-STATIC_INLINE int jl_array_ndimwords(uint32_t ndims) JL_NOTSAFEPOINT
-{
-    return (ndims < 3 ? 0 : ndims-2);
-}
 
 typedef struct _jl_datatype_t jl_tupletype_t;
 struct _jl_code_instance_t;
@@ -539,9 +530,14 @@ typedef struct {
     uint32_t npointers; // number of pointers embedded inside
     int32_t first_ptr; // index of the first pointer (or -1)
     uint16_t alignment; // strictest alignment over all fields
-    uint16_t haspadding : 1; // has internal undefined bytes
-    uint16_t fielddesc_type : 2; // 0 -> 8, 1 -> 16, 2 -> 32, 3 -> foreign type
-    uint16_t padding : 13;
+    struct { // combine these fields into a struct so that we can take addressof them
+        uint16_t haspadding : 1; // has internal undefined bytes
+        uint16_t fielddesc_type : 2; // 0 -> 8, 1 -> 16, 2 -> 32, 3 -> foreign type
+        // metadata bit only for GenericMemory eltype layout
+        uint16_t arrayelem_isboxed : 1;
+        uint16_t arrayelem_isunion : 1;
+        uint16_t padding : 11;
+    } flags;
     // union {
     //     jl_fielddesc8_t field8[nfields];
     //     jl_fielddesc16_t field16[nfields];
@@ -664,10 +660,10 @@ typedef struct _jl_typemap_level_t {
     // next split may be on Type{T} as LeafTypes then TypeName's parents up to Any
     // next split may be on LeafType
     // next split may be on TypeName
-    _Atomic(jl_array_t*) arg1; // contains LeafType (in a map of non-abstract TypeName)
-    _Atomic(jl_array_t*) targ; // contains Type{LeafType} (in a map of non-abstract TypeName)
-    _Atomic(jl_array_t*) name1; // a map for a map for TypeName, for parents up to (excluding) Any
-    _Atomic(jl_array_t*) tname; // a map for Type{TypeName}, for parents up to (including) Any
+    _Atomic(jl_genericmemory_t*) arg1; // contains LeafType (in a map of non-abstract TypeName)
+    _Atomic(jl_genericmemory_t*) targ; // contains Type{LeafType} (in a map of non-abstract TypeName)
+    _Atomic(jl_genericmemory_t*) name1; // a map for a map for TypeName, for parents up to (excluding) Any
+    _Atomic(jl_genericmemory_t*) tname; // a map for Type{TypeName}, for parents up to (including) Any
     // next a linear list of things too complicated at this level for analysis (no more levels)
     _Atomic(jl_typemap_entry_t*) linear;
     // finally, start a new level if the type at offs is Any
@@ -679,7 +675,7 @@ typedef struct _jl_methtable_t {
     JL_DATA_TYPE
     jl_sym_t *name; // sometimes used for debug printing
     _Atomic(jl_typemap_t*) defs;
-    _Atomic(jl_array_t*) leafcache;
+    _Atomic(jl_genericmemory_t*) leafcache;
     _Atomic(jl_typemap_t*) cache;
     _Atomic(intptr_t) max_args;  // max # of non-vararg arguments in a signature
     jl_module_t *module; // sometimes used for debug printing
@@ -809,10 +805,17 @@ extern JL_DLLIMPORT jl_datatype_t *jl_code_instance_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_code_info_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_method_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_module_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_unionall_t *jl_addrspace_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_typename_t *jl_addrspace_typename JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_datatype_t *jl_addrspacecore_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_unionall_t *jl_abstractarray_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_unionall_t *jl_densearray_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_unionall_t *jl_array_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_typename_t *jl_array_typename JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_unionall_t *jl_genericmemory_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_typename_t *jl_genericmemory_typename JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_unionall_t *jl_genericmemoryref_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_typename_t *jl_genericmemoryref_typename JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_weakref_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_abstractstring_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_string_type JL_GLOBALLY_ROOTED;
@@ -833,6 +836,7 @@ extern JL_DLLIMPORT jl_value_t *jl_undefref_exception JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_interrupt_exception JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_boundserror_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_an_empty_vec_any JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_an_empty_memory_any JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_an_empty_string JL_GLOBALLY_ROOTED;
 
 extern JL_DLLIMPORT jl_datatype_t *jl_bool_type JL_GLOBALLY_ROOTED;
@@ -872,6 +876,10 @@ extern JL_DLLIMPORT jl_value_t *jl_array_symbol_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_array_int32_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_array_uint32_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_array_uint64_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_memory_uint8_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_memory_any_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_memoryref_uint8_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_memoryref_any_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_expr_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_binding_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_globalref_type JL_GLOBALLY_ROOTED;
@@ -1019,7 +1027,7 @@ JL_DLLEXPORT void jl_clear_malloc_data(void);
 
 // GC write barriers
 JL_DLLEXPORT void jl_gc_queue_root(const jl_value_t *root) JL_NOTSAFEPOINT;
-JL_DLLEXPORT void jl_gc_queue_multiroot(const jl_value_t *root, const jl_value_t *stored) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_gc_queue_multiroot(const jl_value_t *root, const void *stored, jl_datatype_t *dt) JL_NOTSAFEPOINT;
 
 STATIC_INLINE void jl_gc_wb(const void *parent, const void *ptr) JL_NOTSAFEPOINT
 {
@@ -1039,6 +1047,7 @@ STATIC_INLINE void jl_gc_wb_back(const void *ptr) JL_NOTSAFEPOINT // ptr isa jl_
 
 STATIC_INLINE void jl_gc_multi_wb(const void *parent, const jl_value_t *ptr) JL_NOTSAFEPOINT
 {
+    // 3 == GC_OLD_MARKED
     // ptr is an immutable object
     if (__likely(jl_astaggedvalue(parent)->bits.gc != 3))
         return; // parent is young or in remset
@@ -1047,7 +1056,7 @@ STATIC_INLINE void jl_gc_multi_wb(const void *parent, const jl_value_t *ptr) JL_
     jl_datatype_t *dt = (jl_datatype_t*)jl_typeof(ptr);
     const jl_datatype_layout_t *ly = dt->layout;
     if (ly->npointers)
-        jl_gc_queue_multiroot((jl_value_t*)parent, ptr);
+        jl_gc_queue_multiroot((jl_value_t*)parent, ptr, dt);
 }
 
 JL_DLLEXPORT void *jl_gc_managed_malloc(size_t sz);
@@ -1097,16 +1106,101 @@ STATIC_INLINE jl_value_t *jl_svecset(
 }
 #endif
 
-#define jl_array_len(a)   (((jl_array_t*)(a))->length)
-#define jl_array_data(a)  ((void*)((jl_array_t*)(a))->data)
-#define jl_array_dim(a,i) ((&((jl_array_t*)(a))->nrows)[i])
-#define jl_array_dim0(a)  (((jl_array_t*)(a))->nrows)
-#define jl_array_nrows(a) (((jl_array_t*)(a))->nrows)
-#define jl_array_ndims(a) ((int32_t)(((jl_array_t*)a)->flags.ndims))
-#define jl_array_data_owner_offset(ndims) (offsetof(jl_array_t,ncols) + sizeof(size_t)*(1+jl_array_ndimwords(ndims))) // in bytes
-#define jl_array_data_owner(a) (*((jl_value_t**)((char*)a + jl_array_data_owner_offset(jl_array_ndims(a)))))
+#define jl_genericmemory_data_owner_field(a) (*(jl_value_t**)((jl_genericmemory_t*)(a) + 1))
+
+#define jl_nparams(t)  jl_svec_len(((jl_datatype_t*)(t))->parameters)
+#define jl_tparam0(t)  jl_svecref(((jl_datatype_t*)(t))->parameters, 0)
+#define jl_tparam1(t)  jl_svecref(((jl_datatype_t*)(t))->parameters, 1)
+#define jl_tparam2(t)  jl_svecref(((jl_datatype_t*)(t))->parameters, 2)
+#define jl_tparam(t,i) jl_svecref(((jl_datatype_t*)(t))->parameters, i)
+#define jl_array_data(a,t) ((t*)((jl_array_t*)(a))->ref.ptr_or_offset)
+#define jl_array_data_(a) ((void*)((jl_array_t*)(a))->ref.ptr_or_offset)
+#define jl_array_dim(a,i) (((jl_array_t*)(a))->dimsize[i])
+#define jl_array_dim0(a)  (((jl_array_t*)(a))->dimsize[0])
+#define jl_array_nrows(a) (((jl_array_t*)(a))->dimsize[0])
+#define jl_array_ndims(a) (*(size_t*)jl_tparam1(jl_typetagof(a)))
+#define jl_array_maxsize(a) (((jl_array_t*)(a))->ref.mem->length)
+#define jl_array_len(a)   (jl_array_ndims(a) == 1 ? jl_array_nrows(a) : jl_array_maxsize(a))
+
+/*
+  how - allocation style
+  0 = data is inlined
+  1 = owns the gc-managed data, exclusively
+  2 = malloc-allocated pointer (may or may not own it)
+  3 = has a pointer to the object that owns the data pointer
+*/
+STATIC_INLINE int jl_genericmemory_how(jl_genericmemory_t *m) JL_NOTSAFEPOINT
+{
+    if (m->ptr == (void*)((char*)m + 16)) // JL_SMALL_BYTE_ALIGNMENT (from julia_internal.h)
+        return 0;
+    jl_value_t *owner = jl_genericmemory_data_owner_field(m);
+    if (owner == (jl_value_t*)m)
+        return 1;
+    if (owner == NULL)
+        return 2;
+    return 3;
+}
+
+STATIC_INLINE jl_value_t *jl_genericmemory_owner(jl_genericmemory_t *m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
+{
+    if (jl_genericmemory_how(m) == 3)
+        return jl_genericmemory_data_owner_field(m);
+    return (jl_value_t*)m;
+}
+
+JL_DLLEXPORT char *jl_genericmemory_typetagdata(jl_genericmemory_t *m) JL_NOTSAFEPOINT;
+
+#ifdef __clang_gcanalyzer__
+jl_value_t **jl_genericmemory_ptr_data(jl_genericmemory_t *m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
+STATIC_INLINE jl_value_t *jl_genericmemory_ptr_ref(void *m JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT;
+STATIC_INLINE jl_value_t *jl_genericmemory_ptr_set(
+    void *m JL_ROOTING_ARGUMENT, size_t i,
+    void *x JL_ROOTED_ARGUMENT) JL_NOTSAFEPOINT;
+#else
+#define jl_genericmemory_ptr_data(a)  ((jl_value_t**)((jl_genericmemory_t*)(a))->ptr)
+STATIC_INLINE jl_value_t *jl_genericmemory_ptr_ref(void *m JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT
+{
+    jl_genericmemory_t *m_ = (jl_genericmemory_t*)m;
+    assert(((jl_datatype_t*)jl_typetagof(m_))->layout->flags.arrayelem_isboxed);
+    assert(i < m_->length);
+    return jl_atomic_load_relaxed(((_Atomic(jl_value_t*)*)(m_->ptr)) + i);
+}
+STATIC_INLINE jl_value_t *jl_genericmemory_ptr_set(
+    void *m JL_ROOTING_ARGUMENT, size_t i,
+    void *x JL_ROOTED_ARGUMENT) JL_NOTSAFEPOINT
+{
+    jl_genericmemory_t *m_ = (jl_genericmemory_t*)m;
+    assert(((jl_datatype_t*)jl_typetagof(m_))->layout->flags.arrayelem_isboxed);
+    assert(i < m_->length);
+    jl_atomic_store_release(((_Atomic(jl_value_t*)*)(m_->ptr)) + i, (jl_value_t*)x);
+    if (x) {
+        if (jl_genericmemory_how(m_) == 3)
+            m = (void*)jl_genericmemory_data_owner_field(m_);
+        jl_gc_wb(m, x);
+    }
+    return (jl_value_t*)x;
+}
+#endif
+
+STATIC_INLINE uint8_t jl_memory_uint8_ref(void *m, size_t i) JL_NOTSAFEPOINT
+{
+    jl_genericmemory_t *m_ = (jl_genericmemory_t*)m;
+    assert(jl_typetagis(m_, jl_memory_uint8_type));
+    assert(i < m_->length);
+    return ((uint8_t*)m_->ptr)[i];
+}
+STATIC_INLINE void jl_memory_uint8_set(void *m, size_t i, uint8_t x) JL_NOTSAFEPOINT
+{
+    jl_genericmemory_t *m_ = (jl_genericmemory_t*)m;
+    assert(jl_typetagis(m_, jl_memory_uint8_type));
+    assert(i < m_->length);
+    ((uint8_t*)m_->ptr)[i] = x;
+}
 
-JL_DLLEXPORT char *jl_array_typetagdata(jl_array_t *a) JL_NOTSAFEPOINT;
+STATIC_INLINE jl_value_t *jl_array_owner(jl_array_t *a JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
+{
+    return jl_genericmemory_owner(a->ref.mem);
+}
 
 #ifdef __clang_gcanalyzer__
 jl_value_t **jl_array_ptr_data(jl_array_t *a JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
@@ -1115,25 +1209,22 @@ STATIC_INLINE jl_value_t *jl_array_ptr_set(
     void *a JL_ROOTING_ARGUMENT, size_t i,
     void *x JL_ROOTED_ARGUMENT) JL_NOTSAFEPOINT;
 #else
-#define jl_array_ptr_data(a)  ((jl_value_t**)((jl_array_t*)(a))->data)
+#define jl_array_ptr_data(a) (jl_array_data(a, jl_value_t*))
 STATIC_INLINE jl_value_t *jl_array_ptr_ref(void *a JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT
 {
-    assert(((jl_array_t*)a)->flags.ptrarray);
+    assert(((jl_datatype_t*)jl_typetagof(((jl_array_t*)a)->ref.mem))->layout->flags.arrayelem_isboxed);
     assert(i < jl_array_len(a));
-    return jl_atomic_load_relaxed(((_Atomic(jl_value_t*)*)(jl_array_data(a))) + i);
+    return jl_atomic_load_relaxed(jl_array_data(a, _Atomic(jl_value_t*)) + i);
 }
 STATIC_INLINE jl_value_t *jl_array_ptr_set(
     void *a JL_ROOTING_ARGUMENT, size_t i,
     void *x JL_ROOTED_ARGUMENT) JL_NOTSAFEPOINT
 {
-    assert(((jl_array_t*)a)->flags.ptrarray);
+    assert(((jl_datatype_t*)jl_typetagof(((jl_array_t*)a)->ref.mem))->layout->flags.arrayelem_isboxed);
     assert(i < jl_array_len(a));
-    jl_atomic_store_release(((_Atomic(jl_value_t*)*)(jl_array_data(a))) + i, (jl_value_t*)x);
+    jl_atomic_store_release(jl_array_data(a, _Atomic(jl_value_t*)) + i, (jl_value_t*)x);
     if (x) {
-        if (((jl_array_t*)a)->flags.how == 3) {
-            a = jl_array_data_owner(a);
-        }
-        jl_gc_wb(a, x);
+        jl_gc_wb(jl_array_owner((jl_array_t*)a), x);
     }
     return (jl_value_t*)x;
 }
@@ -1141,32 +1232,26 @@ STATIC_INLINE jl_value_t *jl_array_ptr_set(
 
 STATIC_INLINE uint8_t jl_array_uint8_ref(void *a, size_t i) JL_NOTSAFEPOINT
 {
-    assert(i < jl_array_len(a));
     assert(jl_typetagis(a, jl_array_uint8_type));
-    return ((uint8_t*)(jl_array_data(a)))[i];
+    assert(i < jl_array_len(a));
+    return jl_array_data(a, uint8_t)[i];
 }
 STATIC_INLINE void jl_array_uint8_set(void *a, size_t i, uint8_t x) JL_NOTSAFEPOINT
 {
-    assert(i < jl_array_len(a));
     assert(jl_typetagis(a, jl_array_uint8_type));
-    ((uint8_t*)(jl_array_data(a)))[i] = x;
-}
-STATIC_INLINE uint8_t jl_array_uint32_ref(void *a, size_t i) JL_NOTSAFEPOINT
-{
     assert(i < jl_array_len(a));
-    assert(jl_typetagis(a, jl_array_uint32_type));
-    return ((uint32_t*)(jl_array_data(a)))[i];
+    jl_array_data(a, uint8_t)[i] = x;
 }
 STATIC_INLINE void jl_array_uint32_set(void *a, size_t i, uint8_t x) JL_NOTSAFEPOINT
 {
     assert(i < jl_array_len(a));
-    assert(jl_typetagis(a, jl_array_uint32_type));
-    ((uint32_t*)(jl_array_data(a)))[i] = x;
+    assert(jl_typetagis(a, jl_array_uint32_type) || jl_typetagis(a, jl_array_int32_type));
+    jl_array_data(a, uint32_t)[i] = x;
 }
 
 #define jl_exprarg(e,n) jl_array_ptr_ref(((jl_expr_t*)(e))->args, n)
 #define jl_exprargset(e, n, v) jl_array_ptr_set(((jl_expr_t*)(e))->args, n, v)
-#define jl_expr_nargs(e) jl_array_len(((jl_expr_t*)(e))->args)
+#define jl_expr_nargs(e) jl_array_nrows(((jl_expr_t*)(e))->args)
 
 #define jl_fieldref(s,i) jl_get_nth_field(((jl_value_t*)(s)),i)
 #define jl_fieldref_noalloc(s,i) jl_get_nth_field_noalloc(((jl_value_t*)(s)),i)
@@ -1185,11 +1270,6 @@ STATIC_INLINE void jl_array_uint32_set(void *a, size_t i, uint8_t x) JL_NOTSAFEP
 #define jl_quotenode_value(x) (((jl_value_t**)x)[0])
 #define jl_returnnode_value(x) (((jl_value_t**)x)[0])
 
-#define jl_nparams(t)  jl_svec_len(((jl_datatype_t*)(t))->parameters)
-#define jl_tparam0(t)  jl_svecref(((jl_datatype_t*)(t))->parameters, 0)
-#define jl_tparam1(t)  jl_svecref(((jl_datatype_t*)(t))->parameters, 1)
-#define jl_tparam(t,i) jl_svecref(((jl_datatype_t*)(t))->parameters, i)
-
 // get a pointer to the data in a datatype
 #define jl_data_ptr(v)  ((jl_value_t**)v)
 
@@ -1216,10 +1296,24 @@ STATIC_INLINE jl_value_t *jl_field_type_concrete(jl_datatype_t *st JL_PROPAGATES
     return jl_svecref(st->types, i);
 }
 
-#define jl_datatype_size(t)    (((jl_datatype_t*)t)->layout->size)
-#define jl_datatype_align(t)   (((jl_datatype_t*)t)->layout->alignment)
-#define jl_datatype_nbits(t)   ((((jl_datatype_t*)t)->layout->size)*8)
-#define jl_datatype_nfields(t) (((jl_datatype_t*)(t))->layout->nfields)
+STATIC_INLINE int jl_is_layout_opaque(const jl_datatype_layout_t *l) JL_NOTSAFEPOINT
+{
+    return l->nfields == 0 && l->npointers > 0;
+}
+
+JL_DLLEXPORT jl_value_t *jl_unwrap_unionall(jl_value_t *v JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
+
+#define jl_inlinedatatype_layout(t) (((jl_datatype_t*)t)->layout)
+STATIC_INLINE const jl_datatype_layout_t *jl_datatype_layout(jl_datatype_t *t) JL_NOTSAFEPOINT
+{
+    if (jl_is_layout_opaque(t->layout)) // e.g. GenericMemory
+        t = (jl_datatype_t*)jl_unwrap_unionall(t->name->wrapper);
+    return t->layout;
+}
+#define jl_datatype_size(t)    (jl_datatype_layout((jl_datatype_t*)(t))->size)
+#define jl_datatype_align(t)   (jl_datatype_layout((jl_datatype_t*)(t))->alignment)
+#define jl_datatype_nbits(t)   ((jl_datatype_layout((jl_datatype_t*)(t))->size)*8)
+#define jl_datatype_nfields(t) (jl_datatype_layout((jl_datatype_t*)(t))->nfields)
 
 JL_DLLEXPORT void *jl_symbol_name(jl_sym_t *s);
 // inline version with strong type check to detect typos in a `->name` chain
@@ -1247,23 +1341,23 @@ static inline uint32_t jl_fielddesc_size(int8_t fielddesc_type) JL_NOTSAFEPOINT
 #define jl_dt_layout_fields(d) ((const char*)(d) + sizeof(jl_datatype_layout_t))
 static inline const char *jl_dt_layout_ptrs(const jl_datatype_layout_t *l) JL_NOTSAFEPOINT
 {
-    return jl_dt_layout_fields(l) + jl_fielddesc_size(l->fielddesc_type) * l->nfields;
+    return jl_dt_layout_fields(l) + jl_fielddesc_size(l->flags.fielddesc_type) * l->nfields;
 }
 
 #define DEFINE_FIELD_ACCESSORS(f)                                             \
     static inline uint32_t jl_field_##f(jl_datatype_t *st,                    \
                                         int i) JL_NOTSAFEPOINT                \
     {                                                                         \
-        const jl_datatype_layout_t *ly = st->layout;                          \
+        const jl_datatype_layout_t *ly = jl_datatype_layout(st);              \
         assert(i >= 0 && (size_t)i < ly->nfields);                            \
-        if (ly->fielddesc_type == 0) {                                        \
+        if (ly->flags.fielddesc_type == 0) {                                  \
             return ((const jl_fielddesc8_t*)jl_dt_layout_fields(ly))[i].f;    \
         }                                                                     \
-        else if (ly->fielddesc_type == 1) {                                   \
+        else if (ly->flags.fielddesc_type == 1) {                             \
             return ((const jl_fielddesc16_t*)jl_dt_layout_fields(ly))[i].f;   \
         }                                                                     \
         else {                                                                \
-            assert(ly->fielddesc_type == 2);                                  \
+            assert(ly->flags.fielddesc_type == 2);                            \
             return ((const jl_fielddesc32_t*)jl_dt_layout_fields(ly))[i].f;   \
         }                                                                     \
     }                                                                         \
@@ -1274,24 +1368,24 @@ DEFINE_FIELD_ACCESSORS(size)
 
 static inline int jl_field_isptr(jl_datatype_t *st, int i) JL_NOTSAFEPOINT
 {
-    const jl_datatype_layout_t *ly = st->layout;
+    const jl_datatype_layout_t *ly = jl_datatype_layout(st);
     assert(i >= 0 && (size_t)i < ly->nfields);
-    return ((const jl_fielddesc8_t*)(jl_dt_layout_fields(ly) + jl_fielddesc_size(ly->fielddesc_type) * i))->isptr;
+    return ((const jl_fielddesc8_t*)(jl_dt_layout_fields(ly) + jl_fielddesc_size(ly->flags.fielddesc_type) * i))->isptr;
 }
 
 static inline uint32_t jl_ptr_offset(jl_datatype_t *st, int i) JL_NOTSAFEPOINT
 {
-    const jl_datatype_layout_t *ly = st->layout;
+    const jl_datatype_layout_t *ly = st->layout; // NOT jl_datatype_layout(st)
     assert(i >= 0 && (size_t)i < ly->npointers);
     const void *ptrs = jl_dt_layout_ptrs(ly);
-    if (ly->fielddesc_type == 0) {
+    if (ly->flags.fielddesc_type == 0) {
         return ((const uint8_t*)ptrs)[i];
     }
-    else if (ly->fielddesc_type == 1) {
+    else if (ly->flags.fielddesc_type == 1) {
         return ((const uint16_t*)ptrs)[i];
     }
     else {
-        assert(ly->fielddesc_type == 2);
+        assert(ly->flags.fielddesc_type == 2);
         return ((const uint32_t*)ptrs)[i];
     }
 }
@@ -1320,11 +1414,6 @@ static inline int jl_field_isconst(jl_datatype_t *st, int i) JL_NOTSAFEPOINT
 }
 
 
-static inline int jl_is_layout_opaque(const jl_datatype_layout_t *l) JL_NOTSAFEPOINT
-{
-    return l->nfields == 0 && l->npointers > 0;
-}
-
 // basic predicates -----------------------------------------------------------
 #define jl_is_nothing(v)     (((jl_value_t*)(v)) == ((jl_value_t*)jl_nothing))
 #define jl_is_tuple(v)       (((jl_datatype_t*)jl_typeof(v))->name == jl_tuple_typename)
@@ -1380,7 +1469,8 @@ static inline int jl_is_layout_opaque(const jl_datatype_layout_t *l) JL_NOTSAFEP
 #define jl_is_uint8pointer(v)jl_typetagis(v,jl_uint8pointer_type)
 #define jl_is_llvmpointer(v) (((jl_datatype_t*)jl_typeof(v))->name == jl_llvmpointer_typename)
 #define jl_is_intrinsic(v)   jl_typetagis(v,jl_intrinsic_type)
-#define jl_array_isbitsunion(a) (!(((jl_array_t*)(a))->flags.ptrarray) && jl_is_uniontype(jl_tparam0(jl_typeof(a))))
+#define jl_is_addrspacecore(v) jl_typetagis(v,jl_addrspacecore_type)
+#define jl_genericmemory_isbitsunion(a) (((jl_datatype_t*)jl_typetagof(a))->layout->flags.arrayelem_isunion)
 
 JL_DLLEXPORT int jl_subtype(jl_value_t *a, jl_value_t *b);
 
@@ -1416,23 +1506,23 @@ STATIC_INLINE int jl_is_structtype(void *v) JL_NOTSAFEPOINT
 
 STATIC_INLINE int jl_isbits(void *t) JL_NOTSAFEPOINT // corresponding to isbitstype() in julia
 {
-    return (jl_is_datatype(t) && ((jl_datatype_t*)t)->isbitstype);
+    return jl_is_datatype(t) && ((jl_datatype_t*)t)->isbitstype;
 }
 
 STATIC_INLINE int jl_is_datatype_singleton(jl_datatype_t *d) JL_NOTSAFEPOINT
 {
-    return (d->instance != NULL);
+    return d->instance != NULL && d->layout->size == 0 && d->layout->npointers == 0;
 }
 
 STATIC_INLINE int jl_is_abstracttype(void *v) JL_NOTSAFEPOINT
 {
-    return (jl_is_datatype(v) && ((jl_datatype_t*)(v))->name->abstract);
+    return jl_is_datatype(v) && ((jl_datatype_t*)(v))->name->abstract;
 }
 
 STATIC_INLINE int jl_is_array_type(void *t) JL_NOTSAFEPOINT
 {
-    return (jl_is_datatype(t) &&
-            ((jl_datatype_t*)(t))->name == jl_array_typename);
+    return jl_is_datatype(t) &&
+           ((jl_datatype_t*)(t))->name == jl_array_typename;
 }
 
 STATIC_INLINE int jl_is_array(void *v) JL_NOTSAFEPOINT
@@ -1441,6 +1531,42 @@ STATIC_INLINE int jl_is_array(void *v) JL_NOTSAFEPOINT
     return jl_is_array_type(t);
 }
 
+STATIC_INLINE int jl_is_genericmemory_type(void *t) JL_NOTSAFEPOINT
+{
+    return (jl_is_datatype(t) &&
+            ((jl_datatype_t*)(t))->name == jl_genericmemory_typename);
+}
+
+STATIC_INLINE int jl_is_genericmemory(void *v) JL_NOTSAFEPOINT
+{
+    jl_value_t *t = jl_typeof(v);
+    return jl_is_genericmemory_type(t);
+}
+
+STATIC_INLINE int jl_is_genericmemoryref_type(void *t) JL_NOTSAFEPOINT
+{
+    return (jl_is_datatype(t) &&
+            ((jl_datatype_t*)(t))->name == jl_genericmemoryref_typename);
+}
+
+STATIC_INLINE int jl_is_genericmemoryref(void *v) JL_NOTSAFEPOINT
+{
+    jl_value_t *t = jl_typeof(v);
+    return jl_is_genericmemoryref_type(t);
+}
+
+STATIC_INLINE int jl_is_addrspace_type(void *t) JL_NOTSAFEPOINT
+{
+    return (jl_is_datatype(t) &&
+            ((jl_datatype_t*)(t))->name == jl_addrspace_typename);
+}
+
+STATIC_INLINE int jl_is_addrspace(void *v) JL_NOTSAFEPOINT
+{
+    jl_value_t *t = jl_typeof(v);
+    return jl_is_addrspace_type(t);
+}
+
 
 STATIC_INLINE int jl_is_opaque_closure_type(void *t) JL_NOTSAFEPOINT
 {
@@ -1496,12 +1622,9 @@ STATIC_INLINE int jl_is_type_type(jl_value_t *v) JL_NOTSAFEPOINT
             ((jl_datatype_t*)(v))->name == ((jl_datatype_t*)jl_type_type->body)->name);
 }
 
-STATIC_INLINE int jl_is_array_zeroinit(jl_array_t *a) JL_NOTSAFEPOINT
+STATIC_INLINE int jl_is_genericmemory_zeroinit(jl_genericmemory_t *m) JL_NOTSAFEPOINT
 {
-    if (a->flags.ptrarray || a->flags.hasptr)
-        return 1;
-    jl_value_t *elty = jl_tparam0(jl_typeof(a));
-    return jl_is_datatype(elty) && ((jl_datatype_t*)elty)->zeroinit;
+    return ((jl_datatype_t*)jl_typeof(m))->zeroinit;
 }
 
 // object identity
@@ -1570,6 +1693,7 @@ JL_DLLEXPORT jl_value_t *jl_instantiate_unionall(jl_unionall_t *u, jl_value_t *p
 JL_DLLEXPORT jl_value_t *jl_apply_type(jl_value_t *tc, jl_value_t **params, size_t n);
 JL_DLLEXPORT jl_value_t *jl_apply_type1(jl_value_t *tc, jl_value_t *p1);
 JL_DLLEXPORT jl_value_t *jl_apply_type2(jl_value_t *tc, jl_value_t *p1, jl_value_t *p2);
+JL_DLLEXPORT jl_value_t *jl_apply_type3(jl_value_t *tc, jl_value_t *p1, jl_value_t *p2, jl_value_t *p3);
 JL_DLLEXPORT jl_datatype_t *jl_apply_modify_type(jl_value_t *dt);
 JL_DLLEXPORT jl_datatype_t *jl_apply_cmpswap_type(jl_value_t *dt);
 JL_DLLEXPORT jl_value_t *jl_apply_tuple_type(jl_svec_t *params, int check); // if uncertain, set check=1
@@ -1688,44 +1812,48 @@ int jl_uniontype_size(jl_value_t *ty, size_t *sz);
 JL_DLLEXPORT int jl_islayout_inline(jl_value_t *eltype, size_t *fsz, size_t *al);
 
 // arrays
-JL_DLLEXPORT jl_array_t *jl_new_array(jl_value_t *atype, jl_value_t *dims);
-JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
-                                          jl_value_t *dims);
 JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
                                             size_t nel, int own_buffer);
 JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
                                          jl_value_t *dims, int own_buffer);
 
 JL_DLLEXPORT jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr);
-JL_DLLEXPORT jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr,
-                                           size_t nc);
-JL_DLLEXPORT jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr,
-                                           size_t nc, size_t z);
 JL_DLLEXPORT jl_array_t *jl_pchar_to_array(const char *str, size_t len);
 JL_DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len);
 JL_DLLEXPORT jl_value_t *jl_cstr_to_string(const char *str);
 JL_DLLEXPORT jl_value_t *jl_alloc_string(size_t len);
 JL_DLLEXPORT jl_value_t *jl_array_to_string(jl_array_t *a);
 JL_DLLEXPORT jl_array_t *jl_alloc_vec_any(size_t n);
-JL_DLLEXPORT jl_value_t *jl_arrayref(jl_array_t *a, size_t i);  // 0-indexed
-JL_DLLEXPORT jl_value_t *jl_ptrarrayref(jl_array_t *a JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT;  // 0-indexed
-JL_DLLEXPORT void jl_arrayset(jl_array_t *a JL_ROOTING_ARGUMENT, jl_value_t *v JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, size_t i);  // 0-indexed
-JL_DLLEXPORT void jl_arrayunset(jl_array_t *a, size_t i);  // 0-indexed
-JL_DLLEXPORT int jl_array_isassigned(jl_array_t *a, size_t i);  // 0-indexed
 JL_DLLEXPORT void jl_array_grow_end(jl_array_t *a, size_t inc);
 JL_DLLEXPORT void jl_array_del_end(jl_array_t *a, size_t dec);
-JL_DLLEXPORT void jl_array_grow_beg(jl_array_t *a, size_t inc);
-JL_DLLEXPORT void jl_array_del_beg(jl_array_t *a, size_t dec);
-JL_DLLEXPORT void jl_array_sizehint(jl_array_t *a, size_t sz);
 JL_DLLEXPORT void jl_array_ptr_1d_push(jl_array_t *a, jl_value_t *item);
 JL_DLLEXPORT void jl_array_ptr_1d_append(jl_array_t *a, jl_array_t *a2);
 JL_DLLEXPORT jl_value_t *jl_apply_array_type(jl_value_t *type, size_t dim);
-JL_DLLEXPORT int jl_array_validate_dims(size_t *nel, size_t *tot, uint32_t ndims, size_t *dims, size_t elsz);
 // property access
 JL_DLLEXPORT void *jl_array_ptr(jl_array_t *a);
 JL_DLLEXPORT void *jl_array_eltype(jl_value_t *a);
 JL_DLLEXPORT int jl_array_rank(jl_value_t *a);
-JL_DLLEXPORT size_t jl_array_size(jl_value_t *a, int d);
+
+// genericmemory
+JL_DLLEXPORT jl_genericmemory_t *jl_new_genericmemory(jl_value_t *mtype, jl_value_t *dim);
+JL_DLLEXPORT jl_genericmemory_t *jl_ptr_to_genericmemory(jl_value_t *mtype, void *data,
+                                           size_t nel, int own_buffer);
+JL_DLLEXPORT jl_genericmemory_t *jl_alloc_genericmemory(jl_value_t *mtype, size_t nel);
+JL_DLLEXPORT jl_genericmemory_t *jl_pchar_to_memory(const char *str, size_t len);
+JL_DLLEXPORT jl_value_t *jl_genericmemory_to_string(jl_genericmemory_t *m, size_t len);
+JL_DLLEXPORT jl_genericmemory_t *jl_alloc_memory_any(size_t n);
+JL_DLLEXPORT jl_value_t *jl_genericmemoryref(jl_genericmemory_t *m, size_t i);  // 0-indexed
+JL_DLLEXPORT void jl_genericmemoryset(jl_genericmemory_t *m JL_ROOTING_ARGUMENT, jl_value_t *v JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, size_t i);  // 0-indexed
+JL_DLLEXPORT void jl_genericmemoryunset(jl_genericmemory_t *m, size_t i);  // 0-indexed
+JL_DLLEXPORT int jl_genericmemory_isassigned(jl_genericmemory_t *m, size_t i);  // 0-indexed
+
+JL_DLLEXPORT jl_genericmemoryref_t *jl_new_memoryref(jl_value_t *typ, jl_genericmemory_t *mem, void *data);
+JL_DLLEXPORT jl_value_t *jl_memoryrefget(jl_genericmemoryref_t m JL_PROPAGATES_ROOT);
+JL_DLLEXPORT jl_value_t *jl_ptrmemoryrefget(jl_genericmemoryref_t m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_value_t *jl_memoryref_isassigned(jl_genericmemoryref_t m) JL_GLOBALLY_ROOTED;
+JL_DLLEXPORT jl_genericmemoryref_t jl_memoryrefindex(jl_genericmemoryref_t m JL_PROPAGATES_ROOT, size_t idx) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_memoryrefset(jl_genericmemoryref_t m JL_ROOTING_ARGUMENT, jl_value_t *v JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED);
+JL_DLLEXPORT void jl_memoryrefunset(jl_genericmemoryref_t m);
 
 // strings
 JL_DLLEXPORT const char *jl_string_ptr(jl_value_t *s);
@@ -1782,10 +1910,10 @@ STATIC_INLINE jl_function_t *jl_get_function(jl_module_t *m, const char *name)
 }
 
 // eq hash tables
-JL_DLLEXPORT jl_array_t *jl_eqtable_put(jl_array_t *h JL_ROOTING_ARGUMENT, jl_value_t *key, jl_value_t *val JL_ROOTED_ARGUMENT, int *inserted);
-JL_DLLEXPORT jl_value_t *jl_eqtable_get(jl_array_t *h JL_PROPAGATES_ROOT, jl_value_t *key, jl_value_t *deflt) JL_NOTSAFEPOINT;
-JL_DLLEXPORT jl_value_t *jl_eqtable_pop(jl_array_t *h, jl_value_t *key, jl_value_t *deflt, int *found);
-jl_value_t *jl_eqtable_getkey(jl_array_t *h JL_PROPAGATES_ROOT, jl_value_t *key, jl_value_t *deflt) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_genericmemory_t *jl_eqtable_put(jl_genericmemory_t *h JL_ROOTING_ARGUMENT, jl_value_t *key, jl_value_t *val JL_ROOTED_ARGUMENT, int *inserted);
+JL_DLLEXPORT jl_value_t *jl_eqtable_get(jl_genericmemory_t *h JL_PROPAGATES_ROOT, jl_value_t *key, jl_value_t *deflt) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_value_t *jl_eqtable_pop(jl_genericmemory_t *h, jl_value_t *key, jl_value_t *deflt, int *found);
+jl_value_t *jl_eqtable_getkey(jl_genericmemory_t *h JL_PROPAGATES_ROOT, jl_value_t *key, jl_value_t *deflt) JL_NOTSAFEPOINT;
 
 // system information
 JL_DLLEXPORT int jl_errno(void) JL_NOTSAFEPOINT;
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 7e7483536030f..a162effdec173 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -294,19 +294,17 @@ STATIC_INLINE uint32_t jl_int32hash_fast(uint32_t a)
 // without risk of creating pointers out of thin air
 // TODO: replace with LLVM's llvm.memmove.element.unordered.atomic.p0i8.p0i8.i32
 //       aka `__llvm_memmove_element_unordered_atomic_8` (for 64 bit)
-static inline void memmove_refs(void **dstp, void *const *srcp, size_t n) JL_NOTSAFEPOINT
+static inline void memmove_refs(_Atomic(void*) *dstp, _Atomic(void*) *srcp, size_t n) JL_NOTSAFEPOINT
 {
     size_t i;
-    _Atomic(void*) *srcpa = (_Atomic(void*)*)srcp;
-    _Atomic(void*) *dstpa = (_Atomic(void*)*)dstp;
     if (dstp < srcp || dstp > srcp + n) {
         for (i = 0; i < n; i++) {
-            jl_atomic_store_release(dstpa + i, jl_atomic_load_relaxed(srcpa + i));
+            jl_atomic_store_release(dstp + i, jl_atomic_load_relaxed(srcp + i));
         }
     }
     else {
         for (i = 0; i < n; i++) {
-            jl_atomic_store_release(dstpa + n - i - 1, jl_atomic_load_relaxed(srcpa + n - i - 1));
+            jl_atomic_store_release(dstp + n - i - 1, jl_atomic_load_relaxed(srcp + n - i - 1));
         }
     }
 }
@@ -571,6 +569,7 @@ JL_DLLEXPORT void JL_NORETURN jl_throw_out_of_memory_error(void);
 JL_DLLEXPORT int64_t jl_gc_diff_total_bytes(void) JL_NOTSAFEPOINT;
 JL_DLLEXPORT int64_t jl_gc_sync_total_bytes(int64_t offset) JL_NOTSAFEPOINT;
 void jl_gc_track_malloced_array(jl_ptls_t ptls, jl_array_t *a) JL_NOTSAFEPOINT;
+void jl_gc_track_malloced_genericmemory(jl_ptls_t ptls, jl_genericmemory_t *m, int isaligned) JL_NOTSAFEPOINT;
 void jl_gc_count_allocd(size_t sz) JL_NOTSAFEPOINT;
 void jl_gc_run_all_finalizers(jl_task_t *ct);
 void jl_release_task_stack(jl_ptls_t ptls, jl_task_t *task);
@@ -776,15 +775,13 @@ JL_DLLEXPORT jl_methtable_t *jl_method_get_table(
 JL_DLLEXPORT int jl_pointer_egal(jl_value_t *t);
 JL_DLLEXPORT jl_value_t *jl_nth_slot_type(jl_value_t *sig JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT;
 void jl_compute_field_offsets(jl_datatype_t *st);
-jl_array_t *jl_new_array_for_deserialization(jl_value_t *atype, uint32_t ndims, size_t *dims,
-                                             int isunboxed, int hasptr, int isunion, int elsz);
 void jl_module_run_initializer(jl_module_t *m);
 JL_DLLEXPORT jl_binding_t *jl_get_module_binding(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *var, int alloc);
 JL_DLLEXPORT void jl_binding_deprecation_warning(jl_module_t *m, jl_sym_t *sym, jl_binding_t *b);
 extern jl_array_t *jl_module_init_order JL_GLOBALLY_ROOTED;
 extern htable_t jl_current_modules JL_GLOBALLY_ROOTED;
 extern JL_DLLEXPORT jl_module_t *jl_precompile_toplevel_module JL_GLOBALLY_ROOTED;
-extern jl_array_t *jl_global_roots_table JL_GLOBALLY_ROOTED;
+extern jl_genericmemory_t *jl_global_roots_table JL_GLOBALLY_ROOTED;
 JL_DLLEXPORT int jl_is_globally_rooted(jl_value_t *val JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val JL_MAYBE_UNROOTED);
 
@@ -968,8 +965,8 @@ uint8_t jl_object_in_image(jl_value_t* v) JL_NOTSAFEPOINT;
 
 // the first argument to jl_idtable_rehash is used to return a value
 // make sure it is rooted if it is used after the function returns
-JL_DLLEXPORT jl_array_t *jl_idtable_rehash(jl_array_t *a, size_t newsz);
-_Atomic(jl_value_t*) *jl_table_peek_bp(jl_array_t *a, jl_value_t *key) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_genericmemory_t *jl_idtable_rehash(jl_genericmemory_t *a, size_t newsz);
+_Atomic(jl_value_t*) *jl_table_peek_bp(jl_genericmemory_t *a, jl_value_t *key) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT jl_method_t *jl_new_method_uninit(jl_module_t*);
 
@@ -1287,7 +1284,7 @@ JL_DLLEXPORT unsigned jl_intrinsic_nargs(int f) JL_NOTSAFEPOINT;
 
 STATIC_INLINE int is_valid_intrinsic_elptr(jl_value_t *ety)
 {
-    return ety == (jl_value_t*)jl_any_type || (jl_is_concrete_type(ety) && !jl_is_layout_opaque(((jl_datatype_t*)ety)->layout));
+    return ety == (jl_value_t*)jl_any_type || (jl_is_concrete_type(ety) && !jl_is_layout_opaque(((jl_datatype_t*)ety)->layout) && !jl_is_array(ety));
 }
 JL_DLLEXPORT jl_value_t *jl_bitcast(jl_value_t *ty, jl_value_t *v);
 JL_DLLEXPORT jl_value_t *jl_pointerref(jl_value_t *p, jl_value_t *i, jl_value_t *align);
@@ -1382,7 +1379,6 @@ JL_DLLEXPORT jl_value_t *jl_arraylen(jl_value_t *a);
 JL_DLLEXPORT jl_value_t *jl_have_fma(jl_value_t *a);
 JL_DLLEXPORT int jl_stored_inline(jl_value_t *el_type);
 JL_DLLEXPORT jl_value_t *(jl_array_data_owner)(jl_array_t *a);
-JL_DLLEXPORT int jl_array_isassigned(jl_array_t *a, size_t i);
 JL_DLLEXPORT jl_array_t *jl_array_copy(jl_array_t *ary);
 
 JL_DLLEXPORT uintptr_t jl_object_id_(jl_value_t *tv, jl_value_t *v) JL_NOTSAFEPOINT;
diff --git a/src/llvm-alloc-opt.cpp b/src/llvm-alloc-opt.cpp
index 7ba78fd8b1e69..474dfbec08c91 100644
--- a/src/llvm-alloc-opt.cpp
+++ b/src/llvm-alloc-opt.cpp
@@ -79,6 +79,7 @@ static void removeGCPreserve(CallInst *call, Instruction *val)
  *
  * * load
  * * `pointer_from_objref`
+ * * `gc_loaded`
  * * Any real llvm intrinsics
  * * gc preserve intrinsics
  * * `ccall` gcroot array (`jl_roots` operand bundle)
@@ -94,7 +95,6 @@ static void removeGCPreserve(CallInst *call, Instruction *val)
  * TODO:
  * * Return twice
  * * Handle phi node.
- * * Look through `pointer_from_objref`.
  * * Handle jl_box*
  */
 
@@ -310,7 +310,9 @@ bool Optimizer::isSafepoint(Instruction *inst)
         return false;
     if (auto callee = call->getCalledFunction()) {
         // Known functions emitted in codegen that are not safepoints
-        if (callee == pass.pointer_from_objref_func || callee->getName() == "memcmp") {
+        if (callee == pass.pointer_from_objref_func
+            || callee == pass.gc_loaded_func
+            || callee->getName() == "memcmp") {
             return false;
         }
     }
@@ -693,6 +695,11 @@ void Optimizer::moveToStack(CallInst *orig_inst, size_t sz, bool has_ref)
                 call->eraseFromParent();
                 return;
             }
+            //if (pass.gc_loaded_func == callee) {
+            //    call->replaceAllUsesWith(new_i);
+            //    call->eraseFromParent();
+            //    return;
+            //}
             if (pass.typeof_func == callee) {
                 ++RemovedTypeofs;
                 call->replaceAllUsesWith(tag);
diff --git a/src/llvm-codegen-shared.h b/src/llvm-codegen-shared.h
index 4dc68483fd1b7..11c34af120f3f 100644
--- a/src/llvm-codegen-shared.h
+++ b/src/llvm-codegen-shared.h
@@ -93,7 +93,7 @@ struct CountTrackedPointers {
     unsigned count = 0;
     bool all = true;
     bool derived = false;
-    CountTrackedPointers(llvm::Type *T);
+    CountTrackedPointers(llvm::Type *T, bool ignore_loaded=false);
 };
 
 unsigned TrackWithShadow(llvm::Value *Src, llvm::Type *T, bool isptr, llvm::Value *Dst, llvm::Type *DTy, llvm::IRBuilder<> &irbuilder);
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index 10b2209945081..96a3e5a8f4b9e 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -378,16 +378,18 @@ static bool isSpecialPtr(Type *Ty) {
 
 // return how many Special pointers are in T (count > 0),
 // and if there is anything else in T (all == false)
-CountTrackedPointers::CountTrackedPointers(Type *T) {
+CountTrackedPointers::CountTrackedPointers(Type *T, bool ignore_loaded) {
     if (isa<PointerType>(T)) {
         if (isSpecialPtr(T)) {
+            if (ignore_loaded && T->getPointerAddressSpace() == AddressSpace::Loaded)
+                return;
             count++;
             if (T->getPointerAddressSpace() != AddressSpace::Tracked)
                 derived = true;
         }
     } else if (isa<StructType>(T) || isa<ArrayType>(T) || isa<VectorType>(T)) {
         for (Type *ElT : T->subtypes()) {
-            auto sub = CountTrackedPointers(ElT);
+            auto sub = CountTrackedPointers(ElT, ignore_loaded);
             count += sub.count;
             all &= sub.all;
             derived |= sub.derived;
@@ -403,6 +405,20 @@ CountTrackedPointers::CountTrackedPointers(Type *T) {
         all = false;
 }
 
+bool hasLoadedTy(Type *T) {
+    if (isa<PointerType>(T)) {
+        if (T->getPointerAddressSpace() == AddressSpace::Loaded)
+            return true;
+    } else if (isa<StructType>(T) || isa<ArrayType>(T) || isa<VectorType>(T)) {
+        for (Type *ElT : T->subtypes()) {
+            if (hasLoadedTy(ElT))
+                return true;
+        }
+    }
+    return false;
+}
+
+
 unsigned getCompositeNumElements(Type *T) {
     if (auto *ST = dyn_cast<StructType>(T))
         return ST->getNumElements();
@@ -484,18 +500,19 @@ static std::pair<Value*,int> FindBaseValue(const State &S, Value *V, bool UseCac
             CurrentV = EEI->getVectorOperand();
         }
         else if (auto LI = dyn_cast<LoadInst>(CurrentV)) {
-            if (auto PtrT = dyn_cast<PointerType>(LI->getType()->getScalarType())) {
-                if (PtrT->getAddressSpace() == AddressSpace::Loaded) {
-                    CurrentV = LI->getPointerOperand();
-                    fld_idx = -1;
-                    if (!isSpecialPtr(CurrentV->getType())) {
-                        // This could really be anything, but it's not loaded
-                        // from a tracked pointer, so it doesn't matter what
-                        // it is--just pick something simple.
-                        CurrentV = ConstantPointerNull::get(Type::getInt8PtrTy(V->getContext()));
-                    }
-                    continue;
+            if (hasLoadedTy(LI->getType())) {
+                // This is the old (now deprecated) implementation for loaded.
+                // New code should use the gc_loaded intrinsic to ensure that
+                // the load is paired with the correct Tracked value.
+                CurrentV = LI->getPointerOperand();
+                fld_idx = -1;
+                if (!isSpecialPtr(CurrentV->getType())) {
+                    // This could really be anything, but it's not loaded
+                    // from a tracked pointer, so it doesn't matter what
+                    // it is--just pick something simple.
+                    CurrentV = ConstantPointerNull::get(Type::getInt8PtrTy(V->getContext()));
                 }
+                continue;
             }
             // In general a load terminates a walk
             break;
@@ -517,36 +534,42 @@ static std::pair<Value*,int> FindBaseValue(const State &S, Value *V, bool UseCac
             if (II->getIntrinsicID() == Intrinsic::masked_load ||
                 II->getIntrinsicID() == Intrinsic::masked_gather) {
                 if (auto VTy = dyn_cast<VectorType>(II->getType())) {
-                    if (auto PtrT = dyn_cast<PointerType>(VTy->getElementType())) {
-                        if (PtrT->getAddressSpace() == AddressSpace::Loaded) {
-                            Value *Mask = II->getOperand(2);
-                            Value *Passthrough = II->getOperand(3);
-                            if (!isa<Constant>(Mask) || !cast<Constant>(Mask)->isAllOnesValue()) {
-                                assert(isa<UndefValue>(Passthrough) && "unimplemented");
-                                (void)Passthrough;
+                    if (hasLoadedTy(VTy->getElementType())) {
+                        Value *Mask = II->getOperand(2);
+                        Value *Passthrough = II->getOperand(3);
+                        if (!isa<Constant>(Mask) || !cast<Constant>(Mask)->isAllOnesValue()) {
+                            assert(isa<UndefValue>(Passthrough) && "unimplemented");
+                            (void)Passthrough;
+                        }
+                        CurrentV = II->getOperand(0);
+                        if (II->getIntrinsicID() == Intrinsic::masked_load) {
+                            fld_idx = -1;
+                            if (!isSpecialPtr(CurrentV->getType())) {
+                                CurrentV = ConstantPointerNull::get(Type::getInt8PtrTy(V->getContext()));
                             }
-                            CurrentV = II->getOperand(0);
-                            if (II->getIntrinsicID() == Intrinsic::masked_load) {
-                                fld_idx = -1;
-                                if (!isSpecialPtr(CurrentV->getType())) {
+                        } else {
+                            if (auto VTy2 = dyn_cast<VectorType>(CurrentV->getType())) {
+                                if (!isSpecialPtr(VTy2->getElementType())) {
                                     CurrentV = ConstantPointerNull::get(Type::getInt8PtrTy(V->getContext()));
-                                }
-                            } else {
-                                if (auto VTy2 = dyn_cast<VectorType>(CurrentV->getType())) {
-                                    if (!isSpecialPtr(VTy2->getElementType())) {
-                                        CurrentV = ConstantPointerNull::get(Type::getInt8PtrTy(V->getContext()));
-                                        fld_idx = -1;
-                                    }
+                                    fld_idx = -1;
                                 }
                             }
-                            continue;
                         }
+                        continue;
                     }
                 }
                 // In general a load terminates a walk
                 break;
             }
         }
+        else if (auto CI = dyn_cast<CallInst>(CurrentV)) {
+            auto callee = CI->getCalledFunction();
+            if (callee && callee->getName() == "julia.gc_loaded") {
+                CurrentV = CI->getArgOperand(0);
+                continue;
+            }
+            break;
+        }
         else {
             break;
         }
@@ -638,15 +661,12 @@ void LateLowerGCFrame::LiftSelect(State &S, SelectInst *SI) {
         // already visited here--nothing to do
         return;
     }
+    assert(!isTrackedValue(SI));
     SmallVector<int, 0> Numbers;
     unsigned NumRoots = 1;
-    if (auto VTy = dyn_cast<VectorType>(SI->getType())) {
-        ElementCount EC = VTy->getElementCount();
-        Numbers.resize(EC.getKnownMinValue(), -1);
-    }
-    else
-        assert(isa<PointerType>(SI->getType()) && "unimplemented");
-    assert(!isTrackedValue(SI));
+    Type *STy = SI->getType();
+    if (!isa<PointerType>(STy))
+        Numbers.resize(CountTrackedPointers(STy).count, -1);
     // find the base root for the arguments
     Value *TrueBase = MaybeExtractScalar(S, FindBaseValue(S, SI->getTrueValue(), false), SI);
     Value *FalseBase = MaybeExtractScalar(S, FindBaseValue(S, SI->getFalseValue(), false), SI);
@@ -723,20 +743,17 @@ void LateLowerGCFrame::LiftPhi(State &S, PHINode *Phi) {
     SmallVector<PHINode *, 2> lifted;
     SmallVector<int, 0> Numbers;
     unsigned NumRoots = 1;
-    if (auto VTy = dyn_cast<FixedVectorType>(Phi->getType())) {
-        NumRoots = VTy->getNumElements();
+    Type *PTy = Phi->getType();
+    if (!isa<PointerType>(PTy)) {
+        NumRoots = CountTrackedPointers(PTy).count;
         Numbers.resize(NumRoots);
     }
-    else {
-        // TODO: SVE
-        assert(isa<PointerType>(Phi->getType()) && "unimplemented");
-    }
     for (unsigned i = 0; i < NumRoots; ++i) {
         PHINode *lift = PHINode::Create(T_prjlvalue, Phi->getNumIncomingValues(), "gclift", Phi);
         int Number = ++S.MaxPtrNumber;
         S.AllPtrNumbering[lift] = Number;
         S.ReversePtrNumbering[Number] = lift;
-        if (!isa<VectorType>(Phi->getType()))
+        if (isa<PointerType>(PTy))
             S.AllPtrNumbering[Phi] = Number;
         else
             Numbers[i] = Number;
@@ -1176,7 +1193,7 @@ static bool isLoadFromImmut(LoadInst *LI)
     if (LI->getMetadata(LLVMContext::MD_invariant_load))
         return true;
     MDNode *TBAA = LI->getMetadata(LLVMContext::MD_tbaa);
-    if (isTBAA(TBAA, {"jtbaa_immut", "jtbaa_const", "jtbaa_datatype"}))
+    if (isTBAA(TBAA, {"jtbaa_immut", "jtbaa_const", "jtbaa_datatype", "jtbaa_memoryptr", "jtbaa_memorylen", "jtbaa_memoryown"}))
         return true;
     return false;
 }
@@ -1231,6 +1248,10 @@ static bool isLoadFromConstGV(Value *v, bool &task_local, PhiSet *seen = nullptr
             task_local = true;
             return true;
         }
+        if (callee && callee->getName() == "julia.gc_loaded") {
+            return isLoadFromConstGV(call->getArgOperand(0), task_local, seen) &&
+                   isLoadFromConstGV(call->getArgOperand(1), task_local, seen);
+        }
     }
     if (isa<Argument>(v)) {
         task_local = true;
@@ -1255,8 +1276,7 @@ static bool isLoadFromConstGV(LoadInst *LI, bool &task_local, PhiSet *seen)
     auto load_base = LI->getPointerOperand()->stripInBoundsOffsets();
     assert(load_base); // Static analyzer
     auto gv = dyn_cast<GlobalVariable>(load_base);
-    if (isTBAA(LI->getMetadata(LLVMContext::MD_tbaa),
-               {"jtbaa_immut", "jtbaa_const", "jtbaa_datatype"})) {
+    if (isLoadFromImmut(LI)) {
         if (gv)
             return true;
         return isLoadFromConstGV(load_base, task_local, seen);
@@ -1491,20 +1511,18 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                     if (II->getIntrinsicID() == Intrinsic::masked_load ||
                         II->getIntrinsicID() == Intrinsic::masked_gather) {
                         if (auto VTy = dyn_cast<VectorType>(II->getType())) {
-                            if (auto PtrT = dyn_cast<PointerType>(VTy->getElementType())) {
-                                if (isSpecialPtr(PtrT)) {
-                                    // LLVM sometimes tries to materialize these operations with undefined pointers in our non-integral address space.
-                                    // Hopefully LLVM didn't already propagate that information and poison our users. Set those to NULL now.
-                                    Value *passthru = II->getArgOperand(3);
-                                    if (isa<UndefValue>(passthru)) {
-                                        II->setArgOperand(3, Constant::getNullValue(passthru->getType()));
-                                    }
-                                    if (PtrT->getAddressSpace() == AddressSpace::Loaded) {
-                                        // These are not real defs
-                                        continue;
-                                    }
+                            if (CountTrackedPointers(VTy->getElementType()).count) {
+                                // LLVM sometimes tries to materialize these operations with undefined pointers in our non-integral address space.
+                                // Hopefully LLVM didn't already propagate that information and poison our users. Set those to NULL now.
+                                Value *passthru = II->getArgOperand(3);
+                                if (isa<UndefValue>(passthru)) {
+                                    II->setArgOperand(3, Constant::getNullValue(passthru->getType()));
                                 }
                             }
+                            if (hasLoadedTy(VTy->getElementType())) {
+                                // These are not real defs
+                                continue;
+                            }
                         }
                     }
                 }
@@ -1512,13 +1530,16 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                 if (callee && callee == typeof_func) {
                     MaybeNoteDef(S, BBS, CI, BBS.Safepoints, SmallVector<int, 1>{-2});
                 }
+                else if (callee && callee->getName() == "julia.gc_loaded") {
+                    continue;
+                }
                 else {
                     MaybeNoteDef(S, BBS, CI, BBS.Safepoints);
                 }
                 if (CI->hasStructRetAttr()) {
                     Type *ElT = getAttributeAtIndex(CI->getAttributes(), 1, Attribute::StructRet).getValueAsType();
                     assert(cast<PointerType>(CI->getArgOperand(0)->getType())->isOpaqueOrPointeeTypeMatches(getAttributeAtIndex(CI->getAttributes(), 1, Attribute::StructRet).getValueAsType()));
-                    auto tracked = CountTrackedPointers(ElT);
+                    auto tracked = CountTrackedPointers(ElT, true);
                     if (tracked.count) {
                         AllocaInst *SRet = dyn_cast<AllocaInst>((CI->arg_begin()[0])->stripInBoundsOffsets());
                         assert(SRet);
@@ -1599,7 +1620,7 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                         callee == gc_preserve_end_func || callee == typeof_func ||
                         callee == pgcstack_getter || callee->getName() == XSTR(jl_egal__unboxed) ||
                         callee->getName() == XSTR(jl_lock_value) || callee->getName() == XSTR(jl_unlock_value) ||
-                        callee == write_barrier_func ||
+                        callee == write_barrier_func || callee == gc_loaded_func ||
                         callee->getName() == "memcmp") {
                         continue;
                     }
@@ -1663,9 +1684,8 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                     // task but we do need to issue write barriers for when the current task dies.
                     RefinedPtr.push_back(task_local ? -1 : -2);
                 }
-                if (!Ty->isPointerTy() || Ty->getPointerAddressSpace() != AddressSpace::Loaded) {
+                if (!hasLoadedTy(Ty))
                     MaybeNoteDef(S, BBS, LI, BBS.Safepoints, std::move(RefinedPtr));
-                }
                 NoteOperandUses(S, BBS, I);
             } else if (auto *LI = dyn_cast<AtomicCmpXchgInst>(&I)) {
                 Type *Ty = LI->getNewValOperand()->getType()->getScalarType();
@@ -1827,7 +1847,8 @@ SmallVector<Value*, 0> ExtractTrackedValues(Value *Src, Type *STy, bool isptr, I
         if (ignore_field(Idxs))
             continue;
         Value *Elem = ExtractScalar(Src, STy, isptr, Idxs, irbuilder);
-        Ptrs.push_back(Elem);
+        if (isTrackedValue(Elem)) // ignore addrspace Loaded when it appears
+            Ptrs.push_back(Elem);
     }
     return Ptrs;
 }
@@ -2294,7 +2315,7 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S, bool *CFGModified) {
             if (I->getMetadata(LLVMContext::MD_invariant_load))
                 I->setMetadata(LLVMContext::MD_invariant_load, NULL);
             if (MDNode *TBAA = I->getMetadata(LLVMContext::MD_tbaa)) {
-                if (TBAA->getNumOperands() == 4 && isTBAA(TBAA, {"jtbaa_const"})) {
+                if (TBAA->getNumOperands() == 4 && isTBAA(TBAA, {"jtbaa_const", "jtbaa_memoryptr", "jtbaa_memorylen", "tbaa_memoryown"})) {
                     MDNode *MutableTBAA = createMutableTBAAAccessTag(TBAA);
                     if (MutableTBAA != TBAA)
                         I->setMetadata(LLVMContext::MD_tbaa, MutableTBAA);
@@ -2323,7 +2344,13 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S, bool *CFGModified) {
                 /* No replacement */
             } else if (pointer_from_objref_func != nullptr && callee == pointer_from_objref_func) {
                 auto *obj = CI->getOperand(0);
-                auto *ASCI = new AddrSpaceCastInst(obj, JuliaType::get_pjlvalue_ty(obj->getContext()), "", CI);
+                auto *ASCI = new AddrSpaceCastInst(obj, CI->getType(), "", CI);
+                ASCI->takeName(CI);
+                CI->replaceAllUsesWith(ASCI);
+                UpdatePtrNumbering(CI, ASCI, S);
+            } else if (gc_loaded_func != nullptr && callee == gc_loaded_func) {
+                auto *obj = CI->getOperand(1);
+                auto *ASCI = new AddrSpaceCastInst(obj, CI->getType(), "", CI);
                 ASCI->takeName(CI);
                 CI->replaceAllUsesWith(ASCI);
                 UpdatePtrNumbering(CI, ASCI, S);
diff --git a/src/llvm-pass-helpers.cpp b/src/llvm-pass-helpers.cpp
index 543cdb137e570..63eeb96f0a03e 100644
--- a/src/llvm-pass-helpers.cpp
+++ b/src/llvm-pass-helpers.cpp
@@ -25,7 +25,7 @@ JuliaPassContext::JuliaPassContext()
 
         pgcstack_getter(nullptr), adoptthread_func(nullptr), gc_flush_func(nullptr),
         gc_preserve_begin_func(nullptr), gc_preserve_end_func(nullptr),
-        pointer_from_objref_func(nullptr), alloc_obj_func(nullptr),
+        pointer_from_objref_func(nullptr), gc_loaded_func(nullptr), alloc_obj_func(nullptr),
         typeof_func(nullptr), write_barrier_func(nullptr),
         call_func(nullptr), call2_func(nullptr), module(nullptr)
 {
@@ -48,6 +48,7 @@ void JuliaPassContext::initFunctions(Module &M)
     gc_preserve_begin_func = M.getFunction("llvm.julia.gc_preserve_begin");
     gc_preserve_end_func = M.getFunction("llvm.julia.gc_preserve_end");
     pointer_from_objref_func = M.getFunction("julia.pointer_from_objref");
+    gc_loaded_func = M.getFunction("julia.gc_loaded");
     typeof_func = M.getFunction("julia.typeof");
     write_barrier_func = M.getFunction("julia.write_barrier");
     alloc_obj_func = M.getFunction("julia.gc_alloc_obj");
diff --git a/src/llvm-pass-helpers.h b/src/llvm-pass-helpers.h
index 97cc2a03415b2..3478f1ece0b5e 100644
--- a/src/llvm-pass-helpers.h
+++ b/src/llvm-pass-helpers.h
@@ -56,6 +56,7 @@ struct JuliaPassContext {
     llvm::Function *gc_preserve_begin_func;
     llvm::Function *gc_preserve_end_func;
     llvm::Function *pointer_from_objref_func;
+    llvm::Function *gc_loaded_func;
     llvm::Function *alloc_obj_func;
     llvm::Function *typeof_func;
     llvm::Function *write_barrier_func;
diff --git a/src/method.c b/src/method.c
index 7d8d0e9ec4a78..4e3062fef5246 100644
--- a/src/method.c
+++ b/src/method.c
@@ -94,7 +94,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
             // ignore these
         }
         else {
-            size_t i = 0, nargs = jl_array_len(e->args);
+            size_t i = 0, nargs = jl_array_nrows(e->args);
             if (e->head == jl_opaque_closure_method_sym) {
                 if (nargs != 5) {
                     jl_error("opaque_closure_method: invalid syntax");
@@ -266,7 +266,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
 JL_DLLEXPORT void jl_resolve_globals_in_ir(jl_array_t *stmts, jl_module_t *m, jl_svec_t *sparam_vals,
                               int binding_effects)
 {
-    size_t i, l = jl_array_len(stmts);
+    size_t i, l = jl_array_nrows(stmts);
     for (i = 0; i < l; i++) {
         jl_value_t *stmt = jl_array_ptr_ref(stmts, i);
         jl_array_ptr_set(stmts, i, resolve_globals(stmt, m, sparam_vals, binding_effects, 0));
@@ -286,18 +286,17 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
     jl_expr_t *bodyex = (jl_expr_t*)jl_exprarg(ir, 2);
     jl_value_t *codelocs = jl_exprarg(ir, 3);
     li->linetable = jl_exprarg(ir, 4);
-    size_t nlocs = jl_array_len(codelocs);
+    size_t nlocs = jl_array_nrows(codelocs);
     li->codelocs = (jl_value_t*)jl_alloc_array_1d(jl_array_int32_type, nlocs);
     size_t j;
     for (j = 0; j < nlocs; j++) {
-        jl_arrayset((jl_array_t*)li->codelocs, jl_box_int32(jl_unbox_long(jl_arrayref((jl_array_t*)codelocs, j))),
-                    j);
+        jl_array_uint32_set((jl_array_t*)li->codelocs, j, jl_unbox_long(jl_array_ptr_ref((jl_array_t*)codelocs, j)));
     }
     assert(jl_is_expr(bodyex));
     jl_array_t *body = bodyex->args;
     li->code = body;
     jl_gc_wb(li, li->code);
-    size_t n = jl_array_len(body);
+    size_t n = jl_array_nrows(body);
     jl_value_t **bd = (jl_value_t**)jl_array_ptr_data((jl_array_t*)li->code);
     li->ssaflags = jl_alloc_array_1d(jl_array_uint32_type, n);
     jl_gc_wb(li, li->ssaflags);
@@ -409,7 +408,7 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
     free(inline_flags);
     jl_array_t *vinfo = (jl_array_t*)jl_exprarg(ir, 1);
     jl_array_t *vis = (jl_array_t*)jl_array_ptr_ref(vinfo, 0);
-    size_t nslots = jl_array_len(vis);
+    size_t nslots = jl_array_nrows(vis);
     jl_value_t *ssavalue_types = jl_array_ptr_ref(vinfo, 2);
     assert(jl_is_long(ssavalue_types));
     size_t nssavalue = jl_unbox_long(ssavalue_types);
@@ -507,7 +506,7 @@ void jl_add_function_to_lineinfo(jl_code_info_t *ci, jl_value_t *func)
 {
     // func may contain jl_symbol (function name), jl_method_t, or jl_method_instance_t
     jl_array_t *li = (jl_array_t*)ci->linetable;
-    size_t i, n = jl_array_len(li);
+    size_t i, n = jl_array_nrows(li);
     jl_value_t *rt = NULL, *lno = NULL, *inl = NULL;
     JL_GC_PUSH3(&rt, &lno, &inl);
     for (i = 0; i < n; i++) {
@@ -618,7 +617,7 @@ JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo, siz
 
         // If this generated function has an opaque closure, cache it for
         // correctness of method identity
-        for (int i = 0; i < jl_array_len(func->code); ++i) {
+        for (int i = 0; i < jl_array_nrows(func->code); ++i) {
             jl_value_t *stmt = jl_array_ptr_ref(func->code, i);
             if (jl_is_expr(stmt) && ((jl_expr_t*)stmt)->head == jl_new_opaque_closure_sym) {
                 if (jl_options.incremental && jl_generating_output())
@@ -700,7 +699,7 @@ JL_DLLEXPORT void jl_method_set_source(jl_method_t *m, jl_code_info_t *src)
     JL_GC_PUSH3(&copy, &sparam_vars, &src);
     assert(jl_typetagis(src->code, jl_array_any_type));
     jl_array_t *stmts = (jl_array_t*)src->code;
-    size_t i, n = jl_array_len(stmts);
+    size_t i, n = jl_array_nrows(stmts);
     copy = jl_alloc_vec_any(n);
     for (i = 0; i < n; i++) {
         jl_value_t *st = jl_array_ptr_ref(stmts, i);
@@ -1110,7 +1109,7 @@ JL_DLLEXPORT jl_method_t* jl_method_def(jl_svec_t *argdata,
         jl_all_methods = jl_alloc_vec_any(0);
 #endif
     if (jl_all_methods != NULL) {
-        while (jl_array_len(jl_all_methods) < m->primary_world)
+        while (jl_array_nrows(jl_all_methods) < m->primary_world)
             jl_array_ptr_1d_push(jl_all_methods, NULL);
         jl_array_ptr_1d_push(jl_all_methods, (jl_value_t*)m);
     }
@@ -1170,10 +1169,10 @@ static uint64_t current_root_id(jl_array_t *root_blocks)
     if (!root_blocks)
         return 0;
     assert(jl_is_array(root_blocks));
-    size_t nx2 = jl_array_len(root_blocks);
+    size_t nx2 = jl_array_nrows(root_blocks);
     if (nx2 == 0)
         return 0;
-    uint64_t *blocks = (uint64_t*)jl_array_data(root_blocks);
+    uint64_t *blocks = jl_array_data(root_blocks, uint64_t);
     return blocks[nx2-2];
 }
 
@@ -1182,8 +1181,8 @@ static void add_root_block(jl_array_t *root_blocks, uint64_t modid, size_t len)
 {
     assert(jl_is_array(root_blocks));
     jl_array_grow_end(root_blocks, 2);
-    uint64_t *blocks = (uint64_t*)jl_array_data(root_blocks);
-    int nx2 = jl_array_len(root_blocks);
+    uint64_t *blocks = jl_array_data(root_blocks, uint64_t);
+    int nx2 = jl_array_nrows(root_blocks);
     blocks[nx2-2] = modid;
     blocks[nx2-1] = len;
 }
@@ -1213,7 +1212,7 @@ JL_DLLEXPORT void jl_add_method_root(jl_method_t *m, jl_module_t *mod, jl_value_
     assert(jl_is_method(m));
     prepare_method_for_roots(m, modid);
     if (current_root_id(m->root_blocks) != modid)
-        add_root_block(m->root_blocks, modid, jl_array_len(m->roots));
+        add_root_block(m->root_blocks, modid, jl_array_nrows(m->roots));
     jl_array_ptr_1d_push(m->roots, root);
     JL_GC_POP();
 }
@@ -1225,7 +1224,7 @@ void jl_append_method_roots(jl_method_t *m, uint64_t modid, jl_array_t* roots)
     assert(jl_is_method(m));
     assert(jl_is_array(roots));
     prepare_method_for_roots(m, modid);
-    add_root_block(m->root_blocks, modid, jl_array_len(m->roots));
+    add_root_block(m->root_blocks, modid, jl_array_nrows(m->roots));
     jl_array_ptr_1d_append(m->roots, roots);
     JL_GC_POP();
 }
@@ -1239,7 +1238,7 @@ int get_root_reference(rle_reference *rr, jl_method_t *m, size_t i)
         rr->index = i;
         return i < m->nroots_sysimg;
     }
-    rle_index_to_reference(rr, i, (uint64_t*)jl_array_data(m->root_blocks), jl_array_len(m->root_blocks), 0);
+    rle_index_to_reference(rr, i, jl_array_data(m->root_blocks, uint64_t), jl_array_nrows(m->root_blocks), 0);
     if (rr->key)
         return 1;
     return i < m->nroots_sysimg;
@@ -1254,7 +1253,7 @@ jl_value_t *lookup_root(jl_method_t *m, uint64_t key, int index)
         return jl_array_ptr_ref(m->roots, index);
     }
     rle_reference rr = {key, index};
-    size_t i = rle_reference_to_index(&rr, (uint64_t*)jl_array_data(m->root_blocks), jl_array_len(m->root_blocks), 0);
+    size_t i = rle_reference_to_index(&rr, jl_array_data(m->root_blocks, uint64_t), jl_array_nrows(m->root_blocks), 0);
     return jl_array_ptr_ref(m->roots, i);
 }
 
@@ -1263,11 +1262,11 @@ int nroots_with_key(jl_method_t *m, uint64_t key)
 {
     size_t nroots = 0;
     if (m->roots)
-        nroots = jl_array_len(m->roots);
+        nroots = jl_array_nrows(m->roots);
     if (!m->root_blocks)
         return key == 0 ? nroots : 0;
-    uint64_t *rletable = (uint64_t*)jl_array_data(m->root_blocks);
-    size_t j, nblocks2 = jl_array_len(m->root_blocks);
+    uint64_t *rletable = jl_array_data(m->root_blocks, uint64_t);
+    size_t j, nblocks2 = jl_array_nrows(m->root_blocks);
     int nwithkey = 0;
     for (j = 0; j < nblocks2; j+=2) {
         if (rletable[j] == key)
diff --git a/src/module.c b/src/module.c
index c4b8437da4f01..b9abc2ce6bc38 100644
--- a/src/module.c
+++ b/src/module.c
@@ -41,16 +41,14 @@ JL_DLLEXPORT jl_module_t *jl_new_module_(jl_sym_t *name, jl_module_t *parent, ui
     jl_atomic_store_relaxed(&m->bindings, jl_emptysvec);
     jl_atomic_store_relaxed(&m->bindingkeyset, (jl_array_t*)jl_an_empty_vec_any);
     arraylist_new(&m->usings, 0);
-    JL_GC_PUSH1(&m);
     if (jl_core_module && default_names) {
+        JL_GC_PUSH1(&m);
         jl_module_using(m, jl_core_module);
-    }
-    // export own name, so "using Foo" makes "Foo" itself visible
-    if (default_names) {
+        // export own name, so "using Foo" makes "Foo" itself visible
         jl_set_const(m, name, (jl_value_t*)m);
+        jl_module_public(m, name, 1);
+        JL_GC_POP();
     }
-    jl_module_public(m, name, 1);
-    JL_GC_POP();
     return m;
 }
 
diff --git a/src/precompile.c b/src/precompile.c
index ad33dcd9b6d65..be0e168c6a07c 100644
--- a/src/precompile.c
+++ b/src/precompile.c
@@ -35,7 +35,7 @@ void write_srctext(ios_t *f, jl_array_t *udeps, int64_t srctextpos) {
         //   uint64: length of src text
         //   char*: src text
         // At the end we write int32(0) as a terminal sentinel.
-        size_t len = jl_array_len(udeps);
+        size_t len = jl_array_nrows(udeps);
         static jl_value_t *replace_depot_func = NULL;
         if (!replace_depot_func)
             replace_depot_func = jl_get_global(jl_base_module, jl_symbol("replace_depot_path"));
@@ -104,9 +104,9 @@ JL_DLLEXPORT void jl_write_compiler_output(void)
     jl_array_t *udeps = NULL;
     JL_GC_PUSH2(&worklist, &udeps);
     jl_module_init_order = jl_alloc_vec_any(0);
-    int i, l = jl_array_len(worklist);
+    int i, l = jl_array_nrows(worklist);
     for (i = 0; i < l; i++) {
-        jl_value_t *m = jl_ptrarrayref(worklist, i);
+        jl_value_t *m = jl_array_ptr_ref(worklist, i);
         jl_value_t *f = jl_get_global((jl_module_t*)m, jl_symbol("__init__"));
         if (f) {
             jl_array_ptr_1d_push(jl_module_init_order, m);
diff --git a/src/precompile_utils.c b/src/precompile_utils.c
index 9a577b900a1b7..0203569f33c37 100644
--- a/src/precompile_utils.c
+++ b/src/precompile_utils.c
@@ -154,7 +154,7 @@ static void jl_compile_all_defs(jl_array_t *mis)
 
     jl_foreach_reachable_mtable(compile_all_collect_, allmeths);
 
-    size_t i, l = jl_array_len(allmeths);
+    size_t i, l = jl_array_nrows(allmeths);
     for (i = 0; i < l; i++) {
         jl_method_t *m = (jl_method_t*)jl_array_ptr_ref(allmeths, i);
         if (jl_is_datatype(m->sig) && jl_isa_compileable_sig((jl_tupletype_t*)m->sig, jl_emptysvec, m)) {
@@ -243,7 +243,7 @@ static void *jl_precompile_(jl_array_t *m, int external_linkage)
     jl_method_instance_t *mi = NULL;
     JL_GC_PUSH2(&m2, &mi);
     m2 = jl_alloc_vec_any(0);
-    for (size_t i = 0; i < jl_array_len(m); i++) {
+    for (size_t i = 0; i < jl_array_nrows(m); i++) {
         jl_value_t *item = jl_array_ptr_ref(m, i);
         if (jl_is_method_instance(item)) {
             mi = (jl_method_instance_t*)item;
@@ -287,13 +287,13 @@ static void *jl_precompile_worklist(jl_array_t *worklist, jl_array_t *extext_met
     // type signatures that were inferred but haven't been compiled
     jl_array_t *m = jl_alloc_vec_any(0);
     JL_GC_PUSH1(&m);
-    size_t i, n = jl_array_len(worklist);
+    size_t i, n = jl_array_nrows(worklist);
     for (i = 0; i < n; i++) {
         jl_module_t *mod = (jl_module_t*)jl_array_ptr_ref(worklist, i);
         assert(jl_is_module(mod));
         foreach_mtable_in_module(mod, precompile_enq_all_specializations_, m);
     }
-    n = jl_array_len(extext_methods);
+    n = jl_array_nrows(extext_methods);
     for (i = 0; i < n; i++) {
         jl_method_t *method = (jl_method_t*)jl_array_ptr_ref(extext_methods, i);
         assert(jl_is_method(method));
@@ -310,7 +310,7 @@ static void *jl_precompile_worklist(jl_array_t *worklist, jl_array_t *extext_met
             }
         }
     }
-    n = jl_array_len(new_specializations);
+    n = jl_array_nrows(new_specializations);
     for (i = 0; i < n; i++) {
         jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(new_specializations, i);
         precompile_enq_specialization_(ci->def, m);
diff --git a/src/processor.cpp b/src/processor.cpp
index 1e1c8eba796c2..99e02215be4ea 100644
--- a/src/processor.cpp
+++ b/src/processor.cpp
@@ -993,7 +993,7 @@ extern "C" JL_DLLEXPORT jl_value_t* jl_reflect_clone_targets() {
     }
 
     jl_value_t *arr = (jl_value_t*)jl_alloc_array_1d(jl_array_uint8_type, data.size());
-    uint8_t *out = (uint8_t*)jl_array_data(arr);
+    uint8_t *out = jl_array_data(arr, uint8_t);
     memcpy(out, data.data(), data.size());
     return arr;
 }
diff --git a/src/rtutils.c b/src/rtutils.c
index afe8d24678a61..e3cb1af50c676 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -362,7 +362,10 @@ JL_DLLEXPORT void *(jl_symbol_name)(jl_sym_t *s)
 // WARNING: THIS FUNCTION IS NEVER CALLED BUT INLINE BY CCALL
 JL_DLLEXPORT void *jl_array_ptr(jl_array_t *a)
 {
-    return a->data;
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(a->ref.mem))->layout;
+    if (layout->flags.arrayelem_isunion || layout->size == 0)
+        return (char*)a->ref.mem->ptr + (size_t)jl_array_data_(a);
+    return jl_array_data_(a);
 }
 JL_DLLEXPORT jl_value_t *jl_value_ptr(jl_value_t *a)
 {
@@ -1028,7 +1031,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     }
     else if (vt == jl_expr_type) {
         jl_expr_t *e = (jl_expr_t*)v;
-        if (e->head == jl_assign_sym && jl_array_len(e->args) == 2) {
+        if (e->head == jl_assign_sym && jl_array_nrows(e->args) == 2) {
             n += jl_static_show_x(out, jl_exprarg(e,0), depth, ctx);
             n += jl_printf(out, " = ");
             n += jl_static_show_x(out, jl_exprarg(e,1), depth, ctx);
@@ -1036,7 +1039,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         else {
             char sep = ' ';
             n += jl_printf(out, "Expr(:%s", jl_symbol_name(e->head));
-            size_t i, len = jl_array_len(e->args);
+            size_t i, len = jl_array_nrows(e->args);
             for (i = 0; i < len; i++) {
                 n += jl_printf(out, ",%c", sep);
                 n += jl_static_show_x(out, jl_exprarg(e,i), depth, ctx);
@@ -1046,24 +1049,63 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     }
     else if (jl_array_type && jl_is_array_type(vt)) {
         n += jl_printf(out, "Array{");
-        n += jl_static_show_x(out, (jl_value_t*)jl_tparam0(vt), depth, ctx);
-        n += jl_printf(out, ", (");
+        jl_value_t *el_type = jl_tparam0(vt);
+        n += jl_static_show_x(out, el_type, depth, ctx);
+        jl_array_t *av = (jl_array_t*)v;
         size_t i, ndims = jl_array_ndims(v);
+        n += jl_printf(out, ", %" PRIdPTR "}(dims=(", ndims);
         if (ndims == 1)
             n += jl_printf(out, "%" PRIdPTR ",", jl_array_dim0(v));
         else
             for (i = 0; i < ndims; i++)
                 n += jl_printf(out, (i > 0 ? ", %" PRIdPTR : "%" PRIdPTR), jl_array_dim(v, i));
-        n += jl_printf(out, ")}[");
-        size_t j, tlen = jl_array_len(v);
-        jl_array_t *av = (jl_array_t*)v;
-        jl_value_t *el_type = jl_tparam0(vt);
-        char *typetagdata = (!av->flags.ptrarray && jl_is_uniontype(el_type)) ? jl_array_typetagdata(av) : NULL;
+        n += jl_printf(out, "), mem=");
+        n += jl_static_show_x(out, (jl_value_t*)av->ref.mem, depth, ctx);
+        n += jl_printf(out, ")");
+    }
+    else if (jl_genericmemoryref_type && jl_is_genericmemoryref_type(vt)) {
+        jl_genericmemoryref_t *ref = (jl_genericmemoryref_t*)v;
+        n += jl_printf(out, "MemoryRef(offset=");
+        size_t offset = (size_t)ref->ptr_or_offset;
+        if (ref->mem) {
+            const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typeof(ref->mem))->layout;
+            if (layout->size != 0 && !layout->flags.arrayelem_isunion)
+                offset = ((char*)offset - (char*)ref->mem->ptr) / layout->size;
+        }
+        n += jl_printf(out, "%" PRIdPTR, offset);
+        n += jl_printf(out, ", ptr_or_offset=%p, mem=", ref->ptr_or_offset);
+        n += jl_static_show_x(out, (jl_value_t*)ref->mem, depth, ctx);
+    }
+    else if (jl_genericmemory_type && jl_is_genericmemory_type(vt)) {
+        jl_genericmemory_t *m = (jl_genericmemory_t*)v;
+        jl_value_t *isatomic = jl_tparam0(vt);
+        jl_value_t *addrspace = jl_tparam2(vt);
+        if (isatomic == (jl_value_t*)jl_not_atomic_sym && jl_is_addrspacecore(addrspace) && jl_unbox_uint8(addrspace) == 0) {
+            n += jl_printf(out, "Memory{");
+        }
+        else {
+            n += jl_printf(out, "GenericMemory{");
+            n += jl_static_show_x(out, isatomic, depth, ctx);
+            n += jl_printf(out, ", ");
+            n += jl_static_show_x(out, addrspace, depth, ctx);
+            n += jl_printf(out, ", ");
+        }
+        jl_value_t *el_type = jl_tparam1(vt);
+        n += jl_static_show_x(out, el_type, depth, ctx);
+        size_t j, tlen = m->length;
+        n += jl_printf(out, "}(%" PRIdPTR ", %p)[", tlen, m->ptr);
+//#ifdef _P64
+//        n += jl_printf(out, "0x%016" PRIx64, tlen);
+//#else
+//        n += jl_printf(out, "0x%08" PRIx32, tlen);
+//#endif
+        const jl_datatype_layout_t *layout = vt->layout;
         int nlsep = 0;
-        if (av->flags.ptrarray) {
+        const char *typetagdata = NULL;
+        if (layout->flags.arrayelem_isboxed) {
             // print arrays with newlines, unless the elements are probably small
             for (j = 0; j < tlen; j++) {
-                jl_value_t **ptr = ((jl_value_t**)av->data) + j;
+                jl_value_t **ptr = ((jl_value_t**)m->ptr) + j;
                 jl_value_t *p = *ptr;
                 if (p != NULL && (uintptr_t)p >= 4096U) {
                     jl_value_t *p_ty = jl_typeof(p);
@@ -1076,21 +1118,30 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
                 }
             }
         }
-        if (nlsep && tlen > 1)
-            n += jl_printf(out, "\n  ");
-        for (j = 0; j < tlen; j++) {
-            if (av->flags.ptrarray) {
-                jl_value_t **ptr = ((jl_value_t**)av->data) + j;
-                n += jl_static_show_x(out, *ptr, depth, ctx);
-            }
-            else {
-                char *ptr = ((char*)av->data) + j * av->elsize;
-                n += jl_static_show_x_(out, (jl_value_t*)ptr,
-                        typetagdata ? (jl_datatype_t*)jl_nth_union_component(el_type, typetagdata[j]) : (jl_datatype_t*)el_type,
-                        depth, ctx);
+        else if (layout->flags.arrayelem_isunion) {
+            typetagdata = jl_genericmemory_typetagdata(m);
+        }
+        if (layout->size == 0 && tlen >= 3) {
+            n += jl_static_show_x_(out, (jl_value_t*)m->ptr, (jl_datatype_t*)el_type, depth, ctx);
+            n += jl_printf(out, ", ...");
+        }
+        else {
+            if (nlsep && tlen > 1)
+                n += jl_printf(out, "\n  ");
+            for (size_t j = 0; j < tlen; j++) {
+                if (layout->flags.arrayelem_isboxed) {
+                    jl_value_t **ptr = ((jl_value_t**)m->ptr) + j;
+                    n += jl_static_show_x(out, *ptr, depth, ctx);
+                }
+                else {
+                    char *ptr = ((char*)m->ptr) + j * layout->size;
+                    n += jl_static_show_x_(out, (jl_value_t*)ptr,
+                            (jl_datatype_t*)(typetagdata ? jl_nth_union_component(el_type, typetagdata[j]) : el_type),
+                            depth, ctx);
+                }
+                if (j != tlen - 1)
+                    n += jl_printf(out, nlsep ? ",\n  " : ", ");
             }
-            if (j != tlen - 1)
-                n += jl_printf(out, nlsep ? ",\n  " : ", ");
         }
         n += jl_printf(out, "]");
     }
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index 0c4021570ef21..aa0922fcb96ce 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -1667,12 +1667,6 @@ un_fintrinsic(rint_float,rint_llvm)
 un_fintrinsic(sqrt_float,sqrt_llvm)
 un_fintrinsic(sqrt_float,sqrt_llvm_fast)
 
-JL_DLLEXPORT jl_value_t *jl_arraylen(jl_value_t *a)
-{
-    JL_TYPECHK(arraylen, array, a);
-    return jl_box_long(jl_array_len((jl_array_t*)a));
-}
-
 JL_DLLEXPORT jl_value_t *jl_have_fma(jl_value_t *typ)
 {
     JL_TYPECHK(have_fma, datatype, typ);
diff --git a/src/serialize.h b/src/serialize.h
index afcdcc31d66c4..1bd29e9cc5911 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -64,8 +64,9 @@ extern "C" {
 #define TAG_ARGUMENT           56
 #define TAG_RELOC_METHODROOT   57
 #define TAG_BINDING            58
+#define TAG_MEMORYT            59
 
-#define LAST_TAG 58
+#define LAST_TAG 59
 
 #define write_uint8(s, n) ios_putc((n), (s))
 #define read_uint8(s) ((uint8_t)ios_getc((s)))
diff --git a/src/simplevector.c b/src/simplevector.c
index 65217715ae55f..7bac60f49d9c4 100644
--- a/src/simplevector.c
+++ b/src/simplevector.c
@@ -79,7 +79,7 @@ JL_DLLEXPORT jl_svec_t *jl_svec_copy(jl_svec_t *a)
 {
     size_t n = jl_svec_len(a);
     jl_svec_t *c = jl_alloc_svec_uninit(n);
-    memmove_refs((void**)jl_svec_data(c), (void**)jl_svec_data(a), n);
+    memmove_refs((_Atomic(void*)*)jl_svec_data(c), (_Atomic(void*)*)jl_svec_data(a), n);
     return c;
 }
 
diff --git a/src/smallintset.c b/src/smallintset.c
index fa647b57e7d3e..b3af6e45c7834 100644
--- a/src/smallintset.c
+++ b/src/smallintset.c
@@ -28,11 +28,11 @@ static inline size_t jl_intref(const jl_array_t *arr, size_t idx) JL_NOTSAFEPOIN
 {
     jl_value_t *el = jl_tparam0(jl_typeof(arr));
     if (el == (jl_value_t*)jl_uint8_type)
-        return jl_atomic_load_relaxed(&((_Atomic(uint8_t)*)jl_array_data(arr))[idx]);
+        return jl_atomic_load_relaxed(&jl_array_data(arr, _Atomic(uint8_t))[idx]);
     else if (el == (jl_value_t*)jl_uint16_type)
-        return jl_atomic_load_relaxed(&((_Atomic(uint16_t)*)jl_array_data(arr))[idx]);
+        return jl_atomic_load_relaxed(&jl_array_data(arr, _Atomic(uint16_t))[idx]);
     else if (el == (jl_value_t*)jl_uint32_type)
-        return jl_atomic_load_relaxed(&((_Atomic(uint32_t)*)jl_array_data(arr))[idx]);
+        return jl_atomic_load_relaxed(&jl_array_data(arr, _Atomic(uint32_t))[idx]);
     else
         abort();
 }
@@ -41,11 +41,11 @@ static inline size_t jl_intref_acquire(const jl_array_t *arr, size_t idx) JL_NOT
 {
     jl_value_t *el = jl_tparam0(jl_typeof(arr));
     if (el == (jl_value_t*)jl_uint8_type)
-        return jl_atomic_load_acquire(&((_Atomic(uint8_t)*)jl_array_data(arr))[idx]);
+        return jl_atomic_load_acquire(&jl_array_data(arr, _Atomic(uint8_t))[idx]);
     else if (el == (jl_value_t*)jl_uint16_type)
-        return jl_atomic_load_acquire(&((_Atomic(uint16_t)*)jl_array_data(arr))[idx]);
+        return jl_atomic_load_acquire(&jl_array_data(arr, _Atomic(uint16_t))[idx]);
     else if (el == (jl_value_t*)jl_uint32_type)
-        return jl_atomic_load_acquire(&((_Atomic(uint32_t)*)jl_array_data(arr))[idx]);
+        return jl_atomic_load_acquire(&jl_array_data(arr, _Atomic(uint32_t))[idx]);
     else
         abort();
 }
@@ -54,11 +54,11 @@ static inline void jl_intset_release(const jl_array_t *arr, size_t idx, size_t v
 {
     jl_value_t *el = jl_tparam0(jl_typeof(arr));
     if (el == (jl_value_t*)jl_uint8_type)
-        jl_atomic_store_release(&((_Atomic(uint8_t)*)jl_array_data(arr))[idx], val);
+        jl_atomic_store_release(&jl_array_data(arr, _Atomic(uint8_t))[idx], val);
     else if (el == (jl_value_t*)jl_uint16_type)
-        jl_atomic_store_release(&((_Atomic(uint16_t)*)jl_array_data(arr))[idx], val);
+        jl_atomic_store_release(&jl_array_data(arr, _Atomic(uint16_t))[idx], val);
     else if (el == (jl_value_t*)jl_uint32_type)
-        jl_atomic_store_release(&((_Atomic(uint32_t)*)jl_array_data(arr))[idx], val);
+        jl_atomic_store_release(&jl_array_data(arr, _Atomic(uint32_t))[idx], val);
     else
         abort();
 }
@@ -81,14 +81,17 @@ static inline size_t jl_max_int(const jl_array_t *arr)
 static jl_array_t *jl_alloc_int_1d(size_t np, size_t len)
 {
     jl_value_t *ty;
+    size_t elsize;
     if (np < 0xFF) {
         ty = jl_array_uint8_type;
+        elsize = sizeof(uint8_t);
      }
     else if (np < 0xFFFF) {
         static jl_value_t *int16 JL_ALWAYS_LEAFTYPE = NULL;
         if (int16 == NULL)
             int16 = jl_apply_array_type((jl_value_t*)jl_uint16_type, 1);
         ty = int16;
+        elsize = sizeof(uint16_t);
     }
     else {
         assert(np < 0x7FFFFFFF);
@@ -96,15 +99,16 @@ static jl_array_t *jl_alloc_int_1d(size_t np, size_t len)
         if (int32 == NULL)
             int32 = jl_apply_array_type((jl_value_t*)jl_uint32_type, 1);
         ty = int32;
+        elsize = sizeof(uint32_t);
     }
     jl_array_t *a = jl_alloc_array_1d(ty, len);
-    memset(a->data, 0, len * a->elsize);
+    memset(jl_array_data(a, char), 0, len * elsize);
     return a;
 }
 
 ssize_t jl_smallintset_lookup(jl_array_t *cache, smallintset_eq eq, const void *key, jl_svec_t *data, uint_t hv)
 {
-    size_t sz = jl_array_len(cache);
+    size_t sz = jl_array_nrows(cache);
     if (sz == 0)
         return -1;
     JL_GC_PUSH1(&cache);
@@ -131,7 +135,7 @@ ssize_t jl_smallintset_lookup(jl_array_t *cache, smallintset_eq eq, const void *
 
 static int smallintset_insert_(jl_array_t *a, uint_t hv, size_t val1)
 {
-    size_t sz = jl_array_len(a);
+    size_t sz = jl_array_nrows(a);
     if (sz <= 1)
         return 0;
     size_t orig, index, iter;
@@ -156,7 +160,7 @@ void jl_smallintset_insert(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, sma
 {
     jl_array_t *a = jl_atomic_load_relaxed(pcache);
     if (val + 1 >  jl_max_int(a))
-        smallintset_rehash(pcache, parent, hash, data, jl_array_len(a), val + 1);
+        smallintset_rehash(pcache, parent, hash, data, jl_array_nrows(a), val + 1);
     while (1) {
         a = jl_atomic_load_relaxed(pcache);
         if (smallintset_insert_(a, hash(val, data), val + 1))
@@ -168,7 +172,7 @@ void jl_smallintset_insert(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, sma
         /* lots of time rehashing all the keys over and over. */
         size_t newsz;
         a = jl_atomic_load_relaxed(pcache);
-        size_t sz = jl_array_len(a);
+        size_t sz = jl_array_nrows(a);
         if (sz < HT_N_INLINE)
             newsz = HT_N_INLINE;
         else if (sz >= (1 << 19) || (sz <= (1 << 8)))
@@ -182,7 +186,7 @@ void jl_smallintset_insert(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, sma
 static void smallintset_rehash(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, smallintset_hash hash, jl_svec_t *data, size_t newsz, size_t np)
 {
     jl_array_t *a = jl_atomic_load_relaxed(pcache);
-    size_t sz = jl_array_len(a);
+    size_t sz = jl_array_nrows(a);
     size_t i;
     for (i = 0; i < sz; i += 1) {
         size_t val = jl_intref(a, i);
diff --git a/src/stackwalk.c b/src/stackwalk.c
index 6cf42e079f6ca..6efb177927637 100644
--- a/src/stackwalk.c
+++ b/src/stackwalk.c
@@ -260,21 +260,21 @@ JL_DLLEXPORT jl_value_t *jl_backtrace_from_here(int returnsp, int skip)
             uintptr_t *sp_ptr = NULL;
             if (returnsp) {
                 jl_array_grow_end(sp, maxincr);
-                sp_ptr = (uintptr_t*)jl_array_data(sp) + offset;
+                sp_ptr = jl_array_data(sp, uintptr_t) + offset;
             }
             size_t size_incr = 0;
-            have_more_frames = jl_unw_stepn(&cursor, (jl_bt_element_t*)jl_array_data(ip) + offset,
+            have_more_frames = jl_unw_stepn(&cursor, jl_array_data(ip, jl_bt_element_t) + offset,
                                             &size_incr, sp_ptr, maxincr, skip, &pgcstack, 0);
             skip = 0;
             offset += size_incr;
         }
-        jl_array_del_end(ip, jl_array_len(ip) - offset);
+        jl_array_del_end(ip, jl_array_nrows(ip) - offset);
         if (returnsp)
-            jl_array_del_end(sp, jl_array_len(sp) - offset);
+            jl_array_del_end(sp, jl_array_nrows(sp) - offset);
 
         size_t n = 0;
-        jl_bt_element_t *bt_data = (jl_bt_element_t*)jl_array_data(ip);
-        while (n < jl_array_len(ip)) {
+        jl_bt_element_t *bt_data = jl_array_data(ip, jl_bt_element_t);
+        while (n < jl_array_nrows(ip)) {
             jl_bt_element_t *bt_entry = bt_data + n;
             if (!jl_bt_is_native(bt_entry)) {
                 size_t njlvals = jl_bt_num_jlvals(bt_entry);
@@ -303,7 +303,7 @@ static void decode_backtrace(jl_bt_element_t *bt_data, size_t bt_size,
     bt = *btout = jl_alloc_array_1d(array_ptr_void_type, bt_size);
     static_assert(sizeof(jl_bt_element_t) == sizeof(void*),
                   "jl_bt_element_t is presented as Ptr{Cvoid} on julia side");
-    memcpy(bt->data, bt_data, bt_size * sizeof(jl_bt_element_t));
+    memcpy(jl_array_data(bt, jl_bt_element_t), bt_data, bt_size * sizeof(jl_bt_element_t));
     bt2 = *bt2out = jl_alloc_array_1d(jl_array_any_type, 0);
     // Scan the backtrace buffer for any gc-managed values
     for (size_t i = 0; i < bt_size; i += jl_bt_entry_size(bt_data + i)) {
@@ -669,7 +669,7 @@ void jl_print_bt_entry_codeloc(jl_bt_element_t *bt_entry) JL_NOTSAFEPOINT
             jl_code_info_t *src = (jl_code_info_t*)code;
             // See also the debug info handling in codegen.cpp.
             // NB: debuginfoloc is 1-based!
-            intptr_t debuginfoloc = ((int32_t*)jl_array_data(src->codelocs))[ip];
+            intptr_t debuginfoloc = jl_array_data(src->codelocs, int32_t)[ip];
             while (debuginfoloc != 0) {
                 jl_line_info_node_t *locinfo = (jl_line_info_node_t*)
                     jl_array_ptr_ref(src->linetable, debuginfoloc - 1);
diff --git a/src/staticdata.c b/src/staticdata.c
index 69226408f711b..a77e0774a9441 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -99,7 +99,7 @@ extern "C" {
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
-#define NUM_TAGS    160
+#define NUM_TAGS    173
 
 // An array of references that need to be restored from the sysimg
 // This is a manually constructed dual of the gvars array, which would be produced by codegen for Julia code, for C.
@@ -199,6 +199,15 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_number_type);
         INSERT_TAG(jl_signed_type);
         INSERT_TAG(jl_pair_type);
+        INSERT_TAG(jl_genericmemory_type);
+        INSERT_TAG(jl_memory_any_type);
+        INSERT_TAG(jl_memory_uint8_type);
+        INSERT_TAG(jl_genericmemoryref_type);
+        INSERT_TAG(jl_memoryref_any_type);
+        INSERT_TAG(jl_memoryref_uint8_type);
+        INSERT_TAG(jl_addrspace_type);
+        INSERT_TAG(jl_addrspace_typename);
+        INSERT_TAG(jl_addrspacecore_type);
 
         // special typenames
         INSERT_TAG(jl_tuple_typename);
@@ -209,6 +218,8 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_namedtuple_typename);
         INSERT_TAG(jl_vecelement_typename);
         INSERT_TAG(jl_opaque_closure_typename);
+        INSERT_TAG(jl_genericmemory_typename);
+        INSERT_TAG(jl_genericmemoryref_typename);
 
         // special exceptions
         INSERT_TAG(jl_errorexception_type);
@@ -234,6 +245,7 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_true);
         INSERT_TAG(jl_an_empty_string);
         INSERT_TAG(jl_an_empty_vec_any);
+        INSERT_TAG(jl_an_empty_memory_any);
         INSERT_TAG(jl_module_init_order);
         INSERT_TAG(jl_core_module);
         INSERT_TAG(jl_base_module);
@@ -265,10 +277,11 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_builtin_modifyfield);
         INSERT_TAG(jl_builtin_replacefield);
         INSERT_TAG(jl_builtin_fieldtype);
-        INSERT_TAG(jl_builtin_arrayref);
-        INSERT_TAG(jl_builtin_const_arrayref);
-        INSERT_TAG(jl_builtin_arrayset);
-        INSERT_TAG(jl_builtin_arraysize);
+        INSERT_TAG(jl_builtin_memoryref);
+        INSERT_TAG(jl_builtin_memoryrefoffset);
+        INSERT_TAG(jl_builtin_memoryrefget);
+        INSERT_TAG(jl_builtin_memoryrefset);
+        INSERT_TAG(jl_builtin_memoryref_isassigned);
         INSERT_TAG(jl_builtin_apply_type);
         INSERT_TAG(jl_builtin_applicable);
         INSERT_TAG(jl_builtin_invoke);
@@ -445,8 +458,8 @@ static const jl_fptr_args_t id_to_fptrs[] = {
     &jl_f__call_latest, &jl_f__call_in_world, &jl_f__call_in_world_total, &jl_f_isdefined,
     &jl_f_tuple, &jl_f_svec, &jl_f_intrinsic_call,
     &jl_f_getfield, &jl_f_setfield, &jl_f_swapfield, &jl_f_modifyfield,
-    &jl_f_replacefield, &jl_f_fieldtype, &jl_f_nfields,
-    &jl_f_arrayref, &jl_f_const_arrayref, &jl_f_arrayset, &jl_f_arraysize, &jl_f_apply_type,
+    &jl_f_replacefield, &jl_f_fieldtype, &jl_f_nfields, &jl_f_apply_type,
+    &jl_f_memoryref, &jl_f_memoryrefoffset, &jl_f_memoryrefget, &jl_f_memoryrefset, &jl_f_memoryref_isassigned,
     &jl_f_applicable, &jl_f_invoke, &jl_f_sizeof, &jl_f__expr, &jl_f__typevar,
     &jl_f_ifelse, &jl_f__structtype, &jl_f__abstracttype, &jl_f__primitivetype,
     &jl_f__typebody, &jl_f__setsuper, &jl_f__equiv_typedef, &jl_f_get_binding_type,
@@ -461,6 +474,8 @@ typedef struct {
     ios_t *relocs;              // for (de)serializing relocs_list and gctags_list
     ios_t *gvar_record;         // serialized array mapping gvid => spos
     ios_t *fptr_record;         // serialized array mapping fptrid => spos
+    arraylist_t memowner_list;  // a list of memory locations that have shared owners
+    arraylist_t memref_list;    // a list of memoryref locations
     arraylist_t relocs_list;    // a list of (location, target) pairs, see description at top
     arraylist_t gctags_list;    //      "
     arraylist_t uniquing_types; // a list of locations that reference types that must be de-duplicated
@@ -748,9 +763,8 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
         jl_queue_for_serialization_(s, (jl_value_t*)dt->super, 1, 1);
         // ensure all type parameters are recached
         jl_queue_for_serialization_(s, (jl_value_t*)dt->parameters, 1, 1);
-        jl_value_t *singleton = dt->instance;
-        if (singleton && needs_uniquing(singleton)) {
-            assert(jl_needs_serialization(s, singleton)); // should be true, since we visited dt
+        if (jl_is_datatype_singleton(dt) && needs_uniquing(dt->instance)) {
+            assert(jl_needs_serialization(s, dt->instance)); // should be true, since we visited dt
             // do not visit dt->instance for our template object as it leads to unwanted cycles here
             // (it may get serialized from elsewhere though)
             record_field_change(&dt->instance, jl_nothing);
@@ -829,22 +843,29 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
     }
     else if (jl_is_array(v)) {
         jl_array_t *ar = (jl_array_t*)v;
-        const char *data = (const char*)jl_array_data(ar);
-        if (ar->flags.ptrarray) {
-            size_t i, l = jl_array_len(ar);
+        jl_value_t *mem = get_replaceable_field((jl_value_t**)&ar->ref.mem, 1);
+        jl_queue_for_serialization_(s, mem, 1, immediate);
+    }
+    else if (jl_is_genericmemory(v)) {
+        jl_genericmemory_t *m = (jl_genericmemory_t*)v;
+        const char *data = (const char*)m->ptr;
+        if (jl_genericmemory_how(m) == 3) {
+            jl_queue_for_serialization_(s, jl_genericmemory_data_owner_field(v), 1, immediate);
+        }
+        else if (layout->flags.arrayelem_isboxed) {
+            size_t i, l = m->length;
             for (i = 0; i < l; i++) {
                 jl_value_t *fld = get_replaceable_field(&((jl_value_t**)data)[i], 1);
                 jl_queue_for_serialization_(s, fld, 1, immediate);
             }
         }
-        else if (ar->flags.hasptr) {
-            uint16_t elsz = ar->elsize;
-            size_t i, l = jl_array_len(ar);
-            jl_datatype_t *et = (jl_datatype_t*)jl_tparam0(jl_typeof(ar));
-            size_t j, np = et->layout->npointers;
+        else if (layout->first_ptr >= 0) {
+            uint16_t elsz = layout->size;
+            size_t i, l = m->length;
+            size_t j, np = layout->npointers;
             for (i = 0; i < l; i++) {
                 for (j = 0; j < np; j++) {
-                    uint32_t ptr = jl_ptr_offset(et, j);
+                    uint32_t ptr = jl_ptr_offset(t, j);
                     jl_value_t *fld = get_replaceable_field(&((jl_value_t**)data)[ptr], 1);
                     jl_queue_for_serialization_(s, fld, 1, immediate);
                 }
@@ -995,8 +1016,8 @@ static uintptr_t add_external_linkage(jl_serializer_state *s, jl_value_t *v, jl_
         size_t offset = (uintptr_t)v - (uintptr_t)jl_linkage_blobs.items[2*i];
         offset /= sizeof(void*);
         assert(offset < ((uintptr_t)1 << DEPS_IDX_OFFSET) && "offset to external image too large");
-        assert(n_linkage_blobs() == jl_array_len(s->buildid_depmods_idxs));
-        size_t depsidx = ((uint32_t*)jl_array_data(s->buildid_depmods_idxs))[i]; // map from build_id_idx -> deps_idx
+        assert(n_linkage_blobs() == jl_array_nrows(s->buildid_depmods_idxs));
+        size_t depsidx = jl_array_data(s->buildid_depmods_idxs, uint32_t)[i]; // map from build_id_idx -> deps_idx
         assert(depsidx < INT32_MAX);
         if (depsidx < ((uintptr_t)1 << (RELOC_TAG_OFFSET - DEPS_IDX_OFFSET)) && offset < ((uintptr_t)1 << DEPS_IDX_OFFSET))
             // if it fits in a SysimageLinkage type, use that representation
@@ -1004,8 +1025,8 @@ static uintptr_t add_external_linkage(jl_serializer_state *s, jl_value_t *v, jl_
         // otherwise, we store the image key in `link_ids`
         assert(link_ids && jl_is_array(link_ids));
         jl_array_grow_end(link_ids, 1);
-        uint32_t *link_id_data  = (uint32_t*)jl_array_data(link_ids);  // wait until after the `grow`
-        link_id_data[jl_array_len(link_ids) - 1] = depsidx;
+        uint32_t *link_id_data  = jl_array_data(link_ids, uint32_t);  // wait until after the `grow`
+        link_id_data[jl_array_nrows(link_ids) - 1] = depsidx;
         return ((uintptr_t)ExternalLinkage << RELOC_TAG_OFFSET) + offset;
     }
     return 0;
@@ -1159,6 +1180,36 @@ static void jl_write_module(jl_serializer_state *s, uintptr_t item, jl_module_t
     assert(ios_pos(s->s) - reloc_offset == tot);
 }
 
+static void record_memoryref(jl_serializer_state *s, size_t reloc_offset, jl_genericmemoryref_t ref) {
+    ios_t *f = s->s;
+    // make some header modifications in-place
+    jl_genericmemoryref_t *newref = (jl_genericmemoryref_t*)&f->buf[reloc_offset];
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(ref.mem))->layout;
+    if (!layout->flags.arrayelem_isunion && layout->size != 0) {
+        newref->ptr_or_offset = (void*)((char*)ref.ptr_or_offset - (char*)ref.mem->ptr); // relocation offset (bytes)
+        arraylist_push(&s->memref_list, (void*)reloc_offset); // relocation location
+        arraylist_push(&s->memref_list, NULL); // relocation target (ignored)
+    }
+}
+
+static void record_memoryrefs_inside(jl_serializer_state *s, jl_datatype_t *t, size_t reloc_offset, const char *data)
+{
+    assert(jl_is_datatype(t));
+    size_t i, nf = jl_datatype_nfields(t);
+    for (i = 0; i < nf; i++) {
+        size_t offset = jl_field_offset(t, i);
+        if (jl_field_isptr(t, i))
+            continue;
+        jl_value_t *ft = jl_field_type_concrete(t, i);
+        if (jl_is_uniontype(ft))
+            continue;
+        if (jl_is_genericmemoryref_type(ft))
+            record_memoryref(s, reloc_offset + offset, *(jl_genericmemoryref_t*)(data + offset));
+        else
+            record_memoryrefs_inside(s, (jl_datatype_t*)ft, reloc_offset + offset, data + offset);
+    }
+}
+
 static void record_gvars(jl_serializer_state *s, arraylist_t *globals) JL_NOTSAFEPOINT
 {
     for (size_t i = 0; i < globals->len; i++)
@@ -1201,7 +1252,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
         JL_GC_PROMISE_ROOTED(v);
         assert(!(s->incremental && jl_object_in_image(v)));
         jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v);
-        assert((t->instance == NULL || t->instance == v) && "detected singleton construction corruption");
+        assert((!jl_is_datatype_singleton(t) || t->instance == v) && "detected singleton construction corruption");
         ios_t *f = s->s;
         if (t->smalltag) {
             if (t->layout->npointers == 0 || t == jl_string_type) {
@@ -1260,102 +1311,135 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
         if (jl_is_array(v)) {
             assert(f == s->s);
             // Internal data for types in julia.h with `jl_array_t` field(s)
-#define JL_ARRAY_ALIGN(jl_value, nbytes) LLT_ALIGN(jl_value, nbytes)
             jl_array_t *ar = (jl_array_t*)v;
-            jl_value_t *et = jl_tparam0(jl_typeof(v));
-            size_t alen = jl_array_len(ar);
-            size_t datasize = alen * ar->elsize;
-            size_t tot = datasize;
-            int isbitsunion = jl_array_isbitsunion(ar);
-            if (isbitsunion)
-                tot += alen;
-            else if (ar->elsize == 1)
-                tot += 1;
-            int ndimwords = jl_array_ndimwords(ar->flags.ndims);
-            size_t headersize = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
             // copy header
+            size_t headersize = sizeof(jl_array_t) + jl_array_ndims(ar)*sizeof(size_t);
             ios_write(f, (char*)v, headersize);
-            size_t alignment_amt = JL_SMALL_BYTE_ALIGNMENT;
-            if (tot >= ARRAY_CACHE_ALIGN_THRESHOLD)
-                alignment_amt = JL_CACHE_BYTE_ALIGNMENT;
             // make some header modifications in-place
             jl_array_t *newa = (jl_array_t*)&f->buf[reloc_offset];
-            if (newa->flags.ndims == 1)
-                newa->maxsize = alen;
-            newa->offset = 0;
-            newa->flags.how = 0;
-            newa->flags.pooled = 0;
-            newa->flags.isshared = 0;
-
-            // write data
-            if (!ar->flags.ptrarray && !ar->flags.hasptr) {
-                // Non-pointer eltypes get encoded in the const_data section
-                uintptr_t data = LLT_ALIGN(ios_pos(s->const_data), alignment_amt);
-                write_padding(s->const_data, data - ios_pos(s->const_data));
-                // write data and relocations
-                newa->data = NULL; // relocation offset
-                data /= sizeof(void*);
-                assert(data < ((uintptr_t)1 << RELOC_TAG_OFFSET) && "offset to constant data too large");
-                arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_array_t, data))); // relocation location
-                arraylist_push(&s->relocs_list, (void*)(((uintptr_t)ConstDataRef << RELOC_TAG_OFFSET) + data)); // relocation target
-                if (jl_is_cpointer_type(et)) {
-                    // reset Ptr fields to C_NULL (but keep MAP_FAILED / INVALID_HANDLE)
-                    const intptr_t *data = (const intptr_t*)jl_array_data(ar);
-                    size_t i;
-                    for (i = 0; i < alen; i++) {
-                        if (data[i] != -1)
-                            write_pointer(s->const_data);
-                        else
-                            ios_write(s->const_data, (char*)&data[i], sizeof(data[i]));
-                    }
-                }
-                else {
-                    if (isbitsunion) {
-                        ios_write(s->const_data, (char*)jl_array_data(ar), datasize);
-                        ios_write(s->const_data, jl_array_typetagdata(ar), alen);
+            newa->ref.mem = NULL; // relocation offset
+            arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_array_t, ref.mem))); // relocation location
+            jl_value_t *mem = get_replaceable_field((jl_value_t**)&ar->ref.mem, 1);
+            arraylist_push(&s->relocs_list, (void*)backref_id(s, mem, s->link_ids_relocs)); // relocation target
+            record_memoryref(s, reloc_offset + offsetof(jl_array_t, ref), ar->ref);
+        }
+        else if (jl_is_genericmemory(v)) {
+            assert(f == s->s);
+            // Internal data for types in julia.h with `jl_genericmemory_t` field(s)
+            jl_genericmemory_t *m = (jl_genericmemory_t*)v;
+            const jl_datatype_layout_t *layout = t->layout;
+            size_t len = m->length;
+            if (jl_genericmemory_how(m) == 3 && jl_is_genericmemory(jl_genericmemory_data_owner_field(m))) {
+                jl_genericmemory_t *owner = (jl_genericmemory_t*)jl_genericmemory_data_owner_field(m);
+                size_t data = ((char*)m->ptr - (char*)owner->ptr); // relocation offset (bytes)
+                write_uint(f, len);
+                write_uint(f, data);
+                write_pointerfield(s, (jl_value_t*)owner);
+                // similar to record_memoryref, but the field is always an (offset) pointer
+                arraylist_push(&s->memowner_list, (void*)(reloc_offset + offsetof(jl_genericmemory_t, ptr))); // relocation location
+                arraylist_push(&s->memowner_list, NULL); // relocation target (ignored)
+            }
+            // else if (jl_genericmemory_how(m) == 3) {
+            //     jl_value_t *owner = jl_genericmemory_data_owner_field(m);
+            //     write_uint(f, len);
+            //     write_pointerfield(s, owner);
+            //     write_pointerfield(s, owner);
+            //     jl_genericmemory_t *new_mem = (jl_genericmemory_t*)&f->buf[reloc_offset];
+            //     assert(new_mem->ptr == NULL);
+            //     new_mem->ptr = (void*)((char*)m->ptr - (char*)owner); // relocation offset
+            // }
+            else {
+                size_t datasize = len * layout->size;
+                size_t tot = datasize;
+                int isbitsunion = layout->flags.arrayelem_isunion;
+                if (isbitsunion)
+                    tot += len;
+                size_t headersize = sizeof(jl_genericmemory_t);
+                // copy header
+                ios_write(f, (char*)v, headersize);
+                // write data
+                if (!layout->flags.arrayelem_isboxed && layout->first_ptr < 0) {
+                    // set owner to NULL
+                    headersize += sizeof(void*);
+                    write_pointer(f);
+                    // Non-pointer eltypes get encoded in the const_data section
+                    size_t alignment_amt = JL_SMALL_BYTE_ALIGNMENT;
+                    if (tot >= ARRAY_CACHE_ALIGN_THRESHOLD)
+                        alignment_amt = JL_CACHE_BYTE_ALIGNMENT;
+                    uintptr_t data = LLT_ALIGN(ios_pos(s->const_data), alignment_amt);
+                    write_padding(s->const_data, data - ios_pos(s->const_data));
+                    // write data and relocations
+                    jl_genericmemory_t *new_mem = (jl_genericmemory_t*)&f->buf[reloc_offset];
+                    new_mem->ptr = NULL; // relocation offset
+                    data /= sizeof(void*);
+                    assert(data < ((uintptr_t)1 << RELOC_TAG_OFFSET) && "offset to constant data too large");
+                    arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_genericmemory_t, ptr))); // relocation location
+                    arraylist_push(&s->relocs_list, (void*)(((uintptr_t)ConstDataRef << RELOC_TAG_OFFSET) + data)); // relocation target
+                    jl_value_t *et = jl_tparam1(t);
+                    if (jl_is_cpointer_type(et)) {
+                        // reset Ptr fields to C_NULL (but keep MAP_FAILED / INVALID_HANDLE)
+                        const intptr_t *data = (const intptr_t*)m->ptr;
+                        size_t i;
+                        for (i = 0; i < len; i++) {
+                            if (data[i] != -1)
+                                write_pointer(s->const_data);
+                            else
+                                ios_write(s->const_data, (char*)&data[i], sizeof(data[i]));
+                        }
                     }
                     else {
-                        ios_write(s->const_data, (char*)jl_array_data(ar), tot);
+                        if (isbitsunion) {
+                            ios_write(s->const_data, (char*)m->ptr, datasize);
+                            ios_write(s->const_data, jl_genericmemory_typetagdata(m), len);
+                        }
+                        else {
+                            ios_write(s->const_data, (char*)m->ptr, tot);
+                        }
                     }
+                    if (len == 0) // TODO: should we have a zero-page, instead of writing each type's fragment separately?
+                        write_padding(s->const_data, layout->size ? layout->size : isbitsunion);
+                    else if (jl_genericmemory_how(m) == 3 && jl_is_string(jl_genericmemory_data_owner_field(m)))
+                        write_padding(s->const_data, 1);
                 }
-            }
-            else {
-                // Pointer eltypes are encoded in the mutable data section
-                size_t data = LLT_ALIGN(ios_pos(f), alignment_amt);
-                size_t padding_amt = data - ios_pos(f);
-                headersize += padding_amt;
-                newa->data = (void*)headersize; // relocation offset
-                arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_array_t, data))); // relocation location
-                arraylist_push(&s->relocs_list, (void*)(((uintptr_t)DataRef << RELOC_TAG_OFFSET) + item)); // relocation target
-                write_padding(f, padding_amt);
-                if (ar->flags.hasptr) {
-                    // copy all of the data first
-                    const char *data = (const char*)jl_array_data(ar);
-                    ios_write(f, data, datasize);
-                    // the rewrite all of the embedded pointers to null+relocation
-                    uint16_t elsz = ar->elsize;
-                    size_t j, np = ((jl_datatype_t*)et)->layout->npointers;
-                    size_t i;
-                    for (i = 0; i < alen; i++) {
-                        for (j = 0; j < np; j++) {
-                            size_t offset = i * elsz + jl_ptr_offset(((jl_datatype_t*)et), j) * sizeof(jl_value_t*);
-                            jl_value_t *fld = get_replaceable_field((jl_value_t**)&data[offset], 1);
-                            size_t fld_pos = reloc_offset + headersize + offset;
-                            if (fld != NULL) {
-                                arraylist_push(&s->relocs_list, (void*)(uintptr_t)fld_pos); // relocation location
-                                arraylist_push(&s->relocs_list, (void*)backref_id(s, fld, s->link_ids_relocs)); // relocation target
-                                record_uniquing(s, fld, fld_pos);
+                else {
+                    // Pointer eltypes are encoded in the mutable data section
+                    headersize = LLT_ALIGN(headersize, JL_SMALL_BYTE_ALIGNMENT);
+                    size_t data = LLT_ALIGN(ios_pos(f), JL_SMALL_BYTE_ALIGNMENT);
+                    write_padding(f, data - ios_pos(f));
+                    assert(reloc_offset + headersize == ios_pos(f));
+                    jl_genericmemory_t *new_mem = (jl_genericmemory_t*)&f->buf[reloc_offset];
+                    new_mem->ptr = (void*)headersize; // relocation offset
+                    arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_genericmemory_t, ptr))); // relocation location
+                    arraylist_push(&s->relocs_list, (void*)(((uintptr_t)DataRef << RELOC_TAG_OFFSET) + item)); // relocation target
+                    if (!layout->flags.arrayelem_isboxed) {
+                        // copy all of the data first
+                        const char *data = (const char*)m->ptr;
+                        ios_write(f, data, datasize);
+                        // the rewrite all of the embedded pointers to null+relocation
+                        uint16_t elsz = layout->size;
+                        size_t j, np = layout->first_ptr < 0 ? 0 : layout->npointers;
+                        size_t i;
+                        for (i = 0; i < len; i++) {
+                            for (j = 0; j < np; j++) {
+                                size_t offset = i * elsz + jl_ptr_offset(t, j) * sizeof(jl_value_t*);
+                                jl_value_t *fld = get_replaceable_field((jl_value_t**)&data[offset], 1);
+                                size_t fld_pos = reloc_offset + headersize + offset;
+                                if (fld != NULL) {
+                                    arraylist_push(&s->relocs_list, (void*)(uintptr_t)fld_pos); // relocation location
+                                    arraylist_push(&s->relocs_list, (void*)backref_id(s, fld, s->link_ids_relocs)); // relocation target
+                                    record_uniquing(s, fld, fld_pos);
+                                }
+                                memset(&f->buf[fld_pos], 0, sizeof(fld)); // relocation offset (none)
                             }
-                            memset(&f->buf[fld_pos], 0, sizeof(fld)); // relocation offset (none)
                         }
                     }
-                }
-                else {
-                    jl_value_t **data = (jl_value_t**)jl_array_data(ar);
-                    size_t i;
-                    for (i = 0; i < alen; i++) {
-                        jl_value_t *e = get_replaceable_field(&data[i], 1);
-                        write_pointerfield(s, e);
+                    else {
+                        jl_value_t **data = (jl_value_t**)m->ptr;
+                        size_t i;
+                        for (i = 0; i < len; i++) {
+                            jl_value_t *e = get_replaceable_field(&data[i], 1);
+                            write_pointerfield(s, e);
+                        }
                     }
                 }
             }
@@ -1385,7 +1469,6 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
         }
         else if (jl_datatype_nfields(t) == 0) {
             // The object has no fields, so we just snapshot its byte representation
-            assert(!t->layout->npointers);
             assert(t->layout->npointers == 0);
             ios_write(f, (char*)v, jl_datatype_size(t));
         }
@@ -1419,7 +1502,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 write_padding(f, offset - tot);
                 tot = offset;
                 size_t fsz = jl_field_size(t, i);
-                if (t->name->mutabl && jl_is_cpointer_type(jl_field_type(t, i)) && *(intptr_t*)slot != -1) {
+                if (t->name->mutabl && jl_is_cpointer_type(jl_field_type_concrete(t, i)) && *(intptr_t*)slot != -1) {
                     // reset Ptr fields to C_NULL (but keep MAP_FAILED / INVALID_HANDLE)
                     assert(!jl_field_isptr(t, i));
                     write_pointer(f);
@@ -1446,8 +1529,10 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 memset(&f->buf[fld_pos], 0, sizeof(fld)); // relocation offset (none)
             }
 
-            // A few objects need additional handling beyond the generic serialization above
+            // Need do a tricky fieldtype walk an record all memoryref we find inlined in this value
+            record_memoryrefs_inside(s, t, reloc_offset, data);
 
+            // A few objects need additional handling beyond the generic serialization above
             if (s->incremental && jl_typetagis(v, jl_typemap_entry_type)) {
                 assert(f == s->s);
                 jl_typemap_entry_t *newentry = (jl_typemap_entry_t*)&s->s->buf[reloc_offset];
@@ -1578,14 +1663,14 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                     size_t nf = dt->layout->nfields;
                     size_t np = dt->layout->npointers;
                     size_t fieldsize = 0;
-                    uint8_t is_foreign_type = dt->layout->fielddesc_type == 3;
+                    uint8_t is_foreign_type = dt->layout->flags.fielddesc_type == 3;
                     if (!is_foreign_type) {
-                        fieldsize = jl_fielddesc_size(dt->layout->fielddesc_type);
+                        fieldsize = jl_fielddesc_size(dt->layout->flags.fielddesc_type);
                     }
                     char *flddesc = (char*)dt->layout;
                     size_t fldsize = sizeof(jl_datatype_layout_t) + nf * fieldsize;
                     if (!is_foreign_type && dt->layout->first_ptr != -1)
-                        fldsize += np << dt->layout->fielddesc_type;
+                        fldsize += np << dt->layout->flags.fielddesc_type;
                     uintptr_t layout = LLT_ALIGN(ios_pos(s->const_data), sizeof(void*));
                     write_padding(s->const_data, layout - ios_pos(s->const_data)); // realign stream
                     newdt->layout = NULL; // relocation offset
@@ -1640,6 +1725,10 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 // will need to rehash this, later (after types are fully constructed)
                 arraylist_push(&s->fixup_objs, (void*)reloc_offset);
             }
+            else if (jl_is_genericmemoryref(v)) {
+                assert(f == s->s);
+                record_memoryref(s, reloc_offset, *(jl_genericmemoryref_t*)v);
+            }
             else {
                 write_padding(f, jl_datatype_size(t) - tot);
             }
@@ -1791,7 +1880,7 @@ static inline uintptr_t get_item_for_reloc(jl_serializer_state *s, uintptr_t bas
         size_t depsidx = 0;
 #endif
         assert(s->buildid_depmods_idxs && depsidx < jl_array_len(s->buildid_depmods_idxs));
-        size_t i = ((uint32_t*)jl_array_data(s->buildid_depmods_idxs))[depsidx];
+        size_t i = jl_array_data(s->buildid_depmods_idxs, uint32_t)[depsidx];
         assert(2*i < jl_linkage_blobs.len);
         return (uintptr_t)jl_linkage_blobs.items[2*i] + offset*sizeof(void*);
     }
@@ -1799,10 +1888,10 @@ static inline uintptr_t get_item_for_reloc(jl_serializer_state *s, uintptr_t bas
         assert(link_ids);
         assert(link_index);
         assert(0 <= *link_index && *link_index < jl_array_len(link_ids));
-        uint32_t depsidx = ((uint32_t*)jl_array_data(link_ids))[*link_index];
+        uint32_t depsidx = jl_array_data(link_ids, uint32_t)[*link_index];
         *link_index += 1;
         assert(depsidx < jl_array_len(s->buildid_depmods_idxs));
-        size_t i = ((uint32_t*)jl_array_data(s->buildid_depmods_idxs))[depsidx];
+        size_t i = jl_array_data(s->buildid_depmods_idxs, uint32_t)[depsidx];
         assert(2*i < jl_linkage_blobs.len);
         return (uintptr_t)jl_linkage_blobs.items[2*i] + offset*sizeof(void*);
     }
@@ -1891,6 +1980,37 @@ static void jl_read_reloclist(jl_serializer_state *s, jl_array_t *link_ids, uint
     assert(!link_ids || link_index == jl_array_len(link_ids));
 }
 
+static void jl_read_memreflist(jl_serializer_state *s)
+{
+    uintptr_t base = (uintptr_t)s->s->buf;
+    uintptr_t last_pos = 0;
+    uint8_t *current = (uint8_t *)(s->relocs->buf + s->relocs->bpos);
+    while (1) {
+        // Read the offset of the next object
+        size_t pos_diff = 0;
+        size_t cnt = 0;
+        while (1) {
+            assert(s->relocs->bpos <= s->relocs->size);
+            assert((char *)current <= (char *)(s->relocs->buf + s->relocs->size));
+            int8_t c = *current++;
+            s->relocs->bpos += 1;
+
+            pos_diff |= ((size_t)c & 0x7F) << (7 * cnt++);
+            if ((c >> 7) == 0)
+                break;
+        }
+        if (pos_diff == 0)
+            break;
+
+        uintptr_t pos = last_pos + pos_diff;
+        last_pos = pos;
+        jl_genericmemoryref_t *pv = (jl_genericmemoryref_t*)(base + pos);
+        size_t offset = (size_t)pv->ptr_or_offset;
+        pv->ptr_or_offset = (void*)((char*)pv->mem->ptr + offset);
+    }
+}
+
+
 static void jl_read_arraylist(ios_t *s, arraylist_t *list)
 {
     size_t list_len = read_uint(s);
@@ -2188,7 +2308,7 @@ static jl_value_t *strip_codeinfo_meta(jl_method_t *m, jl_value_t *ci_, int orig
         ci = (jl_code_info_t*)ci_;
     }
     // leave codelocs length the same so the compiler can assume that; just zero it
-    memset(jl_array_data(ci->codelocs), 0, jl_array_len(ci->codelocs)*sizeof(int32_t));
+    memset(jl_array_data(ci->codelocs, int32_t), 0, jl_array_len(ci->codelocs)*sizeof(int32_t));
     // empty linetable
     if (jl_is_array(ci->linetable))
         jl_array_del_end((jl_array_t*)ci->linetable, jl_array_len(ci->linetable));
@@ -2298,7 +2418,7 @@ static void jl_strip_all_codeinfos(void)
 
 // --- entry points ---
 
-jl_array_t *jl_global_roots_table;
+jl_genericmemory_t *jl_global_roots_table;
 jl_mutex_t global_roots_lock;
 
 JL_DLLEXPORT int jl_is_globally_rooted(jl_value_t *val JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT
@@ -2359,7 +2479,7 @@ static void jl_prepare_serialization_data(jl_array_t *mod_array, jl_array_t *new
     // Collect method extensions and edges data
     JL_GC_PUSH1(&edges_map);
     if (edges)
-        edges_map = jl_alloc_vec_any(0);
+        edges_map = jl_alloc_memory_any(0);
     *extext_methods = jl_alloc_vec_any(0);
     jl_collect_methtable_from_mod(jl_type_type_mt, *extext_methods);
     jl_collect_methtable_from_mod(jl_nonfunction_mt, *extext_methods);
@@ -2429,6 +2549,8 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     s.gvar_record = &gvar_record;
     s.fptr_record = &fptr_record;
     s.ptls = jl_current_task->ptls;
+    arraylist_new(&s.memowner_list, 0);
+    arraylist_new(&s.memref_list, 0);
     arraylist_new(&s.relocs_list, 0);
     arraylist_new(&s.gctags_list, 0);
     arraylist_new(&s.uniquing_types, 0);
@@ -2592,6 +2714,8 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     jl_finish_relocs(base + sysimg_offset, sysimg_size, &s.relocs_list);
     jl_write_offsetlist(s.relocs, sysimg_size, &s.gctags_list);
     jl_write_offsetlist(s.relocs, sysimg_size, &s.relocs_list);
+    jl_write_offsetlist(s.relocs, sysimg_size, &s.memowner_list);
+    jl_write_offsetlist(s.relocs, sysimg_size, &s.memref_list);
     if (s.incremental) {
         jl_write_arraylist(s.relocs, &s.uniquing_types);
         jl_write_arraylist(s.relocs, &s.uniquing_objs);
@@ -2649,13 +2773,13 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
             jl_write_value(&s, edges);
         }
         write_uint32(f, jl_array_len(s.link_ids_gctags));
-        ios_write(f, (char*)jl_array_data(s.link_ids_gctags), jl_array_len(s.link_ids_gctags) * sizeof(uint32_t));
+        ios_write(f, (char*)jl_array_data(s.link_ids_gctags, uint32_t), jl_array_len(s.link_ids_gctags) * sizeof(uint32_t));
         write_uint32(f, jl_array_len(s.link_ids_relocs));
-        ios_write(f, (char*)jl_array_data(s.link_ids_relocs), jl_array_len(s.link_ids_relocs) * sizeof(uint32_t));
+        ios_write(f, (char*)jl_array_data(s.link_ids_relocs, uint32_t), jl_array_len(s.link_ids_relocs) * sizeof(uint32_t));
         write_uint32(f, jl_array_len(s.link_ids_gvars));
-        ios_write(f, (char*)jl_array_data(s.link_ids_gvars), jl_array_len(s.link_ids_gvars) * sizeof(uint32_t));
+        ios_write(f, (char*)jl_array_data(s.link_ids_gvars, uint32_t), jl_array_len(s.link_ids_gvars) * sizeof(uint32_t));
         write_uint32(f, jl_array_len(s.link_ids_external_fnvars));
-        ios_write(f, (char*)jl_array_data(s.link_ids_external_fnvars), jl_array_len(s.link_ids_external_fnvars) * sizeof(uint32_t));
+        ios_write(f, (char*)jl_array_data(s.link_ids_external_fnvars, uint32_t), jl_array_len(s.link_ids_external_fnvars) * sizeof(uint32_t));
         write_uint32(f, external_fns_begin);
         jl_write_arraylist(s.s, &s.ccallable_list);
     }
@@ -2665,6 +2789,8 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     arraylist_free(&serialization_queue);
     arraylist_free(&layout_table);
     arraylist_free(&s.ccallable_list);
+    arraylist_free(&s.memowner_list);
+    arraylist_free(&s.memref_list);
     arraylist_free(&s.relocs_list);
     arraylist_free(&s.gctags_list);
     arraylist_free(&gvars);
@@ -2934,7 +3060,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         JL_SMALL_TYPEOF(XX)
 #undef XX
         export_jl_small_typeof();
-        jl_global_roots_table = (jl_array_t*)jl_read_value(&s);
+        jl_global_roots_table = (jl_genericmemory_t*)jl_read_value(&s);
         // set typeof extra-special values now that we have the type set by tags above
         jl_astaggedvalue(jl_nothing)->header = (uintptr_t)jl_nothing_type | jl_astaggedvalue(jl_nothing)->header;
         s.ptls->root_task->tls = jl_read_value(&s);
@@ -2961,22 +3087,22 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     size_t nlinks_gctags = read_uint32(f);
     if (nlinks_gctags > 0) {
         s.link_ids_gctags = jl_alloc_array_1d(jl_array_int32_type, nlinks_gctags);
-        ios_read(f, (char*)jl_array_data(s.link_ids_gctags), nlinks_gctags * sizeof(uint32_t));
+        ios_read(f, (char*)jl_array_data(s.link_ids_gctags, uint32_t), nlinks_gctags * sizeof(uint32_t));
     }
     size_t nlinks_relocs = read_uint32(f);
     if (nlinks_relocs > 0) {
         s.link_ids_relocs = jl_alloc_array_1d(jl_array_int32_type, nlinks_relocs);
-        ios_read(f, (char*)jl_array_data(s.link_ids_relocs), nlinks_relocs * sizeof(uint32_t));
+        ios_read(f, (char*)jl_array_data(s.link_ids_relocs, uint32_t), nlinks_relocs * sizeof(uint32_t));
     }
     size_t nlinks_gvars = read_uint32(f);
     if (nlinks_gvars > 0) {
         s.link_ids_gvars = jl_alloc_array_1d(jl_array_int32_type, nlinks_gvars);
-        ios_read(f, (char*)jl_array_data(s.link_ids_gvars), nlinks_gvars * sizeof(uint32_t));
+        ios_read(f, (char*)jl_array_data(s.link_ids_gvars, uint32_t), nlinks_gvars * sizeof(uint32_t));
     }
     size_t nlinks_external_fnvars = read_uint32(f);
     if (nlinks_external_fnvars > 0) {
         s.link_ids_external_fnvars = jl_alloc_array_1d(jl_array_int32_type, nlinks_external_fnvars);
-        ios_read(f, (char*)jl_array_data(s.link_ids_external_fnvars), nlinks_external_fnvars * sizeof(uint32_t));
+        ios_read(f, (char*)jl_array_data(s.link_ids_external_fnvars, uint32_t), nlinks_external_fnvars * sizeof(uint32_t));
     }
     uint32_t external_fns_begin = read_uint32(f);
     jl_read_arraylist(s.s, ccallable_list ? ccallable_list : &s.ccallable_list);
@@ -3009,6 +3135,8 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     size_t sizeof_tags = ios_pos(&relocs);
     (void)sizeof_tags;
     jl_read_reloclist(&s, s.link_ids_relocs, 0); // general relocs
+    jl_read_memreflist(&s); // memowner_list relocs (must come before memref_list reads the pointers and after general relocs computes the pointers)
+    jl_read_memreflist(&s); // memref_list relocs
     // s.link_ids_gvars will be processed in `jl_update_all_gvars`
     // s.link_ids_external_fns will be processed in `jl_update_all_gvars`
     jl_update_all_gvars(&s, image, external_fns_begin); // gvars relocs
@@ -3094,8 +3222,9 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
                     // leave most fields undefined for now, but we may need instance later,
                     // and we overwrite the name field (field 0) now so preserve it too
                     if (dt->instance) {
-                        assert(dt->instance == jl_nothing);
-                        newdt->instance = dt->instance = jl_gc_permobj(0, newdt);
+                        if (dt->instance == jl_nothing)
+                            dt->instance = jl_gc_permobj(0, newdt);
+                        newdt->instance = dt->instance;
                     }
                     static_assert(offsetof(jl_datatype_t, name) == 0, "");
                     newdt->name = dt->name;
@@ -3110,9 +3239,8 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         }
         else {
             assert(!(image_base < (char*)otyp && (char*)otyp <= image_base + sizeof_sysimg));
-            assert(jl_is_datatype_singleton((jl_datatype_t*)otyp) && "unreachable");
             newobj = ((jl_datatype_t*)otyp)->instance;
-            assert(newobj != jl_nothing);
+            assert(newobj && newobj != jl_nothing);
             arraylist_push(&cleanup_list, (void*)obj);
         }
         if (tag)
@@ -3273,9 +3401,9 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         else {
             // rehash IdDict
             //assert(((jl_datatype_t*)(jl_typeof(obj)))->name == jl_idtable_typename);
-            jl_array_t **a = (jl_array_t**)obj;
-            assert(jl_typetagis(*a, jl_array_any_type));
-            *a = jl_idtable_rehash(*a, jl_array_len(*a));
+            jl_genericmemory_t **a = (jl_genericmemory_t**)obj;
+            assert(jl_typetagis(*a, jl_memory_any_type));
+            *a = jl_idtable_rehash(*a, (*a)->length);
             jl_gc_wb(obj, *a);
         }
     }
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index 047042795d128..1a8dd879c0983 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -1,5 +1,5 @@
 // inverse of backedges graph (caller=>callees hash)
-jl_array_t *edges_map JL_GLOBALLY_ROOTED = NULL; // rooted for the duration of our uses of this
+jl_genericmemory_t *edges_map JL_GLOBALLY_ROOTED = NULL; // rooted for the duration of our uses of this
 
 static void write_float64(ios_t *s, double x) JL_NOTSAFEPOINT
 {
@@ -74,7 +74,7 @@ int must_be_new_dt(jl_value_t *t, htable_t *news, char *image_base, size_t sizeo
 static uint64_t jl_worklist_key(jl_array_t *worklist) JL_NOTSAFEPOINT
 {
     assert(jl_is_array(worklist));
-    size_t len = jl_array_len(worklist);
+    size_t len = jl_array_nrows(worklist);
     if (len > 0) {
         jl_module_t *topmod = (jl_module_t*)jl_array_ptr_ref(worklist, len-1);
         assert(jl_is_module(topmod));
@@ -98,9 +98,9 @@ JL_DLLEXPORT void jl_set_newly_inferred(jl_value_t* _newly_inferred)
 JL_DLLEXPORT void jl_push_newly_inferred(jl_value_t* ci)
 {
     JL_LOCK(&newly_inferred_mutex);
-    size_t end = jl_array_len(newly_inferred);
+    size_t end = jl_array_nrows(newly_inferred);
     jl_array_grow_end(newly_inferred, 1);
-    jl_arrayset(newly_inferred, ci, end);
+    jl_array_ptr_set(newly_inferred, end, ci);
     JL_UNLOCK(&newly_inferred_mutex);
 }
 
@@ -177,7 +177,7 @@ static int has_backedge_to_worklist(jl_method_instance_t *mi, htable_t *visited,
     arraylist_push(stack, (void*)mi);
     int depth = stack->len;
     *bp = (void*)((char*)HT_NOTFOUND + 4 + depth); // preliminarily mark as in-progress
-    size_t i = 0, n = jl_array_len(mi->backedges);
+    size_t i = 0, n = jl_array_nrows(mi->backedges);
     int cycle = depth;
     while (i < n) {
         jl_method_instance_t *be;
@@ -222,7 +222,7 @@ static jl_array_t *queue_external_cis(jl_array_t *list)
     htable_t visited;
     arraylist_t stack;
     assert(jl_is_array(list));
-    size_t n0 = jl_array_len(list);
+    size_t n0 = jl_array_nrows(list);
     htable_new(&visited, n0);
     arraylist_new(&stack, 0);
     jl_array_t *new_specializations = jl_alloc_vec_any(0);
@@ -251,8 +251,8 @@ static jl_array_t *queue_external_cis(jl_array_t *list)
     arraylist_free(&stack);
     JL_GC_POP();
     // reverse new_specializations
-    n0 = jl_array_len(new_specializations);
-    jl_value_t **news = (jl_value_t**)jl_array_data(new_specializations);
+    n0 = jl_array_nrows(new_specializations);
+    jl_value_t **news = jl_array_data(new_specializations, jl_value_t*);
     for (i = 0; i < n0; i++) {
         jl_value_t *temp = news[i];
         news[i] = news[n0 - i - 1];
@@ -266,7 +266,7 @@ static void jl_collect_new_roots(jl_array_t *roots, jl_array_t *new_specializati
 {
     htable_t mset;
     htable_new(&mset, 0);
-    size_t l = new_specializations ? jl_array_len(new_specializations) : 0;
+    size_t l = new_specializations ? jl_array_nrows(new_specializations) : 0;
     for (size_t i = 0; i < l; i++) {
         jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(new_specializations, i);
         assert(jl_is_code_instance(ci));
@@ -289,10 +289,10 @@ static void jl_collect_new_roots(jl_array_t *roots, jl_array_t *new_specializati
                 jl_array_ptr_1d_push(roots, (jl_value_t*)newroots);
                 rle_iter_state rootiter = rle_iter_init(0);
                 uint64_t *rletable = NULL;
-                size_t nblocks2 = 0, nroots = jl_array_len(m->roots), k = 0;
+                size_t nblocks2 = 0, nroots = jl_array_nrows(m->roots), k = 0;
                 if (m->root_blocks) {
-                    rletable = (uint64_t*)jl_array_data(m->root_blocks);
-                    nblocks2 = jl_array_len(m->root_blocks);
+                    rletable = jl_array_data(m->root_blocks, uint64_t);
+                    nblocks2 = jl_array_nrows(m->root_blocks);
                 }
                 while (rle_iter_increment(&rootiter, nroots, rletable, nblocks2))
                     if (rootiter.key == key)
@@ -314,7 +314,7 @@ static void jl_collect_missing_backedges(jl_methtable_t *mt)
 {
     jl_array_t *backedges = mt->backedges;
     if (backedges) {
-        size_t i, l = jl_array_len(backedges);
+        size_t i, l = jl_array_nrows(backedges);
         for (i = 1; i < l; i += 2) {
             jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(backedges, i);
             jl_value_t *missing_callee = jl_array_ptr_ref(backedges, i - 1);  // signature of abstract callee
@@ -337,7 +337,7 @@ static void collect_backedges(jl_method_instance_t *callee, int internal)
 {
     jl_array_t *backedges = callee->backedges;
     if (backedges) {
-        size_t i = 0, l = jl_array_len(backedges);
+        size_t i = 0, l = jl_array_nrows(backedges);
         while (i < l) {
             jl_value_t *invokeTypes;
             jl_method_instance_t *caller;
@@ -411,7 +411,7 @@ static void jl_record_edges(jl_method_instance_t *caller, arraylist_t *wq, jl_ar
     if (callees != NULL) {
         jl_array_ptr_1d_push(edges, (jl_value_t*)caller);
         jl_array_ptr_1d_push(edges, (jl_value_t*)callees);
-        size_t i, l = jl_array_len(callees);
+        size_t i, l = jl_array_nrows(callees);
         for (i = 1; i < l; i += 2) {
             jl_method_instance_t *c = (jl_method_instance_t*)jl_array_ptr_ref(callees, i);
             if (c && jl_is_method_instance(c)) {
@@ -431,7 +431,7 @@ static void jl_collect_edges(jl_array_t *edges, jl_array_t *ext_targets, jl_arra
     htable_t external_mis;
     htable_new(&external_mis, 0);
     if (external_cis) {
-        for (size_t i = 0; i < jl_array_len(external_cis); i++) {
+        for (size_t i = 0; i < jl_array_nrows(external_cis); i++) {
             jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(external_cis, i);
             jl_method_instance_t *mi = ci->def;
             ptrhash_put(&external_mis, (void*)mi, (void*)mi);
@@ -439,10 +439,10 @@ static void jl_collect_edges(jl_array_t *edges, jl_array_t *ext_targets, jl_arra
     }
     arraylist_t wq;
     arraylist_new(&wq, 0);
-    void **table = (void**)jl_array_data(edges_map);    // edges_map is caller => callees
-    size_t table_size = jl_array_len(edges_map);
+    void **table = (void**) edges_map->ptr;    // edges_map is caller => callees
+    size_t table_size = edges_map->length;
     for (size_t i = 0; i < table_size; i += 2) {
-        assert(table == jl_array_data(edges_map) && table_size == jl_array_len(edges_map) &&
+        assert(table == edges_map->ptr && table_size == edges_map->length &&
                "edges_map changed during iteration");
         jl_method_instance_t *caller = (jl_method_instance_t*)table[i];
         jl_array_t *callees = (jl_array_t*)table[i + 1];
@@ -464,7 +464,7 @@ static void jl_collect_edges(jl_array_t *edges, jl_array_t *ext_targets, jl_arra
     htable_t edges_map2;
     htable_new(&edges_map2, 0);
     htable_t edges_ids;
-    size_t l = edges ? jl_array_len(edges) : 0;
+    size_t l = edges ? jl_array_nrows(edges) : 0;
     htable_new(&edges_ids, l);
     for (size_t i = 0; i < l / 2; i++) {
         jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(edges, i * 2);
@@ -479,9 +479,9 @@ static void jl_collect_edges(jl_array_t *edges, jl_array_t *ext_targets, jl_arra
     JL_GC_PUSH3(&matches, &callee_ids, &sig);
     for (size_t i = 0; i < l; i += 2) {
         jl_array_t *callees = (jl_array_t*)jl_array_ptr_ref(edges, i + 1);
-        size_t l = jl_array_len(callees);
+        size_t l = jl_array_nrows(callees);
         callee_ids = jl_alloc_array_1d(jl_array_int32_type, l + 1);
-        int32_t *idxs = (int32_t*)jl_array_data(callee_ids);
+        int32_t *idxs = jl_array_data(callee_ids, int32_t);
         idxs[0] = 0;
         size_t nt = 0;
         for (size_t j = 0; j < l; j += 2) {
@@ -534,7 +534,7 @@ static void jl_collect_edges(jl_array_t *edges, jl_array_t *ext_targets, jl_arra
                         break;
                     }
                     size_t k;
-                    for (k = 0; k < jl_array_len(matches); k++) {
+                    for (k = 0; k < jl_array_nrows(matches); k++) {
                         jl_method_match_t *match = (jl_method_match_t *)jl_array_ptr_ref(matches, k);
                         jl_array_ptr_set(matches, k, match->method);
                     }
@@ -542,7 +542,7 @@ static void jl_collect_edges(jl_array_t *edges, jl_array_t *ext_targets, jl_arra
                 jl_array_ptr_1d_push(ext_targets, invokeTypes);
                 jl_array_ptr_1d_push(ext_targets, callee);
                 jl_array_ptr_1d_push(ext_targets, matches);
-                target = (void*)((char*)HT_NOTFOUND + jl_array_len(ext_targets) / 3);
+                target = (void*)((char*)HT_NOTFOUND + jl_array_nrows(ext_targets) / 3);
                 ptrhash_put(&edges_map2, (void*)callee, target);
             }
             idxs[++nt] = (char*)target - (char*)HT_NOTFOUND - 1;
@@ -574,7 +574,7 @@ static void jl_collect_edges(jl_array_t *edges, jl_array_t *ext_targets, jl_arra
 static void write_mod_list(ios_t *s, jl_array_t *a)
 {
     size_t i;
-    size_t len = jl_array_len(a);
+    size_t len = jl_array_nrows(a);
     for (i = 0; i < len; i++) {
         jl_module_t *m = (jl_module_t*)jl_array_ptr_ref(a, i);
         assert(jl_is_module(m));
@@ -656,7 +656,7 @@ static int64_t write_header(ios_t *s, uint8_t pkgimage)
 // serialize information about the result of deserializing this file
 static void write_worklist_for_header(ios_t *s, jl_array_t *worklist)
 {
-    int i, l = jl_array_len(worklist);
+    int i, l = jl_array_nrows(worklist);
     for (i = 0; i < l; i++) {
         jl_module_t *workmod = (jl_module_t*)jl_array_ptr_ref(worklist, i);
         if (workmod->parent == jl_main_module || workmod->parent == workmod) {
@@ -714,7 +714,7 @@ static int64_t write_dependency_list(ios_t *s, jl_array_t* worklist, jl_array_t
     // dependencies if we don't need them
     initial_pos = ios_pos(s);
     write_uint64(s, 0);
-    size_t i, l = udeps ? jl_array_len(udeps) : 0;
+    size_t i, l = udeps ? jl_array_nrows(udeps) : 0;
     for (i = 0; i < l; i++) {
         jl_value_t *deptuple = jl_array_ptr_ref(udeps, i);
         jl_value_t *abspath = jl_fieldref(deptuple, 1);
@@ -741,7 +741,7 @@ static int64_t write_dependency_list(ios_t *s, jl_array_t* worklist, jl_array_t
         while (depmod_top->parent != jl_main_module && depmod_top->parent != depmod_top)
             depmod_top = depmod_top->parent;
         unsigned provides = 0;
-        size_t j, lj = jl_array_len(worklist);
+        size_t j, lj = jl_array_nrows(worklist);
         for (j = 0; j < lj; j++) {
             jl_module_t *workmod = (jl_module_t*)jl_array_ptr_ref(worklist, j);
             if (workmod->parent == jl_main_module || workmod->parent == workmod) {
@@ -788,7 +788,7 @@ static int64_t write_dependency_list(ios_t *s, jl_array_t* worklist, jl_array_t
 
     // If we successfully got the preferences, write it out, otherwise write `0` for this `.ji` file.
     if (prefs_hash != NULL && prefs_list != NULL) {
-        size_t i, l = jl_array_len(prefs_list);
+        size_t i, l = jl_array_nrows(prefs_list);
         for (i = 0; i < l; i++) {
             jl_value_t *pref_name = jl_array_ptr_ref(prefs_list, i);
             size_t slen = jl_string_len(pref_name);
@@ -824,7 +824,7 @@ static int64_t write_dependency_list(ios_t *s, jl_array_t* worklist, jl_array_t
 // Add methods to external (non-worklist-owned) functions
 static void jl_insert_methods(jl_array_t *list)
 {
-    size_t i, l = jl_array_len(list);
+    size_t i, l = jl_array_nrows(list);
     for (i = 0; i < l; i++) {
         jl_method_t *meth = (jl_method_t*)jl_array_ptr_ref(list, i);
         assert(jl_is_method(meth));
@@ -837,7 +837,7 @@ static void jl_insert_methods(jl_array_t *list)
 
 static void jl_copy_roots(jl_array_t *method_roots_list, uint64_t key)
 {
-    size_t i, l = jl_array_len(method_roots_list);
+    size_t i, l = jl_array_nrows(method_roots_list);
     for (i = 0; i < l; i+=2) {
         jl_method_t *m = (jl_method_t*)jl_array_ptr_ref(method_roots_list, i);
         jl_array_t *roots = (jl_array_t*)jl_array_ptr_ref(method_roots_list, i+1);
@@ -853,12 +853,12 @@ static void jl_copy_roots(jl_array_t *method_roots_list, uint64_t key)
 static jl_array_t *jl_verify_edges(jl_array_t *targets, size_t minworld)
 {
     JL_TIMING(VERIFY_IMAGE, VERIFY_Edges);
-    size_t i, l = jl_array_len(targets) / 3;
+    size_t i, l = jl_array_nrows(targets) / 3;
     static jl_value_t *ulong_array JL_ALWAYS_LEAFTYPE = NULL;
     if (ulong_array == NULL)
         ulong_array = jl_apply_array_type((jl_value_t*)jl_ulong_type, 1);
     jl_array_t *maxvalids = jl_alloc_array_1d(ulong_array, l);
-    memset(jl_array_data(maxvalids), 0, l * sizeof(size_t));
+    memset(jl_array_data(maxvalids, size_t), 0, l * sizeof(size_t));
     jl_value_t *loctag = NULL;
     jl_value_t *matches = NULL;
     jl_value_t *sig = NULL;
@@ -909,7 +909,7 @@ static jl_array_t *jl_verify_edges(jl_array_t *targets, size_t minworld)
             // TODO: possibly need to included ambiguities too (for the optimizer correctness)?
             // len + 1 is to allow us to log causes of invalidation (SnoopCompile's @snoopr)
             matches = jl_matching_methods((jl_tupletype_t*)sig, jl_nothing,
-                    _jl_debug_method_invalidation ? INT32_MAX : jl_array_len(expected),
+                    _jl_debug_method_invalidation ? INT32_MAX : jl_array_nrows(expected),
                     0, minworld, &min_valid, &max_valid, &ambig);
             sig = NULL;
             if (matches == jl_nothing) {
@@ -918,12 +918,12 @@ static jl_array_t *jl_verify_edges(jl_array_t *targets, size_t minworld)
             else {
                 // setdiff!(matches, expected)
                 size_t j, k, ins = 0;
-                if (jl_array_len(matches) != jl_array_len(expected)) {
+                if (jl_array_nrows(matches) != jl_array_nrows(expected)) {
                     max_valid = 0;
                 }
-                for (k = 0; k < jl_array_len(matches); k++) {
+                for (k = 0; k < jl_array_nrows(matches); k++) {
                     jl_method_t *match = ((jl_method_match_t*)jl_array_ptr_ref(matches, k))->method;
-                    size_t l = jl_array_len(expected);
+                    size_t l = jl_array_nrows(expected);
                     for (j = 0; j < l; j++)
                         if (match == (jl_method_t*)jl_array_ptr_ref(expected, j))
                             break;
@@ -938,10 +938,10 @@ static jl_array_t *jl_verify_edges(jl_array_t *targets, size_t minworld)
                     }
                 }
                 if (max_valid != ~(size_t)0 && _jl_debug_method_invalidation)
-                    jl_array_del_end((jl_array_t*)matches, jl_array_len(matches) - ins);
+                    jl_array_del_end((jl_array_t*)matches, jl_array_nrows(matches) - ins);
             }
         }
-        ((size_t*)(jl_array_data(maxvalids)))[i] = max_valid;
+        jl_array_data(maxvalids, size_t)[i] = max_valid;
         if (max_valid != ~(size_t)0 && _jl_debug_method_invalidation) {
             jl_array_ptr_1d_push(_jl_debug_method_invalidation, invokesig ? (jl_value_t*)invokesig : callee);
             loctag = jl_cstr_to_string("insert_backedges_callee");
@@ -965,9 +965,9 @@ static jl_array_t *jl_verify_methods(jl_array_t *edges, jl_array_t *maxvalids)
     jl_value_t *loctag = NULL;
     jl_array_t *maxvalids2 = NULL;
     JL_GC_PUSH2(&loctag, &maxvalids2);
-    size_t i, l = jl_array_len(edges) / 2;
+    size_t i, l = jl_array_nrows(edges) / 2;
     maxvalids2 = jl_alloc_array_1d(jl_typeof(maxvalids), l);
-    size_t *maxvalids2_data = (size_t*)jl_array_data(maxvalids2);
+    size_t *maxvalids2_data = jl_array_data(maxvalids2, size_t);
     memset(maxvalids2_data, 0, l * sizeof(size_t));
     for (i = 0; i < l; i++) {
         jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(edges, 2 * i);
@@ -979,12 +979,12 @@ static jl_array_t *jl_verify_methods(jl_array_t *edges, jl_array_t *maxvalids)
             maxvalids2_data[i] = 0;
         }
         else {
-            int32_t *idxs = (int32_t*)jl_array_data(callee_ids);
+            int32_t *idxs = jl_array_data(callee_ids, int32_t);
             size_t j;
             maxvalids2_data[i] = ~(size_t)0;
             for (j = 0; j < idxs[0]; j++) {
                 int32_t idx = idxs[j + 1];
-                size_t max_valid = ((size_t*)(jl_array_data(maxvalids)))[idx];
+                size_t max_valid = jl_array_data(maxvalids, size_t)[idx];
                 if (max_valid != ~(size_t)0 && _jl_debug_method_invalidation) {
                     jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)caller);
                     loctag = jl_cstr_to_string("verify_methods");
@@ -1024,8 +1024,8 @@ static int jl_verify_graph_edge(size_t *maxvalids2_data, jl_array_t *edges, size
     visited->items[idx] = (void*)(1 + depth);
     jl_array_t *callee_ids = (jl_array_t*)jl_array_ptr_ref(edges, idx * 2 + 1);
     assert(jl_typetagis((jl_value_t*)callee_ids, jl_array_int32_type));
-    int32_t *idxs = (int32_t*)jl_array_data(callee_ids);
-    size_t i, n = jl_array_len(callee_ids);
+    int32_t *idxs = jl_array_data(callee_ids, int32_t);
+    size_t i, n = jl_array_nrows(callee_ids);
     cycle = depth;
     for (i = idxs[0] + 1; i < n; i++) {
         int32_t childidx = idxs[i];
@@ -1079,10 +1079,10 @@ static void jl_verify_graph(jl_array_t *edges, jl_array_t *maxvalids2)
     JL_TIMING(VERIFY_IMAGE, VERIFY_Graph);
     arraylist_t stack, visited;
     arraylist_new(&stack, 0);
-    size_t i, n = jl_array_len(edges) / 2;
+    size_t i, n = jl_array_nrows(edges) / 2;
     arraylist_new(&visited, n);
     memset(visited.items, 0, n * sizeof(size_t));
-    size_t *maxvalids2_data = (size_t*)jl_array_data(maxvalids2);
+    size_t *maxvalids2_data = jl_array_data(maxvalids2, size_t);
     for (i = 0; i < n; i++) {
         assert(visited.items[i] == (void*)0 || visited.items[i] == (void*)1);
         int child_cycle = jl_verify_graph_edge(maxvalids2_data, edges, i, &visited, &stack);
@@ -1107,7 +1107,7 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
     size_t i, l;
 
     // next build a map from external MethodInstances to their CodeInstance for insertion
-    l = jl_array_len(ci_list);
+    l = jl_array_nrows(ci_list);
     htable_t visited;
     htable_new(&visited, l);
     for (i = 0; i < l; i++) {
@@ -1128,14 +1128,14 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
     }
 
     // next enable any applicable new codes
-    l = jl_array_len(edges) / 2;
+    l = jl_array_nrows(edges) / 2;
     for (i = 0; i < l; i++) {
         jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(edges, 2 * i);
-        size_t maxvalid = ((size_t*)(jl_array_data(valids)))[i];
+        size_t maxvalid = jl_array_data(valids, size_t)[i];
         if (maxvalid == ~(size_t)0) {
             // if this callee is still valid, add all the backedges
             jl_array_t *callee_ids = (jl_array_t*)jl_array_ptr_ref(edges, 2 * i + 1);
-            int32_t *idxs = (int32_t*)jl_array_data(callee_ids);
+            int32_t *idxs = jl_array_data(callee_ids, int32_t);
             for (size_t j = 0; j < idxs[0]; j++) {
                 int32_t idx = idxs[j + 1];
                 jl_value_t *invokesig = jl_array_ptr_ref(ext_targets, idx * 3);
@@ -1176,7 +1176,7 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
 
 static void classify_callers(htable_t *callers_with_edges, jl_array_t *edges)
 {
-    size_t l = edges ? jl_array_len(edges) / 2 : 0;
+    size_t l = edges ? jl_array_nrows(edges) / 2 : 0;
     for (size_t i = 0; i < l; i++) {
         jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(edges, 2 * i);
         ptrhash_put(callers_with_edges, (void*)caller, (void*)caller);
@@ -1189,7 +1189,7 @@ static jl_value_t *read_verify_mod_list(ios_t *s, jl_array_t *depmods)
         return jl_get_exceptionf(jl_errorexception_type,
                 "Main module uuid state is invalid for module deserialization.");
     }
-    size_t i, l = jl_array_len(depmods);
+    size_t i, l = jl_array_nrows(depmods);
     for (i = 0; ; i++) {
         size_t len = read_int32(s);
         if (len == 0 && i == l)
@@ -1251,11 +1251,11 @@ static jl_array_t *image_to_depmodidx(jl_array_t *depmods)
 {
     if (!depmods)
         return NULL;
-    assert(jl_array_len(depmods) < INT32_MAX && "too many dependencies to serialize");
+    assert(jl_array_nrows(depmods) < INT32_MAX && "too many dependencies to serialize");
     size_t lbids = n_linkage_blobs();
-    size_t ldeps = jl_array_len(depmods);
+    size_t ldeps = jl_array_nrows(depmods);
     jl_array_t *depmodidxs = jl_alloc_array_1d(jl_array_int32_type, lbids);
-    int32_t *dmidxs = (int32_t*)jl_array_data(depmodidxs);
+    int32_t *dmidxs = jl_array_data(depmodidxs, int32_t);
     memset(dmidxs, -1, lbids * sizeof(int32_t));
     dmidxs[0] = 0; // the sysimg can also be found at idx 0, by construction
     for (size_t i = 0, j = 0; i < ldeps; i++) {
@@ -1275,9 +1275,9 @@ static jl_array_t *depmod_to_imageidx(jl_array_t *depmods)
 {
     if (!depmods)
         return NULL;
-    size_t ldeps = jl_array_len(depmods);
+    size_t ldeps = jl_array_nrows(depmods);
     jl_array_t *imageidxs = jl_alloc_array_1d(jl_array_int32_type, ldeps + 1);
-    int32_t *imgidxs = (int32_t*)jl_array_data(imageidxs);
+    int32_t *imgidxs = jl_array_data(imageidxs, int32_t);
     imgidxs[0] = 0;
     for (size_t i = 0; i < ldeps; i++) {
         jl_value_t *depmod = jl_array_ptr_ref(depmods, i);
diff --git a/src/subtype.c b/src/subtype.c
index 766e0e703f480..f80e31c58c46b 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -846,7 +846,7 @@ static jl_value_t *fix_inferred_var_bound(jl_tvar_t *var, jl_value_t *ty JL_MAYB
         JL_GC_PUSH2(&ans, &vs);
         vs = jl_find_free_typevars(ty);
         int i;
-        for (i = 0; i < jl_array_len(vs); i++) {
+        for (i = 0; i < jl_array_nrows(vs); i++) {
             ans = jl_type_unionall((jl_tvar_t*)jl_array_ptr_ref(vs, i), ans);
         }
         ans = (jl_value_t*)jl_new_typevar(var->name, jl_bottom_type, ans);
@@ -2989,7 +2989,7 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
     }
 
     if (vb->innervars != NULL) {
-        for (size_t i = 0; i < jl_array_len(vb->innervars); i++) {
+        for (size_t i = 0; i < jl_array_nrows(vb->innervars); i++) {
             jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
             // the `btemp->prev` walk is only giving a sort of post-order guarantee (since we are
             // iterating 2 trees at once), so once we set `wrap`, there might remain other branches
diff --git a/src/sys.c b/src/sys.c
index 6da4231c9b7e2..7407da4e3514e 100644
--- a/src/sys.c
+++ b/src/sys.c
@@ -280,14 +280,15 @@ JL_DLLEXPORT jl_value_t *jl_readuntil(ios_t *s, uint8_t delim, uint8_t str, uint
             return str;
         }
         a = jl_alloc_array_1d(jl_array_uint8_type, n - nchomp);
-        memcpy(jl_array_data(a), s->buf + s->bpos, n - nchomp);
+        memcpy(jl_array_data(a, uint8_t), s->buf + s->bpos, n - nchomp);
         s->bpos += n;
     }
     else {
         a = jl_alloc_array_1d(jl_array_uint8_type, 80);
         ios_t dest;
         ios_mem(&dest, 0);
-        ios_setbuf(&dest, (char*)a->data, 80, 0);
+        char *mem = jl_array_data(a, char);
+        ios_setbuf(&dest, (char*)mem, 80, 0);
         size_t n = ios_copyuntil(&dest, s, delim, 1);
         if (chomp && n > 0 && dest.buf[n - 1] == delim) {
             n--;
@@ -298,12 +299,11 @@ JL_DLLEXPORT jl_value_t *jl_readuntil(ios_t *s, uint8_t delim, uint8_t str, uint
             assert(truncret == 0);
             (void)truncret; // ensure the variable is used to avoid warnings
         }
-        if (dest.buf != a->data) {
+        if (dest.buf != mem) {
             a = jl_take_buffer(&dest);
         }
         else {
-            a->length = n;
-            a->nrows = n;
+            a->dimsize[0] = n;
         }
         if (str) {
             JL_GC_PUSH1(&a);
diff --git a/src/toplevel.c b/src/toplevel.c
index a5918c23b4faa..5b67ab6061c51 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -121,7 +121,7 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
 {
     jl_task_t *ct = jl_current_task;
     assert(ex->head == jl_module_sym);
-    if (jl_array_len(ex->args) != 3 || !jl_is_expr(jl_exprarg(ex, 2))) {
+    if (jl_array_nrows(ex->args) != 3 || !jl_is_expr(jl_exprarg(ex, 2))) {
         jl_error("syntax: malformed module expression");
     }
 
@@ -188,7 +188,7 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
     jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 2))->args;
     int lineno = 0;
     const char *filename = "none";
-    if (jl_array_len(exprs) > 0) {
+    if (jl_array_nrows(exprs) > 0) {
         jl_value_t *lineex = jl_array_ptr_ref(exprs, 0);
         if (jl_is_linenode(lineex)) {
             lineno = jl_linenode_line(lineex);
@@ -207,7 +207,7 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
         form = NULL;
     }
 
-    for (int i = 0; i < jl_array_len(exprs); i++) {
+    for (int i = 0; i < jl_array_nrows(exprs); i++) {
         // process toplevel form
         ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
         form = jl_expand_stmt_with_loc(jl_array_ptr_ref(exprs, i), newm, jl_filename, jl_lineno);
@@ -254,7 +254,7 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
     form = NULL;
     if (!jl_generating_output()) {
         if (!ptrhash_has(&jl_current_modules, (void*)newm->parent)) {
-            size_t i, l = jl_array_len(jl_module_init_order);
+            size_t i, l = jl_array_nrows(jl_module_init_order);
             size_t ns = 0;
             form = (jl_value_t*)jl_alloc_vec_any(0);
             for (i = 0; i < l; i++) {
@@ -273,7 +273,7 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
     JL_UNLOCK(&jl_modules_mutex);
 
     if (form) {
-        size_t i, l = jl_array_len(form);
+        size_t i, l = jl_array_nrows(form);
         for (i = 0; i < l; i++) {
             jl_module_t *m = (jl_module_t*)jl_array_ptr_ref(form, i);
             JL_GC_PROMISE_ROOTED(m);
@@ -311,7 +311,7 @@ static jl_value_t *jl_eval_dot_expr(jl_module_t *m, jl_value_t *x, jl_value_t *f
 
 void jl_eval_global_expr(jl_module_t *m, jl_expr_t *ex, int set_type) {
     // create uninitialized mutable binding for "global x" decl sometimes or probably
-    size_t i, l = jl_array_len(ex->args);
+    size_t i, l = jl_array_nrows(ex->args);
     for (i = 0; i < l; i++) {
         jl_value_t *arg = jl_exprarg(ex, i);
         jl_module_t *gm;
@@ -414,7 +414,7 @@ static void expr_attributes(jl_value_t *v, int *has_ccall, int *has_defs, int *h
         return;
     }
     int i;
-    for (i = 0; i < jl_array_len(e->args); i++) {
+    for (i = 0; i < jl_array_nrows(e->args); i++) {
         jl_value_t *a = jl_exprarg(e, i);
         if (jl_is_expr(a))
             expr_attributes(a, has_ccall, has_defs, has_opaque);
@@ -429,7 +429,7 @@ int jl_code_requires_compiler(jl_code_info_t *src, int include_force_compile)
     int has_ccall = 0, has_defs = 0, has_opaque = 0;
     if (include_force_compile && jl_has_meta(body, jl_force_compile_sym))
         return 1;
-    for(i=0; i < jl_array_len(body); i++) {
+    for(i=0; i < jl_array_nrows(body); i++) {
         jl_value_t *stmt = jl_array_ptr_ref(body,i);
         expr_attributes(stmt, &has_ccall, &has_defs, &has_opaque);
         if (has_ccall)
@@ -442,7 +442,7 @@ static void body_attributes(jl_array_t *body, int *has_ccall, int *has_defs, int
 {
     size_t i;
     *has_loops = 0;
-    for(i=0; i < jl_array_len(body); i++) {
+    for(i=0; i < jl_array_nrows(body); i++) {
         jl_value_t *stmt = jl_array_ptr_ref(body,i);
         if (!*has_loops) {
             if (jl_is_gotonode(stmt)) {
@@ -493,7 +493,7 @@ static jl_module_t *call_require(jl_module_t *mod, jl_sym_t *var) JL_GLOBALLY_RO
 static jl_module_t *eval_import_path(jl_module_t *where, jl_module_t *from JL_PROPAGATES_ROOT,
                                      jl_array_t *args, jl_sym_t **name, const char *keyword) JL_GLOBALLY_ROOTED
 {
-    if (jl_array_len(args) == 0)
+    if (jl_array_nrows(args) == 0)
         jl_errorf("malformed \"%s\" statement", keyword);
     jl_sym_t *var = (jl_sym_t*)jl_array_ptr_ref(args, 0);
     size_t i = 1;
@@ -517,14 +517,14 @@ static jl_module_t *eval_import_path(jl_module_t *where, jl_module_t *from JL_PR
         else {
             m = call_require(where, var);
         }
-        if (i == jl_array_len(args))
+        if (i == jl_array_nrows(args))
             return m;
     }
     else {
         // `.A.B.C`: strip off leading dots by following parent links
         m = where;
         while (1) {
-            if (i >= jl_array_len(args))
+            if (i >= jl_array_nrows(args))
                 jl_error("invalid module path");
             var = (jl_sym_t*)jl_array_ptr_ref(args, i);
             if (var != jl_dot_sym)
@@ -541,7 +541,7 @@ static jl_module_t *eval_import_path(jl_module_t *where, jl_module_t *from JL_PR
             jl_type_error(keyword, (jl_value_t*)jl_symbol_type, (jl_value_t*)var);
         if (var == jl_dot_sym)
             jl_errorf("invalid %s path: \".\" in identifier path", keyword);
-        if (i == jl_array_len(args)-1)
+        if (i == jl_array_nrows(args)-1)
             break;
         m = (jl_module_t*)jl_eval_global_var(m, var);
         JL_GC_PROMISE_ROOTED(m);
@@ -582,7 +582,7 @@ int jl_needs_lowering(jl_value_t *e) JL_NOTSAFEPOINT
         return 0;
     }
     if (head == jl_global_sym || head == jl_const_sym) {
-        size_t i, l = jl_array_len(ex->args);
+        size_t i, l = jl_array_nrows(ex->args);
         for (i = 0; i < l; i++) {
             jl_value_t *a = jl_exprarg(ex, i);
             if (!jl_is_symbol(a) && !jl_is_globalref(a))
@@ -841,7 +841,7 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
     }
     else if (head == jl_export_sym || head == jl_public_sym) {
         int exp = (head == jl_export_sym);
-        for (size_t i = 0; i < jl_array_len(ex->args); i++) {
+        for (size_t i = 0; i < jl_array_nrows(ex->args); i++) {
             jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, i);
             if (!jl_is_symbol(name))
                 jl_eval_errorf(m, exp ? "syntax: malformed \"export\" statement" :
@@ -877,7 +877,7 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
     else if (head == jl_toplevel_sym) {
         jl_value_t *res = jl_nothing;
         int i;
-        for (i = 0; i < jl_array_len(ex->args); i++) {
+        for (i = 0; i < jl_array_nrows(ex->args); i++) {
             res = jl_toplevel_eval_flex(m, jl_array_ptr_ref(ex->args, i), fast, 0);
         }
         JL_GC_POP();
@@ -957,7 +957,7 @@ JL_DLLEXPORT void jl_check_top_level_effect(jl_module_t *m, char *fname)
             JL_LOCK(&jl_modules_mutex);
             int open = ptrhash_has(&jl_current_modules, (void*)m);
             if (!open && jl_module_init_order != NULL) {
-                size_t i, l = jl_array_len(jl_module_init_order);
+                size_t i, l = jl_array_nrows(jl_module_init_order);
                 for (i = 0; i < l; i++) {
                     if (m == (jl_module_t*)jl_array_ptr_ref(jl_module_init_order, i)) {
                         open = 1;
diff --git a/src/typemap.c b/src/typemap.c
index 1bdbe52a974dd..32fda9166f8f0 100644
--- a/src/typemap.c
+++ b/src/typemap.c
@@ -277,21 +277,21 @@ static int is_cache_leaf(jl_value_t *ty, int tparam)
     return (jl_is_concrete_type(ty) && (tparam || !jl_is_kind(ty)));
 }
 
-static _Atomic(jl_value_t*) *mtcache_hash_lookup_bp(jl_array_t *cache JL_PROPAGATES_ROOT, jl_value_t *ty) JL_NOTSAFEPOINT
+static _Atomic(jl_value_t*) *mtcache_hash_lookup_bp(jl_genericmemory_t *cache JL_PROPAGATES_ROOT, jl_value_t *ty) JL_NOTSAFEPOINT
 {
-    if (cache == (jl_array_t*)jl_an_empty_vec_any)
+    if (cache == (jl_genericmemory_t*)jl_an_empty_memory_any)
         return NULL;
     _Atomic(jl_value_t*) *pml = jl_table_peek_bp(cache, ty);
     JL_GC_PROMISE_ROOTED(pml); // clang-sa doesn't trust our JL_PROPAGATES_ROOT claim
     return pml;
 }
 
-static void mtcache_hash_insert(_Atomic(jl_array_t*) *cache, jl_value_t *parent, jl_value_t *key, jl_typemap_t *val)
+static void mtcache_hash_insert(_Atomic(jl_genericmemory_t*) *cache, jl_value_t *parent, jl_value_t *key, jl_typemap_t *val)
 {
     int inserted = 0;
-    jl_array_t *a = jl_atomic_load_relaxed(cache);
-    if (a == (jl_array_t*)jl_an_empty_vec_any) {
-        a = jl_alloc_vec_any(16);
+    jl_genericmemory_t *a = jl_atomic_load_relaxed(cache);
+    if (a == (jl_genericmemory_t*)jl_an_empty_memory_any) {
+        a = jl_alloc_memory_any(16);
         jl_atomic_store_release(cache, a);
         if (parent)
             jl_gc_wb(parent, a);
@@ -305,9 +305,9 @@ static void mtcache_hash_insert(_Atomic(jl_array_t*) *cache, jl_value_t *parent,
     }
 }
 
-static jl_typemap_t *mtcache_hash_lookup(jl_array_t *cache JL_PROPAGATES_ROOT, jl_value_t *ty) JL_NOTSAFEPOINT
+static jl_typemap_t *mtcache_hash_lookup(jl_genericmemory_t *cache JL_PROPAGATES_ROOT, jl_value_t *ty) JL_NOTSAFEPOINT
 {
-    if (cache == (jl_array_t*)jl_an_empty_vec_any)
+    if (cache == (jl_genericmemory_t*)jl_an_empty_memory_any)
         return (jl_typemap_t*)jl_nothing;
     jl_typemap_t *ml = (jl_typemap_t*)jl_eqtable_get(cache, ty, jl_nothing);
     return ml;
@@ -315,17 +315,17 @@ static jl_typemap_t *mtcache_hash_lookup(jl_array_t *cache JL_PROPAGATES_ROOT, j
 
 // ----- Sorted Type Signature Lookup Matching ----- //
 
-static int jl_typemap_array_visitor(jl_array_t *a, jl_typemap_visitor_fptr fptr, void *closure)
+static int jl_typemap_memory_visitor(jl_genericmemory_t *a, jl_typemap_visitor_fptr fptr, void *closure)
 {
-    size_t i, l = jl_array_len(a);
-    _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*)jl_array_data(a);
+    size_t i, l = a->length;
+    _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*) a->ptr;
     for (i = 1; i < l; i += 2) {
         jl_value_t *d = jl_atomic_load_relaxed(&data[i]);
         JL_GC_PROMISE_ROOTED(d);
         if (d == NULL)
             continue;
-        if (jl_is_array(d)) {
-            if (!jl_typemap_array_visitor((jl_array_t*)d, fptr, closure))
+        if (jl_is_genericmemory(d)) {
+            if (!jl_typemap_memory_visitor((jl_genericmemory_t*)d, fptr, closure))
                 return 0;
         }
         else {
@@ -352,23 +352,23 @@ int jl_typemap_visitor(jl_typemap_t *cache, jl_typemap_visitor_fptr fptr, void *
 {
     if (jl_typeof(cache) == (jl_value_t*)jl_typemap_level_type) {
         jl_typemap_level_t *node = (jl_typemap_level_t*)cache;
-        jl_array_t *a;
+        jl_genericmemory_t *a;
         JL_GC_PUSH1(&a);
         a = jl_atomic_load_relaxed(&node->targ);
-        if (a != (jl_array_t*)jl_an_empty_vec_any)
-            if (!jl_typemap_array_visitor(a, fptr, closure))
+        if (a != (jl_genericmemory_t*)jl_an_empty_memory_any)
+            if (!jl_typemap_memory_visitor(a, fptr, closure))
                 goto exit;
         a = jl_atomic_load_relaxed(&node->arg1);
-        if (a != (jl_array_t*)jl_an_empty_vec_any)
-            if (!jl_typemap_array_visitor(a, fptr, closure))
+        if (a != (jl_genericmemory_t*)jl_an_empty_memory_any)
+            if (!jl_typemap_memory_visitor(a, fptr, closure))
                 goto exit;
         a = jl_atomic_load_relaxed(&node->tname);
-        if (a != (jl_array_t*)jl_an_empty_vec_any)
-            if (!jl_typemap_array_visitor(a, fptr, closure))
+        if (a != (jl_genericmemory_t*)jl_an_empty_memory_any)
+            if (!jl_typemap_memory_visitor(a, fptr, closure))
                 goto exit;
         a = jl_atomic_load_relaxed(&node->name1);
-        if (a != (jl_array_t*)jl_an_empty_vec_any)
-            if (!jl_typemap_array_visitor(a, fptr, closure))
+        if (a != (jl_genericmemory_t*)jl_an_empty_memory_any)
+            if (!jl_typemap_memory_visitor(a, fptr, closure))
                 goto exit;
         if (!jl_typemap_node_visitor(jl_atomic_load_relaxed(&node->linear), fptr, closure))
             goto exit;
@@ -451,12 +451,12 @@ static int concrete_intersects(jl_value_t *t, jl_value_t *ty, int8_t tparam)
 
 // tparam bit 0 is ::Type{T} (vs. T)
 // tparam bit 1 is typename(T) (vs. T)
-static int jl_typemap_intersection_array_visitor(jl_array_t *a, jl_value_t *ty, int8_t tparam,
+static int jl_typemap_intersection_memory_visitor(jl_genericmemory_t *a, jl_value_t *ty, int8_t tparam,
                                                  int8_t offs, struct typemap_intersection_env *closure)
 {
     JL_GC_PUSH1(&a);
-    size_t i, l = jl_array_len(a);
-    _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*)jl_array_data(a);
+    size_t i, l = a->length;
+    _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*) a->ptr;
     unsigned height = 0;
     jl_datatype_t *tydt = jl_any_type;
     if (tparam & 2) {
@@ -492,8 +492,8 @@ static int jl_typemap_intersection_array_visitor(jl_array_t *a, jl_value_t *ty,
                     tname_intersection_dt(tydt, (jl_typename_t*)t, height)) {
                 if ((tparam & 1) && t == (jl_value_t*)jl_typeofbottom_type->name) // skip Type{Union{}} and Type{typeof(Union{})}, since the caller should have already handled those
                     continue;
-                if (jl_is_array(ml)) {
-                    if (!jl_typemap_intersection_array_visitor((jl_array_t*)ml, ty, tparam & ~2, offs, closure))
+                if (jl_is_genericmemory(ml)) {
+                    if (!jl_typemap_intersection_memory_visitor((jl_genericmemory_t*)ml, ty, tparam & ~2, offs, closure))
                         goto exit;
                 }
                 else {
@@ -627,15 +627,15 @@ int jl_typemap_intersection_visitor(jl_typemap_t *map, int offs,
             if (jl_has_free_typevars(ty))
                 ty = jl_rewrap_unionall(ty, closure->type);
             JL_GC_PUSH1(&ty);
-            jl_array_t *targ = jl_atomic_load_relaxed(&cache->targ);
-            jl_array_t *tname = jl_atomic_load_relaxed(&cache->tname);
+            jl_genericmemory_t *targ = jl_atomic_load_relaxed(&cache->targ);
+            jl_genericmemory_t *tname = jl_atomic_load_relaxed(&cache->tname);
             int maybe_type = 0;
             int maybe_kind = 0;
             int exclude_typeofbottom = 0;
             jl_value_t *typetype = NULL;
             jl_value_t *name = NULL;
             // pre-check: optimized pre-intersection test to see if `ty` could intersect with any Type or Kind
-            if (targ != (jl_array_t*)jl_an_empty_vec_any || tname != (jl_array_t*)jl_an_empty_vec_any) {
+            if (targ != (jl_genericmemory_t*)jl_an_empty_memory_any || tname != (jl_genericmemory_t*)jl_an_empty_memory_any) {
                 maybe_kind = jl_has_intersect_kind_not_type(ty);
                 maybe_type = maybe_kind || jl_has_intersect_type_not_kind(ty);
                 if (maybe_type && !maybe_kind) {
@@ -651,7 +651,7 @@ int jl_typemap_intersection_visitor(jl_typemap_t *map, int offs,
                 }
             }
             // First check for intersections with methods defined on Type{T}, where T was a concrete type
-            if (targ != (jl_array_t*)jl_an_empty_vec_any && maybe_type &&
+            if (targ != (jl_genericmemory_t*)jl_an_empty_memory_any && maybe_type &&
                     (!typetype || jl_has_free_typevars(typetype) || is_cache_leaf(typetype, 1))) { // otherwise cannot contain this particular kind, so don't bother with checking
                 if (!exclude_typeofbottom) {
                     // detect Type{Union{}}, Type{Type{Union{}}}, and Type{typeof(Union{}} and do those early here
@@ -680,18 +680,18 @@ int jl_typemap_intersection_visitor(jl_typemap_t *map, int offs,
                         // attempt semi-direct lookup of types via their names
                         // consider the type name first
                         jl_value_t *ml = mtcache_hash_lookup(targ, (jl_value_t*)name);
-                        if (jl_is_array(ml)) {
+                        if (jl_is_genericmemory(ml)) {
                             if (typetype && !jl_has_free_typevars(typetype)) {
                                 // direct lookup of leaf types
                                 if (is_cache_leaf(typetype, 1)) {
-                                    ml = mtcache_hash_lookup((jl_array_t*)ml, typetype);
+                                    ml = mtcache_hash_lookup((jl_genericmemory_t*)ml, typetype);
                                     if (ml != jl_nothing) {
                                         if (!jl_typemap_intersection_visitor((jl_typemap_t*)ml, offs+1, closure)) { JL_GC_POP(); return 0; }
                                     }
                                 }
                             }
                             else {
-                                if (!jl_typemap_intersection_array_visitor((jl_array_t*)ml, ty, 1, offs, closure)) { JL_GC_POP(); return 0; }
+                                if (!jl_typemap_intersection_memory_visitor((jl_genericmemory_t*)ml, ty, 1, offs, closure)) { JL_GC_POP(); return 0; }
                             }
                         }
                         else if (ml != jl_nothing) {
@@ -699,19 +699,19 @@ int jl_typemap_intersection_visitor(jl_typemap_t *map, int offs,
                         }
                     }
                     else {
-                        // else an array scan is required to consider all the possible subtypes
-                        if (!jl_typemap_intersection_array_visitor(targ, exclude_typeofbottom && !maybe_kind ? ty : (jl_value_t*)jl_any_type, 3, offs, closure)) { JL_GC_POP(); return 0; }
+                        // else a scan is required to consider all the possible subtypes
+                        if (!jl_typemap_intersection_memory_visitor(targ, exclude_typeofbottom && !maybe_kind ? ty : (jl_value_t*)jl_any_type, 3, offs, closure)) { JL_GC_POP(); return 0; }
                     }
                 }
             }
-            jl_array_t *cachearg1 = jl_atomic_load_relaxed(&cache->arg1);
-            if (cachearg1 != (jl_array_t*)jl_an_empty_vec_any) {
+            jl_genericmemory_t *cachearg1 = jl_atomic_load_relaxed(&cache->arg1);
+            if (cachearg1 != (jl_genericmemory_t*)jl_an_empty_memory_any) {
                 if (is_cache_leaf(ty, 0)) {
                     jl_typename_t *name = ty == jl_bottom_type ? jl_typeofbottom_type->name : ((jl_datatype_t*)ty)->name;
                     // direct lookup of leaf types
                     jl_value_t *ml = mtcache_hash_lookup(cachearg1, (jl_value_t*)name);
-                    if (jl_is_array(ml))
-                        ml = mtcache_hash_lookup((jl_array_t*)ml, ty);
+                    if (jl_is_genericmemory(ml))
+                        ml = mtcache_hash_lookup((jl_genericmemory_t*)ml, ty);
                     if (ml != jl_nothing) {
                         if (!jl_typemap_intersection_visitor(ml, offs+1, closure)) { JL_GC_POP(); return 0; }
                     }
@@ -721,21 +721,21 @@ int jl_typemap_intersection_visitor(jl_typemap_t *map, int offs,
                     if (name && jl_type_extract_name_precise(ty, 0)) {
                         // direct lookup of leaf types
                         jl_value_t *ml = mtcache_hash_lookup(cachearg1, name);
-                        if (jl_is_array(ml)) {
-                            if (!jl_typemap_intersection_array_visitor((jl_array_t*)ml, ty, 0, offs, closure)) { JL_GC_POP(); return 0; }
+                        if (jl_is_genericmemory(ml)) {
+                            if (!jl_typemap_intersection_memory_visitor((jl_genericmemory_t*)ml, ty, 0, offs, closure)) { JL_GC_POP(); return 0; }
                         }
                         else {
                             if (!jl_typemap_intersection_visitor((jl_typemap_t*)ml, offs+1, closure)) { JL_GC_POP(); return 0; }
                         }
                     }
                     else {
-                        // else an array scan is required to check subtypes
-                        if (!jl_typemap_intersection_array_visitor(cachearg1, ty, 2, offs, closure)) { JL_GC_POP(); return 0; }
+                        // else a scan is required to check subtypes
+                        if (!jl_typemap_intersection_memory_visitor(cachearg1, ty, 2, offs, closure)) { JL_GC_POP(); return 0; }
                     }
                 }
             }
             // Next check for intersections with methods defined on Type{T}, where T was not concrete (it might even have been a TypeVar), but had an extractable TypeName
-            if (tname != (jl_array_t*)jl_an_empty_vec_any && maybe_type) {
+            if (tname != (jl_genericmemory_t*)jl_an_empty_memory_any && maybe_type) {
                 if (!exclude_typeofbottom || (!typetype && jl_isa((jl_value_t*)jl_typeofbottom_type, ty))) {
                     // detect Type{Union{}}, Type{Type{Union{}}}, and Type{typeof(Union{}} and do those early here
                     // otherwise the possibility of encountering `Type{Union{}}` in this intersection may
@@ -775,13 +775,13 @@ int jl_typemap_intersection_visitor(jl_typemap_t *map, int offs,
                     }
                 }
                 else {
-                    // else an array scan is required to check subtypes of typetype too
+                    // else a scan is required to check subtypes of typetype too
                     tname = jl_atomic_load_relaxed(&cache->tname);  // may be GC'd earlier
-                    if (!jl_typemap_intersection_array_visitor(tname, exclude_typeofbottom && !maybe_kind ? ty : (jl_value_t*)jl_any_type, 3, offs, closure)) { JL_GC_POP(); return 0; }
+                    if (!jl_typemap_intersection_memory_visitor(tname, exclude_typeofbottom && !maybe_kind ? ty : (jl_value_t*)jl_any_type, 3, offs, closure)) { JL_GC_POP(); return 0; }
                 }
             }
-            jl_array_t *name1 = jl_atomic_load_relaxed(&cache->name1);
-            if (name1 != (jl_array_t*)jl_an_empty_vec_any) {
+            jl_genericmemory_t *name1 = jl_atomic_load_relaxed(&cache->name1);
+            if (name1 != (jl_genericmemory_t*)jl_an_empty_memory_any) {
                 jl_value_t *name = jl_type_extract_name(ty);
                 if (name && jl_type_extract_name_precise(ty, 0)) {
                     jl_datatype_t *super = (jl_datatype_t*)jl_unwrap_unionall(((jl_typename_t*)name)->wrapper);
@@ -798,8 +798,8 @@ int jl_typemap_intersection_visitor(jl_typemap_t *map, int offs,
                     }
                 }
                 else {
-                    // else an array scan is required to check subtypes
-                    if (!jl_typemap_intersection_array_visitor(name1, ty, 2, offs, closure)) { JL_GC_POP(); return 0; }
+                    // else a scan is required to check subtypes
+                    if (!jl_typemap_intersection_memory_visitor(name1, ty, 2, offs, closure)) { JL_GC_POP(); return 0; }
                 }
             }
             JL_GC_POP();
@@ -989,12 +989,12 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(
             if (jl_is_type_type(ty)) {
                 jl_value_t *a0 = jl_tparam0(ty);
                 if (is_cache_leaf(a0, 1)) {
-                    jl_array_t *targ = jl_atomic_load_relaxed(&cache->targ);
-                    if (targ != (jl_array_t*)jl_an_empty_vec_any) {
+                    jl_genericmemory_t *targ = jl_atomic_load_relaxed(&cache->targ);
+                    if (targ != (jl_genericmemory_t*)jl_an_empty_memory_any) {
                         jl_typename_t *name = a0 == jl_bottom_type ? jl_typeofbottom_type->name : ((jl_datatype_t*)a0)->name;
                         jl_value_t *ml = mtcache_hash_lookup(targ, (jl_value_t*)name);
-                        if (jl_is_array(ml))
-                            ml = mtcache_hash_lookup((jl_array_t*)ml, a0);
+                        if (jl_is_genericmemory(ml))
+                            ml = mtcache_hash_lookup((jl_genericmemory_t*)ml, a0);
                         if (ml != jl_nothing) {
                             jl_typemap_entry_t *li = jl_typemap_assoc_by_type((jl_typemap_t*)ml, search, offs + 1, subtype);
                             if (li) return li;
@@ -1004,12 +1004,12 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(
                 }
             }
             if (is_cache_leaf(ty, 0)) {
-                jl_array_t *cachearg1 = jl_atomic_load_relaxed(&cache->arg1);
-                if (cachearg1 != (jl_array_t*)jl_an_empty_vec_any) {
+                jl_genericmemory_t *cachearg1 = jl_atomic_load_relaxed(&cache->arg1);
+                if (cachearg1 != (jl_genericmemory_t*)jl_an_empty_memory_any) {
                     jl_typename_t *name = ty == jl_bottom_type ? jl_typeofbottom_type->name : ((jl_datatype_t*)ty)->name;
                     jl_value_t *ml = mtcache_hash_lookup(cachearg1, (jl_value_t*)name);
-                    if (jl_is_array(ml))
-                        ml = mtcache_hash_lookup((jl_array_t*)ml, ty);
+                    if (jl_is_genericmemory(ml))
+                        ml = mtcache_hash_lookup((jl_genericmemory_t*)ml, ty);
                     if (ml != jl_nothing) {
                         jl_typemap_entry_t *li = jl_typemap_assoc_by_type((jl_typemap_t*)ml, search, offs + 1, subtype);
                         if (li) return li;
@@ -1020,8 +1020,8 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(
         }
         if (ty || subtype) {
             // now look at the optimized TypeName caches
-            jl_array_t *tname = jl_atomic_load_relaxed(&cache->tname);
-            if (tname != (jl_array_t*)jl_an_empty_vec_any) {
+            jl_genericmemory_t *tname = jl_atomic_load_relaxed(&cache->tname);
+            if (tname != (jl_genericmemory_t*)jl_an_empty_memory_any) {
                 jl_value_t *a0 = ty && jl_is_type_type(ty) ? jl_type_extract_name(jl_tparam0(ty)) : NULL;
                 if (a0) { // TODO: if we start analyzing Union types in jl_type_extract_name, then a0 might be over-approximated here, leading us to miss possible subtypes
                     jl_datatype_t *super = (jl_datatype_t*)jl_unwrap_unionall(((jl_typename_t*)a0)->wrapper);
@@ -1039,9 +1039,10 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(
                 }
                 else {
                     if (!ty || !jl_has_empty_intersection((jl_value_t*)jl_type_type, ty)) {
+                        jl_genericmemory_t *tname = jl_atomic_load_relaxed(&cache->tname); // reload after type-intersect
                         // couldn't figure out unique `a0` initial point, so scan all for matches
-                        size_t i, l = jl_array_len(tname);
-                        _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*)jl_array_ptr_data(tname);
+                        size_t i, l = tname->length;
+                        _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*) jl_genericmemory_ptr_data(tname);
                         JL_GC_PUSH1(&tname);
                         for (i = 1; i < l; i += 2) {
                             jl_typemap_t *ml = jl_atomic_load_relaxed(&data[i]);
@@ -1057,8 +1058,8 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(
                     }
                 }
             }
-            jl_array_t *name1 = jl_atomic_load_relaxed(&cache->name1);
-            if (name1 != (jl_array_t*)jl_an_empty_vec_any) {
+            jl_genericmemory_t *name1 = jl_atomic_load_relaxed(&cache->name1);
+            if (name1 != (jl_genericmemory_t*)jl_an_empty_memory_any) {
                 if (ty) {
                     jl_value_t *a0 = jl_type_extract_name(ty);
                     if (a0) { // TODO: if we start analyzing Union types in jl_type_extract_name, then a0 might be over-approximated here, leading us to miss possible subtypes
@@ -1079,8 +1080,8 @@ jl_typemap_entry_t *jl_typemap_assoc_by_type(
                 }
                 else {
                     // doing subtype, but couldn't figure out unique `ty`, so scan all for supertypes
-                    size_t i, l = jl_array_len(name1);
-                    _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*)jl_array_ptr_data(name1);
+                    size_t i, l = name1->length;
+                    _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*) jl_genericmemory_ptr_data(name1);
                     JL_GC_PUSH1(&name1);
                     for (i = 1; i < l; i += 2) {
                         jl_typemap_t *ml = jl_atomic_load_relaxed(&data[i]);
@@ -1198,26 +1199,26 @@ jl_typemap_entry_t *jl_typemap_level_assoc_exact(jl_typemap_level_t *cache, jl_v
         jl_value_t *a1 = (offs == 0 ? arg1 : args[offs - 1]);
         jl_value_t *ty = jl_typeof(a1);
         assert(jl_is_datatype(ty));
-        jl_array_t *targ = jl_atomic_load_relaxed(&cache->targ);
-        if (targ != (jl_array_t*)jl_an_empty_vec_any && is_cache_leaf(a1, 1)) {
+        jl_genericmemory_t *targ = jl_atomic_load_relaxed(&cache->targ);
+        if (targ != (jl_genericmemory_t*)jl_an_empty_memory_any && is_cache_leaf(a1, 1)) {
             jl_typename_t *name = a1 == jl_bottom_type ? jl_typeofbottom_type->name : ((jl_datatype_t*)a1)->name;
             jl_value_t *ml_or_cache = mtcache_hash_lookup(targ, (jl_value_t*)name);
-            if (jl_is_array(ml_or_cache))
-                ml_or_cache = mtcache_hash_lookup((jl_array_t*)ml_or_cache, a1);
+            if (jl_is_genericmemory(ml_or_cache))
+                ml_or_cache = mtcache_hash_lookup((jl_genericmemory_t*)ml_or_cache, a1);
             jl_typemap_entry_t *ml = jl_typemap_assoc_exact(ml_or_cache, arg1, args, n, offs+1, world);
             if (ml) return ml;
         }
-        jl_array_t *cachearg1 = jl_atomic_load_relaxed(&cache->arg1);
-        if (cachearg1 != (jl_array_t*)jl_an_empty_vec_any && is_cache_leaf(ty, 0)) {
+        jl_genericmemory_t *cachearg1 = jl_atomic_load_relaxed(&cache->arg1);
+        if (cachearg1 != (jl_genericmemory_t*)jl_an_empty_memory_any && is_cache_leaf(ty, 0)) {
             jl_typename_t *name = ty == jl_bottom_type ? jl_typeofbottom_type->name : ((jl_datatype_t*)ty)->name;
             jl_value_t *ml_or_cache = mtcache_hash_lookup(cachearg1, (jl_value_t*)name);
-            if (jl_is_array(ml_or_cache))
-                ml_or_cache = mtcache_hash_lookup((jl_array_t*)ml_or_cache, ty);
+            if (jl_is_genericmemory(ml_or_cache))
+                ml_or_cache = mtcache_hash_lookup((jl_genericmemory_t*)ml_or_cache, ty);
             jl_typemap_entry_t *ml = jl_typemap_assoc_exact((jl_typemap_t*)ml_or_cache, arg1, args, n, offs+1, world);
             if (ml) return ml;
         }
-        jl_array_t *tname = jl_atomic_load_relaxed(&cache->tname);
-        if (jl_is_kind(ty) && tname != (jl_array_t*)jl_an_empty_vec_any) {
+        jl_genericmemory_t *tname = jl_atomic_load_relaxed(&cache->tname);
+        if (jl_is_kind(ty) && tname != (jl_genericmemory_t*)jl_an_empty_memory_any) {
             jl_value_t *name = jl_type_extract_name(a1);
             if (name) {
                 if (ty != (jl_value_t*)jl_datatype_type)
@@ -1235,8 +1236,8 @@ jl_typemap_entry_t *jl_typemap_level_assoc_exact(jl_typemap_level_t *cache, jl_v
             }
             else {
                 // couldn't figure out unique `name` initial point, so must scan all for matches
-                size_t i, l = jl_array_len(tname);
-                _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*)jl_array_ptr_data(tname);
+                size_t i, l = tname->length;
+                _Atomic(jl_typemap_t*) *data = (_Atomic(jl_typemap_t*)*) jl_genericmemory_ptr_data(tname);
                 JL_GC_PUSH1(&tname);
                 for (i = 1; i < l; i += 2) {
                     jl_typemap_t *ml_or_cache = jl_atomic_load_relaxed(&data[i]);
@@ -1251,8 +1252,8 @@ jl_typemap_entry_t *jl_typemap_level_assoc_exact(jl_typemap_level_t *cache, jl_v
                 JL_GC_POP();
             }
         }
-        jl_array_t *name1 = jl_atomic_load_relaxed(&cache->name1);
-        if (name1 != (jl_array_t*)jl_an_empty_vec_any) {
+        jl_genericmemory_t *name1 = jl_atomic_load_relaxed(&cache->name1);
+        if (name1 != (jl_genericmemory_t*)jl_an_empty_memory_any) {
             while (1) {
                 name1 = jl_atomic_load_relaxed(&cache->name1); // reload after tree descent (which may hit safepoints)
                 jl_typemap_t *ml_or_cache = mtcache_hash_lookup(
@@ -1297,23 +1298,23 @@ static jl_typemap_level_t *jl_new_typemap_level(void)
     jl_typemap_level_t *cache =
         (jl_typemap_level_t*)jl_gc_alloc(ct->ptls, sizeof(jl_typemap_level_t),
                                          jl_typemap_level_type);
-    jl_atomic_store_relaxed(&cache->arg1, (jl_array_t*)jl_an_empty_vec_any);
-    jl_atomic_store_relaxed(&cache->targ, (jl_array_t*)jl_an_empty_vec_any);
-    jl_atomic_store_relaxed(&cache->name1, (jl_array_t*)jl_an_empty_vec_any);
-    jl_atomic_store_relaxed(&cache->tname, (jl_array_t*)jl_an_empty_vec_any);
+    jl_atomic_store_relaxed(&cache->arg1, (jl_genericmemory_t*)jl_an_empty_memory_any);
+    jl_atomic_store_relaxed(&cache->targ, (jl_genericmemory_t*)jl_an_empty_memory_any);
+    jl_atomic_store_relaxed(&cache->name1, (jl_genericmemory_t*)jl_an_empty_memory_any);
+    jl_atomic_store_relaxed(&cache->tname, (jl_genericmemory_t*)jl_an_empty_memory_any);
     jl_atomic_store_relaxed(&cache->linear, (jl_typemap_entry_t*)jl_nothing);
     jl_atomic_store_relaxed(&cache->any, jl_nothing);
     return cache;
 }
 
-static void jl_typemap_array_insert_(
-        jl_typemap_t *map, _Atomic(jl_array_t*) *pcache, jl_value_t *key, jl_typemap_entry_t *newrec,
+static void jl_typemap_memory_insert_(
+        jl_typemap_t *map, _Atomic(jl_genericmemory_t*) *pcache, jl_value_t *key, jl_typemap_entry_t *newrec,
         jl_value_t *parent, int8_t tparam, int8_t offs, jl_value_t *doublesplit);
 
 static jl_value_t *jl_method_convert_list_to_cache(
         jl_typemap_t *map, jl_typemap_entry_t *ml, int8_t tparam, int8_t offs, int8_t doublesplit)
 {
-    jl_value_t *cache = doublesplit ? jl_an_empty_vec_any : (jl_value_t*)jl_new_typemap_level();
+    jl_value_t *cache = doublesplit ? jl_an_empty_memory_any : (jl_value_t*)jl_new_typemap_level();
     jl_typemap_entry_t *next = NULL;
     JL_GC_PUSH3(&cache, &next, &ml);
     while (ml != (void*)jl_nothing) {
@@ -1336,7 +1337,7 @@ static jl_value_t *jl_method_convert_list_to_cache(
                 assert(jl_is_type_type(key));
                 key = jl_tparam0(key);
             }
-            jl_typemap_array_insert_(map, (_Atomic(jl_array_t*)*)&cache, key, ml, NULL, 0, offs, NULL);
+            jl_typemap_memory_insert_(map, (_Atomic(jl_genericmemory_t*)*)&cache, key, ml, NULL, 0, offs, NULL);
         }
         else
             jl_typemap_level_insert_(map, (jl_typemap_level_t*)cache, ml, offs);
@@ -1371,9 +1372,9 @@ static void jl_typemap_insert_generic(
         jl_typemap_entry_t *newrec, int8_t tparam, int8_t offs, jl_value_t *doublesplit)
 {
     jl_value_t *ml = jl_atomic_load_relaxed(pml);
-    if (jl_is_array(ml)) {
+    if (jl_is_genericmemory(ml)) {
         assert(doublesplit);
-        jl_typemap_array_insert_(map, (_Atomic(jl_array_t*)*)pml, doublesplit, newrec, parent, 0, offs, NULL);
+        jl_typemap_memory_insert_(map, (_Atomic(jl_genericmemory_t*)*)pml, doublesplit, newrec, parent, 0, offs, NULL);
         return;
     }
     if (jl_typeof(ml) == (jl_value_t*)jl_typemap_level_type) {
@@ -1389,7 +1390,7 @@ static void jl_typemap_insert_generic(
         jl_atomic_store_release(pml, ml);
         jl_gc_wb(parent, ml);
         if (doublesplit)
-            jl_typemap_array_insert_(map, (_Atomic(jl_array_t*)*)pml, doublesplit, newrec, parent, 0, offs, NULL);
+            jl_typemap_memory_insert_(map, (_Atomic(jl_genericmemory_t*)*)pml, doublesplit, newrec, parent, 0, offs, NULL);
         else
             jl_typemap_level_insert_(map, (jl_typemap_level_t*)ml, newrec, offs);
         return;
@@ -1399,16 +1400,16 @@ static void jl_typemap_insert_generic(
         parent, newrec);
 }
 
-static void jl_typemap_array_insert_(
-        jl_typemap_t *map, _Atomic(jl_array_t*) *pcache, jl_value_t *key, jl_typemap_entry_t *newrec,
+static void jl_typemap_memory_insert_(
+        jl_typemap_t *map, _Atomic(jl_genericmemory_t*) *pcache, jl_value_t *key, jl_typemap_entry_t *newrec,
         jl_value_t *parent, int8_t tparam, int8_t offs, jl_value_t *doublesplit)
 {
-    jl_array_t *cache = jl_atomic_load_relaxed(pcache);
+    jl_genericmemory_t *cache = jl_atomic_load_relaxed(pcache);
     _Atomic(jl_value_t*) *pml = mtcache_hash_lookup_bp(cache, key);
     if (pml == NULL)
         mtcache_hash_insert(pcache, parent, key, (jl_typemap_t*)newrec);
     else
-        jl_typemap_insert_generic(map, pml, (jl_value_t*)cache, newrec, tparam, offs + (doublesplit ? 0 : 1), doublesplit);
+        jl_typemap_insert_generic(map, pml, (jl_value_t*) cache, newrec, tparam, offs + (doublesplit ? 0 : 1), doublesplit);
 }
 
 static void jl_typemap_level_insert_(
@@ -1451,13 +1452,13 @@ static void jl_typemap_level_insert_(
             jl_value_t *a0 = jl_tparam0(t1);
             if (is_cache_leaf(a0, 1)) {
                 jl_typename_t *name = a0 == jl_bottom_type ? jl_typeofbottom_type->name : ((jl_datatype_t*)a0)->name;
-                jl_typemap_array_insert_(map, &cache->targ, (jl_value_t*)name, newrec, (jl_value_t*)cache, 1, offs, jl_is_datatype(name->wrapper) ? NULL : a0);
+                jl_typemap_memory_insert_(map, &cache->targ, (jl_value_t*)name, newrec, (jl_value_t*)cache, 1, offs, jl_is_datatype(name->wrapper) ? NULL : a0);
                 return;
             }
         }
         if (is_cache_leaf(t1, 0)) {
             jl_typename_t *name = t1 == jl_bottom_type ? jl_typeofbottom_type->name : ((jl_datatype_t*)t1)->name;
-            jl_typemap_array_insert_(map, &cache->arg1, (jl_value_t*)name, newrec, (jl_value_t*)cache, 0, offs, jl_is_datatype(name->wrapper) ? NULL : t1);
+            jl_typemap_memory_insert_(map, &cache->arg1, (jl_value_t*)name, newrec, (jl_value_t*)cache, 0, offs, jl_is_datatype(name->wrapper) ? NULL : t1);
             return;
         }
 
@@ -1467,12 +1468,12 @@ static void jl_typemap_level_insert_(
         if (jl_is_type_type(t1)) {
             a0 = jl_type_extract_name(jl_tparam0(t1));
             jl_datatype_t *super = a0 ? (jl_datatype_t*)jl_unwrap_unionall(((jl_typename_t*)a0)->wrapper) : jl_any_type;
-            jl_typemap_array_insert_(map, &cache->tname, (jl_value_t*)super->name, newrec, (jl_value_t*)cache, 1, offs, NULL);
+            jl_typemap_memory_insert_(map, &cache->tname, (jl_value_t*)super->name, newrec, (jl_value_t*)cache, 1, offs, NULL);
             return;
         }
         a0 = jl_type_extract_name(t1);
         if (a0 && a0 != (jl_value_t*)jl_any_type->name) {
-            jl_typemap_array_insert_(map, &cache->name1, a0, newrec, (jl_value_t*)cache, 0, offs, NULL);
+            jl_typemap_memory_insert_(map, &cache->name1, a0, newrec, (jl_value_t*)cache, 0, offs, NULL);
             return;
         }
     }
diff --git a/stdlib/Base64/src/buffer.jl b/stdlib/Base64/src/buffer.jl
index 44a9c0931ac95..bc8c338bad19d 100644
--- a/stdlib/Base64/src/buffer.jl
+++ b/stdlib/Base64/src/buffer.jl
@@ -2,12 +2,12 @@
 
 # Data buffer for pipes.
 mutable struct Buffer
-    data::Vector{UInt8}
+    data::Memory{UInt8}
     ptr::Ptr{UInt8}
     size::Int
 
     function Buffer(bufsize)
-        data = Vector{UInt8}(undef, bufsize)
+        data = Memory{UInt8}(undef, bufsize)
         return new(data, pointer(data), 0)
     end
 end
@@ -18,7 +18,7 @@ Base.setindex!(buffer::Buffer, v::UInt8, i::Integer) = unsafe_store!(buffer.ptr,
 Base.firstindex(buffer::Buffer) = 1
 Base.lastindex(buffer::Buffer) = buffer.size
 Base.pointer(buffer::Buffer) = buffer.ptr
-capacity(buffer::Buffer) = Int(pointer(buffer.data, lastindex(buffer.data) + 1) - buffer.ptr)
+capacity(buffer::Buffer) = Int(pointer(buffer.data, lastindex(buffer.data)) - buffer.ptr) + 1
 
 function consumed!(buffer::Buffer, n::Integer)
     @assert n ≤ buffer.size
diff --git a/stdlib/Mmap/src/Mmap.jl b/stdlib/Mmap/src/Mmap.jl
index 9dd02d5aa9d04..6d328c40cd7b3 100644
--- a/stdlib/Mmap/src/Mmap.jl
+++ b/stdlib/Mmap/src/Mmap.jl
@@ -367,8 +367,9 @@ Forces synchronization between the in-memory version of a memory-mapped `Array`
 [`BitArray`](@ref) and the on-disk version.
 """
 function sync!(m::Array, flags::Integer=MS_SYNC)
-    offset = rem(UInt(pointer(m)), PAGESIZE)
-    ptr = pointer(m) - offset
+    ptr = pointer(m)
+    offset = rem(UInt(ptr), PAGESIZE)
+    ptr = ptr - offset
     mmaplen = sizeof(m) + offset
     GC.@preserve m @static if Sys.isunix()
         systemerror("msync",
@@ -429,8 +430,9 @@ Advises the kernel on the intended usage of the memory-mapped `array`, with the
 `flag` being one of the available `MADV_*` constants.
 """
 function madvise!(m::Array, flag::Integer=MADV_NORMAL)
-    offset = rem(UInt(pointer(m)), PAGESIZE)
-    ptr = pointer(m) - offset
+    ptr = pointer(m)
+    offset = rem(UInt(ptr), PAGESIZE)
+    ptr = ptr - offset
     mmaplen = sizeof(m) + offset
     GC.@preserve m begin
         systemerror("madvise",
diff --git a/stdlib/Profile/test/allocs.jl b/stdlib/Profile/test/allocs.jl
index ae0cbab945f01..e77e5bc826612 100644
--- a/stdlib/Profile/test/allocs.jl
+++ b/stdlib/Profile/test/allocs.jl
@@ -143,12 +143,17 @@ end
 end
 
 @testset "alloc profiler catches allocs from buffer resize" begin
+    f(a) = for _ in 1:100; push!(a, 1); end
+    f(Int[])
+    resize!(Int[], 1)
     a = Int[]
-    Allocs.@profile sample_rate=1 for _ in 1:100; push!(a, 1); end
-
+    Allocs.clear()
+    Allocs.@profile sample_rate=1 f(a)
+    Allocs.@profile sample_rate=1 resize!(a, 1_000_000) # 4MB
     prof = Allocs.fetch()
     Allocs.clear()
 
-    @test length(prof.allocs) >= 1
-    @test length([a for a in prof.allocs if a.type == Profile.Allocs.BufferType]) >= 1
+    @test 3 <= length(prof.allocs) <= 10
+    @test length([a for a in prof.allocs if a.type === Allocs.BufferType]) == 1
+    @test length([a for a in prof.allocs if a.type === Memory{Int}]) >= 2
 end
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index fbd02cc1a78dd..8e8290569cdb7 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -288,6 +288,31 @@ function serialize(s::AbstractSerializer, a::SubArray{T,N,A}) where {T,N,A<:Arra
     serialize_any(s, b)
 end
 
+serialize(s::AbstractSerializer, m::GenericMemory) = error("GenericMemory{:atomic} currently cannot be serialized")
+function serialize(s::AbstractSerializer, m::Memory)
+    serialize_cycle_header(s, m) && return
+    serialize(s, length(m))
+    elty = eltype(m)
+    if isbitstype(elty)
+        serialize_array_data(s.io, m)
+    else
+        sizehint!(s.table, div(length(m),4))  # prepare for lots of pointers
+        @inbounds for i in eachindex(m)
+            if isassigned(m, i)
+                serialize(s, m[i])
+            else
+                writetag(s.io, UNDEFREF_TAG)
+            end
+        end
+    end
+end
+
+function serialize(s::AbstractSerializer, x::GenericMemoryRef)
+    serialize_type(s, typeof(x))
+    serialize(s, getfield(x, :mem))
+    serialize(s, Base.memoryrefoffset(x))
+end
+
 function serialize(s::AbstractSerializer, ss::String)
     len = sizeof(ss)
     if len > 7
@@ -511,7 +536,7 @@ function serialize_typename(s::AbstractSerializer, t::Core.TypeName)
     serialize(s, primary.super)
     serialize(s, primary.parameters)
     serialize(s, primary.types)
-    serialize(s, isdefined(primary, :instance))
+    serialize(s, Base.issingletontype(primary))
     serialize(s, t.flags & 0x1 == 0x1) # .abstract
     serialize(s, t.flags & 0x2 == 0x2) # .mutable
     serialize(s, Int32(length(primary.types) - t.n_uninitialized))
@@ -654,6 +679,11 @@ end
 
 serialize(s::AbstractSerializer, @nospecialize(x)) = serialize_any(s, x)
 
+function serialize(s::AbstractSerializer, x::Core.AddrSpace)
+    serialize_type(s, typeof(x))
+    write(s.io, Core.bitcast(UInt8, x))
+end
+
 function serialize_any(s::AbstractSerializer, @nospecialize(x))
     tag = sertag(x)
     if tag > 0
@@ -1276,7 +1306,7 @@ function deserialize_array(s::AbstractSerializer)
     return A
 end
 
-function deserialize_fillarray!(A::Array{T}, s::AbstractSerializer) where {T}
+function deserialize_fillarray!(A::Union{Array{T},Memory{T}}, s::AbstractSerializer) where {T}
     for i = eachindex(A)
         tag = Int32(read(s.io, UInt8)::UInt8)
         if tag != UNDEFREF_TAG
@@ -1286,6 +1316,48 @@ function deserialize_fillarray!(A::Array{T}, s::AbstractSerializer) where {T}
     return A
 end
 
+function deserialize(s::AbstractSerializer, X::Type{Memory{T}} where T)
+    slot = pop!(s.pending_refs) # e.g. deserialize_cycle
+    n = deserialize(s)::Int
+    elty = eltype(X)
+    if isbitstype(elty)
+        A = X(undef, n)
+        if X === Memory{Bool}
+            i = 1
+            while i <= n
+                b = read(s.io, UInt8)::UInt8
+                v = (b >> 7) != 0
+                count = b & 0x7f
+                nxt = i + count
+                while i < nxt
+                    A[i] = v
+                    i += 1
+                end
+            end
+        else
+            A = read!(s.io, A)::X
+        end
+        s.table[slot] = A
+        return A
+    end
+    A = X(undef, n)
+    s.table[slot] = A
+    sizehint!(s.table, s.counter + div(n, 4))
+    deserialize_fillarray!(A, s)
+    return A
+end
+
+function deserialize(s::AbstractSerializer, X::Type{MemoryRef{T}} where T)
+    x = Core.memoryref(deserialize(s))::X
+    i = deserialize(s)::Int
+    i == 2 || (x = Core.memoryref(x, i, true))
+    return x::X
+end
+
+function deserialize(s::AbstractSerializer, X::Type{Core.AddrSpace{M}} where M)
+    Core.bitcast(X, read(s.io, UInt8))
+end
+
 function deserialize_expr(s::AbstractSerializer, len)
     e = Expr(:temp)
     resolve_ref_immediately(s, e)
@@ -1341,7 +1413,7 @@ function deserialize_typename(s::AbstractSerializer, number)
         tn.max_methods = maxm
         if has_instance
             ty = ty::DataType
-            if !Base.issingletontype(ty)
+            if !isdefined(ty, :instance)
                 singleton = ccall(:jl_new_struct, Any, (Any, Any...), ty)
                 # use setfield! directly to avoid `fieldtype` lowering expecting to see a Singleton object already on ty
                 ccall(:jl_set_nth_field, Cvoid, (Any, Csize_t, Any), ty, Base.fieldindex(DataType, :instance)-1, singleton)
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 1bf61c856cb76..d93c20f34209e 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1108,23 +1108,23 @@ end
 @testset "sizeof" begin
     let arrUInt8 = zeros(UInt8, 10)
         @test sizeof(arrUInt8) == 10
-        @test Core.sizeof(arrUInt8) == 10
+        @test Core.sizeof(arrUInt8) == 3 * sizeof(Int)
     end
 
     let arrUInt32 = zeros(UInt32, 10)
         @test sizeof(arrUInt32) == 40
-        @test Core.sizeof(arrUInt32) == 40
+        @test Core.sizeof(arrUInt32) == 3 * sizeof(Int)
     end
 
     let arrFloat64 = zeros(Float64, 10, 10)
         @test sizeof(arrFloat64) == 800
-        @test Core.sizeof(arrFloat64) == 800
+        @test Core.sizeof(arrFloat64) == 4 * sizeof(Int)
     end
 
     # Test union arrays (Issue #23321)
     let arrUnion = Union{Int64, Cvoid}[rand(Bool) ? k : nothing for k = 1:10]
         @test sizeof(arrUnion) == 80
-        @test Core.sizeof(arrUnion) == 80
+        @test Core.sizeof(arrUnion) == 3 * sizeof(Int)
     end
 
     # Test non-power of 2 types (Issue #35884)
@@ -1138,7 +1138,7 @@ end
     let arrayOfUInt48 = [a, b, c]
         f35884(x) = sizeof(x)
         @test f35884(arrayOfUInt48) == 24
-        @test Core.sizeof(arrayOfUInt48) == 24
+        @test Core.sizeof(arrayOfUInt48) == 3 * sizeof(Int)
     end
 end
 
@@ -1164,7 +1164,7 @@ function Base.getindex(S::Strider{<:Any,N}, I::Vararg{Int,N}) where {N}
 end
 Base.strides(S::Strider) = S.strides
 Base.elsize(::Type{<:Strider{T}}) where {T} = Base.elsize(Vector{T})
-Base.unsafe_convert(::Type{Ptr{T}}, S::Strider{T}) where {T} = pointer(S.data, S.offset)
+Base.cconvert(::Type{Ptr{T}}, S::Strider{T}) where {T} = MemoryRef(S.data.ref, S.offset)
 
 @testset "Simple 3d strided views and permutes" for sz in ((5, 3, 2), (7, 11, 13))
     A = collect(reshape(1:prod(sz), sz))
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index aa54efab2c835..c1681532d26ea 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -513,9 +513,9 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
             @test popfirst!(got) == "       32     Base.invokelatest(g, x)"
         end
         if Sys.WORD_SIZE == 64
-            @test popfirst!(got) == "       48     []"
-        else
             @test popfirst!(got) == "       32     []"
+        else
+            @test popfirst!(got) == "       16     []"
         end
         @test popfirst!(got) == "        - end"
         @test popfirst!(got) == "        - f(1.23)"
@@ -543,7 +543,7 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
                 @test occursin("llvm.module.flags", code)
                 @test !occursin("llvm.dbg.cu", code)
                 @test !occursin("int.jl", code)
-                @test !occursin("\"Int64\"", code)
+                @test !occursin("name: \"Int64\"", code)
             end
             let code = readchomperrors(`$exename -g1 -E "@eval Int64(1)+Int64(1)"`)
                 @test code[1]
@@ -551,7 +551,7 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
                 @test occursin("llvm.module.flags", code)
                 @test occursin("llvm.dbg.cu", code)
                 @test occursin("int.jl", code)
-                @test !occursin("\"Int64\"", code)
+                @test !occursin("name: \"Int64\"", code)
             end
             let code = readchomperrors(`$exename -g2 -E "@eval Int64(1)+Int64(1)"`)
                 @test code[1]
@@ -559,7 +559,7 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
                 @test occursin("llvm.module.flags", code)
                 @test occursin("llvm.dbg.cu", code)
                 @test occursin("int.jl", code)
-                @test occursin("\"Int64\"", code)
+                @test occursin("name: \"Int64\"", code)
             end
         end
     end
diff --git a/test/compiler/EscapeAnalysis/EscapeAnalysis.jl b/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
index 04729ab818420..fc2d6f774cd9d 100644
--- a/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
+++ b/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
@@ -39,10 +39,8 @@ let utils_ex = quote
     Core.eval(@__MODULE__, utils_ex)
 end
 
-using Core.Compiler: alloc_array_ndims
 using .EscapeAnalysis:
-    EscapeInfo, IndexableElements, IndexableFields,
-    array_resize_info, is_array_copy, normalize
+    EscapeInfo, IndexableElements, IndexableFields, normalize
 
 isϕ(@nospecialize x) = isa(x, Core.PhiNode)
 function with_normalized_name(@nospecialize(f), @nospecialize(x))
@@ -54,11 +52,11 @@ function with_normalized_name(@nospecialize(f), @nospecialize(x))
     return false
 end
 isarrayalloc(@nospecialize x) =
-    with_normalized_name(nn::Symbol->!isnothing(alloc_array_ndims(nn)), x)
+    with_normalized_name(nn::Symbol->false, x)
 isarrayresize(@nospecialize x) =
-    with_normalized_name(nn::Symbol->!isnothing(array_resize_info(nn)), x)
+    with_normalized_name(nn::Symbol->false, x)
 isarraycopy(@nospecialize x) =
-    with_normalized_name(nn::Symbol->is_array_copy(nn), x)
+    with_normalized_name(nn::Symbol->false, x)
 """
     is_load_forwardable(x::EscapeInfo) -> Bool
 
@@ -1508,7 +1506,7 @@ end
 
 @testset "array primitives" begin
     # arrayref
-    let result = code_escapes((Vector{String},Int)) do xs, i
+    @test_skip let result = code_escapes((Vector{String},Int)) do xs, i
             s = Base.arrayref(true, xs, i)
             return s
         end
@@ -1517,7 +1515,7 @@ end
         @test has_thrown_escape(result.state[Argument(2)])      # xs
         @test !has_return_escape(result.state[Argument(3)], r)  # i
     end
-    let result = code_escapes((Vector{String},Int)) do xs, i
+    @test_skip let result = code_escapes((Vector{String},Int)) do xs, i
             s = Base.arrayref(false, xs, i)
             return s
         end
@@ -1526,28 +1524,28 @@ end
         @test !has_thrown_escape(result.state[Argument(2)])     # xs
         @test !has_return_escape(result.state[Argument(3)], r)  # i
     end
-    let result = code_escapes((Vector{String},Bool)) do xs, i
+    @test_skip let result = code_escapes((Vector{String},Bool)) do xs, i
             c = Base.arrayref(true, xs, i) # TypeError will happen here
             return c
         end
         t = only(findall(iscall((result.ir, Base.arrayref)), result.ir.stmts.stmt))
         @test has_thrown_escape(result.state[Argument(2)], t) # xs
     end
-    let result = code_escapes((String,Int)) do xs, i
+    @test_skip let result = code_escapes((String,Int)) do xs, i
             c = Base.arrayref(true, xs, i) # TypeError will happen here
             return c
         end
         t = only(findall(iscall((result.ir, Base.arrayref)), result.ir.stmts.stmt))
         @test has_thrown_escape(result.state[Argument(2)], t) # xs
     end
-    let result = code_escapes((AbstractVector{String},Int)) do xs, i
+    @test_skip let result = code_escapes((AbstractVector{String},Int)) do xs, i
             c = Base.arrayref(true, xs, i) # TypeError may happen here
             return c
         end
         t = only(findall(iscall((result.ir, Base.arrayref)), result.ir.stmts.stmt))
         @test has_thrown_escape(result.state[Argument(2)], t) # xs
     end
-    let result = code_escapes((Vector{String},Any)) do xs, i
+    @test_skip let result = code_escapes((Vector{String},Any)) do xs, i
             c = Base.arrayref(true, xs, i) # TypeError may happen here
             return c
         end
@@ -1556,7 +1554,7 @@ end
     end
 
     # arrayset
-    let result = code_escapes((Vector{String},String,Int,)) do xs, x, i
+    @test_skip let result = code_escapes((Vector{String},String,Int,)) do xs, x, i
             Base.arrayset(true, xs, x, i)
             return xs
         end
@@ -1565,7 +1563,7 @@ end
         @test has_thrown_escape(result.state[Argument(2)])    # xs
         @test has_return_escape(result.state[Argument(3)], r) # x
     end
-    let result = code_escapes((Vector{String},String,Int,)) do xs, x, i
+    @test_skip let result = code_escapes((Vector{String},String,Int,)) do xs, x, i
             Base.arrayset(false, xs, x, i)
             return xs
         end
@@ -1574,7 +1572,7 @@ end
         @test !has_thrown_escape(result.state[Argument(2)])    # xs
         @test has_return_escape(result.state[Argument(3)], r) # x
     end
-    let result = code_escapes((String,String,String,)) do s, t, u
+    @test_skip let result = code_escapes((String,String,String,)) do s, t, u
             xs = Vector{String}(undef, 3)
             Base.arrayset(true, xs, s, 1)
             Base.arrayset(true, xs, t, 2)
@@ -1588,7 +1586,7 @@ end
             @test has_return_escape(result.state[Argument(i)], r)
         end
     end
-    let result = code_escapes((Vector{String},String,Bool,)) do xs, x, i
+    @test_skip let result = code_escapes((Vector{String},String,Bool,)) do xs, x, i
             Base.arrayset(true, xs, x, i) # TypeError will happen here
             return xs
         end
@@ -1596,7 +1594,7 @@ end
         @test has_thrown_escape(result.state[Argument(2)], t) # xs
         @test has_thrown_escape(result.state[Argument(3)], t) # x
     end
-    let result = code_escapes((String,String,Int,)) do xs, x, i
+    @test_skip let result = code_escapes((String,String,Int,)) do xs, x, i
             Base.arrayset(true, xs, x, i) # TypeError will happen here
             return xs
         end
@@ -1604,7 +1602,7 @@ end
         @test has_thrown_escape(result.state[Argument(2)], t) # xs::String
         @test has_thrown_escape(result.state[Argument(3)], t) # x::String
     end
-    let result = code_escapes((AbstractVector{String},String,Int,)) do xs, x, i
+    @test_skip let result = code_escapes((AbstractVector{String},String,Int,)) do xs, x, i
             Base.arrayset(true, xs, x, i) # TypeError may happen here
             return xs
         end
@@ -1612,7 +1610,7 @@ end
         @test has_thrown_escape(result.state[Argument(2)], t) # xs
         @test has_thrown_escape(result.state[Argument(3)], t) # x
     end
-    let result = code_escapes((Vector{String},AbstractString,Int,)) do xs, x, i
+    @test_skip let result = code_escapes((Vector{String},AbstractString,Int,)) do xs, x, i
             Base.arrayset(true, xs, x, i) # TypeError may happen here
             return xs
         end
@@ -1622,7 +1620,7 @@ end
     end
 
     # arrayref and arrayset
-    let result = code_escapes() do
+    @test_skip let result = code_escapes() do
             a = Vector{Vector{Any}}(undef, 1)
             b = Any[]
             a[1] = b
@@ -1638,7 +1636,7 @@ end
         @test !has_return_escape(result.state[SSAValue(ai)], r)
         @test has_return_escape(result.state[SSAValue(bi)], r)
     end
-    let result = code_escapes() do
+    @test_skip let result = code_escapes() do
             a = Vector{Vector{Any}}(undef, 1)
             b = Any[]
             a[1] = b
@@ -1654,7 +1652,7 @@ end
         @test has_return_escape(result.state[SSAValue(ai)], r)
         @test has_return_escape(result.state[SSAValue(bi)], r)
     end
-    let result = code_escapes((Vector{Any},String,Int,Int)) do xs, s, i, j
+    @test_skip let result = code_escapes((Vector{Any},String,Int,Int)) do xs, s, i, j
             x = SafeRef(s)
             xs[i] = x
             xs[j] # potential error
@@ -1666,19 +1664,19 @@ end
     end
 
     # arraysize
-    let result = code_escapes((Vector{Any},)) do xs
+    @test_skip let result = code_escapes((Vector{Any},)) do xs
             Core.arraysize(xs, 1)
         end
         t = only(findall(iscall((result.ir, Core.arraysize)), result.ir.stmts.stmt))
         @test !has_thrown_escape(result.state[Argument(2)], t)
     end
-    let result = code_escapes((Vector{Any},Int,)) do xs, dim
+    @test_skip let result = code_escapes((Vector{Any},Int,)) do xs, dim
             Core.arraysize(xs, dim)
         end
         t = only(findall(iscall((result.ir, Core.arraysize)), result.ir.stmts.stmt))
         @test !has_thrown_escape(result.state[Argument(2)], t)
     end
-    let result = code_escapes((Any,)) do xs
+    @test_skip let result = code_escapes((Any,)) do xs
             Core.arraysize(xs, 1)
         end
         t = only(findall(iscall((result.ir, Core.arraysize)), result.ir.stmts.stmt))
@@ -1686,19 +1684,19 @@ end
     end
 
     # arraylen
-    let result = code_escapes((Vector{Any},)) do xs
+    @test_skip let result = code_escapes((Vector{Any},)) do xs
             Base.arraylen(xs)
         end
         t = only(findall(iscall((result.ir, Base.arraylen)), result.ir.stmts.stmt))
         @test !has_thrown_escape(result.state[Argument(2)], t) # xs
     end
-    let result = code_escapes((String,)) do xs
+    @test_skip let result = code_escapes((String,)) do xs
             Base.arraylen(xs)
         end
         t = only(findall(iscall((result.ir, Base.arraylen)), result.ir.stmts.stmt))
         @test has_thrown_escape(result.state[Argument(2)], t) # xs
     end
-    let result = code_escapes((Vector{Any},)) do xs
+    @test_skip let result = code_escapes((Vector{Any},)) do xs
             Base.arraylen(xs, 1)
         end
         t = only(findall(iscall((result.ir, Base.arraylen)), result.ir.stmts.stmt))
@@ -1707,7 +1705,7 @@ end
 
     # array resizing
     # without BoundsErrors
-    let result = code_escapes((Vector{Any},String)) do xs, x
+    @test_skip let result = code_escapes((Vector{Any},String)) do xs, x
             @ccall jl_array_grow_beg(xs::Any, 2::UInt)::Cvoid
             xs[1] = x
             xs
@@ -1716,7 +1714,7 @@ end
         @test !has_thrown_escape(result.state[Argument(2)], t) # xs
         @test !has_thrown_escape(result.state[Argument(3)], t) # x
     end
-    let result = code_escapes((Vector{Any},String)) do xs, x
+    @test_skip let result = code_escapes((Vector{Any},String)) do xs, x
             @ccall jl_array_grow_end(xs::Any, 2::UInt)::Cvoid
             xs[1] = x
             xs
@@ -1726,7 +1724,7 @@ end
         @test !has_thrown_escape(result.state[Argument(3)], t) # x
     end
     # with possible BoundsErrors
-    let result = code_escapes((String,)) do x
+    @test_skip let result = code_escapes((String,)) do x
             xs = Any[1,2,3]
             xs[3] = x
             @ccall jl_array_del_beg(xs::Any, 2::UInt)::Cvoid # can potentially throw
@@ -1737,7 +1735,7 @@ end
         @test has_thrown_escape(result.state[SSAValue(i)], t) # xs
         @test has_thrown_escape(result.state[Argument(2)], t) # x
     end
-    let result = code_escapes((String,)) do x
+    @test_skip let result = code_escapes((String,)) do x
             xs = Any[1,2,3]
             xs[1] = x
             @ccall jl_array_del_end(xs::Any, 2::UInt)::Cvoid # can potentially throw
@@ -1748,7 +1746,7 @@ end
         @test has_thrown_escape(result.state[SSAValue(i)], t) # xs
         @test has_thrown_escape(result.state[Argument(2)], t) # x
     end
-    let result = code_escapes((String,)) do x
+    @test_skip let result = code_escapes((String,)) do x
             xs = Any[x]
             @ccall jl_array_grow_at(xs::Any, 1::UInt, 2::UInt)::Cvoid # can potentially throw
         end
@@ -1757,7 +1755,7 @@ end
         @test has_thrown_escape(result.state[SSAValue(i)], t) # xs
         @test has_thrown_escape(result.state[Argument(2)], t) # x
     end
-    let result = code_escapes((String,)) do x
+    @test_skip let result = code_escapes((String,)) do x
             xs = Any[x]
             @ccall jl_array_del_at(xs::Any, 1::UInt, 2::UInt)::Cvoid # can potentially throw
         end
@@ -1768,15 +1766,15 @@ end
     end
 
     # array copy
-    let result = code_escapes((Vector{Any},)) do xs
+    @test_skip let result = code_escapes((Vector{Any},)) do xs
             return copy(xs)
         end
         i = only(findall(isarraycopy, result.ir.stmts.stmt))
         r = only(findall(isreturn, result.ir.stmts.stmt))
         @test has_return_escape(result.state[SSAValue(i)], r)
-        @test_broken !has_return_escape(result.state[Argument(2)], r)
+        @test !has_return_escape(result.state[Argument(2)], r)
     end
-    let result = code_escapes((String,)) do s
+    @test_skip let result = code_escapes((String,)) do s
             xs = String[s]
             xs′ = copy(xs)
             return xs′[1]
@@ -1788,7 +1786,7 @@ end
         @test !has_return_escape(result.state[SSAValue(i2)])
         @test has_return_escape(result.state[Argument(2)], r) # s
     end
-    let result = code_escapes((Vector{Any},)) do xs
+    @test_skip let result = code_escapes((Vector{Any},)) do xs
             xs′ = copy(xs)
             return xs′[1] # may potentially throw BoundsError, should escape `xs` conservatively (i.e. escape its elements)
         end
@@ -1800,7 +1798,7 @@ end
         @test has_thrown_escape(result.state[Argument(2)], ref)
         @test has_return_escape(result.state[Argument(2)], ret)
     end
-    let result = code_escapes((String,)) do s
+    @test_skip let result = code_escapes((String,)) do s
             xs = Vector{String}(undef, 1)
             xs[1] = s
             xs′ = copy(xs)
@@ -1824,15 +1822,15 @@ end
             return isassigned(xs, i)
         end
         r = only(findall(isreturn, result.ir.stmts.stmt))
-        @test !has_return_escape(result.state[Argument(2)], r)
-        @test !has_thrown_escape(result.state[Argument(2)])
+        @test_broken !has_return_escape(result.state[Argument(2)], r)
+        @test_broken !has_thrown_escape(result.state[Argument(2)])
     end
 
     # indexing analysis
     # -----------------
 
     # safe case
-    let result = code_escapes((String,String)) do s, t
+    @test_skip let result = code_escapes((String,String)) do s, t
             a = Vector{Any}(undef, 2)
             a[1] = s
             a[2] = t
@@ -1845,7 +1843,7 @@ end
         @test has_return_escape(result.state[Argument(2)], r) # s
         @test !has_return_escape(result.state[Argument(3)], r) # t
     end
-    let result = code_escapes((String,String)) do s, t
+    @test_skip let result = code_escapes((String,String)) do s, t
             a = Matrix{Any}(undef, 1, 2)
             a[1, 1] = s
             a[1, 2] = t
@@ -1858,7 +1856,7 @@ end
         @test has_return_escape(result.state[Argument(2)], r) # s
         @test !has_return_escape(result.state[Argument(3)], r) # t
     end
-    let result = code_escapes((Bool,String,String,String)) do c, s, t, u
+    @test_skip let result = code_escapes((Bool,String,String,String)) do c, s, t, u
             a = Vector{Any}(undef, 2)
             if c
                 a[1] = s
@@ -1877,7 +1875,7 @@ end
         @test has_return_escape(result.state[Argument(4)], r) # t
         @test !has_return_escape(result.state[Argument(5)], r) # u
     end
-    let result = code_escapes((Bool,String,String,String)) do c, s, t, u
+    @test_skip let result = code_escapes((Bool,String,String,String)) do c, s, t, u
             a = Any[nothing, nothing] # TODO how to deal with loop indexing?
             if c
                 a[1] = s
@@ -1896,7 +1894,7 @@ end
         @test has_return_escape(result.state[Argument(4)], r) # t
         @test_broken !has_return_escape(result.state[Argument(5)], r) # u
     end
-    let result = code_escapes((String,)) do s
+    @test_skip let result = code_escapes((String,)) do s
             a = Vector{Vector{Any}}(undef, 1)
             b = Any[s]
             a[1] = b
@@ -1912,7 +1910,7 @@ end
         @test_broken is_load_forwardable(result.state[SSAValue(ib)])
         @test has_return_escape(result.state[Argument(2)], r) # s
     end
-    let result = code_escapes((Bool,String,String,Regex,Regex,)) do c, s1, s2, t1, t2
+    @test_skip let result = code_escapes((Bool,String,String,Regex,Regex,)) do c, s1, s2, t1, t2
             if c
                 a = Vector{String}(undef, 2)
                 a[1] = s1
@@ -1934,7 +1932,7 @@ end
         @test has_return_escape(result.state[Argument(5)], r) # t1
         @test !has_return_escape(result.state[Argument(6)], r) # t2
     end
-    let result = code_escapes((String,String,Int)) do s, t, i
+    @test_skip let result = code_escapes((String,String,Int)) do s, t, i
             a = Any[s]
             push!(a, t)
             return a[2]
@@ -1947,7 +1945,7 @@ end
         @test has_return_escape(result.state[Argument(3)], r) # t
     end
     # unsafe cases
-    let result = code_escapes((String,String,Int)) do s, t, i
+    @test_skip let result = code_escapes((String,String,Int)) do s, t, i
             a = Vector{Any}(undef, 2)
             a[1] = s
             a[2] = t
@@ -1960,7 +1958,7 @@ end
         @test has_return_escape(result.state[Argument(2)], r) # s
         @test has_return_escape(result.state[Argument(3)], r) # t
     end
-    let result = code_escapes((String,String,Int)) do s, t, i
+    @test_skip let result = code_escapes((String,String,Int)) do s, t, i
             a = Vector{Any}(undef, 2)
             a[1] = s
             a[i] = t
@@ -1973,7 +1971,7 @@ end
         @test has_return_escape(result.state[Argument(2)], r) # s
         @test has_return_escape(result.state[Argument(3)], r) # t
     end
-    let result = code_escapes((String,String,Int,Int,Int)) do s, t, i, j, k
+    @test_skip let result = code_escapes((String,String,Int,Int,Int)) do s, t, i, j, k
             a = Vector{Any}(undef, 2)
             a[3] = s # BoundsError
             a[1] = t
@@ -1984,7 +1982,7 @@ end
         @test !has_return_escape(result.state[SSAValue(i)], r)
         @test !is_load_forwardable(result.state[SSAValue(i)])
     end
-    let result = @eval Module() begin
+    @test_skip let result = @eval Module() begin
             @noinline some_resize!(a) = pushfirst!(a, nothing)
             $code_escapes((String,String,Int)) do s, t, i
                 a = Vector{Any}(undef, 2)
@@ -2000,7 +1998,7 @@ end
     end
 
     # circular reference
-    let result = code_escapes() do
+    @test_skip let result = code_escapes() do
             xs = Vector{Any}(undef, 1)
             xs[1] = xs
             return xs[1]
@@ -2009,7 +2007,7 @@ end
         r = only(findall(isreturn, result.ir.stmts.stmt))
         @test has_return_escape(result.state[SSAValue(i)], r)
     end
-    let result = @eval Module() begin
+    @test_skip let result = @eval Module() begin
             const Ax = Vector{Any}(undef, 1)
             Ax[1] = Ax
             $code_escapes() do
@@ -2040,7 +2038,7 @@ end
 end
 
 # demonstrate array primitive support with a realistic end to end example
-let result = code_escapes((Int,String,)) do n,s
+@test_skip let result = code_escapes((Int,String,)) do n,s
         xs = String[]
         for i in 1:n
             push!(xs, s)
@@ -2054,7 +2052,7 @@ let result = code_escapes((Int,String,)) do n,s
     @test has_return_escape(result.state[Argument(3)], r) # s
     @test !has_thrown_escape(result.state[Argument(3)])    # s
 end
-let result = code_escapes((Int,String,)) do n,s
+@test_skip let result = code_escapes((Int,String,)) do n,s
         xs = String[]
         for i in 1:n
             pushfirst!(xs, s)
@@ -2068,7 +2066,7 @@ let result = code_escapes((Int,String,)) do n,s
     @test has_return_escape(result.state[Argument(3)], r) # s
     @test !has_thrown_escape(result.state[Argument(3)])    # s
 end
-let result = code_escapes((String,String,String)) do s, t, u
+@test_skip let result = code_escapes((String,String,String)) do s, t, u
         xs = String[]
         resize!(xs, 3)
         xs[1] = s
@@ -2085,129 +2083,6 @@ let result = code_escapes((String,String,String)) do s, t, u
     @test has_return_escape(result.state[Argument(4)], r) # u
 end
 
-@static if isdefined(Core, :ImmutableArray)
-
-import Core: ImmutableArray, arrayfreeze, mutating_arrayfreeze, arraythaw
-
-@testset "ImmutableArray" begin
-    # arrayfreeze
-    let result = code_escapes((Vector{Any},)) do xs
-            arrayfreeze(xs)
-        end
-        @test !has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((Vector,)) do xs
-            arrayfreeze(xs)
-        end
-        @test !has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((Any,)) do xs
-            arrayfreeze(xs)
-        end
-        @test has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((ImmutableArray{Any,1},)) do xs
-            arrayfreeze(xs)
-        end
-        @test has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes() do
-            xs = Any[]
-            arrayfreeze(xs)
-        end
-        i = only(findall(isarrayalloc, result.ir.stmts.stmt))
-        @test has_no_escape(result.state[SSAValue(1)])
-    end
-
-    # mutating_arrayfreeze
-    let result = code_escapes((Vector{Any},)) do xs
-            mutating_arrayfreeze(xs)
-        end
-        @test !has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((Vector,)) do xs
-            mutating_arrayfreeze(xs)
-        end
-        @test !has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((Any,)) do xs
-            mutating_arrayfreeze(xs)
-        end
-        @test has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((ImmutableArray{Any,1},)) do xs
-            mutating_arrayfreeze(xs)
-        end
-        @test has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes() do
-            xs = Any[]
-            mutating_arrayfreeze(xs)
-        end
-        i = only(findall(isarrayalloc, result.ir.stmts.stmt))
-        @test has_no_escape(result.state[SSAValue(1)])
-    end
-
-    # arraythaw
-    let result = code_escapes((ImmutableArray{Any,1},)) do xs
-            arraythaw(xs)
-        end
-        @test !has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((ImmutableArray,)) do xs
-            arraythaw(xs)
-        end
-        @test !has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((Any,)) do xs
-            arraythaw(xs)
-        end
-        @test has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes((Vector{Any},)) do xs
-            arraythaw(xs)
-        end
-        @test has_thrown_escape(result.state[Argument(2)])
-    end
-    let result = code_escapes() do
-            xs = ImmutableArray(Any[])
-            arraythaw(xs)
-        end
-        i = only(findall(isarrayalloc, result.ir.stmts.stmt))
-        @test has_no_escape(result.state[SSAValue(1)])
-    end
-end
-
-# demonstrate some arrayfreeze optimizations
-# !has_return_escape(ary) means ary is eligible for arrayfreeze to mutating_arrayfreeze optimization
-let result = code_escapes((Int,)) do n
-        xs = collect(1:n)
-        ImmutableArray(xs)
-    end
-    i = only(findall(isarrayalloc, result.ir.stmts.stmt))
-    @test !has_return_escape(result.state[SSAValue(i)])
-end
-let result = code_escapes((Vector{Float64},)) do xs
-        ys = sin.(xs)
-        ImmutableArray(ys)
-    end
-    i = only(findall(isarrayalloc, result.ir.stmts.stmt))
-    @test !has_return_escape(result.state[SSAValue(i)])
-end
-let result = code_escapes((Vector{Pair{Int,String}},)) do xs
-        n = maximum(first, xs)
-        ys = Vector{String}(undef, n)
-        for (i, s) in xs
-            ys[i] = s
-        end
-        ImmutableArray(xs)
-    end
-    i = only(findall(isarrayalloc, result.ir.stmts.stmt))
-    @test !has_return_escape(result.state[SSAValue(i)])
-end
-
-end # @static if isdefined(Core, :ImmutableArray)
-
 # demonstrate a simple type level analysis can sometimes improve the analysis accuracy
 # by compensating the lack of yet unimplemented analyses
 @testset "special-casing bitstype" begin
diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl
index 3b517201ce67d..daa636a11b02d 100644
--- a/test/compiler/codegen.jl
+++ b/test/compiler/codegen.jl
@@ -128,11 +128,16 @@ if !is_debug_build && opt_level > 0
     # String
     test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Core.SimpleVector})), [Iptr])
     # Array
-    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Vector{Int}})), [Iptr])
+    test_loads_no_call(strip_debug_calls(get_llvm(sizeof, Tuple{Vector{Int}})), [Iptr])
+    # As long as the eltype is known we don't need to load the elsize, but do need to check isvector
+    @test_skip test_loads_no_call(strip_debug_calls(get_llvm(sizeof, Tuple{Array{Any}})), ["atomic $Iptr", "{} addrspace(10)* addrspace(10)*", "$Iptr addrspace(10)*", Iptr, Iptr, "{ i64, {} addrspace(10)** } addrspace(10)*",  Iptr])
+    # Memory
+    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory{Int}})), [Iptr])
     # As long as the eltype is known we don't need to load the elsize
-    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Array{Any}})), [Iptr])
-    # Check that we load the elsize
-    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Vector})), [Iptr, "i16"])
+    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory{Any}})), [Iptr])
+    # Check that we load the elsize and isunion from the typeof layout
+    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory})), [Iptr, "atomic $Iptr", "i32*", "i32", "i16"])
+    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory})), [Iptr, "atomic $Iptr", "i32*", "i32", "i16"])
     # Primitive Type size should be folded to a constant
     test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Ptr})), String[])
 
@@ -309,8 +314,8 @@ end
 
 # PR #23595
 @generated f23595(g, args...) = Expr(:call, :g, Expr(:(...), :args))
-x23595 = rand(1)
-@test f23595(Core.arrayref, true, x23595, 1) == x23595[]
+x23595 = rand(1).ref
+@test f23595(Core.memoryrefget, x23595, :not_atomic, true) == x23595[]
 
 # Issue #22421
 @noinline f22421_1(x) = x[] + 1
@@ -367,26 +372,10 @@ mktemp() do f_22330, _
 end
 
 # Alias scope
-macro aliasscope(body)
-    sym = gensym()
-    esc(quote
-        $(Expr(:aliasscope))
-        $sym = $body
-        $(Expr(:popaliasscope))
-        $sym
-    end)
-end
-
-struct ConstAliasScope{T<:Array}
-    a::T
-end
-
-@eval Base.getindex(A::ConstAliasScope, i1::Int) = Core.const_arrayref($(Expr(:boundscheck)), A.a, i1)
-@eval Base.getindex(A::ConstAliasScope, i1::Int, i2::Int, I::Int...) =  (@inline; Core.const_arrayref($(Expr(:boundscheck)), A.a, i1, i2, I...))
-
+using Base.Experimental: @aliasscope, Const
 function foo31018!(a, b)
     @aliasscope for i in eachindex(a, b)
-        a[i] = ConstAliasScope(b)[i]
+        a[i] = Const(b)[i]
     end
 end
 io = IOBuffer()
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 98451f696d8ba..186a201f6ebe4 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -472,7 +472,7 @@ end |> Core.Compiler.is_consistent
 
 # issue 46122: @assume_effects for @ccall
 @test Base.infer_effects((Vector{Int},)) do a
-    Base.@assume_effects :effect_free @ccall jl_array_ptr(a::Any)::Ptr{Int}
+    Base.@assume_effects :effect_free @ccall this_call_does_not_really_exist(a::Any)::Ptr{Int}
 end |> Core.Compiler.is_effect_free
 
 # `getfield_effects` handles access to union object nicely
@@ -696,31 +696,34 @@ end
 # low-level constructor
 @noinline construct_array(@nospecialize(T), args...) = Array{T}(undef, args...)
 # should eliminate safe but dead allocations
-let good_dims = @static Int === Int64 ? (1:10) : (1:8)
-    Ns = @static Int === Int64 ? (1:10) : (1:8)
+let good_dims = [1, 2, 3, 4, 10]
+    Ns = [1, 2, 3, 4, 10]
     for dim = good_dims, N = Ns
+        Int64(dim)^N > typemax(Int) && continue
         dims = ntuple(i->dim, N)
         @test @eval Base.infer_effects() do
-            $construct_array(Int, $(dims...))
+            construct_array(Int, $(dims...))
         end |> Core.Compiler.is_removable_if_unused
         @test @eval fully_eliminated() do
-            $construct_array(Int, $(dims...))
+            construct_array(Int, $(dims...))
             nothing
         end
     end
 end
 # should analyze throwness correctly
 let bad_dims = [-1, typemax(Int)]
-    for dim in bad_dims, N in 1:10
-        dims = ntuple(i->dim, N)
-        @test @eval Base.infer_effects() do
-            $construct_array(Int, $(dims...))
-        end |> !Core.Compiler.is_removable_if_unused
-        @test @eval !fully_eliminated() do
-            $construct_array(Int, $(dims...))
-            nothing
+    for dim in bad_dims, N in [1, 2, 3, 4, 10]
+        for T in Any[Int, Union{Missing,Nothing}, Missing, Any]
+            dims = ntuple(i->dim, N)
+            @test @eval Base.infer_effects() do
+                construct_array($T, $(dims...))
+            end |> !Core.Compiler.is_removable_if_unused
+            @test @eval !fully_eliminated() do
+                construct_array($T, $(dims...))
+                nothing
+            end
+            @test_throws "invalid " @eval construct_array($T, $(dims...))
         end
-        @test_throws "invalid Array" @eval $construct_array(Int, $(dims...))
     end
 end
 
@@ -764,12 +767,9 @@ for safesig = Any[
     end
 end
 
-# arrayref
-# --------
-
-for tt = Any[(Bool,Vector{Any},Int),
-             (Bool,Matrix{Any},Int,Int)]
-    @testset let effects = Base.infer_effects(Base.arrayref, tt)
+# array getindex
+let tt = (MemoryRef{Any},Symbol,Bool)
+    @testset let effects = Base.infer_effects(Core.memoryrefget, tt)
         @test Core.Compiler.is_consistent_if_inaccessiblememonly(effects)
         @test Core.Compiler.is_effect_free(effects)
         @test !Core.Compiler.is_nothrow(effects)
@@ -777,12 +777,9 @@ for tt = Any[(Bool,Vector{Any},Int),
     end
 end
 
-# arrayset
-# --------
-
-for tt = Any[(Bool,Vector{Any},Any,Int),
-             (Bool,Matrix{Any},Any,Int,Int)]
-    @testset let effects = Base.infer_effects(Base.arrayset, tt)
+# array setindex!
+let tt = (MemoryRef{Any},Any,Symbol,Bool)
+    @testset let effects = Base.infer_effects(Core.memoryrefset!, tt)
         @test Core.Compiler.is_consistent_if_inaccessiblememonly(effects)
         @test Core.Compiler.is_effect_free_if_inaccessiblememonly(effects)
         @test !Core.Compiler.is_nothrow(effects)
@@ -790,24 +787,24 @@ for tt = Any[(Bool,Vector{Any},Any,Int),
     end
 end
 # nothrow for arrayset
-@test Base.infer_effects((Vector{Int},Int,Int)) do a, v, i
-    Base.arrayset(true, a, v, i)
+@test Base.infer_effects((MemoryRef{Int},Int)) do a, v
+    Core.memoryrefset!(a, v, :not_atomic, true)
 end |> !Core.Compiler.is_nothrow
-@test Base.infer_effects((Vector{Int},Int,Int)) do a, v, i
-    a[i] = v # may throw
+@test Base.infer_effects((MemoryRef{Int},Int)) do a, v
+    a[] = v # may throw
 end |> !Core.Compiler.is_nothrow
 # when bounds checking is turned off, it should be safe
-@test Base.infer_effects((Vector{Int},Int,Int)) do a, v, i
-    Base.arrayset(false, a, v, i)
+@test Base.infer_effects((MemoryRef{Int},Int)) do a, v
+    Core.memoryrefset!(a, v, :not_atomic, false)
 end |> Core.Compiler.is_nothrow
-@test Base.infer_effects((Vector{Number},Number,Int)) do a, v, i
-    Base.arrayset(false, a, v, i)
+@test Base.infer_effects((MemoryRef{Number},Number)) do a, v
+    Core.memoryrefset!(a, v, :not_atomic, false)
 end |> Core.Compiler.is_nothrow
 
 # arraysize
 # ---------
 
-let effects = Base.infer_effects(Base.arraysize, (Array,Int))
+let effects = Base.infer_effects(size, (Array,Int))
     @test Core.Compiler.is_consistent_if_inaccessiblememonly(effects)
     @test Core.Compiler.is_effect_free(effects)
     @test !Core.Compiler.is_nothrow(effects)
@@ -819,7 +816,7 @@ end
 # arraylen
 # --------
 
-let effects = Base.infer_effects(Base.arraylen, (Vector{Any},))
+let effects = Base.infer_effects(length, (Vector{Any},))
     @test Core.Compiler.is_consistent_if_inaccessiblememonly(effects)
     @test Core.Compiler.is_effect_free(effects)
     @test Core.Compiler.is_nothrow(effects)
@@ -829,19 +826,19 @@ end
 # resize
 # ------
 
-for op = Any[
-        Base._growbeg!,
-        Base._growend!,
-        Base._deletebeg!,
-        Base._deleteend!,
-    ]
-    let effects = Base.infer_effects(op, (Vector, Int))
-        @test Core.Compiler.is_effect_free_if_inaccessiblememonly(effects)
-        @test Core.Compiler.is_terminates(effects)
-        @test !Core.Compiler.is_nothrow(effects)
-    end
-end
-
+#for op = Any[
+#        Base._growbeg!,
+#        Base._growend!,
+#        Base._deletebeg!,
+#        Base._deleteend!,
+#    ]
+#    let effects = Base.infer_effects(op, (Vector, Int))
+#        @test Core.Compiler.is_effect_free_if_inaccessiblememonly(effects)
+#        @test Core.Compiler.is_terminates(effects)
+#        @test !Core.Compiler.is_nothrow(effects)
+#    end
+#end
+#
 # tuple indexing
 # --------------
 
@@ -850,17 +847,17 @@ end
 # end to end
 # ----------
 
-function simple_vec_ops(T, op!, op, xs...)
-    a = T[]
-    op!(a, xs...)
-    return op(a)
-end
-for T = Any[Int,Any], op! = Any[push!,pushfirst!], op = Any[length,size],
-    xs = Any[(Int,), (Int,Int,)]
-    let effects = Base.infer_effects(simple_vec_ops, (Type{T},typeof(op!),typeof(op),xs...))
-        @test Core.Compiler.is_foldable(effects)
-    end
-end
+#function simple_vec_ops(T, op!, op, xs...)
+#    a = T[]
+#    op!(a, xs...)
+#    return op(a)
+#end
+#for T = Any[Int,Any], op! = Any[push!,pushfirst!], op = Any[length,size],
+#    xs = Any[(Int,), (Int,Int,)]
+#    let effects = Base.infer_effects(simple_vec_ops, (Type{T},typeof(op!),typeof(op),xs...))
+#        @test Core.Compiler.is_foldable(effects)
+#    end
+#end
 
 # Test that builtin_effects handles vararg correctly
 @test !Core.Compiler.is_nothrow(Core.Compiler.builtin_effects(Core.Compiler.fallback_lattice, Core.isdefined,
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index f01d11695f4d1..861bbbbcec36d 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -366,7 +366,7 @@ barTuple2() = fooTuple{tuple(:y)}()
 # issue #6050
 @test Core.Compiler.getfield_tfunc(Core.Compiler.fallback_lattice,
           Dict{Int64,Tuple{UnitRange{Int64},UnitRange{Int64}}},
-          Core.Compiler.Const(:vals)) == Array{Tuple{UnitRange{Int64},UnitRange{Int64}},1}
+          Core.Compiler.Const(:vals)) == Memory{Tuple{UnitRange{Int64},UnitRange{Int64}}}
 
 # assert robustness of `getfield_tfunc`
 struct GetfieldRobustness
@@ -1190,8 +1190,6 @@ let isdefined_tfunc(@nospecialize xs...) =
     @test isdefined_tfunc(Core.SimpleVector, Const(1)) === Const(false)
     @test Const(false) ⊑ isdefined_tfunc(Const(:x), Symbol)
     @test Const(false) ⊑ isdefined_tfunc(Const(:x), Const(:y))
-    @test isdefined_tfunc(Vector{Int}, Const(1)) == Const(false)
-    @test isdefined_tfunc(Vector{Any}, Const(1)) == Const(false)
     @test isdefined_tfunc(Module, Int) === Union{}
     @test isdefined_tfunc(Tuple{Any,Vararg{Any}}, Const(0)) === Const(false)
     @test isdefined_tfunc(Tuple{Any,Vararg{Any}}, Const(1)) === Const(true)
@@ -1331,30 +1329,33 @@ test_const_return(()->sizeof(1), Tuple{}, sizeof(Int))
 test_const_return(()->sizeof(DataType), Tuple{}, sizeof(DataType))
 test_const_return(()->sizeof(1 < 2), Tuple{}, 1)
 test_const_return(()->fieldtype(Dict{Int64,Nothing}, :age), Tuple{}, UInt)
-test_const_return(@eval(()->Core.sizeof($(Array{Int,0}(undef)))), Tuple{}, sizeof(Int))
-test_const_return(@eval(()->Core.sizeof($(Matrix{Float32}(undef, 2, 2)))), Tuple{}, 4 * 2 * 2)
+test_const_return(@eval(()->Core.sizeof($(Array{Int,0}(undef)))), Tuple{}, 2 * sizeof(Int))
+test_const_return(@eval(()->Core.sizeof($(Matrix{Float32}(undef, 2, 2)))), Tuple{}, 4 * sizeof(Int))
+# TODO: do we want to implement these?
+# test_const_return(@eval(()->sizeof($(Array{Int,0}(undef)))), Tuple{}, sizeof(Int))
+# test_const_return(@eval(()->sizeof($(Matrix{Float32}(undef, 2, 2)))), Tuple{}, 4 * 2 * 2)
+# test_const_return(@eval(()->Core.sizeof($(Memory{Int}(undef, 0)))), Tuple{}, 0)
 
 # Make sure Core.sizeof with a ::DataType as inferred input type is inferred but not constant.
 function sizeof_typeref(typeref)
     return Core.sizeof(typeref[])
 end
 @test @inferred(sizeof_typeref(Ref{DataType}(Int))) == sizeof(Int)
-@test find_call(first(code_typed(sizeof_typeref, (Ref{DataType},))[1]), Core.sizeof, 2)
+@test find_call(only(code_typed(sizeof_typeref, (Ref{DataType},)))[1], Core.sizeof, 2)
 # Constant `Vector` can be resized and shouldn't be optimized to a constant.
 const constvec = [1, 2, 3]
 @eval function sizeof_constvec()
-    return Core.sizeof($constvec)
+    return sizeof($constvec)
 end
 @test @inferred(sizeof_constvec()) == sizeof(Int) * 3
-@test find_call(first(code_typed(sizeof_constvec, ())[1]), Core.sizeof, 2)
 push!(constvec, 10)
-@test @inferred(sizeof_constvec()) == sizeof(Int) * 4
+@test sizeof_constvec() == sizeof(Int) * 4
 
 test_const_return(x->isdefined(x, :re), Tuple{ComplexF64}, true)
 
 isdefined_f3(x) = isdefined(x, 3)
 @test @inferred(isdefined_f3(())) == false
-@test find_call(first(code_typed(isdefined_f3, Tuple{Tuple{Vararg{Int}}})[1]), isdefined, 3)
+@test find_call(only(code_typed(isdefined_f3, Tuple{Tuple{Vararg{Int}}}))[1], isdefined, 3)
 
 let isa_tfunc(@nospecialize xs...) =
         Core.Compiler.isa_tfunc(Core.Compiler.fallback_lattice, xs...)
@@ -1532,7 +1533,7 @@ let nfields_tfunc(@nospecialize xs...) =
     @test sizeof_nothrow(Type{Ptr})
     @test sizeof_nothrow(Type{Union{Ptr{Int}, Int}})
     @test !sizeof_nothrow(Const(Tuple))
-    @test !sizeof_nothrow(Type{Vector{Int}})
+    @test sizeof_nothrow(Type{Vector{Int}})
     @test !sizeof_nothrow(Type{Union{Int, String}})
     @test sizeof_nothrow(String)
     @test !sizeof_nothrow(Type{String})
@@ -1578,36 +1579,43 @@ end
 f_typeof_tfunc(x) = typeof(x)
 @test Base.return_types(f_typeof_tfunc, (Union{<:T, Int} where T<:Complex,)) == Any[Union{Type{Int}, Type{Complex{T}} where T<:Real}]
 
-# arrayref / arrayset / arraysize
-import Core.Compiler: Const
-let arrayref_tfunc(@nospecialize xs...) = Core.Compiler.arrayref_tfunc(Core.Compiler.fallback_lattice, xs...)
-    arrayset_tfunc(@nospecialize xs...) = Core.Compiler.arrayset_tfunc(Core.Compiler.fallback_lattice, xs...)
-    arraysize_tfunc(@nospecialize xs...) = Core.Compiler.arraysize_tfunc(Core.Compiler.fallback_lattice, xs...)
-    @test arrayref_tfunc(Const(true), Vector{Int}, Int) === Int
-    @test arrayref_tfunc(Const(true), Vector{<:Integer}, Int) === Integer
-    @test arrayref_tfunc(Const(true), Vector, Int) === Any
-    @test arrayref_tfunc(Const(true), Vector{Int}, Int, Vararg{Int}) === Int
-    @test arrayref_tfunc(Const(true), Vector{Int}, Vararg{Int}) === Int
-    @test arrayref_tfunc(Const(true), Vector{Int}) === Union{}
-    @test arrayref_tfunc(Const(true), String, Int) === Union{}
-    @test arrayref_tfunc(Const(true), Vector{Int}, Float64) === Union{}
-    @test arrayref_tfunc(Int, Vector{Int}, Int) === Union{}
-    @test arrayset_tfunc(Const(true), Vector{Int}, Int, Int) === Vector{Int}
-    let ua = Vector{<:Integer}
-        @test arrayset_tfunc(Const(true), ua, Int, Int) === ua
-    end
-    @test arrayset_tfunc(Const(true), Vector, Int, Int) === Vector
-    @test arrayset_tfunc(Const(true), Any, Int, Int) === Any
-    @test arrayset_tfunc(Const(true), Vector{String}, String, Int, Vararg{Int}) === Vector{String}
-    @test arrayset_tfunc(Const(true), Vector{String}, String, Vararg{Int}) === Vector{String}
-    @test arrayset_tfunc(Const(true), Vector{String}, String) === Union{}
-    @test arrayset_tfunc(Const(true), String, Char, Int) === Union{}
-    @test arrayset_tfunc(Const(true), Vector{Int}, Int, Float64) === Union{}
-    @test arrayset_tfunc(Int, Vector{Int}, Int, Int) === Union{}
-    @test arrayset_tfunc(Const(true), Vector{Int}, Float64, Int) === Union{}
-    @test arraysize_tfunc(Vector, Int) === Int
-    @test arraysize_tfunc(Vector, Float64) === Union{}
-    @test arraysize_tfunc(String, Int) === Union{}
+# memoryref_tfunc, memoryrefget_tfunc, memoryrefset!_tfunc
+let memoryref_tfunc(@nospecialize xs...) = Core.Compiler.memoryref_tfunc(Core.Compiler.fallback_lattice, xs...)
+    memoryrefget_tfunc(@nospecialize xs...) = Core.Compiler.memoryrefget_tfunc(Core.Compiler.fallback_lattice, xs...)
+    memoryrefset!_tfunc(@nospecialize xs...) = Core.Compiler.memoryrefset!_tfunc(Core.Compiler.fallback_lattice, xs...)
+    @test memoryref_tfunc(Memory{Int}) == MemoryRef{Int}
+    @test memoryref_tfunc(Memory{Integer}) == MemoryRef{Integer}
+    @test memoryref_tfunc(MemoryRef{Int}, Int) == MemoryRef{Int}
+    @test memoryref_tfunc(MemoryRef{Int}, Int, Symbol) == Union{}
+    @test memoryref_tfunc(MemoryRef{Int}, Int, Bool) == MemoryRef{Int}
+    @test memoryref_tfunc(Memory{Int}, Int) == Union{}
+    @test memoryref_tfunc(Any, Any, Any) == Any # also probably could be GenericMemoryRef
+    @test memoryref_tfunc(Any, Any) == Any # also probably could be GenericMemoryRef
+    @test memoryref_tfunc(Any) == GenericMemoryRef
+    @test memoryrefget_tfunc(MemoryRef{Int}, Symbol, Bool) === Int
+    @test memoryrefget_tfunc(MemoryRef{Int}, Any, Any) === Int
+    @test memoryrefget_tfunc(MemoryRef{<:Integer}, Symbol, Bool) === Integer
+    @test memoryrefget_tfunc(GenericMemoryRef, Symbol, Bool) === Any
+    @test memoryrefget_tfunc(GenericMemoryRef{:not_atomic}, Symbol, Bool) === Any
+    @test memoryrefget_tfunc(Vector{Int}, Symbol, Bool) === Union{}
+    @test memoryrefget_tfunc(String, Symbol, Bool) === Union{}
+    @test memoryrefget_tfunc(MemoryRef{Int}, String, Bool) === Union{}
+    @test memoryrefget_tfunc(MemoryRef{Int}, Symbol, String) === Union{}
+    @test memoryrefget_tfunc(Any, Any, Any) === Any
+    @test memoryrefset!_tfunc(MemoryRef{Int}, Int, Symbol, Bool) === MemoryRef{Int}
+    let ua = MemoryRef{<:Integer}
+        @test memoryrefset!_tfunc(ua, Int, Symbol, Bool) === ua
+    end
+    @test memoryrefset!_tfunc(GenericMemoryRef, Int, Symbol, Bool) === GenericMemoryRef
+    @test memoryrefset!_tfunc(GenericMemoryRef{:not_atomic}, Int, Symbol, Bool) === GenericMemoryRef{:not_atomic}
+    @test memoryrefset!_tfunc(Any, Int, Symbol, Bool) === Any
+    @test memoryrefset!_tfunc(MemoryRef{String}, Int, Symbol, Bool) === Union{}
+    @test memoryrefset!_tfunc(String, Char, Symbol, Bool) === Union{}
+    @test memoryrefset!_tfunc(MemoryRef{Int}, Any, Symbol, Bool) === MemoryRef{Int}
+    @test memoryrefset!_tfunc(MemoryRef{Int}, Any, Any, Any) === MemoryRef{Int}
+    @test memoryrefset!_tfunc(GenericMemoryRef{:not_atomic}, Any, Any, Any) === GenericMemoryRef{:not_atomic}
+    @test memoryrefset!_tfunc(GenericMemoryRef, Any, Any, Any) === GenericMemoryRef
+    @test memoryrefset!_tfunc(Any, Any, Any, Any) === Any # also probably could be GenericMemoryRef
 end
 
 let tuple_tfunc(@nospecialize xs...) =
@@ -1667,7 +1675,7 @@ end
 
 # approximate static parameters due to unions
 let T1 = Array{Float64}, T2 = Array{_1,2} where _1
-    inference_test_copy(a::T) where {T<:Array} = ccall(:jl_array_copy, Ref{T}, (Any,), a)
+    inference_test_copy(a::T) where {T<:Array} = ccall(:array_copy_like, Ref{T}, (Any,), a)
     rt = Base.return_types(inference_test_copy, (Union{T1,T2},))[1]
     @test rt >: T1 && rt >: T2
 
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 0fce3e1b6f0d8..a5ad45b3281df 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -147,8 +147,10 @@ end
         s
     end
 
-    (src, _) = code_typed(sum27403, Tuple{Vector{Int}})[1]
-    @test !any(x -> x isa Expr && x.head === :invoke, src.code)
+    (src, _) = only(code_typed(sum27403, Tuple{Vector{Int}}))
+    @test !any(src.code) do x
+        x isa Expr && x.head === :invoke && x.args[2] !== Core.GlobalRef(Base, :throw_boundserror)
+    end
 end
 
 # check that ismutabletype(type) can be fully eliminated
@@ -311,7 +313,7 @@ end
 const _a_global_array = [1]
 f_inline_global_getindex() = _a_global_array[1]
 let ci = code_typed(f_inline_global_getindex, Tuple{})[1].first
-    @test any(x->(isexpr(x, :call) && x.args[1] === GlobalRef(Base, :arrayref)), ci.code)
+    @test any(x->(isexpr(x, :call) && x.args[1] === GlobalRef(Base, :memoryrefget)), ci.code)
 end
 
 # Issue #29114 & #36087 - Inlining of non-tuple splats
@@ -777,8 +779,8 @@ end
 let src = code_typed((Union{Tuple{Int,Int,Int}, Vector{Int}},)) do xs
         g42840(xs, 2)
     end |> only |> first
-    # `(xs::Vector{Int})[a::Const(2)]` => `Base.arrayref(true, xs, 2)`
-    @test count(iscall((src, Base.arrayref)), src.code) == 1
+    # `(xs::Vector{Int})[a::Const(2)]`
+    @test count(iscall((src, Base.memoryrefget)), src.code) == 1
     @test count(isinvoke(:g42840), src.code) == 1
 end
 
@@ -1562,20 +1564,22 @@ end
 # optimize `[push!|pushfirst!](::Vector{Any}, x...)`
 @testset "optimize `$f(::Vector{Any}, x...)`" for f = Any[push!, pushfirst!]
     @eval begin
-        let src = code_typed1((Vector{Any}, Any)) do xs, x
-                $f(xs, x)
+        for T in [Int, Any]
+            let src = code_typed1((Vector{T}, T)) do xs, x
+                    $f(xs, x)
+                end
+                @test count(iscall((src, $f)), src.code) == 0
             end
-            @test count(iscall((src, $f)), src.code) == 0
-            @test count(src.code) do @nospecialize x
-                isa(x, Core.GotoNode) ||
-                isa(x, Core.GotoIfNot) ||
-                iscall((src, getfield))(x)
-            end == 0 # no loop should be involved for the common single arg case
-        end
-        let src = code_typed1((Vector{Any}, Any, Any)) do xs, x, y
-                $f(xs, x, y)
+            let effects = Base.infer_effects((Vector{T}, T)) do xs, x
+                    $f(xs, x)
+                end
+                @test Core.Compiler.Core.Compiler.is_terminates(effects)
+            end
+            let src = code_typed1((Vector{T}, T, T)) do xs, x, y
+                    $f(xs, x, y)
+                end
+                @test count(iscall((src, $f)), src.code) == 0
             end
-            @test count(iscall((src, $f)), src.code) == 0
         end
         let xs = Any[]
             $f(xs, :x, "y", 'z')
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 225839d8e0cf3..cde6b7809f8b5 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1145,9 +1145,10 @@ end
 let # effect-freeness computation for array allocation
 
     # should eliminate dead allocations
-    good_dims = @static Int === Int64 ? (1:10) : (1:8)
-    Ns = @static Int === Int64 ? (1:10) : (1:8)
+    good_dims = [1, 2, 3, 4, 10]
+    Ns = [1, 2, 3, 4, 10]
     for dim = good_dims, N = Ns
+        Int64(dim)^N > typemax(Int) && continue
         dims = ntuple(i->dim, N)
         @test @eval fully_eliminated() do
             Array{Int,$N}(undef, $(dims...))
@@ -1157,14 +1158,14 @@ let # effect-freeness computation for array allocation
 
     # shouldn't eliminate erroneous dead allocations
     bad_dims = [-1, typemax(Int)]
-    for dim in bad_dims, N in 1:10
+    for dim in bad_dims, N in [1, 2, 3, 4, 10], T in Any[Int, Union{Missing,Nothing}, Nothing, Any]
         dims = ntuple(i->dim, N)
         @test @eval !fully_eliminated() do
-            Array{Int,$N}(undef, $(dims...))
+            Array{$T,$N}(undef, $(dims...))
             nothing
         end
-        @test_throws "invalid Array" @eval let
-            Array{Int,$N}(undef, $(dims...))
+        @test_throws "invalid " @eval let
+            Array{$T,$N}(undef, $(dims...))
             nothing
         end
     end
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 0e7c2159d4851..5f9441eb9ead8 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -38,7 +38,7 @@ end
 #        false, false, false, false
 #    ))
 #
-#    NullLineInfo = Core.LineInfoNode(Main, Symbol(""), Symbol(""), Int32(0), Int32(0))
+#    NullLineInfo = Core.LineInfoNode(Main, Symbol(""), Symbol(""), Int32(0), UInt32(0))
 #    Compiler.run_passes(ci, 1, [NullLineInfo])
 #    # XXX: missing @test
 #end
diff --git a/test/core.jl b/test/core.jl
index 959d17b405b49..105e34584405b 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -23,6 +23,8 @@ for (T, c) in (
         (Core.TypeName, [:name, :module, :names, :wrapper, :mt, :hash, :n_uninitialized, :flags]),
         (DataType, [:name, :super, :parameters, :instance, :hash]),
         (TypeVar, [:name, :ub, :lb]),
+        (Core.Memory, [:length, :ptr]),
+        (Core.GenericMemoryRef, [:mem, :ptr_or_offset]),
     )
     @test Set((fieldname(T, i) for i in 1:fieldcount(T) if isconst(T, i))) == Set(c)
 end
@@ -38,6 +40,8 @@ for (T, c) in (
         (Core.TypeMapLevel, [:arg1, :targ, :name1, :tname, :list, :any]),
         (Core.TypeName, [:cache, :linearcache]),
         (DataType, [:types, :layout]),
+        (Core.Memory, []),
+        (Core.GenericMemoryRef, []),
     )
     @test Set((fieldname(T, i) for i in 1:fieldcount(T) if Base.isfieldatomic(T, i))) == Set(c)
 end
@@ -2594,7 +2598,7 @@ struct D14919 <: Function; end
 for f in (:Any, :Function, :(Core.Builtin), :(Union{Nothing, Type}), :(Union{typeof(+), Type}), :(Union{typeof(+), typeof(-)}), :(Base.Callable))
     @test_throws ErrorException("Method dispatch is unimplemented currently for this method signature") @eval (::$f)() = 1
 end
-for f in (:(Core.arrayref), :((::typeof(Core.arrayref))), :((::Core.IntrinsicFunction)))
+for f in (:(Core.getfield), :((::typeof(Core.getfield))), :((::Core.IntrinsicFunction)))
     @test_throws ErrorException("cannot add methods to a builtin function") @eval $f() = 1
 end
 
@@ -4334,6 +4338,7 @@ function f15180(x::T) where T
 end
 @test map(f15180(1), [1,2]) == [(Int,1),(Int,1)]
 
+using Base: _growbeg!, _deletebeg!, _growend!, _deleteend!
 struct ValueWrapper
     vpadding::NTuple{2,VecElement{UInt}}
     value
@@ -4342,43 +4347,44 @@ end
 Base.convert(::Type{ValueWrapper}, x) = ValueWrapper(x)
 for T in (Any, ValueWrapper)
     let ary = Vector{T}(undef, 10)
-        check_undef_and_fill(ary, rng) = for i in rng
-            @test !isassigned(ary, i)
+        check_undef_and_fill(ary, rng) = all(i -> begin
+            isassigned(ary, i) && return false
             ary[i] = (Float64(i), i) # some non-cached content
-            @test isassigned(ary, i)
-        end
+            isassigned(ary, i) || return false
+            return true
+        end, rng)
         # Check if the memory is initially zerod and fill it with value
         # to check if these values are not reused later.
-        check_undef_and_fill(ary, 1:10)
+        @test check_undef_and_fill(ary, 1:10)
         # Check if the memory grown at the end are zerod
-        ccall(:jl_array_grow_end, Cvoid, (Any, Csize_t), ary, 10)
-        check_undef_and_fill(ary, 11:20)
+        _growend!(ary, 10)
+        @test check_undef_and_fill(ary, 11:20)
         # Make sure the content of the memory deleted at the end are not reused
-        ccall(:jl_array_del_end, Cvoid, (Any, Csize_t), ary, 5)
-        ccall(:jl_array_grow_end, Cvoid, (Any, Csize_t), ary, 5)
-        check_undef_and_fill(ary, 16:20)
+        _deleteend!(ary, 5)
+        _growend!(ary, 5)
+        @test check_undef_and_fill(ary, 16:20)
 
         # Now check grow/del_end
         ary = Vector{T}(undef, 1010)
-        check_undef_and_fill(ary, 1:1010)
+        @test check_undef_and_fill(ary, 1:1010)
         # This del_beg should move the buffer
-        ccall(:jl_array_del_beg, Cvoid, (Any, Csize_t), ary, 1000)
-        ccall(:jl_array_grow_beg, Cvoid, (Any, Csize_t), ary, 1000)
-        check_undef_and_fill(ary, 1:1000)
+        _deletebeg!(ary, 1000)
+        _growbeg!(ary, 1000)
+        @test check_undef_and_fill(ary, 1:1000)
         ary = Vector{T}(undef, 1010)
-        check_undef_and_fill(ary, 1:1010)
+        @test check_undef_and_fill(ary, 1:1010)
         # This del_beg should not move the buffer
-        ccall(:jl_array_del_beg, Cvoid, (Any, Csize_t), ary, 10)
-        ccall(:jl_array_grow_beg, Cvoid, (Any, Csize_t), ary, 10)
-        check_undef_and_fill(ary, 1:10)
+        _deletebeg!(ary, 10)
+        _growbeg!(ary, 10)
+        @test check_undef_and_fill(ary, 1:10)
 
         ary = Vector{T}(undef, 1010)
-        check_undef_and_fill(ary, 1:1010)
-        ccall(:jl_array_grow_end, Cvoid, (Any, Csize_t), ary, 10)
-        check_undef_and_fill(ary, 1011:1020)
-        ccall(:jl_array_del_end, Cvoid, (Any, Csize_t), ary, 10)
-        ccall(:jl_array_grow_beg, Cvoid, (Any, Csize_t), ary, 10)
-        check_undef_and_fill(ary, 1:10)
+        @test check_undef_and_fill(ary, 1:1010)
+        _growend!(ary, 10)
+        @test check_undef_and_fill(ary, 1011:1020)
+        _deleteend!(ary, 10)
+        _growbeg!(ary, 10)
+        @test check_undef_and_fill(ary, 1:10)
 
         # Make sure newly malloc'd buffers are filled with 0
         # test this for a few different sizes since we need to make sure
@@ -4391,33 +4397,51 @@ for T in (Any, ValueWrapper)
             GC.gc()
             GC.gc()
             GC.gc()
-            ccall(:jl_array_grow_beg, Cvoid, (Any, Csize_t), ary, 4)
-            ccall(:jl_array_del_beg, Cvoid, (Any, Csize_t), ary, 4)
-            ccall(:jl_array_grow_end, Cvoid, (Any, Csize_t), ary, n)
-            ccall(:jl_array_grow_beg, Cvoid, (Any, Csize_t), ary, 4)
-            check_undef_and_fill(ary, 1:(2n + 4))
+            _growbeg!(ary, 4)
+            _deletebeg!(ary, 4)
+            _growend!(ary, n)
+            _growbeg!(ary, 4)
+            @test check_undef_and_fill(ary, 1:(2n + 4))
         end
 
         ary = Vector{T}(undef, 100)
-        ccall(:jl_array_grow_end, Cvoid, (Any, Csize_t), ary, 10000)
+        _growend!(ary, 10000)
         ary[:] = 1:length(ary)
-        ccall(:jl_array_del_beg, Cvoid, (Any, Csize_t), ary, 10000)
+        _deletebeg!(ary, 10000)
         # grow on the back until a buffer reallocation happens
         cur_ptr = pointer(ary)
         while cur_ptr == pointer(ary)
             len = length(ary)
-            ccall(:jl_array_grow_end, Cvoid, (Any, Csize_t), ary, 10)
-            for i in (len + 1):(len + 10)
-                @test !isassigned(ary, i)
-            end
+            _growend!(ary, 10)
+            result = @test all(i -> !isassigned(ary, i), (len + 1):(len + 10))
+            result isa Test.Pass || break
         end
 
-        ary = Vector{T}(undef, 100)
-        ary[:] = 1:length(ary)
-        ccall(:jl_array_grow_at, Cvoid, (Any, Csize_t, Csize_t), ary, 50, 10)
-        for i in 51:60
-            @test !isassigned(ary, i)
-        end
+        # growat when copy into start of same buffer
+        ary = Vector{T}(undef, 10)
+        ary[:] = 1:10
+        pushfirst!(ary, 0)
+        Base._growat!(ary, 3, 5)
+        @test all(i -> !isassigned(ary, i), 3:7)
+        @test all(i -> isassigned(ary, i), 8:length(ary))
+        @test all(i -> isassigned(ary, i), 1:2)
+
+        # growat when copy into end of same buffer
+        ary = Vector{T}(undef, 10)
+        ary[:] = 1:10
+        push!(ary, 11)
+        Base._growat!(ary, 6, 10)
+        @test all(i -> !isassigned(ary, i), 6:15)
+        @test all(i -> isassigned(ary, i), 16:length(ary))
+        @test all(i -> isassigned(ary, i), 1:5)
+
+        # growat when copy to new buffer
+        ary = Vector{T}(undef, 10)
+        ary[:] = 1:10
+        Base._growat!(ary, 6, 10)
+        @test all(i -> !isassigned(ary, i), 6:15)
+        @test all(i -> isassigned(ary, i), 16:length(ary))
+        @test all(i -> isassigned(ary, i), 1:5)
     end
 end
 
@@ -4503,8 +4527,13 @@ end
 # Make sure arrayset can handle `Array{T}` (where `T` is a type and not a
 # `TypeVar`) without crashing
 let
-    function arrayset_unknown_dim(::Type{T}, n) where T
-        Base.arrayset(true, reshape(Vector{T}(undef, 1), fill(1, n)...), 2, 1)
+    @noinline function arrayset_unknown_dim(::Type{T}, n) where T
+        a = Vector{T}(undef, 1)
+        fill!(a, 0)
+        a = reshape(a, fill(1, n)...)::Array{T}
+        @test a[1] === 0
+        Core.memoryrefset!(a.ref, 2, :not_atomic, true)
+        @test a[1] === 2
     end
     arrayset_unknown_dim(Any, 1)
     arrayset_unknown_dim(Any, 2)
@@ -4514,46 +4543,6 @@ let
     arrayset_unknown_dim(Int, 3)
 end
 
-module TestSharedArrayResize
-using Test
-# Attempting to change the shape of a shared array should unshare it and
-# not modify the original data
-function test_shared_array_resize(::Type{T}) where T
-    len = 100
-    a = Vector{T}(undef, len)
-    function test_unshare(f)
-        a′ = reshape(reshape(a, (len ÷ 2, 2)), len)
-        a[:] = 1:length(a)
-        # The operation should fail on the owner shared array
-        # and has no side effect.
-        @test_throws ErrorException f(a)
-        @test a == [1:len;]
-        @test a′ == [1:len;]
-        @test pointer(a) == pointer(a′)
-        # The operation should pass on the non-owner shared array
-        # and should unshare the arrays with no effect on the original one.
-        f(a′)
-        @test a == [1:len;]
-        @test pointer(a) != pointer(a′)
-    end
-
-    test_unshare(a->ccall(:jl_array_del_end, Cvoid, (Any, Csize_t), a, 0))
-    test_unshare(a->ccall(:jl_array_del_end, Cvoid, (Any, Csize_t), a, 1))
-    test_unshare(a->ccall(:jl_array_del_beg, Cvoid, (Any, Csize_t), a, 0))
-    test_unshare(a->ccall(:jl_array_del_beg, Cvoid, (Any, Csize_t), a, 1))
-    test_unshare(a->deleteat!(a, 10))
-    test_unshare(a->deleteat!(a, 90))
-    test_unshare(a->ccall(:jl_array_grow_end, Cvoid, (Any, Csize_t), a, 0))
-    test_unshare(a->ccall(:jl_array_grow_end, Cvoid, (Any, Csize_t), a, 1))
-    test_unshare(a->ccall(:jl_array_grow_beg, Cvoid, (Any, Csize_t), a, 0))
-    test_unshare(a->ccall(:jl_array_grow_beg, Cvoid, (Any, Csize_t), a, 1))
-    test_unshare(a->insert!(a, 10, 10))
-    test_unshare(a->insert!(a, 90, 90))
-end
-test_shared_array_resize(Int)
-test_shared_array_resize(Any)
-end
-
 # Copy of `#undef`
 copyto!(Vector{Any}(undef, 10), Vector{Any}(undef, 10))
 function test_copy_alias(::Type{T}) where T
@@ -6026,10 +6015,10 @@ const unboxedunions = [Union{Int8, Nothing},
 @test Base.isbitsunion(unboxedunions[2])
 @test Base.isbitsunion(unboxedunions[3])
 
-@test Base.bitsunionsize(unboxedunions[1]) == 1
-@test Base.bitsunionsize(unboxedunions[2]) == 2
-@test Base.bitsunionsize(unboxedunions[3]) == 16
-@test Base.bitsunionsize(unboxedunions[4]) == 8
+@test Base.aligned_sizeof(unboxedunions[1]) == 1
+@test Base.aligned_sizeof(unboxedunions[2]) == 2
+@test Base.aligned_sizeof(unboxedunions[3]) == 16
+@test Base.aligned_sizeof(unboxedunions[4]) == 8
 
 @test sizeof(unboxedunions[1]) == 1
 @test sizeof(unboxedunions[2]) == 2
@@ -6337,7 +6326,7 @@ for U in unboxedunions
             resize!(A, len)
             @test length(A) === len
             @test A[1] === initvalue2(F2)
-            @test typeof(A[end]) === F
+            @test typeof(A[end]) === F2
 
             # deleteat!
             F = Base.uniontypes(U)[2]
@@ -6425,304 +6414,291 @@ for U in unboxedunions
     end
 end
 
-@testset "jl_array_grow_at_end" begin
+@testset "array _growatend!" begin
 
 # start w/ array, set & check elements, grow it, check that elements stayed correct, set & check elements
 A = Vector{Union{Missing, UInt8}}(undef, 2)
-Base.arrayset(true, A, 0x01, 1)
-Base.arrayset(true, A, missing, 2)
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
+setindex!(A, 0x01, 1)
+setindex!(A, missing, 2)
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
 
-# grow_at_end 2
 resize!(A, 5)
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === missing
-Base.arrayset(true, A, 0x03, 3)
-Base.arrayset(true, A, missing, 4)
-Base.arrayset(true, A, 0x05, 5)
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === 0x03
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === 0x05
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
+# The rest of the values are unspecified
+setindex!(A, 0x03, 3)
+setindex!(A, missing, 4)
+setindex!(A, 0x05, 5)
+@test isequal(A, [0x01, missing, 0x03, missing, 0x05])
 
 # grow_at_end 1
 Base._growat!(A, 4, 1)
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === 0x03
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === missing
-@test Base.arrayref(true, A, 6) === 0x05
-
-Base.arrayset(true, A, missing, 1)
-Base.arrayset(true, A, 0x02, 2)
-Base.arrayset(true, A, missing, 3)
-Base.arrayset(true, A, 0x04, 4)
-Base.arrayset(true, A, missing, 5)
-Base.arrayset(true, A, 0x06, 6)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === 0x02
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === 0x04
-@test Base.arrayref(true, A, 5) === missing
-@test Base.arrayref(true, A, 6) === 0x06
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === 0x03
+#A[4] is unspecified
+@test getindex(A, 5) === missing
+@test getindex(A, 6) === 0x05
+
+setindex!(A, missing, 1)
+setindex!(A, 0x02, 2)
+setindex!(A, missing, 3)
+setindex!(A, 0x04, 4)
+setindex!(A, missing, 5)
+setindex!(A, 0x06, 6)
+@test isequal(A, [missing, 0x2, missing, 0x4, missing, 0x6])
 
 # grow_at_end 5
 Base._growat!(A, 4, 1)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === 0x02
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === 0x04
-@test Base.arrayref(true, A, 6) === missing
-@test Base.arrayref(true, A, 7) === 0x06
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === 0x02
+@test getindex(A, 3) === missing
+#A[4] is unspecified
+@test getindex(A, 5) === 0x04
+@test getindex(A, 6) === missing
+@test getindex(A, 7) === 0x06
 
 # grow_at_end 6
 resize!(A, 8)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === 0x02
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === 0x04
-@test Base.arrayref(true, A, 6) === missing
-@test Base.arrayref(true, A, 7) === 0x06
-@test Base.arrayref(true, A, 8) === missing
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === 0x02
+@test getindex(A, 3) === missing
+# A[4] still unspecified
+@test getindex(A, 5) === 0x04
+@test getindex(A, 6) === missing
+@test getindex(A, 7) === 0x06
+# A[8] is unspecified but test that it exists
+@test getindex(A, 8) isa Any
 
 # grow_at_end 4
 resize!(A, 1048576)
 resize!(A, 1048577)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === 0x02
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === 0x04
-@test Base.arrayref(true, A, 6) === missing
-@test Base.arrayref(true, A, 7) === 0x06
-@test Base.arrayref(true, A, 8) === missing
-foreach(9:1048577) do i
-    @test Base.arrayref(true, A, i) === missing
-end
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === 0x02
+@test getindex(A, 3) === missing
+# A[4] is stil still unspecified
+@test getindex(A, 5) === 0x04
+@test getindex(A, 6) === missing
+@test getindex(A, 7) === 0x06
+@test getindex(A, 8) === missing
+# 9:1048577 are unspecified
 foreach(9:1048577) do i
-    Base.arrayset(true, A, i % UInt8, i)
-    @test Base.arrayref(true, A, i) === i % UInt8
+    setindex!(A, i % UInt8, i)
+    @test getindex(A, i) === i % UInt8
 end
 
 # grow_at_end 3
 A = Vector{Union{Missing, UInt8}}(undef, 1048577)
 foreach(1:1048577) do i
-    @test Base.arrayref(true, A, i) === missing
-    Base.arrayset(true, A, i % UInt8, i)
-    @test Base.arrayref(true, A, i) === i % UInt8
+    @test getindex(A, i) === missing
+    setindex!(A, i % UInt8, i)
+    @test getindex(A, i) === i % UInt8
 end
 Base._growat!(A, 1048576, 1)
 @test length(A) == 1048578
 foreach(1:1048575) do i
-    @test Base.arrayref(true, A, i) === i % UInt8
+    @test getindex(A, i) === i % UInt8
     @test A[i] === i % UInt8
 end
-@test Base.arrayref(true, A, 1048576) === missing
-@test Base.arrayref(true, A, 1048577) === 1048576 % UInt8
-@test Base.arrayref(true, A, 1048578) === 1048577 % UInt8
+@test getindex(A, 1048576) === missing
+@test getindex(A, 1048577) === 1048576 % UInt8
+@test getindex(A, 1048578) === 1048577 % UInt8
 
 end # @testset
 
-@testset "jl_array_grow_at_beg" begin
+@testset "array _growatbeg!" begin
 
 # grow_at_beg 4
 A = Vector{Union{Missing, UInt8}}(undef, 5)
-Base.arrayset(true, A, 0x01, 1)
-Base.arrayset(true, A, missing, 2)
-Base.arrayset(true, A, 0x03, 3)
-Base.arrayset(true, A, missing, 4)
-Base.arrayset(true, A, 0x05, 5)
+setindex!(A, 0x01, 1)
+setindex!(A, missing, 2)
+setindex!(A, 0x03, 3)
+setindex!(A, missing, 4)
+setindex!(A, 0x05, 5)
 Base._growat!(A, 1, 1)
 
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === 0x01
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === 0x03
-@test Base.arrayref(true, A, 5) === missing
-@test Base.arrayref(true, A, 6) === 0x05
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === 0x01
+@test getindex(A, 3) === missing
+@test getindex(A, 4) === 0x03
+@test getindex(A, 5) === missing
+@test getindex(A, 6) === 0x05
 
 # grow_at_beg 2
 Base._growat!(A, 1, 1)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === 0x01
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === 0x03
-@test Base.arrayref(true, A, 6) === missing
-@test Base.arrayref(true, A, 7) === 0x05
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === 0x01
+@test getindex(A, 4) === missing
+@test getindex(A, 5) === 0x03
+@test getindex(A, 6) === missing
+@test getindex(A, 7) === 0x05
 
 # grow_at_beg 1
 Base._growat!(A, 2, 1)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === 0x01
-@test Base.arrayref(true, A, 5) === missing
-@test Base.arrayref(true, A, 6) === 0x03
-@test Base.arrayref(true, A, 7) === missing
-@test Base.arrayref(true, A, 8) === 0x05
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === missing
+@test getindex(A, 4) === 0x01
+@test getindex(A, 5) === missing
+@test getindex(A, 6) === 0x03
+@test getindex(A, 7) === missing
+@test getindex(A, 8) === 0x05
 
 # grow_at_beg 9
 Base._growat!(A, 1, 1)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === 0x01
-@test Base.arrayref(true, A, 6) === missing
-@test Base.arrayref(true, A, 7) === 0x03
-@test Base.arrayref(true, A, 8) === missing
-@test Base.arrayref(true, A, 9) === 0x05
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === missing
+@test getindex(A, 4) === missing
+@test getindex(A, 5) === 0x01
+@test getindex(A, 6) === missing
+@test getindex(A, 7) === 0x03
+@test getindex(A, 8) === missing
+@test getindex(A, 9) === 0x05
 
 # grow_at_beg 8
 A = Vector{Union{Missing, UInt8}}(undef, 5)
-Base.arrayset(true, A, 0x01, 1)
-Base.arrayset(true, A, missing, 2)
-Base.arrayset(true, A, 0x03, 3)
-Base.arrayset(true, A, missing, 4)
-Base.arrayset(true, A, 0x05, 5)
+setindex!(A, 0x01, 1)
+setindex!(A, missing, 2)
+setindex!(A, 0x03, 3)
+setindex!(A, missing, 4)
+setindex!(A, 0x05, 5)
 Base._growat!(A, 2, 1)
 Base._growat!(A, 2, 1)
 
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === 0x03
-@test Base.arrayref(true, A, 6) === missing
-@test Base.arrayref(true, A, 7) === 0x05
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === missing
+@test getindex(A, 4) === missing
+@test getindex(A, 5) === 0x03
+@test getindex(A, 6) === missing
+@test getindex(A, 7) === 0x05
 
 # grow_at_beg 5
 A = Vector{Union{Missing, UInt8}}(undef, 5)
-Base.arrayset(true, A, 0x01, 1)
-Base.arrayset(true, A, missing, 2)
-Base.arrayset(true, A, 0x03, 3)
-Base.arrayset(true, A, missing, 4)
-Base.arrayset(true, A, 0x05, 5)
+setindex!(A, 0x01, 1)
+setindex!(A, missing, 2)
+setindex!(A, 0x03, 3)
+setindex!(A, missing, 4)
+setindex!(A, 0x05, 5)
 Base._growat!(A, 4, 1)
 Base._growat!(A, 4, 1)
 
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === 0x03
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === missing
-@test Base.arrayref(true, A, 6) === missing
-@test Base.arrayref(true, A, 7) === 0x05
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === 0x03
+@test getindex(A, 4) === missing
+@test getindex(A, 5) === missing
+@test getindex(A, 6) === missing
+@test getindex(A, 7) === 0x05
 
 # grow_at_beg 6
 Base._growat!(A, 2, 3)
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === missing
-@test Base.arrayref(true, A, 6) === 0x03
-@test Base.arrayref(true, A, 7) === missing
-@test Base.arrayref(true, A, 8) === missing
-@test Base.arrayref(true, A, 9) === missing
-@test Base.arrayref(true, A, 10) === 0x05
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === missing
+@test getindex(A, 4) === missing
+@test getindex(A, 5) === missing
+@test getindex(A, 6) === 0x03
+@test getindex(A, 7) === missing
+@test getindex(A, 8) === missing
+@test getindex(A, 9) === missing
+@test getindex(A, 10) === 0x05
 
 # grow_at_beg 3
 A = Vector{Union{Missing, UInt8}}(undef, 1048577)
-Base.arrayset(true, A, 0x01, 1)
-Base.arrayset(true, A, missing, 2)
-Base.arrayset(true, A, 0x03, 3)
-Base.arrayset(true, A, missing, 4)
-Base.arrayset(true, A, 0x05, 5)
+setindex!(A, 0x01, 1)
+setindex!(A, missing, 2)
+setindex!(A, 0x03, 3)
+setindex!(A, missing, 4)
+setindex!(A, 0x05, 5)
 Base._growat!(A, 2, 1)
 
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === 0x03
-@test Base.arrayref(true, A, 5) === missing
-@test Base.arrayref(true, A, 6) === 0x05
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === missing
+@test getindex(A, 4) === 0x03
+@test getindex(A, 5) === missing
+@test getindex(A, 6) === 0x05
 
 foreach(7:length(A)) do i
-    @test Base.arrayref(true, A, i) === missing
-    Base.arrayset(true, A, i % UInt8, i)
-    @test Base.arrayref(true, A, i) === i % UInt8
+    @test getindex(A, i) === missing
+    setindex!(A, i % UInt8, i)
+    @test getindex(A, i) === i % UInt8
 end
 
 end # @testset
 
-@testset "jl_array_del_at_beg" begin
+@testset "array _deleteatbeg!" begin
 
 A = Vector{Union{Missing, UInt8}}(undef, 5)
-Base.arrayset(true, A, 0x01, 1)
-Base.arrayset(true, A, missing, 2)
-Base.arrayset(true, A, 0x03, 3)
-Base.arrayset(true, A, missing, 4)
-Base.arrayset(true, A, 0x05, 5)
+setindex!(A, 0x01, 1)
+setindex!(A, missing, 2)
+setindex!(A, 0x03, 3)
+setindex!(A, missing, 4)
+setindex!(A, 0x05, 5)
 Base._deleteat!(A, 2, 1)
 
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === 0x03
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === 0x05
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === 0x03
+@test getindex(A, 3) === missing
+@test getindex(A, 4) === 0x05
 
 Base._deleteat!(A, 1, 1)
-@test Base.arrayref(true, A, 1) === 0x03
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === 0x05
+@test getindex(A, 1) === 0x03
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === 0x05
 
 A = Vector{Union{Missing, UInt8}}(undef, 5)
-Base.arrayset(true, A, 0x01, 1)
-Base.arrayset(true, A, missing, 2)
-Base.arrayset(true, A, 0x03, 3)
-Base.arrayset(true, A, missing, 4)
-Base.arrayset(true, A, 0x05, 5)
+setindex!(A, 0x01, 1)
+setindex!(A, missing, 2)
+setindex!(A, 0x03, 3)
+setindex!(A, missing, 4)
+setindex!(A, 0x05, 5)
 Base._growat!(A, 1, 1)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === 0x01
-@test Base.arrayref(true, A, 3) === missing
-@test Base.arrayref(true, A, 4) === 0x03
-@test Base.arrayref(true, A, 5) === missing
-@test Base.arrayref(true, A, 6) === 0x05
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === 0x01
+@test getindex(A, 3) === missing
+@test getindex(A, 4) === 0x03
+@test getindex(A, 5) === missing
+@test getindex(A, 6) === 0x05
 Base._deleteat!(A, 2, 1)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === 0x03
-@test Base.arrayref(true, A, 4) === missing
-@test Base.arrayref(true, A, 5) === 0x05
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === 0x03
+@test getindex(A, 4) === missing
+@test getindex(A, 5) === 0x05
 Base._deleteat!(A, 1, 2)
-@test Base.arrayref(true, A, 1) === 0x03
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === 0x05
+@test getindex(A, 1) === 0x03
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === 0x05
 Base._deleteat!(A, 1, 1)
-@test Base.arrayref(true, A, 1) === missing
-@test Base.arrayref(true, A, 2) === 0x05
+@test getindex(A, 1) === missing
+@test getindex(A, 2) === 0x05
 
 end # @testset
 
-@testset "jl_array_del_at_end" begin
+@testset "array _deleteatend!" begin
 
 A = Vector{Union{Missing, UInt8}}(undef, 5)
-Base.arrayset(true, A, 0x01, 1)
-Base.arrayset(true, A, missing, 2)
-Base.arrayset(true, A, 0x03, 3)
-Base.arrayset(true, A, missing, 4)
-Base.arrayset(true, A, 0x05, 5)
+setindex!(A, 0x01, 1)
+setindex!(A, missing, 2)
+setindex!(A, 0x03, 3)
+setindex!(A, missing, 4)
+setindex!(A, 0x05, 5)
 Base._deleteat!(A, 5, 1)
 
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === 0x03
-@test Base.arrayref(true, A, 4) === missing
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === 0x03
+@test getindex(A, 4) === missing
 
 Base._deleteat!(A, 3, 1)
-@test Base.arrayref(true, A, 1) === 0x01
-@test Base.arrayref(true, A, 2) === missing
-@test Base.arrayref(true, A, 3) === missing
+@test getindex(A, 1) === 0x01
+@test getindex(A, 2) === missing
+@test getindex(A, 3) === missing
 
 end # @testset
 
@@ -6744,23 +6720,23 @@ end
 
 # jl_array_shrink
 let A=Vector{Union{UInt8, Missing}}(undef, 1048577)
-    Base.arrayset(true, A, 0x01, 1)
-    Base.arrayset(true, A, missing, 2)
-    Base.arrayset(true, A, 0x03, 3)
-    Base.arrayset(true, A, missing, 4)
-    Base.arrayset(true, A, 0x05, 5)
+    setindex!(A, 0x01, 1)
+    setindex!(A, missing, 2)
+    setindex!(A, 0x03, 3)
+    setindex!(A, missing, 4)
+    setindex!(A, 0x05, 5)
     deleteat!(A, 6:1048577)
-    @test Base.arrayref(true, A, 1) === 0x01
-    @test Base.arrayref(true, A, 2) === missing
-    @test Base.arrayref(true, A, 3) === 0x03
-    @test Base.arrayref(true, A, 4) === missing
-    @test Base.arrayref(true, A, 5) === 0x05
+    @test getindex(A, 1) === 0x01
+    @test getindex(A, 2) === missing
+    @test getindex(A, 3) === 0x03
+    @test getindex(A, 4) === missing
+    @test getindex(A, 5) === 0x05
     sizehint!(A, 5)
-    @test Base.arrayref(true, A, 1) === 0x01
-    @test Base.arrayref(true, A, 2) === missing
-    @test Base.arrayref(true, A, 3) === 0x03
-    @test Base.arrayref(true, A, 4) === missing
-    @test Base.arrayref(true, A, 5) === 0x05
+    @test getindex(A, 1) === 0x01
+    @test getindex(A, 2) === missing
+    @test getindex(A, 3) === 0x03
+    @test getindex(A, 4) === missing
+    @test getindex(A, 5) === 0x05
 end
 
 # copyto!/vcat w/ internal padding
@@ -6778,14 +6754,14 @@ primitive type TypeWith24Bits 24 end
 TypeWith24Bits(x::UInt32) = Core.Intrinsics.trunc_int(TypeWith24Bits, x)
 let x = TypeWith24Bits(0x112233), y = TypeWith24Bits(0x445566), z = TypeWith24Bits(0x778899)
     a = [x, x]
-    Core.arrayset(true, a, y, 2)
+    Core.memoryrefset!(Core.memoryref(a.ref, 2, true), y, :not_atomic, true)
     @test a == [x, y]
     a[2] = z
     @test a == [x, z]
     @test pointer(a, 2) - pointer(a, 1) == 4
 
     b = [(x, x), (x, x)]
-    Core.arrayset(true, b, (x, y), 2)
+    Core.memoryrefset!(Core.memoryref(b.ref, 2, true), (x, y), :not_atomic, true)
     @test b == [(x, x), (x, y)]
     b[2] = (y, z)
     @test b == [(x, x), (y, z)]
@@ -7504,16 +7480,11 @@ function f34482()
     Base.not_int("ABC")
     1
 end
-function g34482()
-    Core.Intrinsics.arraylen(1)
-    1
-end
 function h34482()
     Core.Intrinsics.bitcast(1, 1)
     1
 end
 @test_throws ErrorException f34482()
-@test_throws TypeError g34482()
 @test_throws TypeError h34482()
 
 struct NFANode34126
diff --git a/test/embedding/embedding.c b/test/embedding/embedding.c
index c5b8845b7c823..746c59fc8ce1f 100644
--- a/test/embedding/embedding.c
+++ b/test/embedding/embedding.c
@@ -86,17 +86,17 @@ int main()
         // (aka, is gc-rooted until) the program reaches the corresponding JL_GC_POP()
         JL_GC_PUSH1(&x);
 
-        double* xData = jl_array_data(x);
+        double* xData = jl_array_data(x, double);
 
         size_t i;
-        for (i = 0; i < jl_array_len(x); i++)
+        for (i = 0; i < jl_array_nrows(x); i++)
             xData[i] = i;
 
         jl_function_t *func  = jl_get_function(jl_base_module, "reverse!");
         jl_call1(func, (jl_value_t*) x);
 
         printf("x = [");
-        for (i = 0; i < jl_array_len(x); i++)
+        for (i = 0; i < jl_array_nrows(x); i++)
             printf("%e ", xData[i]);
         printf("]\n");
         fflush(stdout);
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 3098b684375ec..04af56fb208af 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -460,7 +460,7 @@ let err_str,
     @test startswith(sprint(show, which(StructWithUnionAllMethodDefs{<:Integer}, (Any,))),
                      "($(curmod_prefix)StructWithUnionAllMethodDefs{T} where T<:Integer)(x)")
     @test repr("text/plain", FunctionLike()) == "(::$(curmod_prefix)FunctionLike) (generic function with 1 method)"
-    @test repr("text/plain", Core.arraysize) == "arraysize (built-in function)"
+    @test repr("text/plain", Core.getfield) == "getfield (built-in function)"
 
     err_str = @except_stackframe String() ErrorException
     @test err_str == "String() at $sn:$(method_defs_lineno + 0)"
diff --git a/test/llvmpasses/names.jl b/test/llvmpasses/names.jl
index 6cb92dd7d3724..ad2f418fbd077 100644
--- a/test/llvmpasses/names.jl
+++ b/test/llvmpasses/names.jl
@@ -22,16 +22,6 @@ function f2(a, b, c, d, e...)
     return a + b + c + d + sum(e)
 end
 
-# COM: check basic parameter names + array allocation function name
-function f3(a, b, c, d)
-    return [a + b + c + d]
-end
-
-# COM: check basic parameter name + array allocation function name + array
-function f4(n)
-    return zeros(n)
-end
-
 mutable struct D
     i::Int64
 end
@@ -133,24 +123,6 @@ emit(f2, Float64, Float64, Float64, Float64, Float64, Float64)
 # CHECK-SAME: double %"e[3]::Float64"
 emit(f2, Float64, Float64, Float64, Float64, Float64, Float64, Float64)
 
-# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_f3
-# CHECK-SAME: double %"a::Float64"
-# CHECK-SAME: double %"b::Float64"
-# CHECK-SAME: double %"c::Float64"
-# CHECK-SAME: double %"d::Float64"
-# CHECK: call nonnull {} addrspace(10)* {{.*}} @jlplt_ijl_alloc_array_1d
-# CHECK-SAME: @"+Core.Array
-emit(f3, Float64, Float64, Float64, Float64)
-
-# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_f4
-# CHECK-SAME: %"n::Int64"
-# CHECK: call nonnull {} addrspace(10)* {{.*}} @jlplt_ijl_alloc_array_1d
-# CHECK-SAME: @"+Core.Array
-# CHECK: %.length_ptr
-# CHECK: %.length
-# CHECK: %.data
-emit(f4, Int64)
-
 # CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_f5
 # CHECK-SAME: %"a::A"
 # CHECK: %"a::A.b_ptr.c_ptr.d
diff --git a/test/llvmpasses/pipeline-o2.jl b/test/llvmpasses/pipeline-o2.jl
index 9fd42562f96aa..3ce2f692fc32e 100644
--- a/test/llvmpasses/pipeline-o2.jl
+++ b/test/llvmpasses/pipeline-o2.jl
@@ -2,8 +2,8 @@
 
 # RUN: export JULIA_LLVM_ARGS="--opaque-pointers=0"
 
-# RUN: julia --startup-file=no -O2 --check-bounds=yes %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL
-# RUN: julia --startup-file=no -O3 --check-bounds=yes %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL
+# RUNx: julia --startup-file=no -O2 --check-bounds=yes %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL
+# RUNx: julia --startup-file=no -O3 --check-bounds=yes %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL
 
 # RUN: julia --startup-file=no -O2 --check-bounds=no %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL,BC_OFF
 # RUN: julia --startup-file=no -O3 --check-bounds=no %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL,BC_OFF
@@ -13,8 +13,8 @@
 
 # RUN: export JULIA_LLVM_ARGS="--opaque-pointers=1"
 
-# RUN: julia --startup-file=no -O2 --check-bounds=yes %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL
-# RUN: julia --startup-file=no -O3 --check-bounds=yes %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL
+# RUNx: julia --startup-file=no -O2 --check-bounds=yes %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL
+# RUNx: julia --startup-file=no -O3 --check-bounds=yes %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL
 
 # RUN: julia --startup-file=no -O2 --check-bounds=no %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL,BC_OFF
 # RUN: julia --startup-file=no -O3 --check-bounds=no %s %t -O && llvm-link -S %t/* | FileCheck %s --check-prefixes=ALL,BC_OFF
diff --git a/test/offsetarray.jl b/test/offsetarray.jl
index 3e1acff67b546..7f415c9cc7337 100644
--- a/test/offsetarray.jl
+++ b/test/offsetarray.jl
@@ -627,15 +627,15 @@ end
     B = OffsetArray(reshape(1:24, 4, 3, 2), -5, 6, -7)
     for R in (fill(0, -4:-1), fill(0, -4:-1, 7:7), fill(0, -4:-1, 7:7, -6:-6))
         @test @inferred(maximum!(R, B)) == reshape(maximum(B, dims=(2,3)), axes(R)) == reshape(21:24, axes(R))
-        @test @allocated(maximum!(R, B)) <= 300
+        @test @allocated(maximum!(R, B)) <= 400
         @test @inferred(minimum!(R, B)) == reshape(minimum(B, dims=(2,3)), axes(R)) == reshape(1:4, axes(R))
-        @test @allocated(minimum!(R, B)) <= 300
+        @test @allocated(minimum!(R, B)) <= 400
     end
     for R in (fill(0, -4:-4, 7:9), fill(0, -4:-4, 7:9, -6:-6))
         @test @inferred(maximum!(R, B)) == reshape(maximum(B, dims=(1,3)), axes(R)) == reshape(16:4:24, axes(R))
-        @test @allocated(maximum!(R, B)) <= 300
+        @test @allocated(maximum!(R, B)) <= 400
         @test @inferred(minimum!(R, B)) == reshape(minimum(B, dims=(1,3)), axes(R)) == reshape(1:4:9, axes(R))
-        @test @allocated(minimum!(R, B)) <= 300
+        @test @allocated(minimum!(R, B)) <= 400
     end
     @test_throws DimensionMismatch maximum!(fill(0, -4:-1, 7:7, -6:-6, 1:1), B)
     @test_throws DimensionMismatch minimum!(fill(0, -4:-1, 7:7, -6:-6, 1:1), B)
diff --git a/test/precompile.jl b/test/precompile.jl
index fc4ab2490c4a8..8fd8e0a110cbb 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -271,6 +271,23 @@ precompile_test_harness(false) do dir
               # check that Tasks work from serialized state
               ch1 = Channel(x -> nothing)
               ch2 = Channel(x -> (push!(x, 2); nothing), Inf)
+
+              # check that Memory aliasing is respected
+              a_vec_int = Int[]
+              push!(a_vec_int, 1, 2)
+              a_mat_int = reshape(a_vec_int, (1, 2))
+
+              a_vec_any = Any[]
+              push!(a_vec_any, 1, 2)
+              a_mat_any = reshape(a_vec_any, (1, 2))
+
+              a_vec_union = Union{Int,Nothing}[]
+              push!(a_vec_union, 1, 2)
+              a_mat_union = reshape(a_vec_union, (1, 2))
+
+              a_vec_inline = Pair{Int,Any}[]
+              push!(a_vec_inline, 1=>2, 3=>4)
+              a_mat_inline = reshape(a_vec_inline, (1, 2))
           end
           """)
     # Issue #12623
@@ -332,6 +349,30 @@ precompile_test_harness(false) do dir
         @test !isready(Foo.ch2)
     end
 
+    let
+        @test Foo.a_vec_int == Int[1, 2]
+        @test Foo.a_mat_int == Int[1 2]
+        Foo.a_mat_int[1, 2] = 3
+        @test Foo.a_vec_int[2] === 3
+
+        @test Foo.a_vec_any == Int[1, 2]
+        @test Foo.a_mat_any == Int[1 2]
+        Foo.a_mat_any[1, 2] = 3
+        @test Foo.a_vec_any[2] === 3
+
+        @test Foo.a_vec_union == Union{Int,Nothing}[1, 2]
+        @test Foo.a_mat_union == Union{Int,Nothing}[1 2]
+        Foo.a_mat_union[1, 2] = 3
+        @test Foo.a_vec_union[2] === 3
+        Foo.a_mat_union[1, 2] = nothing
+        @test Foo.a_vec_union[2] === nothing
+
+        @test Foo.a_vec_inline == Pair{Int,Any}[1=>2, 3=>4]
+        @test Foo.a_mat_inline == Pair{Int,Any}[1=>2 3=>4]
+        Foo.a_mat_inline[1, 2] = 5=>6
+        @test Foo.a_vec_inline[2] === Pair{Int,Any}(5, 6)
+    end
+
     @eval begin function ccallable_test()
         Base.llvmcall(
         ("""declare i32 @f35014(i32)
@@ -727,15 +768,15 @@ precompile_test_harness("code caching") do dir
     @test hasspec
     # Test that compilation adds to method roots with appropriate provenance
     m = which(setindex!, (Dict{M.X,Any}, Any, M.X))
-    @test M.X ∈ m.roots
+    @test Memory{M.X} ∈ m.roots
     # Check that roots added outside of incremental builds get attributed to a moduleid of 0
     Base.invokelatest() do
         Dict{M.X2,Any}()[M.X2()] = nothing
     end
-    @test M.X2 ∈ m.roots
+    @test Memory{M.X2} ∈ m.roots
     groups = group_roots(m)
-    @test M.X ∈ groups[Mid]           # attributed to M
-    @test M.X2 ∈ groups[0]            # activate module is not known
+    @test Memory{M.X} ∈ groups[Mid]           # attributed to M
+    @test Memory{M.X2} ∈ groups[0]            # activate module is not known
     @test !isempty(groups[Bid])
     # Check that internal methods and their roots are accounted appropriately
     minternal = which(M.getelsize, (Vector,))
@@ -785,10 +826,10 @@ precompile_test_harness("code caching") do dir
     end
     mT = which(push!, (Vector{T} where T, Any))
     groups = group_roots(mT)
-    @test M2.Y ∈ groups[M2id]
-    @test M2.Z ∈ groups[M2id]
-    @test M.X ∈ groups[Mid]
-    @test M.X ∉ groups[M2id]
+    @test Memory{M2.Y} ∈ groups[M2id]
+    @test Memory{M2.Z} ∈ groups[M2id]
+    @test Memory{M.X} ∈ groups[Mid]
+    @test Memory{M.X} ∉ groups[M2id]
     # backedges of external MethodInstances
     # Root gets used by RootA and RootB, and both consumers end up inferring the same MethodInstance from Root
     # Do both callers get listed as backedges?
diff --git a/test/reflection.jl b/test/reflection.jl
index c0f32e39805e5..7df6a76dfd0ff 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -614,11 +614,16 @@ end
              sizeof(Real))
 @test sizeof(Union{ComplexF32,ComplexF64}) == 16
 @test sizeof(Union{Int8,UInt8}) == 1
-@test_throws ErrorException sizeof(AbstractArray)
+@test sizeof(MemoryRef{Int}) == 2 * sizeof(Int)
+@test sizeof(GenericMemoryRef{:atomic,Int,Core.CPU}) == 2 * sizeof(Int)
+@test sizeof(Array{Int,0}) == 2 * sizeof(Int)
+@test sizeof(Array{Int,1}) == 3 * sizeof(Int)
+@test sizeof(Array{Int,2}) == 4 * sizeof(Int)
+@test sizeof(Array{Int,20}) == 22 * sizeof(Int)
 @test_throws ErrorException sizeof(Tuple)
 @test_throws ErrorException sizeof(Tuple{Any,Any})
 @test_throws ErrorException sizeof(String)
-@test_throws ErrorException sizeof(Vector{Int})
+@test_throws ErrorException sizeof(Memory{false,Int})
 @test_throws ErrorException sizeof(Symbol)
 @test_throws ErrorException sizeof(Core.SimpleVector)
 @test_throws ErrorException sizeof(Union{})
@@ -923,7 +928,7 @@ end
 @test nameof(Any) === :Any
 @test nameof(:) === :Colon
 @test nameof(Core.Intrinsics.mul_int) === :mul_int
-@test nameof(Core.Intrinsics.arraylen) === :arraylen
+@test nameof(Core.Intrinsics.cglobal) === :cglobal
 
 module TestMod33403
 f(x) = 1
@@ -1039,7 +1044,7 @@ ambig_effects_test(a, b) = 1
     @test Base.infer_effects(typeof, (Any,)) |> Core.Compiler.is_foldable_nothrow
     @test Base.infer_effects(===, (Any,Any)) |> Core.Compiler.is_foldable_nothrow
     @test (Base.infer_effects(setfield!, ()); true) # `builtin_effects` shouldn't throw on empty `argtypes`
-    @test (Base.infer_effects(Core.Intrinsics.arraylen, ()); true) # `intrinsic_effects` shouldn't throw on empty `argtypes`
+    @test (Base.infer_effects(Core.Intrinsics.mul_int, ()); true) # `intrinsic_effects` shouldn't throw on empty `argtypes`
 end
 
 @test Base._methods_by_ftype(Tuple{}, -1, Base.get_world_counter()) == Any[]
diff --git a/test/show.jl b/test/show.jl
index f95f943c3c1a4..0e11552f484ee 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1969,12 +1969,12 @@ end
 end
 
 @testset "Intrinsic printing" begin
-    @test sprint(show, Core.Intrinsics.arraylen) == "Core.Intrinsics.arraylen"
-    @test repr(Core.Intrinsics.arraylen) == "Core.Intrinsics.arraylen"
+    @test sprint(show, Core.Intrinsics.cglobal) == "Core.Intrinsics.cglobal"
+    @test repr(Core.Intrinsics.cglobal) == "Core.Intrinsics.cglobal"
     let io = IOBuffer()
-        show(io, MIME"text/plain"(), Core.Intrinsics.arraylen)
+        show(io, MIME"text/plain"(), Core.Intrinsics.cglobal)
         str = String(take!(io))
-        @test occursin("arraylen", str)
+        @test occursin("cglobal", str)
         @test occursin("(intrinsic function", str)
     end
     @test string(Core.Intrinsics.add_int) == "add_int"
diff --git a/test/sorting.jl b/test/sorting.jl
index f89291c8a685a..1164f2932d880 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -972,8 +972,8 @@ end
 
 @testset "ScratchQuickSort allocations on non-concrete eltype" begin
     v = Vector{Union{Nothing, Bool}}(rand(Bool, 10000))
-    @test 4 == @allocations sort(v)
-    @test 4 == @allocations sort(v; alg=Base.Sort.ScratchQuickSort())
+    @test 10 > @allocations sort(v)
+    @test 10 > @allocations sort(v; alg=Base.Sort.ScratchQuickSort())
     # it would be nice if these numbers were lower (1 or 2), but these
     # test that we don't have O(n) allocations due to type instability
 end
@@ -981,15 +981,15 @@ end
 function test_allocs()
     v = rand(10)
     i = randperm(length(v))
-    @test 1 == @allocations sort(v)
+    @test 2 >= @allocations sort(v)
     @test 0 == @allocations sortperm!(i, v)
     @test 0 == @allocations sort!(i)
     @test 0 == @allocations sortperm!(i, v, rev=true)
-    @test 1 == @allocations sortperm(v, rev=true)
-    @test 1 == @allocations sortperm(v, rev=false)
+    @test 2 >= @allocations sortperm(v, rev=true)
+    @test 2 >= @allocations sortperm(v, rev=false)
     @test 0 == @allocations sortperm!(i, v, order=Base.Reverse)
-    @test 1 == @allocations sortperm(v)
-    @test 1 == @allocations sortperm(i, by=sqrt)
+    @test 2 >= @allocations sortperm(v)
+    @test 2 >= @allocations sortperm(i, by=sqrt)
     @test 0 == @allocations sort!(v, lt=(a, b) -> hash(a) < hash(b))
     sort!(Int[], rev=false) # compile
     @test 0 == @allocations sort!(i, rev=false)

From 8382d51cb8c4183b998c960ddab31a7e76415c60 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Fri, 27 Oct 2023 11:55:46 -0400
Subject: [PATCH 0102/1315] Insert the GC preserve into the expanded docs
 (#51884)

The expanded form is not fully correct since it misses the preservation
of
the return value from `cconvert`. The text below talks about the fact
that
`cconvert` should do the allocations necessary, but the expanded code is
incorrect for any `cconvert` that actually does this.
---
 doc/src/manual/calling-c-and-fortran-code.md | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/doc/src/manual/calling-c-and-fortran-code.md b/doc/src/manual/calling-c-and-fortran-code.md
index 7b889589c592d..2602a8b129b2b 100644
--- a/doc/src/manual/calling-c-and-fortran-code.md
+++ b/doc/src/manual/calling-c-and-fortran-code.md
@@ -253,10 +253,14 @@ to the specified type. For example, the following call:
 will behave as if it were written like this:
 
 ```julia
-@ccall "libfoo".foo(
-    Base.unsafe_convert(Int32, Base.cconvert(Int32, x))::Int32,
-    Base.unsafe_convert(Float64, Base.cconvert(Float64, y))::Float64
+c_x = Base.cconvert(Int32, x)
+c_y = Base.cconvert(Float64, y)
+GC.@preserve c_x c_y begin
+    @ccall "libfoo".foo(
+        Base.unsafe_convert(Int32, c_x)::Int32,
+        Base.unsafe_convert(Float64, c_y)::Float64
     )::Cvoid
+end
 ```
 
 [`Base.cconvert`](@ref) normally just calls [`convert`](@ref), but can be defined to return an

From 199cac7d1d474d6bf512943fb6485a53e574e8eb Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Fri, 27 Oct 2023 10:38:05 -0700
Subject: [PATCH 0103/1315] Strip trailing slashes in `JULIA_DEPOT_PATH` when
 embedding `@depot` (#51892)

The new relocatable cache file work uses simple text substitution when
stripping out the depot from a cache file's paths, and when substituting
it in again over the `@depot` marker. However, if a user starts julia
with `JULIA_DEPOT_PATH=/opt/foo/`, the embedded path for `Foo.jl`'s
includes list will look like `@depotpackages/Foo/XYZ/src/Foo.jl`, and if
the user then uses `JULIA_DEPOT_PATH=/opt/foo` (which should be
equivalent) the cache file will fail to load with the message:

```
Failed to determine depot from srctext files
```

This commit standardizes the serialization format to always contain a
trailing `pathsep()`, so that textual substitution is more likely to
work regardless of slightly-inconsistent `JULIA_DEPOT_PATH` settings.
---
 base/loading.jl       | 13 ++++++++++---
 test/relocatedepot.jl |  2 +-
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index bb6ab6e870262..dc532a668bea6 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2600,8 +2600,15 @@ end
 
 function replace_depot_path(path::AbstractString)
     for depot in DEPOT_PATH
+        # Skip depots that don't exist
+        if !isdirpath(depot)
+            continue
+        end
+
+        # Strip extraneous pathseps through normalization.
+        depot = dirname(depot)
         if startswith(path, depot)
-            path = replace(path, depot => "@depot")
+            path = replace(path, depot => "@depot"; count=1)
             break
         end
     end
@@ -2619,7 +2626,7 @@ function resolve_depot(includes)
     end
     for depot in DEPOT_PATH
         if all(includes) do inc
-                isfile(replace(inc, r"^@depot" => depot))
+                isfile(replace(inc, r"^@depot" => depot; count=1))
             end
             return depot
         end
@@ -2725,7 +2732,7 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
         @debug "Missing @depot tag for include dependencies in cache file $cachefile."
     else
         for inc in includes
-            inc.filename = replace(inc.filename, r"^@depot" => depot)
+            inc.filename = replace(inc.filename, r"^@depot" => depot; count=1)
         end
     end
     includes_srcfiles_only = includes[keepidx]
diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
index 91f03d59cc168..18d8c98c637c9 100644
--- a/test/relocatedepot.jl
+++ b/test/relocatedepot.jl
@@ -37,7 +37,7 @@ if !test_relocated_depot
         pkgname = "RelocationTestPkg2"
         test_harness() do
             push!(LOAD_PATH, @__DIR__)
-            push!(DEPOT_PATH, @__DIR__)
+            push!(DEPOT_PATH, string(@__DIR__, "/"))
             pkg = Base.identify_package(pkgname)
             cachefiles = Base.find_all_in_cache_path(pkg)
             rm.(cachefiles, force=true)

From 8a9476f76e7a7b05ee68f055c44c4205360da399 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Fri, 27 Oct 2023 13:53:19 -0700
Subject: [PATCH 0104/1315] [REPL] Fix shell completion error on unreadable
 symlink (#51851)

In macOS there is a file, `/usr/sbin/weakpass_edit` that is a symlink to
a directory that is only readable by `root`. Our REPL shell completion
attempts to call `isfile()` when entering the shell mode and pressing
`w`, throwing an ugly error into the REPL.

This PR fixes the root cause (skipping files that fail the `isfile()`
condition) and adds a test that synthesizes an analogous condition.
---
 stdlib/REPL/src/REPLCompletions.jl  | 15 +++++++++++++--
 stdlib/REPL/test/replcompletions.jl | 29 ++++++++++++++++++-----------
 2 files changed, 31 insertions(+), 13 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 290a26ea4f6f3..cb9dc292d9664 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -329,8 +329,19 @@ function complete_path(path::AbstractString, pos::Int;
             for file in filesinpath
                 # In a perfect world, we would filter on whether the file is executable
                 # here, or even on whether the current user can execute the file in question.
-                if startswith(file, prefix) && isfile(joinpath(pathdir, file))
-                    push!(matches, file)
+                try
+                    if startswith(file, prefix) && isfile(joinpath(pathdir, file))
+                        push!(matches, file)
+                    end
+                catch e
+                    # `isfile()` can throw in rare cases such as when probing a
+                    # symlink that points to a file within a directory we do not
+                    # have read access to.
+                    if isa(e, Base.IOError)
+                        continue
+                    else
+                        rethrow()
+                    end
                 end
             end
         end
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 9f174f4be51ac..1560d322b375d 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -1119,17 +1119,21 @@ let s, c, r
     end
 
     # Tests detecting of files in the env path (in shell mode)
-    let path, file
-        path = tempdir()
-        unreadable = joinpath(tempdir(), "replcompletion-unreadable")
+    mktempdir() do path
+        unreadable = joinpath(path, "replcompletion-unreadable")
+        file = joinpath(path, "tmp-executable")
+        touch(file)
+        chmod(file, 0o755)
+        mkdir(unreadable)
+        hidden_file = joinpath(unreadable, "hidden")
+        touch(hidden_file)
 
-        try
-            file = joinpath(path, "tmp-executable")
-            touch(file)
-            chmod(file, 0o755)
-            mkdir(unreadable)
-            chmod(unreadable, 0o000)
+        # Create symlink to a file that is in an unreadable directory
+        chmod(hidden_file, 0o755)
+        chmod(unreadable, 0o000)
+        symlink(hidden_file, joinpath(path, "replcompletions-link"))
 
+        try
             # PATH can also contain folders which we aren't actually allowed to read.
             withenv("PATH" => string(path, ":", unreadable)) do
                 s = "tmp-execu"
@@ -1137,10 +1141,13 @@ let s, c, r
                 @test "tmp-executable" in c
                 @test r == 1:9
                 @test s[r] == "tmp-execu"
+
+                c,r = test_scomplete("replcompletions-link")
+                @test isempty(c)
             end
         finally
-            rm(file)
-            rm(unreadable)
+            # If we don't fix the permissions here, our cleanup fails.
+            chmod(unreadable, 0o700)
         end
     end
 

From f235291fb6f55915253ef0ed6b483f2bbf18361e Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 27 Oct 2023 16:57:43 -0400
Subject: [PATCH 0105/1315] REPL: Try to fix intermittent hang during
 precompile (#51891)

I was intermittently observing the REPL precompile process not
finishing. What I believe was happening is the following:

1. The last line of the precompile script is
`cd("complete_path\t\t$CTRL_C`
2. As soon as child julia sees the `CTRL_C`, the prompt is terminated,
and a new prompt is echod.
3. The parent julia tries to complete the line by sending `\n`, and
immediately returns, because the child has already written a new prompt.
4. The child reads the `\n` and enters raw mode (ignoring things like
^D).
5. The parent tries to write `^D` to complete the process, but because
the child is still processing the `\n`, this `^D` is ignored and the
process hangs.

Try to fix this by not writing the superfluous `\n` if the precompile
line ends in `^C`.
---
 stdlib/REPL/src/precompile.jl | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/stdlib/REPL/src/precompile.jl b/stdlib/REPL/src/precompile.jl
index 1b22eb77953a3..a1cd746fbeb88 100644
--- a/stdlib/REPL/src/precompile.jl
+++ b/stdlib/REPL/src/precompile.jl
@@ -40,7 +40,7 @@ foo(x) = 1
 @time @eval foo(1)
 ; pwd
 $CTRL_C
-$CTRL_R$CTRL_C
+$CTRL_R$CTRL_C#
 ? reinterpret
 using Ra\t$CTRL_C
 \\alpha\t$CTRL_C
@@ -93,6 +93,7 @@ generate_precompile_statements() = try
                 Sys.iswindows() && (sleep(0.1); yield(); yield()) # workaround hang - probably a libuv issue?
                 write(output_copy, l)
             end
+            write(debug_output, "\n#### EOF ####\n")
         catch ex
             if !(ex isa Base.IOError && ex.code == Base.UV_EIO)
                 rethrow() # ignore EIO on ptm after pts dies
@@ -117,7 +118,10 @@ generate_precompile_statements() = try
                 bytesavailable(output_copy) > 0 && readavailable(output_copy)
                 # push our input
                 write(debug_output, "\n#### inputting statement: ####\n$(repr(l))\n####\n")
-                write(ptm, l, "\n")
+                # If the line ends with a CTRL_C, don't write an extra newline, which would
+                # cause a second empty prompt. Our code below expects one new prompt per
+                # input line and can race out of sync with the unexpected second line.
+                endswith(l, CTRL_C) ? write(ptm, l) : write(ptm, l, "\n")
                 readuntil(output_copy, "\n")
                 # wait for the next prompt-like to appear
                 readuntil(output_copy, "\n")
@@ -131,6 +135,7 @@ generate_precompile_statements() = try
                     sleep(0.1)
                 end
             end
+            write(debug_output, "\n#### COMPLETED - Closing REPL ####\n")
             write(ptm, "$CTRL_D")
             wait(tee)
             success(p) || Base.pipeline_error(p)

From 93dbe3631999bc252cfc07f9c4d3b997f9168ce5 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 27 Oct 2023 16:58:28 -0400
Subject: [PATCH 0106/1315] Comment out DebugObjectManagerPlugin (#51859)

Prem said this might fix #51794.
---
 src/jitlayers.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 6c362fafcc756..ae385e17c4fb9 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1947,9 +1947,11 @@ void JuliaOJIT::enableJITDebuggingSupport()
     cantFail(JD.define(orc::absoluteSymbols(GDBFunctions)));
     if (TM->getTargetTriple().isOSBinFormatMachO())
         ObjectLayer.addPlugin(cantFail(orc::GDBJITDebugInfoRegistrationPlugin::Create(ES, JD, TM->getTargetTriple())));
+/*
     else if (TM->getTargetTriple().isOSBinFormatELF())
         //EPCDebugObjectRegistrar doesn't take a JITDylib, so we have to directly provide the call address
         ObjectLayer.addPlugin(std::make_unique<orc::DebugObjectManagerPlugin>(ES, std::make_unique<orc::EPCDebugObjectRegistrar>(ES, orc::ExecutorAddr::fromPtr(&llvm_orc_registerJITLoaderGDBWrapper))));
+*/
 }
 #else
 void JuliaOJIT::enableJITDebuggingSupport()

From f106bd9708fd61735f658e3e27ee1f227b829736 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Fri, 27 Oct 2023 21:00:53 -0300
Subject: [PATCH 0107/1315] Respect  JULIA_CPU_TARGET set in Make.inc when
 building pkgimgs (#51886)

Co-authored-by: Elliot Saba <staticfloat@gmail.com>
---
 pkgimage.mk | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pkgimage.mk b/pkgimage.mk
index 0b46531cfa137..58049e9a48f2b 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -29,6 +29,10 @@ all-debug:   $(addprefix cache-debug-, $(STDLIBS))
 
 define stdlib_builder
 ifneq ($(filter $(1),$(INDEPENDENT_STDLIBS)),)
+# Define target-specific export for `JULIA_CPU_TARGET`
+$$(BUILDDIR)/stdlib/$1.release.image: export JULIA_CPU_TARGET=$(JULIA_CPU_TARGET)
+$$(BUILDDIR)/stdlib/$1.debug.image: export JULIA_CPU_TARGET=$(JULIA_CPU_TARGET)
+
 $$(BUILDDIR)/stdlib/$1.release.image: $$($1_SRCS) $$(addsuffix .release.image,$$(addprefix $$(BUILDDIR)/stdlib/,$2)) $(build_private_libdir)/sys.$(SHLIB_EXT)
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --pkgimage=no -e 'Base.compilecache(Base.identify_package("$1"))')

From 0a0bd007ab1aa67c4614a67ee60d3d0d9bfffb62 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sat, 28 Oct 2023 09:13:06 +0800
Subject: [PATCH 0108/1315] Fix pointer calculation for `SubArray` with
 none-dense parent. (#51900)

And code clean for `first_index` and `compute_linindex`:
1. call `compute_linindex` directly in `first_index(::SlowSubArray)`.
(There's no need to calculate stride/offset.)
2. remove the uneeded `compute_linindex` dispatch
(`first(x::ScalarIndex) == x`)
---
 base/reshapedarray.jl |  7 +++++-
 base/subarray.jl      | 20 ++--------------
 test/abstractarray.jl | 56 +++++++++++++++++++++++++------------------
 test/subarray.jl      |  6 +++++
 4 files changed, 47 insertions(+), 42 deletions(-)

diff --git a/base/reshapedarray.jl b/base/reshapedarray.jl
index e8a832d119a26..344858e76764a 100644
--- a/base/reshapedarray.jl
+++ b/base/reshapedarray.jl
@@ -319,7 +319,12 @@ substrides(strds::NTuple{N,Int}, I::Tuple{ReshapedUnitRange, Vararg{Any}}) where
 function unsafe_convert(::Type{Ptr{S}}, V::SubArray{T,N,P,<:Tuple{Vararg{Union{RangeIndex,ReshapedUnitRange}}}}) where {S,T,N,P}
     parent = V.parent
     p = cconvert(Ptr{T}, parent) # XXX: this should occur in cconvert, the result is not GC-rooted
-    return Ptr{S}(unsafe_convert(Ptr{T}, p) + (first_index(V)-1)*sizeof(T))
+    Δmem = if _checkcontiguous(Bool, parent)
+        (first_index(V) - firstindex(parent)) * elsize(parent)
+    else
+        _memory_offset(parent, map(first, V.indices)...)
+    end
+    return Ptr{S}(unsafe_convert(Ptr{T}, p) + Δmem)
 end
 
 _checkcontiguous(::Type{Bool}, A::AbstractArray) = false
diff --git a/base/subarray.jl b/base/subarray.jl
index aa4d0c7c04645..61d59bddf547d 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -416,12 +416,8 @@ iscontiguous(A::SubArray) = iscontiguous(typeof(A))
 iscontiguous(::Type{<:SubArray}) = false
 iscontiguous(::Type{<:FastContiguousSubArray}) = true
 
-first_index(V::FastSubArray) = V.offset1 + V.stride1 # cached for fast linear SubArrays
-function first_index(V::SubArray)
-    P, I = parent(V), V.indices
-    s1 = compute_stride1(P, I)
-    s1 + compute_offset1(P, s1, I)
-end
+first_index(V::FastSubArray) = V.offset1 + V.stride1 * firstindex(V) # cached for fast linear SubArrays
+first_index(V::SubArray) = compute_linindex(parent(V), V.indices)
 
 # Computing the first index simply steps through the indices, accumulating the
 # sum of index each multiplied by the parent's stride.
@@ -447,11 +443,6 @@ function compute_linindex(parent, I::NTuple{N,Any}) where N
     IP = fill_to_length(axes(parent), OneTo(1), Val(N))
     compute_linindex(first(LinearIndices(parent)), 1, IP, I)
 end
-function compute_linindex(f, s, IP::Tuple, I::Tuple{ScalarIndex, Vararg{Any}})
-    @inline
-    Δi = I[1]-first(IP[1])
-    compute_linindex(f + Δi*s, s*length(IP[1]), tail(IP), tail(I))
-end
 function compute_linindex(f, s, IP::Tuple, I::Tuple{Any, Vararg{Any}})
     @inline
     Δi = first(I[1])-first(IP[1])
@@ -466,13 +457,6 @@ find_extended_inds(::ScalarIndex, I...) = (@inline; find_extended_inds(I...))
 find_extended_inds(i1, I...) = (@inline; (i1, find_extended_inds(I...)...))
 find_extended_inds() = ()
 
-# cconvert(::Type{<:Ptr}, V::SubArray{T,N,P,<:Tuple{Vararg{RangeIndex}}}) where {T,N,P} = V
-function unsafe_convert(::Type{Ptr{S}}, V::SubArray{T,N,P,<:Tuple{Vararg{RangeIndex}}}) where {S,T,N,P}
-    parent = V.parent
-    p = cconvert(Ptr{T}, parent) # XXX: this should occur in cconvert, the result is not GC-rooted
-    return Ptr{S}(unsafe_convert(Ptr{T}, p) + _memory_offset(parent, map(first, V.indices)...))
-end
-
 pointer(V::FastSubArray, i::Int) = pointer(V.parent, V.offset1 + V.stride1*i)
 pointer(V::FastContiguousSubArray, i::Int) = pointer(V.parent, V.offset1 + i)
 
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index d93c20f34209e..9167cfd954d5f 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1759,47 +1759,50 @@ module IRUtils
     include("compiler/irutils.jl")
 end
 
-@testset "strides for ReshapedArray" begin
-    function check_strides(A::AbstractArray)
-        # Make sure stride(A, i) is equivalent with strides(A)[i] (if 1 <= i <= ndims(A))
-        dims = ntuple(identity, ndims(A))
-        map(i -> stride(A, i), dims) == @inferred(strides(A)) || return false
-        # Test strides via value check.
-        for i in eachindex(IndexLinear(), A)
-            A[i] === Base.unsafe_load(pointer(A, i)) || return false
-        end
-        return true
+function check_pointer_strides(A::AbstractArray)
+    # Make sure stride(A, i) is equivalent with strides(A)[i] (if 1 <= i <= ndims(A))
+    dims = ntuple(identity, ndims(A))
+    map(i -> stride(A, i), dims) == @inferred(strides(A)) || return false
+    # Test pointer via value check.
+    first(A) === Base.unsafe_load(pointer(A)) || return false
+    # Test strides via value check.
+    for i in eachindex(IndexLinear(), A)
+        A[i] === Base.unsafe_load(pointer(A, i)) || return false
     end
+    return true
+end
+
+@testset "strides for ReshapedArray" begin
     # Type-based contiguous Check
     a = vec(reinterpret(reshape, Int16, reshape(view(reinterpret(Int32, randn(10)), 2:11), 5, :)))
     f(a) = only(strides(a));
     @test IRUtils.fully_eliminated(f, Base.typesof(a)) && f(a) == 1
     # General contiguous check
     a = view(rand(10,10), 1:10, 1:10)
-    @test check_strides(vec(a))
+    @test check_pointer_strides(vec(a))
     b = view(parent(a), 1:9, 1:10)
     @test_throws "Input is not strided." strides(vec(b))
     # StridedVector parent
     for n in 1:3
         a = view(collect(1:60n), 1:n:60n)
-        @test check_strides(reshape(a, 3, 4, 5))
-        @test check_strides(reshape(a, 5, 6, 2))
+        @test check_pointer_strides(reshape(a, 3, 4, 5))
+        @test check_pointer_strides(reshape(a, 5, 6, 2))
         b = view(parent(a), 60n:-n:1)
-        @test check_strides(reshape(b, 3, 4, 5))
-        @test check_strides(reshape(b, 5, 6, 2))
+        @test check_pointer_strides(reshape(b, 3, 4, 5))
+        @test check_pointer_strides(reshape(b, 5, 6, 2))
     end
     # StridedVector like parent
     a = randn(10, 10, 10)
     b = view(a, 1:10, 1:1, 5:5)
-    @test check_strides(reshape(b, 2, 5))
+    @test check_pointer_strides(reshape(b, 2, 5))
     # Other StridedArray parent
     a = view(randn(10,10), 1:9, 1:10)
-    @test check_strides(reshape(a,3,3,2,5))
-    @test check_strides(reshape(a,3,3,5,2))
-    @test check_strides(reshape(a,9,5,2))
-    @test check_strides(reshape(a,3,3,10))
-    @test check_strides(reshape(a,1,3,1,3,1,5,1,2))
-    @test check_strides(reshape(a,3,3,5,1,1,2,1,1))
+    @test check_pointer_strides(reshape(a,3,3,2,5))
+    @test check_pointer_strides(reshape(a,3,3,5,2))
+    @test check_pointer_strides(reshape(a,9,5,2))
+    @test check_pointer_strides(reshape(a,3,3,10))
+    @test check_pointer_strides(reshape(a,1,3,1,3,1,5,1,2))
+    @test check_pointer_strides(reshape(a,3,3,5,1,1,2,1,1))
     @test_throws "Input is not strided." strides(reshape(a,3,6,5))
     @test_throws "Input is not strided." strides(reshape(a,3,2,3,5))
     @test_throws "Input is not strided." strides(reshape(a,3,5,3,2))
@@ -1812,7 +1815,14 @@ end
     @test @inferred(strides(a)) == (1, 1, 1)
     # Dense parent (but not StridedArray)
     A = reinterpret(Int8, reinterpret(reshape, Int16, rand(Int8, 2, 3, 3)))
-    @test check_strides(reshape(A, 3, 2, 3))
+    @test check_pointer_strides(reshape(A, 3, 2, 3))
+end
+
+@testset "pointer for SubArray with none-dense parent." begin
+    a = view(Matrix(reshape(0x01:0xc8, 20, :)), 1:2:20, :)
+    b = reshape(a, 20, :)
+    @test check_pointer_strides(view(b, 2:11, 1:5))
+    @test check_pointer_strides(view(b, reshape(2:11, 2, :), 1:5))
 end
 
 @testset "stride for 0 dims array #44087" begin
diff --git a/test/subarray.jl b/test/subarray.jl
index 442e6f485f5b1..f7350d50f793d 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -800,3 +800,9 @@ end
     V = view(OneElVec(6, 2), 1:5)
     @test sprint(show, "text/plain", V) == "$(summary(V)):\n ⋅\n 1\n ⋅\n ⋅\n ⋅"
 end
+
+@testset "Base.first_index for offset indices" begin
+    a = Vector(1:10)
+    b = view(a, Base.IdentityUnitRange(4:7))
+    @test first(b) == a[Base.first_index(b)]
+end

From 9c581cd719fbef73f2e805ce3f746697fbf001f4 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sat, 28 Oct 2023 07:49:59 -0400
Subject: [PATCH 0109/1315] mkpidlock: close update loop in error path (#51902)

---
 stdlib/FileWatching/src/pidfile.jl | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/stdlib/FileWatching/src/pidfile.jl b/stdlib/FileWatching/src/pidfile.jl
index ada725e63094b..71b596ba35f12 100644
--- a/stdlib/FileWatching/src/pidfile.jl
+++ b/stdlib/FileWatching/src/pidfile.jl
@@ -77,6 +77,7 @@ mutable struct LockMonitor
             lock = new(at, fd, update)
             finalizer(close, lock)
         catch ex
+            update === nothing || close(update)
             tryrmopenfile(at)
             close(fd)
             rethrow(ex)
@@ -100,10 +101,13 @@ end
 function mkpidlock(at::String, proc::Process; kwopts...)
     lock = mkpidlock(at, getpid(proc); kwopts...)
     closer = @async begin
-        wait(proc)
-        close(lock)
+        try
+            wait(proc)
+        finally
+            close(lock)
+        end
     end
-    isdefined(Base, :errormonitor) && Base.errormonitor(closer)
+    Base.errormonitor(closer)
     return lock
 end
 

From f573c4aad0b326450dce1936fceff0c256dccc08 Mon Sep 17 00:00:00 2001
From: KronosTheLate <61620837+KronosTheLate@users.noreply.github.com>
Date: Sat, 28 Oct 2023 13:53:19 +0200
Subject: [PATCH 0110/1315] More detail on locks (#51844)

---
 doc/src/manual/multi-threading.md | 134 ++++++++++++++++--------------
 1 file changed, 72 insertions(+), 62 deletions(-)

diff --git a/doc/src/manual/multi-threading.md b/doc/src/manual/multi-threading.md
index b1495192e752c..71e49e65b19a8 100644
--- a/doc/src/manual/multi-threading.md
+++ b/doc/src/manual/multi-threading.md
@@ -136,60 +136,6 @@ julia> nthreads()
 Either or both numbers can be replaced with the word `auto`, which causes
 Julia to choose a reasonable default.
 
-## Communication and synchronization
-
-Although Julia's threads can communicate through shared memory, it is notoriously
-difficult to write correct and data-race free multi-threaded code. Julia's
-[`Channel`](@ref)s are thread-safe and may be used to communicate safely.
-
-### Data-race freedom
-
-You are entirely responsible for ensuring that your program is data-race free,
-and nothing promised here can be assumed if you do not observe that
-requirement. The observed results may be highly unintuitive.
-
-The best way to ensure this is to acquire a lock around any access to data that
-can be observed from multiple threads. For example, in most cases you should
-use the following code pattern:
-
-```julia-repl
-julia> lock(lk) do
-           use(a)
-       end
-
-julia> begin
-           lock(lk)
-           try
-               use(a)
-           finally
-               unlock(lk)
-           end
-       end
-
-julia> @lock lk use(a)
-```
-where `lk` is a lock (e.g. `ReentrantLock()`) and `a` data.
-
-Additionally, Julia is not memory safe in the presence of a data race. Be very
-careful about reading _any_ data if another thread might write to it!
-Instead, always use the lock pattern above when changing data (such as assigning
-to a global or closure variable) accessed by other threads.
-
-```julia
-Thread 1:
-global b = false
-global a = rand()
-global b = true
-
-Thread 2:
-while !b; end
-bad_read1(a) # it is NOT safe to access `a` here!
-
-Thread 3:
-while !@isdefined(a); end
-bad_read2(a) # it is NOT safe to access `a` here
-```
-
 ## The `@threads` Macro
 
 Let's work a simple example using our native threads. Let us create an array of zeros:
@@ -241,10 +187,10 @@ julia> a
 
 Note that [`Threads.@threads`](@ref) does not have an optional reduction parameter like [`@distributed`](@ref).
 
-### Using `@threads` without data races
-
-Taking the example of a naive sum
+### Using `@threads` without data-races
+The concept of a data-race is elaborated on in ["Communication and data races between threads"](@ref man-communication-and-data-races). For now, just known that a data race can result in incorrect results and dangerous errors.
 
+Lets say we want to make the function `sum_single` below multithreaded.
 ```julia-repl
 julia> function sum_single(a)
            s = 0
@@ -277,9 +223,8 @@ julia> sum_multi_bad(1:1_000_000)
 Note that the result is not `500000500000` as it should be, and will most likely change each evaluation.
 
 To fix this, buffers that are specific to the task may be used to segment the sum into chunks that are race-free.
-Here `sum_single` is reused, with its own internal buffer `s`, and vector `a` is split into `nthreads()`
-chunks for parallel work via `nthreads()` `@spawn`-ed tasks.
-
+Here `sum_single` is reused, with its own internal buffer `s`. The input vector `a` is split into `nthreads()`
+chunks for parallel work. We then use `Threads.@spawn` to create tasks that individually sum each chunk. Finally, we sum the results from each task using `sum_single` again:
 ```julia-repl
 julia> function sum_multi_good(a)
            chunks = Iterators.partition(a, length(a) ÷ Threads.nthreads())
@@ -303,7 +248,72 @@ julia> sum_multi_good(1:1_000_000)
 Another option is the use of atomic operations on variables shared across tasks/threads, which may be more performant
 depending on the characteristics of the operations.
 
-## Atomic Operations
+## [Communication and data-races between threads](@id man-communication-and-data-races)
+
+Although Julia's threads can communicate through shared memory, it is notoriously difficult to write correct and data-race free multi-threaded code. Julia's
+[`Channel`](@ref)s are thread-safe and may be used to communicate safely. There are also sections below that explain how to use [locks](@ref man-using-locks) and [atomics](@ref man-atomic-operations) to avoid data-races.
+
+### Data-race freedom
+
+You are entirely responsible for ensuring that your program is data-race free,
+and nothing promised here can be assumed if you do not observe that
+requirement. The observed results may be highly unintuitive.
+
+If data-races are introduced, Julia is not memory safe. **Be very
+careful about reading _any_ data if another thread might write to it, as it could result in segmentation faults or worse**. Below are a couple of unsafe ways to access global variables from different threads:
+```julia
+Thread 1:
+global b = false
+global a = rand()
+global b = true
+
+Thread 2:
+while !b; end
+bad_read1(a) # it is NOT safe to access `a` here!
+
+Thread 3:
+while !@isdefined(a); end
+bad_read2(a) # it is NOT safe to access `a` here
+```
+
+### [Using locks to avoid data-races](@id man-using-locks)
+An important tool to avoid data-races, and thereby write thread-safe code, is the concept of a "lock". A lock can be locked and unlocked. If a thread has locked a lock, and not unlocked it, it is said to "hold" the lock. If there is only one lock, and we write code the requires holding the lock to access some data, we can ensure that multiple threads will never access the same data simultaneously. Note that the link between a lock and a variable is made by the programmer, and not the program.
+
+For example, we can create a lock `my_lock`, and lock it while we mutate a variable `my_variable`. This is done most simply with the `@lock` macro:
+
+```julia-repl
+julia> my_lock = ReentrantLock();
+
+julia> my_variable = [1, 2, 3];
+
+julia> @lock my_lock my_variable[1] = 100
+100
+```
+
+By using a similar pattern with the same lock and variable, but on another thread, the operations are free from data-races.
+
+We could have performed the operation above with the functional version of `lock`, in the following two ways:
+```julia-repl
+julia> lock(my_lock) do
+           my_variable[1] = 100
+       end
+100
+
+julia> begin
+           lock(my_lock)
+           try
+               my_variable[1] = 100
+           finally
+               unlock(my_lock)
+           end
+       end
+100
+```
+
+All three options are equivalent. Note how the final version requires an explicit `try`-block to ensure that the lock is always unlocked, whereas the first two version do this internally. One should always use the lock pattern above when changing data (such as assigning
+to a global or closure variable) accessed by other threads. Failing to do this could have unforeseen and serious consequences.
+
+### [Atomic Operations](@id man-atomic-operations)
 
 Julia supports accessing and modifying values *atomically*, that is, in a thread-safe way to avoid
 [race conditions](https://en.wikipedia.org/wiki/Race_condition). A value (which must be of a primitive
@@ -372,7 +382,7 @@ julia> acc[]
 ```
 
 
-## [Per-field atomics](@id man-atomics)
+#### [Per-field atomics](@id man-atomics)
 
 We can also use atomics on a more granular level using the [`@atomic`](@ref
 Base.@atomic), [`@atomicswap`](@ref Base.@atomicswap), and

From 4975c02bdce654c18c6fda3898049d0c1a5f3d44 Mon Sep 17 00:00:00 2001
From: Ian Atol <ian.r.atol@gmail.com>
Date: Sat, 28 Oct 2023 04:54:39 -0700
Subject: [PATCH 0111/1315] Improve codegen, accuracy of inlining cost for
 unknown intrinsics (#44349)

---
 base/compiler/optimize.jl          | 11 ++---
 base/compiler/tfuncs.jl            | 12 ++++-
 src/builtins.c                     |  8 ++--
 src/codegen.cpp                    | 72 +++++++++++++++++++++++-------
 src/julia_internal.h               |  2 +-
 src/llvm-codegen-shared.h          | 16 +++++--
 src/llvm-gc-invariant-verifier.cpp | 12 +++--
 src/llvm-late-gc-lowering.cpp      | 13 +++---
 src/llvm-pass-helpers.cpp          |  3 +-
 src/llvm-pass-helpers.h            |  1 +
 10 files changed, 111 insertions(+), 39 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index de05e837a419e..a4897865b52e3 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -1022,6 +1022,7 @@ isknowntype(@nospecialize T) = (T === Union{}) || isa(T, Const) || isconcretetyp
 
 function statement_cost(ex::Expr, line::Int, src::Union{CodeInfo, IRCode}, sptypes::Vector{VarState},
                         params::OptimizationParams, error_path::Bool = false)
+    #=const=# UNKNOWN_CALL_COST = 20
     head = ex.head
     if is_meta_expr_head(head)
         return 0
@@ -1067,8 +1068,8 @@ function statement_cost(ex::Expr, line::Int, src::Union{CodeInfo, IRCode}, sptyp
                     return cost
                 end
             end
-            # unknown/unhandled intrinsic
-            return params.inline_nonleaf_penalty
+            # unknown/unhandled intrinsic: hopefully the caller gets a slightly better answer after the inlining
+            return UNKNOWN_CALL_COST
         end
         if isa(f, Builtin) && f !== invoke
             # The efficiency of operations like a[i] and s.b
@@ -1092,7 +1093,7 @@ function statement_cost(ex::Expr, line::Int, src::Union{CodeInfo, IRCode}, sptyp
             if fidx === nothing
                 # unknown/unhandled builtin
                 # Use the generic cost of a direct function call
-                return 20
+                return UNKNOWN_CALL_COST
             end
             return T_FFUNC_COST[fidx]
         end
@@ -1114,10 +1115,10 @@ function statement_cost(ex::Expr, line::Int, src::Union{CodeInfo, IRCode}, sptyp
         # consideration. This way, non-inlined error branches do not
         # prevent inlining.
         extyp = line == -1 ? Any : argextype(SSAValue(line), src, sptypes)
-        return extyp === Union{} ? 0 : 20
+        return extyp === Union{} ? 0 : UNKNOWN_CALL_COST
     elseif head === :(=)
         if ex.args[1] isa GlobalRef
-            cost = 20
+            cost = UNKNOWN_CALL_COST
         else
             cost = 0
         end
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index cf6af02ba020a..cc555e5bde5b6 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -1862,6 +1862,7 @@ const _tvarnames = Symbol[:_A, :_B, :_C, :_D, :_E, :_F, :_G, :_H, :_I, :_J, :_K,
     try
         appl = apply_type(headtype, tparams...)
     catch ex
+        ex isa InterruptException && rethrow()
         # type instantiation might fail if one of the type parameters doesn't
         # match, which could happen only if a type estimate is too coarse
         # and might guess a concrete value while the actual type for it is Bottom
@@ -2528,8 +2529,17 @@ function builtin_tfunction(interp::AbstractInterpreter, @nospecialize(f), argtyp
         if is_pure_intrinsic_infer(f) && all(@nospecialize(a) -> isa(a, Const), argtypes)
             argvals = anymap(@nospecialize(a) -> (a::Const).val, argtypes)
             try
+                # unroll a few cases which have specialized codegen
+                if length(argvals) == 1
+                    return Const(f(argvals[1]))
+                elseif length(argvals) == 2
+                    return Const(f(argvals[1], argvals[2]))
+                elseif length(argvals) == 3
+                    return Const(f(argvals[1], argvals[2], argvals[3]))
+                end
                 return Const(f(argvals...))
-            catch
+            catch ex # expected ErrorException, TypeError, ConcurrencyViolationError, DivideError etc.
+                ex isa InterruptException && rethrow()
                 return Bottom
             end
         end
diff --git a/src/builtins.c b/src/builtins.c
index 70899e4d4853a..bed8bbc2b0216 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1963,7 +1963,6 @@ static unsigned intrinsic_nargs[num_intrinsics];
 
 JL_CALLABLE(jl_f_intrinsic_call)
 {
-    JL_TYPECHK(intrinsic_call, intrinsic, F);
     enum intrinsic f = (enum intrinsic)*(uint32_t*)jl_data_ptr(F);
     if (f == cglobal && nargs == 1)
         f = cglobal_auto;
@@ -2022,6 +2021,7 @@ unsigned jl_intrinsic_nargs(int f)
 
 static void add_intrinsic_properties(enum intrinsic f, unsigned nargs, void (*pfunc)(void))
 {
+    assert(nargs <= 5 && "jl_f_intrinsic_call only implements up to 5 args");
     intrinsic_nargs[f] = nargs;
     runtime_fp[f] = pfunc;
 }
@@ -2074,10 +2074,10 @@ static void add_builtin(const char *name, jl_value_t *v)
     jl_set_const(jl_core_module, jl_symbol(name), v);
 }
 
-jl_fptr_args_t jl_get_builtin_fptr(jl_value_t *b)
+jl_fptr_args_t jl_get_builtin_fptr(jl_datatype_t *dt)
 {
-    assert(jl_isa(b, (jl_value_t*)jl_builtin_type));
-    jl_typemap_entry_t *entry = (jl_typemap_entry_t*)jl_atomic_load_relaxed(&jl_gf_mtable(b)->defs);
+    assert(jl_subtype((jl_value_t*)dt, (jl_value_t*)jl_builtin_type));
+    jl_typemap_entry_t *entry = (jl_typemap_entry_t*)jl_atomic_load_relaxed(&dt->name->mt->defs);
     jl_method_instance_t *mi = jl_atomic_load_relaxed(&entry->func.method->unspecialized);
     jl_code_instance_t *ci = jl_atomic_load_relaxed(&mi->cache);
     return jl_atomic_load_relaxed(&ci->specptr.fptr1);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 4b5197e81365d..50ebb4aa540d8 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -619,6 +619,7 @@ static Type *get_pjlvalue(LLVMContext &C) { return JuliaType::get_pjlvalue_ty(C)
 
 static FunctionType *get_func_sig(LLVMContext &C) { return JuliaType::get_jlfunc_ty(C); }
 static FunctionType *get_func2_sig(LLVMContext &C) { return JuliaType::get_jlfunc2_ty(C); }
+static FunctionType *get_func3_sig(LLVMContext &C) { return JuliaType::get_jlfunc3_ty(C); }
 
 static FunctionType *get_donotdelete_sig(LLVMContext &C) {
     return FunctionType::get(getVoidTy(C), true);
@@ -1225,6 +1226,12 @@ static const auto box_ssavalue_func = new JuliaFunction<TypeFnContextAndSizeT>{
     },
     get_attrs_basic,
 };
+static const auto jlgetbuiltinfptr_func = new JuliaFunction<>{
+    XSTR(jl_get_builtin_fptr),
+    [](LLVMContext &C) { return FunctionType::get(get_func_sig(C)->getPointerTo(),
+            {JuliaType::get_prjlvalue_ty(C)}, false); },
+    nullptr,
+};
 
 
 // placeholder functions
@@ -1277,7 +1284,6 @@ static const auto gc_loaded_func = new JuliaFunction<>{
                   Attributes(C, {Attribute::NonNull, Attribute::NoUndef, Attribute::ReadNone}) }); },
 };
 
-
 // julia.call represents a call with julia calling convention, it is used as
 //
 //   ptr julia.call(ptr %fptr, ptr %f, ptr %arg1, ptr %arg2, ...)
@@ -1314,7 +1320,23 @@ static const auto julia_call2 = new JuliaFunction<>{
     get_attrs_basic,
 };
 
+// julia.call3 is like julia.call, except that %fptr is derived rather than tracked
+static const auto julia_call3 = new JuliaFunction<>{
+    "julia.call3",
+    [](LLVMContext &C) {
+        auto T_prjlvalue = JuliaType::get_prjlvalue_ty(C);
+        Type *T = PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::Derived);
+        return FunctionType::get(T_prjlvalue,
+            {get_func3_sig(C)->getPointerTo(),
+             T}, // %f
+            true); }, // %args
+    get_attrs_basic,
+};
+
+
 static const auto jltuple_func = new JuliaFunction<>{XSTR(jl_f_tuple), get_func_sig, get_func_attrs};
+static const auto jlintrinsic_func = new JuliaFunction<>{XSTR(jl_f_intrinsic_call), get_func3_sig, get_func_attrs};
+
 static const auto &builtin_func_map() {
     static std::map<jl_fptr_args_t, JuliaFunction<>*> builtins = {
           { jl_f_is_addr,                 new JuliaFunction<>{XSTR(jl_f_is), get_func_sig, get_func_attrs} },
@@ -4659,22 +4681,40 @@ static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt, bo
             return jl_cgval_t(); // anything past here is unreachable
     }
 
-    if (f.constant && jl_isa(f.constant, (jl_value_t*)jl_builtin_type)) {
-        if (f.constant == jl_builtin_ifelse && nargs == 4)
-            return emit_ifelse(ctx, argv[1], argv[2], argv[3], rt);
-        jl_cgval_t result;
-        bool handled = emit_builtin_call(ctx, &result, f.constant, argv, nargs - 1, rt, ex, is_promotable);
-        if (handled) {
-            return result;
+    if (jl_subtype(f.typ, (jl_value_t*)jl_builtin_type)) {
+        if (f.constant) {
+            if (f.constant == jl_builtin_ifelse && nargs == 4)
+                return emit_ifelse(ctx, argv[1], argv[2], argv[3], rt);
+            jl_cgval_t result;
+            bool handled = emit_builtin_call(ctx, &result, f.constant, argv, nargs - 1, rt, ex, is_promotable);
+            if (handled)
+                return result;
+
+            // special case for some known builtin not handled by emit_builtin_call
+            auto it = builtin_func_map().find(jl_get_builtin_fptr((jl_datatype_t*)jl_typeof(f.constant)));
+            if (it != builtin_func_map().end()) {
+                Value *ret = emit_jlcall(ctx, it->second, Constant::getNullValue(ctx.types().T_prjlvalue), &argv[1], nargs - 1, julia_call);
+                setName(ctx.emission_context, ret, it->second->name + "_ret");
+                return mark_julia_type(ctx, ret, true, rt);
+            }
+        }
+        FunctionCallee fptr;
+        Value *F;
+        JuliaFunction<> *cc;
+        if (f.typ == (jl_value_t*)jl_intrinsic_type) {
+            fptr = prepare_call(jlintrinsic_func);
+            F = f.ispointer() ? data_pointer(ctx, f) : value_to_pointer(ctx, f).V;
+            F = decay_derived(ctx, maybe_bitcast(ctx, F, ctx.types().T_pjlvalue));
+            cc = julia_call3;
         }
-
-        // special case for known builtin not handled by emit_builtin_call
-        auto it = builtin_func_map().find(jl_get_builtin_fptr(f.constant));
-        if (it != builtin_func_map().end()) {
-            Value *ret = emit_jlcall(ctx, it->second, Constant::getNullValue(ctx.types().T_prjlvalue), &argv[1], nargs - 1, julia_call);
-            setName(ctx.emission_context, ret, it->second->name + "_ret");
-            return mark_julia_type(ctx, ret, true, rt);
+        else {
+            fptr = FunctionCallee(get_func_sig(ctx.builder.getContext()), ctx.builder.CreateCall(prepare_call(jlgetbuiltinfptr_func), {emit_typeof(ctx, f)}));
+            F = boxed(ctx, f);
+            cc = julia_call;
         }
+        Value *ret = emit_jlcall(ctx, fptr, F, &argv[1], nargs - 1, cc);
+        setName(ctx.emission_context, ret, "Builtin_ret");
+        return mark_julia_type(ctx, ret, true, rt);
     }
 
     // handle calling an OpaqueClosure
@@ -9195,6 +9235,8 @@ static void init_jit_functions(void)
     add_named_global(jlboundp_func, &jl_boundp);
     for (auto it : builtin_func_map())
         add_named_global(it.second, it.first);
+    add_named_global(jlintrinsic_func, &jl_f_intrinsic_call);
+    add_named_global(jlgetbuiltinfptr_func, &jl_get_builtin_fptr);
     add_named_global(jlapplygeneric_func, &jl_apply_generic);
     add_named_global(jlinvoke_func, &jl_invoke);
     add_named_global(jltopeval_func, &jl_toplevel_eval);
diff --git a/src/julia_internal.h b/src/julia_internal.h
index a162effdec173..d63df80cafede 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -672,7 +672,7 @@ void jl_install_default_signal_handlers(void);
 void restore_signals(void);
 void jl_install_thread_signal_handler(jl_ptls_t ptls);
 
-JL_DLLEXPORT jl_fptr_args_t jl_get_builtin_fptr(jl_value_t *b);
+JL_DLLEXPORT jl_fptr_args_t jl_get_builtin_fptr(jl_datatype_t *dt);
 
 extern uv_loop_t *jl_io_loop;
 JL_DLLEXPORT void jl_uv_flush(uv_stream_t *stream);
diff --git a/src/llvm-codegen-shared.h b/src/llvm-codegen-shared.h
index 11c34af120f3f..abe4b12cc6d5c 100644
--- a/src/llvm-codegen-shared.h
+++ b/src/llvm-codegen-shared.h
@@ -60,9 +60,19 @@ namespace JuliaType {
         return llvm::FunctionType::get(T_prjlvalue, {
                 T_prjlvalue,  // function
                 T_pprjlvalue, // args[]
-                llvm::Type::getInt32Ty(C),
-                T_prjlvalue,  // linfo
-                }, // nargs
+                llvm::Type::getInt32Ty(C), // nargs
+                T_prjlvalue},  // linfo
+            false);
+    }
+
+    static inline auto get_jlfunc3_ty(llvm::LLVMContext &C) {
+        auto T_prjlvalue = get_prjlvalue_ty(C);
+        auto T_pprjlvalue = llvm::PointerType::get(T_prjlvalue, 0);
+        auto T = get_pjlvalue_ty(C, Derived);
+        return llvm::FunctionType::get(T_prjlvalue, {
+                T,  // function
+                T_pprjlvalue, // args[]
+                llvm::Type::getInt32Ty(C)}, // nargs
             false);
     }
 
diff --git a/src/llvm-gc-invariant-verifier.cpp b/src/llvm-gc-invariant-verifier.cpp
index f1d9df0997e39..8c8e2e4546d04 100644
--- a/src/llvm-gc-invariant-verifier.cpp
+++ b/src/llvm-gc-invariant-verifier.cpp
@@ -161,13 +161,17 @@ void GCInvariantVerifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
 void GCInvariantVerifier::visitCallInst(CallInst &CI) {
     Function *Callee = CI.getCalledFunction();
     if (Callee && (Callee->getName() == "julia.call" ||
-                   Callee->getName() == "julia.call2")) {
-        bool First = true;
+                   Callee->getName() == "julia.call2" ||
+                   Callee->getName() == "julia.call3")) {
+        unsigned Fixed = CI.getFunctionType()->getNumParams();
         for (Value *Arg : CI.args()) {
+            if (Fixed) {
+                Fixed--;
+                continue;
+            }
             Type *Ty = Arg->getType();
-            Check(Ty->isPointerTy() && cast<PointerType>(Ty)->getAddressSpace() == (First ? 0 : AddressSpace::Tracked),
+            Check(Ty->isPointerTy() && cast<PointerType>(Ty)->getAddressSpace() == AddressSpace::Tracked,
                 "Invalid derived pointer in jlcall", &CI);
-            First = false;
         }
     }
 }
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index 96a3e5a8f4b9e..fcca6841989ec 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -2459,14 +2459,15 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S, bool *CFGModified) {
                 ++it;
                 continue;
             } else if ((call_func && callee == call_func) ||
-                       (call2_func && callee == call2_func)) {
+                       (call2_func && callee == call2_func) ||
+                       (call3_func && callee == call3_func)) {
                 assert(T_prjlvalue);
                 size_t nargs = CI->arg_size();
                 size_t nframeargs = nargs-1;
-                if (callee == call_func)
-                    nframeargs -= 1;
-                else if (callee == call2_func)
+                if (callee == call2_func)
                     nframeargs -= 2;
+                else
+                    nframeargs -= 1;
                 SmallVector<Value*, 4> ReplacementArgs;
                 auto arg_it = CI->arg_begin();
                 assert(arg_it != CI->arg_end());
@@ -2499,7 +2500,9 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S, bool *CFGModified) {
                     ReplacementArgs.erase(ReplacementArgs.begin());
                     ReplacementArgs.push_back(front);
                 }
-                FunctionType *FTy = callee == call2_func ? JuliaType::get_jlfunc2_ty(CI->getContext()) : JuliaType::get_jlfunc_ty(CI->getContext());
+                FunctionType *FTy = callee == call3_func ? JuliaType::get_jlfunc3_ty(CI->getContext()) :
+                                    callee == call2_func ? JuliaType::get_jlfunc2_ty(CI->getContext()) :
+                                                           JuliaType::get_jlfunc_ty(CI->getContext());
                 CallInst *NewCall = CallInst::Create(FTy, new_callee, ReplacementArgs, "", CI);
                 NewCall->setTailCallKind(CI->getTailCallKind());
                 auto callattrs = CI->getAttributes();
diff --git a/src/llvm-pass-helpers.cpp b/src/llvm-pass-helpers.cpp
index 63eeb96f0a03e..59bfae3f38b8e 100644
--- a/src/llvm-pass-helpers.cpp
+++ b/src/llvm-pass-helpers.cpp
@@ -27,7 +27,7 @@ JuliaPassContext::JuliaPassContext()
         gc_preserve_begin_func(nullptr), gc_preserve_end_func(nullptr),
         pointer_from_objref_func(nullptr), gc_loaded_func(nullptr), alloc_obj_func(nullptr),
         typeof_func(nullptr), write_barrier_func(nullptr),
-        call_func(nullptr), call2_func(nullptr), module(nullptr)
+        call_func(nullptr), call2_func(nullptr), call3_func(nullptr), module(nullptr)
 {
 }
 
@@ -54,6 +54,7 @@ void JuliaPassContext::initFunctions(Module &M)
     alloc_obj_func = M.getFunction("julia.gc_alloc_obj");
     call_func = M.getFunction("julia.call");
     call2_func = M.getFunction("julia.call2");
+    call3_func = M.getFunction("julia.call3");
 }
 
 void JuliaPassContext::initAll(Module &M)
diff --git a/src/llvm-pass-helpers.h b/src/llvm-pass-helpers.h
index 3478f1ece0b5e..346500df51ca1 100644
--- a/src/llvm-pass-helpers.h
+++ b/src/llvm-pass-helpers.h
@@ -62,6 +62,7 @@ struct JuliaPassContext {
     llvm::Function *write_barrier_func;
     llvm::Function *call_func;
     llvm::Function *call2_func;
+    llvm::Function *call3_func;
 
     // Creates a pass context. Type and function pointers
     // are set to `nullptr`. Metadata nodes are initialized.

From 98542d748540e2390d6222282749c7dd534544da Mon Sep 17 00:00:00 2001
From: matthias314 <56549971+matthias314@users.noreply.github.com>
Date: Sat, 28 Oct 2023 07:55:51 -0400
Subject: [PATCH 0112/1315] Base.Cartesian: add `@ncallkw` and allow `else`
 branch inside `if` (#51501)

---
 NEWS.md                      |  2 ++
 base/cartesian.jl            | 44 ++++++++++++++++++++++++++++++++----
 doc/src/devdocs/cartesian.md |  1 +
 test/cartesian.jl            | 32 ++++++++++++++++++++++++++
 4 files changed, 75 insertions(+), 4 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 69769c8b3fc9d..75a8ac9ab71f8 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -8,6 +8,8 @@ New language features
   difference between `public` and `export` is that `public` names do not become
   available when `using` a package/module. ([#50105])
 * `ScopedValue` implement dynamic scope with inheritance across tasks ([#50958]).
+* The new macro `Base.Cartesian.@ncallkw` is analogous to `Base.Cartesian.@ncall`,
+  but allows to add keyword arguments to the function call ([#51501]).
 * Support for Unicode 15.1 ([#51799]).
 * A new `AbstractString` type, `AnnotatedString`, is introduced that allows for
   regional annotations to be attached to an underlying string. This type is
diff --git a/base/cartesian.jl b/base/cartesian.jl
index 5f96a2061880f..decc01cbc3e5f 100644
--- a/base/cartesian.jl
+++ b/base/cartesian.jl
@@ -2,7 +2,7 @@
 
 module Cartesian
 
-export @nloops, @nref, @ncall, @nexprs, @nextract, @nall, @nany, @ntuple, @nif
+export @nloops, @nref, @ncall, @ncallkw, @nexprs, @nextract, @nall, @nany, @ntuple, @nif
 
 ### Cartesian-specific macros
 
@@ -104,10 +104,38 @@ while `@ncall 2 func a b i->c[i]` yields
 macro ncall(N::Int, f, args...)
     pre = args[1:end-1]
     ex = args[end]
-    vars = Any[ inlineanonymous(ex,i) for i = 1:N ]
+    vars = (inlineanonymous(ex, i) for i = 1:N)
     Expr(:escape, Expr(:call, f, pre..., vars...))
 end
 
+"""
+    @ncallkw N f kw sym...
+
+Generate a function call expression with keyword arguments `kw...`. As
+in the case of [`@ncall`](@ref), `sym` represents any number of function arguments, the
+last of which may be an anonymous-function expression and is expanded into `N` arguments.
+
+# Example
+```jldoctest
+julia> using Base.Cartesian
+
+julia> f(x...; a, b = 1, c = 2, d = 3) = +(x..., a, b, c, d);
+
+julia> x_1, x_2 = (-1, -2); b = 0; kw = (c = 0, d = 0);
+
+julia> @ncallkw 2 f (; a = 0, b, kw...) x
+-3
+
+```
+"""
+macro ncallkw(N::Int, f, kw, args...)
+    pre = args[1:end-1]
+    ex = args[end]
+    vars = (inlineanonymous(ex, i) for i = 1:N)
+    param = Expr(:parameters, Expr(:(...), kw))
+    Expr(:escape, Expr(:call, f, param, pre..., vars...))
+end
+
 """
     @nexprs N expr
 
@@ -374,6 +402,8 @@ function exprresolve_conditional(ex::Expr)
                 return true, exprresolve_cond_dict[callee](ex.args[2], ex.args[3])
             end
         end
+    elseif Meta.isexpr(ex, :block, 2) && ex.args[1] isa LineNumberNode
+        return exprresolve_conditional(ex.args[2])
     end
     false, false
 end
@@ -402,10 +432,16 @@ function exprresolve(ex::Expr)
         return ex.args[1][ex.args[2:end]...]
     end
     # Resolve conditionals
-    if ex.head === :if
+    if ex.head === :if || ex.head === :elseif
         can_eval, tf = exprresolve_conditional(ex.args[1])
         if can_eval
-            ex = tf ? ex.args[2] : ex.args[3]
+            if tf
+                return ex.args[2]
+            elseif length(ex.args) == 3
+                return ex.args[3]
+            else
+                return nothing
+            end
         end
     end
     ex
diff --git a/doc/src/devdocs/cartesian.md b/doc/src/devdocs/cartesian.md
index 1d338cbd8fab3..604f04f2a39e5 100644
--- a/doc/src/devdocs/cartesian.md
+++ b/doc/src/devdocs/cartesian.md
@@ -133,6 +133,7 @@ Base.Cartesian.@nref
 Base.Cartesian.@nextract
 Base.Cartesian.@nexprs
 Base.Cartesian.@ncall
+Base.Cartesian.@ncallkw
 Base.Cartesian.@ntuple
 Base.Cartesian.@nall
 Base.Cartesian.@nany
diff --git a/test/cartesian.jl b/test/cartesian.jl
index df16dfc281d4f..9643da72642ec 100644
--- a/test/cartesian.jl
+++ b/test/cartesian.jl
@@ -533,3 +533,35 @@ end
     inds2 = (1, CI(1, 2), 1, CI(1, 2), 1, CI(1, 2), 1)
     @test (@inferred CI(inds2)) == CI(1, 1, 2, 1, 1, 2, 1, 1, 2, 1)
 end
+
+@testset "@ncallkw" begin
+    f(x...; a, b = 1, c = 2, d = 3) = +(x..., a, b, c, d)
+    x_1, x_2 = (-1, -2)
+    kw = (a = 0, c = 0, d = 0)
+    @test x_1 + x_2 + 1 + 4 == Base.Cartesian.@ncallkw 2 f kw 4 x
+    b = 0
+    kw = (c = 0, d = 0)
+    @test x_1 + x_2 + 4 == Base.Cartesian.@ncallkw 2 f (; a = 0, b, kw...) 4 x
+end
+
+@testset "if with and without else branch" begin
+    t1 = Base.Cartesian.@ntuple 3 i -> i == 1 ? 1 : 0
+    t2 = Base.Cartesian.@ntuple 3 i -> begin
+        m = 0
+        if i == 1
+            m = 1
+        end
+        m
+    end
+    @test t1 == t2
+    t3 = Base.Cartesian.@ntuple 3 i -> begin
+        m = 0
+        if i == 1
+            m = 1
+        elseif i == 2
+            m = 2
+        end
+        m
+    end
+    @test t3 == (1, 2, 0)
+end

From f7b8e6b8fc60a4d9c062f714fec10410eb07d3d7 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Sun, 29 Oct 2023 01:24:54 +0800
Subject: [PATCH 0113/1315] Move the banner function from versions.jl to REPL
 (#51867)

---
 base/client.jl                    |  3 +-
 base/version.jl                   | 70 ------------------------------
 doc/src/manual/getting-started.md |  3 +-
 stdlib/REPL/docs/src/index.md     |  3 +-
 stdlib/REPL/src/REPL.jl           | 72 ++++++++++++++++++++++++++++++-
 stdlib/REPL/test/repl.jl          | 12 +++++-
 test/version.jl                   | 11 -----
 7 files changed, 87 insertions(+), 87 deletions(-)

diff --git a/base/client.jl b/base/client.jl
index 6f4b3273420f3..c4106fefb4dc8 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -425,7 +425,7 @@ function run_main_repl(interactive::Bool, quiet::Bool, banner::Symbol, history_f
         invokelatest(REPL_MODULE_REF[]) do REPL
             term_env = get(ENV, "TERM", @static Sys.iswindows() ? "" : "dumb")
             term = REPL.Terminals.TTYTerminal(term_env, stdin, stdout, stderr)
-            banner == :no || Base.banner(term, short=banner==:short)
+            banner == :no || REPL.banner(term, short=banner==:short)
             if term.term_type == "dumb"
                 repl = REPL.BasicREPL(term)
                 quiet || @warn "Terminal not fully functional"
@@ -445,7 +445,6 @@ function run_main_repl(interactive::Bool, quiet::Bool, banner::Symbol, history_f
         if !fallback_repl && interactive && !quiet
             @warn "REPL provider not available: using basic fallback" LOAD_PATH=join(Base.LOAD_PATH, Sys.iswindows() ? ';' : ':')
         end
-        banner == :no || Base.banner(short=banner==:short)
         let input = stdin
             if isa(input, File) || isa(input, IOStream)
                 # for files, we can slurp in the whole thing at once
diff --git a/base/version.jl b/base/version.jl
index 730ae47a27363..2b332793496f3 100644
--- a/base/version.jl
+++ b/base/version.jl
@@ -266,73 +266,3 @@ else
 end
 
 libllvm_path() = ccall(:jl_get_libllvm, Any, ())
-
-function banner(io::IO = stdout; short = false)
-    if GIT_VERSION_INFO.tagged_commit
-        commit_string = TAGGED_RELEASE_BANNER
-    elseif isempty(GIT_VERSION_INFO.commit)
-        commit_string = ""
-    else
-        days = Int(floor((ccall(:jl_clock_now, Float64, ()) - GIT_VERSION_INFO.fork_master_timestamp) / (60 * 60 * 24)))
-        days = max(0, days)
-        unit = days == 1 ? "day" : "days"
-        distance = GIT_VERSION_INFO.fork_master_distance
-        commit = GIT_VERSION_INFO.commit_short
-
-        if distance == 0
-            commit_string = "Commit $(commit) ($(days) $(unit) old master)"
-        else
-            branch = GIT_VERSION_INFO.branch
-            commit_string = "$(branch)/$(commit) (fork: $(distance) commits, $(days) $(unit))"
-        end
-    end
-
-    commit_date = isempty(Base.GIT_VERSION_INFO.date_string) ? "" : " ($(split(Base.GIT_VERSION_INFO.date_string)[1]))"
-
-    if get(io, :color, false)::Bool
-        c = text_colors
-        tx = c[:normal] # text
-        jl = c[:normal] # julia
-        d1 = c[:bold] * c[:blue]    # first dot
-        d2 = c[:bold] * c[:red]     # second dot
-        d3 = c[:bold] * c[:green]   # third dot
-        d4 = c[:bold] * c[:magenta] # fourth dot
-
-        if short
-            print(io,"""
-              $(d3)o$(tx)  | Version $(VERSION)$(commit_date)
-             $(d2)o$(tx) $(d4)o$(tx) | $(commit_string)
-            """)
-        else
-            print(io,"""               $(d3)_$(tx)
-               $(d1)_$(tx)       $(jl)_$(tx) $(d2)_$(d3)(_)$(d4)_$(tx)     |  Documentation: https://docs.julialang.org
-              $(d1)(_)$(jl)     | $(d2)(_)$(tx) $(d4)(_)$(tx)    |
-               $(jl)_ _   _| |_  __ _$(tx)   |  Type \"?\" for help, \"]?\" for Pkg help.
-              $(jl)| | | | | | |/ _` |$(tx)  |
-              $(jl)| | |_| | | | (_| |$(tx)  |  Version $(VERSION)$(commit_date)
-             $(jl)_/ |\\__'_|_|_|\\__'_|$(tx)  |  $(commit_string)
-            $(jl)|__/$(tx)                   |
-
-            """)
-        end
-    else
-        if short
-            print(io,"""
-              o  |  Version $(VERSION)$(commit_date)
-             o o |  $(commit_string)
-            """)
-        else
-            print(io,"""
-                           _
-               _       _ _(_)_     |  Documentation: https://docs.julialang.org
-              (_)     | (_) (_)    |
-               _ _   _| |_  __ _   |  Type \"?\" for help, \"]?\" for Pkg help.
-              | | | | | | |/ _` |  |
-              | | |_| | | | (_| |  |  Version $(VERSION)$(commit_date)
-             _/ |\\__'_|_|_|\\__'_|  |  $(commit_string)
-            |__/                   |
-
-            """)
-        end
-    end
-end
diff --git a/doc/src/manual/getting-started.md b/doc/src/manual/getting-started.md
index e972788022de6..36d54650388cd 100644
--- a/doc/src/manual/getting-started.md
+++ b/doc/src/manual/getting-started.md
@@ -10,8 +10,9 @@ known as a read-eval-print loop or "REPL") by double-clicking the Julia executab
 `julia` from the command line:
 
 ```@eval
+using REPL
 io = IOBuffer()
-Base.banner(io)
+REPL.banner(io)
 banner = String(take!(io))
 import Markdown
 Markdown.parse("```\n\$ julia\n\n$(banner)\njulia> 1 + 2\n3\n\njulia> ans\n3\n```")
diff --git a/stdlib/REPL/docs/src/index.md b/stdlib/REPL/docs/src/index.md
index bee94354e57e1..ae444e134ad17 100644
--- a/stdlib/REPL/docs/src/index.md
+++ b/stdlib/REPL/docs/src/index.md
@@ -7,8 +7,9 @@ shell modes. The REPL can be started by simply calling `julia` with no arguments
 on the executable:
 
 ```@eval
+using REPL
 io = IOBuffer()
-Base.banner(io)
+REPL.banner(io)
 banner = String(take!(io))
 import Markdown
 Markdown.parse("```\n\$ julia\n\n$(banner)\njulia>\n```")
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index 25b2ff00602d6..8c55883a04fb9 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -1422,10 +1422,80 @@ ends_with_semicolon(code::AbstractString) = ends_with_semicolon(String(code))
 ends_with_semicolon(code::Union{String,SubString{String}}) =
     contains(_rm_strings_and_comments(code), r";\s*$")
 
+function banner(io::IO = stdout; short = false)
+    if Base.GIT_VERSION_INFO.tagged_commit
+        commit_string = Base.TAGGED_RELEASE_BANNER
+    elseif isempty(Base.GIT_VERSION_INFO.commit)
+        commit_string = ""
+    else
+        days = Int(floor((ccall(:jl_clock_now, Float64, ()) - Base.GIT_VERSION_INFO.fork_master_timestamp) / (60 * 60 * 24)))
+        days = max(0, days)
+        unit = days == 1 ? "day" : "days"
+        distance = Base.GIT_VERSION_INFO.fork_master_distance
+        commit = Base.GIT_VERSION_INFO.commit_short
+
+        if distance == 0
+            commit_string = "Commit $(commit) ($(days) $(unit) old master)"
+        else
+            branch = Base.GIT_VERSION_INFO.branch
+            commit_string = "$(branch)/$(commit) (fork: $(distance) commits, $(days) $(unit))"
+        end
+    end
+
+    commit_date = isempty(Base.GIT_VERSION_INFO.date_string) ? "" : " ($(split(Base.GIT_VERSION_INFO.date_string)[1]))"
+
+    if get(io, :color, false)::Bool
+        c = Base.text_colors
+        tx = c[:normal] # text
+        jl = c[:normal] # julia
+        d1 = c[:bold] * c[:blue]    # first dot
+        d2 = c[:bold] * c[:red]     # second dot
+        d3 = c[:bold] * c[:green]   # third dot
+        d4 = c[:bold] * c[:magenta] # fourth dot
+
+        if short
+            print(io,"""
+              $(d3)o$(tx)  | Version $(VERSION)$(commit_date)
+             $(d2)o$(tx) $(d4)o$(tx) | $(commit_string)
+            """)
+        else
+            print(io,"""               $(d3)_$(tx)
+               $(d1)_$(tx)       $(jl)_$(tx) $(d2)_$(d3)(_)$(d4)_$(tx)     |  Documentation: https://docs.julialang.org
+              $(d1)(_)$(jl)     | $(d2)(_)$(tx) $(d4)(_)$(tx)    |
+               $(jl)_ _   _| |_  __ _$(tx)   |  Type \"?\" for help, \"]?\" for Pkg help.
+              $(jl)| | | | | | |/ _` |$(tx)  |
+              $(jl)| | |_| | | | (_| |$(tx)  |  Version $(VERSION)$(commit_date)
+             $(jl)_/ |\\__'_|_|_|\\__'_|$(tx)  |  $(commit_string)
+            $(jl)|__/$(tx)                   |
+
+            """)
+        end
+    else
+        if short
+            print(io,"""
+              o  |  Version $(VERSION)$(commit_date)
+             o o |  $(commit_string)
+            """)
+        else
+            print(io,"""
+                           _
+               _       _ _(_)_     |  Documentation: https://docs.julialang.org
+              (_)     | (_) (_)    |
+               _ _   _| |_  __ _   |  Type \"?\" for help, \"]?\" for Pkg help.
+              | | | | | | |/ _` |  |
+              | | |_| | | | (_| |  |  Version $(VERSION)$(commit_date)
+             _/ |\\__'_|_|_|\\__'_|  |  $(commit_string)
+            |__/                   |
+
+            """)
+        end
+    end
+end
+
 function run_frontend(repl::StreamREPL, backend::REPLBackendRef)
     repl.frontend_task = current_task()
     have_color = hascolor(repl)
-    Base.banner(repl.stream)
+    banner(repl.stream)
     d = REPLDisplay(repl)
     dopushdisplay = !in(d,Base.Multimedia.displays)
     dopushdisplay && pushdisplay(d)
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 0fb41ddacefc7..48284a5e89161 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -18,7 +18,6 @@ include(joinpath(BASE_TEST_PATH, "testenv.jl"))
 include("FakeTerminals.jl")
 import .FakeTerminals.FakeTerminal
 
-
 function kill_timer(delay)
     # Give ourselves a generous timer here, just to prevent
     # this causing e.g. a CI hang when there's something unexpected in the output.
@@ -1726,3 +1725,14 @@ fake_repl(options=REPL.Options(confirm_exit=false,hascolor=true,hint_tab_complet
     Base.wait(repltask)
     @test !occursin("vailable", String(readavailable(stdout_read)))
 end
+
+# banner
+let io = IOBuffer()
+    @test REPL.banner(io) === nothing
+    seek(io, 0)
+    @test countlines(io) == 9
+    take!(io)
+    @test REPL.banner(io; short=true) === nothing
+    seek(io, 0)
+    @test countlines(io) == 2
+end
diff --git a/test/version.jl b/test/version.jl
index 6986e97e1be91..78d606ac2a6cb 100644
--- a/test/version.jl
+++ b/test/version.jl
@@ -219,17 +219,6 @@ for major=0:3, minor=0:3, patch=0:3
     end
 end
 
-# banner
-import Base.banner
-io = IOBuffer()
-@test banner(io) === nothing
-seek(io, 0)
-@test countlines(io) == 9
-take!(io)
-@test banner(io; short=true) === nothing
-seek(io, 0)
-@test countlines(io) == 2
-
 # julia_version.h version test
 @test VERSION.major == ccall(:jl_ver_major, Cint, ())
 @test VERSION.minor == ccall(:jl_ver_minor, Cint, ())

From 57c7c00db1a53e503ff0d09cc270800dc1370839 Mon Sep 17 00:00:00 2001
From: "Viral B. Shah" <ViralBShah@users.noreply.github.com>
Date: Sat, 28 Oct 2023 13:25:05 -0400
Subject: [PATCH 0114/1315] Redo #32205 - PosDef exception is too specific.
 (#51864)

Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
---
 stdlib/LinearAlgebra/src/exceptions.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/exceptions.jl b/stdlib/LinearAlgebra/src/exceptions.jl
index a8d81aad3e067..574decf79fc07 100644
--- a/stdlib/LinearAlgebra/src/exceptions.jl
+++ b/stdlib/LinearAlgebra/src/exceptions.jl
@@ -38,7 +38,7 @@ function Base.showerror(io::IO, ex::PosDefException)
     else
         print(io, "positive definite")
     end
-    print(io, "; Cholesky factorization failed.")
+    print(io, "; Factorization failed.")
 end
 
 struct RankDeficientException <: Exception

From ba984670cf11721928ec8eb528ce2052a2f7b7e2 Mon Sep 17 00:00:00 2001
From: Alexis Montoison <35051714+amontoison@users.noreply.github.com>
Date: Sat, 28 Oct 2023 12:26:49 -0500
Subject: [PATCH 0115/1315] [BLAS] Add the gemmt routine (#51701)

We can finally add this routine, supported by the last version of
OpenBLAS (3.24) and Intel MKL.
---
 stdlib/LinearAlgebra/docs/src/index.md |  3 +
 stdlib/LinearAlgebra/src/blas.jl       | 84 ++++++++++++++++++++++++++
 stdlib/LinearAlgebra/test/blas.jl      | 36 ++++++++++-
 3 files changed, 122 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/docs/src/index.md b/stdlib/LinearAlgebra/docs/src/index.md
index 00ce21ed6fcae..79444333d5ec1 100644
--- a/stdlib/LinearAlgebra/docs/src/index.md
+++ b/stdlib/LinearAlgebra/docs/src/index.md
@@ -730,6 +730,9 @@ and define matrix-matrix operations.
 [Dongarra-1990]: https://dl.acm.org/doi/10.1145/77626.79170
 
 ```@docs
+LinearAlgebra.BLAS.gemmt!
+LinearAlgebra.BLAS.gemmt(::Any, ::Any, ::Any, ::Any, ::Any, ::Any)
+LinearAlgebra.BLAS.gemmt(::Any, ::Any, ::Any, ::Any, ::Any)
 LinearAlgebra.BLAS.gemm!
 LinearAlgebra.BLAS.gemm(::Any, ::Any, ::Any, ::Any, ::Any)
 LinearAlgebra.BLAS.gemm(::Any, ::Any, ::Any, ::Any)
diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 8da19baee5045..998eed6a7d24c 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -63,6 +63,8 @@ export
     # xSYR2
     # xSPR2
 # Level 3
+    gemmt!,
+    gemmt,
     gemm!,
     gemm,
     symm!,
@@ -1481,6 +1483,88 @@ end
 # Level 3
 ## (GE) general matrix-matrix multiplication
 
+"""
+    gemmt!(uplo, tA, tB, alpha, A, B, beta, C)
+
+Update the lower or upper triangular part specified by [`uplo`](@ref stdlib-blas-uplo) of `C` as
+`alpha*A*B + beta*C` or the other variants according to [`tA`](@ref stdlib-blas-trans) and `tB`.
+Return the updated `C`.
+
+!!! compat "Julia 1.11"
+    `gemmt!` requires at least Julia 1.11.
+"""
+function gemmt! end
+
+for (gemmt, elty) in
+        ((:dgemmt_,:Float64),
+         (:sgemmt_,:Float32),
+         (:zgemmt_,:ComplexF64),
+         (:cgemmt_,:ComplexF32))
+    @eval begin
+             # SUBROUTINE DGEMMT(UPLO,TRANSA,TRANSB,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC)
+             # *     .. Scalar Arguments ..
+             #       DOUBLE PRECISION ALPHA,BETA
+             #       INTEGER K,LDA,LDB,LDC,N
+             #       CHARACTER UPLO,TRANSA,TRANSB
+             # *     .. Array Arguments ..
+             #       DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
+        function gemmt!(uplo::AbstractChar, transA::AbstractChar, transB::AbstractChar,
+                        alpha::Union{($elty), Bool},
+                        A::AbstractVecOrMat{$elty}, B::AbstractVecOrMat{$elty},
+                        beta::Union{($elty), Bool},
+                        C::AbstractVecOrMat{$elty})
+            chkuplo(uplo)
+            require_one_based_indexing(A, B, C)
+            m = size(A, transA == 'N' ? 1 : 2)
+            ka = size(A, transA == 'N' ? 2 : 1)
+            kb = size(B, transB == 'N' ? 1 : 2)
+            n = size(B, transB == 'N' ? 2 : 1)
+            if ka != kb || m != n || m != size(C,1) || n != size(C,2)
+                throw(DimensionMismatch(lazy"A has size ($m,$ka), B has size ($kb,$n), C has size $(size(C))"))
+            end
+            chkstride1(A)
+            chkstride1(B)
+            chkstride1(C)
+            ccall((@blasfunc($gemmt), libblastrampoline), Cvoid,
+                (Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{BlasInt},
+                 Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt},
+                 Ptr{$elty}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty},
+                 Ref{BlasInt}, Clong, Clong, Clong),
+                 uplo, transA, transB, n,
+                 ka, alpha, A, max(1,stride(A,2)),
+                 B, max(1,stride(B,2)), beta, C,
+                 max(1,stride(C,2)), 1, 1, 1)
+            C
+        end
+        function gemmt(uplo::AbstractChar, transA::AbstractChar, transB::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
+            gemmt!(uplo, transA, transB, alpha, A, B, zero($elty), similar(B, $elty, (size(A, transA == 'N' ? 1 : 2), size(B, transB == 'N' ? 2 : 1))))
+        end
+        function gemmt(uplo::AbstractChar, transA::AbstractChar, transB::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
+            gemmt(uplo, transA, transB, one($elty), A, B)
+        end
+    end
+end
+
+"""
+    gemmt(uplo, tA, tB, alpha, A, B)
+
+Return the lower or upper triangular part specified by [`uplo`](@ref stdlib-blas-uplo) of `A*B` or the other three variants according to [`tA`](@ref stdlib-blas-trans) and `tB`.
+
+!!! compat "Julia 1.11"
+    `gemmt` requires at least Julia 1.11.
+"""
+gemmt(uplo, tA, tB, alpha, A, B)
+
+"""
+    gemmt(uplo, tA, tB, A, B)
+
+Return the lower or upper triangular part specified by [`uplo`](@ref stdlib-blas-uplo) of `A*B` or the other three variants according to [`tA`](@ref stdlib-blas-trans) and `tB`.
+
+!!! compat "Julia 1.11"
+    `gemmt` requires at least Julia 1.11.
+"""
+gemmt(uplo, tA, tB, A, B)
+
 """
     gemm!(tA, tB, alpha, A, B, beta, C)
 
diff --git a/stdlib/LinearAlgebra/test/blas.jl b/stdlib/LinearAlgebra/test/blas.jl
index 4d6b6ccc3b647..ef7bbca9a9c54 100644
--- a/stdlib/LinearAlgebra/test/blas.jl
+++ b/stdlib/LinearAlgebra/test/blas.jl
@@ -447,6 +447,40 @@ Random.seed!(100)
             end
         end
     end
+    @testset "gemmt" begin
+        for (wrapper, uplo) in ((LowerTriangular, 'L'), (UpperTriangular, 'U'))
+            @test wrapper(BLAS.gemmt(uplo, 'N', 'N', I4, I4)) ≈ wrapper(I4)
+            @test wrapper(BLAS.gemmt(uplo, 'N', 'T', I4, I4)) ≈ wrapper(I4)
+            @test wrapper(BLAS.gemmt(uplo, 'T', 'N', I4, I4)) ≈ wrapper(I4)
+            @test wrapper(BLAS.gemmt(uplo, 'T', 'T', I4, I4)) ≈ wrapper(I4)
+            @test wrapper(BLAS.gemmt(uplo, 'N', 'N', el2, I4, I4)) ≈ wrapper(el2 * I4)
+            @test wrapper(BLAS.gemmt(uplo, 'N', 'T', el2, I4, I4)) ≈ wrapper(el2 * I4)
+            @test wrapper(BLAS.gemmt(uplo, 'T', 'N', el2, I4, I4)) ≈ wrapper(el2 * I4)
+            @test wrapper(BLAS.gemmt(uplo, 'T', 'T', el2, I4, I4)) ≈ wrapper(el2 * I4)
+            I4cp = copy(I4)
+            @test wrapper(BLAS.gemmt!(uplo, 'N', 'N', one(elty), I4, I4, elm1, I4cp)) ≈ wrapper(Z4)
+            @test I4cp ≈ Z4
+            I4cp[:] = I4
+            @test wrapper(BLAS.gemmt!(uplo, 'N', 'T', one(elty), I4, I4, elm1, I4cp)) ≈ wrapper(Z4)
+            @test I4cp ≈ Z4
+            I4cp[:] = I4
+            @test wrapper(BLAS.gemmt!(uplo, 'T', 'N', one(elty), I4, I4, elm1, I4cp)) ≈ wrapper(Z4)
+            @test I4cp ≈ Z4
+            I4cp[:] = I4
+            @test wrapper(BLAS.gemmt!(uplo, 'T', 'T', one(elty), I4, I4, elm1, I4cp)) ≈ wrapper(Z4)
+            @test I4cp ≈ Z4
+            M1 = uplo == 'U' ? U4 : I4
+            @test wrapper(BLAS.gemmt(uplo, 'N', 'N', I4, U4)) ≈ wrapper(M1)
+            M2 = uplo == 'U' ? I4 : U4'
+            @test wrapper(BLAS.gemmt(uplo, 'N', 'T', I4, U4)) ≈ wrapper(M2)
+            @test_throws DimensionMismatch BLAS.gemmt!(uplo, 'N', 'N', one(elty), I43, I4, elm1, I43)
+            @test_throws DimensionMismatch BLAS.gemmt!(uplo, 'N', 'N', one(elty), I4, I4, elm1, Matrix{elty}(I, 5, 5))
+            @test_throws DimensionMismatch BLAS.gemmt!(uplo, 'N', 'N', one(elty), I43, I4, elm1, I4)
+            @test_throws DimensionMismatch BLAS.gemmt!(uplo, 'T', 'N', one(elty), I4, I43, elm1, I43)
+            @test_throws DimensionMismatch BLAS.gemmt!(uplo, 'N', 'T', one(elty), I43, I43, elm1, I43)
+            @test_throws DimensionMismatch BLAS.gemmt!(uplo, 'T', 'T', one(elty), I43, I43, elm1, Matrix{elty}(I, 3, 4))
+        end
+    end
     @testset "gemm" begin
         @test all(BLAS.gemm('N', 'N', I4, I4) .== I4)
         @test all(BLAS.gemm('N', 'T', I4, I4) .== I4)
@@ -455,7 +489,7 @@ Random.seed!(100)
         @test all(BLAS.gemm('N', 'N', el2, I4, I4) .== el2 * I4)
         @test all(BLAS.gemm('N', 'T', el2, I4, I4) .== el2 * I4)
         @test all(BLAS.gemm('T', 'N', el2, I4, I4) .== el2 * I4)
-        @test all(LinearAlgebra.BLAS.gemm('T', 'T', el2, I4, I4) .== el2 * I4)
+        @test all(BLAS.gemm('T', 'T', el2, I4, I4) .== el2 * I4)
         I4cp = copy(I4)
         @test all(BLAS.gemm!('N', 'N', one(elty), I4, I4, elm1, I4cp) .== Z4)
         @test all(I4cp .== Z4)

From ab1eec566d023d59f18b3ad2de136188edf539c1 Mon Sep 17 00:00:00 2001
From: Benjamin Lorenz <benlorenz@users.noreply.github.com>
Date: Sat, 28 Oct 2023 21:43:27 +0200
Subject: [PATCH 0116/1315] libjulia: add jl_unwrap_unionall to exported_funcs
 (#51916)

This was recently refactored in #51319 and while trying to adapt
`libcxxwrap-julia` to the new changes I got:
```
ld: CMakeFiles/test_module.dir/test_module.cpp.o: in function `jl_datatype_layout':
test_module.cpp:(.text+0x2c2): undefined reference to `jl_unwrap_unionall'
```

The function `jl_datatype_layout` is `STATIC_INLINE` in `julia.h`:

https://github.com/JuliaLang/julia/blob/98542d748540e2390d6222282749c7dd534544da/src/julia.h#L1304-L1312
`jl_unwrap_unionall` is marked `JL_DLLEXPORT` here but it doesn't appear
in the exports of `libjulia`.
---
 src/jl_exported_funcs.inc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index f8a756ad216f7..6ae91f5cc32d6 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -497,6 +497,7 @@
     XX(jl_uncompress_argname_n) \
     XX(jl_uncompress_ir) \
     XX(jl_undefined_var_error) \
+    XX(jl_unwrap_unionall) \
     XX(jl_has_no_field_error) \
     XX(jl_value_ptr) \
     XX(jl_ver_is_release) \

From 18f8070af473064ae06970abc439fb0c92ffe848 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Riedemann?=
 <38795484+longemen3000@users.noreply.github.com>
Date: Sat, 28 Oct 2023 18:14:32 -0300
Subject: [PATCH 0117/1315] add 1-arg methods for set comparisons (#50862)

---
 base/abstractset.jl | 102 ++++++++++++++++++++++++++++++++++++++++++++
 test/sets.jl        |  13 ++++++
 2 files changed, 115 insertions(+)

diff --git a/base/abstractset.jl b/base/abstractset.jl
index 38f7a63fd4536..3bfc3bffcd831 100644
--- a/base/abstractset.jl
+++ b/base/abstractset.jl
@@ -364,6 +364,31 @@ hasfastin(x) = hasfastin(typeof(x))
 
 ⊇(a, b) = b ⊆ a
 
+"""
+    issubset(x)
+
+Create a function that compares its argument to `x` using [`issubset`](@ref), i.e.
+a function equivalent to `y -> issubset(y, x)`.
+The returned function is of type `Base.Fix2{typeof(issubset)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+issubset(a) = Fix2(issubset, a)
+
+"""
+    ⊇(x)
+
+Create a function that compares its argument to `x` using [`⊇`](@ref), i.e.
+a function equivalent to `y -> y ⊇ x`.
+The returned function is of type `Base.Fix2{typeof(⊇)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+⊇(a) = Fix2(⊇, a)
 ## strict subset comparison
 
 function ⊊ end
@@ -393,6 +418,31 @@ false
 ⊊(a, b) = Set(a) ⊊ Set(b)
 ⊋(a, b) = b ⊊ a
 
+"""
+    ⊋(x)
+
+Create a function that compares its argument to `x` using [`⊋`](@ref), i.e.
+a function equivalent to `y -> y ⊋ x`.
+The returned function is of type `Base.Fix2{typeof(⊋)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+⊋(a) = Fix2(⊋, a)
+"""
+    ⊊(x)
+
+Create a function that compares its argument to `x` using [`⊊`](@ref), i.e.
+a function equivalent to `y -> y ⊊ x`.
+The returned function is of type `Base.Fix2{typeof(⊊)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+⊊(a) = Fix2(⊊, a)
+
 function ⊈ end
 function ⊉ end
 """
@@ -417,6 +467,32 @@ false
 ⊈(a, b) = !⊆(a, b)
 ⊉(a, b) = b ⊈ a
 
+"""
+    ⊉(x)
+
+Create a function that compares its argument to `x` using [`⊉`](@ref), i.e.
+a function equivalent to `y -> y ⊉ x`.
+The returned function is of type `Base.Fix2{typeof(⊉)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+⊉(a) = Fix2(⊉, a)
+
+"""
+    ⊈(x)
+
+Create a function that compares its argument to `x` using [`⊈`](@ref), i.e.
+a function equivalent to `y -> y ⊈ x`.
+The returned function is of type `Base.Fix2{typeof(⊈)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+⊈(a) = Fix2(⊈, a)
+
 ## set equality comparison
 
 """
@@ -453,6 +529,19 @@ function issetequal(a, b)
     return issetequal(Set(a), Set(b))
 end
 
+"""
+    issetequal(x)
+
+Create a function that compares its argument to `x` using [`issetequal`](@ref), i.e.
+a function equivalent to `y -> issetequal(y, x)`.
+The returned function is of type `Base.Fix2{typeof(issetequal)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+issetequal(a) = Fix2(issetequal, a)
+
 ## set disjoint comparison
 """
     isdisjoint(a, b) -> Bool
@@ -499,6 +588,19 @@ function isdisjoint(a::AbstractRange{T}, b::AbstractRange{T}) where T
     end
 end
 
+"""
+    isdisjoint(x)
+
+Create a function that compares its argument to `x` using [`isdisjoint`](@ref), i.e.
+a function equivalent to `y -> isdisjoint(y, x)`.
+The returned function is of type `Base.Fix2{typeof(isdisjoint)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+isdisjoint(a) = Fix2(isdisjoint, a)
+
 _overlapping_range_isdisjoint(a::AbstractRange{T}, b::AbstractRange{T}) where T = invoke(isdisjoint, Tuple{Any,Any}, a, b)
 
 function _overlapping_range_isdisjoint(a::AbstractRange{T}, b::AbstractRange{T}) where T<:Integer
diff --git a/test/sets.jl b/test/sets.jl
index e33397e58d2b6..694397a1787eb 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -364,7 +364,9 @@ end
             @test issubset(intersect(l,r), r)
             @test issubset(l, union(l,r))
             @test issubset(r, union(l,r))
+            @test issubset(union(l,r))(r)
             @test isdisjoint(l,l) == isempty(l)
+            @test isdisjoint(l)(l) == isempty(l)
             @test isdisjoint(l,r) == isempty(intersect(l,r))
             if S === Vector
                 @test sort(union(intersect(l,r),symdiff(l,r))) == sort(union(l,r))
@@ -381,6 +383,15 @@ end
             @test ⊋(S([1,2]), S([1]))
             @test !⊋(S([1]), S([1]))
             @test ⊉(S([1]), S([2]))
+
+            @test ⊆(S([1,2]))(S([1]))
+            @test ⊊(S([1,2]))(S([1]))
+            @test !⊊(S([1]))(S([1]))
+            @test ⊈(S([2]))(S([1]))
+            @test ⊇(S([1]))(S([1,2]))
+            @test ⊋(S([1]))(S([1,2]))
+            @test !⊋(S([1]))(S([1]))
+            @test ⊉(S([2]))(S([1]))
         end
         let s1 = S([1,2,3,4])
             @test s1 !== symdiff(s1) == s1
@@ -859,6 +870,8 @@ end
         @test !(B ⊉ A)
         @test !issetequal(A, B)
         @test !issetequal(B, A)
+        @test !issetequal(B)(A)
+        @test !issetequal(A)(B)
         for T = (Tuple, identity, Set, BitSet, Base.IdSet{Int})
             @test issetequal(A, T(A))
             @test issetequal(B, T(B))

From 81abb6dbce2219d0409cffbd229c379a8438c7fe Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Sat, 28 Oct 2023 17:25:17 -0400
Subject: [PATCH 0118/1315] Adapt to LLVM 16 (#51591)

Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com>
Co-authored-by: Prem Chintalapudi <prem.chintalapudi@gmail.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 src/APInt-C.cpp                |   4 +-
 src/Makefile                   |   4 +
 src/aotcompile.cpp             |   5 +-
 src/ccall.cpp                  |  29 ++++----
 src/cgutils.cpp                |  38 +++++-----
 src/codegen.cpp                | 129 ++++++++++++++++++++++++---------
 src/intrinsics.cpp             |  30 ++++----
 src/jitlayers.cpp              |  72 ++++++++++++++----
 src/jitlayers.h                |   8 +-
 src/llvm-alloc-opt.cpp         |   2 +-
 src/llvm-codegen-shared.h      |  29 +++++++-
 src/llvm-cpufeatures.cpp       |   6 +-
 src/llvm-julia-licm.cpp        |   4 +
 src/llvm-late-gc-lowering.cpp  |  32 ++++++--
 src/llvm-multiversioning.cpp   |   5 +-
 src/llvm-pass-helpers.cpp      |  12 +++
 src/llvm-ptls.cpp              |   4 +
 src/llvm-remove-addrspaces.cpp |   2 +-
 src/llvm-simdloop.cpp          |   4 +
 src/pipeline.cpp               |  39 +++++++++-
 20 files changed, 336 insertions(+), 122 deletions(-)

diff --git a/src/APInt-C.cpp b/src/APInt-C.cpp
index 7ff68edb0868c..ddb6d7c685738 100644
--- a/src/APInt-C.cpp
+++ b/src/APInt-C.cpp
@@ -30,10 +30,10 @@ const unsigned int host_char_bit = 8;
         /* TODO: this memcpy assumes little-endian,
          * for big-endian, need to align the copy to the other end */ \
         memcpy(data_a64, p##s, RoundUpToAlignment(numbits, host_char_bit) / host_char_bit); \
-        s = APInt(numbits, makeArrayRef(data_a64, nbytes / sizeof(integerPart))); \
+        s = APInt(numbits, ArrayRef<uint64_t>(data_a64, nbytes / sizeof(integerPart))); \
     } \
     else { \
-        s = APInt(numbits, makeArrayRef(p##s, numbits / integerPartWidth)); \
+        s = APInt(numbits, ArrayRef<uint64_t>(p##s, numbits / integerPartWidth)); \
     }
 
 /* assign to "integerPart *pr" from "APInt a" */
diff --git a/src/Makefile b/src/Makefile
index 6060cefa7a3bc..b3ffd79dcad52 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -79,6 +79,10 @@ endif
 
 RT_LLVM_LIBS := support
 
+ifeq ($(LLVM_VER_MAJ),16)
+RT_LLVM_LIBS += targetparser
+endif
+
 ifeq ($(OS),WINNT)
 SRCS += win32_ucontext
 endif
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index a83001e77f0fa..af7e05b338d2f 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -62,7 +62,6 @@ using namespace llvm;
 #include "jitlayers.h"
 #include "serialize.h"
 #include "julia_assert.h"
-#include "llvm-codegen-shared.h"
 #include "processor.h"
 
 #define DEBUG_TYPE "julia_aotcompile"
@@ -1004,7 +1003,7 @@ static AOTOutputs add_output_impl(Module &M, TargetMachine &SourceTM, ShardTimer
             SourceTM.getRelocationModel(),
             SourceTM.getCodeModel(),
             SourceTM.getOptLevel()));
-
+    fixupTM(*TM);
     if (unopt) {
         timers.unopt.startTimer();
         raw_svector_ostream OS(out.unopt);
@@ -1032,6 +1031,7 @@ static AOTOutputs add_output_impl(Module &M, TargetMachine &SourceTM, ShardTimer
                 SourceTM.getRelocationModel(),
                 SourceTM.getCodeModel(),
                 SourceTM.getOptLevel()));
+        fixupTM(*PMTM);
         NewPM optimizer{std::move(PMTM), getOptLevel(jl_options.opt_level), OptimizationOptions::defaults(true, true)};
         optimizer.run(M);
         assert(!verifyLLVMIR(M));
@@ -1527,6 +1527,7 @@ void jl_dump_native_impl(void *native_code,
             CMModel,
             CodeGenOpt::Aggressive // -O3 TODO: respect command -O0 flag?
             ));
+    fixupTM(*SourceTM);
     auto DL = jl_create_datalayout(*SourceTM);
     std::string StackProtectorGuard;
     unsigned OverrideStackAlignment;
diff --git a/src/ccall.cpp b/src/ccall.cpp
index ff7ea305c0c05..4ca865af18e40 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -153,7 +153,7 @@ static Value *runtime_sym_lookup(
             dlsym_lookup);
 
     assert(f->getParent() != NULL);
-    f->getBasicBlockList().push_back(dlsym_lookup);
+    dlsym_lookup->insertInto(f);
     irbuilder.SetInsertPoint(dlsym_lookup);
     Instruction *llvmf;
     Value *nameval = stringConstPtr(emission_context, irbuilder, f_name);
@@ -180,7 +180,7 @@ static Value *runtime_sym_lookup(
     store->setAtomic(AtomicOrdering::Release);
     irbuilder.CreateBr(ccall_bb);
 
-    f->getBasicBlockList().push_back(ccall_bb);
+    ccall_bb->insertInto(f);
     irbuilder.SetInsertPoint(ccall_bb);
     PHINode *p = irbuilder.CreatePHI(T_pvoidfunc, 2);
     p->addIncoming(llvmf_orig, enter_bb);
@@ -440,21 +440,21 @@ static Value *llvm_type_rewrite(
     Value *from;
     Value *to;
     const DataLayout &DL = ctx.builder.GetInsertBlock()->getModule()->getDataLayout();
-    unsigned align = std::max(DL.getPrefTypeAlignment(target_type), DL.getPrefTypeAlignment(from_type));
+    Align align = std::max(DL.getPrefTypeAlign(target_type), DL.getPrefTypeAlign(from_type));
     if (DL.getTypeAllocSize(target_type) >= DL.getTypeAllocSize(from_type)) {
         to = emit_static_alloca(ctx, target_type);
         setName(ctx.emission_context, to, "type_rewrite_buffer");
-        cast<AllocaInst>(to)->setAlignment(Align(align));
+        cast<AllocaInst>(to)->setAlignment(align);
         from = emit_bitcast(ctx, to, from_type->getPointerTo());
     }
     else {
         from = emit_static_alloca(ctx, from_type);
         setName(ctx.emission_context, from, "type_rewrite_buffer");
-        cast<AllocaInst>(from)->setAlignment(Align(align));
+        cast<AllocaInst>(from)->setAlignment(align);
         to = emit_bitcast(ctx, from, target_type->getPointerTo());
     }
-    ctx.builder.CreateAlignedStore(v, from, Align(align));
-    auto pun = ctx.builder.CreateAlignedLoad(target_type, to, Align(align));
+    ctx.builder.CreateAlignedStore(v, from, align);
+    auto pun = ctx.builder.CreateAlignedLoad(target_type, to, align);
     setName(ctx.emission_context, pun, "type_rewrite");
     return pun;
 }
@@ -473,7 +473,7 @@ static Value *runtime_apply_type_env(jl_codectx_t &ctx, jl_value_t *ty)
                 ctx.spvals_ptr,
                 ConstantInt::get(ctx.types().T_size, sizeof(jl_svec_t) / sizeof(jl_value_t*)))
     };
-    auto call = ctx.builder.CreateCall(prepare_call(jlapplytype_func), makeArrayRef(args));
+    auto call = ctx.builder.CreateCall(prepare_call(jlapplytype_func), ArrayRef<Value*>(args));
     addRetAttr(call, Attribute::getWithAlignment(ctx.builder.getContext(), Align(16)));
     return call;
 }
@@ -483,9 +483,10 @@ static const std::string make_errmsg(const char *fname, int n, const char *err)
     std::string _msg;
     raw_string_ostream msg(_msg);
     msg << fname;
-    if (n > 0)
-        msg << " argument " << n;
-    else
+    if (n > 0) {
+        msg << " argument ";
+        msg << n;
+    } else
         msg << " return";
     msg << err;
     return msg.str();
@@ -1055,7 +1056,7 @@ class function_sig_t {
     FunctionType *functype(LLVMContext &ctxt) const {
         assert(err_msg.empty());
         if (nreqargs > 0)
-            return FunctionType::get(sret ? getVoidTy(ctxt) : prt, makeArrayRef(fargt_sig).slice(0, nreqargs), true);
+            return FunctionType::get(sret ? getVoidTy(ctxt) : prt, ArrayRef<Type*>(fargt_sig).slice(0, nreqargs), true);
         else
             return FunctionType::get(sret ? getVoidTy(ctxt) : prt, fargt_sig, false);
     }
@@ -1674,7 +1675,7 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
                 true);
         setName(ctx.emission_context, signal_page_load, "signal_page_load");
         ctx.builder.CreateBr(contBB);
-        ctx.f->getBasicBlockList().push_back(contBB);
+        contBB->insertInto(ctx.f);
         ctx.builder.SetInsertPoint(contBB);
         return ghostValue(ctx, jl_nothing_type);
     }
@@ -1857,7 +1858,7 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
                         decay_derived(ctx, data_pointer(ctx, val)),
                         T_pint8_derived)
             };
-            Value *ret = ctx.builder.CreateCall(prepare_call(jl_object_id__func), makeArrayRef(args));
+            Value *ret = ctx.builder.CreateCall(prepare_call(jl_object_id__func), ArrayRef<Value*>(args));
             setName(ctx.emission_context, ret, "object_id");
             JL_GC_POP();
             return mark_or_box_ccall_result(ctx, ret, retboxed, rt, unionall, static_rt);
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 7590722f82826..e0e48ddf81d53 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -867,7 +867,7 @@ static Type *_julia_struct_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt,
     //  unsigned remainder = fsz % al;
     //  while (remainder--)
     //      Elements.push_back(getInt8Ty(ctxt));
-    //  lty = StructType::get(lty->getContext(), makeArrayRef(Elements));
+    //  lty = StructType::get(lty->getContext(),ArrayRef<Type*>(Elements));
     // }
     if (isboxed) *isboxed = true;
     return JuliaType::get_prjlvalue_ty(ctxt);
@@ -1354,7 +1354,7 @@ static void error_unless(jl_codectx_t &ctx, Value *cond, const Twine &msg)
     ctx.builder.SetInsertPoint(failBB);
     just_emit_error(ctx, prepare_call(jlerror_func), msg);
     ctx.builder.CreateUnreachable();
-    ctx.f->getBasicBlockList().push_back(passBB);
+    passBB->insertInto(ctx.f);
     ctx.builder.SetInsertPoint(passBB);
 }
 
@@ -1368,7 +1368,7 @@ static void raise_exception(jl_codectx_t &ctx, Value *exc,
         contBB = BasicBlock::Create(ctx.builder.getContext(), "after_throw", ctx.f);
     }
     else {
-        ctx.f->getBasicBlockList().push_back(contBB);
+        contBB->insertInto(ctx.f);
     }
     ctx.builder.SetInsertPoint(contBB);
 }
@@ -1739,7 +1739,7 @@ static void emit_typecheck(jl_codectx_t &ctx, const jl_cgval_t &x, jl_value_t *t
         just_emit_type_error(ctx, x, literal_pointer_val(ctx, type), msg);
         ctx.builder.CreateUnreachable();
 
-        ctx.f->getBasicBlockList().push_back(passBB);
+        passBB->insertInto(ctx.f);
         ctx.builder.SetInsertPoint(passBB);
     }
 }
@@ -1814,7 +1814,7 @@ static Value *emit_bounds_check(jl_codectx_t &ctx, const jl_cgval_t &ainfo, jl_v
                     i });
         }
         ctx.builder.CreateUnreachable();
-        ctx.f->getBasicBlockList().push_back(passBB);
+        passBB->insertInto(ctx.f);
         ctx.builder.SetInsertPoint(passBB);
     }
     return im1;
@@ -2451,11 +2451,11 @@ static bool emit_getfield_unknownidx(jl_codectx_t &ctx,
             assert((cast<ArrayType>(strct.V->getType())->getElementType() == ctx.types().T_prjlvalue) == isboxed);
             Value *idx = idx0();
             unsigned i = 0;
-            Value *fld = ctx.builder.CreateExtractValue(strct.V, makeArrayRef(i));
+            Value *fld = ctx.builder.CreateExtractValue(strct.V, ArrayRef<unsigned>(i));
             for (i = 1; i < nfields; i++) {
                 fld = ctx.builder.CreateSelect(
                         ctx.builder.CreateICmpEQ(idx, ConstantInt::get(idx->getType(), i)),
-                        ctx.builder.CreateExtractValue(strct.V, makeArrayRef(i)),
+                        ctx.builder.CreateExtractValue(strct.V, ArrayRef<unsigned>(i)),
                         fld);
             }
             setName(ctx.emission_context, fld, "getfield");
@@ -2723,7 +2723,7 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
                 unsigned i = 0;
                 for (; i < fsz / align; i++) {
                     unsigned fld = st_idx + i;
-                    Value *fldv = ctx.builder.CreateExtractValue(obj, makeArrayRef(fld));
+                    Value *fldv = ctx.builder.CreateExtractValue(obj, ArrayRef<unsigned>(fld));
                     Value *fldp = ctx.builder.CreateConstInBoundsGEP1_32(ET, lv, i);
                     ctx.builder.CreateAlignedStore(fldv, fldp, Align(align));
                 }
@@ -2732,14 +2732,14 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
                     Value *staddr = ctx.builder.CreateConstInBoundsGEP1_32(ET, lv, i);
                     staddr = ctx.builder.CreateBitCast(staddr, getInt8PtrTy(ctx.builder.getContext()));
                     for (; i < ptindex - st_idx; i++) {
-                        Value *fldv = ctx.builder.CreateExtractValue(obj, makeArrayRef(st_idx + i));
+                        Value *fldv = ctx.builder.CreateExtractValue(obj, ArrayRef<unsigned>(st_idx + i));
                         Value *fldp = ctx.builder.CreateConstInBoundsGEP1_32(getInt8Ty(ctx.builder.getContext()), staddr, i);
                         ctx.builder.CreateAlignedStore(fldv, fldp, Align(1));
                     }
                 }
                 setNameWithField(ctx.emission_context, lv, get_objname, jt, idx, Twine());
             }
-            Value *tindex0 = ctx.builder.CreateExtractValue(obj, makeArrayRef(ptindex));
+            Value *tindex0 = ctx.builder.CreateExtractValue(obj, ArrayRef<unsigned>(ptindex));
             Value *tindex = ctx.builder.CreateNUWAdd(ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 1), tindex0);
             setNameWithField(ctx.emission_context, tindex, get_objname, jt, idx, Twine(".tindex"));
             return mark_julia_slot(lv, jfty, tindex, ctx.tbaa().tbaa_stack);
@@ -2752,7 +2752,7 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
                 st_idx = convert_struct_offset(ctx, T, byte_offset);
             else
                 llvm_unreachable("encountered incompatible type for a struct");
-            fldv = ctx.builder.CreateExtractValue(obj, makeArrayRef(st_idx));
+            fldv = ctx.builder.CreateExtractValue(obj, ArrayRef<unsigned>(st_idx));
             setNameWithField(ctx.emission_context, fldv, get_objname, jt, idx, Twine());
         }
         if (maybe_null) {
@@ -3240,7 +3240,7 @@ static Function *mangleIntrinsic(IntrinsicInst *call) //mangling based on replac
 
     auto newfType = FunctionType::get(
             oldfType->getReturnType(),
-            makeArrayRef(argTys).slice(0, oldfType->getNumParams()),
+            ArrayRef<Type*>(argTys).slice(0, oldfType->getNumParams()),
             oldfType->isVarArg());
 
     // Accumulate an array of overloaded types for the given intrinsic
@@ -3460,7 +3460,7 @@ static void emit_cpointercheck(jl_codectx_t &ctx, const jl_cgval_t &x, const Twi
     just_emit_type_error(ctx, x, literal_pointer_val(ctx, (jl_value_t*)jl_pointer_type), msg);
     ctx.builder.CreateUnreachable();
 
-    ctx.f->getBasicBlockList().push_back(passBB);
+    passBB->insertInto(ctx.f);
     ctx.builder.SetInsertPoint(passBB);
 }
 
@@ -3496,7 +3496,7 @@ static Value *emit_new_bits(jl_codectx_t &ctx, Value *jt, Value *pval)
 // if ptr is NULL this emits a write barrier _back_
 static void emit_write_barrier(jl_codectx_t &ctx, Value *parent, Value *ptr)
 {
-    emit_write_barrier(ctx, parent, makeArrayRef(ptr));
+    emit_write_barrier(ctx, parent, ArrayRef<Value*>(ptr));
 }
 
 static void emit_write_barrier(jl_codectx_t &ctx, Value *parent, ArrayRef<Value*> ptrs)
@@ -3798,7 +3798,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                                 Value *fldp = ctx.builder.CreateConstInBoundsGEP1_32(ET, lv, i);
                                 jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack);
                                 Value *fldv = ai.decorateInst(ctx.builder.CreateAlignedLoad(ET, fldp, Align(al)));
-                                strct = ctx.builder.CreateInsertValue(strct, fldv, makeArrayRef(llvm_idx + i));
+                                strct = ctx.builder.CreateInsertValue(strct, fldv, ArrayRef<unsigned>(llvm_idx + i));
                             }
                             // emit remaining bytes up to tindex
                             if (i < ptindex - llvm_idx) {
@@ -3808,14 +3808,14 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                                     Value *fldp = ctx.builder.CreateConstInBoundsGEP1_32(getInt8Ty(ctx.builder.getContext()), staddr, i);
                                     jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack);
                                     Value *fldv = ai.decorateInst(ctx.builder.CreateAlignedLoad(getInt8Ty(ctx.builder.getContext()), fldp, Align(1)));
-                                    strct = ctx.builder.CreateInsertValue(strct, fldv, makeArrayRef(llvm_idx + i));
+                                    strct = ctx.builder.CreateInsertValue(strct, fldv, ArrayRef<unsigned>(llvm_idx + i));
                                 }
                             }
                         }
                         llvm_idx = ptindex;
                         fval = tindex;
                         if (jl_is_vecelement_type(ty))
-                            fval = ctx.builder.CreateInsertValue(strct, fval, makeArrayRef(llvm_idx));
+                            fval = ctx.builder.CreateInsertValue(strct, fval, ArrayRef<unsigned>(llvm_idx));
                     }
                     else {
                         Value *ptindex = emit_struct_gep(ctx, lt, strct, offs + fsz1);
@@ -3842,7 +3842,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                     else if (lt->isVectorTy())
                         strct = ctx.builder.CreateInsertElement(strct, fval, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), llvm_idx));
                     else if (lt->isAggregateType())
-                        strct = ctx.builder.CreateInsertValue(strct, fval, makeArrayRef(llvm_idx));
+                        strct = ctx.builder.CreateInsertValue(strct, fval, ArrayRef<unsigned>(llvm_idx));
                     else
                         assert(false);
                 }
@@ -3856,7 +3856,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                     int fsz = jl_field_size(sty, i) - 1;
                     unsigned llvm_idx = convert_struct_offset(ctx, cast<StructType>(lt), offs + fsz);
                     if (init_as_value)
-                        strct = ctx.builder.CreateInsertValue(strct, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0), makeArrayRef(llvm_idx));
+                        strct = ctx.builder.CreateInsertValue(strct, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0), ArrayRef<unsigned>(llvm_idx));
                     else {
                         jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_unionselbyte);
                         ai.decorateInst(ctx.builder.CreateAlignedStore(
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 50ebb4aa540d8..ca179817d4e1f 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -44,7 +44,6 @@
 
 // support
 #include <llvm/ADT/SmallBitVector.h>
-#include <llvm/ADT/Optional.h>
 #include <llvm/ADT/Statistic.h>
 #include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/FormattedStream.h>
@@ -164,7 +163,6 @@ typedef Instruction TerminatorInst;
 #endif
 
 #include "jitlayers.h"
-#include "llvm-codegen-shared.h"
 #include "processor.h"
 #include "julia_assert.h"
 
@@ -339,7 +337,7 @@ struct jl_typecache_t {
                            PointerType::get(T_jlgenericmemory, AddressSpace::Tracked),
                            // dimsize[ndims]
         };
-        T_jlarray = StructType::get(context, makeArrayRef(vaelts));
+        T_jlarray = StructType::get(context, ArrayRef<Type*>(vaelts));
         T_pjlarray = PointerType::get(T_jlarray, 0);
     }
 };
@@ -612,7 +610,7 @@ AttributeSet Attributes(LLVMContext &C, std::initializer_list<Attribute::AttrKin
         attrs[i] = Attribute::get(C, attrkinds.begin()[i]);
     for (size_t i = 0; i < extra.size(); i++)
         attrs[attrkinds.size() + i] = extra.begin()[i];
-    return AttributeSet::get(C, makeArrayRef(attrs));
+    return AttributeSet::get(C, ArrayRef<Attribute>(attrs));
 }
 
 static Type *get_pjlvalue(LLVMContext &C) { return JuliaType::get_pjlvalue_ty(C); }
@@ -636,9 +634,16 @@ static AttributeList get_func_attrs(LLVMContext &C)
 
 static AttributeList get_donotdelete_func_attrs(LLVMContext &C)
 {
-    AttributeSet FnAttrs = Attributes(C, {Attribute::InaccessibleMemOnly, Attribute::WillReturn, Attribute::NoUnwind});
+    AttrBuilder FnAttrs(C);
+#if JL_LLVM_VERSION >= 160000
+    FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
+#else
+    FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
+#endif
+    FnAttrs.addAttribute(Attribute::WillReturn);
+    FnAttrs.addAttribute(Attribute::NoUnwind);
     return AttributeList::get(C,
-            FnAttrs,
+            AttributeSet::get(C, FnAttrs),
             Attributes(C, {}),
             None);
 }
@@ -973,10 +978,19 @@ static const auto jlegalx_func = new JuliaFunction<TypeFnContextAndSizeT>{
     [](LLVMContext &C, Type *T_size) {
         Type *T = PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::Derived);
         return FunctionType::get(getInt32Ty(C), {T, T, T_size}, false); },
-    [](LLVMContext &C) { return AttributeList::get(C,
-            Attributes(C, {Attribute::ReadOnly, Attribute::NoUnwind, Attribute::ArgMemOnly}),
-            AttributeSet(),
-            None); },
+    [](LLVMContext &C) {
+        AttrBuilder FnAttrs(C);
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleOrArgMemOnly());
+#else
+        FnAttrs.addAttribute(Attribute::ReadOnly);
+        FnAttrs.addAttribute(Attribute::ArgMemOnly);
+#endif
+        FnAttrs.addAttribute(Attribute::NoUnwind);
+        return AttributeList::get(C,
+                AttributeSet::get(C, FnAttrs),
+                AttributeSet(),
+                None); },
 };
 static const auto jl_alloc_obj_func = new JuliaFunction<TypeFnContextAndSizeT>{
     "julia.gc_alloc_obj",
@@ -1024,8 +1038,17 @@ static const auto jl_typeof_func = new JuliaFunction<>{
         return FunctionType::get(T_prjlvalue,
                 {T_prjlvalue}, false);
     },
-    [](LLVMContext &C) { return AttributeList::get(C,
-            Attributes(C, {Attribute::ReadNone, Attribute::NoUnwind, Attribute::NoRecurse}),
+    [](LLVMContext &C) {
+        AttrBuilder FnAttrs(C);
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::none());
+#else
+        FnAttrs.addAttribute(Attribute::ReadNone);
+#endif
+        FnAttrs.addAttribute(Attribute::NoUnwind);
+        FnAttrs.addAttribute(Attribute::NoRecurse);
+        return AttributeList::get(C,
+            AttributeSet::get(C, FnAttrs),
             Attributes(C, {Attribute::NonNull}),
             None); },
 };
@@ -1034,10 +1057,20 @@ static const auto jl_write_barrier_func = new JuliaFunction<>{
     "julia.write_barrier",
     [](LLVMContext &C) { return FunctionType::get(getVoidTy(C),
             {JuliaType::get_prjlvalue_ty(C)}, true); },
-    [](LLVMContext &C) { return AttributeList::get(C,
-            Attributes(C, {Attribute::NoUnwind, Attribute::NoRecurse, Attribute::InaccessibleMemOnly}),
+    [](LLVMContext &C) {
+        AttrBuilder FnAttrs(C);
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
+#else
+        FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
+#endif
+        FnAttrs.addAttribute(Attribute::NoUnwind);
+        FnAttrs.addAttribute(Attribute::NoRecurse);
+        return AttributeList::get(C,
+            AttributeSet::get(C, FnAttrs),
             AttributeSet(),
-            {Attributes(C, {Attribute::ReadOnly})}); },
+            {Attributes(C, {Attribute::ReadOnly})});
+    },
 };
 
 static const auto jlisa_func = new JuliaFunction<>{
@@ -1072,7 +1105,7 @@ static const auto jlapplytype_func = new JuliaFunction<>{
     [](LLVMContext &C) {
         return AttributeList::get(C,
             AttributeSet(),
-            AttributeSet::get(C, makeArrayRef({Attribute::get(C, Attribute::NonNull),
+            AttributeSet::get(C, ArrayRef<Attribute>({Attribute::get(C, Attribute::NonNull),
                                                Attribute::getWithAlignment(C, Align(16))})),
             None);
     },
@@ -1101,8 +1134,17 @@ static const auto memcmp_func = new JuliaFunction<TypeFnContextAndSizeT>{
     XSTR(memcmp),
     [](LLVMContext &C, Type *T_size) { return FunctionType::get(getInt32Ty(C),
             {getInt8PtrTy(C), getInt8PtrTy(C), T_size}, false); },
-    [](LLVMContext &C) { return AttributeList::get(C,
-            Attributes(C, {Attribute::ReadOnly, Attribute::NoUnwind, Attribute::ArgMemOnly}),
+    [](LLVMContext &C) {
+        AttrBuilder FnAttrs(C);
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref));
+#else
+        FnAttrs.addAttribute(Attribute::ArgMemOnly);
+        FnAttrs.addAttribute(Attribute::ReadOnly);
+#endif
+        FnAttrs.addAttribute(Attribute::NoUnwind);
+        return AttributeList::get(C,
+            AttributeSet::get(C, FnAttrs),
             AttributeSet(),
             None); },
     // TODO: inferLibFuncAttributes(*memcmp_func, TLI);
@@ -1147,8 +1189,17 @@ static const auto jlfieldindex_func = new JuliaFunction<>{
         return FunctionType::get(getInt32Ty(C),
             {T_prjlvalue, T_prjlvalue, getInt32Ty(C)}, false);
     },
-    [](LLVMContext &C) { return AttributeList::get(C,
-            Attributes(C, {Attribute::NoUnwind, Attribute::ReadOnly, Attribute::WillReturn}),
+    [](LLVMContext &C) {
+        AttrBuilder FnAttrs(C);
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::readOnly());
+#else
+        FnAttrs.addAttribute(Attribute::ReadOnly);
+#endif
+        FnAttrs.addAttribute(Attribute::NoUnwind);
+        FnAttrs.addAttribute(Attribute::WillReturn);
+        return AttributeList::get(C,
+            AttributeSet::get(C, FnAttrs),
             AttributeSet(),
             None); }, // This function can error if the third argument is 1 so don't do that.
 };
@@ -1262,8 +1313,16 @@ static const auto pointer_from_objref_func = new JuliaFunction<>{
     "julia.pointer_from_objref",
     [](LLVMContext &C) { return FunctionType::get(JuliaType::get_pjlvalue_ty(C),
             {PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::Derived)}, false); },
-    [](LLVMContext &C) { return AttributeList::get(C,
-            Attributes(C, {Attribute::ReadNone, Attribute::NoUnwind}),
+    [](LLVMContext &C) {
+        AttrBuilder FnAttrs(C);
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::none());
+#else
+        FnAttrs.addAttribute(Attribute::ReadNone);
+#endif
+        FnAttrs.addAttribute(Attribute::NoUnwind);
+        return AttributeList::get(C,
+            AttributeSet::get(C, FnAttrs),
             Attributes(C, {Attribute::NonNull}),
             None); },
 };
@@ -3102,7 +3161,7 @@ static Value *emit_bits_compare(jl_codectx_t &ctx, jl_cgval_t arg1, jl_cgval_t a
                 nroots++;
             if ((gc_uses[nroots] = get_gc_root_for(ctx, arg2)))
                 nroots++;
-            OperandBundleDef OpBundle("jl_roots", makeArrayRef(gc_uses, nroots));
+            OperandBundleDef OpBundle("jl_roots", ArrayRef<Value*>(gc_uses, nroots));
             auto answer = ctx.builder.CreateCall(prepare_call(memcmp_func), {
                         ctx.builder.CreateBitCast(varg1, getInt8PtrTy(ctx.builder.getContext())),
                         ctx.builder.CreateBitCast(varg2, getInt8PtrTy(ctx.builder.getContext())),
@@ -4749,7 +4808,7 @@ static void undef_var_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *name)
     ctx.builder.CreateCall(prepare_call(jlundefvarerror_func),
         mark_callee_rooted(ctx, literal_pointer_val(ctx, (jl_value_t*)name)));
     ctx.builder.CreateUnreachable();
-    ctx.f->getBasicBlockList().push_back(ifok);
+    ifok->insertInto(ctx.f);
     ctx.builder.SetInsertPoint(ifok);
 }
 
@@ -4765,7 +4824,7 @@ static void emit_hasnofield_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *
                           {mark_callee_rooted(ctx, literal_pointer_val(ctx, (jl_value_t*)type)),
                            mark_callee_rooted(ctx, boxed(ctx, name))});
     ctx.builder.CreateUnreachable();
-    ctx.f->getBasicBlockList().push_back(ifok);
+    ifok->insertInto(ctx.f);
     ctx.builder.SetInsertPoint(ifok);
 }
 
@@ -4791,7 +4850,7 @@ static Value *global_binding_pointer(jl_codectx_t &ctx, jl_module_t *m, jl_sym_t
         // var not found. switch to delayed lookup.
         Constant *initnul = Constant::getNullValue(ctx.types().T_pjlvalue);
         GlobalVariable *bindinggv = new GlobalVariable(*ctx.f->getParent(), ctx.types().T_pjlvalue,
-                false, GlobalVariable::PrivateLinkage, initnul);
+                false, GlobalVariable::PrivateLinkage, initnul, "jl_binding_ptr"); // LLVM has bugs with nameless globals
         LoadInst *cachedval = ctx.builder.CreateAlignedLoad(ctx.types().T_pjlvalue, bindinggv, Align(sizeof(void*)));
         setName(ctx.emission_context, cachedval, jl_symbol_name(m->name) + StringRef(".") + jl_symbol_name(s) + ".cached");
         cachedval->setOrdering(AtomicOrdering::Unordered);
@@ -4801,7 +4860,7 @@ static Value *global_binding_pointer(jl_codectx_t &ctx, jl_module_t *m, jl_sym_t
         auto iscached = ctx.builder.CreateICmpNE(cachedval, initnul);
         setName(ctx.emission_context, iscached, "iscached");
         ctx.builder.CreateCondBr(iscached, have_val, not_found);
-        ctx.f->getBasicBlockList().push_back(not_found);
+        not_found->insertInto(ctx.f);
         ctx.builder.SetInsertPoint(not_found);
         Value *bval = ctx.builder.CreateCall(prepare_call(assign ? jlgetbindingwrorerror_func : jlgetbindingorerror_func),
                 { literal_pointer_val(ctx, (jl_value_t*)m),
@@ -4809,7 +4868,7 @@ static Value *global_binding_pointer(jl_codectx_t &ctx, jl_module_t *m, jl_sym_t
         setName(ctx.emission_context, bval, jl_symbol_name(m->name) + StringRef(".") + jl_symbol_name(s) + ".found");
         ctx.builder.CreateAlignedStore(bval, bindinggv, Align(sizeof(void*)))->setOrdering(AtomicOrdering::Release);
         ctx.builder.CreateBr(have_val);
-        ctx.f->getBasicBlockList().push_back(have_val);
+        have_val->insertInto(ctx.f);
         ctx.builder.SetInsertPoint(have_val);
         PHINode *p = ctx.builder.CreatePHI(ctx.types().T_pjlvalue, 2);
         p->addIncoming(cachedval, currentbb);
@@ -5711,7 +5770,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
                 Value *mdargs[] = { name, literal_pointer_val(ctx, (jl_value_t*)mod), bp, literal_pointer_val(ctx, bnd) };
                 jl_cgval_t gf = mark_julia_type(
                         ctx,
-                        ctx.builder.CreateCall(prepare_call(jlgenericfunction_func), makeArrayRef(mdargs)),
+                        ctx.builder.CreateCall(prepare_call(jlgenericfunction_func), ArrayRef<Value*>(mdargs)),
                         true,
                         jl_function_type);
                 return gf;
@@ -5730,7 +5789,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
         };
         jl_cgval_t meth = mark_julia_type(
             ctx,
-            ctx.builder.CreateCall(prepare_call(jlmethod_func), makeArrayRef(mdargs)),
+            ctx.builder.CreateCall(prepare_call(jlmethod_func), ArrayRef<Value*>(mdargs)),
             true,
             jl_method_type);
         return meth;
@@ -7109,7 +7168,7 @@ static jl_returninfo_t get_specsig_function(jl_codectx_t &ctx, Module *M, Value
             fsig.push_back(AT->getPointerTo());
             argnames.push_back("union_bytes_return");
             Type *pair[] = { ctx.types().T_prjlvalue, getInt8Ty(ctx.builder.getContext()) };
-            rt = StructType::get(ctx.builder.getContext(), makeArrayRef(pair));
+            rt = StructType::get(ctx.builder.getContext(), ArrayRef<Type*>(pair));
         }
         else if (allunbox) {
             props.cc = jl_returninfo_t::Ghosts;
@@ -8646,9 +8705,7 @@ static jl_llvm_functions_t
                 // Can't use `llvm::SplitCriticalEdge` here because
                 // we may have invalid phi nodes in the destination.
                 BasicBlock *NewBB = BasicBlock::Create(terminator->getContext(),
-                   FromBB->getName() + "." + PhiBB->getName() + "_crit_edge");
-                Function::iterator FBBI = FromBB->getIterator();
-                ctx.f->getBasicBlockList().insert(++FBBI, NewBB); // insert after existing block
+                   FromBB->getName() + "." + PhiBB->getName() + "_crit_edge", FromBB->getParent(), FromBB->getNextNode()); // insert after existing block
                 terminator->replaceSuccessorWith(PhiBB, NewBB);
                 DebugLoc Loc = terminator->getDebugLoc();
                 terminator = BranchInst::Create(PhiBB);
@@ -9333,8 +9390,12 @@ extern "C" void jl_init_llvm(void)
     initializeAnalysis(Registry);
     initializeTransformUtils(Registry);
     initializeInstCombine(Registry);
+#if JL_LLVM_VERSION >= 160000
+    // TODO
+#else
     initializeAggressiveInstCombine(Registry);
     initializeInstrumentation(Registry);
+#endif
     initializeTarget(Registry);
 #ifdef USE_POLLY
     polly::initializePollyPasses(Registry);
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index 0c0196e09b034..b4d493ee80800 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -1414,7 +1414,7 @@ static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **arg
     case fma_float: {
         assert(y->getType() == x->getType());
         assert(z->getType() == y->getType());
-        FunctionCallee fmaintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::fma, makeArrayRef(t));
+        FunctionCallee fmaintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::fma, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(fmaintr, {x, y, z});
     }
     case muladd_float: {
@@ -1444,7 +1444,7 @@ static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **arg
                 (f == checked_smul_int ?
                  Intrinsic::smul_with_overflow :
                  Intrinsic::umul_with_overflow)))));
-        FunctionCallee intr = Intrinsic::getDeclaration(jl_Module, intr_id, makeArrayRef(t));
+        FunctionCallee intr = Intrinsic::getDeclaration(jl_Module, intr_id, ArrayRef<Type*>(t));
         Value *res = ctx.builder.CreateCall(intr, {x, y});
         Value *val = ctx.builder.CreateExtractValue(res, ArrayRef<unsigned>(0));
         setName(ctx.emission_context, val, "checked");
@@ -1564,30 +1564,30 @@ static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **arg
         }
     }
     case bswap_int: {
-        FunctionCallee bswapintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::bswap, makeArrayRef(t));
-        return ctx.builder.CreateCall(bswapintr, x);
+        FunctionCallee bswapintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::bswap, ArrayRef<Type*>(t)); //TODO: Move to deduction guides
+        return ctx.builder.CreateCall(bswapintr, x);                                                           // when we drop LLVM 15
     }
     case ctpop_int: {
-        FunctionCallee ctpopintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::ctpop, makeArrayRef(t));
+        FunctionCallee ctpopintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::ctpop, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(ctpopintr, x);
     }
     case ctlz_int: {
-        FunctionCallee ctlz = Intrinsic::getDeclaration(jl_Module, Intrinsic::ctlz, makeArrayRef(t));
+        FunctionCallee ctlz = Intrinsic::getDeclaration(jl_Module, Intrinsic::ctlz, ArrayRef<Type*>(t));
         y = ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 0);
         return ctx.builder.CreateCall(ctlz, {x, y});
     }
     case cttz_int: {
-        FunctionCallee cttz = Intrinsic::getDeclaration(jl_Module, Intrinsic::cttz, makeArrayRef(t));
+        FunctionCallee cttz = Intrinsic::getDeclaration(jl_Module, Intrinsic::cttz, ArrayRef<Type*>(t));
         y = ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 0);
         return ctx.builder.CreateCall(cttz, {x, y});
     }
 
     case abs_float: {
-        FunctionCallee absintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::fabs, makeArrayRef(t));
+        FunctionCallee absintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::fabs, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(absintr, x);
     }
     case copysign_float: {
-        FunctionCallee copyintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::copysign, makeArrayRef(t));
+        FunctionCallee copyintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::copysign, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(copyintr, {x, y});
     }
     case flipsign_int: {
@@ -1606,27 +1606,27 @@ static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **arg
         return ctx.builder.CreateXor(ctx.builder.CreateAdd(x, tmp), tmp);
     }
     case ceil_llvm: {
-        FunctionCallee ceilintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::ceil, makeArrayRef(t));
+        FunctionCallee ceilintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::ceil, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(ceilintr, x);
     }
     case floor_llvm: {
-        FunctionCallee floorintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::floor, makeArrayRef(t));
+        FunctionCallee floorintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::floor, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(floorintr, x);
     }
     case trunc_llvm: {
-        FunctionCallee truncintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::trunc, makeArrayRef(t));
+        FunctionCallee truncintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::trunc, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(truncintr, x);
     }
     case rint_llvm: {
-        FunctionCallee rintintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::rint, makeArrayRef(t));
+        FunctionCallee rintintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::rint, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(rintintr, x);
     }
     case sqrt_llvm: {
-        FunctionCallee sqrtintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::sqrt, makeArrayRef(t));
+        FunctionCallee sqrtintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::sqrt, ArrayRef<Type*>(t));
         return ctx.builder.CreateCall(sqrtintr, x);
     }
     case sqrt_llvm_fast: {
-        FunctionCallee sqrtintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::sqrt, makeArrayRef(t));
+        FunctionCallee sqrtintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::sqrt, ArrayRef<Type*>(t));
         return math_builder(ctx, true)().CreateCall(sqrtintr, x);
     }
 
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index ae385e17c4fb9..e0b9b0f8e2e69 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -34,7 +34,6 @@
 
 using namespace llvm;
 
-#include "llvm-codegen-shared.h"
 #include "jitlayers.h"
 #include "julia_assert.h"
 #include "processor.h"
@@ -861,8 +860,11 @@ class JLDebuginfoPlugin : public ObjectLinkingLayer::Plugin {
         PendingObjs.erase(&MR);
         return Error::success();
     }
-
+#if JL_LLVM_VERSION >= 160000
+    Error notifyRemovingResources(JITDylib &JD, orc::ResourceKey K) override
+#else
     Error notifyRemovingResources(ResourceKey K) override
+#endif
     {
         std::lock_guard<std::mutex> lock(PluginMutex);
         RegisteredObjs.erase(K);
@@ -870,7 +872,11 @@ class JLDebuginfoPlugin : public ObjectLinkingLayer::Plugin {
         return Error::success();
     }
 
+#if JL_LLVM_VERSION >= 160000
+    void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey, ResourceKey SrcKey) override
+#else
     void notifyTransferringResources(ResourceKey DstKey, ResourceKey SrcKey) override
+#endif
     {
         std::lock_guard<std::mutex> lock(PluginMutex);
         auto SrcIt = RegisteredObjs.find(SrcKey);
@@ -929,11 +935,21 @@ class JLMemoryUsagePlugin : public ObjectLinkingLayer::Plugin {
     Error notifyFailed(orc::MaterializationResponsibility &MR) override {
         return Error::success();
     }
-    Error notifyRemovingResources(orc::ResourceKey K) override {
+#if JL_LLVM_VERSION >= 160000
+    Error notifyRemovingResources(JITDylib &JD, orc::ResourceKey K) override
+#else
+    Error notifyRemovingResources(orc::ResourceKey K) override
+#endif
+    {
         return Error::success();
     }
+#if JL_LLVM_VERSION >= 160000
+    void notifyTransferringResources(JITDylib &JD, orc::ResourceKey DstKey,
+                                     orc::ResourceKey SrcKey) override {}
+#else
     void notifyTransferringResources(orc::ResourceKey DstKey,
                                      orc::ResourceKey SrcKey) override {}
+#endif
 
     void modifyPassConfig(orc::MaterializationResponsibility &,
                           jitlink::LinkGraph &,
@@ -950,7 +966,11 @@ class JLMemoryUsagePlugin : public ObjectLinkingLayer::Plugin {
                 for (auto block : section.blocks()) {
                     secsize += block->getSize();
                 }
+#if JL_LLVM_VERSION >= 160000
+                if ((section.getMemProt() & orc::MemProt::Exec) == orc::MemProt::None) {
+#else
                 if ((section.getMemProt() & jitlink::MemProt::Exec) == jitlink::MemProt::None) {
+#endif
                     data_size += secsize;
                 } else {
                     code_size += secsize;
@@ -984,8 +1004,10 @@ class JLMemoryUsagePlugin : public ObjectLinkingLayer::Plugin {
 std::unique_ptr<jitlink::JITLinkMemoryManager> createJITLinkMemoryManager() {
 #if JL_LLVM_VERSION < 150000
     return cantFail(jitlink::InProcessMemoryManager::Create());
-#else
+#elif JL_LLVM_VERSION < 160000
     return cantFail(orc::MapperJITLinkMemoryManager::CreateWithMapper<orc::InProcessMemoryMapper>());
+#else
+    return cantFail(orc::MapperJITLinkMemoryManager::CreateWithMapper<orc::InProcessMemoryMapper>(/*Reservation Granularity*/ 16 * 1024 * 1024));
 #endif
 }
 
@@ -1032,6 +1054,13 @@ class ForwardingMemoryManager : public RuntimeDyld::MemoryManager {
                                      bool IsReadOnly) override {
         return MemMgr->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly);
     }
+#if JL_LLVM_VERSION >= 160000
+    virtual void reserveAllocationSpace(uintptr_t CodeSize, Align CodeAlign,
+                                        uintptr_t RODataSize, Align RODataAlign,
+                                        uintptr_t RWDataSize, Align RWDataAlign) override {
+        return MemMgr->reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign, RWDataSize, RWDataAlign);
+    }
+#else
     virtual void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
                                         uintptr_t RODataSize,
                                         uint32_t RODataAlign,
@@ -1039,6 +1068,7 @@ class ForwardingMemoryManager : public RuntimeDyld::MemoryManager {
                                         uint32_t RWDataAlign) override {
         return MemMgr->reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign, RWDataSize, RWDataAlign);
     }
+#endif
     virtual bool needsToReserveAllocationSpace() override {
         return MemMgr->needsToReserveAllocationSpace();
     }
@@ -1169,6 +1199,8 @@ namespace {
 #else
             None;
 #endif
+        if (TheTriple.isAArch64())
+            codemodel = CodeModel::Small;
         auto optlevel = CodeGenOptLevelFor(jl_options.opt_level);
         auto TM = TheTarget->createTargetMachine(
                 TheTriple.getTriple(), TheCPU, FeaturesStr,
@@ -1180,11 +1212,7 @@ namespace {
                 );
         assert(TM && "Failed to select target machine -"
                      " Is the LLVM backend for this CPU enabled?");
-        if (!TheTriple.isARM() && !TheTriple.isPPC64()) {
-            // FastISel seems to be buggy for ARM. Ref #13321
-            if (jl_options.opt_level < 2)
-                TM->setFastISel(true);
-        }
+        fixupTM(*TM);
         return std::unique_ptr<TargetMachine>(TM);
     }
 } // namespace
@@ -1210,7 +1238,9 @@ namespace {
             : JTMB(createJTMBFromTM(TM, optlevel)) {}
 
         std::unique_ptr<TargetMachine> operator()() JL_NOTSAFEPOINT {
-            return cantFail(JTMB.createTargetMachine());
+            auto TM = cantFail(JTMB.createTargetMachine());
+            fixupTM(*TM);
+            return TM;
         }
     };
 
@@ -1222,7 +1252,9 @@ namespace {
             : JTMB(createJTMBFromTM(TM, optlevel)), O(getOptLevel(optlevel)), printers(printers) {}
 
         auto operator()() JL_NOTSAFEPOINT {
-            auto NPM = std::make_unique<NewPM>(cantFail(JTMB.createTargetMachine()), O);
+            auto TM = cantFail(JTMB.createTargetMachine());
+            fixupTM(*TM);
+            auto NPM = std::make_unique<NewPM>(std::move(TM), O);
             // TODO this needs to be locked, as different resource pools may add to the printer vector at the same time
             printers.push_back([NPM = NPM.get()]() JL_NOTSAFEPOINT {
                 NPM->printTimers();
@@ -1609,6 +1641,16 @@ void optimizeDLSyms(Module &M) {
     JuliaOJIT::DLSymOptimizer(true)(M);
 }
 
+void fixupTM(TargetMachine &TM){
+    auto TheTriple = TM.getTargetTriple();
+    if (jl_options.opt_level < 2) {
+        if (!TheTriple.isARM() && !TheTriple.isPPC64() && !TheTriple.isAArch64())
+            TM.setFastISel(true);
+        else    // FastISel seems to be buggy Ref #13321
+            TM.setFastISel(false);
+    }
+}
+
 llvm::DataLayout jl_create_datalayout(TargetMachine &TM) {
     // Mark our address spaces as non-integral
     auto jl_data_layout = TM.createDataLayout();
@@ -1865,7 +1907,7 @@ Error JuliaOJIT::addObjectFile(orc::JITDylib &JD, std::unique_ptr<MemoryBuffer>
 JL_JITSymbol JuliaOJIT::findSymbol(StringRef Name, bool ExportedSymbolsOnly)
 {
     orc::JITDylib* SearchOrders[3] = {&JD, &GlobalJD, &ExternalJD};
-    ArrayRef<orc::JITDylib*> SearchOrder = makeArrayRef(&SearchOrders[0], ExportedSymbolsOnly ? 3 : 1);
+    ArrayRef<orc::JITDylib*> SearchOrder = ArrayRef<orc::JITDylib*>(&SearchOrders[0], ExportedSymbolsOnly ? 3 : 1);
     auto Sym = ES.lookup(SearchOrder, Name);
     if (Sym)
         return *Sym;
@@ -1880,7 +1922,7 @@ JL_JITSymbol JuliaOJIT::findUnmangledSymbol(StringRef Name)
 Expected<JITEvaluatedSymbol> JuliaOJIT::findExternalJDSymbol(StringRef Name, bool ExternalJDOnly)
 {
     orc::JITDylib* SearchOrders[3] = {&ExternalJD, &GlobalJD, &JD};
-    ArrayRef<orc::JITDylib*> SearchOrder = makeArrayRef(&SearchOrders[0], ExternalJDOnly ? 1 : 3);
+    ArrayRef<orc::JITDylib*> SearchOrder = ArrayRef<orc::JITDylib*>(&SearchOrders[0], ExternalJDOnly ? 1 : 3);
     auto Sym = ES.lookup(SearchOrder, getMangledName(Name));
     return Sym;
 }
@@ -2136,7 +2178,7 @@ void jl_merge_module(orc::ThreadSafeModule &destTSM, orc::ThreadSafeModule srcTS
 
 std::unique_ptr<TargetMachine> JuliaOJIT::cloneTargetMachine() const
 {
-    return std::unique_ptr<TargetMachine>(getTarget()
+    auto NewTM = std::unique_ptr<TargetMachine>(getTarget()
         .createTargetMachine(
             getTargetTriple().str(),
             getTargetCPU(),
@@ -2145,6 +2187,8 @@ std::unique_ptr<TargetMachine> JuliaOJIT::cloneTargetMachine() const
             TM->getRelocationModel(),
             TM->getCodeModel(),
             TM->getOptLevel()));
+    fixupTM(*NewTM);
+    return NewTM;
 }
 
 const Triple& JuliaOJIT::getTargetTriple() const {
diff --git a/src/jitlayers.h b/src/jitlayers.h
index a120df8148502..016f97b92140b 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -22,10 +22,11 @@
 #include "julia.h"
 #include "julia_internal.h"
 #include "platform.h"
-
+#include "llvm-codegen-shared.h"
 #include <stack>
 #include <queue>
 
+
 // As of LLVM 13, there are two runtime JIT linker implementations, the older
 // RuntimeDyld (used via orc::RTDyldObjectLinkingLayer) and the newer JITLink
 // (used via orc::ObjectLinkingLayer).
@@ -98,7 +99,9 @@ struct OptimizationOptions {
 
 struct NewPM {
     std::unique_ptr<TargetMachine> TM;
+#if JL_LLVM_VERSION < 160000
     StandardInstrumentations SI;
+#endif
     std::unique_ptr<PassInstrumentationCallbacks> PIC;
     PassBuilder PB;
     ModulePassManager MPM;
@@ -386,7 +389,7 @@ class JuliaOJIT {
             }
             private:
             ResourcePool &pool;
-            llvm::Optional<ResourceT> resource;
+            Optional<ResourceT> resource;
         };
 
         OwningResource operator*() JL_NOTSAFEPOINT {
@@ -566,6 +569,7 @@ Module &jl_codegen_params_t::shared_module() JL_NOTSAFEPOINT {
     }
     return *_shared_module;
 }
+void fixupTM(TargetMachine &TM) JL_NOTSAFEPOINT;
 
 void optimizeDLSyms(Module &M);
 
diff --git a/src/llvm-alloc-opt.cpp b/src/llvm-alloc-opt.cpp
index 474dfbec08c91..619fa03ef58dd 100644
--- a/src/llvm-alloc-opt.cpp
+++ b/src/llvm-alloc-opt.cpp
@@ -568,7 +568,7 @@ void Optimizer::replaceIntrinsicUseWith(IntrinsicInst *call, Intrinsic::ID ID,
     auto oldfType = call->getFunctionType();
     auto newfType = FunctionType::get(
             oldfType->getReturnType(),
-            makeArrayRef(argTys).slice(0, oldfType->getNumParams()),
+            ArrayRef<Type*>(argTys).slice(0, oldfType->getNumParams()),
             oldfType->isVarArg());
 
     // Accumulate an array of overloaded types for the given intrinsic
diff --git a/src/llvm-codegen-shared.h b/src/llvm-codegen-shared.h
index abe4b12cc6d5c..b78a3bea9c0ef 100644
--- a/src/llvm-codegen-shared.h
+++ b/src/llvm-codegen-shared.h
@@ -8,11 +8,30 @@
 #include <llvm/IR/DebugLoc.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/MDBuilder.h>
+
+#if JL_LLVM_VERSION >= 160000
+#include <llvm/Support/ModRef.h>
+#endif
+
 #include "julia.h"
 
 #define STR(csym)           #csym
 #define XSTR(csym)          STR(csym)
 
+#if JL_LLVM_VERSION >= 160000
+
+#include <optional>
+
+template<typename T>
+using Optional = std::optional<T>;
+static constexpr std::nullopt_t None = std::nullopt;
+
+#else
+
+#include <llvm/ADT/Optional.h>
+
+#endif
+
 enum AddressSpace {
     Generic = 0,
     Tracked = 10,
@@ -159,9 +178,11 @@ static inline llvm::MDNode *get_tbaa_const(llvm::LLVMContext &ctxt) {
 
 static inline llvm::Instruction *tbaa_decorate(llvm::MDNode *md, llvm::Instruction *inst)
 {
+    using namespace llvm;
     inst->setMetadata(llvm::LLVMContext::MD_tbaa, md);
-    if (llvm::isa<llvm::LoadInst>(inst) && md && md == get_tbaa_const(md->getContext()))
-        inst->setMetadata(llvm::LLVMContext::MD_invariant_load, llvm::MDNode::get(md->getContext(), llvm::None));
+    if (llvm::isa<llvm::LoadInst>(inst) && md && md == get_tbaa_const(md->getContext())) {
+        inst->setMetadata(llvm::LLVMContext::MD_invariant_load, llvm::MDNode::get(md->getContext(), None));
+    }
     return inst;
 }
 
@@ -251,7 +272,11 @@ static inline void emit_gc_safepoint(llvm::IRBuilder<> &builder, llvm::Type *T_s
             auto T_psize = T_size->getPointerTo();
             FunctionType *FT = FunctionType::get(Type::getVoidTy(C), {T_psize}, false);
             F = Function::Create(FT, Function::ExternalLinkage, "julia.safepoint", M);
+#if JL_LLVM_VERSION >= 160000
+            F->setMemoryEffects(MemoryEffects::inaccessibleOrArgMemOnly());
+#else
             F->addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
+#endif
         }
         builder.CreateCall(F, {signal_page});
     }
diff --git a/src/llvm-cpufeatures.cpp b/src/llvm-cpufeatures.cpp
index 02a449cf3b3d5..033a43720c96d 100644
--- a/src/llvm-cpufeatures.cpp
+++ b/src/llvm-cpufeatures.cpp
@@ -43,14 +43,14 @@ Optional<bool> always_have_fma(Function &intr, const Triple &TT) JL_NOTSAFEPOINT
         auto typ = intr_name.substr(strlen("julia.cpu.have_fma."));
         return typ == "f32" || typ == "f64";
     } else {
-        return {};
+        return None;
     }
 }
 
 static bool have_fma(Function &intr, Function &caller, const Triple &TT) JL_NOTSAFEPOINT {
     auto unconditional = always_have_fma(intr, TT);
-    if (unconditional.hasValue())
-        return unconditional.getValue();
+    if (unconditional)
+        return *unconditional;
 
     auto intr_name = intr.getName();
     auto typ = intr_name.substr(strlen("julia.cpu.have_fma."));
diff --git a/src/llvm-julia-licm.cpp b/src/llvm-julia-licm.cpp
index 082398ef7a5d5..e76beaa3df44f 100644
--- a/src/llvm-julia-licm.cpp
+++ b/src/llvm-julia-licm.cpp
@@ -343,7 +343,11 @@ struct JuliaLICM : public JuliaPassContext {
             }
         }
         if (changed && SE) {
+#if JL_LLVM_VERSION >= 160000
+            SE->forgetLoopDispositions();
+#else
             SE->forgetLoopDispositions(L);
+#endif
         }
 #ifdef JL_VERIFY_PASSES
         assert(!verifyLLVMIR(*L));
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index fcca6841989ec..873c34e5a07b7 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -600,7 +600,7 @@ Value *LateLowerGCFrame::MaybeExtractScalar(State &S, std::pair<Value*,int> ValE
     }
     else if (ValExpr.second != -1) {
         auto Tracked = TrackCompositeType(V->getType());
-        auto Idxs = makeArrayRef(Tracked[ValExpr.second]);
+        auto Idxs = ArrayRef<unsigned>(Tracked[ValExpr.second]);
         auto IdxsNotVec = Idxs.slice(0, Idxs.size() - 1);
         Type *FinalT = ExtractValueInst::getIndexedType(V->getType(), IdxsNotVec);
         bool IsVector = isa<VectorType>(FinalT);
@@ -908,7 +908,7 @@ SmallVector<int, 0> LateLowerGCFrame::NumberAllBase(State &S, Value *CurrentV) {
         auto Idxs = IVI->getIndices();
         unsigned j = 0;
         for (unsigned i = 0; i < Tracked.size(); ++i) {
-            auto Elem = makeArrayRef(Tracked[i]);
+            auto Elem = ArrayRef<unsigned>(Tracked[i]);
             if (Elem.size() < Idxs.size())
                 continue;
             if (Idxs.equals(Elem.slice(0, Idxs.size()))) // Tracked.startswith(Idxs)
@@ -921,7 +921,7 @@ SmallVector<int, 0> LateLowerGCFrame::NumberAllBase(State &S, Value *CurrentV) {
         assert(Tracked.size() == BaseNumbers.size());
         auto Idxs = EVI->getIndices();
         for (unsigned i = 0; i < Tracked.size(); ++i) {
-            auto Elem = makeArrayRef(Tracked[i]);
+            auto Elem = ArrayRef<unsigned>(Tracked[i]);
             if (Elem.size() < Idxs.size())
                 continue;
             if (Idxs.equals(Elem.slice(0, Idxs.size()))) // Tracked.startswith(Idxs)
@@ -1624,20 +1624,38 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                         callee->getName() == "memcmp") {
                         continue;
                     }
+#if JL_LLVM_VERSION >= 160000
+                    if (callee->getMemoryEffects().onlyReadsMemory() ||
+                        callee->getMemoryEffects().onlyAccessesArgPointees()) {
+                        continue;
+                    }
+#else
                     if (callee->hasFnAttribute(Attribute::ReadNone) ||
                         callee->hasFnAttribute(Attribute::ReadOnly) ||
                         callee->hasFnAttribute(Attribute::ArgMemOnly)) {
                         continue;
                     }
+#endif
                     if (MemTransferInst *MI = dyn_cast<MemTransferInst>(CI)) {
                         MaybeTrackDst(S, MI);
                     }
                 }
-                if (isa<IntrinsicInst>(CI) || CI->hasFnAttr(Attribute::ArgMemOnly) ||
-                    CI->hasFnAttr(Attribute::ReadNone) || CI->hasFnAttr(Attribute::ReadOnly)) {
+#if JL_LLVM_VERSION >= 160000
+                if (isa<IntrinsicInst>(CI) ||
+                    CI->getMemoryEffects().onlyAccessesArgPointees() ||
+                    CI->getMemoryEffects().onlyReadsMemory()) {
                     // Intrinsics are never safepoints.
                     continue;
                 }
+#else
+                if (isa<IntrinsicInst>(CI) ||
+                    CI->hasFnAttr(Attribute::ArgMemOnly) ||
+                    CI->hasFnAttr(Attribute::ReadNone)   ||
+                    CI->hasFnAttr(Attribute::ReadOnly)) {
+                    // Intrinsics are never safepoints.
+                    continue;
+                }
+#endif
                 SmallVector<int, 0> CalleeRoots;
                 for (Use &U : CI->args()) {
                     // Find all callee rooted arguments.
@@ -1843,7 +1861,7 @@ SmallVector<Value*, 0> ExtractTrackedValues(Value *Src, Type *STy, bool isptr, I
         return false;
     };
     for (unsigned i = 0; i < Tracked.size(); ++i) {
-        auto Idxs = makeArrayRef(Tracked[i]);
+        auto Idxs = ArrayRef<unsigned>(Tracked[i]);
         if (ignore_field(Idxs))
             continue;
         Value *Elem = ExtractScalar(Src, STy, isptr, Idxs, irbuilder);
@@ -2760,7 +2778,7 @@ void LateLowerGCFrame::PlaceRootsAndUpdateCalls(SmallVectorImpl<int> &Colors, St
                     assert(Elem->getContext().supportsTypedPointers());
                     Elem = new BitCastInst(Elem, T_prjlvalue, "", SI);
                 }
-                //auto Idxs = makeArrayRef(Tracked[i]);
+                //auto Idxs = ArrayRef<unsigned>(Tracked[i]);
                 //Value *Elem = ExtractScalar(Base, true, Idxs, SI);
                 Value *shadowStore = new StoreInst(Elem, slotAddress, SI);
                 (void)shadowStore;
diff --git a/src/llvm-multiversioning.cpp b/src/llvm-multiversioning.cpp
index 4ad278a3be75c..83968cf344e72 100644
--- a/src/llvm-multiversioning.cpp
+++ b/src/llvm-multiversioning.cpp
@@ -103,7 +103,8 @@ static uint32_t collect_func_info(Function &F, const Triple &TT, bool &has_vecca
                         if (name.startswith("julia.cpu.have_fma.")) {
                             // for some platforms we know they always do (or don't) support
                             // FMA. in those cases we don't need to clone the function.
-                            if (!always_have_fma(*callee, TT).hasValue())
+                            // always_have_fma returns an optional<bool>
+                            if (!always_have_fma(*callee, TT))
                                 flag |= JL_TARGET_CLONE_CPU;
                         } else {
                             flag |= JL_TARGET_CLONE_CPU;
@@ -690,7 +691,7 @@ void CloneCtx::rewrite_alias(GlobalAlias *alias, Function *F)
     SmallVector<Value *, 0> Args;
     for (auto &arg : trampoline->args())
         Args.push_back(&arg);
-    auto call = irbuilder.CreateCall(F->getFunctionType(), ptr, makeArrayRef(Args));
+    auto call = irbuilder.CreateCall(F->getFunctionType(), ptr, ArrayRef<Value *>(Args));
     if (F->isVarArg()) {
         assert(!TT.isARM() && !TT.isPPC() && "musttail not supported on ARM/PPC!");
         call->setTailCallKind(CallInst::TCK_MustTail);
diff --git a/src/llvm-pass-helpers.cpp b/src/llvm-pass-helpers.cpp
index 59bfae3f38b8e..589b47148fa83 100644
--- a/src/llvm-pass-helpers.cpp
+++ b/src/llvm-pass-helpers.cpp
@@ -218,7 +218,11 @@ namespace jl_intrinsics {
                     false),
                 Function::ExternalLinkage,
                 QUEUE_GC_ROOT_NAME);
+#if JL_LLVM_VERSION >= 160000
+            intrinsic->setMemoryEffects(MemoryEffects::inaccessibleOrArgMemOnly());
+#else
             intrinsic->addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
+#endif
             return intrinsic;
         });
 
@@ -234,7 +238,11 @@ namespace jl_intrinsics {
                     false),
                 Function::ExternalLinkage,
                 SAFEPOINT_NAME);
+#if JL_LLVM_VERSION >= 160000
+            intrinsic->setMemoryEffects(MemoryEffects::inaccessibleOrArgMemOnly());
+#else
             intrinsic->addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
+#endif
             return intrinsic;
         });
 }
@@ -291,7 +299,11 @@ namespace jl_well_known {
                     false),
                 Function::ExternalLinkage,
                 GC_QUEUE_ROOT_NAME);
+#if JL_LLVM_VERSION >= 160000
+            func->setMemoryEffects(MemoryEffects::inaccessibleOrArgMemOnly());
+#else
             func->addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
+#endif
             return func;
         });
 
diff --git a/src/llvm-ptls.cpp b/src/llvm-ptls.cpp
index 050750fbf10f5..d2650d6875cd4 100644
--- a/src/llvm-ptls.cpp
+++ b/src/llvm-ptls.cpp
@@ -63,7 +63,11 @@ struct LowerPTLS {
 
 void LowerPTLS::set_pgcstack_attrs(CallInst *pgcstack) const
 {
+#if JL_LLVM_VERSION >= 160000
+    pgcstack->addFnAttr(Attribute::getWithMemoryEffects(pgcstack->getContext(), MemoryEffects::none()));
+#else
     addFnAttr(pgcstack, Attribute::ReadNone);
+#endif
     addFnAttr(pgcstack, Attribute::NoUnwind);
 }
 
diff --git a/src/llvm-remove-addrspaces.cpp b/src/llvm-remove-addrspaces.cpp
index 4b25821f43efb..e291e47b59b0e 100644
--- a/src/llvm-remove-addrspaces.cpp
+++ b/src/llvm-remove-addrspaces.cpp
@@ -423,7 +423,7 @@ bool removeAddrspaces(Module &M, AddrspaceRemapFunction ASRemapper)
     for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE;) {
         Function *F = &*FI++;
         if (auto Remangled = Intrinsic::remangleIntrinsicFunction(F)) {
-            F->replaceAllUsesWith(Remangled.getValue());
+            F->replaceAllUsesWith(*Remangled);
             F->eraseFromParent();
         }
     }
diff --git a/src/llvm-simdloop.cpp b/src/llvm-simdloop.cpp
index c4981c33f088d..f29802b438e1e 100644
--- a/src/llvm-simdloop.cpp
+++ b/src/llvm-simdloop.cpp
@@ -231,7 +231,11 @@ static bool processLoop(Loop &L, OptimizationRemarkEmitter &ORE, ScalarEvolution
         }
 
         if (SE)
+#if JL_LLVM_VERSION >= 160000
+            SE->forgetLoopDispositions();
+#else
             SE->forgetLoopDispositions(&L);
+#endif
     }
 
 #ifdef JL_VERIFY_PASSES
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index a68ed979492e7..e73b49710bdc3 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -92,7 +92,6 @@
 #include "julia_assert.h"
 #include "passes.h"
 
-
 using namespace llvm;
 
 namespace {
@@ -351,7 +350,12 @@ static void buildEarlySimplificationPipeline(ModulePassManager &MPM, PassBuilder
         FPM.addPass(DCEPass());
         FPM.addPass(SimplifyCFGPass(basicSimplifyCFGOptions()));
         if (O.getSpeedupLevel() >= 1) {
+#if JL_LLVM_VERSION >= 160000
+            // TODO check the LLVM 15 default.
+            FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
+#else
             FPM.addPass(SROAPass());
+#endif
         }
         MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
     }
@@ -386,7 +390,12 @@ static void buildEarlyOptimizerPipeline(ModulePassManager &MPM, PassBuilder *PB,
     if (O.getSpeedupLevel() >= 1) {
         FunctionPassManager FPM;
         if (O.getSpeedupLevel() >= 2) {
+#if JL_LLVM_VERSION >= 160000
+            // TODO check the LLVM 15 default.
+            FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
+#else
             FPM.addPass(SROAPass());
+#endif
             // SROA can duplicate PHI nodes which can block LowerSIMD
             FPM.addPass(InstCombinePass());
             FPM.addPass(JumpThreadingPass());
@@ -456,7 +465,12 @@ static void buildScalarOptimizerPipeline(FunctionPassManager &FPM, PassBuilder *
     FPM.addPass(BeforeScalarOptimizationMarkerPass());
     if (O.getSpeedupLevel() >= 2) {
         JULIA_PASS(FPM.addPass(AllocOptPass()));
+#if JL_LLVM_VERSION >= 160000
+        // TODO check the LLVM 15 default.
+        FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
+#else
         FPM.addPass(SROAPass());
+#endif
         FPM.addPass(InstSimplifyPass());
         FPM.addPass(GVNPass());
         FPM.addPass(MemCpyOptPass());
@@ -687,12 +701,20 @@ PIC.addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
         PIC.addClassToPassName("AfterOptimizationMarkerPass", "AfterOptimization");
     }
 
+#if JL_LLVM_VERSION >= 160000
+    auto createPIC() JL_NOTSAFEPOINT {
+        auto PIC = std::make_unique<PassInstrumentationCallbacks>();
+        adjustPIC(*PIC);
+        return PIC;
+    }
+#else
     auto createPIC(StandardInstrumentations &SI) JL_NOTSAFEPOINT {
         auto PIC = std::make_unique<PassInstrumentationCallbacks>();
         adjustPIC(*PIC);
         SI.registerCallbacks(*PIC);
         return PIC;
     }
+#endif
 
     FunctionAnalysisManager createFAM(OptimizationLevel O, TargetMachine &TM) JL_NOTSAFEPOINT {
 
@@ -722,7 +744,13 @@ PIC.addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 }
 
 NewPM::NewPM(std::unique_ptr<TargetMachine> TM, OptimizationLevel O, OptimizationOptions options) :
-    TM(std::move(TM)), SI(false), PIC(createPIC(SI)),
+    TM(std::move(TM)),
+#if JL_LLVM_VERSION < 160000
+    SI(false),
+    PIC(createPIC(SI)),
+#else
+    PIC(createPIC()),
+#endif
     PB(this->TM.get(), PipelineTuningOptions(), None, PIC.get()),
     MPM(createMPM(PB, O, options)), O(O) {}
 
@@ -751,13 +779,16 @@ void NewPM::run(Module &M) {
     //so that analyses from previous runs of the pass manager
     //do not hang around for the next run
     AnalysisManagers AM{*TM, PB, O};
+
 #ifndef __clang_gcanalyzer__ /* the analyzer cannot prove we have not added instrumentation callbacks with safepoints */
     MPM.run(M, AM.MAM);
 #endif
 }
 
 void NewPM::printTimers() {
+#if JL_LLVM_VERSION < 160000
     SI.getTimePasses().print();
+#endif
 }
 
 OptimizationLevel getOptLevel(int optlevel) {
@@ -775,7 +806,7 @@ OptimizationLevel getOptLevel(int optlevel) {
 }
 
 //This part is also basically stolen from LLVM's PassBuilder.cpp file
-static llvm::Optional<std::pair<OptimizationLevel, OptimizationOptions>> parseJuliaPipelineOptions(StringRef name) {
+static Optional<std::pair<OptimizationLevel, OptimizationOptions>> parseJuliaPipelineOptions(StringRef name) {
     if (name.consume_front("julia")) {
         auto O = OptimizationLevel::O2;
         auto options = OptimizationOptions::defaults();
@@ -825,7 +856,7 @@ static llvm::Optional<std::pair<OptimizationLevel, OptimizationOptions>> parseJu
         }
         return {{O, options}};
     }
-    return {};
+    return None;
 }
 
 bool verifyLLVMIR(const Module &M) JL_NOTSAFEPOINT {

From b5b05c82afadf41f4f56fb2bcc23cdf444225ac0 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Sat, 28 Oct 2023 21:59:04 -0300
Subject: [PATCH 0119/1315] remove jl_gc_wb_buf (#51919)

Stale now that the Memory PR got merged.
---
 src/julia_internal.h | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/src/julia_internal.h b/src/julia_internal.h
index d63df80cafede..f9a50b247b35d 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -575,17 +575,6 @@ void jl_gc_run_all_finalizers(jl_task_t *ct);
 void jl_release_task_stack(jl_ptls_t ptls, jl_task_t *task);
 void jl_gc_add_finalizer_(jl_ptls_t ptls, void *v, void *f) JL_NOTSAFEPOINT;
 
-void gc_setmark_buf(jl_ptls_t ptls, void *buf, uint8_t, size_t) JL_NOTSAFEPOINT;
-
-STATIC_INLINE void jl_gc_wb_buf(void *parent, void *bufptr, size_t minsz) JL_NOTSAFEPOINT // parent isa jl_value_t*
-{
-    // if parent is marked and buf is not
-    if (__unlikely(jl_astaggedvalue(parent)->bits.gc & 1)) {
-        jl_task_t *ct = jl_current_task;
-        gc_setmark_buf(ct->ptls, bufptr, 3, minsz);
-    }
-}
-
 void jl_gc_debug_print_status(void) JL_NOTSAFEPOINT;
 JL_DLLEXPORT void jl_gc_debug_critical_error(void) JL_NOTSAFEPOINT;
 void jl_print_gc_stats(JL_STREAM *s);

From d5c30d8b2eaecea1005b38859883b60b8115ac4f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?P=C3=A1ll=20Haraldsson?= <Pall.Haraldsson@gmail.com>
Date: Sun, 29 Oct 2023 02:25:00 +0000
Subject: [PATCH 0120/1315] Fix -1 for BigInt factorial - Update gmp.jl
 (#51497)

Fixes #51488

---------

Co-authored-by: Rafael Fourquet <fourquet.rafael@gmail.com>
---
 base/gmp.jl | 2 +-
 test/gmp.jl | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/base/gmp.jl b/base/gmp.jl
index ead80b56541a6..7cfcbd21e29da 100644
--- a/base/gmp.jl
+++ b/base/gmp.jl
@@ -705,7 +705,7 @@ function prod(arr::AbstractArray{BigInt})
     foldl(MPZ.mul!, arr; init)
 end
 
-factorial(x::BigInt) = isneg(x) ? BigInt(0) : MPZ.fac_ui(x)
+factorial(n::BigInt) = !isneg(n) ? MPZ.fac_ui(n) : throw(DomainError(n, "`n` must not be negative."))
 
 function binomial(n::BigInt, k::Integer)
     k < 0 && return BigInt(0)
diff --git a/test/gmp.jl b/test/gmp.jl
index 8bfe90ec7d9e4..13413abe55f9d 100644
--- a/test/gmp.jl
+++ b/test/gmp.jl
@@ -220,6 +220,8 @@ end
 end
 @testset "combinatorics" begin
     @test factorial(BigInt(40)) == parse(BigInt,"815915283247897734345611269596115894272000000000")
+    @test_throws DomainError factorial(BigInt(-1))
+    @test_throws DomainError factorial(BigInt(rand(-999:-2)))
     @test binomial(BigInt(1), -1) == BigInt(0)
     @test binomial(BigInt(1), 2)  == BigInt(0)
     @test binomial(BigInt(-53), 42) == parse(BigInt,"959509335087854414441273718")

From 855cd5662d4bb04b20f932ea5bbe33923d2e5d05 Mon Sep 17 00:00:00 2001
From: Michael Abbott <32575566+mcabbott@users.noreply.github.com>
Date: Sun, 29 Oct 2023 11:45:29 -0400
Subject: [PATCH 0121/1315] Clarify docstring for `exponent`, again (#47085)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In #47035 we realised that `issubnormal` used the word "exponent" quite
loosely, and this is also true of `exponent`'s docstring. So this tries
to fix it...

* Saying "this corresponds to the exponent of `x`." seems a bit
circular, but I think it wants to say that in such cases it corresponds
to the exponent bits?
* Saying "normalized floating-point number" does not mean like
`normalize(1.0)`... I think it means not-subnormal. Maybe it's better to
say that? (Although I don't love this sentence.)
* From "largest integer y such that `2^y ≤ abs(x)`" it sounds like
`exponent(8+im)` should work, but it does not. So I marked it `::Real`.
* I think it is nice to mention that 0, Inf, Nan give an error. As they
must, for `2^y ≤ abs(x)`... but `0.0` is not subnormal, so the claim
about reading the bit pattern isn't quite correct without excluding
these cases.
* Better examples, progressively adding detail, not too repetitive.
* See also related functions.

Recently edited in #46815.

And I forgot, but "See also" and errors also overlap with this
(approved) PR:
https://github.com/JuliaLang/julia/pull/45221/files#diff-faa5f0835bd28c4a33e6603e208a9236034568a4abc7adec4995afb64550d0bdR940
. That should go first.
---
 base/math.jl | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/base/math.jl b/base/math.jl
index 0f917dce7c99c..90b6e726f4f9e 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -979,27 +979,28 @@ end
 ldexp(x::Float16, q::Integer) = Float16(ldexp(Float32(x), q))
 
 """
-    exponent(x) -> Int
+    exponent(x::Real) -> Int
 
 Returns the largest integer `y` such that `2^y ≤ abs(x)`.
-For a normalized floating-point number `x`, this corresponds to the exponent of `x`.
+
+Throws a `DomainError` when `x` is zero, infinite, or [`NaN`](@ref).
+For any other non-subnormal floating-point number `x`, this corresponds to the exponent bits of `x`.
+
+See also [`signbit`](@ref), [`significand`](@ref), [`frexp`](@ref), [`issubnormal`](@ref), [`log2`](@ref).
 
 # Examples
 ```jldoctest
 julia> exponent(8)
 3
 
-julia> exponent(64//1)
-6
-
 julia> exponent(6.5)
 2
 
-julia> exponent(16.0)
-4
+julia> exponent(-1//4)
+-2
 
-julia> exponent(3.142e-4)
--12
+julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
+(-126, -149)
 ```
 """
 function exponent(x::T) where T<:IEEEFloat

From ca5b4c5afba3cead8c217e75a59f303f5fee4aaf Mon Sep 17 00:00:00 2001
From: mikmoore <95002244+mikmoore@users.noreply.github.com>
Date: Sun, 29 Oct 2023 20:56:35 -0600
Subject: [PATCH 0122/1315] Small fix to `randn`/`randexp` (#51890)

The pattern `log(rand(rng))` has the consequence of permitting `log(0.0)
== -Inf` to be computed, since the domain of `rand` is $[0,1)$. It looks
like this mishap wouldn't actually escape `randn` (due to exit
conditionals), but it appears that it can escape `randexp`, resulting in
a return value of `+Inf`. While this is a literally admissible return
value, it is grossly over-represented. On the current version, it occurs
with probability roughly $10^{-18}$. For reference, values $>41$ should
occur about that often. The correct return frequency for values that
exceed `floatmax(Float64)` (i.e., `+Inf`) should be roughly
$10^{-10^{308}}$.

Replacing `log(rand(rng))` with `log1p(-rand(rng))` is "statistically
identical" (modulo the effects of finite representations) except that it
equivalently shifts the support of inputs to `log` from $[0,1)$ to the
better-behaved $(0,1]$.

This will change the stream of values produced by `randn`/`randexp`.
Additionally, the largest value returned by `randexp` will change from
$+\infty$ to roughly $44$. Somewhat larger values will be possible if we
extend the dynamic range of `rand` as discussed [on
Discourse](https://discourse.julialang.org/t/output-distribution-of-rand-float32-and-rand-float64-thread-2/105184).
---
 stdlib/Random/src/normal.jl | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stdlib/Random/src/normal.jl b/stdlib/Random/src/normal.jl
index 332af1268aea0..bbc1b03e50b5d 100644
--- a/stdlib/Random/src/normal.jl
+++ b/stdlib/Random/src/normal.jl
@@ -70,8 +70,8 @@ end
 @noinline function randn_unlikely(rng, idx, rabs, x)
     @inbounds if idx == 0
         while true
-            xx = -ziggurat_nor_inv_r*log(rand(rng))
-            yy = -log(rand(rng))
+            xx = -ziggurat_nor_inv_r*log1p(-rand(rng))
+            yy = -log1p(-rand(rng))
             yy+yy > xx*xx &&
                 return (rabs >> 8) % Bool ? -ziggurat_nor_r-xx : ziggurat_nor_r+xx
         end
@@ -138,7 +138,7 @@ end
 
 @noinline function randexp_unlikely(rng, idx, x)
     @inbounds if idx == 0
-        return ziggurat_exp_r - log(rand(rng))
+        return ziggurat_exp_r - log1p(-rand(rng))
     elseif (fe[idx] - fe[idx+1])*rand(rng) + fe[idx+1] < exp(-x)
         return x # return from the triangular area
     else

From af0bd56f83f305ca941b3fe28acb8b2babcd6d54 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 30 Oct 2023 17:14:20 +0900
Subject: [PATCH 0123/1315] minor cosmetic refactor on
 base/compiler/optimize.jl (#51924)

---
 base/compiler/optimize.jl | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index a4897865b52e3..305c9b5c03b10 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -54,7 +54,7 @@ is_inlineable(@nospecialize src::MaybeCompressed) =
 set_inlineable!(src::CodeInfo, val::Bool) =
     src.inlining_cost = (val ? MIN_INLINE_COST : MAX_INLINE_COST)
 
-function inline_cost_clamp(x::Int)::InlineCostType
+function inline_cost_clamp(x::Int)
     x > MAX_INLINE_COST && return MAX_INLINE_COST
     x < MIN_INLINE_COST && return MIN_INLINE_COST
     return convert(InlineCostType, x)
@@ -1157,14 +1157,15 @@ function statement_or_branch_cost(@nospecialize(stmt), line::Int, src::Union{Cod
     return thiscost
 end
 
-function inline_cost(ir::IRCode, params::OptimizationParams,
-                       cost_threshold::Integer=params.inline_cost_threshold)::InlineCostType
-    bodycost::Int = 0
-    for line = 1:length(ir.stmts)
-        stmt = ir[SSAValue(line)][:stmt]
-        thiscost = statement_or_branch_cost(stmt, line, ir, ir.sptypes, params)
+function inline_cost(ir::IRCode, params::OptimizationParams, cost_threshold::Int)
+    bodycost = 0
+    for i = 1:length(ir.stmts)
+        stmt = ir[SSAValue(i)][:stmt]
+        thiscost = statement_or_branch_cost(stmt, i, ir, ir.sptypes, params)
         bodycost = plus_saturate(bodycost, thiscost)
-        bodycost > cost_threshold && return MAX_INLINE_COST
+        if bodycost > cost_threshold
+            return MAX_INLINE_COST
+        end
     end
     return inline_cost_clamp(bodycost)
 end

From 55b07290c975982fa784e1aa1ccc4aece2a2206d Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 30 Oct 2023 17:14:58 +0900
Subject: [PATCH 0124/1315] inference: don't put globally-cached results into
 inference local cache (#51888)

Now, we fill the inference's local cache exclusively with locally-cached
results. Given that sources of globally-cached results will be populated
from the global cache when needed (for inlining), there's no need for
them to waste memory in the local cache.

@nanosoldier `runbenchmarks("inference", vs=":master")`
---
 base/compiler/abstractinterpretation.jl |  2 +-
 base/compiler/inferencestate.jl         | 15 +++----
 base/compiler/typeinfer.jl              | 58 +++++++++++++------------
 stdlib/REPL/src/REPLCompletions.jl      |  4 +-
 test/compiler/AbstractInterpreter.jl    |  6 +--
 5 files changed, 41 insertions(+), 44 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index d3d7d82a1e150..71decf1bb2906 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1181,7 +1181,7 @@ function const_prop_call(interp::AbstractInterpreter,
             add_remark!(interp, sv, "[constprop] Could not handle constant info in matching_cache_argtypes")
             return nothing
         end
-        frame = InferenceState(inf_result, #=cache=#:local, interp)
+        frame = InferenceState(inf_result, #=cache_mode=#:local, interp)
         if frame === nothing
             add_remark!(interp, sv, "[constprop] Could not retrieve the source")
             return nothing # this is probably a bad generated function (unsound), but just ignore it
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 6a6aba1076449..8eb86f48351ed 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -240,7 +240,7 @@ mutable struct InferenceState
     # Whether to restrict inference of abstract call sites to avoid excessive work
     # Set by default for toplevel frame.
     restrict_abstract_call_sites::Bool
-    cached::Bool # TODO move this to InferenceResult?
+    cache_mode::Symbol # TODO move this to InferenceResult?
     insert_coverage::Bool
 
     # The interpreter that created this inference state. Not looked at by
@@ -248,7 +248,7 @@ mutable struct InferenceState
     interp::AbstractInterpreter
 
     # src is assumed to be a newly-allocated CodeInfo, that can be modified in-place to contain intermediate results
-    function InferenceState(result::InferenceResult, src::CodeInfo, cache::Symbol,
+    function InferenceState(result::InferenceResult, src::CodeInfo, cache_mode::Symbol,
                             interp::AbstractInterpreter)
         linfo = result.linfo
         world = get_world_counter(interp)
@@ -303,19 +303,18 @@ mutable struct InferenceState
         end
 
         restrict_abstract_call_sites = isa(def, Module)
-        @assert cache === :no || cache === :local || cache === :global
-        cached = cache === :global
+        @assert cache_mode === :no || cache_mode === :local || cache_mode === :global
 
         # some more setups
         InferenceParams(interp).unoptimize_throw_blocks && mark_throw_blocks!(src, handler_at)
-        cache !== :no && push!(get_inference_cache(interp), result)
+        cache_mode === :local && push!(get_inference_cache(interp), result)
 
         return new(
             linfo, world, mod, sptypes, slottypes, src, cfg, method_info,
             currbb, currpc, ip, handler_at, ssavalue_uses, bb_vartables, ssavaluetypes, stmt_edges, stmt_info,
             pclimitations, limitations, cycle_backedges, callers_in_cycle, dont_work_on_me, parent,
             result, unreachable, valid_worlds, bestguess, ipo_effects,
-            restrict_abstract_call_sites, cached, insert_coverage,
+            restrict_abstract_call_sites, cache_mode, insert_coverage,
             interp)
     end
 end
@@ -667,7 +666,7 @@ end
 function print_callstack(sv::InferenceState)
     while sv !== nothing
         print(sv.linfo)
-        !sv.cached && print("  [uncached]")
+        sv.cache_mode === :global || print("  [uncached]")
         println()
         for cycle in sv.callers_in_cycle
             print(' ', cycle.linfo)
@@ -765,7 +764,7 @@ frame_parent(sv::IRInterpretationState) = sv.parent::Union{Nothing,AbsIntState}
 is_constproped(sv::InferenceState) = any(sv.result.overridden_by_const)
 is_constproped(::IRInterpretationState) = true
 
-is_cached(sv::InferenceState) = sv.cached
+is_cached(sv::InferenceState) = sv.cache_mode === :global
 is_cached(::IRInterpretationState) = false
 
 method_info(sv::InferenceState) = sv.method_info
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index cebf178504a68..d1f635d3be704 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -5,10 +5,10 @@ const track_newly_inferred = RefValue{Bool}(false)
 const newly_inferred = CodeInstance[]
 
 # build (and start inferring) the inference frame for the top-level MethodInstance
-function typeinf(interp::AbstractInterpreter, result::InferenceResult, cache::Symbol)
-    frame = InferenceState(result, cache, interp)
+function typeinf(interp::AbstractInterpreter, result::InferenceResult, cache_mode::Symbol)
+    frame = InferenceState(result, cache_mode, interp)
     frame === nothing && return false
-    cache === :global && lock_mi_inference(interp, result.linfo)
+    cache_mode === :global && lock_mi_inference(interp, result.linfo)
     return typeinf(interp, frame)
 end
 
@@ -239,7 +239,7 @@ function finish!(interp::AbstractInterpreter, caller::InferenceState)
         # but that is what !must_be_codeinf permits
         # This is hopefully unreachable when must_be_codeinf is true
     end
-    return
+    return nothing
 end
 
 function _typeinf(interp::AbstractInterpreter, frame::InferenceState)
@@ -267,11 +267,14 @@ function _typeinf(interp::AbstractInterpreter, frame::InferenceState)
     end
     for caller in frames
         finish!(caller.interp, caller)
-        if caller.cached
+        if caller.cache_mode === :global
             cache_result!(caller.interp, caller.result)
         end
-        # n.b. We do not drop result.src here, even though that wastes memory while it is still in the local cache
-        # since the user might have requested call-site inlining of it.
+        # Drop result.src here since otherwise it can waste memory.
+        # N.B. If the `cache_mode === :local`, the inliner may request to use it later.
+        if caller.cache_mode !== :local
+            caller.result.src = nothing
+        end
     end
     empty!(frames)
     return true
@@ -381,23 +384,23 @@ function cache_result!(interp::AbstractInterpreter, result::InferenceResult)
     end
     # check if the existing linfo metadata is also sufficient to describe the current inference result
     # to decide if it is worth caching this
-    linfo = result.linfo
-    already_inferred = already_inferred_quick_test(interp, linfo)
-    if !already_inferred && haskey(WorldView(code_cache(interp), valid_worlds), linfo)
+    mi = result.linfo
+    already_inferred = already_inferred_quick_test(interp, mi)
+    if !already_inferred && haskey(WorldView(code_cache(interp), valid_worlds), mi)
         already_inferred = true
     end
 
     # TODO: also don't store inferred code if we've previously decided to interpret this function
     if !already_inferred
-        code_cache(interp)[linfo] = ci = CodeInstance(interp, result, valid_worlds)
+        code_cache(interp)[mi] = ci = CodeInstance(interp, result, valid_worlds)
         if track_newly_inferred[]
-            m = linfo.def
+            m = mi.def
             if isa(m, Method) && m.module != Core
                 ccall(:jl_push_newly_inferred, Cvoid, (Any,), ci)
             end
         end
     end
-    unlock_mi_inference(interp, linfo)
+    unlock_mi_inference(interp, mi)
     nothing
 end
 
@@ -543,7 +546,7 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
         # a parent may be cached still, but not this intermediate work:
         # we can throw everything else away now
         me.result.src = nothing
-        me.cached = false
+        me.cache_mode = :no
         set_inlineable!(me.src, false)
         unlock_mi_inference(interp, me.linfo)
     elseif limited_src
@@ -555,7 +558,7 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
         # annotate fulltree with type information,
         # either because we are the outermost code, or we might use this later
         type_annotate!(interp, me)
-        doopt = (me.cached || me.parent !== nothing)
+        doopt = (me.cache_mode !== :no || me.parent !== nothing)
         # Disable the optimizer if we've already determined that there's nothing for
         # it to do.
         if may_discard_trees(interp) && is_result_constabi_eligible(me.result)
@@ -563,8 +566,6 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
         end
         if doopt && may_optimize(interp)
             me.result.src = OptimizationState(me, interp)
-        else
-            me.result.src = me.src::CodeInfo # stash a convenience copy of the code (e.g. for reflection)
         end
     end
     validate_code_in_debug_mode(me.linfo, me.src, "inferred")
@@ -814,7 +815,7 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
             # we already inferred this edge before and decided to discard the inferred code,
             # nevertheless we re-infer it here again and keep it around in the local cache
             # since the inliner will request to use it later
-            cache = :local
+            cache_mode = :local
         else
             rt = cached_return_type(code)
             effects = ipo_effects(code)
@@ -822,7 +823,7 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
             return EdgeCallResult(rt, mi, effects)
         end
     else
-        cache = :global # cache edge targets by default
+        cache_mode = :global # cache edge targets by default
     end
     if ccall(:jl_get_module_infer, Cint, (Any,), method.module) == 0 && !generating_output(#=incremental=#false)
         add_remark!(interp, caller, "Inference is disabled for the target module")
@@ -839,7 +840,7 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         # completely new
         lock_mi_inference(interp, mi)
         result = InferenceResult(mi, typeinf_lattice(interp))
-        frame = InferenceState(result, cache, interp) # always use the cache for edge targets
+        frame = InferenceState(result, cache_mode, interp) # always use the cache for edge targets
         if frame === nothing
             add_remark!(interp, caller, "Failed to retrieve source")
             # can't get the source for this, so we know nothing
@@ -970,7 +971,8 @@ typeinf_frame(interp::AbstractInterpreter, method::Method, @nospecialize(atype),
 function typeinf_frame(interp::AbstractInterpreter, mi::MethodInstance, run_optimizer::Bool)
     start_time = ccall(:jl_typeinf_timing_begin, UInt64, ())
     result = InferenceResult(mi, typeinf_lattice(interp))
-    frame = InferenceState(result, run_optimizer ? :global : :no, interp)
+    cache_mode = run_optimizer ? :global : :no
+    frame = InferenceState(result, cache_mode, interp)
     frame === nothing && return nothing
     typeinf(interp, frame)
     ccall(:jl_typeinf_timing_end, Cvoid, (UInt64,), start_time)
@@ -1010,7 +1012,7 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance)
     end
     lock_mi_inference(interp, mi)
     result = InferenceResult(mi, typeinf_lattice(interp))
-    frame = InferenceState(result, #=cache=#:global, interp)
+    frame = InferenceState(result, #=cache_mode=#:global, interp)
     frame === nothing && return nothing
     typeinf(interp, frame)
     ccall(:jl_typeinf_timing_end, Cvoid, (UInt64,), start_time)
@@ -1043,18 +1045,18 @@ end
 
 # This is a bridge for the C code calling `jl_typeinf_func()`
 typeinf_ext_toplevel(mi::MethodInstance, world::UInt) = typeinf_ext_toplevel(NativeInterpreter(world), mi)
-function typeinf_ext_toplevel(interp::AbstractInterpreter, linfo::MethodInstance)
-    if isa(linfo.def, Method)
+function typeinf_ext_toplevel(interp::AbstractInterpreter, mi::MethodInstance)
+    if isa(mi.def, Method)
         # method lambda - infer this specialization via the method cache
-        src = typeinf_ext(interp, linfo)
+        src = typeinf_ext(interp, mi)
     else
-        src = linfo.uninferred::CodeInfo
+        src = mi.uninferred::CodeInfo
         if !src.inferred
             # toplevel lambda - infer directly
             start_time = ccall(:jl_typeinf_timing_begin, UInt64, ())
             if !src.inferred
-                result = InferenceResult(linfo, typeinf_lattice(interp))
-                frame = InferenceState(result, src, #=cache=#:global, interp)
+                result = InferenceResult(mi, typeinf_lattice(interp))
+                frame = InferenceState(result, src, #=cache_mode=#:global, interp)
                 typeinf(interp, frame)
                 @assert is_inferred(frame) # TODO: deal with this better
                 src = frame.src
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index cb9dc292d9664..d7f5a7cc0c23f 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -519,10 +519,10 @@ CC.bail_out_toplevel_call(::REPLInterpreter, ::CC.InferenceLoopState, ::CC.Infer
 # `REPLInterpreter` is specifically used by `repl_eval_ex`, where all top-level frames are
 # `repl_frame` always. However, this assumption wouldn't stand if `REPLInterpreter` were to
 # be employed, for instance, by `typeinf_ext_toplevel`.
-is_repl_frame(sv::CC.InferenceState) = sv.linfo.def isa Module && !sv.cached
+is_repl_frame(sv::CC.InferenceState) = sv.linfo.def isa Module && sv.cache_mode === :no
 
 function is_call_graph_uncached(sv::CC.InferenceState)
-    sv.cached && return false
+    sv.cache_mode === :global && return false
     parent = sv.parent
     parent === nothing && return true
     return is_call_graph_uncached(parent::CC.InferenceState)
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 2d77c148275b9..083071b566da6 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -437,18 +437,14 @@ custom_lookup_context(x::Int) = custom_lookup_target(true, x)
 const CONST_INVOKE_INTERP_WORLD = Base.get_world_counter()
 const CONST_INVOKE_INTERP = ConstInvokeInterp(; world=CONST_INVOKE_INTERP_WORLD)
 function custom_lookup(mi::MethodInstance, min_world::UInt, max_world::UInt)
-    local matched_mi = nothing
     for inf_result in CONST_INVOKE_INTERP.inf_cache
         if inf_result.linfo === mi
             if CC.any(inf_result.overridden_by_const)
                 return CodeInstance(CONST_INVOKE_INTERP, inf_result, inf_result.valid_worlds)
-            elseif matched_mi === nothing
-                matched_mi = inf_result.linfo
             end
         end
     end
-    matched_mi === nothing && return nothing
-    return CONST_INVOKE_INTERP.code_cache.dict[matched_mi]
+    return CONST_INVOKE_INTERP.code_cache.dict[mi]
 end
 
 let # generate cache

From 96147bbe334fd93ac269430b0f2bcfe8604eaa89 Mon Sep 17 00:00:00 2001
From: Tomas Fiers <tomas.fiers@gmail.com>
Date: Mon, 30 Oct 2023 19:40:24 +0100
Subject: [PATCH 0125/1315] manual/workflow-tips: simplify the basic workflow
 (and explain the why) (#48319)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I came upon this piece of documentation again after seeing this post:
https://discourse.julialang.org/t/how-to-clear-variables-and-or-whole-work-space/10149/21?u=tfiers
("How to clear variables and/or whole work space?" → "Work in a module")

This small addendum to the Worfklow Tips section of the manual answers
"but why should I bother making that module";
basically putting the gist of that discourse thread in the
documentation, where more people might see it.
---
 doc/src/manual/workflow-tips.md | 65 ++++++++++++---------------------
 1 file changed, 24 insertions(+), 41 deletions(-)

diff --git a/doc/src/manual/workflow-tips.md b/doc/src/manual/workflow-tips.md
index 4085a51ff9131..c3bbbbae8146f 100644
--- a/doc/src/manual/workflow-tips.md
+++ b/doc/src/manual/workflow-tips.md
@@ -10,57 +10,40 @@ your experience at the command line.
 
 ### A basic editor/REPL workflow
 
-The most basic Julia workflows involve using a text editor in conjunction with the `julia` command
-line. A common pattern includes the following elements:
+The most basic Julia workflows involve using a text editor in conjunction with the `julia` command line.
 
-  * **Put code under development in a temporary module.** Create a file, say `Tmp.jl`, and include
-    within it
+Create a file, say `Tmp.jl`, and include within it
+```julia
+module Tmp
 
-    ```julia
-    module Tmp
-    export say_hello
+say_hello() = println("Hello!")
 
-    say_hello() = println("Hello!")
+# Your other definitions here
 
-    # your other definitions here
+end # module
 
-    end
-    ```
-  * **Put your test code in another file.** Create another file, say `tst.jl`, which looks like
+using .Tmp
+```
+Then, in the same directory, start the Julia REPL (using the `julia` command).
+Run the new file as follows:
+```
+julia> include("Tmp.jl")
 
-    ```julia
-    include("Tmp.jl")
-    import .Tmp
-    # using .Tmp # we can use `using` to bring the exported symbols in `Tmp` into our namespace
+julia> Tmp.say_hello()
+Hello!
+```
+Explore ideas in the REPL. Save good ideas in `Tmp.jl`.
+To reload the file after it has been changed, just `include` it again.
 
-    Tmp.say_hello()
-    # say_hello()
+The key in the above is that your code is encapsulated in a module.
+That allows you to edit `struct` definitions and remove methods, without restarting Julia.
 
-    # your other test code here
-    ```
+(Explanation: `struct`s cannot be edited after definition, nor can methods be deleted.
+But you _can_ overwrite the definition of a module, which is what we do when we re-`include("Tmp.jl")`).
 
-    and includes tests for the contents of `Tmp`.
-    Alternatively, you can wrap the contents of your test file in a module, as
+In addition, the encapsulation of code in a module protects it from being influenced
+by previous state in the REPL, protecting you from hard-to-detect errors.
 
-    ```julia
-    module Tst
-        include("Tmp.jl")
-        import .Tmp
-        #using .Tmp
-
-        Tmp.say_hello()
-        # say_hello()
-
-        # your other test code here
-    end
-    ```
-
-    The advantage is that your testing code is now contained in a module and does not use the global scope in `Main` for
-    definitions, which is a bit more tidy.
-
-  * `include` the `tst.jl` file in the Julia REPL with `include("tst.jl")`.
-
-  * **Lather. Rinse. Repeat.** Explore ideas at the `julia` command prompt. Save good ideas in `tst.jl`. To execute `tst.jl` after it has been changed, just `include` it again.
 
 ## Browser-based workflow
 

From 85ed34ca47a588d491d66cece5d5f525a1a62686 Mon Sep 17 00:00:00 2001
From: Milan Bouchet-Valat <nalimilan@club.fr>
Date: Tue, 31 Oct 2023 01:14:05 +0100
Subject: [PATCH 0126/1315] Document the kind of indices returned by
 `findmin`/`findmax`/`argmin`/`argmax` (#46705)

This is the sentence used for `find*` functions, introduced by #25577.

Also change "the domain of `f`" to "`domain`" as the domain of `f` can
be a superset of the passed `domain`.

(Spotted at https://github.com/JuliaData/DataFrames.jl/issues/3139.)

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/reduce.jl | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/base/reduce.jl b/base/reduce.jl
index d98b237e4997c..f9411f8b5d783 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -877,11 +877,12 @@ end
 """
     findmax(f, domain) -> (f(x), index)
 
-Return a pair of a value in the codomain (outputs of `f`) and the index of
+Return a pair of a value in the codomain (outputs of `f`) and the index or key of
 the corresponding value in the `domain` (inputs to `f`) such that `f(x)` is maximised.
 If there are multiple maximal points, then the first one will be returned.
 
-`domain` must be a non-empty iterable.
+`domain` must be a non-empty iterable supporting [`keys`](@ref). Indices
+are of the same type as those returned by [`keys(domain)`](@ref).
 
 Values are compared with `isless`.
 
@@ -915,6 +916,9 @@ Return the maximal element of the collection `itr` and its index or key.
 If there are multiple maximal elements, then the first one will be returned.
 Values are compared with `isless`.
 
+Indices are of the same type as those returned by [`keys(itr)`](@ref)
+and [`pairs(itr)`](@ref).
+
 See also: [`findmin`](@ref), [`argmax`](@ref), [`maximum`](@ref).
 
 # Examples
@@ -936,12 +940,15 @@ _findmax(a, ::Colon) = findmax(identity, a)
 """
     findmin(f, domain) -> (f(x), index)
 
-Return a pair of a value in the codomain (outputs of `f`) and the index of
+Return a pair of a value in the codomain (outputs of `f`) and the index or key of
 the corresponding value in the `domain` (inputs to `f`) such that `f(x)` is minimised.
 If there are multiple minimal points, then the first one will be returned.
 
 `domain` must be a non-empty iterable.
 
+Indices are of the same type as those returned by [`keys(domain)`](@ref)
+and [`pairs(domain)`](@ref).
+
 `NaN` is treated as less than all other values except `missing`.
 
 !!! compat "Julia 1.7"
@@ -975,6 +982,9 @@ Return the minimal element of the collection `itr` and its index or key.
 If there are multiple minimal elements, then the first one will be returned.
 `NaN` is treated as less than all other values except `missing`.
 
+Indices are of the same type as those returned by [`keys(itr)`](@ref)
+and [`pairs(itr)`](@ref).
+
 See also: [`findmax`](@ref), [`argmin`](@ref), [`minimum`](@ref).
 
 # Examples
@@ -1027,6 +1037,9 @@ If there are multiple maximal elements, then the first one will be returned.
 
 The collection must not be empty.
 
+Indices are of the same type as those returned by [`keys(itr)`](@ref)
+and [`pairs(itr)`](@ref).
+
 Values are compared with `isless`.
 
 See also: [`argmin`](@ref), [`findmax`](@ref).
@@ -1082,6 +1095,9 @@ If there are multiple minimal elements, then the first one will be returned.
 
 The collection must not be empty.
 
+Indices are of the same type as those returned by [`keys(itr)`](@ref)
+and [`pairs(itr)`](@ref).
+
 `NaN` is treated as less than all other values except `missing`.
 
 See also: [`argmax`](@ref), [`findmin`](@ref).

From a9509be40a7cba9c760a26d50e52f6b37d483616 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 31 Oct 2023 01:46:24 +0100
Subject: [PATCH 0127/1315] updated Doc string in Base.Generator (#35261)

---
 base/generator.jl | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/base/generator.jl b/base/generator.jl
index aa4b7f67cba95..1f981de8dc788 100644
--- a/base/generator.jl
+++ b/base/generator.jl
@@ -5,25 +5,26 @@
 
 Given a function `f` and an iterator `iter`, construct an iterator that yields
 the values of `f` applied to the elements of `iter`.
-The syntax for constructing an instance of this type is `f(x) for x in iter [if cond(x)::Bool] `.
-The `[if cond(x)::Bool]` expression is optional and acts as a "guard", effectively
-filtering out values where the condition is false.
+The syntax `f(x) for x in iter` is syntax for constructing an instance of this
+type.
 
 ```jldoctest
-julia> g = (abs2(x) for x in 1:5 if x != 3);
+julia> g = (abs2(x) for x in 1:5);
 
 julia> for x in g
            println(x)
        end
 1
 4
+9
 16
 25
 
 julia> collect(g)
-4-element Vector{Int64}:
+5-element Vector{Int64}:
   1
   4
+  9
  16
  25
 ```

From 3f77e1ef9a6545f962882d4a4beff607671bd89f Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 31 Oct 2023 10:32:28 +0900
Subject: [PATCH 0128/1315] delay instantiation of `const_results` (#51925)

Makes `abstract_call_gf_by_type` more memory efficient.
---
 base/compiler/abstractinterpretation.jl | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 71decf1bb2906..82aca46f3e7ed 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -35,8 +35,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
     edges = MethodInstance[]
     conditionals = nothing # keeps refinement information of call argument types when the return type is boolean
     seen = 0               # number of signatures actually inferred
-    any_const_result = false
-    const_results = Union{Nothing,ConstResult}[]
+    const_results = nothing # or const_results::Vector{Union{Nothing,ConstResult}} if any const results are available
     multiple_matches = napplicable > 1
     fargs = arginfo.fargs
     all_effects = EFFECTS_TOTAL
@@ -75,8 +74,12 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
                     end
                 end
                 all_effects = merge_effects(all_effects, effects)
-                push!(const_results, const_result)
-                any_const_result |= const_result !== nothing
+                if const_result !== nothing
+                    if const_results === nothing
+                        const_results = fill!(Vector{Union{Nothing,ConstResult}}(undef, #=TODO=#napplicable), nothing)
+                    end
+                    const_results[i] = const_result
+                end
                 edge === nothing || push!(edges, edge)
                 this_rt = tmerge(this_rt, rt)
                 if bail_out_call(interp, this_rt, sv)
@@ -111,8 +114,12 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
                 end
             end
             all_effects = merge_effects(all_effects, effects)
-            push!(const_results, const_result)
-            any_const_result |= const_result !== nothing
+            if const_result !== nothing
+                if const_results === nothing
+                    const_results = fill!(Vector{Union{Nothing,ConstResult}}(undef, napplicable), nothing)
+                end
+                const_results[i] = const_result
+            end
             edge === nothing || push!(edges, edge)
         end
         @assert !(this_conditional isa Conditional || this_rt isa MustAlias) "invalid lattice element returned from inter-procedural context"
@@ -135,7 +142,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
         end
     end
 
-    if any_const_result && seen == napplicable
+    if const_results !== nothing
         @assert napplicable == nmatches(info) == length(const_results)
         info = ConstCallInfo(info, const_results)
     end

From aeb4e7d2755489fb1d4eb96fc577c33e465d6115 Mon Sep 17 00:00:00 2001
From: Lucas Morton <23484003+lamorton@users.noreply.github.com>
Date: Mon, 30 Oct 2023 20:26:40 -0700
Subject: [PATCH 0129/1315] Comment on `include` pattern in Julia vs. Python
 (#41227)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 doc/src/manual/noteworthy-differences.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/src/manual/noteworthy-differences.md b/doc/src/manual/noteworthy-differences.md
index 12dc4fdfddd24..ef47a7635d50a 100644
--- a/doc/src/manual/noteworthy-differences.md
+++ b/doc/src/manual/noteworthy-differences.md
@@ -250,7 +250,8 @@ For users coming to Julia from R, these are some noteworthy differences:
   * There are no classes in Julia. Instead there are structures (mutable or immutable), containing data but no methods.
   * Calling a method of a class instance in Python (`x = MyClass(*args); x.f(y)`) corresponds to a function call in Julia, e.g. `x = MyType(args...); f(x, y)`. In general, multiple dispatch is more flexible and powerful than the Python class system.
   * Julia structures may have exactly one abstract supertype, whereas Python classes can inherit from one or more (abstract or concrete) superclasses.
-  * The logical Julia program structure (Packages and Modules) is independent of the file structure (`include` for additional files), whereas the Python code structure is defined by directories (Packages) and files (Modules).
+  * The logical Julia program structure (Packages and Modules) is independent of the file structure, whereas the Python code structure is defined by directories (Packages) and files (Modules).
+  * In Julia, it is idiomatic to split the text of large modules into multiple files, without introducing a new module per file. The code is reassembled inside a single module in a main file via `include`. While the Python equivalent (`exec`) is not typical for this use (it will silently clobber prior definitions), Julia programs are defined as a unit at the `module` level with `using` or `import`, which will only get executed once when first needed--like `include` in Python. Within those modules, the individual files that make up that module are loaded with `include` by listing them once in the intended order.
   * The ternary operator `x > 0 ? 1 : -1` in Julia corresponds to a conditional expression in Python `1 if x > 0 else -1`.
   * In Julia the `@` symbol refers to a macro, whereas in Python it refers to a decorator.
   * Exception handling in Julia is done using `try` — `catch` — `finally`, instead of `try` — `except` — `finally`. In contrast to Python, it is not recommended to use exception handling as part of the normal workflow in Julia (compared with Python, Julia is faster at ordinary control flow but slower at exception-catching).

From 4ce1c8158b24dac4a3c8d576f4d20243ac6c29ed Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Tue, 31 Oct 2023 09:53:50 +0100
Subject: [PATCH 0130/1315] relocation: a fix for `@depot` tag inserting and
 extra tests (#51920)

#51892 caused depots to be skipped when inserting the `@depot` tags,
because it assumed that `isdirpath(path) == false` means that `path` is
not a directory.
This is fixed here while preserving the path normalization introduced
there.

Furthermore, this adds tests as requested here
https://github.com/JuliaLang/julia/pull/51892#issuecomment-1781754004
---
 base/loading.jl       | 23 ++++++++++++---------
 test/relocatedepot.jl | 47 +++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 58 insertions(+), 12 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index dc532a668bea6..40bf4092ee8f1 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2600,13 +2600,13 @@ end
 
 function replace_depot_path(path::AbstractString)
     for depot in DEPOT_PATH
-        # Skip depots that don't exist
-        if !isdirpath(depot)
-            continue
-        end
+        !isdir(depot) && continue
 
         # Strip extraneous pathseps through normalization.
-        depot = dirname(depot)
+        if isdirpath(depot)
+            depot = dirname(depot)
+        end
+
         if startswith(path, depot)
             path = replace(path, depot => "@depot"; count=1)
             break
@@ -2615,10 +2615,13 @@ function replace_depot_path(path::AbstractString)
     return path
 end
 
+function restore_depot_path(path::AbstractString, depot::AbstractString)
+    replace(path, r"^@depot" => depot; count=1)
+end
+
 # Find depot in DEPOT_PATH for which all @depot tags from the `includes`
 # can be replaced so that they point to a file on disk each.
-# Return nothing when no depot matched.
-function resolve_depot(includes)
+function resolve_depot(includes::Union{AbstractVector,AbstractSet})
     if any(includes) do inc
             !startswith(inc, "@depot")
         end
@@ -2626,7 +2629,7 @@ function resolve_depot(includes)
     end
     for depot in DEPOT_PATH
         if all(includes) do inc
-                isfile(replace(inc, r"^@depot" => depot; count=1))
+                isfile(restore_depot_path(inc, depot))
             end
             return depot
         end
@@ -2732,7 +2735,7 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
         @debug "Missing @depot tag for include dependencies in cache file $cachefile."
     else
         for inc in includes
-            inc.filename = replace(inc.filename, r"^@depot" => depot; count=1)
+            inc.filename = restore_depot_path(inc.filename, depot)
         end
     end
     includes_srcfiles_only = includes[keepidx]
@@ -2795,7 +2798,7 @@ function _read_dependency_src(io::IO, filename::AbstractString, includes::Vector
         fn = if !startswith(depotfn, "@depot")
             depotfn
         else
-            basefn = replace(depotfn, r"^@depot" => "")
+            basefn = restore_depot_path(depotfn, "")
             idx = findfirst(includes) do inc
                 endswith(inc.filename, basefn)
             end
diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
index 18d8c98c637c9..7aaeda1174e29 100644
--- a/test/relocatedepot.jl
+++ b/test/relocatedepot.jl
@@ -19,6 +19,51 @@ end
 
 if !test_relocated_depot
 
+    @testset "insert @depot tag in path" begin
+
+        test_harness() do
+            mktempdir() do dir
+                pushfirst!(DEPOT_PATH, dir)
+                path = dir*dir
+                @test Base.replace_depot_path(path) == "@depot"*dir
+            end
+        end
+
+        test_harness() do
+            mktempdir() do dir
+                pushfirst!(DEPOT_PATH, dir)
+                path = joinpath(dir, "foo")
+                if isdirpath(DEPOT_PATH[1])
+                    DEPOT_PATH[1] = dirname(DEPOT_PATH[1]) # strip trailing pathsep
+                end
+                tag = joinpath("@depot", "") # append a pathsep
+                @test startswith(Base.replace_depot_path(path), tag)
+                DEPOT_PATH[1] = joinpath(DEPOT_PATH[1], "") # append a pathsep
+                @test startswith(Base.replace_depot_path(path), tag)
+                popfirst!(DEPOT_PATH)
+                @test !startswith(Base.replace_depot_path(path), tag)
+            end
+        end
+
+    end
+
+    @testset "restore path from @depot tag" begin
+
+        tmp = tempdir()
+
+        path = joinpath("@depot", "foo", "bar")
+        tmppath = joinpath(tmp, "foo", "bar")
+        @test Base.restore_depot_path(path, tmp) == tmppath
+
+        path = joinpath("no@depot", "foo", "bar")
+        @test Base.restore_depot_path(path, tmp) == path
+
+        path = joinpath("@depot", "foo", "bar\n", "@depot", "foo")
+        tmppath = joinpath(tmp, "foo", "bar\n", "@depot", "foo")
+        @test Base.restore_depot_path(path, tmp) == tmppath
+
+    end
+
     @testset "precompile RelocationTestPkg1" begin
         pkgname = "RelocationTestPkg1"
         test_harness() do
@@ -44,7 +89,6 @@ if !test_relocated_depot
             @test Base.isprecompiled(pkg) == false
             touch(joinpath(@__DIR__, pkgname, "src", "foo.txt"))
             Base.require(pkg) # precompile
-            @info "SERS OIDA"
             @test Base.isprecompiled(pkg, ignore_loaded=true) == true
         end
     end
@@ -59,7 +103,6 @@ else
             for pkgname in ("RelocationTestPkg1", "RelocationTestPkg2")
                 pkg = Base.identify_package(pkgname)
                 cachefile = only(Base.find_all_in_cache_path(pkg))
-                @info cachefile
                 @test_throws ArgumentError("""
                   Failed to determine depot from srctext files in cache file $cachefile.
                   - Make sure you have adjusted DEPOT_PATH in case you relocated depots.""") Base.isprecompiled(pkg)

From b9dcb94f450dcafa22fa6e5a17dbe3bceceb16b3 Mon Sep 17 00:00:00 2001
From: t-bltg <tf.bltg@gmail.com>
Date: Tue, 31 Oct 2023 09:55:35 +0100
Subject: [PATCH 0131/1315] doc: rename `sparam_syms` to `slot_syms` (#45876)

`sparam_syms` was removed in
https://github.com/JuliaLang/julia/pull/31015.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 doc/src/devdocs/ast.md | 7 +++----
 src/julia.h            | 2 +-
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/doc/src/devdocs/ast.md b/doc/src/devdocs/ast.md
index 4bd3959cf0ff6..18ed12b3326e9 100644
--- a/doc/src/devdocs/ast.md
+++ b/doc/src/devdocs/ast.md
@@ -601,10 +601,9 @@ for important details on how to modify these fields safely.
 
   * `sparam_vals`
 
-    The values of the static parameters in `specTypes` indexed by `def.sparam_syms`. For the
-    `MethodInstance` at `Method.unspecialized`, this is the empty `SimpleVector`. But for a
-    runtime `MethodInstance` from the `MethodTable` cache, this will always be defined and
-    indexable.
+    The values of the static parameters in `specTypes`.
+    For the `MethodInstance` at `Method.unspecialized`, this is the empty `SimpleVector`.
+    But for a runtime `MethodInstance` from the `MethodTable` cache, this will always be defined and indexable.
 
   * `uninferred`
 
diff --git a/src/julia.h b/src/julia.h
index 05f3c936fe3d1..1a8e62f9dcf9d 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -378,7 +378,7 @@ struct _jl_method_instance_t {
         jl_method_t *method; // method this is specialized from
     } def; // pointer back to the context for this code
     jl_value_t *specTypes;  // argument types this was specialized for
-    jl_svec_t *sparam_vals; // static parameter values, indexed by def.method->sparam_syms
+    jl_svec_t *sparam_vals; // static parameter values, indexed by def.method->sig
     _Atomic(jl_value_t*) uninferred; // cached uncompressed code, for generated functions, top-level thunks, or the interpreter
     jl_array_t *backedges; // list of method-instances which call this method-instance; `invoke` records (invokesig, caller) pairs
     jl_array_t *callbacks; // list of callback functions to inform external caches about invalidations

From 6084a62c148e019d43ff5d978e6b7a75e5d09626 Mon Sep 17 00:00:00 2001
From: nishtha981 <92522516+nishtha981@users.noreply.github.com>
Date: Tue, 31 Oct 2023 14:27:23 +0530
Subject: [PATCH 0132/1315] Adds information to redirect_std* inline docs
 (#49563)

Partially addresses issue #35959

Adds examples for redirecting std to a file to the markdown file

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 doc/src/manual/networking-and-streams.md | 32 +++++++++++++++++++-----
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/doc/src/manual/networking-and-streams.md b/doc/src/manual/networking-and-streams.md
index 00a10177b2155..45bf60a7944d2 100644
--- a/doc/src/manual/networking-and-streams.md
+++ b/doc/src/manual/networking-and-streams.md
@@ -1,9 +1,10 @@
 # Networking and Streams
 
 Julia provides a rich interface to deal with streaming I/O objects such as terminals, pipes and
-TCP sockets. This interface, though asynchronous at the system level, is presented in a synchronous
-manner to the programmer and it is usually unnecessary to think about the underlying asynchronous
-operation. This is achieved by making heavy use of Julia cooperative threading ([coroutine](@ref man-tasks))
+TCP sockets.
+These objects allow data to be sent and received in a stream-like fashion, which means that data is processed sequentially as it becomes available.
+This interface, though asynchronous at the system level, is presented in a synchronous manner to the programmer.
+This is achieved by making heavy use of Julia cooperative threading ([coroutine](@ref man-tasks))
 functionality.
 
 ## Basic Stream I/O
@@ -66,8 +67,8 @@ abcd
 "abcd"
 ```
 
-Note that depending on your terminal settings, your TTY may be line buffered and might thus require
-an additional enter before the data is sent to Julia.
+Note that depending on your terminal settings, your TTY ("teletype terminal") may be line buffered and might thus require an additional enter before `stdin` data is sent to Julia.
+When running Julia from the command line in a TTY, output is sent to the console by default, and standard input is read from the keyboard.
 
 To read every line from [`stdin`](@ref) you can use [`eachline`](@ref):
 
@@ -205,6 +206,24 @@ julia> open("hello.txt") do f
 "HELLO AGAIN."
 ```
 
+If you want to redirect stdout to a file
+
+```# Open file for writing
+out_file = open("output.txt", "w")
+
+# Redirect stdout to file
+redirect_stdout(out_file) do
+    # Your code here
+    println("This output goes to `out_file` via the `stdout` variable.")
+end
+
+# Close file
+close(out_file)
+
+```
+
+Redirecting stdout to a file can help you save and analyze program output, automate processes, and meet compliance requirements.
+
 ## A simple TCP example
 
 Let's jump right in with a simple example involving TCP sockets.
@@ -336,7 +355,6 @@ ip"74.125.226.225"
 
 ## Asynchronous I/O
 
-
 All I/O operations exposed by [`Base.read`](@ref) and [`Base.write`](@ref) can be performed
 asynchronously through the use of [coroutines](@ref man-tasks). You can create a new coroutine to
 read from or write to a stream using the [`@async`](@ref) macro:
@@ -418,6 +436,7 @@ close(socket)
 This example gives the same functionality as the previous program, but uses IPv6 as the network-layer protocol.
 
 Listener:
+
 ```julia
 using Sockets
 group = Sockets.IPv6("ff05::5:6:7")
@@ -430,6 +449,7 @@ close(socket)
 ```
 
 Sender:
+
 ```julia
 using Sockets
 group = Sockets.IPv6("ff05::5:6:7")

From 9075731481a4ce0bccde0c9611b6695e6d0d0f57 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 31 Oct 2023 07:18:35 -0400
Subject: [PATCH 0133/1315] fixup to #51743, timetype subtraction (#51881)

Restores the method whose removal was probably causing problems.
---
 stdlib/Dates/src/arithmetic.jl  | 3 +--
 stdlib/Dates/test/arithmetic.jl | 5 +++++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/stdlib/Dates/src/arithmetic.jl b/stdlib/Dates/src/arithmetic.jl
index 23a76f5ed75d6..b379747c5f9e9 100644
--- a/stdlib/Dates/src/arithmetic.jl
+++ b/stdlib/Dates/src/arithmetic.jl
@@ -6,8 +6,7 @@
 
 # TimeType arithmetic
 (+)(x::TimeType) = x
-(-)(x::Date, y::Date) = x.instant - y.instant
-(-)(x::Time, y::Time) = x.instant - y.instant
+(-)(x::T, y::T) where {T<:TimeType} = x.instant - y.instant
 (-)(x::DateTime, y::DateTime) = x.instant - y.instant
 (-)(x::AbstractDateTime, y::AbstractDateTime) = -(promote(x, y)...)
 
diff --git a/stdlib/Dates/test/arithmetic.jl b/stdlib/Dates/test/arithmetic.jl
index 129e9a60bf490..6e2e89fe32b68 100644
--- a/stdlib/Dates/test/arithmetic.jl
+++ b/stdlib/Dates/test/arithmetic.jl
@@ -11,8 +11,13 @@ using Dates
     @test Dates.CompoundPeriod(a - b) == Dates.Hour(12)
 end
 
+struct MonthlyDate <: TimeType
+    instant::Dates.UTInstant{Month}
+end
 @testset "TimeType arithmetic" begin
     @test_throws MethodError DateTime(2023, 5, 2) - Date(2023, 5, 1)
+    # check that - between two same-type TimeTypes works by default
+    @test MonthlyDate(Dates.UTInstant(Month(10))) - MonthlyDate(Dates.UTInstant(Month(1))) == Month(9)
 end
 
 @testset "Wrapping arithmetic for Months" begin

From 5b34cdfa705df21997a8b97f6642c18de3a6d0e1 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 31 Oct 2023 12:19:12 +0100
Subject: [PATCH 0134/1315] remove chmodding the pkgimages (#51885)

This shouldn't be needed because `ldd` should do it itself.
---
 base/loading.jl | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 40bf4092ee8f1..cd69c8c445b2a 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2493,12 +2493,6 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
 
             # inherit permission from the source file (and make them writable)
             chmod(tmppath, filemode(path) & 0o777 | 0o200)
-            if cache_objects
-                # Ensure that the user can execute the `.so` we're generating
-                # Note that on windows, `filemode(path)` typically returns `0o666`, so this
-                # addition of the execute bit for the user is doubly needed.
-                chmod(tmppath_so, filemode(path) & 0o777 | 0o331)
-            end
 
             # prune the directory with cache files
             if pkg.uuid !== nothing

From 0887a33a949bf46df234ce692b462d077328cc18 Mon Sep 17 00:00:00 2001
From: Fons van der Plas <fonsvdplas@gmail.com>
Date: Tue, 31 Oct 2023 12:53:10 +0100
Subject: [PATCH 0135/1315] Docs: file: list `read` and `write` again (#49838)

Point 5 of https://github.com/JuliaLang/julia/issues/43428

Motivation: I feel like the most fundamental *file* operations in Julia
are `read(filename::String)` and `write(filename::String, content)`, so
it makes sense to repeat their documentation in the **Filesystem**
documentation. I also see
these methods as fundamental to teach beginners.


Like https://github.com/JuliaLang/julia/pull/49837, the goal is to only
show short docstrings for these methods, not the whole `IOStream`
functionality. So it depends on
https://github.com/JuliaLang/julia/pull/49835 and
https://github.com/JuliaLang/julia/pull/49836 to be useful :)
---
 doc/src/base/file.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/doc/src/base/file.md b/doc/src/base/file.md
index 9a9dc5d8a72f8..22799f882bb26 100644
--- a/doc/src/base/file.md
+++ b/doc/src/base/file.md
@@ -1,6 +1,8 @@
 # Filesystem
 
 ```@docs
+Base.read(::String)
+Base.write(::String, ::Any)
 Base.Filesystem.pwd
 Base.Filesystem.cd(::AbstractString)
 Base.Filesystem.cd(::Function)

From 2253cdf46444676bda962df0ac25590009c684fc Mon Sep 17 00:00:00 2001
From: Takafumi Arakaki <aka.tkf@gmail.com>
Date: Tue, 31 Oct 2023 22:01:28 +0900
Subject: [PATCH 0136/1315] Some extended documentation for
 `Core.Compiler.return_type` usage as `promote_op` (#44340)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/promotion.jl | 96 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/base/promotion.jl b/base/promotion.jl
index a1438267763ae..16769f8566b92 100644
--- a/base/promotion.jl
+++ b/base/promotion.jl
@@ -492,10 +492,106 @@ end
 Guess what an appropriate container eltype would be for storing results of
 `f(::argtypes...)`. The guess is in part based on type inference, so can change any time.
 
+Accordingly, return a type `R` such that `f(args...) isa R` where `args isa T`.
+
 !!! warning
     Due to its fragility, use of `promote_op` should be avoided. It is preferable to base
     the container eltype on the type of the actual elements. Only in the absence of any
     elements (for an empty result container), it may be unavoidable to call `promote_op`.
+
+The type `R` obtained from `promote_op` is merely an upper bound. There may exist a stricter
+type `S` such that `f(args...) isa S` for every `args isa T` with `S <: R` and `S != R`.
+Furthermore, the exact type `R` obtained from `promote_op` depends on various factors
+including but not limited to the exact Julia version used, packages loaded, and command line
+options. As such, when used in publicly registered packages, **it is the package authors'
+responsibility to ensure that the API guarantees provided by the package do not depend on
+the exact type `R` obtained from `promote_op`.**
+
+Additionally, the result may return overly exact types, such as `DataType`, `Type`, or
+`Union{...}`, while the desired inputs or outputs may be different from those. The internal
+`promote_typejoin_union` function may be helpful to improve the result in some of these
+cases.
+
+# Extended help
+
+## Examples
+
+The following function is an invalid use-case of `promote_op`.
+
+```julia
+\"""
+    invalid_usecase1(f, xs::AbstractArray) -> ys::Array
+
+Return an array `ys` such that `vec(ys)` is `isequal`-equivalent to
+
+    [f(xs[1]), f(xs[2]), ..., f(xs[end])]
+\"""
+function invalid_usecase1(f, xs)
+    R = promote_op(f, eltype(xs))
+    ys = similar(xs, R)
+    for i in eachindex(xs, ys)
+        ys[i] = f(xs[i])
+    end
+    return ys
+end
+```
+
+This is because the value obtained through `eltype(invalid_usecase1(f, xs))` depends on
+exactly what `promote_op` returns. It may be improved by re-computing the element type
+before returning the result.
+
+```julia
+function valid_usecase1(f, xs)
+    R = promote_typejoin_union(promote_op(f, eltype(xs)))
+    ys = similar(xs, R)
+    S = Union{}
+    for i in eachindex(xs, ys)
+        ys[i] = f(xs[i])
+        S = promote_type(S, typeof(ys[i]))
+    end
+    if S != R
+        zs = similar(xs, S)
+        copyto!(zs, ys)
+        return zs
+    end
+    return ys
+end
+```
+
+Note that using [`isconcretetype`](@ref) on the result is not enough to safely use
+`promote_op`. The following function is another invalid use-case of `promote_op`.
+
+```julia
+function invalid_usecase2(f, xs)
+    R = promote_op(f, eltype(xs))
+    if isconcretetype(R)
+        ys = similar(xs, R)
+    else
+        ys = similar(xs, Any)
+    end
+    for i in eachindex(xs, ys)
+        ys[i] = f(xs[i])
+    end
+    return ys
+end
+```
+
+This is because whether or not the caller gets `Any` element type depends on if `promote_op`
+can infer a concrete return type of the given function. A fix similar to `valid_usecase1`
+can be used.
+
+*Technically*, another possible fix for `invalid_usecase1` and `invalid_usecase2` is to
+loosen the API guarantee:
+
+>     another_valid_usecase1(f, xs::AbstractArray) -> ys::Array
+>
+> Return an array `ys` such that every element in `xs` with the same index
+> is mapped with `f`.
+>
+> The element type of `ys` is _undefined_. It must not be used with generic
+> functions whose behavior depend on the element type of `ys`.
+
+However, it is discouraged to define such unconventional API guarantees.
 """
 function promote_op(f, S::Type...)
     argT = TupleOrBottom(S...)

From 5ae88f51f503b24116b36ba31a7cc204944ba6b2 Mon Sep 17 00:00:00 2001
From: Suavesito <jose.zubieta@cimat.mx>
Date: Tue, 31 Oct 2023 07:02:17 -0600
Subject: [PATCH 0137/1315] improve `Union` docs as discused in discourse
 (#45109)

Co-authored-by: Viral B. Shah <ViralBShah@users.noreply.github.com>
Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/docs/basedocs.jl | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 795d3ef1ee5d3..f6942a8d4e9e8 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -2857,23 +2857,33 @@ kw"Union{}", Base.Bottom
 """
     Union{Types...}
 
-A type union is an abstract type which includes all instances of any of its argument types. The empty
-union [`Union{}`](@ref) is the bottom type of Julia.
+A `Union` type is an abstract type which includes all instances of any of its argument types.
+This means that `T <: Union{T,S}` and `S <: Union{T,S}`.
+
+Like other abstract types, it cannot be instantiated, even if all of its arguments are non
+abstract.
 
 # Examples
 ```jldoctest
 julia> IntOrString = Union{Int,AbstractString}
 Union{Int64, AbstractString}
 
-julia> 1 isa IntOrString
+julia> 1 isa IntOrString # instance of Int is included in the union
 true
 
-julia> "Hello!" isa IntOrString
+julia> "Hello!" isa IntOrString # String is also included
 true
 
-julia> 1.0 isa IntOrString
+julia> 1.0 isa IntOrString # Float64 is not included because it is neither Int nor AbstractString
 false
 ```
+
+# Extended Help
+
+Unlike most other parametric types, unions are covariant in their parameters. For example,
+`Union{Real, String}` is a subtype of `Union{Number, AbstractString}`.
+
+The empty union [`Union{}`](@ref) is the bottom type of Julia.
 """
 Union
 

From 69a4ecb3148f130aa85546b04bcdc69d6cafcd63 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 31 Oct 2023 13:09:38 -0400
Subject: [PATCH 0138/1315] IO: fix API safety issue for Ptr (#51949)

Align the API for Ref with the new definition for AbstractArray (#49769)
and ensure this API does not accept raw Ptr as input.

Refs #42593
---
 base/io.jl   | 29 +++++++++++++++++++++++------
 test/read.jl | 18 ++++++++++++++++++
 2 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/base/io.jl b/base/io.jl
index bc87f5df9be7b..a2e68882bbc86 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -780,10 +780,17 @@ end
 @noinline unsafe_write(s::IO, p::Ref{T}, n::Integer) where {T} =
     unsafe_write(s, unsafe_convert(Ref{T}, p)::Ptr, n) # mark noinline to ensure ref is gc-rooted somewhere (by the caller)
 unsafe_write(s::IO, p::Ptr, n::Integer) = unsafe_write(s, convert(Ptr{UInt8}, p), convert(UInt, n))
-write(s::IO, x::Ref{T}) where {T} = unsafe_write(s, x, Core.sizeof(T))
+function write(s::IO, x::Ref{T}) where {T}
+    x isa Ptr && error("write cannot copy from a Ptr")
+    if isbitstype(T)
+        unsafe_write(s, x, Core.sizeof(T))
+    else
+        write(s, x[])
+    end
+end
 write(s::IO, x::Int8) = write(s, reinterpret(UInt8, x))
 function write(s::IO, x::Union{Int16,UInt16,Int32,UInt32,Int64,UInt64,Int128,UInt128,Float16,Float32,Float64})
-    return write(s, Ref(x))
+    return unsafe_write(s, Ref(x), Core.sizeof(x))
 end
 
 write(s::IO, x::Bool) = write(s, UInt8(x))
@@ -797,7 +804,7 @@ function write(s::IO, A::AbstractArray)
     r = Ref{eltype(A)}()
     for a in A
         r[] = a
-        nb += @noinline unsafe_write(s, r, sizeof(r)) # r must be heap-allocated
+        nb += @noinline unsafe_write(s, r, Core.sizeof(r)) # r must be heap-allocated
     end
     return nb
 end
@@ -861,11 +868,21 @@ end
 
 @noinline unsafe_read(s::IO, p::Ref{T}, n::Integer) where {T} = unsafe_read(s, unsafe_convert(Ref{T}, p)::Ptr, n) # mark noinline to ensure ref is gc-rooted somewhere (by the caller)
 unsafe_read(s::IO, p::Ptr, n::Integer) = unsafe_read(s, convert(Ptr{UInt8}, p), convert(UInt, n))
-read!(s::IO, x::Ref{T}) where {T} = (unsafe_read(s, x, Core.sizeof(T)); x)
+function read!(s::IO, x::Ref{T}) where {T}
+    x isa Ptr && error("read! cannot copy into a Ptr")
+    if isbitstype(T)
+        unsafe_read(s, x, Core.sizeof(T))
+    else
+        x[] = read(s, T)
+    end
+    return x
+end
 
 read(s::IO, ::Type{Int8}) = reinterpret(Int8, read(s, UInt8))
 function read(s::IO, T::Union{Type{Int16},Type{UInt16},Type{Int32},Type{UInt32},Type{Int64},Type{UInt64},Type{Int128},Type{UInt128},Type{Float16},Type{Float32},Type{Float64}})
-    return read!(s, Ref{T}(0))[]::T
+    r = Ref{T}(0)
+    unsafe_read(s, r, Core.sizeof(T))
+    return r[]
 end
 
 read(s::IO, ::Type{Bool}) = (read(s, UInt8) != 0)
@@ -878,7 +895,7 @@ function read!(s::IO, A::AbstractArray{T}) where {T}
         if isbitstype(T)
             r = Ref{T}()
             for i in eachindex(A)
-                @noinline unsafe_read(s, r, sizeof(r)) # r must be heap-allocated
+                @noinline unsafe_read(s, r, Core.sizeof(r)) # r must be heap-allocated
                 A[i] = r[]
             end
         else
diff --git a/test/read.jl b/test/read.jl
index 3f22dd55a507a..283381668c28a 100644
--- a/test/read.jl
+++ b/test/read.jl
@@ -720,3 +720,21 @@ end
         @test isempty(r) && isempty(collect(r))
     end
 end
+
+@testset "Ref API" begin
+    io = PipeBuffer()
+    @test write(io, Ref{Any}(0xabcd_1234)) === 4
+    @test read(io, UInt32) === 0xabcd_1234
+    @test_throws ErrorException("write cannot copy from a Ptr") invoke(write, Tuple{typeof(io), Ref{Cvoid}}, io, C_NULL)
+    @test_throws ErrorException("write cannot copy from a Ptr") invoke(write, Tuple{typeof(io), Ref{Int}}, io, Ptr{Int}(0))
+    @test_throws ErrorException("write cannot copy from a Ptr") invoke(write, Tuple{typeof(io), Ref{Any}}, io, Ptr{Any}(0))
+    @test_throws ErrorException("read! cannot copy into a Ptr") read!(io, C_NULL)
+    @test_throws ErrorException("read! cannot copy into a Ptr") read!(io, Ptr{Int}(0))
+    @test_throws ErrorException("read! cannot copy into a Ptr") read!(io, Ptr{Any}(0))
+    @test eof(io)
+    @test write(io, C_NULL) === sizeof(Int)
+    @test write(io, Ptr{Int}(4)) === sizeof(Int)
+    @test write(io, Ptr{Any}(5)) === sizeof(Int)
+    @test read!(io, Int[1, 2, 3]) == [0, 4, 5]
+    @test eof(io)
+end

From f6315973a200a84e5d2831c38b9dc8372204af44 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 31 Oct 2023 13:10:55 -0400
Subject: [PATCH 0139/1315] minor cleanups to MemoryRef (#51937)

---
 base/abstractarray.jl       |  2 ++
 base/array.jl               | 20 ++++++++++----------
 base/genericmemory.jl       |  9 ++++++++-
 doc/src/manual/embedding.md |  4 ++--
 stdlib/Base64/src/buffer.jl | 22 +++++++++++-----------
 5 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 881070ff7aa00..4a35c1a2eb9db 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1034,6 +1034,8 @@ the other elements are left untouched.
 
 See also [`copy!`](@ref Base.copy!), [`copy`](@ref).
 
+$(_DOCS_ALIASING_WARNING)
+
 # Examples
 ```jldoctest
 julia> x = [1., 0., 3., 0., 5.];
diff --git a/base/array.jl b/base/array.jl
index 920e51d37be22..6d59c2f3b41d5 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -276,8 +276,6 @@ source and `do` in the destination (1-indexed).
 The `unsafe` prefix on this function indicates that no validation is performed to ensure
 that N is inbounds on either array. Incorrect usage may corrupt or segfault your program, in
 the same manner as C.
-
-$(_DOCS_ALIASING_WARNING)
 """
 function unsafe_copyto!(dest::Array, doffs, src::Array, soffs, n)
     n == 0 && return dest
@@ -291,24 +289,26 @@ end
 Copy `N` elements from collection `src` starting at the linear index `so`, to array `dest` starting at
 the index `do`. Return `dest`.
 """
-function copyto!(dest::Array, doffs::Integer, src::Array, soffs::Integer, n::Integer)
-    return _copyto_impl!(dest, doffs, src, soffs, n)
-end
+copyto!(dest::Array, doffs::Integer, src::Array, soffs::Integer, n::Integer) = _copyto_impl!(dest, doffs, src, soffs, n)
+copyto!(dest::Array, doffs::Integer, src::Memory, soffs::Integer, n::Integer) = _copyto_impl!(dest, doffs, src, soffs, n)
+copyto!(dest::Memory, doffs::Integer, src::Array, soffs::Integer, n::Integer) = _copyto_impl!(dest, doffs, src, soffs, n)
 
 # this is only needed to avoid possible ambiguities with methods added in some packages
-function copyto!(dest::Array{T}, doffs::Integer, src::Array{T}, soffs::Integer, n::Integer) where T
-    return _copyto_impl!(dest, doffs, src, soffs, n)
-end
+copyto!(dest::Array{T}, doffs::Integer, src::Array{T}, soffs::Integer, n::Integer) where {T} = _copyto_impl!(dest, doffs, src, soffs, n)
 
-function _copyto_impl!(dest::Array, doffs::Integer, src::Array, soffs::Integer, n::Integer)
+function _copyto_impl!(dest::Union{Array,Memory}, doffs::Integer, src::Union{Array,Memory}, soffs::Integer, n::Integer)
     n == 0 && return dest
     n > 0 || _throw_argerror("Number of elements to copy must be non-negative.")
     @boundscheck checkbounds(dest, doffs:doffs+n-1)
     @boundscheck checkbounds(src, soffs:soffs+n-1)
-    unsafe_copyto!(dest, doffs, src, soffs, n)
+    @inbounds let dest = GenericMemoryRef(dest isa Array ? getfield(dest, :ref) : dest, doffs)
+                  src = GenericMemoryRef(src isa Array ? getfield(src, :ref) : src, soffs)
+        unsafe_copyto!(dest, src, n)
+    end
     return dest
 end
 
+
 # Outlining this because otherwise a catastrophic inference slowdown
 # occurs, see discussion in #27874.
 # It is also mitigated by using a constant string.
diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index e9ec11292ed77..009948188fe97 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -68,7 +68,7 @@ end
 @eval isassigned(a::GenericMemoryRef) = memoryref_isassigned(a, :not_atomic, $(Expr(:boundscheck)))
 
 ## copy ##
-@eval function unsafe_copyto!(dest::MemoryRef{T}, src::MemoryRef{T}, n) where {T}
+function unsafe_copyto!(dest::MemoryRef{T}, src::MemoryRef{T}, n) where {T}
     @_terminates_globally_meta
     n == 0 && return dest
     @boundscheck GenericMemoryRef(dest, n), GenericMemoryRef(src, n)
@@ -118,6 +118,13 @@ end
 
 copy(a::T) where {T<:Memory} = ccall(:jl_genericmemory_copy, Ref{T}, (Any,), a)
 
+function copyto!(dest::Memory, doffs::Integer, src::Memory, soffs::Integer, n::Integer)
+    n < 0 && _throw_argerror("Number of elements to copy must be non-negative.")
+    unsafe_copyto!(dest, doffs, src, soffs, n)
+    return dest
+end
+
+
 ## Constructors ##
 
 similar(a::Memory{T}) where {T}                   = Memory{T}(undef, length(a))
diff --git a/doc/src/manual/embedding.md b/doc/src/manual/embedding.md
index 60a768788bbb7..f59dee225e1a7 100644
--- a/doc/src/manual/embedding.md
+++ b/doc/src/manual/embedding.md
@@ -432,14 +432,14 @@ object has just been allocated and no garbage collection has run since then. Not
 `jl_...` functions can sometimes invoke garbage collection.
 
 The write barrier is also necessary for arrays of pointers when updating their data directly.
-For example:
+Calling `jl_array_ptr_set` is usually much preferred. But direct updates can be done. For example:
 
 ```c
 jl_array_t *some_array = ...; // e.g. a Vector{Any}
 void **data = jl_array_data(some_array, void*);
 jl_value_t *some_value = ...;
 data[0] = some_value;
-jl_gc_wb(some_array, some_value);
+jl_gc_wb(jl_array_owner(some_array), some_value);
 ```
 
 ### Controlling the Garbage Collector
diff --git a/stdlib/Base64/src/buffer.jl b/stdlib/Base64/src/buffer.jl
index bc8c338bad19d..009a6d56cfde8 100644
--- a/stdlib/Base64/src/buffer.jl
+++ b/stdlib/Base64/src/buffer.jl
@@ -2,37 +2,37 @@
 
 # Data buffer for pipes.
 mutable struct Buffer
-    data::Memory{UInt8}
-    ptr::Ptr{UInt8}
+    const data::Memory{UInt8}
+    offset::Int
     size::Int
 
     function Buffer(bufsize)
         data = Memory{UInt8}(undef, bufsize)
-        return new(data, pointer(data), 0)
+        return new(data, 0, 0)
     end
 end
 
 Base.empty!(buffer::Buffer) = buffer.size = 0
-Base.getindex(buffer::Buffer, i::Integer) = unsafe_load(buffer.ptr, i)
-Base.setindex!(buffer::Buffer, v::UInt8, i::Integer) = unsafe_store!(buffer.ptr, v, i)
+Base.getindex(buffer::Buffer, i::Integer) = buffer.data[buffer.offset + i]
+Base.setindex!(buffer::Buffer, v::UInt8, i::Integer) = buffer.data[buffer.offset + i] = v
 Base.firstindex(buffer::Buffer) = 1
 Base.lastindex(buffer::Buffer) = buffer.size
-Base.pointer(buffer::Buffer) = buffer.ptr
-capacity(buffer::Buffer) = Int(pointer(buffer.data, lastindex(buffer.data)) - buffer.ptr) + 1
+Base.pointer(buffer::Buffer) = pointer(buffer.data) + buffer.offset
+capacity(buffer::Buffer) = length(buffer.data) - buffer.offset
 
 function consumed!(buffer::Buffer, n::Integer)
     @assert n ≤ buffer.size
-    buffer.ptr += n
+    buffer.offset += n
     buffer.size -= n
 end
 
 function read_to_buffer(io::IO, buffer::Buffer)
-    offset = buffer.ptr - pointer(buffer.data)
+    offset = buffer.offset
     copyto!(buffer.data, 1, buffer.data, offset + 1, buffer.size)
-    buffer.ptr = pointer(buffer.data)
+    buffer.offset = 0
     if !eof(io)
         n = min(bytesavailable(io), capacity(buffer) - buffer.size)
-        unsafe_read(io, buffer.ptr + buffer.size, n)
+        unsafe_read(io, pointer(buffer) + buffer.size, n)
         buffer.size += n
     end
     return

From 301f262692be5a230ffefae243656f34535389d6 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <kshyatt@users.noreply.github.com>
Date: Tue, 31 Oct 2023 16:26:14 -0400
Subject: [PATCH 0140/1315] Add a doctest for timedwait (#49686)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/asyncevent.jl | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/base/asyncevent.jl b/base/asyncevent.jl
index 791c78b5a32ce..3c782be10e194 100644
--- a/base/asyncevent.jl
+++ b/base/asyncevent.jl
@@ -327,11 +327,24 @@ end
 """
     timedwait(testcb, timeout::Real; pollint::Real=0.1)
 
-Waits until `testcb()` returns `true` or `timeout` seconds have passed, whichever is earlier.
+Wait until `testcb()` returns `true` or `timeout` seconds have passed, whichever is earlier.
 The test function is polled every `pollint` seconds. The minimum value for `pollint` is 0.001 seconds,
 that is, 1 millisecond.
 
 Return `:ok` or `:timed_out`.
+
+# Examples
+```jldoctest
+julia> cb() = (sleep(5); return);
+
+julia> t = @async cb();
+
+julia> timedwait(()->istaskdone(t), 1)
+:timed_out
+
+julia> timedwait(()->istaskdone(t), 6.5)
+:ok
+```
 """
 function timedwait(testcb, timeout::Real; pollint::Real=0.1)
     pollint >= 1e-3 || throw(ArgumentError("pollint must be ≥ 1 millisecond"))

From 2b73a1d6c64258fdbfa3d44cc2604e841b666120 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Leandro=20Mart=C3=ADnez?=
 <31046348+lmiq@users.noreply.github.com>
Date: Tue, 31 Oct 2023 17:27:20 -0300
Subject: [PATCH 0141/1315] clarify assert doc entry (#45998)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
---
 base/error.jl | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/base/error.jl b/base/error.jl
index fa020f4823cbd..37ceb39253e38 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -197,15 +197,17 @@ windowserror(p, code::UInt32=Libc.GetLastError(); extrainfo=nothing) = throw(Mai
 """
     @assert cond [text]
 
-Throw an [`AssertionError`](@ref) if `cond` is `false`. Preferred syntax for writing assertions.
-Message `text` is optionally displayed upon assertion failure.
+Throw an [`AssertionError`](@ref) if `cond` is `false`. This is the preferred syntax for
+writing assertions, which are conditions that are assumed to be true, but that the user
+might decide to check anyways, as an aid to debugging if they fail.
+The optional message `text` is displayed upon assertion failure.
 
 !!! warning
-    An assert might be disabled at various optimization levels.
+    An assert might be disabled at some optimization levels.
     Assert should therefore only be used as a debugging tool
-    and not used for authentication verification (e.g., verifying passwords),
-    nor should side effects needed for the function to work correctly
-    be used inside of asserts.
+    and not used for authentication verification (e.g., verifying passwords or checking array bounds).
+    The code must not rely on the side effects of running `cond` for the correct behavior
+    of a function.
 
 # Examples
 ```jldoctest

From 2f63cc99fb134fb4adb7f11ba86a4e2ab5adcd48 Mon Sep 17 00:00:00 2001
From: Jerry Ling <proton@jling.dev>
Date: Tue, 31 Oct 2023 20:58:02 -0400
Subject: [PATCH 0142/1315] Fix error when dump() a partial NamedTuple (#51947)

---
 base/show.jl | 7 +++++--
 test/show.jl | 3 +++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/base/show.jl b/base/show.jl
index 079bf5a423cc0..eb9f7bcece49d 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -2990,8 +2990,11 @@ function dump(io::IOContext, x::DataType, n::Int, indent)
         fieldtypes = datatype_fieldtypes(x)
         for idx in 1:length(fields)
             println(io)
-            print(io, indent, "  ", fields[idx], "::")
-            print(tvar_io, fieldtypes[idx])
+            print(io, indent, "  ", fields[idx])
+            if isassigned(fieldtypes, idx)
+                print(io, "::")
+                print(tvar_io, fieldtypes[idx])
+            end
         end
     end
     nothing
diff --git a/test/show.jl b/test/show.jl
index 0e11552f484ee..934a4bbd2ce48 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1314,6 +1314,9 @@ let a = Vector{Any}(undef, 10000)
 end
 @test occursin("NamedTuple", sprint(dump, NamedTuple))
 
+# issue 36495, dumping a partial NamedTupled shouldn't error
+@test occursin("NamedTuple", sprint(dump, NamedTuple{(:foo,:bar)}))
+
 # issue #17338
 @test repr(Core.svec(1, 2)) == "svec(1, 2)"
 

From 3a6c4186f8383e39a8ad482c7e53336e98d68dcf Mon Sep 17 00:00:00 2001
From: Haakon Ludvig Langeland Ervik
 <45243236+haakon-e@users.noreply.github.com>
Date: Tue, 31 Oct 2023 19:28:12 -0700
Subject: [PATCH 0143/1315] update doc references (#48162)

---
 base/reflection.jl                              | 4 ++--
 stdlib/InteractiveUtils/src/InteractiveUtils.jl | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index 7bb77b316b434..e0764ee761a3e 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1187,7 +1187,7 @@ A list of modules can also be specified as an array.
 !!! compat "Julia 1.4"
     At least Julia 1.4 is required for specifying a module.
 
-See also: [`which`](@ref) and `@which`.
+See also: [`which`](@ref), [`@which`](@ref Main.InteractiveUtils.@which) and [`methodswith`](@ref Main.InteractiveUtils.methodswith).
 """
 function methods(@nospecialize(f), @nospecialize(t),
                  mod::Union{Tuple{Module},AbstractArray{Module},Nothing}=nothing)
@@ -1898,7 +1898,7 @@ Returns the method of `f` (a `Method` object) that would be called for arguments
 
 If `types` is an abstract type, then the method that would be called by `invoke` is returned.
 
-See also: [`parentmodule`](@ref), and `@which` and `@edit` in [`InteractiveUtils`](@ref man-interactive-utils).
+See also: [`parentmodule`](@ref), [`@which`](@ref Main.InteractiveUtils.@which), and [`@edit`](@ref Main.InteractiveUtils.@edit).
 """
 function which(@nospecialize(f), @nospecialize(t))
     tt = signature_type(f, t)
diff --git a/stdlib/InteractiveUtils/src/InteractiveUtils.jl b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
index 5d6114913bf71..629cf88cd8ce6 100644
--- a/stdlib/InteractiveUtils/src/InteractiveUtils.jl
+++ b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
@@ -201,6 +201,8 @@ The optional second argument restricts the search to a particular module or func
 
 If keyword `supertypes` is `true`, also return arguments with a parent type of `typ`,
 excluding type `Any`.
+
+See also: [`methods`](@ref).
 """
 function methodswith(@nospecialize(t::Type), @nospecialize(f::Base.Callable), meths = Method[]; supertypes::Bool=false)
     for d in methods(f)

From 072896dd0d48373816713f0225e69a15206b6eee Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 25 Oct 2023 02:01:05 +0000
Subject: [PATCH 0144/1315] Don't use 0x80 as a magic constant

Introduce UNION_BOX_MARKER, to make it easier to grep for all the places
where this is being looked at and distinguish them from other uses of
0x80 as a constant.
---
 src/cgutils.cpp | 10 ++++----
 src/codegen.cpp | 63 +++++++++++++++++++++++++------------------------
 2 files changed, 37 insertions(+), 36 deletions(-)

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index e0e48ddf81d53..5338ad2357f41 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1250,7 +1250,7 @@ static Value *emit_sizeof(jl_codectx_t &ctx, const jl_cgval_t &p)
             BasicBlock *dynloadBB = BasicBlock::Create(ctx.builder.getContext(), "dyn_sizeof", ctx.f);
             BasicBlock *postBB = BasicBlock::Create(ctx.builder.getContext(), "post_sizeof", ctx.f);
             Value *isboxed = ctx.builder.CreateICmpNE(
-                    ctx.builder.CreateAnd(p.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                    ctx.builder.CreateAnd(p.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                     ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
             ctx.builder.CreateCondBr(isboxed, dynloadBB, postBB);
             ctx.builder.SetInsertPoint(dynloadBB);
@@ -1551,14 +1551,14 @@ static Value *emit_exactly_isa(jl_codectx_t &ctx, const jl_cgval_t &arg, jl_data
         unsigned tindex = get_box_tindex(dt, arg.typ);
         if (tindex > 0) {
             // optimize more when we know that this is a split union-type where tindex = 0 is invalid
-            Value *xtindex = ctx.builder.CreateAnd(arg.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x7f));
+            Value *xtindex = ctx.builder.CreateAnd(arg.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), ~UNION_BOX_MARKER));
             auto isa = ctx.builder.CreateICmpEQ(xtindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), tindex));
             setName(ctx.emission_context, isa, "exactly_isa");
             return isa;
         }
         else if (arg.Vboxed) {
-            // test for (arg.TIndex == 0x80 && typeof(arg.V) == type)
-            Value *isboxed = ctx.builder.CreateICmpEQ(arg.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80));
+            // test for (arg.TIndex == UNION_BOX_MARKER && typeof(arg.V) == type)
+            Value *isboxed = ctx.builder.CreateICmpEQ(arg.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER));
             setName(ctx.emission_context, isboxed, "isboxed");
             BasicBlock *currBB = ctx.builder.GetInsertBlock();
             BasicBlock *isaBB = BasicBlock::Create(ctx.builder.getContext(), "isa", ctx.f);
@@ -3152,7 +3152,7 @@ static AllocaInst *try_emit_union_alloca(jl_codectx_t &ctx, jl_uniontype_t *ut,
  * returning `Constant::getNullValue(ctx.types().T_pjlvalue)` in one of the skipped cases. If `skip` is not empty,
  * skip[0] (corresponding to unknown boxed) must always be set. In that
  * case, the calling code must separately deal with the case where
- * `vinfo` is already an unknown boxed union (union tag 0x80).
+ * `vinfo` is already an unknown boxed union (union tag UNION_BOX_MARKER).
  */
 // Returns ctx.types().T_prjlvalue
 static Value *box_union(jl_codectx_t &ctx, const jl_cgval_t &vinfo, const SmallBitVector &skip)
diff --git a/src/codegen.cpp b/src/codegen.cpp
index ca179817d4e1f..8cabe34100390 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1582,11 +1582,12 @@ struct jl_aliasinfo_t {
 };
 
 // metadata tracking for a llvm Value* during codegen
+const uint8_t UNION_BOX_MARKER = 0x80;
 struct jl_cgval_t {
     Value *V; // may be of type T* or T, or set to NULL if ghost (or if the value has not been initialized yet, for a variable definition)
     // For unions, we may need to keep a reference to the boxed part individually.
     // If this is non-NULL, then, at runtime, we satisfy the invariant that (for the corresponding
-    // runtime values) if `(TIndex | 0x80) != 0`, then `Vboxed == V` (by value).
+    // runtime values) if `(TIndex | UNION_BOX_MARKER) != 0`, then `Vboxed == V` (by value).
     // For convenience, we also set this value of isboxed values, in which case
     // it is equal (at compile time) to V.
     // If this is non-NULL, it is always of type `T_prjlvalue`
@@ -2247,7 +2248,7 @@ static void CreateConditionalAbort(IRBuilder<> &irbuilder, Value *test)
 static jl_cgval_t convert_julia_type_union(jl_codectx_t &ctx, const jl_cgval_t &v, jl_value_t *typ, Value **skip)
 {
     // previous value was a split union, compute new index, or box
-    Value *new_tindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80);
+    Value *new_tindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER);
     SmallBitVector skip_box(1, true);
     Value *tindex = ctx.builder.CreateAnd(v.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x7f));
     if (jl_is_uniontype(typ)) {
@@ -2290,14 +2291,14 @@ static jl_cgval_t convert_julia_type_union(jl_codectx_t &ctx, const jl_cgval_t &
     // some of the values are still unboxed
     if (!isa<Constant>(new_tindex)) {
         Value *wasboxed = NULL;
-        // If the old value was boxed and unknown (type tag 0x80),
+        // If the old value was boxed and unknown (type tag UNION_BOX_MARKER),
         // it is possible that the tag was actually one of the types
         // that are now explicitly represented. To find out, we need
         // to compare typeof(v.Vboxed) (i.e. the type of the unknown
         // value) against all the types that are now explicitly
         // selected and select the appropriate one as our new tindex.
         if (v.Vboxed) {
-            wasboxed = ctx.builder.CreateAnd(v.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80));
+            wasboxed = ctx.builder.CreateAnd(v.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER));
             new_tindex = ctx.builder.CreateOr(wasboxed, new_tindex);
             wasboxed = ctx.builder.CreateICmpNE(wasboxed, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
             setName(ctx.emission_context, wasboxed, "wasboxed");
@@ -2319,10 +2320,10 @@ static jl_cgval_t convert_julia_type_union(jl_codectx_t &ctx, const jl_cgval_t &
             };
 
             // If we don't find a match. The type remains unknown
-            // (0x80). We could use `v.Tindex`, here, since we know
-            // it has to be 0x80, but it seems likely the backend
+            // (UNION_BOX_MARKER). We could use `v.Tindex`, here, since we know
+            // it has to be UNION_BOX_MARKER, but it seems likely the backend
             // will like the explicit constant better.
-            Value *union_box_tindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80);
+            Value *union_box_tindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER);
             unsigned counter = 0;
             for_each_uniontype_small(
                 // for each new union-split value
@@ -2332,7 +2333,7 @@ static jl_cgval_t convert_julia_type_union(jl_codectx_t &ctx, const jl_cgval_t &
                         // didn't handle this item before, select its new union index
                         maybe_setup_union_isa();
                         Value *cmp = ctx.builder.CreateICmpEQ(emit_tagfrom(ctx, jt), union_box_dt);
-                        union_box_tindex = ctx.builder.CreateSelect(cmp, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80 | idx), union_box_tindex);
+                        union_box_tindex = ctx.builder.CreateSelect(cmp, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER | idx), union_box_tindex);
                     }
                 },
                 typ,
@@ -2342,7 +2343,7 @@ static jl_cgval_t convert_julia_type_union(jl_codectx_t &ctx, const jl_cgval_t &
                 BasicBlock *postBB = BasicBlock::Create(ctx.builder.getContext(), "post_union_isa", ctx.f);
                 ctx.builder.CreateBr(postBB);
                 ctx.builder.SetInsertPoint(currBB);
-                Value *wasunknown = ctx.builder.CreateICmpEQ(v.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80));
+                Value *wasunknown = ctx.builder.CreateICmpEQ(v.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER));
                 ctx.builder.CreateCondBr(wasunknown, union_isaBB, postBB);
                 ctx.builder.SetInsertPoint(postBB);
                 PHINode *tindex_phi = ctx.builder.CreatePHI(getInt8Ty(ctx.builder.getContext()), 2);
@@ -2354,14 +2355,14 @@ static jl_cgval_t convert_julia_type_union(jl_codectx_t &ctx, const jl_cgval_t &
         }
         if (!skip_box.all()) {
             // some values weren't unboxed in the new union
-            // box them now (tindex above already selected 0x80 = box for them)
+            // box them now (tindex above already selected UNION_BOX_MARKER = box for them)
             Value *boxv = box_union(ctx, v, skip_box);
             if (v.Vboxed) {
                 // If the value is boxed both before and after, we don't need
                 // to touch it at all. Otherwise we're either transitioning
                 // unboxed->boxed, or leaving an unboxed value in place.
                 Value *isboxed = ctx.builder.CreateICmpNE(
-                    ctx.builder.CreateAnd(new_tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                    ctx.builder.CreateAnd(new_tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                     ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
                 boxv = ctx.builder.CreateSelect(
                     ctx.builder.CreateAnd(wasboxed, isboxed), v.Vboxed, boxv);
@@ -2395,7 +2396,7 @@ static jl_cgval_t convert_julia_type_union(jl_codectx_t &ctx, const jl_cgval_t &
 }
 
 // given a value marked with type `v.typ`, compute the mapping and/or boxing to return a value of type `typ`
-// TODO: should this set TIndex when trivial (such as 0x80 or concrete types) ?
+// TODO: should this set TIndex when trivial (such as UNION_BOX_MARKER or concrete types) ?
 static jl_cgval_t convert_julia_type(jl_codectx_t &ctx, const jl_cgval_t &v, jl_value_t *typ, Value **skip)
 {
     if (typ == (jl_value_t*)jl_typeofbottom_type)
@@ -4471,7 +4472,7 @@ static jl_cgval_t emit_call_specfun_other(jl_codectx_t &ctx, bool is_opaque_clos
             Value *tindex = ctx.builder.CreateExtractValue(call, 1);
             Value *derived = ctx.builder.CreateSelect(
                 ctx.builder.CreateICmpEQ(
-                        ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                        ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                         ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0)),
                 decay_derived(ctx, ctx.builder.CreateBitCast(argvals[0], ctx.types().T_pjlvalue)),
                 decay_derived(ctx, box)
@@ -4952,10 +4953,10 @@ static jl_cgval_t emit_isdefined(jl_codectx_t &ctx, jl_value_t *sym)
             Value *box_isnull = ctx.builder.CreateICmpNE(boxed, Constant::getNullValue(ctx.types().T_prjlvalue));
             if (vi.pTIndex) {
                 // value is either boxed in the stack slot, or unboxed in value
-                // as indicated by testing (pTIndex & 0x80)
+                // as indicated by testing (pTIndex & UNION_BOX_MARKER)
                 Value *tindex = ctx.builder.CreateAlignedLoad(getInt8Ty(ctx.builder.getContext()), vi.pTIndex, Align(sizeof(void*)), vi.isVolatile);
                 Value *load_unbox = ctx.builder.CreateICmpEQ(
-                            ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                            ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                             ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
                 isnull = ctx.builder.CreateSelect(load_unbox, isnull, box_isnull);
             }
@@ -5067,9 +5068,9 @@ static jl_cgval_t emit_varinfo(jl_codectx_t &ctx, jl_varinfo_t &vi, jl_sym_t *va
         maybe_mark_load_dereferenceable(boxed, vi.usedUndef || vi.pTIndex, typ);
         if (vi.pTIndex) {
             // value is either boxed in the stack slot, or unboxed in value
-            // as indicated by testing (pTIndex & 0x80)
+            // as indicated by testing (pTIndex & UNION_BOX_MARKER)
             Value *load_unbox = ctx.builder.CreateICmpEQ(
-                        ctx.builder.CreateAnd(v.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                        ctx.builder.CreateAnd(v.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                         ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
             if (vi.usedUndef)
                 isnull = ctx.builder.CreateSelect(load_unbox, isnull, box_isnull);
@@ -5200,7 +5201,7 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
             PHINode *ptr_phi = PHINode::Create(ctx.types().T_prjlvalue, jl_array_nrows(edges), "ptr_phi");
             BB->getInstList().insert(InsertPt, ptr_phi);
             Value *isboxed = ctx.builder.CreateICmpNE(
-                    ctx.builder.CreateAnd(Tindex_phi, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                    ctx.builder.CreateAnd(Tindex_phi, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                     ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
             ctx.builder.CreateMemCpy(phi, MaybeAlign(min_align), dest, dest->getAlign(), nbytes, false);
             ctx.builder.CreateLifetimeEnd(dest);
@@ -5313,13 +5314,13 @@ static void emit_varinfo_assign(jl_codectx_t &ctx, jl_varinfo_t &vi, jl_cgval_t
         if (rval_info.TIndex) {
             tindex = rval_info.TIndex;
             if (!vi.boxroot)
-                tindex = ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x7f));
+                tindex = ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), ~UNION_BOX_MARKER));
         }
         else {
             assert(rval_info.isboxed || rval_info.constant);
             tindex = compute_tindex_unboxed(ctx, rval_info, vi.value.typ);
             if (vi.boxroot)
-                tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80));
+                tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER));
             else
                 rval_info.TIndex = tindex;
         }
@@ -5333,7 +5334,7 @@ static void emit_varinfo_assign(jl_codectx_t &ctx, jl_varinfo_t &vi, jl_cgval_t
         if (vi.pTIndex && rval_info.TIndex) {
             ctx.builder.CreateStore(rval_info.TIndex, vi.pTIndex, vi.isVolatile);
             isboxed = ctx.builder.CreateICmpNE(
-                    ctx.builder.CreateAnd(rval_info.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                    ctx.builder.CreateAnd(rval_info.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                     ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
             rval = rval_info.Vboxed ? rval_info.Vboxed : Constant::getNullValue(ctx.types().T_prjlvalue);
             assert(rval->getType() == ctx.types().T_prjlvalue);
@@ -5412,7 +5413,7 @@ static void emit_upsilonnode(jl_codectx_t &ctx, ssize_t phic, jl_value_t *val)
             // does need to satisfy the union invariants (i.e. inbounds
             // tindex).
             ctx.builder.CreateAlignedStore(
-                vi.boxroot ? ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80) :
+                vi.boxroot ? ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER) :
                              ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x01),
                 vi.pTIndex, Align(1), true);
         }
@@ -6195,7 +6196,7 @@ static void emit_cfunc_invalidate(
         Type *retty = gf_thunk->getReturnType();
         Value *gf_retval = UndefValue::get(retty);
         Value *tindex = compute_box_tindex(ctx, emit_typeof(ctx, gf_retbox, false, true), (jl_value_t*)jl_any_type, rettype);
-        tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80));
+        tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER));
         gf_retval = ctx.builder.CreateInsertValue(gf_retval, gf_ret, 0);
         gf_retval = ctx.builder.CreateInsertValue(gf_retval, tindex, 1);
         ctx.builder.CreateRet(gf_retval);
@@ -6690,7 +6691,7 @@ static Function* gen_cfun_wrapper(
                 Value *tindex = ctx.builder.CreateExtractValue(call, 1);
                 Value *derived = ctx.builder.CreateSelect(
                     ctx.builder.CreateICmpEQ(
-                            ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                            ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                             ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0)),
                     decay_derived(ctx, ctx.builder.CreateBitCast(result, ctx.types().T_pjlvalue)),
                     decay_derived(ctx, box));
@@ -8516,7 +8517,7 @@ static jl_llvm_functions_t
                         // also need to account for the possibility the return object is boxed
                         // and avoid / skip copying it to the stack
                         isboxed_union = ctx.builder.CreateICmpNE(
-                            ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                            ctx.builder.CreateAnd(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                             ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
                         data = ctx.builder.CreateSelect(isboxed_union, retvalinfo.Vboxed, data);
                     }
@@ -8525,7 +8526,7 @@ static jl_llvm_functions_t
                     // treat this as a simple boxed returninfo
                     //assert(retvalinfo.isboxed);
                     tindex = compute_tindex_unboxed(ctx, retvalinfo, jlrettype);
-                    tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80));
+                    tindex = ctx.builder.CreateOr(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER));
                     data = boxed(ctx, retvalinfo);
                     sret = NULL;
                 }
@@ -8769,7 +8770,7 @@ static jl_llvm_functions_t
                     if (tindex == 0) {
                         if (VN)
                             V = boxed(ctx, val);
-                        RTindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80);
+                        RTindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER);
                     }
                     else {
                         if (VN)
@@ -8791,7 +8792,7 @@ static jl_llvm_functions_t
                         if (dest) {
                             // If dest is not set, this is a ghost union, the recipient of which
                             // is often not prepared to handle a boxed representation of the ghost.
-                            RTindex = ctx.builder.CreateOr(RTindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80));
+                            RTindex = ctx.builder.CreateOr(RTindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER));
                         }
                         new_union.TIndex = RTindex;
                     }
@@ -8799,8 +8800,8 @@ static jl_llvm_functions_t
                         V = new_union.Vboxed ? new_union.Vboxed : Constant::getNullValue(ctx.types().T_prjlvalue);
                     if (dest) { // basically, if !ghost union
                         if (new_union.Vboxed != nullptr) {
-                            Value *isboxed = ctx.builder.CreateICmpNE( // if 0x80 is set, we won't select this slot anyways
-                                    ctx.builder.CreateAnd(RTindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80)),
+                            Value *isboxed = ctx.builder.CreateICmpNE( // if UNION_BOX_MARKER is set, we won't select this slot anyways
+                                    ctx.builder.CreateAnd(RTindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                                     ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
                             skip = skip ? ctx.builder.CreateOr(isboxed, skip) : isboxed;
                         }
@@ -8845,7 +8846,7 @@ static jl_llvm_functions_t
                 Value *undef = undef_value_for_type(VN->getType());
                 VN->addIncoming(undef, FromBB);
                 if (TindexN) // let the runtime / optimizer know this is unknown / boxed / null, so that it won't try to union_move / copy it later
-                    RTindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0x80);
+                    RTindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER);
             }
             if (TindexN)
                 TindexN->addIncoming(RTindex, FromBB);

From b6e178af2d2b52a69005450350850f1f2a8ee8e0 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 1 Nov 2023 14:09:27 +0900
Subject: [PATCH 0145/1315] `AbstractInterpreter`: stash inferred `CodeInfo`
 even when optimization doesn't happen (#51952)

After #51888, `(result::InferenceResult).src` is set to `nothing` in two
situations:

1. When the inference result is limited due to recursion.
2. When optimization is unnecessary as the result is already precise.

This commit allows external `AbstractInterpreter` to differentiate
between these two situations by retaining the inferred source code in
`result.src` for the latter case. This is particularly crucial for the
functionality of JET's analysis.
---
 base/compiler/typeinfer.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index d1f635d3be704..cab02a39c87c1 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -566,6 +566,8 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
         end
         if doopt && may_optimize(interp)
             me.result.src = OptimizationState(me, interp)
+        else
+            me.result.src = me.src # for reflection etc.
         end
     end
     validate_code_in_debug_mode(me.linfo, me.src, "inferred")

From b8f74db336129c18e0ff35a329dc80113784bb7f Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 1 Nov 2023 15:13:55 +0900
Subject: [PATCH 0146/1315] inlining: use `SemiConcreteResult` for `invoke`
 calls (#51933)

---
 base/compiler/ssair/inlining.jl | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 75eb467776236..9d216d6cc7714 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1188,16 +1188,23 @@ function handle_invoke_call!(todo::Vector{Pair{Int,Any}},
         item = concrete_result_item(result, info, state; invokesig)
     else
         argtypes = invoke_rewrite(sig.argtypes)
-        if isa(result, ConstPropResult)
-            mi = result.result.linfo
-            validate_sparams(mi.sparam_vals) || return nothing
-            if Union{} !== argtypes_to_type(argtypes) <: mi.def.sig
-                item = resolve_todo(mi, result.result, argtypes, info, flag, state; invokesig)
-                handle_single_case!(todo, ir, idx, stmt, item, true)
-                return nothing
+        if isa(result, SemiConcreteResult)
+            result = inlining_policy(state.interp, result, info, flag, result.mi, argtypes)
+        end
+        if isa(result, SemiConcreteResult)
+            item = semiconcrete_result_item(result, info, flag, state)
+        else
+            if isa(result, ConstPropResult)
+                mi = result.result.linfo
+                validate_sparams(mi.sparam_vals) || return nothing
+                if Union{} !== argtypes_to_type(argtypes) <: mi.def.sig
+                    item = resolve_todo(mi, result.result, argtypes, info, flag, state; invokesig)
+                    handle_single_case!(todo, ir, idx, stmt, item, true)
+                    return nothing
+                end
             end
+            item = analyze_method!(match, argtypes, info, flag, state; allow_typevars=false, invokesig)
         end
-        item = analyze_method!(match, argtypes, info, flag, state; allow_typevars=false, invokesig)
     end
     handle_single_case!(todo, ir, idx, stmt, item, true)
     return nothing

From b093c2d66edce854cf6e013d0f27227fe6097f7c Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 1 Nov 2023 16:19:37 +0900
Subject: [PATCH 0147/1315] `AbstractInterpreter`: define
 `add_invalidation_callback!` utility (#51769)

It seems we're reaching a consensus on how the external
`AbstractInterpreter` utilizes user invalidation callbacks. Let's
establish a utility within `Core.Compiler` for this purpose, which
cannibalizes the pattern, so that external packages can easily access
and use it.

Furthermore, with this commit, gf.c has been adjusted so that each
invocation of `invalidate_method_instance` invokes user callbacks. This
adjustment eliminates the need for user callbacks to traverse
(unstable and internal) backedge lists by themselves.
---
 base/compiler/utilities.jl              | 19 ++++++++++
 src/gf.c                                | 48 +++++++++++--------------
 test/compiler/EscapeAnalysis/EAUtils.jl | 36 +++----------------
 test/compiler/invalidation.jl           | 47 ++++--------------------
 test/compiler/newinterp.jl              |  2 ++
 5 files changed, 53 insertions(+), 99 deletions(-)

diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 175675f2c81cc..67ca98e113b4b 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -321,6 +321,25 @@ function iterate(iter::BackedgeIterator, i::Int=1)
     return BackedgePair(item, backedges[i+1]::MethodInstance), i+2            # `invoke` calls
 end
 
+"""
+    add_invalidation_callback!(callback, mi::MethodInstance)
+
+Register `callback` to be triggered upon the invalidation of `mi`.
+`callback` should a function taking two arguments, `callback(replaced::MethodInstance, max_world::UInt32)`,
+and it will be recursively invoked on `MethodInstance`s within the invalidation graph.
+"""
+function add_invalidation_callback!(@nospecialize(callback), mi::MethodInstance)
+    if !isdefined(mi, :callbacks)
+        callbacks = mi.callbacks = Any[callback]
+    else
+        callbacks = mi.callbacks::Vector{Any}
+        if !any(@nospecialize(cb)->cb===callback, callbacks)
+            push!(callbacks, callback)
+        end
+    end
+    return callbacks
+end
+
 #########
 # types #
 #########
diff --git a/src/gf.c b/src/gf.c
index f6c9041731082..0ad875b167506 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1647,10 +1647,10 @@ static void invalidate_external(jl_method_instance_t *mi, size_t max_world) {
     }
 }
 
-static void do_nothing_with_codeinst(jl_code_instance_t *ci) {}
+static void _invalidate_backedges(jl_method_instance_t *replaced_mi, size_t max_world, int depth);
 
 // recursively invalidate cached methods that had an edge to a replaced method
-static void invalidate_method_instance(void (*f)(jl_code_instance_t*), jl_method_instance_t *replaced, size_t max_world, int depth)
+static void invalidate_method_instance(jl_method_instance_t *replaced, size_t max_world, int depth)
 {
     jl_timing_counter_inc(JL_TIMING_COUNTER_Invalidations, 1);
     if (_jl_debug_method_invalidation) {
@@ -1672,33 +1672,18 @@ static void invalidate_method_instance(void (*f)(jl_code_instance_t*), jl_method
             codeinst->max_world = max_world;
         }
         assert(codeinst->max_world <= max_world);
-        JL_GC_PUSH1(&codeinst);
-        (*f)(codeinst);
-        JL_GC_POP();
         codeinst = jl_atomic_load_relaxed(&codeinst->next);
     }
+    JL_GC_PUSH1(&replaced);
+    invalidate_external(replaced, max_world);
     // recurse to all backedges to update their valid range also
-    jl_array_t *backedges = replaced->backedges;
-    if (backedges) {
-        JL_GC_PUSH1(&backedges);
-        replaced->backedges = NULL;
-        size_t i = 0, l = jl_array_nrows(backedges);
-        jl_method_instance_t *replaced;
-        while (i < l) {
-            i = get_next_edge(backedges, i, NULL, &replaced);
-            invalidate_method_instance(f, replaced, max_world, depth + 1);
-        }
-        JL_GC_POP();
-    }
+    _invalidate_backedges(replaced, max_world, depth + 1);
+    JL_GC_POP();
     JL_UNLOCK(&replaced->def.method->writelock);
 }
 
-// invalidate cached methods that overlap this definition
-static void invalidate_backedges(void (*f)(jl_code_instance_t*), jl_method_instance_t *replaced_mi, size_t max_world, const char *why)
-{
-    JL_LOCK(&replaced_mi->def.method->writelock);
+static void _invalidate_backedges(jl_method_instance_t *replaced_mi, size_t max_world, int depth) {
     jl_array_t *backedges = replaced_mi->backedges;
-    //jl_static_show(JL_STDERR, (jl_value_t*)replaced_mi);
     if (backedges) {
         // invalidate callers (if any)
         replaced_mi->backedges = NULL;
@@ -1707,10 +1692,17 @@ static void invalidate_backedges(void (*f)(jl_code_instance_t*), jl_method_insta
         jl_method_instance_t *replaced;
         while (i < l) {
             i = get_next_edge(backedges, i, NULL, &replaced);
-            invalidate_method_instance(f, replaced, max_world, 1);
+            invalidate_method_instance(replaced, max_world, depth);
         }
         JL_GC_POP();
     }
+}
+
+// invalidate cached methods that overlap this definition
+static void invalidate_backedges(jl_method_instance_t *replaced_mi, size_t max_world, const char *why)
+{
+    JL_LOCK(&replaced_mi->def.method->writelock);
+    _invalidate_backedges(replaced_mi, max_world, 1);
     JL_UNLOCK(&replaced_mi->def.method->writelock);
     if (why && _jl_debug_method_invalidation) {
         jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)replaced_mi);
@@ -1824,6 +1816,7 @@ static int invalidate_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
             }
         }
         if (intersects) {
+            // TODO call invalidate_external here?
             if (_jl_debug_method_invalidation) {
                 jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)mi);
                 jl_value_t *loctag = jl_cstr_to_string("invalidate_mt_cache");
@@ -1906,7 +1899,7 @@ static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *m
         if ((jl_value_t*)mi != jl_nothing) {
             invalidated = 1;
             invalidate_external(mi, max_world);
-            invalidate_backedges(&do_nothing_with_codeinst, mi, max_world, "jl_method_table_disable");
+            invalidate_backedges(mi, max_world, "jl_method_table_disable");
         }
     }
     JL_GC_POP();
@@ -2070,8 +2063,7 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
                 }
                 if (missing) {
                     jl_method_instance_t *backedge = (jl_method_instance_t*)backedges[i];
-                    invalidate_external(backedge, max_world);
-                    invalidate_method_instance(&do_nothing_with_codeinst, backedge, max_world, 0);
+                    invalidate_method_instance(backedge, max_world, 0);
                     invalidated = 1;
                     if (_jl_debug_method_invalidation)
                         jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)backedgetyp);
@@ -2128,7 +2120,7 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
                         // over the intersection (not ambiguous) and the new method will be selected now (morespec_is)
                         int replaced_dispatch = is_replacing(ambig, type, m, d, n, isect, isect2, morespec);
                         // found that this specialization dispatch got replaced by m
-                        // call invalidate_backedges(&do_nothing_with_codeinst, mi, max_world, "jl_method_table_insert");
+                        // call invalidate_backedges(mi, max_world, "jl_method_table_insert");
                         // but ignore invoke-type edges
                         jl_array_t *backedges = mi->backedges;
                         if (backedges) {
@@ -2149,7 +2141,7 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
                                     replaced_edge = replaced_dispatch;
                                 }
                                 if (replaced_edge) {
-                                    invalidate_method_instance(&do_nothing_with_codeinst, caller, max_world, 1);
+                                    invalidate_method_instance(caller, max_world, 1);
                                     invalidated = 1;
                                 }
                                 else {
diff --git a/test/compiler/EscapeAnalysis/EAUtils.jl b/test/compiler/EscapeAnalysis/EAUtils.jl
index 02038cf8e5540..937113c34c872 100644
--- a/test/compiler/EscapeAnalysis/EAUtils.jl
+++ b/test/compiler/EscapeAnalysis/EAUtils.jl
@@ -136,38 +136,12 @@ CC.get(wvc::WorldView{EscapeAnalyzerCacheView}, mi::MethodInstance, default) = g
 CC.getindex(wvc::WorldView{EscapeAnalyzerCacheView}, mi::MethodInstance) = getindex(wvc.cache.code_cache.cache, mi)
 function CC.setindex!(wvc::WorldView{EscapeAnalyzerCacheView}, ci::CodeInstance, mi::MethodInstance)
     wvc.cache.code_cache.cache[mi] = ci
-    add_invalidation_callback!(wvc.cache.code_cache, wvc.cache.escape_cache, mi) # register the callback on invalidation
-    return nothing
-end
-function add_invalidation_callback!(code_cache::CodeCache, escape_cache::EscapeCache, mi)
-    callback = InvalidationCallback(code_cache, escape_cache)
-    if !isdefined(mi, :callbacks)
-        mi.callbacks = Any[callback]
-    else
-        if !any(@nospecialize(cb)->cb===callback, mi.callbacks)
-            push!(mi.callbacks, callback)
-        end
-    end
-    return nothing
-end
-struct InvalidationCallback
-    code_cache::CodeCache
-    escape_cache::EscapeCache
-end
-function (callback::InvalidationCallback)(replaced::MethodInstance, max_world,
-                                          seen::IdSet{MethodInstance}=IdSet{MethodInstance}())
-    (; code_cache, escape_cache) = callback
-    push!(seen, replaced)
-    delete!(code_cache.cache, replaced)
-    delete!(escape_cache.cache, replaced)
-    if isdefined(replaced, :backedges)
-        for mi in replaced.backedges
-            isa(mi, MethodInstance) || continue # might be `Type` object representing an `invoke` signature
-            mi in seen && continue # otherwise fall into infinite loop
-            callback(mi, max_world, seen)
-        end
+    # register the callback on invalidation
+    CC.add_invalidation_callback!(mi) do replaced::MethodInstance, max_world::UInt32
+        delete!(wvc.cache.code_cache.cache, replaced)
+        delete!(wvc.cache.escape_cache.cache, replaced)
     end
-    return nothing
+    return wvc
 end
 
 function CC.optimize(interp::EscapeAnalyzer, opt::OptimizationState, caller::InferenceResult)
diff --git a/test/compiler/invalidation.jl b/test/compiler/invalidation.jl
index 10e239cfc363f..0d1cfeee56ea8 100644
--- a/test/compiler/invalidation.jl
+++ b/test/compiler/invalidation.jl
@@ -18,30 +18,22 @@ InvalidationTesterCache() = InvalidationTesterCache(IdDict{MethodInstance,CodeIn
 const INVALIDATION_TESTER_CACHE = InvalidationTesterCache()
 
 struct InvalidationTester <: CC.AbstractInterpreter
-    callback!
     world::UInt
     inf_params::CC.InferenceParams
     opt_params::CC.OptimizationParams
     inf_cache::Vector{CC.InferenceResult}
     code_cache::InvalidationTesterCache
-    function InvalidationTester(callback! = nothing;
+    function InvalidationTester(;
                                 world::UInt = Base.get_world_counter(),
                                 inf_params::CC.InferenceParams = CC.InferenceParams(),
                                 opt_params::CC.OptimizationParams = CC.OptimizationParams(),
                                 inf_cache::Vector{CC.InferenceResult} = CC.InferenceResult[],
                                 code_cache::InvalidationTesterCache = INVALIDATION_TESTER_CACHE)
-        if callback! === nothing
-            callback! = function (replaced::MethodInstance)
-                # Core.println(replaced) # debug
-                delete!(code_cache.dict, replaced)
-            end
-        end
-        return new(callback!, world, inf_params, opt_params, inf_cache, code_cache)
+        return new(world, inf_params, opt_params, inf_cache, code_cache)
     end
 end
 
 struct InvalidationTesterCacheView
-    interp::InvalidationTester
     dict::IdDict{MethodInstance,CodeInstance}
 end
 
@@ -49,43 +41,18 @@ CC.InferenceParams(interp::InvalidationTester) = interp.inf_params
 CC.OptimizationParams(interp::InvalidationTester) = interp.opt_params
 CC.get_world_counter(interp::InvalidationTester) = interp.world
 CC.get_inference_cache(interp::InvalidationTester) = interp.inf_cache
-CC.code_cache(interp::InvalidationTester) = WorldView(InvalidationTesterCacheView(interp, interp.code_cache.dict), WorldRange(interp.world))
+CC.code_cache(interp::InvalidationTester) = WorldView(InvalidationTesterCacheView(interp.code_cache.dict), WorldRange(interp.world))
 CC.get(wvc::WorldView{InvalidationTesterCacheView}, mi::MethodInstance, default) = get(wvc.cache.dict, mi, default)
 CC.getindex(wvc::WorldView{InvalidationTesterCacheView}, mi::MethodInstance) = getindex(wvc.cache.dict, mi)
 CC.haskey(wvc::WorldView{InvalidationTesterCacheView}, mi::MethodInstance) = haskey(wvc.cache.dict, mi)
 function CC.setindex!(wvc::WorldView{InvalidationTesterCacheView}, ci::CodeInstance, mi::MethodInstance)
-    add_callback!(wvc.cache.interp.callback!, mi)
-    setindex!(wvc.cache.dict, ci, mi)
-end
-
-function add_callback!(@nospecialize(callback!), mi::MethodInstance)
-    callback = function (replaced::MethodInstance, max_world,
-                         seen::Base.IdSet{MethodInstance} = Base.IdSet{MethodInstance}())
-        push!(seen, replaced)
-        callback!(replaced)
-        if isdefined(replaced, :backedges)
-            for item in replaced.backedges
-                isa(item, MethodInstance) || continue # might be `Type` object representing an `invoke` signature
-                mi = item
-                mi in seen && continue # otherwise fail into an infinite loop
-                var"#self#"(mi, max_world, seen)
-            end
-        end
-        return nothing
+    CC.add_invalidation_callback!(mi) do replaced::MethodInstance, max_world::UInt32
+        delete!(wvc.cache.dict, replaced)
+        # Core.println("[InvalidationTester] ", replaced) # debug
     end
-
-    if !isdefined(mi, :callbacks)
-        mi.callbacks = Any[callback]
-    else
-        callbacks = mi.callbacks::Vector{Any}
-        if !any(@nospecialize(cb)->cb===callback, callbacks)
-            push!(callbacks, callback)
-        end
-    end
-    return nothing
+    setindex!(wvc.cache.dict, ci, mi)
 end
 
-
 # basic functionality test
 # ------------------------
 
diff --git a/test/compiler/newinterp.jl b/test/compiler/newinterp.jl
index 56a68f2a09545..b454cdd3a40d8 100644
--- a/test/compiler/newinterp.jl
+++ b/test/compiler/newinterp.jl
@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+# TODO set up a version who defines new interpreter with persistent cache?
+
 """
     @newinterp NewInterpreter
 

From aaa092c0bb1a194f197e0ee45f913e186fd7f986 Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Wed, 1 Nov 2023 08:27:37 +0100
Subject: [PATCH 0148/1315] Implement more missing BFloat16 intrinsics (#51935)

Extends #51790; I forgot the conversion intrinsics defined in `APInt-C`.
To differentiate between Float16/BFloat16, I converted a couple of intrinsics
to take a `jl_datatype_t` argument instead an unsigned number of bits.
---
 src/APInt-C.cpp          | 93 ++++++++++++++++++++++------------------
 src/APInt-C.h            | 22 +++++-----
 src/runtime_intrinsics.c | 15 ++++---
 3 files changed, 74 insertions(+), 56 deletions(-)

diff --git a/src/APInt-C.cpp b/src/APInt-C.cpp
index ddb6d7c685738..22b3beef996db 100644
--- a/src/APInt-C.cpp
+++ b/src/APInt-C.cpp
@@ -7,16 +7,11 @@
 #include <llvm/Support/MathExtras.h>
 
 #include "APInt-C.h"
-#include "julia.h"
 #include "julia_assert.h"
 #include "julia_internal.h"
 
 using namespace llvm;
 
-inline uint64_t RoundUpToAlignment(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
-    return alignTo(Value, Align, Skew);
-}
-
 const unsigned int integerPartWidth = llvm::APInt::APINT_BITS_PER_WORD;
 const unsigned int host_char_bit = 8;
 
@@ -25,11 +20,11 @@ const unsigned int host_char_bit = 8;
     APInt s; \
     if ((numbits % integerPartWidth) != 0) { \
         /* use LLT_ALIGN to round the memory area up to the nearest integerPart-sized chunk */ \
-        unsigned nbytes = RoundUpToAlignment(numbits, integerPartWidth) / host_char_bit; \
+        unsigned nbytes = alignTo(numbits, integerPartWidth) / host_char_bit; \
         integerPart *data_a64 = (integerPart*)alloca(nbytes); \
         /* TODO: this memcpy assumes little-endian,
          * for big-endian, need to align the copy to the other end */ \
-        memcpy(data_a64, p##s, RoundUpToAlignment(numbits, host_char_bit) / host_char_bit); \
+        memcpy(data_a64, p##s, alignTo(numbits, host_char_bit) / host_char_bit); \
         s = APInt(numbits, ArrayRef<uint64_t>(data_a64, nbytes / sizeof(integerPart))); \
     } \
     else { \
@@ -47,7 +42,7 @@ const unsigned int host_char_bit = 8;
     else if (numbits <= 64) \
         *(uint64_t*)p##r = a.getZExtValue(); \
     else \
-        memcpy(p##r, a.getRawData(), RoundUpToAlignment(numbits, host_char_bit) / host_char_bit); \
+        memcpy(p##r, a.getRawData(), alignTo(numbits, host_char_bit) / host_char_bit); \
 
 extern "C" JL_DLLEXPORT
 void LLVMNeg(unsigned numbits, integerPart *pa, integerPart *pr) {
@@ -315,18 +310,23 @@ void LLVMByteSwap(unsigned numbits, integerPart *pa, integerPart *pr) {
 
 extern "C" float julia_half_to_float(uint16_t ival) JL_NOTSAFEPOINT;
 extern "C" uint16_t julia_float_to_half(float param) JL_NOTSAFEPOINT;
+extern "C" float julia_bfloat_to_float(uint16_t ival) JL_NOTSAFEPOINT;
+extern "C" uint16_t julia_float_to_bfloat(float param) JL_NOTSAFEPOINT;
 
-void LLVMFPtoInt(unsigned numbits, void *pa, unsigned onumbits, integerPart *pr, bool isSigned, bool *isExact) {
+void LLVMFPtoInt(jl_datatype_t *ty, void *pa, jl_datatype_t *oty, integerPart *pr, bool isSigned, bool *isExact) {
     double Val;
-    if (numbits == 16)
+    if (ty == jl_float16_type)
         Val = julia_half_to_float(*(uint16_t*)pa);
-    else if (numbits == 32)
+    else if (ty == jl_bfloat16_type)
+        Val = julia_bfloat_to_float(*(uint16_t*)pa);
+    else if (ty == jl_float32_type)
         Val = *(float*)pa;
-    else if (numbits == 64)
+    else if (jl_float64_type)
         Val = *(double*)pa;
     else
         jl_error("FPtoSI: runtime floating point intrinsics are not implemented for bit sizes other than 16, 32 and 64");
-    unsigned onumbytes = RoundUpToAlignment(onumbits, host_char_bit) / host_char_bit;
+    unsigned onumbytes = jl_datatype_size(oty);
+    unsigned onumbits = onumbytes * host_char_bit;
     if (onumbits <= 64) { // fast-path, if possible
         if (isSigned) {
             int64_t ia = Val;
@@ -353,7 +353,7 @@ void LLVMFPtoInt(unsigned numbits, void *pa, unsigned onumbits, integerPart *pr,
         APFloat a(Val);
         bool isVeryExact;
         APFloat::roundingMode rounding_mode = APFloat::rmNearestTiesToEven;
-        unsigned nbytes = RoundUpToAlignment(onumbits, integerPartWidth) / host_char_bit;
+        unsigned nbytes = alignTo(onumbits, integerPartWidth) / host_char_bit;
         integerPart *parts = (integerPart*)alloca(nbytes);
         APFloat::opStatus status = a.convertToInteger(MutableArrayRef<integerPart>(parts, nbytes), onumbits, isSigned, rounding_mode, &isVeryExact);
         memcpy(pr, parts, onumbytes);
@@ -363,69 +363,78 @@ void LLVMFPtoInt(unsigned numbits, void *pa, unsigned onumbits, integerPart *pr,
 }
 
 extern "C" JL_DLLEXPORT
-void LLVMFPtoSI(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
-    LLVMFPtoInt(numbits, pa, onumbits, pr, true, NULL);
+void LLVMFPtoSI(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr) {
+    LLVMFPtoInt(ty, pa, oty, pr, true, NULL);
 }
 
 extern "C" JL_DLLEXPORT
-void LLVMFPtoUI(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
-    LLVMFPtoInt(numbits, pa, onumbits, pr, false, NULL);
+void LLVMFPtoUI(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr) {
+    LLVMFPtoInt(ty, pa, oty, pr, false, NULL);
 }
 
 extern "C" JL_DLLEXPORT
-int LLVMFPtoSI_exact(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+int LLVMFPtoSI_exact(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr) {
     bool isExact;
-    LLVMFPtoInt(numbits, pa, onumbits, pr, true, &isExact);
+    LLVMFPtoInt(ty, pa, oty, pr, true, &isExact);
     return isExact;
 }
 
 extern "C" JL_DLLEXPORT
-int LLVMFPtoUI_exact(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+int LLVMFPtoUI_exact(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr) {
     bool isExact;
-    LLVMFPtoInt(numbits, pa, onumbits, pr, false, &isExact);
+    LLVMFPtoInt(ty, pa, oty, pr, false, &isExact);
     return isExact;
 }
 
 extern "C" JL_DLLEXPORT
-void LLVMSItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+void LLVMSItoFP(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr) {
     double val;
     { // end scope before jl_error call
+        unsigned numbytes = jl_datatype_size(ty);
+        unsigned numbits = numbytes * host_char_bit;
         CREATE(a)
         val = a.roundToDouble(true);
     }
-    if (onumbits == 16)
+    if (oty == jl_float16_type)
         *(uint16_t*)pr = julia_float_to_half(val);
-    else if (onumbits == 32)
+    else if (oty == jl_bfloat16_type)
+        *(uint16_t*)pr = julia_float_to_bfloat(val);
+    else if (oty == jl_float32_type)
         *(float*)pr = val;
-    else if (onumbits == 64)
+    else if (oty == jl_float64_type)
         *(double*)pr = val;
     else
         jl_error("SItoFP: runtime floating point intrinsics are not implemented for bit sizes other than 16, 32 and 64");
 }
 
 extern "C" JL_DLLEXPORT
-void LLVMUItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+void LLVMUItoFP(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr) {
     double val;
     { // end scope before jl_error call
+        unsigned numbytes = jl_datatype_size(ty);
+        unsigned numbits = numbytes * host_char_bit;
         CREATE(a)
         val = a.roundToDouble(false);
     }
-    if (onumbits == 16)
+    if (oty == jl_float16_type)
         *(uint16_t*)pr = julia_float_to_half(val);
-    else if (onumbits == 32)
+    else if (oty == jl_bfloat16_type)
+        *(uint16_t*)pr = julia_float_to_bfloat(val);
+    else if (oty == jl_float32_type)
         *(float*)pr = val;
-    else if (onumbits == 64)
+    else if (oty == jl_float64_type)
         *(double*)pr = val;
     else
         jl_error("UItoFP: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
 }
 
 extern "C" JL_DLLEXPORT
-void LLVMSExt(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
-    if (!(onumbits > inumbits))
+void LLVMSExt(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *otys, integerPart *pr) {
+    unsigned inumbytes = jl_datatype_size(ty);
+    unsigned onumbytes = jl_datatype_size(otys);
+    if (!(onumbytes > inumbytes))
         jl_error("SExt: output bitsize must be > input bitsize");
-    unsigned inumbytes = RoundUpToAlignment(inumbits, host_char_bit) / host_char_bit;
-    unsigned onumbytes = RoundUpToAlignment(onumbits, host_char_bit) / host_char_bit;
+    unsigned inumbits = inumbytes * host_char_bit;
     int bits = (0 - inumbits) % host_char_bit;
     int signbit = (inumbits - 1) % host_char_bit;
     int sign = ((unsigned char*)pa)[inumbytes - 1] & (1 << signbit) ? -1 : 0;
@@ -440,11 +449,12 @@ void LLVMSExt(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPart
 }
 
 extern "C" JL_DLLEXPORT
-void LLVMZExt(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
-    if (!(onumbits > inumbits))
+void LLVMZExt(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *otys, integerPart *pr) {
+    unsigned inumbytes = jl_datatype_size(ty);
+    unsigned onumbytes = jl_datatype_size(otys);
+    if (!(onumbytes > inumbytes))
         jl_error("ZExt: output bitsize must be > input bitsize");
-    unsigned inumbytes = RoundUpToAlignment(inumbits, host_char_bit) / host_char_bit;
-    unsigned onumbytes = RoundUpToAlignment(onumbits, host_char_bit) / host_char_bit;
+    unsigned inumbits = inumbytes * host_char_bit;
     int bits = (0 - inumbits) % host_char_bit;
     // copy over the input bytes
     memcpy(pr, pa, inumbytes);
@@ -457,10 +467,11 @@ void LLVMZExt(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPart
 }
 
 extern "C" JL_DLLEXPORT
-void LLVMTrunc(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
-    if (!(onumbits < inumbits))
+void LLVMTrunc(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *otys, integerPart *pr) {
+    unsigned inumbytes = jl_datatype_size(ty);
+    unsigned onumbytes = jl_datatype_size(otys);
+    if (!(onumbytes < inumbytes))
         jl_error("Trunc: output bitsize must be < input bitsize");
-    unsigned onumbytes = RoundUpToAlignment(onumbits, host_char_bit) / host_char_bit;
     memcpy(pr, pa, onumbytes);
 }
 
diff --git a/src/APInt-C.h b/src/APInt-C.h
index e71d49e82e99a..816d40ccc6529 100644
--- a/src/APInt-C.h
+++ b/src/APInt-C.h
@@ -3,10 +3,12 @@
 #ifndef JL_APINT_C_H
 #define JL_APINT_C_H
 
+#include "julia.h"
+#include "dtypes.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
-#include "dtypes.h"
 
 #ifdef LLVM_VERSION_MAJOR
 using integerPart = llvm::APInt::WordType;
@@ -57,16 +59,16 @@ JL_DLLEXPORT unsigned LLVMCountTrailingZeros(unsigned numbits, integerPart *pa);
 JL_DLLEXPORT unsigned LLVMCountLeadingOnes(unsigned numbits, integerPart *pa);
 JL_DLLEXPORT unsigned LLVMCountLeadingZeros(unsigned numbits, integerPart *pa);
 
-JL_DLLEXPORT void LLVMFPtoSI(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
-JL_DLLEXPORT void LLVMFPtoUI(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
-JL_DLLEXPORT void LLVMSItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
-JL_DLLEXPORT void LLVMUItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
-JL_DLLEXPORT void LLVMSExt(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
-JL_DLLEXPORT void LLVMZExt(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
-JL_DLLEXPORT void LLVMTrunc(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT void LLVMFPtoSI(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
+JL_DLLEXPORT void LLVMFPtoUI(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
+JL_DLLEXPORT void LLVMSItoFP(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
+JL_DLLEXPORT void LLVMUItoFP(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
+JL_DLLEXPORT void LLVMSExt(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
+JL_DLLEXPORT void LLVMZExt(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
+JL_DLLEXPORT void LLVMTrunc(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
 
-JL_DLLEXPORT int LLVMFPtoSI_exact(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
-JL_DLLEXPORT int LLVMFPtoUI_exact(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT int LLVMFPtoSI_exact(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
+JL_DLLEXPORT int LLVMFPtoUI_exact(jl_datatype_t *ty, integerPart *pa, jl_datatype_t *oty, integerPart *pr);
 
 JL_DLLEXPORT void jl_LLVMSMod(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
 JL_DLLEXPORT void jl_LLVMFlipSign(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index aa0922fcb96ce..7b4ddcd6e8b29 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -338,6 +338,14 @@ static inline float bfloat_to_float(uint16_t param) JL_NOTSAFEPOINT
 
 // bfloat16 conversion API
 
+// for use in APInt (without the ABI shenanigans from below)
+uint16_t julia_float_to_bfloat(float param) {
+    return float_to_bfloat(param);
+}
+float julia_bfloat_to_float(uint16_t param) {
+    return bfloat_to_float(param);
+}
+
 // starting with GCC 13 and Clang 17, we have __bf16 on most platforms
 // (but not on Windows; this may be a bug in the MSYS2 GCC compilers)
 #if ((defined(__GNUC__) && __GNUC__ > 12) || \
@@ -1012,7 +1020,7 @@ static inline jl_value_t *jl_intrinsiclambda_u1(jl_value_t *ty, void *pa, unsign
 
 // conversion operator
 
-typedef void (*intrinsic_cvt_t)(unsigned, void*, unsigned, void*);
+typedef void (*intrinsic_cvt_t)(jl_datatype_t*, void*, jl_datatype_t*, void*);
 typedef unsigned (*intrinsic_cvt_check_t)(unsigned, unsigned, void*);
 #define cvt_iintrinsic(LLVMOP, name) \
 JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *ty, jl_value_t *a) \
@@ -1029,12 +1037,9 @@ static inline jl_value_t *jl_intrinsic_cvt(jl_value_t *ty, jl_value_t *a, const
     if (!jl_is_primitivetype(aty))
         jl_errorf("%s: value is not a primitive type", name);
     void *pa = jl_data_ptr(a);
-    unsigned isize = jl_datatype_size(aty);
     unsigned osize = jl_datatype_size(ty);
     void *pr = alloca(osize);
-    unsigned isize_bits = isize * host_char_bit;
-    unsigned osize_bits = osize * host_char_bit;
-    op(isize_bits, pa, osize_bits, pr);
+    op((jl_datatype_t*)aty, pa, (jl_datatype_t*)ty, pr);
     return jl_new_bits(ty, pr);
 }
 

From 3f8396c6d7334f618a6f8695cc6e031a95267706 Mon Sep 17 00:00:00 2001
From: Fons van der Plas <fonsvdplas@gmail.com>
Date: Wed, 1 Nov 2023 08:44:53 +0100
Subject: [PATCH 0149/1315] Docs: io-network: list `read(::String)` and
 `write(::String,::Any)` before `open` (#49837)

Point 3 of https://github.com/JuliaLang/julia/issues/43428

Depends on https://github.com/JuliaLang/julia/pull/49835 and
https://github.com/JuliaLang/julia/pull/49836 to be useful :)

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 doc/src/base/io-network.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/doc/src/base/io-network.md b/doc/src/base/io-network.md
index 68f144427a892..33fc113375e4e 100644
--- a/doc/src/base/io-network.md
+++ b/doc/src/base/io-network.md
@@ -6,6 +6,8 @@
 Base.stdout
 Base.stderr
 Base.stdin
+Base.read(::AbstractString)
+Base.write(::AbstractString, ::Any)
 Base.open
 Base.IOStream
 Base.IOBuffer

From 0bde9a247665c7dfcf43159e63dabe6cde529e72 Mon Sep 17 00:00:00 2001
From: Matt Bauman <mbauman@juliahub.com>
Date: Wed, 1 Nov 2023 10:15:04 -0400
Subject: [PATCH 0150/1315] Implement copy for SecretBuffer (#27827)

As noted in
https://github.com/JuliaLang/julia/pull/27802#issuecomment-400386359

Co-authored-by: Curtis Vogt <curtis.vogt@gmail.com>
---
 base/secretbuffer.jl            | 12 +++++++++
 stdlib/LibGit2/src/callbacks.jl |  4 +--
 test/secretbuffer.jl            | 43 ++++++++++++++++++++++++++++++++-
 3 files changed, 56 insertions(+), 3 deletions(-)

diff --git a/base/secretbuffer.jl b/base/secretbuffer.jl
index 28bd35ac2e93a..61eeffdb4f18d 100644
--- a/base/secretbuffer.jl
+++ b/base/secretbuffer.jl
@@ -117,6 +117,18 @@ end
 const _sb_hash = UInt === UInt32 ? 0x111c0925 : 0xb06061e370557428
 hash(s::SecretBuffer, h::UInt) = hash(_sb_hash, h)
 
+copy(s::SecretBuffer) = copy!(SecretBuffer(sizehint=length(s.data)), s)
+function copy!(dest::SecretBuffer, src::SecretBuffer)
+    if length(dest.data) != length(src.data)
+        securezero!(dest.data)
+        dest.data = copy(src.data)
+    else
+        copyto!(dest.data, src.data)
+    end
+    dest.size = src.size
+    dest.ptr = src.ptr
+    return dest
+end
 
 function write(io::SecretBuffer, b::UInt8)
     if io.ptr > length(io.data)
diff --git a/stdlib/LibGit2/src/callbacks.jl b/stdlib/LibGit2/src/callbacks.jl
index b4fb29716e609..043e04e0dfad6 100644
--- a/stdlib/LibGit2/src/callbacks.jl
+++ b/stdlib/LibGit2/src/callbacks.jl
@@ -195,9 +195,9 @@ function authenticate_userpass(libgit2credptr::Ptr{Ptr{Cvoid}}, p::CredentialPay
     if p.use_git_helpers && (!revised || !isfilled(cred))
         git_cred = GitCredential(p.config, p.url)
 
-         # Use `deepcopy` to ensure shredding the `git_cred` does not shred the `cred`s copy
+         # Use `copy` to ensure shredding the `git_cred` does not shred the `cred`s copy
         cred.user = something(git_cred.username, "")
-        cred.pass = deepcopy(something(git_cred.password, ""))
+        cred.pass = git_cred.password !== nothing ? copy(git_cred.password) : ""
         Base.shred!(git_cred)
         revised = true
 
diff --git a/test/secretbuffer.jl b/test/secretbuffer.jl
index 976c757deea57..29e28ded8da72 100644
--- a/test/secretbuffer.jl
+++ b/test/secretbuffer.jl
@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Base: SecretBuffer, SecretBuffer!, shred!, isshredded
-using Test
+using Test, Random
 
 @testset "SecretBuffer" begin
     @testset "original unmodified" begin
@@ -129,4 +129,45 @@ using Test
         @test_throws ArgumentError Base.unsafe_SecretBuffer!(null_ptr)
         @test_throws ArgumentError Base.unsafe_SecretBuffer!(null_ptr, 0)
     end
+
+    @testset "copiers" begin
+        s1 = SecretBuffer()
+        write(s1, "hello world")
+        seekstart(s1)
+
+        s2 = copy(s1)
+        write(s2, 'c')
+        seekstart(s2)
+
+        @test read(s1) == codeunits("hello world")
+        @test read(s2) == codeunits("cello world")
+
+        shred!(s1)
+        @test isshredded(s1)
+        @test !isshredded(s2)
+        shred!(s2)
+
+        # Copying into a bigger destination
+        s3 = SecretBuffer()
+        s4 = SecretBuffer()
+        write(s3, "original")
+        seekstart(s3)
+        write(s4, randstring(1234))
+        s4data = s4.data
+        copy!(s4, s3)
+        @test s3.data == s4.data
+        @test read(s3) == read(s4) == codeunits("original")
+        @test all(iszero, s4data)
+        shred!(s3); shred!(s4)
+
+        # Copying into a smaller destination
+        s5 = SecretBuffer()
+        s6 = SecretBuffer("sekrit")
+        str = randstring(321)
+        write(s5, str)
+        seekstart(s5)
+        copy!(s6, s5)
+        @test read(s5) == read(s6) == codeunits(str)
+        shred!(s5); shred!(s6)
+    end
 end

From a8a3f924c81b0b16177dc402e81d75ac903f6f7e Mon Sep 17 00:00:00 2001
From: Jeremie Knuesel <knuesel@gmail.com>
Date: Wed, 1 Nov 2023 15:19:58 +0100
Subject: [PATCH 0151/1315] Clarify documentation of anonymous functions
 (#48119)

The example used previously is a bit confusing: the do-block syntax is
introduced only later on the page, and the anonymous function simply
calls `time` so it's actually useless (`time` could be passed to `get`
as-is).
---
 doc/src/manual/functions.md | 30 ++++++++----------------------
 1 file changed, 8 insertions(+), 22 deletions(-)

diff --git a/doc/src/manual/functions.md b/doc/src/manual/functions.md
index dd8db7281d87e..f47b7c19698a0 100644
--- a/doc/src/manual/functions.md
+++ b/doc/src/manual/functions.md
@@ -330,31 +330,17 @@ julia> map(x -> x^2 + 2x - 1, [1, 3, -1])
 ```
 
 An anonymous function accepting multiple arguments can be written using the syntax `(x,y,z)->2x+y-z`.
+
 Argument-type declarations for anonymous functions work as for named functions, for example `x::Integer->2x`.
 The return type of an anonymous function cannot be specified.
 
-A zero-argument anonymous function is written as `()->3`. The idea of a function with no arguments
-may seem strange, but is useful for "delaying" a computation. In this usage, a block of code is
-wrapped in a zero-argument function, which is later invoked by calling it as `f`.
-
-As an example, consider this call to [`get`](@ref):
-
-```julia
-get(dict, key) do
-    # default value calculated here
-    time()
-end
-```
-
-The code above is equivalent to calling `get` with an anonymous function containing the code
-enclosed between `do` and `end`, like so:
-
-```julia
-get(()->time(), dict, key)
-```
-
-The call to [`time`](@ref) is delayed by wrapping it in a 0-argument anonymous function
-that is called only if the requested key is absent from `dict`.
+A zero-argument anonymous function can be written as `()->2+2`. The idea of a function with
+no arguments may seem strange, but is useful in cases where a result cannot (or should not)
+be precomputed. For example, Julia has a zero-argument [`time`](@ref) function that returns
+the current time in seconds, and thus `seconds = ()->round(Int, time())` is an anonymous
+function that returns this time rounded to the nearest integer assigned to the variable
+`seconds`. Each time this anonymous function is called as `seconds()` the current time will
+be calculated and returned.
 
 ## Tuples
 

From 2adf54a951d70d6963af7f22950ca28c032000af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Wed, 1 Nov 2023 14:28:55 +0000
Subject: [PATCH 0152/1315] [devdocs] Improve documentation about building
 external forks of LLVM (#50207)

Suggested by @vchuravy.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 Make.inc                       |  4 +++
 doc/src/devdocs/build/build.md | 52 ++++++++++++++++++++++++++++++++--
 2 files changed, 54 insertions(+), 2 deletions(-)

diff --git a/Make.inc b/Make.inc
index 8d5aa5ce86dfe..d62c485b03dbc 100644
--- a/Make.inc
+++ b/Make.inc
@@ -359,6 +359,10 @@ USE_MLIR := 0
 # Options to use RegionVectorizer
 USE_RV := 0
 
+# Use `ccache` for speeding up recompilation of the C/C++ part of Julia.
+# Requires the `ccache` executable to be in the `PATH` environment variable.
+USECCACHE := 0
+
 # Cross-compile
 #XC_HOST := i686-w64-mingw32
 #XC_HOST := x86_64-w64-mingw32
diff --git a/doc/src/devdocs/build/build.md b/doc/src/devdocs/build/build.md
index 51bcf7d0ee469..52d9482805b9a 100644
--- a/doc/src/devdocs/build/build.md
+++ b/doc/src/devdocs/build/build.md
@@ -60,6 +60,16 @@ To run julia from anywhere you can:
 
 - write `prefix=/path/to/install/folder` into `Make.user` and then run `make install`. If there is a version of Julia already installed in this folder, you should delete it before running `make install`.
 
+Some of the options you can set to control the build of Julia are listed and documented at the beginning of the file `Make.inc`, but you should never edit it for this purpose, use `Make.user` instead.
+
+Julia's Makefiles define convenient automatic rules called `print-<VARNAME>` for printing the value of variables, replacing `<VARNAME>` with the name of the variable to print the value of.
+For example
+```console
+$ make print-JULIA_PRECOMPILE
+JULIA_PRECOMPILE=1
+```
+These rules are useful for debugging purposes.
+
 Now you should be able to run Julia like this:
 
     julia
@@ -239,10 +249,48 @@ For packaging Julia with LLVM, we recommend either:
  - bundling a Julia-only LLVM library inside the Julia package, or
  - adding the patches to the LLVM package of the distribution.
    * A complete list of patches is available in on [Github](https://github.com/JuliaLang/llvm-project) see the `julia-release/15.x` branch.
-   * The only Julia-specific patch is the lib renaming (`llvm-symver-jlprefix.patch`), which should _not_ be applied to a system LLVM.
+   * The only Julia-specific patch is the lib renaming (`llvm7-symver-jlprefix.patch`), which should _not_ be applied to a system LLVM.
    * The remaining patches are all upstream bug fixes, and have been contributed into upstream LLVM.
 
-Using an unpatched or different version of LLVM will result in errors and/or poor performance. Though Julia can be built with newer LLVM versions, support for this should be regarded as experimental and not suitable for packaging.
+Using an unpatched or different version of LLVM will result in errors and/or poor performance.
+You can build a different version of LLVM from a remote Git repository with the following options in the `Make.user` file:
+
+```make
+# Force source build of LLVM
+USE_BINARYBUILDER_LLVM = 0
+# Use Git for fetching LLVM source code
+# this is either `1` to get all of them
+DEPS_GIT = 1
+# or a space-separated list of specific dependencies to download with git
+DEPS_GIT = llvm
+
+# Other useful options:
+#URL of the Git repository you want to obtain LLVM from:
+#  LLVM_GIT_URL = ...
+#Name of the alternate branch to clone from git
+#  LLVM_BRANCH = julia-16.0.6-0
+#SHA hash of the alterate commit to check out automatically
+#  LLVM_SHA1 = $(LLVM_BRANCH)
+#List of LLVM targets to build.  It is strongly recommended to keep at least all the
+#default targets listed in `deps/llvm.mk`, even if you don't necessarily need all of them.
+#  LLVM_TARGETS = ...
+#Use ccache for faster recompilation in case you need to restart a build.
+#  USECCACHE = 1
+#  CMAKE_GENERATOR=Ninja
+#  LLVM_ASSERTIONS=1
+#  LLVM_DEBUG=Symbols
+```
+
+The various build phases are controlled by specific files:
+ * `deps/llvm.version` : touch or change to checkout a new version, `make get-llvm check-llvm`
+ * `deps/srccache/llvm/source-extracted` : result of `make extract-llvm`
+ * `deps/llvm/build_Release*/build-configured` : result of `make configure-llvm`
+ * `deps/llvm/build_Release*/build-configured` : result of `make compile-llvm`
+ * `usr-staging/llvm/build_Release*.tgz` : result of `make stage-llvm` (regenerate with `make reinstall-llvm`)
+ * `usr/manifest/llvm` : result of `make install-llvm` (regenerate with `make uninstall-llvm`)
+ * `make version-check-llvm` : runs every time to warn the user if there are local modifications
+
+Though Julia can be built with newer LLVM versions, support for this should be regarded as experimental and not suitable for packaging.
 
 ### libuv
 

From 5db9dbddf4593825ef16976bce18a45d5fca8f56 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 1 Nov 2023 10:42:48 -0400
Subject: [PATCH 0153/1315] docs: add some clarifications to methods.md
 (#51938)

Closes #40650
Rebase of https://github.com/JuliaLang/julia/pull/40667 with edits,
since upstream deleted their repo

Co-authored-by: Patrick Toche <contact@patricktoche.com>
---
 doc/src/manual/functions.md |  2 +-
 doc/src/manual/methods.md   | 30 ++++++++++++++++++++++--------
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/doc/src/manual/functions.md b/doc/src/manual/functions.md
index f47b7c19698a0..af7f150a74e42 100644
--- a/doc/src/manual/functions.md
+++ b/doc/src/manual/functions.md
@@ -189,7 +189,7 @@ There are three possible points of return from this function, returning the valu
 expressions, depending on the values of `x` and `y`. The `return` on the last line could be omitted
 since it is the last expression.
 
-### Return type
+### [Return type](@id man-functions-return-type)
 
 A return type can be specified in the function declaration using the `::` operator. This converts
 the return value to the specified type.
diff --git a/doc/src/manual/methods.md b/doc/src/manual/methods.md
index 8ca00aa1cfe76..ee68ee265ff95 100644
--- a/doc/src/manual/methods.md
+++ b/doc/src/manual/methods.md
@@ -334,10 +334,11 @@ Stacktrace:
 [...]
 ```
 
-Here the call `g(2.0, 3.0)` could be handled by either the `g(Float64, Any)` or the `g(Any, Float64)`
-method, and neither is more specific than the other. In such cases, Julia raises a [`MethodError`](@ref)
-rather than arbitrarily picking a method. You can avoid method ambiguities by specifying an appropriate
-method for the intersection case:
+Here the call `g(2.0, 3.0)` could be handled by either the `g(::Float64, ::Any)` or the
+`g(::Any, ::Float64)` method. The order in which the methods are defined does not matter and
+neither is more specific than the other. In such cases, Julia raises a
+[`MethodError`](@ref) rather than arbitrarily picking a method. You can avoid method
+ambiguities by specifying an appropriate method for the intersection case:
 
 ```jldoctest gofxy
 julia> g(x::Float64, y::Float64) = 2x + 2y
@@ -406,7 +407,20 @@ Here's an example where the method type parameter `T` is used as the type parame
 type `Vector{T}` in the method signature:
 
 ```jldoctest
-julia> myappend(v::Vector{T}, x::T) where {T} = [v..., x]
+julia> function myappend(v::Vector{T}, x::T) where {T}
+           return [v..., x]
+       end
+myappend (generic function with 1 method)
+```
+
+The type parameter `T` in this example ensures that the added element `x` is a subtype of the
+existing eltype of the vector `v`.
+The `where` keyword introduces a list of those constraints after the method signature definition.
+This works the same for one-line definitions, as seen above, and must appear _before_ the [return
+type declaration](@ref man-functions-return-type), if present, as illustrated below:
+
+```jldoctest
+julia> (myappend(v::Vector{T}, x::T)::Vector) where {T} = [v..., x]
 myappend (generic function with 1 method)
 
 julia> myappend([1,2,3],4)
@@ -444,9 +458,9 @@ Stacktrace:
 [...]
 ```
 
-As you can see, the type of the appended element must match the element type of the vector it
-is appended to, or else a [`MethodError`](@ref) is raised. In the following example, the method type parameter
-`T` is used as the return value:
+If the type of the appended element does not match the element type of the vector it is appended to,
+a [`MethodError`](@ref) is raised.
+In the following example, the method's type parameter `T` is used as the return value:
 
 ```jldoctest
 julia> mytypeof(x::T) where {T} = T

From 518548715dab77e3fceb67284051b698d3f9bb8d Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Wed, 1 Nov 2023 12:16:33 -0400
Subject: [PATCH 0154/1315] When ASAN is enabled, disable
 DebugObjectManagerPlugin on JITLink+ELF (#51917)

---
 src/jitlayers.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index e0b9b0f8e2e69..971a813eb20b1 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1989,11 +1989,11 @@ void JuliaOJIT::enableJITDebuggingSupport()
     cantFail(JD.define(orc::absoluteSymbols(GDBFunctions)));
     if (TM->getTargetTriple().isOSBinFormatMachO())
         ObjectLayer.addPlugin(cantFail(orc::GDBJITDebugInfoRegistrationPlugin::Create(ES, JD, TM->getTargetTriple())));
-/*
+#ifndef _COMPILER_ASAN_ENABLED_ // TODO: Fix duplicated sections spam #51794
     else if (TM->getTargetTriple().isOSBinFormatELF())
         //EPCDebugObjectRegistrar doesn't take a JITDylib, so we have to directly provide the call address
         ObjectLayer.addPlugin(std::make_unique<orc::DebugObjectManagerPlugin>(ES, std::make_unique<orc::EPCDebugObjectRegistrar>(ES, orc::ExecutorAddr::fromPtr(&llvm_orc_registerJITLoaderGDBWrapper))));
-*/
+#endif
 }
 #else
 void JuliaOJIT::enableJITDebuggingSupport()

From e2a6424ee11ca685172244fb6a309932cd9ae921 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Wed, 1 Nov 2023 13:16:12 -0400
Subject: [PATCH 0155/1315] clean up identifiers defined in `Main` (#51878)

A re-do of #51411 that should be non-breaking.

- Loaded packages do not need explicit bindings
- The name `MainInclude` does not need to be visible
- Put Main's eval and include in the module like all other modules and
hide them explicitly instead
---
 base/client.jl                     | 59 ++++--------------------------
 base/docs/basedocs.jl              |  4 +-
 base/sysimg.jl                     | 42 ++++++++++++++++++++-
 doc/src/base/base.md               |  4 +-
 src/ast.c                          |  4 ++
 src/julia_internal.h               |  2 +
 src/module.c                       |  3 +-
 stdlib/REPL/src/REPLCompletions.jl |  2 +-
 8 files changed, 62 insertions(+), 58 deletions(-)

diff --git a/base/client.jl b/base/client.jl
index c4106fefb4dc8..201792c786b51 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -261,8 +261,8 @@ function exec_options(opts)
     distributed_mode = (opts.worker == 1) || (opts.nprocs > 0) || (opts.machine_file != C_NULL)
     if distributed_mode
         let Distributed = require(PkgId(UUID((0x8ba89e20_285c_5b6f, 0x9357_94700520ee1b)), "Distributed"))
-            Core.eval(Main, :(const Distributed = $Distributed))
-            Core.eval(Main, :(using .Distributed))
+            Core.eval(MainInclude, :(const Distributed = $Distributed))
+            Core.eval(Main, :(using Base.MainInclude.Distributed))
         end
 
         invokelatest(Main.Distributed.process_opts, opts)
@@ -384,19 +384,18 @@ _atreplinit(repl) = invokelatest(__atreplinit, repl)
 
 function load_InteractiveUtils(mod::Module=Main)
     # load interactive-only libraries
-    if !isdefined(mod, :InteractiveUtils)
+    if !isdefined(MainInclude, :InteractiveUtils)
         try
             let InteractiveUtils = require(PkgId(UUID(0xb77e0a4c_d291_57a0_90e8_8db25a27a240), "InteractiveUtils"))
-                Core.eval(mod, :(const InteractiveUtils = $InteractiveUtils))
-                Core.eval(mod, :(using .InteractiveUtils))
-                return InteractiveUtils
+                Core.eval(MainInclude, :(const InteractiveUtils = $InteractiveUtils))
             end
         catch ex
             @warn "Failed to import InteractiveUtils into module $mod" exception=(ex, catch_backtrace())
+            return nothing
         end
-        return nothing
     end
-    return getfield(mod, :InteractiveUtils)
+    Core.eval(mod, :(using Base.MainInclude.InteractiveUtils))
+    return MainInclude.InteractiveUtils
 end
 
 function load_REPL()
@@ -486,17 +485,9 @@ function run_main_repl(interactive::Bool, quiet::Bool, banner::Symbol, history_f
     nothing
 end
 
-# MainInclude exists to hide Main.include and eval from `names(Main)`.
+# MainInclude exists to weakly add certain identifiers to Main
 baremodule MainInclude
 using ..Base
-# These definitions calls Base._include rather than Base.include to get
-# one-frame stacktraces for the common case of using include(fname) in Main.
-include(mapexpr::Function, fname::AbstractString) = Base._include(mapexpr, Main, fname)
-function include(fname::AbstractString)
-    isa(fname, String) || (fname = Base.convert(String, fname)::String)
-    Base._include(identity, Main, fname)
-end
-eval(x) = Core.eval(Main, x)
 
 """
     ans
@@ -515,18 +506,8 @@ global err = nothing
 
 # weakly exposes ans and err variables to Main
 export ans, err
-
 end
 
-"""
-    eval(expr)
-
-Evaluate an expression in the global scope of the containing module.
-Every `Module` (except those defined with `baremodule`) has its own 1-argument
-definition of `eval`, which evaluates expressions in that module.
-"""
-MainInclude.eval
-
 function should_use_main_entrypoint()
     isdefined(Main, :main) || return false
     M_binding_owner = Base.binding_module(Main, :main)
@@ -534,30 +515,6 @@ function should_use_main_entrypoint()
     return true
 end
 
-"""
-    include([mapexpr::Function,] path::AbstractString)
-
-Evaluate the contents of the input source file in the global scope of the containing module.
-Every module (except those defined with `baremodule`) has its own
-definition of `include`, which evaluates the file in that module.
-Returns the result of the last evaluated expression of the input file. During including,
-a task-local include path is set to the directory containing the file. Nested calls to
-`include` will search relative to that path. This function is typically used to load source
-interactively, or to combine files in packages that are broken into multiple source files.
-The argument `path` is normalized using [`normpath`](@ref) which will resolve
-relative path tokens such as `..` and convert `/` to the appropriate path separator.
-
-The optional first argument `mapexpr` can be used to transform the included code before
-it is evaluated: for each parsed expression `expr` in `path`, the `include` function
-actually evaluates `mapexpr(expr)`.  If it is omitted, `mapexpr` defaults to [`identity`](@ref).
-
-Use [`Base.include`](@ref) to evaluate a file into another module.
-
-!!! compat "Julia 1.5"
-    Julia 1.5 is required for passing the `mapexpr` argument.
-"""
-MainInclude.include
-
 function _start()
     empty!(ARGS)
     append!(ARGS, Core.ARGS)
diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index f6942a8d4e9e8..071e5b38e3585 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -165,7 +165,7 @@ kw"__init__"
     baremodule
 
 `baremodule` declares a module that does not contain `using Base` or local definitions of
-[`eval`](@ref Base.MainInclude.eval) and [`include`](@ref Base.include). It does still import `Core`. In other words,
+[`eval`](@ref Main.eval) and [`include`](@ref Base.include). It does still import `Core`. In other words,
 
 ```julia
 module Mod
@@ -217,7 +217,7 @@ kw"primitive type"
 A macro maps a sequence of argument expressions to a returned expression, and the
 resulting expression is substituted directly into the program at the point where
 the macro is invoked.
-Macros are a way to run generated code without calling [`eval`](@ref Base.MainInclude.eval),
+Macros are a way to run generated code without calling [`eval`](@ref Main.eval),
 since the generated code instead simply becomes part of the surrounding program.
 Macro arguments may include expressions, literal values, and symbols. Macros can be defined for
 variable number of arguments (varargs), but do not accept keyword arguments.
diff --git a/base/sysimg.jl b/base/sysimg.jl
index 31efa933c1104..4ae876a929f0e 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -6,7 +6,46 @@ using .Base
 
 # Set up Main module
 using Base.MainInclude # ans, err, and sometimes Out
-import Base.MainInclude: eval, include
+
+# These definitions calls Base._include rather than Base.include to get
+# one-frame stacktraces for the common case of using include(fname) in Main.
+
+"""
+    include([mapexpr::Function,] path::AbstractString)
+
+Evaluate the contents of the input source file in the global scope of the containing module.
+Every module (except those defined with `baremodule`) has its own
+definition of `include`, which evaluates the file in that module.
+Returns the result of the last evaluated expression of the input file. During including,
+a task-local include path is set to the directory containing the file. Nested calls to
+`include` will search relative to that path. This function is typically used to load source
+interactively, or to combine files in packages that are broken into multiple source files.
+The argument `path` is normalized using [`normpath`](@ref) which will resolve
+relative path tokens such as `..` and convert `/` to the appropriate path separator.
+
+The optional first argument `mapexpr` can be used to transform the included code before
+it is evaluated: for each parsed expression `expr` in `path`, the `include` function
+actually evaluates `mapexpr(expr)`.  If it is omitted, `mapexpr` defaults to [`identity`](@ref).
+
+Use [`Base.include`](@ref) to evaluate a file into another module.
+
+!!! compat "Julia 1.5"
+    Julia 1.5 is required for passing the `mapexpr` argument.
+"""
+include(mapexpr::Function, fname::AbstractString) = Base._include(mapexpr, Main, fname)
+function include(fname::AbstractString)
+    isa(fname, String) || (fname = Base.convert(String, fname)::String)
+    Base._include(identity, Main, fname)
+end
+
+"""
+    eval(expr)
+
+Evaluate an expression in the global scope of the containing module.
+Every `Module` (except those defined with `baremodule`) has its own 1-argument
+definition of `eval`, which evaluates expressions in that module.
+"""
+eval(x) = Core.eval(Main, x)
 
 # Ensure this file is also tracked
 pushfirst!(Base._included_files, (@__MODULE__, abspath(@__FILE__)))
@@ -80,6 +119,7 @@ let
     Base.init_load_path() # want to be able to find external packages in userimg.jl
 
     ccall(:jl_clear_implicit_imports, Cvoid, (Any,), Main)
+
     tot_time_userimg = @elapsed (isfile("userimg.jl") && Base.include(Main, "userimg.jl"))
 
     tot_time_base = (Base.end_base_include - Base.start_base_include) * 10.0^(-9)
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 39e61738bf1ed..46ac9b2ba05e8 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -30,7 +30,7 @@ Base.isinteractive
 Base.summarysize
 Base.__precompile__
 Base.include
-Base.MainInclude.include
+Main.include
 Base.include_string
 Base.include_dependency
 __init__
@@ -285,7 +285,7 @@ Base.Fix2
 
 ```@docs
 Core.eval
-Base.MainInclude.eval
+Main.eval
 Base.@eval
 Base.evalfile
 Base.esc
diff --git a/src/ast.c b/src/ast.c
index 89ee3f70bf2fd..4647dd9f85a63 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -98,6 +98,8 @@ JL_DLLEXPORT jl_sym_t *jl_aliasscope_sym;
 JL_DLLEXPORT jl_sym_t *jl_popaliasscope_sym;
 JL_DLLEXPORT jl_sym_t *jl_optlevel_sym;
 JL_DLLEXPORT jl_sym_t *jl_thismodule_sym;
+JL_DLLEXPORT jl_sym_t *jl_eval_sym;
+JL_DLLEXPORT jl_sym_t *jl_include_sym;
 JL_DLLEXPORT jl_sym_t *jl_atom_sym;
 JL_DLLEXPORT jl_sym_t *jl_statement_sym;
 JL_DLLEXPORT jl_sym_t *jl_all_sym;
@@ -365,6 +367,8 @@ void jl_init_common_symbols(void)
     jl_aliasscope_sym = jl_symbol("aliasscope");
     jl_popaliasscope_sym = jl_symbol("popaliasscope");
     jl_thismodule_sym = jl_symbol("thismodule");
+    jl_eval_sym = jl_symbol("eval");
+    jl_include_sym = jl_symbol("include");
     jl_block_sym = jl_symbol("block");
     jl_atom_sym = jl_symbol("atom");
     jl_statement_sym = jl_symbol("statement");
diff --git a/src/julia_internal.h b/src/julia_internal.h
index f9a50b247b35d..09a963258d566 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1570,6 +1570,8 @@ extern JL_DLLEXPORT jl_sym_t *jl_aliasscope_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_popaliasscope_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_optlevel_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_thismodule_sym;
+extern JL_DLLEXPORT jl_sym_t *jl_eval_sym;
+extern JL_DLLEXPORT jl_sym_t *jl_include_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_atom_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_statement_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_all_sym;
diff --git a/src/module.c b/src/module.c
index b9abc2ce6bc38..a5b967dc67735 100644
--- a/src/module.c
+++ b/src/module.c
@@ -951,9 +951,10 @@ JL_DLLEXPORT jl_value_t *jl_module_names(jl_module_t *m, int all, int imported)
             break;
         jl_sym_t *asname = b->globalref->name;
         int hidden = jl_symbol_name(asname)[0]=='#';
+        int main_public = (m == jl_main_module && !(asname == jl_eval_sym || asname == jl_include_sym));
         if ((b->publicp ||
              (imported && b->imported) ||
-             (jl_atomic_load_relaxed(&b->owner) == b && !b->imported && (all || m == jl_main_module))) &&
+             (jl_atomic_load_relaxed(&b->owner) == b && !b->imported && (all || main_public))) &&
             (all || (!b->deprecated && !hidden))) {
             jl_array_grow_end(a, 1);
             // n.b. change to jl_arrayset if array storage allocation for Array{Symbols,1} changes:
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index d7f5a7cc0c23f..2c2646636b53a 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -176,7 +176,7 @@ function complete_symbol(@nospecialize(ex), name::String, @nospecialize(ffunc),
         # as excluding Main.Main.Main, etc., because that's most likely not what
         # the user wants
         p = let mod=mod, modname=nameof(mod)
-            (s::Symbol) -> !Base.isdeprecated(mod, s) && s != modname && ffunc(mod, s)::Bool
+            (s::Symbol) -> !Base.isdeprecated(mod, s) && s != modname && ffunc(mod, s)::Bool && !(mod === Main && s === :MainInclude)
         end
         # Looking for a binding in a module
         if mod == context_module

From 405ce111a86ea85a97734efed0ea995cfdc7f56c Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Wed, 1 Nov 2023 13:18:08 -0400
Subject: [PATCH 0156/1315] further fix to the new promoting method for
 AbstractDateTime subtraction (#51967)

---
 stdlib/Dates/src/arithmetic.jl  | 2 +-
 stdlib/Dates/test/arithmetic.jl | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/stdlib/Dates/src/arithmetic.jl b/stdlib/Dates/src/arithmetic.jl
index b379747c5f9e9..83a2873b43409 100644
--- a/stdlib/Dates/src/arithmetic.jl
+++ b/stdlib/Dates/src/arithmetic.jl
@@ -7,7 +7,7 @@
 # TimeType arithmetic
 (+)(x::TimeType) = x
 (-)(x::T, y::T) where {T<:TimeType} = x.instant - y.instant
-(-)(x::DateTime, y::DateTime) = x.instant - y.instant
+(-)(x::T, y::T) where {T<:AbstractDateTime} = x.instant - y.instant
 (-)(x::AbstractDateTime, y::AbstractDateTime) = -(promote(x, y)...)
 
 # Date-Time arithmetic
diff --git a/stdlib/Dates/test/arithmetic.jl b/stdlib/Dates/test/arithmetic.jl
index 6e2e89fe32b68..333ba3a7c0088 100644
--- a/stdlib/Dates/test/arithmetic.jl
+++ b/stdlib/Dates/test/arithmetic.jl
@@ -14,10 +14,15 @@ end
 struct MonthlyDate <: TimeType
     instant::Dates.UTInstant{Month}
 end
+struct OtherTime <: Dates.AbstractDateTime
+    instant::Dates.UTInstant{Nanosecond}
+end
 @testset "TimeType arithmetic" begin
     @test_throws MethodError DateTime(2023, 5, 2) - Date(2023, 5, 1)
     # check that - between two same-type TimeTypes works by default
     @test MonthlyDate(Dates.UTInstant(Month(10))) - MonthlyDate(Dates.UTInstant(Month(1))) == Month(9)
+    # ... and between two same-type AbstractDateTimes
+    @test OtherTime(Dates.UTInstant(Nanosecond(2))) - OtherTime(Dates.UTInstant(Nanosecond(1))) == Nanosecond(1)
 end
 
 @testset "Wrapping arithmetic for Months" begin

From c01913235baee7870b6784cb0ca1a0b54d9e01c0 Mon Sep 17 00:00:00 2001
From: Harsha Byadarahalli Mahesh <bmharsha@users.noreply.github.com>
Date: Thu, 2 Nov 2023 01:50:40 +0530
Subject: [PATCH 0157/1315] Update documentation for min and max with missing
 values (#48906)

With respect to https://github.com/JuliaLang/julia/pull/25403 , `min`
and `max` methods are supposed to return "missing" whenever we pass
"missing" value as one of the arguments, this PR updates the inline
documentation to reflect the same.
---
 base/operators.jl | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/base/operators.jl b/base/operators.jl
index 9f116c07ad14c..5c403e5764563 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -464,13 +464,17 @@ cmp(x::Integer, y::Integer) = ifelse(isless(x, y), -1, ifelse(isless(y, x), 1, 0
 """
     max(x, y, ...)
 
-Return the maximum of the arguments (with respect to [`isless`](@ref)). See also the [`maximum`](@ref) function
-to take the maximum element from a collection.
+Return the maximum of the arguments, with respect to [`isless`](@ref).
+If any of the arguments is [`missing`](@ref), return `missing`.
+See also the [`maximum`](@ref) function to take the maximum element from a collection.
 
 # Examples
 ```jldoctest
 julia> max(2, 5, 1)
 5
+
+julia> max(5, missing, 6)
+missing
 ```
 """
 max(x, y) = ifelse(isless(y, x), x, y)
@@ -478,13 +482,17 @@ max(x, y) = ifelse(isless(y, x), x, y)
 """
     min(x, y, ...)
 
-Return the minimum of the arguments (with respect to [`isless`](@ref)). See also the [`minimum`](@ref) function
-to take the minimum element from a collection.
+Return the minimum of the arguments, with respect to [`isless`](@ref).
+If any of the arguments is [`missing`](@ref), return `missing`.
+See also the [`minimum`](@ref) function to take the minimum element from a collection.
 
 # Examples
 ```jldoctest
 julia> min(2, 5, 1)
 1
+
+julia> min(4, missing, 6)
+missing
 ```
 """
 min(x,y) = ifelse(isless(y, x), y, x)

From 013311cdd0dd0604066a2f534d3f144ed83fd614 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 2 Nov 2023 09:32:29 +0900
Subject: [PATCH 0158/1315] compiler: use `_uncompressed_ir` instead of direct
 `ccall` (#51972)

---
 base/compiler/inferencestate.jl | 2 +-
 base/compiler/ssair/inlining.jl | 2 +-
 base/compiler/utilities.jl      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 8eb86f48351ed..96543308e8bd7 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -733,7 +733,7 @@ function IRInterpretationState(interp::AbstractInterpreter,
     @assert code.def === mi
     src = @atomic :monotonic code.inferred
     if isa(src, String)
-        src = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), mi.def, C_NULL, src)::CodeInfo
+        src = _uncompressed_ir(mi.def, src)
     else
         isa(src, CodeInfo) || return nothing
     end
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 9d216d6cc7714..bb2c092c0a762 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -977,7 +977,7 @@ function analyze_method!(match::MethodMatch, argtypes::Vector{Any},
 end
 
 function retrieve_ir_for_inlining(mi::MethodInstance, src::String)
-    src = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), mi.def, C_NULL, src)::CodeInfo
+    src = _uncompressed_ir(mi.def, src)
     return inflate_ir!(src, mi)
 end
 retrieve_ir_for_inlining(mi::MethodInstance, src::CodeInfo) = inflate_ir(src, mi)
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 67ca98e113b4b..8f980bb681142 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -140,7 +140,7 @@ function retrieve_code_info(linfo::MethodInstance, world::UInt)
             # can happen in images built with --strip-ir
             return nothing
         elseif isa(src, String)
-            c = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), m, C_NULL, src)
+            c = _uncompressed_ir(m, src)
         else
             c = copy(src::CodeInfo)
         end

From 06de99ef626fd15b8147328a716c9a1ffb1fc712 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Thu, 2 Nov 2023 04:44:49 -0400
Subject: [PATCH 0159/1315] Make Scope immutable (#51976)

Addresses keno review comment in
https://github.com/JuliaLang/julia/pull/50958#discussion_r1378513975
---
 base/scopedvalues.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/scopedvalues.jl b/base/scopedvalues.jl
index 4c46809e75ffe..94491294c798a 100644
--- a/base/scopedvalues.jl
+++ b/base/scopedvalues.jl
@@ -56,7 +56,7 @@ Base.isassigned(val::ScopedValue) = val.has_default
 
 const ScopeStorage = Base.PersistentDict{ScopedValue, Any}
 
-mutable struct Scope
+struct Scope
     values::ScopeStorage
 end
 
@@ -114,15 +114,15 @@ function get(val::ScopedValue{T}) where {T}
     # Inline current_scope to avoid doing the type assertion twice.
     scope = current_task().scope
     if scope === nothing
-        isassigned(val) && return Some(val.default)
+        isassigned(val) && return Some{T}(val.default)
         return nothing
     end
     scope = scope::Scope
     if isassigned(val)
-        return Some(Base.get(scope.values, val, val.default)::T)
+        return Some{T}(Base.get(scope.values, val, val.default)::T)
     else
         v = Base.get(scope.values, val, novalue)
-        v === novalue || return Some(v::T)
+        v === novalue || return Some{T}(v::T)
     end
     return nothing
 end

From 58a2a4545fd650ebfebdc93553651e367ed01e27 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Thu, 2 Nov 2023 04:45:48 -0400
Subject: [PATCH 0160/1315] make NEWS.md link style more consistent (#51978)

Minor PR to make the PR link punctuation a bit more consistent in the
NEWS file, and adds a couple of missing PR links.
---
 NEWS.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 75a8ac9ab71f8..bef861803a042 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -6,7 +6,7 @@ New language features
 * `public` is a new keyword. Symbols marked with `public` are considered public
   API. Symbols marked with `export` are now also treated as public API. The
   difference between `public` and `export` is that `public` names do not become
-  available when `using` a package/module. ([#50105])
+  available when `using` a package/module ([#50105]).
 * `ScopedValue` implement dynamic scope with inheritance across tasks ([#50958]).
 * The new macro `Base.Cartesian.@ncallkw` is analogous to `Base.Cartesian.@ncall`,
   but allows to add keyword arguments to the function call ([#51501]).
@@ -34,7 +34,7 @@ Command-line option changes
 (i.e. using `julia script.jl` or `julia -e expr`), julia will subsequently run the `Main.main` function automatically.
 This is intended to unify script and compilation workflows, where code loading may happen
 in the compiler and execution of `Main.main` may happen in the resulting executable. For interactive use, there is no semantic
-difference between defining a `main` function and executing the code directly at the end of the script. ([50974])
+difference between defining a `main` function and executing the code directly at the end of the script ([50974]).
 
 Multi-threading changes
 -----------------------
@@ -46,8 +46,8 @@ New library functions
 ---------------------
 
 * The new `Libc.mkfifo` function wraps the `mkfifo` C function on Unix platforms ([#34587]).
-* `hardlink(src, dst)` can be used to create hard links. ([#41639])
-* `diskstat(path=pwd())` can be used to return statistics about the disk. ([#42248])
+* `hardlink(src, dst)` can be used to create hard links ([#41639]).
+* `diskstat(path=pwd())` can be used to return statistics about the disk ([#42248]).
 * `copyuntil(out, io, delim)` and `copyline(out, io)` copy data into an `out::IO` stream ([#48273]).
 * `eachrsplit(string, pattern)` iterates split substrings right to left.
 
@@ -61,14 +61,14 @@ Standard library changes
 
 #### StyledStrings
 
-* A new standard library for handling styling in a more comprehensive and structured way.
+* A new standard library for handling styling in a more comprehensive and structured way ([#49586]).
 * The new `Faces` struct serves as a container for text styling information
   (think typeface, as well as color and decoration), and comes with a framework
   to provide a convenient, extensible (via `addface!`), and customisable (with a
   user's `Faces.toml` and `loadfaces!`) approach to
-  styled content.
+  styled content ([#49586]).
 * The new `@styled_str` string macro provides a convenient way of creating a
-  `AnnotatedString` with various faces or other attributes applied.
+  `AnnotatedString` with various faces or other attributes applied ([#49586]).
 
 #### Package Manager
 
@@ -88,7 +88,7 @@ Standard library changes
 #### REPL
 
 * Tab complete hints now show in lighter text while typing in the repl. To disable
-  set `Base.active_repl.options.hint_tab_completes = false` ([#51229])
+  set `Base.active_repl.options.hint_tab_completes = false` ([#51229]).
 * Meta-M with an empty prompt now returns the contextual module of the REPL to `Main`.
 
 #### SuiteSparse
@@ -102,7 +102,7 @@ Standard library changes
 
 #### Statistics
 
-* Statistics is now an upgradeable standard library.([#46501])
+* Statistics is now an upgradeable standard library ([#46501]).
 
 #### Distributed
 
@@ -122,13 +122,13 @@ Deprecated or removed
 
 External dependencies
 ---------------------
-* `tput` is no longer called to check terminal capabilities, it has been replaced with a pure-Julia terminfo parser.
+* `tput` is no longer called to check terminal capabilities, it has been replaced with a pure-Julia terminfo parser ([#50797]).
 
 Tooling Improvements
 --------------------
 
 * CI now performs limited automatic typo detection on all PRs. If you merge a PR with a
   failing typo CI check, then the reported typos will be automatically ignored in future CI
-  runs on PRs that edit those same files. ([#51704])
+  runs on PRs that edit those same files ([#51704]).
 
 <!--- generated by NEWS-update.jl: -->

From 2994463d5e1b2eb8b842ecf3f129413517129081 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 2 Nov 2023 05:46:12 -0300
Subject: [PATCH 0161/1315] Stop test printing LLVM IR to stdout (#51974)

Fixes https://github.com/JuliaLang/julia/issues/51971
---
 test/opaque_closure.jl | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/opaque_closure.jl b/test/opaque_closure.jl
index a1a1e2ea53aad..856253ecd5a8d 100644
--- a/test/opaque_closure.jl
+++ b/test/opaque_closure.jl
@@ -348,4 +348,6 @@ let ir = Base.code_ircode((Int,Int)) do x, y
     @test occursin("j_*_", String(take!(io)))
 end
 
-code_llvm(()) do; Base.Experimental.@opaque(@noinline x::Int->println(x))(1) end #Shouldn't crash
+foopaque() = Base.Experimental.@opaque(@noinline x::Int->println(x))(1)
+
+code_llvm(devnull,foopaque,()) #shouldn't crash

From 8b97aa179520f12547e9466d17156316e1b8151d Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 2 Nov 2023 03:47:14 -0500
Subject: [PATCH 0162/1315] Improve style in Base/experimental.jl [NFC]
 (#51965)

Make the checks line up with the error messages.
---
 base/experimental.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/experimental.jl b/base/experimental.jl
index abcd52ffcc43f..ccc041b41ec05 100644
--- a/base/experimental.jl
+++ b/base/experimental.jl
@@ -143,7 +143,7 @@ code to resort to runtime dispatch instead.
 Supported values are `1`, `2`, `3`, `4`, and `default` (currently equivalent to `3`).
 """
 macro max_methods(n::Int)
-    0 < n < 5 || error("We must have that `1 <= max_methods <= 4`, but `max_methods = $n`.")
+    1 <= n <= 4 || error("We must have that `1 <= max_methods <= 4`, but `max_methods = $n`.")
     return Expr(:meta, :max_methods, n)
 end
 
@@ -156,13 +156,13 @@ for max_methods. This setting is global for the entire generic function (or more
 the MethodTable).
 """
 macro max_methods(n::Int, fdef::Expr)
-    0 < n <= 255 || error("We must have that `1 <= max_methods <= 255`, but `max_methods = $n`.")
+    1 <= n <= 255 || error("We must have that `1 <= max_methods <= 255`, but `max_methods = $n`.")
     (fdef.head === :function && length(fdef.args) == 1) || error("Second argument must be a function forward declaration")
     return :(typeof($(esc(fdef))).name.max_methods = $(UInt8(n)))
 end
 
 """
-    Experimental.@compiler_options optimize={0,1,2,3} compile={yes,no,all,min} infer={yes,no} max_methods={default,1,2,3,...}
+    Experimental.@compiler_options optimize={0,1,2,3} compile={yes,no,all,min} infer={yes,no} max_methods={default,1,2,3,4}
 
 Set compiler options for code in the enclosing module. Options correspond directly to
 command-line options with the same name, where applicable. The following options
@@ -195,7 +195,7 @@ macro compiler_options(args...)
             elseif ex.args[1] === :max_methods
                 a = ex.args[2]
                 a = a === :default ? 3 :
-                  a isa Int ? ((0 < a < 5) ? a : error("We must have that `1 <= max_methods <= 4`, but `max_methods = $a`.")) :
+                  a isa Int ? ((1 <= a <= 4) ? a : error("We must have that `1 <= max_methods <= 4`, but `max_methods = $a`.")) :
                   error("invalid argument to \"max_methods\" option")
                 push!(opts.args, Expr(:meta, :max_methods, a))
             else

From 7c74274d9b7ea50428d8f07eee94c559f3018f7e Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Thu, 2 Nov 2023 05:32:23 -0400
Subject: [PATCH 0163/1315] fix `pointer` for `Memory` by deleting incorrect
 method (#51963)

The fallback method for `AbstractArray` was correct and the custom one
for `Memory` wasn't.
---
 base/genericmemory.jl | 1 -
 test/core.jl          | 3 +++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index 009948188fe97..ec33cb67a4097 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -26,7 +26,6 @@ size(a::GenericMemory, d::Int) =
 size(a::GenericMemory, d::Integer) =  size(a, convert(d, Int))
 size(a::GenericMemory) = (length(a),)
 
-pointer(mem::GenericMemory, i::Int) = (@_propagate_inbounds_meta; unsafe_convert(Ptr{Cvoid}, GenericMemoryRef(mem, i))) # boundschecked, even for i==1
 pointer(mem::GenericMemoryRef) = unsafe_convert(Ptr{Cvoid}, mem) # no bounds check, even for empty array
 
 _unsetindex!(A::Memory, i::Int) =  (@_propagate_inbounds_meta; _unsetindex!(GenericMemoryRef(A, i)); A)
diff --git a/test/core.jl b/test/core.jl
index 105e34584405b..739ea182cd4f3 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -1445,6 +1445,9 @@ let
     @test unsafe_load(p2) == 101
     unsafe_store!(p2, 909, 3)
     @test a2 == [101,102,909]
+    # test for issue 51954
+    @test pointer(a.ref.mem)===pointer(a)
+    @test pointer(a.ref.mem,2)===pointer(a,2)
 end
 
 @test unsafe_pointer_to_objref(ccall(:jl_call1, Ptr{Cvoid}, (Any,Any),

From ad86772a476e60a0d7280f32ba8774a45ccd9822 Mon Sep 17 00:00:00 2001
From: Praneeth Jain <praneethjain005@gmail.com>
Date: Thu, 2 Nov 2023 15:04:08 +0530
Subject: [PATCH 0164/1315] test: eachindex for arbitrary number of arguments
 (#51941)

added test cases for `eachindex` to cover arbitrary number of arguments

![image](https://github.com/JuliaLang/julia/assets/49565677/fa39cb8c-2523-40c0-90f3-e3f90f54397e)
---
 test/arrayops.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/arrayops.jl b/test/arrayops.jl
index bf8484c398166..2691da4b17154 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -2128,6 +2128,8 @@ R = CartesianIndices((3,0))
     @test @inferred(eachindex(Base.IndexLinear(), a, b)) == 1:4
     @test @inferred(eachindex(a, b)) == CartesianIndices((2,2))
     @test @inferred(eachindex(a, a)) == 1:4
+    @test @inferred(eachindex(a, a, a)) == 1:4
+    @test @inferred(eachindex(a, a, b)) == CartesianIndices((2,2))
     @test_throws DimensionMismatch eachindex(a, rand(3,3))
     @test_throws DimensionMismatch eachindex(b, rand(3,3))
 end

From 54996ca05c00b08c92adf4aa55d728a7c69fd06c Mon Sep 17 00:00:00 2001
From: Denis Barucic <barucic.d@gmail.com>
Date: Thu, 2 Nov 2023 14:48:16 +0100
Subject: [PATCH 0165/1315] add function `Sys.username()` (#51897)

The commit introduces a new function to Base which returns the current
user's username retrieved from the password database.

Resolves #48302
Closes #48928
Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 NEWS.md              |  1 +
 base/libc.jl         | 21 +++++++++++++++++++++
 base/sysinfo.jl      | 22 ++++++++++++++++++++++
 doc/src/base/base.md |  1 +
 test/sysinfo.jl      | 11 +++++++++++
 5 files changed, 56 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index bef861803a042..1b3cc6438e03f 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -50,6 +50,7 @@ New library functions
 * `diskstat(path=pwd())` can be used to return statistics about the disk ([#42248]).
 * `copyuntil(out, io, delim)` and `copyline(out, io)` copy data into an `out::IO` stream ([#48273]).
 * `eachrsplit(string, pattern)` iterates split substrings right to left.
+* `Sys.username()` can be used to return the current user's username ([#51897]).
 
 New library features
 --------------------
diff --git a/base/libc.jl b/base/libc.jl
index f74f7b4ca5230..1fcf763e4e124 100644
--- a/base/libc.jl
+++ b/base/libc.jl
@@ -493,6 +493,26 @@ struct Group
     mem::Vector{String}
 end
 
+# Gets password-file entry for default user, or a subset thereof
+# (e.g., uid and guid are set to -1 on Windows)
+function getpw()
+    ref_pd = Ref(Cpasswd())
+    ret = ccall(:uv_os_get_passwd, Cint, (Ref{Cpasswd},), ref_pd)
+    Base.uv_error("getpw", ret)
+
+    pd = ref_pd[]
+    pd = Passwd(
+        pd.username == C_NULL ? "" : unsafe_string(pd.username),
+        pd.uid,
+        pd.gid,
+        pd.shell == C_NULL ? "" : unsafe_string(pd.shell),
+        pd.homedir == C_NULL ? "" : unsafe_string(pd.homedir),
+        pd.gecos == C_NULL ? "" : unsafe_string(pd.gecos),
+    )
+    ccall(:uv_os_free_passwd, Cvoid, (Ref{Cpasswd},), ref_pd)
+    return pd
+end
+
 function getpwuid(uid::Unsigned, throw_error::Bool=true)
     ref_pd = Ref(Cpasswd())
     ret = ccall(:uv_os_get_passwd2, Cint, (Ref{Cpasswd}, Culong), ref_pd, uid)
@@ -512,6 +532,7 @@ function getpwuid(uid::Unsigned, throw_error::Bool=true)
     ccall(:uv_os_free_passwd, Cvoid, (Ref{Cpasswd},), ref_pd)
     return pd
 end
+
 function getgrgid(gid::Unsigned, throw_error::Bool=true)
     ref_gp = Ref(Cgroup())
     ret = ccall(:uv_os_get_group, Cint, (Ref{Cgroup}, Culong), ref_gp, gid)
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 2c962088484e7..53835366d3171 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -33,6 +33,7 @@ export BINDIR,
        iswindows,
        isjsvm,
        isexecutable,
+       username,
        which
 
 import ..Base: show
@@ -567,4 +568,25 @@ function which(program_name::String)
 end
 which(program_name::AbstractString) = which(String(program_name))
 
+"""
+    Sys.username() -> String
+
+Return the username for the current user. If the username cannot be determined
+or is empty, this function throws an error.
+
+To retrieve a username that is overridable via an environment variable,
+e.g., `USER`, consider using
+```julia
+user = get(Sys.username, ENV, "USER")
+```
+
+!!! compat "Julia 1.11"
+    This function requires at least Julia 1.11.
+"""
+function username()
+    pw = Libc.getpw()
+    isempty(pw.username) && Base.uv_error("username", Base.UV_ENOENT)
+    return pw.username
+end
+
 end # module Sys
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 46ac9b2ba05e8..c5d7320148e97 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -373,6 +373,7 @@ Base.Sys.uptime
 Base.Sys.isjsvm
 Base.Sys.loadavg
 Base.Sys.isexecutable
+Base.Sys.username
 Base.@static
 ```
 
diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index cb943cfd38843..e8194b113ba24 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -41,3 +41,14 @@ if Sys.isunix()
         end
     end
 end
+
+@testset "username()" begin
+    if Sys.isunix()
+        passwd = Libc.getpwuid(Libc.getuid())
+        @test Sys.username() == passwd.username
+    elseif Sys.iswindows()
+        @test Sys.username() == ENV["USERNAME"]
+    else
+        @test !isempty(Sys.username())
+    end
+end

From 924aac92b977b7a492c8cba878ff14329a4ad4b0 Mon Sep 17 00:00:00 2001
From: Paul Berg <paul@plutojl.org>
Date: Thu, 2 Nov 2023 14:53:26 +0100
Subject: [PATCH 0166/1315] macroexpand: handle const/atomic struct fields
 correctly (#51980)

Fixes #51899
---
 src/macroexpand.scm | 28 +++++++++++++++++-----------
 test/syntax.jl      | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+), 11 deletions(-)

diff --git a/src/macroexpand.scm b/src/macroexpand.scm
index e0e809eee08f1..6e390a6c24cf2 100644
--- a/src/macroexpand.scm
+++ b/src/macroexpand.scm
@@ -340,8 +340,22 @@
 
 (define (reescape ux x)
   (if (and (pair? x) (eq? (car x) 'escape))
-    (reescape '(escape ,ux) (cadr x)))
-    ux)
+    (reescape `(escape ,ux) (cadr x))
+    ux))
+
+;; type has special behavior: identifiers inside are
+;; field names, not expressions.
+(define (resolve-struct-field-expansion x env m parent-scope inarg)
+  (let ((ux (unescape x)))
+    (cond
+        ((atom? ux) ux)
+        ((and (pair? ux) (eq? (car ux) '|::|))
+         `(|::| ,(unescape (cadr ux))
+           ,(resolve-expansion-vars- (reescape (caddr ux) x) env m parent-scope inarg)))
+        ((and (pair? ux) (memq (car ux) '(const atomic)))
+         `(,(car ux) ,(resolve-struct-field-expansion (reescape (cadr ux) x) env m parent-scope inarg)))
+        (else
+         (resolve-expansion-vars-with-new-env x env m parent-scope inarg)))))
 
 (define (resolve-expansion-vars- e env m parent-scope inarg)
   (cond ((or (eq? e 'begin) (eq? e 'end) (eq? e 'ccall) (eq? e 'cglobal) (underscore-symbol? e))
@@ -377,16 +391,8 @@
            ((symbolicgoto) e)
            ((struct)
             `(struct ,(cadr e) ,(resolve-expansion-vars- (caddr e) env m parent-scope inarg)
-                     ;; type has special behavior: identifiers inside are
-                     ;; field names, not expressions.
                      ,(map (lambda (x)
-                             (let ((ux (unescape x)))
-                                  (cond ((atom? ux) ux)
-                                        ((and (pair? ux) (eq? (car ux) '|::|))
-                                         `(|::| ,(unescape (cadr ux))
-                                           ,(resolve-expansion-vars- (reescape (caddr ux) x) env m parent-scope inarg)))
-                                        (else
-                                         (resolve-expansion-vars-with-new-env x env m parent-scope inarg)))))
+                            (resolve-struct-field-expansion x env m parent-scope inarg))
                            (cadddr e))))
 
            ((parameters)
diff --git a/test/syntax.jl b/test/syntax.jl
index 67916e8d37d8c..a2f8ed76373b6 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -1783,6 +1783,43 @@ end
 @test B28593.var.name === :S
 @test C28593.var.name === :S
 
+# issue #51899
+macro struct_macro_51899()
+    quote
+        mutable struct Struct51899
+            const const_field
+            const const_field_with_type::Int
+            $(esc(Expr(:const, :(escaped_const_field::MyType))))
+            @atomic atomic_field
+            @atomic atomic_field_with_type::Int
+        end
+    end
+end
+
+let ex = @macroexpand @struct_macro_51899()
+    const_field, const_field_with_type, escaped_const_field,
+    atomic_field, atomic_field_with_type = filter(x -> isa(x, Expr), ex.args[end].args[end].args)
+    @test Meta.isexpr(const_field, :const)
+    @test const_field.args[1] === :const_field
+
+    @test Meta.isexpr(const_field_with_type, :const)
+    @test Meta.isexpr(const_field_with_type.args[1], :(::))
+    @test const_field_with_type.args[1].args[1] === :const_field_with_type
+    @test const_field_with_type.args[1].args[2] == GlobalRef(@__MODULE__, :Int)
+
+    @test Meta.isexpr(escaped_const_field, :const)
+    @test Meta.isexpr(const_field_with_type.args[1], :(::))
+    @test escaped_const_field.args[1].args[1] === :escaped_const_field
+    @test escaped_const_field.args[1].args[2] === :MyType
+
+    @test Meta.isexpr(atomic_field, :atomic)
+    @test atomic_field.args[1] === :atomic_field
+
+    @test Meta.isexpr(atomic_field_with_type, :atomic)
+    @test atomic_field_with_type.args[1].args[1] === :atomic_field_with_type
+    @test atomic_field_with_type.args[1].args[2] == GlobalRef(@__MODULE__, :Int)
+end
+
 # issue #25955
 macro noeffect25955(e)
     return e

From 55e5ee386839350387d9a8857c71509a16315953 Mon Sep 17 00:00:00 2001
From: Ben Conrad <bc0n@users.noreply.github.com>
Date: Thu, 2 Nov 2023 09:00:23 -0500
Subject: [PATCH 0167/1315] Clarify conversion-and-promotion.md example code
 for `convert` (#50274)

Closes: https://github.com/JuliaLang/julia/issues/50273
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 doc/src/manual/conversion-and-promotion.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/src/manual/conversion-and-promotion.md b/doc/src/manual/conversion-and-promotion.md
index f0c156f21ea62..9f785a560bfcc 100644
--- a/doc/src/manual/conversion-and-promotion.md
+++ b/doc/src/manual/conversion-and-promotion.md
@@ -165,6 +165,7 @@ constructor.
 Such a definition might look like this:
 
 ```julia
+import Base: convert
 convert(::Type{MyType}, x) = MyType(x)
 ```
 
@@ -195,6 +196,8 @@ convert(::Type{T}, x::T) where {T<:Number} = x
 
 Similar definitions exist for `AbstractString`, [`AbstractArray`](@ref), and [`AbstractDict`](@ref).
 
+
+
 ## Promotion
 
 Promotion refers to converting values of mixed types to a single common type. Although it is not
@@ -291,6 +294,7 @@ another type object, such that instances of the argument types will be promoted
 type. Thus, by defining the rule:
 
 ```julia
+import Base: promote_rule
 promote_rule(::Type{Float64}, ::Type{Float32}) = Float64
 ```
 
@@ -336,6 +340,7 @@ Finally, we finish off our ongoing case study of Julia's rational number type, w
 sophisticated use of the promotion mechanism with the following promotion rules:
 
 ```julia
+import Base: promote_rule
 promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:Integer} = Rational{promote_type(T,S)}
 promote_rule(::Type{Rational{T}}, ::Type{Rational{S}}) where {T<:Integer,S<:Integer} = Rational{promote_type(T,S)}
 promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:AbstractFloat} = promote_type(T,S)

From dabb93a6022f695ea9b9686669a249de2e9b29a8 Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Thu, 2 Nov 2023 15:06:48 +0100
Subject: [PATCH 0168/1315] Document the fields of `VersionNumber` (#50179)

`VersionNumber`'s fields are currently not documented, and therefore,
private by default.
However, if people want to use `VersionNumber` for anything other than
the documented comparison operations, users will have to access the
fields.
---
 base/version.jl | 7 +++++++
 test/version.jl | 9 +++++++++
 2 files changed, 16 insertions(+)

diff --git a/base/version.jl b/base/version.jl
index 2b332793496f3..e078b5f9d4ac9 100644
--- a/base/version.jl
+++ b/base/version.jl
@@ -16,6 +16,13 @@ alphanumeric annotations.
 `VersionNumber` objects can be compared with all of the standard comparison
 operators (`==`, `<`, `<=`, etc.), with the result following semver rules.
 
+`VersionNumber` has the the following public fields:
+- `v.major::Integer`
+- `v.minor::Integer`
+- `v.patch::Integer`
+- `v.prerelease::Tuple{Vararg{Union{Integer, AbstractString}}}`
+- `v.build::Tuple{Vararg{Union{Integer, AbstractString}}}`
+
 See also [`@v_str`](@ref) to efficiently construct `VersionNumber` objects
 from semver-format literal strings, [`VERSION`](@ref) for the `VersionNumber`
 of Julia itself, and [Version Number Literals](@ref man-version-number-literals)
diff --git a/test/version.jl b/test/version.jl
index 78d606ac2a6cb..242b32c47cbdc 100644
--- a/test/version.jl
+++ b/test/version.jl
@@ -219,6 +219,15 @@ for major=0:3, minor=0:3, patch=0:3
     end
 end
 
+# VersionNumber has the promised fields
+let v = v"4.2.1-1.x+a.9"
+    @test v.major isa Integer
+    @test v.minor isa Integer
+    @test v.patch isa Integer
+    @test v.prerelease isa Tuple{Vararg{Union{Integer, AbstractString}}}
+    @test v.build isa Tuple{Vararg{Union{Integer, AbstractString}}}
+end
+
 # julia_version.h version test
 @test VERSION.major == ccall(:jl_ver_major, Cint, ())
 @test VERSION.minor == ccall(:jl_ver_minor, Cint, ())

From 09617ac402640f5d46e30927d1044f6432c0a658 Mon Sep 17 00:00:00 2001
From: Simon Byrne <simonbyrne@gmail.com>
Date: Thu, 2 Nov 2023 12:31:46 -0700
Subject: [PATCH 0169/1315] add more defaults for reductions over empty arrays
 (#29919)

From discussion in #28535
---
 base/reduce.jl |  9 +++++++--
 test/reduce.jl | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/base/reduce.jl b/base/reduce.jl
index f9411f8b5d783..2cd2f9518ee03 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -348,6 +348,9 @@ reduce_empty(::typeof(*), ::Type{<:AbstractChar}) = ""
 reduce_empty(::typeof(&), ::Type{Bool}) = true
 reduce_empty(::typeof(|), ::Type{Bool}) = false
 
+reduce_empty(::typeof(max), T) = typemin(T)
+reduce_empty(::typeof(min), T) = typemax(T)
+
 reduce_empty(::typeof(add_sum), ::Type{Union{}}) = _empty_reduce_error(add_sum, Union{})
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T} = reduce_empty(+, T)
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallSigned}  = zero(Int)
@@ -373,8 +376,10 @@ mapreduce_empty(::typeof(identity), op, T) = reduce_empty(op, T)
 mapreduce_empty(::typeof(abs), op, T)      = abs(reduce_empty(op, T))
 mapreduce_empty(::typeof(abs2), op, T)     = abs2(reduce_empty(op, T))
 
-mapreduce_empty(f::typeof(abs),  ::typeof(max), T) = abs(zero(T))
-mapreduce_empty(f::typeof(abs2), ::typeof(max), T) = abs2(zero(T))
+mapreduce_empty(::typeof(abs),  ::typeof(max), T) = abs(zero(T))
+mapreduce_empty(::typeof(abs),  ::typeof(min), T) = typemax(abs(zero(T)))
+mapreduce_empty(::typeof(abs2), ::typeof(max), T) = abs2(zero(T))
+mapreduce_empty(::typeof(abs2),  ::typeof(min), T) = typemax(abs2(zero(T)))
 
 # For backward compatibility:
 mapreduce_empty_iter(f, op, itr, ItrEltype) =
diff --git a/test/reduce.jl b/test/reduce.jl
index 2c852084de37e..eb4004a1baf42 100644
--- a/test/reduce.jl
+++ b/test/reduce.jl
@@ -91,6 +91,10 @@ end
 @test mapreduce(abs2, *, Float64[]) === 1.0
 @test mapreduce(abs2, max, Float64[]) === 0.0
 @test mapreduce(abs, max, Float64[]) === 0.0
+@test mapreduce(abs2, min, Float64[]) === Inf
+@test mapreduce(abs, min, Float64[]) === Inf
+@test_throws ArgumentError mapreduce(abs2, &, Float64[])
+@test_throws ArgumentError mapreduce(abs2, |, Float64[])
 @test_throws ["reducing over an empty collection is not allowed",
               "consider supplying `init`"] mapreduce(abs2, &, Float64[])
 @test_throws str -> !occursin("Closest candidates are", str) mapreduce(abs2, &, Float64[])
@@ -260,6 +264,21 @@ prod2(itr) = invoke(prod, Tuple{Any}, itr)
 @test minimum(sin, []; init=1) == 1
 @test extrema(sin, []; init=(1, -1)) == (1, -1)
 
+@test maximum(Float64[]) === -Inf
+@test minimum(Float64[]) === +Inf
+
+@test maximum(Float32[]) === -Inf32
+@test minimum(Float32[]) === +Inf32
+
+@test maximum(abs, Int[]) === 0
+@test_throws ArgumentError minimum(abs, Int[])
+
+@test maximum(abs, Float64[]) === 0.0
+@test minimum(abs, Float64[]) === +Inf
+
+@test maximum(abs, Float32[]) === 0.0f0
+@test minimum(abs, Float32[]) === +Inf32
+
 @test maximum(5) == 5
 @test minimum(5) == 5
 @test extrema(5) == (5, 5)

From 9bc6994fd6e61d98c12733f673aaa1a296465eb6 Mon Sep 17 00:00:00 2001
From: Ashutosh Bharambe <43771652+ashutosh-b-b@users.noreply.github.com>
Date: Thu, 2 Nov 2023 20:07:01 +0000
Subject: [PATCH 0170/1315] [Artifacts] Pass artifacts dictionary to
 `ensure_artifact_installed` dispatch (#51995)

The artifacts dict is not lowered to ensure_artifact_installed which
causes to load the ".toml" during runtime for lazy artifacts
---
 stdlib/Artifacts/src/Artifacts.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/Artifacts/src/Artifacts.jl b/stdlib/Artifacts/src/Artifacts.jl
index 70593bfadae05..5daf994bfbf10 100644
--- a/stdlib/Artifacts/src/Artifacts.jl
+++ b/stdlib/Artifacts/src/Artifacts.jl
@@ -548,7 +548,7 @@ function _artifact_str(__module__, artifacts_toml, name, path_tail, artifact_dic
             if nameof(lazyartifacts) in (:Pkg, :Artifacts)
                 Base.depwarn("using Pkg instead of using LazyArtifacts is deprecated", :var"@artifact_str", force=true)
             end
-            return jointail(lazyartifacts.ensure_artifact_installed(string(name), artifacts_toml; platform), path_tail)
+            return jointail(lazyartifacts.ensure_artifact_installed(string(name), meta, artifacts_toml; platform), path_tail)
         end
         error("Artifact $(repr(name)) is a lazy artifact; package developers must call `using LazyArtifacts` in $(__module__) before using lazy artifacts.")
     end

From 2a842146ac6ee0a7f505d56b4c1f77274d7f0628 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 2 Nov 2023 16:10:57 -0400
Subject: [PATCH 0171/1315] Revert "add more methods and tests for reductions
 over empty arrays" (#52003)

Reverts JuliaLang/julia#29919

CI was older than I realized on this, so this needed some updates to
tests and docstrings
---
 base/reduce.jl |  9 ++-------
 test/reduce.jl | 19 -------------------
 2 files changed, 2 insertions(+), 26 deletions(-)

diff --git a/base/reduce.jl b/base/reduce.jl
index 2cd2f9518ee03..f9411f8b5d783 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -348,9 +348,6 @@ reduce_empty(::typeof(*), ::Type{<:AbstractChar}) = ""
 reduce_empty(::typeof(&), ::Type{Bool}) = true
 reduce_empty(::typeof(|), ::Type{Bool}) = false
 
-reduce_empty(::typeof(max), T) = typemin(T)
-reduce_empty(::typeof(min), T) = typemax(T)
-
 reduce_empty(::typeof(add_sum), ::Type{Union{}}) = _empty_reduce_error(add_sum, Union{})
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T} = reduce_empty(+, T)
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallSigned}  = zero(Int)
@@ -376,10 +373,8 @@ mapreduce_empty(::typeof(identity), op, T) = reduce_empty(op, T)
 mapreduce_empty(::typeof(abs), op, T)      = abs(reduce_empty(op, T))
 mapreduce_empty(::typeof(abs2), op, T)     = abs2(reduce_empty(op, T))
 
-mapreduce_empty(::typeof(abs),  ::typeof(max), T) = abs(zero(T))
-mapreduce_empty(::typeof(abs),  ::typeof(min), T) = typemax(abs(zero(T)))
-mapreduce_empty(::typeof(abs2), ::typeof(max), T) = abs2(zero(T))
-mapreduce_empty(::typeof(abs2),  ::typeof(min), T) = typemax(abs2(zero(T)))
+mapreduce_empty(f::typeof(abs),  ::typeof(max), T) = abs(zero(T))
+mapreduce_empty(f::typeof(abs2), ::typeof(max), T) = abs2(zero(T))
 
 # For backward compatibility:
 mapreduce_empty_iter(f, op, itr, ItrEltype) =
diff --git a/test/reduce.jl b/test/reduce.jl
index eb4004a1baf42..2c852084de37e 100644
--- a/test/reduce.jl
+++ b/test/reduce.jl
@@ -91,10 +91,6 @@ end
 @test mapreduce(abs2, *, Float64[]) === 1.0
 @test mapreduce(abs2, max, Float64[]) === 0.0
 @test mapreduce(abs, max, Float64[]) === 0.0
-@test mapreduce(abs2, min, Float64[]) === Inf
-@test mapreduce(abs, min, Float64[]) === Inf
-@test_throws ArgumentError mapreduce(abs2, &, Float64[])
-@test_throws ArgumentError mapreduce(abs2, |, Float64[])
 @test_throws ["reducing over an empty collection is not allowed",
               "consider supplying `init`"] mapreduce(abs2, &, Float64[])
 @test_throws str -> !occursin("Closest candidates are", str) mapreduce(abs2, &, Float64[])
@@ -264,21 +260,6 @@ prod2(itr) = invoke(prod, Tuple{Any}, itr)
 @test minimum(sin, []; init=1) == 1
 @test extrema(sin, []; init=(1, -1)) == (1, -1)
 
-@test maximum(Float64[]) === -Inf
-@test minimum(Float64[]) === +Inf
-
-@test maximum(Float32[]) === -Inf32
-@test minimum(Float32[]) === +Inf32
-
-@test maximum(abs, Int[]) === 0
-@test_throws ArgumentError minimum(abs, Int[])
-
-@test maximum(abs, Float64[]) === 0.0
-@test minimum(abs, Float64[]) === +Inf
-
-@test maximum(abs, Float32[]) === 0.0f0
-@test minimum(abs, Float32[]) === +Inf32
-
 @test maximum(5) == 5
 @test minimum(5) == 5
 @test extrema(5) == (5, 5)

From 5eaad532f961d4d1a1630b5c5b60499d2a7b9ae5 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Thu, 2 Nov 2023 14:35:20 -0700
Subject: [PATCH 0172/1315] Remove `ArgumentError()` in `parse_cache_header()`
 when `@depot` cannot be resolved (#51989)

In the original implementation of relocatable package cache files,
`parse_cache_header()` was made responsible for resolving
`@depot/`-relative paths, and it threw an `ArgumentError()` if it could
not find one. However, this could happen for a few reasons:

1. The `JULIA_DEPOT_PATH` could be set incorrectly, so the appropriate
source text files could not be found in an appropriate `packages/`
directory.

2. The package could have been upgraded, leaving a cache file for an
older version on-disk, but no matching source files.

For a concrete example of (2), see the following `bash` script:

    #!/bin/bash
    set -euo pipefail

    TEMP_PATH=$(mktemp -d)
    JULIA=${JULIA:-julia}
    echo JULIA: ${JULIA}
    export JULIA_DEPOT_PATH="${TEMP_PATH}"
    trap 'rm -rf ${TEMP_PATH}' EXIT

    # Create a `Foo.jl` that has an `internal.jl` within it
    FOO_DIR=${JULIA_DEPOT_PATH}/dev/Foo
    mkdir -p ${FOO_DIR}/src
    cat >${FOO_DIR}/Project.toml <<EOF
    name = "Foo"
    uuid = "00000000-0000-0000-0000-000000000001"
    version = "1.0.0"
    EOF
    cat >${FOO_DIR}/src/Foo.jl <<EOF
    module Foo

    include("internal.jl")
    end
    EOF

    cat >${FOO_DIR}/src/internal.jl <<EOF
    # Nothing to see here, folks
    EOF

    ${JULIA} -e "import Pkg; Pkg.develop(\"Foo\"); Pkg.precompile()"

# Change `Foo` to no longer depend on `internal.jl`; this should
invalidate its cache files
    cat >${FOO_DIR}/src/Foo.jl <<EOF
    module Foo
    end
    EOF
    rm -f ${FOO_DIR}/src/internal.jl

    # This should print `SUCCESS!`, not `FAILURE!`
    ${JULIA} -e 'using Foo; println("SUCCESS!")' || echo "FAILURE!"

This pull request removes the `ArgumentError()`, as it seems reasonable
to require `parse_cache_header()` to not throw errors in cases like
these. We instead rely upon a higher level validation to reject a
cachefile whose depot cannot be found, which should happen when
`stale_cachefile()` later checks to ensure that all includes are found
on-disk, (which will be false, as these paths start with `@depot/`, an
unlikely path prefix to exist).
---
 base/loading.jl | 10 +++++----
 test/loading.jl | 57 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+), 4 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index cd69c8c445b2a..125e9b1302fb5 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2722,11 +2722,9 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
         chi.filename ∈ srcfiles && push!(keepidx, i)
     end
     if depot === :no_depot_found
-        throw(ArgumentError("""
-              Failed to determine depot from srctext files in cache file $cachefile.
-              - Make sure you have adjusted DEPOT_PATH in case you relocated depots."""))
+        @debug("Unable to resolve @depot tag in cache file $cachefile", srcfiles)
     elseif depot === :missing_depot_tag
-        @debug "Missing @depot tag for include dependencies in cache file $cachefile."
+        @debug("Missing @depot tag for include dependencies in cache file $cachefile.", srcfiles)
     else
         for inc in includes
             inc.filename = restore_depot_path(inc.filename, depot)
@@ -3279,6 +3277,10 @@ end
             end
             for chi in includes
                 f, fsize_req, hash_req, ftime_req = chi.filename, chi.fsize, chi.hash, chi.mtime
+                if startswith(f, "@depot/")
+                    @debug("Rejecting stale cache file $cachefile because its depot could not be resolved")
+                    return true
+                end
                 if !ispath(f)
                     _f = fixup_stdlib_path(f)
                     if isfile(_f) && startswith(_f, Sys.STDLIB)
diff --git a/test/loading.jl b/test/loading.jl
index 0ee3e3985cc84..9f81a7637cb62 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1274,3 +1274,60 @@ end
         @test_throws ErrorException Base.check_src_module_wrap(p, fpath)
     end
 end
+
+@testset "relocatable upgrades #51989" begin
+    mktempdir() do depot
+        # Create fake `Foo.jl` package with two files:
+        foo_path = joinpath(depot, "dev", "Foo")
+        mkpath(joinpath(foo_path, "src"))
+        open(joinpath(foo_path, "src", "Foo.jl"); write=true) do io
+            println(io, """
+            module Foo
+            include("internal.jl")
+            end
+            """)
+        end
+        open(joinpath(foo_path, "src", "internal.jl"); write=true) do io
+            println(io, "const a = \"asd\"")
+        end
+        open(joinpath(foo_path, "Project.toml"); write=true) do io
+            println(io, """
+            name = "Foo"
+            uuid = "00000000-0000-0000-0000-000000000001"
+            version = "1.0.0"
+            """)
+        end
+
+        # In our depot, `dev` and then `precompile` this `Foo` package.
+        @test success(addenv(
+            `$(Base.julia_cmd()) --startup-file=no -e 'import Pkg; Pkg.develop("Foo"); Pkg.precompile(); exit(0)'`,
+            "JULIA_DEPOT_PATH" => depot,
+        ))
+
+        # Get the size of the generated `.ji` file so that we can ensure that it gets altered
+        foo_compiled_path = joinpath(depot, "compiled", "v$(VERSION.major).$(VERSION.minor)", "Foo")
+        cache_path = joinpath(foo_compiled_path, only(filter(endswith(".ji"), readdir(foo_compiled_path))))
+        cache_size = filesize(cache_path)
+
+        # Next, remove the dependence on `internal.jl` and delete it:
+        rm(joinpath(foo_path, "src", "internal.jl"))
+        open(joinpath(foo_path, "src", "Foo.jl"); write=true) do io
+            truncate(io, 0)
+            println(io, """
+            module Foo
+            end
+            """)
+        end
+
+        # Try to load `Foo`; this should trigger recompilation, not an error!
+        @test success(addenv(
+            `$(Base.julia_cmd()) --startup-file=no -e 'using Foo; exit(0)'`,
+            "JULIA_DEPOT_PATH" => depot,
+        ))
+
+        # Ensure that there is still only one `.ji` file (it got replaced
+        # and the file size changed).
+        @test length(filter(endswith(".ji"), readdir(foo_compiled_path))) == 1
+        @test filesize(cache_path) != cache_size
+    end
+end

From f2a5fb9fc493c859a86e7e9ab806c8634efbd865 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 3 Nov 2023 13:01:17 +0900
Subject: [PATCH 0173/1315] tweak outdated test cases (#51994)

Now those concretized calls are DCE-ed even though they are inlineable.
So we don't need to call e.g. `cfg_simplify!`.
---
 test/compiler/inline.jl | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index a5ad45b3281df..750a52301329a 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -1840,26 +1840,16 @@ end
 # Test that inlining can still use nothrow information from concrete-eval
 # even if the result itself is too big to be inlined, and nothrow is not
 # known without concrete-eval
-const THE_BIG_TUPLE = ntuple(identity, 1024)
+const THE_BIG_TUPLE = ntuple(identity, 1024);
 function return_the_big_tuple(err::Bool)
     err && error("BAD")
     return THE_BIG_TUPLE
 end
-@noinline function return_the_big_tuple_noinline(err::Bool)
-    err && error("BAD")
-    return THE_BIG_TUPLE
+@test fully_eliminated() do
+    return_the_big_tuple(false)[1]
 end
-big_tuple_test1() = return_the_big_tuple(false)[1]
-big_tuple_test2() = return_the_big_tuple_noinline(false)[1]
-
-@test fully_eliminated(big_tuple_test2, Tuple{})
-# Currently we don't run these cleanup passes, but let's make sure that
-# if we did, inlining would be able to remove this
-let ir = Base.code_ircode(big_tuple_test1, Tuple{})[1][1]
-    ir = Core.Compiler.compact!(ir, true)
-    ir = Core.Compiler.cfg_simplify!(ir)
-    ir = Core.Compiler.compact!(ir, true)
-    @test length(ir.stmts) == 1
+@test fully_eliminated() do
+    @inline return_the_big_tuple(false)[1]
 end
 
 # inlineable but removable call should be eligible for DCE

From e98aabad70d6708964fb8a03b69bc09dded1cf56 Mon Sep 17 00:00:00 2001
From: Takuya Iwanaga <takuyai@gmail.com>
Date: Sat, 4 Nov 2023 00:45:32 +1000
Subject: [PATCH 0174/1315] Mention export from InteractiveUtils in docs
 (#36971)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I recently had a frustrating experience where seemingly valid code that
worked in the REPL did not work in my own packages.

Specifically, it is not mentioned in the documentation that `subtypes`
was being automatically exported from `InteractiveUtils` when using the
REPL.
Thanks to @oheil for pointing this out (see exchange
[here](https://discourse.julialang.org/t/error-with-base-generic-function-calls/44174)).

Although in my case I figured out that `subtypes` wasn't exactly what I
needed, I still feel the documentation should be explicit about what
functions are in Base and what functions aren't to avoid the kind of
off-putting experience I had.

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com>
---
 doc/src/base/reflection.md | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/doc/src/base/reflection.md b/doc/src/base/reflection.md
index 2798cfe2e7530..e5c70175e5f9a 100644
--- a/doc/src/base/reflection.md
+++ b/doc/src/base/reflection.md
@@ -51,7 +51,7 @@ The *direct* subtypes of any `DataType` may be listed using [`subtypes`](@ref).
 the abstract `DataType` [`AbstractFloat`](@ref) has four (concrete) subtypes:
 
 ```jldoctest; setup = :(using InteractiveUtils)
-julia> subtypes(AbstractFloat)
+julia> InteractiveUtils.subtypes(AbstractFloat)
 5-element Vector{Any}:
  BigFloat
  Core.BFloat16
@@ -63,6 +63,9 @@ julia> subtypes(AbstractFloat)
 Any abstract subtype will also be included in this list, but further subtypes thereof will not;
 recursive application of [`subtypes`](@ref) may be used to inspect the full type tree.
 
+Note that [`subtypes`](@ref) is located inside [`InteractiveUtils`](@ref man-interactive-utils) but
+is automatically exported when using the REPL.
+
 ## DataType layout
 
 The internal representation of a `DataType` is critically important when interfacing with C code
@@ -83,7 +86,7 @@ the unquoted and interpolated expression ([`Expr`](@ref)) form for a given macro
 be passed instead!). For example:
 
 ```jldoctest; setup = :(using InteractiveUtils)
-julia> macroexpand(@__MODULE__, :(@edit println("")) )
+julia> InteractiveUtils.macroexpand(@__MODULE__, :(@edit println("")) )
 :(InteractiveUtils.edit(println, (Base.typesof)("")))
 ```
 
@@ -140,10 +143,10 @@ For more information see [`@code_lowered`](@ref), [`@code_typed`](@ref), [`@code
 The aforementioned functions and macros take the keyword argument `debuginfo` that controls the level
 debug information printed.
 
-```julia-repl
-julia> @code_typed debuginfo=:source +(1,1)
+```jldoctest; setup = :(using InteractiveUtils), filter = r"int.jl:\d+"
+julia> InteractiveUtils.@code_typed debuginfo=:source +(1,1)
 CodeInfo(
-    @ int.jl:53 within `+'
+    @ int.jl:87 within `+`
 1 ─ %1 = Base.add_int(x, y)::Int64
 └──      return %1
 ) => Int64

From 746cfdf65f5b3aef7c6a5a20a4cf9677a7bd285e Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 3 Nov 2023 10:46:22 -0400
Subject: [PATCH 0175/1315] abstractdict: Create separate error type wrong-key
 insertions (#41778)

Previously we were trying to do string formatting in Core.Compiler,
where this functionality is unavailable. Create a separate type
that can be thrown regardless of whether string processing is
available.
---
 base/abstractdict.jl | 2 ++
 base/dict.jl         | 6 +++---
 base/errorshow.jl    | 6 ++++--
 base/iddict.jl       | 2 +-
 test/dict.jl         | 6 +++---
 5 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/base/abstractdict.jl b/base/abstractdict.jl
index faeab78afaa53..0d6553d08bf9d 100644
--- a/base/abstractdict.jl
+++ b/base/abstractdict.jl
@@ -12,6 +12,8 @@ struct KeyError <: Exception
     key
 end
 
+KeyTypeError(K, key) = TypeError(:var"dict key", K, key)
+
 const secret_table_token = :__c782dbf1cf4d6a2e5e3865d7e95634f2e09b5902__
 
 haskey(d::AbstractDict, k) = in(k, keys(d))
diff --git a/base/dict.jl b/base/dict.jl
index da165c145bbb1..a5bb0f7499183 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -380,7 +380,7 @@ function setindex!(h::Dict{K,V}, v0, key0) where V where K
     else
         key = convert(K, key0)::K
         if !(isequal(key, key0)::Bool)
-            throw(ArgumentError("$(limitrepr(key0)) is not a valid key for type $K"))
+            throw(KeyTypeError(K, key0))
         end
     end
     setindex!(h, v0, key)
@@ -478,7 +478,7 @@ function get!(default::Callable, h::Dict{K,V}, key0) where V where K
     else
         key = convert(K, key0)::K
         if !isequal(key, key0)
-            throw(ArgumentError("$(limitrepr(key0)) is not a valid key for type $K"))
+            throw(KeyTypeError(K, key0))
         end
     end
     return get!(default, h, key)
@@ -786,7 +786,7 @@ function mergewith!(combine, d1::Dict{K, V}, d2::AbstractDict) where {K, V}
             if !(k isa K)
                 k1 = convert(K, k)::K
                 if !isequal(k, k1)
-                    throw(ArgumentError("$(limitrepr(k)) is not a valid key for type $K"))
+                    throw(KeyTypeError(K, k))
                 end
                 k = k1
             end
diff --git a/base/errorshow.jl b/base/errorshow.jl
index 39cdf14d34de8..dd6cd75e57c6b 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -70,6 +70,8 @@ function showerror(io::IO, ex::TypeError)
     print(io, "TypeError: ")
     if ex.expected === Bool
         print(io, "non-boolean (", typeof(ex.got), ") used in boolean context")
+    elseif ex.func === :var"dict key"
+        print(io, "$(limitrepr(ex.got)) is not a valid key for type $(ex.expected)")
     else
         if isvarargtype(ex.got)
             targs = (ex.got,)
@@ -80,7 +82,7 @@ function showerror(io::IO, ex::TypeError)
         end
         if ex.context == ""
             ctx = "in $(ex.func)"
-        elseif ex.func === Symbol("keyword argument")
+        elseif ex.func === :var"keyword argument"
             ctx = "in keyword argument $(ex.context)"
         else
             ctx = "in $(ex.func), in $(ex.context)"
@@ -787,7 +789,7 @@ function show_backtrace(io::IO, t::Vector)
 
     if length(filtered) == 1 && StackTraces.is_top_level_frame(filtered[1][1])
         f = filtered[1][1]::StackFrame
-        if f.line == 0 && f.file === Symbol("")
+        if f.line == 0 && f.file === :var""
             # don't show a single top-level frame with no location info
             return
         end
diff --git a/base/iddict.jl b/base/iddict.jl
index a4d3d439f03c9..73f532af9bba6 100644
--- a/base/iddict.jl
+++ b/base/iddict.jl
@@ -84,7 +84,7 @@ function sizehint!(d::IdDict, newsz)
 end
 
 function setindex!(d::IdDict{K,V}, @nospecialize(val), @nospecialize(key)) where {K, V}
-    !isa(key, K) && throw(ArgumentError("$(limitrepr(key)) is not a valid key for type $K"))
+    !isa(key, K) && throw(KeyTypeError(K, key))
     if !(val isa V) # avoid a dynamic call
         val = convert(V, val)::V
     end
diff --git a/test/dict.jl b/test/dict.jl
index 0284ec9399ca4..34f4d13bb9df5 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -639,13 +639,13 @@ end
     @test d == IdDict(1=>1, 2=>2, 3=>3)
     @test eltype(d) == Pair{Int,Int}
     @test_throws KeyError d[:a]
-    @test_throws ArgumentError d[:a] = 1
+    @test_throws TypeError d[:a] = 1
     @test_throws MethodError d[1] = :a
 
     # copy constructor
     d = IdDict(Pair(1,1), Pair(2,2), Pair(3,3))
     @test collect(values(IdDict{Int,Float64}(d))) == collect(values(d))
-    @test_throws ArgumentError IdDict{Float64,Int}(d)
+    @test_throws TypeError IdDict{Float64,Int}(d)
 
     # misc constructors
     @test typeof(IdDict(1=>1, :a=>2)) == IdDict{Any,Int}
@@ -672,7 +672,7 @@ end
     @test_throws MethodError get!(d, "b", "b")
     @test delete!(d, "a") === d
     @test !haskey(d, "a")
-    @test_throws ArgumentError get!(IdDict{Symbol,Any}(), 2, "b")
+    @test_throws TypeError get!(IdDict{Symbol,Any}(), 2, "b")
     @test get!(IdDict{Int,Int}(), 1, 2.0) === 2
     @test get!(()->2.0, IdDict{Int,Int}(), 1) === 2
 

From 09cbae8fe03315288c1bb53ba7ce24061bfb9f26 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gunnar=20Farneb=C3=A4ck?=
 <gunnar.farneback@contextvision.se>
Date: Fri, 3 Nov 2023 15:53:33 +0100
Subject: [PATCH 0176/1315] Revise Windows implementation of splitdrive
 (#42204)

This PR makes three improvements to the Windows `splitdrive`
implementation:

1. The matched regex is split into pieces and annotated.
2. Forward and backward slashes are considered equivalent. This fixes
   #38492.
3. The patterns in the regex are reordered so that long UNC paths and
   long drive letters are once more recognized. This has been broken
   since #19695 (Julia 0.5).

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/path.jl | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/base/path.jl b/base/path.jl
index c439a2800acce..493add6b0f6d0 100644
--- a/base/path.jl
+++ b/base/path.jl
@@ -34,8 +34,25 @@ elseif Sys.iswindows()
     const path_dir_splitter = r"^(.*?)([/\\]+)([^/\\]*)$"sa
     const path_ext_splitter = r"^((?:.*[/\\])?(?:\.|[^/\\\.])[^/\\]*?)(\.[^/\\\.]*|)$"sa
 
+    const splitdrive_re = let
+        # Slash in either direction.
+        S = raw"[\\/]"
+        # Not a slash in either direction.
+        N = raw"[^\\/]"
+        # Drive letter, e.g. `C:`
+        drive = "$(N)+:"
+        # UNC path, e.g. `\\server\share`
+        unc = "$(S)$(S)$(N)+$(S)$(N)+"
+        # Long drive letter, e.g. `\\?\C:`
+        long_drive = "$(S)$(S)\\?$(S)$(drive)"
+        # Long UNC path, e.g. `\\?\UNC\server\share`
+        long_unc = "$(S)$(S)\\?$(S)UNC$(S)$(N)+$(S)$(N)+"
+        # Need to match the long patterns first so they get priority.
+        Regex("^($long_unc|$long_drive|$unc|$drive|)(.*)\$", "sa")
+    end
+
     function splitdrive(path::String)
-        m = match(r"^([^\\]+:|\\\\[^\\]+\\[^\\]+|\\\\\?\\UNC\\[^\\]+\\[^\\]+|\\\\\?\\[^\\]+:|)(.*)$"sa, path)::AbstractMatch
+        m = match(splitdrive_re, path)::AbstractMatch
         String(something(m.captures[1])), String(something(m.captures[2]))
     end
 else

From b3fe97003279bf9bf511e7b50f717d9374dee32b Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Fri, 3 Nov 2023 11:55:26 -0300
Subject: [PATCH 0177/1315] Fixup static analyzer warnings in staticdata.c
 (#51984)

---
 src/Makefile           |  4 +--
 src/staticdata.c       | 66 +++++++++++++++++++++---------------------
 src/staticdata_utils.c |  8 ++---
 3 files changed, 38 insertions(+), 40 deletions(-)

diff --git a/src/Makefile b/src/Makefile
index b3ffd79dcad52..4d105adec0dbb 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -493,8 +493,6 @@ SA_EXCEPTIONS-jloptions.c                   := -Xanalyzer -analyzer-config -Xana
 SA_EXCEPTIONS-subtype.c                     := -Xanalyzer -analyzer-config -Xanalyzer silence-checkers="core.uninitialized.Assign;core.UndefinedBinaryOperatorResult"
 SA_EXCEPTIONS-codegen.c                     := -Xanalyzer -analyzer-config -Xanalyzer silence-checkers="core"
  # these need to be annotated (and possibly fixed)
-SKIP_IMPLICIT_ATOMICS := staticdata.c
- # these need to be annotated (and possibly fixed)
 SKIP_GC_CHECK := codegen.cpp rtutils.c
 
 # make sure LLVM's invariant information is not discarded with -DNDEBUG
@@ -540,7 +538,7 @@ $(addprefix clang-sagc-,$(CODEGEN_SRCS)): DEBUGFLAGS_CLANG += -DJL_LIBRARY_EXPOR
 $(addprefix clang-tidy-,$(CODEGEN_SRCS)): DEBUGFLAGS_CLANG += -DJL_LIBRARY_EXPORTS_CODEGEN
 
 # Add C files as a target of `analyzesrc` and `analyzegc` and `tidysrc`
-tidysrc: $(addprefix clang-tidy-,$(filter-out $(basename $(SKIP_IMPLICIT_ATOMICS)),$(CODEGEN_SRCS) $(SRCS)))
+tidysrc: $(addprefix clang-tidy-,$(CODEGEN_SRCS) $(SRCS))
 analyzesrc: $(addprefix clang-sa-,$(CODEGEN_SRCS) $(SRCS))
 analyzegc: $(addprefix clang-sagc-,$(filter-out $(basename $(SKIP_GC_CHECK)),$(CODEGEN_SRCS) $(SRCS)))
 analyze: analyzesrc analyzegc tidysrc
diff --git a/src/staticdata.c b/src/staticdata.c
index a77e0774a9441..8c60919e1f7a6 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -722,8 +722,8 @@ static void jl_queue_module_for_serialization(jl_serializer_state *s, jl_module_
 {
     jl_queue_for_serialization(s, m->name);
     jl_queue_for_serialization(s, m->parent);
-    jl_queue_for_serialization(s, m->bindings);
-    jl_queue_for_serialization(s, m->bindingkeyset);
+    jl_queue_for_serialization(s, jl_atomic_load_relaxed(&m->bindings));
+    jl_queue_for_serialization(s, jl_atomic_load_relaxed(&m->bindingkeyset));
     if (jl_options.strip_metadata) {
         jl_svec_t *table = jl_atomic_load_relaxed(&m->bindings);
         for (size_t i = 0; i < jl_svec_len(table); i++) {
@@ -810,8 +810,8 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
     if (jl_is_typename(v)) {
         jl_typename_t *tn = (jl_typename_t*)v;
         // don't recurse into several fields (yet)
-        jl_queue_for_serialization_(s, (jl_value_t*)tn->cache, 0, 1);
-        jl_queue_for_serialization_(s, (jl_value_t*)tn->linearcache, 0, 1);
+        jl_queue_for_serialization_(s, (jl_value_t*)jl_atomic_load_relaxed(&tn->cache), 0, 1);
+        jl_queue_for_serialization_(s, (jl_value_t*)jl_atomic_load_relaxed(&tn->linearcache), 0, 1);
         if (s->incremental) {
             assert(!jl_object_in_image((jl_value_t*)tn->module));
             assert(!jl_object_in_image((jl_value_t*)tn->wrapper));
@@ -1143,12 +1143,12 @@ static void jl_write_module(jl_serializer_state *s, uintptr_t item, jl_module_t
     newm->parent = NULL;
     arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, parent)));
     arraylist_push(&s->relocs_list, (void*)backref_id(s, m->parent, s->link_ids_relocs));
-    newm->bindings = NULL;
+    jl_atomic_store_relaxed(&newm->bindings, NULL);
     arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, bindings)));
-    arraylist_push(&s->relocs_list, (void*)backref_id(s, m->bindings, s->link_ids_relocs));
-    newm->bindingkeyset = NULL;
+    arraylist_push(&s->relocs_list, (void*)backref_id(s, jl_atomic_load_relaxed(&m->bindings), s->link_ids_relocs));
+    jl_atomic_store_relaxed(&newm->bindingkeyset, NULL);
     arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, bindingkeyset)));
-    arraylist_push(&s->relocs_list, (void*)backref_id(s, m->bindingkeyset, s->link_ids_relocs));
+    arraylist_push(&s->relocs_list, (void*)backref_id(s, jl_atomic_load_relaxed(&m->bindingkeyset), s->link_ids_relocs));
     newm->primary_world = ~(size_t)0;
 
     // write out the usings list
@@ -1584,26 +1584,25 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                     if (m->max_world != ~(size_t)0)
                         newm->max_world = 0;
                     else {
-                        if (m->inferred && ptrhash_has(&s->callers_with_edges, m->def))
+                        if (jl_atomic_load_relaxed(&m->inferred)  && ptrhash_has(&s->callers_with_edges, m->def))
                             newm->max_world = 1;  // sentinel value indicating this will need validation
-                        if (m->min_world > 0 && m->inferred) {
+                        if (m->min_world > 0 && jl_atomic_load_relaxed(&m->inferred) ) {
                             // TODO: also check if this object is part of the codeinst cache
                             // will check on deserialize if this cache entry is still valid
                         }
                     }
                 }
-
-                newm->invoke = NULL;
-                newm->specsigflags = 0;
-                newm->specptr.fptr = NULL;
+                jl_atomic_store_relaxed(&newm->invoke, NULL);
+                jl_atomic_store_relaxed(&newm->specsigflags, 0);
+                jl_atomic_store_relaxed(&newm->specptr.fptr, NULL);
                 int8_t fptr_id = JL_API_NULL;
                 int8_t builtin_id = 0;
-                if (m->invoke == jl_fptr_const_return) {
+                if (jl_atomic_load_relaxed(&m->invoke) == jl_fptr_const_return) {
                     fptr_id = JL_API_CONST;
                 }
                 else {
                     if (jl_is_method(m->def->def.method)) {
-                        builtin_id = jl_fptr_id(m->specptr.fptr);
+                        builtin_id = jl_fptr_id(jl_atomic_load_relaxed(&m->specptr.fptr));
                         if (builtin_id) { // found in the table of builtins
                             assert(builtin_id >= 2);
                             fptr_id = JL_API_BUILTIN;
@@ -1643,7 +1642,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                         }
                     }
                 }
-                newm->invoke = NULL; // relocation offset
+                jl_atomic_store_relaxed(&newm->invoke, NULL); // relocation offset
                 if (fptr_id != JL_API_NULL) {
                     assert(fptr_id < BuiltinFunctionTag && "too many functions to serialize");
                     arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_code_instance_t, invoke))); // relocation location
@@ -2138,8 +2137,8 @@ static void jl_update_all_fptrs(jl_serializer_state *s, jl_image_t *image)
             }
             jl_code_instance_t *codeinst = (jl_code_instance_t*)(base + offset);
             uintptr_t base = (uintptr_t)fvars.base;
-            assert(jl_is_method(codeinst->def->def.method) && codeinst->invoke != jl_fptr_const_return);
-            assert(specfunc ? codeinst->invoke != NULL : codeinst->invoke == NULL);
+            assert(jl_is_method(codeinst->def->def.method) && jl_atomic_load_relaxed(&codeinst->invoke) != jl_fptr_const_return);
+            assert(specfunc ? jl_atomic_load_relaxed(&codeinst->invoke) != NULL : jl_atomic_load_relaxed(&codeinst->invoke) == NULL);
             linfos[i] = codeinst->def;     // now it's a MethodInstance
             int32_t offset = fvars.offsets[i];
             for (; clone_idx < fvars.nclones; clone_idx++) {
@@ -2152,11 +2151,11 @@ static void jl_update_all_fptrs(jl_serializer_state *s, jl_image_t *image)
             }
             void *fptr = (void*)(base + offset);
             if (specfunc) {
-                codeinst->specptr.fptr = fptr;
-                codeinst->specsigflags = 0b111; // TODO: set only if confirmed to be true
+                jl_atomic_store_relaxed(&codeinst->specptr.fptr, fptr);
+                jl_atomic_store_relaxed(&codeinst->specsigflags, 0b111); // TODO: set only if confirmed to be true
             }
             else {
-                codeinst->invoke = (jl_callptr_t)fptr;
+                jl_atomic_store_relaxed(&codeinst->invoke,(jl_callptr_t)fptr);
             }
         }
     }
@@ -2227,8 +2226,8 @@ static void jl_root_new_gvars(jl_serializer_state *s, jl_image_t *image, uint32_
                 v = (uintptr_t)jl_as_global_root((jl_value_t*)v);
         } else {
             jl_code_instance_t *codeinst = (jl_code_instance_t*) v;
-            assert(codeinst && (codeinst->specsigflags & 0b01) && codeinst->specptr.fptr);
-            v = (uintptr_t)codeinst->specptr.fptr;
+            assert(codeinst && (jl_atomic_load_relaxed(&codeinst->specsigflags) & 0b01) && jl_atomic_load_relaxed(&codeinst->specptr.fptr));
+            v = (uintptr_t)jl_atomic_load_relaxed(&codeinst->specptr.fptr);
         }
         *gv = v;
     }
@@ -2363,8 +2362,8 @@ static int strip_all_codeinfos__(jl_typemap_entry_t *def, void *_env)
     if (m->source) {
         int stripped_ir = 0;
         if (jl_options.strip_ir) {
-            if (m->unspecialized) {
-                jl_code_instance_t *unspec = jl_atomic_load_relaxed(&m->unspecialized->cache);
+            if (jl_atomic_load_relaxed(&m->unspecialized)) {
+                jl_code_instance_t *unspec = jl_atomic_load_relaxed(&jl_atomic_load_relaxed(&m->unspecialized)->cache);
                 if (unspec && jl_atomic_load_relaxed(&unspec->invoke)) {
                     // we have a generic compiled version, so can remove the IR
                     record_field_change(&m->source, jl_nothing);
@@ -2385,7 +2384,7 @@ static int strip_all_codeinfos__(jl_typemap_entry_t *def, void *_env)
             jl_gc_wb(m, m->source);
         }
     }
-    jl_value_t *specializations = m->specializations;
+    jl_value_t *specializations = jl_atomic_load_relaxed(&m->specializations);
     if (!jl_is_svec(specializations)) {
         strip_specializations_((jl_method_instance_t*)specializations);
     }
@@ -2397,8 +2396,8 @@ static int strip_all_codeinfos__(jl_typemap_entry_t *def, void *_env)
                 strip_specializations_((jl_method_instance_t*)mi);
         }
     }
-    if (m->unspecialized)
-        strip_specializations_(m->unspecialized);
+    if (jl_atomic_load_relaxed(&m->unspecialized))
+        strip_specializations_(jl_atomic_load_relaxed(&m->unspecialized));
     if (jl_options.strip_ir && m->root_blocks)
         record_field_change((jl_value_t**)&m->root_blocks, NULL);
     return 1;
@@ -2408,7 +2407,7 @@ static int strip_all_codeinfos_(jl_methtable_t *mt, void *_env)
 {
     if (jl_options.strip_ir && mt->backedges)
         record_field_change((jl_value_t**)&mt->backedges, NULL);
-    return jl_typemap_visitor(mt->defs, strip_all_codeinfos__, NULL);
+    return jl_typemap_visitor(jl_atomic_load_relaxed(&mt->defs), strip_all_codeinfos__, NULL);
 }
 
 static void jl_strip_all_codeinfos(void)
@@ -2646,9 +2645,10 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
         for (i = 0; i < serialization_queue.len; i++) {
             jl_typename_t *tn = (jl_typename_t*)serialization_queue.items[i];
             if (jl_is_typename(tn)) {
-                tn->cache = jl_prune_type_cache_hash(tn->cache);
-                jl_gc_wb(tn, tn->cache);
-                jl_prune_type_cache_linear(tn->linearcache);
+                jl_atomic_store_relaxed(&tn->cache,
+                    jl_prune_type_cache_hash(jl_atomic_load_relaxed(&tn->cache)));
+                jl_gc_wb(tn, jl_atomic_load_relaxed(&tn->cache));
+                jl_prune_type_cache_linear(jl_atomic_load_relaxed(&tn->linearcache));
             }
         }
     }
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index 1a8dd879c0983..384c479b10f58 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -159,7 +159,7 @@ static int has_backedge_to_worklist(jl_method_instance_t *mi, htable_t *visited,
     if (jl_is_method(mod))
         mod = ((jl_method_t*)mod)->module;
     assert(jl_is_module(mod));
-    if (mi->precompiled || !jl_object_in_image((jl_value_t*)mod) || type_in_worklist(mi->specTypes)) {
+    if (jl_atomic_load_relaxed(&mi->precompiled) || !jl_object_in_image((jl_value_t*)mod) || type_in_worklist(mi->specTypes)) {
         return 1;
     }
     if (!mi->backedges) {
@@ -234,7 +234,7 @@ static jl_array_t *queue_external_cis(jl_array_t *list)
             continue;
         jl_method_instance_t *mi = ci->def;
         jl_method_t *m = mi->def.method;
-        if (ci->inferred && jl_is_method(m) && jl_object_in_image((jl_value_t*)m->module)) {
+        if (jl_atomic_load_relaxed(&ci->inferred) && jl_is_method(m) && jl_object_in_image((jl_value_t*)m->module)) {
             int found = has_backedge_to_worklist(mi, &visited, &stack);
             assert(found == 0 || found == 1 || found == 2);
             assert(stack.len == 0);
@@ -1119,7 +1119,7 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
         else {
             assert(ci->max_world == ~(size_t)0);
             jl_method_instance_t *caller = ci->def;
-            if (ci->inferred && jl_rettype_inferred(caller, minworld, ~(size_t)0) == jl_nothing) {
+            if (jl_atomic_load_relaxed(&ci->inferred)  && jl_rettype_inferred(caller, minworld, ~(size_t)0) == jl_nothing) {
                 jl_mi_cache_insert(caller, ci);
             }
             //jl_static_show((jl_stream*)ios_stderr, (jl_value_t*)caller);
@@ -1162,7 +1162,7 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
             // have some new external code to use
             assert(jl_is_code_instance(ci));
             jl_code_instance_t *codeinst = (jl_code_instance_t*)ci;
-            assert(codeinst->min_world == minworld && codeinst->inferred);
+            assert(codeinst->min_world == minworld && jl_atomic_load_relaxed(&codeinst->inferred) );
             codeinst->max_world = maxvalid;
             if (jl_rettype_inferred(caller, minworld, maxvalid) == jl_nothing) {
                 jl_mi_cache_insert(caller, codeinst);

From 1a4a3a0c441b353d039edc71c25bd2430aaff1c4 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Fri, 3 Nov 2023 10:56:30 -0400
Subject: [PATCH 0178/1315] Fix task suspension in GC for JL_TIMING (#52005)

The timing system does not currently support nesting task suspensions,
so this `JL_TIMING_SUSPEND_TASK` added in #51489 is not permitted since
it is called from within the GC suspension.

This was causing Tracy to crash upon recording with "zone ended twice"
---
 src/safepoint.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/safepoint.c b/src/safepoint.c
index 5a845496f36c6..51dae64e84e72 100644
--- a/src/safepoint.c
+++ b/src/safepoint.c
@@ -201,7 +201,6 @@ void jl_safepoint_wait_thread_resume(void)
     // will observe the change to the safepoint, even though the other thread
     // might have already observed our gc_state.
     // if (!jl_atomic_load_relaxed(&ct->ptls->suspend_count)) return;
-    JL_TIMING_SUSPEND_TASK(USER, ct);
     int8_t state = jl_atomic_load_relaxed(&ct->ptls->gc_state);
     jl_atomic_store_release(&ct->ptls->gc_state, JL_GC_STATE_WAITING);
     uv_mutex_lock(&ct->ptls->sleep_lock);

From 9c63250f9b251f46aec408832a5aaaebe9201c65 Mon Sep 17 00:00:00 2001
From: Marco Prevedello <32065059+Preve92@users.noreply.github.com>
Date: Fri, 3 Nov 2023 15:58:49 +0100
Subject: [PATCH 0179/1315] doc: correct apparent inconsistency in describing
 redefining globals (#47083)

The documentation stated that built-in constants and functions could
both be redefined and _not_ be redefined, while it seemed to more
nearly mean shadowed in the former case.

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 doc/src/manual/variables.md | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/doc/src/manual/variables.md b/doc/src/manual/variables.md
index 2c707784a8831..75c2163896d9c 100644
--- a/doc/src/manual/variables.md
+++ b/doc/src/manual/variables.md
@@ -59,10 +59,10 @@ name `δ` can be entered by typing `\delta`-*tab*, or even `α̂⁽²⁾` by `\a
 that you don't know how to type, the REPL help will tell you: just type `?` and
 then paste the symbol.)
 
-Julia will even let you redefine built-in constants and functions if needed (although
-this is not recommended to avoid potential confusions):
+Julia will even let you shadow existing exported constants and functions with local ones
+(although this is not recommended to avoid potential confusions):
 
-```jldoctest
+```jldoctest; filter = r"with \d+ methods"
 julia> pi = 3
 3
 
@@ -71,6 +71,12 @@ julia> pi
 
 julia> sqrt = 4
 4
+
+julia> length() = 5
+length (generic function with 1 method)
+
+julia> Base.length
+length (generic function with 79 methods)
 ```
 
 However, if you try to redefine a built-in constant or function already in use, Julia will give

From 388680342229b2f25642886dbb0c779690d6d089 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 25 Oct 2023 02:02:03 +0000
Subject: [PATCH 0180/1315] Properly guard UpsilonNode unboxed store

In #51852, we are coercing a boxed `Union{@NamedTuple{progress::String}, @NamedTuple{progress::Float64}}`
to `@NamedTuple{progress::String}` via convert_julia_type. This results in a jl_cgval_t that has
a Vboxed that points to a boxed `@NamedTuple{progress::Float64}` but with a `@NamedTuple{progress::String}`
type tag that the up upsilonnode code then tries to unbox into the typed PhiC slot. This ends up treating
the Float64 as a pointer and crashing in GC. Avoid this by adding a runtime check that the converted value
is actually compatible (we already had this kind of check for the non-boxed cases) and then making the
unboxing runtime-conditional on the type of the union matching the type of the phic.

Fixes #51852
---
 base/compiler/abstractinterpretation.jl       |  82 ++++++------
 base/compiler/optimize.jl                     |   2 +-
 base/compiler/ssair/slot2ssa.jl               |   2 +-
 base/compiler/utilities.jl                    |   2 +-
 src/cgutils.cpp                               |  22 +++-
 src/codegen.cpp                               |  78 ++++++-----
 stdlib/REPL/src/REPLCompletions.jl            |   4 +-
 .../compiler/EscapeAnalysis/EscapeAnalysis.jl |   2 +
 test/compiler/codegen.jl                      |   6 +-
 test/compiler/inference.jl                    | 121 +++++++++++++++++-
 test/show.jl                                  |   9 +-
 11 files changed, 246 insertions(+), 84 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 82aca46f3e7ed..e387352cf8018 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2230,31 +2230,31 @@ end
 
 function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(e), vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
     if isa(e, QuoteNode)
-        return Const(e.value)
+        return RTEffects(Const(e.value), EFFECTS_TOTAL)
     elseif isa(e, SSAValue)
-        return abstract_eval_ssavalue(e, sv)
+        return RTEffects(abstract_eval_ssavalue(e, sv), EFFECTS_TOTAL)
     elseif isa(e, SlotNumber)
+        effects = EFFECTS_THROWS
         if vtypes !== nothing
             vtyp = vtypes[slot_id(e)]
-            if vtyp.undef
-                merge_effects!(interp, sv, Effects(EFFECTS_TOTAL; nothrow=false))
+            if !vtyp.undef
+                effects = EFFECTS_TOTAL
             end
-            return vtyp.typ
+            return RTEffects(vtyp.typ, effects)
         end
-        merge_effects!(interp, sv, Effects(EFFECTS_TOTAL; nothrow=false))
-        return Any
+        return RTEffects(Any, effects)
     elseif isa(e, Argument)
         if vtypes !== nothing
-            return vtypes[slot_id(e)].typ
+            return RTEffects(vtypes[slot_id(e)].typ, EFFECTS_TOTAL)
         else
             @assert isa(sv, IRInterpretationState)
-            return sv.ir.argtypes[e.n] # TODO frame_argtypes(sv)[e.n] and remove the assertion
+            return RTEffects(sv.ir.argtypes[e.n], EFFECTS_TOTAL) # TODO frame_argtypes(sv)[e.n] and remove the assertion
         end
     elseif isa(e, GlobalRef)
         return abstract_eval_globalref(interp, e, sv)
     end
 
-    return Const(e)
+    return RTEffects(Const(e), EFFECTS_TOTAL)
 end
 
 function abstract_eval_value_expr(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
@@ -2288,8 +2288,9 @@ function abstract_eval_value(interp::AbstractInterpreter, @nospecialize(e), vtyp
     if isa(e, Expr)
         return abstract_eval_value_expr(interp, e, vtypes, sv)
     else
-        typ = abstract_eval_special_value(interp, e, vtypes, sv)
-        return collect_limitations!(typ, sv)
+        (;rt, effects) = abstract_eval_special_value(interp, e, vtypes, sv)
+        merge_effects!(interp, sv, effects)
+        return collect_limitations!(rt, sv)
     end
 end
 
@@ -2615,7 +2616,9 @@ function abstract_eval_phi(interp::AbstractInterpreter, phi::PhiNode, vtypes::Un
     for i in 1:length(phi.values)
         isassigned(phi.values, i) || continue
         val = phi.values[i]
-        rt = tmerge(typeinf_lattice(interp), rt, abstract_eval_special_value(interp, val, vtypes, sv))
+        # N.B.: Phi arguments are restricted to not have effects, so we can drop
+        # them here safely.
+        rt = tmerge(typeinf_lattice(interp), rt, abstract_eval_special_value(interp, val, vtypes, sv).rt)
     end
     return rt
 end
@@ -2631,16 +2634,28 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
             add_curr_ssaflag!(sv, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
             return abstract_eval_phi(interp, e, vtypes, sv)
         end
-        return abstract_eval_special_value(interp, e, vtypes, sv)
-    end
-    (; rt, effects) = abstract_eval_statement_expr(interp, e, vtypes, sv)
-    if effects.noub === NOUB_IF_NOINBOUNDS
-        if !iszero(get_curr_ssaflag(sv) & IR_FLAG_INBOUNDS)
-            effects = Effects(effects; noub=ALWAYS_FALSE)
-        elseif !propagate_inbounds(sv)
-            # The callee read our inbounds flag, but unless we propagate inbounds,
-            # we ourselves don't read our parent's inbounds.
-            effects = Effects(effects; noub=ALWAYS_TRUE)
+        (; rt, effects) = abstract_eval_special_value(interp, e, vtypes, sv)
+    else
+        (; rt, effects) = abstract_eval_statement_expr(interp, e, vtypes, sv)
+        if effects.noub === NOUB_IF_NOINBOUNDS
+            if !iszero(get_curr_ssaflag(sv) & IR_FLAG_INBOUNDS)
+                effects = Effects(effects; noub=ALWAYS_FALSE)
+            elseif !propagate_inbounds(sv)
+                # The callee read our inbounds flag, but unless we propagate inbounds,
+                # we ourselves don't read our parent's inbounds.
+                effects = Effects(effects; noub=ALWAYS_TRUE)
+            end
+        end
+        e = e::Expr
+        @assert !isa(rt, TypeVar) "unhandled TypeVar"
+        rt = maybe_singleton_const(rt)
+        if !isempty(sv.pclimitations)
+            if rt isa Const || rt === Union{}
+                empty!(sv.pclimitations)
+            else
+                rt = LimitedAccuracy(rt, sv.pclimitations)
+                sv.pclimitations = IdSet{InferenceState}()
+            end
         end
     end
     # N.B.: This only applies to the effects of the statement itself.
@@ -2648,17 +2663,7 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
     # but these will be recomputed during SSA construction later.
     set_curr_ssaflag!(sv, flags_for_effects(effects), IR_FLAGS_EFFECTS)
     merge_effects!(interp, sv, effects)
-    e = e::Expr
-    @assert !isa(rt, TypeVar) "unhandled TypeVar"
-    rt = maybe_singleton_const(rt)
-    if !isempty(sv.pclimitations)
-        if rt isa Const || rt === Union{}
-            empty!(sv.pclimitations)
-        else
-            rt = LimitedAccuracy(rt, sv.pclimitations)
-            sv.pclimitations = IdSet{InferenceState}()
-        end
-    end
+
     return rt
 end
 
@@ -2666,7 +2671,7 @@ function isdefined_globalref(g::GlobalRef)
     return ccall(:jl_globalref_boundp, Cint, (Any,), g) != 0
 end
 
-function abstract_eval_globalref(g::GlobalRef)
+function abstract_eval_globalref_type(g::GlobalRef)
     if isdefined_globalref(g) && isconst(g)
         return Const(ccall(:jl_get_globalref_value, Any, (Any,), g))
     end
@@ -2674,10 +2679,10 @@ function abstract_eval_globalref(g::GlobalRef)
     ty === nothing && return Any
     return ty
 end
-abstract_eval_global(M::Module, s::Symbol) = abstract_eval_globalref(GlobalRef(M, s))
+abstract_eval_global(M::Module, s::Symbol) = abstract_eval_globalref_type(GlobalRef(M, s))
 
 function abstract_eval_globalref(interp::AbstractInterpreter, g::GlobalRef, sv::AbsIntState)
-    rt = abstract_eval_globalref(g)
+    rt = abstract_eval_globalref_type(g)
     consistent = inaccessiblememonly = ALWAYS_FALSE
     nothrow = false
     if isa(rt, Const)
@@ -2692,8 +2697,7 @@ function abstract_eval_globalref(interp::AbstractInterpreter, g::GlobalRef, sv::
         consistent = inaccessiblememonly = ALWAYS_TRUE
         rt = Union{}
     end
-    merge_effects!(interp, sv, Effects(EFFECTS_TOTAL; consistent, nothrow, inaccessiblememonly))
-    return rt
+    return RTEffects(rt, Effects(EFFECTS_TOTAL; consistent, nothrow, inaccessiblememonly))
 end
 
 function handle_global_assignment!(interp::AbstractInterpreter, frame::InferenceState, lhs::GlobalRef, @nospecialize(newty))
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 305c9b5c03b10..9dff1281e83c5 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -396,7 +396,7 @@ function argextype(
     elseif isa(x, QuoteNode)
         return Const(x.value)
     elseif isa(x, GlobalRef)
-        return abstract_eval_globalref(x)
+        return abstract_eval_globalref_type(x)
     elseif isa(x, PhiNode)
         return Any
     elseif isa(x, PiNode)
diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl
index 1f682d9168413..f3253526d25e9 100644
--- a/base/compiler/ssair/slot2ssa.jl
+++ b/base/compiler/ssair/slot2ssa.jl
@@ -207,7 +207,7 @@ function typ_for_val(@nospecialize(x), ci::CodeInfo, ir::IRCode, idx::Int, slott
         end
         return (ci.ssavaluetypes::Vector{Any})[idx]
     end
-    isa(x, GlobalRef) && return abstract_eval_globalref(x)
+    isa(x, GlobalRef) && return abstract_eval_globalref_type(x)
     isa(x, SSAValue) && return (ci.ssavaluetypes::Vector{Any})[x.id]
     isa(x, Argument) && return slottypes[x.n]
     isa(x, NewSSAValue) && return types(ir)[new_to_regular(x, length(ir.stmts))]
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 175675f2c81cc..368265262deb6 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -431,7 +431,7 @@ function is_throw_call(e::Expr)
     if e.head === :call
         f = e.args[1]
         if isa(f, GlobalRef)
-            ff = abstract_eval_globalref(f)
+            ff = abstract_eval_globalref_type(f)
             if isa(ff, Const) && ff.val === Core.throw
                 return true
             end
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 5338ad2357f41..f158c182744e2 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1406,6 +1406,9 @@ static void null_pointer_check(jl_codectx_t &ctx, Value *v, Value **nullcheck =
 template<typename Func>
 static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, Value *defval, Func &&func)
 {
+    if (!ifnot) {
+        return func();
+    }
     if (auto Cond = dyn_cast<ConstantInt>(ifnot)) {
         if (Cond->isZero())
             return defval;
@@ -1544,7 +1547,7 @@ static bool can_optimize_isa_union(jl_uniontype_t *type)
 }
 
 // a simple case of emit_isa that is obvious not to include a safe-point
-static Value *emit_exactly_isa(jl_codectx_t &ctx, const jl_cgval_t &arg, jl_datatype_t *dt)
+static Value *emit_exactly_isa(jl_codectx_t &ctx, const jl_cgval_t &arg, jl_datatype_t *dt, bool could_be_null=false)
 {
     assert(jl_is_concrete_type((jl_value_t*)dt));
     if (arg.TIndex) {
@@ -1559,6 +1562,10 @@ static Value *emit_exactly_isa(jl_codectx_t &ctx, const jl_cgval_t &arg, jl_data
         else if (arg.Vboxed) {
             // test for (arg.TIndex == UNION_BOX_MARKER && typeof(arg.V) == type)
             Value *isboxed = ctx.builder.CreateICmpEQ(arg.TIndex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER));
+            if (could_be_null) {
+                isboxed = ctx.builder.CreateAnd(isboxed,
+                    ctx.builder.CreateNot(null_pointer_cmp(ctx, arg.Vboxed)));
+            }
             setName(ctx.emission_context, isboxed, "isboxed");
             BasicBlock *currBB = ctx.builder.GetInsertBlock();
             BasicBlock *isaBB = BasicBlock::Create(ctx.builder.getContext(), "isa", ctx.f);
@@ -1579,9 +1586,16 @@ static Value *emit_exactly_isa(jl_codectx_t &ctx, const jl_cgval_t &arg, jl_data
             return ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 0);
         }
     }
-    auto isa = ctx.builder.CreateICmpEQ(emit_typeof(ctx, arg, false, true), emit_tagfrom(ctx, dt));
-    setName(ctx.emission_context, isa, "exactly_isa");
-    return isa;
+    Value *isnull = NULL;
+    if (could_be_null && arg.isboxed) {
+        isnull = null_pointer_cmp(ctx, arg.Vboxed);
+    }
+    Constant *Vfalse = ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 0);
+    return emit_guarded_test(ctx, isnull, Vfalse, [&]{
+        auto isa = ctx.builder.CreateICmpEQ(emit_typeof(ctx, arg, false, true), emit_tagfrom(ctx, dt));
+        setName(ctx.emission_context, isa, "exactly_isa");
+        return isa;
+    });
 }
 
 static std::pair<Value*, bool> emit_isa(jl_codectx_t &ctx, const jl_cgval_t &x,
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 8cabe34100390..55c5e61c1f980 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1590,8 +1590,17 @@ struct jl_cgval_t {
     // runtime values) if `(TIndex | UNION_BOX_MARKER) != 0`, then `Vboxed == V` (by value).
     // For convenience, we also set this value of isboxed values, in which case
     // it is equal (at compile time) to V.
-    // If this is non-NULL, it is always of type `T_prjlvalue`
+
+    // If this is non-NULL (at compile time), it is always of type `T_prjlvalue`.
+    // N.B.: In general we expect this to always be a dereferenceable pointer at runtime.
+    //       However, there are situations where this value may be a runtime NULL
+    //       (PhiNodes with undef predecessors or PhiC with undef UpsilonNode).
+    //       The middle-end arranges appropriate error checks before any use
+    //       of this value that may read a non-dereferenceable Vboxed, with two
+    //       exceptions: PhiNode and UpsilonNode arguments which need special
+    //       handling to account for the possibility that this may be NULL.
     Value *Vboxed;
+
     Value *TIndex; // if `V` is an unboxed (tagged) Union described by `typ`, this gives the DataType index (1-based, small int) as an i8
     jl_value_t *constant; // constant value (rooted in linfo.def.roots)
     jl_value_t *typ; // the original type of V, never NULL
@@ -2408,29 +2417,28 @@ static jl_cgval_t convert_julia_type(jl_codectx_t &ctx, const jl_cgval_t &v, jl_
         return ghostValue(ctx, typ);
     Value *new_tindex = NULL;
     if (jl_is_concrete_type(typ)) {
-        if (v.TIndex && !jl_is_pointerfree(typ)) {
-            // discovered that this union-split type must actually be isboxed
-            if (v.Vboxed) {
-                return jl_cgval_t(v.Vboxed, true, typ, NULL, best_tbaa(ctx.tbaa(), typ));
-            }
-            else {
-                // type mismatch: there weren't any boxed values in the union
-                if (skip)
-                    *skip = ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 1);
-                else
-                    CreateTrap(ctx.builder);
-                return jl_cgval_t();
-            }
-        }
         if (jl_is_concrete_type(v.typ)) {
-            if (jl_is_concrete_type(typ)) {
-                // type mismatch: changing from one leaftype to another
-                if (skip)
-                    *skip = ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 1);
-                else
-                    CreateTrap(ctx.builder);
-                return jl_cgval_t();
+            // type mismatch: changing from one leaftype to another
+            if (skip)
+                *skip = ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 1);
+            else
+                CreateTrap(ctx.builder);
+            return jl_cgval_t();
+        }
+        bool mustbox_union = v.TIndex && !jl_is_pointerfree(typ);
+        if (v.Vboxed && (v.isboxed || mustbox_union)) {
+            if (skip) {
+                *skip = ctx.builder.CreateNot(emit_exactly_isa(ctx, v, (jl_datatype_t*)typ, true));
             }
+            return jl_cgval_t(v.Vboxed, true, typ, NULL, best_tbaa(ctx.tbaa(), typ));
+        }
+        if (mustbox_union) {
+            // type mismatch: there weren't any boxed values in the union
+            if (skip)
+                *skip = ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 1);
+            else
+                CreateTrap(ctx.builder);
+            return jl_cgval_t();
         }
     }
     else {
@@ -5302,9 +5310,13 @@ static void emit_varinfo_assign(jl_codectx_t &ctx, jl_varinfo_t &vi, jl_cgval_t
     // If allow_mismatch is set, type mismatches will not result in traps.
     // This is used for upsilon nodes, where the destination can have a narrower
     // type than the store, if inference determines that the store is never read.
-    Value *dummy = NULL;
-    Value **skip = allow_mismatch ? &dummy : NULL;
-    rval_info = convert_julia_type(ctx, rval_info, slot_type, skip);
+    Value *skip = NULL;
+    rval_info = convert_julia_type(ctx, rval_info, slot_type, &skip);
+    if (!allow_mismatch && skip) {
+        CreateTrap(ctx.builder);
+        return;
+    }
+
     if (rval_info.typ == jl_bottom_type)
         return;
 
@@ -5349,8 +5361,13 @@ static void emit_varinfo_assign(jl_codectx_t &ctx, jl_varinfo_t &vi, jl_cgval_t
 
     // store unboxed variables
     if (!vi.boxroot || (vi.pTIndex && rval_info.TIndex)) {
-        emit_vi_assignment_unboxed(ctx, vi, isboxed, rval_info);
+        emit_guarded_test(ctx, skip ? ctx.builder.CreateNot(skip) : nullptr, nullptr, [&]{
+            emit_vi_assignment_unboxed(ctx, vi, isboxed, rval_info);
+            return nullptr;
+        });
     }
+
+    return;
 }
 
 static void emit_assignment(jl_codectx_t &ctx, jl_value_t *l, jl_value_t *r, ssize_t ssaval)
@@ -5362,7 +5379,8 @@ static void emit_assignment(jl_codectx_t &ctx, jl_value_t *l, jl_value_t *r, ssi
         int sl = jl_slot_number(l) - 1;
         // it's a local variable
         jl_varinfo_t &vi = ctx.slots[sl];
-        return emit_varinfo_assign(ctx, vi, rval_info, l);
+        emit_varinfo_assign(ctx, vi, rval_info, l);
+        return;
     }
 
     jl_module_t *mod;
@@ -5393,15 +5411,17 @@ static void emit_upsilonnode(jl_codectx_t &ctx, ssize_t phic, jl_value_t *val)
     // upsilon node is not dynamically observed.
     if (val) {
         jl_cgval_t rval_info = emit_expr(ctx, val);
-        if (rval_info.typ == jl_bottom_type)
+        if (rval_info.typ == jl_bottom_type) {
             // as a special case, PhiC nodes are allowed to use undefined
             // values, since they are just copy operations, so we need to
             // ignore the store (it will not by dynamically observed), while
             // normally, for any other operation result, we'd assume this store
             // was unreachable and dead
             val = NULL;
-        else
+        }
+        else {
             emit_varinfo_assign(ctx, vi, rval_info, NULL, true);
+        }
     }
     if (!val) {
         if (vi.boxroot) {
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index d7f5a7cc0c23f..eaa4ef593aa46 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -533,9 +533,9 @@ function CC.abstract_eval_globalref(interp::REPLInterpreter, g::GlobalRef,
                                     sv::CC.InferenceState)
     if (interp.limit_aggressive_inference ? is_repl_frame(sv) : is_call_graph_uncached(sv))
         if CC.isdefined_globalref(g)
-            return Const(ccall(:jl_get_globalref_value, Any, (Any,), g))
+            return CC.RTEffects(Const(ccall(:jl_get_globalref_value, Any, (Any,), g)), CC.EFFECTS_TOTAL)
         end
-        return Union{}
+        return CC.RTEffects(Union{}, CC.EFFECTS_THROWS)
     end
     return @invoke CC.abstract_eval_globalref(interp::CC.AbstractInterpreter, g::GlobalRef,
                                               sv::CC.InferenceState)
diff --git a/test/compiler/EscapeAnalysis/EscapeAnalysis.jl b/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
index fc2d6f774cd9d..d8ea8be21fe07 100644
--- a/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
+++ b/test/compiler/EscapeAnalysis/EscapeAnalysis.jl
@@ -201,6 +201,7 @@ end
     let # try/catch
         result = code_escapes((Any,)) do a
             try
+                println("prevent ConstABI")
                 nothing
             catch err
                 return a # return escape
@@ -210,6 +211,7 @@ end
     end
     let result = code_escapes((Any,)) do a
             try
+                println("prevent ConstABI")
                 nothing
             finally
                 return a # return escape
diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl
index daa636a11b02d..a487d628f9f48 100644
--- a/test/compiler/codegen.jl
+++ b/test/compiler/codegen.jl
@@ -487,12 +487,16 @@ function f37262(x)
     catch
         GC.safepoint()
     end
+    local a
     try
         GC.gc()
-        return g37262(x)
+        a = g37262(x)
+        Base.inferencebarrier(false) && error()
+        return a
     catch ex
         GC.gc()
     finally
+        @isdefined(a) && Base.donotdelete(a)
         GC.gc()
     end
 end
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 861bbbbcec36d..bfb78d6c61bfd 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -2561,7 +2561,7 @@ function h25579(g)
     return t ? typeof(h) : typeof(h)
 end
 @test Base.return_types(h25579, (Base.RefValue{Union{Nothing, Int}},)) ==
-        Any[Union{Type{Float64}, Type{Int}, Type{Nothing}}]
+        Any[Type{Float64}]
 
 f26172(v) = Val{length(Base.tail(ntuple(identity, v)))}() # Val(M-1)
 g26172(::Val{0}) = ()
@@ -4424,7 +4424,7 @@ end
             nothing
         end
         return x
-    end) === Union{Int, Float64, Char}
+    end) === Union{Int, Char}
 
 # issue #42097
 struct Foo42097{F} end
@@ -5372,6 +5372,123 @@ end
 @test Base.return_types(phic_type3) |> only === Union{Int, Float64}
 @test phic_type3() === 2
 
+# Issue #51852
+function phic_type4()
+    a = (;progress = "a")
+    try
+        may_error(false)
+        let b = Base.inferencebarrier(true) ? (;progress = 1.0) : a
+            a = b
+        end
+    catch
+    end
+    GC.gc()
+    return a
+end
+@test Base.return_types(phic_type4) |> only === Union{@NamedTuple{progress::Float64}, @NamedTuple{progress::String}}
+@test phic_type4() === (;progress = 1.0)
+
+function phic_type5()
+    a = (;progress = "a")
+    try
+        vals = (a, (progress=1.0,))
+        may_error(false)
+        a = vals[Base.inferencebarrier(false) ? 1 : 2]
+    catch
+    end
+    GC.gc()
+    return a
+end
+@test Base.return_types(phic_type5) |> only === Union{@NamedTuple{progress::Float64}, @NamedTuple{progress::String}}
+@test phic_type5() === (;progress = 1.0)
+
+function phic_type6()
+    a = Base.inferencebarrier(true) ? (;progress = "a") : (;progress = Ref{Any}(0))
+    try
+        may_error(false)
+        let b = Base.inferencebarrier(true) ? (;progress = 1.0) : a
+            a = b
+        end
+    catch
+    end
+    GC.gc()
+    return a
+end
+@test Base.return_types(phic_type6) |> only === Union{@NamedTuple{progress::Float64}, @NamedTuple{progress::Base.RefValue{Any}}, @NamedTuple{progress::String}}
+@test phic_type6() === (;progress = 1.0)
+
+function phic_type7()
+    a = Base.inferencebarrier(true) ? (;progress = "a") : (;progress = Ref{Any}(0))
+    try
+        vals = (a, (progress=1.0,))
+        may_error(false)
+        a = vals[Base.inferencebarrier(false) ? 1 : 2]
+    catch
+    end
+    GC.gc()
+    return a
+end
+@test Base.return_types(phic_type7) |> only === Union{@NamedTuple{progress::Float64}, @NamedTuple{progress::Base.RefValue{Any}}, @NamedTuple{progress::String}}
+@test phic_type7() === (;progress = 1.0)
+
+function phic_type8()
+    local a
+    try
+        may_error(true)
+        a = Base.inferencebarrier(1)
+    catch
+    end
+
+    try
+        a = 2
+        may_error(true)
+    catch
+    end
+    GC.gc()
+    return a
+end
+@test Base.return_types(phic_type8) |> only === Int
+@test phic_type8() === 2
+
+
+function phic_type9()
+    local a
+    try
+        may_error(false)
+        a = Base.inferencebarrier(false) ? 1 : nothing
+    catch
+    end
+
+    try
+        a = 2
+        may_error(true)
+    catch
+    end
+    GC.gc()
+    return a
+end
+@test Base.return_types(phic_type9) |> only === Int
+@test phic_type9() === 2
+
+function phic_type10()
+    local a
+    try
+        may_error(false)
+        a = Base.inferencebarrier(true) ? missing : nothing
+    catch
+    end
+
+    try
+        Base.inferencebarrier(true) && (a = 2)
+        may_error(true)
+    catch
+    end
+    GC.gc()
+    return a::Int
+end
+@test Base.return_types(phic_type10) |> only === Int
+@test phic_type10() === 2
+
 # Test that `exit` returns `Union{}` (issue #51856)
 function test_exit_bottom(s)
     n = tryparse(Int, s)
diff --git a/test/show.jl b/test/show.jl
index 934a4bbd2ce48..899327d80b531 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2052,6 +2052,7 @@ eval(Meta._parse_string("""function my_fun28173(x)
             r = 1
             s = try
                 r = 2
+                Base.inferencebarrier(false) && error()
                 "BYE"
             catch
                 r = 3
@@ -2088,16 +2089,16 @@ let src = code_typed(my_fun28173, (Int,), debuginfo=:source)[1][1]
     end
     @test popfirst!(lines2) == "   │          $(QuoteNode(2))"
     @test pop!(lines2) == "   └───       \$(QuoteNode(4))"
-    @test pop!(lines1) == "17 └───       return %18"
-    @test pop!(lines2) == "   │          return %18"
-    @test pop!(lines2) == "17 │          \$(QuoteNode(3))"
+    @test pop!(lines1) == "18 └───       return %22"
+    @test pop!(lines2) == "   │          return %22"
+    @test pop!(lines2) == "18 │          \$(QuoteNode(3))"
     @test lines1 == lines2
 
     # verbose linetable
     io = IOBuffer()
     Base.IRShow.show_ir(io, ir, Base.IRShow.default_config(ir; verbose_linetable=true))
     seekstart(io)
-    @test count(contains(r"@ a{80}:\d+ within `my_fun28173"), eachline(io)) == 10
+    @test count(contains(r"@ a{80}:\d+ within `my_fun28173"), eachline(io)) == 11
 
     # Test that a bad :invoke doesn't cause an error during printing
     Core.Compiler.insert_node!(ir, 1, Core.Compiler.NewInstruction(Expr(:invoke, nothing, sin), Any), false)

From 4462257017b504847ff873af83f1543a949994aa Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 3 Nov 2023 15:09:39 -0400
Subject: [PATCH 0181/1315] lowering: Fix accidental clearing of never-undef
 flag in closure convert (#51991)

This code dates back all the way to the original closure conversion code
[1]. At the time, the 0x4 bit of the vinfo was used for tracking whether
a variable is assigned in an inner function [2], which apparently needed
to be cleared during closure conversion. However, shortly afterwards,
the bit was removed [3] and subsequently re-used for never-undef [4].
However, the magic number in the closure conversion pass was never
updated, causing the new never-undef flag to be accidentally cleared
unconditionally.

[1]
https://github.com/JuliaLang/julia/commit/a1ee8676f00fc14bd67aaf7eb20ce46ff99f322e
[2]
https://github.com/JuliaLang/julia/blob/a1ee8676f00fc14bd67aaf7eb20ce46ff99f322e/src/ast.scm#L217-L218
[3]
https://github.com/JuliaLang/julia/commit/7e7d74332953497cd0dba278aa243f3efc284cee
[4]
https://github.com/JuliaLang/julia/commit/3d8f8d14787e697fab4543e1bca1ce4519977281

Co-authored-by: Jeff Bezanson <jeff@juliahub.com>
---
 src/julia-syntax.scm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 87a40d2bf3804..6afb8afaffbea 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -3481,7 +3481,7 @@ f(x) = yt(x)
 
 
 (define (vinfo:not-capt vi)
-  (list (car vi) (cadr vi) (logand (caddr vi) (lognot 5))))
+  (list (car vi) (cadr vi) (logand (caddr vi) (lognot 1))))
 
 (define (clear-capture-bits vinfos)
   (map vinfo:not-capt vinfos))

From 7df878171dc752bf053210cdcd756434e175dc28 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 3 Nov 2023 22:54:03 -0300
Subject: [PATCH 0182/1315] Fix GC.gc docstring (#52008)

GC.gc(true) will perform a full mark (note the use of [recollect in gc.c
](https://github.com/JuliaLang/julia/blob/5eaad532f961d4d1a1630b5c5b60499d2a7b9ae5/src/gc.c#L3338)if
the previous sweep was not full).

Fixes https://github.com/JuliaLang/julia/issues/51796.

---------

Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
Co-authored-by: Kiran Pamnany <kpamnany@users.noreply.github.com>
---
 base/gcutils.jl | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/base/gcutils.jl b/base/gcutils.jl
index fed30befd7d5c..ea39bc8ab6130 100644
--- a/base/gcutils.jl
+++ b/base/gcutils.jl
@@ -119,9 +119,12 @@ const GC_INCREMENTAL = 2
     GC.gc([full=true])
 
 Perform garbage collection. The argument `full` determines the kind of
-collection: A full collection (default) sweeps all objects, which makes the
-next GC scan much slower, while an incremental collection may only sweep
-so-called young objects.
+collection: a full collection (default) traverses all live objects (i.e. full mark)
+and should reclaim memory from all unreachable objects. An incremental collection only
+reclaims memory from young objects which are not reachable.
+
+The GC may decide to perform a full collection even if an incremental collection was
+requested.
 
 !!! warning
     Excessive use will likely lead to poor performance.

From d75a00f0a4e28e3af066d04f9b657786be35bea4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?P=C3=A1ll=20Haraldsson?= <Pall.Haraldsson@gmail.com>
Date: Sat, 4 Nov 2023 02:27:31 +0000
Subject: [PATCH 0183/1315] Simplify, 16bit PDP-11 isn't going to be supported
 (#45763)

PDP_ENDIAN isn't used.

Co-authored-by: Viral B. Shah <ViralBShah@users.noreply.github.com>
---
 src/support/dtypes.h | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/support/dtypes.h b/src/support/dtypes.h
index da570921c101c..4e9868ed45c23 100644
--- a/src/support/dtypes.h
+++ b/src/support/dtypes.h
@@ -96,7 +96,6 @@ typedef intptr_t ssize_t;
 #include <endian.h>
 #define LITTLE_ENDIAN  __LITTLE_ENDIAN
 #define BIG_ENDIAN     __BIG_ENDIAN
-#define PDP_ENDIAN     __PDP_ENDIAN
 #define BYTE_ORDER     __BYTE_ORDER
 #endif
 
@@ -104,19 +103,16 @@ typedef intptr_t ssize_t;
 #include <machine/endian.h>
 #define __LITTLE_ENDIAN  LITTLE_ENDIAN
 #define __BIG_ENDIAN     BIG_ENDIAN
-#define __PDP_ENDIAN     PDP_ENDIAN
 #define __BYTE_ORDER     BYTE_ORDER
 #endif
 
 #ifdef _OS_WINDOWS_
 #define __LITTLE_ENDIAN    1234
 #define __BIG_ENDIAN       4321
-#define __PDP_ENDIAN       3412
 #define __BYTE_ORDER       __LITTLE_ENDIAN
 #define __FLOAT_WORD_ORDER __LITTLE_ENDIAN
 #define LITTLE_ENDIAN      __LITTLE_ENDIAN
 #define BIG_ENDIAN         __BIG_ENDIAN
-#define PDP_ENDIAN         __PDP_ENDIAN
 #define BYTE_ORDER         __BYTE_ORDER
 #endif
 

From f3ae44c3f680312ae75a5e7363de3c70bedeaf0c Mon Sep 17 00:00:00 2001
From: chethega <chethega@gmail.com>
Date: Sat, 4 Nov 2023 14:20:35 +0100
Subject: [PATCH 0184/1315] changed broadcast! into bitarray algorithm (#32048)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Cf
https://discourse.julialang.org/t/broadcast-vs-slow-performance-allocations/24259/6
for some more discussion and
https://github.com/JuliaLang/julia/issues/32047 for the question of
validity in view of exceptions.

Before:
```
julia> using BenchmarkTools, Random
julia> y=1; xsmall=[1]; Random.seed!(42); xlarge=rand(1:4, 100_003);
julia> @btime broadcast(==, $xsmall, $y); @btime  broadcast(==, $xlarge, $y); @show hash(broadcast(==, xlarge, y).chunks);
  860.500 ns (3 allocations: 4.31 KiB)
  152.971 μs (3 allocations: 16.59 KiB)
hash((broadcast(==, xlarge, y)).chunks) = 0xaa3b5a692968e128
```
After:
```
julia> @btime broadcast(==, $xsmall, $y); @btime  broadcast(==, $xlarge, $y); @show hash(broadcast(==, xlarge, y).chunks);
  65.466 ns (2 allocations: 128 bytes)
  42.927 μs (2 allocations: 12.41 KiB)
hash((broadcast(==, xlarge, y)).chunks) = 0xaa3b5a692968e128
```

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/broadcast.jl | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index 97e69cc680358..d6e5513889cee 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -974,6 +974,32 @@ preprocess(dest, x) = extrude(broadcast_unalias(dest, x))
     return dest
 end
 
+# Performance optimization: for BitVector outputs, we cache the result
+# in a 64-bit register before writing into memory (to bypass LSQ)
+@inline function copyto!(dest::BitVector, bc::Broadcasted{Nothing})
+    axes(dest) == axes(bc) || throwdm(axes(dest), axes(bc))
+    ischunkedbroadcast(dest, bc) && return chunkedcopyto!(dest, bc)
+    destc = dest.chunks
+    bcp = preprocess(dest, bc)
+    length(bcp) <= 0 && return dest
+    len = Base.num_bit_chunks(Int(length(bcp)))
+    @inbounds for i = 0:(len - 2)
+        z = UInt64(0)
+        for j = 0:63
+           z |= UInt64(bcp[i*64 + j + 1]::Bool) << (j & 63)
+        end
+        destc[i + 1] = z
+    end
+    @inbounds let i = len - 1
+        z = UInt64(0)
+        for j = 0:((length(bcp) - 1) & 63)
+             z |= UInt64(bcp[i*64 + j + 1]::Bool) << (j & 63)
+        end
+        destc[i + 1] = z
+    end
+    return dest
+end
+
 # Performance optimization: for BitArray outputs, we cache the result
 # in a "small" Vector{Bool}, and then copy in chunks into the output
 @inline function copyto!(dest::BitArray, bc::Broadcasted{Nothing})

From c377e02a94ead8f596452c6c75ec66fb5e91666c Mon Sep 17 00:00:00 2001
From: Martin <martin.reinhardt.87@gmail.com>
Date: Sat, 4 Nov 2023 14:22:29 +0100
Subject: [PATCH 0185/1315] doc: AbstractChannel implementation example
 (#47610)

fixes #47608 in the manual

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 doc/src/manual/distributed-computing.md | 69 +++++++++++++++++++++++--
 1 file changed, 66 insertions(+), 3 deletions(-)

diff --git a/doc/src/manual/distributed-computing.md b/doc/src/manual/distributed-computing.md
index 4531506d5c49d..83d4f14808a8f 100644
--- a/doc/src/manual/distributed-computing.md
+++ b/doc/src/manual/distributed-computing.md
@@ -539,9 +539,72 @@ Methods [`put!`](@ref), [`take!`](@ref), [`fetch`](@ref), [`isready`](@ref) and
 on a [`RemoteChannel`](@ref) are proxied onto the backing store on the remote process.
 
 [`RemoteChannel`](@ref) can thus be used to refer to user implemented `AbstractChannel` objects.
-A simple example of this is provided in `dictchannel.jl` in the
-[Examples repository](https://github.com/JuliaAttic/Examples), which uses a dictionary as its
-remote store.
+A simple example of this is the following `DictChannel` which uses a dictionary as its
+remote store:
+
+```jldoctest
+julia> struct DictChannel{T} <: AbstractChannel{T}
+           d::Dict
+           cond_take::Threads.Condition    # waiting for data to become available
+           DictChannel{T}() where {T} = new(Dict(), Threads.Condition())
+           DictChannel() = DictChannel{Any}()
+       end
+
+julia> begin
+       function Base.put!(D::DictChannel, k, v)
+           @lock D.cond_take begin
+               D.d[k] = v
+               notify(D.cond_take)
+           end
+           return D
+       end
+       function Base.take!(D::DictChannel, k)
+           @lock D.cond_take begin
+               v = fetch(D, k)
+               delete!(D.d, k)
+               return v
+           end
+       end
+       Base.isready(D::DictChannel) = @lock D.cond_take !isempty(D.d)
+       Base.isready(D::DictChannel, k) = @lock D.cond_take haskey(D.d, k)
+       function Base.fetch(D::DictChannel, k)
+           @lock D.cond_take begin
+               wait(D, k)
+               return D.d[k]
+           end
+       end
+       function Base.wait(D::DictChannel, k)
+           @lock D.cond_take begin
+               while !isready(D, k)
+                   wait(D.cond_take)
+               end
+           end
+       end
+       end;
+
+julia> d = DictChannel();
+
+julia> isready(d)
+false
+
+julia> put!(d, :k, :v);
+
+julia> isready(d, :k)
+true
+
+julia> fetch(d, :k)
+:v
+
+julia> wait(d, :k)
+
+julia> take!(d, :k)
+:v
+
+julia> isready(d, :k)
+false
+```
+
+
 
 
 ## Channels and RemoteChannels

From bc0d8886c6471e57c4b8b2355e4bf6ea326de2d3 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Sat, 4 Nov 2023 10:23:15 -0300
Subject: [PATCH 0186/1315] make pool_live_bytes metric more accurate (#52015)

`pool_live_bytes` was previously lazily updated during the GC, meaning
it was only accurate right after a GC.

Make this metric accurate if gathered after a GC has happened.
---
 src/gc.c            | 15 ++++++++++++---
 src/julia_threads.h |  1 +
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 0c046aa680e9c..840a9ecc548cd 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -758,7 +758,6 @@ int current_sweep_full = 0;
 int under_pressure = 0;
 
 // Full collection heuristics
-static int64_t pool_live_bytes = 0;
 static int64_t live_bytes = 0;
 static int64_t promoted_bytes = 0;
 static int64_t last_live_bytes = 0; // live_bytes at last collection
@@ -1333,6 +1332,8 @@ STATIC_INLINE jl_value_t *jl_gc_pool_alloc_inner(jl_ptls_t ptls, int pool_offset
     maybe_collect(ptls);
     jl_atomic_store_relaxed(&ptls->gc_num.allocd,
         jl_atomic_load_relaxed(&ptls->gc_num.allocd) + osize);
+    jl_atomic_store_relaxed(&ptls->gc_num.pool_live_bytes,
+        jl_atomic_load_relaxed(&ptls->gc_num.pool_live_bytes) + osize);
     jl_atomic_store_relaxed(&ptls->gc_num.poolalloc,
         jl_atomic_load_relaxed(&ptls->gc_num.poolalloc) + 1);
     // first try to use the freelist
@@ -1520,7 +1521,8 @@ static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_pag
         }
     }
     gc_time_count_page(freedall, pg_skpd);
-    jl_atomic_fetch_add((_Atomic(int64_t) *)&pool_live_bytes, GC_PAGE_SZ - GC_PAGE_OFFSET - nfree * osize);
+    jl_ptls_t ptls = gc_all_tls_states[pg->thread_n];
+    jl_atomic_fetch_add(&ptls->gc_num.pool_live_bytes, GC_PAGE_SZ - GC_PAGE_OFFSET - nfree * osize);
     jl_atomic_fetch_add((_Atomic(int64_t) *)&gc_num.freed, (nfree - old_nfree) * osize);
 }
 
@@ -1642,6 +1644,7 @@ static void gc_sweep_pool(void)
             }
             continue;
         }
+        jl_atomic_store_relaxed(&ptls2->gc_num.pool_live_bytes, 0);
         for (int i = 0; i < JL_GC_N_POOLS; i++) {
             jl_gc_pool_t *p = &ptls2->heap.norm_pools[i];
             jl_taggedvalue_t *last = p->freelist;
@@ -3182,6 +3185,13 @@ JL_DLLEXPORT int64_t jl_gc_sync_total_bytes(int64_t offset) JL_NOTSAFEPOINT
 
 JL_DLLEXPORT int64_t jl_gc_pool_live_bytes(void)
 {
+    int64_t pool_live_bytes = 0;
+    for (int i = 0; i < gc_n_threads; i++) {
+        jl_ptls_t ptls2 = gc_all_tls_states[i];
+        if (ptls2 != NULL) {
+            pool_live_bytes += jl_atomic_load_relaxed(&ptls2->gc_num.pool_live_bytes);
+        }
+    }
     return pool_live_bytes;
 }
 
@@ -3346,7 +3356,6 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
         promoted_bytes = 0;
     }
     scanned_bytes = 0;
-    pool_live_bytes = 0;
     // 6. start sweeping
     uint64_t start_sweep_time = jl_hrtime();
     JL_PROBE_GC_SWEEP_BEGIN(sweep_full);
diff --git a/src/julia_threads.h b/src/julia_threads.h
index b8276682ee359..332ff53ab086d 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -130,6 +130,7 @@ typedef struct {
 
 typedef struct {
     _Atomic(int64_t) allocd;
+    _Atomic(int64_t) pool_live_bytes;
     _Atomic(uint64_t) malloc;
     _Atomic(uint64_t) realloc;
     _Atomic(uint64_t) poolalloc;

From 2896759c07b4b8c48c9b1817c7801fe05a919a1c Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 4 Nov 2023 09:24:03 -0400
Subject: [PATCH 0187/1315] extend escape_raw_string to allow specifying the
 delimiter (#52001)

Similar to how `escape_raw_string` enabled users to reverse the
transform done by string literals, this enables users to reverse the
transform done by cmd literals by specifying an argument of a '\`'.

Refs #41041

Co-authored-by: Simeon Schaub <simeondavidschaub99@gmail.com>
---
 base/strings/io.jl      | 39 ++++++++++++++++++++++-----------------
 doc/src/base/strings.md |  1 +
 test/strings/io.jl      |  9 +++++++++
 3 files changed, 32 insertions(+), 17 deletions(-)

diff --git a/base/strings/io.jl b/base/strings/io.jl
index 441b39693096f..c1e45775f6ca0 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -612,14 +612,14 @@ julia> println(raw"\\\\x \\\\\\"")
 macro raw_str(s); s; end
 
 """
-    escape_raw_string(s::AbstractString)
-    escape_raw_string(io, s::AbstractString)
+    escape_raw_string(s::AbstractString, delim='"') -> AbstractString
+    escape_raw_string(io, s::AbstractString, delim='"')
 
 Escape a string in the manner used for parsing raw string literals.
-For each double-quote (`"`) character in input string `s`, this
-function counts the number _n_ of preceding backslash (`\\`) characters,
-and then increases there the number of backslashes from _n_ to 2_n_+1
-(even for _n_ = 0). It also doubles a sequence of backslashes at the end
+For each double-quote (`"`) character in input string `s` (or `delim` if
+specified), this function counts the number _n_ of preceding backslash (`\\`)
+characters, and then increases there the number of backslashes from _n_ to
+2_n_+1 (even for _n_ = 0). It also doubles a sequence of backslashes at the end
 of the string.
 
 This escaping convention is used in raw strings and other non-standard
@@ -629,36 +629,41 @@ command-line string into the argv[] array.)
 
 See also [`escape_string`](@ref).
 """
-function escape_raw_string(io, str::AbstractString)
+function escape_raw_string(io::IO, str::AbstractString, delim::Char='"')
+    total = 0
     escapes = 0
     for c in str
         if c == '\\'
             escapes += 1
         else
-            if c == '"'
+            if c == delim
                 # if one or more backslashes are followed by
                 # a double quote then escape all backslashes
                 # and the double quote
-                escapes = escapes * 2 + 1
-            end
-            while escapes > 0
-                write(io, '\\')
-                escapes -= 1
+                escapes += 1
+                total += escapes
+                while escapes > 0
+                    write(io, '\\')
+                    escapes -= 1
+                end
             end
             escapes = 0
-            write(io, c)
         end
+        write(io, c)
     end
     # also escape any trailing backslashes,
     # so they do not affect the closing quote
+    total += escapes
     while escapes > 0
-        write(io, '\\')
         write(io, '\\')
         escapes -= 1
     end
+    total
+end
+function escape_raw_string(str::AbstractString, delim::Char='"')
+    total = escape_raw_string(devnull, str, delim) # check whether the string even needs to be copied and how much to allocate for it
+    return total == 0 ? str : sprint(escape_raw_string, str, delim; sizehint = sizeof(str) + total)
 end
-escape_raw_string(str::AbstractString) = sprint(escape_raw_string, str;
-                                                sizehint = lastindex(str) + 2)
 
 ## multiline strings ##
 
diff --git a/doc/src/base/strings.md b/doc/src/base/strings.md
index 2504f3dbd583a..2b70a4f53198e 100644
--- a/doc/src/base/strings.md
+++ b/doc/src/base/strings.md
@@ -95,5 +95,6 @@ Base.isspace
 Base.isuppercase
 Base.isxdigit
 Base.escape_string
+Base.escape_raw_string
 Base.unescape_string
 ```
diff --git a/test/strings/io.jl b/test/strings/io.jl
index aed1f800d4d49..5f657297af08f 100644
--- a/test/strings/io.jl
+++ b/test/strings/io.jl
@@ -156,6 +156,15 @@
         @test "aaa \\g \\n" == unescape_string(str, ['g', 'n'])
     end
     @test Base.escape_raw_string(raw"\"\\\"\\-\\") == "\\\"\\\\\\\"\\\\-\\\\"
+    @test Base.escape_raw_string(raw"`\`\\-\\") == "\`\\\`\\\\-\\\\"
+    @test Base.escape_raw_string(raw"\"\\\"\\-\\", '`') == "\"\\\"\\\\-\\\\"
+    @test Base.escape_raw_string(raw"`\`\\-\\", '`') == "\\\`\\\\\\\`\\\\-\\\\"
+    @test Base.escape_raw_string(raw"some`string") == "some`string"
+    @test Base.escape_raw_string(raw"some\"string", '`') == "some\"string"
+    @test Base.escape_raw_string(raw"some`string\\") == "some`string\\\\"
+    @test Base.escape_raw_string(raw"some\"string\\", '`') == "some\"string\\\\"
+    @test Base.escape_raw_string(raw"some\"string") == "some\\\"string"
+    @test Base.escape_raw_string(raw"some`string", '`') == "some\\`string"
 end
 @testset "join()" begin
     @test join([]) == join([],",") == ""

From 58c6b7033f7aa61a4d0615fad326cbc1756d7c24 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Sat, 4 Nov 2023 10:25:45 -0300
Subject: [PATCH 0188/1315] Fix bugs and some warnings triggered by clang-tidy
 (#52002)

Most of the changes are NFC (unused variables/stores), but a couple (the
change in codegen.cpp and in datatype.c) are potential bugs.
It also complained that ios_readline might leak memory, and it looks
like that is true

While we do run clang-tidy on CI, using `bear` to make a
`compile_commands.json` and running `run-clang-tidy-17.py` seems to have
found some other things. (we disable dead stores in CI for some reason
even though it seems to find some bugs)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 cli/loader_lib.c                  |  3 ++-
 src/codegen.cpp                   |  7 ++++---
 src/datatype.c                    |  4 ++--
 src/disasm.cpp                    |  4 ++--
 src/gc.c                          |  4 ----
 src/jitlayers.cpp                 |  1 +
 src/jltypes.c                     |  1 -
 src/llvm-final-gc-lowering.cpp    |  2 +-
 src/llvm-propagate-addrspaces.cpp |  1 -
 src/runtime_ccall.cpp             |  2 +-
 src/staticdata.c                  |  2 --
 src/support/ios.c                 | 12 +++++++++---
 src/threading.c                   |  2 +-
 13 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/cli/loader_lib.c b/cli/loader_lib.c
index 12feed0c508a0..02030cf2717a5 100644
--- a/cli/loader_lib.c
+++ b/cli/loader_lib.c
@@ -281,6 +281,7 @@ static char *libstdcxxprobe(void)
         // See if the version is compatible
         char *dlerr = dlerror(); // clear out dlerror
         void *sym = dlsym(handle, GLIBCXX_LEAST_VERSION_SYMBOL);
+        (void)sym;
         dlerr = dlerror();
         if (dlerr) {
             // We can't use the library that was found, so don't write anything.
@@ -375,7 +376,6 @@ __attribute__((constructor)) void jl_load_libjulia_internal(void) {
     const char *lib_dir = jl_get_libdir();
 
     // Pre-load libraries that libjulia-internal needs.
-    int deps_len = strlen(&dep_libs[1]);
     char *curr_dep = &dep_libs[1];
 
     // We keep track of "special" libraries names (ones whose name is prefixed with `@`)
@@ -451,6 +451,7 @@ __attribute__((constructor)) void jl_load_libjulia_internal(void) {
                     char *cxxpath = libstdcxxprobe();
                     if (cxxpath) {
                         void *cxx_handle = dlopen(cxxpath, RTLD_LAZY);
+                        (void)cxx_handle;
                         const char *dlr = dlerror();
                         if (dlr) {
                             jl_loader_print_stderr("ERROR: Unable to dlopen(cxxpath) in parent!\n");
diff --git a/src/codegen.cpp b/src/codegen.cpp
index ca179817d4e1f..2365d0af334c5 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -6534,6 +6534,7 @@ static Function* gen_cfun_wrapper(
     jl_cgval_t retval;
     if (calltype == 2) {
         nargs = 0; // arguments not needed -- TODO: not really true, should emit an age_ok test and jlcall
+        (void)nargs; // silence unused variable warning
         jlfunc_sret = false;
         retval = mark_julia_const(ctx, (jl_value_t*)callptr);
     }
@@ -6893,11 +6894,11 @@ static jl_cgval_t emit_cfunction(jl_codectx_t &ctx, jl_value_t *output_type, con
         if (closure_types) {
             assert(ctx.spvals_ptr);
             size_t n = jl_array_nrows(closure_types);
-            jl_svec_t *fill = jl_alloc_svec_uninit(n);
+            jl_svec_t *fill_i = jl_alloc_svec_uninit(n);
             for (size_t i = 0; i < n; i++) {
-                jl_svecset(fill, i, jl_array_ptr_ref(closure_types, i));
+                jl_svecset(fill_i, i, jl_array_ptr_ref(closure_types, i));
             }
-            fill = (jl_svec_t*)jl_ensure_rooted(ctx, (jl_value_t*)fill);
+            fill = (jl_svec_t*)jl_ensure_rooted(ctx, (jl_value_t*)fill_i);
         }
         Type *T_htable = ArrayType::get(ctx.types().T_size, sizeof(htable_t) / sizeof(void*));
         Value *cache = new GlobalVariable(*jl_Module, T_htable, false,
diff --git a/src/datatype.c b/src/datatype.c
index 7fa712b6c8ddf..7a04bfd7f2046 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -1885,8 +1885,8 @@ jl_value_t *modify_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_valu
                 int success = memcmp((char*)v + offs, r, fsz) == 0;
                 if (success) {
                     if (isunion) {
-                        size_t fsz = jl_field_size(st, i);
-                        uint8_t *psel = &((uint8_t*)v)[offs + fsz - 1];
+                        size_t fsz_i = jl_field_size(st, i);
+                        uint8_t *psel = &((uint8_t*)v)[offs + fsz_i - 1];
                         success = (jl_typeof(r) == jl_nth_union_component(ty, *psel));
                         if (success) {
                             unsigned nth = 0;
diff --git a/src/disasm.cpp b/src/disasm.cpp
index 8967f793735f4..2e0cb22e43a1c 100644
--- a/src/disasm.cpp
+++ b/src/disasm.cpp
@@ -804,12 +804,12 @@ static int OpInfoLookup(void *DisInfo, uint64_t PC,
 #endif
                         int TagType, void *TagBuf)
 {
-    SymbolTable *SymTab = (SymbolTable*)DisInfo;
+    // SymbolTable *SymTab = (SymbolTable*)DisInfo;
     LLVMOpInfo1 *info = (LLVMOpInfo1*)TagBuf;
     memset(info, 0, sizeof(*info));
     if (TagType != 1)
         return 0;               // Unknown data format
-    PC += SymTab->getIP() - (uint64_t)(uintptr_t)SymTab->getMemoryObject().data(); // add offset from MemoryObject base
+    // PC += SymTab->getIP() - (uint64_t)(uintptr_t)SymTab->getMemoryObject().data(); // add offset from MemoryObject base
     // TODO: see if we knew of a relocation applied at PC
     // info->AddSymbol.Present = 1;
     // info->AddSymbol.Name = name;
diff --git a/src/gc.c b/src/gc.c
index 840a9ecc548cd..06107f1b2a440 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -558,8 +558,6 @@ void jl_gc_run_all_finalizers(jl_task_t *ct)
     }
     // unlock here because `run_finalizers` locks this
     JL_UNLOCK_NOGC(&finalizers_lock);
-    gc_n_threads = 0;
-    gc_all_tls_states = NULL;
     run_finalizers(ct, 1);
 }
 
@@ -633,8 +631,6 @@ JL_DLLEXPORT void jl_finalize_th(jl_task_t *ct, jl_value_t *o)
             finalize_object(&ptls2->finalizers, o, &copied_list, jl_atomic_load_relaxed(&ct->tid) != i);
     }
     finalize_object(&finalizer_list_marked, o, &copied_list, 0);
-    gc_n_threads = 0;
-    gc_all_tls_states = NULL;
     if (copied_list.len > 0) {
         // This releases the finalizers lock.
         jl_gc_run_finalizers_in_list(ct, &copied_list);
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 971a813eb20b1..a22a5d8a6a264 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -649,6 +649,7 @@ jl_value_t *jl_dump_method_asm_impl(jl_method_instance_t *mi, size_t world,
                 if (src && jl_is_code_info(src)) {
                     if (fptr == (uintptr_t)jl_fptr_const_return_addr && specfptr == 0) {
                         fptr = (uintptr_t)_jl_compile_codeinst(codeinst, src, world, *jl_ExecutionEngine->getContext(), 0);
+                        (void)fptr; // silence unused variable warning
                         specfptr = (uintptr_t)jl_atomic_load_relaxed(&codeinst->specptr.fptr);
                     }
                 }
diff --git a/src/jltypes.c b/src/jltypes.c
index 154fa49953f34..c55c6f47f064c 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -1166,7 +1166,6 @@ static void cache_insert_type_linear(jl_datatype_t *type, ssize_t insert_at)
         jl_atomic_store_release(&type->name->linearcache, nc);
         jl_gc_wb(type->name, nc);
         cache = nc;
-        n = jl_svec_len(nc);
     }
     assert(jl_svecref(cache, insert_at) == jl_nothing);
     jl_svecset(cache, insert_at, (jl_value_t*)type); // todo: make this an atomic-store
diff --git a/src/llvm-final-gc-lowering.cpp b/src/llvm-final-gc-lowering.cpp
index 1edf37b960c03..d6480fd81e8ac 100644
--- a/src/llvm-final-gc-lowering.cpp
+++ b/src/llvm-final-gc-lowering.cpp
@@ -116,7 +116,7 @@ void FinalLowerGC::lowerPushGCFrame(CallInst *target, Function &F)
                     PointerType::get(T_ppjlvalue, 0)),
             Align(sizeof(void*)));
     inst->setMetadata(LLVMContext::MD_tbaa, tbaa_gcframe);
-    inst = builder.CreateAlignedStore(
+    builder.CreateAlignedStore(
             gcframe,
             builder.CreateBitCast(pgcstack, PointerType::get(PointerType::get(T_prjlvalue, 0), 0)),
             Align(sizeof(void*)));
diff --git a/src/llvm-propagate-addrspaces.cpp b/src/llvm-propagate-addrspaces.cpp
index 1df6daca818a3..cc7dace28b24e 100644
--- a/src/llvm-propagate-addrspaces.cpp
+++ b/src/llvm-propagate-addrspaces.cpp
@@ -105,7 +105,6 @@ Value *PropagateJuliaAddrspacesVisitor::LiftPointer(Module *M, Value *V, Instruc
             }
             else if (auto *GEP = dyn_cast<GetElementPtrInst>(CurrentV)) {
                 if (LiftingMap.count(GEP)) {
-                    CurrentV = LiftingMap[GEP];
                     break;
                 } else if (Visited.count(GEP)) {
                     return nullptr;
diff --git a/src/runtime_ccall.cpp b/src/runtime_ccall.cpp
index a63a6dd3d6f1d..652dbedc7ebf3 100644
--- a/src/runtime_ccall.cpp
+++ b/src/runtime_ccall.cpp
@@ -355,7 +355,7 @@ jl_value_t *jl_get_cfunction_trampoline(
     uv_mutex_lock(&trampoline_lock);
     tramp = trampoline_alloc();
     ((void**)result)[0] = tramp;
-    tramp = init_trampoline(tramp, nval);
+    init_trampoline(tramp, nval);
     ptrhash_put(cache, (void*)fobj, result);
     uv_mutex_unlock(&trampoline_lock);
     return result;
diff --git a/src/staticdata.c b/src/staticdata.c
index 8c60919e1f7a6..72fac1c3c845e 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -779,7 +779,6 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
             jl_queue_for_serialization(s, mi->def.value);
             jl_queue_for_serialization(s, mi->specTypes);
             jl_queue_for_serialization(s, (jl_value_t*)mi->sparam_vals);
-            recursive = 0;
             goto done_fields;
         }
         else if (jl_is_method(def) && jl_object_in_image(def)) {
@@ -1360,7 +1359,6 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 // write data
                 if (!layout->flags.arrayelem_isboxed && layout->first_ptr < 0) {
                     // set owner to NULL
-                    headersize += sizeof(void*);
                     write_pointer(f);
                     // Non-pointer eltypes get encoded in the const_data section
                     size_t alignment_amt = JL_SMALL_BYTE_ALIGNMENT;
diff --git a/src/support/ios.c b/src/support/ios.c
index c98c529991642..2c20dcb45e4c4 100644
--- a/src/support/ios.c
+++ b/src/support/ios.c
@@ -210,8 +210,10 @@ static char *_buf_realloc(ios_t *s, size_t sz)
         if (temp == NULL)
             return NULL;
         s->ownbuf = 1;
-        if (s->size > 0)
+        if (s->size > 0) {
+            assert(s->buf != NULL);
             memcpy(temp, s->buf, (size_t)s->size);
+        }
     }
 
     s->buf = temp;
@@ -721,8 +723,10 @@ char *ios_take_buffer(ios_t *s, size_t *psize)
         buf = (char*)LLT_ALLOC((size_t)s->size + 1);
         if (buf == NULL)
             return NULL;
-        if (s->size)
+        if (s->size) {
+            assert(s->buf != NULL);
             memcpy(buf, s->buf, (size_t)s->size);
+        }
     }
     else if (s->size == s->maxsize) {
         buf = (char*)LLT_REALLOC(s->buf, (size_t)s->size + 1);
@@ -1219,7 +1223,9 @@ char *ios_readline(ios_t *s)
     ios_mem(&dest, 0);
     ios_copyuntil(&dest, s, '\n', 1);
     size_t n;
-    return ios_take_buffer(&dest, &n);
+    char * ret = ios_take_buffer(&dest, &n);
+    ios_close(&dest);
+    return ret;
 }
 
 extern int vasprintf(char **strp, const char *fmt, va_list ap);
diff --git a/src/threading.c b/src/threading.c
index 319a2918fab3f..e4735594ffaeb 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -693,7 +693,7 @@ void jl_init_threading(void)
     jl_n_threads_per_pool = (int*)malloc_s(2 * sizeof(int));
     jl_n_threads_per_pool[0] = nthreadsi;
     jl_n_threads_per_pool[1] = nthreads;
-
+    assert(jl_all_tls_states_size > 0);
     jl_atomic_store_release(&jl_all_tls_states, (jl_ptls_t*)calloc(jl_all_tls_states_size, sizeof(jl_ptls_t)));
     jl_atomic_store_release(&jl_n_threads, jl_all_tls_states_size);
     jl_n_gcthreads = ngcthreads;

From a8a9ddf1e1405e79c4cef29c03729cfbb311e7ca Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Sat, 4 Nov 2023 13:49:55 -0400
Subject: [PATCH 0189/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=2075960e509=20to=202d59169bf=20(#52026)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5     | 1 +
 .../Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512  | 1 +
 .../Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5     | 1 -
 .../Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512  | 1 -
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512

diff --git a/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5 b/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5
new file mode 100644
index 0000000000000..97f6d9582d52c
--- /dev/null
+++ b/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5
@@ -0,0 +1 @@
+d077b794fabe0879f4bb8b548ad75ead
diff --git a/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512 b/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512
new file mode 100644
index 0000000000000..a59f670469bf0
--- /dev/null
+++ b/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512
@@ -0,0 +1 @@
+70502a1fc7732b690cfd2145079d44761800a6fe3ff090b7f27a7b96680178c6afc47b9f3df00d4f254dbb355203f038d69fb44bceb7c8fab278b47fb8a3cf79
diff --git a/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5 b/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5
deleted file mode 100644
index d218458a1a63d..0000000000000
--- a/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-7205b17150edf9c43262cab72fc551a7
diff --git a/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512 b/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512
deleted file mode 100644
index 09ea6e3bf8ea8..0000000000000
--- a/deps/checksums/Pkg-75960e509763979f6aac7cf31942f70dd85b3b10.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-24c05fae25133170fbbad28c1113b5ebc54a748d985f8a00bd57ee5c6c79954c7f5a84f2c460d2e67f88fe1bd8896f398c7ae3ed416ec36dea2a481cf1a416e5
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 4345d2e869025..23a4475e5ca01 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 75960e509763979f6aac7cf31942f70dd85b3b10
+PKG_SHA1 = 2d59169bffdf29a4ed7bafd8b35c391ede612dde
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 9e7516142d810a645f00e274af60645354ce93ea Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sat, 4 Nov 2023 12:53:11 -0500
Subject: [PATCH 0190/1315] Simplify pivot selection in ScratchQuickSort
 (#51918)

---
 base/sort.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sort.jl b/base/sort.jl
index f411a240e4e9b..a4616a2e65b9e 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -1036,7 +1036,7 @@ function partition!(t::AbstractVector, lo::Integer, hi::Integer, offset::Integer
         v::AbstractVector, rev::Bool, pivot_dest::AbstractVector, pivot_index_offset::Integer)
     # Ideally we would use `pivot_index = rand(lo:hi)`, but that requires Random.jl
     # and would mutate the global RNG in sorting.
-    pivot_index = typeof(hi-lo)(hash(lo) % (hi-lo+1)) + lo
+    pivot_index = mod(hash(lo), lo:hi)
     @inbounds begin
         pivot = v[pivot_index]
         while lo < pivot_index

From bd917bd52f46a7613283323c2e590e385f287bf0 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 5 Nov 2023 06:48:39 +0530
Subject: [PATCH 0191/1315] Fix indexing boolean ranges with empty ranges
 (#40764)

Co-authored-by: jishnub <jishnub@users.noreply.github.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/range.jl  | 32 +++++++++++++++-----------------
 test/ranges.jl | 25 +++++++++++++++++++++++--
 2 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/base/range.jl b/base/range.jl
index d3be5b8931015..e7d57fa3c7e85 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -372,6 +372,7 @@ function steprange_last_empty(start::Integer, step, stop)::typeof(stop)
     end
     return last
 end
+steprange_last_empty(start::Bool, step, stop) = start ⊻ (step > zero(step)) # isnegative(step) ? start : !start
 # For types where x+oneunit(x) may not be well-defined use the user-given value for stop
 steprange_last_empty(start, step, stop) = stop
 
@@ -987,13 +988,14 @@ function getindex(r::AbstractUnitRange, s::StepRange{T}) where {T<:Integer}
     @boundscheck checkbounds(r, s)
 
     if T === Bool
-        return range(first(s) ? first(r) : last(r), step=oneunit(eltype(r)), length=last(s))
+        len = Int(last(s))
+        return range(first(s) ? first(r) : last(r), step=oneunit(eltype(r)), length=len)
     else
         f = first(r)
         start = oftype(f, f + s.start - firstindex(r))
         st = step(s)
         len = length(s)
-        stop = oftype(f, start + (len - oneunit(len)) * st)
+        stop = oftype(f, start + (len - oneunit(len)) * (iszero(len) ? copysign(oneunit(st), st) : st))
         return range(start, stop; step=st)
     end
 end
@@ -1003,26 +1005,22 @@ function getindex(r::StepRange, s::AbstractRange{T}) where {T<:Integer}
     @boundscheck checkbounds(r, s)
 
     if T === Bool
-        if length(s) == 0
-            start, len = first(r), 0
-        elseif length(s) == 1
-            if first(s)
-                start, len = first(r), 1
-            else
-                start, len = first(r), 0
-            end
-        else # length(s) == 2
-            start, len = last(r), 1
-        end
-        return range(start, step=step(r); length=len)
+        # treat as a zero, one, or two-element vector, where at most one element is true
+        # staying inbounds on the original range (preserving either start or
+        # stop as either stop or start, depending on the length)
+        st = step(s)
+        nonempty = st > zero(st) ? last(s) : first(s)
+        # n.b. isempty(r) implies isempty(r) which means !nonempty and !first(s)
+        range((first(s) ⊻ nonempty) ⊻ isempty(r) ? last(r) : first(r), step=step(r), length=Int(nonempty))
     else
         f = r.start
         fs = first(s)
         st = r.step
-        start = oftype(f, f + (fs - oneunit(fs)) * st)
-        st = st * step(s)
+        start = oftype(f, f + (fs - firstindex(r)) * st)
+        st *= step(s)
         len = length(s)
-        stop = oftype(f, start + (len - oneunit(len)) * st)
+        # mimic steprange_last_empty here, to try to avoid overflow
+        stop = oftype(f, start + (len - oneunit(len)) * (iszero(len) ? copysign(oneunit(st), st) : st))
         return range(start, stop; step=st)
     end
 end
diff --git a/test/ranges.jl b/test/ranges.jl
index 2176e0cae7247..e92fdcf2992fa 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -631,11 +631,30 @@ end
     end
 end
 @testset "indexing range with empty range (#4309)" begin
-    @test (3:6)[5:4] === 7:6
+    @test (@inferred (3:6)[5:4]) === 7:6
     @test_throws BoundsError (3:6)[5:5]
     @test_throws BoundsError (3:6)[5]
-    @test (0:2:10)[7:6] === 12:2:10
+    @test (@inferred (0:2:10)[7:6]) === 12:2:11
     @test_throws BoundsError (0:2:10)[7:7]
+
+    for start in [true], stop in [true, false]
+        @test (@inferred (start:stop)[1:0]) === true:false
+    end
+    @test (@inferred (true:false)[true:false]) == true:false
+
+    @testset "issue #40760" begin
+        empty_range = 1:0
+        r = range(false, length = 0)
+        @test r isa UnitRange && first(r) == 0 && last(r) == -1
+        r = (true:true)[empty_range]
+        @test r isa UnitRange && first(r) == true && last(r) == false
+        @testset for r in Any[true:true, true:true:true, 1:2, 1:1:2]
+            @test (@inferred r[1:0]) isa AbstractRange
+            @test r[1:0] == empty_range
+            @test (@inferred r[1:1:0]) isa AbstractRange
+            @test r[1:1:0] == empty_range
+        end
+    end
 end
 # indexing with negative ranges (#8351)
 for a=AbstractRange[3:6, 0:2:10], b=AbstractRange[0:1, 2:-1:0]
@@ -1007,6 +1026,7 @@ end
         end
         a = prevfloat(a)
     end
+    @test (1:2:3)[StepRangeLen{Bool}(true,-1,2)] == [1]
 end
 
 # issue #20380
@@ -2305,6 +2325,7 @@ end
     @test_throws BoundsError r[true:true:false]
     @test_throws BoundsError r[true:true:true]
 end
+
 @testset "Non-Int64 endpoints that are identical (#39798)" begin
     for T in DataType[Float16,Float32,Float64,Bool,Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt128],
         r in [ LinRange(1, 1, 10), StepRangeLen(7, 0, 5) ]

From 816e31aca7dd9ef9684fe8e09fc13fb7fc6ba3ce Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Sat, 4 Nov 2023 22:06:11 -0400
Subject: [PATCH 0192/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Distributed=20stdlib=20from=20fdf56f4=20to=2041c0106=20(#520?=
 =?UTF-8?q?18)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 stdlib/Distributed.version                                      | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/md5
 create mode 100644 deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/sha512
 delete mode 100644 deps/checksums/Distributed-fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5.tar.gz/md5
 delete mode 100644 deps/checksums/Distributed-fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5.tar.gz/sha512

diff --git a/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/md5 b/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/md5
new file mode 100644
index 0000000000000..91dfaf6968e2b
--- /dev/null
+++ b/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/md5
@@ -0,0 +1 @@
+5c6463034c358a254074e86ab81720b1
diff --git a/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/sha512 b/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/sha512
new file mode 100644
index 0000000000000..0ad09e2e6bf50
--- /dev/null
+++ b/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/sha512
@@ -0,0 +1 @@
+bebc472ed89afc8f48eabe0ec0673cf416c5fc3b2f3c51599b388f47e47e6c9905a8a033a3f4b5c38a29be515c43fd70ef44750e7d6f8c6ecd8dc491b3012ac0
diff --git a/deps/checksums/Distributed-fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5.tar.gz/md5 b/deps/checksums/Distributed-fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5.tar.gz/md5
deleted file mode 100644
index 9c68ca7817a54..0000000000000
--- a/deps/checksums/Distributed-fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-f9d2bec2893aab7d37cab00496eea3ac
diff --git a/deps/checksums/Distributed-fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5.tar.gz/sha512 b/deps/checksums/Distributed-fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5.tar.gz/sha512
deleted file mode 100644
index fb068b6893321..0000000000000
--- a/deps/checksums/Distributed-fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-88068d98571f5ec72e952fa01520daabf7a4955f291e373d59735f4cbe048231d23f54fd08c37675421c005c69abf304318f06ba72eb85b1fc64f483e1978731
diff --git a/stdlib/Distributed.version b/stdlib/Distributed.version
index faed0795fbbf9..ca528066e9403 100644
--- a/stdlib/Distributed.version
+++ b/stdlib/Distributed.version
@@ -1,4 +1,4 @@
 DISTRIBUTED_BRANCH = master
-DISTRIBUTED_SHA1 = fdf56f429cd44da6d5d08cb5208bbf41d5b3d0a5
+DISTRIBUTED_SHA1 = 41c01069533e22a6ce6b794746e4b3aa9f5a25cd
 DISTRIBUTED_GIT_URL := https://github.com/JuliaLang/Distributed.jl
 DISTRIBUTED_TAR_URL = https://api.github.com/repos/JuliaLang/Distributed.jl/tarball/$1

From 9c42df6e7474f9e6d33bb97813c921c57e94a499 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sun, 5 Nov 2023 21:56:50 +0900
Subject: [PATCH 0193/1315] carefully cache freshly-inferred edge for call-site
 inlining (#51975)

Currently call-site inlining fails on freshly-inferred edge if its
source isn't inlineable. This happens because such sources are
exclusively cached globally. For successful call-site inlining, it's
necessary to cache these locally also, ensuring the inliner can access
them later.

To this end, the type of the `cache_mode` field of `InferenceState` has
been switched to `UInt8` from `Symbol`. This change allows it to encode
multiple caching strategies. A new caching mode can be introduced, e.g.
`VOLATILE_CACHE_MODE`, in the future.

@nanosoldier `runbenchmarks("inference", vs=":master")`
---
 base/compiler/inferencestate.jl    | 34 +++++++++++++++++++++++-------
 base/compiler/typeinfer.jl         | 18 ++++++++++------
 stdlib/REPL/src/REPLCompletions.jl |  4 ++--
 test/compiler/inline.jl            | 12 +++++++++++
 4 files changed, 51 insertions(+), 17 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 96543308e8bd7..219efec8850de 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -198,6 +198,10 @@ to enable flow-sensitive analysis.
 """
 const VarTable = Vector{VarState}
 
+const CACHE_MODE_NULL   = 0x00
+const CACHE_MODE_GLOBAL = 0x01 << 0
+const CACHE_MODE_LOCAL  = 0x01 << 1
+
 mutable struct InferenceState
     #= information about this method instance =#
     linfo::MethodInstance
@@ -240,7 +244,7 @@ mutable struct InferenceState
     # Whether to restrict inference of abstract call sites to avoid excessive work
     # Set by default for toplevel frame.
     restrict_abstract_call_sites::Bool
-    cache_mode::Symbol # TODO move this to InferenceResult?
+    cache_mode::UInt8 # TODO move this to InferenceResult?
     insert_coverage::Bool
 
     # The interpreter that created this inference state. Not looked at by
@@ -248,7 +252,7 @@ mutable struct InferenceState
     interp::AbstractInterpreter
 
     # src is assumed to be a newly-allocated CodeInfo, that can be modified in-place to contain intermediate results
-    function InferenceState(result::InferenceResult, src::CodeInfo, cache_mode::Symbol,
+    function InferenceState(result::InferenceResult, src::CodeInfo, cache_mode::UInt8,
                             interp::AbstractInterpreter)
         linfo = result.linfo
         world = get_world_counter(interp)
@@ -303,11 +307,10 @@ mutable struct InferenceState
         end
 
         restrict_abstract_call_sites = isa(def, Module)
-        @assert cache_mode === :no || cache_mode === :local || cache_mode === :global
 
         # some more setups
         InferenceParams(interp).unoptimize_throw_blocks && mark_throw_blocks!(src, handler_at)
-        cache_mode === :local && push!(get_inference_cache(interp), result)
+        !iszero(cache_mode & CACHE_MODE_LOCAL) && push!(get_inference_cache(interp), result)
 
         return new(
             linfo, world, mod, sptypes, slottypes, src, cfg, method_info,
@@ -446,13 +449,28 @@ function should_insert_coverage(mod::Module, src::CodeInfo)
     return false
 end
 
-function InferenceState(result::InferenceResult, cache::Symbol, interp::AbstractInterpreter)
+function InferenceState(result::InferenceResult, cache_mode::UInt8, interp::AbstractInterpreter)
     # prepare an InferenceState object for inferring lambda
     world = get_world_counter(interp)
     src = retrieve_code_info(result.linfo, world)
     src === nothing && return nothing
     validate_code_in_debug_mode(result.linfo, src, "lowered")
-    return InferenceState(result, src, cache, interp)
+    return InferenceState(result, src, cache_mode, interp)
+end
+InferenceState(result::InferenceResult, cache_mode::Symbol, interp::AbstractInterpreter) =
+    InferenceState(result, convert_cache_mode(cache_mode), interp)
+InferenceState(result::InferenceResult, src::CodeInfo, cache_mode::Symbol, interp::AbstractInterpreter) =
+    InferenceState(result, src, convert_cache_mode(cache_mode), interp)
+
+function convert_cache_mode(cache_mode::Symbol)
+    if cache_mode === :global
+        return CACHE_MODE_GLOBAL
+    elseif cache_mode === :local
+        return CACHE_MODE_LOCAL
+    elseif cache_mode === :no
+        return CACHE_MODE_NULL
+    end
+    error("unexpected `cache_mode` is given")
 end
 
 """
@@ -666,7 +684,7 @@ end
 function print_callstack(sv::InferenceState)
     while sv !== nothing
         print(sv.linfo)
-        sv.cache_mode === :global || print("  [uncached]")
+        is_cached(sv) || print("  [uncached]")
         println()
         for cycle in sv.callers_in_cycle
             print(' ', cycle.linfo)
@@ -764,7 +782,7 @@ frame_parent(sv::IRInterpretationState) = sv.parent::Union{Nothing,AbsIntState}
 is_constproped(sv::InferenceState) = any(sv.result.overridden_by_const)
 is_constproped(::IRInterpretationState) = true
 
-is_cached(sv::InferenceState) = sv.cache_mode === :global
+is_cached(sv::InferenceState) = !iszero(sv.cache_mode & CACHE_MODE_GLOBAL)
 is_cached(::IRInterpretationState) = false
 
 method_info(sv::InferenceState) = sv.method_info
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index cab02a39c87c1..a9140a965b5c7 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -267,12 +267,12 @@ function _typeinf(interp::AbstractInterpreter, frame::InferenceState)
     end
     for caller in frames
         finish!(caller.interp, caller)
-        if caller.cache_mode === :global
+        if is_cached(caller)
             cache_result!(caller.interp, caller.result)
         end
         # Drop result.src here since otherwise it can waste memory.
-        # N.B. If the `cache_mode === :local`, the inliner may request to use it later.
-        if caller.cache_mode !== :local
+        # N.B. If cached locally, the inliner may request to use it later.
+        if iszero(caller.cache_mode & CACHE_MODE_LOCAL)
             caller.result.src = nothing
         end
     end
@@ -546,7 +546,7 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
         # a parent may be cached still, but not this intermediate work:
         # we can throw everything else away now
         me.result.src = nothing
-        me.cache_mode = :no
+        me.cache_mode = CACHE_MODE_NULL
         set_inlineable!(me.src, false)
         unlock_mi_inference(interp, me.linfo)
     elseif limited_src
@@ -558,7 +558,7 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
         # annotate fulltree with type information,
         # either because we are the outermost code, or we might use this later
         type_annotate!(interp, me)
-        doopt = (me.cache_mode !== :no || me.parent !== nothing)
+        doopt = (me.cache_mode != CACHE_MODE_NULL || me.parent !== nothing)
         # Disable the optimizer if we've already determined that there's nothing for
         # it to do.
         if may_discard_trees(interp) && is_result_constabi_eligible(me.result)
@@ -817,15 +817,19 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
             # we already inferred this edge before and decided to discard the inferred code,
             # nevertheless we re-infer it here again and keep it around in the local cache
             # since the inliner will request to use it later
-            cache_mode = :local
+            cache_mode = CACHE_MODE_LOCAL
         else
             rt = cached_return_type(code)
             effects = ipo_effects(code)
             update_valid_age!(caller, WorldRange(min_world(code), max_world(code)))
             return EdgeCallResult(rt, mi, effects)
         end
+    elseif is_stmt_inline(get_curr_ssaflag(caller))
+        # if this fresh is going to be inlined, we cache it locally too so that the inliner
+        # can see it later even in a case when the inferred source is discarded from the global cache
+        cache_mode = CACHE_MODE_GLOBAL | CACHE_MODE_LOCAL
     else
-        cache_mode = :global # cache edge targets by default
+        cache_mode = CACHE_MODE_GLOBAL # cache edge targets globally by default
     end
     if ccall(:jl_get_module_infer, Cint, (Any,), method.module) == 0 && !generating_output(#=incremental=#false)
         add_remark!(interp, caller, "Inference is disabled for the target module")
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 2c2646636b53a..1da6c11b2a58a 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -519,10 +519,10 @@ CC.bail_out_toplevel_call(::REPLInterpreter, ::CC.InferenceLoopState, ::CC.Infer
 # `REPLInterpreter` is specifically used by `repl_eval_ex`, where all top-level frames are
 # `repl_frame` always. However, this assumption wouldn't stand if `REPLInterpreter` were to
 # be employed, for instance, by `typeinf_ext_toplevel`.
-is_repl_frame(sv::CC.InferenceState) = sv.linfo.def isa Module && sv.cache_mode === :no
+is_repl_frame(sv::CC.InferenceState) = sv.linfo.def isa Module && sv.cache_mode === CC.CACHE_MODE_NULL
 
 function is_call_graph_uncached(sv::CC.InferenceState)
-    sv.cache_mode === :global && return false
+    sv.cache_mode === CC.CACHE_MODE_GLOBAL && return false
     parent = sv.parent
     parent === nothing && return true
     return is_call_graph_uncached(parent::CC.InferenceState)
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 750a52301329a..5aa95e3109913 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -570,6 +570,18 @@ end
     end
 end
 
+@noinline fresh_edge_noinlined(a::Integer) = unresolvable(a)
+let src = code_typed1((Integer,)) do x
+        @inline fresh_edge_noinlined(x)
+    end
+    @test count(iscall((src, fresh_edge_noinlined)), src.code) == 0
+end
+let src = code_typed1((Integer,)) do x
+        @inline fresh_edge_noinlined(x)
+    end
+    @test count(iscall((src, fresh_edge_noinlined)), src.code) == 0 # should be idempotent
+end
+
 # force constant-prop' for `setproperty!`
 # https://github.com/JuliaLang/julia/pull/41882
 let code = @eval Module() begin

From d2dd076f59dda66fb2e0feaca5b4152c050522da Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 6 Nov 2023 10:44:01 +0900
Subject: [PATCH 0194/1315] optimize `cfg_simplify!` (#51958)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

> Before

```julia
julia> @benchmark CC.cfg_simplify!(ir) setup=(ir = CC.copy(Main.ir))
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  196.333 μs …  22.691 ms  ┊ GC (min … max): 0.00% … 98.80%
 Time  (median):     208.792 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   219.824 μs ± 390.126 μs  ┊ GC (mean ± σ):  4.18% ±  2.40%

               ▄█▃
  ▁▁▁▁▁▁▁▁▁▂▂▃▆███▄▄▅▇▇▅▄▄▄▅▄▄▄▄▃▃▃▃▃▂▂▂▂▂▂▂▂▂▁▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁ ▂
  196 μs           Histogram: frequency by time          235 μs <

 Memory estimate: 169.48 KiB, allocs estimate: 4005.
```

> After

```julia
julia> @benchmark CC.cfg_simplify!(ir) setup=(ir = CC.copy(Main.ir))
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  49.541 μs …  31.882 ms  ┊ GC (min … max):  0.00% … 99.66%
 Time  (median):     54.042 μs               ┊ GC (median):     0.00%
 Time  (mean ± σ):   61.492 μs ± 392.747 μs  ┊ GC (mean ± σ):  10.36% ±  1.72%

              ▄█▇▄▁
  ▁▁▁▁▁▂▂▃▄▄▅██████▇▅▅▄▃▃▃▃▄▃▃▃▃▂▂▂▂▂▂▂▂▂▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁ ▂
  49.5 μs         Histogram: frequency by time         67.2 μs <

 Memory estimate: 72.19 KiB, allocs estimate: 808.
```

with

```julia
julia> ir, = only(Base.code_ircode(sin, (Float64,));
```
---
 base/compiler/ssair/passes.jl | 156 ++++++++++++++++------------------
 test/compiler/irpasses.jl     |   2 +
 2 files changed, 76 insertions(+), 82 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index af3d91d8b69f4..1bdd1c642a17a 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1917,29 +1917,65 @@ end
 
 is_terminator(@nospecialize(stmt)) = isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isexpr(stmt, :enter)
 
-function cfg_simplify!(ir::IRCode)
-    bbs = ir.cfg.blocks
-    merge_into = zeros(Int, length(bbs))
-    merged_succ = zeros(Int, length(bbs))
-    dropped_bbs = Vector{Int}() # sorted
-    function follow_merge_into(idx::Int)
-        while merge_into[idx] != 0
-            idx = merge_into[idx]
-        end
-        return idx
+function follow_map(map::Vector{Int}, idx::Int)
+    while map[idx] ≠ 0
+        idx = map[idx]
+    end
+    return idx
+end
+
+function ascend_eliminated_preds(bbs::Vector{BasicBlock}, pred::Int)
+    while pred != 1 && length(bbs[pred].preds) == 1 && length(bbs[pred].succs) == 1
+        pred = bbs[pred].preds[1]
     end
-    function follow_merged_succ(idx::Int)
-        while merged_succ[idx] != 0
-            idx = merged_succ[idx]
+    return pred
+end
+
+# Compute (renamed) successors and predecessors given (renamed) block
+function compute_succs(merged_succ::Vector{Int}, bbs::Vector{BasicBlock}, result_bbs::Vector{Int}, bb_rename_succ::Vector{Int}, i::Int)
+    orig_bb = follow_map(merged_succ, result_bbs[i])
+    return Int[bb_rename_succ[i] for i in bbs[orig_bb].succs]
+end
+
+function compute_preds(bbs::Vector{BasicBlock}, result_bbs::Vector{Int}, bb_rename_pred::Vector{Int}, i::Int)
+    orig_bb = result_bbs[i]
+    preds = copy(bbs[orig_bb].preds)
+    res = Int[]
+    while !isempty(preds)
+        pred = popfirst!(preds)
+        if pred == 0
+            push!(res, 0)
+            continue
+        end
+        r = bb_rename_pred[pred]
+        (r == -2 || r == -1) && continue
+        if r == -3
+            prepend!(preds, bbs[pred].preds)
+        else
+            push!(res, r)
         end
-        return idx
     end
-    function ascend_eliminated_preds(pred)
-        while pred != 1 && length(bbs[pred].preds) == 1 && length(bbs[pred].succs) == 1
-            pred = bbs[pred].preds[1]
+    return res
+end
+
+function add_preds!(all_new_preds::Vector{Int32}, bbs::Vector{BasicBlock}, bb_rename_pred::Vector{Int}, old_edge::Int32)
+    preds = copy(bbs[old_edge].preds)
+    while !isempty(preds)
+        old_edge′ = popfirst!(preds)
+        new_edge = bb_rename_pred[old_edge′]
+        if new_edge > 0 && new_edge ∉ all_new_preds
+            push!(all_new_preds, Int32(new_edge))
+        elseif new_edge == -3
+            prepend!(preds, bbs[old_edge′].preds)
         end
-        return pred
     end
+end
+
+function cfg_simplify!(ir::IRCode)
+    bbs = ir.cfg.blocks
+    merge_into = zeros(Int, length(bbs))
+    merged_succ = zeros(Int, length(bbs))
+    dropped_bbs = Vector{Int}() # sorted
 
     # Walk the CFG from the entry block and aggressively combine blocks
     for (idx, bb) in enumerate(bbs)
@@ -1953,7 +1989,7 @@ function cfg_simplify!(ir::IRCode)
                 end
                 # Prevent cycles by making sure we don't end up back at `idx`
                 # by following what is to be merged into `succ`
-                if follow_merged_succ(succ) != idx
+                if follow_map(merged_succ, succ) != idx
                     merge_into[succ] = idx
                     merged_succ[idx] = succ
                 end
@@ -1961,13 +1997,13 @@ function cfg_simplify!(ir::IRCode)
                 # If this BB is empty, we can still merge it as long as none of our successor's phi nodes
                 # reference our predecessors.
                 found_interference = false
-                preds = Int[ascend_eliminated_preds(pred) for pred in bb.preds]
+                preds = Int[ascend_eliminated_preds(bbs, pred) for pred in bb.preds]
                 for idx in bbs[succ].stmts
                     stmt = ir[SSAValue(idx)][:stmt]
                     stmt === nothing && continue
                     isa(stmt, PhiNode) || break
                     for edge in stmt.edges
-                        edge = ascend_eliminated_preds(edge)
+                        edge = ascend_eliminated_preds(bbs, Int(edge))
                         for pred in preds
                             if pred == edge
                                 found_interference = true
@@ -1986,7 +2022,7 @@ function cfg_simplify!(ir::IRCode)
 
     # Assign new BB numbers in DFS order, dropping unreachable blocks
     max_bb_num = 1
-    bb_rename_succ = fill(0, length(bbs))
+    bb_rename_succ = zeros(Int, length(bbs))
     worklist = BitSetBoundedMinPrioritySet(length(bbs))
     push!(worklist, 1)
     while !isempty(worklist)
@@ -2025,8 +2061,9 @@ function cfg_simplify!(ir::IRCode)
                         push!(worklist, terminator.dest)
                     end
                 elseif isexpr(terminator, :enter)
-                    if bb_rename_succ[terminator.args[1]] == 0
-                        push!(worklist, terminator.args[1])
+                    enteridx = terminator.args[1]::Int
+                    if bb_rename_succ[enteridx] == 0
+                        push!(worklist, enteridx)
                     end
                 end
                 ncurr = curr + 1
@@ -2112,7 +2149,7 @@ function cfg_simplify!(ir::IRCode)
         elseif is_multi
             bb_rename_pred[i] = -3
         else
-            bbnum = follow_merge_into(pred)
+            bbnum = follow_map(merge_into, pred)
             bb_rename_pred[i] = bb_rename_succ[bbnum]
         end
     end
@@ -2134,48 +2171,12 @@ function cfg_simplify!(ir::IRCode)
         bb_starts[i+1] = bb_starts[i] + result_bbs_lengths[i]
     end
 
-    cresult_bbs = let result_bbs = result_bbs,
-                      merged_succ = merged_succ,
-                      merge_into = merge_into,
-                      bbs = bbs,
-                      bb_rename_succ = bb_rename_succ
-
-        # Compute (renamed) successors and predecessors given (renamed) block
-        function compute_succs(i::Int)
-            orig_bb = follow_merged_succ(result_bbs[i])
-            return Int[bb_rename_succ[i] for i in bbs[orig_bb].succs]
-        end
-        function compute_preds(i::Int)
-            orig_bb = result_bbs[i]
-            preds = bbs[orig_bb].preds
-            res = Int[]
-            function scan_preds!(preds::Vector{Int})
-                for pred in preds
-                    if pred == 0
-                        push!(res, 0)
-                        continue
-                    end
-                    r = bb_rename_pred[pred]
-                    (r == -2 || r == -1) && continue
-                    if r == -3
-                        scan_preds!(bbs[pred].preds)
-                    else
-                        push!(res, r)
-                    end
-                end
-            end
-            scan_preds!(preds)
-            return res
-        end
-
-        BasicBlock[
-            BasicBlock(StmtRange(bb_starts[i],
-                                 i+1 > length(bb_starts) ?
-                                    length(compact.result) : bb_starts[i+1]-1),
-                       compute_preds(i),
-                       compute_succs(i))
-            for i = 1:length(result_bbs)]
-    end
+    cresult_bbs = BasicBlock[
+        BasicBlock(StmtRange(bb_starts[i],
+                             i+1 > length(bb_starts) ? length(compact.result) : bb_starts[i+1]-1),
+                   compute_preds(bbs, result_bbs, bb_rename_pred, i),
+                   compute_succs(merged_succ, bbs, result_bbs, bb_rename_succ, i))
+        for i = 1:length(result_bbs)]
 
     # Fixup terminators for any blocks that would have caused double edges
     for (bbidx, (new_bb, old_bb)) in enumerate(zip(cresult_bbs, result_bbs))
@@ -2186,7 +2187,7 @@ function cfg_simplify!(ir::IRCode)
             terminator = ir[SSAValue(last(bbs[old_bb2].stmts))]
             @assert terminator[:stmt] isa GotoIfNot
             # N.B.: The dest will be renamed in process_node! below
-            terminator[:stmt] = GotoNode(terminator[:stmt].dest)
+            terminator[:stmt] = GotoNode(terminator[:stmt].dest::Int)
             pop!(new_bb.succs)
             new_succ = cresult_bbs[new_bb.succs[1]]
             for (i, nsp) in enumerate(new_succ.preds)
@@ -2210,11 +2211,12 @@ function cfg_simplify!(ir::IRCode)
             for i in bbs[ms].stmts
                 node = ir.stmts[i]
                 compact.result[compact.result_idx] = node
-                if isa(node[:stmt], GotoNode) && merged_succ[ms] != 0
+                stmt = node[:stmt]
+                if isa(stmt, GotoNode) && merged_succ[ms] != 0
                     # If we merged a basic block, we need remove the trailing GotoNode (if any)
                     compact.result[compact.result_idx][:stmt] = nothing
-                elseif isa(node[:stmt], PhiNode)
-                    phi = node[:stmt]
+                elseif isa(stmt, PhiNode)
+                    phi = stmt
                     values = phi.values
                     (; ssa_rename, late_fixup, used_ssas, new_new_used_ssas) = compact
                     ssa_rename[i] = SSAValue(compact.result_idx)
@@ -2236,17 +2238,7 @@ function cfg_simplify!(ir::IRCode)
                         elseif new_edge == -3
                             # Multiple predecessors, we need to expand out this phi
                             all_new_preds = Int32[]
-                            function add_preds!(old_edge)
-                                for old_edge′ in bbs[old_edge].preds
-                                    new_edge = bb_rename_pred[old_edge′]
-                                    if new_edge > 0 && !in(new_edge, all_new_preds)
-                                        push!(all_new_preds, new_edge)
-                                    elseif new_edge == -3
-                                        add_preds!(old_edge′)
-                                    end
-                                end
-                            end
-                            add_preds!(old_edge)
+                            add_preds!(all_new_preds, bbs, bb_rename_pred, old_edge)
                             append!(edges, all_new_preds)
                             if isassigned(renamed_values, old_index)
                                 val = renamed_values[old_index]
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index cde6b7809f8b5..f1c845d26d21c 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1568,3 +1568,5 @@ let m = Meta.@lower 1 + 1
 
     Core.Compiler.verify_ir(ir)
 end
+
+# JET.test_opt(Core.Compiler.cfg_simplify!, (Core.Compiler.IRCode,))

From 6d4f40957c6e68ecfd1dc13115beadff493406fd Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sun, 5 Nov 2023 23:53:43 -0600
Subject: [PATCH 0195/1315] Document that `lt` must return a `Bool` (#52031)

A tiny change that does not significantly increase verbosity.

We already do `::Bool` checks in sort.jl
---
 base/ordering.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/ordering.jl b/base/ordering.jl
index 36d8e90064eba..585824bbeadfe 100644
--- a/base/ordering.jl
+++ b/base/ordering.jl
@@ -111,7 +111,7 @@ ReverseOrdering(by::By) = By(by.by, ReverseOrdering(by.order))
 ReverseOrdering(perm::Perm) = Perm(ReverseOrdering(perm.order), perm.data)
 
 """
-    lt(o::Ordering, a, b)
+    lt(o::Ordering, a, b) -> Bool
 
 Test whether `a` is less than `b` according to the ordering `o`.
 """

From d834a4473e6dfdcf072f8b4426c00b0d9faa2d60 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Mon, 6 Nov 2023 07:56:20 -0300
Subject: [PATCH 0196/1315] bugfix: load jl_n_threads in jl_gc_pool_live_bytes
 (#52034)

Otherwise we may just observe `gc_n_threads = 0` (`jl_gc_collect` sets
it to 0 in the very end of its body) and this function becomes a no-op.
---
 src/gc.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 06107f1b2a440..8320b524ba03e 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -3181,9 +3181,11 @@ JL_DLLEXPORT int64_t jl_gc_sync_total_bytes(int64_t offset) JL_NOTSAFEPOINT
 
 JL_DLLEXPORT int64_t jl_gc_pool_live_bytes(void)
 {
+    int n_threads = jl_atomic_load_acquire(&jl_n_threads);
+    jl_ptls_t *all_tls_states = jl_atomic_load_relaxed(&jl_all_tls_states);
     int64_t pool_live_bytes = 0;
-    for (int i = 0; i < gc_n_threads; i++) {
-        jl_ptls_t ptls2 = gc_all_tls_states[i];
+    for (int i = 0; i < n_threads; i++) {
+        jl_ptls_t ptls2 = all_tls_states[i];
         if (ptls2 != NULL) {
             pool_live_bytes += jl_atomic_load_relaxed(&ptls2->gc_num.pool_live_bytes);
         }

From b723f41863cc84b21b3caa02c55dabdf41858908 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Mon, 6 Nov 2023 09:38:31 -0500
Subject: [PATCH 0197/1315] interpreter: Fix stacktrace for global incorrectly
 assumed to be in phi block (#51990)

We don't fully set up the interpreter state when evaluating the phi
block, because we expect all statements to be valid in value-position
(using the IR definition of value position). However, the interpreter
was overapproximating the size of the phi-block, leading to the
possibility that the evaluation may throw. Correct that by truncating
the phi block to the actual last phi. Will be tested in existing tests
after #51970.
---
 src/interpreter.c   |  8 ++++++++
 test/stacktraces.jl | 16 ++++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/src/interpreter.c b/src/interpreter.c
index 573b4f81f8ff4..00ea5a50934a6 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -351,6 +351,7 @@ static size_t eval_phi(jl_array_t *stmts, interpreter_state *s, size_t ns, size_
     size_t from = s->ip;
     size_t ip = to;
     unsigned nphiblockstmts = 0;
+    unsigned last_phi = 0;
     for (ip = to; ip < ns; ip++) {
         jl_value_t *e = jl_array_ptr_ref(stmts, ip);
         if (!jl_is_phinode(e)) {
@@ -361,9 +362,16 @@ static size_t eval_phi(jl_array_t *stmts, interpreter_state *s, size_t ns, size_
             }
             // Everything else is allowed in the phi-block for implementation
             // convenience - fall through.
+        } else {
+            last_phi = nphiblockstmts + 1;
         }
         nphiblockstmts += 1;
     }
+    // Cut off the phi block at the last phi node. For global refs that are not
+    // actually in the phi block, we want to evaluate them in the regular interpreter
+    // loop instead to make sure exception state is set up properly in case they throw.
+    nphiblockstmts = last_phi;
+    ip = to + last_phi;
     if (nphiblockstmts) {
         jl_value_t **dest = &s->locals[jl_source_nslots(s->src) + to];
         jl_value_t **phis; // = (jl_value_t**)alloca(sizeof(jl_value_t*) * nphiblockstmts);
diff --git a/test/stacktraces.jl b/test/stacktraces.jl
index 5b17a0ced4058..be035e31833d3 100644
--- a/test/stacktraces.jl
+++ b/test/stacktraces.jl
@@ -166,6 +166,22 @@ end
 @test bt[1].line == topline+4
 end
 
+# Accidental incorrect phi block computation in interpreter
+global global_false_bool = false
+let bt, topline = @__LINE__
+    try
+        let
+            global read_write_global_bt_test, global_false_bool
+            if global_false_bool
+            end
+            (read_write_global_bt_test, (read_write_global_bt_test=2;))
+        end
+    catch
+        bt = stacktrace(catch_backtrace())
+    end
+    @test bt[1].line == topline+6
+end
+
 # issue #28990
 let bt
 try

From fae6b7859b493160a290e79cf00ca1549bc9b6c7 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 7 Nov 2023 00:34:11 +0900
Subject: [PATCH 0198/1315] inlining: avoid source deserialization by using
 volatile inference result (#51934)

Currently the inlining algorithm is allowed to use inferred source of
const-prop'ed call that is always locally available (since const-prop'
result isn't cached globally). For non const-prop'ed and globally cached
calls, however, it undergoes a more expensive process, making a
round-trip through serialized inferred source.

We can improve efficiency by bypassing the serialization round-trip for
newly-inferred and globally-cached frames. As these frames are never
cached locally, they can be viewed as volatile. This means we can use
their source destructively while inline-expanding them.

The benchmark results show that this optimization achieves 2-4%
allocation reduction and about 5% speed up in the real-world-ish
compilation targets (`allinference`).

Note that it would be more efficient to propagate `IRCode` object
directly and skip inflation from `CodeInfo` to `IRCode` as experimented
in #47137, but currently the round-trip through
`CodeInfo`-representation is necessary because it often leads to better
CFG simplification while `cfg_simplify!` being expensive (xref: #51960).
---
 base/compiler/abstractinterpretation.jl |  26 +++---
 base/compiler/inferencestate.jl         |   9 ++-
 base/compiler/optimize.jl               |  16 +---
 base/compiler/ssair/inlining.jl         | 102 ++++++++++++++----------
 base/compiler/stmtinfo.jl               |   8 ++
 base/compiler/typeinfer.jl              |  31 ++++---
 base/compiler/types.jl                  |  21 +++--
 test/compiler/inline.jl                 |  17 ++++
 8 files changed, 139 insertions(+), 91 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index e387352cf8018..21ff1c951bf85 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -59,12 +59,12 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             splitsigs = switchtupleunion(sig)
             for sig_n in splitsigs
                 result = abstract_call_method(interp, method, sig_n, svec(), multiple_matches, si, sv)
-                (; rt, edge, effects) = result
+                (; rt, edge, effects, volatile_inf_result) = result
                 this_argtypes = isa(matches, MethodMatches) ? argtypes : matches.applicable_argtypes[i]
                 this_arginfo = ArgInfo(fargs, this_argtypes)
                 const_call_result = abstract_call_method_with_const_args(interp,
                     result, f, this_arginfo, si, match, sv)
-                const_result = nothing
+                const_result = volatile_inf_result
                 if const_call_result !== nothing
                     if const_call_result.rt ⊑ₚ rt
                         rt = const_call_result.rt
@@ -90,7 +90,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             this_rt = widenwrappedconditional(this_rt)
         else
             result = abstract_call_method(interp, method, sig, match.sparams, multiple_matches, si, sv)
-            (; rt, edge, effects) = result
+            (; rt, edge, effects, volatile_inf_result) = result
             this_conditional = ignorelimited(rt)
             this_rt = widenwrappedconditional(rt)
             # try constant propagation with argtypes for this match
@@ -99,7 +99,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             this_arginfo = ArgInfo(fargs, this_argtypes)
             const_call_result = abstract_call_method_with_const_args(interp,
                 result, f, this_arginfo, si, match, sv)
-            const_result = nothing
+            const_result = volatile_inf_result
             if const_call_result !== nothing
                 this_const_conditional = ignorelimited(const_call_result.rt)
                 this_const_rt = widenwrappedconditional(const_call_result.rt)
@@ -621,7 +621,7 @@ function abstract_call_method(interp::AbstractInterpreter,
         sparams = recomputed[2]::SimpleVector
     end
 
-    (; rt, edge, effects) = typeinf_edge(interp, method, sig, sparams, sv)
+    (; rt, edge, effects, volatile_inf_result) = typeinf_edge(interp, method, sig, sparams, sv)
 
     if edge === nothing
         edgecycle = edgelimited = true
@@ -645,7 +645,7 @@ function abstract_call_method(interp::AbstractInterpreter,
         end
     end
 
-    return MethodCallResult(rt, edgecycle, edgelimited, edge, effects)
+    return MethodCallResult(rt, edgecycle, edgelimited, edge, effects, volatile_inf_result)
 end
 
 function edge_matches_sv(interp::AbstractInterpreter, frame::AbsIntState,
@@ -748,12 +748,14 @@ struct MethodCallResult
     edgelimited::Bool
     edge::Union{Nothing,MethodInstance}
     effects::Effects
+    volatile_inf_result::Union{Nothing,VolatileInferenceResult}
     function MethodCallResult(@nospecialize(rt),
                               edgecycle::Bool,
                               edgelimited::Bool,
                               edge::Union{Nothing,MethodInstance},
-                              effects::Effects)
-        return new(rt, edgecycle, edgelimited, edge, effects)
+                              effects::Effects,
+                              volatile_inf_result::Union{Nothing,VolatileInferenceResult}=nothing)
+        return new(rt, edgecycle, edgelimited, edge, effects, volatile_inf_result)
     end
 end
 
@@ -1945,7 +1947,7 @@ function abstract_invoke(interp::AbstractInterpreter, (; fargs, argtypes)::ArgIn
     tienv = ccall(:jl_type_intersection_with_env, Any, (Any, Any), nargtype, method.sig)::SimpleVector
     ti = tienv[1]; env = tienv[2]::SimpleVector
     result = abstract_call_method(interp, method, ti, env, false, si, sv)
-    (; rt, edge, effects) = result
+    (; rt, edge, effects, volatile_inf_result) = result
     match = MethodMatch(ti, env, method, argtype <: method.sig)
     res = nothing
     sig = match.spec_types
@@ -1962,7 +1964,7 @@ function abstract_invoke(interp::AbstractInterpreter, (; fargs, argtypes)::ArgIn
     invokecall = InvokeCall(types, lookupsig)
     const_call_result = abstract_call_method_with_const_args(interp,
         result, f, arginfo, si, match, sv, invokecall)
-    const_result = nothing
+    const_result = volatile_inf_result
     if const_call_result !== nothing
         if ⊑(𝕃ₚ, const_call_result.rt, rt)
             (; rt, effects, const_result, edge) = const_call_result
@@ -2091,13 +2093,13 @@ function abstract_call_opaque_closure(interp::AbstractInterpreter,
     closure::PartialOpaque, arginfo::ArgInfo, si::StmtInfo, sv::AbsIntState, check::Bool=true)
     sig = argtypes_to_type(arginfo.argtypes)
     result = abstract_call_method(interp, closure.source::Method, sig, Core.svec(), false, si, sv)
-    (; rt, edge, effects) = result
+    (; rt, edge, effects, volatile_inf_result) = result
     tt = closure.typ
     sigT = (unwrap_unionall(tt)::DataType).parameters[1]
     match = MethodMatch(sig, Core.svec(), closure.source, sig <: rewrap_unionall(sigT, tt))
     𝕃ₚ = ipo_lattice(interp)
     ⊑ₚ = ⊑(𝕃ₚ)
-    const_result = nothing
+    const_result = volatile_inf_result
     if !result.edgecycle
         const_call_result = abstract_call_method_with_const_args(interp, result,
             nothing, arginfo, si, match, sv)
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 219efec8850de..4024273944200 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -198,9 +198,10 @@ to enable flow-sensitive analysis.
 """
 const VarTable = Vector{VarState}
 
-const CACHE_MODE_NULL   = 0x00
-const CACHE_MODE_GLOBAL = 0x01 << 0
-const CACHE_MODE_LOCAL  = 0x01 << 1
+const CACHE_MODE_NULL     = 0x00      # not cached, without optimization
+const CACHE_MODE_GLOBAL   = 0x01 << 0 # cached globally, optimization allowed
+const CACHE_MODE_LOCAL    = 0x01 << 1 # cached locally, optimization allowed
+const CACHE_MODE_VOLATILE = 0x01 << 2 # not cached, optimization allowed
 
 mutable struct InferenceState
     #= information about this method instance =#
@@ -467,6 +468,8 @@ function convert_cache_mode(cache_mode::Symbol)
         return CACHE_MODE_GLOBAL
     elseif cache_mode === :local
         return CACHE_MODE_LOCAL
+    elseif cache_mode === :volatile
+        return CACHE_MODE_VOLATILE
     elseif cache_mode === :no
         return CACHE_MODE_NULL
     end
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 9dff1281e83c5..cbeb447e0c9aa 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -75,25 +75,11 @@ is_source_inferred(@nospecialize src::MaybeCompressed) =
 
 function inlining_policy(interp::AbstractInterpreter,
     @nospecialize(src), @nospecialize(info::CallInfo), stmt_flag::UInt32, mi::MethodInstance,
-    argtypes::Vector{Any})
+    _::Vector{Any})
     if isa(src, MaybeCompressed)
         is_source_inferred(src) || return nothing
         src_inlineable = is_stmt_inline(stmt_flag) || is_inlineable(src)
         return src_inlineable ? src : nothing
-    elseif src === nothing && is_stmt_inline(stmt_flag)
-        # if this statement is forced to be inlined, make an additional effort to find the
-        # inferred source in the local cache
-        # we still won't find a source for recursive call because the "single-level" inlining
-        # seems to be more trouble and complex than it's worth
-        inf_result = cache_lookup(optimizer_lattice(interp), mi, argtypes, get_inference_cache(interp))
-        inf_result === nothing && return nothing
-        src = inf_result.src
-        if isa(src, CodeInfo)
-            src_inferred = is_source_inferred(src)
-            return src_inferred ? src : nothing
-        else
-            return nothing
-        end
     elseif isa(src, IRCode)
         return src
     elseif isa(src, SemiConcreteResult)
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index bb2c092c0a762..db50c5142f46f 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -842,10 +842,10 @@ function compileable_specialization(match::MethodMatch, effects::Effects,
     return compileable_specialization(mi, effects, et, info; compilesig_invokes)
 end
 
-struct CachedResult
+struct InferredResult
     src::Any
     effects::Effects
-    CachedResult(@nospecialize(src), effects::Effects) = new(src, effects)
+    InferredResult(@nospecialize(src), effects::Effects) = new(src, effects)
 end
 @inline function get_cached_result(state::InliningState, mi::MethodInstance)
     code = get(code_cache(state), mi, nothing)
@@ -853,40 +853,46 @@ end
         if use_const_api(code)
             # in this case function can be inlined to a constant
             return ConstantCase(quoted(code.rettype_const))
-        else
-            src = @atomic :monotonic code.inferred
         end
+        src = @atomic :monotonic code.inferred
         effects = decode_effects(code.ipo_purity_bits)
-        return CachedResult(src, effects)
+        return InferredResult(src, effects)
     end
-    return CachedResult(nothing, Effects())
+    return InferredResult(nothing, Effects())
+end
+@inline function get_local_result(inf_result::InferenceResult)
+    effects = inf_result.ipo_effects
+    if is_foldable_nothrow(effects)
+        res = inf_result.result
+        if isa(res, Const) && is_inlineable_constant(res.val)
+            # use constant calling convention
+            return ConstantCase(quoted(res.val))
+        end
+    end
+    return InferredResult(inf_result.src, effects)
 end
 
 # the general resolver for usual and const-prop'ed calls
-function resolve_todo(mi::MethodInstance, result::Union{MethodMatch,InferenceResult},
-        argtypes::Vector{Any}, @nospecialize(info::CallInfo), flag::UInt32,
-        state::InliningState; invokesig::Union{Nothing,Vector{Any}}=nothing)
+function resolve_todo(mi::MethodInstance, result::Union{Nothing,InferenceResult,VolatileInferenceResult},
+    argtypes::Vector{Any}, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
+    invokesig::Union{Nothing,Vector{Any}}=nothing)
     et = InliningEdgeTracker(state, invokesig)
 
+    preserve_local_sources = true
     if isa(result, InferenceResult)
-        src = result.src
-        effects = result.ipo_effects
-        if is_foldable_nothrow(effects)
-            res = result.result
-            if isa(res, Const) && is_inlineable_constant(res.val)
-                # use constant calling convention
-                add_inlining_backedge!(et, mi)
-                return ConstantCase(quoted(res.val))
-            end
-        end
+        inferred_result = get_local_result(result)
+    elseif isa(result, VolatileInferenceResult)
+        inferred_result = get_local_result(result.inf_result)
+        # volatile inference result can be inlined destructively
+        preserve_local_sources = OptimizationParams(state.interp).preserve_local_sources
     else
-        cached_result = get_cached_result(state, mi)
-        if cached_result isa ConstantCase
-            add_inlining_backedge!(et, mi)
-            return cached_result
-        end
-        (; src, effects) = cached_result
+        inferred_result = get_cached_result(state, mi)
+    end
+    if inferred_result isa ConstantCase
+        add_inlining_backedge!(et, mi)
+        return inferred_result
     end
+    (; src, effects) = inferred_result
 
     # the duplicated check might have been done already within `analyze_method!`, but still
     # we need it here too since we may come here directly using a constant-prop' result
@@ -900,7 +906,8 @@ function resolve_todo(mi::MethodInstance, result::Union{MethodMatch,InferenceRes
         compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
 
     add_inlining_backedge!(et, mi)
-    return InliningTodo(mi, retrieve_ir_for_inlining(mi, src), effects)
+    ir = retrieve_ir_for_inlining(mi, src, preserve_local_sources)
+    return InliningTodo(mi, ir, effects)
 end
 
 # the special resolver for :invoke-d call
@@ -944,7 +951,8 @@ end
 
 function analyze_method!(match::MethodMatch, argtypes::Vector{Any},
     @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
-    allow_typevars::Bool, invokesig::Union{Nothing,Vector{Any}}=nothing)
+    allow_typevars::Bool, invokesig::Union{Nothing,Vector{Any}}=nothing,
+    volatile_inf_result::Union{Nothing,VolatileInferenceResult}=nothing)
     method = match.method
     spec_types = match.spec_types
 
@@ -973,15 +981,25 @@ function analyze_method!(match::MethodMatch, argtypes::Vector{Any},
     # Get the specialization for this method signature
     # (later we will decide what to do with it)
     mi = specialize_method(match)
-    return resolve_todo(mi, match, argtypes, info, flag, state; invokesig)
+    return resolve_todo(mi, volatile_inf_result, argtypes, info, flag, state; invokesig)
 end
 
-function retrieve_ir_for_inlining(mi::MethodInstance, src::String)
+function retrieve_ir_for_inlining(mi::MethodInstance, src::String, ::Bool=true)
     src = _uncompressed_ir(mi.def, src)
     return inflate_ir!(src, mi)
 end
-retrieve_ir_for_inlining(mi::MethodInstance, src::CodeInfo) = inflate_ir(src, mi)
-retrieve_ir_for_inlining(mi::MethodInstance, ir::IRCode) = copy(ir)
+function retrieve_ir_for_inlining(mi::MethodInstance, src::CodeInfo, preserve_local_sources::Bool=true)
+    if preserve_local_sources
+        src = copy(src)
+    end
+    return inflate_ir!(src, mi)
+end
+function retrieve_ir_for_inlining(::MethodInstance, ir::IRCode, preserve_local_sources::Bool=true)
+    if preserve_local_sources
+        ir = copy(ir)
+    end
+    return ir
+end
 
 function flags_for_effects(effects::Effects)
     flags::UInt32 = 0
@@ -1203,7 +1221,8 @@ function handle_invoke_call!(todo::Vector{Pair{Int,Any}},
                     return nothing
                 end
             end
-            item = analyze_method!(match, argtypes, info, flag, state; allow_typevars=false, invokesig)
+            volatile_inf_result = result isa VolatileInferenceResult ? result : nothing
+            item = analyze_method!(match, argtypes, info, flag, state; allow_typevars=false, invokesig, volatile_inf_result)
         end
     end
     handle_single_case!(todo, ir, idx, stmt, item, true)
@@ -1343,8 +1362,8 @@ function handle_any_const_result!(cases::Vector{InliningCase},
     if isa(result, ConstPropResult)
         return handle_const_prop_result!(cases, result, argtypes, info, flag, state; allow_abstract, allow_typevars)
     else
-        @assert result === nothing
-        return handle_match!(cases, match, argtypes, info, flag, state; allow_abstract, allow_typevars)
+        @assert result === nothing || result isa VolatileInferenceResult
+        return handle_match!(cases, match, argtypes, info, flag, state; allow_abstract, allow_typevars, volatile_inf_result = result)
     end
 end
 
@@ -1475,14 +1494,14 @@ end
 function handle_match!(cases::Vector{InliningCase},
     match::MethodMatch, argtypes::Vector{Any}, @nospecialize(info::CallInfo), flag::UInt32,
     state::InliningState;
-    allow_abstract::Bool, allow_typevars::Bool)
+    allow_abstract::Bool, allow_typevars::Bool, volatile_inf_result::Union{Nothing,VolatileInferenceResult})
     spec_types = match.spec_types
     allow_abstract || isdispatchtuple(spec_types) || return false
     # We may see duplicated dispatch signatures here when a signature gets widened
     # during abstract interpretation: for the purpose of inlining, we can just skip
     # processing this dispatch candidate (unless unmatched type parameters are present)
     !allow_typevars && any(case::InliningCase->case.sig === spec_types, cases) && return true
-    item = analyze_method!(match, argtypes, info, flag, state; allow_typevars)
+    item = analyze_method!(match, argtypes, info, flag, state; allow_typevars, volatile_inf_result)
     item === nothing && return false
     push!(cases, InliningCase(spec_types, item))
     return true
@@ -1512,7 +1531,9 @@ function semiconcrete_result_item(result::SemiConcreteResult,
         return compileable_specialization(mi, result.effects, et, info;
             compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
     else
-        return InliningTodo(mi, retrieve_ir_for_inlining(mi, result.ir), result.effects)
+        preserve_local_sources = OptimizationParams(state.interp).preserve_local_sources
+        ir = retrieve_ir_for_inlining(mi, result.ir, preserve_local_sources)
+        return InliningTodo(mi, ir, result.effects)
     end
 end
 
@@ -1587,7 +1608,9 @@ function handle_opaque_closure_call!(todo::Vector{Pair{Int,Any}},
         if isa(result, SemiConcreteResult)
             item = semiconcrete_result_item(result, info, flag, state)
         else
-            item = analyze_method!(info.match, sig.argtypes, info, flag, state; allow_typevars=false)
+            @assert result === nothing || result isa VolatileInferenceResult
+            volatile_inf_result = result
+            item = analyze_method!(info.match, sig.argtypes, info, flag, state; allow_typevars=false, volatile_inf_result)
         end
     end
     handle_single_case!(todo, ir, idx, stmt, item)
@@ -1612,8 +1635,7 @@ function handle_modifyfield!_call!(ir::IRCode, idx::Int, stmt::Expr, info::Modif
 end
 
 function handle_finalizer_call!(ir::IRCode, idx::Int, stmt::Expr, info::FinalizerInfo,
-    state::InliningState)
-
+                                state::InliningState)
     # Finalizers don't return values, so if their execution is not observable,
     # we can just not register them
     if is_removable_if_unused(info.effects)
diff --git a/base/compiler/stmtinfo.jl b/base/compiler/stmtinfo.jl
index 9f55d56181838..d634c88cdf8e8 100644
--- a/base/compiler/stmtinfo.jl
+++ b/base/compiler/stmtinfo.jl
@@ -76,6 +76,14 @@ struct SemiConcreteResult <: ConstResult
     effects::Effects
 end
 
+# XXX Technically this does not represent a result of constant inference, but rather that of
+#     regular edge inference. It might be more appropriate to rename `ConstResult` and
+#     `ConstCallInfo` to better reflect the fact that they represent either of local or
+#     volatile inference result.
+struct VolatileInferenceResult <: ConstResult
+    inf_result::InferenceResult
+end
+
 """
     info::ConstCallInfo <: CallInfo
 
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index a9140a965b5c7..0c678651693b9 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -270,11 +270,6 @@ function _typeinf(interp::AbstractInterpreter, frame::InferenceState)
         if is_cached(caller)
             cache_result!(caller.interp, caller.result)
         end
-        # Drop result.src here since otherwise it can waste memory.
-        # N.B. If cached locally, the inliner may request to use it later.
-        if iszero(caller.cache_mode & CACHE_MODE_LOCAL)
-            caller.result.src = nothing
-        end
     end
     empty!(frames)
     return true
@@ -800,10 +795,12 @@ struct EdgeCallResult
     rt #::Type
     edge::Union{Nothing,MethodInstance}
     effects::Effects
+    volatile_inf_result::Union{Nothing,VolatileInferenceResult}
     function EdgeCallResult(@nospecialize(rt),
                             edge::Union{Nothing,MethodInstance},
-                            effects::Effects)
-        return new(rt, edge, effects)
+                            effects::Effects,
+                            volatile_inf_result::Union{Nothing,VolatileInferenceResult} = nothing)
+        return new(rt, edge, effects, volatile_inf_result)
     end
 end
 
@@ -811,23 +808,20 @@ end
 function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize(atype), sparams::SimpleVector, caller::AbsIntState)
     mi = specialize_method(method, atype, sparams)::MethodInstance
     code = get(code_cache(interp), mi, nothing)
+    force_inline = is_stmt_inline(get_curr_ssaflag(caller))
     if code isa CodeInstance # return existing rettype if the code is already inferred
         inferred = @atomic :monotonic code.inferred
-        if inferred === nothing && is_stmt_inline(get_curr_ssaflag(caller))
+        if inferred === nothing && force_inline
             # we already inferred this edge before and decided to discard the inferred code,
-            # nevertheless we re-infer it here again and keep it around in the local cache
-            # since the inliner will request to use it later
-            cache_mode = CACHE_MODE_LOCAL
+            # nevertheless we re-infer it here again in order to propagate the re-inferred
+            # source to the inliner as a volatile result
+            cache_mode = CACHE_MODE_VOLATILE
         else
             rt = cached_return_type(code)
             effects = ipo_effects(code)
             update_valid_age!(caller, WorldRange(min_world(code), max_world(code)))
             return EdgeCallResult(rt, mi, effects)
         end
-    elseif is_stmt_inline(get_curr_ssaflag(caller))
-        # if this fresh is going to be inlined, we cache it locally too so that the inliner
-        # can see it later even in a case when the inferred source is discarded from the global cache
-        cache_mode = CACHE_MODE_GLOBAL | CACHE_MODE_LOCAL
     else
         cache_mode = CACHE_MODE_GLOBAL # cache edge targets globally by default
     end
@@ -861,7 +855,12 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         isinferred = is_inferred(frame)
         edge = isinferred ? mi : nothing
         effects = isinferred ? frame.ipo_effects : adjust_effects(Effects(), method) # effects are adjusted already within `finish` for ipo_effects
-        return EdgeCallResult(frame.bestguess, edge, effects)
+        # propagate newly inferred source to the inliner, allowing efficient inlining w/o deserialization:
+        # note that this result is cached globally exclusively, we can use this local result destructively
+        volatile_inf_result = isinferred && let inferred_src = result.src
+                isa(inferred_src, CodeInfo) && (is_inlineable(inferred_src) || force_inline)
+            end ? VolatileInferenceResult(result) : nothing
+        return EdgeCallResult(frame.bestguess, edge, effects, volatile_inf_result)
     elseif frame === true
         # unresolvable cycle
         return EdgeCallResult(Any, nothing, Effects())
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index c53256c61ace9..ba05131d4e3a3 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -253,6 +253,11 @@ Parameters that control optimizer operation.
   optimizer license to move side effects (that are proven not observed within a particular
   code path) across a throwing call. Defaults to `false`.
 ---
+- `opt_params.preserve_local_sources::Bool = false`\\
+  If `true`, the inliner is restricted from modifying locally-cached sources that are
+  retained in `CallInfo` objects and always makes their copies before inlining them into
+  caller context. Defaults to `false`.
+---
 """
 struct OptimizationParams
     inlining::Bool
@@ -263,6 +268,7 @@ struct OptimizationParams
     max_tuple_splat::Int
     compilesig_invokes::Bool
     assume_fatal_throw::Bool
+    preserve_local_sources::Bool
 
     function OptimizationParams(
         inlining::Bool,
@@ -272,7 +278,8 @@ struct OptimizationParams
         inline_error_path_cost::Int,
         max_tuple_splat::Int,
         compilesig_invokes::Bool,
-        assume_fatal_throw::Bool)
+        assume_fatal_throw::Bool,
+        preserve_local_sources::Bool)
         return new(
             inlining,
             inline_cost_threshold,
@@ -281,7 +288,8 @@ struct OptimizationParams
             inline_error_path_cost,
             max_tuple_splat,
             compilesig_invokes,
-            assume_fatal_throw)
+            assume_fatal_throw,
+            preserve_local_sources)
     end
 end
 function OptimizationParams(
@@ -293,7 +301,8 @@ function OptimizationParams(
         #=inline_error_path_cost::Int=# 20,
         #=max_tuple_splat::Int=# 32,
         #=compilesig_invokes::Bool=# true,
-        #=assume_fatal_throw::Bool=# false);
+        #=assume_fatal_throw::Bool=# false,
+        #=preserve_local_sources::Bool=# false);
     inlining::Bool = params.inlining,
     inline_cost_threshold::Int = params.inline_cost_threshold,
     inline_nonleaf_penalty::Int = params.inline_nonleaf_penalty,
@@ -301,7 +310,8 @@ function OptimizationParams(
     inline_error_path_cost::Int = params.inline_error_path_cost,
     max_tuple_splat::Int = params.max_tuple_splat,
     compilesig_invokes::Bool = params.compilesig_invokes,
-    assume_fatal_throw::Bool = params.assume_fatal_throw)
+    assume_fatal_throw::Bool = params.assume_fatal_throw,
+    preserve_local_sources::Bool = params.preserve_local_sources)
     return OptimizationParams(
         inlining,
         inline_cost_threshold,
@@ -310,7 +320,8 @@ function OptimizationParams(
         inline_error_path_cost,
         max_tuple_splat,
         compilesig_invokes,
-        assume_fatal_throw)
+        assume_fatal_throw,
+        preserve_local_sources)
 end
 
 """
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 5aa95e3109913..f3c29e4c2e970 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -507,6 +507,17 @@ end
         Base.@constprop :aggressive noinlined_constprop_implicit(a) = a+g
         force_inline_constprop_implicit() = @inline noinlined_constprop_implicit(0)
 
+        function force_inline_constprop_cached1()
+            r1 =         noinlined_constprop_implicit(0)
+            r2 = @inline noinlined_constprop_implicit(0)
+            return (r1, r2)
+        end
+        function force_inline_constprop_cached2()
+            r1 = @inline noinlined_constprop_implicit(0)
+            r2 =         noinlined_constprop_implicit(0)
+            return (r1, r2)
+        end
+
         @inline Base.@constprop :aggressive inlined_constprop_explicit(a) = a+g
         force_noinline_constprop_explicit() = @noinline inlined_constprop_explicit(0)
         @inline Base.@constprop :aggressive inlined_constprop_implicit(a) = a+g
@@ -557,6 +568,12 @@ end
     let code = get_code(M.force_inline_constprop_implicit)
         @test all(!isinvoke(:noinlined_constprop_implicit), code)
     end
+    let code = get_code(M.force_inline_constprop_cached1)
+        @test count(isinvoke(:noinlined_constprop_implicit), code) == 1
+    end
+    let code = get_code(M.force_inline_constprop_cached2)
+        @test count(isinvoke(:noinlined_constprop_implicit), code) == 1
+    end
 
     let code = get_code(M.force_noinline_constprop_explicit)
         @test any(isinvoke(:inlined_constprop_explicit), code)

From b1f954c52efac19e78d264227a8bfe6c776712df Mon Sep 17 00:00:00 2001
From: Yuto Horikawa <hyrodium@gmail.com>
Date: Tue, 7 Nov 2023 06:08:13 +0900
Subject: [PATCH 0199/1315] update `//` docstring (#52050)

The `//` operator supports non-real numbers, so updating the docstring
would be helpful.
---
 base/rational.jl | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/base/rational.jl b/base/rational.jl
index 4671478f0b0d3..5185f79a2f4f9 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -47,6 +47,12 @@ end
     //(num, den)
 
 Divide two integers or rational numbers, giving a [`Rational`](@ref) result.
+More generally, `//` can be used for exact rational division of other numeric types
+with integer or rational components, such as complex numbers with integer components.
+
+Note that floating-point ([`AbstractFloat`](@ref)) arguments are not permitted by `//`
+(even if the values are rational).
+The arguments must be subtypes of [`Integer`](@ref), `Rational`, or composites thereof.
 
 # Examples
 ```jldoctest
@@ -55,6 +61,13 @@ julia> 3 // 5
 
 julia> (3 // 5) // (2 // 1)
 3//10
+
+julia> (1+2im) // (3+4im)
+11//25 + 2//25*im
+
+julia> 1.0 // 2
+ERROR: MethodError: no method matching //(::Float64, ::Int64)
+[...]
 ```
 """
 //(n::Integer,  d::Integer) = Rational(n,d)

From a3812e7e2637c55b6659745d6843cded196076fa Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Mon, 6 Nov 2023 18:44:54 -0300
Subject: [PATCH 0200/1315] codegen: add attributes to box functions and more
 attrs to alloc ones (#51218)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 src/cgutils.cpp                             |   7 +-
 src/codegen.cpp                             | 104 ++++++++++++++++----
 src/llvm-final-gc-lowering.cpp              |  16 +--
 src/llvm-late-gc-lowering.cpp               |   3 +-
 src/llvm-pass-helpers.cpp                   |  10 +-
 test/llvmpasses/alloc-opt-gcframe.ll        |   4 +-
 test/llvmpasses/final-lower-gc.ll           |   8 +-
 test/llvmpasses/late-lower-gc-addrspaces.ll |   8 +-
 test/llvmpasses/late-lower-gc.ll            |   8 +-
 test/llvmpasses/names.jl                    |  14 ++-
 10 files changed, 133 insertions(+), 49 deletions(-)

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index f158c182744e2..431c7450f2f2c 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -3480,7 +3480,8 @@ static void emit_cpointercheck(jl_codectx_t &ctx, const jl_cgval_t &x, const Twi
 
 // allocation for known size object
 // returns a prjlvalue
-static Value *emit_allocobj(jl_codectx_t &ctx, size_t static_size, Value *jt)
+static Value *emit_allocobj(jl_codectx_t &ctx, size_t static_size, Value *jt,
+                             unsigned align=sizeof(void*)) // Allocations are at least pointer alingned
 {
     ++EmittedAllocObjs;
     Value *current_task = get_current_task(ctx);
@@ -3489,12 +3490,14 @@ static Value *emit_allocobj(jl_codectx_t &ctx, size_t static_size, Value *jt)
     call->setAttributes(F->getAttributes());
     if (static_size > 0)
         call->addRetAttr(Attribute::getWithDereferenceableBytes(ctx.builder.getContext(), static_size));
+    call->addRetAttr(Attribute::getWithAlignment(ctx.builder.getContext(), Align(align)));
     return call;
 }
 
 static Value *emit_allocobj(jl_codectx_t &ctx, jl_datatype_t *jt)
 {
-    return emit_allocobj(ctx, jl_datatype_size(jt), ctx.builder.CreateIntToPtr(emit_tagfrom(ctx, jt), ctx.types().T_pjlvalue));
+    return emit_allocobj(ctx, jl_datatype_size(jt), ctx.builder.CreateIntToPtr(emit_tagfrom(ctx, jt), ctx.types().T_pjlvalue),
+                        julia_alignment((jl_value_t*)jt));
 }
 
 // allocation for unknown object from an untracked pointer
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 9c4805398bb91..8cc2634d55aa0 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -664,20 +664,65 @@ static AttributeList get_attrs_basic(LLVMContext &C)
                 None);
 }
 
-static AttributeList get_attrs_sext(LLVMContext &C)
+static AttributeList get_attrs_box_float(LLVMContext &C, unsigned nbytes)
 {
+    auto FnAttrs = AttrBuilder(C);
+    FnAttrs.addAttribute(Attribute::WillReturn);
+    FnAttrs.addAttribute(Attribute::NoUnwind);
+#if JL_LLVM_VERSION >= 160000
+    FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
+#else
+    FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
+#endif
+    auto RetAttrs = AttrBuilder(C);
+    RetAttrs.addAttribute(Attribute::NonNull);
+    RetAttrs.addDereferenceableAttr(nbytes);
+    RetAttrs.addAlignmentAttr(Align(alignof(void*)));
     return AttributeList::get(C,
-                AttributeSet(),
-                Attributes(C, {Attribute::NonNull}),
-                {Attributes(C, {Attribute::SExt})});
+                AttributeSet::get(C, FnAttrs),
+                AttributeSet::get(C, RetAttrs),
+                None);
 }
 
-static AttributeList get_attrs_zext(LLVMContext &C)
+static AttributeList get_attrs_box_sext(LLVMContext &C, unsigned nbytes)
 {
+    auto FnAttrs = AttrBuilder(C);
+    FnAttrs.addAttribute(Attribute::WillReturn);
+    FnAttrs.addAttribute(Attribute::NoUnwind);
+#if JL_LLVM_VERSION >= 160000
+    FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
+#else
+    FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
+#endif
+    auto RetAttrs = AttrBuilder(C);
+    RetAttrs.addAttribute(Attribute::NonNull);
+    RetAttrs.addAttribute(Attribute::getWithDereferenceableBytes(C, nbytes));
+    RetAttrs.addDereferenceableAttr(nbytes);
+    RetAttrs.addAlignmentAttr(Align(alignof(void*)));
     return AttributeList::get(C,
-                AttributeSet(),
-                Attributes(C, {Attribute::NonNull}),
-                {Attributes(C, {Attribute::ZExt})});
+                AttributeSet::get(C, FnAttrs),
+                AttributeSet::get(C, RetAttrs),
+                AttributeSet::get(C, {Attribute::get(C, Attribute::SExt)}));
+}
+
+static AttributeList get_attrs_box_zext(LLVMContext &C, unsigned nbytes)
+{
+    auto FnAttrs = AttrBuilder(C);
+    FnAttrs.addAttribute(Attribute::WillReturn);
+    FnAttrs.addAttribute(Attribute::NoUnwind);
+#if JL_LLVM_VERSION >= 160000
+    FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly());
+#else
+    FnAttrs.addAttribute(Attribute::InaccessibleMemOnly);
+#endif
+    auto RetAttrs = AttrBuilder(C);
+    RetAttrs.addAttribute(Attribute::NonNull);
+    RetAttrs.addDereferenceableAttr(nbytes);
+    RetAttrs.addAlignmentAttr(Align(alignof(void*)));
+    return AttributeList::get(C,
+                AttributeSet::get(C, FnAttrs),
+                AttributeSet::get(C, RetAttrs),
+                AttributeSet::get(C, {Attribute::get(C, Attribute::ZExt)}));
 }
 
 
@@ -1005,8 +1050,13 @@ static const auto jl_alloc_obj_func = new JuliaFunction<TypeFnContextAndSizeT>{
         auto FnAttrs = AttrBuilder(C);
         FnAttrs.addAllocSizeAttr(1, None); // returns %1 bytes
 #if JL_LLVM_VERSION >= 150000
-        FnAttrs.addAllocKindAttr(AllocFnKind::Alloc | AllocFnKind::Uninitialized | AllocFnKind::Aligned);
+        FnAttrs.addAllocKindAttr(AllocFnKind::Alloc | AllocFnKind::Uninitialized);
+#endif
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | inaccessibleMemOnly(ModRefInfo::ModRef));
 #endif
+        FnAttrs.addAttribute(Attribute::WillReturn);
+        FnAttrs.addAttribute(Attribute::NoUnwind);
         auto RetAttrs = AttrBuilder(C);
         RetAttrs.addAttribute(Attribute::NoAlias);
         RetAttrs.addAttribute(Attribute::NonNull);
@@ -1250,22 +1300,34 @@ static const auto sync_gc_total_bytes_func = new JuliaFunction<>{
             {getInt64Ty(C)}, false); },
     nullptr,
 };
-#define BOX_FUNC(ct,at,attrs)                                                    \
+static const auto jlarray_data_owner_func = new JuliaFunction<>{
+    XSTR(jl_array_data_owner),
+    [](LLVMContext &C) {
+        auto T_prjlvalue = JuliaType::get_prjlvalue_ty(C);
+        return FunctionType::get(T_prjlvalue,
+            {T_prjlvalue}, false);
+    },
+    [](LLVMContext &C) { return AttributeList::get(C,
+            Attributes(C, {Attribute::ReadOnly, Attribute::NoUnwind}),
+            Attributes(C, {Attribute::NonNull}),
+            None); },
+};
+#define BOX_FUNC(ct,at,attrs,nbytes)                                                    \
 static const auto box_##ct##_func = new JuliaFunction<>{                           \
     XSTR(jl_box_##ct),                                                           \
     [](LLVMContext &C) { return FunctionType::get(JuliaType::get_prjlvalue_ty(C),\
             {at}, false); },                                                     \
-    attrs,                                                                       \
-}
-BOX_FUNC(int16, getInt16Ty(C), get_attrs_sext);
-BOX_FUNC(uint16, getInt16Ty(C), get_attrs_zext);
-BOX_FUNC(int32, getInt32Ty(C), get_attrs_sext);
-BOX_FUNC(uint32, getInt32Ty(C), get_attrs_zext);
-BOX_FUNC(int64, getInt64Ty(C), get_attrs_sext);
-BOX_FUNC(uint64, getInt64Ty(C), get_attrs_zext);
-BOX_FUNC(char, getCharTy(C), get_attrs_zext);
-BOX_FUNC(float32, getFloatTy(C), get_attrs_basic);
-BOX_FUNC(float64, getDoubleTy(C), get_attrs_basic);
+    [](LLVMContext &C) { return attrs(C,nbytes); },                                                                \
+}
+BOX_FUNC(int16, getInt16Ty(C), get_attrs_box_sext, 2);
+BOX_FUNC(uint16, getInt16Ty(C), get_attrs_box_zext, 2);
+BOX_FUNC(int32, getInt32Ty(C), get_attrs_box_sext, 4);
+BOX_FUNC(uint32, getInt32Ty(C), get_attrs_box_zext, 4);
+BOX_FUNC(int64, getInt64Ty(C), get_attrs_box_sext, 8);
+BOX_FUNC(uint64, getInt64Ty(C), get_attrs_box_zext, 8);
+BOX_FUNC(char, getCharTy(C), get_attrs_box_zext, 1);
+BOX_FUNC(float32, getFloatTy(C), get_attrs_box_float, 4);
+BOX_FUNC(float64, getDoubleTy(C), get_attrs_box_float, 8);
 #undef BOX_FUNC
 
 static const auto box_ssavalue_func = new JuliaFunction<TypeFnContextAndSizeT>{
diff --git a/src/llvm-final-gc-lowering.cpp b/src/llvm-final-gc-lowering.cpp
index d6480fd81e8ac..5a53ce4d8e510 100644
--- a/src/llvm-final-gc-lowering.cpp
+++ b/src/llvm-final-gc-lowering.cpp
@@ -189,8 +189,7 @@ void FinalLowerGC::lowerGCAllocBytes(CallInst *target, Function &F)
     IRBuilder<> builder(target);
     auto ptls = target->getArgOperand(0);
     auto type = target->getArgOperand(2);
-    Attribute derefAttr;
-
+    uint64_t derefBytes = 0;
     if (auto CI = dyn_cast<ConstantInt>(target->getArgOperand(1))) {
         size_t sz = (size_t)CI->getZExtValue();
         // This is strongly architecture and OS dependent
@@ -200,22 +199,27 @@ void FinalLowerGC::lowerGCAllocBytes(CallInst *target, Function &F)
             newI = builder.CreateCall(
                 bigAllocFunc,
                 { ptls, ConstantInt::get(T_size, sz + sizeof(void*)), type });
-            derefAttr = Attribute::getWithDereferenceableBytes(F.getContext(), sz + sizeof(void*));
+            if (sz > 0)
+                derefBytes = sz;
         }
         else {
             auto pool_offs = ConstantInt::get(Type::getInt32Ty(F.getContext()), offset);
             auto pool_osize = ConstantInt::get(Type::getInt32Ty(F.getContext()), osize);
             newI = builder.CreateCall(poolAllocFunc, { ptls, pool_offs, pool_osize, type });
-            derefAttr = Attribute::getWithDereferenceableBytes(F.getContext(), osize);
+            if (sz > 0)
+                derefBytes = sz;
         }
     } else {
         auto size = builder.CreateZExtOrTrunc(target->getArgOperand(1), T_size);
         size = builder.CreateAdd(size, ConstantInt::get(T_size, sizeof(void*)));
         newI = builder.CreateCall(allocTypedFunc, { ptls, size, type });
-        derefAttr = Attribute::getWithDereferenceableBytes(F.getContext(), sizeof(void*));
+        derefBytes = sizeof(void*);
     }
     newI->setAttributes(newI->getCalledFunction()->getAttributes());
-    newI->addRetAttr(derefAttr);
+    unsigned align = std::max((unsigned)target->getRetAlign().valueOrOne().value(), (unsigned)sizeof(void*));
+    newI->addRetAttr(Attribute::getWithAlignment(F.getContext(), Align(align)));
+    if (derefBytes > 0)
+        newI->addDereferenceableRetAttr(derefBytes);
     newI->takeName(target);
     target->replaceAllUsesWith(newI);
     target->eraseFromParent();
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index 873c34e5a07b7..edb3aad8f2328 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -2435,8 +2435,9 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S, bool *CFGModified) {
                             false),
                         builder.CreatePtrToInt(tag, T_size),
                     });
+                newI->setAttributes(allocBytesIntrinsic->getAttributes());
+                newI->addDereferenceableRetAttr(CI->getRetDereferenceableBytes());
                 newI->takeName(CI);
-
                 // Now, finally, set the tag. We do this in IR instead of in the C alloc
                 // function, to provide possible optimization opportunities. (I think? TBH
                 // the most recent editor of this code is not entirely clear on why we
diff --git a/src/llvm-pass-helpers.cpp b/src/llvm-pass-helpers.cpp
index 589b47148fa83..ed8cc9ed645ae 100644
--- a/src/llvm-pass-helpers.cpp
+++ b/src/llvm-pass-helpers.cpp
@@ -7,6 +7,7 @@
 
 #include "llvm-version.h"
 
+#include "llvm/IR/Attributes.h"
 #include <llvm/IR/Function.h>
 #include <llvm/IR/Metadata.h>
 #include <llvm/IR/Module.h>
@@ -123,9 +124,16 @@ namespace jl_intrinsics {
 
     // Annotates a function with attributes suitable for GC allocation
     // functions. Specifically, the return value is marked noalias and nonnull.
-    // The allocation size is set to the first argument.
     static Function *addGCAllocAttributes(Function *target)
     {
+        auto FnAttrs = AttrBuilder(target->getContext());
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | inaccessibleMemOnly(ModRefInfo::ModRef));
+#endif
+        FnAttrs.addAllocKindAttr(AllocFnKind::Alloc | AllocFnKind::Uninitialized);
+        FnAttrs.addAttribute(Attribute::WillReturn);
+        FnAttrs.addAttribute(Attribute::NoUnwind);
+        target->addFnAttrs(FnAttrs);
         addRetAttr(target, Attribute::NoAlias);
         addRetAttr(target, Attribute::NonNull);
         return target;
diff --git a/test/llvmpasses/alloc-opt-gcframe.ll b/test/llvmpasses/alloc-opt-gcframe.ll
index 97fa75df01c50..e01bd900c71e7 100644
--- a/test/llvmpasses/alloc-opt-gcframe.ll
+++ b/test/llvmpasses/alloc-opt-gcframe.ll
@@ -16,13 +16,13 @@ target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 ; TYPED-NEXT: [[ptls_load:%.*]] = load {}*, {}** [[ptls_field]], align 8, !tbaa !0
 ; TYPED-NEXT: [[ppjl_ptls:%.*]] = bitcast {}* [[ptls_load]] to {}**
 ; TYPED-NEXT: [[ptls_i8:%.*]] = bitcast {}** [[ppjl_ptls]] to i8*
-; TYPED-NEXT: %v = call noalias nonnull dereferenceable({{[0-9]+}}) {} addrspace(10)* @ijl_gc_pool_alloc_instrumented(i8* [[ptls_i8]], i32 [[SIZE_T:[0-9]+]], i32 16, i64 {{.*}} @tag {{.*}})
+; TYPED-NEXT: %v = call noalias nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) {} addrspace(10)* @ijl_gc_pool_alloc_instrumented(i8* [[ptls_i8]], i32 [[SIZE_T:[0-9]+]], i32 16, i64 {{.*}} @tag {{.*}})
 ; TYPED: store atomic {} addrspace(10)* @tag, {} addrspace(10)* addrspace(10)* {{.*}} unordered, align 8, !tbaa !4
 
 ; OPAQUE: %current_task = getelementptr inbounds ptr, ptr %gcstack, i64 -12
 ; OPAQUE: [[ptls_field:%.*]] = getelementptr inbounds ptr, ptr %current_task, i64 16
 ; OPAQUE-NEXT: [[ptls_load:%.*]] = load ptr, ptr [[ptls_field]], align 8, !tbaa !0
-; OPAQUE-NEXT: %v = call noalias nonnull dereferenceable({{[0-9]+}}) ptr addrspace(10) @ijl_gc_pool_alloc_instrumented(ptr [[ptls_load]], i32 [[SIZE_T:[0-9]+]], i32 16, i64 {{.*}} @tag {{.*}})
+; OPAQUE-NEXT: %v = call noalias nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) ptr addrspace(10) @ijl_gc_pool_alloc_instrumented(ptr [[ptls_load]], i32 [[SIZE_T:[0-9]+]], i32 16, i64 {{.*}} @tag {{.*}})
 ; OPAQUE: store atomic ptr addrspace(10) @tag, ptr addrspace(10) {{.*}} unordered, align 8, !tbaa !4
 
 define {} addrspace(10)* @return_obj() {
diff --git a/test/llvmpasses/final-lower-gc.ll b/test/llvmpasses/final-lower-gc.ll
index eabeb20ce5636..eb3b68662c2b4 100644
--- a/test/llvmpasses/final-lower-gc.ll
+++ b/test/llvmpasses/final-lower-gc.ll
@@ -78,8 +78,8 @@ top:
   %pgcstack = call {}*** @julia.get_pgcstack()
   %ptls = call {}*** @julia.ptls_states()
   %ptls_i8 = bitcast {}*** %ptls to i8*
-; TYPED: %v = call noalias nonnull dereferenceable({{[0-9]+}}) {} addrspace(10)* @ijl_gc_pool_alloc_instrumented
-; OPAQUE: %v = call noalias nonnull dereferenceable({{[0-9]+}}) ptr addrspace(10) @ijl_gc_pool_alloc_instrumented
+; TYPED: %v = call noalias nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) {} addrspace(10)* @ijl_gc_pool_alloc_instrumented
+; OPAQUE: %v = call noalias nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) ptr addrspace(10) @ijl_gc_pool_alloc_instrumented
   %v = call {} addrspace(10)* @julia.gc_alloc_bytes(i8* %ptls_i8, i64 8, i64 12341234)
   %0 = bitcast {} addrspace(10)* %v to {} addrspace(10)* addrspace(10)*
   %1 = getelementptr {} addrspace(10)*, {} addrspace(10)* addrspace(10)* %0, i64 -1
@@ -94,8 +94,8 @@ top:
   %ptls = call {}*** @julia.ptls_states()
   %ptls_i8 = bitcast {}*** %ptls to i8*
 ; CHECK: %0 = add i64 %size, 8
-; TYPED: %v = call noalias nonnull dereferenceable(8) {} addrspace(10)* @ijl_gc_alloc_typed(i8* %ptls_i8, i64 %0, i64 12341234)
-; OPAQUE: %v = call noalias nonnull dereferenceable(8) ptr addrspace(10) @ijl_gc_alloc_typed(ptr %ptls_i8, i64 %0, i64 12341234)
+; TYPED: %v = call noalias nonnull align {{[0-9]+}} dereferenceable(8) {} addrspace(10)* @ijl_gc_alloc_typed(i8* %ptls_i8, i64 %0, i64 12341234)
+; OPAQUE: %v = call noalias nonnull align {{[0-9]+}} dereferenceable(8) ptr addrspace(10) @ijl_gc_alloc_typed(ptr %ptls_i8, i64 %0, i64 12341234)
   %v = call {} addrspace(10)* @julia.gc_alloc_bytes(i8* %ptls_i8, i64 %size, i64 12341234)
   %0 = bitcast {} addrspace(10)* %v to {} addrspace(10)* addrspace(10)*
   %1 = getelementptr {} addrspace(10)*, {} addrspace(10)* addrspace(10)* %0, i64 -1
diff --git a/test/llvmpasses/late-lower-gc-addrspaces.ll b/test/llvmpasses/late-lower-gc-addrspaces.ll
index b47a523d8a364..77f8e2ac685ce 100644
--- a/test/llvmpasses/late-lower-gc-addrspaces.ll
+++ b/test/llvmpasses/late-lower-gc-addrspaces.ll
@@ -67,7 +67,7 @@ top:
 ; TYPED-NEXT: [[ptls_load:%.*]] = load {}*, {}** [[ptls_field]], align 8, !tbaa !0
 ; TYPED-NEXT: [[ppjl_ptls:%.*]] = bitcast {}* [[ptls_load]] to {}**
 ; TYPED-NEXT: [[ptls_i8:%.*]] = bitcast {}** [[ppjl_ptls]] to i8*
-; TYPED-NEXT: %v = call {} addrspace(10)* @julia.gc_alloc_bytes(i8* [[ptls_i8]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
+; TYPED-NEXT: %v = call noalias nonnull {} addrspace(10)* @julia.gc_alloc_bytes(i8* [[ptls_i8]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
 ; TYPED-NEXT: [[V2:%.*]] = bitcast {} addrspace(10)* %v to {} addrspace(10)* addrspace(10)*
 ; TYPED-NEXT: [[V_HEADROOM:%.*]] = getelementptr inbounds {} addrspace(10)*, {} addrspace(10)* addrspace(10)* [[V2]], i64 -1
 ; TYPED-NEXT: store atomic {} addrspace(10)* @tag, {} addrspace(10)* addrspace(10)* [[V_HEADROOM]] unordered, align 8, !tbaa !4
@@ -75,7 +75,7 @@ top:
 ; OPAQUE: %current_task = getelementptr inbounds ptr, ptr %0, i64 -12
 ; OPAQUE-NEXT: [[ptls_field:%.*]] = getelementptr inbounds ptr, ptr %current_task, i64 16
 ; OPAQUE-NEXT: [[ptls_load:%.*]] = load ptr, ptr [[ptls_field]], align 8, !tbaa !0
-; OPAQUE-NEXT: %v = call ptr addrspace(10) @julia.gc_alloc_bytes(ptr [[ptls_load]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
+; OPAQUE-NEXT: %v = call noalias nonnull ptr addrspace(10) @julia.gc_alloc_bytes(ptr [[ptls_load]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
 ; OPAQUE-NEXT: [[V_HEADROOM:%.*]] = getelementptr inbounds ptr addrspace(10), ptr addrspace(10) %v, i64 -1
 ; OPAQUE-NEXT: store atomic ptr addrspace(10) @tag, ptr addrspace(10) [[V_HEADROOM]] unordered, align 8, !tbaa !4
     %v = call noalias {} addrspace(10)* @julia.gc_alloc_obj({}** %current_task, i64 8, {} addrspace(10)* @tag)
@@ -100,7 +100,7 @@ top:
 ; TYPED-NEXT: [[ptls_load:%.*]] = load {}*, {}** [[ptls_field]], align 8, !tbaa !0
 ; TYPED-NEXT: [[ppjl_ptls:%.*]] = bitcast {}* [[ptls_load]] to {}**
 ; TYPED-NEXT: [[ptls_i8:%.*]] = bitcast {}** [[ppjl_ptls]] to i8*
-; TYPED-NEXT: %v = call {} addrspace(10)* @julia.gc_alloc_bytes(i8* [[ptls_i8]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
+; TYPED-NEXT: %v = call noalias nonnull {} addrspace(10)* @julia.gc_alloc_bytes(i8* [[ptls_i8]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
 ; TYPED-NEXT: [[V2:%.*]] = bitcast {} addrspace(10)* %v to {} addrspace(10)* addrspace(10)*
 ; TYPED-NEXT: [[V_HEADROOM:%.*]] = getelementptr inbounds {} addrspace(10)*, {} addrspace(10)* addrspace(10)* [[V2]], i64 -1
 ; TYPED-NEXT: store atomic {} addrspace(10)* @tag, {} addrspace(10)* addrspace(10)* [[V_HEADROOM]] unordered, align 8, !tbaa !4
@@ -108,7 +108,7 @@ top:
 ; OPAQUE: %current_task = getelementptr inbounds ptr, ptr %0, i64 -12
 ; OPAQUE-NEXT: [[ptls_field:%.*]] = getelementptr inbounds ptr, ptr %current_task, i64 16
 ; OPAQUE-NEXT: [[ptls_load:%.*]] = load ptr, ptr [[ptls_field]], align 8, !tbaa !0
-; OPAQUE-NEXT: %v = call ptr addrspace(10) @julia.gc_alloc_bytes(ptr [[ptls_load]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
+; OPAQUE-NEXT: %v = call noalias nonnull ptr addrspace(10) @julia.gc_alloc_bytes(ptr [[ptls_load]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
 ; OPAQUE-NEXT: [[V_HEADROOM:%.*]] = getelementptr inbounds ptr addrspace(10), ptr addrspace(10) %v, i64 -1
 ; OPAQUE-NEXT: store atomic ptr addrspace(10) @tag, ptr addrspace(10) [[V_HEADROOM]] unordered, align 8, !tbaa !4
     %v = call noalias {} addrspace(10)* @julia.gc_alloc_obj({}** %current_task, i64 8, {} addrspace(10)* @tag)
diff --git a/test/llvmpasses/late-lower-gc.ll b/test/llvmpasses/late-lower-gc.ll
index 4d45ef61faa85..6dee18da5975f 100644
--- a/test/llvmpasses/late-lower-gc.ll
+++ b/test/llvmpasses/late-lower-gc.ll
@@ -64,7 +64,7 @@ top:
 ; TYPED-NEXT: [[ptls_load:%.*]] = load {}*, {}** [[ptls_field]], align 8, !tbaa !0
 ; TYPED-NEXT: [[ppjl_ptls:%.*]] = bitcast {}* [[ptls_load]] to {}**
 ; TYPED-NEXT: [[ptls_i8:%.*]] = bitcast {}** [[ppjl_ptls]] to i8*
-; TYPED-NEXT: %v = call {} addrspace(10)* @julia.gc_alloc_bytes(i8* [[ptls_i8]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
+; TYPED-NEXT: %v = call noalias nonnull {} addrspace(10)* @julia.gc_alloc_bytes(i8* [[ptls_i8]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
 ; TYPED-NEXT: [[V2:%.*]] = bitcast {} addrspace(10)* %v to {} addrspace(10)* addrspace(10)*
 ; TYPED-NEXT: [[V_HEADROOM:%.*]] = getelementptr inbounds {} addrspace(10)*, {} addrspace(10)* addrspace(10)* [[V2]], i64 -1
 ; TYPED-NEXT: store atomic {} addrspace(10)* @tag, {} addrspace(10)* addrspace(10)* [[V_HEADROOM]] unordered, align 8, !tbaa !4
@@ -72,7 +72,7 @@ top:
 ; OPAQUE: %current_task = getelementptr inbounds ptr, ptr %0, i64 -12
 ; OPAQUE-NEXT: [[ptls_field:%.*]] = getelementptr inbounds ptr, ptr %current_task, i64 16
 ; OPAQUE-NEXT: [[ptls_load:%.*]] = load ptr, ptr [[ptls_field]], align 8, !tbaa !0
-; OPAQUE-NEXT: %v = call ptr addrspace(10) @julia.gc_alloc_bytes(ptr [[ptls_load]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
+; OPAQUE-NEXT: %v = call noalias nonnull ptr addrspace(10) @julia.gc_alloc_bytes(ptr [[ptls_load]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
 ; OPAQUE-NEXT: [[V_HEADROOM:%.*]] = getelementptr inbounds ptr addrspace(10), ptr addrspace(10) %v, i64 -1
 ; OPAQUE-NEXT: store atomic ptr addrspace(10) @tag, ptr addrspace(10) [[V_HEADROOM]] unordered, align 8, !tbaa !4
     %v = call noalias {} addrspace(10)* @julia.gc_alloc_obj({}** %current_task, i64 8, {} addrspace(10)* @tag)
@@ -97,7 +97,7 @@ top:
 ; TYPED-NEXT: [[ptls_load:%.*]] = load {}*, {}** [[ptls_field]], align 8, !tbaa !0
 ; TYPED-NEXT: [[ppjl_ptls:%.*]] = bitcast {}* [[ptls_load]] to {}**
 ; TYPED-NEXT: [[ptls_i8:%.*]] = bitcast {}** [[ppjl_ptls]] to i8*
-; TYPED-NEXT: %v = call {} addrspace(10)* @julia.gc_alloc_bytes(i8* [[ptls_i8]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
+; TYPED-NEXT: %v = call noalias nonnull {} addrspace(10)* @julia.gc_alloc_bytes(i8* [[ptls_i8]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
 ; TYPED-NEXT: [[V2:%.*]] = bitcast {} addrspace(10)* %v to {} addrspace(10)* addrspace(10)*
 ; TYPED-NEXT: [[V_HEADROOM:%.*]] = getelementptr inbounds {} addrspace(10)*, {} addrspace(10)* addrspace(10)* [[V2]], i64 -1
 ; TYPED-NEXT: store atomic {} addrspace(10)* @tag, {} addrspace(10)* addrspace(10)* [[V_HEADROOM]] unordered, align 8, !tbaa !4
@@ -105,7 +105,7 @@ top:
 ; OPAQUE: %current_task = getelementptr inbounds ptr, ptr %0, i64 -12
 ; OPAQUE-NEXT: [[ptls_field:%.*]] = getelementptr inbounds ptr, ptr %current_task, i64 16
 ; OPAQUE-NEXT: [[ptls_load:%.*]] = load ptr, ptr [[ptls_field]], align 8, !tbaa !0
-; OPAQUE-NEXT: %v = call ptr addrspace(10) @julia.gc_alloc_bytes(ptr [[ptls_load]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
+; OPAQUE-NEXT: %v = call noalias nonnull ptr addrspace(10) @julia.gc_alloc_bytes(ptr [[ptls_load]], [[SIZE_T:i.[0-9]+]] 8, i64 {{.*}} @tag {{.*}})
 ; OPAQUE-NEXT: [[V_HEADROOM:%.*]] = getelementptr inbounds ptr addrspace(10), ptr addrspace(10) %v, i64 -1
 ; OPAQUE-NEXT: store atomic ptr addrspace(10) @tag, ptr addrspace(10) [[V_HEADROOM]] unordered, align 8, !tbaa !4
     %v = call noalias {} addrspace(10)* @julia.gc_alloc_obj({}** %current_task, i64 8, {} addrspace(10)* @tag)
diff --git a/test/llvmpasses/names.jl b/test/llvmpasses/names.jl
index ad2f418fbd077..6ee2a0335d272 100644
--- a/test/llvmpasses/names.jl
+++ b/test/llvmpasses/names.jl
@@ -67,6 +67,12 @@ mutable struct Barrier
     b
 end
 
+# COM: check write barrier names
+function f8(b,y)
+    b.b = y
+    return b
+end
+
 struct Named
     x::Int
 end
@@ -152,15 +158,15 @@ emit(f6, E)
 # CHECK: define {{(swiftcc )?}}i64 @julia_f7
 # CHECK-SAME: %"a::Tuple"
 # CHECK: %"a::Tuple[2]_ptr.unbox
-emit(f7,Tuple{Int,Int})
+emit(f7, Tuple{Int,Int})
 
-# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_Barrier
-# CHECK-SAME: %"b::Int64"
+# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_f8
+# CHECK-SAME: %"y::Int64"
 # CHECK: %parent_bits
 # CHECK: %parent_old_marked
 # CHECK: %child_bit
 # CHECK: %child_not_marked
-emit(Barrier, Int64)
+emit(f8, Barrier, Int)
 
 # CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_Barrier
 # CHECK-SAME: %"b::Named"

From 32df25bc2e1af16c01f13456c249aed655807f95 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Mon, 6 Nov 2023 18:56:50 -0300
Subject: [PATCH 0201/1315] bugfix: don't set pool_live_bytes to zero at the
 end of GC (#52051)

---
 src/gc.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/gc.c b/src/gc.c
index 8320b524ba03e..38a4a5f60bcd7 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1189,8 +1189,14 @@ static void reset_thread_gc_counts(void) JL_NOTSAFEPOINT
     for (int i = 0; i < gc_n_threads; i++) {
         jl_ptls_t ptls = gc_all_tls_states[i];
         if (ptls != NULL) {
-            memset(&ptls->gc_num, 0, sizeof(ptls->gc_num));
+            // don't reset `pool_live_bytes` here
             jl_atomic_store_relaxed(&ptls->gc_num.allocd, -(int64_t)gc_num.interval);
+            jl_atomic_store_relaxed(&ptls->gc_num.malloc, 0);
+            jl_atomic_store_relaxed(&ptls->gc_num.realloc, 0);
+            jl_atomic_store_relaxed(&ptls->gc_num.poolalloc, 0);
+            jl_atomic_store_relaxed(&ptls->gc_num.bigalloc, 0);
+            jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
+            jl_atomic_store_relaxed(&ptls->gc_num.free_acc, 0);
         }
     }
 }

From 494da9609f5f2800632412140affc4b7d26c0b80 Mon Sep 17 00:00:00 2001
From: "Navid C. Constantinou" <navidcy@users.noreply.github.com>
Date: Mon, 6 Nov 2023 19:53:35 -0700
Subject: [PATCH 0202/1315] Add some spaces for code-readability (#52053)

---
 doc/src/manual/arrays.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/doc/src/manual/arrays.md b/doc/src/manual/arrays.md
index 0b4532e1b423d..027f9ca661443 100644
--- a/doc/src/manual/arrays.md
+++ b/doc/src/manual/arrays.md
@@ -326,8 +326,8 @@ These syntaxes are shorthands for function calls that themselves are convenience
 | Syntax                 | Function         | Description                                                                                                |
 |:---------------------- |:---------------- |:---------------------------------------------------------------------------------------------------------- |
 |                        | [`cat`](@ref)    | concatenate input arrays along dimension(s) `k`                                                            |
-| `[A; B; C; ...]`       | [`vcat`](@ref)   | shorthand for `cat(A...; dims=1)`                                                                           |
-| `[A B C ...]`          | [`hcat`](@ref)   | shorthand for `cat(A...; dims=2)`                                                                           |
+| `[A; B; C; ...]`       | [`vcat`](@ref)   | shorthand for `cat(A...; dims=1)`                                                                          |
+| `[A B C ...]`          | [`hcat`](@ref)   | shorthand for `cat(A...; dims=2)`                                                                          |
 | `[A B; C D; ...]`      | [`hvcat`](@ref)  | simultaneous vertical and horizontal concatenation                                                         |
 | `[A; C;; B; D;;; ...]` | [`hvncat`](@ref) | simultaneous n-dimensional concatenation, where number of semicolons indicate the dimension to concatenate |
 
@@ -935,13 +935,13 @@ element of `axes(A, d)` where `d` is that particular dimension number). This
 allows vectors to be indexed like one-column matrices, for example:
 
 ```jldoctest
-julia> A = [8,6,7]
+julia> A = [8, 6, 7]
 3-element Vector{Int64}:
  8
  6
  7
 
-julia> A[2,1]
+julia> A[2, 1]
 6
 ```
 
@@ -1006,7 +1006,7 @@ The following operators are supported for arrays:
 
 To enable convenient vectorization of mathematical and other operations,
 Julia [provides the dot syntax](@ref man-vectorized) `f.(args...)`, e.g. `sin.(x)`
-or `min.(x,y)`, for elementwise operations over arrays or mixtures of arrays and
+or `min.(x, y)`, for elementwise operations over arrays or mixtures of arrays and
 scalars (a [Broadcasting](@ref) operation); these have the additional advantage of
 "fusing" into a single loop when combined with other dot calls, e.g. `sin.(cos.(x))`.
 
@@ -1020,7 +1020,7 @@ operations like `<`, *only* the elementwise `.<` version is applicable to arrays
 
 Also notice the difference between `max.(a,b)`, which [`broadcast`](@ref)s [`max`](@ref)
 elementwise over `a` and `b`, and [`maximum(a)`](@ref), which finds the largest value within
-`a`. The same relationship holds for `min.(a,b)` and `minimum(a)`.
+`a`. The same relationship holds for `min.(a, b)` and `minimum(a)`.
 
 ## Broadcasting
 
@@ -1111,10 +1111,10 @@ generally work correctly as a fallback for any specific array implementation.
 The `AbstractArray` type includes anything vaguely array-like, and implementations of it might
 be quite different from conventional arrays. For example, elements might be computed on request
 rather than stored. However, any concrete `AbstractArray{T,N}` type should generally implement
-at least [`size(A)`](@ref) (returning an `Int` tuple), [`getindex(A,i)`](@ref) and [`getindex(A,i1,...,iN)`](@ref getindex);
-mutable arrays should also implement [`setindex!`](@ref). It is recommended that these operations
-have nearly constant time complexity, as otherwise some array
-functions may be unexpectedly slow. Concrete types should also typically provide a [`similar(A,T=eltype(A),dims=size(A))`](@ref)
+at least [`size(A)`](@ref) (returning an `Int` tuple), [`getindex(A, i)`](@ref) and
+[`getindex(A, i1, ..., iN)`](@ref getindex); mutable arrays should also implement [`setindex!`](@ref).
+It is recommended that these operations have nearly constant time complexity, as otherwise some array
+functions may be unexpectedly slow. Concrete types should also typically provide a [`similar(A, T=eltype(A), dims=size(A))`](@ref)
 method, which is used to allocate a similar array for [`copy`](@ref) and other out-of-place
 operations. No matter how an `AbstractArray{T,N}` is represented internally, `T` is the type of
 object returned by *integer* indexing (`A[1, ..., 1]`, when `A` is not empty) and `N` should be
@@ -1161,7 +1161,7 @@ julia> stride(A, 1)
 
 The stride of the second dimension is the spacing between elements in the same row, skipping
 as many elements as there are in a single column (`5`). Similarly, jumping between the two
-"pages" (in the third dimension) requires skipping `5*7 == 35` elements.  The [`strides`](@ref)
+"pages" (in the third dimension) requires skipping `5*7 == 35` elements. The [`strides`](@ref)
 of this array is the tuple of these three numbers together:
 
 ```julia-repl

From e7345b89fd4eb15e8f395395701e19be705d7b06 Mon Sep 17 00:00:00 2001
From: Yuto Horikawa <hyrodium@gmail.com>
Date: Tue, 7 Nov 2023 11:53:54 +0900
Subject: [PATCH 0203/1315] Update `complex` docstring with `Missing` (#52052)

The docstring of `complex(T::Type)` is a bit incorrect if `T` contains
`Missing`.

```julia
julia> T = Union{Int, Missing}
Union{Missing, Int64}

julia> complex(T)
Union{Missing, Complex{Int64}}

julia> typeof(complex(zero(T)))
Complex{Int64}
```
---
 base/complex.jl | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/base/complex.jl b/base/complex.jl
index ff0209301b441..148bbdcf11f5e 100644
--- a/base/complex.jl
+++ b/base/complex.jl
@@ -178,7 +178,7 @@ complex(x::Real, y::Real) = Complex(x, y)
     complex(T::Type)
 
 Return an appropriate type which can represent a value of type `T` as a complex number.
-Equivalent to `typeof(complex(zero(T)))`.
+Equivalent to `typeof(complex(zero(T)))` if `T` does not contain `Missing`.
 
 # Examples
 ```jldoctest
@@ -187,6 +187,9 @@ Complex{Int64}
 
 julia> complex(Int)
 Complex{Int64}
+
+julia> complex(Union{Int, Missing})
+Union{Missing, Complex{Int64}}
 ```
 """
 complex(::Type{T}) where {T<:Real} = Complex{T}

From 140ea94f8e88a769419503e9ee6c5f81a3e9c638 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 7 Nov 2023 13:58:47 -0500
Subject: [PATCH 0204/1315] [Profile] add builtin Allocs.print and formatting
 equivalents to Profile.print (#51981)

Defines a converter for Allocs to the types implemented by Profile for
printing, allowing flamegraph report generation of allocations with just
the stdlib tooling.

Refs: https://github.com/JuliaLang/julia/pull/42768

For old versions of Julia, you could previously get download a copy of
this code that could be included as a polyfill to add this:
https://gist.github.com/vtjnash/c6aa4db9dafccb0fd28a65f87d6b1adb
---
 stdlib/Profile/docs/src/index.md |   1 +
 stdlib/Profile/src/Allocs.jl     | 206 ++++++++++++++++++++++++++++++-
 stdlib/Profile/src/Profile.jl    |  26 +++-
 stdlib/Profile/test/allocs.jl    |  21 ++++
 stdlib/Profile/test/runtests.jl  |  30 ++---
 5 files changed, 257 insertions(+), 27 deletions(-)

diff --git a/stdlib/Profile/docs/src/index.md b/stdlib/Profile/docs/src/index.md
index 1fbab0ea534d8..ab670866e086c 100644
--- a/stdlib/Profile/docs/src/index.md
+++ b/stdlib/Profile/docs/src/index.md
@@ -106,6 +106,7 @@ The methods in `Profile.Allocs` are not exported and need to be called e.g. as `
 
 ```@docs
 Profile.Allocs.clear
+Profile.Allocs.print
 Profile.Allocs.fetch
 Profile.Allocs.start
 Profile.Allocs.stop
diff --git a/stdlib/Profile/src/Allocs.jl b/stdlib/Profile/src/Allocs.jl
index e45f4dca9607f..59399b1f21bb3 100644
--- a/stdlib/Profile/src/Allocs.jl
+++ b/stdlib/Profile/src/Allocs.jl
@@ -1,5 +1,12 @@
 module Allocs
 
+global print # Allocs.print is separate from both Base.print and Profile.print
+public @profile,
+    clear,
+    print,
+    fetch
+
+using ..Profile: Profile, ProfileFormat, StackFrameTree, print_flat, print_tree
 using Base.StackTraces: StackTrace, StackFrame, lookup
 using Base: InterpreterIP
 
@@ -138,7 +145,7 @@ end
 # Without this, the Alloc's stacktrace prints for lines and lines and lines...
 function Base.show(io::IO, a::Alloc)
     stacktrace_sample = length(a.stacktrace) >= 1 ? "$(a.stacktrace[1]), ..." : ""
-    print(io, "$Alloc($(a.type), $StackFrame[$stacktrace_sample], $(a.size))")
+    Base.print(io, "$Alloc($(a.type), $StackFrame[$stacktrace_sample], $(a.size))")
 end
 
 const BacktraceCache = Dict{BTElement,Vector{StackFrame}}
@@ -216,4 +223,201 @@ function stacktrace_memoized(
     return stack
 end
 
+function warning_empty()
+    @warn """
+    There were no samples collected.
+    Run your program longer (perhaps by running it multiple times),
+    or adjust the frequency of samples to record every event with
+    the `sample_rate=1.0` kwarg."""
+end
+
+
+"""
+    Profile.Allocs.print([io::IO = stdout,] [data::AllocResults = fetch()]; kwargs...)
+
+Prints profiling results to `io` (by default, `stdout`). If you do not
+supply a `data` vector, the internal buffer of accumulated backtraces
+will be used.
+
+See `Profile.print` for an explanation of the valid keyword arguments.
+"""
+print(; kwargs...) =
+    Profile.print(stdout, fetch(); kwargs...)
+print(io::IO; kwargs...) =
+    Profile.print(io, fetch(); kwargs...)
+print(io::IO, data::AllocResults; kwargs...) =
+    Profile.print(io, data; kwargs...)
+Profile.print(data::AllocResults; kwargs...) =
+    Profile.print(stdout, data; kwargs...)
+
+function Profile.print(io::IO,
+        data::AllocResults,
+        ;
+        format = :tree,
+        C = false,
+        #combine = true,
+        maxdepth::Int = typemax(Int),
+        mincount::Int = 0,
+        noisefloor = 0,
+        sortedby::Symbol = :filefuncline,
+        groupby::Union{Symbol,AbstractVector{Symbol}} = :none,
+        recur::Symbol = :off,
+        )
+    pf = ProfileFormat(;C, maxdepth, mincount, noisefloor, sortedby, recur)
+    Profile.print(io, data, pf, format)
+    return
+end
+
+function Profile.print(io::IO, data::AllocResults, fmt::ProfileFormat, format::Symbol)
+    cols::Int = Base.displaysize(io)[2]
+    fmt.recur ∈ (:off, :flat, :flatc) || throw(ArgumentError("recur value not recognized"))
+    data = data.allocs
+    if format === :tree
+        tree(io, data, cols, fmt)
+    elseif format === :flat
+        fmt.recur === :off || throw(ArgumentError("format flat only implements recur=:off"))
+        flat(io, data, cols, fmt)
+    else
+        throw(ArgumentError("output format $(repr(format)) not recognized"))
+    end
+    nothing
+end
+
+
+function parse_flat(::Type{T}, data::Vector{Alloc}, C::Bool) where T
+    lilist = StackFrame[]
+    n = Int[]
+    m = Int[]
+    lilist_idx = Dict{T, Int}()
+    recursive = Set{T}()
+    totalbytes = 0
+    for r in data
+        first = true
+        empty!(recursive)
+        nb = r.size # or 1 for counting
+        totalbytes += nb
+        for frame in r.stacktrace
+            !C && frame.from_c && continue
+            key = (T === UInt64 ? ip : frame)
+            idx = get!(lilist_idx, key, length(lilist) + 1)
+            if idx > length(lilist)
+                push!(recursive, key)
+                push!(lilist, frame)
+                push!(n, nb)
+                push!(m, 0)
+            elseif !(key in recursive)
+                push!(recursive, key)
+                n[idx] += nb
+            end
+            if first
+                m[idx] += nb
+                first = false
+            end
+        end
+    end
+    @assert length(lilist) == length(n) == length(m) == length(lilist_idx)
+    return (lilist, n, m, totalbytes)
+end
+
+function flat(io::IO, data::Vector{Alloc}, cols::Int, fmt::ProfileFormat)
+    fmt.combine || error(ArgumentError("combine=false"))
+    lilist, n, m, totalbytes = parse_flat(fmt.combine ? StackFrame : UInt64, data, fmt.C)
+    filenamemap = Dict{Symbol,String}()
+    if isempty(lilist)
+        warning_empty()
+        return true
+    end
+    print_flat(io, lilist, n, m, cols, filenamemap, fmt)
+    Base.println(io, "Total snapshots: ", length(data))
+    Base.println(io, "Total bytes: ", totalbytes)
+    return false
+end
+
+function tree!(root::StackFrameTree{T}, all::Vector{Alloc}, C::Bool, recur::Symbol) where {T}
+    tops = Vector{StackFrameTree{T}}()
+    build = Dict{T, StackFrameTree{T}}()
+    for r in all
+        first = true
+        nb = r.size # or 1 for counting
+        root.recur = 0
+        root.count += nb
+        parent = root
+        for i in reverse(eachindex(r.stacktrace))
+            frame = r.stacktrace[i]
+            key = (T === UInt64 ? ip : frame)
+            if (recur === :flat && !frame.from_c) || recur === :flatc
+                # see if this frame already has a parent
+                this = get!(build, frame, parent)
+                if this !== parent
+                    # Rewind the `parent` tree back, if this exact ip (FIXME) was already present *higher* in the current tree
+                    push!(tops, parent)
+                    parent = this
+                end
+            end
+            !C && frame.from_c && continue
+            this = get!(StackFrameTree{T}, parent.down, key)
+            if recur === :off || this.recur == 0
+                this.frame = frame
+                this.up = parent
+                this.count += nb
+                this.recur = 1
+            else
+                this.count_recur += 1
+            end
+            parent = this
+        end
+        parent.overhead += nb
+        if recur !== :off
+            # We mark all visited nodes to so we'll only count those branches
+            # once for each backtrace. Reset that now for the next backtrace.
+            empty!(build)
+            push!(tops, parent)
+            for top in tops
+                while top.recur != 0
+                    top.max_recur < top.recur && (top.max_recur = top.recur)
+                    top.recur = 0
+                    top = top.up
+                end
+            end
+            empty!(tops)
+        end
+        let this = parent
+            while this !== root
+                this.flat_count += nb
+                this = this.up
+            end
+        end
+    end
+    function cleanup!(node::StackFrameTree)
+        stack = [node]
+        while !isempty(stack)
+            node = pop!(stack)
+            node.recur = 0
+            empty!(node.builder_key)
+            empty!(node.builder_value)
+            append!(stack, values(node.down))
+        end
+        nothing
+    end
+    cleanup!(root)
+    return root
+end
+
+function tree(io::IO, data::Vector{Alloc}, cols::Int, fmt::ProfileFormat)
+    fmt.combine || error(ArgumentError("combine=false"))
+    if fmt.combine
+        root = tree!(StackFrameTree{StackFrame}(), data, fmt.C, fmt.recur)
+    else
+        root = tree!(StackFrameTree{UInt64}(), data, fmt.C, fmt.recur)
+    end
+    print_tree(io, root, cols, fmt, false)
+    if isempty(root.down)
+        warning_empty()
+        return true
+    end
+    Base.println(io, "Total snapshots: ", length(data))
+    Base.println(io, "Total bytes: ", root.count)
+    return false
+end
+
 end
diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index c37cdd0af0368..206d2957a91e5 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -5,6 +5,20 @@ Profiling support, main entry point is the [`@profile`](@ref) macro.
 """
 module Profile
 
+global print
+public @profile,
+    clear,
+    print,
+    fetch,
+    retrieve,
+    add_fake_meta,
+    flatten,
+    callers,
+    init,
+    take_heap_snapshot,
+    clear_malloc_data,
+    Allocs
+
 import Base.StackTraces: lookup, UNKNOWN, show_spec_linfo, StackFrame
 
 const nmeta = 4 # number of metadata fields per block (threadid, taskid, cpu_cycle_clock, thread_sleeping)
@@ -220,7 +234,7 @@ function print(io::IO,
 
     pf = ProfileFormat(;C, combine, maxdepth, mincount, noisefloor, sortedby, recur)
     if groupby === :none
-        print(io, data, lidict, pf, format, threads, tasks, false)
+        print_group(io, data, lidict, pf, format, threads, tasks, false)
     else
         if !in(groupby, [:thread, :task, [:task, :thread], [:thread, :task]])
             error(ArgumentError("Unrecognized groupby option: $groupby. Options are :none (default), :task, :thread, [:task, :thread], or [:thread, :task]"))
@@ -244,7 +258,7 @@ function print(io::IO,
                     printstyled(io, "Task $(Base.repr(taskid))$nl"; bold=true, color=Base.debug_color())
                     for threadid in threadids
                         printstyled(io, " Thread $threadid "; bold=true, color=Base.info_color())
-                        nosamples = print(io, data, lidict, pf, format, threadid, taskid, true)
+                        nosamples = print_group(io, data, lidict, pf, format, threadid, taskid, true)
                         nosamples && (any_nosamples = true)
                         println(io)
                     end
@@ -262,7 +276,7 @@ function print(io::IO,
                     printstyled(io, "Thread $threadid$nl"; bold=true, color=Base.info_color())
                     for taskid in taskids
                         printstyled(io, " Task $(Base.repr(taskid)) "; bold=true, color=Base.debug_color())
-                        nosamples = print(io, data, lidict, pf, format, threadid, taskid, true)
+                        nosamples = print_group(io, data, lidict, pf, format, threadid, taskid, true)
                         nosamples && (any_nosamples = true)
                         println(io)
                     end
@@ -274,7 +288,7 @@ function print(io::IO,
             isempty(taskids) && (any_nosamples = true)
             for taskid in taskids
                 printstyled(io, "Task $(Base.repr(taskid)) "; bold=true, color=Base.debug_color())
-                nosamples = print(io, data, lidict, pf, format, threads, taskid, true)
+                nosamples = print_group(io, data, lidict, pf, format, threads, taskid, true)
                 nosamples && (any_nosamples = true)
                 println(io)
             end
@@ -284,7 +298,7 @@ function print(io::IO,
             isempty(threadids) && (any_nosamples = true)
             for threadid in threadids
                 printstyled(io, "Thread $threadid "; bold=true, color=Base.info_color())
-                nosamples = print(io, data, lidict, pf, format, threadid, tasks, true)
+                nosamples = print_group(io, data, lidict, pf, format, threadid, tasks, true)
                 nosamples && (any_nosamples = true)
                 println(io)
             end
@@ -306,7 +320,7 @@ See `Profile.print([io], data)` for an explanation of the valid keyword argument
 print(data::Vector{<:Unsigned} = fetch(), lidict::Union{LineInfoDict, LineInfoFlatDict} = getdict(data); kwargs...) =
     print(stdout, data, lidict; kwargs...)
 
-function print(io::IO, data::Vector{<:Unsigned}, lidict::Union{LineInfoDict, LineInfoFlatDict}, fmt::ProfileFormat,
+function print_group(io::IO, data::Vector{<:Unsigned}, lidict::Union{LineInfoDict, LineInfoFlatDict}, fmt::ProfileFormat,
                 format::Symbol, threads::Union{Int,AbstractVector{Int}}, tasks::Union{UInt,AbstractVector{UInt}},
                 is_subsection::Bool = false)
     cols::Int = Base.displaysize(io)[2]
diff --git a/stdlib/Profile/test/allocs.jl b/stdlib/Profile/test/allocs.jl
index e77e5bc826612..d4930a2b7f5ed 100644
--- a/stdlib/Profile/test/allocs.jl
+++ b/stdlib/Profile/test/allocs.jl
@@ -1,6 +1,13 @@
 using Test
 using Profile: Allocs
 
+Allocs.clear()
+let iobuf = IOBuffer()
+    for format in (:tree, :flat)
+        Test.@test_logs (:warn, r"^There were no samples collected\.") Allocs.print(iobuf; format, C=true)
+    end
+end
+
 @testset "alloc profiler doesn't segfault" begin
     res = Allocs.@profile sample_rate=1.0 begin
         # test the allocations during compilation
@@ -13,6 +20,20 @@ using Profile: Allocs
     @test first_alloc.size > 0
     @test length(first_alloc.stacktrace) > 0
     @test length(string(first_alloc.type)) > 0
+
+    # test printing options
+    for options in ((format=:tree, C=true),
+                    (format=:tree, maxdepth=2),
+                    (format=:flat, C=true),
+                    (),
+                    (format=:flat, sortedby=:count),
+                    (format=:tree, recur=:flat),
+                   )
+        iobuf = IOBuffer()
+        Allocs.print(iobuf; options...)
+        str = String(take!(iobuf))
+        @test !isempty(str)
+    end
 end
 
 @testset "alloc profiler works when there are multiple tasks on multiple threads" begin
diff --git a/stdlib/Profile/test/runtests.jl b/stdlib/Profile/test/runtests.jl
index 95ec7f857dad7..eccfeea846a23 100644
--- a/stdlib/Profile/test/runtests.jl
+++ b/stdlib/Profile/test/runtests.jl
@@ -38,28 +38,18 @@ let r = Profile.retrieve()
     end
 end
 
-let iobuf = IOBuffer()
-    Profile.print(iobuf, format=:tree, C=true)
-    str = String(take!(iobuf))
-    @test !isempty(str)
-    truncate(iobuf, 0)
-    Profile.print(iobuf, format=:tree, maxdepth=2)
-    str = String(take!(iobuf))
-    @test !isempty(str)
-    truncate(iobuf, 0)
-    Profile.print(iobuf, format=:flat, C=true)
-    str = String(take!(iobuf))
-    @test !isempty(str)
-    truncate(iobuf, 0)
-    Profile.print(iobuf)
-    @test !isempty(String(take!(iobuf)))
-    truncate(iobuf, 0)
-    Profile.print(iobuf, format=:flat, sortedby=:count)
-    @test !isempty(String(take!(iobuf)))
-    Profile.print(iobuf, format=:tree, recur=:flat)
+# test printing options
+for options in ((format=:tree, C=true),
+                (format=:tree, maxdepth=2),
+                (format=:flat, C=true),
+                (),
+                (format=:flat, sortedby=:count),
+                (format=:tree, recur=:flat),
+               )
+    iobuf = IOBuffer()
+    Profile.print(iobuf; options...)
     str = String(take!(iobuf))
     @test !isempty(str)
-    truncate(iobuf, 0)
 end
 
 @testset "Profile.print() groupby options" begin

From 08e5983f19b4bfd21dd113c335a41796d6bd8765 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 8 Nov 2023 09:46:59 +0900
Subject: [PATCH 0205/1315] inference: remove the `must_be_codeinf` setting
 (#52059)

This setting is no longer utilized in either the base or known external
compiler pipelines. And what allowed by setting `must_be_codeinf =
false` can now be achieved using the `cache_mode::UInt8` field, making
the setting redundant.
---
 base/compiler/typeinfer.jl | 8 ++++----
 base/compiler/types.jl     | 3 +--
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 0c678651693b9..bf81c989c3155 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -227,7 +227,7 @@ function finish!(interp::AbstractInterpreter, caller::InferenceState)
         store_backedges(result, caller.stmt_edges[1])
     end
     opt = result.src
-    if opt isa OptimizationState && result.must_be_codeinf
+    if opt isa OptimizationState
         result.src = opt = ir_to_codeinf!(opt)
     end
     if opt isa CodeInfo
@@ -235,9 +235,9 @@ function finish!(interp::AbstractInterpreter, caller::InferenceState)
         opt.max_world = last(valid_worlds)
         caller.src = opt
     else
-        # In this case caller.src is invalid for clients (such as typeinf_ext) to use
-        # but that is what !must_be_codeinf permits
-        # This is hopefully unreachable when must_be_codeinf is true
+        # In this case `caller.src` is invalid for clients (such as `typeinf_ext`) to use
+        # but that is what's permitted by `caller.cache_mode`.
+        # This is hopefully unreachable from such clients using `NativeInterpreter`.
     end
     return nothing
 end
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index ba05131d4e3a3..5c7445aec0386 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -76,13 +76,12 @@ mutable struct InferenceResult
     ipo_effects::Effects     # if inference is finished
     effects::Effects         # if optimization is finished
     argescapes               # ::ArgEscapeCache if optimized, nothing otherwise
-    must_be_codeinf::Bool    # if this must come out as CodeInfo or leaving it as IRCode is ok
     function InferenceResult(linfo::MethodInstance, cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
         # def = linfo.def
         # nargs = def isa Method ? Int(def.nargs) : 0
         # @assert length(cache_argtypes) == nargs
         return new(linfo, cache_argtypes, overridden_by_const, nothing, nothing,
-            WorldRange(), Effects(), Effects(), nothing, true)
+            WorldRange(), Effects(), Effects(), nothing)
     end
 end
 InferenceResult(linfo::MethodInstance, 𝕃::AbstractLattice=fallback_lattice) =

From 1327dfec807fa00782311f02d095b8e37ea55f2a Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 8 Nov 2023 09:51:16 +0900
Subject: [PATCH 0206/1315] allow destructive inlining only when the source is
 volatile (#52062)

Destructive inlining introduced by JuliaLang/julia#51934 implicitly
presupposes that inferred `CodeInfo` source has been compressed to the
`String` format when cached, which is not generally true for external
`AbstractInterpreter`s that may disable the `may_compress` and/or
`may_discard_trees` settings. This commit adds a safeguard to ensure the
eligibility of such `CodeInfo` source propagated by
`VolatileInferenceResult` for destructive inlining.
---
 base/compiler/ssair/inlining.jl | 2 +-
 base/compiler/typeinfer.jl      | 2 ++
 base/compiler/types.jl          | 3 ++-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index db50c5142f46f..318b21b09bb16 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -884,7 +884,7 @@ function resolve_todo(mi::MethodInstance, result::Union{Nothing,InferenceResult,
     elseif isa(result, VolatileInferenceResult)
         inferred_result = get_local_result(result.inf_result)
         # volatile inference result can be inlined destructively
-        preserve_local_sources = OptimizationParams(state.interp).preserve_local_sources
+        preserve_local_sources = !result.inf_result.is_src_volatile | OptimizationParams(state.interp).preserve_local_sources
     else
         inferred_result = get_cached_result(state, mi)
     end
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index bf81c989c3155..9eef6615521ca 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -361,7 +361,9 @@ function transform_result_for_cache(interp::AbstractInterpreter,
     linfo::MethodInstance, valid_worlds::WorldRange, result::InferenceResult)
     inferred_result = result.src
     if inferred_result isa CodeInfo
+        uncompressed = inferred_result
         inferred_result = maybe_compress_codeinfo(interp, linfo, inferred_result)
+        result.is_src_volatile |= uncompressed !== inferred_result
     end
     # The global cache can only handle objects that codegen understands
     if !isa(inferred_result, MaybeCompressed)
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index 5c7445aec0386..db1d85cdddc40 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -76,12 +76,13 @@ mutable struct InferenceResult
     ipo_effects::Effects     # if inference is finished
     effects::Effects         # if optimization is finished
     argescapes               # ::ArgEscapeCache if optimized, nothing otherwise
+    is_src_volatile::Bool    # `src` has been cached globally as the compressed format already, allowing `src` to be used destructively
     function InferenceResult(linfo::MethodInstance, cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
         # def = linfo.def
         # nargs = def isa Method ? Int(def.nargs) : 0
         # @assert length(cache_argtypes) == nargs
         return new(linfo, cache_argtypes, overridden_by_const, nothing, nothing,
-            WorldRange(), Effects(), Effects(), nothing)
+            WorldRange(), Effects(), Effects(), nothing, false)
     end
 end
 InferenceResult(linfo::MethodInstance, 𝕃::AbstractLattice=fallback_lattice) =

From 9f2f3ce9fe5d778e14e526b0084c2605a8c5f973 Mon Sep 17 00:00:00 2001
From: Petr Vana <petvana@gmail.com>
Date: Wed, 8 Nov 2023 15:23:53 +0100
Subject: [PATCH 0207/1315] Introduce sizehint!(s, n; shrink = true) to
 controll shrinkage (#51929)

This is a second part of #51629 to introduce `shrink = true` argument
for `sizehint!` into public API.
---
 NEWS.md                  |  1 +
 base/abstractdict.jl     |  3 +-
 base/abstractset.jl      |  2 +-
 base/array.jl            | 13 ++++++---
 base/dict.jl             |  6 ++--
 base/set.jl              |  2 +-
 base/weakkeydict.jl      |  2 +-
 test/dict.jl             |  4 +--
 test/sets.jl             | 15 ++++++++++
 test/smallarrayshrink.jl | 61 ++++++++++++----------------------------
 10 files changed, 51 insertions(+), 58 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 1b3cc6438e03f..d53911040e4d7 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -56,6 +56,7 @@ New library features
 --------------------
 * `replace(string, pattern...)` now supports an optional `IO` argument to
   write the output to a stream rather than returning a string ([#48625]).
+* `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
 
 Standard library changes
 ------------------------
diff --git a/base/abstractdict.jl b/base/abstractdict.jl
index 0d6553d08bf9d..39898ae71970f 100644
--- a/base/abstractdict.jl
+++ b/base/abstractdict.jl
@@ -220,8 +220,7 @@ Dict{Int64, Int64} with 3 entries:
 function merge!(d::AbstractDict, others::AbstractDict...)
     for other in others
         if haslength(d) && haslength(other)
-            # TODO - do not shrink
-            sizehint!(d, length(d) + length(other))
+            sizehint!(d, length(d) + length(other); shrink = false)
         end
         for (k,v) in other
             d[k] = v
diff --git a/base/abstractset.jl b/base/abstractset.jl
index 3bfc3bffcd831..b38cb2799740b 100644
--- a/base/abstractset.jl
+++ b/base/abstractset.jl
@@ -101,7 +101,7 @@ max_values(::Type{Bool}) = 2
 max_values(::Type{Nothing}) = 1
 
 function union!(s::AbstractSet{T}, itr) where T
-    haslength(itr) && _sizehint!(s, length(s) + Int(length(itr))::Int; shrink = false)
+    haslength(itr) && sizehint!(s, length(s) + Int(length(itr))::Int; shrink = false)
     for x in itr
         push!(s, x)
         length(s) == max_values(T) && break
diff --git a/base/array.jl b/base/array.jl
index 6d59c2f3b41d5..a8d98be3a9b9f 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -1441,7 +1441,7 @@ function resize!(a::Vector, nl::Integer)
 end
 
 """
-    sizehint!(s, n) -> s
+    sizehint!(s, n; shrink::Bool = true) -> s
 
 Suggest that collection `s` reserve capacity for at least `n` elements. That is, if
 you expect that you're going to have to push a lot of values onto `s`, you can avoid
@@ -1462,10 +1462,15 @@ For types that support `sizehint!`,
    `Base`.
 
 3. `empty!` is nearly costless (and O(1)) for types that support this kind of preallocation.
+
+4. `shrink` controls if the collection can be shrunk.
+
+!!! compat "Julia 1.11"
+    The `shrink` argument was added in Julia 1.11.
 """
 function sizehint! end
 
-function sizehint!(a::Vector, sz::Integer)
+function sizehint!(a::Vector, sz::Integer; shrink::Bool = true)
     len = length(a)
     ref = a.ref
     mem = ref.mem
@@ -1474,7 +1479,7 @@ function sizehint!(a::Vector, sz::Integer)
     sz = max(Int(sz), offset + len - 1)
     if sz <= memlen
         # if we don't save at least 1/8th memlen then its not worth it to shrink
-        if memlen - sz <= div(memlen, 8)
+        if !shrink || memlen - sz <= div(memlen, 8)
             return a
         end
         newmem = array_new_memory(mem, sz)
@@ -1494,7 +1499,7 @@ function sizehint!(a::Vector, sz::Integer)
 end
 
 # Fall-back implementation for non-shrinkable collections
-_sizehint!(a, sz; shrink) = sizehint!(a, sz)
+sizehint!(a, sz; shrink::Bool) = sizehint!(a, sz)
 
 """
     pop!(collection) -> item
diff --git a/base/dict.jl b/base/dict.jl
index a5bb0f7499183..7eef5e76e140a 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -228,7 +228,7 @@ end
     return h
 end
 
-function _sizehint!(d::Dict{T}, newsz; shrink = true) where T
+function sizehint!(d::Dict{T}, newsz; shrink::Bool = true) where T
     oldsz = length(d.slots)
     # limit new element count to max_values of the key type
     newsz = min(max(newsz, length(d)), max_values(T)::Int)
@@ -237,8 +237,6 @@ function _sizehint!(d::Dict{T}, newsz; shrink = true) where T
     return (shrink ? newsz == oldsz : newsz <= oldsz) ? d : rehash!(d, newsz)
 end
 
-sizehint!(d::Dict{T}, newsz) where T = _sizehint!(d, newsz)
-
 """
     empty!(collection) -> collection
 
@@ -777,7 +775,7 @@ function map!(f, iter::ValueIterator{<:Dict})
 end
 
 function mergewith!(combine, d1::Dict{K, V}, d2::AbstractDict) where {K, V}
-    haslength(d2) && _sizehint!(d1, length(d1) + length(d2), shrink = false)
+    haslength(d2) && sizehint!(d1, length(d1) + length(d2), shrink = false)
     for (k, v) in d2
         i, sh = ht_keyindex2_shorthash!(d1, k)
         if i > 0
diff --git a/base/set.jl b/base/set.jl
index a91bf328bd911..460f6f176f889 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -117,7 +117,7 @@ copymutable(s::Set{T}) where {T} = Set{T}(s)
 # Set is the default mutable fall-back
 copymutable(s::AbstractSet{T}) where {T} = Set{T}(s)
 
-sizehint!(s::Set, newsz) = (sizehint!(s.dict, newsz); s)
+sizehint!(s::Set, newsz; shrink::Bool = true) = (sizehint!(s.dict, newsz, shrink = shrink); s)
 empty!(s::Set) = (empty!(s.dict); s)
 rehash!(s::Set) = (rehash!(s.dict); s)
 
diff --git a/base/weakkeydict.jl b/base/weakkeydict.jl
index 328f368c80b71..5073e55191847 100644
--- a/base/weakkeydict.jl
+++ b/base/weakkeydict.jl
@@ -80,7 +80,7 @@ function _cleanup_locked(h::WeakKeyDict)
     return h
 end
 
-sizehint!(d::WeakKeyDict, newsz) = sizehint!(d.ht, newsz)
+sizehint!(d::WeakKeyDict, newsz; shrink::Bool = true) = @lock d sizehint!(d.ht, newsz; shrink = shrink)
 empty(d::WeakKeyDict, ::Type{K}, ::Type{V}) where {K, V} = WeakKeyDict{K, V}()
 
 IteratorSize(::Type{<:WeakKeyDict}) = SizeUnknown()
diff --git a/test/dict.jl b/test/dict.jl
index 34f4d13bb9df5..ff4a2ef11a97c 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -1492,9 +1492,9 @@ end
     sizehint!(d, 10)
     @test length(d.slots) < 100
     sizehint!(d, 1000)
-    Base._sizehint!(d, 1; shrink = false)
+    sizehint!(d, 1; shrink = false)
     @test length(d.slots) >= 1000
-    Base._sizehint!(d, 1; shrink = true)
+    sizehint!(d, 1; shrink = true)
     @test length(d.slots) < 1000
 end
 
diff --git a/test/sets.jl b/test/sets.jl
index 694397a1787eb..e9e73fe74534c 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -164,6 +164,19 @@ end
     sizehint!(s2, 10)
     @test s2 == GenericSet(s)
 end
+
+@testset "shrinking" begin # Similar test as for the underlying Dict
+    d = Set(i for i = 1:1000)
+    filter!(x -> x < 10, d)
+    sizehint!(d, 10)
+    @test length(d.dict.slots) < 100
+    sizehint!(d, 1000)
+    sizehint!(d, 1; shrink = false)
+    @test length(d.dict.slots) >= 1000
+    sizehint!(d, 1; shrink = true)
+    @test length(d.dict.slots) < 1000
+end
+
 @testset "rehash!" begin
     # Use a pointer type to have defined behavior for uninitialized
     # array element
@@ -966,4 +979,6 @@ end
     end
     set = TestSet{Any}()
     @test sizehint!(set, 1) === set
+    @test sizehint!(set, 1; shrink = true) === set
+    @test sizehint!(set, 1; shrink = false) === set
 end
diff --git a/test/smallarrayshrink.jl b/test/smallarrayshrink.jl
index a1a7df5aee5a5..680a882e432d4 100644
--- a/test/smallarrayshrink.jl
+++ b/test/smallarrayshrink.jl
@@ -1,45 +1,20 @@
 @testset "shrink small array" begin
-    x = [1, 2, 3, 4]
-    @test x[1] == 1
-    @test x[2] == 2
-    @test x[3] == 3
-    @test x[4] == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 0) == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 1) == 4
-    sizehint!(x, 10000)
-    @test x[1] == 1
-    @test x[2] == 2
-    @test x[3] == 3
-    @test x[4] == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 0) == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 1) == 10000
-    sizehint!(x, 4)
-    @test x[1] == 1
-    @test x[2] == 2
-    @test x[3] == 3
-    @test x[4] == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 0) == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 1) == 4
-
-    x = [1, 2, 3, 4]
-    @test x[1] == 1
-    @test x[2] == 2
-    @test x[3] == 3
-    @test x[4] == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 0) == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 1) == 4
-    sizehint!(x, 1000000)
-    @test x[1] == 1
-    @test x[2] == 2
-    @test x[3] == 3
-    @test x[4] == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 0) == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 1) == 1000000
-    sizehint!(x, 4)
-    @test x[1] == 1
-    @test x[2] == 2
-    @test x[3] == 3
-    @test x[4] == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 0) == 4
-    @test ccall(:jl_array_size, Int, (Any, UInt), x, 1) == 4
+    function check_array(x, size, capacity)
+        @test x[1] == 1
+        @test x[2] == 2
+        @test x[3] == 3
+        @test x[4] == 4
+        @test ccall(:jl_array_size, Int, (Any, UInt), x, 0) == size
+        @test ccall(:jl_array_size, Int, (Any, UInt), x, 1) == capacity
+    end
+    for hint_size = [10000, 1000000]
+        x = [1, 2, 3, 4]
+        check_array(x, 4, 4)
+        sizehint!(x, hint_size)
+        check_array(x, 4, hint_size)
+        sizehint!(x, 4; shrink = false)
+        check_array(x, 4, hint_size)
+        sizehint!(x, 4)
+        check_array(x, 4, 4)
+    end
 end

From 6f6419c586fd837cbcd0ee37ae14943675823a5d Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Wed, 8 Nov 2023 16:17:57 +0100
Subject: [PATCH 0208/1315] Make `pop!(::Set{A}, ::B)` return an A, not B
 (#52017)

Previously, `pop!(::Set, x)` returned `x`, not the element in the
set. This matters if multiple different elements are equal and hash to
the same.

Before:
```julia
julia> pop!(Set([1]), 0x01)
0x01
```
Now:
```julia
julia> pop!(Set([1]), 0x01)
1
```
---
 base/set.jl  | 9 ++++++++-
 test/sets.jl | 8 ++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/base/set.jl b/base/set.jl
index 460f6f176f889..e3013ac807095 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -101,8 +101,15 @@ function in!(x, s::Set)
 end
 
 push!(s::Set, x) = (s.dict[x] = nothing; s)
-pop!(s::Set, x) = (pop!(s.dict, x); x)
+
 pop!(s::Set, x, default) = (x in s ? pop!(s, x) : default)
+function pop!(s::Set, x)
+    index = ht_keyindex(s.dict, x)
+    index < 1 && throw(KeyError(x))
+    result = @inbounds s.dict.keys[index]
+    _delete!(s.dict, index)
+    result
+end
 
 function pop!(s::Set)
     isempty(s) && throw(ArgumentError("set must be non-empty"))
diff --git a/test/sets.jl b/test/sets.jl
index e9e73fe74534c..7bce5aa57feae 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -124,6 +124,14 @@ end
     @test isempty(s)
     @test_throws ArgumentError pop!(s)
     @test length(Set(['x',120])) == 2
+
+    # Test that pop! returns the element in the set, not the query
+    s = Set{Any}(Any[0x01, UInt(2), 3, 4.0])
+    @test pop!(s, 1) === 0x01
+    @test pop!(s, 2) === UInt(2)
+    @test pop!(s, 3) === 3
+    @test pop!(s, 4) === 4.0
+    @test_throws KeyError pop!(s, 5)
 end
 @testset "copy" begin
     data_in = (1,2,9,8,4)

From 8f8b9cacdf33c7d518ec22507a697dfb8d6d5526 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Wed, 8 Nov 2023 12:20:30 -0300
Subject: [PATCH 0209/1315] Optimizations for Memory{T} allocation calls
 (#51968)

Special case for the Memory{T} allocation in ccall so that we can add
attributes and permit method inlining when constructing an Array by
removing `@noinline`.
---
 base/boot.jl              |  4 ----
 src/ccall.cpp             | 28 ++++++++++++++++++++++++++++
 src/cgutils.cpp           | 10 +++++-----
 src/codegen.cpp           | 24 ++++++++++++++++++++++++
 test/compiler/irpasses.jl |  2 +-
 test/compiler/irutils.jl  |  1 +
 test/llvmpasses/names.jl  |  9 +++++++++
 7 files changed, 68 insertions(+), 10 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 98eceb1414ecc..30c340a3cc403 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -559,20 +559,16 @@ end
 
 # type and dimensionality specified, accepting dims as series of Ints
 eval(Core, :(function (self::Type{Array{T,1}})(::UndefInitializer, m::Int) where {T}
-    @noinline
     mem = fieldtype(fieldtype(self, :ref), :mem)(undef, m)
     return $(Expr(:new, :self, :(memoryref(mem)), :((m,))))
 end))
 eval(Core, :(function (self::Type{Array{T,2}})(::UndefInitializer, m::Int, n::Int) where {T}
-    @noinline
     return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(m, n))), :((m, n))))
 end))
 eval(Core, :(function (self::Type{Array{T,3}})(::UndefInitializer, m::Int, n::Int, o::Int) where {T}
-    @noinline
     return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(m, n, o))), :((m, n, o))))
 end))
 eval(Core, :(function (self::Type{Array{T, N}})(::UndefInitializer, d::Vararg{Int, N}) where {T, N}
-    @noinline
     return $(Expr(:new, :self, :(new_as_memoryref(fieldtype(self, :ref), checked_dims(d...))), :d))
 end))
 # type and dimensionality specified, accepting dims as tuples of Ints
diff --git a/src/ccall.cpp b/src/ccall.cpp
index 4ca865af18e40..db2d73bbfcd3f 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -32,6 +32,7 @@ TRANSFORMED_CCALL_STAT(jl_svec_ref);
 TRANSFORMED_CCALL_STAT(jl_string_ptr);
 TRANSFORMED_CCALL_STAT(jl_symbol_name);
 TRANSFORMED_CCALL_STAT(jl_genericmemory_owner);
+TRANSFORMED_CCALL_STAT(jl_alloc_genericmemory);
 TRANSFORMED_CCALL_STAT(memcpy);
 TRANSFORMED_CCALL_STAT(memset);
 TRANSFORMED_CCALL_STAT(memmove);
@@ -1771,6 +1772,33 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         JL_GC_POP();
         return mark_julia_type(ctx, obj, true, jl_any_type);
     }
+    else if (is_libjulia_func(jl_alloc_genericmemory)) {
+        ++CCALL_STAT(jl_alloc_genericmemory);
+        assert(lrt == ctx.types().T_prjlvalue);
+        assert(!isVa && !llvmcall && nccallargs == 2);
+        const jl_cgval_t &typ = argv[0];
+        const jl_cgval_t &nel = argv[1];
+        auto arg_typename = [&] JL_NOTSAFEPOINT {
+            auto istyp = argv[0].constant;
+            std::string type_str;
+            if (istyp && jl_is_datatype(istyp) && jl_is_genericmemory_type(istyp)){
+                auto eltype = jl_tparam1(istyp);
+                if (jl_is_datatype(eltype))
+                    type_str = jl_symbol_name(((jl_datatype_t*)eltype)->name->name);
+                else if (jl_is_uniontype(eltype))
+                    type_str = "Union";
+                else
+                    type_str = "<unknown type>";
+            }
+            else
+                type_str = "<unknown type>";
+            return "Memory{" + type_str + "}[]";
+            };
+        auto alloc = ctx.builder.CreateCall(prepare_call(jl_allocgenericmemory), { boxed(ctx,typ), emit_unbox(ctx, ctx.types().T_size, nel, (jl_value_t*)jl_ulong_type)});
+        setName(ctx.emission_context, alloc, arg_typename);
+        JL_GC_POP();
+        return mark_julia_type(ctx, alloc, true, jl_any_type);
+    }
     else if (is_libjulia_func(memcpy) && (rt == (jl_value_t*)jl_nothing_type || jl_is_cpointer_type(rt))) {
         ++CCALL_STAT(memcpy);
         const jl_cgval_t &dst = argv[0];
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 431c7450f2f2c..ea59d4e298f1c 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -3350,10 +3350,10 @@ static Value *boxed(jl_codectx_t &ctx, const jl_cgval_t &vinfo, bool is_promotab
                 ctx.builder.restoreIP(IP);
             } else {
                 auto arg_typename = [&] JL_NOTSAFEPOINT {
-                    return jl_symbol_name(((jl_datatype_t*)(jt))->name->name);
+                    return "box::" + std::string(jl_symbol_name(((jl_datatype_t*)(jt))->name->name));
                 };
                 box = emit_allocobj(ctx, (jl_datatype_t*)jt);
-                setName(ctx.emission_context, box, "box" + StringRef("::") + arg_typename());
+                setName(ctx.emission_context, box, arg_typename);
                 init_bits_cgval(ctx, box, vinfo, jl_is_mutable(jt) ? ctx.tbaa().tbaa_mutab : ctx.tbaa().tbaa_immut);
             }
         }
@@ -3693,7 +3693,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
     assert(jl_is_concrete_type(ty));
     jl_datatype_t *sty = (jl_datatype_t*)ty;
     auto arg_typename = [&] JL_NOTSAFEPOINT {
-        return jl_symbol_name((sty)->name->name);
+        return "new::" + std::string(jl_symbol_name((sty)->name->name));
     };
     size_t nf = jl_datatype_nfields(sty);
     if (nf > 0 || sty->name->mutabl) {
@@ -3726,7 +3726,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
             }
             else {
                 strct = emit_static_alloca(ctx, lt);
-                setName(ctx.emission_context, strct, "new" + StringRef("::") + arg_typename());
+                setName(ctx.emission_context, strct, arg_typename);
                 if (tracked.count)
                     undef_derived_strct(ctx, strct, sty, ctx.tbaa().tbaa_stack);
             }
@@ -3897,7 +3897,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
             }
         }
         Value *strct = emit_allocobj(ctx, sty);
-        setName(ctx.emission_context, strct, "new" + StringRef("::") + arg_typename());
+        setName(ctx.emission_context, strct, arg_typename);
         jl_cgval_t strctinfo = mark_julia_type(ctx, strct, true, ty);
         strct = decay_derived(ctx, strct);
         undef_derived_strct(ctx, strct, sty, strctinfo.tbaa);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 8cc2634d55aa0..f430487e7a480 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1300,6 +1300,29 @@ static const auto sync_gc_total_bytes_func = new JuliaFunction<>{
             {getInt64Ty(C)}, false); },
     nullptr,
 };
+static const auto jl_allocgenericmemory = new JuliaFunction<TypeFnContextAndSizeT>{
+    XSTR(jl_alloc_genericmemory),
+    [](LLVMContext &C, Type *T_Size) {
+        auto T_prjlvalue = JuliaType::get_prjlvalue_ty(C);
+        return FunctionType::get(T_prjlvalue, // new Memory
+                                {T_prjlvalue, // type
+                                T_Size        // nelements
+                                }, false); },
+        [](LLVMContext &C) {
+            AttrBuilder FnAttrs(C);
+            AttrBuilder RetAttrs(C);
+#if JL_LLVM_VERSION >= 160000
+            FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef) | argMemOnly(MemoryEffects::ModRefInfo::Ref));
+#endif
+            FnAttrs.addAttribute(Attribute::WillReturn);
+            RetAttrs.addAlignmentAttr(Align(16));
+            RetAttrs.addAttribute(Attribute::NonNull);
+            RetAttrs.addDereferenceableAttr(16);
+            return AttributeList::get(C,
+                AttributeSet::get(C, FnAttrs),
+                AttributeSet::get(C, RetAttrs),
+                None); },
+};
 static const auto jlarray_data_owner_func = new JuliaFunction<>{
     XSTR(jl_array_data_owner),
     [](LLVMContext &C) {
@@ -9407,6 +9430,7 @@ static void init_jit_functions(void)
     add_named_global(jlfieldindex_func, &jl_field_index);
     add_named_global(diff_gc_total_bytes_func, &jl_gc_diff_total_bytes);
     add_named_global(sync_gc_total_bytes_func, &jl_gc_sync_total_bytes);
+    add_named_global(jl_allocgenericmemory, &jl_alloc_genericmemory);
     add_named_global(gcroot_flush_func, (void*)NULL);
     add_named_global(gc_preserve_begin_func, (void*)NULL);
     add_named_global(gc_preserve_end_func, (void*)NULL);
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index f1c845d26d21c..61fb0f6935f1b 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -503,7 +503,7 @@ function isdefined_elim()
     return arr
 end
 let src = code_typed1(isdefined_elim)
-    @test is_scalar_replaced(src)
+    @test count(isisdefined, src.code) == 0
 end
 @test isdefined_elim() == Any[]
 
diff --git a/test/compiler/irutils.jl b/test/compiler/irutils.jl
index d1c1431587b1f..72ea8a6ba0636 100644
--- a/test/compiler/irutils.jl
+++ b/test/compiler/irutils.jl
@@ -17,6 +17,7 @@ end
 isnew(@nospecialize x) = isexpr(x, :new)
 issplatnew(@nospecialize x) = isexpr(x, :splatnew)
 isreturn(@nospecialize x) = isa(x, ReturnNode) && isdefined(x, :val)
+isisdefined(@nospecialize x) = isexpr(x, :isdefined)
 
 # check if `x` is a dynamic call of a given function
 iscall(y) = @nospecialize(x) -> iscall(y, x)
diff --git a/test/llvmpasses/names.jl b/test/llvmpasses/names.jl
index 6ee2a0335d272..344738abc3802 100644
--- a/test/llvmpasses/names.jl
+++ b/test/llvmpasses/names.jl
@@ -76,6 +76,10 @@ end
 struct Named
     x::Int
 end
+
+function fmemory(nel)
+    return Memory{Int64}(undef,nel)
+end
 # CHECK-LABEL: define {{(swiftcc )?}}double @julia_f1
 # CHECK-SAME: double %"a::Float64"
 # CHECK-SAME: double %"b::Float64"
@@ -175,3 +179,8 @@ emit(f8, Barrier, Int)
 # CHECK: %parent_bits
 # CHECK: %parent_old_marked
 emit(Barrier, Named)
+
+# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_fmemory
+# CHECK-SAME: %"nel::Int64"
+# CHECK: %"Memory{Int64}[]"
+emit(fmemory, Int64)

From 19724320faf0a5b8a4a61e2276d604d2211f6a61 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Wed, 8 Nov 2023 23:36:24 +0800
Subject: [PATCH 0210/1315] Make `StridedReinterpretArray`'s `get/setindex`
 pointer based. (#44186)

This PR makes `StridedReinterpretArray`'s `get/setindex` purely pointer based if its root storage is a `Array`/`Memory`.
The generated IR would be simpler and (hopefully) easier to optimize.

TODO: LLVM's LV dislikes GC preserved `MemoryRef`, reinterpreted `Array`s might block auto vectorization.

---------

Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/reinterpretarray.jl               |  62 +++++--
 test/reinterpretarray.jl               | 235 +++++++++++++++----------
 test/testhelpers/arrayindexingtypes.jl |   3 +
 3 files changed, 191 insertions(+), 109 deletions(-)

diff --git a/base/reinterpretarray.jl b/base/reinterpretarray.jl
index 16d2716c7a2eb..23bfb38a28654 100644
--- a/base/reinterpretarray.jl
+++ b/base/reinterpretarray.jl
@@ -352,7 +352,7 @@ has_offset_axes(a::ReinterpretArray) = has_offset_axes(a.parent)
 elsize(::Type{<:ReinterpretArray{T}}) where {T} = sizeof(T)
 cconvert(::Type{Ptr{T}}, a::ReinterpretArray{T,N,S} where N) where {T,S} = cconvert(Ptr{S}, a.parent)
 
-@inline @propagate_inbounds function getindex(a::NonReshapedReinterpretArray{T,0,S}) where {T,S}
+@propagate_inbounds function getindex(a::NonReshapedReinterpretArray{T,0,S}) where {T,S}
     if isprimitivetype(T) && isprimitivetype(S)
         reinterpret(T, a.parent[])
     else
@@ -360,15 +360,24 @@ cconvert(::Type{Ptr{T}}, a::ReinterpretArray{T,N,S} where N) where {T,S} = cconv
     end
 end
 
-@inline @propagate_inbounds getindex(a::ReinterpretArray) = a[firstindex(a)]
+check_ptr_indexable(a::ReinterpretArray, sz = elsize(a)) = check_ptr_indexable(parent(a), sz)
+check_ptr_indexable(a::ReshapedArray, sz) = check_ptr_indexable(parent(a), sz)
+check_ptr_indexable(a::FastContiguousSubArray, sz) = check_ptr_indexable(parent(a), sz)
+check_ptr_indexable(a::Array, sz) = sizeof(eltype(a)) !== sz
+check_ptr_indexable(a::Memory, sz) = true
+check_ptr_indexable(a::AbstractArray, sz) = false
 
-@inline @propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, inds::Vararg{Int, N}) where {T,N,S}
+@propagate_inbounds getindex(a::ReinterpretArray) = a[firstindex(a)]
+
+@propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, inds::Vararg{Int, N}) where {T,N,S}
     check_readable(a)
+    check_ptr_indexable(a) && return _getindex_ptr(a, inds...)
     _getindex_ra(a, inds[1], tail(inds))
 end
 
-@inline @propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, i::Int) where {T,N,S}
+@propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, i::Int) where {T,N,S}
     check_readable(a)
+    check_ptr_indexable(a) && return _getindex_ptr(a, i)
     if isa(IndexStyle(a), IndexLinear)
         return _getindex_ra(a, i, ())
     end
@@ -378,16 +387,22 @@ end
     isempty(inds) ? _getindex_ra(a, 1, ()) : _getindex_ra(a, inds[1], tail(inds))
 end
 
-@inline @propagate_inbounds function getindex(a::ReshapedReinterpretArray{T,N,S}, ind::SCartesianIndex2) where {T,N,S}
+@propagate_inbounds function getindex(a::ReshapedReinterpretArray{T,N,S}, ind::SCartesianIndex2) where {T,N,S}
     check_readable(a)
     s = Ref{S}(a.parent[ind.j])
-    GC.@preserve s begin
-        tptr = Ptr{T}(unsafe_convert(Ref{S}, s))
-        return unsafe_load(tptr, ind.i)
-    end
+    tptr = Ptr{T}(unsafe_convert(Ref{S}, s))
+    GC.@preserve s return unsafe_load(tptr, ind.i)
 end
 
-@inline @propagate_inbounds function _getindex_ra(a::NonReshapedReinterpretArray{T,N,S}, i1::Int, tailinds::TT) where {T,N,S,TT}
+@inline function _getindex_ptr(a::ReinterpretArray{T}, inds...) where {T}
+    @boundscheck checkbounds(a, inds...)
+    li = _to_linear_index(a, inds...)
+    ap = cconvert(Ptr{T}, a)
+    p = unsafe_convert(Ptr{T}, ap) + sizeof(T) * (li - 1)
+    GC.@preserve ap return unsafe_load(p)
+end
+
+@propagate_inbounds function _getindex_ra(a::NonReshapedReinterpretArray{T,N,S}, i1::Int, tailinds::TT) where {T,N,S,TT}
     # Make sure to match the scalar reinterpret if that is applicable
     if sizeof(T) == sizeof(S) && (fieldcount(T) + fieldcount(S)) == 0
         if issingletontype(T) # singleton types
@@ -443,7 +458,7 @@ end
     end
 end
 
-@inline @propagate_inbounds function _getindex_ra(a::ReshapedReinterpretArray{T,N,S}, i1::Int, tailinds::TT) where {T,N,S,TT}
+@propagate_inbounds function _getindex_ra(a::ReshapedReinterpretArray{T,N,S}, i1::Int, tailinds::TT) where {T,N,S,TT}
     # Make sure to match the scalar reinterpret if that is applicable
     if sizeof(T) == sizeof(S) && (fieldcount(T) + fieldcount(S)) == 0
         if issingletontype(T) # singleton types
@@ -490,7 +505,7 @@ end
     end
 end
 
-@inline @propagate_inbounds function setindex!(a::NonReshapedReinterpretArray{T,0,S}, v) where {T,S}
+@propagate_inbounds function setindex!(a::NonReshapedReinterpretArray{T,0,S}, v) where {T,S}
     if isprimitivetype(S) && isprimitivetype(T)
         a.parent[] = reinterpret(S, v)
         return a
@@ -498,15 +513,17 @@ end
     setindex!(a, v, firstindex(a))
 end
 
-@inline @propagate_inbounds setindex!(a::ReinterpretArray, v) = setindex!(a, v, firstindex(a))
+@propagate_inbounds setindex!(a::ReinterpretArray, v) = setindex!(a, v, firstindex(a))
 
-@inline @propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, inds::Vararg{Int, N}) where {T,N,S}
+@propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, inds::Vararg{Int, N}) where {T,N,S}
     check_writable(a)
+    check_ptr_indexable(a) && return _setindex_ptr!(a, v, inds...)
     _setindex_ra!(a, v, inds[1], tail(inds))
 end
 
-@inline @propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, i::Int) where {T,N,S}
+@propagate_inbounds function setindex!(a::ReinterpretArray{T,N,S}, v, i::Int) where {T,N,S}
     check_writable(a)
+    check_ptr_indexable(a) && return _setindex_ptr!(a, v, i)
     if isa(IndexStyle(a), IndexLinear)
         return _setindex_ra!(a, v, i, ())
     end
@@ -514,7 +531,7 @@ end
     _setindex_ra!(a, v, inds[1], tail(inds))
 end
 
-@inline @propagate_inbounds function setindex!(a::ReshapedReinterpretArray{T,N,S}, v, ind::SCartesianIndex2) where {T,N,S}
+@propagate_inbounds function setindex!(a::ReshapedReinterpretArray{T,N,S}, v, ind::SCartesianIndex2) where {T,N,S}
     check_writable(a)
     v = convert(T, v)::T
     s = Ref{S}(a.parent[ind.j])
@@ -526,7 +543,16 @@ end
     return a
 end
 
-@inline @propagate_inbounds function _setindex_ra!(a::NonReshapedReinterpretArray{T,N,S}, v, i1::Int, tailinds::TT) where {T,N,S,TT}
+@inline function _setindex_ptr!(a::ReinterpretArray{T}, v, inds...) where {T}
+    @boundscheck checkbounds(a, inds...)
+    li = _to_linear_index(a, inds...)
+    ap = cconvert(Ptr{T}, a)
+    p = unsafe_convert(Ptr{T}, ap) + sizeof(T) * (li - 1)
+    GC.@preserve ap unsafe_store!(p, v)
+    return a
+end
+
+@propagate_inbounds function _setindex_ra!(a::NonReshapedReinterpretArray{T,N,S}, v, i1::Int, tailinds::TT) where {T,N,S,TT}
     v = convert(T, v)::T
     # Make sure to match the scalar reinterpret if that is applicable
     if sizeof(T) == sizeof(S) && (fieldcount(T) + fieldcount(S)) == 0
@@ -599,7 +625,7 @@ end
     return a
 end
 
-@inline @propagate_inbounds function _setindex_ra!(a::ReshapedReinterpretArray{T,N,S}, v, i1::Int, tailinds::TT) where {T,N,S,TT}
+@propagate_inbounds function _setindex_ra!(a::ReshapedReinterpretArray{T,N,S}, v, i1::Int, tailinds::TT) where {T,N,S,TT}
     v = convert(T, v)::T
     # Make sure to match the scalar reinterpret if that is applicable
     if sizeof(T) == sizeof(S) && (fieldcount(T) + fieldcount(S)) == 0
diff --git a/test/reinterpretarray.jl b/test/reinterpretarray.jl
index 501e9f4a9b57f..05a40895b7934 100644
--- a/test/reinterpretarray.jl
+++ b/test/reinterpretarray.jl
@@ -6,20 +6,28 @@ using .Main.OffsetArrays
 isdefined(Main, :TSlow) || @eval Main include("testhelpers/arrayindexingtypes.jl")
 using .Main: TSlow, WrapperArray
 
+tslow(a::AbstractArray) = TSlow(a)
+wrapper(a::AbstractArray) = WrapperArray(a)
+fcviews(a::AbstractArray) = view(a, ntuple(Returns(:),ndims(a)-1)..., axes(a)[end])
+fcviews(a::AbstractArray{<:Any, 0}) = view(a)
+tslow(t::Tuple) = map(tslow, t)
+wrapper(t::Tuple) = map(wrapper, t)
+fcviews(t::Tuple) = map(fcviews, t)
+
+test_many_wrappers(testf, A, wrappers) = foreach(w -> testf(w(A)), wrappers)
+test_many_wrappers(testf, A) = test_many_wrappers(testf, A, (identity, tslow, wrapper, fcviews))
+
 A = Int64[1, 2, 3, 4]
-As = TSlow(A)
 Ars = Int64[1 3; 2 4]
-Arss = TSlow(Ars)
 B = Complex{Int64}[5+6im, 7+8im, 9+10im]
-Bs = TSlow(B)
 Av = [Int32[1,2], Int32[3,4]]
 
-for Ar in (Ars, Arss)
+test_many_wrappers(Ars, (identity, tslow)) do Ar
     @test @inferred(ndims(reinterpret(reshape, Complex{Int64}, Ar))) == 1
     @test @inferred(axes(reinterpret(reshape, Complex{Int64}, Ar))) === (Base.OneTo(2),)
     @test @inferred(size(reinterpret(reshape, Complex{Int64}, Ar))) == (2,)
 end
-for _B in (B, Bs)
+test_many_wrappers(B, (identity, tslow)) do _B
     @test @inferred(ndims(reinterpret(reshape, Int64, _B))) == 2
     @test @inferred(axes(reinterpret(reshape, Int64, _B))) === (Base.OneTo(2), Base.OneTo(3))
     @test @inferred(size(reinterpret(reshape, Int64, _B))) == (2, 3)
@@ -42,24 +50,25 @@ end
 @test_throws ArgumentError("cannot reinterpret a zero-dimensional `UInt8` array to `UInt16` which is of a larger size") reinterpret(reshape, UInt16, reshape([0x01]))
 
 # getindex
-for _A in (A, As)
+test_many_wrappers(A) do _A
     @test reinterpret(Complex{Int64}, _A) == [1 + 2im, 3 + 4im]
     @test reinterpret(Float64, _A) == reinterpret.(Float64, A)
     @test reinterpret(reshape, Float64, _A) == reinterpret.(Float64, A)
 end
-for Ar in (Ars, Arss)
+test_many_wrappers(Ars) do Ar
     @test reinterpret(reshape, Complex{Int64}, Ar) == [1 + 2im, 3 + 4im]
     @test reinterpret(reshape, Float64, Ar) == reinterpret.(Float64, Ars)
 end
 
-for _B in (B, Bs)
+test_many_wrappers(B) do _B
     @test reinterpret(NTuple{3, Int64}, _B) == [(5,6,7),(8,9,10)]
     @test reinterpret(reshape, Int64, _B) == [5 7 9; 6 8 10]
 end
 
 # setindex
-for (_A, Ar, _B) in ((A, Ars, B), (As, Arss, Bs))
-    let Ac = copy(_A), Arsc = copy(Ar), Bc = copy(_B)
+test_many_wrappers((A, Ars, B)) do (A, Ars, B)
+    _A, Ar, _B = deepcopy(A), deepcopy(Ars), deepcopy(B)
+    let Ac = deepcopy(_A), Arsc = deepcopy(Ar), Bc = deepcopy(_B)
         reinterpret(Complex{Int64}, Ac)[2] = -1 - 2im
         @test Ac == [1, 2, -1, -2]
         reinterpret(Complex{Int64}, Arsc)[2] = -1 - 2im
@@ -94,50 +103,67 @@ for (_A, Ar, _B) in ((A, Ars, B), (As, Arss, Bs))
     end
 end
 A3 = collect(reshape(1:18, 2, 3, 3))
-A3r = reinterpret(reshape, Complex{Int}, A3)
-@test A3r[4] === A3r[1,2] === A3r[CartesianIndex(1, 2)] === 7+8im
-A3r[2,3] = -8-15im
-@test A3[1,2,3] == -8
-@test A3[2,2,3] == -15
-A3r[4] = 100+200im
-@test A3[1,1,2] == 100
-@test A3[2,1,2] == 200
-A3r[CartesianIndex(1,2)] = 300+400im
-@test A3[1,1,2] == 300
-@test A3[2,1,2] == 400
+test_many_wrappers(A3) do A3_
+    A3 = deepcopy(A3_)
+    A3r = reinterpret(reshape, Complex{Int}, A3)
+    @test A3r[4] === A3r[1,2] === A3r[CartesianIndex(1, 2)] === 7+8im
+    A3r[2,3] = -8-15im
+    @test A3[1,2,3] == -8
+    @test A3[2,2,3] == -15
+    A3r[4] = 100+200im
+    @test A3[1,1,2] == 100
+    @test A3[2,1,2] == 200
+    A3r[CartesianIndex(1,2)] = 300+400im
+    @test A3[1,1,2] == 300
+    @test A3[2,1,2] == 400
+end
 
 # same-size reinterpret where one of the types is non-primitive
-let a = NTuple{4,UInt8}[(0x01,0x02,0x03,0x04)], ra = reinterpret(Float32, a)
-    @test ra[1] == reinterpret(Float32, 0x04030201)
-    @test setindex!(ra, 2.0) === ra
-    @test reinterpret(Float32, a)[1] == 2.0
+let a = NTuple{4,UInt8}[(0x01,0x02,0x03,0x04)]
+    test_many_wrappers(a, (identity, wrapper, fcviews)) do a_
+        a = deepcopy(a_)
+        ra = reinterpret(Float32, a)
+        @test ra[1] == reinterpret(Float32, 0x04030201)
+        @test setindex!(ra, 2.0) === ra
+        @test reinterpret(Float32, a)[1] == 2.0
+    end
 end
-let a = NTuple{4,UInt8}[(0x01,0x02,0x03,0x04)], ra = reinterpret(reshape, Float32, a)
-    @test ra[1] == reinterpret(Float32, 0x04030201)
-    @test setindex!(ra, 2.0) === ra
-    @test reinterpret(reshape, Float32, a)[1] == 2.0
+let a = NTuple{4,UInt8}[(0x01,0x02,0x03,0x04)]
+    test_many_wrappers(a, (identity, wrapper, fcviews)) do a_
+        a = deepcopy(a_)
+        ra = reinterpret(reshape, Float32, a)
+        @test ra[1] == reinterpret(Float32, 0x04030201)
+        @test setindex!(ra, 2.0) === ra
+        @test reinterpret(reshape, Float32, a)[1] == 2.0
+    end
 end
 
 # Pass-through indexing
 B = Complex{Int64}[5+6im, 7+8im, 9+10im]
-Br = reinterpret(reshape, Int64, B)
-W = WrapperArray(Br)
-for (b, w) in zip(5:10, W)
-    @test b == w
-end
-for (i, j) in zip(eachindex(W), 11:16)
-    W[i] = j
+test_many_wrappers(B) do B_
+    B = deepcopy(B_)
+    Br = reinterpret(reshape, Int64, B)
+    W = WrapperArray(Br)
+    for (b, w) in zip(5:10, W)
+        @test b == w
+    end
+    for (i, j) in zip(eachindex(W), 11:16)
+        W[i] = j
+    end
+    @test B[1] === Complex{Int64}(11+12im)
+    @test B[2] === Complex{Int64}(13+14im)
+    @test B[3] === Complex{Int64}(15+16im)
 end
-@test B[1] === Complex{Int64}(11+12im)
-@test B[2] === Complex{Int64}(13+14im)
-@test B[3] === Complex{Int64}(15+16im)
 z3 = (0x00, 0x00, 0x00)
 Az = [z3 z3; z3 z3]
-Azr = reinterpret(reshape, UInt8, Az)
-W = WrapperArray(Azr)
-copyto!(W, fill(0x01, 3, 2, 2))
-@test all(isequal((0x01, 0x01, 0x01)), Az)
-@test eachindex(W, W) == eachindex(W)
+test_many_wrappers(Az, (identity, wrapper)) do Az_
+    Az = deepcopy(Az_)
+    Azr = reinterpret(reshape, UInt8, Az)
+    W = WrapperArray(Azr)
+    copyto!(W, fill(0x01, 3, 2, 2))
+    @test all(isequal((0x01, 0x01, 0x01)), Az)
+    @test eachindex(W, W) == eachindex(W)
+end
 
 # ensure that reinterpret arrays aren't erroneously classified as strided
 let A = reshape(1:20, 5, 4)
@@ -169,7 +195,7 @@ function check_strides(A::AbstractArray)
 end
 
 @testset "strides for NonReshapedReinterpretArray" begin
-    A = Array{Int32}(reshape(1:88, 11, 8))
+    A = WrapperArray(Array{Int32}(reshape(1:88, 11, 8)))
     for viewax2 in (1:8, 1:2:6, 7:-1:1, 5:-2:1, 2:3:8, 7:-6:1, 3:5:11)
         # dim1 is contiguous
         for T in (Int16, Float32)
@@ -203,7 +229,7 @@ end
 end
 
 @testset "strides for ReshapedReinterpretArray" begin
-    A = Array{Int32}(reshape(1:192, 3, 8, 8))
+    A = WrapperArray(Array{Int32}(reshape(1:192, 3, 8, 8)))
     for viewax1 in (1:8, 1:2:8, 8:-1:1, 8:-2:1), viewax2 in (1:2, 4:-1:1)
         for T in (Int16, Float32)
             @test check_strides(reinterpret(reshape, T, view(A, 1:2, viewax1, viewax2)))
@@ -240,7 +266,8 @@ end
 end
 
 # IndexStyle
-let a = fill(1.0, 5, 3)
+test_many_wrappers(fill(1.0, 5, 3), (identity, wrapper)) do a_
+    a = deepcopy(a_)
     r = reinterpret(Int64, a)
     @test @inferred(IndexStyle(r)) == IndexLinear()
     fill!(r, 2)
@@ -293,14 +320,13 @@ let a = fill(1.0, 5, 3)
         @test setindex!(r, -5, goodinds...) === r
         @test r[goodinds...] == -5
     end
-
-    ar = [(1,2), (3,4)]
+end
+let ar = [(1,2), (3,4)]
     arr = reinterpret(reshape, Int, ar)
     @test @inferred(IndexStyle(arr)) == Base.IndexSCartesian2{2}()
     @test @inferred(eachindex(arr)) == Base.SCartesianIndices2{2}(Base.OneTo(2))
     @test @inferred(eachindex(arr, arr)) == Base.SCartesianIndices2{2}(Base.OneTo(2))
 end
-
 # Error on reinterprets that would expose padding
 struct S1
     a::Int8
@@ -314,11 +340,14 @@ end
 
 A1 = S1[S1(0, 0)]
 A2 = S2[S2(0, 0)]
-@test reinterpret(S1, A2)[1] == S1(0, 0)
-@test_throws Base.PaddingError (reinterpret(S1, A2)[1] = S2(1, 2))
-@test_throws Base.PaddingError reinterpret(S2, A1)[1]
-reinterpret(S2, A1)[1] = S2(1, 2)
-@test A1[1] == S1(1, 2)
+test_many_wrappers((A1, A2), (identity, wrapper)) do (A1_, A2_)
+    A1, A2 = deepcopy(A1_), deepcopy(A2_)
+    @test reinterpret(S1, A2)[1] == S1(0, 0)
+    @test_throws Base.PaddingError (reinterpret(S1, A2)[1] = S2(1, 2))
+    @test_throws Base.PaddingError reinterpret(S2, A1)[1]
+    reinterpret(S2, A1)[1] = S2(1, 2)
+    @test A1[1] == S1(1, 2)
+end
 
 # Unconventional axes
 let a = [0.1 0.2; 0.3 0.4], at = reshape([(i,i+1) for i = 1:2:8], 2, 2)
@@ -371,50 +400,59 @@ end
 
 # Test 0-dimensional Arrays
 A = zeros(UInt32)
-B = reinterpret(Int32, A)
-Brs = reinterpret(reshape,Int32, A)
-C = reinterpret(Tuple{UInt32}, A) # non-primitive type
-Crs = reinterpret(reshape, Tuple{UInt32}, A)  # non-primitive type
-@test size(B) == size(Brs) == size(C) == size(Crs) == ()
-@test axes(B) == axes(Brs) == axes(C) == axes(Crs) == ()
-@test setindex!(B, Int32(5)) === B
-@test B[] === Int32(5)
-@test Brs[] === Int32(5)
-@test C[] === (UInt32(5),)
-@test Crs[] === (UInt32(5),)
-@test A[] === UInt32(5)
-@test setindex!(Brs, Int32(12)) === Brs
-@test A[] === UInt32(12)
-@test setindex!(C, (UInt32(7),)) === C
-@test A[] === UInt32(7)
-@test setindex!(Crs, (UInt32(3),)) === Crs
-@test A[] === UInt32(3)
-
-
-a = [(1.0,2.0)]
-af = @inferred(reinterpret(reshape, Float64, a))
-anew = @inferred(reinterpret(reshape, Tuple{Float64,Float64}, vec(af)))
-@test anew[1] == a[1]
-@test ndims(anew) == 0
+test_many_wrappers(A, (identity, wrapper)) do A_
+    A = deepcopy(A_)
+    B = reinterpret(Int32, A)
+    Brs = reinterpret(reshape,Int32, A)
+    C = reinterpret(Tuple{UInt32}, A) # non-primitive type
+    Crs = reinterpret(reshape, Tuple{UInt32}, A)  # non-primitive type
+    @test size(B) == size(Brs) == size(C) == size(Crs) == ()
+    @test axes(B) == axes(Brs) == axes(C) == axes(Crs) == ()
+    @test setindex!(B, Int32(5)) === B
+    @test B[] === Int32(5)
+    @test Brs[] === Int32(5)
+    @test C[] === (UInt32(5),)
+    @test Crs[] === (UInt32(5),)
+    @test A[] === UInt32(5)
+    @test setindex!(Brs, Int32(12)) === Brs
+    @test A[] === UInt32(12)
+    @test setindex!(C, (UInt32(7),)) === C
+    @test A[] === UInt32(7)
+    @test setindex!(Crs, (UInt32(3),)) === Crs
+    @test A[] === UInt32(3)
+end
+
+test_many_wrappers([(1.0,2.0)], (identity, wrapper)) do a
+    af = @inferred(reinterpret(reshape, Float64, a))
+    anew = @inferred(reinterpret(reshape, Tuple{Float64,Float64}, vec(af)))
+    @test anew[1] == a[1]
+    @test ndims(anew) == 0
+end
 
 # re-reinterpret
 a0 = reshape([0x22, 0x44, 0x88, 0xf0, 0x01, 0x02, 0x03, 0x04], 4, 2)
-a = reinterpret(reshape, NTuple{4,UInt8}, a0)
-@test a == [(0x22, 0x44, 0x88, 0xf0), (0x01, 0x02, 0x03, 0x04)]
-@test reinterpret(UInt8, a) == [0x22, 0x44, 0x88, 0xf0, 0x01, 0x02, 0x03, 0x04]
-@test reinterpret(reshape, UInt8, a) === a0
+test_many_wrappers(a0, (identity, wrapper)) do a0
+    a = reinterpret(reshape, NTuple{4,UInt8}, a0)
+    @test a == [(0x22, 0x44, 0x88, 0xf0), (0x01, 0x02, 0x03, 0x04)]
+    @test reinterpret(UInt8, a) == [0x22, 0x44, 0x88, 0xf0, 0x01, 0x02, 0x03, 0x04]
+    @test reinterpret(reshape, UInt8, a) === a0
+end
 
 # reductions
 a = [(1,2,3), (4,5,6)]
-ars = reinterpret(reshape, Int, a)
-@test sum(ars) == 21
-@test sum(ars; dims=1) == [6 15]
-@test sum(ars; dims=2) == reshape([5,7,9], (3, 1))
-@test sum(ars; dims=(1,2)) == reshape([21], (1, 1))
+test_many_wrappers(a, (identity, wrapper)) do a
+    ars = reinterpret(reshape, Int, a)
+    @test sum(ars) == 21
+    @test sum(ars; dims=1) == [6 15]
+    @test sum(ars; dims=2) == reshape([5,7,9], (3, 1))
+    @test sum(ars; dims=(1,2)) == reshape([21], (1, 1))
+end
 # also test large sizes for the pairwise algorithm
 a = [(k,k+1,k+2) for k = 1:3:4000]
-ars = reinterpret(reshape, Int, a)
-@test sum(ars) == 8010003
+test_many_wrappers(a, (identity, wrapper)) do a
+    ars = reinterpret(reshape, Int, a)
+    @test sum(ars) == 8010003
+end
 
 @testset "similar(::ReinterpretArray)" begin
     a = reinterpret(NTuple{2,Float64}, TSlow(rand(Float64, 4, 4)))
@@ -514,6 +552,21 @@ end
     @test_throws MethodError x[2,4] = nothing
 end
 
+@testset "pointer for StridedArray" begin
+    a = rand(Float64, 251)
+    v = view(a, UInt(2):UInt(251));
+    A = reshape(v, 25, 10);
+    @test A isa StridedArray && pointer(A) === pointer(a, 2)
+    Av = view(A, 1:20, 1:2)
+    @test Av isa StridedArray && pointer(Av) === pointer(a, 2)
+    @test Av * Av' isa Array
+end
+
+@testset "effect of StridedReinterpretArray's getindex" begin
+    eff = Base.infer_effects(getindex, Base.typesof(reinterpret(Int8, Int[1]), 1))
+    @test Core.Compiler.is_effect_free(eff)
+end
+
 # reinterpret of arbitrary bitstypes
 @testset "Reinterpret arbitrary bitstypes" begin
     struct Bytes15
diff --git a/test/testhelpers/arrayindexingtypes.jl b/test/testhelpers/arrayindexingtypes.jl
index 0e956b5216c94..95c1f18e00903 100644
--- a/test/testhelpers/arrayindexingtypes.jl
+++ b/test/testhelpers/arrayindexingtypes.jl
@@ -66,3 +66,6 @@ Base.axes(A::WrapperArray) = axes(A.parent)
 Base.getindex(A::WrapperArray, i::Int...) = A.parent[i...]
 Base.setindex!(A::WrapperArray, v, i::Int...) = A.parent[i...] = v
 Base.similar(A::WrapperArray, ::Type{T}, dims::Dims) where T = similar(A.parent, T, dims)
+Base.cconvert(::Type{Ptr{T}}, A::WrapperArray{T}) where {T} = Base.cconvert(Ptr{T}, A.parent)
+Base.strides(A::WrapperArray) = strides(A.parent)
+Base.elsize(::Type{WrapperArray{T,N,A}}) where {T,N,A<:AbstractArray{T,N}} = Base.elsize(A)

From cd78e6f85aa4f3ffd26751726738e97113d1b6d8 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 8 Nov 2023 10:42:50 -0500
Subject: [PATCH 0211/1315] make sigaltstack failure nonfatal and clean up on
 thread return (#52055)

Since we already could handle recursion onto the altstack, we can also
handle recursion onto the main stack as well (at the cost of losing the
ability to handle stackoverflow when this allocation fails). In the
future, on mach, we could consider just using a single stack for
handling stackoverflow and use a `_resetstkoflw`-like and/or
`collect_backtrace_fiber`-like mechanism (like Windows) to pass it from
one thread to the next that sequentially needs to use it.

Closes #50786
---
 src/gc-stacks.c       |  5 ++-
 src/julia_threads.h   |  1 +
 src/signal-handling.c |  4 +--
 src/signals-mach.c    |  5 +--
 src/signals-unix.c    | 81 ++++++++++++++++++++++++-------------------
 src/signals-win.c     |  2 +-
 src/threading.c       | 24 +++++++++++++
 7 files changed, 80 insertions(+), 42 deletions(-)

diff --git a/src/gc-stacks.c b/src/gc-stacks.c
index 86c1c8a573a68..0318162289f11 100644
--- a/src/gc-stacks.c
+++ b/src/gc-stacks.c
@@ -208,7 +208,10 @@ void sweep_stack_pools(void)
         for (int p = 0; p < JL_N_STACK_POOLS; p++) {
             small_arraylist_t *al = &ptls2->heap.free_stacks[p];
             size_t n_to_free;
-            if (al->len > MIN_STACK_MAPPINGS_PER_POOL) {
+            if (jl_atomic_load_relaxed(&ptls2->current_task) == NULL) {
+                n_to_free = al->len; // not alive yet or dead, so it does not need these anymore
+            }
+            else if (al->len > MIN_STACK_MAPPINGS_PER_POOL) {
                 n_to_free = al->len / 2;
                 if (n_to_free > (al->len - MIN_STACK_MAPPINGS_PER_POOL))
                     n_to_free = al->len - MIN_STACK_MAPPINGS_PER_POOL;
diff --git a/src/julia_threads.h b/src/julia_threads.h
index 332ff53ab086d..220e31403b0d4 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -263,6 +263,7 @@ typedef struct _jl_tls_states_t {
     int needs_resetstkoflw;
 #else
     void *signal_stack;
+    size_t signal_stack_size;
 #endif
     jl_thread_t system_id;
     _Atomic(int16_t) suspend_count;
diff --git a/src/signal-handling.c b/src/signal-handling.c
index 6c2702a5604d6..00bc9d9d8aabb 100644
--- a/src/signal-handling.c
+++ b/src/signal-handling.c
@@ -463,9 +463,9 @@ void jl_critical_error(int sig, int si_code, bt_context_t *context, jl_task_t *c
         pthread_sigmask(SIG_UNBLOCK, &sset, NULL);
 #endif
         if (si_code)
-            jl_safe_printf("\n[%d] signal (%d.%d): %s\n", getpid(), sig, si_code, strsignal(sig));
+            jl_safe_printf("\n[%d] signal %d (%d): %s\n", getpid(), sig, si_code, strsignal(sig));
         else
-            jl_safe_printf("\n[%d] signal (%d): %s\n", getpid(), sig, strsignal(sig));
+            jl_safe_printf("\n[%d] signal %d: %s\n", getpid(), sig, strsignal(sig));
     }
     jl_safe_printf("in expression starting at %s:%d\n", jl_filename, jl_lineno);
     if (context && ct) {
diff --git a/src/signals-mach.c b/src/signals-mach.c
index ebc54d35a5b46..b7ab8ecaf8ef6 100644
--- a/src/signals-mach.c
+++ b/src/signals-mach.c
@@ -213,13 +213,14 @@ static void jl_call_in_state(jl_ptls_t ptls2, host_thread_state_t *state,
 #else
 #error "julia: throw-in-context not supported on this platform"
 #endif
-    if (ptls2 == NULL || ptls2->signal_stack == NULL || is_addr_on_sigstack(ptls2, (void*)rsp)) {
+    if (ptls2 == NULL || is_addr_on_sigstack(ptls2, (void*)rsp)) {
         rsp = (rsp - 256) & ~(uintptr_t)15; // redzone and re-alignment
     }
     else {
-        rsp = (uintptr_t)ptls2->signal_stack + sig_stack_size;
+        rsp = (uintptr_t)ptls2->signal_stack + (ptls2->signal_stack_size ? ptls2->signal_stack_size : sig_stack_size);
     }
     assert(rsp % 16 == 0);
+    rsp -= 16;
 
 #ifdef _CPU_X86_64_
     rsp -= sizeof(void*);
diff --git a/src/signals-unix.c b/src/signals-unix.c
index 07d6d0bb72cc1..eb51a5fccfaba 100644
--- a/src/signals-unix.c
+++ b/src/signals-unix.c
@@ -35,10 +35,8 @@
 #include <sys/event.h>
 #endif
 
-// 8M signal stack, same as default stack size and enough
-// for reasonable finalizers.
-// Should also be enough for parallel GC when we have it =)
-#define sig_stack_size (8 * 1024 * 1024)
+// 8M signal stack, same as default stack size (though we barely use this)
+static const size_t sig_stack_size = 8 * 1024 * 1024;
 
 #include "julia_assert.h"
 
@@ -94,8 +92,9 @@ static inline __attribute__((unused)) uintptr_t jl_get_rsp_from_ctx(const void *
 static int is_addr_on_sigstack(jl_ptls_t ptls, void *ptr)
 {
     // One guard page for signal_stack.
-    return !((char*)ptr < (char*)ptls->signal_stack - jl_page_size ||
-             (char*)ptr > (char*)ptls->signal_stack + sig_stack_size);
+    return ptls->signal_stack == NULL ||
+           ((char*)ptr >= (char*)ptls->signal_stack - jl_page_size &&
+            (char*)ptr <= (char*)ptls->signal_stack + (ptls->signal_stack_size ? ptls->signal_stack_size : sig_stack_size));
 }
 
 // Modify signal context `_ctx` so that `fptr` will execute when the signal
@@ -111,7 +110,7 @@ JL_NO_ASAN static void jl_call_in_ctx(jl_ptls_t ptls, void (*fptr)(void), int si
     // checks that the syscall is made in the signal handler and that
     // the ucontext address is valid. Hopefully the value of the ucontext
     // will not be part of the validation...
-    if (!ptls || !ptls->signal_stack) {
+    if (!ptls) {
         sigset_t sset;
         sigemptyset(&sset);
         sigaddset(&sset, sig);
@@ -120,13 +119,12 @@ JL_NO_ASAN static void jl_call_in_ctx(jl_ptls_t ptls, void (*fptr)(void), int si
         return;
     }
     uintptr_t rsp = jl_get_rsp_from_ctx(_ctx);
-    if (is_addr_on_sigstack(ptls, (void*)rsp)) {
+    if (is_addr_on_sigstack(ptls, (void*)rsp))
         rsp = (rsp - 256) & ~(uintptr_t)15; // redzone and re-alignment
-    }
-    else {
-        rsp = (uintptr_t)ptls->signal_stack + sig_stack_size;
-    }
+    else
+        rsp = (uintptr_t)ptls->signal_stack + (ptls->signal_stack_size ? ptls->signal_stack_size : sig_stack_size);
     assert(rsp % 16 == 0);
+    rsp -= 16;
 #if defined(_OS_LINUX_) && defined(_CPU_X86_64_)
     ucontext_t *ctx = (ucontext_t*)_ctx;
     rsp -= sizeof(void*);
@@ -229,7 +227,10 @@ static void sigdie_handler(int sig, siginfo_t *info, void *context)
     uv_tty_reset_mode();
     if (sig == SIGILL)
         jl_show_sigill(context);
-    jl_critical_error(sig, info->si_code, jl_to_bt_context(context), jl_get_current_task());
+    jl_task_t *ct = jl_get_current_task();
+    jl_critical_error(sig, info->si_code, jl_to_bt_context(context), ct);
+    if (ct)
+        jl_atomic_store_relaxed(&ct->ptls->safepoint, (size_t*)NULL + 1);
     if (info->si_code == 0 ||
         info->si_code == SI_USER ||
 #ifdef SI_KERNEL
@@ -252,7 +253,8 @@ static void sigdie_handler(int sig, siginfo_t *info, void *context)
              sig != SIGFPE &&
              sig != SIGTRAP)
         raise(sig);
-    // fall-through return to re-execute faulting statement (but without the error handler)
+    // fall-through return to re-execute faulting statement (but without the
+    // error handler and the pgcstack having been destroyed)
 }
 
 #if defined(_CPU_X86_64_) || defined(_CPU_X86_)
@@ -343,7 +345,8 @@ int is_write_fault(void *context) {
 
 static int jl_is_on_sigstack(jl_ptls_t ptls, void *ptr, void *context)
 {
-    return (is_addr_on_sigstack(ptls, ptr) &&
+    return (ptls->signal_stack != NULL &&
+            is_addr_on_sigstack(ptls, ptr) &&
             is_addr_on_sigstack(ptls, (void*)jl_get_rsp_from_ctx(context)));
 }
 
@@ -635,30 +638,36 @@ static void allocate_segv_handler(void)
     }
 }
 
-static void *alloc_sigstack(size_t *ssize)
-{
-    void *stk = jl_malloc_stack(ssize, NULL);
-    if (stk == NULL)
-        jl_errorf("fatal error allocating signal stack: mmap: %s", strerror(errno));
-    return stk;
-}
-
 void jl_install_thread_signal_handler(jl_ptls_t ptls)
 {
-    size_t ssize = sig_stack_size;
-    void *signal_stack = alloc_sigstack(&ssize);
-    ptls->signal_stack = signal_stack;
-    stack_t ss;
-    ss.ss_flags = 0;
-    ss.ss_size = ssize - 16;
-    ss.ss_sp = signal_stack;
-    if (sigaltstack(&ss, NULL) < 0) {
-        jl_errorf("fatal error: sigaltstack: %s", strerror(errno));
-    }
-
 #ifdef HAVE_MACH
     attach_exception_port(pthread_mach_thread_np(ptls->system_id), 0);
 #endif
+    stack_t ss;
+    if (sigaltstack(NULL, &ss) < 0)
+        jl_errorf("fatal error: sigaltstack: %s", strerror(errno));
+    if ((ss.ss_flags & SS_DISABLE) != SS_DISABLE)
+        return; // someone else appears to have already set this up, so just use that
+    size_t ssize = sig_stack_size;
+    void *signal_stack = jl_malloc_stack(&ssize, NULL);
+    ss.ss_flags = 0;
+    ss.ss_size = ssize;
+    assert(ssize != 0);
+    if (signal_stack == NULL) {
+        signal_stack = malloc(ssize);
+        ssize = 0;
+        if (signal_stack == NULL)
+            jl_safe_printf("\nwarning: julia signal alt stack could not be allocated (StackOverflowError will be fatal on this thread).\n");
+        else
+            jl_safe_printf("\nwarning: julia signal stack allocated without guard page (launch foreign threads earlier to avoid this warning).\n");
+    }
+    if (signal_stack != NULL) {
+        ss.ss_sp = signal_stack;
+        if (sigaltstack(&ss, NULL) < 0)
+            jl_errorf("fatal error: sigaltstack: %s", strerror(errno));
+        ptls->signal_stack = signal_stack;
+        ptls->signal_stack_size = ssize;
+    }
 }
 
 const static int sigwait_sigs[] = {
@@ -1029,7 +1038,7 @@ void jl_install_default_signal_handlers(void)
     memset(&actf, 0, sizeof(struct sigaction));
     sigemptyset(&actf.sa_mask);
     actf.sa_sigaction = fpe_handler;
-    actf.sa_flags = SA_ONSTACK | SA_SIGINFO;
+    actf.sa_flags = SA_SIGINFO;
     if (sigaction(SIGFPE, &actf, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
@@ -1038,7 +1047,7 @@ void jl_install_default_signal_handlers(void)
     memset(&acttrap, 0, sizeof(struct sigaction));
     sigemptyset(&acttrap.sa_mask);
     acttrap.sa_sigaction = sigtrap_handler;
-    acttrap.sa_flags = SA_ONSTACK | SA_SIGINFO;
+    acttrap.sa_flags = SA_SIGINFO;
     if (sigaction(SIGTRAP, &acttrap, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
diff --git a/src/signals-win.c b/src/signals-win.c
index 10bd0dec7f480..f763b71e1cf32 100644
--- a/src/signals-win.c
+++ b/src/signals-win.c
@@ -4,7 +4,7 @@
 // Note that this file is `#include`d by "signal-handling.c"
 #include <mmsystem.h> // hidden by LEAN_AND_MEAN
 
-#define sig_stack_size 131072 // 128k reserved for SEGV handling
+static const size_t sig_stack_size = 131072; // 128k reserved for backtrace_fiber for stack overflow handling
 
 // Copied from MINGW_FLOAT_H which may not be found due to a collision with the builtin gcc float.h
 // eventually we can probably integrate this into OpenLibm.
diff --git a/src/threading.c b/src/threading.c
index e4735594ffaeb..18c502cf94387 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -447,6 +447,30 @@ static void jl_delete_thread(void *value) JL_NOTSAFEPOINT_ENTER
     jl_atomic_store_relaxed(&ptls->sleep_check_state, 2); // dead, interpreted as sleeping and unwakeable
     jl_fence();
     jl_wakeup_thread(0); // force thread 0 to see that we do not have the IO lock (and am dead)
+    // try to free some state we do not need anymore
+#ifndef _OS_WINDOWS_
+    void *signal_stack = ptls->signal_stack;
+    size_t signal_stack_size = ptls->signal_stack_size;
+    if (signal_stack != NULL) {
+        stack_t ss;
+        if (sigaltstack(NULL, &ss))
+            jl_errorf("fatal error: sigaltstack: %s", strerror(errno));
+        if (ss.ss_sp == signal_stack) {
+            ss.ss_flags = SS_DISABLE;
+            if (sigaltstack(&ss, NULL) != 0) {
+                jl_errorf("warning: sigaltstack: %s (will leak this memory)", strerror(errno));
+                signal_stack = NULL;
+            }
+        }
+        if (signal_stack != NULL) {
+            if (signal_stack_size)
+                jl_free_stack(signal_stack, signal_stack_size);
+            else
+                free(signal_stack);
+        }
+        ptls->signal_stack = NULL;
+    }
+#endif
     // Acquire the profile write lock, to ensure we are not racing with the `kill`
     // call in the profile code which will also try to look at this thread.
     // We have no control over when the user calls pthread_join, so we must do

From e1150db4935695ba2eaa2737111b0237a947b397 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 9 Nov 2023 01:15:37 +0900
Subject: [PATCH 0212/1315] define and use an internal macro to introduce
 `Expr(:boundscheck)` (#52077)

To avoid the previous uses of `eval` just to manually introduce
`Expr(:boundscheck)`. The new macro is named `@_boundscheck` and is
intended for internal use only, streamlining our codebase a bit.
---
 base/Base.jl              |  2 ++
 base/boot.jl              | 25 +++++++++++++------------
 base/compiler/compiler.jl |  2 ++
 base/essentials.jl        | 19 +++++++++----------
 base/genericmemory.jl     |  8 +++-----
 base/tuple.jl             |  4 ++--
 6 files changed, 31 insertions(+), 29 deletions(-)

diff --git a/base/Base.jl b/base/Base.jl
index 24f07dfef6de7..9d0a44b7a1f5d 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -34,6 +34,8 @@ ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Base, is_primary_base_module)
 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)
diff --git a/base/boot.jl b/base/boot.jl
index 30c340a3cc403..122fb3f40fa11 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -268,11 +268,12 @@ ccall(:jl_toplevel_eval_in, Any, (Any, Any),
 macro nospecialize(x)
     _expr(:meta, :nospecialize, x)
 end
+Expr(@nospecialize args...) = _expr(args...)
 
 _is_internal(__module__) = __module__ === Core
 # can be used in place of `@assume_effects :foldable` (supposed to be used for bootstrapping)
 macro _foldable_meta()
-    return _is_internal(__module__) && _expr(:meta, _expr(:purity,
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
         #=:consistent=#true,
         #=:effect_free=#true,
         #=:nothrow=#false,
@@ -283,6 +284,11 @@ macro _foldable_meta()
         #=:noub=#true))
 end
 
+macro inline()   Expr(:meta, :inline)   end
+macro noinline() Expr(:meta, :noinline) end
+
+macro _boundscheck() Expr(:boundscheck) end
+
 # n.b. the effects and model of these is refined in inference abstractinterpretation.jl
 TypeVar(@nospecialize(n)) = _typevar(n::Symbol, Union{}, Any)
 TypeVar(@nospecialize(n), @nospecialize(ub)) = _typevar(n::Symbol, Union{}, ub)
@@ -309,16 +315,11 @@ kwftype(@nospecialize(t)) = typeof(kwcall)
 Union{}(a...) = throw(ArgumentError("cannot construct a value of type Union{} for return result"))
 kwcall(kwargs, ::Type{Union{}}, a...) = Union{}(a...)
 
-Expr(@nospecialize args...) = _expr(args...)
-
 abstract type Exception end
 struct ErrorException <: Exception
     msg::AbstractString
 end
 
-macro inline()   Expr(:meta, :inline)   end
-macro noinline() Expr(:meta, :noinline) end
-
 struct BoundsError <: Exception
     a::Any
     i::Any
@@ -509,14 +510,14 @@ const undef = UndefInitializer()
 const Memory{T} = GenericMemory{:not_atomic, T, CPU}
 const MemoryRef{T} = GenericMemoryRef{:not_atomic, T, CPU}
 GenericMemoryRef(mem::GenericMemory) = memoryref(mem)
-eval(Core, :(GenericMemoryRef(ref::GenericMemoryRef, i::Integer) = memoryref(ref, Int(i), $(Expr(:boundscheck)))))
-eval(Core, :(GenericMemoryRef(mem::GenericMemory, i::Integer) = memoryref(memoryref(mem), Int(i), $(Expr(:boundscheck)))))
+GenericMemoryRef(ref::GenericMemoryRef, i::Integer) = memoryref(ref, Int(i), @_boundscheck)
+GenericMemoryRef(mem::GenericMemory, i::Integer) = memoryref(memoryref(mem), Int(i), @_boundscheck)
 MemoryRef(mem::Memory) = memoryref(mem)
-eval(Core, :(MemoryRef(ref::MemoryRef, i::Integer) = memoryref(ref, Int(i), $(Expr(:boundscheck)))))
-eval(Core, :(MemoryRef(mem::Memory, i::Integer) = memoryref(memoryref(mem), Int(i), $(Expr(:boundscheck)))))
+MemoryRef(ref::MemoryRef, i::Integer) = memoryref(ref, Int(i), @_boundscheck)
+MemoryRef(mem::Memory, i::Integer) = memoryref(memoryref(mem), Int(i), @_boundscheck)
 MemoryRef{T}(mem::Memory{T}) where {T} = memoryref(mem)
-eval(Core, :(MemoryRef{T}(ref::MemoryRef{T}, i::Integer) where {T} = memoryref(ref, Int(i), $(Expr(:boundscheck)))))
-eval(Core, :(MemoryRef{T}(mem::Memory{T}, i::Integer) where {T} = memoryref(memoryref(mem), Int(i), $(Expr(:boundscheck)))))
+MemoryRef{T}(ref::MemoryRef{T}, i::Integer) where {T} = memoryref(ref, Int(i), @_boundscheck)
+MemoryRef{T}(mem::Memory{T}, i::Integer) where {T} = memoryref(memoryref(mem), Int(i), @_boundscheck)
 
 # construction helpers for Array
 new_as_memoryref(self::Type{GenericMemoryRef{isatomic,T,addrspace}}, m::Int) where {T,isatomic,addrspace} = memoryref(fieldtype(self, :mem)(undef, m))
diff --git a/base/compiler/compiler.jl b/base/compiler/compiler.jl
index 997e6989312f3..b81268215578c 100644
--- a/base/compiler/compiler.jl
+++ b/base/compiler/compiler.jl
@@ -28,6 +28,8 @@ include(mod, x) = Core.include(mod, x)
 macro inline()   Expr(:meta, :inline)   end
 macro noinline() Expr(:meta, :noinline) end
 
+macro _boundscheck() Expr(:boundscheck) end
+
 convert(::Type{Any}, Core.@nospecialize x) = x
 convert(::Type{T}, x::T) where {T} = x
 
diff --git a/base/essentials.jl b/base/essentials.jl
index ece48a0e772ee..a8a3ec3c15382 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -13,8 +13,8 @@ length(a::Array) = getfield(getfield(getfield(a, :ref), :mem), :length)
 length(a::GenericMemory) = getfield(a, :length)
 throw_boundserror(A, I) = (@noinline; throw(BoundsError(A, I)))
 
-eval(:(getindex(A::GenericMemory{:not_atomic}, i::Int) = memoryrefget(memoryref(memoryref(A), i, $(Expr(:boundscheck))), :not_atomic, false)))
-eval(:(getindex(A::GenericMemoryRef{:not_atomic}) = memoryrefget(A, :not_atomic, $(Expr(:boundscheck)))))
+getindex(A::GenericMemory{:not_atomic}, i::Int) = memoryrefget(memoryref(memoryref(A), i, @_boundscheck), :not_atomic, false)
+getindex(A::GenericMemoryRef{:not_atomic}) = memoryrefget(A, :not_atomic, @_boundscheck)
 
 # multidimensional getindex will be defined later on
 
@@ -786,20 +786,19 @@ macro goto(name::Symbol)
 end
 
 # linear indexing
-eval(:(function getindex(A::Array, i::Int)
-        @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) || throw_boundserror(A, (i,))
-        memoryrefget(memoryref(getfield(A, :ref), i, false), :not_atomic, false)
-    end))
+function getindex(A::Array, i::Int)
+    @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) || throw_boundserror(A, (i,))
+    memoryrefget(memoryref(getfield(A, :ref), i, false), :not_atomic, false)
+end
 # simple Array{Any} operations needed for bootstrap
 function setindex!(A::Array{Any}, @nospecialize(x), i::Int)
     @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) || throw_boundserror(A, (i,))
     memoryrefset!(memoryref(getfield(A, :ref), i, false), x, :not_atomic, false)
     return A
 end
-@eval setindex!(A::Memory{Any}, @nospecialize(x), i::Int) = (memoryrefset!(memoryref(memoryref(A), i, $(Expr(:boundscheck))), x, :not_atomic, $(Expr(:boundscheck))); A)
-@eval setindex!(A::MemoryRef{T}, x) where {T} = memoryrefset!(A, convert(T, x), :not_atomic, $(Expr(:boundscheck)))
-@eval setindex!(A::MemoryRef{Any}, @nospecialize(x)) = memoryrefset!(A, x, :not_atomic, $(Expr(:boundscheck)))
-
+setindex!(A::Memory{Any}, @nospecialize(x), i::Int) = (memoryrefset!(memoryref(memoryref(A), i, @_boundscheck), x, :not_atomic, @_boundscheck); A)
+setindex!(A::MemoryRef{T}, x) where {T} = memoryrefset!(A, convert(T, x), :not_atomic, @_boundscheck)
+setindex!(A::MemoryRef{Any}, @nospecialize(x)) = memoryrefset!(A, x, :not_atomic, @_boundscheck)
 
 # SimpleVector
 
diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index ec33cb67a4097..06d64708113e3 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -64,7 +64,7 @@ function isassigned(a::Memory, i::Int)
     return @inbounds memoryref_isassigned(GenericMemoryRef(a, i), :not_atomic, false)
 end
 
-@eval isassigned(a::GenericMemoryRef) = memoryref_isassigned(a, :not_atomic, $(Expr(:boundscheck)))
+isassigned(a::GenericMemoryRef) = memoryref_isassigned(a, :not_atomic, @_boundscheck)
 
 ## copy ##
 function unsafe_copyto!(dest::MemoryRef{T}, src::MemoryRef{T}, n) where {T}
@@ -182,14 +182,12 @@ getindex(A::Memory, c::Colon) = copy(A)
 
 ## Indexing: setindex! ##
 
-@eval begin
 function setindex!(A::Memory{T}, x, i1::Int) where {T}
     val = x isa T ? x : convert(T,x)::T
-    ref = memoryref(memoryref(A), i1, $(Expr(:boundscheck)))
-    memoryrefset!(ref, val, :not_atomic, $(Expr(:boundscheck)))
+    ref = memoryref(memoryref(A), i1, @_boundscheck)
+    memoryrefset!(ref, val, :not_atomic, @_boundscheck)
     return A
 end
-end
 function setindex!(A::Memory{T}, x, i1::Int, i2::Int, I::Int...) where {T}
     @inline
     @boundscheck (i2 == 1 && all(==(1), I)) || throw_boundserror(A, (i1, i2, I...))
diff --git a/base/tuple.jl b/base/tuple.jl
index 339aafac171b1..c2e0a478cca48 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -28,8 +28,8 @@ firstindex(@nospecialize t::Tuple) = 1
 lastindex(@nospecialize t::Tuple) = length(t)
 size(@nospecialize(t::Tuple), d::Integer) = (d == 1) ? length(t) : throw(ArgumentError("invalid tuple dimension $d"))
 axes(@nospecialize t::Tuple) = (OneTo(length(t)),)
-@eval getindex(@nospecialize(t::Tuple), i::Int) = getfield(t, i, $(Expr(:boundscheck)))
-@eval getindex(@nospecialize(t::Tuple), i::Integer) = getfield(t, convert(Int, i), $(Expr(:boundscheck)))
+getindex(@nospecialize(t::Tuple), i::Int) = getfield(t, i, @_boundscheck)
+getindex(@nospecialize(t::Tuple), i::Integer) = getfield(t, convert(Int, i), @_boundscheck)
 __inbounds_getindex(@nospecialize(t::Tuple), i::Int) = getfield(t, i, false)
 __inbounds_getindex(@nospecialize(t::Tuple), i::Integer) = getfield(t, convert(Int, i), false)
 getindex(t::Tuple, r::AbstractArray{<:Any,1}) = (eltype(t)[t[ri] for ri in r]...,)

From 560ede55320577c6678c7d9fe2927fb63108b1b4 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 8 Nov 2023 22:01:22 +0530
Subject: [PATCH 0213/1315] Permit the construction of a 1D `StepRangeLen` of
 `CartesianIndex`es (#50457)

---
 base/multidimensional.jl | 14 ++++++++++++++
 test/ranges.jl           | 21 +++++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 9e0ad293345f4..d8646e4c261ed 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -83,6 +83,7 @@ module IteratorsMD
     CartesianIndex{N}(index::Integer...) where {N} = CartesianIndex{N}(index)
     CartesianIndex{N}() where {N} = CartesianIndex{N}(())
     # Un-nest passed CartesianIndexes
+    CartesianIndex{N}(index::CartesianIndex{N}) where {N} = index
     CartesianIndex(index::Union{Integer, CartesianIndex}...) = CartesianIndex(flatten(index))
     flatten(::Tuple{}) = ()
     flatten(I::Tuple{Any}) = Tuple(I[1])
@@ -166,6 +167,19 @@ module IteratorsMD
     Base.iterate(::CartesianIndex) =
         error("iteration is deliberately unsupported for CartesianIndex. Use `I` rather than `I...`, or use `Tuple(I)...`")
 
+    # ranges are deliberately disabled to prevent ambiguities with the colon constructor
+    Base.range_start_step_length(start::CartesianIndex, step::CartesianIndex, len::Integer) =
+        error("range with a specified length is deliberately unsupported for CartesianIndex arguments."*
+            " Use StepRangeLen($start, $step, $len) to construct this range")
+
+    # show is special-cased to avoid the start:stop:step display,
+    # which constructs a CartesianIndices
+    # See #50784
+    function show(io::IO, r::StepRangeLen{<:CartesianIndex})
+        print(io, "StepRangeLen(", first(r), ", ",
+                    step(r), ", ", length(r), ")")
+    end
+
     # Iteration
     const OrdinalRangeInt = OrdinalRange{Int, Int}
     """
diff --git a/test/ranges.jl b/test/ranges.jl
index e92fdcf2992fa..8933ab0047c86 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -2558,3 +2558,24 @@ end
     a = StepRangeLen(1,2,3,2)
     @test a[UInt(1)] == -1
 end
+
+@testset "StepRangeLen of CartesianIndex-es" begin
+    CIstart = CartesianIndex(2,3)
+    CIstep = CartesianIndex(1,1)
+    r = StepRangeLen(CIstart, CIstep, 4)
+    @test length(r) == 4
+    @test first(r) == CIstart
+    @test step(r) == CIstep
+    @test last(r) == CartesianIndex(5,6)
+    @test r[2] == CartesianIndex(3,4)
+
+    @test repr(r) == "StepRangeLen($CIstart, $CIstep, 4)"
+
+    r = StepRangeLen(CartesianIndex(), CartesianIndex(), 3)
+    @test all(==(CartesianIndex()), r)
+    @test length(r) == 3
+    @test repr(r) == "StepRangeLen(CartesianIndex(), CartesianIndex(), 3)"
+
+    errmsg = ("deliberately unsupported for CartesianIndex", "StepRangeLen")
+    @test_throws errmsg range(CartesianIndex(1), step=CartesianIndex(1), length=3)
+end

From 449c7a2504191a96cfd382e0dbc0b40bf922cd6d Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 8 Nov 2023 12:24:32 -0500
Subject: [PATCH 0214/1315] make UndefVarError messages more precise and
 informative (#51979)

Record the 'scope' of the variable that was undefined (the Module, or a
descriptive word such as :local or :static_parameter). Add that scope to
the error message, and expand the hint suggestions added by the REPL to
include more specific advice on common mistakes:

  - forgetting to set an initial value
  - forgetting to import a global
  - creating a local of the same name as a global
  - not matching a static parameter in a signature subtype

Fixes #17062 (although more could probably be done to search for typos
using REPL.string_distance and getting the method from stacktrace)
Fixes #18877
Fixes #25263
Fixes #35126
Fixes #39280
Fixes #41728
Fixes #48731
Fixes #49917
Fixes #50369
---
 base/boot.jl                            |  3 ++
 base/docs/basedocs.jl                   |  7 ++--
 base/errorshow.jl                       | 10 +++++
 base/logging.jl                         |  4 +-
 doc/src/manual/control-flow.md          |  7 ++--
 doc/src/manual/distributed-computing.md |  4 +-
 doc/src/manual/faq.md                   |  6 +--
 doc/src/manual/metaprogramming.md       |  4 +-
 doc/src/manual/modules.md               |  6 +--
 doc/src/manual/variables-and-scoping.md | 13 ++++---
 src/ast.c                               |  2 +
 src/builtins.c                          |  2 +-
 src/codegen.cpp                         | 27 +++++++------
 src/interpreter.c                       | 10 ++---
 src/julia.h                             |  3 +-
 src/julia_internal.h                    |  1 +
 src/module.c                            |  9 +----
 src/rtutils.c                           | 26 +++++++++++--
 stdlib/REPL/src/REPLCompletions.jl      | 50 +++++++++++++++++++++++--
 stdlib/REPL/test/repl.jl                |  8 ++--
 stdlib/REPL/test/replcompletions.jl     | 10 +++--
 stdlib/Test/test/runtests.jl            |  2 +-
 test/ccall.jl                           |  4 +-
 test/client.jl                          |  6 +--
 test/compiler/inference.jl              |  2 +-
 test/compiler/inline.jl                 |  2 +-
 test/core.jl                            | 34 ++++++++---------
 test/corelogging.jl                     |  8 ++--
 test/errorshow.jl                       |  7 +++-
 test/subtype.jl                         |  2 +-
 test/syntax.jl                          |  4 +-
 test/testdefs.jl                        |  3 ++
 32 files changed, 186 insertions(+), 100 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 122fb3f40fa11..604817cbf2117 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -335,6 +335,9 @@ struct StackOverflowError  <: Exception end
 struct UndefRefError       <: Exception end
 struct UndefVarError <: Exception
     var::Symbol
+    scope # a Module or Symbol or other object describing the context where this variable was looked for (e.g. Main or :local or :static_parameter)
+    UndefVarError(var::Symbol) = new(var)
+    UndefVarError(var::Symbol, @nospecialize scope) = new(var, scope)
 end
 struct ConcurrencyViolationError <: Exception
     msg::AbstractString
diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 071e5b38e3585..87f568a420b8d 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -1818,14 +1818,14 @@ In these examples, `a` is a [`Rational`](@ref), which has two fields.
 nfields
 
 """
-    UndefVarError(var::Symbol)
+    UndefVarError(var::Symbol, [scope])
 
 A symbol in the current scope is not defined.
 
 # Examples
 ```jldoctest
 julia> a
-ERROR: UndefVarError: `a` not defined
+ERROR: UndefVarError: `a` not defined in `Main`
 
 julia> a = 1;
 
@@ -2346,7 +2346,8 @@ See also [`setproperty!`](@ref Base.setproperty!) and [`getglobal`](@ref)
 julia> module M end;
 
 julia> M.a  # same as `getglobal(M, :a)`
-ERROR: UndefVarError: `a` not defined
+ERROR: UndefVarError: `a` not defined in `M`
+Suggestion: check for spelling errors or missing imports. No global of this name exists in this module.
 
 julia> setglobal!(M, :a, 1)
 1
diff --git a/base/errorshow.jl b/base/errorshow.jl
index dd6cd75e57c6b..0440e2073ead0 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -170,6 +170,16 @@ showerror(io::IO, ex::UndefKeywordError) =
 
 function showerror(io::IO, ex::UndefVarError)
     print(io, "UndefVarError: `$(ex.var)` not defined")
+    if isdefined(ex, :scope)
+        scope = ex.scope
+        if scope isa Module
+            print(io, " in `$scope`")
+        elseif scope === :static_parameter
+            print(io, " in static parameter matching")
+        else
+            print(io, " in $scope scope")
+        end
+    end
     Experimental.show_error_hints(io, ex)
 end
 
diff --git a/base/logging.jl b/base/logging.jl
index 208774bcecf38..7150299efa647 100644
--- a/base/logging.jl
+++ b/base/logging.jl
@@ -335,12 +335,12 @@ function logmsg_code(_module, file, line, level, message, exs...)
         checkerrors = nothing
         for kwarg in reverse(log_data.kwargs)
             if isa(kwarg.args[2].args[1], Symbol)
-                checkerrors = Expr(:if, Expr(:isdefined, kwarg.args[2]), checkerrors, Expr(:call, Expr(:core, :UndefVarError), QuoteNode(kwarg.args[2].args[1])))
+                checkerrors = Expr(:if, Expr(:isdefined, kwarg.args[2]), checkerrors, Expr(:call, Expr(:core, :UndefVarError), QuoteNode(kwarg.args[2].args[1]), QuoteNode(:local)))
             end
         end
         if isa(message, Symbol)
             message = esc(message)
-            checkerrors = Expr(:if, Expr(:isdefined, message), checkerrors, Expr(:call, Expr(:core, :UndefVarError), QuoteNode(message.args[1])))
+            checkerrors = Expr(:if, Expr(:isdefined, message), checkerrors, Expr(:call, Expr(:core, :UndefVarError), QuoteNode(message.args[1]), QuoteNode(:local)))
         end
         logrecord = quote
             let err = $checkerrors
diff --git a/doc/src/manual/control-flow.md b/doc/src/manual/control-flow.md
index 84b7f141dfd13..5eb2bd24fb076 100644
--- a/doc/src/manual/control-flow.md
+++ b/doc/src/manual/control-flow.md
@@ -139,7 +139,7 @@ julia> test(1,2)
 x is less than y.
 
 julia> test(2,1)
-ERROR: UndefVarError: `relation` not defined
+ERROR: UndefVarError: `relation` not defined in local scope
 Stacktrace:
  [1] test(::Int64, ::Int64) at ./none:7
 ```
@@ -458,7 +458,7 @@ julia> for j = 1:3
 3
 
 julia> j
-ERROR: UndefVarError: `j` not defined
+ERROR: UndefVarError: `j` not defined in `Main`
 ```
 
 ```jldoctest
@@ -862,7 +862,8 @@ end
            else
                foo
            end
-    ERROR: UndefVarError: `foo` not defined
+    ERROR: UndefVarError: `foo` not defined in `Main`
+    Suggestion: check for spelling errors or missing imports. No global of this name exists in this module.
     ```
     Use the [`local` keyword](@ref local-scope) outside the `try` block to make the variable
     accessible from anywhere within the outer scope.
diff --git a/doc/src/manual/distributed-computing.md b/doc/src/manual/distributed-computing.md
index 83d4f14808a8f..dd372ccbc53d4 100644
--- a/doc/src/manual/distributed-computing.md
+++ b/doc/src/manual/distributed-computing.md
@@ -158,7 +158,7 @@ julia> rand2(2,2)
  1.15119   0.918912
 
 julia> fetch(@spawnat :any rand2(2,2))
-ERROR: RemoteException(2, CapturedException(UndefVarError(Symbol("#rand2"))
+ERROR: RemoteException(2, CapturedException(UndefVarError(Symbol("#rand2"))))
 Stacktrace:
 [...]
 ```
@@ -209,7 +209,7 @@ MyType(7)
 
 julia> fetch(@spawnat 2 MyType(7))
 ERROR: On worker 2:
-UndefVarError: `MyType` not defined
+UndefVarError: `MyType` not defined in `Main`
 ⋮
 
 julia> fetch(@spawnat 2 DummyModule.MyType(7))
diff --git a/doc/src/manual/faq.md b/doc/src/manual/faq.md
index 5ac88bbc98bf0..ccea44f922a8e 100644
--- a/doc/src/manual/faq.md
+++ b/doc/src/manual/faq.md
@@ -725,7 +725,7 @@ julia> module Foo
 
 julia> Foo.foo()
 ERROR: On worker 2:
-UndefVarError: `Foo` not defined
+UndefVarError: `Foo` not defined in `Main`
 Stacktrace:
 [...]
 ```
@@ -746,7 +746,7 @@ julia> @everywhere module Foo
 
 julia> Foo.foo()
 ERROR: On worker 2:
-UndefVarError: `gvar` not defined
+UndefVarError: `gvar` not defined in `Main.Foo`
 Stacktrace:
 [...]
 ```
@@ -782,7 +782,7 @@ bar (generic function with 1 method)
 
 julia> remotecall_fetch(bar, 2)
 ERROR: On worker 2:
-UndefVarError: `#bar` not defined
+UndefVarError: `#bar` not defined in `Main`
 [...]
 
 julia> anon_bar  = ()->1
diff --git a/doc/src/manual/metaprogramming.md b/doc/src/manual/metaprogramming.md
index 4936e4fbe550f..b1623ff8591b0 100644
--- a/doc/src/manual/metaprogramming.md
+++ b/doc/src/manual/metaprogramming.md
@@ -379,7 +379,7 @@ julia> ex = :(a + b)
 :(a + b)
 
 julia> eval(ex)
-ERROR: UndefVarError: `b` not defined
+ERROR: UndefVarError: `b` not defined in `Main`
 [...]
 
 julia> a = 1; b = 2;
@@ -397,7 +397,7 @@ julia> ex = :(x = 1)
 :(x = 1)
 
 julia> x
-ERROR: UndefVarError: `x` not defined
+ERROR: UndefVarError: `x` not defined in `Main`
 
 julia> eval(ex)
 1
diff --git a/doc/src/manual/modules.md b/doc/src/manual/modules.md
index 4be08edc56f38..10da581c2a8b3 100644
--- a/doc/src/manual/modules.md
+++ b/doc/src/manual/modules.md
@@ -288,7 +288,7 @@ julia> using .A, .B
 
 julia> f
 WARNING: both B and A export "f"; uses of it in module Main must be qualified
-ERROR: UndefVarError: `f` not defined
+ERROR: UndefVarError: `f` not defined in `Main`
 ```
 
 Here, Julia cannot decide which `f` you are referring to, so you have to make a choice. The following solutions are commonly used:
@@ -404,7 +404,7 @@ x = 0
 
 module Sub
 using ..TestPackage
-z = y # ERROR: UndefVarError: `y` not defined
+z = y # ERROR: UndefVarError: `y` not defined in `Main`
 end
 
 y = 1
@@ -420,7 +420,7 @@ For similar reasons, you cannot use a cyclic ordering:
 module A
 
 module B
-using ..C # ERROR: UndefVarError: `C` not defined
+using ..C # ERROR: UndefVarError: `C` not defined in `Main.A`
 end
 
 module C
diff --git a/doc/src/manual/variables-and-scoping.md b/doc/src/manual/variables-and-scoping.md
index c763d62680091..9d2d68244a65b 100644
--- a/doc/src/manual/variables-and-scoping.md
+++ b/doc/src/manual/variables-and-scoping.md
@@ -90,7 +90,8 @@ julia> module B
 julia> module D
            b = a # errors as D's global scope is separate from A's
        end;
-ERROR: UndefVarError: `a` not defined
+ERROR: UndefVarError: `a` not defined in `D`
+Suggestion: check for spelling errors or missing imports. No global of this name exists in this module.
 ```
 
 If a top-level expression contains a variable declaration with keyword `local`,
@@ -187,7 +188,7 @@ julia> greet()
 hello
 
 julia> x # global
-ERROR: UndefVarError: `x` not defined
+ERROR: UndefVarError: `x` not defined in `Main`
 ```
 
 Inside of the `greet` function, the assignment `x = "hello"` causes `x` to be a new local variable
@@ -256,7 +257,7 @@ julia> sum_to(10)
 55
 
 julia> s # global
-ERROR: UndefVarError: `s` not defined
+ERROR: UndefVarError: `s` not defined in `Main`
 ```
 
 Since `s` is local to the function `sum_to`, calling the function has no effect on the global
@@ -343,7 +344,7 @@ hello
 hello
 
 julia> x
-ERROR: UndefVarError: `x` not defined
+ERROR: UndefVarError: `x` not defined in `Main`
 ```
 
 Since the global `x` is not defined when the `for` loop is evaluated, the first clause of the soft
@@ -408,7 +409,7 @@ julia> code = """
 julia> include_string(Main, code)
 ┌ Warning: Assignment to `s` in soft scope is ambiguous because a global variable by the same name exists: `s` will be treated as a new local. Disambiguate by using `local s` to suppress this warning or `global s` to assign to the existing global variable.
 └ @ string:4
-ERROR: LoadError: UndefVarError: `s` not defined
+ERROR: LoadError: UndefVarError: `s` not defined in local scope
 ```
 
 Here we use [`include_string`](@ref), to evaluate `code` as though it were the contents of a file.
@@ -559,7 +560,7 @@ julia> let x = 1, z
            println("z: $z") # errors as z has not been assigned yet but is local
        end
 x: 1, y: -1
-ERROR: UndefVarError: `z` not defined
+ERROR: UndefVarError: `z` not defined in local scope
 ```
 
 The assignments are evaluated in order, with each right-hand side evaluated in the scope before
diff --git a/src/ast.c b/src/ast.c
index 4647dd9f85a63..9e22369d836b9 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -60,6 +60,7 @@ JL_DLLEXPORT jl_sym_t *jl_thunk_sym;
 JL_DLLEXPORT jl_sym_t *jl_foreigncall_sym;
 JL_DLLEXPORT jl_sym_t *jl_as_sym;
 JL_DLLEXPORT jl_sym_t *jl_global_sym;
+JL_DLLEXPORT jl_sym_t *jl_local_sym;
 JL_DLLEXPORT jl_sym_t *jl_list_sym;
 JL_DLLEXPORT jl_sym_t *jl_dot_sym;
 JL_DLLEXPORT jl_sym_t *jl_newvar_sym;
@@ -322,6 +323,7 @@ void jl_init_common_symbols(void)
     jl_opaque_closure_method_sym = jl_symbol("opaque_closure_method");
     jl_const_sym = jl_symbol("const");
     jl_global_sym = jl_symbol("global");
+    jl_local_sym = jl_symbol("local");
     jl_thunk_sym = jl_symbol("thunk");
     jl_toplevel_sym = jl_symbol("toplevel");
     jl_dot_sym = jl_symbol(".");
diff --git a/src/builtins.c b/src/builtins.c
index bed8bbc2b0216..b2733818abcb0 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -669,7 +669,7 @@ static jl_value_t *do_apply(jl_value_t **args, uint32_t nargs, jl_value_t *itera
         }
     }
     if (extra && iterate == NULL) {
-        jl_undefined_var_error(jl_symbol("iterate"));
+        jl_undefined_var_error(jl_symbol("iterate"), NULL);
     }
     // allocate space for the argument array and gc roots for it
     // based on our previous estimates
diff --git a/src/codegen.cpp b/src/codegen.cpp
index f430487e7a480..079038c71e481 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -833,8 +833,10 @@ static const auto jltypeerror_func = new JuliaFunction<>{
 };
 static const auto jlundefvarerror_func = new JuliaFunction<>{
     XSTR(jl_undefined_var_error),
-    [](LLVMContext &C) { return FunctionType::get(getVoidTy(C),
-            {PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::CalleeRooted)}, false); },
+    [](LLVMContext &C) {
+        Type *T = PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::CalleeRooted);
+        return FunctionType::get(getVoidTy(C), {T, T}, false);
+    },
     get_attrs_noreturn,
 };
 static const auto jlhasnofield_func = new JuliaFunction<>{
@@ -1977,7 +1979,7 @@ static jl_returninfo_t get_specsig_function(jl_codectx_t &ctx, Module *M, Value
 static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaval = -1);
 static Value *global_binding_pointer(jl_codectx_t &ctx, jl_module_t *m, jl_sym_t *s,
                                      jl_binding_t **pbnd, bool assign);
-static jl_cgval_t emit_checked_var(jl_codectx_t &ctx, Value *bp, jl_sym_t *name, bool isvol, MDNode *tbaa);
+static jl_cgval_t emit_checked_var(jl_codectx_t &ctx, Value *bp, jl_sym_t *name, jl_value_t *scope, bool isvol, MDNode *tbaa);
 static jl_cgval_t emit_sparam(jl_codectx_t &ctx, size_t i);
 static Value *emit_condition(jl_codectx_t &ctx, const jl_cgval_t &condV, const Twine &msg);
 static Value *get_current_task(jl_codectx_t &ctx);
@@ -3099,7 +3101,7 @@ static jl_cgval_t emit_globalref(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *
         }
     }
     // todo: use type info to avoid undef check
-    return emit_checked_var(ctx, bp, name, false, ctx.tbaa().tbaa_binding);
+    return emit_checked_var(ctx, bp, name, (jl_value_t*)mod, false, ctx.tbaa().tbaa_binding);
 }
 
 static bool emit_globalset(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *sym, const jl_cgval_t &rval_info, AtomicOrdering Order)
@@ -4892,15 +4894,16 @@ static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt, bo
 
 // --- accessing and assigning variables ---
 
-static void undef_var_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *name)
+static void undef_var_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *name, jl_value_t *scope)
 {
     ++EmittedUndefVarErrors;
     BasicBlock *err = BasicBlock::Create(ctx.builder.getContext(), "err", ctx.f);
     BasicBlock *ifok = BasicBlock::Create(ctx.builder.getContext(), "ok");
     ctx.builder.CreateCondBr(ok, ifok, err);
     ctx.builder.SetInsertPoint(err);
-    ctx.builder.CreateCall(prepare_call(jlundefvarerror_func),
-        mark_callee_rooted(ctx, literal_pointer_val(ctx, (jl_value_t*)name)));
+    ctx.builder.CreateCall(prepare_call(jlundefvarerror_func), {
+            mark_callee_rooted(ctx, literal_pointer_val(ctx, (jl_value_t*)name)),
+            mark_callee_rooted(ctx, literal_pointer_val(ctx, scope))});
     ctx.builder.CreateUnreachable();
     ifok->insertInto(ctx.f);
     ctx.builder.SetInsertPoint(ifok);
@@ -4988,7 +4991,7 @@ static Value *global_binding_pointer(jl_codectx_t &ctx, jl_module_t *m, jl_sym_t
     return julia_binding_gv(ctx, b);
 }
 
-static jl_cgval_t emit_checked_var(jl_codectx_t &ctx, Value *bp, jl_sym_t *name, bool isvol, MDNode *tbaa)
+static jl_cgval_t emit_checked_var(jl_codectx_t &ctx, Value *bp, jl_sym_t *name, jl_value_t *scope, bool isvol, MDNode *tbaa)
 {
     LoadInst *v = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, bp, Align(sizeof(void*)));
     setName(ctx.emission_context, v, jl_symbol_name(name) + StringRef(".checked"));
@@ -4999,7 +5002,7 @@ static jl_cgval_t emit_checked_var(jl_codectx_t &ctx, Value *bp, jl_sym_t *name,
         jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
         ai.decorateInst(v);
     }
-    undef_var_error_ifnot(ctx, ctx.builder.CreateIsNotNull(v), name);
+    undef_var_error_ifnot(ctx, ctx.builder.CreateIsNotNull(v), name, scope);
     return mark_julia_type(ctx, v, true, jl_any_type);
 }
 
@@ -5025,7 +5028,7 @@ static jl_cgval_t emit_sparam(jl_codectx_t &ctx, size_t i)
         sparam = (jl_unionall_t*)sparam->body;
         assert(jl_is_unionall(sparam));
     }
-    undef_var_error_ifnot(ctx, isnull, sparam->var->name);
+    undef_var_error_ifnot(ctx, isnull, sparam->var->name, (jl_value_t*)jl_static_parameter_sym);
     return mark_julia_type(ctx, sp, true, jl_any_type);
 }
 
@@ -5183,7 +5186,7 @@ static jl_cgval_t emit_varinfo(jl_codectx_t &ctx, jl_varinfo_t &vi, jl_sym_t *va
     }
     if (isnull) {
         setName(ctx.emission_context, isnull, jl_symbol_name(varname) + StringRef("_is_null"));
-        undef_var_error_ifnot(ctx, isnull, varname);
+        undef_var_error_ifnot(ctx, isnull, varname, (jl_value_t*)jl_local_sym);
     }
     return v;
 }
@@ -5779,7 +5782,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
                 literal_pointer_val(ctx, jl_undefref_exception));
         }
         else {
-            undef_var_error_ifnot(ctx, cond, var);
+            undef_var_error_ifnot(ctx, cond, var, (jl_value_t*)jl_local_sym);
         }
         return ghostValue(ctx, jl_nothing_type);
     }
diff --git a/src/interpreter.c b/src/interpreter.c
index 00ea5a50934a6..f6000b6aeca92 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -147,7 +147,7 @@ jl_value_t *jl_eval_global_var(jl_module_t *m, jl_sym_t *e)
 {
     jl_value_t *v = jl_get_global(m, e);
     if (v == NULL)
-        jl_undefined_var_error(e);
+        jl_undefined_var_error(e, (jl_value_t*)m);
     return v;
 }
 
@@ -155,7 +155,7 @@ jl_value_t *jl_eval_globalref(jl_globalref_t *g)
 {
     jl_value_t *v = jl_get_globalref_value(g);
     if (v == NULL)
-        jl_undefined_var_error(g->name);
+        jl_undefined_var_error(g->name, (jl_value_t*)g->mod);
     return v;
 }
 
@@ -191,7 +191,7 @@ static jl_value_t *eval_value(jl_value_t *e, interpreter_state *s)
             jl_error("access to invalid slot number");
         jl_value_t *v = s->locals[n - 1];
         if (v == NULL)
-            jl_undefined_var_error((jl_sym_t*)jl_array_ptr_ref(src->slotnames, n - 1));
+            jl_undefined_var_error((jl_sym_t*)jl_array_ptr_ref(src->slotnames, n - 1), (jl_value_t*)jl_local_sym);
         return v;
     }
     if (jl_is_quotenode(e)) {
@@ -268,7 +268,7 @@ static jl_value_t *eval_value(jl_value_t *e, interpreter_state *s)
             if (var == jl_getfield_undefref_sym)
                 jl_throw(jl_undefref_exception);
             else
-                jl_undefined_var_error(var);
+                jl_undefined_var_error(var, (jl_value_t*)jl_local_sym);
         }
         return jl_nothing;
     }
@@ -307,7 +307,7 @@ static jl_value_t *eval_value(jl_value_t *e, interpreter_state *s)
         if (s->sparam_vals && n <= jl_svec_len(s->sparam_vals)) {
             jl_value_t *sp = jl_svecref(s->sparam_vals, n - 1);
             if (jl_is_typevar(sp) && !s->preevaluation)
-                jl_undefined_var_error(((jl_tvar_t*)sp)->name);
+                jl_undefined_var_error(((jl_tvar_t*)sp)->name, (jl_value_t*)jl_static_parameter_sym);
             return sp;
         }
         // static parameter val unknown needs to be an error for ccall
diff --git a/src/julia.h b/src/julia.h
index 1a8e62f9dcf9d..b2f6ab8b7a62f 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1877,7 +1877,6 @@ JL_DLLEXPORT int jl_get_module_max_methods(jl_module_t *m);
 // get binding for reading
 JL_DLLEXPORT jl_binding_t *jl_get_binding(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *var);
 JL_DLLEXPORT jl_binding_t *jl_get_binding_or_error(jl_module_t *m, jl_sym_t *var);
-JL_DLLEXPORT jl_binding_t *jl_get_binding_if_bound(jl_module_t *m, jl_sym_t *var);
 JL_DLLEXPORT jl_value_t *jl_module_globalref(jl_module_t *m, jl_sym_t *var);
 JL_DLLEXPORT jl_value_t *jl_get_binding_type(jl_module_t *m, jl_sym_t *var);
 // get binding for assignment
@@ -1953,7 +1952,7 @@ JL_DLLEXPORT void JL_NORETURN jl_type_error_rt(const char *fname,
                                                const char *context,
                                                jl_value_t *ty JL_MAYBE_UNROOTED,
                                                jl_value_t *got JL_MAYBE_UNROOTED);
-JL_DLLEXPORT void JL_NORETURN jl_undefined_var_error(jl_sym_t *var);
+JL_DLLEXPORT void JL_NORETURN jl_undefined_var_error(jl_sym_t *var, jl_value_t *scope JL_MAYBE_UNROOTED);
 JL_DLLEXPORT void JL_NORETURN jl_has_no_field_error(jl_sym_t *type_name, jl_sym_t *var);
 JL_DLLEXPORT void JL_NORETURN jl_atomic_error(char *str);
 JL_DLLEXPORT void JL_NORETURN jl_bounds_error(jl_value_t *v JL_MAYBE_UNROOTED,
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 09a963258d566..2c0c13d0bb343 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1532,6 +1532,7 @@ extern JL_DLLEXPORT jl_sym_t *jl_thunk_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_foreigncall_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_as_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_global_sym;
+extern JL_DLLEXPORT jl_sym_t *jl_local_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_list_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_dot_sym;
 extern JL_DLLEXPORT jl_sym_t *jl_newvar_sym;
diff --git a/src/module.c b/src/module.c
index a5b967dc67735..04ddb4f4fb3ae 100644
--- a/src/module.c
+++ b/src/module.c
@@ -426,13 +426,6 @@ static jl_binding_t *jl_resolve_owner(jl_binding_t *b/*optional*/, jl_module_t *
     return b2;
 }
 
-JL_DLLEXPORT jl_binding_t *jl_get_binding_if_bound(jl_module_t *m, jl_sym_t *var)
-{
-    jl_binding_t *b = jl_get_module_binding(m, var, 0);
-    return b == NULL ? NULL : jl_atomic_load_relaxed(&b->owner);
-}
-
-
 // get the current likely owner of binding when accessing m.var, without resolving the binding (it may change later)
 JL_DLLEXPORT jl_binding_t *jl_binding_owner(jl_module_t *m, jl_sym_t *var)
 {
@@ -467,7 +460,7 @@ JL_DLLEXPORT jl_binding_t *jl_get_binding_or_error(jl_module_t *m, jl_sym_t *var
 {
     jl_binding_t *b = jl_get_binding(m, var);
     if (b == NULL)
-        jl_undefined_var_error(var);
+        jl_undefined_var_error(var, (jl_value_t*)m);
     // XXX: this only considers if the original is deprecated, not the binding in m
     if (b->deprecated)
         jl_binding_deprecation_warning(m, var, b);
diff --git a/src/rtutils.c b/src/rtutils.c
index e3cb1af50c676..5fbba42c15b02 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -127,11 +127,29 @@ JL_DLLEXPORT void JL_NORETURN jl_type_error(const char *fname,
     jl_type_error_rt(fname, "", expected, got);
 }
 
-JL_DLLEXPORT void JL_NORETURN jl_undefined_var_error(jl_sym_t *var)
+JL_DLLEXPORT void JL_NORETURN jl_undefined_var_error(jl_sym_t *var, jl_value_t *scope)
 {
-    if (!jl_undefvarerror_type)
-        jl_errorf("UndefVarError(%s)", jl_symbol_name(var));
-    jl_throw(jl_new_struct(jl_undefvarerror_type, var));
+    if (!jl_undefvarerror_type) {
+        const char *s1 = "";
+        const char *s2 = "";
+        if (scope) {
+            if (jl_is_symbol(scope)) {
+                s1 = ", :";
+                s2 = jl_symbol_name((jl_sym_t*)scope);
+            }
+            else if (jl_is_module(scope)) {
+                s1 = ", module ";
+                s2 = jl_symbol_name(((jl_module_t*)scope)->name);
+            }
+            else {
+                s1 = ", ";
+                s2 = "unknown scope";
+            }
+        }
+        jl_errorf("UndefVarError(%s%s%s)", jl_symbol_name(var), s1, s2);
+    }
+    JL_GC_PUSH1(&scope);
+    jl_throw(jl_new_struct(jl_undefvarerror_type, var, scope));
 }
 
 JL_DLLEXPORT void JL_NORETURN jl_has_no_field_error(jl_sym_t *type_name, jl_sym_t *var)
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index f8a367b8342da..35deb0277406c 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -1293,16 +1293,60 @@ end
 function UndefVarError_hint(io::IO, ex::UndefVarError)
     var = ex.var
     if var === :or
-        print(io, "\nsuggestion: Use `||` for short-circuiting boolean OR.")
+        print(io, "\nSuggestion: Use `||` for short-circuiting boolean OR.")
     elseif var === :and
-        print(io, "\nsuggestion: Use `&&` for short-circuiting boolean AND.")
+        print(io, "\nSuggestion: Use `&&` for short-circuiting boolean AND.")
     elseif var === :help
         println(io)
         # Show friendly help message when user types help or help() and help is undefined
         show(io, MIME("text/plain"), Base.Docs.parsedoc(Base.Docs.keywords[:help]))
     elseif var === :quit
-        print(io, "\nsuggestion: To exit Julia, use Ctrl-D, or type exit() and press enter.")
+        print(io, "\nSuggestion: To exit Julia, use Ctrl-D, or type exit() and press enter.")
     end
+    if isdefined(ex, :scope)
+        scope = ex.scope
+        if scope isa Module
+            bnd = ccall(:jl_get_module_binding, Any, (Any, Any, Cint), scope, var, true)::Core.Binding
+            if isdefined(bnd, :owner)
+                owner = bnd.owner
+                if owner === bnd
+                    print(io, "\nSuggestion: add an appropriate import or assignment. This global was declared but not assigned.")
+                end
+            else
+                owner = ccall(:jl_binding_owner, Ptr{Cvoid}, (Any, Any), scope, var)
+                if C_NULL == owner
+                    print(io, "\nSuggestion: check for spelling errors or missing imports. No global of this name exists in this module.")
+                    owner = bnd
+                else
+                    owner = unsafe_pointer_to_objref(owner)::Core.Binding
+                end
+            end
+            if owner !== bnd
+                # this could use jl_binding_dbgmodule for the exported location in the message too
+                print(io, "\nSuggestion: this global was defined as `$(owner.globalref)` but not assigned a value.")
+            end
+        elseif scope === :static_parameter
+            print(io, "\nSuggestion: run Test.detect_unbound_args to detect method arguments that do not fully constrain a type parameter.")
+        elseif scope === :local
+            print(io, "\nSuggestion: check for an assignment to a local variable that shadows a global of the same name.")
+        end
+    else
+        scope = undef
+    end
+    warnfor(m, var) = Base.isbindingresolved(m, var) && isdefined(m, var) && (print(io, "\nHint: a global variable of this name also exists in $m."); true)
+    if scope !== Base && !warnfor(Base, var)
+        warned = false
+        for m in Base.loaded_modules_order
+            m === Core && continue
+            m === Base && continue
+            m === Main && continue
+            m === scope && continue
+            warned = warnfor(m, var) || warned
+        end
+        warned = warned || warnfor(Core, var)
+        warned = warned || warnfor(Main, var)
+    end
+    nothing
 end
 
 function __init__()
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 48284a5e89161..0e5f1c5f60c26 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -6,6 +6,8 @@ using Random
 import REPL.LineEdit
 using Markdown
 
+empty!(Base.Experimental._hint_handlers) # unregister error hints so they can be tested separately
+
 @test isassigned(Base.REPL_MODULE_REF)
 
 const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
@@ -1491,7 +1493,7 @@ fake_repl() do stdin_write, stdout_read, repl
     # generate top-level error
     write(stdin_write, "foobar\n")
     readline(stdout_read)
-    @test readline(stdout_read) == "\e[0mERROR: UndefVarError: `foobar` not defined"
+    @test readline(stdout_read) == "\e[0mERROR: UndefVarError: `foobar` not defined in `Main`"
     @test readline(stdout_read) == ""
     readuntil(stdout_read, "julia> ", keep=true)
     # check that top-level error did not change `err`
@@ -1506,13 +1508,13 @@ fake_repl() do stdin_write, stdout_read, repl
     readuntil(stdout_read, "julia> ", keep=true)
     write(stdin_write, "foo()\n")
     readline(stdout_read)
-    @test readline(stdout_read) == "\e[0mERROR: UndefVarError: `foobar` not defined"
+    @test readline(stdout_read) == "\e[0mERROR: UndefVarError: `foobar` not defined in `Main`"
     readuntil(stdout_read, "julia> ", keep=true)
     # check that deeper error did set `err`
     write(stdin_write, "err\n")
     readline(stdout_read)
     @test readline(stdout_read) == "\e[0m1-element ExceptionStack:"
-    @test readline(stdout_read) == "UndefVarError: `foobar` not defined"
+    @test readline(stdout_read) == "UndefVarError: `foobar` not defined in `Main`"
     @test readline(stdout_read) == "Stacktrace:"
     readuntil(stdout_read, "\n\n", keep=true)
     readuntil(stdout_read, "julia> ", keep=true)
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 1560d322b375d..5b98052e7de7e 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -4,12 +4,14 @@ using REPL.REPLCompletions
 using Test
 using Random
 using REPL
-    @testset "Check symbols previously not shown by REPL.doc_completions()" begin
+
+@testset "Check symbols previously not shown by REPL.doc_completions()" begin
     symbols = ["?","=","[]","[","]","{}","{","}",";","","'","&&","||","julia","Julia","new","@var_str"]
-        for i in symbols
-            @test i ∈ REPL.doc_completions(i, Main)
-        end
+    for i in symbols
+        @test i ∈ REPL.doc_completions(i, Main)
     end
+end
+
 let ex = quote
     module CompletionFoo
         using Random
diff --git a/stdlib/Test/test/runtests.jl b/stdlib/Test/test/runtests.jl
index 92ca8900882ce..1f93db2b5ed72 100644
--- a/stdlib/Test/test/runtests.jl
+++ b/stdlib/Test/test/runtests.jl
@@ -77,7 +77,7 @@ end
     @test 1234 === @test_nowarn(1234)
     @test 5678 === @test_warn("WARNING: foo", begin println(stderr, "WARNING: foo"); 5678; end)
     let a
-        @test_throws UndefVarError(:a) a
+        @test_throws UndefVarError(:a, :local) a
         @test_nowarn a = 1
         @test a === 1
     end
diff --git a/test/ccall.jl b/test/ccall.jl
index 6e8269a36225d..3647173eb9290 100644
--- a/test/ccall.jl
+++ b/test/ccall.jl
@@ -1477,7 +1477,7 @@ end
 # issue #20835
 @test_throws(ErrorException("could not evaluate ccall argument type (it might depend on a local variable)"),
              eval(:(f20835(x) = ccall(:fn, Cvoid, (Ptr{typeof(x)},), x))))
-@test_throws(UndefVarError(:Something_not_defined_20835),
+@test_throws(UndefVarError(:Something_not_defined_20835, @__MODULE__),
              eval(:(f20835(x) = ccall(:fn, Something_not_defined_20835, (Ptr{typeof(x)},), x))))
 @test isempty(methods(f20835))
 
@@ -1838,7 +1838,7 @@ ccall_lazy_lib_name(x) = ccall((:testUcharX, compute_lib_name()), Int32, (UInt8,
 @test ccall_lazy_lib_name(0) == 0
 @test ccall_lazy_lib_name(3) == 1
 ccall_with_undefined_lib() = ccall((:time, xx_nOt_DeFiNeD_xx), Cint, (Ptr{Cvoid},), C_NULL)
-@test_throws UndefVarError(:xx_nOt_DeFiNeD_xx) ccall_with_undefined_lib()
+@test_throws UndefVarError(:xx_nOt_DeFiNeD_xx, @__MODULE__) ccall_with_undefined_lib()
 
 @testset "transcode for UInt8 and UInt16" begin
     a   = [UInt8(1), UInt8(2), UInt8(3)]
diff --git a/test/client.jl b/test/client.jl
index b2877001d235e..61fe7d5093474 100644
--- a/test/client.jl
+++ b/test/client.jl
@@ -12,14 +12,14 @@ nested_error_pattern = r"""
     ERROR: DivideError: integer division error
     Stacktrace:.*
 
-    caused by: UndefVarError: `__not_a_binding__` not defined
+    caused by: UndefVarError: `__not_a_binding__` not defined in `Main`
     Stacktrace:.*
     """s
 
 @testset "display_error" begin
     # Display of errors which cause more than one entry on the exception stack
     excs = try
-        eval(nested_error_expr)
+        Core.eval(Main, nested_error_expr)
     catch
         Base.current_exceptions()
     end
@@ -31,7 +31,7 @@ nested_error_pattern = r"""
         DivideError: integer division error
         Stacktrace:.*
 
-        caused by: UndefVarError: `__not_a_binding__` not defined
+        caused by: UndefVarError: `__not_a_binding__` not defined in `Main`
         Stacktrace:.*
         """s, sprint(show, excs))
 end
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index bfb78d6c61bfd..20fdaaf297d82 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -731,7 +731,7 @@ for (codetype, all_ssa) in Any[
     test_inferred_static(codetype, all_ssa)
 end
 @test f18679() === ()
-@test_throws UndefVarError(:any_undef_global) g18679()
+@test_throws UndefVarError(:any_undef_global, @__MODULE__) g18679()
 @test h18679() === nothing
 
 
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index f3c29e4c2e970..2ad18e3374d7f 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -71,7 +71,7 @@ function bar12620()
         foo_inl(i==1)
     end
 end
-@test_throws UndefVarError(:y) bar12620()
+@test_throws UndefVarError(:y, :local) bar12620()
 
 # issue #16165
 @inline f16165(x) = (x = UInt(x) + 1)
diff --git a/test/core.jl b/test/core.jl
index 739ea182cd4f3..72b9f435d21a1 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -552,7 +552,7 @@ function i18408()
     return (x -> i)
 end
 let f = i18408()
-    @test_throws UndefVarError(:i) f(0)
+    @test_throws UndefVarError(:i, :local) f(0)
 end
 
 # issue #23558
@@ -612,7 +612,7 @@ begin
         global f7234_cnt += -10000
     end
 end
-@test_throws UndefVarError(:glob_x2) f7234_a()
+@test_throws UndefVarError(:glob_x2, :local) f7234_a()
 @test f7234_cnt == 1
 begin
     global glob_x2 = 24
@@ -622,7 +622,7 @@ begin
         global f7234_cnt += -10000
     end
 end
-@test_throws UndefVarError(:glob_x2) f7234_b()
+@test_throws UndefVarError(:glob_x2, :local) f7234_b()
 @test f7234_cnt == 2
 # globals can accessed if declared
 for i = 1:2
@@ -737,11 +737,11 @@ function f21900()
     global f21900_cnt += -1000
     nothing
 end
-@test_throws UndefVarError(:x_global_undefined_error) f21900()
+@test_throws UndefVarError(:x_global_undefined_error, @__MODULE__) f21900()
 @test f21900_cnt == 1
 
 # use @eval so this runs as a toplevel scope block
-@test_throws UndefVarError(:foo21900) @eval begin
+@test_throws UndefVarError(:foo21900, @__MODULE__) @eval begin
     for i21900 = 1:10
         local bar21900
         for j21900 = 1:10
@@ -754,7 +754,7 @@ end
 @test !@isdefined(foo21900)
 @test !@isdefined(bar21900)
 bar21900 = 0
-@test_throws UndefVarError(:foo21900) @eval begin
+@test_throws UndefVarError(:foo21900, @__MODULE__) @eval begin
     for i21900 = 1:10
         global bar21900
         for j21900 = 1:10
@@ -4176,7 +4176,7 @@ let foo(x::Union{T, Nothing}, y::Union{T, Nothing}) where {T} = 1
 end
 let foo(x::Union{T, Nothing}, y::Union{T, Nothing}) where {T} = T
     @test foo(1, nothing) === Int
-    @test_throws UndefVarError(:T) foo(nothing, nothing)
+    @test_throws UndefVarError(:T, :static_parameter) foo(nothing, nothing)
 end
 
 module TestMacroGlobalFunction
@@ -4230,14 +4230,14 @@ foo9677(x::Array) = invoke(foo9677, Tuple{AbstractArray}, x)
 
 # issue #6846
 f6846() = (please6846; 2)
-@test_throws UndefVarError(:please6846) f6846()
+@test_throws UndefVarError(:please6846, @__MODULE__) f6846()
 
 module M6846
     macro f()
         return esc(:(please6846; 2))
     end
 end
-@test_throws UndefVarError(:please6846) @M6846.f()
+@test_throws UndefVarError(:please6846, @__MODULE__) @M6846.f()
 
 # issue #14758
 @test isa(@eval(f14758(; $([]...)) = ()), Function)
@@ -4940,7 +4940,7 @@ function trigger14878()
     w.ext[:14878] = B14878(junk)  # global junk not defined!
     return w
 end
-@test_throws UndefVarError(:junk) trigger14878()
+@test_throws UndefVarError(:junk, @__MODULE__) trigger14878()
 
 # issue #1090
 function f1090(x)::Int
@@ -5258,9 +5258,9 @@ GC.enable(true)
 @test isa(which(bad_tvars, ()), Method)
 @test bad_tvars() === 1
 @test_warn "declares type variable T but does not use it" @eval bad_tvars2() where {T} = T
-@test_throws UndefVarError(:T) bad_tvars2()
+@test_throws UndefVarError(:T, :static_parameter) bad_tvars2()
 missing_tvar(::T...) where {T} = T
-@test_throws UndefVarError(:T) missing_tvar()
+@test_throws UndefVarError(:T, :static_parameter) missing_tvar()
 @test missing_tvar(1) === Int
 @test missing_tvar(1, 2, 3) === Int
 @test_throws MethodError missing_tvar(1, 2, "3")
@@ -5876,7 +5876,7 @@ function f_unused_undefined_sp(::T...) where T
     T
     return 0
 end
-@test_throws UndefVarError(:T) f_unused_undefined_sp()
+@test_throws UndefVarError(:T, :static_parameter) f_unused_undefined_sp()
 
 # note: the constant `5` here should be > DataType.ninitialized.
 # This tests that there's no crash due to accessing Type.body.layout.
@@ -6866,7 +6866,7 @@ end
 # issue #21004
 const PTuple_21004{N,T} = NTuple{N,VecElement{T}}
 @test_throws ArgumentError("too few elements for tuple type $PTuple_21004") PTuple_21004(1)
-@test_throws UndefVarError(:T) PTuple_21004_2{N,T} = NTuple{N, VecElement{T}}(1)
+@test_throws UndefVarError(:T, :static_parameter) PTuple_21004_2{N,T} = NTuple{N, VecElement{T}}(1)
 
 #issue #22792
 foo_22792(::Type{<:Union{Int8,Int,UInt}}) = 1;
@@ -7164,7 +7164,7 @@ end
 c28399 = 42
 @test g28399(0)() == 42
 @test g28399(1)() == 42
-@test_throws UndefVarError(:__undef_28399__) f28399()
+@test_throws UndefVarError(:__undef_28399__, @__MODULE__) f28399()
 
 # issue #28445
 mutable struct foo28445
@@ -7960,14 +7960,14 @@ code_typed(f47476, (Int, Int, Vararg{Union{Int, NTuple{2,Int}}},))
 code_typed(f47476, (Int, Int, Int, Vararg{Union{Int, NTuple{2,Int}}},))
 code_typed(f47476, (Int, Int, Int, Int, Vararg{Union{Int, NTuple{2,Int}}},))
 @test f47476(1, 2, 3, 4, 5, 6, (7, 8)) === 2
-@test_throws UndefVarError(:N) f47476(1, 2, 3, 4, 5, 6, 7)
+@test_throws UndefVarError(:N, :static_parameter) f47476(1, 2, 3, 4, 5, 6, 7)
 
 vect47476(::Type{T}) where {T} = T
 @test vect47476(Type{Type{Type{Int32}}}) === Type{Type{Type{Int32}}}
 @test vect47476(Type{Type{Type{Int64}}}) === Type{Type{Type{Int64}}}
 
 g47476(::Union{Nothing,Int,Val{T}}...) where {T} = T
-@test_throws UndefVarError(:T) g47476(nothing, 1, nothing, 2, nothing, 3, nothing, 4, nothing, 5)
+@test_throws UndefVarError(:T, :static_parameter) g47476(nothing, 1, nothing, 2, nothing, 3, nothing, 4, nothing, 5)
 @test g47476(nothing, 1, nothing, 2, nothing, 3, nothing, 4, nothing, 5, Val(6)) === 6
 let spec = only(methods(g47476)).specializations::Core.SimpleVector
     @test !isempty(spec)
diff --git a/test/corelogging.jl b/test/corelogging.jl
index 9626f48e4b407..778e70aecd406 100644
--- a/test/corelogging.jl
+++ b/test/corelogging.jl
@@ -103,12 +103,12 @@ end
         logmsg = (function() @info msg x=y end,
                   function() @info msg x=y z=1+1 end)[i]
         @test_logs (Error, Test.Ignored(), Test.Ignored(), :logevent_error) catch_exceptions=true logmsg()
-        @test_throws UndefVarError(:msg) collect_test_logs(logmsg)
-        @test (only(collect_test_logs(logmsg, catch_exceptions=true)[1]).kwargs[:exception]::Tuple{UndefVarError, Vector})[1] === UndefVarError(:msg)
+        @test_throws UndefVarError(:msg, :local) collect_test_logs(logmsg)
+        @test (only(collect_test_logs(logmsg, catch_exceptions=true)[1]).kwargs[:exception]::Tuple{UndefVarError, Vector})[1] === UndefVarError(:msg, :local)
         msg = "the msg"
         @test_logs (Error, Test.Ignored(), Test.Ignored(), :logevent_error) catch_exceptions=true logmsg()
-        @test_throws UndefVarError(:y) collect_test_logs(logmsg)
-        @test (only(collect_test_logs(logmsg, catch_exceptions=true)[1]).kwargs[:exception]::Tuple{UndefVarError, Vector})[1] === UndefVarError(:y)
+        @test_throws UndefVarError(:y, :local) collect_test_logs(logmsg)
+        @test (only(collect_test_logs(logmsg, catch_exceptions=true)[1]).kwargs[:exception]::Tuple{UndefVarError, Vector})[1] === UndefVarError(:y, :local)
         y = "the y"
         @test_logs (Info,"the msg") logmsg()
         @test only(collect_test_logs(logmsg)[1]).kwargs[:x] === "the y"
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 04af56fb208af..1b9d46ca5f4bd 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -5,6 +5,9 @@ using Random, LinearAlgebra
 # For curmod_*
 include("testenv.jl")
 
+# re-register only the error hints that are being tested here (
+Base.Experimental.register_error_hint(Base.noncallable_number_hint_handler, MethodError)
+Base.Experimental.register_error_hint(Base.string_concatenation_hint_handler, MethodError)
 
 @testset "SystemError" begin
     err = try; systemerror("reason", Cint(0)); false; catch ex; ex; end::SystemError
@@ -350,7 +353,7 @@ let undefvar
     err_str = @except_str Vector{Any}(undef, 1)[1] UndefRefError
     @test err_str == "UndefRefError: access to undefined reference"
     err_str = @except_str undefvar UndefVarError
-    @test err_str == "UndefVarError: `undefvar` not defined"
+    @test err_str == "UndefVarError: `undefvar` not defined in local scope"
     err_str = @except_str read(IOBuffer(), UInt8) EOFError
     @test err_str == "EOFError: read end of file"
     err_str = @except_str Dict()[:doesnotexist] KeyError
@@ -501,7 +504,7 @@ let
     @test (@macroexpand @fastmath +      ) == :(Base.FastMath.add_fast)
     @test (@macroexpand @fastmath min(1) ) == :(Base.FastMath.min_fast(1))
     let err = try; @macroexpand @doc "" f() = @x; catch ex; ex; end
-        @test err == UndefVarError(Symbol("@x"))
+        @test err == UndefVarError(Symbol("@x"), @__MODULE__)
     end
     @test (@macroexpand @seven_dollar $bar) == 7
     x = 2
diff --git a/test/subtype.jl b/test/subtype.jl
index 289c31c475792..9a1dd62f4f9c4 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -1520,7 +1520,7 @@ f26453(x::T,y::T) where {S,T>:S} = 0
 @test f26453(1,2) == 0
 @test f26453(1,"") == 0
 g26453(x::T,y::T) where {S,T>:S} = T
-@test_throws UndefVarError(:T) g26453(1,1)
+@test_throws UndefVarError(:T, :static_parameter) g26453(1,1)
 @test issub_strict((Tuple{T,T} where T), (Tuple{T,T} where {S,T>:S}))
 
 # issue #27632
diff --git a/test/syntax.jl b/test/syntax.jl
index a2f8ed76373b6..106a8f296ced2 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -1706,7 +1706,7 @@ end
 @test Meta.parse("(a...)") == Expr(Symbol("..."), :a)
 
 # #19324
-@test_throws UndefVarError(:x) eval(:(module M19324
+@test_throws UndefVarError(:x, :local) eval(:(module M19324
                  x=1
                  for i=1:10
                      x += i
@@ -1923,7 +1923,7 @@ function capture_with_conditional_label()
     return y->x
 end
 let f = capture_with_conditional_label()  # should not throw
-    @test_throws UndefVarError(:x) f(0)
+    @test_throws UndefVarError(:x, :local) f(0)
 end
 
 # `_` should not create a global (or local)
diff --git a/test/testdefs.jl b/test/testdefs.jl
index a1d4107a502bd..e8f62858d1cbb 100644
--- a/test/testdefs.jl
+++ b/test/testdefs.jl
@@ -5,6 +5,9 @@ using Test, Random
 function runtests(name, path, isolate=true; seed=nothing)
     old_print_setting = Test.TESTSET_PRINT_ENABLE[]
     Test.TESTSET_PRINT_ENABLE[] = false
+    # remove all hint_handlers, so that errorshow tests are not changed by which packages have been loaded on this worker already
+    # packages that call register_error_hint should also call this again, and then re-add any hooks they want to test
+    empty!(Base.Experimental._hint_handlers)
     try
         if isolate
             # Simple enough to type and random enough so that no one will hard

From f31cd8ad2fecefa2717aa0f5462876c985acbdea Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Wed, 8 Nov 2023 12:27:15 -0500
Subject: [PATCH 0215/1315] Manual: Mention `Base.Checked` module in integer
 overflow handling (#52071)

The `Base.Checked` module is not mentioned in this section of the
manual. This helps clarify to the reader an alternative solution
provided by `Base` in addition to use of `big()`.
---
 doc/src/base/math.md                                  | 1 +
 doc/src/manual/integers-and-floating-point-numbers.md | 9 ++++-----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/src/base/math.md b/doc/src/base/math.md
index 573a2fc0d7e90..9093eddd51dfe 100644
--- a/doc/src/base/math.md
+++ b/doc/src/base/math.md
@@ -138,6 +138,7 @@ Base.minmax
 Base.Math.clamp
 Base.Math.clamp!
 Base.abs
+Base.Checked
 Base.Checked.checked_abs
 Base.Checked.checked_neg
 Base.Checked.checked_add
diff --git a/doc/src/manual/integers-and-floating-point-numbers.md b/doc/src/manual/integers-and-floating-point-numbers.md
index 8b45288f38efa..4c31871374aa2 100644
--- a/doc/src/manual/integers-and-floating-point-numbers.md
+++ b/doc/src/manual/integers-and-floating-point-numbers.md
@@ -243,11 +243,10 @@ julia> x + 1 == typemin(Int64)
 true
 ```
 
-Thus, arithmetic with Julia integers is actually a form of [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic).
-This reflects the characteristics of the underlying arithmetic of integers as implemented on modern
-computers. In applications where overflow is possible, explicit checking for wraparound produced
-by overflow is essential; otherwise, the [`BigInt`](@ref) type in [Arbitrary Precision Arithmetic](@ref)
-is recommended instead.
+Arithmetic operations with Julia's integer types inherently perform [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic),
+mirroring the characteristics of integer arithmetic on modern computer hardware. In scenarios where overflow is a possibility,
+it is crucial to explicitly check for wraparound effects that can result from such overflows.
+The [`Base.Checked`](@ref) module provides a suite of arithmetic operations equipped with overflow checks, which trigger errors if an overflow occurs. For use cases where overflow cannot be tolerated under any circumstances, utilizing the [`BigInt`](@ref) type, as detailed in [Arbitrary Precision Arithmetic](@ref), is advisable.
 
 An example of overflow behavior and how to potentially resolve it is as follows:
 

From f99e6bfe19b7b8d73975f5f96e54052e9725f1c8 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 8 Nov 2023 20:44:29 -0500
Subject: [PATCH 0216/1315] fix sorting for iterables that define copymutable
 (#52086)

---
 base/sort.jl    | 4 ++--
 test/sorting.jl | 5 +++++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/base/sort.jl b/base/sort.jl
index a4616a2e65b9e..be5ed28b43ebe 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -1500,7 +1500,7 @@ function sort(v; kws...)
     size = IteratorSize(v)
     size == HasShape{0}() && throw(ArgumentError("$v cannot be sorted"))
     size == IsInfinite() && throw(ArgumentError("infinite iterator $v cannot be sorted"))
-    sort!(copymutable(v); kws...)
+    sort!(collect(v); kws...)
 end
 sort(v::AbstractVector; kws...) = sort!(copymutable(v); kws...) # for method disambiguation
 sort(::AbstractString; kws...) =
@@ -1512,7 +1512,7 @@ function sort(x::NTuple{N}; lt::Function=isless, by::Function=identity,
               rev::Union{Bool,Nothing}=nothing, order::Ordering=Forward) where N
     o = ord(lt,by,rev,order)
     if N > 9
-        v = sort!(copymutable(x), DEFAULT_STABLE, o)
+        v = sort!(collect(x), DEFAULT_STABLE, o)
         tuple((v[i] for i in 1:N)...)
     else
         _sort(x, o)
diff --git a/test/sorting.jl b/test/sorting.jl
index 1164f2932d880..9cb5d717635c9 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -559,6 +559,11 @@ end
 
     @test_throws ArgumentError sort("string")
     @test_throws ArgumentError("1 cannot be sorted") sort(1)
+
+    @test sort(Set((1, 3, 6))) == [1, 3, 6]
+    @test sort(Dict((1=>9, 3=>2, 6=>5))) == [1=>9, 3=>2, 6=>5]
+    @test sort(keys(Dict((1=>2, 3=>5, 6=>9)))) == [1, 3, 6]
+    @test sort(values(Dict((1=>9, 3=>2, 6=>5)))) == [2, 5, 9]
 end
 
 @testset "sort!(::AbstractVector{<:Integer}) with short int range" begin

From 1b967b8da9a32479d8a1a33139e472541210e54e Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Thu, 9 Nov 2023 10:48:20 +0800
Subject: [PATCH 0217/1315] Mark `GenericMemory` as `IndexLinear` (#52082)

---
 base/genericmemory.jl | 2 ++
 test/abstractarray.jl | 1 +
 2 files changed, 3 insertions(+)

diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index 06d64708113e3..34c452af97ad2 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -26,6 +26,8 @@ size(a::GenericMemory, d::Int) =
 size(a::GenericMemory, d::Integer) =  size(a, convert(d, Int))
 size(a::GenericMemory) = (length(a),)
 
+IndexStyle(::Type{<:GenericMemory}) = IndexLinear()
+
 pointer(mem::GenericMemoryRef) = unsafe_convert(Ptr{Cvoid}, mem) # no bounds check, even for empty array
 
 _unsetindex!(A::Memory, i::Int) =  (@_propagate_inbounds_meta; _unsetindex!(GenericMemoryRef(A, i)); A)
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 9167cfd954d5f..1e370a7dfdfa8 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1079,6 +1079,7 @@ end
 @testset "IndexStyle for various types" begin
     @test Base.IndexStyle(UpperTriangular) == IndexCartesian() # subtype of AbstractArray, not of Array
     @test Base.IndexStyle(Vector) == IndexLinear()
+    @test Base.IndexStyle(Memory) == IndexLinear()
     @test Base.IndexStyle(UnitRange) == IndexLinear()
     @test Base.IndexStyle(UpperTriangular(rand(3, 3)), [1; 2; 3]) == IndexCartesian()
     @test Base.IndexStyle(UpperTriangular(rand(3, 3)), rand(3, 3), [1; 2; 3]) == IndexCartesian()

From 7309756146a0b86039652b2f6d91ac90bfe33c01 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 9 Nov 2023 11:48:44 +0900
Subject: [PATCH 0218/1315] minor fix on `getfield_nothrow` (#52083)

- fixed index of `order` when there are 5 arguments
- add type check for `boundscheck` argument
---
 base/compiler/tfuncs.jl  | 12 +++++++-----
 test/compiler/effects.jl | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index cc555e5bde5b6..588ecabe429ec 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -929,7 +929,7 @@ function getfield_boundscheck((; fargs, argtypes)::ArgInfo) # Symbol
     elseif length(argtypes) == 4
         fargs !== nothing && (farg = fargs[4])
         boundscheck = argtypes[4]
-        isvarargtype(boundscheck) && return :unknown
+        isvarargtype(boundscheck) && return :unsafe
         if widenconst(boundscheck) === Symbol
             return :on
         end
@@ -937,9 +937,9 @@ function getfield_boundscheck((; fargs, argtypes)::ArgInfo) # Symbol
         fargs !== nothing && (farg = fargs[5])
         boundscheck = argtypes[5]
     else
-        return :unknown
+        return :unsafe
     end
-    isvarargtype(boundscheck) && return :unknown
+    isvarargtype(boundscheck) && return :unsafe
     boundscheck = widenconditional(boundscheck)
     if widenconst(boundscheck) === Bool
         if isa(boundscheck, Const)
@@ -947,11 +947,13 @@ function getfield_boundscheck((; fargs, argtypes)::ArgInfo) # Symbol
         elseif farg !== nothing && isexpr(farg, :boundscheck)
             return :boundscheck
         end
+        return :unknown
     end
-    return :unknown
+    return :unsafe
 end
 
 function getfield_nothrow(𝕃::AbstractLattice, arginfo::ArgInfo, boundscheck::Symbol=getfield_boundscheck(arginfo))
+    boundscheck === :unsafe && return false
     (;argtypes) = arginfo
     ordering = Const(:not_atomic)
     if length(argtypes) == 4
@@ -960,7 +962,7 @@ function getfield_nothrow(𝕃::AbstractLattice, arginfo::ArgInfo, boundscheck::
             ordering = argtypes[4]
         end
     elseif length(argtypes) == 5
-        ordering = argtypes[5]
+        ordering = argtypes[4]
     elseif length(argtypes) != 3
         return false
     end
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 186a201f6ebe4..031e454c10539 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -497,6 +497,25 @@ end |> Core.Compiler.is_nothrow
     getfield(t, i, false) # invalid name type
 end |> !Core.Compiler.is_nothrow
 
+@test Base.infer_effects((Some{Any},)) do some
+    getfield(some, 1, :not_atomic)
+end |> Core.Compiler.is_nothrow
+@test Base.infer_effects((Some{Any},)) do some
+    getfield(some, 1, :invalid_atomic_spec)
+end |> !Core.Compiler.is_nothrow
+@test Base.infer_effects((Some{Any},Bool)) do some, boundscheck
+    getfield(some, 1, boundscheck)
+end |> Core.Compiler.is_nothrow
+@test Base.infer_effects((Some{Any},Bool)) do some, boundscheck
+    getfield(some, 1, :not_atomic, boundscheck)
+end |> Core.Compiler.is_nothrow
+@test Base.infer_effects((Some{Any},Bool)) do some, boundscheck
+    getfield(some, 1, :invalid_atomic_spec, boundscheck)
+end |> !Core.Compiler.is_nothrow
+@test Base.infer_effects((Some{Any},Any)) do some, boundscheck
+    getfield(some, 1, :not_atomic, boundscheck)
+end |> !Core.Compiler.is_nothrow
+
 @test Core.Compiler.is_consistent(Base.infer_effects(setindex!, (Base.RefValue{Int}, Int)))
 
 # :inaccessiblememonly effect

From f72ebec9fb6a69a985b4639bd86a7baaa6913f01 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 9 Nov 2023 12:13:32 +0900
Subject: [PATCH 0219/1315] [REPLCompletions] fix `limit_aggressive_inference`
 code path (#52074)

---
 stdlib/REPL/src/REPLCompletions.jl  |  4 ++--
 stdlib/REPL/test/replcompletions.jl | 10 ++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 35deb0277406c..f7d248464f3c9 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -522,7 +522,7 @@ CC.bail_out_toplevel_call(::REPLInterpreter, ::CC.InferenceLoopState, ::CC.Infer
 is_repl_frame(sv::CC.InferenceState) = sv.linfo.def isa Module && sv.cache_mode === CC.CACHE_MODE_NULL
 
 function is_call_graph_uncached(sv::CC.InferenceState)
-    sv.cache_mode === CC.CACHE_MODE_GLOBAL && return false
+    CC.is_cached(sv) && return false
     parent = sv.parent
     parent === nothing && return true
     return is_call_graph_uncached(parent::CC.InferenceState)
@@ -545,7 +545,7 @@ function is_repl_frame_getproperty(sv::CC.InferenceState)
     def = sv.linfo.def
     def isa Method || return false
     def.name === :getproperty || return false
-    sv.cached && return false
+    CC.is_cached(sv) && return false
     return is_repl_frame(sv.parent)
 end
 
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 5b98052e7de7e..4e7f8b2becc3c 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2005,6 +2005,16 @@ let inferred = REPL.REPLCompletions.repl_eval_ex(
     RT = Core.Compiler.widenconst(inferred)
     @test Val{false} <: RT
 end
+module TestLimitAggressiveInferenceGetProp
+global global_var = 1
+end
+function test_limit_aggressive_inference_getprop()
+    return getproperty(TestLimitAggressiveInferenceGetProp, :global_var)
+end
+let inferred = REPL.REPLCompletions.repl_eval_ex(
+        :(test_limit_aggressive_inference_getprop()), @__MODULE__; limit_aggressive_inference=true)
+    @test inferred == Core.Const(1)
+end
 
 # Test completion of var"" identifiers (#49280)
 let s = "var\"complicated "

From c95cb95520f473bd20aa9acf71a895d2c1769767 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Wed, 8 Nov 2023 22:42:03 -0500
Subject: [PATCH 0220/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20SparseArrays=20stdlib=20from=203582898=20to=2037fc321=20(#52?=
 =?UTF-8?q?089)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: SparseArrays
URL: https://github.com/JuliaSparse/SparseArrays.jl.git
Stdlib branch: main
Julia branch: master
Old commit: 3582898
New commit: 37fc321
Julia version: 1.11.0-DEV
SparseArrays version: 1.11.0
Bump invoked by: @ViralBShah
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaSparse/SparseArrays.jl/compare/3582898a4efd3f504d39076f5a162b9ed1ebcdb2...37fc321e28a32f79a928c24e5739a83d92de5205

```
$ git log --oneline 3582898..37fc321
37fc321 test: relax allocated tests (#468)
bd2bda8 replace ind2sub/sub2ind by CartesianIndices/LinearIndices (#451)
7897f1f test: somewhat more permissive test_throws message (#466)
911cf6a `reverse` for sparse vector/matrix (#450)
713a260 Define algebraic operators for SparseMatrixCSCView (#458)
f455a8e Add messages to DimensionMismatch errors (#461)
81fc6f3 Aggressive constprop in sparse * dense (#460)
0b36fdd fix h/vcat invoke dispatch arguments (#464)
6b23902 Add Finch to list of External Julia Sparse Array Libraries (#462)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/SparseArrays.version                                     | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/sha512
 create mode 100644 deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/md5 b/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/md5
deleted file mode 100644
index 12314ebe27beb..0000000000000
--- a/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-6427ffc68076c0555b0d3a02eaf88160
diff --git a/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/sha512 b/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/sha512
deleted file mode 100644
index 5c7602b6707cc..0000000000000
--- a/deps/checksums/SparseArrays-3582898a4efd3f504d39076f5a162b9ed1ebcdb2.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-7a4c6dae45b739bb1b22c53c8b2b32fc765995767580338218a99f671749bbd5c5d9b61f45718c3b80e153b524737501141481ede2a6f24856de1c028f07ad3a
diff --git a/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/md5 b/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/md5
new file mode 100644
index 0000000000000..2f1c977402216
--- /dev/null
+++ b/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/md5
@@ -0,0 +1 @@
+c69549ac1ff7fd9122b242c2bc50ecb2
diff --git a/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/sha512 b/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/sha512
new file mode 100644
index 0000000000000..9f54e3f375b16
--- /dev/null
+++ b/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/sha512
@@ -0,0 +1 @@
+381ac83206f2791115f9ccb5e7f794760fdc927a1e22601b26a555d0a744133dceaf8cf0b5ae42f1df9c9158f95f3c51adc8246a4d7a7c543ed71497dd19e0d3
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 10357d46ab030..761eb10fd2062 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 3582898a4efd3f504d39076f5a162b9ed1ebcdb2
+SPARSEARRAYS_SHA1 = 37fc321e28a32f79a928c24e5739a83d92de5205
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From 137783f1663ae0f7c1129c7d8031c874083b49fe Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Wed, 8 Nov 2023 22:37:59 -0600
Subject: [PATCH 0221/1315] Move profiling manual section to a new tutorials
 toplevel heading (#52056)

---
 doc/make.jl                              | 7 ++++++-
 doc/src/{manual => tutorials}/profile.md | 0
 2 files changed, 6 insertions(+), 1 deletion(-)
 rename doc/src/{manual => tutorials}/profile.md (100%)

diff --git a/doc/make.jl b/doc/make.jl
index f59c9bb54e8b0..89026f786f14b 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -92,7 +92,6 @@ Manual = [
     "manual/environment-variables.md",
     "manual/embedding.md",
     "manual/code-loading.md",
-    "manual/profile.md",
     "manual/stacktraces.md",
     "manual/performance-tips.md",
     "manual/workflow-tips.md",
@@ -128,6 +127,10 @@ BaseDocs = [
 
 StdlibDocs = [stdlib.targetfile for stdlib in STDLIB_DOCS]
 
+Tutorials = [
+    "tutorials/profile.md",
+]
+
 DevDocs = [
     "Documentation of Julia's Internals" => [
         "devdocs/init.md",
@@ -185,6 +188,7 @@ const PAGES = [
     "Manual" => ["index.md", Manual...],
     "Base" => BaseDocs,
     "Standard Library" => StdlibDocs,
+    "Tutorials" => Tutorials,
     # Add "Release Notes" to devdocs
     "Developer Documentation" => [DevDocs..., hide("NEWS.md")],
 ]
@@ -195,6 +199,7 @@ const PAGES = [
     "Manual" => Manual,
     "Base" => BaseDocs,
     "Standard Library" => StdlibDocs,
+    "Tutorials" => Tutorials,
     "Developer Documentation" => DevDocs,
 ]
 end
diff --git a/doc/src/manual/profile.md b/doc/src/tutorials/profile.md
similarity index 100%
rename from doc/src/manual/profile.md
rename to doc/src/tutorials/profile.md

From eafa1e39bea35cd2e71ff5cb01109da734036001 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Thu, 9 Nov 2023 14:17:45 +0900
Subject: [PATCH 0222/1315] fix up test case for unmatched type param inlining

---
 base/compiler/ssair/inlining.jl |  9 ++++-----
 test/compiler/inline.jl         | 25 +++++++++++--------------
 2 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 318b21b09bb16..831133f84ca74 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1393,8 +1393,7 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
     cases = InliningCase[]
     argtypes = sig.argtypes
     local handled_all_cases::Bool = true
-    local revisit_idx = nothing
-    local only_method = nothing
+    local revisit_idx = local only_method = nothing
     local meth::MethodLookupResult
     local all_result_count = 0
     local joint_effects::Effects = EFFECTS_TOTAL
@@ -1410,14 +1409,14 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
             handled_all_cases = false
             continue
         else
-            if length(meth) == 1 && only_method !== false
+            if length(meth) == 1 && only_method !== missing
                 if only_method === nothing
                     only_method = meth[1].method
                 elseif only_method !== meth[1].method
-                    only_method = false
+                    only_method = missing
                 end
             else
-                only_method = false
+                only_method = missing
             end
         end
         local split_fully_covered::Bool = false
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 2ad18e3374d7f..9e58f23fd755c 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -1675,13 +1675,12 @@ function oc_capture_oc(z)
 end
 @test fully_eliminated(oc_capture_oc, (Int,))
 
+# inlining with unmatched type parameters
 @eval struct OldVal{T}
-    x::T
     (OV::Type{OldVal{T}})() where T = $(Expr(:new, :OV))
 end
-with_unmatched_typeparam1(x::OldVal{i}) where {i} = i
-with_unmatched_typeparam2() = [ Base.donotdelete(OldVal{i}()) for i in 1:10000 ]
-function with_unmatched_typeparam3()
+@test OldVal{0}() === OldVal{0}.instance
+function with_unmatched_typeparam()
     f(x::OldVal{i}) where {i} = i
     r = 0
     for i = 1:10000
@@ -1689,17 +1688,15 @@ function with_unmatched_typeparam3()
     end
     return r
 end
-
-@testset "Inlining with unmatched type parameters" begin
-    let src = code_typed1(with_unmatched_typeparam1, (Any,))
-        @test !any(@nospecialize(x) -> isexpr(x, :call) && length(x.args) == 1, src.code)
-    end
-    let src = code_typed1(with_unmatched_typeparam2)
-        @test !any(@nospecialize(x) -> isexpr(x, :call) && length(x.args) == 1, src.code)
-    end
-    let src = code_typed1(with_unmatched_typeparam3)
-        @test !any(@nospecialize(x) -> isexpr(x, :call) && length(x.args) == 1, src.code)
+let src = code_typed1(with_unmatched_typeparam)
+    found = nothing
+    for x in src.code
+        if isexpr(x, :call) && length(x.args) == 1
+            found = x
+            break
+        end
     end
+    @test isnothing(found) || (source=src, statement=found)
 end
 
 function twice_sitofp(x::Int, y::Int)

From 81ef12a3a82c9845aa525207c63802b4fd91b0ad Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Thu, 9 Nov 2023 14:18:06 +0900
Subject: [PATCH 0223/1315] fixed test case for #43296

---
 test/compiler/inference.jl | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 20fdaaf297d82..174218f65b988 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -138,7 +138,7 @@ end
       Core.Compiler.limit_type_size(Type{Any}, Type, Union{}, 0, 0) ==
       Type{Any}
 
-# issue #43296 #43296
+# issue #43296
 struct C43296{t,I} end
 r43296(b) = r43296(typeof(b))
 r43296(::Type) = nothing
@@ -149,7 +149,8 @@ f43296(g, :) = h
 k43296(b, j, :) = l
 k43296(b, j, ::Nothing) = b
 i43296(b, j) = k43296(b, j, r43296(j))
-@test only(Base.return_types(i43296, (Int, C43296{C43296{C43296{Val, Tuple}, Tuple}}))) == Int
+@test only(Base.return_types(i43296, (Int, C43296{C43296{C43296{Val, Tuple}}}))) <: Int
+@test only(Base.return_types(i43296, (Int, C43296{C43296{C43296{Val, <:Tuple}}}))) <: Int
 
 abstract type e43296{a, j} <: AbstractArray{a, j} end
 abstract type b43296{a, j, c, d} <: e43296{a, j} end

From 358540cf46c683f3a6881242722f4b610c376a50 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Thu, 9 Nov 2023 02:14:31 +0900
Subject: [PATCH 0224/1315] effects: improve idempotency of effects derived by
 post-opt analysis

Since now effects can be refined by post-opt analysis, `typeinf_edge`
should propagate `frame.result.ipo_effects` instead of
`frame.ipo_effects`.
---
 base/compiler/typeinfer.jl |  4 ++--
 test/compiler/effects.jl   | 14 ++++++++++++++
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 9eef6615521ca..29d3c01d151be 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -537,7 +537,7 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
     end
     me.result.valid_worlds = me.valid_worlds
     me.result.result = bestguess
-    me.ipo_effects = me.result.ipo_effects = adjust_effects(me)
+    me.result.ipo_effects = me.ipo_effects = adjust_effects(me)
 
     if limited_ret
         # a parent may be cached still, but not this intermediate work:
@@ -856,7 +856,7 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         update_valid_age!(caller, frame.valid_worlds)
         isinferred = is_inferred(frame)
         edge = isinferred ? mi : nothing
-        effects = isinferred ? frame.ipo_effects : adjust_effects(Effects(), method) # effects are adjusted already within `finish` for ipo_effects
+        effects = isinferred ? frame.result.ipo_effects : adjust_effects(Effects(), method) # effects are adjusted already within `finish` for ipo_effects
         # propagate newly inferred source to the inliner, allowing efficient inlining w/o deserialization:
         # note that this result is cached globally exclusively, we can use this local result destructively
         volatile_inf_result = isinferred && let inferred_src = result.src
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 031e454c10539..ad2c60723adf6 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1158,3 +1158,17 @@ end
     issue51837(; openquotechar, newlinechar)
 end |> !Core.Compiler.is_nothrow
 @test_throws ArgumentError issue51837(; openquotechar='α', newlinechar='\n')
+
+# idempotency of effects derived by post-opt analysis
+callgetfield(x, f) = getfield(x, f, Base.@_boundscheck)
+@test Base.infer_effects(callgetfield, (Some{Any},Symbol)).noub === Core.Compiler.NOUB_IF_NOINBOUNDS
+callgetfield1(x, f) = getfield(x, f, Base.@_boundscheck)
+callgetfield_simple(x, f) = callgetfield1(x, f)
+@test Base.infer_effects(callgetfield_simple, (Some{Any},Symbol)).noub ===
+      Base.infer_effects(callgetfield_simple, (Some{Any},Symbol)).noub ===
+      Core.Compiler.ALWAYS_TRUE
+callgetfield2(x, f) = getfield(x, f, Base.@_boundscheck)
+callgetfield_inbounds(x, f) = @inbounds callgetfield2(x, f)
+@test Base.infer_effects(callgetfield_inbounds, (Some{Any},Symbol)).noub ===
+      Base.infer_effects(callgetfield_inbounds, (Some{Any},Symbol)).noub ===
+      Core.Compiler.ALWAYS_FALSE

From 29d78fae2121eda08d03ebf1abeb4626859ef62b Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 10 Nov 2023 00:04:31 +0900
Subject: [PATCH 0225/1315] inlining: stop passing `SemiConcreteResult` to
 `inlining_policy` (#52064)

It feels a bit inconsistent that the `src` argument of `inlining_policy`
needs to handle `SemiConcreteResult` while it doesn't need to handle the
other container objects that propagates sources like `CodeInstance`
`InferenceResult`, or `VolatileInferenceResult`.

This commit makes `inlining_policy` take `result.ir::IRCode` instead
when dealing with `result::SemiConcreteResult` for more consistency and
clarity.
---
 base/compiler/abstractinterpretation.jl |  2 +-
 base/compiler/optimize.jl               |  9 +--
 base/compiler/ssair/inlining.jl         | 97 ++++++++++++-------------
 base/compiler/ssair/passes.jl           |  2 +-
 test/compiler/AbstractInterpreter.jl    |  6 +-
 5 files changed, 50 insertions(+), 66 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 21ff1c951bf85..a092b0312eaf1 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1137,7 +1137,7 @@ function const_prop_methodinstance_heuristic(interp::AbstractInterpreter,
         if isa(code, CodeInstance)
             inferred = @atomic :monotonic code.inferred
             # TODO propagate a specific `CallInfo` that conveys information about this call
-            if inlining_policy(interp, inferred, NoCallInfo(), IR_FLAG_NULL, mi, arginfo.argtypes) !== nothing
+            if inlining_policy(interp, inferred, NoCallInfo(), IR_FLAG_NULL) !== nothing
                 return true
             end
         end
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index cbeb447e0c9aa..62a20896334b3 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -74,8 +74,7 @@ is_source_inferred(@nospecialize src::MaybeCompressed) =
     ccall(:jl_ir_flag_inferred, Bool, (Any,), src)
 
 function inlining_policy(interp::AbstractInterpreter,
-    @nospecialize(src), @nospecialize(info::CallInfo), stmt_flag::UInt32, mi::MethodInstance,
-    _::Vector{Any})
+    @nospecialize(src), @nospecialize(info::CallInfo), stmt_flag::UInt32)
     if isa(src, MaybeCompressed)
         is_source_inferred(src) || return nothing
         src_inlineable = is_stmt_inline(stmt_flag) || is_inlineable(src)
@@ -83,12 +82,6 @@ function inlining_policy(interp::AbstractInterpreter,
     elseif isa(src, IRCode)
         return src
     elseif isa(src, SemiConcreteResult)
-        if is_declared_noinline(mi.def::Method)
-            # For `NativeInterpreter`, `SemiConcreteResult` may be produced for
-            # a `@noinline`-declared method when it's marked as `@constprop :aggressive`.
-            # Suppress the inlining here.
-            return nothing
-        end
         return src
     end
     return nothing
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 831133f84ca74..7f6514b16d6e7 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -874,7 +874,7 @@ end
 
 # the general resolver for usual and const-prop'ed calls
 function resolve_todo(mi::MethodInstance, result::Union{Nothing,InferenceResult,VolatileInferenceResult},
-    argtypes::Vector{Any}, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
+    @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
     invokesig::Union{Nothing,Vector{Any}}=nothing)
     et = InliningEdgeTracker(state, invokesig)
 
@@ -901,7 +901,7 @@ function resolve_todo(mi::MethodInstance, result::Union{Nothing,InferenceResult,
             compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
     end
 
-    src = inlining_policy(state.interp, src, info, flag, mi, argtypes)
+    src = inlining_policy(state.interp, src, info, flag)
     src === nothing && return compileable_specialization(mi, effects, et, info;
         compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
 
@@ -911,8 +911,8 @@ function resolve_todo(mi::MethodInstance, result::Union{Nothing,InferenceResult,
 end
 
 # the special resolver for :invoke-d call
-function resolve_todo(mi::MethodInstance, argtypes::Vector{Any},
-    @nospecialize(info::CallInfo), flag::UInt32, state::InliningState)
+function resolve_todo(mi::MethodInstance, @nospecialize(info::CallInfo), flag::UInt32,
+                      state::InliningState)
     if !OptimizationParams(state.interp).inlining || is_stmt_noinline(flag)
         return nothing
     end
@@ -926,7 +926,7 @@ function resolve_todo(mi::MethodInstance, argtypes::Vector{Any},
     end
     (; src, effects) = cached_result
 
-    src = inlining_policy(state.interp, src, info, flag, mi, argtypes)
+    src = inlining_policy(state.interp, src, info, flag)
 
     src === nothing && return nothing
 
@@ -981,7 +981,7 @@ function analyze_method!(match::MethodMatch, argtypes::Vector{Any},
     # Get the specialization for this method signature
     # (later we will decide what to do with it)
     mi = specialize_method(match)
-    return resolve_todo(mi, volatile_inf_result, argtypes, info, flag, state; invokesig)
+    return resolve_todo(mi, volatile_inf_result, info, flag, state; invokesig)
 end
 
 function retrieve_ir_for_inlining(mi::MethodInstance, src::String, ::Bool=true)
@@ -1204,26 +1204,21 @@ function handle_invoke_call!(todo::Vector{Pair{Int,Any}},
     invokesig = sig.argtypes
     if isa(result, ConcreteResult)
         item = concrete_result_item(result, info, state; invokesig)
+    elseif isa(result, SemiConcreteResult)
+        item = semiconcrete_result_item(result, info, flag, state)
     else
         argtypes = invoke_rewrite(sig.argtypes)
-        if isa(result, SemiConcreteResult)
-            result = inlining_policy(state.interp, result, info, flag, result.mi, argtypes)
-        end
-        if isa(result, SemiConcreteResult)
-            item = semiconcrete_result_item(result, info, flag, state)
-        else
-            if isa(result, ConstPropResult)
-                mi = result.result.linfo
-                validate_sparams(mi.sparam_vals) || return nothing
-                if Union{} !== argtypes_to_type(argtypes) <: mi.def.sig
-                    item = resolve_todo(mi, result.result, argtypes, info, flag, state; invokesig)
-                    handle_single_case!(todo, ir, idx, stmt, item, true)
-                    return nothing
-                end
+        if isa(result, ConstPropResult)
+            mi = result.result.linfo
+            validate_sparams(mi.sparam_vals) || return nothing
+            if Union{} !== argtypes_to_type(argtypes) <: mi.def.sig
+                item = resolve_todo(mi, result.result, info, flag, state; invokesig)
+                handle_single_case!(todo, ir, idx, stmt, item, true)
+                return nothing
             end
-            volatile_inf_result = result isa VolatileInferenceResult ? result : nothing
-            item = analyze_method!(match, argtypes, info, flag, state; allow_typevars=false, invokesig, volatile_inf_result)
         end
+        volatile_inf_result = result isa VolatileInferenceResult ? result : nothing
+        item = analyze_method!(match, argtypes, info, flag, state; allow_typevars=false, invokesig, volatile_inf_result)
     end
     handle_single_case!(todo, ir, idx, stmt, item, true)
     return nothing
@@ -1352,15 +1347,10 @@ function handle_any_const_result!(cases::Vector{InliningCase},
     allow_abstract::Bool, allow_typevars::Bool)
     if isa(result, ConcreteResult)
         return handle_concrete_result!(cases, result, info, state)
-    end
-    if isa(result, SemiConcreteResult)
-        result = inlining_policy(state.interp, result, info, flag, result.mi, argtypes)
-        if isa(result, SemiConcreteResult)
-            return handle_semi_concrete_result!(cases, result, info, flag, state; allow_abstract)
-        end
-    end
-    if isa(result, ConstPropResult)
-        return handle_const_prop_result!(cases, result, argtypes, info, flag, state; allow_abstract, allow_typevars)
+    elseif isa(result, SemiConcreteResult)
+        return handle_semi_concrete_result!(cases, result, info, flag, state; allow_abstract)
+    elseif isa(result, ConstPropResult)
+        return handle_const_prop_result!(cases, result, info, flag, state; allow_abstract, allow_typevars)
     else
         @assert result === nothing || result isa VolatileInferenceResult
         return handle_match!(cases, match, argtypes, info, flag, state; allow_abstract, allow_typevars, volatile_inf_result = result)
@@ -1507,8 +1497,7 @@ function handle_match!(cases::Vector{InliningCase},
 end
 
 function handle_const_prop_result!(cases::Vector{InliningCase},
-    result::ConstPropResult, argtypes::Vector{Any}, @nospecialize(info::CallInfo),
-    flag::UInt32, state::InliningState;
+    result::ConstPropResult, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
     allow_abstract::Bool, allow_typevars::Bool)
     mi = result.result.linfo
     spec_types = mi.specTypes
@@ -1516,7 +1505,7 @@ function handle_const_prop_result!(cases::Vector{InliningCase},
     if !validate_sparams(mi.sparam_vals)
         (allow_typevars && !may_have_fcalls(mi.def::Method)) || return false
     end
-    item = resolve_todo(mi, result.result, argtypes, info, flag, state)
+    item = resolve_todo(mi, result.result, info, flag, state)
     item === nothing && return false
     push!(cases, InliningCase(spec_types, item))
     return true
@@ -1525,15 +1514,24 @@ end
 function semiconcrete_result_item(result::SemiConcreteResult,
         @nospecialize(info::CallInfo), flag::UInt32, state::InliningState)
     mi = result.mi
-    if !OptimizationParams(state.interp).inlining || is_stmt_noinline(flag)
-        et = InliningEdgeTracker(state)
+    et = InliningEdgeTracker(state)
+
+    if (!OptimizationParams(state.interp).inlining || is_stmt_noinline(flag) ||
+        # For `NativeInterpreter`, `SemiConcreteResult` may be produced for
+        # a `@noinline`-declared method when it's marked as `@constprop :aggressive`.
+        # Suppress the inlining here (unless inlining is requested at the callsite).
+        (is_declared_noinline(mi.def::Method) && !is_stmt_inline(flag)))
         return compileable_specialization(mi, result.effects, et, info;
             compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
-    else
-        preserve_local_sources = OptimizationParams(state.interp).preserve_local_sources
-        ir = retrieve_ir_for_inlining(mi, result.ir, preserve_local_sources)
-        return InliningTodo(mi, ir, result.effects)
     end
+    ir = inlining_policy(state.interp, result.ir, info, flag)
+    ir === nothing && return compileable_specialization(mi, result.effects, et, info;
+        compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
+
+    add_inlining_backedge!(et, mi)
+    preserve_local_sources = OptimizationParams(state.interp).preserve_local_sources
+    ir = retrieve_ir_for_inlining(mi, ir, preserve_local_sources)
+    return InliningTodo(mi, ir, result.effects)
 end
 
 function handle_semi_concrete_result!(cases::Vector{InliningCase}, result::SemiConcreteResult,
@@ -1597,20 +1595,15 @@ function handle_opaque_closure_call!(todo::Vector{Pair{Int,Any}},
     if isa(result, ConstPropResult)
         mi = result.result.linfo
         validate_sparams(mi.sparam_vals) || return nothing
-        item = resolve_todo(mi, result.result, sig.argtypes, info, flag, state)
+        item = resolve_todo(mi, result.result, info, flag, state)
     elseif isa(result, ConcreteResult)
         item = concrete_result_item(result, info, state)
+    elseif isa(result, SemiConcreteResult)
+        item = item = semiconcrete_result_item(result, info, flag, state)
     else
-        if isa(result, SemiConcreteResult)
-            result = inlining_policy(state.interp, result, info, flag, result.mi, sig.argtypes)
-        end
-        if isa(result, SemiConcreteResult)
-            item = semiconcrete_result_item(result, info, flag, state)
-        else
-            @assert result === nothing || result isa VolatileInferenceResult
-            volatile_inf_result = result
-            item = analyze_method!(info.match, sig.argtypes, info, flag, state; allow_typevars=false, volatile_inf_result)
-        end
+        @assert result === nothing || result isa VolatileInferenceResult
+        volatile_inf_result = result
+        item = analyze_method!(info.match, sig.argtypes, info, flag, state; allow_typevars=false, volatile_inf_result)
     end
     handle_single_case!(todo, ir, idx, stmt, item)
     return nothing
@@ -1678,7 +1671,7 @@ end
 function handle_invoke_expr!(todo::Vector{Pair{Int,Any}}, ir::IRCode,
     idx::Int, stmt::Expr, @nospecialize(info::CallInfo), flag::UInt32, sig::Signature, state::InliningState)
     mi = stmt.args[1]::MethodInstance
-    case = resolve_todo(mi, sig.argtypes, info, flag, state)
+    case = resolve_todo(mi, info, flag, state)
     handle_single_case!(todo, ir, idx, stmt, case, false)
     return nothing
 end
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 1bdd1c642a17a..ce3d5f96337a6 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1236,7 +1236,7 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
         src = nothing
     end
 
-    src = inlining_policy(inlining.interp, src, info, IR_FLAG_NULL, mi, Any[])
+    src = inlining_policy(inlining.interp, src, info, IR_FLAG_NULL)
     src === nothing && return false
     src = retrieve_ir_for_inlining(mi, src)
 
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 083071b566da6..2980e456e9f9c 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -335,14 +335,12 @@ function CC.abstract_call(interp::NoinlineInterpreter,
     return ret
 end
 function CC.inlining_policy(interp::NoinlineInterpreter,
-    @nospecialize(src), @nospecialize(info::CallInfo), stmt_flag::UInt32, mi::MethodInstance,
-    argtypes::Vector{Any})
+    @nospecialize(src), @nospecialize(info::CallInfo), stmt_flag::UInt32)
     if isa(info, NoinlineCallInfo)
         return nothing
     end
     return @invoke CC.inlining_policy(interp::CC.AbstractInterpreter,
-        src::Any, info::CallInfo, stmt_flag::UInt32, mi::MethodInstance,
-        argtypes::Vector{Any})
+        src::Any, info::CallInfo, stmt_flag::UInt32)
 end
 
 @inline function inlined_usually(x, y, z)

From 42c088b8b3e678edd19e5cb9ea54503e43624d06 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Fri, 10 Nov 2023 05:47:38 -0600
Subject: [PATCH 0226/1315] Fix errors in `sort` docstring (#52098)

Two chagnes wrapped into one `Base.copymutable` => `Base.copymutable` &
`collect` and `Base.copymutable` => `similar` & words.

Followup for #52086 and #46104; also fixes #51932 (though we still may
want to make `copymutable` public at some point)

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/sort.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/sort.jl b/base/sort.jl
index be5ed28b43ebe..f35add7a55b35 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -1474,7 +1474,8 @@ end
 
 Variant of [`sort!`](@ref) that returns a sorted copy of `v` leaving `v` itself unmodified.
 
-Uses `Base.copymutable` to support immutable collections and iterables.
+Returns something [`similar`](@ref) to `v` when `v` is an `AbstractArray` and uses
+[`collect`](@ref) to support arbitrary non-`AbstractArray` iterables.
 
 !!! compat "Julia 1.10"
     `sort` of arbitrary iterables requires at least Julia 1.10.

From d88d5cddacdc96c1eb13f12c9c3541e5f2908e02 Mon Sep 17 00:00:00 2001
From: Petr Vana <petvana@gmail.com>
Date: Fri, 10 Nov 2023 15:30:10 +0100
Subject: [PATCH 0227/1315] Optimize `pop!(s::Set, x, default)` (#52023)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Minor optimization to compute index in `Dict` only once.

This PR should not be merged before #52017.

**Master**
``` julia
  126.417 μs (1 allocation: 16 bytes)
  147.812 μs (1 allocation: 16 bytes)
```

**PR**
``` julia
  86.494 μs (1 allocation: 16 bytes)
  156.912 μs (1 allocation: 16 bytes)
```

<details>
<summary><b><u>Testing code</u></b></summary>

``` julia
using BenchmarkTools

function PR_pop!(s::Set, x, default)
    dict = s.dict
    index = Base.ht_keyindex(dict, x)
    if index > 0
        @inbounds key = dict.keys[index]
        Base._delete!(dict, index)
        return key
    else
        return default
    end
end

N = 10000
x = collect(1:N)
x_negative = collect(-N:-1)

function pop_all(s, x)
    for v in x
        pop!(s, v, -1)
    end
end

function pop_all_PR(s, x)
    for v in x
        PR_pop!(s, v, -1)
    end
end

# Master
@btime pop_all(s, x) setup=(s=Set(x))
@btime pop_all(s, x_negative) setup=(s=Set(x))

# PR
@btime pop_all_PR(s, x) setup=(s=Set(x))
@btime pop_all_PR(s, x_negative) setup=(s=Set(x))
```
</details>
---
 base/set.jl | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/base/set.jl b/base/set.jl
index e3013ac807095..1831df62efec5 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -102,7 +102,18 @@ end
 
 push!(s::Set, x) = (s.dict[x] = nothing; s)
 
-pop!(s::Set, x, default) = (x in s ? pop!(s, x) : default)
+function pop!(s::Set, x, default)
+    dict = s.dict
+    index = ht_keyindex(dict, x)
+    if index > 0
+        @inbounds key = dict.keys[index]
+        _delete!(dict, index)
+        return key
+    else
+        return default
+    end
+end
+
 function pop!(s::Set, x)
     index = ht_keyindex(s.dict, x)
     index < 1 && throw(KeyError(x))

From 0513228cae1e28fd1614226899b996b51130a028 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 10 Nov 2023 12:45:54 -0500
Subject: [PATCH 0228/1315] staticdata: gc the global_roots_table contents
 during saving (#52088)

A (very) small memory optimization to avoid saving objects that are
essentially unreachable
---
 src/staticdata.c | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/staticdata.c b/src/staticdata.c
index 72fac1c3c845e..74ac268508ede 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -2594,6 +2594,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
             jl_docmeta_sym = (jl_sym_t*)jl_get_global((jl_module_t*)docs, jl_symbol("META"));
         }
     }
+    jl_genericmemory_t *global_roots_table = NULL;
 
     { // step 1: record values (recursively) that need to go in the image
         size_t i;
@@ -2602,7 +2603,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
                 jl_value_t *tag = *tags[i];
                 jl_queue_for_serialization(&s, tag);
             }
-            jl_queue_for_serialization(&s, jl_global_roots_table);
             jl_queue_for_serialization(&s, s.ptls->root_task->tls);
         }
         else {
@@ -2638,8 +2638,19 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
         record_gvars(&s, &gvars);
         record_external_fns(&s, &external_fns);
         jl_serialize_reachable(&s);
-        // step 1.3: prune (garbage collect) some special weak references from
-        // built-in type caches
+        // step 1.3: prune (garbage collect) special weak references from the jl_global_roots_table
+        if (worklist == NULL) {
+            global_roots_table = jl_alloc_memory_any(0);
+            for (size_t i = 0; i < jl_global_roots_table->length; i += 2) {
+                jl_value_t *val = jl_genericmemory_ptr_ref(jl_global_roots_table, i);
+                if (ptrhash_get(&serialization_order, val) != HT_NOTFOUND)
+                    global_roots_table = jl_eqtable_put(global_roots_table, val, jl_nothing, NULL);
+            }
+            jl_queue_for_serialization(&s, global_roots_table);
+            jl_serialize_reachable(&s);
+        }
+        // step 1.4: prune (garbage collect) some special weak references from
+        // built-in type caches too
         for (i = 0; i < serialization_queue.len; i++) {
             jl_typename_t *tn = (jl_typename_t*)serialization_queue.items[i];
             if (jl_is_typename(tn)) {
@@ -2747,7 +2758,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
                 jl_value_t *tag = *tags[i];
                 jl_write_value(&s, tag);
             }
-            jl_write_value(&s, jl_global_roots_table);
+            jl_write_value(&s, global_roots_table);
             jl_write_value(&s, s.ptls->root_task->tls);
             write_uint32(f, jl_get_gs_ctr());
             write_uint(f, jl_atomic_load_acquire(&jl_world_counter));

From 786caaa567255f2f63a12f41bd47f0f20331a237 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 10 Nov 2023 12:47:44 -0500
Subject: [PATCH 0229/1315] lowering: avoid calling a generated function to
 make new IR just for the side-effect of calling diff_names for kwarg error
 checking (#52081)

empirically this makes a very minor difference, but it seems to be at
least very slightly more optimal in bytes allocated for some tests,
though I didn't check very many tests to compare broadly
```
show         (6) |    15.72 |   0.18 |  1.1 |    2695.53 |   696.03
show         (6) |    15.82 |   0.18 |  1.2 |    2734.35 |   707.94
```
---
 src/julia-syntax.scm | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 6afb8afaffbea..c1e9fcf429c66 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -509,7 +509,7 @@
                   sparams))
          (kw      (gensy))
          (kwdecl  `(|::| ,kw (core NamedTuple)))
-         (rkw     (if (null? restkw) (make-ssavalue) (symbol (string (car restkw) "..."))))
+         (rkw     (if (null? restkw) '() (symbol (string (car restkw) "..."))))
          (restkw  (map (lambda (v) `(|::| ,v (call (top pairs) (core NamedTuple)))) restkw))
          (mangled (let ((und (and name (undot-name name))))
                     (symbol (string (if (and name (= (string.char (string name) 0) #\#))
@@ -608,16 +608,18 @@
                                ,tempslot)))
                    vars vals)
               `(block
-                (= ,rkw (call (top pairs)
-                              ,(if (null? keynames)
-                                   kw
-                                   `(call (top structdiff) ,kw (curly (core NamedTuple)
-                                                                      (tuple ,@(map quotify keynames)))))))
-                ,@(if (null? restkw)
-                      `((if (call (top isempty) ,rkw)
+                ,(if (null? restkw)
+                      `(if (call (top isempty)
+                                 (call (top diff_names)
+                                       (call (top keys) ,kw)
+                                       (tuple ,@(map quotify keynames))))
                             (null)
-                            (call (top kwerr) ,kw ,@(map arg-name pargl) ,@splatted-vararg)))
-                      '())
+                            (call (top kwerr) ,kw ,@(map arg-name pargl) ,@splatted-vararg))
+                      `(= ,rkw (call (top pairs)
+                                     ,(if (null? keynames)
+                                          kw
+                                          `(call (top structdiff) ,kw (curly (core NamedTuple)
+                                                                             (tuple ,@(map quotify keynames))))))))
                 (return (call ,mangled  ;; finally, call the core function
                               ,@keyvars
                               ,@(if (null? restkw) '() (list rkw))

From 9eb277059ca7fec1ac1d56117a2ff94a2956a841 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 10 Nov 2023 12:48:31 -0500
Subject: [PATCH 0230/1315] add sizehint! for `first` and make append!/prepend!
 safer (#51903)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

First we add an optional API parameter for `sizehint!` that controls
whether it is for `push!` (default) or `pushfirst!`. Secondly, we make
the offset zero when using `sizehint!` to shrink an array from the end,
or the trailing size zero when using it to shring from the beginning.

Then we replace the prior implementations of `prepend!` and `append!`
with ones that are safe even if the iterator changes length during the
operation or if convert fails. The result of `prepend!` may be in an
undefined order (because of the `reverse!` call) in the presence of
concurrent modifications or errors, but at least all of the elements
will be present and valid afterwards.

Replaces and closes #49905
Replaces and closes #47391
Fixes #15868

Benchmarks show that repeated `push!` performance (with sizehint) is
nearly equivalent to the old append performance:
```
julia> @benchmark append!(x, 1:1000) setup=x=Vector{Float64}(undef,0)
BenchmarkTools.Trial: 10000 samples with 10 evaluations.
 Range (min … max):  1.027 μs … 72.871 μs  ┊ GC (min … max): 0.00% … 94.57%
 Time  (median):     1.465 μs              ┊ GC (median):    0.00%
 Time  (mean ± σ):   1.663 μs ±  1.832 μs  ┊ GC (mean ± σ):  6.20% ±  5.67%

             ▂▃▅▆█▇▇▆▄▂▁
  ▂▁▁▂▂▂▂▃▄▅▇█████████████▇▆▅▅▅▅▅▅▄▅▄▅▅▅▆▇███▆▅▄▃▃▂▂▂▂▂▂▂▂▂▂ ▄
  1.03 μs        Histogram: frequency by time        2.31 μs <

 Memory estimate: 19.69 KiB, allocs estimate: 0.

julia> @benchmark append!(x, 1:1000) setup=x=Vector{Int}(undef,0)
BenchmarkTools.Trial: 10000 samples with 10 evaluations.
 Range (min … max):  851.900 ns … 76.757 μs  ┊ GC (min … max): 0.00% … 91.59%
 Time  (median):       1.181 μs              ┊ GC (median):    0.00%
 Time  (mean ± σ):     1.543 μs ±  1.972 μs  ┊ GC (mean ± σ):  6.75% ±  5.75%

     ▆█▇▃
  ▂▃██████▇▅▅▄▅▅▃▂▂▂▃▃▃▂▃▃▃▂▂▂▂▂▁▂▁▂▁▂▂▂▁▁▂▂▁▁▁▁▁▁▁▂▂▂▃▃▃▃▂▂▂▂ ▃
  852 ns          Histogram: frequency by time         4.07 μs <

 Memory estimate: 19.69 KiB, allocs estimate: 0.
```

Co-authored-by: Sukera <Seelengrab@users.noreply.github.com>
Co-authored-by: MasonProtter <mason.protter@icloud.com>
---
 base/array.jl         | 84 ++++++++++++++++++++++++-------------------
 base/bitset.jl        |  5 ++-
 base/dict.jl          |  4 +--
 base/set.jl           |  2 +-
 test/abstractarray.jl | 22 ++++++++++++
 test/arrayops.jl      | 26 ++++++++++++++
 6 files changed, 102 insertions(+), 41 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index a8d98be3a9b9f..d883c620428e4 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -1294,11 +1294,11 @@ and [`prepend!`](@ref) and [`pushfirst!`](@ref) for the opposite order.
 """
 function append! end
 
-function append!(a::Vector, items::AbstractVector)
-    itemindices = eachindex(items)
-    n = length(itemindices)
+function append!(a::Vector{T}, items::Union{AbstractVector{<:T},Tuple}) where T
+    items isa Tuple && (items = map(x -> convert(T, x), items))
+    n = length(items)
     _growend!(a, n)
-    copyto!(a, length(a)-n+1, items, first(itemindices), n)
+    copyto!(a, length(a)-n+1, items, firstindex(items), n)
     return a
 end
 
@@ -1308,16 +1308,11 @@ push!(a::AbstractVector, iter...) = append!(a, iter)
 append!(a::AbstractVector, iter...) = foldl(append!, iter, init=a)
 
 function _append!(a::AbstractVector, ::Union{HasLength,HasShape}, iter)
-    @_terminates_locally_meta
-    n = length(a)
+    n = Int(length(iter))::Int
     i = lastindex(a)
-    resize!(a, n+Int(length(iter))::Int)
-    for (i, item) in zip(i+1:lastindex(a), iter)
-        if isa(a, Vector) # give better effects for builtin vectors
-            @_safeindex a[i] = item
-        else
-            a[i] = item
-        end
+    sizehint!(a, length(a) + n; shrink=false)
+    for item in iter
+        push!(a, item)
     end
     a
 end
@@ -1359,15 +1354,13 @@ julia> prepend!([6], [1, 2], [3, 4, 5])
 """
 function prepend! end
 
-function prepend!(a::Vector, items::AbstractVector)
-    itemindices = eachindex(items)
-    n = length(itemindices)
+function prepend!(a::Vector{T}, items::Union{AbstractVector{<:T},Tuple}) where T
+    items isa Tuple && (items = map(x -> convert(T, x), items))
+    n = length(items)
     _growbeg!(a, n)
-    if a === items
-        copyto!(a, 1, items, n+1, n)
-    else
-        copyto!(a, 1, items, first(itemindices), n)
-    end
+    # in case of aliasing, the _growbeg might have shifted our data, so copy
+    # just the last n elements instead of all of them from the first
+    copyto!(a, 1, items, lastindex(items)-n+1, n)
     return a
 end
 
@@ -1379,12 +1372,14 @@ prepend!(a::AbstractVector, iter...) = foldr((v, a) -> prepend!(a, v), iter, ini
 function _prepend!(a::Vector, ::Union{HasLength,HasShape}, iter)
     @_terminates_locally_meta
     require_one_based_indexing(a)
-    n = length(iter)
-    _growbeg!(a, n)
-    i = 0
+    n = Int(length(iter))::Int
+    sizehint!(a, length(a) + n; first=true, shrink=false)
+    n = 0
     for item in iter
-        @_safeindex a[i += 1] = item
+        n += 1
+        pushfirst!(a, item)
     end
+    reverse!(a, 1, n)
     a
 end
 function _prepend!(a::Vector, ::IteratorSize, iter)
@@ -1441,13 +1436,17 @@ function resize!(a::Vector, nl::Integer)
 end
 
 """
-    sizehint!(s, n; shrink::Bool = true) -> s
+    sizehint!(s, n; first::Bool=false, shrink::Bool=true) -> s
 
 Suggest that collection `s` reserve capacity for at least `n` elements. That is, if
 you expect that you're going to have to push a lot of values onto `s`, you can avoid
 the cost of incremental reallocation by doing it once up front; this can improve
 performance.
 
+If `first` is true, then the reserved space is from the start of the collection, for ordered
+collections. Supplying this keyword may result in an error if the collection is nor ordered
+or if `pushfirst!` is not supported for this collection.
+
 See also [`resize!`](@ref).
 
 # Notes on the performance model
@@ -1466,32 +1465,37 @@ For types that support `sizehint!`,
 4. `shrink` controls if the collection can be shrunk.
 
 !!! compat "Julia 1.11"
-    The `shrink` argument was added in Julia 1.11.
+    The `shrink` and `first` arguments were added in Julia 1.11.
 """
 function sizehint! end
 
-function sizehint!(a::Vector, sz::Integer; shrink::Bool = true)
+function sizehint!(a::Vector, sz::Integer; first::Bool=false, shrink::Bool=true)
     len = length(a)
     ref = a.ref
     mem = ref.mem
     memlen = length(mem)
-    offset = memoryrefoffset(ref)
-    sz = max(Int(sz), offset + len - 1)
+    sz = max(Int(sz), len)
+    inc = sz - len
     if sz <= memlen
         # if we don't save at least 1/8th memlen then its not worth it to shrink
         if !shrink || memlen - sz <= div(memlen, 8)
             return a
         end
         newmem = array_new_memory(mem, sz)
-        if len == 0
-            newref = GenericMemoryRef(newmem)
+        if first
+            newref = GenericMemoryRef(newmem, inc + 1)
         else
-            unsafe_copyto!(newmem, offset, mem, offset, len)
-            newref = @inbounds GenericMemoryRef(newmem, offset)
+            newref = GenericMemoryRef(newmem)
         end
+        unsafe_copyto!(newref, ref, len)
         setfield!(a, :ref, newref)
-    else
-        inc = sz - len;
+    elseif first
+        _growbeg!(a, inc)
+        newref = getfield(a, :ref)
+        newref = GenericMemoryRef(newref, inc + 1)
+        setfield!(a, :size, (len,)) # undo the size change from _growbeg!
+        setfield!(a, :ref, newref) # undo the offset change from _growbeg!
+    else # last
         _growend!(a, inc)
         setfield!(a, :size, (len,)) # undo the size change from _growend!
     end
@@ -1499,7 +1503,13 @@ function sizehint!(a::Vector, sz::Integer; shrink::Bool = true)
 end
 
 # Fall-back implementation for non-shrinkable collections
-sizehint!(a, sz; shrink::Bool) = sizehint!(a, sz)
+# avoid defining this the normal way to avoid avoid infinite recursion
+function Core.kwcall(kwargs::NamedTuple{names}, ::typeof(sizehint!), a, sz) where names
+    get(kwargs, :first, false)::Bool
+    get(kwargs, :shrink, true)::Bool
+    isempty(diff_names(names, (:first, :shrink))) || kwerr(kwargs, sizehint!, a, sz)
+    sizehint!(a, sz)
+end
 
 """
     pop!(collection) -> item
diff --git a/base/bitset.jl b/base/bitset.jl
index 0e26fc28acbd0..78d8fc8769de1 100644
--- a/base/bitset.jl
+++ b/base/bitset.jl
@@ -55,7 +55,10 @@ function copy!(dest::BitSet, src::BitSet)
     dest
 end
 
-sizehint!(s::BitSet, n::Integer) = (sizehint!(s.bits, (n+63) >> 6); s)
+function sizehint!(s::BitSet, n::Integer; first::Bool=false, shrink::Bool=true)
+    sizehint!(s.bits, (n+63) >> 6; first, shrink)
+    s
+end
 
 function _bits_getindex(b::Bits, n::Int, offset::Int)
     ci = _div64(n) - offset + 1
diff --git a/base/dict.jl b/base/dict.jl
index 7eef5e76e140a..26896c78a7008 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -228,7 +228,7 @@ end
     return h
 end
 
-function sizehint!(d::Dict{T}, newsz; shrink::Bool = true) where T
+function sizehint!(d::Dict{T}, newsz; shrink::Bool=true) where T
     oldsz = length(d.slots)
     # limit new element count to max_values of the key type
     newsz = min(max(newsz, length(d)), max_values(T)::Int)
@@ -775,7 +775,7 @@ function map!(f, iter::ValueIterator{<:Dict})
 end
 
 function mergewith!(combine, d1::Dict{K, V}, d2::AbstractDict) where {K, V}
-    haslength(d2) && sizehint!(d1, length(d1) + length(d2), shrink = false)
+    haslength(d2) && sizehint!(d1, length(d1) + length(d2), shrink=false)
     for (k, v) in d2
         i, sh = ht_keyindex2_shorthash!(d1, k)
         if i > 0
diff --git a/base/set.jl b/base/set.jl
index 1831df62efec5..4708197588f3c 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -135,7 +135,7 @@ copymutable(s::Set{T}) where {T} = Set{T}(s)
 # Set is the default mutable fall-back
 copymutable(s::AbstractSet{T}) where {T} = Set{T}(s)
 
-sizehint!(s::Set, newsz; shrink::Bool = true) = (sizehint!(s.dict, newsz, shrink = shrink); s)
+sizehint!(s::Set, newsz; shrink::Bool=true) = (sizehint!(s.dict, newsz; shrink); s)
 empty!(s::Set) = (empty!(s.dict); s)
 rehash!(s::Set) = (rehash!(s.dict); s)
 
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 1e370a7dfdfa8..8762440a2f25a 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1354,6 +1354,28 @@ Base.pushfirst!(tpa::TestPushArray{T}, a::T) where T = pushfirst!(tpa.data, a)
     @test tpa.data == reverse(collect(1:6))
 end
 
+mutable struct SimpleArray{T} <: AbstractVector{T}
+    els::Vector{T}
+end
+Base.size(sa::SimpleArray) = size(sa.els)
+Base.getindex(sa::SimpleArray, idx...) = getindex(sa.els, idx...)
+Base.setindex!(sa::SimpleArray, v, idx...) = setindex!(sa.els, v, idx...)
+Base.resize!(sa::SimpleArray, n) = resize!(sa.els, n)
+Base.copy(sa::SimpleArray) = SimpleArray(copy(sa.els))
+
+isdefined(Main, :OffsetArrays) || @eval Main include("testhelpers/OffsetArrays.jl")
+using .Main.OffsetArrays
+
+@testset "Failing `$f` should not grow the array $a" for
+        f in (push!, append!, pushfirst!, prepend!),
+        a in (["foo", "Bar"], SimpleArray(["foo", "Bar"]), OffsetVector(["foo", "Bar"], 0:1))
+    for args in ((1,), (1,2), ([1], [2]), [1])
+        orig = copy(a)
+        @test_throws Exception f(a, args...)
+        @test a == orig
+    end
+end
+
 @testset "splatting into hvcat" begin
     t = (1, 2)
     @test [t...; 3 4] == [1 2; 3 4]
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 2691da4b17154..30f00ca5d5a46 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -1786,6 +1786,32 @@ end
     # offset array
     @test append!([1,2], OffsetArray([9,8], (-3,))) == [1,2,9,8]
     @test prepend!([1,2], OffsetArray([9,8], (-3,))) == [9,8,1,2]
+
+    # Error recovery
+    A = [1, 2]
+    @test_throws MethodError append!(A, [1, 2, "hi"])
+    @test A == [1, 2, 1, 2]
+
+    oA = OffsetVector(A, 0:3)
+    @test_throws InexactError append!(oA, [1, 2, 3.01])
+    @test oA == OffsetVector([1, 2, 1, 2, 1, 2], 0:5)
+
+    @test_throws InexactError append!(A, (x for x in [1, 2, 3.1]))
+    @test A == [1, 2, 1, 2, 1, 2, 1, 2]
+
+    @test_throws InexactError append!(A, (x for x in [1, 2, 3.1] if isfinite(x)))
+    @test A == [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
+
+    @test_throws MethodError prepend!(A, [1, 2, "hi"])
+    @test A == [2, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
+
+    A = [1, 2]
+    @test_throws InexactError prepend!(A, (x for x in [1, 2, 3.1]))
+    @test A == [2, 1, 1, 2]
+
+    A = [1, 2]
+    @test_throws InexactError prepend!(A, (x for x in [1, 2, 3.1] if isfinite(x)))
+    @test A == [2, 1, 1, 2]
 end
 
 let A = [1,2]

From 5303a7a16c4bf87c7dfc3913e2a2308c08a124c1 Mon Sep 17 00:00:00 2001
From: Zentrik <Zentrik@users.noreply.github.com>
Date: Fri, 10 Nov 2023 17:51:28 +0000
Subject: [PATCH 0231/1315] Add `Dict` test whether key is updated on
 re-assignment (#52110)

Tests whether key is updated even if they are equal.

Refs #52066
---
 test/dict.jl | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/dict.jl b/test/dict.jl
index ff4a2ef11a97c..d3d1c3732eee2 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -1528,3 +1528,10 @@ Base.hash(::BadHash, ::UInt)=UInt(1)
     d[BadHash(1)]=nothing
     @test !(BadHash(2) in keys(d))
 end
+
+# Issue #52066
+let d = Dict()
+    d[1] = 'a'
+    d[1.0] = 'b'
+    @test only(d) === Pair{Any,Any}(1.0, 'b')
+end

From b567b377e532835ae1b2d1cdfcd92d925b1c6a2b Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Fri, 10 Nov 2023 11:52:39 -0600
Subject: [PATCH 0232/1315] docs: Add link to external tutorials (#52104)

---
 doc/make.jl                   | 1 +
 doc/src/tutorials/external.md | 4 ++++
 2 files changed, 5 insertions(+)
 create mode 100644 doc/src/tutorials/external.md

diff --git a/doc/make.jl b/doc/make.jl
index 89026f786f14b..78604a5fd3c75 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -129,6 +129,7 @@ StdlibDocs = [stdlib.targetfile for stdlib in STDLIB_DOCS]
 
 Tutorials = [
     "tutorials/profile.md",
+    "tutorials/external.md",
 ]
 
 DevDocs = [
diff --git a/doc/src/tutorials/external.md b/doc/src/tutorials/external.md
new file mode 100644
index 0000000000000..0211db3d63a5e
--- /dev/null
+++ b/doc/src/tutorials/external.md
@@ -0,0 +1,4 @@
+# External Tutorials
+
+We have created a non-exhaustive list of community provided Julia tutorials.
+[Check them out to learn Julia through the lens of someone from the community](https://julialang.org/learning/tutorials/).

From 8944a22b7aced0767cf8980ca6c89ca64de4a238 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 10 Nov 2023 23:23:03 +0530
Subject: [PATCH 0233/1315] Mark the indexing as `@inbounds` in `triu!`
 (#52117)

---
 stdlib/LinearAlgebra/src/dense.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 8d5a3e6ea8de2..c9eb7d3669d76 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -136,7 +136,7 @@ function triu!(M::AbstractMatrix, k::Integer)
     m, n = size(M)
     for j in 1:min(n, m + k)
         for i in max(1, j - k + 1):m
-            M[i,j] = zero(M[i,j])
+            @inbounds M[i,j] = zero(M[i,j])
         end
     end
     M

From 16e61e25c7e15280b1e3c11b549b410e324175c4 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 10 Nov 2023 19:47:53 -0500
Subject: [PATCH 0234/1315] Outline potentially undefined globals during
 lowering (#51970)

Currently [1] it is illegal [2] in IRCode to have a GlobalRef in value
position that could potentially throw. This is because in IRCode, we
want to assign flags to every statement and if there are multiple things
with effects in a statement, we lose precision in tracking which they
apply to. However, we currently do allow this in `CodeInfo`. Now that
we're starting to make more use of flags in inference also, this is
becoming annoying (as it did for IRCode), so I would like to do this
transformation earlier. This is an attempt to do this during lowering.
It is not entirely clear that this is precisely the correct place for
it. We could alternatively consider doing it during the global resolve
pass in method.c, but that currently does not renumber SSAValues, so
doing it during the renumbering inside lowering may be easier.

N.B.: This is against #51853, because this needs some of the inference
precision improvements in that PR to avoid regressing the try/catch
elision tests (which before that PR, we were incorrectly computing
effects for statement-position GlobalRefs).

[1]
https://github.com/JuliaLang/julia/commit/39c278b728deb04c3a32d70e3e35dcef7822c0c0
[2]
https://github.com/JuliaLang/julia/blob/2f63cc99fb134fb4adb7f11ba86a4e2ab5adcd48/base/compiler/ssair/verify.jl#L54-L58

---------

Co-authored-by: Jeff Bezanson <jeff.bezanson@gmail.com>
Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
---
 base/compiler/abstractinterpretation.jl | 16 +++--
 base/compiler/utilities.jl              |  7 +-
 base/reflection.jl                      |  2 +
 doc/src/base/reflection.md              |  2 +-
 src/ast.c                               | 61 ++++++++++++-----
 src/jlfrontend.scm                      |  1 +
 src/julia-syntax.scm                    | 87 +++++++++++++++----------
 src/toplevel.c                          | 11 ++--
 stdlib/Test/src/Test.jl                 |  2 +-
 test/compiler/inference.jl              | 19 ++++--
 test/core.jl                            | 48 +++++++++-----
 test/meta.jl                            | 10 +--
 test/syntax.jl                          | 13 +++-
 13 files changed, 185 insertions(+), 94 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index a092b0312eaf1..96b63c91d9dd5 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -320,7 +320,7 @@ function from_interprocedural!(interp::AbstractInterpreter, @nospecialize(rt), s
                                arginfo::ArgInfo, @nospecialize(maybecondinfo))
     rt = collect_limitations!(rt, sv)
     if isa(rt, InterMustAlias)
-        rt = from_intermustalias(rt, arginfo)
+        rt = from_intermustalias(rt, arginfo, sv)
     elseif is_lattice_bool(ipo_lattice(interp), rt)
         if maybecondinfo === nothing
             rt = widenconditional(rt)
@@ -340,10 +340,10 @@ function collect_limitations!(@nospecialize(typ), sv::InferenceState)
     return typ
 end
 
-function from_intermustalias(rt::InterMustAlias, arginfo::ArgInfo)
+function from_intermustalias(rt::InterMustAlias, arginfo::ArgInfo, sv::AbsIntState)
     fargs = arginfo.fargs
     if fargs !== nothing && 1 ≤ rt.slot ≤ length(fargs)
-        arg = fargs[rt.slot]
+        arg = ssa_def_slot(fargs[rt.slot], sv)
         if isa(arg, SlotNumber)
             argtyp = widenslotwrapper(arginfo.argtypes[rt.slot])
             if rt.vartyp ⊑ argtyp
@@ -1334,6 +1334,9 @@ function ssa_def_slot(@nospecialize(arg), sv::InferenceState)
     return arg
 end
 
+# No slots in irinterp
+ssa_def_slot(@nospecialize(arg), sv::IRInterpretationState) = nothing
+
 struct AbstractIterationResult
     cti::Vector{Any}
     info::MaybeAbstractIterationInfo
@@ -1743,7 +1746,7 @@ function abstract_call_builtin(interp::AbstractInterpreter, f::Builtin, (; fargs
         a3 = argtypes[3]
         if isa(a3, Const)
             if rt !== Bottom && !isalreadyconst(rt)
-                var = fargs[2]
+                var = ssa_def_slot(fargs[2], sv)
                 if isa(var, SlotNumber)
                     vartyp = widenslotwrapper(argtypes[2])
                     fldidx = maybe_const_fldidx(vartyp, a3.val)
@@ -3047,6 +3050,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                     @goto branch
                 elseif isa(stmt, GotoIfNot)
                     condx = stmt.cond
+                    condxslot = ssa_def_slot(condx, frame)
                     condt = abstract_eval_value(interp, condx, currstate, frame)
                     if condt === Bottom
                         ssavaluetypes[currpc] = Bottom
@@ -3054,10 +3058,10 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                         @goto find_next_bb
                     end
                     orig_condt = condt
-                    if !(isa(condt, Const) || isa(condt, Conditional)) && isa(condx, SlotNumber)
+                    if !(isa(condt, Const) || isa(condt, Conditional)) && isa(condxslot, SlotNumber)
                         # if this non-`Conditional` object is a slot, we form and propagate
                         # the conditional constraint on it
-                        condt = Conditional(condx, Const(true), Const(false))
+                        condt = Conditional(condxslot, Const(true), Const(false))
                     end
                     condval = maybe_extract_const_bool(condt)
                     nothrow = (condval !== nothing) || ⊑(𝕃ᵢ, orig_condt, Bool)
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index f46f9f19ee629..3d1fe35453060 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -446,9 +446,12 @@ function find_ssavalue_uses(e::PhiNode, uses::Vector{BitSet}, line::Int)
     end
 end
 
-function is_throw_call(e::Expr)
+function is_throw_call(e::Expr, code::Vector{Any})
     if e.head === :call
         f = e.args[1]
+        if isa(f, SSAValue)
+            f = code[f.id]
+        end
         if isa(f, GlobalRef)
             ff = abstract_eval_globalref_type(f)
             if isa(ff, Const) && ff.val === Core.throw
@@ -478,7 +481,7 @@ function find_throw_blocks(code::Vector{Any}, handler_at::Vector{Int})
                 end
             elseif s.head === :return
                 # see `ReturnNode` handling
-            elseif is_throw_call(s)
+            elseif is_throw_call(s, code)
                 if handler_at[i] == 0
                     push!(stmts, i)
                 end
diff --git a/base/reflection.jl b/base/reflection.jl
index e0764ee761a3e..5e32d6e68a58e 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -2081,6 +2081,8 @@ function bodyfunction(basemethod::Method)
                     else
                         return nothing
                     end
+                elseif isa(fsym, Core.SSAValue)
+                    fsym = ast.code[fsym.id]
                 else
                     return nothing
                 end
diff --git a/doc/src/base/reflection.md b/doc/src/base/reflection.md
index e5c70175e5f9a..d44bc474abbd2 100644
--- a/doc/src/base/reflection.md
+++ b/doc/src/base/reflection.md
@@ -97,7 +97,7 @@ Finally, the [`Meta.lower`](@ref) function gives the `lowered` form of any expre
 particular interest for understanding how language constructs map to primitive operations such
 as assignments, branches, and calls:
 
-```jldoctest
+```jldoctest; setup = (using Base: +, sin)
 julia> Meta.lower(@__MODULE__, :( [1+2, sin(0.5)] ))
 :($(Expr(:thunk, CodeInfo(
     @ none within `top-level scope`
diff --git a/src/ast.c b/src/ast.c
index 9e22369d836b9..e6adbdc4d5aac 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -153,17 +153,61 @@ static jl_value_t *scm_to_julia(fl_context_t *fl_ctx, value_t e, jl_module_t *mo
 static value_t julia_to_scm(fl_context_t *fl_ctx, jl_value_t *v);
 static jl_value_t *jl_expand_macros(jl_value_t *expr, jl_module_t *inmodule, struct macroctx_stack *macroctx, int onelevel, size_t world, int throw_load_error);
 
+static jl_sym_t *scmsym_to_julia(fl_context_t *fl_ctx, value_t s)
+{
+    assert(issymbol(s));
+    if (fl_isgensym(fl_ctx, s)) {
+        char gsname[16];
+        char *n = uint2str(&gsname[1], sizeof(gsname)-1,
+                           ((gensym_t*)ptr(s))->id, 10);
+        *(--n) = '#';
+        return jl_symbol(n);
+    }
+    return jl_symbol(symbol_name(fl_ctx, s));
+}
+
 static value_t fl_defined_julia_global(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     // tells whether a var is defined in and *by* the current module
     argcount(fl_ctx, "defined-julia-global", nargs, 1);
     (void)tosymbol(fl_ctx, args[0], "defined-julia-global");
     jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
-    jl_sym_t *var = jl_symbol(symbol_name(fl_ctx, args[0]));
+    jl_sym_t *var = scmsym_to_julia(fl_ctx, args[0]);
     jl_binding_t *b = jl_get_module_binding(ctx->module, var, 0);
     return (b != NULL && jl_atomic_load_relaxed(&b->owner) == b) ? fl_ctx->T : fl_ctx->F;
 }
 
+static value_t fl_nothrow_julia_global(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
+{
+    // tells whether a var is defined, in the sense that accessing it is nothrow
+    // can take either a symbol or a module and a symbol
+    jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
+    jl_module_t *mod = ctx->module;
+    jl_sym_t *var = NULL;
+    if (nargs == 1) {
+        (void)tosymbol(fl_ctx, args[0], "nothrow-julia-global");
+        var = scmsym_to_julia(fl_ctx, args[0]);
+    }
+    else {
+        argcount(fl_ctx, "nothrow-julia-global", nargs, 2);
+        value_t argmod = args[0];
+        if (iscvalue(argmod) && cv_class((cvalue_t*)ptr(argmod)) == jl_ast_ctx(fl_ctx)->jvtype) {
+            mod = *(jl_module_t**)cv_data((cvalue_t*)ptr(argmod));
+            JL_GC_PROMISE_ROOTED(mod);
+        } else {
+            (void)tosymbol(fl_ctx, argmod, "nothrow-julia-global");
+            if (scmsym_to_julia(fl_ctx, argmod) != jl_thismodule_sym) {
+                lerrorf(fl_ctx, fl_ctx->ArgError, "nothrow-julia-global: Unknown globalref module kind");
+            }
+        }
+        (void)tosymbol(fl_ctx, args[1], "nothrow-julia-global");
+        var = scmsym_to_julia(fl_ctx, args[1]);
+    }
+    jl_binding_t *b = jl_get_module_binding(mod, var, 0);
+    b = b ? jl_atomic_load_relaxed(&b->owner) : NULL;
+    return b != NULL && jl_atomic_load_relaxed(&b->value) != NULL ? fl_ctx->T : fl_ctx->F;
+}
+
 static value_t fl_current_module_counter(fl_context_t *fl_ctx, value_t *args, uint32_t nargs) JL_NOTSAFEPOINT
 {
     jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
@@ -210,6 +254,7 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, jl_module_t *m
 
 static const builtinspec_t julia_flisp_ast_ext[] = {
     { "defined-julia-global", fl_defined_julia_global }, // TODO: can we kill this safepoint
+    { "nothrow-julia-global", fl_nothrow_julia_global },
     { "current-julia-module-counter", fl_current_module_counter },
     { "julia-scalar?", fl_julia_scalar },
     { "julia-current-file", fl_julia_current_file },
@@ -421,20 +466,6 @@ JL_DLLEXPORT void fl_profile(const char *fname)
     jl_ast_ctx_leave(ctx);
 }
 
-
-static jl_sym_t *scmsym_to_julia(fl_context_t *fl_ctx, value_t s)
-{
-    assert(issymbol(s));
-    if (fl_isgensym(fl_ctx, s)) {
-        char gsname[16];
-        char *n = uint2str(&gsname[1], sizeof(gsname)-1,
-                           ((gensym_t*)ptr(s))->id, 10);
-        *(--n) = '#';
-        return jl_symbol(n);
-    }
-    return jl_symbol(symbol_name(fl_ctx, s));
-}
-
 static jl_value_t *scm_to_julia(fl_context_t *fl_ctx, value_t e, jl_module_t *mod)
 {
     jl_value_t *v = NULL;
diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index 34a8f5405676a..b46663c560346 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -31,6 +31,7 @@
 
 ;; this is overwritten when we run in actual julia
 (define (defined-julia-global v) #f)
+(define (nothrow-julia-global v) #f)
 (define (julia-current-file) 'none)
 (define (julia-current-line) 0)
 
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index c1e9fcf429c66..2937f31ecc0f2 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -4254,17 +4254,21 @@ f(x) = yt(x)
         (else (for-each linearize (cdr e))))
   e)
 
+;; N.B.: This assumes that resolve-scopes has run, so outerref is equivalent to
+;; a global in the current scope.
 (define (valid-ir-argument? e)
-  (or (simple-atom? e) (symbol? e)
+  (or (simple-atom? e)
+      (and (outerref? e) (nothrow-julia-global (cadr e)))
+      (and (globalref? e) (nothrow-julia-global (cadr e) (caddr e)))
       (and (pair? e)
-           (memq (car e) '(quote inert top core globalref outerref
+           (memq (car e) '(quote inert top core
                                  slot static_parameter)))))
 
 (define (valid-ir-rvalue? lhs e)
   (or (ssavalue? lhs)
       (valid-ir-argument? e)
       (and (symbol? lhs) (pair? e)
-           (memq (car e) '(new splatnew the_exception isdefined call invoke foreigncall cfunction gc_preserve_begin copyast new_opaque_closure)))))
+           (memq (car e) '(new splatnew the_exception isdefined call invoke foreigncall cfunction gc_preserve_begin copyast new_opaque_closure globalref outerref)))))
 
 (define (valid-ir-return? e)
   ;; returning lambda directly is needed for @generated
@@ -4410,48 +4414,59 @@ f(x) = yt(x)
           (else                (string "\"" h "\" expression"))))
       (if (not (null? (cadr lam)))
           (error (string (head-to-text (car e)) " not at top level"))))
+    (define (valid-body-ir-argument? aval)
+      (or (valid-ir-argument? aval)
+          (and (symbol? aval) ; Arguments are always defined slots
+               (or (memq aval (lam:args lam))
+                   (let ((vi (get vinfo-table aval #f)))
+                     (and vi (vinfo:never-undef vi)))))))
+    (define (single-assign-var? aval)
+      (and (symbol? aval) ; Arguments are always sa
+           (or (memq aval (lam:args lam))
+               (let ((vi (get vinfo-table aval #f)))
+                 (and vi (vinfo:sa vi))))))
+    ;; TODO: We could also allow const globals here
+    (define (const-read-arg? x)
+      ;; Even if we have side effects, we know that singly-assigned
+      ;; locals cannot be affected them, so we can inline them anyway.
+      (or (simple-atom? x) (single-assign-var? x)
+        (and (pair? x)
+          (memq (car x) '(quote inert top core)))))
     ;; evaluate the arguments of a call, creating temporary locations as needed
     (define (compile-args lst break-labels)
       (if (null? lst) '()
-          (let ((simple? (every (lambda (x) (or (simple-atom? x) (symbol? x)
-                                                (and (pair? x)
-                                                     (memq (car x) '(quote inert top core globalref outerref)))))
-                                lst)))
-            (let loop ((lst  lst)
-                       (vals '()))
-              (if (null? lst)
-                  (reverse! vals)
-                  (let* ((arg (car lst))
-                         (aval (or (compile arg break-labels #t #f)
-                                   ;; TODO: argument exprs that don't yield a value?
-                                   '(null))))
-                    (loop (cdr lst)
-                          (cons (if (and (not simple?)
-                                         (not (simple-atom? arg))
-                                         (not (simple-atom? aval))
-                                         (not (and (pair? arg)
-                                                   (memq (car arg) '(quote inert top core))))
-                                         (not (and (symbol? aval) ;; function args are immutable and always assigned
-                                                   (memq aval (lam:args lam))))
-                                         (not (and (or (symbol? arg)
-                                                       (and (pair? arg)
-                                                            (memq (car arg) '(globalref outerref))))
-                                                   (or (null? (cdr lst))
-                                                       (null? vals)))))
-                                    (let ((tmp (make-ssavalue)))
-                                      (emit `(= ,tmp ,aval))
-                                      tmp)
-                                    aval)
-                                vals))))))))
+        ;; First check if all the arguments as simple (and therefore side-effect free).
+        ;; Otherwise, we need to use ssa values for all arguments to ensure proper
+        ;; left-to-right evaluation semantics.
+        (let ((simple? (every (lambda (x) (or (simple-atom? x) (symbol? x)
+                                              (and (pair? x)
+                                                   (memq (car x) '(quote inert top core globalref outerref)))))
+                              lst)))
+          (let loop ((lst  lst)
+                     (vals '()))
+            (if (null? lst)
+                (reverse! vals)
+                (let* ((arg (car lst))
+                       (aval (or (compile arg break-labels #t #f)
+                                 ;; TODO: argument exprs that don't yield a value?
+                                 '(null))))
+                  (loop (cdr lst)
+                        (cons (if (and
+                                   (or simple? (const-read-arg? aval))
+                                   (valid-body-ir-argument? aval))
+                                  aval
+                                  (let ((tmp (make-ssavalue)))
+                                    (emit `(= ,tmp ,aval))
+                                    tmp))
+                              vals))))))))
     (define (compile-cond ex break-labels)
       (let ((cnd (or (compile ex break-labels #t #f)
                      ;; TODO: condition exprs that don't yield a value?
                      '(null))))
-        (if (not (valid-ir-argument? cnd))
+        (if (valid-body-ir-argument? cnd) cnd
             (let ((tmp (make-ssavalue)))
               (emit `(= ,tmp ,cnd))
-              tmp)
-            cnd)))
+              tmp))))
     (define (emit-cond cnd break-labels endl)
       (let* ((cnd (if (and (pair? cnd) (eq? (car cnd) 'block))
                       (flatten-ex 'block cnd)
diff --git a/src/toplevel.c b/src/toplevel.c
index 5b67ab6061c51..750f34aaa9fed 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -352,7 +352,7 @@ JL_DLLEXPORT jl_module_t *jl_base_relative_to(jl_module_t *m)
     return jl_top_module;
 }
 
-static void expr_attributes(jl_value_t *v, int *has_ccall, int *has_defs, int *has_opaque)
+static void expr_attributes(jl_value_t *v, jl_array_t *body, int *has_ccall, int *has_defs, int *has_opaque)
 {
     if (!jl_is_expr(v))
         return;
@@ -390,6 +390,9 @@ static void expr_attributes(jl_value_t *v, int *has_ccall, int *has_defs, int *h
     else if (head == jl_call_sym && jl_expr_nargs(e) > 0) {
         jl_value_t *called = NULL;
         jl_value_t *f = jl_exprarg(e, 0);
+        if (jl_is_ssavalue(f)) {
+            f = jl_array_ptr_ref(body, ((jl_ssavalue_t*)f)->id - 1);
+        }
         if (jl_is_globalref(f)) {
             jl_module_t *mod = jl_globalref_mod(f);
             jl_sym_t *name = jl_globalref_name(f);
@@ -417,7 +420,7 @@ static void expr_attributes(jl_value_t *v, int *has_ccall, int *has_defs, int *h
     for (i = 0; i < jl_array_nrows(e->args); i++) {
         jl_value_t *a = jl_exprarg(e, i);
         if (jl_is_expr(a))
-            expr_attributes(a, has_ccall, has_defs, has_opaque);
+            expr_attributes(a, body, has_ccall, has_defs, has_opaque);
     }
 }
 
@@ -431,7 +434,7 @@ int jl_code_requires_compiler(jl_code_info_t *src, int include_force_compile)
         return 1;
     for(i=0; i < jl_array_nrows(body); i++) {
         jl_value_t *stmt = jl_array_ptr_ref(body,i);
-        expr_attributes(stmt, &has_ccall, &has_defs, &has_opaque);
+        expr_attributes(stmt, body, &has_ccall, &has_defs, &has_opaque);
         if (has_ccall)
             return 1;
     }
@@ -454,7 +457,7 @@ static void body_attributes(jl_array_t *body, int *has_ccall, int *has_defs, int
                     *has_loops = 1;
             }
         }
-        expr_attributes(stmt, has_ccall, has_defs, has_opaque);
+        expr_attributes(stmt, body, has_ccall, has_defs, has_opaque);
     }
     *forced_compile = jl_has_meta(body, jl_force_compile_sym);
 }
diff --git a/stdlib/Test/src/Test.jl b/stdlib/Test/src/Test.jl
index 7e416df91864e..9742975d7c464 100644
--- a/stdlib/Test/src/Test.jl
+++ b/stdlib/Test/src/Test.jl
@@ -1814,7 +1814,7 @@ matches the inferred type modulo `AllowedType`, or when the return type is a sub
 `AllowedType`. This is useful when testing type stability of functions returning a small
 union such as `Union{Nothing, T}` or `Union{Missing, T}`.
 
-```jldoctest; setup = :(using InteractiveUtils), filter = r"begin\\n(.|\\n)*end"
+```jldoctest; setup = :(using InteractiveUtils; using Base: >), filter = r"begin\\n(.|\\n)*end"
 julia> f(a) = a > 1 ? 1 : 1.0
 f (generic function with 1 method)
 
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 174218f65b988..6872ad0bcc0bc 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -2999,13 +2999,16 @@ end
 @test ig27907(Int, Int, 1, 0) == 0
 
 # issue #28279
+# ensure that lowering doesn't move these into statement position, which would require renumbering
+using Base: +, -
 function f28279(b::Bool)
-    i = 1
-    while i > b
-        i -= 1
+    let i = 1
+        while i > b
+            i -= 1
+        end
+        if b end
+        return i + 1
     end
-    if b end
-    return i + 1
 end
 code28279 = code_lowered(f28279, (Bool,))[1].code
 oldcode28279 = deepcopy(code28279)
@@ -5451,7 +5454,6 @@ end
 @test Base.return_types(phic_type8) |> only === Int
 @test phic_type8() === 2
 
-
 function phic_type9()
     local a
     try
@@ -5490,6 +5492,11 @@ end
 @test Base.return_types(phic_type10) |> only === Int
 @test phic_type10() === 2
 
+undef_trycatch() = try (a_undef_trycatch = a_undef_trycatch, b = 2); return 1 catch end
+# `global a_undef_trycatch` could be defined dynamically, so both paths must be allowed
+@test Base.return_types(undef_trycatch) |> only === Union{Nothing, Int}
+@test undef_trycatch() === nothing
+
 # Test that `exit` returns `Union{}` (issue #51856)
 function test_exit_bottom(s)
     n = tryparse(Int, s)
diff --git a/test/core.jl b/test/core.jl
index 72b9f435d21a1..505c5d03a6484 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -7357,21 +7357,27 @@ let fc = FieldConvert(1.0, [2.0], 0x3, 0x4, 0x5)
 end
 @test ftype_eval[] == 1
 let code = code_lowered(FieldConvert)[1].code
-    @test code[1] == Expr(:call, GlobalRef(Core, :apply_type), GlobalRef(@__MODULE__, :FieldConvert), GlobalRef(@__MODULE__, :FieldTypeA), Expr(:static_parameter, 1))
-    @test code[2] == Expr(:call, GlobalRef(Core, :fieldtype), Core.SSAValue(1), 1)
-    @test code[7] == Expr(:(=), Core.SlotNumber(10), Expr(:call, GlobalRef(Base, :convert), Core.SSAValue(2), Core.SlotNumber(10)))
-    @test code[8] == Core.SlotNumber(10)
-    @test code[9] == Expr(:call, GlobalRef(Core, :fieldtype), Core.SSAValue(1), 2)
-    @test code[14] == Expr(:(=), Core.SlotNumber(9), Expr(:call, GlobalRef(Base, :convert), Core.SSAValue(9), Core.SlotNumber(9)))
-    @test code[15] == Core.SlotNumber(9)
-    @test code[16] == Expr(:call, GlobalRef(Core, :fieldtype), Core.SSAValue(1), 4)
-    @test code[21] == Expr(:(=), Core.SlotNumber(8), Expr(:call, GlobalRef(Base, :convert), Core.SSAValue(16), Core.SlotNumber(8)))
-    @test code[22] == Core.SlotNumber(8)
-    @test code[23] == Expr(:call, GlobalRef(Core, :fieldtype), Core.SSAValue(1), 5)
-    @test code[28] == Expr(:(=), Core.SlotNumber(7), Expr(:call, GlobalRef(Base, :convert), Core.SSAValue(23), Core.SlotNumber(7)))
-    @test code[29] == Core.SlotNumber(7)
-    @test code[30] == Expr(:new, Core.SSAValue(1), Core.SSAValue(8), Core.SSAValue(15), Core.SlotNumber(4), Core.SSAValue(22), Core.SSAValue(29))
-    @test code[31] == Core.ReturnNode(Core.SSAValue(30))
+    local fc_global_ssa, sp1_ssa, apply_type_ssa, field_type_ssa,
+        field_type2_ssa, field_type4_ssa, field_type5_ssa,
+        slot_read_1, slot_read_2, slot_read_3, slot_read_4,
+        new_ssa
+    @test code[(fc_global_ssa = 1;)] == GlobalRef(@__MODULE__, :FieldConvert)
+    @test code[(sp1_ssa = 2;)] == Expr(:static_parameter, 1)
+    @test code[(apply_type_ssa = 3;)] == Expr(:call, GlobalRef(Core, :apply_type), Core.SSAValue(fc_global_ssa), GlobalRef(@__MODULE__, :FieldTypeA), Core.SSAValue(sp1_ssa))
+    @test code[(field_type_ssa = 4;)] == Expr(:call, GlobalRef(Core, :fieldtype), Core.SSAValue(apply_type_ssa), 1)
+    @test code[10] == Expr(:(=), Core.SlotNumber(10), Expr(:call, GlobalRef(Base, :convert), Core.SSAValue(field_type_ssa), Core.SlotNumber(10)))
+    @test code[(slot_read_1 = 11;)] == Core.SlotNumber(10)
+    @test code[(field_type2_ssa = 12;)] == Expr(:call, GlobalRef(Core, :fieldtype), Core.SSAValue(apply_type_ssa), 2)
+    @test code[18] == Expr(:(=), Core.SlotNumber(9), Expr(:call, GlobalRef(Base, :convert), Core.SSAValue(field_type2_ssa), Core.SlotNumber(9)))
+    @test code[(slot_read_2 = 19;)] == Core.SlotNumber(9)
+    @test code[(field_type4_ssa = 20;)] == Expr(:call, GlobalRef(Core, :fieldtype), Core.SSAValue(apply_type_ssa), 4)
+    @test code[26] == Expr(:(=), Core.SlotNumber(8), Expr(:call, GlobalRef(Base, :convert), Core.SSAValue(field_type4_ssa), Core.SlotNumber(8)))
+    @test code[(slot_read_3 = 27;)] == Core.SlotNumber(8)
+    @test code[(field_type5_ssa = 28;)] == Expr(:call, GlobalRef(Core, :fieldtype), Core.SSAValue(apply_type_ssa), 5)
+    @test code[34] == Expr(:(=), Core.SlotNumber(7), Expr(:call, GlobalRef(Base, :convert), Core.SSAValue(field_type5_ssa), Core.SlotNumber(7)))
+    @test code[(slot_read_4 = 35;)] == Core.SlotNumber(7)
+    @test code[(new_ssa = 36;)] == Expr(:new, Core.SSAValue(apply_type_ssa), Core.SSAValue(slot_read_1), Core.SSAValue(slot_read_2), Core.SlotNumber(4), Core.SSAValue(slot_read_3), Core.SSAValue(slot_read_4))
+    @test code[37] == Core.ReturnNode(Core.SSAValue(new_ssa))
 end
 
 # Issue #32820
@@ -8042,3 +8048,15 @@ end
 let lin = Core.LineInfoNode(Base, first(methods(convert)), :foo, Int32(5), Int32(0))
     @test convert(LineNumberNode, lin) == LineNumberNode(5, :foo)
 end
+
+# Test that a nothrow-globalref doesn't get outlined during lowering
+module WellKnownGlobal
+    global well_known = 1
+end
+macro insert_global()
+    Expr(:call, GlobalRef(Base, :println), GlobalRef(WellKnownGlobal, :well_known))
+end
+check_globalref_lowering() = @insert_global
+let src = code_lowered(check_globalref_lowering)[1]
+    @test length(src.code) == 2
+end
diff --git a/test/meta.jl b/test/meta.jl
index 36a8acbfe08dd..856462fedd9fa 100644
--- a/test/meta.jl
+++ b/test/meta.jl
@@ -254,14 +254,14 @@ end
 f(::T) where {T} = T
 ci = code_lowered(f, Tuple{Int})[1]
 @test Meta.partially_inline!(ci.code, [], Tuple{typeof(f),Int}, Any[Int], 0, 0, :propagate) ==
-    Any[Core.ReturnNode(QuoteNode(Int))]
+    Any[QuoteNode(Int), Core.ReturnNode(Core.SSAValue(1))]
 
 g(::Val{x}) where {x} = x ? 1 : 0
 ci = code_lowered(g, Tuple{Val{true}})[1]
-@test Meta.partially_inline!(ci.code, [], Tuple{typeof(g),Val{true}}, Any[true], 0, 0, :propagate)[1] ==
-   Core.GotoIfNot(QuoteNode(true), 3)
-@test Meta.partially_inline!(ci.code, [], Tuple{typeof(g),Val{true}}, Any[true], 0, 2, :propagate)[1] ==
-   Core.GotoIfNot(QuoteNode(true), 5)
+@test Meta.partially_inline!(ci.code, [], Tuple{typeof(g),Val{true}}, Any[true], 0, 0, :propagate)[2] ==
+   Core.GotoIfNot(Core.SSAValue(1), 4)
+@test Meta.partially_inline!(ci.code, [], Tuple{typeof(g),Val{true}}, Any[true], 0, 2, :propagate)[2] ==
+   Core.GotoIfNot(Core.SSAValue(3), 6)
 
 @testset "inlining with isdefined" begin
     isdefined_slot(x) = @isdefined(x)
diff --git a/test/syntax.jl b/test/syntax.jl
index 106a8f296ced2..4d204f3e29364 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -553,7 +553,7 @@ for (str, tag) in Dict("" => :none, "\"" => :string, "#=" => :comment, "'" => :c
 end
 
 # meta nodes for optional positional arguments
-let src = Meta.lower(Main, :(@inline f(p::Int=2) = 3)).args[1].code[end-1].args[3]
+let src = Meta.lower(Main, :(@inline f(p::Int=2) = 3)).args[1].code[end-2].args[3]
     @test Core.Compiler.is_declared_inline(src)
 end
 
@@ -713,7 +713,7 @@ m1_exprs = get_expr_list(Meta.lower(@__MODULE__, quote @m1 end))
 let low3 = Meta.lower(@__MODULE__, quote @m3 end)
     m3_exprs = get_expr_list(low3)
     ci = low3.args[1]::Core.CodeInfo
-    @test ci.codelocs == [4, 2]
+    @test ci.codelocs in ([4, 4, 2], [4, 2])
     @test is_return_ssavalue(m3_exprs[end])
 end
 
@@ -2511,7 +2511,14 @@ end
 function ncalls_in_lowered(ex, fname)
     lowered_exprs = Meta.lower(Main, ex).args[1].code
     return count(lowered_exprs) do ex
-        Meta.isexpr(ex, :call) && ex.args[1] == fname
+        if Meta.isexpr(ex, :call)
+            arg = ex.args[1]
+            if isa(arg, Core.SSAValue)
+                arg = lowered_exprs[arg.id]
+            end
+            return arg == fname
+        end
+        return false
     end
 end
 

From fcd62da13d9c3ed7e3d3772479bcade7473b3e24 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Sat, 11 Nov 2023 03:27:41 -0500
Subject: [PATCH 0235/1315] cfg_simplify: Avoid ambiguous magic number (#52111)

This code was using the sentinel value -1 as a special marker in
addition to the negative BB indices. That ambiguity was causing
`cfg_simplify!` to fail on functions that merge any BB into the first
basic block.

This change is to use `typemin(Int)` as a marker instead.

Fixes #52058
---
 base/compiler/ssair/passes.jl | 10 ++++++----
 test/compiler/irpasses.jl     | 15 +++++++++++++++
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index ce3d5f96337a6..c6ae1a8e399d8 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -2029,7 +2029,7 @@ function cfg_simplify!(ir::IRCode)
         i = popfirst!(worklist)
         # Drop blocks that will be merged away
         if merge_into[i] != 0
-            bb_rename_succ[i] = -1
+            bb_rename_succ[i] = typemin(Int)
         end
         # Mark dropped blocks for fixup
         if !isempty(searchsorted(dropped_bbs, i))
@@ -2049,7 +2049,7 @@ function cfg_simplify!(ir::IRCode)
                 # we have to schedule that block next
                 while merged_succ[curr] != 0
                     if bb_rename_succ[curr] == 0
-                        bb_rename_succ[curr] = -1
+                        bb_rename_succ[curr] = typemin(Int)
                     end
                     curr = merged_succ[curr]
                 end
@@ -2089,9 +2089,9 @@ function cfg_simplify!(ir::IRCode)
         resolved_all = true
         for bb in dropped_bbs
             obb = bb_rename_succ[bb]
-            if obb < -1
+            if obb < 0 && obb != typemin(Int)
                 nsucc = bb_rename_succ[-obb]
-                if nsucc == -1
+                if nsucc == typemin(Int)
                     nsucc = -merge_into[-obb]
                 end
                 bb_rename_succ[bb] = nsucc
@@ -2106,6 +2106,8 @@ function cfg_simplify!(ir::IRCode)
         if bb_rename_succ[i] == 0
             bb_rename_succ[i] = -1
             bb_rename_pred[i] = -2
+        elseif bb_rename_succ[i] == typemin(Int)
+            bb_rename_succ[i] = -1
         end
     end
 
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 61fb0f6935f1b..ef6bf630bd2e5 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1569,4 +1569,19 @@ let m = Meta.@lower 1 + 1
     Core.Compiler.verify_ir(ir)
 end
 
+function f_with_merge_to_entry_block()
+    while true
+        i = @noinline rand(Int)
+        if @noinline isodd(i)
+            return i
+        end
+    end
+end
+
+let (ir, _) = only(Base.code_ircode(f_with_merge_to_entry_block))
+    Core.Compiler.verify_ir(ir)
+    ir = Core.Compiler.cfg_simplify!(ir)
+    Core.Compiler.verify_ir(ir)
+end
+
 # JET.test_opt(Core.Compiler.cfg_simplify!, (Core.Compiler.IRCode,))

From c15f4e9ed5540b8a64558c985a4ffda50151353c Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Sat, 11 Nov 2023 08:47:41 -0500
Subject: [PATCH 0236/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=202d59169bf=20to=20debc38b9a=20(#52124)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5     | 1 -
 .../Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512  | 1 -
 .../Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5     | 1 +
 .../Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512

diff --git a/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5 b/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5
deleted file mode 100644
index 97f6d9582d52c..0000000000000
--- a/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-d077b794fabe0879f4bb8b548ad75ead
diff --git a/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512 b/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512
deleted file mode 100644
index a59f670469bf0..0000000000000
--- a/deps/checksums/Pkg-2d59169bffdf29a4ed7bafd8b35c391ede612dde.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-70502a1fc7732b690cfd2145079d44761800a6fe3ff090b7f27a7b96680178c6afc47b9f3df00d4f254dbb355203f038d69fb44bceb7c8fab278b47fb8a3cf79
diff --git a/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5 b/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5
new file mode 100644
index 0000000000000..d222465b498dd
--- /dev/null
+++ b/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5
@@ -0,0 +1 @@
+e6fee75f07782a63581ec844a25e97f5
diff --git a/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512 b/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512
new file mode 100644
index 0000000000000..9ee7f65eaaabf
--- /dev/null
+++ b/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512
@@ -0,0 +1 @@
+f3353f4493c25a45db7125be2448fb3799e2c6f02b9fde14a444b4d4bf7c144d56abde6f8b678407f918b3c2ba00f6ab19047b908004f5034d422d5cfd6c1f41
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 23a4475e5ca01..273ffd825b9f1 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 2d59169bffdf29a4ed7bafd8b35c391ede612dde
+PKG_SHA1 = debc38b9a2d800f035a17f42a01c14a3775fa859
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From e746ba4085b7de0036e596e19c0979071ee0a920 Mon Sep 17 00:00:00 2001
From: Zentrik <Zentrik@users.noreply.github.com>
Date: Sun, 12 Nov 2023 05:18:07 +0000
Subject: [PATCH 0237/1315] Fix typo in devdocs (#52128)

---
 doc/src/devdocs/ssair.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/devdocs/ssair.md b/doc/src/devdocs/ssair.md
index d00f1ebb809c3..4375012c9f580 100644
--- a/doc/src/devdocs/ssair.md
+++ b/doc/src/devdocs/ssair.md
@@ -225,7 +225,7 @@ Instead, we do the following:
 - RAUW style operations are performed by setting the corresponding statement index to the replacement
   value.
 - Statements are erased by setting the corresponding statement to `nothing` (this is essentially just a special-case
-  convention of the above.
+  convention of the above).
 - If there are any uses of the statement being erased, they will be set to `nothing`.
 
 There is a `compact!` function that compacts the above data structure by performing the insertion of nodes in the appropriate place, trivial copy propagation, and renaming of uses to any changed SSA values. However, the clever part

From 85d7ccad2cc2154d9c3371283512eec33252cc40 Mon Sep 17 00:00:00 2001
From: Claire Foster <aka.c42f@gmail.com>
Date: Mon, 13 Nov 2023 18:03:29 +1000
Subject: [PATCH 0238/1315] Bump JuliaSyntax to 0.4.7 (#52136)

This fixes a whole bunch of small but annoying bugs, as described in the
JuliaSyntax-0.4.7 release notes

https://github.com/JuliaLang/JuliaSyntax.jl/releases/tag/v0.4.7

I've been careful about cutting the JuliaSyntax-0.4.7 release from
nonbreaking changes, so we should be able to backport this to 1.10.

---

Extended notes about compatibility
* The public keyword in
https://github.com/JuliaLang/JuliaSyntax.jl/pull/320 is released in
JuliaSyntax-0.4.7 but JuliaSyntax is multi-version aware so this is
disabled when used as the default parser in Julia 1.10, but is enabled
in 1.11-DEV. So should be backportable.
* We aim for parsing to `Expr` to always be stable in JuliaSyntax and
independent of the host Julia `VERSION`, but we're not fully there yet
for 1.11 / 1.10 due to
https://github.com/JuliaLang/JuliaSyntax.jl/issues/377. Thus some
careful management of the JuliaSyntax-0.4.x branch for now.
---
 deps/JuliaSyntax.version                                        | 2 +-
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/JuliaSyntax-4f1731d6ce7c2465fc21ea245110b7a39f34658a.tar.gz/md5
 create mode 100644 deps/checksums/JuliaSyntax-4f1731d6ce7c2465fc21ea245110b7a39f34658a.tar.gz/sha512
 delete mode 100644 deps/checksums/JuliaSyntax-a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7.tar.gz/md5
 delete mode 100644 deps/checksums/JuliaSyntax-a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7.tar.gz/sha512

diff --git a/deps/JuliaSyntax.version b/deps/JuliaSyntax.version
index 1d7dfd8efd096..7f124715024ce 100644
--- a/deps/JuliaSyntax.version
+++ b/deps/JuliaSyntax.version
@@ -1,4 +1,4 @@
 JULIASYNTAX_BRANCH = main
-JULIASYNTAX_SHA1 = a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7
+JULIASYNTAX_SHA1 = 4f1731d6ce7c2465fc21ea245110b7a39f34658a
 JULIASYNTAX_GIT_URL := https://github.com/JuliaLang/JuliaSyntax.jl.git
 JULIASYNTAX_TAR_URL = https://api.github.com/repos/JuliaLang/JuliaSyntax.jl/tarball/$1
diff --git a/deps/checksums/JuliaSyntax-4f1731d6ce7c2465fc21ea245110b7a39f34658a.tar.gz/md5 b/deps/checksums/JuliaSyntax-4f1731d6ce7c2465fc21ea245110b7a39f34658a.tar.gz/md5
new file mode 100644
index 0000000000000..c2663955ec773
--- /dev/null
+++ b/deps/checksums/JuliaSyntax-4f1731d6ce7c2465fc21ea245110b7a39f34658a.tar.gz/md5
@@ -0,0 +1 @@
+8c9d9579eeab1ba40f978a32c9db9900
diff --git a/deps/checksums/JuliaSyntax-4f1731d6ce7c2465fc21ea245110b7a39f34658a.tar.gz/sha512 b/deps/checksums/JuliaSyntax-4f1731d6ce7c2465fc21ea245110b7a39f34658a.tar.gz/sha512
new file mode 100644
index 0000000000000..46647cb3e432b
--- /dev/null
+++ b/deps/checksums/JuliaSyntax-4f1731d6ce7c2465fc21ea245110b7a39f34658a.tar.gz/sha512
@@ -0,0 +1 @@
+1bdad624f61482b55deba8727fea1c087bfaea9e1f8afa3b44b984441fb7e663dac067baa4a96ae2d4cbd4a46ae8c87e9d20d2dfcd17046ad194711304184e57
diff --git a/deps/checksums/JuliaSyntax-a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7.tar.gz/md5 b/deps/checksums/JuliaSyntax-a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7.tar.gz/md5
deleted file mode 100644
index 25f5adf71897d..0000000000000
--- a/deps/checksums/JuliaSyntax-a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-a42bbb42babbbd727556f6bc01455826
diff --git a/deps/checksums/JuliaSyntax-a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7.tar.gz/sha512 b/deps/checksums/JuliaSyntax-a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7.tar.gz/sha512
deleted file mode 100644
index cd3f3f3043d45..0000000000000
--- a/deps/checksums/JuliaSyntax-a9110fa8ecbe79943bb9525b4ccd99a3976cfcb7.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-d542766e72b57418b9b4e17743f89d8535c1f36497346b57538bd0cb451e64af9493015692179f80ec4ee8cf18349c1e0888f5710db895e19f9bb0322f0f7464

From 6d5787a993ae7623df479217c9805767ceaa3556 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 13 Nov 2023 11:32:10 -0500
Subject: [PATCH 0239/1315] Devdocs on fixing precompile hangs, take 2 (#51895)

This is #50914, with only the documentation changes, plus an improvement
to the warning message.

---------

Co-authored-by: Tim Holy <tim.holy@gmail.com>
Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
---
 doc/make.jl                                 |   1 +
 doc/src/devdocs/img/precompilation_hang.png | Bin 0 -> 9175 bytes
 doc/src/devdocs/precompile_hang.md          |  98 ++++++++++++++++++++
 src/jl_uv.c                                 |   9 +-
 4 files changed, 105 insertions(+), 3 deletions(-)
 create mode 100644 doc/src/devdocs/img/precompilation_hang.png
 create mode 100644 doc/src/devdocs/precompile_hang.md

diff --git a/doc/make.jl b/doc/make.jl
index 78604a5fd3c75..d0bd52247aa81 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -163,6 +163,7 @@ DevDocs = [
         "devdocs/gc.md",
         "devdocs/jit.md",
         "devdocs/builtins.md",
+        "devdocs/precompile_hang.md",
     ],
     "Developing/debugging Julia's C code" => [
         "devdocs/backtraces.md",
diff --git a/doc/src/devdocs/img/precompilation_hang.png b/doc/src/devdocs/img/precompilation_hang.png
new file mode 100644
index 0000000000000000000000000000000000000000..d076b7697f2712a12aa8132197e95ea7e7014e2d
GIT binary patch
literal 9175
zcmb_iXH-+$wzhy&DIy?EihvLT9GdhX9SJogKxm2(nu0>8N<dJ0=m|}F4<IEV2o{c1
z2^}dSqK94tY0}%<;hcNNeZSrtZ#>2bX*+AJIoCJ8Z_c@Pl!=k<Wm-<!bLY-ozN4oF
zJ9qA)AMo0n`U3EuAa3IYJW)8S8>*i>R})WnWKRjar+KW0M4vl%#hd&%|J{k#|J=D7
z0e7_2;r@23S+?bZV?N<qXfNggZNV2aH7fNlREaX2Qa9_{xUa@_@uT_qMUA9um_uo3
zl0s2J*ArM<m|om?f#oQ;r^As?&%lw#MPqxJI{&su(vK;X9_!a%kcih${rr4#e#xxO
z=NXTDEgwCpDBB&@-F<Ytv!>#LmFl?W(35dAe|odrz=8Zu=3-XUN;0CD`~@~W#K?B1
z3-lRyDb>+)yF}v95$}5T8>d{eR1A?MOTJ1<W`NKQL83UxSEX?*4x@4^q+`!UruSYZ
z8k?t|UFCF1$!Gk(O=Ff!QaSi&W^uYS9@A+oc&Kr5(#Hse{YrpJa+@&abbVNR7q~sb
z7<|l})8#>)7VSnJJOf@VD{vq=&fX%NZ;CpZZB^@x?RWg)_bce6J@|O{bUl5=dL~Tm
zn4h&Y;mCPvaZiz?ir%pyQYn1%KfUO~@a>%s*XiupVljDu8E&xjs-x+EwjX%;_~iFl
zI(SjlrqIkuPsq`>Zm9?)8S@}_LB#gk{+=13srvS24rL3BgnJygy8WQ+5{RYW81l9p
zL1zez=VZKew!C@G_)O%KZ@`@b(hEGD5@2F#m0f;W*M}P`asK(jL+CDuvJXCB=9ux*
z`<>4}yS%nWSF6d6bc!e2SO0s*_$|pMeZlTnGkUKpA~<NSccylM7uqQNg&9vH3T0LP
zxIjzxM=b-eS)U6@I2W-y^2E76oh>D<t4VpYL?>X?Ro;k_(mq1RB*oZyqD}`Hv-KHp
zb{+NsuNxvOn~x=|BKoWKjteJ9&VAXfx*8xoh-d>=^eV^UgQ~lq#T{fvmDeWqJajwz
zC*S#4t49(het>T_=)hf2=w+7Os<pr)Q6DJ7cD?SAslca%Fjg5djwC(<I4~?TcyA#Q
z^t*fw+JI+}DeGbXp#Y-eM5K2)m*oOhw3<C)KHt~<T}M}q-&<c>p-g&aNr&yzl{<Vy
z&|58Q4l}LU$bvK!x2(_*%Z(gbR_%y>*l>HMhxK!}$~pMflZhD)6U5u!A=J{dbLCaj
zcX!W#);9!9EjKBZnrl$zp@Zk3cZdtc4b$Dhm*XAV=lTahhJ*RiD0OXwU9JR2$5sBl
zX=t2)*WMyXILFkS`r|q>I+}#*)BI$opn%inY<TGUbYe+LWy5$!boMTUK*oHUYCeFK
zuTVS<ovLa6>~jA6JY1Mqq3tq?n9qt=6OXmzGZzg*4BJ^IJnM26g)c774^=I(HDdYM
zCMG`MNZ4xe<Fj#i3d!Se;R(un(HE2A#j`EGtDKBZ&2*J$#E@RR$)*0JWiIAbRw-@f
z*q&+i>Kd16UcpN!dmOC3vSxJ^B$G`W`Jjm$QRB)$K$RSuq)UGAETkqwc)E3+rf-TR
zeYSGFT_+aAGNAJYPojU14{Qq}7+9$zSUeeR>*{P9=@3qOJyQ>K&PKUG9z_u`4?u*o
ziAJ<JEaTBNGncK+q}c&8w%iM?@&gm<DtZ2U^f4dQR9ru5={0PQ`u>3x{fclB-MoeA
z47BW5GILKQRj4@=vd=@wG~)Dw90;R`bbBrJ<=9M9JOLUHgn<4|n~5?lmPvrMQSn_$
z*CtWEQ#bJ!&79x-N~7|w9ig(^fFfmhXaywm{e&i_?%q=ERaQKq;%!cF4Q~FW+aUnS
zKlRpPA#PE%N-6z=MrWW48U%L!Ri$))cCbN133H%h4fazqcU#hMw!kxwfEn(p2*zgV
zJLjj`<>O{srG4w~t6SZ=z|d`#Oh*;b6mr<*>^B$;jwovtP!*I5S7|w4nBo|vKrJ^H
z`k_njJpYH^CEBR)@B(34)*o3M5U8nXI-e^wh`|NE->Wa~&OVsT98Ici^qK)Vc|-sD
znL!Q%2pNmwdD3^Af)vLkudDI*Mx1Ce=kF9AJ*$|tfyj25dzvZ#o@SCQ3cUVgmi~(Q
z%Nt_j6b^4LcU!UG653ccsY6(m7zL9O)UU*y|4Ka$x2vOLm7{Rp*Q;qSOE7l*csb|G
zt!1-=x&jTcmov{2@VBoPkpRTrMs%Bi+YVLnC;VapXLNG+AG(x)=})Ay=>Bkvx)1d|
zBR&=~2(5CZd7sSo%$28lcdb_ha~~BpK7PFS_2-zk>*GD6hO@w;AsZ80-t&kD614sO
zbMjDXb)WTw6VLP|zpkt(3pX+iIT%F)I^k-AT7D_HUEdq?h<hJ2PXhypKm@&7GA1rX
z7K7RcWGyi4|63-mnUw$w_&*6q4`-^K!kYu*{*HM2OB<BN0&@)M(PX3kk%tb%{JI72
z-Tn5hYk+kIn<|rwT$=j^zJdiN3x(hK%{=Qn7E?V^1W%C)N<nd6Vt1Qfw8rkL4W#z8
z_F6Y=7(>pYf}I={8Kk4Zst=OlMZ98EY`?_vM0vWLiB!uej@-mQ`ij;2F?&DbUj*gz
zv|Q*4W}}9Rnzd}a9;+g7mKvzcGz^N%0(PgV76FEq5qdTwy2%i=s+IlDXrmG&fYj$i
z2oKLZOny_DzEW#ukuLxJ^x3xuYVWhb@{cANV#t2oi3I#gK%iQR*ctxFmxIn=jNX#I
z@%U<?G)S;^K<~6&$qL-_fh@oP;(!S%t|FS~=!de%oKV7uJO+qmleujlFoU<RKrJe0
zV=pST@~%0>y#W7>Dy-(x5{h%2#)v7Gf#PF}@CIG_!JNT#^(&3306=qoU%M@9SQsRd
zs40DkZbl1J>N^~fZQwD;##bDK%AT7Y{iJ~pI9~OeIoSpn5CaHe*Hq6qdQVU5QUyqU
zI{u1!IJhE>Y>00<86Y(Hs5go9L!kR2@T&q*#^yr!J?yK2$D91}M`p9#7Lr|k;mj2J
zs#YC??+<7B=-jZ;HMg1AW;xpLj1V{-wK0})3c1DFhA?+%T>yDS1|t!dTO&M5`lU7r
zCWA)+i8rNvc7JeNE<8@lECsURc$3cSx!?D<dEfjm{r>fS?1?^aB%h|;hXc@w4=))p
zD`2vIUIEDzI=bS%sZa2STVfUyWr&NLc^<?Y*lD+XS(diB);C&K`a0e>t@NeTFR-@=
z*mEYa&*qBdf=jdAs7I3H;XGPMoWx~|l<U|X&8U2#nFNA@Y0eu7G3dC2ZTqau6EKC}
z9#~r&rN4mL9G?Vuhsejl9K%!<{a|ZIn(_&=@li5{c0bkFjhsRKodZ}Qiii0-3OfY-
z1_JE|DHRE-OL=usSg&*VFez@W0CsB#KU>%`i>GBAf=wUKL9*mz7%4~af6NGtu~!rP
z6z0e+&8oY7#{y<%ASW{`_d<fP8wQ6LOE?x=&q{||(&M89U(xjz!JS^%irAfn=Sy;U
z%Hg9pHFMOz<zH@O`*a;98Pd!h-X`2+Zei+`tI(y}kx-4YWP>B*1k1z`?B%Ql1M~Q%
zM7k~oM^K;3pr{jBtq7$COD(4QHP`$`rusT_h)N)#2}E&a+BDY75c!{>1y*-SVFzEF
z3wJcg&H40xb6)B^pih$^8P=@(#Us%*iD4j?5q|()WYx;0lS(PWz0#+0fv59JMO1Nc
z{M%J2{u1b`U0I@d!poU$1<(WdEam3-xbplG>oySVfJ#MrefiCUo^>FOMLk<=ACkZ$
zgZq+*b+3fTNp9^L+3uH!beQR<kAr>>v|NhyJs*5HPKFC>VMKTaqfo!~S6hNgA6iSZ
z0#dMS^++_dXcC%JR9b3)nmj&=DU#)#hMi9)1unejx(4J$ON#|53O{XqAfLm}tkoqG
z2`fU_jnSPVNxACVAzSw5q2C4UraH45OJ?%T49Wd-<weGNV%h^<qIM`()AR~h!g9qc
zrWjAvq_i(#T7o%NJhx0X)CZ}#9>p}Y0T<*|k0??k{sLoC^7EzDhnRkSKb+FNP1(_K
zHRM+3wZ=_n{=l}d=bE9oJjniv#7i;x%KP`>9{;IMuS%t7^6%Y&LC^P5-_U~jGt7M*
zpqe!QE_`X3<sgaprLYHYtD{)`N0GGH57PA(&rdEFU7_%o%VF#8Q7qeo|5hPy=cUg^
zwx|mX0A;0+Wk~BnhhIINH-D1nawv);I?TWMCVV~t^=O=nykG2OJp%aI6$Kwz<vC!3
z6}l72Uvy;homCz45YL?>2i@Hujbw8hj=<JZGI#WxNe~kCOQ{S!jlZkXyx#t|hPjia
ziTrsHY4}hR$S;U(XKYwW&Il&&{!_L*By;Hhx`z2hwSidv7}0zpvQN&i%!Zh+C$&bQ
zr~XRV>I2jvc`_~OY&f)90tuVr_F{9_pUfk2o)04?;b#<XwcjvqkVU4uTF@3(@NtKq
z+FpFp&EOp<mNC$0c8uDPl3)-AAs00BxEf0Q{^p1U02=~rQ^3!i!3}g5zbB9m0Xfh4
zxp<md)*+c7%`}C~GJ&ygIb@_xn544@2W=f~@1Bd|u==cl7A4nO^APoXaSrF%gNd~=
z>ORq&Kwpb)pFD!$0M0%DpyjV7^5X(=Ve=RxpoFWtjPG)`y#8*zuFlC-mX1(vu(Jcm
zj@?NNke)gjC)z+e8s9vAT)HQD7lUA%q^-K!o)GCcQSBmTq}nx2CBKFyBig;(U~f4_
zZFsI{$YpsLQGC)p%d79ZxhZlF7-a1)e}*mv_QjS$N*{Udnc+DD+j?$Nr}sE)K~w{;
zgKj48P}Vb2;CjpFYwG0-Rm~-crM^cey)T2;Pnun~r&=BMsi$p@_6-$lS>0auP#!fO
zkM_5OASf9lMo0p?4=hfIJz-QIo-pK4i&)x@mLxWj1XID>6x|!fWq{@$Yv^t|X416@
zeC&RZkSn7neW@uSU3QKstK^mix|W^n$D6s*gXn9CepcGcVGNo*cOvdgZE#qto-~~D
z@p>g<tR&ib?S(k@;V&N3<*<@yPluza`$E4x+v`4%g;}Iew|txeve8JY8byh{TTK80
zc(_K~uHZ7w6qFyw4G7UpGI3#oZJcwId4n@nG^xX!k5y1cs${jHDeXz{D>8LknRs+;
zFm{!9Z&?uuY=&(4m0~6fZeGkj!d$Z~wDSHY#~N#xB|R_y3>?{%2NZ@Ny=D!qlTF^{
zXU47^L(`v)Vo3B~Mz(*H`T3J;0q@^N9gWm@g7v~<?;{&+6zLR5MT8ES0*q{#<aTMu
zQ`aMkuX1&GGjh`9^0bE1w}+ZLAUy}d66vCEL|9(tpj{db<O60KDkeOU)<Nd+B^H_q
z5Zg<#is17AoiMO9mAaD4|3k_M4?Xf+q9__5Keq@2SjL0MICv*|EACP5<ifvTO7+7L
zC*c^n!as8b7P6F4ish$b<@aLe{E3Q%d0b)F5Am&0qW?1eS+9UJ`@@h&y$#61N`n={
zfDN?Oq*`~(j4?@Xa;S{KnSs!I0{bGFF5b4SRTOFD*x~}!Qq&;qwCHhfl|d}pdY(~l
zA|$RuR5~onVD%s#PK;G)c@Iztaf6Q-i-7I9p_FuU#-^_MxPUI5PSQBM?O|iN$3GjQ
zlByVe^$Tv(Ec1W|tt}FE?>KHB@cB6atyl6z9|m+o2B&4TZBffVOcedq<U7*d>vV1b
z@G2Di_<8Kg9pU1qca>^~gL@VFAdu~AWN5EOkhD^SFy;Y=H^D<OOl;&m917Jkigz02
z7=5f4(|?r?QT!;5%b{oKc9S^Af`)|%|1Xb%8%RUOyV*<4S}dnS*B^HbK7wy9)yC71
z!;Qr}eeu=S?)7op(UANJHfYRPPltPYzYj(o9<IqZjow(0FH+{`=Im|};SIZx2{jfq
z)i&{Hvmupabu5sZF)Pa4tNa|!h3}4w)><g~q>K6=?0$$k*4ao-ilWw_n8xij%^w>8
z^x)kBGJ}CbgrOdx3V9>z9Cp~YP*rXXKb=Z*XfdgUBeCq|W<ET<)Ed+6bep@(;sf;i
z^yfHo!|2;hz4t;h@AxQugsymeZ^{xB*26HYs+acgI|@0YPsur|yE!Twd@$d=S$S|G
zfDhQ+lAO+IKd6-kXnrSBq5gTDmDd;HlOUg3X)<1y;OUHZ{s%y`!z=_Wo|ZfvOCW(a
zP99;UO2WNgM9fwjk~<kCX{0a%hhnm{7{!yg-}9f$_6I3;8?TW|ppG=9e?~gEzNdRP
zXynRSGs{Vt4APSQ#=o0hwQ_)u|66P7f9QbS?AY&YKB+q0TTyHFQ5^S6$5hlx{XM98
zdP!`v|Bk@Tb3o?^IUg;<-n=^}*}Uu5nRC2(czU=dd7iGzp6=bYMZbycWYWsZdoNL0
z3Y?!Ezwz8sV(W1WHPa%lNn4k0Rq_O5(_7GTXMhSJ9c_*UoeuFHBg1CZ=oo|NxaT12
zZ=I7=`F^g*GcqvbAb1`dG0@rDc@+ljECv#v_qmnxw4H9<t*jQ$>5|Ca?^D#*su4O&
zc#<iu8K(ARH((?p=y}8G{L?OHx`%Lg!FuFqlqQs)!`daM|7Ue$P42vbt7RFDEK>EB
zU;u1uuM?~4lEO0O=EL^%$q_PnXT!~2869-kGg7&_+wYoDe!my80&Ky~ZIr-XcHjY#
z8o|z{cT#)%OSEsHewj{nC~0{68E><<=y=E$2QqlO<cHx7Tixm~hiRiht|Kojz7{or
zgNJ{f?YeILN?M*mJk0T79tKj?I^Us@sCZTIDNo;d_@$v{J3@FxQh7!<i%89HWXQ-e
z7+&;V`K02`jK5rqc`WA5-Ln<N>)W`?`X$R9R+F18Z%BcE`Sk}LPVZ(z4p;~^Ybsku
z@_oF*Ilj|PPQ-p7gSlU#T?eIoGmTWI`Z@UgB*VdG{4wFv#5dEQi%)u@ek2VfxG%U6
zdx=KeR<vDTS~8yM-+0MIXSlKzAFMjgl{aO^Iui^hGRf*?4iSw!?`J7V%Gtd|AEn2T
z{9o5*DK=x~-NvGR_lt7H{j;PBlGc3zF=l&e={6y~<eCf>u5o5O^81~;NYu$*5tP0V
zE*$ZYZMv!WWG?n|D|TgxIa*0m+Jm>e=W@;Fo`*B!kqcPxa5NwyJlq&z(3#+^rnPH4
z8t~PzSLu=SJKq#wUbNNW<4WJj1@uF<(UsPJGLopZ>uQ+aHvs^h5{hbnsN7E3Kyq>+
zOQo5KL$87Af2H~=#r??1XNWl+ptYyhMFQ2TOuKO45E2(Vy^-GKLRpG0inaMRIJJ&U
z_4}W2n~1EyH7(>yN7mnkX~ns*nC)UMjXYvSjHFXca{N!Qp+ks%m#Zaq<^*w{(PbD6
zGJMJ1f&!w5E;-y2pP~FMm>qo)>=5-$L=2o8jyuo3Q)_N-Kk*Y&da%yH)=Qz1OqsLO
z`0>K~lDS!PbxK3iCpzl*n%oP+ic0#pRoDcS?o+VaV`~$3{PPdsR(|Sg&5ZP6Us7}8
z$nrOc-SS9o<|7SX&X#8yJwl)qi7KLdkF(QLPJ)O_uR{wA-T_78F(vOA?T_ml_FS4p
zI$gf}>B8Qb>|znnV^e0!YW|DY?d?}v;-Y}*&hyB6<5+^F{}J*_g!*{p)Em0|nr;`_
z5EM93XhwwDo}bJ!mk`2F8206!1alu#b$!vWMFjzv!^LdU@uY*8jD3lG@(R0-@@mr@
zCX>^W7`{;4y-u_tet#xa!qsc>cKRiJKol2FS!Xuxppc{AQ@zo%aG*>?^`|Fa8IPys
zGp~g_1=h9_jVaLvpw>O8Z_>DkW2M9^r*X3S29$*ahEHfLUcP0@?Dq7xb7N}*Hnr06
zBBaO}ZjCCsJjbHDpAzKp@UR5}$B_0-jQ(<*GCOX)Fub5cZhw9vZE+-B)Oy;jfXcG&
zxQ`sRz@@D~rMN?fj22|Sav>Z0#NsU!e^BV$>-($gf(O`z0=nP@d7c8LVii18>U>d@
z#wi&IhK#6zZ}+tBKr)L~#UWoMNuOFT8NH4{Db_WV_qiQEf0@$lV0&X(z@!0p%*Pf-
zh*ZM)NMP7@@+=j8nW(Mx$g%zH#Nw+{rAHe3iFm9y96o;|UN!1ixnJe<uhi>!%C1Pu
z7jHhk>V<Y+UH$5b!qaf-v8B;s1<HGF>STlw)V0HjGz?~^L6>)rl0<~YBMjOHv65nZ
zbX(Gag<N~|tE|em_rQWq@0RInXlKJ;dbQ^B5GvvmxLzmS^hqu{rjgmE(VC#i=aI|y
z)x*ZI>$Hn9x@-L@W0gmAaaCBf<c;umS##zn`TBh*qII9C^MhlEVSntiq45M*5(YO|
z6UnKA39rMp6HDjCGAH!IHBA~i-`sq9<L4NX*{b7#!jBirRn*|pST847SHuPiKNw~E
zGOCw}Q5QK_yc08?&dF}V2H)W^U26@Pu-oN`8>|i)tW3N05Q@@|amnHGS@v{^TrOby
zIJ}>qMQG%7ufn=o4lUxeGWB`uvC2qMhQh5lOEj3AGXPyX+OFoXXwq<4k9UksN5ZqO
z+<({ouLuVBLex=l(qHHsi{Xt0!o~A-r3>}_*#w2M>xi>f_Unr{7WsKUOSUU-M@0rH
zMr4fs&|uZ;9S;Bf*fM1@6>iSS$x{fU)DKq`rCSDp^Hl~4iKUK86}O+Nbt{bc;t^}D
z_F|t}U_0Sp>ol&9ZZ{MjQof%4L)9mD%zV4Xl2$H&ClN&UPK3VR4x1AJedvE#SHJWm
z`p?j>X_xd)8wv*#rC4JrM-_#^?Za=L5tk3+O2;05uOGvNI~1DZF5`p@Uk*Ary|-N*
zo+<4UUx@JyKjs_WIY=Xw1RW(Bzh|`Wu-$IE#&F;ASB3*wL)}eKki8<^#JgraL7g^k
zk8rRH9kxEX3>9&-ZL6gQ^SlmS7oL;o2TF?Jil}rYPM<v6`wAstPD5~y!<F>tf@S6s
z+4~^`a%X~6?`B$7f^|(bOTh1Po8%PMGb%ey`FpzPrSOAd+-cf3wDX3}Yjh03<c(h2
zzJ9fv2efPHxjq~>=INVv)S-S1)>u|Ui5VB_vF)(Zw$0i1oCQ4BeL*U25sr`SQ<NmR
ztM2^^DXU&_K_;RFh55R%FEx+VxFxUk!nXD4N`1_HvKv-?a;C0bww9_h;P|=fR&rgp
z(bcXit&e?`{!krzi-iuC64seBsL)j^jJ+~w)u*g62$TCt?#<si+%eYPkA+k<CXm}K
zdb3*JG}*~nMF-L2Awua-UwCoHX8O~ybq-V2g~Vd8j(NzwuEe5>yqv|*eALdk4C_rp
zj}XdYbFmH`&_tOwAzRu*7gc;JYTZ$8i@KDgTObY+_nCoDSRa^di(<lM><`hJ_)Is8
z!w;>HNYg<rQGt=2d*0x$gWBq$2DVKu&ULL}Wf{=}?ypTxmCz$dRTViqq1JujKXfSA
zhS?N#-@<8cM5?N5&fXxoSm#RH6(Gy(T+hGuDC^s*fB#F<z-ynryPCCNl~ZnXV#G)_
z&Z}D~VgnG-Vc=*6Q|kV6CP)cUoQ<WIVz2P!X90oC*hLfLyX<aWC}y83;^93WH7oMO
z`M`zIp*6#KIn1a%MV?L3f<VjgO@;#Q;(2{li`tU8&^CBximGn;oVuYiVaQn&usoZ8
z^M&{AuXnCG&Z$zt&E4KM$;O$0iXe6co>#hb%a>&1DXk8W9fW!@|M!e@t<DMqj$o8n
zy_)>+zS$Pieqxs=&m70)R(@bvSJ2yCa%kaH*Gj2-g*X&tMwQ7Lon79yy#X?f3KUk>
z8K`qqcTYwCex9ND%~y}ZoetjdKo&Y8CT{X?vKW>MIsMggVMz^b`p80gTcHfy4e*4$
zTI7zD_@FscXHE*_A&1|H%!o5iuJi0XtAg}`s`>XK%MaBQfd3a7Z{{HPHhanEF5qd&
zZJs-kP)Y+(vi^Oo%l&)V0|{wafy6RfIQzZ(9kukH5Qq6!XmPWTiWkLI)Q#F*$I)pA
z6)8`NJ0WMz8R93!VqkB1sp8g|y<*~Q&u`zU%Ywk)UQ1jw#>0541`uYg6a=sdw>~}e
zj5c;sAl&t~O2rjZI}17(h}c66IGp}z0Se5SC#_V3S9*%lQMPHL)=^h_S7GuS>tlDi
zS0L;nT$@{8avs)TvLHx|zzu@_V2K=stt#O+IL{(w`0$K1U=3zD1cwV+m^AILn50P8
zGcFB(y8AbgeuWeZwQ|<~&I??g=`)X(sc^gBTSG1>ZdFQO^tOa~iJ6?8{J0pl@$#|E
zSV!M}>43G_XRLZ95a+{sO9QizzM!c;#KfWQ!Hg!{atnIUR9zO8KcbK;ql-lCROezW
z(N@_Rkp^I|uv-ge<p%8S%rAuC6gagxP=k<BcQ(smls<oCoi=dhwe7B1Y?9JMec!o2
z+AVZNp*pjvh<Q8EJL|$wlLGg%mF<lSWj7tPK8G{wTHDh@xgXqr$F_rh3M5U`QfOHr
z%Q(Y)+ld^m?fo7%N5j~#<%(<?dE`|JtB!o;*hAXQI>B(n>)85Kxfd=_{}x)A;1s2p
z?RYh}uv_*aV7Bm!FPc>f_@3~E)~&G%6!#Ka#jQG^GG%qoXvG1bX<9a~#va!KIJ0S|
zi733sR$rbN=E-*br<F^3xwr#}cbi@dW2pz39X+gu{L(n|S}JfUVysX+6ZReWJa`x(
z{8w&OXet*Dv;`C{)5;T+P3v3>jJlGR`Ru^?mCELqWKy&nJ&n-UP$xzgeW^ODuyuRR
z8Vi?C9IkPG*IErP@=|@|?}?`t`m(QBCB|3H<hNiw-G&|eS5q=YBLcDt{+5!_d2+{d
z?u04JCTaNx^;?(UFGJUZHI&Tjv8neOxv6t$dd|<efnlmhytU=>@jLj07)GS}Q-~6J
zJ(_sC4<yl^s_FVsd<1C^&G7|oHKM@R%!n=2aGHKEORmm*N_<hih0d{x{*n$$X+T|E
znNB~r9qhvZnkfppE~Ip~yv*Q>E){i7U2xIoU;%eKjjSk5s^YBoi76XN#$}qDG$4$~
z=)<Q^PyZVCH^>do(DNr+#O=(s_{tIgU|`W1xwKqdCZXMJ6I<VD&X;59u6R<n%b#sF
zW4DnfHvNvJLgvh)*#v{yl0Vet%#tU2Vh#gR2Nw%#`{HWjeQv#NEgh1E*7#w*0Mds<
zW%RbF-SMPJ2yTW|rqk_i{n{FRKc=VXEO;n!cJ*__{DCEkGkMT1(Q-d1IlblhA$A;9
zAwAX!`kZD!2!g!bHTb>0uU!lI<qRD3JK!53|J>Hm0sQQ&(7ybCybI)iD7Ass!2iq5
qCZ8Yq1ZQRb>u+AadB6Ace61eNQQn$&4Y)Js+#PKrtxAo1q5lO5s^B&N

literal 0
HcmV?d00001

diff --git a/doc/src/devdocs/precompile_hang.md b/doc/src/devdocs/precompile_hang.md
new file mode 100644
index 0000000000000..0de9c99792b64
--- /dev/null
+++ b/doc/src/devdocs/precompile_hang.md
@@ -0,0 +1,98 @@
+# Fixing precompilation hangs due to open tasks or IO
+
+On Julia 1.10 or higher, you might see the following message:
+
+![Screenshot of precompilation hang](./img/precompilation_hang.png)
+
+This may repeat. If it continues to repeat with no hints that it will
+resolve itself, you may have a "precompilation hang" that requires
+fixing. Even if it's transient, you might prefer to resolve it so that
+users will not be bothered by this warning.  This page walks you
+through how to analyze and fix such issues.
+
+If you follow the advice and hit `Ctrl-C`, you might see
+
+```
+^C Interrupted: Exiting precompilation...
+
+  1 dependency had warnings during precompilation:
+┌ Test1 [ac89d554-e2ba-40bc-bc5c-de68b658c982]
+│  [pid 2745] waiting for IO to finish:
+│   Handle type        uv_handle_t->data
+│   timer              0x55580decd1e0->0x7f94c3a4c340
+```
+
+This message conveys two key pieces of information:
+
+- the hang is occurring during precompilation of `Test1`, a dependency of `Test2` (the package we were trying to load with `using Test2`)
+- during precompilation of `Test1`, Julia created a `Timer` object (use `?Timer` if you're unfamiliar with Timers) which is still open; until that closes, the process is hung
+
+If this is enough of a hint for you to figure out how `timer = Timer(args...)` is being created, one good solution is to add `wait(timer)` if `timer` eventually finishes on its own, or `close(timer)` if you need to force-close it, before the final `end` of the module.
+
+However, there are cases that may not be that straightforward. Usually the best option is to start by determining whether the hang is due to code in Test1 or whether it is due to one of Test1's dependencies:
+
+- Option 1: `Pkg.add("Aqua")` and use [`Aqua.test_persistent_tasks`](https://juliatesting.github.io/Aqua.jl/dev/#Aqua.test_persistent_tasks-Tuple{Base.PkgId}). This should help you identify which package is causing the problem, after which the instructions [below](@ref pchang_fix) should be followed. If needed, you can create a `PkgId` as `Base.PkgId(UUID("..."), "Test1")`, where `...` comes from the `uuid` entry in `Test1/Project.toml`.
+- Option 2: manually diagnose the source of the hang.
+
+To manually diagnose:
+
+1. `Pkg.develop("Test1")`
+2. Comment out all the code `include`d or defined in `Test1`, *except* the `using/import` statements.
+3. Try `using Test2` (or even `using Test1` assuming that hangs too) again
+
+Now we arrive at a fork in the road: either
+
+- the hang persists, indicating it is [due to one of your dependencies](@ref pchang_deps)
+- the hang disappears, indicating that it is [due to something in your code](@ref pchang_fix).
+
+## [Diagnosing and fixing hangs due to a package dependency](@id pchang_deps)
+
+Use a binary search to identify the problematic dependency: start by commenting out half your dependencies, then when you isolate which half is responsible comment out half of that half, etc. (You don't have to remove them from the project, just comment out the `using`/`import` statements.)
+
+Once you've identified a suspect (here we'll call it `ThePackageYouThinkIsCausingTheProblem`), first try precompiling that package. If it also hangs during precompilation, continue chasing the problem backwards.
+
+However, most likely `ThePackageYouThinkIsCausingTheProblem` will precompile fine. This suggests it's in the function `ThePackageYouThinkIsCausingTheProblem.__init__`, which does not run during precompilation of `ThePackageYouThinkIsCausingTheProblem` but *does* in any package that loads `ThePackageYouThinkIsCausingTheProblem`.  To test this theory, set up a minimal working example (MWE), something like
+
+```julia
+(@v1.10) pkg> generate MWE
+  Generating  project MWE:
+    MWE\Project.toml
+    MWE\src\MWE.jl
+```
+
+where the source code of `MWE.jl` is
+
+```julia
+module MWE
+using ThePackageYouThinkIsCausingTheProblem
+end
+```
+
+and you've added `ThePackageYouThinkIsCausingTheProblem` to MWE's dependencies.
+
+If that MWE reproduces the hang, you've found your culprit:
+`ThePackageYouThinkIsCausingTheProblem.__init__` must be creating the `Timer` object. If the timer object can be safely `close`d, that's a good option. Otherwise, the most common solution is to avoid creating the timer while *any* package is being precompiled: add
+
+```julia
+ccall(:jl_generating_output, Cint, ()) == 1 && return nothing
+```
+
+as the first line of `ThePackageYouThinkIsCausingTheProblem.__init__`, and it will avoid doing any initialization in any Julia process whose purpose is to precompile packages.
+
+## [Fixing package code to avoid hangs](@id pchang_fix)
+
+Search your package for suggestive words (here like "Timer") and see if you can identify where the problem is being created. Note that a method *definition* like
+
+```julia
+maketimer() = Timer(timer -> println("hi"), 0; interval=1)
+```
+
+is not problematic in and of itself: it can cause this problem only if `maketimer` gets called while the module is being defined. This might be happening from a top-level statement such as
+
+```julia
+const GLOBAL_TIMER = maketimer()
+```
+
+or it might conceivably occur in a [precompile workload](https://github.com/JuliaLang/PrecompileTools.jl).
+
+If you struggle to identify the causative lines, then consider doing a binary search: comment out sections of your package (or `include` lines to omit entire files) until you've reduced the problem in scope.
diff --git a/src/jl_uv.c b/src/jl_uv.c
index 281dd798dbb36..62dc3a628d085 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -51,9 +51,9 @@ static void walk_print_cb(uv_handle_t *h, void *arg)
     npad += strlen(type);
     pad += npad < strlen(pad) ? npad : strlen(pad);
     if (fd == -1)
-        jl_safe_printf(" %s   %s@%p->%p\n", type,             pad, (void*)h, (void*)h->data);
+        jl_safe_printf(" %s   %s%p->%p\n", type,             pad, (void*)h, (void*)h->data);
     else
-        jl_safe_printf(" %s[%zd] %s@%p->%p\n", type, (size_t)fd, pad, (void*)h, (void*)h->data);
+        jl_safe_printf(" %s[%zd] %s%p->%p\n", type, (size_t)fd, pad, (void*)h, (void*)h->data);
 }
 
 static void wait_empty_func(uv_timer_t *t)
@@ -63,9 +63,12 @@ static void wait_empty_func(uv_timer_t *t)
     if (!uv_loop_alive(t->loop))
         return;
     jl_safe_printf("\n[pid %zd] waiting for IO to finish:\n"
-                   " TYPE[FD/PID]       @UV_HANDLE_T->DATA\n",
+                   " Handle type        uv_handle_t->data\n",
                    (size_t)uv_os_getpid());
     uv_walk(jl_io_loop, walk_print_cb, NULL);
+    if (jl_generating_output() && jl_options.incremental) {
+        jl_safe_printf("This means that a package has started a background task or event source that has not finished running. For precompilation to complete successfully, the event source needs to be closed explicitly. See the developer documentation on fixing precompilation hangs for more help.\n");
+    }
     jl_gc_collect(JL_GC_FULL);
 }
 

From 9754dbbde5c0b39faa682c390668cf00f9a3df43 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 13 Nov 2023 13:40:37 -0500
Subject: [PATCH 0240/1315] add an exception type for missing IR (#52121)

This makes it possible to suppress the output and easier to catch the
exception if a deployed application hits this situation.
---
 base/boot.jl             | 3 +++
 src/builtins.c           | 2 +-
 src/gf.c                 | 7 ++-----
 src/interpreter.c        | 2 +-
 src/jl_exported_data.inc | 1 +
 src/jltypes.c            | 1 +
 src/julia.h              | 1 +
 src/staticdata.c         | 3 ++-
 8 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 604817cbf2117..7ada0782600b4 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -342,6 +342,9 @@ end
 struct ConcurrencyViolationError <: Exception
     msg::AbstractString
 end
+struct MissingCodeError <: Exception
+    mi::MethodInstance
+end
 struct InterruptException <: Exception end
 struct DomainError <: Exception
     val
diff --git a/src/builtins.c b/src/builtins.c
index b2733818abcb0..b745fed2a888d 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1968,7 +1968,7 @@ JL_CALLABLE(jl_f_intrinsic_call)
         f = cglobal_auto;
     unsigned fargs = intrinsic_nargs[f];
     if (!fargs)
-        jl_errorf("`%s` must be compiled to be called", jl_intrinsic_name(f));
+        jl_errorf("`%s` requires the compiler", jl_intrinsic_name(f));
     JL_NARGS(intrinsic_call, fargs, fargs);
 
     union {
diff --git a/src/gf.c b/src/gf.c
index 0ad875b167506..f2365ee040670 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -2490,7 +2490,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
             return codeinst;
         }
         if (compile_option == JL_OPTIONS_COMPILE_OFF) {
-            jl_printf(JL_STDERR, "code missing for ");
+            jl_printf(JL_STDERR, "No compiled code available for ");
             jl_static_show(JL_STDERR, (jl_value_t*)mi);
             jl_printf(JL_STDERR, " : sysimg may not have been built with --compile=all\n");
         }
@@ -2505,10 +2505,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         if (ucache_invoke == NULL) {
             if (def->source == jl_nothing && (jl_atomic_load_relaxed(&ucache->def->uninferred) == jl_nothing ||
                                               jl_atomic_load_relaxed(&ucache->def->uninferred) == NULL)) {
-                jl_printf(JL_STDERR, "source not available for ");
-                jl_static_show(JL_STDERR, (jl_value_t*)mi);
-                jl_printf(JL_STDERR, "\n");
-                jl_error("source missing for method that needs to be compiled");
+                jl_throw(jl_new_struct(jl_missingcodeerror_type, (jl_value_t*)mi));
             }
             jl_generate_fptr_for_unspecialized(ucache);
             ucache_invoke = jl_atomic_load_acquire(&ucache->invoke);
diff --git a/src/interpreter.c b/src/interpreter.c
index f6000b6aeca92..d9536ca512889 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -683,7 +683,7 @@ jl_code_info_t *jl_code_for_interpreter(jl_method_instance_t *mi, size_t world)
         }
     }
     if (!src || !jl_is_code_info(src)) {
-        jl_error("source missing for method called in interpreter");
+        jl_throw(jl_new_struct(jl_missingcodeerror_type, (jl_value_t*)mi));
     }
     return src;
 }
diff --git a/src/jl_exported_data.inc b/src/jl_exported_data.inc
index 11617bea9ec65..b6b9774c1538e 100644
--- a/src/jl_exported_data.inc
+++ b/src/jl_exported_data.inc
@@ -84,6 +84,7 @@
     XX(jl_method_match_type) \
     XX(jl_method_type) \
     XX(jl_methtable_type) \
+    XX(jl_missingcodeerror_type) \
     XX(jl_module_type) \
     XX(jl_n_threads_per_pool) \
     XX(jl_namedtuple_type) \
diff --git a/src/jltypes.c b/src/jltypes.c
index c55c6f47f064c..d9cf77927efb7 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3507,6 +3507,7 @@ void post_boot_hooks(void)
     jl_methoderror_type    = (jl_datatype_t*)core("MethodError");
     jl_loaderror_type      = (jl_datatype_t*)core("LoadError");
     jl_initerror_type      = (jl_datatype_t*)core("InitError");
+    jl_missingcodeerror_type = (jl_datatype_t*)core("MissingCodeError");
     jl_pair_type           = core("Pair");
     jl_kwcall_func         = core("kwcall");
     jl_kwcall_mt           = ((jl_datatype_t*)jl_typeof(jl_kwcall_func))->name->mt;
diff --git a/src/julia.h b/src/julia.h
index b2f6ab8b7a62f..0b3a010c32856 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -827,6 +827,7 @@ extern JL_DLLIMPORT jl_datatype_t *jl_typeerror_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_methoderror_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_undefvarerror_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_atomicerror_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_datatype_t *jl_missingcodeerror_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_lineinfonode_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_stackovf_exception JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_memory_exception JL_GLOBALLY_ROOTED;
diff --git a/src/staticdata.c b/src/staticdata.c
index 74ac268508ede..22571922fc4ce 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -99,7 +99,7 @@ extern "C" {
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
-#define NUM_TAGS    173
+#define NUM_TAGS    174
 
 // An array of references that need to be restored from the sysimg
 // This is a manually constructed dual of the gvars array, which would be produced by codegen for Julia code, for C.
@@ -237,6 +237,7 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_undefref_exception);
         INSERT_TAG(jl_readonlymemory_exception);
         INSERT_TAG(jl_atomicerror_type);
+        INSERT_TAG(jl_missingcodeerror_type);
 
         // other special values
         INSERT_TAG(jl_emptysvec);

From 2d449d4c870fcb8e347d0a49e974d4ca0020e440 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Mon, 13 Nov 2023 18:22:40 -0600
Subject: [PATCH 0241/1315] Rewrite sortslices from scratch and add inference
 tests (#52039)

---
 base/multidimensional.jl | 44 ++++++++++++++--------------------------
 test/arrayops.jl         |  9 ++++++++
 2 files changed, 24 insertions(+), 29 deletions(-)

diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index d8646e4c261ed..0ca2fbc36e6df 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -1897,39 +1897,25 @@ julia> sortslices(reshape([5; 4; 3; 2; 1], (1,1,5)), dims=3, by=x->x[1,1])
 ```
 """
 function sortslices(A::AbstractArray; dims::Union{Integer, Tuple{Vararg{Integer}}}, kws...)
-    _sortslices(A, Val{dims}(); kws...)
-end
+    if A isa Matrix && dims isa Integer && dims == 1
+        # TODO: remove once the generic version becomes as fast or faster
+        perm = sortperm(eachslice(A; dims); kws...)
+        return A[perm, :]
+    end
 
-# Works around inference's lack of ability to recognize partial constness
-struct DimSelector{dims, T}
-    A::T
+    B = similar(A)
+    _sortslices!(B, A, Val{dims}(); kws...)
+    B
 end
-DimSelector{dims}(x::T) where {dims, T} = DimSelector{dims, T}(x)
-(ds::DimSelector{dims, T})(i) where {dims, T} = i in dims ? axes(ds.A, i) : (:,)
-
-_negdims(n, dims) = filter(i->!(i in dims), 1:n)
 
-function compute_itspace(A, ::Val{dims}) where {dims}
-    negdims = _negdims(ndims(A), dims)
-    axs = Iterators.product(ntuple(DimSelector{dims}(A), ndims(A))...)
-    vec(permutedims(collect(axs), (dims..., negdims...)))
-end
+function _sortslices!(B, A, ::Val{dims}; kws...) where dims
+    ves = vec(eachslice(A; dims))
+    perm = sortperm(ves; kws...)
+    bes = eachslice(B; dims)
 
-function _sortslices(A::AbstractArray, d::Val{dims}; kws...) where dims
-    itspace = compute_itspace(A, d)
-    vecs = map(its->view(A, its...), itspace)
-    p = sortperm(vecs; kws...)
-    if ndims(A) == 2 && isa(dims, Integer) && isa(A, Array)
-        # At the moment, the performance of the generic version is subpar
-        # (about 5x slower). Hardcode a fast-path until we're able to
-        # optimize this.
-        return dims == 1 ? A[p, :] : A[:, p]
-    else
-        B = similar(A)
-        for (x, its) in zip(p, itspace)
-            B[its...] = vecs[x]
-        end
-        B
+    # TODO for further optimization: traverse in memory order
+    for (slice, i) in zip(eachslice(B; dims), perm)
+        slice .= ves[i]
     end
 end
 
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 30f00ca5d5a46..9c9aac987929d 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -1446,6 +1446,15 @@ end
     @test sortslices(B, dims=(1,3)) == B
 end
 
+@testset "sortslices inference (#52019)" begin
+    x = rand(3, 2)
+    @inferred sortslices(x, dims=1)
+    @inferred sortslices(x, dims=(2,))
+    x = rand(1, 2, 3)
+    @inferred sortslices(x, dims=(1,2))
+    @inferred sortslices(x, dims=3, by=sum)
+end
+
 @testset "fill" begin
     @test fill!(Float64[1.0], -0.0)[1] === -0.0
     A = fill(1.,3,3)

From d5f873f2f3017c268c388081158f7b1401e1e304 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 13 Nov 2023 19:25:34 -0500
Subject: [PATCH 0242/1315] fix `--pkgimage[s]` inconsistencies (#52147)

---
 base/util.jl    | 3 +--
 pkgimage.mk     | 4 ++--
 src/jloptions.c | 2 +-
 test/loading.jl | 2 +-
 4 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/base/util.jl b/base/util.jl
index fe04eaf04bd47..cbe07bb05e30f 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -163,8 +163,7 @@ To get the julia command without propagated command line arguments, `julia_cmd()
     The flags `--color` and `--startup-file` were added in Julia 1.5.
 
 !!! compat "Julia 1.9"
-    The keyword argument `cpu_target` was added.
-
+    The keyword argument `cpu_target` was added in 1.9.
     The flag `--pkgimages` was added in Julia 1.9.
 """
 function julia_cmd(julia=joinpath(Sys.BINDIR, julia_exename()); cpu_target::Union{Nothing,String} = nothing)
diff --git a/pkgimage.mk b/pkgimage.mk
index 58049e9a48f2b..0a4823b70e4a2 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -35,12 +35,12 @@ $$(BUILDDIR)/stdlib/$1.debug.image: export JULIA_CPU_TARGET=$(JULIA_CPU_TARGET)
 
 $$(BUILDDIR)/stdlib/$1.release.image: $$($1_SRCS) $$(addsuffix .release.image,$$(addprefix $$(BUILDDIR)/stdlib/,$2)) $(build_private_libdir)/sys.$(SHLIB_EXT)
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
-	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --pkgimage=no -e 'Base.compilecache(Base.identify_package("$1"))')
+	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --pkgimages=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	touch $$@
 $$(BUILDDIR)/stdlib/$1.debug.image: $$($1_SRCS) $$(addsuffix .debug.image,$$(addprefix $$(BUILDDIR)/stdlib/,$2)) $(build_private_libdir)/sys-debug.$(SHLIB_EXT)
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
-	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --pkgimage=no -e 'Base.compilecache(Base.identify_package("$1"))')
+	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --pkgimages=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	touch $$@
 else
diff --git a/src/jloptions.c b/src/jloptions.c
index f9443ed8f5704..13ee06b862c32 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -475,7 +475,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
             else if (!strcmp(optarg,"no"))
                 jl_options.use_pkgimages = JL_OPTIONS_USE_PKGIMAGES_NO;
             else
-                jl_errorf("julia: invalid argument to --pkgimage={yes|no} (%s)", optarg);
+                jl_errorf("julia: invalid argument to --pkgimages={yes|no} (%s)", optarg);
             break;
         case 'C': // cpu-target
             jl_options.cpu_target = strdup(optarg);
diff --git a/test/loading.jl b/test/loading.jl
index 9f81a7637cb62..5ae22f4d598aa 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1092,7 +1092,7 @@ end
     end
 end
 
-pkgimage(val) = val == 1 ? `--pkgimage=yes` : `--pkgimage=no`
+pkgimage(val) = val == 1 ? `--pkgimages=yes` : `--pkgimages=no`
 opt_level(val) = `-O$val`
 debug_level(val) = `-g$val`
 inline(val) = val == 1 ? `--inline=yes` : `--inline=no`

From 9729f312186c70de4f5209dfa0d0fdf0f1669ee6 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Mon, 13 Nov 2023 20:14:06 -0500
Subject: [PATCH 0243/1315] Tweak test LOAD_PATH and fix loading test (#52150)

This does two things:
1. Give the latest addition to the loading test an active project, so
that it works, even without a global one.
2. Standardize the JULIA_LOAD_PATH setting to "@:@stdlib" for both
`Base.runtests` (which CI uses) and `make test-*`. Before, the former
was using the default load path, while the latter was using "@stdlib"
only. However, neither is great. With the default load path, test
results could in theory depend on the global environment and tests that
accidentally modify the global environment go undetected. The latter
resolved those issues. However, without the active project on the load
path, the behavior is quite weird - even if you activate a project you
can't load it and even if you could, and even if you try to load
something explicitly, that project can't find its dependencies. I think
"@:@stdlib", is a reasonable compromise here. It has the same
protections against the global environment interfering with test
results, while also making the active project logic work as usual.

Fixes #52148
Fixes #50055 (the remainder thereof at least)
---
 Make.inc        |  3 +++
 base/util.jl    |  2 +-
 test/Makefile   |  2 +-
 test/loading.jl | 10 ++++++----
 4 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/Make.inc b/Make.inc
index d62c485b03dbc..910fcdc276e3b 100644
--- a/Make.inc
+++ b/Make.inc
@@ -599,10 +599,13 @@ CPP_STDOUT := $(CPP) -P
 # file extensions
 ifeq ($(OS), WINNT)
   SHLIB_EXT := dll
+  PATHSEP := ;
 else ifeq ($(OS), Darwin)
   SHLIB_EXT := dylib
+  PATHSEP := :
 else
   SHLIB_EXT := so
+  PATHSEP := :
 endif
 
 ifeq ($(OS),WINNT)
diff --git a/base/util.jl b/base/util.jl
index cbe07bb05e30f..6a9f219e403c0 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -690,7 +690,7 @@ function runtests(tests = ["all"]; ncores::Int = ceil(Int, Sys.CPU_THREADS / 2),
     ENV2["JULIA_CPU_THREADS"] = "$ncores"
     pathsep = Sys.iswindows() ? ";" : ":"
     ENV2["JULIA_DEPOT_PATH"] = string(mktempdir(; cleanup = true), pathsep) # make sure the default depots can be loaded
-    delete!(ENV2, "JULIA_LOAD_PATH")
+    ENV2["JULIA_LOAD_PATH"] = string("@", pathsep, "@stdlib")
     delete!(ENV2, "JULIA_PROJECT")
     try
         run(setenv(`$(julia_cmd()) $(joinpath(Sys.BINDIR,
diff --git a/test/Makefile b/test/Makefile
index d8605341ff9b9..c3b877793f4b5 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -7,7 +7,7 @@ STDLIBDIR := $(build_datarootdir)/julia/stdlib/$(VERSDIR)
 # TODO: this Makefile ignores BUILDDIR, except for computing JULIA_EXECUTABLE
 
 export JULIA_DEPOT_PATH := $(build_prefix)/share/julia
-export JULIA_LOAD_PATH := @stdlib
+export JULIA_LOAD_PATH := @$(PATHSEP)@stdlib
 unexport JULIA_PROJECT :=
 unexport JULIA_BINDIR :=
 
diff --git a/test/loading.jl b/test/loading.jl
index 5ae22f4d598aa..efb83a6e00335 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1277,6 +1277,9 @@ end
 
 @testset "relocatable upgrades #51989" begin
     mktempdir() do depot
+        project_path = joinpath(depot, "project")
+        mkpath(project_path)
+
         # Create fake `Foo.jl` package with two files:
         foo_path = joinpath(depot, "dev", "Foo")
         mkpath(joinpath(foo_path, "src"))
@@ -1300,9 +1303,8 @@ end
 
         # In our depot, `dev` and then `precompile` this `Foo` package.
         @test success(addenv(
-            `$(Base.julia_cmd()) --startup-file=no -e 'import Pkg; Pkg.develop("Foo"); Pkg.precompile(); exit(0)'`,
-            "JULIA_DEPOT_PATH" => depot,
-        ))
+            `$(Base.julia_cmd()) --project=$project_path --startup-file=no -e 'import Pkg; Pkg.develop("Foo"); Pkg.precompile(); exit(0)'`,
+            "JULIA_DEPOT_PATH" => depot))
 
         # Get the size of the generated `.ji` file so that we can ensure that it gets altered
         foo_compiled_path = joinpath(depot, "compiled", "v$(VERSION.major).$(VERSION.minor)", "Foo")
@@ -1321,7 +1323,7 @@ end
 
         # Try to load `Foo`; this should trigger recompilation, not an error!
         @test success(addenv(
-            `$(Base.julia_cmd()) --startup-file=no -e 'using Foo; exit(0)'`,
+            `$(Base.julia_cmd()) --project=$project_path --startup-file=no -e 'using Foo; exit(0)'`,
             "JULIA_DEPOT_PATH" => depot,
         ))
 

From 092f95fa33d89bd57de615b0fb5bc5affe4c61f0 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 14 Nov 2023 11:52:03 +0900
Subject: [PATCH 0244/1315] fix up the test case to pass custom codegen params
 to `code_llvm` (#52144)

---
 test/compiler/AbstractInterpreter.jl | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 2980e456e9f9c..9580fc55508ac 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -464,6 +464,7 @@ let # generate cache
         lookup)
     io = IOBuffer()
     code_llvm(io, custom_lookup_target, (Bool,Int,); params)
-    @test  occursin("j_sin_", String(take!(io)))
-    @test !occursin("j_cos_", String(take!(io)))
+    s = String(take!(io))
+    @test  occursin("j_sin_", s)
+    @test !occursin("j_cos_", s)
 end

From c1f67f82bda6918b736fb592a16567c7cd2fda7b Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Tue, 14 Nov 2023 03:14:01 -0300
Subject: [PATCH 0245/1315] Use libuv thread instead of std::thread to avoid
 musl issues (#52149)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

See
https://ariadne.space/2021/06/25/understanding-thread-stack-sizes-and-how-alpine-is-different/
and
https://git.alpinelinux.org/aports/commit/?id=4ab6ef38f167f4983008f8b213e5beace8d453f0

---------

Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com>
---
 src/aotcompile.cpp | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index af7e05b338d2f..b65d412b6bcda 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1263,6 +1263,12 @@ static void construct_vars(Module &M, Partition &partition) {
     gidxs_var->setDSOLocal(true);
 }
 
+extern "C" void lambda_trampoline(void* arg) {
+    std::function<void()>* func = static_cast<std::function<void()>*>(arg);
+    (*func)();
+    delete func;
+}
+
 // Entrypoint to optionally-multithreaded image compilation. This handles global coordination of the threading,
 // as well as partitioning, serialization, and deserialization.
 template<typename ModuleReleasedFunc>
@@ -1351,9 +1357,9 @@ static SmallVector<AOTOutputs, 16> add_output(Module &M, TargetMachine &TM, Stri
     // Start all of the worker threads
     {
         JL_TIMING(NATIVE_AOT, NATIVE_Opt);
-        std::vector<std::thread> workers(threads);
+        std::vector<uv_thread_t> workers(threads);
         for (unsigned i = 0; i < threads; i++) {
-            workers[i] = std::thread([&, i]() {
+            std::function<void()> func = [&, i]() {
                 LLVMContext ctx;
                 // Lazily deserialize the entire module
                 timers[i].deserialize.startTimer();
@@ -1375,12 +1381,14 @@ static SmallVector<AOTOutputs, 16> add_output(Module &M, TargetMachine &TM, Stri
                 timers[i].construct.stopTimer();
 
                 outputs[i] = add_output_impl(*M, TM, timers[i], unopt_out, opt_out, obj_out, asm_out);
-            });
+            };
+            auto arg = new std::function<void()>(func);
+            uv_thread_create(&workers[i], lambda_trampoline, arg); // Use libuv thread to avoid issues with stack sizes
         }
 
         // Wait for all of the worker threads to finish
-        for (auto &w : workers)
-            w.join();
+        for (unsigned i = 0; i < threads; i++)
+            uv_thread_join(&workers[i]);
     }
 
     output_timer.stopTimer();
@@ -1418,7 +1426,6 @@ static unsigned compute_image_thread_count(const ModuleInfo &info) {
         LLVM_DEBUG(dbgs() << "COFF is restricted to a single thread for large images\n");
         return 1;
     }
-
     // This is not overridable because empty modules do occasionally appear, but they'll be very small and thus exit early to
     // known easy behavior. Plus they really don't warrant multiple threads
     if (info.weight < 1000) {

From 1a885c4f7209b64cede127756382fdae907dcd30 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 15 Nov 2023 00:55:00 +0900
Subject: [PATCH 0246/1315] AbsInt: thread lattice throughout
 `abstract_call_gf_by_type` (#52162)

---
 base/compiler/abstractinterpretation.jl | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 96b63c91d9dd5..3a61aa5ef3dae 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -10,7 +10,8 @@ call_result_unused(si::StmtInfo) = !si.used
 function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
                                   arginfo::ArgInfo, si::StmtInfo, @nospecialize(atype),
                                   sv::AbsIntState, max_methods::Int)
-    ⊑ₚ = ⊑(ipo_lattice(interp))
+    𝕃ₚ, 𝕃ᵢ = ipo_lattice(interp), typeinf_lattice(interp)
+    ⊑ₚ = ⊑(𝕃ₚ)
     if !should_infer_this_call(interp, sv)
         add_remark!(interp, sv, "Skipped call in throw block")
         # At this point we are guaranteed to end up throwing on this path,
@@ -21,7 +22,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
     end
 
     argtypes = arginfo.argtypes
-    matches = find_matching_methods(typeinf_lattice(interp), argtypes, atype, method_table(interp),
+    matches = find_matching_methods(𝕃ᵢ, argtypes, atype, method_table(interp),
         InferenceParams(interp).max_union_splitting, max_methods)
     if isa(matches, FailedMethodMatch)
         add_remark!(interp, sv, matches.reason)
@@ -40,7 +41,6 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
     fargs = arginfo.fargs
     all_effects = EFFECTS_TOTAL
 
-    𝕃ₚ = ipo_lattice(interp)
     for i in 1:napplicable
         match = applicable[i]::MethodMatch
         method = match.method
@@ -131,9 +131,9 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
                                Any[Bottom for _ in 1:length(argtypes)]
             end
             for i = 1:length(argtypes)
-                cnd = conditional_argtype(this_conditional, sig, argtypes, i)
-                conditionals[1][i] = tmerge(conditionals[1][i], cnd.thentype)
-                conditionals[2][i] = tmerge(conditionals[2][i], cnd.elsetype)
+                cnd = conditional_argtype(𝕃ᵢ, this_conditional, sig, argtypes, i)
+                conditionals[1][i] = tmerge(𝕃ᵢ, conditionals[1][i], cnd.thentype)
+                conditionals[2][i] = tmerge(𝕃ᵢ, conditionals[2][i], cnd.elsetype)
             end
         end
         if bail_out_call(interp, InferenceLoopState(sig, rettype, all_effects), sv)
@@ -394,7 +394,7 @@ function from_interconditional(𝕃ᵢ::AbstractLattice, @nospecialize(rt), sv::
                 new_elsetype = maybecondinfo[2][i]
             else
                 # otherwise compute it on the fly
-                cnd = conditional_argtype(rt, maybecondinfo, argtypes, i)
+                cnd = conditional_argtype(𝕃ᵢ, rt, maybecondinfo, argtypes, i)
                 new_thentype = cnd.thentype
                 new_elsetype = cnd.elsetype
             end
@@ -440,11 +440,12 @@ function from_interconditional(𝕃ᵢ::AbstractLattice, @nospecialize(rt), sv::
     return widenconditional(rt)
 end
 
-function conditional_argtype(@nospecialize(rt), @nospecialize(sig), argtypes::Vector{Any}, i::Int)
+function conditional_argtype(𝕃ᵢ::AbstractLattice, @nospecialize(rt), @nospecialize(sig),
+                             argtypes::Vector{Any}, i::Int)
     if isa(rt, InterConditional) && rt.slot == i
         return rt
     else
-        thentype = elsetype = tmeet(widenslotwrapper(argtypes[i]), fieldtype(sig, i))
+        thentype = elsetype = tmeet(𝕃ᵢ, widenslotwrapper(argtypes[i]), fieldtype(sig, i))
         condval = maybe_extract_const_bool(rt)
         condval === true && (elsetype = Bottom)
         condval === false && (thentype = Bottom)

From 4bc45a7f0adbf15416ca860eb3e4cb100b115e91 Mon Sep 17 00:00:00 2001
From: "Luiz M. Faria" <maltezfaria@users.noreply.github.com>
Date: Tue, 14 Nov 2023 17:49:44 +0100
Subject: [PATCH 0247/1315] Transpose elements in `copy_transpose!` (#52116)

---
 stdlib/LinearAlgebra/src/transpose.jl |  2 +-
 stdlib/LinearAlgebra/test/adjtrans.jl | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/transpose.jl b/stdlib/LinearAlgebra/src/transpose.jl
index cd9123615d4bb..afc3494fc9726 100644
--- a/stdlib/LinearAlgebra/src/transpose.jl
+++ b/stdlib/LinearAlgebra/src/transpose.jl
@@ -194,7 +194,7 @@ function copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_de
     for jsrc in jr_src
         jdest = first(jr_dest)
         for isrc in ir_src
-            B[idest,jdest] = A[isrc,jsrc]
+            B[idest,jdest] = transpose(A[isrc,jsrc])
             jdest += step(jr_dest)
         end
         idest += step(ir_dest)
diff --git a/stdlib/LinearAlgebra/test/adjtrans.jl b/stdlib/LinearAlgebra/test/adjtrans.jl
index 555010913660a..ccd93c97d440e 100644
--- a/stdlib/LinearAlgebra/test/adjtrans.jl
+++ b/stdlib/LinearAlgebra/test/adjtrans.jl
@@ -681,4 +681,19 @@ end
     @test sprint(Base.print_matrix, Adjoint(o)) == sprint(Base.print_matrix, OneHotVecOrMat((1,2), (1,4)))
 end
 
+@testset "copy_transpose!" begin
+    # scalar case
+    A = [randn() for _ in 1:2, _ in 1:3]
+    At = copy(transpose(A))
+    B = zero.(At)
+    LinearAlgebra.copy_transpose!(B, axes(B, 1), axes(B, 2), A, axes(A, 1), axes(A, 2))
+    @test B == At
+    # matrix of matrices
+    A = [randn(2,3) for _ in 1:2, _ in 1:3]
+    At = copy(transpose(A))
+    B = zero.(At)
+    LinearAlgebra.copy_transpose!(B, axes(B, 1), axes(B, 2), A, axes(A, 1), axes(A, 2))
+    @test B == At
+end
+
 end # module TestAdjointTranspose

From 4fd96924c324f2ff41ec7396bebfe2c65b9072fb Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 14 Nov 2023 20:53:17 +0000
Subject: [PATCH 0248/1315] test: fix race in atexit test

Exposed by the presence of any atexit hooks in the new process, such as added in this PR.
---
 test/atexit.jl | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/test/atexit.jl b/test/atexit.jl
index 64b56e32466df..4a37d465f250b 100644
--- a/test/atexit.jl
+++ b/test/atexit.jl
@@ -214,12 +214,13 @@ using Test
             # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
             # 3. attempting to register a hook after all hooks have finished (disallowed)
             """
-            const atexit_has_finished = Threads.Atomic{Bool}(false)
+            const atexit_has_finished = Threads.Atomic{Int}(0)
             atexit() do
                 Threads.@spawn begin
                     # Block until the atexit hooks have all finished. We use a manual "spin
                     # lock" because task switch is disallowed inside the finalizer, below.
-                    while !atexit_has_finished[] end
+                    atexit_has_finished[] = 1
+                    while atexit_has_finished[] == 1 end
                     try
                         # By the time this runs, all the atexit hooks will be done.
                         # So this will throw.
@@ -231,15 +232,16 @@ using Test
                         exit(22)
                     end
                 end
+                while atexit_has_finished[] == 0 end
             end
             # Finalizers run after the atexit hooks, so this blocks exit until the spawned
             # task above gets a chance to run.
             x = []
             finalizer(x) do x
                 # Allow the spawned task to finish
-                atexit_has_finished[] = true
+                atexit_has_finished[] = 2
                 # Then spin forever to prevent exit.
-                while atexit_has_finished[] end
+                while atexit_has_finished[] == 2 end
             end
             exit(0)
             """ => 22,

From b638381d23e8d4d3f11c81a4cdf0093818552dcd Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 23 Oct 2023 18:06:19 +0000
Subject: [PATCH 0249/1315] atexit: move hook before precompile output

To show how this is used, this updates the profile_printing_listener
background job to use this mechanism.

Also ensure mktemp and mktempdir cleanup even on unexpected exit:
Previously this was relying on all Tasks running to completion, which is
not a good assumption. Add the atexit hook, so that even if they do not
run to completion, they still get cleaned up.
---
 NEWS.md                        |  4 +++
 base/Base.jl                   | 31 ++++++++++++------
 base/file.jl                   | 58 ++++++++++++++++++++++++++--------
 base/initdefs.jl               | 10 +++---
 contrib/generate_precompile.jl |  4 ---
 src/init.c                     | 30 ++++++++++--------
 src/jl_uv.c                    |  4 +--
 src/julia_internal.h           |  1 -
 src/partr.c                    |  5 +++
 src/signal-handling.c          | 14 +++++---
 src/staticdata_utils.c         | 32 ++++++++++---------
 stdlib/Profile/Project.toml    |  3 --
 stdlib/REPL/src/precompile.jl  |  4 ---
 13 files changed, 124 insertions(+), 76 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index d53911040e4d7..18e7f5d87316c 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -19,6 +19,10 @@ New language features
 
 Language changes
 ----------------
+* During precompilation, the `atexit` hooks now run before saving the output file. This
+  allows users to safely tear down background state (such as closing Timers and sending
+  disconnect notifications to heartbeat tasks) and cleanup other resources when the program
+  wants to begin exiting.
 
 Compiler/Runtime improvements
 -----------------------------
diff --git a/base/Base.jl b/base/Base.jl
index 9d0a44b7a1f5d..0ca13265adc4f 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -481,6 +481,7 @@ include("summarysize.jl")
 include("errorshow.jl")
 
 include("initdefs.jl")
+Filesystem.__postinit__()
 
 # worker threads
 include("threadcall.jl")
@@ -594,14 +595,12 @@ if is_primary_base_module
 # Profiling helper
 # triggers printing the report and (optionally) saving a heap snapshot after a SIGINFO/SIGUSR1 profile request
 # Needs to be in Base because Profile is no longer loaded on boot
-const PROFILE_PRINT_COND = Ref{Base.AsyncCondition}()
-function profile_printing_listener()
+function profile_printing_listener(cond::Base.AsyncCondition)
     profile = nothing
     try
-        while true
-            wait(PROFILE_PRINT_COND[])
-            profile = @something(profile, require(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))
-
+        while _trywait(cond)
+            # this call to require is mostly legal, only because Profile has no dependencies and is usually in LOAD_PATH
+            profile = @something(profile, require(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))::Module
             invokelatest(profile.peek_report[])
             if Base.get_bool_env("JULIA_PROFILE_PEEK_HEAP_SNAPSHOT", false) === true
                 println(stderr, "Saving heap snapshot...")
@@ -614,10 +613,13 @@ function profile_printing_listener()
             @error "Profile printing listener crashed" exception=ex,catch_backtrace()
         end
     end
+    nothing
 end
 
 function __init__()
     # Base library init
+    global _atexit_hooks_finished = false
+    Filesystem.__postinit__()
     reinit_stdio()
     Multimedia.reinit_displays() # since Multimedia.displays uses stdout as fallback
     # initialize loading
@@ -633,9 +635,20 @@ function __init__()
         # triggering a profile via signals is not implemented on windows
         cond = Base.AsyncCondition()
         Base.uv_unref(cond.handle)
-        PROFILE_PRINT_COND[] = cond
-        ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), PROFILE_PRINT_COND[].handle)
-        errormonitor(Threads.@spawn(profile_printing_listener()))
+        t = errormonitor(Threads.@spawn(profile_printing_listener(cond)))
+        atexit() do
+            # destroy this callback when exiting
+            ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), C_NULL)
+            # this will prompt any ongoing or pending event to flush also
+            close(cond)
+            # error-propagation is not needed, since the errormonitor will handle printing that better
+            _wait(t)
+        end
+        finalizer(cond) do c
+            # if something goes south, still make sure we aren't keeping a reference in C to this
+            ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), C_NULL)
+        end
+        ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), cond.handle)
     end
     _require_world_age[] = get_world_counter()
     # Prevent spawned Julia process from getting stuck waiting on Tracy to connect.
diff --git a/base/file.jl b/base/file.jl
index 9060b086b44bb..e46a0c34dade2 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -521,37 +521,67 @@ const TEMP_CLEANUP = Dict{String,Bool}()
 const TEMP_CLEANUP_LOCK = ReentrantLock()
 
 function temp_cleanup_later(path::AbstractString; asap::Bool=false)
-    lock(TEMP_CLEANUP_LOCK)
+    @lock TEMP_CLEANUP_LOCK begin
     # each path should only be inserted here once, but if there
     # is a collision, let !asap win over asap: if any user might
     # still be using the path, don't delete it until process exit
     TEMP_CLEANUP[path] = get(TEMP_CLEANUP, path, true) & asap
     if length(TEMP_CLEANUP) > TEMP_CLEANUP_MAX[]
-        temp_cleanup_purge()
+        temp_cleanup_purge_prelocked(false)
         TEMP_CLEANUP_MAX[] = max(TEMP_CLEANUP_MIN[], 2*length(TEMP_CLEANUP))
     end
-    unlock(TEMP_CLEANUP_LOCK)
-    return nothing
+    end
+    nothing
 end
 
-function temp_cleanup_purge(; force::Bool=false)
-    need_gc = Sys.iswindows()
-    for (path, asap) in TEMP_CLEANUP
+function temp_cleanup_forget(path::AbstractString)
+    @lock TEMP_CLEANUP_LOCK delete!(TEMP_CLEANUP, path)
+    nothing
+end
+
+function temp_cleanup_purge_prelocked(force::Bool)
+    filter!(TEMP_CLEANUP) do (path, asap)
         try
-            if (force || asap) && ispath(path)
-                need_gc && GC.gc(true)
-                need_gc = false
+            ispath(path) || return false
+            if force || asap
                 prepare_for_deletion(path)
                 rm(path, recursive=true, force=true)
             end
-            !ispath(path) && delete!(TEMP_CLEANUP, path)
+            return ispath(path)
         catch ex
             @warn """
                 Failed to clean up temporary path $(repr(path))
                 $ex
                 """ _group=:file
+            ex isa InterruptException && rethrow()
+            return true
         end
     end
+    nothing
+end
+
+function temp_cleanup_purge_all()
+    may_need_gc = false
+    @lock TEMP_CLEANUP_LOCK filter!(TEMP_CLEANUP) do (path, asap)
+        try
+            ispath(path) || return false
+            may_need_gc = true
+            return true
+        catch ex
+            ex isa InterruptException && rethrow()
+            return true
+        end
+    end
+    if may_need_gc
+        # this is only usually required on Sys.iswindows(), but may as well do it everywhere
+        GC.gc(true)
+    end
+    @lock TEMP_CLEANUP_LOCK temp_cleanup_purge_prelocked(true)
+    nothing
+end
+
+function __postinit__()
+    Base.atexit(temp_cleanup_purge_all)
 end
 
 const temp_prefix = "jl_"
@@ -733,10 +763,11 @@ temporary file upon completion.
 See also: [`mktempdir`](@ref).
 """
 function mktemp(fn::Function, parent::AbstractString=tempdir())
-    (tmp_path, tmp_io) = mktemp(parent, cleanup=false)
+    (tmp_path, tmp_io) = mktemp(parent)
     try
         fn(tmp_path, tmp_io)
     finally
+        temp_cleanup_forget(tmp_path)
         try
             close(tmp_io)
             ispath(tmp_path) && rm(tmp_path)
@@ -761,10 +792,11 @@ See also: [`mktemp`](@ref), [`mkdir`](@ref).
 """
 function mktempdir(fn::Function, parent::AbstractString=tempdir();
     prefix::AbstractString=temp_prefix)
-    tmpdir = mktempdir(parent; prefix=prefix, cleanup=false)
+    tmpdir = mktempdir(parent; prefix=prefix)
     try
         fn(tmpdir)
     finally
+        temp_cleanup_forget(tmpdir)
         try
             if ispath(tmpdir)
                 prepare_for_deletion(tmpdir)
diff --git a/base/initdefs.jl b/base/initdefs.jl
index debbb45428e99..59b2f59d7b263 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -367,9 +367,7 @@ end
 
 ## atexit: register exit hooks ##
 
-const atexit_hooks = Callable[
-    () -> Filesystem.temp_cleanup_purge(force=true)
-]
+const atexit_hooks = Callable[]
 const _atexit_hooks_lock = ReentrantLock()
 global _atexit_hooks_finished::Bool = false
 
@@ -413,7 +411,7 @@ function _atexit(exitcode::Cint)
     # will immediately run here.
     while true
         local f
-        Base.@lock _atexit_hooks_lock begin
+        @lock _atexit_hooks_lock begin
             # If this is the last iteration, atomically disable atexit hooks to prevent
             # someone from registering a hook that will never be run.
             # (We do this inside the loop, so that it is atomic: no one can have registered
@@ -434,7 +432,7 @@ function _atexit(exitcode::Cint)
             end
         catch ex
             showerror(stderr, ex)
-            Base.show_backtrace(stderr, catch_backtrace())
+            show_backtrace(stderr, catch_backtrace())
             println(stderr)
         end
     end
@@ -454,7 +452,7 @@ function _postoutput()
             f()
         catch ex
             showerror(stderr, ex)
-            Base.show_backtrace(stderr, catch_backtrace())
+            show_backtrace(stderr, catch_backtrace())
             println(stderr)
         end
     end
diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index 82c9ea2aba037..a685f28a2c735 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -334,10 +334,6 @@ end
 
 generate_precompile_statements()
 
-# As a last step in system image generation,
-# remove some references to build time environment for a more reproducible build.
-Base.Filesystem.temp_cleanup_purge(force=true)
-
 let stdout = Ref{IO}(stdout)
     Base.PROGRAM_FILE = ""
     Sys.BINDIR = ""
diff --git a/src/init.c b/src/init.c
index fef3e73bd2d06..893032543db82 100644
--- a/src/init.c
+++ b/src/init.c
@@ -246,25 +246,16 @@ JL_DLLEXPORT void jl_atexit_hook(int exitcode) JL_NOTSAFEPOINT_ENTER
 
     jl_task_t *ct = jl_get_current_task();
 
-    if (ct) {
-        if (exitcode == 0)
-            jl_write_compiler_output();
+    if (ct == NULL && jl_base_module) {
+        ct = container_of(jl_adopt_thread(), jl_task_t, gcstack);
+    }
+    else if (ct != NULL) {
         // we are about to start tearing everything down, so lets try not to get
         // upset by the local mess of things when we run the user's _atexit hooks
         // this also forces us into a GC-unsafe region without a safepoint
         jl_task_frame_noreturn(ct);
-    }
-
-    if (ct == NULL && jl_base_module)
-        ct = container_of(jl_adopt_thread(), jl_task_t, gcstack);
-    else if (ct != NULL)
         jl_gc_safepoint_(ct->ptls);
-
-    jl_print_gc_stats(JL_STDERR);
-    if (jl_options.code_coverage)
-        jl_write_coverage_data(jl_options.output_code_coverage);
-    if (jl_options.malloc_log)
-        jl_write_malloc_log();
+    }
 
     if (jl_base_module) {
         jl_value_t *f = jl_get_global(jl_base_module, jl_symbol("_atexit"));
@@ -290,6 +281,15 @@ JL_DLLEXPORT void jl_atexit_hook(int exitcode) JL_NOTSAFEPOINT_ENTER
         }
     }
 
+    if (ct && exitcode == 0)
+        jl_write_compiler_output();
+
+    jl_print_gc_stats(JL_STDERR);
+    if (jl_options.code_coverage)
+        jl_write_coverage_data(jl_options.output_code_coverage);
+    if (jl_options.malloc_log)
+        jl_write_malloc_log();
+
     // replace standard output streams with something that we can still print to
     // after the finalizers from base/stream.jl close the TTY
     JL_STDOUT = (uv_stream_t*) STDOUT_FILENO;
@@ -710,6 +710,7 @@ extern jl_mutex_t jl_modules_mutex;
 extern jl_mutex_t precomp_statement_out_lock;
 extern jl_mutex_t newly_inferred_mutex;
 extern jl_mutex_t global_roots_lock;
+extern jl_mutex_t profile_show_peek_cond_lock;
 
 static void restore_fp_env(void)
 {
@@ -729,6 +730,7 @@ static void init_global_mutexes(void) {
     JL_MUTEX_INIT(&global_roots_lock, "global_roots_lock");
     JL_MUTEX_INIT(&jl_codegen_lock, "jl_codegen_lock");
     JL_MUTEX_INIT(&typecache_lock, "typecache_lock");
+    JL_MUTEX_INIT(&profile_show_peek_cond_lock, "profile_show_peek_cond_lock");
 }
 
 JL_DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel)
diff --git a/src/jl_uv.c b/src/jl_uv.c
index 62dc3a628d085..8cdd8f95ba2e6 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -86,12 +86,10 @@ void jl_wait_empty_begin(void)
     }
     JL_UV_UNLOCK();
 }
-
 void jl_wait_empty_end(void)
 {
-    JL_UV_LOCK();
+    // n.b. caller must be holding jl_uv_mutex
     uv_close((uv_handle_t*)&wait_empty_worker, NULL);
-    JL_UV_UNLOCK();
 }
 
 
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 2c0c13d0bb343..dd65a1ac4981a 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -194,7 +194,6 @@ int jl_running_under_rr(int recheck) JL_NOTSAFEPOINT;
 // Returns time in nanosec
 JL_DLLEXPORT uint64_t jl_hrtime(void) JL_NOTSAFEPOINT;
 
-JL_DLLEXPORT void jl_set_peek_cond(uintptr_t);
 JL_DLLEXPORT double jl_get_profile_peek_duration(void);
 JL_DLLEXPORT void jl_set_profile_peek_duration(double);
 
diff --git a/src/partr.c b/src/partr.c
index a660f6be63de3..bc31b187f83e7 100644
--- a/src/partr.c
+++ b/src/partr.c
@@ -357,9 +357,14 @@ void jl_task_wait_empty(void)
         ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
         if (f)
             jl_apply_generic(f, NULL, 0);
+        // we are back from jl_task_get_next now
         ct->world_age = lastage;
         wait_empty = NULL;
+        // TODO: move this lock acquire-release pair to the caller, so that we ensure new work
+        // (from uv_unref objects) didn't unexpectedly get scheduled and start running behind our back
+        JL_UV_LOCK();
         jl_wait_empty_end();
+        JL_UV_UNLOCK();
     }
 }
 
diff --git a/src/signal-handling.c b/src/signal-handling.c
index 00bc9d9d8aabb..b5e7d69242266 100644
--- a/src/signal-handling.c
+++ b/src/signal-handling.c
@@ -285,21 +285,27 @@ void jl_set_profile_peek_duration(double t)
     profile_peek_duration = t;
 }
 
-uintptr_t profile_show_peek_cond_loc;
-JL_DLLEXPORT void jl_set_peek_cond(uintptr_t cond)
+jl_mutex_t profile_show_peek_cond_lock;
+static uv_async_t *profile_show_peek_cond_loc;
+JL_DLLEXPORT void jl_set_peek_cond(uv_async_t *cond)
 {
+    JL_LOCK_NOGC(&profile_show_peek_cond_lock);
     profile_show_peek_cond_loc = cond;
+    JL_UNLOCK_NOGC(&profile_show_peek_cond_lock);
 }
 
 static void jl_check_profile_autostop(void)
 {
-    if ((profile_autostop_time != -1.0) && (jl_hrtime() > profile_autostop_time)) {
+    if (profile_show_peek_cond_loc != NULL && profile_autostop_time != -1.0 && jl_hrtime() > profile_autostop_time) {
         profile_autostop_time = -1.0;
         jl_profile_stop_timer();
         jl_safe_printf("\n==============================================================\n");
         jl_safe_printf("Profile collected. A report will print at the next yield point\n");
         jl_safe_printf("==============================================================\n\n");
-        uv_async_send((uv_async_t*)profile_show_peek_cond_loc);
+        JL_LOCK_NOGC(&profile_show_peek_cond_lock);
+        if (profile_show_peek_cond_loc != NULL)
+            uv_async_send(profile_show_peek_cond_loc);
+        JL_UNLOCK_NOGC(&profile_show_peek_cond_lock);
     }
 }
 
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index 384c479b10f58..a6d883c3870c3 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -717,22 +717,24 @@ static int64_t write_dependency_list(ios_t *s, jl_array_t* worklist, jl_array_t
     size_t i, l = udeps ? jl_array_nrows(udeps) : 0;
     for (i = 0; i < l; i++) {
         jl_value_t *deptuple = jl_array_ptr_ref(udeps, i);
-        jl_value_t *abspath = jl_fieldref(deptuple, 1);
-
-        jl_value_t **replace_depot_args;
-        JL_GC_PUSHARGS(replace_depot_args, 2);
-        replace_depot_args[0] = replace_depot_func;
-        replace_depot_args[1] = abspath;
-        ct = jl_current_task;
-        size_t last_age = ct->world_age;
-        ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
-        jl_value_t *depalias = (jl_value_t*)jl_apply(replace_depot_args, 2);
-        ct->world_age = last_age;
-        JL_GC_POP();
-
-        size_t slen = jl_string_len(depalias);
+        jl_value_t *deppath = jl_fieldref(deptuple, 1);
+
+        if (replace_depot_func) {
+            jl_value_t **replace_depot_args;
+            JL_GC_PUSHARGS(replace_depot_args, 2);
+            replace_depot_args[0] = replace_depot_func;
+            replace_depot_args[1] = deppath;
+            ct = jl_current_task;
+            size_t last_age = ct->world_age;
+            ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
+            deppath = (jl_value_t*)jl_apply(replace_depot_args, 2);
+            ct->world_age = last_age;
+            JL_GC_POP();
+        }
+
+        size_t slen = jl_string_len(deppath);
         write_int32(s, slen);
-        ios_write(s, jl_string_data(depalias), slen);
+        ios_write(s, jl_string_data(deppath), slen);
         write_uint64(s, jl_unbox_uint64(jl_fieldref(deptuple, 2)));    // fsize
         write_uint32(s, jl_unbox_uint32(jl_fieldref(deptuple, 3)));    // hash
         write_float64(s, jl_unbox_float64(jl_fieldref(deptuple, 4)));  // mtime
diff --git a/stdlib/Profile/Project.toml b/stdlib/Profile/Project.toml
index 8e50b474f1cd3..ad0107ecf9404 100644
--- a/stdlib/Profile/Project.toml
+++ b/stdlib/Profile/Project.toml
@@ -2,9 +2,6 @@ name = "Profile"
 uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
 version = "1.11.0"
 
-[deps]
-Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
-
 [extras]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
diff --git a/stdlib/REPL/src/precompile.jl b/stdlib/REPL/src/precompile.jl
index a1cd746fbeb88..97c494cb331d3 100644
--- a/stdlib/REPL/src/precompile.jl
+++ b/stdlib/REPL/src/precompile.jl
@@ -205,9 +205,5 @@ end
 
 generate_precompile_statements()
 
-# As a last step in system image generation,
-# remove some references to build time environment for a more reproducible build.
-Base.Filesystem.temp_cleanup_purge(force=true)
-
 precompile(Tuple{typeof(getproperty), REPL.REPLBackend, Symbol})
 end # Precompile

From 67ec832373a581358b0d6430b35fe427818d8dd7 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 27 Oct 2023 10:09:43 -0400
Subject: [PATCH 0250/1315] restore deprecated function for Pkg tests

---
 base/file.jl | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/base/file.jl b/base/file.jl
index e46a0c34dade2..e63ed67ae249b 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -580,6 +580,9 @@ function temp_cleanup_purge_all()
     nothing
 end
 
+# deprecated internal function used by some packages
+temp_cleanup_purge(; force=false) = force ? temp_cleanup_purge_all() : @lock TEMP_CLEANUP_LOCK temp_cleanup_purge_prelocked(false)
+
 function __postinit__()
     Base.atexit(temp_cleanup_purge_all)
 end

From d8a410c8eb18f4f6cd797211ef21783cf7b2ca3a Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 1 Nov 2023 16:56:26 +0000
Subject: [PATCH 0251/1315] improve "deadlock avoidance" of unexpectedly abrubt
 exits

---
 src/signal-handling.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/signal-handling.c b/src/signal-handling.c
index b5e7d69242266..abe63ba6d2d7f 100644
--- a/src/signal-handling.c
+++ b/src/signal-handling.c
@@ -431,11 +431,18 @@ void jl_task_frame_noreturn(jl_task_t *ct) JL_NOTSAFEPOINT
         ct->gcstack = NULL;
         ct->eh = NULL;
         ct->world_age = 1;
-        ct->ptls->locks.len = 0;
+        // Force all locks to drop. Is this a good idea? Of course not. But the alternative would probably deadlock instead of crashing.
+        small_arraylist_t *locks = &ct->ptls->locks;
+        for (size_t i = locks->len; i > 0; i--)
+            jl_mutex_unlock_nogc((jl_mutex_t*)locks->items[i - 1]);
+        locks->len = 0;
         ct->ptls->in_pure_callback = 0;
         ct->ptls->in_finalizer = 0;
         ct->ptls->defer_signal = 0;
-        jl_atomic_store_release(&ct->ptls->gc_state, 0); // forcibly exit GC (if we were in it) or safe into unsafe, without the mandatory safepoint
+        // forcibly exit GC (if we were in it) or safe into unsafe, without the mandatory safepoint
+        jl_atomic_store_release(&ct->ptls->gc_state, 0);
+        // allow continuing to use a Task that should have already died--unsafe necromancy!
+        jl_atomic_store_relaxed(&ct->_state, JL_TASK_STATE_RUNNABLE);
     }
 }
 

From 0cf2bf143552c2f425150fcb2a60225c67ea042d Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Tue, 14 Nov 2023 22:58:03 +0100
Subject: [PATCH 0252/1315] Reduce compile time for generic matmatmul (#52038)

This is another attempt at improving the compile time issue with generic
matmatmul, hopefully improving runtime performance also.

@chriselrod @jishnub

There seems to be a little typo/oversight somewhere, but it shows how it
could work. Locally, this reduces benchmark times from
https://github.com/JuliaLang/julia/pull/51812#issuecomment-1780394475 by
more than 50%.

---------

Co-authored-by: Chris Elrod <elrodc@gmail.com>
---
 stdlib/LinearAlgebra/src/adjtrans.jl |  10 ++
 stdlib/LinearAlgebra/src/matmul.jl   | 256 +++++++--------------------
 stdlib/LinearAlgebra/test/matmul.jl  |  31 ++--
 test/testhelpers/Furlongs.jl         |   1 +
 4 files changed, 87 insertions(+), 211 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/adjtrans.jl b/stdlib/LinearAlgebra/src/adjtrans.jl
index c8b02f7a10a76..3df9e3e151f25 100644
--- a/stdlib/LinearAlgebra/src/adjtrans.jl
+++ b/stdlib/LinearAlgebra/src/adjtrans.jl
@@ -281,6 +281,11 @@ adjoint(A::Adjoint) = A.parent
 transpose(A::Transpose) = A.parent
 adjoint(A::Transpose{<:Real}) = A.parent
 transpose(A::Adjoint{<:Real}) = A.parent
+adjoint(A::Transpose{<:Any,<:Adjoint}) = transpose(A.parent.parent)
+transpose(A::Adjoint{<:Any,<:Transpose}) = adjoint(A.parent.parent)
+# disambiguation
+adjoint(A::Transpose{<:Real,<:Adjoint}) = transpose(A.parent.parent)
+transpose(A::Adjoint{<:Real,<:Transpose}) = A.parent
 
 # printing
 function Base.showarg(io::IO, v::Adjoint, toplevel)
@@ -395,11 +400,16 @@ map(f, avs::AdjointAbsVec...) = adjoint(map((xs...) -> adjoint(f(adjoint.(xs)...
 map(f, tvs::TransposeAbsVec...) = transpose(map((xs...) -> transpose(f(transpose.(xs)...)), parent.(tvs)...))
 quasiparentt(x) = parent(x); quasiparentt(x::Number) = x # to handle numbers in the defs below
 quasiparenta(x) = parent(x); quasiparenta(x::Number) = conj(x) # to handle numbers in the defs below
+quasiparentc(x) = parent(parent(x)); quasiparentc(x::Number) = conj(x) # to handle numbers in the defs below
 broadcast(f, avs::Union{Number,AdjointAbsVec}...) = adjoint(broadcast((xs...) -> adjoint(f(adjoint.(xs)...)), quasiparenta.(avs)...))
 broadcast(f, tvs::Union{Number,TransposeAbsVec}...) = transpose(broadcast((xs...) -> transpose(f(transpose.(xs)...)), quasiparentt.(tvs)...))
 # Hack to preserve behavior after #32122; this needs to be done with a broadcast style instead to support dotted fusion
 Broadcast.broadcast_preserving_zero_d(f, avs::Union{Number,AdjointAbsVec}...) = adjoint(broadcast((xs...) -> adjoint(f(adjoint.(xs)...)), quasiparenta.(avs)...))
 Broadcast.broadcast_preserving_zero_d(f, tvs::Union{Number,TransposeAbsVec}...) = transpose(broadcast((xs...) -> transpose(f(transpose.(xs)...)), quasiparentt.(tvs)...))
+Broadcast.broadcast_preserving_zero_d(f, tvs::Union{Number,Transpose{<:Any,<:AdjointAbsVec}}...) =
+    transpose(adjoint(broadcast((xs...) -> adjoint(transpose(f(conj.(xs)...))), quasiparentc.(tvs)...)))
+Broadcast.broadcast_preserving_zero_d(f, tvs::Union{Number,Adjoint{<:Any,<:TransposeAbsVec}}...) =
+    adjoint(transpose(broadcast((xs...) -> transpose(adjoint(f(conj.(xs)...))), quasiparentc.(tvs)...)))
 # TODO unify and allow mixed combinations with a broadcast style
 
 
diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index 018ad20e538c8..0ca0527785d61 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -337,7 +337,7 @@ julia> lmul!(F.Q, B)
 lmul!(A, B)
 
 # THE one big BLAS dispatch
-@inline function generic_matmatmul!(C::StridedMatrix{T}, tA, tB, A::StridedVecOrMat{T}, B::StridedVecOrMat{T},
+Base.@constprop :aggressive function generic_matmatmul!(C::StridedMatrix{T}, tA, tB, A::StridedVecOrMat{T}, B::StridedVecOrMat{T},
                                     _add::MulAddMul=MulAddMul()) where {T<:BlasFloat}
     if all(in(('N', 'T', 'C')), (tA, tB))
         if tA == 'T' && tB == 'N' && A === B
@@ -364,16 +364,16 @@ lmul!(A, B)
             return BLAS.hemm!('R', tB == 'H' ? 'U' : 'L', alpha, B, A, beta, C)
         end
     end
-    return _generic_matmatmul!(C, 'N', 'N', wrap(A, tA), wrap(B, tB), _add)
+    return _generic_matmatmul!(C, wrap(A, tA), wrap(B, tB), _add)
 end
 
 # Complex matrix times (transposed) real matrix. Reinterpret the first matrix to real for efficiency.
-@inline function generic_matmatmul!(C::StridedVecOrMat{Complex{T}}, tA, tB, A::StridedVecOrMat{Complex{T}}, B::StridedVecOrMat{T},
+Base.@constprop :aggressive function generic_matmatmul!(C::StridedVecOrMat{Complex{T}}, tA, tB, A::StridedVecOrMat{Complex{T}}, B::StridedVecOrMat{T},
                     _add::MulAddMul=MulAddMul()) where {T<:BlasReal}
     if all(in(('N', 'T', 'C')), (tA, tB))
         gemm_wrapper!(C, tA, tB, A, B, _add)
     else
-        _generic_matmatmul!(C, 'N', 'N', wrap(A, tA), wrap(B, tB), _add)
+        _generic_matmatmul!(C, wrap(A, tA), wrap(B, tB), _add)
     end
 end
 
@@ -563,11 +563,11 @@ function gemm_wrapper(tA::AbstractChar, tB::AbstractChar,
     if all(in(('N', 'T', 'C')), (tA, tB))
         gemm_wrapper!(C, tA, tB, A, B)
     else
-        _generic_matmatmul!(C, 'N', 'N', wrap(A, tA), wrap(B, tB), _add)
+        _generic_matmatmul!(C, wrap(A, tA), wrap(B, tB), _add)
     end
 end
 
-function gemm_wrapper!(C::StridedVecOrMat{T}, tA::AbstractChar, tB::AbstractChar,
+Base.@constprop :aggressive function gemm_wrapper!(C::StridedVecOrMat{T}, tA::AbstractChar, tB::AbstractChar,
                        A::StridedVecOrMat{T}, B::StridedVecOrMat{T},
                        _add = MulAddMul()) where {T<:BlasFloat}
     mA, nA = lapack_size(tA, A)
@@ -604,10 +604,10 @@ function gemm_wrapper!(C::StridedVecOrMat{T}, tA::AbstractChar, tB::AbstractChar
         stride(C, 2) >= size(C, 1))
         return BLAS.gemm!(tA, tB, alpha, A, B, beta, C)
     end
-    _generic_matmatmul!(C, tA, tB, A, B, _add)
+    _generic_matmatmul!(C, wrap(A, tA), wrap(B, tB), _add)
 end
 
-function gemm_wrapper!(C::StridedVecOrMat{Complex{T}}, tA::AbstractChar, tB::AbstractChar,
+Base.@constprop :aggressive function gemm_wrapper!(C::StridedVecOrMat{Complex{T}}, tA::AbstractChar, tB::AbstractChar,
                        A::StridedVecOrMat{Complex{T}}, B::StridedVecOrMat{T},
                        _add = MulAddMul()) where {T<:BlasReal}
     mA, nA = lapack_size(tA, A)
@@ -647,7 +647,7 @@ function gemm_wrapper!(C::StridedVecOrMat{Complex{T}}, tA::AbstractChar, tB::Abs
         BLAS.gemm!(tA, tB, alpha, reinterpret(T, A), B, beta, reinterpret(T, C))
         return C
     end
-    _generic_matmatmul!(C, tA, tB, A, B, _add)
+    _generic_matmatmul!(C, wrap(A, tA), wrap(B, tB), _add)
 end
 
 # blas.jl defines matmul for floats; other integer and mixed precision
@@ -764,197 +764,65 @@ end
 
 const tilebufsize = 10800  # Approximately 32k/3
 
-function generic_matmatmul!(C::AbstractVecOrMat, tA, tB, A::AbstractVecOrMat, B::AbstractVecOrMat, _add::MulAddMul)
-    mA, nA = lapack_size(tA, A)
-    mB, nB = lapack_size(tB, B)
-    mC, nC = size(C)
-
-    if iszero(_add.alpha)
-        return _rmul_or_fill!(C, _add.beta)
-    end
-    if mA == nA == mB == nB == mC == nC == 2
-        return matmul2x2!(C, tA, tB, A, B, _add)
-    end
-    if mA == nA == mB == nB == mC == nC == 3
-        return matmul3x3!(C, tA, tB, A, B, _add)
-    end
-    A, tA = tA in ('H', 'h', 'S', 's') ? (wrap(A, tA), 'N') : (A, tA)
-    B, tB = tB in ('H', 'h', 'S', 's') ? (wrap(B, tB), 'N') : (B, tB)
-    _generic_matmatmul!(C, tA, tB, A, B, _add)
-end
+Base.@constprop :aggressive generic_matmatmul!(C::AbstractVecOrMat, tA, tB, A::AbstractVecOrMat, B::AbstractVecOrMat, _add::MulAddMul) =
+    _generic_matmatmul!(C, wrap(A, tA), wrap(B, tB), _add)
 
-function _generic_matmatmul!(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S},
+@noinline function _generic_matmatmul!(C::AbstractVecOrMat{R}, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S},
                              _add::MulAddMul) where {T,S,R}
-    @assert tA in ('N', 'T', 'C') && tB in ('N', 'T', 'C')
-    require_one_based_indexing(C, A, B)
-
-    mA, nA = lapack_size(tA, A)
-    mB, nB = lapack_size(tB, B)
-    if mB != nA
-        throw(DimensionMismatch(lazy"matrix A has dimensions ($mA,$nA), matrix B has dimensions ($mB,$nB)"))
-    end
-    if size(C,1) != mA || size(C,2) != nB
-        throw(DimensionMismatch(lazy"result C has dimensions $(size(C)), needs ($mA,$nB)"))
-    end
-
-    if iszero(_add.alpha) || isempty(A) || isempty(B)
-        return _rmul_or_fill!(C, _add.beta)
-    end
-
-    tile_size = 0
-    if isbitstype(R) && isbitstype(T) && isbitstype(S) && (tA == 'N' || tB != 'N')
-        tile_size = floor(Int, sqrt(tilebufsize / max(sizeof(R), sizeof(S), sizeof(T), 1)))
-    end
-    @inbounds begin
-    if tile_size > 0
-        sz = (tile_size, tile_size)
-        Atile = Array{T}(undef, sz)
-        Btile = Array{S}(undef, sz)
-
-        z1 = zero(A[1, 1]*B[1, 1] + A[1, 1]*B[1, 1])
-        z = convert(promote_type(typeof(z1), R), z1)
-
-        if mA < tile_size && nA < tile_size && nB < tile_size
-            copy_transpose!(Atile, 1:nA, 1:mA, tA, A, 1:mA, 1:nA)
-            copyto!(Btile, 1:mB, 1:nB, tB, B, 1:mB, 1:nB)
-            for j = 1:nB
-                boff = (j-1)*tile_size
-                for i = 1:mA
-                    aoff = (i-1)*tile_size
-                    s = z
-                    for k = 1:nA
-                        s += Atile[aoff+k] * Btile[boff+k]
-                    end
-                    _modify!(_add, s, C, (i,j))
-                end
-            end
-        else
-            Ctile = Array{R}(undef, sz)
-            for jb = 1:tile_size:nB
-                jlim = min(jb+tile_size-1,nB)
-                jlen = jlim-jb+1
-                for ib = 1:tile_size:mA
-                    ilim = min(ib+tile_size-1,mA)
-                    ilen = ilim-ib+1
-                    fill!(Ctile, z)
-                    for kb = 1:tile_size:nA
-                        klim = min(kb+tile_size-1,mB)
-                        klen = klim-kb+1
-                        copy_transpose!(Atile, 1:klen, 1:ilen, tA, A, ib:ilim, kb:klim)
-                        copyto!(Btile, 1:klen, 1:jlen, tB, B, kb:klim, jb:jlim)
-                        for j=1:jlen
-                            bcoff = (j-1)*tile_size
-                            for i = 1:ilen
-                                aoff = (i-1)*tile_size
-                                s = z
-                                for k = 1:klen
-                                    s += Atile[aoff+k] * Btile[bcoff+k]
-                                end
-                                Ctile[bcoff+i] += s
-                            end
-                        end
-                    end
-                    if isone(_add.alpha) && iszero(_add.beta)
-                        copyto!(C, ib:ilim, jb:jlim, Ctile, 1:ilen, 1:jlen)
-                    else
-                        C[ib:ilim, jb:jlim] .= @views _add.(Ctile[1:ilen, 1:jlen], C[ib:ilim, jb:jlim])
-                    end
-                end
+    AxM = axes(A, 1)
+    AxK = axes(A, 2) # we use two `axes` calls in case of `AbstractVector`
+    BxK = axes(B, 1)
+    BxN = axes(B, 2)
+    CxM = axes(C, 1)
+    CxN = axes(C, 2)
+    if AxM != CxM
+        throw(DimensionMismatch(lazy"matrix A has axes ($AxM,$AxK), matrix C has axes ($CxM,$CxN)"))
+    end
+    if AxK != BxK
+        throw(DimensionMismatch(lazy"matrix A has axes ($AxM,$AxK), matrix B has axes ($BxK,$CxN)"))
+    end
+    if BxN != CxN
+        throw(DimensionMismatch(lazy"matrix B has axes ($BxK,$BxN), matrix C has axes ($CxM,$CxN)"))
+    end
+    if isbitstype(R) && sizeof(R) ≤ 16 && !(A isa Adjoint || A isa Transpose)
+        _rmul_or_fill!(C, _add.beta)
+        (iszero(_add.alpha) || isempty(A) || isempty(B)) && return C
+        @inbounds for n in BxN, k in BxK
+            Balpha = B[k,n]*_add.alpha
+            @simd for m in AxM
+                C[m,n] = muladd(A[m,k], Balpha, C[m,n])
             end
         end
+    elseif isbitstype(R) && sizeof(R) ≤ 16 && ((A isa Adjoint && B isa Adjoint) || (A isa Transpose && B isa Transpose))
+        _rmul_or_fill!(C, _add.beta)
+        (iszero(_add.alpha) || isempty(A) || isempty(B)) && return C
+        t = wrapperop(A)
+        pB = parent(B)
+        pA = parent(A)
+        tmp = similar(C, CxN)
+        ci = first(CxM)
+        ta = t(_add.alpha)
+        for i in AxM
+            mul!(tmp, pB, view(pA, :, i))
+            C[ci,:] .+= t.(ta .* tmp)
+            ci += 1
+        end
     else
-        # Multiplication for non-plain-data uses the naive algorithm
-        if tA == 'N'
-            if tB == 'N'
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(A[i, 1]*B[1, j] + A[i, 1]*B[1, j])
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += A[i, k]*B[k, j]
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
-            elseif tB == 'T'
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(A[i, 1]*transpose(B[j, 1]) + A[i, 1]*transpose(B[j, 1]))
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += A[i, k] * transpose(B[j, k])
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
-            else
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(A[i, 1]*B[j, 1]' + A[i, 1]*B[j, 1]')
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += A[i, k]*B[j, k]'
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
-            end
-        elseif tA == 'T'
-            if tB == 'N'
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(transpose(A[1, i])*B[1, j] + transpose(A[1, i])*B[1, j])
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += transpose(A[k, i]) * B[k, j]
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
-            elseif tB == 'T'
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(transpose(A[1, i])*transpose(B[j, 1]) + transpose(A[1, i])*transpose(B[j, 1]))
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += transpose(A[k, i]) * transpose(B[j, k])
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
-            else
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(transpose(A[1, i])*B[j, 1]' + transpose(A[1, i])*B[j, 1]')
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += transpose(A[k, i]) * adjoint(B[j, k])
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
-            end
-        else
-            if tB == 'N'
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(A[1, i]'*B[1, j] + A[1, i]'*B[1, j])
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += A[k, i]'B[k, j]
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
-            elseif tB == 'T'
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(A[1, i]'*transpose(B[j, 1]) + A[1, i]'*transpose(B[j, 1]))
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += adjoint(A[k, i]) * transpose(B[j, k])
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
-            else
-                for i = 1:mA, j = 1:nB
-                    z2 = zero(A[1, i]'*B[j, 1]' + A[1, i]'*B[j, 1]')
-                    Ctmp = convert(promote_type(R, typeof(z2)), z2)
-                    for k = 1:nA
-                        Ctmp += A[k, i]'B[j, k]'
-                    end
-                    _modify!(_add, Ctmp, C, (i,j))
-                end
+        if iszero(_add.alpha) || isempty(A) || isempty(B)
+            return _rmul_or_fill!(C, _add.beta)
+        end
+        a1 = first(AxK)
+        b1 = first(BxK)
+        @inbounds for i in AxM, j in BxN
+            z2 = zero(A[i, a1]*B[b1, j] + A[i, a1]*B[b1, j])
+            Ctmp = convert(promote_type(R, typeof(z2)), z2)
+            @simd for k in AxK
+                Ctmp = muladd(A[i, k], B[k, j], Ctmp)
             end
+            _modify!(_add, Ctmp, C, (i,j))
         end
     end
-    end # @inbounds
-    C
+    return C
 end
 
 
@@ -963,7 +831,7 @@ function matmul2x2(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,
     matmul2x2!(similar(B, promote_op(matprod, T, S), 2, 2), tA, tB, A, B)
 end
 
-function matmul2x2!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix,
+Base.@constprop :aggressive function matmul2x2!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix,
                     _add::MulAddMul = MulAddMul())
     require_one_based_indexing(C, A, B)
     if !(size(A) == size(B) == size(C) == (2,2))
@@ -1030,7 +898,7 @@ function matmul3x3(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,
     matmul3x3!(similar(B, promote_op(matprod, T, S), 3, 3), tA, tB, A, B)
 end
 
-function matmul3x3!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix,
+Base.@constprop :aggressive function matmul3x3!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix,
                     _add::MulAddMul = MulAddMul())
     require_one_based_indexing(C, A, B)
     if !(size(A) == size(B) == size(C) == (3,3))
diff --git a/stdlib/LinearAlgebra/test/matmul.jl b/stdlib/LinearAlgebra/test/matmul.jl
index 86606654e911a..30cc74694b3f4 100644
--- a/stdlib/LinearAlgebra/test/matmul.jl
+++ b/stdlib/LinearAlgebra/test/matmul.jl
@@ -227,7 +227,7 @@ end
     @test C == AB
     mul!(C, A, B, 2, -1)
     @test C == AB
-    LinearAlgebra._generic_matmatmul!(C, 'N', 'N', A, B, LinearAlgebra.MulAddMul(2, -1))
+    LinearAlgebra.generic_matmatmul!(C, 'N', 'N', A, B, LinearAlgebra.MulAddMul(2, -1))
     @test C == AB
 end
 
@@ -255,7 +255,7 @@ end
 
 @testset "mixed Blas-non-Blas matmul" begin
     AA = rand(-10:10, 6, 6)
-    BB = rand(Float64, 6, 6)
+    BB = ones(Float64, 6, 6)
     CC = zeros(Float64, 6, 6)
     for A in (copy(AA), view(AA, 1:6, 1:6)), B in (copy(BB), view(BB, 1:6, 1:6)), C in (copy(CC), view(CC, 1:6, 1:6))
         @test LinearAlgebra.mul!(C, A, B) == A * B
@@ -667,12 +667,9 @@ end
 import Base: *, adjoint, transpose
 import LinearAlgebra: Adjoint, Transpose
 (*)(x::RootInt, y::RootInt) = x.i * y.i
+(*)(x::RootInt, y::Integer) = x.i * y
 adjoint(x::RootInt) = x
 transpose(x::RootInt) = x
-Adjoint(x::RootInt) = x
-Transpose(x::RootInt) = x
-# TODO once Adjoint/Transpose constructors call adjoint/transpose recursively
-# rather than Adjoint/Transpose, the additional definitions should become unnecessary
 
 @test Base.promote_op(*, RootInt, RootInt) === Int
 
@@ -690,7 +687,7 @@ Transpose(x::RootInt) = x
     @test A * a == [56]
 end
 
-function test_mul(C, A, B)
+function test_mul(C, A, B, S)
     mul!(C, A, B)
     @test Array(A) * Array(B) ≈ C
     @test A * B ≈ C
@@ -699,10 +696,10 @@ function test_mul(C, A, B)
     # but consider all number types involved:
     rtol = max(rtoldefault.(real.(eltype.((C, A, B))))...)
 
-    rand!(C)
+    rand!(C, S)
     T = promote_type(eltype.((A, B))...)
-    α = rand(T)
-    β = rand(T)
+    α = T <: AbstractFloat ? rand(T) : rand(T(-10):T(10))
+    β = T <: AbstractFloat ? rand(T) : rand(T(-10):T(10))
     βArrayC = β * Array(C)
     βC = β * C
     mul!(C, A, B, α, β)
@@ -711,7 +708,7 @@ function test_mul(C, A, B)
 end
 
 @testset "mul! vs * for special types" begin
-    eltypes = [Float32, Float64, Int64]
+    eltypes = [Float32, Float64, Int64(-100):Int64(100)]
     for k in [3, 4, 10]
         T = rand(eltypes)
         bi1 = Bidiagonal(rand(T, k), rand(T, k - 1), rand([:U, :L]))
@@ -724,26 +721,26 @@ end
         specialmatrices = (bi1, bi2, tri1, tri2, stri1, stri2)
         for A in specialmatrices
             B = specialmatrices[rand(1:length(specialmatrices))]
-            test_mul(C, A, B)
+            test_mul(C, A, B, T)
         end
         for S in specialmatrices
             l = rand(1:6)
             B = randn(k, l)
             C = randn(k, l)
-            test_mul(C, S, B)
+            test_mul(C, S, B, T)
             A = randn(l, k)
             C = randn(l, k)
-            test_mul(C, A, S)
+            test_mul(C, A, S, T)
         end
     end
     for T in eltypes
         A = Bidiagonal(rand(T, 2), rand(T, 1), rand([:U, :L]))
         B = Bidiagonal(rand(T, 2), rand(T, 1), rand([:U, :L]))
         C = randn(2, 2)
-        test_mul(C, A, B)
+        test_mul(C, A, B, T)
         B = randn(2, 9)
         C = randn(2, 9)
-        test_mul(C, A, B)
+        test_mul(C, A, B, T)
     end
     let
         tri44 = Tridiagonal(randn(3), randn(4), randn(3))
@@ -871,7 +868,7 @@ end
     # Just in case dispatching on the surface API `mul!` is changed in the future,
     # let's test the function where the tiled multiplication is defined.
     fill!(C, 0)
-    LinearAlgebra._generic_matmatmul!(C, 'N', 'N', A, B, LinearAlgebra.MulAddMul(-1, 0))
+    LinearAlgebra.generic_matmatmul!(C, 'N', 'N', A, B, LinearAlgebra.MulAddMul(-1, 0))
     @test D ≈ C
 end
 
diff --git a/test/testhelpers/Furlongs.jl b/test/testhelpers/Furlongs.jl
index f63b5460c7c16..6d52260bb20fd 100644
--- a/test/testhelpers/Furlongs.jl
+++ b/test/testhelpers/Furlongs.jl
@@ -99,5 +99,6 @@ for op in (:rem, :mod)
     end
 end
 Base.sqrt(x::Furlong) = _div(sqrt(x.val), x, Val(2))
+Base.muladd(x::Furlong, y::Furlong, z::Furlong) = x*y + z
 
 end

From cd986324cc05615f86b33949915f6982fa5a18a5 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 14 Nov 2023 20:11:34 -0500
Subject: [PATCH 0253/1315] test: disable bug-report=rr-local on aarch64
 (#52172)

This always fails on CI. Refs
https://github.com/JuliaLang/julia/pull/51776
---
 test/cmdlineargs.jl | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index c1681532d26ea..fda4ce2699292 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -996,11 +996,10 @@ end
 @test readchomp(`$(Base.julia_cmd()) -e 'module Hello; export main; (@main)(ARGS) = println("hello"); end; import .Hello'`) == ""
 
 # test --bug-report=rr
-if Sys.islinux() && Sys.ARCH in (:i686, :x86_64, :aarch64) # rr is only available on these platforms
+if Sys.islinux() && Sys.ARCH in (:i686, :x86_64) # rr is only available on these platforms
     mktempdir() do temp_trace_dir
         @test success(pipeline(setenv(`$(Base.julia_cmd()) --bug-report=rr-local -e 'exit()'`,
                                       "JULIA_RR_RECORD_ARGS" => "-n --nested=ignore",
-                                      "_RR_TRACE_DIR" => temp_trace_dir);
-                               #=stdout, stderr=#))
+                                      "_RR_TRACE_DIR" => temp_trace_dir); #=stderr, stdout=#))
     end
 end

From a26e23a4cf9c43a8da0d904c2674ec8e284cf2c6 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 14 Nov 2023 20:13:40 -0500
Subject: [PATCH 0254/1315] make objectid effects total (#52119)

Avoids the need to rehash most dictionaries on reload.

System image data size increase is about 109MB -> 112MB, since there are
about 130k Arrays, 75k CodeInstances, 30k Methods, 80k TypeMapEntries,
75k MethodInstance, and 36k Core.Bindings, and other mutable objects.
---
 base/reflection.jl   | 14 +++--------
 src/builtins.c       | 59 +++++++++++++++++++++++++-------------------
 src/ccall.cpp        |  2 +-
 src/codegen.cpp      |  2 +-
 src/iddict.c         |  2 +-
 src/julia_internal.h |  2 +-
 src/staticdata.c     | 33 +++++++++++--------------
 test/core.jl         |  9 +++----
 test/precompile.jl   |  7 ++++++
 9 files changed, 67 insertions(+), 63 deletions(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index 5e32d6e68a58e..3a1a3e288f1d6 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -720,18 +720,10 @@ If `x === y` then `objectid(x) == objectid(y)`, and usually when `x !== y`, `obj
 
 See also [`hash`](@ref), [`IdDict`](@ref).
 """
-function objectid(x)
-    # objectid is foldable iff it isn't a pointer.
-    if isidentityfree(typeof(x))
-        return _foldable_objectid(x)
-    end
-    return _objectid(x)
-end
-function _foldable_objectid(@nospecialize(x))
-    @_foldable_meta
-    _objectid(x)
+function objectid(@nospecialize(x))
+    @_total_meta
+    return ccall(:jl_object_id, UInt, (Any,), x)
 end
-_objectid(@nospecialize(x)) = ccall(:jl_object_id, UInt, (Any,), x)
 
 """
     isdispatchtuple(T)
diff --git a/src/builtins.c b/src/builtins.c
index b745fed2a888d..04b45500fddaa 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -344,6 +344,9 @@ static uintptr_t type_object_id_(jl_value_t *v, jl_varidx_t *env) JL_NOTSAFEPOIN
             i++;
             pe = pe->prev;
         }
+        uintptr_t bits = jl_astaggedvalue(v)->header;
+        if (bits & GC_IN_IMAGE)
+            return ((uintptr_t*)v)[-2];
         return inthash((uintptr_t)v);
     }
     if (tv == jl_uniontype_type) {
@@ -432,50 +435,56 @@ static uintptr_t immut_id_(jl_datatype_t *dt, jl_value_t *v, uintptr_t h) JL_NOT
     return h;
 }
 
-static uintptr_t NOINLINE jl_object_id__cold(jl_datatype_t *dt, jl_value_t *v) JL_NOTSAFEPOINT
+static uintptr_t NOINLINE jl_object_id__cold(uintptr_t tv, jl_value_t *v) JL_NOTSAFEPOINT
 {
-    if (dt == jl_simplevector_type)
-        return hash_svec((jl_svec_t*)v);
-    if (dt == jl_datatype_type) {
-        jl_datatype_t *dtv = (jl_datatype_t*)v;
-        uintptr_t h = ~dtv->name->hash;
-        return bitmix(h, hash_svec(dtv->parameters));
-    }
-    if (dt == jl_string_type) {
+    jl_datatype_t *dt = (jl_datatype_t*)jl_to_typeof(tv);
+    if (dt->name->mutabl) {
+        if (dt == jl_string_type) {
 #ifdef _P64
-        return memhash_seed(jl_string_data(v), jl_string_len(v), 0xedc3b677);
+            return memhash_seed(jl_string_data(v), jl_string_len(v), 0xedc3b677);
 #else
-        return memhash32_seed(jl_string_data(v), jl_string_len(v), 0xedc3b677);
+            return memhash32_seed(jl_string_data(v), jl_string_len(v), 0xedc3b677);
 #endif
-    }
-    if (dt == jl_module_type) {
-        jl_module_t *m = (jl_module_t*)v;
-        return m->hash;
-    }
-    if (dt->name->mutabl)
+        }
+        if (dt == jl_simplevector_type)
+            return hash_svec((jl_svec_t*)v);
+        if (dt == jl_datatype_type) {
+            jl_datatype_t *dtv = (jl_datatype_t*)v;
+            uintptr_t h = ~dtv->name->hash;
+            return bitmix(h, hash_svec(dtv->parameters));
+        }
+        if (dt == jl_module_type) {
+            jl_module_t *m = (jl_module_t*)v;
+            return m->hash;
+        }
+        uintptr_t bits = jl_astaggedvalue(v)->header;
+        if (bits & GC_IN_IMAGE)
+            return ((uintptr_t*)v)[-2];
         return inthash((uintptr_t)v);
+    }
     return immut_id_(dt, v, dt->hash);
 }
 
-JL_DLLEXPORT inline uintptr_t jl_object_id_(jl_value_t *tv, jl_value_t *v) JL_NOTSAFEPOINT
+JL_DLLEXPORT inline uintptr_t jl_object_id_(uintptr_t tv, jl_value_t *v) JL_NOTSAFEPOINT
 {
-    jl_datatype_t *dt = (jl_datatype_t*)tv;
-    if (dt == jl_symbol_type)
+    if (tv == jl_symbol_tag << 4) {
         return ((jl_sym_t*)v)->hash;
-    if (dt == jl_typename_type)
-        return ((jl_typename_t*)v)->hash;
-    if (dt == jl_datatype_type) {
+    }
+    else if (tv == jl_datatype_tag << 4) {
         jl_datatype_t *dtv = (jl_datatype_t*)v;
         if (dtv->isconcretetype)
             return dtv->hash;
     }
-    return jl_object_id__cold(dt, v);
+    else if (tv == (uintptr_t)jl_typename_type) {
+        return ((jl_typename_t*)v)->hash;
+    }
+    return jl_object_id__cold(tv, v);
 }
 
 
 JL_DLLEXPORT uintptr_t jl_object_id(jl_value_t *v) JL_NOTSAFEPOINT
 {
-    return jl_object_id_(jl_typeof(v), v);
+    return jl_object_id_(jl_typetagof(v), v);
 }
 
 // eq hash table --------------------------------------------------------------
diff --git a/src/ccall.cpp b/src/ccall.cpp
index db2d73bbfcd3f..7755b14bbaf95 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1880,7 +1880,7 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
             if (!val.isghost && !val.ispointer())
                 val = value_to_pointer(ctx, val);
             Value *args[] = {
-                emit_typeof(ctx, val),
+                emit_typeof(ctx, val, false, true),
                 val.isghost ? ConstantPointerNull::get(T_pint8_derived) :
                     ctx.builder.CreateBitCast(
                         decay_derived(ctx, data_pointer(ctx, val)),
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 079038c71e481..b9c796f2b3c1a 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1165,7 +1165,7 @@ static const auto jlapplytype_func = new JuliaFunction<>{
 static const auto jl_object_id__func = new JuliaFunction<TypeFnContextAndSizeT>{
     XSTR(jl_object_id_),
     [](LLVMContext &C, Type *T_size) { return FunctionType::get(T_size,
-            {JuliaType::get_prjlvalue_ty(C), PointerType::get(getInt8Ty(C), AddressSpace::Derived)}, false); },
+            {T_size, PointerType::get(getInt8Ty(C), AddressSpace::Derived)}, false); },
     nullptr,
 };
 static const auto setjmp_func = new JuliaFunction<TypeFnContextAndTriple>{
diff --git a/src/iddict.c b/src/iddict.c
index 43ce6c7aa7377..eaa55657e2517 100644
--- a/src/iddict.c
+++ b/src/iddict.c
@@ -5,7 +5,7 @@
 // compute empirical max-probe for a given size
 #define max_probe(size) ((size) <= 1024 ? 16 : (size) >> 6)
 
-#define keyhash(k) jl_object_id_(jl_typeof(k), k)
+#define keyhash(k) jl_object_id_(jl_typetagof(k), k)
 #define h2index(hv, sz) (size_t)(((hv) & ((sz)-1)) * 2)
 
 static inline int jl_table_assign_bp(jl_genericmemory_t **pa, jl_value_t *key, jl_value_t *val);
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 2c0c13d0bb343..f0d947aea1e6f 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1370,7 +1370,7 @@ JL_DLLEXPORT int jl_stored_inline(jl_value_t *el_type);
 JL_DLLEXPORT jl_value_t *(jl_array_data_owner)(jl_array_t *a);
 JL_DLLEXPORT jl_array_t *jl_array_copy(jl_array_t *ary);
 
-JL_DLLEXPORT uintptr_t jl_object_id_(jl_value_t *tv, jl_value_t *v) JL_NOTSAFEPOINT;
+JL_DLLEXPORT uintptr_t jl_object_id_(uintptr_t tv, jl_value_t *v) JL_NOTSAFEPOINT;
 JL_DLLEXPORT void jl_set_next_task(jl_task_t *task) JL_NOTSAFEPOINT;
 
 // -- synchronization utilities -- //
diff --git a/src/staticdata.c b/src/staticdata.c
index 22571922fc4ce..bf9ad12cd28b6 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -501,8 +501,6 @@ typedef struct {
     int8_t incremental;
 } jl_serializer_state;
 
-static jl_value_t *jl_idtable_type = NULL;
-static jl_typename_t *jl_idtable_typename = NULL;
 static jl_value_t *jl_bigint_type = NULL;
 static int gmp_limb_size = 0;
 static jl_sym_t *jl_docmeta_sym = NULL;
@@ -1253,24 +1251,35 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
         assert(!(s->incremental && jl_object_in_image(v)));
         jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v);
         assert((!jl_is_datatype_singleton(t) || t->instance == v) && "detected singleton construction corruption");
+        int mutabl = t->name->mutabl;
         ios_t *f = s->s;
         if (t->smalltag) {
             if (t->layout->npointers == 0 || t == jl_string_type) {
-                if (jl_datatype_nfields(t) == 0 || t->name->mutabl == 0 || t == jl_string_type) {
+                if (jl_datatype_nfields(t) == 0 || mutabl == 0 || t == jl_string_type) {
                     f = s->const_data;
                 }
             }
         }
 
-        // realign stream to expected gc alignment (16 bytes)
+        // realign stream to expected gc alignment (16 bytes) after tag
         uintptr_t skip_header_pos = ios_pos(f) + sizeof(jl_taggedvalue_t);
+        uintptr_t object_id_expected = mutabl &&
+                 t != jl_datatype_type &&
+                 t != jl_typename_type &&
+                 t != jl_string_type &&
+                 t != jl_simplevector_type &&
+                 t != jl_module_type;
+        if (object_id_expected)
+            skip_header_pos += sizeof(size_t);
         write_padding(f, LLT_ALIGN(skip_header_pos, 16) - skip_header_pos);
 
         // write header
+        if (object_id_expected)
+            write_uint(f, jl_object_id(v));
         if (s->incremental && jl_needs_serialization(s, (jl_value_t*)t) && needs_uniquing((jl_value_t*)t))
             arraylist_push(&s->uniquing_types, (void*)(uintptr_t)(ios_pos(f)|1));
         if (f == s->const_data)
-            write_uint(s->const_data, ((uintptr_t)t->smalltag << 4) | GC_OLD_MARKED);
+            write_uint(s->const_data, ((uintptr_t)t->smalltag << 4) | GC_OLD_MARKED | GC_IN_IMAGE);
         else
             write_gctaggedfield(s, t);
         size_t reloc_offset = ios_pos(f);
@@ -1718,11 +1727,6 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                     arraylist_push(&s->fixup_objs, (void*)reloc_offset);
                 }
             }
-            else if (((jl_datatype_t*)(jl_typeof(v)))->name == jl_idtable_typename) {
-                assert(f == s->s);
-                // will need to rehash this, later (after types are fully constructed)
-                arraylist_push(&s->fixup_objs, (void*)reloc_offset);
-            }
             else if (jl_is_genericmemoryref(v)) {
                 assert(f == s->s);
                 record_memoryref(s, reloc_offset, *(jl_genericmemoryref_t*)v);
@@ -2582,8 +2586,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
             }
         }
     }
-    jl_idtable_type = jl_base_module ? jl_get_global(jl_base_module, jl_symbol("IdDict")) : NULL;
-    jl_idtable_typename = jl_base_module ? ((jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_idtable_type))->name : NULL;
     jl_bigint_type = jl_base_module ? jl_get_global(jl_base_module, jl_symbol("BigInt")) : NULL;
     if (jl_bigint_type) {
         gmp_limb_size = jl_unbox_long(jl_get_global((jl_module_t*)jl_get_global(jl_base_module, jl_symbol("GMP")),
@@ -3409,12 +3411,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
             }
         }
         else {
-            // rehash IdDict
-            //assert(((jl_datatype_t*)(jl_typeof(obj)))->name == jl_idtable_typename);
-            jl_genericmemory_t **a = (jl_genericmemory_t**)obj;
-            assert(jl_typetagis(*a, jl_memory_any_type));
-            *a = jl_idtable_rehash(*a, (*a)->length);
-            jl_gc_wb(obj, *a);
+            abort();
         }
     }
     // Now pick up the globalref binding pointer field
diff --git a/test/core.jl b/test/core.jl
index 505c5d03a6484..e9a680cd506c4 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8000,12 +8000,11 @@ for T in (Int, String, Symbol, Module)
     @test Core.Compiler.is_foldable(Base.infer_effects(hash, (Tuple{T},)))
     @test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{T,T},)))
     @test Core.Compiler.is_foldable(Base.infer_effects(hash, (Tuple{T,T},)))
+    @test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Ref{T},)))
+    @test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{Ref{T}},)))
+    @test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{Vector{T}},)))
 end
-@test !Core.Compiler.is_consistent(Base.infer_effects(objectid, (Ref{Int},)))
-@test !Core.Compiler.is_consistent(Base.infer_effects(objectid, (Tuple{Ref{Int}},)))
-# objectid for datatypes is inconsistent for types that have unbound type parameters.
-@test !Core.Compiler.is_consistent(Base.infer_effects(objectid, (DataType,)))
-@test !Core.Compiler.is_consistent(Base.infer_effects(objectid, (Tuple{Vector{Int}},)))
+@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (DataType,)))
 
 # donotdelete should not taint consistency of the containing function
 f_donotdete(x) = (Core.Compiler.donotdelete(x); 1)
diff --git a/test/precompile.jl b/test/precompile.jl
index 8fd8e0a110cbb..29ca79ef5fce3 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -288,6 +288,9 @@ precompile_test_harness(false) do dir
               a_vec_inline = Pair{Int,Any}[]
               push!(a_vec_inline, 1=>2, 3=>4)
               a_mat_inline = reshape(a_vec_inline, (1, 2))
+
+              oid_vec_int = objectid(a_vec_int)
+              oid_mat_int = objectid(a_mat_int)
           end
           """)
     # Issue #12623
@@ -371,6 +374,10 @@ precompile_test_harness(false) do dir
         @test Foo.a_mat_inline == Pair{Int,Any}[1=>2 3=>4]
         Foo.a_mat_inline[1, 2] = 5=>6
         @test Foo.a_vec_inline[2] === Pair{Int,Any}(5, 6)
+
+        @test objectid(Foo.a_vec_int) === Foo.oid_vec_int
+        @test objectid(Foo.a_mat_int) === Foo.oid_mat_int
+        @test Foo.oid_vec_int !== Foo.oid_mat_int
     end
 
     @eval begin function ccallable_test()

From 25bcc6066000a3288b6c804642b0bdb6298eb872 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 15 Nov 2023 10:38:15 +0900
Subject: [PATCH 0255/1315] tidy up the inlining algorithm (#52158)

---
 base/compiler/ssair/inlining.jl | 31 +++++++++++++------------------
 base/compiler/ssair/passes.jl   |  3 +--
 2 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 7f6514b16d6e7..12eec68938441 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -383,12 +383,13 @@ function ir_prepare_inlining!(insert_node!::Inserter, inline_target::Union{IRCod
     return SSASubstitute(mi, argexprs, spvals_ssa, linetable_offset)
 end
 
-function adjust_boundscheck!(inline_compact, idx′, stmt, boundscheck)
+function adjust_boundscheck!(inline_compact::IncrementalCompact, idx′::Int, stmt::Expr, boundscheck::Symbol)
     if boundscheck === :off
-        length(stmt.args) == 0 && push!(stmt.args, false)
+        isempty(stmt.args) && push!(stmt.args, false)
     elseif boundscheck !== :propagate
-        length(stmt.args) == 0 && push!(stmt.args, true)
+        isempty(stmt.args) && push!(stmt.args, true)
     end
+    return nothing
 end
 
 function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector{Any},
@@ -398,11 +399,8 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
 
     ssa_substitute = ir_prepare_inlining!(InsertHere(compact), compact, item.ir, item.mi, inlined_at, argexprs)
 
-    if boundscheck === :default || boundscheck === :propagate
-        if (compact.result[idx][:flag] & IR_FLAG_INBOUNDS) != 0
-            boundscheck = :off
-        end
-    end
+    boundscheck = iszero(compact.result[idx][:flag] & IR_FLAG_INBOUNDS) ? boundscheck : :off
+
     # If the iterator already moved on to the next basic block,
     # temporarily re-open in again.
     local return_value
@@ -419,7 +417,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
             inline_compact[idx′] = nothing
             insert_node! = InsertBefore(inline_compact, SSAValue(idx′))
             stmt′ = ssa_substitute!(insert_node!, inline_compact[SSAValue(idx′)], stmt′,
-                                    ssa_substitute, boundscheck)
+                                    ssa_substitute)
             if isa(stmt′, ReturnNode)
                 val = stmt′.val
                 return_value = SSAValue(idx′)
@@ -450,7 +448,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
             inline_compact[idx′] = nothing
             insert_node! = InsertBefore(inline_compact, SSAValue(idx′))
             stmt′ = ssa_substitute!(insert_node!, inline_compact[SSAValue(idx′)], stmt′,
-                                    ssa_substitute, boundscheck)
+                                    ssa_substitute)
             if isa(stmt′, ReturnNode)
                 if isdefined(stmt′, :val)
                     val = stmt′.val
@@ -659,10 +657,7 @@ function batch_inline!(ir::IRCode, todo::Vector{Pair{Int,Any}}, propagate_inboun
     end
     finish_cfg_inline!(state)
 
-    boundscheck = :default
-    if boundscheck === :default && propagate_inbounds
-        boundscheck = :propagate
-    end
+    boundscheck = propagate_inbounds ? :propagate : :default
 
     let compact = IncrementalCompact(ir, CFGTransformState!(state.new_cfg_blocks, false))
         # This needs to be a minimum and is more of a size hint
@@ -1845,9 +1840,9 @@ struct SSASubstitute
 end
 
 function ssa_substitute!(insert_node!::Inserter, subst_inst::Instruction, @nospecialize(val),
-                         ssa_substitute::SSASubstitute, boundscheck::Symbol)
+                         ssa_substitute::SSASubstitute)
     subst_inst[:line] += ssa_substitute.linetable_offset
-    return ssa_substitute_op!(insert_node!, subst_inst, val, ssa_substitute, boundscheck)
+    return ssa_substitute_op!(insert_node!, subst_inst, val, ssa_substitute)
 end
 
 function insert_spval!(insert_node!::Inserter, spvals_ssa::SSAValue, spidx::Int, do_isdefined::Bool)
@@ -1864,7 +1859,7 @@ function insert_spval!(insert_node!::Inserter, spvals_ssa::SSAValue, spidx::Int,
 end
 
 function ssa_substitute_op!(insert_node!::Inserter, subst_inst::Instruction, @nospecialize(val),
-                            ssa_substitute::SSASubstitute, boundscheck::Symbol)
+                            ssa_substitute::SSASubstitute)
     if isa(val, Argument)
         return ssa_substitute.arg_replacements[val.n]
     end
@@ -1920,7 +1915,7 @@ function ssa_substitute_op!(insert_node!::Inserter, subst_inst::Instruction, @no
     isa(val, Union{SSAValue, NewSSAValue}) && return val # avoid infinite loop
     urs = userefs(val)
     for op in urs
-        op[] = ssa_substitute_op!(insert_node!, subst_inst, op[], ssa_substitute, boundscheck)
+        op[] = ssa_substitute_op!(insert_node!, subst_inst, op[], ssa_substitute)
     end
     return urs[]
 end
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index c6ae1a8e399d8..85f704e9a076d 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1259,8 +1259,7 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
         stmt′ = ssamap(stmt′) do ssa::SSAValue
             ssa_rename[ssa.id]
         end
-        stmt′ = ssa_substitute_op!(InsertBefore(ir, SSAValue(idx)), inst, stmt′,
-                                   ssa_substitute, :default)
+        stmt′ = ssa_substitute_op!(InsertBefore(ir, SSAValue(idx)), inst, stmt′, ssa_substitute)
         ssa_rename[idx′] = insert_node!(ir, idx,
             NewInstruction(inst; stmt=stmt′, line=inst[:line]+ssa_substitute.linetable_offset),
             attach_after)

From eaef647957ca5e085eea299cfa9f699c6afe6d8f Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 14 Nov 2023 21:42:19 -0500
Subject: [PATCH 0256/1315] Make c func `abspath` consistent on Windows. Fix
 tracking path conversion. (#52140)

Explanation for the `GetFullPathName` behavior
https://developercommunity.visualstudio.com/t/GetFullPath-fails-if-given-empty-string/483359#T-N486167
---
 src/init.c          | 11 ++++++++++-
 test/cmdlineargs.jl | 39 ++++++++++++++++++++++++++++++++++++++-
 2 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/src/init.c b/src/init.c
index 893032543db82..3e4bbf4e077bc 100644
--- a/src/init.c
+++ b/src/init.c
@@ -575,6 +575,14 @@ static char *abspath(const char *in, int nprefix)
         }
     }
 #else
+    // GetFullPathName intentionally errors if given an empty string so manually insert `.` to invoke cwd
+    char *in2 = (char*)malloc_s(JL_PATH_MAX);
+    if (strlen(in) - nprefix == 0) {
+        memcpy(in2, in, nprefix);
+        in2[nprefix] = '.';
+        in2[nprefix+1] = '\0';
+        in = in2;
+    }
     DWORD n = GetFullPathName(in + nprefix, 0, NULL, NULL);
     if (n <= 0) {
         jl_error("fatal error: jl_options.image_file path too long or GetFullPathName failed");
@@ -585,6 +593,7 @@ static char *abspath(const char *in, int nprefix)
         jl_error("fatal error: jl_options.image_file path too long or GetFullPathName failed");
     }
     memcpy(out, in, nprefix);
+    free(in2);
 #endif
     return out;
 }
@@ -680,7 +689,7 @@ static void jl_resolve_sysimg_location(JL_IMAGE_SEARCH rel)
     if (jl_options.output_code_coverage)
         jl_options.output_code_coverage = absformat(jl_options.output_code_coverage);
     if (jl_options.tracked_path)
-        jl_options.tracked_path = absformat(jl_options.tracked_path);
+        jl_options.tracked_path = abspath(jl_options.tracked_path, 0);
 
     const char **cmdp = jl_options.cmds;
     if (cmdp) {
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index fda4ce2699292..26cee030f9110 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -473,10 +473,47 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         @test occursin(expected, got) || (expected, got)
         @test_broken occursin(expected_good, got)
 
+        # Ask for coverage in current directory
+        tdir = dirname(realpath(inputfile))
+        cd(tdir) do
+            # there may be atrailing separator here so use rstrip
+            @test readchomp(`$exename -E "(Base.JLOptions().code_coverage, rstrip(unsafe_string(Base.JLOptions().tracked_path), '/'))" -L $inputfile
+                --code-coverage=$covfile --code-coverage=@`) == "(3, $(repr(tdir)))"
+        end
+        @test isfile(covfile)
+        got = read(covfile, String)
+        rm(covfile)
+        @test occursin(expected, got) || (expected, got)
+        @test_broken occursin(expected_good, got)
+
+        # Ask for coverage in relative directory
+        tdir = dirname(realpath(inputfile))
+        cd(dirname(tdir)) do
+            @test readchomp(`$exename -E "(Base.JLOptions().code_coverage, unsafe_string(Base.JLOptions().tracked_path))" -L $inputfile
+                --code-coverage=$covfile --code-coverage=@testhelpers`) == "(3, $(repr(tdir)))"
+        end
+        @test isfile(covfile)
+        got = read(covfile, String)
+        rm(covfile)
+        @test occursin(expected, got) || (expected, got)
+        @test_broken occursin(expected_good, got)
+
+        # Ask for coverage in relative directory with dot-dot notation
+        tdir = dirname(realpath(inputfile))
+        cd(tdir) do
+            @test readchomp(`$exename -E "(Base.JLOptions().code_coverage, unsafe_string(Base.JLOptions().tracked_path))" -L $inputfile
+                --code-coverage=$covfile --code-coverage=@../testhelpers`) == "(3, $(repr(tdir)))"
+        end
+        @test isfile(covfile)
+        got = read(covfile, String)
+        rm(covfile)
+        @test occursin(expected, got) || (expected, got)
+        @test_broken occursin(expected_good, got)
+
         # Ask for coverage in a different directory
         tdir = mktempdir() # a dir that contains no code
         @test readchomp(`$exename -E "(Base.JLOptions().code_coverage, unsafe_string(Base.JLOptions().tracked_path))" -L $inputfile
-            --code-coverage=$covfile --code-coverage=@$tdir`) == "(3, $(repr(tdir)))"
+            --code-coverage=$covfile --code-coverage=@$tdir`) == "(3, $(repr(realpath(tdir))))"
         @test isfile(covfile)
         got = read(covfile, String)
         @test isempty(got)

From 5edcdc5a234fa69a65f5e2b8d85ac51cfb37a653 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Wed, 15 Nov 2023 14:15:16 -0500
Subject: [PATCH 0257/1315] [REPL] fix computation of startpos for path
 completions (#52009)

Fixes https://github.com/JuliaLang/julia/issues/51985

Ensure that the REPL completions escape and unescape text correctly,
using the correct functions, and accounting for exactly what the user
has currently typed.

The old broken method is left around for Pkg, since it has an
over-reliance on it returning incorrect answers. Once Pkg is fixed, we
can delete that code.

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/shell.jl                       |  24 ++-
 stdlib/REPL/src/REPLCompletions.jl  | 266 +++++++++++++++++++---------
 stdlib/REPL/test/replcompletions.jl |  58 +++---
 test/spawn.jl                       |  16 +-
 4 files changed, 246 insertions(+), 118 deletions(-)

diff --git a/base/shell.jl b/base/shell.jl
index 5bfd11fb46d29..48214418bdee5 100644
--- a/base/shell.jl
+++ b/base/shell.jl
@@ -18,12 +18,11 @@ end
 
 function shell_parse(str::AbstractString, interpolate::Bool=true;
                      special::AbstractString="", filename="none")
-    s = SubString(str, firstindex(str))
+    last_arg = firstindex(str) # N.B.: This is used by REPLCompletions
+    s = SubString(str, last_arg)
     s = rstrip_shell(lstrip(s))
 
-    # N.B.: This is used by REPLCompletions
-    last_parse = 0:-1
-    isempty(s) && return interpolate ? (Expr(:tuple,:()),last_parse) : ([],last_parse)
+    isempty(s) && return interpolate ? (Expr(:tuple,:()), last_arg) : ([], last_arg)
 
     in_single_quotes = false
     in_double_quotes = false
@@ -32,6 +31,7 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
     arg = []
     i = firstindex(s)
     st = Iterators.Stateful(pairs(s))
+    update_last_arg = false # true after spaces or interpolate
 
     function push_nonempty!(list, x)
         if !isa(x,AbstractString) || !isempty(x)
@@ -54,6 +54,7 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
     for (j, c) in st
         j, c = j::Int, c::C
         if !in_single_quotes && !in_double_quotes && isspace(c)
+            update_last_arg = true
             i = consume_upto!(arg, s, i, j)
             append_2to1!(args, arg)
             while !isempty(st)
@@ -77,12 +78,17 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
                 # use parseatom instead of parse to respect filename (#28188)
                 ex, j = Meta.parseatom(s, stpos, filename=filename)
             end
-            last_parse = (stpos:prevind(s, j)) .+ s.offset
-            push_nonempty!(arg, ex)
+            last_arg = stpos + s.offset
+            update_last_arg = true
+            push!(arg, ex)
             s = SubString(s, j)
             Iterators.reset!(st, pairs(s))
             i = firstindex(s)
         else
+            if update_last_arg
+                last_arg = i + s.offset
+                update_last_arg = false
+            end
             if !in_double_quotes && c == '\''
                 in_single_quotes = !in_single_quotes
                 i = consume_upto!(arg, s, i, j)
@@ -124,14 +130,14 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
     push_nonempty!(arg, s[i:end])
     append_2to1!(args, arg)
 
-    interpolate || return args, last_parse
+    interpolate || return args, last_arg
 
     # construct an expression
     ex = Expr(:tuple)
     for arg in args
         push!(ex.args, Expr(:tuple, arg...))
     end
-    return ex, last_parse
+    return ex, last_arg
 end
 
 function shell_split(s::AbstractString)
@@ -216,7 +222,7 @@ function print_shell_escaped_posixly(io::IO, args::AbstractString...)
         function isword(c::AbstractChar)
             if '0' <= c <= '9' || 'a' <= c <= 'z' || 'A' <= c <= 'Z'
                 # word characters
-            elseif c == '_' || c == '/' || c == '+' || c == '-'
+            elseif c == '_' || c == '/' || c == '+' || c == '-' || c == '.'
                 # other common characters
             elseif c == '\''
                 have_single = true
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index f7d248464f3c9..c89cff0db38b3 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -258,8 +258,21 @@ const sorted_keyvals = ["false", "true"]
 
 complete_keyval(s::Union{String,SubString{String}}) = complete_from_list(KeyvalCompletion, sorted_keyvals, s)
 
-function complete_path(path::AbstractString, pos::Int;
-                       use_envpath=false, shell_escape=false,
+function do_raw_escape(s)
+    # escape_raw_string with delim='`' and ignoring the rule for the ending \
+    return replace(s, r"(\\+)`" => s"\1\\`")
+end
+function do_shell_escape(s)
+    return Base.shell_escape_posixly(s)
+end
+function do_string_escape(s)
+    return escape_string(s, ('\"','$'))
+end
+
+function complete_path(path::AbstractString;
+                       use_envpath=false,
+                       shell_escape=false,
+                       raw_escape=false,
                        string_escape=false)
     @assert !(shell_escape && string_escape)
     if Base.Sys.isunix() && occursin(r"^~(?:/|$)", path)
@@ -272,50 +285,49 @@ function complete_path(path::AbstractString, pos::Int;
     else
         dir, prefix = splitdir(path)
     end
-    local files
-    try
+    files = try
         if isempty(dir)
-            files = readdir()
+            readdir()
         elseif isdir(dir)
-            files = readdir(dir)
+            readdir(dir)
         else
-            return Completion[], 0:-1, false
+            return Completion[], dir, false
         end
-    catch
-        return Completion[], 0:-1, false
+    catch ex
+        ex isa Base.IOError || rethrow()
+        return Completion[], dir, false
     end
 
     matches = Set{String}()
     for file in files
         if startswith(file, prefix)
             p = joinpath(dir, file)
-            is_dir = try isdir(p) catch; false end
-            push!(matches, is_dir ? joinpath(file, "") : file)
+            is_dir = try isdir(p) catch ex; ex isa Base.IOError ? false : rethrow() end
+            push!(matches, is_dir ? file * "/" : file)
         end
     end
 
-    if use_envpath && length(dir) == 0
+    if use_envpath && isempty(dir)
         # Look for files in PATH as well
-        local pathdirs = split(ENV["PATH"], @static Sys.iswindows() ? ";" : ":")
+        pathdirs = split(ENV["PATH"], @static Sys.iswindows() ? ";" : ":")
 
         for pathdir in pathdirs
-            local actualpath
-            try
-                actualpath = realpath(pathdir)
-            catch
+            actualpath = try
+                realpath(pathdir)
+            catch ex
+                ex isa Base.IOError || rethrow()
                 # Bash doesn't expect every folder in PATH to exist, so neither shall we
                 continue
             end
 
-            if actualpath != pathdir && in(actualpath,pathdirs)
+            if actualpath != pathdir && in(actualpath, pathdirs)
                 # Remove paths which (after resolving links) are in the env path twice.
                 # Many distros eg. point /bin to /usr/bin but have both in the env path.
                 continue
             end
 
-            local filesinpath
-            try
-                filesinpath = readdir(pathdir)
+            filesinpath = try
+                readdir(pathdir)
             catch e
                 # Bash allows dirs in PATH that can't be read, so we should as well.
                 if isa(e, Base.IOError) || isa(e, Base.ArgumentError)
@@ -347,18 +359,38 @@ function complete_path(path::AbstractString, pos::Int;
         end
     end
 
-    function do_escape(s)
-        return shell_escape ? replace(s, r"(\s|\\)" => s"\\\0") :
-               string_escape ? escape_string(s, ('\"','$')) :
-               s
-    end
+    matches = ((shell_escape ? do_shell_escape(s) : string_escape ? do_string_escape(s) : s) for s in matches)
+    matches = ((raw_escape ? do_raw_escape(s) : s) for s in matches)
+    matches = Completion[PathCompletion(s) for s in matches]
+    return matches, dir, !isempty(matches)
+end
 
-    matchList = Completion[PathCompletion(do_escape(s)) for s in matches]
-    startpos = pos - lastindex(do_escape(prefix)) + 1
-    # The pos - lastindex(prefix) + 1 is correct due to `lastindex(prefix)-lastindex(prefix)==0`,
-    # hence we need to add one to get the first index. This is also correct when considering
-    # pos, because pos is the `lastindex` a larger string which `endswith(path)==true`.
-    return matchList, startpos:pos, !isempty(matchList)
+function complete_path(path::AbstractString,
+                       pos::Int;
+                       use_envpath=false,
+                       shell_escape=false,
+                       string_escape=false)
+    ## TODO: enable this depwarn once Pkg is fixed
+    #Base.depwarn("complete_path with pos argument is deprecated because the return value [2] is incorrect to use", :complete_path)
+    paths, dir, success = complete_path(path; use_envpath, shell_escape, string_escape)
+    if Base.Sys.isunix() && occursin(r"^~(?:/|$)", path)
+        # if the path is just "~", don't consider the expanded username as a prefix
+        if path == "~"
+            dir, prefix = homedir(), ""
+        else
+            dir, prefix = splitdir(homedir() * path[2:end])
+        end
+    else
+        dir, prefix = splitdir(path)
+    end
+    startpos = pos - lastindex(prefix) + 1
+    Sys.iswindows() && map!(paths, paths) do c::PathCompletion
+        # emulation for unnecessarily complicated return value, since / is a
+        # perfectly acceptable path character which does not require quoting
+        # but is required by Pkg's awkward parser handling
+        return endswith(c.path, "/") ? PathCompletion(chop(c.path) * "\\\\") : c
+    end
+    return paths, startpos:pos, success
 end
 
 function complete_expanduser(path::AbstractString, r)
@@ -838,10 +870,11 @@ function afterusing(string::String, startpos::Int)
     return occursin(r"^\b(using|import)\s*((\w+[.])*\w+\s*,\s*)*$", str[fr:end])
 end
 
-function close_path_completion(str, startpos, r, paths, pos)
+function close_path_completion(dir, paths, str, pos)
     length(paths) == 1 || return false  # Only close if there's a single choice...
-    _path = str[startpos:prevind(str, first(r))] * (paths[1]::PathCompletion).path
-    path = expanduser(unescape_string(replace(_path, "\\\$"=>"\$", "\\\""=>"\"")))
+    path = (paths[1]::PathCompletion).path
+    path = unescape_string(replace(path, "\\\$"=>"\$"))
+    path = joinpath(dir, path)
     # ...except if it's a directory...
     try
         isdir(path)
@@ -1136,42 +1169,80 @@ function completions(string::String, pos::Int, context_module::Module=Main, shif
         return complete_identifiers!(Completion[], ffunc, context_module, string,
             string[startpos:pos], pos, dotpos, startpos)
     elseif inc_tag === :cmd
-        m = match(r"[\t\n\r\"`><=*?|]| (?!\\)", reverse(partial))
-        startpos = nextind(partial, reverseind(partial, m.offset))
-        r = startpos:pos
-
-        # This expansion with "\\ "=>' ' replacement and shell_escape=true
-        # assumes the path isn't further quoted within the cmd backticks.
-        expanded = complete_expanduser(replace(string[r], r"\\ " => " "), r)
-        expanded[3] && return expanded  # If user expansion available, return it
-
-        paths, r, success = complete_path(replace(string[r], r"\\ " => " "), pos,
-                                          shell_escape=true)
-
-        return sort!(paths, by=p->p.path), r, success
+        # TODO: should this call shell_completions instead of partially reimplementing it?
+        let m = match(r"[\t\n\r\"`><=*?|]| (?!\\)", reverse(partial)) # fuzzy shell_parse in reverse
+            startpos = nextind(partial, reverseind(partial, m.offset))
+            r = startpos:pos
+            scs::String = string[r]
+
+            expanded = complete_expanduser(scs, r)
+            expanded[3] && return expanded  # If user expansion available, return it
+
+            path::String = replace(scs, r"(\\+)\g1(\\?)`" => "\1\2`") # fuzzy unescape_raw_string: match an even number of \ before ` and replace with half as many
+            # This expansion with "\\ "=>' ' replacement and shell_escape=true
+            # assumes the path isn't further quoted within the cmd backticks.
+            path = replace(path, r"\\ " => " ", r"\$" => "\$") # fuzzy shell_parse (reversed by shell_escape_posixly)
+            paths, dir, success = complete_path(path, shell_escape=true, raw_escape=true)
+
+            if success && !isempty(dir)
+                let dir = do_raw_escape(do_shell_escape(dir))
+                    # if escaping of dir matches scs prefix, remove that from the completions
+                    # otherwise make it the whole completion
+                    if endswith(dir, "/") && startswith(scs, dir)
+                        r = (startpos + sizeof(dir)):pos
+                    elseif startswith(scs, dir * "/")
+                        r = nextind(string, startpos + sizeof(dir)):pos
+                    else
+                        map!(paths, paths) do c::PathCompletion
+                            return PathCompletion(dir * "/" * c.path)
+                        end
+                    end
+                end
+            end
+            return sort!(paths, by=p->p.path), r, success
+        end
     elseif inc_tag === :string
         # Find first non-escaped quote
-        m = match(r"\"(?!\\)", reverse(partial))
-        startpos = nextind(partial, reverseind(partial, m.offset))
-        r = startpos:pos
+        let m = match(r"\"(?!\\)", reverse(partial))
+            startpos = nextind(partial, reverseind(partial, m.offset))
+            r = startpos:pos
+            scs::String = string[r]
+
+            expanded = complete_expanduser(scs, r)
+            expanded[3] && return expanded  # If user expansion available, return it
+
+            path = try
+                unescape_string(replace(scs, "\\\$"=>"\$"))
+            catch ex
+                ex isa ArgumentError || rethrow()
+                nothing
+            end
+            if !isnothing(path)
+                paths, dir, success = complete_path(path::String, string_escape=true)
 
-        expanded = complete_expanduser(string[r], r)
-        expanded[3] && return expanded  # If user expansion available, return it
+                if close_path_completion(dir, paths, path, pos)
+                    paths[1] = PathCompletion((paths[1]::PathCompletion).path * "\"")
+                end
 
-        path_prefix = try
-            unescape_string(replace(string[r], "\\\$"=>"\$", "\\\""=>"\""))
-        catch
-            nothing
-        end
-        if !isnothing(path_prefix)
-            paths, r, success = complete_path(path_prefix, pos, string_escape=true)
+                if success && !isempty(dir)
+                    let dir = do_string_escape(dir)
+                        # if escaping of dir matches scs prefix, remove that from the completions
+                        # otherwise make it the whole completion
+                        if endswith(dir, "/") && startswith(scs, dir)
+                            r = (startpos + sizeof(dir)):pos
+                        elseif startswith(scs, dir * "/")
+                            r = nextind(string, startpos + sizeof(dir)):pos
+                        else
+                            map!(paths, paths) do c::PathCompletion
+                                return PathCompletion(dir * "/" * c.path)
+                            end
+                        end
+                    end
+                end
 
-            if close_path_completion(string, startpos, r, paths, pos)
-                paths[1] = PathCompletion((paths[1]::PathCompletion).path * "\"")
+                # Fallthrough allowed so that Latex symbols can be completed in strings
+                success && return sort!(paths, by=p->p.path), r, success
             end
-
-            # Fallthrough allowed so that Latex symbols can be completed in strings
-            success && return sort!(paths, by=p->p.path), r, success
         end
     end
 
@@ -1257,35 +1328,58 @@ end
 function shell_completions(string, pos)
     # First parse everything up to the current position
     scs = string[1:pos]
-    local args, last_parse
-    try
-        args, last_parse = Base.shell_parse(scs, true)::Tuple{Expr,UnitRange{Int}}
-    catch
+    args, last_arg_start = try
+        Base.shell_parse(scs, true)::Tuple{Expr,Int}
+    catch ex
+        ex isa ArgumentError || ex isa ErrorException || rethrow()
         return Completion[], 0:-1, false
     end
     ex = args.args[end]::Expr
     # Now look at the last thing we parsed
     isempty(ex.args) && return Completion[], 0:-1, false
-    arg = ex.args[end]
-    if all(s -> isa(s, AbstractString), ex.args)
-        arg = arg::AbstractString
-        # Treat this as a path
-
-        # As Base.shell_parse throws away trailing spaces (unless they are escaped),
-        # we need to special case here.
-        # If the last char was a space, but shell_parse ignored it search on "".
-        ignore_last_word = arg != " " && scs[end] == ' '
-        prefix = ignore_last_word ? "" : join(ex.args)
+    lastarg = ex.args[end]
+    # As Base.shell_parse throws away trailing spaces (unless they are escaped),
+    # we need to special case here.
+    # If the last char was a space, but shell_parse ignored it search on "".
+    if isexpr(lastarg, :incomplete) || isexpr(lastarg, :error)
+        partial = string[last_arg_start:pos]
+        ret, range = completions(partial, lastindex(partial))
+        range = range .+ (last_arg_start - 1)
+        return ret, range, true
+    elseif endswith(scs, ' ') && !endswith(scs, "\\ ")
+        r = pos+1:pos
+        paths, dir, success = complete_path("", use_envpath=false, shell_escape=true)
+        return paths, r, success
+    elseif all(arg -> arg isa AbstractString, ex.args)
+        # Join these and treat this as a path
+        path::String = join(ex.args)
+        r = last_arg_start:pos
 
         # Also try looking into the env path if the user wants to complete the first argument
-        use_envpath = !ignore_last_word && length(args.args) < 2
+        use_envpath = length(args.args) < 2
 
-        return complete_path(prefix, pos, use_envpath=use_envpath, shell_escape=true)
-    elseif isexpr(arg, :incomplete) || isexpr(arg, :error)
-        partial = scs[last_parse]
-        ret, range = completions(partial, lastindex(partial))
-        range = range .+ (first(last_parse) - 1)
-        return ret, range, true
+        # TODO: call complete_expanduser here?
+
+        paths, dir, success = complete_path(path, use_envpath=use_envpath, shell_escape=true)
+
+        if success && !isempty(dir)
+            let dir = do_shell_escape(dir)
+                # if escaping of dir matches scs prefix, remove that from the completions
+                # otherwise make it the whole completion
+                partial = string[last_arg_start:pos]
+                if endswith(dir, "/") && startswith(partial, dir)
+                    r = (last_arg_start + sizeof(dir)):pos
+                elseif startswith(partial, dir * "/")
+                    r = nextind(string, last_arg_start + sizeof(dir)):pos
+                else
+                    map!(paths, paths) do c::PathCompletion
+                        return PathCompletion(dir * "/" * c.path)
+                    end
+                end
+            end
+        end
+
+        return paths, r, success
     end
     return Completion[], 0:-1, false
 end
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 4e7f8b2becc3c..9b1effced05e3 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -327,7 +327,7 @@ end
 let s = "\\alpha"
     c, r = test_bslashcomplete(s)
     @test c[1] == "α"
-    @test r == 1:length(s)
+    @test r == 1:lastindex(s)
     @test length(c) == 1
 end
 
@@ -1043,7 +1043,7 @@ let s, c, r
     s = "@show \"/dev/nul\""
     c,r = completions(s, 15)
     c = map(completion_text, c)
-    @test "null" in c
+    @test "null\"" in c
     @test r == 13:15
     @test s[r] == "nul"
 
@@ -1067,8 +1067,8 @@ let s, c, r
     if !isdir(joinpath(s, "tmp"))
         c,r = test_scomplete(s)
         @test !("tmp/" in c)
-        @test r === length(s) + 1:0
-        @test s[r] == ""
+        @test !("$s/tmp/" in c)
+        @test r === (sizeof(s) + 1):sizeof(s)
     end
 
     s = "cd \$(Iter"
@@ -1093,7 +1093,7 @@ let s, c, r
         touch(file)
         s = string(tempdir(), "/repl\\ ")
         c,r = test_scomplete(s)
-        @test ["repl\\ completions"] == c
+        @test ["'repl completions'"] == c
         @test s[r] == "repl\\ "
         rm(file)
     end
@@ -1194,7 +1194,7 @@ let current_dir, forbidden
             catch e
                 e isa Base.IOError && occursin("ELOOP", e.msg)
             end
-            c, r = test_complete("\""*escape_string(joinpath(path, "selfsym")))
+            c, r = test_complete("\"$(escape_string(path))/selfsym")
             @test c == ["selfsymlink"]
         end
     end
@@ -1231,20 +1231,20 @@ mktempdir() do path
         dir_space = replace(space_folder, " " => "\\ ")
         s = Sys.iswindows() ? "cd $dir_space\\\\space" : "cd $dir_space/space"
         c, r = test_scomplete(s)
-        @test s[r] == "space"
-        @test "space\\ .file" in c
+        @test s[r] == (Sys.iswindows() ? "$dir_space\\\\space" : "$dir_space/space")
+        @test "'$space_folder'/'space .file'" in c
         # Also use shell escape rules within cmd backticks
         s = "`$s"
         c, r = test_scomplete(s)
-        @test s[r] == "space"
-        @test "space\\ .file" in c
+        @test s[r] == (Sys.iswindows() ? "$dir_space\\\\space" : "$dir_space/space")
+        @test "'$space_folder'/'space .file'" in c
 
         # escape string according to Julia escaping rules
-        julia_esc(str) = escape_string(str, ('\"','$'))
+        julia_esc(str) = REPL.REPLCompletions.do_string_escape(str)
 
         # For normal strings the string should be properly escaped according to
         # the usual rules for Julia strings.
-        s = "cd(\"" * julia_esc(joinpath(path, space_folder, "space"))
+        s = "cd(\"" * julia_esc(joinpath(path, space_folder) * "/space")
         c, r = test_complete(s)
         @test s[r] == "space"
         @test "space .file\"" in c
@@ -1253,7 +1253,7 @@ mktempdir() do path
         # which needs to be escaped in Julia strings (on unix we could do this
         # test with all sorts of special chars)
         touch(joinpath(space_folder, "needs_escape\$.file"))
-        escpath = julia_esc(joinpath(path, space_folder, "needs_escape\$"))
+        escpath = julia_esc(joinpath(path, space_folder) * "/needs_escape\$")
         s = "cd(\"$escpath"
         c, r = test_complete(s)
         @test s[r] == "needs_escape\\\$"
@@ -1290,12 +1290,12 @@ mktempdir() do path
                     # in shell commands the shell path completion cannot complete
                     # paths with these characters
                     c, r, res = test_scomplete(test_dir)
-                    @test c[1] == test_dir*(Sys.iswindows() ? "\\\\" : "/")
+                    @test c[1] == "'$test_dir/'"
                     @test res
                 end
                 escdir = julia_esc(test_dir)
                 c, r, res = test_complete("\""*escdir)
-                @test c[1] == escdir*(Sys.iswindows() ? "\\\\" : "/")
+                @test c[1] == escdir * "/"
                 @test res
             finally
                 rm(joinpath(path, test_dir), recursive=true)
@@ -1331,27 +1331,43 @@ if Sys.iswindows()
     cd(path) do
         s = "cd ..\\\\"
         c,r = test_scomplete(s)
-        @test r == length(s)+1:length(s)
-        @test temp_name * "\\\\" in c
+        @test r == lastindex(s)-3:lastindex(s)
+        @test "../$temp_name/" in c
+
+        s = "cd ../"
+        c,r = test_scomplete(s)
+        @test r == lastindex(s)+1:lastindex(s)
+        @test "$temp_name/" in c
 
         s = "ls $(file[1:2])"
         c,r = test_scomplete(s)
-        @test r == length(s)-1:length(s)
+        @test r == lastindex(s)-1:lastindex(s)
         @test file in c
 
         s = "cd(\"..\\\\"
         c,r = test_complete(s)
-        @test r == length(s)+1:length(s)
-        @test temp_name * "\\\\" in c
+        @test r == lastindex(s)-3:lastindex(s)
+        @test "../$temp_name/" in c
+
+        s = "cd(\"../"
+        c,r = test_complete(s)
+        @test r == lastindex(s)+1:lastindex(s)
+        @test "$temp_name/" in c
 
         s = "cd(\"$(file[1:2])"
         c,r = test_complete(s)
-        @test r == length(s) - 1:length(s)
+        @test r == lastindex(s) - 1:lastindex(s)
         @test (length(c) > 1 && file in c) || (["$file\""] == c)
     end
     rm(tmp)
 end
 
+# issue 51985
+let s = "`\\"
+    c,r = test_scomplete(s)
+    @test r == lastindex(s)+1:lastindex(s)
+end
+
 # auto completions of true and false... issue #14101
 let s = "tru"
     c, r, res = test_complete(s)
diff --git a/test/spawn.jl b/test/spawn.jl
index 3fdfa794ff39e..1fab652199ee0 100644
--- a/test/spawn.jl
+++ b/test/spawn.jl
@@ -660,9 +660,21 @@ let p = run(`$sleepcmd 100`, wait=false)
     kill(p)
 end
 
-# Second argument of shell_parse
+# Second return of shell_parse
 let s = "   \$abc   "
-    @test s[Base.shell_parse(s)[2]] == "abc"
+    @test Base.shell_parse(s)[2] === findfirst('a', s)
+    s = "abc def"
+    @test Base.shell_parse(s)[2] === findfirst('d', s)
+    s = "abc 'de'f\"\"g"
+    @test Base.shell_parse(s)[2] === findfirst('\'', s)
+    s = "abc \$x'de'f\"\"g"
+    @test Base.shell_parse(s)[2] === findfirst('\'', s)
+    s = "abc def\$x'g'"
+    @test Base.shell_parse(s)[2] === findfirst('\'', s)
+    s = "abc def\$x "
+    @test Base.shell_parse(s)[2] === findfirst('x', s)
+    s = "abc \$(d)ef\$(x "
+    @test Base.shell_parse(s)[2] === findfirst('x', s) - 1
 end
 
 # Logging macros should not output to finalized streams (#26687)

From 221f074fff180aa462792d82e5c6435ae8ddea15 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Wed, 15 Nov 2023 15:08:06 -0500
Subject: [PATCH 0258/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20SparseArrays=20stdlib=20from=2037fc321=20to=207786a73=20(#52?=
 =?UTF-8?q?181)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: SparseArrays
URL: https://github.com/JuliaSparse/SparseArrays.jl.git
Stdlib branch: main
Julia branch: master
Old commit: 37fc321
New commit: 7786a73
Julia version: 1.11.0-DEV
SparseArrays version: 1.11.0
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaSparse/SparseArrays.jl/compare/37fc321e28a32f79a928c24e5739a83d92de5205...7786a73cefe4147fb423a5fa529aa583ca6c877c

```
$ git log --oneline 37fc321..7786a73
7786a73 Add Aqua compat. Create CompatHelper.yml (#470)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/SparseArrays.version                                     | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/sha512
 create mode 100644 deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/md5 b/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/md5
deleted file mode 100644
index 2f1c977402216..0000000000000
--- a/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-c69549ac1ff7fd9122b242c2bc50ecb2
diff --git a/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/sha512 b/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/sha512
deleted file mode 100644
index 9f54e3f375b16..0000000000000
--- a/deps/checksums/SparseArrays-37fc321e28a32f79a928c24e5739a83d92de5205.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-381ac83206f2791115f9ccb5e7f794760fdc927a1e22601b26a555d0a744133dceaf8cf0b5ae42f1df9c9158f95f3c51adc8246a4d7a7c543ed71497dd19e0d3
diff --git a/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/md5 b/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/md5
new file mode 100644
index 0000000000000..4d54e2c51c446
--- /dev/null
+++ b/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/md5
@@ -0,0 +1 @@
+d292f91d749fd0c7521a519b049971a4
diff --git a/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/sha512 b/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/sha512
new file mode 100644
index 0000000000000..fb2a83ab6269d
--- /dev/null
+++ b/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/sha512
@@ -0,0 +1 @@
+65ca67da7c3826aab06689077a9b3f06a5562319422ed2cc616ff237af87302f1267049a7c018de2fabf3413470ee82af062699283a40301588602e9e8c8b8b8
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 761eb10fd2062..f891c5ead4c10 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 37fc321e28a32f79a928c24e5739a83d92de5205
+SPARSEARRAYS_SHA1 = 7786a73cefe4147fb423a5fa529aa583ca6c877c
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From aa00204afd0532e3e81547e6673e386a0907835e Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Wed, 15 Nov 2023 19:54:28 -0500
Subject: [PATCH 0259/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20SparseArrays=20stdlib=20from=207786a73=20to=20f154de2=20(#52?=
 =?UTF-8?q?183)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/SparseArrays.version                                     | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/sha512
 create mode 100644 deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/md5 b/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/md5
deleted file mode 100644
index 4d54e2c51c446..0000000000000
--- a/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-d292f91d749fd0c7521a519b049971a4
diff --git a/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/sha512 b/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/sha512
deleted file mode 100644
index fb2a83ab6269d..0000000000000
--- a/deps/checksums/SparseArrays-7786a73cefe4147fb423a5fa529aa583ca6c877c.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-65ca67da7c3826aab06689077a9b3f06a5562319422ed2cc616ff237af87302f1267049a7c018de2fabf3413470ee82af062699283a40301588602e9e8c8b8b8
diff --git a/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/md5 b/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/md5
new file mode 100644
index 0000000000000..9a38667523ea0
--- /dev/null
+++ b/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/md5
@@ -0,0 +1 @@
+e4c17513749ebdd898daf62f932fc9b3
diff --git a/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/sha512 b/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/sha512
new file mode 100644
index 0000000000000..6547864574540
--- /dev/null
+++ b/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/sha512
@@ -0,0 +1 @@
+15a6dfcf64ebc2ff3893373107f317a1abf8518d852219092ead1bdf1db602dc4ac36d836e0c8412b6b1e0b42147deab95d355741fc72234b52f3399a56ba8f9
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index f891c5ead4c10..68cdbbf3fca7c 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 7786a73cefe4147fb423a5fa529aa583ca6c877c
+SPARSEARRAYS_SHA1 = f154de2b6801ec8d5afaf58b73b830c8e71013c3
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From 253cddc6b6bafd05afd02fff064e9f3ba8d7004e Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 16 Nov 2023 14:27:32 +0900
Subject: [PATCH 0260/1315] enhance maintainability of `jl_ir_` accessors
 (#52167)

By allowing us to change data size at one place when we make a change to
the layout of compressed IR.
---
 src/ircode.c | 30 +++++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/src/ircode.c b/src/ircode.c
index e660b8a463aa0..5926f48ef1cf8 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -788,6 +788,18 @@ static jl_value_t *jl_decode_value(jl_ircode_state *s) JL_GC_DISABLED
 
 typedef jl_value_t jl_string_t; // for local expressibility
 
+#define IR_DATASIZE_FLAGS         sizeof(uint8_t)
+#define IR_DATASIZE_PURITY        sizeof(uint8_t)
+#define IR_DATASIZE_INLINING_COST sizeof(uint16_t)
+#define IR_DATASIZE_NSLOTS        sizeof(int32_t)
+typedef enum {
+    ir_offset_flags         = 0,
+    ir_offset_purity        = 0 + IR_DATASIZE_FLAGS,
+    ir_offset_inlining_cost = 0 + IR_DATASIZE_FLAGS + IR_DATASIZE_PURITY,
+    ir_offset_nslots        = 0 + IR_DATASIZE_FLAGS + IR_DATASIZE_PURITY + IR_DATASIZE_INLINING_COST,
+    ir_offset_slotflags     = 0 + IR_DATASIZE_FLAGS + IR_DATASIZE_PURITY + IR_DATASIZE_INLINING_COST + IR_DATASIZE_NSLOTS
+} ir_offset;
+
 JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
 {
     JL_TIMING(AST_COMPRESS, AST_COMPRESS);
@@ -813,12 +825,16 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
     jl_code_info_flags_t flags = code_info_flags(code->inferred, code->propagate_inbounds, code->has_fcall,
                                                  code->nospecializeinfer, code->inlining, code->constprop);
     write_uint8(s.s, flags.packed);
+    static_assert(sizeof(flags.packed) == IR_DATASIZE_FLAGS, "ir_datasize_flags is mismatched with the actual size");
     write_uint8(s.s, code->purity.bits);
+    static_assert(sizeof(code->purity.bits) == IR_DATASIZE_PURITY, "ir_datasize_purity is mismatched with the actual size");
     write_uint16(s.s, code->inlining_cost);
+    static_assert(sizeof(code->inlining_cost) == IR_DATASIZE_INLINING_COST, "ir_datasize_inlining_cost is mismatched with the actual size");
 
-    size_t nslots = jl_array_nrows(code->slotflags);
+    int32_t nslots = jl_array_nrows(code->slotflags);
     assert(nslots >= m->nargs && nslots < INT32_MAX); // required by generated functions
     write_int32(s.s, nslots);
+    static_assert(sizeof(nslots) == IR_DATASIZE_NSLOTS, "ir_datasize_nslots is mismatched with the actual size");
     ios_write(s.s, jl_array_data(code->slotflags, const char), nslots);
 
     // N.B.: The layout of everything before this point is explicitly referenced
@@ -973,7 +989,7 @@ JL_DLLEXPORT uint8_t jl_ir_flag_inferred(jl_string_t *data)
         return ((jl_code_info_t*)data)->inferred;
     assert(jl_is_string(data));
     jl_code_info_flags_t flags;
-    flags.packed = jl_string_data(data)[0];
+    flags.packed = jl_string_data(data)[ir_offset_flags];
     return flags.bits.inferred;
 }
 
@@ -983,7 +999,7 @@ JL_DLLEXPORT uint8_t jl_ir_flag_inlining(jl_string_t *data)
         return ((jl_code_info_t*)data)->inlining;
     assert(jl_is_string(data));
     jl_code_info_flags_t flags;
-    flags.packed = jl_string_data(data)[0];
+    flags.packed = jl_string_data(data)[ir_offset_flags];
     return flags.bits.inlining;
 }
 
@@ -993,7 +1009,7 @@ JL_DLLEXPORT uint8_t jl_ir_flag_has_fcall(jl_string_t *data)
         return ((jl_code_info_t*)data)->has_fcall;
     assert(jl_is_string(data));
     jl_code_info_flags_t flags;
-    flags.packed = jl_string_data(data)[0];
+    flags.packed = jl_string_data(data)[ir_offset_flags];
     return flags.bits.has_fcall;
 }
 
@@ -1002,7 +1018,7 @@ JL_DLLEXPORT uint16_t jl_ir_inlining_cost(jl_string_t *data)
     if (jl_is_code_info(data))
         return ((jl_code_info_t*)data)->inlining_cost;
     assert(jl_is_string(data));
-    uint16_t res = jl_load_unaligned_i16(jl_string_data(data) + 2);
+    uint16_t res = jl_load_unaligned_i16(jl_string_data(data) + ir_offset_inlining_cost);
     return res;
 }
 
@@ -1040,7 +1056,7 @@ JL_DLLEXPORT ssize_t jl_ir_nslots(jl_value_t *data)
     }
     else {
         assert(jl_is_string(data));
-        int nslots = jl_load_unaligned_i32(jl_string_data(data) + 2 + sizeof(uint16_t));
+        int nslots = jl_load_unaligned_i32(jl_string_data(data) + ir_offset_nslots);
         return nslots;
     }
 }
@@ -1053,7 +1069,7 @@ JL_DLLEXPORT uint8_t jl_ir_slotflag(jl_string_t *data, size_t i)
         return jl_array_data(slotflags, uint8_t)[i];
     }
     assert(jl_is_string(data));
-    return jl_string_data(data)[2 + sizeof(uint16_t) + sizeof(int32_t) + i];
+    return jl_string_data(data)[ir_offset_slotflags + i];
 }
 
 JL_DLLEXPORT jl_array_t *jl_uncompress_argnames(jl_value_t *syms)

From 3c824030a403ba47706c161986c3a630465c2573 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Wed, 15 Nov 2023 22:28:46 +0900
Subject: [PATCH 0261/1315] stop passing `arginfo` to `builtin_effects`

`builtin_effects` no longer requires the `arginfo` parameter, as
`getfield_effects` doesn't depend on analyzing `fargs` for
`:boundscheck` information anymore. The equivalent analysis is now
done as the post-opt analysis.

Given that `:boundscheck` expressions are now lowered to an independent
statement, even if we need to analyze `fargs` within `builtin_effects`,
we would likely need to pass `sv::AbsIntState` too in order to allow
it to use `ssa_def_slot`. For now, it's more efficient to just eliminate
the passing of `arginfo` since it is not necessary.
---
 base/compiler/abstractinterpretation.jl |  5 ++---
 base/compiler/optimize.jl               |  2 +-
 base/compiler/tfuncs.jl                 | 26 ++++++++++---------------
 base/reflection.jl                      |  3 +--
 test/compiler/effects.jl                |  9 +++++----
 5 files changed, 19 insertions(+), 26 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 3a61aa5ef3dae..51838003bb2db 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2017,7 +2017,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
             return abstract_applicable(interp, argtypes, sv, max_methods)
         end
         rt = abstract_call_builtin(interp, f, arginfo, sv)
-        effects = builtin_effects(𝕃ᵢ, f, arginfo, rt)
+        effects = builtin_effects(𝕃ᵢ, f, argtypes, rt)
         return CallMeta(rt, effects, NoCallInfo())
     elseif isa(f, Core.OpaqueClosure)
         # calling an OpaqueClosure about which we have no information returns no information
@@ -2043,8 +2043,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
             abstract_call_gf_by_type(interp, f, ArgInfo(nothing, T), si, atype, sv, max_methods)
         end
         pT = typevar_tfunc(𝕃ᵢ, n, lb_var, ub_var)
-        effects = builtin_effects(𝕃ᵢ, Core._typevar, ArgInfo(nothing,
-            Any[Const(Core._typevar), n, lb_var, ub_var]), pT)
+        effects = builtin_effects(𝕃ᵢ, Core._typevar, Any[Const(Core._typevar), n, lb_var, ub_var], pT)
         return CallMeta(pT, effects, call.info)
     elseif f === UnionAll
         call = abstract_call_gf_by_type(interp, f, ArgInfo(nothing, Any[Const(UnionAll), Any, Any]), si, Tuple{Type{UnionAll}, Any, Any}, sv, max_methods)
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 62a20896334b3..cb6ce5bd871df 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -296,7 +296,7 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
             # Needs to be handled in inlining to look at the callee effects
             f === Core._apply_iterate && return (false, false, false)
             argtypes = Any[argextype(args[arg], src) for arg in 1:length(args)]
-            effects = builtin_effects(𝕃ₒ, f, ArgInfo(args, argtypes), rt)
+            effects = builtin_effects(𝕃ₒ, f, argtypes, rt)
             consistent = is_consistent(effects)
             effect_free = is_effect_free(effects)
             nothrow = is_nothrow(effects)
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 588ecabe429ec..b15836be6eb39 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -922,19 +922,16 @@ function try_compute_fieldidx(@nospecialize(typ), @nospecialize(field))
     return field
 end
 
-function getfield_boundscheck((; fargs, argtypes)::ArgInfo) # Symbol
-    farg = nothing
+function getfield_boundscheck(argtypes::Vector{Any})
     if length(argtypes) == 3
         return :on
     elseif length(argtypes) == 4
-        fargs !== nothing && (farg = fargs[4])
         boundscheck = argtypes[4]
         isvarargtype(boundscheck) && return :unsafe
         if widenconst(boundscheck) === Symbol
             return :on
         end
     elseif length(argtypes) == 5
-        fargs !== nothing && (farg = fargs[5])
         boundscheck = argtypes[5]
     else
         return :unsafe
@@ -944,15 +941,13 @@ function getfield_boundscheck((; fargs, argtypes)::ArgInfo) # Symbol
     if widenconst(boundscheck) === Bool
         if isa(boundscheck, Const)
             return boundscheck.val::Bool ? :on : :off
-        elseif farg !== nothing && isexpr(farg, :boundscheck)
-            return :boundscheck
         end
-        return :unknown
+        return :unknown # including a case when specified as `:boundscheck`
     end
     return :unsafe
 end
 
-function getfield_nothrow(𝕃::AbstractLattice, arginfo::ArgInfo, boundscheck::Symbol=getfield_boundscheck(arginfo))
+function getfield_nothrow(𝕃::AbstractLattice, argtypes::Vector{Any}, boundscheck::Symbol=getfield_boundscheck(argtypes))
     boundscheck === :unsafe && return false
     (;argtypes) = arginfo
     ordering = Const(:not_atomic)
@@ -2180,7 +2175,7 @@ end
     elseif f === invoke
         return false
     elseif f === getfield
-        return getfield_nothrow(𝕃, ArgInfo(nothing, Any[Const(f), argtypes...]))
+        return getfield_nothrow(𝕃, Any[Const(f), argtypes...])
     elseif f === setfield!
         if na == 3
             return setfield!_nothrow(𝕃, argtypes[1], argtypes[2], argtypes[3])
@@ -2384,8 +2379,7 @@ function isdefined_effects(𝕃::AbstractLattice, argtypes::Vector{Any})
     return Effects(EFFECTS_TOTAL; consistent, nothrow, inaccessiblememonly)
 end
 
-function getfield_effects(𝕃::AbstractLattice, arginfo::ArgInfo, @nospecialize(rt))
-    (;argtypes) = arginfo
+function getfield_effects(𝕃::AbstractLattice, argtypes::Vector{Any}, @nospecialize(rt))
     length(argtypes) < 3 && return EFFECTS_THROWS
     obj = argtypes[2]
     if isvarargtype(obj)
@@ -2409,8 +2403,8 @@ function getfield_effects(𝕃::AbstractLattice, arginfo::ArgInfo, @nospecialize
         consistent = ALWAYS_FALSE
     end
     noub = ALWAYS_TRUE
-    bcheck = getfield_boundscheck(arginfo)
-    nothrow = getfield_nothrow(𝕃, arginfo, bcheck)
+    bcheck = getfield_boundscheck(argtypes)
+    nothrow = getfield_nothrow(𝕃, argtypes, bcheck)
     if !nothrow
         if bcheck !== :on
             # If we cannot independently prove inboundsness, taint `:noub`.
@@ -2453,15 +2447,15 @@ function getglobal_effects(argtypes::Vector{Any}, @nospecialize(rt))
     return Effects(EFFECTS_TOTAL; consistent, nothrow, inaccessiblememonly)
 end
 
-function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), arginfo::ArgInfo, @nospecialize(rt))
+function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argtypes::Vector{Any}, @nospecialize(rt))
     if isa(f, IntrinsicFunction)
-        return intrinsic_effects(f, arginfo.argtypes[2:end])
+        return intrinsic_effects(f, argtypes[2:end])
     end
 
     @assert !contains_is(_SPECIAL_BUILTINS, f)
 
     if f === getfield
-        return getfield_effects(𝕃, arginfo, rt)
+        return getfield_effects(𝕃, argtypes, rt)
     end
 
     # if this builtin call deterministically throws,
diff --git a/base/reflection.jl b/base/reflection.jl
index 3a1a3e288f1d6..e5949401ff093 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1796,8 +1796,7 @@ function infer_effects(@nospecialize(f), @nospecialize(types=default_tt(f));
         types = to_tuple_type(types)
         argtypes = Any[Core.Const(f), types.parameters...]
         rt = Core.Compiler.builtin_tfunction(interp, f, argtypes[2:end], nothing)
-        return Core.Compiler.builtin_effects(Core.Compiler.typeinf_lattice(interp), f,
-            Core.Compiler.ArgInfo(nothing, argtypes), rt)
+        return Core.Compiler.builtin_effects(Core.Compiler.typeinf_lattice(interp), f, argtypes, rt)
     end
     tt = signature_type(f, types)
     matches = Core.Compiler.findall(tt, Core.Compiler.method_table(interp))
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index ad2c60723adf6..a3681be1a6bc8 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -477,9 +477,10 @@ end |> Core.Compiler.is_effect_free
 
 # `getfield_effects` handles access to union object nicely
 let 𝕃 = Core.Compiler.fallback_lattice
-    @test Core.Compiler.is_consistent(Core.Compiler.getfield_effects(𝕃, Core.Compiler.ArgInfo(nothing, Any[Core.Const(getfield), Some{String}, Core.Const(:value)]), String))
-    @test Core.Compiler.is_consistent(Core.Compiler.getfield_effects(𝕃, Core.Compiler.ArgInfo(nothing, Any[Core.Const(getfield), Some{Symbol}, Core.Const(:value)]), Symbol))
-    @test Core.Compiler.is_consistent(Core.Compiler.getfield_effects(𝕃, Core.Compiler.ArgInfo(nothing, Any[Core.Const(getfield), Union{Some{Symbol},Some{String}}, Core.Const(:value)]), Union{Symbol,String}))
+    getfield_effects = Core.Compiler.getfield_effects
+    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Core.Const(getfield), Some{String}, Core.Const(:value)], String))
+    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Core.Const(getfield), Some{Symbol}, Core.Const(:value)], Symbol))
+    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Core.Const(getfield), Union{Some{Symbol},Some{String}}, Core.Const(:value)], Union{Symbol,String}))
 end
 @test Base.infer_effects((Bool,)) do c
     obj = c ? Some{String}("foo") : Some{Symbol}(:bar)
@@ -880,7 +881,7 @@ end
 
 # Test that builtin_effects handles vararg correctly
 @test !Core.Compiler.is_nothrow(Core.Compiler.builtin_effects(Core.Compiler.fallback_lattice, Core.isdefined,
-    Core.Compiler.ArgInfo(nothing, Any[Core.Compiler.Const(Core.isdefined), String, Vararg{Any}]), Bool))
+    Any[Core.Compiler.Const(Core.isdefined), String, Vararg{Any}], Bool))
 
 # Test that :new can be eliminated even if an sparam is unknown
 struct SparamUnused{T}

From 574c5d121f0239c9458148e974827dfbb19a5125 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Wed, 15 Nov 2023 22:40:54 +0900
Subject: [PATCH 0262/1315] exclude the first builtin function from `argtypes`
 of `builtin_effects`

Streamlined the `builtin_effects` function to accept `argtypes` without
including the builtin function itself. The first argument in the
previous implementation of `argtypes` was just redundant. This change
might reduce unnecessary allocations.
---
 base/compiler/abstractinterpretation.jl |  4 +-
 base/compiler/optimize.jl               |  2 +-
 base/compiler/tfuncs.jl                 | 52 ++++++++++++++-----------
 base/reflection.jl                      |  4 +-
 test/compiler/effects.jl                |  8 ++--
 5 files changed, 40 insertions(+), 30 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 51838003bb2db..73777646fa68b 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2017,7 +2017,9 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
             return abstract_applicable(interp, argtypes, sv, max_methods)
         end
         rt = abstract_call_builtin(interp, f, arginfo, sv)
+        ft = popfirst!(argtypes)
         effects = builtin_effects(𝕃ᵢ, f, argtypes, rt)
+        pushfirst!(argtypes, ft)
         return CallMeta(rt, effects, NoCallInfo())
     elseif isa(f, Core.OpaqueClosure)
         # calling an OpaqueClosure about which we have no information returns no information
@@ -2043,7 +2045,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
             abstract_call_gf_by_type(interp, f, ArgInfo(nothing, T), si, atype, sv, max_methods)
         end
         pT = typevar_tfunc(𝕃ᵢ, n, lb_var, ub_var)
-        effects = builtin_effects(𝕃ᵢ, Core._typevar, Any[Const(Core._typevar), n, lb_var, ub_var], pT)
+        effects = builtin_effects(𝕃ᵢ, Core._typevar, Any[n, lb_var, ub_var], pT)
         return CallMeta(pT, effects, call.info)
     elseif f === UnionAll
         call = abstract_call_gf_by_type(interp, f, ArgInfo(nothing, Any[Const(UnionAll), Any, Any]), si, Tuple{Type{UnionAll}, Any, Any}, sv, max_methods)
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index cb6ce5bd871df..e974a23d05651 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -295,7 +295,7 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
             isa(f, Builtin) || return (false, false, false)
             # Needs to be handled in inlining to look at the callee effects
             f === Core._apply_iterate && return (false, false, false)
-            argtypes = Any[argextype(args[arg], src) for arg in 1:length(args)]
+            argtypes = Any[argextype(args[arg], src) for arg in 2:length(args)]
             effects = builtin_effects(𝕃ₒ, f, argtypes, rt)
             consistent = is_consistent(effects)
             effect_free = is_effect_free(effects)
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index b15836be6eb39..32b523bf32671 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -923,16 +923,16 @@ function try_compute_fieldidx(@nospecialize(typ), @nospecialize(field))
 end
 
 function getfield_boundscheck(argtypes::Vector{Any})
-    if length(argtypes) == 3
+    if length(argtypes) == 2
         return :on
-    elseif length(argtypes) == 4
-        boundscheck = argtypes[4]
+    elseif length(argtypes) == 3
+        boundscheck = argtypes[3]
         isvarargtype(boundscheck) && return :unsafe
         if widenconst(boundscheck) === Symbol
             return :on
         end
-    elseif length(argtypes) == 5
-        boundscheck = argtypes[5]
+    elseif length(argtypes) == 4
+        boundscheck = argtypes[4]
     else
         return :unsafe
     end
@@ -949,16 +949,15 @@ end
 
 function getfield_nothrow(𝕃::AbstractLattice, argtypes::Vector{Any}, boundscheck::Symbol=getfield_boundscheck(argtypes))
     boundscheck === :unsafe && return false
-    (;argtypes) = arginfo
     ordering = Const(:not_atomic)
-    if length(argtypes) == 4
-        isvarargtype(argtypes[4]) && return false
-        if widenconst(argtypes[4]) !== Bool
-            ordering = argtypes[4]
-        end
-    elseif length(argtypes) == 5
-        ordering = argtypes[4]
-    elseif length(argtypes) != 3
+    if length(argtypes) == 3
+        isvarargtype(argtypes[3]) && return false
+        if widenconst(argtypes[3]) !== Bool
+            ordering = argtypes[3]
+        end
+    elseif length(argtypes) == 4
+        ordering = argtypes[3]
+    elseif length(argtypes) ≠ 2
         return false
     end
     isa(ordering, Const) || return false
@@ -967,7 +966,7 @@ function getfield_nothrow(𝕃::AbstractLattice, argtypes::Vector{Any}, boundsch
     if ordering !== :not_atomic # TODO: this is assuming not atomic
         return false
     end
-    return getfield_nothrow(𝕃, argtypes[2], argtypes[3], !(boundscheck === :off))
+    return getfield_nothrow(𝕃, argtypes[1], argtypes[2], !(boundscheck === :off))
 end
 @nospecs function getfield_nothrow(𝕃::AbstractLattice, s00, name, boundscheck::Bool)
     # If we don't have boundscheck off and don't know the field, don't even bother
@@ -2175,7 +2174,7 @@ end
     elseif f === invoke
         return false
     elseif f === getfield
-        return getfield_nothrow(𝕃, Any[Const(f), argtypes...])
+        return getfield_nothrow(𝕃, argtypes)
     elseif f === setfield!
         if na == 3
             return setfield!_nothrow(𝕃, argtypes[1], argtypes[2], argtypes[3])
@@ -2380,8 +2379,8 @@ function isdefined_effects(𝕃::AbstractLattice, argtypes::Vector{Any})
 end
 
 function getfield_effects(𝕃::AbstractLattice, argtypes::Vector{Any}, @nospecialize(rt))
-    length(argtypes) < 3 && return EFFECTS_THROWS
-    obj = argtypes[2]
+    length(argtypes) < 2 && return EFFECTS_THROWS
+    obj = argtypes[1]
     if isvarargtype(obj)
         return Effects(EFFECTS_TOTAL;
             consistent=CONSISTENT_IF_INACCESSIBLEMEMONLY,
@@ -2399,7 +2398,7 @@ function getfield_effects(𝕃::AbstractLattice, argtypes::Vector{Any}, @nospeci
     # with undefined value to avoid tainting `:consistent` too aggressively
     # TODO this should probably taint `:noub`, however, it would hinder concrete eval for
     # `REPLInterpreter` that can ignore `:consistent-cy`, causing worse completions
-    if !(length(argtypes) ≥ 3 && getfield_notundefined(obj, argtypes[3]))
+    if !(length(argtypes) ≥ 2 && getfield_notundefined(obj, argtypes[2]))
         consistent = ALWAYS_FALSE
     end
     noub = ALWAYS_TRUE
@@ -2419,7 +2418,7 @@ function getfield_effects(𝕃::AbstractLattice, argtypes::Vector{Any}, @nospeci
         end
     end
     if hasintersect(widenconst(obj), Module)
-        inaccessiblememonly = getglobal_effects(argtypes[2:end], rt).inaccessiblememonly
+        inaccessiblememonly = getglobal_effects(argtypes, rt).inaccessiblememonly
     elseif is_mutation_free_argtype(obj)
         inaccessiblememonly = ALWAYS_TRUE
     else
@@ -2447,9 +2446,14 @@ function getglobal_effects(argtypes::Vector{Any}, @nospecialize(rt))
     return Effects(EFFECTS_TOTAL; consistent, nothrow, inaccessiblememonly)
 end
 
+"""
+    builtin_effects(𝕃::AbstractLattice, f::Builtin, argtypes::Vector{Any}, rt) -> Effects
+
+Compute the effects of a builtin function call. `argtypes` should not include `f` itself.
+"""
 function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argtypes::Vector{Any}, @nospecialize(rt))
     if isa(f, IntrinsicFunction)
-        return intrinsic_effects(f, argtypes[2:end])
+        return intrinsic_effects(f, argtypes)
     end
 
     @assert !contains_is(_SPECIAL_BUILTINS, f)
@@ -2463,7 +2467,6 @@ function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argty
     # note this is safe only if we accounted for :noub already
     rt === Bottom && return EFFECTS_THROWS
 
-    argtypes = arginfo.argtypes[2:end]
     if f === isdefined
         return isdefined_effects(𝕃, argtypes)
     elseif f === getglobal
@@ -2509,6 +2512,11 @@ function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argty
     end
 end
 
+"""
+    builtin_nothrow(𝕃::AbstractLattice, f::Builtin, argtypes::Vector{Any}, rt) -> Bool
+
+Compute throw-ness of a builtin function call. `argtypes` should not include `f` itself.
+"""
 function builtin_nothrow(𝕃::AbstractLattice, @nospecialize(f), argtypes::Vector{Any}, @nospecialize(rt))
     rt === Bottom && return false
     contains_is(_PURE_BUILTINS, f) && return true
diff --git a/base/reflection.jl b/base/reflection.jl
index e5949401ff093..304f7a4344fb2 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1794,8 +1794,8 @@ function infer_effects(@nospecialize(f), @nospecialize(types=default_tt(f));
         error("code reflection cannot be used from generated functions")
     if isa(f, Core.Builtin)
         types = to_tuple_type(types)
-        argtypes = Any[Core.Const(f), types.parameters...]
-        rt = Core.Compiler.builtin_tfunction(interp, f, argtypes[2:end], nothing)
+        argtypes = Any[types.parameters...]
+        rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
         return Core.Compiler.builtin_effects(Core.Compiler.typeinf_lattice(interp), f, argtypes, rt)
     end
     tt = signature_type(f, types)
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index a3681be1a6bc8..7ec1910dfb2a3 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -478,9 +478,9 @@ end |> Core.Compiler.is_effect_free
 # `getfield_effects` handles access to union object nicely
 let 𝕃 = Core.Compiler.fallback_lattice
     getfield_effects = Core.Compiler.getfield_effects
-    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Core.Const(getfield), Some{String}, Core.Const(:value)], String))
-    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Core.Const(getfield), Some{Symbol}, Core.Const(:value)], Symbol))
-    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Core.Const(getfield), Union{Some{Symbol},Some{String}}, Core.Const(:value)], Union{Symbol,String}))
+    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Some{String}, Core.Const(:value)], String))
+    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Some{Symbol}, Core.Const(:value)], Symbol))
+    @test Core.Compiler.is_consistent(getfield_effects(𝕃, Any[Union{Some{Symbol},Some{String}}, Core.Const(:value)], Union{Symbol,String}))
 end
 @test Base.infer_effects((Bool,)) do c
     obj = c ? Some{String}("foo") : Some{Symbol}(:bar)
@@ -881,7 +881,7 @@ end
 
 # Test that builtin_effects handles vararg correctly
 @test !Core.Compiler.is_nothrow(Core.Compiler.builtin_effects(Core.Compiler.fallback_lattice, Core.isdefined,
-    Any[Core.Compiler.Const(Core.isdefined), String, Vararg{Any}], Bool))
+    Any[String, Vararg{Any}], Bool))
 
 # Test that :new can be eliminated even if an sparam is unknown
 struct SparamUnused{T}

From 4689850aadbdeb2be9ffe5cc7ce04770eef334b3 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 16 Nov 2023 21:44:45 +0530
Subject: [PATCH 0263/1315] Compatible parent index when displaying dots in
 SubArrays (#52097)

Fix #52095 by passing the `reindex`ed indices through `to_indices` to
convert them to `Integer`s. This should strip `CartesianIndex`es in
particular, which resolves the issue.

Fixes:
```julia
julia> view(1:2, [CartesianIndex(2)])
1-element view(::UnitRange{Int64}, CartesianIndex{1}[CartesianIndex(2,)]) with eltype Int64:
 2
```
---
 base/subarray.jl | 4 ++--
 test/subarray.jl | 3 +++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index 61d59bddf547d..fa142a8843c63 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -483,8 +483,8 @@ end
 has_offset_axes(S::SubArray) = has_offset_axes(S.indices...)
 
 function replace_in_print_matrix(S::SubArray{<:Any,2,<:AbstractMatrix}, i::Integer, j::Integer, s::AbstractString)
-    replace_in_print_matrix(S.parent, reindex(S.indices, (i,j))..., s)
+    replace_in_print_matrix(S.parent, to_indices(S.parent, reindex(S.indices, (i,j)))..., s)
 end
 function replace_in_print_matrix(S::SubArray{<:Any,1,<:AbstractVector}, i::Integer, j::Integer, s::AbstractString)
-    replace_in_print_matrix(S.parent, reindex(S.indices, (i,))..., j, s)
+    replace_in_print_matrix(S.parent, to_indices(S.parent, reindex(S.indices, (i,)))..., j, s)
 end
diff --git a/test/subarray.jl b/test/subarray.jl
index f7350d50f793d..da2a88d68408e 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -799,6 +799,9 @@ end
     end
     V = view(OneElVec(6, 2), 1:5)
     @test sprint(show, "text/plain", V) == "$(summary(V)):\n ⋅\n 1\n ⋅\n ⋅\n ⋅"
+
+    V = view(1:2, [CartesianIndex(2)])
+    @test sprint(show, "text/plain", V) == "$(summary(V)):\n 2"
 end
 
 @testset "Base.first_index for offset indices" begin

From 7f18f767ab5711b03eee98a03594e909e5510365 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 17 Nov 2023 01:51:06 +0900
Subject: [PATCH 0264/1315] inference: enhance memoryop tfunc robustness
 (#52185)

Make them able to handle potential `Vararg` argument. Also adds plenty
of tests.
---
 base/compiler/tfuncs.jl    | 11 ++++++-----
 test/compiler/inference.jl | 31 ++++++++++++++++++++++++++++++-
 2 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 32b523bf32671..a8610eb8fd653 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -1992,7 +1992,7 @@ end
 add_tfunc(memoryref_isassigned, 3, 3, memoryref_isassigned_tfunc, 20)
 
 @nospecs function memoryref_tfunc(𝕃::AbstractLattice, mem)
-    a = widenconst(mem)
+    a = widenconst(unwrapva(mem))
     if !has_free_typevars(a)
         unw = unwrap_unionall(a)
         if isa(unw, DataType) && unw.name === GenericMemory.body.body.body.name
@@ -2006,7 +2006,10 @@ add_tfunc(memoryref_isassigned, 3, 3, memoryref_isassigned_tfunc, 20)
     return GenericMemoryRef
 end
 @nospecs function memoryref_tfunc(𝕃::AbstractLattice, ref, idx)
-    memoryref_tfunc(𝕃, ref, idx, Const(true))
+    if isvarargtype(idx)
+        idx = unwrapva(idx)
+    end
+    return memoryref_tfunc(𝕃, ref, idx, Const(true))
 end
 @nospecs function memoryref_tfunc(𝕃::AbstractLattice, ref, idx, boundscheck)
     memoryref_builtin_common_errorcheck(ref, Const(:not_atomic), boundscheck) || return Bottom
@@ -2021,12 +2024,10 @@ add_tfunc(memoryref, 1, 3, memoryref_tfunc, 1)
 end
 add_tfunc(memoryrefoffset, 1, 1, memoryrefoffset_tfunc, 5)
 
-
-
 @nospecs function memoryref_builtin_common_errorcheck(mem, order, boundscheck)
     hasintersect(widenconst(mem), GenericMemoryRef) || return false
     hasintersect(widenconst(order), Symbol) || return false
-    hasintersect(widenconst(boundscheck), Bool) || return false
+    hasintersect(widenconst(unwrapva(boundscheck)), Bool) || return false
     return true
 end
 
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 6872ad0bcc0bc..ace17baeb5859 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -1580,15 +1580,21 @@ end
 f_typeof_tfunc(x) = typeof(x)
 @test Base.return_types(f_typeof_tfunc, (Union{<:T, Int} where T<:Complex,)) == Any[Union{Type{Int}, Type{Complex{T}} where T<:Real}]
 
-# memoryref_tfunc, memoryrefget_tfunc, memoryrefset!_tfunc
+# memoryref_tfunc, memoryrefget_tfunc, memoryrefset!_tfunc, memoryref_isassigned, memoryrefoffset_tfunc
 let memoryref_tfunc(@nospecialize xs...) = Core.Compiler.memoryref_tfunc(Core.Compiler.fallback_lattice, xs...)
     memoryrefget_tfunc(@nospecialize xs...) = Core.Compiler.memoryrefget_tfunc(Core.Compiler.fallback_lattice, xs...)
+    memoryref_isassigned_tfunc(@nospecialize xs...) = Core.Compiler.memoryref_isassigned_tfunc(Core.Compiler.fallback_lattice, xs...)
     memoryrefset!_tfunc(@nospecialize xs...) = Core.Compiler.memoryrefset!_tfunc(Core.Compiler.fallback_lattice, xs...)
+    memoryrefoffset_tfunc(@nospecialize xs...) = Core.Compiler.memoryrefoffset_tfunc(Core.Compiler.fallback_lattice, xs...)
+    interp = Core.Compiler.NativeInterpreter()
+    builtin_tfunction(@nospecialize xs...) = Core.Compiler.builtin_tfunction(interp, xs..., nothing)
     @test memoryref_tfunc(Memory{Int}) == MemoryRef{Int}
     @test memoryref_tfunc(Memory{Integer}) == MemoryRef{Integer}
     @test memoryref_tfunc(MemoryRef{Int}, Int) == MemoryRef{Int}
+    @test memoryref_tfunc(MemoryRef{Int}, Vararg{Int}) == MemoryRef{Int}
     @test memoryref_tfunc(MemoryRef{Int}, Int, Symbol) == Union{}
     @test memoryref_tfunc(MemoryRef{Int}, Int, Bool) == MemoryRef{Int}
+    @test memoryref_tfunc(MemoryRef{Int}, Int, Vararg{Bool}) == MemoryRef{Int}
     @test memoryref_tfunc(Memory{Int}, Int) == Union{}
     @test memoryref_tfunc(Any, Any, Any) == Any # also probably could be GenericMemoryRef
     @test memoryref_tfunc(Any, Any) == Any # also probably could be GenericMemoryRef
@@ -1603,6 +1609,20 @@ let memoryref_tfunc(@nospecialize xs...) = Core.Compiler.memoryref_tfunc(Core.Co
     @test memoryrefget_tfunc(MemoryRef{Int}, String, Bool) === Union{}
     @test memoryrefget_tfunc(MemoryRef{Int}, Symbol, String) === Union{}
     @test memoryrefget_tfunc(Any, Any, Any) === Any
+    @test builtin_tfunction(Core.memoryrefget, Any[MemoryRef{Int}, Vararg{Any}]) == Int
+    @test builtin_tfunction(Core.memoryrefget, Any[MemoryRef{Int}, Symbol, Bool, Vararg{Bool}]) == Int
+    @test memoryref_isassigned_tfunc(MemoryRef{Any}, Symbol, Bool) === Bool
+    @test memoryref_isassigned_tfunc(MemoryRef{Any}, Any, Any) === Bool
+    @test memoryref_isassigned_tfunc(MemoryRef{<:Integer}, Symbol, Bool) === Bool
+    @test memoryref_isassigned_tfunc(GenericMemoryRef, Symbol, Bool) === Bool
+    @test memoryref_isassigned_tfunc(GenericMemoryRef{:not_atomic}, Symbol, Bool) === Bool
+    @test memoryref_isassigned_tfunc(Vector{Int}, Symbol, Bool) === Union{}
+    @test memoryref_isassigned_tfunc(String, Symbol, Bool) === Union{}
+    @test memoryref_isassigned_tfunc(MemoryRef{Int}, String, Bool) === Union{}
+    @test memoryref_isassigned_tfunc(MemoryRef{Int}, Symbol, String) === Union{}
+    @test memoryref_isassigned_tfunc(Any, Any, Any) === Bool
+    @test builtin_tfunction(Core.memoryref_isassigned, Any[MemoryRef{Int}, Vararg{Any}]) == Bool
+    @test builtin_tfunction(Core.memoryref_isassigned, Any[MemoryRef{Int}, Symbol, Bool, Vararg{Bool}]) == Bool
     @test memoryrefset!_tfunc(MemoryRef{Int}, Int, Symbol, Bool) === MemoryRef{Int}
     let ua = MemoryRef{<:Integer}
         @test memoryrefset!_tfunc(ua, Int, Symbol, Bool) === ua
@@ -1617,6 +1637,15 @@ let memoryref_tfunc(@nospecialize xs...) = Core.Compiler.memoryref_tfunc(Core.Co
     @test memoryrefset!_tfunc(GenericMemoryRef{:not_atomic}, Any, Any, Any) === GenericMemoryRef{:not_atomic}
     @test memoryrefset!_tfunc(GenericMemoryRef, Any, Any, Any) === GenericMemoryRef
     @test memoryrefset!_tfunc(Any, Any, Any, Any) === Any # also probably could be GenericMemoryRef
+    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Vararg{Any}]) == MemoryRef{Int}
+    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Vararg{Symbol}]) == Union{}
+    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Any, Symbol, Vararg{Bool}]) == MemoryRef{Int}
+    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Any, Symbol, Bool, Vararg{Any}]) == MemoryRef{Int}
+    @test memoryrefoffset_tfunc(MemoryRef) == memoryrefoffset_tfunc(GenericMemoryRef) == Int
+    @test memoryrefoffset_tfunc(Memory) == memoryrefoffset_tfunc(GenericMemory) == Union{}
+    @test builtin_tfunction(Core.memoryrefoffset, Any[Vararg{MemoryRef}]) == Int
+    @test builtin_tfunction(Core.memoryrefoffset, Any[Vararg{Any}]) == Int
+    @test builtin_tfunction(Core.memoryrefoffset, Any[Vararg{Memory}]) == Union{}
 end
 
 let tuple_tfunc(@nospecialize xs...) =

From 40e56a50cca62b55a70bbd62bdb935d5a00dd30c Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Thu, 16 Nov 2023 16:15:03 -0300
Subject: [PATCH 0265/1315] add some instrumentation to measure page
 utilization per size class (#52164)

One of the limitations is that it's only accurate right after the GC.
Still might be helpful for observability purposes.
---
 src/gc.c | 34 ++++++++++++++++++++++++++++++++++
 src/gc.h |  8 ++++++++
 2 files changed, 42 insertions(+)

diff --git a/src/gc.c b/src/gc.c
index 38a4a5f60bcd7..6860871587952 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1413,6 +1413,38 @@ int jl_gc_classify_pools(size_t sz, int *osize)
 
 // sweep phase
 
+gc_fragmentation_stat_t gc_page_fragmentation_stats[JL_GC_N_POOLS];
+
+extern gc_fragmentation_stat_t gc_page_fragmentation_stats[JL_GC_N_POOLS];
+
+STATIC_INLINE void gc_update_page_fragmentation_data(jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT
+{
+#ifdef GC_MEASURE_PAGE_FRAGMENTATION
+    gc_fragmentation_stat_t *stats = &gc_page_fragmentation_stats[pg->pool_n];
+    jl_atomic_fetch_add(&stats->n_freed_objs, pg->nfree);
+    jl_atomic_fetch_add(&stats->n_pages_allocd, 1);
+#endif
+}
+
+STATIC_INLINE void gc_dump_page_utilization_data(void) JL_NOTSAFEPOINT
+{
+#ifdef GC_MEASURE_PAGE_FRAGMENTATION
+    for (int i = 0; i < JL_GC_N_POOLS; i++) {
+        gc_fragmentation_stat_t *stats = &gc_page_fragmentation_stats[i];
+        double utilization = 1.0;
+        size_t n_freed_objs = jl_atomic_load_relaxed(&stats->n_freed_objs);
+        size_t n_pages_allocd = jl_atomic_load_relaxed(&stats->n_pages_allocd);
+        if (n_pages_allocd != 0) {
+            utilization -= ((double)n_freed_objs * (double)jl_gc_sizeclasses[i]) / (double)n_pages_allocd / (double)GC_PAGE_SZ;
+        }
+        jl_safe_printf("Size class %d: %.2f%% utilization\n", jl_gc_sizeclasses[i], utilization * 100.0);
+        jl_atomic_store_relaxed(&stats->n_freed_objs, 0);
+        jl_atomic_store_relaxed(&stats->n_pages_allocd, 0);
+    }
+    jl_safe_printf("-----------------------------------------\n");
+#endif
+}
+
 int64_t buffered_pages = 0;
 
 // Returns pointer to terminal pointer of list rooted at *pfl.
@@ -1522,6 +1554,7 @@ static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_pag
             push_lf_back(&global_page_pool_lazily_freed, pg);
         }
     }
+    gc_update_page_fragmentation_data(pg);
     gc_time_count_page(freedall, pg_skpd);
     jl_ptls_t ptls = gc_all_tls_states[pg->thread_n];
     jl_atomic_fetch_add(&ptls->gc_num.pool_live_bytes, GC_PAGE_SZ - GC_PAGE_OFFSET - nfree * osize);
@@ -1735,6 +1768,7 @@ static void gc_sweep_pool(void)
 #else
     gc_free_pages();
 #endif
+    gc_dump_page_utilization_data();
     gc_time_pool_end(current_sweep_full);
 }
 
diff --git a/src/gc.h b/src/gc.h
index 4830d2d123c5d..227dc5b6b7a53 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -234,6 +234,14 @@ STATIC_INLINE jl_gc_pagemeta_t *pop_lf_back(jl_gc_page_stack_t *pool) JL_NOTSAFE
     }
 }
 
+// data structures for tracking fragmentation in the pool allocator
+// #define GC_MEASURE_PAGE_FRAGMENTATION
+
+typedef struct {
+    _Atomic(size_t) n_freed_objs;
+    _Atomic(size_t) n_pages_allocd;
+} gc_fragmentation_stat_t;
+
 #ifdef _P64
 #define REGION0_PG_COUNT (1 << 16)
 #define REGION1_PG_COUNT (1 << 16)

From b1c8e120d1c73655578a557b4fbe3d6e142dadcc Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 16 Nov 2023 14:51:25 -0500
Subject: [PATCH 0266/1315] Use pkgimages for coverage & malloc tracking by
 ignoring native code in tracked packages (#52123)

---
 NEWS.md                                     |  5 ++
 base/loading.jl                             | 52 +++++++++++++++++++--
 base/util.jl                                |  3 --
 pkgimage.mk                                 |  2 -
 src/codegen.cpp                             | 12 +++--
 src/init.c                                  |  5 --
 src/jloptions.c                             |  9 ----
 src/staticdata.c                            |  6 ++-
 stdlib/Test/docs/src/index.md               | 12 +++++
 test/cmdlineargs.jl                         | 13 +++++-
 test/loading.jl                             | 44 +++++++++++++++++
 test/precompile.jl                          |  2 +-
 test/project/deps/CovTest.jl/Project.toml   |  3 ++
 test/project/deps/CovTest.jl/src/CovTest.jl | 26 +++++++++++
 14 files changed, 164 insertions(+), 30 deletions(-)
 create mode 100644 test/project/deps/CovTest.jl/Project.toml
 create mode 100644 test/project/deps/CovTest.jl/src/CovTest.jl

diff --git a/NEWS.md b/NEWS.md
index 18e7f5d87316c..30dd2e6e03783 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -23,6 +23,11 @@ Language changes
   allows users to safely tear down background state (such as closing Timers and sending
   disconnect notifications to heartbeat tasks) and cleanup other resources when the program
   wants to begin exiting.
+* Code coverage and malloc tracking is no longer generated during the package precompilation stage.
+  Further, during these modes pkgimage caches are now used for packages that are not being tracked.
+  Meaning that coverage testing (the default for `julia-actions/julia-runtest`) will by default use
+  pkgimage caches for all other packages than the package being tested, likely meaning faster test
+  execution. ([#52123])
 
 Compiler/Runtime improvements
 -----------------------------
diff --git a/base/loading.jl b/base/loading.jl
index 125e9b1302fb5..021c32b7c2654 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1044,7 +1044,21 @@ const TIMING_IMPORTS = Threads.Atomic{Int}(0)
 # these return either the array of modules loaded from the path / content given
 # or an Exception that describes why it couldn't be loaded
 # and it reconnects the Base.Docs.META
-function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{Nothing, String}, depmods::Vector{Any})
+function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{Nothing, String}, depmods::Vector{Any}, ignore_native::Union{Nothing,Bool}=nothing)
+    if isnothing(ignore_native)
+        if JLOptions().code_coverage == 0 && JLOptions().malloc_log == 0
+            ignore_native = false
+        else
+            io = open(path, "r")
+            try
+                iszero(isvalid_cache_header(io)) && return ArgumentError("Invalid header in cache file $path.")
+                _, (includes, _, _), _, _, _, _, _, _ = parse_cache_header(io, path)
+                ignore_native = pkg_tracked(includes)
+            finally
+                close(io)
+            end
+        end
+    end
     assert_havelock(require_lock)
     timing_imports = TIMING_IMPORTS[] > 0
     try
@@ -1056,7 +1070,7 @@ function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{No
 
     if ocachepath !== nothing
         @debug "Loading object cache file $ocachepath for $pkg"
-        sv = ccall(:jl_restore_package_image_from_file, Any, (Cstring, Any, Cint, Cstring), ocachepath, depmods, false, pkg.name)
+        sv = ccall(:jl_restore_package_image_from_file, Any, (Cstring, Any, Cint, Cstring, Cint), ocachepath, depmods, false, pkg.name, ignore_native)
     else
         @debug "Loading cache file $path for $pkg"
         sv = ccall(:jl_restore_incremental, Any, (Cstring, Any, Cint, Cstring), path, depmods, false, pkg.name)
@@ -1495,15 +1509,45 @@ function _tryrequire_from_serialized(modkey::PkgId, path::String, ocachepath::Un
     return loaded
 end
 
+# returns whether the package is tracked in coverage or malloc tracking based on
+# JLOptions and includes
+function pkg_tracked(includes)
+    if JLOptions().code_coverage == 0 && JLOptions().malloc_log == 0
+        return false
+    elseif JLOptions().code_coverage == 1 || JLOptions().malloc_log == 1 # user
+        # Just say true. Pkgimages aren't in Base
+        return true
+    elseif JLOptions().code_coverage == 2 || JLOptions().malloc_log == 2 # all
+        return true
+    elseif JLOptions().code_coverage == 3 || JLOptions().malloc_log == 3 # tracked path
+        if JLOptions().tracked_path == C_NULL
+            return false
+        else
+            tracked_path = unsafe_string(JLOptions().tracked_path)
+            if isempty(tracked_path)
+                return false
+            else
+                return any(includes) do inc
+                    startswith(inc.filename, tracked_path)
+                end
+            end
+        end
+    end
+end
+
 # loads a precompile cache file, ignoring stale_cachefile tests
 # load the best available (non-stale) version of all dependent modules first
 function _tryrequire_from_serialized(pkg::PkgId, path::String, ocachepath::Union{Nothing, String})
     assert_havelock(require_lock)
     local depmodnames
     io = open(path, "r")
+    ignore_native = false
     try
         iszero(isvalid_cache_header(io)) && return ArgumentError("Invalid header in cache file $path.")
-        _, _, depmodnames, _, _, _, clone_targets, _ = parse_cache_header(io, path)
+        _, (includes, _, _), depmodnames, _, _, _, clone_targets, _ = parse_cache_header(io, path)
+
+        ignore_native = pkg_tracked(includes)
+
         pkgimage = !isempty(clone_targets)
         if pkgimage
             ocachepath !== nothing || return ArgumentError("Expected ocachepath to be provided")
@@ -1529,7 +1573,7 @@ function _tryrequire_from_serialized(pkg::PkgId, path::String, ocachepath::Union
         depmods[i] = dep
     end
     # then load the file
-    return _include_from_serialized(pkg, path, ocachepath, depmods)
+    return _include_from_serialized(pkg, path, ocachepath, depmods, ignore_native)
 end
 
 # returns `nothing` if require found a precompile cache for this sourcepath, but couldn't load it
diff --git a/base/util.jl b/base/util.jl
index 6a9f219e403c0..a3771f4ae9dc4 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -242,9 +242,6 @@ function julia_cmd(julia=joinpath(Sys.BINDIR, julia_exename()); cpu_target::Unio
     end
     if opts.use_pkgimages == 0
         push!(addflags, "--pkgimages=no")
-    else
-        # If pkgimage is set, malloc_log and code_coverage should not
-        @assert opts.malloc_log == 0 && opts.code_coverage == 0
     end
     return `$julia -C$cpu_target -J$image_file $addflags`
 end
diff --git a/pkgimage.mk b/pkgimage.mk
index 0a4823b70e4a2..83c66bd94c702 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -35,12 +35,10 @@ $$(BUILDDIR)/stdlib/$1.debug.image: export JULIA_CPU_TARGET=$(JULIA_CPU_TARGET)
 
 $$(BUILDDIR)/stdlib/$1.release.image: $$($1_SRCS) $$(addsuffix .release.image,$$(addprefix $$(BUILDDIR)/stdlib/,$2)) $(build_private_libdir)/sys.$(SHLIB_EXT)
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
-	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --pkgimages=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	touch $$@
 $$(BUILDDIR)/stdlib/$1.debug.image: $$($1_SRCS) $$(addsuffix .debug.image,$$(addprefix $$(BUILDDIR)/stdlib/,$2)) $(build_private_libdir)/sys-debug.$(SHLIB_EXT)
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
-	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --pkgimages=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	touch $$@
 else
diff --git a/src/codegen.cpp b/src/codegen.cpp
index b9c796f2b3c1a..3209b076b5746 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -8450,15 +8450,19 @@ static jl_llvm_functions_t
         cursor = -1;
     };
 
+    // If a pkgimage or sysimage is being generated, disable tracking.
+    // This means sysimage build or pkgimage precompilation workloads aren't tracked.
     auto do_coverage = [&] (bool in_user_code, bool is_tracked) {
-        return (coverage_mode == JL_LOG_ALL ||
+        return (jl_generating_output() == 0 &&
+                (coverage_mode == JL_LOG_ALL ||
                 (in_user_code && coverage_mode == JL_LOG_USER) ||
-                (is_tracked && coverage_mode == JL_LOG_PATH));
+                (is_tracked && coverage_mode == JL_LOG_PATH)));
     };
     auto do_malloc_log = [&] (bool in_user_code, bool is_tracked) {
-        return (malloc_log_mode == JL_LOG_ALL ||
+        return (jl_generating_output() == 0 &&
+                (malloc_log_mode == JL_LOG_ALL ||
                 (in_user_code && malloc_log_mode == JL_LOG_USER) ||
-                (is_tracked && malloc_log_mode == JL_LOG_PATH));
+                (is_tracked && malloc_log_mode == JL_LOG_PATH)));
     };
     SmallVector<unsigned, 0> current_lineinfo, new_lineinfo;
     auto coverageVisitStmt = [&] (size_t dbg) {
diff --git a/src/init.c b/src/init.c
index 3e4bbf4e077bc..925ef0018048f 100644
--- a/src/init.c
+++ b/src/init.c
@@ -814,11 +814,6 @@ JL_DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel)
 #endif
 #endif
 
-    if ((jl_options.outputo || jl_options.outputbc || jl_options.outputasm) &&
-        (jl_options.code_coverage || jl_options.malloc_log)) {
-        jl_error("cannot generate code-coverage or track allocation information while generating a .o, .bc, or .s output file");
-    }
-
     jl_init_rand();
     jl_init_runtime_ccall();
     jl_init_tasks();
diff --git a/src/jloptions.c b/src/jloptions.c
index 13ee06b862c32..cc00e102c16b1 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -333,7 +333,6 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
     const char **cmds = NULL;
     int codecov = JL_LOG_NONE;
     int malloclog = JL_LOG_NONE;
-    int pkgimage_explicit = 0;
     int argc = *argcp;
     char **argv = *argvp;
     char *endptr;
@@ -469,7 +468,6 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                 jl_errorf("julia: invalid argument to --compiled-modules={yes|no|existing} (%s)", optarg);
             break;
         case opt_pkgimages:
-            pkgimage_explicit = 1;
             if (!strcmp(optarg,"yes"))
                 jl_options.use_pkgimages = JL_OPTIONS_USE_PKGIMAGES_YES;
             else if (!strcmp(optarg,"no"))
@@ -860,13 +858,6 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                       "This is a bug, please report it.", c);
         }
     }
-    if (codecov || malloclog) {
-        if (pkgimage_explicit && jl_options.use_pkgimages) {
-            jl_errorf("julia: Can't use --pkgimages=yes together "
-                      "with --track-allocation or --code-coverage.");
-        }
-        jl_options.use_pkgimages = 0;
-    }
     jl_options.code_coverage = codecov;
     jl_options.malloc_log = malloclog;
     int proc_args = *argcp < optind ? *argcp : optind;
diff --git a/src/staticdata.c b/src/staticdata.c
index bf9ad12cd28b6..f34f64b28e321 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -3675,7 +3675,7 @@ JL_DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len)
     JL_SIGATOMIC_END();
 }
 
-JL_DLLEXPORT jl_value_t *jl_restore_package_image_from_file(const char *fname, jl_array_t *depmods, int completeinfo, const char *pkgname)
+JL_DLLEXPORT jl_value_t *jl_restore_package_image_from_file(const char *fname, jl_array_t *depmods, int completeinfo, const char *pkgname, int ignore_native)
 {
     void *pkgimg_handle = jl_dlopen(fname, JL_RTLD_LAZY);
     if (!pkgimg_handle) {
@@ -3696,6 +3696,10 @@ JL_DLLEXPORT jl_value_t *jl_restore_package_image_from_file(const char *fname, j
 
     jl_image_t pkgimage = jl_init_processor_pkgimg(pkgimg_handle);
 
+    if (ignore_native){
+        memset(&pkgimage.fptrs, 0, sizeof(pkgimage.fptrs));
+    }
+
     jl_value_t* mod = jl_restore_incremental_from_buf(pkgimg_handle, pkgimg_data, &pkgimage, *plen, depmods, completeinfo, pkgname, false);
 
     return mod;
diff --git a/stdlib/Test/docs/src/index.md b/stdlib/Test/docs/src/index.md
index 3d133419a1792..ddb5d580ef832 100644
--- a/stdlib/Test/docs/src/index.md
+++ b/stdlib/Test/docs/src/index.md
@@ -491,3 +491,15 @@ Using `Test.jl`, more complicated tests can be added for packages but this shoul
 ```@meta
 DocTestSetup = nothing
 ```
+
+### Code Coverage
+
+Code coverage tracking during tests can be enabled using the `pkg> test --coverage` flag (or at a lower level using the
+[`--code-coverage`](@ref command-line-interface) julia arg). This is on by default in the
+[julia-runtest](https://github.com/julia-actions/julia-runtest) GitHub action.
+
+To evaluate coverage either manually inspect the `.cov` files that are generated beside the source files locally,
+or in CI use the [julia-processcoverage](https://github.com/julia-actions/julia-processcoverage) GitHub action.
+
+!!! compat "Julia 1.11"
+    Since Julia 1.11, coverage is not collected during the package precompilation phase.
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 26cee030f9110..1c90352af29c9 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -62,8 +62,19 @@ end
 
 @testset "julia_cmd" begin
     julia_basic = Base.julia_cmd()
+    function get_julia_cmd(arg)
+        io = Base.BufferStream()
+        cmd = `$julia_basic $arg -e 'print(repr(Base.julia_cmd()))'`
+        try
+            run(pipeline(cmd, stdout=io, stderr=io))
+        catch
+            @error "cmd failed" cmd read(io, String)
+            rethrow()
+        end
+        return read(io, String)
+    end
+
     opts = Base.JLOptions()
-    get_julia_cmd(arg) = strip(read(`$julia_basic $arg -e 'print(repr(Base.julia_cmd()))'`, String), ['`'])
 
     for (arg, default) in (
                             ("-C$(unsafe_string(opts.cpu_target))",  false),
diff --git a/test/loading.jl b/test/loading.jl
index efb83a6e00335..d39bdceb53341 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1333,3 +1333,47 @@ end
         @test filesize(cache_path) != cache_size
     end
 end
+
+@testset "code coverage disabled during precompilation" begin
+    mktempdir() do depot
+        cov_test_dir = joinpath(@__DIR__, "project", "deps", "CovTest.jl")
+        cov_cache_dir = joinpath(depot, "compiled", "v$(VERSION.major).$(VERSION.minor)", "CovTest")
+        function rm_cov_files()
+            for cov_file in filter(endswith(".cov"), readdir(joinpath(cov_test_dir, "src"), join=true))
+                rm(cov_file)
+            end
+            @test !cov_exists()
+        end
+        cov_exists() = !isempty(filter(endswith(".cov"), readdir(joinpath(cov_test_dir, "src"))))
+
+        rm_cov_files() # clear out any coverage files first
+        @test !cov_exists()
+
+        cd(cov_test_dir) do
+            # In our depot, precompile CovTest.jl with coverage on
+            @test success(addenv(
+                `$(Base.julia_cmd()) --startup-file=no --pkgimage=yes --code-coverage=@ --project -e 'using CovTest; exit(0)'`,
+                "JULIA_DEPOT_PATH" => depot,
+            ))
+            @test !isempty(filter(!endswith(".ji"), readdir(cov_cache_dir))) # check that object cache file(s) exists
+            @test !cov_exists()
+            rm_cov_files()
+
+            # same again but call foo(), which is in the pkgimage, and should generate coverage
+            @test success(addenv(
+                `$(Base.julia_cmd()) --startup-file=no --pkgimage=yes --code-coverage=@ --project -e 'using CovTest; foo(); exit(0)'`,
+                "JULIA_DEPOT_PATH" => depot,
+            ))
+            @test cov_exists()
+            rm_cov_files()
+
+            # same again but call bar(), which is NOT in the pkgimage, and should generate coverage
+            @test success(addenv(
+                `$(Base.julia_cmd()) --startup-file=no --pkgimage=yes --code-coverage=@ --project -e 'using CovTest; bar(); exit(0)'`,
+                "JULIA_DEPOT_PATH" => depot,
+            ))
+            @test cov_exists()
+            rm_cov_files()
+        end
+    end
+end
diff --git a/test/precompile.jl b/test/precompile.jl
index 29ca79ef5fce3..bb87e1f6b1dc7 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1778,7 +1778,7 @@ precompile_test_harness("PkgCacheInspector") do load_path
     end
 
     if ocachefile !== nothing
-        sv = ccall(:jl_restore_package_image_from_file, Any, (Cstring, Any, Cint, Cstring), ocachefile, depmods, true, "PCI")
+        sv = ccall(:jl_restore_package_image_from_file, Any, (Cstring, Any, Cint, Cstring, Cint), ocachefile, depmods, true, "PCI", false)
     else
         sv = ccall(:jl_restore_incremental, Any, (Cstring, Any, Cint, Cstring), cachefile, depmods, true, "PCI")
     end
diff --git a/test/project/deps/CovTest.jl/Project.toml b/test/project/deps/CovTest.jl/Project.toml
new file mode 100644
index 0000000000000..97fb2c7d9cfce
--- /dev/null
+++ b/test/project/deps/CovTest.jl/Project.toml
@@ -0,0 +1,3 @@
+name = "CovTest"
+uuid = "f1f4390d-b815-473a-b5dd-5af6e1d717cb"
+version = "0.1.0"
diff --git a/test/project/deps/CovTest.jl/src/CovTest.jl b/test/project/deps/CovTest.jl/src/CovTest.jl
new file mode 100644
index 0000000000000..bd172fc3a00f4
--- /dev/null
+++ b/test/project/deps/CovTest.jl/src/CovTest.jl
@@ -0,0 +1,26 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+module CovTest
+
+function foo()
+    x = 1
+    y = 2
+    z = x * y
+    return z
+end
+
+function bar()
+    x = 1
+    y = 2
+    z = x * y
+    return z
+end
+
+if Base.generating_output()
+    # precompile foo but not bar
+    foo()
+end
+
+export foo, bar
+
+end #module

From f26947b4f5aee73135581bb14290c1c00102b8e3 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Thu, 16 Nov 2023 23:09:09 -0300
Subject: [PATCH 0267/1315] cap the number of GC threads to number of cpu cores
 (#52192)

---
 src/threading.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/threading.c b/src/threading.c
index 18c502cf94387..e20e7cbf80f26 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -681,6 +681,7 @@ void jl_init_threading(void)
         }
     }
 
+    int cpu = jl_cpu_threads();
     jl_n_markthreads = jl_options.nmarkthreads - 1;
     jl_n_sweepthreads = jl_options.nsweepthreads;
     if (jl_n_markthreads == -1) { // --gcthreads not specified
@@ -709,8 +710,20 @@ void jl_init_threading(void)
             else {
                 jl_n_markthreads = (nthreads / 2) - 1;
             }
+            // if `--gcthreads` or ENV[NUM_GCTHREADS_NAME] was not specified,
+            // cap the number of threads that may run the mark phase to
+            // the number of CPU cores
+            if (jl_n_markthreads + 1 >= cpu) {
+                jl_n_markthreads = cpu - 1;
+            }
         }
     }
+    // warn the user if they try to run with a number
+    // of GC threads which is larger than the number
+    // of physical cores
+    if (jl_n_markthreads + 1 > cpu) {
+        jl_safe_printf("WARNING: running Julia with %d GC threads on %d CPU cores\n", jl_n_markthreads + 1, cpu);
+    }
     int16_t ngcthreads = jl_n_markthreads + jl_n_sweepthreads;
 
     jl_all_tls_states_size = nthreads + nthreadsi + ngcthreads;

From 1cb85ad3fb1ba32e18be9be67775d1b36dc27079 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 17 Nov 2023 03:41:28 +0100
Subject: [PATCH 0268/1315] Revert "Support sorting iterators (#46104)"
 (#52010)

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/sort.jl               | 43 ++------------------------------------
 stdlib/REPL/src/docview.jl |  2 +-
 test/sorting.jl            | 36 -------------------------------
 3 files changed, 3 insertions(+), 78 deletions(-)

diff --git a/base/sort.jl b/base/sort.jl
index f35add7a55b35..90b43c040d969 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -5,8 +5,7 @@ module Sort
 using Base.Order
 
 using Base: copymutable, midpoint, require_one_based_indexing, uinttype,
-    sub_with_overflow, add_with_overflow, OneTo, BitSigned, BitIntegerType, top_set_bit,
-    IteratorSize, HasShape, IsInfinite, tail
+    sub_with_overflow, add_with_overflow, OneTo, BitSigned, BitIntegerType, top_set_bit
 
 import Base:
     sort,
@@ -1474,12 +1473,6 @@ end
 
 Variant of [`sort!`](@ref) that returns a sorted copy of `v` leaving `v` itself unmodified.
 
-Returns something [`similar`](@ref) to `v` when `v` is an `AbstractArray` and uses
-[`collect`](@ref) to support arbitrary non-`AbstractArray` iterables.
-
-!!! compat "Julia 1.10"
-    `sort` of arbitrary iterables requires at least Julia 1.10.
-
 # Examples
 ```jldoctest
 julia> v = [3, 1, 2];
@@ -1497,39 +1490,7 @@ julia> v
  2
 ```
 """
-function sort(v; kws...)
-    size = IteratorSize(v)
-    size == HasShape{0}() && throw(ArgumentError("$v cannot be sorted"))
-    size == IsInfinite() && throw(ArgumentError("infinite iterator $v cannot be sorted"))
-    sort!(collect(v); kws...)
-end
-sort(v::AbstractVector; kws...) = sort!(copymutable(v); kws...) # for method disambiguation
-sort(::AbstractString; kws...) =
-    throw(ArgumentError("sort(::AbstractString) is not supported"))
-sort(::Tuple; kws...) =
-    throw(ArgumentError("sort(::Tuple) is only supported for NTuples"))
-
-function sort(x::NTuple{N}; lt::Function=isless, by::Function=identity,
-              rev::Union{Bool,Nothing}=nothing, order::Ordering=Forward) where N
-    o = ord(lt,by,rev,order)
-    if N > 9
-        v = sort!(collect(x), DEFAULT_STABLE, o)
-        tuple((v[i] for i in 1:N)...)
-    else
-        _sort(x, o)
-    end
-end
-_sort(x::Union{NTuple{0}, NTuple{1}}, o::Ordering) = x
-function _sort(x::NTuple, o::Ordering)
-    a, b = Base.IteratorsMD.split(x, Val(length(x)>>1))
-    merge(_sort(a, o), _sort(b, o), o)
-end
-merge(x::NTuple, y::NTuple{0}, o::Ordering) = x
-merge(x::NTuple{0}, y::NTuple, o::Ordering) = y
-merge(x::NTuple{0}, y::NTuple{0}, o::Ordering) = x # Method ambiguity
-merge(x::NTuple, y::NTuple, o::Ordering) =
-    (lt(o, y[1], x[1]) ? (y[1], merge(x, tail(y), o)...) : (x[1], merge(tail(x), y, o)...))
-
+sort(v::AbstractVector; kws...) = sort!(copymutable(v); kws...)
 
 ## partialsortperm: the permutation to sort the first k elements of an array ##
 
diff --git a/stdlib/REPL/src/docview.jl b/stdlib/REPL/src/docview.jl
index 8551c5f38fcd3..41f3020447090 100644
--- a/stdlib/REPL/src/docview.jl
+++ b/stdlib/REPL/src/docview.jl
@@ -184,7 +184,7 @@ log_nonpublic_access(expr, ::Module, _) = expr
 
 function insert_internal_warning(md::Markdown.MD, internal_access::Set{Pair{Module,Symbol}})
     if !isempty(internal_access)
-        items = Any[Any[Markdown.Paragraph(Any[Markdown.Code("", s)])] for s in sort("$mod.$sym" for (mod, sym) in internal_access)]
+        items = Any[Any[Markdown.Paragraph(Any[Markdown.Code("", s)])] for s in sort!(["$mod.$sym" for (mod, sym) in internal_access])]
         admonition = Markdown.Admonition("warning", "Warning", Any[
             Markdown.Paragraph(Any["The following bindings may be internal; they may change or be removed in future versions:"]),
             Markdown.List(items, -1, false)])
diff --git a/test/sorting.jl b/test/sorting.jl
index 9cb5d717635c9..bb0fd3cc6392e 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -88,20 +88,6 @@ end
         vcat(2000, (x:x+99 for x in 1900:-100:100)..., 1:99)
 end
 
-function tuple_sort_test(x)
-    @test issorted(sort(x))
-    length(x) > 9 && return # length > 9 uses a vector fallback
-    @test 0 == @allocated sort(x)
-end
-@testset "sort(::NTuple)" begin
-    @test sort((9,8,3,3,6,2,0,8)) == (0,2,3,3,6,8,8,9)
-    @test sort((9,8,3,3,6,2,0,8), by=x->x÷3) == (2,0,3,3,8,6,8,9)
-    for i in 1:40
-        tuple_sort_test(tuple(rand(i)...))
-    end
-    @test_throws ArgumentError sort((1,2,3.0))
-end
-
 @testset "partialsort" begin
     @test partialsort([3,6,30,1,9],3) == 6
     @test partialsort([3,6,30,1,9],3:4) == [6,9]
@@ -544,28 +530,6 @@ end
     @test isequal(a, [8,6,7,NaN,5,3,0,9])
 end
 
-@testset "sort!(iterable)" begin
-    gen = (x % 7 + 0.1x for x in 1:50)
-    @test sort(gen) == sort!(collect(gen))
-    gen = (x % 7 + 0.1y for x in 1:10, y in 1:5)
-    @test sort(gen; dims=1) == sort!(collect(gen); dims=1)
-    @test sort(gen; dims=2) == sort!(collect(gen); dims=2)
-
-    @test_throws ArgumentError("dimension out of range") sort(gen; dims=3)
-
-    @test_throws UndefKeywordError(:dims) sort(gen)
-    @test_throws UndefKeywordError(:dims) sort(collect(gen))
-    @test_throws UndefKeywordError(:dims) sort!(collect(gen))
-
-    @test_throws ArgumentError sort("string")
-    @test_throws ArgumentError("1 cannot be sorted") sort(1)
-
-    @test sort(Set((1, 3, 6))) == [1, 3, 6]
-    @test sort(Dict((1=>9, 3=>2, 6=>5))) == [1=>9, 3=>2, 6=>5]
-    @test sort(keys(Dict((1=>2, 3=>5, 6=>9)))) == [1, 3, 6]
-    @test sort(values(Dict((1=>9, 3=>2, 6=>5)))) == [2, 5, 9]
-end
-
 @testset "sort!(::AbstractVector{<:Integer}) with short int range" begin
     a = view([9:-1:0;], :)::SubArray
     sort!(a)

From a65bc9a267837fcf9813bef2fc6eb79d02e25ea5 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 16 Nov 2023 21:55:10 -0500
Subject: [PATCH 0269/1315] jitlayers: replace sharedbytes intern pool with one
 that respects alignment (#52182)

The llvm optimizations may increase alignment beyond the initial
MAX_ALIGN. This pool's alignment was previously only `sizeof(struct {
atomic<int> RefCount; size_t Length; char Data[]; })` however,
potentially resulting in segfaults at runtime.

Fixes #52118. Should make CI much happier.
---
 src/gc.c             |  3 +--
 src/jitlayers.cpp    | 21 +++++++++++++++------
 src/jitlayers.h      | 43 +++++++++++++++++++++++++++++++++++++++++++
 src/julia_internal.h |  2 +-
 4 files changed, 60 insertions(+), 9 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 6860871587952..c68d4e92f9f57 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -4099,8 +4099,7 @@ static void *gc_perm_alloc_large(size_t sz, int zero, unsigned align, unsigned o
     errno = last_errno;
     jl_may_leak(base);
     assert(align > 0);
-    unsigned diff = (offset - (uintptr_t)base) % align;
-    return (void*)((char*)base + diff);
+    return (void*)(LLT_ALIGN((uintptr_t)base + offset, (uintptr_t)align) - offset);
 }
 
 STATIC_INLINE void *gc_try_perm_alloc_pool(size_t sz, unsigned align, unsigned offset) JL_NOTSAFEPOINT
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index a22a5d8a6a264..2de5455903375 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1410,10 +1410,12 @@ namespace {
 
     struct JITPointersT {
 
-        JITPointersT(orc::ExecutionSession &ES) JL_NOTSAFEPOINT : ES(ES) {}
+        JITPointersT(SharedBytesT &SharedBytes, std::mutex &Lock) JL_NOTSAFEPOINT
+            : SharedBytes(SharedBytes), Lock(Lock) {}
 
         Expected<orc::ThreadSafeModule> operator()(orc::ThreadSafeModule TSM, orc::MaterializationResponsibility &R) JL_NOTSAFEPOINT {
             TSM.withModuleDo([&](Module &M) JL_NOTSAFEPOINT {
+                std::lock_guard<std::mutex> locked(Lock);
                 for (auto &GV : make_early_inc_range(M.globals())) {
                     if (auto *Shared = getSharedBytes(GV)) {
                         ++InternedGlobals;
@@ -1429,10 +1431,11 @@ namespace {
             return std::move(TSM);
         }
 
+    private:
         // optimize memory by turning long strings into memoized copies, instead of
         // making a copy per object file of output.
-        // we memoize them using the ExecutionSession's string pool;
-        // this makes it unsafe to call clearDeadEntries() on the pool.
+        // we memoize them using a StringSet with a custom-alignment allocator
+        // to ensure they are properly aligned
         Constant *getSharedBytes(GlobalVariable &GV) JL_NOTSAFEPOINT {
             // We could probably technically get away with
             // interning even external linkage globals,
@@ -1458,11 +1461,17 @@ namespace {
                 // Cutoff, since we don't want to intern small strings
                 return nullptr;
             }
-            auto Interned = *ES.intern(Data);
+            Align Required = GV.getAlign().valueOrOne();
+            Align Preferred = MaxAlignedAlloc::alignment(Data.size());
+            if (Required > Preferred)
+                return nullptr;
+            StringRef Interned = SharedBytes.insert(Data).first->getKey();
+            assert(llvm::isAddrAligned(Preferred, Interned.data()));
             return literal_static_pointer_val(Interned.data(), GV.getType());
         }
 
-        orc::ExecutionSession &ES;
+        SharedBytesT &SharedBytes;
+        std::mutex &Lock;
     };
 }
 
@@ -1696,7 +1705,7 @@ JuliaOJIT::JuliaOJIT()
 #endif
     LockLayer(ObjectLayer),
     CompileLayer(ES, LockLayer, std::make_unique<CompilerT<N_optlevels>>(orc::irManglingOptionsFromTargetOptions(TM->Options), *TM)),
-    JITPointersLayer(ES, CompileLayer, orc::IRTransformLayer::TransformFunction(JITPointersT(ES))),
+    JITPointersLayer(ES, CompileLayer, orc::IRTransformLayer::TransformFunction(JITPointersT(SharedBytes, RLST_mutex))),
     OptimizeLayer(ES, JITPointersLayer, orc::IRTransformLayer::TransformFunction(OptimizerT<N_optlevels>(*TM, PrintLLVMTimers))),
     OptSelLayer(ES, OptimizeLayer, orc::IRTransformLayer::TransformFunction(selectOptLevel)),
     DepsVerifyLayer(ES, OptSelLayer, orc::IRTransformLayer::TransformFunction(validateExternRelocations)),
diff --git a/src/jitlayers.h b/src/jitlayers.h
index 016f97b92140b..85cbb2cf8ec28 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -1,6 +1,8 @@
 // This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include <llvm/ADT/MapVector.h>
+#include <llvm/ADT/StringSet.h>
+#include <llvm/Support/AllocatorBase.h>
 
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Constants.h>
@@ -292,6 +294,44 @@ static const inline char *name_from_method_instance(jl_method_instance_t *li) JL
     return jl_is_method(li->def.method) ? jl_symbol_name(li->def.method->name) : "top-level scope";
 }
 
+template <size_t offset = 0>
+class MaxAlignedAllocImpl
+    : public AllocatorBase<MaxAlignedAllocImpl<offset>> {
+
+public:
+    MaxAlignedAllocImpl() JL_NOTSAFEPOINT = default;
+
+    static Align alignment(size_t Size) JL_NOTSAFEPOINT {
+        // Define the maximum alignment we expect to require, from offset bytes off
+        // the returned pointer, this is >= alignof(std::max_align_t), which is too
+        // small often to actually use.
+        const size_t MaxAlignment = JL_CACHE_BYTE_ALIGNMENT;
+        return Align(std::min((size_t)llvm::PowerOf2Ceil(Size), MaxAlignment));
+    }
+
+    LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, Align Alignment) {
+        Align MaxAlign = alignment(Size);
+        assert(Alignment < MaxAlign); (void)Alignment;
+        return jl_gc_perm_alloc(Size, 0, MaxAlign.value(), offset);
+    }
+
+    inline LLVM_ATTRIBUTE_RETURNS_NONNULL
+    void * Allocate(size_t Size, size_t Alignment) {
+        return Allocate(Size, Align(Alignment));
+    }
+
+    // Pull in base class overloads.
+    using AllocatorBase<MaxAlignedAllocImpl>::Allocate;
+
+    void Deallocate(const void *Ptr, size_t Size, size_t /*Alignment*/) { abort(); }
+
+    // Pull in base class overloads.
+    using AllocatorBase<MaxAlignedAllocImpl>::Deallocate;
+
+private:
+};
+using MaxAlignedAlloc = MaxAlignedAllocImpl<>;
+
 typedef JITSymbol JL_JITSymbol;
 // The type that is similar to SymbolInfo on LLVM 4.0 is actually
 // `JITEvaluatedSymbol`. However, we only use this type when a JITSymbol
@@ -300,6 +340,7 @@ typedef JITSymbol JL_SymbolInfo;
 
 using CompilerResultT = Expected<std::unique_ptr<llvm::MemoryBuffer>>;
 using OptimizerResultT = Expected<orc::ThreadSafeModule>;
+using SharedBytesT = StringSet<MaxAlignedAllocImpl<sizeof(StringSet<>::MapEntryTy)>>;
 
 class JuliaOJIT {
 public:
@@ -516,6 +557,7 @@ class JuliaOJIT {
 
     // Note that this is a safepoint due to jl_get_library_ and jl_dlsym calls
     void optimizeDLSyms(Module &M);
+
 private:
 
     const std::unique_ptr<TargetMachine> TM;
@@ -529,6 +571,7 @@ class JuliaOJIT {
     std::mutex RLST_mutex{};
     int RLST_inc = 0;
     DenseMap<void*, std::string> ReverseLocalSymbolTable;
+    SharedBytesT SharedBytes;
 
     std::unique_ptr<DLSymOptimizer> DLSymOpt;
 
diff --git a/src/julia_internal.h b/src/julia_internal.h
index ad3e46cd6307e..c09b73f8a1052 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -349,7 +349,7 @@ JL_DLLEXPORT int jl_gc_classify_pools(size_t sz, int *osize) JL_NOTSAFEPOINT;
 extern uv_mutex_t gc_perm_lock;
 void *jl_gc_perm_alloc_nolock(size_t sz, int zero,
     unsigned align, unsigned offset) JL_NOTSAFEPOINT;
-void *jl_gc_perm_alloc(size_t sz, int zero,
+JL_DLLEXPORT void *jl_gc_perm_alloc(size_t sz, int zero,
     unsigned align, unsigned offset) JL_NOTSAFEPOINT;
 void gc_sweep_sysimg(void);
 

From 29be3ef88c0e4e093c6563f50237c37d5ab14a39 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Fri, 17 Nov 2023 08:21:50 -0500
Subject: [PATCH 0270/1315] Move heap_size batching code into pair of functions
 (#51611)

Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com>
---
 src/gc.c         | 126 ++++++++++++++++-------------------------------
 src/staticdata.c |  11 ++---
 2 files changed, 47 insertions(+), 90 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index c68d4e92f9f57..bc0361c8ac7a8 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -700,6 +700,7 @@ static uint64_t gc_end_time = 0;
 static int thrash_counter = 0;
 static int thrashing = 0;
 // global variables for GC stats
+static uint64_t freed_in_runtime = 0;
 
 // Resetting the object to a young object, this is used when marking the
 // finalizer list to collect them the next time because the object is very
@@ -1005,6 +1006,22 @@ static void sweep_weak_refs(void)
 }
 
 
+STATIC_INLINE void jl_batch_accum_heap_size(jl_ptls_t ptls, uint64_t sz) JL_NOTSAFEPOINT
+{
+    uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc) + sz;
+    if (alloc_acc < 16*1024)
+        jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, alloc_acc);
+    else {
+        jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, alloc_acc);
+        jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
+    }
+}
+
+STATIC_INLINE void jl_batch_accum_free_size(jl_ptls_t ptls, uint64_t sz) JL_NOTSAFEPOINT
+{
+    jl_atomic_store_relaxed(&ptls->gc_num.free_acc, jl_atomic_load_relaxed(&ptls->gc_num.free_acc) + sz);
+}
+
 // big value list
 
 // Size includes the tag and the tag is not cleared!!
@@ -1027,13 +1044,7 @@ STATIC_INLINE jl_value_t *jl_gc_big_alloc_inner(jl_ptls_t ptls, size_t sz)
         jl_atomic_load_relaxed(&ptls->gc_num.allocd) + allocsz);
     jl_atomic_store_relaxed(&ptls->gc_num.bigalloc,
         jl_atomic_load_relaxed(&ptls->gc_num.bigalloc) + 1);
-    uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
-    if (alloc_acc + allocsz < 16*1024)
-        jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, alloc_acc + allocsz);
-    else {
-        jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, alloc_acc + allocsz);
-        jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
-    }
+    jl_batch_accum_heap_size(ptls, allocsz);
 #ifdef MEMDEBUG
     memset(v, 0xee, allocsz);
 #endif
@@ -1147,16 +1158,10 @@ void jl_gc_count_allocd(size_t sz) JL_NOTSAFEPOINT
     jl_ptls_t ptls = jl_current_task->ptls;
     jl_atomic_store_relaxed(&ptls->gc_num.allocd,
         jl_atomic_load_relaxed(&ptls->gc_num.allocd) + sz);
-        uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
-    if (alloc_acc + sz < 16*1024)
-        jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, alloc_acc + sz);
-    else {
-        jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, alloc_acc + sz);
-        jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
-    }
+    jl_batch_accum_heap_size(ptls, sz);
 }
-
-static void combine_thread_gc_counts(jl_gc_num_t *dest) JL_NOTSAFEPOINT
+// Only safe to update the heap inside the GC
+static void combine_thread_gc_counts(jl_gc_num_t *dest, int update_heap) JL_NOTSAFEPOINT
 {
     int gc_n_threads;
     jl_ptls_t* gc_all_tls_states;
@@ -1170,12 +1175,14 @@ static void combine_thread_gc_counts(jl_gc_num_t *dest) JL_NOTSAFEPOINT
             dest->realloc += jl_atomic_load_relaxed(&ptls->gc_num.realloc);
             dest->poolalloc += jl_atomic_load_relaxed(&ptls->gc_num.poolalloc);
             dest->bigalloc += jl_atomic_load_relaxed(&ptls->gc_num.bigalloc);
-            uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
-            uint64_t free_acc = jl_atomic_load_relaxed(&ptls->gc_num.free_acc);
             dest->freed += jl_atomic_load_relaxed(&ptls->gc_num.free_acc);
-            jl_atomic_store_relaxed(&gc_heap_stats.heap_size, alloc_acc - free_acc + jl_atomic_load_relaxed(&gc_heap_stats.heap_size));
-            jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
-            jl_atomic_store_relaxed(&ptls->gc_num.free_acc, 0);
+            if (update_heap) {
+                uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
+                freed_in_runtime += jl_atomic_load_relaxed(&ptls->gc_num.free_acc);
+                jl_atomic_store_relaxed(&gc_heap_stats.heap_size, alloc_acc + jl_atomic_load_relaxed(&gc_heap_stats.heap_size));
+                jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
+                jl_atomic_store_relaxed(&ptls->gc_num.free_acc, 0);
+            }
         }
     }
 }
@@ -1209,7 +1216,7 @@ static int64_t inc_live_bytes(int64_t inc) JL_NOTSAFEPOINT
 
 void jl_gc_reset_alloc_count(void) JL_NOTSAFEPOINT
 {
-    combine_thread_gc_counts(&gc_num);
+    combine_thread_gc_counts(&gc_num, 0);
     inc_live_bytes(gc_num.deferred_alloc + gc_num.allocd);
     gc_num.allocd = 0;
     gc_num.deferred_alloc = 0;
@@ -3176,7 +3183,7 @@ JL_DLLEXPORT int jl_gc_is_enabled(void)
 JL_DLLEXPORT void jl_gc_get_total_bytes(int64_t *bytes) JL_NOTSAFEPOINT
 {
     jl_gc_num_t num = gc_num;
-    combine_thread_gc_counts(&num);
+    combine_thread_gc_counts(&num, 0);
     // Sync this logic with `base/util.jl:GC_Diff`
     *bytes = (num.total_allocd + num.deferred_alloc + num.allocd);
 }
@@ -3189,7 +3196,7 @@ JL_DLLEXPORT uint64_t jl_gc_total_hrtime(void)
 JL_DLLEXPORT jl_gc_num_t jl_gc_num(void)
 {
     jl_gc_num_t num = gc_num;
-    combine_thread_gc_counts(&num);
+    combine_thread_gc_counts(&num, 0);
     return num;
 }
 
@@ -3248,7 +3255,7 @@ size_t jl_maxrss(void);
 // Only one thread should be running in this function
 static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
 {
-    combine_thread_gc_counts(&gc_num);
+    combine_thread_gc_counts(&gc_num, 1);
 
     // We separate the update of the graph from the update of live_bytes here
     // so that the sweep shows a downward trend in memory usage.
@@ -3432,6 +3439,8 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
         gc_num.last_incremental_sweep = gc_end_time;
     }
 
+    jl_atomic_store_relaxed(&gc_heap_stats.heap_size, jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - freed_in_runtime);
+    freed_in_runtime = 0;
     size_t heap_size = jl_atomic_load_relaxed(&gc_heap_stats.heap_size);
     double target_allocs = 0.0;
     double min_interval = default_collect_interval;
@@ -3780,13 +3789,7 @@ JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz)
             jl_atomic_load_relaxed(&ptls->gc_num.allocd) + sz);
         jl_atomic_store_relaxed(&ptls->gc_num.malloc,
             jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1);
-        uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
-        if (alloc_acc + sz < 16*1024)
-            jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, alloc_acc + sz);
-        else {
-            jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, alloc_acc + sz);
-            jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
-        }
+        jl_batch_accum_heap_size(ptls, sz);
     }
     return data;
 }
@@ -3803,13 +3806,7 @@ JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz)
             jl_atomic_load_relaxed(&ptls->gc_num.allocd) + nm*sz);
         jl_atomic_store_relaxed(&ptls->gc_num.malloc,
             jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1);
-        uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
-        if (alloc_acc + sz < 16*1024)
-            jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, alloc_acc + sz * nm);
-        else {
-            jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, alloc_acc + sz * nm);
-            jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
-        }
+        jl_batch_accum_heap_size(ptls, sz * nm);
     }
     return data;
 }
@@ -3820,14 +3817,7 @@ JL_DLLEXPORT void jl_gc_counted_free_with_size(void *p, size_t sz)
     jl_task_t *ct = jl_current_task;
     free(p);
     if (pgcstack != NULL && ct->world_age) {
-        jl_ptls_t ptls = ct->ptls;
-        uint64_t free_acc = jl_atomic_load_relaxed(&ptls->gc_num.free_acc);
-        if (free_acc + sz < 16*1024)
-            jl_atomic_store_relaxed(&ptls->gc_num.free_acc, free_acc + sz);
-        else {
-            jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, -(free_acc + sz));
-            jl_atomic_store_relaxed(&ptls->gc_num.free_acc, 0);
-        }
+        jl_batch_accum_free_size(ct->ptls, sz);
     }
 }
 
@@ -3847,23 +3837,10 @@ JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size
 
         int64_t diff = sz - old;
         if (diff < 0) {
-            diff = -diff;
-            uint64_t free_acc = jl_atomic_load_relaxed(&ptls->gc_num.free_acc);
-            if (free_acc + diff < 16*1024)
-                jl_atomic_store_relaxed(&ptls->gc_num.free_acc, free_acc + diff);
-            else {
-                jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, -(free_acc + diff));
-                jl_atomic_store_relaxed(&ptls->gc_num.free_acc, 0);
-            }
+            jl_batch_accum_free_size(ptls, -diff);
         }
         else {
-            uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
-            if (alloc_acc + diff < 16*1024)
-                jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, alloc_acc + diff);
-            else {
-                jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, alloc_acc + diff);
-                jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
-            }
+            jl_batch_accum_heap_size(ptls, diff);
         }
     }
     return data;
@@ -3948,13 +3925,7 @@ JL_DLLEXPORT void *jl_gc_managed_malloc(size_t sz)
         jl_atomic_load_relaxed(&ptls->gc_num.allocd) + allocsz);
     jl_atomic_store_relaxed(&ptls->gc_num.malloc,
         jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1);
-    uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
-    if (alloc_acc + allocsz < 16*1024)
-        jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, alloc_acc + allocsz);
-    else {
-        jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, alloc_acc + allocsz);
-        jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
-    }
+    jl_batch_accum_heap_size(ptls, allocsz);
 #ifdef _OS_WINDOWS_
     SetLastError(last_error);
 #endif
@@ -4002,23 +3973,10 @@ static void *gc_managed_realloc_(jl_ptls_t ptls, void *d, size_t sz, size_t olds
 
     int64_t diff = allocsz - oldsz;
     if (diff < 0) {
-        diff = -diff;
-        uint64_t free_acc = jl_atomic_load_relaxed(&ptls->gc_num.free_acc);
-        if (free_acc + diff < 16*1024)
-            jl_atomic_store_relaxed(&ptls->gc_num.free_acc, free_acc + diff);
-        else {
-            jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, -(free_acc + diff));
-            jl_atomic_store_relaxed(&ptls->gc_num.free_acc, 0);
-        }
+        jl_batch_accum_free_size(ptls, -diff);
     }
     else {
-        uint64_t alloc_acc = jl_atomic_load_relaxed(&ptls->gc_num.alloc_acc);
-        if (alloc_acc + diff < 16*1024)
-            jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, alloc_acc + diff);
-        else {
-            jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, alloc_acc + diff);
-            jl_atomic_store_relaxed(&ptls->gc_num.alloc_acc, 0);
-        }
+        jl_batch_accum_heap_size(ptls, diff);
     }
     if (allocsz > oldsz) {
         maybe_record_alloc_to_profile((jl_value_t*)b, allocsz - oldsz, (jl_datatype_t*)jl_buff_tag);
diff --git a/src/staticdata.c b/src/staticdata.c
index f34f64b28e321..42a5fdb63b63e 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -71,7 +71,6 @@ External links:
 */
 #include <stdlib.h>
 #include <string.h>
-#include <stdbool.h>
 #include <stdio.h> // printf
 #include <inttypes.h> // PRIxPTR
 
@@ -3522,7 +3521,7 @@ static jl_value_t *jl_validate_cache_file(ios_t *f, jl_array_t *depmods, uint64_
 }
 
 // TODO?: refactor to make it easier to create the "package inspector"
-static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, ios_t *f, jl_image_t *image, jl_array_t *depmods, int completeinfo, const char *pkgname, bool needs_permalloc)
+static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, ios_t *f, jl_image_t *image, jl_array_t *depmods, int completeinfo, const char *pkgname, int needs_permalloc)
 {
     JL_TIMING(LOAD_IMAGE, LOAD_Pkgimg);
     jl_timing_printf(JL_TIMING_DEFAULT_BLOCK, pkgname);
@@ -3548,7 +3547,7 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
         JL_SIGATOMIC_BEGIN();
         size_t len = dataendpos - datastartpos;
         char *sysimg;
-        bool success = !needs_permalloc;
+        int success = !needs_permalloc;
         ios_seek(f, datastartpos);
         if (needs_permalloc)
             sysimg = (char*)jl_gc_perm_alloc(len, 0, 64, 0);
@@ -3608,7 +3607,7 @@ static void jl_restore_system_image_from_stream(ios_t *f, jl_image_t *image, uin
     jl_restore_system_image_from_stream_(f, image, NULL, checksum | ((uint64_t)0xfdfcfbfa << 32), NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
-JL_DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(void* pkgimage_handle, const char *buf, jl_image_t *image, size_t sz, jl_array_t *depmods, int completeinfo, const char *pkgname, bool needs_permalloc)
+JL_DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(void* pkgimage_handle, const char *buf, jl_image_t *image, size_t sz, jl_array_t *depmods, int completeinfo, const char *pkgname, int needs_permalloc)
 {
     ios_t f;
     ios_static_buffer(&f, (char*)buf, sz);
@@ -3625,7 +3624,7 @@ JL_DLLEXPORT jl_value_t *jl_restore_incremental(const char *fname, jl_array_t *d
             "Cache file \"%s\" not found.\n", fname);
     }
     jl_image_t pkgimage = {};
-    jl_value_t *ret = jl_restore_package_image_from_stream(NULL, &f, &pkgimage, depmods, completeinfo, pkgname, true);
+    jl_value_t *ret = jl_restore_package_image_from_stream(NULL, &f, &pkgimage, depmods, completeinfo, pkgname, 1);
     ios_close(&f);
     return ret;
 }
@@ -3700,7 +3699,7 @@ JL_DLLEXPORT jl_value_t *jl_restore_package_image_from_file(const char *fname, j
         memset(&pkgimage.fptrs, 0, sizeof(pkgimage.fptrs));
     }
 
-    jl_value_t* mod = jl_restore_incremental_from_buf(pkgimg_handle, pkgimg_data, &pkgimage, *plen, depmods, completeinfo, pkgname, false);
+    jl_value_t* mod = jl_restore_incremental_from_buf(pkgimg_handle, pkgimg_data, &pkgimage, *plen, depmods, completeinfo, pkgname, 0);
 
     return mod;
 }

From f1f84a2bfd735f8d05f71899b65eee49afc8c5cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Fri, 17 Nov 2023 14:23:49 +0000
Subject: [PATCH 0271/1315] [OpenBLAS_jll] Upgrade to v0.3.25 (#52178)

See the [release notes of
v0.3.25](https://github.com/OpenMathLib/OpenBLAS/releases/tag/v0.3.25).

Usual memo to self for the upgrade:

* update version number in `stdlib/OpenBLAS_jll/Project.toml`
* run `make -f contrib/refresh_checksums.mk -j openblas` to update the
checksums
* update version number and commit hash in `deps/openblas.version`
---
 deps/checksums/openblas          | 184 +++++++++++++++----------------
 deps/openblas.version            |   6 +-
 stdlib/OpenBLAS_jll/Project.toml |   2 +-
 3 files changed, 96 insertions(+), 96 deletions(-)

diff --git a/deps/checksums/openblas b/deps/checksums/openblas
index 9e11a478e7427..b49af255be0e7 100644
--- a/deps/checksums/openblas
+++ b/deps/checksums/openblas
@@ -1,94 +1,94 @@
-OpenBLAS.v0.3.24+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/9b52215f0729a2d96bc86a820c280433
-OpenBLAS.v0.3.24+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/b772022a498075f1712e707ed394583af49a25db60bce9d59981827f3d82968e5ddbbd05394c791ce89595b4c2442330870c3a36739e5511a99f166c2805b3ae
-OpenBLAS.v0.3.24+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/d89ee1bb7ebefe186c02354209d60e94
-OpenBLAS.v0.3.24+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/ed8178b62bacf8aefe094adb822cfda4cb696161ca712b7b70c635b1f7868d84c2912880010465cb6ba00632e25b3bdcdb9f1bab9307ccb7bf1d7eb7a2a760c7
-OpenBLAS.v0.3.24+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/271a15b5d77c1501b13934702e0bea3d
-OpenBLAS.v0.3.24+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/f2dfb1478471870526c3b8a2b8173eb4705b2dcb7e2c8b4fd4acebe24f4bdc999262e998f832a6769a5def4577256b07f4aa76c058abf7e93ea5e814a74d014d
-OpenBLAS.v0.3.24+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/7c47ee25fade4bf4d4fcbd9b8e5feea7
-OpenBLAS.v0.3.24+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/b92e08f527c30d74470e1fa8275dfa6f8ce6bdae028394fc1440a55e4b1ddd15d8ab14bf36b87cf400ee22a69c13ce9b78c22889dccb5ffc4945c5293deea445
-OpenBLAS.v0.3.24+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/2c00dd0f2d0e8e3938e02e21ad4fcbed
-OpenBLAS.v0.3.24+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/e61635827d9495bbbe8726a3d7803c786b9304dbb32ba3d99ac5a359ae827b6e48e0db7ffa3fc2279d65e2cda3ca96abccdbcdd86b54e962cc8b7f86937e9594
-OpenBLAS.v0.3.24+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/35297e1b32247edeb41907fca6f18a0a
-OpenBLAS.v0.3.24+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/b8277b5f07b29940f5893f44af4fec3278c8cb7e52db7fb7f416ffe644d47f781d98f8d9fef89dea623762473e78abe61977eff1f4c3f1c9ff44dd833430f897
-OpenBLAS.v0.3.24+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/ce187d3e01cfa633421567c2c5d18509
-OpenBLAS.v0.3.24+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/408106528aa80ea68808d99544ff4e6485d5912bf7e2586936c0e7758d94a53705388077140b8335714cd75772ef9d5465fa629fdac6939268ba11617076c42d
-OpenBLAS.v0.3.24+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/52a7f29bfe47e89f32b5c95f6ce65c29
-OpenBLAS.v0.3.24+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/4816b3e022613b6a7a2073dd292311b29d8e848887f4d0ed7bcf32140bce2e9f15e05d754c48c1575cbaf70fcae8cfec501725df15d6bb1c7ac1ac1c74b59489
-OpenBLAS.v0.3.24+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/6f4aa76cc544ce52da6aa094ee5a1aeb
-OpenBLAS.v0.3.24+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/c3428c36e19e9bd89dd0eb809f2617b7f90cbfaadffe9c58bf16c319e5e36d07102f48bafeb7a787bb6a18655ba3688a29ccd4f3724bc9354915d7e55fb64d44
-OpenBLAS.v0.3.24+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/298a83c0550694b3b6c22f6dd460cc9d
-OpenBLAS.v0.3.24+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/b8e5ac5304364c950a427384db13ed5c573e7b5e9d16bb7c354b7b5e46ca8e7471bc911a2cf9defbfc933fbfbff315949011b5596532b8863c551de6d543f434
-OpenBLAS.v0.3.24+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/2b584ae3aa496ff871cc735242e63cf4
-OpenBLAS.v0.3.24+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/ba0911f7f6f9f9a5823fa0e98778e4a7d2a9bbd5d674d552fefd20458743b60baf10a49e1ee65a3b934636229296d64b1eece55826f136824f9cae91b6a208c4
-OpenBLAS.v0.3.24+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/2ff249795f3d8796b99536a4bf11670c
-OpenBLAS.v0.3.24+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/517c4a99933e439de7ede07376b6f40785406216489f1bd6f995e5d6e444c860df401807abba6dc04ff83dd701f32047fcd4d3fd01660601f27edbc545ea783e
-OpenBLAS.v0.3.24+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/f3c3fab4d30655b8cd831511a307d4d3
-OpenBLAS.v0.3.24+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/06d47db95ec374b5238857c1ad595cee882441fd462ae6a030f1a1c4465b617228feb34fd80a97d8ca965bfc87f8d4a3a94a3654b2c0615ef4506fa827e8c155
-OpenBLAS.v0.3.24+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/52a7f29bfe47e89f32b5c95f6ce65c29
-OpenBLAS.v0.3.24+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/4816b3e022613b6a7a2073dd292311b29d8e848887f4d0ed7bcf32140bce2e9f15e05d754c48c1575cbaf70fcae8cfec501725df15d6bb1c7ac1ac1c74b59489
-OpenBLAS.v0.3.24+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/6f4aa76cc544ce52da6aa094ee5a1aeb
-OpenBLAS.v0.3.24+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/c3428c36e19e9bd89dd0eb809f2617b7f90cbfaadffe9c58bf16c319e5e36d07102f48bafeb7a787bb6a18655ba3688a29ccd4f3724bc9354915d7e55fb64d44
-OpenBLAS.v0.3.24+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/298a83c0550694b3b6c22f6dd460cc9d
-OpenBLAS.v0.3.24+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/b8e5ac5304364c950a427384db13ed5c573e7b5e9d16bb7c354b7b5e46ca8e7471bc911a2cf9defbfc933fbfbff315949011b5596532b8863c551de6d543f434
-OpenBLAS.v0.3.24+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/2b584ae3aa496ff871cc735242e63cf4
-OpenBLAS.v0.3.24+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/ba0911f7f6f9f9a5823fa0e98778e4a7d2a9bbd5d674d552fefd20458743b60baf10a49e1ee65a3b934636229296d64b1eece55826f136824f9cae91b6a208c4
-OpenBLAS.v0.3.24+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/2ff249795f3d8796b99536a4bf11670c
-OpenBLAS.v0.3.24+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/517c4a99933e439de7ede07376b6f40785406216489f1bd6f995e5d6e444c860df401807abba6dc04ff83dd701f32047fcd4d3fd01660601f27edbc545ea783e
-OpenBLAS.v0.3.24+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/f3c3fab4d30655b8cd831511a307d4d3
-OpenBLAS.v0.3.24+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/06d47db95ec374b5238857c1ad595cee882441fd462ae6a030f1a1c4465b617228feb34fd80a97d8ca965bfc87f8d4a3a94a3654b2c0615ef4506fa827e8c155
-OpenBLAS.v0.3.24+0.i686-linux-gnu-libgfortran3.tar.gz/md5/316162aaa72c7b0938ea3f1e77b904a9
-OpenBLAS.v0.3.24+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/b6ed223ab2ac32938d4283d7fd45a88565ef6d5b361ff28adfd7def4da8bc51895af26d3dff1104e472ae0681dac3af7ba4e75760e1c57e25b2a51599d8152c2
-OpenBLAS.v0.3.24+0.i686-linux-gnu-libgfortran4.tar.gz/md5/6dc4ceeb488810cd8e6e90b05743764f
-OpenBLAS.v0.3.24+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/c0a13c43667218fe1ffb4e19fc74ca5b25dbccb74fb57e193fc9343e8659731664e60c1c7a50c243a0825ba8747c97729f2a68bb36421ec6ba646c4f0c507219
-OpenBLAS.v0.3.24+0.i686-linux-gnu-libgfortran5.tar.gz/md5/124d38befd30a1fba95048612eb20911
-OpenBLAS.v0.3.24+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/009d3217b990ec40729db4313526a4dcd977760fde4878c5fd420cce9649f367f348cc1d9f480057ff87b59545421935c7494f9fa7646206f8d114fede13051c
-OpenBLAS.v0.3.24+0.i686-linux-musl-libgfortran3.tar.gz/md5/908d7ebace63754a7842e7d1dd338a43
-OpenBLAS.v0.3.24+0.i686-linux-musl-libgfortran3.tar.gz/sha512/8ab5364d7b3a445390b07dad5046d6e428fddf0eeb0b3b36f630b8a3e428fb8544d1a8fb493ba429cd3683dbe70e0a476333d322fe233cec356895b7a94c5670
-OpenBLAS.v0.3.24+0.i686-linux-musl-libgfortran4.tar.gz/md5/cf70732029bae0fc4f87713d75faad9c
-OpenBLAS.v0.3.24+0.i686-linux-musl-libgfortran4.tar.gz/sha512/fea55b3aa2d6a8282345d710957401ad9d6350c57bf39d695173f3996c886a05d7f2672f3767397f6e0878c405117bd650923b7de5313fcd855b4846325b22e8
-OpenBLAS.v0.3.24+0.i686-linux-musl-libgfortran5.tar.gz/md5/cb4f6f8c7175c9d2159c213c37f71d86
-OpenBLAS.v0.3.24+0.i686-linux-musl-libgfortran5.tar.gz/sha512/0e92168e196d271105d8d267ed2329ab8b213375ca67539dd91a293576842ed13755f9e21536a48332d0c55e9323349f7c96817e5e80ced06986c8ad1e47a8fc
-OpenBLAS.v0.3.24+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/54b061bb2191fdbb39cb8103615d70bd
-OpenBLAS.v0.3.24+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/b45fa1d1f5a8556f0a56f81e602457d98528d2b7b6dccbbad93cedcc3cecbe1a31d3f9543161ae801d0bdbb1413a9a70589ba6f221dc5d81fd3fc17e6e536f7f
-OpenBLAS.v0.3.24+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/8590055b4fc585317a2f36fbce1c2a50
-OpenBLAS.v0.3.24+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/47bc23c59e314606d45e252dedd7ec228c36bf25cf1cc19d64ca2b862407eede5410a6e7594881d8dc263aab0d140bfdde3082d57fa41ea038c286467d8354a3
-OpenBLAS.v0.3.24+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/32120e6d84ff84bd859e080e4f124986
-OpenBLAS.v0.3.24+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/7ddada5781415099d6b1f198d27277d91a36f6850d957446ccfa7b8b2b38594b18de3ce5b1c7861c97e66897a7df1500531ac2c3ad12c597c7548def1db05fef
-OpenBLAS.v0.3.24+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/d7dbb78769e588175612a939ce69c32b
-OpenBLAS.v0.3.24+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/a1894b94dcf26d5da9da8ad119b3ecde8e6bf6d3a9d97286c1e405a059ec999a15e69ac6f497b170b485d64d6b324b4f38eb59984ec6b20d5aa6b881be819c4d
-OpenBLAS.v0.3.24+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/acda753318cb352a2581c3ebc49d6d42
-OpenBLAS.v0.3.24+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/82bda1158b223fa899b7c9350b2abf0a7b693de75f928e48698ce9555998fc98d357b1b63ac8ca18d935636812141f0ceb58f51c2a1f48faec60cc8c0ca85126
-OpenBLAS.v0.3.24+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/abbd21e61746ec41b03c1efb5dfb884c
-OpenBLAS.v0.3.24+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/7b284db00a9ab39b222caa9d4d6f3bcff3cc86560e275b7bac68c8c06c0cbe1c39226f381fba9fa90f52b8273e0c5436897c9ae0507482eb62bdeacc39ef3d35
-OpenBLAS.v0.3.24+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/36258636e985f73ab926fd4ee0e4cccb
-OpenBLAS.v0.3.24+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/a53aa38afdb9ca13e14b3420f63c728ad83451a4c7bcda53a9944ff5488c6455367db6f8253983fbe174fd408513f2a48e7fec5d184900113165f2e82a812e7e
-OpenBLAS.v0.3.24+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/780f66fc5707839a98c7bdad0432975b
-OpenBLAS.v0.3.24+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/52957cdab20b7042e844468eb6fab822937636346807469decfdb6cfb43cd6d8cc479e3e58f0259d593f120ad5ad330006a470c390bfdafbf4865ee04d3fc401
-OpenBLAS.v0.3.24+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/83e26fedfa1f84a0a13c92e10b9c12f7
-OpenBLAS.v0.3.24+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/7a5eddc7486d46f2ef7b285d8d25ed17e0cf6a00c9c74784044b086b0063f0494bbdd28197a6f933f32345167e337fe62400f5d6b76d69f578aeb3a37ab56069
-OpenBLAS.v0.3.24+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/d4b83cbbd5a06eb84edd40e10cea9c78
-OpenBLAS.v0.3.24+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/28b86fbaad0adae2efe39f086f573e19b1f4a1db16f48144cb1ed4212013b82a5a22dabb75c7bb8c2b5f465ea0bfbf413af7e2fac75884baef1a2cfd7dfb0ceb
-OpenBLAS.v0.3.24+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/2be815ebba026781801af79447f85383
-OpenBLAS.v0.3.24+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/2d86efa35a0b29e1b96d4063031e64c823440aca01739d2020856e825da22cf9044561f11ebf447674ced34c697c8b43207fe324f64c42c1c62f2edf869698e3
-OpenBLAS.v0.3.24+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/235767c8f001d56bb8c9e2b4694e94fe
-OpenBLAS.v0.3.24+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/f326fed57de6017cf1de0e1d2806af9bc0b2897377611472f051634dd862fb3d964131e02f04d7b741a64c8e72241399716510e70132f802d046f54b1d170a35
-OpenBLAS.v0.3.24+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/b202b8750e1f69099875a83be96683a1
-OpenBLAS.v0.3.24+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/c83a2c0a977b3afbc6fbe408b07888750a89e8dd66e65e1563d609296214b5114cf0b97009e4dea65a2579377d14ff1ef281c20dc327154d8635c23d50261263
-OpenBLAS.v0.3.24+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/63cf99543c8c7d741808775d0e2b133c
-OpenBLAS.v0.3.24+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/5a850adffb7cc1026b81c1780e3ff97875b29e5f794a33e9d1b3feb41d45eb25c9867c4c9e1699d0d78884ed93b32fb90d9ae8b48000939af7ecbe0d53793ac5
-OpenBLAS.v0.3.24+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/2c34974e3d5ae02dcdbb8c091dd39e2f
-OpenBLAS.v0.3.24+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/ec27f0891b9d56fe0ab86811c7a3043a6bee6518952e6ec58d00313cb6de858c8eaa7918692876e3bc8a0e3aac5f5ec563f612af9eacca47ebbdd4bea1153a0e
-OpenBLAS.v0.3.24+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/85cbc32584528f6e5f1573eee0815f41
-OpenBLAS.v0.3.24+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/e7d48088e65b74a0e5c4a0714c97ce379ba4edc1f0f9cdf733a41da1a51fcdb2231589ac92d71a28605526c1408fb3eec7bb1f1d914e67cacd37425ce22c450e
-OpenBLAS.v0.3.24+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/ad6c269fa00c998ea49311656afbf8cd
-OpenBLAS.v0.3.24+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/604067b4b827395cdb7802f88a850e023acfee7e642669567eda0d1ed9612bdf968af4f5e43a25e6b3a213fd118bf3a49cd7a02dc2ef019ee853e31bf4316664
-OpenBLAS.v0.3.24+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/e5f233a4f87cec0c18b7a47073d9ea4d
-OpenBLAS.v0.3.24+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/04fda9400f11948ec4f4c088096dd2971b4fbe2c513c755515bee757903f50c3246a5076f1fa095aae26092b0a76847ee1db4c972e235cd154af188600c387d8
-OpenBLAS.v0.3.24+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/0134d022448a5cc11f0b92b37600f7ce
-OpenBLAS.v0.3.24+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/8da81604e96bb917d6300242709056ddd9c07232a0e7a1862cb1972e8ec631af093e3ddad8538e352295de78c19387dcb9ad7eb163c40fe715a8129855fe1dfb
-OpenBLAS.v0.3.24+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/7f79751f5fb9713152410e665061872d
-OpenBLAS.v0.3.24+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/50d836e6aac10e3bd181b87946917d77aacfc74bba3d973c12e94dcdac946bcc8d58fb079838784812c27c581c46fb5485bc6e0a192287fc11df46fb7674ec17
-OpenBLAS.v0.3.24+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/8b13dbb97a45754c418994d522eee197
-OpenBLAS.v0.3.24+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/1883a4b88cede205def3c29d82773379035edc3b04b8738197137a00bcf95726ca689866f5fc1a25914ea09e3fa2775435f8b4fff95738f7fda3857bcd44653d
+OpenBLAS.v0.3.25+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/1acfa1d2dbebaf274812e36b59cdd0f7
+OpenBLAS.v0.3.25+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/4cf10b1e5a791dcaea814f4f34b328499405b39c68ed652569e3a070f14c51b935e18d04bc10440b19967a40d21d7ef4c061817a5e6abf1403613e25cd45ef2f
+OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/bf8cb41b65e7b60015b67727adca5c50
+OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/710646a8e7bcf1cb0320777006d328b20f90463dac29f37b0c0472d22a8e00e49bd8aad1a0e71772279bf452e5daef9a6e9b51a5ea2af806fcdcae2999039108
+OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/60ff3026347c9a53f88cc90fd0f29950
+OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/1dd600ac2b315a051c84529e4653aad77d43c228538ebe94c36b6f68ed14a15c5d7cfad17b49eeba4ce0ec857d7199b767c241a5e9863f7c60d5f516020a8d20
+OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/5b57d42de0fa82c123f792adb6835195
+OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/e534b6c26100a8c841a1a81dee75cd2ae8c34f5bc3ddcd6b5cc9afdc21d46419459046371fa448c5b9c6d02eeccfb64d10c887c53b52c4744e809c50d3b7d41d
+OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/d2417bfa94754ca621c875b926dadd66
+OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/249b95d0502f6f82ac7151a38380c8a6cf9314e856a9f545cc086b14eaa3f7804ff24eb8b3430144c3add912aeec8fbfaee40fe30e4245fcafec3e9df3a73484
+OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/d68bee54d083f93fa9a96ccaa0b10d6c
+OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/909d9d4a9581899c564f6a42f325e50ba7b82f1bf7d2912a9d47cc88e8e13ddda6dff8a40680720f8d0a4a1973f6b6c48ffd0ec51d0323cb08cc73268386a61c
+OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/f103f1d84b9bbac3d73d70efa79f8f8a
+OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/ad1bbfbfce09e7a7eb6d33e87f432530a3347d68b033d877029f8da9e290b129b2ab887eac510b27c9a1d9506679fb3e7e554dc0accfa05c5c950ae40c1501e6
+OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/8d92bf601f216b0512e1eb9bb0f4689e
+OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8abd7f22db9d739c90df3c512ec4958989135e894d45ee91bf364e4c4a07b3dd8640351e596ef4b62f314bcf0ed22a35036499756611f5db1f98bdf1a3130033
+OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/c56a5861637867ca4d0a88e2d71e0301
+OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/301a30c2d5c1a6355516a0520caadf83f1e121e95480bbaf3c39baaedfb10902adea826b289f0e5411ec9bb12eeb0a63fb3630b1ef3780304689a2d2bb97add8
+OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/6c8f6582db03396ed30b41deeb706877
+OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/22e2c5ba0a9d6fe1dea222d24fe5da9b208525656185945a8ef90e201592e8c2692571bde7824651dde50850b0a81f25b5dfd8d4283a097d2f6193507128b587
+OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/546e7ec9501a6687784c9285b70cf2d4
+OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/8d306c18e810a22b637c5fa2f35b791b44aec67198b1a2632ff245cf5519cf138d2074eea84e85a348075b77b90eb5ff6342a920e66e508501eefd6c8cabfb6b
+OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/494c5b1a2df492723aedc05301958606
+OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/01d413b45df28b6c262d2e1c1859a499d10e24cbf32c8954b5fe5f66c6cbc13e113e7834db304beee02a31228f2c5c1bb83e83455551b63cc972cf0d604db843
+OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/0e14407a456d8354d4759140b8c2dcab
+OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/38b045a701d0dc1cc161877944a6db5154b36437d4122460727f489b05b902a7766e760ace5331a4056f804a8008fb3e123c905adae45839d1eeeadf1f209116
+OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/8d92bf601f216b0512e1eb9bb0f4689e
+OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8abd7f22db9d739c90df3c512ec4958989135e894d45ee91bf364e4c4a07b3dd8640351e596ef4b62f314bcf0ed22a35036499756611f5db1f98bdf1a3130033
+OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/c56a5861637867ca4d0a88e2d71e0301
+OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/301a30c2d5c1a6355516a0520caadf83f1e121e95480bbaf3c39baaedfb10902adea826b289f0e5411ec9bb12eeb0a63fb3630b1ef3780304689a2d2bb97add8
+OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/6c8f6582db03396ed30b41deeb706877
+OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/22e2c5ba0a9d6fe1dea222d24fe5da9b208525656185945a8ef90e201592e8c2692571bde7824651dde50850b0a81f25b5dfd8d4283a097d2f6193507128b587
+OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/546e7ec9501a6687784c9285b70cf2d4
+OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/8d306c18e810a22b637c5fa2f35b791b44aec67198b1a2632ff245cf5519cf138d2074eea84e85a348075b77b90eb5ff6342a920e66e508501eefd6c8cabfb6b
+OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/494c5b1a2df492723aedc05301958606
+OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/01d413b45df28b6c262d2e1c1859a499d10e24cbf32c8954b5fe5f66c6cbc13e113e7834db304beee02a31228f2c5c1bb83e83455551b63cc972cf0d604db843
+OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/0e14407a456d8354d4759140b8c2dcab
+OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/38b045a701d0dc1cc161877944a6db5154b36437d4122460727f489b05b902a7766e760ace5331a4056f804a8008fb3e123c905adae45839d1eeeadf1f209116
+OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran3.tar.gz/md5/fb62eeaa26adad79f27a4871abe4c8f2
+OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/1712755c80f7d48052fdc2ffd254b745ddd5d9a90bcf2f25532448d258317664895efdd8b92054a17271349e6371449b3dbf1cbe44d2bab2b2a11e77a0f8207e
+OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran4.tar.gz/md5/bbb096eb2294179d4bbac42fa08dfa04
+OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/6de33c7a98077c82d2d730b2a3046f9d84cf779c46527e70b4e862c2b51b7487d3b5d66eb1693235ab19bb9b254f85677707bfe496ca96e8b2f9840413d52d86
+OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran5.tar.gz/md5/25e6e7f428ca9d817ce06dfd1ce440d7
+OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/3d7d12c9de5d435fd7d9b8919c6b511d3a825e02d9d303a2222f16d13f7c93b620e6099fb290cd36648f51952c187b9100753e107530be2d40c1e006f44ac453
+OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran3.tar.gz/md5/0f09043138753743b33bdc1598ea2f98
+OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran3.tar.gz/sha512/a43510a70e63b534812fb0213af75743c0c78f8d153e61cfa0b3ec0b5a51172db3d3ca5b40429ccfd2fe99eb730db661566d61f825f0c97d079f75933ab17385
+OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran4.tar.gz/md5/b8c78d226bf548306cb0de09c296fcfd
+OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran4.tar.gz/sha512/165b85271b686da7daad21e2d3be683efcf8beb3208d2ba73e753cdc8405236c673ceb5713f84131a5b44045721c98de70242f600f7823c1597d38156f692ca6
+OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran5.tar.gz/md5/1f508ddbb3ef7aff7880b34a8caeb032
+OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran5.tar.gz/sha512/9f603451d957483b5be45dd8d705f0a45f0fa3fa4e32d9431a15b7dc986fbce200d7d8966717564c588ee3a367c949342b63f03b81de387bb90c691cb3b0d2a5
+OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/e85605ee1a4d33d43a2fb2e516eaa99f
+OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/98512575e60b34df6fe0a2d3f4a0a57d8f9ef1ef7a65b014427776104633acffbbd48bdb8aecdeb54dca1bdee39e1efd6f677dd68028911f2dfbe55f1180f054
+OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/673c70c7f29dab76a154b5171f6112a2
+OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/4ec6313ddbdcf3a98d48bc8510d5c120fb3232433738a28e9ccd9beec1e2a0ef401c625b0b97702cd7be7fd6061e2f8ed48f35ae36b46495d952053e0accaaae
+OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/7242fefbdb29d0ef5f08f39590fb204d
+OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/be253db33b2345388550d3e82b8cea4e9416874df5e01b24e96796faace87440178a10e93a47d228b4e31e21754de8b42a067e69aba8ab6267a19e7197f3d54c
+OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/1fd83d8f353195c7ae1a1fa9ea266171
+OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/0cb87fb1dbe6af1f1aef1bb3e346078a9de39d2ef33a51c99c0fafe67cdb494b1aae567429a9bec8fdfd41c651afe63815b7ecec20ea95fb3d0bedf06eb78188
+OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/f2a4141dea91feef792036dd149e552d
+OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/58dc721598f36380c65f34cb5d3efeb77bb03605afb82bb08689674893cb399af34dde47002105f072422d031df8f629fbfb4f463a9900c3b09fd6e98b3d007b
+OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/f472322bd6f463f335d7b9c5b2ae69be
+OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/b9530287d7972b599535b4d78a2540e00a49664660c077cf7c50ebcc86e79fb7fb2e6ddd2d1f3e80c1f4f6d6094c4f4a0641e3112994f7b770ac14868c704ec0
+OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/28c498d970d4c659d47981f915448a2e
+OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/f5a5d9d98013b39b26134910ba9e2cbd23caf1bfca1cb9867e972753081cafd90edfa5089747d94b87368aa4cecffcb40314326b82a47ddb4eafa3a63437482e
+OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/2888ac4b4ad4f693b652c0054187360b
+OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/0292f8d1ecbc5b357c1b9891944831cf652d1937d62a4d7486dc5c4dea3a9fa54bd1f0d76ba5553fe009d09e68edb79ee1310ac2b296ba61e33ea1ed794f4713
+OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/f3868395464c24b87fe543a630799cb8
+OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/4790f559458a301cb4ca9ce11bb2004b2bc0a72f7cf88c7dc45572f7c56adb154f7ab76a72e463ac0871019248e4b6ed4129356ab036bc71bee3700235f9f805
+OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/83fde9ea432e7c87413ebedea4062070
+OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/00428ed95ef6dd1191911e768d929d9a511f34ad1f098c6311df7f2176fb82d67e763326da95fc390ec05854a7a1482c3e2e4efd4b1975653c45a825b4b3ef68
+OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/415f468e44c3762451b39596eb6dd45d
+OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/bda9c30547cc219fdc00d3854ad02708d225a46850c7a95b786b527722e75185787ab2353185007cb9f692a4cd5a3c38d64018a46ee4d400df9d4612371a2a9b
+OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/7858a2a1c13b6707f6bee3b021811728
+OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/0a0e4995652e9459dd54325ee92262261244ace5f065f293459ad91433345efbbdf1e51996ae2629968498a8fc34b0fb64fadde7bc36498a48eeefafde987d5d
+OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/30f5deef5223ee198acb8c213a7c89b1
+OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/a933e33e6070475450312d0608626811bae98e129adb30d84cf5a3c7d525217e805b0ffb88490931a927b1fda1c9479af953282e47af1f469f993d4d2150da95
+OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/86fd8946da2bd4fb97f54c8df5883d5e
+OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/d61187e632a0d49c89854d441b9b42fcd9dc7517f4f38514cd17f599c2f9ad3600054bf8457d0e9fb766fe9c7d0c248cd3e5383be2600ac2c538f2d524a8e1de
+OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/d95539fa91c80db375310ed09d191379
+OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/ab786856a1c4ab47808e9ea2167c6ae42e69d6a11e539b7771464bbc0c7bb1d5482ed2c3c0154fae37bfb1579103e862637675e4d81726d4e3ed633cd7548cd9
+OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/09ea7329e39dac562e45f00e6b135ad6
+OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/c0b8b3b6f7c9a326b857e218014bc232165122865c18811bc5c9af28b54c494a4a0ed139101cdf30ff5e8b03f9e8bb4ce32865ab5ba4e5251f841a2bf612eb86
+OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/f874721e0ee45094c62cf4a006c5309c
+OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/03d57202ef4209f23f83a5faef01c772c2c6b04085d8448b835eec793b50b9f2f13dec2ba1d0a7ac55f6be7df8231a04163ac6d1fccb91976e965fd10bc0e3f1
+OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/69de0e673292ccaf3294e785a96cc22b
+OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/9ff1dd63a62d5f0d771833a7872d0abdf6e2307aabf57d7b5f1469f75aeda99525beb5a4c2f311cef0b8af3905daab321435b613c9e046a7d7c5c30e2548ba0b
+OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/2cd93681be2f2f781285ca7dbef7eba1
+OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/3163b20884e9be0a6d99735c400ca58f52f097fbbcb396be0ce9c29b3d4adebe5cee4ddb91f095a692e1f812c5558690a603bd455c5576c374e7c49e6cfaac7b
+OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/751aff51cf7674bcb68fe3bb94137603
+OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/b5fa7477f9033f5e55214fb4e0bd3bf923e2c580c6582b7241739237dc50d269448459efebf75da82415ceb2f547033210f118d9b8c9ab2585fc792253331309
+OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/de458200baed33ba568f8222a9b72865
+OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/d6acccb3a10e3eb01be2aacb4d77f084f022fef3ca3bbf05530cae5c13224b4ab12b62e8e8a3ce1ef6ab0b2cca9e88c687794a8620fe0af1c478323976268d5a
 openblas-9f815cf1bf16b4e64d4aee681b33558fc090b62a.tar.gz/md5/d890367a6452aa209f396359fb770bc7
 openblas-9f815cf1bf16b4e64d4aee681b33558fc090b62a.tar.gz/sha512/0627960fc2582e08fd039c77aab1f4105f18edb1beba52176a791813bb3f1ebb04f52d174814e156826c45c6adf5f3c1d2242e81fdb520a7fff2170cb1277228
diff --git a/deps/openblas.version b/deps/openblas.version
index 9790ad1718e78..7b16df95c9c7f 100644
--- a/deps/openblas.version
+++ b/deps/openblas.version
@@ -3,9 +3,9 @@
 OPENBLAS_JLL_NAME := OpenBLAS
 
 ## source build
-OPENBLAS_VER := 0.3.24
-OPENBLAS_BRANCH=v0.3.24
-OPENBLAS_SHA1=9f815cf1bf16b4e64d4aee681b33558fc090b62a
+OPENBLAS_VER := 0.3.25
+OPENBLAS_BRANCH=v0.3.25
+OPENBLAS_SHA1=5e1a429eab44731b6668b8f6043c1ea951b0a80b
 
 # LAPACK, source-only
 LAPACK_VER := 3.9.0
diff --git a/stdlib/OpenBLAS_jll/Project.toml b/stdlib/OpenBLAS_jll/Project.toml
index ad5041cf4ac81..99a75366e24a7 100644
--- a/stdlib/OpenBLAS_jll/Project.toml
+++ b/stdlib/OpenBLAS_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "OpenBLAS_jll"
 uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
-version = "0.3.24+0"
+version = "0.3.25+0"
 
 [deps]
 # See note in `src/OpenBLAS_jll.jl` about this dependency.

From 8af47bd585fc81ec373167b3ca02010177e7ccf8 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 17 Nov 2023 23:58:49 +0900
Subject: [PATCH 0272/1315] irinterp: check if `IRCode` has been compacted
 (#52203)

Adds assertion that checks if `IRCode` passed to irinterp or post-opt
analysis has been compacted. And using the invariant from the assertion,
this commit also propagates `inst::Instruction` for `scan!` callbacks
instead of `stmt` and removes `idx::Int` argument since it is redundant
with `inst.idx`.
---
 base/compiler/optimize.jl       | 14 +++++++-----
 base/compiler/ssair/irinterp.jl | 40 +++++++++++++++++----------------
 2 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index e974a23d05651..5f4faa4933e0a 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -602,7 +602,7 @@ function scan_non_dataflow_flags!(inst::Instruction, sv::PostOptAnalysisState)
     end
 end
 
-function scan_inconsistency!(inst::Instruction, idx::Int, sv::PostOptAnalysisState)
+function scan_inconsistency!(inst::Instruction, sv::PostOptAnalysisState)
     flag = inst[:flag]
     stmt_inconsistent = iszero(flag & IR_FLAG_CONSISTENT)
     stmt = inst[:stmt]
@@ -625,7 +625,7 @@ function scan_inconsistency!(inst::Instruction, idx::Int, sv::PostOptAnalysisSta
             end
         end
     end
-    stmt_inconsistent && push!(inconsistent, idx)
+    stmt_inconsistent && push!(inconsistent, inst.idx)
     return stmt_inconsistent
 end
 
@@ -633,7 +633,7 @@ struct ScanStmt
     sv::PostOptAnalysisState
 end
 
-function ((; sv)::ScanStmt)(inst::Instruction, idx::Int, lstmt::Int, bb::Int)
+function ((; sv)::ScanStmt)(inst::Instruction, lstmt::Int, bb::Int)
     stmt = inst[:stmt]
 
     if isexpr(stmt, :enter)
@@ -644,9 +644,9 @@ function ((; sv)::ScanStmt)(inst::Instruction, idx::Int, lstmt::Int, bb::Int)
 
     scan_non_dataflow_flags!(inst, sv)
 
-    stmt_inconsistent = scan_inconsistency!(inst, idx, sv)
+    stmt_inconsistent = scan_inconsistency!(inst, sv)
 
-    if stmt_inconsistent && idx == lstmt
+    if stmt_inconsistent && inst.idx == lstmt
         if isa(stmt, ReturnNode) && isdefined(stmt, :val)
             sv.all_retpaths_consistent = false
         elseif isa(stmt, GotoIfNot)
@@ -736,6 +736,8 @@ end
 function ipo_dataflow_analysis!(interp::AbstractInterpreter, ir::IRCode, result::InferenceResult)
     is_ipo_dataflow_analysis_profitable(result.ipo_effects) || return false
 
+    @assert isempty(ir.new_nodes) "IRCode should be compacted before post-opt analysis"
+
     sv = PostOptAnalysisState(result, ir)
     scanner = BBScanner(ir)
 
@@ -746,7 +748,7 @@ function ipo_dataflow_analysis!(interp::AbstractInterpreter, ir::IRCode, result:
             check_inconsistentcy!(sv, scanner)
         else
             # No longer any dataflow concerns, just scan the flags
-            scan!(scanner, false) do inst::Instruction, idx::Int, lstmt::Int, bb::Int
+            scan!(scanner, false) do inst::Instruction, lstmt::Int, bb::Int
                 scan_non_dataflow_flags!(inst, sv)
                 # bail out early if there are no possibilities to refine the effects
                 if !any_refinable(sv)
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 0e34cf9ce70bc..c9c9eb2501f99 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -95,10 +95,10 @@ function kill_terminator_edges!(irsv::IRInterpretationState, term_idx::Int, bb::
     end
 end
 
-function reprocess_instruction!(interp::AbstractInterpreter, idx::Int, bb::Union{Int,Nothing},
-    @nospecialize(stmt), @nospecialize(typ), irsv::IRInterpretationState)
+function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction, idx::Int,
+                                bb::Union{Int,Nothing}, irsv::IRInterpretationState)
     ir = irsv.ir
-    inst = ir[SSAValue(idx)]
+    stmt = inst[:stmt]
     if isa(stmt, GotoIfNot)
         cond = stmt.cond
         condval = maybe_extract_const_bool(argextype(cond, ir))
@@ -172,7 +172,7 @@ function reprocess_instruction!(interp::AbstractInterpreter, idx::Int, bb::Union
                 inst[:stmt] = quoted(rt.val)
             end
             return true
-        elseif !⊑(typeinf_lattice(interp), typ, rt)
+        elseif !⊑(typeinf_lattice(interp), inst[:type], rt)
             inst[:type] = rt
             return true
         end
@@ -226,7 +226,7 @@ function scan!(callback, scanner::BBScanner, forwards_only::Bool)
         lstmt = last(stmts)
         for idx = stmts
             inst = ir[SSAValue(idx)]
-            ret = callback(inst, idx, lstmt, bb)
+            ret = callback(inst, lstmt, bb)
             ret === nothing && return true
             ret::Bool || break
             idx == lstmt && process_terminator!(inst[:stmt], bb, bb_ip) && forwards_only && return false
@@ -236,11 +236,11 @@ function scan!(callback, scanner::BBScanner, forwards_only::Bool)
 end
 
 function populate_def_use_map!(tpdum::TwoPhaseDefUseMap, scanner::BBScanner)
-    scan!(scanner, false) do inst::Instruction, idx::Int, lstmt::Int, bb::Int
+    scan!(scanner, false) do inst::Instruction, lstmt::Int, bb::Int
         for ur in userefs(inst)
             val = ur[]
             if isa(val, SSAValue)
-                push!(tpdum[val.id], idx)
+                push!(tpdum[val.id], inst.idx)
             end
         end
         return true
@@ -255,6 +255,8 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
 
     (; ir, tpdum, ssa_refined) = irsv
 
+    @assert isempty(ir.new_nodes) "IRCode should be compacted before irinterp"
+
     all_rets = Int[]
     scanner = BBScanner(ir)
 
@@ -263,15 +265,16 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
     # Fast path: Scan both use counts and refinement in one single pass of
     #            of the instructions. In the absence of backedges, this will
     #            converge.
-    completed_scan = scan!(scanner, true) do inst::Instruction, idx::Int, lstmt::Int, bb::Int
+    completed_scan = scan!(scanner, true) do inst::Instruction, lstmt::Int, bb::Int
+        idx = inst.idx
         irsv.curridx = idx
-        stmt = ir.stmts[idx][:stmt]
-        typ = ir.stmts[idx][:type]
-        flag = ir.stmts[idx][:flag]
+        stmt = inst[:stmt]
+        typ = inst[:type]
+        flag = inst[:flag]
         any_refined = false
         if (flag & IR_FLAG_REFINED) != 0
             any_refined = true
-            ir.stmts[idx][:flag] &= ~IR_FLAG_REFINED
+            inst[:flag] &= ~IR_FLAG_REFINED
         end
         for ur in userefs(stmt)
             val = ur[]
@@ -292,11 +295,11 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
         if typ === Bottom && !(idx == lstmt && is_terminator_or_phi)
             return true
         end
-        if (any_refined && reprocess_instruction!(interp, idx, bb, stmt, typ, irsv)) ||
+        if (any_refined && reprocess_instruction!(interp, inst, idx, bb, irsv)) ||
             (externally_refined !== nothing && idx in externally_refined)
             push!(ssa_refined, idx)
-            stmt = ir.stmts[idx][:stmt]
-            typ = ir.stmts[idx][:type]
+            stmt = inst[:stmt]
+            typ = inst[:type]
         end
         if typ === Bottom && !is_terminator_or_phi
             kill_terminator_edges!(irsv, lstmt, bb)
@@ -316,7 +319,8 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
         stmt_ip = BitSetBoundedMinPrioritySet(length(ir.stmts))
 
         # Slow Path Phase 1.A: Complete use scanning
-        scan!(scanner, false) do inst::Instruction, idx::Int, lstmt::Int, bb::Int
+        scan!(scanner, false) do inst::Instruction, lstmt::Int, bb::Int
+            idx = inst.idx
             irsv.curridx = idx
             stmt = inst[:stmt]
             flag = inst[:flag]
@@ -356,9 +360,7 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
             idx = popfirst!(stmt_ip)
             irsv.curridx = idx
             inst = ir[SSAValue(idx)]
-            stmt = inst[:stmt]
-            typ = inst[:type]
-            if reprocess_instruction!(interp, idx, nothing, stmt, typ, irsv)
+            if reprocess_instruction!(interp, inst, idx, nothing, irsv)
                 append!(stmt_ip, tpdum[idx])
             end
         end

From 03bbf91902b5dbeb04d71fb02f4f168dd1c3c6df Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sat, 18 Nov 2023 00:00:13 +0900
Subject: [PATCH 0273/1315] remove `switch_[to|from]_irinterp` mechanism
 (#52204)

This seems to cause (probably not very profitable) union-splitting all
over the place and complicate code generation. Let's just remove it.

As a result, this would slightly
reduce image sizes too.
---
 base/compiler/ssair/irinterp.jl |  2 --
 base/compiler/typeinfer.jl      |  1 -
 base/compiler/types.jl          | 38 +++------------------------------
 3 files changed, 3 insertions(+), 38 deletions(-)

diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index c9c9eb2501f99..2d609d6dd3d08 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -251,8 +251,6 @@ populate_def_use_map!(tpdum::TwoPhaseDefUseMap, ir::IRCode) =
 
 function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IRInterpretationState;
         externally_refined::Union{Nothing,BitSet} = nothing)
-    interp = switch_to_irinterp(interp)
-
     (; ir, tpdum, ssa_refined) = irsv
 
     @assert isempty(ir.new_nodes) "IRCode should be compacted before irinterp"
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 29d3c01d151be..fcb9944619831 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -243,7 +243,6 @@ function finish!(interp::AbstractInterpreter, caller::InferenceState)
 end
 
 function _typeinf(interp::AbstractInterpreter, frame::InferenceState)
-    interp = switch_from_irinterp(interp)
     typeinf_nocycle(interp, frame) || return false # frame is now part of a higher cycle
     # with no active ip's, frame is done
     frames = frame.callers_in_cycle
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index db1d85cdddc40..dde5335b36f68 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -342,9 +342,6 @@ struct NativeInterpreter <: AbstractInterpreter
     # Parameters for inference and optimization
     inf_params::InferenceParams
     opt_params::OptimizationParams
-
-    # a boolean flag to indicate if this interpreter is performing semi concrete interpretation
-    irinterp::Bool
 end
 
 function NativeInterpreter(world::UInt = get_world_counter();
@@ -364,7 +361,7 @@ function NativeInterpreter(world::UInt = get_world_counter();
 
     inf_cache = Vector{InferenceResult}() # Initially empty cache
 
-    return NativeInterpreter(world, method_table, inf_cache, inf_params, opt_params, #=irinterp=#false)
+    return NativeInterpreter(world, method_table, inf_cache, inf_params, opt_params)
 end
 
 function NativeInterpreter(interp::NativeInterpreter;
@@ -372,9 +369,8 @@ function NativeInterpreter(interp::NativeInterpreter;
                            method_table::CachedMethodTable{InternalMethodTable} = interp.method_table,
                            inf_cache::Vector{InferenceResult} = interp.inf_cache,
                            inf_params::InferenceParams = interp.inf_params,
-                           opt_params::OptimizationParams = interp.opt_params,
-                           irinterp::Bool = interp.irinterp)
-    return NativeInterpreter(world, method_table, inf_cache, inf_params, opt_params, irinterp)
+                           opt_params::OptimizationParams = interp.opt_params)
+    return NativeInterpreter(world, method_table, inf_cache, inf_params, opt_params)
 end
 
 # Quickly and easily satisfy the AbstractInterpreter API contract
@@ -468,34 +464,6 @@ typeinf_lattice(::AbstractInterpreter) = InferenceLattice(BaseInferenceLattice.i
 ipo_lattice(::AbstractInterpreter) = InferenceLattice(IPOResultLattice.instance)
 optimizer_lattice(::AbstractInterpreter) = SimpleInferenceLattice.instance
 
-typeinf_lattice(interp::NativeInterpreter) = interp.irinterp ?
-    InferenceLattice(SimpleInferenceLattice.instance) :
-    InferenceLattice(BaseInferenceLattice.instance)
-ipo_lattice(interp::NativeInterpreter) = interp.irinterp ?
-    InferenceLattice(SimpleInferenceLattice.instance) :
-    InferenceLattice(IPOResultLattice.instance)
-optimizer_lattice(interp::NativeInterpreter) = SimpleInferenceLattice.instance
-
-"""
-    switch_to_irinterp(interp::AbstractInterpreter) -> irinterp::AbstractInterpreter
-
-This interface allows `ir_abstract_constant_propagation` to convert `interp` to a new
-`irinterp::AbstractInterpreter` to perform semi-concrete interpretation.
-`NativeInterpreter` uses this interface to switch its lattice to `optimizer_lattice` during
-semi-concrete interpretation on `IRCode`.
-"""
-switch_to_irinterp(interp::AbstractInterpreter) = interp
-switch_to_irinterp(interp::NativeInterpreter) = NativeInterpreter(interp; irinterp=true)
-
-"""
-    switch_from_irinterp(irinterp::AbstractInterpreter) -> interp::AbstractInterpreter
-
-The inverse operation of `switch_to_irinterp`, allowing `typeinf` to convert `irinterp` back
-to a new `interp::AbstractInterpreter` to perform ordinary abstract interpretation.
-"""
-switch_from_irinterp(irinterp::AbstractInterpreter) = irinterp
-switch_from_irinterp(irinterp::NativeInterpreter) = NativeInterpreter(irinterp; irinterp=false)
-
 abstract type CallInfo end
 
 @nospecialize

From 113431532e24c999b89d93136974ead53cd2d534 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sat, 18 Nov 2023 01:21:29 +0900
Subject: [PATCH 0274/1315] effects: taint :noub for memory operations (#52186)

Currently our effects system does not track `:noub` about memory
operations. While this sounds unsafe, it's actually not problematic in
most contexts. We restrict concrete-evaluation for anything involing
memory operations anyway, as mutable values aren't propagated as
compile-time constants (except `Symbol`s). However, it turns out that
this is actually causing very dangerous situations in REPL completion
context, where `REPLInterpreter` enables aggressive concrete-evaluation
that propagates mutable values as constants and ignores the
`:consisten`-cy requirement that is usually tainted by memory
operations.

This commit addresses this issue by tainting `:noub` for memory
operations. This commit ends up being somewhat extensive because it
would cause significant regression in REPL completions if we make memory
ops naively taint `:noub`. Complicating this further is the Base's uses
of `boundscheck=false` for peak performance of core memory operations,
where bounds checking is conducted separately before performing actual
memory operations, e.g.:
> essentials.jl
```julia
function getindex(A::Array, i::Int)
    @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) || throw_boundserror(A, (i,))
    memoryrefget(memoryref(getfield(A, :ref), i, false), :not_atomic, false)
end
```
Here `boundscheck=false` should generally taint `:noub` immediately, but
in this kind of case `:noub` can actually be `NOUB_IF_NOINBOUNDS` since
it has `@boundscheck` that asserts safety of the memory ops. Note that
we could employ a similar technique to `getfield` if we change the above
implementation to something like:
```julia
function getindex(A::Array, i::Int)
    memoryrefget(memoryref(getfield(A, :ref), i, @_boundscheck), :not_atomic, @_boundscheck)
end
```
although this would end up being slower (check the difference at the
code LLVM emits on each implementation if interested).

To this end, this commit also introduces new `:noub_if_noinbounds`
setting to `@assume_effects` and use it within the base implementation.
Now `UInt8` is not enough to represent `EffectsOverride` information,
the bit is enlarged to `UInt16`. While this approach might not be ideal,
I don't think there is a better way to do this. An alternative I tried
before making this commit was to introduce new semantics for
`Expr(:boundscheck, ...)` where `Expr(:boundscheck, nothing)` will be
constant folded to `false` during codegen while during inference time it
does not taint `:noub`. I felt this further complicates the already
complex complext `:boundscheck` situation, so I decided to go with the
approach to expand the settings set of `@assume_effects`.
---
 base/array.jl                             | 28 ++++------
 base/boot.jl                              |  3 +-
 base/c.jl                                 |  2 +-
 base/compiler/abstractinterpretation.jl   |  4 +-
 base/compiler/effects.jl                  | 46 ++++++++--------
 base/compiler/optimize.jl                 | 35 ++++++++----
 base/compiler/ssair/inlining.jl           |  2 +-
 base/compiler/ssair/irinterp.jl           |  6 +-
 base/compiler/tfuncs.jl                   | 41 +++++++++++++-
 base/compiler/typeinfer.jl                |  2 +
 base/compiler/validation.jl               |  2 -
 base/docs/intrinsicsdocs.jl               | 17 +++---
 base/essentials.jl                        | 62 ++++++++++++++-------
 base/expr.jl                              | 16 ++++--
 base/genericmemory.jl                     | 11 ----
 base/strings/string.jl                    |  2 +-
 base/tuple.jl                             |  3 +-
 src/common_symbols2.inc                   |  1 -
 src/ircode.c                              |  6 +-
 src/jltypes.c                             |  4 +-
 src/julia.h                               | 19 ++++---
 src/method.c                              |  5 +-
 stdlib/REPL/test/replcompletions.jl       |  9 +++
 stdlib/Serialization/src/Serialization.jl | 15 +++--
 test/compiler/effects.jl                  | 67 +++++++++++++++++++++++
 25 files changed, 277 insertions(+), 131 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index d883c620428e4..e90723957afdb 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -124,8 +124,8 @@ const DenseVecOrMat{T} = Union{DenseVector{T}, DenseMatrix{T}}
     @_safeindex
 
 This internal macro converts:
-- `getindex(xs::Tuple, )` -> `__inbounds_getindex(args...)`
-- `setindex!(xs::Vector, args...)` -> `__inbounds_setindex!(xs, args...)`
+- `getindex(xs::Tuple, i::Int)` -> `__safe_getindex(xs, i)`
+- `setindex!(xs::Vector{T}, x, i::Int)` -> `__safe_setindex!(xs, x, i)`
 to tell the compiler that indexing operations within the applied expression are always
 inbounds and do not need to taint `:consistent` and `:nothrow`.
 """
@@ -143,10 +143,10 @@ function _safeindex(__module__, ex)
             for i = 2:length(lhs.args)
                 args[i-1] = _safeindex(__module__, lhs.args[i])
             end
-            return Expr(:call, GlobalRef(__module__, :__inbounds_setindex!), xs, _safeindex(__module__, rhs), args...)
+            return Expr(:call, GlobalRef(__module__, :__safe_setindex!), xs, _safeindex(__module__, rhs), args...)
         end
     elseif ex.head === :ref # xs[i]
-        return Expr(:call, GlobalRef(__module__, :__inbounds_getindex), ex.args...)
+        return Expr(:call, GlobalRef(__module__, :__safe_getindex), ex.args...)
     end
     args = Vector{Any}(undef, length(ex.args))
     for i = 1:length(ex.args)
@@ -236,6 +236,7 @@ sizeof(a::Array) = length(a) * elsize(typeof(a)) # n.b. this ignores bitsunion b
 
 function isassigned(a::Array, i::Int...)
     @inline
+    @_noub_if_noinbounds_meta
     @boundscheck checkbounds(Bool, a, i...) || return false
     ii = _sub2ind(size(a), i...)
     return @inbounds isassigned(memoryref(a.ref, ii, false))
@@ -243,6 +244,7 @@ end
 
 function isassigned(a::Vector, i::Int) # slight compiler simplification for the most common case
     @inline
+    @_noub_if_noinbounds_meta
     @boundscheck checkbounds(Bool, a, i) || return false
     return @inbounds isassigned(memoryref(a.ref, i, false))
 end
@@ -962,29 +964,23 @@ Dict{String, Int64} with 2 entries:
 function setindex! end
 
 function setindex!(A::Array{T}, x, i::Int) where {T}
+    @_noub_if_noinbounds_meta
     @boundscheck (i - 1)%UInt < length(A)%UInt || throw_boundserror(A, (i,))
     memoryrefset!(memoryref(A.ref, i, false), x isa T ? x : convert(T,x)::T, :not_atomic, false)
     return A
 end
 function setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T}
     @inline
+    @_noub_if_noinbounds_meta
     @boundscheck checkbounds(A, i1, i2, I...) # generally _to_linear_index requires bounds checking
     memoryrefset!(memoryref(A.ref, _to_linear_index(A, i1, i2, I...), false), x isa T ? x : convert(T,x)::T, :not_atomic, false)
     return A
 end
 
-function __inbounds_setindex!(A::Array{T}, x, i::Int) where {T}
-    @inline
-    val = x isa T ? x : convert(T,x)::T
-    memoryrefset!(memoryref(A.ref, i, false), val, :not_atomic, false)
-    return A
-end
-function __inbounds_setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T}
-    @inline
-    val = x isa T ? x : convert(T,x)::T
-    memoryrefset!(memoryref(A.ref, _to_linear_index(A, i1, i2, I...), false), val, :not_atomic, false)
-    return A
-end
+__safe_setindex!(A::Vector{T}, x::T, i::Int) where {T} = (@inline; @_nothrow_noub_meta;
+    memoryrefset!(memoryref(A.ref, i, false), x, :not_atomic, false); return A)
+__safe_setindex!(A::Vector{T}, x,    i::Int) where {T} = (@inline;
+    __safe_setindex!(A, convert(T, x)::T, i))
 
 # This is redundant with the abstract fallbacks but needed and helpful for bootstrap
 function setindex!(A::Array, X::AbstractArray, I::AbstractVector{Int})
diff --git a/base/boot.jl b/base/boot.jl
index 7ada0782600b4..74eaed090f879 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -281,7 +281,8 @@ macro _foldable_meta()
         #=:terminates_locally=#false,
         #=:notaskstate=#true,
         #=:inaccessiblememonly=#true,
-        #=:noub=#true))
+        #=:noub=#true,
+        #=:noub_if_noinbounds=#false))
 end
 
 macro inline()   Expr(:meta, :inline)   end
diff --git a/base/c.jl b/base/c.jl
index 1182033802aad..eb552d3507662 100644
--- a/base/c.jl
+++ b/base/c.jl
@@ -409,6 +409,6 @@ macro ccall(expr)
     return ccall_macro_lower(:ccall, ccall_macro_parse(expr)...)
 end
 
-macro ccall_effects(effects::UInt8, expr)
+macro ccall_effects(effects::UInt16, expr)
     return ccall_macro_lower((:ccall, effects), ccall_macro_parse(expr)...)
 end
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 73777646fa68b..77024670b7002 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2604,7 +2604,7 @@ function abstract_eval_foreigncall(interp::AbstractInterpreter, e::Expr, vtypes:
         abstract_eval_value(interp, x, vtypes, sv)
     end
     cconv = e.args[5]
-    if isa(cconv, QuoteNode) && (v = cconv.value; isa(v, Tuple{Symbol, UInt8}))
+    if isa(cconv, QuoteNode) && (v = cconv.value; isa(v, Tuple{Symbol, UInt16}))
         override = decode_effects_override(v[2])
         effects = Effects(effects;
             consistent          = override.consistent ? ALWAYS_TRUE : effects.consistent,
@@ -2613,7 +2613,7 @@ function abstract_eval_foreigncall(interp::AbstractInterpreter, e::Expr, vtypes:
             terminates          = override.terminates_globally ? true : effects.terminates,
             notaskstate         = override.notaskstate ? true : effects.notaskstate,
             inaccessiblememonly = override.inaccessiblememonly ? ALWAYS_TRUE : effects.inaccessiblememonly,
-            noub                = override.noub ? ALWAYS_TRUE : effects.noub)
+            noub                = override.noub ? ALWAYS_TRUE : override.noub_if_noinbounds ? NOUB_IF_NOINBOUNDS : effects.noub)
     end
     return RTEffects(t, effects)
 end
diff --git a/base/compiler/effects.jl b/base/compiler/effects.jl
index 485ba5e416665..fc774efbbee85 100644
--- a/base/compiler/effects.jl
+++ b/base/compiler/effects.jl
@@ -197,15 +197,14 @@ is_nothrow(effects::Effects)             = effects.nothrow
 is_terminates(effects::Effects)          = effects.terminates
 is_notaskstate(effects::Effects)         = effects.notaskstate
 is_inaccessiblememonly(effects::Effects) = effects.inaccessiblememonly === ALWAYS_TRUE
+is_noub(effects::Effects)                = effects.noub === ALWAYS_TRUE
+is_noub_if_noinbounds(effects::Effects)  = effects.noub === NOUB_IF_NOINBOUNDS
 is_nonoverlayed(effects::Effects)        = effects.nonoverlayed
 
-is_noub(effects::Effects, noinbounds::Bool=true) =
-    effects.noub === ALWAYS_TRUE || (noinbounds && effects.noub === NOUB_IF_NOINBOUNDS)
-
 # implies `is_notaskstate` & `is_inaccessiblememonly`, but not explicitly checked here
 is_foldable(effects::Effects) =
     is_consistent(effects) &&
-    is_noub(effects) &&
+    (is_noub(effects) || is_noub_if_noinbounds(effects)) &&
     is_effect_free(effects) &&
     is_terminates(effects)
 
@@ -262,29 +261,32 @@ struct EffectsOverride
     notaskstate::Bool
     inaccessiblememonly::Bool
     noub::Bool
+    noub_if_noinbounds::Bool
 end
 
 function encode_effects_override(eo::EffectsOverride)
-    e = 0x00
-    eo.consistent          && (e |= (0x01 << 0))
-    eo.effect_free         && (e |= (0x01 << 1))
-    eo.nothrow             && (e |= (0x01 << 2))
-    eo.terminates_globally && (e |= (0x01 << 3))
-    eo.terminates_locally  && (e |= (0x01 << 4))
-    eo.notaskstate         && (e |= (0x01 << 5))
-    eo.inaccessiblememonly && (e |= (0x01 << 6))
-    eo.noub                && (e |= (0x01 << 7))
+    e = 0x0000
+    eo.consistent          && (e |= (0x0001 << 0))
+    eo.effect_free         && (e |= (0x0001 << 1))
+    eo.nothrow             && (e |= (0x0001 << 2))
+    eo.terminates_globally && (e |= (0x0001 << 3))
+    eo.terminates_locally  && (e |= (0x0001 << 4))
+    eo.notaskstate         && (e |= (0x0001 << 5))
+    eo.inaccessiblememonly && (e |= (0x0001 << 6))
+    eo.noub                && (e |= (0x0001 << 7))
+    eo.noub_if_noinbounds  && (e |= (0x0001 << 8))
     return e
 end
 
-function decode_effects_override(e::UInt8)
+function decode_effects_override(e::UInt16)
     return EffectsOverride(
-        (e & (0x01 << 0)) != 0x00,
-        (e & (0x01 << 1)) != 0x00,
-        (e & (0x01 << 2)) != 0x00,
-        (e & (0x01 << 3)) != 0x00,
-        (e & (0x01 << 4)) != 0x00,
-        (e & (0x01 << 5)) != 0x00,
-        (e & (0x01 << 6)) != 0x00,
-        (e & (0x01 << 7)) != 0x00)
+        !iszero(e & (0x0001 << 0)),
+        !iszero(e & (0x0001 << 1)),
+        !iszero(e & (0x0001 << 2)),
+        !iszero(e & (0x0001 << 3)),
+        !iszero(e & (0x0001 << 4)),
+        !iszero(e & (0x0001 << 5)),
+        !iszero(e & (0x0001 << 6)),
+        !iszero(e & (0x0001 << 7)),
+        !iszero(e & (0x0001 << 8)))
 end
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 5f4faa4933e0a..bdf62ac0f10b8 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -563,9 +563,21 @@ function is_ipo_dataflow_analysis_profitable(effects::Effects)
              is_nothrow(effects) && is_noub(effects))
 end
 
-function is_getfield_with_boundscheck_arg(@nospecialize(stmt), sv::PostOptAnalysisState)
-    is_known_call(stmt, getfield, sv.ir) || return false
-    length(stmt.args) < 4 && return false
+function iscall_with_boundscheck(@nospecialize(stmt), sv::PostOptAnalysisState)
+    isexpr(stmt, :call) || return false
+    ft = argextype(stmt.args[1], sv.ir)
+    f = singleton_type(ft)
+    f === nothing && return false
+    if f === getfield
+        nargs = 4
+    elseif f === memoryref || f === memoryrefget || f === memoryref_isassigned
+        nargs = 4
+    elseif f === memoryrefset!
+        nargs = 5
+    else
+        return false
+    end
+    length(stmt.args) < nargs && return false
     boundscheck = stmt.args[end]
     argextype(boundscheck, sv.ir) === Bool || return false
     isa(boundscheck, SSAValue) || return false
@@ -573,15 +585,13 @@ function is_getfield_with_boundscheck_arg(@nospecialize(stmt), sv::PostOptAnalys
 end
 
 function is_conditional_noub(inst::Instruction, sv::PostOptAnalysisState)
-    # Special case: `:boundscheck` into `getfield`
     stmt = inst[:stmt]
-    is_getfield_with_boundscheck_arg(stmt, sv) || return false
-    barg = stmt.args[end]
+    iscall_with_boundscheck(stmt, sv) || return false
+    barg = stmt.args[end]::SSAValue
     bstmt = sv.ir[barg][:stmt]
     isexpr(bstmt, :boundscheck) || return false
     # If IR_FLAG_INBOUNDS is already set, no more conditional ub
     (!isempty(bstmt.args) && bstmt.args[1] === false) && return false
-    sv.any_conditional_ub = true
     return true
 end
 
@@ -596,7 +606,10 @@ function scan_non_dataflow_flags!(inst::Instruction, sv::PostOptAnalysisState)
     end
     sv.all_nothrow &= !iszero(flag & IR_FLAG_NOTHROW)
     if iszero(flag & IR_FLAG_NOUB)
-        if !is_conditional_noub(inst, sv)
+        # Special case: `:boundscheck` into `getfield` or memory operations is `:noub_if_noinbounds`
+        if is_conditional_noub(inst, sv)
+            sv.any_conditional_ub = true
+        else
             sv.all_noub = false
         end
     end
@@ -606,9 +619,9 @@ function scan_inconsistency!(inst::Instruction, sv::PostOptAnalysisState)
     flag = inst[:flag]
     stmt_inconsistent = iszero(flag & IR_FLAG_CONSISTENT)
     stmt = inst[:stmt]
-    # Special case: For getfield, we allow inconsistency of the :boundscheck argument
+    # Special case: For `getfield` and memory operations, we allow inconsistency of the :boundscheck argument
     (; inconsistent, tpdum) = sv
-    if is_getfield_with_boundscheck_arg(stmt, sv)
+    if iscall_with_boundscheck(stmt, sv)
         for i = 1:(length(stmt.args)-1)
             val = stmt.args[i]
             if isa(val, SSAValue)
@@ -703,7 +716,7 @@ function check_inconsistentcy!(sv::PostOptAnalysisState, scanner::BBScanner)
         idx = popfirst!(stmt_ip)
         inst = ir[SSAValue(idx)]
         stmt = inst[:stmt]
-        if is_getfield_with_boundscheck_arg(stmt, sv)
+        if iscall_with_boundscheck(stmt, sv)
             any_non_boundscheck_inconsistent = false
             for i = 1:(length(stmt.args)-1)
                 val = stmt.args[i]
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 12eec68938441..de1b3bd2cb79e 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1007,7 +1007,7 @@ function flags_for_effects(effects::Effects)
     if is_nothrow(effects)
         flags |= IR_FLAG_NOTHROW
     end
-    if is_noub(effects, false)
+    if is_noub(effects)
         flags |= IR_FLAG_NOUB
     end
     return flags
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 2d609d6dd3d08..fbd2112a1c0fe 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -21,20 +21,20 @@ function concrete_eval_invoke(interp::AbstractInterpreter,
             try
                 Core._call_in_world_total(world, args...)
             catch
-                return Pair{Any,Tuple{Bool,Bool}}(Bottom, (false, is_noub(effects, false)))
+                return Pair{Any,Tuple{Bool,Bool}}(Bottom, (false, is_noub(effects)))
             end
         end
         return Pair{Any,Tuple{Bool,Bool}}(Const(value), (true, true))
     else
         if is_constprop_edge_recursed(mi, irsv)
-            return Pair{Any,Tuple{Bool,Bool}}(nothing, (is_nothrow(effects), is_noub(effects, false)))
+            return Pair{Any,Tuple{Bool,Bool}}(nothing, (is_nothrow(effects), is_noub(effects)))
         end
         newirsv = IRInterpretationState(interp, code, mi, argtypes, world)
         if newirsv !== nothing
             newirsv.parent = irsv
             return ir_abstract_constant_propagation(interp, newirsv)
         end
-        return Pair{Any,Tuple{Bool,Bool}}(nothing, (is_nothrow(effects), is_noub(effects, false)))
+        return Pair{Any,Tuple{Bool,Bool}}(nothing, (is_nothrow(effects), is_noub(effects)))
     end
 end
 
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index a8610eb8fd653..eb43e77885d64 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -924,6 +924,7 @@ end
 
 function getfield_boundscheck(argtypes::Vector{Any})
     if length(argtypes) == 2
+        isvarargtype(argtypes[2]) && return :unsafe
         return :on
     elseif length(argtypes) == 3
         boundscheck = argtypes[3]
@@ -933,10 +934,10 @@ function getfield_boundscheck(argtypes::Vector{Any})
         end
     elseif length(argtypes) == 4
         boundscheck = argtypes[4]
+        isvarargtype(boundscheck) && return :unsafe
     else
         return :unsafe
     end
-    isvarargtype(boundscheck) && return :unsafe
     boundscheck = widenconditional(boundscheck)
     if widenconst(boundscheck) === Bool
         if isa(boundscheck, Const)
@@ -2144,7 +2145,6 @@ end
     return boundscheck ⊑ Bool && memtype ⊑ GenericMemoryRef && order ⊑ Symbol
 end
 
-
 # Query whether the given builtin is guaranteed not to throw given the argtypes
 @nospecs function _builtin_nothrow(𝕃::AbstractLattice, f, argtypes::Vector{Any}, rt)
     ⊑ = Core.Compiler.:⊑(𝕃)
@@ -2509,8 +2509,43 @@ function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argty
         else
             inaccessiblememonly = ALWAYS_FALSE
         end
-        return Effects(EFFECTS_TOTAL; consistent, effect_free, nothrow, inaccessiblememonly)
+        if f === memoryref || f === memoryrefget || f === memoryrefset! || f === memoryref_isassigned
+            noub = memoryop_noub(f, argtypes) ? ALWAYS_TRUE : ALWAYS_FALSE
+        else
+            noub = ALWAYS_TRUE
+        end
+        return Effects(EFFECTS_TOTAL; consistent, effect_free, nothrow, inaccessiblememonly, noub)
+    end
+end
+
+function memoryop_noub(@nospecialize(f), argtypes::Vector{Any})
+    nargs = length(argtypes)
+    nargs == 0 && return true # must throw and noub
+    lastargtype = argtypes[end]
+    isva = isvarargtype(lastargtype)
+    if f === memoryref
+        if nargs == 1 && !isva
+            return true
+        elseif nargs == 2 && !isva
+            return true
+        end
+        expected_nargs = 3
+    elseif f === memoryrefget || f === memoryref_isassigned
+        expected_nargs = 3
+    else
+        @assert f === memoryrefset! "unexpected memoryop is given"
+        expected_nargs = 4
+    end
+    if nargs == expected_nargs && !isva
+        boundscheck = widenconditional(lastargtype)
+        hasintersect(widenconst(boundscheck), Bool) || return true # must throw and noub
+        boundscheck isa Const && boundscheck.val === true && return true
+    elseif nargs > expected_nargs + 1
+        return true # must throw and noub
+    elseif !isva
+        return true # must throw and noub
     end
+    return false
 end
 
 """
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index fcb9944619831..48558c05f1e8d 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -445,6 +445,8 @@ function adjust_effects(ipo_effects::Effects, def::Method)
     end
     if is_effect_overridden(override, :noub)
         ipo_effects = Effects(ipo_effects; noub=ALWAYS_TRUE)
+    elseif is_effect_overridden(override, :noub_if_noinbounds) && ipo_effects.noub !== ALWAYS_TRUE
+        ipo_effects = Effects(ipo_effects; noub=NOUB_IF_NOINBOUNDS)
     end
     return ipo_effects
 end
diff --git a/base/compiler/validation.jl b/base/compiler/validation.jl
index 5505f5a2b423b..ef6602b082797 100644
--- a/base/compiler/validation.jl
+++ b/base/compiler/validation.jl
@@ -253,5 +253,3 @@ function is_valid_rvalue(@nospecialize(x))
 end
 
 is_valid_return(@nospecialize(x)) = is_valid_argument(x) || (isa(x, Expr) && x.head === :lambda)
-
-is_flag_set(byte::UInt8, flag::UInt8) = (byte & flag) == flag
diff --git a/base/docs/intrinsicsdocs.jl b/base/docs/intrinsicsdocs.jl
index effc9e859becf..9f6ec773ff9a8 100644
--- a/base/docs/intrinsicsdocs.jl
+++ b/base/docs/intrinsicsdocs.jl
@@ -3,14 +3,14 @@
 """
     Core.IR
 
-The Core.IR module exports the IR object model.
+The `Core.IR` module exports the IR object model.
 """
 Core.IR
 
 """
     Core.IntrinsicFunction <: Core.Builtin <: Function
 
-The Core.IntrinsicFunction function define some basic primitives for what defines the
+The `Core.IntrinsicFunction` function define some basic primitives for what defines the
 abilities and behaviors of a Julia program
 """
 Core.IntrinsicFunction
@@ -18,7 +18,7 @@ Core.IntrinsicFunction
 """
     Core.Intrinsics
 
-The Core.Intrinsics module holds the Core.IntrinsicFunction objects.
+The `Core.Intrinsics` module holds the `Core.IntrinsicFunction` objects.
 """
 Core.Intrinsics
 
@@ -26,21 +26,21 @@ Core.Intrinsics
     Core.memoryref(::GenericMemory)
     Core.memoryref(::GenericMemoryRef, index::Int, [boundscheck::Bool])
 
-Return a GenericMemoryRef for a GenericMemory. See [`MemoryRef`](@ref).
+Return a `GenericMemoryRef` for a `GenericMemory`. See [`MemoryRef`](@ref).
 """
 Core.memoryref
 
 """
     Core..memoryrefoffset(::GenericMemoryRef)
 
-Return the offset index that was used to construct the MemoryRef. See [`Core.memoryref`](@ref).
+Return the offset index that was used to construct the `MemoryRef`. See [`Core.memoryref`](@ref).
 """
 Core.memoryrefoffset
 
 """
     Core.memoryrefget(::GenericMemoryRef, ordering::Symbol, boundscheck::Bool)
 
-Return the value stored at the MemoryRef, throwing a BoundsError if the Memory is empty. See `ref[]`.
+Return the value stored at the `MemoryRef`, throwing a `BoundsError` if the `Memory` is empty. See `ref[]`.
 The memory ordering specified must be compatible with the `isatomic` parameter.
 """
 Core.memoryrefget
@@ -48,7 +48,7 @@ Core.memoryrefget
 """
     Core.memoryrefset!(::GenericMemoryRef, value, ordering::Symbol, boundscheck::Bool)
 
-Store the value to the MemoryRef, throwing a BoundsError if the Memory is empty. See `ref[] = value`.
+Store the value to the `MemoryRef`, throwing a `BoundsError` if the `Memory` is empty. See `ref[] = value`.
 The memory ordering specified must be compatible with the `isatomic` parameter.
 """
 Core.memoryrefset!
@@ -56,7 +56,8 @@ Core.memoryrefset!
 """
     Core.memoryref_isassigned(::GenericMemoryRef, ordering::Symbol, boundscheck::Bool)
 
-Return whether there is a value stored at the MemoryRef, returning false if the Memory is empty. See [`isassigned(::Base.RefValue)`](@ref), [`Core.memoryrefget`](@ref).
+Return whether there is a value stored at the `MemoryRef`, returning false if the `Memory`
+is empty. See [`isassigned(::Base.RefValue)`](@ref), [`Core.memoryrefget`](@ref).
 The memory ordering specified must be compatible with the `isatomic` parameter.
 """
 Core.memoryref_isassigned
diff --git a/base/essentials.jl b/base/essentials.jl
index a8a3ec3c15382..106826d140c57 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -13,9 +13,6 @@ length(a::Array) = getfield(getfield(getfield(a, :ref), :mem), :length)
 length(a::GenericMemory) = getfield(a, :length)
 throw_boundserror(A, I) = (@noinline; throw(BoundsError(A, I)))
 
-getindex(A::GenericMemory{:not_atomic}, i::Int) = memoryrefget(memoryref(memoryref(A), i, @_boundscheck), :not_atomic, false)
-getindex(A::GenericMemoryRef{:not_atomic}) = memoryrefget(A, :not_atomic, @_boundscheck)
-
 # multidimensional getindex will be defined later on
 
 ==(a::GlobalRef, b::GlobalRef) = a.mod === b.mod && a.name === b.name
@@ -214,7 +211,8 @@ macro _total_meta()
         #=:terminates_locally=#false,
         #=:notaskstate=#true,
         #=:inaccessiblememonly=#true,
-        #=:noub=#true))
+        #=:noub=#true,
+        #=:noub_if_noinbounds=#false))
 end
 # can be used in place of `@assume_effects :foldable` (supposed to be used for bootstrapping)
 macro _foldable_meta()
@@ -226,19 +224,8 @@ macro _foldable_meta()
         #=:terminates_locally=#false,
         #=:notaskstate=#true,
         #=:inaccessiblememonly=#true,
-        #=:noub=#true))
-end
-# can be used in place of `@assume_effects :nothrow` (supposed to be used for bootstrapping)
-macro _nothrow_meta()
-    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
-        #=:consistent=#false,
-        #=:effect_free=#false,
-        #=:nothrow=#true,
-        #=:terminates_globally=#false,
-        #=:terminates_locally=#false,
-        #=:notaskstate=#false,
-        #=:inaccessiblememonly=#false,
-        #=:noub=#false))
+        #=:noub=#true,
+        #=:noub_if_noinbounds=#false))
 end
 # can be used in place of `@assume_effects :terminates_locally` (supposed to be used for bootstrapping)
 macro _terminates_locally_meta()
@@ -250,7 +237,8 @@ macro _terminates_locally_meta()
         #=:terminates_locally=#true,
         #=:notaskstate=#false,
         #=:inaccessiblememonly=#false,
-        #=:noub=#false))
+        #=:noub=#false,
+        #=:noub_if_noinbounds=#false))
 end
 # can be used in place of `@assume_effects :terminates_globally` (supposed to be used for bootstrapping)
 macro _terminates_globally_meta()
@@ -262,7 +250,8 @@ macro _terminates_globally_meta()
         #=:terminates_locally=#true,
         #=:notaskstate=#false,
         #=:inaccessiblememonly=#false,
-        #=:noub=#false))
+        #=:noub=#false,
+        #=:noub_if_noinbounds=#false))
 end
 # can be used in place of `@assume_effects :effect_free :terminates_locally` (supposed to be used for bootstrapping)
 macro _effect_free_terminates_locally_meta()
@@ -274,7 +263,34 @@ macro _effect_free_terminates_locally_meta()
         #=:terminates_locally=#true,
         #=:notaskstate=#false,
         #=:inaccessiblememonly=#false,
-        #=:noub=#false))
+        #=:noub=#false,
+        #=:noub_if_noinbounds=#false))
+end
+# can be used in place of `@assume_effects :nothrow :noub` (supposed to be used for bootstrapping)
+macro _nothrow_noub_meta()
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
+        #=:consistent=#false,
+        #=:effect_free=#false,
+        #=:nothrow=#true,
+        #=:terminates_globally=#false,
+        #=:terminates_locally=#false,
+        #=:notaskstate=#false,
+        #=:inaccessiblememonly=#false,
+        #=:noub=#true,
+        #=:noub_if_noinbounds=#false))
+end
+# can be used in place of `@assume_effects :noub_if_noinbounds` (supposed to be used for bootstrapping)
+macro _noub_if_noinbounds_meta()
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
+        #=:consistent=#false,
+        #=:effect_free=#false,
+        #=:nothrow=#false,
+        #=:terminates_globally=#false,
+        #=:terminates_locally=#false,
+        #=:notaskstate=#false,
+        #=:inaccessiblememonly=#false,
+        #=:noub=#false,
+        #=:noub_if_noinbounds=#true))
 end
 
 # another version of inlining that propagates an inbounds context
@@ -285,6 +301,10 @@ macro _nospecializeinfer_meta()
     return Expr(:meta, :nospecializeinfer)
 end
 
+getindex(A::GenericMemory{:not_atomic}, i::Int) = (@_noub_if_noinbounds_meta;
+    memoryrefget(memoryref(memoryref(A), i, @_boundscheck), :not_atomic, false))
+getindex(A::GenericMemoryRef{:not_atomic}) = memoryrefget(A, :not_atomic, @_boundscheck)
+
 function iterate end
 
 """
@@ -787,11 +807,13 @@ end
 
 # linear indexing
 function getindex(A::Array, i::Int)
+    @_noub_if_noinbounds_meta
     @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) || throw_boundserror(A, (i,))
     memoryrefget(memoryref(getfield(A, :ref), i, false), :not_atomic, false)
 end
 # simple Array{Any} operations needed for bootstrap
 function setindex!(A::Array{Any}, @nospecialize(x), i::Int)
+    @_noub_if_noinbounds_meta
     @boundscheck ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A))) || throw_boundserror(A, (i,))
     memoryrefset!(memoryref(getfield(A, :ref), i, false), x, :not_atomic, false)
     return A
diff --git a/base/expr.jl b/base/expr.jl
index 4e418d140e5a6..3e68c68b2ac4f 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -477,6 +477,7 @@ The following `setting`s are supported.
 - `:notaskstate`
 - `:inaccessiblememonly`
 - `:noub`
+- `:noub_if_noinbounds`
 - `:foldable`
 - `:removable`
 - `:total`
@@ -714,8 +715,8 @@ macro assume_effects(args...)
         ex = nothing
         idx = length(args)
     end
-    (consistent, effect_free, nothrow, terminates_globally, terminates_locally, notaskstate, inaccessiblememonly, noub) =
-        (false, false, false, false, false, false, false, false, false)
+    consistent = effect_free = nothrow = terminates_globally = terminates_locally =
+        notaskstate = inaccessiblememonly = noub = noub_if_noinbounds = false
     for i in 1:idx
         org_setting = args[i]
         (setting, val) = compute_assumed_setting(org_setting)
@@ -735,6 +736,8 @@ macro assume_effects(args...)
             inaccessiblememonly = val
         elseif setting === :noub
             noub = val
+        elseif setting === :noub_if_noinbounds
+            noub_if_noinbounds = val
         elseif setting === :foldable
             consistent = effect_free = terminates_globally = noub = val
         elseif setting === :removable
@@ -747,15 +750,18 @@ macro assume_effects(args...)
     end
     if is_function_def(inner)
         return esc(pushmeta!(ex, :purity,
-            consistent, effect_free, nothrow, terminates_globally, terminates_locally, notaskstate, inaccessiblememonly, noub))
+            consistent, effect_free, nothrow, terminates_globally, terminates_locally,
+            notaskstate, inaccessiblememonly, noub, noub_if_noinbounds))
     elseif isexpr(ex, :macrocall) && ex.args[1] === Symbol("@ccall")
         ex.args[1] = GlobalRef(Base, Symbol("@ccall_effects"))
         insert!(ex.args, 3, Core.Compiler.encode_effects_override(Core.Compiler.EffectsOverride(
-            consistent, effect_free, nothrow, terminates_globally, terminates_locally, notaskstate, inaccessiblememonly, noub)))
+            consistent, effect_free, nothrow, terminates_globally, terminates_locally,
+            notaskstate, inaccessiblememonly, noub, noub_if_noinbounds)))
         return esc(ex)
     else # anonymous function case
         return Expr(:meta, Expr(:purity,
-            consistent, effect_free, nothrow, terminates_globally, terminates_locally, notaskstate, inaccessiblememonly, noub))
+            consistent, effect_free, nothrow, terminates_globally, terminates_locally,
+            notaskstate, inaccessiblememonly, noub, noub_if_noinbounds))
     end
 end
 
diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index 34c452af97ad2..51b25d453e5c4 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -196,17 +196,6 @@ function setindex!(A::Memory{T}, x, i1::Int, i2::Int, I::Int...) where {T}
     setindex!(A, x, i1)
 end
 
-function __inbounds_setindex!(A::Memory{T}, x, i1::Int) where {T}
-    val = x isa T ? x : convert(T,x)::T
-    ref = memoryref(memoryref(A), i1, false)
-    memoryrefset!(ref, val, :not_atomic, false)
-    return A
-end
-function __inbounds_setindex!(A::Memory{T}, x, i1::Int, i2::Int, I::Int...) where {T}
-    @boundscheck (i2 == 1 && all(==(1), I)) || throw_boundserror(A, (i1, i2, I...))
-    __inbounds_setindex(A, x, i1)
-end
-
 # Faster contiguous setindex! with copyto!
 function setindex!(A::Memory{T}, X::Memory{T}, I::AbstractUnitRange{Int}) where T
     @inline
diff --git a/base/strings/string.jl b/base/strings/string.jl
index 9f5995c25c558..29216ae97aa37 100644
--- a/base/strings/string.jl
+++ b/base/strings/string.jl
@@ -87,7 +87,7 @@ end
 
 # This is @assume_effects :effect_free :nothrow :terminates_globally @ccall jl_alloc_string(n::Csize_t)::Ref{String},
 # but the macro is not available at this time in bootstrap, so we write it manually.
-@eval _string_n(n::Integer) = $(Expr(:foreigncall, QuoteNode(:jl_alloc_string), Ref{String}, Expr(:call, Expr(:core, :svec), :Csize_t), 1, QuoteNode((:ccall,0xe)), :(convert(Csize_t, n))))
+@eval _string_n(n::Integer) = $(Expr(:foreigncall, QuoteNode(:jl_alloc_string), Ref{String}, Expr(:call, Expr(:core, :svec), :Csize_t), 1, QuoteNode((:ccall,0x000e)), :(convert(Csize_t, n))))
 
 """
     String(s::AbstractString)
diff --git a/base/tuple.jl b/base/tuple.jl
index c2e0a478cca48..2e1c5972c407d 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -30,8 +30,7 @@ size(@nospecialize(t::Tuple), d::Integer) = (d == 1) ? length(t) : throw(Argumen
 axes(@nospecialize t::Tuple) = (OneTo(length(t)),)
 getindex(@nospecialize(t::Tuple), i::Int) = getfield(t, i, @_boundscheck)
 getindex(@nospecialize(t::Tuple), i::Integer) = getfield(t, convert(Int, i), @_boundscheck)
-__inbounds_getindex(@nospecialize(t::Tuple), i::Int) = getfield(t, i, false)
-__inbounds_getindex(@nospecialize(t::Tuple), i::Integer) = getfield(t, convert(Int, i), false)
+__safe_getindex(@nospecialize(t::Tuple), i::Int) = (@_nothrow_noub_meta; getfield(t, i, false))
 getindex(t::Tuple, r::AbstractArray{<:Any,1}) = (eltype(t)[t[ri] for ri in r]...,)
 getindex(t::Tuple, b::AbstractArray{Bool,1}) = length(b) == length(t) ? getindex(t, findall(b)) : throw(BoundsError(t, b))
 getindex(t::Tuple, c::Colon) = t
diff --git a/src/common_symbols2.inc b/src/common_symbols2.inc
index 6850fcd3033d1..a4583fe39f186 100644
--- a/src/common_symbols2.inc
+++ b/src/common_symbols2.inc
@@ -50,7 +50,6 @@ jl_symbol("C_NULL"),
 jl_symbol("oftype"),
 jl_symbol("_growend!"),
 jl_symbol("Any"),
-jl_symbol("__inbounds_setindex!"),
 jl_symbol("Tuple"),
 jl_symbol("float.jl"),
 jl_symbol("ncodeunits"),
diff --git a/src/ircode.c b/src/ircode.c
index 5926f48ef1cf8..6ed1740b3667a 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -789,7 +789,7 @@ static jl_value_t *jl_decode_value(jl_ircode_state *s) JL_GC_DISABLED
 typedef jl_value_t jl_string_t; // for local expressibility
 
 #define IR_DATASIZE_FLAGS         sizeof(uint8_t)
-#define IR_DATASIZE_PURITY        sizeof(uint8_t)
+#define IR_DATASIZE_PURITY        sizeof(uint16_t)
 #define IR_DATASIZE_INLINING_COST sizeof(uint16_t)
 #define IR_DATASIZE_NSLOTS        sizeof(int32_t)
 typedef enum {
@@ -826,7 +826,7 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
                                                  code->nospecializeinfer, code->inlining, code->constprop);
     write_uint8(s.s, flags.packed);
     static_assert(sizeof(flags.packed) == IR_DATASIZE_FLAGS, "ir_datasize_flags is mismatched with the actual size");
-    write_uint8(s.s, code->purity.bits);
+    write_uint16(s.s, code->purity.bits);
     static_assert(sizeof(code->purity.bits) == IR_DATASIZE_PURITY, "ir_datasize_purity is mismatched with the actual size");
     write_uint16(s.s, code->inlining_cost);
     static_assert(sizeof(code->inlining_cost) == IR_DATASIZE_INLINING_COST, "ir_datasize_inlining_cost is mismatched with the actual size");
@@ -927,7 +927,7 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
     code->propagate_inbounds = flags.bits.propagate_inbounds;
     code->has_fcall = flags.bits.has_fcall;
     code->nospecializeinfer = flags.bits.nospecializeinfer;
-    code->purity.bits = read_uint8(s.s);
+    code->purity.bits = read_uint16(s.s);
     code->inlining_cost = read_uint16(s.s);
 
     size_t nslots = read_int32(&src);
diff --git a/src/jltypes.c b/src/jltypes.c
index d9cf77927efb7..9f27b14785dbe 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3132,7 +3132,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_bool_type,
                             jl_uint8_type,
                             jl_uint8_type,
-                            jl_uint8_type,
+                            jl_uint16_type,
                             jl_uint16_type),
                         jl_emptysvec,
                         0, 1, 22);
@@ -3201,7 +3201,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_bool_type,
                             jl_uint8_type,
                             jl_uint8_type,
-                            jl_uint8_type),
+                            jl_uint16_type),
                         jl_emptysvec,
                         0, 1, 10);
     //const static uint32_t method_constfields[1] = { 0x03fc065f }; // (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<6)|(1<<9)|(1<<10)|(1<<18)|(1<<19)|(1<<20)|(1<<21)|(1<<22)|(1<<23)|(1<<24)|(1<<25);
diff --git a/src/julia.h b/src/julia.h
index 0b3a010c32856..034280524cd11 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -248,20 +248,21 @@ typedef struct _jl_line_info_node_t {
 // the following mirrors `struct EffectsOverride` in `base/compiler/effects.jl`
 typedef union __jl_purity_overrides_t {
     struct {
-        uint8_t ipo_consistent          : 1;
-        uint8_t ipo_effect_free         : 1;
-        uint8_t ipo_nothrow             : 1;
-        uint8_t ipo_terminates_globally : 1;
+        uint16_t ipo_consistent          : 1;
+        uint16_t ipo_effect_free         : 1;
+        uint16_t ipo_nothrow             : 1;
+        uint16_t ipo_terminates_globally : 1;
         // Weaker form of `terminates` that asserts
         // that any control flow syntactically in the method
         // is guaranteed to terminate, but does not make
         // assertions about any called functions.
-        uint8_t ipo_terminates_locally  : 1;
-        uint8_t ipo_notaskstate         : 1;
-        uint8_t ipo_inaccessiblememonly : 1;
-        uint8_t ipo_noub                : 1;
+        uint16_t ipo_terminates_locally  : 1;
+        uint16_t ipo_notaskstate         : 1;
+        uint16_t ipo_inaccessiblememonly : 1;
+        uint16_t ipo_noub                : 1;
+        uint16_t ipo_noub_if_noinbounds  : 1;
     } overrides;
-    uint8_t bits;
+    uint16_t bits;
 } _jl_purity_overrides_t;
 
 // This type describes a single function body
diff --git a/src/method.c b/src/method.c
index 4e3062fef5246..8b89e66c62eb0 100644
--- a/src/method.c
+++ b/src/method.c
@@ -192,7 +192,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                         jl_error("In ccall calling convention, expected two argument tuple or symbol.");
                     }
                     JL_TYPECHK(ccall method definition, symbol, jl_get_nth_field(cc, 0));
-                    JL_TYPECHK(ccall method definition, uint8, jl_get_nth_field(cc, 1));
+                    JL_TYPECHK(ccall method definition, uint16, jl_get_nth_field(cc, 1));
                 }
                 jl_exprargset(e, 0, resolve_globals(jl_exprarg(e, 0), module, sparam_vals, binding_effects, 1));
                 i++;
@@ -327,7 +327,7 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
                 else if (ma == (jl_value_t*)jl_no_constprop_sym)
                     li->constprop = 2;
                 else if (jl_is_expr(ma) && ((jl_expr_t*)ma)->head == jl_purity_sym) {
-                    if (jl_expr_nargs(ma) == 8) {
+                    if (jl_expr_nargs(ma) == 9) {
                         li->purity.overrides.ipo_consistent = jl_unbox_bool(jl_exprarg(ma, 0));
                         li->purity.overrides.ipo_effect_free = jl_unbox_bool(jl_exprarg(ma, 1));
                         li->purity.overrides.ipo_nothrow = jl_unbox_bool(jl_exprarg(ma, 2));
@@ -336,6 +336,7 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
                         li->purity.overrides.ipo_notaskstate = jl_unbox_bool(jl_exprarg(ma, 5));
                         li->purity.overrides.ipo_inaccessiblememonly = jl_unbox_bool(jl_exprarg(ma, 6));
                         li->purity.overrides.ipo_noub = jl_unbox_bool(jl_exprarg(ma, 7));
+                        li->purity.overrides.ipo_noub_if_noinbounds = jl_unbox_bool(jl_exprarg(ma, 8));
                     }
                 }
                 else
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 9b1effced05e3..868457d6514cd 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2139,3 +2139,12 @@ end
 
 # issue #51823
 @test "include" in test_complete_context("inc", Main)[1]
+
+# REPL completions should not try to concrete-evaluate !:noub methods
+function very_unsafe_method(i::Int)
+    xs = Any[]
+    @inbounds xs[i]
+end
+let t = REPLCompletions.repl_eval_ex(:(unsafe_method(42)), @__MODULE__)
+    @test isnothing(t)
+end
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index 8e8290569cdb7..46081f38cf9aa 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -80,7 +80,7 @@ const TAGS = Any[
 const NTAGS = length(TAGS)
 @assert NTAGS == 255
 
-const ser_version = 25 # do not make changes without bumping the version #!
+const ser_version = 26 # do not make changes without bumping the version #!
 
 format_version(::AbstractSerializer) = ser_version
 format_version(s::Serializer) = s.version
@@ -1058,7 +1058,8 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
     isva = deserialize(s)::Bool
     is_for_opaque_closure = false
     nospecializeinfer = false
-    constprop = purity = 0x00
+    constprop = 0x00
+    purity = 0x0000
     template_or_is_opaque = deserialize(s)
     if isa(template_or_is_opaque, Bool)
         is_for_opaque_closure = template_or_is_opaque
@@ -1068,8 +1069,10 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
         if format_version(s) >= 14
             constprop = deserialize(s)::UInt8
         end
-        if format_version(s) >= 17
-            purity = deserialize(s)::UInt8
+        if format_version(s) >= 26
+            purity = deserialize(s)::UInt16
+        elseif format_version(s) >= 17
+            purity = UInt16(deserialize(s)::UInt8)
         end
         template = deserialize(s)
     else
@@ -1242,7 +1245,9 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
     if format_version(s) >= 14
         ci.constprop = deserialize(s)::UInt8
     end
-    if format_version(s) >= 17
+    if format_version(s) >= 26
+        ci.purity = deserialize(s)::UInt16
+    elseif format_version(s) >= 17
         ci.purity = deserialize(s)::UInt8
     end
     if format_version(s) >= 22
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 7ec1910dfb2a3..96d9017e0699b 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1173,3 +1173,70 @@ callgetfield_inbounds(x, f) = @inbounds callgetfield2(x, f)
 @test Base.infer_effects(callgetfield_inbounds, (Some{Any},Symbol)).noub ===
       Base.infer_effects(callgetfield_inbounds, (Some{Any},Symbol)).noub ===
       Core.Compiler.ALWAYS_FALSE
+
+# noub modeling for memory ops
+let (memoryref, memoryrefget, memoryref_isassigned, memoryrefset!) =
+        (Core.memoryref, Core.memoryrefget, Core.memoryref_isassigned, Core.memoryrefset!)
+    function builtin_effects(@nospecialize xs...)
+        interp = Core.Compiler.NativeInterpreter()
+        𝕃 = Core.Compiler.typeinf_lattice(interp)
+        rt = Core.Compiler.builtin_tfunction(interp, xs..., nothing)
+        return Core.Compiler.builtin_effects(𝕃, xs..., rt)
+    end
+    @test Core.Compiler.is_noub(builtin_effects(memoryref, Any[Memory,]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryref, Any[MemoryRef,Int]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryref, Any[MemoryRef,Int,Core.Const(true)]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryref, Any[MemoryRef,Int,Core.Const(false)]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryref, Any[MemoryRef,Int,Bool]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryref, Any[MemoryRef,Int,Int]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryref, Any[MemoryRef,Int,Vararg{Bool}]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryref, Any[MemoryRef,Vararg{Any}]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryrefget, Any[MemoryRef,Symbol,Core.Const(true)]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryrefget, Any[MemoryRef,Symbol,Core.Const(false)]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryrefget, Any[MemoryRef,Symbol,Bool]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryrefget, Any[MemoryRef,Symbol,Int]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryrefget, Any[MemoryRef,Symbol,Vararg{Bool}]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryrefget, Any[MemoryRef,Vararg{Any}]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryref_isassigned, Any[MemoryRef,Symbol,Core.Const(true)]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryref_isassigned, Any[MemoryRef,Symbol,Core.Const(false)]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryref_isassigned, Any[MemoryRef,Symbol,Bool]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryref_isassigned, Any[MemoryRef,Symbol,Int]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryref_isassigned, Any[MemoryRef,Symbol,Vararg{Bool}]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryref_isassigned, Any[MemoryRef,Vararg{Any}]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryrefset!, Any[MemoryRef,Any,Symbol,Core.Const(true)]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryrefset!, Any[MemoryRef,Any,Symbol,Core.Const(false)]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryrefset!, Any[MemoryRef,Any,Symbol,Bool]))
+    @test Core.Compiler.is_noub(builtin_effects(memoryrefset!, Any[MemoryRef,Any,Symbol,Int]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryrefset!, Any[MemoryRef,Any,Symbol,Vararg{Bool}]))
+    @test !Core.Compiler.is_noub(builtin_effects(memoryrefset!, Any[MemoryRef,Vararg{Any}]))
+    # `:boundscheck` taint should be refined by post-opt analysis
+    @test Base.infer_effects() do xs::Vector{Any}, i::Int
+        memoryrefget(memoryref(getfield(xs, :ref), i, Base.@_boundscheck), :not_atomic, Base.@_boundscheck)
+    end |> Core.Compiler.is_noub_if_noinbounds
+end
+
+# high level tests
+@test Core.Compiler.is_noub_if_noinbounds(Base.infer_effects(getindex, (Vector{Int},Int)))
+@test Core.Compiler.is_noub_if_noinbounds(Base.infer_effects(getindex, (Vector{Any},Int)))
+@test Core.Compiler.is_noub_if_noinbounds(Base.infer_effects(setindex!, (Vector{Int},Int,Int)))
+@test Core.Compiler.is_noub_if_noinbounds(Base.infer_effects(setindex!, (Vector{Any},Any,Int)))
+@test Core.Compiler.is_noub_if_noinbounds(Base.infer_effects(isassigned, (Vector{Int},Int)))
+@test Core.Compiler.is_noub_if_noinbounds(Base.infer_effects(isassigned, (Vector{Any},Int)))
+@test Base.infer_effects((Vector{Int},Int)) do xs, i
+    xs[i]
+end |> Core.Compiler.is_noub
+@test Base.infer_effects((Vector{Any},Int)) do xs, i
+    xs[i]
+end |> Core.Compiler.is_noub
+@test Base.infer_effects((Vector{Int},Int,Int)) do xs, x, i
+    xs[i] = x
+end |> Core.Compiler.is_noub
+@test Base.infer_effects((Vector{Any},Any,Int)) do xs, x, i
+    xs[i] = x
+end |> Core.Compiler.is_noub
+@test Base.infer_effects((Vector{Int},Int)) do xs, i
+    @inbounds xs[i]
+end |> !Core.Compiler.is_noub
+@test Base.infer_effects((Vector{Any},Int)) do xs, i
+    @inbounds xs[i]
+end |> !Core.Compiler.is_noub

From 234a7586c397140489d78fd149fa5a67eec56446 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sat, 18 Nov 2023 01:25:51 +0900
Subject: [PATCH 0275/1315] post-opt-analysis: use EA to refine `:effect_free`
 (#51494)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit is aiming to integrate EA into the Base compiler pipeline by
using it during the post-opt analysis to refine `:effect_free`
information. In doing so, this also generalizes `argescapes` field of
`Union{InferenceResult,CodeInstance}` to
`analysis_results::AnalysisResults` so that it can hold results of
multiple post-optimization analyses, where `AnalysisResults` is designed
to be linked-list like data structure. This is because an external
`AbstractInterpreter`, like `EscapeAnalyzer`, might perform several
post-optimization analyses. Honestly speaking, however, I’m not
completely satisfied with this solution yet. It might make more sense to
require a single post-optimization analysis for every
`AbstractInterpreter` always, as like what we do for the other fields
like `rettype`.

Co-authored-by: Keno Fischer <keno@juliacomputing.com>
---
 base/boot.jl                                  |   4 +-
 base/compiler/optimize.jl                     | 142 ++++++++++++++++--
 .../ssair/EscapeAnalysis/EscapeAnalysis.jl    |  13 +-
 base/compiler/ssair/inlining.jl               |   5 +
 base/compiler/typeinfer.jl                    |   2 +-
 base/compiler/types.jl                        |  29 +++-
 src/gf.c                                      |   6 +-
 src/jltypes.c                                 |   2 +-
 src/julia.h                                   |   2 +-
 src/opaque_closure.c                          |   2 +-
 test/compiler/EscapeAnalysis/EAUtils.jl       |  86 ++++-------
 test/compiler/effects.jl                      |  64 ++++++--
 test/core.jl                                  |   2 +-
 test/spawn.jl                                 |  14 ++
 14 files changed, 276 insertions(+), 97 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 74eaed090f879..ff3502c2f418e 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -481,12 +481,12 @@ end)
 function CodeInstance(
     mi::MethodInstance, @nospecialize(rettype), @nospecialize(inferred_const),
     @nospecialize(inferred), const_flags::Int32, min_world::UInt, max_world::UInt,
-    ipo_effects::UInt32, effects::UInt32, @nospecialize(argescapes#=::Union{Nothing,Vector{ArgEscapeInfo}}=#),
+    ipo_effects::UInt32, effects::UInt32, @nospecialize(analysis_results),
     relocatability::UInt8)
     return ccall(:jl_new_codeinst, Ref{CodeInstance},
         (Any, Any, Any, Any, Int32, UInt, UInt, UInt32, UInt32, Any, UInt8),
         mi, rettype, inferred_const, inferred, const_flags, min_world, max_world,
-        ipo_effects, effects, argescapes,
+        ipo_effects, effects, analysis_results,
         relocatability)
 end
 GlobalRef(m::Module, s::Symbol) = ccall(:jl_module_globalref, Ref{GlobalRef}, (Any, Any), m, s)
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index bdf62ac0f10b8..514f2e03c2cae 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -24,9 +24,7 @@ const IR_FLAG_INLINE      = UInt32(1) << 1
 # This statement is marked as @noinline by user
 const IR_FLAG_NOINLINE    = UInt32(1) << 2
 const IR_FLAG_THROW_BLOCK = UInt32(1) << 3
-# This statement may be removed if its result is unused. In particular,
-# it must be both :effect_free and :nothrow.
-# TODO: Separate these out.
+# This statement was proven :effect_free
 const IR_FLAG_EFFECT_FREE = UInt32(1) << 4
 # This statement was proven not to throw
 const IR_FLAG_NOTHROW     = UInt32(1) << 5
@@ -39,6 +37,12 @@ const IR_FLAG_REFINED     = UInt32(1) << 7
 # This is :noub == ALWAYS_TRUE
 const IR_FLAG_NOUB        = UInt32(1) << 8
 
+# TODO: Both of these should eventually go away once
+# This is :effect_free == EFFECT_FREE_IF_INACCESSIBLEMEMONLY
+const IR_FLAG_EFIIMO      = UInt32(1) << 9
+# This is :inaccessiblememonly == INACCESSIBLEMEM_OR_ARGMEMONLY
+const IR_FLAG_INACCESSIBLE_OR_ARGMEM = UInt32(1) << 10
+
 const IR_FLAGS_EFFECTS = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW | IR_FLAG_CONSISTENT | IR_FLAG_NOUB
 
 const TOP_TUPLE = GlobalRef(Core, :tuple)
@@ -514,7 +518,6 @@ function get!(lazyagdomtree::LazyAugmentedDomtree)
     return lazyagdomtree.agdomtree = AugmentedDomtree(cfg, domtree)
 end
 
-# TODO refine `:effect_free` using EscapeAnalysis
 mutable struct PostOptAnalysisState
     const result::InferenceResult
     const ir::IRCode
@@ -522,8 +525,10 @@ mutable struct PostOptAnalysisState
     const tpdum::TwoPhaseDefUseMap
     const lazypostdomtree::LazyPostDomtree
     const lazyagdomtree::LazyAugmentedDomtree
+    const ea_analysis_pending::Vector{Int}
     all_retpaths_consistent::Bool
     all_effect_free::Bool
+    effect_free_if_argmem_only::Union{Nothing,Bool}
     all_nothrow::Bool
     all_noub::Bool
     any_conditional_ub::Bool
@@ -532,12 +537,14 @@ mutable struct PostOptAnalysisState
         tpdum = TwoPhaseDefUseMap(length(ir.stmts))
         lazypostdomtree = LazyPostDomtree(ir)
         lazyagdomtree = LazyAugmentedDomtree(ir)
-        return new(result, ir, inconsistent, tpdum, lazypostdomtree, lazyagdomtree, true, true, true, true, false)
+        return new(result, ir, inconsistent, tpdum, lazypostdomtree, lazyagdomtree, Int[],
+                   true, true, nothing, true, true, false)
     end
 end
 
 give_up_refinements!(sv::PostOptAnalysisState) =
-    sv.all_retpaths_consistent = sv.all_effect_free = sv.all_nothrow = sv.all_noub = false
+    sv.all_retpaths_consistent = sv.all_effect_free = sv.effect_free_if_argmem_only =
+    sv.all_nothrow = sv.all_noub = false
 
 function any_refinable(sv::PostOptAnalysisState)
     effects = sv.result.ipo_effects
@@ -547,12 +554,47 @@ function any_refinable(sv::PostOptAnalysisState)
             (!is_noub(effects) & sv.all_noub))
 end
 
-function refine_effects!(sv::PostOptAnalysisState)
+struct GetNativeEscapeCache{CodeCache}
+    code_cache::CodeCache
+    GetNativeEscapeCache(code_cache::CodeCache) where CodeCache = new{CodeCache}(code_cache)
+end
+GetNativeEscapeCache(interp::AbstractInterpreter) = GetNativeEscapeCache(code_cache(interp))
+function ((; code_cache)::GetNativeEscapeCache)(mi::MethodInstance)
+    codeinst = get(code_cache, mi, nothing)
+    codeinst isa CodeInstance || return false
+    argescapes = traverse_analysis_results(codeinst) do @nospecialize result
+        return result isa EscapeAnalysis.ArgEscapeCache ? result : nothing
+    end
+    if argescapes !== nothing
+        return argescapes
+    end
+    effects = decode_effects(codeinst.ipo_purity_bits)
+    if is_effect_free(effects) && is_inaccessiblememonly(effects)
+        # We might not have run EA on simple frames without any escapes (e.g. when optimization
+        # is skipped when result is constant-folded by abstract interpretation). If those
+        # frames aren't inlined, the accuracy of EA for caller context takes a big hit.
+        # This is a HACK to avoid that, but obviously, a more comprehensive fix would be ideal.
+        return true
+    end
+    return false
+end
+
+function refine_effects!(interp::AbstractInterpreter, sv::PostOptAnalysisState)
+    if !is_effect_free(sv.result.ipo_effects) && sv.all_effect_free && !isempty(sv.ea_analysis_pending)
+        ir = sv.ir
+        nargs = length(ir.argtypes)
+        estate = EscapeAnalysis.analyze_escapes(ir, nargs, GetNativeEscapeCache(interp))
+        argescapes = EscapeAnalysis.ArgEscapeCache(estate)
+        stack_analysis_result!(sv.result, argescapes)
+        validate_mutable_arg_escapes!(estate, sv)
+    end
+
     any_refinable(sv) || return false
     effects = sv.result.ipo_effects
     sv.result.ipo_effects = Effects(effects;
         consistent = sv.all_retpaths_consistent ? ALWAYS_TRUE : effects.consistent,
-        effect_free = sv.all_effect_free ? ALWAYS_TRUE : effects.effect_free,
+        effect_free = sv.all_effect_free ? ALWAYS_TRUE :
+                      sv.effect_free_if_argmem_only === true ? EFFECT_FREE_IF_INACCESSIBLEMEMONLY : effects.effect_free,
         nothrow = sv.all_nothrow ? true : effects.nothrow,
         noub = sv.all_noub ? (sv.any_conditional_ub ? NOUB_IF_NOINBOUNDS : ALWAYS_TRUE) : effects.noub)
     return true
@@ -584,6 +626,58 @@ function iscall_with_boundscheck(@nospecialize(stmt), sv::PostOptAnalysisState)
     return true
 end
 
+function check_all_args_noescape!(sv::PostOptAnalysisState, ir::IRCode, @nospecialize(stmt),
+                                  estate::EscapeAnalysis.EscapeState)
+    stmt isa Expr || return false
+    if isexpr(stmt, :invoke)
+        startidx = 2
+    elseif isexpr(stmt, :new)
+        startidx = 1
+    else
+        return false
+    end
+    for i = startidx:length(stmt.args)
+        arg = stmt.args[i]
+        argt = argextype(arg, ir)
+        if is_mutation_free_argtype(argt)
+            continue
+        end
+        # See if we can find the allocation
+        if isa(arg, Argument)
+            if EscapeAnalysis.has_no_escape(EscapeAnalysis.ignore_argescape(estate[arg]))
+                # Even if we prove everything else effect_free, the best we can
+                # say is :effect_free_if_argmem_only
+                if sv.effect_free_if_argmem_only === nothing
+                    sv.effect_free_if_argmem_only = true
+                end
+            else
+                sv.effect_free_if_argmem_only = false
+            end
+            return false
+        elseif isa(arg, SSAValue)
+            EscapeAnalysis.has_no_escape(estate[arg]) || return false
+            check_all_args_noescape!(sv, ir, ir[arg][:stmt], estate) || return false
+        else
+            return false
+        end
+    end
+    return true
+end
+
+function validate_mutable_arg_escapes!(estate::EscapeAnalysis.EscapeState, sv::PostOptAnalysisState)
+    ir = sv.ir
+    for idx in sv.ea_analysis_pending
+        # See if any mutable memory was allocated in this function and determined
+        # not to escape.
+        inst = ir[SSAValue(idx)]
+        stmt = inst[:stmt]
+        if !check_all_args_noescape!(sv, ir, stmt, estate)
+            return sv.all_effect_free = false
+        end
+    end
+    return true
+end
+
 function is_conditional_noub(inst::Instruction, sv::PostOptAnalysisState)
     stmt = inst[:stmt]
     iscall_with_boundscheck(stmt, sv) || return false
@@ -595,14 +689,30 @@ function is_conditional_noub(inst::Instruction, sv::PostOptAnalysisState)
     return true
 end
 
+const IR_FLAGS_NEEDS_EA = IR_FLAG_EFIIMO | IR_FLAG_INACCESSIBLE_OR_ARGMEM
+
 function scan_non_dataflow_flags!(inst::Instruction, sv::PostOptAnalysisState)
     flag = inst[:flag]
+    # If we can prove that the argmem does not escape the current function, we can
+    # refine this to :effect_free.
+    needs_ea_validation = (flag & IR_FLAGS_NEEDS_EA) == IR_FLAGS_NEEDS_EA
     stmt = inst[:stmt]
-    if !isterminator(stmt) && stmt !== nothing
-        # ignore control flow node – they are not removable on their own and thus not
-        # have `IR_FLAG_EFFECT_FREE` but still do not taint `:effect_free`-ness of
-        # the whole method invocation
-        sv.all_effect_free &= !iszero(flag & IR_FLAG_EFFECT_FREE)
+    if !needs_ea_validation
+        if !isterminator(stmt) && stmt !== nothing
+            # ignore control flow node – they are not removable on their own and thus not
+            # have `IR_FLAG_EFFECT_FREE` but still do not taint `:effect_free`-ness of
+            # the whole method invocation
+            sv.all_effect_free &= !iszero(flag & IR_FLAG_EFFECT_FREE)
+        end
+    elseif sv.all_effect_free
+        if (isexpr(stmt, :invoke) || isexpr(stmt, :new) ||
+            # HACK for performance: limit the scope of EA to code with object field access only,
+            # since its abilities to reason about e.g. arrays are currently very limited anyways.
+            is_known_call(stmt, setfield!, sv.ir))
+            push!(sv.ea_analysis_pending, inst.idx)
+        else
+            sv.all_effect_free = false
+        end
     end
     sv.all_nothrow &= !iszero(flag & IR_FLAG_NOTHROW)
     if iszero(flag & IR_FLAG_NOUB)
@@ -747,7 +857,9 @@ function check_inconsistentcy!(sv::PostOptAnalysisState, scanner::BBScanner)
 end
 
 function ipo_dataflow_analysis!(interp::AbstractInterpreter, ir::IRCode, result::InferenceResult)
-    is_ipo_dataflow_analysis_profitable(result.ipo_effects) || return false
+    if !is_ipo_dataflow_analysis_profitable(result.ipo_effects)
+        return false
+    end
 
     @assert isempty(ir.new_nodes) "IRCode should be compacted before post-opt analysis"
 
@@ -772,7 +884,7 @@ function ipo_dataflow_analysis!(interp::AbstractInterpreter, ir::IRCode, result:
         end
     end
 
-    return refine_effects!(sv)
+    return refine_effects!(interp, sv)
 end
 
 # run the optimization work
diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index a770a4a92146c..70d45819574fd 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -610,7 +610,7 @@ end
 
 Analyzes escape information in `ir`:
 - `nargs`: the number of actual arguments of the analyzed call
-- `get_escape_cache(::MethodInstance) -> Union{Nothing,ArgEscapeCache}`:
+- `get_escape_cache(::MethodInstance) -> Union{Bool,ArgEscapeCache}`:
   retrieves cached argument escape information
 """
 function analyze_escapes(ir::IRCode, nargs::Int, get_escape_cache)
@@ -1061,11 +1061,14 @@ function escape_invoke!(astate::AnalysisState, pc::Int, args::Vector{Any})
     first_idx, last_idx = 2, length(args)
     # TODO inspect `astate.ir.stmts[pc][:info]` and use const-prop'ed `InferenceResult` if available
     cache = astate.get_escape_cache(mi)
-    if cache === nothing
-        return add_conservative_changes!(astate, pc, args, 2)
-    else
-        cache = cache::ArgEscapeCache
+    if cache isa Bool
+        if cache
+            return nothing # guaranteed to have no escape
+        else
+            return add_conservative_changes!(astate, pc, args, 2)
+        end
     end
+    cache = cache::ArgEscapeCache
     ret = SSAValue(pc)
     retinfo = astate.estate[ret] # escape information imposed on the call statement
     method = mi.def::Method
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index de1b3bd2cb79e..26dacbc3388f3 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1003,6 +1003,11 @@ function flags_for_effects(effects::Effects)
     end
     if is_effect_free(effects)
         flags |= IR_FLAG_EFFECT_FREE
+    elseif is_effect_free_if_inaccessiblememonly(effects)
+        flags |= IR_FLAG_EFIIMO
+    end
+    if is_inaccessiblemem_or_argmemonly(effects)
+        flags |= IR_FLAG_INACCESSIBLE_OR_ARGMEM
     end
     if is_nothrow(effects)
         flags |= IR_FLAG_NOTHROW
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 48558c05f1e8d..c1230980c42a6 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -330,7 +330,7 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult,
         widenconst(result_type), rettype_const, inferred_result,
         const_flags, first(valid_worlds), last(valid_worlds),
         # TODO: Actually do something with non-IPO effects
-        encode_effects(result.ipo_effects), encode_effects(result.ipo_effects), result.argescapes,
+        encode_effects(result.ipo_effects), encode_effects(result.ipo_effects), result.analysis_results,
         relocatability)
 end
 
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index dde5335b36f68..41fde10dfedf4 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -59,6 +59,16 @@ end
 
 abstract type ForwardableArgtypes end
 
+struct AnalysisResults
+    result
+    next::AnalysisResults
+    AnalysisResults(@nospecialize(result), next::AnalysisResults) = new(result, next)
+    AnalysisResults(@nospecialize(result)) = new(result)
+    # NullAnalysisResults() = new(nothing)
+    # global const NULL_ANALYSIS_RESULTS = NullAnalysisResults()
+end
+const NULL_ANALYSIS_RESULTS = AnalysisResults(nothing)
+
 """
     InferenceResult(linfo::MethodInstance, [argtypes::ForwardableArgtypes, 𝕃::AbstractLattice])
 
@@ -75,14 +85,14 @@ mutable struct InferenceResult
     valid_worlds::WorldRange # if inference and optimization is finished
     ipo_effects::Effects     # if inference is finished
     effects::Effects         # if optimization is finished
-    argescapes               # ::ArgEscapeCache if optimized, nothing otherwise
+    analysis_results::AnalysisResults # AnalysisResults with e.g. result::ArgEscapeCache if optimized, otherwise NULL_ANALYSIS_RESULTS
     is_src_volatile::Bool    # `src` has been cached globally as the compressed format already, allowing `src` to be used destructively
     function InferenceResult(linfo::MethodInstance, cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
         # def = linfo.def
         # nargs = def isa Method ? Int(def.nargs) : 0
         # @assert length(cache_argtypes) == nargs
         return new(linfo, cache_argtypes, overridden_by_const, nothing, nothing,
-            WorldRange(), Effects(), Effects(), nothing, false)
+            WorldRange(), Effects(), Effects(), NULL_ANALYSIS_RESULTS, false)
     end
 end
 InferenceResult(linfo::MethodInstance, 𝕃::AbstractLattice=fallback_lattice) =
@@ -90,6 +100,21 @@ InferenceResult(linfo::MethodInstance, 𝕃::AbstractLattice=fallback_lattice) =
 InferenceResult(linfo::MethodInstance, argtypes::ForwardableArgtypes, 𝕃::AbstractLattice=fallback_lattice) =
     InferenceResult(linfo, matching_cache_argtypes(𝕃, linfo, argtypes)...)
 
+function stack_analysis_result!(inf_result::InferenceResult, @nospecialize(result))
+    return inf_result.analysis_results = AnalysisResults(result, inf_result.analysis_results)
+end
+
+function traverse_analysis_results(callback, (;analysis_results)::Union{InferenceResult,CodeInstance})
+    analysis_results isa AnalysisResults || return nothing
+    while isdefined(analysis_results, :next)
+        if (result = callback(analysis_results.result)) !== nothing
+            return result
+        end
+        analysis_results = analysis_results.next
+    end
+    return nothing
+end
+
 """
     inf_params::InferenceParams
 
diff --git a/src/gf.c b/src/gf.c
index f2365ee040670..f964927aa3368 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -288,7 +288,7 @@ JL_DLLEXPORT jl_code_instance_t* jl_new_codeinst(
         jl_method_instance_t *mi, jl_value_t *rettype,
         jl_value_t *inferred_const, jl_value_t *inferred,
         int32_t const_flags, size_t min_world, size_t max_world,
-        uint32_t ipo_effects, uint32_t effects, jl_value_t *argescapes,
+        uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
         uint8_t relocatability);
 
 jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_args_t fptr) JL_GC_DISABLED
@@ -486,7 +486,7 @@ JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
         jl_method_instance_t *mi, jl_value_t *rettype,
         jl_value_t *inferred_const, jl_value_t *inferred,
         int32_t const_flags, size_t min_world, size_t max_world,
-        uint32_t ipo_effects, uint32_t effects, jl_value_t *argescapes,
+        uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
         uint8_t relocatability
         /*, jl_array_t *edges, int absolute_max*/)
 {
@@ -514,7 +514,7 @@ JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
     jl_atomic_store_relaxed(&codeinst->next, NULL);
     codeinst->ipo_purity_bits = ipo_effects;
     jl_atomic_store_relaxed(&codeinst->purity_bits, effects);
-    codeinst->argescapes = argescapes;
+    codeinst->analysis_results = analysis_results;
     codeinst->relocatability = relocatability;
     return codeinst;
 }
diff --git a/src/jltypes.c b/src/jltypes.c
index 9f27b14785dbe..b1830ec4e765e 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3255,7 +3255,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             //"edges",
                             //"absolute_max",
                             "ipo_purity_bits", "purity_bits",
-                            "argescapes",
+                            "analysis_results",
                             "isspecsig", "precompile", "relocatability",
                             "invoke", "specptr"), // function object decls
                         jl_svec(15,
diff --git a/src/julia.h b/src/julia.h
index 034280524cd11..acb700c0bd936 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -436,7 +436,7 @@ typedef struct _jl_code_instance_t {
     //     uint8_t nonoverlayed        : 1;
     //     uint8_t notaskstate         : 2;
     //     uint8_t inaccessiblememonly : 2;
-    jl_value_t *argescapes; // escape information of call arguments
+    jl_value_t *analysis_results; // Analysis results about this code (IPO-safe)
 
     // compilation state cache
     _Atomic(uint8_t) specsigflags; // & 0b001 == specptr is a specialized function signature for specTypes->rettype
diff --git a/src/opaque_closure.c b/src/opaque_closure.c
index d73beff0f8587..8b7cc7292be22 100644
--- a/src/opaque_closure.c
+++ b/src/opaque_closure.c
@@ -138,7 +138,7 @@ JL_DLLEXPORT jl_code_instance_t* jl_new_codeinst(
         jl_method_instance_t *mi, jl_value_t *rettype,
         jl_value_t *inferred_const, jl_value_t *inferred,
         int32_t const_flags, size_t min_world, size_t max_world,
-        uint32_t ipo_effects, uint32_t effects, jl_value_t *argescapes,
+        uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
         uint8_t relocatability);
 
 JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tupletype_t *argt, jl_value_t *rt_lb, jl_value_t *rt_ub,
diff --git a/test/compiler/EscapeAnalysis/EAUtils.jl b/test/compiler/EscapeAnalysis/EAUtils.jl
index 937113c34c872..27428e07e920a 100644
--- a/test/compiler/EscapeAnalysis/EAUtils.jl
+++ b/test/compiler/EscapeAnalysis/EAUtils.jl
@@ -62,14 +62,13 @@ __clear_cache!() = empty!(GLOBAL_EA_CODE_CACHE)
 # imports
 import .CC:
     AbstractInterpreter, NativeInterpreter, WorldView, WorldRange,
-    InferenceParams, OptimizationParams, get_world_counter, get_inference_cache, code_cache
+    InferenceParams, OptimizationParams, get_world_counter, get_inference_cache, code_cache,
+    ipo_dataflow_analysis!, cache_result!
 # usings
 using Core:
     CodeInstance, MethodInstance, CodeInfo
 using .CC:
-    InferenceResult, OptimizationState, IRCode, copy as cccopy,
-    @timeit, convert_to_ircode, slot2reg, compact!, ssa_inlining_pass!, sroa_pass!,
-    adce_pass!, JLOptions, verify_ir, verify_linetable
+    InferenceResult, OptimizationState, IRCode
 using .EA: analyze_escapes, ArgEscapeCache, EscapeInfo, EscapeState
 
 struct CodeCache
@@ -144,17 +143,31 @@ function CC.setindex!(wvc::WorldView{EscapeAnalyzerCacheView}, ci::CodeInstance,
     return wvc
 end
 
-function CC.optimize(interp::EscapeAnalyzer, opt::OptimizationState, caller::InferenceResult)
-    ir = run_passes_ipo_safe_with_ea(interp, opt.src, opt, caller)
-    CC.ipo_dataflow_analysis!(interp, ir, caller)
-    return CC.finish(interp, opt, ir, caller)
+function CC.ipo_dataflow_analysis!(interp::EscapeAnalyzer, ir::IRCode, caller::InferenceResult)
+    # run EA on all frames that have been optimized
+    nargs = let def = caller.linfo.def; isa(def, Method) ? Int(def.nargs) : 0; end
+    get_escape_cache = GetEscapeCache(interp)
+    estate = try
+        analyze_escapes(ir, nargs, get_escape_cache)
+    catch err
+        @error "error happened within EA, inspect `Main.failed_escapeanalysis`"
+        Main.failed_escapeanalysis = FailedAnalysis(ir, nargs, get_escape_cache)
+        rethrow(err)
+    end
+    if caller.linfo === interp.entry_mi
+        # return back the result
+        interp.result = EscapeResultForEntry(CC.copy(ir), estate, caller.linfo)
+    end
+    record_escapes!(interp, caller, estate, ir)
+
+    @invoke CC.ipo_dataflow_analysis!(interp::AbstractInterpreter, ir::IRCode, caller::InferenceResult)
 end
 
 function record_escapes!(interp::EscapeAnalyzer,
-    caller::InferenceResult, estate::EscapeState, cacheir::IRCode)
-    cache = ArgEscapeCache(estate)
-    ecache = EscapeCacheInfo(cache, estate, cacheir)
-    return caller.argescapes = ecache
+    caller::InferenceResult, estate::EscapeState, ir::IRCode)
+    argescapes = ArgEscapeCache(estate)
+    ecacheinfo = EscapeCacheInfo(argescapes, estate, ir)
+    return CC.stack_analysis_result!(caller, ecacheinfo)
 end
 
 struct GetEscapeCache
@@ -162,8 +175,8 @@ struct GetEscapeCache
     GetEscapeCache(interp::EscapeAnalyzer) = new(interp.escape_cache)
 end
 function ((; escape_cache)::GetEscapeCache)(mi::MethodInstance)
-    cached = get(escape_cache.cache, mi, nothing)
-    return cached === nothing ? nothing : cached.argescapes
+    ecacheinfo = get(escape_cache.cache, mi, nothing)
+    return ecacheinfo === nothing ? false : ecacheinfo.argescapes
 end
 
 struct FailedAnalysis
@@ -172,45 +185,12 @@ struct FailedAnalysis
     get_escape_cache::GetEscapeCache
 end
 
-function run_passes_ipo_safe_with_ea(interp::EscapeAnalyzer,
-    ci::CodeInfo, sv::OptimizationState, caller::InferenceResult)
-    @timeit "convert"   ir = convert_to_ircode(ci, sv)
-    @timeit "slot2reg"  ir = slot2reg(ir, ci, sv)
-    # TODO: Domsorting can produce an updated domtree - no need to recompute here
-    @timeit "compact 1" ir = compact!(ir)
-    @timeit "Inlining"  ir = ssa_inlining_pass!(ir, sv.inlining, ci.propagate_inbounds)
-    # @timeit "verify 2" verify_ir(ir)
-    @timeit "compact 2" ir = compact!(ir)
-    @timeit "SROA"      ir = sroa_pass!(ir, sv.inlining)
-    @timeit "ADCE"      ir = adce_pass!(ir, sv.inlining)
-    @timeit "compact 3" ir = compact!(ir, true)
-    if JLOptions().debug_level == 2
-        @timeit "verify 3" (verify_ir(ir); verify_linetable(ir.linetable))
-    end
-    nargs = let def = sv.linfo.def; isa(def, Method) ? Int(def.nargs) : 0; end
-    get_escape_cache = GetEscapeCache(interp)
-    local estate::EscapeState
-    try
-        @timeit "EA" estate = analyze_escapes(ir, nargs, get_escape_cache)
-    catch err
-        @error "error happened within EA, inspect `Main.failed_escapeanalysis`"
-        Main.failed_escapeanalysis = FailedAnalysis(ir, nargs, get_escape_cache)
-        rethrow(err)
-    end
-    if caller.linfo === interp.entry_mi
-        # return back the result
-        interp.result = EscapeResultForEntry(cccopy(ir), estate, sv.linfo)
-    end
-    record_escapes!(interp, caller, estate, ir)
-    return ir
-end
-
-function CC.cache_result!(interp::EscapeAnalyzer, result::InferenceResult)
-    argescapes = result.argescapes
-    if argescapes isa EscapeCacheInfo
-        interp.escape_cache.cache[result.linfo] = argescapes
+function CC.cache_result!(interp::EscapeAnalyzer, inf_result::InferenceResult)
+    ecacheinfo = CC.traverse_analysis_results(inf_result) do @nospecialize result
+        return result isa EscapeCacheInfo ? result : nothing
     end
-    return @invoke CC.cache_result!(interp::AbstractInterpreter, result::InferenceResult)
+    ecacheinfo isa EscapeCacheInfo && (interp.escape_cache.cache[inf_result.linfo] = ecacheinfo)
+    return @invoke CC.cache_result!(interp::AbstractInterpreter, inf_result::InferenceResult)
 end
 
 # printing
@@ -278,7 +258,7 @@ Base.show(io::IO, result::EscapeResult) = print_with_info(io, result)
 @eval Base.iterate(res::EscapeResult, state=1) =
     return state > $(fieldcount(EscapeResult)) ? nothing : (getfield(res, state), state+1)
 
-Base.show(io::IO, cached::EscapeCacheInfo) = show(io, EscapeResult(cached.ir, cached.state))
+Base.show(io::IO, ecacheinfo::EscapeCacheInfo) = show(io, EscapeResult(ecacheinfo.ir, ecacheinfo.state))
 
 # adapted from https://github.com/JuliaDebug/LoweredCodeUtils.jl/blob/4612349432447e868cf9285f647108f43bd0a11c/src/codeedges.jl#L881-L897
 function print_with_info(io::IO, result::EscapeResult)
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 96d9017e0699b..5405066263d79 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1133,20 +1133,60 @@ end
     post_opt_refine_effect_free(y, true)
 end |> Core.Compiler.is_effect_free
 
-# effects for Cmd construction
-for f in (() -> `a b c`, () -> `a a$("bb")a $("c")`)
-    effects = Base.infer_effects(f)
-    @test Core.Compiler.is_effect_free(effects)
-    @test Core.Compiler.is_terminates(effects)
-    @test Core.Compiler.is_noub(effects)
-    @test !Core.Compiler.is_consistent(effects)
+# Check EA-based refinement of :effect_free
+Base.@assume_effects :nothrow @noinline _noinline_set!(x) = (x[] = 1; nothing)
+
+function set_ref_with_unused_arg_1(_)
+    x = Ref(0)
+    _noinline_set!(x)
+    return nothing
 end
-let effects = Base.infer_effects(x -> `a $x`, (Any,))
-    @test !Core.Compiler.is_effect_free(effects)
-    @test !Core.Compiler.is_terminates(effects)
-    @test !Core.Compiler.is_noub(effects)
-    @test !Core.Compiler.is_consistent(effects)
+function set_ref_with_unused_arg_2(_)
+    x = @noinline Ref(0)
+    _noinline_set!(x)
+    return nothing
 end
+function set_arg_ref!(x)
+    _noinline_set!(x)
+    y = Ref(false)
+    y[] && (Main.x = x)
+    return nothing
+end
+
+function set_arr_with_unused_arg_1(_)
+    x = Int[0]
+    _noinline_set!(x)
+    return nothing
+end
+function set_arr_with_unused_arg_2(_)
+    x = @noinline Int[0]
+    _noinline_set!(x)
+    return nothing
+end
+function set_arg_arr!(x)
+    _noinline_set!(x)
+    y = Bool[false]
+    y[] && (Main.x = x)
+    return nothing
+end
+
+# This is inferable by type analysis only since the arguments have no mutable memory
+@test Core.Compiler.is_effect_free_if_inaccessiblememonly(Base.infer_effects(_noinline_set!, (Base.RefValue{Int},)))
+@test Core.Compiler.is_effect_free_if_inaccessiblememonly(Base.infer_effects(_noinline_set!, (Vector{Int},)))
+for func in (set_ref_with_unused_arg_1, set_ref_with_unused_arg_2,
+             set_arr_with_unused_arg_1, set_arr_with_unused_arg_2)
+    effects = Base.infer_effects(func, (Nothing,))
+    @test Core.Compiler.is_inaccessiblememonly(effects)
+    @test Core.Compiler.is_effect_free(effects)
+end
+
+# These need EA
+@test Core.Compiler.is_effect_free(Base.infer_effects(set_ref_with_unused_arg_1, (Base.RefValue{Int},)))
+@test Core.Compiler.is_effect_free(Base.infer_effects(set_ref_with_unused_arg_2, (Base.RefValue{Int},)))
+@test Core.Compiler.is_effect_free_if_inaccessiblememonly(Base.infer_effects(set_arg_ref!, (Base.RefValue{Int},)))
+@test_broken Core.Compiler.is_effect_free(Base.infer_effects(set_arr_with_unused_arg_1, (Vector{Int},)))
+@test_broken Core.Compiler.is_effect_free(Base.infer_effects(set_arr_with_unused_arg_2, (Vector{Int},)))
+@test_broken Core.Compiler.is_effect_free_if_inaccessiblememonly(Base.infer_effects(set_arg_arr!, (Vector{Int},)))
 
 function issue51837(; openquotechar::Char, newlinechar::Char)
     ncodeunits(openquotechar) == 1 || throw(ArgumentError("`openquotechar` must be a single-byte character"))
diff --git a/test/core.jl b/test/core.jl
index e9a680cd506c4..00ab41e4ecd48 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -14,7 +14,7 @@ include("testenv.jl")
 # sanity tests that our built-in types are marked correctly for const fields
 for (T, c) in (
         (Core.CodeInfo, []),
-        (Core.CodeInstance, [:def, :rettype, :rettype_const, :ipo_purity_bits, :argescapes]),
+        (Core.CodeInstance, [:def, :rettype, :rettype_const, :ipo_purity_bits, :analysis_results]),
         (Core.Method, [#=:name, :module, :file, :line, :primary_world, :sig, :slot_syms, :external_mt, :nargs, :called, :nospecialize, :nkw, :isva, :is_for_opaque_closure, :constprop=#]),
         (Core.MethodInstance, [#=:def, :specTypes, :sparam_vals=#]),
         (Core.MethodTable, [:module]),
diff --git a/test/spawn.jl b/test/spawn.jl
index 1fab652199ee0..dab1857399375 100644
--- a/test/spawn.jl
+++ b/test/spawn.jl
@@ -1015,5 +1015,19 @@ end
     args = ["ab ^` c", " \" ", "\"", ascii95, ascii95,
             "\"\\\"\\", "", "|", "&&", ";"];
     @test Base.shell_escape_wincmd(Base.escape_microsoft_c_args(args...)) == "\"ab ^` c\" \" \\\" \" \"\\\"\" \" !\\\"#\$%^&'^(^)*+,-./0123456789:;^<=^>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^^_`abcdefghijklmnopqrstuvwxyz{^|}~\" \" ^!\\\"#\$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\" \"\\\"\\\\\\\"\\\\\" \"\" ^| ^&^& ;"
+end
 
+# effects for Cmd construction
+for f in (() -> `a b c`, () -> `a a$("bb")a $("c")`)
+    effects = Base.infer_effects(f)
+    @test Core.Compiler.is_effect_free(effects)
+    @test Core.Compiler.is_terminates(effects)
+    @test Core.Compiler.is_noub(effects)
+    @test !Core.Compiler.is_consistent(effects)
+end
+let effects = Base.infer_effects(x -> `a $x`, (Any,))
+    @test !Core.Compiler.is_effect_free(effects)
+    @test !Core.Compiler.is_terminates(effects)
+    @test !Core.Compiler.is_noub(effects)
+    @test !Core.Compiler.is_consistent(effects)
 end

From 045b6f9c8837776d11e75a73841d6c23718c4e08 Mon Sep 17 00:00:00 2001
From: Stefan Karpinski <stefan@karpinski.org>
Date: Fri, 17 Nov 2023 11:46:13 -0500
Subject: [PATCH 0276/1315] invmod(n::BitInteger): efficient native modular
 inverses (#52180)

Implement algorithm described in https://arxiv.org/pdf/2204.04342.pdf.
The algorithm is pleasingly simple and efficient and the generic Julia
implementation is also really enjoyable.
---
 NEWS.md          |  3 +++
 base/intfuncs.jl | 39 ++++++++++++++++++++++++++++++++++++++-
 test/intfuncs.jl | 33 ++++++++++++++++++++++++++++++++-
 3 files changed, 73 insertions(+), 2 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 30dd2e6e03783..c9b968da3c1e0 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -63,6 +63,9 @@ New library functions
 
 New library features
 --------------------
+
+* `invmod(n, T)` where `T` is a native integer type now computes the modular inverse of `n` in the modular integer ring that `T` defines ([#52180]).
+* `invmod(n)` is an abbreviation for `invmod(n, typeof(n))` for native integer types ([#52180]).
 * `replace(string, pattern...)` now supports an optional `IO` argument to
   write the output to a stream rather than returning a string ([#48625]).
 * `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
diff --git a/base/intfuncs.jl b/base/intfuncs.jl
index 558d55c118b34..ea35da0910736 100644
--- a/base/intfuncs.jl
+++ b/base/intfuncs.jl
@@ -218,7 +218,7 @@ gcdx(a::T, b::T) where T<:Real = throw(MethodError(gcdx, (a,b)))
 # multiplicative inverse of n mod m, error if none
 
 """
-    invmod(n, m)
+    invmod(n::Integer, m::Integer)
 
 Take the inverse of `n` modulo `m`: `y` such that ``n y = 1 \\pmod m``,
 and ``div(y,m) = 0``. This will throw an error if ``m = 0``, or if
@@ -257,6 +257,43 @@ function invmod(n::Integer, m::Integer)
     return mod(x, m)
 end
 
+"""
+    invmod(n::Integer, T) where {T <: Base.BitInteger}
+    invmod(n::T) where {T <: Base.BitInteger}
+
+Compute the modular inverse of `n` in the integer ring of type `T`, i.e. modulo
+`2^N` where `N = 8*sizeof(T)` (e.g. `N = 32` for `Int32`). In other words these
+methods satisfy the following identities:
+```
+n * invmod(n) == 1
+(n * invmod(n, T)) % T == 1
+(n % T) * invmod(n, T) == 1
+```
+Note that `*` here is modular multiplication in the integer ring, `T`.
+
+Specifying the modulus implied by an integer type as an explicit value is often
+inconvenient since the modulus is by definition too big to be represented by the
+type.
+
+The modular inverse is computed much more efficiently than the general case
+using the algorithm described in https://arxiv.org/pdf/2204.04342.pdf.
+
+!!! compat "Julia 1.11"
+    The `invmod(n)` and `invmod(n, T)` methods require Julia 1.11 or later.
+"""
+invmod(n::Integer, ::Type{T}) where {T<:BitInteger} = invmod(n % T)
+
+function invmod(n::T) where {T<:BitInteger}
+    isodd(n) || throw(DomainError(n, "Argument must be odd."))
+    x = (3*n ⊻ 2) % T
+    y = (1 - n*x) % T
+    for _ = 1:trailing_zeros(2*sizeof(T))
+        x *= y + true
+        y *= y
+    end
+    return x
+end
+
 # ^ for any x supporting *
 to_power_type(x) = convert(Base._return_type(*, Tuple{typeof(x), typeof(x)}), x)
 @noinline throw_domerr_powbysq(::Any, p) = throw(DomainError(p, LazyString(
diff --git a/test/intfuncs.jl b/test/intfuncs.jl
index ceaac235a3da9..ed661b2806fb5 100644
--- a/test/intfuncs.jl
+++ b/test/intfuncs.jl
@@ -221,7 +221,7 @@ end
     @test_throws MethodError gcdx(MyOtherRational(2//3), MyOtherRational(3//4))
 end
 
-@testset "invmod" begin
+@testset "invmod(n, m)" begin
     @test invmod(6, 31) === 26
     @test invmod(-1, 3) === 2
     @test invmod(1, -3) === -2
@@ -256,6 +256,37 @@ end
     end
 end
 
+@testset "invmod(n)" begin
+    for T in (Int8,UInt8,Int16,UInt16,Int32,UInt32,Int64,UInt64,Int128,UInt128)
+        if sizeof(T) ≤ 2
+            # test full domain for small types
+            for a = typemin(T)+true:T(2):typemax(T)
+                b = invmod(a)
+                @test a * b == 1
+            end
+        else
+            # test random sample for large types
+            for _ = 1:2^12
+                a = rand(T) | true
+                b = invmod(a)
+                @test a * b == 1
+            end
+        end
+    end
+end
+
+@testset "invmod(n, T)" begin
+    for S in (Int8,UInt8,Int16,UInt16,Int32,UInt32,Int64,UInt64,Int128,UInt128),
+        T in (Int8,UInt8,Int16,UInt16,Int32,UInt32,Int64,UInt64,Int128,UInt128)
+        for _ = 1:2^8
+            a = rand(S) | true
+            b = invmod(a, T)
+            @test (a * b) % T == 1
+            @test (a % T) * b == 1
+        end
+    end
+end
+
 @testset "powermod" begin
     @test powermod(2, 3, 5) == 3
     @test powermod(2, 3, -5) == -2

From 9aa7980358349ee7017fa614525f571ffa92c55d Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 17 Nov 2023 13:58:01 -0500
Subject: [PATCH 0277/1315] codegen: ensure i1 bool is widened to i8 before
 storing (#52189)

Teach value_to_pointer to convert primitive types to their stored
representation first, to avoid exposing undef bits later (via memcpy).

Take this opportunity to also generalizes the support for zext Bool to
anywhere inside any struct for changing any bitwidth to a multiple of 8
bytes. This would change a vector like <2 x i4> from occupying i8 to i16
(c.f. LLVM's LangRef), if such an operation were expressible in Julia
today. And take this opportunity to do a bit of code cleanup, now that
codegen is better and using helpers from LLVM.

Fixes #52127
---
 src/cgutils.cpp    |   3 --
 src/codegen.cpp    |  27 +++-------
 src/intrinsics.cpp | 119 ++++++++++++++++++++++++++++++---------------
 test/llvmcall2.jl  |   9 ++++
 4 files changed, 98 insertions(+), 60 deletions(-)

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index ea59d4e298f1c..b560f84a4db8c 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -783,9 +783,6 @@ static Type *_julia_struct_to_llvm(jl_codegen_params_t *ctx, LLVMContext &ctxt,
                 lty = JuliaType::get_prjlvalue_ty(ctxt);
                 isvector = false;
             }
-            else if (ty == (jl_value_t*)jl_bool_type) {
-                lty = getInt8Ty(ctxt);
-            }
             else if (jl_is_uniontype(ty)) {
                 // pick an Integer type size such that alignment will generally be correct,
                 // and always end with an Int8 (selector byte).
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 3209b076b5746..e09cec49e6c0a 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -2163,9 +2163,12 @@ static bool valid_as_globalinit(const Value *v) {
     return isa<Constant>(v);
 }
 
+static Value *zext_struct(jl_codectx_t &ctx, Value *V);
+
 static inline jl_cgval_t value_to_pointer(jl_codectx_t &ctx, Value *v, jl_value_t *typ, Value *tindex)
 {
     Value *loc;
+    v = zext_struct(ctx, v);
     if (valid_as_globalinit(v)) { // llvm can't handle all the things that could be inside a ConstantExpr
         assert(jl_is_concrete_type(typ)); // not legal to have an unboxed abstract type
         loc = get_pointer_to_constant(ctx.emission_context, cast<Constant>(v), Align(julia_alignment(typ)), "_j_const", *jl_Module);
@@ -2291,17 +2294,6 @@ static void alloc_def_flag(jl_codectx_t &ctx, jl_varinfo_t& vi)
 
 // --- utilities ---
 
-static Constant *undef_value_for_type(Type *T) {
-    auto tracked = CountTrackedPointers(T);
-    Constant *undef;
-    if (tracked.count)
-        // make sure gc pointers (including ptr_phi of union-split) are initialized to NULL
-        undef = Constant::getNullValue(T);
-    else
-        undef = UndefValue::get(T);
-    return undef;
-}
-
 static void CreateTrap(IRBuilder<> &irbuilder, bool create_new_block)
 {
     Function *f = irbuilder.GetInsertBlock()->getParent();
@@ -3574,7 +3566,7 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
     if (f == jl_builtin_is && nargs == 2) {
         // emit comparison test
         Value *ans = emit_f_is(ctx, argv[1], argv[2]);
-        *ret = mark_julia_type(ctx, ctx.builder.CreateZExt(ans, getInt8Ty(ctx.builder.getContext())), false, jl_bool_type);
+        *ret = mark_julia_type(ctx, ans, false, jl_bool_type);
         return true;
     }
 
@@ -3613,8 +3605,6 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         if (jl_is_type_type(ty.typ) && !jl_has_free_typevars(ty.typ)) {
             jl_value_t *tp0 = jl_tparam0(ty.typ);
             Value *isa_result = emit_isa(ctx, arg, tp0, Twine()).first;
-            if (isa_result->getType() == getInt1Ty(ctx.builder.getContext()))
-                isa_result = ctx.builder.CreateZExt(isa_result, getInt8Ty(ctx.builder.getContext()));
             *ret = mark_julia_type(ctx, isa_result, false, jl_bool_type);
             return true;
         }
@@ -5551,16 +5541,15 @@ static Value *emit_condition(jl_codectx_t &ctx, const jl_cgval_t &condV, const T
         emit_typecheck(ctx, condV, (jl_value_t*)jl_bool_type, msg);
     }
     if (isbool) {
-        Value *cond = emit_unbox(ctx, getInt8Ty(ctx.builder.getContext()), condV, (jl_value_t*)jl_bool_type);
-        assert(cond->getType() == getInt8Ty(ctx.builder.getContext()));
-        return ctx.builder.CreateXor(ctx.builder.CreateTrunc(cond, getInt1Ty(ctx.builder.getContext())), ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 1));
+        Value *cond = emit_unbox(ctx, getInt1Ty(ctx.builder.getContext()), condV, (jl_value_t*)jl_bool_type);
+        return ctx.builder.CreateNot(cond);
     }
     if (condV.isboxed) {
         return ctx.builder.CreateICmpEQ(boxed(ctx, condV),
             track_pjlvalue(ctx, literal_pointer_val(ctx, jl_false)));
     }
-    // not a boolean
-    return ConstantInt::get(getInt1Ty(ctx.builder.getContext()), 0); // TODO: replace with Undef
+    // not a boolean (unreachable dead code)
+    return UndefValue::get(getInt1Ty(ctx.builder.getContext()));
 }
 
 static Value *emit_condition(jl_codectx_t &ctx, jl_value_t *cond, const Twine &msg)
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index b4d493ee80800..fde27b910faea 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -173,12 +173,7 @@ static Type *INTT(Type *t, const DataLayout &DL)
 
 static Value *uint_cnvt(jl_codectx_t &ctx, Type *to, Value *x)
 {
-    Type *t = x->getType();
-    if (t == to)
-        return x;
-    if (to->getPrimitiveSizeInBits() < x->getType()->getPrimitiveSizeInBits())
-        return ctx.builder.CreateTrunc(x, to);
-    return ctx.builder.CreateZExt(x, to);
+    return ctx.builder.CreateZExtOrTrunc(x, to);
 }
 
 static Constant *julia_const_to_llvm(jl_codectx_t &ctx, const void *ptr, jl_datatype_t *bt)
@@ -317,25 +312,90 @@ static Constant *julia_const_to_llvm(jl_codectx_t &ctx, jl_value_t *e)
     return julia_const_to_llvm(ctx, e, (jl_datatype_t*)bt);
 }
 
+static Constant *undef_value_for_type(Type *T) {
+    auto tracked = CountTrackedPointers(T);
+    Constant *undef;
+    if (tracked.count)
+        // make sure gc pointers (including ptr_phi of union-split) are initialized to NULL
+        undef = Constant::getNullValue(T);
+    else
+        undef = UndefValue::get(T);
+    return undef;
+}
+
+// rebuild a struct type with any i1 Bool (e.g. the llvmcall type) widened to i8 (the native size for memcpy)
+static Type *zext_struct_type(Type *T)
+{
+    if (auto *AT = dyn_cast<ArrayType>(T)) {
+        return ArrayType::get(AT->getElementType(), AT->getNumElements());
+    }
+    else if (auto *ST = dyn_cast<StructType>(T)) {
+        SmallVector<Type*> Elements(ST->element_begin(), ST->element_end());
+        for (size_t i = 0; i < Elements.size(); i++) {
+            Elements[i] = zext_struct_type(Elements[i]);
+        }
+        return StructType::get(ST->getContext(), Elements, ST->isPacked());
+    }
+    else if (auto *VT = dyn_cast<VectorType>(T)) {
+        return VectorType::get(zext_struct_type(VT->getElementType()), VT);
+    }
+    else if (auto *IT = dyn_cast<IntegerType>(T)) {
+        unsigned BitWidth = IT->getBitWidth();
+        if (alignTo(BitWidth, 8) != BitWidth)
+            return IntegerType::get(IT->getContext(), alignTo(BitWidth, 8));
+    }
+    return T;
+}
+
+// rebuild a struct with any i1 Bool (e.g. the llvmcall type) widened to i8 (the native size for memcpy)
+static Value *zext_struct_helper(jl_codectx_t &ctx, Value *V, Type *T2)
+{
+    Type *T = V->getType();
+    if (T == T2)
+        return V;
+    if (auto *AT = dyn_cast<ArrayType>(T2)) {
+        Value *V2 = undef_value_for_type(AT);
+        for (size_t i = 0; i < AT->getNumElements(); i++) {
+            Value *E = zext_struct_helper(ctx, ctx.builder.CreateExtractValue(V, i), AT->getElementType());
+            V2 = ctx.builder.CreateInsertValue(V2, E, i);
+        }
+        return V2;
+    }
+    else if (auto *ST = dyn_cast<StructType>(T2)) {
+        Value *V2 = undef_value_for_type(ST);
+        for (size_t i = 0; i < ST->getNumElements(); i++) {
+            Value *E = zext_struct_helper(ctx, ctx.builder.CreateExtractValue(V, i), ST->getElementType(i));
+            V2 = ctx.builder.CreateInsertValue(V2, E, i);
+        }
+        return V2;
+    }
+    else if (T2->isIntegerTy() || T2->isVectorTy()) {
+        return ctx.builder.CreateZExt(V, T2);
+    }
+    return V;
+}
+
+static Value *zext_struct(jl_codectx_t &ctx, Value *V)
+{
+    return zext_struct_helper(ctx, V, zext_struct_type(V->getType()));
+}
+
 static Value *emit_unboxed_coercion(jl_codectx_t &ctx, Type *to, Value *unboxed)
 {
+    if (unboxed->getType() == to)
+        return unboxed;
+    if (CastInst::castIsValid(Instruction::Trunc, unboxed, to))
+        return ctx.builder.CreateTrunc(unboxed, to);
+    unboxed = zext_struct(ctx, unboxed);
     Type *ty = unboxed->getType();
     if (ty == to)
         return unboxed;
     bool frompointer = ty->isPointerTy();
     bool topointer = to->isPointerTy();
     const DataLayout &DL = jl_Module->getDataLayout();
-    if (ty->isIntegerTy(1) && to->isIntegerTy(8)) {
-        // bools may be stored internally as int8
-        unboxed = ctx.builder.CreateZExt(unboxed, to);
-    }
-    else if (ty->isIntegerTy(8) && to->isIntegerTy(1)) {
-        // bools may be stored internally as int8
-        unboxed = ctx.builder.CreateTrunc(unboxed, to);
-    }
-    else if (ty->isVoidTy() || DL.getTypeSizeInBits(ty) != DL.getTypeSizeInBits(to)) {
+    if (ty->isVoidTy() || DL.getTypeSizeInBits(ty) != DL.getTypeSizeInBits(to)) {
         // this can happen in dead code
-        //emit_unreachable(ctx);
+        CreateTrap(ctx.builder);
         return UndefValue::get(to);
     }
     if (frompointer && topointer) {
@@ -380,7 +440,7 @@ static Value *emit_unbox(jl_codectx_t &ctx, Type *to, const jl_cgval_t &x, jl_va
         if (type_is_ghost(to)) {
             return NULL;
         }
-        //emit_unreachable(ctx);
+        CreateTrap(ctx.builder);
         return UndefValue::get(to); // type mismatch error
     }
 
@@ -446,17 +506,9 @@ static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value *dest
         return;
     }
 
-    Value *unboxed = nullptr;
-    if (!x.ispointer()) { // already unboxed, but sometimes need conversion
-        unboxed = x.V;
-        assert(unboxed);
-    }
-
-    // bools stored as int8, but can be narrowed to int1 often
-    if (x.typ == (jl_value_t*)jl_bool_type)
-        unboxed = emit_unbox(ctx, getInt8Ty(ctx.builder.getContext()), x, (jl_value_t*)jl_bool_type);
-
-    if (unboxed) {
+    if (!x.ispointer()) { // already unboxed, but sometimes need conversion (e.g. f32 -> i32)
+        assert(x.V);
+        Value *unboxed = zext_struct(ctx, x.V);
         Type *dest_ty = unboxed->getType()->getPointerTo();
         if (dest->getType() != dest_ty)
             dest = emit_bitcast(ctx, dest, dest_ty);
@@ -1445,12 +1497,7 @@ static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **arg
                  Intrinsic::smul_with_overflow :
                  Intrinsic::umul_with_overflow)))));
         FunctionCallee intr = Intrinsic::getDeclaration(jl_Module, intr_id, ArrayRef<Type*>(t));
-        Value *res = ctx.builder.CreateCall(intr, {x, y});
-        Value *val = ctx.builder.CreateExtractValue(res, ArrayRef<unsigned>(0));
-        setName(ctx.emission_context, val, "checked");
-        Value *obit = ctx.builder.CreateExtractValue(res, ArrayRef<unsigned>(1));
-        setName(ctx.emission_context, obit, "overflow");
-        Value *obyte = ctx.builder.CreateZExt(obit, getInt8Ty(ctx.builder.getContext()));
+        Value *tupval = ctx.builder.CreateCall(intr, {x, y});
 
         jl_value_t *params[2];
         params[0] = xtyp;
@@ -1458,10 +1505,6 @@ static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **arg
         jl_datatype_t *tuptyp = (jl_datatype_t*)jl_apply_tuple_type_v(params, 2);
         *newtyp = tuptyp;
 
-        Value *tupval;
-        tupval = UndefValue::get(julia_type_to_llvm(ctx, (jl_value_t*)tuptyp));
-        tupval = ctx.builder.CreateInsertValue(tupval, val, ArrayRef<unsigned>(0));
-        tupval = ctx.builder.CreateInsertValue(tupval, obyte, ArrayRef<unsigned>(1));
         return tupval;
     }
 
diff --git a/test/llvmcall2.jl b/test/llvmcall2.jl
index 07b27fc407433..e3e89bb916f2d 100644
--- a/test/llvmcall2.jl
+++ b/test/llvmcall2.jl
@@ -73,3 +73,12 @@ end
     jl_str = unsafe_string(str)
     @test length(jl_str) > 4
 end
+
+
+# boolean structs
+const NT4I = NTuple{4, VecElement{Int}}
+const NT4B = NTuple{4, VecElement{Bool}}
+f_nt4b(x, y) = ccall("llvm.sadd.with.overflow", llvmcall, Pair{NT4B, NT4B}, (NT4B, NT4B), x, y)
+f_nt4i(x, y) = ccall("llvm.sadd.with.overflow", llvmcall, Pair{NT4I, NT4B}, (NT4I, NT4I), x, y)
+@test f_nt4b((false, true, false, true), (false, false, true, true)) === (NT4B((false, true, true, false)) => NT4B((false, false, false, true)))
+@test f_nt4i((typemin(Int), 0, typemax(Int), typemax(Int)), (-1, typemax(Int),-1, 1)) === (NT4I((typemax(Int), typemax(Int), typemax(Int)-1, typemin(Int))) => NT4B((true, false, false, true)))

From 20440fd9a379f450c3c4317cb320669c9dc6d631 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Fri, 17 Nov 2023 13:46:52 -0600
Subject: [PATCH 0278/1315] Move "Creating Packages" from Pkg.jl docs (#52102)

---
 doc/make.jl                            |   1 +
 doc/src/manual/style-guide.md          |   2 +-
 doc/src/tutorials/creating-packages.md | 634 +++++++++++++++++++++++++
 3 files changed, 636 insertions(+), 1 deletion(-)
 create mode 100644 doc/src/tutorials/creating-packages.md

diff --git a/doc/make.jl b/doc/make.jl
index d0bd52247aa81..da0fb8242913b 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -128,6 +128,7 @@ BaseDocs = [
 StdlibDocs = [stdlib.targetfile for stdlib in STDLIB_DOCS]
 
 Tutorials = [
+    "tutorials/creating-packages.md",
     "tutorials/profile.md",
     "tutorials/external.md",
 ]
diff --git a/doc/src/manual/style-guide.md b/doc/src/manual/style-guide.md
index f892d6284fb10..19b4908927187 100644
--- a/doc/src/manual/style-guide.md
+++ b/doc/src/manual/style-guide.md
@@ -346,7 +346,7 @@ This would provide custom showing of vectors with a specific new element type. W
 this should be avoided. The trouble is that users will expect a well-known type like `Vector()`
 to behave in a certain way, and overly customizing its behavior can make it harder to work with.
 
-## Avoid type piracy
+## [Avoid type piracy](@id avoid-type-piracy)
 
 "Type piracy" refers to the practice of extending or redefining methods in Base
 or other packages on types that you have not defined. In extreme cases, you can crash Julia
diff --git a/doc/src/tutorials/creating-packages.md b/doc/src/tutorials/creating-packages.md
new file mode 100644
index 0000000000000..a01141a2f6e48
--- /dev/null
+++ b/doc/src/tutorials/creating-packages.md
@@ -0,0 +1,634 @@
+# [Creating Packages](@id creating-packages-tutorial)
+
+## Generating files for a package
+
+!!! note
+    The [PkgTemplates](https://github.com/invenia/PkgTemplates.jl) package offers an easy, repeatable, and
+    customizable way to generate the files for a new package. It can also generate files needed for Documentation, CI, etc.
+    We recommend that you use PkgTemplates for creating
+    new packages instead of using the minimal `pkg> generate` functionality described below.
+
+To generate the bare minimum files for a new package, use `pkg> generate`.
+
+```julia-repl
+(@v1.8) pkg> generate HelloWorld
+```
+
+This creates a new project `HelloWorld` in a subdirectory by the same name, with the following files (visualized with the external [`tree` command](https://linux.die.net/man/1/tree)):
+
+```julia-repl
+shell> tree HelloWorld/
+HelloWorld/
+├── Project.toml
+└── src
+    └── HelloWorld.jl
+
+2 directories, 2 files
+```
+
+The `Project.toml` file contains the name of the package, its unique UUID, its version, the authors and potential dependencies:
+
+```toml
+name = "HelloWorld"
+uuid = "b4cd1eb8-1e24-11e8-3319-93036a3eb9f3"
+version = "0.1.0"
+authors = ["Some One <someone@email.com>"]
+
+[deps]
+```
+
+The content of `src/HelloWorld.jl` is:
+
+```julia
+module HelloWorld
+
+greet() = print("Hello World!")
+
+end # module
+```
+
+We can now activate the project by using the path to the directory where it is installed, and load the package:
+
+```julia-repl
+pkg> activate ./HelloWorld
+
+julia> import HelloWorld
+
+julia> HelloWorld.greet()
+Hello World!
+```
+
+For the rest of the tutorial we enter inside the directory of the project, for convenience:
+
+```julia-repl
+julia> cd("HelloWorld")
+```
+
+## Adding dependencies to the project
+
+Let’s say we want to use the standard library package `Random` and the registered package `JSON` in our project.
+We simply `add` these packages (note how the prompt now shows the name of the newly generated project,
+since we `activate`d it):
+
+```julia-repl
+(HelloWorld) pkg> add Random JSON
+   Resolving package versions...
+    Updating `~/HelloWorld/Project.toml`
+  [682c06a0] + JSON v0.21.3
+  [9a3f8284] + Random
+    Updating `~/HelloWorld/Manifest.toml`
+  [682c06a0] + JSON v0.21.3
+  [69de0a69] + Parsers v2.4.0
+  [ade2ca70] + Dates
+ ...
+```
+
+Both `Random` and `JSON` got added to the project’s `Project.toml` file, and the resulting dependencies got added to the `Manifest.toml` file.
+The resolver has installed each package with the highest possible version, while still respecting the compatibility that each package enforces on its dependencies.
+
+We can now use both `Random` and `JSON` in our project. Changing `src/HelloWorld.jl` to
+
+```julia
+module HelloWorld
+
+import Random
+import JSON
+
+greet() = print("Hello World!")
+greet_alien() = print("Hello ", Random.randstring(8))
+
+end # module
+```
+
+and reloading the package, the new `greet_alien` function that uses `Random` can be called:
+
+```julia-repl
+julia> HelloWorld.greet_alien()
+Hello aT157rHV
+```
+
+## Defining a public API
+
+If you want your package to be useful to other packages and you want folks to be able to
+easily update to newer version of your package when they come out, it is important to
+document what behavior will stay consistent across updates.
+
+Unless you note otherwise, the public API of your package is defined as all the behavior you
+describe about public symbols. A public symbol is a symbol that is exported from your
+package with the `export` keyword or marked as public with the `public` keyword. When you
+change the behavior of something that was previously public so that the new
+version no longer conforms to the specifications provided in the old version, you should
+adjust your package version number according to [Julia's variant on SemVer](#Version-specifier-format).
+If you would like to include a symbol in your public API without exporting it into the
+global namespace of folks who call `using YourPackage`, you should mark that symbol as
+public with `public that_symbol`. Symbols marked as public with the `public` keyword are
+just as public as those marked as public with the `export` keyword, but when folks call
+`using YourPackage`, they will still have to qualify access to those symbols with
+`YourPackage.that_symbol`.
+
+Let's say we would like our `greet` function to be part of the public API, but not the
+`greet_alien` function. We could the write the following and release it as version `1.0.0`.
+
+```julia
+module HelloWorld
+
+export greet
+
+import Random
+import JSON
+
+"Writes a friendly message."
+greet() = print("Hello World!")
+
+"Greet an alien by a randomly generated name."
+greet_alien() = print("Hello ", Random.randstring(8))
+
+end # module
+```
+
+Then, if we change `greet` to
+
+```julia
+"Writes a friendly message that is exactly three words long."
+greet() = print("Hello Lovely World!")
+```
+
+We would release the new version as `1.1.0`. This is not breaking
+because the new implementation conforms to the old documentation, but
+it does add a new feature, that the message must be three words long.
+
+Later, we may wish to change `greet_alien` to
+
+```julia
+"Greet an alien by a the name of \"Zork\"."
+greet_alien() = print("Hello Zork")
+```
+
+And also export it by changing
+
+```julia
+export greet
+```
+
+to
+
+```julia
+export greet, greet_alien
+```
+
+We should release this new version as `1.2.0` because it adds a new feature
+`greet_alien` to the public API. Even though `greet_alien` was documented before
+and the new version does not conform to the old documentation, this is not breaking
+because the old documentation was not attached to a symbol that was exported
+at the time so that documentation does not apply across released versions.
+
+However, if we now wish to change `greet` to
+
+```julia
+"Writes a friendly message that is exactly four words long."
+greet() = print("Hello very lovely world")
+```
+
+we would need to release the new version as `2.0.0`. In version `1.1.0`, we specified that
+the greeting would be three words long, and because `greet` was exported, that description
+also applies to all future versions until the next breaking release. Because this new
+version does not conform to the old specification, it must be tagged as a breaking change.
+
+Please note that version numbers are free and unlimited. It is okay to use lots of them
+(e.g. version `6.62.8`).
+
+## Adding a build step to the package
+
+The build step is executed the first time a package is installed or when explicitly invoked with `build`.
+A package is built by executing the file `deps/build.jl`.
+
+```julia-repl
+julia> mkpath("deps");
+
+julia> write("deps/build.jl",
+             """
+             println("I am being built...")
+             """);
+
+(HelloWorld) pkg> build
+  Building HelloWorld → `deps/build.log`
+ Resolving package versions...
+
+julia> print(readchomp("deps/build.log"))
+I am being built...
+```
+
+If the build step fails, the output of the build step is printed to the console
+
+```julia-repl
+julia> write("deps/build.jl",
+             """
+             error("Ooops")
+             """);
+
+(HelloWorld) pkg> build
+    Building HelloWorld → `~/HelloWorld/deps/build.log`
+ERROR: Error building `HelloWorld`:
+ERROR: LoadError: Ooops
+Stacktrace:
+ [1] error(s::String)
+   @ Base ./error.jl:35
+ [2] top-level scope
+   @ ~/HelloWorld/deps/build.jl:1
+ [3] include(fname::String)
+   @ Base.MainInclude ./client.jl:476
+ [4] top-level scope
+   @ none:5
+in expression starting at /home/kc/HelloWorld/deps/build.jl:1
+```
+
+!!! warning
+    A build step should generally not create or modify any files in the package directory. If you need to store some files
+    from the build step, use the [Scratch.jl](https://github.com/JuliaPackaging/Scratch.jl) package.
+
+## Adding tests to the package
+
+When a package is tested the file `test/runtests.jl` is executed:
+
+```julia-repl
+julia> mkpath("test");
+
+julia> write("test/runtests.jl",
+             """
+             println("Testing...")
+             """);
+
+(HelloWorld) pkg> test
+   Testing HelloWorld
+ Resolving package versions...
+Testing...
+   Testing HelloWorld tests passed
+```
+
+Tests are run in a new Julia process, where the package itself, and any
+test-specific dependencies, are available, see below.
+
+
+!!! warning
+    Tests should generally not create or modify any files in the package directory. If you need to store some files
+    from the build step, use the [Scratch.jl](https://github.com/JuliaPackaging/Scratch.jl) package.
+
+### Test-specific dependencies
+
+There are two ways of adding test-specific dependencies (dependencies that are not dependencies of the package but will still be available to
+load when the package is tested).
+
+#### `target` based test specific dependencies
+
+Using this method of adding test-specific dependencies, the packages are added under an `[extras]` section and to a test target,
+e.g. to add `Markdown` and `Test` as test dependencies, add the following to the `Project.toml` file:
+
+```toml
+[extras]
+Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["Markdown", "Test"]
+```
+
+Note that the only supported targets are `test` and `build`, the latter of which (not recommended) can be used
+for any `deps/build.jl` scripts.
+
+#### Alternative approach: `test/Project.toml` file test specific dependencies
+
+!!! note
+    The exact interaction between `Project.toml`, `test/Project.toml` and their corresponding
+    `Manifest.toml`s are not fully worked out and may be subject to change in future versions.
+    The older method of adding test-specific dependencies, described in the previous section,
+    will therefore be supported throughout all Julia 1.X releases.
+
+In Julia 1.2 and later test dependencies can be declared in `test/Project.toml`. When running
+tests, Pkg will automatically merge this and the package Projects to create the test environment.
+
+!!! note
+    If no `test/Project.toml` exists Pkg will use the `target` based test specific dependencies.
+
+To add a test-specific dependency, i.e. a dependency that is available only when testing,
+it is thus enough to add this dependency to the `test/Project.toml` project. This can be
+done from the Pkg REPL by activating this environment, and then use `add` as one normally
+does. Let's add the `Test` standard library as a test dependency:
+
+```julia-repl
+(HelloWorld) pkg> activate ./test
+[ Info: activating environment at `~/HelloWorld/test/Project.toml`.
+
+(test) pkg> add Test
+ Resolving package versions...
+  Updating `~/HelloWorld/test/Project.toml`
+  [8dfed614] + Test
+  Updating `~/HelloWorld/test/Manifest.toml`
+  [...]
+```
+
+We can now use `Test` in the test script and we can see that it gets installed when testing:
+
+```julia-repl
+julia> write("test/runtests.jl",
+             """
+             using Test
+             @test 1 == 1
+             """);
+
+(test) pkg> activate .
+
+(HelloWorld) pkg> test
+   Testing HelloWorld
+ Resolving package versions...
+  Updating `/var/folders/64/76tk_g152sg6c6t0b4nkn1vw0000gn/T/tmpPzUPPw/Project.toml`
+  [d8327f2a] + HelloWorld v0.1.0 [`~/.julia/dev/Pkg/HelloWorld`]
+  [8dfed614] + Test
+  Updating `/var/folders/64/76tk_g152sg6c6t0b4nkn1vw0000gn/T/tmpPzUPPw/Manifest.toml`
+  [d8327f2a] + HelloWorld v0.1.0 [`~/.julia/dev/Pkg/HelloWorld`]
+   Testing HelloWorld tests passed```
+```
+
+## Compatibility on dependencies
+
+Every dependency should in general have a compatibility constraint on it.
+This is an important topic so there is a chapter in the package docs about it:
+[Compatibility](https://pkgdocs.julialang.org/v1/compatibility).
+
+## Weak dependencies
+
+!!! note
+    This is a somewhat advanced usage of Pkg which can be skipped for people new to Julia and Julia packages.
+
+!!! compat
+    The described feature requires Julia 1.9+.
+
+A weak dependency is a dependency that will not automatically install when the package is installed but
+you can still control what versions of that package are allowed to be installed by setting compatibility on it.
+These are listed in the project file under the `[weakdeps]` section:
+
+```toml
+[weakdeps]
+SomePackage = "b3785f31-9d33-4cdf-bc73-f646780f1739"
+
+[compat]
+SomePackage = "1.2"
+```
+
+The current usage of this is almost solely limited to "extensions" which is described in the next section.
+
+## Conditional loading of code in packages (Extensions)
+
+!!! note
+    This is a somewhat advanced usage of Pkg which can be skipped for people new to Julia and Julia packages.
+
+!!! compat
+    The described feature requires Julia 1.9+.
+
+Sometimes one wants to make two or more packages work well together, but may be reluctant (perhaps due to increased load times) to make one an unconditional dependency of the other.
+A package *extension* is a module in a file (similar to a package) that is automatically loaded when *some other set of packages* are
+loaded into the Julia session. This is very similar to functionality that the external package
+[Requires.jl](https://github.com/JuliaPackaging/Requires.jl) provides, but which is now available directly through Julia,
+and provides added benefits such as being able to precompile the extension.
+
+### Code structure
+
+A useful application of extensions could be for a plotting package that should be able to plot
+objects from a wide variety of different Julia packages.
+Adding all those different Julia packages as dependencies of the plotting package
+could be expensive since they would end up getting loaded even if they were never used.
+Instead, the code required to plot objects for specific packages can be put into separate files
+(extensions) and these are loaded only when the packages that define the type(s) we want to plot
+are loaded.
+
+Below is an example of how the code can be structured for a use case in which a
+`Plotting` package wants to be able to display objects defined in the external package `Contour`.
+The file and folder structure shown below is found in the `Plotting` package.
+
+ `Project.toml`:
+ ```toml
+name = "Plotting"
+version = "0.1.0"
+uuid = "..."
+
+[weakdeps]
+Contour = "d38c429a-6771-53c6-b99e-75d170b6e991"
+
+[extensions]
+# name of extension to the left
+# extension dependencies required to load the extension to the right
+# use a list for multiple extension dependencies
+PlottingContourExt = "Contour"
+
+[compat]
+Contour = "0.6.2"
+```
+
+`src/Plotting.jl`:
+```julia
+module Plotting
+
+function plot(x::Vector)
+    # Some functionality for plotting a vector here
+end
+
+end # module
+```
+
+`ext/PlottingContourExt.jl` (can also be in `ext/PlottingContourExt/PlottingContourExt.jl`):
+```julia
+module PlottingContourExt # Should be same name as the file (just like a normal package)
+
+using Plotting, Contour
+
+function Plotting.plot(c::Contour.ContourCollection)
+    # Some functionality for plotting a contour here
+end
+
+end # module
+```
+
+Extensions can have any arbitrary name (here `PlottingContourExt`), but using something similar to the format of
+this example that makes the extended functionality and dependency of the extension clear is likely a good idea.
+
+!!! compat
+    Often you will put the extension dependencies into the `test` target so they are loaded when running e.g. `Pkg.test()`. On earlier Julia versions
+    this requires you to also put the package in the `[extras]` section. This is unfortunate but the project verifier on older Julia versions will
+    complain if this is not done.
+
+!!! note
+    If you use a manifest generated by a Julia version that does not know about extensions with a Julia version that does
+    know about them, the extensions will not load. This is because the manifest lacks some information that tells Julia
+    when it should load these packages. So make sure you use a manifest generated at least the Julia version you are using.
+
+### Behavior of extensions
+
+A user that depends only on `Plotting` will not pay the cost of the "extension" inside the `PlottingContourExt` module.
+It is only when the `Contour` package actually gets loaded that the `PlottingContourExt` extension is loaded too
+and provides the new functionality.
+
+In our example, the new functionality is an additional _method_, which we add to an existing _function_ from the parent package `Plotting`.
+Implementing such methods is among the most standard use cases of package extensions.
+Within the parent package, the function to extend can even be defined with zero methods, as follows:
+
+```julia
+function plot end
+```
+
+!!! note
+    If one considers `PlottingContourExt` as a completely separate package, it could be argued that defining `Plotting.plot(c::Contour.ContourCollection)` is
+    [type piracy](@ref avoid-type-piracy) since `PlottingContourExt` _owns_ neither the function `Plotting.plot` nor the type `Contour.ContourCollection`.
+    However, for extensions, it is ok to assume that the extension owns the functions in its parent package.
+
+In other situations, one may need to define new symbols in the extension (types, structs, functions, etc.) instead of reusing those from the parent package.
+Such symbols are created in a separate module corresponding to the extension, namely `PlottingContourExt`, and thus not in `Plotting` itself.
+If extension symbols are needed in the parent package, one must call `Base.get_extension` to retrieve them.
+Here is an example showing how a custom type defined in `PlottingContourExt` can be accessed in `Plotting`:
+
+```julia
+ext = Base.get_extension(@__MODULE__, :PlottingContourExt)
+if !isnothing(ext)
+    ContourPlotType = ext.ContourPlotType
+end
+```
+
+On the other hand, accessing extension symbols from a third-party package (i.e. not the parent) is not a recommended practice at the moment.
+
+### Backwards compatibility
+
+This section discusses various methods for using extensions on Julia versions that support them,
+while simultaneously providing similar functionality on older Julia versions.
+
+#### Requires.jl
+
+This section is relevant if you are currently using Requires.jl but want to transition to using extensions (while still having Requires be used on Julia versions that do not support extensions).
+This is done by making the following changes (using the example above):
+
+- Add the following to the package file. This makes it so that Requires.jl loads and inserts the
+  callback only when extensions are not supported
+  ```julia
+  # This symbol is only defined on Julia versions that support extensions
+  if !isdefined(Base, :get_extension)
+  using Requires
+  end
+
+  @static if !isdefined(Base, :get_extension)
+  function __init__()
+      @require Contour = "d38c429a-6771-53c6-b99e-75d170b6e991" include("../ext/PlottingContourExt.jl")
+  end
+  end
+  ```
+  or if you have other things in your `__init__()` function:
+  ```julia
+  if !isdefined(Base, :get_extension)
+  using Requires
+  end
+
+  function __init__()
+      # Other init functionality here
+
+      @static if !isdefined(Base, :get_extension)
+          @require Contour = "d38c429a-6771-53c6-b99e-75d170b6e991" include("../ext/PlottingContourExt.jl")
+      end
+  end
+  ```
+- Make the following change in the conditionally-loaded code:
+  ```julia
+  isdefined(Base, :get_extension) ? (using Contour) : (using ..Contour)
+  ```
+- Add `Requires` to `[weakdeps]` in your `Project.toml` file, so that it is listed in both `[deps]` and `[weakdeps]`.
+  Julia 1.9+ knows to not install it as a regular dependency, whereas earlier versions will consider it a dependency.
+
+The package should now work with Requires.jl on Julia versions before extensions were introduced
+and with extensions on more recent Julia versions.
+
+####  Transition from normal dependency to extension
+
+This section is relevant if you have a normal dependency that you want to transition be an extension (while still having the dependency be a normal dependency on Julia versions that do not support extensions).
+This is done by making the following changes (using the example above):
+
+- Make sure that the package is **both** in the `[deps]` and `[weakdeps]` section. Newer Julia versions will ignore dependencies in `[deps]` that are also in `[weakdeps]`.
+- Add the following to your main package file (typically at the bottom):
+  ```julia
+  if !isdefined(Base, :get_extension)
+    include("../ext/PlottingContourExt.jl")
+  end
+  ```
+
+#### Using an extension while supporting older Julia versions
+
+In the case where one wants to use an extension (without worrying about the
+feature of the extension begin available on older Julia versions) while still
+supporting older Julia versions the packages under `[weakdeps]` should be
+duplicated into `[extras]`. This is an unfortunate duplication, but without
+doing this the project verifier under older Julia versions will throw an error
+if it finds packages under `[compat]` that is not listed in `[extras]`.
+
+## Package naming guidelines
+
+Package names should be sensible to most Julia users, *even to those who are not domain experts*.
+The following guidelines apply to the `General` registry but may be useful for other package
+registries as well.
+
+Since the `General` registry belongs to the entire community, people may have opinions about
+your package name when you publish it, especially if it's ambiguous or can be confused with
+something other than what it is. Usually, you will then get suggestions for a new name that
+may fit your package better.
+
+1. Avoid jargon. In particular, avoid acronyms unless there is minimal possibility of confusion.
+
+     * It's ok to say `USA` if you're talking about the USA.
+     * It's not ok to say `PMA`, even if you're talking about positive mental attitude.
+2. Avoid using `Julia` in your package name or prefixing it with `Ju`.
+
+     * It is usually clear from context and to your users that the package is a Julia package.
+     * Package names already have a `.jl` extension, which communicates to users that `Package.jl` is a Julia package.
+     * Having Julia in the name can imply that the package is connected to, or endorsed by, contributors
+       to the Julia language itself.
+3. Packages that provide most of their functionality in association with a new type should have pluralized
+   names.
+
+     * `DataFrames` provides the `DataFrame` type.
+     * `BloomFilters` provides the `BloomFilter` type.
+     * In contrast, `JuliaParser` provides no new type, but instead new functionality in the `JuliaParser.parse()`
+       function.
+4. Err on the side of clarity, even if clarity seems long-winded to you.
+
+     * `RandomMatrices` is a less ambiguous name than `RndMat` or `RMT`, even though the latter are shorter.
+5. A less systematic name may suit a package that implements one of several possible approaches to
+   its domain.
+
+     * Julia does not have a single comprehensive plotting package. Instead, `Gadfly`, `PyPlot`, `Winston`
+       and other packages each implement a unique approach based on a particular design philosophy.
+     * In contrast, `SortingAlgorithms` provides a consistent interface to use many well-established
+       sorting algorithms.
+6. Packages that wrap external libraries or programs should be named after those libraries or programs.
+
+     * `CPLEX.jl` wraps the `CPLEX` library, which can be identified easily in a web search.
+     * `MATLAB.jl` provides an interface to call the MATLAB engine from within Julia.
+7. Avoid naming a package closely to an existing package
+     * `Websocket` is too close to `WebSockets` and can be confusing to users. Rather use a new name such as `SimpleWebsockets`.
+
+## Registering packages
+
+Once a package is ready it can be registered with the [General Registry](https://github.com/JuliaRegistries/General#registering-a-package-in-general) (see also the [FAQ](https://github.com/JuliaRegistries/General#faq)).
+Currently, packages are submitted via [`Registrator`](https://juliaregistrator.github.io/).
+In addition to `Registrator`, [`TagBot`](https://github.com/marketplace/actions/julia-tagbot) helps manage the process of tagging releases.
+
+## Best Practices
+
+Packages should avoid mutating their own state (writing to files within their package directory).
+Packages should, in general, not assume that they are located in a writable location (e.g. if installed as part of a system-wide depot) or even a stable one (e.g. if they are bundled into a system image by [PackageCompiler.jl](https://github.com/JuliaLang/PackageCompiler.jl)).
+To support the various use cases in the Julia package ecosystem, the Pkg developers have created a number of auxiliary packages and techniques to help package authors create self-contained, immutable, and relocatable packages:
+
+* [`Artifacts`](https://pkgdocs.julialang.org/v1/artifacts/) can be used to bundle chunks of data alongside your package, or even allow them to be downloaded on-demand.
+  Prefer artifacts over attempting to open a file via a path such as `joinpath(@__DIR__, "data", "my_dataset.csv")` as this is non-relocatable.
+  Once your package has been precompiled, the result of `@__DIR__` will have been baked into your precompiled package data, and if you attempt to distribute this package, it will attempt to load files at the wrong location.
+  Artifacts can be bundled and accessed easily using the `artifact"name"` string macro.
+
+* [`Scratch.jl`](https://github.com/JuliaPackaging/Scratch.jl) provides the notion of "scratch spaces", mutable containers of data for packages.
+  Scratch spaces are designed for data caches that are completely managed by a package and should be removed when the package itself is uninstalled.
+  For important user-generated data, packages should continue to write out to a user-specified path that is not managed by Julia or Pkg.
+
+* [`Preferences.jl`](https://github.com/JuliaPackaging/Preferences.jl) allows packages to read and write preferences to the top-level `Project.toml`.
+  These preferences can be read at runtime or compile-time, to enable or disable different aspects of package behavior.
+  Packages previously would write out files to their own package directories to record options set by the user or environment, but this is highly discouraged now that `Preferences` is available.

From 625bbdef20f59cd546ed841f9c53f00beaba4d8b Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 17 Nov 2023 18:43:52 -0500
Subject: [PATCH 0279/1315] build: disable DT_TEXTREL warning for i686 (#52211)

This warning was distracting and annoying me, so I looked into whether
it was a bug. Turns out the warning is harmless (loading the object just
will make a copy of the ~2kb text field into memory). So add the code to
disable it, either with different assembly or different linker flags.
Default to continuing to use the same assembly.
---
 cli/Makefile                       |  3 ++-
 cli/trampolines/trampolines_i686.S | 30 +++++++++++++++++++++++++++++-
 2 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/cli/Makefile b/cli/Makefile
index b6a2b48ebf044..c72ebff2b9bfd 100644
--- a/cli/Makefile
+++ b/cli/Makefile
@@ -20,7 +20,8 @@ ifeq ($(OS),WINNT)
 LOADER_LDFLAGS += -municode -mconsole -nostdlib --disable-auto-import \
                   --disable-runtime-pseudo-reloc -lntdll -lkernel32 -lpsapi
 else ifeq ($(OS),Linux)
-LOADER_LDFLAGS += -Wl,--no-as-needed -ldl -lpthread -rdynamic -lc -Wl,--as-needed
+# textoff and notext are aliases to the same option which suppress the TEXTREL warning for i686
+LOADER_LDFLAGS += -Wl,--no-as-needed -ldl -lpthread -rdynamic -lc -Wl,--as-needed -Wl,-z,notext
 else ifeq ($(OS),FreeBSD)
 LOADER_LDFLAGS += -Wl,--no-as-needed -ldl -lpthread -rdynamic -lc -Wl,--as-needed
 else ifeq ($(OS),Darwin)
diff --git a/cli/trampolines/trampolines_i686.S b/cli/trampolines/trampolines_i686.S
index 3d9cacf0ce652..f6c46fd6ee49b 100644
--- a/cli/trampolines/trampolines_i686.S
+++ b/cli/trampolines/trampolines_i686.S
@@ -3,13 +3,41 @@
 #include "common.h"
 #include "../../src/jl_exported_funcs.inc"
 
+// set this option to 1 to get very slightly slower trampolines which however do not trigger
+// this linker warning:
+//   ld: ./loader_trampolines.o: warning: relocation against `jl_***_addr' in read-only section `.text'
+//   ld: warning: creating DT_TEXTREL in a shared object
+// If you have a large libjulia.so file or other restrictions on using TEXTREL for some
+// reason, this may be worthwhile.
+// This is not relevant on Windows (though it is valid there), since it always uses
+// DT_TEXTREL anyways, and does not support this notion of PIC.
+#define USE_PC32 0
+
+#if USE_PC32
+.cfi_startproc
+julia__x86.get_pc_thunk.ax:
+    mov    (%esp),%eax
+    ret
+.cfi_endproc
+
+#define CALL(name) \
+    call julia__x86.get_pc_thunk.ax; \
+    jmpl *(CNAMEADDR(name) - .)(%eax); \
+
+#else
+
+#define CALL(name) \
+    jmpl *(CNAMEADDR(name)); \
+
+#endif
+
 #define XX(name) \
 DEBUGINFO(CNAME(name)); \
 .global CNAME(name); \
 .cfi_startproc; \
 CNAME(name)##:; \
     CET_START(); \
-    jmpl *(CNAMEADDR(name)); \
+    CALL(name); \
     ud2; \
 .cfi_endproc; \
 EXPORT(name); \

From 81afdbc36b365fcbf3ae25b7451c6cb5798c0c3d Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 17 Nov 2023 18:44:45 -0500
Subject: [PATCH 0280/1315] codegen: remove UB from uninitialized bitstypes in
 new (#52169)

In the time since the creation of issue #26764, there _is_ now 'a way to
say to llvm "I don't care what this value is, but it always has to be
the same"' using the `freeze` instruction, so we can use that to
instruct LLVM to not give us undefined behavior when users are using
uninitialized memory. There should not be an impact if users were
already avoiding this paradigm and are fully initializing their structs.

Fixes #26764
---
 src/ccall.cpp                     | 11 ++++++---
 src/cgutils.cpp                   | 39 ++++++++++++++++++++-----------
 src/codegen.cpp                   |  9 +++----
 src/intrinsics.cpp                | 10 ++++----
 src/llvm-alloc-helpers.cpp        | 11 ++++++++-
 src/llvm-alloc-helpers.h          |  5 +++-
 src/llvm-alloc-opt.cpp            | 33 ++++++++++++++++++++++----
 src/llvm-pass-helpers.cpp         |  2 +-
 test/llvmpasses/alloc-opt-pass.ll | 38 ++++++++++++++++++++++++++++++
 9 files changed, 125 insertions(+), 33 deletions(-)

diff --git a/src/ccall.cpp b/src/ccall.cpp
index 7755b14bbaf95..ece0ee24908e8 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1003,8 +1003,9 @@ static Value *box_ccall_result(jl_codectx_t &ctx, Value *result, Value *runtime_
     // XXX: need to handle parameterized zero-byte types (singleton)
     const DataLayout &DL = ctx.builder.GetInsertBlock()->getModule()->getDataLayout();
     unsigned nb = DL.getTypeStoreSize(result->getType());
+    unsigned align = sizeof(void*); // Allocations are at least pointer aligned
     MDNode *tbaa = jl_is_mutable(rt) ? ctx.tbaa().tbaa_mutab : ctx.tbaa().tbaa_immut;
-    Value *strct = emit_allocobj(ctx, nb, runtime_dt);
+    Value *strct = emit_allocobj(ctx, nb, runtime_dt, true, align);
     setName(ctx.emission_context, strct, "ccall_result_box");
     init_bits_value(ctx, strct, result, tbaa);
     return strct;
@@ -1383,6 +1384,10 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         assert(i < nccallargs && i + fc_args_start <= nargs);
         jl_value_t *argi = args[fc_args_start + i];
         argv[i] = emit_expr(ctx, argi);
+        if (argv[i].typ == jl_bottom_type) {
+            JL_GC_POP();
+            return jl_cgval_t();
+        }
     }
 
     // emit roots
@@ -1984,7 +1989,7 @@ jl_cgval_t function_sig_t::emit_a_ccall(
             // XXX: result needs to be zero'd and given a GC root here
             // and has incorrect write barriers.
             // instead this code path should behave like `unsafe_load`
-            result = emit_allocobj(ctx, (jl_datatype_t*)rt);
+            result = emit_allocobj(ctx, (jl_datatype_t*)rt, true);
             setName(ctx.emission_context, result, "ccall_sret_box");
             sretty = ctx.types().T_jlvalue;
             sretboxed = true;
@@ -2141,7 +2146,7 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         else if (jlretboxed && !retboxed) {
             assert(jl_is_datatype(rt));
             if (static_rt) {
-                Value *strct = emit_allocobj(ctx, (jl_datatype_t*)rt);
+                Value *strct = emit_allocobj(ctx, (jl_datatype_t*)rt, true);
                 setName(ctx.emission_context, strct, "ccall_ret_box");
                 MDNode *tbaa = jl_is_mutable(rt) ? ctx.tbaa().tbaa_mutab : ctx.tbaa().tbaa_immut;
                 int boxalign = julia_alignment(rt);
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index b560f84a4db8c..15a1522ee0d57 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -2896,7 +2896,7 @@ static Value *emit_genericmemoryowner(jl_codectx_t &ctx, Value *t)
 
 // --- boxing ---
 
-static Value *emit_allocobj(jl_codectx_t &ctx, jl_datatype_t *jt);
+static Value *emit_allocobj(jl_codectx_t &ctx, jl_datatype_t *jt, bool fully_initialized);
 
 static void init_bits_value(jl_codectx_t &ctx, Value *newv, Value *v, MDNode *tbaa,
                             unsigned alignment = sizeof(void*)) // min alignment in julia's gc is pointer-aligned
@@ -3206,7 +3206,7 @@ static Value *box_union(jl_codectx_t &ctx, const jl_cgval_t &vinfo, const SmallB
                     jl_cgval_t vinfo_r = jl_cgval_t(vinfo, (jl_value_t*)jt, NULL);
                     box = _boxed_special(ctx, vinfo_r, t);
                     if (!box) {
-                        box = emit_allocobj(ctx, jt);
+                        box = emit_allocobj(ctx, jt, true);
                         setName(ctx.emission_context, box, "unionbox");
                         init_bits_cgval(ctx, box, vinfo_r, jl_is_mutable(jt) ? ctx.tbaa().tbaa_mutab : ctx.tbaa().tbaa_immut);
                     }
@@ -3333,7 +3333,7 @@ static Value *boxed(jl_codectx_t &ctx, const jl_cgval_t &vinfo, bool is_promotab
             if (do_promote && is_promotable) {
                 auto IP = ctx.builder.saveIP();
                 ctx.builder.SetInsertPoint(vinfo.promotion_point);
-                box = emit_allocobj(ctx, (jl_datatype_t*)jt);
+                box = emit_allocobj(ctx, (jl_datatype_t*)jt, true);
                 Value *decayed = decay_derived(ctx, box);
                 AllocaInst *originalAlloca = cast<AllocaInst>(vinfo.V);
                 box->takeName(originalAlloca);
@@ -3349,7 +3349,7 @@ static Value *boxed(jl_codectx_t &ctx, const jl_cgval_t &vinfo, bool is_promotab
                 auto arg_typename = [&] JL_NOTSAFEPOINT {
                     return "box::" + std::string(jl_symbol_name(((jl_datatype_t*)(jt))->name->name));
                 };
-                box = emit_allocobj(ctx, (jl_datatype_t*)jt);
+                box = emit_allocobj(ctx, (jl_datatype_t*)jt, true);
                 setName(ctx.emission_context, box, arg_typename);
                 init_bits_cgval(ctx, box, vinfo, jl_is_mutable(jt) ? ctx.tbaa().tbaa_mutab : ctx.tbaa().tbaa_immut);
             }
@@ -3478,7 +3478,7 @@ static void emit_cpointercheck(jl_codectx_t &ctx, const jl_cgval_t &x, const Twi
 // allocation for known size object
 // returns a prjlvalue
 static Value *emit_allocobj(jl_codectx_t &ctx, size_t static_size, Value *jt,
-                             unsigned align=sizeof(void*)) // Allocations are at least pointer alingned
+                            bool fully_initialized, unsigned align)
 {
     ++EmittedAllocObjs;
     Value *current_task = get_current_task(ctx);
@@ -3486,15 +3486,19 @@ static Value *emit_allocobj(jl_codectx_t &ctx, size_t static_size, Value *jt,
     auto call = ctx.builder.CreateCall(F, {current_task, ConstantInt::get(ctx.types().T_size, static_size), maybe_decay_untracked(ctx, jt)});
     call->setAttributes(F->getAttributes());
     if (static_size > 0)
-        call->addRetAttr(Attribute::getWithDereferenceableBytes(ctx.builder.getContext(), static_size));
-    call->addRetAttr(Attribute::getWithAlignment(ctx.builder.getContext(), Align(align)));
+        call->addRetAttr(Attribute::getWithDereferenceableBytes(call->getContext(), static_size));
+    call->addRetAttr(Attribute::getWithAlignment(call->getContext(), Align(align)));
+#if JL_LLVM_VERSION >= 150000
+    if (fully_initialized)
+        call->addFnAttr(Attribute::get(call->getContext(), Attribute::AllocKind, uint64_t(AllocFnKind::Alloc | AllocFnKind::Uninitialized)));
+#endif
     return call;
 }
 
-static Value *emit_allocobj(jl_codectx_t &ctx, jl_datatype_t *jt)
+static Value *emit_allocobj(jl_codectx_t &ctx, jl_datatype_t *jt, bool fully_initialized)
 {
     return emit_allocobj(ctx, jl_datatype_size(jt), ctx.builder.CreateIntToPtr(emit_tagfrom(ctx, jt), ctx.types().T_pjlvalue),
-                        julia_alignment((jl_value_t*)jt));
+                         fully_initialized, julia_alignment((jl_value_t*)jt));
 }
 
 // allocation for unknown object from an untracked pointer
@@ -3716,14 +3720,20 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                 strct = NULL;
             }
             else if (init_as_value) {
-                if (tracked.count)
+                if (tracked.count) {
                     strct = Constant::getNullValue(lt);
-                else
+                }
+                else {
                     strct = UndefValue::get(lt);
+                    if (nargs < nf)
+                        strct = ctx.builder.CreateFreeze(strct);
+                }
             }
             else {
                 strct = emit_static_alloca(ctx, lt);
                 setName(ctx.emission_context, strct, arg_typename);
+                if (nargs < nf)
+                    ctx.builder.CreateStore(ctx.builder.CreateFreeze(UndefValue::get(lt)), strct);
                 if (tracked.count)
                     undef_derived_strct(ctx, strct, sty, ctx.tbaa().tbaa_stack);
             }
@@ -3893,7 +3903,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                 return ret;
             }
         }
-        Value *strct = emit_allocobj(ctx, sty);
+        Value *strct = emit_allocobj(ctx, sty, nargs >= nf);
         setName(ctx.emission_context, strct, arg_typename);
         jl_cgval_t strctinfo = mark_julia_type(ctx, strct, true, ty);
         strct = decay_derived(ctx, strct);
@@ -3926,13 +3936,14 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
         return strctinfo;
     }
     else {
-        // 0 fields, ghost or bitstype
+        // 0 fields, ghost or primitive type
         if (jl_datatype_nbits(sty) == 0)
             return ghostValue(ctx, sty);
+        // n.b. this is not valid IR form to construct a primitive type (use bitcast for example)
         bool isboxed;
         Type *lt = julia_type_to_llvm(ctx, ty, &isboxed);
         assert(!isboxed);
-        return mark_julia_type(ctx, UndefValue::get(lt), false, ty);
+        return mark_julia_type(ctx, ctx.builder.CreateFreeze(UndefValue::get(lt)), false, ty);
     }
 }
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
index e09cec49e6c0a..632c76caa1c08 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1052,7 +1052,7 @@ static const auto jl_alloc_obj_func = new JuliaFunction<TypeFnContextAndSizeT>{
         auto FnAttrs = AttrBuilder(C);
         FnAttrs.addAllocSizeAttr(1, None); // returns %1 bytes
 #if JL_LLVM_VERSION >= 150000
-        FnAttrs.addAllocKindAttr(AllocFnKind::Alloc | AllocFnKind::Uninitialized);
+        FnAttrs.addAllocKindAttr(AllocFnKind::Alloc);
 #endif
 #if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | inaccessibleMemOnly(ModRefInfo::ModRef));
@@ -5217,7 +5217,7 @@ static void emit_vi_assignment_unboxed(jl_codectx_t &ctx, jl_varinfo_t &vi, Valu
                 }
                 else {
                     Value *dest = vi.value.V;
-                    if (vi.pTIndex)
+                    if (vi.pTIndex) // TODO: use lifetime-end here instead
                         ctx.builder.CreateStore(UndefValue::get(cast<AllocaInst>(vi.value.V)->getAllocatedType()), vi.value.V);
                     Type *store_ty = julia_type_to_llvm(ctx, rval_info.constant ? jl_typeof(rval_info.constant) : rval_info.typ);
                     Type *dest_ty = store_ty->getPointerTo();
@@ -7018,7 +7018,7 @@ static jl_cgval_t emit_cfunction(jl_codectx_t &ctx, jl_value_t *output_type, con
         outboxed = (output_type != (jl_value_t*)jl_voidpointer_type);
         if (outboxed) {
             assert(jl_datatype_size(output_type) == sizeof(void*) * 4);
-            Value *strct = emit_allocobj(ctx, (jl_datatype_t*)output_type);
+            Value *strct = emit_allocobj(ctx, (jl_datatype_t*)output_type, true);
             setName(ctx.emission_context, strct, "cfun_result");
             Value *derived_strct = emit_bitcast(ctx, decay_derived(ctx, strct), ctx.types().T_size->getPointerTo());
             MDNode *tbaa = best_tbaa(ctx.tbaa(), output_type);
@@ -7194,7 +7194,7 @@ static Function *gen_invoke_wrapper(jl_method_instance_t *lam, jl_value_t *jlret
             if (!lty->isAggregateType()) // keep "aggregate" type values in place as pointers
                 theArg = ctx.builder.CreateAlignedLoad(lty, theArg, Align(julia_alignment(ty)));
         }
-        assert(dyn_cast<UndefValue>(theArg) == NULL);
+        assert(!isa<UndefValue>(theArg));
         args[idx] = theArg;
         idx++;
     }
@@ -8962,6 +8962,7 @@ static jl_llvm_functions_t
     }
 
     for (PHINode *PN : ToDelete) {
+        // This basic block is statically unreachable, thus so is this PHINode
         PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
         PN->eraseFromParent();
     }
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index fde27b910faea..81fc9ec1af831 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -639,7 +639,8 @@ static jl_cgval_t generic_bitcast(jl_codectx_t &ctx, const jl_cgval_t *argv)
         return mark_julia_type(ctx, vx, false, bt);
     }
     else {
-        Value *box = emit_allocobj(ctx, nb, bt_value_rt);
+        unsigned align = sizeof(void*); // Allocations are at least pointer aligned
+        Value *box = emit_allocobj(ctx, nb, bt_value_rt, true, align);
         setName(ctx.emission_context, box, "bitcast_box");
         init_bits_value(ctx, box, vx, ctx.tbaa().tbaa_immut);
         return mark_julia_type(ctx, box, true, bt->name->wrapper);
@@ -698,7 +699,8 @@ static jl_cgval_t generic_cast(
     else {
         Value *targ_rt = boxed(ctx, targ);
         emit_concretecheck(ctx, targ_rt, std::string(jl_intrinsic_name(f)) + ": target type not a leaf primitive type");
-        Value *box = emit_allocobj(ctx, nb, targ_rt);
+        unsigned align = sizeof(void*); // Allocations are at least pointer aligned
+        Value *box = emit_allocobj(ctx, nb, targ_rt, true, align);
         setName(ctx.emission_context, box, "cast_box");
         init_bits_value(ctx, box, ans, ctx.tbaa().tbaa_immut);
         return mark_julia_type(ctx, box, true, jlto->name->wrapper);
@@ -749,7 +751,7 @@ static jl_cgval_t emit_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
     else if (!deserves_stack(ety)) {
         assert(jl_is_datatype(ety));
         uint64_t size = jl_datatype_size(ety);
-        Value *strct = emit_allocobj(ctx, (jl_datatype_t*)ety);
+        Value *strct = emit_allocobj(ctx, (jl_datatype_t*)ety, true);
         setName(ctx.emission_context, strct, "pointerref_box");
         im1 = ctx.builder.CreateMul(im1, ConstantInt::get(ctx.types().T_size,
                     LLT_ALIGN(size, jl_datatype_align(ety))));
@@ -905,7 +907,7 @@ static jl_cgval_t emit_atomic_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
 
     if (!deserves_stack(ety)) {
         assert(jl_is_datatype(ety));
-        Value *strct = emit_allocobj(ctx, (jl_datatype_t*)ety);
+        Value *strct = emit_allocobj(ctx, (jl_datatype_t*)ety, true);
         setName(ctx.emission_context, strct, "atomic_pointerref_box");
         Value *thePtr = emit_unbox(ctx, getInt8PtrTy(ctx.builder.getContext()), e, e.typ);
         Type *loadT = Type::getIntNTy(ctx.builder.getContext(), nb * 8);
diff --git a/src/llvm-alloc-helpers.cpp b/src/llvm-alloc-helpers.cpp
index 665c0b1d2e00e..953ecc1830142 100644
--- a/src/llvm-alloc-helpers.cpp
+++ b/src/llvm-alloc-helpers.cpp
@@ -125,6 +125,12 @@ JL_USED_FUNC void AllocUseInfo::dump(llvm::raw_ostream &OS)
     OS << "hastypeof: " << hastypeof << '\n';
     OS << "refload: " << refload << '\n';
     OS << "refstore: " << refstore << '\n';
+    OS << "allockind:";
+    if ((allockind & AllocFnKind::Uninitialized) != AllocFnKind::Unknown)
+      OS << " uninitialized";
+    if ((allockind & AllocFnKind::Zeroed) != AllocFnKind::Unknown)
+      OS << " zeroed";
+    OS << '\n';
     OS << "Uses: " << uses.size() << '\n';
     for (auto inst: uses)
         inst->print(OS);
@@ -164,8 +170,11 @@ JL_USED_FUNC void AllocUseInfo::dump()
 #define REMARK(remark)
 #endif
 
-void jl_alloc::runEscapeAnalysis(llvm::Instruction *I, EscapeAnalysisRequiredArgs required, EscapeAnalysisOptionalArgs options) {
+void jl_alloc::runEscapeAnalysis(llvm::CallInst *I, EscapeAnalysisRequiredArgs required, EscapeAnalysisOptionalArgs options) {
     required.use_info.reset();
+    Attribute allockind = I->getFnAttr(Attribute::AllocKind);
+    if (allockind.isValid())
+        required.use_info.allockind = allockind.getAllocKind();
     if (I->use_empty())
         return;
     CheckInst::Frame cur{I, 0, I->use_begin(), I->use_end()};
diff --git a/src/llvm-alloc-helpers.h b/src/llvm-alloc-helpers.h
index 3bd80704a0888..49c3b15332a56 100644
--- a/src/llvm-alloc-helpers.h
+++ b/src/llvm-alloc-helpers.h
@@ -87,6 +87,8 @@ namespace jl_alloc {
         bool returned:1;
         // The object is used in an error function
         bool haserror:1;
+        // For checking attributes of "uninitialized" or "zeroed" or unknown
+        llvm::AllocFnKind allockind;
 
         // The alloc has a Julia object reference not in an explicit field.
         bool has_unknown_objref:1;
@@ -105,6 +107,7 @@ namespace jl_alloc {
             hasunknownmem = false;
             returned = false;
             haserror = false;
+            allockind = llvm::AllocFnKind::Unknown;
             has_unknown_objref = false;
             has_unknown_objrefaggr = false;
             uses.clear();
@@ -153,7 +156,7 @@ namespace jl_alloc {
         }
     };
 
-    void runEscapeAnalysis(llvm::Instruction *I, EscapeAnalysisRequiredArgs required, EscapeAnalysisOptionalArgs options=EscapeAnalysisOptionalArgs());
+    void runEscapeAnalysis(llvm::CallInst *I, EscapeAnalysisRequiredArgs required, EscapeAnalysisOptionalArgs options=EscapeAnalysisOptionalArgs());
 }
 
 
diff --git a/src/llvm-alloc-opt.cpp b/src/llvm-alloc-opt.cpp
index 619fa03ef58dd..5df4f52aca425 100644
--- a/src/llvm-alloc-opt.cpp
+++ b/src/llvm-alloc-opt.cpp
@@ -135,12 +135,13 @@ struct Optimizer {
     // insert llvm.lifetime.* calls for `ptr` with size `sz` based on the use of `orig`.
     void insertLifetime(Value *ptr, Constant *sz, Instruction *orig);
 
-    void checkInst(Instruction *I);
+    void checkInst(CallInst *I);
 
     void replaceIntrinsicUseWith(IntrinsicInst *call, Intrinsic::ID ID,
                                  Instruction *orig_i, Instruction *new_i);
     void removeAlloc(CallInst *orig_inst);
-    void moveToStack(CallInst *orig_inst, size_t sz, bool has_ref);
+    void moveToStack(CallInst *orig_inst, size_t sz, bool has_ref, AllocFnKind allockind);
+    void initializeAlloca(IRBuilder<> &prolog_builder, AllocaInst *buff, AllocFnKind allockind);
     void splitOnStack(CallInst *orig_inst);
     void optimizeTag(CallInst *orig_inst);
 
@@ -288,7 +289,7 @@ void Optimizer::optimizeAll()
                 << "GC allocation moved to stack " << ore::NV("GC Allocation", orig);
         });
         // The object has no fields with mix reference access
-        moveToStack(orig, sz, has_ref);
+        moveToStack(orig, sz, has_ref, use_info.allockind);
     }
 }
 
@@ -355,7 +356,7 @@ ssize_t Optimizer::getGCAllocSize(Instruction *I)
     return -1;
 }
 
-void Optimizer::checkInst(Instruction *I)
+void Optimizer::checkInst(CallInst *I)
 {
     LLVM_DEBUG(dbgs() << "Running escape analysis on " << *I << "\n");
     jl_alloc::EscapeAnalysisRequiredArgs required{use_info, check_stack, pass, *pass.DL};
@@ -598,9 +599,25 @@ void Optimizer::replaceIntrinsicUseWith(IntrinsicInst *call, Intrinsic::ID ID,
     call->eraseFromParent();
 }
 
+void Optimizer::initializeAlloca(IRBuilder<> &prolog_builder, AllocaInst *buff, AllocFnKind allockind)
+{
+    if ((allockind & AllocFnKind::Uninitialized) != AllocFnKind::Unknown)
+        return;
+    assert(!buff->isArrayAllocation());
+    Type *T = buff->getAllocatedType();
+    Value *Init = UndefValue::get(T);
+    if ((allockind & AllocFnKind::Zeroed) != AllocFnKind::Unknown)
+        Init = Constant::getNullValue(T); // zero, as described
+    else if (allockind == AllocFnKind::Unknown)
+        Init = Constant::getNullValue(T); // assume zeroed since we didn't find the attribute
+    else
+        Init = prolog_builder.CreateFreeze(UndefValue::get(T)); // assume freeze, since LLVM does not natively support this case
+    prolog_builder.CreateStore(Init, buff);
+}
+
 // This function should not erase any safepoint so that the lifetime marker can find and cache
 // all the original safepoints.
-void Optimizer::moveToStack(CallInst *orig_inst, size_t sz, bool has_ref)
+void Optimizer::moveToStack(CallInst *orig_inst, size_t sz, bool has_ref, AllocFnKind allockind)
 {
     ++RemovedAllocs;
     ++StackAllocs;
@@ -643,6 +660,10 @@ void Optimizer::moveToStack(CallInst *orig_inst, size_t sz, bool has_ref)
         ptr = cast<Instruction>(prolog_builder.CreateBitCast(buff, Type::getInt8PtrTy(prolog_builder.getContext(), buff->getType()->getPointerAddressSpace())));
     }
     insertLifetime(ptr, ConstantInt::get(Type::getInt64Ty(prolog_builder.getContext()), sz), orig_inst);
+    if (sz != 0 && !has_ref) { // TODO: fix has_ref case too
+        IRBuilder<> builder(orig_inst);
+        initializeAlloca(builder, buff, allockind);
+    }
     Instruction *new_inst = cast<Instruction>(prolog_builder.CreateBitCast(ptr, JuliaType::get_pjlvalue_ty(prolog_builder.getContext(), buff->getType()->getPointerAddressSpace())));
     new_inst->takeName(orig_inst);
 
@@ -927,8 +948,10 @@ void Optimizer::splitOnStack(CallInst *orig_inst)
             allocty = ArrayType::get(Type::getInt8Ty(pass.getLLVMContext()), field.size);
         }
         slot.slot = prolog_builder.CreateAlloca(allocty);
+        IRBuilder<> builder(orig_inst);
         insertLifetime(prolog_builder.CreateBitCast(slot.slot, Type::getInt8PtrTy(prolog_builder.getContext())),
                        ConstantInt::get(Type::getInt64Ty(prolog_builder.getContext()), field.size), orig_inst);
+        initializeAlloca(builder, slot.slot, use_info.allockind);
         slots.push_back(std::move(slot));
     }
     const auto nslots = slots.size();
diff --git a/src/llvm-pass-helpers.cpp b/src/llvm-pass-helpers.cpp
index ed8cc9ed645ae..d17ce3105135c 100644
--- a/src/llvm-pass-helpers.cpp
+++ b/src/llvm-pass-helpers.cpp
@@ -130,7 +130,7 @@ namespace jl_intrinsics {
 #if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | inaccessibleMemOnly(ModRefInfo::ModRef));
 #endif
-        FnAttrs.addAllocKindAttr(AllocFnKind::Alloc | AllocFnKind::Uninitialized);
+        FnAttrs.addAllocKindAttr(AllocFnKind::Alloc);
         FnAttrs.addAttribute(Attribute::WillReturn);
         FnAttrs.addAttribute(Attribute::NoUnwind);
         target->addFnAttrs(FnAttrs);
diff --git a/test/llvmpasses/alloc-opt-pass.ll b/test/llvmpasses/alloc-opt-pass.ll
index 521fd88d582ee..6bee0fd325105 100644
--- a/test/llvmpasses/alloc-opt-pass.ll
+++ b/test/llvmpasses/alloc-opt-pass.ll
@@ -81,6 +81,7 @@ L3:
 ; CHECK-LABEL: @legal_int_types
 ; CHECK: alloca [12 x i8]
 ; CHECK-NOT: alloca i96
+; CHECK: store [12 x i8] zeroinitializer,
 ; CHECK: ret void
 define void @legal_int_types() {
   %pgcstack = call {}*** @julia.get_pgcstack()
@@ -143,6 +144,7 @@ L2:
 ; CHECK: alloca
 ; CHECK-NOT: call token(...) @llvm.julia.gc_preserve_begin
 ; CHECK: call void @llvm.lifetime.start
+; CHECK: store [8 x i8] zeroinitializer,
 ; CHECK-NOT: call void @llvm.lifetime.end
 define void @lifetime_no_preserve_end({}* noalias nocapture noundef nonnull sret({}) %0) {
   %pgcstack = call {}*** @julia.get_pgcstack()
@@ -160,3 +162,39 @@ define void @lifetime_no_preserve_end({}* noalias nocapture noundef nonnull sret
   ret void
 }
 ; CHECK-LABEL: }{{$}}
+
+
+; CHECK-LABEL: @initializers
+; CHECK: alloca [1 x i8]
+; CHECK-DAG: alloca [2 x i8]
+; CHECK-DAG: alloca [3 x i8]
+; CHECK-DAG: freeze [1 x i8] undef
+; CHECK-DAG: store [1 x i8] %
+; CHECK-DAG: store [3 x i8] zeroinitializer,
+; CHECK-NOT: store
+; CHECK-NOT: zeroinitializer
+; CHECK: ret void
+define void @initializers() {
+  %pgcstack = call {}*** @julia.get_pgcstack()
+  %ptls = call {}*** @julia.ptls_states()
+  %ptls_i8 = bitcast {}*** %ptls to i8*
+
+  %var1 = call {} addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, i64 1, {} addrspace(10)* @tag) #0
+  %var2 = addrspacecast {} addrspace(10)* %var1 to {} addrspace(11)*
+  %var3 = call {}* @julia.pointer_from_objref({} addrspace(11)* %var2)
+
+  %var4 = call {} addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, i64 2, {} addrspace(10)* @tag) #1
+  %var5 = addrspacecast {} addrspace(10)* %var4 to {} addrspace(11)*
+  %var6 = call {}* @julia.pointer_from_objref({} addrspace(11)* %var5)
+
+  %var7 = call {} addrspace(10)* @julia.gc_alloc_obj(i8* %ptls_i8, i64 3, {} addrspace(10)* @tag) #2
+  %var8 = addrspacecast {} addrspace(10)* %var7 to {} addrspace(11)*
+  %var9 = call {}* @julia.pointer_from_objref({} addrspace(11)* %var8)
+
+  ret void
+}
+; CHECK-LABEL: }{{$}}
+
+attributes #0 = { allockind("alloc") }
+attributes #1 = { allockind("alloc,uninitialized") }
+attributes #2 = { allockind("alloc,zeroed") }

From e754f2036cbfc37ea24a33d02e86e41a9cf56af9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= <lars.goettgens@rwth-aachen.de>
Date: Sat, 18 Nov 2023 07:30:38 +0100
Subject: [PATCH 0281/1315] Add missing type annotation reported by JET
 (#52207)

We already know from
https://github.com/lgoettgens/julia/blob/d0a3edddda407302930f3b2a742a7c8ebbcafb5b/base/loading.jl#L1212
that the value is not `nothing`. However, type inference does not know
that as the check lives in a different function.
---
 base/loading.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/loading.jl b/base/loading.jl
index 021c32b7c2654..ff1a2207a2022 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1278,7 +1278,7 @@ function _insert_extension_triggers(parent::PkgId, extensions::Dict{String, Any}
     for (ext, triggers) in extensions
         triggers = triggers::Union{String, Vector{String}}
         triggers isa String && (triggers = [triggers])
-        id = PkgId(uuid5(parent.uuid, ext), ext)
+        id = PkgId(uuid5(parent.uuid::UUID, ext), ext)
         if id in keys(EXT_PRIMED) || haskey(Base.loaded_modules, id)
             continue  # extension is already primed or loaded, don't add it again
         end

From 959b474d0516df77a268d9f23ccda5d2ad32acdf Mon Sep 17 00:00:00 2001
From: Frank Ebel <git@ebel.page>
Date: Sat, 18 Nov 2023 11:43:17 +0100
Subject: [PATCH 0282/1315] docs: update latest stable version (#52215)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e904b3b8d6770..add11e8cef44b 100644
--- a/README.md
+++ b/README.md
@@ -93,7 +93,7 @@ and then use the command prompt to change into the resulting julia directory. By
 Julia. However, most users should use the [most recent stable version](https://github.com/JuliaLang/julia/releases)
 of Julia. You can get this version by running:
 
-    git checkout v1.9.3
+    git checkout v1.9.4
 
 To build the `julia` executable, run `make` from within the julia directory.
 

From e75dd479ee38907183cb940e572440411ea1c448 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 18 Nov 2023 11:32:51 +0000
Subject: [PATCH 0283/1315] [nghttp2_jll] Upgrade to v1.58.0 (#52218)

Usual memo to self:

* update version in `stdlib/nghttp2_jll/Project.toml` and
`deps/nghttp2.version`
* update test in `stdlib/nghttp2_jll/test/runtests.jl`
* refresh checksums with `make -f contrib/refresh_checksums.mk -j
nghttp2`
---
 deps/checksums/nghttp2              | 68 ++++++++++++++---------------
 deps/nghttp2.version                |  2 +-
 stdlib/nghttp2_jll/Project.toml     |  2 +-
 stdlib/nghttp2_jll/test/runtests.jl |  2 +-
 4 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/deps/checksums/nghttp2 b/deps/checksums/nghttp2
index 66ae3cbf34c0e..9c419f5234ffc 100644
--- a/deps/checksums/nghttp2
+++ b/deps/checksums/nghttp2
@@ -1,34 +1,34 @@
-nghttp2-1.52.0.tar.bz2/md5/bde5874bd8e7e8be3512a621de27b9d5
-nghttp2-1.52.0.tar.bz2/sha512/019ec7a904d1baf8755ffcea0b38acf45ea9c6829d989a530ab35807338ba78d3328b86eebb3106b8372b7a8c51b466974d423e0cd786b6d6d020f0840c160bf
-nghttp2.v1.52.0+1.aarch64-apple-darwin.tar.gz/md5/e3d9e07029e184cc55b7e0c4d2e27c7f
-nghttp2.v1.52.0+1.aarch64-apple-darwin.tar.gz/sha512/cd098db984f751b00d2cc99d7f7eba0fa830ba178dd85a9dfa679a591e62d57364dcfd74e6a55ef513a0436a8e520b1a5474d4bfa9a8bdcd70e398482b7c9985
-nghttp2.v1.52.0+1.aarch64-linux-gnu.tar.gz/md5/73fe75f3cfa2bd3e804ea39a4eb884a9
-nghttp2.v1.52.0+1.aarch64-linux-gnu.tar.gz/sha512/71f4b2a23ba148b66432797b0db954dbd98fc900045d4572f488b43779aae125f71929e5bba6bbadd30c7998a133c5e5beb70888968bf3b01bb5fe9c9ea0e451
-nghttp2.v1.52.0+1.aarch64-linux-musl.tar.gz/md5/736a24a7eee567851a965558e31489fb
-nghttp2.v1.52.0+1.aarch64-linux-musl.tar.gz/sha512/ab36182b04a590b092fae9e3a912a87467e8b01ad40a628a1d2e52910ee513ab327d5d2836df598d5aa8203f60a605d19d0b9636eb35d12a84a1c9d87124604b
-nghttp2.v1.52.0+1.armv6l-linux-gnueabihf.tar.gz/md5/56fd32e8d77d4c9d9e2355565f4db19b
-nghttp2.v1.52.0+1.armv6l-linux-gnueabihf.tar.gz/sha512/85718e0e5cee35d91a8684ea33d8f965bb30d62dbd6b74a574a2fbc4c1027b1ef23ef68f1dec3f037fa6c5739287329567df9591a69f8f23b23fab2516a0b644
-nghttp2.v1.52.0+1.armv6l-linux-musleabihf.tar.gz/md5/283273d3bf4d53b56d12ef6af2e72f20
-nghttp2.v1.52.0+1.armv6l-linux-musleabihf.tar.gz/sha512/5c1d92cbf5f2f4e1ceb4ee13634c0bceb6ca28abaf9d87cc673f264d274bb96aa095648295e9aa76f86eb0890a426f47c0b942e72610daf722ed8e86b5f0df69
-nghttp2.v1.52.0+1.armv7l-linux-gnueabihf.tar.gz/md5/d7ae84e5365759a42d0fe0360f679b61
-nghttp2.v1.52.0+1.armv7l-linux-gnueabihf.tar.gz/sha512/63212e3ad94d2bc54ca9ebd452d8de8e67aa53c03a3b3033d36da765303e714d8d5c24156ea4fb985acc72fe52e2977e8e8a658cdd9409bd41ecf401c08c1aee
-nghttp2.v1.52.0+1.armv7l-linux-musleabihf.tar.gz/md5/a6ad0f25f43b7f1832faeaaadf683ed4
-nghttp2.v1.52.0+1.armv7l-linux-musleabihf.tar.gz/sha512/64b9075c0d819288345d53c5ce88b360d2ca4d24c3d2e81fb53c55f86054b1a3e95d7831b363a4100965cdbf479268a5993d66ef59089a219a97b4151d8fef60
-nghttp2.v1.52.0+1.i686-linux-gnu.tar.gz/md5/9781f6eeb4d24a291d6737e59e74edc1
-nghttp2.v1.52.0+1.i686-linux-gnu.tar.gz/sha512/2b542cb67e78993ef881694dc50c980b57db3761c5f4e11c381afb1b31d1fb8ab0a8b20e1279303a602c07912f21e8ef9d732366b76ab3f356a74b444a5dc78c
-nghttp2.v1.52.0+1.i686-linux-musl.tar.gz/md5/08603b9364179ab4cbe0637b9b1b63b5
-nghttp2.v1.52.0+1.i686-linux-musl.tar.gz/sha512/0a5b79709482548c6a713843b670695b4b13d2b219b592d029719da0b4187fe884798fb44e2c511c300f02bab03f2b0b289d49d6256e3ce0b9602a66ea2382bd
-nghttp2.v1.52.0+1.i686-w64-mingw32.tar.gz/md5/1abdf0cad466ed0ca0da137809999d8e
-nghttp2.v1.52.0+1.i686-w64-mingw32.tar.gz/sha512/04680895ead989fda56b284d8963e7ca31680492c8f77f4c6bd7ca03b9a66ee7529b78cf35e07b2e106f43c9aa543dffd4081b034339803ba95021293d3df997
-nghttp2.v1.52.0+1.powerpc64le-linux-gnu.tar.gz/md5/ae411e40e24cb3f3b07fe8de211b58c6
-nghttp2.v1.52.0+1.powerpc64le-linux-gnu.tar.gz/sha512/7433502d76646e5761ea2707fa65ea5a412c513c70908a4d9ceb504f08121b1f39bcff984543370c221814785b7064f85dedc777a22df5e30a64a64e510e0978
-nghttp2.v1.52.0+1.x86_64-apple-darwin.tar.gz/md5/59f0de0affaa17898e837b5074de68fc
-nghttp2.v1.52.0+1.x86_64-apple-darwin.tar.gz/sha512/e639c813373b17d95220640ec2a568e9731cfc32df826610357ec9ff8e9d7e7abe10291140eaeb9342ae69215798bf3f999db7647c23efb4f815b54f4da9cfe4
-nghttp2.v1.52.0+1.x86_64-linux-gnu.tar.gz/md5/6bc8501392d47b349c7463e984dc5909
-nghttp2.v1.52.0+1.x86_64-linux-gnu.tar.gz/sha512/522cc2a8464ee5770c01b83a6b4ecbbcce322efffbd738f7c907643fe85342e785bbc805028d41c2b7404d6241168d1ab37a9db15018623c265b53905bcf060f
-nghttp2.v1.52.0+1.x86_64-linux-musl.tar.gz/md5/725a6adc23880b28303017597b974535
-nghttp2.v1.52.0+1.x86_64-linux-musl.tar.gz/sha512/ede5a34b7f71310e4c3cd99b9b61b2453db5dc8117675de12adb1e68c9283cdf821614f49f4d04bdd3b0f17d51a52972ec1e226d0dbdc5462b1a4a1fcc9f39e7
-nghttp2.v1.52.0+1.x86_64-unknown-freebsd.tar.gz/md5/02e68f367dd5f2ceac3a619da402cbb4
-nghttp2.v1.52.0+1.x86_64-unknown-freebsd.tar.gz/sha512/d0522c4f40471cdfc0768863f9b0e97b453b2e0c850417811d4f264fd167622493141beea66a8668b15dc6b9b4ae42a38017b9f31ed59c9205701188df3d84b9
-nghttp2.v1.52.0+1.x86_64-w64-mingw32.tar.gz/md5/e1c8ec6ec2d69b2ac64b114ebf09f8b4
-nghttp2.v1.52.0+1.x86_64-w64-mingw32.tar.gz/sha512/cb43cb138f14717501e852ed388a44d41012e2bb70b6887584b37b4e0f42827d74f17ea85ba4aa0bc09d623dedeef73eee80815c1db2b6858b31251feb0b5580
+nghttp2-1.58.0.tar.bz2/md5/f60a0340da2638eba448df73b6783bc3
+nghttp2-1.58.0.tar.bz2/sha512/7a40afe80587a13bdd7fd85fc7eb666c0dcc18b951a03c65ab4b52429bdf5d2eae27a9bfaa7303e7517e275239397f60dd466170364dfbd1077e25188ba54aca
+nghttp2.v1.58.0+0.aarch64-apple-darwin.tar.gz/md5/528dec6d4a54854532d527067dccade7
+nghttp2.v1.58.0+0.aarch64-apple-darwin.tar.gz/sha512/cfc993f23f95ef3b2841d40e704c17816dec22a173a16c5d0bc3c85a092f1d63b69e47112a8a1aeb4e85603a7087746b97fbf9ea91a0ec42b45d38deb78f3e0b
+nghttp2.v1.58.0+0.aarch64-linux-gnu.tar.gz/md5/c358e3407e956bddab6fde752c2bd2b5
+nghttp2.v1.58.0+0.aarch64-linux-gnu.tar.gz/sha512/207ef70f4ba231e8e4fd570a5da7931a488a297d2d525983499d874abef268440d3e8408cc953c3deab5219bc8c93034b89bf2f3e4c1179b52cede354ae6d27f
+nghttp2.v1.58.0+0.aarch64-linux-musl.tar.gz/md5/eef1a1209fdbf30a71af878e307c4fb2
+nghttp2.v1.58.0+0.aarch64-linux-musl.tar.gz/sha512/9ad61002303add92b3d9842a408092b8b35ac8ac5ab17fabb77f144261c4829a2695111177b4794901efba87f97ed9274aac9935fc702c60189395abbb4d9a3f
+nghttp2.v1.58.0+0.armv6l-linux-gnueabihf.tar.gz/md5/2864d534833745ff12ebb86378a90b0b
+nghttp2.v1.58.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/091c367466cd547859d06b6d0bd37d424b0ccefc0f41dd4819156a61f98e0cc1eebf6da4171810e2a876fec9b919675efd9240089681ca8d3cd8620f5f40f8f3
+nghttp2.v1.58.0+0.armv6l-linux-musleabihf.tar.gz/md5/30a7b272ed36c45a3a5f58e7406150e5
+nghttp2.v1.58.0+0.armv6l-linux-musleabihf.tar.gz/sha512/c1c96c2e987a700929c0158232ef745a0fe8d93c722174a91b32c767cdc0441ee73059da9f64daca4010367ee005a9037919cdb73079a12f9612f45852549b0d
+nghttp2.v1.58.0+0.armv7l-linux-gnueabihf.tar.gz/md5/3940e07955102a7a71030fe4c8aed59f
+nghttp2.v1.58.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/5b628901371a36937a16802211707334b02632c8651a5fd01d2e1508926e51c960b693abbea6f629cfb7ca750b6039b5e4385324f2d431f1fe6e47b121a57f30
+nghttp2.v1.58.0+0.armv7l-linux-musleabihf.tar.gz/md5/2d6d0b8adba7bfea20dabde3c87333df
+nghttp2.v1.58.0+0.armv7l-linux-musleabihf.tar.gz/sha512/10c72fdc2e635add9f0364dd95fd8404f187068bce05587531d4865f75126c8eaf4f7c154762175d3ed0e85914b21df90c193766f610da91bb6dd75fe93df5fa
+nghttp2.v1.58.0+0.i686-linux-gnu.tar.gz/md5/8753bf62f8863b5c3041ef73ed3fe36a
+nghttp2.v1.58.0+0.i686-linux-gnu.tar.gz/sha512/741a8f2bd5902df9f06de67ecdcb041951a21e0d32f5acffac780cba7a41be5d67507ca49f65bf636849baf1b07e53871d9ee5624d4e33e1d4ff4137bd785bda
+nghttp2.v1.58.0+0.i686-linux-musl.tar.gz/md5/a1b0f85e40bef6f2647a9e1dfa415196
+nghttp2.v1.58.0+0.i686-linux-musl.tar.gz/sha512/0e438073cc6fe39e2b47d7b89467c1cab1abe953e357f782b2cb16de5f9238f063b925ab602558a1d562b3c3f608167dd339a4ec54ec93b27c4f43bd2e54aaed
+nghttp2.v1.58.0+0.i686-w64-mingw32.tar.gz/md5/7cf81bd21105f4d9fd5dd4dbf61fcb70
+nghttp2.v1.58.0+0.i686-w64-mingw32.tar.gz/sha512/47624f56df68983d3bd881cab1e88be249b678cb184cc426443c4a8c85481af03cddc65f642f1d88afd300cad88950662a99c5dbd75a459bd99dc56d3f38231c
+nghttp2.v1.58.0+0.powerpc64le-linux-gnu.tar.gz/md5/a6e9e975026f658cb2b68418c5f2cee9
+nghttp2.v1.58.0+0.powerpc64le-linux-gnu.tar.gz/sha512/2007cf1420ac0866b4b6b5b463aa9c491abd85b2559bea259efa075e308301b10f1d8e72f86c36c21cf42e891f672ac289b5c81640a83f002c89aefebeefb355
+nghttp2.v1.58.0+0.x86_64-apple-darwin.tar.gz/md5/06c250253f1969f1c8460f3c65ec02a9
+nghttp2.v1.58.0+0.x86_64-apple-darwin.tar.gz/sha512/397bd1ea32617ff005ad4217cdd5652a6a58d5c98837cdb8366aa4d0fd86824673864850aeb3771c3304755d8d5466b881b4007603a9cded924cd6b8b18384f4
+nghttp2.v1.58.0+0.x86_64-linux-gnu.tar.gz/md5/2be0cc258a81106eaea132fbbdfce04f
+nghttp2.v1.58.0+0.x86_64-linux-gnu.tar.gz/sha512/1be2b3906b9a5e2cb9af24ea358b92b50e3c7be85e9533784e3721b28219bce555700ebe3edf789123ff471a062dfc22f10eef1d21a6f060a43151f8904495d0
+nghttp2.v1.58.0+0.x86_64-linux-musl.tar.gz/md5/55898f6770dd85835d76e52003e8a1f6
+nghttp2.v1.58.0+0.x86_64-linux-musl.tar.gz/sha512/ad2266563dca33543c5fae9d0cb4daf9f0c6f4ccab8efc30e2eb273be9df33ae43da3007bcf83d19f39b830c11c17f8577014c81fcf5e76dce159f28937166f2
+nghttp2.v1.58.0+0.x86_64-unknown-freebsd.tar.gz/md5/5f9886a4e321bc393dd086106a685466
+nghttp2.v1.58.0+0.x86_64-unknown-freebsd.tar.gz/sha512/d86ba3730bb63143f990bdbe453fa4a0692b434beab372aa9a8e7673c2fddc8c97ebd2e47ac109ffe50172121f2d56ddd40d8d500b73e61a58635edcede8d071
+nghttp2.v1.58.0+0.x86_64-w64-mingw32.tar.gz/md5/98ecb527506234cc69cb8a958a74a002
+nghttp2.v1.58.0+0.x86_64-w64-mingw32.tar.gz/sha512/3941233fdfa82af9a5590f5975728d51e42791eb1b966a4ae7913a24f52500c24dea05e66911b3c5768535b145c99b31e2dc2ab50354648492df4b4b63434578
diff --git a/deps/nghttp2.version b/deps/nghttp2.version
index 200e08bf4bfd9..680be055e4443 100644
--- a/deps/nghttp2.version
+++ b/deps/nghttp2.version
@@ -3,4 +3,4 @@
 NGHTTP2_JLL_NAME := nghttp2
 
 ## source build
-NGHTTP2_VER := 1.52.0
+NGHTTP2_VER := 1.58.0
diff --git a/stdlib/nghttp2_jll/Project.toml b/stdlib/nghttp2_jll/Project.toml
index d75e0780bd01a..560a9537a3b21 100644
--- a/stdlib/nghttp2_jll/Project.toml
+++ b/stdlib/nghttp2_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "nghttp2_jll"
 uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
-version = "1.52.0+1"
+version = "1.58.0+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/stdlib/nghttp2_jll/test/runtests.jl b/stdlib/nghttp2_jll/test/runtests.jl
index 2f9af6d6a3338..8155e4e787fcc 100644
--- a/stdlib/nghttp2_jll/test/runtests.jl
+++ b/stdlib/nghttp2_jll/test/runtests.jl
@@ -11,5 +11,5 @@ end
 
 @testset "nghttp2_jll" begin
     info = unsafe_load(ccall((:nghttp2_version,libnghttp2), Ptr{nghttp2_info}, (Cint,), 0))
-    @test VersionNumber(unsafe_string(info.version_str)) == v"1.52.0"
+    @test VersionNumber(unsafe_string(info.version_str)) == v"1.58.0"
 end

From 41a6f268ff07f68779bdf6f8f9dd6ebba82a02b5 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 19 Nov 2023 03:29:15 -0500
Subject: [PATCH 0284/1315] Thread lattice through escape analysis (#52223)

As of #51494 is used in the base pipeline, so external abstract
interpreters inherit it by default. To avoid breaking them, make sure we
properly pass down the lattice.
---
 base/compiler/optimize.jl                          |  2 +-
 .../ssair/EscapeAnalysis/EscapeAnalysis.jl         | 14 +++++++-------
 test/compiler/EscapeAnalysis/EAUtils.jl            |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 514f2e03c2cae..68118f82fb5f2 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -583,7 +583,7 @@ function refine_effects!(interp::AbstractInterpreter, sv::PostOptAnalysisState)
     if !is_effect_free(sv.result.ipo_effects) && sv.all_effect_free && !isempty(sv.ea_analysis_pending)
         ir = sv.ir
         nargs = length(ir.argtypes)
-        estate = EscapeAnalysis.analyze_escapes(ir, nargs, GetNativeEscapeCache(interp))
+        estate = EscapeAnalysis.analyze_escapes(ir, nargs, optimizer_lattice(interp), GetNativeEscapeCache(interp))
         argescapes = EscapeAnalysis.ArgEscapeCache(estate)
         stack_analysis_result!(sv.result, argescapes)
         validate_mutable_arg_escapes!(estate, sv)
diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index 70d45819574fd..820975d405525 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -27,7 +27,7 @@ using Core.Compiler: # Core.Compiler specific definitions
     Bottom, IRCode, IR_FLAG_NOTHROW, InferenceResult, SimpleInferenceLattice,
     argextype, check_effect_free!, fieldcount_noerror, hasintersect, intrinsic_nothrow,
     is_meta_expr_head, isbitstype, isexpr, println, setfield!_nothrow, singleton_type,
-    try_compute_field, try_compute_fieldidx, widenconst, ⊑
+    try_compute_field, try_compute_fieldidx, widenconst, ⊑, AbstractLattice
 
 include(x) = _TOP_MOD.include(@__MODULE__, x)
 if _TOP_MOD === Core.Compiler
@@ -37,7 +37,6 @@ else
 end
 
 const AInfo = IdSet{Any}
-const 𝕃ₒ = SimpleInferenceLattice.instance
 
 """
     x::EscapeInfo
@@ -598,10 +597,11 @@ struct LivenessChange <: Change
 end
 const Changes = Vector{Change}
 
-struct AnalysisState{T}
+struct AnalysisState{T, L <: AbstractLattice}
     ir::IRCode
     estate::EscapeState
     changes::Changes
+    𝕃ₒ::L
     get_escape_cache::T
 end
 
@@ -613,14 +613,14 @@ Analyzes escape information in `ir`:
 - `get_escape_cache(::MethodInstance) -> Union{Bool,ArgEscapeCache}`:
   retrieves cached argument escape information
 """
-function analyze_escapes(ir::IRCode, nargs::Int, get_escape_cache)
+function analyze_escapes(ir::IRCode, nargs::Int, 𝕃ₒ::AbstractLattice, get_escape_cache)
     stmts = ir.stmts
     nstmts = length(stmts) + length(ir.new_nodes.stmts)
 
     tryregions, arrayinfo = compute_frameinfo(ir)
     estate = EscapeState(nargs, nstmts, arrayinfo)
     changes = Changes() # keeps changes that happen at current statement
-    astate = AnalysisState(ir, estate, changes, get_escape_cache)
+    astate = AnalysisState(ir, estate, changes, 𝕃ₒ, get_escape_cache)
 
     local debug_itr_counter = 0
     while true
@@ -1452,10 +1452,10 @@ function escape_builtin!(::typeof(setfield!), astate::AnalysisState, pc::Int, ar
     add_escape_change!(astate, val, ssainfo)
     # compute the throwness of this setfield! call here since builtin_nothrow doesn't account for that
     @label add_thrown_escapes
-    if length(args) == 4 && setfield!_nothrow(𝕃ₒ,
+    if length(args) == 4 && setfield!_nothrow(astate.𝕃ₒ,
         argextype(args[2], ir), argextype(args[3], ir), argextype(args[4], ir))
         return true
-    elseif length(args) == 3 && setfield!_nothrow(𝕃ₒ,
+    elseif length(args) == 3 && setfield!_nothrow(astate.𝕃ₒ,
         argextype(args[2], ir), argextype(args[3], ir))
         return true
     else
diff --git a/test/compiler/EscapeAnalysis/EAUtils.jl b/test/compiler/EscapeAnalysis/EAUtils.jl
index 27428e07e920a..27a971173ac70 100644
--- a/test/compiler/EscapeAnalysis/EAUtils.jl
+++ b/test/compiler/EscapeAnalysis/EAUtils.jl
@@ -148,7 +148,7 @@ function CC.ipo_dataflow_analysis!(interp::EscapeAnalyzer, ir::IRCode, caller::I
     nargs = let def = caller.linfo.def; isa(def, Method) ? Int(def.nargs) : 0; end
     get_escape_cache = GetEscapeCache(interp)
     estate = try
-        analyze_escapes(ir, nargs, get_escape_cache)
+        analyze_escapes(ir, nargs, CC.optimizer_lattice(interp), get_escape_cache)
     catch err
         @error "error happened within EA, inspect `Main.failed_escapeanalysis`"
         Main.failed_escapeanalysis = FailedAnalysis(ir, nargs, get_escape_cache)

From 19ca07d00fdc34b90d79511acf4ebbe9d2bf9527 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 19 Nov 2023 03:29:29 -0500
Subject: [PATCH 0285/1315] cfg_simplify: Fix phi node renaming corner case bug
 (#52224)

Depending on the order of basic block, cfg_simplify! could occasionally
forget to renumber a phinode edge, causing at best a downstream
assertion and at worst a miscompile. The root of this issue is that
ordinarily, we detect whether a phinode edge requires later renaming by
looking at the last inserted index, and since we process all indices by
order, detecting whether we have already inserted a certain value is a
simple comparison. However, cfg_simplify! re-arranges the order of basic
blocks, so this check no longer works. Instead, we check whether the
incoming edge has already been scheduled. This is slightly less precise
(because it is possible for the edge itself to not have been scheduled,
even though the value has been), but correct and a slight imprecision
here at worst causes a negligible compile-time increase.
---
 base/compiler/ssair/ir.jl     | 11 ++++++-----
 base/compiler/ssair/passes.jl | 12 +++++++++---
 test/compiler/irpasses.jl     | 31 +++++++++++++++++++++++++++++++
 3 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 3f8160a088e8d..c2c3d2ac0ed54 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1112,7 +1112,7 @@ end
 (this::Refiner)() = (this.result_flags[this.result_idx] |= IR_FLAG_REFINED; nothing)
 
 function process_phinode_values(old_values::Vector{Any}, late_fixup::Vector{Int},
-                                processed_idx::Int, result_idx::Int,
+                                already_inserted, result_idx::Int,
                                 ssa_rename::Vector{Any}, used_ssas::Vector{Int},
                                 new_new_used_ssas::Vector{Int},
                                 do_rename_ssa::Bool,
@@ -1123,7 +1123,7 @@ function process_phinode_values(old_values::Vector{Any}, late_fixup::Vector{Int}
         val = old_values[i]
         if isa(val, SSAValue)
             if do_rename_ssa
-                if val.id > processed_idx
+                if !already_inserted(i, OldSSAValue(val.id))
                     push!(late_fixup, result_idx)
                     val = OldSSAValue(val.id)
                 else
@@ -1133,7 +1133,7 @@ function process_phinode_values(old_values::Vector{Any}, late_fixup::Vector{Int}
                 used_ssas[val.id] += 1
             end
         elseif isa(val, OldSSAValue)
-            if val.id > processed_idx
+            if !already_inserted(i, val)
                 push!(late_fixup, result_idx)
             else
                 # Always renumber these. do_rename_ssa applies only to actual SSAValues
@@ -1293,6 +1293,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
     (; result, ssa_rename, late_fixup, used_ssas, new_new_used_ssas) = compact
     (; cfg_transforms_enabled, fold_constant_branches, bb_rename_succ, bb_rename_pred, result_bbs) = compact.cfg_transform
     mark_refined! = Refiner(result.flag, result_idx)
+    already_inserted = (::Int, ssa::OldSSAValue)->ssa.id <= processed_idx
     if stmt === nothing
         ssa_rename[idx] = stmt
     elseif isa(stmt, OldSSAValue)
@@ -1461,7 +1462,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
             values = stmt.values
         end
 
-        values = process_phinode_values(values, late_fixup, processed_idx, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!)
+        values = process_phinode_values(values, late_fixup, already_inserted, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!)
         # Don't remove the phi node if it is before the definition of its value
         # because doing so can create forward references. This should only
         # happen with dead loops, but can cause problems when optimization
@@ -1500,7 +1501,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
                 push!(values, value)
             end
         end
-        result[result_idx][:stmt] = PhiCNode(process_phinode_values(values, late_fixup, processed_idx, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!))
+        result[result_idx][:stmt] = PhiCNode(process_phinode_values(values, late_fixup, already_inserted, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!))
         result_idx += 1
     else
         if isa(stmt, SSAValue)
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 85f704e9a076d..21e0e9b213f1c 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -2209,7 +2209,8 @@ function cfg_simplify!(ir::IRCode)
         ms = orig_bb
         bb_start = true
         while ms != 0
-            for i in bbs[ms].stmts
+            old_bb_stmts = bbs[ms].stmts
+            for i in old_bb_stmts
                 node = ir.stmts[i]
                 compact.result[compact.result_idx] = node
                 stmt = node[:stmt]
@@ -2221,8 +2222,13 @@ function cfg_simplify!(ir::IRCode)
                     values = phi.values
                     (; ssa_rename, late_fixup, used_ssas, new_new_used_ssas) = compact
                     ssa_rename[i] = SSAValue(compact.result_idx)
-                    processed_idx = i
-                    renamed_values = process_phinode_values(values, late_fixup, processed_idx, compact.result_idx, ssa_rename, used_ssas, new_new_used_ssas, true, nothing)
+                    already_inserted = function (i::Int, val::OldSSAValue)
+                        if val.id in old_bb_stmts
+                            return val.id <= i
+                        end
+                        return bb_rename_pred[phi.edges[i]] < idx
+                    end
+                    renamed_values = process_phinode_values(values, late_fixup, already_inserted, compact.result_idx, ssa_rename, used_ssas, new_new_used_ssas, true, nothing)
                     edges = Int32[]
                     values = Any[]
                     sizehint!(edges, length(phi.edges)); sizehint!(values, length(renamed_values))
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index ef6bf630bd2e5..204d0400ea701 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1584,4 +1584,35 @@ let (ir, _) = only(Base.code_ircode(f_with_merge_to_entry_block))
     Core.Compiler.verify_ir(ir)
 end
 
+# Test that CFG simplify doesn't leave an un-renamed SSA Value
+let m = Meta.@lower 1 + 1
+    # Test that CFG simplify doesn't try to merge every block in a loop into
+    # its predecessor
+    @assert Meta.isexpr(m, :thunk)
+    src = m.args[1]::CodeInfo
+    src.code = Any[
+        # Block 1
+        GotoIfNot(Argument(1), 3),
+        # Block 2
+        GotoNode(5),
+        # Block 3
+        Expr(:call, Base.inferencebarrier, 1),
+        GotoNode(6),
+        # Block 4
+        Expr(:call, Base.inferencebarrier, 2), # fallthrough
+        # Block 5
+        PhiNode(Int32[4, 5], Any[SSAValue(3), SSAValue(5)]),
+        ReturnNode(1)
+    ]
+    nstmts = length(src.code)
+    src.ssavaluetypes = nstmts
+    src.codelocs = fill(Int32(1), nstmts)
+    src.ssaflags = fill(Int32(0), nstmts)
+    ir = Core.Compiler.inflate_ir(src)
+    Core.Compiler.verify_ir(ir)
+    ir = Core.Compiler.cfg_simplify!(ir)
+    Core.Compiler.verify_ir(ir)
+    @test length(ir.cfg.blocks) == 4
+end
+
 # JET.test_opt(Core.Compiler.cfg_simplify!, (Core.Compiler.IRCode,))

From ec3911cfd46b0413ce435956b372ab7202d127f8 Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Sun, 19 Nov 2023 09:36:43 +0100
Subject: [PATCH 0286/1315] Add `lmul!` and `rmul!` for `Bidiagonal` (#51777)

---
 stdlib/LinearAlgebra/src/bidiag.jl  | 44 +++++++++++++++++++++++++++--
 stdlib/LinearAlgebra/test/bidiag.jl | 12 ++++++--
 2 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/bidiag.jl b/stdlib/LinearAlgebra/src/bidiag.jl
index f8cc3ceadcfad..78c79b6fcefac 100644
--- a/stdlib/LinearAlgebra/src/bidiag.jl
+++ b/stdlib/LinearAlgebra/src/bidiag.jl
@@ -426,6 +426,7 @@ end
 
 const BandedMatrix = Union{Bidiagonal,Diagonal,Tridiagonal,SymTridiagonal} # or BiDiTriSym
 const BiTriSym = Union{Bidiagonal,Tridiagonal,SymTridiagonal}
+const TriSym = Union{Tridiagonal,SymTridiagonal}
 const BiTri = Union{Bidiagonal,Tridiagonal}
 @inline mul!(C::AbstractVector, A::BandedMatrix, B::AbstractVector, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
 @inline mul!(C::AbstractMatrix, A::BandedMatrix, B::AbstractVector, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
@@ -433,6 +434,9 @@ const BiTri = Union{Bidiagonal,Tridiagonal}
 @inline mul!(C::AbstractMatrix, A::AbstractMatrix, B::BandedMatrix, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
 @inline mul!(C::AbstractMatrix, A::BandedMatrix, B::BandedMatrix, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
 
+lmul!(A::Bidiagonal, B::AbstractVecOrMat) = @inline _mul!(B, A, B, MulAddMul())
+rmul!(B::AbstractMatrix, A::Bidiagonal) = @inline _mul!(B, B, A, MulAddMul())
+
 function check_A_mul_B!_sizes(C, A, B)
     mA, nA = size(A)
     mB, nB = size(B)
@@ -460,7 +464,11 @@ function _diag(A::Bidiagonal, k)
     end
 end
 
-function _mul!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym, _add::MulAddMul = MulAddMul())
+_mul!(C::AbstractMatrix, A::BiTriSym, B::TriSym, _add::MulAddMul = MulAddMul()) =
+    _bibimul!(C, A, B, _add)
+_mul!(C::AbstractMatrix, A::BiTriSym, B::Bidiagonal, _add::MulAddMul = MulAddMul()) =
+    _bibimul!(C, A, B, _add)
+function _bibimul!(C, A, B, _add)
     check_A_mul_B!_sizes(C, A, B)
     n = size(A,1)
     n <= 3 && return mul!(C, Array(A), Array(B), _add.alpha, _add.beta)
@@ -583,7 +591,7 @@ function _mul!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat, _add::MulA
     C
 end
 
-function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym, _add::MulAddMul = MulAddMul())
+function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::TriSym, _add::MulAddMul = MulAddMul())
     require_one_based_indexing(C, A)
     check_A_mul_B!_sizes(C, A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
@@ -618,7 +626,37 @@ function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::BiTriSym, _add::MulAddMu
     C
 end
 
-function _mul!(C::AbstractMatrix, A::Diagonal, B::BiTriSym, _add::MulAddMul = MulAddMul())
+function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::Bidiagonal, _add::MulAddMul = MulAddMul())
+    require_one_based_indexing(C, A)
+    check_A_mul_B!_sizes(C, A, B)
+    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    if size(A, 1) <= 3 || size(B, 2) <= 1
+        return mul!(C, Array(A), Array(B), _add.alpha, _add.beta)
+    end
+    m, n = size(A)
+    @inbounds if B.uplo == 'U'
+        for i in 1:m
+            for j in n:-1:2
+                _modify!(_add, A[i,j] * B.dv[j] + A[i,j-1] * B.ev[j-1], C, (i, j))
+            end
+            _modify!(_add, A[i,1] * B.dv[1], C, (i, 1))
+        end
+    else # uplo == 'L'
+        for i in 1:m
+            for j in 1:n-1
+                _modify!(_add, A[i,j] * B.dv[j] + A[i,j+1] * B.ev[j], C, (i, j))
+            end
+            _modify!(_add, A[i,n] * B.dv[n], C, (i, n))
+        end
+    end
+    C
+end
+
+_mul!(C::AbstractMatrix, A::Diagonal, B::Bidiagonal, _add::MulAddMul = MulAddMul()) =
+    _dibimul!(C, A, B, _add)
+_mul!(C::AbstractMatrix, A::Diagonal, B::TriSym, _add::MulAddMul = MulAddMul()) =
+    _dibimul!(C, A, B, _add)
+function _dibimul!(C, A, B, _add)
     require_one_based_indexing(C)
     check_A_mul_B!_sizes(C, A, B)
     n = size(A,1)
diff --git a/stdlib/LinearAlgebra/test/bidiag.jl b/stdlib/LinearAlgebra/test/bidiag.jl
index a3e5a2f437e93..2fce781e30ab1 100644
--- a/stdlib/LinearAlgebra/test/bidiag.jl
+++ b/stdlib/LinearAlgebra/test/bidiag.jl
@@ -439,6 +439,9 @@ Random.seed!(1)
                 for op in (+, -, *)
                     @test Array(op(T, T2)) ≈ op(Tfull, Tfull2)
                 end
+                A = kron(T.dv, T.dv')
+                @test T * A ≈ lmul!(T, copy(A))
+                @test A * T ≈ rmul!(copy(A), T)
             end
             # test pass-through of mul! for SymTridiagonal*Bidiagonal
             TriSym = SymTridiagonal(T.dv, T.ev)
@@ -446,7 +449,8 @@ Random.seed!(1)
             # test pass-through of mul! for AbstractTriangular*Bidiagonal
             Tri = UpperTriangular(diagm(1 => T.ev))
             Dia = Diagonal(T.dv)
-            @test Array(Tri*T) ≈ Array(Tri)*Array(T)
+            @test Array(Tri*T) ≈ Array(Tri)*Array(T) ≈ rmul!(copy(Tri), T)
+            @test Array(T*Tri) ≈ Array(T)*Array(Tri) ≈ lmul!(T, copy(Tri))
             # test mul! itself for these types
             for AA in (Tri, Dia)
                 for f in (identity, transpose, adjoint)
@@ -459,8 +463,10 @@ Random.seed!(1)
             for f in (identity, transpose, adjoint)
                 C = relty == Int ? rand(float(elty), n, n) : rand(elty, n, n)
                 B = rand(elty, n, n)
-                D = copy(C) + 2.0 * Array(T*f(B))
-                mul!(C, T, f(B), 2.0, 1.0) ≈ D
+                D = C + 2.0 * Array(T*f(B))
+                @test mul!(C, T, f(B), 2.0, 1.0) ≈ D
+                @test lmul!(T, copy(f(B))) ≈ T * f(B)
+                @test rmul!(copy(f(B)), T) ≈ f(B) * T
             end
 
             # Issue #31870

From c07893d0ab90ef44ea7256fc5877b625761738d3 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 19 Nov 2023 15:39:19 +0530
Subject: [PATCH 0287/1315] Cartesian indexing for SubArrays with non-integer
 AbstractRanges (#52094)

With #50457 now merged, an `AbstractRange` of `CartesianIndex`es should
use `CartesianIndexing` in constructing a `SubArray`. I've limited the
method to integer ranges, as this is the case where we know for sure
that the indexing may be linear.

Fixes
```julia
julia> view(1:2, StepRangeLen(CartesianIndex(1), CartesianIndex(1), 0))
0-element view(::UnitRange{Int64}, StepRangeLen(CartesianIndex(1,), CartesianIndex(1,), 0)) with eltype Int64
```

---------

Co-authored-by: N5N3 <2642243996@qq.com>
---
 base/subarray.jl | 6 ++++--
 test/subarray.jl | 8 ++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index fa142a8843c63..464bd660b0856 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -52,8 +52,10 @@ viewindexing(I::Tuple{Slice, Slice, Vararg{Any}}) = (@inline; viewindexing(tail(
 # A UnitRange can follow Slices, but only if all other indices are scalar
 viewindexing(I::Tuple{Slice, AbstractUnitRange, Vararg{ScalarIndex}}) = IndexLinear()
 viewindexing(I::Tuple{Slice, Slice, Vararg{ScalarIndex}}) = IndexLinear() # disambiguate
-# In general, ranges are only fast if all other indices are scalar
-viewindexing(I::Tuple{AbstractRange, Vararg{ScalarIndex}}) = IndexLinear()
+# In general, scalar ranges are only fast if all other indices are scalar
+# Other ranges, such as those of `CartesianIndex`es, are not fast even if these
+# are followed by `ScalarIndex`es
+viewindexing(I::Tuple{AbstractRange{<:ScalarIndex}, Vararg{ScalarIndex}}) = IndexLinear()
 # All other index combinations are slow
 viewindexing(I::Tuple{Vararg{Any}}) = IndexCartesian()
 # Of course, all other array types are slow
diff --git a/test/subarray.jl b/test/subarray.jl
index da2a88d68408e..35e376f1a40b4 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -809,3 +809,11 @@ end
     b = view(a, Base.IdentityUnitRange(4:7))
     @test first(b) == a[Base.first_index(b)]
 end
+
+@testset "StepRangeLen of CartesianIndex-es" begin
+    v = view(1:2, StepRangeLen(CartesianIndex(1,1), CartesianIndex(1,1), 0))
+    @test isempty(v)
+    r = StepRangeLen(CartesianIndex(1), CartesianIndex(1), 1)
+    v = view(1:2, r)
+    @test v == view(1:2, collect(r))
+end

From f5d189fa3dbe5076ef07bf495e5582a73cd1acca Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 20 Nov 2023 00:50:33 +0900
Subject: [PATCH 0288/1315] effects: don't taint `:noub` for `:new` allocations
 (#52222)

After #52169, the UB previously associated with allocations with
uninitialized fields has been addressed, so there's no longer a need to
taint `:noub` for `:new` allocations during abstract interpretation.

I believe, even without #52169, uninitialized field does not inherently
leads to UB, but just causes inconsistency of the program, since what
actually causes UB is `getfield` that accesses into whatever object, but
not the allocation itself.
---
 base/compiler/abstractinterpretation.jl | 20 +++++++++++---------
 base/compiler/ssair/inlining.jl         |  2 +-
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 77024670b7002..f173f19fe0080 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2352,24 +2352,22 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
     elseif ehead === :new
         t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
         ut = unwrap_unionall(t)
-        consistent = noub = ALWAYS_FALSE
-        nothrow = false
         if isa(ut, DataType) && !isabstracttype(ut)
             ismutable = ismutabletype(ut)
             fcount = datatype_fieldcount(ut)
             nargs = length(e.args) - 1
-            if (fcount === nothing || (fcount > nargs && (let t = t
+            has_any_uninitialized = (fcount === nothing || (fcount > nargs && (let t = t
                     any(i::Int -> !is_undefref_fieldtype(fieldtype(t, i)), (nargs+1):fcount)
                 end)))
-                # allocation with undefined field leads to undefined behavior and should taint `:noub`
+            if has_any_uninitialized
+                # allocation with undefined field is inconsistent always
+                consistent = ALWAYS_FALSE
             elseif ismutable
-                # mutable object isn't `:consistent`, but we still have a chance that
+                # mutable allocation isn't `:consistent`, but we still have a chance that
                 # return type information later refines the `:consistent`-cy of the method
                 consistent = CONSISTENT_IF_NOTRETURNED
-                noub = ALWAYS_TRUE
             else
-                consistent = ALWAYS_TRUE
-                noub = ALWAYS_TRUE
+                consistent = ALWAYS_TRUE # immutable allocation is consistent
             end
             if isconcretedispatch(t)
                 nothrow = true
@@ -2411,9 +2409,13 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
                 end
             else
                 t = refine_partial_type(t)
+                nothrow = false
             end
+        else
+            consistent = ALWAYS_FALSE
+            nothrow = false
         end
-        effects = Effects(EFFECTS_TOTAL; consistent, nothrow, noub)
+        effects = Effects(EFFECTS_TOTAL; consistent, nothrow)
     elseif ehead === :splatnew
         t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
         nothrow = false # TODO: More precision
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 26dacbc3388f3..f62e773567ac3 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1265,7 +1265,7 @@ function check_effect_free!(ir::IRCode, idx::Int, @nospecialize(stmt), @nospecia
     elseif nothrow
         ir.stmts[idx][:flag] |= IR_FLAG_NOTHROW
     end
-    if !isexpr(stmt, :call) && !isexpr(stmt, :invoke)
+    if !(isexpr(stmt, :call) || isexpr(stmt, :invoke))
         # There is a bit of a subtle point here, which is that some non-call
         # statements (e.g. PiNode) can be UB:, however, we consider it
         # illegal to introduce such statements that actually cause UB (for any

From c8ca350832030992fca113ed56d979b6a8ff7fd3 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 19 Nov 2023 17:11:17 -0500
Subject: [PATCH 0289/1315] inference: Model type propagation through
 exceptions (#51754)

Currently the type of a caught exception is always modeled as `Any`.
This isn't a huge problem, because control flow in Julia is generally
assumed to be somewhat slow, so the extra type imprecision of not
knowing the return type does not matter all that much. However, there
are a few situations where it matters. For example:

```
maybe_getindex(A, i) =
    try; A[i]; catch e; isa(e, BoundsError) && return nothing; rethrow(); end
```

At present, we cannot infer :nothrow for this method, even if that is
the only error type that `A[i]` can throw. This is particularly
noticable, since we can now optimize away `:nothrow` exception frames
entirely (#51674). Note that this PR still does not make the above
example particularly efficient (at least interprocedurally), though
specialized codegen could be added on top of this to make that happen.
It does however improve the inference result.

A second major motivation of this change is that reasoning about
exception types is likely to be a major aspect of any future work on
interface checking (since interfaces imply the absence of MethodErrors),
so this PR lays the groundwork for appropriate modeling of these error
paths.

Note that this PR adds all the required plumbing, but does not yet have
a particularly precise model of error types for our builtins, bailing to
`Any` for any builtin not known to be `:nothrow`. This can be improved
in follow up PRs as required.
---
 base/boot.jl                            |   6 +-
 base/compiler/abstractinterpretation.jl | 309 ++++++++++++++++--------
 base/compiler/effects.jl                |  62 +++++
 base/compiler/inferencestate.jl         |  59 +++--
 base/compiler/optimize.jl               |   6 +-
 base/compiler/ssair/ir.jl               |  36 ++-
 base/compiler/ssair/irinterp.jl         |  62 +++--
 base/compiler/ssair/passes.jl           |  20 +-
 base/compiler/ssair/slot2ssa.jl         |  15 +-
 base/compiler/ssair/verify.jl           |   5 +-
 base/compiler/stmtinfo.jl               |   1 +
 base/compiler/tfuncs.jl                 |  44 ++--
 base/compiler/typeinfer.jl              |  26 +-
 base/compiler/types.jl                  |   3 +-
 base/compiler/utilities.jl              |   6 +-
 src/codegen.cpp                         |  11 +-
 src/gf.c                                |  20 +-
 src/jltypes.c                           |  12 +-
 src/julia.h                             |   1 +
 src/julia_internal.h                    |   7 +
 src/opaque_closure.c                    |   9 +-
 stdlib/REPL/src/REPLCompletions.jl      |   6 +-
 test/compiler/AbstractInterpreter.jl    |   2 +-
 test/compiler/inference.jl              |  29 ++-
 test/core.jl                            |   2 +-
 test/precompile.jl                      |   2 +-
 26 files changed, 517 insertions(+), 244 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index ff3502c2f418e..056b14fa5d0ac 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -479,13 +479,13 @@ eval(Core, quote
 end)
 
 function CodeInstance(
-    mi::MethodInstance, @nospecialize(rettype), @nospecialize(inferred_const),
+    mi::MethodInstance, @nospecialize(rettype), @nospecialize(exctype), @nospecialize(inferred_const),
     @nospecialize(inferred), const_flags::Int32, min_world::UInt, max_world::UInt,
     ipo_effects::UInt32, effects::UInt32, @nospecialize(analysis_results),
     relocatability::UInt8)
     return ccall(:jl_new_codeinst, Ref{CodeInstance},
-        (Any, Any, Any, Any, Int32, UInt, UInt, UInt32, UInt32, Any, UInt8),
-        mi, rettype, inferred_const, inferred, const_flags, min_world, max_world,
+        (Any, Any, Any, Any, Any, Int32, UInt, UInt, UInt32, UInt32, Any, UInt8),
+        mi, rettype, exctype, inferred_const, inferred, const_flags, min_world, max_world,
         ipo_effects, effects, analysis_results,
         relocatability)
 end
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index f173f19fe0080..453b55caffa42 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -18,7 +18,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
         # which is all that's required for :consistent-cy. Of course, we don't
         # know anything else about this statement.
         effects = Effects(; consistent=ALWAYS_TRUE)
-        return CallMeta(Any, effects, NoCallInfo())
+        return CallMeta(Any, Any, effects, NoCallInfo())
     end
 
     argtypes = arginfo.argtypes
@@ -26,13 +26,13 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
         InferenceParams(interp).max_union_splitting, max_methods)
     if isa(matches, FailedMethodMatch)
         add_remark!(interp, sv, matches.reason)
-        return CallMeta(Any, Effects(), NoCallInfo())
+        return CallMeta(Any, Any, Effects(), NoCallInfo())
     end
 
     (; valid_worlds, applicable, info) = matches
     update_valid_age!(sv, valid_worlds)
     napplicable = length(applicable)
-    rettype = Bottom
+    rettype = excttype = Bottom
     edges = MethodInstance[]
     conditionals = nothing # keeps refinement information of call argument types when the return type is boolean
     seen = 0               # number of signatures actually inferred
@@ -51,6 +51,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             break
         end
         this_rt = Bottom
+        this_exct = Bottom
         splitunions = false
         # TODO: this used to trigger a bug in inference recursion detection, and is unmaintained now
         # sigtuple = unwrap_unionall(sig)::DataType
@@ -59,7 +60,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             splitsigs = switchtupleunion(sig)
             for sig_n in splitsigs
                 result = abstract_call_method(interp, method, sig_n, svec(), multiple_matches, si, sv)
-                (; rt, edge, effects, volatile_inf_result) = result
+                (; rt, exct, edge, effects, volatile_inf_result) = result
                 this_argtypes = isa(matches, MethodMatches) ? argtypes : matches.applicable_argtypes[i]
                 this_arginfo = ArgInfo(fargs, this_argtypes)
                 const_call_result = abstract_call_method_with_const_args(interp,
@@ -69,9 +70,17 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
                     if const_call_result.rt ⊑ₚ rt
                         rt = const_call_result.rt
                         (; effects, const_result, edge) = const_call_result
+                    elseif is_better_effects(const_call_result.effects, effects)
+                        (; effects, const_result, edge) = const_call_result
                     else
                         add_remark!(interp, sv, "[constprop] Discarded because the result was wider than inference")
                     end
+                    if !(exct ⊑ₚ const_call_result.exct)
+                        exct = const_call_result.exct
+                        (; const_result, edge) = const_call_result
+                    else
+                        add_remark!(interp, sv, "[constprop] Discarded exception type because result was wider than inference")
+                    end
                 end
                 all_effects = merge_effects(all_effects, effects)
                 if const_result !== nothing
@@ -82,6 +91,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
                 end
                 edge === nothing || push!(edges, edge)
                 this_rt = tmerge(this_rt, rt)
+                this_exct = tmerge(this_exct, exct)
                 if bail_out_call(interp, this_rt, sv)
                     break
                 end
@@ -90,9 +100,10 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             this_rt = widenwrappedconditional(this_rt)
         else
             result = abstract_call_method(interp, method, sig, match.sparams, multiple_matches, si, sv)
-            (; rt, edge, effects, volatile_inf_result) = result
+            (; rt, exct, edge, effects, volatile_inf_result) = result
             this_conditional = ignorelimited(rt)
             this_rt = widenwrappedconditional(rt)
+            this_exct = exct
             # try constant propagation with argtypes for this match
             # this is in preparation for inlining, or improving the return result
             this_argtypes = isa(matches, MethodMatches) ? argtypes : matches.applicable_argtypes[i]
@@ -103,15 +114,30 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             if const_call_result !== nothing
                 this_const_conditional = ignorelimited(const_call_result.rt)
                 this_const_rt = widenwrappedconditional(const_call_result.rt)
-                # return type of const-prop' inference can be wider than that of non const-prop' inference
-                # e.g. in cases when there are cycles but cached result is still accurate
                 if this_const_rt ⊑ₚ this_rt
+                    # As long as the const-prop result we have is not *worse* than
+                    # what we found out on types, we'd like to use it. Even if the
+                    # end result is exactly equivalent, it is likely that the IR
+                    # we produced while constproping is better than that with
+                    # generic types.
+                    # Return type of const-prop' inference can be wider than that of non const-prop' inference
+                    # e.g. in cases when there are cycles but cached result is still accurate
                     this_conditional = this_const_conditional
                     this_rt = this_const_rt
                     (; effects, const_result, edge) = const_call_result
+                elseif is_better_effects(const_call_result.effects, effects)
+                    (; effects, const_result, edge) = const_call_result
                 else
                     add_remark!(interp, sv, "[constprop] Discarded because the result was wider than inference")
                 end
+                # Treat the exception type separately. Currently, constprop often cannot determine the exception type
+                # because consistent-cy does not apply to exceptions.
+                if !(this_exct ⊑ₚ const_call_result.exct)
+                    this_exct = const_call_result.exct
+                    (; const_result, edge) = const_call_result
+                else
+                    add_remark!(interp, sv, "[constprop] Discarded exception type because result was wider than inference")
+                end
             end
             all_effects = merge_effects(all_effects, effects)
             if const_result !== nothing
@@ -125,6 +151,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
         @assert !(this_conditional isa Conditional || this_rt isa MustAlias) "invalid lattice element returned from inter-procedural context"
         seen += 1
         rettype = tmerge(𝕃ₚ, rettype, this_rt)
+        excttype = tmerge(𝕃ₚ, excttype, this_exct)
         if has_conditional(𝕃ₚ, sv) && this_conditional !== Bottom && is_lattice_bool(𝕃ₚ, rettype) && fargs !== nothing
             if conditionals === nothing
                 conditionals = Any[Bottom for _ in 1:length(argtypes)],
@@ -149,12 +176,13 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
 
     if seen ≠ napplicable
         # there is unanalyzed candidate, widen type and effects to the top
-        rettype = Any
+        rettype = excttype = Any
         all_effects = Effects()
     elseif isa(matches, MethodMatches) ? (!matches.fullmatch || any_ambig(matches)) :
             (!all(matches.fullmatches) || any_ambig(matches))
         # Account for the fact that we may encounter a MethodError with a non-covered or ambiguous signature.
         all_effects = Effects(all_effects; nothrow=false)
+        excttype = tmerge(𝕃ₚ, excttype, MethodError)
     end
 
     rettype = from_interprocedural!(interp, rettype, sv, arginfo, conditionals)
@@ -199,7 +227,8 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             end
         end
     end
-    return CallMeta(rettype, all_effects, info)
+
+    return CallMeta(rettype, excttype, all_effects, info)
 end
 
 struct FailedMethodMatch
@@ -490,13 +519,13 @@ function abstract_call_method(interp::AbstractInterpreter,
                               hardlimit::Bool, si::StmtInfo, sv::AbsIntState)
     if method.name === :depwarn && isdefined(Main, :Base) && method.module === Main.Base
         add_remark!(interp, sv, "Refusing to infer into `depwarn`")
-        return MethodCallResult(Any, false, false, nothing, Effects())
+        return MethodCallResult(Any, Any, false, false, nothing, Effects())
     end
     sigtuple = unwrap_unionall(sig)
     sigtuple isa DataType ||
-        return MethodCallResult(Any, false, false, nothing, Effects())
+        return MethodCallResult(Any, Any, false, false, nothing, Effects())
     all(@nospecialize(x) -> valid_as_lattice(unwrapva(x), true), sigtuple.parameters) ||
-        return MethodCallResult(Union{}, false, false, nothing, EFFECTS_THROWS) # catch bad type intersections early
+        return MethodCallResult(Union{}, Any, false, false, nothing, EFFECTS_THROWS) # catch bad type intersections early
 
     if is_nospecializeinfer(method)
         sig = get_nospecializeinfer_sig(method, sig, sparams)
@@ -521,7 +550,7 @@ function abstract_call_method(interp::AbstractInterpreter,
                     # we have a self-cycle in the call-graph, but not in the inference graph (typically):
                     # break this edge now (before we record it) by returning early
                     # (non-typically, this means that we lose the ability to detect a guaranteed StackOverflow in some cases)
-                    return MethodCallResult(Any, true, true, nothing, Effects())
+                    return MethodCallResult(Any, Any, true, true, nothing, Effects())
                 end
                 topmost = nothing
                 edgecycle = true
@@ -576,7 +605,7 @@ function abstract_call_method(interp::AbstractInterpreter,
                 # since it's very unlikely that we'll try to inline this,
                 # or want make an invoke edge to its calling convention return type.
                 # (non-typically, this means that we lose the ability to detect a guaranteed StackOverflow in some cases)
-                return MethodCallResult(Any, true, true, nothing, Effects())
+                return MethodCallResult(Any, Any, true, true, nothing, Effects())
             end
             add_remark!(interp, sv, washardlimit ? RECURSION_MSG_HARDLIMIT : RECURSION_MSG)
             # TODO (#48913) implement a proper recursion handling for irinterp:
@@ -622,7 +651,7 @@ function abstract_call_method(interp::AbstractInterpreter,
         sparams = recomputed[2]::SimpleVector
     end
 
-    (; rt, edge, effects, volatile_inf_result) = typeinf_edge(interp, method, sig, sparams, sv)
+    (; rt, exct, edge, effects, volatile_inf_result) = typeinf_edge(interp, method, sig, sparams, sv)
 
     if edge === nothing
         edgecycle = edgelimited = true
@@ -646,7 +675,7 @@ function abstract_call_method(interp::AbstractInterpreter,
         end
     end
 
-    return MethodCallResult(rt, edgecycle, edgelimited, edge, effects, volatile_inf_result)
+    return MethodCallResult(rt, exct, edgecycle, edgelimited, edge, effects, volatile_inf_result)
 end
 
 function edge_matches_sv(interp::AbstractInterpreter, frame::AbsIntState,
@@ -745,18 +774,19 @@ end
 # backedge computation, and concrete evaluation or constant-propagation
 struct MethodCallResult
     rt
+    exct
     edgecycle::Bool
     edgelimited::Bool
     edge::Union{Nothing,MethodInstance}
     effects::Effects
     volatile_inf_result::Union{Nothing,VolatileInferenceResult}
-    function MethodCallResult(@nospecialize(rt),
+    function MethodCallResult(@nospecialize(rt), @nospecialize(exct),
                               edgecycle::Bool,
                               edgelimited::Bool,
                               edge::Union{Nothing,MethodInstance},
                               effects::Effects,
                               volatile_inf_result::Union{Nothing,VolatileInferenceResult}=nothing)
-        return new(rt, edgecycle, edgelimited, edge, effects, volatile_inf_result)
+        return new(rt, exct, edgecycle, edgelimited, edge, effects, volatile_inf_result)
     end
 end
 
@@ -768,15 +798,16 @@ end
 
 struct ConstCallResults
     rt::Any
+    exct::Any
     const_result::ConstResult
     effects::Effects
     edge::MethodInstance
     function ConstCallResults(
-        @nospecialize(rt),
+        @nospecialize(rt), @nospecialize(exct),
         const_result::ConstResult,
         effects::Effects,
         edge::MethodInstance)
-        return new(rt, const_result, effects, edge)
+        return new(rt, exct, const_result, effects, edge)
     end
 end
 
@@ -903,11 +934,12 @@ function concrete_eval_call(interp::AbstractInterpreter,
     edge = result.edge::MethodInstance
     value = try
         Core._call_in_world_total(world, f, args...)
-    catch
-        # The evaluation threw. By :consistent-cy, we're guaranteed this would have happened at runtime
-        return ConstCallResults(Bottom, ConcreteResult(edge, result.effects), result.effects, edge)
+    catch e
+        # The evaluation threw. By :consistent-cy, we're guaranteed this would have happened at runtime.
+        # Howevever, at present, :consistency does not mandate the type of the exception
+        return ConstCallResults(Bottom, Any, ConcreteResult(edge, result.effects), result.effects, edge)
     end
-    return ConstCallResults(Const(value), ConcreteResult(edge, EFFECTS_TOTAL, value), EFFECTS_TOTAL, edge)
+    return ConstCallResults(Const(value), Union{}, ConcreteResult(edge, EFFECTS_TOTAL, value), EFFECTS_TOTAL, edge)
 end
 
 # check if there is a cycle and duplicated inference of `mi`
@@ -1170,7 +1202,7 @@ function semi_concrete_eval_call(interp::AbstractInterpreter,
                 if noub
                     effects = Effects(effects; noub = ALWAYS_TRUE)
                 end
-                return ConstCallResults(rt, SemiConcreteResult(mi, ir, effects), effects, mi)
+                return ConstCallResults(rt, result.exct, SemiConcreteResult(mi, ir, effects), effects, mi)
             end
         end
     end
@@ -1179,7 +1211,7 @@ end
 
 function const_prop_call(interp::AbstractInterpreter,
     mi::MethodInstance, result::MethodCallResult, arginfo::ArgInfo, sv::AbsIntState,
-    concrete_eval_result::Union{Nothing,ConstCallResults}=nothing)
+    concrete_eval_result::Union{Nothing, ConstCallResults}=nothing)
     inf_cache = get_inference_cache(interp)
     𝕃ᵢ = typeinf_lattice(interp)
     inf_result = cache_lookup(𝕃ᵢ, mi, arginfo.argtypes, inf_cache)
@@ -1214,7 +1246,8 @@ function const_prop_call(interp::AbstractInterpreter,
             return nothing
         end
     end
-    return ConstCallResults(inf_result.result, ConstPropResult(inf_result), inf_result.ipo_effects, mi)
+    return ConstCallResults(inf_result.result, inf_result.exc_result,
+        ConstPropResult(inf_result), inf_result.ipo_effects, mi)
 end
 
 # TODO implement MustAlias forwarding
@@ -1457,7 +1490,7 @@ function abstract_iteration(interp::AbstractInterpreter, @nospecialize(itft), @n
     # WARNING: Changes to the iteration protocol must be reflected here,
     # this is not just an optimization.
     # TODO: this doesn't realize that Array, SimpleVector, Tuple, and NamedTuple do not use the iterate protocol
-    stateordonet === Bottom && return AbstractIterationResult(Any[Bottom], AbstractIterationInfo(CallMeta[CallMeta(Bottom, call.effects, info)], true))
+    stateordonet === Bottom && return AbstractIterationResult(Any[Bottom], AbstractIterationInfo(CallMeta[CallMeta(Bottom, Any, call.effects, info)], true))
     valtype = statetype = Bottom
     ret = Any[]
     calls = CallMeta[call]
@@ -1535,7 +1568,7 @@ function abstract_apply(interp::AbstractInterpreter, argtypes::Vector{Any}, si::
                         sv::AbsIntState, max_methods::Int=get_max_methods(interp, sv))
     itft = argtype_by_index(argtypes, 2)
     aft = argtype_by_index(argtypes, 3)
-    (itft === Bottom || aft === Bottom) && return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
+    (itft === Bottom || aft === Bottom) && return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
     aargtypes = argtype_tail(argtypes, 4)
     aftw = widenconst(aft)
     if !isa(aft, Const) && !isa(aft, PartialOpaque) && (!isType(aftw) || has_free_typevars(aftw))
@@ -1543,7 +1576,7 @@ function abstract_apply(interp::AbstractInterpreter, argtypes::Vector{Any}, si::
             add_remark!(interp, sv, "Core._apply_iterate called on a function of a non-concrete type")
             # bail now, since it seems unlikely that abstract_call will be able to do any better after splitting
             # this also ensures we don't call abstract_call_gf_by_type below on an IntrinsicFunction or Builtin
-            return CallMeta(Any, Effects(), NoCallInfo())
+            return CallMeta(Any, Any, Effects(), NoCallInfo())
         end
     end
     res = Union{}
@@ -1602,6 +1635,7 @@ function abstract_apply(interp::AbstractInterpreter, argtypes::Vector{Any}, si::
     retinfo = UnionSplitApplyCallInfo(retinfos)
     napplicable = length(ctypes)
     seen = 0
+    exct = effects.nothrow ? Union{} : Any
     for i = 1:napplicable
         ct = ctypes[i]
         arginfo = infos[i]
@@ -1619,6 +1653,7 @@ function abstract_apply(interp::AbstractInterpreter, argtypes::Vector{Any}, si::
         seen += 1
         push!(retinfos, ApplyCallInfo(call.info, arginfo))
         res = tmerge(typeinf_lattice(interp), res, call.rt)
+        exct = tmerge(typeinf_lattice(interp), exct, call.exct)
         effects = merge_effects(effects, call.effects)
         if bail_out_apply(interp, InferenceLoopState(ct, res, effects), sv)
             add_remark!(interp, sv, "_apply_iterate inference reached maximally imprecise information. Bailing on.")
@@ -1628,12 +1663,13 @@ function abstract_apply(interp::AbstractInterpreter, argtypes::Vector{Any}, si::
     if seen ≠ napplicable
         # there is unanalyzed candidate, widen type and effects to the top
         res = Any
+        exct = Any
         effects = Effects()
         retinfo = NoCallInfo() # NOTE this is necessary to prevent the inlining processing
     end
     # TODO: Add a special info type to capture all the iteration info.
     # For now, only propagate info if we don't also union-split the iteration
-    return CallMeta(res, effects, retinfo)
+    return CallMeta(res, exct, effects, retinfo)
 end
 
 function argtype_by_index(argtypes::Vector{Any}, i::Int)
@@ -1882,9 +1918,9 @@ function abstract_call_unionall(interp::AbstractInterpreter, argtypes::Vector{An
     na = length(argtypes)
     if isvarargtype(argtypes[end])
         if na ≤ 2
-            return CallMeta(Any, EFFECTS_THROWS, call.info)
+            return CallMeta(Any, Any, EFFECTS_THROWS, call.info)
         elseif na > 4
-            return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
+            return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
         end
         a2 = argtypes[2]
         a3 = unwrapva(argtypes[3])
@@ -1895,7 +1931,7 @@ function abstract_call_unionall(interp::AbstractInterpreter, argtypes::Vector{An
         ⊑ᵢ = ⊑(typeinf_lattice(interp))
         nothrow = a2 ⊑ᵢ TypeVar && (a3 ⊑ᵢ Type || a3 ⊑ᵢ TypeVar)
     else
-        return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
+        return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
     end
     canconst = true
     if isa(a3, Const)
@@ -1904,10 +1940,10 @@ function abstract_call_unionall(interp::AbstractInterpreter, argtypes::Vector{An
         body = a3.parameters[1]
         canconst = false
     else
-        return CallMeta(Any, Effects(EFFECTS_TOTAL; nothrow), call.info)
+        return CallMeta(Any, Any, Effects(EFFECTS_TOTAL; nothrow), call.info)
     end
     if !(isa(body, Type) || isa(body, TypeVar))
-        return CallMeta(Any, EFFECTS_THROWS, call.info)
+        return CallMeta(Any, Any, EFFECTS_THROWS, call.info)
     end
     if has_free_typevars(body)
         if isa(a2, Const)
@@ -1916,36 +1952,36 @@ function abstract_call_unionall(interp::AbstractInterpreter, argtypes::Vector{An
             tv = a2.tv
             canconst = false
         else
-            return CallMeta(Any, EFFECTS_THROWS, call.info)
+            return CallMeta(Any, Any, EFFECTS_THROWS, call.info)
         end
-        isa(tv, TypeVar) || return CallMeta(Any, EFFECTS_THROWS, call.info)
+        isa(tv, TypeVar) || return CallMeta(Any, Any, EFFECTS_THROWS, call.info)
         body = UnionAll(tv, body)
     end
     ret = canconst ? Const(body) : Type{body}
-    return CallMeta(ret, Effects(EFFECTS_TOTAL; nothrow), call.info)
+    return CallMeta(ret, Any, Effects(EFFECTS_TOTAL; nothrow), call.info)
 end
 
 function abstract_invoke(interp::AbstractInterpreter, (; fargs, argtypes)::ArgInfo, si::StmtInfo, sv::AbsIntState)
     ft′ = argtype_by_index(argtypes, 2)
     ft = widenconst(ft′)
-    ft === Bottom && return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
+    ft === Bottom && return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
     (types, isexact, isconcrete, istype) = instanceof_tfunc(argtype_by_index(argtypes, 3), false)
-    isexact || return CallMeta(Any, Effects(), NoCallInfo())
+    isexact || return CallMeta(Any, Any, Effects(), NoCallInfo())
     unwrapped = unwrap_unionall(types)
     if types === Bottom || !(unwrapped isa DataType) || unwrapped.name !== Tuple.name
-        return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
+        return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
     end
     argtype = argtypes_to_type(argtype_tail(argtypes, 4))
     nargtype = typeintersect(types, argtype)
-    nargtype === Bottom && return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
-    nargtype isa DataType || return CallMeta(Any, Effects(), NoCallInfo()) # other cases are not implemented below
-    isdispatchelem(ft) || return CallMeta(Any, Effects(), NoCallInfo()) # check that we might not have a subtype of `ft` at runtime, before doing supertype lookup below
+    nargtype === Bottom && return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
+    nargtype isa DataType || return CallMeta(Any, Any, Effects(), NoCallInfo()) # other cases are not implemented below
+    isdispatchelem(ft) || return CallMeta(Any, Any, Effects(), NoCallInfo()) # check that we might not have a subtype of `ft` at runtime, before doing supertype lookup below
     ft = ft::DataType
     lookupsig = rewrap_unionall(Tuple{ft, unwrapped.parameters...}, types)::Type
     nargtype = Tuple{ft, nargtype.parameters...}
     argtype = Tuple{ft, argtype.parameters...}
     match, valid_worlds = findsup(lookupsig, method_table(interp))
-    match === nothing && return CallMeta(Any, Effects(), NoCallInfo())
+    match === nothing && return CallMeta(Any, Any, Effects(), NoCallInfo())
     update_valid_age!(sv, valid_worlds)
     method = match.method
     tienv = ccall(:jl_type_intersection_with_env, Any, (Any, Any), nargtype, method.sig)::SimpleVector
@@ -1977,7 +2013,7 @@ function abstract_invoke(interp::AbstractInterpreter, (; fargs, argtypes)::ArgIn
     rt = from_interprocedural!(interp, rt, sv, arginfo, sig)
     info = InvokeCallInfo(match, const_result)
     edge !== nothing && add_invoke_backedge!(sv, lookupsig, edge)
-    return CallMeta(rt, effects, info)
+    return CallMeta(rt, Any, effects, info)
 end
 
 function invoke_rewrite(xs::Vector{Any})
@@ -1991,9 +2027,9 @@ function abstract_finalizer(interp::AbstractInterpreter, argtypes::Vector{Any},
     if length(argtypes) == 3
         finalizer_argvec = Any[argtypes[2], argtypes[3]]
         call = abstract_call(interp, ArgInfo(nothing, finalizer_argvec), StmtInfo(false), sv, #=max_methods=#1)
-        return CallMeta(Nothing, Effects(), FinalizerInfo(call.info, call.effects))
+        return CallMeta(Nothing, Any, Effects(), FinalizerInfo(call.info, call.effects))
     end
-    return CallMeta(Nothing, Effects(), NoCallInfo())
+    return CallMeta(Nothing, Any, Effects(), NoCallInfo())
 end
 
 # call where the function is known exactly
@@ -2015,19 +2051,33 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
             return abstract_finalizer(interp, argtypes, sv)
         elseif f === applicable
             return abstract_applicable(interp, argtypes, sv, max_methods)
+        elseif f === throw
+            if la == 2
+                arg2 = argtypes[2]
+                if isvarargtype(arg2)
+                    exct = tmerge(𝕃ᵢ, unwrapva(argtypes[2]), ArgumentError)
+                else
+                    exct = arg2
+                end
+            elseif la == 3 && isvarargtype(argtypes[3])
+                exct = tmerge(𝕃ᵢ, argtypes[2], ArgumentError)
+            else
+                exct = ArgumentError
+            end
+            return CallMeta(Union{}, exct, EFFECTS_THROWS, NoCallInfo())
         end
         rt = abstract_call_builtin(interp, f, arginfo, sv)
         ft = popfirst!(argtypes)
         effects = builtin_effects(𝕃ᵢ, f, argtypes, rt)
         pushfirst!(argtypes, ft)
-        return CallMeta(rt, effects, NoCallInfo())
+        return CallMeta(rt, effects.nothrow ? Union{} : Any, effects, NoCallInfo())
     elseif isa(f, Core.OpaqueClosure)
         # calling an OpaqueClosure about which we have no information returns no information
-        return CallMeta(typeof(f).parameters[2], Effects(), NoCallInfo())
+        return CallMeta(typeof(f).parameters[2], Any, Effects(), NoCallInfo())
     elseif f === TypeVar
         # Manually look through the definition of TypeVar to
         # make sure to be able to get `PartialTypeVar`s out.
-        (la < 2 || la > 4) && return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
+        (la < 2 || la > 4) && return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
         n = argtypes[2]
         ub_var = Const(Any)
         lb_var = Const(Union{})
@@ -2046,7 +2096,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         end
         pT = typevar_tfunc(𝕃ᵢ, n, lb_var, ub_var)
         effects = builtin_effects(𝕃ᵢ, Core._typevar, Any[n, lb_var, ub_var], pT)
-        return CallMeta(pT, effects, call.info)
+        return CallMeta(pT, Any, effects, call.info)
     elseif f === UnionAll
         call = abstract_call_gf_by_type(interp, f, ArgInfo(nothing, Any[Const(UnionAll), Any, Any]), si, Tuple{Type{UnionAll}, Any, Any}, sv, max_methods)
         return abstract_call_unionall(interp, argtypes, call)
@@ -2054,7 +2104,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         aty = argtypes[2]
         ty = isvarargtype(aty) ? unwrapva(aty) : widenconst(aty)
         if !isconcretetype(ty)
-            return CallMeta(Tuple, EFFECTS_UNKNOWN, NoCallInfo())
+            return CallMeta(Tuple, Any, EFFECTS_UNKNOWN, NoCallInfo())
         end
     elseif is_return_type(f)
         return return_type_tfunc(interp, argtypes, si, sv)
@@ -2063,16 +2113,16 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         aty = argtypes[2]
         if isa(aty, Conditional)
             call = abstract_call_gf_by_type(interp, f, ArgInfo(fargs, Any[Const(f), Bool]), si, Tuple{typeof(f), Bool}, sv, max_methods) # make sure we've inferred `!(::Bool)`
-            return CallMeta(Conditional(aty.slot, aty.elsetype, aty.thentype), call.effects, call.info)
+            return CallMeta(Conditional(aty.slot, aty.elsetype, aty.thentype), Any, call.effects, call.info)
         end
     elseif la == 3 && istopfunction(f, :!==)
         # mark !== as exactly a negated call to ===
         call = abstract_call_gf_by_type(interp, f, ArgInfo(fargs, Any[Const(f), Any, Any]), si, Tuple{typeof(f), Any, Any}, sv, max_methods)
         rty = abstract_call_known(interp, (===), arginfo, si, sv, max_methods).rt
         if isa(rty, Conditional)
-            return CallMeta(Conditional(rty.slot, rty.elsetype, rty.thentype), EFFECTS_TOTAL, NoCallInfo()) # swap if-else
+            return CallMeta(Conditional(rty.slot, rty.elsetype, rty.thentype), Bottom, EFFECTS_TOTAL, NoCallInfo()) # swap if-else
         elseif isa(rty, Const)
-            return CallMeta(Const(rty.val === false), EFFECTS_TOTAL, MethodResultPure())
+            return CallMeta(Const(rty.val === false), Bottom, EFFECTS_TOTAL, MethodResultPure())
         end
         return call
     elseif la == 3 && istopfunction(f, :(>:))
@@ -2086,7 +2136,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         argtypes = Any[typeof(<:), argtypes[3], argtypes[2]]
         return abstract_call_known(interp, <:, ArgInfo(fargs, argtypes), si, sv, max_methods)
     elseif la == 2 && istopfunction(f, :typename)
-        return CallMeta(typename_static(argtypes[2]), EFFECTS_TOTAL, MethodResultPure())
+        return CallMeta(typename_static(argtypes[2]), Any, EFFECTS_TOTAL, MethodResultPure())
     elseif f === Core._hasmethod
         return _hasmethod_tfunc(interp, argtypes, sv)
     end
@@ -2125,7 +2175,7 @@ function abstract_call_opaque_closure(interp::AbstractInterpreter,
     rt = from_interprocedural!(interp, rt, sv, arginfo, match.spec_types)
     info = OpaqueClosureCallInfo(match, const_result)
     edge !== nothing && add_backedge!(sv, edge)
-    return CallMeta(rt, effects, info)
+    return CallMeta(rt, Any, effects, info)
 end
 
 function most_general_argtypes(closure::PartialOpaque)
@@ -2150,13 +2200,13 @@ function abstract_call_unknown(interp::AbstractInterpreter, @nospecialize(ft),
     wft = widenconst(ft)
     if hasintersect(wft, Builtin)
         add_remark!(interp, sv, "Could not identify method table for call")
-        return CallMeta(Any, Effects(), NoCallInfo())
+        return CallMeta(Any, Any, Effects(), NoCallInfo())
     elseif hasintersect(wft, Core.OpaqueClosure)
         uft = unwrap_unionall(wft)
         if isa(uft, DataType)
-            return CallMeta(rewrap_unionall(uft.parameters[2], wft), Effects(), NoCallInfo())
+            return CallMeta(rewrap_unionall(uft.parameters[2], wft), Any, Effects(), NoCallInfo())
         end
-        return CallMeta(Any, Effects(), NoCallInfo())
+        return CallMeta(Any, Any, Effects(), NoCallInfo())
     end
     # non-constant function, but the number of arguments is known and the `f` is not a builtin or intrinsic
     atype = argtypes_to_type(arginfo.argtypes)
@@ -2237,31 +2287,30 @@ end
 
 function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(e), vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
     if isa(e, QuoteNode)
-        return RTEffects(Const(e.value), EFFECTS_TOTAL)
+        return RTEffects(Const(e.value), Union{}, EFFECTS_TOTAL)
     elseif isa(e, SSAValue)
-        return RTEffects(abstract_eval_ssavalue(e, sv), EFFECTS_TOTAL)
+        return RTEffects(abstract_eval_ssavalue(e, sv), Union{}, EFFECTS_TOTAL)
     elseif isa(e, SlotNumber)
-        effects = EFFECTS_THROWS
         if vtypes !== nothing
             vtyp = vtypes[slot_id(e)]
             if !vtyp.undef
-                effects = EFFECTS_TOTAL
+                return RTEffects(vtyp.typ, Union{}, EFFECTS_TOTAL)
             end
-            return RTEffects(vtyp.typ, effects)
+            return RTEffects(vtyp.typ, UndefVarError, EFFECTS_THROWS)
         end
-        return RTEffects(Any, effects)
+        return RTEffects(Any, UndefVarError, EFFECTS_THROWS)
     elseif isa(e, Argument)
         if vtypes !== nothing
-            return RTEffects(vtypes[slot_id(e)].typ, EFFECTS_TOTAL)
+            return RTEffects(vtypes[slot_id(e)].typ, Union{}, EFFECTS_TOTAL)
         else
             @assert isa(sv, IRInterpretationState)
-            return RTEffects(sv.ir.argtypes[e.n], EFFECTS_TOTAL) # TODO frame_argtypes(sv)[e.n] and remove the assertion
+            return RTEffects(sv.ir.argtypes[e.n], Union{}, EFFECTS_TOTAL) # TODO frame_argtypes(sv)[e.n] and remove the assertion
         end
     elseif isa(e, GlobalRef)
         return abstract_eval_globalref(interp, e, sv)
     end
 
-    return RTEffects(Const(e), EFFECTS_TOTAL)
+    return RTEffects(Const(e), Union{}, EFFECTS_TOTAL)
 end
 
 function abstract_eval_value_expr(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
@@ -2316,17 +2365,18 @@ end
 
 struct RTEffects
     rt
+    exct
     effects::Effects
-    RTEffects(@nospecialize(rt), effects::Effects) = new(rt, effects)
+    RTEffects(@nospecialize(rt), @nospecialize(exct), effects::Effects) = new(rt, exct, effects)
 end
 
 function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo, sv::InferenceState)
     si = StmtInfo(!call_result_unused(sv, sv.currpc))
-    (; rt, effects, info) = abstract_call(interp, arginfo, si, sv)
+    (; rt, exct, effects, info) = abstract_call(interp, arginfo, si, sv)
     sv.stmt_info[sv.currpc] = info
     # mark this call statement as DCE-eligible
     # TODO better to do this in a single pass based on the `info` object at the end of abstractinterpret?
-    return RTEffects(rt, effects)
+    return RTEffects(rt, exct, effects)
 end
 
 function abstract_eval_call(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
@@ -2334,24 +2384,31 @@ function abstract_eval_call(interp::AbstractInterpreter, e::Expr, vtypes::Union{
     ea = e.args
     argtypes = collect_argtypes(interp, ea, vtypes, sv)
     if argtypes === nothing
-        return RTEffects(Bottom, Effects())
+        return RTEffects(Bottom, Any, Effects())
     end
     arginfo = ArgInfo(ea, argtypes)
     return abstract_call(interp, arginfo, sv)
 end
 
+function abstract_eval_the_exception(interp::AbstractInterpreter, sv::InferenceState)
+    return sv.handlers[sv.handler_at[sv.currpc][2]].exct
+end
+abstract_eval_the_exception(::AbstractInterpreter, ::IRInterpretationState) = Any
+
 function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
                                       sv::AbsIntState)
     effects = Effects()
     ehead = e.head
     𝕃ᵢ = typeinf_lattice(interp)
     ⊑ᵢ = ⊑(𝕃ᵢ)
+    exct = Any
     if ehead === :call
-        (; rt, effects) = abstract_eval_call(interp, e, vtypes, sv)
+        (; rt, exct, effects) = abstract_eval_call(interp, e, vtypes, sv)
         t = rt
     elseif ehead === :new
         t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
         ut = unwrap_unionall(t)
+        exct = Union{ErrorException, TypeError}
         if isa(ut, DataType) && !isabstracttype(ut)
             ismutable = ismutabletype(ut)
             fcount = datatype_fieldcount(ut)
@@ -2416,6 +2473,7 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
             nothrow = false
         end
         effects = Effects(EFFECTS_TOTAL; consistent, nothrow)
+        nothrow && (exct = Union{})
     elseif ehead === :splatnew
         t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
         nothrow = false # TODO: More precision
@@ -2465,7 +2523,7 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
             end
         end
     elseif ehead === :foreigncall
-        (; rt, effects) = abstract_eval_foreigncall(interp, e, vtypes, sv)
+        (; rt, exct, effects) = abstract_eval_foreigncall(interp, e, vtypes, sv)
         t = rt
     elseif ehead === :cfunction
         effects = EFFECTS_UNKNOWN
@@ -2488,6 +2546,7 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         sym = e.args[1]
         t = Bool
         effects = EFFECTS_TOTAL
+        exct = Union{}
         if isa(sym, SlotNumber) && vtypes !== nothing
             vtyp = vtypes[slot_id(sym)]
             if vtyp.typ === Bottom
@@ -2528,10 +2587,12 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         condt = argextype(stmt.args[2], ir)
         condval = maybe_extract_const_bool(condt)
         t = Nothing
+        exct = UndefVarError
         effects = EFFECTS_THROWS
         if condval isa Bool
             if condval
                 effects = EFFECTS_TOTAL
+                exct = Union{}
             else
                 t = Union{}
             end
@@ -2540,13 +2601,16 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         end
     elseif ehead === :boundscheck
         t = Bool
+        exct = Union{}
         effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE)
     elseif ehead === :the_exception
-        t = Any
+        t = abstract_eval_the_exception(interp, sv)
+        exct = Union{}
         effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE)
     elseif ehead === :static_parameter
         n = e.args[1]::Int
         nothrow = false
+        exct = UndefVarError
         if 1 <= n <= length(sv.sptypes)
             sp = sv.sptypes[n]
             t = sp.typ
@@ -2554,15 +2618,21 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         else
             t = Any
         end
+        if nothrow
+            exct = Union{}
+        end
         effects = Effects(EFFECTS_TOTAL; nothrow)
     elseif ehead === :gc_preserve_begin || ehead === :aliasscope
         t = Any
+        exct = Union{}
         effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE, effect_free=EFFECT_FREE_GLOBALLY)
     elseif ehead === :gc_preserve_end || ehead === :leave || ehead === :pop_exception || ehead === :global || ehead === :popaliasscope
         t = Nothing
+        exct = Union{}
         effects = Effects(EFFECTS_TOTAL; effect_free=EFFECT_FREE_GLOBALLY)
     elseif ehead === :method
         t = Method
+        exct = Union{}
         effects = Effects(EFFECTS_TOTAL; effect_free=EFFECT_FREE_GLOBALLY)
     elseif ehead === :thunk
         t = Any
@@ -2578,7 +2648,7 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         # and recompute the effects.
         effects = EFFECTS_TOTAL
     end
-    return RTEffects(t, effects)
+    return RTEffects(t, exct, effects)
 end
 
 # refine the result of instantiation of partially-known type `t` if some invariant can be assumed
@@ -2599,7 +2669,7 @@ function abstract_eval_foreigncall(interp::AbstractInterpreter, e::Expr, vtypes:
     t = sp_type_rewrap(e.args[2], mi, true)
     for i = 3:length(e.args)
         if abstract_eval_value(interp, e.args[i], vtypes, sv) === Bottom
-            return RTEffects(Bottom, EFFECTS_THROWS)
+            return RTEffects(Bottom, Any, EFFECTS_THROWS)
         end
     end
     effects = foreigncall_effects(e) do @nospecialize x
@@ -2617,7 +2687,7 @@ function abstract_eval_foreigncall(interp::AbstractInterpreter, e::Expr, vtypes:
             inaccessiblememonly = override.inaccessiblememonly ? ALWAYS_TRUE : effects.inaccessiblememonly,
             noub                = override.noub ? ALWAYS_TRUE : override.noub_if_noinbounds ? NOUB_IF_NOINBOUNDS : effects.noub)
     end
-    return RTEffects(t, effects)
+    return RTEffects(t, Any, effects)
 end
 
 function abstract_eval_phi(interp::AbstractInterpreter, phi::PhiNode, vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
@@ -2641,11 +2711,11 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
     if !isa(e, Expr)
         if isa(e, PhiNode)
             add_curr_ssaflag!(sv, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
-            return abstract_eval_phi(interp, e, vtypes, sv)
+            return RTEffects(abstract_eval_phi(interp, e, vtypes, sv), Union{}, EFFECTS_TOTAL)
         end
-        (; rt, effects) = abstract_eval_special_value(interp, e, vtypes, sv)
+        (; rt, exct, effects) = abstract_eval_special_value(interp, e, vtypes, sv)
     else
-        (; rt, effects) = abstract_eval_statement_expr(interp, e, vtypes, sv)
+        (; rt, exct, effects) = abstract_eval_statement_expr(interp, e, vtypes, sv)
         if effects.noub === NOUB_IF_NOINBOUNDS
             if !iszero(get_curr_ssaflag(sv) & IR_FLAG_INBOUNDS)
                 effects = Effects(effects; noub=ALWAYS_FALSE)
@@ -2673,7 +2743,7 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
     set_curr_ssaflag!(sv, flags_for_effects(effects), IR_FLAGS_EFFECTS)
     merge_effects!(interp, sv, effects)
 
-    return rt
+    return RTEffects(rt, exct, effects)
 end
 
 function isdefined_globalref(g::GlobalRef)
@@ -2706,7 +2776,7 @@ function abstract_eval_globalref(interp::AbstractInterpreter, g::GlobalRef, sv::
         consistent = inaccessiblememonly = ALWAYS_TRUE
         rt = Union{}
     end
-    return RTEffects(rt, Effects(EFFECTS_TOTAL; consistent, nothrow, inaccessiblememonly))
+    return RTEffects(rt, nothrow ? Union{} : UndefVarError, Effects(EFFECTS_TOTAL; consistent, nothrow, inaccessiblememonly))
 end
 
 function handle_global_assignment!(interp::AbstractInterpreter, frame::InferenceState, lhs::GlobalRef, @nospecialize(newty))
@@ -2900,50 +2970,51 @@ end
 
 struct BasicStmtChange
     changes::Union{Nothing,StateUpdate}
-    type::Any # ::Union{Type, Nothing} - `nothing` if this statement may not be used as an SSA Value
+    rt::Any # extended lattice element or `nothing` - `nothing` if this statement may not be used as an SSA Value
+    exct::Any
     # TODO effects::Effects
-    BasicStmtChange(changes::Union{Nothing,StateUpdate}, @nospecialize type) = new(changes, type)
+    BasicStmtChange(changes::Union{Nothing,StateUpdate}, @nospecialize(rt), @nospecialize(exct)) = new(changes, rt, exct)
 end
 
 @inline function abstract_eval_basic_statement(interp::AbstractInterpreter,
     @nospecialize(stmt), pc_vartable::VarTable, frame::InferenceState)
     if isa(stmt, NewvarNode)
         changes = StateUpdate(stmt.slot, VarState(Bottom, true), pc_vartable, false)
-        return BasicStmtChange(changes, nothing)
+        return BasicStmtChange(changes, nothing, Union{})
     elseif !isa(stmt, Expr)
-        t = abstract_eval_statement(interp, stmt, pc_vartable, frame)
-        return BasicStmtChange(nothing, t)
+        (; rt, exct) = abstract_eval_statement(interp, stmt, pc_vartable, frame)
+        return BasicStmtChange(nothing, rt, exct)
     end
     changes = nothing
     stmt = stmt::Expr
     hd = stmt.head
     if hd === :(=)
-        t = abstract_eval_statement(interp, stmt.args[2], pc_vartable, frame)
-        if t === Bottom
-            return BasicStmtChange(nothing, Bottom)
+        (; rt, exct) = abstract_eval_statement(interp, stmt.args[2], pc_vartable, frame)
+        if rt === Bottom
+            return BasicStmtChange(nothing, Bottom, exct)
         end
         lhs = stmt.args[1]
         if isa(lhs, SlotNumber)
-            changes = StateUpdate(lhs, VarState(t, false), pc_vartable, false)
+            changes = StateUpdate(lhs, VarState(rt, false), pc_vartable, false)
         elseif isa(lhs, GlobalRef)
-            handle_global_assignment!(interp, frame, lhs, t)
+            handle_global_assignment!(interp, frame, lhs, rt)
         elseif !isa(lhs, SSAValue)
             merge_effects!(interp, frame, EFFECTS_UNKNOWN)
         end
-        return BasicStmtChange(changes, t)
+        return BasicStmtChange(changes, rt, exct)
     elseif hd === :method
         fname = stmt.args[1]
         if isa(fname, SlotNumber)
             changes = StateUpdate(fname, VarState(Any, false), pc_vartable, false)
         end
-        return BasicStmtChange(changes, nothing)
+        return BasicStmtChange(changes, nothing, Union{})
     elseif (hd === :code_coverage_effect || (
             hd !== :boundscheck && # :boundscheck can be narrowed to Bool
             is_meta_expr(stmt)))
-        return BasicStmtChange(nothing, Nothing)
+        return BasicStmtChange(nothing, Nothing, Bottom)
     else
-        t = abstract_eval_statement(interp, stmt, pc_vartable, frame)
-        return BasicStmtChange(nothing, t)
+        (; rt, exct) = abstract_eval_statement(interp, stmt, pc_vartable, frame)
+        return BasicStmtChange(nothing, rt, exct)
     end
 end
 
@@ -3004,9 +3075,9 @@ end
 function propagate_to_error_handler!(frame::InferenceState, currpc::Int, W::BitSet, 𝕃ᵢ::AbstractLattice, currstate::VarTable)
     # If this statement potentially threw, propagate the currstate to the
     # exception handler, BEFORE applying any state changes.
-    cur_hand = frame.handler_at[currpc]
+    cur_hand = frame.handler_at[currpc][1]
     if cur_hand != 0
-        enter = frame.src.code[cur_hand]::Expr
+        enter = frame.src.code[frame.handlers[cur_hand].enter_idx]::Expr
         l = enter.args[1]::Int
         exceptbb = block_for_inst(frame.cfg, l)
         if update_bbstate!(𝕃ᵢ, frame, exceptbb, currstate)
@@ -3152,23 +3223,47 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 # Fall through terminator - treat as regular stmt
             end
             # Process non control-flow statements
-            (; changes, type) = abstract_eval_basic_statement(interp,
+            (; changes, rt, exct) = abstract_eval_basic_statement(interp,
                 stmt, currstate, frame)
+            if exct !== Union{}
+                𝕃ₚ = ipo_lattice(interp)
+                cur_hand = frame.handler_at[currpc][1]
+                if cur_hand == 0
+                    if !⊑(𝕃ₚ, exct, frame.exc_bestguess)
+                        frame.exc_bestguess = tmerge(𝕃ₚ, frame.exc_bestguess, exct)
+                        for (caller, caller_pc) in frame.cycle_backedges
+                            handler = caller.handler_at[caller_pc][1]
+                            if (handler == 0 ? caller.exc_bestguess : caller.handlers[handler].exct) !== Any
+                                push!(caller.ip, block_for_inst(caller.cfg, caller_pc))
+                            end
+                        end
+                    end
+                else
+                    handler_frame = frame.handlers[cur_hand]
+                    if !⊑(𝕃ₚ, exct, handler_frame.exct)
+                        handler_frame.exct = tmerge(𝕃ₚ, handler_frame.exct, exct)
+                        enter = frame.src.code[handler_frame.enter_idx]::Expr
+                        l = enter.args[1]::Int
+                        exceptbb = block_for_inst(frame.cfg, l)
+                        push!(W, exceptbb)
+                    end
+                end
+            end
             if (get_curr_ssaflag(frame) & IR_FLAG_NOTHROW) != IR_FLAG_NOTHROW
                 propagate_to_error_handler!(frame, currpc, W, 𝕃ᵢ, currstate)
             end
-            if type === Bottom
+            if rt === Bottom
                 ssavaluetypes[currpc] = Bottom
                 @goto find_next_bb
             end
             if changes !== nothing
                 stoverwrite1!(currstate, changes)
             end
-            if type === nothing
+            if rt === nothing
                 ssavaluetypes[currpc] = Any
                 continue
             end
-            record_ssa_assign!(𝕃ᵢ, currpc, type, frame)
+            record_ssa_assign!(𝕃ᵢ, currpc, rt, frame)
         end # for currpc in bbstart:bbend
 
         # Case 1: Fallthrough termination
diff --git a/base/compiler/effects.jl b/base/compiler/effects.jl
index fc774efbbee85..d4c972ab89e95 100644
--- a/base/compiler/effects.jl
+++ b/base/compiler/effects.jl
@@ -171,6 +171,68 @@ function Effects(effects::Effects = _EFFECTS_UNKNOWN;
         nonoverlayed)
 end
 
+function is_better_effects(new::Effects, old::Effects)
+    any_improved = false
+    if new.consistent == ALWAYS_TRUE
+        any_improved |= old.consistent != ALWAYS_TRUE
+    else
+        if !iszero(new.consistent & CONSISTENT_IF_NOTRETURNED)
+            old.consistent == ALWAYS_TRUE && return false
+            any_improved |= iszero(old.consistent & CONSISTENT_IF_NOTRETURNED)
+        elseif !iszero(new.consistent & CONSISTENT_IF_INACCESSIBLEMEMONLY)
+            old.consistent == ALWAYS_TRUE && return false
+            any_improved |= iszero(old.consistent & CONSISTENT_IF_INACCESSIBLEMEMONLY)
+        else
+            return false
+        end
+    end
+    if new.effect_free == ALWAYS_TRUE
+        any_improved |= old.consistent != ALWAYS_TRUE
+    elseif new.effect_free == EFFECT_FREE_IF_INACCESSIBLEMEMONLY
+        old.effect_free == ALWAYS_TRUE && return false
+        any_improved |= old.effect_free != EFFECT_FREE_IF_INACCESSIBLEMEMONLY
+    elseif new.effect_free != old.effect_free
+        return false
+    end
+    if new.nothrow
+        any_improved |= !old.nothrow
+    elseif new.nothrow != old.nothrow
+        return false
+    end
+    if new.terminates
+        any_improved |= !old.terminates
+    elseif new.terminates != old.terminates
+        return false
+    end
+    if new.notaskstate
+        any_improved |= !old.notaskstate
+    elseif new.notaskstate != old.notaskstate
+        return false
+    end
+    if new.inaccessiblememonly == ALWAYS_TRUE
+        any_improved |= old.inaccessiblememonly != ALWAYS_TRUE
+    elseif new.inaccessiblememonly == INACCESSIBLEMEM_OR_ARGMEMONLY
+        old.inaccessiblememonly == ALWAYS_TRUE && return false
+        any_improved |= old.inaccessiblememonly != INACCESSIBLEMEM_OR_ARGMEMONLY
+    elseif new.inaccessiblememonly != old.inaccessiblememonly
+        return false
+    end
+    if new.noub == ALWAYS_TRUE
+        any_improved |= old.noub != ALWAYS_TRUE
+    elseif new.noub == NOUB_IF_NOINBOUNDS
+        old.noub == ALWAYS_TRUE && return false
+        any_improved |= old.noub != NOUB_IF_NOINBOUNDS
+    elseif new.noub != old.noub
+        return false
+    end
+    if new.nonoverlayed
+        any_improved |= !old.nonoverlayed
+    elseif new.nonoverlayed != old.nonoverlayed
+        return false
+    end
+    return any_improved
+end
+
 function merge_effects(old::Effects, new::Effects)
     return Effects(
         merge_effectbits(old.consistent, new.consistent),
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 4024273944200..772dbe72d4dc1 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -203,6 +203,12 @@ const CACHE_MODE_GLOBAL   = 0x01 << 0 # cached globally, optimization allowed
 const CACHE_MODE_LOCAL    = 0x01 << 1 # cached locally, optimization allowed
 const CACHE_MODE_VOLATILE = 0x01 << 2 # not cached, optimization allowed
 
+mutable struct TryCatchFrame
+    exct
+    const enter_idx::Int
+    TryCatchFrame(@nospecialize(exct), enter_idx::Int) = new(exct, enter_idx)
+end
+
 mutable struct InferenceState
     #= information about this method instance =#
     linfo::MethodInstance
@@ -218,7 +224,8 @@ mutable struct InferenceState
     currbb::Int
     currpc::Int
     ip::BitSet#=TODO BoundedMinPrioritySet=# # current active instruction pointers
-    handler_at::Vector{Int} # current exception handler info
+    handlers::Vector{TryCatchFrame}
+    handler_at::Vector{Tuple{Int, Int}} # tuple of current (handler, exception stack) value at the pc
     ssavalue_uses::Vector{BitSet} # ssavalue sparsity and restart info
     # TODO: Could keep this sparsely by doing structural liveness analysis ahead of time.
     bb_vartables::Vector{Union{Nothing,VarTable}} # nothing if not analyzed yet
@@ -239,6 +246,7 @@ mutable struct InferenceState
     unreachable::BitSet # statements that were found to be statically unreachable
     valid_worlds::WorldRange
     bestguess #::Type
+    exc_bestguess
     ipo_effects::Effects
 
     #= flags =#
@@ -266,7 +274,7 @@ mutable struct InferenceState
 
         currbb = currpc = 1
         ip = BitSet(1) # TODO BitSetBoundedMinPrioritySet(1)
-        handler_at = compute_trycatch(code, BitSet())
+        handler_at, handlers = compute_trycatch(code, BitSet())
         nssavalues = src.ssavaluetypes::Int
         ssavalue_uses = find_ssavalue_uses(code, nssavalues)
         nstmts = length(code)
@@ -296,6 +304,7 @@ mutable struct InferenceState
 
         valid_worlds = WorldRange(src.min_world, src.max_world == typemax(UInt) ? get_world_counter() : src.max_world)
         bestguess = Bottom
+        exc_bestguess = Bottom
         ipo_effects = EFFECTS_TOTAL
 
         insert_coverage = should_insert_coverage(mod, src)
@@ -315,9 +324,9 @@ mutable struct InferenceState
 
         return new(
             linfo, world, mod, sptypes, slottypes, src, cfg, method_info,
-            currbb, currpc, ip, handler_at, ssavalue_uses, bb_vartables, ssavaluetypes, stmt_edges, stmt_info,
+            currbb, currpc, ip, handlers, handler_at, ssavalue_uses, bb_vartables, ssavaluetypes, stmt_edges, stmt_info,
             pclimitations, limitations, cycle_backedges, callers_in_cycle, dont_work_on_me, parent,
-            result, unreachable, valid_worlds, bestguess, ipo_effects,
+            result, unreachable, valid_worlds, bestguess, exc_bestguess, ipo_effects,
             restrict_abstract_call_sites, cache_mode, insert_coverage,
             interp)
     end
@@ -347,16 +356,19 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
     empty!(ip)
     ip.offset = 0 # for _bits_findnext
     push!(ip, n + 1)
-    handler_at = fill(0, n)
+    handler_at = fill((0, 0), n)
+    handlers = TryCatchFrame[]
 
     # start from all :enter statements and record the location of the try
     for pc = 1:n
         stmt = code[pc]
         if isexpr(stmt, :enter)
             l = stmt.args[1]::Int
-            handler_at[pc + 1] = pc
+            push!(handlers, TryCatchFrame(Bottom, pc))
+            handler_id = length(handlers)
+            handler_at[pc + 1] = (handler_id, 0)
             push!(ip, pc + 1)
-            handler_at[l] = pc
+            handler_at[l] = (handler_id, handler_id)
             push!(ip, l)
         end
     end
@@ -369,25 +381,26 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
         while true # inner loop optimizes the common case where it can run straight from pc to pc + 1
             pc´ = pc + 1 # next program-counter (after executing instruction)
             delete!(ip, pc)
-            cur_hand = handler_at[pc]
-            @assert cur_hand != 0 "unbalanced try/catch"
+            cur_stacks = handler_at[pc]
+            @assert cur_stacks != (0, 0) "unbalanced try/catch"
             stmt = code[pc]
             if isa(stmt, GotoNode)
                 pc´ = stmt.label
             elseif isa(stmt, GotoIfNot)
                 l = stmt.dest::Int
-                if handler_at[l] != cur_hand
-                    @assert handler_at[l] == 0 "unbalanced try/catch"
-                    handler_at[l] = cur_hand
+                if handler_at[l] != cur_stacks
+                    @assert handler_at[l][1] == 0 || handler_at[l][1] == cur_stacks[1] "unbalanced try/catch"
+                    handler_at[l] = cur_stacks
                     push!(ip, l)
                 end
             elseif isa(stmt, ReturnNode)
-                @assert !isdefined(stmt, :val) "unbalanced try/catch"
+                @assert !isdefined(stmt, :val) || cur_stacks[1] == 0 "unbalanced try/catch"
                 break
             elseif isa(stmt, Expr)
                 head = stmt.head
                 if head === :enter
-                    cur_hand = pc
+                    # Already set above
+                    cur_stacks = (handler_at[pc´][1], cur_stacks[2])
                 elseif head === :leave
                     l = 0
                     for j = 1:length(stmt.args)
@@ -403,19 +416,21 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
                         end
                         l += 1
                     end
+                    cur_hand = cur_stacks[1]
                     for i = 1:l
-                        cur_hand = handler_at[cur_hand]
+                        cur_hand = handler_at[handlers[cur_hand].enter_idx][1]
                     end
-                    cur_hand == 0 && break
+                    cur_stacks = (cur_hand, cur_stacks[2])
+                    cur_stacks == (0, 0) && break
+                elseif head === :pop_exception
+                    cur_stacks = (cur_stacks[1], handler_at[(stmt.args[1]::SSAValue).id][2])
+                    cur_stacks == (0, 0) && break
                 end
             end
 
             pc´ > n && break # can't proceed with the fast-path fall-through
-            if handler_at[pc´] != cur_hand
-                if handler_at[pc´] != 0
-                    @assert false "unbalanced try/catch"
-                end
-                handler_at[pc´] = cur_hand
+            if handler_at[pc´] != cur_stacks
+                handler_at[pc´] = cur_stacks
             elseif !in(pc´, ip)
                 break  # already visited
             end
@@ -424,7 +439,7 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
     end
 
     @assert first(ip) == n + 1
-    return handler_at
+    return handler_at, handlers
 end
 
 # check if coverage mode is enabled
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 68118f82fb5f2..43bdebed32b03 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -925,8 +925,10 @@ function run_passes_ipo_safe(
     # @timeit "verify 2" verify_ir(ir)
     @pass "compact 2" ir = compact!(ir)
     @pass "SROA"      ir = sroa_pass!(ir, sv.inlining)
-    @pass "ADCE"      ir = adce_pass!(ir, sv.inlining)
-    @pass "compact 3" ir = compact!(ir, true)
+    @pass "ADCE"      (ir, made_changes) = adce_pass!(ir, sv.inlining)
+    if made_changes
+        @pass "compact 3" ir = compact!(ir, true)
+    end
     if JLOptions().debug_level == 2
         @timeit "verify 3" (verify_ir(ir, true, false, optimizer_lattice(sv.inlining.interp)); verify_linetable(ir.linetable))
     end
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index c2c3d2ac0ed54..e4ded5bd282da 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -587,6 +587,7 @@ struct CFGTransformState
     result_bbs::Vector{BasicBlock}
     bb_rename_pred::Vector{Int}
     bb_rename_succ::Vector{Int}
+    domtree::Union{Nothing, DomTree}
 end
 
 # N.B.: Takes ownership of the CFG array
@@ -622,11 +623,14 @@ function CFGTransformState!(blocks::Vector{BasicBlock}, allow_cfg_transforms::Bo
         let blocks = blocks, bb_rename = bb_rename
             result_bbs = BasicBlock[blocks[i] for i = 1:length(blocks) if bb_rename[i] != -1]
         end
+        # TODO: This could be done by just renaming the domtree
+        domtree = construct_domtree(result_bbs)
     else
         bb_rename = Vector{Int}()
         result_bbs = blocks
+        domtree = nothing
     end
-    return CFGTransformState(allow_cfg_transforms, allow_cfg_transforms, result_bbs, bb_rename, bb_rename)
+    return CFGTransformState(allow_cfg_transforms, allow_cfg_transforms, result_bbs, bb_rename, bb_rename, domtree)
 end
 
 mutable struct IncrementalCompact
@@ -681,7 +685,7 @@ mutable struct IncrementalCompact
         bb_rename = Vector{Int}()
         pending_nodes = NewNodeStream()
         pending_perm = Int[]
-        return new(code, parent.result, CFGTransformState(false, false, parent.cfg_transform.result_bbs, bb_rename, bb_rename),
+        return new(code, parent.result, CFGTransformState(false, false, parent.cfg_transform.result_bbs, bb_rename, bb_rename, nothing),
             ssa_rename, parent.used_ssas,
             parent.late_fixup, perm, 1,
             parent.new_new_nodes, parent.new_new_used_ssas, pending_nodes, pending_perm,
@@ -942,6 +946,14 @@ function insert_node_here!(compact::IncrementalCompact, newinst::NewInstruction,
     return inst
 end
 
+function delete_inst_here!(compact)
+    # Delete the statement, update refcounts etc
+    compact[SSAValue(compact.result_idx-1)] = nothing
+    # Pretend that we never compacted this statement in the first place
+    compact.result_idx -= 1
+    return nothing
+end
+
 function getindex(view::TypesView, v::OldSSAValue)
     id = v.id
     ir = view.ir.ir
@@ -1222,19 +1234,25 @@ end
 
 # N.B.: from and to are non-renamed indices
 function kill_edge!(compact::IncrementalCompact, active_bb::Int, from::Int, to::Int)
-    # Note: We recursively kill as many edges as are obviously dead. However, this
-    # may leave dead loops in the IR. We kill these later in a CFG cleanup pass (or
-    # worstcase during codegen).
-    (; bb_rename_pred, bb_rename_succ, result_bbs) = compact.cfg_transform
+    # Note: We recursively kill as many edges as are obviously dead.
+    (; bb_rename_pred, bb_rename_succ, result_bbs, domtree) = compact.cfg_transform
     preds = result_bbs[bb_rename_succ[to]].preds
     succs = result_bbs[bb_rename_pred[from]].succs
     deleteat!(preds, findfirst(x::Int->x==bb_rename_pred[from], preds)::Int)
     deleteat!(succs, findfirst(x::Int->x==bb_rename_succ[to], succs)::Int)
+    if domtree !== nothing
+        domtree_delete_edge!(domtree, result_bbs, bb_rename_pred[from], bb_rename_succ[to])
+    end
     # Check if the block is now dead
-    if length(preds) == 0
-        for succ in copy(result_bbs[bb_rename_succ[to]].succs)
-            kill_edge!(compact, active_bb, to, findfirst(x::Int->x==succ, bb_rename_pred)::Int)
+    if length(preds) == 0 || (domtree !== nothing && bb_unreachable(domtree, bb_rename_succ[to]))
+        to_succs = result_bbs[bb_rename_succ[to]].succs
+        for succ in copy(to_succs)
+            new_succ = findfirst(x::Int->x==succ, bb_rename_pred)
+            new_succ === nothing && continue
+            kill_edge!(compact, active_bb, to, new_succ)
         end
+        empty!(preds)
+        empty!(to_succs)
         if to < active_bb
             # Kill all statements in the block
             stmts = result_bbs[bb_rename_succ[to]].stmts
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index fbd2112a1c0fe..5b414f8786e98 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -46,22 +46,29 @@ end
 
 function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo, irsv::IRInterpretationState)
     si = StmtInfo(true) # TODO better job here?
-    (; rt, effects, info) = abstract_call(interp, arginfo, si, irsv)
+    (; rt, exct, effects, info) = abstract_call(interp, arginfo, si, irsv)
     irsv.ir.stmts[irsv.curridx][:info] = info
-    return RTEffects(rt, effects)
+    return RTEffects(rt, exct, effects)
 end
 
+function kill_block!(ir, bb)
+    # Kill the entire block
+    stmts = ir.cfg.blocks[bb].stmts
+    for bidx = stmts
+        inst = ir[SSAValue(bidx)]
+        inst[:stmt] = nothing
+        inst[:type] = Bottom
+        inst[:flag] = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+    end
+    ir[SSAValue(last(stmts))][:stmt] = ReturnNode()
+    return
+end
+
+
 function update_phi!(irsv::IRInterpretationState, from::Int, to::Int)
     ir = irsv.ir
     if length(ir.cfg.blocks[to].preds) == 0
-        # Kill the entire block
-        for bidx = ir.cfg.blocks[to].stmts
-            inst = ir[SSAValue(bidx)]
-            inst[:stmt] = nothing
-            inst[:type] = Bottom
-            inst[:flag] = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
-        end
-        return
+        kill_block!(ir, to)
     end
     for sidx = ir.cfg.blocks[to].stmts
         stmt = ir[SSAValue(sidx)][:stmt]
@@ -83,15 +90,38 @@ function kill_terminator_edges!(irsv::IRInterpretationState, term_idx::Int, bb::
     ir = irsv.ir
     stmt = ir[SSAValue(term_idx)][:stmt]
     if isa(stmt, GotoIfNot)
-        kill_edge!(ir, bb, stmt.dest, update_phi!(irsv))
-        kill_edge!(ir, bb, bb+1, update_phi!(irsv))
+        kill_edge!(irsv, bb, stmt.dest)
+        kill_edge!(irsv, bb, bb+1)
     elseif isa(stmt, GotoNode)
-        kill_edge!(ir, bb, stmt.label, update_phi!(irsv))
+        kill_edge!(irsv, bb, stmt.label)
     elseif isa(stmt, ReturnNode)
         # Nothing to do
     else
         @assert !isexpr(stmt, :enter)
-        kill_edge!(ir, bb, bb+1, update_phi!(irsv))
+        kill_edge!(irsv, bb, bb+1)
+    end
+end
+
+function kill_edge!(irsv::IRInterpretationState, from::Int, to::Int)
+    ir = irsv.ir
+    kill_edge!(ir, from, to, update_phi!(irsv))
+
+    lazydomtree = irsv.lazydomtree
+    domtree = nothing
+    if isdefined(lazydomtree, :domtree)
+        domtree = get!(lazydomtree)
+        domtree_delete_edge!(domtree, ir.cfg.blocks, from, to)
+    elseif length(ir.cfg.blocks[to].preds) != 0
+        # TODO: If we're not maintaining the domtree, computing it just for this
+        # is slightly overkill - just the dfs tree would be enough.
+        domtree = get!(lazydomtree)
+    end
+
+    if domtree !== nothing && bb_unreachable(domtree, to)
+        kill_block!(ir, to)
+        for edge in ir.cfg.blocks[to].succs
+            kill_edge!(irsv, to, edge)
+        end
     end
 end
 
@@ -113,10 +143,10 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
             if condval
                 inst[:stmt] = nothing
                 inst[:type] = Any
-                kill_edge!(ir, bb, stmt.dest, update_phi!(irsv))
+                kill_edge!(irsv, bb, stmt.dest)
             else
                 inst[:stmt] = GotoNode(stmt.dest)
-                kill_edge!(ir, bb, bb+1, update_phi!(irsv))
+                kill_edge!(irsv, bb, bb+1)
             end
             return true
         end
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 21e0e9b213f1c..6db47ed537e0e 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -382,7 +382,9 @@ function lift_leaves(compact::IncrementalCompact, field::Int,
             elseif isexpr(def, :new)
                 typ = unwrap_unionall(widenconst(types(compact)[leaf]))
                 (isa(typ, DataType) && !isabstracttype(typ)) || return nothing
-                @assert !ismutabletype(typ)
+                if ismutabletype(typ)
+                    isconst(typ, field) || return nothing
+                end
                 if length(def.args) < 1+field
                     if field > fieldcount(typ)
                         return nothing
@@ -1735,7 +1737,8 @@ function adce_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
     phi_uses = fill(0, length(ir.stmts) + length(ir.new_nodes))
     all_phis = Int[]
     unionphis = Pair{Int,Any}[] # sorted
-    compact = IncrementalCompact(ir)
+    compact = IncrementalCompact(ir, true)
+    made_changes = false
     for ((_, idx), stmt) in compact
         if isa(stmt, PhiNode)
             push!(all_phis, idx)
@@ -1757,7 +1760,7 @@ function adce_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
                 # nullify safe `typeassert` calls
                 ty, isexact = instanceof_tfunc(argextype(stmt.args[3], compact), true)
                 if isexact && ⊑(𝕃ₒ, argextype(stmt.args[2], compact), ty)
-                    compact[idx] = nothing
+                    delete_inst_here!(compact)
                     continue
                 end
             end
@@ -1799,6 +1802,7 @@ function adce_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
         if t === Union{}
             stmt = compact[SSAValue(phi)][:stmt]::PhiNode
             kill_phi!(compact, phi_uses, 1:length(stmt.values), SSAValue(phi), stmt, true)
+            made_changes = true
             continue
         elseif t === Any
             continue
@@ -1820,16 +1824,17 @@ function adce_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
         end
         compact.result[phi][:type] = t
         kill_phi!(compact, phi_uses, to_drop, SSAValue(phi), stmt, false)
+        made_changes = true
     end
     # Perform simple DCE for unused values
     extra_worklist = Int[]
     for (idx, nused) in Iterators.enumerate(compact.used_ssas)
         idx >= compact.result_idx && break
         nused == 0 || continue
-        adce_erase!(phi_uses, extra_worklist, compact, idx, false)
+        made_changes |= adce_erase!(phi_uses, extra_worklist, compact, idx, false)
     end
     while !isempty(extra_worklist)
-        adce_erase!(phi_uses, extra_worklist, compact, pop!(extra_worklist), true)
+        made_changes |= adce_erase!(phi_uses, extra_worklist, compact, pop!(extra_worklist), true)
     end
     # Go back and erase any phi cycles
     changed = true
@@ -1850,10 +1855,11 @@ function adce_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
         while !isempty(extra_worklist)
             if adce_erase!(phi_uses, extra_worklist, compact, pop!(extra_worklist), true)
                 changed = true
+                made_changes = true
             end
         end
     end
-    return complete(compact)
+    return Pair{IRCode, Bool}(complete(compact), made_changes)
 end
 
 function is_bb_empty(ir::IRCode, bb::BasicBlock)
@@ -2203,7 +2209,7 @@ function cfg_simplify!(ir::IRCode)
     # Run instruction compaction to produce the result,
     # but we're messing with the CFG
     # so we don't want compaction to do so independently
-    compact = IncrementalCompact(ir, CFGTransformState(true, false, cresult_bbs, bb_rename_pred, bb_rename_succ))
+    compact = IncrementalCompact(ir, CFGTransformState(true, false, cresult_bbs, bb_rename_pred, bb_rename_succ, nothing))
     result_idx = 1
     for (idx, orig_bb) in enumerate(result_bbs)
         ms = orig_bb
diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl
index f3253526d25e9..cbe167926014c 100644
--- a/base/compiler/ssair/slot2ssa.jl
+++ b/base/compiler/ssair/slot2ssa.jl
@@ -584,7 +584,7 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
     end
 
     # Record the correct exception handler for all critical sections
-    handler_at = compute_trycatch(code, BitSet())
+    handler_at, handlers = compute_trycatch(code, BitSet())
 
     phi_slots = Vector{Int}[Int[] for _ = 1:length(ir.cfg.blocks)]
     live_slots = Vector{Int}[Int[] for _ = 1:length(ir.cfg.blocks)]
@@ -627,10 +627,12 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
                 # The slot is live-in into this block. We need to
                 # Create a PhiC node in the catch entry block and
                 # an upsilon node in the corresponding enter block
+                varstate = sv.bb_vartables[li]
+                if varstate === nothing
+                    continue
+                end
                 node = PhiCNode(Any[])
                 insertpoint = first_insert_for_bb(code, cfg, li)
-                varstate = sv.bb_vartables[li]
-                @assert varstate !== nothing
                 vt = varstate[idx]
                 phic_ssa = NewSSAValue(
                     insert_node!(ir, insertpoint,
@@ -690,6 +692,9 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
     new_nodes = ir.new_nodes
     @timeit "SSA Rename" while !isempty(worklist)
         (item::Int, pred, incoming_vals) = pop!(worklist)
+        if sv.bb_vartables[item] === nothing
+            continue
+        end
         # Rename existing phi nodes first, because their uses occur on the edge
         # TODO: This isn't necessary if inlining stops replacing arguments by slots.
         for idx in cfg.blocks[item].stmts
@@ -810,8 +815,8 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
                         incoming_vals[id] = Pair{Any, Any}(thisval, thisdef)
                         has_pinode[id] = false
                         enter_idx = idx
-                        while handler_at[enter_idx] != 0
-                            enter_idx = handler_at[enter_idx]
+                        while handler_at[enter_idx][1] != 0
+                            (; enter_idx) = handlers[handler_at[enter_idx][1]]
                             leave_block = block_for_inst(cfg, code[enter_idx].args[1]::Int)
                             cidx = findfirst((; slot)::NewPhiCNode2->slot_id(slot)==id, new_phic_nodes[leave_block])
                             if cidx !== nothing
diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index f770c72d0fae5..801836c485e31 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -47,7 +47,10 @@ function check_op(ir::IRCode, domtree::DomTree, @nospecialize(op), use_bb::Int,
         end
 
         use_inst = ir[op]
-        if isa(use_inst[:stmt], Union{GotoIfNot, GotoNode, ReturnNode})
+        if isa(use_inst[:stmt], Union{GotoIfNot, GotoNode, ReturnNode}) && !(isa(use_inst[:stmt], ReturnNode) && !isdefined(use_inst[:stmt], :val))
+            # Allow uses of `unreachable`, which may have been inserted when
+            # an earlier block got deleted, but for some reason we didn't figure
+            # out yet that this entire block is dead also.
             @verify_error "At statement %$use_idx: Invalid use of value statement or terminator %$(op.id)"
             error("")
         end
diff --git a/base/compiler/stmtinfo.jl b/base/compiler/stmtinfo.jl
index d634c88cdf8e8..e28858eea60aa 100644
--- a/base/compiler/stmtinfo.jl
+++ b/base/compiler/stmtinfo.jl
@@ -10,6 +10,7 @@ and any additional information (`call.info`) for a given generic call.
 """
 struct CallMeta
     rt::Any
+    exct::Any
     effects::Effects
     info::CallInfo
 end
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index eb43e77885d64..97d8bf90c060d 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -1374,10 +1374,10 @@ end
 function abstract_modifyfield!(interp::AbstractInterpreter, argtypes::Vector{Any}, si::StmtInfo, sv::AbsIntState)
     nargs = length(argtypes)
     if !isempty(argtypes) && isvarargtype(argtypes[nargs])
-        nargs - 1 <= 6 || return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
-        nargs > 3 || return CallMeta(Any, Effects(), NoCallInfo())
+        nargs - 1 <= 6 || return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
+        nargs > 3 || return CallMeta(Any, Any, Effects(), NoCallInfo())
     else
-        5 <= nargs <= 6 || return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
+        5 <= nargs <= 6 || return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
     end
     𝕃ᵢ = typeinf_lattice(interp)
     o = unwrapva(argtypes[2])
@@ -1399,7 +1399,7 @@ function abstract_modifyfield!(interp::AbstractInterpreter, argtypes::Vector{Any
         end
         info = ModifyFieldInfo(callinfo.info)
     end
-    return CallMeta(RT, Effects(), info)
+    return CallMeta(RT, Any, Effects(), info)
 end
 @nospecs function replacefield!_tfunc(𝕃::AbstractLattice, o, f, x, v, success_order, failure_order)
     return replacefield!_tfunc(𝕃, o, f, x, v)
@@ -2742,7 +2742,7 @@ end
 # since abstract_call_gf_by_type is a very inaccurate model of _method and of typeinf_type,
 # while this assumes that it is an absolutely precise and accurate and exact model of both
 function return_type_tfunc(interp::AbstractInterpreter, argtypes::Vector{Any}, si::StmtInfo, sv::AbsIntState)
-    UNKNOWN = CallMeta(Type, EFFECTS_THROWS, NoCallInfo())
+    UNKNOWN = CallMeta(Type, Any, EFFECTS_THROWS, NoCallInfo())
     if !(2 <= length(argtypes) <= 3)
         return UNKNOWN
     end
@@ -2771,7 +2771,7 @@ function return_type_tfunc(interp::AbstractInterpreter, argtypes::Vector{Any}, s
     end
 
     if contains_is(argtypes_vec, Union{})
-        return CallMeta(Const(Union{}), EFFECTS_TOTAL, NoCallInfo())
+        return CallMeta(Const(Union{}), Union{}, EFFECTS_TOTAL, NoCallInfo())
     end
 
     # Run the abstract_call without restricting abstract call
@@ -2789,33 +2789,33 @@ function return_type_tfunc(interp::AbstractInterpreter, argtypes::Vector{Any}, s
     rt = widenslotwrapper(call.rt)
     if isa(rt, Const)
         # output was computed to be constant
-        return CallMeta(Const(typeof(rt.val)), EFFECTS_TOTAL, info)
+        return CallMeta(Const(typeof(rt.val)), Union{}, EFFECTS_TOTAL, info)
     end
     rt = widenconst(rt)
     if rt === Bottom || (isconcretetype(rt) && !iskindtype(rt))
         # output cannot be improved so it is known for certain
-        return CallMeta(Const(rt), EFFECTS_TOTAL, info)
+        return CallMeta(Const(rt), Union{}, EFFECTS_TOTAL, info)
     elseif isa(sv, InferenceState) && !isempty(sv.pclimitations)
         # conservatively express uncertainty of this result
         # in two ways: both as being a subtype of this, and
         # because of LimitedAccuracy causes
-        return CallMeta(Type{<:rt}, EFFECTS_TOTAL, info)
+        return CallMeta(Type{<:rt}, Union{}, EFFECTS_TOTAL, info)
     elseif isa(tt, Const) || isconstType(tt)
         # input arguments were known for certain
         # XXX: this doesn't imply we know anything about rt
-        return CallMeta(Const(rt), EFFECTS_TOTAL, info)
+        return CallMeta(Const(rt), Union{}, EFFECTS_TOTAL, info)
     elseif isType(rt)
-        return CallMeta(Type{rt}, EFFECTS_TOTAL, info)
+        return CallMeta(Type{rt}, Union{}, EFFECTS_TOTAL, info)
     else
-        return CallMeta(Type{<:rt}, EFFECTS_TOTAL, info)
+        return CallMeta(Type{<:rt}, Union{}, EFFECTS_TOTAL, info)
     end
 end
 
 # a simplified model of abstract_call_gf_by_type for applicable
 function abstract_applicable(interp::AbstractInterpreter, argtypes::Vector{Any},
                              sv::AbsIntState, max_methods::Int)
-    length(argtypes) < 2 && return CallMeta(Bottom, EFFECTS_THROWS, NoCallInfo())
-    isvarargtype(argtypes[2]) && return CallMeta(Bool, EFFECTS_UNKNOWN, NoCallInfo())
+    length(argtypes) < 2 && return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
+    isvarargtype(argtypes[2]) && return CallMeta(Bool, Any, EFFECTS_UNKNOWN, NoCallInfo())
     argtypes = argtypes[2:end]
     atype = argtypes_to_type(argtypes)
     matches = find_matching_methods(typeinf_lattice(interp), argtypes, atype, method_table(interp),
@@ -2854,7 +2854,7 @@ function abstract_applicable(interp::AbstractInterpreter, argtypes::Vector{Any},
             end
         end
     end
-    return CallMeta(rt, EFFECTS_TOTAL, NoCallInfo())
+    return CallMeta(rt, Union{}, EFFECTS_TOTAL, NoCallInfo())
 end
 add_tfunc(applicable, 1, INT_INF, @nospecs((𝕃::AbstractLattice, f, args...)->Bool), 40)
 
@@ -2863,26 +2863,26 @@ function _hasmethod_tfunc(interp::AbstractInterpreter, argtypes::Vector{Any}, sv
     if length(argtypes) == 3 && !isvarargtype(argtypes[3])
         ft′ = argtype_by_index(argtypes, 2)
         ft = widenconst(ft′)
-        ft === Bottom && return CallMeta(Bool, EFFECTS_THROWS, NoCallInfo())
+        ft === Bottom && return CallMeta(Bool, Any, EFFECTS_THROWS, NoCallInfo())
         typeidx = 3
     elseif length(argtypes) == 2 && !isvarargtype(argtypes[2])
         typeidx = 2
     else
-        return CallMeta(Any, Effects(), NoCallInfo())
+        return CallMeta(Any, Any, Effects(), NoCallInfo())
     end
     (types, isexact, isconcrete, istype) = instanceof_tfunc(argtype_by_index(argtypes, typeidx), false)
-    isexact || return CallMeta(Bool, Effects(), NoCallInfo())
+    isexact || return CallMeta(Bool, Any, Effects(), NoCallInfo())
     unwrapped = unwrap_unionall(types)
     if types === Bottom || !(unwrapped isa DataType) || unwrapped.name !== Tuple.name
-        return CallMeta(Bool, EFFECTS_THROWS, NoCallInfo())
+        return CallMeta(Bool, Any, EFFECTS_THROWS, NoCallInfo())
     end
     if typeidx == 3
-        isdispatchelem(ft) || return CallMeta(Bool, Effects(), NoCallInfo()) # check that we might not have a subtype of `ft` at runtime, before doing supertype lookup below
+        isdispatchelem(ft) || return CallMeta(Bool, Any, Effects(), NoCallInfo()) # check that we might not have a subtype of `ft` at runtime, before doing supertype lookup below
         types = rewrap_unionall(Tuple{ft, unwrapped.parameters...}, types)::Type
     end
     mt = ccall(:jl_method_table_for, Any, (Any,), types)
     if !isa(mt, MethodTable)
-        return CallMeta(Bool, EFFECTS_THROWS, NoCallInfo())
+        return CallMeta(Bool, Any, EFFECTS_THROWS, NoCallInfo())
     end
     match, valid_worlds = findsup(types, method_table(interp))
     update_valid_age!(sv, valid_worlds)
@@ -2894,7 +2894,7 @@ function _hasmethod_tfunc(interp::AbstractInterpreter, argtypes::Vector{Any}, sv
         edge = specialize_method(match)::MethodInstance
         add_invoke_backedge!(sv, types, edge)
     end
-    return CallMeta(rt, EFFECTS_TOTAL, NoCallInfo())
+    return CallMeta(rt, Any, EFFECTS_TOTAL, NoCallInfo())
 end
 
 # N.B.: typename maps type equivalence classes to a single value
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index c1230980c42a6..55026e54f777d 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -327,7 +327,7 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult,
     end
     # relocatability = isa(inferred_result, String) ? inferred_result[end] : UInt8(0)
     return CodeInstance(result.linfo,
-        widenconst(result_type), rettype_const, inferred_result,
+        widenconst(result_type), widenconst(result.exc_result), rettype_const, inferred_result,
         const_flags, first(valid_worlds), last(valid_worlds),
         # TODO: Actually do something with non-IPO effects
         encode_effects(result.ipo_effects), encode_effects(result.ipo_effects), result.analysis_results,
@@ -524,7 +524,8 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
     # inspect whether our inference had a limited result accuracy,
     # else it may be suitable to cache
     bestguess = me.bestguess = cycle_fix_limited(me.bestguess, me)
-    limited_ret = bestguess isa LimitedAccuracy
+    exc_bestguess = me.exc_bestguess = cycle_fix_limited(me.exc_bestguess, me)
+    limited_ret = bestguess isa LimitedAccuracy || exc_bestguess isa LimitedAccuracy
     limited_src = false
     if !limited_ret
         gt = me.ssavaluetypes
@@ -539,6 +540,7 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
     me.result.valid_worlds = me.valid_worlds
     me.result.result = bestguess
     me.result.ipo_effects = me.ipo_effects = adjust_effects(me)
+    me.result.exc_result = exc_bestguess
 
     if limited_ret
         # a parent may be cached still, but not this intermediate work:
@@ -568,6 +570,7 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
             me.result.src = me.src # for reflection etc.
         end
     end
+
     validate_code_in_debug_mode(me.linfo, me.src, "inferred")
     nothing
 end
@@ -795,15 +798,16 @@ end
 ipo_effects(code::CodeInstance) = decode_effects(code.ipo_purity_bits)
 
 struct EdgeCallResult
-    rt #::Type
+    rt
+    exct
     edge::Union{Nothing,MethodInstance}
     effects::Effects
     volatile_inf_result::Union{Nothing,VolatileInferenceResult}
-    function EdgeCallResult(@nospecialize(rt),
+    function EdgeCallResult(@nospecialize(rt), @nospecialize(exct),
                             edge::Union{Nothing,MethodInstance},
                             effects::Effects,
                             volatile_inf_result::Union{Nothing,VolatileInferenceResult} = nothing)
-        return new(rt, edge, effects, volatile_inf_result)
+        return new(rt, exct, edge, effects, volatile_inf_result)
     end
 end
 
@@ -823,14 +827,14 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
             rt = cached_return_type(code)
             effects = ipo_effects(code)
             update_valid_age!(caller, WorldRange(min_world(code), max_world(code)))
-            return EdgeCallResult(rt, mi, effects)
+            return EdgeCallResult(rt, code.exctype, mi, effects)
         end
     else
         cache_mode = CACHE_MODE_GLOBAL # cache edge targets globally by default
     end
     if ccall(:jl_get_module_infer, Cint, (Any,), method.module) == 0 && !generating_output(#=incremental=#false)
         add_remark!(interp, caller, "Inference is disabled for the target module")
-        return EdgeCallResult(Any, nothing, Effects())
+        return EdgeCallResult(Any, Any, nothing, Effects())
     end
     if !is_cached(caller) && frame_parent(caller) === nothing
         # this caller exists to return to the user
@@ -848,7 +852,7 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
             add_remark!(interp, caller, "Failed to retrieve source")
             # can't get the source for this, so we know nothing
             unlock_mi_inference(interp, mi)
-            return EdgeCallResult(Any, nothing, Effects())
+            return EdgeCallResult(Any, Any, nothing, Effects())
         end
         if is_cached(caller) || frame_parent(caller) !== nothing # don't involve uncached functions in cycle resolution
             frame.parent = caller
@@ -863,15 +867,15 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         volatile_inf_result = isinferred && let inferred_src = result.src
                 isa(inferred_src, CodeInfo) && (is_inlineable(inferred_src) || force_inline)
             end ? VolatileInferenceResult(result) : nothing
-        return EdgeCallResult(frame.bestguess, edge, effects, volatile_inf_result)
+        return EdgeCallResult(frame.bestguess, frame.exc_bestguess, edge, effects, volatile_inf_result)
     elseif frame === true
         # unresolvable cycle
-        return EdgeCallResult(Any, nothing, Effects())
+        return EdgeCallResult(Any, Any, nothing, Effects())
     end
     # return the current knowledge about this cycle
     frame = frame::InferenceState
     update_valid_age!(caller, frame.valid_worlds)
-    return EdgeCallResult(frame.bestguess, nothing, adjust_effects(Effects(), method))
+    return EdgeCallResult(frame.bestguess, frame.exc_bestguess, nothing, adjust_effects(Effects(), method))
 end
 
 function cached_return_type(code::CodeInstance)
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index 41fde10dfedf4..b98cf09ff7cf1 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -81,6 +81,7 @@ mutable struct InferenceResult
     const argtypes::Vector{Any}
     const overridden_by_const::BitVector
     result                   # extended lattice element if inferred, nothing otherwise
+    exc_result               # like `result`, but for the thrown value
     src                      # ::Union{CodeInfo, IRCode, OptimizationState} if inferred copy is available, nothing otherwise
     valid_worlds::WorldRange # if inference and optimization is finished
     ipo_effects::Effects     # if inference is finished
@@ -91,7 +92,7 @@ mutable struct InferenceResult
         # def = linfo.def
         # nargs = def isa Method ? Int(def.nargs) : 0
         # @assert length(cache_argtypes) == nargs
-        return new(linfo, cache_argtypes, overridden_by_const, nothing, nothing,
+        return new(linfo, cache_argtypes, overridden_by_const, nothing, nothing, nothing,
             WorldRange(), Effects(), Effects(), NULL_ANALYSIS_RESULTS, false)
     end
 end
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 3d1fe35453060..d8ca4d9551656 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -462,14 +462,14 @@ function is_throw_call(e::Expr, code::Vector{Any})
     return false
 end
 
-function mark_throw_blocks!(src::CodeInfo, handler_at::Vector{Int})
+function mark_throw_blocks!(src::CodeInfo, handler_at::Vector{Tuple{Int, Int}})
     for stmt in find_throw_blocks(src.code, handler_at)
         src.ssaflags[stmt] |= IR_FLAG_THROW_BLOCK
     end
     return nothing
 end
 
-function find_throw_blocks(code::Vector{Any}, handler_at::Vector{Int})
+function find_throw_blocks(code::Vector{Any}, handler_at::Vector{Tuple{Int, Int}})
     stmts = BitSet()
     n = length(code)
     for i in n:-1:1
@@ -482,7 +482,7 @@ function find_throw_blocks(code::Vector{Any}, handler_at::Vector{Int})
             elseif s.head === :return
                 # see `ReturnNode` handling
             elseif is_throw_call(s, code)
-                if handler_at[i] == 0
+                if handler_at[i][1] == 0
                     push!(stmts, i)
                 end
             elseif i+1 in stmts
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 632c76caa1c08..16f0b6903aa28 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -8006,7 +8006,16 @@ static jl_llvm_functions_t
 
             auto scan_ssavalue = [&](jl_value_t *val) {
                 if (jl_is_ssavalue(val)) {
-                    ctx.ssavalue_usecount[((jl_ssavalue_t*)val)->id-1] += 1;
+                    size_t ssa_idx = ((jl_ssavalue_t*)val)->id-1;
+                    /*
+                     * We technically allow out of bounds SSAValues in dead IR, so make
+                     * sure to bounds check this here. It's still not *good* to leave
+                     * dead code in the IR, because this will conservatively overcount
+                     * it, but let's at least make it not crash.
+                     */
+                    if (ssa_idx < ctx.ssavalue_usecount.size()) {
+                        ctx.ssavalue_usecount[ssa_idx] += 1;
+                    }
                     return true;
                 }
                 return false;
diff --git a/src/gf.c b/src/gf.c
index f964927aa3368..fffeb928a1889 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -284,13 +284,6 @@ JL_DLLEXPORT jl_value_t *jl_methtable_lookup(jl_methtable_t *mt, jl_value_t *typ
 
 // ----- MethodInstance specialization instantiation ----- //
 
-JL_DLLEXPORT jl_code_instance_t* jl_new_codeinst(
-        jl_method_instance_t *mi, jl_value_t *rettype,
-        jl_value_t *inferred_const, jl_value_t *inferred,
-        int32_t const_flags, size_t min_world, size_t max_world,
-        uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
-        uint8_t relocatability);
-
 jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_args_t fptr) JL_GC_DISABLED
 {
     jl_sym_t *sname = jl_symbol(name);
@@ -323,7 +316,7 @@ jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_a
     jl_gc_wb(m, mi);
 
     jl_code_instance_t *codeinst = jl_new_codeinst(mi,
-        (jl_value_t*)jl_any_type, jl_nothing, jl_nothing,
+        (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, jl_nothing, jl_nothing,
         0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
     jl_mi_cache_insert(mi, codeinst);
     jl_atomic_store_relaxed(&codeinst->specptr.fptr1, fptr);
@@ -466,7 +459,7 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
         codeinst = jl_atomic_load_relaxed(&codeinst->next);
     }
     codeinst = jl_new_codeinst(
-        mi, rettype, NULL, NULL,
+        mi, rettype, (jl_value_t*)jl_any_type, NULL, NULL,
         0, min_world, max_world, 0, 0, jl_nothing, 0);
     jl_mi_cache_insert(mi, codeinst);
     return codeinst;
@@ -483,7 +476,7 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
 }
 
 JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
-        jl_method_instance_t *mi, jl_value_t *rettype,
+        jl_method_instance_t *mi, jl_value_t *rettype, jl_value_t *exctype,
         jl_value_t *inferred_const, jl_value_t *inferred,
         int32_t const_flags, size_t min_world, size_t max_world,
         uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
@@ -498,6 +491,7 @@ JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
     codeinst->min_world = min_world;
     codeinst->max_world = max_world;
     codeinst->rettype = rettype;
+    codeinst->exctype = exctype;
     jl_atomic_store_release(&codeinst->inferred, inferred);
     //codeinst->edges = NULL;
     if ((const_flags & 2) == 0)
@@ -2455,7 +2449,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
                 jl_callptr_t unspec_invoke = NULL;
                 if (unspec && (unspec_invoke = jl_atomic_load_acquire(&unspec->invoke))) {
                     jl_code_instance_t *codeinst = jl_new_codeinst(mi,
-                        (jl_value_t*)jl_any_type, NULL, NULL,
+                        (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
                         0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
                     void *unspec_fptr = jl_atomic_load_relaxed(&unspec->specptr.fptr);
                     if (unspec_fptr) {
@@ -2482,7 +2476,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         jl_code_info_t *src = jl_code_for_interpreter(mi, world);
         if (!jl_code_requires_compiler(src, 0)) {
             jl_code_instance_t *codeinst = jl_new_codeinst(mi,
-                (jl_value_t*)jl_any_type, NULL, NULL,
+                (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
                 0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
             jl_atomic_store_release(&codeinst->invoke, jl_fptr_interpret_call);
             jl_mi_cache_insert(mi, codeinst);
@@ -2516,7 +2510,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
             // only these care about the exact specTypes, otherwise we can use it directly
             return ucache;
         }
-        codeinst = jl_new_codeinst(mi, (jl_value_t*)jl_any_type, NULL, NULL,
+        codeinst = jl_new_codeinst(mi, (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
             0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
         void *unspec_fptr = jl_atomic_load_relaxed(&ucache->specptr.fptr);
         if (unspec_fptr) {
diff --git a/src/jltypes.c b/src/jltypes.c
index b1830ec4e765e..c7c7d213c5317 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3244,12 +3244,13 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_code_instance_type =
         jl_new_datatype(jl_symbol("CodeInstance"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(15,
+                        jl_perm_symsvec(16,
                             "def",
                             "next",
                             "min_world",
                             "max_world",
                             "rettype",
+                            "exctype",
                             "rettype_const",
                             "inferred",
                             //"edges",
@@ -3258,7 +3259,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             "analysis_results",
                             "isspecsig", "precompile", "relocatability",
                             "invoke", "specptr"), // function object decls
-                        jl_svec(15,
+                        jl_svec(16,
                             jl_method_instance_type,
                             jl_any_type,
                             jl_ulong_type,
@@ -3266,6 +3267,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_any_type,
                             jl_any_type,
                             jl_any_type,
+                            jl_any_type,
                             //jl_any_type,
                             //jl_bool_type,
                             jl_uint32_type, jl_uint32_type,
@@ -3277,8 +3279,8 @@ void jl_init_types(void) JL_GC_DISABLED
                         jl_emptysvec,
                         0, 1, 1);
     jl_svecset(jl_code_instance_type->types, 1, jl_code_instance_type);
-    const static uint32_t code_instance_constfields[1]  = { 0b000001010110001 }; // Set fields 1, 5-6, 8, 10 as const
-    const static uint32_t code_instance_atomicfields[1] = { 0b110100101000010 }; // Set fields 2, 7, 9, 12, 14-15 as atomic
+    const static uint32_t code_instance_constfields[1]  = { 0b0000010101110001 }; // Set fields 1, 5-7, 9, 11 as const
+    const static uint32_t code_instance_atomicfields[1] = { 0b1101001010000010 }; // Set fields 2, 8, 10, 13, 15-16 as atomic
     //Fields 3-4 are only operated on by construction and deserialization, so are const at runtime
     //Fields 11 and 15 must be protected by locks, and thus all operations on jl_code_instance_t are threadsafe
     jl_code_instance_type->name->constfields = code_instance_constfields;
@@ -3420,8 +3422,8 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_svecset(jl_methtable_type->types, 10, jl_uint8_type);
     jl_svecset(jl_method_type->types, 12, jl_method_instance_type);
     jl_svecset(jl_method_instance_type->types, 6, jl_code_instance_type);
-    jl_svecset(jl_code_instance_type->types, 13, jl_voidpointer_type);
     jl_svecset(jl_code_instance_type->types, 14, jl_voidpointer_type);
+    jl_svecset(jl_code_instance_type->types, 15, jl_voidpointer_type);
     jl_svecset(jl_binding_type->types, 1, jl_globalref_type);
     jl_svecset(jl_binding_type->types, 2, jl_binding_type);
 
diff --git a/src/julia.h b/src/julia.h
index acb700c0bd936..cdc3477a30419 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -411,6 +411,7 @@ typedef struct _jl_code_instance_t {
 
     // inference state cache
     jl_value_t *rettype; // return type for fptr
+    jl_value_t *exctype; // thrown type for fptr
     jl_value_t *rettype_const; // inferred constant return value, or null
     _Atomic(jl_value_t *) inferred; // inferred jl_code_info_t (may be compressed), or jl_nothing, or null
     //TODO: jl_array_t *edges; // stored information about edges from this object
diff --git a/src/julia_internal.h b/src/julia_internal.h
index c09b73f8a1052..eeee548a9a4ee 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -622,6 +622,13 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
 jl_method_instance_t *jl_get_unspecialized_from_mi(jl_method_instance_t *method JL_PROPAGATES_ROOT);
 jl_method_instance_t *jl_get_unspecialized(jl_method_t *def JL_PROPAGATES_ROOT);
 
+JL_DLLEXPORT jl_code_instance_t* jl_new_codeinst(
+        jl_method_instance_t *mi, jl_value_t *rettype, jl_value_t *exctype,
+        jl_value_t *inferred_const, jl_value_t *inferred,
+        int32_t const_flags, size_t min_world, size_t max_world,
+        uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
+        uint8_t relocatability);
+
 JL_DLLEXPORT void jl_compile_method_instance(jl_method_instance_t *mi, jl_tupletype_t *types, size_t world);
 JL_DLLEXPORT int jl_compile_hint(jl_tupletype_t *types);
 jl_code_info_t *jl_code_for_interpreter(jl_method_instance_t *lam JL_PROPAGATES_ROOT, size_t world);
diff --git a/src/opaque_closure.c b/src/opaque_closure.c
index 8b7cc7292be22..7fd6d5a0f8666 100644
--- a/src/opaque_closure.c
+++ b/src/opaque_closure.c
@@ -134,13 +134,6 @@ jl_opaque_closure_t *jl_new_opaque_closure(jl_tupletype_t *argt, jl_value_t *rt_
 jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name,
     int nargs, jl_value_t *functionloc, jl_code_info_t *ci, int isva);
 
-JL_DLLEXPORT jl_code_instance_t* jl_new_codeinst(
-        jl_method_instance_t *mi, jl_value_t *rettype,
-        jl_value_t *inferred_const, jl_value_t *inferred,
-        int32_t const_flags, size_t min_world, size_t max_world,
-        uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
-        uint8_t relocatability);
-
 JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tupletype_t *argt, jl_value_t *rt_lb, jl_value_t *rt_ub,
     jl_module_t *mod, jl_code_info_t *ci, int lineno, jl_value_t *file, int nargs, int isva, jl_value_t *env, int do_compile)
 {
@@ -157,7 +150,7 @@ JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tuplet
 
     sigtype = jl_argtype_with_function(env, (jl_value_t*)argt);
     jl_method_instance_t *mi = jl_specializations_get_linfo((jl_method_t*)root, sigtype, jl_emptysvec);
-    inst = jl_new_codeinst(mi, rt_ub, NULL, (jl_value_t*)ci,
+    inst = jl_new_codeinst(mi, rt_ub, (jl_value_t*)jl_any_type, NULL, (jl_value_t*)ci,
         0, meth->primary_world, -1, 0, 0, jl_nothing, 0);
     jl_mi_cache_insert(mi, inst);
 
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index c89cff0db38b3..2c9d8560aed4d 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -565,9 +565,9 @@ function CC.abstract_eval_globalref(interp::REPLInterpreter, g::GlobalRef,
                                     sv::CC.InferenceState)
     if (interp.limit_aggressive_inference ? is_repl_frame(sv) : is_call_graph_uncached(sv))
         if CC.isdefined_globalref(g)
-            return CC.RTEffects(Const(ccall(:jl_get_globalref_value, Any, (Any,), g)), CC.EFFECTS_TOTAL)
+            return CC.RTEffects(Const(ccall(:jl_get_globalref_value, Any, (Any,), g)), Union{}, CC.EFFECTS_TOTAL)
         end
-        return CC.RTEffects(Union{}, CC.EFFECTS_THROWS)
+        return CC.RTEffects(Union{}, UndefVarError, CC.EFFECTS_THROWS)
     end
     return @invoke CC.abstract_eval_globalref(interp::CC.AbstractInterpreter, g::GlobalRef,
                                               sv::CC.InferenceState)
@@ -609,7 +609,7 @@ function CC.concrete_eval_eligible(interp::REPLInterpreter, @nospecialize(f),
                                    sv::CC.InferenceState)
     if (interp.limit_aggressive_inference ? is_repl_frame(sv) : is_call_graph_uncached(sv))
         neweffects = CC.Effects(result.effects; consistent=CC.ALWAYS_TRUE)
-        result = CC.MethodCallResult(result.rt, result.edgecycle, result.edgelimited,
+        result = CC.MethodCallResult(result.rt, result.exct, result.edgecycle, result.edgelimited,
                                      result.edge, neweffects)
     end
     ret = @invoke CC.concrete_eval_eligible(interp::CC.AbstractInterpreter, f::Any,
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 9580fc55508ac..121e7fad55c90 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -330,7 +330,7 @@ function CC.abstract_call(interp::NoinlineInterpreter,
     ret = @invoke CC.abstract_call(interp::CC.AbstractInterpreter,
         arginfo::CC.ArgInfo, si::CC.StmtInfo, sv::CC.InferenceState, max_methods::Int)
     if sv.mod in noinline_modules(interp)
-        return CC.CallMeta(ret.rt, ret.effects, NoinlineCallInfo(ret.info))
+        return CC.CallMeta(ret.rt, ret.exct, ret.effects, NoinlineCallInfo(ret.info))
     end
     return ret
 end
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index ace17baeb5859..b75e5e5fe87f0 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -4439,8 +4439,8 @@ let x = Tuple{Int,Any}[
         #=21=# (0, Expr(:pop_exception, Core.SSAValue(2)))
         #=22=# (0, Core.ReturnNode(Core.SlotNumber(3)))
     ]
-    handler_at = Core.Compiler.compute_trycatch(last.(x), Core.Compiler.BitSet())
-    @test handler_at == first.(x)
+    handler_at, handlers = Core.Compiler.compute_trycatch(last.(x), Core.Compiler.BitSet())
+    @test map(x->x[1] == 0 ? 0 : handlers[x[1]].enter_idx, handler_at) == first.(x)
 end
 
 @test only(Base.return_types((Bool,)) do y
@@ -5533,3 +5533,28 @@ function test_exit_bottom(s)
     n
 end
 @test only(Base.return_types(test_exit_bottom, Tuple{String})) == Int
+
+function foo_typed_throw_error()
+    try
+        error()
+    catch e
+        if isa(e, ErrorException)
+            return 1.0
+        end
+    end
+    return 1
+end
+@test Base.return_types(foo_typed_throw_error) |> only === Float64
+
+will_throw_no_method(x::Int) = 1
+function foo_typed_throw_metherr()
+    try
+        will_throw_no_method(1.0)
+    catch e
+        if isa(e, MethodError)
+            return 1.0
+        end
+    end
+    return 1
+end
+@test Base.return_types(foo_typed_throw_metherr) |> only === Float64
diff --git a/test/core.jl b/test/core.jl
index 00ab41e4ecd48..c85868c496d91 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -14,7 +14,7 @@ include("testenv.jl")
 # sanity tests that our built-in types are marked correctly for const fields
 for (T, c) in (
         (Core.CodeInfo, []),
-        (Core.CodeInstance, [:def, :rettype, :rettype_const, :ipo_purity_bits, :analysis_results]),
+        (Core.CodeInstance, [:def, :rettype, :exctype, :rettype_const, :ipo_purity_bits, :analysis_results]),
         (Core.Method, [#=:name, :module, :file, :line, :primary_world, :sig, :slot_syms, :external_mt, :nargs, :called, :nospecialize, :nkw, :isva, :is_for_opaque_closure, :constprop=#]),
         (Core.MethodInstance, [#=:def, :specTypes, :sparam_vals=#]),
         (Core.MethodTable, [:module]),
diff --git a/test/precompile.jl b/test/precompile.jl
index bb87e1f6b1dc7..051b750fa7fdf 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1684,7 +1684,7 @@ precompile_test_harness("issue #46296") do load_path
         module CodeInstancePrecompile
 
         mi = first(Base.specializations(first(methods(identity))))
-        ci = Core.CodeInstance(mi, Any, nothing, nothing, zero(Int32), typemin(UInt),
+        ci = Core.CodeInstance(mi, Any, Any, nothing, nothing, zero(Int32), typemin(UInt),
                                typemax(UInt), zero(UInt32), zero(UInt32), nothing, 0x00)
 
         __init__() = @assert ci isa Core.CodeInstance

From 72cd63ce28c50c8c72e009df03dfec608802450e Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 19 Nov 2023 22:03:15 -0500
Subject: [PATCH 0290/1315] jitlayers: reduce excess alignment of #52182
 (#52210)

---
 src/jitlayers.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/jitlayers.h b/src/jitlayers.h
index 85cbb2cf8ec28..ba2e81879a44b 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -306,7 +306,9 @@ class MaxAlignedAllocImpl
         // the returned pointer, this is >= alignof(std::max_align_t), which is too
         // small often to actually use.
         const size_t MaxAlignment = JL_CACHE_BYTE_ALIGNMENT;
-        return Align(std::min((size_t)llvm::PowerOf2Ceil(Size), MaxAlignment));
+        if (Size <= offset)
+            return Align(1);
+        return Align(std::min((size_t)llvm::PowerOf2Ceil(Size - offset), MaxAlignment));
     }
 
     LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, Align Alignment) {

From 7327a8f4256b3dd250ba3838990947b6e7798b25 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 20 Nov 2023 22:23:39 +0900
Subject: [PATCH 0291/1315] effects: add some more test cases for
 `Base.@propagate_inbounds` (#52236)

---
 test/compiler/effects.jl | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 5405066263d79..133ff6e9f3ca9 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1280,3 +1280,13 @@ end |> !Core.Compiler.is_noub
 @test Base.infer_effects((Vector{Any},Int)) do xs, i
     @inbounds xs[i]
 end |> !Core.Compiler.is_noub
+Base.@propagate_inbounds getindex_propagate(xs, i) = xs[i]
+getindex_dont_propagate(xs, i) = xs[i]
+@test Core.Compiler.is_noub_if_noinbounds(Base.infer_effects(getindex_propagate, (Vector{Any},Int)))
+@test Core.Compiler.is_noub(Base.infer_effects(getindex_dont_propagate, (Vector{Any},Int)))
+@test Base.infer_effects((Vector{Any},Int)) do xs, i
+    @inbounds getindex_propagate(xs, i)
+end |> !Core.Compiler.is_noub
+@test Base.infer_effects((Vector{Any},Int)) do xs, i
+    @inbounds getindex_dont_propagate(xs, i)
+end |> Core.Compiler.is_noub

From 5cb0e514a143a7aa4dfb371e25f03c35007fa927 Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Mon, 20 Nov 2023 16:45:21 +0100
Subject: [PATCH 0292/1315] build: ASAN fixes for glibc (#51755)

For the `sigsetjmp` bypass; looks like glibc removed the
`__libc_siglongjmp` symbol in glibc 2.34, so change to using the
approach taking by our `dlopen` wrapper instead.

Adopts topolarity's fixes from #50170
Resolves #47698

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 src/dlload.c |  2 +-
 src/julia.h  |  7 +++----
 src/task.c   | 18 ++++++++++++++++++
 3 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/src/dlload.c b/src/dlload.c
index f2ba02e14c5d1..484c36a228886 100644
--- a/src/dlload.c
+++ b/src/dlload.c
@@ -188,7 +188,7 @@ JL_DLLEXPORT JL_NO_SANITIZE void *jl_dlopen(const char *filename, unsigned flags
         dlopen = (dlopen_prototype*)dlsym(RTLD_NEXT, "dlopen");
         if (!dlopen)
             return NULL;
-        void *libdl_handle = dlopen("libdl.so", RTLD_NOW | RTLD_NOLOAD);
+        void *libdl_handle = dlopen("libdl.so.2", RTLD_NOW | RTLD_NOLOAD);
         assert(libdl_handle);
         dlopen = (dlopen_prototype*)dlsym(libdl_handle, "dlopen");
         dlclose(libdl_handle);
diff --git a/src/julia.h b/src/julia.h
index cdc3477a30419..5198bcab5a2bd 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -2287,10 +2287,9 @@ void (ijl_longjmp)(jmp_buf _Buf, int _Value);
 #define jl_setjmp_name "sigsetjmp"
 #endif
 #define jl_setjmp(a,b) sigsetjmp(a,b)
-#if defined(_COMPILER_ASAN_ENABLED_) && __GLIBC__
-// Bypass the ASAN longjmp wrapper - we're unpoisoning the stack ourselves.
-JL_DLLIMPORT int __attribute__ ((nothrow)) (__libc_siglongjmp)(jl_jmp_buf buf, int val);
-#define jl_longjmp(a,b) __libc_siglongjmp(a,b)
+#if defined(_COMPILER_ASAN_ENABLED_) && defined(__GLIBC__)
+extern void (*real_siglongjmp)(jmp_buf _Buf, int _Value);
+#define jl_longjmp(a,b) real_siglongjmp(a,b)
 #else
 #define jl_longjmp(a,b) siglongjmp(a,b)
 #endif
diff --git a/src/task.c b/src/task.c
index dca924c3ae09c..8905b49e87f8e 100644
--- a/src/task.c
+++ b/src/task.c
@@ -42,6 +42,13 @@ extern "C" {
 #endif
 
 #if defined(_COMPILER_ASAN_ENABLED_)
+#if __GLIBC__
+#include <dlfcn.h>
+// Bypass the ASAN longjmp wrapper - we are unpoisoning the stack ourselves,
+// since ASAN normally unpoisons far too much.
+// c.f. interceptor in jl_dlopen as well
+void (*real_siglongjmp)(jmp_buf _Buf, int _Value) = NULL;
+#endif
 static inline void sanitizer_start_switch_fiber(jl_ptls_t ptls, jl_task_t *from, jl_task_t *to) {
     if (to->copy_stack)
         __sanitizer_start_switch_fiber(&from->ctx.asan_fake_stack, (char*)ptls->stackbase-ptls->stacksize, ptls->stacksize);
@@ -1226,6 +1233,17 @@ void jl_init_tasks(void) JL_GC_DISABLED
         exit(1);
     }
 #endif
+#if defined(_COMPILER_ASAN_ENABLED_) && __GLIBC__
+    void *libc_handle = dlopen("libc.so.6", RTLD_NOW | RTLD_NOLOAD);
+    if (libc_handle) {
+        *(void**)&real_siglongjmp = dlsym(libc_handle, "siglongjmp");
+        dlclose(libc_handle);
+    }
+    if (real_siglongjmp == NULL) {
+        jl_safe_printf("failed to get real siglongjmp\n");
+        exit(1);
+    }
+#endif
 }
 
 #if defined(_COMPILER_ASAN_ENABLED_)

From 67161a3ba8253f64932a3e7023ab81aa20a6bf65 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Mon, 20 Nov 2023 17:10:15 +0000
Subject: [PATCH 0293/1315] Silence noisy test in `test/cmdlineargs.jl`
 (#52225)

This is spamming
([example](https://buildkite.com/julialang/julia-master/builds/30247#018be235-0cd3-43bb-ba43-cc378ac0d682/792-1056))
```
      From worker 12:	ERROR: LoadError: UndefVarError: `@which` not defined in `Main`
      From worker 12:	Stacktrace:
      From worker 12:	 [1] top-level scope
      From worker 12:	   @ :0
      From worker 12:	 [2] lower
      From worker 12:	   @ ./meta.jl:163 [inlined]
      From worker 12:	 [3] eval_user_input(errio::IOContext{Base.PipeEndpoint}, ast::Any, show_value::Bool)
      From worker 12:	   @ Base ./client.jl:141
      From worker 12:	 [4] run_main_repl(interactive::Bool, quiet::Bool, banner::Symbol, history_file::Bool, color_set::Bool)
      From worker 12:	   @ Base ./client.jl:477
      From worker 12:	 [5] repl_main
      From worker 12:	   @ Base ./client.jl:561 [inlined]
      From worker 12:	 [6] _start()
      From worker 12:	   @ Base ./client.jl:535
      From worker 12:	in expression starting at none:1
```
in all jobs
---
 test/cmdlineargs.jl | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 1c90352af29c9..ae81dbb0fefbe 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -4,8 +4,8 @@ import Libdl
 
 # helper function for passing input to stdin
 # and returning the stdout result
-function writereadpipeline(input, exename)
-    p = open(exename, "w+")
+function writereadpipeline(input, exename; stderr=nothing)
+    p = open(pipeline(exename; stderr), "w+")
     @async begin
         write(p.in, input)
         close(p.in)
@@ -145,14 +145,19 @@ end
 
 let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
     # tests for handling of ENV errors
-    let v = writereadpipeline(
+    let
+        io = IOBuffer()
+        v = writereadpipeline(
             "println(\"REPL: \", @which(less), @isdefined(InteractiveUtils))",
             setenv(`$exename -i -E '@assert isempty(LOAD_PATH); push!(LOAD_PATH, "@stdlib"); @isdefined InteractiveUtils'`,
                     "JULIA_LOAD_PATH" => "",
                     "JULIA_DEPOT_PATH" => ";:",
-                    "HOME" => homedir()))
+                    "HOME" => homedir());
+            stderr=io)
         # @which is undefined
         @test_broken v == ("false\nREPL: InteractiveUtilstrue\n", true)
+        stderr = String(take!(io))
+        @test_broken isempty(stderr)
     end
     let v = writereadpipeline("println(\"REPL: \", InteractiveUtils)",
                 setenv(`$exename -i -e 'const InteractiveUtils = 3'`,

From 65090d116eecddad5bdef88b1f3d6dace91310da Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 21 Nov 2023 03:08:45 +0100
Subject: [PATCH 0294/1315] tweak the error printed for `PrecompileError` to
 indicate that it doesn't have to be due to `__precompile__(false)` (#51367)

---
 base/loading.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/loading.jl b/base/loading.jl
index ff1a2207a2022..9a3a922298f1e 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1747,7 +1747,7 @@ end
 # we throw PrecompilableError when a module doesn't want to be precompiled
 struct PrecompilableError <: Exception end
 function show(io::IO, ex::PrecompilableError)
-    print(io, "Declaring __precompile__(false) is not allowed in files that are being precompiled.")
+    print(io, "Error when precompiling module, potentially caused by a __precompile__(false) declaration in the module.")
 end
 precompilableerror(ex::PrecompilableError) = true
 precompilableerror(ex::WrappedException) = precompilableerror(ex.error)

From 15ab0262bf015ec9e41df89f718d6718c2bb1ee6 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Tue, 21 Nov 2023 02:59:58 +0900
Subject: [PATCH 0295/1315] inference: add reflection utility for exception
 type analysis

This commit defines functions that mirror our tools for analyzing return
types and computational effects.

The key point to discuss is that this commit introduces two functions:
`Base.exception_types` and `Base.exception_type`. `Base.exception_types`
acts like `Base.return_types`, giving a list of exception types for each
method that matches with the given call signature. On the other hand,
`Base.exception_type` is akin to `Base.infer_effects`, returning a
single exception type that covers all potential outcomes entailed by the
given call signature. I personally lean towards the latter for its
utility, particularly in testing scenarios, but I included
`exception_types` too for consistency with `return_types`.
I'd welcome any feedback on this approach.
---
 base/reflection.jl | 264 ++++++++++++++++++++++++++++++++++++++++-----
 test/reflection.jl |  27 +++++
 2 files changed, 263 insertions(+), 28 deletions(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index 304f7a4344fb2..145a7a9a376d5 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1692,15 +1692,45 @@ function code_ircode_by_type(
     return asts
 end
 
+function _builtin_return_type(interp::Core.Compiler.AbstractInterpreter,
+                              @nospecialize(f::Core.Builtin), @nospecialize(types))
+    argtypes = Any[to_tuple_type(types).parameters...]
+    rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
+    return Core.Compiler.widenconst(rt)
+end
+
+function _builtin_effects(interp::Core.Compiler.AbstractInterpreter,
+                          @nospecialize(f::Core.Builtin), @nospecialize(types))
+    argtypes = Any[to_tuple_type(types).parameters...]
+    rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
+    return Core.Compiler.builtin_effects(Core.Compiler.typeinf_lattice(interp), f, argtypes, rt)
+end
+
+check_generated_context(world::UInt) =
+    (ccall(:jl_is_in_pure_context, Bool, ()) || world == typemax(UInt)) &&
+        error("code reflection cannot be used from generated functions")
 
 """
-    Base.return_types(f::Function, types::DataType=default_tt(f);
-                      world::UInt=get_world_counter(), interp::NativeInterpreter=Core.Compiler.NativeInterpreter(world))
+    Base.return_types(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::NativeInterpreter=Core.Compiler.NativeInterpreter(world)) -> rts::Vector{Any}
 
 Return a list of possible return types for a given function `f` and argument types `types`.
 The list corresponds to the results of type inference on all the possible method match
 candidates for `f` and `types` (see also [`methods(f, types)`](@ref methods).
 
+# Arguments
+- `f`: The function to analyze.
+- `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
+- `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+
+# Returns
+- `rts::Vector{Any}`: The list of return types that are figured out by inference on
+  methods matching with the given `f` and `types`. The list's order matches the order
+  returned by `methods(f, types)`.
+
 # Example
 
 ```julia
@@ -1722,25 +1752,22 @@ julia> Base.return_types(sum, (Union{Vector{Int},UnitRange{Int}},))
 ```
 
 !!! warning
-    The `return_types` function should not be used from generated functions;
+    The `Base.return_types` function should not be used from generated functions;
     doing so will result in an error.
 """
 function return_types(@nospecialize(f), @nospecialize(types=default_tt(f));
                       world::UInt=get_world_counter(),
                       interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
-    (ccall(:jl_is_in_pure_context, Bool, ()) || world == typemax(UInt)) &&
-        error("code reflection cannot be used from generated functions")
+    check_generated_context(world)
     if isa(f, Core.OpaqueClosure)
         _, rt = only(code_typed_opaque_closure(f))
         return Any[rt]
     end
-
     if isa(f, Core.Builtin)
-        argtypes = Any[to_tuple_type(types).parameters...]
-        rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
-        return Any[Core.Compiler.widenconst(rt)]
+        rt = _builtin_return_type(interp, f, types)
+        return Any[rt]
     end
-    rts = []
+    rts = Any[]
     tt = signature_type(f, types)
     matches = _methods_by_ftype(tt, #=lim=#-1, world)::Vector
     for match in matches
@@ -1752,35 +1779,220 @@ function return_types(@nospecialize(f), @nospecialize(types=default_tt(f));
 end
 
 """
-    infer_effects(f, types=default_tt(f); world=get_world_counter(), interp=Core.Compiler.NativeInterpreter(world))
+    Base.infer_exception_types(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::NativeInterpreter=Core.Compiler.NativeInterpreter(world)) -> excts::Vector{Any}
 
-Compute the `Effects` of a function `f` with argument types `types`. The `Effects` represents the computational effects of the function call, such as whether it is free of side effects, guaranteed not to throw an exception, guaranteed to terminate, etc. The `world` and `interp` arguments specify the world counter and the native interpreter to use for the analysis.
+Return a list of possible exception types for a given function `f` and argument types `types`.
+The list corresponds to the results of type inference on all the possible method match
+candidates for `f` and `types` (see also [`methods(f, types)`](@ref methods).
+It works like [`Base.return_types`](@ref), but it infers the exception types instead of the return types.
 
 # Arguments
 - `f`: The function to analyze.
 - `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
 - `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
-- `interp` (optional): The native interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
 
 # Returns
-- `effects::Effects`: The computed effects of the function call.
+- `excts::Vector{Any}`: The list of exception types that are figured out by inference on
+  methods matching with the given `f` and `types`. The list's order matches the order
+  returned by `methods(f, types)`.
 
 # Example
 
 ```julia
-julia> function foo(x)
-           y = x * 2
-           return y
-       end;
+julia> throw_if_number(::Number) = error("number is given");
+
+julia> throw_if_number(::Any) = nothing;
+
+julia> Base.infer_exception_types(throw_if_number, (Int,))
+1-element Vector{Any}:
+ ErrorException
+
+julia> methods(throw_if_number, (Any,))
+# 2 methods for generic function "throw_if_number" from Main:
+ [1] throw_if_number(x::Number)
+     @ REPL[1]:1
+ [2] throw_if_number(::Any)
+     @ REPL[2]:1
+
+julia> Base.infer_exception_types(throw_if_number, (Any,))
+2-element Vector{Any}:
+ ErrorException # the result of inference on `throw_if_number(::Number)`
+ Union{}        # the result of inference on `throw_if_number(::Any)`
+```
+
+!!! warning
+    The `Base.infer_exception_types` function should not be used from generated functions;
+    doing so will result in an error.
+"""
+function infer_exception_types(@nospecialize(f), @nospecialize(types=default_tt(f));
+                               world::UInt=get_world_counter(),
+                               interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
+    check_generated_context(world)
+    if isa(f, Core.OpaqueClosure)
+        return Any[Any] # TODO
+    end
+    if isa(f, Core.Builtin)
+        effects = _builtin_effects(interp, f, types)
+        exct = Core.Compiler.is_nothrow(effects) ? Union{} : Any
+        return Any[exct]
+    end
+    excts = Any[]
+    tt = signature_type(f, types)
+    matches = _methods_by_ftype(tt, #=lim=#-1, world)::Vector
+    for match in matches
+        match = match::Core.MethodMatch
+        frame = Core.Compiler.typeinf_frame(interp, match, #=run_optimizer=#false)
+        if frame === nothing
+            exct = Any
+        else
+            exct = Core.Compiler.widenconst(frame.result.exc_result)
+        end
+        push!(excts, exct)
+    end
+    return excts
+end
+
+_may_throw_methoderror(matches#=::Core.Compiler.MethodLookupResult=#) =
+    matches.ambig || !any(match::Core.MethodMatch->match.fully_covers, matches.matches)
+
+"""
+    Base.infer_exception_type(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world)) -> exct::Type
+
+Returns the type of exception potentially thrown by the function call specified by `f` and `types`.
+
+# Arguments
+- `f`: The function to analyze.
+- `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
+- `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+
+# Returns
+- `exct::Type`: The inferred type of exception that can be thrown by the function call
+  specified by the given call signature.
 
-julia> effects = Base.infer_effects(foo, (Int,))
+!!! note
+    Note that, different from [`Base.infer_exception_types`](@ref), this doesn't give you the list
+    exception types for every possible matching method with the given `f` and `types`.
+    It provides a single exception type, taking into account all potential outcomes of
+    any function call entailed by the given signature type.
+
+# Example
+
+```julia
+julia> f1(x) = x * 2;
+
+julia> Base.infer_exception_type(f1, (Int,))
+Union{}
+```
+
+The exception inferred as `Union{}` indicates that `f1(::Int)` will not throw any exception.
+
+```julia
+julia> f2(x::Int) = x * 2;
+
+julia> Base.infer_exception_type(f2, (Integer,))
+MethodError
+```
+
+This case is pretty much the same as with `f1`, but there's a key difference to note. For
+`f2`, the argument type is limited to `Int`, while the argument type is given as `Tuple{Integer}`.
+Because of this, taking into account the chance of the method error entailed by the call
+signature, the exception type is widened to `MethodError`.
+
+!!! warning
+    The `Base.infer_exception_type` function should not be used from generated functions;
+    doing so will result in an error.
+"""
+function infer_exception_type(@nospecialize(f), @nospecialize(types=default_tt(f));
+                              world::UInt=get_world_counter(),
+                              interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
+    check_generated_context(world)
+    if isa(f, Core.OpaqueClosure)
+        return Any # TODO
+    end
+    if isa(f, Core.Builtin)
+        effects = _builtin_effects(interp, f, types)
+        return Core.Compiler.is_nothrow(effects) ? Union{} : Any
+    end
+    tt = signature_type(f, types)
+    matches = Core.Compiler.findall(tt, Core.Compiler.method_table(interp))
+    if matches === nothing
+        # unanalyzable call, i.e. the interpreter world might be newer than the world where
+        # the `f` is defined, return the unknown exception type
+        return Any
+    end
+    exct = Union{}
+    if _may_throw_methoderror(matches)
+        # account for the fact that we may encounter a MethodError with a non-covered or ambiguous signature.
+        exct = Core.Compiler.tmerge(exct, MethodError)
+    end
+    for match in matches.matches
+        match = match::Core.MethodMatch
+        frame = Core.Compiler.typeinf_frame(interp, match, #=run_optimizer=#false)
+        frame === nothing && return Any
+        exct = Core.Compiler.tmerge(exct, Core.Compiler.widenconst(frame.result.exc_result))
+    end
+    return exct
+end
+
+"""
+    Base.infer_effects(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world)) -> effects::Effects
+
+Returns the possible computation effects of the function call specified by `f` and `types`.
+
+# Arguments
+- `f`: The function to analyze.
+- `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
+- `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+
+# Returns
+- `effects::Effects`: The computed effects of the function call specified by the given call signature.
+  See the documentation of [`Effects`](@ref Core.Compiler.Effects) or [`Base.@assume_effects`](@ref)
+  for more information on the various effect properties.
+
+!!! note
+    Note that, different from [`Base.return_types`](@ref), this doesn't give you the list
+    effect analysis results for every possible matching method with the given `f` and `types`.
+    It provides a single effect, taking into account all potential outcomes of any function
+    call entailed by the given signature type.
+
+# Example
+
+```julia
+julia> f1(x) = x * 2;
+
+julia> Base.infer_effects(f1, (Int,))
 (+c,+e,+n,+t,+s,+m,+i)
 ```
 
-This function will return an `Effects` object with information about the computational effects of the function `foo` when called with an `Int` argument. See the documentation for `Effects` for more information on the various effect properties.
+This function will return an `Effects` object with information about the computational
+effects of the function `f1` when called with an `Int` argument.
+
+```julia
+julia> f2(x::Int) = x * 2;
+
+julia> Base.infer_effects(f2, (Integer,))
+(+c,+e,!n,+t,+s,+m,+i)
+```
+
+This case is pretty much the same as with `f1`, but there's a key difference to note. For
+`f2`, the argument type is limited to `Int`, while the argument type is given as `Tuple{Integer}`.
+Because of this, taking into account the chance of the method error entailed by the call
+signature, the `:nothrow` bit gets tainted.
 
 !!! warning
-    The `infer_effects` function should not be used from generated functions;
+    The `Base.infer_effects` function should not be used from generated functions;
     doing so will result in an error.
 
 # See Also
@@ -1790,13 +2002,9 @@ This function will return an `Effects` object with information about the computa
 function infer_effects(@nospecialize(f), @nospecialize(types=default_tt(f));
                        world::UInt=get_world_counter(),
                        interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
-    (ccall(:jl_is_in_pure_context, Bool, ()) || world == typemax(UInt)) &&
-        error("code reflection cannot be used from generated functions")
+    check_generated_context(world)
     if isa(f, Core.Builtin)
-        types = to_tuple_type(types)
-        argtypes = Any[types.parameters...]
-        rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
-        return Core.Compiler.builtin_effects(Core.Compiler.typeinf_lattice(interp), f, argtypes, rt)
+        return _builtin_effects(interp, f, types)
     end
     tt = signature_type(f, types)
     matches = Core.Compiler.findall(tt, Core.Compiler.method_table(interp))
@@ -1806,7 +2014,7 @@ function infer_effects(@nospecialize(f), @nospecialize(types=default_tt(f));
         return Core.Compiler.Effects()
     end
     effects = Core.Compiler.EFFECTS_TOTAL
-    if matches.ambig || !any(match::Core.MethodMatch->match.fully_covers, matches.matches)
+    if _may_throw_methoderror(matches)
         # account for the fact that we may encounter a MethodError with a non-covered or ambiguous signature.
         effects = Core.Compiler.Effects(effects; nothrow=false)
     end
diff --git a/test/reflection.jl b/test/reflection.jl
index 7df6a76dfd0ff..87f16deacdded 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1047,6 +1047,33 @@ ambig_effects_test(a, b) = 1
     @test (Base.infer_effects(Core.Intrinsics.mul_int, ()); true) # `intrinsic_effects` shouldn't throw on empty `argtypes`
 end
 
+@testset "infer_exception_type[s]" begin
+    # generic functions
+    @test Base.infer_exception_type(issue41694, (Int,)) == only(Base.infer_exception_types(issue41694, (Int,))) == ErrorException
+    @test Base.infer_exception_type((Int,)) do x
+        issue41694(x)
+    end == Base.infer_exception_types((Int,)) do x
+        issue41694(x)
+    end |> only == ErrorException
+    @test Base.infer_exception_type(issue41694) == only(Base.infer_exception_types(issue41694)) == ErrorException # use `default_tt`
+    let excts = Base.infer_exception_types(maybe_effectful, (Any,))
+        @test any(==(Any), excts)
+        @test any(==(Union{}), excts)
+    end
+    @test Base.infer_exception_type(maybe_effectful, (Any,)) == Any
+    # `infer_exception_type` should account for MethodError
+    @test Base.infer_exception_type(issue41694, (Float64,)) == MethodError # definitive dispatch error
+    @test Base.infer_exception_type(issue41694, (Integer,)) == Union{MethodError,ErrorException} # possible dispatch error
+    @test Base.infer_exception_type(f_no_methods) == MethodError # no possible matching methods
+    @test Base.infer_exception_type(ambig_effects_test, (Int,Int)) == MethodError # ambiguity error
+    @test Base.infer_exception_type(ambig_effects_test, (Int,Any)) == MethodError # ambiguity error
+    # builtins
+    @test Base.infer_exception_type(typeof, (Any,)) === only(Base.infer_exception_types(typeof, (Any,))) === Union{}
+    @test Base.infer_exception_type(===, (Any,Any)) === only(Base.infer_exception_types(===, (Any,Any))) === Union{}
+    @test (Base.infer_exception_type(setfield!, ()); Base.infer_exception_types(setfield!, ()); true) # `infer_exception_type[s]` shouldn't throw on empty `argtypes`
+    @test (Base.infer_exception_type(Core.Intrinsics.mul_int, ()); Base.infer_exception_types(Core.Intrinsics.mul_int, ()); true) # `infer_exception_type[s]` shouldn't throw on empty `argtypes`
+end
+
 @test Base._methods_by_ftype(Tuple{}, -1, Base.get_world_counter()) == Any[]
 @test length(methods(Base.Broadcast.broadcasted, Tuple{Any, Any, Vararg})) >
       length(methods(Base.Broadcast.broadcasted, Tuple{Base.Broadcast.BroadcastStyle, Any, Vararg})) >=

From da1258cb91a397dd4f1a31d2fd4af6fb354391bb Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Mon, 20 Nov 2023 18:16:44 +0900
Subject: [PATCH 0296/1315] `typeinf_local`: factor into
 `update_cycle_worklists!` utility

---
 base/compiler/abstractinterpretation.jl | 26 +++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 453b55caffa42..a811eafbfac02 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -3086,6 +3086,14 @@ function propagate_to_error_handler!(frame::InferenceState, currpc::Int, W::BitS
     end
 end
 
+function update_cycle_worklists!(callback, frame::InferenceState)
+    for (caller, caller_pc) in frame.cycle_backedges
+        if callback(caller, caller_pc)
+            push!(caller.ip, block_for_inst(caller.cfg, caller_pc))
+        end
+    end
+end
+
 # make as much progress on `frame` as possible (without handling cycles)
 function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
     @assert !is_inferred(frame)
@@ -3204,11 +3212,9 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 elseif isa(stmt, ReturnNode)
                     rt = abstract_eval_value(interp, stmt.val, currstate, frame)
                     if update_bestguess!(interp, frame, currstate, rt)
-                        for (caller, caller_pc) in frame.cycle_backedges
-                            if caller.ssavaluetypes[caller_pc] !== Any
-                                # no reason to revisit if that call-site doesn't affect the final result
-                                push!(caller.ip, block_for_inst(caller.cfg, caller_pc))
-                            end
+                        update_cycle_worklists!(frame) do caller::InferenceState, caller_pc::Int
+                            # no reason to revisit if that call-site doesn't affect the final result
+                            return caller.ssavaluetypes[caller_pc] !== Any
                         end
                     end
                     ssavaluetypes[frame.currpc] = Any
@@ -3231,11 +3237,11 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 if cur_hand == 0
                     if !⊑(𝕃ₚ, exct, frame.exc_bestguess)
                         frame.exc_bestguess = tmerge(𝕃ₚ, frame.exc_bestguess, exct)
-                        for (caller, caller_pc) in frame.cycle_backedges
-                            handler = caller.handler_at[caller_pc][1]
-                            if (handler == 0 ? caller.exc_bestguess : caller.handlers[handler].exct) !== Any
-                                push!(caller.ip, block_for_inst(caller.cfg, caller_pc))
-                            end
+                        update_cycle_worklists!(frame) do caller::InferenceState, caller_pc::Int
+                            caller_handler = caller.handler_at[caller_pc][1]
+                            caller_exct = caller_handler == 0 ?
+                                caller.exc_bestguess : caller.handlers[caller_handler].exct
+                            return caller_exct !== Any
                         end
                     end
                 else

From 808d7ac7b8c52a1dc8eb6dc951376347f2c515c0 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Mon, 20 Nov 2023 18:17:13 +0900
Subject: [PATCH 0297/1315] inference: fix exception type of `typename` call

---
 base/compiler/abstractinterpretation.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index a811eafbfac02..b14ebe04796c6 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2136,7 +2136,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         argtypes = Any[typeof(<:), argtypes[3], argtypes[2]]
         return abstract_call_known(interp, <:, ArgInfo(fargs, argtypes), si, sv, max_methods)
     elseif la == 2 && istopfunction(f, :typename)
-        return CallMeta(typename_static(argtypes[2]), Any, EFFECTS_TOTAL, MethodResultPure())
+        return CallMeta(typename_static(argtypes[2]), Bottom, EFFECTS_TOTAL, MethodResultPure())
     elseif f === Core._hasmethod
         return _hasmethod_tfunc(interp, argtypes, sv)
     end

From d85cb0ec0b7cd1b2182612443624e8d2542eb8b9 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Mon, 20 Nov 2023 18:17:28 +0900
Subject: [PATCH 0298/1315] add missing type annotations

---
 base/compiler/ssair/irinterp.jl | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 5b414f8786e98..b1c3fddc3df6e 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -51,7 +51,7 @@ function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo, irsv::IRIn
     return RTEffects(rt, exct, effects)
 end
 
-function kill_block!(ir, bb)
+function kill_block!(ir::IRCode, bb::Int)
     # Kill the entire block
     stmts = ir.cfg.blocks[bb].stmts
     for bidx = stmts
@@ -64,7 +64,6 @@ function kill_block!(ir, bb)
     return
 end
 
-
 function update_phi!(irsv::IRInterpretationState, from::Int, to::Int)
     ir = irsv.ir
     if length(ir.cfg.blocks[to].preds) == 0

From 8dd0cf5c43af7fe401157c6a5ff6704b71f8fd48 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Mon, 20 Nov 2023 18:19:27 +0900
Subject: [PATCH 0299/1315] inference: refine `exct` information if `:nothrow`
 is proven

---
 base/compiler/abstractinterpretation.jl |  9 ++++----
 base/compiler/typeinfer.jl              | 16 ++++++++++----
 test/compiler/inference.jl              | 29 +++++++++++++++++++++++++
 3 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index b14ebe04796c6..d99243a56e969 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1196,13 +1196,14 @@ function semi_concrete_eval_call(interp::AbstractInterpreter,
                 # state = InliningState(interp)
                 # ir = ssa_inlining_pass!(irsv.ir, state, propagate_inbounds(irsv))
                 effects = result.effects
-                if !is_nothrow(effects)
-                    effects = Effects(effects; nothrow)
+                if nothrow
+                    effects = Effects(effects; nothrow=true)
                 end
                 if noub
-                    effects = Effects(effects; noub = ALWAYS_TRUE)
+                    effects = Effects(effects; noub=ALWAYS_TRUE)
                 end
-                return ConstCallResults(rt, result.exct, SemiConcreteResult(mi, ir, effects), effects, mi)
+                exct = refine_exception_type(result.exct, effects)
+                return ConstCallResults(rt, exct, SemiConcreteResult(mi, ir, effects), effects, mi)
             end
         end
     end
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 55026e54f777d..de296089f43be 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -503,6 +503,11 @@ function adjust_effects(sv::InferenceState)
     return ipo_effects
 end
 
+function refine_exception_type(@nospecialize(exc_bestguess), ipo_effects::Effects)
+    ipo_effects.nothrow && return Bottom
+    return exc_bestguess
+end
+
 # inference completed on `me`
 # update the MethodInstance
 function finish(me::InferenceState, interp::AbstractInterpreter)
@@ -539,8 +544,8 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
     end
     me.result.valid_worlds = me.valid_worlds
     me.result.result = bestguess
-    me.result.ipo_effects = me.ipo_effects = adjust_effects(me)
-    me.result.exc_result = exc_bestguess
+    ipo_effects = me.result.ipo_effects = me.ipo_effects = adjust_effects(me)
+    me.result.exc_result = me.exc_bestguess = refine_exception_type(me.exc_bestguess, ipo_effects)
 
     if limited_ret
         # a parent may be cached still, but not this intermediate work:
@@ -862,12 +867,13 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         isinferred = is_inferred(frame)
         edge = isinferred ? mi : nothing
         effects = isinferred ? frame.result.ipo_effects : adjust_effects(Effects(), method) # effects are adjusted already within `finish` for ipo_effects
+        exc_bestguess = refine_exception_type(frame.exc_bestguess, effects)
         # propagate newly inferred source to the inliner, allowing efficient inlining w/o deserialization:
         # note that this result is cached globally exclusively, we can use this local result destructively
         volatile_inf_result = isinferred && let inferred_src = result.src
                 isa(inferred_src, CodeInfo) && (is_inlineable(inferred_src) || force_inline)
             end ? VolatileInferenceResult(result) : nothing
-        return EdgeCallResult(frame.bestguess, frame.exc_bestguess, edge, effects, volatile_inf_result)
+        return EdgeCallResult(frame.bestguess, exc_bestguess, edge, effects, volatile_inf_result)
     elseif frame === true
         # unresolvable cycle
         return EdgeCallResult(Any, Any, nothing, Effects())
@@ -875,7 +881,9 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
     # return the current knowledge about this cycle
     frame = frame::InferenceState
     update_valid_age!(caller, frame.valid_worlds)
-    return EdgeCallResult(frame.bestguess, frame.exc_bestguess, nothing, adjust_effects(Effects(), method))
+    effects = adjust_effects(Effects(), method)
+    exc_bestguess = refine_exception_type(frame.exc_bestguess, effects)
+    return EdgeCallResult(frame.bestguess, exc_bestguess, nothing, effects)
 end
 
 function cached_return_type(code::CodeInstance)
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index b75e5e5fe87f0..8cdee8baa90e6 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5558,3 +5558,32 @@ function foo_typed_throw_metherr()
     return 1
 end
 @test Base.return_types(foo_typed_throw_metherr) |> only === Float64
+
+# using `exct` information if `:nothrow` is proven
+Base.@assume_effects :nothrow function sin_nothrow(x::Float64)
+    x == Inf && return zero(x)
+    return sin(x)
+end
+@test Base.infer_exception_type(sin_nothrow, (Float64,)) == Union{}
+@test Base.return_types((Float64,)) do x
+    try
+        return sin_nothrow(x)
+    catch err
+        return err
+    end
+end |> only === Float64
+# for semi-concrete interpretation result too
+Base.@constprop :aggressive function sin_maythrow(x::Float64, maythrow::Bool)
+    if maythrow
+        return sin(x)
+    else
+        return @noinline sin_nothrow(x)
+    end
+end
+@test Base.return_types((Float64,)) do x
+    try
+        return sin_maythrow(x, false)
+    catch err
+        return err
+    end
+end |> only === Float64

From 527af6603f77f353e9d407ebc2b14d905486bf09 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 21 Nov 2023 20:55:13 +0900
Subject: [PATCH 0300/1315] inference: add reflection utility for exception
 type analysis (#52240)

This commit defines functions that mirror our tools for analyzing return
types and computational effects.

The key point to discuss is that this commit introduces two functions:
`Base.infer_exception_types` and `Base.infer_exception_type`.
`Base.infer_exception_types` acts like `Base.return_types`, giving a
list of exception types for each method that matches with the given call
signature. On the other hand, `Base.infer_exception_type` is akin to
`Base.infer_effects`, returning a single exception type that covers all
potential outcomes entailed by the given call signature. I personally
lean towards the latter for its utility, particularly in testing
scenarios, but I included `infer_exception_types` too for consistency
with `return_types`. I'd welcome any feedback on this approach.
---
 base/reflection.jl | 264 ++++++++++++++++++++++++++++++++++++++++-----
 test/reflection.jl |  27 +++++
 2 files changed, 263 insertions(+), 28 deletions(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index 304f7a4344fb2..145a7a9a376d5 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1692,15 +1692,45 @@ function code_ircode_by_type(
     return asts
 end
 
+function _builtin_return_type(interp::Core.Compiler.AbstractInterpreter,
+                              @nospecialize(f::Core.Builtin), @nospecialize(types))
+    argtypes = Any[to_tuple_type(types).parameters...]
+    rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
+    return Core.Compiler.widenconst(rt)
+end
+
+function _builtin_effects(interp::Core.Compiler.AbstractInterpreter,
+                          @nospecialize(f::Core.Builtin), @nospecialize(types))
+    argtypes = Any[to_tuple_type(types).parameters...]
+    rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
+    return Core.Compiler.builtin_effects(Core.Compiler.typeinf_lattice(interp), f, argtypes, rt)
+end
+
+check_generated_context(world::UInt) =
+    (ccall(:jl_is_in_pure_context, Bool, ()) || world == typemax(UInt)) &&
+        error("code reflection cannot be used from generated functions")
 
 """
-    Base.return_types(f::Function, types::DataType=default_tt(f);
-                      world::UInt=get_world_counter(), interp::NativeInterpreter=Core.Compiler.NativeInterpreter(world))
+    Base.return_types(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::NativeInterpreter=Core.Compiler.NativeInterpreter(world)) -> rts::Vector{Any}
 
 Return a list of possible return types for a given function `f` and argument types `types`.
 The list corresponds to the results of type inference on all the possible method match
 candidates for `f` and `types` (see also [`methods(f, types)`](@ref methods).
 
+# Arguments
+- `f`: The function to analyze.
+- `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
+- `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+
+# Returns
+- `rts::Vector{Any}`: The list of return types that are figured out by inference on
+  methods matching with the given `f` and `types`. The list's order matches the order
+  returned by `methods(f, types)`.
+
 # Example
 
 ```julia
@@ -1722,25 +1752,22 @@ julia> Base.return_types(sum, (Union{Vector{Int},UnitRange{Int}},))
 ```
 
 !!! warning
-    The `return_types` function should not be used from generated functions;
+    The `Base.return_types` function should not be used from generated functions;
     doing so will result in an error.
 """
 function return_types(@nospecialize(f), @nospecialize(types=default_tt(f));
                       world::UInt=get_world_counter(),
                       interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
-    (ccall(:jl_is_in_pure_context, Bool, ()) || world == typemax(UInt)) &&
-        error("code reflection cannot be used from generated functions")
+    check_generated_context(world)
     if isa(f, Core.OpaqueClosure)
         _, rt = only(code_typed_opaque_closure(f))
         return Any[rt]
     end
-
     if isa(f, Core.Builtin)
-        argtypes = Any[to_tuple_type(types).parameters...]
-        rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
-        return Any[Core.Compiler.widenconst(rt)]
+        rt = _builtin_return_type(interp, f, types)
+        return Any[rt]
     end
-    rts = []
+    rts = Any[]
     tt = signature_type(f, types)
     matches = _methods_by_ftype(tt, #=lim=#-1, world)::Vector
     for match in matches
@@ -1752,35 +1779,220 @@ function return_types(@nospecialize(f), @nospecialize(types=default_tt(f));
 end
 
 """
-    infer_effects(f, types=default_tt(f); world=get_world_counter(), interp=Core.Compiler.NativeInterpreter(world))
+    Base.infer_exception_types(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::NativeInterpreter=Core.Compiler.NativeInterpreter(world)) -> excts::Vector{Any}
 
-Compute the `Effects` of a function `f` with argument types `types`. The `Effects` represents the computational effects of the function call, such as whether it is free of side effects, guaranteed not to throw an exception, guaranteed to terminate, etc. The `world` and `interp` arguments specify the world counter and the native interpreter to use for the analysis.
+Return a list of possible exception types for a given function `f` and argument types `types`.
+The list corresponds to the results of type inference on all the possible method match
+candidates for `f` and `types` (see also [`methods(f, types)`](@ref methods).
+It works like [`Base.return_types`](@ref), but it infers the exception types instead of the return types.
 
 # Arguments
 - `f`: The function to analyze.
 - `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
 - `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
-- `interp` (optional): The native interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
 
 # Returns
-- `effects::Effects`: The computed effects of the function call.
+- `excts::Vector{Any}`: The list of exception types that are figured out by inference on
+  methods matching with the given `f` and `types`. The list's order matches the order
+  returned by `methods(f, types)`.
 
 # Example
 
 ```julia
-julia> function foo(x)
-           y = x * 2
-           return y
-       end;
+julia> throw_if_number(::Number) = error("number is given");
+
+julia> throw_if_number(::Any) = nothing;
+
+julia> Base.infer_exception_types(throw_if_number, (Int,))
+1-element Vector{Any}:
+ ErrorException
+
+julia> methods(throw_if_number, (Any,))
+# 2 methods for generic function "throw_if_number" from Main:
+ [1] throw_if_number(x::Number)
+     @ REPL[1]:1
+ [2] throw_if_number(::Any)
+     @ REPL[2]:1
+
+julia> Base.infer_exception_types(throw_if_number, (Any,))
+2-element Vector{Any}:
+ ErrorException # the result of inference on `throw_if_number(::Number)`
+ Union{}        # the result of inference on `throw_if_number(::Any)`
+```
+
+!!! warning
+    The `Base.infer_exception_types` function should not be used from generated functions;
+    doing so will result in an error.
+"""
+function infer_exception_types(@nospecialize(f), @nospecialize(types=default_tt(f));
+                               world::UInt=get_world_counter(),
+                               interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
+    check_generated_context(world)
+    if isa(f, Core.OpaqueClosure)
+        return Any[Any] # TODO
+    end
+    if isa(f, Core.Builtin)
+        effects = _builtin_effects(interp, f, types)
+        exct = Core.Compiler.is_nothrow(effects) ? Union{} : Any
+        return Any[exct]
+    end
+    excts = Any[]
+    tt = signature_type(f, types)
+    matches = _methods_by_ftype(tt, #=lim=#-1, world)::Vector
+    for match in matches
+        match = match::Core.MethodMatch
+        frame = Core.Compiler.typeinf_frame(interp, match, #=run_optimizer=#false)
+        if frame === nothing
+            exct = Any
+        else
+            exct = Core.Compiler.widenconst(frame.result.exc_result)
+        end
+        push!(excts, exct)
+    end
+    return excts
+end
+
+_may_throw_methoderror(matches#=::Core.Compiler.MethodLookupResult=#) =
+    matches.ambig || !any(match::Core.MethodMatch->match.fully_covers, matches.matches)
+
+"""
+    Base.infer_exception_type(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world)) -> exct::Type
+
+Returns the type of exception potentially thrown by the function call specified by `f` and `types`.
+
+# Arguments
+- `f`: The function to analyze.
+- `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
+- `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+
+# Returns
+- `exct::Type`: The inferred type of exception that can be thrown by the function call
+  specified by the given call signature.
 
-julia> effects = Base.infer_effects(foo, (Int,))
+!!! note
+    Note that, different from [`Base.infer_exception_types`](@ref), this doesn't give you the list
+    exception types for every possible matching method with the given `f` and `types`.
+    It provides a single exception type, taking into account all potential outcomes of
+    any function call entailed by the given signature type.
+
+# Example
+
+```julia
+julia> f1(x) = x * 2;
+
+julia> Base.infer_exception_type(f1, (Int,))
+Union{}
+```
+
+The exception inferred as `Union{}` indicates that `f1(::Int)` will not throw any exception.
+
+```julia
+julia> f2(x::Int) = x * 2;
+
+julia> Base.infer_exception_type(f2, (Integer,))
+MethodError
+```
+
+This case is pretty much the same as with `f1`, but there's a key difference to note. For
+`f2`, the argument type is limited to `Int`, while the argument type is given as `Tuple{Integer}`.
+Because of this, taking into account the chance of the method error entailed by the call
+signature, the exception type is widened to `MethodError`.
+
+!!! warning
+    The `Base.infer_exception_type` function should not be used from generated functions;
+    doing so will result in an error.
+"""
+function infer_exception_type(@nospecialize(f), @nospecialize(types=default_tt(f));
+                              world::UInt=get_world_counter(),
+                              interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
+    check_generated_context(world)
+    if isa(f, Core.OpaqueClosure)
+        return Any # TODO
+    end
+    if isa(f, Core.Builtin)
+        effects = _builtin_effects(interp, f, types)
+        return Core.Compiler.is_nothrow(effects) ? Union{} : Any
+    end
+    tt = signature_type(f, types)
+    matches = Core.Compiler.findall(tt, Core.Compiler.method_table(interp))
+    if matches === nothing
+        # unanalyzable call, i.e. the interpreter world might be newer than the world where
+        # the `f` is defined, return the unknown exception type
+        return Any
+    end
+    exct = Union{}
+    if _may_throw_methoderror(matches)
+        # account for the fact that we may encounter a MethodError with a non-covered or ambiguous signature.
+        exct = Core.Compiler.tmerge(exct, MethodError)
+    end
+    for match in matches.matches
+        match = match::Core.MethodMatch
+        frame = Core.Compiler.typeinf_frame(interp, match, #=run_optimizer=#false)
+        frame === nothing && return Any
+        exct = Core.Compiler.tmerge(exct, Core.Compiler.widenconst(frame.result.exc_result))
+    end
+    return exct
+end
+
+"""
+    Base.infer_effects(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world)) -> effects::Effects
+
+Returns the possible computation effects of the function call specified by `f` and `types`.
+
+# Arguments
+- `f`: The function to analyze.
+- `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
+- `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+
+# Returns
+- `effects::Effects`: The computed effects of the function call specified by the given call signature.
+  See the documentation of [`Effects`](@ref Core.Compiler.Effects) or [`Base.@assume_effects`](@ref)
+  for more information on the various effect properties.
+
+!!! note
+    Note that, different from [`Base.return_types`](@ref), this doesn't give you the list
+    effect analysis results for every possible matching method with the given `f` and `types`.
+    It provides a single effect, taking into account all potential outcomes of any function
+    call entailed by the given signature type.
+
+# Example
+
+```julia
+julia> f1(x) = x * 2;
+
+julia> Base.infer_effects(f1, (Int,))
 (+c,+e,+n,+t,+s,+m,+i)
 ```
 
-This function will return an `Effects` object with information about the computational effects of the function `foo` when called with an `Int` argument. See the documentation for `Effects` for more information on the various effect properties.
+This function will return an `Effects` object with information about the computational
+effects of the function `f1` when called with an `Int` argument.
+
+```julia
+julia> f2(x::Int) = x * 2;
+
+julia> Base.infer_effects(f2, (Integer,))
+(+c,+e,!n,+t,+s,+m,+i)
+```
+
+This case is pretty much the same as with `f1`, but there's a key difference to note. For
+`f2`, the argument type is limited to `Int`, while the argument type is given as `Tuple{Integer}`.
+Because of this, taking into account the chance of the method error entailed by the call
+signature, the `:nothrow` bit gets tainted.
 
 !!! warning
-    The `infer_effects` function should not be used from generated functions;
+    The `Base.infer_effects` function should not be used from generated functions;
     doing so will result in an error.
 
 # See Also
@@ -1790,13 +2002,9 @@ This function will return an `Effects` object with information about the computa
 function infer_effects(@nospecialize(f), @nospecialize(types=default_tt(f));
                        world::UInt=get_world_counter(),
                        interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
-    (ccall(:jl_is_in_pure_context, Bool, ()) || world == typemax(UInt)) &&
-        error("code reflection cannot be used from generated functions")
+    check_generated_context(world)
     if isa(f, Core.Builtin)
-        types = to_tuple_type(types)
-        argtypes = Any[types.parameters...]
-        rt = Core.Compiler.builtin_tfunction(interp, f, argtypes, nothing)
-        return Core.Compiler.builtin_effects(Core.Compiler.typeinf_lattice(interp), f, argtypes, rt)
+        return _builtin_effects(interp, f, types)
     end
     tt = signature_type(f, types)
     matches = Core.Compiler.findall(tt, Core.Compiler.method_table(interp))
@@ -1806,7 +2014,7 @@ function infer_effects(@nospecialize(f), @nospecialize(types=default_tt(f));
         return Core.Compiler.Effects()
     end
     effects = Core.Compiler.EFFECTS_TOTAL
-    if matches.ambig || !any(match::Core.MethodMatch->match.fully_covers, matches.matches)
+    if _may_throw_methoderror(matches)
         # account for the fact that we may encounter a MethodError with a non-covered or ambiguous signature.
         effects = Core.Compiler.Effects(effects; nothrow=false)
     end
diff --git a/test/reflection.jl b/test/reflection.jl
index 7df6a76dfd0ff..87f16deacdded 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1047,6 +1047,33 @@ ambig_effects_test(a, b) = 1
     @test (Base.infer_effects(Core.Intrinsics.mul_int, ()); true) # `intrinsic_effects` shouldn't throw on empty `argtypes`
 end
 
+@testset "infer_exception_type[s]" begin
+    # generic functions
+    @test Base.infer_exception_type(issue41694, (Int,)) == only(Base.infer_exception_types(issue41694, (Int,))) == ErrorException
+    @test Base.infer_exception_type((Int,)) do x
+        issue41694(x)
+    end == Base.infer_exception_types((Int,)) do x
+        issue41694(x)
+    end |> only == ErrorException
+    @test Base.infer_exception_type(issue41694) == only(Base.infer_exception_types(issue41694)) == ErrorException # use `default_tt`
+    let excts = Base.infer_exception_types(maybe_effectful, (Any,))
+        @test any(==(Any), excts)
+        @test any(==(Union{}), excts)
+    end
+    @test Base.infer_exception_type(maybe_effectful, (Any,)) == Any
+    # `infer_exception_type` should account for MethodError
+    @test Base.infer_exception_type(issue41694, (Float64,)) == MethodError # definitive dispatch error
+    @test Base.infer_exception_type(issue41694, (Integer,)) == Union{MethodError,ErrorException} # possible dispatch error
+    @test Base.infer_exception_type(f_no_methods) == MethodError # no possible matching methods
+    @test Base.infer_exception_type(ambig_effects_test, (Int,Int)) == MethodError # ambiguity error
+    @test Base.infer_exception_type(ambig_effects_test, (Int,Any)) == MethodError # ambiguity error
+    # builtins
+    @test Base.infer_exception_type(typeof, (Any,)) === only(Base.infer_exception_types(typeof, (Any,))) === Union{}
+    @test Base.infer_exception_type(===, (Any,Any)) === only(Base.infer_exception_types(===, (Any,Any))) === Union{}
+    @test (Base.infer_exception_type(setfield!, ()); Base.infer_exception_types(setfield!, ()); true) # `infer_exception_type[s]` shouldn't throw on empty `argtypes`
+    @test (Base.infer_exception_type(Core.Intrinsics.mul_int, ()); Base.infer_exception_types(Core.Intrinsics.mul_int, ()); true) # `infer_exception_type[s]` shouldn't throw on empty `argtypes`
+end
+
 @test Base._methods_by_ftype(Tuple{}, -1, Base.get_world_counter()) == Any[]
 @test length(methods(Base.Broadcast.broadcasted, Tuple{Any, Any, Vararg})) >
       length(methods(Base.Broadcast.broadcasted, Tuple{Base.Broadcast.BroadcastStyle, Any, Vararg})) >=

From a6c656e6c47ff2b1237c92e90ba73ac267fc1dc0 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Tue, 21 Nov 2023 18:06:36 -0300
Subject: [PATCH 0301/1315] Make have_fma consistent between interpreter and
 compiled (#52206)

Currently the interpreter always returns false. Which isn't very good.
Make it follow whatever the JIT will do.
---
 src/jl_exported_funcs.inc       |  1 +
 src/llvm-cpufeatures.cpp        |  4 ++--
 src/processor.h                 |  2 ++
 src/processor_arm.cpp           | 16 ++++++++++++++++
 src/processor_fallback.cpp      |  5 +++++
 src/processor_x86.cpp           | 11 +++++++++++
 src/runtime_intrinsics.c        | 11 ++++++++---
 test/llvmpasses/cpu-features.ll |  2 ++
 test/sysinfo.jl                 |  2 ++
 9 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 6ae91f5cc32d6..6c7af9bf2e245 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -200,6 +200,7 @@
     XX(jl_get_binding_wr) \
     XX(jl_get_cpu_name) \
     XX(jl_get_cpu_features) \
+    XX(jl_cpu_has_fma) \
     XX(jl_get_current_task) \
     XX(jl_get_default_sysimg_path) \
     XX(jl_get_excstack) \
diff --git a/src/llvm-cpufeatures.cpp b/src/llvm-cpufeatures.cpp
index 033a43720c96d..2539c5cd2e37c 100644
--- a/src/llvm-cpufeatures.cpp
+++ b/src/llvm-cpufeatures.cpp
@@ -59,7 +59,7 @@ static bool have_fma(Function &intr, Function &caller, const Triple &TT) JL_NOTS
     StringRef FS =
         FSAttr.isValid() ? FSAttr.getValueAsString() : jl_ExecutionEngine->getTargetFeatureString();
 
-    SmallVector<StringRef, 6> Features;
+    SmallVector<StringRef, 128> Features;
     FS.split(Features, ',');
     for (StringRef Feature : Features)
     if (TT.isARM()) {
@@ -67,7 +67,7 @@ static bool have_fma(Function &intr, Function &caller, const Triple &TT) JL_NOTS
         return typ == "f32" || typ == "f64";
       else if (Feature == "+vfp4sp")
         return typ == "f32";
-    } else {
+    } else if (TT.isX86()) {
       if (Feature == "+fma" || Feature == "+fma4")
         return typ == "f32" || typ == "f64";
     }
diff --git a/src/processor.h b/src/processor.h
index c22f8cff34a63..a4c8deb9a8796 100644
--- a/src/processor.h
+++ b/src/processor.h
@@ -226,6 +226,8 @@ JL_DLLEXPORT jl_value_t *jl_get_cpu_name(void);
 // Return the features of the host CPU as a julia string.
 JL_DLLEXPORT jl_value_t *jl_get_cpu_features(void);
 // Dump the name and feature set of the host CPU
+JL_DLLEXPORT jl_value_t *jl_cpu_has_fma(int bits);
+// Check if the CPU has native FMA instructions;
 // For debugging only
 JL_DLLEXPORT void jl_dump_host_cpu(void);
 JL_DLLEXPORT jl_value_t* jl_check_pkgimage_clones(char* data);
diff --git a/src/processor_arm.cpp b/src/processor_arm.cpp
index 1cb209dbbcd62..6a09e00cf23e7 100644
--- a/src/processor_arm.cpp
+++ b/src/processor_arm.cpp
@@ -1808,6 +1808,22 @@ JL_DLLEXPORT jl_value_t *jl_get_cpu_features(void)
     return jl_cstr_to_string(jl_get_cpu_features_llvm().c_str());
 }
 
+JL_DLLEXPORT jl_value_t *jl_cpu_has_fma(int bits)
+{
+#ifdef _CPU_AARCH64_
+    return jl_true;
+#else
+    TargetData<feature_sz> target = jit_targets.front();
+    FeatureList<feature_sz> features = target.en.features;
+    if (bits == 32 && test_nbit(features, Feature::vfp4sp))
+        return jl_true;
+    else if ((bits == 64 || bits == 32) && test_nbit(features, Feature::vfp4))
+        return jl_true;
+    else
+        return jl_false;
+#endif
+}
+
 jl_image_t jl_init_processor_sysimg(void *hdl)
 {
     if (!jit_targets.empty())
diff --git a/src/processor_fallback.cpp b/src/processor_fallback.cpp
index 8c343aa982470..399d31af05ebf 100644
--- a/src/processor_fallback.cpp
+++ b/src/processor_fallback.cpp
@@ -172,6 +172,11 @@ JL_DLLEXPORT jl_value_t *jl_get_cpu_features(void)
     return jl_cstr_to_string(jl_get_cpu_features_llvm().c_str());
 }
 
+JL_DLLEXPORT jl_value_t *jl_cpu_has_fma(int bits)
+{
+    return jl_false; // Match behaviour of have_fma in src/llvm-cpufeatures.cpp (assume false)
+}
+
 JL_DLLEXPORT void jl_dump_host_cpu(void)
 {
     jl_safe_printf("CPU: %s\n", host_cpu_name().c_str());
diff --git a/src/processor_x86.cpp b/src/processor_x86.cpp
index 361a8c6167541..3f8c62acaed11 100644
--- a/src/processor_x86.cpp
+++ b/src/processor_x86.cpp
@@ -4,6 +4,7 @@
 
 // CPUID
 
+#include "julia.h"
 extern "C" JL_DLLEXPORT void jl_cpuid(int32_t CPUInfo[4], int32_t InfoType)
 {
     asm volatile (
@@ -1062,6 +1063,16 @@ JL_DLLEXPORT jl_value_t *jl_get_cpu_features(void)
     return jl_cstr_to_string(jl_get_cpu_features_llvm().c_str());
 }
 
+JL_DLLEXPORT jl_value_t *jl_cpu_has_fma(int bits)
+{
+    TargetData<feature_sz> target = jit_targets.front();
+    FeatureList<feature_sz> features = target.en.features;
+    if ((bits == 32 || bits == 64) && (test_nbit(features, Feature::fma) || test_nbit(features, Feature::fma4)))
+        return jl_true;
+    else
+        return jl_false;
+}
+
 jl_image_t jl_init_processor_sysimg(void *hdl)
 {
     if (!jit_targets.empty())
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index 7b4ddcd6e8b29..4569c2081ae88 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -1671,10 +1671,15 @@ un_fintrinsic(trunc_float,trunc_llvm)
 un_fintrinsic(rint_float,rint_llvm)
 un_fintrinsic(sqrt_float,sqrt_llvm)
 un_fintrinsic(sqrt_float,sqrt_llvm_fast)
+jl_value_t *jl_cpu_has_fma(int bits);
 
 JL_DLLEXPORT jl_value_t *jl_have_fma(jl_value_t *typ)
 {
-    JL_TYPECHK(have_fma, datatype, typ);
-    // TODO: run-time feature check?
-    return jl_false;
+    JL_TYPECHK(have_fma, datatype, typ); // TODO what about float16/bfloat16?
+    if (typ == (jl_value_t*)jl_float32_type)
+        return jl_cpu_has_fma(32);
+    else if (typ == (jl_value_t*)jl_float64_type)
+        return jl_cpu_has_fma(64);
+    else
+        return jl_false;
 }
diff --git a/test/llvmpasses/cpu-features.ll b/test/llvmpasses/cpu-features.ll
index 5125743248fec..323f5e24015e9 100644
--- a/test/llvmpasses/cpu-features.ll
+++ b/test/llvmpasses/cpu-features.ll
@@ -3,6 +3,8 @@
 ; RUN: opt -enable-new-pm=1 --opaque-pointers=0 --load-pass-plugin=libjulia-codegen%shlibext -passes='CPUFeatures,simplifycfg' -S %s | FileCheck %s
 
 ; RUN: opt -enable-new-pm=1 --opaque-pointers=1 --load-pass-plugin=libjulia-codegen%shlibext -passes='CPUFeatures,simplifycfg' -S %s | FileCheck %s
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12:13"
+target triple = "x86_64-linux-gnu"
 
 declare i1 @julia.cpu.have_fma.f64()
 declare double @with_fma(double %0, double %1, double %2)
diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index e8194b113ba24..8864e3a48efc7 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -12,6 +12,8 @@ Base.Sys.loadavg()
 
 @test length(ccall(:jl_get_cpu_name, String, ())) != 0
 @test length(ccall(:jl_get_cpu_features, String, ())) >= 0
+foo_fma() = Core.Intrinsics.have_fma(Int64)
+@test ccall(:jl_cpu_has_fma, Bool, (Cint,), 64) == foo_fma()
 
 if Sys.isunix()
     mktempdir() do tempdir

From 49d3e852d06138e23bae6c4a451d36a1477e8900 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 22 Nov 2023 17:40:32 +0900
Subject: [PATCH 0302/1315] inference: update `exc_bestguess` when seeing
 unsafe `GotoIfNot` (#52267)

---
 base/compiler/abstractinterpretation.jl | 60 +++++++++++++------------
 test/compiler/inference.jl              |  5 +++
 2 files changed, 36 insertions(+), 29 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index d99243a56e969..bb6281024e6fe 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -3073,16 +3073,38 @@ function update_bestguess!(interp::AbstractInterpreter, frame::InferenceState,
     end
 end
 
-function propagate_to_error_handler!(frame::InferenceState, currpc::Int, W::BitSet, 𝕃ᵢ::AbstractLattice, currstate::VarTable)
+function update_exc_bestguess!(@nospecialize(exct), frame::InferenceState, 𝕃ₚ::AbstractLattice)
+    cur_hand = frame.handler_at[frame.currpc][1]
+    if cur_hand == 0
+        if !⊑(𝕃ₚ, exct, frame.exc_bestguess)
+            frame.exc_bestguess = tmerge(𝕃ₚ, frame.exc_bestguess, exct)
+            update_cycle_worklists!(frame) do caller::InferenceState, caller_pc::Int
+                caller_handler = caller.handler_at[caller_pc][1]
+                caller_exct = caller_handler == 0 ?
+                    caller.exc_bestguess : caller.handlers[caller_handler].exct
+                return caller_exct !== Any
+            end
+        end
+    else
+        handler_frame = frame.handlers[cur_hand]
+        if !⊑(𝕃ₚ, exct, handler_frame.exct)
+            handler_frame.exct = tmerge(𝕃ₚ, handler_frame.exct, exct)
+            enter = frame.src.code[handler_frame.enter_idx]::Expr
+            exceptbb = block_for_inst(frame.cfg, enter.args[1]::Int)
+            push!(frame.ip, exceptbb)
+        end
+    end
+end
+
+function propagate_to_error_handler!(currstate::VarTable, frame::InferenceState, 𝕃ᵢ::AbstractLattice)
     # If this statement potentially threw, propagate the currstate to the
     # exception handler, BEFORE applying any state changes.
-    cur_hand = frame.handler_at[currpc][1]
+    cur_hand = frame.handler_at[frame.currpc][1]
     if cur_hand != 0
         enter = frame.src.code[frame.handlers[cur_hand].enter_idx]::Expr
-        l = enter.args[1]::Int
-        exceptbb = block_for_inst(frame.cfg, l)
+        exceptbb = block_for_inst(frame.cfg, enter.args[1]::Int)
         if update_bbstate!(𝕃ᵢ, frame, exceptbb, currstate)
-            push!(W, exceptbb)
+            push!(frame.ip, exceptbb)
         end
     end
 end
@@ -3152,7 +3174,8 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                     if nothrow
                         add_curr_ssaflag!(frame, IR_FLAG_NOTHROW)
                     else
-                        propagate_to_error_handler!(frame, currpc, W, 𝕃ᵢ, currstate)
+                        update_exc_bestguess!(TypeError, frame, ipo_lattice(interp))
+                        propagate_to_error_handler!(currstate, frame, 𝕃ᵢ)
                         merge_effects!(interp, frame, EFFECTS_THROWS)
                     end
 
@@ -3233,31 +3256,10 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             (; changes, rt, exct) = abstract_eval_basic_statement(interp,
                 stmt, currstate, frame)
             if exct !== Union{}
-                𝕃ₚ = ipo_lattice(interp)
-                cur_hand = frame.handler_at[currpc][1]
-                if cur_hand == 0
-                    if !⊑(𝕃ₚ, exct, frame.exc_bestguess)
-                        frame.exc_bestguess = tmerge(𝕃ₚ, frame.exc_bestguess, exct)
-                        update_cycle_worklists!(frame) do caller::InferenceState, caller_pc::Int
-                            caller_handler = caller.handler_at[caller_pc][1]
-                            caller_exct = caller_handler == 0 ?
-                                caller.exc_bestguess : caller.handlers[caller_handler].exct
-                            return caller_exct !== Any
-                        end
-                    end
-                else
-                    handler_frame = frame.handlers[cur_hand]
-                    if !⊑(𝕃ₚ, exct, handler_frame.exct)
-                        handler_frame.exct = tmerge(𝕃ₚ, handler_frame.exct, exct)
-                        enter = frame.src.code[handler_frame.enter_idx]::Expr
-                        l = enter.args[1]::Int
-                        exceptbb = block_for_inst(frame.cfg, l)
-                        push!(W, exceptbb)
-                    end
-                end
+                update_exc_bestguess!(exct, frame, ipo_lattice(interp))
             end
             if (get_curr_ssaflag(frame) & IR_FLAG_NOTHROW) != IR_FLAG_NOTHROW
-                propagate_to_error_handler!(frame, currpc, W, 𝕃ᵢ, currstate)
+                propagate_to_error_handler!(currstate, frame, 𝕃ᵢ)
             end
             if rt === Bottom
                 ssavaluetypes[currpc] = Bottom
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 8cdee8baa90e6..9c9ee2ef0e9bd 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5587,3 +5587,8 @@ end
         return err
     end
 end |> only === Float64
+
+# exception type from GotoIfNot
+@test Base.infer_exception_type(c::Bool -> c ? 1 : 2) == Union{}
+@test Base.infer_exception_type(c::Missing -> c ? 1 : 2) == TypeError
+@test Base.infer_exception_type(c::Any -> c ? 1 : 2) == TypeError

From a0a2bda1d3e217732b9e076dfdbd37c1a0e04683 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 22 Nov 2023 18:00:29 +0900
Subject: [PATCH 0303/1315] inference: incorporate stackoverflow possibility
 into exc type modeling (#52268)

Currently `exc_bestguess` does not take into account the possibility of
stackoverflow error, causing the inconsistency between exception type
modeling and `:nothrow` modeling. This commit fixes it up.
---
 base/compiler/typeinfer.jl | 3 +++
 test/compiler/inference.jl | 5 +++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index de296089f43be..460f4be4db0f0 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -883,6 +883,9 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
     update_valid_age!(caller, frame.valid_worlds)
     effects = adjust_effects(Effects(), method)
     exc_bestguess = refine_exception_type(frame.exc_bestguess, effects)
+    # this call can fail into an infinite cycle, so incorporate this fact into
+    # `exc_bestguess` by merging `StackOverflowError` into it
+    exc_bestguess = tmerge(typeinf_lattice(interp), Core.StackOverflowError, exc_bestguess)
     return EdgeCallResult(frame.bestguess, exc_bestguess, nothing, effects)
 end
 
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 9c9ee2ef0e9bd..30a2763cb605b 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -423,12 +423,13 @@ A14009(a::T) where {T} = A14009{T}()
 f14009(a) = rand(Bool) ? f14009(A14009(a)) : a
 code_typed(f14009, (Int,))
 code_llvm(devnull, f14009, (Int,))
+@test Base.infer_exception_type(f14009, (Int,)) != Union{}
 
 mutable struct B14009{T}; end
 g14009(a) = g14009(B14009{a})
 code_typed(g14009, (Type{Int},))
-code_llvm(devnull, f14009, (Int,))
-
+code_llvm(devnull, g14009, (Type{Int},))
+@test Base.infer_exception_type(g14009, (Type{Int},)) == StackOverflowError
 
 # issue #9232
 arithtype9232(::Type{T},::Type{T}) where {T<:Real} = arithtype9232(T)

From 1b40e91ad516b3b12c569e7f8c5c40f0fff74d14 Mon Sep 17 00:00:00 2001
From: "Viral B. Shah" <ViralBShah@users.noreply.github.com>
Date: Wed, 22 Nov 2023 04:01:42 -0500
Subject: [PATCH 0304/1315] Fix #52216 (#52266)

---
 stdlib/InteractiveUtils/test/runtests.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index 5f90491fd8151..10dfbd1aca0ed 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -229,7 +229,7 @@ module Tmp14173
 end
 varinfo(Tmp14173) # warm up
 const MEMDEBUG = ccall(:jl_is_memdebug, Bool, ())
-@test @allocated(varinfo(Tmp14173)) < (MEMDEBUG ? 300000 : 100000)
+@test @allocated(varinfo(Tmp14173)) < (MEMDEBUG ? 300000 : 125000)
 
 # PR #24997: test that `varinfo` doesn't fail when encountering `missing`
 module A

From 8c9ac8dfbaa8d54923a5c4e6e340c7a308291639 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 22 Nov 2023 19:19:31 +0530
Subject: [PATCH 0305/1315] Declare `LinearAlgebra.AbstractTriangular` to be
 public (#52246)

Since methods such as `mul!`, `(l/r)mul!` and `(l/r)div!` are defined
for `AbstractTriangular`, having this be public allows easier
disambiguation in packages. [Several
packages](https://juliahub.com/ui/Search?q=AbstractTriangular&type=code)
are already using it as if it's public, so it makes sense to support
this.

This would resolve the specific issue in
https://discourse.julialang.org/t/methoderrors-suggest-fixes-that-may-depend-on-internal-bindings/106468
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 3 +++
 stdlib/LinearAlgebra/src/triangular.jl    | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index b372ef26a46d4..49f7f3226bc0a 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -161,6 +161,9 @@ export
 # Constants
     I
 
+# not exported, but public names
+public AbstractTriangular
+
 const BlasFloat = Union{Float64,Float32,ComplexF64,ComplexF32}
 const BlasReal = Union{Float64,Float32}
 const BlasComplex = Union{ComplexF64,ComplexF32}
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 798c748380cba..b92c0b110fff4 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -3,6 +3,12 @@
 ## Triangular
 
 # could be renamed to Triangular when that name has been fully deprecated
+"""
+    AbstractTriangular
+
+Supertype of triangular matrix types such as [`LowerTriangular`](@ref), [`UpperTriangular`](@ref),
+[`UnitLowerTriangular`](@ref) and [`UnitUpperTriangular`](@ref).
+"""
 abstract type AbstractTriangular{T} <: AbstractMatrix{T} end
 
 # First loop through all methods that don't need special care for upper/lower and unit diagonal

From 85e3da02bbf0f8fe40166c1bb06653821f7c9f3c Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Wed, 22 Nov 2023 11:26:21 -0300
Subject: [PATCH 0306/1315] add a compile-time option to enable 4k page sizes
 (#52229)

We're suffering from heavy fragmentation in some of our workloads.

Add a build-time option to enable 4k pages (instead of 16k) in the GC,
since that improves memory utilization considerably for us.

Drawback is that this may increase the number of `madvise` system calls
in the sweeping phase by a factor of 4, but concurrent page sweeping
should help with some of that.
---
 src/gc.h             | 24 ++++++++++++++++++++++-
 src/julia_internal.h | 45 ++++++++++++++++++++++++++++++++++++--------
 src/julia_threads.h  | 12 +++---------
 src/options.h        |  5 +++++
 4 files changed, 68 insertions(+), 18 deletions(-)

diff --git a/src/gc.h b/src/gc.h
index 227dc5b6b7a53..6dceee9053ede 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -33,8 +33,12 @@
 extern "C" {
 #endif
 
+#ifdef GC_SMALL_PAGE
+#define GC_PAGE_LG2 12 // log2(size of a page)
+#else
 #define GC_PAGE_LG2 14 // log2(size of a page)
-#define GC_PAGE_SZ (1 << GC_PAGE_LG2) // 16k
+#endif
+#define GC_PAGE_SZ (1 << GC_PAGE_LG2)
 #define GC_PAGE_OFFSET (JL_HEAP_ALIGNMENT - (sizeof(jl_taggedvalue_t) % JL_HEAP_ALIGNMENT))
 
 #define jl_malloc_tag ((void*)0xdeadaa01)
@@ -242,6 +246,23 @@ typedef struct {
     _Atomic(size_t) n_pages_allocd;
 } gc_fragmentation_stat_t;
 
+#ifdef GC_SMALL_PAGE
+#ifdef _P64
+#define REGION0_PG_COUNT (1 << 16)
+#define REGION1_PG_COUNT (1 << 18)
+#define REGION2_PG_COUNT (1 << 18)
+#define REGION0_INDEX(p) (((uintptr_t)(p) >> 12) & 0xFFFF) // shift by GC_PAGE_LG2
+#define REGION1_INDEX(p) (((uintptr_t)(p) >> 28) & 0x3FFFF)
+#define REGION_INDEX(p)  (((uintptr_t)(p) >> 46) & 0x3FFFF)
+#else
+#define REGION0_PG_COUNT (1 << 10)
+#define REGION1_PG_COUNT (1 << 10)
+#define REGION2_PG_COUNT (1 << 0)
+#define REGION0_INDEX(p) (((uintptr_t)(p) >> 12) & 0x3FF) // shift by GC_PAGE_LG2
+#define REGION1_INDEX(p) (((uintptr_t)(p) >> 22) & 0x3FF)
+#define REGION_INDEX(p)  (0)
+#endif
+#else
 #ifdef _P64
 #define REGION0_PG_COUNT (1 << 16)
 #define REGION1_PG_COUNT (1 << 16)
@@ -257,6 +278,7 @@ typedef struct {
 #define REGION1_INDEX(p) (((uintptr_t)(p) >> 22) & 0x3FF)
 #define REGION_INDEX(p)  (0)
 #endif
+#endif
 
 // define the representation of the levels of the page-table (0 to 2)
 typedef struct {
diff --git a/src/julia_internal.h b/src/julia_internal.h
index eeee548a9a4ee..45b1f893ef71a 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -373,24 +373,48 @@ static const int jl_gc_sizeclasses[] = {
     144, 160, 176, 192, 208, 224, 240, 256,
 
     // the following tables are computed for maximum packing efficiency via the formula:
-    // pg = 2^14
+    // pg = GC_SMALL_PAGE ? 2^12 : 2^14
     // sz = (div.(pg-8, rng).÷16)*16; hcat(sz, (pg-8).÷sz, pg .- (pg-8).÷sz.*sz)'
 
+#ifdef GC_SMALL_PAGE
+    // rng = 15:-1:2 (14 pools)
+    272, 288, 304, 336, 368, 400, 448, 496, 576, 672, 816, 1008, 1360, 2032
+//  15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, /pool
+//  16, 64, 144, 64, 48, 96, 64, 128, 64, 64, 16, 64, 16, 32, bytes lost
+#else
     // rng = 60:-4:32 (8 pools)
     272, 288, 304, 336, 368, 400, 448, 496,
-//   60,  56,  53,  48,  44,  40,  36,  33, /pool
-//   64, 256, 272, 256, 192, 384, 256,  16, bytes lost
+//  60, 56, 53, 48, 44, 40, 36, 33, /pool
+//  64, 256, 272, 256, 192, 384, 256,  16, bytes lost
 
     // rng = 30:-2:16 (8 pools)
     544, 576, 624, 672, 736, 816, 896, 1008,
-//   30,  28,  26,  24,  22,  20,  18,  16, /pool
-//   64, 256, 160, 256, 192,  64, 256, 256, bytes lost
+//  30, 28, 26, 24, 22, 20, 18, 16, /pool
+//  64, 256, 160, 256, 192,  64, 256, 256, bytes lost
 
     // rng = 15:-1:8 (8 pools)
     1088, 1168, 1248, 1360, 1488, 1632, 1808, 2032
-//    15,   14,   13,   12,   11,   10,    9,    8, /pool
-//    64,   32,  160,   64,   16,   64,  112,  128, bytes lost
+//   15, 14, 13, 12, 11, 10, 9, 8, /pool
+//   64, 32, 160, 64, 16, 64, 112,  128, bytes lost
+#endif
 };
+#ifdef GC_SMALL_PAGE
+#ifdef _P64
+#  define JL_GC_N_POOLS 39
+#elif MAX_ALIGN == 8
+#  define JL_GC_N_POOLS 40
+#else
+#  define JL_GC_N_POOLS 41
+#endif
+#else
+#ifdef _P64
+#  define JL_GC_N_POOLS 49
+#elif MAX_ALIGN == 8
+#  define JL_GC_N_POOLS 50
+#else
+#  define JL_GC_N_POOLS 51
+#endif
+#endif
 static_assert(sizeof(jl_gc_sizeclasses) / sizeof(jl_gc_sizeclasses[0]) == JL_GC_N_POOLS, "");
 
 STATIC_INLINE int jl_gc_alignment(size_t sz) JL_NOTSAFEPOINT
@@ -417,7 +441,12 @@ JL_DLLEXPORT int jl_alignment(size_t sz) JL_NOTSAFEPOINT;
 
 // the following table is computed as:
 // [searchsortedfirst(jl_gc_sizeclasses, i) - 1 for i = 0:16:jl_gc_sizeclasses[end]]
-static const uint8_t szclass_table[] = {0, 1, 3, 5, 7, 9, 11, 13, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 28, 29, 29, 30, 30, 31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34, 35, 35, 35, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 46, 46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48};
+static const uint8_t szclass_table[] =
+#ifdef GC_SMALL_PAGE
+    {0,1,3,5,7,9,11,13,15,17,18,19,20,21,22,23,24,25,26,27,28,28,29,29,30,30,31,31,31,32,32,32,33,33,33,33,33,34,34,34,34,34,34,35,35,35,35,35,35,35,35,35,36,36,36,36,36,36,36,36,36,36,36,36,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,37,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38};
+#else
+    {0,1,3,5,7,9,11,13,15,17,18,19,20,21,22,23,24,25,26,27,28,28,29,29,30,30,31,31,31,32,32,32,33,33,33,34,34,35,35,35,36,36,36,37,37,37,37,38,38,38,38,38,39,39,39,39,39,40,40,40,40,40,40,40,41,41,41,41,41,42,42,42,42,42,43,43,43,43,43,44,44,44,44,44,44,44,45,45,45,45,45,45,45,45,46,46,46,46,46,46,46,46,46,47,47,47,47,47,47,47,47,47,47,47,48,48,48,48,48,48,48,48,48,48,48,48,48,48};
+#endif
 static_assert(sizeof(szclass_table) == 128, "");
 
 STATIC_INLINE uint8_t JL_CONST_FUNC jl_gc_szclass(unsigned sz) JL_NOTSAFEPOINT
diff --git a/src/julia_threads.h b/src/julia_threads.h
index 220e31403b0d4..edda8f8adaa1c 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -4,8 +4,8 @@
 #ifndef JL_THREADS_H
 #define JL_THREADS_H
 
-#include "work-stealing-queue.h"
 #include "julia_atomics.h"
+#include "work-stealing-queue.h"
 #ifndef _OS_WINDOWS_
 #include "pthread.h"
 #endif
@@ -161,14 +161,8 @@ typedef struct {
     arraylist_t *last_remset;
 
     // variables for allocating objects from pools
-#ifdef _P64
-#  define JL_GC_N_POOLS 49
-#elif MAX_ALIGN == 8
-#  define JL_GC_N_POOLS 50
-#else
-#  define JL_GC_N_POOLS 51
-#endif
-    jl_gc_pool_t norm_pools[JL_GC_N_POOLS];
+#define JL_GC_N_MAX_POOLS 51 // conservative. must be kept in sync with `src/julia_internal.h`
+    jl_gc_pool_t norm_pools[JL_GC_N_MAX_POOLS];
 
 #define JL_N_STACK_POOLS 16
     small_arraylist_t free_stacks[JL_N_STACK_POOLS];
diff --git a/src/options.h b/src/options.h
index b535d5ad4566f..7f7ac360fdae2 100644
--- a/src/options.h
+++ b/src/options.h
@@ -78,6 +78,11 @@
 // OBJPROFILE counts objects by type
 // #define OBJPROFILE
 
+// pool allocator configuration options
+
+// GC_SMALL_PAGE allocates objects in 4k pages
+// #define GC_SMALL_PAGE
+
 
 // method dispatch profiling --------------------------------------------------
 

From 05f4b05384af9af364dcdf181db1a35020e07270 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Wed, 22 Nov 2023 11:23:07 -0500
Subject: [PATCH 0307/1315] fix Unicode.julia_chartransform for Julia 1.10
 (#52027)

#49559 by @JeffBezanson updated `src/flisp/julia_charmap.h` but missed
[the
comment](https://github.com/JuliaLang/julia/blob/164969f3d06919b073f3aa9ee608e40974ca82d9/src/flisp/julia_charmap.h#L5-L6)
noting that `base/strings/unicode.jl` has to be updated accordingly.
---
 base/strings/unicode.jl         | 1 +
 stdlib/Unicode/test/runtests.jl | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/base/strings/unicode.jl b/base/strings/unicode.jl
index 17c5d66c160b6..2e04633b87487 100644
--- a/base/strings/unicode.jl
+++ b/base/strings/unicode.jl
@@ -179,6 +179,7 @@ const _julia_charmap = Dict{UInt32,UInt32}(
     0x00B7 => 0x22C5,
     0x0387 => 0x22C5,
     0x2212 => 0x002D,
+    0x210F => 0x0127,
 )
 
 utf8proc_map(s::AbstractString, flags::Integer, chartransform=identity) = utf8proc_map(String(s), flags, chartransform)
diff --git a/stdlib/Unicode/test/runtests.jl b/stdlib/Unicode/test/runtests.jl
index 5c5a75b33e363..573d5da6167ba 100644
--- a/stdlib/Unicode/test/runtests.jl
+++ b/stdlib/Unicode/test/runtests.jl
@@ -27,8 +27,8 @@ using Unicode: normalize, isassigned, julia_chartransform
     @test normalize("\u0072\u0307\u0323", :NFC) == "\u1E5B\u0307" #26917
 
     # julia_chartransform identifier normalization
-    @test normalize("julia\u025B\u00B5\u00B7\u0387\u2212", chartransform=julia_chartransform) ==
-        "julia\u03B5\u03BC\u22C5\u22C5\u002D"
+    @test normalize("julia\u025B\u00B5\u00B7\u0387\u2212\u210F", chartransform=julia_chartransform) ==
+        "julia\u03B5\u03BC\u22C5\u22C5\u002D\u0127"
     @test julia_chartransform('\u00B5') === '\u03BC'
 end
 

From abfc2c6b57424e32a93a08f6121a8013c50504ee Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Wed, 22 Nov 2023 12:54:09 -0600
Subject: [PATCH 0308/1315] Add SubArray optimization to sorting (#52072)

---
 base/sort.jl    | 46 ++++++++++++++++++++++++++++++++++++++--------
 test/sorting.jl |  6 +++---
 2 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/base/sort.jl b/base/sort.jl
index 90b43c040d969..b57c00edb5454 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -528,6 +528,34 @@ internal or recursive calls.
 """
 function _sort! end
 
+# TODO: delete this optimization when views have no overhead.
+const UnwrappableSubArray = SubArray{T, 1, <:AbstractArray{T}, <:Tuple{AbstractUnitRange, Vararg{Number}}, true} where T
+"""
+    SubArrayOptimization(next) <: Algorithm
+
+Unwrap certain known SubArrays because views have a performance overhead 😢
+
+Specifically, unwraps some instances of the type
+
+    $UnwrappableSubArray
+"""
+struct SubArrayOptimization{T <: Algorithm} <: Algorithm
+    next::T
+end
+
+_sort!(v::AbstractVector, a::SubArrayOptimization, o::Ordering, kw) = _sort!(v, a.next, o, kw)
+function _sort!(v::UnwrappableSubArray, a::SubArrayOptimization, o::Ordering, kw)
+    @getkw lo hi
+    # @assert v.stride1 == 1
+    parent = v.parent
+    if parent isa Array && !(parent isa Vector) && hi - lo < 100
+        # vec(::Array{T, ≠1}) allocates and is therefore somewhat expensive.
+        # We don't want that for small inputs.
+        _sort!(v, a.next, o, kw)
+    else
+        _sort!(vec(parent), a.next, o, (;kw..., lo = lo + v.offset1, hi = hi + v.offset1))
+    end
+end
 
 """
     MissingOptimization(next) <: Algorithm
@@ -1223,14 +1251,16 @@ future versions of Julia.
 If `next` is stable, then `InitialOptimizations(next)` is also stable.
 
 The specific optimizations attempted by `InitialOptimizations` are
-[`MissingOptimization`](@ref), [`BoolOptimization`](@ref), dispatch to
-[`InsertionSort`](@ref) for inputs with `length <= 10`, and [`IEEEFloatOptimization`](@ref).
-"""
-InitialOptimizations(next) = MissingOptimization(
-    BoolOptimization(
-        Small{10}(
-            IEEEFloatOptimization(
-                next))))
+[`SubArrayOptimization`](@ref), [`MissingOptimization`](@ref), [`BoolOptimization`](@ref),
+dispatch to [`InsertionSort`](@ref) for inputs with `length <= 10`, and
+[`IEEEFloatOptimization`](@ref).
+"""
+InitialOptimizations(next) = SubArrayOptimization(
+    MissingOptimization(
+        BoolOptimization(
+            Small{10}(
+                IEEEFloatOptimization(
+                    next)))))
 """
     DEFAULT_STABLE
 
diff --git a/test/sorting.jl b/test/sorting.jl
index bb0fd3cc6392e..edc6ca17cfde0 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -791,9 +791,9 @@ end
     let
         requires_uint_mappable = Union{Base.Sort.RadixSort, Base.Sort.ConsiderRadixSort,
             Base.Sort.CountingSort, Base.Sort.ConsiderCountingSort,
-            typeof(Base.Sort.DEFAULT_STABLE.next.next.big.next.yes),
-            typeof(Base.Sort.DEFAULT_STABLE.next.next.big.next.yes.big),
-            typeof(Base.Sort.DEFAULT_STABLE.next.next.big.next.yes.big.next)}
+            typeof(Base.Sort.DEFAULT_STABLE.next.next.next.big.next.yes),
+            typeof(Base.Sort.DEFAULT_STABLE.next.next.next.big.next.yes.big),
+            typeof(Base.Sort.DEFAULT_STABLE.next.next.next.big.next.yes.big.next)}
 
         function test_alg(kw, alg, float=true)
             for order in [Base.Forward, Base.Reverse, Base.By(x -> x^2)]

From 418423b1af734ba7aba93e68ea7a908aff3047cd Mon Sep 17 00:00:00 2001
From: Christopher Burns <christopher.burns@gmail.com>
Date: Wed, 22 Nov 2023 14:46:49 -0800
Subject: [PATCH 0309/1315] optimize `allunique()` for sorted collections
 (#50372)

---
 base/set.jl  | 28 +++++++++++++++++++++++++++-
 test/sets.jl |  3 +++
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/base/set.jl b/base/set.jl
index 4708197588f3c..489673945ea1f 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -446,6 +446,8 @@ end
 
 Return `true` if all values from `itr` are distinct when compared with [`isequal`](@ref).
 
+`allunique` may use a specialized implementation when the input is sorted.
+
 See also: [`unique`](@ref), [`issorted`](@ref), [`allequal`](@ref).
 
 # Examples
@@ -494,7 +496,31 @@ allunique(::Union{AbstractSet,AbstractDict}) = true
 
 allunique(r::AbstractRange) = !iszero(step(r)) || length(r) <= 1
 
-allunique(A::StridedArray) = length(A) < 32 ? _indexed_allunique(A) : _hashed_allunique(A)
+function allunique(A::StridedArray)
+    if length(A) < 32
+        _indexed_allunique(A)
+    elseif OrderStyle(eltype(A)) === Ordered()
+        a1, rest1 = Iterators.peel(A)
+        a2, rest = Iterators.peel(rest1)
+        if !isequal(a1, a2)
+            compare = isless(a1, a2) ? isless : (a,b) -> isless(b,a)
+            for a in rest
+                if compare(a2, a)
+                    a2 = a
+                elseif isequal(a2, a)
+                    return false
+                else
+                    return _hashed_allunique(A)
+                end
+            end
+        else # isequal(a1, a2)
+            return false
+        end
+        return true
+    else
+        _hashed_allunique(A)
+    end
+end
 
 function _indexed_allunique(A)
     length(A) < 2 && return true
diff --git a/test/sets.jl b/test/sets.jl
index 7bce5aa57feae..19ccf3bf3701e 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -580,6 +580,9 @@ end
     @test !allunique([1,1,2])
     @test !allunique([:a,:b,:c,:a])
     @test allunique(unique(randn(100)))  # longer than 32
+    @test allunique(collect(1:100)) # sorted/unique && longer than 32
+    @test allunique(collect(100:-1:1)) # sorted/unique && longer than 32
+    @test !allunique(fill(1,100)) # sorted/repeating && longer than 32
     @test allunique(collect('A':'z')) # 58-element Vector{Char}
     @test !allunique(repeat(1:99, 1, 2))
     @test !allunique(vcat(pi, randn(1998), pi))  # longer than 1000

From 44b8983f38c3832ca8f4069169a2ccee828b9b55 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 23 Nov 2023 13:23:42 +0900
Subject: [PATCH 0310/1315] compiler: add flag manipulation utilities (#52269)

Right now, we're checking if a flag exists using bare operations like
`&` and `==`. This works fine, but I think unifying these interfaces
could make our code easier to maintain. So, this commit introduces some
new high-level operators and refactored the code to incorporate them:
- `has_flag(curr::UInt32, flag::UInt32)`
- `has_flag(inst::Instruction, flag::UInt32)`
- `add_flag!(inst::Instruction, flag::UInt32)`
- `sub_flag!(inst::Instruction, flag::UInt32)`
---
 base/compiler/abstractinterpretation.jl       |  6 +--
 base/compiler/inferencestate.jl               |  7 ++-
 base/compiler/optimize.jl                     | 44 ++++++++++---------
 .../ssair/EscapeAnalysis/EscapeAnalysis.jl    |  8 ++--
 base/compiler/ssair/inlining.jl               | 19 ++++----
 base/compiler/ssair/ir.jl                     | 30 ++++++++-----
 base/compiler/ssair/irinterp.jl               | 22 +++++-----
 base/compiler/ssair/passes.jl                 | 27 +++++++-----
 8 files changed, 91 insertions(+), 72 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index bb6281024e6fe..24d5eb52c1ffb 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2705,7 +2705,7 @@ end
 
 function stmt_taints_inbounds_consistency(sv::AbsIntState)
     propagate_inbounds(sv) && return true
-    return (get_curr_ssaflag(sv) & IR_FLAG_INBOUNDS) != 0
+    return has_curr_ssaflag(sv, IR_FLAG_INBOUNDS)
 end
 
 function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e), vtypes::VarTable, sv::InferenceState)
@@ -2718,7 +2718,7 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
     else
         (; rt, exct, effects) = abstract_eval_statement_expr(interp, e, vtypes, sv)
         if effects.noub === NOUB_IF_NOINBOUNDS
-            if !iszero(get_curr_ssaflag(sv) & IR_FLAG_INBOUNDS)
+            if has_curr_ssaflag(sv, IR_FLAG_INBOUNDS)
                 effects = Effects(effects; noub=ALWAYS_FALSE)
             elseif !propagate_inbounds(sv)
                 # The callee read our inbounds flag, but unless we propagate inbounds,
@@ -3258,7 +3258,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             if exct !== Union{}
                 update_exc_bestguess!(exct, frame, ipo_lattice(interp))
             end
-            if (get_curr_ssaflag(frame) & IR_FLAG_NOTHROW) != IR_FLAG_NOTHROW
+            if !has_curr_ssaflag(frame, IR_FLAG_NOTHROW)
                 propagate_to_error_handler!(currstate, frame, 𝕃ᵢ)
             end
             if rt === Bottom
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 772dbe72d4dc1..7085b87db9beb 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -888,6 +888,9 @@ end
 get_curr_ssaflag(sv::InferenceState) = sv.src.ssaflags[sv.currpc]
 get_curr_ssaflag(sv::IRInterpretationState) = sv.ir.stmts[sv.curridx][:flag]
 
+has_curr_ssaflag(sv::InferenceState, flag::UInt32) = has_flag(sv.src.ssaflags[sv.currpc], flag)
+has_curr_ssaflag(sv::IRInterpretationState, flag::UInt32) = has_flag(sv.ir.stmts[sv.curridx][:flag], flag)
+
 function set_curr_ssaflag!(sv::InferenceState, flag::UInt32, mask::UInt32=typemax(UInt32))
     curr_flag = sv.src.ssaflags[sv.currpc]
     sv.src.ssaflags[sv.currpc] = (curr_flag & ~mask) | flag
@@ -898,10 +901,10 @@ function set_curr_ssaflag!(sv::IRInterpretationState, flag::UInt32, mask::UInt32
 end
 
 add_curr_ssaflag!(sv::InferenceState, flag::UInt32) = sv.src.ssaflags[sv.currpc] |= flag
-add_curr_ssaflag!(sv::IRInterpretationState, flag::UInt32) = sv.ir.stmts[sv.curridx][:flag] |= flag
+add_curr_ssaflag!(sv::IRInterpretationState, flag::UInt32) = add_flag!(sv.ir.stmts[sv.curridx], flag)
 
 sub_curr_ssaflag!(sv::InferenceState, flag::UInt32) = sv.src.ssaflags[sv.currpc] &= ~flag
-sub_curr_ssaflag!(sv::IRInterpretationState, flag::UInt32) = sv.ir.stmts[sv.curridx][:flag] &= ~flag
+sub_curr_ssaflag!(sv::IRInterpretationState, flag::UInt32) = sub_flag!(sv.ir.stmts[sv.curridx], flag)
 
 function merge_effects!(::AbstractInterpreter, caller::InferenceState, effects::Effects)
     if effects.effect_free === EFFECT_FREE_GLOBALLY
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 43bdebed32b03..b0a4dfd1ced8d 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -15,36 +15,38 @@ const SLOT_USEDUNDEF    = 32 # slot has uses that might raise UndefVarError
 
 # NOTE make sure to sync the flag definitions below with julia.h and `jl_code_info_set_ir` in method.c
 
-const IR_FLAG_NULL        = UInt32(0)
+const IR_FLAG_NULL        = zero(UInt32)
 # This statement is marked as @inbounds by user.
 # Ff replaced by inlining, any contained boundschecks may be removed.
-const IR_FLAG_INBOUNDS    = UInt32(1) << 0
+const IR_FLAG_INBOUNDS    = one(UInt32) << 0
 # This statement is marked as @inline by user
-const IR_FLAG_INLINE      = UInt32(1) << 1
+const IR_FLAG_INLINE      = one(UInt32) << 1
 # This statement is marked as @noinline by user
-const IR_FLAG_NOINLINE    = UInt32(1) << 2
-const IR_FLAG_THROW_BLOCK = UInt32(1) << 3
+const IR_FLAG_NOINLINE    = one(UInt32) << 2
+const IR_FLAG_THROW_BLOCK = one(UInt32) << 3
 # This statement was proven :effect_free
-const IR_FLAG_EFFECT_FREE = UInt32(1) << 4
+const IR_FLAG_EFFECT_FREE = one(UInt32) << 4
 # This statement was proven not to throw
-const IR_FLAG_NOTHROW     = UInt32(1) << 5
+const IR_FLAG_NOTHROW     = one(UInt32) << 5
 # This is :consistent
-const IR_FLAG_CONSISTENT  = UInt32(1) << 6
+const IR_FLAG_CONSISTENT  = one(UInt32) << 6
 # An optimization pass has updated this statement in a way that may
 # have exposed information that inference did not see. Re-running
 # inference on this statement may be profitable.
-const IR_FLAG_REFINED     = UInt32(1) << 7
+const IR_FLAG_REFINED     = one(UInt32) << 7
 # This is :noub == ALWAYS_TRUE
-const IR_FLAG_NOUB        = UInt32(1) << 8
+const IR_FLAG_NOUB        = one(UInt32) << 8
 
 # TODO: Both of these should eventually go away once
 # This is :effect_free == EFFECT_FREE_IF_INACCESSIBLEMEMONLY
-const IR_FLAG_EFIIMO      = UInt32(1) << 9
+const IR_FLAG_EFIIMO      = one(UInt32) << 9
 # This is :inaccessiblememonly == INACCESSIBLEMEM_OR_ARGMEMONLY
-const IR_FLAG_INACCESSIBLE_OR_ARGMEM = UInt32(1) << 10
+const IR_FLAG_INACCESSIBLE_OR_ARGMEM = one(UInt32) << 10
 
 const IR_FLAGS_EFFECTS = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW | IR_FLAG_CONSISTENT | IR_FLAG_NOUB
 
+has_flag(curr::UInt32, flag::UInt32) = (curr & flag) == flag
+
 const TOP_TUPLE = GlobalRef(Core, :tuple)
 
 # This corresponds to the type of `CodeInfo`'s `inlining_cost` field
@@ -218,9 +220,9 @@ end
 
 _topmod(sv::OptimizationState) = _topmod(sv.mod)
 
-is_stmt_inline(stmt_flag::UInt32)      = stmt_flag & IR_FLAG_INLINE      ≠ 0
-is_stmt_noinline(stmt_flag::UInt32)    = stmt_flag & IR_FLAG_NOINLINE    ≠ 0
-is_stmt_throw_block(stmt_flag::UInt32) = stmt_flag & IR_FLAG_THROW_BLOCK ≠ 0
+is_stmt_inline(stmt_flag::UInt32)      = has_flag(stmt_flag, IR_FLAG_INLINE)
+is_stmt_noinline(stmt_flag::UInt32)    = has_flag(stmt_flag, IR_FLAG_NOINLINE)
+is_stmt_throw_block(stmt_flag::UInt32) = has_flag(stmt_flag, IR_FLAG_THROW_BLOCK)
 
 function new_expr_effect_flags(𝕃ₒ::AbstractLattice, args::Vector{Any}, src::Union{IRCode,IncrementalCompact}, pattern_match=nothing)
     Targ = args[1]
@@ -468,7 +470,7 @@ end
 
 function any_stmt_may_throw(ir::IRCode, bb::Int)
     for stmt in ir.cfg.blocks[bb].stmts
-        if (ir[SSAValue(stmt)][:flag] & IR_FLAG_NOTHROW) != 0
+        if has_flag(ir[SSAValue(stmt)], IR_FLAG_NOTHROW)
             return true
         end
     end
@@ -702,7 +704,7 @@ function scan_non_dataflow_flags!(inst::Instruction, sv::PostOptAnalysisState)
             # ignore control flow node – they are not removable on their own and thus not
             # have `IR_FLAG_EFFECT_FREE` but still do not taint `:effect_free`-ness of
             # the whole method invocation
-            sv.all_effect_free &= !iszero(flag & IR_FLAG_EFFECT_FREE)
+            sv.all_effect_free &= has_flag(flag, IR_FLAG_EFFECT_FREE)
         end
     elseif sv.all_effect_free
         if (isexpr(stmt, :invoke) || isexpr(stmt, :new) ||
@@ -714,8 +716,8 @@ function scan_non_dataflow_flags!(inst::Instruction, sv::PostOptAnalysisState)
             sv.all_effect_free = false
         end
     end
-    sv.all_nothrow &= !iszero(flag & IR_FLAG_NOTHROW)
-    if iszero(flag & IR_FLAG_NOUB)
+    sv.all_nothrow &= has_flag(flag, IR_FLAG_NOTHROW)
+    if !has_flag(flag, IR_FLAG_NOUB)
         # Special case: `:boundscheck` into `getfield` or memory operations is `:noub_if_noinbounds`
         if is_conditional_noub(inst, sv)
             sv.any_conditional_ub = true
@@ -960,11 +962,11 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                     ((block + 1) != destblock) && cfg_delete_edge!(sv.cfg, block, destblock)
                     expr = Expr(:call, Core.typeassert, expr.cond, Bool)
                 elseif i + 1 in sv.unreachable
-                    @assert (ci.ssaflags[i] & IR_FLAG_NOTHROW) != 0
+                    @assert has_flag(ci.ssaflags[i], IR_FLAG_NOTHROW)
                     cfg_delete_edge!(sv.cfg, block, block + 1)
                     expr = GotoNode(expr.dest)
                 elseif expr.dest in sv.unreachable
-                    @assert (ci.ssaflags[i] & IR_FLAG_NOTHROW) != 0
+                    @assert has_flag(ci.ssaflags[i], IR_FLAG_NOTHROW)
                     cfg_delete_edge!(sv.cfg, block, block_for_inst(sv.cfg, expr.dest))
                     expr = nothing
                 end
diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index 820975d405525..c05f3f53837a7 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -25,9 +25,9 @@ using ._TOP_MOD:     # Base definitions
     unwrap_unionall, !, !=, !==, &, *, +, -, :, <, <<, =>, >, |, ∈, ∉, ∩, ∪, ≠, ≤, ≥, ⊆
 using Core.Compiler: # Core.Compiler specific definitions
     Bottom, IRCode, IR_FLAG_NOTHROW, InferenceResult, SimpleInferenceLattice,
-    argextype, check_effect_free!, fieldcount_noerror, hasintersect, intrinsic_nothrow,
-    is_meta_expr_head, isbitstype, isexpr, println, setfield!_nothrow, singleton_type,
-    try_compute_field, try_compute_fieldidx, widenconst, ⊑, AbstractLattice
+    argextype, check_effect_free!, fieldcount_noerror, hasintersect, has_flag,
+    intrinsic_nothrow, is_meta_expr_head, isbitstype, isexpr, println, setfield!_nothrow,
+    singleton_type, try_compute_field, try_compute_fieldidx, widenconst, ⊑, AbstractLattice
 
 include(x) = _TOP_MOD.include(@__MODULE__, x)
 if _TOP_MOD === Core.Compiler
@@ -975,7 +975,7 @@ end
     error("unexpected assignment found: inspect `Main.pc` and `Main.pc`")
 end
 
-is_nothrow(ir::IRCode, pc::Int) = ir[SSAValue(pc)][:flag] & IR_FLAG_NOTHROW ≠ 0
+is_nothrow(ir::IRCode, pc::Int) = has_flag(ir[SSAValue(pc)], IR_FLAG_NOTHROW)
 
 # NOTE if we don't maintain the alias set that is separated from the lattice state, we can do
 # something like below: it essentially incorporates forward escape propagation in our default
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index f62e773567ac3..2e250bade533c 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -399,7 +399,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
 
     ssa_substitute = ir_prepare_inlining!(InsertHere(compact), compact, item.ir, item.mi, inlined_at, argexprs)
 
-    boundscheck = iszero(compact.result[idx][:flag] & IR_FLAG_INBOUNDS) ? boundscheck : :off
+    boundscheck = has_flag(compact.result[idx], IR_FLAG_INBOUNDS) ? :off : boundscheck
 
     # If the iterator already moved on to the next basic block,
     # temporarily re-open in again.
@@ -1032,7 +1032,7 @@ function handle_single_case!(todo::Vector{Pair{Int,Any}},
             stmt.head = :invoke
             pushfirst!(stmt.args, case.invoke)
         end
-        ir[SSAValue(idx)][:flag] |= flags_for_effects(case.effects)
+        add_flag!(ir[SSAValue(idx)], flags_for_effects(case.effects))
     elseif case === nothing
         # Do, well, nothing
     else
@@ -1257,13 +1257,14 @@ function check_effect_free!(ir::IRCode, idx::Int, @nospecialize(stmt), @nospecia
 end
 function check_effect_free!(ir::IRCode, idx::Int, @nospecialize(stmt), @nospecialize(rt), 𝕃ₒ::AbstractLattice)
     (consistent, effect_free_and_nothrow, nothrow) = stmt_effect_flags(𝕃ₒ, stmt, rt, ir)
+    inst = ir.stmts[idx]
     if consistent
-        ir.stmts[idx][:flag] |= IR_FLAG_CONSISTENT
+        add_flag!(inst, IR_FLAG_CONSISTENT)
     end
     if effect_free_and_nothrow
-        ir.stmts[idx][:flag] |= IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+        add_flag!(inst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
     elseif nothrow
-        ir.stmts[idx][:flag] |= IR_FLAG_NOTHROW
+        add_flag!(inst, IR_FLAG_NOTHROW)
     end
     if !(isexpr(stmt, :call) || isexpr(stmt, :invoke))
         # There is a bit of a subtle point here, which is that some non-call
@@ -1271,7 +1272,7 @@ function check_effect_free!(ir::IRCode, idx::Int, @nospecialize(stmt), @nospecia
         # illegal to introduce such statements that actually cause UB (for any
         # input). Ideally that'd be handled at insertion time (TODO), but for
         # the time being just do that here.
-        ir.stmts[idx][:flag] |= IR_FLAG_NOUB
+        add_flag!(inst, IR_FLAG_NOUB)
     end
     return effect_free_and_nothrow
 end
@@ -1583,7 +1584,7 @@ function handle_cases!(todo::Vector{Pair{Int,Any}}, ir::IRCode, idx::Int, stmt::
         end
         push!(todo, idx=>UnionSplit(fully_covered, atype, cases))
     else
-        ir[SSAValue(idx)][:flag] |= flags_for_effects(joint_effects)
+        add_flag!(ir[SSAValue(idx)], flags_for_effects(joint_effects))
     end
     return nothing
 end
@@ -1682,7 +1683,7 @@ function inline_const_if_inlineable!(inst::Instruction)
         inst[:stmt] = quoted(rt.val)
         return true
     end
-    inst[:flag] |= IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+    add_flag!(inst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
     return false
 end
 
@@ -1879,7 +1880,7 @@ function ssa_substitute_op!(insert_node!::Inserter, subst_inst::Instruction, @no
                 return quoted(val)
             else
                 flag = subst_inst[:flag]
-                maybe_undef = (flag & IR_FLAG_NOTHROW) == 0 && isa(val, TypeVar)
+                maybe_undef = !has_flag(flag, IR_FLAG_NOTHROW) && isa(val, TypeVar)
                 (ret, tcheck_not) = insert_spval!(insert_node!, ssa_substitute.spvals_ssa::SSAValue, spidx, maybe_undef)
                 if maybe_undef
                     insert_node!(
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index e4ded5bd282da..5c347846e6e18 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -283,6 +283,10 @@ function setindex!(node::Instruction, newval::Instruction)
     return node
 end
 
+has_flag(inst::Instruction, flag::UInt32) = has_flag(inst[:flag], flag)
+add_flag!(inst::Instruction, flag::UInt32) = inst[:flag] |= flag
+sub_flag!(inst::Instruction, flag::UInt32) = inst[:flag] &= ~flag
+
 struct NewNodeInfo
     # Insertion position (interpretation depends on which array this is in)
     pos::Int
@@ -334,18 +338,24 @@ function NewInstruction(inst::Instruction;
     return NewInstruction(stmt, type, info, line, flag)
 end
 @specialize
-effect_free_and_nothrow(newinst::NewInstruction) = NewInstruction(newinst; flag=add_flag(newinst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW))
-with_flags(newinst::NewInstruction, flags::UInt32) = NewInstruction(newinst; flag=add_flag(newinst, flags))
-without_flags(newinst::NewInstruction, flags::UInt32) = NewInstruction(newinst; flag=sub_flag(newinst, flags))
+effect_free_and_nothrow(newinst::NewInstruction) = add_flag(newinst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
 function add_flag(newinst::NewInstruction, newflag::UInt32)
     flag = newinst.flag
-    flag === nothing && return newflag
-    return flag | newflag
+    if flag === nothing
+        flag = newflag
+    else
+        flag |= newflag
+    end
+    return NewInstruction(newinst; flag)
 end
 function sub_flag(newinst::NewInstruction, newflag::UInt32)
     flag = newinst.flag
-    flag === nothing && return IR_FLAG_NULL
-    return flag & ~newflag
+    if flag === nothing
+        flag = IR_FLAG_NULL
+    else
+        flag &= ~newflag
+    end
+    return NewInstruction(newinst; flag)
 end
 
 struct IRCode
@@ -1325,7 +1335,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
     elseif isa(stmt, GlobalRef)
         total_flags = IR_FLAG_CONSISTENT | IR_FLAG_EFFECT_FREE
         flag = result[result_idx][:flag]
-        if (flag & total_flags) == total_flags
+        if has_flag(flag, total_flags)
             ssa_rename[idx] = stmt
         else
             ssa_rename[idx] = SSAValue(result_idx)
@@ -1532,7 +1542,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
         else
             # Constant assign, replace uses of this ssa value with its result
         end
-        if (inst[:flag] & IR_FLAG_REFINED) != 0 && !isa(stmt, Refined)
+        if has_flag(inst, IR_FLAG_REFINED) && !isa(stmt, Refined)
             # If we're compacting away an instruction that was marked as refined,
             # leave a marker in the ssa_rename, so we can taint any users.
             stmt = Refined(stmt)
@@ -1767,7 +1777,7 @@ function maybe_erase_unused!(callback::Function, compact::IncrementalCompact, id
     stmt = inst[:stmt]
     stmt === nothing && return false
     inst[:type] === Bottom && return false
-    effect_free = (inst[:flag] & (IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)) == IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+    effect_free = has_flag(inst, (IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW))
     effect_free || return false
     foreachssa(stmt) do val::SSAValue
         if compact.used_ssas[val.id] == 1
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index b1c3fddc3df6e..9f8bc17beca7f 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -138,7 +138,7 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
             if bb === nothing
                 bb = block_for_inst(ir, idx)
             end
-            inst[:flag] |= IR_FLAG_NOTHROW
+            add_flag!(inst, IR_FLAG_NOTHROW)
             if condval
                 inst[:stmt] = nothing
                 inst[:type] = Any
@@ -156,14 +156,14 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
         head = stmt.head
         if head === :call || head === :foreigncall || head === :new || head === :splatnew || head === :static_parameter || head === :isdefined || head === :boundscheck
             (; rt, effects) = abstract_eval_statement_expr(interp, stmt, nothing, irsv)
-            inst[:flag] |= flags_for_effects(effects)
+            add_flag!(inst, flags_for_effects(effects))
         elseif head === :invoke
             rt, (nothrow, noub) = concrete_eval_invoke(interp, stmt, stmt.args[1]::MethodInstance, irsv)
             if nothrow
-                inst[:flag] |= IR_FLAG_NOTHROW
+                add_flag!(inst, IR_FLAG_NOTHROW)
             end
             if noub
-                inst[:flag] |= IR_FLAG_NOUB
+                add_flag!(inst, IR_FLAG_NOUB)
             end
         elseif head === :throw_undef_if_not
             condval = maybe_extract_const_bool(argextype(stmt.args[2], ir))
@@ -197,7 +197,7 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
     if rt !== nothing
         if isa(rt, Const)
             inst[:type] = rt
-            if is_inlineable_constant(rt.val) && (inst[:flag] & (IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)) == IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+            if is_inlineable_constant(rt.val) && has_flag(inst, (IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW))
                 inst[:stmt] = quoted(rt.val)
             end
             return true
@@ -299,9 +299,9 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
         typ = inst[:type]
         flag = inst[:flag]
         any_refined = false
-        if (flag & IR_FLAG_REFINED) != 0
+        if has_flag(flag, IR_FLAG_REFINED)
             any_refined = true
-            inst[:flag] &= ~IR_FLAG_REFINED
+            sub_flag!(inst, IR_FLAG_REFINED)
         end
         for ur in userefs(stmt)
             val = ur[]
@@ -351,8 +351,8 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
             irsv.curridx = idx
             stmt = inst[:stmt]
             flag = inst[:flag]
-            if (flag & IR_FLAG_REFINED) != 0
-                inst[:flag] &= ~IR_FLAG_REFINED
+            if has_flag(flag, IR_FLAG_REFINED)
+                sub_flag!(inst, IR_FLAG_REFINED)
                 push!(stmt_ip, idx)
             end
             check_ret!(stmt, idx)
@@ -408,8 +408,8 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
     nothrow = noub = true
     for idx = 1:length(ir.stmts)
         flag = ir[SSAValue(idx)][:flag]
-        nothrow &= !iszero(flag & IR_FLAG_NOTHROW)
-        noub &= !iszero(flag & IR_FLAG_NOUB)
+        nothrow &= has_flag(flag, IR_FLAG_NOTHROW)
+        noub &= has_flag(flag, IR_FLAG_NOUB)
         (nothrow | noub) || break
     end
 
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 6db47ed537e0e..9c6ed30dbbce8 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -934,17 +934,17 @@ end
 
 function refine_new_effects!(𝕃ₒ::AbstractLattice, compact::IncrementalCompact, idx::Int, stmt::Expr)
     inst = compact[SSAValue(idx)]
-    if (inst[:flag] & (IR_FLAG_NOTHROW | IR_FLAG_EFFECT_FREE)) == (IR_FLAG_NOTHROW | IR_FLAG_EFFECT_FREE)
+    if has_flag(inst, (IR_FLAG_NOTHROW | IR_FLAG_EFFECT_FREE))
         return # already accurate
     end
     (consistent, effect_free_and_nothrow, nothrow) = new_expr_effect_flags(𝕃ₒ, stmt.args, compact, pattern_match_typeof)
     if consistent
-        inst[:flag] |= IR_FLAG_CONSISTENT
+        add_flag!(inst, IR_FLAG_CONSISTENT)
     end
     if effect_free_and_nothrow
-        inst[:flag] |= IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+        add_flag!(inst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
     elseif nothrow
-        inst[:flag] |= IR_FLAG_NOTHROW
+        add_flag!(inst, IR_FLAG_NOTHROW)
     end
     return nothing
 end
@@ -1195,7 +1195,7 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
         compact[idx] = lifted_val === nothing ? nothing : lifted_val.val
         if lifted_val !== nothing
             if !⊑(𝕃ₒ, compact[SSAValue(idx)][:type], result_t)
-                compact[SSAValue(idx)][:flag] |= IR_FLAG_REFINED
+                add_flag!(compact[SSAValue(idx)], IR_FLAG_REFINED)
             end
         end
     end
@@ -1270,7 +1270,7 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
     return true
 end
 
-is_nothrow(ir::IRCode, ssa::SSAValue) = (ir[ssa][:flag] & IR_FLAG_NOTHROW) ≠ 0
+is_nothrow(ir::IRCode, ssa::SSAValue) = has_flag(ir[ssa], IR_FLAG_NOTHROW)
 
 function reachable_blocks(cfg::CFG, from_bb::Int, to_bb::Union{Nothing,Int} = nothing)
     worklist = Int[from_bb]
@@ -1386,7 +1386,7 @@ function try_resolve_finalizer!(ir::IRCode, idx::Int, finalizer_idx::Int, defuse
 
     finalizer_stmt = ir[SSAValue(finalizer_idx)][:stmt]
     argexprs = Any[finalizer_stmt.args[2], finalizer_stmt.args[3]]
-    flags = info isa FinalizerInfo ? flags_for_effects(info.effects) : IR_FLAG_NULL
+    flag = info isa FinalizerInfo ? flags_for_effects(info.effects) : IR_FLAG_NULL
     if length(finalizer_stmt.args) >= 4
         inline = finalizer_stmt.args[4]
         if inline === nothing
@@ -1396,11 +1396,13 @@ function try_resolve_finalizer!(ir::IRCode, idx::Int, finalizer_idx::Int, defuse
             if inline::Bool && try_inline_finalizer!(ir, argexprs, loc, mi, info, inlining, attach_after)
                 # the finalizer body has been inlined
             else
-                insert_node!(ir, loc, with_flags(NewInstruction(Expr(:invoke, mi, argexprs...), Nothing), flags), attach_after)
+                newinst = add_flag(NewInstruction(Expr(:invoke, mi, argexprs...), Nothing), flag)
+                insert_node!(ir, loc, newinst, attach_after)
             end
         end
     else
-        insert_node!(ir, loc, with_flags(NewInstruction(Expr(:call, argexprs...), Nothing), flags), attach_after)
+        newinst = add_flag(NewInstruction(Expr(:call, argexprs...), Nothing), flag)
+        insert_node!(ir, loc, newinst, attach_after)
     end
     # Erase the call to `finalizer`
     ir[SSAValue(finalizer_idx)][:stmt] = nothing
@@ -1542,9 +1544,10 @@ function sroa_mutables!(ir::IRCode, defuses::IdDict{Int, Tuple{SPCSet, SSADefUse
                 # Now go through all uses and rewrite them
                 for use in du.uses
                     if use.kind === :getfield
-                        ir[SSAValue(use.idx)][:stmt] = compute_value_for_use(ir, domtree, allblocks,
+                        inst = ir[SSAValue(use.idx)]
+                        inst[:stmt] = compute_value_for_use(ir, domtree, allblocks,
                             du, phinodes, fidx, use.idx)
-                        ir[SSAValue(use.idx)][:flag] |= IR_FLAG_REFINED
+                        add_flag!(inst, IR_FLAG_REFINED)
                     elseif use.kind === :isdefined
                         continue # already rewritten if possible
                     elseif use.kind === :nopreserve
@@ -1590,7 +1593,7 @@ function sroa_mutables!(ir::IRCode, defuses::IdDict{Int, Tuple{SPCSet, SSADefUse
                     # know we have removed all uses of the mutable allocation.
                     # As a result, if we ever do prove nothrow, we can delete
                     # this statement then.
-                    ir[ssa][:flag] |= IR_FLAG_EFFECT_FREE
+                    add_flag!(ir[ssa], IR_FLAG_EFFECT_FREE)
                 end
             end
         end

From 10d58eb0bd954ca89864b0a910c085710896f3b6 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 23 Nov 2023 13:28:37 +0900
Subject: [PATCH 0311/1315] reflection: add `Base.infer_return_type` utility
 (#52247)

This commit introduces `Base.infer_return_type`, a new reflection
utility which shares a similar interface with `Base.return_types` but
differs in its output; `Base.infer_return_type` provides a singular
return type taking into account all potential outcomes specified with
the given call signature. This function parallels `Base.infer_effects`
and the newly added `Base.infer_exception_type`, offering some utility,
especially in testing scenarios.
---
 base/compiler/typeinfer.jl |  9 ++--
 base/reflection.jl         | 85 +++++++++++++++++++++++++++++++++++---
 test/reflection.jl         | 23 +++++++++--
 3 files changed, 105 insertions(+), 12 deletions(-)

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 460f4be4db0f0..4075f25c6b1e0 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -1051,7 +1051,11 @@ function typeinf_type(interp::AbstractInterpreter, method::Method, @nospecialize
     if contains_is(unwrap_unionall(atype).parameters, Union{})
         return Union{} # don't ask: it does weird and unnecessary things, if it occurs during bootstrap
     end
-    mi = specialize_method(method, atype, sparams)::MethodInstance
+    return typeinf_type(interp, specialize_method(method, atype, sparams))
+end
+typeinf_type(interp::AbstractInterpreter, match::MethodMatch) =
+    typeinf_type(interp, specialize_method(match))
+function typeinf_type(interp::AbstractInterpreter, mi::MethodInstance)
     start_time = ccall(:jl_typeinf_timing_begin, UInt64, ())
     code = get(code_cache(interp), mi, nothing)
     if code isa CodeInstance
@@ -1120,8 +1124,7 @@ function _return_type(interp::AbstractInterpreter, t::DataType)
         rt = widenconst(rt)
     else
         for match in _methods_by_ftype(t, -1, get_world_counter(interp))::Vector
-            match = match::MethodMatch
-            ty = typeinf_type(interp, match.method, match.spec_types, match.sparams)
+            ty = typeinf_type(interp, match::MethodMatch)
             ty === nothing && return Any
             rt = tmerge(rt, ty)
             rt === Any && break
diff --git a/base/reflection.jl b/base/reflection.jl
index 145a7a9a376d5..4d59942cf4013 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1710,6 +1710,8 @@ check_generated_context(world::UInt) =
     (ccall(:jl_is_in_pure_context, Bool, ()) || world == typemax(UInt)) &&
         error("code reflection cannot be used from generated functions")
 
+# TODO rename `Base.return_types` to `Base.infer_return_types`
+
 """
     Base.return_types(
         f, types=default_tt(f);
@@ -1741,9 +1743,9 @@ julia> Base.return_types(sum, Tuple{Vector{Int}})
 julia> methods(sum, (Union{Vector{Int},UnitRange{Int}},))
 # 2 methods for generic function "sum" from Base:
  [1] sum(r::AbstractRange{<:Real})
-     @ range.jl:1396
+     @ range.jl:1399
  [2] sum(a::AbstractArray; dims, kw...)
-     @ reducedim.jl:996
+     @ reducedim.jl:1010
 
 julia> Base.return_types(sum, (Union{Vector{Int},UnitRange{Int}},))
 2-element Vector{Any}:
@@ -1771,13 +1773,84 @@ function return_types(@nospecialize(f), @nospecialize(types=default_tt(f));
     tt = signature_type(f, types)
     matches = _methods_by_ftype(tt, #=lim=#-1, world)::Vector
     for match in matches
-        match = match::Core.MethodMatch
-        ty = Core.Compiler.typeinf_type(interp, match.method, match.spec_types, match.sparams)
+        ty = Core.Compiler.typeinf_type(interp, match::Core.MethodMatch)
         push!(rts, something(ty, Any))
     end
     return rts
 end
 
+"""
+    Base.infer_return_type(
+        f, types=default_tt(f);
+        world::UInt=get_world_counter(),
+        interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world)) -> rt::Type
+
+Returns an inferred return type of the function call specified by `f` and `types`.
+
+# Arguments
+- `f`: The function to analyze.
+- `types` (optional): The argument types of the function. Defaults to the default tuple type of `f`.
+- `world` (optional): The world counter to use for the analysis. Defaults to the current world counter.
+- `interp` (optional): The abstract interpreter to use for the analysis. Defaults to a new `Core.Compiler.NativeInterpreter` with the specified `world`.
+
+# Returns
+- `rt::Type`: An inferred return type of the function call specified by the given call signature.
+
+!!! note
+    Note that, different from [`Base.return_types`](@ref), this doesn't give you the list
+    return types of every possible method matching with the given `f` and `types`.
+    It returns a single return type, taking into account all potential outcomes of
+    any function call entailed by the given signature type.
+
+# Example
+
+```julia
+julia> checksym(::Symbol) = :symbol;
+
+julia> checksym(x::Any) = x;
+
+julia> Base.infer_return_type(checksym, (Union{Symbol,String},))
+Union{String, Symbol}
+
+julia> Base.return_types(checksym, (Union{Symbol,String},))
+2-element Vector{Any}:
+ Symbol
+ Union{String, Symbol}
+```
+
+It's important to note the difference here: `Base.return_types` gives back inferred results
+for each method that matches the given signature `checksum(::Union{Symbol,String})`.
+On the other hand `Base.infer_return_type` returns one collective result that sums up all those possibilities.
+
+!!! warning
+    The `Base.infer_return_type` function should not be used from generated functions;
+    doing so will result in an error.
+"""
+function infer_return_type(@nospecialize(f), @nospecialize(types=default_tt(f));
+                           world::UInt=get_world_counter(),
+                           interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
+    check_generated_context(world)
+    if isa(f, Core.OpaqueClosure)
+        return last(only(code_typed_opaque_closure(f)))
+    end
+    if isa(f, Core.Builtin)
+        return _builtin_return_type(interp, f, types)
+    end
+    tt = signature_type(f, types)
+    matches = Core.Compiler.findall(tt, Core.Compiler.method_table(interp))
+    if matches === nothing
+        # unanalyzable call, i.e. the interpreter world might be newer than the world where
+        # the `f` is defined, return the unknown return type
+        return Any
+    end
+    rt = Union{}
+    for match in matches.matches
+        ty = Core.Compiler.typeinf_type(interp, match::Core.MethodMatch)
+        rt = Core.Compiler.tmerge(rt, something(ty, Any))
+    end
+    return rt
+end
+
 """
     Base.infer_exception_types(
         f, types=default_tt(f);
@@ -1880,7 +1953,7 @@ Returns the type of exception potentially thrown by the function call specified
 !!! note
     Note that, different from [`Base.infer_exception_types`](@ref), this doesn't give you the list
     exception types for every possible matching method with the given `f` and `types`.
-    It provides a single exception type, taking into account all potential outcomes of
+    It returns a single exception type, taking into account all potential outcomes of
     any function call entailed by the given signature type.
 
 # Example
@@ -1964,7 +2037,7 @@ Returns the possible computation effects of the function call specified by `f` a
 !!! note
     Note that, different from [`Base.return_types`](@ref), this doesn't give you the list
     effect analysis results for every possible matching method with the given `f` and `types`.
-    It provides a single effect, taking into account all potential outcomes of any function
+    It returns a single effect, taking into account all potential outcomes of any function
     call entailed by the given signature type.
 
 # Example
diff --git a/test/reflection.jl b/test/reflection.jl
index 87f16deacdded..ddeeb0d053ff2 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1020,7 +1020,22 @@ ambig_effects_test(a::Int, b) = 1
 ambig_effects_test(a, b::Int) = 1
 ambig_effects_test(a, b) = 1
 
-@testset "infer_effects" begin
+@testset "Base.infer_return_type[s]" begin
+    # generic function case
+    @test only(Base.return_types(issue41694, (Int,))) == Base.infer_return_type(issue41694, (Int,)) == Int
+    # case when it's not fully covered
+    @test only(Base.return_types(issue41694, (Integer,))) == Base.infer_return_type(issue41694, (Integer,)) == Int
+    # MethodError case
+    @test isempty(Base.return_types(issue41694, (Float64,)))
+    @test Base.infer_return_type(issue41694, (Float64,)) == Union{}
+    # builtin case
+    @test only(Base.return_types(typeof, (Any,))) == Base.infer_return_type(typeof, (Any,)) == DataType
+    @test only(Base.return_types(===, (Any,Any))) == Base.infer_return_type(===, (Any,Any)) == Bool
+    @test only(Base.return_types(setfield!, ())) == Base.infer_return_type(setfield!, ()) == Union{}
+    @test only(Base.return_types(Core.Intrinsics.mul_int, ())) == Base.infer_return_type(Core.Intrinsics.mul_int, ()) == Union{}
+end
+
+@testset "Base.infer_effects" begin
     # generic functions
     @test Base.infer_effects(issue41694, (Int,)) |> Core.Compiler.is_terminates
     @test Base.infer_effects((Int,)) do x
@@ -1047,7 +1062,7 @@ ambig_effects_test(a, b) = 1
     @test (Base.infer_effects(Core.Intrinsics.mul_int, ()); true) # `intrinsic_effects` shouldn't throw on empty `argtypes`
 end
 
-@testset "infer_exception_type[s]" begin
+@testset "Base.infer_exception_type[s]" begin
     # generic functions
     @test Base.infer_exception_type(issue41694, (Int,)) == only(Base.infer_exception_types(issue41694, (Int,))) == ErrorException
     @test Base.infer_exception_type((Int,)) do x
@@ -1119,7 +1134,9 @@ end
         return :(x)
     end
 end
-@test only(Base.return_types(generated_only_simple, (Real,))) == Core.Compiler.return_type(generated_only_simple, Tuple{Real}) == Any
+@test only(Base.return_types(generated_only_simple, (Real,))) ==
+      Base.infer_return_type(generated_only_simple, (Real,)) ==
+      Core.Compiler.return_type(generated_only_simple, Tuple{Real}) == Any
 let (src, rt) = only(code_typed(generated_only_simple, (Real,)))
     @test src isa Method
     @test rt == Any

From a624d445c02cc2928f8b6a34108aa78fdbb13121 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Thu, 23 Nov 2023 15:22:28 +0800
Subject: [PATCH 0312/1315] Widen diagonal var during `Type` unwrapping in
 `instanceof_tfunc` (#52228)

close #52168
close #27031
---
 base/compiler/tfuncs.jl    |  14 ++-
 base/essentials.jl         |   5 +
 src/subtype.c              | 206 +++++++++++++++++++++++++++++++++++++
 test/compiler/inference.jl |  13 +++
 test/core.jl               |  11 ++
 5 files changed, 245 insertions(+), 4 deletions(-)

diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 97d8bf90c060d..c30f4a1a237e1 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -95,7 +95,7 @@ add_tfunc(throw, 1, 1, @nospecs((𝕃::AbstractLattice, x)->Bottom), 0)
 # if isexact is false, the actual runtime type may (will) be a subtype of t
 # if isconcrete is true, the actual runtime type is definitely concrete (unreachable if not valid as a typeof)
 # if istype is true, the actual runtime value will definitely be a type (e.g. this is false for Union{Type{Int}, Int})
-function instanceof_tfunc(@nospecialize(t), astag::Bool=false)
+function instanceof_tfunc(@nospecialize(t), astag::Bool=false, @nospecialize(troot) = t)
     if isa(t, Const)
         if isa(t.val, Type) && valid_as_lattice(t.val, astag)
             return t.val, true, isconcretetype(t.val), true
@@ -103,6 +103,7 @@ function instanceof_tfunc(@nospecialize(t), astag::Bool=false)
         return Bottom, true, false, false # runtime throws on non-Type
     end
     t = widenconst(t)
+    troot = widenconst(troot)
     if t === Bottom
         return Bottom, true, true, false # runtime unreachable
     elseif t === typeof(Bottom) || !hasintersect(t, Type)
@@ -110,10 +111,15 @@ function instanceof_tfunc(@nospecialize(t), astag::Bool=false)
     elseif isType(t)
         tp = t.parameters[1]
         valid_as_lattice(tp, astag) || return Bottom, true, false, false # runtime unreachable / throws on non-Type
+        if troot isa UnionAll
+            # Free `TypeVar`s inside `Type` has violated the "diagonal" rule.
+            # Widen them before `UnionAll` rewraping to relax concrete constraint.
+            tp = widen_diagonal(tp, troot)
+        end
         return tp, !has_free_typevars(tp), isconcretetype(tp), true
     elseif isa(t, UnionAll)
         t′ = unwrap_unionall(t)
-        t′′, isexact, isconcrete, istype = instanceof_tfunc(t′, astag)
+        t′′, isexact, isconcrete, istype = instanceof_tfunc(t′, astag, rewrap_unionall(t, troot))
         tr = rewrap_unionall(t′′, t)
         if t′′ isa DataType && t′′.name !== Tuple.name && !has_free_typevars(tr)
             # a real instance must be within the declared bounds of the type,
@@ -128,8 +134,8 @@ function instanceof_tfunc(@nospecialize(t), astag::Bool=false)
         end
         return tr, isexact, isconcrete, istype
     elseif isa(t, Union)
-        ta, isexact_a, isconcrete_a, istype_a = instanceof_tfunc(t.a, astag)
-        tb, isexact_b, isconcrete_b, istype_b = instanceof_tfunc(t.b, astag)
+        ta, isexact_a, isconcrete_a, istype_a = instanceof_tfunc(t.a, astag, troot)
+        tb, isexact_b, isconcrete_b, istype_b = instanceof_tfunc(t.b, astag, troot)
         isconcrete = isconcrete_a && isconcrete_b
         istype = istype_a && istype_b
         # most users already handle the Union case, so here we assume that
diff --git a/base/essentials.jl b/base/essentials.jl
index 106826d140c57..a9f3bfc40f622 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -459,6 +459,11 @@ function rename_unionall(@nospecialize(u))
     return UnionAll(nv, body{nv})
 end
 
+# remove concrete constraint on diagonal TypeVar if it comes from troot
+function widen_diagonal(@nospecialize(t), troot::UnionAll)
+    body = ccall(:jl_widen_diagonal, Any, (Any, Any), t, troot)
+end
+
 function isvarargtype(@nospecialize(t))
     return isa(t, Core.TypeofVararg)
 end
diff --git a/src/subtype.c b/src/subtype.c
index f80e31c58c46b..ce2572be2952d 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -4304,6 +4304,212 @@ int jl_subtype_matching(jl_value_t *a, jl_value_t *b, jl_svec_t **penv)
     return sub;
 }
 
+// type utils
+static void check_diagonal(jl_value_t *t, jl_varbinding_t *troot, int param)
+{
+    if (jl_is_uniontype(t)) {
+        int i, len = 0;
+        jl_varbinding_t *v;
+        for (v = troot; v != NULL; v = v->prev)
+            len++;
+        int8_t *occurs = (int8_t *)alloca(len);
+        for (v = troot, i = 0; v != NULL; v = v->prev, i++)
+            occurs[i] = v->occurs_inv | (v->occurs_cov << 2);
+        check_diagonal(((jl_uniontype_t *)t)->a, troot, param);
+        for (v = troot, i = 0; v != NULL; v = v->prev, i++) {
+            int8_t occurs_inv = occurs[i] & 3;
+            int8_t occurs_cov = occurs[i] >> 2;
+            occurs[i] = v->occurs_inv | (v->occurs_cov << 2);
+            v->occurs_inv = occurs_inv;
+            v->occurs_cov = occurs_cov;
+        }
+        check_diagonal(((jl_uniontype_t *)t)->b, troot, param);
+        for (v = troot, i = 0; v != NULL; v = v->prev, i++) {
+            if (v->occurs_inv < (occurs[i] & 3))
+                v->occurs_inv = occurs[i] & 3;
+            if (v->occurs_cov < (occurs[i] >> 2))
+                v->occurs_cov = occurs[i] >> 2;
+        }
+    }
+    else if (jl_is_unionall(t)) {
+        assert(troot != NULL);
+        jl_varbinding_t *v1 = troot, *v2 = troot->prev;
+        while (v2 != NULL) {
+            if (v2->var == ((jl_unionall_t *)t)->var) {
+                v1->prev = v2->prev;
+                break;
+            }
+            v1 = v2;
+            v2 = v2->prev;
+        }
+        check_diagonal(((jl_unionall_t *)t)->body, troot, param);
+        v1->prev = v2;
+    }
+    else if (jl_is_datatype(t)) {
+        int nparam = jl_is_tuple_type(t) ? 1 : 2;
+        if (nparam < param) nparam = param;
+        for (size_t i = 0; i < jl_nparams(t); i++) {
+            check_diagonal(jl_tparam(t, i), troot, nparam);
+        }
+    }
+    else if (jl_is_vararg(t)) {
+        jl_value_t *T = jl_unwrap_vararg(t);
+        jl_value_t *N = jl_unwrap_vararg_num(t);
+        int n = (N && jl_is_long(N)) ? jl_unbox_long(N) : 2;
+        if (T && n > 0) check_diagonal(T, troot, param);
+        if (T && n > 1) check_diagonal(T, troot, param);
+        if (N)          check_diagonal(N, troot, 2);
+    }
+    else if (jl_is_typevar(t)) {
+        jl_varbinding_t *v = troot;
+        for (; v != NULL; v = v->prev) {
+            if (v->var == (jl_tvar_t *)t) {
+                if (param == 1 && v->occurs_cov < 2) v->occurs_cov++;
+                if (param == 2 && v->occurs_inv < 2) v->occurs_inv++;
+                break;
+            }
+        }
+        if (v == NULL)
+            check_diagonal(((jl_tvar_t *)t)->ub, troot, 0);
+    }
+}
+
+static jl_value_t *insert_nondiagonal(jl_value_t *type, jl_varbinding_t *troot, int widen2ub)
+{
+    if (jl_is_typevar(type)) {
+        int concretekind = widen2ub > 1 ? 0 : 1;
+        jl_varbinding_t *v = troot;
+        for (; v != NULL; v = v->prev) {
+            if (v->occurs_inv == 0 &&
+                v->occurs_cov > concretekind &&
+                v->var == (jl_tvar_t *)type)
+                break;
+        }
+        if (v != NULL) {
+            if (widen2ub) {
+                type = insert_nondiagonal(((jl_tvar_t *)type)->ub, troot, 2);
+            }
+            else {
+                // we must replace each covariant occurrence of newvar with a different newvar2<:newvar (diagonal rule)
+                if (v->innervars == NULL)
+                    v->innervars = jl_alloc_array_1d(jl_array_any_type, 0);
+                jl_value_t *newvar = NULL, *lb = v->var->lb, *ub = (jl_value_t *)v->var;
+                jl_array_t *innervars = v->innervars;
+                JL_GC_PUSH4(&newvar, &lb, &ub, &innervars);
+                newvar = (jl_value_t *)jl_new_typevar(v->var->name, lb, ub);
+                jl_array_ptr_1d_push(innervars, newvar);
+                JL_GC_POP();
+                type = newvar;
+            }
+        }
+    }
+    else if (jl_is_unionall(type)) {
+        jl_value_t *body = ((jl_unionall_t*)type)->body;
+        jl_tvar_t *var = ((jl_unionall_t*)type)->var;
+        jl_varbinding_t *v = troot;
+        for (; v != NULL; v = v->prev) {
+            if (v->var == var)
+                break;
+        }
+        if (v) v->var = NULL; // Temporarily remove `type->var` from binding list.
+        jl_value_t *newbody = insert_nondiagonal(body, troot, widen2ub);
+        if (v) v->var = var; // And restore it after inner insertation.
+        jl_value_t *newvar = NULL;
+        JL_GC_PUSH2(&newbody, &newvar);
+        if (body == newbody || jl_has_typevar(newbody, var)) {
+            if (body != newbody)
+                newbody = jl_new_struct(jl_unionall_type, var, newbody);
+            // n.b. we do not widen lb, since that would be the wrong direction
+            newvar = insert_nondiagonal(var->ub, troot, widen2ub);
+            if (newvar != var->ub) {
+                newvar = (jl_value_t*)jl_new_typevar(var->name, var->lb, newvar);
+                newbody = jl_apply_type1(newbody, newvar);
+                newbody = jl_type_unionall((jl_tvar_t*)newvar, newbody);
+            }
+        }
+        type = newbody;
+        JL_GC_POP();
+    }
+    else if (jl_is_uniontype(type)) {
+        jl_value_t *a = ((jl_uniontype_t*)type)->a;
+        jl_value_t *b = ((jl_uniontype_t*)type)->b;
+        jl_value_t *newa = NULL;
+        jl_value_t *newb = NULL;
+        JL_GC_PUSH2(&newa, &newb);
+        newa = insert_nondiagonal(a, troot, widen2ub);
+        newb = insert_nondiagonal(b, troot, widen2ub);
+        if (newa != a || newb != b)
+            type = simple_union(newa, newb);
+        JL_GC_POP();
+    }
+    else if (jl_is_vararg(type)) {
+        // As for Vararg we'd better widen it's var to ub as otherwise they are still diagonal
+        jl_value_t *t = jl_unwrap_vararg(type);
+        jl_value_t *n = jl_unwrap_vararg_num(type);
+        if (widen2ub == 0)
+            widen2ub = !(n && jl_is_long(n)) || jl_unbox_long(n) > 1;
+        jl_value_t *newt;
+        JL_GC_PUSH2(&newt, &n);
+        newt = insert_nondiagonal(t, troot, widen2ub);
+        if (t != newt)
+            type = (jl_value_t *)jl_wrap_vararg(newt, n, 0);
+        JL_GC_POP();
+    }
+    else if (jl_is_datatype(type)) {
+        if (jl_is_tuple_type(type)) {
+            jl_svec_t *newparams = NULL;
+            jl_value_t *newelt = NULL;
+            JL_GC_PUSH2(&newparams, &newelt);
+            for (size_t i = 0; i < jl_nparams(type); i++) {
+                jl_value_t *elt = jl_tparam(type, i);
+                newelt = insert_nondiagonal(elt, troot, widen2ub);
+                if (elt != newelt) {
+                    if (!newparams)
+                        newparams = jl_svec_copy(((jl_datatype_t*)type)->parameters);
+                    jl_svecset(newparams, i, newelt);
+                }
+            }
+            if (newparams)
+                type = (jl_value_t*)jl_apply_tuple_type(newparams, 1);
+            JL_GC_POP();
+        }
+    }
+    return type;
+}
+
+static jl_value_t *_widen_diagonal(jl_value_t *t, jl_varbinding_t *troot) {
+    check_diagonal(t, troot, 0);
+    int any_concrete = 0;
+    for (jl_varbinding_t *v = troot; v != NULL; v = v->prev)
+        any_concrete |= v->occurs_cov > 1 && v->occurs_inv == 0;
+    if (!any_concrete)
+        return t; // no diagonal
+    return insert_nondiagonal(t, troot, 0);
+}
+
+static jl_value_t *widen_diagonal(jl_value_t *t, jl_unionall_t *u, jl_varbinding_t *troot)
+{
+    jl_varbinding_t vb = { u->var, NULL, NULL, 1, 0, 0, 0, 0, 0, 0, 0, 0, NULL, troot };
+    jl_value_t *nt;
+    JL_GC_PUSH2(&vb.innervars, &nt);
+    if (jl_is_unionall(u->body))
+        nt = widen_diagonal(t, (jl_unionall_t *)u->body, &vb);
+    else
+        nt = _widen_diagonal(t, &vb);
+    if (vb.innervars != NULL) {
+        for (size_t i = 0; i < jl_array_nrows(vb.innervars); i++) {
+            jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb.innervars, i);
+            nt = jl_type_unionall(var, nt);
+        }
+    }
+    JL_GC_POP();
+    return nt;
+}
+
+JL_DLLEXPORT jl_value_t *jl_widen_diagonal(jl_value_t *t, jl_unionall_t *ua)
+{
+    return widen_diagonal(t, ua, NULL);
+}
 
 // specificity comparison
 
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 30a2763cb605b..108a62db4b940 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5593,3 +5593,16 @@ end |> only === Float64
 @test Base.infer_exception_type(c::Bool -> c ? 1 : 2) == Union{}
 @test Base.infer_exception_type(c::Missing -> c ? 1 : 2) == TypeError
 @test Base.infer_exception_type(c::Any -> c ? 1 : 2) == TypeError
+
+# Issue #52168
+f52168(x, t::Type) = x::NTuple{2, Base.inferencebarrier(t)::Type}
+@test f52168((1, 2.), Any) === (1, 2.)
+
+# Issue #27031
+let x = 1, _Any = Any
+    @noinline bar27031(tt::Tuple{T,T}, ::Type{Val{T}}) where {T} = notsame27031(tt)
+    @noinline notsame27031(tt::Tuple{T, T}) where {T} = error()
+    @noinline notsame27031(tt::Tuple{T, S}) where {T, S} = "OK"
+    foo27031() = bar27031((x, 1.0), Val{_Any})
+    @test foo27031() == "OK"
+end
diff --git a/test/core.jl b/test/core.jl
index c85868c496d91..7cd4be5427eb4 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8059,3 +8059,14 @@ check_globalref_lowering() = @insert_global
 let src = code_lowered(check_globalref_lowering)[1]
     @test length(src.code) == 2
 end
+
+# Test correctness of widen_diagonal
+let widen_diagonal(x::UnionAll) = Base.rewrap_unionall(Base.widen_diagonal(Base.unwrap_unionall(x), x), x),
+    check_widen_diagonal(x, y) = !<:(x, y) && x <: widen_diagonal(y)
+    @test Tuple{Int,Float64} <: widen_diagonal(NTuple)
+    @test Tuple{Int,Float64} <: widen_diagonal(Tuple{T,T} where {T})
+    @test Tuple{Real,Int,Float64} <: widen_diagonal(Tuple{S,Vararg{T}} where {S, T<:S})
+    @test Tuple{Int,Int,Float64,Float64} <: widen_diagonal(Tuple{S,S,Vararg{T}} where {S, T<:S})
+    @test Union{Tuple{T}, Tuple{T,Int}} where {T} === widen_diagonal(Union{Tuple{T}, Tuple{T,Int}} where {T})
+    @test Tuple === widen_diagonal(Union{Tuple{Vararg{S}}, Tuple{Vararg{T}}} where {S, T})
+end

From 0c46852901c63b33f0603b0afd58ff1da687d760 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 23 Nov 2023 17:00:46 +0900
Subject: [PATCH 0313/1315] effects: refine `:nothrow` when `exct` is known to
 be `Bottom` (#52270)

Implements effects refinement that goes in the reverse direction of what
was implemented in 8dd0cf5.

In the discussion at JuliaLang/julia#52268, there's a debate on how to
deal with exceptions
like `StackOverflowError` or `InterruptException` that are caused by
environment. The
original purpose of #52268 was to fix issues where methods that could
cause a
`StackOverflowError` were mistakenly refined to `:nothrow`. But now it
feels like it's a bit
weird to model such environment-dependent exceptions as `:nothrow` in
the first place. If we
can exclude environment-dependent errors from the `:nothrow` modeling,
those methods might
be safely considered `:nothrow`. To prevent the concrete evaluation of
methods that may
cause `StackOverflowError`, it's enough to taint its `:teminates` after
all.
This commit excludes environment-depending errors from the `:nothrow`
modeling, reverting the changes from #52268 while making it explicit in
the `Effects` and `Base.@assume_effects` docstrings.

Anyway, now the compile is able to prove `:nothrow`-ness of the
following frame:
```julia
function getindex_nothrow(xs::Vector{Int}, i::Int)
    try
        return xs[i]
    catch err
        err isa BoundsError && return nothing
        rethrow(err)
    end
end
```
---
 base/compiler/effects.jl   |  5 +++++
 base/compiler/typeinfer.jl |  8 +++++---
 base/expr.jl               |  8 ++++++--
 test/compiler/effects.jl   | 12 ++++++++++++
 test/compiler/inference.jl |  4 +---
 5 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/base/compiler/effects.jl b/base/compiler/effects.jl
index d4c972ab89e95..9d66407b58eb3 100644
--- a/base/compiler/effects.jl
+++ b/base/compiler/effects.jl
@@ -24,6 +24,11 @@ following meanings:
   * `EFFECT_FREE_IF_INACCESSIBLEMEMONLY`: the `:effect-free`-ness of this method can later be
     refined to `ALWAYS_TRUE` in a case when `:inaccessiblememonly` is proven.
 - `nothrow::Bool`: this method is guaranteed to not throw an exception.
+  If the execution of this method may raise `MethodError`s and similar exceptions, then
+  the method is not considered as `:nothrow`.
+  However, note that environment-dependent errors like `StackOverflowError` or `InterruptException`
+  are not modeled by this effect and thus a method that may result in `StackOverflowError`
+  does not necessarily need to taint `:nothrow` (although it should usually taint `:terminates` too).
 - `terminates::Bool`: this method is guaranteed to terminate.
 - `notaskstate::Bool`: this method does not access any state bound to the current
   task and may thus be moved to a different task without changing observable
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 4075f25c6b1e0..958993847a48e 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -463,6 +463,11 @@ function adjust_effects(sv::InferenceState)
         # always throwing an error counts or never returning both count as consistent
         ipo_effects = Effects(ipo_effects; consistent=ALWAYS_TRUE)
     end
+    if sv.exc_bestguess === Bottom
+        # if the exception type of this frame is known to be `Bottom`,
+        # this frame is known to be safe
+        ipo_effects = Effects(ipo_effects; nothrow=true)
+    end
     if is_inaccessiblemem_or_argmemonly(ipo_effects) && all(1:narguments(sv, #=include_va=#true)) do i::Int
             return is_mutation_free_argtype(sv.slottypes[i])
         end
@@ -883,9 +888,6 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
     update_valid_age!(caller, frame.valid_worlds)
     effects = adjust_effects(Effects(), method)
     exc_bestguess = refine_exception_type(frame.exc_bestguess, effects)
-    # this call can fail into an infinite cycle, so incorporate this fact into
-    # `exc_bestguess` by merging `StackOverflowError` into it
-    exc_bestguess = tmerge(typeinf_lattice(interp), Core.StackOverflowError, exc_bestguess)
     return EdgeCallResult(frame.bestguess, exc_bestguess, nothing, effects)
 end
 
diff --git a/base/expr.jl b/base/expr.jl
index 3e68c68b2ac4f..755eff1b7c1b8 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -552,7 +552,7 @@ were not executed.
 ---
 ## `:nothrow`
 
-The `:nothrow` settings asserts that this method does not terminate abnormally
+The `:nothrow` settings asserts that this method does not throw an exception
 (i.e. will either always return a value or never return).
 
 !!! note
@@ -561,7 +561,11 @@ The `:nothrow` settings asserts that this method does not terminate abnormally
     method itself.
 
 !!! note
-    `MethodErrors` and similar exceptions count as abnormal termination.
+    If the execution of a method may raise `MethodError`s and similar exceptions, then
+    the method is not considered as `:nothrow`.
+    However, note that environment-dependent errors like `StackOverflowError` or `InterruptException`
+    are not modeled by this effect and thus a method that may result in `StackOverflowError`
+    does not necessarily need to be `!:nothrow` (although it should usually be `!:terminates` too).
 
 ---
 ## `:terminates_globally`
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 133ff6e9f3ca9..3e0c24f908bc9 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1290,3 +1290,15 @@ end |> !Core.Compiler.is_noub
 @test Base.infer_effects((Vector{Any},Int)) do xs, i
     @inbounds getindex_dont_propagate(xs, i)
 end |> Core.Compiler.is_noub
+
+# refine `:nothrow` when `exct` is known to be `Bottom`
+@test Base.infer_exception_type(getindex, (Vector{Int},Int)) == BoundsError
+function getindex_nothrow(xs::Vector{Int}, i::Int)
+    try
+        return xs[i]
+    catch err
+        err isa BoundsError && return nothing
+        rethrow(err)
+    end
+end
+@test Core.Compiler.is_nothrow(Base.infer_effects(getindex_nothrow, (Vector{Int}, Int)))
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 108a62db4b940..9e06d120e501f 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -423,13 +423,11 @@ A14009(a::T) where {T} = A14009{T}()
 f14009(a) = rand(Bool) ? f14009(A14009(a)) : a
 code_typed(f14009, (Int,))
 code_llvm(devnull, f14009, (Int,))
-@test Base.infer_exception_type(f14009, (Int,)) != Union{}
 
 mutable struct B14009{T}; end
 g14009(a) = g14009(B14009{a})
 code_typed(g14009, (Type{Int},))
 code_llvm(devnull, g14009, (Type{Int},))
-@test Base.infer_exception_type(g14009, (Type{Int},)) == StackOverflowError
 
 # issue #9232
 arithtype9232(::Type{T},::Type{T}) where {T<:Real} = arithtype9232(T)
@@ -5560,7 +5558,7 @@ function foo_typed_throw_metherr()
 end
 @test Base.return_types(foo_typed_throw_metherr) |> only === Float64
 
-# using `exct` information if `:nothrow` is proven
+# refine `exct` when `:nothrow` is proven
 Base.@assume_effects :nothrow function sin_nothrow(x::Float64)
     x == Inf && return zero(x)
     return sin(x)

From 38438d7b1b510d6180058e63852aba9186278a4b Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 23 Nov 2023 10:15:22 -0600
Subject: [PATCH 0314/1315] Remove upper bound in timer test (#52282)

---
 test/channels.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/channels.jl b/test/channels.jl
index 82689e8d08d28..5633d9480d0b8 100644
--- a/test/channels.jl
+++ b/test/channels.jl
@@ -559,7 +559,7 @@ end
     e = @elapsed for i = 1:5
         wait(t)
     end
-    @test 1.5 > e >= 0.4
+    @test e >= 0.4
     @test a[] == 0
     nothing
 end

From 9884e447e79241a27f88c6484f07aa58c5c6f681 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 23 Nov 2023 10:16:15 -0600
Subject: [PATCH 0315/1315] Don't print "No global of this name exists in this
 module." on UndefValError (#52280)

---
 base/docs/basedocs.jl                   | 2 +-
 doc/src/manual/control-flow.md          | 2 +-
 doc/src/manual/variables-and-scoping.md | 2 +-
 stdlib/REPL/src/REPLCompletions.jl      | 4 +++-
 4 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 87f568a420b8d..b2d81f482b646 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -2347,7 +2347,7 @@ julia> module M end;
 
 julia> M.a  # same as `getglobal(M, :a)`
 ERROR: UndefVarError: `a` not defined in `M`
-Suggestion: check for spelling errors or missing imports. No global of this name exists in this module.
+Suggestion: check for spelling errors or missing imports.
 
 julia> setglobal!(M, :a, 1)
 1
diff --git a/doc/src/manual/control-flow.md b/doc/src/manual/control-flow.md
index 5eb2bd24fb076..4ab611f0cafae 100644
--- a/doc/src/manual/control-flow.md
+++ b/doc/src/manual/control-flow.md
@@ -863,7 +863,7 @@ end
                foo
            end
     ERROR: UndefVarError: `foo` not defined in `Main`
-    Suggestion: check for spelling errors or missing imports. No global of this name exists in this module.
+    Suggestion: check for spelling errors or missing imports.
     ```
     Use the [`local` keyword](@ref local-scope) outside the `try` block to make the variable
     accessible from anywhere within the outer scope.
diff --git a/doc/src/manual/variables-and-scoping.md b/doc/src/manual/variables-and-scoping.md
index 9d2d68244a65b..6a6f176650b2a 100644
--- a/doc/src/manual/variables-and-scoping.md
+++ b/doc/src/manual/variables-and-scoping.md
@@ -91,7 +91,7 @@ julia> module D
            b = a # errors as D's global scope is separate from A's
        end;
 ERROR: UndefVarError: `a` not defined in `D`
-Suggestion: check for spelling errors or missing imports. No global of this name exists in this module.
+Suggestion: check for spelling errors or missing imports.
 ```
 
 If a top-level expression contains a variable declaration with keyword `local`,
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 2c9d8560aed4d..375a4e044b228 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -1409,7 +1409,9 @@ function UndefVarError_hint(io::IO, ex::UndefVarError)
             else
                 owner = ccall(:jl_binding_owner, Ptr{Cvoid}, (Any, Any), scope, var)
                 if C_NULL == owner
-                    print(io, "\nSuggestion: check for spelling errors or missing imports. No global of this name exists in this module.")
+                    # No global of this name exists in this module.
+                    # This is the common case, so do not print that information.
+                    print(io, "\nSuggestion: check for spelling errors or missing imports.")
                     owner = bnd
                 else
                     owner = unsafe_pointer_to_objref(owner)::Core.Binding

From 79a845ce49b05bf0b7c3e088872f4c0d65a2b16a Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 23 Nov 2023 16:04:29 -0300
Subject: [PATCH 0316/1315] Don't reuse passmanagers across compilations
 (#52054)

---
 doc/src/devdocs/locks.md |  1 +
 src/aotcompile.cpp       |  3 +++
 src/codegen.cpp          |  7 +++++
 src/jitlayers.cpp        | 20 +++++++++------
 src/jitlayers.h          | 11 +++-----
 src/pipeline.cpp         | 55 ++++++++++++++++++----------------------
 6 files changed, 52 insertions(+), 45 deletions(-)

diff --git a/doc/src/devdocs/locks.md b/doc/src/devdocs/locks.md
index 26de9351e40cd..33947035f51a0 100644
--- a/doc/src/devdocs/locks.md
+++ b/doc/src/devdocs/locks.md
@@ -30,6 +30,7 @@ The following are definitely leaf locks (level 1), and must not try to acquire a
 >   * jl_in_stackwalk (Win32)
 >   * ResourcePool<?>::mutex
 >   * RLST_mutex
+>   * llvm_printing_mutex
 >   * jl_locked_stream::mutex
 >   * debuginfo_asyncsafe
 >   * inference_timing_mutex
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index b65d412b6bcda..b844d22337d31 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1414,12 +1414,15 @@ static SmallVector<AOTOutputs, 16> add_output(Module &M, TargetMachine &TM, Stri
     return outputs;
 }
 
+extern int jl_is_timing_passes;
 static unsigned compute_image_thread_count(const ModuleInfo &info) {
     // 32-bit systems are very memory-constrained
 #ifdef _P32
     LLVM_DEBUG(dbgs() << "32-bit systems are restricted to a single thread\n");
     return 1;
 #endif
+    if (jl_is_timing_passes) // LLVM isn't thread safe when timing the passes https://github.com/llvm/llvm-project/issues/44417
+        return 1;
     // COFF has limits on external symbols (even hidden) up to 65536. We reserve the last few
     // for any of our other symbols that we insert during compilation.
     if (info.triple.isOSBinFormatCOFF() && info.globals > 64000) {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 16f0b6903aa28..42a62bae4bd80 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -9483,6 +9483,8 @@ char jl_using_oprofile_jitevents = 0; // Non-zero if running under OProfile
 char jl_using_perf_jitevents = 0;
 #endif
 
+int jl_is_timing_passes = 0;
+
 extern "C" void jl_init_llvm(void)
 {
     jl_page_size = jl_getpagesize();
@@ -9541,6 +9543,11 @@ extern "C" void jl_init_llvm(void)
     if (clopt && clopt->getNumOccurrences() == 0) {
         clopt->addOccurrence(1, clopt->ArgStr, "false", true);
     }
+
+    clopt = llvmopts.lookup("time-passes");
+    if (clopt && clopt->getNumOccurrences() > 0)
+        jl_is_timing_passes = 1;
+
     jl_ExecutionEngine = new JuliaOJIT();
 
     bool jl_using_gdb_jitevents = false;
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 2de5455903375..3ed86c688f6dd 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1249,26 +1249,30 @@ namespace {
         orc::JITTargetMachineBuilder JTMB;
         OptimizationLevel O;
         SmallVector<std::function<void()>, 0> &printers;
-        PMCreator(TargetMachine &TM, int optlevel, SmallVector<std::function<void()>, 0> &printers) JL_NOTSAFEPOINT
-            : JTMB(createJTMBFromTM(TM, optlevel)), O(getOptLevel(optlevel)), printers(printers) {}
+        std::mutex &llvm_printing_mutex;
+        PMCreator(TargetMachine &TM, int optlevel, SmallVector<std::function<void()>, 0> &printers, std::mutex &llvm_printing_mutex) JL_NOTSAFEPOINT
+            : JTMB(createJTMBFromTM(TM, optlevel)), O(getOptLevel(optlevel)), printers(printers), llvm_printing_mutex(llvm_printing_mutex) {}
 
         auto operator()() JL_NOTSAFEPOINT {
             auto TM = cantFail(JTMB.createTargetMachine());
             fixupTM(*TM);
             auto NPM = std::make_unique<NewPM>(std::move(TM), O);
             // TODO this needs to be locked, as different resource pools may add to the printer vector at the same time
-            printers.push_back([NPM = NPM.get()]() JL_NOTSAFEPOINT {
-                NPM->printTimers();
-            });
+            {
+                std::lock_guard<std::mutex> lock(llvm_printing_mutex);
+                printers.push_back([NPM = NPM.get()]() JL_NOTSAFEPOINT {
+                    NPM->printTimers();
+                });
+            }
             return NPM;
         }
     };
 
     template<size_t N>
     struct OptimizerT {
-        OptimizerT(TargetMachine &TM, SmallVector<std::function<void()>, 0> &printers) JL_NOTSAFEPOINT {
+        OptimizerT(TargetMachine &TM, SmallVector<std::function<void()>, 0> &printers, std::mutex &llvm_printing_mutex) JL_NOTSAFEPOINT {
             for (size_t i = 0; i < N; i++) {
-                PMs[i] = std::make_unique<JuliaOJIT::ResourcePool<std::unique_ptr<PassManager>>>(PMCreator(TM, i, printers));
+                PMs[i] = std::make_unique<JuliaOJIT::ResourcePool<std::unique_ptr<PassManager>>>(PMCreator(TM, i, printers, llvm_printing_mutex));
             }
         }
 
@@ -1706,7 +1710,7 @@ JuliaOJIT::JuliaOJIT()
     LockLayer(ObjectLayer),
     CompileLayer(ES, LockLayer, std::make_unique<CompilerT<N_optlevels>>(orc::irManglingOptionsFromTargetOptions(TM->Options), *TM)),
     JITPointersLayer(ES, CompileLayer, orc::IRTransformLayer::TransformFunction(JITPointersT(SharedBytes, RLST_mutex))),
-    OptimizeLayer(ES, JITPointersLayer, orc::IRTransformLayer::TransformFunction(OptimizerT<N_optlevels>(*TM, PrintLLVMTimers))),
+    OptimizeLayer(ES, JITPointersLayer, orc::IRTransformLayer::TransformFunction(OptimizerT<N_optlevels>(*TM, PrintLLVMTimers, llvm_printing_mutex))),
     OptSelLayer(ES, OptimizeLayer, orc::IRTransformLayer::TransformFunction(selectOptLevel)),
     DepsVerifyLayer(ES, OptSelLayer, orc::IRTransformLayer::TransformFunction(validateExternRelocations)),
     ExternalCompileLayer(ES, LockLayer,
diff --git a/src/jitlayers.h b/src/jitlayers.h
index ba2e81879a44b..622fe9131861d 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -10,6 +10,7 @@
 #include <llvm/IR/Value.h>
 #include <llvm/IR/PassManager.h>
 #include <llvm/IR/LegacyPassManager.h>
+#include <llvm/IR/PassTimingInfo.h>
 
 #include <llvm/ExecutionEngine/Orc/IRCompileLayer.h>
 #include <llvm/ExecutionEngine/Orc/IRTransformLayer.h>
@@ -101,14 +102,9 @@ struct OptimizationOptions {
 
 struct NewPM {
     std::unique_ptr<TargetMachine> TM;
-#if JL_LLVM_VERSION < 160000
-    StandardInstrumentations SI;
-#endif
-    std::unique_ptr<PassInstrumentationCallbacks> PIC;
-    PassBuilder PB;
-    ModulePassManager MPM;
     OptimizationLevel O;
-
+    OptimizationOptions options;
+    TimePassesHandler TimePasses;
     NewPM(std::unique_ptr<TargetMachine> TM, OptimizationLevel O, OptimizationOptions options = OptimizationOptions::defaults()) JL_NOTSAFEPOINT;
     ~NewPM() JL_NOTSAFEPOINT;
 
@@ -582,6 +578,7 @@ class JuliaOJIT {
     jl_locked_stream dump_compiles_stream;
     jl_locked_stream dump_llvm_opt_stream;
 
+    std::mutex llvm_printing_mutex{};
     SmallVector<std::function<void()>, 0> PrintLLVMTimers;
 
     ResourcePool<orc::ThreadSafeContext, 0, std::queue<orc::ThreadSafeContext>> ContextPool;
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index e73b49710bdc3..4b099521d33f9 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -701,21 +701,6 @@ PIC.addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
         PIC.addClassToPassName("AfterOptimizationMarkerPass", "AfterOptimization");
     }
 
-#if JL_LLVM_VERSION >= 160000
-    auto createPIC() JL_NOTSAFEPOINT {
-        auto PIC = std::make_unique<PassInstrumentationCallbacks>();
-        adjustPIC(*PIC);
-        return PIC;
-    }
-#else
-    auto createPIC(StandardInstrumentations &SI) JL_NOTSAFEPOINT {
-        auto PIC = std::make_unique<PassInstrumentationCallbacks>();
-        adjustPIC(*PIC);
-        SI.registerCallbacks(*PIC);
-        return PIC;
-    }
-#endif
-
     FunctionAnalysisManager createFAM(OptimizationLevel O, TargetMachine &TM) JL_NOTSAFEPOINT {
 
         FunctionAnalysisManager FAM;
@@ -744,15 +729,8 @@ PIC.addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 }
 
 NewPM::NewPM(std::unique_ptr<TargetMachine> TM, OptimizationLevel O, OptimizationOptions options) :
-    TM(std::move(TM)),
-#if JL_LLVM_VERSION < 160000
-    SI(false),
-    PIC(createPIC(SI)),
-#else
-    PIC(createPIC()),
-#endif
-    PB(this->TM.get(), PipelineTuningOptions(), None, PIC.get()),
-    MPM(createMPM(PB, O, options)), O(O) {}
+    TM(std::move(TM)), O(O), options(options), TimePasses() {}
+
 
 NewPM::~NewPM() = default;
 
@@ -778,17 +756,34 @@ void NewPM::run(Module &M) {
     //We must recreate the analysis managers every time
     //so that analyses from previous runs of the pass manager
     //do not hang around for the next run
-    AnalysisManagers AM{*TM, PB, O};
-
+#if JL_LLVM_VERSION >= 160000
+    StandardInstrumentations SI(M.getContext(),false);
+#else
+    StandardInstrumentations SI(false);
+#endif
+    FunctionAnalysisManager FAM(createFAM(O, *TM.get()));
+    PassInstrumentationCallbacks PIC;
+    adjustPIC(PIC);
+    TimePasses.registerCallbacks(PIC);
+    SI.registerCallbacks(PIC, &FAM);
+    SI.getTimePasses().setOutStream(nulls()); //TODO: figure out a better way of doing this
+    LoopAnalysisManager LAM;
+    CGSCCAnalysisManager CGAM;
+    ModuleAnalysisManager MAM;
+    PassBuilder PB(TM.get(), PipelineTuningOptions(), None, &PIC);
+    PB.registerLoopAnalyses(LAM);
+    PB.registerFunctionAnalyses(FAM);
+    PB.registerCGSCCAnalyses(CGAM);
+    PB.registerModuleAnalyses(MAM);
+    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    ModulePassManager MPM = createMPM(PB, O, options);
 #ifndef __clang_gcanalyzer__ /* the analyzer cannot prove we have not added instrumentation callbacks with safepoints */
-    MPM.run(M, AM.MAM);
+    MPM.run(M, MAM);
 #endif
 }
 
 void NewPM::printTimers() {
-#if JL_LLVM_VERSION < 160000
-    SI.getTimePasses().print();
-#endif
+    TimePasses.print();
 }
 
 OptimizationLevel getOptLevel(int optlevel) {

From 187e8c2222878c68b2afc9295ab8dc61773bd7f2 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 23 Nov 2023 15:16:52 -0600
Subject: [PATCH 0317/1315] Add `BracketedSort` a new, faster algorithm for
 `partialsort` and friends (#52006)

---
 base/sort.jl    | 199 +++++++++++++++++++++++++++++++++++++++++++++++-
 test/sorting.jl |  37 +++++++++
 2 files changed, 235 insertions(+), 1 deletion(-)

diff --git a/base/sort.jl b/base/sort.jl
index b57c00edb5454..b9497d8136114 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -90,7 +90,15 @@ issorted(itr;
     issorted(itr, ord(lt,by,rev,order))
 
 function partialsort!(v::AbstractVector, k::Union{Integer,OrdinalRange}, o::Ordering)
-    _sort!(v, InitialOptimizations(ScratchQuickSort(k)), o, (;))
+    # TODO move k from `alg` to `kw`
+    # Don't perform InitialOptimizations before Bracketing. The optimizations take O(n)
+    # time and so does the whole sort. But do perform them before recursive calls because
+    # that can cause significant speedups when the target range is large so the runtime is
+    # dominated by k log k and the optimizations runs in O(k) time.
+    _sort!(v, BoolOptimization(
+        Small{12}( # Very small inputs should go straight to insertion sort
+            BracketedSort(k))),
+        o, (;))
     maybeview(v, k)
 end
 
@@ -1138,6 +1146,195 @@ function _sort!(v::AbstractVector, a::ScratchQuickSort, o::Ordering, kw;
 end
 
 
+"""
+    BracketedSort(target[, next::Algorithm]) <: Algorithm
+
+Perform a partialsort for the elements that fall into the indices specified by the `target`
+using BracketedSort with the `next` algorithm for subproblems.
+
+BracketedSort takes a random* sample of the input, estimates the quantiles of the input
+using the quantiles of the sample to find signposts that almost certainly bracket the target
+values, filters the value in the input that fall between the signpost values to the front of
+the input, and then, if that "almost certainly" turned out to be true, finds the target
+within the small chunk that are, by value, between the signposts and now by position, at the
+front of the vector. On small inputs or when target is close to the size of the input,
+BracketedSort falls back to the `next` algorithm directly. Otherwise, BracketedSort uses the
+`next` algorithm only to compute quantiles of the sample and to find the target within the
+small chunk.
+
+## Performance
+
+If the `next` algorithm has `O(n * log(n))` runtime and the input is not pathological then
+the runtime of this algorithm is `O(n + k * log(k))` where `n` is the length of the input
+and `k` is `length(target)`. On pathological inputs the asymptotic runtime is the same as
+the runtime of the `next` algorithm.
+
+BracketedSort itself does not allocate. If `next` is in-place then BracketedSort is also
+in-place. If `next` is not in place, and it's space usage increases monotonically with input
+length then BracketedSort's maximum space usage will never be more than the space usage
+of `next` on the input BracketedSort receives. For large nonpathological inputs and targets
+substantially smaller than the size of the input, BracketedSort's maximum memory usage will
+be much less than `next`'s. If the maximum additional space usage of `next` scales linearly
+then for small k the average* maximum additional space usage of BracketedSort will be
+`O(n^(2.3/3))`.
+
+By default, BracketedSort uses the `O(n)` space and `O(n + k log k)` runtime
+`ScratchQuickSort` algorithm recursively.
+
+*Sorting is unable to depend on Random.jl because Random.jl depends on sorting.
+ Consequently, we use `hash` as a source of randomness. The average runtime guarantees
+ assume that `hash(x::Int)` produces a random result. However, as this randomization is
+ deterministic, if you try hard enough you can find inputs that consistently reach the
+ worst case bounds. Actually constructing such inputs is an exercise left to the reader.
+ Have fun :).
+
+Characteristics:
+  * *unstable*: does not preserve the ordering of elements that compare equal
+    (e.g. "a" and "A" in a sort of letters that ignores case).
+  * *in-place* in memory if the `next` algorithm is in-place.
+  * *estimate-and-filter*: strategy
+  * *linear runtime* if `length(target)` is constant and `next` is reasonable
+  * *n + k log k* worst case runtime if `next` has that runtime.
+  * *pathological inputs* can significantly increase constant factors.
+"""
+struct BracketedSort{T, F} <: Algorithm
+    target::T
+    get_next::F
+end
+
+# TODO: this composition between BracketedSort and ScratchQuickSort does not bring me joy
+BracketedSort(k) = BracketedSort(k, k -> InitialOptimizations(ScratchQuickSort(k)))
+
+function bracket_kernel!(v::AbstractVector, lo, hi, lo_signpost, hi_signpost, o)
+    i = 0
+    count_below = 0
+    checkbounds(v, lo:hi)
+    for j in lo:hi
+        x = @inbounds v[j]
+        a = lo_signpost !== nothing && lt(o, x, lo_signpost)
+        b = hi_signpost === nothing || !lt(o, hi_signpost, x)
+        count_below += a
+        # if a != b # This branch is almost never taken, so making it branchless is bad.
+        #     @inbounds v[i], v[j] = v[j], v[i]
+        #     i += 1
+        # end
+        c = a != b # JK, this is faster.
+        k = i * c + j
+        # Invariant: @assert firstindex(v) ≤ lo ≤ i + j ≤ k ≤ j ≤ hi ≤ lastindex(v)
+        @inbounds v[j], v[k] = v[k], v[j]
+        i += c - 1
+    end
+    count_below, i+hi
+end
+
+function move!(v, target, source)
+    # This function never dominates runtime—only add `@inbounds` if you can demonstrate a
+    # performance improvement. And if you do, also double check behavior when `target`
+    # is out of bounds.
+    @assert length(target) == length(source)
+    if length(target) == 1 || isdisjoint(target, source)
+        for (i, j) in zip(target, source)
+            v[i], v[j] = v[j], v[i]
+        end
+    else
+        @assert minimum(source) <= minimum(target)
+        reverse!(v, minimum(source), maximum(target))
+        reverse!(v, minimum(target), maximum(target))
+    end
+end
+
+function _sort!(v::AbstractVector, a::BracketedSort, o::Ordering, kw)
+    @getkw lo hi scratch
+    # TODO for further optimization: reuse scratch between trials better, from signpost
+    # selection to recursive calls, and from the fallback (but be aware of type stability,
+    # especially when sorting IEEE floats.
+
+    # We don't need to bounds check target because that is done higher up in the stack
+    # However, we cannot assume the target is inbounds.
+    lo < hi || return scratch
+    ln = hi - lo + 1
+
+    # This is simply a precomputed short-circuit to avoid doing scalar math for small inputs.
+    # It does not change dispatch at all.
+    ln < 260 && return _sort!(v, a.get_next(a.target), o, kw)
+
+    target = a.target
+    k = cbrt(ln)
+    k2 = round(Int, k^2)
+    k2ln = k2/ln
+    offset = .15k2*top_set_bit(k2) # TODO for further optimization: tune this
+    lo_signpost_i, hi_signpost_i =
+        (floor(Int, (tar - lo) * k2ln + lo + off) for (tar, off) in
+            ((minimum(target), -offset), (maximum(target), offset)))
+    lastindex_sample = lo+k2-1
+    expected_middle_ln = (min(lastindex_sample, hi_signpost_i) - max(lo, lo_signpost_i) + 1) / k2ln
+    # This heuristic is complicated because it fairly accurately reflects the runtime of
+    # this algorithm which is necessary to get good dispatch when both the target is large
+    # and the input are large.
+    # expected_middle_ln is a float and k2 is significantly below typemax(Int), so this will
+    # not overflow:
+    # TODO move target from alg to kw to avoid this ickyness:
+    ln <= 130 + 2k2 + 2expected_middle_ln && return _sort!(v, a.get_next(a.target), o, kw)
+
+    # We store the random sample in
+    #     sample = view(v, lo:lo+k2)
+    # but views are not quite as fast as using the input array directly,
+    # so we don't actually construct this view at runtime.
+
+    # TODO for further optimization: handle lots of duplicates better.
+    # Right now lots of duplicates rounds up when it could use some super fast optimizations
+    # in some cases.
+    # e.g.
+    #
+    # Target:                      |----|
+    # Sorted input: 000000000000000000011111112222223333333333
+    #
+    # Will filter all zeros and ones to the front when it could just take the first few
+    # it encounters. This optimization would be especially potent when `allequal(ans)` and
+    # equal elements are egal.
+
+    # 3 random trials should typically give us 0.99999 reliability; we can assume
+    # the input is pathological and abort to fallback if we fail three trials.
+    seed = hash(ln, Int === Int64 ? 0x85eb830e0216012d : 0xae6c4e15)
+    for attempt in 1:3
+        seed = hash(attempt, seed)
+        for i in lo:lo+k2-1
+            j = mod(hash(i, seed), i:hi) # TODO for further optimization: be sneaky and remove this division
+            v[i], v[j] = v[j], v[i]
+        end
+        count_below, lastindex_middle = if lo_signpost_i <= lo && lastindex_sample <= hi_signpost_i
+            # The heuristics higher up in this function that dispatch to the `next`
+            # algorithm should prevent this from happening.
+            # Specifically, this means that expected_middle_ln == ln, so
+            # ln <= ... + 2.0expected_middle_ln && return ...
+            # will trigger.
+            @assert false
+            # But if it does happen, the kernel reduces to
+            0, hi
+        elseif lo_signpost_i <= lo
+            _sort!(v, a.get_next(hi_signpost_i), o, (;kw..., hi=lastindex_sample))
+            bracket_kernel!(v, lo, hi, nothing, v[hi_signpost_i], o)
+        elseif lastindex_sample <= hi_signpost_i
+            _sort!(v, a.get_next(lo_signpost_i), o, (;kw..., hi=lastindex_sample))
+            bracket_kernel!(v, lo, hi, v[lo_signpost_i], nothing, o)
+        else
+            # TODO for further optimization: don't sort the middle elements
+            _sort!(v, a.get_next(lo_signpost_i:hi_signpost_i), o, (;kw..., hi=lastindex_sample))
+            bracket_kernel!(v, lo, hi, v[lo_signpost_i], v[hi_signpost_i], o)
+        end
+        target_in_middle = target .- count_below
+        if lo <= minimum(target_in_middle) && maximum(target_in_middle) <= lastindex_middle
+            scratch = _sort!(v, a.get_next(target_in_middle), o, (;kw..., hi=lastindex_middle))
+            move!(v, target, target_in_middle)
+            return scratch
+        end
+        # This line almost never runs.
+    end
+    # This line only runs on pathological inputs. Make sure it's covered by tests :)
+    _sort!(v, a.get_next(target), o, kw)
+end
+
+
 """
     StableCheckSorted(next) <: Algorithm
 
diff --git a/test/sorting.jl b/test/sorting.jl
index edc6ca17cfde0..d88cc43a8e1f4 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -721,6 +721,8 @@ end
     for alg in safe_algs
         @test sort(1:n, alg=alg, lt = (i,j) -> v[i]<=v[j]) == perm
     end
+    # This could easily break with minor heuristic adjustments
+    # because partialsort is not even guaranteed to be stable:
     @test partialsort(1:n, 172, lt = (i,j) -> v[i]<=v[j]) == perm[172]
     @test partialsort(1:n, 315:415, lt = (i,j) -> v[i]<=v[j]) == perm[315:415]
 
@@ -1034,6 +1036,41 @@ end
     @test issorted(sort!(rand(100), Base.Sort.InitialOptimizations(DispatchLoopTestAlg()), Base.Order.Forward))
 end
 
+@testset "partialsort tests added for BracketedSort #52006" begin
+    x = rand(Int, 1000)
+    @test partialsort(x, 1) == minimum(x)
+    @test partialsort(x, 1000) == maximum(x)
+    sx = sort(x)
+    for i in [1, 2, 4, 10, 11, 425, 500, 845, 991, 997, 999, 1000]
+        @test partialsort(x, i) == sx[i]
+    end
+    for i in [1:1, 1:2, 1:5, 1:8, 1:9, 1:11, 1:108, 135:812, 220:586, 363:368, 450:574, 458:597, 469:638, 487:488, 500:501, 584:594, 1000:1000]
+        @test partialsort(x, i) == sx[i]
+    end
+
+    # Semi-pathological input
+    seed = hash(1000, Int === Int64 ? 0x85eb830e0216012d : 0xae6c4e15)
+    seed = hash(1, seed)
+    for i in 1:100
+        j = mod(hash(i, seed), i:1000)
+        x[j] = typemax(Int)
+    end
+    @test partialsort(x, 500) == sort(x)[500]
+
+    # Fully pathological input
+    # it would be too much trouble to actually construct a valid pathological input, so we
+    # construct an invalid pathological input.
+    # This test is kind of sketchy because it passes invalid inputs to the function
+    for i in [1:6, 1:483, 1:957, 77:86, 118:478, 223:227, 231:970, 317:958, 500:501, 500:501, 500:501, 614:620, 632:635, 658:665, 933:940, 937:942, 997:1000, 999:1000]
+        x = rand(1:5, 1000)
+        @test partialsort(x, i, lt=(<=)) == sort(x)[i]
+    end
+    for i in [1, 7, 8, 490, 495, 852, 993, 996, 1000]
+        x = rand(1:5, 1000)
+        @test partialsort(x, i, lt=(<=)) == sort(x)[i]
+    end
+end
+
 # This testset is at the end of the file because it is slow.
 @testset "searchsorted" begin
     numTypes = [ Int8,  Int16,  Int32,  Int64,  Int128,

From a386cd101ca8ff1775f38e2ec2fbeb7076a39c4f Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Fri, 24 Nov 2023 10:51:32 -0300
Subject: [PATCH 0318/1315] Fix multiversioning issues caused by the parallel
 llvm work (#52194)

So after struggling with this for a long while it seems there were two
different issues. The first one we lacked coverage over, but the other
was a very subtle issue when we sorted the fptrs.

~I still need to add test that does multiversioning where we call
between multiversioned functions~

Fixes https://github.com/JuliaLang/julia/issues/52079
---
 src/llvm-multiversioning.cpp           |   4 +-
 src/processor.cpp                      |   5 +-
 test/compiler/codegen.jl               |  13 +++
 test/llvmpasses/multiversioning-x86.ll | 132 +++++++++++++++++++++++++
 4 files changed, 151 insertions(+), 3 deletions(-)
 create mode 100644 test/llvmpasses/multiversioning-x86.ll

diff --git a/src/llvm-multiversioning.cpp b/src/llvm-multiversioning.cpp
index 83968cf344e72..cf6afaf153fb1 100644
--- a/src/llvm-multiversioning.cpp
+++ b/src/llvm-multiversioning.cpp
@@ -532,7 +532,7 @@ void CloneCtx::clone_decls()
             new_F->setVisibility(F->getVisibility());
             new_F->setDSOLocal(true);
             auto base_func = F;
-            if (specs[i].flags & JL_TARGET_CLONE_ALL)
+            if (!(specs[i].flags & JL_TARGET_CLONE_ALL))
                 base_func = static_cast<Group*>(linearized[specs[i].base])->base_func(F);
             (*linearized[i]->vmap)[base_func] = new_F;
         }
@@ -587,7 +587,7 @@ void CloneCtx::clone_bodies()
             }
             for (auto &target : groups[i].clones) {
                 prepare_vmap(*target.vmap);
-                auto target_F = cast_or_null<Function>(map_get(*target.vmap, F));
+                auto target_F = cast_or_null<Function>(map_get(*target.vmap, group_F));
                 if (target_F) {
                     if (!F->isDeclaration()) {
                         clone_function(group_F, target_F, *target.vmap);
diff --git a/src/processor.cpp b/src/processor.cpp
index 99e02215be4ea..ee521bd05c8b2 100644
--- a/src/processor.cpp
+++ b/src/processor.cpp
@@ -786,7 +786,10 @@ static inline jl_image_t parse_sysimg(void *hdl, F &&callback)
 
     if (!clones.empty()) {
         assert(!fvars.empty());
-        std::sort(clones.begin(), clones.end());
+        std::sort(clones.begin(), clones.end(),
+            [](const std::pair<uint32_t, const char *> &a, const std::pair<uint32_t, const char *> &b) {
+                return (a.first & jl_sysimg_val_mask) < (b.first & jl_sysimg_val_mask);
+        });
         auto clone_offsets = (int32_t *) malloc(sizeof(int32_t) * clones.size());
         auto clone_idxs = (uint32_t *) malloc(sizeof(uint32_t) * clones.size());
         for (size_t i = 0; i < clones.size(); i++) {
diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl
index a487d628f9f48..94396bf7a7a49 100644
--- a/test/compiler/codegen.jl
+++ b/test/compiler/codegen.jl
@@ -860,3 +860,16 @@ foo50964(1) # Shouldn't assert!
 # https://github.com/JuliaLang/julia/issues/51233
 obj51233 = (1,)
 @test_throws ErrorException obj51233.x
+
+# Very specific test for multiversioning
+if Sys.ARCH === :x86_64
+    foo52079() = Core.Intrinsics.have_fma(Float64)
+    if foo52079() == true
+        let io = IOBuffer()
+            code_native(io,^,(Float64,Float64), dump_module=false)
+            str = String(take!(io))
+            @test !occursin("fma_emulated", str)
+            @test occursin("vfmadd", str)
+        end
+    end
+end
diff --git a/test/llvmpasses/multiversioning-x86.ll b/test/llvmpasses/multiversioning-x86.ll
new file mode 100644
index 0000000000000..ca43462e1eda9
--- /dev/null
+++ b/test/llvmpasses/multiversioning-x86.ll
@@ -0,0 +1,132 @@
+; This file is a part of Julia. License is MIT: https://julialang.org/license
+
+; RUN: opt -enable-new-pm=1 --opaque-pointers=0 --load-pass-plugin=libjulia-codegen%shlibext -passes='JuliaMultiVersioning,CPUFeatures' -S %s | FileCheck %s
+
+; RUN: opt -enable-new-pm=1 --opaque-pointers=1 --load-pass-plugin=libjulia-codegen%shlibext -passes='JuliaMultiVersioning,CPUFeatures' -S %s | FileCheck %s
+
+; COM: This test checks that multiversioning actually happens from start to finish
+; COM: We need the fvars for a proper test
+
+
+
+; CHECK: @jl_fvar_idxs = hidden constant [5 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4], align 16
+; CHECK: @jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer, align 16
+; TYPED: @simd_test.reloc_slot = hidden global i32 (<4 x i32>)* null
+; OPAQUE: @simd_test.reloc_slot = hidden global ptr null
+; TYPED: @jl_fvar_offsets = hidden constant [6 x i32] [i32 5, i32 0, i32 trunc (i64 sub (i64 ptrtoint (float (float, float)* @fastmath_test to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (i32)* @loop_test to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test_call to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32)]
+; OPAQUE: @jl_fvar_offsets = hidden constant [6 x i32] [i32 5, i32 0, i32 trunc (i64 sub (i64 ptrtoint (ptr @fastmath_test to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @loop_test to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test_call to i64), i64 ptrtoint (ptr @boring to i64)) to i32)]
+; CHECK: @jl_gvar_base = hidden constant i64 0
+; CHECK: @jl_gvar_offsets = hidden constant [1 x i32] zeroinitializer
+; TYPED: @jl_clone_slots = hidden constant [3 x i32] [i32 1, i32 3, i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)** @simd_test.reloc_slot to i64), i64 ptrtoint (i64* @jl_gvar_base to i64)) to i32)]
+; OPAQUE: @jl_clone_slots = hidden constant [3 x i32] [i32 1, i32 3, i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test.reloc_slot to i64), i64 ptrtoint (ptr @jl_gvar_base to i64)) to i32)]
+; CHECK: @jl_clone_idxs = hidden constant [10 x i32] [i32 -2147483647, i32 3, i32 -2147483647, i32 3, i32 4, i32 1, i32 1, i32 2, i32 -2147483645, i32 4]
+; TYPED: @jl_clone_offsets = hidden constant [9 x i32] [i32 trunc (i64 sub (i64 ptrtoint (i32 (i32)* @boring.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (float (float, float)* @fastmath_test.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (i32)* @loop_test.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test_call.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (float (float, float)* @fastmath_test.2 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (i32)* @loop_test.2 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test.2 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test_call.2 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32)]
+; OPAQUE: @jl_clone_offsets = hidden constant [9 x i32] [i32 trunc (i64 sub (i64 ptrtoint (ptr @boring.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @fastmath_test.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @loop_test.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test_call.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @fastmath_test.2 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @loop_test.2 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test.2 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test_call.2 to i64), i64 ptrtoint (ptr @boring to i64)) to i32)]
+; TYPED: @jl_fvar_base = hidden alias i64, bitcast (i32 (i32)* @boring to i64*)
+; OPAQUE: @jl_fvar_base = hidden alias i64, ptr @boring
+
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12:13"
+target triple = "x86_64-linux-gnu"
+
+@jl_fvars = global [5 x i64*] [i64* bitcast (i32 (i32)* @boring to i64*),
+                               i64* bitcast (float (float, float)* @fastmath_test to i64*),
+                               i64* bitcast (i32 (i32)* @loop_test to i64*),
+                               i64* bitcast (i32 (<4 x i32>)* @simd_test to i64*),
+                               i64* bitcast (i32 (<4 x i32>)* @simd_test_call to i64*)
+                              ], align 16
+@jl_gvars = global [0 x i64*] zeroinitializer, align 16
+@jl_fvar_idxs = hidden constant [5 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4], align 16
+@jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer, align 16
+
+declare i1 @julia.cpu.have_fma.f32()
+
+; CHECK: @boring{{.*}}#[[BORING_BASE:[0-9]+]]
+define noundef i32 @boring(i32 noundef %0) {
+  ret i32 %0
+}
+
+; CHECK: @fastmath_test{{.*}}#[[NOT_BORING_BASE:[0-9]+]]
+; CHECK: %3 = sitofp i1 false to float
+define noundef float @fastmath_test(float noundef %0, float noundef %1) {
+  %3 = call i1 @julia.cpu.have_fma.f32()
+  %4 = sitofp i1 %3 to float
+  %5 = fadd fast float %0, %4
+  ret float %5
+}
+
+; CHECK: @loop_test{{.*}}#[[NOT_BORING_BASE:[0-9]+]]
+define noundef i32 @loop_test(i32 noundef %0) {
+  %2 = icmp sgt i32 %0, 0
+  br i1 %2, label %5, label %3
+
+3:                                                ; preds = %5, %1
+  %4 = phi i32 [ 0, %1 ], [ %9, %5 ]
+  ret i32 %4
+
+5:                                                ; preds = %1, %5
+  %6 = phi i32 [ %10, %5 ], [ 0, %1 ]
+  %7 = phi i32 [ %9, %5 ], [ 0, %1 ]
+  %8 = lshr i32 %6, 1
+  %9 = add nuw nsw i32 %8, %7
+  %10 = add nuw nsw i32 %6, 1
+  %11 = icmp eq i32 %10, %0
+  br i1 %11, label %3, label %5;, !llvm.loop -
+}
+
+; CHECK: @simd_test{{.*}}#[[SIMD_BASE_RELOC:[0-9]+]]
+define noundef i32 @simd_test(<4 x i32> noundef %0) {
+  %2 = extractelement <4 x i32> %0, i64 0
+  ret i32 %2
+}
+
+; CHECK: @simd_test_call{{.*}}#[[NOT_BORING_BASE:[0-9]+]]
+define noundef i32 @simd_test_call(<4 x i32> noundef %0) {
+  %2 = call noundef i32 @simd_test(<4 x i32> noundef %0)
+  ret i32 %2
+}
+
+; CHECK: @boring{{.*}}#[[BORING_CLONE:[0-9]+]]
+
+; CHECK: @fastmath_test{{.*}}#[[NOT_BORING_CLONE1:[0-9]+]]
+; CHECK: %3 = sitofp i1 false to float
+
+; CHECK: @fastmath_test{{.*}}#[[NOT_BORING_CLONE2:[0-9]+]]
+; CHECK: %3 = sitofp i1 true to float
+
+; CHECK: @loop_test{{.*}}#[[NOT_BORING_CLONE1:[0-9]+]]
+
+; CHECK: @loop_test{{.*}}#[[NOT_BORING_CLONE2:[0-9]+]]
+
+; CHECK: @simd_test{{.*}}#[[SIMD_CLONE1:[0-9]+]]
+
+; CHECK: @simd_test{{.*}}#[[SIMD_CLONE2:[0-9]+]]
+
+; CHECK: @simd_test_call{{.*}}#[[NOT_BORING_CLONE1:[0-9]+]]
+; TYPED: %2 = load i32 (<4 x i32>)*, i32 (<4 x i32>)** @simd_test.reloc_slot, align 8, !tbaa !8, !invariant.load !12
+; OPAQUE: %2 = load ptr, ptr @simd_test.reloc_slot, align 8, !tbaa !8, !invariant.load !12
+; CHECK: %3 = call noundef i32 %2(<4 x i32> noundef %0)
+
+; CHECK: @simd_test_call{{.*}}#[[NOT_BORING_CLONE2:[0-9]+]]
+; CHECK: %2 = call noundef i32 @simd_test.2(<4 x i32> noundef %0)
+
+; CHECK-DAG: attributes #[[BORING_BASE]] = { "julia.mv.clone"="0" "julia.mv.clones"="2" "julia.mv.fvar" "target-cpu"="x86-64" "target-features"="+cx16,-sse3,-pclmul,-ssse3,-fma,-sse4.1,-sse4.2,-movbe,-popcnt,-aes,-xsave,-avx,-f16c,-rdrnd,-fsgsbase,-bmi,-avx2,-bmi2,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-sahf,-lzcnt,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8" }
+; CHECK-DAG: attributes #[[NOT_BORING_BASE]] = { "julia.mv.clone"="0" "julia.mv.clones"="6" "julia.mv.fvar" "target-cpu"="x86-64" "target-features"="+cx16,-sse3,-pclmul,-ssse3,-fma,-sse4.1,-sse4.2,-movbe,-popcnt,-aes,-xsave,-avx,-f16c,-rdrnd,-fsgsbase,-bmi,-avx2,-bmi2,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-sahf,-lzcnt,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8" }
+; CHECK-DAG: attributes #[[SIMD_BASE_RELOC]] = { "julia.mv.clone"="0" "julia.mv.clones"="6" "julia.mv.reloc" "target-cpu"="x86-64" "target-features"="+cx16,-sse3,-pclmul,-ssse3,-fma,-sse4.1,-sse4.2,-movbe,-popcnt,-aes,-xsave,-avx,-f16c,-rdrnd,-fsgsbase,-bmi,-avx2,-bmi2,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-sahf,-lzcnt,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8" }
+; CHECK-DAG: attributes #[[BORING_CLONE]] = { "julia.mv.clone"="1" "julia.mv.clones"="2" "julia.mv.fvar" "target-cpu"="sandybridge" "target-features"="+sahf,+avx,+xsave,+popcnt,+sse4.2,+sse4.1,+cx16,+ssse3,+pclmul,+sse3,-fma,-movbe,-aes,-f16c,-rdrnd,-fsgsbase,-bmi,-avx2,-bmi2,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-lzcnt,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8" }
+; CHECK-DAG: attributes #[[NOT_BORING_CLONE1]] = { "julia.mv.clone"="1" "julia.mv.clones"="6" "julia.mv.fvar" "target-cpu"="sandybridge" "target-features"="+sahf,+avx,+xsave,+popcnt,+sse4.2,+sse4.1,+cx16,+ssse3,+pclmul,+sse3,-fma,-movbe,-aes,-f16c,-rdrnd,-fsgsbase,-bmi,-avx2,-bmi2,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-lzcnt,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8" }
+; CHECK-DAG: attributes #[[NOT_BORING_CLONE2]] =  { "julia.mv.clone"="2" "julia.mv.clones"="6" "julia.mv.fvar" "target-cpu"="haswell" "target-features"="+lzcnt,+sahf,+bmi2,+avx2,+bmi,+fsgsbase,+f16c,+avx,+xsave,+popcnt,+movbe,+sse4.2,+sse4.1,+cx16,+fma,+ssse3,+pclmul,+sse3,-aes,-rdrnd,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8" }
+; CHECK-DAG: attributes #[[SIMD_CLONE1]] = { "julia.mv.clone"="1" "julia.mv.clones"="6" "julia.mv.reloc" "target-cpu"="sandybridge" "target-features"="+sahf,+avx,+xsave,+popcnt,+sse4.2,+sse4.1,+cx16,+ssse3,+pclmul,+sse3,-fma,-movbe,-aes,-f16c,-rdrnd,-fsgsbase,-bmi,-avx2,-bmi2,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-lzcnt,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8" }
+; CHECK-DAG: attributes #[[SIMD_CLONE2]] = { "julia.mv.clone"="2" "julia.mv.clones"="6" "julia.mv.reloc" "target-cpu"="haswell" "target-features"="+lzcnt,+sahf,+bmi2,+avx2,+bmi,+fsgsbase,+f16c,+avx,+xsave,+popcnt,+movbe,+sse4.2,+sse4.1,+cx16,+fma,+ssse3,+pclmul,+sse3,-aes,-rdrnd,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8" }
+
+
+!llvm.module.flags = !{!0, !2}
+
+
+!0 = !{i32 1, !"julia.mv.enable", i32 1}
+!1 = !{!1}
+!2 = !{i32 1, !"julia.mv.specs", !3}
+!3 = !{!4, !5, !6}
+!4 = !{!"x86-64", !"+cx16,-sse3,-pclmul,-ssse3,-fma,-sse4.1,-sse4.2,-movbe,-popcnt,-aes,-xsave,-avx,-f16c,-rdrnd,-fsgsbase,-bmi,-avx2,-bmi2,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-sahf,-lzcnt,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8", i32 0, i32 0}
+!5 = !{!"sandybridge", !"+sahf,+avx,+xsave,+popcnt,+sse4.2,+sse4.1,+cx16,+ssse3,+pclmul,+sse3,-fma,-movbe,-aes,-f16c,-rdrnd,-fsgsbase,-bmi,-avx2,-bmi2,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-lzcnt,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8", i32 0, i32 2}
+!6 = !{!"haswell", !"+lzcnt,+sahf,+bmi2,+avx2,+bmi,+fsgsbase,+f16c,+avx,+xsave,+popcnt,+movbe,+sse4.2,+sse4.1,+cx16,+fma,+ssse3,+pclmul,+sse3,-aes,-rdrnd,-rtm,-avx512f,-avx512dq,-rdseed,-adx,-avx512ifma,-clflushopt,-clwb,-avx512pf,-avx512er,-avx512cd,-sha,-avx512bw,-avx512vl,-prefetchwt1,-avx512vbmi,-pku,-waitpkg,-avx512vbmi2,-shstk,-gfni,-vaes,-vpclmulqdq,-avx512vnni,-avx512bitalg,-avx512vpopcntdq,-rdpid,-cldemote,-movdiri,-movdir64b,-enqcmd,-uintr,-avx512vp2intersect,-serialize,-tsxldtrk,-pconfig,-amx-bf16,-avx512fp16,-amx-tile,-amx-int8,-sse4a,-prfchw,-xop,-fma4,-tbm,-mwaitx,-xsaveopt,-xsavec,-xsaves,-clzero,-wbnoinvd,-avxvnni,-avx512bf16,-ptwrite,+sse2,+mmx,+fxsr,+64bit,+cx8", i32 1, i32 284}

From 6e23543bc477eb46e5fc8d5cab119190b990ed7c Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 24 Nov 2023 10:26:51 -0500
Subject: [PATCH 0319/1315] Fix off-by-2 in codegen (#52292)

This is cherry-picked from #52245. This is an independent bugfix, and
looks like #52245 might need another round of discussion.

There were two separate off-by-1's in the codegen code that is trying to
detect assignments to slots inside try/catch regions.

First, it was asking to include the value of the catch label, which is
actually the first statement *not* in the try region. Second, there was
a confusion of 0 and 1 based indexing in the iteration bounds. The end
result of this was that the code was also looking at the first two
statements of the catch region.

This wasn't a problem before #52245 (other than a potentially
over-conservative marking of some slots as volatile), because our catch
blocks always had at least two statements (a :leave and a terminator),
but with the `:leave` change, it is possible to have catch blocks with
only one statement. If these happened to be at the end of the function,
things would blow up.

As a side node, this code isn't particularly sound, because it assumes
that try/catch regions are lexical, which they are not. The assumption
happens to work out ok for the code we generate in the frontend and
optimized IR doesn't have slots, so we don't use this code, but it is
not in general sound.
---
 src/codegen.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/codegen.cpp b/src/codegen.cpp
index 42a62bae4bd80..45b20e0044847 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -2924,7 +2924,7 @@ static bool local_var_occurs(jl_value_t *e, int sl)
 static std::set<int> assigned_in_try(jl_array_t *stmts, int s, long l)
 {
     std::set<int> av;
-    for(int i=s; i <= l; i++) {
+    for(int i=s; i < l; i++) {
         jl_value_t *st = jl_array_ptr_ref(stmts,i);
         if (jl_is_expr(st)) {
             if (((jl_expr_t*)st)->head == jl_assign_sym) {
@@ -2946,7 +2946,7 @@ static void mark_volatile_vars(jl_array_t *stmts, SmallVectorImpl<jl_varinfo_t>
         if (jl_is_expr(st)) {
             if (((jl_expr_t*)st)->head == jl_enter_sym) {
                 int last = jl_unbox_long(jl_exprarg(st, 0));
-                std::set<int> as = assigned_in_try(stmts, i + 1, last);
+                std::set<int> as = assigned_in_try(stmts, i + 1, last - 1);
                 for (int j = 0; j < (int)slength; j++) {
                     if (j < i || j > last) {
                         std::set<int>::iterator it = as.begin();

From 9e8fe688c5e32bde3ab48bb71f9d4ab45ef272ee Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Fri, 24 Nov 2023 17:35:51 -0500
Subject: [PATCH 0320/1315] Turn Method Overwritten Error into a
 PrecompileError -- turning off caching (#52214)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes #52213

Overwritting methods during cache creation is currently not something
that the system
can support and can lead to surprising, counter-intuitive and fatal
errors.

In 1.10 we turned it from a warning to a strong error, with this PR it
remains
a strong error, but the precompilation system recognizes it and
essentially sets `__precompile__(false)`
for this module and all modules that depend on it.

Before:
```
julia> using OverwriteMethodError
[ Info: Precompiling OverwriteMethodError [top-level]
WARNING: Method definition +(Bool, Bool) in module Base at bool.jl:166 overwritten in module OverwriteMethodError at /home/vchuravy/src/julia2/OverwriteMethodError.jl:2.
ERROR: LoadError: Method overwriting is not permitted during Module precompile.
Stacktrace:
 [1] top-level scope
   @ ~/src/julia2/OverwriteMethodError.jl:2
 [2] include
   @ Base ./Base.jl:489 [inlined]
 [3] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
   @ Base ./loading.jl:2216
 [4] top-level scope
   @ stdin:3
in expression starting at /home/vchuravy/src/julia2/OverwriteMethodError.jl:1
in expression starting at stdin:3
ERROR: Failed to precompile OverwriteMethodError [top-level] to "/home/vchuravy/.julia/compiled/v1.10/jl_guiuCQ".
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:35
  [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)
    @ Base ./loading.jl:2462
  [3] compilecache
    @ Base ./loading.jl:2334 [inlined]
  [4] (::Base.var"#968#969"{Base.PkgId})()
    @ Base ./loading.jl:1968
  [5] mkpidlock(f::Base.var"#968#969"{Base.PkgId}, at::String, pid::Int32; kwopts::@Kwargs{stale_age::Int64, wait::Bool})
    @ FileWatching.Pidfile ~/.julia/juliaup/julia-1.10.0-rc1+0.x64.linux.gnu/share/julia/stdlib/v1.10/FileWatching/src/pidfile.jl:93
  [6] #mkpidlock#6
    @ FileWatching.Pidfile ~/.julia/juliaup/julia-1.10.0-rc1+0.x64.linux.gnu/share/julia/stdlib/v1.10/FileWatching/src/pidfile.jl:88 [inlined]
  [7] trymkpidlock(::Function, ::Vararg{Any}; kwargs::@Kwargs{stale_age::Int64})
    @ FileWatching.Pidfile ~/.julia/juliaup/julia-1.10.0-rc1+0.x64.linux.gnu/share/julia/stdlib/v1.10/FileWatching/src/pidfile.jl:111
  [8] #invokelatest#2
    @ Base ./essentials.jl:889 [inlined]
  [9] invokelatest
    @ Base ./essentials.jl:884 [inlined]
 [10] maybe_cachefile_lock(f::Base.var"#968#969"{Base.PkgId}, pkg::Base.PkgId, srcpath::String; stale_age::Int64)
    @ Base ./loading.jl:2977
 [11] maybe_cachefile_lock
    @ Base ./loading.jl:2974 [inlined]
 [12] _require(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:1964
 [13] __require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:1806
 [14] #invoke_in_world#3
    @ Base ./essentials.jl:921 [inlined]
 [15] invoke_in_world
    @ Base ./essentials.jl:918 [inlined]
 [16] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:1797
 [17] macro expansion
    @ Base ./loading.jl:1784 [inlined]
 [18] macro expansion
    @ Base ./lock.jl:267 [inlined]
 [19] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:1747
 [20] #invoke_in_world#3
    @ Base ./essentials.jl:921 [inlined]
 [21] invoke_in_world
    @ Base ./essentials.jl:918 [inlined]
 [22] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:1740
```

After:
```
julia> using OverwriteMethodError
┌ Info: Precompiling OverwriteMethodError [top-level]
└ @ Base loading.jl:2486
WARNING: Method definition +(Bool, Bool) in module Base at bool.jl:166 overwritten in module OverwriteMethodError at /home/vchuravy/src/julia2/OverwriteMethodError.jl:2.
ERROR: Method overwriting is not permitted during Module precompile.
┌ Info: Skipping precompilation since __precompile__(false). Importing OverwriteMethodError [top-level].
└ @ Base loading.jl:2084
```

---------

Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
---
 base/boot.jl             |  2 ++
 base/loading.jl          |  2 +-
 src/gf.c                 |  6 ++++--
 src/jl_exported_data.inc |  1 +
 src/jltypes.c            |  1 +
 src/julia.h              |  1 +
 src/staticdata.c         |  3 ++-
 test/precompile.jl       | 10 ++++++++++
 8 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 056b14fa5d0ac..2dc19528e178e 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -413,6 +413,8 @@ struct InitError <: WrappedException
     error
 end
 
+struct PrecompilableError <: Exception end
+
 String(s::String) = s  # no constructor yet
 
 const Cvoid = Nothing
diff --git a/base/loading.jl b/base/loading.jl
index 9a3a922298f1e..95b83e84aad15 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1745,7 +1745,7 @@ function include_dependency(path::AbstractString)
 end
 
 # we throw PrecompilableError when a module doesn't want to be precompiled
-struct PrecompilableError <: Exception end
+import Core: PrecompilableError
 function show(io::IO, ex::PrecompilableError)
     print(io, "Error when precompiling module, potentially caused by a __precompile__(false) declaration in the module.")
 end
diff --git a/src/gf.c b/src/gf.c
index fffeb928a1889..5013706030777 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1572,8 +1572,10 @@ static void method_overwrite(jl_typemap_entry_t *newentry, jl_method_t *oldvalue
         jl_printf(s, ".\n");
         jl_uv_flush(s);
     }
-    if (jl_generating_output())
-        jl_error("Method overwriting is not permitted during Module precompile.");
+    if (jl_generating_output()) {
+        jl_printf(JL_STDERR, "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n");
+        jl_throw(jl_precompilable_error);
+    }
 }
 
 static void update_max_args(jl_methtable_t *mt, jl_value_t *type)
diff --git a/src/jl_exported_data.inc b/src/jl_exported_data.inc
index b6b9774c1538e..1a843c71f0e1e 100644
--- a/src/jl_exported_data.inc
+++ b/src/jl_exported_data.inc
@@ -145,6 +145,7 @@
     XX(jl_weakref_type) \
     XX(jl_libdl_module) \
     XX(jl_libdl_dlopen_func) \
+    XX(jl_precompilable_error) \
 
 // Data symbols that are defined inside the public libjulia
 #define JL_EXPORTED_DATA_SYMBOLS(XX) \
diff --git a/src/jltypes.c b/src/jltypes.c
index c7c7d213c5317..a30d746bbb320 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3510,6 +3510,7 @@ void post_boot_hooks(void)
     jl_loaderror_type      = (jl_datatype_t*)core("LoadError");
     jl_initerror_type      = (jl_datatype_t*)core("InitError");
     jl_missingcodeerror_type = (jl_datatype_t*)core("MissingCodeError");
+    jl_precompilable_error = jl_new_struct_uninit((jl_datatype_t*)core("PrecompilableError"));
     jl_pair_type           = core("Pair");
     jl_kwcall_func         = core("kwcall");
     jl_kwcall_mt           = ((jl_datatype_t*)jl_typeof(jl_kwcall_func))->name->mt;
diff --git a/src/julia.h b/src/julia.h
index 5198bcab5a2bd..d728458f50180 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -837,6 +837,7 @@ extern JL_DLLIMPORT jl_value_t *jl_readonlymemory_exception JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_diverror_exception JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_undefref_exception JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_interrupt_exception JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_precompilable_error JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_boundserror_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_an_empty_vec_any JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_an_empty_memory_any JL_GLOBALLY_ROOTED;
diff --git a/src/staticdata.c b/src/staticdata.c
index 42a5fdb63b63e..52a354b4933d7 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -98,7 +98,7 @@ extern "C" {
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
-#define NUM_TAGS    174
+#define NUM_TAGS    175
 
 // An array of references that need to be restored from the sysimg
 // This is a manually constructed dual of the gvars array, which would be produced by codegen for Julia code, for C.
@@ -237,6 +237,7 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_readonlymemory_exception);
         INSERT_TAG(jl_atomicerror_type);
         INSERT_TAG(jl_missingcodeerror_type);
+        INSERT_TAG(jl_precompilable_error);
 
         // other special values
         INSERT_TAG(jl_emptysvec);
diff --git a/test/precompile.jl b/test/precompile.jl
index 051b750fa7fdf..1ac3999947736 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -571,6 +571,16 @@ precompile_test_harness(false) do dir
 
     @test Base.compilecache(Base.PkgId("Baz")) == Base.PrecompilableError() # due to __precompile__(false)
 
+    OverwriteMethodError_file = joinpath(dir, "OverwriteMethodError.jl")
+    write(OverwriteMethodError_file,
+          """
+          module OverwriteMethodError
+              Base.:(+)(x::Bool, y::Bool) = false
+          end
+          """)
+
+    @test Base.compilecache(Base.PkgId("OverwriteMethodError")) == Base.PrecompilableError() # due to piracy
+
     UseBaz_file = joinpath(dir, "UseBaz.jl")
     write(UseBaz_file,
           """

From 9c5def518b71426b3aad7ba742670b08ecba657d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Leandro=20Mart=C3=ADnez?=
 <31046348+lmiq@users.noreply.github.com>
Date: Fri, 24 Nov 2023 22:05:06 -0300
Subject: [PATCH 0321/1315] docs: simpler example for randn (#52252)

As noted here:
https://discourse.julialang.org/t/how-do-we-julians-win-big-when-the-situation-is-so-unfair/106433/63?u=lmiq

The randn example is overly complicated and does not indicate the
simplest usage, which is probably the most typical one.

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 stdlib/Random/src/normal.jl | 46 +++++++++++++++++++++++++++++--------
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/stdlib/Random/src/normal.jl b/stdlib/Random/src/normal.jl
index bbc1b03e50b5d..9f663495c1c20 100644
--- a/stdlib/Random/src/normal.jl
+++ b/stdlib/Random/src/normal.jl
@@ -14,25 +14,51 @@
 
 Generate a normally-distributed random number of type `T`
 with mean 0 and standard deviation 1.
-Optionally generate an array of normally-distributed random numbers.
-The `Base` module currently provides an implementation for the types
-[`Float16`](@ref), [`Float32`](@ref), and [`Float64`](@ref) (the default), and their
-[`Complex`](@ref) counterparts. When the type argument is complex, the values are drawn
-from the circularly symmetric complex normal distribution of variance 1 (corresponding to real and imaginary part having independent normal distribution with mean zero and variance `1/2`).
+Given the optional `dims` argument(s), generate an array of size `dims` of such numbers.
+Julia's standard library supports `randn` for any floating-point type
+that implements [`rand`](@ref), e.g. the `Base` types
+[`Float16`](@ref), [`Float32`](@ref), [`Float64`](@ref) (the default), and [`BigFloat`](@ref),
+along with their [`Complex`](@ref) counterparts.
+
+(When `T` is complex, the values are drawn
+from the circularly symmetric complex normal distribution of variance 1, corresponding to real and imaginary parts
+having independent normal distribution with mean zero and variance `1/2`).
 
 See also [`randn!`](@ref) to act in-place.
 
 # Examples
+
+Generating a single random number (with the default `Float64` type):
+
+```julia-repl
+julia> randn()
+-0.942481877315864
+```
+
+Generating a matrix of normal random numbers (with the default `Float64` type):
+
+```julia-repl
+julia> randn(2,3)
+2×3 Matrix{Float64}:
+  1.18786   -0.678616   1.49463
+ -0.342792  -0.134299  -1.45005
+```
+
+Setting up of the random number generator `rng` with a user-defined seed (for reproducible numbers)
+and using it to generate a random `Float32` number or a matrix of `ComplexF32` random numbers:
+
 ```jldoctest
-julia> using Random; rng = Xoshiro(123);
+julia> using Random
+
+julia> rng = Xoshiro(123);
 
-julia> randn(rng, ComplexF64)
--0.45660053706486897 - 1.0346749725929225im
+julia> randn(rng, Float32)
+-0.6457307f0
 
 julia> randn(rng, ComplexF32, (2, 3))
 2×3 Matrix{ComplexF32}:
- -1.14806-0.153912im   0.056538+1.0954im      0.419454-0.543347im
-  0.34807+0.693657im  -0.948661+0.291442im  -0.0538589-0.463085im
+  -1.03467-1.14806im  0.693657+0.056538im   0.291442+0.419454im
+ -0.153912+0.34807im    1.0954-0.948661im  -0.543347-0.0538589im
 ```
 """
 @inline function randn(rng::AbstractRNG=default_rng())

From 93d474052925323421ed1d95667b650e593163f5 Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Sat, 25 Nov 2023 02:11:40 +0100
Subject: [PATCH 0322/1315] Document and export `Base.in!` (#51636)

I think `in!` is a useful general function for users, and would be good
to have as official API. Its semantics is clear and unambiguous, while
providing a clear performance advantage over the naive implementation.

For more evidence that this functionality is useful, consider:
* Rust's `HashSet::insert` works just like this implementation of `in!`
* This function was already used in the implementation of `Base.unique`,
precisely for the performance over the naive approach

Comes from #45156 with some initial discussion.
---
 NEWS.md                     |  1 +
 base/exports.jl             |  1 +
 base/set.jl                 | 42 +++++++++++++++++++++++++++++++++----
 doc/src/base/collections.md |  1 +
 test/sets.jl                | 25 ++++++++++++++++++++++
 5 files changed, 66 insertions(+), 4 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index c9b968da3c1e0..30a4c1af21d89 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -54,6 +54,7 @@ Build system changes
 New library functions
 ---------------------
 
+* `in!(x, s::AbstractSet)` will return whether `x` is in `s`, and insert `x` in `s` if not.
 * The new `Libc.mkfifo` function wraps the `mkfifo` C function on Unix platforms ([#34587]).
 * `hardlink(src, dst)` can be used to create hard links ([#41639]).
 * `diskstat(path=pwd())` can be used to return statistics about the disk ([#42248]).
diff --git a/base/exports.jl b/base/exports.jl
index b6f7ea0d6ad35..398d828f9cf19 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -532,6 +532,7 @@ export
     getkey,
     haskey,
     in,
+    in!,
     intersect!,
     intersect,
     isdisjoint,
diff --git a/base/set.jl b/base/set.jl
index 489673945ea1f..07c857fab3213 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -91,12 +91,46 @@ isempty(s::Set) = isempty(s.dict)
 length(s::Set)  = length(s.dict)
 in(x, s::Set) = haskey(s.dict, x)
 
-# This avoids hashing and probing twice and it works the same as
-# in!(x, s::Set) = in(x, s) ? true : (push!(s, x); false)
+"""
+    in!(x, s::AbstractSet) -> Bool
+
+If `x` is in `s`, return `true`. If not, push `x` into `s` and return `false`.
+This is equivalent to `in(x, s) ? true : (push!(s, x); false)`, but may have a
+more efficient implementation.
+
+See also: [`in`](@ref), [`push!`](@ref), [`Set`](@ref)
+
+!!! compat "Julia 1.11"
+    This function requires at least 1.11.
+
+# Examples
+```jldoctest; filter = r"^  [1234]\$"
+julia> s = Set{Any}([1, 2, 3]); in!(4, s)
+false
+
+julia> length(s)
+4
+
+julia> in!(0x04, s)
+true
+
+julia> s
+Set{Any} with 4 elements:
+  4
+  2
+  3
+  1
+```
+"""
+function in!(x, s::AbstractSet)
+    x ∈ s ? true : (push!(s, x); false)
+end
+
 function in!(x, s::Set)
-    idx, sh = ht_keyindex2_shorthash!(s.dict, x)
+    xT = convert(eltype(s), x)
+    idx, sh = ht_keyindex2_shorthash!(s.dict, xT)
     idx > 0 && return true
-    _setindex!(s.dict, nothing, x, -idx, sh)
+    _setindex!(s.dict, nothing, xT, -idx, sh)
     return false
 end
 
diff --git a/doc/src/base/collections.md b/doc/src/base/collections.md
index a8f2bdc6b7d7d..23cb8d6dab7c2 100644
--- a/doc/src/base/collections.md
+++ b/doc/src/base/collections.md
@@ -255,6 +255,7 @@ Base.symdiff
 Base.symdiff!
 Base.intersect!
 Base.issubset
+Base.in!
 Base.:⊈
 Base.:⊊
 Base.issetequal
diff --git a/test/sets.jl b/test/sets.jl
index 19ccf3bf3701e..2e7e19c5c1cdf 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -133,6 +133,31 @@ end
     @test pop!(s, 4) === 4.0
     @test_throws KeyError pop!(s, 5)
 end
+
+@testset "in!" begin
+    s = Set()
+    @test !(in!(0x01, s))
+    @test !(in!(Int32(2), s))
+    @test in!(1, s)
+    @test in!(2.0, s)
+    (a, b, c...) = sort!(collect(s))
+    @test a === 0x01
+    @test b === Int32(2)
+    @test isempty(c)
+
+    # in! will convert to the right type automatically
+    s = Set{Int32}()
+    @test !(in!(1, s))
+    @test only(s) === Int32(1)
+    @test_throws Exception in!("hello", s)
+
+    # Other set types
+    s = BitSet()
+    @test !(in!(13, s))
+    @test in!(UInt16(13), s)
+    @test only(s) === 13
+end
+
 @testset "copy" begin
     data_in = (1,2,9,8,4)
     s = Set(data_in)

From c1fc9858d9d8643e4d8951f26220140d66f70198 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sat, 25 Nov 2023 11:23:33 +0900
Subject: [PATCH 0323/1315] irinterp: improve semi-concrete interpretation
 accuracy (#52275)

By enforcing re-inference on calls with all constant arguments.

While it's debatable whether this approach is the most efficient, it was
the easiest choice given that `used_ssas` based on `IncrementaCompact`
wasn't an option for irinterp.

- fixes #52202
- fixes #50037
---
 base/compiler/abstractinterpretation.jl |  6 ++++--
 base/compiler/ssair/ir.jl               |  2 +-
 base/compiler/ssair/irinterp.jl         | 12 ++++++++++++
 stdlib/LinearAlgebra/test/matmul.jl     |  4 ++++
 test/compiler/inference.jl              |  7 +++++++
 5 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 24d5eb52c1ffb..8c6840a4b0706 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -903,12 +903,14 @@ end
 is_all_const_arg(arginfo::ArgInfo, start::Int) = is_all_const_arg(arginfo.argtypes, start::Int)
 function is_all_const_arg(argtypes::Vector{Any}, start::Int)
     for i = start:length(argtypes)
-        a = widenslotwrapper(argtypes[i])
-        isa(a, Const) || isconstType(a) || issingletontype(a) || return false
+        argtype = widenslotwrapper(argtypes[i])
+        is_const_argtype(argtype) || return false
     end
     return true
 end
 
+is_const_argtype(@nospecialize argtype) = isa(argtype, Const) || isconstType(argtype) || issingletontype(argtype)
+
 any_conditional(argtypes::Vector{Any}) = any(@nospecialize(x)->isa(x, Conditional), argtypes)
 any_conditional(arginfo::ArgInfo) = any_conditional(arginfo.argtypes)
 
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 5c347846e6e18..9b89b30854cdf 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -956,7 +956,7 @@ function insert_node_here!(compact::IncrementalCompact, newinst::NewInstruction,
     return inst
 end
 
-function delete_inst_here!(compact)
+function delete_inst_here!(compact::IncrementalCompact)
     # Delete the statement, update refcounts etc
     compact[SSAValue(compact.result_idx-1)] = nothing
     # Pretend that we never compacted this statement in the first place
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 9f8bc17beca7f..be072ca64e1c4 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -278,6 +278,15 @@ end
 populate_def_use_map!(tpdum::TwoPhaseDefUseMap, ir::IRCode) =
     populate_def_use_map!(tpdum, BBScanner(ir))
 
+function is_all_const_call(@nospecialize(stmt), interp::AbstractInterpreter, irsv::IRInterpretationState)
+    isexpr(stmt, :call) || return false
+    @inbounds for i = 2:length(stmt.args)
+        argtype = abstract_eval_value(interp, stmt.args[i], nothing, irsv)
+        is_const_argtype(argtype) || return false
+    end
+    return true
+end
+
 function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IRInterpretationState;
         externally_refined::Union{Nothing,BitSet} = nothing)
     (; ir, tpdum, ssa_refined) = irsv
@@ -302,6 +311,9 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
         if has_flag(flag, IR_FLAG_REFINED)
             any_refined = true
             sub_flag!(inst, IR_FLAG_REFINED)
+        elseif is_all_const_call(stmt, interp, irsv)
+            # force reinference on calls with all constant arguments
+            any_refined = true
         end
         for ur in userefs(stmt)
             val = ur[]
diff --git a/stdlib/LinearAlgebra/test/matmul.jl b/stdlib/LinearAlgebra/test/matmul.jl
index 30cc74694b3f4..afdc02534728a 100644
--- a/stdlib/LinearAlgebra/test/matmul.jl
+++ b/stdlib/LinearAlgebra/test/matmul.jl
@@ -23,6 +23,10 @@ mul_wrappers = [
     @test @inferred(f(A)) === A
     g(A) = LinearAlgebra.wrap(A, 'T')
     @test @inferred(g(A)) === transpose(A)
+    # https://github.com/JuliaLang/julia/issues/52202
+    @test Base.infer_return_type((Vector{Float64},)) do v
+        LinearAlgebra.wrap(v, 'N')
+    end == Vector{Float64}
 end
 
 @testset "matrices with zero dimensions" begin
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 9e06d120e501f..88bd4d8fba007 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5592,6 +5592,13 @@ end |> only === Float64
 @test Base.infer_exception_type(c::Missing -> c ? 1 : 2) == TypeError
 @test Base.infer_exception_type(c::Any -> c ? 1 : 2) == TypeError
 
+# semi-concrete interpretation accuracy
+# https://github.com/JuliaLang/julia/issues/50037
+@inline countvars50037(bitflags::Int, var::Int) = bitflags >> 0
+@test Base.infer_return_type() do var::Int
+    Val(countvars50037(1, var))
+end == Val{1}
+
 # Issue #52168
 f52168(x, t::Type) = x::NTuple{2, Base.inferencebarrier(t)::Type}
 @test f52168((1, 2.), Any) === (1, 2.)

From 3bdf9d597ff7212be920ef191f0b92b44591bb12 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sat, 25 Nov 2023 11:26:01 +0900
Subject: [PATCH 0324/1315] inference: optimize call to `builtin_tfunction`
 (#52284)

By avoiding unnecessary copy of `argtypes[2:end]`.
---
 base/compiler/abstractinterpretation.jl | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 8c6840a4b0706..6563f5589c71d 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1781,7 +1781,9 @@ function abstract_call_builtin(interp::AbstractInterpreter, f::Builtin, (; fargs
             end
         end
     end
-    rt = builtin_tfunction(interp, f, argtypes[2:end], sv)
+    ft = popfirst!(argtypes)
+    rt = builtin_tfunction(interp, f, argtypes, sv)
+    pushfirst!(argtypes, ft)
     if has_mustalias(𝕃ᵢ) && f === getfield && isa(fargs, Vector{Any}) && la ≥ 3
         a3 = argtypes[3]
         if isa(a3, Const)

From da48487db65a997127179b0f31b5effd291d27a4 Mon Sep 17 00:00:00 2001
From: Mason Protter <mason.protter@icloud.com>
Date: Sat, 25 Nov 2023 03:29:21 +0100
Subject: [PATCH 0325/1315] Add assertion to `_sqrt_quasitriu_diag_block`
 (#52274)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes https://github.com/JuliaLang/julia/issues/52255

Before this change:
```julia
julia> using JET

julia> report_call(√, Tuple{Matrix{Complex{Float64}}})
═════ 1 possible error found ═════
┌ sqrt(A::Matrix{ComplexF64}) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/dense.jl:884
│┌ sqrt(A::UpperTriangular{ComplexF64, Matrix{ComplexF64}}) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2159
││┌ sqrt_quasitriu(A0::UpperTriangular{ComplexF64, Matrix{ComplexF64}}) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2184
│││┌ sqrt_quasitriu(A0::UpperTriangular{ComplexF64, Matrix{ComplexF64}}; blockwidth::Int64) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2211
││││┌ kwcall(::@NamedTuple{blockwidth::Int64, n::Int64}, ::typeof(LinearAlgebra._sqrt_quasitriu!), R::Matrix{ComplexF64}, A::UpperTriangular{ComplexF64, Matrix{ComplexF64}}) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2226
│││││┌ _sqrt_quasitriu!(R::Matrix{ComplexF64}, A::UpperTriangular{ComplexF64, Matrix{ComplexF64}}; blockwidth::Int64, n::Int64) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2228
││││││┌ _sqrt_quasitriu_block!(R::Matrix{ComplexF64}, A::UpperTriangular{ComplexF64, Matrix{ComplexF64}}) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2248
│││││││┌ _sqrt_quasitriu_diag_block!(R::Matrix{ComplexF64}, A::UpperTriangular{ComplexF64, Matrix{ComplexF64}}) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2263
││││││││┌ _sqrt_real_2x2!(R::SubArray{ComplexF64, 2, Matrix{ComplexF64}, Tuple{UnitRange{Int64}, UnitRange{Int64}}, false}, A::SubArray{ComplexF64, 2, UpperTriangular{ComplexF64, Matrix{ComplexF64}}, Tuple{UnitRange{Int64}, UnitRange{Int64}}, false}) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2311
│││││││││┌ _real_sqrt(θ::ComplexF64, μ::Float64) @ LinearAlgebra /home/mason/julia-dev/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:2323
││││││││││┌ >=(x::ComplexF64, y::Int64) @ Base ./operators.jl:425
│││││││││││┌ <=(x::Int64, y::ComplexF64) @ Base ./operators.jl:401
││││││││││││┌ <(x::Int64, y::ComplexF64) @ Base ./operators.jl:352
│││││││││││││ no matching method found `isless(::Int64, ::ComplexF64)`: isless(x::Int64, y::ComplexF64)
││││││││││││└────────────────────
```

after this change
```julia
julia> report_call(√, Tuple{Matrix{Complex{Float64}}})
No errors detected
```

There was a pre-existing comment in the function claiming "this branch
is never reached when A is complex triangular". I don't fully understand
why that would be the case, but if we believe it to be true, it would be
good to share that information with the compiler.

I used `@assert` here because it's believed by whoever wrote the
algorithm that this branch is unreachable, so I think that's the correct
way to use `@assert`, but if people have suggestions for a better way to
communicate this info to the compiler, I'd gladly change things around.
---
 stdlib/LinearAlgebra/src/triangular.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index b92c0b110fff4..303ae2d8f1a10 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -2265,7 +2265,8 @@ function _sqrt_quasitriu_diag_block!(R, A)
             R[i, i] = sqrt(ta(A[i, i]))
             i += 1
         else
-            # this branch is never reached when A is complex triangular
+            # This branch is never reached when A is complex triangular
+            @assert eltype(A) <: Real
             @views _sqrt_real_2x2!(R[i:(i + 1), i:(i + 1)], A[i:(i + 1), i:(i + 1)])
             i += 2
         end

From cc4424e346ec6787b6669fc0d2fb4fffec846bb6 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sat, 25 Nov 2023 08:05:05 +0530
Subject: [PATCH 0326/1315] Improve type-inference in complex eigen (#52290)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Indexing using integers instead of a `Vector` uses constant-propagation
to improve the inferred return types. After this, the return type of
`eigen(::Matrix{ComplexF64})` is inferred as a small union.
```julia
julia> @code_typed eigen(rand(ComplexF64,2,2))
CodeInfo(
1 ─ %1 = invoke LinearAlgebra.:(var"#eigen#94")(true::Bool, true::Bool, LinearAlgebra.eigsortby::typeof(LinearAlgebra.eigsortby), #self#::typeof(eigen), A::Matrix{ComplexF64})::Union{Eigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}, Eigen{ComplexF64, Float64, Matrix{ComplexF64}, Vector{Float64}}}
└──      return %1
) => Union{Eigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}, Eigen{ComplexF64, Float64, Matrix{ComplexF64}, Vector{Float64}}}
```
Close #52289
---
 stdlib/LinearAlgebra/src/eigen.jl  | 3 ++-
 stdlib/LinearAlgebra/test/eigen.jl | 8 ++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/eigen.jl b/stdlib/LinearAlgebra/src/eigen.jl
index 489bfa4665c7a..571556be47c0a 100644
--- a/stdlib/LinearAlgebra/src/eigen.jl
+++ b/stdlib/LinearAlgebra/src/eigen.jl
@@ -173,7 +173,8 @@ function eigen!(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true, sortb
     n = size(A, 2)
     n == 0 && return Eigen(zeros(T, 0), zeros(T, 0, 0))
     ishermitian(A) && return eigen!(Hermitian(A), sortby=sortby)
-    eval, evec = LAPACK.geevx!(permute ? (scale ? 'B' : 'P') : (scale ? 'S' : 'N'), 'N', 'V', 'N', A)[[2,4]]
+    E = LAPACK.geevx!(permute ? (scale ? 'B' : 'P') : (scale ? 'S' : 'N'), 'N', 'V', 'N', A)
+    eval, evec = E[2], E[4]
     return Eigen(sorteig!(eval, evec, sortby)...)
 end
 
diff --git a/stdlib/LinearAlgebra/test/eigen.jl b/stdlib/LinearAlgebra/test/eigen.jl
index 413a8df0474fa..b9e6d0e62e3ee 100644
--- a/stdlib/LinearAlgebra/test/eigen.jl
+++ b/stdlib/LinearAlgebra/test/eigen.jl
@@ -243,4 +243,12 @@ end
     @test F.vectors ≈ F32.vectors
 end
 
+@testset "complex eigen inference (#52289)" begin
+    A = ComplexF64[1.0 0.0; 0.0 8.0]
+    TC = Eigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
+    TR = Eigen{ComplexF64, Float64, Matrix{ComplexF64}, Vector{Float64}}
+    λ, v = @inferred Union{TR,TC} eigen(A)
+    @test λ == [1.0, 8.0]
+end
+
 end # module TestEigen

From cb01a3b4521abbca1756f64537082561e815dc5e Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 24 Nov 2023 23:45:22 -0500
Subject: [PATCH 0327/1315] optimized (and ordered) IdSet code (#52114)

We have had this smallintset code around for a while for internal
purposes, though it was not quite fully general purpose (it didn't have
pop). We also have around this tiny global_roots_table (about 1500
entries after building the sysig). This saves about 50% of the space for
storing that table. It also optimizes all other IdSet code to not be an
inefficient mutable wrapper around an IdDict, but instead be an ordered
(by first insertion) set type of its own.
---
 base/idset.jl            |  97 +++++++++++++++++++-----
 src/Makefile             |   2 +-
 src/builtins.c           |   1 +
 src/gc.c                 |   3 +-
 src/gf.c                 |  12 +--
 src/iddict.c             |   1 +
 src/idset.c              | 118 +++++++++++++++++++++++++++++
 src/init.c               |   3 +-
 src/jl_exported_data.inc |   3 +-
 src/jltypes.c            |   7 +-
 src/julia.h              |   7 +-
 src/julia_internal.h     |  20 +++--
 src/method.c             |   2 +-
 src/module.c             |  12 +--
 src/smallintset.c        | 160 +++++++++++++++++++++------------------
 src/staticdata.c         |  39 ++++++----
 sysimage.mk              |   3 +
 17 files changed, 355 insertions(+), 135 deletions(-)
 create mode 100644 src/idset.c

diff --git a/base/idset.jl b/base/idset.jl
index 0a4d4275b4231..6e0b7a85a5b23 100644
--- a/base/idset.jl
+++ b/base/idset.jl
@@ -1,13 +1,13 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-# Like Set, but using IdDict
-mutable struct IdSet{T} <: AbstractSet{T}
-    dict::IdDict{T,Nothing}
-
-    IdSet{T}() where {T} = new(IdDict{T,Nothing}())
-    IdSet{T}(s::IdSet{T}) where {T} = new(copy(s.dict))
+mutable struct IdSet{K} <: AbstractSet{K}
+    list::Memory{Any}
+    idxs::Union{Memory{UInt8}, Memory{UInt16}, Memory{UInt32}}
+    count::Int
+    max::Int # n.b. always <= length(list)
+    IdSet{T}() where {T} = new(Memory{Any}(undef, 0), Memory{UInt8}(undef, 0), 0, 0)
+    IdSet{T}(s::IdSet{T}) where {T} = new(copy(s.list), copy(s.idxs), s.count, s.max)
 end
-
 IdSet{T}(itr) where {T} = union!(IdSet{T}(), itr)
 IdSet() = IdSet{Any}()
 
@@ -15,22 +15,77 @@ copymutable(s::IdSet) = typeof(s)(s)
 emptymutable(s::IdSet{T}, ::Type{U}=T) where {T,U} = IdSet{U}()
 copy(s::IdSet) = typeof(s)(s)
 
-isempty(s::IdSet) = isempty(s.dict)
-length(s::IdSet)  = length(s.dict)
-in(@nospecialize(x), s::IdSet) = haskey(s.dict, x)
-push!(s::IdSet, @nospecialize(x)) = (s.dict[x] = nothing; s)
-pop!(s::IdSet, @nospecialize(x)) = (pop!(s.dict, x); x)
-pop!(s::IdSet, @nospecialize(x), @nospecialize(default)) = (x in s ? pop!(s, x) : default)
-delete!(s::IdSet, @nospecialize(x)) = (delete!(s.dict, x); s)
+haskey(s::IdSet, @nospecialize(key)) = ccall(:jl_idset_peek_bp, Int, (Any, Any, Any), s.list, s.idxs, key) != -1
+isempty(s::IdSet) = s.count == 0
+length(s::IdSet)  = s.count
+in(@nospecialize(x), s::IdSet) = haskey(s, x)
+function push!(s::IdSet, @nospecialize(x))
+    idx = ccall(:jl_idset_peek_bp, Int, (Any, Any, Any), s.list, s.idxs, x)
+    if idx >= 0
+        s.list[idx + 1] = x
+    else
+        if s.max < length(s.list)
+            idx = s.max
+            @assert !isassigned(s.list, idx + 1)
+            s.list[idx + 1] = x
+            s.max = idx + 1
+        else
+            newidx = RefValue{Int}(0)
+            setfield!(s, :list, ccall(:jl_idset_put_key, Any, (Any, Any, Ptr{Int}), s.list, x, newidx))
+            idx = newidx[]
+            s.max = idx < 0 ? -idx : idx + 1
+        end
+        @assert s.list[s.max] === x
+        setfield!(s, :idxs, ccall(:jl_idset_put_idx, Any, (Any, Any, Int), s.list, s.idxs, idx))
+        s.count += 1
+    end
+    s
+end
+function _pop!(s::IdSet, @nospecialize(x))
+    removed = ccall(:jl_idset_pop, Int, (Any, Any, Any), s.list, s.idxs, x)
+    if removed != -1
+        s.count -= 1
+        while s.max > 0 && !isassigned(s.list, s.max)
+            s.max -= 1
+        end
+    end
+    removed
+end
+pop!(s::IdSet, @nospecialize(x)) = _pop!(s, x) == -1 ? throw(KeyError(x)) : x
+pop!(s::IdSet, @nospecialize(x), @nospecialize(default)) = _pop!(s, x) == -1 ? default : x
+delete!(s::IdSet, @nospecialize(x)) = (_pop!(s, x); s)
 
-sizehint!(s::IdSet, newsz) = (sizehint!(s.dict, newsz); s)
-empty!(s::IdSet) = (empty!(s.dict); s)
+function sizehint!(s::IdSet, newsz)
+    # TODO: grow/compact list and perform rehash, if profitable?
+    # TODO: shrink?
+    # s.list = resize(s.list, newsz)
+    # newsz = _tablesz(newsz)
+    # oldsz = length(s.idxs)
+    # #grow at least 25%
+    # if newsz < (oldsz*5)>>2
+    #     return s
+    # end
+    # rehash!(s, newsz)
+    nothing
+end
+
+function empty!(s::IdSet)
+    fill!(s.idxs, 0x00)
+    list = s.list
+    for i = 1:s.max
+        _unsetindex!(list, i)
+    end
+    s.count = 0
+    s.max = 0
+    s
+end
 
 filter!(f, d::IdSet) = unsafe_filter!(f, d)
 
-function iterate(s::IdSet, state...)
-    y = iterate(s.dict, state...)
-    y === nothing && return nothing
-    ((k, _), i) = y
-    return (k, i)
+function iterate(s::IdSet{S}, state=0) where {S}
+    while true
+        state += 1
+        state > s.max && return nothing
+        isassigned(s.list, state) && return s.list[state]::S, state
+    end
 end
diff --git a/src/Makefile b/src/Makefile
index 4d105adec0dbb..5fc2bc2eaaa41 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -306,7 +306,7 @@ $(BUILDDIR)/julia_flisp.boot: $(addprefix $(SRCDIR)/,jlfrontend.scm flisp/aliase
 $(BUILDDIR)/codegen-stubs.o $(BUILDDIR)/codegen-stubs.dbg.obj: $(SRCDIR)/intrinsics.h
 $(BUILDDIR)/aotcompile.o $(BUILDDIR)/aotcompile.dbg.obj: $(SRCDIR)/jitlayers.h $(SRCDIR)/llvm-codegen-shared.h $(SRCDIR)/processor.h
 $(BUILDDIR)/ast.o $(BUILDDIR)/ast.dbg.obj: $(BUILDDIR)/julia_flisp.boot.inc $(SRCDIR)/flisp/*.h
-$(BUILDDIR)/builtins.o $(BUILDDIR)/builtins.dbg.obj: $(SRCDIR)/iddict.c $(SRCDIR)/builtin_proto.h
+$(BUILDDIR)/builtins.o $(BUILDDIR)/builtins.dbg.obj: $(SRCDIR)/iddict.c $(SRCDIR)/idset.c $(SRCDIR)/builtin_proto.h
 $(BUILDDIR)/codegen.o $(BUILDDIR)/codegen.dbg.obj: $(addprefix $(SRCDIR)/,\
 	intrinsics.cpp jitlayers.h intrinsics.h llvm-codegen-shared.h cgutils.cpp ccall.cpp abi_*.cpp processor.h builtin_proto.h)
 $(BUILDDIR)/datatype.o $(BUILDDIR)/datatype.dbg.obj: $(SRCDIR)/support/htable.h $(SRCDIR)/support/htable.inc
diff --git a/src/builtins.c b/src/builtins.c
index 04b45500fddaa..88b91baa19279 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -490,6 +490,7 @@ JL_DLLEXPORT uintptr_t jl_object_id(jl_value_t *v) JL_NOTSAFEPOINT
 // eq hash table --------------------------------------------------------------
 
 #include "iddict.c"
+#include "idset.c"
 
 // object model and type primitives -------------------------------------------
 
diff --git a/src/gc.c b/src/gc.c
index bc0361c8ac7a8..38cebf151493d 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -3096,7 +3096,8 @@ static void gc_mark_roots(jl_gc_markqueue_t *mq)
     // constants
     gc_try_claim_and_push(mq, jl_emptytuple_type, NULL);
     gc_try_claim_and_push(mq, cmpswap_names, NULL);
-    gc_try_claim_and_push(mq, jl_global_roots_table, NULL);
+    gc_try_claim_and_push(mq, jl_global_roots_list, NULL);
+    gc_try_claim_and_push(mq, jl_global_roots_keyset, NULL);
 }
 
 // find unmarked objects that need to be finalized from the finalizer list "list".
diff --git a/src/gf.c b/src/gf.c
index 5013706030777..e5249e18d1d68 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -110,7 +110,7 @@ static int8_t jl_cachearg_offset(jl_methtable_t *mt)
 /// ----- Insertion logic for special entries ----- ///
 
 
-static uint_t speccache_hash(size_t idx, jl_svec_t *data)
+static uint_t speccache_hash(size_t idx, jl_value_t *data)
 {
     jl_method_instance_t *ml = (jl_method_instance_t*)jl_svecref(data, idx);
     jl_value_t *sig = ml->specTypes;
@@ -119,7 +119,7 @@ static uint_t speccache_hash(size_t idx, jl_svec_t *data)
     return ((jl_datatype_t*)sig)->hash;
 }
 
-static int speccache_eq(size_t idx, const void *ty, jl_svec_t *data, uint_t hv)
+static int speccache_eq(size_t idx, const void *ty, jl_value_t *data, uint_t hv)
 {
     jl_method_instance_t *ml = (jl_method_instance_t*)jl_svecref(data, idx);
     jl_value_t *sig = ml->specTypes;
@@ -139,7 +139,7 @@ static jl_method_instance_t *jl_specializations_get_linfo_(jl_method_t *m JL_PRO
     jl_value_t *ut = jl_is_unionall(type) ? jl_unwrap_unionall(type) : type;
     JL_TYPECHK(specializations, datatype, ut);
     uint_t hv = ((jl_datatype_t*)ut)->hash;
-    jl_array_t *speckeyset = NULL;
+    jl_genericmemory_t *speckeyset = NULL;
     jl_value_t *specializations = NULL;
     size_t i = -1, cl = 0, lastcl;
     for (int locked = 0; locked < 2; locked++) {
@@ -164,7 +164,7 @@ static jl_method_instance_t *jl_specializations_get_linfo_(jl_method_t *m JL_PRO
         }
         cl = jl_svec_len(specializations);
         if (hv) {
-            ssize_t idx = jl_smallintset_lookup(speckeyset, speccache_eq, type, (jl_svec_t*)specializations, hv);
+            ssize_t idx = jl_smallintset_lookup(speckeyset, speccache_eq, type, specializations, hv, 0);
             if (idx != -1) {
                 jl_method_instance_t *mi = (jl_method_instance_t*)jl_svecref(specializations, idx);
                 if (locked)
@@ -210,7 +210,7 @@ static jl_method_instance_t *jl_specializations_get_linfo_(jl_method_t *m JL_PRO
             jl_atomic_store_release(&m->specializations, specializations);
             jl_gc_wb(m, specializations);
             if (hv)
-                jl_smallintset_insert(&m->speckeyset, (jl_value_t*)m, speccache_hash, 0, (jl_svec_t*)specializations);
+                jl_smallintset_insert(&m->speckeyset, (jl_value_t*)m, speccache_hash, 0, specializations);
         }
         if (hv) {
             _Atomic(jl_method_instance_t*) *data = (_Atomic(jl_method_instance_t*)*)jl_svec_data(specializations);
@@ -242,7 +242,7 @@ static jl_method_instance_t *jl_specializations_get_linfo_(jl_method_t *m JL_PRO
         assert(jl_svecref(specializations, i) == jl_nothing);
         jl_svecset(specializations, i, mi);
         if (hv)
-            jl_smallintset_insert(&m->speckeyset, (jl_value_t*)m, speccache_hash, i, (jl_svec_t*)specializations);
+            jl_smallintset_insert(&m->speckeyset, (jl_value_t*)m, speccache_hash, i, specializations);
         JL_GC_POP();
     }
     JL_UNLOCK(&m->writelock); // may gc
diff --git a/src/iddict.c b/src/iddict.c
index eaa55657e2517..8d17f172b91fe 100644
--- a/src/iddict.c
+++ b/src/iddict.c
@@ -194,3 +194,4 @@ size_t jl_eqtable_nextind(jl_genericmemory_t *t, size_t i)
 
 #undef hash_size
 #undef max_probe
+#undef h2index
diff --git a/src/idset.c b/src/idset.c
new file mode 100644
index 0000000000000..b9711ee17f021
--- /dev/null
+++ b/src/idset.c
@@ -0,0 +1,118 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+
+static uint_t idset_hash(size_t idx, jl_value_t *data)
+{
+    jl_value_t *x = jl_genericmemory_ptr_ref(data, idx);
+    // x should not be NULL, unless there was concurrent corruption
+    return x == NULL ? 0 : jl_object_id(x);
+}
+
+static int idset_eq(size_t idx, const void *y, jl_value_t *data, uint_t hv)
+{
+    jl_value_t *x = jl_genericmemory_ptr_ref(data, idx);
+    // x should not be NULL, unless there was concurrent corruption
+    return x == NULL ? 0 : jl_egal(x, (jl_value_t*)y);
+}
+
+jl_genericmemory_t *jl_idset_rehash(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, size_t newsz)
+{
+    if (newsz == 0)
+        return idxs;
+    newsz = next_power_of_two(newsz);
+    //if (idxs->length == newsz)
+    //    jl_idset_put_idx(keys, idxs, -newsz+1);
+    //else
+    return smallintset_rehash(idxs, idset_hash, (jl_value_t*)keys, newsz, 0);
+}
+
+// Return idx if key is in hash, otherwise -1
+// Note: lookup in the IdSet is permitted concurrently, if you avoid deletions,
+// and assuming you do use an external lock around all insertions
+ssize_t jl_idset_peek_bp(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT
+{
+    uintptr_t hv = jl_object_id(key);
+    return jl_smallintset_lookup(idxs, idset_eq, key, (jl_value_t*)keys, hv, 0);
+}
+
+jl_value_t *jl_idset_get(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT
+{
+    ssize_t idx = jl_idset_peek_bp(keys, idxs, key);
+    if (idx == -1)
+        return NULL;
+    return jl_genericmemory_ptr_ref(keys, idx);
+}
+
+
+static ssize_t idset_compact(jl_genericmemory_t *keys)
+{
+    // compact keys before rehashing idxs
+    ssize_t i, j;
+    ssize_t rehash = 0;
+    for (i = j = 0; i < keys->length; i++) {
+        jl_value_t *k = jl_genericmemory_ptr_ref(keys, i);
+        if (k != NULL) {
+            if (i != j) {
+                rehash = 1;
+                jl_genericmemory_ptr_set(keys, j, k);
+                jl_genericmemory_ptr_set(keys, i, NULL);
+            }
+            j++;
+        }
+    }
+    return rehash ? -j : j;
+}
+
+jl_genericmemory_t *jl_idset_put_key(jl_genericmemory_t *keys, jl_value_t *key, ssize_t *newidx)
+{
+    ssize_t l = keys->length;
+    ssize_t i = l;
+    while (i > 0 && jl_genericmemory_ptr_ref(keys, i - 1) == NULL)
+        i--;
+    // i points to the place to insert
+    *newidx = i;
+    if (i == l) {
+        i = idset_compact(keys);
+        if (i < 0) {
+            *newidx = i - 1;
+            i = -i;
+        }
+        if (i >= l / 3 * 2) {
+            size_t nl = l < 4 ? 4 : (l * 3) >> 1; // grow space by 50% if less than 33% free after compacting
+            jl_genericmemory_t *nk = jl_alloc_genericmemory(jl_memory_any_type, nl);
+            if (i > 0)
+                memcpy(nk->ptr, keys->ptr, sizeof(void*) * i);
+            keys = nk;
+        }
+    }
+    assert(jl_genericmemory_ptr_ref(keys, i) == NULL);
+    jl_genericmemory_ptr_set(keys, i, key);
+    return keys;
+}
+
+jl_genericmemory_t *jl_idset_put_idx(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, ssize_t idx)
+{
+    _Atomic(jl_genericmemory_t*) newidxs = idxs;
+    JL_GC_PUSH1(&newidxs);
+    if (idx < 0) { // full rehash
+        smallintset_empty(idxs);
+        for (ssize_t i = 0; i < -idx; i++)
+            if (jl_genericmemory_ptr_ref(keys, i) != NULL)
+                jl_smallintset_insert(&newidxs, NULL, idset_hash, i, (jl_value_t*)keys);
+    }
+    else {
+        jl_smallintset_insert(&newidxs, NULL, idset_hash, idx, (jl_value_t*)keys);
+    }
+    JL_GC_POP();
+    return jl_atomic_load_relaxed(&newidxs);
+}
+
+/* returns idx if key is in hash, otherwise -1 */
+ssize_t jl_idset_pop(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT
+{
+    uintptr_t hv = jl_object_id(key);
+    ssize_t idx = jl_smallintset_lookup(idxs, idset_eq, key, (jl_value_t*)keys, hv, 1);
+    if (idx != -1)
+        jl_genericmemory_ptr_set(keys, idx, NULL);
+    return idx;
+}
diff --git a/src/init.c b/src/init.c
index 925ef0018048f..d4128c8ae9e40 100644
--- a/src/init.c
+++ b/src/init.c
@@ -861,7 +861,8 @@ static NOINLINE void _finish_julia_init(JL_IMAGE_SEARCH rel, jl_ptls_t ptls, jl_
         jl_restore_system_image(jl_options.image_file);
     } else {
         jl_init_types();
-        jl_global_roots_table = jl_alloc_memory_any(0);
+        jl_global_roots_list = (jl_genericmemory_t*)jl_an_empty_memory_any;
+        jl_global_roots_keyset = (jl_genericmemory_t*)jl_an_empty_memory_any;
     }
 
     jl_init_flisp();
diff --git a/src/jl_exported_data.inc b/src/jl_exported_data.inc
index 1a843c71f0e1e..e840d2e8a40dc 100644
--- a/src/jl_exported_data.inc
+++ b/src/jl_exported_data.inc
@@ -73,12 +73,13 @@
     XX(jl_genericmemory_type) \
     XX(jl_genericmemory_typename) \
     XX(jl_memory_uint8_type) \
+    XX(jl_memory_uint16_type) \
+    XX(jl_memory_uint32_type) \
     XX(jl_memory_uint64_type) \
     XX(jl_memoryref_any_type) \
     XX(jl_genericmemoryref_type) \
     XX(jl_genericmemoryref_typename) \
     XX(jl_memoryref_uint8_type) \
-    XX(jl_memoryref_uint64_type) \
     XX(jl_methoderror_type) \
     XX(jl_method_instance_type) \
     XX(jl_method_match_type) \
diff --git a/src/jltypes.c b/src/jltypes.c
index a30d746bbb320..5666319860f6a 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -2977,6 +2977,9 @@ void jl_init_types(void) JL_GC_DISABLED
 
     jl_memory_any_type = jl_apply_type3((jl_value_t*)jl_genericmemory_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_any_type, cpumem);
     jl_memory_uint8_type = jl_apply_type3((jl_value_t*)jl_genericmemory_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_uint8_type, cpumem);
+    jl_memory_uint16_type = jl_apply_type3((jl_value_t*)jl_genericmemory_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_uint16_type, cpumem);
+    jl_memory_uint32_type = jl_apply_type3((jl_value_t*)jl_genericmemory_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_uint32_type, cpumem);
+    jl_memory_uint64_type = jl_apply_type3((jl_value_t*)jl_genericmemory_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_uint64_type, cpumem);
     jl_memoryref_any_type = jl_apply_type3((jl_value_t*)jl_genericmemoryref_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_any_type, cpumem);
     jl_memoryref_uint8_type = jl_apply_type3((jl_value_t*)jl_genericmemoryref_type, (jl_value_t*)jl_not_atomic_sym, (jl_value_t*)jl_uint8_type, cpumem);
 
@@ -3004,7 +3007,7 @@ void jl_init_types(void) JL_GC_DISABLED
 
     // finish initializing module Core
     core = jl_core_module;
-    jl_atomic_store_relaxed(&core->bindingkeyset, (jl_array_t*)jl_an_empty_vec_any);
+    jl_atomic_store_relaxed(&core->bindingkeyset, (jl_genericmemory_t*)jl_an_empty_memory_any);
     // export own name, so "using Foo" makes "Foo" itself visible
     jl_set_const(core, core->name, (jl_value_t*)core);
     jl_module_public(core, core->name, 1);
@@ -3180,7 +3183,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_ulong_type,
                             jl_type_type,
                             jl_any_type, // union(jl_simplevector_type, jl_method_instance_type),
-                            jl_array_type,
+                            jl_genericmemory_type, // union(jl_memory_uint8_type, jl_memory_uint16_type, jl_memory_uint32_type, jl_memory_uint64_type, jl_memory_any_type)
                             jl_string_type,
                             jl_any_type,
                             jl_any_type,
diff --git a/src/julia.h b/src/julia.h
index d728458f50180..409da556ed957 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -320,7 +320,7 @@ typedef struct _jl_method_t {
 
     // table of all jl_method_instance_t specializations we have
     _Atomic(jl_value_t*) specializations; // allocated as [hashable, ..., NULL, linear, ....], or a single item
-    _Atomic(jl_array_t*) speckeyset; // index lookup by hash into specializations
+    _Atomic(jl_genericmemory_t*) speckeyset; // index lookup by hash into specializations
 
     jl_value_t *slot_syms; // compacted list of slot names (String)
     jl_value_t *external_mt; // reference to the method table this method is part of, null if part of the internal table
@@ -611,7 +611,7 @@ typedef struct _jl_module_t {
     jl_sym_t *name;
     struct _jl_module_t *parent;
     _Atomic(jl_svec_t*) bindings;
-    _Atomic(jl_array_t*) bindingkeyset; // index lookup by name into bindings
+    _Atomic(jl_genericmemory_t*) bindingkeyset; // index lookup by name into bindings
     // hidden fields:
     arraylist_t usings;  // modules with all bindings potentially imported
     jl_uuid_t build_id;
@@ -881,6 +881,9 @@ extern JL_DLLIMPORT jl_value_t *jl_array_int32_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_array_uint32_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_array_uint64_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_memory_uint8_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_memory_uint16_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_memory_uint32_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_value_t *jl_memory_uint64_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_memory_any_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_memoryref_uint8_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_value_t *jl_memoryref_any_type JL_GLOBALLY_ROOTED;
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 45b1f893ef71a..da025a900400e 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -805,7 +805,8 @@ JL_DLLEXPORT void jl_binding_deprecation_warning(jl_module_t *m, jl_sym_t *sym,
 extern jl_array_t *jl_module_init_order JL_GLOBALLY_ROOTED;
 extern htable_t jl_current_modules JL_GLOBALLY_ROOTED;
 extern JL_DLLEXPORT jl_module_t *jl_precompile_toplevel_module JL_GLOBALLY_ROOTED;
-extern jl_genericmemory_t *jl_global_roots_table JL_GLOBALLY_ROOTED;
+extern jl_genericmemory_t *jl_global_roots_list JL_GLOBALLY_ROOTED;
+extern jl_genericmemory_t *jl_global_roots_keyset JL_GLOBALLY_ROOTED;
 JL_DLLEXPORT int jl_is_globally_rooted(jl_value_t *val JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val JL_MAYBE_UNROOTED);
 
@@ -1420,10 +1421,19 @@ void jl_safepoint_resume_thread_mach(jl_ptls_t ptls2, int16_t tid2) JL_NOTSAFEPO
 
 // -- smallintset.c -- //
 
-typedef uint_t (*smallintset_hash)(size_t val, jl_svec_t *data);
-typedef int (*smallintset_eq)(size_t val, const void *key, jl_svec_t *data, uint_t hv);
-ssize_t jl_smallintset_lookup(jl_array_t *cache, smallintset_eq eq, const void *key, jl_svec_t *data, uint_t hv);
-void jl_smallintset_insert(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, smallintset_hash hash, size_t val, jl_svec_t *data);
+typedef uint_t (*smallintset_hash)(size_t val, jl_value_t *data);
+typedef int (*smallintset_eq)(size_t val, const void *key, jl_value_t *data, uint_t hv);
+ssize_t jl_smallintset_lookup(jl_genericmemory_t *cache, smallintset_eq eq, const void *key, jl_value_t *data, uint_t hv, int pop);
+void jl_smallintset_insert(_Atomic(jl_genericmemory_t*) *pcache, jl_value_t *parent, smallintset_hash hash, size_t val, jl_value_t *data);
+jl_genericmemory_t* smallintset_rehash(jl_genericmemory_t* a, smallintset_hash hash, jl_value_t *data, size_t newsz, size_t np);
+void smallintset_empty(const jl_genericmemory_t *a) JL_NOTSAFEPOINT;
+
+JL_DLLEXPORT jl_genericmemory_t *jl_idset_rehash(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, size_t newsz);
+JL_DLLEXPORT ssize_t jl_idset_peek_bp(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT;
+jl_value_t *jl_idset_get(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_genericmemory_t *jl_idset_put_key(jl_genericmemory_t *keys, jl_value_t *key, ssize_t *newidx);
+JL_DLLEXPORT jl_genericmemory_t *jl_idset_put_idx(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, ssize_t idx);
+JL_DLLEXPORT ssize_t jl_idset_pop(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT;
 
 // -- typemap.c -- //
 
diff --git a/src/method.c b/src/method.c
index 8b89e66c62eb0..9cb7e83d57c1c 100644
--- a/src/method.c
+++ b/src/method.c
@@ -795,7 +795,7 @@ JL_DLLEXPORT jl_method_t *jl_new_method_uninit(jl_module_t *module)
     jl_method_t *m =
         (jl_method_t*)jl_gc_alloc(ct->ptls, sizeof(jl_method_t), jl_method_type);
     jl_atomic_store_relaxed(&m->specializations, (jl_value_t*)jl_emptysvec);
-    jl_atomic_store_relaxed(&m->speckeyset, (jl_array_t*)jl_an_empty_vec_any);
+    jl_atomic_store_relaxed(&m->speckeyset, (jl_genericmemory_t*)jl_an_empty_memory_any);
     m->sig = NULL;
     m->slot_syms = NULL;
     m->roots = NULL;
diff --git a/src/module.c b/src/module.c
index 04ddb4f4fb3ae..47309c897ae63 100644
--- a/src/module.c
+++ b/src/module.c
@@ -39,7 +39,7 @@ JL_DLLEXPORT jl_module_t *jl_new_module_(jl_sym_t *name, jl_module_t *parent, ui
         bitmix(name->hash, parent->hash);
     JL_MUTEX_INIT(&m->lock, "module->lock");
     jl_atomic_store_relaxed(&m->bindings, jl_emptysvec);
-    jl_atomic_store_relaxed(&m->bindingkeyset, (jl_array_t*)jl_an_empty_vec_any);
+    jl_atomic_store_relaxed(&m->bindingkeyset, (jl_genericmemory_t*)jl_an_empty_memory_any);
     arraylist_new(&m->usings, 0);
     if (jl_core_module && default_names) {
         JL_GC_PUSH1(&m);
@@ -699,14 +699,14 @@ JL_DLLEXPORT int jl_binding_resolved_p(jl_module_t *m, jl_sym_t *var)
     return b && jl_atomic_load_relaxed(&b->owner) != NULL;
 }
 
-static uint_t bindingkey_hash(size_t idx, jl_svec_t *data)
+static uint_t bindingkey_hash(size_t idx, jl_value_t *data)
 {
     jl_binding_t *b = (jl_binding_t*)jl_svecref(data, idx);
     jl_sym_t *var = b->globalref->name;
     return var->hash;
 }
 
-static int bindingkey_eq(size_t idx, const void *var, jl_svec_t *data, uint_t hv)
+static int bindingkey_eq(size_t idx, const void *var, jl_value_t *data, uint_t hv)
 {
     jl_binding_t *b = (jl_binding_t*)jl_svecref(data, idx);
     jl_sym_t *name = b->globalref->name;
@@ -717,9 +717,9 @@ JL_DLLEXPORT jl_binding_t *jl_get_module_binding(jl_module_t *m, jl_sym_t *var,
 {
     uint_t hv = var->hash;
     for (int locked = 0; ; locked++) {
-        jl_array_t *bindingkeyset = jl_atomic_load_acquire(&m->bindingkeyset);
+        jl_genericmemory_t *bindingkeyset = jl_atomic_load_acquire(&m->bindingkeyset);
         jl_svec_t *bindings = jl_atomic_load_relaxed(&m->bindings);
-        ssize_t idx = jl_smallintset_lookup(bindingkeyset, bindingkey_eq, var, bindings, hv); // acquire
+        ssize_t idx = jl_smallintset_lookup(bindingkeyset, bindingkey_eq, var, (jl_value_t*)bindings, hv, 0); // acquire
         if (idx != -1) {
             jl_binding_t *b = (jl_binding_t*)jl_svecref(bindings, idx); // relaxed
             if (locked)
@@ -753,7 +753,7 @@ JL_DLLEXPORT jl_binding_t *jl_get_module_binding(jl_module_t *m, jl_sym_t *var,
             jl_binding_t *b = new_binding(m, var);
             assert(jl_svecref(bindings, i) == jl_nothing);
             jl_svecset(bindings, i, b); // relaxed
-            jl_smallintset_insert(&m->bindingkeyset, (jl_value_t*)m, bindingkey_hash, i, bindings); // release
+            jl_smallintset_insert(&m->bindingkeyset, (jl_value_t*)m, bindingkey_hash, i, (jl_value_t*)bindings); // release
             JL_UNLOCK(&m->lock);
             return b;
         }
diff --git a/src/smallintset.c b/src/smallintset.c
index b3af6e45c7834..df67239f79fb5 100644
--- a/src/smallintset.c
+++ b/src/smallintset.c
@@ -24,91 +24,103 @@
 extern "C" {
 #endif
 
-static inline size_t jl_intref(const jl_array_t *arr, size_t idx) JL_NOTSAFEPOINT
+static inline size_t ignore_tombstone(size_t val, size_t tombstone) JL_NOTSAFEPOINT
 {
-    jl_value_t *el = jl_tparam0(jl_typeof(arr));
-    if (el == (jl_value_t*)jl_uint8_type)
-        return jl_atomic_load_relaxed(&jl_array_data(arr, _Atomic(uint8_t))[idx]);
-    else if (el == (jl_value_t*)jl_uint16_type)
-        return jl_atomic_load_relaxed(&jl_array_data(arr, _Atomic(uint16_t))[idx]);
-    else if (el == (jl_value_t*)jl_uint32_type)
-        return jl_atomic_load_relaxed(&jl_array_data(arr, _Atomic(uint32_t))[idx]);
+    return val == tombstone ? 0 : val;
+}
+static inline size_t jl_intref(const jl_genericmemory_t *arr, size_t idx) JL_NOTSAFEPOINT
+{
+    jl_value_t *el = (jl_value_t*)jl_typetagof(arr);
+    if (el == jl_memory_uint8_type)
+        return ignore_tombstone(jl_atomic_load_relaxed(&((_Atomic(uint8_t)*)arr->ptr)[idx]), (uint8_t)-1);
+    else if (el == jl_memory_uint16_type)
+        return ignore_tombstone(jl_atomic_load_relaxed(&((_Atomic(uint16_t)*)arr->ptr)[idx]), (uint16_t)-1);
+    else if (el == jl_memory_uint32_type)
+        return ignore_tombstone(jl_atomic_load_relaxed(&((_Atomic(uint32_t)*)arr->ptr)[idx]), (uint32_t)-1);
     else
         abort();
 }
 
-static inline size_t jl_intref_acquire(const jl_array_t *arr, size_t idx) JL_NOTSAFEPOINT
+static inline size_t acquire_tombstone(size_t val, size_t tombstone) JL_NOTSAFEPOINT
 {
-    jl_value_t *el = jl_tparam0(jl_typeof(arr));
-    if (el == (jl_value_t*)jl_uint8_type)
-        return jl_atomic_load_acquire(&jl_array_data(arr, _Atomic(uint8_t))[idx]);
-    else if (el == (jl_value_t*)jl_uint16_type)
-        return jl_atomic_load_acquire(&jl_array_data(arr, _Atomic(uint16_t))[idx]);
-    else if (el == (jl_value_t*)jl_uint32_type)
-        return jl_atomic_load_acquire(&jl_array_data(arr, _Atomic(uint32_t))[idx]);
+    return val == tombstone ? (size_t)-1 : val;
+}
+static inline size_t jl_intref_acquire(const jl_genericmemory_t *arr, size_t idx) JL_NOTSAFEPOINT
+{
+    jl_value_t *el = (jl_value_t*)jl_typetagof(arr);
+    if (el == jl_memory_uint8_type)
+        return acquire_tombstone(jl_atomic_load_acquire(&((_Atomic(uint8_t)*)arr->ptr)[idx]), (uint8_t)-1);
+    else if (el == jl_memory_uint16_type)
+        return acquire_tombstone(jl_atomic_load_acquire(&((_Atomic(uint16_t)*)arr->ptr)[idx]), (uint16_t)-1);
+    else if (el == jl_memory_uint32_type)
+        return acquire_tombstone(jl_atomic_load_acquire(&((_Atomic(uint32_t)*)arr->ptr)[idx]), (uint32_t)-1);
     else
         abort();
 }
 
-static inline void jl_intset_release(const jl_array_t *arr, size_t idx, size_t val) JL_NOTSAFEPOINT
+static inline void jl_intset_release(const jl_genericmemory_t *arr, size_t idx, size_t val) JL_NOTSAFEPOINT
 {
-    jl_value_t *el = jl_tparam0(jl_typeof(arr));
-    if (el == (jl_value_t*)jl_uint8_type)
-        jl_atomic_store_release(&jl_array_data(arr, _Atomic(uint8_t))[idx], val);
-    else if (el == (jl_value_t*)jl_uint16_type)
-        jl_atomic_store_release(&jl_array_data(arr, _Atomic(uint16_t))[idx], val);
-    else if (el == (jl_value_t*)jl_uint32_type)
-        jl_atomic_store_release(&jl_array_data(arr, _Atomic(uint32_t))[idx], val);
+    jl_value_t *el = (jl_value_t*)jl_typetagof(arr);
+    if (el == jl_memory_uint8_type)
+        jl_atomic_store_release(&((_Atomic(uint8_t)*)arr->ptr)[idx], val);
+    else if (el == jl_memory_uint16_type)
+        jl_atomic_store_release(&((_Atomic(uint16_t)*)arr->ptr)[idx], val);
+    else if (el == jl_memory_uint32_type)
+        jl_atomic_store_release(&((_Atomic(uint32_t)*)arr->ptr)[idx], val);
     else
         abort();
 }
 
-static inline size_t jl_max_int(const jl_array_t *arr)
+static inline size_t jl_max_int(const jl_genericmemory_t *arr) JL_NOTSAFEPOINT
 {
-    jl_value_t *el = jl_tparam0(jl_typeof(arr));
-    if (el == (jl_value_t*)jl_uint8_type)
+    jl_value_t *el = (jl_value_t*)jl_typetagof(arr);
+    if (el == jl_memory_uint8_type)
         return 0xFF;
-    else if (el == (jl_value_t*)jl_uint16_type)
+    else if (el == jl_memory_uint16_type)
         return 0xFFFF;
-    else if (el == (jl_value_t*)jl_uint32_type)
+    else if (el == jl_memory_uint32_type)
         return 0xFFFFFFFF;
-    else if (el == (jl_value_t*)jl_any_type)
+    else if (el == jl_memory_any_type)
         return 0;
     else
         abort();
 }
 
-static jl_array_t *jl_alloc_int_1d(size_t np, size_t len)
+void smallintset_empty(const jl_genericmemory_t *a) JL_NOTSAFEPOINT
 {
-    jl_value_t *ty;
     size_t elsize;
-    if (np < 0xFF) {
-        ty = jl_array_uint8_type;
+    jl_value_t *el = (jl_value_t*)jl_typetagof(a);
+    if (el == jl_memory_uint8_type)
         elsize = sizeof(uint8_t);
-     }
-    else if (np < 0xFFFF) {
-        static jl_value_t *int16 JL_ALWAYS_LEAFTYPE = NULL;
-        if (int16 == NULL)
-            int16 = jl_apply_array_type((jl_value_t*)jl_uint16_type, 1);
-        ty = int16;
+    else if (el == jl_memory_uint16_type)
         elsize = sizeof(uint16_t);
-    }
-    else {
-        assert(np < 0x7FFFFFFF);
-        static jl_value_t *int32 JL_ALWAYS_LEAFTYPE = NULL;
-        if (int32 == NULL)
-            int32 = jl_apply_array_type((jl_value_t*)jl_uint32_type, 1);
-        ty = int32;
+    else if (el == jl_memory_uint32_type)
         elsize = sizeof(uint32_t);
-    }
-    jl_array_t *a = jl_alloc_array_1d(ty, len);
-    memset(jl_array_data(a, char), 0, len * elsize);
+    else if (el == jl_memory_any_type)
+        elsize = 0;
+    else
+        abort();
+    memset(a->ptr, 0, a->length * elsize);
+}
+
+static jl_genericmemory_t *jl_alloc_int_1d(size_t np, size_t len)
+{
+    jl_value_t *ty;
+    if (np < 0xFF)
+        ty = jl_memory_uint8_type;
+    else if (np < 0xFFFF)
+        ty = jl_memory_uint16_type;
+    else
+        ty = jl_memory_uint32_type;
+    assert(np < 0x7FFFFFFF);
+    jl_genericmemory_t *a = jl_alloc_genericmemory(ty, len);
+    smallintset_empty(a);
     return a;
 }
 
-ssize_t jl_smallintset_lookup(jl_array_t *cache, smallintset_eq eq, const void *key, jl_svec_t *data, uint_t hv)
+ssize_t jl_smallintset_lookup(jl_genericmemory_t *cache, smallintset_eq eq, const void *key, jl_value_t *data, uint_t hv, int pop)
 {
-    size_t sz = jl_array_nrows(cache);
+    size_t sz = cache->length;
     if (sz == 0)
         return -1;
     JL_GC_PUSH1(&cache);
@@ -122,8 +134,10 @@ ssize_t jl_smallintset_lookup(jl_array_t *cache, smallintset_eq eq, const void *
             JL_GC_POP();
             return -1;
         }
-        if (eq(val1 - 1, key, data, hv)) {
+        if (val1 != -1 && eq(val1 - 1, key, data, hv)) {
             JL_GC_POP();
+            if (pop)
+                jl_intset_release(cache, index, (size_t)-1); // replace with tombstone
             return val1 - 1;
         }
         index = (index + 1) & (sz - 1);
@@ -133,9 +147,9 @@ ssize_t jl_smallintset_lookup(jl_array_t *cache, smallintset_eq eq, const void *
     return -1;
 }
 
-static int smallintset_insert_(jl_array_t *a, uint_t hv, size_t val1)
+static int smallintset_insert_(jl_genericmemory_t *a, uint_t hv, size_t val1) JL_NOTSAFEPOINT
 {
-    size_t sz = jl_array_nrows(a);
+    size_t sz = a->length;
     if (sz <= 1)
         return 0;
     size_t orig, index, iter;
@@ -153,16 +167,17 @@ static int smallintset_insert_(jl_array_t *a, uint_t hv, size_t val1)
     } while (iter <= maxprobe && index != orig);
     return 0;
 }
+//}
 
-static void smallintset_rehash(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, smallintset_hash hash, jl_svec_t *data, size_t newsz, size_t np);
-
-void jl_smallintset_insert(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, smallintset_hash hash, size_t val, jl_svec_t *data)
+void jl_smallintset_insert(_Atomic(jl_genericmemory_t*) *pcache, jl_value_t *parent, smallintset_hash hash, size_t val, jl_value_t *data)
 {
-    jl_array_t *a = jl_atomic_load_relaxed(pcache);
-    if (val + 1 >  jl_max_int(a))
-        smallintset_rehash(pcache, parent, hash, data, jl_array_nrows(a), val + 1);
+    jl_genericmemory_t *a = jl_atomic_load_relaxed(pcache);
+    if (val + 1 >= jl_max_int(a)) {
+        a = smallintset_rehash(a, hash, data, a->length, val + 1);
+        jl_atomic_store_release(pcache, a);
+        if (parent) jl_gc_wb(parent, a);
+    }
     while (1) {
-        a = jl_atomic_load_relaxed(pcache);
         if (smallintset_insert_(a, hash(val, data), val + 1))
             return;
 
@@ -172,21 +187,22 @@ void jl_smallintset_insert(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, sma
         /* lots of time rehashing all the keys over and over. */
         size_t newsz;
         a = jl_atomic_load_relaxed(pcache);
-        size_t sz = jl_array_nrows(a);
+        size_t sz = a->length;
         if (sz < HT_N_INLINE)
             newsz = HT_N_INLINE;
         else if (sz >= (1 << 19) || (sz <= (1 << 8)))
             newsz = sz << 1;
         else
             newsz = sz << 2;
-        smallintset_rehash(pcache, parent, hash, data, newsz, 0);
+        a = smallintset_rehash(a, hash, data, newsz, 0);
+        jl_atomic_store_release(pcache, a);
+        if (parent) jl_gc_wb(parent, a);
     }
 }
 
-static void smallintset_rehash(_Atomic(jl_array_t*) *pcache, jl_value_t *parent, smallintset_hash hash, jl_svec_t *data, size_t newsz, size_t np)
+jl_genericmemory_t* smallintset_rehash(jl_genericmemory_t* a, smallintset_hash hash, jl_value_t *data, size_t newsz, size_t np)
 {
-    jl_array_t *a = jl_atomic_load_relaxed(pcache);
-    size_t sz = jl_array_nrows(a);
+    size_t sz = a->length;
     size_t i;
     for (i = 0; i < sz; i += 1) {
         size_t val = jl_intref(a, i);
@@ -194,7 +210,7 @@ static void smallintset_rehash(_Atomic(jl_array_t*) *pcache, jl_value_t *parent,
             np = val;
     }
     while (1) {
-        jl_array_t *newa = jl_alloc_int_1d(np, newsz);
+        jl_genericmemory_t *newa = jl_alloc_int_1d(np + 1, newsz);
         JL_GC_PUSH1(&newa);
         for (i = 0; i < sz; i += 1) {
             size_t val1 = jl_intref(a, i);
@@ -205,16 +221,12 @@ static void smallintset_rehash(_Atomic(jl_array_t*) *pcache, jl_value_t *parent,
             }
         }
         JL_GC_POP();
-        if (i == sz) {
-            jl_atomic_store_release(pcache, newa);
-            jl_gc_wb(parent, newa);
-            return;
-        }
+        if (i == sz)
+            return newa;
         newsz <<= 1;
     }
 }
 
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/staticdata.c b/src/staticdata.c
index 52a354b4933d7..6f21d0aa4aa2c 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -98,7 +98,7 @@ extern "C" {
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
-#define NUM_TAGS    175
+#define NUM_TAGS    178
 
 // An array of references that need to be restored from the sysimg
 // This is a manually constructed dual of the gvars array, which would be produced by codegen for Julia code, for C.
@@ -201,6 +201,9 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_genericmemory_type);
         INSERT_TAG(jl_memory_any_type);
         INSERT_TAG(jl_memory_uint8_type);
+        INSERT_TAG(jl_memory_uint16_type);
+        INSERT_TAG(jl_memory_uint32_type);
+        INSERT_TAG(jl_memory_uint64_type);
         INSERT_TAG(jl_genericmemoryref_type);
         INSERT_TAG(jl_memoryref_any_type);
         INSERT_TAG(jl_memoryref_uint8_type);
@@ -2420,7 +2423,8 @@ static void jl_strip_all_codeinfos(void)
 
 // --- entry points ---
 
-jl_genericmemory_t *jl_global_roots_table;
+jl_genericmemory_t *jl_global_roots_list;
+jl_genericmemory_t *jl_global_roots_keyset;
 jl_mutex_t global_roots_lock;
 
 JL_DLLEXPORT int jl_is_globally_rooted(jl_value_t *val JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT
@@ -2449,14 +2453,17 @@ JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val JL_MAYBE_UNROOTED)
         if ((uint64_t)(n+512) < 1024)
             return jl_box_int64(n);
     }
+    // TODO: check table before acquiring lock to reduce writer contention
     JL_GC_PUSH1(&val);
     JL_LOCK(&global_roots_lock);
-    jl_value_t *rval = jl_eqtable_getkey(jl_global_roots_table, val, NULL);
+    jl_value_t *rval = jl_idset_get(jl_global_roots_list, jl_global_roots_keyset, val);
     if (rval) {
         val = rval;
     }
     else {
-        jl_global_roots_table = jl_eqtable_put(jl_global_roots_table, val, jl_nothing, NULL);
+        ssize_t idx;
+        jl_global_roots_list = jl_idset_put_key(jl_global_roots_list, val, &idx);
+        jl_global_roots_keyset = jl_idset_put_idx(jl_global_roots_list, jl_global_roots_keyset, idx);
     }
     JL_UNLOCK(&global_roots_lock);
     JL_GC_POP();
@@ -2597,7 +2604,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
             jl_docmeta_sym = (jl_sym_t*)jl_get_global((jl_module_t*)docs, jl_symbol("META"));
         }
     }
-    jl_genericmemory_t *global_roots_table = NULL;
+    jl_genericmemory_t *global_roots_list = NULL;
 
     { // step 1: record values (recursively) that need to go in the image
         size_t i;
@@ -2641,15 +2648,17 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
         record_gvars(&s, &gvars);
         record_external_fns(&s, &external_fns);
         jl_serialize_reachable(&s);
-        // step 1.3: prune (garbage collect) special weak references from the jl_global_roots_table
+        // step 1.3: prune (garbage collect) special weak references from the jl_global_roots_list
         if (worklist == NULL) {
-            global_roots_table = jl_alloc_memory_any(0);
-            for (size_t i = 0; i < jl_global_roots_table->length; i += 2) {
-                jl_value_t *val = jl_genericmemory_ptr_ref(jl_global_roots_table, i);
-                if (ptrhash_get(&serialization_order, val) != HT_NOTFOUND)
-                    global_roots_table = jl_eqtable_put(global_roots_table, val, jl_nothing, NULL);
+            global_roots_list = jl_alloc_memory_any(0);
+            for (size_t i = 0; i < jl_global_roots_list->length; i++) {
+                jl_value_t *val = jl_genericmemory_ptr_ref(jl_global_roots_list, i);
+                if (val && ptrhash_get(&serialization_order, val) != HT_NOTFOUND) {
+                    ssize_t idx;
+                    global_roots_list = jl_idset_put_key(global_roots_list, val, &idx);
+                }
             }
-            jl_queue_for_serialization(&s, global_roots_table);
+            jl_queue_for_serialization(&s, global_roots_list);
             jl_serialize_reachable(&s);
         }
         // step 1.4: prune (garbage collect) some special weak references from
@@ -2761,7 +2770,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
                 jl_value_t *tag = *tags[i];
                 jl_write_value(&s, tag);
             }
-            jl_write_value(&s, global_roots_table);
+            jl_write_value(&s, global_roots_list);
             jl_write_value(&s, s.ptls->root_task->tls);
             write_uint32(f, jl_get_gs_ctr());
             write_uint(f, jl_atomic_load_acquire(&jl_world_counter));
@@ -3072,7 +3081,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         JL_SMALL_TYPEOF(XX)
 #undef XX
         export_jl_small_typeof();
-        jl_global_roots_table = (jl_genericmemory_t*)jl_read_value(&s);
+        jl_global_roots_list = (jl_genericmemory_t*)jl_read_value(&s);
         // set typeof extra-special values now that we have the type set by tags above
         jl_astaggedvalue(jl_nothing)->header = (uintptr_t)jl_nothing_type | jl_astaggedvalue(jl_nothing)->header;
         s.ptls->root_task->tls = jl_read_value(&s);
@@ -3370,6 +3379,8 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         o->bits.in_image = 1;
     }
     arraylist_free(&cleanup_list);
+    if (!s.incremental && jl_global_roots_list->length > 0)
+        jl_global_roots_keyset = jl_idset_put_idx(jl_global_roots_list, (jl_genericmemory_t*)jl_an_empty_memory_any, -jl_global_roots_list->length);
     for (size_t i = 0; i < s.fixup_objs.len; i++) {
         uintptr_t item = (uintptr_t)s.fixup_objs.items[i];
         jl_value_t *obj = (jl_value_t*)(image_base + item);
diff --git a/sysimage.mk b/sysimage.mk
index 44c5762ec8b81..e6fa54be5f186 100644
--- a/sysimage.mk
+++ b/sysimage.mk
@@ -26,6 +26,9 @@ COMPILER_SRCS := $(addprefix $(JULIAHOME)/, \
 		base/docs/core.jl \
 		base/abstractarray.jl \
 		base/abstractdict.jl \
+		base/abstractset.jl \
+		base/iddict.jl \
+		base/idset.jl \
 		base/array.jl \
 		base/bitarray.jl \
 		base/bitset.jl \

From 18c6c66ada1eb11dc950b34c3e7bd1406ab2342f Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 25 Nov 2023 09:15:48 -0500
Subject: [PATCH 0328/1315] Bail out of constprop if we already know it's gonna
 throw an error (#52293)

While looking at some other things, I noticed that we call concrete
evaluation on every `error("foo")`-like call just to find out again that
it errors. which is obviously wasteful. In the future we may want to
model exception-`:consistent`-cy in which case there could be some
additional `exct` refinement here, but we're not there yet.

---------

Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
---
 base/compiler/abstractinterpretation.jl | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 6563f5589c71d..1b860bb8aee6a 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -869,6 +869,15 @@ function bail_out_const_call(interp::AbstractInterpreter, result::MethodCallResu
         if isa(result.rt, Const) || call_result_unused(si)
             return true
         end
+    elseif result.rt === Bottom
+        if is_terminates(result.effects) && is_effect_free(result.effects)
+            # In the future, we may want to add `&& isa(result.exct, Const)` to
+            # the list of conditions here, but currently, our effect system isn't
+            # precise enough to let us determine :consistency of `exct`, so we
+            # would have to force constprop just to determine this, which is too
+            # expensive.
+            return true
+        end
     end
     return false
 end

From ea261ce1a4906820dfc7e7079933ee282093db1f Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 25 Nov 2023 09:16:02 -0500
Subject: [PATCH 0329/1315] Automatically :leave the exception frame on the
 catch edge (#52245)

Right now, we require a :leave expression at both the end of a try
region and as the first expression in the catch block. This doesn't
really make sense. Throwing the exception should leave the exception
frame implicitly. This isn't a huge saving, but does save one IR node
(and generated call in the native code) per try/catch block.
---
 base/compiler/inferencestate.jl   |  7 +++++--
 src/codegen.cpp                   |  7 ++++++-
 src/interpreter.c                 | 24 +++++++++++++-----------
 src/julia-syntax.scm              |  4 ++--
 test/compiler/inference.jl        | 24 +++++++++++-------------
 test/compiler/interpreter_exec.jl |  1 -
 test/show.jl                      |  4 ++--
 7 files changed, 39 insertions(+), 32 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 7085b87db9beb..dd3b10405fccf 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -368,7 +368,7 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
             handler_id = length(handlers)
             handler_at[pc + 1] = (handler_id, 0)
             push!(ip, pc + 1)
-            handler_at[l] = (handler_id, handler_id)
+            handler_at[l] = (0, handler_id)
             push!(ip, l)
         end
     end
@@ -399,7 +399,10 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
             elseif isa(stmt, Expr)
                 head = stmt.head
                 if head === :enter
-                    # Already set above
+                    l = stmt.args[1]::Int
+                    # We assigned a handler number above. Here we just merge that
+                    # with out current handler information.
+                    handler_at[l] = (cur_stacks[1], handler_at[l][2])
                     cur_stacks = (handler_at[pc´][1], cur_stacks[2])
                 elseif head === :leave
                     l = 0
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 45b20e0044847..bd5572ce7be16 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -8745,11 +8745,16 @@ static jl_llvm_functions_t
             sj->setCanReturnTwice();
             Value *isz = ctx.builder.CreateICmpEQ(sj, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 0));
             BasicBlock *tryblk = BasicBlock::Create(ctx.builder.getContext(), "try", f);
+            BasicBlock *catchpop = BasicBlock::Create(ctx.builder.getContext(), "catch_pop", f);
             BasicBlock *handlr = NULL;
             handlr = BB[lname];
             workstack.push_back(lname - 1);
             come_from_bb[cursor + 1] = ctx.builder.GetInsertBlock();
-            ctx.builder.CreateCondBr(isz, tryblk, handlr);
+            ctx.builder.CreateCondBr(isz, tryblk, catchpop);
+            ctx.builder.SetInsertPoint(catchpop);
+            ctx.builder.CreateCall(prepare_call(jlleave_func),
+                            ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 1));
+            ctx.builder.CreateBr(handlr);
             ctx.builder.SetInsertPoint(tryblk);
         }
         else {
diff --git a/src/interpreter.c b/src/interpreter.c
index d9536ca512889..7f8bd236819d5 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -550,15 +550,17 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
                 s->locals[jl_source_nslots(s->src) + ip] = jl_box_ulong(jl_excstack_state());
                 if (!jl_setjmp(__eh.eh_ctx, 1)) {
                     return eval_body(stmts, s, next_ip, toplevel);
-                }
-                else if (s->continue_at) { // means we reached a :leave expression
-                    ip = s->continue_at;
-                    s->continue_at = 0;
-                    continue;
-                }
-                else { // a real exception
-                    ip = catch_ip;
-                    continue;
+                } else {
+                    jl_eh_restore_state(&__eh);
+                    if (s->continue_at) { // means we reached a :leave expression
+                        ip = s->continue_at;
+                        s->continue_at = 0;
+                        continue;
+                    }
+                    else { // a real exception
+                        ip = catch_ip;
+                        continue;
+                    }
                 }
             }
             else if (head == jl_leave_sym) {
@@ -575,11 +577,11 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
                 }
                 if (hand_n_leave > 0) {
                     assert(hand_n_leave > 0);
-                    // equivalent to jl_pop_handler(hand_n_leave), but retaining eh for longjmp:
+                    // equivalent to jl_pop_handler(hand_n_leave), longjmping
+                    // to the :enter code above instead, which handles cleanup
                     jl_handler_t *eh = ct->eh;
                     while (--hand_n_leave > 0)
                         eh = eh->prev;
-                    jl_eh_restore_state(eh);
                     // leave happens during normal control flow, but we must
                     // longjmp to pop the eval_body call for each enter.
                     s->continue_at = next_ip;
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 2937f31ecc0f2..4dd7735776315 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -4755,9 +4755,9 @@ f(x) = yt(x)
                             (let ((v3 (compile (cadddr e) break-labels value tail))) ;; emit else block code
                               (if val (emit-assignment val v3)))
                             (if endl (emit `(goto ,endl)))))
-                 ;; emit either catch or finally block
+                 ;; emit either catch or finally block. A combined try/catch/finally block was split into
+                 ;; separate trycatch and tryfinally blocks earlier.
                  (mark-label catch)
-                 (emit `(leave ,handler-token))
                  (if finally
                      (begin (enter-finally-block '(call (top rethrow)) #f) ;; enter block via exception
                             (mark-label endl) ;; non-exceptional control flow enters here
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 88bd4d8fba007..f0a01eba61405 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -4416,7 +4416,7 @@ g41908() = f41908(Any[1][1])
 # issue #42022
 let x = Tuple{Int,Any}[
         #= 1=# (0, Expr(:(=), Core.SlotNumber(3), 1))
-        #= 2=# (0, Expr(:enter, 18))
+        #= 2=# (0, Expr(:enter, 17))
         #= 3=# (2, Expr(:(=), Core.SlotNumber(3), 2.0))
         #= 4=# (2, Expr(:enter, 12))
         #= 5=# (4, Expr(:(=), Core.SlotNumber(3), '3'))
@@ -4425,18 +4425,16 @@ let x = Tuple{Int,Any}[
         #= 8=# (0, Core.ReturnNode(1))
         #= 9=# (4, Expr(:call, GlobalRef(Main, :throw)))
         #=10=# (4, Expr(:leave, Core.SSAValue(4)))
-        #=11=# (2, Core.GotoNode(16))
-        #=12=# (4, Expr(:leave, Core.SSAValue(4)))
-        #=13=# (2, Expr(:(=), Core.SlotNumber(4), Expr(:the_exception)))
-        #=14=# (2, Expr(:call, GlobalRef(Main, :rethrow)))
-        #=15=# (2, Expr(:pop_exception, Core.SSAValue(4)))
-        #=16=# (2, Expr(:leave, Core.SSAValue(2)))
-        #=17=# (0, Core.GotoNode(22))
-        #=18=# (2, Expr(:leave, Core.SSAValue(2)))
-        #=19=# (0, Expr(:(=), Core.SlotNumber(5), Expr(:the_exception)))
-        #=20=# (0, nothing)
-        #=21=# (0, Expr(:pop_exception, Core.SSAValue(2)))
-        #=22=# (0, Core.ReturnNode(Core.SlotNumber(3)))
+        #=11=# (2, Core.GotoNode(15))
+        #=12=# (2, Expr(:(=), Core.SlotNumber(4), Expr(:the_exception)))
+        #=13=# (2, Expr(:call, GlobalRef(Main, :rethrow)))
+        #=14=# (2, Expr(:pop_exception, Core.SSAValue(4)))
+        #=15=# (2, Expr(:leave, Core.SSAValue(2)))
+        #=16=# (0, Core.GotoNode(20))
+        #=17=# (0, Expr(:(=), Core.SlotNumber(5), Expr(:the_exception)))
+        #=18=# (0, nothing)
+        #=19=# (0, Expr(:pop_exception, Core.SSAValue(2)))
+        #=20=# (0, Core.ReturnNode(Core.SlotNumber(3)))
     ]
     handler_at, handlers = Core.Compiler.compute_trycatch(last.(x), Core.Compiler.BitSet())
     @test map(x->x[1] == 0 ? 0 : handlers[x[1]].enter_idx, handler_at) == first.(x)
diff --git a/test/compiler/interpreter_exec.jl b/test/compiler/interpreter_exec.jl
index 641656196c00d..47dc3778402bd 100644
--- a/test/compiler/interpreter_exec.jl
+++ b/test/compiler/interpreter_exec.jl
@@ -94,7 +94,6 @@ let m = Meta.@lower 1 + 1
         # block 6
         Core.PhiCNode(Any[Core.SSAValue(5), Core.SSAValue(7), Core.SSAValue(9)]), # NULL, :a, :b
         Core.PhiCNode(Any[Core.SSAValue(6)]), # NULL
-        Expr(:leave, Core.SSAValue(4)),
         # block 7
         ReturnNode(Core.SSAValue(11)),
     ]
diff --git a/test/show.jl b/test/show.jl
index 899327d80b531..a2ed2bba31f50 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2089,8 +2089,8 @@ let src = code_typed(my_fun28173, (Int,), debuginfo=:source)[1][1]
     end
     @test popfirst!(lines2) == "   │          $(QuoteNode(2))"
     @test pop!(lines2) == "   └───       \$(QuoteNode(4))"
-    @test pop!(lines1) == "18 └───       return %22"
-    @test pop!(lines2) == "   │          return %22"
+    @test pop!(lines1) == "18 └───       return %21"
+    @test pop!(lines2) == "   │          return %21"
     @test pop!(lines2) == "18 │          \$(QuoteNode(3))"
     @test lines1 == lines2
 

From 9ea29d9b8f41509ea2609ce012cea69dfc4285e8 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Sat, 25 Nov 2023 10:13:27 -0500
Subject: [PATCH 0330/1315] Make PersistentDict behave like an IdDict (#52193)

---
 base/dict.jl | 33 ++++++++++++-------
 base/hamt.jl | 32 +++++++++++-------
 test/dict.jl | 93 +++++++++++++++++++++-------------------------------
 3 files changed, 80 insertions(+), 78 deletions(-)

diff --git a/base/dict.jl b/base/dict.jl
index 26896c78a7008..83180f5c0ee1b 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -902,6 +902,10 @@ returns a new dictionary separate from the previous one, but the underlying
 implementation is space-efficient and may share storage across multiple
 separate dictionaries.
 
+!!!note
+    It behaves like an IdDict.
+
+
     PersistentDict(KV::Pair)
 
 # Examples
@@ -922,24 +926,31 @@ Base.PersistentDict{Symbol, Int64} with 1 entry:
 PersistentDict
 
 PersistentDict{K,V}() where {K,V} = PersistentDict(HAMT.HAMT{K,V}())
-PersistentDict{K,V}(KV::Pair) where {K,V} = PersistentDict(HAMT.HAMT{K,V}(KV...))
-PersistentDict(KV::Pair{K,V}) where {K,V} = PersistentDict(HAMT.HAMT{K,V}(KV...))
+PersistentDict{K,V}(KV::Pair) where {K,V} = PersistentDict(HAMT.HAMT{K,V}(KV))
+PersistentDict(KV::Pair{K,V}) where {K,V} = PersistentDict(HAMT.HAMT{K,V}(KV))
 PersistentDict(dict::PersistentDict, pair::Pair) = PersistentDict(dict, pair...)
 PersistentDict{K,V}(dict::PersistentDict{K,V}, pair::Pair) where {K,V} = PersistentDict(dict, pair...)
 function PersistentDict(dict::PersistentDict{K,V}, key, val) where {K,V}
     key = convert(K, key)
     val = convert(V, val)
     trie = dict.trie
-    h = hash(key)
+    h = HAMT.HashState(key)
     found, present, trie, i, bi, top, hs = HAMT.path(trie, key, h, #=persistent=# true)
     HAMT.insert!(found, present, trie, i, bi, hs, val)
     return PersistentDict(top)
 end
 
+function PersistentDict{K,V}(KV::Pair, rest::Pair...) where {K,V}
+    dict = PersistentDict{K,V}(KV)
+    for (key, value) in rest
+        dict = PersistentDict(dict, key, value)
+    end
+    return dict
+end
+
 function PersistentDict(kv::Pair, rest::Pair...)
     dict = PersistentDict(kv)
-    for kv in rest
-        key, value = kv
+    for (key, value) in rest
         dict = PersistentDict(dict, key, value)
     end
     return dict
@@ -955,7 +966,7 @@ function in(key_val::Pair{K,V}, dict::PersistentDict{K,V}, valcmp=(==)) where {K
 
     key, val = key_val
 
-    h = hash(key)
+    h = HAMT.HashState(key)
     found, present, trie, i, _, _, _ = HAMT.path(trie, key, h)
     if found && present
         leaf = @inbounds trie.data[i]::HAMT.Leaf{K,V}
@@ -966,7 +977,7 @@ end
 
 function haskey(dict::PersistentDict{K}, key::K) where K
     trie = dict.trie
-    h = hash(key)
+    h = HAMT.HashState(key)
     found, present, _, _, _, _, _ = HAMT.path(trie, key, h)
     return found && present
 end
@@ -976,7 +987,7 @@ function getindex(dict::PersistentDict{K,V}, key::K) where {K,V}
     if HAMT.islevel_empty(trie)
         throw(KeyError(key))
     end
-    h = hash(key)
+    h = HAMT.HashState(key)
     found, present, trie, i, _, _, _ = HAMT.path(trie, key, h)
     if found && present
         leaf = @inbounds trie.data[i]::HAMT.Leaf{K,V}
@@ -990,7 +1001,7 @@ function get(dict::PersistentDict{K,V}, key::K, default) where {K,V}
     if HAMT.islevel_empty(trie)
         return default
     end
-    h = hash(key)
+    h = HAMT.HashState(key)
     found, present, trie, i, _, _, _ = HAMT.path(trie, key, h)
     if found && present
         leaf = @inbounds trie.data[i]::HAMT.Leaf{K,V}
@@ -1004,7 +1015,7 @@ function get(default::Callable, dict::PersistentDict{K,V}, key::K) where {K,V}
     if HAMT.islevel_empty(trie)
         return default
     end
-    h = hash(key)
+    h = HAMT.HashState(key)
     found, present, trie, i, _, _, _ = HAMT.path(trie, key, h)
     if found && present
         leaf = @inbounds trie.data[i]::HAMT.Leaf{K,V}
@@ -1017,7 +1028,7 @@ iterate(dict::PersistentDict, state=nothing) = HAMT.iterate(dict.trie, state)
 
 function delete(dict::PersistentDict{K}, key::K) where K
     trie = dict.trie
-    h = hash(key)
+    h = HAMT.HashState(key)
     found, present, trie, i, bi, top, _ = HAMT.path(trie, key, h, #=persistent=# true)
     if found && present
         deleteat!(trie.data, i)
diff --git a/base/hamt.jl b/base/hamt.jl
index d801352fce6c5..e940f4e00b1d5 100644
--- a/base/hamt.jl
+++ b/base/hamt.jl
@@ -62,36 +62,47 @@ A HashArrayMappedTrie that optionally supports persistence.
 mutable struct HAMT{K, V}
     const data::Vector{Union{Leaf{K, V}, HAMT{K, V}}}
     bitmap::BITMAP
+    HAMT{K,V}(data, bitmap) where {K,V} = new{K,V}(data, bitmap)
+    HAMT{K, V}() where {K, V} = new{K,V}(Vector{Union{Leaf{K, V}, HAMT{K, V}}}(undef, 0), zero(BITMAP))
 end
-HAMT{K, V}() where {K, V} = HAMT(Vector{Union{Leaf{K, V}, HAMT{K, V}}}(undef, 0), zero(BITMAP))
-function HAMT{K,V}(k::K, v) where {K, V}
+function HAMT{K,V}((k,v)::Pair) where {K, V}
+    k = convert(K, k)
     v = convert(V, v)
     # For a single element we can't have a hash-collision
-    trie = HAMT(Vector{Union{Leaf{K, V}, HAMT{K, V}}}(undef, 1), zero(BITMAP))
+    trie = HAMT{K,V}(Vector{Union{Leaf{K, V}, HAMT{K, V}}}(undef, 1), zero(BITMAP))
     trie.data[1] = Leaf{K,V}(k,v)
     bi = BitmapIndex(HashState(k))
     set!(trie, bi)
     return trie
 end
-HAMT(k::K, v::V) where {K, V} = HAMT{K,V}(K, V)
+HAMT(pair::Pair{K,V}) where {K, V} = HAMT{K,V}(pair)
 
+# TODO: Parameterize by hash function
 struct HashState{K}
     key::K
     hash::UInt
     depth::Int
     shift::Int
 end
-HashState(key)= HashState(key, hash(key), 0, 0)
+HashState(key) = HashState(key, objectid(key), 0, 0)
 # Reconstruct
-HashState(key, depth, shift) = HashState(key, hash(key, UInt(depth ÷ BITS_PER_LEVEL)), depth, shift)
+function HashState(other::HashState, key)
+    h = HashState(key)
+    while h.depth !== other.depth
+        h = next(h)
+    end
+    return h
+end
 
 function next(h::HashState)
     depth = h.depth + 1
     shift = h.shift + BITS_PER_LEVEL
+    @assert h.shift <= MAX_SHIFT
     if shift > MAX_SHIFT
         # Note we use `UInt(depth ÷ BITS_PER_LEVEL)` to seed the hash function
         # the hash docs, do we need to hash `UInt(depth ÷ BITS_PER_LEVEL)` first?
-        h_hash = hash(h.key, UInt(depth ÷ BITS_PER_LEVEL))
+        h_hash = hash(objectid(h.key), UInt(depth ÷ BITS_PER_LEVEL))
+        shift = 0
     else
         h_hash = h.hash
     end
@@ -137,8 +148,7 @@ as the current `level`.
 If a copy function is provided `copyf` use the return `top` for the
 new persistent tree.
 """
-@inline function path(trie::HAMT{K,V}, key, _h, copy=false) where {K, V}
-    h = HashState(key, _h, 0, 0)
+@inline function path(trie::HAMT{K,V}, key, h::HashState, copy=false) where {K, V}
     if copy
         trie = top = HAMT{K,V}(Base.copy(trie.data), trie.bitmap)
     else
@@ -151,7 +161,7 @@ new persistent tree.
             next = @inbounds trie.data[i]
             if next isa Leaf{K,V}
                 # Check if key match if not we will need to grow.
-                found = (next.key === h.key || isequal(next.key, h.key))
+                found = next.key === h.key
                 return found, true, trie, i, bi, top, h
             end
             if copy
@@ -184,7 +194,7 @@ or grows the HAMT by inserting a new trie instead.
         @assert present
         # collision -> grow
         leaf = @inbounds trie.data[i]::Leaf{K,V}
-        leaf_h = HashState(leaf.key, h.depth, h.shift)
+        leaf_h = HashState(h, leaf.key)
         if leaf_h.hash == h.hash
             error("Perfect hash collision")
         end
diff --git a/test/dict.jl b/test/dict.jl
index d3d1c3732eee2..d5ae88735dd43 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -1084,17 +1084,30 @@ Dict(1 => rand(2,3), 'c' => "asdf") # just make sure this does not trigger a dep
     GC.@preserve A B C D nothing
 end
 
-mutable struct CollidingHash
-end
-Base.hash(::CollidingHash, h::UInt) = hash(UInt(0), h)
-
-struct PredictableHash
-    x::UInt
-end
-Base.hash(x::PredictableHash, h::UInt) = x.x
-
 import Base.PersistentDict
 @testset "PersistentDict" begin
+    @testset "HAMT HashState" begin
+        key = :key
+        h = Base.HAMT.HashState(key)
+        h1 = Base.HAMT.HashState(key, objectid(key), 0, 0)
+        h2 = Base.HAMT.HashState(h, key) # reconstruct
+        @test h.hash == h1.hash
+        @test h.hash == h2.hash
+
+        hs = Base.HAMT.next(h1)
+        @test hs.depth == 1
+        recompute_depth = (Base.HAMT.MAX_SHIFT ÷ Base.HAMT.BITS_PER_LEVEL) + 1
+        for i in 2:recompute_depth
+            hs = Base.HAMT.next(hs)
+            @test hs.depth == i
+        end
+        @test hs.depth == recompute_depth
+        @test hs.shift == 0
+        hsr = Base.HAMT.HashState(hs, key)
+        @test hs.hash == hsr.hash
+        @test hs.depth == hsr.depth
+        @test hs.shift == hsr.shift
+    end
     @testset "basics" begin
         dict = PersistentDict{Int, Int}()
         @test_throws KeyError dict[1]
@@ -1145,6 +1158,21 @@ import Base.PersistentDict
         @test dict[4] == 1
     end
 
+    @testset "objectid" begin
+        c = [0]
+        dict = PersistentDict{Any, Int}(c => 1, [1] => 2)
+        @test dict[c] == 1
+        c[1] = 1
+        @test dict[c] == 1
+
+        c[1] = 0
+        dict = PersistentDict{Any, Int}((c,) => 1, ([1],) => 2)
+        @test dict[(c,)] == 1
+
+        c[1] = 1
+        @test dict[(c,)] == 1
+    end
+
     @testset "stress" begin
         N = 2^14
         dict = PersistentDict{Int, Int}()
@@ -1164,53 +1192,6 @@ import Base.PersistentDict
         end
         @test isempty(dict)
     end
-
-    @testset "CollidingHash" begin
-        dict = PersistentDict{CollidingHash, Nothing}()
-        dict = PersistentDict(dict, CollidingHash(), nothing)
-        @test_throws ErrorException PersistentDict(dict, CollidingHash(), nothing)
-    end
-
-    # Test the internal implementation
-    @testset "PredictableHash" begin
-        dict = PersistentDict{PredictableHash, Nothing}()
-        for i in 1:Base.HashArrayMappedTries.ENTRY_COUNT
-            key = PredictableHash(UInt(i-1)) # Level 0
-            dict = PersistentDict(dict, key, nothing)
-        end
-        @test length(dict.trie.data) == Base.HashArrayMappedTries.ENTRY_COUNT
-        @test dict.trie.bitmap == typemax(Base.HashArrayMappedTries.BITMAP)
-        for entry in dict.trie.data
-            @test entry isa Base.HashArrayMappedTries.Leaf
-        end
-
-        dict = PersistentDict{PredictableHash, Nothing}()
-        for i in 1:Base.HashArrayMappedTries.ENTRY_COUNT
-            key = PredictableHash(UInt(i-1) << Base.HashArrayMappedTries.BITS_PER_LEVEL) # Level 1
-            dict = PersistentDict(dict, key, nothing)
-        end
-        @test length(dict.trie.data) == 1
-        @test length(dict.trie.data[1].data) == 32
-
-        max_level = (Base.HashArrayMappedTries.NBITS ÷ Base.HashArrayMappedTries.BITS_PER_LEVEL)
-        dict = PersistentDict{PredictableHash, Nothing}()
-        for i in 1:Base.Base.HashArrayMappedTries.ENTRY_COUNT
-            key = PredictableHash(UInt(i-1) << (max_level * Base.HashArrayMappedTries.BITS_PER_LEVEL)) # Level 12
-            dict = PersistentDict(dict, key, nothing)
-        end
-        data = dict.trie.data
-        for level in 1:max_level
-            @test length(data) == 1
-            data = only(data).data
-        end
-        last_level_nbits = Base.HashArrayMappedTries.NBITS - (max_level * Base.HashArrayMappedTries.BITS_PER_LEVEL)
-        if Base.HashArrayMappedTries.NBITS == 64
-            @test last_level_nbits == 4
-        elseif Base.HashArrayMappedTries.NBITS == 32
-            @test last_level_nbits == 2
-        end
-        @test length(data) == 2^last_level_nbits
-    end
 end
 
 @testset "issue #19995, hash of dicts" begin

From 49c2d89a2286288263fd4b7bc60e04da999ebc12 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 26 Nov 2023 00:20:52 -0500
Subject: [PATCH 0331/1315] jltypes: avoid creating lots of duplicates of this
 function (#52299)

Core.Compiler calls this on many functions, creating associated Types
inferred for each for some reason. This saves several MB from the system
image.
---
 base/array.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/base/array.jl b/base/array.jl
index e90723957afdb..23a1a59052147 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -977,6 +977,8 @@ function setindex!(A::Array{T}, x, i1::Int, i2::Int, I::Int...) where {T}
     return A
 end
 
+__safe_setindex!(A::Vector{Any}, @nospecialize(x), i::Int) = (@inline; @_nothrow_noub_meta;
+    memoryrefset!(memoryref(A.ref, i, false), x, :not_atomic, false); return A)
 __safe_setindex!(A::Vector{T}, x::T, i::Int) where {T} = (@inline; @_nothrow_noub_meta;
     memoryrefset!(memoryref(A.ref, i, false), x, :not_atomic, false); return A)
 __safe_setindex!(A::Vector{T}, x,    i::Int) where {T} = (@inline;

From c30d45dfdf63c83eb864ebe924a715fe283013b4 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 26 Nov 2023 11:05:52 -0500
Subject: [PATCH 0332/1315] Make :enter a proper node type (#52300)

This is a prepratory commit in anticipation of giving :enter additional
responsibilities of entering and restoring dynamic scopes for
ScopedValue (c.f. #51352). This commit simply turns `:enter` into its
own node type (like the other terminators). The changes are largely
mechanical from the `Expr` version, but will make it easier to add
additional semantics in a follow up PR.
---
 base/boot.jl                                  |  8 +-
 base/compiler/abstractinterpretation.jl       | 11 +--
 base/compiler/inferencestate.jl               | 20 ++---
 base/compiler/optimize.jl                     | 37 ++++----
 .../ssair/EscapeAnalysis/EscapeAnalysis.jl    |  9 +-
 base/compiler/ssair/inlining.jl               |  8 +-
 base/compiler/ssair/ir.jl                     | 41 +++++----
 base/compiler/ssair/irinterp.jl               |  9 +-
 base/compiler/ssair/legacy.jl                 | 10 +--
 base/compiler/ssair/passes.jl                 |  8 +-
 base/compiler/ssair/show.jl                   | 14 ++-
 base/compiler/ssair/slot2ssa.jl               | 18 ++--
 base/compiler/ssair/verify.jl                 | 10 +--
 base/meta.jl                                  |  5 +-
 src/ast.c                                     |  5 ++
 src/builtins.c                                |  1 +
 src/codegen.cpp                               | 43 ++++-----
 src/interpreter.c                             | 89 +++++++++----------
 src/jl_exported_data.inc                      |  1 +
 src/jltypes.c                                 |  6 ++
 src/julia.h                                   |  3 +
 src/staticdata.c                              |  3 +-
 test/compiler/inference.jl                    |  4 +-
 test/compiler/interpreter_exec.jl             |  2 +-
 24 files changed, 191 insertions(+), 174 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 2dc19528e178e..b84f9b76838e0 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -459,6 +459,7 @@ eval(Core, quote
     ReturnNode(@nospecialize val) = $(Expr(:new, :ReturnNode, :val))
     ReturnNode() = $(Expr(:new, :ReturnNode)) # unassigned val indicates unreachable
     GotoIfNot(@nospecialize(cond), dest::Int) = $(Expr(:new, :GotoIfNot, :cond, :dest))
+    EnterNode(dest::Int) = $(Expr(:new, :EnterNode, :dest))
     LineNumberNode(l::Int) = $(Expr(:new, :LineNumberNode, :l, nothing))
     function LineNumberNode(l::Int, @nospecialize(f))
         isa(f, String) && (f = Symbol(f))
@@ -626,12 +627,12 @@ module IR
 export CodeInfo, MethodInstance, CodeInstance, GotoNode, GotoIfNot, ReturnNode,
     NewvarNode, SSAValue, SlotNumber, Argument,
     PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode,
-    Const, PartialStruct, InterConditional
+    Const, PartialStruct, InterConditional, EnterNode
 
 using Core: CodeInfo, MethodInstance, CodeInstance, GotoNode, GotoIfNot, ReturnNode,
     NewvarNode, SSAValue, SlotNumber, Argument,
     PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode,
-    Const, PartialStruct, InterConditional
+    Const, PartialStruct, InterConditional, EnterNode
 
 end # module IR
 
@@ -965,4 +966,7 @@ arraysize(a::Array) = a.size
 arraysize(a::Array, i::Int) = sle_int(i, nfields(a.size)) ? getfield(a.size, i) : 1
 export arrayref, arrayset, arraysize, const_arrayref
 
+# For convenience
+EnterNode(old::EnterNode, new_dest::Int) = EnterNode(new_dest)
+
 ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Core, true)
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 1b860bb8aee6a..f284928b17135 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -3102,8 +3102,8 @@ function update_exc_bestguess!(@nospecialize(exct), frame::InferenceState, 𝕃
         handler_frame = frame.handlers[cur_hand]
         if !⊑(𝕃ₚ, exct, handler_frame.exct)
             handler_frame.exct = tmerge(𝕃ₚ, handler_frame.exct, exct)
-            enter = frame.src.code[handler_frame.enter_idx]::Expr
-            exceptbb = block_for_inst(frame.cfg, enter.args[1]::Int)
+            enter = frame.src.code[handler_frame.enter_idx]::EnterNode
+            exceptbb = block_for_inst(frame.cfg, enter.catch_dest)
             push!(frame.ip, exceptbb)
         end
     end
@@ -3114,8 +3114,8 @@ function propagate_to_error_handler!(currstate::VarTable, frame::InferenceState,
     # exception handler, BEFORE applying any state changes.
     cur_hand = frame.handler_at[frame.currpc][1]
     if cur_hand != 0
-        enter = frame.src.code[frame.handlers[cur_hand].enter_idx]::Expr
-        exceptbb = block_for_inst(frame.cfg, enter.args[1]::Int)
+        enter = frame.src.code[frame.handlers[cur_hand].enter_idx]::EnterNode
+        exceptbb = block_for_inst(frame.cfg, enter.catch_dest)
         if update_bbstate!(𝕃ᵢ, frame, exceptbb, currstate)
             push!(frame.ip, exceptbb)
         end
@@ -3256,8 +3256,9 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                     end
                     ssavaluetypes[frame.currpc] = Any
                     @goto find_next_bb
-                elseif isexpr(stmt, :enter)
+                elseif isa(stmt, EnterNode)
                     ssavaluetypes[currpc] = Any
+                    add_curr_ssaflag!(frame, IR_FLAG_NOTHROW)
                     @goto fallthrough
                 elseif isexpr(stmt, :leave)
                     ssavaluetypes[currpc] = Any
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index dd3b10405fccf..885a6dbab65b7 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -362,8 +362,8 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
     # start from all :enter statements and record the location of the try
     for pc = 1:n
         stmt = code[pc]
-        if isexpr(stmt, :enter)
-            l = stmt.args[1]::Int
+        if isa(stmt, EnterNode)
+            l = stmt.catch_dest
             push!(handlers, TryCatchFrame(Bottom, pc))
             handler_id = length(handlers)
             handler_at[pc + 1] = (handler_id, 0)
@@ -396,15 +396,15 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
             elseif isa(stmt, ReturnNode)
                 @assert !isdefined(stmt, :val) || cur_stacks[1] == 0 "unbalanced try/catch"
                 break
+            elseif isa(stmt, EnterNode)
+                l = stmt.catch_dest
+                # We assigned a handler number above. Here we just merge that
+                # with out current handler information.
+                handler_at[l] = (cur_stacks[1], handler_at[l][2])
+                cur_stacks = (handler_at[pc´][1], cur_stacks[2])
             elseif isa(stmt, Expr)
                 head = stmt.head
-                if head === :enter
-                    l = stmt.args[1]::Int
-                    # We assigned a handler number above. Here we just merge that
-                    # with out current handler information.
-                    handler_at[l] = (cur_stacks[1], handler_at[l][2])
-                    cur_stacks = (handler_at[pc´][1], cur_stacks[2])
-                elseif head === :leave
+                if head === :leave
                     l = 0
                     for j = 1:length(stmt.args)
                         arg = stmt.args[j]
@@ -415,7 +415,7 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
                             if enter_stmt === nothing
                                 continue
                             end
-                            @assert isexpr(enter_stmt, :enter) "malformed :leave"
+                            @assert isa(enter_stmt, EnterNode) "malformed :leave"
                         end
                         l += 1
                     end
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index b0a4dfd1ced8d..54a3823cd2f26 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -270,6 +270,7 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
     isa(stmt, PiNode) && return (true, true, true)
     isa(stmt, PhiNode) && return (true, true, true)
     isa(stmt, ReturnNode) && return (true, false, true)
+    isa(stmt, EnterNode) && return (true, false, true)
     isa(stmt, GotoNode) && return (true, false, true)
     isa(stmt, GotoIfNot) && return (true, false, ⊑(𝕃ₒ, argextype(stmt.cond, src), Bool))
     if isa(stmt, GlobalRef)
@@ -761,7 +762,7 @@ end
 function ((; sv)::ScanStmt)(inst::Instruction, lstmt::Int, bb::Int)
     stmt = inst[:stmt]
 
-    if isexpr(stmt, :enter)
+    if isa(stmt, EnterNode)
         # try/catch not yet modeled
         give_up_refinements!(sv)
         return nothing
@@ -971,8 +972,8 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                     expr = nothing
                 end
                 code[i] = expr
-            elseif isexpr(expr, :enter)
-                catchdest = expr.args[1]::Int
+            elseif isa(expr, EnterNode)
+                catchdest = expr.catch_dest
                 if catchdest in sv.unreachable
                     cfg_delete_edge!(sv.cfg, block_for_inst(sv.cfg, i), block_for_inst(sv.cfg, catchdest))
                     code[i] = nothing
@@ -1239,12 +1240,6 @@ function statement_cost(ex::Expr, line::Int, src::Union{CodeInfo, IRCode}, sptyp
         return cost
     elseif head === :copyast
         return 100
-    elseif head === :enter
-        # try/catch is a couple function calls,
-        # but don't inline functions with try/catch
-        # since these aren't usually performance-sensitive functions,
-        # and llvm is more likely to miscompile them when these functions get large
-        return typemax(Int)
     end
     return 0
 end
@@ -1263,6 +1258,12 @@ function statement_or_branch_cost(@nospecialize(stmt), line::Int, src::Union{Cod
         thiscost = dst(stmt.label) < line ? 40 : 0
     elseif stmt isa GotoIfNot
         thiscost = dst(stmt.dest) < line ? 40 : 0
+    elseif stmt isa EnterNode
+        # try/catch is a couple function calls,
+        # but don't inline functions with try/catch
+        # since these aren't usually performance-sensitive functions,
+        # and llvm is more likely to miscompile them when these functions get large
+        thiscost = typemax(Int)
     end
     return thiscost
 end
@@ -1359,19 +1360,19 @@ function renumber_ir_elements!(body::Vector{Any}, ssachangemap::Vector{Int}, lab
                     i += 1
                 end
             end
+        elseif isa(el, EnterNode)
+            tgt = el.catch_dest
+            was_deleted = labelchangemap[tgt] == typemin(Int)
+            if was_deleted
+                body[i] = nothing
+            else
+                body[i] = EnterNode(el, tgt + labelchangemap[tgt])
+            end
         elseif isa(el, Expr)
             if el.head === :(=) && el.args[2] isa Expr
                 el = el.args[2]::Expr
             end
-            if el.head === :enter
-                tgt = el.args[1]::Int
-                was_deleted = labelchangemap[tgt] == typemin(Int)
-                if was_deleted
-                    body[i] = nothing
-                else
-                    el.args[1] = tgt + labelchangemap[tgt]
-                end
-            elseif !is_meta_expr_head(el.head)
+            if !is_meta_expr_head(el.head)
                 args = el.args
                 for i = 1:length(args)
                     el = args[i]
diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index c05f3f53837a7..e4ea159ac8824 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -652,7 +652,7 @@ function analyze_escapes(ir::IRCode, nargs::Int, 𝕃ₒ::AbstractLattice, get_e
                 elseif is_meta_expr_head(head)
                     # meta expressions doesn't account for any usages
                     continue
-                elseif head === :enter || head === :leave || head === :the_exception || head === :pop_exception
+                elseif head === :leave || head === :the_exception || head === :pop_exception
                     # ignore these expressions since escapes via exceptions are handled by `escape_exception!`
                     # `escape_exception!` conservatively propagates `AllEscape` anyway,
                     # and so escape information imposed on `:the_exception` isn't computed
@@ -666,6 +666,9 @@ function analyze_escapes(ir::IRCode, nargs::Int, 𝕃ₒ::AbstractLattice, get_e
                 else
                     add_conservative_changes!(astate, pc, stmt.args)
                 end
+            elseif isa(stmt, EnterNode)
+                # Handled via escape_exception!
+                continue
             elseif isa(stmt, ReturnNode)
                 if isdefined(stmt, :val)
                     add_escape_change!(astate, stmt.val, ReturnEscape(pc))
@@ -728,10 +731,10 @@ function compute_frameinfo(ir::IRCode)
     for idx in 1:nstmts+nnewnodes
         inst = ir[SSAValue(idx)]
         stmt = inst[:stmt]
-        if isexpr(stmt, :enter)
+        if isa(stmt, EnterNode)
             @assert idx ≤ nstmts "try/catch inside new_nodes unsupported"
             tryregions === nothing && (tryregions = UnitRange{Int}[])
-            leave_block = stmt.args[1]::Int
+            leave_block = stmt.catch_dest
             leave_pc = first(ir.cfg.blocks[leave_block].stmts)
             push!(tryregions, idx:leave_pc)
         elseif arrayinfo !== nothing
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 2e250bade533c..326a4094e4134 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -459,8 +459,8 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
                 end
             elseif isa(stmt′, GotoNode)
                 stmt′ = GotoNode(stmt′.label + bb_offset)
-            elseif isa(stmt′, Expr) && stmt′.head === :enter
-                stmt′ = Expr(:enter, stmt′.args[1]::Int + bb_offset)
+            elseif isa(stmt′, EnterNode)
+                stmt′ = EnterNode(stmt′, stmt′.catch_dest + bb_offset)
             elseif isa(stmt′, GotoIfNot)
                 stmt′ = GotoIfNot(stmt′.cond, stmt′.dest + bb_offset)
             elseif isa(stmt′, PhiNode)
@@ -710,8 +710,8 @@ function batch_inline!(ir::IRCode, todo::Vector{Pair{Int,Any}}, propagate_inboun
                 end
             elseif isa(stmt, GotoNode)
                 compact[idx] = GotoNode(state.bb_rename[stmt.label])
-            elseif isa(stmt, Expr) && stmt.head === :enter
-                compact[idx] = Expr(:enter, state.bb_rename[stmt.args[1]::Int])
+            elseif isa(stmt, EnterNode)
+                compact[idx] = EnterNode(stmt, state.bb_rename[stmt.catch_dest])
             elseif isa(stmt, GotoIfNot)
                 compact[idx] = GotoIfNot(stmt.cond, state.bb_rename[stmt.dest])
             elseif isa(stmt, PhiNode)
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 9b89b30854cdf..fb1219803b1fe 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -2,7 +2,7 @@
 
 Core.PhiNode() = Core.PhiNode(Int32[], Any[])
 
-isterminator(@nospecialize(stmt)) = isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isa(stmt, ReturnNode)
+isterminator(@nospecialize(stmt)) = isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isa(stmt, ReturnNode) || isa(stmt, EnterNode)
 
 struct CFG
     blocks::Vector{BasicBlock}
@@ -60,16 +60,16 @@ block_for_inst(cfg::CFG, inst::Int) = block_for_inst(cfg.index, inst)
             # This is a fake dest to force the next stmt to start a bb
             idx < length(stmts) && push!(jump_dests, idx+1)
             push!(jump_dests, stmt.label)
+        elseif isa(stmt, EnterNode)
+            # :enter starts/ends a BB
+            push!(jump_dests, idx)
+            push!(jump_dests, idx+1)
+            # The catch block is a jump dest
+            push!(jump_dests, stmt.catch_dest)
         elseif isa(stmt, Expr)
             if stmt.head === :leave
                 # :leave terminates a BB
                 push!(jump_dests, idx+1)
-            elseif stmt.head === :enter
-                # :enter starts/ends a BB
-                push!(jump_dests, idx)
-                push!(jump_dests, idx+1)
-                # The catch block is a jump dest
-                push!(jump_dests, stmt.args[1]::Int)
             end
         end
         if isa(stmt, PhiNode)
@@ -125,11 +125,11 @@ function compute_basic_blocks(stmts::Vector{Any})
                 push!(blocks[block′].preds, num)
                 push!(b.succs, block′)
             end
-        elseif isexpr(terminator, :enter)
+        elseif isa(terminator, EnterNode)
             # :enter gets a virtual edge to the exception handler and
             # the exception handler gets a virtual edge from outside
             # the function.
-            block′ = block_for_inst(basic_block_index, terminator.args[1]::Int)
+            block′ = block_for_inst(basic_block_index, terminator.catch_dest)
             push!(blocks[block′].preds, num)
             push!(blocks[block′].preds, 0)
             push!(b.succs, block′)
@@ -456,6 +456,10 @@ struct UndefToken end; const UNDEF_TOKEN = UndefToken()
         isdefined(stmt, :val) || return OOB_TOKEN
         op == 1 || return OOB_TOKEN
         return stmt.val
+    elseif isa(stmt, EnterNode)
+        isdefined(stmt, :scope) || return OOB_TOKEN
+        op == 1 || return OOB_TOKEN
+        return stmt.scope
     elseif isa(stmt, PiNode)
         isdefined(stmt, :val) || return OOB_TOKEN
         op == 1 || return OOB_TOKEN
@@ -510,6 +514,9 @@ end
     elseif isa(stmt, GotoIfNot)
         op == 1 || throw(BoundsError())
         stmt = GotoIfNot(v, stmt.dest)
+    elseif isa(stmt, EnterNode)
+        op == 1 || throw(BoundsError())
+        stmt = EnterNode(stmt.catch_dest, v)
     elseif isa(stmt, ReturnNode)
         op == 1 || throw(BoundsError())
         stmt = typeof(stmt)(v)
@@ -544,7 +551,7 @@ end
 function userefs(@nospecialize(x))
     relevant = (isa(x, Expr) && is_relevant_expr(x)) ||
         isa(x, GotoIfNot) || isa(x, ReturnNode) || isa(x, SSAValue) || isa(x, NewSSAValue) ||
-        isa(x, PiNode) || isa(x, PhiNode) || isa(x, PhiCNode) || isa(x, UpsilonNode)
+        isa(x, PiNode) || isa(x, PhiNode) || isa(x, PhiCNode) || isa(x, UpsilonNode) || isa(x, EnterNode)
     return UseRefIterator(x, relevant)
 end
 
@@ -1379,13 +1386,15 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
             result[result_idx][:stmt] = GotoIfNot(cond, label)
             result_idx += 1
         end
+    elseif cfg_transforms_enabled && isa(stmt, EnterNode)
+        label = bb_rename_succ[stmt.catch_dest]
+        @assert label > 0
+        ssa_rename[idx] = SSAValue(result_idx)
+        result[result_idx][:stmt] = EnterNode(stmt, label)
+        result_idx += 1
     elseif isa(stmt, Expr)
         stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, new_new_used_ssas, late_fixup, result_idx, do_rename_ssa, mark_refined!)::Expr
-        if cfg_transforms_enabled && isexpr(stmt, :enter)
-            label = bb_rename_succ[stmt.args[1]::Int]
-            @assert label > 0
-            stmt.args[1] = label
-        elseif isexpr(stmt, :throw_undef_if_not)
+        if isexpr(stmt, :throw_undef_if_not)
             cond = stmt.args[2]
             if isa(cond, Bool) && cond === true
                 # cond was folded to true - this statement
@@ -1445,7 +1454,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
         ssa_rename[idx] = SSAValue(result_idx)
         result[result_idx][:stmt] = stmt
         result_idx += 1
-    elseif isa(stmt, ReturnNode) || isa(stmt, UpsilonNode) || isa(stmt, GotoIfNot)
+    elseif isa(stmt, ReturnNode) || isa(stmt, UpsilonNode) || isa(stmt, GotoIfNot) || isa(stmt, EnterNode)
         ssa_rename[idx] = SSAValue(result_idx)
         result[result_idx][:stmt] = renumber_ssa2!(stmt, ssa_rename, used_ssas, new_new_used_ssas, late_fixup, result_idx, do_rename_ssa, mark_refined!)
         result_idx += 1
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index be072ca64e1c4..dd9a133f36802 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -96,7 +96,7 @@ function kill_terminator_edges!(irsv::IRInterpretationState, term_idx::Int, bb::
     elseif isa(stmt, ReturnNode)
         # Nothing to do
     else
-        @assert !isexpr(stmt, :enter)
+        @assert !isa(stmt, EnterNode)
         kill_edge!(irsv, bb, bb+1)
     end
 end
@@ -222,8 +222,8 @@ function process_terminator!(@nospecialize(stmt), bb::Int, bb_ip::BitSetBoundedM
         backedge || push!(bb_ip, stmt.dest)
         push!(bb_ip, bb+1)
         return backedge
-    elseif isexpr(stmt, :enter)
-        dest = stmt.args[1]::Int
+    elseif isa(stmt, EnterNode)
+        dest = stmt.catch_dest
         @assert dest > bb
         push!(bb_ip, dest)
         push!(bb_ip, bb+1)
@@ -329,8 +329,7 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
             delete!(ssa_refined, idx)
         end
         check_ret!(stmt, idx)
-        is_terminator_or_phi = (isa(stmt, PhiNode) || isa(stmt, GotoNode) ||
-            isa(stmt, GotoIfNot) || isa(stmt, ReturnNode) || isexpr(stmt, :enter))
+        is_terminator_or_phi = (isa(stmt, PhiNode) || isterminator(stmt))
         if typ === Bottom && !(idx == lstmt && is_terminator_or_phi)
             return true
         end
diff --git a/base/compiler/ssair/legacy.jl b/base/compiler/ssair/legacy.jl
index 8f557f4fd2241..e8ed197ba5ce6 100644
--- a/base/compiler/ssair/legacy.jl
+++ b/base/compiler/ssair/legacy.jl
@@ -25,9 +25,8 @@ function inflate_ir!(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{A
             code[i] = GotoIfNot(stmt.cond, block_for_inst(cfg, stmt.dest))
         elseif isa(stmt, PhiNode)
             code[i] = PhiNode(Int32[block_for_inst(cfg, Int(edge)) for edge in stmt.edges], stmt.values)
-        elseif isexpr(stmt, :enter)
-            stmt.args[1] = block_for_inst(cfg, stmt.args[1]::Int)
-            code[i] = stmt
+        elseif isa(stmt, EnterNode)
+            code[i] = EnterNode(stmt, block_for_inst(cfg, stmt.catch_dest))
         end
     end
     nstmts = length(code)
@@ -93,9 +92,8 @@ function replace_code_newstyle!(ci::CodeInfo, ir::IRCode)
             code[i] = GotoIfNot(stmt.cond, first(ir.cfg.blocks[stmt.dest].stmts))
         elseif isa(stmt, PhiNode)
             code[i] = PhiNode(Int32[edge == 0 ? 0 : last(ir.cfg.blocks[edge].stmts) for edge in stmt.edges], stmt.values)
-        elseif isexpr(stmt, :enter)
-            stmt.args[1] = first(ir.cfg.blocks[stmt.args[1]::Int].stmts)
-            code[i] = stmt
+        elseif isa(stmt, EnterNode)
+            code[i] = EnterNode(stmt, first(ir.cfg.blocks[stmt.catch_dest].stmts))
         end
     end
 end
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 9c6ed30dbbce8..8b3ae55fe7429 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1911,7 +1911,7 @@ function legalize_bb_drop_pred!(ir::IRCode, bb::BasicBlock, bbidx::Int, bbs::Vec
         end
         ir[last_fallthrough_term_ssa] = nothing
         kill_edge!(bbs, last_fallthrough, terminator.dest)
-    elseif isexpr(terminator, :enter)
+    elseif isa(terminator, EnterNode)
         return false
     elseif isa(terminator, GotoNode)
         return true
@@ -1923,8 +1923,6 @@ function legalize_bb_drop_pred!(ir::IRCode, bb::BasicBlock, bbidx::Int, bbs::Vec
     return true
 end
 
-is_terminator(@nospecialize(stmt)) = isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isexpr(stmt, :enter)
-
 function follow_map(map::Vector{Int}, idx::Int)
     while map[idx] ≠ 0
         idx = map[idx]
@@ -1992,7 +1990,7 @@ function cfg_simplify!(ir::IRCode)
             if length(bbs[succ].preds) == 1 && succ != 1
                 # Can't merge blocks with :enter terminator even if they
                 # only have one successor.
-                if isexpr(ir[SSAValue(last(bb.stmts))][:stmt], :enter)
+                if isa(ir[SSAValue(last(bb.stmts))][:stmt], EnterNode)
                     continue
                 end
                 # Prevent cycles by making sure we don't end up back at `idx`
@@ -2068,7 +2066,7 @@ function cfg_simplify!(ir::IRCode)
                     if bb_rename_succ[terminator.dest] == 0
                         push!(worklist, terminator.dest)
                     end
-                elseif isexpr(terminator, :enter)
+                elseif isa(terminator, EnterNode)
                     enteridx = terminator.args[1]::Int
                     if bb_rename_succ[enteridx] == 0
                         push!(worklist, enteridx)
diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl
index 67698fbc89aaa..7323c21ae56b4 100644
--- a/base/compiler/ssair/show.jl
+++ b/base/compiler/ssair/show.jl
@@ -67,8 +67,8 @@ function print_stmt(io::IO, idx::Int, @nospecialize(stmt), used::BitSet, maxleng
         join(io, (print_arg(i) for i = 3:length(stmt.args)), ", ")
         print(io, ")")
     # given control flow information, we prefer to print these with the basic block #, instead of the ssa %
-    elseif isexpr(stmt, :enter) && length((stmt::Expr).args) == 1 && (stmt::Expr).args[1] isa Int
-        print(io, "\$(Expr(:enter, #", (stmt::Expr).args[1]::Int, "))")
+    elseif isa(stmt, EnterNode)
+        print(io, "enter #", stmt.catch_dest, "")
     elseif stmt isa GotoNode
         print(io, "goto #", stmt.label)
     elseif stmt isa PhiNode
@@ -154,11 +154,11 @@ end
 
 function should_print_ssa_type(@nospecialize node)
     if isa(node, Expr)
-        return !(node.head in (:gc_preserve_begin, :gc_preserve_end, :meta, :enter, :leave))
+        return !(node.head in (:gc_preserve_begin, :gc_preserve_end, :meta, :leave))
     end
     return !isa(node, PiNode)   && !isa(node, GotoIfNot) &&
            !isa(node, GotoNode) && !isa(node, ReturnNode) &&
-           !isa(node, QuoteNode)
+           !isa(node, QuoteNode) && !isa(node, EnterNode)
 end
 
 function default_expr_type_printer(io::IO; @nospecialize(type), used::Bool, show_type::Bool=true, _...)
@@ -565,10 +565,8 @@ end
 
 function statement_indices_to_labels(stmt, cfg::CFG)
     # convert statement index to labels, as expected by print_stmt
-    if stmt isa Expr
-        if stmt.head === :enter && length(stmt.args) == 1 && stmt.args[1] isa Int
-            stmt = Expr(:enter, block_for_inst(cfg, stmt.args[1]::Int))
-        end
+    if stmt isa EnterNode
+        stmt = EnterNode(stmt, block_for_inst(cfg, stmt.catch_dest))
     elseif isa(stmt, GotoIfNot)
         stmt = GotoIfNot(stmt.cond, block_for_inst(cfg, stmt.dest))
     elseif stmt isa GotoNode
diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl
index cbe167926014c..52e809f1c445b 100644
--- a/base/compiler/ssair/slot2ssa.jl
+++ b/base/compiler/ssair/slot2ssa.jl
@@ -468,10 +468,8 @@ function domsort_ssa!(ir::IRCode, domtree::DomTree)
             end
             result[inst_range[end]][:stmt] = GotoIfNot(terminator.cond, bb_rename[terminator.dest])
         elseif !isa(terminator, ReturnNode)
-            if isa(terminator, Expr)
-                if terminator.head === :enter
-                    terminator.args[1] = bb_rename[terminator.args[1]]
-                end
+            if isa(terminator, EnterNode)
+                result[inst_range[end]][:stmt] = EnterNode(terminator, bb_rename[terminator.catch_dest])
             end
             if bb_rename[bb + 1] != new_bb + 1
                 # Add an explicit goto node
@@ -576,10 +574,10 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
     catch_entry_blocks = TryCatchRegion[]
     for idx in 1:length(code)
         stmt = code[idx]
-        if isexpr(stmt, :enter)
+        if isa(stmt, EnterNode)
             push!(catch_entry_blocks, TryCatchRegion(
                 block_for_inst(cfg, idx),
-                block_for_inst(cfg, stmt.args[1]::Int)))
+                block_for_inst(cfg, stmt.catch_dest)))
         end
     end
 
@@ -817,7 +815,7 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
                         enter_idx = idx
                         while handler_at[enter_idx][1] != 0
                             (; enter_idx) = handlers[handler_at[enter_idx][1]]
-                            leave_block = block_for_inst(cfg, code[enter_idx].args[1]::Int)
+                            leave_block = block_for_inst(cfg, (code[enter_idx]::EnterNode).catch_dest)
                             cidx = findfirst((; slot)::NewPhiCNode2->slot_id(slot)==id, new_phic_nodes[leave_block])
                             if cidx !== nothing
                                 node = thisdef ? UpsilonNode(thisval) : UpsilonNode()
@@ -879,9 +877,9 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
             else
                 new_code[idx] = GotoIfNot(stmt.cond, new_dest)
             end
-        elseif isexpr(stmt, :enter)
-            except_bb = block_for_inst(cfg, stmt.args[1]::Int)
-            new_code[idx] = Expr(:enter, except_bb)
+        elseif isa(stmt, EnterNode)
+            except_bb = block_for_inst(cfg, stmt.catch_dest)
+            new_code[idx] = EnterNode(stmt, except_bb)
             ssavalmap[idx] = SSAValue(idx) # Slot to store token for pop_exception
         elseif isexpr(stmt, :leave) || isexpr(stmt, :(=)) || isa(stmt, ReturnNode) ||
             isexpr(stmt, :meta) || isa(stmt, NewvarNode)
diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index 801836c485e31..03e3ab0b0f03a 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -198,9 +198,9 @@ function verify_ir(ir::IRCode, print::Bool=true,
                 @verify_error "Block $idx successors ($(block.succs)), does not match GotoIfNot terminator"
                 error("")
             end
-        elseif isexpr(terminator, :enter)
+        elseif isa(terminator, EnterNode)
             @label enter_check
-            if length(block.succs) != 2 || (block.succs != Int[terminator.args[1], idx+1] && block.succs != Int[idx+1, terminator.args[1]])
+            if length(block.succs) != 2 || (block.succs != Int[terminator.catch_dest, idx+1] && block.succs != Int[idx+1, terminator.catch_dest])
                 @verify_error "Block $idx successors ($(block.succs)), does not match :enter terminator"
                 error("")
             end
@@ -210,7 +210,7 @@ function verify_ir(ir::IRCode, print::Bool=true,
                 # statement, until we can do proper CFG manipulations during compaction.
                 for stmt_idx in first(block.stmts):last(block.stmts)
                     stmt = ir[SSAValue(stmt_idx)][:stmt]
-                    if isexpr(stmt, :enter)
+                    if isa(stmt, EnterNode)
                         terminator = stmt
                         @goto enter_check
                     end
@@ -319,7 +319,7 @@ function verify_ir(ir::IRCode, print::Bool=true,
                     error("")
                 end
             end
-        elseif (isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isexpr(stmt, :enter)) && idx != last(ir.cfg.blocks[bb].stmts)
+        elseif (isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isa(stmt, EnterNode)) && idx != last(ir.cfg.blocks[bb].stmts)
             @verify_error "Terminator $idx in bb $bb is not the last statement in the block"
             error("")
         else
@@ -373,7 +373,7 @@ function verify_ir(ir::IRCode, print::Bool=true,
                             error()
                         elseif isa(arg, SSAValue)
                             enter_stmt = ir[arg::SSAValue][:stmt]
-                            if !isa(enter_stmt, Nothing) && !isexpr(enter_stmt, :enter)
+                            if !isa(enter_stmt, Nothing) && !isa(enter_stmt, EnterNode)
                                 @verify_error "Malformed :leave - argument ssavalue should point to `nothing` or :enter"
                                 error()
                             end
diff --git a/base/meta.jl b/base/meta.jl
index 31fef1b9697e3..545b1dbf5243b 100644
--- a/base/meta.jl
+++ b/base/meta.jl
@@ -377,6 +377,9 @@ function _partially_inline!(@nospecialize(x), slot_replacements::Vector{Any},
             x.dest + statement_offset,
         )
     end
+    if isa(x, Core.EnterNode)
+        return Core.EnterNode(x, x.catch_dest + statement_offset)
+    end
     if isa(x, Expr)
         head = x.head
         if head === :static_parameter
@@ -424,8 +427,6 @@ function _partially_inline!(@nospecialize(x), slot_replacements::Vector{Any},
                                            static_param_values, slot_offset,
                                            statement_offset, boundscheck)
             x.args[2] += statement_offset
-        elseif head === :enter
-            x.args[1] += statement_offset
         elseif head === :isdefined
             arg = x.args[1]
             # inlining a QuoteNode or literal into `Expr(:isdefined, x)` is invalid, replace with true
diff --git a/src/ast.c b/src/ast.c
index e6adbdc4d5aac..8257309a07b2b 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -603,6 +603,11 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, jl_module_t *m
             temp = scm_to_julia(fl_ctx, car_(cdr_(e)), mod);
             temp = jl_new_struct(jl_gotoifnot_type, ex, temp);
         }
+        else if (sym == jl_enter_sym) {
+            ex = scm_to_julia_(fl_ctx, car_(e), mod);
+            temp = jl_new_struct_uninit(jl_enternode_type);
+            jl_enternode_catch_dest(temp) = jl_unbox_long(ex);
+        }
         else if (sym == jl_newvar_sym) {
             ex = scm_to_julia_(fl_ctx, car_(e), mod);
             temp = jl_new_struct(jl_newvarnode_type, ex);
diff --git a/src/builtins.c b/src/builtins.c
index 88b91baa19279..78e66ef190437 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -2214,6 +2214,7 @@ void jl_init_primitives(void) JL_GC_DISABLED
     add_builtin("LineInfoNode", (jl_value_t*)jl_lineinfonode_type);
     add_builtin("GotoNode", (jl_value_t*)jl_gotonode_type);
     add_builtin("GotoIfNot", (jl_value_t*)jl_gotoifnot_type);
+    add_builtin("EnterNode", (jl_value_t*)jl_enternode_type);
     add_builtin("ReturnNode", (jl_value_t*)jl_returnnode_type);
     add_builtin("PiNode", (jl_value_t*)jl_pinode_type);
     add_builtin("PhiNode", (jl_value_t*)jl_phinode_type);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index bd5572ce7be16..bc7f30f49626d 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -2943,18 +2943,16 @@ static void mark_volatile_vars(jl_array_t *stmts, SmallVectorImpl<jl_varinfo_t>
     size_t slength = jl_array_dim0(stmts);
     for (int i = 0; i < (int)slength; i++) {
         jl_value_t *st = jl_array_ptr_ref(stmts, i);
-        if (jl_is_expr(st)) {
-            if (((jl_expr_t*)st)->head == jl_enter_sym) {
-                int last = jl_unbox_long(jl_exprarg(st, 0));
-                std::set<int> as = assigned_in_try(stmts, i + 1, last - 1);
-                for (int j = 0; j < (int)slength; j++) {
-                    if (j < i || j > last) {
-                        std::set<int>::iterator it = as.begin();
-                        for (; it != as.end(); it++) {
-                            if (local_var_occurs(jl_array_ptr_ref(stmts, j), *it)) {
-                                jl_varinfo_t &vi = slots[*it];
-                                vi.isVolatile = true;
-                            }
+        if (jl_is_enternode(st)) {
+            int last = jl_enternode_catch_dest(st);
+            std::set<int> as = assigned_in_try(stmts, i + 1, last - 1);
+            for (int j = 0; j < (int)slength; j++) {
+                if (j < i || j > last) {
+                    std::set<int>::iterator it = as.begin();
+                    for (; it != as.end(); it++) {
+                        if (local_var_occurs(jl_array_ptr_ref(stmts, j), *it)) {
+                            jl_varinfo_t &vi = slots[*it];
+                            vi.isVolatile = true;
                         }
                     }
                 }
@@ -8522,14 +8520,11 @@ static jl_llvm_functions_t
                 // targets.
                 if (i + 2 <= stmtslen)
                     branch_targets.insert(i + 2);
-            } else if (jl_is_expr(stmt)) {
-                if (((jl_expr_t*)stmt)->head == jl_enter_sym) {
-                    branch_targets.insert(i + 1);
-                    if (i + 2 <= stmtslen)
-                        branch_targets.insert(i + 2);
-                    int dest = jl_unbox_long(jl_array_ptr_ref(((jl_expr_t*)stmt)->args, 0));
-                    branch_targets.insert(dest);
-                }
+            } else if (jl_is_enternode(stmt)) {
+                branch_targets.insert(i + 1);
+                if (i + 2 <= stmtslen)
+                    branch_targets.insert(i + 2);
+                branch_targets.insert(jl_enternode_catch_dest(stmt));
             } else if (jl_is_gotonode(stmt)) {
                 int dest = jl_gotonode_label(stmt);
                 branch_targets.insert(dest);
@@ -8575,7 +8570,6 @@ static jl_llvm_functions_t
         }
         ctx.noalias().aliasscope.current = aliasscopes[cursor];
         jl_value_t *stmt = jl_array_ptr_ref(stmts, cursor);
-        jl_expr_t *expr = jl_is_expr(stmt) ? (jl_expr_t*)stmt : nullptr;
         if (jl_is_returnnode(stmt)) {
             jl_value_t *retexpr = jl_returnnode_value(stmt);
             if (retexpr == NULL) {
@@ -8729,11 +8723,8 @@ static jl_llvm_functions_t
             find_next_stmt(cursor + 1);
             continue;
         }
-        else if (expr && expr->head == jl_enter_sym) {
-            jl_value_t **args = jl_array_data(expr->args, jl_value_t*);
-
-            assert(jl_is_long(args[0]));
-            int lname = jl_unbox_long(args[0]);
+        else if (jl_is_enternode(stmt)) {
+            int lname = jl_enternode_catch_dest(stmt);
             // Save exception stack depth at enter for use in pop_exception
             Value *excstack_state =
                 ctx.builder.CreateCall(prepare_call(jl_excstack_state_func));
diff --git a/src/interpreter.c b/src/interpreter.c
index 7f8bd236819d5..313f5d9423fcc 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -489,6 +489,50 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
             ssize_t id = ((jl_ssavalue_t*)phic)->id - 1;
             s->locals[jl_source_nslots(s->src) + id] = val;
         }
+        else if (jl_is_enternode(stmt)) {
+            jl_enter_handler(&__eh);
+            // This is a bit tricky, but supports the implementation of PhiC nodes.
+            // They are conceptually slots, but the slot to store to doesn't get explicitly
+            // mentioned in the store (aka the "UpsilonNode") (this makes them integrate more
+            // nicely with the rest of the SSA representation). In a compiler, we would figure
+            // out which slot to store to at compile time when we encounter the statement. We
+            // can't quite do that here, but we do something similar: We scan the catch entry
+            // block (the only place where PhiC nodes may occur) to find all the Upsilons we
+            // can possibly encounter. Then, we remember which slot they store to (we abuse the
+            // SSA value result array for this purpose). TODO: We could do this only the first
+            // time we encounter a given enter.
+            size_t catch_ip = jl_enternode_catch_dest(stmt) - 1;
+            while (catch_ip < ns) {
+                jl_value_t *phicnode = jl_array_ptr_ref(stmts, catch_ip);
+                if (!jl_is_phicnode(phicnode))
+                    break;
+                jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(phicnode, 0);
+                for (size_t i = 0; i < jl_array_nrows(values); ++i) {
+                    jl_value_t *val = jl_array_ptr_ref(values, i);
+                    assert(jl_is_ssavalue(val));
+                    size_t upsilon = ((jl_ssavalue_t*)val)->id - 1;
+                    assert(jl_is_upsilonnode(jl_array_ptr_ref(stmts, upsilon)));
+                    s->locals[jl_source_nslots(s->src) + upsilon] = jl_box_ssavalue(catch_ip + 1);
+                }
+                s->locals[jl_source_nslots(s->src) + catch_ip] = NULL;
+                catch_ip += 1;
+            }
+            // store current top of exception stack for restore in pop_exception.
+            s->locals[jl_source_nslots(s->src) + ip] = jl_box_ulong(jl_excstack_state());
+            if (!jl_setjmp(__eh.eh_ctx, 1)) {
+                return eval_body(stmts, s, next_ip, toplevel);
+            }
+            jl_eh_restore_state(&__eh);
+            if (s->continue_at) { // means we reached a :leave expression
+                ip = s->continue_at;
+                s->continue_at = 0;
+                continue;
+            }
+            else { // a real exception
+                ip = catch_ip;
+                continue;
+            }
+        }
         else if (jl_is_expr(stmt)) {
             // Most exprs are allowed to end a BB by fall through
             jl_sym_t *head = ((jl_expr_t*)stmt)->head;
@@ -518,51 +562,6 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
                     JL_GC_POP();
                 }
             }
-            else if (head == jl_enter_sym) {
-                jl_enter_handler(&__eh);
-                // This is a bit tricky, but supports the implementation of PhiC nodes.
-                // They are conceptually slots, but the slot to store to doesn't get explicitly
-                // mentioned in the store (aka the "UpsilonNode") (this makes them integrate more
-                // nicely with the rest of the SSA representation). In a compiler, we would figure
-                // out which slot to store to at compile time when we encounter the statement. We
-                // can't quite do that here, but we do something similar: We scan the catch entry
-                // block (the only place where PhiC nodes may occur) to find all the Upsilons we
-                // can possibly encounter. Then, we remember which slot they store to (we abuse the
-                // SSA value result array for this purpose). TODO: We could do this only the first
-                // time we encounter a given enter.
-                size_t catch_ip = jl_unbox_long(jl_exprarg(stmt, 0)) - 1;
-                while (catch_ip < ns) {
-                    jl_value_t *phicnode = jl_array_ptr_ref(stmts, catch_ip);
-                    if (!jl_is_phicnode(phicnode))
-                        break;
-                    jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(phicnode, 0);
-                    for (size_t i = 0; i < jl_array_nrows(values); ++i) {
-                        jl_value_t *val = jl_array_ptr_ref(values, i);
-                        assert(jl_is_ssavalue(val));
-                        size_t upsilon = ((jl_ssavalue_t*)val)->id - 1;
-                        assert(jl_is_upsilonnode(jl_array_ptr_ref(stmts, upsilon)));
-                        s->locals[jl_source_nslots(s->src) + upsilon] = jl_box_ssavalue(catch_ip + 1);
-                    }
-                    s->locals[jl_source_nslots(s->src) + catch_ip] = NULL;
-                    catch_ip += 1;
-                }
-                // store current top of exception stack for restore in pop_exception.
-                s->locals[jl_source_nslots(s->src) + ip] = jl_box_ulong(jl_excstack_state());
-                if (!jl_setjmp(__eh.eh_ctx, 1)) {
-                    return eval_body(stmts, s, next_ip, toplevel);
-                } else {
-                    jl_eh_restore_state(&__eh);
-                    if (s->continue_at) { // means we reached a :leave expression
-                        ip = s->continue_at;
-                        s->continue_at = 0;
-                        continue;
-                    }
-                    else { // a real exception
-                        ip = catch_ip;
-                        continue;
-                    }
-                }
-            }
             else if (head == jl_leave_sym) {
                 int hand_n_leave = 0;
                 for (int i = 0; i < jl_expr_nargs(stmt); ++i) {
diff --git a/src/jl_exported_data.inc b/src/jl_exported_data.inc
index e840d2e8a40dc..f40b252180a65 100644
--- a/src/jl_exported_data.inc
+++ b/src/jl_exported_data.inc
@@ -52,6 +52,7 @@
     XX(jl_binding_type) \
     XX(jl_globalref_type) \
     XX(jl_gotoifnot_type) \
+    XX(jl_enternode_type) \
     XX(jl_gotonode_type) \
     XX(jl_initerror_type) \
     XX(jl_int16_type) \
diff --git a/src/jltypes.c b/src/jltypes.c
index 5666319860f6a..dddf88aececac 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3046,6 +3046,12 @@ void jl_init_types(void) JL_GC_DISABLED
                         jl_svec(2, jl_any_type, jl_long_type),
                         jl_emptysvec, 0, 0, 2);
 
+    jl_enternode_type =
+        jl_new_datatype(jl_symbol("EnterNode"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(1, "catch_dest"),
+                        jl_svec(1, jl_long_type),
+                        jl_emptysvec, 0, 0, 1);
+
     jl_returnnode_type =
         jl_new_datatype(jl_symbol("ReturnNode"), core, jl_any_type, jl_emptysvec,
                         jl_perm_symsvec(1, "val"),
diff --git a/src/julia.h b/src/julia.h
index 409da556ed957..9b69dd54dabc8 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -893,6 +893,7 @@ extern JL_DLLIMPORT jl_datatype_t *jl_globalref_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_linenumbernode_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_gotonode_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_gotoifnot_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_datatype_t *jl_enternode_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_returnnode_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_phinode_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_pinode_type JL_GLOBALLY_ROOTED;
@@ -1272,6 +1273,7 @@ STATIC_INLINE void jl_array_uint32_set(void *a, size_t i, uint8_t x) JL_NOTSAFEP
 #define jl_gotonode_label(x) (((intptr_t*)(x))[0])
 #define jl_gotoifnot_cond(x) (((jl_value_t**)(x))[0])
 #define jl_gotoifnot_label(x) (((intptr_t*)(x))[1])
+#define jl_enternode_catch_dest(x) (((intptr_t*)(x))[0])
 #define jl_globalref_mod(s) (*(jl_module_t**)(s))
 #define jl_globalref_name(s) (((jl_sym_t**)(s))[1])
 #define jl_quotenode_value(x) (((jl_value_t**)x)[0])
@@ -1455,6 +1457,7 @@ static inline int jl_field_isconst(jl_datatype_t *st, int i) JL_NOTSAFEPOINT
 #define jl_is_gotonode(v)    jl_typetagis(v,jl_gotonode_type)
 #define jl_is_gotoifnot(v)   jl_typetagis(v,jl_gotoifnot_type)
 #define jl_is_returnnode(v)  jl_typetagis(v,jl_returnnode_type)
+#define jl_is_enternode(v)   jl_typetagis(v,jl_enternode_type)
 #define jl_is_argument(v)    jl_typetagis(v,jl_argument_type)
 #define jl_is_pinode(v)      jl_typetagis(v,jl_pinode_type)
 #define jl_is_phinode(v)     jl_typetagis(v,jl_phinode_type)
diff --git a/src/staticdata.c b/src/staticdata.c
index 6f21d0aa4aa2c..a687406dbe73a 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -98,7 +98,7 @@ extern "C" {
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
-#define NUM_TAGS    178
+#define NUM_TAGS    179
 
 // An array of references that need to be restored from the sysimg
 // This is a manually constructed dual of the gvars array, which would be produced by codegen for Julia code, for C.
@@ -132,6 +132,7 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_gotonode_type);
         INSERT_TAG(jl_quotenode_type);
         INSERT_TAG(jl_gotoifnot_type);
+        INSERT_TAG(jl_enternode_type);
         INSERT_TAG(jl_argument_type);
         INSERT_TAG(jl_returnnode_type);
         INSERT_TAG(jl_const_type);
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index f0a01eba61405..c71fd3ca9b265 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -4416,9 +4416,9 @@ g41908() = f41908(Any[1][1])
 # issue #42022
 let x = Tuple{Int,Any}[
         #= 1=# (0, Expr(:(=), Core.SlotNumber(3), 1))
-        #= 2=# (0, Expr(:enter, 17))
+        #= 2=# (0, EnterNode(17))
         #= 3=# (2, Expr(:(=), Core.SlotNumber(3), 2.0))
-        #= 4=# (2, Expr(:enter, 12))
+        #= 4=# (2, EnterNode(12))
         #= 5=# (4, Expr(:(=), Core.SlotNumber(3), '3'))
         #= 6=# (4, Core.GotoIfNot(Core.SlotNumber(2), 9))
         #= 7=# (4, Expr(:leave, Core.SSAValue(4), Core.SSAValue(2)))
diff --git a/test/compiler/interpreter_exec.jl b/test/compiler/interpreter_exec.jl
index 47dc3778402bd..17d0e4f7e7eac 100644
--- a/test/compiler/interpreter_exec.jl
+++ b/test/compiler/interpreter_exec.jl
@@ -81,7 +81,7 @@ let m = Meta.@lower 1 + 1
         QuoteNode(:b),
         GlobalRef(@__MODULE__, :test29262),
         # block 2
-        Expr(:enter, 11),
+        Core.EnterNode(11),
         # block 3
         Core.UpsilonNode(),
         Core.UpsilonNode(),

From cd4f49a3d2921fc591891a29f95dc113a8386857 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 26 Nov 2023 15:30:58 -0500
Subject: [PATCH 0333/1315] Give a better assertion failure for module
 serialization issues (#52306)

This issue confused me for a few hours. Basically what happened was that
I had some IR that verified fine, but did not survive a deserialization
round-trip (related to mismatching pointer types, which of course are
starting to lose their meaning in LLVM). In this situation, the first
assertion hit was the failure to verify the LLVM module at the output,
but I had a hard time figuring out where this IR was coming from, since
it looked totally corrupted. If LLVM assertions had been enabled, I
would have seen the cantFail give a proper error, but since I only had
Julia assertions enabled, I did not see this error message. Try to
improve this situation by also asserting the absence of serialization
errors using Julia assertions, not just LLVM assertions.
---
 src/aotcompile.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index b844d22337d31..64ce3b3f6350c 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1363,7 +1363,13 @@ static SmallVector<AOTOutputs, 16> add_output(Module &M, TargetMachine &TM, Stri
                 LLVMContext ctx;
                 // Lazily deserialize the entire module
                 timers[i].deserialize.startTimer();
-                auto M = cantFail(getLazyBitcodeModule(MemoryBufferRef(StringRef(serialized.data(), serialized.size()), "Optimized"), ctx), "Error loading module");
+                auto EM = getLazyBitcodeModule(MemoryBufferRef(StringRef(serialized.data(), serialized.size()), "Optimized"), ctx);
+                // Make sure this also fails with only julia, but not LLVM assertions enabled,
+                // otherwise, the first error we hit is the LLVM module verification failure,
+                // which will look very confusing, because the module was partially deserialized.
+                bool deser_succeeded = (bool)EM;
+                auto M = cantFail(std::move(EM), "Error loading module");
+                assert(deser_succeeded); (void)deser_succeeded;
                 timers[i].deserialize.stopTimer();
 
                 timers[i].materialize.startTimer();

From 08d89eb2cede81ce46b0337e2d1d31e812b82d46 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 26 Nov 2023 23:27:43 -0500
Subject: [PATCH 0334/1315] codegen: fix ssa order regression from initializing
 structs (#52311)

---
 src/cgutils.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 15a1522ee0d57..9f74fee1fb6ae 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -3733,7 +3733,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                 strct = emit_static_alloca(ctx, lt);
                 setName(ctx.emission_context, strct, arg_typename);
                 if (nargs < nf)
-                    ctx.builder.CreateStore(ctx.builder.CreateFreeze(UndefValue::get(lt)), strct);
+                    promotion_point = ctx.builder.CreateStore(ctx.builder.CreateFreeze(UndefValue::get(lt)), strct);
                 if (tracked.count)
                     undef_derived_strct(ctx, strct, sty, ctx.tbaa().tbaa_stack);
             }

From 4a18886a16308dee8d475c942bc641d718e59e9f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Mon, 27 Nov 2023 05:27:30 +0000
Subject: [PATCH 0335/1315] More helpful error message for empty `cpu_target`
 in `Base.julia_cmd` (#52217)

Fix #52209.
---
 base/util.jl        |  6 ++++--
 test/cmdlineargs.jl | 16 +++++++++++++---
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/base/util.jl b/base/util.jl
index a3771f4ae9dc4..929b6f99a227a 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -144,7 +144,7 @@ See also [`print`](@ref), [`println`](@ref), [`show`](@ref).
     printstyled(stdout, msg...; bold=bold, italic=italic, underline=underline, blink=blink, reverse=reverse, hidden=hidden, color=color)
 
 """
-    Base.julia_cmd(juliapath=joinpath(Sys.BINDIR, julia_exename()); cpu_target)
+    Base.julia_cmd(juliapath=joinpath(Sys.BINDIR, julia_exename()); cpu_target::Union{Nothing,String}=nothing)
 
 Return a julia command similar to the one of the running process.
 Propagates any of the `--cpu-target`, `--sysimage`, `--compile`, `--sysimage-native-code`,
@@ -154,6 +154,8 @@ command line arguments that are not at their default values.
 
 Among others, `--math-mode`, `--warn-overwrite`, and `--trace-compile` are notably not propagated currently.
 
+Unless set to `nothing`, the `cpu_target` keyword argument can be used to override the CPU target set for the running process.
+
 To get the julia command without propagated command line arguments, `julia_cmd()[1]` can be used.
 
 !!! compat "Julia 1.1"
@@ -243,7 +245,7 @@ function julia_cmd(julia=joinpath(Sys.BINDIR, julia_exename()); cpu_target::Unio
     if opts.use_pkgimages == 0
         push!(addflags, "--pkgimages=no")
     end
-    return `$julia -C$cpu_target -J$image_file $addflags`
+    return `$julia -C $cpu_target -J$image_file $addflags`
 end
 
 function julia_exename()
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index ae81dbb0fefbe..564f352424369 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -77,7 +77,9 @@ end
     opts = Base.JLOptions()
 
     for (arg, default) in (
-                            ("-C$(unsafe_string(opts.cpu_target))",  false),
+                            # Use a Cmd to handle space nicely when
+                            # interpolating inside another Cmd.
+                            (`-C $(unsafe_string(opts.cpu_target))`,  false),
 
                             ("-J$(unsafe_string(opts.image_file))",  false),
 
@@ -134,13 +136,21 @@ end
                             ("--pkgimages=no",  false),
                         )
         @testset "$arg" begin
+            str = arg isa Cmd ? join(arg.exec, ' ') : arg
             if default
-                @test !occursin(arg, get_julia_cmd(arg))
+                @test !occursin(str, get_julia_cmd(arg))
             else
-                @test occursin(arg, get_julia_cmd(arg))
+                @test occursin(str, get_julia_cmd(arg))
             end
         end
     end
+
+    # Test empty `cpu_target` gives a helpful error message, issue #52209.
+    io = IOBuffer()
+    p = run(pipeline(`$(Base.julia_cmd(; cpu_target="")) --startup-file=no -e ''`; stderr=io); wait=false)
+    wait(p)
+    @test p.exitcode == 1
+    @test occursin("empty CPU name", String(take!(io)))
 end
 
 let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`

From 9dcedaa8ec198b49387a8459e4daff1474b93ce2 Mon Sep 17 00:00:00 2001
From: Mason Protter <mason.protter@icloud.com>
Date: Mon, 27 Nov 2023 07:00:19 +0100
Subject: [PATCH 0336/1315] Memoize `cwstring` when used for env lookup /
 modification on Windows (#51371)

~This is just me proposing a suggestion from @KristofferC in
https://discourse.julialang.org/t/debug-has-massive-performance-impact/103974/22,
it's all his code / idea, not mine.~

This PR makes it so that on windows, we pre-allocate an `IdDict` and
every time someone looks up environment variables (motivating example
here is `@debug` statements), we store the result of
`cwstring(::String)` in that `IdDict` so that it doesn't need to be
re-computed for future uses.

The idea behind this is that people have observed that [using `@debug`
is significantly more costly on Windows than other
platforms](https://discourse.julialang.org/t/debug-has-massive-performance-impact/103974),
even though we have documented in that manual that it should be a really
cheap operation. @KristofferC suggests this is due to the fact that
[checking environment variables in Windows is more
costly](https://discourse.julialang.org/t/debug-has-massive-performance-impact/103974/18).

~The idea here is that we preallocate a `Cwstring` on Windows that just
holds the text `"JULIA_DEBUG"`, so that if `access_env(f,
"JULIA_DEBUG")` gets called, we don't need to create a new `Cwstring`
and then throw it away each time.~

---------

Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/env.jl | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/base/env.jl b/base/env.jl
index 077b3a4ed28e5..27594acff6b7f 100644
--- a/base/env.jl
+++ b/base/env.jl
@@ -3,12 +3,29 @@
 if Sys.iswindows()
     const ERROR_ENVVAR_NOT_FOUND = UInt32(203)
 
+    const env_dict = IdDict{String, Vector{Cwchar_t}}()
+    const env_lock = ReentrantLock()
+
+    function memoized_env_lookup(str::AbstractString)
+        # Windows environment variables have a different format from Linux / MacOS, and previously
+        # incurred allocations because we had to convert a String to a Vector{Cwchar_t} each time
+        # an environment variable was looked up. This function memoizes that lookup process, storing
+        # the String => Vector{Cwchar_t} pairs in env_dict
+        var = get(env_dict, str, nothing)
+        if isnothing(var)
+            var = @lock env_lock begin
+                env_dict[str] = cwstring(str)
+            end
+        end
+        var
+    end
+
     _getenvlen(var::Vector{UInt16}) = ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Ptr{UInt16},Ptr{UInt16},UInt32),var,C_NULL,0)
     _hasenv(s::Vector{UInt16}) = _getenvlen(s) != 0 || Libc.GetLastError() != ERROR_ENVVAR_NOT_FOUND
-    _hasenv(s::AbstractString) = _hasenv(cwstring(s))
+    _hasenv(s::AbstractString) = _hasenv(memoized_env_lookup(s))
 
     function access_env(onError::Function, str::AbstractString)
-        var = cwstring(str)
+        var = memoized_env_lookup(str)
         len = _getenvlen(var)
         if len == 0
             return Libc.GetLastError() != ERROR_ENVVAR_NOT_FOUND ? "" : onError(str)
@@ -21,7 +38,7 @@ if Sys.iswindows()
     end
 
     function _setenv(svar::AbstractString, sval::AbstractString, overwrite::Bool=true)
-        var = cwstring(svar)
+        var = memoized_env_lookup(svar)
         val = cwstring(sval)
         if overwrite || !_hasenv(var)
             ret = ccall(:SetEnvironmentVariableW,stdcall,Int32,(Ptr{UInt16},Ptr{UInt16}),var,val)
@@ -30,7 +47,7 @@ if Sys.iswindows()
     end
 
     function _unsetenv(svar::AbstractString)
-        var = cwstring(svar)
+        var = memoized_env_lookup(svar)
         ret = ccall(:SetEnvironmentVariableW,stdcall,Int32,(Ptr{UInt16},Ptr{UInt16}),var,C_NULL)
         windowserror(:setenv, ret == 0 && Libc.GetLastError() != ERROR_ENVVAR_NOT_FOUND)
     end

From 9233a16172139c06107b475480bfce098f10a8a6 Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Mon, 27 Nov 2023 07:01:45 +0100
Subject: [PATCH 0337/1315] Document Base.StatStruct's fields as public
 (#50177)

These fields are documented in the docstring of `stat`, and also
mentioned as being public in the style guide, but their types are not
documented, nor is `StatStruct` directly documented.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/stat.jl | 55 +++++++++++++++++++++++++++++++++++++---------------
 test/file.jl | 22 +++++++++++++++++++++
 2 files changed, 61 insertions(+), 16 deletions(-)

diff --git a/base/stat.jl b/base/stat.jl
index 43c51b0b911df..56b960c4f74ea 100644
--- a/base/stat.jl
+++ b/base/stat.jl
@@ -25,6 +25,30 @@ export
     stat,
     uperm
 
+"""
+    StatStruct
+
+A struct which stores the information from `stat`.
+The following fields of this struct is considered public API:
+
+| Name    | Type                            | Description                                                        |
+|:--------|:--------------------------------|:-------------------------------------------------------------------|
+| desc    | `Union{String, Base.OS_HANDLE}` | The path or OS file descriptor                                     |
+| size    | `Int64`                         | The size (in bytes) of the file                                    |
+| device  | `UInt`                          | ID of the device that contains the file                            |
+| inode   | `UInt`                          | The inode number of the file                                       |
+| mode    | `UInt`                          | The protection mode of the file                                    |
+| nlink   | `Int`                           | The number of hard links to the file                               |
+| uid     | `UInt`                          | The user id of the owner of the file                               |
+| gid     | `UInt`                          | The group id of the file owner                                     |
+| rdev    | `UInt`                          | If this file refers to a device, the ID of the device it refers to |
+| blksize | `Int64`                         | The file-system preferred block size for the file                  |
+| blocks  | `Int64`                         | The number of 512-byte blocks allocated                            |
+| mtime   | `Float64`                       | Unix timestamp of when the file was last modified                  |
+| ctime   | `Float64`                       | Unix timestamp of when the file's metadata was changed             |
+
+See also: [`stat`](@ref)
+"""
 struct StatStruct
     desc    :: Union{String, OS_HANDLE} # for show method, not included in equality or hash
     device  :: UInt
@@ -173,22 +197,21 @@ stat(fd::Integer)           = stat(RawFD(fd))
 Return a structure whose fields contain information about the file.
 The fields of the structure are:
 
-| Name    | Description                                                        |
-|:--------|:-------------------------------------------------------------------|
-| desc    | The path or OS file descriptor                                     |
-| size    | The size (in bytes) of the file                                    |
-| device  | ID of the device that contains the file                            |
-| inode   | The inode number of the file                                       |
-| mode    | The protection mode of the file                                    |
-| nlink   | The number of hard links to the file                               |
-| uid     | The user id of the owner of the file                               |
-| gid     | The group id of the file owner                                     |
-| rdev    | If this file refers to a device, the ID of the device it refers to |
-| blksize | The file-system preferred block size for the file                  |
-| blocks  | The number of 512-byte blocks allocated                            |
-| mtime   | Unix timestamp of when the file was last modified                  |
-| ctime   | Unix timestamp of when the file's metadata was changed             |
-
+| Name    | Type                            | Description                                                        |
+|:--------|:--------------------------------|:-------------------------------------------------------------------|
+| desc    | `Union{String, Base.OS_HANDLE}` | The path or OS file descriptor                                     |
+| size    | `Int64`                         | The size (in bytes) of the file                                    |
+| device  | `UInt`                          | ID of the device that contains the file                            |
+| inode   | `UInt`                          | The inode number of the file                                       |
+| mode    | `UInt`                          | The protection mode of the file                                    |
+| nlink   | `Int`                           | The number of hard links to the file                               |
+| uid     | `UInt`                          | The user id of the owner of the file                               |
+| gid     | `UInt`                          | The group id of the file owner                                     |
+| rdev    | `UInt`                          | If this file refers to a device, the ID of the device it refers to |
+| blksize | `Int64`                         | The file-system preferred block size for the file                  |
+| blocks  | `Int64`                         | The number of 512-byte blocks allocated                            |
+| mtime   | `Float64`                       | Unix timestamp of when the file was last modified                  |
+| ctime   | `Float64`                       | Unix timestamp of when the file's metadata was changed             |
 """
 stat(path...) = stat(joinpath(path...))
 
diff --git a/test/file.jl b/test/file.jl
index b392ffb3e8161..808fba52f9048 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -1695,6 +1695,28 @@ if Sys.iswindows()
 end
 end
 
+# Unusually for structs, we test this explicitly because the fields of StatStruct
+# is part of its documentation, and therefore cannot change.
+@testset "StatStruct has promised fields" begin
+    f, io = mktemp()
+    s = stat(f)
+    @test s isa Base.StatStruct
+
+    @test s.desc isa Union{String, Base.OS_HANDLE}
+    @test s.size isa Int64
+    @test s.device isa UInt
+    @test s.inode isa UInt
+    @test s.mode isa UInt
+    @test s.nlink isa Int
+    @test s.uid isa UInt
+    @test s.gid isa UInt
+    @test s.rdev isa UInt
+    @test s.blksize isa Int64
+    @test s.blocks isa Int64
+    @test s.mtime isa Float64
+    @test s.ctime isa Float64
+end
+
 @testset "StatStruct show's extended details" begin
     f, io = mktemp()
     s = stat(f)

From 5b2fcb68800875e570d7bb8c78ed00d360b6cfd5 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Mon, 27 Nov 2023 12:01:53 -0500
Subject: [PATCH 0338/1315] Compiler support for optimizing PersistentDict
 (#51993)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is part of the work to address #51352 by attempting to allow the
compiler to perform SRAO on persistent data structures like
`PersistentDict` as if they were regular immutable data structures.
These sorts of data structures have very complicated internals (with
lots of mutation, memory sharing, etc.), but a relatively simple
interface. As such, it is unlikely that our compiler will have
sufficient power to optimize this interface by analyzing the
implementation.

We thus need to come up with some other mechanism that gives the
compiler license to perform the requisite optimization. One way would be
to just hardcode `PersistentDict` into the compiler, optimizing it like
any of the other builtin datatypes. However, this is of course very
unsatisfying. At the other end of the spectrum would be something like a
generic rewrite rule system (e-graphs anyone?) that would let the
PersistentDict implementation declare its interface to the compiler and
the compiler would use this for optimization (in a perfect world, the
actual rewrite would then be checked using some sort of formal methods).
I think that would be interesting, but we're very far from even being
able to design something like that (at least in Base - experiments with
external AbstractInterpreters in this direction are encouraged).

This PR tries to come up with a reasonable middle ground, where the
compiler gets some knowledge of the protocol hardcoded without having to
know about the implementation details of the data structure.

The basic ideas is that `Core` provides some magic generic functions
that implementations can extend. Semantically, they are not special.
They dispatch as usual, and implementations are expected to work
properly even in the absence of any compiler optimizations.

However, the compiler is semantically permitted to perform structural
optimization using these magic generic functions. In the concrete case,
this PR introduces the `KeyValue` interface which consists of two
generic functions, `get` and `set`. The core optimization is that the
compiler is allowed to rewrite any occurrence of `get(set(x, k, v), k)`
into `v` without additional legality checks. In particular, the compiler
performs no type checks, conversions, etc. The higher level
implementation code is expected to do all that.

This approach closely matches the general direction we've been taking in
external AbstractInterpreters for embedding additional semantics and
optimization opportunities into Julia code (although we generally use
methods there, rather than full generic functions), so I think we have
some evidence that this sort of approach works reasonably well.

Nevertheless, this is certainly an experiment and the interface is
explicitly declared unstable.

## Current Status

This is fully working and implemented, but the optimization currently
bails on anything but the simplest cases. Filling all those cases in is
not particularly hard, but should be done along with a more invasive
refactoring of SROA, so we should figure out the general direction here
first and then we can finish all that up in a follow-up cleanup.

## Obligatory benchmark
Before:
```
julia> using BenchmarkTools

julia> function foo()
           a = Base.PersistentDict(:a => 1)
           return a[:a]
       end
foo (generic function with 1 method)

julia> @benchmark foo()
BenchmarkTools.Trial: 10000 samples with 993 evaluations.
 Range (min … max):  32.940 ns …  28.754 μs  ┊ GC (min … max):  0.00% … 99.76%
 Time  (median):     49.647 ns               ┊ GC (median):     0.00%
 Time  (mean ± σ):   57.519 ns ± 333.275 ns  ┊ GC (mean ± σ):  10.81% ±  2.22%

        ▃█▅               ▁▃▅▅▃▁                ▁▃▂   ▂
  ▁▂▄▃▅▇███▇▃▁▂▁▁▁▁▁▁▁▁▂▂▅██████▅▂▁▁▁▁▁▁▁▁▁▁▂▃▃▇███▇▆███▆▄▃▃▂▂ ▃
  32.9 ns         Histogram: frequency by time         68.6 ns <

 Memory estimate: 128 bytes, allocs estimate: 4.

julia> @code_typed foo()
CodeInfo(
1 ─ %1  = invoke Vector{Union{Base.HashArrayMappedTries.HAMT{Symbol, Int64}, Base.HashArrayMappedTries.Leaf{Symbol, Int64}}}(Base.HashArrayMappedTries.undef::UndefInitializer, 1::Int64)::Vector{Union{Base.HashArrayMappedTries.HAMT{Symbol, Int64}, Base.HashArrayMappedTries.Leaf{Symbol, Int64}}}
│   %2  = %new(Base.HashArrayMappedTries.HAMT{Symbol, Int64}, %1, 0x00000000)::Base.HashArrayMappedTries.HAMT{Symbol, Int64}
│   %3  = %new(Base.HashArrayMappedTries.Leaf{Symbol, Int64}, :a, 1)::Base.HashArrayMappedTries.Leaf{Symbol, Int64}
│   %4  = Base.getfield(%2, :data)::Vector{Union{Base.HashArrayMappedTries.HAMT{Symbol, Int64}, Base.HashArrayMappedTries.Leaf{Symbol, Int64}}}
│   %5  = $(Expr(:boundscheck, true))::Bool
└──       goto #5 if not %5
2 ─ %7  = Base.sub_int(1, 1)::Int64
│   %8  = Base.bitcast(UInt64, %7)::UInt64
│   %9  = Base.getfield(%4, :size)::Tuple{Int64}
│   %10 = $(Expr(:boundscheck, true))::Bool
│   %11 = Base.getfield(%9, 1, %10)::Int64
│   %12 = Base.bitcast(UInt64, %11)::UInt64
│   %13 = Base.ult_int(%8, %12)::Bool
└──       goto #4 if not %13
3 ─       goto #5
4 ─ %16 = Core.tuple(1)::Tuple{Int64}
│         invoke Base.throw_boundserror(%4::Vector{Union{Base.HashArrayMappedTries.HAMT{Symbol, Int64}, Base.HashArrayMappedTries.Leaf{Symbol, Int64}}}, %16::Tuple{Int64})::Union{}
└──       unreachable
5 ┄ %19 = Base.getfield(%4, :ref)::MemoryRef{Union{Base.HashArrayMappedTries.HAMT{Symbol, Int64}, Base.HashArrayMappedTries.Leaf{Symbol, Int64}}}
│   %20 = Base.memoryref(%19, 1, false)::MemoryRef{Union{Base.HashArrayMappedTries.HAMT{Symbol, Int64}, Base.HashArrayMappedTries.Leaf{Symbol, Int64}}}
│         Base.memoryrefset!(%20, %3, :not_atomic, false)::MemoryRef{Union{Base.HashArrayMappedTries.HAMT{Symbol, Int64}, Base.HashArrayMappedTries.Leaf{Symbol, Int64}}}
└──       goto #6
6 ─ %23 = Base.getfield(%2, :bitmap)::UInt32
│   %24 = Base.or_int(%23, 0x00010000)::UInt32
│         Base.setfield!(%2, :bitmap, %24)::UInt32
└──       goto #7
7 ─ %27 = %new(Base.PersistentDict{Symbol, Int64}, %2)::Base.PersistentDict{Symbol, Int64}
└──       goto #8
8 ─ %29 = invoke Base.getindex(%27::Base.PersistentDict{Symbol, Int64}, :a::Symbol)::Int64
└──       return %29
```

After:
```
julia> using BenchmarkTools

julia> function foo()
           a = Base.PersistentDict(:a => 1)
           return a[:a]
       end
foo (generic function with 1 method)

julia> @benchmark foo()
BenchmarkTools.Trial: 10000 samples with 1000 evaluations.
 Range (min … max):  2.459 ns … 11.320 ns  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     2.460 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   2.469 ns ±  0.183 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

  ▂    █                                              ▁    █ ▂
  █▁▁▁▁█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█▁▁▁▁█ █
  2.46 ns      Histogram: log(frequency) by time     2.47 ns <

 Memory estimate: 0 bytes, allocs estimate: 0.

julia> @code_typed foo()
CodeInfo(
1 ─     return 1
```
---
 base/boot.jl                  |   3 +-
 base/compiler/ssair/passes.jl |  82 ++++++++++++++++++++-
 base/dict.jl                  | 129 ++++++++++++++++++----------------
 base/hamt.jl                  |  12 +++-
 base/optimized_generics.jl    |  57 +++++++++++++++
 test/compiler/irpasses.jl     |  10 +++
 6 files changed, 228 insertions(+), 65 deletions(-)
 create mode 100644 base/optimized_generics.jl

diff --git a/base/boot.jl b/base/boot.jl
index b84f9b76838e0..218e4e2e533b1 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -957,7 +957,6 @@ function _hasmethod(@nospecialize(tt)) # this function has a special tfunc
     return Intrinsics.not_int(ccall(:jl_gf_invoke_lookup, Any, (Any, Any, UInt), tt, nothing, world) === nothing)
 end
 
-
 # for backward compat
 arrayref(inbounds::Bool, A::Array, i::Int...) = Main.Base.getindex(A, i...)
 const_arrayref(inbounds::Bool, A::Array, i::Int...) = Main.Base.getindex(A, i...)
@@ -969,4 +968,6 @@ export arrayref, arrayset, arraysize, const_arrayref
 # For convenience
 EnterNode(old::EnterNode, new_dest::Int) = EnterNode(new_dest)
 
+include(Core, "optimized_generics.jl")
+
 ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Core, true)
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 8b3ae55fe7429..f280b11532c19 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -6,6 +6,13 @@ function is_known_call(@nospecialize(x), @nospecialize(func), ir::Union{IRCode,I
     return singleton_type(ft) === func
 end
 
+function is_known_invoke_or_call(@nospecialize(x), @nospecialize(func), ir::Union{IRCode,IncrementalCompact})
+    isinvoke = isexpr(x, :invoke)
+    (isinvoke || isexpr(x, :call)) || return false
+    ft = argextype(x.args[isinvoke ? 2 : 1], ir)
+    return singleton_type(ft) === func
+end
+
 struct SSAUse
     kind::Symbol
     idx::Int
@@ -819,6 +826,76 @@ function lift_svec_ref!(compact::IncrementalCompact, idx::Int, stmt::Expr)
     return
 end
 
+function lift_leaves_keyvalue(compact::IncrementalCompact, @nospecialize(key),
+                             leaves::Vector{Any}, 𝕃ₒ::AbstractLattice)
+    # For every leaf, the lifted value
+    lifted_leaves = LiftedLeaves()
+    for i = 1:length(leaves)
+        leaf = leaves[i]
+        cache_key = leaf
+        if isa(leaf, AnySSAValue)
+            (def, leaf) = walk_to_def(compact, leaf)
+            if is_known_invoke_or_call(def, Core.OptimizedGenerics.KeyValue.set, compact)
+                @assert isexpr(def, :invoke)
+                if length(def.args) in (5, 6)
+                    collection = def.args[end-2]
+                    set_key = def.args[end-1]
+                    set_val_idx = length(def.args)
+                elseif length(def.args) == 4
+                    collection = def.args[end-1]
+                    # Key is deleted
+                    # TODO: Model this
+                    return nothing
+                elseif length(def.args) == 3
+                    collection = def.args[end]
+                    # The whole collection is deleted
+                    # TODO: Model this
+                    return nothing
+                else
+                    return nothing
+                end
+                if set_key === key || (egal_tfunc(𝕃ₒ, argextype(key, compact), argextype(set_key, compact)) == Const(true))
+                    lift_arg!(compact, leaf, cache_key, def, set_val_idx, lifted_leaves)
+                    continue
+                end
+                # TODO: Continue walking the chain
+                return nothing
+            end
+        end
+        return nothing
+    end
+    return lifted_leaves
+end
+
+function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 𝕃ₒ::AbstractLattice)
+    collection = stmt.args[end-1]
+    key = stmt.args[end]
+
+    leaves, visited_philikes = collect_leaves(compact, collection, Any, 𝕃ₒ, phi_or_ifelse_predecessors)
+    isempty(leaves) && return
+
+    lifted_leaves = lift_leaves_keyvalue(compact, key, leaves, 𝕃ₒ)
+    lifted_leaves === nothing && return
+
+    result_t = Union{}
+    for v in values(lifted_leaves)
+        v === nothing && return
+        result_t = tmerge(𝕃ₒ, result_t, argextype(v.val, compact))
+    end
+
+    lifted_val = perform_lifting!(compact,
+        visited_philikes, key, result_t, lifted_leaves, collection, nothing)
+
+    compact[idx] = lifted_val === nothing ? nothing : Expr(:call, Core.tuple, lifted_val.val)
+    if lifted_val !== nothing
+        if !⊑(𝕃ₒ, compact[SSAValue(idx)][:type], result_t)
+            compact[SSAValue(idx)][:flag] |= IR_FLAG_REFINED
+        end
+    end
+
+    return
+end
+
 # TODO: We could do the whole lifing machinery here, but really all
 # we want to do is clean this up when it got inserted by inlining,
 # which always targets simple `svec` call or `_compute_sparams`,
@@ -1004,7 +1081,7 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
     for ((_, idx), stmt) in compact
         # check whether this statement is `getfield` / `setfield!` (or other "interesting" statement)
         isa(stmt, Expr) || continue
-        is_setfield = is_isdefined = is_finalizer = false
+        is_setfield = is_isdefined = is_finalizer = is_keyvalue_get = false
         field_ordering = :unspecified
         if is_known_call(stmt, setfield!, compact)
             4 <= length(stmt.args) <= 5 || continue
@@ -1094,6 +1171,9 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
                 lift_comparison!(isa, compact, idx, stmt, 𝕃ₒ)
             elseif is_known_call(stmt, Core.ifelse, compact)
                 fold_ifelse!(compact, idx, stmt)
+            elseif is_known_invoke_or_call(stmt, Core.OptimizedGenerics.KeyValue.get, compact)
+                2 == (length(stmt.args) - (isexpr(stmt, :invoke) ? 2 : 1)) || continue
+                lift_keyvalue_get!(compact, idx, stmt, 𝕃ₒ)
             elseif isexpr(stmt, :new)
                 refine_new_effects!(𝕃ₒ, compact, idx, stmt)
             end
diff --git a/base/dict.jl b/base/dict.jl
index 83180f5c0ee1b..768f8215946b8 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -887,10 +887,35 @@ _similar_for(c::AbstractDict, ::Type{T}, itr, isz, len) where {T} =
 
 include("hamt.jl")
 using .HashArrayMappedTries
+using Core.OptimizedGenerics: KeyValue
 const HAMT = HashArrayMappedTries
 
 struct PersistentDict{K,V} <: AbstractDict{K,V}
     trie::HAMT.HAMT{K,V}
+    # Serves as a marker for an empty initialization
+    @noinline function KeyValue.set(::Type{PersistentDict{K, V}}) where {K, V}
+        new{K, V}(HAMT.HAMT{K,V}())
+    end
+    @noinline function KeyValue.set(::Type{PersistentDict{K, V}}, ::Nothing, key, val) where {K, V}
+        new{K, V}(HAMT.HAMT{K, V}(key => val))
+    end
+    @noinline function KeyValue.set(dict::PersistentDict{K, V}, key, val) where {K, V}
+        trie = dict.trie
+        h = HAMT.HashState(key)
+        found, present, trie, i, bi, top, hs = HAMT.path(trie, key, h, #=persistent=# true)
+        HAMT.insert!(found, present, trie, i, bi, hs, val)
+        return new{K, V}(top)
+    end
+    @noinline function KeyValue.set(dict::PersistentDict{K, V}, key) where {K, V}
+        trie = dict.trie
+        h = HAMT.HashState(key)
+        found, present, trie, i, bi, top, _ = HAMT.path(trie, key, h, #=persistent=# true)
+        if found && present
+            deleteat!(trie.data, i)
+            HAMT.unset!(trie, bi)
+        end
+        return new{K, V}(top)
+    end
 end
 
 """
@@ -925,19 +950,27 @@ Base.PersistentDict{Symbol, Int64} with 1 entry:
 """
 PersistentDict
 
-PersistentDict{K,V}() where {K,V} = PersistentDict(HAMT.HAMT{K,V}())
-PersistentDict{K,V}(KV::Pair) where {K,V} = PersistentDict(HAMT.HAMT{K,V}(KV))
-PersistentDict(KV::Pair{K,V}) where {K,V} = PersistentDict(HAMT.HAMT{K,V}(KV))
+PersistentDict{K,V}() where {K, V} = KeyValue.set(PersistentDict{K,V})
+function PersistentDict{K,V}(KV::Pair) where {K,V}
+    KeyValue.set(
+        PersistentDict{K, V},
+        nothing,
+        KV...)
+end
+function PersistentDict(KV::Pair{K,V}) where {K,V}
+    KeyValue.set(
+        PersistentDict{K, V},
+        nothing,
+        KV...)
+end
 PersistentDict(dict::PersistentDict, pair::Pair) = PersistentDict(dict, pair...)
 PersistentDict{K,V}(dict::PersistentDict{K,V}, pair::Pair) where {K,V} = PersistentDict(dict, pair...)
+
+
 function PersistentDict(dict::PersistentDict{K,V}, key, val) where {K,V}
     key = convert(K, key)
     val = convert(V, val)
-    trie = dict.trie
-    h = HAMT.HashState(key)
-    found, present, trie, i, bi, top, hs = HAMT.path(trie, key, h, #=persistent=# true)
-    HAMT.insert!(found, present, trie, i, bi, hs, val)
-    return PersistentDict(top)
+    return KeyValue.set(dict, key, val)
 end
 
 function PersistentDict{K,V}(KV::Pair, rest::Pair...) where {K,V}
@@ -959,84 +992,60 @@ end
 eltype(::PersistentDict{K,V}) where {K,V} = Pair{K,V}
 
 function in(key_val::Pair{K,V}, dict::PersistentDict{K,V}, valcmp=(==)) where {K,V}
-    trie = dict.trie
-    if HAMT.islevel_empty(trie)
-        return false
-    end
-
     key, val = key_val
-
-    h = HAMT.HashState(key)
-    found, present, trie, i, _, _, _ = HAMT.path(trie, key, h)
-    if found && present
-        leaf = @inbounds trie.data[i]::HAMT.Leaf{K,V}
-        return valcmp(val, leaf.val) && return true
-    end
-    return false
+    found = KeyValue.get(dict, key)
+    found === nothing && return false
+    return valcmp(val, only(found))
 end
 
 function haskey(dict::PersistentDict{K}, key::K) where K
-    trie = dict.trie
-    h = HAMT.HashState(key)
-    found, present, _, _, _, _, _ = HAMT.path(trie, key, h)
-    return found && present
+    return KeyValue.get(dict, key) !== nothing
 end
 
 function getindex(dict::PersistentDict{K,V}, key::K) where {K,V}
-    trie = dict.trie
-    if HAMT.islevel_empty(trie)
-        throw(KeyError(key))
-    end
-    h = HAMT.HashState(key)
-    found, present, trie, i, _, _, _ = HAMT.path(trie, key, h)
-    if found && present
-        leaf = @inbounds trie.data[i]::HAMT.Leaf{K,V}
-        return leaf.val
-    end
-    throw(KeyError(key))
+    found = KeyValue.get(dict, key)
+    found === nothing && throw(KeyError(key))
+    return only(found)
 end
 
 function get(dict::PersistentDict{K,V}, key::K, default) where {K,V}
-    trie = dict.trie
-    if HAMT.islevel_empty(trie)
-        return default
-    end
-    h = HAMT.HashState(key)
-    found, present, trie, i, _, _, _ = HAMT.path(trie, key, h)
-    if found && present
-        leaf = @inbounds trie.data[i]::HAMT.Leaf{K,V}
-        return leaf.val
-    end
-    return default
+    found = KeyValue.get(dict, key)
+    found === nothing && return default
+    return only(found)
 end
 
-function get(default::Callable, dict::PersistentDict{K,V}, key::K) where {K,V}
+@noinline function KeyValue.get(dict::PersistentDict{K, V}, key) where {K, V}
     trie = dict.trie
     if HAMT.islevel_empty(trie)
-        return default
+        return nothing
     end
     h = HAMT.HashState(key)
     found, present, trie, i, _, _, _ = HAMT.path(trie, key, h)
     if found && present
         leaf = @inbounds trie.data[i]::HAMT.Leaf{K,V}
-        return leaf.val
+        return (leaf.val,)
     end
-    return default()
+    return nothing
 end
 
-iterate(dict::PersistentDict, state=nothing) = HAMT.iterate(dict.trie, state)
+@noinline function KeyValue.get(default, dict::PersistentDict, key)
+    found = KeyValue.get(dict, key)
+    found === nothing && return default()
+    return only(found)
+end
+
+function get(default::Callable, dict::PersistentDict{K,V}, key::K) where {K,V}
+    found = KeyValue.get(dict, key)
+    found === nothing && return default()
+    return only(found)
+end
 
 function delete(dict::PersistentDict{K}, key::K) where K
-    trie = dict.trie
-    h = HAMT.HashState(key)
-    found, present, trie, i, bi, top, _ = HAMT.path(trie, key, h, #=persistent=# true)
-    if found && present
-        deleteat!(trie.data, i)
-        HAMT.unset!(trie, bi)
-    end
-    return PersistentDict(top)
+    return KeyValue.set(dict, key)
 end
 
+iterate(dict::PersistentDict, state=nothing) = HAMT.iterate(dict.trie, state)
+
 length(dict::PersistentDict) = HAMT.length(dict.trie)
 isempty(dict::PersistentDict) = HAMT.isempty(dict.trie)
 empty(::PersistentDict, ::Type{K}, ::Type{V}) where {K, V} = PersistentDict{K, V}()
diff --git a/base/hamt.jl b/base/hamt.jl
index e940f4e00b1d5..fc298b8b7a338 100644
--- a/base/hamt.jl
+++ b/base/hamt.jl
@@ -65,12 +65,18 @@ mutable struct HAMT{K, V}
     HAMT{K,V}(data, bitmap) where {K,V} = new{K,V}(data, bitmap)
     HAMT{K, V}() where {K, V} = new{K,V}(Vector{Union{Leaf{K, V}, HAMT{K, V}}}(undef, 0), zero(BITMAP))
 end
-function HAMT{K,V}((k,v)::Pair) where {K, V}
-    k = convert(K, k)
-    v = convert(V, v)
+
+@Base.assume_effects :nothrow function init_hamt(K, V, k, v)
     # For a single element we can't have a hash-collision
     trie = HAMT{K,V}(Vector{Union{Leaf{K, V}, HAMT{K, V}}}(undef, 1), zero(BITMAP))
     trie.data[1] = Leaf{K,V}(k,v)
+    return trie
+end
+
+function HAMT{K,V}((k,v)::Pair) where {K, V}
+    k = convert(K, k)
+    v = convert(V, v)
+    trie = init_hamt(K, V, k, v)
     bi = BitmapIndex(HashState(k))
     set!(trie, bi)
     return trie
diff --git a/base/optimized_generics.jl b/base/optimized_generics.jl
new file mode 100644
index 0000000000000..86b54a294564d
--- /dev/null
+++ b/base/optimized_generics.jl
@@ -0,0 +1,57 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+module OptimizedGenerics
+
+# This file defines interfaces that are recognized and optimized by the compiler
+# They are intended to be used by data structure implementations that wish to
+# opt into some level of compiler optimizations. These interfaces are
+# EXPERIMENTAL and currently intended for use by Base only. They are subject
+# to change or removal without notice. It is undefined behavior to add methods
+# to these generics that do not conform to the specified interface.
+#
+# The intended way to use these generics is that data structures will provide
+# appropriate implementations for a generic. In the absence of compiler
+# optimizations, these behave like regular methods. However, the compiler is
+# semantically allowed to perform certain structural optimizations on
+# appropriate combinations of these intrinsics without proving correctness.
+
+# Compiler-recognized generics for immutable key-value stores (dicts, etc.)
+"""
+    module KeyValue
+
+Implements a key-value like interface where the compiler has liberty to perform
+the following transformations. The core optimization semantically allowed for
+the compiler is:
+
+    get(set(x, key, val), key) -> (val,)
+
+where the compiler will recursively look through `x`. Keys are compared by
+egality.
+
+Implementations must observe the following constraints:
+
+1. It is undefined behavior for `get` not to return the exact (by egality) val
+   stored for a given `key`.
+"""
+module KeyValue
+    """
+        set(collection, [key [, val]])
+        set(T, collection, key, val)
+
+    Set the `key` in `collection` to `val`. If `val` is omitted, deletes the
+    value from the collection. If `key` is omitted as well, deletes all elements
+    of the collection.
+    """
+    function set end
+
+    """
+        get(collection, key)
+
+    Retrieve the value corresponding to `key` in `collection` as a single
+    element tuple or `nothing` if no value corresponding to the key was found.
+    `key`s are compared by egal.
+    """
+    function get end
+end
+
+end
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 204d0400ea701..fe5263059b0ba 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1616,3 +1616,13 @@ let m = Meta.@lower 1 + 1
 end
 
 # JET.test_opt(Core.Compiler.cfg_simplify!, (Core.Compiler.IRCode,))
+
+# Test support for Core.OptimizedGenerics.KeyValue protocol
+function persistent_dict_elim()
+    a = Base.PersistentDict(:a => 1)
+    return a[:a]
+end
+# Ideally we would be able to fully eliminate this,
+# but currently this would require an extra round of constprop
+@test_broken fully_eliminated(persistent_dict_elim)
+@test code_typed(persistent_dict_elim)[1][1].code[end] == Core.ReturnNode(1)

From 72dbbdb27bce02319b54caea078bb020a0020f62 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 28 Nov 2023 00:18:39 -0500
Subject: [PATCH 0339/1315] cfg_simplify: Handle various corner cases with
 try/catch blocks (#52323)

Mostly long-standing bugs related to not handling the virtual
predecessor to catch blocks, but also one recent regression from the
EnterNode change.
---
 base/compiler/ssair/passes.jl | 17 +++++++++--
 test/compiler/irpasses.jl     | 53 +++++++++++++++++++++++++++++++++++
 2 files changed, 67 insertions(+), 3 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index f280b11532c19..3b8e5494db33e 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -2011,6 +2011,7 @@ function follow_map(map::Vector{Int}, idx::Int)
 end
 
 function ascend_eliminated_preds(bbs::Vector{BasicBlock}, pred::Int)
+    pred == 0 && return pred
     while pred != 1 && length(bbs[pred].preds) == 1 && length(bbs[pred].succs) == 1
         pred = bbs[pred].preds[1]
     end
@@ -2048,6 +2049,10 @@ function add_preds!(all_new_preds::Vector{Int32}, bbs::Vector{BasicBlock}, bb_re
     preds = copy(bbs[old_edge].preds)
     while !isempty(preds)
         old_edge′ = popfirst!(preds)
+        if old_edge′ == 0
+            push!(all_new_preds, old_edge′)
+            continue
+        end
         new_edge = bb_rename_pred[old_edge′]
         if new_edge > 0 && new_edge ∉ all_new_preds
             push!(all_new_preds, Int32(new_edge))
@@ -2147,9 +2152,9 @@ function cfg_simplify!(ir::IRCode)
                         push!(worklist, terminator.dest)
                     end
                 elseif isa(terminator, EnterNode)
-                    enteridx = terminator.args[1]::Int
-                    if bb_rename_succ[enteridx] == 0
-                        push!(worklist, enteridx)
+                    catchbb = terminator.catch_dest
+                    if bb_rename_succ[catchbb] == 0
+                        push!(worklist, catchbb)
                     end
                 end
                 ncurr = curr + 1
@@ -2329,6 +2334,12 @@ function cfg_simplify!(ir::IRCode)
                             else
                                 resize!(values, length(values)+1)
                             end
+                        elseif new_edge == -1
+                            @assert length(phi.edges) == 1
+                            if isassigned(phi.values, old_index)
+                                push!(edges, -1)
+                                push!(values, phi.values[old_index])
+                            end
                         elseif new_edge == -3
                             # Multiple predecessors, we need to expand out this phi
                             all_new_preds = Int32[]
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index fe5263059b0ba..5b6df09bb93b4 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1626,3 +1626,56 @@ end
 # but currently this would require an extra round of constprop
 @test_broken fully_eliminated(persistent_dict_elim)
 @test code_typed(persistent_dict_elim)[1][1].code[end] == Core.ReturnNode(1)
+
+# Test CFG simplify with try/catch blocks
+let m = Meta.@lower 1 + 1
+    @assert Meta.isexpr(m, :thunk)
+    src = m.args[1]::CodeInfo
+    src.code = Any[
+        # Block 1
+        GotoIfNot(Argument(1), 5),
+        # Block 2
+        EnterNode(4),
+        # Block 3
+        Expr(:leave),
+        # Block 4
+        GotoNode(5),
+        # Block 5
+        ReturnNode(1)
+    ]
+    nstmts = length(src.code)
+    src.ssavaluetypes = nstmts
+    src.codelocs = fill(Int32(1), nstmts)
+    src.ssaflags = fill(Int32(0), nstmts)
+    ir = Core.Compiler.inflate_ir(src)
+    Core.Compiler.verify_ir(ir)
+    ir = Core.Compiler.cfg_simplify!(ir)
+    Core.Compiler.verify_ir(ir)
+    @test length(ir.cfg.blocks) == 4
+end
+
+# Test CFG simplify with single predecessor phi node
+let m = Meta.@lower 1 + 1
+    @assert Meta.isexpr(m, :thunk)
+    src = m.args[1]::CodeInfo
+    src.code = Any[
+        # Block 1
+        Expr(:call, Base.inferencebarrier, 1),
+        GotoNode(3),
+        # Block 2
+        PhiNode(Int32[1], Any[SSAValue(1)]),
+        ReturnNode(SSAValue(3))
+    ]
+    nstmts = length(src.code)
+    src.ssavaluetypes = nstmts
+    src.codelocs = fill(Int32(1), nstmts)
+    src.ssaflags = fill(Int32(0), nstmts)
+    ir = Core.Compiler.inflate_ir(src)
+    Core.Compiler.verify_ir(ir)
+    ir = Core.Compiler.cfg_simplify!(ir)
+    Core.Compiler.verify_ir(ir)
+    @test length(ir.cfg.blocks) == 1
+    ir = Core.Compiler.compact!(ir)
+    @test length(ir.stmts) == 2
+    @test (ir[SSAValue(2)][:stmt]::ReturnNode).val == SSAValue(1)
+end

From df40bab2dadf6ad46b822e5ea3e71ac3ee238628 Mon Sep 17 00:00:00 2001
From: Hendrik Ranocha <ranocha@users.noreply.github.com>
Date: Tue, 28 Nov 2023 13:19:12 +0100
Subject: [PATCH 0340/1315] fix invalidations related to `ismutable` (#52170)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Related to #52134. It would be nice if the underlying inference issue
was fixed but this seems to be a hotfix for now.

I have seen this inference problem occurring in Julia v1.9, v1.10, and
current `master`. For example, on Julia v1.9.3, I get

```julia

julia> code_warntype(ismutable, (Function,))
MethodInstance for ismutable(::Function)
  from ismutable(x) @ Base reflection.jl:521
Arguments
  #self#::Core.Const(ismutable)
  x::Function
Body::Any
1 ─      nothing
│        nothing
│   %3 = Base.typeof(x)::Type{<:Function}
│   %4 = Base.getproperty(%3, :name)::Any
│   %5 = Base.getproperty(%4, :flags)::Any
│   %6 = (%5 & 0x02)::Any
│   %7 = (%6 == 0x02)::Any
└──      return %7
```

This causes some invalidations when `using OrdinaryDiffEq`.
---
 base/reflection.jl | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index 4d59942cf4013..19dd289efbebf 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -627,7 +627,9 @@ true
 !!! compat "Julia 1.5"
     This function requires at least Julia 1.5.
 """
-ismutable(@nospecialize(x)) = (@_total_meta; typeof(x).name.flags & 0x2 == 0x2)
+ismutable(@nospecialize(x)) = (@_total_meta; (typeof(x).name::Core.TypeName).flags & 0x2 == 0x2)
+# The type assertion above is required to fix some invalidations.
+# See also https://github.com/JuliaLang/julia/issues/52134
 
 """
     ismutabletype(T) -> Bool

From 68b4587420613f689e2d83fe6c6fb0f4ecdea4de Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Tue, 28 Nov 2023 08:39:40 -0600
Subject: [PATCH 0341/1315] Remove no-op specializations of `only` [NFC]
 (#52328)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An easily merged subset of @matthias314's #52296, separated from that PR
at @mkitti's suggestion.

I kept the low-but-nonzero value specializations for Tuple and Named
tuple which offer better error messages. They may be removed with a
future PR that improves the generic error message.

To verify this is indeed a no-op

```
@code_llvm only(Ref(4))
@code_llvm only(Ref(nothing))
@code_llvm only('z')
@code_llvm only((4,))
@code_llvm only((nothing,))
only((4,2))
@code_llvm only(Array{Int, 0}(undef))
@code_llvm only((;x=3))
only((;))
only((;x=2, y=4))
```
Before
```
julia> @code_llvm only(Ref(4))
; Function Signature: only(Base.RefValue{Int64})
;  @ iterators.jl:1563 within `only`
define i64 @julia_only_2451({}* noundef nonnull align 8 dereferenceable(8) %"x::RefValue") #0 {
top:
; ┌ @ refvalue.jl:59 within `getindex`
; │┌ @ Base.jl:49 within `getproperty`
    %0 = bitcast {}* %"x::RefValue" to i64*
    %.x = load i64, i64* %0, align 8
; └└
  ret i64 %.x
}

julia> @code_llvm only(Ref(nothing))
; Function Signature: only(Base.RefValue{Nothing})
;  @ iterators.jl:1563 within `only`
define void @julia_only_2519({}* noundef nonnull %"x::RefValue") #0 {
top:
  ret void
}

julia> @code_llvm only('z')
; Function Signature: only(Char)
;  @ iterators.jl:1565 within `only`
define i32 @julia_only_2527(i32 zeroext %"x::Char") #0 {
top:
  ret i32 %"x::Char"
}

julia> @code_llvm only((4,))
; Function Signature: only(Tuple{Int64})
;  @ iterators.jl:1566 within `only`
define i64 @julia_only_2529([1 x i64]* nocapture noundef nonnull readonly align 8 dereferenceable(8) %"x::Tuple") #0 {
top:
; ┌ @ tuple.jl:31 within `getindex`
   %"x::Tuple[1]_ptr" = getelementptr inbounds [1 x i64], [1 x i64]* %"x::Tuple", i64 0, i64 0
; └
  %"x::Tuple[1]_ptr.unbox" = load i64, i64* %"x::Tuple[1]_ptr", align 8
  ret i64 %"x::Tuple[1]_ptr.unbox"
}

julia> @code_llvm only((nothing,))
; Function Signature: only(Tuple{Nothing})
;  @ iterators.jl:1566 within `only`
define void @julia_only_2532() #0 {
top:
  ret void
}

julia> only((4,2))
ERROR: ArgumentError: Tuple contains 2 elements, must contain exactly 1 element
Stacktrace:
 [1] only(x::Tuple{Int64, Int64})
   @ Base.Iterators ./iterators.jl:1567
 [2] top-level scope
   @ REPL[6]:1

julia> @code_llvm only(Array{Int, 0}(undef))
; Function Signature: only(Array{Int64, 0})
;  @ iterators.jl:1570 within `only`
define i64 @julia_only_2779({}* noundef nonnull align 8 dereferenceable(16) %"a::Array") #0 {
top:
; ┌ @ abstractarray.jl:1314 within `getindex`
; │┌ @ abstractarray.jl:1343 within `_getindex`
; ││┌ @ essentials.jl:817 within `getindex`
     %0 = bitcast {}* %"a::Array" to i64**
     %1 = load i64*, i64** %0, align 8
     %2 = load i64, i64* %1, align 8
; └└└
  ret i64 %2
}

julia> @code_llvm only((;x=3))
; Function Signature: only(NamedTuple{(:x,), Tuple{Int64}})
;  @ iterators.jl:1571 within `only`
define i64 @julia_only_2794([1 x i64]* nocapture noundef nonnull readonly align 8 dereferenceable(8) %"x::NamedTuple") #0 {
top:
; ┌ @ abstractarray.jl:469 within `first`
; │┌ @ namedtuple.jl:165 within `iterate` @ namedtuple.jl:165
    %"x::NamedTuple.x_ptr" = getelementptr inbounds [1 x i64], [1 x i64]* %"x::NamedTuple", i64 0, i64 0
; └└
  %"x::NamedTuple.x_ptr.unbox" = load i64, i64* %"x::NamedTuple.x_ptr", align 8
  ret i64 %"x::NamedTuple.x_ptr.unbox"
}

julia> only((;))
ERROR: ArgumentError: NamedTuple contains 0 elements, must contain exactly 1 element
Stacktrace:
 [1] only(x::@NamedTuple{})
   @ Base.Iterators ./iterators.jl:1572
 [2] top-level scope
   @ REPL[9]:1

julia> only((;x=2, y=4))
ERROR: ArgumentError: NamedTuple contains 2 elements, must contain exactly 1 element
Stacktrace:
 [1] only(x::@NamedTuple{x::Int64, y::Int64})
   @ Base.Iterators ./iterators.jl:1572
 [2] top-level scope
   @ REPL[10]:1
```

After
```
julia> @code_llvm only(Ref(4))
; Function Signature: only(Base.RefValue{Int64})
;  @ iterators.jl:1550 within `only`
define i64 @julia_only_6821({}* noundef nonnull align 8 dereferenceable(8) %"x::RefValue") #0 {
top:
;  @ iterators.jl:1551 within `only`
; ┌ @ refpointer.jl:103 within `iterate`
; │┌ @ refvalue.jl:59 within `getindex`
; ││┌ @ Base.jl:49 within `getproperty`
     %0 = bitcast {}* %"x::RefValue" to i64*
     %.x = load i64, i64* %0, align 8
; └└└
;  @ iterators.jl:1559 within `only`
  ret i64 %.x
}

julia> @code_llvm only(Ref(nothing))
; Function Signature: only(Base.RefValue{Nothing})
;  @ iterators.jl:1550 within `only`
define void @julia_only_6824({}* noundef nonnull %"x::RefValue") #0 {
top:
;  @ iterators.jl:1559 within `only`
  ret void
}

julia> @code_llvm only('z')
; Function Signature: only(Char)
;  @ iterators.jl:1550 within `only`
define i32 @julia_only_6826(i32 zeroext %"x::Char") #0 {
top:
;  @ iterators.jl:1559 within `only`
  ret i32 %"x::Char"
}

julia> @code_llvm only((4,))
; Function Signature: only(Tuple{Int64})
;  @ /Users/x/.julia/dev/julia/base/iterators.jl:1566 within `only`
define i64 @julia_only_6833([1 x i64]* nocapture noundef nonnull readonly align 8 dereferenceable(8) %"x::Tuple") #0 {
top:
; ┌ @ tuple.jl:31 within `getindex`
   %"x::Tuple[1]_ptr" = getelementptr inbounds [1 x i64], [1 x i64]* %"x::Tuple", i64 0, i64 0
; └
  %"x::Tuple[1]_ptr.unbox" = load i64, i64* %"x::Tuple[1]_ptr", align 8
  ret i64 %"x::Tuple[1]_ptr.unbox"
}

julia> @code_llvm only((nothing,))
; Function Signature: only(Tuple{Nothing})
;  @ /Users/x/.julia/dev/julia/base/iterators.jl:1566 within `only`
define void @julia_only_6836() #0 {
top:
  ret void
}

julia> only((4,2))
ERROR: ArgumentError: Tuple contains 2 elements, must contain exactly 1 element
Stacktrace:
 [1] only(x::Tuple{Int64, Int64})
   @ Base.Iterators ~/.julia/dev/julia/base/iterators.jl:1564
 [2] top-level scope
   @ REPL[31]:1

julia> @code_llvm only(Array{Int, 0}(undef))
; Function Signature: only(Array{Int64, 0})
;  @ iterators.jl:1550 within `only`
define i64 @julia_only_6848({}* noundef nonnull align 8 dereferenceable(16) %"x::Array") #0 {
L60:
;  @ iterators.jl:1551 within `only`
; ┌ @ array.jl:884 within `iterate` @ array.jl:884
; │┌ @ essentials.jl:817 within `getindex`
    %0 = bitcast {}* %"x::Array" to i64**
    %1 = load i64*, i64** %0, align 8
    %2 = load i64, i64* %1, align 8
; └└
;  @ iterators.jl:1559 within `only`
  ret i64 %2
}

julia> @code_llvm only((;x=3))
; Function Signature: only(NamedTuple{(:x,), Tuple{Int64}})
;  @ /Users/x/.julia/dev/julia/base/iterators.jl:1571 within `only`
define i64 @julia_only_6871([1 x i64]* nocapture noundef nonnull readonly align 8 dereferenceable(8) %"x::NamedTuple") #0 {
top:
; ┌ @ abstractarray.jl:469 within `first`
; │┌ @ namedtuple.jl:165 within `iterate` @ namedtuple.jl:165
    %"x::NamedTuple.x_ptr" = getelementptr inbounds [1 x i64], [1 x i64]* %"x::NamedTuple", i64 0, i64 0
; └└
  %"x::NamedTuple.x_ptr.unbox" = load i64, i64* %"x::NamedTuple.x_ptr", align 8
  ret i64 %"x::NamedTuple.x_ptr.unbox"
}

julia> only((;))
ERROR: ArgumentError: NamedTuple contains 0 elements, must contain exactly 1 element
Stacktrace:
 [1] only(x::@NamedTuple{})
   @ Base.Iterators ~/.julia/dev/julia/base/iterators.jl:1568
 [2] top-level scope
   @ REPL[34]:1

julia> only((;x=2, y=4))
ERROR: ArgumentError: NamedTuple contains 2 elements, must contain exactly 1 element
Stacktrace:
 [1] only(x::@NamedTuple{x::Int64, y::Int64})
   @ Base.Iterators ~/.julia/dev/julia/base/iterators.jl:1568
 [2] top-level scope
   @ REPL[35]:1
```
Diff
```diff
< # Before
---
> # After
4,5c4,5
< ;  @ iterators.jl:1563 within `only`
< define i64 @julia_only_2451({}* noundef nonnull align 8 dereferenceable(8) %"x::RefValue") #0 {
---
> ;  @ iterators.jl:1550 within `only`
> define i64 @julia_only_6821({}* noundef nonnull align 8 dereferenceable(8) %"x::RefValue") #0 {
7,11c7,14
< ; ┌ @ refvalue.jl:59 within `getindex`
< ; │┌ @ Base.jl:49 within `getproperty`
<     %0 = bitcast {}* %"x::RefValue" to i64*
<     %.x = load i64, i64* %0, align 8
< ; └└
---
> ;  @ iterators.jl:1551 within `only`
> ; ┌ @ refpointer.jl:103 within `iterate`
> ; │┌ @ refvalue.jl:59 within `getindex`
> ; ││┌ @ Base.jl:49 within `getproperty`
>      %0 = bitcast {}* %"x::RefValue" to i64*
>      %.x = load i64, i64* %0, align 8
> ; └└└
> ;  @ iterators.jl:1559 within `only`
17,18c20,21
< ;  @ iterators.jl:1563 within `only`
< define void @julia_only_2519({}* noundef nonnull %"x::RefValue") #0 {
---
> ;  @ iterators.jl:1550 within `only`
> define void @julia_only_6824({}* noundef nonnull %"x::RefValue") #0 {
19a23
> ;  @ iterators.jl:1559 within `only`
25,26c29,30
< ;  @ iterators.jl:1565 within `only`
< define i32 @julia_only_2527(i32 zeroext %"x::Char") #0 {
---
> ;  @ iterators.jl:1550 within `only`
> define i32 @julia_only_6826(i32 zeroext %"x::Char") #0 {
27a32
> ;  @ iterators.jl:1559 within `only`
33,34c38,39
< ;  @ iterators.jl:1566 within `only`
< define i64 @julia_only_2529([1 x i64]* nocapture noundef nonnull readonly align 8 dereferenceable(8) %"x::Tuple") #0 {
---
> ;  @ /Users/x/.julia/dev/julia/base/iterators.jl:1566 within `only`
> define i64 @julia_only_6833([1 x i64]* nocapture noundef nonnull readonly align 8 dereferenceable(8) %"x::Tuple") #0 {
45,46c50,51
< ;  @ iterators.jl:1566 within `only`
< define void @julia_only_2532() #0 {
---
> ;  @ /Users/x/.julia/dev/julia/base/iterators.jl:1566 within `only`
> define void @julia_only_6836() #0 {
55c60
<    @ Base.Iterators ./iterators.jl:1567
---
>    @ Base.Iterators ~/.julia/dev/julia/base/iterators.jl:1564
57c62
<    @ REPL[6]:1
---
>    @ REPL[31]:1
61,70c66,76
< ;  @ iterators.jl:1570 within `only`
< define i64 @julia_only_2779({}* noundef nonnull align 8 dereferenceable(16) %"a::Array") #0 {
< top:
< ; ┌ @ abstractarray.jl:1314 within `getindex`
< ; │┌ @ abstractarray.jl:1343 within `_getindex`
< ; ││┌ @ essentials.jl:817 within `getindex`
<      %0 = bitcast {}* %"a::Array" to i64**
<      %1 = load i64*, i64** %0, align 8
<      %2 = load i64, i64* %1, align 8
< ; └└└
---
> ;  @ iterators.jl:1550 within `only`
> define i64 @julia_only_6848({}* noundef nonnull align 8 dereferenceable(16) %"x::Array") #0 {
> L60:
> ;  @ iterators.jl:1551 within `only`
> ; ┌ @ array.jl:884 within `iterate` @ array.jl:884
> ; │┌ @ essentials.jl:817 within `getindex`
>     %0 = bitcast {}* %"x::Array" to i64**
>     %1 = load i64*, i64** %0, align 8
>     %2 = load i64, i64* %1, align 8
> ; └└
> ;  @ iterators.jl:1559 within `only`
76,77c82,83
< ;  @ iterators.jl:1571 within `only`
< define i64 @julia_only_2794([1 x i64]* nocapture noundef nonnull readonly align 8 dereferenceable(8) %"x::NamedTuple") #0 {
---
> ;  @ /Users/x/.julia/dev/julia/base/iterators.jl:1571 within `only`
> define i64 @julia_only_6871([1 x i64]* nocapture noundef nonnull readonly align 8 dereferenceable(8) %"x::NamedTuple") #0 {
91c97
<    @ Base.Iterators ./iterators.jl:1572
---
>    @ Base.Iterators ~/.julia/dev/julia/base/iterators.jl:1568
93c99
<    @ REPL[9]:1
---
>    @ REPL[34]:1
99c105
<    @ Base.Iterators ./iterators.jl:1572
---
>    @ Base.Iterators ~/.julia/dev/julia/base/iterators.jl:1568
101c107
<    @ REPL[10]:1
---
>    @ REPL[35]:1
```

---------

Co-authored-by: matthias314 <matthias314@posteo.net>
Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 base/iterators.jl | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/base/iterators.jl b/base/iterators.jl
index 24595d29ecc90..71099bb65d0b6 100644
--- a/base/iterators.jl
+++ b/base/iterators.jl
@@ -1559,15 +1559,11 @@ Stacktrace:
     return ret
 end
 
-# Collections of known size
-only(x::Ref) = x[]
-only(x::Number) = x
-only(x::Char) = x
+# Specific error messages for tuples and named tuples
 only(x::Tuple{Any}) = x[1]
 only(x::Tuple) = throw(
     ArgumentError("Tuple contains $(length(x)) elements, must contain exactly 1 element")
 )
-only(a::AbstractArray{<:Any, 0}) = @inbounds return a[]
 only(x::NamedTuple{<:Any, <:Tuple{Any}}) = first(x)
 only(x::NamedTuple) = throw(
     ArgumentError("NamedTuple contains $(length(x)) elements, must contain exactly 1 element")

From de525afa57ccc7bafa47c443b54710b47db3a61d Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 29 Nov 2023 02:38:41 +0900
Subject: [PATCH 0342/1315] extract common code to create a dummy `IRCode` into
 a utility function (#52329)

Simplifies test code.
xref:
<https://github.com/JuliaLang/julia/pull/52323#pullrequestreview-1751907258>.
---
 test/compiler/interpreter_exec.jl |  64 ++++++-------
 test/compiler/irpasses.jl         | 153 +++++++-----------------------
 test/compiler/irutils.jl          |  33 +++++++
 test/compiler/ssair.jl            |  45 +++++----
 4 files changed, 119 insertions(+), 176 deletions(-)

diff --git a/test/compiler/interpreter_exec.jl b/test/compiler/interpreter_exec.jl
index 17d0e4f7e7eac..ce0704be15178 100644
--- a/test/compiler/interpreter_exec.jl
+++ b/test/compiler/interpreter_exec.jl
@@ -2,22 +2,22 @@
 
 # tests that interpreter matches codegen
 using Test
-using Core: GotoIfNot, ReturnNode
+using Core.IR
 
 # test that interpreter correctly handles PhiNodes (#29262)
 let m = Meta.@lower 1 + 1
     @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::Core.CodeInfo
+    src = m.args[1]::CodeInfo
     src.code = Any[
         # block 1
         QuoteNode(:a),
         QuoteNode(:b),
         GlobalRef(@__MODULE__, :test29262),
-        GotoIfNot(Core.SSAValue(3), 6),
+        GotoIfNot(SSAValue(3), 6),
         # block 2
-        Core.PhiNode(Int32[4], Any[Core.SSAValue(1)]),
-        Core.PhiNode(Int32[4, 5], Any[Core.SSAValue(2), Core.SSAValue(5)]),
-        ReturnNode(Core.SSAValue(6)),
+        PhiNode(Int32[4], Any[SSAValue(1)]),
+        PhiNode(Int32[4, 5], Any[SSAValue(2), SSAValue(5)]),
+        ReturnNode(SSAValue(6)),
     ]
     nstmts = length(src.code)
     src.ssavaluetypes = Any[ Any for _ = 1:nstmts ]
@@ -33,7 +33,7 @@ end
 
 let m = Meta.@lower 1 + 1
     @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::Core.CodeInfo
+    src = m.args[1]::CodeInfo
     src.code = Any[
         # block 1
         QuoteNode(:a),
@@ -41,24 +41,24 @@ let m = Meta.@lower 1 + 1
         QuoteNode(:c),
         GlobalRef(@__MODULE__, :test29262),
         # block 2
-        Core.PhiNode(Int32[4, 16], Any[false, true]), # false, true
-        Core.PhiNode(Int32[4, 16], Any[Core.SSAValue(1), Core.SSAValue(2)]), # :a, :b
-        Core.PhiNode(Int32[4, 16], Any[Core.SSAValue(3), Core.SSAValue(6)]), # :c, :a
-        Core.PhiNode(Int32[16], Any[Core.SSAValue(7)]), # NULL, :c
+        PhiNode(Int32[4, 16], Any[false, true]), # false, true
+        PhiNode(Int32[4, 16], Any[SSAValue(1), SSAValue(2)]), # :a, :b
+        PhiNode(Int32[4, 16], Any[SSAValue(3), SSAValue(6)]), # :c, :a
+        PhiNode(Int32[16], Any[SSAValue(7)]), # NULL, :c
         # block 3
-        Core.PhiNode(Int32[], Any[]), # NULL, NULL
-        Core.PhiNode(Int32[17, 8], Any[true, Core.SSAValue(4)]), # test29262, test29262, [true]
-        Core.PhiNode(Int32[17], Vector{Any}(undef, 1)), # NULL, NULL
-        Core.PhiNode(Int32[8], Vector{Any}(undef, 1)), # NULL, NULL
-        Core.PhiNode(Int32[], Any[]), # NULL, NULL
-        Core.PhiNode(Int32[17, 8], Any[Core.SSAValue(2), Core.SSAValue(8)]), # NULL, :c, [:b]
-        Core.PhiNode(Int32[], Any[]), # NULL, NULL
-        GotoIfNot(Core.SSAValue(5), 5),
+        PhiNode(Int32[], Any[]), # NULL, NULL
+        PhiNode(Int32[17, 8], Any[true, SSAValue(4)]), # test29262, test29262, [true]
+        PhiNode(Int32[17], Vector{Any}(undef, 1)), # NULL, NULL
+        PhiNode(Int32[8], Vector{Any}(undef, 1)), # NULL, NULL
+        PhiNode(Int32[], Any[]), # NULL, NULL
+        PhiNode(Int32[17, 8], Any[SSAValue(2), SSAValue(8)]), # NULL, :c, [:b]
+        PhiNode(Int32[], Any[]), # NULL, NULL
+        GotoIfNot(SSAValue(5), 5),
         # block 4
-        GotoIfNot(Core.SSAValue(10), 9),
+        GotoIfNot(SSAValue(10), 9),
         # block 5
-        Expr(:call, GlobalRef(Core, :tuple), Core.SSAValue(6), Core.SSAValue(7), Core.SSAValue(8), Core.SSAValue(14)),
-        ReturnNode(Core.SSAValue(18)),
+        Expr(:call, GlobalRef(Core, :tuple), SSAValue(6), SSAValue(7), SSAValue(8), SSAValue(14)),
+        ReturnNode(SSAValue(18)),
     ]
     nstmts = length(src.code)
     src.ssavaluetypes = Any[ Any for _ = 1:nstmts ]
@@ -74,28 +74,28 @@ end
 
 let m = Meta.@lower 1 + 1
     @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::Core.CodeInfo
+    src = m.args[1]::CodeInfo
     src.code = Any[
         # block 1
         QuoteNode(:a),
         QuoteNode(:b),
         GlobalRef(@__MODULE__, :test29262),
         # block 2
-        Core.EnterNode(11),
+        EnterNode(11),
         # block 3
-        Core.UpsilonNode(),
-        Core.UpsilonNode(),
-        Core.UpsilonNode(Core.SSAValue(2)),
-        GotoIfNot(Core.SSAValue(3), 10),
+        UpsilonNode(),
+        UpsilonNode(),
+        UpsilonNode(SSAValue(2)),
+        GotoIfNot(SSAValue(3), 10),
         # block 4
-        Core.UpsilonNode(Core.SSAValue(1)),
+        UpsilonNode(SSAValue(1)),
         # block 5
         Expr(:throw_undef_if_not, :expected, false),
         # block 6
-        Core.PhiCNode(Any[Core.SSAValue(5), Core.SSAValue(7), Core.SSAValue(9)]), # NULL, :a, :b
-        Core.PhiCNode(Any[Core.SSAValue(6)]), # NULL
+        PhiCNode(Any[SSAValue(5), SSAValue(7), SSAValue(9)]), # NULL, :a, :b
+        PhiCNode(Any[SSAValue(6)]), # NULL
         # block 7
-        ReturnNode(Core.SSAValue(11)),
+        ReturnNode(SSAValue(11)),
     ]
     nstmts = length(src.code)
     src.ssavaluetypes = Any[ Any for _ = 1:nstmts ]
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 5b6df09bb93b4..f0c099d9cd2bd 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -10,10 +10,7 @@ include("irutils.jl")
 # =======
 
 ## Test that domsort doesn't mangle single-argument phis (#29262)
-let m = Meta.@lower 1 + 1
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+let code = Any[
         # block 1
         Expr(:call, :opaque),
         GotoIfNot(Core.SSAValue(1), 10),
@@ -31,12 +28,7 @@ let m = Meta.@lower 1 + 1
         Core.PhiNode(Int32[2, 8], Any[0, Core.SSAValue(7)]),
         ReturnNode(Core.SSAValue(10)),
     ]
-    nstmts = length(src.code)
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    ir = Core.Compiler.inflate_ir(src)
-    Core.Compiler.verify_ir(ir)
+    ir = make_ircode(code)
     domtree = Core.Compiler.construct_domtree(ir.cfg.blocks)
     ir = Core.Compiler.domsort_ssa!(ir, domtree)
     Core.Compiler.verify_ir(ir)
@@ -45,10 +37,7 @@ let m = Meta.@lower 1 + 1
 end
 
 # test that we don't stack-overflow in SNCA with large functions.
-let m = Meta.@lower 1 + 1
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    code = Any[]
+let code = Any[]
     N = 2^15
     for i in 1:2:N
         push!(code, Expr(:call, :opaque))
@@ -57,14 +46,7 @@ let m = Meta.@lower 1 + 1
     # all goto here
     push!(code, Expr(:call, :opaque))
     push!(code, ReturnNode(nothing))
-    src.code = code
-
-    nstmts = length(src.code)
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    ir = Core.Compiler.inflate_ir(src)
-    Core.Compiler.verify_ir(ir)
+    ir = make_ircode(code)
     domtree = Core.Compiler.construct_domtree(ir.cfg.blocks)
     ir = Core.Compiler.domsort_ssa!(ir, domtree)
     Core.Compiler.verify_ir(ir)
@@ -73,7 +55,7 @@ end
 # SROA
 # ====
 
-import Core.Compiler: widenconst
+using Core.Compiler: widenconst
 
 is_load_forwarded(src::CodeInfo) = !any(iscall((src, getfield)), src.code)
 is_scalar_replaced(src::CodeInfo) =
@@ -695,10 +677,7 @@ end
 @test fully_eliminated(f_partial, Tuple{Float64})
 
 # A SSAValue after the compaction line
-let m = Meta.@lower 1 + 1
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+let code = Any[
         # block 1
         nothing,
         # block 2
@@ -717,7 +696,7 @@ let m = Meta.@lower 1 + 1
         # block 5
         ReturnNode(Core.SSAValue(2)),
     ]
-    src.ssavaluetypes = Any[
+    ssavaluetypes = Any[
         Nothing,
         Any,
         Bool,
@@ -730,21 +709,14 @@ let m = Meta.@lower 1 + 1
         Any,
         Any
     ]
-    nstmts = length(src.code)
-    src.codelocs = fill(one(Int32), nstmts)
-    src.ssaflags = fill(one(Int32), nstmts)
-    src.slotflags = fill(zero(UInt8), 3)
-    ir = Core.Compiler.inflate_ir(src)
-    @test Core.Compiler.verify_ir(ir) === nothing
+    slottypes = Any[Any, Any, Any]
+    ir = make_ircode(code; ssavaluetypes, slottypes)
     ir = @test_nowarn Core.Compiler.sroa_pass!(ir)
     @test Core.Compiler.verify_ir(ir) === nothing
 end
 
 # A lifted Core.ifelse with an eliminated branch (#50276)
-let m = Meta.@lower 1 + 1
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+let code = Any[
         # block 1
         #=  %1: =# Core.Argument(2),
         # block 2
@@ -768,7 +740,7 @@ let m = Meta.@lower 1 + 1
         # block 5
         #= %11: =# ReturnNode(false),
     ]
-    src.ssavaluetypes = Any[
+    ssavaluetypes = Any[
         Any,
         Union{Missing, Bool},
         Any,
@@ -781,12 +753,8 @@ let m = Meta.@lower 1 + 1
         Any,
         Any
     ]
-    nstmts = length(src.code)
-    src.codelocs = fill(one(Int32), nstmts)
-    src.ssaflags = fill(one(Int32), nstmts)
-    src.slotflags = fill(zero(UInt8), 3)
-    ir = Core.Compiler.inflate_ir(src)
-    @test Core.Compiler.verify_ir(ir) === nothing
+    slottypes = Any[Any, Any, Any]
+    ir = make_ircode(code; ssavaluetypes, slottypes)
     ir = @test_nowarn Core.Compiler.sroa_pass!(ir)
     @test Core.Compiler.verify_ir(ir) === nothing
 end
@@ -809,11 +777,8 @@ let src = code_typed(gcd, Tuple{Int, Int})[1].first
     Core.Compiler.verify_ir(ir)
 end
 
-let m = Meta.@lower 1 + 1
-    # Test that CFG simplify combines redundant basic blocks
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+let # Test that CFG simplify combines redundant basic blocks
+    code = Any[
         Core.Compiler.GotoNode(2),
         Core.Compiler.GotoNode(3),
         Core.Compiler.GotoNode(4),
@@ -822,12 +787,7 @@ let m = Meta.@lower 1 + 1
         Core.Compiler.GotoNode(7),
         ReturnNode(2)
     ]
-    nstmts = length(src.code)
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    ir = Core.Compiler.inflate_ir(src)
-    Core.Compiler.verify_ir(ir)
+    ir = make_ircode(code)
     ir = Core.Compiler.cfg_simplify!(ir)
     Core.Compiler.verify_ir(ir)
     ir = Core.Compiler.compact!(ir)
@@ -923,11 +883,8 @@ let stmts = [
     @test Set(term.val for term in terms if isa(term, ReturnNode)) == Set([1,2])
 end
 
-let m = Meta.@lower 1 + 1
-    # Test that CFG simplify doesn't mess up when chaining past return blocks
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+let # Test that CFG simplify doesn't mess up when chaining past return blocks
+    code = Any[
         Core.Compiler.GotoIfNot(Core.Compiler.Argument(2), 3),
         Core.Compiler.GotoNode(4),
         ReturnNode(1),
@@ -939,12 +896,7 @@ let m = Meta.@lower 1 + 1
         ReturnNode(2),
         ReturnNode(3)
     ]
-    nstmts = length(src.code)
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    ir = Core.Compiler.inflate_ir(src)
-    Core.Compiler.verify_ir(ir)
+    ir = make_ircode(code)
     ir = Core.Compiler.cfg_simplify!(ir)
     Core.Compiler.verify_ir(ir)
     @test length(ir.cfg.blocks) == 5
@@ -952,12 +904,9 @@ let m = Meta.@lower 1 + 1
     @test isa(ret_2, Core.Compiler.ReturnNode) && ret_2.val == 2
 end
 
-let m = Meta.@lower 1 + 1
-    # Test that CFG simplify doesn't try to merge every block in a loop into
+let # Test that CFG simplify doesn't try to merge every block in a loop into
     # its predecessor
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+    code = Any[
         # Block 1
         Core.Compiler.GotoNode(2),
         # Block 2
@@ -965,12 +914,7 @@ let m = Meta.@lower 1 + 1
         # Block 3
         Core.Compiler.GotoNode(1)
     ]
-    nstmts = length(src.code)
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    ir = Core.Compiler.inflate_ir(src)
-    Core.Compiler.verify_ir(ir)
+    ir = make_ircode(code)
     ir = Core.Compiler.cfg_simplify!(ir)
     Core.Compiler.verify_ir(ir)
     @test length(ir.cfg.blocks) == 1
@@ -1522,10 +1466,7 @@ end
 @test isnothing(f_with_early_try_catch_exit())
 
 # Issue #51144 - UndefRefError during compaction
-let m = Meta.@lower 1 + 1
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+let code = Any[
         # block 1  → 2, 3
         #=  %1: =# Expr(:(=), Core.SlotNumber(4), Core.Argument(2)),
         #=  %2: =# Expr(:call, :(===), Core.SlotNumber(4), nothing),
@@ -1540,14 +1481,8 @@ let m = Meta.@lower 1 + 1
         # block 5
         #=  %8: =# ReturnNode(nothing), # Must not insert a π-node here
     ]
-    nstmts = length(src.code)
-    nslots = 4
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    src.slotflags = fill(0, nslots)
-    src.slottypes = Any[Any, Union{Bool, Nothing}, Bool, Union{Bool, Nothing}]
-    ir = Core.Compiler.inflate_ir(src)
+    slottypes = Any[Any, Union{Bool, Nothing}, Bool, Union{Bool, Nothing}]
+    src = make_codeinfo(code; slottypes)
 
     mi = ccall(:jl_new_method_instance_uninit, Ref{Core.MethodInstance}, ());
     mi.specTypes = Tuple{}
@@ -1585,12 +1520,9 @@ let (ir, _) = only(Base.code_ircode(f_with_merge_to_entry_block))
 end
 
 # Test that CFG simplify doesn't leave an un-renamed SSA Value
-let m = Meta.@lower 1 + 1
-    # Test that CFG simplify doesn't try to merge every block in a loop into
+let # Test that CFG simplify doesn't try to merge every block in a loop into
     # its predecessor
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+    code = Any[
         # Block 1
         GotoIfNot(Argument(1), 3),
         # Block 2
@@ -1604,12 +1536,7 @@ let m = Meta.@lower 1 + 1
         PhiNode(Int32[4, 5], Any[SSAValue(3), SSAValue(5)]),
         ReturnNode(1)
     ]
-    nstmts = length(src.code)
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    ir = Core.Compiler.inflate_ir(src)
-    Core.Compiler.verify_ir(ir)
+    ir = make_ircode(code)
     ir = Core.Compiler.cfg_simplify!(ir)
     Core.Compiler.verify_ir(ir)
     @test length(ir.cfg.blocks) == 4
@@ -1628,10 +1555,7 @@ end
 @test code_typed(persistent_dict_elim)[1][1].code[end] == Core.ReturnNode(1)
 
 # Test CFG simplify with try/catch blocks
-let m = Meta.@lower 1 + 1
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+let code = Any[
         # Block 1
         GotoIfNot(Argument(1), 5),
         # Block 2
@@ -1643,22 +1567,14 @@ let m = Meta.@lower 1 + 1
         # Block 5
         ReturnNode(1)
     ]
-    nstmts = length(src.code)
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    ir = Core.Compiler.inflate_ir(src)
-    Core.Compiler.verify_ir(ir)
+    ir = make_ircode(code)
     ir = Core.Compiler.cfg_simplify!(ir)
     Core.Compiler.verify_ir(ir)
     @test length(ir.cfg.blocks) == 4
 end
 
 # Test CFG simplify with single predecessor phi node
-let m = Meta.@lower 1 + 1
-    @assert Meta.isexpr(m, :thunk)
-    src = m.args[1]::CodeInfo
-    src.code = Any[
+let code = Any[
         # Block 1
         Expr(:call, Base.inferencebarrier, 1),
         GotoNode(3),
@@ -1666,12 +1582,7 @@ let m = Meta.@lower 1 + 1
         PhiNode(Int32[1], Any[SSAValue(1)]),
         ReturnNode(SSAValue(3))
     ]
-    nstmts = length(src.code)
-    src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
-    src.ssaflags = fill(Int32(0), nstmts)
-    ir = Core.Compiler.inflate_ir(src)
-    Core.Compiler.verify_ir(ir)
+    ir = make_ircode(code)
     ir = Core.Compiler.cfg_simplify!(ir)
     Core.Compiler.verify_ir(ir)
     @test length(ir.cfg.blocks) == 1
diff --git a/test/compiler/irutils.jl b/test/compiler/irutils.jl
index 72ea8a6ba0636..788d7bbc721ee 100644
--- a/test/compiler/irutils.jl
+++ b/test/compiler/irutils.jl
@@ -56,3 +56,36 @@ end
 macro fully_eliminated(ex0...)
     return gen_call_with_extracted_types_and_kwargs(__module__, :fully_eliminated, ex0)
 end
+
+let m = Meta.@lower 1 + 1
+    @assert Meta.isexpr(m, :thunk)
+    orig_src = m.args[1]::CodeInfo
+    global function make_codeinfo(code::Vector{Any};
+                                  ssavaluetypes::Union{Nothing,Vector{Any}}=nothing,
+                                  slottypes::Union{Nothing,Vector{Any}}=nothing)
+        src = copy(orig_src)
+        src.code = code
+        nstmts = length(src.code)
+        if ssavaluetypes === nothing
+            src.ssavaluetypes = nstmts
+        else
+            src.ssavaluetypes = ssavaluetypes
+        end
+        src.codelocs = fill(one(Int32), nstmts)
+        src.ssaflags = fill(zero(UInt32), nstmts)
+        if slottypes !== nothing
+            src.slottypes = slottypes
+            src.slotflags = fill(zero(UInt8), length(slottypes))
+        end
+        return src
+    end
+    global function make_ircode(code::Vector{Any};
+                                ssavaluetypes::Union{Nothing,Vector{Any}}=nothing,
+                                slottypes::Union{Nothing,Vector{Any}}=nothing,
+                                verify::Bool=true)
+        src = make_codeinfo(code; ssavaluetypes, slottypes)
+        ir = Core.Compiler.inflate_ir(src)
+        verify && Core.Compiler.verify_ir(ir)
+        return ir
+    end
+end
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 5f9441eb9ead8..d72a9bce8bc90 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -143,7 +143,7 @@ end
 @test f32579(0, false) === false
 
 # Test for bug caused by renaming blocks improperly, related to PR #32145
-let ci = make_ci([
+let code = Any[
         # block 1
         Expr(:boundscheck),
         Core.Compiler.GotoIfNot(SSAValue(1), 6),
@@ -162,34 +162,34 @@ let ci = make_ci([
         Core.Compiler.ReturnNode(Core.SSAValue(9)),
         # block 6
         Core.Compiler.ReturnNode(Core.SSAValue(9))
-    ])
-    ir = Core.Compiler.inflate_ir(ci)
+    ]
+    ir = make_ircode(code)
     ir = Core.Compiler.compact!(ir, true)
     @test Core.Compiler.verify_ir(ir) === nothing
 end
 
 # Test that the verifier doesn't choke on cglobals (which aren't linearized)
-let ci = make_ci([
+let code = Any[
         Expr(:call, GlobalRef(Main, :cglobal),
                     Expr(:call, Core.tuple, :(:c)), Nothing),
                     Core.Compiler.ReturnNode()
-    ])
-    ir = Core.Compiler.inflate_ir(ci)
+    ]
+    ir = make_ircode(code)
     @test Core.Compiler.verify_ir(ir) === nothing
 end
 
 # Test that GlobalRef in value position is non-canonical
-let ci = make_ci([
+let code = Any[
         Expr(:call, GlobalRef(Main, :something_not_defined_please))
         ReturnNode(SSAValue(1))
-    ])
-    ir = Core.Compiler.inflate_ir(ci)
+    ]
+    ir = make_ircode(code; verify=false)
     ir = Core.Compiler.compact!(ir, true)
     @test_throws ErrorException Core.Compiler.verify_ir(ir, false)
 end
 
 # Issue #29107
-let ci = make_ci([
+let code = Any[
         # Block 1
         Core.Compiler.GotoNode(6),
         # Block 2
@@ -204,8 +204,8 @@ let ci = make_ci([
         Core.Compiler.GotoNode(2),
         # Block 3
         Core.Compiler.ReturnNode(1000)
-    ])
-    ir = Core.Compiler.inflate_ir(ci)
+    ]
+    ir = make_ircode(code)
     ir = Core.Compiler.compact!(ir, true)
     # Make sure that if there is a call to `something` (block 2 should be
     # removed entirely with working DCE), it doesn't use any SSA values that
@@ -220,9 +220,8 @@ let ci = make_ci([
     end
 end
 
-# Make sure dead blocks that are removed are not still referenced in live phi
-# nodes
-let ci = make_ci([
+# Make sure dead blocks that are removed are not still referenced in live phi nodes
+let code = Any[
         # Block 1
         Core.Compiler.GotoNode(3),
         # Block 2 (no predecessors)
@@ -230,8 +229,8 @@ let ci = make_ci([
         # Block 3
         Core.PhiNode(Int32[1, 2], Any[100, 200]),
         Core.Compiler.ReturnNode(Core.SSAValue(3))
-    ])
-    ir = Core.Compiler.inflate_ir(ci)
+    ]
+    ir = make_ircode(code; verify=false)
     ir = Core.Compiler.compact!(ir, true)
     @test Core.Compiler.verify_ir(ir) == nothing
 end
@@ -568,7 +567,7 @@ let ir = Base.code_ircode((Int,Int); optimize_until="inlining") do a, b
 end
 
 # Issue #50379 - insert_node!(::IncrementalCompact, ...) at end of basic block
-let ci = make_ci([
+let code = Any[
         # block 1
         #= %1: =# Expr(:boundscheck),
         #= %2: =# Core.Compiler.GotoIfNot(SSAValue(1), 4),
@@ -577,8 +576,8 @@ let ci = make_ci([
         # block 3
         #= %4: =# Core.PhiNode(),
         #= %5: =# Core.Compiler.ReturnNode(),
-    ])
-    ir = Core.Compiler.inflate_ir(ci)
+    ]
+    ir = make_ircode(code)
 
     # Insert another call at end of "block 2"
     compact = Core.Compiler.IncrementalCompact(ir)
@@ -596,11 +595,11 @@ let ci = make_ci([
 end
 
 # compact constant PiNode
-let ci = make_ci(Any[
+let code = Any[
         PiNode(0.0, Const(0.0))
         ReturnNode(SSAValue(1))
-    ])
-    ir = Core.Compiler.inflate_ir(ci)
+    ]
+    ir = make_ircode(code)
     ir = Core.Compiler.compact!(ir)
     @test fully_eliminated(ir)
 end

From 9bd2432d1869c63ec91568d7e4610a9d842e104a Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 29 Nov 2023 00:06:41 -0500
Subject: [PATCH 0343/1315] cfg_simplify: Fix bug in my bugfix (#52337)

The fix in #52323 was not quite correct. Fix that and adjust the test to
more accurately reflect the actual issue.
---
 base/compiler/ssair/passes.jl |  4 ++--
 test/compiler/irpasses.jl     | 16 ++++++++++------
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 3b8e5494db33e..b90a90f178d3a 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -2336,9 +2336,9 @@ function cfg_simplify!(ir::IRCode)
                             end
                         elseif new_edge == -1
                             @assert length(phi.edges) == 1
-                            if isassigned(phi.values, old_index)
+                            if isassigned(renamed_values, old_index)
                                 push!(edges, -1)
-                                push!(values, phi.values[old_index])
+                                push!(values, renamed_values[old_index])
                             end
                         elseif new_edge == -3
                             # Multiple predecessors, we need to expand out this phi
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index f0c099d9cd2bd..6d17f9f3d0a88 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1576,17 +1576,21 @@ end
 # Test CFG simplify with single predecessor phi node
 let code = Any[
         # Block 1
-        Expr(:call, Base.inferencebarrier, 1),
         GotoNode(3),
         # Block 2
-        PhiNode(Int32[1], Any[SSAValue(1)]),
-        ReturnNode(SSAValue(3))
+        nothing,
+        # Block 3
+        Expr(:call, Base.inferencebarrier, 1),
+        GotoNode(5),
+        # Block 4
+        PhiNode(Int32[4], Any[SSAValue(3)]),
+        ReturnNode(SSAValue(5))
     ]
     ir = make_ircode(code)
     ir = Core.Compiler.cfg_simplify!(ir)
     Core.Compiler.verify_ir(ir)
-    @test length(ir.cfg.blocks) == 1
+    @test length(ir.cfg.blocks) <= 2
     ir = Core.Compiler.compact!(ir)
-    @test length(ir.stmts) == 2
-    @test (ir[SSAValue(2)][:stmt]::ReturnNode).val == SSAValue(1)
+    @test length(ir.stmts) <= 3
+    @test (ir[SSAValue(length(ir.stmts))][:stmt]::ReturnNode).val !== nothing
 end

From fd67cb2ab0fe5c41d2e12d6aae0396d493a72b71 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Wed, 29 Nov 2023 16:13:04 -0500
Subject: [PATCH 0344/1315] incorporate upstream fixes to crc32c.c assembly
 (#52326)

These are a response to
[this comment](https://stackoverflow.com/questions/17645167/implementing-sse-4-2s-crc32c-in-software/17646775#comment88832559_17646775)
on StackOverflow:

> Your asm constraints aren't strictly safe. A pointer in a `"r"`
constraint does not imply that the pointed-to memory is also an input.
You could just use memory operands (or the `_mm_crc32_u64` intrinsic),
but if you want to force the addressing mode you can use a dummy memory
operand like `asm("crc32 (%1),%0 " : "+r"(crc0) : "r"(next), "m"
(*(const char (*)[24]) pStr) )`;. Inlining or LTO could break this. See
[at&t asm inline c++
problem](https://stackoverflow.com/posts/comments/81680441) (which needs
an update: pointer-to-array is cleaner than a struct with a flexible
array member).

The existing test coverage wasn't enough to fully exercise Adler's code,
so I added another test.

Closes #52325
---
 src/crc32c.c                   | 39 ++++++++++++++++++++--------------
 stdlib/CRC32c/test/runtests.jl |  9 ++++++++
 2 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/src/crc32c.c b/src/crc32c.c
index 4ca8db06459a1..844a6e34156e6 100644
--- a/src/crc32c.c
+++ b/src/crc32c.c
@@ -1,6 +1,6 @@
 /* crc32c.c -- compute CRC-32C using software table or available hardware instructions
- * Copyright (C) 2013 Mark Adler
- * Version 1.1  1 Aug 2013  Mark Adler
+ * Copyright (C) 2013, 2021 Mark Adler
+ * Version 1.1  1 Aug 2013  Mark Adler, updates from Version 1.2 5 June 2021
  *
  * Code retrieved in August 2016 from August 2013 post by Mark Adler on
  *    http://stackoverflow.com/questions/17645167/implementing-sse-4-2s-crc32c-in-software
@@ -10,6 +10,7 @@
  *    - architecture and compiler detection
  *    - precompute crc32c tables and store in a generated .c file
  *    - ARMv8 support
+ * Updated to incorporate upstream 2021 patch by Mark Adler to register constraints.
  */
 
 /*
@@ -39,6 +40,8 @@
 /* Version history:
    1.0  10 Feb 2013  First version
    1.1   1 Aug 2013  Correct comments on why three crc instructions in parallel
+   1.2   5 Jun 2021  Correct register constraints on assembly instructions
+                     (+ other changes that were superfluous for us)
 */
 
 #include "julia.h"
@@ -98,16 +101,14 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
        to an eight-byte boundary */
     while (len && ((uintptr_t)buf & 7) != 0) {
         __asm__("crc32b\t" "(%1), %0"
-                : "=r"(crc0)
-                : "r"(buf), "0"(crc0));
+                : "+r"(crc0)
+                : "r"(buf), "m"(*buf));
         buf++;
         len--;
     }
 
-    /* compute the crc on sets of LONG*3 bytes, executing three independent crc
-       instructions, each on LONG bytes -- this is optimized for the Nehalem,
-       Westmere, Sandy Bridge, and Ivy Bridge architectures, which have a
-       throughput of one crc per cycle, but a latency of three cycles */
+    /* compute the crc on sets of LONG*3 bytes,
+       making use of three ALUs in parallel on a single core. */
     while (len >= LONG * 3) {
         uintptr_t crc1 = 0;
         uintptr_t crc2 = 0;
@@ -116,8 +117,11 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
             __asm__(CRC32_PTR "\t" "(%3), %0\n\t"
                     CRC32_PTR "\t" LONGx1 "(%3), %1\n\t"
                     CRC32_PTR "\t" LONGx2 "(%3), %2"
-                    : "=r"(crc0), "=r"(crc1), "=r"(crc2)
-                    : "r"(buf), "0"(crc0), "1"(crc1), "2"(crc2));
+                    : "+r"(crc0), "+r"(crc1), "+r"(crc2)
+                    : "r"(buf),
+                      "m"(* (const char (*)[sizeof(void*)]) &buf[0]),
+                      "m"(* (const char (*)[sizeof(void*)]) &buf[LONG]),
+                      "m"(* (const char (*)[sizeof(void*)]) &buf[LONG*2]));
             buf += sizeof(void*);
         } while (buf < end);
         crc0 = crc32c_shift(crc32c_long, crc0) ^ crc1;
@@ -136,8 +140,11 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
             __asm__(CRC32_PTR "\t" "(%3), %0\n\t"
                     CRC32_PTR "\t" SHORTx1 "(%3), %1\n\t"
                     CRC32_PTR "\t" SHORTx2 "(%3), %2"
-                    : "=r"(crc0), "=r"(crc1), "=r"(crc2)
-                    : "r"(buf), "0"(crc0), "1"(crc1), "2"(crc2));
+                    : "+r"(crc0), "+r"(crc1), "+r"(crc2)
+                    : "r"(buf),
+                      "m"(* (const char (*)[sizeof(void*)]) &buf[0]),
+                      "m"(* (const char (*)[sizeof(void*)]) &buf[SHORT]),
+                      "m"(* (const char (*)[sizeof(void*)]) &buf[SHORT*2]));
             buf += sizeof(void*);
         } while (buf < end);
         crc0 = crc32c_shift(crc32c_short, crc0) ^ crc1;
@@ -151,8 +158,8 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
     const char *end = buf + (len - (len & 7));
     while (buf < end) {
         __asm__(CRC32_PTR "\t" "(%1), %0"
-                : "=r"(crc0)
-                : "r"(buf), "0"(crc0));
+                : "+r"(crc0)
+                : "r"(buf), "m"(* (const char (*)[sizeof(void*)]) buf));
         buf += sizeof(void*);
     }
     len &= 7;
@@ -160,8 +167,8 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
     /* compute the crc for up to seven trailing bytes */
     while (len) {
         __asm__("crc32b\t" "(%1), %0"
-                : "=r"(crc0)
-                : "r"(buf), "0"(crc0));
+                : "+r"(crc0)
+                : "r"(buf), "m"(*buf));
         buf++;
         len--;
     }
diff --git a/stdlib/CRC32c/test/runtests.jl b/stdlib/CRC32c/test/runtests.jl
index e9e933ee2451c..41a7ea2ab62fa 100644
--- a/stdlib/CRC32c/test/runtests.jl
+++ b/stdlib/CRC32c/test/runtests.jl
@@ -45,6 +45,15 @@ function test_crc32c(crc32c)
             rm(f, force=true)
         end
     end
+
+    # test longer arrays to cover all the code paths in crc32c.c
+    LONG = 8192 # from crc32c.c
+    SHORT = 256 # from crc32c.c
+    n = LONG*3+SHORT*3+SHORT*2+64+7
+    big = vcat(reinterpret(UInt8, hton.(0x74d7f887 .^ (1:n÷4))), UInt8[1:n%4;])
+    for (offset,crc) in [(0, 0x13a5ecd5), (1, 0xecf34b7e), (2, 0xfa71b596), (3, 0xbfd24745), (4, 0xf0cb3370), (5, 0xb0ec88b5), (6, 0x258c20a8), (7, 0xa9bd638d)]
+        @test crc == crc32c(@view big[1+offset:end])
+    end
 end
 unsafe_crc32c_sw(a, n, crc) =
     ccall(:jl_crc32c_sw, UInt32, (UInt32, Ptr{UInt8}, Csize_t), crc, a, n)

From bac3ba5697c21cfc5058dfdb85a829e756ba9c68 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 29 Nov 2023 22:12:47 -0500
Subject: [PATCH 0345/1315] Fix oracle count violation in sroa_pass! (#52336)

---
 base/compiler/ssair/ir.jl     | 11 +++++------
 base/compiler/ssair/passes.jl |  3 +--
 test/compiler/irpasses.jl     | 21 +++++++++++++++++++++
 3 files changed, 27 insertions(+), 8 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index fb1219803b1fe..dc19c9a09fbba 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1003,14 +1003,13 @@ function kill_current_uses!(compact::IncrementalCompact, @nospecialize(stmt))
     end
 end
 
-function setindex!(compact::IncrementalCompact, @nospecialize(v), idx::SSAValue)
-    @assert idx.id < compact.result_idx
-    (compact.result[idx.id][:stmt] === v) && return compact
+function setindex!(compact::IncrementalCompact, @nospecialize(v), ssa::Union{SSAValue, NewSSAValue})
+    (compact[ssa][:stmt] === v) && return compact
     # Kill count for current uses
-    kill_current_uses!(compact, compact.result[idx.id][:stmt])
-    compact.result[idx.id][:stmt] = v
+    kill_current_uses!(compact, compact[ssa][:stmt])
+    compact[ssa][:stmt] = v
     # Add count for new use
-    count_added_node!(compact, v) && push!(compact.late_fixup, idx.id)
+    count_added_node!(compact, v) && isa(ssa, SSAValue) && push!(compact.late_fixup, ssa.id)
     return compact
 end
 
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index b90a90f178d3a..944e444bf6d06 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -762,8 +762,7 @@ function perform_lifting!(compact::IncrementalCompact,
                 only_result = (then_result === SKIP_TOKEN) ? else_result : then_result
 
                 # Replace Core.ifelse(%cond, %a, %b) with %a
-                compact[lf.ssa][:stmt] = only_result
-                should_count && _count_added_node!(compact, only_result)
+                compact[lf.ssa] = only_result
 
                 # Note: Core.ifelse(%cond, %a, %b) has observable effects (!nothrow), but since
                 # we have not deleted the preceding statement that this was derived from, this
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 6d17f9f3d0a88..8dbae2dca9649 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1594,3 +1594,24 @@ let code = Any[
     @test length(ir.stmts) <= 3
     @test (ir[SSAValue(length(ir.stmts))][:stmt]::ReturnNode).val !== nothing
 end
+
+let code = Any[
+    Expr(:call, Base.inferencebarrier, Argument(1)), # ::Bool
+    Expr(:call, Core.tuple, 1), # ::Tuple{Int}
+    Expr(:call, Core.tuple, 1.0), # ::Tuple{Float64}
+    Expr(:call, Core.ifelse, SSAValue(1), SSAValue(2), SSAValue(3)), # ::Tuple{Int} (e.g. from inlining)
+    Expr(:call, Core.getfield, SSAValue(4), 1), # ::Int
+    ReturnNode(SSAValue(5))
+]
+    try
+        argtypes = Any[Bool]
+        ssavaluetypes = Any[Bool, Tuple{Int}, Tuple{Float64}, Tuple{Int}, Int, Any]
+        ir = make_ircode(code; slottypes=argtypes, ssavaluetypes)
+        Core.Compiler.verify_ir(ir)
+        Core.Compiler.__set_check_ssa_counts(true)
+        ir = Core.Compiler.sroa_pass!(ir)
+        Core.Compiler.verify_ir(ir)
+    finally
+        Core.Compiler.__set_check_ssa_counts(false)
+    end
+end

From 58c1d51e1fc5bf956059340d9e63bdaff0dfff7f Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 1 Dec 2023 09:12:35 +0900
Subject: [PATCH 0346/1315] [REPLCompletions] fix #52099 by adjusting effects
 of `HAMT` methods (#52331)

After looking into #52099, I discovered that it has the same root cause
as #51548. Essentially, when a method that's not `!effect_free` is
applied to a `Const` value concretized by the `REPLInterpreter`'s
aggressive inference, since the `!effect_free` method will not be
concretized, it will eventually lead to the `Const` representing
unexpected object being returned.

This commit tries to fix the specific problem reported in #52099 by
enhancing the effects of `Base.HAMT` methods, so they're
concrete-evaled.

Admittedly, this is more of a quick fix than a complete solution, and
not the best one, but it was the simplest. A better solution might
involve implementing EA's handling of `Memory`-objects that allows the
compiler to automatically prove `:effect_free` in more scenarios. But
this would need a bigger overhaul, so I plan to tackle it in another PR.
---
 base/compiler/optimize.jl           |  4 ++--
 base/hamt.jl                        | 10 +++++-----
 stdlib/REPL/test/replcompletions.jl |  8 ++++++++
 test/dict.jl                        |  3 +++
 4 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 54a3823cd2f26..fe8e8d0580bcb 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -698,7 +698,7 @@ function scan_non_dataflow_flags!(inst::Instruction, sv::PostOptAnalysisState)
     flag = inst[:flag]
     # If we can prove that the argmem does not escape the current function, we can
     # refine this to :effect_free.
-    needs_ea_validation = (flag & IR_FLAGS_NEEDS_EA) == IR_FLAGS_NEEDS_EA
+    needs_ea_validation = has_flag(flag, IR_FLAGS_NEEDS_EA)
     stmt = inst[:stmt]
     if !needs_ea_validation
         if !isterminator(stmt) && stmt !== nothing
@@ -730,7 +730,7 @@ end
 
 function scan_inconsistency!(inst::Instruction, sv::PostOptAnalysisState)
     flag = inst[:flag]
-    stmt_inconsistent = iszero(flag & IR_FLAG_CONSISTENT)
+    stmt_inconsistent = !has_flag(flag, IR_FLAG_CONSISTENT)
     stmt = inst[:stmt]
     # Special case: For `getfield` and memory operations, we allow inconsistency of the :boundscheck argument
     (; inconsistent, tpdum) = sv
diff --git a/base/hamt.jl b/base/hamt.jl
index fc298b8b7a338..b8bf60cb22afb 100644
--- a/base/hamt.jl
+++ b/base/hamt.jl
@@ -66,21 +66,21 @@ mutable struct HAMT{K, V}
     HAMT{K, V}() where {K, V} = new{K,V}(Vector{Union{Leaf{K, V}, HAMT{K, V}}}(undef, 0), zero(BITMAP))
 end
 
-@Base.assume_effects :nothrow function init_hamt(K, V, k, v)
-    # For a single element we can't have a hash-collision
+Base.@assume_effects :nothrow :effect_free function init_hamt(K, V, k, v)
+    # For a single element we can't have a 'hash-collision
     trie = HAMT{K,V}(Vector{Union{Leaf{K, V}, HAMT{K, V}}}(undef, 1), zero(BITMAP))
     trie.data[1] = Leaf{K,V}(k,v)
     return trie
 end
 
-function HAMT{K,V}((k,v)::Pair) where {K, V}
-    k = convert(K, k)
-    v = convert(V, v)
+Base.@assume_effects :effect_free function HAMT{K,V}((k,v)::Pair{K,V}) where {K, V}
     trie = init_hamt(K, V, k, v)
     bi = BitmapIndex(HashState(k))
     set!(trie, bi)
     return trie
 end
+HAMT{K,V}(kv::Pair) where {K, V} = HAMT{K,V}(convert(Pair{K,V}, kv))
+
 HAMT(pair::Pair{K,V}) where {K, V} = HAMT{K,V}(pair)
 
 # TODO: Parameterize by hash function
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 868457d6514cd..4ee9761524741 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2148,3 +2148,11 @@ end
 let t = REPLCompletions.repl_eval_ex(:(unsafe_method(42)), @__MODULE__)
     @test isnothing(t)
 end
+
+# https://github.com/JuliaLang/julia/issues/52099
+const issue52099 = []
+let t = REPLCompletions.repl_eval_ex(:(Base.PersistentDict(issue52099 => 3)), @__MODULE__)
+    if t isa Core.Const
+        @test length(t.val) == 1
+    end
+end
diff --git a/test/dict.jl b/test/dict.jl
index d5ae88735dd43..f00c7c4747672 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -1107,6 +1107,9 @@ import Base.PersistentDict
         @test hs.hash == hsr.hash
         @test hs.depth == hsr.depth
         @test hs.shift == hsr.shift
+
+        @test Core.Compiler.is_removable_if_unused(Base.infer_effects(Base.HAMT.init_hamt, (Type{Vector{Any}},Type{Int},Vector{Any},Int)))
+        @test Core.Compiler.is_removable_if_unused(Base.infer_effects(Base.HAMT.HAMT{Vector{Any},Int}, (Pair{Vector{Any},Int},)))
     end
     @testset "basics" begin
         dict = PersistentDict{Int, Int}()

From aef528d32a6291ce82452c3a1ff1fa56ccf17641 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 1 Dec 2023 00:51:11 -0300
Subject: [PATCH 0347/1315] nfc: remove duplicate variable declaration (#52360)

---
 src/gc.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 38cebf151493d..bf5364aaa286d 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1422,8 +1422,6 @@ int jl_gc_classify_pools(size_t sz, int *osize)
 
 gc_fragmentation_stat_t gc_page_fragmentation_stats[JL_GC_N_POOLS];
 
-extern gc_fragmentation_stat_t gc_page_fragmentation_stats[JL_GC_N_POOLS];
-
 STATIC_INLINE void gc_update_page_fragmentation_data(jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT
 {
 #ifdef GC_MEASURE_PAGE_FRAGMENTATION

From 641f717a15cf89964db446c1bb32d0d672763786 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sat, 2 Dec 2023 09:36:18 -0500
Subject: [PATCH 0348/1315] make custom log macros work (#52359)

---
 base/logging.jl                 | 34 ++++++++++++++++-----------------
 stdlib/Logging/test/runtests.jl | 17 +++++++++++++++++
 2 files changed, 34 insertions(+), 17 deletions(-)

diff --git a/base/logging.jl b/base/logging.jl
index 7150299efa647..f6a34aee2f516 100644
--- a/base/logging.jl
+++ b/base/logging.jl
@@ -159,6 +159,9 @@ Alias for [`LogLevel(2000)`](@ref LogLevel).
 const Error         = LogLevel(    2000)
 const AboveMaxLevel = LogLevel( 1000001)
 
+# Global log limiting mechanism for super fast but inflexible global log limiting.
+const _min_enabled_level = Ref{LogLevel}(Debug)
+
 function show(io::IO, level::LogLevel)
     if     level == BelowMinLevel  print(io, "BelowMinLevel")
     elseif level == Debug          print(io, "Debug")
@@ -319,6 +322,15 @@ function issimplekw(@nospecialize val)
     return false
 end
 
+# helper function to get the current logger, if enabled for the specified message type
+@noinline Base.@constprop :none function current_logger_for_env(std_level::LogLevel, group, _module)
+    logstate = @inline current_logstate()
+    if std_level >= logstate.min_enabled_level || env_override_minlevel(group, _module)
+        return logstate.logger
+    end
+    return nothing
+end
+
 # Generate code for logging macros
 function logmsg_code(_module, file, line, level, message, exs...)
     @nospecialize
@@ -370,23 +382,23 @@ function logmsg_code(_module, file, line, level, message, exs...)
         let
             level = $level
             # simplify std_level code emitted, if we know it is one of our global constants
-            std_level = $(level isa Symbol ? :level : :(level isa LogLevel ? level : convert(LogLevel, level)::LogLevel))
-            if std_level >= _min_enabled_level[]
+            std_level = $(level isa Symbol ? :level : :(level isa $LogLevel ? level : convert($LogLevel, level)::$LogLevel))
+            if std_level >= $(_min_enabled_level)[]
                 group = $(log_data._group)
                 _module = $(log_data._module)
-                logger = current_logger_for_env(std_level, group, _module)
+                logger = $(current_logger_for_env)(std_level, group, _module)
                 if !(logger === nothing)
                     id = $(log_data._id)
                     # Second chance at an early bail-out (before computing the message),
                     # based on arbitrary logger-specific logic.
-                    if invokelatest(shouldlog, logger, level, _module, group, id)
+                    if invokelatest($shouldlog, logger, level, _module, group, id)
                         file = $(log_data._file)
                         if file isa String
                             file = Base.fixup_stdlib_path(file)
                         end
                         line = $(log_data._line)
                         local msg, kwargs
-                        $(logrecord) && invokelatest(handle_message,
+                        $(logrecord) && invokelatest($handle_message,
                             logger, level, msg, _module, group, id, file, line;
                             kwargs...)
                     end
@@ -481,9 +493,6 @@ function logmsg_shim(level, message, _module, group, id, file, line, kwargs)
     nothing
 end
 
-# Global log limiting mechanism for super fast but inflexible global log limiting.
-const _min_enabled_level = Ref{LogLevel}(Debug)
-
 # LogState - a cache of data extracted from the logger, plus the logger itself.
 struct LogState
     min_enabled_level::LogLevel
@@ -499,15 +508,6 @@ function current_logstate()
     return something(maybe, _global_logstate)::LogState
 end
 
-# helper function to get the current logger, if enabled for the specified message type
-@noinline Base.@constprop :none function current_logger_for_env(std_level::LogLevel, group, _module)
-    logstate = @inline current_logstate()
-    if std_level >= logstate.min_enabled_level || env_override_minlevel(group, _module)
-        return logstate.logger
-    end
-    return nothing
-end
-
 with_logstate(f::Function, logstate) = @with(CURRENT_LOGSTATE => logstate, f())
 
 #-------------------------------------------------------------------------------
diff --git a/stdlib/Logging/test/runtests.jl b/stdlib/Logging/test/runtests.jl
index b6b4813964536..3a793c4e0bc33 100644
--- a/stdlib/Logging/test/runtests.jl
+++ b/stdlib/Logging/test/runtests.jl
@@ -6,6 +6,10 @@ import Logging: min_enabled_level, shouldlog, handle_message
 
 @noinline func1() = backtrace()
 
+# see "custom log macro" testset
+CustomLog = LogLevel(-500)
+macro customlog(exs...) Base.CoreLogging.logmsg_code((Base.CoreLogging.@_sourceinfo)..., esc(CustomLog), exs...) end
+
 @testset "Logging" begin
 
 @testset "Core" begin
@@ -275,4 +279,17 @@ end
     @test m.run()
 end
 
+@testset "custom log macro" begin
+    @test_logs (CustomLog, "a") min_level=CustomLog @customlog "a"
+
+    buf = IOBuffer()
+    io = IOContext(buf, :displaysize=>(30,80), :color=>false)
+    logger = ConsoleLogger(io, CustomLog)
+
+    with_logger(logger) do
+        @customlog "a"
+    end
+    @test occursin("LogLevel(-500): a", String(take!(buf)))
+end
+
 end

From 3e4b38684e38a015446253f5752ee9cf840f50cc Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sun, 3 Dec 2023 13:15:57 +0900
Subject: [PATCH 0349/1315] add some comments about `ScopedValue`
 implementation (#52372)

---
 base/scopedvalues.jl |  4 +++-
 test/scopedvalues.jl | 15 ++++++++++-----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/base/scopedvalues.jl b/base/scopedvalues.jl
index 94491294c798a..6e1cc4755d618 100644
--- a/base/scopedvalues.jl
+++ b/base/scopedvalues.jl
@@ -38,7 +38,9 @@ julia> sval[]
     implementation is available from the package ScopedValues.jl.
 """
 mutable struct ScopedValue{T}
-    const has_default::Bool
+    # NOTE this struct must be defined as mutable one since it's used as a key of
+    #      `ScopeStorage` dictionary and thus needs object identity
+    const has_default::Bool # this field is necessary since isbitstype `default` field may be initialized with undefined value
     const default::T
     ScopedValue{T}() where T = new(false)
     ScopedValue{T}(val) where T = new{T}(true, val)
diff --git a/test/scopedvalues.jl b/test/scopedvalues.jl
index c9d376ab05cbd..b2a0e574fe7aa 100644
--- a/test/scopedvalues.jl
+++ b/test/scopedvalues.jl
@@ -4,13 +4,18 @@ import Base: ScopedValues
 @testset "errors" begin
     @test ScopedValue{Float64}(1)[] == 1.0
     @test_throws InexactError ScopedValue{Int}(1.5)
-    val = ScopedValue(1)
-    @test_throws MethodError val[] = 2
-    with() do
+    let val = ScopedValue(1)
         @test_throws MethodError val[] = 2
+        with() do
+            @test_throws MethodError val[] = 2
+        end
+    end
+    let val = ScopedValue{String}()
+        @test_throws KeyError val[]
+    end
+    let val = ScopedValue{Int}()
+        @test_throws KeyError val[]
     end
-    val = ScopedValue{Int}()
-    @test_throws KeyError val[]
     @test_throws MethodError ScopedValue()
 end
 

From fb5f7add1de6484a0394525ef953e28843691277 Mon Sep 17 00:00:00 2001
From: Joe Greener <jgreener@hotmail.co.uk>
Date: Mon, 4 Dec 2023 00:34:19 +0000
Subject: [PATCH 0350/1315] Fix docs link to package tests docs (#52384)

Since https://github.com/JuliaLang/julia/pull/52102 these links to the
Pkg.jl docs are dead. This should point them to the new location in the
Julia docs.

There is a reference in CONTRIBUTING.md that should change as well, but
maybe not until a Julia version with these changes is released:
https://github.com/JuliaLang/julia/blob/3e4b38684e38a015446253f5752ee9cf840f50cc/CONTRIBUTING.md?plain=1#L17
---
 doc/src/tutorials/creating-packages.md | 2 +-
 stdlib/Test/docs/src/index.md          | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/src/tutorials/creating-packages.md b/doc/src/tutorials/creating-packages.md
index a01141a2f6e48..6511aa2503816 100644
--- a/doc/src/tutorials/creating-packages.md
+++ b/doc/src/tutorials/creating-packages.md
@@ -246,7 +246,7 @@ in expression starting at /home/kc/HelloWorld/deps/build.jl:1
     A build step should generally not create or modify any files in the package directory. If you need to store some files
     from the build step, use the [Scratch.jl](https://github.com/JuliaPackaging/Scratch.jl) package.
 
-## Adding tests to the package
+## [Adding tests to the package](@id adding-tests-to-packages)
 
 When a package is tested the file `test/runtests.jl` is executed:
 
diff --git a/stdlib/Test/docs/src/index.md b/stdlib/Test/docs/src/index.md
index ddb5d580ef832..99f1a93286a37 100644
--- a/stdlib/Test/docs/src/index.md
+++ b/stdlib/Test/docs/src/index.md
@@ -20,7 +20,7 @@ The `Test` module provides simple *unit testing* functionality. Unit testing is
 see if your code is correct by checking that the results are what you expect. It can be helpful
 to ensure your code still works after you make changes, and can be used when developing as a way
 of specifying the behaviors your code should have when complete. You may also want to look at the
-documentation for [adding tests to your Julia Package](https://pkgdocs.julialang.org/dev/creating-packages/#Adding-tests-to-the-package).
+documentation for [adding tests to your Julia Package](@ref adding-tests-to-packages).
 
 Simple unit testing can be performed with the `@test` and `@test_throws` macros:
 
@@ -420,7 +420,7 @@ end
 We will need to create those two included files, `math_tests.jl` and `greeting_tests.jl`, and add some tests to them.
 
 > **Note:** Notice how we did not have to specify add `Example` into the `test` environment's `Project.toml`.
-> This is a benefit of Julia's testing system that you could [read about more here](https://pkgdocs.julialang.org/dev/creating-packages/).
+> This is a benefit of Julia's testing system that you could [read about more here](@ref adding-tests-to-packages).
 
 #### Writing Tests for `math_tests.jl`
 

From b69398a810f64e134211f01373a8f09c5c2cc6e1 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 4 Dec 2023 08:38:55 +0530
Subject: [PATCH 0351/1315] Integer matrix exponentiation in schurpow (#51992)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This improves type-inference by avoiding recursion, as the `A^p` method
calls `schurpow` if `p` is a float. After this, the result of `schurpow`
is inferred as a small `Union`:

```julia
julia> @inferred Union{Matrix{ComplexF64}, Matrix{Float64}} LinearAlgebra.schurpow([1.0 2; 3 4], 2.0)
2×2 Matrix{Float64}:
  7.0  10.0
 15.0  22.0
```

One concern here might be that for large `p`, the `A^Int(p)` computation
might be expensive by repeated multiplication, as opposed to
diagonalization. However, this may only be the case for really large
`p`, which may not be commonly encountered.

I've added a test, but I'm unsure if `schurpow` is deemed to be an
internal function, and this test is unwise. Unfortunately, the return
type of `A^p` isn't concretely inferred yet as there are too many
possible types that are returned, so I couldn't test for that.
---
 stdlib/LinearAlgebra/src/dense.jl  | 4 ++--
 stdlib/LinearAlgebra/test/dense.jl | 7 +++++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index c9eb7d3669d76..40054a44e72ec 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -490,7 +490,7 @@ end
 function schurpow(A::AbstractMatrix, p)
     if istriu(A)
         # Integer part
-        retmat = A ^ floor(p)
+        retmat = A ^ floor(Integer, p)
         # Real part
         if p - floor(p) == 0.5
             # special case: A^0.5 === sqrt(A)
@@ -501,7 +501,7 @@ function schurpow(A::AbstractMatrix, p)
     else
         S,Q,d = Schur{Complex}(schur(A))
         # Integer part
-        R = S ^ floor(p)
+        R = S ^ floor(Integer, p)
         # Real part
         if p - floor(p) == 0.5
             # special case: A^0.5 === sqrt(A)
diff --git a/stdlib/LinearAlgebra/test/dense.jl b/stdlib/LinearAlgebra/test/dense.jl
index b11ab5ece9c21..b22c0619abd24 100644
--- a/stdlib/LinearAlgebra/test/dense.jl
+++ b/stdlib/LinearAlgebra/test/dense.jl
@@ -1028,8 +1028,8 @@ end
     @test lyap(1.0+2.0im, 3.0+4.0im) == -1.5 - 2.0im
 end
 
-@testset "Matrix to real power" for elty in (Float64, ComplexF64)
-# Tests proposed at Higham, Deadman: Testing Matrix Function Algorithms Using Identities, March 2014
+@testset "$elty Matrix to real power" for elty in (Float64, ComplexF64)
+    # Tests proposed at Higham, Deadman: Testing Matrix Function Algorithms Using Identities, March 2014
     #Aa : only positive real eigenvalues
     Aa = convert(Matrix{elty}, [5 4 2 1; 0 1 -1 -1; -1 -1 3 0; 1 1 -1 2])
 
@@ -1065,6 +1065,9 @@ end
         @test (A^(2/3))*(A^(1/3)) ≈ A
         @test (A^im)^(-im) ≈ A
     end
+
+    Tschurpow = Union{Matrix{real(elty)}, Matrix{complex(elty)}}
+    @test (@inferred Tschurpow LinearAlgebra.schurpow(Aa, 2.0)) ≈ Aa^2
 end
 
 @testset "diagonal integer matrix to real power" begin

From e280387cf0811de7541220d8772281f3a86f4c6e Mon Sep 17 00:00:00 2001
From: Alexis Montoison <35051714+amontoison@users.noreply.github.com>
Date: Mon, 4 Dec 2023 07:10:54 -0600
Subject: [PATCH 0352/1315] [LAPACK] Interface lacpy! and add a Julia version
 copytrito! (#51909)

The PR adds a function `lacpy!` to easily copy a triangular part of a
square or rectangular dense matrix.
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl |  1 +
 stdlib/LinearAlgebra/src/generic.jl       | 45 +++++++++++++++++++
 stdlib/LinearAlgebra/src/lapack.jl        | 53 +++++++++++++++++++++++
 stdlib/LinearAlgebra/test/generic.jl      | 11 +++++
 stdlib/LinearAlgebra/test/lapack.jl       | 13 ++++++
 5 files changed, 123 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index 49f7f3226bc0a..9b250e8ee61f5 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -76,6 +76,7 @@ export
     cond,
     condskeel,
     copyto!,
+    copytrito!,
     copy_transpose!,
     cross,
     adjoint,
diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl
index 9ab961461e76f..929618b95ce0a 100644
--- a/stdlib/LinearAlgebra/src/generic.jl
+++ b/stdlib/LinearAlgebra/src/generic.jl
@@ -1897,3 +1897,48 @@ end
 
 normalize(x) = x / norm(x)
 normalize(x, p::Real) = x / norm(x, p)
+
+"""
+    copytrito!(B, A, uplo) -> B
+
+Copies a triangular part of a matrix `A` to another matrix `B`.
+`uplo` specifies the part of the matrix `A` to be copied to `B`.
+Set `uplo = 'L'` for the lower triangular part or `uplo = 'U'
+for the upper triangular part.
+
+!!! compat "Julia 1.11"
+    `copytrito!` requires at least Julia 1.11.
+
+# Examples
+```jldoctest
+julia> A = [1 2 ; 3 4];
+
+julia> B = [0 0 ; 0 0];
+
+julia> copytrito!(B, A, 'L')
+2×2 Matrix{Int64}:
+ 1  0
+ 3  4
+```
+"""
+function copytrito!(B::AbstractMatrix, A::AbstractMatrix, uplo::AbstractChar)
+    require_one_based_indexing(A, B)
+    BLAS.chkuplo(uplo)
+    m,n = size(A)
+    m1,n1 = size(B)
+    (m1 < m || n1 < n) && throw(DimensionMismatch("B of size ($m1,$n1) should have at least the same number of rows and columns than A of size ($m,$n)"))
+    if uplo == 'U'
+        for j=1:n
+            for i=1:min(j,m)
+                @inbounds B[i,j] = A[i,j]
+            end
+        end
+    else  # uplo == 'L'
+        for j=1:n
+            for i=j:m
+                @inbounds B[i,j] = A[i,j]
+            end
+        end
+    end
+    return B
+end
diff --git a/stdlib/LinearAlgebra/src/lapack.jl b/stdlib/LinearAlgebra/src/lapack.jl
index 7bb26c2b6589a..18ebe53453e44 100644
--- a/stdlib/LinearAlgebra/src/lapack.jl
+++ b/stdlib/LinearAlgebra/src/lapack.jl
@@ -6992,4 +6992,57 @@ Returns `X` (overwriting `C`) and `scale`.
 """
 trsyl!(transa::AbstractChar, transb::AbstractChar, A::AbstractMatrix, B::AbstractMatrix, C::AbstractMatrix, isgn::Int=1)
 
+for (fn, elty) in ((:dlacpy_, :Float64),
+                   (:slacpy_, :Float32),
+                   (:zlacpy_, :ComplexF64),
+                   (:clacpy_, :ComplexF32))
+    @eval begin
+        # SUBROUTINE DLACPY( UPLO, M, N, A, LDA, B, LDB )
+        #     .. Scalar Arguments ..
+        #      CHARACTER          UPLO
+        #      INTEGER            LDA, LDB, M, N
+        #     ..
+        #     .. Array Arguments ..
+        #     DOUBLE PRECISION   A( LDA, * ), B( LDB, * )
+        #     ..
+        function lacpy!(B::AbstractMatrix{$elty}, A::AbstractMatrix{$elty}, uplo::AbstractChar)
+            require_one_based_indexing(A, B)
+            chkstride1(A, B)
+            m,n = size(A)
+            m1,n1 = size(B)
+            (m1 < m || n1 < n) && throw(DimensionMismatch("B of size ($m1,$n1) should have at least the same number of rows and columns than A of size ($m,$n)"))
+            lda = max(1, stride(A, 2))
+            ldb = max(1, stride(B, 2))
+            ccall((@blasfunc($fn), libblastrampoline), Cvoid,
+                 (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty},
+                  Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Clong),
+                  uplo, m, n, A, lda, B, ldb, 1)
+            B
+        end
+    end
+end
+
+"""
+    lacpy!(B, A, uplo) -> B
+
+Copies all or part of a matrix `A` to another matrix `B`.
+uplo specifies the part of the matrix `A` to be copied to `B`.
+Set `uplo = 'L'` for the lower triangular part, `uplo = 'U'`
+for the upper triangular part, any other character for all
+the matrix `A`.
+
+# Examples
+```jldoctest
+julia> A = [1. 2. ; 3. 4.];
+
+julia> B = [0. 0. ; 0. 0.];
+
+julia> LAPACK.lacpy!(B, A, 'U')
+2×2 Matrix{Float64}:
+ 1.0  2.0
+ 0.0  4.0
+```
+"""
+lacpy!(B::AbstractMatrix, A::AbstractMatrix, uplo::AbstractChar)
+
 end # module
diff --git a/stdlib/LinearAlgebra/test/generic.jl b/stdlib/LinearAlgebra/test/generic.jl
index 303e78cfd0c58..c79173ad1011a 100644
--- a/stdlib/LinearAlgebra/test/generic.jl
+++ b/stdlib/LinearAlgebra/test/generic.jl
@@ -636,4 +636,15 @@ end
     @test condskeel(A) ≈ condskeel(A, [8,8,8])
 end
 
+@testset "copytrito!" begin
+    n = 10
+    A = rand(n, n)
+    for uplo in ('L', 'U')
+        B = zeros(n, n)
+        copytrito!(B, A, uplo)
+        C = uplo == 'L' ? tril(A) : triu(A)
+        @test B ≈ C
+    end
+end
+
 end # module TestGeneric
diff --git a/stdlib/LinearAlgebra/test/lapack.jl b/stdlib/LinearAlgebra/test/lapack.jl
index 141b47d1bacef..6e12c85204a78 100644
--- a/stdlib/LinearAlgebra/test/lapack.jl
+++ b/stdlib/LinearAlgebra/test/lapack.jl
@@ -685,6 +685,19 @@ end
     end
 end
 
+@testset "lacpy!" begin
+    @testset for elty in (Float32, Float64, ComplexF32, ComplexF64)
+        n = 10
+        A = rand(elty, n, n)
+        for uplo in ('L', 'U', 'N')
+            B = zeros(elty, n, n)
+            LinearAlgebra.LAPACK.lacpy!(B, A, uplo)
+            C = uplo == 'L' ? tril(A) : (uplo == 'U' ? triu(A) : A)
+            @test B ≈ C
+        end
+    end
+end
+
 @testset "Julia vs LAPACK" begin
     # Test our own linear algebra functionality against LAPACK
     @testset for elty in (Float32, Float64, ComplexF32, ComplexF64)

From f7618602d409eae92f8cde3a717ee5c56987bd8d Mon Sep 17 00:00:00 2001
From: Benjamin Lorenz <benlorenz@users.noreply.github.com>
Date: Mon, 4 Dec 2023 15:15:02 +0100
Subject: [PATCH 0353/1315] Export `jl_alloc_array_nd`, re-add and export
 convenience wrappers (#52248)

This is used in an example here in the docs
https://docs.julialang.org/en/v1.11-dev/manual/embedding/#Multidimensional-Arrays
and needed to adapt to the removed `jl_alloc_array_2d` (#51319).
---
 src/array.c               | 12 ++++++++++++
 src/jl_exported_funcs.inc |  3 +++
 src/julia.h               |  3 +++
 3 files changed, 18 insertions(+)

diff --git a/src/array.c b/src/array.c
index 2c6505b9d6e04..fcae8ac26fa22 100644
--- a/src/array.c
+++ b/src/array.c
@@ -167,6 +167,18 @@ JL_DLLEXPORT jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr)
     return new_array(atype, 1, &nr);
 }
 
+JL_DLLEXPORT jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr, size_t nc)
+{
+    size_t dims[2] = {nr, nc};
+    return new_array(atype, 2, &dims[0]);
+}
+
+JL_DLLEXPORT jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr, size_t nc, size_t z)
+{
+    size_t dims[3] = {nr, nc, z};
+    return new_array(atype, 3, &dims[0]);
+}
+
 JL_DLLEXPORT jl_array_t *jl_alloc_array_nd(jl_value_t *atype, size_t *dims, size_t ndims)
 {
     return new_array(atype, ndims, dims);
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 6c7af9bf2e245..e5d78a1ddb8f5 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -6,6 +6,9 @@
     XX(jl_adopt_thread) \
     XX(jl_alignment) \
     XX(jl_alloc_array_1d) \
+    XX(jl_alloc_array_2d) \
+    XX(jl_alloc_array_3d) \
+    XX(jl_alloc_array_nd) \
     XX(jl_alloc_string) \
     XX(jl_alloc_svec) \
     XX(jl_alloc_svec_uninit) \
diff --git a/src/julia.h b/src/julia.h
index 9b69dd54dabc8..e87f277092629 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1828,6 +1828,9 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
                                          jl_value_t *dims, int own_buffer);
 
 JL_DLLEXPORT jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr);
+JL_DLLEXPORT jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr, size_t nc);
+JL_DLLEXPORT jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr, size_t nc, size_t z);
+JL_DLLEXPORT jl_array_t *jl_alloc_array_nd(jl_value_t *atype, size_t *dims, size_t ndims);
 JL_DLLEXPORT jl_array_t *jl_pchar_to_array(const char *str, size_t len);
 JL_DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len);
 JL_DLLEXPORT jl_value_t *jl_cstr_to_string(const char *str);

From bb7091c6f264f4ddbcb1ad7712bf0b96de365643 Mon Sep 17 00:00:00 2001
From: matthias314 <56549971+matthias314@users.noreply.github.com>
Date: Mon, 4 Dec 2023 09:58:00 -0500
Subject: [PATCH 0354/1315] Speed up `first` and `only` for various types
 (#52296)

---
 base/abstractarray.jl |  2 +-
 base/dict.jl          |  4 ++++
 base/iterators.jl     | 15 +++++++++++++--
 base/set.jl           |  2 ++
 base/strings/basic.jl |  2 ++
 base/weakkeydict.jl   |  2 ++
 6 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 4a35c1a2eb9db..200586213cc90 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -446,7 +446,7 @@ julia> firstindex(rand(3,4,5), 2)
 firstindex(a::AbstractArray) = (@inline; first(eachindex(IndexLinear(), a)))
 firstindex(a, d) = (@inline; first(axes(a, d)))
 
-first(a::AbstractArray) = a[first(eachindex(a))]
+@propagate_inbounds first(a::AbstractArray) = a[first(eachindex(a))]
 
 """
     first(coll)
diff --git a/base/dict.jl b/base/dict.jl
index 768f8215946b8..afed320609f57 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -738,6 +738,8 @@ end
 isempty(t::Dict) = (t.count == 0)
 length(t::Dict) = t.count
 
+@propagate_inbounds Iterators.only(t::Dict) = Iterators._only(t, first)
+
 @propagate_inbounds function Base.iterate(v::T, i::Int = v.dict.idxfloor) where T <: Union{KeySet{<:Any, <:Dict}, ValueIterator{<:Dict}}
     i == 0 && return nothing
     i = skip_deleted(v.dict, i)
@@ -1049,3 +1051,5 @@ iterate(dict::PersistentDict, state=nothing) = HAMT.iterate(dict.trie, state)
 length(dict::PersistentDict) = HAMT.length(dict.trie)
 isempty(dict::PersistentDict) = HAMT.isempty(dict.trie)
 empty(::PersistentDict, ::Type{K}, ::Type{V}) where {K, V} = PersistentDict{K, V}()
+
+@propagate_inbounds Iterators.only(dict::PersistentDict) = Iterators._only(dict, first)
diff --git a/base/iterators.jl b/base/iterators.jl
index 71099bb65d0b6..14cbd104c09d1 100644
--- a/base/iterators.jl
+++ b/base/iterators.jl
@@ -11,7 +11,7 @@ const Base = parentmodule(@__MODULE__)
 using .Base:
     @inline, Pair, Pairs, AbstractDict, IndexLinear, IndexStyle, AbstractVector, Vector,
     SizeUnknown, HasLength, HasShape, IsInfinite, EltypeUnknown, HasEltype, OneTo,
-    @propagate_inbounds, @isdefined, @boundscheck, @inbounds, Generator,
+    @propagate_inbounds, @isdefined, @boundscheck, @inbounds, Generator, IdDict,
     AbstractRange, AbstractUnitRange, UnitRange, LinearIndices, TupleOrBottom,
     (:), |, +, -, *, !==, !, ==, !=, <=, <, >, >=, missing,
     any, _counttuple, eachindex, ntuple, zero, prod, reduce, in, firstindex, lastindex,
@@ -1547,7 +1547,9 @@ Stacktrace:
 [...]
 ```
 """
-@propagate_inbounds function only(x)
+@propagate_inbounds only(x) = _only(x, iterate)
+
+@propagate_inbounds function _only(x, ::typeof(iterate))
     i = iterate(x)
     @boundscheck if i === nothing
         throw(ArgumentError("Collection is empty, must contain exactly 1 element"))
@@ -1559,6 +1561,15 @@ Stacktrace:
     return ret
 end
 
+@inline function _only(x, ::typeof(first))
+    @boundscheck if length(x) != 1
+        throw(ArgumentError("Collection must contain exactly 1 element"))
+    end
+    @inbounds first(x)
+end
+
+@propagate_inbounds only(x::IdDict) = _only(x, first)
+
 # Specific error messages for tuples and named tuples
 only(x::Tuple{Any}) = x[1]
 only(x::Tuple) = throw(
diff --git a/base/set.jl b/base/set.jl
index 07c857fab3213..76502ee9d22ef 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -175,6 +175,8 @@ rehash!(s::Set) = (rehash!(s.dict); s)
 
 iterate(s::Set, i...)       = iterate(KeySet(s.dict), i...)
 
+@propagate_inbounds Iterators.only(s::Set) = Iterators._only(s, first)
+
 # In case the size(s) is smaller than size(t) its more efficient to iterate through
 # elements of s instead and only delete the ones also contained in t.
 # The threshold for this decision boils down to a tradeoff between
diff --git a/base/strings/basic.jl b/base/strings/basic.jl
index 5fc5dea24da8d..4136571963f99 100644
--- a/base/strings/basic.jl
+++ b/base/strings/basic.jl
@@ -179,6 +179,8 @@ firstindex(s::AbstractString) = 1
 lastindex(s::AbstractString) = thisind(s, ncodeunits(s)::Int)
 isempty(s::AbstractString) = iszero(ncodeunits(s)::Int)
 
+@propagate_inbounds first(s::AbstractString) = s[firstindex(s)]
+
 function getindex(s::AbstractString, i::Integer)
     @boundscheck checkbounds(s, i)
     @inbounds return isvalid(s, i) ? (iterate(s, i)::NTuple{2,Any})[1] : string_index_err(s, i)
diff --git a/base/weakkeydict.jl b/base/weakkeydict.jl
index 5073e55191847..b827f0d1495da 100644
--- a/base/weakkeydict.jl
+++ b/base/weakkeydict.jl
@@ -213,4 +213,6 @@ function iterate(t::WeakKeyDict{K,V}, state...) where {K, V}
     end
 end
 
+@propagate_inbounds Iterators.only(d::WeakKeyDict) = Iterators._only(d, first)
+
 filter!(f, d::WeakKeyDict) = filter_in_one_pass!(f, d)

From 0a4b8108ee44aa915619f4791d39345adbcd95ae Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Mon, 4 Dec 2023 17:29:30 -0300
Subject: [PATCH 0355/1315] functionality to expose page utilization at the
 julia level (#52390)

---------

Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com>
---
 base/timing.jl | 7 +++++++
 src/gc.c       | 8 ++------
 src/gc.h       | 3 ---
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/base/timing.jl b/base/timing.jl
index bc4bd73d927b2..3a5dcf77aab28 100644
--- a/base/timing.jl
+++ b/base/timing.jl
@@ -98,6 +98,13 @@ function gc_live_bytes()
     Int(ccall(:jl_gc_live_bytes, Int64, ())) + num.allocd + num.deferred_alloc
 end
 
+# must be kept in sync with the value from `src/julia_threads.h``
+const JL_GC_N_MAX_POOLS = 51
+function gc_page_utilization_data()
+    page_utilization_raw = cglobal(:gc_page_utilization_stats, Float64)
+    return Base.unsafe_wrap(Array, page_utilization_raw, JL_GC_N_MAX_POOLS, own=false)
+end
+
 """
     Base.jit_total_bytes()
 
diff --git a/src/gc.c b/src/gc.c
index bf5364aaa286d..904566cdf8d14 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1421,19 +1421,17 @@ int jl_gc_classify_pools(size_t sz, int *osize)
 // sweep phase
 
 gc_fragmentation_stat_t gc_page_fragmentation_stats[JL_GC_N_POOLS];
+JL_DLLEXPORT double gc_page_utilization_stats[JL_GC_N_MAX_POOLS];
 
 STATIC_INLINE void gc_update_page_fragmentation_data(jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT
 {
-#ifdef GC_MEASURE_PAGE_FRAGMENTATION
     gc_fragmentation_stat_t *stats = &gc_page_fragmentation_stats[pg->pool_n];
     jl_atomic_fetch_add(&stats->n_freed_objs, pg->nfree);
     jl_atomic_fetch_add(&stats->n_pages_allocd, 1);
-#endif
 }
 
 STATIC_INLINE void gc_dump_page_utilization_data(void) JL_NOTSAFEPOINT
 {
-#ifdef GC_MEASURE_PAGE_FRAGMENTATION
     for (int i = 0; i < JL_GC_N_POOLS; i++) {
         gc_fragmentation_stat_t *stats = &gc_page_fragmentation_stats[i];
         double utilization = 1.0;
@@ -1442,12 +1440,10 @@ STATIC_INLINE void gc_dump_page_utilization_data(void) JL_NOTSAFEPOINT
         if (n_pages_allocd != 0) {
             utilization -= ((double)n_freed_objs * (double)jl_gc_sizeclasses[i]) / (double)n_pages_allocd / (double)GC_PAGE_SZ;
         }
-        jl_safe_printf("Size class %d: %.2f%% utilization\n", jl_gc_sizeclasses[i], utilization * 100.0);
+        gc_page_utilization_stats[i] = utilization;
         jl_atomic_store_relaxed(&stats->n_freed_objs, 0);
         jl_atomic_store_relaxed(&stats->n_pages_allocd, 0);
     }
-    jl_safe_printf("-----------------------------------------\n");
-#endif
 }
 
 int64_t buffered_pages = 0;
diff --git a/src/gc.h b/src/gc.h
index 6dceee9053ede..e4facad8efae0 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -238,9 +238,6 @@ STATIC_INLINE jl_gc_pagemeta_t *pop_lf_back(jl_gc_page_stack_t *pool) JL_NOTSAFE
     }
 }
 
-// data structures for tracking fragmentation in the pool allocator
-// #define GC_MEASURE_PAGE_FRAGMENTATION
-
 typedef struct {
     _Atomic(size_t) n_freed_objs;
     _Atomic(size_t) n_pages_allocd;

From 150c1adfd6f1a54e6a74393c7bb73af8f772fa30 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 5 Dec 2023 15:35:31 +0530
Subject: [PATCH 0356/1315] Add single-term multiplication for `AbstractQ` on
 v1.10 and above (#52342)

---
 stdlib/LinearAlgebra/src/abstractq.jl  | 3 +++
 stdlib/LinearAlgebra/test/abstractq.jl | 1 +
 2 files changed, 4 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/abstractq.jl b/stdlib/LinearAlgebra/src/abstractq.jl
index 2aa333beef2b2..b0d53320f4aa3 100644
--- a/stdlib/LinearAlgebra/src/abstractq.jl
+++ b/stdlib/LinearAlgebra/src/abstractq.jl
@@ -157,6 +157,9 @@ qsize_check(Q::AbstractQ, P::AbstractQ) =
     size(Q, 2) == size(P, 1) ||
         throw(DimensionMismatch("second dimension of A, $(size(Q,2)), must coincide with first dimension of B, $(size(P,1))"))
 
+# mimic the AbstractArray fallback
+*(Q::AbstractQ{<:Number}) = Q
+
 (*)(Q::AbstractQ, J::UniformScaling) = Q*J.λ
 function (*)(Q::AbstractQ, b::Number)
     T = promote_type(eltype(Q), typeof(b))
diff --git a/stdlib/LinearAlgebra/test/abstractq.jl b/stdlib/LinearAlgebra/test/abstractq.jl
index 83a26c6050484..19b872d685668 100644
--- a/stdlib/LinearAlgebra/test/abstractq.jl
+++ b/stdlib/LinearAlgebra/test/abstractq.jl
@@ -34,6 +34,7 @@ n = 5
         T <: Complex && @test_throws ErrorException transpose(Q)
         @test convert(AbstractQ{complex(T)}, Q) isa MyQ{complex(T)}
         @test convert(AbstractQ{complex(T)}, Q') isa AdjointQ{<:complex(T),<:MyQ{complex(T)}}
+        @test *(Q) == Q
         @test Q*I ≈ Q.Q*I rtol=2eps(real(T))
         @test Q'*I ≈ Q.Q'*I rtol=2eps(real(T))
         @test I*Q ≈ Q.Q*I rtol=2eps(real(T))

From 53f1eb82b8a4265def61ab677746b63a583ef865 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Tue, 5 Dec 2023 05:26:21 -0500
Subject: [PATCH 0357/1315] bugfix for dot of Hermitian{noncommutative}
 (#52333)

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 stdlib/LinearAlgebra/src/symmetric.jl  |  2 +-
 stdlib/LinearAlgebra/test/symmetric.jl | 16 ++++++++++++++++
 test/testhelpers/Quaternions.jl        |  5 ++++-
 3 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 0c19e26e3dd4a..789ad40a9de94 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -453,7 +453,7 @@ function triu(A::Symmetric, k::Integer=0)
     end
 end
 
-for (T, trans, real) in [(:Symmetric, :transpose, :identity), (:Hermitian, :adjoint, :real)]
+for (T, trans, real) in [(:Symmetric, :transpose, :identity), (:(Hermitian{<:Union{Real,Complex}}), :adjoint, :real)]
     @eval begin
         function dot(A::$T, B::$T)
             n = size(A, 2)
diff --git a/stdlib/LinearAlgebra/test/symmetric.jl b/stdlib/LinearAlgebra/test/symmetric.jl
index 224b7b31a50df..82236c2a677eb 100644
--- a/stdlib/LinearAlgebra/test/symmetric.jl
+++ b/stdlib/LinearAlgebra/test/symmetric.jl
@@ -4,6 +4,11 @@ module TestSymmetric
 
 using Test, LinearAlgebra, Random
 
+const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
+
+isdefined(Main, :Quaternions) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "Quaternions.jl"))
+using .Main.Quaternions
+
 Random.seed!(1010)
 
 @testset "Pauli σ-matrices: $σ" for σ in map(Hermitian,
@@ -462,6 +467,17 @@ end
     end
 end
 
+# bug identified in PR #52318: dot products of quaternionic Hermitian matrices,
+# or any number type where conj(a)*conj(b) ≠ conj(a*b):
+@testset "dot Hermitian quaternion #52318" begin
+    A, B = [Quaternion.(randn(3,3), randn(3, 3), randn(3, 3), randn(3,3)) |> t -> t + t' for i in 1:2]
+    @test A == Hermitian(A) && B == Hermitian(B)
+    @test dot(A, B) ≈ dot(Hermitian(A), Hermitian(B))
+    A, B = [Quaternion.(randn(3,3), randn(3, 3), randn(3, 3), randn(3,3)) |> t -> t + transpose(t) for i in 1:2]
+    @test A == Symmetric(A) && B == Symmetric(B)
+    @test dot(A, B) ≈ dot(Symmetric(A), Symmetric(B))
+end
+
 #Issue #7647: test xsyevr, xheevr, xstevr drivers.
 @testset "Eigenvalues in interval for $(typeof(Mi7647))" for Mi7647 in
         (Symmetric(diagm(0 => 1.0:3.0)),
diff --git a/test/testhelpers/Quaternions.jl b/test/testhelpers/Quaternions.jl
index 1eddad322ec40..81b7a0c2d0121 100644
--- a/test/testhelpers/Quaternions.jl
+++ b/test/testhelpers/Quaternions.jl
@@ -20,6 +20,7 @@ Base.abs2(q::Quaternion) = q.s*q.s + q.v1*q.v1 + q.v2*q.v2 + q.v3*q.v3
 Base.float(z::Quaternion{T}) where T = Quaternion(float(z.s), float(z.v1), float(z.v2), float(z.v3))
 Base.abs(q::Quaternion) = sqrt(abs2(q))
 Base.real(::Type{Quaternion{T}}) where {T} = T
+Base.real(q::Quaternion) = q.s
 Base.conj(q::Quaternion) = Quaternion(q.s, -q.v1, -q.v2, -q.v3)
 Base.isfinite(q::Quaternion) = isfinite(q.s) & isfinite(q.v1) & isfinite(q.v2) & isfinite(q.v3)
 Base.zero(::Type{Quaternion{T}}) where T = Quaternion{T}(zero(T), zero(T), zero(T), zero(T))
@@ -33,7 +34,9 @@ Base.:(*)(q::Quaternion, w::Quaternion) = Quaternion(q.s*w.s - q.v1*w.v1 - q.v2*
                                             q.s*w.v2 - q.v1*w.v3 + q.v2*w.s + q.v3*w.v1,
                                             q.s*w.v3 + q.v1*w.v2 - q.v2*w.v1 + q.v3*w.s)
 Base.:(*)(q::Quaternion, r::Real) = Quaternion(q.s*r, q.v1*r, q.v2*r, q.v3*r)
-Base.:(*)(q::Quaternion, b::Bool) = b * q # remove method ambiguity
+Base.:(*)(q::Quaternion, r::Bool) = Quaternion(q.s*r, q.v1*r, q.v2*r, q.v3*r) # remove method ambiguity
+Base.:(*)(r::Real, q::Quaternion) = q * r
+Base.:(*)(r::Bool, q::Quaternion) = q * r # remove method ambiguity
 Base.:(/)(q::Quaternion, w::Quaternion) = q * conj(w) * (1.0 / abs2(w))
 Base.:(\)(q::Quaternion, w::Quaternion) = conj(q) * w * (1.0 / abs2(q))
 

From 8d0eec929ac0a7c2ce14e2f5e5b390a9703d9145 Mon Sep 17 00:00:00 2001
From: Aravindh Krishnamoorthy <aravindh.krishnamoorthy@fau.de>
Date: Tue, 5 Dec 2023 11:37:42 +0100
Subject: [PATCH 0358/1315] Implement `cbrt(A::AbstractMatrix{<:Real})`
 (#50661)

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 NEWS.md                                   |  1 +
 doc/src/base/math.md                      |  2 +-
 stdlib/LinearAlgebra/docs/src/index.md    |  5 +-
 stdlib/LinearAlgebra/src/LinearAlgebra.jl |  4 +-
 stdlib/LinearAlgebra/src/dense.jl         | 48 ++++++++++++
 stdlib/LinearAlgebra/src/diagonal.jl      |  3 +
 stdlib/LinearAlgebra/src/symmetric.jl     |  7 ++
 stdlib/LinearAlgebra/src/triangular.jl    | 91 +++++++++++++++++++++++
 stdlib/LinearAlgebra/test/dense.jl        | 48 ++++++++++++
 9 files changed, 204 insertions(+), 5 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 30a4c1af21d89..fed308639b9a3 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -88,6 +88,7 @@ Standard library changes
 #### Package Manager
 
 #### LinearAlgebra
+* `cbrt(::AbstractMatrix{<:Real})` is now defined and returns real-valued matrix cube roots of real-valued matrices ([#50661]).
 
 #### Printf
 
diff --git a/doc/src/base/math.md b/doc/src/base/math.md
index 9093eddd51dfe..cb427c9458fe1 100644
--- a/doc/src/base/math.md
+++ b/doc/src/base/math.md
@@ -159,7 +159,7 @@ Base.signbit
 Base.flipsign
 Base.sqrt(::Number)
 Base.isqrt
-Base.Math.cbrt
+Base.Math.cbrt(::AbstractFloat)
 Base.real
 Base.imag
 Base.reim
diff --git a/stdlib/LinearAlgebra/docs/src/index.md b/stdlib/LinearAlgebra/docs/src/index.md
index 79444333d5ec1..d263dfe299206 100644
--- a/stdlib/LinearAlgebra/docs/src/index.md
+++ b/stdlib/LinearAlgebra/docs/src/index.md
@@ -184,8 +184,8 @@ as well as whether hooks to various optimized methods for them in LAPACK are ava
 
 | Matrix type                   | `+` | `-` | `*` | `\` | Other functions with optimized methods                      |
 |:----------------------------- |:--- |:--- |:--- |:--- |:----------------------------------------------------------- |
-| [`Symmetric`](@ref)           |     |     |     | MV  | [`inv`](@ref), [`sqrt`](@ref), [`exp`](@ref)                |
-| [`Hermitian`](@ref)           |     |     |     | MV  | [`inv`](@ref), [`sqrt`](@ref), [`exp`](@ref)                |
+| [`Symmetric`](@ref)           |     |     |     | MV  | [`inv`](@ref), [`sqrt`](@ref), [`cbrt`](@ref), [`exp`](@ref)                |
+| [`Hermitian`](@ref)           |     |     |     | MV  | [`inv`](@ref), [`sqrt`](@ref), [`cbrt`](@ref), [`exp`](@ref)                |
 | [`UpperTriangular`](@ref)     |     |     | MV  | MV  | [`inv`](@ref), [`det`](@ref), [`logdet`](@ref)                                |
 | [`UnitUpperTriangular`](@ref) |     |     | MV  | MV  | [`inv`](@ref), [`det`](@ref), [`logdet`](@ref)                                |
 | [`LowerTriangular`](@ref)     |     |     | MV  | MV  | [`inv`](@ref), [`det`](@ref), [`logdet`](@ref)                                |
@@ -516,6 +516,7 @@ Base.:^(::AbstractMatrix, ::Number)
 Base.:^(::Number, ::AbstractMatrix)
 LinearAlgebra.log(::StridedMatrix)
 LinearAlgebra.sqrt(::StridedMatrix)
+LinearAlgebra.cbrt(::AbstractMatrix{<:Real})
 LinearAlgebra.cos(::StridedMatrix{<:Real})
 LinearAlgebra.sin(::StridedMatrix{<:Real})
 LinearAlgebra.sincos(::StridedMatrix{<:Real})
diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index 9b250e8ee61f5..a1aebdd92b4e7 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -9,8 +9,8 @@ module LinearAlgebra
 
 import Base: \, /, *, ^, +, -, ==
 import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, asec, asech,
-    asin, asinh, atan, atanh, axes, big, broadcast, ceil, cis, collect, conj, convert, copy,
-    copyto!, copymutable, cos, cosh, cot, coth, csc, csch, eltype, exp, fill!, floor,
+    asin, asinh, atan, atanh, axes, big, broadcast, cbrt, ceil, cis, collect, conj, convert,
+    copy, copyto!, copymutable, cos, cosh, cot, coth, csc, csch, eltype, exp, fill!, floor,
     getindex, hcat, getproperty, imag, inv, isapprox, isequal, isone, iszero, IndexStyle,
     kron, kron!, length, log, map, ndims, one, oneunit, parent, permutedims,
     power_by_squaring, promote_rule, real, sec, sech, setindex!, show, similar, sin,
diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 40054a44e72ec..02b9aee4c502e 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -907,6 +907,54 @@ end
 sqrt(A::AdjointAbsMat) = adjoint(sqrt(parent(A)))
 sqrt(A::TransposeAbsMat) = transpose(sqrt(parent(A)))
 
+"""
+    cbrt(A::AbstractMatrix{<:Real})
+
+Computes the real-valued cube root of a real-valued matrix `A`. If `T = cbrt(A)`, then
+we have `T*T*T ≈ A`, see example given below.
+
+If `A` is symmetric, i.e., of type `HermOrSym{<:Real}`, then ([`eigen`](@ref)) is used to
+find the cube root. Otherwise, a specialized version of the p-th root algorithm [^S03] is
+utilized, which exploits the real-valued Schur decomposition ([`schur`](@ref))
+to compute the cube root.
+
+[^S03]:
+
+    Matthew I. Smith, "A Schur Algorithm for Computing Matrix pth Roots",
+    SIAM Journal on Matrix Analysis and Applications, vol. 24, 2003, pp. 971–989.
+    [doi:10.1137/S0895479801392697](https://doi.org/10.1137/s0895479801392697)
+
+# Examples
+```jldoctest
+julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
+2×2 Matrix{Float64}:
+  0.927524  -0.15857
+ -1.3677    -1.01172
+
+julia> T = cbrt(A)
+2×2 Matrix{Float64}:
+  0.910077  -0.151019
+ -1.30257   -0.936818
+
+julia> T*T*T ≈ A
+true
+```
+"""
+function cbrt(A::AbstractMatrix{<:Real})
+    if checksquare(A) == 0
+        return copy(A)
+    elseif issymmetric(A)
+        return cbrt(Symmetric(A, :U))
+    else
+        S = schur(A)
+        return S.Z * _cbrt_quasi_triu!(S.T) * S.Z'
+    end
+end
+
+# Cube roots of adjoint and transpose matrices
+cbrt(A::AdjointAbsMat) = adjoint(cbrt(parent(A)))
+cbrt(A::TransposeAbsMat) = transpose(cbrt(parent(A)))
+
 function inv(A::StridedMatrix{T}) where T
     checksquare(A)
     if istriu(A)
diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index ebc0d1cd0e59b..4646520ecd1ab 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -736,6 +736,9 @@ for f in (:exp, :cis, :log, :sqrt,
     @eval $f(D::Diagonal) = Diagonal($f.(D.diag))
 end
 
+# Cube root of a real-valued diagonal matrix
+cbrt(A::Diagonal{<:Real}) = Diagonal(cbrt.(A.diag))
+
 function inv(D::Diagonal{T}) where T
     Di = similar(D.diag, typeof(inv(oneunit(T))))
     for i = 1:length(D.diag)
diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 789ad40a9de94..fbfa613efb5f2 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -812,6 +812,13 @@ for func in (:log, :sqrt)
     end
 end
 
+# Cube root of a real-valued symmetric matrix
+function cbrt(A::HermOrSym{<:Real})
+    F = eigen(A)
+    A = F.vectors * Diagonal(cbrt.(F.values)) * F.vectors'
+    return A
+end
+
 """
     hermitianpart(A, uplo=:U) -> Hermitian
 
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 303ae2d8f1a10..9252350336b02 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -2537,3 +2537,94 @@ for (tritype, comptritype) in ((:LowerTriangular, :UpperTriangular),
     @eval /(u::TransposeAbsVec, A::$tritype{<:Any,<:Adjoint}) = transpose($comptritype(conj(parent(parent(A)))) \ u.parent)
     @eval /(u::TransposeAbsVec, A::$tritype{<:Any,<:Transpose}) = transpose(transpose(A) \ u.parent)
 end
+
+# Cube root of a 2x2 real-valued matrix with complex conjugate eigenvalues and equal diagonal values.
+# Reference [1]: Smith, M. I. (2003). A Schur Algorithm for Computing Matrix pth Roots.
+#   SIAM Journal on Matrix Analysis and Applications (Vol. 24, Issue 4, pp. 971–989).
+#   https://doi.org/10.1137/s0895479801392697
+function _cbrt_2x2!(A::AbstractMatrix{T}) where {T<:Real}
+    @assert checksquare(A) == 2
+    @inbounds begin
+        (A[1,1] == A[2,2]) || throw(ArgumentError("_cbrt_2x2!: Matrix A must have equal diagonal values."))
+        (A[1,2]*A[2,1] < 0) || throw(ArgumentError("_cbrt_2x2!: Matrix A must have complex conjugate eigenvalues."))
+        μ = sqrt(-A[1,2]*A[2,1])
+        r = cbrt(hypot(A[1,1], μ))
+        θ = atan(μ, A[1,1])
+        s, c = sincos(θ/3)
+        α, β′ = r*c, r*s/µ
+        A[1,1] = α
+        A[2,2] = α
+        A[1,2] = β′*A[1,2]
+        A[2,1] = β′*A[2,1]
+    end
+    return A
+end
+
+# Cube root of a quasi upper triangular matrix (output of Schur decomposition)
+# Reference [1]: Smith, M. I. (2003). A Schur Algorithm for Computing Matrix pth Roots.
+#   SIAM Journal on Matrix Analysis and Applications (Vol. 24, Issue 4, pp. 971–989).
+#   https://doi.org/10.1137/s0895479801392697
+@views function _cbrt_quasi_triu!(A::AbstractMatrix{T}) where {T<:Real}
+    m, n = size(A)
+    (m == n) || throw(ArgumentError("_cbrt_quasi_triu!: Matrix A must be square."))
+    # Cube roots of 1x1 and 2x2 diagonal blocks
+    i = 1
+    sizes = ones(Int,n)
+    S = zeros(T,2,n)
+    while i < n
+        if !iszero(A[i+1,i])
+            _cbrt_2x2!(A[i:i+1,i:i+1])
+            mul!(S[1:2,i:i+1], A[i:i+1,i:i+1], A[i:i+1,i:i+1])
+            sizes[i] = 2
+            sizes[i+1] = 0
+            i += 2
+        else
+            A[i,i] = cbrt(A[i,i])
+            S[1,i] = A[i,i]*A[i,i]
+            i += 1
+        end
+    end
+    if i == n
+        A[n,n] = cbrt(A[n,n])
+        S[1,n] = A[n,n]*A[n,n]
+    end
+    # Algorithm 4.3 in Reference [1]
+    Δ = I(4)
+    M_L₀ = zeros(T,4,4)
+    M_L₁ = zeros(T,4,4)
+    M_Bᵢⱼ⁽⁰⁾ = zeros(T,2,2)
+    M_Bᵢⱼ⁽¹⁾ = zeros(T,2,2)
+    for k = 1:n-1
+        for i = 1:n-k
+            if sizes[i] == 0 || sizes[i+k] == 0 continue end
+            k₁, k₂ = i+1+(sizes[i+1]==0), i+k-1
+            i₁, i₂, j₁, j₂, s₁, s₂ = i, i+sizes[i]-1, i+k, i+k+sizes[i+k]-1, sizes[i], sizes[i+k]
+            L₀ = M_L₀[1:s₁*s₂,1:s₁*s₂]
+            L₁ = M_L₁[1:s₁*s₂,1:s₁*s₂]
+            Bᵢⱼ⁽⁰⁾ = M_Bᵢⱼ⁽⁰⁾[1:s₁, 1:s₂]
+            Bᵢⱼ⁽¹⁾ = M_Bᵢⱼ⁽¹⁾[1:s₁, 1:s₂]
+            # Compute Bᵢⱼ⁽⁰⁾ and Bᵢⱼ⁽¹⁾
+            mul!(Bᵢⱼ⁽⁰⁾, A[i₁:i₂,k₁:k₂], A[k₁:k₂,j₁:j₂])
+            # Retreive Rᵢ,ᵢ₊ₖ as A[i+k,i]'
+            mul!(Bᵢⱼ⁽¹⁾, A[i₁:i₂,k₁:k₂], A[j₁:j₂,k₁:k₂]')
+            # Solve Uᵢ,ᵢ₊ₖ using Reference [1, (4.10)]
+            kron!(L₀, Δ[1:s₂,1:s₂], S[1:s₁,i₁:i₂])
+            L₀ .+= kron!(L₁, A[j₁:j₂,j₁:j₂]', A[i₁:i₂,i₁:i₂])
+            L₀ .+= kron!(L₁, S[1:s₂,j₁:j₂]', Δ[1:s₁,1:s₁])
+            mul!(A[i₁:i₂,j₁:j₂], A[i₁:i₂,i₁:i₂], Bᵢⱼ⁽⁰⁾, -1.0, 1.0)
+            A[i₁:i₂,j₁:j₂] .-= Bᵢⱼ⁽¹⁾
+            ldiv!(lu!(L₀), A[i₁:i₂,j₁:j₂][:])
+            # Compute and store Rᵢ,ᵢ₊ₖ' in A[i+k,i]
+            mul!(Bᵢⱼ⁽⁰⁾, A[i₁:i₂,i₁:i₂], A[i₁:i₂,j₁:j₂], 1.0, 1.0)
+            mul!(Bᵢⱼ⁽⁰⁾, A[i₁:i₂,j₁:j₂], A[j₁:j₂,j₁:j₂], 1.0, 1.0)
+            A[j₁:j₂,i₁:i₂] .= Bᵢⱼ⁽⁰⁾'
+        end
+    end
+    # Make quasi triangular
+    for j=1:n for i=j+1+(sizes[j]==2):n A[i,j] = 0 end end
+    return A
+end
+
+# Cube roots of real-valued triangular matrices
+cbrt(A::UpperTriangular{T}) where {T<:Real} = UpperTriangular(_cbrt_quasi_triu!(Matrix{T}(A)))
+cbrt(A::LowerTriangular{T}) where {T<:Real} = LowerTriangular(_cbrt_quasi_triu!(Matrix{T}(A'))')
diff --git a/stdlib/LinearAlgebra/test/dense.jl b/stdlib/LinearAlgebra/test/dense.jl
index b22c0619abd24..66670f579aa1f 100644
--- a/stdlib/LinearAlgebra/test/dense.jl
+++ b/stdlib/LinearAlgebra/test/dense.jl
@@ -1232,4 +1232,52 @@ Base.:+(x::TypeWithZero, ::TypeWithoutZero) = x
     @test diagm(0 => [TypeWithoutZero()]) isa Matrix{TypeWithZero}
 end
 
+@testset "cbrt(A::AbstractMatrix{T})" begin
+    N = 10
+
+    # Non-square
+    A = randn(N,N+2)
+    @test_throws DimensionMismatch cbrt(A)
+
+    # Real valued diagonal
+    D = Diagonal(randn(N))
+    T = cbrt(D)
+    @test T*T*T ≈ D
+    @test eltype(D) == eltype(T)
+    # Real valued triangular
+    U = UpperTriangular(randn(N,N))
+    T = cbrt(U)
+    @test T*T*T ≈ U
+    @test eltype(U) == eltype(T)
+    L = LowerTriangular(randn(N,N))
+    T = cbrt(L)
+    @test T*T*T ≈ L
+    @test eltype(L) == eltype(T)
+    # Real valued symmetric
+    S =  (A -> (A+A')/2)(randn(N,N))
+    T = cbrt(Symmetric(S,:U))
+    @test T*T*T ≈ S
+    @test eltype(S) == eltype(T)
+    # Real valued symmetric
+    S =  (A -> (A+A')/2)(randn(N,N))
+    T = cbrt(Symmetric(S,:L))
+    @test T*T*T ≈ S
+    @test eltype(S) == eltype(T)
+    # Real valued Hermitian
+    S =  (A -> (A+A')/2)(randn(N,N))
+    T = cbrt(Hermitian(S,:U))
+    @test T*T*T ≈ S
+    @test eltype(S) == eltype(T)
+    # Real valued Hermitian
+    S =  (A -> (A+A')/2)(randn(N,N))
+    T = cbrt(Hermitian(S,:L))
+    @test T*T*T ≈ S
+    @test eltype(S) == eltype(T)
+    # Real valued arbitrary
+    A = randn(N,N)
+    T = cbrt(A)
+    @test T*T*T ≈ A
+    @test eltype(A) == eltype(T)
+end
+
 end # module TestDense

From c1ca0d35dc02478206a6f3733bfb9051b4527067 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 5 Dec 2023 16:29:48 +0530
Subject: [PATCH 0359/1315] Generalize Diagonal * AdjOrTransAbsMat to arbitrary
 element types (#52389)

---
 stdlib/LinearAlgebra/src/diagonal.jl  |  9 ---------
 stdlib/LinearAlgebra/test/diagonal.jl |  8 ++++++++
 test/testhelpers/SizedArrays.jl       | 13 +++++++++++--
 3 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index 4646520ecd1ab..e47b0248fbe53 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -320,15 +320,6 @@ end
 rmul!(A::AbstractMatrix, D::Diagonal) = @inline mul!(A, A, D)
 lmul!(D::Diagonal, B::AbstractVecOrMat) = @inline mul!(B, D, B)
 
-function (*)(A::AdjOrTransAbsMat, D::Diagonal)
-    Ac = copy_similar(A, promote_op(*, eltype(A), eltype(D.diag)))
-    rmul!(Ac, D)
-end
-function (*)(D::Diagonal, A::AdjOrTransAbsMat)
-    Ac = copy_similar(A, promote_op(*, eltype(A), eltype(D.diag)))
-    lmul!(D, Ac)
-end
-
 function __muldiag!(out, D::Diagonal, B, _add::MulAddMul{ais1,bis0}) where {ais1,bis0}
     require_one_based_indexing(out, B)
     alpha, beta = _add.alpha, _add.beta
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index caefc7889a8d6..72c99f742a2f4 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -18,6 +18,9 @@ using .Main.InfiniteArrays
 isdefined(Main, :FillArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "FillArrays.jl"))
 using .Main.FillArrays
 
+isdefined(Main, :SizedArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "SizedArrays.jl"))
+using .Main.SizedArrays
+
 const n=12 # Size of matrix problem to test
 Random.seed!(1)
 
@@ -778,6 +781,11 @@ end
         D = Diagonal(fill(M, n))
         @test D == Matrix{eltype(D)}(D)
     end
+
+    S = SizedArray{(2,3)}(reshape([1:6;],2,3))
+    D = Diagonal(fill(S,3))
+    @test D * fill(S,2,3)' == fill(S * S', 3, 2)
+    @test fill(S,3,2)' * D == fill(S' * S, 2, 3)
 end
 
 @testset "Eigensystem for block diagonal (issue #30681)" begin
diff --git a/test/testhelpers/SizedArrays.jl b/test/testhelpers/SizedArrays.jl
index dfcc5b79f1387..fc2862d844b3f 100644
--- a/test/testhelpers/SizedArrays.jl
+++ b/test/testhelpers/SizedArrays.jl
@@ -9,6 +9,8 @@ module SizedArrays
 
 import Base: +, *, ==
 
+using LinearAlgebra
+
 export SizedArray
 
 struct SizedArray{SZ,T,N,A<:AbstractArray} <: AbstractArray{T,N}
@@ -31,9 +33,16 @@ Base.getindex(A::SizedArray, i...) = getindex(A.data, i...)
 Base.zero(::Type{T}) where T <: SizedArray = SizedArray{size(T)}(zeros(eltype(T), size(T)))
 +(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = SizedArray{SZ}(S1.data + S2.data)
 ==(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = S1.data == S2.data
-function *(S1::SizedArray, S2::SizedArray)
+
+const SizedArrayLike = Union{SizedArray, Transpose{<:Any, <:SizedArray}, Adjoint{<:Any, <:SizedArray}}
+
+_data(S::SizedArray) = S.data
+_data(T::Transpose{<:Any, <:SizedArray}) = transpose(_data(parent(T)))
+_data(T::Adjoint{<:Any, <:SizedArray}) = adjoint(_data(parent(T)))
+
+function *(S1::SizedArrayLike, S2::SizedArrayLike)
     0 < ndims(S1) < 3 && 0 < ndims(S2) < 3 && size(S1, 2) == size(S2, 1) || throw(ArgumentError("size mismatch!"))
-    data = S1.data * S2.data
+    data = _data(S1) * _data(S2)
     SZ = ndims(data) == 1 ? (size(S1, 1), ) : (size(S1, 1), size(S2, 2))
     SizedArray{SZ}(data)
 end

From 705564413cad1e6d6835bab6c407b69437c63d8f Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 5 Dec 2023 18:29:58 +0530
Subject: [PATCH 0360/1315] Unalias off-diagonals in Tridiagonal constructor
 (#51763)

---
 stdlib/LinearAlgebra/src/lu.jl       |  3 ---
 stdlib/LinearAlgebra/src/tridiag.jl  | 11 ++++++-----
 stdlib/LinearAlgebra/test/lu.jl      |  4 +++-
 stdlib/LinearAlgebra/test/tridiag.jl | 10 +++++++++-
 4 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/lu.jl b/stdlib/LinearAlgebra/src/lu.jl
index 4afb855117c14..25e32a8ab0828 100644
--- a/stdlib/LinearAlgebra/src/lu.jl
+++ b/stdlib/LinearAlgebra/src/lu.jl
@@ -520,9 +520,6 @@ end
 
     # Initialize variables
     info = 0
-    if dl === du
-        throw(ArgumentError("off-diagonals must not alias"))
-    end
     fill!(du2, 0)
 
     @inbounds begin
diff --git a/stdlib/LinearAlgebra/src/tridiag.jl b/stdlib/LinearAlgebra/src/tridiag.jl
index d71519cfa5365..235fa5636877a 100644
--- a/stdlib/LinearAlgebra/src/tridiag.jl
+++ b/stdlib/LinearAlgebra/src/tridiag.jl
@@ -472,13 +472,13 @@ struct Tridiagonal{T,V<:AbstractVector{T}} <: AbstractMatrix{T}
                 "lengths of subdiagonal, diagonal and superdiagonal: ",
                 "($(length(dl)), $(length(d)), $(length(du)))")))
         end
-        new{T,V}(dl, d, du)
+        new{T,V}(dl, d, Base.unalias(dl, du))
     end
     # constructor used in lu!
     function Tridiagonal{T,V}(dl, d, du, du2) where {T,V<:AbstractVector{T}}
         require_one_based_indexing(dl, d, du, du2)
         # length checks?
-        new{T,V}(dl, d, du, du2)
+        new{T,V}(dl, d, Base.unalias(dl, du), du2)
     end
 end
 
@@ -491,6 +491,10 @@ solvers, but may be converted into a regular matrix with
 [`convert(Array, _)`](@ref) (or `Array(_)` for short).
 The lengths of `dl` and `du` must be one less than the length of `d`.
 
+!!! note
+    The subdiagonal `dl` and the superdiagonal `du` must not be aliased to each other.
+    If aliasing is detected, the constructor will use a copy of `du` as its argument.
+
 # Examples
 ```jldoctest
 julia> dl = [1, 2, 3];
@@ -912,9 +916,6 @@ function ldiv!(A::Tridiagonal, B::AbstractVecOrMat)
     dl = A.dl
     d = A.d
     du = A.du
-    if dl === du
-        throw(ArgumentError("off-diagonals of `A` must not alias"))
-    end
 
     @inbounds begin
         for i in 1:n-1
diff --git a/stdlib/LinearAlgebra/test/lu.jl b/stdlib/LinearAlgebra/test/lu.jl
index 2facbc55c8aff..d96510549caa5 100644
--- a/stdlib/LinearAlgebra/test/lu.jl
+++ b/stdlib/LinearAlgebra/test/lu.jl
@@ -97,7 +97,9 @@ dimg  = randn(n)/2
             dlu = convert.(eltya, [1, 1])
             dia = convert.(eltya, [-2, -2, -2])
             tri = Tridiagonal(dlu, dia, dlu)
-            @test_throws ArgumentError lu!(tri)
+            L = lu(tri)
+            @test lu!(tri) == L
+            @test UpperTriangular(tri) == L.U
         end
     end
     @testset for eltyb in (Float32, Float64, ComplexF32, ComplexF64, Int)
diff --git a/stdlib/LinearAlgebra/test/tridiag.jl b/stdlib/LinearAlgebra/test/tridiag.jl
index 68a792b55d396..2d846683e38c3 100644
--- a/stdlib/LinearAlgebra/test/tridiag.jl
+++ b/stdlib/LinearAlgebra/test/tridiag.jl
@@ -82,7 +82,7 @@ end
             @test TT == Matrix(TT)
             @test TT.dl === y
             @test TT.d  === x
-            @test TT.du === y
+            @test TT.du == y
             @test typeof(TT)(TT) === TT
         end
         ST = SymTridiagonal{elty}([1,2,3,4], [1,2,3])
@@ -521,6 +521,14 @@ end
     @test Tridiagonal(4:5, 1:3, 1:2) == [1 1 0; 4 2 2; 0 5 3]
 end
 
+@testset "Prevent off-diagonal aliasing in Tridiagonal" begin
+    e = ones(4)
+    f = e[1:end-1]
+    T = Tridiagonal(f, 2e, f)
+    T ./= 10
+    @test all(==(0.1), f)
+end
+
 @testset "Issue #26994 (and the empty case)" begin
     T = SymTridiagonal([1.0],[3.0])
     x = ones(1)

From 9c6fec13ed3a106a4c1e30d07d55eaa3701b5a59 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Tue, 5 Dec 2023 08:39:06 -0600
Subject: [PATCH 0361/1315] Add Zulip to README (#52403)

As
[suggested](https://github.com/JuliaLang/www.julialang.org/pull/1982#issuecomment-1839772373)
by @jariji

Placing it above Slack because

- Zulip does not eat messages (the slackhole is a drain of community
resources, esp. on the #helpdesk channel)
- Zulip is FOSS
- Zulip is a wee bit more feature complete (this is debatable, but I
hold it to be true)
---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index add11e8cef44b..6fa264c57ac21 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,7 @@ and installing Julia, below.
 - **Documentation:** <https://docs.julialang.org>
 - **Packages:** <https://julialang.org/packages/>
 - **Discussion forum:** <https://discourse.julialang.org>
+- **Zulip:** <https://julialang.zulipchat.com/>
 - **Slack:** <https://julialang.slack.com> (get an invite from <https://julialang.org/slack/>)
 - **YouTube:** <https://www.youtube.com/user/JuliaLanguage>
 - **Code coverage:** <https://coveralls.io/r/JuliaLang/julia>

From 28b252a30f0cf4c6469dc67bd0262fd740032a4b Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 5 Dec 2023 20:24:21 +0530
Subject: [PATCH 0362/1315] Remove confusing `::AdjointAbsVec *
 ::AdjointAbsVec` methods (#52401)

These methods presumably exist to throw an error at the top-level,
rather than after the arrays have been unwrapped. However, the error
message is confusingly incorrect:
```julia
julia> x = [1]';

julia> x isa Adjoint{T, <:AbstractVector} where T
true

julia> x * x
ERROR: MethodError: no method matching *(::LinearAlgebra.Adjoint{Int64, Vector{Int64}}, ::LinearAlgebra.Adjoint{Int64, Vector{Int64}})

Closest candidates are:
  *(::LinearAlgebra.Adjoint{T, <:AbstractVector} where T, ::LinearAlgebra.Adjoint{T, <:AbstractVector} where T)
   @ LinearAlgebra ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/adjtrans.jl:481
  *(::LinearAlgebra.Adjoint{T, <:AbstractVector} where T, ::AbstractMatrix)
   @ LinearAlgebra ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/matmul.jl:87
  *(::AbstractMatrix, ::AbstractMatrix, ::Number, ::Number)
   @ LinearAlgebra ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/matmul.jl:1084
  ...

Stacktrace:
 [1] *(u::LinearAlgebra.Adjoint{Int64, Vector{Int64}}, v::LinearAlgebra.Adjoint{Int64, Vector{Int64}})
   @ LinearAlgebra ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/adjtrans.jl:481
 [2] top-level scope
   @ REPL[2]:1
```
Note that the first suggested method is the one that we're hitting,
except this is throwing a `MethodError` again, which makes it seem like
there is no match. We may potentially change this from a `MethodError`
to a different type (perhaps `ArgumentError`), but perhaps this method
is not necessary anyway? After this PR, we obtain
```julia
julia> x * x
ERROR: MethodError: no method matching *(::Vector{Int64}, ::Vector{Int64})

Closest candidates are:
  *(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:595
  *(::Dates.Period, ::AbstractArray)
   @ Dates ~/julia/usr/share/julia/stdlib/v1.11/Dates/src/periods.jl:93
  *(::Number, ::AbstractArray)
   @ Base arraymath.jl:21
  ...

Stacktrace:
 [1] *(x::Adjoint{Int64, Vector{Int64}}, A::Adjoint{Int64, Vector{Int64}})
   @ LinearAlgebra ~/julia/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/matmul.jl:87
 [2] top-level scope
   @ REPL[9]:1
```
This makes it clear that the real issue is that we can't multiply two
vectors.
---
 stdlib/LinearAlgebra/src/adjtrans.jl | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/adjtrans.jl b/stdlib/LinearAlgebra/src/adjtrans.jl
index 3df9e3e151f25..3f274e54d13c8 100644
--- a/stdlib/LinearAlgebra/src/adjtrans.jl
+++ b/stdlib/LinearAlgebra/src/adjtrans.jl
@@ -476,10 +476,6 @@ end
 
 # vector * Adjoint/Transpose-vector
 *(u::AbstractVector, v::AdjOrTransAbsVec) = broadcast(*, u, v)
-# Adjoint/Transpose-vector * Adjoint/Transpose-vector
-# (necessary for disambiguation with fallback methods in linalg/matmul)
-*(u::AdjointAbsVec, v::AdjointAbsVec) = throw(MethodError(*, (u, v)))
-*(u::TransposeAbsVec, v::TransposeAbsVec) = throw(MethodError(*, (u, v)))
 
 # AdjOrTransAbsVec{<:Any,<:AdjOrTransAbsVec} is a lazy conj vectors
 # We need to expand the combinations to avoid ambiguities

From d0e7ec09bb77279b9eb56683197ead5fbe058bc5 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 5 Dec 2023 20:24:41 +0530
Subject: [PATCH 0363/1315] Adjoint for vectors may use trailing axes of the
 parent (#52379)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Close #52373, or at least the part that may be addressed here. After
this, the first axis for an `Adjoint(parent::AbstractVector)` will be
the second axis of the `parent`. This will change the type of the axis
where the parent array type specializes `axes(A, d)`. In the short term,
this would improve type-stability in cases such as
```julia
julia> A = OffsetArray([1,2], 2);

julia> @code_typed axes(A')[1]
CodeInfo(
1 ─ %1 = $(Expr(:boundscheck))::Bool
│   %2 = Base.getfield(t, i, %1)::OffsetArrays.IdOffsetRange{Int64, Base.OneTo{Int64}}
└──      return %2
) => OffsetArrays.IdOffsetRange{Int64, Base.OneTo{Int64}}
```
where the result is now concretely inferred instead of being a small
`Union`.
In principle, with
https://github.com/JuliaArrays/StaticArrays.jl/pull/916, this would make
the axes of the adjoint of a `StaticVector` statically sized.
---
 stdlib/LinearAlgebra/src/adjtrans.jl  | 2 +-
 stdlib/LinearAlgebra/test/adjtrans.jl | 9 ++++++++-
 test/offsetarray.jl                   | 3 ++-
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/adjtrans.jl b/stdlib/LinearAlgebra/src/adjtrans.jl
index 3f274e54d13c8..5ad678e82f014 100644
--- a/stdlib/LinearAlgebra/src/adjtrans.jl
+++ b/stdlib/LinearAlgebra/src/adjtrans.jl
@@ -324,7 +324,7 @@ axes(A::AdjOrTrans) = reverse(axes(A.parent))
 length(A::AdjOrTrans) = length(A.parent)
 size(v::AdjOrTransAbsVec) = (1, length(v.parent))
 size(A::AdjOrTransAbsMat) = reverse(size(A.parent))
-axes(v::AdjOrTransAbsVec) = (Base.OneTo(1), axes(v.parent)...)
+axes(v::AdjOrTransAbsVec) = (axes(v.parent,2), axes(v.parent)...)
 axes(A::AdjOrTransAbsMat) = reverse(axes(A.parent))
 IndexStyle(::Type{<:AdjOrTransAbsVec}) = IndexLinear()
 IndexStyle(::Type{<:AdjOrTransAbsMat}) = IndexCartesian()
diff --git a/stdlib/LinearAlgebra/test/adjtrans.jl b/stdlib/LinearAlgebra/test/adjtrans.jl
index ccd93c97d440e..2c533af37f912 100644
--- a/stdlib/LinearAlgebra/test/adjtrans.jl
+++ b/stdlib/LinearAlgebra/test/adjtrans.jl
@@ -6,6 +6,9 @@ using Test, LinearAlgebra
 
 const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
 
+isdefined(Main, :OffsetArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "OffsetArrays.jl"))
+using .Main.OffsetArrays
+
 @testset "Adjoint and Transpose inner constructor basics" begin
     intvec, intmat = [1, 2], [1 2; 3 4]
     # Adjoint/Transpose eltype must match the type of the Adjoint/Transpose of the input eltype
@@ -87,11 +90,15 @@ end
         @test size(Transpose(intvec)) == (1, length(intvec))
         @test size(Transpose(intmat)) == reverse(size(intmat))
     end
-    @testset "indices methods" begin
+    @testset "axes methods" begin
         @test axes(Adjoint(intvec)) == (Base.OneTo(1), Base.OneTo(length(intvec)))
         @test axes(Adjoint(intmat)) == reverse(axes(intmat))
         @test axes(Transpose(intvec)) == (Base.OneTo(1), Base.OneTo(length(intvec)))
         @test axes(Transpose(intmat)) == reverse(axes(intmat))
+
+        A = OffsetArray([1,2], 2)
+        @test (@inferred axes(A')[2]) === axes(A,1)
+        @test (@inferred axes(A')[1]) === axes(A,2)
     end
     @testset "IndexStyle methods" begin
         @test IndexStyle(Adjoint(intvec)) == IndexLinear()
diff --git a/test/offsetarray.jl b/test/offsetarray.jl
index 7f415c9cc7337..e2924ac0a8ca4 100644
--- a/test/offsetarray.jl
+++ b/test/offsetarray.jl
@@ -403,7 +403,8 @@ v2 = copy(v)
 v = OffsetArray(v0, (-3,))
 @test lastindex(v) == 1
 @test v ≈ v
-@test axes(v') === (Base.OneTo(1), OffsetArrays.IdOffsetRange(Base.OneTo(4), -3))
+@test (@inferred axes(v')[1]) === OffsetArrays.IdOffsetRange(Base.OneTo(1))
+@test (@inferred axes(v')[2]) === OffsetArrays.IdOffsetRange(Base.OneTo(4), -3)
 @test parent(v) == collect(v)
 rv = reverse(v)
 @test axes(rv) == axes(v)

From e0d9cb25d04ddd39e4468f27fa9e298fc9f8b76a Mon Sep 17 00:00:00 2001
From: Morten Piibeleht <morten.piibeleht@juliahub.com>
Date: Wed, 6 Dec 2023 03:55:24 +1300
Subject: [PATCH 0364/1315] Update Documenter 0.27.23 => 1.2.1 (#47105)

Currently mainly to test a few things on CI here, but will update this
to an actual PR once 0.28.0 is out.

---------

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 doc/Manifest.toml              | 177 ++++++++++++++++++++++++++++++---
 doc/make.jl                    |  67 ++++++++++++-
 stdlib/Dates/docs/src/index.md |   4 -
 3 files changed, 231 insertions(+), 17 deletions(-)

diff --git a/doc/Manifest.toml b/doc/Manifest.toml
index 31eb3634fa709..3e973e043f60a 100644
--- a/doc/Manifest.toml
+++ b/doc/Manifest.toml
@@ -9,47 +9,109 @@ git-tree-sha1 = "574baf8110975760d391c710b6341da1afa48d8c"
 uuid = "a4c015fc-c6ff-483c-b24f-f7ea428134e9"
 version = "0.0.1"
 
+[[deps.AbstractTrees]]
+git-tree-sha1 = "faa260e4cb5aba097a73fab382dd4b5819d8ec8c"
+uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
+version = "0.4.4"
+
+[[deps.ArgTools]]
+uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"
+version = "1.1.1"
+
 [[deps.Artifacts]]
 uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
+version = "1.11.0"
 
 [[deps.Base64]]
 uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+version = "1.11.0"
 
 [[deps.Dates]]
 deps = ["Printf"]
 uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
+version = "1.11.0"
 
 [[deps.DocStringExtensions]]
 deps = ["LibGit2"]
-git-tree-sha1 = "5158c2b41018c5f7eb1470d558127ac274eca0c9"
+git-tree-sha1 = "2fb1e02f2b635d0845df5d7c167fec4dd739b00d"
 uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
-version = "0.9.1"
+version = "0.9.3"
 
 [[deps.Documenter]]
-deps = ["ANSIColoredPrinters", "Base64", "Dates", "DocStringExtensions", "IOCapture", "InteractiveUtils", "JSON", "LibGit2", "Logging", "Markdown", "REPL", "Test", "Unicode"]
-git-tree-sha1 = "6030186b00a38e9d0434518627426570aac2ef95"
+deps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "LibGit2", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "Test", "Unicode"]
+git-tree-sha1 = "2613dbec8f4748273bbe30ba71fd5cb369966bac"
 uuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
-version = "0.27.23"
+version = "1.2.1"
+
+[[deps.Downloads]]
+deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"]
+uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
+version = "1.6.0"
+
+[[deps.Expat_jll]]
+deps = ["Artifacts", "JLLWrappers", "Libdl"]
+git-tree-sha1 = "4558ab818dcceaab612d1bb8c19cee87eda2b83c"
+uuid = "2e619515-83b5-522b-bb60-26c02a35a201"
+version = "2.5.0+0"
+
+[[deps.FileWatching]]
+uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"
+version = "1.11.0"
+
+[[deps.Git]]
+deps = ["Git_jll"]
+git-tree-sha1 = "51764e6c2e84c37055e846c516e9015b4a291c7d"
+uuid = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2"
+version = "1.3.0"
+
+[[deps.Git_jll]]
+deps = ["Artifacts", "Expat_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "Libiconv_jll", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"]
+git-tree-sha1 = "bb8f7cc77ec1152414b2af6db533d9471cfbb2d1"
+uuid = "f8c6e375-362e-5223-8a59-34ff63f689eb"
+version = "2.42.0+0"
 
 [[deps.IOCapture]]
 deps = ["Logging", "Random"]
-git-tree-sha1 = "f7be53659ab06ddc986428d3a9dcc95f6fa6705a"
+git-tree-sha1 = "d75853a0bdbfb1ac815478bacd89cd27b550ace6"
 uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89"
-version = "0.2.2"
+version = "0.2.3"
 
 [[deps.InteractiveUtils]]
 deps = ["Markdown"]
 uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+version = "1.11.0"
+
+[[deps.JLLWrappers]]
+deps = ["Artifacts", "Preferences"]
+git-tree-sha1 = "7e5d6779a1e09a36db2a7b6cff50942a0a7d0fca"
+uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
+version = "1.5.0"
 
 [[deps.JSON]]
 deps = ["Dates", "Mmap", "Parsers", "Unicode"]
-git-tree-sha1 = "3c837543ddb02250ef42f4738347454f95079d4e"
+git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a"
 uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
-version = "0.21.3"
+version = "0.21.4"
+
+[[deps.LazilyInitializedFields]]
+git-tree-sha1 = "8f7f3cabab0fd1800699663533b6d5cb3fc0e612"
+uuid = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf"
+version = "1.2.2"
+
+[[deps.LibCURL]]
+deps = ["LibCURL_jll", "MozillaCACerts_jll"]
+uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"
+version = "0.6.4"
+
+[[deps.LibCURL_jll]]
+deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
+uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
+version = "8.4.0+0"
 
 [[deps.LibGit2]]
 deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"]
 uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
+version = "1.11.0"
 
 [[deps.LibGit2_jll]]
 deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"]
@@ -63,13 +125,28 @@ version = "1.11.0+1"
 
 [[deps.Libdl]]
 uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+version = "1.11.0"
+
+[[deps.Libiconv_jll]]
+deps = ["Artifacts", "JLLWrappers", "Libdl"]
+git-tree-sha1 = "f9557a255370125b405568f9767d6d195822a175"
+uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531"
+version = "1.17.0+0"
 
 [[deps.Logging]]
 uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
+version = "1.11.0"
 
 [[deps.Markdown]]
 deps = ["Base64"]
 uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
+version = "1.11.0"
+
+[[deps.MarkdownAST]]
+deps = ["AbstractTrees", "Markdown"]
+git-tree-sha1 = "465a70f0fc7d443a00dcdc3267a497397b8a3899"
+uuid = "d0879d2d-cac2-40c8-9cee-1863dc0c7391"
+version = "0.1.2"
 
 [[deps.MbedTLS_jll]]
 deps = ["Artifacts", "Libdl"]
@@ -78,28 +155,70 @@ version = "2.28.2+1"
 
 [[deps.Mmap]]
 uuid = "a63ad114-7e13-5084-954f-fe012c677804"
+version = "1.11.0"
+
+[[deps.MozillaCACerts_jll]]
+uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
+version = "2023.1.10"
 
 [[deps.NetworkOptions]]
 uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
 version = "1.2.0"
 
+[[deps.OpenSSL_jll]]
+deps = ["Artifacts", "JLLWrappers", "Libdl"]
+git-tree-sha1 = "cc6e1927ac521b659af340e0ca45828a3ffc748f"
+uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
+version = "3.0.12+0"
+
+[[deps.PCRE2_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15"
+version = "10.42.0+1"
+
 [[deps.Parsers]]
-deps = ["Dates"]
-git-tree-sha1 = "3d5bf43e3e8b412656404ed9466f1dcbf7c50269"
+deps = ["Dates", "PrecompileTools", "UUIDs"]
+git-tree-sha1 = "a935806434c9d4c506ba941871b327b96d41f2bf"
 uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
-version = "2.4.0"
+version = "2.8.0"
+
+[[deps.Pkg]]
+deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
+uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+version = "1.11.0"
+
+[[deps.PrecompileTools]]
+deps = ["Preferences"]
+git-tree-sha1 = "03b4c25b43cb84cee5c90aa9b5ea0a78fd848d2f"
+uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
+version = "1.2.0"
+
+[[deps.Preferences]]
+deps = ["TOML"]
+git-tree-sha1 = "00805cd429dcb4870060ff49ef443486c262e38e"
+uuid = "21216c6a-2e73-6563-6e65-726566657250"
+version = "1.4.1"
 
 [[deps.Printf]]
 deps = ["Unicode"]
 uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+version = "1.11.0"
 
 [[deps.REPL]]
 deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
 uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+version = "1.11.0"
 
 [[deps.Random]]
 deps = ["SHA"]
 uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+version = "1.11.0"
+
+[[deps.RegistryInstances]]
+deps = ["LazilyInitializedFields", "Pkg", "TOML", "Tar"]
+git-tree-sha1 = "ffd19052caf598b8653b99404058fce14828be51"
+uuid = "2792f1a3-b283-48e8-9a74-f99dce5104f3"
+version = "0.1.0"
 
 [[deps.SHA]]
 uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"
@@ -107,13 +226,47 @@ version = "0.7.0"
 
 [[deps.Serialization]]
 uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+version = "1.11.0"
 
 [[deps.Sockets]]
 uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
+version = "1.11.0"
+
+[[deps.TOML]]
+deps = ["Dates"]
+uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
+version = "1.0.3"
+
+[[deps.Tar]]
+deps = ["ArgTools", "SHA"]
+uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"
+version = "1.10.0"
 
 [[deps.Test]]
 deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
 uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+version = "1.11.0"
+
+[[deps.UUIDs]]
+deps = ["Random", "SHA"]
+uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+version = "1.11.0"
 
 [[deps.Unicode]]
 uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
+version = "1.11.0"
+
+[[deps.Zlib_jll]]
+deps = ["Libdl"]
+uuid = "83775a58-1f1d-513f-b197-d71354ab007a"
+version = "1.2.13+1"
+
+[[deps.nghttp2_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
+version = "1.58.0+0"
+
+[[deps.p7zip_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
+version = "17.4.0+2"
diff --git a/doc/make.jl b/doc/make.jl
index da0fb8242913b..cf266370acb01 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -8,6 +8,7 @@ using Pkg
 Pkg.instantiate()
 
 using Documenter
+import LibGit2
 
 baremodule GenStdLib end
 
@@ -42,6 +43,68 @@ cd(joinpath(@__DIR__, "src")) do
     end
 end
 
+# Because we have standard libraries that are hosted outside of the julia repo,
+# but their docs are included in the manual, we need to populate the remotes argument
+# of makedocs(), to make sure that Documenter knows how to resolve the directories
+# in stdlib/ to the correct remote Git repositories (for source and edit links).
+#
+# This function parses the *.version files in stdlib/, returning a dictionary with
+# all the key-value pairs from those files. *_GIT_URL and *_SHA1 fields are the ones
+# we will actually be interested in.
+function parse_stdlib_version_file(path)
+    values = Dict{String,String}()
+    for line in readlines(path)
+        m = match(r"^([A-Z0-9_]+)\s+:?=\s+(\S+)$", line)
+        if isnothing(m)
+            @warn "Unable to parse line in $(path)" line
+        else
+            values[m[1]] = m[2]
+        end
+    end
+    return values
+end
+# This generates the value that will be passed to the `remotes` argument of makedocs(),
+# by looking through all *.version files in stdlib/.
+documenter_stdlib_remotes = let stdlib_dir = realpath(joinpath(@__DIR__, "..", "stdlib"))
+    # Get a list of all *.version files in stdlib/..
+    version_files = filter(readdir(stdlib_dir)) do fname
+        isfile(joinpath(stdlib_dir, fname)) && endswith(fname, ".version")
+    end
+    # .. and then parse them, each becoming an entry for makedocs's remotes.
+    # The values for each are of the form path => (remote, sha1), where
+    #  - path: the path to the stdlib package's root directory, i.e. "stdlib/$PACKAGE"
+    #  - remote: a Documenter.Remote object, pointing to the Git repository where package is hosted
+    #  - sha1: the SHA1 of the commit that is included with the current Julia version
+    remotes_list = map(version_files) do version_fname
+        package = match(r"(.+)\.version", version_fname)[1]
+        versionfile = parse_stdlib_version_file(joinpath(stdlib_dir, version_fname))
+        # From the (all uppercase) $(package)_GIT_URL and $(package)_SHA1 fields, we'll determine
+        # the necessary information. If this logic happens to fail for some reason for any of the
+        # standard libraries, we'll crash the documentation build, so that it could be fixed.
+        remote = let git_url_key = "$(uppercase(package))_GIT_URL"
+            haskey(versionfile, git_url_key) || error("Missing $(git_url_key) in $version_fname")
+            m = match(LibGit2.GITHUB_REGEX, versionfile[git_url_key])
+            isnothing(m) && error("Unable to parse $(git_url_key)='$(versionfile[git_url_key])' in $version_fname")
+            Documenter.Remotes.GitHub(m[2], m[3])
+        end
+        package_sha = let sha_key = "$(uppercase(package))_SHA1"
+            haskey(versionfile, sha_key) || error("Missing $(sha_key) in $version_fname")
+            versionfile[sha_key]
+        end
+        # Construct the absolute (local) path to the stdlib package's root directory
+        package_root_dir = joinpath(stdlib_dir, "$(package)-$(package_sha)")
+        # Documenter needs package_root_dir to exist --- it's just a sanity check it does on the remotes= keyword.
+        # In normal (local) builds, this will be the case, since the Makefiles will have unpacked the standard
+        # libraries. However, on CI we do this thing where we actually build docs in a clean worktree, just
+        # unpacking the `usr/` directory from the main build, and the unpacked stdlibs will be missing, and this
+        # will cause Documenter to throw an error. However, we don't _actually_ need the source files of the standard
+        # libraries to be present, so we just generate empty root directories to satisfy the check in Documenter.
+        isdir(package_root_dir) || mkpath(package_root_dir)
+        package_root_dir => (remote, package_sha)
+    end
+    Dict(remotes_list)
+end
+
 # Check if we are building a PDF
 const render_pdf = "pdf" in ARGS
 
@@ -299,6 +362,8 @@ else
         collapselevel = 1,
         sidebar_sitename = false,
         ansicolor = true,
+        size_threshold = 800 * 2^10, # 800 KiB
+        size_threshold_warn = 200 * 2^10, # the manual has quite a few large pages, so we warn at 200+ KiB only
     )
 end
 
@@ -310,12 +375,12 @@ makedocs(
     doctest   = ("doctest=fix" in ARGS) ? (:fix) : ("doctest=only" in ARGS) ? (:only) : ("doctest=true" in ARGS) ? true : false,
     linkcheck = "linkcheck=true" in ARGS,
     linkcheck_ignore = ["https://bugs.kde.org/show_bug.cgi?id=136779"], # fails to load from nanosoldier?
-    strict    = true,
     checkdocs = :none,
     format    = format,
     sitename  = "The Julia Language",
     authors   = "The Julia Project",
     pages     = PAGES,
+    remotes   = documenter_stdlib_remotes,
 )
 
 # Update URLs to external stdlibs (JuliaLang/julia#43199)
diff --git a/stdlib/Dates/docs/src/index.md b/stdlib/Dates/docs/src/index.md
index 5d3fe4fd50f00..db452b1912a27 100644
--- a/stdlib/Dates/docs/src/index.md
+++ b/stdlib/Dates/docs/src/index.md
@@ -1,7 +1,3 @@
-```@meta
-EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Dates/docs/src/index.md"
-```
-
 # Dates
 
 ```@meta

From dcf08befeaabdb185ac9ec94efea7e2ae9d2c1d6 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 5 Dec 2023 20:33:12 +0530
Subject: [PATCH 0365/1315] Declare hermitian/hermitian_type to be public
 (#52388)

Similarly, for `symmetric/symmetric_type`. These are meant to be
specialized by custom types, so these should not be marked internal to
`LinearAlgebra`.
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index a1aebdd92b4e7..cad58bdc0ef38 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -163,7 +163,11 @@ export
     I
 
 # not exported, but public names
-public AbstractTriangular
+public AbstractTriangular,
+        hermitian,
+        hermitian_type,
+        symmetric,
+        symmetric_type
 
 const BlasFloat = Union{Float64,Float32,ComplexF64,ComplexF32}
 const BlasReal = Union{Float64,Float32}

From 2ef056a139d5fdc9d3a9aa9e5051a0127c9bdf7a Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Tue, 5 Dec 2023 16:39:51 +0100
Subject: [PATCH 0366/1315] Simplify triangular multiplication code slightly
 (#52393)

---
 stdlib/LinearAlgebra/src/triangular.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 9252350336b02..6d703b2436b23 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -703,9 +703,9 @@ mul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractTriangular) = _trimul!
 _trimul!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVector) =
     lmul!(A, copyto!(C, B))
 _trimul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractMatrix) =
-    lmul!(A, inplace_adj_or_trans(B)(C, _unwrap_at(B)))
+    lmul!(A, copyto!(C, B))
 _trimul!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractTriangular) =
-    rmul!(inplace_adj_or_trans(A)(C, _unwrap_at(A)), B)
+    rmul!(copyto!(C, A), B)
 _trimul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractTriangular) =
     lmul!(A, copyto!(C, B))
 # redirect for UpperOrLowerTriangular
@@ -752,9 +752,9 @@ end
 ldiv!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = _ldiv!(C, A, B)
 # generic fallback for AbstractTriangular, directs to 2-arg [l/r]div!
 _ldiv!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) =
-    ldiv!(A, inplace_adj_or_trans(B)(C, _unwrap_at(B)))
+    ldiv!(A, copyto!(C, B))
 _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractTriangular) =
-    rdiv!(inplace_adj_or_trans(A)(C, _unwrap_at(A)), B)
+    rdiv!(copyto!(C, A), B)
 # redirect for UpperOrLowerTriangular to generic_*div!
 _ldiv!(C::AbstractVecOrMat, A::UpperOrLowerTriangular, B::AbstractVecOrMat) =
     generic_trimatdiv!(C, uplo_char(A), isunit_char(A), wrapperop(parent(A)), _unwrap_at(parent(A)), B)

From e26c257b28ec6285c8687aef466b64f9ce23c3c7 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Tue, 5 Dec 2023 13:47:15 -0300
Subject: [PATCH 0367/1315] GC scheduler refinements (#52294)

Supersedes https://github.com/JuliaLang/julia/pull/51061 and
https://github.com/JuliaLang/julia/pull/51414.

Still needs more perf analysis.
---
 src/gc.c | 117 +++++++++++++++++++++++++++++++++++++++++++++++--------
 src/gc.h |  15 +------
 2 files changed, 102 insertions(+), 30 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 904566cdf8d14..809e254bdadc7 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -31,6 +31,8 @@ uv_mutex_t gc_threads_lock;
 uv_cond_t gc_threads_cond;
 // To indicate whether concurrent sweeping should run
 uv_sem_t gc_sweep_assists_needed;
+// Mutex used to coordinate entry of GC threads in the mark loop
+uv_mutex_t gc_queue_observer_lock;
 
 // Linked list of callback functions
 
@@ -2857,8 +2859,10 @@ void gc_mark_and_steal(jl_ptls_t ptls)
     jl_gc_markqueue_t *mq = &ptls->mark_queue;
     jl_gc_markqueue_t *mq_master = NULL;
     int master_tid = jl_atomic_load(&gc_master_tid);
-    if (master_tid != -1)
-        mq_master = &gc_all_tls_states[master_tid]->mark_queue;
+    if (master_tid == -1) {
+        return;
+    }
+    mq_master = &gc_all_tls_states[master_tid]->mark_queue;
     void *new_obj;
     jl_gc_chunk_t c;
     pop : {
@@ -2933,28 +2937,108 @@ void gc_mark_and_steal(jl_ptls_t ptls)
     }
 }
 
+size_t gc_count_work_in_queue(jl_ptls_t ptls) JL_NOTSAFEPOINT
+{
+    // assume each chunk is worth 256 units of work and each pointer
+    // is worth 1 unit of work
+    size_t work = 256 * (jl_atomic_load_relaxed(&ptls->mark_queue.chunk_queue.bottom) -
+        jl_atomic_load_relaxed(&ptls->mark_queue.chunk_queue.top));
+    work += (jl_atomic_load_relaxed(&ptls->mark_queue.ptr_queue.bottom) -
+        jl_atomic_load_relaxed(&ptls->mark_queue.ptr_queue.top));
+    return work;
+}
+
+/**
+ * Correctness argument for the mark-loop termination protocol.
+ *
+ * Safety properties:
+ * - No work items shall be in any thread's queues when `gc_mark_loop_barrier` observes
+ * that `gc_n_threads_marking` is zero.
+ *
+ * - No work item shall be stolen from the master thread (i.e. mutator thread which started
+ * GC and which helped the `jl_n_markthreads` - 1 threads to mark) after
+ * `gc_mark_loop_barrier` observes that `gc_n_threads_marking` is zero. This property is
+ * necessary because we call `gc_mark_loop_serial` after marking the finalizer list in
+ * `_jl_gc_collect`, and want to ensure that we have the serial mark-loop semantics there,
+ * and that no work is stolen from us at that point.
+ *
+ * Proof:
+ * - Suppose the master thread observes that `gc_n_threads_marking` is zero in
+ * `gc_mark_loop_barrier` and there is a work item left in one thread's queue at that point.
+ * Since threads try to steal from all threads' queues, this implies that all threads must
+ * have tried to steal from the queue which still has a work item left, but failed to do so,
+ * which violates the semantics of Chase-Lev's work-stealing queue.
+ *
+ * - Let E1 be the event "master thread writes -1 to gc_master_tid" and E2 be the even
+ * "master thread observes that `gc_n_threads_marking` is zero". Since we're using
+ * sequentially consistent atomics, E1 => E2. Now suppose one thread which is spinning in
+ * `gc_should_mark` tries to enter the mark-loop after E2. In order to do so, it must
+ * increment `gc_n_threads_marking` to 1 in an event E3, and then read `gc_master_tid` in an
+ * event E4. Since we're using sequentially consistent atomics, E3 => E4. Since we observed
+ * `gc_n_threads_marking` as zero in E2, then E2 => E3, and we conclude E1 => E4, so that
+ * the thread which is spinning in `gc_should_mark` must observe that `gc_master_tid` is -1
+ * and therefore won't enter the mark-loop.
+ */
+
+int gc_should_mark(jl_ptls_t ptls)
+{
+    int should_mark = 0;
+    int n_threads_marking = jl_atomic_load(&gc_n_threads_marking);
+    // fast path
+    if (n_threads_marking == 0) {
+        return 0;
+    }
+    uv_mutex_lock(&gc_queue_observer_lock);
+    while (1) {
+        int tid = jl_atomic_load(&gc_master_tid);
+        // fast path
+        if (tid == -1) {
+            break;
+        }
+        n_threads_marking = jl_atomic_load(&gc_n_threads_marking);
+        // fast path
+        if (n_threads_marking == 0) {
+            break;
+        }
+        size_t work = gc_count_work_in_queue(gc_all_tls_states[tid]);
+        for (tid = gc_first_tid; tid < gc_first_tid + jl_n_markthreads; tid++) {
+            work += gc_count_work_in_queue(gc_all_tls_states[tid]);
+        }
+        // if there is a lot of work left, enter the mark loop
+        if (work >= 16 * n_threads_marking) {
+            jl_atomic_fetch_add(&gc_n_threads_marking, 1);
+            should_mark = 1;
+            break;
+        }
+        jl_cpu_pause();
+    }
+    uv_mutex_unlock(&gc_queue_observer_lock);
+    return should_mark;
+}
+
+void gc_wake_all_for_marking(jl_ptls_t ptls)
+{
+    jl_atomic_store(&gc_master_tid, ptls->tid);
+    uv_mutex_lock(&gc_threads_lock);
+    jl_atomic_fetch_add(&gc_n_threads_marking, 1);
+    uv_cond_broadcast(&gc_threads_cond);
+    uv_mutex_unlock(&gc_threads_lock);
+}
+
 void gc_mark_loop_parallel(jl_ptls_t ptls, int master)
 {
-    int backoff = GC_BACKOFF_MIN;
     if (master) {
-        jl_atomic_store(&gc_master_tid, ptls->tid);
-        // Wake threads up and try to do some work
-        uv_mutex_lock(&gc_threads_lock);
-        jl_atomic_fetch_add(&gc_n_threads_marking, 1);
-        uv_cond_broadcast(&gc_threads_cond);
-        uv_mutex_unlock(&gc_threads_lock);
+        gc_wake_all_for_marking(ptls);
         gc_mark_and_steal(ptls);
         jl_atomic_fetch_add(&gc_n_threads_marking, -1);
     }
-    while (jl_atomic_load(&gc_n_threads_marking) > 0) {
-        // Try to become a thief while other threads are marking
-        jl_atomic_fetch_add(&gc_n_threads_marking, 1);
-        if (jl_atomic_load(&gc_master_tid) != -1) {
-            gc_mark_and_steal(ptls);
+    while (1) {
+        int should_mark = gc_should_mark(ptls);
+        if (!should_mark) {
+            break;
         }
+        gc_mark_and_steal(ptls);
         jl_atomic_fetch_add(&gc_n_threads_marking, -1);
-        // Failed to steal
-        gc_backoff(&backoff);
     }
 }
 
@@ -3722,6 +3806,7 @@ void jl_gc_init(void)
     uv_mutex_init(&gc_threads_lock);
     uv_cond_init(&gc_threads_cond);
     uv_sem_init(&gc_sweep_assists_needed, 0);
+    uv_mutex_init(&gc_queue_observer_lock);
 
     jl_gc_init_page();
     jl_gc_debug_init();
diff --git a/src/gc.h b/src/gc.h
index e4facad8efae0..85903469c918e 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -190,25 +190,12 @@ extern jl_gc_page_stack_t global_page_pool_lazily_freed;
 extern jl_gc_page_stack_t global_page_pool_clean;
 extern jl_gc_page_stack_t global_page_pool_freed;
 
-#define GC_BACKOFF_MIN 4
-#define GC_BACKOFF_MAX 12
-
-STATIC_INLINE void gc_backoff(int *i) JL_NOTSAFEPOINT
-{
-    if (*i < GC_BACKOFF_MAX) {
-        (*i)++;
-    }
-    for (int j = 0; j < (1 << *i); j++) {
-        jl_cpu_pause();
-    }
-}
-
 // Lock-free stack implementation taken
 // from Herlihy's "The Art of Multiprocessor Programming"
 // XXX: this is not a general-purpose lock-free stack. We can
 // get away with just using a CAS and not implementing some ABA
 // prevention mechanism since once a node is popped from the
-// `jl_gc_global_page_pool_t`, it may only be pushed back to them
+// `jl_gc_page_stack_t`, it may only be pushed back to them
 // in the sweeping phase, which also doesn't push a node into the
 // same stack after it's popped
 

From fd41af5af8023c1bbaf2a4ead7966a09c891a1eb Mon Sep 17 00:00:00 2001
From: Sam <oceanographerschoice@gmail.com>
Date: Tue, 5 Dec 2023 09:10:25 -0800
Subject: [PATCH 0368/1315] Add logdet and logabsdet methods for
 Symmetric/Hermitian matrices (#51930)

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 stdlib/LinearAlgebra/src/symmetric.jl | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index fbfa613efb5f2..6827a416e7222 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -574,6 +574,12 @@ function _factorize(A::HermOrSym{T}; check::Bool=true) where T
     end
 end
 
+logabsdet(A::RealHermSymComplexHerm) = ((l, s) = logabsdet(_factorize(A; check=false)); return real(l), s)
+logabsdet(A::Symmetric{<:Real}) = logabsdet(_factorize(A; check=false))
+logabsdet(A::Symmetric) = logabsdet(_factorize(A; check=false))
+logdet(A::RealHermSymComplexHerm) = real(logdet(_factorize(A; check=false)))
+logdet(A::Symmetric{<:Real}) = logdet(_factorize(A; check=false))
+logdet(A::Symmetric) = logdet(_factorize(A; check=false))
 det(A::RealHermSymComplexHerm) = real(det(_factorize(A; check=false)))
 det(A::Symmetric{<:Real}) = det(_factorize(A; check=false))
 det(A::Symmetric) = det(_factorize(A; check=false))

From 42094740f8f48213c07d9a807d85f5d24cf6c27f Mon Sep 17 00:00:00 2001
From: jariji <96840304+jariji@users.noreply.github.com>
Date: Tue, 5 Dec 2023 10:24:32 -0800
Subject: [PATCH 0369/1315] Add `Docs.hasdoc` function (#52139)

Add helper method `Docs.hasdoc` to facilitate automated testing of
whether documentation exists.

Closes: https://github.com/JuliaLang/julia/issues/51174.
Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 NEWS.md                         |  1 +
 base/docs/Docs.jl               | 20 ++++++++++++++++++++
 doc/src/manual/documentation.md |  3 +++
 test/docs.jl                    |  7 +++++++
 4 files changed, 31 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index fed308639b9a3..b5dbc894a3aeb 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -70,6 +70,7 @@ New library features
 * `replace(string, pattern...)` now supports an optional `IO` argument to
   write the output to a stream rather than returning a string ([#48625]).
 * `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
+* New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
 
 Standard library changes
 ------------------------
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 4ca384361c4e3..87b4a45c4dc80 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -655,4 +655,24 @@ function parsedoc end
 function apropos end
 function doc end
 
+
+"""
+    Docs.hasdoc(mod::Module, sym::Symbol)::Bool
+
+Return `true` if `sym` in `mod` has a docstring and `false` otherwise.
+"""
+hasdoc(mod::Module, sym::Symbol) = hasdoc(Docs.Binding(mod, sym))
+function hasdoc(binding::Docs.Binding, sig::Type = Union{})
+    # this function is based on the Base.Docs.doc method implemented
+    # in REPL/src/docview.jl.  TODO: refactor and unify these methods.
+    defined(binding) && !isnothing(getdoc(resolve(binding), sig)) && return true
+    for mod in modules
+        dict = meta(mod; autoinit=false)
+        !isnothing(dict) && haskey(dict, binding) && return true
+    end
+    alias = aliasof(binding)
+    return alias == binding ? false : hasdoc(alias, sig)
+end
+
+
 end
diff --git a/doc/src/manual/documentation.md b/doc/src/manual/documentation.md
index 4c724e1deaaeb..169b27ead15f8 100644
--- a/doc/src/manual/documentation.md
+++ b/doc/src/manual/documentation.md
@@ -19,6 +19,9 @@ environments provide a way to access documentation directly:
 - In [Juno](https://junolab.org) using `Ctrl-J, Ctrl-D` will show the documentation for the object
   under the cursor.
 
+
+`Docs.hasdoc(module, name)::Bool` tells whether a name has a docstring.
+
 ## Writing Documentation
 
 Julia enables package developers and users to document functions, types and other objects easily
diff --git a/test/docs.jl b/test/docs.jl
index 401759cd7cdb0..1b26c9670e180 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -69,6 +69,13 @@ $$latex literal$$
 """
 function break_me_docs end
 
+
+# `hasdoc` returns `true` on a name with a docstring.
+@test Docs.hasdoc(Base, :map)
+# `hasdoc` returns `false` on a name without a docstring.
+@test !isdefined(Base, :_this_name_doesnt_exist_) && !Docs.hasdoc(Base, :_this_name_doesnt_exist_)
+@test isdefined(Base, :_typed_vcat) && !Docs.hasdoc(Base, :_typed_vcat)
+
 # issue #11548
 
 module ModuleMacroDoc

From 2949dd5723d0c02dc86f3f44f17e2f410fadc866 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Tue, 5 Dec 2023 17:40:31 -0300
Subject: [PATCH 0370/1315] bugfix: make sure symbol loading from
 Base.gc_page_utilization_data works on linux (#52406)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/timing.jl | 2 +-
 src/gc.c       | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/timing.jl b/base/timing.jl
index 3a5dcf77aab28..472efcd94cb08 100644
--- a/base/timing.jl
+++ b/base/timing.jl
@@ -101,7 +101,7 @@ end
 # must be kept in sync with the value from `src/julia_threads.h``
 const JL_GC_N_MAX_POOLS = 51
 function gc_page_utilization_data()
-    page_utilization_raw = cglobal(:gc_page_utilization_stats, Float64)
+    page_utilization_raw = cglobal(:jl_gc_page_utilization_stats, Float64)
     return Base.unsafe_wrap(Array, page_utilization_raw, JL_GC_N_MAX_POOLS, own=false)
 end
 
diff --git a/src/gc.c b/src/gc.c
index 809e254bdadc7..7089bb12fc347 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1423,7 +1423,7 @@ int jl_gc_classify_pools(size_t sz, int *osize)
 // sweep phase
 
 gc_fragmentation_stat_t gc_page_fragmentation_stats[JL_GC_N_POOLS];
-JL_DLLEXPORT double gc_page_utilization_stats[JL_GC_N_MAX_POOLS];
+JL_DLLEXPORT double jl_gc_page_utilization_stats[JL_GC_N_MAX_POOLS];
 
 STATIC_INLINE void gc_update_page_fragmentation_data(jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT
 {
@@ -1442,7 +1442,7 @@ STATIC_INLINE void gc_dump_page_utilization_data(void) JL_NOTSAFEPOINT
         if (n_pages_allocd != 0) {
             utilization -= ((double)n_freed_objs * (double)jl_gc_sizeclasses[i]) / (double)n_pages_allocd / (double)GC_PAGE_SZ;
         }
-        gc_page_utilization_stats[i] = utilization;
+        jl_gc_page_utilization_stats[i] = utilization;
         jl_atomic_store_relaxed(&stats->n_freed_objs, 0);
         jl_atomic_store_relaxed(&stats->n_pages_allocd, 0);
     }

From f96585b5c9232b0029b93374543f69b30f5757b3 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 6 Dec 2023 14:03:06 +0900
Subject: [PATCH 0371/1315] reflection: refactor `@assume_effects`
 implementation (#52399)

I am working on implementing a support for callsite `@assume_effects`
annotation, and this update is part of the preparation for that goal.
Along this, I've modified the API from `pushmeta!(::Expr, ::Symbol,
args...)` to `pushmeta!(::Expr, ::Union{Symbol,Expr})`. This change
isn't breaking as long as the `args` are empty, which is the case for
most use cases (actually there is only one usage of `pushmeta!` with
non-empty `args` within Julia base). I've verified on JuliaHub, and
there don't appear to be any packages using `pushmeta!` with non-empty
`args`, so there shouldn't be any (big) issues.
---
 base/compiler/compiler.jl |  37 ++++++++++++-
 base/compiler/effects.jl  |  12 ----
 base/deprecated.jl        |  10 +---
 base/expr.jl              | 113 +++++++++++++++++++-------------------
 base/namedtuple.jl        |  28 ++++++----
 doc/src/devdocs/meta.md   |   5 +-
 test/meta.jl              | 105 +++++++++++++++++------------------
 7 files changed, 165 insertions(+), 145 deletions(-)

diff --git a/base/compiler/compiler.jl b/base/compiler/compiler.jl
index b81268215578c..528b8fd97869f 100644
--- a/base/compiler/compiler.jl
+++ b/base/compiler/compiler.jl
@@ -33,9 +33,44 @@ macro _boundscheck() Expr(:boundscheck) end
 convert(::Type{Any}, Core.@nospecialize x) = x
 convert(::Type{T}, x::T) where {T} = x
 
-# mostly used by compiler/methodtable.jl, but also by reflection.jl
+# 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
+struct EffectsOverride
+    consistent::Bool
+    effect_free::Bool
+    nothrow::Bool
+    terminates_globally::Bool
+    terminates_locally::Bool
+    notaskstate::Bool
+    inaccessiblememonly::Bool
+    noub::Bool
+    noub_if_noinbounds::Bool
+end
+function EffectsOverride(
+    override::EffectsOverride =
+        EffectsOverride(false, false, false, false, false, false, false, false, false);
+    consistent::Bool = override.consistent,
+    effect_free::Bool = override.effect_free,
+    nothrow::Bool = override.nothrow,
+    terminates_globally::Bool = override.terminates_globally,
+    terminates_locally::Bool = override.terminates_locally,
+    notaskstate::Bool = override.notaskstate,
+    inaccessiblememonly::Bool = override.inaccessiblememonly,
+    noub::Bool = override.noub,
+    noub_if_noinbounds::Bool = override.noub_if_noinbounds)
+    return EffectsOverride(
+        consistent,
+        effect_free,
+        nothrow,
+        terminates_globally,
+        terminates_locally,
+        notaskstate,
+        inaccessiblememonly,
+        noub,
+        noub_if_noinbounds)
+end
 
 # essential files and libraries
 include("essentials.jl")
diff --git a/base/compiler/effects.jl b/base/compiler/effects.jl
index 9d66407b58eb3..b63cc95b02b9e 100644
--- a/base/compiler/effects.jl
+++ b/base/compiler/effects.jl
@@ -319,18 +319,6 @@ function decode_effects(e::UInt32)
         _Bool((e >> 12) & 0x01))
 end
 
-struct EffectsOverride
-    consistent::Bool
-    effect_free::Bool
-    nothrow::Bool
-    terminates_globally::Bool
-    terminates_locally::Bool
-    notaskstate::Bool
-    inaccessiblememonly::Bool
-    noub::Bool
-    noub_if_noinbounds::Bool
-end
-
 function encode_effects_override(eo::EffectsOverride)
     e = 0x0000
     eo.consistent          && (e |= (0x0001 << 0))
diff --git a/base/deprecated.jl b/base/deprecated.jl
index cfccb35d98bad..5a7ec69979728 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -271,14 +271,10 @@ getindex(match::Core.MethodMatch, field::Int) =
 # these were internal functions, but some packages seem to be relying on them
 tuple_type_head(T::Type) = fieldtype(T, 1)
 tuple_type_cons(::Type, ::Type{Union{}}) = Union{}
-function tuple_type_cons(::Type{S}, ::Type{T}) where T<:Tuple where S
-    @_foldable_meta
+@assume_effects :foldable tuple_type_cons(::Type{S}, ::Type{T}) where T<:Tuple where S =
     Tuple{S, T.parameters...}
-end
-function parameter_upper_bound(t::UnionAll, idx)
-    @_foldable_meta
-    return rewrap_unionall((unwrap_unionall(t)::DataType).parameters[idx], t)
-end
+@assume_effects :foldable parameter_upper_bound(t::UnionAll, idx) =
+    rewrap_unionall((unwrap_unionall(t)::DataType).parameters[idx], t)
 
 # these were internal functions, but some packages seem to be relying on them
 @deprecate cat_shape(dims, shape::Tuple{}, shapes::Tuple...) cat_shape(dims, shapes) false
diff --git a/base/expr.jl b/base/expr.jl
index 755eff1b7c1b8..168cd492b78e4 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -719,64 +719,71 @@ macro assume_effects(args...)
         ex = nothing
         idx = length(args)
     end
-    consistent = effect_free = nothrow = terminates_globally = terminates_locally =
-        notaskstate = inaccessiblememonly = noub = noub_if_noinbounds = false
-    for i in 1:idx
-        org_setting = args[i]
-        (setting, val) = compute_assumed_setting(org_setting)
-        if setting === :consistent
-            consistent = val
-        elseif setting === :effect_free
-            effect_free = val
-        elseif setting === :nothrow
-            nothrow = val
-        elseif setting === :terminates_globally
-            terminates_globally = val
-        elseif setting === :terminates_locally
-            terminates_locally = val
-        elseif setting === :notaskstate
-            notaskstate = val
-        elseif setting === :inaccessiblememonly
-            inaccessiblememonly = val
-        elseif setting === :noub
-            noub = val
-        elseif setting === :noub_if_noinbounds
-            noub_if_noinbounds = val
-        elseif setting === :foldable
-            consistent = effect_free = terminates_globally = noub = val
-        elseif setting === :removable
-            effect_free = nothrow = terminates_globally = val
-        elseif setting === :total
-            consistent = effect_free = nothrow = terminates_globally = notaskstate = inaccessiblememonly = noub = val
-        else
-            throw(ArgumentError("@assume_effects $org_setting not supported"))
-        end
+    override = EffectsOverride()
+    for i = 1:idx
+        setting = args[i]
+        override = compute_assumed_setting(override, setting)
+        override === nothing &&
+            throw(ArgumentError("@assume_effects $setting not supported"))
     end
     if is_function_def(inner)
-        return esc(pushmeta!(ex, :purity,
-            consistent, effect_free, nothrow, terminates_globally, terminates_locally,
-            notaskstate, inaccessiblememonly, noub, noub_if_noinbounds))
+        return esc(pushmeta!(ex, form_purity_expr(override)))
     elseif isexpr(ex, :macrocall) && ex.args[1] === Symbol("@ccall")
         ex.args[1] = GlobalRef(Base, Symbol("@ccall_effects"))
-        insert!(ex.args, 3, Core.Compiler.encode_effects_override(Core.Compiler.EffectsOverride(
-            consistent, effect_free, nothrow, terminates_globally, terminates_locally,
-            notaskstate, inaccessiblememonly, noub, noub_if_noinbounds)))
+        insert!(ex.args, 3, Core.Compiler.encode_effects_override(override))
         return esc(ex)
     else # anonymous function case
-        return Expr(:meta, Expr(:purity,
-            consistent, effect_free, nothrow, terminates_globally, terminates_locally,
-            notaskstate, inaccessiblememonly, noub, noub_if_noinbounds))
+        return Expr(:meta, form_purity_expr(override))
     end
 end
 
-function compute_assumed_setting(@nospecialize(setting), val::Bool=true)
+using Core.Compiler: EffectsOverride
+
+function compute_assumed_setting(override::EffectsOverride, @nospecialize(setting), val::Bool=true)
     if isexpr(setting, :call) && setting.args[1] === :(!)
-        return compute_assumed_setting(setting.args[2], !val)
+        return compute_assumed_setting(override, setting.args[2], !val)
     elseif isa(setting, QuoteNode)
-        return compute_assumed_setting(setting.value, val)
-    else
-        return (setting, val)
+        return compute_assumed_setting(override, setting.value, val)
     end
+    if setting === :consistent
+        return EffectsOverride(override; consistent = val)
+    elseif setting === :effect_free
+        return EffectsOverride(override; effect_free = val)
+    elseif setting === :nothrow
+        return EffectsOverride(override; nothrow = val)
+    elseif setting === :terminates_globally
+        return EffectsOverride(override; terminates_globally = val)
+    elseif setting === :terminates_locally
+        return EffectsOverride(override; terminates_locally = val)
+    elseif setting === :notaskstate
+        return EffectsOverride(override; notaskstate = val)
+    elseif setting === :inaccessiblememonly
+        return EffectsOverride(override; inaccessiblememonly = val)
+    elseif setting === :noub
+        return EffectsOverride(override; noub = val)
+    elseif setting === :noub_if_noinbounds
+        return EffectsOverride(override; noub_if_noinbounds = val)
+    elseif setting === :foldable
+        consistent = effect_free = terminates_globally = noub = val
+        return EffectsOverride(override; consistent, effect_free, terminates_globally, noub)
+    elseif setting === :removable
+        effect_free = nothrow = terminates_globally = val
+        return EffectsOverride(override; effect_free, nothrow, terminates_globally)
+    elseif setting === :total
+        consistent = effect_free = nothrow = terminates_globally = notaskstate =
+            inaccessiblememonly = noub = val
+        return EffectsOverride(override;
+            consistent, effect_free, nothrow, terminates_globally, notaskstate,
+            inaccessiblememonly, noub)
+    end
+    return nothing
+end
+
+function form_purity_expr(override::EffectsOverride)
+    return Expr(:purity,
+        override.consistent, override.effect_free, override.nothrow,
+        override.terminates_globally, override.terminates_locally, override.notaskstate,
+        override.inaccessiblememonly, override.noub, override.noub_if_noinbounds)
 end
 
 """
@@ -850,23 +857,17 @@ function unwrap_macrocalls(ex::Expr)
     return inner
 end
 
-function pushmeta!(ex::Expr, sym::Symbol, args::Any...)
-    if isempty(args)
-        tag = sym
-    else
-        tag = Expr(sym, args...)::Expr
-    end
-
+function pushmeta!(ex::Expr, tag::Union{Symbol,Expr})
     inner = unwrap_macrocalls(ex)
-
     idx, exargs = findmeta(inner)
     if idx != 0
-        push!(exargs[idx].args, tag)
+        metastmt = exargs[idx]::Expr
+        push!(metastmt.args, tag)
     else
         body = inner.args[2]::Expr
         pushfirst!(body.args, Expr(:meta, tag))
     end
-    ex
+    return ex
 end
 
 popmeta!(body, sym) = _getmeta(body, sym, true)
diff --git a/base/namedtuple.jl b/base/namedtuple.jl
index 5863cb462010c..5d9b119b4c38e 100644
--- a/base/namedtuple.jl
+++ b/base/namedtuple.jl
@@ -268,8 +268,9 @@ function map(f, nt::NamedTuple{names}, nts::NamedTuple...) where names
     NamedTuple{names}(map(f, map(Tuple, (nt, nts...))...))
 end
 
-@assume_effects :total function merge_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
-    @nospecialize an bn
+function merge_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
+    @nospecialize
+    @_total_meta
     names = Symbol[an...]
     for n in bn
         if !sym_in(n, an)
@@ -279,15 +280,17 @@ end
     (names...,)
 end
 
-@assume_effects :total function merge_types(names::Tuple{Vararg{Symbol}}, a::Type{<:NamedTuple}, b::Type{<:NamedTuple})
-    @nospecialize names a b
+function merge_types(names::Tuple{Vararg{Symbol}}, a::Type{<:NamedTuple}, b::Type{<:NamedTuple})
+    @nospecialize
+    @_total_meta
     bn = _nt_names(b)
     return Tuple{Any[ fieldtype(sym_in(names[n], bn) ? b : a, names[n]) for n in 1:length(names) ]...}
 end
 
-@assume_effects :foldable function merge_fallback(a::NamedTuple, b::NamedTuple,
-                                                  an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
+function merge_fallback(a::NamedTuple, b::NamedTuple,
+                        an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
     @nospecialize
+    @_foldable_meta
     names = merge_names(an, bn)
     types = merge_types(names, typeof(a), typeof(b))
     n = length(names)
@@ -388,8 +391,9 @@ tail(t::NamedTuple{names}) where names = NamedTuple{tail(names::Tuple)}(t)
 front(t::NamedTuple{names}) where names = NamedTuple{front(names::Tuple)}(t)
 reverse(nt::NamedTuple) = NamedTuple{reverse(keys(nt))}(reverse(values(nt)))
 
-@assume_effects :total function diff_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
-    @nospecialize an bn
+function diff_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
+    @nospecialize
+    @_total_meta
     names = Symbol[]
     for n in an
         if !sym_in(n, bn)
@@ -399,11 +403,15 @@ reverse(nt::NamedTuple) = NamedTuple{reverse(keys(nt))}(reverse(values(nt)))
     (names...,)
 end
 
-@assume_effects :foldable function diff_types(@nospecialize(a::NamedTuple), @nospecialize(names::Tuple{Vararg{Symbol}}))
+function diff_types(a::NamedTuple, names::Tuple{Vararg{Symbol}})
+    @nospecialize
+    @_foldable_meta
     return Tuple{Any[ fieldtype(typeof(a), names[n]) for n in 1:length(names) ]...}
 end
 
-@assume_effects :foldable function diff_fallback(@nospecialize(a::NamedTuple), @nospecialize(an::Tuple{Vararg{Symbol}}), @nospecialize(bn::Tuple{Vararg{Symbol}}))
+function diff_fallback(a::NamedTuple, an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
+    @nospecialize
+    @_foldable_meta
     names = diff_names(an, bn)
     isempty(names) && return (;)
     types = diff_types(a, names)
diff --git a/doc/src/devdocs/meta.md b/doc/src/devdocs/meta.md
index 7a58578b3e53e..726f471c228e0 100644
--- a/doc/src/devdocs/meta.md
+++ b/doc/src/devdocs/meta.md
@@ -34,9 +34,8 @@ quote
 end
 ```
 
-`Base.pushmeta!(ex, :symbol, args...)` appends `:symbol` to the end of the `:meta` expression,
-creating a new `:meta` expression if necessary. If `args` is specified, a nested expression containing
-`:symbol` and these arguments is appended instead, which can be used to specify additional information.
+`Base.pushmeta!(ex, tag::Union{Symbol,Expr})` appends `:tag` to the end of the `:meta` expression,
+creating a new `:meta` expression if necessary.
 
 To use the metadata, you have to parse these `:meta` expressions. If your implementation can be
 performed within Julia, `Base.popmeta!` is very handy: `Base.popmeta!(body, :symbol)` will scan
diff --git a/test/meta.jl b/test/meta.jl
index 856462fedd9fa..be0ecf0cdb827 100644
--- a/test/meta.jl
+++ b/test/meta.jl
@@ -43,77 +43,70 @@ end
 @test foundfunc(h_inlined(), :g_inlined)
 @test foundfunc(h_noinlined(), :g_noinlined)
 
-using Base: pushmeta!, popmeta!
+using Base: popmeta!
 
-macro attach(val, ex)
-    esc(_attach(val, ex))
+macro attach_meta(val, ex)
+    esc(_attach_meta(val, ex))
 end
+_attach_meta(val, ex) = Base.pushmeta!(ex, Expr(:test, val))
 
-_attach(val, ex) = pushmeta!(ex, :test, val)
-
-@attach 42 function dummy()
+@attach_meta 42 function dummy()
     false
 end
-
-asts = code_lowered(dummy, Tuple{})
-@test length(asts) == 1
-ast = asts[1]
-
-body = Expr(:block)
-body.args = ast.code
-
-@test popmeta!(body, :test) == (true, [42])
-@test popmeta!(body, :nonexistent) == (false, [])
+let ast = only(code_lowered(dummy, Tuple{}))
+    body = Expr(:block)
+    body.args = ast.code
+    @test popmeta!(body, :test) == (true, [42])
+    @test popmeta!(body, :nonexistent) == (false, [])
+end
 
 # Simple popmeta!() tests
-ex1 = quote
-    $(Expr(:meta, :foo))
-    x*x+1
+let ex1 = quote
+        $(Expr(:meta, :foo))
+        x*x+1
+    end
+    @test popmeta!(ex1, :foo)[1]
+    @test !popmeta!(ex1, :foo)[1]
+    @test !popmeta!(ex1, :bar)[1]
+    @test !(popmeta!(:(x*x+1), :foo)[1])
 end
-@test popmeta!(ex1, :foo)[1]
-@test !popmeta!(ex1, :foo)[1]
-@test !popmeta!(ex1, :bar)[1]
-@test !(popmeta!(:(x*x+1), :foo)[1])
 
 # Find and pop meta information from general ast locations
-multi_meta = quote
-    $(Expr(:meta, :foo1))
-    y = x
-    $(Expr(:meta, :foo2, :foo3))
-    begin
-        $(Expr(:meta, :foo4, Expr(:foo5, 1, 2)))
+let multi_meta = quote
+        $(Expr(:meta, :foo1))
+        y = x
+        $(Expr(:meta, :foo2, :foo3))
+        begin
+            $(Expr(:meta, :foo4, Expr(:foo5, 1, 2)))
+        end
+        x*x+1
     end
-    x*x+1
-end
-@test popmeta!(deepcopy(multi_meta), :foo1) == (true, [])
-@test popmeta!(deepcopy(multi_meta), :foo2) == (true, [])
-@test popmeta!(deepcopy(multi_meta), :foo3) == (true, [])
-@test popmeta!(deepcopy(multi_meta), :foo4) == (true, [])
-@test popmeta!(deepcopy(multi_meta), :foo5) == (true, [1,2])
-@test popmeta!(deepcopy(multi_meta), :bar)  == (false, [])
-
-# Test that popmeta!() removes meta blocks entirely when they become empty.
-for m in [:foo1, :foo2, :foo3, :foo4, :foo5]
-    @test popmeta!(multi_meta, m)[1]
+    @test popmeta!(deepcopy(multi_meta), :foo1) == (true, [])
+    @test popmeta!(deepcopy(multi_meta), :foo2) == (true, [])
+    @test popmeta!(deepcopy(multi_meta), :foo3) == (true, [])
+    @test popmeta!(deepcopy(multi_meta), :foo4) == (true, [])
+    @test popmeta!(deepcopy(multi_meta), :foo5) == (true, [1,2])
+    @test popmeta!(deepcopy(multi_meta), :bar)  == (false, [])
+
+    # Test that popmeta!() removes meta blocks entirely when they become empty.
+    ast = :(dummy() = $multi_meta)
+    for m in [:foo1, :foo2, :foo3, :foo4, :foo5]
+        @test popmeta!(multi_meta, m)[1]
+    end
+    @test Base.findmeta(ast)[1] == 0
 end
-@test Base.findmeta(multi_meta.args)[1] == 0
 
 # Test that pushmeta! can push across other macros,
 # in the case multiple pushmeta!-based macros are combined
-
-@attach 40 @attach 41 @attach 42 dummy_multi() = return nothing
-
-asts = code_lowered(dummy_multi, Tuple{})
-@test length(asts) == 1
-ast = asts[1]
-
-body = Expr(:block)
-body.args = ast.code
-
-@test popmeta!(body, :test) == (true, [40])
-@test popmeta!(body, :test) == (true, [41])
-@test popmeta!(body, :test) == (true, [42])
-@test popmeta!(body, :nonexistent) == (false, [])
+@attach_meta 40 @attach_meta 41 @attach_meta 42 dummy_multi() = return nothing
+let ast = only(code_lowered(dummy_multi, Tuple{}))
+    body = Expr(:block)
+    body.args = ast.code
+    @test popmeta!(body, :test) == (true, [40])
+    @test popmeta!(body, :test) == (true, [41])
+    @test popmeta!(body, :test) == (true, [42])
+    @test popmeta!(body, :nonexistent) == (false, [])
+end
 
 # tests to fully cover functions in base/meta.jl
 using Base.Meta

From a948e6dc2fdb3123c53c1e7a461cc5838413a880 Mon Sep 17 00:00:00 2001
From: Lionel Zoubritzky <Liozou@users.noreply.github.com>
Date: Wed, 6 Dec 2023 06:10:09 +0100
Subject: [PATCH 0372/1315] Fix completion hint for sub/superscripts (#52402)

Fix #52376

The completion hint starting offset was not computed considering the
case where the input and the completion do not share the same prefix,
which happens when completing into a subscript or a superscript. This
fixes that by iteratively going through the characters of the hint until
reaching that which marks the end of the input.
---
 stdlib/REPL/src/LineEdit.jl | 28 ++++++++++++++++------------
 stdlib/REPL/test/repl.jl    | 11 +++++++++++
 2 files changed, 27 insertions(+), 12 deletions(-)

diff --git a/stdlib/REPL/src/LineEdit.jl b/stdlib/REPL/src/LineEdit.jl
index 2fdeb707043b0..709eeaa2857d0 100644
--- a/stdlib/REPL/src/LineEdit.jl
+++ b/stdlib/REPL/src/LineEdit.jl
@@ -382,23 +382,27 @@ function check_for_hint(s::MIState)
         return clear_hint(st)
     end
     completions, partial, should_complete = complete_line(st.p.complete, st, s.active_module)::Tuple{Vector{String},String,Bool}
+    isempty(completions) && return clear_hint(st)
     # Don't complete for single chars, given e.g. `x` completes to `xor`
     if length(partial) > 1 && should_complete
-        if length(completions) == 1
-            hint = only(completions)[sizeof(partial)+1:end]
-            if !isempty(hint) # completion on a complete name returns itself so check that there's something to hint
+        singlecompletion = length(completions) == 1
+        p = singlecompletion ? completions[1] : common_prefix(completions)
+        if singlecompletion || p in completions # i.e. complete `@time` even though `@time_imports` etc. exists
+            # The completion `p` and the input `partial` may not share the same initial
+            # characters, for instance when completing to subscripts or superscripts.
+            # So, in general, make sure that the hint starts at the correct position by
+            # incrementing its starting position by as many characters as the input.
+            startind = 1 # index of p from which to start providing the hint
+            maxind = ncodeunits(p)
+            for _ in partial
+                startind = nextind(p, startind)
+                startind > maxind && break
+            end
+            if startind ≤ maxind # completion on a complete name returns itself so check that there's something to hint
+                hint = p[startind:end]
                 st.hint = hint
                 return true
             end
-        elseif length(completions) > 1
-            p = common_prefix(completions)
-            if p in completions # i.e. complete `@time` even though `@time_imports` etc. exists
-                hint = p[sizeof(partial)+1:end]
-                if !isempty(hint)
-                    st.hint = hint
-                    return true
-                end
-            end
         end
     end
     return clear_hint(st)
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 0e5f1c5f60c26..7896b589612e3 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -1711,6 +1711,17 @@ fake_repl() do stdin_write, stdout_read, repl
     end
     @test LineEdit.state(repl.mistate).hint === nothing
 
+    # issue #52376
+    write(stdin_write, "\x15")
+    write(stdin_write, "\\_ailuj")
+    while LineEdit.state(repl.mistate).hint !== nothing
+        sleep(0.1)
+    end
+    @test LineEdit.state(repl.mistate).hint === nothing
+    s5 = readuntil(stdout_read, "\\_ailuj")
+    write(stdin_write, "\t")
+    s6 = readuntil(stdout_read, "ₐᵢₗᵤⱼ")
+
     write(stdin_write, "\x15\x04")
     Base.wait(repltask)
 end

From b5abac441dba8b30e042a05654fdb9a28f7b265b Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 6 Dec 2023 00:12:22 -0500
Subject: [PATCH 0373/1315] delete unused code from simplevector (#52412)

Circa #45062 and #46975
---
 src/builtins.c            |  4 +--
 src/ccall.cpp             | 57 ---------------------------------------
 src/codegen.cpp           |  4 +--
 src/gf.c                  |  2 +-
 src/jl_exported_funcs.inc |  1 -
 src/julia_internal.h      |  4 ---
 src/module.c              |  7 ++---
 src/simplevector.c        |  7 -----
 src/staticdata.c          |  2 +-
 src/toplevel.c            |  2 +-
 10 files changed, 11 insertions(+), 79 deletions(-)

diff --git a/src/builtins.c b/src/builtins.c
index 78e66ef190437..5238a9476c9a2 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -998,7 +998,7 @@ static inline size_t get_checked_fieldindex(const char *name, jl_datatype_t *st,
     }
     if (mutabl && jl_field_isconst(st, idx)) {
         jl_errorf("%s: const field .%s of type %s cannot be changed", name,
-                jl_symbol_name((jl_sym_t*)jl_svec_ref(jl_field_names(st), idx)), jl_symbol_name(st->name->name));
+                jl_symbol_name((jl_sym_t*)jl_svecref(jl_field_names(st), idx)), jl_symbol_name(st->name->name));
     }
     return idx;
 }
@@ -1767,7 +1767,7 @@ JL_CALLABLE(jl_f__svec_ref)
     if (idx < 1 || idx > len) {
         jl_bounds_error_int((jl_value_t*)s, idx);
     }
-    return jl_svec_ref(s, idx-1);
+    return jl_svecref(s, idx-1);
 }
 
 static int equiv_field_types(jl_value_t *old, jl_value_t *ft)
diff --git a/src/ccall.cpp b/src/ccall.cpp
index ece0ee24908e8..92ede74402791 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -27,8 +27,6 @@ TRANSFORMED_CCALL_STAT(jl_get_current_task);
 TRANSFORMED_CCALL_STAT(jl_set_next_task);
 TRANSFORMED_CCALL_STAT(jl_sigatomic_begin);
 TRANSFORMED_CCALL_STAT(jl_sigatomic_end);
-TRANSFORMED_CCALL_STAT(jl_svec_len);
-TRANSFORMED_CCALL_STAT(jl_svec_ref);
 TRANSFORMED_CCALL_STAT(jl_string_ptr);
 TRANSFORMED_CCALL_STAT(jl_symbol_name);
 TRANSFORMED_CCALL_STAT(jl_genericmemory_owner);
@@ -1685,61 +1683,6 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         ctx.builder.SetInsertPoint(contBB);
         return ghostValue(ctx, jl_nothing_type);
     }
-    else if (is_libjulia_func(jl_svec_len)) {
-        ++CCALL_STAT(jl_svec_len);
-        assert(!isVa && !llvmcall && nccallargs == 1);
-        const jl_cgval_t &svecv = argv[0];
-        Value *len;
-        if (svecv.constant && svecv.typ == (jl_value_t*)jl_simplevector_type) {
-            // Check the type as well before we call
-            len = ConstantInt::get(ctx.types().T_size, jl_svec_len(svecv.constant));
-        }
-        else {
-            auto ptr = emit_bitcast(ctx, boxed(ctx, svecv), ctx.types().T_size->getPointerTo());
-            setName(ctx.emission_context, ptr, "svec_len_ptr");
-            len = ctx.builder.CreateAlignedLoad(ctx.types().T_size, ptr, ctx.types().alignof_ptr);
-            setName(ctx.emission_context, len, "svec_len");
-            // Only mark with TBAA if we are sure about the type.
-            // This could otherwise be in a dead branch
-            if (svecv.typ == (jl_value_t*)jl_simplevector_type) {
-                jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_const);
-                ai.decorateInst(cast<Instruction>(len));
-            }
-            MDBuilder MDB(ctx.builder.getContext());
-            auto rng = MDB.createRange(
-                Constant::getNullValue(ctx.types().T_size), ConstantInt::get(ctx.types().T_size, INTPTR_MAX / sizeof(void*) - 1));
-            cast<LoadInst>(len)->setMetadata(LLVMContext::MD_range, rng);
-        }
-        JL_GC_POP();
-        return mark_or_box_ccall_result(ctx, len, retboxed, rt, unionall, static_rt);
-    }
-    else if (is_libjulia_func(jl_svec_ref) && argv[1].typ == (jl_value_t*)jl_long_type) {
-        ++CCALL_STAT(jl_svec_ref);
-        assert(lrt == ctx.types().T_prjlvalue);
-        assert(!isVa && !llvmcall && nccallargs == 2);
-        const jl_cgval_t &svecv = argv[0];
-        const jl_cgval_t &idxv = argv[1];
-        Value *idx = emit_unbox(ctx, ctx.types().T_size, idxv, (jl_value_t*)jl_long_type);
-        idx = ctx.builder.CreateAdd(idx, ConstantInt::get(ctx.types().T_size, 1));
-        setName(ctx.emission_context, idx, "svec_idx");
-        auto ptr = emit_bitcast(ctx, boxed(ctx, svecv), ctx.types().T_pprjlvalue);
-        setName(ctx.emission_context, ptr, "svec_data_ptr");
-        Value *slot_addr = ctx.builder.CreateInBoundsGEP(ctx.types().T_prjlvalue,
-                                                         decay_derived(ctx, ptr), idx);
-        setName(ctx.emission_context, slot_addr, "svec_slot_addr");
-        LoadInst *load = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, slot_addr,
-                                                       Align(sizeof(void*)));
-        setName(ctx.emission_context, load, "svec_slot");
-        load->setAtomic(AtomicOrdering::Unordered);
-        // Only mark with TBAA if we are sure about the type.
-        // This could otherwise be in a dead branch
-        if (svecv.typ == (jl_value_t*)jl_simplevector_type) {
-            jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_const);
-            ai.decorateInst(load);
-        }
-        JL_GC_POP();
-        return mark_or_box_ccall_result(ctx, load, retboxed, rt, unionall, static_rt);
-    }
     else if (is_libjulia_func(jl_string_ptr)) {
         ++CCALL_STAT(jl_string_ptr);
         assert(lrt == ctx.types().T_size);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index bc7f30f49626d..53c3561c50039 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -211,7 +211,7 @@ void setNameWithField(jl_codegen_params_t &params, Value *V, std::function<Strin
         } else {
             auto flds = jl_field_names(jt);
             if (idx < jl_svec_len(flds)) {
-                auto name = jl_svec_ref(flds, idx);
+                auto name = jl_svecref(flds, idx);
                 assert(jl_is_symbol(name));
                 V->setName(Twine(GetObjName()) + "." + Twine(jl_symbol_name((jl_sym_t*)name)) + suffix);
                 return;
@@ -3521,7 +3521,7 @@ static bool emit_f_opfield(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                 }
                 else if (jl_field_isconst(uty, idx)) {
                     std::string msg = fname + ": const field ."
-                        + std::string(jl_symbol_name((jl_sym_t*)jl_svec_ref(jl_field_names(uty), idx)))
+                        + std::string(jl_symbol_name((jl_sym_t*)jl_svecref(jl_field_names(uty), idx)))
                         + " of type "
                         + std::string(jl_symbol_name(uty->name->name))
                         + " cannot be changed";
diff --git a/src/gf.c b/src/gf.c
index e5249e18d1d68..ca462c26e6b1b 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -565,7 +565,7 @@ int foreach_mtable_in_module(
 {
     jl_svec_t *table = jl_atomic_load_relaxed(&m->bindings);
     for (size_t i = 0; i < jl_svec_len(table); i++) {
-        jl_binding_t *b = (jl_binding_t*)jl_svec_ref(table, i);
+        jl_binding_t *b = (jl_binding_t*)jl_svecref(table, i);
         if ((void*)b == jl_nothing)
             break;
         jl_sym_t *name = b->globalref->name;
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index e5d78a1ddb8f5..a946578d25146 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -445,7 +445,6 @@
     XX(jl_svec2) \
     XX(jl_svec_copy) \
     XX(jl_svec_fill) \
-    XX(jl_svec_ref) \
     XX(jl_switch) \
     XX(jl_switchto) \
     XX(jl_symbol) \
diff --git a/src/julia_internal.h b/src/julia_internal.h
index da025a900400e..e18aa084d0f08 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1498,10 +1498,6 @@ void typemap_slurp_search(jl_typemap_entry_t *ml, struct typemap_intersection_en
 
 // -- simplevector.c -- //
 
-// For codegen only.
-JL_DLLEXPORT size_t (jl_svec_len)(jl_svec_t *t) JL_NOTSAFEPOINT;
-JL_DLLEXPORT jl_value_t *jl_svec_ref(jl_svec_t *t JL_PROPAGATES_ROOT, ssize_t i);
-
 // check whether the specified number of arguments is compatible with the
 // specified number of parameters of the tuple type
 JL_DLLEXPORT int jl_tupletype_length_compat(jl_value_t *v, size_t nargs) JL_NOTSAFEPOINT;
diff --git a/src/module.c b/src/module.c
index 47309c897ae63..db1d86aa4a3ce 100644
--- a/src/module.c
+++ b/src/module.c
@@ -1,4 +1,5 @@
 // This file is a part of Julia. License is MIT: https://julialang.org/license
+//
 
 /*
   modules and top-level bindings
@@ -641,7 +642,7 @@ JL_DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from)
     // silently override a "using" name. see issue #2054.
     jl_svec_t *table = jl_atomic_load_relaxed(&from->bindings);
     for (size_t i = 0; i < jl_svec_len(table); i++) {
-        jl_binding_t *b = (jl_binding_t*)jl_svec_ref(table, i);
+        jl_binding_t *b = (jl_binding_t*)jl_svecref(table, i);
         if ((void*)b == jl_nothing)
             break;
         if (b->exportp && (jl_atomic_load_relaxed(&b->owner) == b || b->imported)) {
@@ -939,7 +940,7 @@ JL_DLLEXPORT jl_value_t *jl_module_names(jl_module_t *m, int all, int imported)
     JL_GC_PUSH1(&a);
     jl_svec_t *table = jl_atomic_load_relaxed(&m->bindings);
     for (size_t i = 0; i < jl_svec_len(table); i++) {
-        jl_binding_t *b = (jl_binding_t*)jl_svec_ref(table, i);
+        jl_binding_t *b = (jl_binding_t*)jl_svecref(table, i);
         if ((void*)b == jl_nothing)
             break;
         jl_sym_t *asname = b->globalref->name;
@@ -996,7 +997,7 @@ JL_DLLEXPORT void jl_clear_implicit_imports(jl_module_t *m)
     JL_LOCK(&m->lock);
     jl_svec_t *table = jl_atomic_load_relaxed(&m->bindings);
     for (size_t i = 0; i < jl_svec_len(table); i++) {
-        jl_binding_t *b = (jl_binding_t*)jl_svec_ref(table, i);
+        jl_binding_t *b = (jl_binding_t*)jl_svecref(table, i);
         if ((void*)b == jl_nothing)
             break;
         if (jl_atomic_load_relaxed(&b->owner) && jl_atomic_load_relaxed(&b->owner) != b && !b->imported)
diff --git a/src/simplevector.c b/src/simplevector.c
index 7bac60f49d9c4..5f1fd744abd0c 100644
--- a/src/simplevector.c
+++ b/src/simplevector.c
@@ -96,10 +96,3 @@ JL_DLLEXPORT size_t (jl_svec_len)(jl_svec_t *t) JL_NOTSAFEPOINT
 {
     return jl_svec_len(t);
 }
-
-JL_DLLEXPORT jl_value_t *jl_svec_ref(jl_svec_t *t JL_PROPAGATES_ROOT, ssize_t i)
-{
-    jl_value_t *v = jl_svecref(t, (size_t)i);
-    assert(v != NULL);
-    return v;
-}
diff --git a/src/staticdata.c b/src/staticdata.c
index a687406dbe73a..f08b59828dfbd 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -730,7 +730,7 @@ static void jl_queue_module_for_serialization(jl_serializer_state *s, jl_module_
     if (jl_options.strip_metadata) {
         jl_svec_t *table = jl_atomic_load_relaxed(&m->bindings);
         for (size_t i = 0; i < jl_svec_len(table); i++) {
-            jl_binding_t *b = (jl_binding_t*)jl_svec_ref(table, i);
+            jl_binding_t *b = (jl_binding_t*)jl_svecref(table, i);
             if ((void*)b == jl_nothing)
                 break;
             jl_sym_t *name = b->globalref->name;
diff --git a/src/toplevel.c b/src/toplevel.c
index 750f34aaa9fed..cb078a05d0ce4 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -222,7 +222,7 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
     size_t i;
     jl_svec_t *table = jl_atomic_load_relaxed(&newm->bindings);
     for (size_t i = 0; i < jl_svec_len(table); i++) {
-        jl_binding_t *b = (jl_binding_t*)jl_svec_ref(table, i);
+        jl_binding_t *b = (jl_binding_t*)jl_svecref(table, i);
         if ((void*)b != jl_nothing) {
             // remove non-exported macros
             if (jl_symbol_name(b->name)[0]=='@' &&

From 6a1df3d3e4a32435bb7bfcbc101356e0b8176ae2 Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Wed, 6 Dec 2023 12:20:33 +0100
Subject: [PATCH 0374/1315] Review annotations and test for allocations in
 generic matmatmul (#52298)

---
 stdlib/LinearAlgebra/src/matmul.jl  | 16 ++++---
 stdlib/LinearAlgebra/test/matmul.jl | 65 ++++++++++++++++++++++++-----
 2 files changed, 62 insertions(+), 19 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index 0ca0527785d61..c2c7cdb66a07f 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -233,9 +233,7 @@ For custom matrix and vector types, it is recommended to implement
 5-argument `mul!` rather than implementing 3-argument `mul!` directly
 if possible.
 """
-@inline function mul!(C, A, B)
-    return mul!(C, A, B, true, false)
-end
+mul!(C, A, B) = mul!(C, A, B, true, false)
 
 """
     mul!(C, A, B, α, β) -> C
@@ -337,6 +335,7 @@ julia> lmul!(F.Q, B)
 lmul!(A, B)
 
 # THE one big BLAS dispatch
+# aggressive constant propagation makes mul!(C, A, B) invoke gemm_wrapper! directly
 Base.@constprop :aggressive function generic_matmatmul!(C::StridedMatrix{T}, tA, tB, A::StridedVecOrMat{T}, B::StridedVecOrMat{T},
                                     _add::MulAddMul=MulAddMul()) where {T<:BlasFloat}
     if all(in(('N', 'T', 'C')), (tA, tB))
@@ -567,7 +566,7 @@ function gemm_wrapper(tA::AbstractChar, tB::AbstractChar,
     end
 end
 
-Base.@constprop :aggressive function gemm_wrapper!(C::StridedVecOrMat{T}, tA::AbstractChar, tB::AbstractChar,
+function gemm_wrapper!(C::StridedVecOrMat{T}, tA::AbstractChar, tB::AbstractChar,
                        A::StridedVecOrMat{T}, B::StridedVecOrMat{T},
                        _add = MulAddMul()) where {T<:BlasFloat}
     mA, nA = lapack_size(tA, A)
@@ -607,7 +606,7 @@ Base.@constprop :aggressive function gemm_wrapper!(C::StridedVecOrMat{T}, tA::Ab
     _generic_matmatmul!(C, wrap(A, tA), wrap(B, tB), _add)
 end
 
-Base.@constprop :aggressive function gemm_wrapper!(C::StridedVecOrMat{Complex{T}}, tA::AbstractChar, tB::AbstractChar,
+function gemm_wrapper!(C::StridedVecOrMat{Complex{T}}, tA::AbstractChar, tB::AbstractChar,
                        A::StridedVecOrMat{Complex{T}}, B::StridedVecOrMat{T},
                        _add = MulAddMul()) where {T<:BlasReal}
     mA, nA = lapack_size(tA, A)
@@ -762,8 +761,7 @@ function generic_matmatmul(tA, tB, A::AbstractVecOrMat{T}, B::AbstractMatrix{S})
     generic_matmatmul!(C, tA, tB, A, B)
 end
 
-const tilebufsize = 10800  # Approximately 32k/3
-
+# aggressive const prop makes mixed eltype mul!(C, A, B) invoke _generic_matmatmul! directly
 Base.@constprop :aggressive generic_matmatmul!(C::AbstractVecOrMat, tA, tB, A::AbstractVecOrMat, B::AbstractVecOrMat, _add::MulAddMul) =
     _generic_matmatmul!(C, wrap(A, tA), wrap(B, tB), _add)
 
@@ -831,7 +829,7 @@ function matmul2x2(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,
     matmul2x2!(similar(B, promote_op(matprod, T, S), 2, 2), tA, tB, A, B)
 end
 
-Base.@constprop :aggressive function matmul2x2!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix,
+function matmul2x2!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix,
                     _add::MulAddMul = MulAddMul())
     require_one_based_indexing(C, A, B)
     if !(size(A) == size(B) == size(C) == (2,2))
@@ -898,7 +896,7 @@ function matmul3x3(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S}) where {T,
     matmul3x3!(similar(B, promote_op(matprod, T, S), 3, 3), tA, tB, A, B)
 end
 
-Base.@constprop :aggressive function matmul3x3!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix,
+function matmul3x3!(C::AbstractMatrix, tA, tB, A::AbstractMatrix, B::AbstractMatrix,
                     _add::MulAddMul = MulAddMul())
     require_one_based_indexing(C, A, B)
     if !(size(A) == size(B) == size(C) == (3,3))
diff --git a/stdlib/LinearAlgebra/test/matmul.jl b/stdlib/LinearAlgebra/test/matmul.jl
index afdc02534728a..4b0181f079a6f 100644
--- a/stdlib/LinearAlgebra/test/matmul.jl
+++ b/stdlib/LinearAlgebra/test/matmul.jl
@@ -27,6 +27,9 @@ mul_wrappers = [
     @test Base.infer_return_type((Vector{Float64},)) do v
         LinearAlgebra.wrap(v, 'N')
     end == Vector{Float64}
+    h(A) = LinearAlgebra.wrap(LinearAlgebra._unwrap(A), LinearAlgebra.wrapper_char(A))
+    @test @inferred(h(transpose(A))) === transpose(A)
+    @test @inferred(h(adjoint(A))) === transpose(A)
 end
 
 @testset "matrices with zero dimensions" begin
@@ -131,7 +134,7 @@ end
         @test mul!(C, transpose(A), B) == A' * B
         @test mul!(C, A, transpose(B)) == A * B'
         @test mul!(C, transpose(A), transpose(B)) == A' * B'
-        @test LinearAlgebra.mul!(C, adjoint(A), transpose(B)) == A' * transpose(B)
+        @test mul!(C, adjoint(A), transpose(B)) == A' * transpose(B)
 
         # Inplace multiply-add
         α = rand(-10:10)
@@ -147,8 +150,8 @@ end
         @test mul!(C0(), adjoint(A), transpose(B), α, β) == α * A' * transpose(B) .+ βC
 
         #test DimensionMismatch for generic_matmatmul
-        @test_throws DimensionMismatch LinearAlgebra.mul!(C, adjoint(A), transpose(fill(1, 4, 4)))
-        @test_throws DimensionMismatch LinearAlgebra.mul!(C, adjoint(fill(1, 4, 4)), transpose(B))
+        @test_throws DimensionMismatch mul!(C, adjoint(A), transpose(fill(1, 4, 4)))
+        @test_throws DimensionMismatch mul!(C, adjoint(fill(1, 4, 4)), transpose(B))
     end
     vv = [1, 2]
     CC = Matrix{Int}(undef, 2, 2)
@@ -240,9 +243,9 @@ end
     BB = rand(Float64, 6, 6)
     CC = zeros(Float64, 6, 6)
     for A in (copy(AA), view(AA, 1:6, 1:6)), B in (copy(BB), view(BB, 1:6, 1:6)), C in (copy(CC), view(CC, 1:6, 1:6))
-        @test LinearAlgebra.mul!(C, transpose(A), transpose(B)) == transpose(A) * transpose(B)
-        @test LinearAlgebra.mul!(C, A, adjoint(B)) == A * transpose(B)
-        @test LinearAlgebra.mul!(C, adjoint(A), B) == transpose(A) * B
+        @test mul!(C, transpose(A), transpose(B)) == transpose(A) * transpose(B)
+        @test mul!(C, A, adjoint(B)) == A * transpose(B)
+        @test mul!(C, adjoint(A), B) == transpose(A) * B
 
         # Inplace multiply-add
         α = rand(Float64)
@@ -257,15 +260,57 @@ end
     end
 end
 
+@testset "allocations in BLAS-mul" begin
+    for n in (2, 3, 6)
+        A = rand(Float64, n, n)
+        B = rand(Float64, n, n)
+        C = zeros(Float64, n, n)
+        # gemm
+        for t in (identity, adjoint, transpose)
+            At = t(A)
+            Bt = t(B)
+            mul!(C, At, B)
+            @test 0 == @allocations mul!(C, At, B)
+            mul!(C, A, Bt)
+            @test 0 == @allocations mul!(C, A, Bt)
+            mul!(C, At, Bt)
+            @test 0 == @allocations mul!(C, At, Bt)
+        end
+        # syrk/herk
+        @test 0 == @allocations mul!(C, transpose(A), A)
+        @test 0 == @allocations mul!(C, adjoint(A), A)
+        @test 0 == @allocations mul!(C, A, transpose(A))
+        @test 0 == @allocations mul!(C, A, adjoint(A))
+        # complex times real
+        Cc = complex(C)
+        Ac = complex(A)
+        for t in (identity, adjoint, transpose)
+            Bt = t(B)
+            @test 0 == @allocations mul!(Cc, Ac, Bt)
+        end
+    end
+end
+
 @testset "mixed Blas-non-Blas matmul" begin
     AA = rand(-10:10, 6, 6)
     BB = ones(Float64, 6, 6)
     CC = zeros(Float64, 6, 6)
     for A in (copy(AA), view(AA, 1:6, 1:6)), B in (copy(BB), view(BB, 1:6, 1:6)), C in (copy(CC), view(CC, 1:6, 1:6))
-        @test LinearAlgebra.mul!(C, A, B) == A * B
-        @test LinearAlgebra.mul!(C, transpose(A), transpose(B)) == transpose(A) * transpose(B)
-        @test LinearAlgebra.mul!(C, A, adjoint(B)) == A * transpose(B)
-        @test LinearAlgebra.mul!(C, adjoint(A), B) == transpose(A) * B
+        @test mul!(C, A, B) == A * B
+        @test mul!(C, transpose(A), transpose(B)) == transpose(A) * transpose(B)
+        @test mul!(C, A, adjoint(B)) == A * transpose(B)
+        @test mul!(C, adjoint(A), B) == transpose(A) * B
+    end
+end
+
+@testset "allocations in mixed Blas-non-Blas matmul" begin
+    for n in (2, 3, 6)
+        A = rand(-10:10, n, n)
+        B = ones(Float64, n, n)
+        C = zeros(Float64, n, n)
+        @test 0 == @allocations mul!(C, A, B)
+        @test 0 == @allocations mul!(C, A, transpose(B))
+        @test 0 == @allocations mul!(C, adjoint(A), B)
     end
 end
 

From cfcc04308a0ea17b37585e3b752184c040197d0c Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 6 Dec 2023 19:38:22 +0530
Subject: [PATCH 0375/1315] Aggressive constprop in matvecmul and matmatmul
 (#51961)

---
 stdlib/LinearAlgebra/src/matmul.jl | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index c2c7cdb66a07f..3f61bf9a19fed 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -397,7 +397,8 @@ end
     A
 end
 
-function gemv!(y::StridedVector{T}, tA::AbstractChar, A::StridedVecOrMat{T}, x::StridedVector{T},
+Base.@constprop :aggressive function gemv!(y::StridedVector{T}, tA::AbstractChar,
+                A::StridedVecOrMat{T}, x::StridedVector{T},
                α::Number=true, β::Number=false) where {T<:BlasFloat}
     mA, nA = lapack_size(tA, A)
     nA != length(x) &&
@@ -427,7 +428,7 @@ function gemv!(y::StridedVector{T}, tA::AbstractChar, A::StridedVecOrMat{T}, x::
     end
 end
 
-function gemv!(y::StridedVector{Complex{T}}, tA::AbstractChar, A::StridedVecOrMat{Complex{T}}, x::StridedVector{T},
+Base.@constprop :aggressive function gemv!(y::StridedVector{Complex{T}}, tA::AbstractChar, A::StridedVecOrMat{Complex{T}}, x::StridedVector{T},
     α::Number = true, β::Number = false) where {T<:BlasReal}
     mA, nA = lapack_size(tA, A)
     nA != length(x) &&
@@ -449,8 +450,9 @@ function gemv!(y::StridedVector{Complex{T}}, tA::AbstractChar, A::StridedVecOrMa
     end
 end
 
-function gemv!(y::StridedVector{Complex{T}}, tA::AbstractChar, A::StridedVecOrMat{T}, x::StridedVector{Complex{T}},
-    α::Number = true, β::Number = false) where {T<:BlasFloat}
+Base.@constprop :aggressive function gemv!(y::StridedVector{Complex{T}}, tA::AbstractChar,
+        A::StridedVecOrMat{T}, x::StridedVector{Complex{T}},
+        α::Number = true, β::Number = false) where {T<:BlasReal}
     mA, nA = lapack_size(tA, A)
     nA != length(x) &&
         throw(DimensionMismatch(lazy"second dimension of A, $nA, does not match length of x, $(length(x))"))

From fd9d3c08c9e3229283e4d2b7d749234f0b903773 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 6 Dec 2023 09:15:44 -0500
Subject: [PATCH 0376/1315] ircode: fix regression (crash) from Memory{T} PR
 (#52409)

The offset should be in elements not bytes.
---
 src/ircode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/ircode.c b/src/ircode.c
index 6ed1740b3667a..388b3b4904217 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -155,7 +155,7 @@ static void jl_encode_memory_slice(jl_ircode_state *s, jl_genericmemory_t *mem,
     }
     else {
         ios_write(s->s, (char*)mem->ptr + offset * layout->size, len * layout->size);
-        if (jl_genericmemory_isbitsunion(mem))
+        if (layout->flags.arrayelem_isunion)
             ios_write(s->s, jl_genericmemory_typetagdata(mem) + offset, len);
     }
 }
@@ -392,7 +392,7 @@ static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal)
         if (layout->flags.arrayelem_isunion || layout->size == 0)
             offset = (uintptr_t)ar->ref.ptr_or_offset;
         else
-            offset = (char*)ar->ref.ptr_or_offset - (char*)ar->ref.mem->ptr;
+            offset = ((char*)ar->ref.ptr_or_offset - (char*)ar->ref.mem->ptr) / layout->size;
         jl_encode_memory_slice(s, ar->ref.mem, offset, l);
     }
     else if (as_literal && jl_is_genericmemory(v)) {

From dbb797f26d6edc94f6045a618908a43e7772227c Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 6 Dec 2023 23:31:35 +0900
Subject: [PATCH 0377/1315] add two-arg `@macroexpand[1]` (#52416)

So that we can provide a module context to evaluate in.
This is more aligned with the design of `@eval` and `Meta.@lower`.
---
 base/expr.jl      | 15 ++++++++++++---
 test/errorshow.jl |  8 ++++++++
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/base/expr.jl b/base/expr.jl
index 168cd492b78e4..e9e64f0126d94 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -129,9 +129,10 @@ function macroexpand(m::Module, @nospecialize(x); recursive=true)
 end
 
 """
-    @macroexpand
+    @macroexpand [mod,] ex
 
 Return equivalent expression with all macros removed (expanded).
+If two arguments are provided, the first is the module to evaluate in.
 
 There are differences between `@macroexpand` and [`macroexpand`](@ref).
 
@@ -166,20 +167,28 @@ julia> M.f()
 ```
 With `@macroexpand` the expression expands where `@macroexpand` appears in the code (module `M` in the example).
 With `macroexpand` the expression expands in the module given as the first argument.
+
+!!! compat "Julia 1.11"
+    The two-argument form requires at least Julia 1.11.
 """
 macro macroexpand(code)
     return :(macroexpand($__module__, $(QuoteNode(code)), recursive=true))
 end
-
+macro macroexpand(mod, code)
+    return :(macroexpand($(esc(mod)), $(QuoteNode(code)), recursive=true))
+end
 
 """
-    @macroexpand1
+    @macroexpand1 [mod,] ex
 
 Non recursive version of [`@macroexpand`](@ref).
 """
 macro macroexpand1(code)
     return :(macroexpand($__module__, $(QuoteNode(code)), recursive=false))
 end
+macro macroexpand1(mod, code)
+    return :(macroexpand($(esc(mod)), $(QuoteNode(code)), recursive=false))
+end
 
 ## misc syntax ##
 
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 1b9d46ca5f4bd..28ca2c1bc3c5c 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -537,6 +537,14 @@ end
     @test (@macroexpand1 @nest2b 42) == _macroexpand1(:(@nest2b 42))
 end
 
+module TwoargMacroExpand
+macro modulecontext(); return __module__; end
+end
+@test (@__MODULE__) == @macroexpand TwoargMacroExpand.@modulecontext
+@test TwoargMacroExpand == @macroexpand TwoargMacroExpand @modulecontext
+@test (@__MODULE__) == @macroexpand1 TwoargMacroExpand.@modulecontext
+@test TwoargMacroExpand == @macroexpand1 TwoargMacroExpand @modulecontext
+
 foo_9965(x::Float64; w=false) = x
 foo_9965(x::Int) = 2x
 

From 627210d64a7c3510f865e34e80e9497b546103f7 Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Wed, 6 Dec 2023 15:36:51 +0100
Subject: [PATCH 0378/1315] Return of the `tilebufsize` (#52422)

See
https://github.com/JuliaLang/julia/pull/52298#discussion_r1417407376.
---
 stdlib/LinearAlgebra/src/matmul.jl | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index 3f61bf9a19fed..adc2d866ad70e 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -2,6 +2,9 @@
 
 # matmul.jl: Everything to do with dense matrix multiplication
 
+# unused internal constant, here for legacy reasons
+const tilebufsize = 10800  # Approximately 32k/3
+
 # Matrix-matrix multiplication
 
 AdjOrTransStridedMat{T} = Union{Adjoint{<:Any, <:StridedMatrix{T}}, Transpose{<:Any, <:StridedMatrix{T}}}

From e2af398a9679ca31374e522275b3e9efeda405c8 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Wed, 6 Dec 2023 12:12:40 -0300
Subject: [PATCH 0379/1315] add a test for page utilization metric (#52411)

---
 src/gc.c   | 2 +-
 test/gc.jl | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/gc.c b/src/gc.c
index 7089bb12fc347..7fac0f130d4f4 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -2969,7 +2969,7 @@ size_t gc_count_work_in_queue(jl_ptls_t ptls) JL_NOTSAFEPOINT
  * have tried to steal from the queue which still has a work item left, but failed to do so,
  * which violates the semantics of Chase-Lev's work-stealing queue.
  *
- * - Let E1 be the event "master thread writes -1 to gc_master_tid" and E2 be the even
+ * - Let E1 be the event "master thread writes -1 to gc_master_tid" and E2 be the event
  * "master thread observes that `gc_n_threads_marking` is zero". Since we're using
  * sequentially consistent atomics, E1 => E2. Now suppose one thread which is spinning in
  * `gc_should_mark` tries to enter the mark-loop after E2. In order to do so, it must
diff --git a/test/gc.jl b/test/gc.jl
index e085c1d8658e5..99b96a5ae1fd2 100644
--- a/test/gc.jl
+++ b/test/gc.jl
@@ -15,6 +15,13 @@ function run_gctest(file)
     end
 end
 
+function run_nonzero_page_utilization_test()
+    GC.gc()
+    page_utilization = Base.gc_page_utilization_data()
+    # at least one of the pools should have nonzero page_utilization
+    @test any(page_utilization .> 0)
+end
+
 # !!! note:
 #     Since we run our tests on 32bit OS as well we confine ourselves
 #     to parameters that allocate about 512MB of objects. Max RSS is lower
@@ -24,4 +31,5 @@ end
     run_gctest("gc/linkedlist.jl")
     run_gctest("gc/objarray.jl")
     run_gctest("gc/chunks.jl")
+    run_nonzero_page_utilization_test()
 end

From 3aa943b21cf90a78e40fefe653fd4372ad328df5 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 6 Dec 2023 20:54:51 +0530
Subject: [PATCH 0380/1315] Sort exported names from LinearAlgebra [nfc]
 (#52419)

---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 86 ++++++++++++-----------
 1 file changed, 44 insertions(+), 42 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index cad58bdc0ef38..705c167b9e058 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -27,133 +27,135 @@ import Libdl
 
 export
 # Modules
-    LAPACK,
     BLAS,
+    LAPACK,
 
 # Types
     Adjoint,
-    Transpose,
-    SymTridiagonal,
-    Tridiagonal,
     Bidiagonal,
-    Factorization,
     BunchKaufman,
     Cholesky,
     CholeskyPivoted,
     ColumnNorm,
+    Diagonal,
     Eigen,
+    Factorization,
     GeneralizedEigen,
     GeneralizedSVD,
     GeneralizedSchur,
+    Hermitian,
     Hessenberg,
-    LU,
     LDLt,
+    LQ,
+    LU,
+    LowerTriangular,
     NoPivot,
-    RowNonZero,
     QR,
     QRPivoted,
-    LQ,
-    Schur,
-    SVD,
-    Hermitian,
     RowMaximum,
+    RowNonZero,
+    SVD,
+    Schur,
+    SymTridiagonal,
     Symmetric,
-    LowerTriangular,
-    UpperTriangular,
+    Transpose,
+    Tridiagonal,
+    UniformScaling,
     UnitLowerTriangular,
     UnitUpperTriangular,
     UpperHessenberg,
-    Diagonal,
-    UniformScaling,
+    UpperTriangular,
+
 
 # Functions
-    axpy!,
+    adjoint!,
+    adjoint,
     axpby!,
-    bunchkaufman,
+    axpy!,
     bunchkaufman!,
-    cholesky,
+    bunchkaufman,
     cholesky!,
+    cholesky,
     cond,
     condskeel,
+    copy_transpose!,
     copyto!,
     copytrito!,
-    copy_transpose!,
     cross,
-    adjoint,
-    adjoint!,
     det,
     diag,
     diagind,
     diagm,
     dot,
-    eigen,
     eigen!,
+    eigen,
     eigmax,
     eigmin,
-    eigvals,
     eigvals!,
+    eigvals,
     eigvecs,
     factorize,
     givens,
-    hermitianpart,
     hermitianpart!,
-    hessenberg,
+    hermitianpart,
     hessenberg!,
+    hessenberg,
     isdiag,
     ishermitian,
-    isposdef,
     isposdef!,
+    isposdef,
     issuccess,
     issymmetric,
     istril,
     istriu,
-    kron,
     kron!,
+    kron,
     ldiv!,
     ldlt!,
     ldlt,
+    lmul!,
     logabsdet,
     logdet,
-    lowrankdowndate,
     lowrankdowndate!,
-    lowrankupdate,
+    lowrankdowndate,
     lowrankupdate!,
-    lu,
+    lowrankupdate,
+    lq!,
+    lq,
     lu!,
+    lu,
     lyap,
     mul!,
-    lmul!,
-    rmul!,
     norm,
-    normalize,
     normalize!,
+    normalize,
     nullspace,
+    opnorm,
     ordschur!,
     ordschur,
     pinv,
-    qr,
     qr!,
-    lq,
-    lq!,
-    opnorm,
+    qr,
     rank,
     rdiv!,
     reflect!,
+    rmul!,
     rotate!,
-    schur,
     schur!,
-    svd,
+    schur,
     svd!,
+    svd,
     svdvals!,
     svdvals,
     sylvester,
     tr,
-    transpose,
     transpose!,
-    tril,
-    triu,
+    transpose,
     tril!,
+    tril,
     triu!,
+    triu,
+
 
 # Operators
     \,

From 856e1120a8f255e4907a05f0146a2026a6665dd4 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 6 Dec 2023 10:35:44 -0500
Subject: [PATCH 0381/1315] channels: fix memory ordering violation in iterate
 (#52407)

Channel `iterate` calls might miss trailing items without this patch. I
have not seen proof of this reaching a failure, but we do appear to be
missing this ordering specification in visual review.

Should not make a difference to generated code on x86, which already has
TSO guaranteed, but may alter optimizations and other CPUs with weaker
memory orderings.
---
 base/channels.jl | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/base/channels.jl b/base/channels.jl
index 90dac37f41cb6..75207e9fac76b 100644
--- a/base/channels.jl
+++ b/base/channels.jl
@@ -211,7 +211,12 @@ function close(c::Channel, @nospecialize(excp::Exception))
     end
     nothing
 end
-isopen(c::Channel) = ((@atomic :monotonic c.state) === :open)
+
+# Use acquire here to pair with release store in `close`, so that subsequent `isready` calls
+# are forced to see `isready == true` if they see `isopen == false`. This means users must
+# call `isopen` before `isready` if you are using the race-y APIs (or call `iterate`, which
+# does this right for you).
+isopen(c::Channel) = ((@atomic :acquire c.state) === :open)
 
 """
     bind(chnl::Channel, task::Task)

From bdbee27ae76cbbe84f48152a1e4f75f4ba26a410 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 7 Dec 2023 07:06:48 +0900
Subject: [PATCH 0382/1315] effects: support callsite `@assume_effects`
 annotation (#52400)

---
 NEWS.md                                 |  1 +
 base/compiler/abstractinterpretation.jl | 26 +++++---
 base/compiler/compiler.jl               |  1 +
 base/compiler/effects.jl                |  3 +
 base/compiler/inferencestate.jl         | 12 +++-
 base/compiler/optimize.jl               |  2 +
 base/expr.jl                            | 82 ++++++++++++++++---------
 doc/src/devdocs/ast.md                  | 11 +---
 src/julia-syntax.scm                    |  4 +-
 src/julia.h                             | 26 +++++---
 src/macroexpand.scm                     |  2 +-
 src/method.c                            | 49 ++++++++++-----
 test/compiler/effects.jl                | 38 ++++++++++++
 13 files changed, 182 insertions(+), 75 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index b5dbc894a3aeb..ca91c08e915ab 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -34,6 +34,7 @@ Compiler/Runtime improvements
 * Updated GC heuristics to count allocated pages instead of individual objects ([#50144]).
 * A new `LazyLibrary` type is exported from `Libdl` for use in building chained lazy library
   loads, primarily to be used within JLLs ([#50074]).
+* Added a support for annotating `Base.@assume_effects` on code block ([#52400]).
 
 Command-line option changes
 ---------------------------
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index f284928b17135..d4e4afdb8407b 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2692,14 +2692,7 @@ function abstract_eval_foreigncall(interp::AbstractInterpreter, e::Expr, vtypes:
     cconv = e.args[5]
     if isa(cconv, QuoteNode) && (v = cconv.value; isa(v, Tuple{Symbol, UInt16}))
         override = decode_effects_override(v[2])
-        effects = Effects(effects;
-            consistent          = override.consistent ? ALWAYS_TRUE : effects.consistent,
-            effect_free         = override.effect_free ? ALWAYS_TRUE : effects.effect_free,
-            nothrow             = override.nothrow ? true : effects.nothrow,
-            terminates          = override.terminates_globally ? true : effects.terminates,
-            notaskstate         = override.notaskstate ? true : effects.notaskstate,
-            inaccessiblememonly = override.inaccessiblememonly ? ALWAYS_TRUE : effects.inaccessiblememonly,
-            noub                = override.noub ? ALWAYS_TRUE : override.noub_if_noinbounds ? NOUB_IF_NOINBOUNDS : effects.noub)
+        effects = override_effects(effects, override)
     end
     return RTEffects(t, Any, effects)
 end
@@ -2754,16 +2747,29 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
     # N.B.: This only applies to the effects of the statement itself.
     # It is possible for arguments (GlobalRef/:static_parameter) to throw,
     # but these will be recomputed during SSA construction later.
+    override = decode_statement_effects_override(sv)
+    effects = override_effects(effects, override)
     set_curr_ssaflag!(sv, flags_for_effects(effects), IR_FLAGS_EFFECTS)
     merge_effects!(interp, sv, effects)
 
     return RTEffects(rt, exct, effects)
 end
 
-function isdefined_globalref(g::GlobalRef)
-    return ccall(:jl_globalref_boundp, Cint, (Any,), g) != 0
+function override_effects(effects::Effects, override::EffectsOverride)
+    return Effects(effects;
+        consistent = override.consistent ? ALWAYS_TRUE : effects.consistent,
+        effect_free = override.effect_free ? ALWAYS_TRUE : effects.effect_free,
+        nothrow = override.nothrow ? true : effects.nothrow,
+        terminates = override.terminates_globally ? true : effects.terminates,
+        notaskstate = override.notaskstate ? true : effects.notaskstate,
+        inaccessiblememonly = override.inaccessiblememonly ? ALWAYS_TRUE : effects.inaccessiblememonly,
+        noub = override.noub ? ALWAYS_TRUE :
+               override.noub_if_noinbounds && effects.noub !== ALWAYS_TRUE ? NOUB_IF_NOINBOUNDS :
+               effects.noub)
 end
 
+isdefined_globalref(g::GlobalRef) = !iszero(ccall(:jl_globalref_boundp, Cint, (Any,), g))
+
 function abstract_eval_globalref_type(g::GlobalRef)
     if isdefined_globalref(g) && isconst(g)
         return Const(ccall(:jl_get_globalref_value, Any, (Any,), g))
diff --git a/base/compiler/compiler.jl b/base/compiler/compiler.jl
index 528b8fd97869f..6868f3ea03477 100644
--- a/base/compiler/compiler.jl
+++ b/base/compiler/compiler.jl
@@ -71,6 +71,7 @@ function EffectsOverride(
         noub,
         noub_if_noinbounds)
 end
+const NUM_EFFECTS_OVERRIDES = 9 # sync with julia.h
 
 # essential files and libraries
 include("essentials.jl")
diff --git a/base/compiler/effects.jl b/base/compiler/effects.jl
index b63cc95b02b9e..a864925b23eb1 100644
--- a/base/compiler/effects.jl
+++ b/base/compiler/effects.jl
@@ -345,3 +345,6 @@ function decode_effects_override(e::UInt16)
         !iszero(e & (0x0001 << 7)),
         !iszero(e & (0x0001 << 8)))
 end
+
+decode_statement_effects_override(ssaflag::UInt32) =
+    decode_effects_override(UInt16((ssaflag >> NUM_IR_FLAGS) & (1 << NUM_EFFECTS_OVERRIDES - 1)))
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 885a6dbab65b7..09757adc54850 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -818,7 +818,14 @@ frame_world(sv::IRInterpretationState) = sv.world
 callers_in_cycle(sv::InferenceState) = sv.callers_in_cycle
 callers_in_cycle(sv::IRInterpretationState) = ()
 
-is_effect_overridden(sv::AbsIntState, effect::Symbol) = is_effect_overridden(frame_instance(sv), effect)
+function is_effect_overridden(sv::AbsIntState, effect::Symbol)
+    if is_effect_overridden(frame_instance(sv), effect)
+        return true
+    elseif is_effect_overridden(decode_statement_effects_override(sv), effect)
+        return true
+    end
+    return false
+end
 function is_effect_overridden(linfo::MethodInstance, effect::Symbol)
     def = linfo.def
     return isa(def, Method) && is_effect_overridden(def, effect)
@@ -918,6 +925,9 @@ function merge_effects!(::AbstractInterpreter, caller::InferenceState, effects::
 end
 merge_effects!(::AbstractInterpreter, ::IRInterpretationState, ::Effects) = return
 
+decode_statement_effects_override(sv::AbsIntState) =
+    decode_statement_effects_override(get_curr_ssaflag(sv))
+
 struct InferenceLoopState
     sig
     rt
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index fe8e8d0580bcb..dbbb78680595a 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -43,6 +43,8 @@ const IR_FLAG_EFIIMO      = one(UInt32) << 9
 # This is :inaccessiblememonly == INACCESSIBLEMEM_OR_ARGMEMONLY
 const IR_FLAG_INACCESSIBLE_OR_ARGMEM = one(UInt32) << 10
 
+const NUM_IR_FLAGS = 11 # sync with julia.h
+
 const IR_FLAGS_EFFECTS = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW | IR_FLAG_CONSISTENT | IR_FLAG_NOUB
 
 has_flag(curr::UInt32, flag::UInt32) = (curr & flag) == flag
diff --git a/base/expr.jl b/base/expr.jl
index e9e64f0126d94..553f5a360dff1 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -412,16 +412,16 @@ end
 """
     Base.@assume_effects setting... [ex]
 
-Override the compiler's effect modeling for the given method or foreign call.
-`@assume_effects` can be applied immediately before a function definition or within a function body.
-It can also be applied immediately before a `@ccall` expression.
-
-!!! compat "Julia 1.8"
-    Using `Base.@assume_effects` requires Julia version 1.8.
+Override the compiler's effect modeling.
+This macro can be used in several contexts:
+1. Immediately before a method definition, to override the entire effect modeling of the applied method.
+2. Within a function body without any arguments, to override the entire effect modeling of the enclosing method.
+3. Applied to a code block, to override the local effect modeling of the applied code block.
 
 # Examples
 ```jldoctest
 julia> Base.@assume_effects :terminates_locally function fact(x)
+           # usage 1:
            # this :terminates_locally allows `fact` to be constant-folded
            res = 1
            0 ≤ x < 20 || error("bad fact")
@@ -442,6 +442,7 @@ CodeInfo(
 
 julia> code_typed() do
            map((2,3,4)) do x
+               # usage 2:
                # this :terminates_locally allows this anonymous function to be constant-folded
                Base.@assume_effects :terminates_locally
                res = 1
@@ -457,13 +458,35 @@ CodeInfo(
 1 ─     return (2, 6, 24)
 ) => Tuple{Int64, Int64, Int64}
 
-julia> Base.@assume_effects :total !:nothrow @ccall jl_type_intersection(Vector{Int}::Any, Vector{<:Integer}::Any)::Any
-Vector{Int64} (alias for Array{Int64, 1})
+julia> code_typed() do
+           map((2,3,4)) do x
+               res = 1
+               0 ≤ x < 20 || error("bad fact")
+               # usage 3:
+               # with this :terminates_locally annotation the compiler skips tainting
+               # `:terminates` effect within this `while` block, allowing the parent
+               # anonymous function to be constant-folded
+               Base.@assume_effects :terminates_locally while x > 1
+                   res *= x
+                   x -= 1
+               end
+               return res
+           end
+       end |> only
+CodeInfo(
+1 ─     return (2, 6, 24)
+) => Tuple{Int64, Int64, Int64}
 ```
 
+!!! compat "Julia 1.8"
+    Using `Base.@assume_effects` requires Julia version 1.8.
+
 !!! compat "Julia 1.10"
     The usage within a function body requires at least Julia 1.10.
 
+!!! compact "Julia 1.11"
+    The code block annotation requires at least Julia 1.11.
+
 !!! warning
     Improper use of this macro causes undefined behavior (including crashes,
     incorrect answers, or other hard to track bugs). Use with care and only as a
@@ -717,33 +740,36 @@ the call is generally total, it may however throw.
 """
 macro assume_effects(args...)
     lastex = args[end]
-    inner = unwrap_macrocalls(lastex)
-    if is_function_def(inner)
-        ex = lastex
-        idx = length(args)-1
+    override = compute_assumed_settings(args[begin:end-1])
+    if is_function_def(unwrap_macrocalls(lastex))
+        return esc(pushmeta!(lastex, form_purity_expr(override)))
     elseif isexpr(lastex, :macrocall) && lastex.args[1] === Symbol("@ccall")
-        ex = lastex
-        idx = length(args)-1
-    else # anonymous function case
-        ex = nothing
-        idx = length(args)
+        lastex.args[1] = GlobalRef(Base, Symbol("@ccall_effects"))
+        insert!(lastex.args, 3, Core.Compiler.encode_effects_override(override))
+        return esc(lastex)
+    end
+    override′ = compute_assumed_setting(override, lastex)
+    if override′ !== nothing
+        # anonymous function case
+        return Expr(:meta, form_purity_expr(override′))
+    else
+        # call site annotation case
+        return Expr(:block,
+                    form_purity_expr(override),
+                    Expr(:local, Expr(:(=), :val, esc(lastex))),
+                    Expr(:purity), # region end token
+                    :val)
     end
+end
+
+function compute_assumed_settings(settings)
     override = EffectsOverride()
-    for i = 1:idx
-        setting = args[i]
+    for setting in settings
         override = compute_assumed_setting(override, setting)
         override === nothing &&
             throw(ArgumentError("@assume_effects $setting not supported"))
     end
-    if is_function_def(inner)
-        return esc(pushmeta!(ex, form_purity_expr(override)))
-    elseif isexpr(ex, :macrocall) && ex.args[1] === Symbol("@ccall")
-        ex.args[1] = GlobalRef(Base, Symbol("@ccall_effects"))
-        insert!(ex.args, 3, Core.Compiler.encode_effects_override(override))
-        return esc(ex)
-    else # anonymous function case
-        return Expr(:meta, form_purity_expr(override))
-    end
+    return override
 end
 
 using Core.Compiler: EffectsOverride
diff --git a/doc/src/devdocs/ast.md b/doc/src/devdocs/ast.md
index 18ed12b3326e9..f829b27663e62 100644
--- a/doc/src/devdocs/ast.md
+++ b/doc/src/devdocs/ast.md
@@ -689,15 +689,8 @@ A (usually temporary) container for holding lowered source code.
 
   * `ssaflags`
 
-    Statement-level flags for each expression in the function. Many of these are reserved, but not yet implemented:
-
-    * 0x01 << 0 = statement is marked as `@inbounds`
-    * 0x01 << 1 = statement is marked as `@inline`
-    * 0x01 << 2 = statement is marked as `@noinline`
-    * 0x01 << 3 = statement is within a block that leads to `throw` call
-    * 0x01 << 4 = statement may be removed if its result is unused, in particular it is thus be both pure and effect free
-    * 0x01 << 5-6 = <unused>
-    * 0x01 << 7 = <reserved> has out-of-band info
+    Statement-level 32 bits flags for each expression in the function.
+    See the definition of `jl_code_info_t` in julia.h for more details.
 
   * `linetable`
 
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 4dd7735776315..76a06c6d1a47b 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -3710,7 +3710,7 @@ f(x) = yt(x)
          thunk with-static-parameters toplevel-only
          global globalref outerref const-if-global thismodule
          const atomic null true false ssavalue isdefined toplevel module lambda
-         error gc_preserve_begin gc_preserve_end import using export public inline noinline)))
+         error gc_preserve_begin gc_preserve_end import using export public inline noinline purity)))
 
 (define (local-in? s lam (tab #f))
   (or (and tab (has? tab s))
@@ -4877,7 +4877,7 @@ f(x) = yt(x)
                (cons (car e) args)))
 
             ;; metadata expressions
-            ((lineinfo line meta inbounds loopinfo gc_preserve_end aliasscope popaliasscope inline noinline)
+            ((lineinfo line meta inbounds loopinfo gc_preserve_end aliasscope popaliasscope inline noinline purity)
              (let ((have-ret? (and (pair? code) (pair? (car code)) (eq? (caar code) 'return))))
                (cond ((eq? (car e) 'line)
                       (set! current-loc e)
diff --git a/src/julia.h b/src/julia.h
index e87f277092629..bc2e3c7335f1a 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -265,20 +265,28 @@ typedef union __jl_purity_overrides_t {
     uint16_t bits;
 } _jl_purity_overrides_t;
 
+#define NUM_EFFECTS_OVERRIDES 9
+#define NUM_IR_FLAGS 11
+
 // This type describes a single function body
 typedef struct _jl_code_info_t {
     // ssavalue-indexed arrays of properties:
     jl_array_t *code;  // Any array of statements
     jl_value_t *codelocs; // Int32 array of indices into the line table
     jl_value_t *ssavaluetypes; // types of ssa values (or count of them)
-    jl_array_t *ssaflags; // flags associated with each statement:
-        // 0 = inbounds
-        // 1 = inline
-        // 2 = noinline
-        // 3 = <reserved> strict-ieee (strictfp)
-        // 4 = effect-free (may be deleted if unused)
-        // 5-6 = <unused>
-        // 7 = has out-of-band info
+    jl_array_t *ssaflags; // 32 bits flags associated with each statement:
+        // 1 << 0 = inbounds region
+        // 1 << 1 = callsite inline region
+        // 1 << 2 = callsite noinline region
+        // 1 << 3 = throw block
+        // 1 << 4 = :effect_free
+        // 1 << 5 = :nothrow
+        // 1 << 6 = :consistent
+        // 1 << 7 = :refined
+        // 1 << 8 = :noub
+        // 1 << 9 = :effect_free_if_inaccessiblememonly
+        // 1 << 10 = :inaccessiblemem_or_argmemonly
+        // 1 << 11-18 = callsite effects overrides
     // miscellaneous data:
     jl_value_t *method_for_inference_limit_heuristics; // optional method used during inference
     jl_value_t *linetable; // Table of locations [TODO: make this volatile like slotnames]
@@ -1250,7 +1258,7 @@ STATIC_INLINE void jl_array_uint8_set(void *a, size_t i, uint8_t x) JL_NOTSAFEPO
     assert(i < jl_array_len(a));
     jl_array_data(a, uint8_t)[i] = x;
 }
-STATIC_INLINE void jl_array_uint32_set(void *a, size_t i, uint8_t x) JL_NOTSAFEPOINT
+STATIC_INLINE void jl_array_uint32_set(void *a, size_t i, uint32_t x) JL_NOTSAFEPOINT
 {
     assert(i < jl_array_len(a));
     assert(jl_typetagis(a, jl_array_uint32_type) || jl_typetagis(a, jl_array_int32_type));
diff --git a/src/macroexpand.scm b/src/macroexpand.scm
index 6e390a6c24cf2..424e921a35713 100644
--- a/src/macroexpand.scm
+++ b/src/macroexpand.scm
@@ -385,7 +385,7 @@
                                ,(resolve-expansion-vars-with-new-env (caddr arg) env m parent-scope inarg))
                            (unescape-global-lhs arg env m parent-scope inarg)))
                       (cdr e))))
-           ((using import export meta line inbounds boundscheck loopinfo inline noinline) (map unescape e))
+           ((using import export meta line inbounds boundscheck loopinfo inline noinline purity) (map unescape e))
            ((macrocall) e) ; invalid syntax anyways, so just act like it's quoted.
            ((symboliclabel) e)
            ((symbolicgoto) e)
diff --git a/src/method.c b/src/method.c
index 9cb7e83d57c1c..73d2d256320ab 100644
--- a/src/method.c
+++ b/src/method.c
@@ -301,10 +301,11 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
     li->ssaflags = jl_alloc_array_1d(jl_array_uint32_type, n);
     jl_gc_wb(li, li->ssaflags);
     int inbounds_depth = 0; // number of stacked inbounds
-    // isempty(inline_flags): no user annotation
-    // last(inline_flags) == 1: inline region
-    // last(inline_flags) == 0: noinline region
+    // isempty(inline_flags): no user callsite inline annotation
+    // last(inline_flags) == 1: callsite inline region
+    // last(inline_flags) == 0: callsite noinline region
     arraylist_t *inline_flags = arraylist_new((arraylist_t*)malloc_s(sizeof(arraylist_t)), 0);
+    arraylist_t *purity_exprs = arraylist_new((arraylist_t*)malloc_s(sizeof(arraylist_t)), 0);
     for (j = 0; j < n; j++) {
         jl_value_t *st = bd[j];
         int is_flag_stmt = 0;
@@ -327,7 +328,7 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
                 else if (ma == (jl_value_t*)jl_no_constprop_sym)
                     li->constprop = 2;
                 else if (jl_is_expr(ma) && ((jl_expr_t*)ma)->head == jl_purity_sym) {
-                    if (jl_expr_nargs(ma) == 9) {
+                    if (jl_expr_nargs(ma) == NUM_EFFECTS_OVERRIDES) {
                         li->purity.overrides.ipo_consistent = jl_unbox_bool(jl_exprarg(ma, 0));
                         li->purity.overrides.ipo_effect_free = jl_unbox_bool(jl_exprarg(ma, 1));
                         li->purity.overrides.ipo_nothrow = jl_unbox_bool(jl_exprarg(ma, 2));
@@ -381,32 +382,50 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
             }
             bd[j] = jl_nothing;
         }
-        else if (jl_is_expr(st) && ((jl_expr_t*)st)->head == jl_boundscheck_sym) {
-            // Don't set IR_FLAG_INBOUNDS on boundscheck at the same level
+        else if (jl_is_expr(st) && ((jl_expr_t*)st)->head == jl_purity_sym) {
             is_flag_stmt = 1;
+            size_t na = jl_expr_nargs(st);
+            if (na == NUM_EFFECTS_OVERRIDES)
+                arraylist_push(purity_exprs, (void*)st);
+            else {
+                assert(na == 0);
+                arraylist_pop(purity_exprs);
+            }
+            bd[j] = jl_nothing;
         }
-        else if (jl_is_expr(st) && ((jl_expr_t*)st)->head == jl_return_sym) {
+        else if (jl_is_expr(st) && ((jl_expr_t*)st)->head == jl_boundscheck_sym)
+            // Don't set IR_FLAG_INBOUNDS on boundscheck at the same level
+            is_flag_stmt = 1;
+        else if (jl_is_expr(st) && ((jl_expr_t*)st)->head == jl_return_sym)
             jl_array_ptr_set(body, j, jl_new_struct(jl_returnnode_type, jl_exprarg(st, 0)));
-        }
-        else if (jl_is_expr(st) && (((jl_expr_t*)st)->head == jl_foreigncall_sym || ((jl_expr_t*)st)->head == jl_cfunction_sym)) {
+        else if (jl_is_expr(st) && (((jl_expr_t*)st)->head == jl_foreigncall_sym || ((jl_expr_t*)st)->head == jl_cfunction_sym))
             li->has_fcall = 1;
-        }
         if (is_flag_stmt)
             jl_array_uint32_set(li->ssaflags, j, 0);
         else {
-            uint8_t flag = 0;
+            uint32_t flag = 0;
             if (inbounds_depth > 0)
                 flag |= IR_FLAG_INBOUNDS;
             if (inline_flags->len > 0) {
-                void* inline_flag = inline_flags->items[inline_flags->len - 1];
+                void* inline_flag = inline_flags->items[inline_flags->len-1];
                 flag |= 1 << (inline_flag ? 1 : 2);
             }
+            int n_purity_exprs = purity_exprs->len;
+            if (n_purity_exprs > 0) {
+                // apply all purity overrides
+                for (int i = 0; i < n_purity_exprs; i++) {
+                    void* purity_expr = purity_exprs->items[i];
+                    for (int j = 0; j < NUM_EFFECTS_OVERRIDES; j++) {
+                        flag |= jl_unbox_bool(jl_exprarg((jl_value_t*)purity_expr, j)) ? (1 << (NUM_IR_FLAGS+j)) : 0;
+                    }
+                }
+            }
             jl_array_uint32_set(li->ssaflags, j, flag);
         }
     }
-    assert(inline_flags->len == 0); // malformed otherwise
-    arraylist_free(inline_flags);
-    free(inline_flags);
+    assert(inline_flags->len == 0 && purity_exprs->len == 0); // malformed otherwise
+    arraylist_free(inline_flags); arraylist_free(purity_exprs);
+    free(inline_flags); free(purity_exprs);
     jl_array_t *vinfo = (jl_array_t*)jl_exprarg(ir, 1);
     jl_array_t *vis = (jl_array_t*)jl_array_ptr_ref(vinfo, 0);
     size_t nslots = jl_array_nrows(vis);
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 3e0c24f908bc9..9df29a19c5e28 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1302,3 +1302,41 @@ function getindex_nothrow(xs::Vector{Int}, i::Int)
     end
 end
 @test Core.Compiler.is_nothrow(Base.infer_effects(getindex_nothrow, (Vector{Int}, Int)))
+
+# callsite `@assume_effects` annotation
+let ast = code_lowered((Int,)) do x
+        Base.@assume_effects :total identity(x)
+    end |> only
+    ssaflag = ast.ssaflags[findfirst(!iszero, ast.ssaflags)::Int]
+    override = Core.Compiler.decode_statement_effects_override(ssaflag)
+    # if this gets broken, check if this is synced with expr.jl
+    @test override.consistent && override.effect_free && override.nothrow &&
+          override.terminates_globally && !override.terminates_locally &&
+          override.notaskstate && override.inaccessiblememonly &&
+          override.noub && !override.noub_if_noinbounds
+end
+@test Base.infer_effects((Float64,)) do x
+    isinf(x) && return 0.0
+    return Base.@assume_effects :nothrow sin(x)
+end |> Core.Compiler.is_nothrow
+let effects = Base.infer_effects((Vector{Float64},)) do xs
+        isempty(xs) && return 0.0
+        Base.@assume_effects :nothrow begin
+            x = Base.@assume_effects :noub @inbounds xs[1]
+            isinf(x) && return 0.0
+            return sin(x)
+        end
+    end
+    # all nested overrides should be applied
+    @test Core.Compiler.is_nothrow(effects)
+    @test Core.Compiler.is_noub(effects)
+end
+@test Base.infer_effects((Int,)) do x
+    res = 1
+    0 ≤ x < 20 || error("bad fact")
+    Base.@assume_effects :terminates_locally while x > 1
+        res *= x
+        x -= 1
+    end
+    return res
+end |> Core.Compiler.is_terminates

From c731edb861540fc1b6737ebbe240ca83b2dbd913 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 7 Dec 2023 10:57:47 +0900
Subject: [PATCH 0383/1315] irinterp: skip `nothing` statement when analyzing
 `:nothrow` and `:noub` (#52417)

This commit makes irinterp skip `nothing` statements when looking
through `:nothrow` and `:noub` flags of all statements. This is
necessary since `nothing` can be inserted as a dummy node, e.g. to
prevent CFG change by `finish_current_bb!`, without explicitly marking
it as `IR_FLAG_NOTHROW`.

Alternatively, rather than altering irinterp, it might be better to mark
`IR_FLAG_NOTHROW` (and maybe even `IR_FLAG_EFFECT_FREE` and other flags
too) where those `nothing` statements are inserted. But I wasn't
confident that this would address all scenarios or if it's the best way
to go, so this commit opts for the previously mentioned symptomatic
approach.
---
 base/compiler/ssair/ir.jl       | 2 +-
 base/compiler/ssair/irinterp.jl | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index dc19c9a09fbba..9cdd127473c6d 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1588,7 +1588,7 @@ function finish_current_bb!(compact::IncrementalCompact, active_bb::Int,
             if unreachable
                 node[:stmt], node[:type], node[:line] = ReturnNode(), Union{}, 0
             else
-                node[:stmt], node[:type], node[:line] = nothing, Nothing, 0
+                node[:stmt], node[:type], node[:line], node[:flag] = nothing, Nothing, 0, IR_FLAGS_EFFECTS
             end
             compact.result_idx = old_result_idx + 1
         elseif cfg_transforms_enabled && compact.result_idx - 1 == first(bb.stmts)
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index dd9a133f36802..288f23132635a 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -418,6 +418,11 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
 
     nothrow = noub = true
     for idx = 1:length(ir.stmts)
+        if ir[SSAValue(idx)][:stmt] === nothing
+            # skip `nothing` statement, which might be inserted as a dummy node,
+            # e.g. by `finish_current_bb!` without explicitly marking it as `:nothrow`
+            continue
+        end
         flag = ir[SSAValue(idx)][:flag]
         nothrow &= has_flag(flag, IR_FLAG_NOTHROW)
         noub &= has_flag(flag, IR_FLAG_NOUB)

From 83abbcd551af37fd0bc4f8b66a090c24b5b1ecdb Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 7 Dec 2023 12:22:24 +0900
Subject: [PATCH 0384/1315] [REPLCompletions] improve `REPLInterpreter` effects
 of dict operations (#52347)

This should allow more completions for cases involving dict operations.
---
 base/dict.jl                        |  8 ++++----
 stdlib/REPL/test/replcompletions.jl | 18 ++++++++++++++++++
 2 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/base/dict.jl b/base/dict.jl
index afed320609f57..eaee28271d6d5 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -271,7 +271,7 @@ function empty!(h::Dict{K,V}) where V where K
 end
 
 # get the index where a key is stored, or -1 if not present
-@assume_effects :terminates_locally function ht_keyindex(h::Dict{K,V}, key) where V where K
+function ht_keyindex(h::Dict{K,V}, key) where V where K
     isempty(h) && return -1
     sz = length(h.keys)
     iter = 0
@@ -280,9 +280,9 @@ end
     index, sh = hashindex(key, sz)
     keys = h.keys
 
-    @inbounds while true
+    @assume_effects :terminates_locally :noub @inbounds while true
         isslotempty(h,index) && return -1
-        if h.slots[index] == sh
+        if sh == h.slots[index]
             k = keys[index]
             if (key ===  k || isequal(key, k))
                 return index
@@ -507,7 +507,7 @@ end
 
 function getindex(h::Dict{K,V}, key) where V where K
     index = ht_keyindex(h, key)
-    @inbounds return (index < 0) ? throw(KeyError(key)) : h.vals[index]::V
+    return index < 0 ? throw(KeyError(key)) : @assume_effects :noub @inbounds h.vals[index]::V
 end
 
 """
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 4ee9761524741..05064e7b7e063 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2156,3 +2156,21 @@ let t = REPLCompletions.repl_eval_ex(:(Base.PersistentDict(issue52099 => 3)), @_
         @test length(t.val) == 1
     end
 end
+
+# test REPLInterpreter effects for `getindex(::Dict, key)`
+for (DictT, KeyT) = Any[(Dict{Symbol,Any}, Symbol),
+                        (Dict{Int,Any}, Int),
+                        (Dict{String,Any}, String)]
+    @testset let DictT=DictT, KeyT=KeyT
+        effects = Base.infer_effects(getindex, (DictT,KeyT); interp=REPL.REPLCompletions.REPLInterpreter())
+        @test Core.Compiler.is_effect_free(effects)
+        @test Core.Compiler.is_terminates(effects)
+        @test Core.Compiler.is_noub(effects)
+        effects = Base.infer_effects((DictT,KeyT); interp=REPL.REPLCompletions.REPLInterpreter()) do d, key
+            key in keys(d)
+        end
+        @test Core.Compiler.is_effect_free(effects)
+        @test Core.Compiler.is_terminates(effects)
+        @test Core.Compiler.is_noub(effects)
+    end
+end

From fa69f9c728c66ce5473f732b390bbfa76123fe67 Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Thu, 7 Dec 2023 04:38:34 +0100
Subject: [PATCH 0385/1315] Fix type check in poll_fd() exception handler
 (#52377)

---
 stdlib/FileWatching/src/FileWatching.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/FileWatching/src/FileWatching.jl b/stdlib/FileWatching/src/FileWatching.jl
index 2a654547ae6e3..0e68cd97681ff 100644
--- a/stdlib/FileWatching/src/FileWatching.jl
+++ b/stdlib/FileWatching/src/FileWatching.jl
@@ -727,7 +727,7 @@ function poll_fd(s::Union{RawFD, Sys.iswindows() ? WindowsRawSocket : Union{}},
                     end
                 end
             catch ex
-                ex isa EOFError() || rethrow()
+                ex isa EOFError || rethrow()
                 return FDEvent()
             end
         else

From 75fdd86c6196de1c497657973f6edf8b2c99c0ef Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Thu, 7 Dec 2023 04:07:57 -0500
Subject: [PATCH 0386/1315] clarify at-views docstring (#52374)

---
 base/views.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/views.jl b/base/views.jl
index 70d4c1d9110ee..d83005c86f46c 100644
--- a/base/views.jl
+++ b/base/views.jl
@@ -224,16 +224,16 @@ Similarly, `@views` converts string slices into [`SubString`](@ref) views.
     occurs in functions called by that code.
 
 !!! compat "Julia 1.5"
-    Using `begin` in an indexing expression to refer to the first index requires at least
-    Julia 1.5.
+    Using `begin` in an indexing expression to refer to the first index was implemented
+    in Julia 1.4, but was only supported by `@views` starting in Julia 1.5.
 
 # Examples
 ```jldoctest
 julia> A = zeros(3, 3);
 
 julia> @views for row in 1:3
-           b = A[row, :]
-           b[:] .= row
+           b = A[row, :] # b is a view, not a copy
+           b .= row      # assign every element to the row index
        end
 
 julia> A

From 71ee30f9ed4ef9bb3aed48bb6808774716166b53 Mon Sep 17 00:00:00 2001
From: kamesy <58350382+kamesy@users.noreply.github.com>
Date: Thu, 7 Dec 2023 02:01:05 -0800
Subject: [PATCH 0387/1315] Expand geqp3! docs and replace Vectors with Refs
 (#51555)

---
 stdlib/LinearAlgebra/src/lapack.jl | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/lapack.jl b/stdlib/LinearAlgebra/src/lapack.jl
index 18ebe53453e44..51dd73f517a31 100644
--- a/stdlib/LinearAlgebra/src/lapack.jl
+++ b/stdlib/LinearAlgebra/src/lapack.jl
@@ -613,7 +613,9 @@ Compute the pivoted `QR` factorization of `A`, `AP = QR` using BLAS level 3.
 reflectors. The arguments `jpvt` and `tau` are optional and allow
 for passing preallocated arrays. When passed, `jpvt` must have length greater
 than or equal to `n` if `A` is an `(m x n)` matrix and `tau` must have length
-greater than or equal to the smallest dimension of `A`.
+greater than or equal to the smallest dimension of `A`. On entry, if `jpvt[j]`
+does not equal zero then the `j`th column of `A` is permuted to the front of
+`AP`.
 
 `A`, `jpvt`, and `tau` are modified in-place.
 """
@@ -2524,17 +2526,17 @@ for (laic1, elty) in
             if j != length(w)
                 throw(DimensionMismatch("vectors must have same length, but length of x is $j and length of w is $(length(w))"))
             end
-            sestpr = Vector{$elty}(undef, 1)
-            s = Vector{$elty}(undef, 1)
-            c = Vector{$elty}(undef, 1)
+            sestpr = Ref{$elty}()
+            s = Ref{$elty}()
+            c = Ref{$elty}()
             ccall((@blasfunc($laic1), libblastrampoline), Cvoid,
                 (Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, Ref{$elty},
-                 Ptr{$elty}, Ref{$elty}, Ptr{$elty}, Ptr{$elty},
-                 Ptr{$elty}),
+                 Ptr{$elty}, Ref{$elty}, Ref{$elty}, Ref{$elty},
+                 Ref{$elty}),
                 job, j, x, sest,
                 w, gamma, sestpr, s,
                 c)
-            sestpr[1], s[1], c[1]
+            sestpr[], s[], c[]
         end
     end
 end
@@ -2558,17 +2560,17 @@ for (laic1, elty, relty) in
             if j != length(w)
                 throw(DimensionMismatch("vectors must have same length, but length of x is $j and length of w is $(length(w))"))
             end
-            sestpr = Vector{$relty}(undef, 1)
-            s = Vector{$elty}(undef, 1)
-            c = Vector{$elty}(undef, 1)
+            sestpr = Ref{$relty}()
+            s = Ref{$elty}()
+            c = Ref{$elty}()
             ccall((@blasfunc($laic1), libblastrampoline), Cvoid,
                 (Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, Ref{$relty},
-                 Ptr{$elty}, Ref{$elty}, Ptr{$relty}, Ptr{$elty},
-                 Ptr{$elty}),
+                 Ptr{$elty}, Ref{$elty}, Ref{$relty}, Ref{$elty},
+                 Ref{$elty}),
                 job, j, x, sest,
                 w, gamma, sestpr, s,
                 c)
-            sestpr[1], s[1], c[1]
+            sestpr[], s[], c[]
         end
     end
 end

From 9a0d20929e251e1df21cca6e09479ecea7021873 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 7 Dec 2023 16:36:31 +0530
Subject: [PATCH 0388/1315] Use IndexStyle in `diagind` to optionally return a
 range of `CartesianIndex`es (#52115)

---
 stdlib/LinearAlgebra/src/dense.jl     | 12 ++++++++++--
 stdlib/LinearAlgebra/test/bidiag.jl   |  8 ++++++++
 stdlib/LinearAlgebra/test/diagonal.jl |  8 ++++++++
 3 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 02b9aee4c502e..b66cbee054eed 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -198,9 +198,17 @@ function fillband!(A::AbstractMatrix{T}, x, l, u) where T
     return A
 end
 
-diagind(m::Integer, n::Integer, k::Integer=0) =
+diagind(m::Integer, n::Integer, k::Integer=0) = diagind(IndexLinear(), m, n, k)
+diagind(::IndexLinear, m::Integer, n::Integer, k::Integer=0) =
     k <= 0 ? range(1-k, step=m+1, length=min(m+k, n)) : range(k*m+1, step=m+1, length=min(m, n-k))
 
+function diagind(::IndexCartesian, m::Integer, n::Integer, k::Integer=0)
+    Cstart = CartesianIndex(1 + max(0,-k), 1 + max(0,k))
+    Cstep = CartesianIndex(1, 1)
+    length = max(0, k <= 0 ? min(m+k, n) : min(m, n-k))
+    StepRangeLen(Cstart, Cstep, length)
+end
+
 """
     diagind(M, k::Integer=0)
 
@@ -222,7 +230,7 @@ julia> diagind(A,-1)
 """
 function diagind(A::AbstractMatrix, k::Integer=0)
     require_one_based_indexing(A)
-    diagind(size(A,1), size(A,2), k)
+    diagind(IndexStyle(A), size(A,1), size(A,2), k)
 end
 
 """
diff --git a/stdlib/LinearAlgebra/test/bidiag.jl b/stdlib/LinearAlgebra/test/bidiag.jl
index 2fce781e30ab1..bf65088dc953b 100644
--- a/stdlib/LinearAlgebra/test/bidiag.jl
+++ b/stdlib/LinearAlgebra/test/bidiag.jl
@@ -843,4 +843,12 @@ end
     @test all(iszero, diag(B, 1))
 end
 
+@testset "diagind" begin
+    B = Bidiagonal(1:4, 1:3, :U)
+    M = Matrix(B)
+    @testset for k in -4:4
+        @test B[diagind(B,k)] == M[diagind(M,k)]
+    end
+end
+
 end # module TestBidiagonal
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 72c99f742a2f4..83a5ea3b3e03d 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -1227,4 +1227,12 @@ end
     @test *(Diagonal(ones(n)), Diagonal(1:n), Diagonal(ones(n)), Diagonal(1:n)) isa Diagonal
 end
 
+@testset "diagind" begin
+    D = Diagonal(1:4)
+    M = Matrix(D)
+    @testset for k in -4:4
+        @test D[diagind(D,k)] == M[diagind(M,k)]
+    end
+end
+
 end # module TestDiagonal

From 39ccdb27990d0095d44715394bf2cb18f6b14dd3 Mon Sep 17 00:00:00 2001
From: Aravindh Krishnamoorthy <aravindh.krishnamoorthy@fau.de>
Date: Thu, 7 Dec 2023 12:21:05 +0100
Subject: [PATCH 0389/1315] Bunchkaufman- and LU-decomposition based
 generalized eigenvalues and eigenvectors (#50471)

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 NEWS.md                                     |  3 +
 base/combinatorics.jl                       | 38 +++++++++++
 stdlib/LinearAlgebra/src/LinearAlgebra.jl   | 10 +--
 stdlib/LinearAlgebra/src/bunchkaufman.jl    | 23 ++++++-
 stdlib/LinearAlgebra/src/symmetriceigen.jl  | 76 +++++++++++++++++++++
 stdlib/LinearAlgebra/test/symmetriceigen.jl | 73 +++++++++++++++++++-
 6 files changed, 215 insertions(+), 8 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index ca91c08e915ab..0dd4d2f53bc01 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -91,6 +91,9 @@ Standard library changes
 
 #### LinearAlgebra
 * `cbrt(::AbstractMatrix{<:Real})` is now defined and returns real-valued matrix cube roots of real-valued matrices ([#50661]).
+* `eigvals/eigen(A, bunchkaufman(B))` and `eigvals/eigen(A, lu(B))`, which utilize the Bunchkaufman (LDL) and LU decomposition of `B`,
+   respectively, now efficiently compute the generalized eigenvalues (`eigen`: and eigenvectors) of `A` and `B`. Note: The second
+   argument is the output of `bunchkaufman` or `lu` ([#50471]).
 
 #### Printf
 
diff --git a/base/combinatorics.jl b/base/combinatorics.jl
index 5afd96dc1dc4a..6923c2a793a43 100644
--- a/base/combinatorics.jl
+++ b/base/combinatorics.jl
@@ -136,6 +136,44 @@ function permutecols!!(a::AbstractMatrix, p::AbstractVector{<:Integer})
     a
 end
 
+# Row and column permutations for AbstractMatrix
+permutecols!(a::AbstractMatrix, p::AbstractVector{<:Integer}) =
+    _permute!(a, p, Base.swapcols!)
+permuterows!(a::AbstractMatrix, p::AbstractVector{<:Integer}) =
+    _permute!(a, p, Base.swaprows!)
+@inline function _permute!(a::AbstractMatrix, p::AbstractVector{<:Integer}, swapfun!::F) where {F}
+    require_one_based_indexing(a, p)
+    p .= .-p
+    for i in 1:length(p)
+        p[i] > 0 && continue
+        j = i
+        in = p[j] = -p[j]
+        while p[in] < 0
+            swapfun!(a, in, j)
+            j = in
+            in = p[in] = -p[in]
+        end
+    end
+    a
+end
+invpermutecols!(a::AbstractMatrix, p::AbstractVector{<:Integer}) =
+    _invpermute!(a, p, Base.swapcols!)
+invpermuterows!(a::AbstractMatrix, p::AbstractVector{<:Integer}) =
+    _invpermute!(a, p, Base.swaprows!)
+@inline function _invpermute!(a::AbstractMatrix, p::AbstractVector{<:Integer}, swapfun!::F) where {F}
+    require_one_based_indexing(a, p)
+    p .= .-p
+    for i in 1:length(p)
+        p[i] > 0 && continue
+        j = p[i] = -p[i]
+        while j != i
+           swapfun!(a, j, i)
+           j = p[j] = -p[j]
+        end
+     end
+    a
+end
+
 """
     permute!(v, p)
 
diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index 705c167b9e058..e18edf88f8c9e 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -11,11 +11,11 @@ import Base: \, /, *, ^, +, -, ==
 import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, asec, asech,
     asin, asinh, atan, atanh, axes, big, broadcast, cbrt, ceil, cis, collect, conj, convert,
     copy, copyto!, copymutable, cos, cosh, cot, coth, csc, csch, eltype, exp, fill!, floor,
-    getindex, hcat, getproperty, imag, inv, isapprox, isequal, isone, iszero, IndexStyle,
-    kron, kron!, length, log, map, ndims, one, oneunit, parent, permutedims,
-    power_by_squaring, promote_rule, real, sec, sech, setindex!, show, similar, sin,
-    sincos, sinh, size, sqrt, strides, stride, tan, tanh, transpose, trunc, typed_hcat,
-    vec, view, zero
+    getindex, hcat, getproperty, imag, inv, invpermuterows!, isapprox, isequal, isone, iszero,
+    IndexStyle, kron, kron!, length, log, map, ndims, one, oneunit, parent, permutecols!,
+    permutedims, permuterows!, power_by_squaring, promote_rule, real, sec, sech, setindex!,
+    show, similar, sin, sincos, sinh, size, sqrt, strides, stride, tan, tanh, transpose, trunc,
+    typed_hcat, vec, view, zero
 using Base: IndexLinear, promote_eltype, promote_op, promote_typeof, print_matrix,
     @propagate_inbounds, reduce, typed_hvcat, typed_vcat, require_one_based_indexing,
     splat
diff --git a/stdlib/LinearAlgebra/src/bunchkaufman.jl b/stdlib/LinearAlgebra/src/bunchkaufman.jl
index d1019a1a4ea5a..f995b3b8444c4 100644
--- a/stdlib/LinearAlgebra/src/bunchkaufman.jl
+++ b/stdlib/LinearAlgebra/src/bunchkaufman.jl
@@ -88,7 +88,7 @@ Base.iterate(S::BunchKaufman) = (S.D, Val(:UL))
 Base.iterate(S::BunchKaufman, ::Val{:UL}) = (S.uplo == 'L' ? S.L : S.U, Val(:p))
 Base.iterate(S::BunchKaufman, ::Val{:p}) = (S.p, Val(:done))
 Base.iterate(S::BunchKaufman, ::Val{:done}) = nothing
-
+copy(S::BunchKaufman) = BunchKaufman(copy(S.LD), copy(S.ipiv), S.uplo, S.symmetric, S.rook, S.info)
 
 """
     bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman
@@ -278,6 +278,27 @@ end
 Base.propertynames(B::BunchKaufman, private::Bool=false) =
     (:p, :P, :L, :U, :D, (private ? fieldnames(typeof(B)) : ())...)
 
+function getproperties!(B::BunchKaufman{T,<:StridedMatrix}) where {T<:BlasFloat}
+    # NOTE: Unlike in the 'getproperty' function, in this function L/U and D are computed in place.
+    if B.rook
+        LUD, od = LAPACK.syconvf_rook!(B.uplo, 'C', B.LD, B.ipiv)
+    else
+        LUD, od = LAPACK.syconv!(B.uplo, B.LD, B.ipiv)
+    end
+    if B.uplo == 'U'
+        M = UnitUpperTriangular(LUD)
+        du = od[2:end]
+        # Avoid aliasing dl and du.
+        dl = B.symmetric ? du : conj.(du)
+    else
+        M = UnitLowerTriangular(LUD)
+        dl = od[1:end-1]
+        # Avoid aliasing dl and du.
+        du = B.symmetric ? dl : conj.(dl)
+    end
+    return (M, Tridiagonal(dl, diag(LUD), du), B.p)
+end
+
 issuccess(B::BunchKaufman) = B.info == 0
 
 function adjoint(B::BunchKaufman)
diff --git a/stdlib/LinearAlgebra/src/symmetriceigen.jl b/stdlib/LinearAlgebra/src/symmetriceigen.jl
index 279577c31d664..4e35616f62181 100644
--- a/stdlib/LinearAlgebra/src/symmetriceigen.jl
+++ b/stdlib/LinearAlgebra/src/symmetriceigen.jl
@@ -184,6 +184,49 @@ function eigen!(A::AbstractMatrix, C::Cholesky; sortby::Union{Function,Nothing}=
     GeneralizedEigen(sorteig!(vals, vecs, sortby)...)
 end
 
+# Bunch-Kaufmann (LDLT) based solution for generalized eigenvalues and eigenvectors
+function eigen(A::StridedMatrix{T}, B::BunchKaufman{T,<:AbstractMatrix}; sortby::Union{Function,Nothing}=nothing) where {T<:BlasFloat}
+    eigen!(copy(A), copy(B); sortby)
+end
+function eigen!(A::StridedMatrix{T}, B::BunchKaufman{T,<:StridedMatrix}; sortby::Union{Function,Nothing}=nothing) where {T<:BlasFloat}
+    M, TD, p = getproperties!(B)
+    # Compute generalized eigenvalues of equivalent matrix:
+    #    A' = inv(Tridiagonal(dl,d,du))*inv(M)*P*A*P'*inv(M')
+    # See: https://github.com/JuliaLang/julia/pull/50471#issuecomment-1627836781
+    permutecols!(A, p)
+    permuterows!(A, p)
+    ldiv!(M, A)
+    rdiv!(A, M')
+    ldiv!(TD, A)
+    vals, vecs = eigen!(A; sortby)
+    # Compute generalized eigenvectors from 'vecs':
+    #   vecs = P'*inv(M')*vecs
+    # See: https://github.com/JuliaLang/julia/pull/50471#issuecomment-1627836781
+    M = B.uplo == 'U' ? UnitUpperTriangular{eltype(vecs)}(M) : UnitLowerTriangular{eltype(vecs)}(M) ;
+    ldiv!(M', vecs)
+    invpermuterows!(vecs, p)
+    GeneralizedEigen(sorteig!(vals, vecs, sortby)...)
+end
+
+# LU based solution for generalized eigenvalues and eigenvectors
+function eigen(A::StridedMatrix{T}, F::LU{T,<:StridedMatrix}; sortby::Union{Function,Nothing}=nothing) where {T}
+    return eigen!(copy(A), copy(F); sortby)
+end
+function eigen!(A::StridedMatrix{T}, F::LU{T,<:StridedMatrix}; sortby::Union{Function,Nothing}=nothing) where {T}
+    L = UnitLowerTriangular(F.L)
+    U = UpperTriangular(F.U)
+    permuterows!(A, F.p)
+    ldiv!(L, A)
+    rdiv!(A, U)
+    vals, vecs = eigen!(A; sortby)
+    # Compute generalized eigenvectors from 'vecs':
+    #   vecs = P'*inv(M')*vecs
+    # See: https://github.com/JuliaLang/julia/pull/50471#issuecomment-1627836781
+    U = UpperTriangular{eltype(vecs)}(U)
+    ldiv!(U, vecs)
+    GeneralizedEigen(sorteig!(vals, vecs, sortby)...)
+end
+
 # Perform U' \ A / U in-place, where U::Union{UpperTriangular,Diagonal}
 UtiAUi!(A, U) = _UtiAUi!(A, U)
 UtiAUi!(A::Symmetric, U) = Symmetric(_UtiAUi!(copytri!(parent(A), A.uplo), U), sym_uplo(A.uplo))
@@ -218,3 +261,36 @@ function eigvals!(A::AbstractMatrix{T}, C::Cholesky{T, <:AbstractMatrix}; sortby
     # Cholesky decomposition based eigenvalues
     return eigvals!(UtiAUi!(A, C.U); sortby)
 end
+
+# Bunch-Kaufmann (LDLT) based solution for generalized eigenvalues
+function eigvals(A::StridedMatrix{T}, B::BunchKaufman{T,<:AbstractMatrix}; sortby::Union{Function,Nothing}=nothing) where {T<:BlasFloat}
+    eigvals!(copy(A), copy(B); sortby)
+end
+function eigvals!(A::StridedMatrix{T}, B::BunchKaufman{T,<:StridedMatrix}; sortby::Union{Function,Nothing}=nothing) where {T<:BlasFloat}
+    M, TD, p = getproperties!(B)
+    # Compute generalized eigenvalues of equivalent matrix:
+    #    A' = inv(Tridiagonal(dl,d,du))*inv(M)*P*A*P'*inv(M')
+    # See: https://github.com/JuliaLang/julia/pull/50471#issuecomment-1627836781
+    permutecols!(A, p)
+    permuterows!(A, p)
+    ldiv!(M, A)
+    rdiv!(A, M')
+    ldiv!(TD, A)
+    return eigvals!(A; sortby)
+end
+
+# LU based solution for generalized eigenvalues
+function eigvals(A::StridedMatrix{T}, F::LU{T,<:StridedMatrix}; sortby::Union{Function,Nothing}=nothing) where {T}
+    return eigvals!(copy(A), copy(F); sortby)
+end
+function eigvals!(A::StridedMatrix{T}, F::LU{T,<:StridedMatrix}; sortby::Union{Function,Nothing}=nothing) where {T}
+    L = UnitLowerTriangular(F.L)
+    U = UpperTriangular(F.U)
+    # Compute generalized eigenvalues of equivalent matrix:
+    #    A' = inv(L)*(P*A)*inv(U)
+    # See: https://github.com/JuliaLang/julia/pull/50471#issuecomment-1627836781
+    permuterows!(A, F.p)
+    ldiv!(L, A)
+    rdiv!(A, U)
+    return eigvals!(A; sortby)
+end
diff --git a/stdlib/LinearAlgebra/test/symmetriceigen.jl b/stdlib/LinearAlgebra/test/symmetriceigen.jl
index c28c17255c222..e2f475323b292 100644
--- a/stdlib/LinearAlgebra/test/symmetriceigen.jl
+++ b/stdlib/LinearAlgebra/test/symmetriceigen.jl
@@ -8,7 +8,7 @@ using Test, LinearAlgebra
     ## Cholesky decomposition based
 
     # eigenvalue sorting
-    sf = x->(real(x),imag(x))
+    sf = x->(imag(x),real(x))
 
     ## Real valued
     A = Float64[1 1 0 0; 1 2 1 0; 0 1 3 1; 0 0 1 4]
@@ -40,6 +40,9 @@ using Test, LinearAlgebra
 end
 
 @testset "issue #49533" begin
+    # eigenvalue sorting
+    sf = x->(imag(x),real(x))
+
     ## Real valued
     A = Float64[1 1 0 0; 1 2 1 0; 0 1 3 1; 0 0 1 4]
     B = Matrix(Diagonal(Float64[1:4;]))
@@ -62,7 +65,6 @@ end
     B =  [2.0+2.0im 1.0+1.0im 4.0+4.0im 3.0+3.0im; 0 3.0+2.0im 1.0+1.0im 3.0+4.0im; 3.0+3.0im 1.0+4.0im 0 0; 0 1.0+2.0im 3.0+1.0im 1.0+1.0im]
     BH = B'B
     # eigen
-    sf = x->(real(x),imag(x))
     e1,v1 = eigen(A, Hermitian(BH))
     @test A*v1 ≈ Hermitian(BH)*v1*Diagonal(e1)
     e2,v2 = eigen(Hermitian(AH), B)
@@ -75,4 +77,71 @@ end
     @test eigvals(AH, BH; sortby=sf) ≈ eigvals(Hermitian(AH), Hermitian(BH); sortby=sf)
 end
 
+@testset "bk-lu-eigen-eigvals" begin
+    # Bunchkaufman decomposition based
+
+    # eigenvalue sorting
+    sf = x->(imag(x),real(x))
+
+    # Real-valued random matrix
+    N = 10
+    A = randn(N,N)
+    B = randn(N,N)
+    BH = (B+B')/2
+    # eigen
+    e0 = eigvals(A,BH; sortby=sf)
+    e,v = eigen(A,bunchkaufman(Hermitian(BH,:L)); sortby=sf)
+    @test e0 ≈ e
+    @test A*v ≈ BH*v*Diagonal(e)
+    e,v = eigen(A,bunchkaufman(Hermitian(BH,:U)); sortby=sf)
+    @test e0 ≈ e
+    @test A*v ≈ BH*v*Diagonal(e)
+    e,v = eigen(A,lu(Hermitian(BH,:L)); sortby=sf)
+    @test e0 ≈ e
+    @test A*v ≈ BH*v*Diagonal(e)
+    e,v = eigen(A,lu(Hermitian(BH,:U)); sortby=sf)
+    @test e0 ≈ e
+    @test A*v ≈ BH*v*Diagonal(e)
+    # eigvals
+    e0 = eigvals(A,BH; sortby=sf)
+    el = eigvals(A,bunchkaufman(Hermitian(BH,:L)); sortby=sf)
+    eu = eigvals(A,bunchkaufman(Hermitian(BH,:U)); sortby=sf)
+    @test e0 ≈ el
+    @test e0 ≈ eu
+    el = eigvals(A,lu(Hermitian(BH,:L)); sortby=sf)
+    eu = eigvals(A,lu(Hermitian(BH,:U)); sortby=sf)
+    @test e0 ≈ el
+    @test e0 ≈ eu
+
+    # Complex-valued random matrix
+    N = 10
+    A = complex.(randn(N,N),randn(N,N))
+    B = complex.(randn(N,N),randn(N,N))
+    BH = (B+B')/2
+    # eigen
+    e0 = eigvals(A,BH; sortby=sf)
+    e,v = eigen(A,bunchkaufman(Hermitian(BH,:L)); sortby=sf)
+    @test e0 ≈ e
+    @test A*v ≈ BH*v*Diagonal(e)
+    e,v = eigen(A,bunchkaufman(Hermitian(BH,:U)); sortby=sf)
+    @test e0 ≈ e
+    @test A*v ≈ BH*v*Diagonal(e)
+    e,v = eigen(A,lu(Hermitian(BH,:L)); sortby=sf)
+    @test e0 ≈ e
+    @test A*v ≈ BH*v*Diagonal(e)
+    e,v = eigen(A,lu(Hermitian(BH,:U)); sortby=sf)
+    @test e0 ≈ e
+    @test A*v ≈ BH*v*Diagonal(e)
+    # eigvals
+    e0 = eigvals(A,BH; sortby=sf)
+    el = eigvals(A,bunchkaufman(Hermitian(BH,:L)); sortby=sf)
+    eu = eigvals(A,bunchkaufman(Hermitian(BH,:U)); sortby=sf)
+    @test e0 ≈ el
+    @test e0 ≈ eu
+    el = eigvals(A,lu(Hermitian(BH,:L)); sortby=sf)
+    eu = eigvals(A,lu(Hermitian(BH,:U)); sortby=sf)
+    @test e0 ≈ el
+    @test e0 ≈ eu
+end
+
 end # module TestSymmetricEigen

From 431964fbef73970d5e559df52edef0b1cbbe4622 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 7 Dec 2023 08:27:02 -0600
Subject: [PATCH 0390/1315] Remove the GMP.round function (#52319)

---
 base/gmp.jl | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/base/gmp.jl b/base/gmp.jl
index 7cfcbd21e29da..b66c2eed9ae8d 100644
--- a/base/gmp.jl
+++ b/base/gmp.jl
@@ -320,11 +320,6 @@ function BigInt(x::Float64)
     unsafe_trunc(BigInt,x)
 end
 
-function round(::Type{BigInt}, x::Union{Float16,Float32,Float64}, r::RoundingMode{:ToZero})
-    isfinite(x) || throw(InexactError(:trunc, BigInt, x))
-    unsafe_trunc(BigInt,x)
-end
-
 BigInt(x::Float16) = BigInt(Float64(x))
 BigInt(x::Float32) = BigInt(Float64(x))
 

From b0abf958864ed0d5131a62614de198fe953b151f Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 7 Dec 2023 08:54:05 -0600
Subject: [PATCH 0391/1315] Add `shuffle!` algorithm specialized for
 `AbstractArray{Bool}` (#52133)

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
Co-authored-by: Denis Barucic <barucic.d@gmail.com>
---
 stdlib/Random/src/misc.jl      | 15 +++++++++++++++
 stdlib/Random/test/runtests.jl |  1 +
 2 files changed, 16 insertions(+)

diff --git a/stdlib/Random/src/misc.jl b/stdlib/Random/src/misc.jl
index 2cedb200bc022..908776383d45f 100644
--- a/stdlib/Random/src/misc.jl
+++ b/stdlib/Random/src/misc.jl
@@ -220,6 +220,21 @@ function shuffle!(r::AbstractRNG, a::AbstractArray)
     return a
 end
 
+function shuffle!(r::AbstractRNG, a::AbstractArray{Bool})
+    old_count = count(a)
+    len = length(a)
+    uncommon_value = 2old_count <= len
+    fuel = uncommon_value ? old_count : len - old_count
+    fuel == 0 && return a
+    a .= !uncommon_value
+    while fuel > 0
+        k = rand(r, eachindex(a))
+        fuel -= a[k] != uncommon_value
+        a[k] = uncommon_value
+    end
+    a
+end
+
 shuffle!(a::AbstractArray) = shuffle!(default_rng(), a)
 
 """
diff --git a/stdlib/Random/test/runtests.jl b/stdlib/Random/test/runtests.jl
index 2ad9d38d94845..61cee5c952c51 100644
--- a/stdlib/Random/test/runtests.jl
+++ b/stdlib/Random/test/runtests.jl
@@ -512,6 +512,7 @@ end
     @test shuffle!(mta,Vector(1:10)) == shuffle!(mtb,Vector(1:10))
     @test shuffle(mta,Vector(2:11)) == shuffle(mtb,2:11)
     @test shuffle!(mta, rand(mta, 2, 3)) == shuffle!(mtb, rand(mtb, 2, 3))
+    @test shuffle!(mta, rand(mta, Bool, 2, 3)) == shuffle!(mtb, rand(mtb, Bool, 2, 3))
     @test shuffle(mta, rand(mta, 2, 3)) == shuffle(mtb, rand(mtb, 2, 3))
 
     @test randperm(mta,10) == randperm(mtb,10)

From 067e02e5775b8588e753489a19786e7a3bee447c Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 7 Dec 2023 09:02:13 -0600
Subject: [PATCH 0392/1315] Optimize `sort!` for AbstractArray (#52278)

- Use `foreach` to union-split on dim rather than using dynamic dispatch. This is
reasonable because it is unrolling to a finite set with size equal to `ndims` (e.g. 2)
For high dimension arrays, this may still use dynamic dispatch (which is okay!)
- When `dims != 0`, we're sorting slices with non-one step size. These are slow to sort
so for large inputs copy to a contiguous array, sort that, and copy back.
- For very short inputs, don't even allocate a scratch space.
---
 base/sort.jl | 41 +++++++++++++++++++++++++++--------------
 1 file changed, 27 insertions(+), 14 deletions(-)

diff --git a/base/sort.jl b/base/sort.jl
index b9497d8136114..2b68f3d979aa8 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -2093,24 +2093,37 @@ function sort!(A::AbstractArray{T};
                by=identity,
                rev::Union{Bool,Nothing}=nothing,
                order::Ordering=Forward, # TODO stop eagerly over-allocating.
-               scratch::Union{Vector{T}, Nothing}=Vector{T}(undef, size(A, dims))) where T
-    __sort!(A, Val(dims), maybe_apply_initial_optimizations(alg), ord(lt, by, rev, order), scratch)
-end
-function __sort!(A::AbstractArray{T}, ::Val{K},
-                alg::Algorithm,
-                order::Ordering,
-                scratch::Union{Vector{T}, Nothing}) where {K,T}
+               scratch::Union{Vector{T}, Nothing}=size(A, dims) < 10 ? nothing : Vector{T}(undef, size(A, dims))) where T
     nd = ndims(A)
-
-    1 <= K <= nd || throw(ArgumentError("dimension out of range"))
-
-    remdims = ntuple(i -> i == K ? 1 : axes(A, i), nd)
-    for idx in CartesianIndices(remdims)
-        Av = view(A, ntuple(i -> i == K ? Colon() : idx[i], nd)...)
-        sort!(Av; alg, order, scratch)
+    1 <= dims <= nd || throw(ArgumentError("dimension out of range"))
+    alg2 = maybe_apply_initial_optimizations(alg)
+    order2 = ord(lt, by, rev, order)
+    foreach(ntuple(Val, nd)) do d
+        get_value(d) == dims || return
+        # We assume that an Integer between 1 and nd must be equal to one of the
+        # values 1:nd. If this assumption is false, then what's an integer? and
+        # also sort! will silently do nothing.
+
+        idxs = CartesianIndices(ntuple(i -> i == get_value(d) ? 1 : axes(A, i), ndims(A)))
+        get_view(idx) = view(A, ntuple(i -> i == get_value(d) ? Colon() : idx[i], ndims(A))...)
+        if d == Val(1) || size(A, get_value(d)) < 30
+            for idx in idxs
+                sort!(get_view(idx); alg=alg2, order=order2, scratch)
+            end
+        else
+            v = similar(get_view(first(idxs)))
+            for idx in idxs
+                vw = get_view(idx)
+                v .= vw
+                sort!(v; alg=alg2, order=order2, scratch)
+                vw .= v
+            end
+        end
+        A
     end
     A
 end
+get_value(::Val{x}) where x = x
 
 
 ## uint mapping to allow radix sorting primitives other than UInts ##

From e5046b4579cf571931714abbe14a3a049ca6383b Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 7 Dec 2023 11:21:38 -0500
Subject: [PATCH 0393/1315] Bump LLVM to 15.0.7+10 to fix GC issue (#52405)

---
 deps/checksums/clang            | 216 ++++++++--------
 deps/checksums/lld              | 216 ++++++++--------
 deps/checksums/llvm             | 436 ++++++++++++++++----------------
 deps/clang.version              |   2 +-
 deps/lld.version                |   2 +-
 deps/llvm-tools.version         |   4 +-
 deps/llvm.version               |   6 +-
 stdlib/LLD_jll/Project.toml     |   2 +-
 stdlib/libLLVM_jll/Project.toml |   2 +-
 9 files changed, 443 insertions(+), 443 deletions(-)

diff --git a/deps/checksums/clang b/deps/checksums/clang
index f0f458c6cce9a..78743a32a2956 100644
--- a/deps/checksums/clang
+++ b/deps/checksums/clang
@@ -1,108 +1,108 @@
-Clang.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/f11d13e193ab5e18c88652012d0313fd
-Clang.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/513a14b0a99695ef330c1109e53d2f9ebd44f9d189e2fac691f4dd3502dea0b1437dbad58fecfc99549d64c90237f5143a0d31b8d05dbd747eb9d2570ed85763
-Clang.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/97c7f0c55a0943ef658960aa6b8ad6fe
-Clang.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/7a655675d0d3b3a18f031effbfcd60b171d880ebbe14c64d82f3017e537d56deb19e7a613dbfe619dbd4e8c9db1a2d4e14eefa984f11efd086332eed5d141d06
-Clang.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/3ae704a7c7be76ce32bba7c29ef34bc7
-Clang.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/93550af832e64603431a4e87ef90af227f9e376184a839e073ccb8880399b83bb748f4dc0525a69ddcf2bae0a31a010bd27884a9b8f9462f8439899080bd83f7
-Clang.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/6bebcf58049da1baa3689f9b5b4c0508
-Clang.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/68dce1abe90fd6df3facf19f0e430f27a3d27426c6d5673b82e671a252e08f3bed435bbf571e0c203cb95f2b5311dfb948f9a4da81eeec4f53b3c27dd692b049
-Clang.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/ac81a4b721024af1f63a006047b23d61
-Clang.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/48673b058ceb6c022f553c567ee303154cc587adfb6d5e2c60bf3594a47515cfee01bf6abda54a9f54e49b3bbc40bef372f2cd25e4eca4966834fdf5cc1ce150
-Clang.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/51ec3b7ad77d6a525a433cd9044046f7
-Clang.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b67f6c782734d5a1b3bac8b4f93d0bbe49cc2a1fde095c1d13517d19b1631a926f31291c92058d560b4cd69a6161891b1808ad8f6f6e30e8c103e7183d5f59d8
-Clang.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/bb3218601635220ded4b8285d991b88a
-Clang.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/0c60978c8b09a9cfdb7042dbfa61b5147748e968c08508df535a26b8d6ce199837b2ca7aee483d940ddb60aa601a191247e31c89e89d9f1eb427e28358a8c0cb
-Clang.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/53631f7d2506def52ff0bdc9b60e703c
-Clang.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/5a0362e15e3ab1b39e88ebf1c5fd8c179e72d784516d6fdf0139180f3e59806ae07f0bf11f92d0313baf3340b77d872d8f6ce04f1d9f2fe1ba15cbf4b7ae3c61
-Clang.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/8a4061b3454b411f05c8c375b3af4f44
-Clang.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/2ee66b4a16821f0fc5f8a2aad92017f71767d5f12374425162c0ba9440ad40082780f21114f61e51ee35be4f0eccd8d61e28c964e2b724046c572945e9410740
-Clang.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/eb3d9c2224594d96c2b735ebb420f24a
-Clang.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/1ea760423afcb28d306f1bcd67d25d1bdc88dee21445f397bfe5b2fdddd84c8343fc4e5fbedb006640546b28643946aff766d7660e75e2d25c3fde51f64e35d7
-Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/ee4b539db8439cf3eb480f4f86b67588
-Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/fe73b6d62a39e8724bf3cc7ddad385958ef1fc80bce8a6c7a4f57c4bb383736b2ed4a59da228683101bf2f16d4673d9012a30973c22b4b9dbad4be75872a4a95
-Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/27e36fa4a5173cdb6179c27299e80128
-Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/9b078f25921f2208fb2cf7ffadeb7f451be772527a6a9a268f44c20a17b8369b9e0b7f55b48ca38ccfa77f9f2a4209a6168001300ebf63ae09a50bc19e1a5403
-Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/76086701d89bd10682c0f937571af5be
-Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/0d637913b61dcab5aa32e7d2b1315e1d597114f9c5a9dd8f9c50bf26ca8260cd76a9cf4e4992bf7a502ce6ae682222a41f6d44e5a5676f329837d4ec5151dddd
-Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/9151fa6e2a3d3cf51f1ccc0023ea7e23
-Clang.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/56ebc1653607e623d4a1ecba4a66865b069b548a5d3ff3410e712da6e20e9ae222d5ed6fafe50c924fdd927a6052cc02287aeb5a49fd6a404d7ead243f04d230
-Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/cc22ad5247ded68dd2b22f49d9a9da0b
-Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9f42403c94ec2978f252a38215b0feeb9e2e1131a777bab52bfdec1fbd0399e12008e4012254a53c92b31e7db4d9dcaccd47be40f37d5e23596648ba89e77f9f
-Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/ac2fbc3060d46a0ff2b1536db0d87461
-Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/a5db6ffeabaeaf20cb8b9b61530094fcca442de249265f9bd5d62067aab663fc42ed65ee87fea91e427648340e3a8a739a6b38363ced69aa2c6f50bc2a14dee9
-Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/916988129901ce50be35b29ca2969ba4
-Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/e37769b80134a14ffca04f85e4a82b36c61395f1459a0122fd07505561aefe0fa8e681d428bfd58fe4c40bb8d4c201e8fc7a1029de2527eb78728ab8d0513981
-Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/d57074a9cd8d0a99db44026a75bbed52
-Clang.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/2bd80d0d5ee6d3fa14d1c5e1c5838f5fef13f0d31012ed0ecaefce66f35d2918faad2444eeedddc64a699b1843b705d002f95ef7f8d82a2dbbe55fe1ff545591
-Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/2aeda3d3dbb3c4d294d3cdfad028aca5
-Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/597ac2c8fa1e00f157af7555f82f7f011a74f6e24ec6dbfca31f5e104b67d6fc157f59b03689afe16cc35f3b8840a22867766d17b92750891e5fcdd0b6027ffd
-Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/8318580861648c955f488eed4c2beb87
-Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/6b4f85bfa1bc804666c8e25f15c49dd67c665a261e6a5e79b1d72f079a9cb02ce4c929855e342aa0c0a08fb7ff8891eb93468dc4dad598367eac0314823d398f
-Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/d8c1f0aaa04b0a7b8795477a67fad0c0
-Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/5ca6f1ab1e17a4e4712397be9dd040641ee8583c21670a2c26881bd917b1d54420d193efe039ea1aa929b7647b0672838c9309d011c733aa5d060598a985a84b
-Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/6dccafa2ab530b162b42948e4e089fc3
-Clang.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/c4a9e1703a1b4c4f7753d16d1dd9cb6159c7199a9217ff01ae2e5b29bf1cbc4eb7e3c9549afe84c23cb767bf095d2f19635dd6451bbf16e7716561b317f6adbc
-Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/cf3a71a9368cafd9c90d0949069715ef
-Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/b3a6fd1bc2ce52a96915e8095a0ccaf9c9234446336249cf796fe2853f5a95808de7bdec126032135ef4ed202dd83058a055fae95dc06a7c4aef575715d17177
-Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/f15f065e1e759d94576373023cfda5e7
-Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/94903b6220ceb155f1407e822e0449584f9a39ed899c753146736884cebf054b3ce0fc3da657ece6e9573b2699829ebce8b5737c329e67e78fc12fda7a6bbbed
-Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/7047338e3cdff0e9bd52d04160ef0ac2
-Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/fa48444ab31826eb06a9eca8c209d7beef952b11e1448bfc2e4dd1906ac5a12fa84fd0f048069cbdecf0ddebf6fe12bfc44d2dd6c117d3d17befb17d05ef0efb
-Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/3497b263dc6af14911baf3457f0e002d
-Clang.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/44853f230ed408744fb79911f7fa94843a6dc034dd52ecae86710325f9c6ce635771bd3e54b573f021d30542cf1a72cc92a338454633990c25ef51eb741cd63a
-Clang.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/9ecbe0287e26e692377b249e7b56943e
-Clang.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/ac1ad5ea8e31d68231fa83d54bb8bc63d14b906682590e209fb50dbb6bb41349c1683fa08f4cdcd381f0c05eb7b80443af26e3557110fceb075f392f6cba3acf
-Clang.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/83a7ace018fd7c1ff108b74f71064e00
-Clang.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/8ccb3e34e6d5e92b30024877db4df2d697420a3318eda2413442d10b7e8541a25ffe1b8b4133d37882ed6ddbd0ef7aff984315946538946484150f5b8d7307c1
-Clang.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2ebc196f9c8d210d7e99f9674cf92c38
-Clang.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d6a236854893629a5e318dd3b4cfc99ae75849fa3677c466d06355a3e6ba002db07fc0cee74ab2abf17a56cb58b37bb58e65d9c1f760d1d900dab35372afadc3
-Clang.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/48f329f4721bb4a5c805291449f397b6
-Clang.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/5e781a7e1ca0a8fdf8065d1ca9b5ecc6f2b85cb3ce6544d7aace5d86c7dccfb25ad46caf39b9231def435c0a61f7466638c3de5878bb20830fbf77e25d39347a
-Clang.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/b44457db229714204cdc46862511a8f9
-Clang.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/fab8fa3518106d833aa03e83b17db2e19d57894d5061459376a13de9c825ca3d500d0ea5dede65455f0cd35e00e8e92ed2da9c7c6f085cc0d6b0efd9b755c9b1
-Clang.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/16821bd1660dddb0b807023a00106fc0
-Clang.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/30a3ff94e6a41a719d3b8cec64d9445f69f5ec697b2496dd0f637ae6ed3d6398df34bed47676d1ca8d96a9d83bb59c803246c64d65cbcc19f1c4536c4a83a010
-Clang.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/1d1640575d3ae6ec8c8119c01d48e4d0
-Clang.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/0094a40618ccaa6a1abb5f90f8ded22b9b13f3e1fdb49d71e5cd32666a96ccc02fe2555101b747eb2599178428841d97f273e9f275a2f7ec1666337788a50898
-Clang.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/c2e562ab1853b204ae278286bd08a174
-Clang.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/d668546ab19a6f101aa5fdf3ac81010663b3d1b05870ab413e6ca227901b4653c4ad7f198ed1f97ab33b7c679d4589451f7ba2acc0d17033f9402ab48c8179b9
-Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/259877c60e0bd46d38fa6f442e3adc2a
-Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/697fbb22251008dc0af7b85cd4aaf7213e7ab1c1c546df0d5df1a5e9bd7ee7d3acf7008059ffe6ad904719c520aaa7e11464b4bf639f5c15a752ba1ebeadc45e
-Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/7a3e2d4a5e1e81ff723629f0f4213623
-Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/6d5cb30265751e4486ac0ff8f46bcc305cc52129130ef2f2d79fb000ec375a402de80302ba42ce381342e52e31e3827dd3958bc4cb125e28b1890b0b6ff16f45
-Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/fc86537fbf358dbb05142e34a60a6677
-Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/14915a943536fde5a27e26d3b1d067739cd456f274f16772fa3e5dd114813a73b556663e406ce5370b3ca7ece201dae74db5c9c76e26488611b2e551e26a71c4
-Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/5efc569392f8892668f4b7c6b23f4234
-Clang.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/01a7a29a9587ea9b0bf78cfec86a4f458466dd9fa3237a9caf55c96ab58fde10c60d5d8148b00cdff7cb74d43b93a806d704ca064aeb631d4cff3f2a5b63e547
-Clang.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/9b9db8d4a19045a4f9f9f6d443564bfa
-Clang.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/d32d1f731752e1f39fd5cd5c671d439249092ca2a7002c1d29ad152a273a56df03c197489dc7c52a3a2b94b7368934f93f3602cfe5a50eb949a8cfa902f4edfe
-Clang.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/e05b07aca51f3f463b2d77cce7fc3e50
-Clang.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/c17c396462785ebac988c52679517edddf15ccaa46357c4b8e21c939c4a23aa82503f5fada360d003e087b03b0978141780af8504dc7d87c61e0f41ea0a5cc43
-Clang.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/b28a8a689f053b5bc2427f9f2843a82f
-Clang.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/e7acc5e7eaff6fe784ed94240f4b9a7e3cd550b9c8cfd5bac7c9e8b6697a78ef876c52a2e593caa09938b629734361c30317ec748366fe26800c7b0419e86cc5
-Clang.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/12551be7929fb3bd8cbe3bc6346d17e5
-Clang.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/0c3650ddf008768300b4da3119667207c78bdef2dcb185d0986cf5c0eac87d59a772261de97f8afe2e872178f98bb0483f81e577d7398dbbef8d1cc01c97bf87
-Clang.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/38ae5bb94d4bfd9ae0cdd4adc7c46241
-Clang.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/035735f1724f93dd96fa60c0fb64453f309e3628da2a7373a76418a22c74d5770e99ac52d460559420454bd4d4e95d0291bd35308c542f3b4004efd61a528646
-Clang.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/5e2744c263f84a40e78526ab456b625a
-Clang.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/d3eebce8107972f693b2aac8d27ca724e8c0de382c3bf9ab2063590ef694c3177d2c7e9cc73bb359fe480413c817ce24df4994cb2f7cd14c325baa8e329ce84a
-Clang.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/5b35d50b46f46f84937207cbbe53f361
-Clang.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/7b1ff511a59e93aba410c2fae82c12a732efa8c6978e48a2d0ba480e3f5bed305c30b25a169555e4f23d2fc4c257e2a04150bb17b19c28469825e549c7a0ffcc
-Clang.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/89d5bc6e2ed559b89b1e69a062b2b0bf
-Clang.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/658da15ad6615e406e2f4117d6c447ca819383a2add6c236c8e57f150742ab4512c2f198b92c3d51f4236745aa40b8bf63d0b78f6ed0f3c748771717bc8eceba
-Clang.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/4a18a0ea6afd7708adb6023e92f81549
-Clang.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/2bc99affd9098c10ea35a90245006f25c10249616cea5395974502e5c82a5c48569e064c5c2436ed01348675b2b590b50fc6d493407ddf63a953309c225705b9
-Clang.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/f257257f8c4b05983e802bb32701ab3e
-Clang.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/3090e623585702693ea93b17564f5393f54a839f3e655aaea3461dc8cf6ba71a5191cc87a7043da4bde1c1bd5a7caeadc36b99c64e524e60c85aa95557a9b07e
-Clang.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/8550b772d168d5b8ef760c58bdf6897a
-Clang.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/bc35342a4587dff85acfd059415790b2a05bdfcf4e5657aabfce48fed34fc1ced89eb5924f4a03159736da2538954e049f2293ed307912d50e47aab3118b7fc7
-Clang.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/8c2124c8edc3e8e0d48b4cc55247b6b7
-Clang.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/a9282c87c8bb658f3f52ee2fa8c8636dded015b456d42a8edfec9f395185180b783b9dbe75d6bad4dc977571dcafcdeff162d5bb100f447c883b135246d8324e
-Clang.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/a4cbc590373f57422eef9f29d4174b87
-Clang.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/3286759915cc733f7aa3784e9cfa0e88c69a2fc6c3bf1bd34f401f7ada9db63c51f51e138c0086a4eeaafa8fa36bc90e11a56f57857daa4772e9c4d45ad5fc9a
-Clang.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/ebd1348b93fa59b64750230ae6c84977
-Clang.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/10f742b2db05da287ab7eea5d2c75f4c6dfd7798f2f5b13a6ec1da166aedf5d591a40bcc2df3383072eaf12584901e56f177d8fbfcbbc5b3b0db06e2d829c4cd
-Clang.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/739f8ba3cdc2afb4e03b9f03d4872cd5
-Clang.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/25df8931176dd77881494d94ecd52c4fccabf72e8d34d646016fc3cd3eb151a59cf994a796fd1f7bb776f62ca51cd03640c1c1817c857c117445e2c1ba3c8c41
-Clang.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/62714b3305623018e2c8c774509a8514
-Clang.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/cc95aed610963b63aaa7267c0d77fd57e29e19730d369135a27a9b3956837f34197b69af8239d38498cd004e9723ad78d279ed159aeef655dfb173f426420375
+Clang.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/b064c4494822dc829611629c4f2bd5eb
+Clang.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/6f4fcfebbea9df7964eb6f7b4c33b91baaa2abb03c44e0c51150d894d22d4f99e1ccb6b6f9acfb45f532bbb61e2ff11515d306a56004be46f67d60134259bdfd
+Clang.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/8a17e03287b24b2e9e08a4f753e12fe0
+Clang.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/065a53430ddfc2cf202ad0d18933967af3f4ebe07bd59ac41856d0ea9e67a59f958850b7bb2312f98b1927d5e74bdd9015867145eebd242930a081c58a9bbd19
+Clang.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/d7d43a6f98be3c09c3c5b9cebd6fc930
+Clang.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/290cc24e1278b7e6648d006669bccfec1c41d797718e16c9996588969b7fc9eda360cfa0d2a7d100b0c5e403fabdc77487c11d0a812fe51e9cc2ec2a814192e7
+Clang.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/95036da7fb8a37330ea3a74f721460e7
+Clang.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/7d1df0c6c8514153a7295a75b79f827d724d53542f39773d0572be9cc24d8793ab02e35ca818f17661bd777bae7e346e8318f139e9f141736f10214b80d7461f
+Clang.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/81854d7e53af48122a80448106a5cec9
+Clang.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0744f60891c18a8fdfe8e4c11b827fa42ed98285bb0557837f7b6dafcb1eabcf763d787c4b4b541d0a3e40905008c6e7b2d76d76ac7edf8a470cfc39e635f43d
+Clang.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/e381e3ec37796905cf0d1863f34d316e
+Clang.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/417218e1447ffcdf642d9e28e7ffae98138efafe5292f6dae83cf2490eb89b3cf39cbff5c77b6c442a0e04173f9eb22ff0dbb0469cdfc622f7eefe8bdd65a5ef
+Clang.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/7972214282a5b81512a185e023488970
+Clang.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/01483ffbb7e5878ed95843d8e750ae163018fb7fd2bc044aa42d55024248d17fbc094154968b7297aad6131aa7976630af282be4dbda1b9b6114cd660d8cb075
+Clang.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/22d08b77071e480d81a1e3c0b7ad7f66
+Clang.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/b7e3c2b1cb6f00fe1280b0bb9f72f43e5883df37fc50b750e663845083d7c797f4a4a47c4703169a29a0c70899e92b8f9d861674563164590b4689d7bf39cf4f
+Clang.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/abb72f91e3ee55c95a5364e1ec22c161
+Clang.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/899fb8b9734c0041b524d6e8befe61d7c0980fb697be82297f4c091a71c30e1f56c1f8fd76149853d7f7a4026148d934aef906ef4a35fb00d9dbc51a56bdb5e7
+Clang.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/745d75f7eb0d8b905182f08c0c1f9911
+Clang.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/9f249ad4078fc023874c8d8990b981aef1663828533c41841bb5ed860832fde7f9b37f19d78dcf06bbbff73b24286204a686d051abeada7dc484a1fc5bf8d9ee
+Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d2b4126d32ff0b9e28b85d91feeced15
+Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/d319064266d2d264ffec849d44efddc6f1835058a7a0e33d3e78dd2122ddc18b0303c38a265d86145debfc5cae9b98c3794b447fa688e042bbcb4f75119f9788
+Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/4161a2b194e54c35badc65124a19b81f
+Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/7302ecb2f05b697ad212fe1d3a1d24740d3d5a8bd1b01a61955ba84c1592f80e7ca3b5ceb7b62361ee61eaadec762a2eb7c899c53b7b4e06fccd8c71ab3ead46
+Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/c2d179b7b8d9afd783e9be03f258884b
+Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/4455aed97627d50caaa28624ab15a099b9e174988bddd13ca558e1796791606c25a22689beec358e03d4e2760f6778a2d54a76538e370637169e3b9120e664a8
+Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/c6aa69e3061de0bc80b17108ac89f6d6
+Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/012aa640b4359842081c06c76bf51c208bba6a494e6c8167c1abf57b8a01677376c23917b0bf66edc7afd5dcf83f08090fb5a51ac1604213d6e3ed48bdd64118
+Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/1abf2235894e554d19b1e5372149f38f
+Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/f35cceb0f39dc444435e9db90c6bd8d39adf49cc9c885bc190df051e38c13379e5d5ea5618034763c608abcce06f363c93397fcccc493989f4fdb910e800aa7e
+Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/5ecd609bac911e14fd7e36fef5ad8e65
+Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/d05457ce07abd12eeee5a036742f66ec4dac99190e98e4fa26c7b59d00b5c90a98bfc65352355ccc609ffb7114106f66dfea166de1eff1d3553180c2cc5484c7
+Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/49a60af7a47d4a5ba9838594af44b695
+Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/06bc663411ea5b156fee0deab246abbce42d8c180489cd38cc0a1bfa9c73c4d21e382407decec65750423269bb71c758bf2401788aea884394e8ce40aa75f9bc
+Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/b555bc479f57daae26101118b71e5b9a
+Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/aabe9e63b6f11101d6b9be4c56b945014c49373ddf670346baec1ef255c504341c9c3f8e729684c17df8ca50b108e0f4b2441b7d5b55a8e2afde3934866b5f6c
+Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/5ef0a90f103a00c80c68309b5bcf1f4d
+Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/37266e4253e853b68a41d4ae21e3c6f8b76d9799f8b802d347b8de72e33e529364c4ff48de0e11fabfb85f5d982a3b0fba594f4098f6b428c883fced9767517c
+Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/915cacbf726988039454f100fd007f76
+Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/15bfafb2b04655617190f8ba8cf1f5a92ed277eefb84e22b8ebbe05f19b384cf296db893e2d2abffb1228749c07e3e5a59e42d8becb3c32591970d060beb71db
+Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/dc2c2c78c6446cd17fc55e7499ebd9b5
+Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/a4713dc6fabe3b374632534452a4ffc997588d2e15f4ba08087a9c0dc23b1f447ab5d33557f56eb0523433ce534da2def7de76600021825781d662bfbe09e094
+Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/855f38cf2d8b2761319ed6670897a32a
+Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/eca1511c2eaaca9a538efe2f04f17234dc2c0920d2e4081b7e1b92565000028749f7d379574c636f04754e51baa04c193437e9bf755fcdbbfd5ce3a96c7c5a1e
+Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/8601f1d8e99af31a38e044daeddc3622
+Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/dca2e5434f83ed1829e16e6cf7abed86bdd3251492998bfc808dd117a253a08886234d5e1086bcec76a38f3373ae76a36a4c1a81a1967fda567b95aadbc354c7
+Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/82c18bf06d579467d7eebeb646238b25
+Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/4669a4a7e62af66271259bc15b38dc63e72227097eab35b93d44c483d48205b45403a83fa779c10f926bed2fab1347a73d93956930550194343525e3ff642855
+Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/99f9eb32064c66ad460fbf73d4ec379b
+Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/074773e19ba60ddf152e7a65689bcb2c0ff255813cd4079190ddad14442be698edbf9917a9f042b005a666a879261c026f265309254d2c4e6ac07e85dfefddee
+Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/ab5c8cac975d0348bdab3f55850db1a8
+Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/f8ded9ea7c2209a63349e5ba221adfc76689c1299087680108939474c6bc965506245632788c9af4975b3cf099c9a85e94aa3fdf0f2f139b8462ee2f9b306704
+Clang.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/9cd24f4c1519ed384dbe5a5325943e86
+Clang.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/579177600090fe900edf8e6bd5ab7e8617d74c411769e6726a424492f468c3fa9938101673ee2a13ae1e3ce5b0fc22d74589e4eb6e31e6a411d2f0b50eac05f2
+Clang.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/970230c1742c8005358514ff5c44e6b5
+Clang.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f24e1bf1c92bea7519a6b767c4391566bc80d1668e2562f4c083f7d68b7166e9330b83fa45406129ba3a0caba5ff8d18a90273e9c7992d93f4b915ee54c6f5a9
+Clang.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/6b331d43437f38918216388402529ff4
+Clang.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d302d08b7ed46a7c907a0b04e25947ba0f84e5e12486d3dcd4b0b875e9d686902fffe89eb7db631b9be33606c05b83a13181295bcde45653c6959f7f5c1ba9d8
+Clang.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/46e24960499c926aa047f1b29da282e3
+Clang.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/6efddeb8de7bb9f6245c604c1f80a1a1449278b1b63ac8787b27092713324e4cfb483a03684b7e58e2dd14d15f39fe6e315bd654d2cf788c03b333fe5068ed10
+Clang.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/1540ce6fb7925df9124ebfe27ace9ae1
+Clang.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/9acc77743c34ccab9f362dcd5cdf761ecfc2dc0c7974d3f62b4dde852427de327e9c53981988cf5ebd6c29ea89221d938bfd23783ba64522fcb7bad5cff7f79c
+Clang.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/2bc9b9a0d15a35e7311ea30d6240d04d
+Clang.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/4ec99c6c90a870485bc4eb526bbed1cc1aba5f35f23ff47d32c86e64871806d6ff94244869b14600f82d5e8f0dc91ae307e87d808c3b89ec92b1e9c8519fbec1
+Clang.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/73b8c5fee1a5c1f3a59d75e4ab7482fd
+Clang.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/f4eb27d2dac224585e274ae5bd9012e60c044220d39daa2a46e00da54e8cb26b20f9447f111c71364d05594683773d73fd22e06cacd465c64ce5c0fe0b51eb43
+Clang.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/7c2c723aebc97f0df6a06ab04117e7a6
+Clang.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/e2d28c9a69c7d384cc82c077138fad2f8c87c89ae4400a6ebb468dd8c26695db42e4889542fb91f515cd53d9e7d71859ff7b9614cdbb6a6c6a40a67402737495
+Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/e58dfa6c7f5647eeb320e12b0be71e94
+Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/1817b521f096597b8be1a08ba4cff23725c4191988844423c1ee13c62202093c9fdc677554c8a416e68c2c8efadcf39b7b2011d4ef6662704f2793121827508b
+Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/a617b5275ee7b13a9ca8d45a8a1bbcc4
+Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/074b61e67d6ac161912ac8cba8dad2b5d0daa310dc7a23a91659f9734248c94a31f1a3af97aa02cc3aa8d226bed6cd25d80a4dcd15024b68b417df973a37e59b
+Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2fc553d70042a737fb6f8919ba8c7586
+Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/98a4ac67f40d48c86819ceb5fe7692f367207b039bcaea7068d04137e529c7019d7369f7495ee8aadec66968736e665e81185732da26be12ba06be331f7e9bff
+Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7191ddb4f1263b75b475a4ca7e258dad
+Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/91dc613500fa03aa0f972800ea33a5602b25542314ed47f4e3457aed1d218b14f988f3d6a6a66d0ff14df152aab7df4ff798a5725078edb208c06540e9ec93e2
+Clang.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/5c8b2900fe9fc12db25ee97dcb489f85
+Clang.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/bc7b36f3ba8f7ba3463a36b49f2eed6e5a3683c50f02c2901f6828d0e8ef31e61850aeb2f3668df206703123b34281a1038820be9ea38381a4be1204b5af1325
+Clang.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/f4567028c971108cb7f6970041eb58eb
+Clang.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/9f6f5e65480720bebefd46a207ce32958304ded6f6ba6135ab700ee6263bf9e5fca55cba6eebb9f651fa8b6bd03de5df1bcdcddd17ce33c3b19ef137e998eb20
+Clang.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/6e3487ee5dc66c1d30bc269b53f78176
+Clang.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/0479baed38a2810e0ccb813f00d40c1159acaa54270d7074df364e7d39dcfab524cd83a63b712ed3bd992792eee596a53202ec5363097f019fbaa07a7a5123e6
+Clang.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ac5de702c96c77d8257d72dc003ab347
+Clang.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f74a9ba8cef5cb0fdc4a2229ccd911c4c9f612a6f2446a85fdca13918a034a6e43f365e0b46580a0a0a690c871a07a17ef8cd0d40da74ed210b78de8cfa6c253
+Clang.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/1889148c5bef3f759430f78c9806ffaf
+Clang.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/7e5f5a3834abd1a95b03bc5b2bd095d4c16950d6a67d015d82e7985f5b918cc879ae1197a636ec6582fb71929d392a5758dba48d8a9ab6563454170caeb46421
+Clang.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/1c2833125dea9030c8d36c372367ed4b
+Clang.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/0399915bd90fc8d798494b4eaf21dcc8587b8634003bd0bff0be66f4986587b8fdec3fb324defc3fd2ebf6793db8d3444e1188d2d300b8b1aacd3d1eb5a48114
+Clang.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/64c0ac9f6a4a4f8a47c9a944f79f6760
+Clang.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/901ac11e5f210c0a6f06e88e816333316c880f0b92df482eef7154393535b3a4342534167b1e572b529284d42adbb251e5522dfec1ca027443cba346bb89c467
+Clang.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/bbf33438b1316d8900155c74583e9bcf
+Clang.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/5c3eb14173b1bd623007820d8731cf15a2e30cc02cb28d0552bc2e79029cdeaa8e86a516e980fdbd87988acb3667254902287e7a78e1a753f1b338e17e1e183f
+Clang.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/725287948e706bfc5749b0bc0844980d
+Clang.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/e419a863044afc67471b5f0f1f53dc19f26cd0ee06cbe6aa3f5367e5e8056564abc6625b9323cf24a0a625bf07a9783b0a569738e4ab8c2ee841c0c37c0f6b17
+Clang.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/55adeeb7f199bdfdb0c72e50420bbc38
+Clang.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/94272d7b12ec6342c03865b6f8eda72d71119bc153aa14958f6c324e9844f870feeb97adb2e7950162897aa606c74e95f37aeaaefb1b37985025055212255aea
+Clang.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/a8e552a0a30f6f764a40c525bebdd220
+Clang.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/ccd1d96adfb4aeba8b8502c25f747acb0a33c8806c956898ad80f1289077a5ea3f16877129db76af965d7cb232f8ff029b35319bf331ebc3fb4d4f291f11ac65
+Clang.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/182c624c223b3b50be67c59293b990c0
+Clang.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/3e60390a5d20812998554836f249e404ef3e3b63c86852a710c3a47794fe8cd661632f5e0ffbbb7ed71df003491255a4c05ae7bc64fbcef07fe8556c98c294fa
+Clang.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/a181cc98814d4a0725664e9e8a1f785d
+Clang.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/d19646a1d9413048fed8e63786a5e4a2adabb36bba625c4be02ef3302780e3e67bc1096f94d265aeb77e146986cfc86513004c19962de7bed156e3e2779270fc
+Clang.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/7ea1ff3c09bc37acee30d727a81dde09
+Clang.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/b862b29b4fba7d218e5dcb7a4c4bd48d5fdd7417032f1caa9f9c0889d934a1f9bae6bedc25194feece6a768bdc28fce319c7ff5e0bdce2540e3c6e6904eb1a89
+Clang.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/df89bf4ab33ec28f42994939e793388e
+Clang.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/e68f083291a3b8f16132dadb779c35b23e3755fd401a86ba8f4619245c3f5e3bd13a8f938800941853fe8fd508e8844b8dcaf061b6ebc9fb0adb955636680123
+Clang.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/f77f3bfa69a9f2e0e8f7191a364d720a
+Clang.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/3502d48863f5936cf136a9c61cc56dd4efb92ddf11ef4cc07f9e49f3ee420403bb9dc2480247052e5a99ed467d6e4fc83d1251ed6873787e994693c4b8dc2011
diff --git a/deps/checksums/lld b/deps/checksums/lld
index 6936b85224dc4..63a7d923451d0 100644
--- a/deps/checksums/lld
+++ b/deps/checksums/lld
@@ -1,108 +1,108 @@
-LLD.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/2515c9282eb379601ab7087dba9c121d
-LLD.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/0d0a6bee7fa181fe84bdcf75342397416bce00a3f6d40f0df34e9a0c4814a3e15aefb4a8fb1f8f63b2b4f2e8f41691398fc545d67c3783577840379a07d6002b
-LLD.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/988278a56d1709f9a52d4e59fc7b1dd6
-LLD.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/96f5c8ccdefa8dff272236af684b430c60bded64ddb9d2d814e9420992fd8c25e6938f155be8c47bccf3717ceff8213ba7b33642dc2c15866e70163bc13af1a2
-LLD.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/4760ca32d06be9bed2f18d8ce397bc84
-LLD.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/e4178ed3826c513be62ab51f10e9660afc5bdd7802f8d2a8130de4a8c948640525f85ad946758626946d63f55325004feefce2af08b6aa90aa0a908c24d47b9c
-LLD.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/7b88bdfb8fa1f3160b60b02fa0b7fee4
-LLD.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/05a5815ea20948a41ee506911a6d0c7e03d0a169b8c714720de466b48483bfd887960c454946878ac8040f64fcbd36f30657419b8b7051f7c67b2f9e5067b8f1
-LLD.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/4ef7e0fef18afef96790a1d8d85c8ece
-LLD.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/68813d3f7c10d64696435abd8d978257b5edd51b0aa8f8325a4add5dc4abcd9e14452bd208c1bc8396336d2fd7d7037b1b8b4f56cd995cb65406949afa0fb4b9
-LLD.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/128fd145cf30d49d24293866923d25cc
-LLD.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/faaea140bd122019e4914d5a6fca1af30a5dfbc5015c4650ac9734d489fe51db46428b3f58983c381b7d56802a1487ebe66d3b8536ebfa3d7b9a527eb7e5357d
-LLD.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/d78d58fc905b18232cbcce6521740756
-LLD.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/65190392bd91801269d7f65437da95ca98665264c9815223ee32bf6dd95d3abbf3c2404184d7b3d04ff37907dc901dc827cc92e63b58d119d42b08736728ed11
-LLD.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/0853474ca6d0150937b882578d488abf
-LLD.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/38a4898aff7d41553c2dabb4e81a0e8ba373ef4b7a6536281772aba4a1ae6f7df7b3ef80bc7e65c8e3c4f609462ea8ff96eac21822d7d17e043e020332ab325b
-LLD.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/81809aff70e22c183da2d369bdccc667
-LLD.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/eb291e31221a227c370d60c6ff7ab609ad4766a0b0e107bfac049d798873398d78206ef69fb5a1cccd14f8827cbbe15e12fca1882d14adbb2ecfe6f096411b21
-LLD.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/c9865ba23de7443bb0a135898eac573d
-LLD.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/1af80988614295b11b4263d1e27d182c6646137fb76b295524fa82ff5012a3333df8a07992c155ed2eb285d0b7c402560348ff7716dd31978edad5ead95a295b
-LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d02a04c53ffc1426243b848dfa9c00fd
-LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/0a1b933af79f045a8538b4a694c02014ac8c3017ed76b5e675c77fcb3b01371cbecf0260fe92e1f141388bff8be6ef271b6e889837051e66c08f14198df87022
-LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/911765f28d1e96d8540ad52a8a6a0ca8
-LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/55705692f7be598160fae7b8663d8f4394e40a016b0caf99132c1799081dc8f6f296abcc23505966a8a1247a468dc95e27fb072448ed7eb90a8ef022410a9898
-LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/7dbbcbcfceabb11f227f5f8a3fcbc15b
-LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/08912bd251628d429986b4e032d9ac0e6e3608318e8c3c3207ce241ffcfadfb7ab1d6b17065ee88965730ab3090e26014231ed3ae7681c5512a0cab8c1455bf2
-LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/01b0d73f4cff765c20fe3dea05b0b925
-LLD.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/10e30133f5b68e7d425c9407d80c6b2704ebf2e4df7cf0594f0f6fad3d4dfac47dc7268503bd97e1fb679971b622116c95f4d66d502c4ffd5a0be995e014ae65
-LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a162866a5d4830debf30e1a7e594cb37
-LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/28fd908126506cfdec748947a34de59943215ed922299ceb2cbdbcfcd75559fd3e8c0f8eb656fab05dde0a94aa73475643e71db0140c18e885d60b0474fa50fb
-LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/a937f25494a6221ba62caf1863067bf4
-LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/74bbc42376571135ea3f37bbb9ccb54c3c7cf4d5181a7e5ce958e2eb85071859510247b8c2d1ccf1435b5e93820c66c5fc0751457b318530fba388e69ca7e40e
-LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/46cbfd0c17be90082e03e9b365b6528e
-LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/5d2d9d6fbc4439c6aa6e5af196c900efd66c65e91c06d2f88ec7a58d0a4a23d6659b9ba655f6c17450ff09cac73d6816012bc1b56907238ba6e4b8fef18cc553
-LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/dba008662626e1ffff3be471a6f336c4
-LLD.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/03ef05fa73d8d867f619e7268266ba8afdbe1b91cdd1afba04f48889bd69152bbb73ebf7cb4b465472d5851ff764ba50c033ea7da1430f32647fd3c32504f033
-LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/fe5707850e6572458579a652b62ef375
-LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9575326ae0110aa0f6d6e6611628b40b49db19c2397154fe66aa8ce538ddeb517abbbe72f20f71a3e4de588d730916b556ab949ebf04c45e3c79c03519b73064
-LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/46ca92e8392d0e66189add3e07e0176e
-LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/b62ecc665d731a4e5397efcba784853dd94a5b0ca2b036c17f17910531ed96b5cb07332f13383f27ec9751a0066d6cce1f4f77a1f06f42629060e3017e280195
-LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/4ad63e824cf246445ae363145efc5977
-LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/914c388e41b467b59b5cd3f53a135662c689f62c367e0b010d7faa01a94338b36c3ca23115b37562bcbb2060914603646999351efb2672992d393135bda8debf
-LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/64964540adbc4da2d9b3734ffb3b5414
-LLD.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/19190d022c9aa733b2a3be1ad523c291ee187569ace0594eb2d18959486e91aa56e8440f3ee715801ed7214bab6cd348679f2851c6418f6133f84479a5980587
-LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/014f16cfe047ba26323d730171b63efa
-LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/0eb6a94107b88675a9cb5c6e514f9b326a6d8067ff32062e10ab63961eccd6b44fe784b888caf0e5b1a297641b2a9f943caccbce18df76a100b1183b6fb78177
-LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/3041df8d07f840a18f9a3712ba165a11
-LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/01954c0c500eb2dc85a896fd0604672a432c86781a1a25818bf6849e350e5e0751a0d3e124a5dcc3cc5ddfd6130816f00024b5bf0bf062c3fa143b27f7cfc7cf
-LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/00c8d0195d3bb52158e25d96f9667cf0
-LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/504b79e64929b8f21b05e9fbaa4a2eb60b565ba6b4ade3369dc1e38678bc094344f4ffdde657b41c062e951f97701c6ed58841b66f2060a21274202e2cbbfc69
-LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/a81af919513dc7103d5f65748e99a932
-LLD.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/9d6c0311113d998a2e2f93afaad2b0155bae6e37dcaa0778879259d61ce1d37d54ccb169c06dc7911f63b0184499cf208a72d4b330198cf5282df15baa307bdd
-LLD.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/39bc3ee14a07b7a19149e74ef678b2d1
-LLD.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/19ae60bf3efe9347eb7fb510437d0aa97039bba7f9ac0e0ca50fb5222348c6e8fa74920960d97e421306c9764921f3b00e6e79410bfd355719304709b3424a3c
-LLD.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ae563cfd3b9ce5ca8de3d63c9f956d29
-LLD.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/11b036eafb2f2037382af2a6e76901ecfef70c120f2b33d7d9621d2047cade9082e184580c684e1d6a70f92d2c33fcb75a8fcd78ce047e04d57165d532e191c9
-LLD.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2fb700351f0a990f8b61ee854b1cf52b
-LLD.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/474cb28550056d2a51d95ad6ae806f032a872e69d72eddcf039cbfed21d1d3c182caad73a720f11c2173f20c63043e352d618761a15535ec3e8071b3fdd88cd3
-LLD.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/5ccc80802c4053ad1a5fe351b45d33f3
-LLD.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b7349862fb03d4c29b1018ad7ef90ce056e8d40a3340b10af754a1cbb06d4ab494d7837c274de2a7e13028d3b044f11c39ca3bbe969569adf4557e6402191993
-LLD.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/bd4b518e05a13241809a0cdefe05cf3a
-LLD.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/6c327220fad9cbaec397078232c6e800cdc824d6706a4453ec03e016baf0a86ef2c082df2b980196d1b10ebd2d22c74fbb7b92cd90e7fd902372a3a176630bfb
-LLD.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/ff60ea3e401a5315560d77990eb1261d
-LLD.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/f018c307b47779cc97368762e1edfa63e0f9c354166eefe706f2c398599b30be7041161e08ea5276b75a826c8bceaf250330e1231591b96ca430bf674c51dbb1
-LLD.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/9ff7c7f20eaf5ab1a8053037e5b50e23
-LLD.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/f3508b68727c2c7890928975fa4387009edcce957f6942c1ac9db0554c7b3dc3c6d9b22bbe543910d7354717bb292d30d4468f48b9451adb0f305ececfd5a528
-LLD.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/48f6fe99a0d2f67ef378b06ffa6a1386
-LLD.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/59096b2f9067d49e9eefa3d5e4356e0bf0a6cb2c7b8fc477ebc74603f2ba0c6a5e7c44b65080fa73ad4d2ebe4377b9788e370e311cafaabd2a95f76be383c240
-LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/adbac48e6ea29783d7e0e0a34b0a74f1
-LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/c589a430dc42d2f2fa8334dcc6a992e2776d4a3d1e76c435759b99b200117710c4afbac56e02d7c0a6285817e404a62b11833b570eacafb1ef871cec0c3c7c30
-LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/a215122469aca265bff80e6c8948aaa2
-LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/519f835a62ba7c3e27169d94e95f3a2671a82ce37ab67af79061b1ae15811d6974f6e0788a9979d510cef4aa2e444ce90b358c8655265b26b4c569e3899700ae
-LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/6cdeb73fb0f6a1d305111382b1074b16
-LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/8a86e431e5d6ddedc52a38bafadafef4cdfeeea2b3be34793ffefe240ae1a0347adae2a4efe783a493377fe8fc30a0646e68a1acd868bcee9e50a2b486611a42
-LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/d8b6577c4f0c6286641599cb0a0b7abc
-LLD.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/fb6262eb94adfb3ed1e81c69706600d00e267176d40c3ae6247dd7c0cdb4248d041083a5ad7c83fd9f307352f4a22d1d3b10274b4d43c4fd5c47a68189f22de2
-LLD.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/60bd90c33a864d74a6c2e16a43599e78
-LLD.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/1f6b39e41a892cbaf1435d6ffc4ed8f80c2418f1a7f6feeb1175b38620e8294b00a96213e5c3c13ca33dd2e57493b03cc4417fb786e98577fe35224a0d4fe8fb
-LLD.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/0b003a8140dba5e1c0f4dcc9dc56f83d
-LLD.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/f56334c7d2bf42390feb02e3b4e4261940fcf731a5d6083d9d8d52f75006f72866b8271951f2ce8a0208ed624fb45f5254978e12ae805b75a391b9130fd3af68
-LLD.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/5e755233a506d16ee5b83e84bc776351
-LLD.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/4ab51f3375fd33857e3ab7d58f8d59f3038747a40e14473236b830fb8924f8e8460e44dd9a26c545e6b0f236591d72fb23f0ad0d59ebf60ccd3dbf268922bb23
-LLD.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/fb0cc1fefe0795f3b401959a2ff2ec42
-LLD.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/de8899449b864b698db37acffcf94e4f9dc14b920b108b4289c3bf1dbae87d0374361e83242f7f964983117f2978d2c7ba1509111395c063b70de57ee71ff632
-LLD.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/d86e2f57b0b19326c99d8bb24ce70238
-LLD.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/e0cc6552b92f9246b19032d18a0a2edfc65950cabab3ddd8a5d24eb56b34bd735a3d1875714a8cf1a7771fe3cf3845de53d99198ecf3c3298d152e1598f57c5b
-LLD.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/b7a713da29369a24ab4c293280527552
-LLD.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/de33a4d3134c339c7669275018e18bd1ee34b64fd58dd7ac509fffdfcd364732fc8c2319a6664cbbefd9f2461b5e83538adf3214564c7cf932cf705de6fef709
-LLD.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/6b2a3d6b923387a5667ac8f2347f1351
-LLD.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/d4a6df10c8d537866e85676b116c1ae6140c1169cee866ea1b5c45831f3610f872a85eef9e925651dcd9070cec53ae297de93870f29a582e8bb83678b0d3bd7a
-LLD.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/b0179804d9ba8ee1567558264c18263e
-LLD.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/d836ed00ca3486496488d7913de68609dd664924da65ae5bfc1df2ace7a7a8c79674340e219c3d1ca62e9c9d4d7f3deb4b56b3e19b19ce2cee2ba33a07bbfe32
-LLD.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/af12ad9a93df90946b85872ac6b9ef79
-LLD.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/894a5f2f3599cf9a88260bf07fb0ef382ba829e9bd8aef98770adeef995f524e8f8e35e5877181371a02a2e9035f9b5cf995532299dbd645ce946739900be711
-LLD.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/b1161814ecafd0897ec8bba22a9dfb8c
-LLD.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/e1c6b33320c50d68914b530add1d5321baf385f19a4392bd1babae98abb2ec8b155e18015d712f6e33f7c9c08c8a27b565ffb986989373c98773bf4991a8b963
-LLD.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/75ab6b8e7ddfedf97d5a97027be1d390
-LLD.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/56c8dc096650756c0dcbcbcab1fd528755873b8fd4e502c0179ff83dd01c4832f7b8a2b474b62bd2fe7eb2550daeb9bc4999906e84fd99598b15a199c5c83443
-LLD.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/45b91d8869d97e7ba12cd125fb2ccda5
-LLD.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/e88eeb4d357cdf57a739803897fec1365cd43cb57d62f54b479031b1c2d1ae52511397c4c66f1cc1465580f077e5b121275bd70c5fac29c841cbaab599679173
-LLD.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/c2e9acb2ad5943920e045baea06d1ff1
-LLD.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/07eca55d28508fa500a7a93d3fc599460f4c894bd6c1979507a725f066d5d17b692e501d56861dee9bbf002629e3841d48eef2b65b3120ef05d3daefdba8f19a
-LLD.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/1b3227e17ea0a65c2879439094e2bc2f
-LLD.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/68b939ee717f9f751359e6ef4141ec4608be6926f72158b8f02128876fc97be8c255b7a27f8a89906de8e9f5f3f77eb0b83861ff46d614c2a33f349a254179ff
-LLD.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/f2280fb244942fc505285aa415359409
-LLD.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/770abd9b2be1adec57442b4bde0dbc1dedbf78e60a8589e3e146bb44b2af3fe48cbc8ddd7036a8c0eeafed81b45c5d0dcd3a298876e98a1b0039a77a210f6778
-LLD.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/b12f9686b2bf8bf1022ddfe5647cc32c
-LLD.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/bf6738aa1f8cbf749fb110fadabb23e02a137c5e55e8ca0e1cec94b517ca6a314affc3da4899cc6e6f58a7f920dc87e4de939069590b5e516176bde07458df43
+LLD.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/09c320b356e69a8d2c91aafdb0d735c8
+LLD.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/42d0ef4bce4425832c535f16b83a86570c0851736ec671f94248b3216600e0c0d8fb0a9f7133d9f1ed6a3bb95e9ea5536db99b35f2f29050faa77a13db21d5a9
+LLD.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/ed7b9ba513235c91d96e0258355eefec
+LLD.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/4cfbb5198a0f59c54f81c3bac4d880b09e02531c113b985bb512a161dfb66d28e1ebe5a2d27eb567e067545141d25c5b6f7658439dc20c39f0cb324b406d87d4
+LLD.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/0fccd87c8d6016a812c842255b4318ca
+LLD.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/6b44fe0337b74bc80f387ef41dc11b06f7277375ddae3de079071cc0bb743b42a90068453c3d9e2613d7cbced47d134c67297fb7dce6ce098673354fe49a6292
+LLD.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/bbce3af58d39cb571ca851bf86c38ca6
+LLD.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/e577f2ec2f1a15115d850a850bc0679c80e2dcff6a9f3982ac84cea6497c71d7bc269ff1fd262d427d3a98bff9f72eb4a127ea841471af96078f7e43bea6c5c5
+LLD.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/a461bae1e190f5f7f72a64336db88df8
+LLD.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/312f465093817c39f8b17cd004108166241322bd6559545f64bcc5b0c3247f7f7b85e618587a37e51cbeb8decaaebdc69d60f34bf8ddc53e5efebc4d9192ca9b
+LLD.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/017a1ffae7b74dc5ae069c00b4ee16e9
+LLD.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/62cc6fced8358ac46562887fa03c4196d77b61031b4f80ce3ad339bc6b8ff1f6079b99a862bfbf899d11201b744bc495f7b44315672e72886ae6046c6130d488
+LLD.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/417d35e8169ef5ab07ba41d2de46d7e4
+LLD.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/fff169fe51910680110fd3df8d369fe529f69785a151b4274b127223fe9c660f160366044b74c17a63c24abc8f8c659cfec50624e98c99e7d60ab84716f12888
+LLD.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/a2bedb0bfad8a556040b7e5ca0e2848e
+LLD.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/0bcc2183e787547d5181d203f1c132b63186a100f1b9348886443eb268eff70086009c3dce17266d6cfcf6285bd15c50e18bbe1a30517cbdc5b1769e5f01ea94
+LLD.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/773083d5c46259aab09522dd7be7586c
+LLD.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/d6e240cdb8fef431f88ff80364c0c493eb198ef599db13e91628da08b624ed13070a1add19d2507fc4bc006f3fb9709a4de601a4e2adbb30b3967c72082da583
+LLD.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/b44023d4e9557f997fba9fdcbedabc2e
+LLD.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/1a4f92bf5eb73919384c89d84ad3059c3ac585258662f8b450c1cb878c7271659cf1a3e90ed7337123348399580b39fbd29e9a68b64e94a66ac56f1637b6f9d1
+LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/f6fa081c30f619170b9607d9c374a19e
+LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/4ce50a67739d5aebd8b96ee6c7441685a7fb00e816b23f685c102c84300b9da98b83b8f9f2d7bcdfd1ddc288c1b7a03e884dbdeedb665aa16108e97e58a8f4d9
+LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/ac3a61e234e6ad8d6a7b8f56ea3fdd59
+LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/45a6ffaffd514628569f9463a4467d07049c9c115fae7cdffe8881e1151968e5b5f1f196b969e4a4319fdf7af4e667e5bba5401b98b26038fba72fbed95d9fe3
+LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/8843ae687a9a697c49e7b2718a819fc5
+LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/6eddcb1ceaeada1134c4b8cc8641e4c7c8998b975b98adf6c0b460bfb891f0ea7bdfa086bc41f58d0c9ffadcd44d8ccb9e15895cdf7127317d9bb11659c3e0b9
+LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/d21e19634ba816b5d8ed06e8e29fe264
+LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/098c299191c527ca953a201e27e9ca7202c5a8093e3f338b31c5f54fafb243bf2aaa366eb32b18a3770f86036f7583bc5d55d7ae39cb7bd61af280e20d57a5c7
+LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/5962ef5d8db691edc3483e8b94ac445b
+LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/076f1b0995e1ad40a4237a25c5de03ce29025eed9e65db33a935537bc93e84b886af6ecf88ff1a5efd075c3837ab2b80addde99580325043a190a4cd6864cf59
+LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/e8c0db4a2c24728314fa5d338144277e
+LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/703fc4caf03390afea0dc070c6ca9b2b402bee87d8c62053503395e858a67eeab369bae4ec3ec52fbb618856fd582aaa10db1b3843648e5343ba10359e2846dd
+LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/eb595bc0386677a420f356ffa2eb16a0
+LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/a9c6c1b8464332ec5ab9eaf405ae18efd06a339a970f8f28cc88fe8d45712b1420e5b8add02e97f82204c49b653ed1c7f3fc87a0b4eada873e46e53d0e132f0c
+LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/553a1eaa6982bcd82dea38f81c6e024a
+LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/9e0007d255c01dbd08e0c51355200d53219850b0ea60d5747a99a4f3241a79f5c171315f7b9fa2529ab6f870d281c76d9b5a4ec3e10d58e41b3d2486d3a38861
+LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/713c09bb19b6f47ede0b4ced61d5039b
+LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/553b9d20b7291521e607b2df7a2964e69a58599622ca3084f795bcb77239617a88c08bbf0bde07cd7e37cab0f53dc6d500bebad957415a5e66223af9acd0373b
+LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/f878e4d2464cc1a70eeb5fa57e80978e
+LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/3e341e44f54434d70b99ac1d71a9e79999a31656b0d442c1692731e4bdca9b95863ea9f83c3da968a774f6f693c9088374aad25836da924846f5ba05f05f968a
+LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/2e4fae7565ddd6717a34c8240dab8115
+LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/f1bc27876f546e0f926a63c0e0b878bc33c2836e5902809f186c54a148f9c96f2f88d892910d4cac14ab4697723212ce0389a79364d74420aec075f034bb3867
+LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/e064f11cf58b6a870212a9082a2a4844
+LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/75bb485d234b077ef3cd607d30568943559cc50ccc5d5aabe9556c7fc104a1cbab24ada562cd6b8b1060af58bed10da6697fcd9f05fc7d669ae694ca5fe010fd
+LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/b0754db228f635d247ffb5ea9938aab9
+LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/650b7ebcc5aca07b1a9a4a8d7c2d1dac60bb61586279aafebaa718283933735929dc2fc8b08c8901626533d1834be4071fc03cb5a8183311e519d245cff33bad
+LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/ddd06a6b9f67a95053f4f06d85ad118d
+LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/e7e87fb0e2c394dce36134bf0024c6ed613ab6707da6a472a708771f7f2915ccbe4539aeaf3fef2c5db08eb5cd5b9fadc30c18f6b34cadc9d56e1aca89fc0b25
+LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/89673b45e8b6ad861df5c469ce9e0dc4
+LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/ad654354e7da47d6d1db8b9acc26a02412ed02e842e0c6eb8c403785fa502bf75453d575ee01927db4f39e4803549b25b3ed4cd2e0354b01292877b45a4a7b84
+LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/84a8693bdf7a669b523bcc1475b6e868
+LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/d784c66624069a51b7df50773e9946db73e7015af617ba745c8dd7e926936295e88bdbdaeb175c363903340c422193ef0437e035a15cc7595c4fbc0fd3bd56c1
+LLD.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/d4005209edfb3793556a946c6a6943a7
+LLD.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/80c21eee46810d4a5dae35cd42604266c463e73f399e7d0c9cc62b90ae14f3c8fb49b34254612b0efc7af2bc52213c35f1a50c3a4b4fb30d4b9f06273e31d7fe
+LLD.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/0563df5ee7aa191b4c1054fed3ed228c
+LLD.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/578dc162a37c38a3ebc9f45f5ce220ded71df1104a1bd830fd5055ae78d634e3110fe6a0b8c86bc08aae145c16e7c964dbe301a1df752db4a597f98b653a5e17
+LLD.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/d0e448c7694f03e7221020a5deac6fe8
+LLD.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/f1e1605bc9a0872d19e74dfde78982b39fb0cd3b28c8af65b2960ac292c4910afc84328ac1edbf70fd2c20e697d2e826b729a6325949831aa008d3ac565d4d4b
+LLD.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/881ca8f1640a296af635e255f671b3cf
+LLD.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/67146381b1debe7cd71d819d3d4e930b5e9f904b30a41cbd87681675e6a263ee8008347f1b6879d13098f2f261555eda7e67494e111536b11299561d9bde4b08
+LLD.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/3054aa99b31c9fe01f018542b1ee1628
+LLD.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/57326651e05dc18436166dbe31cc2e373de78a705d1c12204db6126a905092cb81e81f66d81229b6694b82ae279049ccdc3a1decc14dd0e5d9706b9079aefcd2
+LLD.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/2ba48f3fb8db80e4145e5495583279d5
+LLD.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/ddb3ffb64a7326ae511e65bc825b01cc14a403fd129b29e9b01f00f87346cec127ffb4eadb994d4c00ae49b78f59f8d32f2ab131ed7dc59e636f83aa182ca2f7
+LLD.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/03df4914136836a7ac62e5f9c74e2c58
+LLD.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/0e5d0e32a1c817cb81169503a94ee428a4fde8b39cc2174f749e8df2b23526e738e21b028e66b44c8abba1e0be0d93ef3f341c7ae7d20fbc22bac60c38ee887b
+LLD.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/58c367d5d536469831b740d6181e1909
+LLD.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/e55d2a0152fcc7629007416f8af7601de163da794939c0f1bff9b9083641b15fb365f7ab9e78f984e77246d994781a74c56397da26d81aa66cf926ed280cc2e7
+LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/c822be796e7e20e1b081a1c6c9fcb4c6
+LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/a057a957b55f97c0da5991d0f8f73049ac30733aad062645614b32db17e4f6efced6c82b77a689c90bbc37b610219f235bb02b6b29d1476ed1b5f615b30b5267
+LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8dad1af20464f8e3e96f77d8acf7b180
+LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f6769fecba508ec9136dbe03035ce0bbf7eea14f3c806b3e21b2e32de449fd9a698a489507412f6f603af86e8139dd67f2c91d51ac3385d82fae02ae4bf41531
+LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/454a8a9c011d795de525c088b0fdc329
+LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/904f8846ccd8885d15eeca2ce08d327f3b13cead1368f50cbee3986edba590bfd6d696b9e0fc081f7a8a127a3b83daaa99dd74a0597027c84797099c9b0c807e
+LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/36302281868d2a02af18601d5b7625a1
+LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/fcbb43e37308c99dcc7e2e152923eaf3413e4143124dc598d18467fdb6e8c561c0b99ef19d5d0797565f6a18f86a087de95bc21599c65ccdba42089a678b9796
+LLD.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/4468fed82218b2380295799030f1fad6
+LLD.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/37cddefa5e24c8451e9ae2d64a931f4dd2bffea498cc818a9b7dd08d4df57ac81f96dc573e18e90449e63cb104cb641286cd755e24d6749c8f9bc943e248c5c4
+LLD.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/3089a2c2700d0a645d1ef4cc26a7dca8
+LLD.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/e935b01349d844e8c6cb9693e6d0dcb8a99973bb63b53df010a207833c4ea78da3493421c28f26122e92bc109f4fbfd55c547a7459bea2fc39ebb3c9318571dd
+LLD.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/aa3aa224c3403e9a955e8cabd4efab4b
+LLD.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/255f6f5eba7835041d510a57cf706b273f87153bfa402b4e0950a418c71a582232a99c94cec4262fb8e3e2ece973f5ef9197a625425515541c61fce398f439b1
+LLD.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/363e88347921c781d163844446f78f0c
+LLD.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/2e12a0d74cfe145a2c12224d9a2fc5be0a0e7f1332d17b89fcd694b0d72c1bfe7dfff030cbee16d02cc7c9df1d350541685fcfe1ebfac38e4fa4d6172216bba6
+LLD.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/7abf726bc36460e40dc2799b65dcb0b4
+LLD.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/19b4a38448d503a6dbfd5f972f8bb60df4d54735541559271be242d977519436d83a9558b42984a4128a2b467bc3e22bf5c37725db2e03c8bd3fc4369a526d7d
+LLD.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/f1f685b8f111ab299a3979de7f5b3718
+LLD.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/657d404e9295170696830f94bedffc7a3b638ce5e515c24b3a60e3da1ee9ef9d00919db6bf324f9fe9692b916394ea1d93a47840358ec1d56a9734fff0c6f9f0
+LLD.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/7968b42dd7370573a820c3a4aa9765fa
+LLD.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/716a6ded0379cdb441b51031919814afab5ead38cd8004491e022b20c2a2aaf6a1481d4b6396e70e30a8f2c4b81f03450ac5c1591e001bfac345d492933c1556
+LLD.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/8a375261e55943a26956036a3f99b72b
+LLD.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/4678ef639b1b4ecdf9bd818881f3f01b134f19b3f43c152f2f05cc8ee2b2f8f68526788cab1b0f0d3154bf55683488ce05e21df93767e749eecfa78e7c5146b5
+LLD.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/9e654f59807553bc6b63649561d42db1
+LLD.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/bb4401fc7733e00469d73a761e7eb9e1c6c4a2a9ebd420bd048fbd189b25a6d17e3eec177479b63e8e71471189de1d5becc68022cd9e4d8b0ef96890400eff24
+LLD.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/967160242a405064609a4828e5506e53
+LLD.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/a2e02f065dff865c2447e689d1a080073fc0a160a8a4492912633f8748b0637cbc6bf6923560fc7f31091bfbb968f339f48ffa62e768440dbfcc8f1c7ea2ef38
+LLD.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/89be1c975c0c240608f40fc89de9cc79
+LLD.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/86fa05bdd9f544dee43dd5ed701a43bbaac137d0f05e3bccb0ff32cb51fba790a6446c814f7dfe644ee82661a25e34ae4fa905b88bd65c71978d905489240c5f
+LLD.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/b8dafd04d9213317e7c6c99e2cc02c4f
+LLD.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/107d0a97eece870f86d658531478a5930597210fb05458fdf5ceee48953b126a206c910837caa3637cd7b626a343ca5bf6684f2da47ab9a3e83166d4d0de4b86
+LLD.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/249c60b944d6ee16c4b28fec414353ac
+LLD.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/2ff5ae01910b33c49331cd60d1f3eb9906d28f81c1c8e6a56c4079c74d56bfedd316707a7fec38385112e873e0be4a05d587f9863394d7d62945bdfc8c1e81e1
+LLD.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/a331a6f81958efc3ef061f1282ae63dd
+LLD.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/aa93b56e06f8e0ffbe15f50c36b1d7bb5f77022d731fafbbb6d502f93dc229ccd79f44adf6f6d1dd0ea94ecc5a05490c326533a8d25bb1df316922f86c6371b1
+LLD.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/72427b0c7a896027a47c27b0ab2bafab
+LLD.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/5aaa2fdf91385133bcb0b563a7f2ed3c8c5ff3fb307b02387c94afea863759b78de097855a7949ba41449e7ee444f166fa4f6867f41ed3a561bb6c53bd747729
+LLD.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/6985692a2c8a41b34c5d2d103a969348
+LLD.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/8339b3aa2143b105c7133171ecfdb375a19fb9358e9fde0c41fcb57baca9a5603c23cbe8ee70936fba86452c1a57b4c84ba20250805513445ac609804f35adc9
diff --git a/deps/checksums/llvm b/deps/checksums/llvm
index c0386f3377a85..715ba89ad559e 100644
--- a/deps/checksums/llvm
+++ b/deps/checksums/llvm
@@ -1,111 +1,111 @@
-LLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/a70ce2a3f17c7f1a5ca012cb54824961
-LLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/fe882bdeac640beba174498dfd2ecb388db1fa1265555047588d0ad250bc673088b9611bfdfc14689e65fc874b60e91474f912600c395a25c81b53e69f298f7d
-LLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/dfe8b093925d73e04b8fe20ab1f03db9
-LLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/09dbe669fd5cb3680e1ede7e3f2bd2efa50d30a231a459ef498f172c9066ee2360d9012bb080abaa880aa38a01db9808ba5ac656edf395857b3ed683e688c514
-LLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/5ef95fa3fa21127f2445652c22dece6e
-LLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/e5c3e014a987ec0b7699941ca1543035cd8b1d67f3498826fc2df48944579ab008a8edd8b8bffed8ba0ffeb543e815e8a26495de028ad86cb5a1aaa160338866
-LLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/1a9e4424b89695dec44dd683557e2849
-LLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/6de91e4ba3a8c8cdb04f6c829890a6bb74ddae1fb90076000ac11031746129ff818910adf7f9e6300550efd190b9fda5f2493ff3e4bef3fdac8ca3bf97e6ccaa
-LLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/0b05b71ad4721dea3815e1e2454d0133
-LLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/a191e2d7a4dd3a967fdf7b1e8f27a5ac2a0738008026351a27bb2aa188b2cb086b18848c99ad73ad2e1a350863137619c9bc1a51371baab29f1f1698e15d03d1
-LLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/a80354c67defce5ad7b989c4f3366008
-LLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/82fd3e66b46ec56d2affeae043462d01933ea20677ce44f7d1e25a3983ba2e34c018a7287125a55e62d9a3346bd330a2df8c3c94326a393ef04a9d8f01beecdf
-LLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/e0400469dbc86855fae49afa2de33734
-LLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/52acee4ac93c17596e430865ce877c92afaaae194d616af930003e51972dc05348d0019325af83d0949b7188e3043d7f8b893837a65751cf55ecf4985cde8fcc
-LLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/39e6aed193941fa8cb05140071443492
-LLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/c9e565abbcc25a3cd731ff1af92de94c3fadd83e6ebed8c9d9d25b259b32f22014404027fcd433484ee0eef2b5bbc9398f218a805f8205cb5dfa61257a034c90
-LLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/ed14d5afbf2b8b3654a683ad1e04af31
-LLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/4124a866e55f5b397d1ead170548c13e004105b2947ec0c8ecb20d021c6eba2206cefb63fb005e899c338583b56c9a0bd17c94724ceac7edae844a84a77c0a8f
-LLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/8361fcfe223d65680625c5a20159dae7
-LLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/385be5df02cb44746365da98feaf7caa2360cd3203fcb4f63809dd88c52c90a479b4ddad592b46f1fce025fb305aaa7b1a02ceb57059f598c95495cdaf52da66
-LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a3852342bd1ae33e7af332008c279654
-LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/a6b97c22ba365176ad17071b91546fc361b28ac03f1ef521f41106eaa1f66daa06a90d7d483e8e64bcf9778a9ed74ffb2cea908f1d53e8000886554a2674cf59
-LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/4175eea371b3c2087838761f90af9e80
-LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/ad6d824d03d262098348f04a8de59354b8cba1ead11c3b3c48b74dbf78b5e03219f6cfd7cc9eb48bd13b624a20fb524560565bc06290620d0583c4218fd8ce4d
-LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/b58769dd16d41cc232e0af0745db0c0d
-LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/aa3a9dd18439977ee2a9946325e873bfc65f01d8787ac9ac42f44b6780e0d8908c072ea410679dd463bf08ce539154bdf5a5139d6ce8032462137126abfaeb25
-LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/f06631ff471f4abc3ac775f4160c7d43
-LLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/67ab50784ff858cc705ed2748898b1892c21a9ce21065cead4a62c2361c7a9f053e562ee27a629348ebe66f41fe078aadeca67526c0ed70148bab7369d8bfdb0
-LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/9a3cf1e8cbdfe3ed895defe91c184107
-LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/d1fb7496f60d152c35e5974b15958f96ef30eae118d2fa09fe48058db4310ddaf88a20eeea995b6fb882412ee9d23760e087836f7f93b3ac64818f5badfa3dba
-LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/743bfb035a17bbc85de8202e46631fd9
-LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/86a737660325089d9973ff1de39d471d54cd2994ab3b8b24dfffc5ce2db2188ed11af4c4cbb7d6eee2c55760d736b00974eec7352c36ed5afaaeec65b83c2f72
-LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/6a64360208288c31ea44ac4f7f6e7f73
-LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/186da02c1bea8f65e9107bf1712db4b93acc78622c0a57534e7c342e40ffbc7fb4daf675e66879ae2a58835657a673f3fa61b08452fbb809838ca65469f75aba
-LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/50af8192ae03a8c2586a6e3c66490df1
-LLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/44e41c8064bba44705bdf1ac8e31a795cfe86c6697f48c26b8b87fcc0dad1083bd4ea203894a06530cf59ee646259694dd7732c7d3d99c7c1632c8ea3be56635
-LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a2263b7edb6ca4d1654d264169fc1a34
-LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/c95c8bb2eb823eae849d04235bd2754c0368fbb91933deb4103cbdad4f49437f2dfa9a59a656fd6b5e7016de189ead3961e5c2bcaa60b0511d8b9667e84bddf7
-LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/72fd40f0f2a14d6dda0ab0ea76587b3b
-LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/1ab3af3fdb4442f6b9dd1b954ccc775f4815159c3af913c6101319d76715c691216818f9c35e6d92be95d457f198d7dde6b4fc81fe8af71f47a1dcaa74a35ae6
-LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/29329543013995dedb79661591fdbe08
-LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/40f75b4409a5def7f41b39c4e4cdb31dc81ed027005281da2ec8ed5ebbd477929d2a1aa1177c33b6c981ef6616194e0b267fc5d9d0e8717c05e7bbea490ff257
-LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/2f21a287b77d37fdfd03d20e21ed1378
-LLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/24a396cf3d963f476a02939e8d666112ef2fcab1883e46243ef166dc13bf354356fd1db9ca8081a2107ea08d015bfec3456f8a4ee33b029b8b7958db7d631400
-LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/0289c0b501b8bcb693a1c92e10613727
-LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/ed91a1785a193f1ad88f4c25467916a9c97cdff470b6bf86b640e296193d338f1ccbf380f1a89751b7be31ed12485665d0a77abf31b879a789582f5196f50406
-LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/2b01d3ed13d8d6c2f1981f6ae2969405
-LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/eba25bf68431d480df175706a6a02612aeb38cfbea08b9171e6da019b4bdb1f5fad2f357a7b1cdd1b06353558e371868bd5678275cf5cfaef3095f261f401134
-LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/0721db7911f73b5806d467d769ea7a8c
-LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/f38d2e09f01b566a845e067514cd653ace5398578148cd8700d27077abd4d3d71cab29aa9025dd7e7f0383b0307c5a88a0666b3978600d2ea3840a5bccdd22bf
-LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/bdfe5c46ef0b04930c5ab2595945e5d3
-LLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/ad783a4b1b1f5d54e740cf42840d7ed24ff9d2e512900c08ea16356def2c8158d5d1c70f3026f8cb5a0b4b4802857c6f5090dd83ea871f9d5d3c4a7a22cf0e73
-LLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/f72efb9dba006c308cc791389b6eabc4
-LLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/dce1dd64311f840fadfba85a52f41a8a4eeb90244a1261de5360cc911cdc19371a0f12b7d67384ea251105a6eedc91a4fc615b87f63fd9ecb6a4d2ae9346cc53
-LLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8fd06e11639cacc71ba363017cc9a82f
-LLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/6f32b44bd4e910aca8a9359eeedc8fd038001e0eaf0c12b34c07fed78546ca6d06ac54e0a1cb43846b19a1c7389729616fcf1f39db41450fc5cb7e54a8572129
-LLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2ad4cda8bb5528f1b187fc66f5c74aea
-LLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/199fafa07917f05b4b9f3e18a8a59235aa3491c79ffe1b54ac4acee41b90df8bb630e789584c8bfce6d60c454e5c7b24c7b424db63458de0916dffa3b28ced21
-LLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/781bd8b1e041bc05600e4d0fe70fe125
-LLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/02bda3d17a509980e3a1b1464e64ea80879e0759eb5c5f706c913164af5bf83b19da96f05adcbebdc02566ee953e69adc41da7d752e41533ae6781d22daf4404
-LLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/6a09756d6d1c4a2fdafad07a55a4199d
-LLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/f55038c9446cf6f2fd305e26097ca208766ea4a5ef0e875510b43390fc749b1a123376aa629287dd2df0608160c37bc8c5d7579c2c63abbd798839b5e628dcc8
-LLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/39f7f5a20d035a78305f0923009b4bc8
-LLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/22ecc841945137e2dcfaffef5cdb51fa19a9b7554367f4c0735f2d9399adef591af234b0c9aced763fd8f8135dbfad5f04dc915175af8c7f1853a961e67e3f85
-LLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/ddb8c15c549c4dd1d886f0e3e3b01c9e
-LLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/c484efa3ca5fc9e1e570a97b02f06ce7470ef46fb445f04118dee460682194de2363b55b0d7217c4535bcd0fc2dc5d7f032a91de75ed028c37fedb8955f1275f
-LLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/6f9957228785593507affbb5751d855f
-LLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/ee45945e4133c12b16d12ffc761eadbf218f2d527e54722d48aab60f6574f57c13f21846f2d786a9389eeeb32908fb11c438e38a2932b1711c9cfd880ee5440f
-LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/c51b915e22e90204f7309fbdffcfe8a1
-LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/5a44fea5b9caa9c933350d29b23c8819f0ad040d62c7235f4612fa8ddc51c352803c7b9a4c92d7eace8543e7138cfea639e68e8529208291dfd443c4810a397e
-LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/28d9ad7228add4db7a12545df5d1a35d
-LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/6b7e3b6a4523a66237dc26563b8706769cc6b7228fbf61e4e6804678ced42243434e42c7c92421bafa88c0bd761fc8a57cb0c5225ab3c00a83c719edb2d7776d
-LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/256222a8980ee3d8aeae284ceb9e9704
-LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/fa61dbf7051ec054e2e85e6d486ef8522536512a092ff10f0d46fe975aa3e2ba3d7e8ec98b3bc99d7d066b5c694f07b97c46ea42ecac9119d108e403ed05c83f
-LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/ff364000aa8025b973923dbc89f419b9
-LLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/0c90ea208dac7f3e96f4547565cce4a965cf27eabe79e1bc557593524e9f723eef8e4a1cbad1fab9004a1b94d34e8a71622fed40feed693240d1c923cf1be18f
-LLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/95b33cdcd79b499f8d862c85a81acf71
-LLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/8f89c44f53b5561a8d949089bb3237e1f82952f45cc540c42e3f784c399ac0435edca90ad08966a200dbe194026fd459c63750aba930e11cc6da5e2ec1cbd475
-LLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/1693403dc93ca962bd081ad8271c569d
-LLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/8364ef2a49fbf6442b32279326e5494491a501e466105842f8ccb7d9b259b91fdbd296d0984222d56cc9e4be87464b9d6f279553a967a148b2a6fac662ee6d68
-LLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/859698c3451608193f1bacbd3d893a12
-LLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/284094eaa0b76092cb62ea1a55ca03d983f1b1a904ce52aad12b4dd6adfd139d738e8dd9df0f004c544f905d5454dc166e9e783646c7b60367fbd2788a108ba7
-LLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/95c7e9fb2a344e6ac0252878fc12a7b5
-LLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/b023f2b762efd971c825bb1d34d591caa198ec8ea75742beab0b0bcecd50173a09fdfdd1dc5e8aa448ea5244c2c1c34218c96005452b95461cdd26c76619ac53
-LLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/43de4986e07102480c22658cb3ae8592
-LLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/4a55b9983d19f1b012d80303291420a0e98e9d61644ddc94b694faac7e0dd575a45417d177ee822d9fc9f001c23e5b6ca3c9feee0e49f34088f657cae7278cc4
-LLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/8698009378fe086c50243d908d45a085
-LLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/f264e5663d65cf6856547fde0e6800b8b828ae77c49cf87c73226bedbd95f71f4c12598bd26b0a47e3424bf710a79650b255935eb5e82c4e3b7c6845066c77d8
-LLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/1ebed3977c754042d3fad1c8a2b5c471
-LLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/b374a6cc383df97c71ed16503d8af7e0713217705a5b38fe9b137eb2c0df1a69f28fe7e8a96e496ce8cc63546e63ae262fca139fdffa0cfcef3c9b2b0a412f7d
-LLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/7a7440b35ed8484efb1a7a66929e7a68
-LLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/9856dd0395ff5340f3c3d4198f901dd11e024af72cb61cf146aa177c18c06926b00b9848248c1d360f8b550d8f0a7b291966ca089591655aff865519d152bf4e
-LLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/8a3b05772a16c58fd37df033adfb68ca
-LLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/62ca5be9abcd355e18ee3ea3d120dae336076b84ab877d2a796e8f138f9d9084353b592c221762d6e4af7beb64587497d4e27edbc6b371afdbc09e926fcb23cd
-LLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/9e88bc5575372bde26d67342b375d41f
-LLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/e1b377008b3ff6626608410eb6d6cd77cae32a73ff3e2bd042cb9212529089c80223aee8196fc04966072e1dcad46ba4d980a80426f0b5247da3e4087dc7fa24
-LLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/749af273a95500e67ee926c30bc6bbe4
-LLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/961550ab92e51cdabffe31c4210953f49dffdb962a29ac3f02b64f523e70434a0c0c842077d2eb9bf064b52fb14eae0c345e80c3d602c7ac49ef982222c2abfe
-LLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/65052109742b92529cddde9c21003e9b
-LLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/7e7992f8ac36b427a3639c58109743d7c7134f42eff768bab248a33c7d890e731704de949d107c63b30d1644497eaa230150c575d059fce50e2eea2a9f8c2ee5
-LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/0655017c0caa7d90e1d36b2bf5f6672b
-LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/1b78ebd6dbf6b83045f9d4df7b45b84e930cc905b1cdc2204ccc5b550230fde3c1e61eae60edd3821cf9d0854a072d03975956a188fc6f64d50cfe62046cfcb3
-LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/755c270d98e648dff4e1a53bf6c11e94
-LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/3bb2bba0bf41f0d5a6cd92b7fd4f39e2b336f10f3011b0240b14c5e90769d6d77f6d0efa81f577e6801748cd20da525c0f4b21449c5d8c014f7f94ec30490670
-LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/006b00b828e176f8f29f292fcc247297
-LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/519e9d529e27111522eb5ab7c1b12b14c7a0063c4d1d74a5522fd387f52f7349b975ceb23c687b39837752afefe154ceb325d206fe376813f5be626f8f7552f7
-LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/f5644910d8072e24ec4e0126721a01bd
-LLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/b8bc06cd12e56d2d82db8f960172a99af1aba51748eef369cf95cad57107b95cdf3c21f534b48cfdea714e0e23df1a29ea82d961a69060b3649c0b043c20021f
+LLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/0d30873e7f66a55acee43d5948fa9c1f
+LLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/5e18d759332b99aa4af44d4c74215e5bad61bda576681f9347a6824b12cc9920fd9c6e87aa73f8acf1f484184e21bf0929fde66f25a091c1189f946f10ff9e18
+LLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/def878000c77970c9fd35071788d73b2
+LLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/3b47f231f283d0a15171e3e8d3f41dd6354a86a5f986e85c739d5413426d0731afcdf0464b7d6c127a895d3d351aa867996004f69f9e8fb74a324421ad85c0f8
+LLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/d507299a26c0a7a4f3d7c7e06a97fd63
+LLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/56cc59f05e595c44a8ef9209f2760db1c312394d91afb09d37ad403cfedab956bb0dfc28c9c461d15e97f000037379404d3a14bc551b579c592f5f3d5f43af93
+LLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8b587dcc1feb233e7c503f3e89d707c0
+LLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/592158975df17c5156ca1fc94518af938cdf76920eca4dd02cf15d8c6bf2a8e98588689ef863bbc24d1a538abdb11e15dd53444d9ce54c1d517902d4cdcdea4c
+LLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/c0c9f2db22ca738bb71e11735a469d7b
+LLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0901683e377aae6ccc649103dcaad238968ef750c569b530c77f775dd6320343cb0337eeb99e5c69fca0de907705630994073025db288d267215624cb5993d77
+LLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/91933ede30f956f2cbc66aa42760e5c8
+LLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b4388126af2c542471cba0a6224aec92c59dc0376a7733a890e020fa267710ef3f77b73d7d1a4013c865d9ae3ddd80814b7c55e451cf930ca37a0bdb20f22a43
+LLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/9bd64f73682db24333e149ffeb909ba9
+LLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/5d2eaac3976de1a29dcce8dffa0ce49fe839d68ba288f6e06e902f359095fc6a0c40d22533ad49401629c21e0363f82c34d8ac0d8c348b201c5a0738390f97da
+LLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/4893c85dc5294deb7d13932bd396569b
+LLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/25f3d4596fea8e3a7375ea1e8cc282fb7ac4afaa68d1c9b02947457d53dd78aa5d0b4ba97ee7d5c2c7138fb78a25e16c3075e113465b70b73f99e9b553d19079
+LLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/dfd4fbfcdf9d114982a8a332879ff69a
+LLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/11d00cb09fb1d73dc55a4fe4dbaedabb266c56b7fdb0254f5c003b27d77373c1823322b2b03d40e06fab1a5015a0370b867e88e53a28c2e9714b66e97ea61c40
+LLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/7f4da380cdfb8285c3449b97abdd89ba
+LLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/714f50b99a44c00d4a03782c5472c6bafbaba8e2c35c82e1a94c82ef74a1cad94675ba58f5e414ff9ed53bd2ca0baf6b96d8a044ab88eeaed68ca9b1d80aa27d
+LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/7061ed8e6c7ff30e641d09a986a6d48a
+LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/96e50a24a5ce85fc2a8f784fb8c6fac027d01ef6236790dadae565c6d7abbf2733747263a6d32da4a01d26042786d960d9dfbb1a8817f3c8dc247e8f27007fec
+LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/5f3d4e151c628eb1ea81fd0b56af9847
+LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/8ec01f93cc7234abf710ff43025bc19661747cc2844dd1f93464802f3f42c83eb1f200ad2855e01657b7bcd3123d786de9a54c4687a62c499b326a40aa555590
+LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5a744d9068877b4455c26a0cf1ae2ead
+LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/c1ca99bf3516eceb06409a428e6b988e6b5fc3f6097dd3800f6cdac8ea90278977b0b494285ef4c59bf34f52d17648d4ff46c119b46b6048235869cefaa08c8c
+LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/b0cd7594ce3ace35ca733df1524df121
+LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/1b856a2283a676162574f42acba2b59c2bd7e12888a83b21dd656774afad6cf40240bb1dfd2e544ab5f13d43d7b103d03886594f42ea31866b6f7bb0cdb84801
+LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d3d114c4c3dbf78c4657bb35472b9626
+LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/8834f6685accdda8a64f16a907e7f980c435d327c19d6beb01dcd792b99db7e3f4e2b218a63dbf8b90079821a5c21b5c57b761484956d2f9f2547068fc03079e
+LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/ffcb4dea25ca467e2c2ea448caf697f3
+LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/41927a4ada35a543653c4dc10161b3186e826f7eb49507fb02bdcb7ac06c68685114cddeb7d5d0449e7407eda162522549d4597d1c216c2dbbe2bb8ace86724c
+LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/d64410cb9328a1056bfa4244d6ec1ef8
+LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/24b41c566851d0b98e4432657221f60e57f1cf04c073483401a8ea9b928d8e0676b5ce484bbf25209e2ff71d24ba7bef2b327f56be936fef1c7db7e75f3e4306
+LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/34c1baed09eb46be39a532b305d1edc1
+LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/53c5c59d773057296f4b51a32abaea949326ddbbe2c8342beef3939ee13778361012d0b6826bbbd8d8a4e7959e52bde5b4791b5d689bc1b0adfd264215b217b0
+LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/785db67d3898a9ba9621259053e170b4
+LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/3dfea783f30e85c51129d025912b50a57e9c8275096d6cc52fa1a93752b8c39c804f26dd8dc6fd4db01deaf283c48ebb5671ea45816f3d4d3d507e764b5e3281
+LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/f4bc8c6adc9b21e3b034199c8585c50d
+LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/2eb3a4d559d7885894e787942a719a433d955abfd9587af0e910a75ef77330c557bbaea3db600488e008696f05a56ffd24d367e1b91d692b31cf28d4ac3212de
+LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/b7eb28506784b718d6dd9654ac9742c6
+LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/6ed8273693c7b8947ff20d130c09e9d945fc39f50c2c306b0c5437ac97eaf29befca180e6e8f61f7eb7b4c5193f647032f9846aac68327e8194453d765791426
+LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/4a6b352370dd9dfb5536d6a6788d4072
+LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/289ad6c530ed1fc43ad355fce7420335e30df4cbd02b5b27373008f91a4f8415eee2681dd7a0c5704da83d4a21752089f5f7202cdbb2a9d3b3ece8fcb26d46b9
+LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/1675466bc589ffb48c4626d7aca1e061
+LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/1d36039fa1d9ccc4715a2bb6db76bc238c65a7416d5e31c15bc9526bfb6c3171d8f2541d5958710837009b95ff315ea09126f1d8ed1c41016352a40ac268b13b
+LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/37525ca67fbaaf5e125f95943e804377
+LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/30a1679e8bfb392a8ff66e30a7f704bff88da4fdbfb0694b0384451148219ee2fc9c256306775ce655ff193b993f11cf6ccaebde2bc8fe2b1553945400e32aa4
+LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/aaf3be684e78fedc69be62ea69cc31ec
+LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/8c6c9b027913439c3456a209539f25e30cb247b297523de18530aac51649717522c5d14ec531a9053f9c82392ef7e36e03d53bd32e329e90fbd9966467a560e0
+LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/2514cd3b344b1c1df29b6ed42bb4e78d
+LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/5ecbf336054fa831a1aecdb29c01641b3c5a67d44faf64fec1d4b9c86f997b561e58fd011ebb450234371257680222f12ec6bd24aa29b0cc1b4578f8692d4239
+LLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/eb1c80df14af9b80176bcf3e9798e1ce
+LLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/7e4f70d61e2e8b05e8561253968ff3677ea818314753101488f6df8c3024027ff5189b09d42a3b71855a9b919527e7d1a099463f77d21af5bac143acb50cad93
+LLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/50b6ea315963df2469e7d014a0e190dd
+LLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f57ccc09f6ec82a9bb93626953a3ec07a0c1fe265c5b862e16c65751c5ef1d7a34d2c8d32275e2b140ea5ef0657abc0408a9f3f770c6ba615e057bfb63c5c99f
+LLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/4b31b77bda90b61804fb82e75f3df05e
+LLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/dcaa8dc33b02eed25e6a5b7315e56ac65b81352c8cb7966007a4018e54f29f02f4ead95e723e6ea70a378b893fc1036f3df7aac792f5a44552f4b0e2d4ee5dad
+LLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/25a8fec502b17af9b56896436c8c9815
+LLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/05f05b128c151a0946470ac2f609899299e74102817e7e46176728b6ce96612a32b9255603bc770d7f64976dbed0a06ccd289ca30d2d3cabec2a835b8756c750
+LLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/464e16e268b36f7a9edf4a281cc83fa9
+LLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/bec094bf52d95de0f6c49ed4e18be75e5cd655a7e9246c49b361d72db82ac7aa5838c154cf70eba4c6f292fbc867ad83ac0cedea6a278a4c4acca994226a9742
+LLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/18dbfb7b104d56a1167e66e0de830287
+LLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/71c0d3aa067d8a397ab55cd18621124fbe02038dbdac8b67e44485a49c4c5a55cecbda5827f87311448030e1ac98ebb5cfec242e8697907ced74ccde3b41e254
+LLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/cb44e73504c3704c0909f55fe63a3e92
+LLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/e1889df0eced29d82e20087169fcb8cf82fd9e230a9911ec49ff365a76b2cfc3e19ca7c7d14ab9a537d7abce9c169104f400b2756dd032a20fc5e8b211d1b52e
+LLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/df717a78c5393e4a954047e8fe22814d
+LLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/1957b6f3bb3f570f918e13a387c55b294808c3b690b99db4062be6321d4f8336911b17535fa04b359b6943a842ee9b54f136d203b1397d99e780c41c95876249
+LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/92d555d261eda37e9e6cb078e3c2c6eb
+LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/b89b748241bfe4537ff8b64686fa63dc495e64a5ba011240297add47adedb74547547dc2f80b87c686e36218471770ea3253b5b117bfc2e990eb7a524a774ccd
+LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8fec352d4d5499426c978be761d3ce82
+LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/3dcd842bb640a2772f802bae326e92a09be33a25be51931c4bb1b7ec75b9f839a29fedb857aa86ef2b674d6265b1251589572debcacdb02ee7452bd5896af932
+LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/96603a41127d3ccd9b832dfae5b26a30
+LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/088473b8c712fa9e21d70515a7f829456970f0a93f592754905b107adeab5c144b5761382fe1e67fcfab911584e481133ea1f705207f8868e9ae2cc408fd14d4
+LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/252df3705f7ae6544f502f0fd67701b5
+LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/6c75f1f5e2539c50b6d8d35b483c8d24d1d701e6dbfc59d169d69e5db24c654dae021e1e7ae9c1e7f693ecb296ad08abbc6091f3c8d1df8edf0fc7bf973d1223
+LLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/34c6138393b5407126f43f308d735b41
+LLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/abee7517a142ca79041ef4a669969d86e93f421a40a25530ba21d92f88e13e91958002c967f1911ddfcb5950fa095e3f5e9b60ef8ed305439990f9ad6a697297
+LLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/6e6baa28e352134d12b03326597866d4
+LLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/20c259ce68504c318e3d2789090dcad5a2ca247b9ed3e5d2a6714193b117033003c4df262015fb86b3a2d2fcfc72d2135dff7bdcf71126e50182d2c608863b24
+LLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/a97ee35283986ae5ce0f57ec58d459e9
+LLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/6e529cb46a5d7f9be12c7c9fbb4e0db4d0cb009d55655fefcdf901923f9636f28110de7ae18fe634d551aebf4990c1f5c350b5c9d705daa2e30b08e35a218360
+LLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/1d09d79c4c30ec32b7dc1f513cc6ba3b
+LLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/91024fd81157e0d496fe5c4fdb9f2812a19eb87ffdba009a819ac0e2c6f60145631509f200286369826db707e03825dc62c8c2af02176d10d266e2230cade81d
+LLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/81f2a02cb792bd664b782d7734029d66
+LLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/ddad49a9fbbe902e7efc4849e4980d98b21be0e8af0be71b6e66ac50da01e73058984784863b2a4f4aa12ae62f8b3806a6298e8de38198547d03ab0ada17d853
+LLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/bf7683be32c7792e1947e00062d7b8ef
+LLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b3ebeeed5c428fd5ed2643ef45511b74ee0bf0b02653b9211f002e7ecc9f8ff5437139ca0b282c7f25a0918b0e25d316e97b2522a69099d7614d3d1cbe243f84
+LLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/371fd22021c2d6a150e7a7500dea52d7
+LLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/635cc4cfbf7809b679d5fde80b3af72e22dc056778eb7fc66ff80dcb7706809b4819655e922ea3a1b78c913c116444805b05b8fb98ce84c062ea67b12bac417c
+LLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/a60ed90e12ec86fd71be1e7c00626429
+LLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/d86264d3d89c647ba75b919b338f2ce6dc496536970a3459abb88b3850216561603e4ef43e821d64a1db8cb53f27be12a2a462648b8aa8e5478290e78fc1b66c
+LLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/8f6abe2c11ecadc4e7aced1373bab7b9
+LLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/8746bf3261aeefd3af48b6cb277530add2d1ad7988140d0c086c386213d9c7e0c81c04569237d1f6194b6c7636166b78e87d19ab231a6963aa460e557e94ab3e
+LLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/d81588b9e5be65ee8099f5ff063421d7
+LLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/23f35975c450e0ad84617ed61d0a8fbe0c52e2152fb3f2207913e8c9ea4ec4cd7e1ecbfef283ea8c69ddf453e9978f9015965ac18bbedb95b8f802cea2a44c56
+LLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/bb23932f8c246ba09182c9f35c714714
+LLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/78ab81475ad9e62eae7068a7e0def61c9e10e5f1f97182de3fd1dbc5f4925b05c7f239a151035b086ea7bab97e697073643c26d762be63a0da67b1c1cb03a9a7
+LLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/5c84a61bc941cb920e09a195080195a9
+LLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/083fe443b5b8223ebc12e9f3393394ae790f2a9defcb81b8a1ccbbdb9d2631a6e5e8b4f3b000744d6cd2db6bafce18a1919da80bb563b79b7b008484eb5b4997
+LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/5078269b5db1fd0ba11b9dab936ec538
+LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/69ac651d6229cf4cdc1360ffd17a2a0b5ee3c1efcb13b70f651c3d58d50e9dceb6c53acf0d1f05fdeacf7361460be564662340b4e6eef82cc2422f8f46eede94
+LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/96c2dd5b8c37c516a45d30088bc9c67f
+LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/9f9904cbf0ecbe5e599cf6fee2c689d1b9bf28b1fcb434f98f732af9f02c8ed69fe6107abe12247dc50f7a7f7900a6b5d6e5ea38a0153d4f4e0238dcdecee7b6
+LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/45ac91912beee2f1a348c300830dba87
+LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/034dfb8ede8e63d208d7b07102108f1d69e28644d21919d5478e894d42f77e8bcd54774eb85080cb0b03dfd76f70fbd218d94b0d77867f78a8db5ec492d39545
+LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/82701bc015acc0ab092fac5eb1b7c854
+LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/1e72b2ed04759607907a9931b8180fbde059f04b1066f4eb3272e16752ab854aca1ce3579cb58853bf87a3ecf2b1acfe14fbad324b5bcfa31824987d45ecc225
 LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/md5/b95ad4844e649bf46db43683b55b9f4f
 LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/sha512/15e0996aebe6db91fe58121001aa7ea4b23685ead3c26b5d89afae34b535e34b4e801a971f4854d8e1a1fbc805cece06272470622eef863e225358113a127913
 LLVMLibUnwind.v12.0.1+0.aarch64-linux-gnu.tar.gz/md5/6d8783dc9b86c9884e0877f0d8ac4167
@@ -138,115 +138,115 @@ LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/md5/54ac594b4c8e7f261034a8
 LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/sha512/a43756afd92081e6dd7244d162862fc318b41ca110a5e8be6e4ee2d8fdfd8fb0f79961ae55e48913e055779791bd1c0ecd34fd59281fb66b3c4f24a1f44128f0
 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/md5/83cf8fc2a085a73b8af4245a82b7d32f
 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/sha512/297a5c7b33bd3f57878871eccb3b9879ea5549639523a1b9db356b710cafb232906a74d668315340d60ba0c5087d3400f14ab92c3704e32e062e6b546abf7df6
-libLLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/119e6752a47c65f2eb26becb92b0d1b6
-libLLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/f83e594967feaf6b5aea1b81db28f36386f2c33b28c63454123c4563e235526cad50446d153d0cafc41a39252fb13c62b9a9d9489429bb263e61d9ba54712a62
-libLLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/946e446b392d33f6c42a3d6f8d854079
-libLLVM.v15.0.7+9.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/f5fd00286b65101b644837fae104c24cd8c99c79aa5b952c0fb3855a25377626295cd839cdecab7b839e3a75d5b2b852fc3a886c71fe0f5f4ab78ad348609c45
-libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/55f9c6f7a51f5310da2d0205ce181c26
-libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/89cdb450885dbb4f511ffe3939afbee607bcc2e8568e5ce6ac34bb36431db3c7c8ca3e9d59a27e2ccccddda13ecc3c5d5ffe7a19ae63f909718a731f5c27067b
-libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8600b413e657ad169370d2e07d168aa7
-libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/ca35d96928ae93ed36ab8274c67e5e8a9a971d2b11a3363313f3160579871856cf5c92a8246edc404e10bd44a21c1dbe66941995d87af5efe34b10882aae1df1
-libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/504427a6bf7adf4178891c37a2cbee09
-libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/3a4e40d3ce7ab47987ef604275759cadc171a168638781e74396e2cd48bb6a8a8bc0983ccbe099c2bbb43584d405df63a214d5426830863db773487733688121
-libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/75dbde809013a444c1d9db1556b7e14b
-libLLVM.v15.0.7+9.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/37a72c7dc0333fb6be67023447e82a8f98ec3b74c64a3f08b5b047feb585fa8f35cf397ab3db3eef512ff0a7ace6556c3c4e685df7ff22dd095515b77b3ef8ca
-libLLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/e92dafe7f987c44f2a860db03bb6df05
-libLLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/31bc73561d6ee24bf8eaad8b7cbbcf1a3713814058a3db47624a05ce572e407241cb7857a851a4f12f93be0df4f2341102e0d68c8371505fd36ce19069e48918
-libLLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/6b978e264a0a1131907c817d4f259534
-libLLVM.v15.0.7+9.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/bdb4976a3d4fdde5885f930a411da895600ef1ef76c8c0f5d6929c9495062600dc422e87f7fea4af12e169f508740fb0701df50ba7e9c4c1c332387a9b7d4c6d
-libLLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/ab22578145e661333b4e4d7369e5ff7f
-libLLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/4598533c15224a1543fcdd84edbf11ef9611dc4cb22e16f4bef66ffec65e5a9b5a0993bea9bfe25c7af4bb0447af0f31ec82b1eca01cd96d8065bf82007e58b2
-libLLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/9ceb4fc78861ca7d687646350a3d18b8
-libLLVM.v15.0.7+9.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/158f0bf1cf555e5c0b79c1bb8ab9cf8a2c434236f5795c70e9c08c2b5c01da4d88a59cf61a1215f40e4046d3875dcfe2fe89c56e9f6ca7088d10c1fc044de22c
-libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/0172fc1ff16552478bf00bbb480b08a2
-libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/710d392dbd708208eb0e2149d87603e2aa4fa99722d50fef2e2ed8c9ba5fbb3b4dff3208a1ee390635eb885aab91a7b228083424a9ca320578b25d8e391d0a8a
-libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/c9583dd988c03827d08afb42342a4893
-libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/0954a6c774befd092d59ae228b7a48cfc509fc89e215e79958f460ab2dadc5f7fbd46e00d9c3f0032ab96cd0300aab4f6cdb92488cdf8619513f82cf56f512a0
-libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5fbe9ce9d7cad44dc57757ce537e098f
-libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/b275a24bcc051c25fe57f042518749afae00df2ce61491a70227a7e2e5fdd793e069597a1d19d148462149e3bc0e7d7f5d6b578187dae4e791ae70fbe063e14c
-libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/42b7d81dc8084eeb385c22cd4b43e34b
-libLLVM.v15.0.7+9.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/75ca00734dd52ef00f3603bb8b89d9ffbb45ff145d2557c460dc856802d814e3ff8e02af1179a18ee32edb0552ccd4fcb44cf5b23b682af164969433916c2d47
-libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a138c265db068e53752ed917ef9afeab
-libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/b66106cc2d348b262d097158ecc0a5ce604460b2de6e1f2c04c24f30a3e7a4103a2c775f0ac1b9f9ba2ad23c8b9a472d0dcb5a266222149deb6fe77611a245a1
-libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/d1e2420d0c90443a2e9ed805e7f36bdd
-libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/641f40c2bc485a09f69c38afed880987562549342a71d8626daceb444d76d71d2ec7bcdfd23e870cc9e216791be223599d29e885856a8be4f394b59750b23a0b
-libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/03e52f6937072c2bb6ec1fe6e62e6181
-libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/30399baaaf445c45b70f0fd4c95b7d9b63b0f0b2213d4817913b2ea28c35cd1906c398c8cfd9fffde077fcebc43445d6b5bd992ecbe9859e74a3122318ef3628
-libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/12301c5764dd64d924ef617547dc9b8a
-libLLVM.v15.0.7+9.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/3d11ba6018f67712483cbb9c52e686d69000b39964e908e13e6695832eb1e6e9f8c764669cbe487fc8a9ef11b4619bddbc9da42210f43e4f60984813cd81b1b7
-libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/06c8c80bff9e49ee05f8024f527b925a
-libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/671c47b9f03856641eb0e24cb4d08fdfc2993bc739d5cf11857b0bbad517fab490b2259501d2efad84efd295ad7bcdfa9d0b4991425f7bfc2538b13f7958b556
-libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/a7d88848fd4ef9dff68aa4f1294a272a
-libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/25e243b38a1a5bcc1c01f9fcb69d7fa08ded91856de0c626bad22d472c3af77c3ac91d4dbbfef198fb90d21a7cc100eb461f66a21764adbd867fcb889121aa9b
-libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/c6cc7b104317544312531f2acda37610
-libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/e732b0af56e5c0efb9bf15996bb398ba6ed49bd5a97517b742d54cd16415830e6bbdf4427ea6e07f316c720a31a279220e72e360128cbcd867520a8322690594
-libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/2318d50e1541d7d319ee23ce1eed268d
-libLLVM.v15.0.7+9.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/3ff0a6d43cf26af45e51d966a4212cd3a7b4127cb7dfe6742ead34c489f1a6487c06721591db4e26848b0d42abd49b0a970231f2a1d655c46686f163c7fd3c0a
-libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/560bdfdfef0fcab6cb71eefe82412f30
-libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/8d1960d83544e4f6c1a421f4f74f17cf05503c52cd3b5bc2f3dd544aeb7b533af812e1ec1dc113a68396ea66adba5ce01019c97507f8115ec087c95456cb8bb8
-libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/b4765514e48975aa73a9694f3bdca5e5
-libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/085aa81d1542b50b247120b08866775ce3a13dd23e9b649282c902bd2ba8d4581a4571c09d241340a29bc8413a7e749c5f37c1063af4f5b450cf5b271be1e24e
-libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/78000c16b21ae1b67610976a26ef201f
-libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/1a053a22f183b7b04b4ce8fbcc24393612ace7479a60b73f2a58f54b1ae8632fb9679daf10662347d17ece27d4f64be10d28a6b7f21cedb1131c174754e77660
-libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/12ec163e43b1247a37b3edd5662b0317
-libLLVM.v15.0.7+9.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/44a8a3a68f63a2858a190d2e6ab80952d233f1c86adcb9e6acb23a7f7719ac710a3aadc89053433baf33b435db191b67132f52ccb1ac0f731aa5088400f7a7b4
-libLLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/41bda0ee2f4bc2fbd5b9ee19648249c6
-libLLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/df36876b425dc1ad4639171c61bb82ad0f13405e192cff4d015dd98a2360970ccf096a865c0e8ffc94db829f928ce6323fe54c2db58532b5417ff36da69a1023
-libLLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/335e0c093c6df8d38a0543c5ac7da915
-libLLVM.v15.0.7+9.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/384bb24b12d99896ee617bb54c5a76714df667b41de39dc83bbcfd7e94c8aa2e0e8af9f82570c828f395cf363fbb7b8989413618b0222da373bbeb37a60925ac
-libLLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/6255fd402da3174d3256558b719b0ed2
-libLLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/df45f55a4c9f0b235dd741e85e7c353300fdc3dc7b0746b1627b2925d14aba8420ffd669529441b8decd8227dca7821e3efb7c5311368cafd2ef1e1c985a5546
-libLLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/c07fd8ab5524bdc8480bc3255b36b44f
-libLLVM.v15.0.7+9.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/015cdc9f78ad1caa90d22abe46314e7ef685ef6da3fc842de5dc641edecb6e41a1329ecd6a9b1450ab50649318320ec0960ae5baad1724c5d938ed97e6fcda17
-libLLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/f7f778128d4bf9982a4b2d8fadece45f
-libLLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/622eabb90a99c34b02784303cb09a9ae2670d839f9ca0307c7034abe7e03ac2dc637eb60c084f4cc59e88b184a9dc174493e812b40a4935b05dcab8b4ae23f1e
-libLLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/899150cd028d99652e2e390c9afefff3
-libLLVM.v15.0.7+9.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/834d8ce87a58e876c5589ab05389ddfb7dd898cc90a2a8138f31d5bb65d01821a4da4ad70b747b506cca6119cdf70146aa7448307655681aeb7e58012dabdc2f
-libLLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/152a7b0c440560edfe0e20a5c8eedb15
-libLLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/344f2ecd173d198d3bfaa7400f46de57822219345234157ae9c901d929e0a32628339989eafeaff716763d26b4c66ca9cb5f55696fa3ad9f236d537f21e26b0b
-libLLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/3755794024285e1a3e9dd716e5a0c47b
-libLLVM.v15.0.7+9.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/245c5cfce819dcc128925bd40ebc3b39eb2b9760a400c3604168a13434ab6ca96e9067df19acaabc031205d59996e677bc1d804be3c63e7d9a0a88fee6e4d518
-libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/fedb5c68002a0827e4172ba59ebd3efb
-libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/4137e0254c8176a9e5ac1d36160a27c1a0d67ec1c21970e115cdea831211ae1258fdfa8f8f7382bfccd08b467777421458e74274979f1e1c2c4c163cb9e51d06
-libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/b6ce8039dd59ade65a12087fc9a507ea
-libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/06a351fa2e1dfe1d762908bfbc9c350b15758be77766b8c2fbe9d3208f4385304fce31051966c3073e3cb8aba7a1c15aac12b725fa8b552fb30ac3ebe69f7379
-libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/fb15051e20aa736d745c75af41e1ac72
-libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/4bdb341710510e07a2a7151f2f612229269b12d6bd6b3f61d9ecf5ae02001bee1e24cf0fa29ca36f105f5b003544b95c47858da59c201e49ba3a067dad7abc7d
-libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/4fcb319068cd0dce43619eee69c3ae04
-libLLVM.v15.0.7+9.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/f576e9d47a6b12026d7b765b28fbe8fc88a64fa0d4d4b76640cfcc25648ba1894d0bed31a1c23c3a2086d9fc9db7e17c944c9f22cca3d8142656b12cabe1556d
-libLLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/b4a3dcd7838f363c67ffccf926e2607d
-libLLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/1b72a72de7a14a15a9748820c44f75f3ec6b0ef59f25e9a0a3416205014076f4503781a8738770af2fa3b02ca8445be09bd873bf1d37fb56ad92ba690624f4d0
-libLLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/3af7ad02cfedb3ae47b3bc9748abe5d0
-libLLVM.v15.0.7+9.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/18e6a2bbafa7f7381b5a063db3769aedf952f21bb97e6d26a7b55fced146cfd34ab16d300ca9d42be8d703e4e91426b21174f119fb0348179651d1689ff07c7b
-libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/f6f5e31aa1047ab6afce0ffcac90ac14
-libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/d4235fb8858d5f696e0ac6252d54e7ae54abe18336f6e962631c83feeb6a1c1c87cb3a65900dc4d41a2f2ecf4eaf63a914392c151d26003aa5ae6b1858d417c6
-libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/34a53675cb20a6c2114091dc4b500202
-libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/ec81f180f3241c4936a0374b5eee9e1336bb16dd69b403c9c8a4d2bec6207a197a55d0d6b487b7ec694d18db09267f7cbee4efb09b13d32d57927381b5dd09dd
-libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/5a392fd27d729a834fff3536dd3a11b0
-libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/152a79331508858070bfa62444c45a66eba488522739369886c277cf597e3b7e5d24b74b371b87e3c92383aea3ffa259a18f6d216f27388babf5baf46a3bf352
-libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/d275153e2738e0517d42e9dd1594c1f5
-libLLVM.v15.0.7+9.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/16362cc75e79e7f19819a2d6b46af96d4ce152bf3a733eb5b573932ad09b3c46700036839978e5f968e14d7c6e5e96b53b051bbe0e1f644421bf8cb1078d3010
-libLLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/8f6f6f101db3da2a422239db48d80228
-libLLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/82950bb2b6e3f4cf4832c73df72753246476ae0c923fe2d1c0abfaee52bdf47dd307e478594163a50633c248d7b86b64ff43a6fd0601616425b0d44eaae1cf55
-libLLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/dcf7c1df5048db10ff97ac0639a4e567
-libLLVM.v15.0.7+9.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/99bfab8c2f954c889b63623e9426bd6e378b51a3bd414c6ce844e8464f026ca21de2e6cdfa313e678b6bf93a62af39b39bfeeb4154e7362604dd5216323fae4e
-libLLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/4475f2fe1521a0cc8213a7ef53052a3b
-libLLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/82a0f70ffa92e7f43d8c07a0c64dc5ef0d628b3150c285d87926e49bf66017f1ca4cd8a372b1c9842154c8e47db933e95305626501f481d2b837119e843cea7a
-libLLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/0f13558877d79581c2d302fc2480fd2b
-libLLVM.v15.0.7+9.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/cc8343fabdc2569982b65c55dca33c290b3d72ebcd7126006fd13f1b216d2803c502f6a5e9839c69d22e642031db711b2dca23ccf1ca3b7c481c55dda1159630
-libLLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/854190a61038ca020a18ef5fa5cdd0a1
-libLLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/f39ec16b2e8aef564b8cc7e523ab2b38de7f18705915140f1769e003bab3871259c8ba3403c0896b3cd78b2cf30bcf2c2d2f5f649329dd35c0e4fc706cee203e
-libLLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/3c58b4d61518cf6a53b1035f4fc9b13e
-libLLVM.v15.0.7+9.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/b706427edd2fe21ca527da587f1cac37b0e36857c6006b1263115bf3e6eb9bc4524b7afd68aebad42d28eafb22fde8c373c460e31a123e8ae4cde3b2fb249d7b
-libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/1d5d1f85a7ad52636b550fd0c449130a
-libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/4bb34be432bcb752561068b9b99756910bcce1ebc91a54761fc67ce08536e807d61cfa238a0df02026e1a4131cfb2feb1137f449fb16aac76eb4697befd94a6c
-libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/b39be2b3fd55154523d6cefc9eec82c9
-libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/ee38ba17a790caeb3997e872eaea2dc81a2e9cfbb70caf900c65052be859ce798b008d545b1cc3c0025d880e069fe4287a37862f1920c4e0c7abbd11a811a080
-libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/4197b06616c8a56ea25dd16fc5cb3b68
-libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/cf2a1868f0b68b76b00bf97bf9ea89f5054ab89e5177b112b8c958ec1c9545bc6ed912c3b4b5038368cd6447ec295d3ae0fe6b9abc4f53c91239644a3bd1a95c
-libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/608053656f194352fb58dd00a3168a41
-libLLVM.v15.0.7+9.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/8f4688db666fd2342f57887aeb64b85cf000321c6cd9d27f9a685d61136a27055cff426d3eda1a8beaafb8a178250ba0e4736f435baf3e6f1cf31e20720a3a8d
-llvm-julia-15.0.7-9.tar.gz/md5/930ebd05cf54da65ae2142aa2833e2be
-llvm-julia-15.0.7-9.tar.gz/sha512/f9f4d2e28379470f7b7785be2782f8295aaee2c1587d7678fa1f43747a1dabff6b065e4ce778def2ebf6471595b6c072a9650b4a61d019e34fde8a1fb7bdee5a
+libLLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/aafac8a677723e932e6a4cdb6bbb4411
+libLLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/b584923d317db14a72434ec9d684a34e0c7df2c9b88fc4f005922784fa0fea6975894fd5aae3842b81dd7c7cabd34ecc8faadfa0b808bbb582c7eac0ca94ebd0
+libLLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/d890bc7254bf75563c79261b35feb8fd
+libLLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/55a6bdc18476cb2b98b6e9370da8efd519c2a25624eda32fd301cdd3f9d9863f4a113b631536b6e982d551bb3a0f3e8cdb690699ef0513926ae5c86f65db1f8a
+libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/f4c53b8cea77f992d3c24088cf0c49ed
+libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/2b61db1a554f33c5f46b00f4032c722922755267de8f05de04165907329b6b4e33986255084699291be8a2faa7aa5e36aa0bcb5eec2aa324cb8c16e451518adf
+libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/52c355a71a585f09aef28ad4605cb51e
+libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/3a010828b7a6fb51101cf08a74702d2d3d5d85579a3e23a91dff1b3622ca6fd8f04948cefbbf74d03e3cf7955b566dc439f04ce73ba77efce9d8c8e1cc37d790
+libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/bb96ff22c46a5587b066e5994c1d806d
+libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d643d142777122cc745dfe853070007f70abcb32a9fe5bdaff3ca0eae77f5b774323ccf1c51340ad2f18c72fbbf83bece673dde0c48f94b1ee4204a69bbcdbe4
+libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/9a68655b71b38c61b59959ee890199f0
+libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1b9e20d00114819029aad078aa201a1bcabbf5a5b66bf9867019479180a37cc930cd50127657f87474ae045d1ee808298378e3ac2b8079492a8a3ce4663bdd60
+libLLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/ad4fb8227d147a16b19442b194a22467
+libLLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/fb9c1184de6ea663b3c1b20ba5a5f65afa6bd2a0ea70472db8dd15246b7f0cbe7a0d29eb3dda66d969a6a9b48269f34c200431279e2215760f64e74de6f865c7
+libLLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/8981bd41cb59d4680fff276a5cea6b17
+libLLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/5992cce6b5bfd38f62b3b370f1ac72d106ffe42c075d26cb6462651f4e9ca1d8bf8a91a254ae4d36b656643f5926229d5ff6fe96e1b31151c7e96f85160a2571
+libLLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/f25e87b0d1c66dff45971bb6c5d2a6d1
+libLLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/581ea7266aa711b355f3a0c676bb3e7bdd33e0297e24afdf420bc5e2ac9cc4bd9330150b8f49af977c9fbfad3c0987bf6f901e93743c844a3a1ee3a4d7902717
+libLLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/a6a0cc01bdaafc1f34d35453ecc89fd7
+libLLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/cea08396c6617a6ab8ef8749c4af9d15b60171462fded556726f35dbccab888b763637002987f95dcccead210f70c947458068c9ab1fef696cba61334010ee9a
+libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d0694876f0a4af8f738b1ef5b15b7483
+libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9dc388988ad1a05212e7306a494a8800be76378bb797c01bb9148b8db02f6734d7bf74b1ac2d19eead331aee4121c0eeda7e05635196f5eb44ae4fada1e8f2be
+libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/92868cf79a7e9af62d91f4d1418aad4a
+libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/093ec44f15ec8f8cd855f4c56a70f51b244837cabff3804cd8d5513b3ba7a1ce4d021009a2cd1e484e8705aeab2af5c3f470af2d03b9c21cc3619ba3e5e80621
+libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/9ef52c4ddb07b6edb399fd6050af7067
+libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/e109335b53f7bc98dc837c4f90c085ba37864ee9e4c9b8c0888b6f00c5f083a2639e3af6c4a29287b3e9b0da6af555832b1cd4a8a514a963d8f45458d70bc291
+libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/894ceace311aad57cde915bc4f7e3068
+libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/a075d62dbcec46612ee7b58e00698a8aabcb53705396e8aaae9488517eca34c52bdb5daadd6d21ba721f87a0a46b79bfbbf2268e545020fd60bbd8222249f939
+libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/3a6cb7ab61c9739915ff6697ca6584ae
+libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/7e50687474b0cf3b1d01737b82d5d8076b2559e43a3fbdd9fd376d2f0e68cfb6535e458d7b8781a4a0535f00f28b3b29d0fe390cdceddb84ca4bfd360e814b66
+libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/3213bdb23eacbbf1dbb21e5758c038f1
+libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/51fb41605c5167486c866885eead1c95ccc11e9b96ca222875fc0965fd97c020afd11aea52abb883870138d5029434cdc5a27d6b5fd5d7966a61a9a11c5d1fe0
+libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/0ebd2f002adbfd00a1a39959b45dd4d1
+libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/01793b10cab22b3a78c53a9394655572696b2bad368d0f9432582109cd363432ce709c2de04130395ef66453479f154cef1d6a2249340ab6391f85ba4111ab1a
+libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/8ff3ccd7327e47d1772f6a7ed2d33bf4
+libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/cb01d95f48f41e17b3b4c6549d5fdf5b1c6c8d0e38462796eef6966ad75a81e05a829ed732b189d34e2d3af7f70dcc2530b6b2692cf151f43d804c88a1ce466e
+libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/dd9e9d296953f7cf32cbe39b519c9e59
+libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/e2e3d398c83bf3b7a0cb084577493455ce24ef551edc59297761a8df4007c07e6a7e3727a33f3a650a69639ba3d5de96051fdb6230a985a907582db3ef0e5d2f
+libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/62df2ac64bb8195960a93cf1f1fee8b4
+libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/ba01d9e1e6ed1096a04fedec5f319497620a8df655535104726a1497f27a2df4766955d4ac1e161296c313bbd5f0cd8c2d524c41aec234a8c38a1717caf56a63
+libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/69e44d007b7f44fefb1622533e2964f9
+libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/9d934d951c3e67c6f008438db3159f7a4628b22db25e5f47fde21669120ae766bcea839adfee748a9b1dd7f3f3d758e88fd7bcf95e0d9289d378062805bfb954
+libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/0a8eb8bac53734bec7f153ec6a46bd34
+libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/1ffab09538ec5267840d4d74f8b9fccc1213707471b19ed7a45789da49bcda2d78a4da0d6954de828b444a33fb020b771d3453fe943334ee12af62984a96b409
+libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/320247c2e5d1bfbe966ff93e194bc6ca
+libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/4b38a64de0794befd2be7256419de25eb0be7642db922f15dc359c1ecbfd647e3e1e75f0671f71e66455853af34912dfc2960d313f269d9318040583d48d05e1
+libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/1a15e742f9109325842b08296b900d73
+libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/1c3844c7eb23b7829bdc9d5928199cdaff42e98ee0a931912e9931724e110b965e7ec5b8443c3af79f4694397fa5093786e7e7257344df895cbb22cd827df86e
+libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/d88d9d0e9eab5681bf92c91cf5d8ddde
+libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/a956df66e3a71fd995aeee43cd2ff8838c346de0a12ea4ec849742bf2f9530e9959a316b16c4ecdf184d5692293125309ac7668d2992f81f17b207657e2c1bf4
+libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/1c0ce845334af339b4e797af5bda727f
+libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/8be9c57a67331cdd5dbcf9466bd2346d21fcb100beae0e2027961d8b7b57d26ba03e785dc701f2cbbff60cc298e6aff54a8890fdafe4f4e505d3e91b8ac6adcb
+libLLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/2bbbd07363fda9e70bfce36a6c5ad6eb
+libLLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/0e4be179ecff5be8a715b744ac441a73cd742d98ee7ac521de4cec1d150fbb2485c29138d6f489289c7a15f74b5a68418133375162caa324a72f4ab1f95232f4
+libLLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/dd655c71803ffae63e89e44f627a1649
+libLLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/467974be3051359de81e2d08c7895cfdcac9ec9d6ba850c7515915b2358745795ed2ddd3c5cc12744942fa72a0eb28ce5f4ad4f622106d4a19f9e289e5357a27
+libLLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/79c051e8492e8c6696f356bf450c641d
+libLLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/da679eea0673b1c117363785147d08f372e3be95c8e00bfc5277e662784be3232a1a66c1552c9bb538a5343fcdca0f7a4131805acd239216b26c05b81eedd97d
+libLLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7d910217dcf88c9c59d3a1c4383c5067
+libLLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/10ad390312d937f40e05c3444509f8adfbe0ee8fb6829d35a9a8ec7736106e75d6d5f48b9154e140e4cb59ce4d659dff624ae4a3f6353523d462f63fde4122d2
+libLLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/168402080c3d56f85a298bbaea1c1b17
+libLLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/27c29f50968c01adca981939bf1aba2010341ab4aafe60c4554b954209ef04e793a572404028a63f51ad9ed962bc72540f2270486b9a1f4501535fb547df11b3
+libLLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/92a55a6891a199d49b1d523a3fb24766
+libLLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/82e52b2b177758ee8c410407c6dc4a5f72816e2b97f9c971b6250e27d9bca1ebf73c5700dfd67c648a0ab0a48c48d6eabee0ee9bfa820ee8cf4fec64a708fc43
+libLLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/441231777c430560297c930f1e41191c
+libLLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/6ecbb8a014ab4e9ba5c930d81020d9ca47feb2105335e874a5f46a08aa0a2d8ad3622434a21d4361191baf5868e1fd6b9a04a69ada27d3ec1dac4334e92cd640
+libLLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/5418d900f7eaecaa8d0258a498757fda
+libLLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/fb25c480cc1826b3aa4a4d861281b6e701b1c792ac4030ad25265ab9510a159994a74aaf33d20fb8ed545526ca11eb693ae7cb0e79499d3248097d39f9691073
+libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/06b1e8271b1551b32c1cdadee06c40c1
+libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/7c8c10225e9cf75a6b23317e8a277cd548e8f2de41ccfef91cbc66338f94ba59c520c7fa3b4baecce8dbca6ec3e0f241aa09f898d44b1b459b738b7c243f636c
+libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/527a5f29eb6141c2ae43c186cd6c9f2c
+libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/466c863bde18d1ff889379ff18c79b7566b755a8207fe09e7a3faa770de242345e781aaa446bd2b656136905f0d2462f9062061052d0472c1079c966a03c68b1
+libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/bc24a37e40f45480aa5e458f022cc7ce
+libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/83121dad17e11c6bb2984ff1e7232ad77da362d3699f7ee1c15a8778d21635d87d89d483cb5848034552f23c2448f47c05419247a326c1b843eacd6cb9e99d0a
+libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/0b0ee5ee232cf0da7ad227609d1c09d1
+libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/8465b942c400e7a811bd4d46596ca57bcb5ddfed80358f7256d5671db3f797342e9a8ca800d74785874c8643c45367c952f4109d63cebce4cba897db3671e0db
+libLLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/558e9e1ca9306d382a32f7fdd076a509
+libLLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/7d1d0e8366a3541edeae36ef0a198db9bfaf7eaf54064c8b3eff34fc5efa5628d41001a7a94cea4ba6f960b64ab6849780ac79d25bfb5e30fb7255439c2fa012
+libLLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/8c5afffc8d684d7fc42ad46d2b3e0eb8
+libLLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/7a857e2b4842c2520600b245f9f3aa44e5206959fd013ab36ca2a9274862f04f5953d460e6024ed572f1ee9099d4afbc74187c310546476e6e3763cb4a68ac14
+libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/97b51e70fb151f680d268ef348f4e8ba
+libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/5da888921c4bd3bb801c136c02a37f8866e468a02e7716290dc73ba85cfc3adb42c66c881e7bc55366b3d98f4190aa8aa10c5477464e1f53b6c3dbffd9b396a4
+libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/c505b9ab36ce3f2c3f22a03edd8c17ad
+libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/c69f17c49286c352557bf2d5d34a6872184558612f435d0cda2b55892d3cbad91862f19cd0dd2129d5e8ccf6172127445b17a5d9b7c8a136abb15175f49b1c78
+libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/9aabdd2b8c2c448fa346727c89468d93
+libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/25372337eb7b55bcd51407e9ee202d55633786b6742e38ad12677b0939c824bbcb2e10cef0d6f1bff6f4c0ad8b461c30fde862daf4ddc8a4bc4ea3d91436d4e7
+libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/58466a504b06dbfb8dc48c15184193c8
+libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/d1d76bdaf3e74a1003fef3a623675be7a9ec0c64f7c5a0c88e7da0bd0384791b39e46dc297b3544f634a1820ffd051a3843c2e91d9f53319609d66542ea30e23
+libLLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/6b6f0d707452691ba0c3504616f2548b
+libLLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/6c4bad2ab972cc89316f246b0af6c1907650d17685c0923ca2f23144aac7ecc4fdbc29308fcb76d1c67ec99b6148cb0e48f49319d62834c8cbe750a68735d604
+libLLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/319a680fa35212f8327c5f3cf8348241
+libLLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/c9ba68a75a3491320e9e7c6eae378ce30cb504450fca5e7e3953175182ba4ef7347fc5aff0219617200b508244aa8691427469cfc49a230ac70a690504ffee6a
+libLLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/230bf82575576a349873550a4e3f3f40
+libLLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/1a7cab070cc58b5bc1d5c3397f0218fb7c24758d0a1b0e1f8ed3baf71e45b3014afc6c0ff94b3f9c8627dbd62603240a320a84888b4c69df1cfc485e16c9c1f6
+libLLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/bce28b0fde016756db056611d119b49a
+libLLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/8247dcba4f31dcc22d9771b3c5e6e96b29c5019df24a5b3f026c88a822877bbab75987e512108523951ec938b47113b0f6c161067b2935e9fb5735839b18fee2
+libLLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/7ac5d8081c414e6ca91bedb0f5cd5f78
+libLLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/86899309b86b542dae0812e4ba78ba9dfb7dd6c5d9a9db3fb868d78930a906cd70e2dc63bcadf8a085b0fd5690af1df80c0cec9df3c1dabe2c312c049defff39
+libLLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/b5c2edca868b332968d63d161ad7a0fa
+libLLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/352e5abb30d78cae34d10d25f3cc0f856d79ff034a8905610ae6c25944216d3dd78444593f3b1355a7e541fb47adcb88df312ffb374604638cd08d3105c7dcca
+libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/3a818c98e5b2dcb086a58390ef61d82d
+libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/c238fd4f9cb573f5b47c3b71e3d7b7a26457267a049f318295f3e2ab2498ac6418d79e0734dde6dc47df859b670d8e8588ab29dc47fd7bd6e4f49db1c4b252b6
+libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/3533470b13310d9cff7e7a7c3619d921
+libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/89a533d3485dba9611ad799f9b3f26af83ed5dede874943c230236a09c2e6ab36df167dbe34f7121af5f291d0720d0975096df46b5f5db34c9822602654572e5
+libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/bfa2faaee4ffa22513c5109e7c76e788
+libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/dbc995dfcc6da651c990b2b9254aab4d46a8dc05fc2961d5fb7199fc9af3b44d0e90b3206f605d9f0e3e9acfac6b534c3e9e5b8d05f0dd17f5c3c664e72c6d7f
+libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/e92c1827d1e7b815675740bbc5000cde
+libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/b098df199c1f30b0a5084c91af8cc444fbf9699474ea78513489a5cc434f8235952359f0d769871c7a8b344216c8de4893c517ec7a6b12c4098b585cfa67666a
+llvm-julia-15.0.7-10.tar.gz/md5/e74093b6e760645ca1567aecce27d463
+llvm-julia-15.0.7-10.tar.gz/sha512/9d2b466c0368996bfa825cdc4fb8e00d0cd43521761946b310c8bc6fff461771f4454bf0b7f8be44d723462a9a2c3721504c4250a3fccdf969ffa789ee40d058
 llvmunwind-12.0.1.tar.xz/md5/4ec327cee517fdb1f6a20e83748e2c7b
 llvmunwind-12.0.1.tar.xz/sha512/847b6ba03010a43f4fdbfdc49bf16d18fd18474d01584712e651b11191814bf7c1cf53475021d9ee447ed78413202b4ed97973d7bdd851d3e49f8d06f55a7af4
diff --git a/deps/clang.version b/deps/clang.version
index 18e40bbd2c434..6e50e2413f622 100644
--- a/deps/clang.version
+++ b/deps/clang.version
@@ -1,4 +1,4 @@
 ## jll artifact
 # Clang (paired with LLVM, only here as a JLL download)
 CLANG_JLL_NAME := Clang
-CLANG_JLL_VER  := 15.0.7+9
+CLANG_JLL_VER  := 15.0.7+10
diff --git a/deps/lld.version b/deps/lld.version
index 106ffc05fecf3..56303e3dc0292 100644
--- a/deps/lld.version
+++ b/deps/lld.version
@@ -1,3 +1,3 @@
 ## jll artifact
 LLD_JLL_NAME := LLD
-LLD_JLL_VER := 15.0.7+9
+LLD_JLL_VER := 15.0.7+10
diff --git a/deps/llvm-tools.version b/deps/llvm-tools.version
index d7ae53fca1fc1..e7fd7ae57622a 100644
--- a/deps/llvm-tools.version
+++ b/deps/llvm-tools.version
@@ -1,5 +1,5 @@
 ## jll artifact
 # LLVM_tools (downloads LLVM_jll to get things like `lit` and `opt`)
 LLVM_TOOLS_JLL_NAME := LLVM
-LLVM_TOOLS_JLL_VER := 15.0.7+9
-LLVM_TOOLS_ASSERT_JLL_VER := 15.0.7+9
+LLVM_TOOLS_JLL_VER := 15.0.7+10
+LLVM_TOOLS_ASSERT_JLL_VER := 15.0.7+10
diff --git a/deps/llvm.version b/deps/llvm.version
index ba0b900233bfb..918889e016f2c 100644
--- a/deps/llvm.version
+++ b/deps/llvm.version
@@ -2,14 +2,14 @@
 
 ## jll artifact
 LLVM_JLL_NAME := libLLVM
-LLVM_ASSERT_JLL_VER := 15.0.7+9
+LLVM_ASSERT_JLL_VER := 15.0.7+10
 ## source build
 # Version number of LLVM
 LLVM_VER := 15.0.7
 # Git branch name in `LLVM_GIT_URL` repository
-LLVM_BRANCH=julia-15.0.7-9
+LLVM_BRANCH=julia-15.0.7-10
 # Git ref in `LLVM_GIT_URL` repository
-LLVM_SHA1=julia-15.0.7-9
+LLVM_SHA1=julia-15.0.7-10
 
 ## Following options are used to automatically fetch patchset from Julia's fork.  This is
 ## useful if you want to build an external LLVM while still applying Julia's patches.
diff --git a/stdlib/LLD_jll/Project.toml b/stdlib/LLD_jll/Project.toml
index 30d0c6625a28e..454da0a0b221b 100644
--- a/stdlib/LLD_jll/Project.toml
+++ b/stdlib/LLD_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LLD_jll"
 uuid = "d55e3150-da41-5e91-b323-ecfd1eec6109"
-version = "15.0.7+9"
+version = "15.0.7+10"
 
 [deps]
 Zlib_jll = "83775a58-1f1d-513f-b197-d71354ab007a"
diff --git a/stdlib/libLLVM_jll/Project.toml b/stdlib/libLLVM_jll/Project.toml
index a8e628438e170..92867293c3116 100644
--- a/stdlib/libLLVM_jll/Project.toml
+++ b/stdlib/libLLVM_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "libLLVM_jll"
 uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
-version = "15.0.7+9"
+version = "15.0.7+10"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 79de5f3caa4b013f089bd668ea7125c3ab9f39f2 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 7 Dec 2023 21:56:52 +0530
Subject: [PATCH 0394/1315] Declare some LinearAlgebra types and functions to
 be public (#52420)

---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index e18edf88f8c9e..10cc9a2f3459a 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -166,8 +166,12 @@ export
 
 # not exported, but public names
 public AbstractTriangular,
+        Givens,
+        checksquare,
         hermitian,
         hermitian_type,
+        isbanded,
+        peakflops,
         symmetric,
         symmetric_type
 

From 0ba01570e9902a2236d7ba17d1b96cc97a149f8e Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 7 Dec 2023 09:06:31 -0800
Subject: [PATCH 0395/1315] sroa: Lift restriction that all_same optimization
 must give SSAValue (#52338)

This restriction has been in there since this code was added in #44557.
Unfortunately, I can't tell from the commit history why this restriction
was added. It's possible that it was trying to avoid putting things into
statement position that were not allowed in the phi block, but we have
cleaned that up since (#50308 and related), so let's see if this
restriction is still required, since I was seeing some suboptimial
optimization results because of this.

---------

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
---
 base/compiler/ssair/inlining.jl |   2 +-
 base/compiler/ssair/ir.jl       |  66 ++++++---
 base/compiler/ssair/passes.jl   | 242 +++++++++++++++++++-------------
 test/compiler/irpasses.jl       |  39 +++++
 4 files changed, 237 insertions(+), 112 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 326a4094e4134..3792027f82aa4 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1918,7 +1918,7 @@ function ssa_substitute_op!(insert_node!::Inserter, subst_inst::Instruction, @no
             end
         end
     end
-    isa(val, Union{SSAValue, NewSSAValue}) && return val # avoid infinite loop
+    isa(val, AnySSAValue) && return val # avoid infinite loop
     urs = userefs(val)
     for op in urs
         op[] = ssa_substitute_op!(insert_node!, subst_inst, op[], ssa_substitute)
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 9cdd127473c6d..6a1114a009519 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -464,7 +464,7 @@ struct UndefToken end; const UNDEF_TOKEN = UndefToken()
         isdefined(stmt, :val) || return OOB_TOKEN
         op == 1 || return OOB_TOKEN
         return stmt.val
-    elseif isa(stmt, Union{SSAValue, NewSSAValue, GlobalRef})
+    elseif isa(stmt, Union{AnySSAValue, GlobalRef})
         op == 1 || return OOB_TOKEN
         return stmt
     elseif isa(stmt, UpsilonNode)
@@ -520,7 +520,7 @@ end
     elseif isa(stmt, ReturnNode)
         op == 1 || throw(BoundsError())
         stmt = typeof(stmt)(v)
-    elseif isa(stmt, Union{SSAValue, NewSSAValue, GlobalRef})
+    elseif isa(stmt, Union{AnySSAValue, GlobalRef})
         op == 1 || throw(BoundsError())
         stmt = v
     elseif isa(stmt, UpsilonNode)
@@ -550,7 +550,7 @@ end
 
 function userefs(@nospecialize(x))
     relevant = (isa(x, Expr) && is_relevant_expr(x)) ||
-        isa(x, GotoIfNot) || isa(x, ReturnNode) || isa(x, SSAValue) || isa(x, NewSSAValue) ||
+        isa(x, GotoIfNot) || isa(x, ReturnNode) || isa(x, SSAValue) || isa(x, OldSSAValue) || isa(x, NewSSAValue) ||
         isa(x, PiNode) || isa(x, PhiNode) || isa(x, PhiCNode) || isa(x, UpsilonNode) || isa(x, EnterNode)
     return UseRefIterator(x, relevant)
 end
@@ -781,6 +781,16 @@ function dominates_ssa(compact::IncrementalCompact, domtree::DomTree, x::AnySSAV
     xb = block_for_inst(compact, x)
     yb = block_for_inst(compact, y)
     if xb == yb
+        if isa(compact[x][:stmt], PhiNode)
+            if isa(compact[y][:stmt], PhiNode)
+                # A node dominates another only if it dominates all uses of that note.
+                # Usually that is not a distinction. However, for phi nodes, the use
+                # occurs on the edge to the predecessor block. Thus, by definition, for
+                # any other PhiNode in the same BB there must be (at least) one edge
+                # that this phi node does not dominate.
+                return false
+            end
+        end
         xinfo = yinfo = nothing
         if isa(x, OldSSAValue)
             x′ = compact.ssa_rename[x.id]::SSAValue
@@ -939,17 +949,23 @@ function insert_node!(compact::IncrementalCompact, @nospecialize(before), newins
     end
 end
 
+function maybe_reopen_bb!(compact)
+    result_idx = compact.result_idx
+    result_bbs = compact.cfg_transform.result_bbs
+    if (compact.active_result_bb == length(result_bbs) + 1) ||
+        result_idx == first(result_bbs[compact.active_result_bb].stmts)
+        compact.active_result_bb -= 1
+        return true
+    end
+    return false
+end
+
 function insert_node_here!(compact::IncrementalCompact, newinst::NewInstruction, reverse_affinity::Bool=false)
     newline = newinst.line::Int32
     refinish = false
     result_idx = compact.result_idx
     result_bbs = compact.cfg_transform.result_bbs
-    if reverse_affinity &&
-            ((compact.active_result_bb == length(result_bbs) + 1) ||
-             result_idx == first(result_bbs[compact.active_result_bb].stmts))
-        compact.active_result_bb -= 1
-        refinish = true
-    end
+    refinish = reverse_affinity && maybe_reopen_bb!(compact)
     if result_idx > length(compact.result)
         @assert result_idx == length(compact.result) + 1
         resize!(compact, result_idx)
@@ -964,10 +980,17 @@ function insert_node_here!(compact::IncrementalCompact, newinst::NewInstruction,
 end
 
 function delete_inst_here!(compact::IncrementalCompact)
+    # If we already closed this bb, reopen it for our modification
+    refinish = maybe_reopen_bb!(compact)
+
     # Delete the statement, update refcounts etc
     compact[SSAValue(compact.result_idx-1)] = nothing
+
     # Pretend that we never compacted this statement in the first place
     compact.result_idx -= 1
+
+    refinish && finish_current_bb!(compact, 0)
+
     return nothing
 end
 
@@ -1169,13 +1192,15 @@ function process_phinode_values(old_values::Vector{Any}, late_fixup::Vector{Int}
             end
         elseif isa(val, NewSSAValue)
             if val.id < 0
-                push!(late_fixup, result_idx)
                 new_new_used_ssas[-val.id] += 1
             else
                 @assert do_rename_ssa
                 val = SSAValue(val.id)
             end
         end
+        if isa(val, NewSSAValue)
+            push!(late_fixup, result_idx)
+        end
         values[i] = val
     end
     return values
@@ -1196,6 +1221,9 @@ function renumber_ssa2(val::SSAValue, ssanums::Vector{Any}, used_ssas::Vector{In
     end
     if isa(val, SSAValue)
         used_ssas[val.id] += 1
+    elseif isa(val, NewSSAValue)
+        @assert val.id < 0
+        new_new_used_ssas[-val.id] += 1
     end
     return val
 end
@@ -1834,14 +1862,20 @@ function fixup_node(compact::IncrementalCompact, @nospecialize(stmt), reify_new_
             return FixedNode(stmt, true)
         end
     elseif isa(stmt, OldSSAValue)
-        val = compact.ssa_rename[stmt.id]
-        if isa(val, Refined)
-            val = val.val
+        node = compact.ssa_rename[stmt.id]
+        if isa(node, Refined)
+            node = node.val
         end
-        if isa(val, SSAValue)
-            compact.used_ssas[val.id] += 1
+        needs_fixup = false
+        if isa(node, NewSSAValue)
+            (;node, needs_fixup) = fixup_node(compact, node, reify_new_nodes)
+        end
+        if isa(node, SSAValue)
+            compact.used_ssas[node.id] += 1
+        elseif isa(node, NewSSAValue)
+            compact.new_new_used_ssas[-node.id] += 1
         end
-        return FixedNode(val, false)
+        return FixedNode(node, needs_fixup)
     else
         urs = userefs(stmt)
         fixup = false
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 944e444bf6d06..424ab23b5a28a 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -473,9 +473,14 @@ function lift_arg!(
     if is_old(compact, leaf) && isa(lifted, SSAValue)
         lifted = OldSSAValue(lifted.id)
         if already_inserted(compact, lifted)
-            lifted = compact.ssa_rename[lifted.id]
-            if isa(lifted, Refined)
-                lifted = lifted.val
+            new_lifted = compact.ssa_rename[lifted.id]
+            if isa(new_lifted, Refined)
+                new_lifted = new_lifted.val
+            end
+            # Special case: If lifted happens to be the statement we're currently processing,
+            # leave it as old SSAValue in case we decide to handle this in the renamer
+            if !isa(new_lifted, SSAValue) || new_lifted != SSAValue(compact.result_idx-1)
+                lifted = new_lifted
             end
         end
     end
@@ -602,10 +607,12 @@ function lift_comparison_leaves!(@specialize(tfunc),
     end
 
     # perform lifting
-    lifted_val = perform_lifting!(compact,
-        visited_philikes, cmp, Bool, lifted_leaves::LiftedLeaves, val, nothing)::LiftedValue
+    (lifted_val, nest) = perform_lifting!(compact,
+        visited_philikes, cmp, Bool, lifted_leaves::LiftedLeaves, val, nothing)
+
+    compact[idx] = (lifted_val::LiftedValue).val
 
-    compact[idx] = lifted_val.val
+    finish_phi_nest!(compact, nest)
 end
 
 struct IfElseCall
@@ -651,80 +658,22 @@ function lifted_value(compact::IncrementalCompact, @nospecialize(old_node_ssa#=:
 end
 
 function is_old(compact, @nospecialize(old_node_ssa))
-    isa(old_node_ssa, OldSSAValue) &&
-        !is_pending(compact, old_node_ssa) &&
-        !already_inserted(compact, old_node_ssa)
+    isa(old_node_ssa, OldSSAValue) || return false
+    is_pending(compact, old_node_ssa) && return false
+    already_inserted(compact, old_node_ssa) && return false
+    return true
 end
 
-function perform_lifting!(compact::IncrementalCompact,
-        visited_philikes::Vector{AnySSAValue}, @nospecialize(cache_key),
-        @nospecialize(result_t), lifted_leaves::Union{LiftedLeaves, LiftedDefs}, @nospecialize(stmt_val),
-        lazydomtree::Union{LazyDomtree,Nothing})
-    reverse_mapping = IdDict{AnySSAValue, Int}()
-    for id in 1:length(visited_philikes)
-        reverse_mapping[visited_philikes[id]] = id
-    end
-
-    # Check if all the lifted leaves are the same
-    local the_leaf
-    all_same = true
-    for (_, val) in lifted_leaves
-        if !@isdefined(the_leaf)
-            the_leaf = val
-            continue
-        end
-        if val !== the_leaf
-            all_same = false
-        end
-    end
-
-    the_leaf_val = isa(the_leaf, LiftedValue) ? the_leaf.val : nothing
-    if !isa(the_leaf_val, SSAValue)
-        all_same = false
-    end
-
-    if all_same
-        dominates_all = true
-        if lazydomtree !== nothing
-            domtree = get!(lazydomtree)
-            for item in visited_philikes
-                if !dominates_ssa(compact, domtree, the_leaf_val, item)
-                    dominates_all = false
-                    break
-                end
-            end
-            if dominates_all
-                return the_leaf
-            end
-        end
-    end
-
-    # Insert PhiNodes
-    nphilikes = length(visited_philikes)
-    lifted_philikes = Vector{LiftedPhilike}(undef, nphilikes)
-    for i = 1:nphilikes
-        old_ssa = visited_philikes[i]
-        old_inst = compact[old_ssa]
-        old_node = old_inst[:stmt]::Union{PhiNode,Expr}
-        if isa(old_node, PhiNode)
-            new_node = PhiNode()
-            ssa = insert_node!(compact, old_ssa, effect_free_and_nothrow(NewInstruction(new_node, result_t)))
-            lifted_philikes[i] = LiftedPhilike(ssa, new_node, true)
-        else
-            @assert is_known_call(old_node, Core.ifelse, compact)
-            ifelse_func, condition = old_node.args
-            if is_old(compact, old_ssa) && isa(condition, SSAValue)
-                condition = OldSSAValue(condition.id)
-            end
-
-            new_node = Expr(:call, ifelse_func, condition) # Renamed then_result, else_result added below
-            new_inst = NewInstruction(new_node, result_t, NoCallInfo(), old_inst[:line], old_inst[:flag])
-
-            ssa = insert_node!(compact, old_ssa, new_inst, #= attach_after =# true)
-            lifted_philikes[i] = LiftedPhilike(ssa, IfElseCall(new_node), true)
-        end
-    end
+struct PhiNest
+    visited_philikes::Vector{AnySSAValue}
+    lifted_philikes::Vector{LiftedPhilike}
+    lifted_leaves::Union{LiftedLeaves, LiftedDefs}
+    reverse_mapping::IdDict{AnySSAValue, Int}
+end
 
+function finish_phi_nest!(compact::IncrementalCompact, nest::PhiNest)
+    (;visited_philikes, lifted_philikes, lifted_leaves, reverse_mapping) = nest
+    nphilikes = length(lifted_philikes)
     # Fix up arguments
     for i = 1:nphilikes
         (old_node_ssa, lf) = visited_philikes[i], lifted_philikes[i]
@@ -782,6 +731,91 @@ function perform_lifting!(compact::IncrementalCompact,
             push!(lfnode.call.args, else_result)
         end
     end
+end
+
+function perform_lifting!(compact::IncrementalCompact,
+        visited_philikes::Vector{AnySSAValue}, @nospecialize(cache_key),
+        @nospecialize(result_t), lifted_leaves::Union{LiftedLeaves, LiftedDefs}, @nospecialize(stmt_val),
+        lazydomtree::Union{LazyDomtree,Nothing})
+    reverse_mapping = IdDict{AnySSAValue, Int}()
+    for id in 1:length(visited_philikes)
+        reverse_mapping[visited_philikes[id]] = id
+    end
+
+    # Check if all the lifted leaves are the same
+    local the_leaf
+    all_same = true
+    for (_, val) in lifted_leaves
+        if !@isdefined(the_leaf)
+            the_leaf = val
+            continue
+        end
+        if val !== the_leaf
+            all_same = false
+        end
+    end
+
+    if all_same && isa(the_leaf, LiftedValue)
+        dominates_all = true
+        the_leaf_val = the_leaf.val
+        if isa(the_leaf_val, AnySSAValue)
+            if lazydomtree === nothing
+                # Must conservatively assume this
+                dominates_all = false
+            else
+                # This code guards against the possibility of accidentally forwarding a value from a
+                # previous iteration. Consider for example:
+                #
+                # %p = phi(%arg, %t)
+                # %b = <...>
+                # %c = getfield(%p, 1)
+                # %t = tuple(%b)
+                #
+                # It would be incorrect to replace `%c` by `%b`, because that would read the value of
+                # `%b` in the *current* iteration, while the value of `%b` that comes in via `%p` is
+                # that of the previous iteration.
+                domtree = get!(lazydomtree)
+                for item in visited_philikes
+                    if !dominates_ssa(compact, domtree, the_leaf_val, item)
+                        dominates_all = false
+                        break
+                    end
+                end
+            end
+        end
+        if dominates_all
+            if isa(the_leaf, OldSSAValue)
+                the_leaf = simple_walk(compact, the_leaf)
+            end
+            return Pair{Any, PhiNest}(the_leaf, PhiNest(visited_philikes, Vector{LiftedPhilike}(undef, 0), lifted_leaves, reverse_mapping))
+        end
+    end
+
+    # Insert PhiNodes
+    nphilikes = length(visited_philikes)
+    lifted_philikes = Vector{LiftedPhilike}(undef, nphilikes)
+    for i = 1:nphilikes
+        old_ssa = visited_philikes[i]
+        old_inst = compact[old_ssa]
+        old_node = old_inst[:stmt]::Union{PhiNode,Expr}
+        if isa(old_node, PhiNode)
+            new_node = PhiNode()
+            ssa = insert_node!(compact, old_ssa, effect_free_and_nothrow(NewInstruction(new_node, result_t)))
+            lifted_philikes[i] = LiftedPhilike(ssa, new_node, true)
+        else
+            @assert is_known_call(old_node, Core.ifelse, compact)
+            ifelse_func, condition = old_node.args
+            if is_old(compact, old_ssa) && isa(condition, SSAValue)
+                condition = OldSSAValue(condition.id)
+            end
+
+            new_node = Expr(:call, ifelse_func, condition) # Renamed then_result, else_result added below
+            new_inst = NewInstruction(new_node, result_t, NoCallInfo(), old_inst[:line], old_inst[:flag])
+
+            ssa = insert_node!(compact, old_ssa, new_inst, #= attach_after =# true)
+            lifted_philikes[i] = LiftedPhilike(ssa, IfElseCall(new_node), true)
+        end
+    end
 
     # Fixup the stmt itself
     if isa(stmt_val, Union{SSAValue, OldSSAValue})
@@ -789,12 +823,12 @@ function perform_lifting!(compact::IncrementalCompact,
     end
 
     if stmt_val in keys(lifted_leaves)
-        return lifted_leaves[stmt_val]
+        stmt_val = lifted_leaves[stmt_val]
     elseif isa(stmt_val, AnySSAValue) && stmt_val in keys(reverse_mapping)
-        return LiftedValue(lifted_philikes[reverse_mapping[stmt_val]].ssa)
+        stmt_val = LiftedValue(lifted_philikes[reverse_mapping[stmt_val]].ssa)
     end
 
-    return stmt_val # N.B. should never happen
+    return Pair{Any, PhiNest}(stmt_val, PhiNest(visited_philikes, lifted_philikes, lifted_leaves, reverse_mapping))
 end
 
 function lift_svec_ref!(compact::IncrementalCompact, idx::Int, stmt::Expr)
@@ -882,10 +916,11 @@ function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 
         result_t = tmerge(𝕃ₒ, result_t, argextype(v.val, compact))
     end
 
-    lifted_val = perform_lifting!(compact,
+    (lifted_val, nest) = perform_lifting!(compact,
         visited_philikes, key, result_t, lifted_leaves, collection, nothing)
 
     compact[idx] = lifted_val === nothing ? nothing : Expr(:call, Core.tuple, lifted_val.val)
+    finish_phi_nest!(compact, nest)
     if lifted_val !== nothing
         if !⊑(𝕃ₒ, compact[SSAValue(idx)][:type], result_t)
             compact[SSAValue(idx)][:flag] |= IR_FLAG_REFINED
@@ -1077,7 +1112,7 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
     defuses = nothing # will be initialized once we encounter mutability in order to reduce dynamic allocations
     # initialization of domtree is delayed to avoid the expensive computation in many cases
     lazydomtree = LazyDomtree(ir)
-    for ((_, idx), stmt) in compact
+    for ((old_idx, idx), stmt) in compact
         # check whether this statement is `getfield` / `setfield!` (or other "interesting" statement)
         isa(stmt, Expr) || continue
         is_setfield = is_isdefined = is_finalizer = is_keyvalue_get = false
@@ -1248,9 +1283,27 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
             result_t = tmerge(𝕃ₒ, result_t, argextype(v.val, compact))
         end
 
-        lifted_val = perform_lifting!(compact,
+        (lifted_val, nest) = perform_lifting!(compact,
             visited_philikes, field, result_t, lifted_leaves, val, lazydomtree)
 
+        node_was_deleted = false
+        line = compact[SSAValue(idx)][:line]
+        if lifted_val !== nothing && !⊑(𝕃ₒ, compact[SSAValue(idx)][:type], result_t)
+            compact[idx] = lifted_val === nothing ? nothing : lifted_val.val
+            add_flag!(compact[SSAValue(idx)], IR_FLAG_REFINED)
+        elseif lifted_val === nothing || isa(lifted_val.val, AnySSAValue)
+            # Save some work in a later compaction, by inserting this into the renamer now,
+            # but only do this if we didn't set the REFINED flag, to save work for irinterp
+            # in revisiting only the renamings that came through *this* idx.
+            delete_inst_here!(compact)
+            compact.ssa_rename[old_idx] = lifted_val === nothing ? nothing : lifted_val.val
+            node_was_deleted = true
+        else
+            compact[idx] = lifted_val === nothing ? nothing : lifted_val.val
+        end
+
+        finish_phi_nest!(compact, nest)
+
         # Insert the undef check if necessary
         if any_undef
             if lifted_val === nothing
@@ -1260,23 +1313,22 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
                 for (k, v) in pairs(lifted_leaves)
                     lifted_leaves_def[k] = v === nothing ? false : true
                 end
-                def_val = perform_lifting!(compact,
-                    visited_philikes, field, Bool, lifted_leaves_def, val, lazydomtree).val
+                (def_val, nest) = perform_lifting!(compact,
+                    visited_philikes, field, Bool, lifted_leaves_def, val, lazydomtree)
+                def_val = (def_val::LiftedValue).val
+                finish_phi_nest!(compact, nest)
+            end
+            ni = NewInstruction(
+                Expr(:throw_undef_if_not, Symbol("##getfield##"), def_val), Nothing, line)
+            if node_was_deleted
+                insert_node_here!(compact, ni, true)
+            else
+                insert_node!(compact, SSAValue(idx), ni)
             end
-            insert_node!(compact, SSAValue(idx), NewInstruction(
-                Expr(:throw_undef_if_not, Symbol("##getfield##"), def_val), Nothing))
-
         else
             # val must be defined
             @assert lifted_val !== nothing
         end
-
-        compact[idx] = lifted_val === nothing ? nothing : lifted_val.val
-        if lifted_val !== nothing
-            if !⊑(𝕃ₒ, compact[SSAValue(idx)][:type], result_t)
-                add_flag!(compact[SSAValue(idx)], IR_FLAG_REFINED)
-            end
-        end
     end
 
     non_dce_finish!(compact)
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 8dbae2dca9649..17bc9a5beef52 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1615,3 +1615,42 @@ let code = Any[
         Core.Compiler.__set_check_ssa_counts(false)
     end
 end
+
+# Test SROA all_same on NewNode
+let code = Any[
+    # Block 1
+    Expr(:call, tuple, Argument(1)),
+    GotoIfNot(Argument(4), 5),
+    # Block 2
+    Expr(:call, tuple, Argument(2)),
+    GotoIfNot(Argument(4), 9),
+    # Block 3
+    PhiNode(Int32[2, 4], Any[SSAValue(1), SSAValue(3)]),
+    Expr(:call, getfield, SSAValue(5), 1),
+    Expr(:call, tuple, SSAValue(6), Argument(2)), # ::Tuple{Int, Int}
+    Expr(:call, tuple, SSAValue(7), Argument(3)), # ::Tuple{Tuple{Int, Int}, Int}
+    # Block 4
+    PhiNode(Int32[4, 8], Any[nothing, SSAValue(8)]),
+    Expr(:call, Core.Intrinsics.not_int, Argument(4)),
+    GotoIfNot(SSAValue(10), 13),
+    # Block 5
+    ReturnNode(1),
+    # Block 6
+    PiNode(SSAValue(9), Tuple{Tuple{Int, Int}, Int}),
+    Expr(:call, getfield, SSAValue(13), 1),
+    Expr(:call, getfield, SSAValue(14), 1),
+    ReturnNode(SSAValue(15))
+]
+
+    argtypes = Any[Int, Int, Int, Bool]
+    ssavaluetypes = Any[Tuple{Int}, Any, Tuple{Int}, Any, Tuple{Int}, Int, Tuple{Int, Int}, Tuple{Tuple{Int, Int}, Int},
+                        Union{Nothing, Tuple{Tuple{Int, Int}, Int}}, Bool, Any, Any,
+                        Tuple{Tuple{Int, Int}, Int},
+                        Tuple{Int, Int}, Int, Any]
+    ir = make_ircode(code; slottypes=argtypes, ssavaluetypes)
+    Core.Compiler.verify_ir(ir)
+    ir = Core.Compiler.sroa_pass!(ir)
+    Core.Compiler.verify_ir(ir)
+    ir = Core.Compiler.compact!(ir)
+    Core.Compiler.verify_ir(ir)
+end

From 46ad1c12885c8a689ae7d85618d813df9997375a Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 7 Dec 2023 13:17:03 -0500
Subject: [PATCH 0396/1315] support if cache has a mixture of depot and
 non-depot includes (#52346)

---
 base/loading.jl | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 95b83e84aad15..212e26bec7d01 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2660,13 +2660,15 @@ end
 # Find depot in DEPOT_PATH for which all @depot tags from the `includes`
 # can be replaced so that they point to a file on disk each.
 function resolve_depot(includes::Union{AbstractVector,AbstractSet})
-    if any(includes) do inc
+    # `all` because it's possible to have a mixture of includes inside and outside of the depot
+    if all(includes) do inc
             !startswith(inc, "@depot")
         end
-        return :missing_depot_tag
+        return :fully_outside_depot
     end
     for depot in DEPOT_PATH
-        if all(includes) do inc
+        # `any` because it's possible to have a mixture of includes inside and outside of the depot
+        if any(includes) do inc
                 isfile(restore_depot_path(inc, depot))
             end
             return depot
@@ -2767,8 +2769,8 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
     end
     if depot === :no_depot_found
         @debug("Unable to resolve @depot tag in cache file $cachefile", srcfiles)
-    elseif depot === :missing_depot_tag
-        @debug("Missing @depot tag for include dependencies in cache file $cachefile.", srcfiles)
+    elseif depot === :fully_outside_depot
+        @debug("All include dependencies in cache file $cachefile are outside of a depot.", srcfiles)
     else
         for inc in includes
             inc.filename = restore_depot_path(inc.filename, depot)

From 710bf900ac8cd00148149aa08aecc004cd37fedd Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Thu, 7 Dec 2023 21:52:39 +0100
Subject: [PATCH 0397/1315] Make type hashing `:total` (#52427)

Since types can't really be deleted and the hash of a type is already
being cached inside of the type object itself, it should be legal to
mark the `ccall` retrieving that hash as `:total`, permitting hashing of
types to be concretely evaluated.

I'm unsure if the test I've added is good as written, or whether this
should be done differently.

---------

Co-authored-by: Sukera <Seelengrab@users.noreply.github.com>
Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 base/hashing.jl | 4 +++-
 test/hashing.jl | 2 ++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/base/hashing.jl b/base/hashing.jl
index 5dbae09123bd6..7de9f47de3182 100644
--- a/base/hashing.jl
+++ b/base/hashing.jl
@@ -29,7 +29,9 @@ See also: [`objectid`](@ref), [`Dict`](@ref), [`Set`](@ref).
 """
 hash(x::Any) = hash(x, zero(UInt))
 hash(w::WeakRef, h::UInt) = hash(w.value, h)
-hash(T::Type, h::UInt) = hash_uint(3h - ccall(:jl_type_hash, UInt, (Any,), T))
+
+# Types can't be deleted, so marking as total allows the compiler to look up the hash
+hash(T::Type, h::UInt) = hash_uint(3h - @assume_effects :total ccall(:jl_type_hash, UInt, (Any,), T))
 
 ## hashing general objects ##
 
diff --git a/test/hashing.jl b/test/hashing.jl
index 7c3024640aa32..173a31d10a6a9 100644
--- a/test/hashing.jl
+++ b/test/hashing.jl
@@ -302,3 +302,5 @@ struct AUnionParam{T<:Union{Nothing,Float32,Float64}} end
     # test hashing of rational with odd denominator
     @test hash(5//3) == hash(big(5)//3)
 end
+
+@test Core.Compiler.is_foldable_nothrow(Base.infer_effects(hash, Tuple{Type{Int}, UInt}))

From 727142a0b983d1df17b681920409730d6b20bff5 Mon Sep 17 00:00:00 2001
From: mikmoore <95002244+mikmoore@users.noreply.github.com>
Date: Thu, 7 Dec 2023 14:02:06 -0700
Subject: [PATCH 0398/1315] Specialize eps(::IEEEFloat) (#52087)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`eps(::IEEEFloat)` can be made notably faster. I doubt this function
appears in performance-critical places, but better is better and this
new version is branch-free.

```julia-repl
julia> using BenchmarkTools

julia> x = randn(2^10);

julia> @btime map(eps,$x); # v1.9.1
  2.067 μs (1 allocation: 8.12 KiB)

julia> @btime map(eps,$x); # this PR
  613.095 ns (1 allocation: 8.12 KiB)
```

A couple probably-negligible caveats that arise from the use of floating
point arithmetic in this implementation:
- The previous version always returned Julia's canonical `NaN` when the
result would be NaN. In this PR, the NaN payload depends on the payload
behavior of the hardware and the input.
- The result is vulnerable to flush-to-zero floating point environments,
in which case subnormal results will be flushed to `zero(T)`. The
usability of a subnormal result amidst flushing mode is questionable, as
is the well-posed-ness of `eps`'s semantics in such a situation. *Note
that the existing implementation has this same vulnerability (due to
`ldexp`), though only when the input to `eps` is normal and the result
would be subnormal (only with an input of zero or a subnormal is a
correct subnormal output produced, assuming the flushing occurs during
arithmetic but not storage).*

Canonicalizing `NaN` would require a simple `ifelse` switch on the
result, though I can't imagine we care. Guaranteeing a proper subnormal
result in flush-to-zero mode may be more challenging (and may warrant a
branch) and is only handled slightly more correctly by the preexisting
implementation. I imagine that flushing breaks a lot more functions than
just this one, anyway.

---------

Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
---
 base/float.jl | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/base/float.jl b/base/float.jl
index 3e6e39c5951d8..d26d279e47895 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -1014,13 +1014,24 @@ isodd(x::AbstractFloat) = isinteger(x) && abs(x) ≤ maxintfloat(x) && isodd(Int
     floatmax(::Type{Float32}) = $(bitcast(Float32, 0x7f7fffff))
     floatmax(::Type{Float64}) = $(bitcast(Float64, 0x7fefffffffffffff))
 
-    eps(x::AbstractFloat) = isfinite(x) ? abs(x) >= floatmin(x) ? ldexp(eps(typeof(x)), exponent(x)) : nextfloat(zero(x)) : oftype(x, NaN)
     eps(::Type{Float16}) = $(bitcast(Float16, 0x1400))
     eps(::Type{Float32}) = $(bitcast(Float32, 0x34000000))
     eps(::Type{Float64}) = $(bitcast(Float64, 0x3cb0000000000000))
     eps() = eps(Float64)
 end
 
+eps(x::AbstractFloat) = isfinite(x) ? abs(x) >= floatmin(x) ? ldexp(eps(typeof(x)), exponent(x)) : nextfloat(zero(x)) : oftype(x, NaN)
+
+function eps(x::T) where T<:IEEEFloat
+    # For isfinite(x), toggling the LSB will produce either prevfloat(x) or
+    # nextfloat(x) but will never change the sign or exponent.
+    # For !isfinite(x), this will map Inf to NaN and NaN to NaN or Inf.
+    y = reinterpret(T, reinterpret(Unsigned, x) ⊻ true)
+    # The absolute difference between these values is eps(x). This is true even
+    # for Inf/NaN values.
+    return abs(x - y)
+end
+
 """
     floatmin(T = Float64)
 

From 1e20c9c48facb670d615d8343daa37c0fa5d0bbc Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 7 Dec 2023 17:02:18 -0800
Subject: [PATCH 0399/1315] sroa: Handle looking through chains of KeyValue
 instances (#52369)

Addresses an outstanding todo from the KeyValue PR and allows (once all
the PRs are merged), optimization when multiple ScopedValues are used
`with(a=>1, b=>2)`, etc. To facilitate this, in addition to the sroa
adjustment, the ScopedValue code is adjusted to unroll the
PersistentDict creation so that the optimizer can see the full chain (we
do not support loops in the optimizer).
---
 base/compiler/ssair/passes.jl | 60 ++++++++++++++++++-----------------
 base/scopedvalues.jl          | 13 +++++---
 test/compiler/irpasses.jl     |  9 ++++++
 3 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 424ab23b5a28a..b8dd5d1271f3a 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -866,36 +866,38 @@ function lift_leaves_keyvalue(compact::IncrementalCompact, @nospecialize(key),
     for i = 1:length(leaves)
         leaf = leaves[i]
         cache_key = leaf
-        if isa(leaf, AnySSAValue)
-            (def, leaf) = walk_to_def(compact, leaf)
-            if is_known_invoke_or_call(def, Core.OptimizedGenerics.KeyValue.set, compact)
-                @assert isexpr(def, :invoke)
-                if length(def.args) in (5, 6)
-                    collection = def.args[end-2]
-                    set_key = def.args[end-1]
-                    set_val_idx = length(def.args)
-                elseif length(def.args) == 4
-                    collection = def.args[end-1]
-                    # Key is deleted
-                    # TODO: Model this
-                    return nothing
-                elseif length(def.args) == 3
-                    collection = def.args[end]
-                    # The whole collection is deleted
-                    # TODO: Model this
-                    return nothing
-                else
-                    return nothing
-                end
-                if set_key === key || (egal_tfunc(𝕃ₒ, argextype(key, compact), argextype(set_key, compact)) == Const(true))
-                    lift_arg!(compact, leaf, cache_key, def, set_val_idx, lifted_leaves)
+        while true
+            if isa(leaf, AnySSAValue)
+                (def, leaf) = walk_to_def(compact, leaf)
+                if is_known_invoke_or_call(def, Core.OptimizedGenerics.KeyValue.set, compact)
+                    @assert isexpr(def, :invoke)
+                    if length(def.args) in (5, 6)
+                        collection = def.args[end-2]
+                        set_key = def.args[end-1]
+                        set_val_idx = length(def.args)
+                    elseif length(def.args) == 4
+                        collection = def.args[end-1]
+                        # Key is deleted
+                        # TODO: Model this
+                        return nothing
+                    elseif length(def.args) == 3
+                        collection = def.args[end]
+                        # The whole collection is deleted
+                        # TODO: Model this
+                        return nothing
+                    else
+                        return nothing
+                    end
+                    if set_key === key || (egal_tfunc(𝕃ₒ, argextype(key, compact), argextype(set_key, compact)) == Const(true))
+                        lift_arg!(compact, leaf, cache_key, def, set_val_idx, lifted_leaves)
+                        break
+                    end
+                    leaf = collection
                     continue
                 end
-                # TODO: Continue walking the chain
-                return nothing
             end
+            return nothing
         end
-        return nothing
     end
     return lifted_leaves
 end
@@ -919,11 +921,11 @@ function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 
     (lifted_val, nest) = perform_lifting!(compact,
         visited_philikes, key, result_t, lifted_leaves, collection, nothing)
 
-    compact[idx] = lifted_val === nothing ? nothing : Expr(:call, Core.tuple, lifted_val.val)
+    compact[idx] = lifted_val === nothing ? nothing : Expr(:call, GlobalRef(Core, :tuple), lifted_val.val)
     finish_phi_nest!(compact, nest)
     if lifted_val !== nothing
-        if !⊑(𝕃ₒ, compact[SSAValue(idx)][:type], result_t)
-            compact[SSAValue(idx)][:flag] |= IR_FLAG_REFINED
+        if !⊑(𝕃ₒ, compact[SSAValue(idx)][:type], tuple_tfunc(𝕃ₒ, Any[result_t]))
+            add_flag!(compact[SSAValue(idx)], IR_FLAG_REFINED)
         end
     end
 
diff --git a/base/scopedvalues.jl b/base/scopedvalues.jl
index 6e1cc4755d618..fd18e932d6a46 100644
--- a/base/scopedvalues.jl
+++ b/base/scopedvalues.jl
@@ -70,11 +70,14 @@ function Scope(parent::Union{Nothing, Scope}, key::ScopedValue{T}, value) where
     return Scope(ScopeStorage(parent.values, key=>val))
 end
 
-function Scope(scope, pairs::Pair{<:ScopedValue}...)
-    for pair in pairs
-        scope = Scope(scope, pair...)
-    end
-    return scope::Scope
+function Scope(scope, pair::Pair{<:ScopedValue})
+    return Scope(scope, pair...)
+end
+
+function Scope(scope, pair1::Pair{<:ScopedValue}, pair2::Pair{<:ScopedValue}, pairs::Pair{<:ScopedValue}...)
+    # Unroll this loop through recursion to make sure that
+    # our compiler optimization support works
+    return Scope(Scope(scope, pair1...), pair2, pairs...)
 end
 Scope(::Nothing) = nothing
 
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 17bc9a5beef52..8ef19589e2f4f 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1549,11 +1549,20 @@ function persistent_dict_elim()
     a = Base.PersistentDict(:a => 1)
     return a[:a]
 end
+
 # Ideally we would be able to fully eliminate this,
 # but currently this would require an extra round of constprop
 @test_broken fully_eliminated(persistent_dict_elim)
 @test code_typed(persistent_dict_elim)[1][1].code[end] == Core.ReturnNode(1)
 
+function persistent_dict_elim_multiple()
+    a = Base.PersistentDict(:a => 1)
+    b = Base.PersistentDict(a, :b => 2)
+    return b[:a]
+end
+@test_broken fully_eliminated(persistent_dict_elim_multiple)
+@test code_typed(persistent_dict_elim_multiple)[1][1].code[end] == Core.ReturnNode(1)
+
 # Test CFG simplify with try/catch blocks
 let code = Any[
         # Block 1

From 1f4b33aa59ead299254f636808b4dd0b6be6a9f3 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 7 Dec 2023 17:04:43 -0800
Subject: [PATCH 0400/1315] Rm outdated code to outline value-position
 GlobalRef/Expr (#52446)

Since this code was written, we have adjusted the semantics of IRCode to
disallow non-constant GlobalRefs or non-trivial Exprs in statement
position.
---
 base/compiler/ssair/passes.jl | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index b8dd5d1271f3a..5abed1a182048 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -484,15 +484,6 @@ function lift_arg!(
             end
         end
     end
-    if isa(lifted, GlobalRef) || isa(lifted, Expr)
-        lifted = insert_node!(compact, leaf, effect_free_and_nothrow(NewInstruction(lifted, argextype(lifted, compact))))
-        compact[leaf] = nothing
-        stmt.args[argidx] = lifted
-        compact[leaf] = stmt
-        if isa(leaf, SSAValue) && leaf.id < compact.result_idx
-            push!(compact.late_fixup, leaf.id)
-        end
-    end
     lifted_leaves[cache_key] = LiftedValue(lifted)
     return nothing
 end

From cfc4289d181def92dffb83b63e7bb4b0b74e63a6 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 8 Dec 2023 10:14:54 +0900
Subject: [PATCH 0401/1315] improve exception type inference for core math
 functions (#52254)

Continued from #52241.

This PR focuses on improving exception type inference for core math
functions by using new callsite `Base.@assume_effects` annnotation.
---
 base/array.jl            | 12 +++++-----
 base/math.jl             | 23 +++++++++++--------
 base/special/log.jl      | 36 ++++++++++++-----------------
 base/special/rem_pio2.jl | 19 +++++++---------
 test/math.jl             | 49 +++++++++++++++++++++++++++++++---------
 5 files changed, 81 insertions(+), 58 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index 23a1a59052147..be9f44625c06f 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -130,9 +130,9 @@ to tell the compiler that indexing operations within the applied expression are
 inbounds and do not need to taint `:consistent` and `:nothrow`.
 """
 macro _safeindex(ex)
-    return esc(_safeindex(__module__, ex))
+    return esc(_safeindex(ex))
 end
-function _safeindex(__module__, ex)
+function _safeindex(ex)
     isa(ex, Expr) || return ex
     if ex.head === :(=)
         lhs = ex.args[1]
@@ -141,16 +141,16 @@ function _safeindex(__module__, ex)
             xs = lhs.args[1]
             args = Vector{Any}(undef, length(lhs.args)-1)
             for i = 2:length(lhs.args)
-                args[i-1] = _safeindex(__module__, lhs.args[i])
+                args[i-1] = _safeindex(lhs.args[i])
             end
-            return Expr(:call, GlobalRef(__module__, :__safe_setindex!), xs, _safeindex(__module__, rhs), args...)
+            return Expr(:call, GlobalRef(@__MODULE__, :__safe_setindex!), xs, _safeindex(rhs), args...)
         end
     elseif ex.head === :ref # xs[i]
-        return Expr(:call, GlobalRef(__module__, :__safe_getindex), ex.args...)
+        return Expr(:call, GlobalRef(@__MODULE__, :__safe_getindex), ex.args...)
     end
     args = Vector{Any}(undef, length(ex.args))
     for i = 1:length(ex.args)
-        args[i] = _safeindex(__module__, ex.args[i])
+        args[i] = _safeindex(ex.args[i])
     end
     return Expr(ex.head, args...)
 end
diff --git a/base/math.jl b/base/math.jl
index 90b6e726f4f9e..ca2f064e49ee7 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -304,14 +304,19 @@ end
 
 # polynomial evaluation using compensated summation.
 # much more accurate, especially when lo can be combined with other rounding errors
-Base.@assume_effects :terminates_locally @inline function exthorner(x, p::Tuple)
-    hi, lo = p[end], zero(x)
-    for i in length(p)-1:-1:1
-        pi = getfield(p, i) # needed to prove consistency
-        prod, err = two_mul(hi,x)
-        hi = pi+prod
-        lo = fma(lo, x, prod - (hi - pi) + err)
-    end
+@inline function exthorner(x::T, p::Tuple{T,T,T}) where T<:Union{Float32,Float64}
+    hi, lo = p[lastindex(p)], zero(x)
+    hi, lo = _exthorner(2, x, p, hi, lo)
+    hi, lo = _exthorner(1, x, p, hi, lo)
+    return hi, lo
+end
+
+@inline function _exthorner(i::Int, x::T, p::Tuple{T,T,T}, hi::T, lo::T) where T<:Union{Float32,Float64}
+    i == 2 || i == 1 || error("unexpected index")
+    pi = p[i]
+    prod, err = two_mul(hi,x)
+    hi = pi+prod
+    lo = fma(lo, x, prod - (hi - pi) + err)
     return hi, lo
 end
 
@@ -1215,7 +1220,7 @@ end
 end
 
 @inline function pow_body(xu::UInt64, y::Float64)
-    logxhi,logxlo = Base.Math._log_ext(xu)
+    logxhi,logxlo = _log_ext(xu)
     xyhi, xylo = two_mul(logxhi,y)
     xylo = muladd(logxlo, y, xylo)
     hi = xyhi+xylo
diff --git a/base/special/log.jl b/base/special/log.jl
index 488f0c89d48e3..029394b7a63f1 100644
--- a/base/special/log.jl
+++ b/base/special/log.jl
@@ -155,14 +155,11 @@ logbU(::Type{Float64},::Val{10}) = 0.4342944819032518
 logbL(::Type{Float64},::Val{10}) = 1.098319650216765e-17
 
 # Procedure 1
-# XXX we want to mark :noub here so that this function can be concrete-folded,
-# because the effect analysis currently can't prove it in the presence of `@inbounds` or
-# `:boundscheck`, but still the access to `t_log_Float64` is really safe here
-Base.@assume_effects :consistent :noub @inline function log_proc1(y::Float64,mf::Float64,F::Float64,f::Float64,base=Val(:ℯ))
+@inline function log_proc1(y::Float64,mf::Float64,F::Float64,f::Float64,base=Val(:ℯ))
     jp = unsafe_trunc(Int,128.0*F)-127
 
     ## Steps 1 and 2
-    @inbounds hi,lo = t_log_Float64[jp]
+    Base.@assume_effects :nothrow :noub @inbounds hi,lo = t_log_Float64[jp]
     l_hi = mf* 0.6931471805601177 + hi
     l_lo = mf*-1.7239444525614835e-13 + lo
 
@@ -216,14 +213,11 @@ end
 end
 
 # Procedure 1
-# XXX we want to mark :noub here so that this function can be concrete-folded,
-# because the effect analysis currently can't prove it in the presence of `@inbounds` or
-# `:boundscheck`, but still the access to `t_log_Float32` is really safe here
-Base.@assume_effects :consistent :noub @inline function log_proc1(y::Float32,mf::Float32,F::Float32,f::Float32,base=Val(:ℯ))
+@inline function log_proc1(y::Float32,mf::Float32,F::Float32,f::Float32,base=Val(:ℯ))
     jp = unsafe_trunc(Int,128.0f0*F)-127
 
     ## Steps 1 and 2
-    @inbounds hi = t_log_Float32[jp]
+    Base.@assume_effects :nothrow :noub @inbounds hi = t_log_Float32[jp]
     l = mf*0.6931471805599453 + hi
 
     ## Step 3
@@ -267,7 +261,7 @@ end
 @noinline log(x::Float64)   = _log(x, Val(:ℯ), :log)
 @noinline log10(x::Float64) = _log(x, Val(10), :log10)
 
-@inline function _log(x::Float64, base, func)
+@inline function _log(x::Float64, base, func::Symbol)
     if x > 0.0
         x == Inf && return x
 
@@ -294,15 +288,15 @@ end
 
         return log_proc1(y,mf,F,f,base)
     elseif x == 0.0
-        -Inf
+        return -Inf
     elseif isnan(x)
-        NaN
+        return NaN
     else
         throw_complex_domainerror(func, x)
     end
 end
 
-@inline function _log(x::Float32, base, func)
+@inline function _log(x::Float32, base, func::Symbol)
     if x > 0f0
         x == Inf32 && return x
 
@@ -327,11 +321,11 @@ end
         F = (y + 65536.0f0) - 65536.0f0 # 0x1p-7*round(0x1p7*y)
         f = y-F
 
-        log_proc1(y,mf,F,f,base)
+        return log_proc1(y,mf,F,f,base)
     elseif x == 0f0
-        -Inf32
+        return -Inf32
     elseif isnan(x)
-        NaN32
+        return NaN32
     else
         throw_complex_domainerror(func, x)
     end
@@ -562,17 +556,17 @@ end
 # Adapted and modified from https://github.com/ARM-software/optimized-routines/blob/master/math/pow.c
 # Copyright (c) 2018-2020, Arm Limited. (which is also MIT licensed)
 # note that this isn't an exact translation as this version compacts the table to reduce cache pressure.
-function _log_ext(xu)
+function _log_ext(xu::UInt64)
     # x = 2^k z; where z is in range [0x1.69555p-1,0x1.69555p-0) and exact.
     # The range is split into N subintervals.
     # The ith subinterval contains z and c is near the center of the interval.
     tmp = reinterpret(Int64, xu - 0x3fe6955500000000) #0x1.69555p-1
-    i = (tmp >> 45) & 127
     z = reinterpret(Float64, xu - (tmp & 0xfff0000000000000))
     k = Float64(tmp >> 52)
     # log(x) = k*Ln2 + log(c) + log1p(z/c-1).
-    # getfield instead of getindex to satisfy effect analysis not knowing whether this is inbounds
-    t, logctail = getfield(t_log_table_compact, Int(i+1))
+    # N.B. :nothrow and :noub since `idx` is known to be `1 ≤ idx ≤ length(t_log_table_compact)`
+    idx = (tmp >> 45) & (length(t_log_table_compact)-1) + 1
+    t, logctail = Base.@assume_effects :nothrow :noub @inbounds t_log_table_compact[idx]
     invc, logc = log_tab_unpack(t)
     # Note: invc is j/N or j/N/2 where j is an integer in [N,2N) and
     # |z/c - 1| < 1/N, so r = z/c - 1 is exactly representable.
diff --git a/base/special/rem_pio2.jl b/base/special/rem_pio2.jl
index 3086f3ebc02c9..b0a17fdc25087 100644
--- a/base/special/rem_pio2.jl
+++ b/base/special/rem_pio2.jl
@@ -126,10 +126,7 @@ function fromfraction(f::Int128)
     return (z1,z2)
 end
 
-# XXX we want to mark :noub here so that this function can be concrete-folded,
-# because the effect analysis currently can't prove it in the presence of `@inbounds` or
-# `:boundscheck`, but still the accesses to `INV_2PI` are really safe here
-Base.@assume_effects :consistent :noub function paynehanek(x::Float64)
+function paynehanek(x::Float64)
     # 1. Convert to form
     #
     #    x = X * 2^k,
@@ -168,15 +165,15 @@ Base.@assume_effects :consistent :noub function paynehanek(x::Float64)
     idx = k >> 6
 
     shift = k - (idx << 6)
-    if shift == 0
-        @inbounds a1 = INV_2PI[idx+1]
-        @inbounds a2 = INV_2PI[idx+2]
-        @inbounds a3 = INV_2PI[idx+3]
+    Base.@assume_effects :nothrow :noub @inbounds if shift == 0
+        a1 = INV_2PI[idx+1]
+        a2 = INV_2PI[idx+2]
+        a3 = INV_2PI[idx+3]
     else
         # use shifts to extract the relevant 64 bit window
-        @inbounds a1 = (idx < 0 ? zero(UInt64) : INV_2PI[idx+1] << shift) | (INV_2PI[idx+2] >> (64 - shift))
-        @inbounds a2 = (INV_2PI[idx+2] << shift) | (INV_2PI[idx+3] >> (64 - shift))
-        @inbounds a3 = (INV_2PI[idx+3] << shift) | (INV_2PI[idx+4] >> (64 - shift))
+        a1 = (idx < 0 ? zero(UInt64) : INV_2PI[idx+1] << shift) | (INV_2PI[idx+2] >> (64 - shift))
+        a2 = (INV_2PI[idx+2] << shift) | (INV_2PI[idx+3] >> (64 - shift))
+        a3 = (INV_2PI[idx+3] << shift) | (INV_2PI[idx+4] >> (64 - shift))
     end
 
     # 3. Perform the multiplication:
diff --git a/test/math.jl b/test/math.jl
index df5c0d23d37a4..248f99cebd987 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -1542,30 +1542,57 @@ end
 end
 
 @testset "constant-foldability of core math functions" begin
-    for fn in (:sin, :cos, :tan, :log, :log2, :log10, :log1p, :exponent, :sqrt, :cbrt, :fourthroot,
-            :asin, :atan, :acos, :sinh, :cosh, :tanh, :asinh, :acosh, :atanh,
-            :exp, :exp2, :exp10, :expm1
-            )
-        for T in (Float16, Float32, Float64)
-            @testset let f = getfield(@__MODULE__, fn), T = T
-                @test Core.Compiler.is_foldable(Base.infer_effects(f, (T,)))
+    for T = Any[Float16, Float32, Float64]
+        @testset let T = T
+            for f = Any[sin, cos, tan, log, log2, log10, log1p, exponent, sqrt, cbrt, fourthroot,
+                        asin, atan, acos, sinh, cosh, tanh, asinh, acosh, atanh, exp, exp2, exp10, expm1]
+                @testset let f = f
+                    @test Base.infer_return_type(f, (T,)) != Union{}
+                    @test Core.Compiler.is_foldable(Base.infer_effects(f, (T,)))
+                end
             end
+            @test Core.Compiler.is_foldable(Base.infer_effects(^, (T,Int)))
+            @test Core.Compiler.is_foldable(Base.infer_effects(^, (T,T)))
         end
     end
 end;
 @testset "removability of core math functions" begin
-    for T in (Float16, Float32, Float64)
+    for T = Any[Float16, Float32, Float64]
         @testset let T = T
-            for f in (exp, exp2, exp10)
+            for f = Any[exp, exp2, exp10, expm1]
                 @testset let f = f
                     @test Core.Compiler.is_removable_if_unused(Base.infer_effects(f, (T,)))
                 end
             end
-            @test Core.Compiler.is_foldable(Base.infer_effects(^, (T,Int)))
-            @test Core.Compiler.is_foldable(Base.infer_effects(^, (T,T)))
         end
     end
 end;
+@testset "exception type inference of core math functions" begin
+    MathErrorT = Union{DomainError, InexactError}
+    for T = (Float16, Float32, Float64)
+        @testset let T = T
+            for f = Any[sin, cos, tan, log, log2, log10, log1p, exponent, sqrt, cbrt, fourthroot,
+                        asin, atan, acos, sinh, cosh, tanh, asinh, acosh, atanh, exp, exp2, exp10, expm1]
+                @testset let f = f
+                    @test Base.infer_exception_type(f, (T,)) <: MathErrorT
+                end
+            end
+            @test Base.infer_exception_type(^, (T,Int)) <: MathErrorT
+            @test Base.infer_exception_type(^, (T,T)) <: MathErrorT
+        end
+    end
+end;
+@test Base.infer_return_type((Int,)) do x
+    local r = nothing
+    try
+        r = sin(x)
+    catch err
+        if err isa DomainError
+            r = 0.0
+        end
+    end
+    return r
+end === Float64
 
 @testset "BigInt Rationals with special funcs" begin
     @test sinpi(big(1//1)) == big(0.0)

From 80ba4573f68a1a9bfb15e81e7ddc0be069b91053 Mon Sep 17 00:00:00 2001
From: Jay-sanjay <134289328+Jay-sanjay@users.noreply.github.com>
Date: Fri, 8 Dec 2023 09:03:30 +0530
Subject: [PATCH 0402/1315] `BLAS.geru!` added (#51951)

Closes https://github.com/JuliaLang/LinearAlgebra.jl/issues/12.

**PR Checklist**
- [x]   added BLAS.geru! function in   stdlib/LinearAlgebra/src/blas.jl
- [x] also added test cases for it in stdlib/LinearAlgebra/test/blas.jl

---------

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
Co-authored-by: Viral B. Shah <ViralBShah@users.noreply.github.com>
Co-authored-by: mikmoore <95002244+mikmoore@users.noreply.github.com>
Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
---
 stdlib/LinearAlgebra/src/blas.jl  | 36 +++++++++++++++++++++++++++++++
 stdlib/LinearAlgebra/test/blas.jl |  5 ++++-
 2 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 998eed6a7d24c..6cc0edfd9f3a1 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -52,6 +52,7 @@ export
     # xTBSV
     # xTPSV
     ger!,
+    geru!,
     # xGERU
     # xGERC
     her!,
@@ -1417,6 +1418,41 @@ for (fname, elty) in ((:dger_,:Float64),
     end
 end
 
+### geru
+
+"""
+    geru!(alpha, x, y, A)
+
+Rank-1 update of the matrix `A` with vectors `x` and `y` as `alpha*x*transpose(y) + A`.
+"""
+function geru! end
+
+for (fname, elty) in ((:zgeru_,:ComplexF64), (:cgeru_,:ComplexF32))
+    @eval begin
+        function geru!(α::$elty, x::AbstractVector{$elty}, y::AbstractVector{$elty}, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A, x, y)
+            m, n = size(A)
+            if m != length(x) || n != length(y)
+                throw(DimensionMismatch(lazy"A has size ($m,$n), x has length $(length(x)), y has length $(length(y))"))
+            end
+            px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed"))
+            py, sty = vec_pointer_stride(y, ArgumentError("input vector with 0 stride is not allowed"))
+            GC.@preserve x y ccall((@blasfunc($fname), libblastrampoline), Cvoid,
+                (Ref{BlasInt}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty},
+                 Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty},
+                 Ref{BlasInt}),
+                 m, n, α, px, stx, py, sty, A, max(1,stride(A,2)))
+            A
+        end
+    end
+end
+for elty in (:Float64, :Float32)
+    @eval begin
+        geru!(α::$elty, x::AbstractVector{$elty}, y::AbstractVector{$elty}, A::AbstractMatrix{$elty}) =
+            ger!(α, x, y, A)
+    end
+end
+
 ### syr
 
 """
diff --git a/stdlib/LinearAlgebra/test/blas.jl b/stdlib/LinearAlgebra/test/blas.jl
index ef7bbca9a9c54..dd432952cb56e 100644
--- a/stdlib/LinearAlgebra/test/blas.jl
+++ b/stdlib/LinearAlgebra/test/blas.jl
@@ -135,7 +135,7 @@ Random.seed!(100)
             end
         end
 
-        @testset "ger, her, syr" for x in (rand(elty, n), view(rand(elty,2n), 1:2:2n), view(rand(elty,n), n:-1:1)),
+        @testset "ger, geru, her, syr" for x in (rand(elty, n), view(rand(elty,2n), 1:2:2n), view(rand(elty,n), n:-1:1)),
             y in (rand(elty,n), view(rand(elty,3n), 1:3:3n), view(rand(elty,2n), 2n:-2:2))
 
             A = rand(elty,n,n)
@@ -144,6 +144,9 @@ Random.seed!(100)
             @test BLAS.ger!(α,x,y,copy(A)) ≈ A + α*x*y'
             @test_throws DimensionMismatch BLAS.ger!(α,Vector{elty}(undef,n+1),y,copy(A))
 
+            @test BLAS.geru!(α,x,y,copy(A)) ≈ A + α*x*transpose(y)
+            @test_throws DimensionMismatch BLAS.geru!(α,Vector{elty}(undef,n+1),y,copy(A))
+
             A = rand(elty,n,n)
             A = A + transpose(A)
             @test issymmetric(A)

From 5dfaef7a67c9b58ed272ba8557bcad103bb814e3 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 8 Dec 2023 09:09:30 +0530
Subject: [PATCH 0403/1315] Limit REPL suggestions to modules from which name
 is exported/public (#52418)

Close #52387 by implementing the suggestion in
https://github.com/JuliaLang/julia/issues/52387#issuecomment-1839152721.
After this, in a fresh session
```julia
julia> Diagonal
ERROR: UndefVarError: `Diagonal` not defined in `Main`
Suggestion: check for spelling errors or missing imports.
Hint: a global variable of this name also exists in LinearAlgebra.
```
---
 stdlib/REPL/src/REPLCompletions.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 375a4e044b228..0089197275ec5 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -1429,7 +1429,7 @@ function UndefVarError_hint(io::IO, ex::UndefVarError)
     else
         scope = undef
     end
-    warnfor(m, var) = Base.isbindingresolved(m, var) && isdefined(m, var) && (print(io, "\nHint: a global variable of this name also exists in $m."); true)
+    warnfor(m, var) = Base.isbindingresolved(m, var) && (Base.isexported(m, var) || Base.ispublic(m, var)) && (print(io, "\nHint: a global variable of this name also exists in $m."); true)
     if scope !== Base && !warnfor(Base, var)
         warned = false
         for m in Base.loaded_modules_order

From 3b9c39ac1cbb46688d7b3597e70b9ae591e3b0ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hamza=20Yusuf=20=C3=87ak=C4=B1r?=
 <32282514+hycakir@users.noreply.github.com>
Date: Fri, 8 Dec 2023 15:37:11 +0100
Subject: [PATCH 0404/1315] Remove `Pkg` dependency from `SuiteSparse_jll`
 (#52441)

This dependency seems to be superfluous, and `Pkg` brings lots of
dependencies into the project (Downloads, LibGit2, etc.) which makes it
hard to create leaner binary packages via `PackageCompiler` for projects
that depend on `SuiteSparse_jll`.
---
 stdlib/SuiteSparse_jll/Project.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stdlib/SuiteSparse_jll/Project.toml b/stdlib/SuiteSparse_jll/Project.toml
index ccd1d06d9a7bb..7518d64e80200 100644
--- a/stdlib/SuiteSparse_jll/Project.toml
+++ b/stdlib/SuiteSparse_jll/Project.toml
@@ -4,7 +4,6 @@ version = "7.2.1+1"
 
 [deps]
 libblastrampoline_jll = "8e850b90-86db-534c-a0d3-1478176c7d93"
-Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 

From bf6c31ceb5c4da5839026463bc29d00458d80a75 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 8 Dec 2023 09:46:55 -0500
Subject: [PATCH 0405/1315] docs: add notes about scratchspaces in depot
 (#52367)

Co-authored-by: Fredrik Ekre <ekrefredrik@gmail.com>
---
 base/initdefs.jl | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/base/initdefs.jl b/base/initdefs.jl
index 59b2f59d7b263..6309781579500 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -73,13 +73,21 @@ environment variable if set.
 Each entry in `DEPOT_PATH` is a path to a directory which contains subdirectories used by Julia for various purposes.
 Here is an overview of some of the subdirectories that may exist in a depot:
 
+* `artifacts`: Contains content that packages use for which Pkg manages the installation of.
 * `clones`: Contains full clones of package repos. Maintained by `Pkg.jl` and used as a cache.
+* `config`: Contains julia-level configuration such as a `startup.jl`
 * `compiled`: Contains precompiled `*.ji` files for packages. Maintained by Julia.
 * `dev`: Default directory for `Pkg.develop`. Maintained by `Pkg.jl` and the user.
 * `environments`: Default package environments. For instance the global environment for a specific julia version. Maintained by `Pkg.jl`.
 * `logs`: Contains logs of `Pkg` and `REPL` operations. Maintained by `Pkg.jl` and `Julia`.
 * `packages`: Contains packages, some of which were explicitly installed and some which are implicit dependencies. Maintained by `Pkg.jl`.
 * `registries`: Contains package registries. By default only `General`. Maintained by `Pkg.jl`.
+* `scratchspaces`: Contains content that a package itself installs via the [`Scratch.jl`](https://github.com/JuliaPackaging/Scratch.jl) package. `Pkg.gc()` will delete content that is known to be unused.
+
+!!! note
+    Packages that want to store content should use the `scratchspaces` subdirectory via
+    [`Scratch.jl`](https://github.com/JuliaPackaging/Scratch.jl) instead of creating new
+    subdirectories in the depot root.
 
 See also [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH), and
 [Code Loading](@ref code-loading).

From 9723de584ecf7fe53b0c3db461b2d1a0cad2a267 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 8 Dec 2023 11:34:05 -0500
Subject: [PATCH 0406/1315] loading: support extensions for stdlibs (an
 implicit env) (#52428)

Some groundwork for
https://github.com/JuliaStats/Statistics.jl/pull/134 which is bumped
(and thus tested) in #52431 that will be merged after this
---
 base/loading.jl | 46 ++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 42 insertions(+), 4 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 212e26bec7d01..25f75c9086589 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -668,7 +668,20 @@ function manifest_uuid_path(env::String, pkg::PkgId)::Union{Nothing,String,Missi
         return explicit_manifest_uuid_path(project_file, pkg)
     elseif project_file
         # if env names a directory, search it
-        return implicit_manifest_uuid_path(env, pkg)
+        proj = implicit_manifest_uuid_path(env, pkg)
+        proj === nothing || return proj
+        # if not found
+        parentid = get(EXT_PRIMED, pkg, nothing)
+        if parentid !== nothing
+            _, parent_project_file = entry_point_and_project_file(env, parentid.name)
+            if parent_project_file !== nothing
+                parentproj = project_file_name_uuid(parent_project_file, parentid.name)
+                if parentproj == parentid
+                    mby_ext = project_file_ext_path(parent_project_file, pkg.name)
+                    mby_ext === nothing || return mby_ext
+                end
+            end
+        end
     end
     return nothing
 end
@@ -1221,11 +1234,19 @@ end
 
 function insert_extension_triggers(env::String, pkg::PkgId)::Union{Nothing,Missing}
     project_file = env_project_file(env)
-    if project_file isa String
+    if project_file isa String || project_file
+        implicit_project_file = project_file
+        if !(implicit_project_file isa String)
+            # if env names a directory, search it for an implicit project file (for stdlibs)
+            path, implicit_project_file = entry_point_and_project_file(env, pkg.name)
+            if !(implicit_project_file isa String)
+                return nothing
+            end
+        end
         # Look in project for extensions to insert
-        proj_pkg = project_file_name_uuid(project_file, pkg.name)
+        proj_pkg = project_file_name_uuid(implicit_project_file, pkg.name)
         if pkg == proj_pkg
-            d_proj = parsed_toml(project_file)
+            d_proj = parsed_toml(implicit_project_file)
             weakdeps = get(d_proj, "weakdeps", nothing)::Union{Nothing, Vector{String}, Dict{String,Any}}
             extensions = get(d_proj, "extensions", nothing)::Union{Nothing, Dict{String, Any}}
             extensions === nothing && return
@@ -1236,6 +1257,7 @@ function insert_extension_triggers(env::String, pkg::PkgId)::Union{Nothing,Missi
         end
 
         # Now look in manifest
+        project_file isa String || return nothing
         manifest_file = project_file_manifest_path(project_file)
         manifest_file === nothing && return
         d = get_deps(parsed_toml(manifest_file))
@@ -2371,6 +2393,22 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     depot_path = map(abspath, DEPOT_PATH)
     dl_load_path = map(abspath, DL_LOAD_PATH)
     load_path = map(abspath, Base.load_path())
+    # if pkg is a stdlib, append its parent Project.toml to the load path
+    parentid = get(EXT_PRIMED, pkg, nothing)
+    if parentid !== nothing
+        for env in load_path
+            project_file = env_project_file(env)
+            if project_file === true
+                _, parent_project_file = entry_point_and_project_file(env, parentid.name)
+                if parent_project_file !== nothing
+                    parentproj = project_file_name_uuid(parent_project_file, parentid.name)
+                    if parentproj == parentid
+                        push!(load_path, parent_project_file)
+                    end
+                end
+            end
+        end
+    end
     path_sep = Sys.iswindows() ? ';' : ':'
     any(path -> path_sep in path, load_path) &&
         error("LOAD_PATH entries cannot contain $(repr(path_sep))")

From 551b37adf55acc7e9ffbe8c42623735186a2ec12 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Fri, 8 Dec 2023 14:41:58 -0500
Subject: [PATCH 0407/1315] =?UTF-8?q?=F0=9F=A4=96=20Bump=20the=20Statistic?=
 =?UTF-8?q?s=20stdlib=20from=2004e5d89=20to=2068869af=20(#52431)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Statistics
URL: https://github.com/JuliaStats/Statistics.jl.git
Stdlib branch: master
Julia branch: jn/loading-stdlib-exts
Old commit: 04e5d89
New commit: 68869af
Julia version: 1.11.0-DEV
Statistics version: 1.11.1(Does not match)
Bump invoked by: @vtjnash
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaStats/Statistics.jl/compare/04e5d8916fae616f5ad328cf6a0b94cf883b8ba6...68869af06e8cdeb7aba1d5259de602da7328057f

```
$ git log --oneline 04e5d89..68869af
68869af Bump patch for version 1.11.1
89f5fc7 Create tagbot.yml
dc844db CI: restore v1.9.4 to build matrix (#159)
d0523ae relax test for mapreduce_empty (#156)
d1c1c42 Drop support for v1.9 in CI (#157)
bfc6326 Fix `quantile` with `Date` and `DateTime` (#153)
b8ea3d2 Prevent overflow in `mean(::AbstractRange)` and relax type constraint. (#150)
a88ae4f Document MATLAB behavior in `quantile` docstring (#152)
46290a0 Revert "Prepare standalone package, step 2 (#128)" (#148)
81a90af make SparseArrays a weak dependency (#134)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/Statistics.version                                       | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Statistics-04e5d8916fae616f5ad328cf6a0b94cf883b8ba6.tar.gz/md5
 delete mode 100644 deps/checksums/Statistics-04e5d8916fae616f5ad328cf6a0b94cf883b8ba6.tar.gz/sha512
 create mode 100644 deps/checksums/Statistics-68869af06e8cdeb7aba1d5259de602da7328057f.tar.gz/md5
 create mode 100644 deps/checksums/Statistics-68869af06e8cdeb7aba1d5259de602da7328057f.tar.gz/sha512

diff --git a/deps/checksums/Statistics-04e5d8916fae616f5ad328cf6a0b94cf883b8ba6.tar.gz/md5 b/deps/checksums/Statistics-04e5d8916fae616f5ad328cf6a0b94cf883b8ba6.tar.gz/md5
deleted file mode 100644
index 546b021cc2afb..0000000000000
--- a/deps/checksums/Statistics-04e5d8916fae616f5ad328cf6a0b94cf883b8ba6.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-1ed739f3d108cfe880fd97fe8b4359e7
diff --git a/deps/checksums/Statistics-04e5d8916fae616f5ad328cf6a0b94cf883b8ba6.tar.gz/sha512 b/deps/checksums/Statistics-04e5d8916fae616f5ad328cf6a0b94cf883b8ba6.tar.gz/sha512
deleted file mode 100644
index c4501f163b216..0000000000000
--- a/deps/checksums/Statistics-04e5d8916fae616f5ad328cf6a0b94cf883b8ba6.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-f83e44af718c5dbe8346762f869796cf80ca6bb10d97c7855e5ea2863198ae650ba8462b46a92a7f6d0941f52d2739c3e10b0a7cbbc6f28e0ad3adb13a89a874
diff --git a/deps/checksums/Statistics-68869af06e8cdeb7aba1d5259de602da7328057f.tar.gz/md5 b/deps/checksums/Statistics-68869af06e8cdeb7aba1d5259de602da7328057f.tar.gz/md5
new file mode 100644
index 0000000000000..9ba42f555d535
--- /dev/null
+++ b/deps/checksums/Statistics-68869af06e8cdeb7aba1d5259de602da7328057f.tar.gz/md5
@@ -0,0 +1 @@
+01b84d67052d1558e51619d5159e7a8b
diff --git a/deps/checksums/Statistics-68869af06e8cdeb7aba1d5259de602da7328057f.tar.gz/sha512 b/deps/checksums/Statistics-68869af06e8cdeb7aba1d5259de602da7328057f.tar.gz/sha512
new file mode 100644
index 0000000000000..31c9c6ca42cec
--- /dev/null
+++ b/deps/checksums/Statistics-68869af06e8cdeb7aba1d5259de602da7328057f.tar.gz/sha512
@@ -0,0 +1 @@
+6ab55ba6f93d2e8b34b19f53cb51a4bfc97b336d451b98f7b95ff81f04fee4fb90a2e4d04aa4bbf3ccffc99c36d9c82c9d00dbae283474308de4a27a91c2e0b7
diff --git a/stdlib/Statistics.version b/stdlib/Statistics.version
index 6028e12fe19f4..1449dcee29b79 100644
--- a/stdlib/Statistics.version
+++ b/stdlib/Statistics.version
@@ -1,4 +1,4 @@
 STATISTICS_BRANCH = master
-STATISTICS_SHA1 = 04e5d8916fae616f5ad328cf6a0b94cf883b8ba6
+STATISTICS_SHA1 = 68869af06e8cdeb7aba1d5259de602da7328057f
 STATISTICS_GIT_URL := https://github.com/JuliaStats/Statistics.jl.git
 STATISTICS_TAR_URL = https://api.github.com/repos/JuliaStats/Statistics.jl/tarball/$1

From 649982aa0995c45165084baa643ce5c7c5b489cb Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sat, 9 Dec 2023 10:05:25 +0900
Subject: [PATCH 0408/1315] [REPLCompletions] support method invalidation
 (#52448)

---
 stdlib/REPL/src/REPLCompletions.jl  | 7 ++++++-
 stdlib/REPL/test/replcompletions.jl | 7 +++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 0089197275ec5..8a9029ccf49cd 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -521,7 +521,12 @@ CC.code_cache(interp::REPLInterpreter) = CC.WorldView(interp.code_cache, CC.Worl
 CC.get(wvc::CC.WorldView{REPLInterpreterCache}, mi::MethodInstance, default) = get(wvc.cache.dict, mi, default)
 CC.getindex(wvc::CC.WorldView{REPLInterpreterCache}, mi::MethodInstance) = getindex(wvc.cache.dict, mi)
 CC.haskey(wvc::CC.WorldView{REPLInterpreterCache}, mi::MethodInstance) = haskey(wvc.cache.dict, mi)
-CC.setindex!(wvc::CC.WorldView{REPLInterpreterCache}, ci::CodeInstance, mi::MethodInstance) = setindex!(wvc.cache.dict, ci, mi)
+function CC.setindex!(wvc::CC.WorldView{REPLInterpreterCache}, ci::CodeInstance, mi::MethodInstance)
+    CC.add_invalidation_callback!(mi) do replaced::MethodInstance, max_world::UInt32
+        delete!(wvc.cache.dict, replaced)
+    end
+    return setindex!(wvc.cache.dict, ci, mi)
+end
 
 # REPLInterpreter is only used for type analysis, so it should disable optimization entirely
 CC.may_optimize(::REPLInterpreter) = false
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 05064e7b7e063..d0bb09dbf8909 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2174,3 +2174,10 @@ for (DictT, KeyT) = Any[(Dict{Symbol,Any}, Symbol),
         @test Core.Compiler.is_noub(effects)
     end
 end
+
+# test invalidation support
+replinterp_invalidation_callee(c::Bool=rand(Bool)) = Some(c ? r"foo" : r"bar")
+replinterp_invalidation_caller() = replinterp_invalidation_callee().value
+@test REPLCompletions.repl_eval_ex(:(replinterp_invalidation_caller()), @__MODULE__) == Regex
+replinterp_invalidation_callee(c::Bool=rand(Bool)) = Some(c ? "foo" : "bar")
+@test REPLCompletions.repl_eval_ex(:(replinterp_invalidation_caller()), @__MODULE__) == String

From abeb68feea5da6151a83ec27786a23b71e06fc88 Mon Sep 17 00:00:00 2001
From: Mason Protter <mason.protter@icloud.com>
Date: Sat, 9 Dec 2023 18:01:26 +0100
Subject: [PATCH 0409/1315] make `rationalize` default to use `Int` on
 `Irrational` (and `Real`) (#46656)

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/rational.jl | 2 +-
 test/rational.jl | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/rational.jl b/base/rational.jl
index 5185f79a2f4f9..5288492e72e71 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -245,7 +245,7 @@ function rationalize(::Type{T}, x::Union{AbstractFloat, Rational}, tol::Real) wh
     end
 end
 rationalize(::Type{T}, x::AbstractFloat; tol::Real = eps(x)) where {T<:Integer} = rationalize(T, x, tol)
-rationalize(x::AbstractFloat; kvs...) = rationalize(Int, x; kvs...)
+rationalize(x::Real; kvs...) = rationalize(Int, x; kvs...)
 rationalize(::Type{T}, x::Complex; kvs...) where {T<:Integer} = Complex(rationalize(T, x.re; kvs...), rationalize(T, x.im; kvs...))
 rationalize(x::Complex; kvs...) = Complex(rationalize(Int, x.re; kvs...), rationalize(Int, x.im; kvs...))
 rationalize(::Type{T}, x::Rational; tol::Real = 0) where {T<:Integer} = rationalize(T, x, tol)
diff --git a/test/rational.jl b/test/rational.jl
index 9efbc931650c4..118f2e6289228 100644
--- a/test/rational.jl
+++ b/test/rational.jl
@@ -542,6 +542,7 @@ end
              100798//32085
              103993//33102
              312689//99532 ]
+    @test rationalize(pi) === rationalize(BigFloat(pi))
 end
 
 @testset "issue #12536" begin

From 84cfe04e7f149235cbb903cc6f4110ddaa7007eb Mon Sep 17 00:00:00 2001
From: Mason Protter <mason.protter@icloud.com>
Date: Sat, 9 Dec 2023 22:38:11 +0100
Subject: [PATCH 0410/1315] add `wrap` function which is the safe counterpart
 to `unsafe_wrap`. (#52049)

---
 NEWS.md          |  1 +
 base/array.jl    | 33 +++++++++++++++++++++++++++++++++
 base/exports.jl  |  1 +
 test/arrayops.jl | 19 +++++++++++++++++++
 4 files changed, 54 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index 0dd4d2f53bc01..3a2fc922a17eb 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -62,6 +62,7 @@ New library functions
 * `copyuntil(out, io, delim)` and `copyline(out, io)` copy data into an `out::IO` stream ([#48273]).
 * `eachrsplit(string, pattern)` iterates split substrings right to left.
 * `Sys.username()` can be used to return the current user's username ([#51897]).
+* `wrap(Array, m::Union{MemoryRef{T}, Memory{T}}, dims)` which is the safe counterpart to `unsafe_wrap` ([#52049]).
 
 New library features
 --------------------
diff --git a/base/array.jl b/base/array.jl
index be9f44625c06f..6fd6f61a4fc95 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -3039,3 +3039,36 @@ intersect(r::AbstractRange, v::AbstractVector) = intersect(v, r)
         _getindex(v, i)
     end
 end
+
+"""
+    wrap(Array, m::Union{Memory{T}, MemoryRef{T}}, dims)
+
+Create an array of size `dims` using `m` as the underlying memory. This can be thought of as a safe version
+of [`unsafe_wrap`](@ref) utilizing `Memory` or `MemoryRef` instead of raw pointers.
+"""
+function wrap end
+
+@eval @propagate_inbounds function wrap(::Type{Array}, ref::MemoryRef{T}, dims::NTuple{N, Integer}) where {T, N}
+    mem = ref.mem
+    mem_len = length(mem) + 1 - memoryrefoffset(ref)
+    len = Core.checked_dims(dims...)
+    @boundscheck mem_len >= len || invalid_wrap_err(mem_len, dims, len)
+    if N != 1 && !(ref === GenericMemoryRef(mem) && len === mem_len)
+        mem = ccall(:jl_genericmemory_slice, Memory{T}, (Any, Ptr{Cvoid}, Int), mem, ref.ptr_or_offset, len)
+        ref = MemoryRef(mem)
+    end
+    $(Expr(:new, :(Array{T, N}), :ref, :dims))
+end
+
+@noinline invalid_wrap_err(len, dims, proddims) = throw(DimensionMismatch(
+    "Attempted to wrap a MemoryRef of length $len with an Array of size dims=$dims, which is invalid because prod(dims) = $proddims > $len, so that the array would have more elements than the underlying memory can store."))
+
+function wrap(::Type{Array}, m::Memory{T}, dims::NTuple{N, Integer}) where {T, N}
+    wrap(Array, MemoryRef(m), dims)
+end
+function wrap(::Type{Array}, m::MemoryRef{T}, l::Integer) where {T}
+    wrap(Array, m, (l,))
+end
+function wrap(::Type{Array}, m::Memory{T}, l::Integer) where {T}
+    wrap(Array, MemoryRef(m), (l,))
+end
diff --git a/base/exports.jl b/base/exports.jl
index 398d828f9cf19..374016f22571f 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -458,6 +458,7 @@ export
     vcat,
     vec,
     view,
+    wrap,
     zeros,
 
 # search, find, match and related functions
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 9c9aac987929d..8e33e209ee88b 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -3170,3 +3170,22 @@ end
         @test c + zero(c) == c
     end
 end
+
+@testset "Wrapping Memory into Arrays" begin
+    mem = Memory{Int}(undef, 10) .= 1
+    memref = MemoryRef(mem)
+    @test_throws DimensionMismatch wrap(Array, mem, (10, 10))
+    @test wrap(Array, mem, (5,)) == ones(Int, 5)
+    @test wrap(Array, mem, 2) == ones(Int, 2)
+    @test wrap(Array, memref, 10) == ones(Int, 10)
+    @test wrap(Array, memref, (2,2,2)) == ones(Int,2,2,2)
+    @test wrap(Array, mem, (5, 2)) == ones(Int, 5, 2)
+
+    memref2 = MemoryRef(mem, 3)
+    @test wrap(Array, memref2, (5,)) == ones(Int, 5)
+    @test wrap(Array, memref2, 2) == ones(Int, 2)
+    @test wrap(Array, memref2, (2,2,2)) == ones(Int,2,2,2)
+    @test wrap(Array, memref2, (3, 2)) == ones(Int, 3, 2)
+    @test_throws DimensionMismatch wrap(Array, memref2, 9)
+    @test_throws DimensionMismatch wrap(Array, memref2, 10)
+end

From e2a26aa7fd0e5e6e1b1eca33946da56ce6ad4170 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Sun, 10 Dec 2023 11:27:08 -0300
Subject: [PATCH 0411/1315] use atomics in the write barrier slow path (#52463)

Use atomics in the write-barrier slow-path to prevent duplicates in the
remset.

As discussed in https://github.com/JuliaLang/julia/issues/50419, setting
the mark bit is idempotent, but updating page metadata in the mark phase
is not.
---
 src/gc.c | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 7fac0f130d4f4..508ab0062f187 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1788,13 +1788,17 @@ JL_DLLEXPORT void jl_gc_queue_root(const jl_value_t *ptr)
 {
     jl_ptls_t ptls = jl_current_task->ptls;
     jl_taggedvalue_t *o = jl_astaggedvalue(ptr);
-    // The modification of the `gc_bits` is not atomic but it
-    // should be safe here since GC is not allowed to run here and we only
-    // write GC_OLD to the GC bits outside GC. This could cause
-    // duplicated objects in the remset but that shouldn't be a problem.
-    o->bits.gc = GC_MARKED;
-    arraylist_push(ptls->heap.remset, (jl_value_t*)ptr);
-    ptls->heap.remset_nptr++; // conservative
+    // The modification of the `gc_bits` needs to be atomic.
+    // We need to ensure that objects are in the remset at
+    // most once, since the mark phase may update page metadata,
+    // which is not idempotent. See comments in https://github.com/JuliaLang/julia/issues/50419
+    uintptr_t header = jl_atomic_load_relaxed((_Atomic(uintptr_t) *)&o->header);
+    header &= ~GC_OLD; // clear the age bit
+    header = jl_atomic_exchange_relaxed((_Atomic(uintptr_t) *)&o->header, header);
+    if (header & GC_OLD) { // write barrier has not been triggered in this object yet
+        arraylist_push(ptls->heap.remset, (jl_value_t*)ptr);
+        ptls->heap.remset_nptr++; // conservative
+    }
 }
 
 void jl_gc_queue_multiroot(const jl_value_t *parent, const void *ptr, jl_datatype_t *dt) JL_NOTSAFEPOINT

From d90fa45c6ac5da8398e6864128579df48edbf00c Mon Sep 17 00:00:00 2001
From: Milan Bouchet-Valat <nalimilan@club.fr>
Date: Sun, 10 Dec 2023 16:45:21 +0100
Subject: [PATCH 0412/1315] Fix minimum/maximum over dimensions with missing
 values (#35323)

`v0 != v0` returns `missing` for missing values. Use the
largest/smallest non-missing value to initialize the array. This is an
inefficient approach. Faster alternatives would be to avoid using an
initial value at all, and instead keep track of whether a value has been
set in a separate mask; or to use `typemax`/`typemin` for types that
support them.

Fixes #35308.
---
 base/reducedim.jl | 22 +++++++++++++++-------
 test/reducedim.jl | 15 +++++++++++----
 2 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/base/reducedim.jl b/base/reducedim.jl
index f5a22940310cf..21dff3b46ab37 100644
--- a/base/reducedim.jl
+++ b/base/reducedim.jl
@@ -146,16 +146,18 @@ for (f1, f2, initval, typeextreme) in ((:min, :max, :Inf, :typemax), (:max, :min
             T = _realtype(f, promote_union(eltype(A)))
             Tr = v0 isa T ? T : typeof(v0)
 
-            # but NaNs and missing need to be avoided as initial values
+            # but NaNs, missing and unordered values need to be avoided as initial values
             if v0 isa Number && isnan(v0)
                 # v0 is NaN
                 v0 = oftype(v0, $initval)
             elseif isunordered(v0)
                 # v0 is missing or a third-party unordered value
                 Tnm = nonmissingtype(Tr)
-                # TODO: Some types, like BigInt, don't support typemin/typemax.
-                # So a Matrix{Union{BigInt, Missing}} can still error here.
-                v0 = $typeextreme(Tnm)
+                if Tnm <: Union{BitInteger, IEEEFloat, BigFloat}
+                    v0 = $typeextreme(Tnm)
+                elseif !all(isunordered, A1)
+                    v0 = mapreduce(f, $f2, Iterators.filter(!isunordered, A1))
+                end
             end
             # v0 may have changed type.
             Tr = v0 isa T ? T : typeof(v0)
@@ -186,12 +188,18 @@ function reducedim_init(f::ExtremaMap, op::typeof(_extrema_rf), A::AbstractArray
 
     # but NaNs and missing need to be avoided as initial values
     if v0[1] isa Number && isnan(v0[1])
+        # v0 is NaN
         v0 = oftype(v0[1], Inf), oftype(v0[2], -Inf)
     elseif isunordered(v0[1])
         # v0 is missing or a third-party unordered value
-        # TODO: Some types, like BigInt, don't support typemin/typemax.
-        # So a Matrix{Union{BigInt, Missing}} can still error here.
-        v0 = typemax(nonmissingtype(Tmin)), typemin(nonmissingtype(Tmax))
+        Tminnm = nonmissingtype(Tmin)
+        Tmaxnm = nonmissingtype(Tmax)
+        if Tminnm <: Union{BitInteger, IEEEFloat, BigFloat} &&
+            Tmaxnm <: Union{BitInteger, IEEEFloat, BigFloat}
+            v0 = (typemax(Tminnm), typemin(Tmaxnm))
+        elseif !all(isunordered, A1)
+            v0 = reverse(mapreduce(f, op, Iterators.filter(!isunordered, A1)))
+        end
     end
     # v0 may have changed type.
     Tmin = v0[1] isa T ? T : typeof(v0[1])
diff --git a/test/reducedim.jl b/test/reducedim.jl
index daa0a3fbe1f92..f4767dd7a472c 100644
--- a/test/reducedim.jl
+++ b/test/reducedim.jl
@@ -608,7 +608,7 @@ end
 end
 @testset "NaN/missing test for extrema with dims #43599" begin
     for sz = (3, 10, 100)
-        for T in (Int, Float64, BigFloat)
+        for T in (Int, Float64, BigFloat, BigInt)
             Aₘ = Matrix{Union{T, Missing}}(rand(-sz:sz, sz, sz))
             Aₘ[rand(1:sz*sz, sz)] .= missing
             unordered_test_for_extrema(Aₘ)
@@ -622,9 +622,16 @@ end
         end
     end
 end
-@test_broken minimum([missing;BigInt(1)], dims = 1)
-@test_broken maximum([missing;BigInt(1)], dims = 1)
-@test_broken extrema([missing;BigInt(1)], dims = 1)
+
+@testset "minimum/maximum over dims with missing (#35308)" begin
+    for T in (Int, Float64, BigInt, BigFloat)
+        x = Union{T, Missing}[1 missing; 2 missing]
+        @test isequal(minimum(x, dims=1), reshape([1, missing], 1, :))
+        @test isequal(maximum(x, dims=1), reshape([2, missing], 1, :))
+        @test isequal(minimum(x, dims=2), reshape([missing, missing], :, 1))
+        @test isequal(maximum(x, dims=2), reshape([missing, missing], :, 1))
+    end
+end
 
 # issue #26709
 @testset "dimensional reduce with custom non-bitstype types" begin

From 5e9cd58c5f5aca41b7e041f42f9b977cc4093448 Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Mon, 11 Dec 2023 03:29:06 +0100
Subject: [PATCH 0413/1315] Use optimised string search methods for substrings,
 too (#52424)

Allow searching for ASCII chars in substrings to use memchr, and other
similar optimisations. Previously, only String was special cased.
---
 base/strings/search.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/strings/search.jl b/base/strings/search.jl
index 1a3085e084ccd..e2b3dc96b98cf 100644
--- a/base/strings/search.jl
+++ b/base/strings/search.jl
@@ -13,7 +13,7 @@ abstract type AbstractPattern end
 nothing_sentinel(i) = i == 0 ? nothing : i
 
 function findnext(pred::Fix2{<:Union{typeof(isequal),typeof(==)},<:AbstractChar},
-                  s::String, i::Integer)
+                  s::Union{String, SubString{String}}, i::Integer)
     if i < 1 || i > sizeof(s)
         i == sizeof(s) + 1 && return nothing
         throw(BoundsError(s, i))
@@ -38,7 +38,7 @@ findnext(pred::Fix2{<:Union{typeof(isequal),typeof(==)},<:Union{Int8,UInt8}}, a:
 findfirst(::typeof(iszero), a::ByteArray) = nothing_sentinel(_search(a, zero(UInt8)))
 findnext(::typeof(iszero), a::ByteArray, i::Integer) = nothing_sentinel(_search(a, zero(UInt8), i))
 
-function _search(a::Union{String,ByteArray}, b::Union{Int8,UInt8}, i::Integer = 1)
+function _search(a::Union{String,SubString{String},ByteArray}, b::Union{Int8,UInt8}, i::Integer = 1)
     if i < 1
         throw(BoundsError(a, i))
     end
@@ -201,10 +201,10 @@ function _search_bloom_mask(c)
     UInt64(1) << (c & 63)
 end
 
-_nthbyte(s::String, i) = codeunit(s, i)
+_nthbyte(s::Union{String, SubString{String}}, i) = codeunit(s, i)
 _nthbyte(t::AbstractVector, index) = t[index + (firstindex(t)-1)]
 
-function _searchindex(s::String, t::String, i::Integer)
+function _searchindex(s::Union{String, SubString{String}}, t::Union{String, SubString{String}}, i::Integer)
     # Check for fast case of a single byte
     lastindex(t) == 1 && return something(findnext(isequal(t[1]), s, i), 0)
     _searchindex(codeunits(s), codeunits(t), i)

From 2fe4190b3d26b4eee52b2b1b1054ddd6e38a941e Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 11 Dec 2023 10:07:14 +0530
Subject: [PATCH 0414/1315] Reduce code duplication in
 `eigen(::AbstractMatrix)` methods (#52450)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This also fixes the following:
```julia
julia> D = Diagonal(Float16[1,2,4])
3×3 Diagonal{Float16, Vector{Float16}}:
 1.0   ⋅    ⋅
  ⋅   2.0   ⋅
  ⋅    ⋅   4.0

julia> eigen(Array(D)) # returns Float32
Eigen{Float32, Float32, Matrix{Float32}, Vector{Float32}}
values:
3-element Vector{Float32}:
 1.0
 2.0
 4.0
vectors:
3×3 Matrix{Float32}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> eigen(D)  # returns Float16 as expected
Eigen{Float16, Float16, Matrix{Float16}, Vector{Float16}}
values:
3-element Vector{Float16}:
 1.0
 2.0
 4.0
vectors:
3×3 Matrix{Float16}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0
```
After this,
```julia
julia> eigen(Array(D))
Eigen{Float16, Float16, Matrix{Float16}, Vector{Float16}}
values:
3-element Vector{Float16}:
 1.0
 2.0
 4.0
vectors:
3×3 Matrix{Float16}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0
```
---
 stdlib/LinearAlgebra/src/eigen.jl  | 17 +++++++++--------
 stdlib/LinearAlgebra/test/eigen.jl | 15 +++++++++++++++
 2 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/eigen.jl b/stdlib/LinearAlgebra/src/eigen.jl
index 571556be47c0a..4ba540d42b261 100644
--- a/stdlib/LinearAlgebra/src/eigen.jl
+++ b/stdlib/LinearAlgebra/src/eigen.jl
@@ -236,22 +236,23 @@ true
 ```
 """
 function eigen(A::AbstractMatrix{T}; permute::Bool=true, scale::Bool=true, sortby::Union{Function,Nothing}=eigsortby) where T
-    isdiag(A) && return eigen(Diagonal{eigtype(T)}(diag(A)); sortby)
-    ishermitian(A) && return eigen!(eigencopy_oftype(Hermitian(A), eigtype(T)); sortby)
-    AA = eigencopy_oftype(A, eigtype(T))
-    return eigen!(AA; permute, scale, sortby)
+    _eigen(A; permute, scale, sortby)
 end
 function eigen(A::AbstractMatrix{T}; permute::Bool=true, scale::Bool=true, sortby::Union{Function,Nothing}=eigsortby) where {T <: Union{Float16,Complex{Float16}}}
+    E = _eigen(A; permute, scale, sortby)
+    values = convert(AbstractVector{isreal(E.values) ? Float16 : Complex{Float16}}, E.values)
+    vectors = convert(AbstractMatrix{isreal(E.vectors) ? Float16 : Complex{Float16}}, E.vectors)
+    return Eigen(values, vectors)
+end
+function _eigen(A::AbstractMatrix{T}; permute=true, scale=true, sortby=eigsortby) where {T}
     isdiag(A) && return eigen(Diagonal{eigtype(T)}(diag(A)); sortby)
-    E = if ishermitian(A)
+    if ishermitian(A)
         eigen!(eigencopy_oftype(Hermitian(A), eigtype(T)); sortby)
     else
         eigen!(eigencopy_oftype(A, eigtype(T)); permute, scale, sortby)
     end
-    values = convert(AbstractVector{isreal(E.values) ? Float16 : Complex{Float16}}, E.values)
-    vectors = convert(AbstractMatrix{isreal(E.vectors) ? Float16 : Complex{Float16}}, E.vectors)
-    return Eigen(values, vectors)
 end
+
 eigen(x::Number) = Eigen([x], fill(one(x), 1, 1))
 
 """
diff --git a/stdlib/LinearAlgebra/test/eigen.jl b/stdlib/LinearAlgebra/test/eigen.jl
index b9e6d0e62e3ee..85ec5cdf5ab46 100644
--- a/stdlib/LinearAlgebra/test/eigen.jl
+++ b/stdlib/LinearAlgebra/test/eigen.jl
@@ -241,6 +241,21 @@ end
     @test F.vectors isa Matrix{ComplexF16}
     @test F.values ≈ F32.values
     @test F.vectors ≈ F32.vectors
+
+    for T in (Float16, ComplexF16)
+        D = Diagonal(T[1,2,4])
+        A = Array(D)
+        B = eigen(A)
+        @test B isa Eigen{Float16, Float16, Matrix{Float16}, Vector{Float16}}
+        @test B.values isa Vector{Float16}
+        @test B.vectors isa Matrix{Float16}
+    end
+    D = Diagonal(ComplexF16[im,2,4])
+    A = Array(D)
+    B = eigen(A)
+    @test B isa Eigen{Float16, ComplexF16, Matrix{Float16}, Vector{ComplexF16}}
+    @test B.values isa Vector{ComplexF16}
+    @test B.vectors isa Matrix{Float16}
 end
 
 @testset "complex eigen inference (#52289)" begin

From 69e90051e1bf1bb1f13395dd7efad12a2daee34d Mon Sep 17 00:00:00 2001
From: omahs <73983677+omahs@users.noreply.github.com>
Date: Mon, 11 Dec 2023 10:46:47 +0100
Subject: [PATCH 0415/1315] Fix typos (#52479)

Fix typos
---
 doc/src/devdocs/EscapeAnalysis.md      | 4 ++--
 doc/src/devdocs/aot.md                 | 2 +-
 doc/src/tutorials/creating-packages.md | 4 ++--
 doc/src/tutorials/profile.md           | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/src/devdocs/EscapeAnalysis.md b/doc/src/devdocs/EscapeAnalysis.md
index ed91ee64e8bdc..1bd7868790f7f 100644
--- a/doc/src/devdocs/EscapeAnalysis.md
+++ b/doc/src/devdocs/EscapeAnalysis.md
@@ -18,7 +18,7 @@ This escape analysis aims to:
 ## Try it out!
 
 You can give a try to the escape analysis by loading the `EAUtils.jl` utility script that
-define the convenience entries `code_escapes` and `@code_escapes` for testing and debugging purposes:
+defines the convenience entries `code_escapes` and `@code_escapes` for testing and debugging purposes:
 ```@repl EAUtils
 let JULIA_DIR = normpath(Sys.BINDIR, "..", "share", "julia")
     # load `EscapeAnalysis` module to define the core analysis code
@@ -54,7 +54,7 @@ result = code_escapes((String,String,String,String)) do s1, s2, s3, s4
 end
 ```
 
-The symbols in the side of each call argument and SSA statements represents the following meaning:
+The symbols on the side of each call argument and SSA statements represent the following meaning:
 - `◌` (plain): this value is not analyzed because escape information of it won't be used anyway (when the object is `isbitstype` for example)
 - `✓` (green or cyan): this value never escapes (`has_no_escape(result.state[x])` holds), colored blue if it has arg escape also (`has_arg_escape(result.state[x])` holds)
 - `↑` (blue or yellow): this value can escape to the caller via return (`has_return_escape(result.state[x])` holds), colored yellow if it has unhandled thrown escape also (`has_thrown_escape(result.state[x])` holds)
diff --git a/doc/src/devdocs/aot.md b/doc/src/devdocs/aot.md
index e74f121437b80..cdaf1880ab927 100644
--- a/doc/src/devdocs/aot.md
+++ b/doc/src/devdocs/aot.md
@@ -23,7 +23,7 @@ Firstly, the methods that need to be compiled to native code must be identified.
 
 Once the methods to be compiled have been identified, they are passed to the `jl_create_system_image` function. This function sets up a number of data structures that will be used when serializing native code to a file, and then calls `jl_create_native` with the array of methods. `jl_create_native` runs codegen on the methods produces one or more LLVM modules. `jl_create_system_image` then records some useful information about what codegen produced from the module(s).
 
-The module(s) are then passed to `jl_dump_native`, along with the information recorded by `jl_create_system_image`. `jl_dump_native` contains the code necessary to serialize the module(s) to bitcode, object, or assembly files depending on the command-line options passed to Julia. The serialized code and information is then written to a file as an archive.
+The module(s) are then passed to `jl_dump_native`, along with the information recorded by `jl_create_system_image`. `jl_dump_native` contains the code necessary to serialize the module(s) to bitcode, object, or assembly files depending on the command-line options passed to Julia. The serialized code and information are then written to a file as an archive.
 
 The final step is to run a system linker on the object files in the archive produced by `jl_dump_native`. Once this step is complete, a shared library containing the compiled code is produced.
 
diff --git a/doc/src/tutorials/creating-packages.md b/doc/src/tutorials/creating-packages.md
index 6511aa2503816..d1f79e8c88a9d 100644
--- a/doc/src/tutorials/creating-packages.md
+++ b/doc/src/tutorials/creating-packages.md
@@ -160,7 +160,7 @@ it does add a new feature, that the message must be three words long.
 Later, we may wish to change `greet_alien` to
 
 ```julia
-"Greet an alien by a the name of \"Zork\"."
+"Greet an alien by the name of \"Zork\"."
 greet_alien() = print("Hello Zork")
 ```
 
@@ -557,7 +557,7 @@ This is done by making the following changes (using the example above):
 #### Using an extension while supporting older Julia versions
 
 In the case where one wants to use an extension (without worrying about the
-feature of the extension begin available on older Julia versions) while still
+feature of the extension being available on older Julia versions) while still
 supporting older Julia versions the packages under `[weakdeps]` should be
 duplicated into `[extras]`. This is an unfortunate duplication, but without
 doing this the project verifier under older Julia versions will throw an error
diff --git a/doc/src/tutorials/profile.md b/doc/src/tutorials/profile.md
index 3a1812cb6d187..a3baec593a53d 100644
--- a/doc/src/tutorials/profile.md
+++ b/doc/src/tutorials/profile.md
@@ -300,7 +300,7 @@ on the author's laptop).
 ## Memory allocation analysis
 
 One of the most common techniques to improve performance is to reduce memory allocation. Julia
-provides several tools measure this:
+provides several tools to measure this:
 
 ### `@time`
 

From 456951fbbb0d47e45f49dd7942d5f7571831c049 Mon Sep 17 00:00:00 2001
From: Thomas van Doornmalen <60822431+Taaitaaiger@users.noreply.github.com>
Date: Mon, 11 Dec 2023 14:32:26 +0100
Subject: [PATCH 0416/1315] Export several genericmemory-related functions from
 C (#52475)

The functionality of `jl_array_isassigned`, `jl_arrayref`,
`jl_arrayset`, and `jl_arrayunset` has been moved to new functions, but
those new functions aren't exported. This PR exports them.
---
 src/jl_exported_funcs.inc | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index a946578d25146..9131ece904e88 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -28,7 +28,11 @@
     XX(jl_array_ptr) \
     XX(jl_array_ptr_1d_append) \
     XX(jl_array_ptr_1d_push) \
+    XX(jl_genericmemory_isassigned) \
     XX(jl_genericmemory_owner) \
+    XX(jl_genericmemoryref) \
+    XX(jl_genericmemoryset) \
+    XX(jl_genericmemoryunset) \
     XX(jl_array_rank) \
     XX(jl_array_to_string) \
     XX(jl_atexit_hook) \

From 3accfe8c80eb7165a11f86ab18824f0045bafe3e Mon Sep 17 00:00:00 2001
From: Milan Bouchet-Valat <nalimilan@club.fr>
Date: Mon, 11 Dec 2023 18:16:48 +0100
Subject: [PATCH 0417/1315] Improve `sizehint!` docstring about `shrink` arg
 (#52226)

See
https://github.com/JuliaLang/julia/pull/51929#discussion_r1390444453.
---
 base/array.jl | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index 6fd6f61a4fc95..beb5246a0cbda 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -1441,10 +1441,14 @@ you expect that you're going to have to push a lot of values onto `s`, you can a
 the cost of incremental reallocation by doing it once up front; this can improve
 performance.
 
-If `first` is true, then the reserved space is from the start of the collection, for ordered
-collections. Supplying this keyword may result in an error if the collection is nor ordered
+If `first` is `true`, then any additional space is reserved before the start of the collection.
+This way, subsequent calls to `pushfirst!` (instead of `push!`) may become faster.
+Supplying this keyword may result in an error if the collection is not ordered
 or if `pushfirst!` is not supported for this collection.
 
+If `shrink=true` (the default), the collection's capacity may be reduced if its current
+capacity is greater than `n`.
+
 See also [`resize!`](@ref).
 
 # Notes on the performance model
@@ -1460,8 +1464,6 @@ For types that support `sizehint!`,
 
 3. `empty!` is nearly costless (and O(1)) for types that support this kind of preallocation.
 
-4. `shrink` controls if the collection can be shrunk.
-
 !!! compat "Julia 1.11"
     The `shrink` and `first` arguments were added in Julia 1.11.
 """

From 7b54ae762faf251868802e29a8163d8976cf12eb Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 11 Dec 2023 12:17:48 -0500
Subject: [PATCH 0418/1315] relax type signature for PipeBuffer to accept
 AbstractVector{UInt8} (#52459)

Fixes #48585
---
 base/iobuffer.jl | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index deb86e774f4e4..4407d7327ce6f 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -123,10 +123,11 @@ function IOBuffer(;
     return buf
 end
 
-# PipeBuffers behave like Unix Pipes. They are typically readable and writable, they act appendable, and are not seekable.
+# PipeBuffers behave somewhat more like Unix Pipes (than Files). They are typically readable and writable, they act appendable, and are not seekable.
+# However, they do not support stream notification, so for that there is the BufferStream wrapper around this.
 
 """
-    PipeBuffer(data::Vector{UInt8}=UInt8[]; maxsize::Integer = typemax(Int))
+    PipeBuffer(data::AbstractVector{UInt8}=UInt8[]; maxsize::Integer = typemax(Int))
 
 An [`IOBuffer`](@ref) that allows reading and performs writes by appending.
 Seeking and truncating are not supported.
@@ -134,8 +135,8 @@ See [`IOBuffer`](@ref) for the available constructors.
 If `data` is given, creates a `PipeBuffer` to operate on a data vector,
 optionally specifying a size beyond which the underlying `Array` may not be grown.
 """
-PipeBuffer(data::Vector{UInt8}=UInt8[]; maxsize::Int = typemax(Int)) =
-    GenericIOBuffer(data,true,true,false,true,maxsize)
+PipeBuffer(data::AbstractVector{UInt8}=UInt8[]; maxsize::Int = typemax(Int)) =
+    GenericIOBuffer(data, true, true, false, true, maxsize)
 PipeBuffer(maxsize::Integer) = (x = PipeBuffer(StringVector(maxsize), maxsize = maxsize); x.size=0; x)
 
 _similar_data(b::GenericIOBuffer, len::Int) = similar(b.data, len)

From bb2822275b9d39afbdf3398cd913046f2d1cdced Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 11 Dec 2023 12:25:11 -0500
Subject: [PATCH 0419/1315] better support threads in precompile and
 jl_task_wait_empty (#52445)

Add a `nrunning` counter which identifies (when zero) when there is
nothing running anymore. Allowing us to gate all tasks on all threads on
reaching a quiescent state, not just thread 0. This should let us better
support running precompile with threads (since we will be ensured that
all of them are asleep in a consistent state before serialization tries
to inspect the process state). We could additionally stop them
afterwards to make sure there is no way for them to begin running, even
if we forgot about some other event source, but that seems unnecessary
paranoia for now.

Note it is quite hard to encounter currently, as most places where
precompile happens currently try to force the number of threads to 1.
But this should become more relevant in the future as more threads are
supported in more places. This also may help generally with being able
to ensure the IO loop is running on at least one thread (as that is
currently lacking in this PR and on master). And also help with being
able to decide on a more advanced tree-wakeup strategy, as we start to
track how many threads are in various states of running and sleeping,
relative to the amount of work they find.

Fixes #52435
---
 src/Makefile                 |   2 +-
 src/jl_uv.c                  |  26 ++++---
 src/julia_threads.h          |   4 +-
 src/options.h                |  20 ------
 src/precompile.c             |   8 ++-
 src/{partr.c => scheduler.c} | 127 ++++++++++++++++++++++++++---------
 src/staticdata.c             |   2 +-
 src/threading.c              |   5 +-
 8 files changed, 125 insertions(+), 69 deletions(-)
 rename src/{partr.c => scheduler.c} (78%)

diff --git a/src/Makefile b/src/Makefile
index 5fc2bc2eaaa41..747090a8dcd83 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -44,7 +44,7 @@ SRCS := \
 	jltypes gf typemap smallintset ast builtins module interpreter symbol \
 	dlload sys init task array genericmemory staticdata toplevel jl_uv datatype \
 	simplevector runtime_intrinsics precompile jloptions mtarraylist \
-	threading partr stackwalk gc gc-debug gc-pages gc-stacks gc-alloc-profiler method \
+	threading scheduler stackwalk gc gc-debug gc-pages gc-stacks gc-alloc-profiler method \
 	jlapi signal-handling safepoint timing subtype rtutils gc-heap-snapshot \
 	crc32c APInt-C processor ircode opaque_closure codegen-stubs coverage runtime_ccall
 
diff --git a/src/jl_uv.c b/src/jl_uv.c
index 8cdd8f95ba2e6..32adf9f1ba8f2 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -75,21 +75,26 @@ static void wait_empty_func(uv_timer_t *t)
 void jl_wait_empty_begin(void)
 {
     JL_UV_LOCK();
-    if (wait_empty_worker.type != UV_TIMER && jl_io_loop) {
-        // try to purge anything that is just waiting for cleanup
-        jl_io_loop->stop_flag = 0;
-        uv_run(jl_io_loop, UV_RUN_NOWAIT);
-        uv_timer_init(jl_io_loop, &wait_empty_worker);
+    if (jl_io_loop) {
+        if (wait_empty_worker.type != UV_TIMER) {
+            // try to purge anything that is just waiting for cleanup
+            jl_io_loop->stop_flag = 0;
+            uv_run(jl_io_loop, UV_RUN_NOWAIT);
+            uv_timer_init(jl_io_loop, &wait_empty_worker);
+            uv_unref((uv_handle_t*)&wait_empty_worker);
+        }
+        // make sure this is running
         uv_update_time(jl_io_loop);
         uv_timer_start(&wait_empty_worker, wait_empty_func, 10, 15000);
-        uv_unref((uv_handle_t*)&wait_empty_worker);
     }
     JL_UV_UNLOCK();
 }
 void jl_wait_empty_end(void)
 {
     // n.b. caller must be holding jl_uv_mutex
-    uv_close((uv_handle_t*)&wait_empty_worker, NULL);
+    if (wait_empty_worker.type == UV_TIMER)
+        // make sure this timer is stopped, but not destroyed in case the user calls jl_wait_empty_begin again
+        uv_timer_stop(&wait_empty_worker);
 }
 
 
@@ -174,9 +179,12 @@ static void jl_uv_closeHandle(uv_handle_t *handle)
         ct->world_age = last_age;
         return;
     }
-    if (handle == (uv_handle_t*)&signal_async || handle == (uv_handle_t*)&wait_empty_worker)
+    if (handle == (uv_handle_t*)&wait_empty_worker)
+        handle->type = UV_UNKNOWN_HANDLE;
+    else if (handle == (uv_handle_t*)&signal_async)
         return;
-    free(handle);
+    else
+        free(handle);
 }
 
 static void jl_uv_flush_close_callback(uv_write_t *req, int status)
diff --git a/src/julia_threads.h b/src/julia_threads.h
index edda8f8adaa1c..af7df23447c01 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -371,11 +371,11 @@ void jl_gc_safe_leave(jl_ptls_t ptls, int8_t state) JL_NOTSAFEPOINT_LEAVE; // th
 #endif
 
 JL_DLLEXPORT void jl_gc_enable_finalizers(struct _jl_task_t *ct, int on);
-JL_DLLEXPORT void jl_gc_disable_finalizers_internal(void);
+JL_DLLEXPORT void jl_gc_disable_finalizers_internal(void) JL_NOTSAFEPOINT;
 JL_DLLEXPORT void jl_gc_enable_finalizers_internal(void);
 JL_DLLEXPORT void jl_gc_run_pending_finalizers(struct _jl_task_t *ct);
 extern JL_DLLEXPORT _Atomic(int) jl_gc_have_pending_finalizers;
-JL_DLLEXPORT int8_t jl_gc_is_in_finalizer(void);
+JL_DLLEXPORT int8_t jl_gc_is_in_finalizer(void) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT void jl_wakeup_thread(int16_t tid);
 
diff --git a/src/options.h b/src/options.h
index 7f7ac360fdae2..685dea7b981db 100644
--- a/src/options.h
+++ b/src/options.h
@@ -143,26 +143,6 @@
 #define MACHINE_EXCLUSIVE_NAME          "JULIA_EXCLUSIVE"
 #define DEFAULT_MACHINE_EXCLUSIVE       0
 
-// partr -- parallel tasks runtime options ------------------------------------
-
-// multiq
-    // number of heaps = MULTIQ_HEAP_C * nthreads
-#define MULTIQ_HEAP_C                   4
-    // how many in each heap
-#define MULTIQ_TASKS_PER_HEAP           129
-
-// parfor
-    // tasks = niters / (GRAIN_K * nthreads)
-#define GRAIN_K                         4
-
-// synchronization
-    // narrivers = ((GRAIN_K * nthreads) ^ ARRIVERS_P) + 1
-    // limit for number of recursive parfors
-#define ARRIVERS_P                      2
-    // nreducers = narrivers * REDUCERS_FRAC
-#define REDUCERS_FRAC                   1
-
-
 // sanitizer defaults ---------------------------------------------------------
 
 // Automatically enable MEMDEBUG and KEEP_BODIES for the sanitizers
diff --git a/src/precompile.c b/src/precompile.c
index be0e168c6a07c..c40e867ea699e 100644
--- a/src/precompile.c
+++ b/src/precompile.c
@@ -93,7 +93,12 @@ JL_DLLEXPORT void jl_write_compiler_output(void)
         return;
     }
 
-    jl_task_wait_empty();
+    jl_task_wait_empty(); // wait for most work to finish (except possibly finalizers)
+    jl_gc_collect(JL_GC_FULL);
+    jl_gc_collect(JL_GC_INCREMENTAL); // sweep finalizers
+    jl_task_t *ct = jl_current_task;
+    jl_gc_enable_finalizers(ct, 0); // now disable finalizers, as they could schedule more work or make other unexpected changes to reachability
+    jl_task_wait_empty(); // then make sure we are the only thread alive that could be running user code past here
 
     if (!jl_module_init_order) {
         jl_printf(JL_STDERR, "WARNING: --output requested, but no modules defined during run\n");
@@ -184,6 +189,7 @@ JL_DLLEXPORT void jl_write_compiler_output(void)
         }
     }
     JL_GC_POP();
+    jl_gc_enable_finalizers(ct, 1);
 }
 
 #ifdef __cplusplus
diff --git a/src/partr.c b/src/scheduler.c
similarity index 78%
rename from src/partr.c
rename to src/scheduler.c
index bc31b187f83e7..44ee850dbf365 100644
--- a/src/partr.c
+++ b/src/scheduler.c
@@ -29,6 +29,11 @@ static const int16_t sleeping = 1;
 // this thread is dead.
 static const int16_t sleeping_like_the_dead JL_UNUSED = 2;
 
+// a running count of how many threads are currently not_sleeping
+// plus a running count of the number of in-flight wake-ups
+// n.b. this may temporarily exceed jl_n_threads
+static _Atomic(int) nrunning = 1;
+
 // invariant: No thread is ever asleep unless sleep_check_state is sleeping (or we have a wakeup signal pending).
 // invariant: Any particular thread is not asleep unless that thread's sleep_check_state is sleeping.
 // invariant: The transition of a thread state to sleeping must be followed by a check that there wasn't work pending for it.
@@ -64,7 +69,7 @@ JL_DLLEXPORT int jl_set_task_tid(jl_task_t *task, int16_t tid) JL_NOTSAFEPOINT
     if (was == tid)
         return 1;
     if (was == -1)
-        return jl_atomic_cmpswap(&task->tid, &was, tid);
+        return jl_atomic_cmpswap(&task->tid, &was, tid) || was == tid;
     return 0;
 }
 
@@ -180,6 +185,8 @@ void jl_threadfun(void *arg)
     jl_init_stack_limits(0, &stack_lo, &stack_hi);
     // warning: this changes `jl_current_task`, so be careful not to call that from this function
     jl_task_t *ct = jl_init_root_task(ptls, stack_lo, stack_hi);
+    int wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, 1);
+    assert(wasrunning); (void)wasrunning;
     JL_GC_PROMISE_ROOTED(ct);
 
     // wait for all threads
@@ -220,7 +227,7 @@ int jl_running_under_rr(int recheck)
 
 
 //  sleep_check_after_threshold() -- if sleep_threshold ns have passed, return 1
-static int sleep_check_after_threshold(uint64_t *start_cycles)
+static int sleep_check_after_threshold(uint64_t *start_cycles) JL_NOTSAFEPOINT
 {
     JULIA_DEBUG_SLEEPWAKE( return 1 ); // hammer on the sleep/wake logic much harder
     /**
@@ -243,18 +250,31 @@ static int sleep_check_after_threshold(uint64_t *start_cycles)
     return 0;
 }
 
+static int set_not_sleeping(jl_ptls_t ptls) JL_NOTSAFEPOINT
+{
+    if (jl_atomic_load_relaxed(&ptls->sleep_check_state) != not_sleeping) {
+        if (jl_atomic_exchange_relaxed(&ptls->sleep_check_state, not_sleeping) != not_sleeping) {
+            return 1;
+        }
+    }
+    int wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, -1); // consume in-flight wakeup
+    assert(wasrunning > 1); (void)wasrunning;
+    return 0;
+}
 
 static int wake_thread(int16_t tid) JL_NOTSAFEPOINT
 {
-    jl_ptls_t other = jl_atomic_load_relaxed(&jl_all_tls_states)[tid];
-    int8_t state = sleeping;
-
-    if (jl_atomic_load_relaxed(&other->sleep_check_state) == sleeping) {
-        if (jl_atomic_cmpswap_relaxed(&other->sleep_check_state, &state, not_sleeping)) {
-            JL_PROBE_RT_SLEEP_CHECK_WAKE(other, state);
-            uv_mutex_lock(&other->sleep_lock);
-            uv_cond_signal(&other->wake_signal);
-            uv_mutex_unlock(&other->sleep_lock);
+    jl_ptls_t ptls2 = jl_atomic_load_relaxed(&jl_all_tls_states)[tid];
+
+    if (jl_atomic_load_relaxed(&ptls2->sleep_check_state) != not_sleeping) {
+        int8_t state = sleeping;
+        if (jl_atomic_cmpswap_relaxed(&ptls2->sleep_check_state, &state, not_sleeping)) {
+            int wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, 1); // increment in-flight wakeup count
+            assert(wasrunning); (void)wasrunning;
+            JL_PROBE_RT_SLEEP_CHECK_WAKE(ptls2, state);
+            uv_mutex_lock(&ptls2->sleep_lock);
+            uv_cond_signal(&ptls2->wake_signal);
+            uv_mutex_unlock(&ptls2->sleep_lock);
             return 1;
         }
     }
@@ -280,10 +300,14 @@ JL_DLLEXPORT void jl_wakeup_thread(int16_t tid) JL_NOTSAFEPOINT
     JULIA_DEBUG_SLEEPWAKE( wakeup_enter = cycleclock() );
     if (tid == self || tid == -1) {
         // we're already awake, but make sure we'll exit uv_run
+        // and that nrunning is updated if this is now considered in-flight
         jl_ptls_t ptls = ct->ptls;
-        if (jl_atomic_load_relaxed(&ptls->sleep_check_state) == sleeping) {
-            jl_atomic_store_relaxed(&ptls->sleep_check_state, not_sleeping);
-            JL_PROBE_RT_SLEEP_CHECK_WAKEUP(ptls);
+        if (jl_atomic_load_relaxed(&ptls->sleep_check_state) != not_sleeping) {
+            if (jl_atomic_exchange_relaxed(&ptls->sleep_check_state, not_sleeping) != not_sleeping) {
+                int wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, 1);
+                assert(wasrunning); (void)wasrunning;
+                JL_PROBE_RT_SLEEP_CHECK_WAKEUP(ptls);
+            }
         }
         if (uvlock == ct)
             uv_stop(jl_global_event_loop());
@@ -360,8 +384,10 @@ void jl_task_wait_empty(void)
         // we are back from jl_task_get_next now
         ct->world_age = lastage;
         wait_empty = NULL;
-        // TODO: move this lock acquire-release pair to the caller, so that we ensure new work
-        // (from uv_unref objects) didn't unexpectedly get scheduled and start running behind our back
+        // TODO: move this lock acquire to before the wait_empty return and the
+        // unlock to the caller, so that we ensure new work (from uv_unref
+        // objects) didn't unexpectedly get scheduled and start running behind
+        // our back during the function return
         JL_UV_LOCK();
         jl_wait_empty_end();
         JL_UV_UNLOCK();
@@ -378,6 +404,7 @@ static int may_sleep(jl_ptls_t ptls) JL_NOTSAFEPOINT
     return jl_atomic_load_relaxed(&ptls->sleep_check_state) == sleeping;
 }
 
+
 extern _Atomic(unsigned) _threadedregion;
 
 JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q, jl_value_t *checkempty)
@@ -405,8 +432,7 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
             jl_fence(); // [^store_buffering_1]
             JL_PROBE_RT_SLEEP_CHECK_SLEEP(ptls);
             if (!check_empty(checkempty)) { // uses relaxed loads
-                if (jl_atomic_load_relaxed(&ptls->sleep_check_state) != not_sleeping) {
-                    jl_atomic_store_relaxed(&ptls->sleep_check_state, not_sleeping); // let other threads know they don't need to wake us
+                if (set_not_sleeping(ptls)) {
                     JL_PROBE_RT_SLEEP_CHECK_TASKQ_WAKE(ptls);
                 }
                 continue;
@@ -415,8 +441,7 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
             if (ptls != ct->ptls) {
                 // sigh, a yield was detected, so let's go ahead and handle it anyway by starting over
                 ptls = ct->ptls;
-                if (jl_atomic_load_relaxed(&ptls->sleep_check_state) != not_sleeping) {
-                    jl_atomic_store_relaxed(&ptls->sleep_check_state, not_sleeping); // let other threads know they don't need to wake us
+                if (set_not_sleeping(ptls)) {
                     JL_PROBE_RT_SLEEP_CHECK_TASK_WAKE(ptls);
                 }
                 if (task)
@@ -424,14 +449,12 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
                 continue;
             }
             if (task) {
-                if (jl_atomic_load_relaxed(&ptls->sleep_check_state) != not_sleeping) {
-                    jl_atomic_store_relaxed(&ptls->sleep_check_state, not_sleeping); // let other threads know they don't need to wake us
+                if (set_not_sleeping(ptls)) {
                     JL_PROBE_RT_SLEEP_CHECK_TASK_WAKE(ptls);
                 }
                 return task;
             }
 
-
             // IO is always permitted, but outside a threaded region, only
             // thread 0 will process messages.
             // Inside a threaded region, any thread can listen for IO messages,
@@ -485,14 +508,16 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
                 // right back to sleep on the individual wake signal to let
                 // them take it from us without conflict.
                 if (active || !may_sleep(ptls)) {
+                    if (set_not_sleeping(ptls)) {
+                        JL_PROBE_RT_SLEEP_CHECK_UV_WAKE(ptls);
+                    }
                     start_cycles = 0;
                     continue;
                 }
                 if (!enter_eventloop && !jl_atomic_load_relaxed(&_threadedregion) && ptls->tid == 0) {
                     // thread 0 is the only thread permitted to run the event loop
                     // so it needs to stay alive, just spin-looping if necessary
-                    if (jl_atomic_load_relaxed(&ptls->sleep_check_state) != not_sleeping) {
-                        jl_atomic_store_relaxed(&ptls->sleep_check_state, not_sleeping); // let other threads know they don't need to wake us
+                    if (set_not_sleeping(ptls)) {
                         JL_PROBE_RT_SLEEP_CHECK_UV_WAKE(ptls);
                     }
                     start_cycles = 0;
@@ -500,26 +525,47 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
                 }
             }
 
+            // any thread which wants us running again will have to observe
+            // sleep_check_state==sleeping and increment nrunning for us
+            int wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, -1);
+            assert(wasrunning);
+            if (wasrunning == 1) {
+                // This was the last running thread, and there is no thread with !may_sleep
+                // so make sure tid 0 is notified to check wait_empty
+                // TODO: this also might be a good time to check again that
+                // libuv's queue is truly empty, instead of during delete_thread
+                if (ptls->tid != 0) {
+                    uv_mutex_lock(&ptls->sleep_lock);
+                    uv_cond_wait(&ptls->wake_signal, &ptls->sleep_lock);
+                    uv_mutex_unlock(&ptls->sleep_lock);
+                }
+            }
+
             // the other threads will just wait for an individual wake signal to resume
             JULIA_DEBUG_SLEEPWAKE( ptls->sleep_enter = cycleclock() );
             int8_t gc_state = jl_gc_safe_enter(ptls);
             uv_mutex_lock(&ptls->sleep_lock);
             while (may_sleep(ptls)) {
-                if (ptls->tid == 0 && wait_empty) {
-                    task = wait_empty;
-                    if (jl_atomic_load_relaxed(&ptls->sleep_check_state) != not_sleeping) {
-                        jl_atomic_store_relaxed(&ptls->sleep_check_state, not_sleeping); // let other threads know they don't need to wake us
-                        JL_PROBE_RT_SLEEP_CHECK_TASK_WAKE(ptls);
-                    }
+                task = wait_empty;
+                if (ptls->tid == 0 && task && jl_atomic_load_relaxed(&nrunning) == 0) {
+                    wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, 1);
+                    assert(!wasrunning);
+                    wasrunning = !set_not_sleeping(ptls);
+                    assert(!wasrunning);
+                    JL_PROBE_RT_SLEEP_CHECK_TASK_WAKE(ptls);
+                    if (!ptls->finalizers_inhibited)
+                        ptls->finalizers_inhibited++; // this annoyingly is rather sticky (we should like to reset it at the end of jl_task_wait_empty)
                     break;
                 }
+                // else should we warn the user of certain deadlock here if tid == 0 && nrunning == 0?
                 uv_cond_wait(&ptls->wake_signal, &ptls->sleep_lock);
             }
             assert(jl_atomic_load_relaxed(&ptls->sleep_check_state) == not_sleeping);
+            assert(jl_atomic_load_relaxed(&nrunning));
+            start_cycles = 0;
             uv_mutex_unlock(&ptls->sleep_lock);
             JULIA_DEBUG_SLEEPWAKE( ptls->sleep_leave = cycleclock() );
             jl_gc_safe_leave(ptls, gc_state); // contains jl_gc_safepoint
-            start_cycles = 0;
             if (task) {
                 assert(task == wait_empty);
                 wait_empty = NULL;
@@ -533,6 +579,23 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
     }
 }
 
+void scheduler_delete_thread(jl_ptls_t ptls) JL_NOTSAFEPOINT
+{
+    if (jl_atomic_exchange_relaxed(&ptls->sleep_check_state, sleeping_like_the_dead) != sleeping) {
+        int wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, -1);
+        if (wasrunning == 1) {
+            jl_ptls_t ptls2 = jl_atomic_load_relaxed(&jl_all_tls_states)[0];
+            // This was the last running thread, and there is no thread with !may_sleep
+            // so make sure tid 0 is notified to check wait_empty
+            uv_mutex_lock(&ptls2->sleep_lock);
+            uv_cond_signal(&ptls2->wake_signal);
+            uv_mutex_unlock(&ptls2->sleep_lock);
+        }
+    }
+    jl_fence();
+    jl_wakeup_thread(0); // force thread 0 to see that we do not have the IO lock (and am dead)
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/staticdata.c b/src/staticdata.c
index f08b59828dfbd..29e5d0eea3338 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -643,7 +643,7 @@ static int jl_needs_serialization(jl_serializer_state *s, jl_value_t *v) JL_NOTS
     else if (jl_typetagis(v, jl_uint8_tag << 4)) {
         return 0;
     }
-    else if (jl_typetagis(v, jl_task_tag << 4)) {
+    else if (v == (jl_value_t*)s->ptls->root_task) {
         return 0;
     }
 
diff --git a/src/threading.c b/src/threading.c
index e20e7cbf80f26..f0ee5cca363ea 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -434,6 +434,7 @@ JL_DLLEXPORT jl_gcframe_t **jl_adopt_thread(void)
 }
 
 void jl_task_frame_noreturn(jl_task_t *ct) JL_NOTSAFEPOINT;
+void scheduler_delete_thread(jl_ptls_t ptls) JL_NOTSAFEPOINT;
 
 static void jl_delete_thread(void *value) JL_NOTSAFEPOINT_ENTER
 {
@@ -444,9 +445,7 @@ static void jl_delete_thread(void *value) JL_NOTSAFEPOINT_ENTER
     // safepoint until GC exit, in case GC was running concurrently while in
     // prior unsafe-region (before we let it release the stack memory)
     (void)jl_gc_unsafe_enter(ptls);
-    jl_atomic_store_relaxed(&ptls->sleep_check_state, 2); // dead, interpreted as sleeping and unwakeable
-    jl_fence();
-    jl_wakeup_thread(0); // force thread 0 to see that we do not have the IO lock (and am dead)
+    scheduler_delete_thread(ptls);
     // try to free some state we do not need anymore
 #ifndef _OS_WINDOWS_
     void *signal_stack = ptls->signal_stack;

From 8cf7598ebd0c120f50db2f5d6bbd091855a4836c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Drvo=C5=A1t=C4=9Bp?=
 <tomas.drvostep@gmail.com>
Date: Mon, 11 Dec 2023 18:25:46 +0100
Subject: [PATCH 0420/1315] Make `jl_write_coverage_data` dllexported again
 (#52456)

Closes #52452
---
 src/coverage.cpp     | 2 +-
 src/julia_internal.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/coverage.cpp b/src/coverage.cpp
index 3d3b3bc734eaa..100a4c66322bd 100644
--- a/src/coverage.cpp
+++ b/src/coverage.cpp
@@ -192,7 +192,7 @@ static void write_lcov_data(logdata_t &logData, const std::string &outfile)
     outf.close();
 }
 
-extern "C" void jl_write_coverage_data(const char *output)
+extern "C" JL_DLLEXPORT void jl_write_coverage_data(const char *output)
 {
     if (output) {
         StringRef output_pattern(output);
diff --git a/src/julia_internal.h b/src/julia_internal.h
index e18aa084d0f08..6890f03dcce1d 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1635,7 +1635,7 @@ JL_DLLEXPORT enum jl_memory_order jl_get_atomic_order_checked(jl_sym_t *order, c
 
 struct _jl_image_fptrs_t;
 
-void jl_write_coverage_data(const char*);
+JL_DLLEXPORT void jl_write_coverage_data(const char*);
 void jl_write_malloc_log(void);
 
 #if jl_has_builtin(__builtin_unreachable) || defined(_COMPILER_GCC_) || defined(_COMPILER_INTEL_)

From 2deff4dba1726cf1251bf6b85f7dee49794789b3 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 25 Nov 2023 09:44:35 -0500
Subject: [PATCH 0421/1315] ircode: deduplicate Strings during deserialize
 instead of waiting for codegen

---
 src/ircode.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/ircode.c b/src/ircode.c
index 388b3b4904217..b238e79a239ff 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -104,6 +104,8 @@ static void jl_encode_as_indexed_root(jl_ircode_state *s, jl_value_t *v)
 {
     rle_reference rr;
 
+    if (jl_is_string(v))
+        v = jl_as_global_root(v, 1);
     literal_val_id(&rr, s, v);
     int id = rr.index;
     assert(id >= 0);

From 3c2c5ce2ad5ae8a2a1944b3df495a3b2bba7f344 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 8 Nov 2023 13:44:21 -0500
Subject: [PATCH 0422/1315] jltypes: try to reduce duplicate objects in type
 parameters

We have this fairly small global cache of objects, so try to
de-duplicate some other global objects with it.
---
 doc/src/devdocs/locks.md |  3 +-
 src/codegen.cpp          | 10 ++++--
 src/debuginfo.cpp        |  3 +-
 src/gc.c                 |  8 ++---
 src/jltypes.c            | 72 ++++++++++++++++++++++++++--------------
 src/julia.h              |  4 +--
 src/julia_internal.h     |  6 ++--
 src/staticdata.c         | 48 +++++++++++++++++++++------
 8 files changed, 105 insertions(+), 49 deletions(-)

diff --git a/doc/src/devdocs/locks.md b/doc/src/devdocs/locks.md
index 33947035f51a0..f79f4f2b1e3e3 100644
--- a/doc/src/devdocs/locks.md
+++ b/doc/src/devdocs/locks.md
@@ -41,7 +41,7 @@ The following are definitely leaf locks (level 1), and must not try to acquire a
 
 The following is a leaf lock (level 2), and only acquires level 1 locks (safepoint) internally:
 
->   * typecache
+>   * global_roots_lock
 >   * Module->lock
 >   * JLDebuginfoPlugin::PluginMutex
 >   * newly_inferred_mutex
@@ -49,6 +49,7 @@ The following is a leaf lock (level 2), and only acquires level 1 locks (safepoi
 The following is a level 3 lock, which can only acquire level 1 or level 2 locks internally:
 
 >   * Method->writelock
+>   * typecache
 
 The following is a level 4 lock, which can only recurse to acquire level 1, 2, or 3 locks:
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 53c3561c50039..a5615cbdb013d 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -3064,7 +3064,7 @@ static jl_value_t *jl_ensure_rooted(jl_codectx_t &ctx, jl_value_t *val)
         }
         JL_UNLOCK(&m->writelock);
     }
-    return jl_as_global_root(val);
+    return jl_as_global_root(val, 1);
 }
 
 // --- generating function calls ---
@@ -4241,7 +4241,9 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
             // don't bother codegen constant-folding for toplevel.
             jl_value_t *ty = static_apply_type(ctx, argv, nargs + 1);
             if (ty != NULL) {
+                JL_GC_PUSH1(&ty);
                 ty = jl_ensure_rooted(ctx, ty);
+                JL_GC_POP();
                 *ret = mark_julia_const(ctx, ty);
                 return true;
             }
@@ -5848,7 +5850,9 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
                 JL_CATCH {
                     jl_value_t *e = jl_current_exception();
                     // errors. boo. :(
-                    e = jl_as_global_root(e);
+                    JL_GC_PUSH1(&e);
+                    e = jl_as_global_root(e, 1);
+                    JL_GC_POP();
                     raise_exception(ctx, literal_pointer_val(ctx, e));
                     return ghostValue(ctx, jl_nothing_type);
                 }
@@ -6994,7 +6998,9 @@ static jl_cgval_t emit_cfunction(jl_codectx_t &ctx, jl_value_t *output_type, con
             for (size_t i = 0; i < n; i++) {
                 jl_svecset(fill_i, i, jl_array_ptr_ref(closure_types, i));
             }
+            JL_GC_PUSH1(&fill_i);
             fill = (jl_svec_t*)jl_ensure_rooted(ctx, (jl_value_t*)fill_i);
+            JL_GC_POP();
         }
         Type *T_htable = ArrayType::get(ctx.types().T_size, sizeof(htable_t) / sizeof(void*));
         Value *cache = new GlobalVariable(*jl_Module, T_htable, false,
diff --git a/src/debuginfo.cpp b/src/debuginfo.cpp
index e8ab8507761fd..b2b4743962fc0 100644
--- a/src/debuginfo.cpp
+++ b/src/debuginfo.cpp
@@ -374,12 +374,13 @@ void JITDebugInfoRegistry::registerJITObject(const object::ObjectFile &Object,
         }
         jl_method_instance_t *mi = NULL;
         if (codeinst) {
+            JL_GC_PROMISE_ROOTED(codeinst);
             mi = codeinst->def;
             // Non-opaque-closure MethodInstances are considered globally rooted
             // through their methods, but for OC, we need to create a global root
             // here.
             if (jl_is_method(mi->def.value) && mi->def.method->is_for_opaque_closure)
-                mi = (jl_method_instance_t*)jl_as_global_root((jl_value_t*)mi);
+                mi = (jl_method_instance_t*)jl_as_global_root((jl_value_t*)mi, 1);
         }
         jl_profile_atomic([&]() JL_NOTSAFEPOINT {
             if (mi)
diff --git a/src/gc.c b/src/gc.c
index 508ab0062f187..17975a075dea4 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1915,6 +1915,10 @@ STATIC_INLINE void gc_mark_push_remset(jl_ptls_t ptls, jl_value_t *obj,
 // Push a work item to the queue
 STATIC_INLINE void gc_ptr_queue_push(jl_gc_markqueue_t *mq, jl_value_t *obj) JL_NOTSAFEPOINT
 {
+#ifdef JL_DEBUG_BUILD
+    if (obj == gc_findval)
+        jl_raise_debugger();
+#endif
     ws_array_t *old_a = ws_queue_push(&mq->ptr_queue, &obj, sizeof(jl_value_t*));
     // Put `old_a` in `reclaim_set` to be freed after the mark phase
     if (__unlikely(old_a != NULL))
@@ -2531,10 +2535,6 @@ FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_
 {
     jl_value_t *new_obj = (jl_value_t *)_new_obj;
     mark_obj: {
-    #ifdef JL_DEBUG_BUILD
-        if (new_obj == gc_findval)
-            jl_raise_debugger();
-    #endif
         jl_taggedvalue_t *o = jl_astaggedvalue(new_obj);
         uintptr_t vtag = o->header & ~(uintptr_t)0xf;
         uint8_t bits = (gc_old(o->header) && !mark_reset_age) ? GC_OLD_MARKED : GC_MARKED;
diff --git a/src/jltypes.c b/src/jltypes.c
index dddf88aececac..7fb7a6dc13eb5 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -1457,7 +1457,7 @@ JL_EXTENSION struct _jl_typestack_t {
 };
 
 static jl_value_t *inst_type_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_t *stack, int check);
-static jl_svec_t *inst_ftypes(jl_svec_t *p, jl_typeenv_t *env, jl_typestack_t *stack);
+static jl_svec_t *inst_ftypes(jl_svec_t *p, jl_typeenv_t *env, jl_typestack_t *stack, int cacheable);
 
 JL_DLLEXPORT jl_value_t *jl_instantiate_unionall(jl_unionall_t *u, jl_value_t *p)
 {
@@ -1729,7 +1729,7 @@ static void check_datatype_parameters(jl_typename_t *tn, jl_value_t **params, si
     JL_GC_POP();
 }
 
-jl_value_t *extract_wrapper(jl_value_t *t JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT JL_GLOBALLY_ROOTED
+static jl_value_t *extract_wrapper(jl_value_t *t JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT JL_GLOBALLY_ROOTED
 {
     t = jl_unwrap_unionall(t);
     if (jl_is_datatype(t))
@@ -1744,7 +1744,7 @@ jl_value_t *extract_wrapper(jl_value_t *t JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT JL
     return NULL;
 }
 
-int _may_substitute_ub(jl_value_t *v, jl_tvar_t *var, int inside_inv, int *cov_count) JL_NOTSAFEPOINT
+static int _may_substitute_ub(jl_value_t *v, jl_tvar_t *var, int inside_inv, int *cov_count) JL_NOTSAFEPOINT
 {
     while (1) {
         if (v == (jl_value_t*)var) {
@@ -2008,24 +2008,18 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
         }
     }
 
-    // move array of instantiated parameters to heap; we need to keep it
-    if (p == NULL) {
-        p = jl_alloc_svec_uninit(ntp);
-        for (size_t i = 0; i < ntp; i++)
-            jl_svecset(p, i, iparams[i]);
-    }
-
     // try to simplify some type parameters
     if (check && tn != jl_type_typename) {
-        size_t i;
         int changed = 0;
         if (istuple) // normalization might change Tuple's, but not other types's, cacheable status
             cacheable = 1;
+        size_t i;
         for (i = 0; i < ntp; i++) {
-            jl_value_t *newp = normalize_unionalls(iparams[i]);
-            if (newp != iparams[i]) {
+            jl_value_t *pi = iparams[i];
+            jl_value_t *newp = normalize_unionalls(pi);
+            if (newp != pi) {
                 iparams[i] = newp;
-                jl_svecset(p, i, newp);
+                if (p) jl_gc_wb(p, newp);
                 changed = 1;
             }
             if (istuple && cacheable && !jl_is_concrete_type(newp))
@@ -2051,12 +2045,39 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
         }
     }
 
+    // try to reduce duplication in objects (if the caller didn't already check) by
+    // comparing them against a list of objects already known to be globally rooted and
+    // swapping them as possible
+    if (check && jl_global_roots_list != NULL) {
+        for (size_t i = 0; i < ntp; i++) {
+            jl_value_t *pi = iparams[i];
+            if (cacheable || !jl_has_free_typevars(pi)) {
+                pi = jl_as_global_root(pi, cacheable);
+                if (pi != NULL) {
+                    iparams[i] = pi;
+                    if (p) jl_gc_wb(p, pi);
+                }
+            }
+        }
+    }
+
+    // move array of instantiated parameters to heap; we need to keep it
+    if (p == NULL) {
+        p = jl_alloc_svec_uninit(ntp);
+        for (size_t i = 0; i < ntp; i++) {
+            jl_svecset(p, i, iparams[i]);
+        }
+    }
+
+    ndt = jl_new_uninitialized_datatype();
+
+    // now that most allocations are done
     // acquire the write lock now that we know we need a new object
     // since we're going to immediately leak it globally via the instantiation stack
     if (cacheable) {
         JL_LOCK(&typecache_lock); // Might GC
         jl_value_t *lkup = (jl_value_t*)lookup_type(tn, iparams, ntp);
-        if (lkup != NULL) {
+        if (lkup) {
             JL_UNLOCK(&typecache_lock); // Might GC
             JL_GC_POP();
             return lkup;
@@ -2064,7 +2085,6 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
     }
 
     // create and initialize new type
-    ndt = jl_new_uninitialized_datatype();
     ndt->isprimitivetype = dt->isprimitivetype;
     // Usually dt won't have ismutationfree set at this point, but it is
     // overridden for `Type`, which we handle here.
@@ -2152,9 +2172,9 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
         else if (cacheable) {
             // recursively instantiate the types of the fields
             if (dt->types == NULL)
-                ndt->types = jl_compute_fieldtypes(ndt, stack);
+                ndt->types = jl_compute_fieldtypes(ndt, stack, cacheable);
             else
-                ndt->types = inst_ftypes(ftypes, env, stack);
+                ndt->types = inst_ftypes(ftypes, env, stack, cacheable);
             jl_gc_wb(ndt, ndt->types);
         }
     }
@@ -2221,14 +2241,15 @@ jl_tupletype_t *jl_inst_arg_tuple_type(jl_value_t *arg1, jl_value_t **args, size
     return tt;
 }
 
-static jl_svec_t *inst_ftypes(jl_svec_t *p, jl_typeenv_t *env, jl_typestack_t *stack)
+static jl_svec_t *inst_ftypes(jl_svec_t *p, jl_typeenv_t *env, jl_typestack_t *stack, int cacheable)
 {
     size_t i;
     size_t lp = jl_svec_len(p);
     jl_svec_t *np = jl_alloc_svec(lp);
-    JL_GC_PUSH1(&np);
+    jl_value_t *pi = NULL;
+    JL_GC_PUSH2(&np, &pi);
     for (i = 0; i < lp; i++) {
-        jl_value_t *pi = jl_svecref(p, i);
+        pi = jl_svecref(p, i);
         JL_TRY {
             pi = inst_type_w_(pi, env, stack, 1);
             if (!jl_is_type(pi) && !jl_is_typevar(pi)) {
@@ -2238,7 +2259,8 @@ static jl_svec_t *inst_ftypes(jl_svec_t *p, jl_typeenv_t *env, jl_typestack_t *s
         JL_CATCH {
             pi = jl_bottom_type;
         }
-        jl_svecset(np, i, pi);
+        jl_value_t *globalpi = jl_as_global_root(pi, cacheable);
+        jl_svecset(np, i, globalpi ? globalpi : pi);
     }
     JL_GC_POP();
     return np;
@@ -2485,7 +2507,7 @@ jl_vararg_t *jl_wrap_vararg(jl_value_t *t, jl_value_t *n, int check)
     return vm;
 }
 
-JL_DLLEXPORT jl_svec_t *jl_compute_fieldtypes(jl_datatype_t *st JL_PROPAGATES_ROOT, void *stack)
+JL_DLLEXPORT jl_svec_t *jl_compute_fieldtypes(jl_datatype_t *st JL_PROPAGATES_ROOT, void *stack, int cacheable)
 {
     assert(st->name != jl_namedtuple_typename && st->name != jl_tuple_typename);
     jl_datatype_t *wt = (jl_datatype_t*)jl_unwrap_unionall(st->name->wrapper);
@@ -2505,7 +2527,7 @@ JL_DLLEXPORT jl_svec_t *jl_compute_fieldtypes(jl_datatype_t *st JL_PROPAGATES_RO
     jl_typestack_t top;
     top.tt = st;
     top.prev = (jl_typestack_t*)stack;
-    st->types = inst_ftypes(wt->types, &env[n - 1], &top);
+    st->types = inst_ftypes(wt->types, &env[n - 1], &top, cacheable);
     jl_gc_wb(st, st->types);
     return st->types;
 }
@@ -2553,7 +2575,7 @@ void jl_reinstantiate_inner_types(jl_datatype_t *t) // can throw!
             for (i = 0; i < n; i++)
                 env[i].val = jl_svecref(ndt->parameters, i);
             assert(ndt->types == NULL);
-            ndt->types = inst_ftypes(t->types, &env[n - 1], &top);
+            ndt->types = inst_ftypes(t->types, &env[n - 1], &top, 1);
             jl_gc_wb(ndt, ndt->types);
             if (ndt->isconcretetype) { // cacheable
                 jl_compute_field_offsets(ndt);
diff --git a/src/julia.h b/src/julia.h
index bc2e3c7335f1a..7b148ecbec55d 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1297,8 +1297,8 @@ STATIC_INLINE void jl_array_uint32_set(void *a, size_t i, uint32_t x) JL_NOTSAFE
 #define jl_gf_name(f)   (jl_gf_mtable(f)->name)
 
 // struct type info
-JL_DLLEXPORT jl_svec_t *jl_compute_fieldtypes(jl_datatype_t *st JL_PROPAGATES_ROOT, void *stack);
-#define jl_get_fieldtypes(st) ((st)->types ? (st)->types : jl_compute_fieldtypes((st), NULL))
+JL_DLLEXPORT jl_svec_t *jl_compute_fieldtypes(jl_datatype_t *st JL_PROPAGATES_ROOT, void *stack, int cacheable);
+#define jl_get_fieldtypes(st) ((st)->types ? (st)->types : jl_compute_fieldtypes((st), NULL, 0))
 STATIC_INLINE jl_svec_t *jl_field_names(jl_datatype_t *st) JL_NOTSAFEPOINT
 {
     return st->name->names;
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 6890f03dcce1d..9105a291ac82b 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -726,7 +726,7 @@ jl_svec_t *jl_outer_unionall_vars(jl_value_t *u);
 jl_value_t *jl_type_intersection_env_s(jl_value_t *a, jl_value_t *b, jl_svec_t **penv, int *issubty);
 jl_value_t *jl_type_intersection_env(jl_value_t *a, jl_value_t *b, jl_svec_t **penv);
 int jl_subtype_matching(jl_value_t *a, jl_value_t *b, jl_svec_t **penv);
-JL_DLLEXPORT int jl_types_egal(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT int jl_types_egal(jl_value_t *a, jl_value_t *b) JL_NOTSAFEPOINT;
 // specificity comparison assuming !(a <: b) and !(b <: a)
 JL_DLLEXPORT int jl_type_morespecific_no_subtype(jl_value_t *a, jl_value_t *b);
 jl_value_t *jl_instantiate_type_with(jl_value_t *t, jl_value_t **env, size_t n);
@@ -808,7 +808,7 @@ extern JL_DLLEXPORT jl_module_t *jl_precompile_toplevel_module JL_GLOBALLY_ROOTE
 extern jl_genericmemory_t *jl_global_roots_list JL_GLOBALLY_ROOTED;
 extern jl_genericmemory_t *jl_global_roots_keyset JL_GLOBALLY_ROOTED;
 JL_DLLEXPORT int jl_is_globally_rooted(jl_value_t *val JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT;
-JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val JL_MAYBE_UNROOTED);
+JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val, int insert) JL_GLOBALLY_ROOTED;
 
 jl_opaque_closure_t *jl_new_opaque_closure(jl_tupletype_t *argt, jl_value_t *rt_lb, jl_value_t *rt_ub,
     jl_value_t *source,  jl_value_t **env, size_t nenv, int do_compile);
@@ -1430,7 +1430,7 @@ void smallintset_empty(const jl_genericmemory_t *a) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT jl_genericmemory_t *jl_idset_rehash(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, size_t newsz);
 JL_DLLEXPORT ssize_t jl_idset_peek_bp(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT;
-jl_value_t *jl_idset_get(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT;
+jl_value_t *jl_idset_get(jl_genericmemory_t *keys JL_PROPAGATES_ROOT, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_genericmemory_t *jl_idset_put_key(jl_genericmemory_t *keys, jl_value_t *key, ssize_t *newidx);
 JL_DLLEXPORT jl_genericmemory_t *jl_idset_put_idx(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, ssize_t idx);
 JL_DLLEXPORT ssize_t jl_idset_pop(jl_genericmemory_t *keys, jl_genericmemory_t *idxs, jl_value_t *key) JL_NOTSAFEPOINT;
diff --git a/src/staticdata.c b/src/staticdata.c
index 29e5d0eea3338..8befca1d93414 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -2230,8 +2230,9 @@ static void jl_root_new_gvars(jl_serializer_state *s, jl_image_t *image, uint32_
         uintptr_t v = *gv;
         if (i < external_fns_begin) {
             if (!jl_is_binding(v))
-                v = (uintptr_t)jl_as_global_root((jl_value_t*)v);
-        } else {
+                v = (uintptr_t)jl_as_global_root((jl_value_t*)v, 1);
+        }
+        else {
             jl_code_instance_t *codeinst = (jl_code_instance_t*) v;
             assert(codeinst && (jl_atomic_load_relaxed(&codeinst->specsigflags) & 0b01) && jl_atomic_load_relaxed(&codeinst->specptr.fptr));
             v = (uintptr_t)jl_atomic_load_relaxed(&codeinst->specptr.fptr);
@@ -2430,7 +2431,13 @@ jl_mutex_t global_roots_lock;
 
 JL_DLLEXPORT int jl_is_globally_rooted(jl_value_t *val JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT
 {
-    if (jl_is_concrete_type(val) || jl_is_bool(val) || jl_is_symbol(val) ||
+    if (jl_is_datatype(val)) {
+        jl_datatype_t *dt = (jl_datatype_t*)val;
+        if (jl_unwrap_unionall(dt->name->wrapper) == val)
+            return 1;
+        return (jl_is_tuple_type(val) ? dt->isconcretetype : !dt->hasfreetypevars); // aka is_cacheable from jltypes.c
+    }
+    if (jl_is_bool(val) || jl_is_symbol(val) ||
             val == (jl_value_t*)jl_any_type || val == (jl_value_t*)jl_bottom_type || val == (jl_value_t*)jl_core_module)
         return 1;
     if (val == ((jl_datatype_t*)jl_typeof(val))->instance)
@@ -2438,10 +2445,21 @@ JL_DLLEXPORT int jl_is_globally_rooted(jl_value_t *val JL_MAYBE_UNROOTED) JL_NOT
     return 0;
 }
 
-JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val JL_MAYBE_UNROOTED)
+static jl_value_t *extract_wrapper(jl_value_t *t JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT JL_GLOBALLY_ROOTED
+{
+    t = jl_unwrap_unionall(t);
+    if (jl_is_datatype(t))
+        return ((jl_datatype_t*)t)->name->wrapper;
+    return NULL;
+}
+
+JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val, int insert)
 {
     if (jl_is_globally_rooted(val))
         return val;
+    jl_value_t *tw = extract_wrapper(val);
+    if (tw && (val == tw || jl_types_egal(val, tw)))
+        return tw;
     if (jl_is_uint8(val))
         return jl_box_uint8(jl_unbox_uint8(val));
     if (jl_is_int32(val)) {
@@ -2454,20 +2472,24 @@ JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val JL_MAYBE_UNROOTED)
         if ((uint64_t)(n+512) < 1024)
             return jl_box_int64(n);
     }
-    // TODO: check table before acquiring lock to reduce writer contention
-    JL_GC_PUSH1(&val);
-    JL_LOCK(&global_roots_lock);
+    // check table before acquiring lock to reduce writer contention
     jl_value_t *rval = jl_idset_get(jl_global_roots_list, jl_global_roots_keyset, val);
+    if (rval)
+        return rval;
+    JL_LOCK(&global_roots_lock);
+    rval = jl_idset_get(jl_global_roots_list, jl_global_roots_keyset, val);
     if (rval) {
         val = rval;
     }
-    else {
+    else if (insert) {
         ssize_t idx;
         jl_global_roots_list = jl_idset_put_key(jl_global_roots_list, val, &idx);
         jl_global_roots_keyset = jl_idset_put_idx(jl_global_roots_list, jl_global_roots_keyset, idx);
     }
+    else {
+        val = NULL;
+    }
     JL_UNLOCK(&global_roots_lock);
-    JL_GC_POP();
     return val;
 }
 
@@ -2606,6 +2628,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
         }
     }
     jl_genericmemory_t *global_roots_list = NULL;
+    jl_genericmemory_t *global_roots_keyset = NULL;
 
     { // step 1: record values (recursively) that need to go in the image
         size_t i;
@@ -2652,14 +2675,17 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
         // step 1.3: prune (garbage collect) special weak references from the jl_global_roots_list
         if (worklist == NULL) {
             global_roots_list = jl_alloc_memory_any(0);
+            global_roots_keyset = jl_alloc_memory_any(0);
             for (size_t i = 0; i < jl_global_roots_list->length; i++) {
                 jl_value_t *val = jl_genericmemory_ptr_ref(jl_global_roots_list, i);
                 if (val && ptrhash_get(&serialization_order, val) != HT_NOTFOUND) {
                     ssize_t idx;
                     global_roots_list = jl_idset_put_key(global_roots_list, val, &idx);
+                    global_roots_keyset = jl_idset_put_idx(global_roots_list, global_roots_keyset, idx);
                 }
             }
             jl_queue_for_serialization(&s, global_roots_list);
+            jl_queue_for_serialization(&s, global_roots_keyset);
             jl_serialize_reachable(&s);
         }
         // step 1.4: prune (garbage collect) some special weak references from
@@ -2772,6 +2798,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
                 jl_write_value(&s, tag);
             }
             jl_write_value(&s, global_roots_list);
+            jl_write_value(&s, global_roots_keyset);
             jl_write_value(&s, s.ptls->root_task->tls);
             write_uint32(f, jl_get_gs_ctr());
             write_uint(f, jl_atomic_load_acquire(&jl_world_counter));
@@ -3083,6 +3110,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
 #undef XX
         export_jl_small_typeof();
         jl_global_roots_list = (jl_genericmemory_t*)jl_read_value(&s);
+        jl_global_roots_keyset = (jl_genericmemory_t*)jl_read_value(&s);
         // set typeof extra-special values now that we have the type set by tags above
         jl_astaggedvalue(jl_nothing)->header = (uintptr_t)jl_nothing_type | jl_astaggedvalue(jl_nothing)->header;
         s.ptls->root_task->tls = jl_read_value(&s);
@@ -3380,8 +3408,6 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         o->bits.in_image = 1;
     }
     arraylist_free(&cleanup_list);
-    if (!s.incremental && jl_global_roots_list->length > 0)
-        jl_global_roots_keyset = jl_idset_put_idx(jl_global_roots_list, (jl_genericmemory_t*)jl_an_empty_memory_any, -jl_global_roots_list->length);
     for (size_t i = 0; i < s.fixup_objs.len; i++) {
         uintptr_t item = (uintptr_t)s.fixup_objs.items[i];
         jl_value_t *obj = (jl_value_t*)(image_base + item);

From b71523e9b8de47fcefcea50e78bd336f2bf2a265 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 11 Dec 2023 12:36:47 -0500
Subject: [PATCH 0423/1315] combine reduce_empty methods for Union{} eltypes
 (#51948)

With #49470, these can all be dispatched to the same method now,
avoiding unnecessary code duplication for this case.
---
 base/errorshow.jl |  7 ++-----
 base/reduce.jl    | 17 +++++++----------
 test/reduce.jl    | 12 +++++-------
 3 files changed, 14 insertions(+), 22 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index 0440e2073ead0..24663604f1a74 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -254,7 +254,6 @@ function showerror(io::IO, ex::MethodError)
         return showerror_ambiguous(io, meth, f, arg_types)
     end
     arg_types_param::SimpleVector = arg_types.parameters
-    show_candidates = true
     print(io, "MethodError: ")
     ft = typeof(f)
     f_is_function = false
@@ -270,9 +269,6 @@ function showerror(io::IO, ex::MethodError)
     if f === Base.convert && length(arg_types_param) == 2 && !is_arg_types
         f_is_function = true
         show_convert_error(io, ex, arg_types_param)
-    elseif f === mapreduce_empty || f === reduce_empty
-        print(io, "reducing over an empty collection is not allowed; consider supplying `init` to the reducer")
-        show_candidates = false
     elseif isempty(methods(f)) && isa(f, DataType) && isabstracttype(f)
         print(io, "no constructors have been defined for ", f)
     elseif isempty(methods(f)) && !isa(f, Function) && !isa(f, Type)
@@ -346,11 +342,12 @@ function showerror(io::IO, ex::MethodError)
         end
     end
     Experimental.show_error_hints(io, ex, arg_types_param, kwargs)
-    show_candidates && try
+    try
         show_method_candidates(io, ex, kwargs)
     catch ex
         @error "Error showing method candidates, aborted" exception=ex,catch_backtrace()
     end
+    nothing
 end
 
 striptype(::Type{T}) where {T} = T
diff --git a/base/reduce.jl b/base/reduce.jl
index f9411f8b5d783..6a0d46c61fcd9 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -316,10 +316,11 @@ pairwise_blocksize(::typeof(abs2), ::typeof(+)) = 4096
 
 
 # handling empty arrays
-_empty_reduce_error() = throw(ArgumentError("reducing over an empty collection is not allowed"))
-_empty_reduce_error(@nospecialize(f), @nospecialize(T::Type)) = throw(ArgumentError("""
-    reducing with $f over an empty collection of element type $T is not allowed.
-    You may be able to prevent this error by supplying an `init` value to the reducer."""))
+_empty_reduce_error() = throw(ArgumentError("reducing over an empty collection is not allowed; consider supplying `init` to the reducer"))
+reduce_empty(f, T) = _empty_reduce_error()
+mapreduce_empty(f, op, T) = _empty_reduce_error()
+reduce_empty(f, ::Type{Union{}}, splat...) = _empty_reduce_error()
+mapreduce_empty(f, op, ::Type{Union{}}, splat...) = _empty_reduce_error()
 
 """
     Base.reduce_empty(op, T)
@@ -339,20 +340,16 @@ is generally ambiguous, and especially so when the element type is unknown).
 
 As an alternative, consider supplying an `init` value to the reducer.
 """
-reduce_empty(::typeof(+), ::Type{Union{}}) = _empty_reduce_error(+, Union{})
 reduce_empty(::typeof(+), ::Type{T}) where {T} = zero(T)
 reduce_empty(::typeof(+), ::Type{Bool}) = zero(Int)
-reduce_empty(::typeof(*), ::Type{Union{}}) = _empty_reduce_error(*, Union{})
 reduce_empty(::typeof(*), ::Type{T}) where {T} = one(T)
 reduce_empty(::typeof(*), ::Type{<:AbstractChar}) = ""
 reduce_empty(::typeof(&), ::Type{Bool}) = true
 reduce_empty(::typeof(|), ::Type{Bool}) = false
 
-reduce_empty(::typeof(add_sum), ::Type{Union{}}) = _empty_reduce_error(add_sum, Union{})
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T} = reduce_empty(+, T)
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallSigned}  = zero(Int)
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallUnsigned} = zero(UInt)
-reduce_empty(::typeof(mul_prod), ::Type{Union{}}) = _empty_reduce_error(mul_prod, Union{})
 reduce_empty(::typeof(mul_prod), ::Type{T}) where {T} = reduce_empty(*, T)
 reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:SmallSigned}  = one(Int)
 reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:SmallUnsigned} = one(UInt)
@@ -753,7 +750,7 @@ julia> maximum([1,2,3])
 3
 
 julia> maximum(())
-ERROR: MethodError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
+ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
 Stacktrace:
 [...]
 
@@ -785,7 +782,7 @@ julia> minimum([1,2,3])
 1
 
 julia> minimum([])
-ERROR: MethodError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
+ERROR: ArgumentError: reducing over an empty collection is not allowed; consider supplying `init` to the reducer
 Stacktrace:
 [...]
 
diff --git a/test/reduce.jl b/test/reduce.jl
index 2c852084de37e..f5140c8a34bd9 100644
--- a/test/reduce.jl
+++ b/test/reduce.jl
@@ -53,8 +53,8 @@ end
 @test reduce(max, [8 6 7 5 3 0 9]) == 9
 @test reduce(+, 1:5; init=1000) == (1000 + 1 + 2 + 3 + 4 + 5)
 @test reduce(+, 1) == 1
-@test_throws "reducing with * over an empty collection of element type Union{} is not allowed" reduce(*, ())
-@test_throws "reducing with * over an empty collection of element type Union{} is not allowed" reduce(*, Union{}[])
+@test_throws "reducing over an empty collection is not allowed" reduce(*, ())
+@test_throws "reducing over an empty collection is not allowed" reduce(*, Union{}[])
 
 # mapreduce
 @test mapreduce(-, +, [-10 -9 -3]) == ((10 + 9) + 3)
@@ -91,8 +91,7 @@ end
 @test mapreduce(abs2, *, Float64[]) === 1.0
 @test mapreduce(abs2, max, Float64[]) === 0.0
 @test mapreduce(abs, max, Float64[]) === 0.0
-@test_throws ["reducing over an empty collection is not allowed",
-              "consider supplying `init`"] mapreduce(abs2, &, Float64[])
+@test_throws "reducing over an empty collection is not allowed" mapreduce(abs2, &, Float64[])
 @test_throws str -> !occursin("Closest candidates are", str) mapreduce(abs2, &, Float64[])
 @test_throws "reducing over an empty collection is not allowed" mapreduce(abs2, |, Float64[])
 
@@ -144,9 +143,8 @@ fz = float(z)
 @test sum(z) === 136
 @test sum(fz) === 136.0
 
-@test_throws "reducing with add_sum over an empty collection of element type Union{} is not allowed" sum(Union{}[])
-@test_throws ["reducing over an empty collection is not allowed",
-              "consider supplying `init`"] sum(sin, Int[])
+@test_throws "reducing over an empty collection is not allowed" sum(Union{}[])
+@test_throws "reducing over an empty collection is not allowed" sum(sin, Int[])
 @test sum(sin, 3) == sin(3.0)
 @test sum(sin, [3]) == sin(3.0)
 a = sum(sin, z)

From e39e77fa9eb659e524a45ab0b7943a74ed9cd62b Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Tue, 12 Dec 2023 07:12:18 +0800
Subject: [PATCH 0424/1315] Fix `unaliascopy(::SubArray)` with `indices` of
 `Array{<:CartesianIndex}` (#47779)

This PR fixes the bug caused by the trimming trick.
`Base.index_lengths` is not a proper tool to calculate the trimmed shape
as `indices` might consume more than 1 dim.
And we can avoid the unneeded "`repeat`" when we meet
`Array{CartesianIndex{0}}`

Test added.
Close #47644.
---
 base/subarray.jl | 39 ++++++++++++++++++++++++++++++++-------
 test/subarray.jl | 17 +++++++++++++++--
 2 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index 464bd660b0856..e42bd070747a2 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -110,16 +110,41 @@ unaliascopy(A::SubArray) = typeof(A)(unaliascopy(A.parent), map(unaliascopy, A.i
 
 # When the parent is an Array we can trim the size down a bit. In the future this
 # could possibly be extended to any mutable array.
-function unaliascopy(V::SubArray{T,N,A,I,LD}) where {T,N,A<:Array,I<:Tuple{Vararg{Union{Real,AbstractRange,Array}}},LD}
-    dest = Array{T}(undef, index_lengths(V.indices...))
-    copyto!(dest, V)
+function unaliascopy(V::SubArray{T,N,A,I,LD}) where {T,N,A<:Array,I<:Tuple{Vararg{Union{ScalarIndex,AbstractRange{<:ScalarIndex},Array{<:Union{ScalarIndex,AbstractCartesianIndex}}}}},LD}
+    dest = Array{T}(undef, _trimmedshape(V.indices...))
+    trimmedpind = _trimmedpind(V.indices...)
+    vdest = trimmedpind isa Tuple{Vararg{Union{Slice,Colon}}} ? dest : view(dest, trimmedpind...)
+    copyto!(vdest, view(V, _trimmedvind(V.indices...)...))
     SubArray{T,N,A,I,LD}(dest, map(_trimmedindex, V.indices), 0, Int(LD))
 end
+# Get the proper trimmed shape
+_trimmedshape(::ScalarIndex, rest...) = (1, _trimmedshape(rest...)...)
+_trimmedshape(i::AbstractRange, rest...) = (maximum(i), _trimmedshape(rest...)...)
+_trimmedshape(i::Union{UnitRange,StepRange,OneTo}, rest...) = (length(i), _trimmedshape(rest...)...)
+_trimmedshape(i::AbstractArray{<:ScalarIndex}, rest...) = (length(i), _trimmedshape(rest...)...)
+_trimmedshape(i::AbstractArray{<:AbstractCartesianIndex{0}}, rest...) = _trimmedshape(rest...)
+_trimmedshape(i::AbstractArray{<:AbstractCartesianIndex{N}}, rest...) where {N} = (length(i), ntuple(Returns(1), Val(N - 1))..., _trimmedshape(rest...)...)
+_trimmedshape() = ()
+# We can avoid the repeation from `AbstractArray{CartesianIndex{0}}`
+_trimmedpind(i, rest...) = (map(Returns(:), axes(i))..., _trimmedpind(rest...)...)
+_trimmedpind(i::AbstractRange, rest...) = (i, _trimmedpind(rest...)...)
+_trimmedpind(i::Union{UnitRange,StepRange,OneTo}, rest...) = ((:), _trimmedpind(rest...)...)
+_trimmedpind(i::AbstractArray{<:AbstractCartesianIndex{0}}, rest...) = _trimmedpind(rest...)
+_trimmedpind() = ()
+_trimmedvind(i, rest...) = (map(Returns(:), axes(i))..., _trimmedvind(rest...)...)
+_trimmedvind(i::AbstractArray{<:AbstractCartesianIndex{0}}, rest...) = (map(first, axes(i))..., _trimmedvind(rest...)...)
+_trimmedvind() = ()
 # Transform indices to be "dense"
-_trimmedindex(i::Real) = oftype(i, 1)
-_trimmedindex(i::AbstractUnitRange) = oftype(i, oneto(length(i)))
-_trimmedindex(i::AbstractArray) = oftype(i, reshape(eachindex(IndexLinear(), i), axes(i)))
-
+_trimmedindex(i::ScalarIndex) = oftype(i, 1)
+_trimmedindex(i::AbstractRange) = i
+_trimmedindex(i::Union{UnitRange,StepRange,OneTo}) = oftype(i, oneto(length(i)))
+_trimmedindex(i::AbstractArray{<:ScalarIndex}) = oftype(i, reshape(eachindex(IndexLinear(), i), axes(i)))
+_trimmedindex(i::AbstractArray{<:AbstractCartesianIndex{0}}) = oftype(i, copy(i))
+function _trimmedindex(i::AbstractArray{<:AbstractCartesianIndex{N}}) where {N}
+    padding = ntuple(Returns(1), Val(N - 1))
+    ax1 = eachindex(IndexLinear(), i)
+    return oftype(i, reshape(CartesianIndices((ax1, padding...)), axes(i)))
+end
 ## SubArray creation
 # We always assume that the dimensionality of the parent matches the number of
 # indices that end up getting passed to it, so we store the parent as a
diff --git a/test/subarray.jl b/test/subarray.jl
index 35e376f1a40b4..2502a19519ddb 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -660,8 +660,21 @@ end
 @testset "unaliascopy trimming; Issue #26263" begin
     A = rand(5,5,5,5)
     V = view(A, 2:5, :, 2:5, 1:2:5)
-    @test @inferred(Base.unaliascopy(V)) == V == A[2:5, :, 2:5, 1:2:5]
-    @test @inferred(sum(Base.unaliascopy(V))) ≈ sum(V) ≈ sum(A[2:5, :, 2:5, 1:2:5])
+    V′ = @inferred(Base.unaliascopy(V))
+    @test size(V′.parent) == size(V)
+    @test V′::typeof(V) == V == A[2:5, :, 2:5, 1:2:5]
+    @test @inferred(sum(V′)) ≈ sum(V) ≈ sum(A[2:5, :, 2:5, 1:2:5])
+    V = view(A, Base.IdentityUnitRange(2:4), :, Base.StepRangeLen(1,1,3), 1:2:5)
+    V′ = @inferred(Base.unaliascopy(V))
+    @test size(V.parent) != size(V′.parent)
+    @test V′ == V && V′ isa typeof(V)
+    i1 = collect(CartesianIndices((2:5)))
+    i2 = [CartesianIndex(), CartesianIndex()]
+    i3 = collect(CartesianIndices((2:5, 1:2:5)))
+    V = view(A, i1, 1:5, i2, i3)
+    @test @inferred(Base.unaliascopy(V))::typeof(V) == V == A[i1, 1:5, i2, i3]
+    V = view(A, i1, 1:5, i3, i2)
+    @test @inferred(Base.unaliascopy(V))::typeof(V) == V == A[i1, 1:5, i3, i2]
 end
 
 @testset "issue #27632" begin

From 9374e49f2121457a08ee6b5eefcbb4af6868c5a9 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 12 Dec 2023 18:03:25 +0900
Subject: [PATCH 0425/1315] allow external `AbstractInterpreter` to overload
 `throw`-call handling (#52498)

By defining new `abstract_throw` interface, which allows external
`AbstractInterpreter` to customize the behavior of `throw`-call handling
just by overloading `abstract_throw` method. This is particularly useful
for JET.
---
 base/compiler/abstractinterpretation.jl | 33 ++++++++++++++-----------
 1 file changed, 19 insertions(+), 14 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index d4e4afdb8407b..dd156ae338058 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2046,13 +2046,30 @@ function abstract_finalizer(interp::AbstractInterpreter, argtypes::Vector{Any},
     return CallMeta(Nothing, Any, Effects(), NoCallInfo())
 end
 
+function abstract_throw(interp::AbstractInterpreter, argtypes::Vector{Any}, ::AbsIntState)
+    na = length(argtypes)
+    𝕃ᵢ = typeinf_lattice(interp)
+    if na == 2
+        argtype2 = argtypes[2]
+        if isvarargtype(argtype2)
+            exct = tmerge(𝕃ᵢ, unwrapva(argtype2), ArgumentError)
+        else
+            exct = argtype2
+        end
+    elseif na == 3 && isvarargtype(argtypes[3])
+        exct = tmerge(𝕃ᵢ, argtypes[2], ArgumentError)
+    else
+        exct = ArgumentError
+    end
+    return CallMeta(Union{}, exct, EFFECTS_THROWS, NoCallInfo())
+end
+
 # call where the function is known exactly
 function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         arginfo::ArgInfo, si::StmtInfo, sv::AbsIntState,
         max_methods::Int = get_max_methods(interp, f, sv))
     (; fargs, argtypes) = arginfo
     la = length(argtypes)
-
     𝕃ᵢ = typeinf_lattice(interp)
     if isa(f, Builtin)
         if f === _apply_iterate
@@ -2066,19 +2083,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         elseif f === applicable
             return abstract_applicable(interp, argtypes, sv, max_methods)
         elseif f === throw
-            if la == 2
-                arg2 = argtypes[2]
-                if isvarargtype(arg2)
-                    exct = tmerge(𝕃ᵢ, unwrapva(argtypes[2]), ArgumentError)
-                else
-                    exct = arg2
-                end
-            elseif la == 3 && isvarargtype(argtypes[3])
-                exct = tmerge(𝕃ᵢ, argtypes[2], ArgumentError)
-            else
-                exct = ArgumentError
-            end
-            return CallMeta(Union{}, exct, EFFECTS_THROWS, NoCallInfo())
+            return abstract_throw(interp, argtypes, sv)
         end
         rt = abstract_call_builtin(interp, f, arginfo, sv)
         ft = popfirst!(argtypes)

From 0a6ae7cae009367b4d28e91f40c0e48fbc456fcf Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Tue, 12 Dec 2023 11:01:50 -0600
Subject: [PATCH 0426/1315] contrib/check-whitespace: Use / for all platform
 (#52468)

When built on Windows, the source code build will not pass
`check-whitespace`.

_check-whitespace issues (truncated):_
```
$ make check-whitespace
Whitespace check found 1658 issues:
src/flisp/aliases.scm:25 -- tab
src/flisp/aliases.scm:27 -- tab
src/flisp/aliases.scm:28 -- tab
src/flisp/aliases.scm:29 -- tab
src/flisp/aliases.scm:73 -- tab
src/flisp/color.lsp:55 -- tab
....
```

Because `git ls-files` use `/` as a path separator on Windows.

https://github.com/JuliaLang/julia/blob/649982aa0995c45165084baa643ce5c7c5b489cb/contrib/check-whitespace.jl#L33
_"git ls-files" output on win (truncated):_
```
$ git ls-files -- *.jl
base/Base.jl
base/Enums.jl
base/abstractarray.jl
base/abstractarraymath.jl
base/abstractdict.jl
base/abstractset.jl
base/accumulate.jl
...
```


But `joinpath` gives `\\` on win, so it won't match.

https://github.com/JuliaLang/julia/blob/649982aa0995c45165084baa643ce5c7c5b489cb/contrib/check-whitespace.jl#L21-L29


Change: just use `/` for all platforms.
---
 contrib/check-whitespace.jl | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/contrib/check-whitespace.jl b/contrib/check-whitespace.jl
index d5473ab4c7c62..b92f0c88a53a6 100755
--- a/contrib/check-whitespace.jl
+++ b/contrib/check-whitespace.jl
@@ -18,15 +18,17 @@ const patterns = split("""
     *Makefile
 """)
 
+# Note: `git ls-files` gives `/` as a path separator on Windows,
+#   so we just use `/` for all platforms.
 allow_tabs(path) =
     path == "Make.inc" ||
     endswith(path, "Makefile") ||
     endswith(path, ".make") ||
     endswith(path, ".mk") ||
-    startswith(path, joinpath("src", "support")) ||
-    startswith(path, joinpath("src", "flisp")) ||
-    endswith(path, joinpath("test", "syntax.jl")) ||
-    endswith(path, joinpath("test", "triplequote.jl"))
+    startswith(path, "src/support") ||
+    startswith(path, "src/flisp") ||
+    endswith(path, "test/syntax.jl") ||
+    endswith(path, "test/triplequote.jl")
 
 const errors = Set{Tuple{String,Int,String}}()
 

From eba10ddfbb1f6c57fb65e1d8d0bd75e9ecb4e179 Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Tue, 12 Dec 2023 12:03:05 -0500
Subject: [PATCH 0427/1315] CI: Start the Pkg tests very early on during the
 test suite (#52460)

---
 test/runtests.jl | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/test/runtests.jl b/test/runtests.jl
index 1264acae985b0..7f386160435db 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -84,12 +84,14 @@ move_to_node1("stress")
 # since it starts a lot of workers and can easily exceed the maximum memory
 limited_worker_rss && move_to_node1("Distributed")
 
-# Shuffle LinearAlgebra tests to the front, because they take a while, so we might
+# Move LinearAlgebra and Pkg tests to the front, because they take a while, so we might
 # as well get them all started early.
-linalg_test_ids = findall(x->occursin("LinearAlgebra", x), tests)
-linalg_tests = tests[linalg_test_ids]
-deleteat!(tests, linalg_test_ids)
-prepend!(tests, linalg_tests)
+for prependme in ["LinearAlgebra", "Pkg"]
+    prependme_test_ids = findall(x->occursin(prependme, x), tests)
+    prependme_tests = tests[prependme_test_ids]
+    deleteat!(tests, prependme_test_ids)
+    prepend!(tests, prependme_tests)
+end
 
 import LinearAlgebra
 cd(@__DIR__) do

From d27ed8f34f0092671e6ca612ef3309d6d3d177c2 Mon Sep 17 00:00:00 2001
From: Christopher Sahnwaldt <jcsahnwaldt@gmail.com>
Date: Tue, 12 Dec 2023 21:29:59 +0100
Subject: [PATCH 0428/1315] doc/src/manual/arrays.md: fix typo (#52502)

Mix-up between `I_k` and `i_k`. I bolded the wrong part.
---
 doc/src/manual/arrays.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/manual/arrays.md b/doc/src/manual/arrays.md
index 027f9ca661443..09a095729f174 100644
--- a/doc/src/manual/arrays.md
+++ b/doc/src/manual/arrays.md
@@ -603,7 +603,7 @@ overwritten with the value of `X`, [`convert`](@ref)ing to the
 If any index `I_k` is itself an array, then the right hand side `X` must also be an
 array with the same shape as the result of indexing `A[I_1, I_2, ..., I_n]` or a vector with
 the same number of elements. The value in location `I_1[i_1], I_2[i_2], ..., I_n[i_n]` of
-`A` is overwritten with the value `X[I_1, I_2, ..., I_n]`, converting if necessary. The
+`A` is overwritten with the value `X[i_1, i_2, ..., i_n]`, converting if necessary. The
 element-wise assignment operator `.=` may be used to [broadcast](@ref Broadcasting) `X`
 across the selected locations:
 

From 406f5b44725287f6a2211eb7369fe67ae089891a Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 12 Dec 2023 20:17:25 -0800
Subject: [PATCH 0429/1315] Make EnterNode save/restore dynamic scope (#52309)

As discussed in #51352, this gives `EnterNode` the ability to set (and
restore on leave or catch edge) jl_current_task->scope. Manual
modifications of the task field after the task has started are
considered undefined behavior. In addition, we gain a new intrinsic to
access current_task->scope and both inference and the optimizer will
forward scopes from EnterNodes to this intrinsic
(non-interprocedurally). Together with #51993 this is sufficient to
fully optimize ScopedValues (non-interprocedurally at least).
---
 base/boot.jl                            |  4 +-
 base/compiler/abstractinterpretation.jl | 13 +++++++
 base/compiler/inferencestate.jl         |  6 ++-
 base/compiler/ssair/ir.jl               |  1 +
 base/compiler/ssair/passes.jl           | 25 ++++++++++++
 base/compiler/ssair/show.jl             |  4 ++
 base/compiler/ssair/verify.jl           |  2 +-
 base/compiler/tfuncs.jl                 | 52 +++++++++++++++++++++++--
 base/compiler/validation.jl             |  9 ++++-
 base/scopedvalues.jl                    | 51 ++++++------------------
 base/task.jl                            |  9 +++++
 src/ast.c                               |  4 ++
 src/builtin_proto.h                     |  1 +
 src/builtins.c                          |  7 ++++
 src/codegen.cpp                         | 52 ++++++++++++++++++++++---
 src/interpreter.c                       | 19 ++++++++-
 src/jltypes.c                           |  4 +-
 src/julia-syntax.scm                    | 13 +++++--
 src/julia.h                             |  1 +
 src/method.c                            | 15 +++++++
 src/staticdata.c                        |  1 +
 test/core.jl                            | 13 +++++++
 test/scopedvalues.jl                    |  4 +-
 23 files changed, 248 insertions(+), 62 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 218e4e2e533b1..13bb6bcd7cd4b 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -460,6 +460,7 @@ eval(Core, quote
     ReturnNode() = $(Expr(:new, :ReturnNode)) # unassigned val indicates unreachable
     GotoIfNot(@nospecialize(cond), dest::Int) = $(Expr(:new, :GotoIfNot, :cond, :dest))
     EnterNode(dest::Int) = $(Expr(:new, :EnterNode, :dest))
+    EnterNode(dest::Int, @nospecialize(scope)) = $(Expr(:new, :EnterNode, :dest, :scope))
     LineNumberNode(l::Int) = $(Expr(:new, :LineNumberNode, :l, nothing))
     function LineNumberNode(l::Int, @nospecialize(f))
         isa(f, String) && (f = Symbol(f))
@@ -966,7 +967,8 @@ arraysize(a::Array, i::Int) = sle_int(i, nfields(a.size)) ? getfield(a.size, i)
 export arrayref, arrayset, arraysize, const_arrayref
 
 # For convenience
-EnterNode(old::EnterNode, new_dest::Int) = EnterNode(new_dest)
+EnterNode(old::EnterNode, new_dest::Int) = isdefined(old, :scope) ?
+    EnterNode(new_dest, old.scope) : EnterNode(new_dest)
 
 include(Core, "optimized_generics.jl")
 
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index dd156ae338058..0541aa9e64278 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -3270,6 +3270,19 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 elseif isa(stmt, EnterNode)
                     ssavaluetypes[currpc] = Any
                     add_curr_ssaflag!(frame, IR_FLAG_NOTHROW)
+                    if isdefined(stmt, :scope)
+                        scopet = abstract_eval_value(interp, stmt.scope, currstate, frame)
+                        handler = frame.handlers[frame.handler_at[frame.currpc+1][1]]
+                        @assert handler.scopet !== nothing
+                        if !⊑(𝕃ᵢ, scopet, handler.scopet)
+                            handler.scopet = tmerge(𝕃ᵢ, scopet, handler.scopet)
+                            if isdefined(handler, :scope_uses)
+                                for bb in handler.scope_uses
+                                    push!(W, bb)
+                                end
+                            end
+                        end
+                    end
                     @goto fallthrough
                 elseif isexpr(stmt, :leave)
                     ssavaluetypes[currpc] = Any
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 09757adc54850..f8650c2e6cfde 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -205,8 +205,10 @@ const CACHE_MODE_VOLATILE = 0x01 << 2 # not cached, optimization allowed
 
 mutable struct TryCatchFrame
     exct
+    scopet
     const enter_idx::Int
-    TryCatchFrame(@nospecialize(exct), enter_idx::Int) = new(exct, enter_idx)
+    scope_uses::Vector{Int}
+    TryCatchFrame(@nospecialize(exct), @nospecialize(scopet), enter_idx::Int) = new(exct, scopet, enter_idx)
 end
 
 mutable struct InferenceState
@@ -364,7 +366,7 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
         stmt = code[pc]
         if isa(stmt, EnterNode)
             l = stmt.catch_dest
-            push!(handlers, TryCatchFrame(Bottom, pc))
+            push!(handlers, TryCatchFrame(Bottom, isdefined(stmt, :scope) ? Bottom : nothing, pc))
             handler_id = length(handlers)
             handler_at[pc + 1] = (handler_id, 0)
             push!(ip, pc + 1)
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 6a1114a009519..c37562a06c2ca 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1414,6 +1414,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
             result_idx += 1
         end
     elseif cfg_transforms_enabled && isa(stmt, EnterNode)
+        stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, new_new_used_ssas, late_fixup, result_idx, do_rename_ssa, mark_refined!)::EnterNode
         label = bb_rename_succ[stmt.catch_dest]
         @assert label > 0
         ssa_rename[idx] = SSAValue(result_idx)
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 5abed1a182048..fdd7c0d3b48aa 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1069,6 +1069,29 @@ function fold_ifelse!(compact::IncrementalCompact, idx::Int, stmt::Expr)
     return false
 end
 
+function fold_current_scope!(compact::IncrementalCompact, idx::Int, stmt::Expr, lazydomtree::LazyDomtree)
+    domtree = get!(lazydomtree)
+
+    # The frontend enforces the invariant that any :enter dominates its active
+    # region, so all we have to do here is walk the domtree to find it.
+    dombb = block_for_inst(compact, SSAValue(idx))
+
+    local bbterminator
+    while true
+        dombb = domtree.idoms_bb[dombb]
+
+        # Did not find any dominating :enter - scope is inherited from the outside
+        dombb == 0 && return nothing
+
+        bbterminator = compact[SSAValue(last(compact.cfg_transform.result_bbs[dombb].stmts))][:stmt]
+        isa(bbterminator, EnterNode) || continue
+        isdefined(bbterminator, :scope) || continue
+        compact[idx] = bbterminator.scope
+        return nothing
+    end
+end
+
+
 # NOTE we use `IdSet{Int}` instead of `BitSet` for in these passes since they work on IR after inlining,
 # which can be very large sometimes, and program counters in question are often very sparse
 const SPCSet = IdSet{Int}
@@ -1201,6 +1224,8 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
             elseif is_known_invoke_or_call(stmt, Core.OptimizedGenerics.KeyValue.get, compact)
                 2 == (length(stmt.args) - (isexpr(stmt, :invoke) ? 2 : 1)) || continue
                 lift_keyvalue_get!(compact, idx, stmt, 𝕃ₒ)
+            elseif is_known_call(stmt, Core.current_scope, compact)
+                fold_current_scope!(compact, idx, stmt, lazydomtree)
             elseif isexpr(stmt, :new)
                 refine_new_effects!(𝕃ₒ, compact, idx, stmt)
             end
diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl
index 7323c21ae56b4..82af7f9964045 100644
--- a/base/compiler/ssair/show.jl
+++ b/base/compiler/ssair/show.jl
@@ -69,6 +69,10 @@ function print_stmt(io::IO, idx::Int, @nospecialize(stmt), used::BitSet, maxleng
     # given control flow information, we prefer to print these with the basic block #, instead of the ssa %
     elseif isa(stmt, EnterNode)
         print(io, "enter #", stmt.catch_dest, "")
+        if isdefined(stmt, :scope)
+            print(io, " with scope ")
+            show_unquoted(io, stmt.scope, indent)
+        end
     elseif stmt isa GotoNode
         print(io, "goto #", stmt.label)
     elseif stmt isa PhiNode
diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index 03e3ab0b0f03a..9eded81d9d84b 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -2,7 +2,7 @@
 
 function maybe_show_ir(ir::IRCode)
     if isdefined(Core, :Main)
-        Core.Main.Base.display(ir)
+        invokelatest(Core.Main.Base.display, ir)
     end
 end
 
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index c30f4a1a237e1..bb8712458e0be 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -2488,6 +2488,19 @@ function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argty
         return Effects(EFFECTS_TOTAL;
             consistent = (isa(setting, Const) && setting.val === :conditional) ? ALWAYS_TRUE : ALWAYS_FALSE,
             nothrow = compilerbarrier_nothrow(setting, nothing))
+    elseif f === Core.current_scope
+        nothrow = true
+        if length(argtypes) != 0
+            if length(argtypes) != 1 || !isvarargtype(argtypes[1])
+                return EFFECTS_THROWS
+            end
+            nothrow = false
+        end
+        return Effects(EFFECTS_TOTAL;
+            consistent = ALWAYS_FALSE,
+            notaskstate = false,
+            nothrow
+        )
     else
         if contains_is(_CONSISTENT_BUILTINS, f)
             consistent = ALWAYS_TRUE
@@ -2554,6 +2567,32 @@ function memoryop_noub(@nospecialize(f), argtypes::Vector{Any})
     return false
 end
 
+function current_scope_tfunc(interp::AbstractInterpreter, sv::InferenceState)
+    pc = sv.currpc
+    while true
+        handleridx = sv.handler_at[pc][1]
+        if handleridx == 0
+            # No local scope available - inherited from the outside
+            return Any
+        end
+        pchandler = sv.handlers[handleridx]
+        # Remember that we looked at this handler, so we get re-scheduled
+        # if the scope information changes
+        isdefined(pchandler, :scope_uses) || (pchandler.scope_uses = Int[])
+        pcbb = block_for_inst(sv.cfg, pc)
+        if findfirst(==(pcbb), pchandler.scope_uses) === nothing
+            push!(pchandler.scope_uses, pcbb)
+        end
+        scope = pchandler.scopet
+        if scope !== nothing
+            # Found the scope - forward it
+            return scope
+        end
+        pc = pchandler.enter_idx
+    end
+end
+current_scope_tfunc(interp::AbstractInterpreter, sv) = Any
+
 """
     builtin_nothrow(𝕃::AbstractLattice, f::Builtin, argtypes::Vector{Any}, rt) -> Bool
 
@@ -2568,9 +2607,6 @@ end
 function builtin_tfunction(interp::AbstractInterpreter, @nospecialize(f), argtypes::Vector{Any},
                            sv::Union{AbsIntState, Nothing})
     𝕃ᵢ = typeinf_lattice(interp)
-    if f === tuple
-        return tuple_tfunc(𝕃ᵢ, argtypes)
-    end
     if isa(f, IntrinsicFunction)
         if is_pure_intrinsic_infer(f) && all(@nospecialize(a) -> isa(a, Const), argtypes)
             argvals = anymap(@nospecialize(a) -> (a::Const).val, argtypes)
@@ -2596,6 +2632,16 @@ function builtin_tfunction(interp::AbstractInterpreter, @nospecialize(f), argtyp
         end
         tf = T_IFUNC[iidx]
     else
+        if f === tuple
+            return tuple_tfunc(𝕃ᵢ, argtypes)
+        elseif f === Core.current_scope
+            if length(argtypes) != 0
+                if length(argtypes) != 1 || !isvarargtype(argtypes[1])
+                    return Bottom
+                end
+            end
+            return current_scope_tfunc(interp, sv)
+        end
         fidx = find_tfunc(f)
         if fidx === nothing
             # unknown/unhandled builtin function
diff --git a/base/compiler/validation.jl b/base/compiler/validation.jl
index ef6602b082797..2428ea8a38892 100644
--- a/base/compiler/validation.jl
+++ b/base/compiler/validation.jl
@@ -13,7 +13,7 @@ const VALID_EXPR_HEADS = IdDict{Symbol,UnitRange{Int}}(
     :new => 1:typemax(Int),
     :splatnew => 2:2,
     :the_exception => 0:0,
-    :enter => 1:1,
+    :enter => 1:2,
     :leave => 1:typemax(Int),
     :pop_exception => 1:1,
     :inbounds => 1:1,
@@ -160,6 +160,13 @@ function validate_code!(errors::Vector{InvalidCodeError}, c::CodeInfo, is_top_le
                 push!(errors, InvalidCodeError(INVALID_CALL_ARG, x.cond))
             end
             validate_val!(x.cond)
+        elseif isa(x, EnterNode)
+            if isdefined(x, :scope)
+                if !is_valid_argument(x.scope)
+                    push!(errors, InvalidCodeError(INVALID_CALL_ARG, x.scope))
+                end
+                validate_val!(x.scope)
+            end
         elseif isa(x, ReturnNode)
             if isdefined(x, :val)
                 if !is_valid_return(x.val)
diff --git a/base/scopedvalues.jl b/base/scopedvalues.jl
index fd18e932d6a46..6eb1004a1d30f 100644
--- a/base/scopedvalues.jl
+++ b/base/scopedvalues.jl
@@ -81,13 +81,6 @@ function Scope(scope, pair1::Pair{<:ScopedValue}, pair2::Pair{<:ScopedValue}, pa
 end
 Scope(::Nothing) = nothing
 
-"""
-    current_scope()::Union{Nothing, Scope}
-
-Return the current dynamic scope.
-"""
-current_scope() = current_task().scope::Union{Nothing, Scope}
-
 function Base.show(io::IO, scope::Scope)
     print(io, Scope, "(")
     first = true
@@ -116,8 +109,7 @@ return `nothing`. Otherwise returns `Some{T}` with the current
 value.
 """
 function get(val::ScopedValue{T}) where {T}
-    # Inline current_scope to avoid doing the type assertion twice.
-    scope = current_task().scope
+    scope = Core.current_scope()::Union{Scope, Nothing}
     if scope === nothing
         isassigned(val) && return Some{T}(val.default)
         return nothing
@@ -151,25 +143,6 @@ function Base.show(io::IO, val::ScopedValue)
     print(io, ')')
 end
 
-"""
-    with(f, (var::ScopedValue{T} => val::T)...)
-
-Execute `f` in a new scope with `var` set to `val`.
-"""
-function with(f, pair::Pair{<:ScopedValue}, rest::Pair{<:ScopedValue}...)
-    @nospecialize
-    ct = Base.current_task()
-    current_scope = ct.scope::Union{Nothing, Scope}
-    ct.scope = Scope(current_scope, pair, rest...)
-    try
-        return f()
-    finally
-        ct.scope = current_scope
-    end
-end
-
-with(@nospecialize(f)) = f()
-
 """
     @with vars... expr
 
@@ -187,18 +160,18 @@ macro with(exprs...)
     else
         error("@with expects at least one argument")
     end
-    for expr in exprs
-        if expr.head !== :call || first(expr.args) !== :(=>)
-            error("@with expects arguments of the form `A => 2` got $expr")
-        end
-    end
     exprs = map(esc, exprs)
-    quote
-        ct = $(Base.current_task)()
-        current_scope = ct.scope::$(Union{Nothing, Scope})
-        ct.scope = $(Scope)(current_scope, $(exprs...))
-        $(Expr(:tryfinally, esc(ex), :(ct.scope = current_scope)))
-    end
+    Expr(:tryfinally, esc(ex), :(), :(Scope(Core.current_scope()::Union{Nothing, Scope}, $(exprs...))))
 end
 
+"""
+    with(f, (var::ScopedValue{T} => val::T)...)
+
+Execute `f` in a new scope with `var` set to `val`.
+"""
+function with(f, pair::Pair{<:ScopedValue}, rest::Pair{<:ScopedValue}...)
+    @with(pair, rest..., f())
+end
+with(@nospecialize(f)) = f()
+
 end # module ScopedValues
diff --git a/base/task.jl b/base/task.jl
index 09b40f19f5913..79e85024ac0d0 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -180,11 +180,20 @@ end
     elseif field === :exception
         # TODO: this field name should be deprecated in 2.0
         return t._isexception ? t.result : nothing
+    elseif field === :scope
+        error("Querying `scope` is disallowed. Use `current_scope` instead.")
     else
         return getfield(t, field)
     end
 end
 
+@inline function setproperty!(t::Task, field::Symbol, @nospecialize(v))
+    if field === :scope
+        istaskstarted(t) && error("Setting scope on a started task directly is disallowed.")
+    end
+    return @invoke setproperty!(t::Any, field, v)
+end
+
 """
     istaskdone(t::Task) -> Bool
 
diff --git a/src/ast.c b/src/ast.c
index 8257309a07b2b..7e7e7fb445e00 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -606,7 +606,11 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, jl_module_t *m
         else if (sym == jl_enter_sym) {
             ex = scm_to_julia_(fl_ctx, car_(e), mod);
             temp = jl_new_struct_uninit(jl_enternode_type);
+            jl_enternode_scope(temp) = NULL;
             jl_enternode_catch_dest(temp) = jl_unbox_long(ex);
+            if (n == 2) {
+                jl_enternode_scope(temp) = scm_to_julia(fl_ctx, car_(cdr_(e)), mod);
+            }
         }
         else if (sym == jl_newvar_sym) {
             ex = scm_to_julia_(fl_ctx, car_(e), mod);
diff --git a/src/builtin_proto.h b/src/builtin_proto.h
index e6e91207b2fdb..a009b535ac951 100644
--- a/src/builtin_proto.h
+++ b/src/builtin_proto.h
@@ -62,6 +62,7 @@ DECLARE_BUILTIN(setglobal);
 DECLARE_BUILTIN(finalizer);
 DECLARE_BUILTIN(_compute_sparams);
 DECLARE_BUILTIN(_svec_ref);
+DECLARE_BUILTIN(current_scope);
 
 JL_CALLABLE(jl_f__structtype);
 JL_CALLABLE(jl_f__abstracttype);
diff --git a/src/builtins.c b/src/builtins.c
index 5238a9476c9a2..e6472457cb6a9 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -587,6 +587,12 @@ JL_CALLABLE(jl_f_ifelse)
     return (args[0] == jl_false ? args[2] : args[1]);
 }
 
+JL_CALLABLE(jl_f_current_scope)
+{
+    JL_NARGS(current_scope, 0, 0);
+    return jl_current_task->scope;
+}
+
 // apply ----------------------------------------------------------------------
 
 static NOINLINE jl_svec_t *_copy_to(size_t newalloc, jl_value_t **oldargs, size_t oldalloc)
@@ -2158,6 +2164,7 @@ void jl_init_primitives(void) JL_GC_DISABLED
     add_builtin_func("finalizer", jl_f_finalizer);
     add_builtin_func("_compute_sparams", jl_f__compute_sparams);
     add_builtin_func("_svec_ref", jl_f__svec_ref);
+    add_builtin_func("current_scope", jl_f_current_scope);
 
     // builtin types
     add_builtin("Any", (jl_value_t*)jl_any_type);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index a5615cbdb013d..2cbe7733ab708 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1833,6 +1833,7 @@ class jl_codectx_t {
     // local var info. globals are not in here.
     SmallVector<jl_varinfo_t, 0> slots;
     std::map<int, jl_varinfo_t> phic_slots;
+    std::map<int, std::pair<Value*, Value*> > scope_restore;
     SmallVector<jl_cgval_t, 0> SAvalues;
     SmallVector<std::tuple<jl_cgval_t, BasicBlock *, AllocaInst *, PHINode *, jl_value_t *>, 0> PhiNodes;
     SmallVector<bool, 0> ssavalue_assigned;
@@ -5601,18 +5602,28 @@ static void emit_stmtpos(jl_codectx_t &ctx, jl_value_t *expr, int ssaval_result)
     }
     else if (head == jl_leave_sym) {
         int hand_n_leave = 0;
+        Value *scope_to_restore = nullptr;
+        Value *scope_ptr = nullptr;
         for (size_t i = 0; i < jl_expr_nargs(ex); ++i) {
             jl_value_t *arg = args[i];
             if (arg == jl_nothing)
                 continue;
             assert(jl_is_ssavalue(arg));
-            jl_value_t *enter_stmt = jl_array_ptr_ref(ctx.code, ((jl_ssavalue_t*)arg)->id - 1);
+            size_t enter_idx = ((jl_ssavalue_t*)arg)->id - 1;
+            jl_value_t *enter_stmt = jl_array_ptr_ref(ctx.code, enter_idx);
             if (enter_stmt == jl_nothing)
                 continue;
+            if (ctx.scope_restore.count(enter_idx))
+                std::tie(scope_to_restore, scope_ptr) = ctx.scope_restore[enter_idx];
             hand_n_leave += 1;
         }
         ctx.builder.CreateCall(prepare_call(jlleave_func),
                            ConstantInt::get(getInt32Ty(ctx.builder.getContext()), hand_n_leave));
+        if (scope_to_restore) {
+            jl_aliasinfo_t scope_ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_gcframe);
+            scope_ai.decorateInst(
+                ctx.builder.CreateAlignedStore(scope_to_restore, scope_ptr, ctx.types().alignof_ptr));
+        }
     }
     else if (head == jl_pop_exception_sym) {
         jl_cgval_t excstack_state = emit_expr(ctx, jl_exprarg(expr, 0));
@@ -6059,7 +6070,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
         return jl_cgval_t();
     }
     else if (head == jl_leave_sym || head == jl_coverageeffect_sym
-            || head == jl_pop_exception_sym || head == jl_enter_sym || head == jl_inbounds_sym
+            || head == jl_pop_exception_sym || head == jl_inbounds_sym
             || head == jl_aliasscope_sym || head == jl_popaliasscope_sym || head == jl_inline_sym || head == jl_noinline_sym) {
         jl_errorf("Expr(:%s) in value position", jl_symbol_name(head));
     }
@@ -6150,6 +6161,16 @@ static Value *get_last_age_field(jl_codectx_t &ctx)
             "world_age");
 }
 
+static Value *get_scope_field(jl_codectx_t &ctx)
+{
+    Value *ct = get_current_task(ctx);
+    return ctx.builder.CreateInBoundsGEP(
+            ctx.types().T_prjlvalue,
+            ctx.builder.CreateBitCast(ct, ctx.types().T_prjlvalue->getPointerTo()),
+            ConstantInt::get(ctx.types().T_size, offsetof(jl_task_t, scope) / ctx.types().sizeof_ptr),
+            "current_scope");
+}
+
 static Function *emit_tojlinvoke(jl_code_instance_t *codeinst, Module *M, jl_codegen_params_t &params)
 {
     ++EmittedToJLInvokes;
@@ -8730,6 +8751,20 @@ static jl_llvm_functions_t
             continue;
         }
         else if (jl_is_enternode(stmt)) {
+            // For the two-arg version of :enter, twiddle the scope
+            Value *scope_ptr = NULL;
+            Value *old_scope = NULL;
+            jl_aliasinfo_t scope_ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_gcframe);
+            if (jl_enternode_scope(stmt)) {
+                jl_cgval_t new_scope = emit_expr(ctx, jl_enternode_scope(stmt));
+                Value *new_scope_boxed = boxed(ctx, new_scope);
+                scope_ptr = get_scope_field(ctx);
+                old_scope = scope_ai.decorateInst(
+                        ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, scope_ptr, ctx.types().alignof_ptr));
+                scope_ai.decorateInst(
+                    ctx.builder.CreateAlignedStore(new_scope_boxed, scope_ptr, ctx.types().alignof_ptr));
+                ctx.scope_restore[cursor] = std::make_pair(old_scope, scope_ptr);
+            }
             int lname = jl_enternode_catch_dest(stmt);
             // Save exception stack depth at enter for use in pop_exception
             Value *excstack_state =
@@ -8737,6 +8772,7 @@ static jl_llvm_functions_t
             assert(!ctx.ssavalue_assigned[cursor]);
             ctx.SAvalues[cursor] = jl_cgval_t(excstack_state, (jl_value_t*)jl_ulong_type, NULL);
             ctx.ssavalue_assigned[cursor] = true;
+            // Actually enter the exception frame
             CallInst *sj = ctx.builder.CreateCall(prepare_call(except_enter_func));
             // We need to mark this on the call site as well. See issue #6757
             sj->setCanReturnTwice();
@@ -8749,9 +8785,15 @@ static jl_llvm_functions_t
             come_from_bb[cursor + 1] = ctx.builder.GetInsertBlock();
             ctx.builder.CreateCondBr(isz, tryblk, catchpop);
             ctx.builder.SetInsertPoint(catchpop);
-            ctx.builder.CreateCall(prepare_call(jlleave_func),
-                            ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 1));
-            ctx.builder.CreateBr(handlr);
+            {
+                ctx.builder.CreateCall(prepare_call(jlleave_func),
+                                ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 1));
+                if (old_scope) {
+                    scope_ai.decorateInst(
+                        ctx.builder.CreateAlignedStore(old_scope, scope_ptr, ctx.types().alignof_ptr));
+                }
+                ctx.builder.CreateBr(handlr);
+            }
             ctx.builder.SetInsertPoint(tryblk);
         }
         else {
diff --git a/src/interpreter.c b/src/interpreter.c
index 313f5d9423fcc..81096413c8e73 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -519,8 +519,23 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
             }
             // store current top of exception stack for restore in pop_exception.
             s->locals[jl_source_nslots(s->src) + ip] = jl_box_ulong(jl_excstack_state());
-            if (!jl_setjmp(__eh.eh_ctx, 1)) {
-                return eval_body(stmts, s, next_ip, toplevel);
+            if (jl_enternode_scope(stmt)) {
+                jl_value_t *old_scope = ct->scope;
+                JL_GC_PUSH1(&old_scope);
+                jl_value_t *new_scope = eval_value(jl_enternode_scope(stmt), s);
+                ct->scope = new_scope;
+                if (!jl_setjmp(__eh.eh_ctx, 1)) {
+                    eval_body(stmts, s, next_ip, toplevel);
+                    jl_unreachable();
+                }
+                ct->scope = old_scope;
+                JL_GC_POP();
+            }
+            else {
+                if (!jl_setjmp(__eh.eh_ctx, 1)) {
+                    eval_body(stmts, s, next_ip, toplevel);
+                    jl_unreachable();
+                }
             }
             jl_eh_restore_state(&__eh);
             if (s->continue_at) { // means we reached a :leave expression
diff --git a/src/jltypes.c b/src/jltypes.c
index 7fb7a6dc13eb5..f0f3b36951a2b 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3070,8 +3070,8 @@ void jl_init_types(void) JL_GC_DISABLED
 
     jl_enternode_type =
         jl_new_datatype(jl_symbol("EnterNode"), core, jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(1, "catch_dest"),
-                        jl_svec(1, jl_long_type),
+                        jl_perm_symsvec(2, "catch_dest", "scope"),
+                        jl_svec(2, jl_long_type, jl_any_type),
                         jl_emptysvec, 0, 0, 1);
 
     jl_returnnode_type =
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 76a06c6d1a47b..e7899688453c7 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -4718,7 +4718,9 @@ f(x) = yt(x)
                #f))
 
             ;; exception handlers are lowered using
-            ;; (= tok (enter L)) - push handler with catch block at label L, yielding token
+            ;; (= tok (enter L scope))
+            ;;      push handler with catch block at label L and scope `scope`, yielding token
+            ;;      `scope` is only recognized for tryfinally and may be omitted in the lowering
             ;; (leave n) - pop N exception handlers
             ;; (pop_exception tok) - pop exception stack back to state of associated enter
             ((trycatch tryfinally trycatchelse)
@@ -4728,9 +4730,10 @@ f(x) = yt(x)
                    (endl  (make-label))
                    (last-finally-handler finally-handler)
                    (finally           (if (eq? (car e) 'tryfinally) (new-mutable-var) #f))
+                   (scope             (if (eq? (car e) 'tryfinally) (cdddr e) '()))
                    (my-finally-handler #f))
                ;; handler block entry
-               (emit `(= ,handler-token (enter ,catch)))
+               (emit `(= ,handler-token (enter ,catch ,@(compile-args scope break-labels))))
                (set! handler-token-stack (cons handler-token handler-token-stack))
                (if finally (begin (set! my-finally-handler (list finally endl '() handler-token-stack catch-token-stack))
                                   (set! finally-handler my-finally-handler)
@@ -5104,8 +5107,10 @@ f(x) = yt(x)
              (let ((idx (get ssavalue-table (cadr e) #f)))
                (if (not idx) (begin (prn e) (prn lam) (error "ssavalue with no def")))
                `(ssavalue ,idx)))
-            ((memq (car e) '(goto enter))
-             (list* (car e) (get label-table (cadr e)) (cddr e)))
+            ((eq? (car e) 'goto)
+             `(goto ,(get label-table (cadr e))))
+            ((eq? (car e) 'enter)
+             `(enter ,(get label-table (cadr e)) ,@(map renumber-stuff (cddr e))))
             ((eq? (car e) 'gotoifnot)
              `(gotoifnot ,(renumber-stuff (cadr e)) ,(get label-table (caddr e))))
             ((eq? (car e) 'lambda)
diff --git a/src/julia.h b/src/julia.h
index 7b148ecbec55d..c5aa659670612 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1282,6 +1282,7 @@ STATIC_INLINE void jl_array_uint32_set(void *a, size_t i, uint32_t x) JL_NOTSAFE
 #define jl_gotoifnot_cond(x) (((jl_value_t**)(x))[0])
 #define jl_gotoifnot_label(x) (((intptr_t*)(x))[1])
 #define jl_enternode_catch_dest(x) (((intptr_t*)(x))[0])
+#define jl_enternode_scope(x) (((jl_value_t**)(x))[1])
 #define jl_globalref_mod(s) (*(jl_module_t**)(s))
 #define jl_globalref_name(s) (((jl_sym_t**)(s))[1])
 #define jl_quotenode_value(x) (((jl_value_t**)x)[0])
diff --git a/src/method.c b/src/method.c
index 73d2d256320ab..30bf9c5774f11 100644
--- a/src/method.c
+++ b/src/method.c
@@ -64,6 +64,21 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
         }
         return expr;
     }
+    else if (jl_is_enternode(expr)) {
+        jl_value_t *scope = jl_enternode_scope(expr);
+        if (scope) {
+            jl_value_t *val = resolve_globals(scope, module, sparam_vals, binding_effects, eager_resolve);
+            if (val != scope) {
+                intptr_t catch_dest = jl_enternode_catch_dest(expr);
+                JL_GC_PUSH1(&val);
+                expr = jl_new_struct_uninit(jl_enternode_type);
+                jl_enternode_catch_dest(expr) = catch_dest;
+                jl_enternode_scope(expr) = val;
+                JL_GC_POP();
+            }
+        }
+        return expr;
+    }
     else if (jl_is_gotoifnot(expr)) {
         jl_value_t *cond = resolve_globals(jl_gotoifnot_cond(expr), module, sparam_vals, binding_effects, eager_resolve);
         if (cond != jl_gotoifnot_cond(expr)) {
diff --git a/src/staticdata.c b/src/staticdata.c
index 8befca1d93414..8244c5a4373ce 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -470,6 +470,7 @@ static const jl_fptr_args_t id_to_fptrs[] = {
     &jl_f__typebody, &jl_f__setsuper, &jl_f__equiv_typedef, &jl_f_get_binding_type,
     &jl_f_set_binding_type, &jl_f_opaque_closure_call, &jl_f_donotdelete, &jl_f_compilerbarrier,
     &jl_f_getglobal, &jl_f_setglobal, &jl_f_finalizer, &jl_f__compute_sparams, &jl_f__svec_ref,
+    &jl_f_current_scope,
     NULL };
 
 typedef struct {
diff --git a/test/core.jl b/test/core.jl
index 7cd4be5427eb4..25264c689fcfb 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8070,3 +8070,16 @@ let widen_diagonal(x::UnionAll) = Base.rewrap_unionall(Base.widen_diagonal(Base.
     @test Union{Tuple{T}, Tuple{T,Int}} where {T} === widen_diagonal(Union{Tuple{T}, Tuple{T,Int}} where {T})
     @test Tuple === widen_diagonal(Union{Tuple{Vararg{S}}, Tuple{Vararg{T}}} where {S, T})
 end
+
+# Test try/catch/else ordering
+function test_try_catch_else()
+    local x
+    try
+        x = 1
+    catch
+        rethrow()
+    else
+        return x
+    end
+end
+@test test_try_catch_else() == 1
diff --git a/test/scopedvalues.jl b/test/scopedvalues.jl
index b2a0e574fe7aa..b1f3241af8fc6 100644
--- a/test/scopedvalues.jl
+++ b/test/scopedvalues.jl
@@ -69,11 +69,11 @@ end
 @testset "show" begin
     @test sprint(show, ScopedValue{Int}()) == "ScopedValue{$Int}(undefined)"
     @test sprint(show, sval) == "ScopedValue{$Int}(1)"
-    @test sprint(show, ScopedValues.current_scope()) == "nothing"
+    @test sprint(show, Core.current_scope()) == "nothing"
     with(sval => 2.0) do
         @test sprint(show, sval) == "ScopedValue{$Int}(2)"
         objid = sprint(show, Base.objectid(sval))
-        @test sprint(show, ScopedValues.current_scope()) == "Base.ScopedValues.Scope(ScopedValue{$Int}@$objid => 2)"
+        @test sprint(show, Core.current_scope()) == "Base.ScopedValues.Scope(ScopedValue{$Int}@$objid => 2)"
     end
 end
 

From 2f5daca0bc801ab51850026db7be05037af0e59b Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 13 Dec 2023 02:42:02 -0500
Subject: [PATCH 0430/1315] fix alignment of emit_unbox_store copy (#52505)

The dest alignment might be determined to be greater than the source.
For example, observed with:

    code_llvm(dump_module=true, optimize=false, (Int,)) do x
        Pair(ntuple(i -> 0x00, 8), x)
    end

Where the alignment of the first field of the Pair is at least 4, but
the alignment of the ntuple data is 1.

(discovered while analyzing an ARM build failure @staticfloat)
---
 doc/src/devdocs/debuggingtips.md |  7 ++++-
 src/aotcompile.cpp               | 52 ++++++++++++++++++++++++++++++++
 src/cgutils.cpp                  |  3 +-
 src/intrinsics.cpp               |  2 +-
 4 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/doc/src/devdocs/debuggingtips.md b/doc/src/devdocs/debuggingtips.md
index 7639e8be2ef96..a7740b1780b06 100644
--- a/doc/src/devdocs/debuggingtips.md
+++ b/doc/src/devdocs/debuggingtips.md
@@ -41,11 +41,16 @@ useful.
 
 ## Useful Julia functions for Inspecting those variables
 
-  * `jl_gdblookup($rip)` :: For looking up the current function and line. (use `$eip` on i686 platforms)
+  * `jl_print_task_backtraces(0)` :: Similar to gdb's `thread apply all bt` or lldb's `thread backtrace
+    all`. Runs all threads while printing backtraces for all existing tasks.
+  * `jl_gdblookup($pc)` :: For looking up the current function and line.
+  * `jl_gdblookupinfo($pc)` :: For looking up the current method instance object.
+  * `jl_gdbdumpcode(mi)` :: For dumping all of `code_typed/code_llvm/code_asm` when the REPL is not working right.
   * `jlbacktrace()` :: For dumping the current Julia backtrace stack to stderr. Only usable after
     `record_backtrace()` has been called.
   * `jl_dump_llvm_value(Value*)` :: For invoking `Value->dump()` in gdb, where it doesn't work natively.
     For example, `f->linfo->functionObject`, `f->linfo->specFunctionObject`, and `to_function(f->linfo)`.
+  * `jl_dump_llvm_module(Module*)` :: For invoking `Module->dump()` in gdb, where it doesn't work natively.
   * `Type->dump()` :: only works in lldb. Note: add something like `;1` to prevent lldb from printing
     its prompt over the output
   * `jl_eval_string("expr")` :: for invoking side-effects to modify the current state or to lookup
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 64ce3b3f6350c..be70016e45f21 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1820,6 +1820,58 @@ void addTargetPasses(legacy::PassManagerBase *PM, const Triple &triple, TargetIR
     PM->add(createTargetTransformInfoWrapperPass(std::move(analysis)));
 }
 
+// sometimes in GDB you want to find out what code was created from a mi
+extern "C" JL_DLLEXPORT_CODEGEN jl_code_info_t *jl_gdbdumpcode(jl_method_instance_t *mi)
+{
+    jl_llvmf_dump_t llvmf_dump;
+    size_t world = jl_current_task->world_age;
+    JL_STREAM *stream = (JL_STREAM*)STDERR_FILENO;
+
+    jl_printf(stream, "---- dumping IR for ----\n");
+    jl_static_show(stream, (jl_value_t*)mi);
+    jl_printf(stream, "\n----\n");
+
+    jl_printf(stream, "\n---- unoptimized IR ----");
+    jl_get_llvmf_defn(&llvmf_dump, mi, world, 0, false, jl_default_cgparams);
+    if (llvmf_dump.F) {
+        jl_value_t *ir = jl_dump_function_ir(&llvmf_dump, 0, 1, "source");
+        jl_static_show(stream, ir);
+    }
+    jl_printf(stream, "----\n");
+
+    jl_printf(stream, "\n---- optimized IR ----");
+    jl_get_llvmf_defn(&llvmf_dump, mi, world, 0, true, jl_default_cgparams);
+    if (llvmf_dump.F) {
+        jl_value_t *ir = jl_dump_function_ir(&llvmf_dump, 0, 1, "source");
+        jl_static_show(stream, ir);
+    }
+    jl_printf(stream, "----\n");
+
+    jl_printf(stream, "\n---- assembly ----");
+    jl_get_llvmf_defn(&llvmf_dump, mi, world, 0, true, jl_default_cgparams);
+    if (llvmf_dump.F) {
+        jl_value_t *ir = jl_dump_function_asm(&llvmf_dump, 0, "", "source", 0, true);
+        jl_static_show(stream, ir);
+    }
+    jl_printf(stream, "----\n");
+
+    jl_code_info_t *src = NULL;
+    jl_value_t *ci = jl_default_cgparams.lookup(mi, world, world);
+    if (ci != jl_nothing) {
+        jl_code_instance_t *codeinst = (jl_code_instance_t*)ci;
+        src = (jl_code_info_t*)jl_atomic_load_relaxed(&codeinst->inferred);
+        if ((jl_value_t*)src != jl_nothing && !jl_is_code_info(src) && jl_is_method(mi->def.method)) {
+            JL_GC_PUSH2(&codeinst, &src);
+            src = jl_uncompress_ir(mi->def.method, codeinst, (jl_value_t*)src);
+            JL_GC_POP();
+        }
+    }
+    if (!src || (jl_value_t*)src == jl_nothing) {
+        src = jl_type_infer(mi, world, 0);
+    }
+    return src;
+}
+
 // --- native code info, and dump function to IR and ASM ---
 // Get pointer to llvm::Function instance, compiling if necessary
 // for use in reflection from Julia.
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 9f74fee1fb6ae..8c6880d7245cd 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -2911,7 +2911,8 @@ static void init_bits_cgval(jl_codectx_t &ctx, Value *newv, const jl_cgval_t& v,
 {
     // newv should already be tagged
     if (v.ispointer()) {
-        emit_memcpy(ctx, newv, jl_aliasinfo_t::fromTBAA(ctx, tbaa), v, jl_datatype_size(v.typ), sizeof(void*), julia_alignment(v.typ));
+        unsigned align = std::max(julia_alignment(v.typ), (unsigned)sizeof(void*));
+        emit_memcpy(ctx, newv, jl_aliasinfo_t::fromTBAA(ctx, tbaa), v, jl_datatype_size(v.typ), align, julia_alignment(v.typ));
     }
     else {
         init_bits_value(ctx, newv, v.V, tbaa);
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index 81fc9ec1af831..c784727c4f598 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -520,7 +520,7 @@ static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value *dest
     }
 
     Value *src = data_pointer(ctx, x);
-    emit_memcpy(ctx, dest, jl_aliasinfo_t::fromTBAA(ctx, tbaa_dest), src, jl_aliasinfo_t::fromTBAA(ctx, x.tbaa), jl_datatype_size(x.typ), alignment, alignment, isVolatile);
+    emit_memcpy(ctx, dest, jl_aliasinfo_t::fromTBAA(ctx, tbaa_dest), src, jl_aliasinfo_t::fromTBAA(ctx, x.tbaa), jl_datatype_size(x.typ), alignment, julia_alignment(x.typ), isVolatile);
 }
 
 static jl_datatype_t *staticeval_bitstype(const jl_cgval_t &targ)

From 15244663a345a98e2919837fbd6d9e0ad997d5ba Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 13 Dec 2023 17:46:57 +0900
Subject: [PATCH 0431/1315] follow up #52309 (#52499)

---
 base/compiler/ssair/ir.jl     | 10 +++++-----
 base/compiler/ssair/passes.jl |  2 +-
 base/task.jl                  |  2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index c37562a06c2ca..e217141a9a535 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -514,21 +514,21 @@ end
     elseif isa(stmt, GotoIfNot)
         op == 1 || throw(BoundsError())
         stmt = GotoIfNot(v, stmt.dest)
+    elseif isa(stmt, ReturnNode)
+        op == 1 || throw(BoundsError())
+        stmt = ReturnNode(v)
     elseif isa(stmt, EnterNode)
         op == 1 || throw(BoundsError())
         stmt = EnterNode(stmt.catch_dest, v)
-    elseif isa(stmt, ReturnNode)
-        op == 1 || throw(BoundsError())
-        stmt = typeof(stmt)(v)
     elseif isa(stmt, Union{AnySSAValue, GlobalRef})
         op == 1 || throw(BoundsError())
         stmt = v
     elseif isa(stmt, UpsilonNode)
         op == 1 || throw(BoundsError())
-        stmt = typeof(stmt)(v)
+        stmt = UpsilonNode(v)
     elseif isa(stmt, PiNode)
         op == 1 || throw(BoundsError())
-        stmt = typeof(stmt)(v, stmt.typ)
+        stmt = PiNode(v, stmt.typ)
     elseif isa(stmt, PhiNode)
         op > length(stmt.values) && throw(BoundsError())
         isassigned(stmt.values, op) || throw(BoundsError())
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index fdd7c0d3b48aa..727edd2825933 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -2345,7 +2345,7 @@ function cfg_simplify!(ir::IRCode)
         @assert length(new_bb.succs) <= 2
         length(new_bb.succs) <= 1 && continue
         if new_bb.succs[1] == new_bb.succs[2]
-            old_bb2 = findfirst(x::Int->x==bbidx, bb_rename_pred)
+            old_bb2 = findfirst(x::Int->x==bbidx, bb_rename_pred)::Int
             terminator = ir[SSAValue(last(bbs[old_bb2].stmts))]
             @assert terminator[:stmt] isa GotoIfNot
             # N.B.: The dest will be renamed in process_node! below
diff --git a/base/task.jl b/base/task.jl
index 79e85024ac0d0..ba96d7bca5095 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -191,7 +191,7 @@ end
     if field === :scope
         istaskstarted(t) && error("Setting scope on a started task directly is disallowed.")
     end
-    return @invoke setproperty!(t::Any, field, v)
+    return @invoke setproperty!(t::Any, field::Symbol, v::Any)
 end
 
 """

From 282e466923dedde4e25e53b8ec0e9e41c82cbf67 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 13 Dec 2023 09:54:42 -0500
Subject: [PATCH 0432/1315] spawn: permit using IOBuffer as stdout (#52461)

People expect to use this (the docs even almost even suggested it at
some point), so it is better to make it work as expected (and better
than they can emulate) than to criticize their choices.

Also fix a few regressions and handling mistakes in setup_stdios:
- #44500 tried to store a Redirectable into a SpawnIO, dropping
FileRedirect
- CmdRedirect did not allocate a ProcessChain, so it would call
setup_stdio then call setup_stdios on the result of that, which is
strongly discouraged as setup_stdio(s) should only be called once
- BufferStream was missing `check_open` calls before writing, and
ignored `Base.reseteof` as a possible means of resuming writing after
`closewrite` sends a shutdown message.
 - Add `closewrite` to more methods, and document it.

Fixes #39311
Fixes #49234
Fixes #49233
Fixes #46768
---
 NEWS.md                         |   8 ++
 base/coreio.jl                  |   1 +
 base/exports.jl                 |  10 +++
 base/filesystem.jl              |   2 +
 base/io.jl                      |  12 +++
 base/iobuffer.jl                |   1 -
 base/iostream.jl                |   2 +
 base/process.jl                 | 131 ++++++++++++++++++++------------
 base/stream.jl                  |  17 ++++-
 src/support/ios.c               |  12 ++-
 stdlib/Profile/test/runtests.jl |  25 +++---
 test/cmdlineargs.jl             |   1 +
 test/compiler/ssair.jl          |   2 +-
 test/spawn.jl                   |   3 +-
 14 files changed, 162 insertions(+), 65 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 3a2fc922a17eb..feb51b0fa40ad 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -73,6 +73,14 @@ New library features
   write the output to a stream rather than returning a string ([#48625]).
 * `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
 * New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
+* Passing an IOBuffer as a stdout argument for Process spawn now works as
+  expected, synchronized with `wait` or `success`, so a `Base.BufferStream` is
+  no longer required there for correctness to avoid data-races ([#TBD]).
+* After a process exits, `closewrite` will no longer be automatically called on
+  the stream passed to it. Call `wait` on the process instead to ensure the
+  content is fully written, then call `closewrite` manually to avoid
+  data-races. Or use the callback form of `open` to have all that handled
+  automatically.
 
 Standard library changes
 ------------------------
diff --git a/base/coreio.jl b/base/coreio.jl
index 3e508c64a0a64..7fc608111d5f2 100644
--- a/base/coreio.jl
+++ b/base/coreio.jl
@@ -11,6 +11,7 @@ struct DevNull <: IO end
 const devnull = DevNull()
 write(::DevNull, ::UInt8) = 1
 unsafe_write(::DevNull, ::Ptr{UInt8}, n::UInt)::Int = n
+closewrite(::DevNull) = nothing
 close(::DevNull) = nothing
 wait_close(::DevNull) = wait()
 bytesavailable(io::DevNull) = 0
diff --git a/base/exports.jl b/base/exports.jl
index 374016f22571f..92525b85c7635 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1156,6 +1156,16 @@ public
     @locals,
     @propagate_inbounds,
 
+# IO
+    # types
+    BufferStream,
+    IOServer,
+    OS_HANDLE,
+    PipeEndpoint,
+    TTY,
+    # functions
+    reseteof,
+
 # misc
     notnothing,
     runtests,
diff --git a/base/filesystem.jl b/base/filesystem.jl
index d291dd3b31630..d9760ec08a8a9 100644
--- a/base/filesystem.jl
+++ b/base/filesystem.jl
@@ -143,6 +143,8 @@ function close(f::File)
     nothing
 end
 
+closewrite(f::File) = nothing
+
 # sendfile is the most efficient way to copy from a file descriptor
 function sendfile(dst::File, src::File, src_offset::Int64, bytes::Int)
     check_open(dst)
diff --git a/base/io.jl b/base/io.jl
index a2e68882bbc86..fd286297ec090 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -25,6 +25,14 @@ end
 
 lock(::IO) = nothing
 unlock(::IO) = nothing
+
+"""
+    reseteof(io)
+
+Clear the EOF flag from IO so that further reads (and possibly writes) are
+again allowed. Note that it may immediately get re-set, if the underlying
+stream object is at EOF and cannot be resumed.
+"""
 reseteof(x::IO) = nothing
 
 const SZ_UNBUFFERED_IO = 65536
@@ -68,6 +76,10 @@ Shutdown the write half of a full-duplex I/O stream. Performs a [`flush`](@ref)
 first. Notify the other end that no more data will be written to the underlying
 file. This is not supported by all IO types.
 
+If implemented, `closewrite` causes subsequent `read` or `eof` calls that would
+block to instead throw EOF or return true, respectively. If the stream is
+already closed, this is idempotent.
+
 # Examples
 ```jldoctest
 julia> io = Base.BufferStream(); # this never blocks, so we can read and write on the same Task
diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index 4407d7327ce6f..895205549bc7e 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -350,7 +350,6 @@ eof(io::GenericIOBuffer) = (io.ptr-1 == io.size)
 
 function closewrite(io::GenericIOBuffer)
     io.writable = false
-    # OR throw(_UVError("closewrite", UV_ENOTSOCK))
     nothing
 end
 
diff --git a/base/iostream.jl b/base/iostream.jl
index b048d8a5f1d01..ba422cd692fcd 100644
--- a/base/iostream.jl
+++ b/base/iostream.jl
@@ -63,6 +63,8 @@ function close(s::IOStream)
     systemerror("close", bad)
 end
 
+closewrite(s::IOStream) = nothing
+
 function flush(s::IOStream)
     sigatomic_begin()
     bad = @_lock_ios s ccall(:ios_flush, Cint, (Ptr{Cvoid},), s.ios) != 0
diff --git a/base/process.jl b/base/process.jl
index ed51a30ae3ced..24e676138bfae 100644
--- a/base/process.jl
+++ b/base/process.jl
@@ -6,11 +6,12 @@ mutable struct Process <: AbstractPipe
     in::IO
     out::IO
     err::IO
+    syncd::Vector{Task}
     exitcode::Int64
     termsignal::Int32
     exitnotify::ThreadSynchronizer
-    function Process(cmd::Cmd, handle::Ptr{Cvoid})
-        this = new(cmd, handle, devnull, devnull, devnull,
+    function Process(cmd::Cmd, handle::Ptr{Cvoid}, syncd::Vector{Task})
+        this = new(cmd, handle, devnull, devnull, devnull, syncd,
                    typemin(fieldtype(Process, :exitcode)),
                    typemin(fieldtype(Process, :termsignal)),
                    ThreadSynchronizer())
@@ -35,6 +36,15 @@ end
 pipe_reader(p::ProcessChain) = p.out
 pipe_writer(p::ProcessChain) = p.in
 
+# a lightweight pair of a child OS_HANDLE and associated Task that will
+# complete only after all content has been read from it for synchronizing
+# state without the kernel to aide
+struct SyncCloseFD
+    fd
+    t::Task
+end
+rawhandle(io::SyncCloseFD) = rawhandle(io.fd)
+
 # release ownership of the libuv handle
 function uvfinalize(proc::Process)
     if proc.handle != C_NULL
@@ -74,8 +84,8 @@ function _uv_hook_close(proc::Process)
     nothing
 end
 
-const SpawnIO  = Union{IO, RawFD, OS_HANDLE}
-const SpawnIOs = Vector{SpawnIO} # convenience name for readability
+const SpawnIO  = Union{IO, RawFD, OS_HANDLE, SyncCloseFD} # internal copy of Redirectable, removing FileRedirect and adding SyncCloseFD
+const SpawnIOs = Memory{SpawnIO} # convenience name for readability (used for dispatch also to clearly distinguish from Vector{Redirectable})
 
 function as_cpumask(cpus::Vector{UInt16})
     n = max(Int(maximum(cpus)), Int(ccall(:uv_cpumask_size, Cint, ())))
@@ -100,6 +110,7 @@ end
                 error("invalid spawn handle $h from $io")
             end
             for io in stdio]
+        syncd = Task[io.t for io in stdio if io isa SyncCloseFD]
         handle = Libc.malloc(_sizeof_uv_process)
         disassociate_julia_struct(handle)
         (; exec, flags, env, dir) = cmd
@@ -117,7 +128,7 @@ end
             cpumask === nothing ? 0 : length(cpumask),
             @cfunction(uv_return_spawn, Cvoid, (Ptr{Cvoid}, Int64, Int32)))
         if err == 0
-            pp = Process(cmd, handle)
+            pp = Process(cmd, handle, syncd)
             associate_julia_struct(handle, pp)
         else
             ccall(:jl_forceclose_uv, Cvoid, (Ptr{Cvoid},), handle) # will call free on handle eventually
@@ -130,23 +141,24 @@ end
     return pp
 end
 
-_spawn(cmds::AbstractCmd) = _spawn(cmds, SpawnIO[])
+_spawn(cmds::AbstractCmd) = _spawn(cmds, SpawnIOs())
 
-# optimization: we can spawn `Cmd` directly without allocating the ProcessChain
-function _spawn(cmd::Cmd, stdios::SpawnIOs)
-    isempty(cmd.exec) && throw(ArgumentError("cannot spawn empty command"))
+function _spawn(cmd::AbstractCmd, stdios::Vector{Redirectable})
     pp = setup_stdios(stdios) do stdios
-        return _spawn_primitive(cmd.exec[1], cmd, stdios)
+        return _spawn(cmd, stdios)
     end
     return pp
 end
 
+# optimization: we can spawn `Cmd` directly without allocating the ProcessChain
+function _spawn(cmd::Cmd, stdios::SpawnIOs)
+    isempty(cmd.exec) && throw(ArgumentError("cannot spawn empty command"))
+    return _spawn_primitive(cmd.exec[1], cmd, stdios)
+end
+
 # assume that having a ProcessChain means that the stdio are setup
 function _spawn(cmds::AbstractCmd, stdios::SpawnIOs)
-    pp = setup_stdios(stdios) do stdios
-        return _spawn(cmds, stdios, ProcessChain())
-    end
-    return pp
+    return _spawn(cmds, stdios, ProcessChain())
 end
 
 # helper function for making a copy of a SpawnIOs, with replacement
@@ -212,7 +224,7 @@ end
 
 
 # open the child end of each element of `stdios`, and initialize the parent end
-function setup_stdios(f, stdios::SpawnIOs)
+function setup_stdios(f, stdios::Vector{Redirectable})
     nstdio = length(stdios)
     open_io = SpawnIOs(undef, nstdio)
     close_io = falses(nstdio)
@@ -295,25 +307,26 @@ function setup_stdio(stdio::IO, child_readable::Bool)
     child = child_readable ? rd : wr
     try
         let in = (child_readable ? parent : stdio),
-            out = (child_readable ? stdio : parent)
-            @async try
+            out = (child_readable ? stdio : parent),
+            t = @async try
                 write(in, out)
             catch ex
                 @warn "Process I/O error" exception=(ex, catch_backtrace())
+                rethrow()
             finally
                 close(parent)
-                child_readable || closewrite(stdio)
             end
+            return (SyncCloseFD(child, t), true)
         end
     catch
         close_pipe_sync(child)
         rethrow()
     end
-    return (child, true)
 end
 
-close_stdio(stdio::OS_HANDLE) = close_pipe_sync(stdio)
 close_stdio(stdio) = close(stdio)
+close_stdio(stdio::OS_HANDLE) = close_pipe_sync(stdio)
+close_stdio(stdio::SyncCloseFD) = close_stdio(stdio.fd)
 
 # INTERNAL
 # pad out stdio to have at least three elements,
@@ -325,19 +338,19 @@ close_stdio(stdio) = close(stdio)
 #   - An Filesystem.File or IOStream object to redirect the output to
 #   - A FileRedirect, containing a string specifying a filename to be opened for the child
 
-spawn_opts_swallow(stdios::StdIOSet) = SpawnIO[stdios...]
-spawn_opts_inherit(stdios::StdIOSet) = SpawnIO[stdios...]
+spawn_opts_swallow(stdios::StdIOSet) = Redirectable[stdios...]
+spawn_opts_inherit(stdios::StdIOSet) = Redirectable[stdios...]
 spawn_opts_swallow(in::Redirectable=devnull, out::Redirectable=devnull, err::Redirectable=devnull) =
-    SpawnIO[in, out, err]
+    Redirectable[in, out, err]
 # pass original descriptors to child processes by default, because we might
 # have already exhausted and closed the libuv object for our standard streams.
 # ref issue #8529
 spawn_opts_inherit(in::Redirectable=RawFD(0), out::Redirectable=RawFD(1), err::Redirectable=RawFD(2)) =
-    SpawnIO[in, out, err]
+    Redirectable[in, out, err]
 
 function eachline(cmd::AbstractCmd; keep::Bool=false)
     out = PipeEndpoint()
-    processes = _spawn(cmd, SpawnIO[devnull, out, stderr])
+    processes = _spawn(cmd, Redirectable[devnull, out, stderr])
     # if the user consumes all the data, also check process exit status for success
     ondone = () -> (success(processes) || pipeline_error(processes); nothing)
     return EachLine(out, keep=keep, ondone=ondone)::EachLine
@@ -385,20 +398,20 @@ function open(cmds::AbstractCmd, stdio::Redirectable=devnull; write::Bool=false,
         stdio === devnull || throw(ArgumentError("no stream can be specified for `stdio` in read-write mode"))
         in = PipeEndpoint()
         out = PipeEndpoint()
-        processes = _spawn(cmds, SpawnIO[in, out, stderr])
+        processes = _spawn(cmds, Redirectable[in, out, stderr])
         processes.in = in
         processes.out = out
     elseif read
         out = PipeEndpoint()
-        processes = _spawn(cmds, SpawnIO[stdio, out, stderr])
+        processes = _spawn(cmds, Redirectable[stdio, out, stderr])
         processes.out = out
     elseif write
         in = PipeEndpoint()
-        processes = _spawn(cmds, SpawnIO[in, stdio, stderr])
+        processes = _spawn(cmds, Redirectable[in, stdio, stderr])
         processes.in = in
     else
         stdio === devnull || throw(ArgumentError("no stream can be specified for `stdio` in no-access mode"))
-        processes = _spawn(cmds, SpawnIO[devnull, devnull, stderr])
+        processes = _spawn(cmds, Redirectable[devnull, devnull, stderr])
     end
     return processes
 end
@@ -415,12 +428,18 @@ function open(f::Function, cmds::AbstractCmd, args...; kwargs...)
     P = open(cmds, args...; kwargs...)
     function waitkill(P::Union{Process,ProcessChain})
         close(P)
-        # 0.1 seconds after we hope it dies (from closing stdio),
-        # we kill the process with SIGTERM (15)
-        local t = Timer(0.1) do t
+        # shortly after we hope it starts cleanup and dies (from closing
+        # stdio), we kill the process with SIGTERM (15) so that we can proceed
+        # with throwing the error and hope it will exit soon from that
+        local t = Timer(2) do t
             process_running(P) && kill(P)
         end
-        wait(P)
+        # pass false to indicate that we do not care about data-races on the
+        # Julia stdio objects after this point, since we already know this is
+        # an error path and the state of them is fairly unpredictable anyways
+        # in that case. Since we closed P some of those should come crumbling
+        # down already, and we don't want to throw that error here either.
+        wait(P, false)
         close(t)
     end
     ret = try
@@ -430,10 +449,23 @@ function open(f::Function, cmds::AbstractCmd, args...; kwargs...)
         rethrow()
     end
     close(P.in)
+    closestdio = @async begin
+        # wait for P to complete (including sync'd), then mark the output streams for EOF (if applicable to that stream type)
+        wait(P)
+        err = P.err
+        applicable(closewrite, err) && closewrite(err)
+        out = P.out
+        applicable(closewrite, out) && closewrite(out)
+        nothing
+    end
+    # now verify that the output stream is at EOF, and the user didn't fail to consume it successfully
+    # (we do not currently verify the user dealt with the stderr stream)
     if !(eof(P.out)::Bool)
         waitkill(P)
         throw(_UVError("open(do)", UV_EPIPE))
     end
+    # make sure to closestdio is completely done to avoid data-races later
+    wait(closestdio)
     success(P) || pipeline_error(P)
     return ret
 end
@@ -650,26 +682,31 @@ function process_status(s::Process)
            error("process status error")
 end
 
-function wait(x::Process)
-    process_exited(x) && return
-    iolock_begin()
+function wait(x::Process, syncd::Bool=true)
     if !process_exited(x)
-        preserve_handle(x)
-        lock(x.exitnotify)
-        iolock_end()
-        try
-            wait(x.exitnotify)
-        finally
-            unlock(x.exitnotify)
-            unpreserve_handle(x)
+        iolock_begin()
+        if !process_exited(x)
+            preserve_handle(x)
+            lock(x.exitnotify)
+            iolock_end()
+            try
+                wait(x.exitnotify)
+            finally
+                unlock(x.exitnotify)
+                unpreserve_handle(x)
+            end
+        else
+            iolock_end()
         end
-    else
-        iolock_end()
+    end
+    # and make sure all sync'd Tasks are complete too
+    syncd && for t in x.syncd
+        wait(t)
     end
     nothing
 end
 
-wait(x::ProcessChain) = foreach(wait, x.processes)
+wait(x::ProcessChain, syncd::Bool=true) = foreach(p -> wait(p, syncd), x.processes)
 
 show(io::IO, p::Process) = print(io, "Process(", p.cmd, ", ", process_status(p), ")")
 
diff --git a/base/stream.jl b/base/stream.jl
index 22af8d59359f3..3124b8b0c0a24 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -436,7 +436,10 @@ end
 
 function closewrite(s::LibuvStream)
     iolock_begin()
-    check_open(s)
+    if !iswritable(s)
+        iolock_end()
+        return
+    end
     req = Libc.malloc(_sizeof_uv_shutdown)
     uv_req_set_data(req, C_NULL) # in case we get interrupted before arriving at the wait call
     err = ccall(:uv_shutdown, Int32, (Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}),
@@ -1489,7 +1492,7 @@ closewrite(s::BufferStream) = close(s)
 function close(s::BufferStream)
     lock(s.cond) do
         s.status = StatusClosed
-        notify(s.cond)
+        notify(s.cond) # aka flush
         nothing
     end
 end
@@ -1549,6 +1552,7 @@ stop_reading(s::BufferStream) = nothing
 write(s::BufferStream, b::UInt8) = write(s, Ref{UInt8}(b))
 function unsafe_write(s::BufferStream, p::Ptr{UInt8}, nb::UInt)
     nwrite = lock(s.cond) do
+        check_open(s)
         rv = unsafe_write(s.buffer, p, nb)
         s.buffer_writes || notify(s.cond)
         rv
@@ -1569,9 +1573,18 @@ end
 buffer_writes(s::BufferStream, bufsize=0) = (s.buffer_writes = true; s)
 function flush(s::BufferStream)
     lock(s.cond) do
+        check_open(s)
         notify(s.cond)
         nothing
     end
 end
 
 skip(s::BufferStream, n) = skip(s.buffer, n)
+
+function reseteof(x::BufferStream)
+    lock(s.cond) do
+        s.status = StatusOpen
+        nothing
+    end
+    nothing
+end
diff --git a/src/support/ios.c b/src/support/ios.c
index 2c20dcb45e4c4..7f70112c82cc0 100644
--- a/src/support/ios.c
+++ b/src/support/ios.c
@@ -602,12 +602,12 @@ int ios_eof(ios_t *s)
 {
     if (s->state == bst_rd && s->bpos < s->size)
         return 0;
+    if (s->_eof)
+        return 1;
     if (s->bm == bm_mem)
-        return (s->_eof ? 1 : 0);
+        return 0;
     if (s->fd == -1)
         return 1;
-    if (s->_eof)
-        return 1;
     return 0;
     /*
     if (_fd_available(s->fd))
@@ -617,6 +617,12 @@ int ios_eof(ios_t *s)
     */
 }
 
+void ios_reseteof(ios_t *s)
+{
+    if (s->bm != bm_mem && s->fd != -1)
+        s->_eof = 0;
+}
+
 int ios_eof_blocking(ios_t *s)
 {
     if (s->state == bst_rd && s->bpos < s->size)
diff --git a/stdlib/Profile/test/runtests.jl b/stdlib/Profile/test/runtests.jl
index eccfeea846a23..39da65952bf24 100644
--- a/stdlib/Profile/test/runtests.jl
+++ b/stdlib/Profile/test/runtests.jl
@@ -171,7 +171,7 @@ let cmd = Base.julia_cmd()
     p = open(`$cmd -e $script`)
     t = Timer(120) do t
         # should be under 10 seconds, so give it 2 minutes then report failure
-        println("KILLING BY PROFILE TEST WATCHDOG\n")
+        println("KILLING debuginfo registration test BY PROFILE TEST WATCHDOG\n")
         kill(p, Base.SIGTERM)
         sleep(10)
         kill(p, Base.SIGKILL)
@@ -191,16 +191,21 @@ if Sys.isbsd() || Sys.islinux()
                 print(stderr, "started\n")
                 eof(stdin)
                 """
-            iob = Base.BufferStream()
+            iob = Base.BufferStream() # make an unbounded buffer, so we can just read after waiting for exit
             notify_exit = Base.PipeEndpoint()
-            p = run(pipeline(`$cmd -e $script`, stdin=notify_exit, stderr=iob, stdout=devnull), wait=false)
-            t = Timer(120) do t
+            p = run(`$cmd -e $script`, notify_exit, devnull, iob, wait=false)
+            eof = @async try # set up a monitor task to set EOF on iob after p exits
+                wait(p)
+            finally
+                closewrite(iob)
+            end
+            t = Timer(10) do t
                 # should be under 10 seconds, so give it 2 minutes then report failure
-                println("KILLING BY PROFILE TEST WATCHDOG\n")
+                println("KILLING siginfo/sigusr1 test BY PROFILE TEST WATCHDOG\n")
                 kill(p, Base.SIGTERM)
                 sleep(10)
                 kill(p, Base.SIGKILL)
-                close(p)
+                close(notify_exit)
             end
             try
                 s = readuntil(iob, "started", keep=true)
@@ -219,18 +224,18 @@ if Sys.isbsd() || Sys.islinux()
                     @test occursin("Overhead ╎", s)
                 end
                 close(notify_exit) # notify test finished
-                s = read(iob, String) # consume test output
-                wait(p) # wait for test completion
-                @test success(p)
+                wait(eof) # wait for test completion
+                s = read(iob, String) # consume test output from buffer
                 close(t)
             catch
                 close(notify_exit)
+                wait(eof) # wait for test completion
                 errs = read(iob, String) # consume test output
                 isempty(errs) || println("CHILD STDERR after test failure: ", errs)
-                wait(p) # wait for test completion
                 close(t)
                 rethrow()
             end
+            @test success(p)
         end
     end
 end
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 564f352424369..92bada23cb258 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -71,6 +71,7 @@ end
             @error "cmd failed" cmd read(io, String)
             rethrow()
         end
+        closewrite(io)
         return read(io, String)
     end
 
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index d72a9bce8bc90..491638f7596d9 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -337,7 +337,7 @@ let # https://github.com/JuliaLang/julia/issues/42258
         code_typed(Core.Compiler.setindex!, (Core.Compiler.UseRef,Core.Compiler.NewSSAValue); optimize=true)
         """
     cmd = `$(Base.julia_cmd()) -g 2 -e $code`
-    stderr = Base.BufferStream()
+    stderr = IOBuffer()
     @test success(pipeline(Cmd(cmd); stdout, stderr))
     @test readchomp(stderr) == ""
 end
diff --git a/test/spawn.jl b/test/spawn.jl
index dab1857399375..4ae4b3368bef6 100644
--- a/test/spawn.jl
+++ b/test/spawn.jl
@@ -807,8 +807,9 @@ let text = "input-test-text"
     out = Base.BufferStream()
     proc = run(catcmd, IOBuffer(text), out, wait=false)
     @test proc.out === out
-    @test read(out, String) == text
     @test success(proc)
+    closewrite(out)
+    @test read(out, String) == text
 
     out = PipeBuffer()
     proc = run(catcmd, IOBuffer(SubString(text)), out)

From c601f39fed8d7240c2efd4f5b07aefb0fc85e78d Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Wed, 13 Dec 2023 10:05:00 -0500
Subject: [PATCH 0433/1315] Update crc32c.c register constraints again (#52437)

As suggested in #52326#issuecomment-1840999660

For https://github.com/JuliaPackaging/Yggdrasil/pull/7757#issuecomment-1840604944
---
 src/crc32c.c | 45 +++++++++++++++++++--------------------------
 1 file changed, 19 insertions(+), 26 deletions(-)

diff --git a/src/crc32c.c b/src/crc32c.c
index 844a6e34156e6..b38f9d6c0e765 100644
--- a/src/crc32c.c
+++ b/src/crc32c.c
@@ -56,14 +56,9 @@
 #define POLY 0x82f63b78
 
 /* Block sizes for three-way parallel crc computation.  LONG and SHORT must
-   both be powers of two.  The associated string constants must be set
-   accordingly, for use in constructing the assembler instructions. */
+   both be powers of two. */
 #define LONG 8192
-#define LONGx1 "8192"
-#define LONGx2 "16384"
 #define SHORT 256
-#define SHORTx1 "256"
-#define SHORTx2 "512"
 
 #ifndef GEN_CRC32C_TABLES
 #include "crc32c-tables.c"
@@ -100,9 +95,9 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
     /* compute the crc for up to seven leading bytes to bring the data pointer
        to an eight-byte boundary */
     while (len && ((uintptr_t)buf & 7) != 0) {
-        __asm__("crc32b\t" "(%1), %0"
+        __asm__("crc32b\t" "%1, %0"
                 : "+r"(crc0)
-                : "r"(buf), "m"(*buf));
+                : "m"(*buf));
         buf++;
         len--;
     }
@@ -114,14 +109,13 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
         uintptr_t crc2 = 0;
         const char *end = buf + LONG;
         do {
-            __asm__(CRC32_PTR "\t" "(%3), %0\n\t"
-                    CRC32_PTR "\t" LONGx1 "(%3), %1\n\t"
-                    CRC32_PTR "\t" LONGx2 "(%3), %2"
+            __asm__(CRC32_PTR "\t%3, %0\n\t"
+                    CRC32_PTR "\t%4, %1\n\t"
+                    CRC32_PTR "\t%5, %2"
                     : "+r"(crc0), "+r"(crc1), "+r"(crc2)
-                    : "r"(buf),
-                      "m"(* (const char (*)[sizeof(void*)]) &buf[0]),
-                      "m"(* (const char (*)[sizeof(void*)]) &buf[LONG]),
-                      "m"(* (const char (*)[sizeof(void*)]) &buf[LONG*2]));
+                    : "m"(* (const uintptr_t *) &buf[0]),
+                      "m"(* (const uintptr_t *) &buf[LONG]),
+                      "m"(* (const uintptr_t *) &buf[LONG*2]));
             buf += sizeof(void*);
         } while (buf < end);
         crc0 = crc32c_shift(crc32c_long, crc0) ^ crc1;
@@ -137,14 +131,13 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
         uintptr_t crc2 = 0;
         const char *end = buf + SHORT;
         do {
-            __asm__(CRC32_PTR "\t" "(%3), %0\n\t"
-                    CRC32_PTR "\t" SHORTx1 "(%3), %1\n\t"
-                    CRC32_PTR "\t" SHORTx2 "(%3), %2"
+            __asm__(CRC32_PTR "\t%3, %0\n\t"
+                    CRC32_PTR "\t%4, %1\n\t"
+                    CRC32_PTR "\t%5, %2"
                     : "+r"(crc0), "+r"(crc1), "+r"(crc2)
-                    : "r"(buf),
-                      "m"(* (const char (*)[sizeof(void*)]) &buf[0]),
-                      "m"(* (const char (*)[sizeof(void*)]) &buf[SHORT]),
-                      "m"(* (const char (*)[sizeof(void*)]) &buf[SHORT*2]));
+                    : "m"(* (const uintptr_t *) &buf[0]),
+                      "m"(* (const uintptr_t *) &buf[SHORT]),
+                      "m"(* (const uintptr_t *) &buf[SHORT*2]));
             buf += sizeof(void*);
         } while (buf < end);
         crc0 = crc32c_shift(crc32c_short, crc0) ^ crc1;
@@ -157,18 +150,18 @@ static uint32_t crc32c_sse42(uint32_t crc, const char *buf, size_t len)
        block */
     const char *end = buf + (len - (len & 7));
     while (buf < end) {
-        __asm__(CRC32_PTR "\t" "(%1), %0"
+        __asm__(CRC32_PTR "\t" "%1, %0"
                 : "+r"(crc0)
-                : "r"(buf), "m"(* (const char (*)[sizeof(void*)]) buf));
+                : "m"(* (const uintptr_t *) buf));
         buf += sizeof(void*);
     }
     len &= 7;
 
     /* compute the crc for up to seven trailing bytes */
     while (len) {
-        __asm__("crc32b\t" "(%1), %0"
+        __asm__("crc32b\t" "%1, %0"
                 : "+r"(crc0)
-                : "r"(buf), "m"(*buf));
+                : "m"(*buf));
         buf++;
         len--;
     }

From c92ce0a65589a1fc6379feeb26502a7bfe3139ea Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 12 Dec 2023 18:27:19 +0000
Subject: [PATCH 0434/1315] Reland "gc: avoid cpu stalls when starting"

This reverts commit 4801b6ce9a4d737ad1722ca620a7bc8087590f2e and adds
the safepoints needed to catch the unsafe->safe transition also and the
locks needed for the condition broadcast message to be seen.
---
 src/gc-debug.c            |  1 -
 src/gc.c                  | 27 +------------
 src/julia_internal.h      | 12 +-----
 src/julia_threads.h       |  6 +--
 src/llvm-codegen-shared.h |  4 +-
 src/rtutils.c             |  4 +-
 src/safepoint.c           | 82 +++++++++++++++++++++++++++++++++------
 src/signals-mach.c        |  2 +
 8 files changed, 82 insertions(+), 56 deletions(-)

diff --git a/src/gc-debug.c b/src/gc-debug.c
index 87861a5d89b9c..84db461ce2b0a 100644
--- a/src/gc-debug.c
+++ b/src/gc-debug.c
@@ -83,7 +83,6 @@ void add_lostval_parent(jl_value_t *parent)
  innocent looking functions which allocate (and thus trigger marking) only on special cases.
 
  If you can't find it, you can try the following :
- - Ensure that should_timeout() is deterministic instead of clock based.
  - Once you have a completely deterministic program which crashes on gc_verify, the addresses
    should stay constant between different runs (with same binary, same environment ...).
    Do not forget to turn off ASLR (linux: echo 0 > /proc/sys/kernel/randomize_va_space).
diff --git a/src/gc.c b/src/gc.c
index 17975a075dea4..31e2da6ff997a 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -222,32 +222,7 @@ NOINLINE uintptr_t gc_get_stack_ptr(void)
     return (uintptr_t)jl_get_frame_addr();
 }
 
-#define should_timeout() 0
-
-void jl_gc_wait_for_the_world(jl_ptls_t* gc_all_tls_states, int gc_n_threads)
-{
-    JL_TIMING(GC, GC_Stop);
-#ifdef USE_TRACY
-    TracyCZoneCtx ctx = JL_TIMING_DEFAULT_BLOCK->tracy_ctx;
-    TracyCZoneColor(ctx, 0x696969);
-#endif
-    assert(gc_n_threads);
-    if (gc_n_threads > 1)
-        jl_wake_libuv();
-    for (int i = 0; i < gc_n_threads; i++) {
-        jl_ptls_t ptls2 = gc_all_tls_states[i];
-        if (ptls2 != NULL) {
-            // This acquire load pairs with the release stores
-            // in the signal handler of safepoint so we are sure that
-            // all the stores on those threads are visible.
-            // We're currently also using atomic store release in mutator threads
-            // (in jl_gc_state_set), but we may want to use signals to flush the
-            // memory operations on those threads lazily instead.
-            while (!jl_atomic_load_relaxed(&ptls2->gc_state) || !jl_atomic_load_acquire(&ptls2->gc_state))
-                jl_cpu_pause(); // yield?
-        }
-    }
-}
+void jl_gc_wait_for_the_world(jl_ptls_t* gc_all_tls_states, int gc_n_threads);
 
 // malloc wrappers, aligned allocation
 
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 9105a291ac82b..7f9cf06798ce0 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -966,17 +966,7 @@ JL_DLLEXPORT void jl_pgcstack_getkey(jl_get_pgcstack_func **f, jl_pgcstack_key_t
 extern pthread_mutex_t in_signal_lock;
 #endif
 
-static inline void jl_set_gc_and_wait(void) // n.b. not used on _OS_DARWIN_
-{
-    jl_task_t *ct = jl_current_task;
-    // reading own gc state doesn't need atomic ops since no one else
-    // should store to it.
-    int8_t state = jl_atomic_load_relaxed(&ct->ptls->gc_state);
-    jl_atomic_store_release(&ct->ptls->gc_state, JL_GC_STATE_WAITING);
-    jl_safepoint_wait_gc();
-    jl_atomic_store_release(&ct->ptls->gc_state, state);
-    jl_safepoint_wait_thread_resume(); // block in thread-suspend now if requested, after clearing the gc_state
-}
+void jl_set_gc_and_wait(void); // n.b. not used on _OS_DARWIN_
 
 // Query if a Julia object is if a permalloc region (due to part of a sys- pkg-image)
 STATIC_INLINE size_t n_linkage_blobs(void) JL_NOTSAFEPOINT
diff --git a/src/julia_threads.h b/src/julia_threads.h
index af7df23447c01..292c11f61d60d 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -347,9 +347,9 @@ STATIC_INLINE int8_t jl_gc_state_set(jl_ptls_t ptls, int8_t state,
                                      int8_t old_state)
 {
     jl_atomic_store_release(&ptls->gc_state, state);
-    // A safe point is required if we transition from GC-safe region to
-    // non GC-safe region.
-    if (old_state && !state)
+    if (state == JL_GC_STATE_SAFE && old_state == 0)
+        jl_gc_safepoint_(ptls);
+    if (state == 0 && old_state == JL_GC_STATE_SAFE)
         jl_gc_safepoint_(ptls);
     return old_state;
 }
diff --git a/src/llvm-codegen-shared.h b/src/llvm-codegen-shared.h
index b78a3bea9c0ef..a4f77bc1b3b38 100644
--- a/src/llvm-codegen-shared.h
+++ b/src/llvm-codegen-shared.h
@@ -304,8 +304,8 @@ static inline llvm::Value *emit_gc_state_set(llvm::IRBuilder<> &builder, llvm::T
     BasicBlock *passBB = BasicBlock::Create(builder.getContext(), "safepoint", builder.GetInsertBlock()->getParent());
     BasicBlock *exitBB = BasicBlock::Create(builder.getContext(), "after_safepoint", builder.GetInsertBlock()->getParent());
     Constant *zero8 = ConstantInt::get(T_int8, 0);
-    builder.CreateCondBr(builder.CreateAnd(builder.CreateICmpNE(old_state, zero8), // if (old_state && !state)
-                                           builder.CreateICmpEQ(state, zero8)),
+    builder.CreateCondBr(builder.CreateOr(builder.CreateICmpEQ(old_state, zero8), // if (!old_state || !state)
+                                          builder.CreateICmpEQ(state, zero8)),
                          passBB, exitBB);
     builder.SetInsertPoint(passBB);
     MDNode *tbaa = get_tbaa_const(builder.getContext());
diff --git a/src/rtutils.c b/src/rtutils.c
index 5fbba42c15b02..74f66ae0b1769 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -281,7 +281,6 @@ JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh)
     // This function should **NOT** have any safepoint before the ones at the
     // end.
     sig_atomic_t old_defer_signal = ct->ptls->defer_signal;
-    int8_t old_gc_state = jl_atomic_load_relaxed(&ct->ptls->gc_state);
     ct->eh = eh->prev;
     ct->gcstack = eh->gcstack;
     small_arraylist_t *locks = &ct->ptls->locks;
@@ -293,9 +292,10 @@ JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh)
     }
     ct->world_age = eh->world_age;
     ct->ptls->defer_signal = eh->defer_signal;
+    int8_t old_gc_state = jl_atomic_load_relaxed(&ct->ptls->gc_state);
     if (old_gc_state != eh->gc_state)
         jl_atomic_store_release(&ct->ptls->gc_state, eh->gc_state);
-    if (!eh->gc_state)
+    if (!old_gc_state || !eh->gc_state) // it was or is unsafe now
         jl_gc_safepoint_(ct->ptls);
     if (old_defer_signal && !eh->defer_signal)
         jl_sigint_safepoint(ct->ptls);
diff --git a/src/safepoint.c b/src/safepoint.c
index 51dae64e84e72..a05d37e492813 100644
--- a/src/safepoint.c
+++ b/src/safepoint.c
@@ -44,7 +44,8 @@ uint16_t jl_safepoint_enable_cnt[4] = {0, 0, 0, 0};
 // load/store so that threads waiting for the GC doesn't have to also
 // fight on the safepoint lock...
 uv_mutex_t safepoint_lock;
-uv_cond_t safepoint_cond;
+uv_cond_t safepoint_cond_begin;
+uv_cond_t safepoint_cond_end;
 
 static void jl_safepoint_enable(int idx) JL_NOTSAFEPOINT
 {
@@ -91,7 +92,8 @@ static void jl_safepoint_disable(int idx) JL_NOTSAFEPOINT
 void jl_safepoint_init(void)
 {
     uv_mutex_init(&safepoint_lock);
-    uv_cond_init(&safepoint_cond);
+    uv_cond_init(&safepoint_cond_begin);
+    uv_cond_init(&safepoint_cond_end);
     // jl_page_size isn't available yet.
     size_t pgsz = jl_getpagesize();
 #ifdef _OS_WINDOWS_
@@ -124,12 +126,51 @@ void jl_safepoint_init(void)
     jl_safepoint_pages = addr;
 }
 
+void jl_gc_wait_for_the_world(jl_ptls_t* gc_all_tls_states, int gc_n_threads)
+{
+    JL_TIMING(GC, GC_Stop);
+#ifdef USE_TRACY
+    TracyCZoneCtx ctx = JL_TIMING_DEFAULT_BLOCK->tracy_ctx;
+    TracyCZoneColor(ctx, 0x696969);
+#endif
+    assert(gc_n_threads);
+    if (gc_n_threads > 1)
+        jl_wake_libuv();
+    for (int i = 0; i < gc_n_threads; i++) {
+        jl_ptls_t ptls2 = gc_all_tls_states[i];
+        if (ptls2 != NULL) {
+            // This acquire load pairs with the release stores
+            // in the signal handler of safepoint so we are sure that
+            // all the stores on those threads are visible.
+            // We're currently also using atomic store release in mutator threads
+            // (in jl_gc_state_set), but we may want to use signals to flush the
+            // memory operations on those threads lazily instead.
+            while (!jl_atomic_load_relaxed(&ptls2->gc_state) || !jl_atomic_load_acquire(&ptls2->gc_state)) {
+                // Use system mutexes rather than spin locking to minimize wasted CPU time
+                // while we wait for other threads reach a safepoint.
+                // This is particularly important when run under rr.
+                uv_mutex_lock(&safepoint_lock);
+                if (!jl_atomic_load_relaxed(&ptls2->gc_state))
+                    uv_cond_wait(&safepoint_cond_begin, &safepoint_lock);
+                uv_mutex_unlock(&safepoint_lock);
+            }
+        }
+    }
+}
+
 int jl_safepoint_start_gc(void)
 {
-    // The thread should have set this already
+    // The thread should have just set this before entry
     assert(jl_atomic_load_relaxed(&jl_current_task->ptls->gc_state) == JL_GC_STATE_WAITING);
-    jl_safepoint_wait_thread_resume(); // make sure we are permitted to run GC now (we might be required to stop instead)
     uv_mutex_lock(&safepoint_lock);
+    uv_cond_broadcast(&safepoint_cond_begin);
+    // make sure we are permitted to run GC now (we might be required to stop instead)
+    jl_task_t *ct = jl_current_task;
+    while (jl_atomic_load_relaxed(&ct->ptls->suspend_count)) {
+        uv_mutex_unlock(&safepoint_lock);
+        jl_safepoint_wait_thread_resume();
+        uv_mutex_lock(&safepoint_lock);
+    }
     // In case multiple threads enter the GC at the same time, only allow
     // one of them to actually run the collection. We can't just let the
     // master thread do the GC since it might be running unmanaged code
@@ -169,7 +210,22 @@ void jl_safepoint_end_gc(void)
     jl_mach_gc_end();
 #  endif
     uv_mutex_unlock(&safepoint_lock);
-    uv_cond_broadcast(&safepoint_cond);
+    uv_cond_broadcast(&safepoint_cond_end);
+}
+
+void jl_set_gc_and_wait(void) // n.b. not used on _OS_DARWIN_
+{
+    jl_task_t *ct = jl_current_task;
+    // reading own gc state doesn't need atomic ops since no one else
+    // should store to it.
+    int8_t state = jl_atomic_load_relaxed(&ct->ptls->gc_state);
+    jl_atomic_store_release(&ct->ptls->gc_state, JL_GC_STATE_WAITING);
+    uv_mutex_lock(&safepoint_lock);
+    uv_cond_broadcast(&safepoint_cond_begin);
+    uv_mutex_unlock(&safepoint_lock);
+    jl_safepoint_wait_gc();
+    jl_atomic_store_release(&ct->ptls->gc_state, state);
+    jl_safepoint_wait_thread_resume(); // block in thread-suspend now if requested, after clearing the gc_state
 }
 
 // this is the core of jl_set_gc_and_wait
@@ -187,7 +243,7 @@ void jl_safepoint_wait_gc(void) JL_NOTSAFEPOINT
         // This is particularly important when run under rr.
         uv_mutex_lock(&safepoint_lock);
         if (jl_atomic_load_relaxed(&jl_gc_running))
-            uv_cond_wait(&safepoint_cond, &safepoint_lock);
+            uv_cond_wait(&safepoint_cond_end, &safepoint_lock);
         uv_mutex_unlock(&safepoint_lock);
     }
 }
@@ -204,6 +260,14 @@ void jl_safepoint_wait_thread_resume(void)
     int8_t state = jl_atomic_load_relaxed(&ct->ptls->gc_state);
     jl_atomic_store_release(&ct->ptls->gc_state, JL_GC_STATE_WAITING);
     uv_mutex_lock(&ct->ptls->sleep_lock);
+    if (jl_atomic_load_relaxed(&ct->ptls->suspend_count)) {
+        // defer this broadcast until we determine whether uv_cond_wait is really going to be needed
+        uv_mutex_unlock(&ct->ptls->sleep_lock);
+        uv_mutex_lock(&safepoint_lock);
+        uv_cond_broadcast(&safepoint_cond_begin);
+        uv_mutex_unlock(&safepoint_lock);
+        uv_mutex_lock(&ct->ptls->sleep_lock);
+    }
     while (jl_atomic_load_relaxed(&ct->ptls->suspend_count))
         uv_cond_wait(&ct->ptls->wake_signal, &ct->ptls->sleep_lock);
     // must while still holding the mutex_unlock, so we know other threads in
@@ -249,7 +313,7 @@ int jl_safepoint_suspend_thread(int tid, int waitstate)
                 break;
             if (waitstate == 3 && state2 == JL_GC_STATE_WAITING)
                 break;
-            jl_cpu_pause(); // yield?
+            jl_cpu_pause(); // yield (wait for safepoint_cond_begin, for example)?
         }
     }
     return suspend_count;
@@ -262,9 +326,7 @@ int jl_safepoint_resume_thread(int tid) JL_NOTSAFEPOINT
     if (0 > tid || tid >= jl_atomic_load_acquire(&jl_n_threads))
         return 0;
     jl_ptls_t ptls2 = jl_atomic_load_relaxed(&jl_all_tls_states)[tid];
-#  ifdef _OS_DARWIN_
     uv_mutex_lock(&safepoint_lock);
-#  endif
     uv_mutex_lock(&ptls2->sleep_lock);
     int16_t suspend_count = jl_atomic_load_relaxed(&ptls2->suspend_count);
     if (suspend_count == 1) { // last to unsuspend
@@ -283,9 +345,7 @@ int jl_safepoint_resume_thread(int tid) JL_NOTSAFEPOINT
             jl_safepoint_disable(3);
     }
     uv_mutex_unlock(&ptls2->sleep_lock);
-#  ifdef _OS_DARWIN_
     uv_mutex_unlock(&safepoint_lock);
-#  endif
     return suspend_count;
 }
 
diff --git a/src/signals-mach.c b/src/signals-mach.c
index b7ab8ecaf8ef6..87a2eb4758d4a 100644
--- a/src/signals-mach.c
+++ b/src/signals-mach.c
@@ -45,6 +45,7 @@ static void attach_exception_port(thread_port_t thread, int segv_only);
 // low 16 bits are the thread id, the next 8 bits are the original gc_state
 static arraylist_t suspended_threads;
 extern uv_mutex_t safepoint_lock;
+extern uv_cond_t safepoint_cond_begin;
 
 // see jl_safepoint_wait_thread_resume
 void jl_safepoint_resume_thread_mach(jl_ptls_t ptls2, int16_t tid2)
@@ -122,6 +123,7 @@ static void jl_mach_gc_wait(jl_ptls_t ptls2, mach_port_t thread, int16_t tid)
     }
     if (relaxed_suspend_count)
         uv_mutex_unlock(&ptls2->sleep_lock);
+    uv_cond_broadcast(&safepoint_cond_begin);
     uv_mutex_unlock(&safepoint_lock);
 }
 

From 3495404f9dba5bf4186debf3ee59d704c44ae556 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 12 Dec 2023 19:40:43 +0000
Subject: [PATCH 0435/1315] handle data-race on nrunning==0 from
 scheduler_delete_thread

Could be observed by thread 0 during certain phases, since if the dying
thread was not running, it was not supposed to call jl_wakeup_thread
(which will not increment nrunning until after the wakeup).
---
 src/scheduler.c | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/scheduler.c b/src/scheduler.c
index 44ee850dbf365..d0517c7e4afc9 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -581,9 +581,10 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
 
 void scheduler_delete_thread(jl_ptls_t ptls) JL_NOTSAFEPOINT
 {
-    if (jl_atomic_exchange_relaxed(&ptls->sleep_check_state, sleeping_like_the_dead) != sleeping) {
-        int wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, -1);
-        if (wasrunning == 1) {
+    int notsleeping = jl_atomic_exchange_relaxed(&ptls->sleep_check_state, sleeping_like_the_dead) == not_sleeping;
+    jl_fence();
+    if (notsleeping) {
+        if (jl_atomic_load_relaxed(&nrunning) == 1) {
             jl_ptls_t ptls2 = jl_atomic_load_relaxed(&jl_all_tls_states)[0];
             // This was the last running thread, and there is no thread with !may_sleep
             // so make sure tid 0 is notified to check wait_empty
@@ -592,8 +593,11 @@ void scheduler_delete_thread(jl_ptls_t ptls) JL_NOTSAFEPOINT
             uv_mutex_unlock(&ptls2->sleep_lock);
         }
     }
-    jl_fence();
+    else {
+        jl_atomic_fetch_add_relaxed(&nrunning, 1);
+    }
     jl_wakeup_thread(0); // force thread 0 to see that we do not have the IO lock (and am dead)
+    jl_atomic_fetch_add_relaxed(&nrunning, -1);
 }
 
 #ifdef __cplusplus

From ab1dda237fdabfd0fd38eb6c51ce219e5e15c1f4 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 13 Dec 2023 16:24:09 +0000
Subject: [PATCH 0436/1315] add missing increment of nrunning for
 jl_adopt_thread

---
 src/scheduler.c | 16 +++++++++++++++-
 src/threading.c |  5 ++---
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/src/scheduler.c b/src/scheduler.c
index d0517c7e4afc9..50e15b286a8eb 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -32,7 +32,7 @@ static const int16_t sleeping_like_the_dead JL_UNUSED = 2;
 // a running count of how many threads are currently not_sleeping
 // plus a running count of the number of in-flight wake-ups
 // n.b. this may temporarily exceed jl_n_threads
-static _Atomic(int) nrunning = 1;
+static _Atomic(int) nrunning = 0;
 
 // invariant: No thread is ever asleep unless sleep_check_state is sleeping (or we have a wakeup signal pending).
 // invariant: Any particular thread is not asleep unless that thread's sleep_check_state is sleeping.
@@ -201,6 +201,20 @@ void jl_threadfun(void *arg)
 }
 
 
+
+void jl_init_thread_scheduler(jl_ptls_t ptls) JL_NOTSAFEPOINT
+{
+    uv_mutex_init(&ptls->sleep_lock);
+    uv_cond_init(&ptls->wake_signal);
+    // record that there is now another thread that may be used to schedule work
+    // we will decrement this again in scheduler_delete_thread, only slightly
+    // in advance of pthread_join (which hopefully itself also had been
+    // adopted by now and is included in nrunning too)
+    (void)jl_atomic_fetch_add_relaxed(&nrunning, 1);
+    // n.b. this is the only point in the code where we ignore the invariants on the ordering of nrunning
+    // since we are being initialized from foreign code, we could not necessarily have expected or predicted that to happen
+}
+
 int jl_running_under_rr(int recheck)
 {
 #ifdef _OS_LINUX_
diff --git a/src/threading.c b/src/threading.c
index f0ee5cca363ea..648f7d935bac2 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -316,6 +316,7 @@ int jl_all_tls_states_size;
 static uv_cond_t cond;
 // concurrent reads are permitted, using the same pattern as mtsmall_arraylist
 // it is implemented separately because the API of direct jl_all_tls_states use is already widely prevalent
+void jl_init_thread_scheduler(jl_ptls_t ptls) JL_NOTSAFEPOINT;
 
 // return calling thread's ID
 JL_DLLEXPORT int16_t jl_threadid(void)
@@ -379,9 +380,7 @@ jl_ptls_t jl_init_threadtls(int16_t tid)
     ptls->bt_data = bt_data;
     small_arraylist_new(&ptls->locks, 0);
     jl_init_thread_heap(ptls);
-
-    uv_mutex_init(&ptls->sleep_lock);
-    uv_cond_init(&ptls->wake_signal);
+    jl_init_thread_scheduler(ptls);
 
     uv_mutex_lock(&tls_lock);
     if (tid == -1)

From b9668eeb49dd70b4ae110e96f0b7016d521b56e9 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Wed, 13 Dec 2023 20:17:34 -0500
Subject: [PATCH 0437/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20debc38b9a=20to=205f666b077=20(#52521)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5     | 1 +
 .../Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512  | 1 +
 .../Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5     | 1 -
 .../Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512  | 1 -
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512

diff --git a/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5 b/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5
new file mode 100644
index 0000000000000..42689be2f3b8f
--- /dev/null
+++ b/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5
@@ -0,0 +1 @@
+01bdae97c316f2e9dda5136f0d630865
diff --git a/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512 b/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512
new file mode 100644
index 0000000000000..58d2c23eefa8b
--- /dev/null
+++ b/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512
@@ -0,0 +1 @@
+95aa0943a88bc55d262595a23a153eba21f2e9275dd39f8414678f8c6483f1807ab687c84da4162674c0fd66fc5c801f532adaa8b776652495707b65f5262c87
diff --git a/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5 b/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5
deleted file mode 100644
index d222465b498dd..0000000000000
--- a/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-e6fee75f07782a63581ec844a25e97f5
diff --git a/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512 b/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512
deleted file mode 100644
index 9ee7f65eaaabf..0000000000000
--- a/deps/checksums/Pkg-debc38b9a2d800f035a17f42a01c14a3775fa859.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-f3353f4493c25a45db7125be2448fb3799e2c6f02b9fde14a444b4d4bf7c144d56abde6f8b678407f918b3c2ba00f6ab19047b908004f5034d422d5cfd6c1f41
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 273ffd825b9f1..ea2a64d1e4dae 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = debc38b9a2d800f035a17f42a01c14a3775fa859
+PKG_SHA1 = 5f666b077298c6862ecce3a0e78cab29fd6c5cbf
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 0ae209488fc9d9aa49181a5165e1e5790b0d9810 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 14 Dec 2023 10:31:42 +0530
Subject: [PATCH 0438/1315] Pass mutable copies to inplace LinearAlgebra
 functions (#52504)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This gets some functions working with immutable matrix types, e.g.:
```julia
julia> using FillArrays, LinearAlgebra

julia> F = Fill(big(2), 4, 4)
4×4 Fill{BigInt}, with entries equal to 2

julia> det(F)
0

julia> triu(F)
4×4 Matrix{BigInt}:
 2  2  2  2
 0  2  2  2
 0  0  2  2
 0  0  0  2
```
---
 stdlib/LinearAlgebra/src/generic.jl    | 10 +++++-----
 stdlib/LinearAlgebra/src/triangular.jl | 20 ++++++++++++++++++--
 stdlib/LinearAlgebra/test/generic.jl   | 13 +++++++++++++
 test/testhelpers/FillArrays.jl         |  2 ++
 4 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl
index 929618b95ce0a..ca01646820ccf 100644
--- a/stdlib/LinearAlgebra/src/generic.jl
+++ b/stdlib/LinearAlgebra/src/generic.jl
@@ -338,7 +338,7 @@ julia> triu(a)
  0.0  0.0  0.0  1.0
 ```
 """
-triu(M::AbstractMatrix) = triu!(copy(M))
+triu(M::AbstractMatrix) = triu!(copymutable(M))
 
 """
     tril(M)
@@ -362,7 +362,7 @@ julia> tril(a)
  1.0  1.0  1.0  1.0
 ```
 """
-tril(M::AbstractMatrix) = tril!(copy(M))
+tril(M::AbstractMatrix) = tril!(copymutable(M))
 
 """
     triu(M, k::Integer)
@@ -393,7 +393,7 @@ julia> triu(a,-3)
  1.0  1.0  1.0  1.0
 ```
 """
-triu(M::AbstractMatrix,k::Integer) = triu!(copy(M),k)
+triu(M::AbstractMatrix,k::Integer) = triu!(copymutable(M),k)
 
 """
     tril(M, k::Integer)
@@ -424,7 +424,7 @@ julia> tril(a,-3)
  1.0  0.0  0.0  0.0
 ```
 """
-tril(M::AbstractMatrix,k::Integer) = tril!(copy(M),k)
+tril(M::AbstractMatrix,k::Integer) = tril!(copymutable(M),k)
 
 """
     triu!(M)
@@ -1760,7 +1760,7 @@ Calculates the determinant of a matrix using the
 [Bareiss Algorithm](https://en.wikipedia.org/wiki/Bareiss_algorithm).
 Also refer to [`det_bareiss!`](@ref).
 """
-det_bareiss(M) = det_bareiss!(copy(M))
+det_bareiss(M) = det_bareiss!(copymutable(M))
 
 
 
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 6d703b2436b23..f057133a2533c 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -332,7 +332,15 @@ function tril!(A::UpperTriangular{T}, k::Integer=0) where {T}
         return UpperTriangular(tril!(A.data,k))
     end
 end
-triu!(A::UpperTriangular, k::Integer=0) = UpperTriangular(triu!(A.data, k))
+function triu!(A::UpperTriangular, k::Integer=0)
+    n = size(A,1)
+    if k > 0
+        for j in 1:n, i in max(1,j-k+1):j
+            A.data[i,j] = zero(eltype(A))
+        end
+    end
+    return A
+end
 
 function tril!(A::UnitUpperTriangular{T}, k::Integer=0) where {T}
     n = size(A,1)
@@ -375,7 +383,15 @@ function triu!(A::LowerTriangular{T}, k::Integer=0) where {T}
     end
 end
 
-tril!(A::LowerTriangular, k::Integer=0) = LowerTriangular(tril!(A.data, k))
+function tril!(A::LowerTriangular, k::Integer=0)
+    n = size(A,1)
+    if k < 0
+        for j in 1:n, i in j:min(j-k-1,n)
+            A.data[i, j] = zero(eltype(A))
+        end
+    end
+    A
+end
 
 function triu!(A::UnitLowerTriangular{T}, k::Integer=0) where T
     n = size(A,1)
diff --git a/stdlib/LinearAlgebra/test/generic.jl b/stdlib/LinearAlgebra/test/generic.jl
index c79173ad1011a..b8cb15ff695cb 100644
--- a/stdlib/LinearAlgebra/test/generic.jl
+++ b/stdlib/LinearAlgebra/test/generic.jl
@@ -15,6 +15,9 @@ using .Main.OffsetArrays
 isdefined(Main, :DualNumbers) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "DualNumbers.jl"))
 using .Main.DualNumbers
 
+isdefined(Main, :FillArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "FillArrays.jl"))
+using .Main.FillArrays
+
 Random.seed!(123)
 
 n = 5 # should be odd
@@ -647,4 +650,14 @@ end
     end
 end
 
+@testset "immutable arrays" begin
+    A = FillArrays.Fill(big(3), (4, 4))
+    M = Array(A)
+    @test triu(A) == triu(M)
+    @test triu(A, -1) == triu(M, -1)
+    @test tril(A) == tril(M)
+    @test tril(A, 1) == tril(M, 1)
+    @test det(A) == det(M)
+end
+
 end # module TestGeneric
diff --git a/test/testhelpers/FillArrays.jl b/test/testhelpers/FillArrays.jl
index 1f36a77bf8c12..7ba18f22307ca 100644
--- a/test/testhelpers/FillArrays.jl
+++ b/test/testhelpers/FillArrays.jl
@@ -9,6 +9,8 @@ Fill(v, size::Vararg{Integer}) = Fill(v, size)
 
 Base.size(F::Fill) = F.size
 
+Base.copy(F::Fill) = F
+
 @inline getindex_value(F::Fill) = F.value
 
 @inline function Base.getindex(F::Fill{<:Any,N}, i::Vararg{Int,N}) where {N}

From 914743713b133ef1b4462f11799652bcbae28487 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 13 Dec 2023 23:08:14 -0800
Subject: [PATCH 0439/1315] irinterp: Add :leave support (#52525)

We still don't model exceptions, but the :leave expression doesn't
participate in type refinement, so adding it here is easy.
---
 base/compiler/ssair/irinterp.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 288f23132635a..cc93757a60cbc 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -177,6 +177,8 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
         elseif head === :gc_preserve_begin ||
                head === :gc_preserve_end
             return false
+        elseif head === :leave
+            return false
         else
             error("reprocess_instruction!: unhandled expression found")
         end

From d69bb97d960fb8c140f47766ed96e34117765653 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Thu, 14 Dec 2023 20:23:12 +0800
Subject: [PATCH 0440/1315] Expand more Vararg elements during re-intersection
 if valid. (#46604)

Our type intersection "prefers" `Tuple` with more parameters.
This PR tries to replace `Tuple{Vararg{T,N}}` with
`Tuple{T,T,T,Vararg{T,N}}` during re-intersection if we can prove that
`N >= 3` and `N` is used only for Vararg length.
---
 src/subtype.c   | 147 +++++++++++++++++++++++++++++++-----------------
 test/subtype.jl |  23 +++++---
 2 files changed, 110 insertions(+), 60 deletions(-)

diff --git a/src/subtype.c b/src/subtype.c
index ce2572be2952d..17a6bf7041e3b 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -69,6 +69,8 @@ typedef struct jl_varbinding_t {
     int8_t occurs_inv;  // occurs in invariant position
     int8_t occurs_cov;  // # of occurrences in covariant position
     int8_t concrete;    // 1 if another variable has a constraint forcing this one to be concrete
+    int8_t max_offset;  // record the maximum positive offset of the variable (up to 32)
+                        // max_offset < 0 if this variable occurs outside VarargNum.
     // constraintkind: in covariant position, we try three different ways to compute var ∩ type:
     // let ub = var.ub ∩ type
     // 0 - var.ub <: type ? var : ub
@@ -77,6 +79,7 @@ typedef struct jl_varbinding_t {
     int8_t constraintkind;
     int8_t intvalued; // intvalued: must be integer-valued; i.e. occurs as N in Vararg{_,N}
     int8_t limited;
+    int8_t intersected; // whether this variable has been intersected
     int16_t depth0;         // # of invariant constructors nested around the UnionAll type for this var
     // array of typevars that our bounds depend on, whose UnionAlls need to be
     // moved outside ours.
@@ -168,9 +171,9 @@ static int current_env_length(jl_stenv_t *e)
 typedef struct {
     int8_t *buf;
     int rdepth;
-    int8_t _space[24]; // == 8 * 3
+    int8_t _space[32]; // == 8 * 4
     jl_gcframe_t gcframe;
-    jl_value_t *roots[24];
+    jl_value_t *roots[24]; // == 8 * 3
 } jl_savedenv_t;
 
 static void re_save_env(jl_stenv_t *e, jl_savedenv_t *se, int root)
@@ -200,6 +203,7 @@ static void re_save_env(jl_stenv_t *e, jl_savedenv_t *se, int root)
         se->buf[j++] = v->occurs;
         se->buf[j++] = v->occurs_inv;
         se->buf[j++] = v->occurs_cov;
+        se->buf[j++] = v->max_offset;
         v = v->prev;
     }
     assert(i == nroots); (void)nroots;
@@ -231,7 +235,7 @@ static void alloc_env(jl_stenv_t *e, jl_savedenv_t *se, int root)
             ct->gcstack = &se->gcframe;
         }
     }
-    se->buf = (len > 8 ? (int8_t*)malloc_s(len * 3) : se->_space);
+    se->buf = (len > 8 ? (int8_t*)malloc_s(len * 4) : se->_space);
 #ifdef __clang_gcanalyzer__
     memset(se->buf, 0, len * 3);
 #endif
@@ -281,6 +285,7 @@ static void restore_env(jl_stenv_t *e, jl_savedenv_t *se, int root) JL_NOTSAFEPO
         v->occurs = se->buf[j++];
         v->occurs_inv = se->buf[j++];
         v->occurs_cov = se->buf[j++];
+        v->max_offset = se->buf[j++];
         v = v->prev;
     }
     assert(i == nroots); (void)nroots;
@@ -677,6 +682,10 @@ static void record_var_occurrence(jl_varbinding_t *vb, jl_stenv_t *e, int param)
         else if (vb->occurs_cov < 2) {
             vb->occurs_cov++;
         }
+        // Always set `max_offset` to `-1` during the 1st round intersection.
+        // Would be recovered in `intersect_varargs`/`subtype_tuple_varargs` if needed.
+        if (!vb->intersected)
+            vb->max_offset = -1;
     }
 }
 
@@ -888,7 +897,7 @@ static jl_unionall_t *unalias_unionall(jl_unionall_t *u, jl_stenv_t *e)
 static int subtype_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8_t R, int param)
 {
     u = unalias_unionall(u, e);
-    jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, 0, 0, 0, 0, 0, 0, 0,
+    jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                            e->invdepth, NULL, e->vars };
     JL_GC_PUSH4(&u, &vb.lb, &vb.ub, &vb.innervars);
     e->vars = &vb;
@@ -1008,39 +1017,30 @@ static int subtype_tuple_varargs(
     jl_value_t *xp0 = jl_unwrap_vararg(vtx); jl_value_t *xp1 = jl_unwrap_vararg_num(vtx);
     jl_value_t *yp0 = jl_unwrap_vararg(vty); jl_value_t *yp1 = jl_unwrap_vararg_num(vty);
 
+    jl_varbinding_t *xlv = NULL, *ylv = NULL;
+    if (xp1 && jl_is_typevar(xp1))
+        xlv = lookup(e, (jl_tvar_t*)xp1);
+    if (yp1 && jl_is_typevar(yp1))
+        ylv = lookup(e, (jl_tvar_t*)yp1);
+
+    int8_t max_offsetx = xlv ? xlv->max_offset : 0;
+    int8_t max_offsety = ylv ? ylv->max_offset : 0;
+
+    jl_value_t *xl = xlv ? xlv->lb : xp1;
+    jl_value_t *yl = ylv ? ylv->lb : yp1;
+
     if (!xp1) {
-        jl_value_t *yl = yp1;
-        if (yl) {
-            // Unconstrained on the left, constrained on the right
-            if (jl_is_typevar(yl)) {
-                jl_varbinding_t *ylv = lookup(e, (jl_tvar_t*)yl);
-                if (ylv)
-                    yl = ylv->lb;
-            }
-            if (jl_is_long(yl)) {
-                return 0;
-            }
-        }
+        // Unconstrained on the left, constrained on the right
+        if (yl && jl_is_long(yl))
+            return 0;
     }
     else {
-        jl_value_t *xl = jl_unwrap_vararg_num(vtx);
-        if (jl_is_typevar(xl)) {
-            jl_varbinding_t *xlv = lookup(e, (jl_tvar_t*)xl);
-            if (xlv)
-                xl = xlv->lb;
-        }
         if (jl_is_long(xl)) {
             if (jl_unbox_long(xl) + 1 == vx) {
                 // LHS is exhausted. We're a subtype if the RHS is either
                 // exhausted as well or unbounded (in which case we need to
                 // set it to 0).
-                jl_value_t *yl = jl_unwrap_vararg_num(vty);
                 if (yl) {
-                    if (jl_is_typevar(yl)) {
-                        jl_varbinding_t *ylv = lookup(e, (jl_tvar_t*)yl);
-                        if (ylv)
-                            yl = ylv->lb;
-                    }
                     if (jl_is_long(yl)) {
                         return jl_unbox_long(yl) + 1 == vy;
                     }
@@ -1090,6 +1090,8 @@ static int subtype_tuple_varargs(
         // appropriately.
         e->invdepth++;
         int ans = subtype((jl_value_t*)jl_any_type, yp1, e, 2);
+        if (ylv && !ylv->intersected)
+            ylv->max_offset = max_offsety;
         e->invdepth--;
         return ans;
     }
@@ -1130,6 +1132,10 @@ static int subtype_tuple_varargs(
         e->Loffset = 0;
     }
     JL_GC_POP();
+    if (ylv && !ylv->intersected)
+        ylv->max_offset = max_offsety;
+    if (xlv && !xlv->intersected)
+        xlv->max_offset = max_offsetx;
     e->invdepth--;
     return ans;
 }
@@ -3134,7 +3140,7 @@ static jl_value_t *intersect_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_
 {
     jl_value_t *res = NULL;
     jl_savedenv_t se;
-    jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, 0, 0, 0, 0, 0, 0, 0,
+    jl_varbinding_t vb = { u->var, u->var->lb, u->var->ub, R, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                            e->invdepth, NULL, e->vars };
     JL_GC_PUSH4(&res, &vb.lb, &vb.ub, &vb.innervars);
     save_env(e, &se, 1);
@@ -3142,6 +3148,7 @@ static jl_value_t *intersect_unionall(jl_value_t *t, jl_unionall_t *u, jl_stenv_
     if (is_leaf_typevar(u->var) && noinv && always_occurs_cov(u->body, u->var, param))
         vb.constraintkind = 1;
     res = intersect_unionall_(t, u, e, R, param, &vb);
+    vb.intersected = 1;
     if (vb.limited) {
         // if the environment got too big, avoid tree recursion and propagate the flag
         if (e->vars)
@@ -3218,10 +3225,12 @@ static jl_value_t *intersect_varargs(jl_vararg_t *vmx, jl_vararg_t *vmy, ssize_t
     assert(e->Loffset == 0);
     e->Loffset = offset;
     jl_varbinding_t *xb = NULL, *yb = NULL;
+    int8_t max_offsetx = 0, max_offsety = 0;
     if (xp2) {
         assert(jl_is_typevar(xp2));
         xb = lookup(e, (jl_tvar_t*)xp2);
         if (xb) xb->intvalued = 1;
+        if (xb) max_offsetx = xb->max_offset;
         if (!yp2)
             i2 = bound_var_below((jl_tvar_t*)xp2, xb, e, 0);
     }
@@ -3229,6 +3238,7 @@ static jl_value_t *intersect_varargs(jl_vararg_t *vmx, jl_vararg_t *vmy, ssize_t
         assert(jl_is_typevar(yp2));
         yb = lookup(e, (jl_tvar_t*)yp2);
         if (yb) yb->intvalued = 1;
+        if (yb) max_offsety = yb->max_offset;
         if (!xp2)
             i2 = bound_var_below((jl_tvar_t*)yp2, yb, e, 1);
     }
@@ -3243,14 +3253,27 @@ static jl_value_t *intersect_varargs(jl_vararg_t *vmx, jl_vararg_t *vmy, ssize_t
     }
     assert(e->Loffset == offset);
     e->Loffset = 0;
-    if (i2 == jl_bottom_type)
+    if (i2 == jl_bottom_type) {
         ii = (jl_value_t*)jl_bottom_type;
-    else if (xp2 && obviously_egal(xp1, ii) && obviously_egal(xp2, i2))
-        ii = (jl_value_t*)vmx;
-    else if (yp2 && obviously_egal(yp1, ii) && obviously_egal(yp2, i2))
-        ii = (jl_value_t*)vmy;
-    else
-        ii = (jl_value_t*)jl_wrap_vararg(ii, i2, 1);
+    }
+    else {
+        if (xb && !xb->intersected) {
+            xb->max_offset = max_offsetx;
+            if (offset > xb->max_offset && xb->max_offset >= 0)
+                xb->max_offset = offset > 32 ? 32 : offset;
+        }
+        if (yb && !yb->intersected) {
+            yb->max_offset = max_offsety;
+            if (-offset > yb->max_offset && yb->max_offset >= 0)
+                yb->max_offset = -offset > 32 ? 32 : -offset;
+        }
+        if (xp2 && obviously_egal(xp1, ii) && obviously_egal(xp2, i2))
+            ii = (jl_value_t*)vmx;
+        else if (yp2 && obviously_egal(yp1, ii) && obviously_egal(yp2, i2))
+            ii = (jl_value_t*)vmy;
+        else
+            ii = (jl_value_t*)jl_wrap_vararg(ii, i2, 1);
+    }
     JL_GC_POP();
     return ii;
 }
@@ -3269,6 +3292,24 @@ static jl_value_t *intersect_tuple(jl_datatype_t *xd, jl_datatype_t *yd, jl_sten
         llx += jl_unbox_long(jl_unwrap_vararg_num((jl_vararg_t *)jl_tparam(xd, lx-1))) - 1;
     if (vvy == JL_VARARG_INT)
         lly += jl_unbox_long(jl_unwrap_vararg_num((jl_vararg_t *)jl_tparam(yd, ly-1))) - 1;
+    if (vvx == JL_VARARG_BOUND && (vvy == JL_VARARG_BOUND || vvy == JL_VARARG_UNBOUND)) {
+        jl_value_t *xlen = jl_unwrap_vararg_num((jl_vararg_t*)jl_tparam(xd, lx-1));
+        assert(xlen && jl_is_typevar(xlen));
+        jl_varbinding_t *xb = lookup(e, (jl_tvar_t*)xlen);
+        if (xb && xb->intersected && xb->max_offset > 0) {
+            assert(xb->max_offset <= 32);
+            llx += xb->max_offset;
+        }
+    }
+    if (vvy == JL_VARARG_BOUND && (vvx == JL_VARARG_BOUND || vvx == JL_VARARG_UNBOUND)) {
+        jl_value_t *ylen = jl_unwrap_vararg_num((jl_vararg_t*)jl_tparam(yd, ly-1));
+        assert(ylen && jl_is_typevar(ylen));
+        jl_varbinding_t *yb = lookup(e, (jl_tvar_t*)ylen);
+        if (yb && yb->intersected && yb->max_offset > 0) {
+            assert(yb->max_offset <= 32);
+            lly += yb->max_offset;
+        }
+    }
 
     if ((vvx == JL_VARARG_NONE || vvx == JL_VARARG_INT) &&
         (vvy == JL_VARARG_NONE || vvy == JL_VARARG_INT)) {
@@ -3301,8 +3342,8 @@ static jl_value_t *intersect_tuple(jl_datatype_t *xd, jl_datatype_t *yd, jl_sten
             assert(i == j && i == np);
             break;
         }
-        if (xi && jl_is_vararg(xi)) vx = vvx != JL_VARARG_INT;
-        if (yi && jl_is_vararg(yi)) vy = vvy != JL_VARARG_INT;
+        if (xi && jl_is_vararg(xi)) vx = vvx == JL_VARARG_UNBOUND || (vvx == JL_VARARG_BOUND && i == llx - 1);
+        if (yi && jl_is_vararg(yi)) vy = vvy == JL_VARARG_UNBOUND || (vvy == JL_VARARG_BOUND && j == lly - 1);
         if (xi == NULL || yi == NULL) {
             if (vx && intersect_vararg_length(xi, lly+1-llx, e, 0)) {
                 np = j;
@@ -3845,15 +3886,15 @@ static int merge_env(jl_stenv_t *e, jl_savedenv_t *se, int count)
         roots = se->roots;
         nroots = se->gcframe.nroots >> 2;
     }
-    int n = 0;
+    int m = 0, n = 0;
     jl_varbinding_t *v = e->vars;
-    v = e->vars;
     while (v != NULL) {
         if (count == 0) {
             // need to initialize this
-            se->buf[n] = 0;
-            se->buf[n+1] = 0;
-            se->buf[n+2] = 0;
+            se->buf[m] = 0;
+            se->buf[m+1] = 0;
+            se->buf[m+2] = 0;
+            se->buf[m+3] = v->max_offset;
         }
         if (v->occurs) {
             // only merge lb/ub/innervars if this var occurs.
@@ -3879,13 +3920,17 @@ static int merge_env(jl_stenv_t *e, jl_savedenv_t *se, int count)
                     roots[n+2] = b2;
             }
             // record the meeted vars.
-            se->buf[n] = 1;
+            se->buf[m] = 1;
         }
         // always merge occurs_inv/cov by max (never decrease)
-        if (v->occurs_inv > se->buf[n+1])
-            se->buf[n+1] = v->occurs_inv;
-        if (v->occurs_cov > se->buf[n+2])
-            se->buf[n+2] = v->occurs_cov;
+        if (v->occurs_inv > se->buf[m+1])
+            se->buf[m+1] = v->occurs_inv;
+        if (v->occurs_cov > se->buf[m+2])
+            se->buf[m+2] = v->occurs_cov;
+        // always merge max_offset by min
+        if (!v->intersected && v->max_offset < se->buf[m+3])
+            se->buf[m+3] = v->max_offset;
+        m = m + 4;
         n = n + 3;
         v = v->prev;
     }
@@ -3917,7 +3962,7 @@ static void final_merge_env(jl_stenv_t *e, jl_savedenv_t *me, jl_savedenv_t *se)
     }
     assert(nroots == current_env_length(e) * 3);
     assert(nroots % 3 == 0);
-    for (int n = 0; n < nroots; n = n + 3) {
+    for (int n = 0, m = 0; n < nroots; n += 3, m += 4) {
         if (merged[n] == NULL)
             merged[n] = saved[n];
         if (merged[n+1] == NULL)
@@ -3933,7 +3978,7 @@ static void final_merge_env(jl_stenv_t *e, jl_savedenv_t *me, jl_savedenv_t *se)
             else
                 merged[n+2] = b2;
         }
-        me->buf[n] |= se->buf[n];
+        me->buf[m] |= se->buf[m];
     }
 }
 
@@ -4489,7 +4534,7 @@ static jl_value_t *_widen_diagonal(jl_value_t *t, jl_varbinding_t *troot) {
 
 static jl_value_t *widen_diagonal(jl_value_t *t, jl_unionall_t *u, jl_varbinding_t *troot)
 {
-    jl_varbinding_t vb = { u->var, NULL, NULL, 1, 0, 0, 0, 0, 0, 0, 0, 0, NULL, troot };
+    jl_varbinding_t vb = { u->var, NULL, NULL, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, troot };
     jl_value_t *nt;
     JL_GC_PUSH2(&vb.innervars, &nt);
     if (jl_is_unionall(u->body))
diff --git a/test/subtype.jl b/test/subtype.jl
index 9a1dd62f4f9c4..edc38c8556f3c 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -2210,13 +2210,19 @@ let A = Tuple{NTuple{N, Int}, NTuple{N, Int}} where N,
     Bs = (Tuple{Tuple{Int, Vararg{Any}}, Tuple{Int, Int, Vararg{Any}}},
           Tuple{Tuple{Int, Vararg{Any,N1}}, Tuple{Int, Int, Vararg{Any,N2}}} where {N1,N2},
           Tuple{Tuple{Int, Vararg{Any,N}} where {N}, Tuple{Int, Int, Vararg{Any,N}} where {N}})
-    Cerr = Tuple{Tuple{Int, Vararg{Int, N}}, Tuple{Int, Int, Vararg{Int, N}}} where {N}
+    C = Tuple{Tuple{Int, Int, Vararg{Int, N}}, Tuple{Int, Int, Vararg{Int, N}}} where {N}
     for B in Bs
-        C = typeintersect(A, B)
-        @test C == typeintersect(B, A) != Union{}
-        @test C != Cerr
-        # TODO: The ideal result is Tuple{Tuple{Int, Int, Vararg{Int, N}}, Tuple{Int, Int, Vararg{Int, N}}} where {N}
-        @test_broken C != Tuple{Tuple{Int, Vararg{Int}}, Tuple{Int, Int, Vararg{Int}}}
+        @testintersect(A, B, C)
+    end
+    A = Tuple{NTuple{N, Int}, Tuple{Int, Vararg{Int, N}}} where N
+    C = Tuple{Tuple{Int, Vararg{Int, N}}, Tuple{Int, Int, Vararg{Int, N}}} where {N}
+    for B in Bs
+        @testintersect(A, B, C)
+    end
+    A = Tuple{Tuple{Int, Vararg{Int, N}}, NTuple{N, Int}} where N
+    C = Tuple{Tuple{Int, Int, Int, Vararg{Int, N}}, Tuple{Int, Int, Vararg{Int, N}}} where {N}
+    for B in Bs
+        @testintersect(A, B, C)
     end
 end
 
@@ -2229,9 +2235,8 @@ let A = Pair{NTuple{N, Int}, NTuple{N, Int}} where N,
     Bs = (Pair{<:Tuple{Int, Vararg{Int}}, <:Tuple{Int, Int, Vararg{Int}}},
           Pair{Tuple{Int, Vararg{Int,N1}}, Tuple{Int, Int, Vararg{Int,N2}}} where {N1,N2},
           Pair{<:Tuple{Int, Vararg{Int,N}} where {N}, <:Tuple{Int, Int, Vararg{Int,N}} where {N}})
-    Cs = (Bs[2], Bs[2], Bs[3])
-    for (B, C) in zip(Bs, Cs)
-        # TODO: The ideal result is Pair{Tuple{Int, Int, Vararg{Int, N}}, Tuple{Int, Int, Vararg{Int, N}}} where {N}
+    C = Pair{Tuple{Int, Int, Vararg{Int, N}}, Tuple{Int, Int, Vararg{Int, N}}} where {N}
+    for B in Bs
         @testintersect(A, B, C)
     end
 end

From 5195da2ca006d3e63dcd8973c7d867c88381f6be Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 14 Dec 2023 17:54:16 +0530
Subject: [PATCH 0441/1315] Improve linear indexing performance for
 FastSubArrays (#45371)

This PR forwards `AbstractUnitRange` indices for `FastSubArrays` to the
parent, making use of the fact that the parent might have efficient
vector indexing methods defined.

---------

Co-authored-by: Jishnu Bhattacharya <jishnub@users.noreply.github.com>
Co-authored-by: N5N3 <2642243996@qq.com>
---
 base/subarray.jl |  24 +++++++++++
 test/subarray.jl | 107 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 131 insertions(+)

diff --git a/base/subarray.jl b/base/subarray.jl
index e42bd070747a2..fcc417fa1d157 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -334,6 +334,15 @@ function getindex(V::FastContiguousSubArray, i::Int)
     @inbounds r = V.parent[V.offset1 + i]
     r
 end
+# parents of FastContiguousSubArrays may support fast indexing with AbstractUnitRanges,
+# so we may just forward the indexing to the parent
+function getindex(V::FastContiguousSubArray, i::AbstractUnitRange{Int})
+    @inline
+    @boundscheck checkbounds(V, i)
+    @inbounds r = V.parent[V.offset1 .+ i]
+    r
+end
+
 # For vector views with linear indexing, we disambiguate to favor the stride/offset
 # computation as that'll generally be faster than (or just as fast as) re-indexing into a range.
 function getindex(V::FastSubArray{<:Any, 1}, i::Int)
@@ -348,6 +357,7 @@ function getindex(V::FastContiguousSubArray{<:Any, 1}, i::Int)
     @inbounds r = V.parent[V.offset1 + i]
     r
 end
+@inline getindex(V::FastContiguousSubArray, i::Colon) = getindex(V, to_indices(V, (:,))...)
 
 # Indexed assignment follows the same pattern as `getindex` above
 function setindex!(V::SubArray{T,N}, x, I::Vararg{Int,N}) where {T,N}
@@ -368,6 +378,19 @@ function setindex!(V::FastContiguousSubArray, x, i::Int)
     @inbounds V.parent[V.offset1 + i] = x
     V
 end
+function setindex!(V::FastSubArray, x, i::AbstractUnitRange{Int})
+    @inline
+    @boundscheck checkbounds(V, i)
+    @inbounds V.parent[V.offset1 .+ V.stride1 .* i] = x
+    V
+end
+function setindex!(V::FastContiguousSubArray, x, i::AbstractUnitRange{Int})
+    @inline
+    @boundscheck checkbounds(V, i)
+    @inbounds V.parent[V.offset1 .+ i] = x
+    V
+end
+
 function setindex!(V::FastSubArray{<:Any, 1}, x, i::Int)
     @inline
     @boundscheck checkbounds(V, i)
@@ -380,6 +403,7 @@ function setindex!(V::FastContiguousSubArray{<:Any, 1}, x, i::Int)
     @inbounds V.parent[V.offset1 + i] = x
     V
 end
+@inline setindex!(V::FastSubArray, x, i::Colon) = setindex!(V, x, to_indices(V, (i,))...)
 
 function isassigned(V::SubArray{T,N}, I::Vararg{Int,N}) where {T,N}
     @inline
diff --git a/test/subarray.jl b/test/subarray.jl
index 2502a19519ddb..ad68496e38245 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -465,6 +465,113 @@ end
     @test sA[[1 2 4 4; 6 1 1 4]] == [34 35 38 38; 50 34 34 38]
 end
 
+@testset "fast linear indexing with AbstractUnitRange or Colon indices" begin
+    @testset "getindex" begin
+        @testset "1D" begin
+            for a1 in Any[1:5, [1:5;]]
+                b1 = @view a1[:]; # FastContiguousSubArray
+                c1 = @view a1[eachindex(a1)]; # FastContiguousSubArray
+                d1 = @view a1[begin:1:end]; # FastSubArray
+
+                ax1 = eachindex(a1);
+                @test b1[ax1] == c1[ax1] == d1[ax1] == a1[ax1]
+                @test b1[:] == c1[:] == d1[:] == a1[:]
+
+                # some arbitrary indices
+                inds1 = 2:4
+                c1 = @view a1[inds1]
+                @test c1[axes(c1,1)] == c1[:] == a1[inds1]
+
+                inds12 = Base.IdentityUnitRange(Base.OneTo(4))
+                c1 = @view a1[inds12]
+                @test c1[axes(c1,1)] == c1[:] == a1[inds12]
+
+                inds2 = 3:2:5
+                d1 = @view a1[inds2]
+                @test d1[axes(d1,1)] == d1[:] == a1[inds2]
+            end
+        end
+
+        @testset "2D" begin
+            a2_ = reshape(1:25, 5, 5)
+            for a2 in Any[a2_, collect(a2_)]
+                b2 = @view a2[:, :]; # 2D FastContiguousSubArray
+                b22 = @view a2[:]; # 1D FastContiguousSubArray
+                c2 = @view a2[eachindex(a2)]; # 1D FastContiguousSubArray
+                d2 = @view a2[begin:1:end]; # 1D FastSubArray
+
+                ax2 = eachindex(a2);
+                @test b2[ax2] == b22[ax2] == c2[ax2] == d2[ax2] == a2[ax2]
+                @test b2[:] == b22[:] == c2[:] == d2[:] == a2[:]
+
+                # some arbitrary indices
+                inds1 = 2:4
+                c2 = @view a2[inds1]
+                @test c2[axes(c2,1)] == c2[:] == a2[inds1]
+
+                inds12 = Base.IdentityUnitRange(Base.OneTo(4))
+                c2 = @view a2[inds12]
+                @test c2[axes(c2,1)] == c2[:] == a2[inds12]
+
+                inds2 = 2:2:4
+                d2 = @view a2[inds2];
+                @test d2[axes(d2,1)] == d2[:] == a2[inds2]
+            end
+        end
+    end
+    @testset "setindex!" begin
+        @testset "1D" begin
+            a1 = rand(10);
+            a12 = copy(a1);
+            b1 = @view a1[:]; # 1D FastContiguousSubArray
+            c1 = @view a1[eachindex(a1)]; # 1D FastContiguousSubArray
+            d1 = @view a1[begin:1:end]; # 1D FastSubArray
+
+            ax1 = eachindex(a1);
+            @test (b1[ax1] = a12; b1) == (c1[ax1] = a12; c1) == (d1[ax1] = a12; d1) == (a1[ax1] = a12; a1)
+            @test (b1[:] = a12; b1) == (c1[:] = a12; c1) == (d1[:] = a12; d1) == (a1[:] = a12; a1)
+
+            # some arbitrary indices
+            ind1 = 2:4
+            c1 = a12[ind1]
+            @test (c1[axes(c1,1)] = a12[ind1]; c1) == (c1[:] = a12[ind1]; c1) == a12[ind1]
+
+            inds1 = Base.IdentityUnitRange(Base.OneTo(4))
+            c1 = @view a1[inds1]
+            @test (c1[eachindex(c1)] = @view(a12[inds1]); c1) == @view(a12[inds1])
+
+            ind2 = 2:2:8
+            d1 = a12[ind2]
+            @test (d1[axes(d1,1)] = a12[ind2]; d1) == (d1[:] = a12[ind2]; d1) == a12[ind2]
+        end
+
+        @testset "2D" begin
+            a2 = rand(10, 10);
+            a22 = copy(a2);
+            a2v = vec(a22);
+            b2 = @view a2[:, :]; # 2D FastContiguousSubArray
+            c2 = @view a2[eachindex(a2)]; # 1D FastContiguousSubArray
+            d2 = @view a2[begin:1:end]; # 1D FastSubArray
+
+            @test (b2[eachindex(b2)] = a2v; vec(b2)) == (c2[eachindex(c2)] = a2v; c2) == a2v
+            @test (d2[eachindex(d2)] = a2v; d2) == a2v
+
+            # some arbitrary indices
+            inds1 = 3:9
+            c2 = @view a2[inds1]
+            @test (c2[eachindex(c2)] = @view(a22[inds1]); c2) == @view(a22[inds1])
+
+            inds1 = Base.IdentityUnitRange(Base.OneTo(4))
+            c2 = @view a2[inds1]
+            @test (c2[eachindex(c2)] = @view(a22[inds1]); c2) == @view(a22[inds1])
+
+            inds2 = 3:3:9
+            d2 = @view a2[inds2]
+            @test (d2[eachindex(d2)] = @view(a22[inds2]); d2) == @view(a22[inds2])
+        end
+    end
+end
+
 @testset "issue #11871" begin
     a = fill(1., (2,2))
     b = view(a, 1:2, 1:2)

From ad2d770e9110022392509b3270a12418f28246b9 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 14 Dec 2023 14:18:22 -0500
Subject: [PATCH 0442/1315] test: fix timeout changed by #52461 accidentally
 (#52534)

---
 stdlib/Profile/test/runtests.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/Profile/test/runtests.jl b/stdlib/Profile/test/runtests.jl
index 39da65952bf24..ad7c12272d051 100644
--- a/stdlib/Profile/test/runtests.jl
+++ b/stdlib/Profile/test/runtests.jl
@@ -199,7 +199,7 @@ if Sys.isbsd() || Sys.islinux()
             finally
                 closewrite(iob)
             end
-            t = Timer(10) do t
+            t = Timer(120) do t
                 # should be under 10 seconds, so give it 2 minutes then report failure
                 println("KILLING siginfo/sigusr1 test BY PROFILE TEST WATCHDOG\n")
                 kill(p, Base.SIGTERM)

From e9b0fa11c992b3aa9a1f327c52816391e323ab8f Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 14 Dec 2023 14:54:58 -0500
Subject: [PATCH 0443/1315] Add preference for version named manifest files
 (#43845)

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 NEWS.md                           |  5 +++++
 base/loading.jl                   |  7 ++++++-
 doc/src/manual/code-loading.md    |  4 ++--
 stdlib/Artifacts/src/Artifacts.jl |  2 +-
 stdlib/Artifacts/test/runtests.jl |  2 +-
 test/loading.jl                   | 31 ++++++++++++++++++++++++++++++-
 6 files changed, 45 insertions(+), 6 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index feb51b0fa40ad..28be243e568a4 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -16,6 +16,11 @@ New language features
   particularly useful for holding styling information, and is used extensively
   in the new `StyledStrings` standard library. There is also a new `AnnotatedChar`
   type, that is the equivalent new `AbstractChar` type.
+* `Manifest.toml` files can now be renamed in the format `Manifest-v{major}.{minor}.toml`
+  to be preferentially picked up by the given julia version. i.e. in the same folder,
+  a `Manifest-v1.11.toml` would be used by v1.11 and `Manifest.toml` by every other julia
+  version. This makes managing environments for multiple julia versions at the same time
+  easier ([#43845]).
 
 Language changes
 ----------------
diff --git a/base/loading.jl b/base/loading.jl
index 25f75c9086589..fbd50d4d7f95b 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -566,7 +566,12 @@ end
 ## generic project & manifest API ##
 
 const project_names = ("JuliaProject.toml", "Project.toml")
-const manifest_names = ("JuliaManifest.toml", "Manifest.toml")
+const manifest_names = (
+    "JuliaManifest-v$(VERSION.major).$(VERSION.minor).toml",
+    "Manifest-v$(VERSION.major).$(VERSION.minor).toml",
+    "JuliaManifest.toml",
+    "Manifest.toml",
+)
 const preferences_names = ("JuliaLocalPreferences.toml", "LocalPreferences.toml")
 
 function locate_project_file(env::String)
diff --git a/doc/src/manual/code-loading.md b/doc/src/manual/code-loading.md
index 743ee83c333a4..25ebf3475f34c 100644
--- a/doc/src/manual/code-loading.md
+++ b/doc/src/manual/code-loading.md
@@ -14,7 +14,7 @@ Code inclusion is quite straightforward and simple: it evaluates the given sourc
 
 A *package* is a source tree with a standard layout providing functionality that can be reused by other Julia projects. A package is loaded by `import X` or  `using X` statements. These statements also make the module named `X`—which results from loading the package code—available within the module where the import statement occurs. The meaning of `X` in `import X` is context-dependent: which `X` package is loaded depends on what code the statement occurs in. Thus, handling of `import X` happens in two stages: first, it determines **what** package is defined to be `X` in this context; second, it determines **where** that particular `X` package is found.
 
-These questions are answered by searching through the project environments listed in [`LOAD_PATH`](@ref) for project files (`Project.toml` or `JuliaProject.toml`), manifest files (`Manifest.toml` or `JuliaManifest.toml`), or folders of source files.
+These questions are answered by searching through the project environments listed in [`LOAD_PATH`](@ref) for project files (`Project.toml` or `JuliaProject.toml`), manifest files (`Manifest.toml` or `JuliaManifest.toml`, or the same names suffixed by `-v{major}.{minor}.toml` for specific versions), or folders of source files.
 
 
 ## Federation of packages
@@ -63,7 +63,7 @@ Each kind of environment defines these three maps differently, as detailed in th
 
 ### Project environments
 
-A project environment is determined by a directory containing a project file called `Project.toml`, and optionally a manifest file called `Manifest.toml`. These files may also be called `JuliaProject.toml` and `JuliaManifest.toml`, in which case `Project.toml` and `Manifest.toml` are ignored. This allows for coexistence with other tools that might consider files called `Project.toml` and `Manifest.toml` significant. For pure Julia projects, however, the names `Project.toml` and `Manifest.toml` are preferred.
+A project environment is determined by a directory containing a project file called `Project.toml`, and optionally a manifest file called `Manifest.toml`. These files may also be called `JuliaProject.toml` and `JuliaManifest.toml`, in which case `Project.toml` and `Manifest.toml` are ignored. This allows for coexistence with other tools that might consider files called `Project.toml` and `Manifest.toml` significant. For pure Julia projects, however, the names `Project.toml` and `Manifest.toml` are preferred. However, from Julia v1.11 onwards, `(Julia)Manifest-v{major}.{minor}.toml` is recognized as a format to make a given julia version use a specific manifest file i.e. in the same folder, a `Manifest-v1.11.toml` would be used by v1.11 and `Manifest.toml` by any other julia version.
 
 The roots, graph and paths maps of a project environment are defined as follows:
 
diff --git a/stdlib/Artifacts/src/Artifacts.jl b/stdlib/Artifacts/src/Artifacts.jl
index 5daf994bfbf10..348d0d8990f58 100644
--- a/stdlib/Artifacts/src/Artifacts.jl
+++ b/stdlib/Artifacts/src/Artifacts.jl
@@ -18,7 +18,7 @@ function parse_toml(path::String)
     Base.parsed_toml(path)
 end
 
-# keep in sync with Base.project_names and Base.manifest_names
+# keep in sync with Base.project_names
 const artifact_names = ("JuliaArtifacts.toml", "Artifacts.toml")
 
 const ARTIFACTS_DIR_OVERRIDE = Ref{Union{String,Nothing}}(nothing)
diff --git a/stdlib/Artifacts/test/runtests.jl b/stdlib/Artifacts/test/runtests.jl
index 57b7e018e327a..db0d5d4c53ab1 100644
--- a/stdlib/Artifacts/test/runtests.jl
+++ b/stdlib/Artifacts/test/runtests.jl
@@ -258,6 +258,6 @@ end
 @testset "`Artifacts.artifact_names` and friends" begin
     n = length(Artifacts.artifact_names)
     @test length(Base.project_names) == n
-    @test length(Base.manifest_names) == n
+    @test length(Base.manifest_names) == 2n # there are two manifest names per project name
     @test length(Base.preferences_names) == n
 end
diff --git a/test/loading.jl b/test/loading.jl
index d39bdceb53341..c3bdce3890795 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -795,8 +795,10 @@ end
 @testset "`Base.project_names` and friends" begin
     # Some functions in Pkg assumes that these tuples have the same length
     n = length(Base.project_names)
-    @test length(Base.manifest_names) == n
     @test length(Base.preferences_names) == n
+
+    # there are two manifest names per project name
+    @test length(Base.manifest_names) == 2n
 end
 
 @testset "Manifest formats" begin
@@ -825,6 +827,33 @@ end
     end
 end
 
+@testset "Manifest name preferential loading" begin
+    mktempdir() do tmp
+        proj = joinpath(tmp, "Project.toml")
+        touch(proj)
+        for man_name in (
+            "Manifest.toml",
+            "JuliaManifest.toml",
+            "Manifest-v$(VERSION.major).$(VERSION.minor).toml",
+            "JuliaManifest-v$(VERSION.major).$(VERSION.minor).toml"
+            )
+            touch(joinpath(tmp, man_name))
+            man = basename(Base.project_file_manifest_path(proj))
+            @test man == man_name
+        end
+    end
+    mktempdir() do tmp
+        # check that another version isn't preferred
+        proj = joinpath(tmp, "Project.toml")
+        touch(proj)
+        touch(joinpath(tmp, "Manifest-v1.5.toml"))
+        @test Base.project_file_manifest_path(proj) == nothing
+        touch(joinpath(tmp, "Manifest.toml"))
+        man = basename(Base.project_file_manifest_path(proj))
+        @test man == "Manifest.toml"
+    end
+end
+
 @testset "error message loading pkg bad module name" begin
     mktempdir() do tmp
         old_loadpath = copy(LOAD_PATH)

From 5e4e7fa153ed0c272c73076a9c386abc3f434c1b Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Thu, 14 Dec 2023 19:17:27 -0500
Subject: [PATCH 0444/1315] remove unnecessary `\up` (upright) from some latex
 abbrevs (e.g. \upMu -> \Mu) (#50925)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #50911.  Closes #50913.

There were a few oddball symbols prefixed with `\up` (for "upright") for
no reason that I can tell, ala the LaTeX "upgreek" package, even though
we don't use an `\up` prefix for other upright Greek letters (e.g. we
have `\alpha`, not `\upalpha`, even though it isn't italicized — we have
`\italpha` for italic alpha).

Not breaking since this is just a UI thing.

(In practice, I doubt many people use these symbols. e.g. `\upMu` is
`Μ`, which looks a lot like the Latin `M`. But there is no reason to
have the `\up` prefix here. It seems to have just been an automated
abbreviation-import snafu. And [`\upkoppa 'ϟ'`
(U+O3DF)](https://www.compart.com/en/unicode/U+03DF) is visually quite
distinctive though I've never seen it used in math, not to mention
lowercase — it's definitely goofy to have an `\up` prefix for it.)
---
 stdlib/REPL/src/latex_symbols.jl | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/stdlib/REPL/src/latex_symbols.jl b/stdlib/REPL/src/latex_symbols.jl
index ddd110de8b714..bc406e1468710 100644
--- a/stdlib/REPL/src/latex_symbols.jl
+++ b/stdlib/REPL/src/latex_symbols.jl
@@ -984,17 +984,16 @@ const latex_symbols = Dict(
     "\\droang" => "̚",  # left angle above (non-spacing)
     "\\wideutilde" => "̰",  # under tilde accent (multiple characters and non-spacing)
     "\\not" => "̸",  # combining long solidus overlay
-    "\\upMu" => "Μ",  # capital mu, greek
-    "\\upNu" => "Ν",  # capital nu, greek
-    "\\upOmicron" => "Ο",  # capital omicron, greek
-    "\\upepsilon" => "ε",  # rounded small epsilon, greek
-    "\\upomicron" => "ο",  # small omicron, greek
-    "\\upvarbeta" => "ϐ",  # rounded small beta, greek
-    "\\upoldKoppa" => "Ϙ",  # greek letter archaic koppa
-    "\\upoldkoppa" => "ϙ",  # greek small letter archaic koppa
-    "\\upstigma" => "ϛ",  # greek small letter stigma
-    "\\upkoppa" => "ϟ",  # greek small letter koppa
-    "\\upsampi" => "ϡ",  # greek small letter sampi
+    "\\Mu" => "Μ",  # capital mu, greek
+    "\\Nu" => "Ν",  # capital nu, greek
+    "\\Omicron" => "Ο",  # capital omicron, greek
+    "\\omicron" => "ο",  # small omicron, greek
+    "\\varbeta" => "ϐ",  # rounded small beta, greek
+    "\\oldKoppa" => "Ϙ",  # greek letter archaic koppa
+    "\\oldkoppa" => "ϙ",  # greek small letter archaic koppa
+    "\\stigma" => "ϛ",  # greek small letter stigma
+    "\\koppa" => "ϟ",  # greek small letter koppa
+    "\\sampi" => "ϡ",  # greek small letter sampi
     "\\tieconcat" => "⁀",  # character tie, z notation sequence concatenation
     "\\leftharpoonaccent" => "⃐",  # combining left harpoon above
     "\\rightharpoonaccent" => "⃑",  # combining right harpoon above

From d0efc5cd29740ed7e100c59fa79d5c54801b9d69 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Thu, 14 Dec 2023 20:01:55 -0500
Subject: [PATCH 0445/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=205f666b077=20to=2085f1e5564=20(#52537)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5     | 1 -
 .../Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512  | 1 -
 .../Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5     | 1 +
 .../Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512

diff --git a/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5 b/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5
deleted file mode 100644
index 42689be2f3b8f..0000000000000
--- a/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-01bdae97c316f2e9dda5136f0d630865
diff --git a/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512 b/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512
deleted file mode 100644
index 58d2c23eefa8b..0000000000000
--- a/deps/checksums/Pkg-5f666b077298c6862ecce3a0e78cab29fd6c5cbf.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-95aa0943a88bc55d262595a23a153eba21f2e9275dd39f8414678f8c6483f1807ab687c84da4162674c0fd66fc5c801f532adaa8b776652495707b65f5262c87
diff --git a/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5 b/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5
new file mode 100644
index 0000000000000..aa3fbc2f13b9f
--- /dev/null
+++ b/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5
@@ -0,0 +1 @@
+7d9833fd8933f957c7060ff8ff61909d
diff --git a/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512 b/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512
new file mode 100644
index 0000000000000..6608a48614ed2
--- /dev/null
+++ b/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512
@@ -0,0 +1 @@
+a4634d94c5136b59aa1683a5c82fd9d8cc0d27483c2042f60fba88ebf7ca54bb5c0c6244fb69054b89aa480742cce81e5e6e69905f07bd570ca61019896e6ee3
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index ea2a64d1e4dae..98a3e315c3a54 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 5f666b077298c6862ecce3a0e78cab29fd6c5cbf
+PKG_SHA1 = 85f1e5564d733c9b04199d3523aeef0607f564e2
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 9fc1b653c435217c2af7b54b5a6a4bcec3d9bad0 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Fri, 15 Dec 2023 01:24:22 -0500
Subject: [PATCH 0446/1315] clarify permutedims docs (#52261)

As commented [on
discourse](https://discourse.julialang.org/t/how-do-we-julians-win-big-when-the-situation-is-so-unfair/106433/63?u=stevengj),
it would be nice if the `permutedims` examples began with something like
an array of strings where `transpose` is inapplicable.

This PR simply clarifies the docs and adds a few more examples.

---------

Co-authored-by: Haakon Ludvig Langeland Ervik <45243236+haakon-e@users.noreply.github.com>
Co-authored-by: Jishnu Bhattacharya <jishnub.github@gmail.com>
---
 base/permuteddimsarray.jl | 137 ++++++++++++++++++++++++++++----------
 1 file changed, 100 insertions(+), 37 deletions(-)

diff --git a/base/permuteddimsarray.jl b/base/permuteddimsarray.jl
index a4335609c7d7f..c66f441d6f963 100644
--- a/base/permuteddimsarray.jl
+++ b/base/permuteddimsarray.jl
@@ -87,13 +87,68 @@ end
 
 """
     permutedims(A::AbstractArray, perm)
+    permutedims(A::AbstractMatrix)
 
-Permute the dimensions of array `A`. `perm` is a vector or a tuple of length `ndims(A)`
+Permute the dimensions (axes) of array `A`. `perm` is a tuple or vector of `ndims(A)` integers
 specifying the permutation.
 
+If `A` is a 2d array ([`AbstractMatrix`](@ref)), then
+`perm` defaults to `(2,1)`, swapping the two axes of `A` (the rows and columns
+of the matrix).   This differs from [`transpose`](@ref) in that the
+operation is not recursive, which is especially useful for arrays of non-numeric values
+(where the recursive `transpose` would throw an error) and/or 2d arrays that do not represent
+linear operators.
+
+For 1d arrays, see [`permutedims(v::AbstractVector)`](@ref), which returns a 1-row “matrix”.
+
 See also [`permutedims!`](@ref), [`PermutedDimsArray`](@ref), [`transpose`](@ref), [`invperm`](@ref).
 
 # Examples
+
+## 2d arrays:
+Unlike `transpose`, `permutedims` can be used to swap rows and columns of 2d arrays of
+arbitrary non-numeric elements, such as strings:
+```jldoctest
+julia> A = ["a" "b" "c"
+            "d" "e" "f"]
+2×3 Matrix{String}:
+ "a"  "b"  "c"
+ "d"  "e"  "f"
+
+julia> permutedims(A)
+3×2 Matrix{String}:
+ "a"  "d"
+ "b"  "e"
+ "c"  "f"
+```
+And `permutedims` produces results that differ from `transpose`
+for matrices whose elements are themselves numeric matrices:
+```jldoctest; setup = :(using LinearAlgebra)
+julia> a = [1 2; 3 4];
+
+julia> b = [5 6; 7 8];
+
+julia> c = [9 10; 11 12];
+
+julia> d = [13 14; 15 16];
+
+julia> X = [[a] [b]; [c] [d]]
+2×2 Matrix{Matrix{Int64}}:
+ [1 2; 3 4]     [5 6; 7 8]
+ [9 10; 11 12]  [13 14; 15 16]
+
+julia> permutedims(X)
+2×2 Matrix{Matrix{Int64}}:
+ [1 2; 3 4]  [9 10; 11 12]
+ [5 6; 7 8]  [13 14; 15 16]
+
+julia> transpose(X)
+2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
+ [1 3; 2 4]  [9 11; 10 12]
+ [5 7; 6 8]  [13 15; 14 16]
+```
+
+## Multi-dimensional arrays
 ```jldoctest
 julia> A = reshape(Vector(1:8), (2,2,2))
 2×2×2 Array{Int64, 3}:
@@ -143,54 +198,62 @@ function permutedims(A::AbstractArray, perm)
     permutedims!(dest, A, perm)
 end
 
-"""
-    permutedims(m::AbstractMatrix)
-
-Permute the dimensions of the matrix `m`, by flipping the elements across the diagonal of
-the matrix. Differs from `LinearAlgebra`'s [`transpose`](@ref) in that the
-operation is not recursive.
-
-# Examples
-```jldoctest; setup = :(using LinearAlgebra)
-julia> a = [1 2; 3 4];
-
-julia> b = [5 6; 7 8];
-
-julia> c = [9 10; 11 12];
-
-julia> d = [13 14; 15 16];
-
-julia> X = [[a] [b]; [c] [d]]
-2×2 Matrix{Matrix{Int64}}:
- [1 2; 3 4]     [5 6; 7 8]
- [9 10; 11 12]  [13 14; 15 16]
-
-julia> permutedims(X)
-2×2 Matrix{Matrix{Int64}}:
- [1 2; 3 4]  [9 10; 11 12]
- [5 6; 7 8]  [13 14; 15 16]
-
-julia> transpose(X)
-2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
- [1 3; 2 4]  [9 11; 10 12]
- [5 7; 6 8]  [13 15; 14 16]
-```
-"""
 permutedims(A::AbstractMatrix) = permutedims(A, (2,1))
 
 """
     permutedims(v::AbstractVector)
 
 Reshape vector `v` into a `1 × length(v)` row matrix.
-Differs from `LinearAlgebra`'s [`transpose`](@ref) in that
-the operation is not recursive.
+Differs from [`transpose`](@ref) in that
+the operation is not recursive, which is especially useful for arrays of non-numeric values
+(where the recursive `transpose` might throw an error).
 
 # Examples
+Unlike `transpose`, `permutedims` can be used on vectors of
+arbitrary non-numeric elements, such as strings:
+```jldoctest
+julia> permutedims(["a", "b", "c"])
+1×3 Matrix{String}:
+ "a"  "b"  "c"
+```
+For vectors of numbers, `permutedims(v)` works much like `transpose(v)`
+except that the return type differs (it uses [`reshape`](@ref)
+rather than a `LinearAlgebra.Transpose` view, though both
+share memory with the original array `v`):
 ```jldoctest; setup = :(using LinearAlgebra)
-julia> permutedims([1, 2, 3, 4])
+julia> v = [1, 2, 3, 4]
+4-element Vector{Int64}:
+ 1
+ 2
+ 3
+ 4
+
+julia> p = permutedims(v)
 1×4 Matrix{Int64}:
  1  2  3  4
 
+julia> r = transpose(v)
+1×4 transpose(::Vector{Int64}) with eltype Int64:
+ 1  2  3  4
+
+julia> p == r
+true
+
+julia> typeof(r)
+Transpose{Int64, Vector{Int64}}
+
+julia> p[1] = 5; r[2] = 6; # mutating p or r also changes v
+
+julia> v # shares memory with both p and r
+4-element Vector{Int64}:
+ 5
+ 6
+ 3
+ 4
+```
+However, `permutedims` produces results that differ from `transpose`
+for vectors whose elements are themselves numeric matrices:
+```jldoctest; setup = :(using LinearAlgebra)
 julia> V = [[[1 2; 3 4]]; [[5 6; 7 8]]]
 2-element Vector{Matrix{Int64}}:
  [1 2; 3 4]

From 2c2ea3aa649fcea7a7b889c80e211b84cf6f2510 Mon Sep 17 00:00:00 2001
From: Hendrik Ranocha <ranocha@users.noreply.github.com>
Date: Fri, 15 Dec 2023 16:53:35 +0100
Subject: [PATCH 0447/1315] Document environment variable
 JULIA_PKG_PRESERVE_TIERED_INSTALLED (#52362)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is based on

```julia
julia> using Pkg

help?> Pkg.add
...
  │ Note
  │
  │  To change the default strategy to PRESERVE_TIERED_INSTALLED set the env var
  │  JULIA_PKG_PRESERVE_TIERED_INSTALLED to true.
...
```

I suggest to backport this so that it becomes available in the release
docs of Julia v1.9 and newer.
---
 doc/src/manual/environment-variables.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/src/manual/environment-variables.md b/doc/src/manual/environment-variables.md
index 2fc1dcbb2f32b..4d591faedc8f1 100644
--- a/doc/src/manual/environment-variables.md
+++ b/doc/src/manual/environment-variables.md
@@ -251,6 +251,15 @@ If set to `true`, Pkg operations which use the git protocol will use an external
 
 The accuracy of the package resolver. This should be a positive integer, the default is `1`.
 
+### [`JULIA_PKG_PRESERVE_TIERED_INSTALLED`](@id JULIA_PKG_PRESERVE_TIERED_INSTALLED)
+
+Change the default package installation strategy to `Pkg.PRESERVE_TIERED_INSTALLED`
+to let the package manager try to install versions of packages while keeping as many
+versions of packages already installed as possible.
+
+!!! compat "Julia 1.9"
+    This only affects Julia 1.9 and above.
+
 ## Network transport
 
 ### [`JULIA_NO_VERIFY_HOSTS`](@id JULIA_NO_VERIFY_HOSTS)

From e8576fc50af10f27453337a8e4cb3deae522026c Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 15 Dec 2023 12:35:07 -0500
Subject: [PATCH 0448/1315] gc: add some guard rails and refinements to
 MemBalancer (#52197)

This replaces https://github.com/JuliaLang/julia/pull/50909, though
notably does not include the change to use heap size instead of heap
memory.

This adds the smoothing behavior from that prior PR (to better estimate
the long-term rates / ignore transient changes), updates the GC_TIME
printing to reflect the change to use MemBalancer heuristics, and adds
some other guardrails to the decisions so they do not get put off too
far into the future. Since, unlike several other languages that use
MemBalancer, we do not have a time-based trigger for GC to update these
heuristics continuously, so we need to make sure each step is reasonably
conservative (both from under and over predicting the rate). Finally,
this is stricter about observing limits set by the user, by strictly
limiting the exceedence rate to around 10%, while avoiding some prior
possible issues with the hard cut-off being disjoint at the cutoff. This
should mean we will go over the threshold slowly if the program
continues to demand more space. If we OOM eventually by the kerenl, we
would have died anyways from OOM now by ourself.
---
 src/gc-debug.c |  34 ++++++++--
 src/gc.c       | 175 ++++++++++++++++++++++++++++++++++++-------------
 src/gc.h       |  14 ++++
 3 files changed, 172 insertions(+), 51 deletions(-)

diff --git a/src/gc-debug.c b/src/gc-debug.c
index 84db461ce2b0a..108983ad8992d 100644
--- a/src/gc-debug.c
+++ b/src/gc-debug.c
@@ -849,11 +849,11 @@ void gc_time_pool_end(int sweep_full)
     double sweep_speed = sweep_gb / sweep_pool_sec;
     jl_safe_printf("GC sweep pools end %.2f ms at %.1f GB/s "
                    "(skipped %.2f %% of %" PRId64 ", swept %" PRId64 " pgs, "
-                   "%" PRId64 " freed with %" PRId64 " lazily) %s\n",
+                   "%" PRId64 " freed) %s\n",
                    sweep_pool_sec * 1000, sweep_speed,
                    (total_pages ? ((double)skipped_pages * 100) / total_pages : 0),
                    total_pages, total_pages - skipped_pages,
-                   freed_pages, lazy_freed_pages,
+                   freed_pages,
                    sweep_full ? "full" : "quick");
 }
 
@@ -945,12 +945,12 @@ void gc_time_sweep_pause(uint64_t gc_end_t, int64_t actual_allocd,
     jl_safe_printf("GC sweep pause %.2f ms live %" PRId64 " kB "
                    "(freed %" PRId64 " kB EST %" PRId64 " kB "
                    "[error %" PRId64 "] = %d%% of allocd b %" PRIu64 ") "
-                   "(%.2f ms in post_mark) %s | next in %" PRId64 " kB\n",
+                   "(%.2f ms in post_mark) %s\n",
                    jl_ns2ms(sweep_pause), live_bytes / 1024,
                    gc_num.freed / 1024, estimate_freed / 1024,
                    gc_num.freed - estimate_freed, pct, gc_num.allocd / 1024,
                    jl_ns2ms(gc_postmark_end - gc_premark_end),
-                   sweep_full ? "full" : "quick", -gc_num.allocd / 1024);
+                   sweep_full ? "full" : "quick");
 }
 
 void gc_time_summary(int sweep_full, uint64_t start, uint64_t end,
@@ -970,11 +970,35 @@ void gc_time_summary(int sweep_full, uint64_t start, uint64_t end,
         jl_safe_printf("TS: %" PRIu64 " Minor collection: estimate freed = %" PRIu64
                        " live = %" PRIu64 "m new interval = %" PRIu64 "m pause time = %"
                        PRIu64 "ms ttsp = %" PRIu64 "us mark time = %" PRIu64
-                       "ms sweep time = %" PRIu64 "ms \n",
+                       "ms sweep time = %" PRIu64 "ms\n",
                        end, freed, live/1024/1024,
                        interval/1024/1024, pause/1000000, ttsp,
                        mark/1000000,sweep/1000000);
 }
+
+void gc_heuristics_summary(
+        uint64_t old_alloc_diff, uint64_t alloc_mem,
+        uint64_t old_mut_time, uint64_t alloc_time,
+        uint64_t old_freed_diff, uint64_t gc_mem,
+        uint64_t old_pause_time, uint64_t gc_time,
+        int thrash_counter, const char *reason,
+        uint64_t current_heap, uint64_t target_heap)
+{
+    jl_safe_printf("Estimates: alloc_diff=%" PRIu64 "kB (%" PRIu64 ")"
+                            //"  nongc_time=%" PRIu64 "ns (%" PRIu64 ")"
+                            "  mut_time=%" PRIu64 "ns (%" PRIu64 ")"
+                            "  freed_diff=%" PRIu64 "kB (%" PRIu64 ")"
+                            "  pause_time=%" PRIu64 "ns (%" PRIu64 ")"
+                            "  thrash_counter=%d%s"
+                            "  current_heap=%" PRIu64 " MB"
+                            "  target_heap=%" PRIu64 " MB\n",
+                   old_alloc_diff/1024, alloc_mem/1024,
+                   old_mut_time/1000, alloc_time/1000,
+                   old_freed_diff/1024, gc_mem/1024,
+                   old_pause_time/1000, gc_time/1000,
+                   thrash_counter, reason,
+                   current_heap/1024/1024, target_heap/1024/1024);
+}
 #endif
 
 void jl_gc_debug_init(void)
diff --git a/src/gc.c b/src/gc.c
index 31e2da6ff997a..04004f267d01c 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -668,11 +668,12 @@ static const size_t default_collect_interval = 3200 * 1024 * sizeof(void*);
 static memsize_t max_total_memory = (memsize_t) MAX32HEAP;
 #endif
 // heuristic stuff for https://dl.acm.org/doi/10.1145/3563323
-static uint64_t old_pause_time = 0;
-static uint64_t old_mut_time = 0;
+// start with values that are in the target ranges to reduce transient hiccups at startup
+static uint64_t old_pause_time = 1e7; // 10 ms
+static uint64_t old_mut_time = 1e9; // 1 second
 static uint64_t old_heap_size = 0;
-static uint64_t old_alloc_diff = 0;
-static uint64_t old_freed_diff = 0;
+static uint64_t old_alloc_diff = default_collect_interval;
+static uint64_t old_freed_diff = default_collect_interval;
 static uint64_t gc_end_time = 0;
 static int thrash_counter = 0;
 static int thrashing = 0;
@@ -3303,9 +3304,37 @@ JL_DLLEXPORT int64_t jl_gc_live_bytes(void)
     return live_bytes;
 }
 
-double jl_gc_smooth(uint64_t old_val, uint64_t new_val, double factor)
+uint64_t jl_gc_smooth(uint64_t old_val, uint64_t new_val, double factor)
 {
-    return factor * old_val + (1.0-factor) * new_val;
+    double est = factor * old_val + (1 - factor) * new_val;
+    if (est <= 1)
+        return 1; // avoid issues with <= 0
+    if (est > (uint64_t)2<<36)
+        return (uint64_t)2<<36; // avoid overflow
+    return est;
+}
+
+// an overallocation curve inspired by array allocations
+// grows very fast initially, then much slower at large heaps
+static uint64_t overallocation(uint64_t old_val, uint64_t val, uint64_t max_val)
+{
+    // compute maxsize = maxsize + 4*maxsize^(7/8) + maxsize/8
+    // for small n, we grow much faster than O(n)
+    // for large n, we grow at O(n/8)
+    // and as we reach O(memory) for memory>>1MB,
+    // this means we end by adding about 10% of memory each time at most
+    int exp2 = sizeof(old_val) * 8 -
+#ifdef _P64
+        __builtin_clzll(old_val);
+#else
+        __builtin_clz(old_val);
+#endif
+    uint64_t inc = (uint64_t)((size_t)1 << (exp2 * 7 / 8)) * 4 + old_val / 8;
+    // once overallocation would exceed max_val, grow by no more than 5% of max_val
+    if (inc + val > max_val)
+        if (inc > max_val / 20)
+            return max_val / 20;
+    return inc;
 }
 
 size_t jl_maxrss(void);
@@ -3322,7 +3351,7 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
     jl_gc_markqueue_t *mq = &ptls->mark_queue;
 
     uint64_t gc_start_time = jl_hrtime();
-    uint64_t mutator_time = gc_start_time - gc_end_time;
+    uint64_t mutator_time = gc_end_time == 0 ? old_mut_time : gc_start_time - gc_end_time;
     uint64_t before_free_heap_size = jl_atomic_load_relaxed(&gc_heap_stats.heap_size);
     int64_t last_perm_scanned_bytes = perm_scanned_bytes;
     uint64_t start_mark_time = jl_hrtime();
@@ -3497,57 +3526,102 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
         gc_num.last_incremental_sweep = gc_end_time;
     }
 
-    jl_atomic_store_relaxed(&gc_heap_stats.heap_size, jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - freed_in_runtime);
+    size_t heap_size = jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - freed_in_runtime;
+    jl_atomic_store_relaxed(&gc_heap_stats.heap_size, heap_size);
     freed_in_runtime = 0;
-    size_t heap_size = jl_atomic_load_relaxed(&gc_heap_stats.heap_size);
-    double target_allocs = 0.0;
-    double min_interval = default_collect_interval;
+    uint64_t user_max = max_total_memory * 0.8;
+    uint64_t alloc_diff = before_free_heap_size - old_heap_size;
+    uint64_t freed_diff = before_free_heap_size - heap_size;
+    uint64_t target_heap;
+    const char *reason = ""; (void)reason; // for GC_TIME output stats
+    old_heap_size = heap_size; // TODO: Update these values dynamically instead of just during the GC
     if (collection == JL_GC_AUTO) {
-        uint64_t alloc_diff = before_free_heap_size - old_heap_size;
-        uint64_t freed_diff = before_free_heap_size - heap_size;
+        // update any heuristics only when the user does not force the GC
+        // but still update the timings, since GC was run and reset, even if it was too early
+        uint64_t target_allocs = 0.0;
         double alloc_smooth_factor = 0.95;
         double collect_smooth_factor = 0.5;
-        double tuning_factor = 0.03;
-        double alloc_mem = jl_gc_smooth(old_alloc_diff, alloc_diff, alloc_smooth_factor);
-        double alloc_time = jl_gc_smooth(old_mut_time, mutator_time + sweep_time, alloc_smooth_factor); // Charge sweeping to the mutator
-        double gc_mem = jl_gc_smooth(old_freed_diff, freed_diff, collect_smooth_factor);
-        double gc_time = jl_gc_smooth(old_pause_time, pause - sweep_time, collect_smooth_factor);
-        old_alloc_diff = alloc_diff;
-        old_mut_time = mutator_time;
-        old_freed_diff = freed_diff;
-        old_pause_time = pause;
-        old_heap_size = heap_size; // TODO: Update these values dynamically instead of just during the GC
-        if (gc_time > alloc_time * 95 && !(thrash_counter < 4))
+        double tuning_factor = 2e4;
+        uint64_t alloc_mem = jl_gc_smooth(old_alloc_diff, alloc_diff, alloc_smooth_factor);
+        uint64_t alloc_time = jl_gc_smooth(old_mut_time, mutator_time, alloc_smooth_factor); // TODO: subtract estimated finalizer time?
+        uint64_t gc_mem = jl_gc_smooth(old_freed_diff, freed_diff, collect_smooth_factor);
+        uint64_t gc_time = jl_gc_smooth(old_pause_time, pause - sweep_time, collect_smooth_factor);
+        old_alloc_diff = alloc_mem;
+        old_mut_time = alloc_time;
+        old_freed_diff = gc_mem;
+        old_pause_time = gc_time;
+        // thrashing estimator: if GC time more than 50% of the runtime
+        if (pause > mutator_time && !(thrash_counter < 4))
             thrash_counter += 1;
         else if (thrash_counter > 0)
             thrash_counter -= 1;
-        if (alloc_mem != 0 && alloc_time != 0 && gc_mem != 0 && gc_time != 0 ) {
-            double alloc_rate = alloc_mem/alloc_time;
-            double gc_rate = gc_mem/gc_time;
-            target_allocs = sqrt(((double)heap_size/min_interval * alloc_rate)/(gc_rate * tuning_factor)); // work on multiples of min interval
+        if (alloc_mem != 0 && alloc_time != 0 && gc_mem != 0 && gc_time != 0) {
+            double alloc_rate = (double)alloc_mem/alloc_time;
+            double gc_rate = (double)gc_mem/gc_time;
+            target_allocs = sqrt((double)heap_size * alloc_rate / gc_rate) * tuning_factor;
+        }
+
+        if (thrashing == 0 && thrash_counter >= 3) {
+            // require 3 consecutive thrashing cycles to force the default allocator rate
+            thrashing = 1;
+            // and require 4 default allocations to clear
+            thrash_counter = 6;
+        }
+        else if (thrashing == 1 && thrash_counter <= 2) {
+            thrashing = 0; // maybe we should report this to the user or error out?
+        }
+
+        target_heap = target_allocs + heap_size;
+        // optionally smooth this:
+        //   target_heap = jl_gc_smooth(jl_atomic_load_relaxed(&gc_heap_stats.heap_target), target_heap, alloc_smooth_factor);
+
+        // compute some guardrails values
+        uint64_t min_target_allocs = heap_size / 20; // minimum 5% of current heap
+        if (min_target_allocs < default_collect_interval / 8) // unless the heap is small
+            min_target_allocs = default_collect_interval / 8;
+        uint64_t max_target_allocs = overallocation(before_free_heap_size, heap_size, user_max);
+        if (max_target_allocs < min_target_allocs)
+            max_target_allocs = min_target_allocs;
+        // respect max_total_memory first
+        if (target_heap > user_max) {
+            target_allocs = heap_size < user_max ? user_max - heap_size : 1;
+            reason = " user limit";
+        }
+        // If we are thrashing use a default only (an average) for a couple collections
+        if (thrashing) {
+            uint64_t thrashing_allocs = sqrt((double)min_target_allocs * max_target_allocs);
+            if (target_allocs < thrashing_allocs) {
+                target_allocs = thrashing_allocs;
+                reason = " thrashing";
+            }
+        }
+        // then add the guardrails for transient issues
+        if (target_allocs > max_target_allocs) {
+            target_allocs = max_target_allocs;
+            reason = " rate limit max";
+        }
+        else if (target_allocs < min_target_allocs) {
+            target_allocs = min_target_allocs;
+            reason = " min limit";
         }
+        // and set the heap detection threshold
+        target_heap = target_allocs + heap_size;
+        if (target_heap < default_collect_interval) {
+            target_heap = default_collect_interval;
+            reason = " min heap";
+        }
+        jl_atomic_store_relaxed(&gc_heap_stats.heap_target, target_heap);
+    }
+    else {
+        target_heap = jl_atomic_load_relaxed(&gc_heap_stats.heap_target);
     }
-    if (thrashing == 0 && thrash_counter >= 3)
-        thrashing = 1;
-    else if (thrashing == 1 && thrash_counter <= 2)
-        thrashing = 0; // maybe we should report this to the user or error out?
-
-    int bad_result = (target_allocs*min_interval + heap_size) > 2 * jl_atomic_load_relaxed(&gc_heap_stats.heap_target); // Don't follow through on a bad decision
-    if (target_allocs == 0.0 || thrashing || bad_result) // If we are thrashing go back to default
-        target_allocs = 2*sqrt((double)heap_size/min_interval);
-    uint64_t target_heap = (uint64_t)target_allocs*min_interval + heap_size;
-    if (target_heap > max_total_memory && !thrashing) // Allow it to go over if we are thrashing if we die we die
-        target_heap = max_total_memory;
-    else if (target_heap < default_collect_interval)
-        target_heap = default_collect_interval;
-    jl_atomic_store_relaxed(&gc_heap_stats.heap_target, target_heap);
 
     double old_ratio = (double)promoted_bytes/(double)heap_size;
-    if (heap_size > max_total_memory * 0.8 || old_ratio > 0.15)
+    if (heap_size > user_max || old_ratio > 0.15)
         next_sweep_full = 1;
     else
         next_sweep_full = 0;
-    if (heap_size > max_total_memory * 0.8 || thrashing)
+    if (heap_size > user_max || thrashing)
         under_pressure = 1;
     // sweeping is over
     // 7. if it is a quick sweep, put back the remembered objects in queued state
@@ -3586,8 +3660,8 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
         gc_num.max_memory = max_memory;
     }
     gc_final_pause_end(gc_start_time, gc_end_time);
-    gc_time_sweep_pause(gc_end_time, allocd, live_bytes,
-                        estimate_freed, sweep_full);
+    gc_time_sweep_pause(gc_end_time, gc_num.allocd, live_bytes,
+                        gc_num.freed, sweep_full);
     gc_num.full_sweep += sweep_full;
     last_live_bytes = live_bytes;
     live_bytes += -gc_num.freed + gc_num.allocd;
@@ -3597,6 +3671,15 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
                     live_bytes, gc_num.interval, pause,
                     gc_num.time_to_safepoint,
                     gc_num.mark_time, gc_num.sweep_time);
+    if (collection == JL_GC_AUTO) {
+        gc_heuristics_summary(
+            old_alloc_diff, alloc_diff,
+            old_mut_time, mutator_time,
+            old_freed_diff, freed_diff,
+            old_pause_time, pause - sweep_time,
+            thrash_counter, reason,
+            heap_size, target_heap);
+    }
 
     prev_sweep_full = sweep_full;
     gc_num.pause += !recollect;
diff --git a/src/gc.h b/src/gc.h
index 85903469c918e..217b8050e40ac 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -525,6 +525,13 @@ void gc_time_summary(int sweep_full, uint64_t start, uint64_t end,
                      uint64_t freed, uint64_t live, uint64_t interval,
                      uint64_t pause, uint64_t ttsp, uint64_t mark,
                      uint64_t sweep);
+void gc_heuristics_summary(
+        uint64_t old_alloc_diff, uint64_t alloc_mem,
+        uint64_t old_mut_time, uint64_t alloc_time,
+        uint64_t old_freed_diff, uint64_t gc_mem,
+        uint64_t old_pause_time, uint64_t gc_time,
+        int thrash_counter, const char *reason,
+        uint64_t current_heap, uint64_t target_heap);
 #else
 #define gc_time_pool_start()
 STATIC_INLINE void gc_time_count_page(int freedall, int pg_skpd) JL_NOTSAFEPOINT
@@ -552,6 +559,13 @@ STATIC_INLINE void gc_time_count_mallocd_memory(int bits) JL_NOTSAFEPOINT
                             estimate_freed, sweep_full)
 #define  gc_time_summary(sweep_full, start, end, freed, live,           \
                          interval, pause, ttsp, mark, sweep)
+#define gc_heuristics_summary( \
+        old_alloc_diff, alloc_mem, \
+        old_mut_time, alloc_time, \
+        old_freed_diff, gc_mem, \
+        old_pause_time, gc_time, \
+        thrash_counter, reason, \
+        current_heap, target_heap)
 #endif
 
 #ifdef MEMFENCE

From e207c106ba7eaffcb521140baccc7795664a4d53 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sat, 16 Dec 2023 05:29:26 +0900
Subject: [PATCH 0449/1315] fix #52531, fix the effects modeling of `QuoteNode`
 (#52548)

What observed in #52531 is that `QuoteNode` can embed global variables
that users can modify. Therefore, when dealing with `QuoteNode`, it's
necessary to taint its `:inaccessiblememonly` just like we do for
`GlobalRef`.

- fixes #52531
- replaces #52536
---
 base/compiler/abstractinterpretation.jl |  4 +++-
 test/compiler/effects.jl                | 16 ++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 0541aa9e64278..bae7bad238318 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2306,7 +2306,9 @@ end
 
 function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(e), vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
     if isa(e, QuoteNode)
-        return RTEffects(Const(e.value), Union{}, EFFECTS_TOTAL)
+        effects = Effects(EFFECTS_TOTAL;
+            inaccessiblememonly = is_mutation_free_argtype(typeof(e.value)) ? ALWAYS_TRUE : ALWAYS_FALSE)
+        return RTEffects(Const(e.value), Union{}, effects)
     elseif isa(e, SSAValue)
         return RTEffects(abstract_eval_ssavalue(e, sv), Union{}, EFFECTS_TOTAL)
     elseif isa(e, SlotNumber)
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 9df29a19c5e28..2160a716af689 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1340,3 +1340,19 @@ end
     end
     return res
 end |> Core.Compiler.is_terminates
+
+# https://github.com/JuliaLang/julia/issues/52531
+const a52531 = Core.Ref(1)
+@eval getref52531() = $(QuoteNode(a52531)).x
+@test !Core.Compiler.is_consistent(Base.infer_effects(getref52531))
+let
+    global set_a52531!, get_a52531
+    _a::Int       = -1
+    set_a52531!(a::Int) = (_a = a; return get_a52531())
+    get_a52531()       = _a
+end
+@test !Core.Compiler.is_consistent(Base.infer_effects(set_a52531!, (Int,)))
+@test !Core.Compiler.is_consistent(Base.infer_effects(get_a52531, ()))
+@test get_a52531() == -1
+@test set_a52531!(1) == 1
+@test get_a52531() == 1

From 67c7843d8ca8e4cc1a3565e36b4e5b7339f6e4b2 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 15 Dec 2023 17:53:29 -0500
Subject: [PATCH 0450/1315] Log pid of parent process that is running the CI
 tests (#52554)

---
 test/runtests.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/runtests.jl b/test/runtests.jl
index 7f386160435db..1b839a41bf0e0 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -126,6 +126,7 @@ cd(@__DIR__) do
 
     println("""
         Running parallel tests with:
+          getpid() = $(getpid())
           nworkers() = $(nworkers())
           nthreads() = $(Threads.threadpoolsize())
           Sys.CPU_THREADS = $(Sys.CPU_THREADS)

From c99572e86e9c76f2c6df9e8a4cf6fd525fe0f8ce Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 18 Dec 2023 07:38:12 +0530
Subject: [PATCH 0451/1315] Propagate inbounds in
 triangular/symmetric/UpperHessenberg get/setindex (#52512)

Annotate several `getindex`/`setindex!` methods with
`@propagate_inbounds`. We may need to be a bit careful to check for
errant `@inbounds` annotations without a corresponding bounds-check.

Close #52550
---
 stdlib/LinearAlgebra/src/hessenberg.jl  |  4 +--
 stdlib/LinearAlgebra/src/symmetric.jl   |  4 +--
 stdlib/LinearAlgebra/src/triangular.jl  | 40 +++++++++++++++----------
 stdlib/LinearAlgebra/test/triangular.jl | 15 ++++++++++
 4 files changed, 43 insertions(+), 20 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/hessenberg.jl b/stdlib/LinearAlgebra/src/hessenberg.jl
index e0264ee5a8a60..87f7305f0146c 100644
--- a/stdlib/LinearAlgebra/src/hessenberg.jl
+++ b/stdlib/LinearAlgebra/src/hessenberg.jl
@@ -83,10 +83,10 @@ end
 Base.isassigned(H::UpperHessenberg, i::Int, j::Int) =
     i <= j+1 ? isassigned(H.data, i, j) : true
 
-getindex(H::UpperHessenberg{T}, i::Integer, j::Integer) where {T} =
+Base.@propagate_inbounds getindex(H::UpperHessenberg{T}, i::Integer, j::Integer) where {T} =
     i <= j+1 ? convert(T, H.data[i,j]) : zero(T)
 
-function setindex!(A::UpperHessenberg, x, i::Integer, j::Integer)
+Base.@propagate_inbounds function setindex!(A::UpperHessenberg, x, i::Integer, j::Integer)
     if i > j+1
         x == 0 || throw(ArgumentError("cannot set index in the lower triangular part " *
             "($i, $j) of an UpperHessenberg matrix to a nonzero value ($x)"))
diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 6827a416e7222..f45a630e0aadc 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -253,12 +253,12 @@ end
     end
 end
 
-function setindex!(A::Symmetric, v, i::Integer, j::Integer)
+@propagate_inbounds function setindex!(A::Symmetric, v, i::Integer, j::Integer)
     i == j || throw(ArgumentError("Cannot set a non-diagonal index in a symmetric matrix"))
     setindex!(A.data, v, i, j)
 end
 
-function setindex!(A::Hermitian, v, i::Integer, j::Integer)
+@propagate_inbounds function setindex!(A::Hermitian, v, i::Integer, j::Integer)
     if i != j
         throw(ArgumentError("Cannot set a non-diagonal index in a Hermitian matrix"))
     elseif !isreal(v)
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index f057133a2533c..6a97f9c194f83 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -239,16 +239,16 @@ Base.isstored(A::UnitUpperTriangular, i::Int, j::Int) =
 Base.isstored(A::UpperTriangular, i::Int, j::Int) =
     i <= j ? Base.isstored(A.data, i, j) : false
 
-getindex(A::UnitLowerTriangular{T}, i::Integer, j::Integer) where {T} =
+@propagate_inbounds getindex(A::UnitLowerTriangular{T}, i::Integer, j::Integer) where {T} =
     i > j ? A.data[i,j] : ifelse(i == j, oneunit(T), zero(T))
-getindex(A::LowerTriangular, i::Integer, j::Integer) =
+@propagate_inbounds getindex(A::LowerTriangular, i::Integer, j::Integer) =
     i >= j ? A.data[i,j] : zero(A.data[j,i])
-getindex(A::UnitUpperTriangular{T}, i::Integer, j::Integer) where {T} =
+@propagate_inbounds getindex(A::UnitUpperTriangular{T}, i::Integer, j::Integer) where {T} =
     i < j ? A.data[i,j] : ifelse(i == j, oneunit(T), zero(T))
-getindex(A::UpperTriangular, i::Integer, j::Integer) =
+@propagate_inbounds getindex(A::UpperTriangular, i::Integer, j::Integer) =
     i <= j ? A.data[i,j] : zero(A.data[j,i])
 
-function setindex!(A::UpperTriangular, x, i::Integer, j::Integer)
+@propagate_inbounds function setindex!(A::UpperTriangular, x, i::Integer, j::Integer)
     if i > j
         iszero(x) || throw(ArgumentError("cannot set index in the lower triangular part " *
             "($i, $j) of an UpperTriangular matrix to a nonzero value ($x)"))
@@ -258,7 +258,7 @@ function setindex!(A::UpperTriangular, x, i::Integer, j::Integer)
     return A
 end
 
-function setindex!(A::UnitUpperTriangular, x, i::Integer, j::Integer)
+@propagate_inbounds function setindex!(A::UnitUpperTriangular, x, i::Integer, j::Integer)
     if i > j
         iszero(x) || throw(ArgumentError("cannot set index in the lower triangular part " *
             "($i, $j) of a UnitUpperTriangular matrix to a nonzero value ($x)"))
@@ -271,7 +271,7 @@ function setindex!(A::UnitUpperTriangular, x, i::Integer, j::Integer)
     return A
 end
 
-function setindex!(A::LowerTriangular, x, i::Integer, j::Integer)
+@propagate_inbounds function setindex!(A::LowerTriangular, x, i::Integer, j::Integer)
     if i < j
         iszero(x) || throw(ArgumentError("cannot set index in the upper triangular part " *
             "($i, $j) of a LowerTriangular matrix to a nonzero value ($x)"))
@@ -281,7 +281,7 @@ function setindex!(A::LowerTriangular, x, i::Integer, j::Integer)
     return A
 end
 
-function setindex!(A::UnitLowerTriangular, x, i::Integer, j::Integer)
+@propagate_inbounds function setindex!(A::UnitLowerTriangular, x, i::Integer, j::Integer)
     if i < j
         iszero(x) || throw(ArgumentError("cannot set index in the upper triangular part " *
             "($i, $j) of a UnitLowerTriangular matrix to a nonzero value ($x)"))
@@ -467,6 +467,7 @@ tr(A::UnitUpperTriangular) = size(A, 1) * oneunit(eltype(A))
 
 # copy and scale
 function copyto!(A::T, B::T) where {T<:Union{UpperTriangular,UnitUpperTriangular}}
+    checkbounds(A, axes(B)...)
     n = size(B,1)
     for j = 1:n
         for i = 1:(isa(B, UnitUpperTriangular) ? j-1 : j)
@@ -476,6 +477,7 @@ function copyto!(A::T, B::T) where {T<:Union{UpperTriangular,UnitUpperTriangular
     return A
 end
 function copyto!(A::T, B::T) where {T<:Union{LowerTriangular,UnitLowerTriangular}}
+    checkbounds(A, axes(B)...)
     n = size(B,1)
     for j = 1:n
         for i = (isa(B, UnitLowerTriangular) ? j+1 : j):n
@@ -492,8 +494,14 @@ end
 @inline mul!(A::AbstractTriangular, B::Number, C::AbstractTriangular, alpha::Number, beta::Number) =
     _triscale!(A, B, C, MulAddMul(alpha, beta))
 
+function checksize1(A, B)
+    szA, szB = size(A), size(B)
+    szA == szB || throw(DimensionMismatch("size of A, $szA, does not match size of B, $szB"))
+    checksquare(B)
+end
+
 function _triscale!(A::UpperTriangular, B::UpperTriangular, c::Number, _add)
-    n = checksquare(B)
+    n = checksize1(A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
     for j = 1:n
         for i = 1:j
@@ -503,7 +511,7 @@ function _triscale!(A::UpperTriangular, B::UpperTriangular, c::Number, _add)
     return A
 end
 function _triscale!(A::UpperTriangular, c::Number, B::UpperTriangular, _add)
-    n = checksquare(B)
+    n = checksize1(A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
     for j = 1:n
         for i = 1:j
@@ -513,7 +521,7 @@ function _triscale!(A::UpperTriangular, c::Number, B::UpperTriangular, _add)
     return A
 end
 function _triscale!(A::UpperOrUnitUpperTriangular, B::UnitUpperTriangular, c::Number, _add)
-    n = checksquare(B)
+    n = checksize1(A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
     for j = 1:n
         @inbounds _modify!(_add, c, A, (j,j))
@@ -524,7 +532,7 @@ function _triscale!(A::UpperOrUnitUpperTriangular, B::UnitUpperTriangular, c::Nu
     return A
 end
 function _triscale!(A::UpperOrUnitUpperTriangular, c::Number, B::UnitUpperTriangular, _add)
-    n = checksquare(B)
+    n = checksize1(A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
     for j = 1:n
         @inbounds _modify!(_add, c, A, (j,j))
@@ -535,7 +543,7 @@ function _triscale!(A::UpperOrUnitUpperTriangular, c::Number, B::UnitUpperTriang
     return A
 end
 function _triscale!(A::LowerTriangular, B::LowerTriangular, c::Number, _add)
-    n = checksquare(B)
+    n = checksize1(A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
     for j = 1:n
         for i = j:n
@@ -545,7 +553,7 @@ function _triscale!(A::LowerTriangular, B::LowerTriangular, c::Number, _add)
     return A
 end
 function _triscale!(A::LowerTriangular, c::Number, B::LowerTriangular, _add)
-    n = checksquare(B)
+    n = checksize1(A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
     for j = 1:n
         for i = j:n
@@ -555,7 +563,7 @@ function _triscale!(A::LowerTriangular, c::Number, B::LowerTriangular, _add)
     return A
 end
 function _triscale!(A::LowerOrUnitLowerTriangular, B::UnitLowerTriangular, c::Number, _add)
-    n = checksquare(B)
+    n = checksize1(A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
     for j = 1:n
         @inbounds _modify!(_add, c, A, (j,j))
@@ -566,7 +574,7 @@ function _triscale!(A::LowerOrUnitLowerTriangular, B::UnitLowerTriangular, c::Nu
     return A
 end
 function _triscale!(A::LowerOrUnitLowerTriangular, c::Number, B::UnitLowerTriangular, _add)
-    n = checksquare(B)
+    n = checksize1(A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
     for j = 1:n
         @inbounds _modify!(_add, c, A, (j,j))
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index e0ba443ece7df..c99ec5552ffe3 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -866,4 +866,19 @@ end
     end
 end
 
+@testset "error paths" begin
+    A = zeros(1,1); B = zeros(2,2)
+    @testset "inplace mul scaling with incompatible sizes" begin
+        for T in (UpperTriangular, LowerTriangular, UnitUpperTriangular, UnitLowerTriangular)
+            @test_throws DimensionMismatch mul!(T(A), T(B), 3)
+            @test_throws DimensionMismatch mul!(T(A), 3, T(B))
+        end
+    end
+    @testset "copyto with incompatible sizes" begin
+        for T in (UpperTriangular, LowerTriangular, UnitUpperTriangular, UnitLowerTriangular)
+            @test_throws BoundsError copyto!(T(A), T(B))
+        end
+    end
+end
+
 end # module TestTriangular

From df5361ac5af25cfe54ba4a272a19aa10eaedd9b5 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 18 Dec 2023 07:42:24 +0530
Subject: [PATCH 0452/1315] Accept IndexStyle in diagind, defaulting to
 IndexLinear (#52549)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Partly revert and redesign #52115, with `diagind` now accepting an
optional `IndexStyle`, which is `IndexLinear` by default. This should
address the breakages reported in that PR. After this,
```julia
julia> D = Diagonal(1:4)
4×4 Diagonal{Int64, UnitRange{Int64}}:
 1  ⋅  ⋅  ⋅
 ⋅  2  ⋅  ⋅
 ⋅  ⋅  3  ⋅
 ⋅  ⋅  ⋅  4

julia> diagind(D)
1:5:16

julia> diagind(D, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 4)
```

---------

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 stdlib/LinearAlgebra/src/dense.jl          | 13 +++++++++----
 stdlib/LinearAlgebra/src/diagonal.jl       |  2 +-
 stdlib/LinearAlgebra/src/symmetric.jl      |  2 +-
 stdlib/LinearAlgebra/src/uniformscaling.jl |  2 +-
 4 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index b66cbee054eed..683f7e45cb28d 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -210,9 +210,12 @@ function diagind(::IndexCartesian, m::Integer, n::Integer, k::Integer=0)
 end
 
 """
-    diagind(M, k::Integer=0)
+    diagind(M::AbstractMatrix, [k::Integer=0,] indstyle::IndexStyle = IndexLinear())
 
 An `AbstractRange` giving the indices of the `k`th diagonal of the matrix `M`.
+Optionally, an index style may be specified which determines the type of the range returned.
+If `indstyle isa IndexLinear` (default), this returns an `AbstractRange{Integer}`.
+On the other hand, if `indstyle isa IndexCartesian`, this returns an `AbstractRange{CartesianIndex{2}}`.
 
 See also: [`diag`](@ref), [`diagm`](@ref), [`Diagonal`](@ref).
 
@@ -228,11 +231,13 @@ julia> diagind(A,-1)
 2:4:6
 ```
 """
-function diagind(A::AbstractMatrix, k::Integer=0)
+function diagind(A::AbstractMatrix, k::Integer=0, indexstyle::IndexStyle = IndexLinear())
     require_one_based_indexing(A)
-    diagind(IndexStyle(A), size(A,1), size(A,2), k)
+    diagind(indexstyle, size(A,1), size(A,2), k)
 end
 
+diagind(A::AbstractMatrix, indexstyle::IndexStyle) = diagind(A, 0, indexstyle)
+
 """
     diag(M, k::Integer=0)
 
@@ -254,7 +259,7 @@ julia> diag(A,1)
  6
 ```
 """
-diag(A::AbstractMatrix, k::Integer=0) = A[diagind(A,k)]
+diag(A::AbstractMatrix, k::Integer=0) = A[diagind(A, k, IndexStyle(A))]
 
 """
     diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index e47b0248fbe53..e71b438f230e3 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -890,7 +890,7 @@ dot(x::AbstractVector, D::Diagonal, y::AbstractVector) = _mapreduce_prod(dot, x,
 dot(A::Diagonal, B::Diagonal) = dot(A.diag, B.diag)
 function dot(D::Diagonal, B::AbstractMatrix)
     size(D) == size(B) || throw(DimensionMismatch("Matrix sizes $(size(D)) and $(size(B)) differ"))
-    return dot(D.diag, view(B, diagind(B)))
+    return dot(D.diag, view(B, diagind(B, IndexStyle(B))))
 end
 
 dot(A::AbstractMatrix, B::Diagonal) = conj(dot(B, A))
diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index f45a630e0aadc..67ed8afd35c0b 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -202,7 +202,7 @@ for (S, H) in ((:Symmetric, :Hermitian), (:Hermitian, :Symmetric))
         function $S(A::$H, uplo::Symbol)
             if A.uplo == char_uplo(uplo)
                 if $H === Hermitian && !(eltype(A) <: Real) &&
-                    any(!isreal, A.data[i] for i in diagind(A.data))
+                    any(!isreal, A.data[i] for i in diagind(A.data, IndexStyle(A.data)))
 
                     throw(ArgumentError("Cannot construct $($S)($($H))); diagonal contains complex values"))
                 end
diff --git a/stdlib/LinearAlgebra/src/uniformscaling.jl b/stdlib/LinearAlgebra/src/uniformscaling.jl
index b014472a9cec2..47a282b91b9ea 100644
--- a/stdlib/LinearAlgebra/src/uniformscaling.jl
+++ b/stdlib/LinearAlgebra/src/uniformscaling.jl
@@ -293,7 +293,7 @@ function mul!(out::AbstractMatrix{T}, a::Number, B::UniformScaling, α::Number,
     end
     s = convert(T, a*B.λ*α)
     if !iszero(s)
-        @inbounds for i in diagind(out)
+        @inbounds for i in diagind(out, IndexStyle(out))
             out[i] += s
         end
     end

From 7fe08e0748bb4486bd485aa9e045d516b5251fe2 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 18 Dec 2023 11:28:18 +0530
Subject: [PATCH 0453/1315] Specialize copy for Diagonal (#52500)

On master
```julia
julia> copy(Diagonal(1:4)) |> typeof
Diagonal{Int64, Vector{Int64}}
```
This PR
```julia
julia> copy(Diagonal(1:4)) |> typeof
Diagonal{Int64, UnitRange{Int64}}
```
Similar methods already exist for `Bidiagonal` and `Tridiagonal`, but
this was missing for `Diagonal`.
---
 stdlib/LinearAlgebra/src/diagonal.jl  | 2 ++
 stdlib/LinearAlgebra/test/diagonal.jl | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index e71b438f230e3..bd2958d1b222b 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -203,6 +203,8 @@ end
 
 parent(D::Diagonal) = D.diag
 
+copy(D::Diagonal) = Diagonal(copy(D.diag))
+
 ishermitian(D::Diagonal{<:Real}) = true
 ishermitian(D::Diagonal{<:Number}) = isreal(D.diag)
 ishermitian(D::Diagonal) = all(ishermitian, D.diag)
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 83a5ea3b3e03d..3de868a847b7c 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -1235,4 +1235,8 @@ end
     end
 end
 
+@testset "copy" begin
+    @test copy(Diagonal(1:5)) === Diagonal(1:5)
+end
+
 end # module TestDiagonal

From b57f8d168dc88be8570e1c9ff7cd352fc5e11c98 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Mon, 18 Dec 2023 10:20:17 +0100
Subject: [PATCH 0454/1315] Export method instance lookup functions (#52176)

---
 src/gf.c                  | 77 ++++++++++++++++++++++-----------------
 src/jl_exported_funcs.inc |  2 +
 src/julia.h               |  3 +-
 src/julia_internal.h      |  3 +-
 test/reflection.jl        |  8 ++++
 5 files changed, 57 insertions(+), 36 deletions(-)

diff --git a/src/gf.c b/src/gf.c
index ca462c26e6b1b..268927f60172e 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1444,34 +1444,45 @@ static jl_method_instance_t *cache_method(
 
 static jl_method_match_t *_gf_invoke_lookup(jl_value_t *types JL_PROPAGATES_ROOT, jl_value_t *mt, size_t world, size_t *min_valid, size_t *max_valid);
 
-static jl_method_instance_t *jl_mt_assoc_by_type(jl_methtable_t *mt JL_PROPAGATES_ROOT, jl_datatype_t *tt, size_t world)
+static jl_method_instance_t *jl_mt_assoc_by_type(jl_methtable_t *mt JL_PROPAGATES_ROOT, jl_datatype_t *tt JL_MAYBE_UNROOTED, size_t world)
 {
-    // caller must hold the mt->writelock
+    jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
+    jl_typemap_entry_t *entry = lookup_leafcache(leafcache, (jl_value_t*)tt, world);
+    if (entry)
+        return entry->func.linfo;
+    JL_TIMING(METHOD_LOOKUP_SLOW, METHOD_LOOKUP_SLOW);
+    jl_method_match_t *matc = NULL;
+    JL_GC_PUSH2(&tt, &matc);
+    JL_LOCK(&mt->writelock);
     assert(tt->isdispatchtuple || tt->hasfreetypevars);
+    jl_method_instance_t *mi = NULL;
     if (tt->isdispatchtuple) {
         jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
         jl_typemap_entry_t *entry = lookup_leafcache(leafcache, (jl_value_t*)tt, world);
         if (entry)
-            return entry->func.linfo;
+            mi = entry->func.linfo;
     }
 
-    struct jl_typemap_assoc search = {(jl_value_t*)tt, world, NULL, 0, ~(size_t)0};
-    jl_typemap_entry_t *entry = jl_typemap_assoc_by_type(jl_atomic_load_relaxed(&mt->cache), &search, jl_cachearg_offset(mt), /*subtype*/1);
-    if (entry)
-        return entry->func.linfo;
+    if (!mi) {
+        struct jl_typemap_assoc search = {(jl_value_t*)tt, world, NULL, 0, ~(size_t)0};
+        jl_typemap_entry_t *entry = jl_typemap_assoc_by_type(jl_atomic_load_relaxed(&mt->cache), &search, jl_cachearg_offset(mt), /*subtype*/1);
+        if (entry)
+            mi = entry->func.linfo;
+    }
 
-    size_t min_valid = 0;
-    size_t max_valid = ~(size_t)0;
-    jl_method_match_t *matc = _gf_invoke_lookup((jl_value_t*)tt, jl_nothing, world, &min_valid, &max_valid);
-    jl_method_instance_t *nf = NULL;
-    if (matc) {
-        JL_GC_PUSH1(&matc);
-        jl_method_t *m = matc->method;
-        jl_svec_t *env = matc->sparams;
-        nf = cache_method(mt, &mt->cache, (jl_value_t*)mt, tt, m, world, min_valid, max_valid, env);
-        JL_GC_POP();
+    if (!mi) {
+        size_t min_valid = 0;
+        size_t max_valid = ~(size_t)0;
+        matc = _gf_invoke_lookup((jl_value_t*)tt, jl_nothing, world, &min_valid, &max_valid);
+        if (matc) {
+            jl_method_t *m = matc->method;
+            jl_svec_t *env = matc->sparams;
+            mi = cache_method(mt, &mt->cache, (jl_value_t*)mt, tt, m, world, min_valid, max_valid, env);
+        }
     }
-    return nf;
+    JL_UNLOCK(&mt->writelock);
+    JL_GC_POP();
+    return mi;
 }
 
 
@@ -2233,7 +2244,19 @@ static jl_tupletype_t *lookup_arg_type_tuple(jl_value_t *arg1 JL_PROPAGATES_ROOT
     return jl_lookup_arg_tuple_type(arg1, args, nargs, 1);
 }
 
-jl_method_instance_t *jl_method_lookup(jl_value_t **args, size_t nargs, size_t world)
+JL_DLLEXPORT jl_method_instance_t *jl_method_lookup_by_tt(jl_tupletype_t *tt, size_t world, jl_value_t *_mt)
+{
+    jl_methtable_t *mt = NULL;
+    if (_mt == jl_nothing)
+        mt = jl_gf_ft_mtable(jl_tparam0(tt));
+    else {
+        assert(jl_isa(_mt, (jl_value_t*)jl_methtable_type));
+        mt = (jl_methtable_t*) _mt;
+    }
+    return jl_mt_assoc_by_type(mt, tt, world);
+}
+
+JL_DLLEXPORT jl_method_instance_t *jl_method_lookup(jl_value_t **args, size_t nargs, size_t world)
 {
     assert(nargs > 0 && "expected caller to handle this case");
     jl_methtable_t *mt = jl_gf_mtable(args[0]);
@@ -2242,16 +2265,7 @@ jl_method_instance_t *jl_method_lookup(jl_value_t **args, size_t nargs, size_t w
     if (entry)
         return entry->func.linfo;
     jl_tupletype_t *tt = arg_type_tuple(args[0], &args[1], nargs);
-    jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
-    entry = lookup_leafcache(leafcache, (jl_value_t*)tt, world);
-    if (entry)
-        return entry->func.linfo;
-    JL_GC_PUSH1(&tt);
-    JL_LOCK(&mt->writelock);
-    jl_method_instance_t *sf = jl_mt_assoc_by_type(mt, tt, world);
-    JL_UNLOCK(&mt->writelock);
-    JL_GC_POP();
-    return sf;
+    return jl_mt_assoc_by_type(mt, tt, world);
 }
 
 // return a Vector{Any} of svecs, each describing a method match:
@@ -3051,14 +3065,9 @@ STATIC_INLINE jl_method_instance_t *jl_lookup_generic_(jl_value_t *F, jl_value_t
         mfunc = entry->func.linfo;
     }
     else {
-        JL_GC_PUSH1(&tt);
         assert(tt);
-        JL_LOCK(&mt->writelock);
         // cache miss case
-        JL_TIMING(METHOD_LOOKUP_SLOW, METHOD_LOOKUP_SLOW);
         mfunc = jl_mt_assoc_by_type(mt, tt, world);
-        JL_UNLOCK(&mt->writelock);
-        JL_GC_POP();
         if (jl_options.malloc_log)
             jl_gc_sync_total_bytes(last_alloc); // discard allocation count from compilation
         if (mfunc == NULL) {
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 9131ece904e88..8e850b47f2fe7 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -238,6 +238,8 @@
     XX(jl_get_world_counter) \
     XX(jl_get_zero_subnormals) \
     XX(jl_gf_invoke_lookup) \
+    XX(jl_method_lookup_by_tt) \
+    XX(jl_method_lookup) \
     XX(jl_gf_invoke_lookup_worlds) \
     XX(jl_git_branch) \
     XX(jl_git_commit) \
diff --git a/src/julia.h b/src/julia.h
index c5aa659670612..6ad742d78602b 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1294,7 +1294,8 @@ STATIC_INLINE void jl_array_uint32_set(void *a, size_t i, uint32_t x) JL_NOTSAFE
 #define jl_string_data(s) ((char*)s + sizeof(void*))
 #define jl_string_len(s)  (*(size_t*)s)
 
-#define jl_gf_mtable(f) (((jl_datatype_t*)jl_typeof(f))->name->mt)
+#define jl_gf_ft_mtable(ft) (((jl_datatype_t*)ft)->name->mt)
+#define jl_gf_mtable(f) (jl_gf_ft_mtable(jl_typeof(f)))
 #define jl_gf_name(f)   (jl_gf_mtable(f)->name)
 
 // struct type info
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 7f9cf06798ce0..1ecf7a0c1cdfa 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -777,7 +777,8 @@ JL_DLLEXPORT int jl_is_toplevel_only_expr(jl_value_t *e) JL_NOTSAFEPOINT;
 jl_value_t *jl_call_scm_on_ast_and_loc(const char *funcname, jl_value_t *expr,
                                        jl_module_t *inmodule, const char *file, int line);
 
-jl_method_instance_t *jl_method_lookup(jl_value_t **args, size_t nargs, size_t world);
+JL_DLLEXPORT jl_method_instance_t *jl_method_lookup_by_tt(jl_tupletype_t *tt, size_t world, jl_value_t *_mt);
+JL_DLLEXPORT jl_method_instance_t *jl_method_lookup(jl_value_t **args, size_t nargs, size_t world);
 
 jl_value_t *jl_gf_invoke_by_method(jl_method_t *method, jl_value_t *gf, jl_value_t **args, size_t nargs);
 jl_value_t *jl_gf_invoke(jl_value_t *types, jl_value_t *f, jl_value_t **args, size_t nargs);
diff --git a/test/reflection.jl b/test/reflection.jl
index ddeeb0d053ff2..d866749e12d34 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1004,6 +1004,14 @@ end
     @test Base.default_tt(m.f4) == Tuple
 end
 
+@testset "lookup mi" begin
+    @test 1+1 == 2
+    mi1 = @ccall jl_method_lookup_by_tt(Tuple{typeof(+), Int, Int}::Any, Base.get_world_counter()::Csize_t, nothing::Any)::Ref{Core.MethodInstance}
+    @test mi1.def.name == :+
+    mi2 = @ccall jl_method_lookup(Any[+, 1, 1]::Ptr{Any}, 3::Csize_t, Base.get_world_counter()::Csize_t)::Ref{Core.MethodInstance}
+    @test mi1 == mi2
+end
+
 Base.@assume_effects :terminates_locally function issue41694(x::Int)
     res = 1
     0 ≤ x < 20 || error("bad fact")

From 2ab41059eff87625e7a6aaf1e08b75e700bc7b48 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Mon, 18 Dec 2023 08:08:19 -0600
Subject: [PATCH 0455/1315] Fix typo in heuristics of BracketedSort (#52494)

The impact of this typo was a) massively decreased performance that was
b) predicted by heuristic dispatch, resulting in this algorithm not
being dispatched too. I introduced this typo in
187e8c2222878c68b2afc9295ab8dc61773bd7f2 after performing all the benchmarking and before merging.
---
 base/sort.jl    | 2 +-
 test/sorting.jl | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/base/sort.jl b/base/sort.jl
index 2b68f3d979aa8..9272846618a0e 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -1262,7 +1262,7 @@ function _sort!(v::AbstractVector, a::BracketedSort, o::Ordering, kw)
     k = cbrt(ln)
     k2 = round(Int, k^2)
     k2ln = k2/ln
-    offset = .15k2*top_set_bit(k2) # TODO for further optimization: tune this
+    offset = .15k*top_set_bit(k2) # TODO for further optimization: tune this
     lo_signpost_i, hi_signpost_i =
         (floor(Int, (tar - lo) * k2ln + lo + off) for (tar, off) in
             ((minimum(target), -offset), (maximum(target), offset)))
diff --git a/test/sorting.jl b/test/sorting.jl
index d88cc43a8e1f4..878c4b36d4611 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -721,10 +721,9 @@ end
     for alg in safe_algs
         @test sort(1:n, alg=alg, lt = (i,j) -> v[i]<=v[j]) == perm
     end
-    # This could easily break with minor heuristic adjustments
-    # because partialsort is not even guaranteed to be stable:
-    @test partialsort(1:n, 172, lt = (i,j) -> v[i]<=v[j]) == perm[172]
-    @test partialsort(1:n, 315:415, lt = (i,j) -> v[i]<=v[j]) == perm[315:415]
+    # Broken by the introduction of BracketedSort in #52006 which is unstable
+    @test_broken partialsort(1:n, 172, lt = (i,j) -> v[i]<=v[j]) == perm[172]
+    @test_broken partialsort(1:n, 315:415, lt = (i,j) -> v[i]<=v[j]) == perm[315:415]
 
     # lt can be very poorly behaved and sort will still permute its input in some way.
     for alg in safe_algs

From 5977cb0a0c1ef98fa0e4019bf1a41380a717be6f Mon Sep 17 00:00:00 2001
From: Zentrik <Zentrik@users.noreply.github.com>
Date: Mon, 18 Dec 2023 21:37:22 +0000
Subject: [PATCH 0456/1315] Fix GC rooting during rehashing of iddict (#52569)

Should fix #52558. `a` should be rooted before the alloc call. I removed
the comment as it seemed to refer to a write barrier that was removed
long ago.
---
 src/iddict.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/iddict.c b/src/iddict.c
index 8d17f172b91fe..0a0895d048c32 100644
--- a/src/iddict.c
+++ b/src/iddict.c
@@ -15,15 +15,14 @@ JL_DLLEXPORT jl_genericmemory_t *jl_idtable_rehash(jl_genericmemory_t *a, size_t
     size_t sz = a->length;
     size_t i;
     jl_value_t **ol = (jl_value_t **) a->ptr;
-    jl_genericmemory_t *newa = jl_alloc_memory_any(newsz);
+    jl_genericmemory_t *newa = NULL;
     // keep the original memory in the original slot since we need `ol`
     // to be valid in the loop below.
     JL_GC_PUSH2(&newa, &a);
+    newa = jl_alloc_memory_any(newsz);
     for (i = 0; i < sz; i += 2) {
         if (ol[i + 1] != NULL) {
             jl_table_assign_bp(&newa, ol[i], ol[i + 1]);
-            // it is however necessary here because allocation
-            // can (and will) occur in a recursive call inside table_lookup_bp
         }
     }
     JL_GC_POP();

From d336a3e15db141cee054d90c7927c36807dbec81 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 19 Dec 2023 10:07:59 +0530
Subject: [PATCH 0457/1315] Fix negation for an immutable unit triangular
 (#52510)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes
```julia
julia> using FillArrays, LinearAlgebra

julia> U = UnitUpperTriangular(Fill(2,4,4))
4×4 UnitUpperTriangular{Int64, Fill{Int64, 2, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}}:
 1  2  2  2
 ⋅  1  2  2
 ⋅  ⋅  1  2
 ⋅  ⋅  ⋅  1

julia> -U
ERROR: ArgumentError: Cannot setindex! to -1 for an AbstractFill with value -2.
Stacktrace:
 [1] setindex!
   @ ~/.julia/packages/FillArrays/oXkMk/src/FillArrays.jl:52 [inlined]
 [2] -(A::UnitUpperTriangular{Int64, Fill{Int64, 2, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}})
   @ LinearAlgebra ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:442
 [3] top-level scope
   @ REPL[33]:1
```
After this,
```julia
julia> -U
4×4 UpperTriangular{Int64, Matrix{Int64}}:
 -1  -2  -2  -2
  ⋅  -1  -2  -2
  ⋅   ⋅  -1  -2
  ⋅   ⋅   ⋅  -1
```
---
 stdlib/LinearAlgebra/src/triangular.jl  |  8 ++++++--
 stdlib/LinearAlgebra/test/triangular.jl | 13 +++++++++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 6a97f9c194f83..42c44996df1b1 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -446,14 +446,18 @@ diag(A::UnitUpperTriangular) = fill(oneunit(eltype(A)), size(A,1))
 -(A::LowerTriangular) = LowerTriangular(-A.data)
 -(A::UpperTriangular) = UpperTriangular(-A.data)
 function -(A::UnitLowerTriangular)
-    Anew = -A.data
+    Adata = A.data
+    Anew = similar(Adata) # must be mutable, even if Adata is not
+    @. Anew = -Adata
     for i = 1:size(A, 1)
         Anew[i, i] = -A[i, i]
     end
     LowerTriangular(Anew)
 end
 function -(A::UnitUpperTriangular)
-    Anew = -A.data
+    Adata = A.data
+    Anew = similar(Adata) # must be mutable, even if Adata is not
+    @. Anew = -Adata
     for i = 1:size(A, 1)
         Anew[i, i] = -A[i, i]
     end
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index c99ec5552ffe3..e2111db95f1ef 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -8,6 +8,11 @@ using LinearAlgebra: BlasFloat, errorbounds, full!, transpose!,
     UnitUpperTriangular, UnitLowerTriangular,
     mul!, rdiv!, rmul!, lmul!
 
+const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
+
+isdefined(Main, :FillArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "FillArrays.jl"))
+using .Main.FillArrays
+
 debug && println("Triangular matrices")
 
 n = 9
@@ -866,6 +871,14 @@ end
     end
 end
 
+@testset "arithmetic with an immutable parent" begin
+    F = FillArrays.Fill(2, (4,4))
+    for UT in (UnitUpperTriangular, UnitLowerTriangular)
+        U = UT(F)
+        @test -U == -Array(U)
+    end
+end
+
 @testset "error paths" begin
     A = zeros(1,1); B = zeros(2,2)
     @testset "inplace mul scaling with incompatible sizes" begin

From ec4745b147f1292923190cbe3b4a0d86dca75e16 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 19 Dec 2023 12:21:11 +0100
Subject: [PATCH 0458/1315] Fix interaction between try/catch elision and scope
 handling (#52527)

Currently, our try/catch elision code does not look at whether the
EnterNode has a scope, and just deletes it, if it can prove the contents
nothrow. This is obviously problematic, so this fixes that case up to
instead set the catch dest to 0 in that case (along with support in the
rest of the system to ignore such catch dests for the purpose of
renaming). The idea is that a later pass could use the notasklocalstate
effect to delete this after appropriate verification, but this is not
implemented. Additionally, this currently bails on folding current_scope
inside such try/catch regions - for such regions we cannot use the CFG
to determine the extent of the try/catch region. A proper treatment of
this would probably be to just treat this as a single value mutable -
but again this is not implemented. The primary purpose of this patch is
to ensure correctness.
---
 base/compiler/inferencestate.jl | 10 +++--
 base/compiler/optimize.jl       | 24 +++++++++---
 base/compiler/ssair/inlining.jl |  4 +-
 base/compiler/ssair/ir.jl       | 26 ++++++++-----
 base/compiler/ssair/legacy.jl   |  4 +-
 base/compiler/ssair/passes.jl   | 17 ++++++++-
 base/compiler/ssair/show.jl     |  2 +-
 base/compiler/ssair/slot2ssa.jl |  4 +-
 src/codegen.cpp                 | 68 +++++++++++++++++++--------------
 src/interpreter.c               | 34 +++++++++--------
 test/compiler/irpasses.jl       | 22 +++++++++++
 11 files changed, 144 insertions(+), 71 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index f8650c2e6cfde..1961099e1d02f 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -370,8 +370,10 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
             handler_id = length(handlers)
             handler_at[pc + 1] = (handler_id, 0)
             push!(ip, pc + 1)
-            handler_at[l] = (0, handler_id)
-            push!(ip, l)
+            if l != 0
+                handler_at[l] = (0, handler_id)
+                push!(ip, l)
+            end
         end
     end
 
@@ -402,7 +404,9 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
                 l = stmt.catch_dest
                 # We assigned a handler number above. Here we just merge that
                 # with out current handler information.
-                handler_at[l] = (cur_stacks[1], handler_at[l][2])
+                if l != 0
+                    handler_at[l] = (cur_stacks[1], handler_at[l][2])
+                end
                 cur_stacks = (handler_at[pc´][1], cur_stacks[2])
             elseif isa(stmt, Expr)
                 head = stmt.head
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index dbbb78680595a..57fb1082add5e 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -978,7 +978,16 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                 catchdest = expr.catch_dest
                 if catchdest in sv.unreachable
                     cfg_delete_edge!(sv.cfg, block_for_inst(sv.cfg, i), block_for_inst(sv.cfg, catchdest))
-                    code[i] = nothing
+                    if isdefined(expr, :scope)
+                        # We've proven that nothing inside the enter region throws,
+                        # but we don't yet know whether something might read the scope,
+                        # so we need to retain this enter for the time being. However,
+                        # we use the special marker `0` to indicate that setting up
+                        # the try/catch frame is not required.
+                        code[i] = EnterNode(expr, 0)
+                    else
+                        code[i] = nothing
+                    end
                 end
             end
         end
@@ -1364,11 +1373,14 @@ function renumber_ir_elements!(body::Vector{Any}, ssachangemap::Vector{Int}, lab
             end
         elseif isa(el, EnterNode)
             tgt = el.catch_dest
-            was_deleted = labelchangemap[tgt] == typemin(Int)
-            if was_deleted
-                body[i] = nothing
-            else
-                body[i] = EnterNode(el, tgt + labelchangemap[tgt])
+            if tgt != 0
+                was_deleted = labelchangemap[tgt] == typemin(Int)
+                if was_deleted
+                    @assert !isdefined(el, :scope)
+                    body[i] = nothing
+                else
+                    body[i] = EnterNode(el, tgt + labelchangemap[tgt])
+                end
             end
         elseif isa(el, Expr)
             if el.head === :(=) && el.args[2] isa Expr
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 3792027f82aa4..650af8248883c 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -460,7 +460,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
             elseif isa(stmt′, GotoNode)
                 stmt′ = GotoNode(stmt′.label + bb_offset)
             elseif isa(stmt′, EnterNode)
-                stmt′ = EnterNode(stmt′, stmt′.catch_dest + bb_offset)
+                stmt′ = EnterNode(stmt′, stmt′.catch_dest == 0 ? 0 : stmt′.catch_dest + bb_offset)
             elseif isa(stmt′, GotoIfNot)
                 stmt′ = GotoIfNot(stmt′.cond, stmt′.dest + bb_offset)
             elseif isa(stmt′, PhiNode)
@@ -711,7 +711,7 @@ function batch_inline!(ir::IRCode, todo::Vector{Pair{Int,Any}}, propagate_inboun
             elseif isa(stmt, GotoNode)
                 compact[idx] = GotoNode(state.bb_rename[stmt.label])
             elseif isa(stmt, EnterNode)
-                compact[idx] = EnterNode(stmt, state.bb_rename[stmt.catch_dest])
+                compact[idx] = EnterNode(stmt, stmt.catch_dest == 0 ? 0 : state.bb_rename[stmt.catch_dest])
             elseif isa(stmt, GotoIfNot)
                 compact[idx] = GotoIfNot(stmt.cond, state.bb_rename[stmt.dest])
             elseif isa(stmt, PhiNode)
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index e217141a9a535..289f643a84f3a 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -65,7 +65,9 @@ block_for_inst(cfg::CFG, inst::Int) = block_for_inst(cfg.index, inst)
             push!(jump_dests, idx)
             push!(jump_dests, idx+1)
             # The catch block is a jump dest
-            push!(jump_dests, stmt.catch_dest)
+            if stmt.catch_dest != 0
+                push!(jump_dests, stmt.catch_dest)
+            end
         elseif isa(stmt, Expr)
             if stmt.head === :leave
                 # :leave terminates a BB
@@ -129,10 +131,12 @@ function compute_basic_blocks(stmts::Vector{Any})
             # :enter gets a virtual edge to the exception handler and
             # the exception handler gets a virtual edge from outside
             # the function.
-            block′ = block_for_inst(basic_block_index, terminator.catch_dest)
-            push!(blocks[block′].preds, num)
-            push!(blocks[block′].preds, 0)
-            push!(b.succs, block′)
+            if terminator.catch_dest != 0
+                block′ = block_for_inst(basic_block_index, terminator.catch_dest)
+                push!(blocks[block′].preds, num)
+                push!(blocks[block′].preds, 0)
+                push!(b.succs, block′)
+            end
         end
         # statement fall-through
         if num + 1 <= length(blocks)
@@ -1415,10 +1419,14 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
         end
     elseif cfg_transforms_enabled && isa(stmt, EnterNode)
         stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, new_new_used_ssas, late_fixup, result_idx, do_rename_ssa, mark_refined!)::EnterNode
-        label = bb_rename_succ[stmt.catch_dest]
-        @assert label > 0
-        ssa_rename[idx] = SSAValue(result_idx)
-        result[result_idx][:stmt] = EnterNode(stmt, label)
+        if stmt.catch_dest != 0
+            label = bb_rename_succ[stmt.catch_dest]
+            @assert label > 0
+            ssa_rename[idx] = SSAValue(result_idx)
+            result[result_idx][:stmt] = EnterNode(stmt, label)
+        else
+            result[result_idx][:stmt] = stmt
+        end
         result_idx += 1
     elseif isa(stmt, Expr)
         stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, new_new_used_ssas, late_fixup, result_idx, do_rename_ssa, mark_refined!)::Expr
diff --git a/base/compiler/ssair/legacy.jl b/base/compiler/ssair/legacy.jl
index e8ed197ba5ce6..3e9a4e2a746dc 100644
--- a/base/compiler/ssair/legacy.jl
+++ b/base/compiler/ssair/legacy.jl
@@ -26,7 +26,7 @@ function inflate_ir!(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{A
         elseif isa(stmt, PhiNode)
             code[i] = PhiNode(Int32[block_for_inst(cfg, Int(edge)) for edge in stmt.edges], stmt.values)
         elseif isa(stmt, EnterNode)
-            code[i] = EnterNode(stmt, block_for_inst(cfg, stmt.catch_dest))
+            code[i] = EnterNode(stmt, stmt.catch_dest == 0 ? 0 : block_for_inst(cfg, stmt.catch_dest))
         end
     end
     nstmts = length(code)
@@ -93,7 +93,7 @@ function replace_code_newstyle!(ci::CodeInfo, ir::IRCode)
         elseif isa(stmt, PhiNode)
             code[i] = PhiNode(Int32[edge == 0 ? 0 : last(ir.cfg.blocks[edge].stmts) for edge in stmt.edges], stmt.values)
         elseif isa(stmt, EnterNode)
-            code[i] = EnterNode(stmt, first(ir.cfg.blocks[stmt.catch_dest].stmts))
+            code[i] = EnterNode(stmt, stmt.catch_dest == 0 ? 0 : first(ir.cfg.blocks[stmt.catch_dest].stmts))
         end
     end
 end
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 727edd2825933..86d6aeae78f6c 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1077,6 +1077,7 @@ function fold_current_scope!(compact::IncrementalCompact, idx::Int, stmt::Expr,
     dombb = block_for_inst(compact, SSAValue(idx))
 
     local bbterminator
+    prevdombb = dombb
     while true
         dombb = domtree.idoms_bb[dombb]
 
@@ -1084,8 +1085,20 @@ function fold_current_scope!(compact::IncrementalCompact, idx::Int, stmt::Expr,
         dombb == 0 && return nothing
 
         bbterminator = compact[SSAValue(last(compact.cfg_transform.result_bbs[dombb].stmts))][:stmt]
-        isa(bbterminator, EnterNode) || continue
-        isdefined(bbterminator, :scope) || continue
+        if !isa(bbterminator, EnterNode) || !isdefined(bbterminator, :scope)
+            prevdombb = dombb
+            continue
+        end
+        if bbterminator.catch_dest == 0
+            # TODO: dominance alone is not enough here, we need to actually find the :leaves
+            return nothing
+        end
+        # Check that we are inside the :enter region, i.e. are dominated by the first block in the
+        # enter region - otherwise we've already left this :enter and should keep going
+        if prevdombb != dombb + 1
+            prevdombb = dombb
+            continue
+        end
         compact[idx] = bbterminator.scope
         return nothing
     end
diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl
index 82af7f9964045..3936a82a6560e 100644
--- a/base/compiler/ssair/show.jl
+++ b/base/compiler/ssair/show.jl
@@ -570,7 +570,7 @@ end
 function statement_indices_to_labels(stmt, cfg::CFG)
     # convert statement index to labels, as expected by print_stmt
     if stmt isa EnterNode
-        stmt = EnterNode(stmt, block_for_inst(cfg, stmt.catch_dest))
+        stmt = EnterNode(stmt, stmt.catch_dest == 0 ? 0 : block_for_inst(cfg, stmt.catch_dest))
     elseif isa(stmt, GotoIfNot)
         stmt = GotoIfNot(stmt.cond, block_for_inst(cfg, stmt.dest))
     elseif stmt isa GotoNode
diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl
index 52e809f1c445b..c2a769acbe9e9 100644
--- a/base/compiler/ssair/slot2ssa.jl
+++ b/base/compiler/ssair/slot2ssa.jl
@@ -469,7 +469,7 @@ function domsort_ssa!(ir::IRCode, domtree::DomTree)
             result[inst_range[end]][:stmt] = GotoIfNot(terminator.cond, bb_rename[terminator.dest])
         elseif !isa(terminator, ReturnNode)
             if isa(terminator, EnterNode)
-                result[inst_range[end]][:stmt] = EnterNode(terminator, bb_rename[terminator.catch_dest])
+                result[inst_range[end]][:stmt] = EnterNode(terminator, terminator.catch_dest == 0 ? 0 : bb_rename[terminator.catch_dest])
             end
             if bb_rename[bb + 1] != new_bb + 1
                 # Add an explicit goto node
@@ -878,7 +878,7 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, sv::OptimizationState,
                 new_code[idx] = GotoIfNot(stmt.cond, new_dest)
             end
         elseif isa(stmt, EnterNode)
-            except_bb = block_for_inst(cfg, stmt.catch_dest)
+            except_bb = stmt.catch_dest == 0 ? 0 : block_for_inst(cfg, stmt.catch_dest)
             new_code[idx] = EnterNode(stmt, except_bb)
             ssavalmap[idx] = SSAValue(idx) # Slot to store token for pop_exception
         elseif isexpr(stmt, :leave) || isexpr(stmt, :(=)) || isa(stmt, ReturnNode) ||
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 2cbe7733ab708..ceef6486f8c31 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -2946,6 +2946,8 @@ static void mark_volatile_vars(jl_array_t *stmts, SmallVectorImpl<jl_varinfo_t>
         jl_value_t *st = jl_array_ptr_ref(stmts, i);
         if (jl_is_enternode(st)) {
             int last = jl_enternode_catch_dest(st);
+            if (last == 0)
+                continue;
             std::set<int> as = assigned_in_try(stmts, i + 1, last - 1);
             for (int j = 0; j < (int)slength; j++) {
                 if (j < i || j > last) {
@@ -5615,7 +5617,11 @@ static void emit_stmtpos(jl_codectx_t &ctx, jl_value_t *expr, int ssaval_result)
                 continue;
             if (ctx.scope_restore.count(enter_idx))
                 std::tie(scope_to_restore, scope_ptr) = ctx.scope_restore[enter_idx];
-            hand_n_leave += 1;
+            if (jl_enternode_catch_dest(enter_stmt)) {
+                // We're not actually setting up the exception frames for these, so
+                // we don't need to exit them.
+                hand_n_leave += 1;
+            }
         }
         ctx.builder.CreateCall(prepare_call(jlleave_func),
                            ConstantInt::get(getInt32Ty(ctx.builder.getContext()), hand_n_leave));
@@ -8551,7 +8557,9 @@ static jl_llvm_functions_t
                 branch_targets.insert(i + 1);
                 if (i + 2 <= stmtslen)
                     branch_targets.insert(i + 2);
-                branch_targets.insert(jl_enternode_catch_dest(stmt));
+                size_t catch_dest = jl_enternode_catch_dest(stmt);
+                if (catch_dest)
+                    branch_targets.insert(catch_dest);
             } else if (jl_is_gotonode(stmt)) {
                 int dest = jl_gotonode_label(stmt);
                 branch_targets.insert(dest);
@@ -8766,35 +8774,37 @@ static jl_llvm_functions_t
                 ctx.scope_restore[cursor] = std::make_pair(old_scope, scope_ptr);
             }
             int lname = jl_enternode_catch_dest(stmt);
-            // Save exception stack depth at enter for use in pop_exception
-            Value *excstack_state =
-                ctx.builder.CreateCall(prepare_call(jl_excstack_state_func));
-            assert(!ctx.ssavalue_assigned[cursor]);
-            ctx.SAvalues[cursor] = jl_cgval_t(excstack_state, (jl_value_t*)jl_ulong_type, NULL);
-            ctx.ssavalue_assigned[cursor] = true;
-            // Actually enter the exception frame
-            CallInst *sj = ctx.builder.CreateCall(prepare_call(except_enter_func));
-            // We need to mark this on the call site as well. See issue #6757
-            sj->setCanReturnTwice();
-            Value *isz = ctx.builder.CreateICmpEQ(sj, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 0));
-            BasicBlock *tryblk = BasicBlock::Create(ctx.builder.getContext(), "try", f);
-            BasicBlock *catchpop = BasicBlock::Create(ctx.builder.getContext(), "catch_pop", f);
-            BasicBlock *handlr = NULL;
-            handlr = BB[lname];
-            workstack.push_back(lname - 1);
-            come_from_bb[cursor + 1] = ctx.builder.GetInsertBlock();
-            ctx.builder.CreateCondBr(isz, tryblk, catchpop);
-            ctx.builder.SetInsertPoint(catchpop);
-            {
-                ctx.builder.CreateCall(prepare_call(jlleave_func),
-                                ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 1));
-                if (old_scope) {
-                    scope_ai.decorateInst(
-                        ctx.builder.CreateAlignedStore(old_scope, scope_ptr, ctx.types().alignof_ptr));
+            if (lname) {
+                // Save exception stack depth at enter for use in pop_exception
+                Value *excstack_state =
+                    ctx.builder.CreateCall(prepare_call(jl_excstack_state_func));
+                assert(!ctx.ssavalue_assigned[cursor]);
+                ctx.SAvalues[cursor] = jl_cgval_t(excstack_state, (jl_value_t*)jl_ulong_type, NULL);
+                ctx.ssavalue_assigned[cursor] = true;
+                // Actually enter the exception frame
+                CallInst *sj = ctx.builder.CreateCall(prepare_call(except_enter_func));
+                // We need to mark this on the call site as well. See issue #6757
+                sj->setCanReturnTwice();
+                Value *isz = ctx.builder.CreateICmpEQ(sj, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 0));
+                BasicBlock *tryblk = BasicBlock::Create(ctx.builder.getContext(), "try", f);
+                BasicBlock *catchpop = BasicBlock::Create(ctx.builder.getContext(), "catch_pop", f);
+                BasicBlock *handlr = NULL;
+                handlr = BB[lname];
+                workstack.push_back(lname - 1);
+                come_from_bb[cursor + 1] = ctx.builder.GetInsertBlock();
+                ctx.builder.CreateCondBr(isz, tryblk, catchpop);
+                ctx.builder.SetInsertPoint(catchpop);
+                {
+                    ctx.builder.CreateCall(prepare_call(jlleave_func),
+                                    ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 1));
+                    if (old_scope) {
+                        scope_ai.decorateInst(
+                            ctx.builder.CreateAlignedStore(old_scope, scope_ptr, ctx.types().alignof_ptr));
+                    }
+                    ctx.builder.CreateBr(handlr);
                 }
-                ctx.builder.CreateBr(handlr);
+                ctx.builder.SetInsertPoint(tryblk);
             }
-            ctx.builder.SetInsertPoint(tryblk);
         }
         else {
             emit_stmtpos(ctx, stmt, cursor);
diff --git a/src/interpreter.c b/src/interpreter.c
index 81096413c8e73..5102d1417c939 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -501,23 +501,26 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
             // can possibly encounter. Then, we remember which slot they store to (we abuse the
             // SSA value result array for this purpose). TODO: We could do this only the first
             // time we encounter a given enter.
-            size_t catch_ip = jl_enternode_catch_dest(stmt) - 1;
-            while (catch_ip < ns) {
-                jl_value_t *phicnode = jl_array_ptr_ref(stmts, catch_ip);
-                if (!jl_is_phicnode(phicnode))
-                    break;
-                jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(phicnode, 0);
-                for (size_t i = 0; i < jl_array_nrows(values); ++i) {
-                    jl_value_t *val = jl_array_ptr_ref(values, i);
-                    assert(jl_is_ssavalue(val));
-                    size_t upsilon = ((jl_ssavalue_t*)val)->id - 1;
-                    assert(jl_is_upsilonnode(jl_array_ptr_ref(stmts, upsilon)));
-                    s->locals[jl_source_nslots(s->src) + upsilon] = jl_box_ssavalue(catch_ip + 1);
+            size_t catch_ip = jl_enternode_catch_dest(stmt);
+            if (catch_ip) {
+                catch_ip -= 1;
+                while (catch_ip < ns) {
+                    jl_value_t *phicnode = jl_array_ptr_ref(stmts, catch_ip);
+                    if (!jl_is_phicnode(phicnode))
+                        break;
+                    jl_array_t *values = (jl_array_t*)jl_fieldref_noalloc(phicnode, 0);
+                    for (size_t i = 0; i < jl_array_nrows(values); ++i) {
+                        jl_value_t *val = jl_array_ptr_ref(values, i);
+                        assert(jl_is_ssavalue(val));
+                        size_t upsilon = ((jl_ssavalue_t*)val)->id - 1;
+                        assert(jl_is_upsilonnode(jl_array_ptr_ref(stmts, upsilon)));
+                        s->locals[jl_source_nslots(s->src) + upsilon] = jl_box_ssavalue(catch_ip + 1);
+                    }
+                    s->locals[jl_source_nslots(s->src) + catch_ip] = NULL;
+                    catch_ip += 1;
                 }
-                s->locals[jl_source_nslots(s->src) + catch_ip] = NULL;
-                catch_ip += 1;
+                // store current top of exception stack for restore in pop_exception.
             }
-            // store current top of exception stack for restore in pop_exception.
             s->locals[jl_source_nslots(s->src) + ip] = jl_box_ulong(jl_excstack_state());
             if (jl_enternode_scope(stmt)) {
                 jl_value_t *old_scope = ct->scope;
@@ -545,6 +548,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
             }
             else { // a real exception
                 ip = catch_ip;
+                assert(jl_enternode_catch_dest(stmt) != 0);
                 continue;
             }
         }
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 8ef19589e2f4f..b4f151614160c 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1663,3 +1663,25 @@ let code = Any[
     ir = Core.Compiler.compact!(ir)
     Core.Compiler.verify_ir(ir)
 end
+
+# Test correctness of current_scope folding
+@eval function scope_folding()
+    $(Expr(:tryfinally,
+        Expr(:block,
+            Expr(:tryfinally, :(), :(), 2),
+            :(return Core.current_scope())),
+    :(), 1))
+end
+
+@eval function scope_folding_opt()
+    $(Expr(:tryfinally,
+        Expr(:block,
+            Expr(:tryfinally, :(), :(), :(Base.inferencebarrier(2))),
+            :(return Core.current_scope())),
+    :(), :(Base.inferencebarrier(1))))
+end
+
+@test scope_folding() == 1
+@test scope_folding_opt() == 1
+@test_broken fully_eliminated(scope_folding)
+@test_broken fully_eliminated(scope_folding_opt)

From 4f25e875be424e9dceb880ac9460301ed286a35e Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 19 Dec 2023 12:24:27 +0100
Subject: [PATCH 0459/1315] sroa: Better walk for chained KeyValue (#52542)

This redoes #52369, to put the walk through tothe chained KeyValue into
a more logical place (the definition walking). This way, we
automatically inherit correct handling of PhiNodes and ifelse.
---
 base/compiler/ssair/passes.jl | 87 ++++++++++++++++++++++-------------
 test/compiler/irpasses.jl     | 12 +++++
 2 files changed, 68 insertions(+), 31 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 86d6aeae78f6c..754d0a6cefd8b 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -273,7 +273,9 @@ function walk_to_defs(compact::IncrementalCompact, @nospecialize(defssa), @nospe
         def = compact[defssa][:stmt]
         values = predecessors(def, compact)
         if values !== nothing
-            push!(visited_philikes, defssa)
+            if isa(def, PhiNode) || length(values) > 1
+                push!(visited_philikes, defssa)
+            end
             possible_predecessors = Int[]
 
             for n in 1:length(values)
@@ -857,38 +859,32 @@ function lift_leaves_keyvalue(compact::IncrementalCompact, @nospecialize(key),
     for i = 1:length(leaves)
         leaf = leaves[i]
         cache_key = leaf
-        while true
-            if isa(leaf, AnySSAValue)
-                (def, leaf) = walk_to_def(compact, leaf)
-                if is_known_invoke_or_call(def, Core.OptimizedGenerics.KeyValue.set, compact)
-                    @assert isexpr(def, :invoke)
-                    if length(def.args) in (5, 6)
-                        collection = def.args[end-2]
-                        set_key = def.args[end-1]
-                        set_val_idx = length(def.args)
-                    elseif length(def.args) == 4
-                        collection = def.args[end-1]
-                        # Key is deleted
-                        # TODO: Model this
-                        return nothing
-                    elseif length(def.args) == 3
-                        collection = def.args[end]
-                        # The whole collection is deleted
-                        # TODO: Model this
-                        return nothing
-                    else
-                        return nothing
-                    end
-                    if set_key === key || (egal_tfunc(𝕃ₒ, argextype(key, compact), argextype(set_key, compact)) == Const(true))
-                        lift_arg!(compact, leaf, cache_key, def, set_val_idx, lifted_leaves)
-                        break
-                    end
-                    leaf = collection
-                    continue
+        if isa(leaf, AnySSAValue)
+            (def, leaf) = walk_to_def(compact, leaf)
+            if is_known_invoke_or_call(def, Core.OptimizedGenerics.KeyValue.set, compact)
+                @assert isexpr(def, :invoke)
+                if length(def.args) in (5, 6)
+                    set_key = def.args[end-1]
+                    set_val_idx = length(def.args)
+                elseif length(def.args) == 4
+                    # Key is deleted
+                    # TODO: Model this
+                    return nothing
+                elseif length(def.args) == 3
+                    # The whole collection is deleted
+                    # TODO: Model this
+                    return nothing
+                else
+                    return nothing
                 end
+                if set_key === key || (egal_tfunc(𝕃ₒ, argextype(key, compact), argextype(set_key, compact)) == Const(true))
+                    lift_arg!(compact, leaf, cache_key, def, set_val_idx, lifted_leaves)
+                    break
+                end
+                continue
             end
-            return nothing
         end
+        return nothing
     end
     return lifted_leaves
 end
@@ -897,7 +893,36 @@ function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 
     collection = stmt.args[end-1]
     key = stmt.args[end]
 
-    leaves, visited_philikes = collect_leaves(compact, collection, Any, 𝕃ₒ, phi_or_ifelse_predecessors)
+    function keyvalue_predecessors(@nospecialize(def), compact::IncrementalCompact)
+        if is_known_invoke_or_call(def, Core.OptimizedGenerics.KeyValue.set, compact)
+            @assert isexpr(def, :invoke)
+            if length(def.args) in (5, 6)
+                collection = def.args[end-2]
+                set_key = def.args[end-1]
+                set_val_idx = length(def.args)
+            elseif length(def.args) == 4
+                collection = def.args[end-1]
+                # Key is deleted
+                # TODO: Model this
+                return nothing
+            elseif length(def.args) == 3
+                collection = def.args[end]
+                # The whole collection is deleted
+                # TODO: Model this
+                return nothing
+            else
+                return nothing
+            end
+            if set_key === key || (egal_tfunc(𝕃ₒ, argextype(key, compact), argextype(set_key, compact)) == Const(true))
+                # This is an actual def
+                return nothing
+            end
+            return Any[collection]
+        end
+        return phi_or_ifelse_predecessors(def, compact)
+    end
+
+    leaves, visited_philikes = collect_leaves(compact, collection, Any, 𝕃ₒ, keyvalue_predecessors)
     isempty(leaves) && return
 
     lifted_leaves = lift_leaves_keyvalue(compact, key, leaves, 𝕃ₒ)
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index b4f151614160c..97e80fca6cba1 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1563,6 +1563,18 @@ end
 @test_broken fully_eliminated(persistent_dict_elim_multiple)
 @test code_typed(persistent_dict_elim_multiple)[1][1].code[end] == Core.ReturnNode(1)
 
+function persistent_dict_elim_multiple_phi(c::Bool)
+    if c
+        a = Base.PersistentDict(:a => 1)
+    else
+        a = Base.PersistentDict(:a => 1)
+    end
+    b = Base.PersistentDict(a, :b => 2)
+    return b[:a]
+end
+@test_broken fully_eliminated(persistent_dict_elim_multiple_phi)
+@test code_typed(persistent_dict_elim_multiple_phi)[1][1].code[end] == Core.ReturnNode(1)
+
 # Test CFG simplify with try/catch blocks
 let code = Any[
         # Block 1

From 91d87c6d498d45ebb8bddc1df4d00c2437abccbc Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Tue, 19 Dec 2023 12:49:05 +0100
Subject: [PATCH 0460/1315] Add --pkgimages=existing. (#52573)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Equivalent of https://github.com/JuliaLang/julia/pull/50586; implements
https://github.com/JuliaLang/julia/issues/51474.

With `--pkgimages=existing`, it's possible to disable the (often slow)
generation of package images, without losing the ability to use existing
ones. That's important now that we're moving more and more packages
outside of the system image, e.g., running with `--pkgimages=no`
otherwise takes close to 30s here before the Pkg REPL is usable.

The main motivation for this is PkgEval, where generating package images
is not very useful, yet disabling generation of them makes each job
(which requires Pkg to drive the test process) take a significantly
longer time.

For example, `--pkgimages=yes` vs `no`:

```julia
❯ JULIA_DEBUG=loading ./julia --project=Example.jl --pkgimages=yes
# no precompilation of REPL.jl
┌ Debug: Loading object cache file /Users/tim/Julia/src/julia/build/dev/usr/share/julia/compiled/v1.11/REPL/u0gqU_XmENM.dylib for REPL [3fa0cd96-eef1-5676-8a61-b3b8758bbffb]
└ @ Base loading.jl:1116

julia> using Example
# short time precompiling + pkgimg generation for Example.jl
┌ Debug: Loading object cache file /Users/tim/.julia/compiled/v1.11/Example/lLvWP_tJaso.dylib for Example [7876af07-990d-54b4-ab0e-23690620f79a]
└ @ Base loading.jl:1116
```

```julia
❯ JULIA_DEBUG=loading ./julia --project=Example.jl --pkgimages=no
┌ Debug: Rejecting cache file /Users/tim/Julia/src/julia/build/dev/usr/share/julia/compiled/v1.11/REPL/u0gqU_XmENM.ji for REPL [3fa0cd96-eef1-5676-8a61-b3b8758bbffb] since the flags are mismatched
│   current session: use_pkgimages = false, debug_level = 1, check_bounds = 0, inline = true, opt_level = 2
│   cache file:      use_pkgimages = true, debug_level = 1, check_bounds = 0, inline = true, opt_level = 2
└ @ Base loading.jl:3289
# long time precompiling REPL.jl
┌ Debug: Loading cache file /Users/tim/.julia/compiled/v1.11/REPL/u0gqU_CWvWI.ji for REPL [3fa0cd96-eef1-5676-8a61-b3b8758bbffb]
└ @ Base loading.jl:1119

julia> using Example
# short time precompiling Example
┌ Debug: Loading cache file /Users/tim/.julia/compiled/v1.11/Example/lLvWP_CWvWI.ji for Example [7876af07-990d-54b4-ab0e-23690620f79a]
└ @ Base loading.jl:1119
```

With the new `--pkgimages=existing`:

```julia
❯ JULIA_DEBUG=loading ./julia --project=Example.jl --pkgimages=existing
# no precompilation of REPL.jl
┌ Debug: Loading object cache file /Users/tim/Julia/src/julia/build/dev/usr/share/julia/compiled/v1.11/REPL/u0gqU_XmENM.dylib for REPL [3fa0cd96-eef1-5676-8a61-b3b8758bbffb]
└ @ Base loading.jl:1116

julia> using Example
# short time precompiling Example
┌ Debug: Loading cache file /Users/tim/.julia/compiled/v1.11/Example/lLvWP_CWvWI.ji for Example [7876af07-990d-54b4-ab0e-23690620f79a]
└ @ Base loading.jl:1119
```
---
 NEWS.md                   |  3 ++
 base/loading.jl           | 36 ++++++++++++++++--
 base/util.jl              |  5 +--
 doc/man/julia.1           |  8 +++-
 doc/src/manual/modules.md | 24 +++++++-----
 src/jloptions.c           |  4 +-
 src/julia.h               |  1 +
 src/staticdata_utils.c    |  5 +++
 test/loading.jl           | 79 +++++++++++++++++++++++++++++++++++++++
 9 files changed, 145 insertions(+), 20 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 28be243e568a4..0ec643882a4af 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -50,6 +50,9 @@ Command-line option changes
 This is intended to unify script and compilation workflows, where code loading may happen
 in the compiler and execution of `Main.main` may happen in the resulting executable. For interactive use, there is no semantic
 difference between defining a `main` function and executing the code directly at the end of the script ([50974]).
+* The `--compiled-modules` and `--pkgimages` flags can now be set to `existing`, which will
+  cause Julia to consider loading existing cache files, but not to create new ones ([#50586]
+  and [#52573]).
 
 Multi-threading changes
 -----------------------
diff --git a/base/loading.jl b/base/loading.jl
index fbd50d4d7f95b..4e7ca940d15a1 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1043,9 +1043,35 @@ function find_all_in_cache_path(pkg::PkgId)
         end
     end
     if length(paths) > 1
-        # allocating the sort vector is less expensive than using sort!(.. by=mtime), which would
-        # call the relatively slow mtime multiple times per path
-        p = sortperm(mtime.(paths), rev = true)
+        function sort_by(path)
+            # when using pkgimages, consider those cache files first
+            pkgimage = if JLOptions().use_pkgimages != 0
+                io = open(path, "r")
+                try
+                    if iszero(isvalid_cache_header(io))
+                        false
+                    else
+                        _, _, _, _, _, _, _, flags = parse_cache_header(io, path)
+                        CacheFlags(flags).use_pkgimages
+                    end
+                finally
+                    close(io)
+                end
+            else
+                false
+            end
+            (; pkgimage, mtime=mtime(path))
+        end
+        function sort_lt(a, b)
+            if a.pkgimage != b.pkgimage
+                return a.pkgimage < b.pkgimage
+            end
+            return a.mtime < b.mtime
+        end
+
+        # allocating the sort vector is less expensive than using sort!(.. by=sort_by),
+        # which would call the relatively slow mtime multiple times per path
+        p = sortperm(sort_by.(paths), lt=sort_lt, rev=true)
         return paths[p]
     else
         return paths
@@ -2431,10 +2457,12 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     end
 
     if output_o !== nothing
+        @debug "Generating object cache file for $pkg"
         cpu_target = get(ENV, "JULIA_CPU_TARGET", nothing)
         opt_level = Base.JLOptions().opt_level
         opts = `-O$(opt_level) --output-o $(output_o) --output-ji $(output) --output-incremental=yes`
     else
+        @debug "Generating cache file for $pkg"
         cpu_target = nothing
         opts = `-O0 --output-ji $(output) --output-incremental=yes`
     end
@@ -2531,7 +2559,7 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
     # create a temporary file in `cachepath` directory, write the cache in it,
     # write the checksum, _and then_ atomically move the file to `cachefile`.
     mkpath(cachepath)
-    cache_objects = JLOptions().use_pkgimages != 0
+    cache_objects = JLOptions().use_pkgimages == 1
     tmppath, tmpio = mktemp(cachepath)
 
     if cache_objects
diff --git a/base/util.jl b/base/util.jl
index 929b6f99a227a..38e27520a39cc 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -207,6 +207,8 @@ function julia_cmd(julia=joinpath(Sys.BINDIR, julia_exename()); cpu_target::Unio
     opts.can_inline == 0 && push!(addflags, "--inline=no")
     opts.use_compiled_modules == 0 && push!(addflags, "--compiled-modules=no")
     opts.use_compiled_modules == 2 && push!(addflags, "--compiled-modules=existing")
+    opts.use_pkgimages == 0 && push!(addflags, "--pkgimages=no")
+    opts.use_pkgimages == 2 && push!(addflags, "--pkgimages=existing")
     opts.opt_level == 2 || push!(addflags, "-O$(opts.opt_level)")
     opts.opt_level_min == 0 || push!(addflags, "--min-optlevel=$(opts.opt_level_min)")
     push!(addflags, "-g$(opts.debug_level)")
@@ -242,9 +244,6 @@ function julia_cmd(julia=joinpath(Sys.BINDIR, julia_exename()); cpu_target::Unio
     if opts.use_sysimage_native_code == 0
         push!(addflags, "--sysimage-native-code=no")
     end
-    if opts.use_pkgimages == 0
-        push!(addflags, "--pkgimages=no")
-    end
     return `$julia -C $cpu_target -J$image_file $addflags`
 end
 
diff --git a/doc/man/julia.1 b/doc/man/julia.1
index 95cf73afd0556..b0af07539cb41 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -93,8 +93,12 @@ Enable or disable Julia's default signal handlers
 Use native code from system image if available
 
 .TP
---compiled-modules={yes*|no}
-Enable or disable incremental precompilation of modules
+--compiled-modules={yes*|no|existing}
+Enable or disable incremental precompilation of modules.
+
+.TP
+--pkgimages={yes*|no|existing}
+Enable or disable usage of native code caching in the form of pkgimages
 
 .TP
 -e, --eval <expr>
diff --git a/doc/src/manual/modules.md b/doc/src/manual/modules.md
index 10da581c2a8b3..8c366616bac49 100644
--- a/doc/src/manual/modules.md
+++ b/doc/src/manual/modules.md
@@ -599,15 +599,19 @@ A few other points to be aware of:
    an error to do this, but you simply need to be prepared that the system will try to copy some
    of these and to create a single unique instance of others.
 
-It is sometimes helpful during module development to turn off incremental precompilation. The
-command line flag `--compiled-modules={yes|no}` enables you to toggle module precompilation on and
-off. When Julia is started with `--compiled-modules=no` the serialized modules in the compile cache
-are ignored when loading modules and module dependencies.
-More fine-grained control is available with `--pkgimages=no`, which suppresses only
-native-code storage during precompilation. `Base.compilecache` can still be called
-manually. The state of this command line flag is passed to `Pkg.build` to disable automatic
-precompilation triggering when installing, updating, and explicitly building packages.
+It is sometimes helpful during module development to turn off incremental precompilation.
+The command line flag `--compiled-modules={yes|no|existing}` enables you to toggle module
+precompilation on and off. When Julia is started with `--compiled-modules=no` the serialized
+modules in the compile cache are ignored when loading modules and module dependencies. In
+some cases, you may want to load existing precompiled modules, but not create new ones. This
+can be done by starting Julia with `--compiled-modules=existing`. More fine-grained control
+is available with `--pkgimages={yes|no|existing}`, which only affects native-code storage
+during precompilation. `Base.compilecache` can still be called manually. The state of this
+command line flag is passed to `Pkg.build` to disable automatic precompilation triggering
+when installing, updating, and explicitly building packages.
 
 You can also debug some precompilation failures with environment variables. Setting
-`JULIA_VERBOSE_LINKING=true` may help resolve failures in linking shared libraries of compiled
-native code. See the **Developer Documentation** part of the Julia manual, where you will find further details in the section documenting Julia's internals under "Package Images".
+`JULIA_VERBOSE_LINKING=true` may help resolve failures in linking shared libraries of
+compiled native code. See the **Developer Documentation** part of the Julia manual, where
+you will find further details in the section documenting Julia's internals under "Package
+Images".
diff --git a/src/jloptions.c b/src/jloptions.c
index cc00e102c16b1..5d627687a38be 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -112,7 +112,7 @@ static const char opts[]  =
     "                            Use native code from system image if available\n"
     " --compiled-modules={yes*|no|existing}\n"
     "                            Enable or disable incremental precompilation of modules\n"
-    " --pkgimages={yes*|no}\n"
+    " --pkgimages={yes*|no|existing}\n"
     "                            Enable or disable usage of native code caching in the form of pkgimages ($)\n\n"
 
     // actions
@@ -472,6 +472,8 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                 jl_options.use_pkgimages = JL_OPTIONS_USE_PKGIMAGES_YES;
             else if (!strcmp(optarg,"no"))
                 jl_options.use_pkgimages = JL_OPTIONS_USE_PKGIMAGES_NO;
+            else if (!strcmp(optarg,"existing"))
+                jl_options.use_pkgimages = JL_OPTIONS_USE_PKGIMAGES_EXISTING;
             else
                 jl_errorf("julia: invalid argument to --pkgimages={yes|no} (%s)", optarg);
             break;
diff --git a/src/julia.h b/src/julia.h
index 6ad742d78602b..44dc913209c6b 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -2484,6 +2484,7 @@ JL_DLLEXPORT int jl_generating_output(void) JL_NOTSAFEPOINT;
 #define JL_OPTIONS_USE_COMPILED_MODULES_YES 1
 #define JL_OPTIONS_USE_COMPILED_MODULES_NO 0
 
+#define JL_OPTIONS_USE_PKGIMAGES_EXISTING 2
 #define JL_OPTIONS_USE_PKGIMAGES_YES 1
 #define JL_OPTIONS_USE_PKGIMAGES_NO 0
 
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index a6d883c3870c3..35233cf0795f0 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -619,6 +619,11 @@ JL_DLLEXPORT uint8_t jl_match_cache_flags(uint8_t flags)
         return 1;
     }
 
+    // If package images are optional, ignore that bit (it will be unset in current_flags)
+    if (jl_options.use_pkgimages == JL_OPTIONS_USE_PKGIMAGES_EXISTING) {
+        flags &= ~1;
+    }
+
     // 2. Check all flags, execept opt level must be exact
     uint8_t mask = (1 << OPT_LEVEL)-1;
     if ((flags & mask) != (current_flags & mask))
diff --git a/test/loading.jl b/test/loading.jl
index c3bdce3890795..826107c8aab87 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1406,3 +1406,82 @@ end
         end
     end
 end
+
+@testset "command-line flags" begin
+    mktempdir() do dir
+        # generate a Parent.jl and Child.jl package, with Parent depending on Child
+        open(joinpath(dir, "Child.jl"), "w") do io
+            println(io, """
+                module Child
+                end""")
+        end
+        open(joinpath(dir, "Parent.jl"), "w") do io
+            println(io, """
+                module Parent
+                using Child
+                end""")
+        end
+
+        # helper function to load a package and return the output
+        function load_package(name, args=``)
+            code = "using $name"
+            cmd = addenv(`$(Base.julia_cmd()) -e $code $args`,
+                        "JULIA_LOAD_PATH" => dir,
+                        "JULIA_DEBUG" => "loading")
+
+            out = Pipe()
+            proc = run(pipeline(cmd, stdout=out, stderr=out))
+            close(out.in)
+
+            log = @async String(read(out))
+            @test success(proc)
+            fetch(log)
+        end
+
+        log = load_package("Parent", `--compiled-modules=no --pkgimages=no`)
+        @test !occursin(r"Generating (cache|object cache) file", log)
+        @test !occursin(r"Loading (cache|object cache) file", log)
+
+
+        ## tests for `--compiled-modules`, which generates cache files
+
+        log = load_package("Child", `--compiled-modules=yes --pkgimages=no`)
+        @test occursin(r"Generating cache file for Child", log)
+        @test occursin(r"Loading cache file .+ for Child", log)
+
+        # with `--compiled-modules=existing` we should only precompile Child
+        log = load_package("Parent", `--compiled-modules=existing --pkgimages=no`)
+        @test !occursin(r"Generating cache file for Child", log)
+        @test occursin(r"Loading cache file .+ for Child", log)
+        @test !occursin(r"Generating cache file for Parent", log)
+        @test !occursin(r"Loading cache file .+ for Parent", log)
+
+        # the default is `--compiled-modules=yes`, which should now precompile Parent
+        log = load_package("Parent", `--pkgimages=no`)
+        @test !occursin(r"Generating cache file for Child", log)
+        @test occursin(r"Loading cache file .+ for Child", log)
+        @test occursin(r"Generating cache file for Parent", log)
+        @test occursin(r"Loading cache file .+ for Parent", log)
+
+
+        ## tests for `--pkgimages`, which generates object cache files
+
+        log = load_package("Child", `--compiled-modules=yes --pkgimages=yes`)
+        @test occursin(r"Generating object cache file for Child", log)
+        @test occursin(r"Loading object cache file .+ for Child", log)
+
+        # with `--pkgimages=existing` we should only generate code for Child
+        log = load_package("Parent", `--compiled-modules=yes --pkgimages=existing`)
+        @test !occursin(r"Generating object cache file for Child", log)
+        @test occursin(r"Loading object cache file .+ for Child", log)
+        @test !occursin(r"Generating object cache file for Parent", log)
+        @test !occursin(r"Loading object cache file .+ for Parent", log)
+
+        # the default is `--pkgimages=yes`, which should now generate code for Parent
+        log = load_package("Parent")
+        @test !occursin(r"Generating object cache file for Child", log)
+        @test occursin(r"Loading object cache file .+ for Child", log)
+        @test occursin(r"Generating object cache file for Parent", log)
+        @test occursin(r"Loading object cache file .+ for Parent", log)
+    end
+end

From 3b250c73dc686cb3857067582f47be336ac788ef Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Tue, 19 Dec 2023 07:55:04 -0500
Subject: [PATCH 0461/1315] fix isequal_normalized for combining-char
 reordering (#52447)

Fixes #52408.

(Note that this function was added in Julia 1.8, in #42493.)

In the future it would be good to further optimize this function by
adding a fast path for the common case of strings that are mostly ASCII
characters. Perhaps simply skip ahead to the first byte that doesn't
match before we begin doing decomposition etcetera.
---
 stdlib/Unicode/src/Unicode.jl   | 81 ++++++++++++++++++++++++++++-----
 stdlib/Unicode/test/runtests.jl | 67 +++++++++++++++++++++++++++
 2 files changed, 137 insertions(+), 11 deletions(-)

diff --git a/stdlib/Unicode/src/Unicode.jl b/stdlib/Unicode/src/Unicode.jl
index bd54037ec9e6f..9d86f6f9cbe7b 100644
--- a/stdlib/Unicode/src/Unicode.jl
+++ b/stdlib/Unicode/src/Unicode.jl
@@ -208,12 +208,19 @@ end
 
 using Base.Unicode: utf8proc_error, UTF8PROC_DECOMPOSE, UTF8PROC_CASEFOLD, UTF8PROC_STRIPMARK
 
-function _decompose_char!(codepoint::Union{Integer,Char}, dest::Vector{UInt32}, options::Integer)
-    ret = @ccall utf8proc_decompose_char(codepoint::UInt32, dest::Ptr{UInt32}, length(dest)::Int, options::Cint, C_NULL::Ptr{Cint})::Int
+function _decompose_char!(codepoint::Union{Integer,Char}, dest::Vector{UInt32}, offset::Integer, options::Integer)
+    ret = GC.@preserve dest @ccall utf8proc_decompose_char(codepoint::UInt32, pointer(dest, 1+offset)::Ptr{UInt32}, (length(dest)-offset)::Int, options::Cint, C_NULL::Ptr{Cint})::Int
     ret < 0 && utf8proc_error(ret)
     return ret
 end
 
+# would be good to have higher-level accessor functions in utf8proc.  alternatively,
+# we could mirror the whole utf8proc_property_t struct in Julia, but that is annoying
+# because of the bitfields.
+combining_class(uc::Integer) =
+    0x000301 ≤ uc ≤ 0x10ffff ? unsafe_load(ccall(:utf8proc_get_property, Ptr{UInt16}, (UInt32,), uc), 2) : 0x0000
+combining_class(c::AbstractChar) = ismalformed(c) ? 0x0000 : combining_class(UInt32(c))
+
 """
     isequal_normalized(s1::AbstractString, s2::AbstractString; casefold=false, stripmark=false, chartransform=identity)
 
@@ -225,6 +232,9 @@ As with [`Unicode.normalize`](@ref), you can also pass an arbitrary
 function via the `chartransform` keyword (mapping `Integer` codepoints to codepoints)
 to perform custom normalizations, such as [`Unicode.julia_chartransform`](@ref).
 
+!!! compat "Julia 1.8"
+    The `isequal_normalized` function was added in Julia 1.8.
+
 # Examples
 
 For example, the string `"noël"` can be constructed in two canonically equivalent ways
@@ -251,29 +261,78 @@ julia> isequal_normalized(s1, "NOËL", casefold=true)
 true
 ```
 """
-function isequal_normalized(s1::AbstractString, s2::AbstractString; casefold::Bool=false, stripmark::Bool=false, chartransform=identity)
-    function decompose_next_char!(c, state, d, options, s)
-        n = _decompose_char!(c, d, options)
-        if n > length(d) # may be possible in future Unicode versions?
-            n = _decompose_char!(c, resize!(d, n), options)
+isequal_normalized(s1::AbstractString, s2::AbstractString; casefold::Bool=false, stripmark::Bool=false, chartransform=identity) =
+    _isequal_normalized!(s1, s2, Vector{UInt32}(undef, 4), Vector{UInt32}(undef, 4), chartransform; casefold, stripmark)
+
+# like isequal_normalized, but takes pre-allocated codepoint buffers as arguments, and chartransform is a positional argument
+function _isequal_normalized!(s1::AbstractString, s2::AbstractString,
+                              d1::Vector{UInt32}, d2::Vector{UInt32}, chartransform::F=identity;
+                              casefold::Bool=false, stripmark::Bool=false) where {F}
+    function decompose_next_chars!(state, d, options, s)
+        local n
+        offset = 0
+        @inbounds while true
+            # read a char and decompose it to d
+            c = chartransform(UInt32(state[1]))
+            state = iterate(s, state[2])
+            if c < 0x80 # fast path for common ASCII case
+                n = 1 + offset
+                n > length(d) && resize!(d, 2n)
+                d[n] = casefold ? (0x41 ≤ c ≤ 0x5A ? c+0x20 : c) : c
+                break # ASCII characters are all zero combining class
+            else
+                while true
+                    n = _decompose_char!(c, d, offset, options) + offset
+                    if n > length(d)
+                        resize!(d, 2n)
+                        continue
+                    end
+                    break
+                end
+            end
+
+            # decomposed chars must be sorted in ascending order of combining class,
+            # which means we need to keep fetching chars until we get to non-combining
+            (iszero(combining_class(d[n])) || isnothing(state)) && break # non-combining
+            offset = n
         end
-        return 1, n, iterate(s, state)
+
+        # sort by combining class
+        if n < 32 # almost always true
+            for j1 = 2:n # insertion sort
+                cc = combining_class(d[j1])
+                iszero(cc) && continue # don't re-order non-combiners
+                for j2 = j1:-1:2
+                    combining_class(d[j2-1]) ≤ cc && break
+                    d[j2-1], d[j2] = d[j2], d[j2-1]
+                end
+            end
+        else # avoid n^2 complexity in crazy large-n case
+            j = 1
+            @views while j < n
+                j₀ = j + something(findnext(iszero ∘ combining_class, d[j+1:n], 1), n+1-j)
+                sort!(d[j:j₀-1], by=combining_class)
+                j = j₀
+            end
+        end
+
+        # split return statement to help type inference:
+        return state === nothing ? (1, n, nothing) : (1, n, state)
     end
     options = UTF8PROC_DECOMPOSE
     casefold && (options |= UTF8PROC_CASEFOLD)
     stripmark && (options |= UTF8PROC_STRIPMARK)
     i1,i2 = iterate(s1),iterate(s2)
-    d1,d2 = Vector{UInt32}(undef, 4), Vector{UInt32}(undef, 4) # codepoint buffers
     n1 = n2 = 0 # lengths of codepoint buffers
     j1 = j2 = 1 # indices in d1, d2
     while true
         if j1 > n1
             i1 === nothing && return i2 === nothing && j2 > n2
-            j1, n1, i1 = decompose_next_char!(chartransform(UInt32(i1[1])), i1[2], d1, options, s1)
+            j1, n1, i1 = decompose_next_chars!(i1, d1, options, s1)
         end
         if j2 > n2
             i2 === nothing && return false
-            j2, n2, i2 = decompose_next_char!(chartransform(UInt32(i2[1])), i2[2], d2, options, s2)
+            j2, n2, i2 = decompose_next_chars!(i2, d2, options, s2)
         end
         d1[j1] == d2[j2] || return false
         j1 += 1; j2 += 1
diff --git a/stdlib/Unicode/test/runtests.jl b/stdlib/Unicode/test/runtests.jl
index 573d5da6167ba..5248bd1e1fd27 100644
--- a/stdlib/Unicode/test/runtests.jl
+++ b/stdlib/Unicode/test/runtests.jl
@@ -3,6 +3,9 @@
 using Test
 using Unicode
 using Unicode: normalize, isassigned, julia_chartransform
+import Random
+
+Random.seed!(12345)
 
 @testset "string normalization" begin
     # normalize (Unicode normalization etc.):
@@ -455,6 +458,9 @@ end
     @test !Base.Unicode.isvalid(Char, overlong_char)
 end
 
+# the obvious, but suboptimal, algorithm:
+isequal_normalized_naive(s1, s2; kws...) = normalize(s1; kws...) == normalize(s2; kws...)
+
 @testset "Unicode equivalence" begin
     @test isequal_normalized("no\u00EBl", "noe\u0308l")
     @test !isequal_normalized("no\u00EBl", "noe\u0308l ")
@@ -466,4 +472,65 @@ end
     @test isequal_normalized("no\u00EBl", "noel", stripmark=true)
     @test isequal_normalized("no\u00EBl", "NOEL", stripmark=true, casefold=true)
     @test isequal_normalized("\u00B5\u0302m", "\u03BC\u0302m", chartransform=julia_chartransform)
+
+    # issue #52408
+    @testset "Sorting combining characters" begin
+        for str in ("\u5bc\u5b0", "j\u5ae\u5bf\u5b2\u5b4") # julia#52408 examples
+            @test isequal_normalized(str, normalize(str))
+        end
+
+        # first codepoint in every possible Unicode combining class
+        let cc_chars = UInt32[0x00000334, 0x00016ff0, 0x0000093c, 0x00003099, 0x0000094d, 0x000005b0, 0x000005b1, 0x000005b2, 0x000005b3, 0x000005b4, 0x000005b5, 0x000005b6, 0x000005b7, 0x000005b8, 0x000005b9, 0x000005bb, 0x000005bc, 0x000005bd, 0x000005bf, 0x000005c1, 0x000005c2, 0x0000fb1e, 0x0000064b, 0x0000064c, 0x0000064d, 0x00000618, 0x00000619, 0x0000061a, 0x00000651, 0x00000652, 0x00000670, 0x00000711, 0x00000c55, 0x00000c56, 0x00000e38, 0x00000e48, 0x00000eb8, 0x00000ec8, 0x00000f71, 0x00000f72, 0x00000f74, 0x00000321, 0x00001dce, 0x0000031b, 0x00001dfa, 0x00000316, 0x0000059a, 0x0000302e, 0x0001d16d, 0x000005ae, 0x00000301, 0x00000315, 0x0000035c, 0x0000035d, 0x00000345],
+            vowels = ['a', 'e', 'i', 'o', 'u', 'å', 'é', 'î', 'ö', 'ü'], Vowels = [vowels; uppercase.(vowels)]
+            function randcc(n, n_cc) # random string with lots of combining chars
+                buf = IOBuffer()
+                for _ = 1:n
+                    print.(buf, rand(Vowels, rand(1:5)))
+                    print.(buf, Char.(rand(cc_chars, rand(0:n_cc))))
+                end
+                return String(take!(buf))
+            end
+            for _ = 1:100
+                s = randcc(10,10)
+                ns = normalize(s)
+                cs = normalize(s, casefold=true)
+                @test isequal_normalized(s, s)
+                if !isequal_normalized(s, ns)
+                    @show s
+                end
+                @test isequal_normalized(s, ns)
+                @test isequal_normalized(cs, ns) == isequal_normalized_naive(cs, ns)
+                @test isequal_normalized(cs, ns, casefold=true) ==
+                      isequal_normalized_naive(cs, ns, casefold=true)
+            end
+            for _ = 1:3
+                s = randcc(5,1000) # exercise sort!-based fallback
+                @test isequal_normalized(s, normalize(s))
+            end
+            function randcc2(n, n_cc) # 2 strings with equivalent reordered combiners
+                buf1 = IOBuffer()
+                buf2 = IOBuffer()
+                p = n_cc / length(cc_chars)
+                for _ = 1:n
+                    a = join(rand(Vowels, rand(1:5)))
+                    print(buf1, a)
+                    print(buf2, a)
+
+                    # chars from distinct combining classes
+                    # are canonically equivalent when re-ordered
+                    c = Random.randsubseq(cc_chars, p)
+                    print.(buf1, Char.(Random.shuffle!(c)))
+                    print.(buf2, Char.(Random.shuffle!(c)))
+                end
+                return String(take!(buf1)), String(take!(buf2))
+            end
+            for _ = 1:100
+                s1, s2 = randcc2(10,10)
+                @test isequal_normalized(s1, s2)
+            end
+        end
+
+        # combining characters in the same class are inequivalent if re-ordered:
+        @test !isequal_normalized("x\u0334\u0335", "x\u0335\u0334")
+    end
 end

From f1f680f5605ecc471678073391f280696640207e Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Tue, 19 Dec 2023 14:23:26 +0100
Subject: [PATCH 0462/1315] docs: fix `PersistentDict` doc string note
 admonition formatting (#52579)

https://docs.julialang.org/en/v1/stdlib/Markdown/#Admonitions

Fixes #52578
---
 base/dict.jl | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/base/dict.jl b/base/dict.jl
index eaee28271d6d5..89592d06d7bb6 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -929,11 +929,12 @@ returns a new dictionary separate from the previous one, but the underlying
 implementation is space-efficient and may share storage across multiple
 separate dictionaries.
 
-!!!note
+!!! note
     It behaves like an IdDict.
 
-
-    PersistentDict(KV::Pair)
+```julia
+PersistentDict(KV::Pair)
+```
 
 # Examples
 

From 4d677a5906680ccf843d510c85bc73d2cb0e0b14 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 19 Dec 2023 16:19:34 +0100
Subject: [PATCH 0463/1315] Fix array condition in is_valid_intrinsic_elptr
 (#52433)

This conditional was added in the Memory PR, but the `ety` is obviously
a type, not an array, so I'm assuming it meant to filter out array
types.
---
 src/julia_internal.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/julia_internal.h b/src/julia_internal.h
index 1ecf7a0c1cdfa..4f92c3eb500e3 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1300,7 +1300,7 @@ JL_DLLEXPORT unsigned jl_intrinsic_nargs(int f) JL_NOTSAFEPOINT;
 
 STATIC_INLINE int is_valid_intrinsic_elptr(jl_value_t *ety)
 {
-    return ety == (jl_value_t*)jl_any_type || (jl_is_concrete_type(ety) && !jl_is_layout_opaque(((jl_datatype_t*)ety)->layout) && !jl_is_array(ety));
+    return ety == (jl_value_t*)jl_any_type || (jl_is_concrete_type(ety) && !jl_is_layout_opaque(((jl_datatype_t*)ety)->layout) && !jl_is_array_type(ety));
 }
 JL_DLLEXPORT jl_value_t *jl_bitcast(jl_value_t *ty, jl_value_t *v);
 JL_DLLEXPORT jl_value_t *jl_pointerref(jl_value_t *p, jl_value_t *i, jl_value_t *align);

From 24e43ad57ab4ef17d1609c510cb41eb3567fe013 Mon Sep 17 00:00:00 2001
From: ArunS <74652697+ArunS-tack@users.noreply.github.com>
Date: Wed, 20 Dec 2023 00:00:40 +0530
Subject: [PATCH 0464/1315] added promotions for SymTri and Tri (#48536)

Co-authored-by: zzeuuus <74652697+ArunSanganal@users.noreply.github.com>
Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 stdlib/LinearAlgebra/src/tridiag.jl  | 23 +++++++++++++++++++----
 stdlib/LinearAlgebra/test/tridiag.jl | 17 +++++++++++------
 2 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/tridiag.jl b/stdlib/LinearAlgebra/src/tridiag.jl
index 235fa5636877a..da15e1680f53a 100644
--- a/stdlib/LinearAlgebra/src/tridiag.jl
+++ b/stdlib/LinearAlgebra/src/tridiag.jl
@@ -70,9 +70,14 @@ julia> A[2,1]
 SymTridiagonal(dv::V, ev::V) where {T,V<:AbstractVector{T}} = SymTridiagonal{T}(dv, ev)
 SymTridiagonal{T}(dv::V, ev::V) where {T,V<:AbstractVector{T}} = SymTridiagonal{T,V}(dv, ev)
 function SymTridiagonal{T}(dv::AbstractVector, ev::AbstractVector) where {T}
-    SymTridiagonal(convert(AbstractVector{T}, dv)::AbstractVector{T},
-                   convert(AbstractVector{T}, ev)::AbstractVector{T})
+    d = convert(AbstractVector{T}, dv)::AbstractVector{T}
+    e = convert(AbstractVector{T}, ev)::AbstractVector{T}
+    typeof(d) == typeof(e) ?
+        SymTridiagonal{T}(d, e) :
+        throw(ArgumentError("diagonal vectors needed to be convertible to same type"))
 end
+SymTridiagonal(d::AbstractVector{T}, e::AbstractVector{S}) where {T,S} =
+    SymTridiagonal{promote_type(T, S)}(d, e)
 
 """
     SymTridiagonal(A::AbstractMatrix)
@@ -513,11 +518,21 @@ julia> Tridiagonal(dl, d, du)
 """
 Tridiagonal(dl::V, d::V, du::V) where {T,V<:AbstractVector{T}} = Tridiagonal{T,V}(dl, d, du)
 Tridiagonal(dl::V, d::V, du::V, du2::V) where {T,V<:AbstractVector{T}} = Tridiagonal{T,V}(dl, d, du, du2)
+Tridiagonal(dl::AbstractVector{T}, d::AbstractVector{S}, du::AbstractVector{U}) where {T,S,U} =
+    Tridiagonal{promote_type(T, S, U)}(dl, d, du)
+Tridiagonal(dl::AbstractVector{T}, d::AbstractVector{S}, du::AbstractVector{U}, du2::AbstractVector{V}) where {T,S,U,V} =
+    Tridiagonal{promote_type(T, S, U, V)}(dl, d, du, du2)
 function Tridiagonal{T}(dl::AbstractVector, d::AbstractVector, du::AbstractVector) where {T}
-    Tridiagonal(map(x->convert(AbstractVector{T}, x), (dl, d, du))...)
+    l, d, u = map(x->convert(AbstractVector{T}, x), (dl, d, du))
+    typeof(l) == typeof(d) == typeof(u) ?
+        Tridiagonal(l, d, u) :
+        throw(ArgumentError("diagonal vectors needed to be convertible to same type"))
 end
 function Tridiagonal{T}(dl::AbstractVector, d::AbstractVector, du::AbstractVector, du2::AbstractVector) where {T}
-    Tridiagonal(map(x->convert(AbstractVector{T}, x), (dl, d, du, du2))...)
+    l, d, u, u2 = map(x->convert(AbstractVector{T}, x), (dl, d, du, du2))
+    typeof(l) == typeof(d) == typeof(u) == typeof(u2) ?
+        Tridiagonal(l, d, u, u2) :
+        throw(ArgumentError("diagonal vectors needed to be convertible to same type"))
 end
 
 """
diff --git a/stdlib/LinearAlgebra/test/tridiag.jl b/stdlib/LinearAlgebra/test/tridiag.jl
index 2d846683e38c3..0c07e5b160c58 100644
--- a/stdlib/LinearAlgebra/test/tridiag.jl
+++ b/stdlib/LinearAlgebra/test/tridiag.jl
@@ -95,12 +95,12 @@ end
         @test isa(ST, SymTridiagonal{elty,Vector{elty}})
         TT = Tridiagonal{elty,Vector{elty}}(GenericArray(dl), d, GenericArray(dl))
         @test isa(TT, Tridiagonal{elty,Vector{elty}})
-        @test_throws MethodError SymTridiagonal(d, GenericArray(dl))
-        @test_throws MethodError SymTridiagonal(GenericArray(d), dl)
-        @test_throws MethodError Tridiagonal(GenericArray(dl), d, GenericArray(dl))
-        @test_throws MethodError Tridiagonal(dl, GenericArray(d), dl)
-        @test_throws MethodError SymTridiagonal{elty}(d, GenericArray(dl))
-        @test_throws MethodError Tridiagonal{elty}(GenericArray(dl), d,GenericArray(dl))
+        @test_throws ArgumentError SymTridiagonal(d, GenericArray(dl))
+        @test_throws ArgumentError SymTridiagonal(GenericArray(d), dl)
+        @test_throws ArgumentError Tridiagonal(GenericArray(dl), d, GenericArray(dl))
+        @test_throws ArgumentError Tridiagonal(dl, GenericArray(d), dl)
+        @test_throws ArgumentError SymTridiagonal{elty}(d, GenericArray(dl))
+        @test_throws ArgumentError Tridiagonal{elty}(GenericArray(dl), d,GenericArray(dl))
         STI = SymTridiagonal([1,2,3,4], [1,2,3])
         TTI = Tridiagonal([1,2,3], [1,2,3,4], [1,2,3])
         TTI2 = Tridiagonal([1,2,3], [1,2,3,4], [1,2,3], [1,2])
@@ -505,6 +505,11 @@ end
     @test SymTridiagonal([1, 2], [0])^3 == [1 0; 0 8]
 end
 
+@testset "Issue #48505" begin
+    @test SymTridiagonal([1,2,3],[4,5.0]) == [1.0 4.0 0.0; 4.0 2.0 5.0; 0.0 5.0 3.0]
+    @test Tridiagonal([1, 2], [4, 5, 1], [6.0, 7]) == [4.0 6.0 0.0; 1.0 5.0 7.0; 0.0 2.0 1.0]
+end
+
 @testset "convert for SymTridiagonal" begin
     STF32 = SymTridiagonal{Float32}(fill(1f0, 5), fill(1f0, 4))
     @test convert(SymTridiagonal{Float64}, STF32)::SymTridiagonal{Float64} == STF32

From 163393448c9df1fa0a3a3d051913eadd4f94a3ac Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 20 Dec 2023 09:36:26 +0530
Subject: [PATCH 0465/1315] Specialize `fill!` for `Lower`/`UpperTriangular`
 (#52570)

Only looping over the triangular part provides a performance boost:
```julia
julia> U = UpperTriangular(rand(3000,3000));

julia> @btime zero($U);
  23.575 ms (3 allocations: 68.66 MiB) # master
  15.739 ms (3 allocations: 68.66 MiB) # PR
```
This is only really applicable when filling a triangular matrix with
zeros, but this has several applications (e.g. imaginary part of a real
matrix).

---------

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 stdlib/LinearAlgebra/src/triangular.jl  | 16 ++++++++++++++++
 stdlib/LinearAlgebra/test/triangular.jl |  5 +++++
 2 files changed, 21 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 42c44996df1b1..66e5fd3e4b4c1 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -294,6 +294,22 @@ end
     return A
 end
 
+@inline function fill!(A::UpperTriangular, x)
+    iszero(x) || throw(ArgumentError("cannot set indices in the lower triangular part " *
+            "of an UpperTriangular matrix to a nonzero value ($x)"))
+    for col in axes(A,2), row in firstindex(A,1):col
+        @inbounds A.data[row, col] = x
+    end
+    A
+end
+@inline function fill!(A::LowerTriangular, x)
+    iszero(x) || throw(ArgumentError("cannot set indices in the upper triangular part " *
+            "of a LowerTriangular matrix to a nonzero value ($x)"))
+    for col in axes(A,2), row in col:lastindex(A,1)
+        @inbounds A.data[row, col] = x
+    end
+    A
+end
 
 ## structured matrix methods ##
 function Base.replace_in_print_matrix(A::Union{UpperTriangular,UnitUpperTriangular},
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index e2111db95f1ef..ebff80d3db2ca 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -192,6 +192,11 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo
         @test imag(A1) == imag(Matrix(A1))
         @test abs.(A1) == abs.(Matrix(A1))
 
+        # zero
+        if A1 isa UpperTriangular || A1 isa LowerTriangular
+            @test zero(A1) == zero(parent(A1))
+        end
+
         # Unary operations
         @test -A1 == -Matrix(A1)
 

From d07a272a7fdee4a81b7e444f9a29b5570ca34634 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 20 Dec 2023 09:36:38 +0530
Subject: [PATCH 0466/1315] Improve the docstring of `mul!` (#52509)

Add a comparison between the in-place and out-of-place versions to
demonstrate that they compute the same values.
---
 stdlib/LinearAlgebra/src/matmul.jl | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index adc2d866ad70e..cc1c954258a88 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -217,18 +217,24 @@ end
 """
     mul!(Y, A, B) -> Y
 
-Calculates the matrix-matrix or matrix-vector product ``AB`` and stores the result in `Y`,
+Calculates the matrix-matrix or matrix-vector product ``A B`` and stores the result in `Y`,
 overwriting the existing value of `Y`. Note that `Y` must not be aliased with either `A` or
 `B`.
 
 # Examples
 ```jldoctest
-julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; Y = similar(B); mul!(Y, A, B);
+julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; Y = similar(B);
+
+julia> mul!(Y, A, B) === Y
+true
 
 julia> Y
 2×2 Matrix{Float64}:
  3.0  3.0
  7.0  7.0
+
+julia> Y == A * B
+true
 ```
 
 # Implementation
@@ -250,15 +256,22 @@ aliased with either `A` or `B`.
 
 # Examples
 ```jldoctest
-julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; C=[1.0 2.0; 3.0 4.0];
+julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; C = [1.0 2.0; 3.0 4.0];
 
-julia> mul!(C, A, B, 100.0, 10.0) === C
+julia> α, β = 100.0, 10.0;
+
+julia> mul!(C, A, B, α, β) === C
 true
 
 julia> C
 2×2 Matrix{Float64}:
  310.0  320.0
  730.0  740.0
+
+julia> C_original = [1.0 2.0; 3.0 4.0]; # A copy of the original value of C
+
+julia> C == A * B * α + C_original * β
+true
 ```
 """
 @inline mul!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat, α::Number, β::Number) =

From d53fc50c24f5758bd0056f5e3fdf8655da63b9bc Mon Sep 17 00:00:00 2001
From: freemin7 <25376460+freemin7@users.noreply.github.com>
Date: Wed, 20 Dec 2023 06:39:47 +0100
Subject: [PATCH 0467/1315] Expand Nagle DocString (#52565)

Improve Nagle DocString. See also
https://github.com/JuliaLang/julia/issues/31842

---------

Co-authored-by: Elliot Saba <staticfloat@gmail.com>
---
 stdlib/Sockets/src/Sockets.jl | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/stdlib/Sockets/src/Sockets.jl b/stdlib/Sockets/src/Sockets.jl
index 2f6b39aa38184..85f3e7639b6ae 100644
--- a/stdlib/Sockets/src/Sockets.jl
+++ b/stdlib/Sockets/src/Sockets.jl
@@ -567,7 +567,11 @@ end
 """
     nagle(socket::Union{TCPServer, TCPSocket}, enable::Bool)
 
-Enables or disables Nagle's algorithm on a given TCP server or socket.
+Nagle's algorithm batches multiple small TCP packets into larger
+ones. This can improve throughput but worsen latency. Nagle's algorithm
+is enabled by default. This function sets whether Nagle's algorithm is
+active on a given TCP server or socket. The opposite option is called
+`TCP_NODELAY` in other languages.
 
 !!! compat "Julia 1.3"
     This function requires Julia 1.3 or later.

From ae3c71165f71ead84078f1f0364acb92d686c366 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 20 Dec 2023 18:25:52 +0900
Subject: [PATCH 0468/1315] make `update_exc_bestguess!` overloadable by
 `AbstractInterpreter` (#52588)

This change allows `AbstractInterpreter` to record each program counter
where exception type inference happened, which is required for new
functionality of Cthulhu that I'm implementing.
---
 base/compiler/abstractinterpretation.jl | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index bae7bad238318..1f5b4ab445330 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -3099,7 +3099,8 @@ function update_bestguess!(interp::AbstractInterpreter, frame::InferenceState,
     end
 end
 
-function update_exc_bestguess!(@nospecialize(exct), frame::InferenceState, 𝕃ₚ::AbstractLattice)
+function update_exc_bestguess!(interp::AbstractInterpreter, @nospecialize(exct), frame::InferenceState)
+    𝕃ₚ = ipo_lattice(interp)
     cur_hand = frame.handler_at[frame.currpc][1]
     if cur_hand == 0
         if !⊑(𝕃ₚ, exct, frame.exc_bestguess)
@@ -3200,7 +3201,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                     if nothrow
                         add_curr_ssaflag!(frame, IR_FLAG_NOTHROW)
                     else
-                        update_exc_bestguess!(TypeError, frame, ipo_lattice(interp))
+                        update_exc_bestguess!(interp, TypeError, frame)
                         propagate_to_error_handler!(currstate, frame, 𝕃ᵢ)
                         merge_effects!(interp, frame, EFFECTS_THROWS)
                     end
@@ -3296,7 +3297,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             (; changes, rt, exct) = abstract_eval_basic_statement(interp,
                 stmt, currstate, frame)
             if exct !== Union{}
-                update_exc_bestguess!(exct, frame, ipo_lattice(interp))
+                update_exc_bestguess!(interp, exct, frame)
             end
             if !has_curr_ssaflag(frame, IR_FLAG_NOTHROW)
                 propagate_to_error_handler!(currstate, frame, 𝕃ᵢ)

From a987f56bf35da093c6b93e98eea8e09dd06dcc20 Mon Sep 17 00:00:00 2001
From: Lionel Zoubritzky <Liozou@users.noreply.github.com>
Date: Wed, 20 Dec 2023 11:17:51 +0100
Subject: [PATCH 0469/1315] Fix ?(#TAB method search name exploration (#52555)

Fix #52551.

This PR ensures that a `SomeModule.?(...#TAB` completion can only
suggests method `foo` such that `SomeModule.foo` exists (by checking
`isdefined(SomeModule, :foo)`). This is equivalent, I believe, to the
initial implementation of https://github.com/JuliaLang/julia/pull/38791,
less the bug.

Now that we have #51345, we may want to relax the above condition
somewhat to include public names present in modules loaded into
`SomeModule`, so that, for instance, a direct completion of `?(` would
include `@assume_effects`. This could be good for method exploration
because even though typing `@assume_effects` with no qualification in
`Main` will error, the error now includes the helpful message
```
Hint: a global variable of this name also exists in Base.
```
But that can wait for a later PR anyway, this one is just the bugfix.

The bug mentioned at
https://github.com/JuliaLang/julia/issues/52551#issuecomment-1858543413
dates from the initial #38791 so this could be backported as far back as
v1.8.

---------

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
---
 stdlib/REPL/src/REPLCompletions.jl  | 50 +++++++++++++----------------
 stdlib/REPL/test/replcompletions.jl |  7 ++++
 2 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 8a9029ccf49cd..da5d20270c5b6 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -7,7 +7,7 @@ export completions, shell_completions, bslash_completions, completion_text
 using Core: CodeInfo, MethodInstance, CodeInstance, Const
 const CC = Core.Compiler
 using Base.Meta
-using Base: propertynames, something
+using Base: propertynames, something, IdSet
 
 abstract type Completion end
 
@@ -718,6 +718,26 @@ function complete_methods(ex_org::Expr, context_module::Module=Main, shift::Bool
 end
 
 MAX_ANY_METHOD_COMPLETIONS::Int = 10
+function recursive_explore_names!(seen::IdSet, callee_module::Module, initial_module::Module, exploredmodules::IdSet{Module}=IdSet{Module}())
+    push!(exploredmodules, callee_module)
+    for name in names(callee_module; all=true, imported=true)
+        if !Base.isdeprecated(callee_module, name) && !startswith(string(name), '#') && isdefined(initial_module, name)
+            func = getfield(callee_module, name)
+            if !isa(func, Module)
+                funct = Core.Typeof(func)
+                push!(seen, funct)
+            elseif isa(func, Module) && func ∉ exploredmodules
+                recursive_explore_names!(seen, func, initial_module, exploredmodules)
+            end
+        end
+    end
+end
+function recursive_explore_names(callee_module::Module, initial_module::Module)
+    seen = IdSet{Any}()
+    recursive_explore_names!(seen, callee_module, initial_module)
+    seen
+end
+
 function complete_any_methods(ex_org::Expr, callee_module::Module, context_module::Module, moreargs::Bool, shift::Bool)
     out = Completion[]
     args_ex, kwargs_ex, kwargs_flag = try
@@ -733,32 +753,8 @@ function complete_any_methods(ex_org::Expr, callee_module::Module, context_modul
     # semicolon for the ".?(" syntax
     moreargs && push!(args_ex, Vararg{Any})
 
-    seen = Base.IdSet()
-    for name in names(callee_module; all=true)
-        if !Base.isdeprecated(callee_module, name) && isdefined(callee_module, name) && !startswith(string(name), '#')
-            func = getfield(callee_module, name)
-            if !isa(func, Module)
-                funct = Core.Typeof(func)
-                if !in(funct, seen)
-                    push!(seen, funct)
-                    complete_methods!(out, funct, args_ex, kwargs_ex, MAX_ANY_METHOD_COMPLETIONS, false)
-                end
-            elseif callee_module === Main && isa(func, Module)
-                callee_module2 = func
-                for name in names(callee_module2)
-                    if !Base.isdeprecated(callee_module2, name) && isdefined(callee_module2, name) && !startswith(string(name), '#')
-                        func = getfield(callee_module, name)
-                        if !isa(func, Module)
-                            funct = Core.Typeof(func)
-                            if !in(funct, seen)
-                                push!(seen, funct)
-                                complete_methods!(out, funct, args_ex, kwargs_ex, MAX_ANY_METHOD_COMPLETIONS, false)
-                            end
-                        end
-                    end
-                end
-            end
-        end
+    for seen_name in recursive_explore_names(callee_module, callee_module)
+        complete_methods!(out, seen_name, args_ex, kwargs_ex, MAX_ANY_METHOD_COMPLETIONS, false)
     end
 
     if !shift
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index d0bb09dbf8909..2fe6c987de63d 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -142,6 +142,10 @@ let ex = quote
         struct WeirdNames end
         Base.propertynames(::WeirdNames) = (Symbol("oh no!"), Symbol("oh yes!"))
 
+        # https://github.com/JuliaLang/julia/issues/52551#issuecomment-1858543413
+        export exported_symbol
+        exported_symbol(::WeirdNames) = nothing
+
         end # module CompletionFoo
         test_repl_comp_dict = CompletionFoo.test_dict
         test_repl_comp_customdict = CompletionFoo.test_customdict
@@ -742,6 +746,9 @@ end
 
 #TODO: @test_nocompletion("CompletionFoo.?(3; len2=5; ")
 
+# https://github.com/JuliaLang/julia/issues/52551
+@test !isempty(test_complete("?("))
+
 #################################################################
 
 # Test method completion with varargs

From f8cd1eb4bee56058a5f12383ac49990fc1c98ee7 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 20 Dec 2023 18:12:21 +0530
Subject: [PATCH 0470/1315] `invperm` for immutable arrays (#52546)

Rebase #47855

Close #47855
Close #47847

After this,
```julia
julia> invperm(SA[3,2,1])
3-element MVector{3, Int64} with indices SOneTo(3):
 3
 2
 1
```
---
 base/combinatorics.jl               | 2 +-
 test/combinatorics.jl               | 7 +++++++
 test/testhelpers/ImmutableArrays.jl | 3 +++
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/base/combinatorics.jl b/base/combinatorics.jl
index 6923c2a793a43..a169cfb9ecd77 100644
--- a/base/combinatorics.jl
+++ b/base/combinatorics.jl
@@ -279,7 +279,7 @@ julia> B[invperm(v)]
 """
 function invperm(a::AbstractVector)
     require_one_based_indexing(a)
-    b = zero(a) # similar vector of zeros
+    b = fill!(similar(a), zero(eltype(a))) # mutable vector of zeros
     n = length(a)
     @inbounds for (i, j) in enumerate(a)
         ((1 <= j <= n) && b[j] == 0) ||
diff --git a/test/combinatorics.jl b/test/combinatorics.jl
index f8fe4e0bd0829..25a444b70ec36 100644
--- a/test/combinatorics.jl
+++ b/test/combinatorics.jl
@@ -2,6 +2,9 @@
 
 using Random: randcycle
 
+isdefined(Main, :ImmutableArrays) || @eval Main include("testhelpers/ImmutableArrays.jl")
+using .Main.ImmutableArrays
+
 @testset "binomial" begin
     @test binomial(5,-1) == 0
     @test binomial(5,10) == 0
@@ -67,6 +70,10 @@ end
         @test isperm(T) == true
         @test isperm(K) == false
     end
+
+    # issue #47847
+    p = ImmutableArrays.ImmutableArray([2,3,1])
+    @test invperm(p) == invperm([2,3,1])
 end
 
 @testset "factorial" begin
diff --git a/test/testhelpers/ImmutableArrays.jl b/test/testhelpers/ImmutableArrays.jl
index df2a78387e07b..8f2d23be3a7a7 100644
--- a/test/testhelpers/ImmutableArrays.jl
+++ b/test/testhelpers/ImmutableArrays.jl
@@ -25,4 +25,7 @@ Base.getindex(A::ImmutableArray, i...) = getindex(A.data, i...)
 AbstractArray{T}(A::ImmutableArray) where {T} = ImmutableArray(AbstractArray{T}(A.data))
 AbstractArray{T,N}(A::ImmutableArray{S,N}) where {S,T,N} = ImmutableArray(AbstractArray{T,N}(A.data))
 
+Base.copy(A::ImmutableArray) = ImmutableArray(copy(A.data))
+Base.zero(A::ImmutableArray) = ImmutableArray(zero(A.data))
+
 end

From 69d5537e7e810f606b35dde1f9444535db24ee09 Mon Sep 17 00:00:00 2001
From: Will Tebbutt <wt0881@my.bristol.ac.uk>
Date: Wed, 20 Dec 2023 14:15:20 +0000
Subject: [PATCH 0471/1315] Additional Phi node semantics details for ssair
 docs (#52587)

Following a discussion on slack, I thought I would propose to add this
to the docs. I'm very open to changing the form of the explanation, I
just wanted to get the point across that "all phi nodes at the start of
a basic block run simultaneously".

---------

Co-authored-by: Keno Fischer <keno@alumni.harvard.edu>
Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
---
 doc/src/devdocs/ssair.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/src/devdocs/ssair.md b/doc/src/devdocs/ssair.md
index 4375012c9f580..2eb065a62e4bf 100644
--- a/doc/src/devdocs/ssair.md
+++ b/doc/src/devdocs/ssair.md
@@ -83,6 +83,15 @@ may assume that any use of a Phi node will have an assigned value in the corresp
 for the mapping to be incomplete, i.e. for a Phi node to have missing incoming edges. In that case, it must
 be dynamically guaranteed that the corresponding value will not be used.
 
+Note that SSA uses semantically occur after the terminator of the corresponding predecessor ("on the edge").
+Consequently, if multiple Phi nodes appear at the start of a basic block, they are run simultaneously.
+This means that in the following IR snippet, if we came from block `23`, `%46` will take the value associated to
+`%45` _before_ we entered this block.
+```julia
+%45 = φ (#18 => %23, #23 => %50)
+%46 = φ (#18 => 1.0, #23 => %45)
+```
+
 PiNodes encode statically proven information that may be implicitly assumed in basic blocks dominated by a given
 pi node. They are conceptually equivalent to the technique introduced in the paper
 [ABCD: Eliminating Array Bounds Checks on Demand](https://dl.acm.org/citation.cfm?id=358438.349342) or the predicate info nodes in LLVM. To see how they work, consider,

From 58fac69cfa1277c6f9db9a5cb475d08ce267f725 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Wed, 20 Dec 2023 22:17:32 +0800
Subject: [PATCH 0472/1315] inference: fix `istuple` check in
 `apply_type_tfunc` (#52585)

close #51927
---
 base/compiler/tfuncs.jl    | 2 +-
 test/compiler/inference.jl | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index bb8712458e0be..a5790c052e24b 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -1743,7 +1743,7 @@ const _tvarnames = Symbol[:_A, :_B, :_C, :_D, :_E, :_F, :_G, :_H, :_I, :_J, :_K,
         end
         return allconst ? Const(ty) : Type{ty}
     end
-    istuple = isa(headtype, Type) && (headtype == Tuple)
+    istuple = headtype === Tuple
     if !istuple && !isa(headtype, UnionAll) && !isvarargtype(headtype)
         return Union{}
     end
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index c71fd3ca9b265..5e302f1743008 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5609,3 +5609,8 @@ let x = 1, _Any = Any
     foo27031() = bar27031((x, 1.0), Val{_Any})
     @test foo27031() == "OK"
 end
+
+# Issue #51927
+let 𝕃 = Core.Compiler.fallback_lattice
+    @test apply_type_tfunc(𝕃, Const(Tuple{Vararg{Any,N}} where N), Int) == Type{NTuple{_A, Any}} where _A
+end

From 2cf4de4f674e56bb3e9555010a609f66753e6a30 Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Wed, 20 Dec 2023 17:34:08 +0100
Subject: [PATCH 0473/1315] Document the String constructors for IPv4 and IPv6
 (#52559)

Also capitalized 'IP' in the Int constructors.

These are pretty important and I couldn't see them mentioned anywhere
else in the docs.
---
 stdlib/Sockets/src/IPAddr.jl | 27 ++++++++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

diff --git a/stdlib/Sockets/src/IPAddr.jl b/stdlib/Sockets/src/IPAddr.jl
index 04710e400fe87..5b480ef30f20e 100644
--- a/stdlib/Sockets/src/IPAddr.jl
+++ b/stdlib/Sockets/src/IPAddr.jl
@@ -31,7 +31,7 @@ end
 """
     IPv4(host::Integer) -> IPv4
 
-Return an IPv4 object from ip address `host` formatted as an [`Integer`](@ref).
+Return an IPv4 object from IP address `host` formatted as an [`Integer`](@ref).
 
 # Examples
 ```jldoctest
@@ -49,7 +49,17 @@ function IPv4(host::Integer)
     end
 end
 
-# constructor: ("1.2.3.4")
+"""
+    IPv4(str::AbstractString) -> IPv4
+
+Parse an IPv4 address string into an `IPv4` object.
+
+# Examples
+```jldoctest
+julia> IPv4("127.0.0.1")
+ip"127.0.0.1"
+```
+"""
 IPv4(str::AbstractString) = parse(IPv4, str)
 
 show(io::IO,ip::IPv4) = print(io,"ip\"",ip,"\"")
@@ -84,7 +94,7 @@ end
 """
     IPv6(host::Integer) -> IPv6
 
-Return an IPv6 object from ip address `host` formatted as an [`Integer`](@ref).
+Return an IPv6 object from IP address `host` formatted as an [`Integer`](@ref).
 
 # Examples
 ```jldoctest
@@ -104,6 +114,17 @@ function IPv6(host::Integer)
     end
 end
 
+"""
+    IPv6(str::AbstractString) -> IPv6
+
+Parse an IPv6 address string into an `IPv6` object.
+
+# Examples
+```jldoctest
+julia> IPv6("::1")
+ip"::1"
+```
+"""
 IPv6(str::AbstractString) = parse(IPv6, str)
 
 # Suppress leading '0's and "0x"

From 39087c55ca1f50ba031c0623800cb16cca897285 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 21 Dec 2023 02:20:53 +0100
Subject: [PATCH 0474/1315] Exception type: Model intrinsics (#52547)

And then use this model for `nothrow` also (eventually we should just
refactor everything to make nothrow just the appropriate query on exct).
While we're at it, fix the nothrow model for pointerref/pointerset,
which was missing a type check.

---------

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 base/compiler/abstractinterpretation.jl |   7 +-
 base/compiler/tfuncs.jl                 | 119 ++++++++++++++++++------
 base/reflection.jl                      |  11 +++
 test/compiler/effects.jl                |   4 +
 test/core.jl                            |   3 +
 5 files changed, 117 insertions(+), 27 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 1f5b4ab445330..199735b201630 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2088,8 +2088,13 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
         rt = abstract_call_builtin(interp, f, arginfo, sv)
         ft = popfirst!(argtypes)
         effects = builtin_effects(𝕃ᵢ, f, argtypes, rt)
+        if effects.nothrow
+            exct = Union{}
+        else
+            exct = builtin_exct(𝕃ᵢ, f, argtypes, rt)
+        end
         pushfirst!(argtypes, ft)
-        return CallMeta(rt, effects.nothrow ? Union{} : Any, effects, NoCallInfo())
+        return CallMeta(rt, exct, effects, NoCallInfo())
     elseif isa(f, Core.OpaqueClosure)
         # calling an OpaqueClosure about which we have no information returns no information
         return CallMeta(typeof(f).parameters[2], Any, Effects(), NoCallInfo())
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index a5790c052e24b..c02c76c25ee98 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -2537,6 +2537,7 @@ function builtin_effects(𝕃::AbstractLattice, @nospecialize(f::Builtin), argty
     end
 end
 
+
 function memoryop_noub(@nospecialize(f), argtypes::Vector{Any})
     nargs = length(argtypes)
     nargs == 0 && return true # must throw and noub
@@ -2680,80 +2681,146 @@ _iszero(@nospecialize x) = x === Intrinsics.xor_int(x, x)
 _isneg1(@nospecialize x) = _iszero(Intrinsics.not_int(x))
 _istypemin(@nospecialize x) = !_iszero(x) && Intrinsics.neg_int(x) === x
 
-function intrinsic_nothrow(f::IntrinsicFunction, argtypes::Vector{Any})
+
+
+function builtin_exct(𝕃::AbstractLattice, @nospecialize(f::Builtin), argtypes::Vector{Any}, @nospecialize(rt))
+    if isa(f, IntrinsicFunction)
+        return intrinsic_exct(𝕃, f, argtypes)
+    end
+    return Any
+end
+
+function div_nothrow(f::IntrinsicFunction, @nospecialize(arg1), @nospecialize(arg2))
+    isa(arg2, Const) || return false
+
+    den_val = arg2.val
+    _iszero(den_val) && return false
+    f !== Intrinsics.checked_sdiv_int && return true
+    # Nothrow as long as we additionally don't do typemin(T)/-1
+    return !_isneg1(den_val) || (isa(arg1, Const) && !_istypemin(arg1.val))
+end
+
+function known_is_valid_intrinsic_elptr(𝕃::AbstractLattice, @nospecialize(ptr))
+    ptrT = typeof_tfunc(𝕃, ptr)
+    isa(ptrT, Const) || return false
+    return is_valid_intrinsic_elptr(ptrT.val)
+end
+
+function intrinsic_exct(𝕃::AbstractLattice, f::IntrinsicFunction, argtypes::Vector{Any})
+    if !isempty(argtypes) && isvarargtype(argtypes[end])
+        return Any
+    end
+
     # First check that we have the correct number of arguments
     iidx = Int(reinterpret(Int32, f::IntrinsicFunction)) + 1
     if iidx < 1 || iidx > length(T_IFUNC)
-        # invalid intrinsic
-        return false
+        # invalid intrinsic (system will crash)
+        return Any
     end
     tf = T_IFUNC[iidx]
     tf = tf::Tuple{Int, Int, Any}
     if !(tf[1] <= length(argtypes) <= tf[2])
         # wrong # of args
-        return false
+        return ArgumentError
     end
+
     # TODO: We could do better for cglobal
-    f === Intrinsics.cglobal && return false
+    f === Intrinsics.cglobal && return Any
     # TODO: We can't know for sure, but the user should have a way to assert
     # that it won't
-    f === Intrinsics.llvmcall && return false
+    f === Intrinsics.llvmcall && return Any
+
     if f === Intrinsics.checked_udiv_int || f === Intrinsics.checked_urem_int || f === Intrinsics.checked_srem_int || f === Intrinsics.checked_sdiv_int
         # Nothrow as long as the second argument is guaranteed not to be zero
-        arg2 = argtypes[2]
-        isa(arg2, Const) || return false
         arg1 = argtypes[1]
+        arg2 = argtypes[2]
         warg1 = widenconst(arg1)
         warg2 = widenconst(arg2)
-        (warg1 === warg2 && isprimitivetype(warg1)) || return false
-        den_val = arg2.val
-        _iszero(den_val) && return false
-        f !== Intrinsics.checked_sdiv_int && return true
-        # Nothrow as long as we additionally don't do typemin(T)/-1
-        return !_isneg1(den_val) || (isa(arg1, Const) && !_istypemin(arg1.val))
+        if !(warg1 === warg2 && isprimitivetype(warg1))
+            return Union{TypeError, DivideError}
+        end
+        if !div_nothrow(f, arg1, arg2)
+            return DivideError
+        end
+        return Union{}
     end
+
     if f === Intrinsics.pointerref
         # Nothrow as long as the types are ok. N.B.: dereferencability is not
         # modeled here, but can cause errors (e.g. ReadOnlyMemoryError). We follow LLVM here
         # in that it is legal to remove unused non-volatile loads.
-        length(argtypes) == 3 || return false
-        return argtypes[1] ⊑ Ptr && argtypes[2] ⊑ Int && argtypes[3] ⊑ Int
+        if !(argtypes[1] ⊑ Ptr && argtypes[2] ⊑ Int && argtypes[3] ⊑ Int)
+            return Union{TypeError, ErrorException}
+        end
+        if !known_is_valid_intrinsic_elptr(𝕃, argtypes[1])
+            return ErrorException
+        end
+        return Union{}
     end
+
     if f === Intrinsics.pointerset
         eT = pointer_eltype(argtypes[1])
-        isprimitivetype(eT) || return false
-        return argtypes[2] ⊑ eT && argtypes[3] ⊑ Int && argtypes[4] ⊑ Int
+        if !known_is_valid_intrinsic_elptr(𝕃, argtypes[1])
+            return Union{TypeError, ErrorException}
+        end
+        if !(argtypes[2] ⊑ eT && argtypes[3] ⊑ Int && argtypes[4] ⊑ Int)
+            return TypeError
+        end
+        return Union{}
     end
+
     if f === Intrinsics.bitcast
         ty, isexact, isconcrete = instanceof_tfunc(argtypes[1], true)
         xty = widenconst(argtypes[2])
-        return isconcrete && isprimitivetype(ty) && isprimitivetype(xty) && Core.sizeof(ty) === Core.sizeof(xty)
+        if !isconcrete
+            return Union{ErrorException, TypeError}
+        end
+        if !(isprimitivetype(ty) && isprimitivetype(xty) && Core.sizeof(ty) === Core.sizeof(xty))
+            return ErrorException
+        end
+        return Union{}
     end
+
     if f in (Intrinsics.sext_int, Intrinsics.zext_int, Intrinsics.trunc_int,
-             Intrinsics.fptoui, Intrinsics.fptosi, Intrinsics.uitofp,
-             Intrinsics.sitofp, Intrinsics.fptrunc, Intrinsics.fpext)
+        Intrinsics.fptoui, Intrinsics.fptosi, Intrinsics.uitofp,
+        Intrinsics.sitofp, Intrinsics.fptrunc, Intrinsics.fpext)
         # If !isconcrete, `ty` may be Union{} at runtime even if we have
         # isprimitivetype(ty).
         ty, isexact, isconcrete = instanceof_tfunc(argtypes[1], true)
+        if !isconcrete
+            return Union{ErrorException, TypeError}
+        end
         xty = widenconst(argtypes[2])
-        return isconcrete && isprimitivetype(ty) && isprimitivetype(xty)
+        if !(isprimitivetype(ty) && isprimitivetype(xty))
+            return ErrorException
+        end
+        return Union{}
     end
+
     if f === Intrinsics.have_fma
         ty, isexact, isconcrete = instanceof_tfunc(argtypes[1], true)
-        return isconcrete && isprimitivetype(ty)
+        if !(isconcrete && isprimitivetype(ty))
+            return TypeError
+        end
+        return Union{}
     end
+
     # The remaining intrinsics are math/bits/comparison intrinsics. They work on all
     # primitive types of the same type.
     isshift = f === shl_int || f === lshr_int || f === ashr_int
     argtype1 = widenconst(argtypes[1])
-    isprimitivetype(argtype1) || return false
+    isprimitivetype(argtype1) || return ErrorException
     for i = 2:length(argtypes)
         argtype = widenconst(argtypes[i])
         if isshift ? !isprimitivetype(argtype) : argtype !== argtype1
-            return false
+            return ErrorException
         end
     end
-    return true
+    return Union{}
+end
+
+function intrinsic_nothrow(f::IntrinsicFunction, argtypes::Vector{Any})
+    return intrinsic_exct(SimpleInferenceLattice.instance, f, argtypes) === Union{}
 end
 
 # whether `f` is pure for inference
diff --git a/base/reflection.jl b/base/reflection.jl
index 19dd289efbebf..adbd20deab636 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -850,6 +850,17 @@ function isabstracttype(@nospecialize(t))
     return isa(t, DataType) && (t.name.flags & 0x1) == 0x1
 end
 
+function is_datatype_layoutopaque(dt::DataType)
+    datatype_nfields(dt) == 0 && !datatype_pointerfree(dt)
+end
+
+function is_valid_intrinsic_elptr(@nospecialize(ety))
+    ety === Any && return true
+    isconcretetype(ety) || return false
+    ety <: Array && return false
+    return !is_datatype_layoutopaque(ety)
+end
+
 """
     Base.issingletontype(T)
 
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 2160a716af689..f9593ab35bab6 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1356,3 +1356,7 @@ end
 @test get_a52531() == -1
 @test set_a52531!(1) == 1
 @test get_a52531() == 1
+
+# pointerref nothrow for invalid pointer
+@test !Core.Compiler.intrinsic_nothrow(Core.Intrinsics.pointerref, Any[Type{Ptr{Vector{Int64}}}, Int, Int])
+@test !Core.Compiler.intrinsic_nothrow(Core.Intrinsics.pointerref, Any[Type{Ptr{T}} where T, Int, Int])
diff --git a/test/core.jl b/test/core.jl
index 25264c689fcfb..7245b488624b0 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8083,3 +8083,6 @@ function test_try_catch_else()
     end
 end
 @test test_try_catch_else() == 1
+
+# #52433
+@test_throws ErrorException Core.Intrinsics.pointerref(Ptr{Vector{Int64}}(C_NULL), 1, 0)

From fb3e3871bd3ed12adaaf8d0d59e41222f602a134 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 21 Dec 2023 02:21:13 +0100
Subject: [PATCH 0475/1315] Fix small issue in EnterNode rename (#52589)

Fixes issue noted at [1] - not sure why it didn't show up in CI on the
PR.

[1]
https://github.com/JuliaLang/julia/pull/52527#issuecomment-1863930368
---
 base/compiler/ssair/ir.jl     | 2 +-
 base/compiler/ssair/verify.jl | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 289f643a84f3a..045477e615b57 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1422,11 +1422,11 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
         if stmt.catch_dest != 0
             label = bb_rename_succ[stmt.catch_dest]
             @assert label > 0
-            ssa_rename[idx] = SSAValue(result_idx)
             result[result_idx][:stmt] = EnterNode(stmt, label)
         else
             result[result_idx][:stmt] = stmt
         end
+        ssa_rename[idx] = SSAValue(result_idx)
         result_idx += 1
     elseif isa(stmt, Expr)
         stmt = renumber_ssa2!(stmt, ssa_rename, used_ssas, new_new_used_ssas, late_fixup, result_idx, do_rename_ssa, mark_refined!)::Expr
diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index 9eded81d9d84b..ca3b7c4b64894 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -200,7 +200,12 @@ function verify_ir(ir::IRCode, print::Bool=true,
             end
         elseif isa(terminator, EnterNode)
             @label enter_check
-            if length(block.succs) != 2 || (block.succs != Int[terminator.catch_dest, idx+1] && block.succs != Int[idx+1, terminator.catch_dest])
+            if length(block.succs) == 1
+                if terminator.catch_dest != 0
+                    @verify_error "Block $idx successors ($(block.succs)), does not match :enter terminator"
+                    error("")
+                end
+            elseif (block.succs != Int[terminator.catch_dest, idx+1] && block.succs != Int[idx+1, terminator.catch_dest])
                 @verify_error "Block $idx successors ($(block.succs)), does not match :enter terminator"
                 error("")
             end

From 0cac28ca752c825c6563c78821d266bc623570f5 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Wed, 20 Dec 2023 21:37:11 -0500
Subject: [PATCH 0476/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=2085f1e5564=20to=203c86ba27e=20(#52595)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 85f1e5564
New commit: 3c86ba27e
Julia version: 1.11.0-DEV
Pkg version: 1.11.0
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/85f1e5564d733c9b04199d3523aeef0607f564e2...3c86ba27e904807e13beb8cb0466ed70365b0b2d

```
$ git log --oneline 85f1e5564..3c86ba27e
3c86ba27e add `add --weak/extra Foo` to add to [weakdeps] or [extras] (#3708)
2e640f92f respect --color=no in Pkg.precompile (#3740)
cbd5d08ad Automatically add compat entries when adding deps to a package (#3732)
03de920b3 rm old manual handling of `--compiled-modules` (#3738)
314d5497b Use realpaths for temp dirs during tests. Fix SparseArrays `why` breakage (#3734)
a6531d4be environments.md: update Julia version (#3715)
a509bc062 Revise the API of is_manifest_current. (#3701)
60b7b7995 rm incorrect kwargs in add docstring (#3733)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5     | 1 +
 .../Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512  | 1 +
 .../Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5     | 1 -
 .../Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512  | 1 -
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512

diff --git a/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5 b/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5
new file mode 100644
index 0000000000000..3e7b0ffe63bd8
--- /dev/null
+++ b/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5
@@ -0,0 +1 @@
+5723739fcb31b88a2e2513c05bea2952
diff --git a/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512 b/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512
new file mode 100644
index 0000000000000..bb5ed6f7ae970
--- /dev/null
+++ b/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512
@@ -0,0 +1 @@
+265e293ee24eac484f45311019c22ada29db413e783fb9e8f3eb4c94925ea79557580839a6b1e6ea655d91c198e6e62043fcfd07da025ce3e03fb2379207aca8
diff --git a/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5 b/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5
deleted file mode 100644
index aa3fbc2f13b9f..0000000000000
--- a/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-7d9833fd8933f957c7060ff8ff61909d
diff --git a/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512 b/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512
deleted file mode 100644
index 6608a48614ed2..0000000000000
--- a/deps/checksums/Pkg-85f1e5564d733c9b04199d3523aeef0607f564e2.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-a4634d94c5136b59aa1683a5c82fd9d8cc0d27483c2042f60fba88ebf7ca54bb5c0c6244fb69054b89aa480742cce81e5e6e69905f07bd570ca61019896e6ee3
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 98a3e315c3a54..f7b6068e3768c 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 85f1e5564d733c9b04199d3523aeef0607f564e2
+PKG_SHA1 = 3c86ba27e904807e13beb8cb0466ed70365b0b2d
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 631e7ef6ffee377b87b4a156cc41bb25305a6c31 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Thu, 21 Dec 2023 18:00:25 +0800
Subject: [PATCH 0477/1315] effect: mark `Core.TypeofVararg` as
 `ismutationfree` (#52586)

Found in
https://buildkite.com/julialang/julia-master/builds/31309#018c7f0b-aada-4017-bb2f-44001593ac6b.
On master keyword call might taint `inaccessiblememonly`.
MWE:
```julia
julia> foo(; kws...) = 1
foo (generic function with 1 method)

julia> Base.infer_effects(foo, Tuple{})
(+c,+e,+n,+t,+s,!m,+u)
```
which is caused by
```julia
julia> Base.infer_effects(()->Vararg)
(+c,+e,+n,+t,+s,!m,+u)
```

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 src/jltypes.c            | 1 +
 test/compiler/effects.jl | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/src/jltypes.c b/src/jltypes.c
index f0f3b36951a2b..5bd5ec31185d9 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -2785,6 +2785,7 @@ void jl_init_types(void) JL_GC_DISABLED
     XX(vararg);
     // It seems like we probably usually end up needing the box for kinds (often used in an Any context), so force it to exist
     jl_vararg_type->name->mayinlinealloc = 0;
+    jl_vararg_type->ismutationfree = 1;
 
     jl_svec_t *anytuple_params = jl_svec(1, jl_wrap_vararg((jl_value_t*)jl_any_type, (jl_value_t*)NULL, 0));
     jl_anytuple_type = jl_new_datatype(jl_symbol("Tuple"), core, jl_any_type, anytuple_params,
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index f9593ab35bab6..0c95ca0a29aab 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1357,6 +1357,9 @@ end
 @test set_a52531!(1) == 1
 @test get_a52531() == 1
 
+@test Core.Compiler.is_inaccessiblememonly(Base.infer_effects(identity∘identity, Tuple{Any}))
+@test Core.Compiler.is_inaccessiblememonly(Base.infer_effects(()->Vararg, Tuple{}))
+
 # pointerref nothrow for invalid pointer
 @test !Core.Compiler.intrinsic_nothrow(Core.Intrinsics.pointerref, Any[Type{Ptr{Vector{Int64}}}, Int, Int])
 @test !Core.Compiler.intrinsic_nothrow(Core.Intrinsics.pointerref, Any[Type{Ptr{T}} where T, Int, Int])

From 34d1b7120fff7ee074f341c2189d30d632298a43 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 21 Dec 2023 19:15:04 +0600
Subject: [PATCH 0478/1315] Fix typos CI job for PRs that don't edit any files
 or do edit binary files (#52600)

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .github/workflows/Typos.yml | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/Typos.yml b/.github/workflows/Typos.yml
index f9fa20fff5d12..da5a6a550abe8 100644
--- a/.github/workflows/Typos.yml
+++ b/.github/workflows/Typos.yml
@@ -23,6 +23,13 @@ jobs:
           OLD_FILES=$(git diff-index --name-only --diff-filter=ad FETCH_HEAD)
           NEW_FILES=$(git diff-index --name-only --diff-filter=d FETCH_HEAD)
 
+          # This is necessary because the typos command interprets the
+          # empty string as "check all files" rather than "check no files".
+          if [ -z "$NEW_FILES" ]; then
+            echo "All edited files were deleted. Skipping typos check."
+            exit 0
+          fi
+
           mkdir -p "${{ runner.temp }}/typos"
           RELEASE_ASSET_URL="$(
             gh api /repos/crate-ci/typos/releases/latest \
@@ -35,19 +42,26 @@ jobs:
 
           echo -n $NEW_FILES | xargs "${{ runner.temp }}/typos/typos" --format json >> ${{ runner.temp }}/new_typos.jsonl || true
           git checkout FETCH_HEAD -- $OLD_FILES
-          echo -n $OLD_FILES | xargs "${{ runner.temp }}/typos/typos" --format json >> ${{ runner.temp }}/old_typos.jsonl  || true
+          if [ -z "$OLD_FILES" ]; then
+            touch "${{ runner.temp }}/old_typos.jsonl" # No old files, so no old typos.
+          else
+            echo -n $OLD_FILES | xargs "${{ runner.temp }}/typos/typos" --format json >> ${{ runner.temp }}/old_typos.jsonl || true
+          fi
+
 
           python -c '
           import sys, json
           old = set()
           with open(sys.argv[1]) as old_file:
             for line in old_file:
-              old.add(json.loads(line)["typo"])
+              j = json.loads(line)
+              if j["type"] == "typo":
+                old.add(j["typo"])
           clean = True
           with open(sys.argv[2]) as new_file:
             for line in new_file:
               new = json.loads(line)
-              if new["typo"] not in old:
+              if new["type"] == "typo" and new["typo"] not in old:
                 if len(new["typo"]) > 6: # Short typos might be false positives. Long are probably real.
                   clean = False
                 print("::warning file={},line={},col={}::perhaps \"{}\" should be \"{}\".".format(

From f2ae45fb57d2b82e536a1f57c2c28bb67b4357a8 Mon Sep 17 00:00:00 2001
From: Tortar <68152031+Tortar@users.noreply.github.com>
Date: Thu, 21 Dec 2023 15:40:06 +0100
Subject: [PATCH 0479/1315] Don't use `deepcopy_internal(xi, stackdict)` for
 isbits fields (#52597)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This gives a good speed-up in some common cases:

```julia
julia> mutable struct A
           x::Int
       end

julia> a = A(1)
A(1)

# before
julia> @benchmark deepcopy($a)
BenchmarkTools.Trial: 10000 samples with 209 evaluations.
 Range (min … max):  370.895 ns …   4.573 μs  ┊ GC (min … max): 0.00% … 83.23%
 Time  (median):     389.206 ns               ┊ GC (median):    0.00%
 Time  (mean ± σ):   406.474 ns ± 136.334 ns  ┊ GC (mean ± σ):  1.19% ±  3.34%

   ▁▁▆█▆▄▆▅▄▃▂▁                                                 ▂
  ▆█████████████▇▆▆▅▅▅▅▃▃▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▄▄▆▆▇▇▆▇▆█▇███▇▇▇▇█▇█▇ █
  371 ns        Histogram: log(frequency) by time        596 ns <

 Memory estimate: 352 bytes, allocs estimate: 3.

# this pr
julia> @benchmark deepcopy($a)
BenchmarkTools.Trial: 10000 samples with 964 evaluations.
 Range (min … max):  80.261 ns …  1.642 μs  ┊ GC (min … max): 0.00% … 86.97%
 Time  (median):     87.662 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   96.426 ns ± 77.467 ns  ┊ GC (mean ± σ):  6.20% ±  7.42%

  ▂█▅▆▁
  █████▄▃▃▃▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▁▁▂▁▁▁▁▁▁▁▁▂▂▂▂▂▂▂▂▂ ▃
  80.3 ns         Histogram: frequency by time         239 ns <

 Memory estimate: 352 bytes, allocs estimate: 3.

julia> mutable struct B
           x::Int
           y::Float64
       end

julia> b = B(1, 1.0)
B(1, 1.0)

# before
julia> @benchmark deepcopy($b)
BenchmarkTools.Trial: 10000 samples with 153 evaluations.
 Range (min … max):  699.569 ns …   9.972 μs  ┊ GC (min … max): 0.00% … 89.92%
 Time  (median):     723.804 ns               ┊ GC (median):    0.00%
 Time  (mean ± σ):   738.515 ns ± 222.079 ns  ┊ GC (mean ± σ):  0.93% ±  2.94%

      ▂▇█▁
  ▂▂▂▃████▆▅▄▅▇▆▅▃▃▃▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▁▁▂▁▁▁▁▂▁▂▁▁▁▁▁▁▂▁▁▂▁▂▁▂▂▂▂ ▃
  700 ns           Histogram: frequency by time          914 ns <

 Memory estimate: 384 bytes, allocs estimate: 4.

# this pr
julia> @benchmark deepcopy($b)
BenchmarkTools.Trial: 10000 samples with 956 evaluations.
 Range (min … max):   91.535 ns …  1.660 μs  ┊ GC (min … max): 0.00% … 81.91%
 Time  (median):      99.322 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   108.450 ns ± 88.399 ns  ┊ GC (mean ± σ):  6.97% ±  7.82%

         ▁▃██▅▂
  ▂▂▂▂▃▄▇███████▇▆▅▄▃▃▃▃▃▃▃▃▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▂▂▂▁▁▁▂ ▃
  91.5 ns         Histogram: frequency by time          134 ns <

 Memory estimate: 384 bytes, allocs estimate: 4.
```
---
 base/deepcopy.jl | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/base/deepcopy.jl b/base/deepcopy.jl
index e0cb6c5e781fa..d2e675dc53bf5 100644
--- a/base/deepcopy.jl
+++ b/base/deepcopy.jl
@@ -65,7 +65,9 @@ function deepcopy_internal(@nospecialize(x), stackdict::IdDict)
         for i in 1:nf
             if isdefined(x, i)
                 xi = getfield(x, i)
-                xi = deepcopy_internal(xi, stackdict)::typeof(xi)
+                if !isbits(xi)
+                    xi = deepcopy_internal(xi, stackdict)::typeof(xi)
+                end
                 ccall(:jl_set_nth_field, Cvoid, (Any, Csize_t, Any), y, i-1, xi)
             end
         end
@@ -76,7 +78,9 @@ function deepcopy_internal(@nospecialize(x), stackdict::IdDict)
         for i in 1:nf
             if isdefined(x, i)
                 xi = getfield(x, i)
-                xi = deepcopy_internal(xi, stackdict)::typeof(xi)
+                if !isbits(xi)
+                    xi = deepcopy_internal(xi, stackdict)::typeof(xi)
+                end
                 flds[i] = xi
             else
                 nf = i - 1 # rest of tail must be undefined values

From a1a9ff4b5ab267cc3ed5034debc5d4efd3b98edb Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Thu, 21 Dec 2023 14:02:45 -0300
Subject: [PATCH 0480/1315] remove duplicate increment to freecall in
 jl_gc_free_memory (#52598)

Probably a typo.
---
 src/gc.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/gc.c b/src/gc.c
index 04004f267d01c..d703fb9d26218 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1226,7 +1226,6 @@ static void jl_gc_free_memory(jl_value_t *v, int isaligned) JL_NOTSAFEPOINT
         jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - jl_genericmemory_nbytes(m));
     gc_num.freed += jl_genericmemory_nbytes(m);
     gc_num.freecall++;
-    gc_num.freecall++;
 }
 
 static void sweep_malloced_memory(void) JL_NOTSAFEPOINT

From bc979ae8e077127853caada895d174729cc3431a Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Thu, 21 Dec 2023 14:12:24 -0300
Subject: [PATCH 0481/1315] expand GC developer docs (#52340)

The previous GC docs are mostly stale now given the recent GC changes.
---
 doc/src/devdocs/gc.md                        |  85 ++++++++-----------
 doc/src/devdocs/img/gc-tiered-allocation.jpg | Bin 0 -> 354128 bytes
 2 files changed, 34 insertions(+), 51 deletions(-)
 create mode 100644 doc/src/devdocs/img/gc-tiered-allocation.jpg

diff --git a/doc/src/devdocs/gc.md b/doc/src/devdocs/gc.md
index 942535f426b34..2f75e4d911f69 100644
--- a/doc/src/devdocs/gc.md
+++ b/doc/src/devdocs/gc.md
@@ -2,77 +2,60 @@
 
 ## Introduction
 
-Julia has a serial, stop-the-world, generational, non-moving mark-sweep garbage collector.
-Native objects are precisely scanned and foreign ones are conservatively marked.
+Julia has a non-moving, partially concurrent, parallel, generational and mostly precise mark-sweep collector (an interface
+for conservative stack scanning is provided as an option for users who wish to call Julia from C).
 
-## Memory layout of objects and GC bits
+## Allocation
 
-An opaque tag is stored in the front of GC managed objects, and its lowest two bits are
-used for garbage collection.  The lowest bit is set for marked objects and the second
-lowest bit stores age information (e.g. it's only set for old objects).
+Julia uses two types of allocators, the size of the allocation request determining which one is used. Objects up to 2k
+bytes are allocated on a per-thread free-list pool allocator, while objects larger than 2k bytes are allocated through libc
+malloc.
 
-Objects are aligned by a multiple of 4 bytes to ensure this pointer tagging is legal.
+Julia’s pool allocator partitions objects on different size classes, so that a memory page managed by the pool allocator
+(which spans 4 operating system pages on 64bit platforms) only contains objects of the same size class. Each memory
+page from the pool allocator is paired with some page metadata stored on per-thread lock-free lists. The page metadata contains information such as whether the page has live objects at all, number of free slots, and offsets to the first and last objects in the free-list contained in that page. These metadata are used to optimize the collection phase: a page which has no live objects at all may be returned to the operating system without any need of scanning it, for example.
 
-## Pool allocation
+While a page that has no objects may be returned to the operating system, its associated metadata is permanently
+allocated and may outlive the given page. As mentioned above, metadata for allocated pages are stored on per-thread lock-free
+lists. Metadata for free pages, however, may be stored into three separate lock-free lists depending on whether the page has been mapped but never accessed (`page_pool_clean`), or whether the page has been lazily sweeped and it's waiting to be madvised by a background GC thread (`page_pool_lazily_freed`), or whether the page has been madvised (`page_pool_freed`).
 
-Sufficiently small objects (up to 2032 bytes) are allocated on per-thread object
-pools.
+Julia's pool allocator follows a "tiered" allocation discipline. When requesting a memory page for the pool allocator, Julia will:
 
-A three-level tree (analogous to a three-level page-table) is used to keep metadata
-(e.g. whether a page has been allocated, whether contains marked objects, number of free objects etc.)
-about address ranges spanning at least one page.
-Sweeping a pool allocated object consists of inserting it back into the free list
-maintained by its pool.
+- Try to claim a page from `page_pool_lazily_freed`, which contains pages which were empty on the last stop-the-world phase, but not yet madivsed by a concurrent sweeper GC thread.
 
-## Malloc'd arrays and big objects
+- If it failed claiming a page from `page_pool_lazily_freed`, it will try to claim a page from `the page_pool_clean`, which contains pages which were mmaped on a previous page allocation request but never accessed.
 
-Two lists are used to keep track of the remaining allocated objects:
-one for sufficiently large malloc'd arrays (`mallocarray_t`) and one for
-sufficiently large objects (`bigval_t`).
+- If it failed claiming a page from `pool_page_clean` and from `page_pool_lazily_freed`, it will try to claim a page
+from `page_pool_freed`, which contains pages which have already been madvised by a concurrent sweeper GC thread and whose underlying virtual address can be recycled.
 
-Sweeping these objects consists of unlinking them from their list and calling `free` on the
-corresponding address.
+- If it failed in all of the attempts mentioned above, it will mmap a batch of pages, claim one page for itself, and
+insert the remaining pages into `page_pool_clean`.
 
-## Generational and remembered sets
+![Diagram of tiered pool allocation](./img/gc-tiered-allocation.jpg)
 
-Field writes into old objects trigger a write barrier if the written field
-points to a young object and if a write barrier has not been triggered on the old object yet.
-In this case, the old object being written to is enqueued into a remembered set, and
-its mark bit is set to indicate that a write barrier has already been triggered on it.
+## Marking and Generational Collection
 
-There is no explicit flag to determine whether a marking pass will scan the
-entire heap or only through young objects and remembered set.
-The mark bits of the objects themselves are used to determine whether a full mark happens.
-The mark-sweep algorithm follows this sequence of steps:
+Julia’s mark phase is implemented through a parallel iterative depth-first-search over the object graph. Julia’s collector is non-moving, so object age information can’t be determined through the memory region in which the object resides alone, but has to be somehow encoded in the object header or on a side table. The lowest two bits of an object’s header are used to store, respectively, a mark bit that is set when an object is scanned during the mark phase and an age bit for the generational collection.
 
-- Objects in the remembered set have their GC mark bits reset
-(these are set once write barrier is triggered, as described above) and are enqueued.
+Generational collection is implemented through sticky bits: objects are only pushed to the mark-stack, and therefore
+traced, if their mark-bits are not set. When objects reach the oldest generation, their mark-bits are not reset during
+the so-called "quick-sweep", which leads to these objects not being traced in a subsequent mark phase. A "full-sweep",
+however, causes the mark-bits of all objects to be reset, leading to all objects being traced in a subsequent mark phase.
+Objects are promoted to the next generation during every sweep phase they survive. On the mutator side, field writes
+are intercepted through a write barrier that pushes an object’s address into a per-thread remembered set if the object is
+in the last generation, and if the object at the field being written is not. Objects in this remembered set are then traced
+during the mark phase.
 
-- Roots (e.g. thread locals) are enqueued.
+## Sweeping
 
-- Object graph is traversed and mark bits are set.
+Sweeping of object pools for Julia may fall into two categories: if a given page managed by the pool allocator contains at least one live object, then a free-list must be threaded through its dead objects; if a given page contains no live objects at all, then its underlying physical memory may be returned to the operating system through, for instance, the use of madvise system calls on Linux.
 
-- Object pools, malloc'd arrays and big objects are sweeped. On a full sweep,
-the mark bits of all marked objects are reset. On a generational sweep,
-only the mark bits of marked young objects are reset.
-
-- Mark bits of objects in the remembered set are set,
-so we don't trigger the write barrier on them again.
-
-After these stages, old objects will be left with their mark bits set,
-so that references from them are not explored in a subsequent generational collection.
-This scheme eliminates the need of explicitly keeping a flag to indicate a full mark
-(though a flag to indicate a full sweep is necessary).
+The first category of sweeping is parallelized through work-stealing. For the second category of sweeping, if concurrent page sweeping is enabled through the flag `--gcthreads=X,1` we perform the madvise system calls in a background sweeper thread, concurrently with the mutator threads. During the stop-the-world phase of the collector, pool allocated pages which contain no live objects are initially pushed into the `pool_page_lazily_freed`. The background sweeping thread is then woken up and is responsible for removing pages from `pool_page_lazily_freed`, calling madvise on them, and inserting them into `pool_page_freed`. As described above, `pool_page_lazily_freed` is also shared with mutator threads. This implies that on allocation-heavy multithreaded workloads, mutator threads would often avoid a page fault on allocation (coming from accessing a fresh mmaped page or accessing a madvised page) by directly allocating from a page in `pool_page_lazily_freed`, while the background sweeper thread needs to madvise a reduce number of pages given some of them were already claimed by the mutators.
 
 ## Heuristics
 
 GC heuristics tune the GC by changing the size of the allocation interval between garbage collections.
 
-The GC heuristics measure how big the heap size is after a collection and set the next
-collection according to the algorithm described by https://dl.acm.org/doi/10.1145/3563323,
-in summary, it argues that the heap target should have a square root relationship with the live heap, and that it should also be scaled by how fast the GC is freeing objects and how fast the mutators are allocating.
-The heuristics measure the heap size by counting the number of pages that are in use and the objects that use malloc. Previously we measured the heap size by counting
-the alive objects, but that doesn't take into account fragmentation which could lead to bad decisions, that also meant that we used thread local information (allocations) to make
-decisions about a process wide (when to GC), measuring pages means the decision is global.
+The GC heuristics measure how big the heap size is after a collection and set the next collection according to the algorithm described by https://dl.acm.org/doi/10.1145/3563323, in summary, it argues that the heap target should have a square root relationship with the live heap, and that it should also be scaled by how fast the GC is freeing objects and how fast the mutators are allocating. The heuristics measure the heap size by counting the number of pages that are in use and the objects that use malloc. Previously we measured the heap size by counting the alive objects, but that doesn't take into account fragmentation which could lead to bad decisions, that also meant that we used thread local information (allocations) to make decisions about a process wide (when to GC), measuring pages means the decision is global.
 
 The GC will do full collections when the heap size reaches 80% of the maximum allowed size.
diff --git a/doc/src/devdocs/img/gc-tiered-allocation.jpg b/doc/src/devdocs/img/gc-tiered-allocation.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..4ab0e1298364cb755953421e89a574bcd8b6cfca
GIT binary patch
literal 354128
zcmeFZbyS;Svo9J55IjI}Ek%nKYw^%htdt@xZl%y-1&Rj^#i2L_THK+y1$Qk_T#H+A
zNzecRZoa+GK4<UmkA38>eeYfC_GP`SmE^UV=QlIY{AQl_ZuV{kK=wjWMG=674FF(a
z{s4FL0C@mD9v%n}7as%y5fI=L5>t{86A=;9QQQMlGSRazGto0L-e(u!y8nQWjggW2
z$wR(JLZYIgEL;*Y;=<AbBBH|oxCj;j0Rb@)F)axRtuQMitMLE!cGnId$0y(>=mugv
z0AQ120m-rMx&bVh=fuVOmksdWHY{u)4lW)DpMa1Ea{!zSfQ<zNV&edDadB`kNBdxY
z2jGz7Qm_g=#k;3z272H~Df~G$3!m*-We1hk7=m5oos&NSAvFyx9X$sp7xzORQL)EQ
z#3dx<pDQRTDXYAA{YG0yS5M!-+~WNQODk&|XBSsDcc_PFKwwaCNN8AiT>RIB#H4TE
zle2Sj^YRM{e-u?!*T8G*>Kht6ySjUN`+oKhj89BXP0!5!o?Bg8-}tk+wY{^8JU%%+
zJHJ3(Uj0KZECBFd#lrmmSHb>CE^>@q*f=;q9MC`H!oqgP>_BoHTvj1Gil>?&Gsk-m
zgg@g`K8ww&>>ywh(LzwYa~dP0W*1%MK>kCtf068eO)&reBgy`|VE;p|IRG&b3p02?
zasUKyamAhONBDRDtAoE7_=|zR82G=3fz4*KHRS5^i9{KJJ*~#J)DGO12953@{^cEG
z{!hL#cYxTs_Kb5Xha1XCEEY5$m>f1HF#|c;fUPV2hfgM-6#yQ0fdBB_-y{C&<KNKo
z7axDE;jcCPwT6Gwz+Y?lYYqQ~g}<@k|21ovyaU`jBLdag>2}cfM3zkSVbv#$7A3vS
zX>0N1{{*AH18itj-vKI0Gj1cPmNc*wDF5#NM>?QNC`KhIjxw_rFZWqgA>v*U_NwQj
z?LhMqnIr~0k-_jhn*d4Q0!ufrm&dgFhMGwxb~tw?c0Gjo4)Ak+Mg5wv?l#=!h&KRv
zgpO>*!3;?;Y&$=b^tk$7cQR#i$hoJjfwReFFr@lRuCN0m)qLt!R6>C%lWok>9O|OS
z<Uu8*c?{m0dJX)v!g9UMeFylg0h)!I9A8bmg4-7F74q9nFyy7ng$jQXR%fzKHp#*(
z&HcUmxbKnivv@_=@3;83t{X6BLCeYE$dzl(n}e~qt96zxN}KL`2VEH`T!806aGqJw
zd`hI``P?yC&&$N)l5qTk1a`|<o#K9&CG3*(g5{h%=?)+l)xw~FWR6}F|B#|I$=V!6
z^PBCt6IJ8NC|({_QYk8039;DhPCuMQ@>RIC+v64Ru}JhleRQM=&lh=w!k@_6qK{`@
z2@&nF4f=G_?JPK6AN*tlOR2iO1(BSw#n2~86D4rkGQp3h+tiyJ>@^nLAV{d#k22JC
zXDfaE<Ez#>TZc~)k2adhr`}LN$mN)rsD`&?r4e;uTaT|~;dailA{!eyu?s<O3DCHX
zEKJS1)CsFJ;~&q=ZHtDHmBC!RY;x|vpZm%^0M8N4SOupgY>Y5vQ2T-9my@iG$pgbU
z4ay@zl`jD>Du;pm8E>CeQ{n}m6y52A(nFzmQq{&A?Wb(WOwy?EzEN-8OjJ5oyuuWJ
z`7@uh$kz8)KRQ@Kf56pXDq|n2L$q4M=T!Tpi(O+**bt8(LYJd>2~<P!NKmIc{T<+(
zQSzX8R|;K;&xLzsM-rL46#-0cVF?#iX@1HXz?=uPsf=hT<bu*JqC-Wo%KrtnP6h?t
zN4QoqrIuc64A1Ld!{cPe4`c%~@3WM;(Cbtd*e3FN<t=r1eC)$kHhMIYbt>EIM?IoF
z0jDbn9@Kz0Breweig{T!#;iyS>{vNF6?1CVT}eVmEtA~=_AX(k7H7K#N8vRr#J$m_
zHnr1+y_y!Vw2(s0el#xN<C`bCZqtuPoIM<=TAIxT`G(1L>(~*z-^N?HP`n1ss;Vqx
zbIpft*~;_}`YIUO`_GGSMXSdJ(X54Ydoy;{c|XGixO50L>~Wl)9z{)JRoc2bc-b)x
z<syxq-XBoC7ox+Q8AYOIv>ak8hq&-NV6T{bvh5Z_t=eEH5ka9!0k}9&o0Mfmsj5zt
zIvk13D<2#tdE-zFJ=mfn#QJDKo~i*-Q+T(-EP%Le$sa1TPHrhVk0Bo7ylK_wby}^^
zZ8Op_&gcQ-?9#{WoG(47u}!oKC;g)%<M$3bqkR-){4WZ29$7CZQnL1Px%!jb^<FUk
z(=XI-E{I^m3PNN&XSDS`>UDP=%wk-u$@WWn_Pxd@4w)F7aRc+RV`8w_S4eYbSbUI%
z?Q^b!h6~WB(VqpNeiClbu3tD{->PKjUbg`xjGul>ankPS-Roc>*%vH|OiJsoZ5n%1
zvS#6jKfG|$s#57VKjp{<OkNWLniQPoAl=cRy%{yz0^8~FVJulgyvP*Bv@E~HzI<Ct
z#Tl12ve}fy2j{$lZ#PBQmDoP@D(!LupM|&2pzT)6i5mM#ZK<c@Dt?B>jYJz45%je_
zyaGjd%dExR0cIQF@b&wHih&`TyKh$gE_wj=nhKV-2Ionu^Q>OQOFfn!huJ7zd?F%K
zX35GVOwNcvi{zO2L~G5|TpOk%RX=4V?TYlR8*2WHe;(Jpi);+mc^%V!dVl7ZDbYbQ
z$r{n3&Q@>yQ^z8crJ&lVHA}5OQ7R0|{d|ric|Jg{FWzDWLtf^brPesf7Ece&KlH_=
zVr5+K$X$g4ma;3*GV5S4s`P^$_)YLhf8Vzv!m6z-o_5Ah9z~LU-5DS&nn=qZw&#^b
zSzX;JxfZe!WQ;84a!lG(DcPt1WhB-2#<4R7ui2+vqJnV+V<8$oku>S|$6ao8CRCf+
zf*JNIUXlr2<^szgJb>}+`pZ@xC_TyZ+5R<EA#uCh$R4aafHz57sm)%xAmSqUfVFYz
z%+}T_pCOy0jt*2*v{7+^?e}=Q!~u+|eu{i4teR~TW5NerDpa-@dHD|yP?`+jE~4+P
z%ipHPyVh<FAD?_A&ldvZ$}BN9T~i7;eYhT=Ia8Ybeah%TaI7EO{g}*ypAuV?Sd(LK
zT++<dW<Kg%ylC-1{vCxAQ*V|bzwHyrSzfy1N%FmEs{CL-a~L>s-zekhu1^raG`qgZ
z;fpV@seu}aikp-W$9oQ)xxIQ1JS*#GVvjVY6@G-P|LQ5IJ`<#AG~I#(cBa!cUJI0$
z&KoYcK8hTd{1<OlP#*2gb5311SoRwZpKN_8z#^4#UB3%v3kU~n7v?vWSPkz}QBwTs
z1At!}xhzwA6X34GVH5^*SiKrj1vlqdrqg~>k~|EmO}5v{hb4y(>g&GRN9m;sSDfK|
zvatbhXBRJ<8tf#Bm@NIOFq8}WlW@fol{<<X&YLtT%LbKKt$?>Q&6H{p<t<}r8K*fZ
zJ}cy+!?9#4R(*<;4O{d2P(S7><uyCHimttkpKwZ7TH^*9ga_~LF7-~UrZlYiF9|jL
zN$4z!)>6lAU`JK2NC@;4p%O=xUkP_~!j>)UZmfXS+21KEM<`S&zp&c_d9!}L^(6BO
z@1JSLxbSzPKDOGm)yo5XktY>rgu=>Kgn-{g7j@^JcGX79iygN1xj?>S91ZnX>QrHw
zsEf`euKH`)=+b$k1@i~Ynm>>J5o~zBp^$d~_M+?Crj9#6Ryg1k`XPK1f6M<(BHbHl
zCpJ7?En$2%fBYl$GFW@YvAVa|9pG)T=?x`(R0HeH=9J5x-7^M)Ga|k64|L&+o7%B`
z(nay{qo=3E32Uw5cYydPgyoHA`E7_8z)PFT;0~ZsJ-)xu+}0R8JtvfuXo+8Z#@WD%
z^lIl^@4o{C#x46gW(cUYT}&_d)?m$RYOl6cH&hs2dli1Du{fcIE(lX$#zw*E4uF75
zliUI1#iDOcVV!<bgayt;JJY(K42*54D~uKx<%z3#nnT1pe@I9pdz>rL8i?mrxsIr~
zp0uCZSkdgK2XD}ZxzHCEy|)Za({L4jxR=M9o%6l>nj#K3*o3L*StbR5>x^evTEPeo
zO=D1L%?wE`?dEsQJP9Bn!Nx{ZdUly^INItC5ce5zblVnv8yVc91Ebikoja9eyowOo
zjW63S{T4GUvEi$9jG1h4m$Zm<d&*XOcv<G}k}axRTnlK4WIU`=1g{lfet&^sl<7pr
z4CPKncoZmY^f%lHi$Gc`+q^8Q$mrm+riu4?dx<nj_wW6Ym#ij}i~(t$mJ8ivO22;F
zO6dTex6!-<Sf$iQ4i&{W4b1)$IY<jRE{zU3&meJ$lz`ij+RD3|S+v<VQ8Wqj5?6jq
zB~Fk5*#OSyc@tYvu`36Ur-wK9OySDql+8Hy@Al%Jyv3IL$;K5$Vh^+3$x)%NY^yaE
z@8zITyHCC^!{Gi>19y%$B4n-avw$FO5j5@}fL$FExxK`K8SKYSKi5?xju0*(eac(|
zsL>H<TRQ@yjLG4pI&;732iR(jF@ZTwsg;KW*e6Sid|pZ#Su$_@GKcg23t1Vr3Y=(f
z4UoJ7E9+BsKM;HJ1}Eyrij^3+0^{Ta#UGEqslE?6`doLGNg69=EUETFO-zhPr!CT5
zrs!9`HZ6!lB<7Kl{aTrB7|K_9^QI7f`OX!(tgfSr@$o%)_%c0S?*WurBDh+=<TQja
z+Kp;Nm9H2|b=eAr@e^mReCtxqyaP06mhZ_iB~Tf3X;e?~<uq3`2Jg;2{hCNaT8awK
zzI`~FGvy%KFJ@?U^fBw?@SXeIyJ$jpA!)1=!7VxZQ(YEY<m>jCq|RX$3jNET+Q{oz
zm2)>N^)2IICt+?tcKE=Iv|2XQ1~)~2ioYb`b|nEZa=Uv5@xy>5d~<VYcuqCt$C^KW
z?^dENVUdiAG~pl7qi|pRDf{v1iEf>IODXO5BxL5>M1CTwNYz^vSSW07tnFJSX`;-l
zPCM~kAyY${P(^2_svlphhF|Tk13_FeKc;ohJrjx+W*0kL?Yn~#34mFBARI>%?bYbZ
z#{_qPeR3c4pHkD$rpGTtkFNG0w-Gjg({SFjnP!hw2jY=)A9I7++6+3(^!4*$5dlkR
zu_Wk=3z$;zD0{bdCI!!!?W1J0RsjyUFq0(tVU-G_kaSgJt`(6;WxIxCoR=;WS5F4E
z0@Tj1yEgdcIuBj^?KRK=qvA9wD)=v&#Ic3BAx4C9R-E3qfAPEu&U4G%f&@^fol;k0
zw`roF>(L*=|LXBGNt46dN2MKBGbokEtmcN`lLJp^Kl7l@=Gqy()|$80?*QTJRfuL!
z{@{|glevxZjt=({-0B{3I!CW^*#W$WPrB?JIJ%GfD9L}g$0-sP<;1B-V;yP!Hr3zN
zDRwn?#hq%Rpw?q24Pj&??{PZ6+6tD|T~SlSoyv|^kLvD%iSh>!(*87$6Tfd+xufID
zGHWGi8E|0dE#`gEXwV!ivDih;5oRyPMCzphQde+JzKCw-T}_Fu-o09c!+V9z`rTQy
zHI&gdO95*wpl+mevOuvN^xjd4-AVb>D}1y9;G?E~V_93CRh)s+k7Wg$3nveqHTm00
z)Qa!BN>}x;bmB2MUPUVsx5S;>t&!XMF^eJ(K4^9nq_3boamK)JFd(%kd&p3%kEf+)
zB%IN$U4)5Z;s5Era?6iN_VO(60A_}e8+zX6GVt0mI$Q^KPKC+A$FiFS{?pU{XP5u~
z^Y1+H+YHO1*}?ZPJF20Q!CK`!je)Km9ji=mN-L{3e$#lev2N!B!(xTYr9O#d!3!`l
z+M(sFT(A<E5nki=+q!%=@tTzQ-Jf%RnK!Av31>%Nq}^AKaOW-?dyaE|HAGEAlC5RG
z>>PfQ+54j&>ML4}tZj59QX`yK+ogZbKKP{hTjv&Hq#=_e60%+p&G(6Y@@=yw`pM&d
z^yI@E+oFj(fVHufG>K~0wDVPp^_<{XfNt>QxsI+u<c3b7&hdiLz`S`lJKrxKzf5pm
z%^hIwN#_Nv;epia8uQ7b+;9k4`)z`3@wytg*MtM{@`~eEe6D0Q0g+)pt=2nx;dX4_
zz!|X>$nR@eovd}5)Atiuup8R-OTn$VrV(1bIqOzd6wK1xjtX95ki+Nr{Ij;w*F``k
z_<4DTG*x!b8idjN&Dfvb`33<t4D&!lw`}VR0wKyX_qu&4VErbjpgVwRJZwjP6mP3N
z(#CKZM>WUzkAtXfQk{!^76D%a+Pxf&S5cFJD)xSl1oo7k%<1W?<?E&A1WJ8}@!bLD
zU-ThODg`@7!frY1KkM6_9f)n#&50WZqzYY$JD=Jdp_x{XP>Q#pe!B;D4fPZGjTtiT
zKLb~;gXY?T03U9L?*PYYhmd_X!Q0PFmbb&E$AWvyXK2VN;pj~ohQdl&fXynJ-e601
zp+H6YJ0j3%xk-U{wUZPlpTa*78q(<iWt7=skK|||)`FLmHL$B&$Q6IF<$7<D*^{m>
z2QLhH-CI9rDVNbdvQQ8%le5oc%owh3n`7ybG|6+wx2mOaG*)vEQTt@}c93Qe{wB8f
zm0`4l=P66n3&T}`61m|Szl>}2S1jk%r69BShzpgb@%@thGu|N{iVGF&V0R&ZI;8(X
z>WNWbh&Om;8OXn}BsS$@tfbfQJ<l3W{md=nxswMMdwTP9e%P8`7K(xKisPX9DlIsW
zVK7|5J#1W>LbtF3RG#O!3__EyvQR;t)Eo?nifsj@QWEOZ!oH*nH*B$`rk<T=lEV6~
zlKiug<-unxKs7t6eO<XlBJK!B#9&Pn_SO+FDyP)Ft%ft{?GlJStEx`Yf1wAzK`8nW
z*Dtrjy@>dpPj>(s!De2EH9@e|5`Epo8nwuGfw=)OLb~q&t-&e3*BLKovVBK+3|GI9
zi5t$UoL_hP@eg0Y{BB7XY#Se^SzAJ{EQrVD34g@tXcP{8J~7LXzRED@MJXUo6dDkz
z%xp6s&8EcEUe@ei6msI{h0>D5#z(}@Bu`JS)gsF~2x>~150{R&tv@|Uz{#4G#Ql^D
zj8S>^$ZHaUD{Y!@V}e&Tw$T{Qr2dM8IPv(A4i9a@Td<}-)+yVL9AiO`I(Xh&Z2Huc
z9%VpP0kJ+7u*<r97w<nyD2|n&M<%`v6*E5%ic?K7#UK2zU!@`)Nfh8uKz<-`FqeXC
zGN?lupNFkPl3KJ(vNux<u-bL9)fD+FRSU`bIqS$uJ*z!h3B7mN2i5QaC2|8B5f`21
znAoW%yF2qzXOb^i=V0UA;U8r_MaKnX1nDC0GcfkH+pS1SPizPGR6dS$@ar1?EZ?J7
ze!41pW6*N>lx`=er;H-!R1Te&2I<P<;M2ZmB!G`IY2F`^Ofw;}Os}T3YIJEP_>+GY
z5PuF3A-@A)X^9+}d@(UcZauG`mSyPYud!p>xp?Tdo5S^1M+f5Po$=NRd-=034b)N@
zkq~ZTHLW`{L&ldRV*IQs?ibd5dl0~q(Y&CPD^QkU0V>jGke`#cti%#>^ctvs`GxJ%
z)Bg2<dhmyyk5HOkdi78=tC<JxDYo9hnEg9zfR*tZJYp&0D6pemBe>hP{GPW)%cu*K
z-`<6R+g;7KDNHcJ%uq_1@00k(!v}s6ZT_amQr_}+fbu_>;1)lf+KM&CC+%1SE$&P1
zP4ZxxfMq@P9%OVBfZ|AW*%@d0a?zEH{Ks=<BoKRw<Cp|+xm!0~EVc|To{!By_rU_o
z{jnUt|Je#LDaf}5;BC@`dhfo9@v-<PJ6}rscxc<Iv*wtbgNZflq@72k9gSzc2yC|9
zq}<MY+Em#bw=+>P9~3(7=i0SRMEy!9M2rM7JRAEcI_qlq<F(VgV!qz`>-r@7ObaZ3
zkCDo<0OPmI)s)X+qs)`Oib8S(@9zMd?aSx*@t1H-6#ohdktRZ|wWVYSVWX@2agSx5
z>_z4C2o0WM3(_~K>n$c#n9S_0!!?cydakY&GXv~r9c?>kyN!<Xldf{Wu^zgXGlCk-
z|Ee7=i?wX12^uKQj8OT5L`$__0ef6C=$b*RX^_>P;k^9qX}2djg4F%|+2o1DyMd2o
zFP286k(%Y`wAZki=-aWfoOKvFPR8<P8*=KY0a92o?1zJ~tZ3XxO{_n%S~@xD*AmAc
z+GduSulAwi9Y|rbvMe_^y6SQ)66i+=<B)J)R%rHxZm7}h&dfL^JpS8~ZY)CIlMFi@
zTv%4HF8J9c1wzmkR-?-8GNi5=C!wP%N^Y;U>Ou55M*05PTE#6Hs`%Bo?0r<7(xiZS
z-II&5^CMnd9oN_nqx6kOeWNp)$i5yO>Lr4VuJa25$08dCM$P%|`33GzJ)uk@5nwIo
zwiVD|jbDAuw3CRVYVx&u<78>h6XCDyjE)Z?$o-Vrc4GCD-I5SF9arp<AMzl<hXUCV
z{J)Zz-;Do6U50`9B!)pYTe9q&<tuHUJ@LNSAIpu?9vr2M_zOque`oq);q^J{Y!YR;
z+Sg^vLSkT(@xG!pu(O=wY@=x`N?3*1t$YGViPedgY#L)lU3<|4=5xt6!F>v|5}c^?
z{1`x39es7Lc-3{P)x%6#I7i`}?qe>zPMZrt*v}r@56c+0%MR-Ml1|m68J@=^ZaojD
ztr>ZsY!@gLs7OGDQ%Jj#!0x3}daz(h3bW!(Gt}l}Vl%GesblvpeD!N<ds}3imL9N&
zc1E;yc}52blBVR&S<eOK@{5)Bq^jNnX~qy3SumPs7@d__u56Zw3i{LcmevSWCvSc#
zK!x|_g1c9A&DP69TbakaS$#w$;b~I~2x+$p!(UaRQC)yll}kk@^|KyFQv#PCV#|J4
zn@QBtn0TKZ%@w&RHh;C|CvgV|)|JIcXBZ)eZoRH-o^cSMy>wrPM*6tLD5{K%Vnw``
zWwS9M9v7@Br$hlYD+6?E8?X(%SS#6I-iyn`ih7*tN-|`PW`HAfe&ncSVQ97qyf#az
zV*U*t_5|nK8Lfi*Q90PP-p(F~lg=l#^mZWuqLG%`jbFKDSKjEzLFrfx<CFpB=~lp*
z)9da@(Rst!UWzr!gs1zo*pM`ZA3OB+a2tMCRU+H@PaWO5<RFc%`;5%!jNyWsu(wtI
zltK6P*0ssG7Ul3BN1Ki3XM%B1SgSV-TH|N7O$P$Qo11et-eDht^m97>AIFJrrSk-~
z($*r~4_Hfgk~S45Ci#1QasTn2(p&G0ld^wb7IN;4X^w)KVEh+`w#g(^CxZ2lKnrf0
z)sOxCMA0zoJhTAHy?7C7(C@O>@<O>ZB36WgV1$i*C1^RqU82~ORF)R%td8&r8qUj|
zv!RdNCz3v1?5tX;UxdqJ+Njr~nx`@%lbMDa5aUQYHfzr6Sb<LN{`W?~ePenVon_u4
z$i##-2(ERj@dmGl?Z=o!xnW?=gCH)JMe(1qx4nMSM?LgL5JF#Gl$XxvQ}~2fnDm!o
z1+EWIxV^zIB`cUhPuG&xKcrvPbsyndhlzALP#V^Re$qBkD}g<*UM7R{!dTF{h`JCL
z6`eyFNpt>%(X^j_RWuup$3?z&QE=FrJ34V0a0i%q^N-xbPZCV)ErJLt?<zInl_4D_
zu;Y85%n%si(J@AZZF<D4Bq274zK76>EkkM8Hr|wYmUcMXeoP7&Qf7UHT~w>2wLHPN
zHPvi=2YA303frf{C^tK~{>U%mSk(@;x9M<0=qF()!#U9jsTqn4jwFLuwN<;t;iH~@
zOA7^7EYgaXyO&c>w{7f7L+$`37(ObypxinWEP%ShJR*Cm>D6_}WpW+jVzu^j0ZMkj
zPE{2?DaNo(?e*j6fxcdK!~w(ScDg<$$K)TF(Y#ghZacdGpNO>~E_x-^L#6K(7%BN+
z4>^2{U3`8F7?Ug{iSZ;A2Im1h4il_0NNyoLSvw_T+j9qP-}vh&D&tt}WupSYAIfri
zTCr-Tr9B+hOey!ML%PmmaiV%xn`?CXkV4}3YgKkqv3^qhGF((Z0?)&0CtYe!PFo1)
zEs`D%NH8D+mIYAESt^V=t~c<c$Tlk`c}1kpM1F=PoguH{*WN0!dxWG<FF#wZ$A<%^
zP(kj9a0h~2>gn>Vvh3Q!kMn9l?w6U~0WRjWT!4-B<fawDdq&&K)y<7f5^=Wp1<FJx
z{)~a3S!&=mk7+2qrJppxN}86G9q-G4*NyPFxhZT=YV{A}_F6rx)cAwF@DY@Ij>?+)
z@40K`06dS|(Mo^MpA1d`sLyiLvS27ssSS}0O);qo(Vje0VNXau!^zV1U}9in_gC2)
za%!WI1{Xk0d(v4ZU91#J)3e-)#Y(&ttJnnSls*PayY;oWLGYv<a+OwQy`_pwy3C5K
zquJF-CPKdm9Jfc#?!@8m3K?beLg=l1?;|ZkMAJBTrRw+X1LH^T*{kgjU<WfY0-U2w
zF$_Mq@4(k8drVr0X>0c2OhVP<<tyx7I=PW+3HFQ&1*6KOm4v9M#<xk&k{_iQ=&yr$
z(>EFzs!!RND)rk~Tzcy!rA5{}_<9zDzTRqYyll{FO7M@}o;ADloG~k~Vj+SXGr8KT
z33eS>y!QCoM<2*?V0jq3!2A^x7FehGU82JbwgOKh<quj}z8h@zbWsy_S-0N-{3=0{
zndKhkTqxHPl&K-I_6In)nZ?r9w%~{MG%J?(uNVMPjk)_TB^g}L9st#Vw;G1ce7`1m
zg^a({)io;UUcTfsd4TaWbdUtVCm60T%l0u!a=DwnC4xTa;P8m|K$%_doemF`yan+}
z>J=I9lio(-@-CKe6M7_G0R8XZHcsCJ`QKfdvpEHKo&rK}Nd3xeb5RUyiy|5bs{E)K
zN2NmR>vgDc`-f*e34St)q_R0XMt6X2uRRzuhOn&*I<?k0_{b$<GDxrxO7zeywpUx@
zmJehANLjNrf{v^We_mm8WH<QG;pkH6*u47fR=J)zDAJRpuk#LoYh<<cQkJnIiYeuJ
zWjFQv3ksk8>o}ji;ak=h-gL;WuBAs!O1A^)f)A{p#gW%mJ$BqKDLo3<F==pI^C6s3
zl5C!Xf1BuZIO!hH4yl#QFdG7RD0M6v>~+o6g`*i@pHAkjhS;a~VL?=(A3cG`wNey5
zHqo6hQUmn!Nq7bWG#_V@!?v23`UE|e4=_JY$Hz*LlXfj;!7s@}>V~0h*M2;JesmS#
zsKE_km!f9d&E)hMVgbSjVZ{9<C@#Z9DgGA>(}`l=Yr{yVbO_Z=>+#P>V&!OV1<|tO
zeBOdwVW&jmHKng#x_py~3k@h+0TcP*4?o@OdAfe!rcQA?tTWe*IyqEmNCE=t<88@N
z0S3zq&Bpn&s0VxU!J86rwdc8*iB89N-A{boqya$SWQMt3y4Y9&0z(H*S>_u*R1MVu
z@-P=2aIO_>>qU3^$;kf`|E~*KQNQGB#ngl=w99Y94Ys)f<y6Q%bgFv*WN!*~Dp5RF
z+~e(d2jF5_8M!($y&<&$?8-hskvC%u?TKV!B~@L>>G_F3sl@;RsRzf&=U!0lE3jBX
znUObj$cx0@oo30(eIEK=4iDW0(YLiQ`psMJpUFqPc0^s0H~Wd{OhSBt4zp!_F!rlN
zERp%SCLh(VWfET&YYLnA?JFY_E$YBmI8`rZS2&MVxaRyM%70J0HzMpS%|+<!vYR{E
zoB$SdEb>w5n@vm(ou;H{show~#*C1fP&@t^=gL~63^|aKIzSh6Ew$8Pz3M=|u=paT
z3%7HSx1n7DUxjP*lkMX@y)Wxr5uMAsk9Jy#$2S%zJf=At9gHX>*lsUh?|J}|R*ya(
zpxxIJkqJv*?DC<$1VROR@?=kiUUxl~MSy-BLbru5H4#b-TTq3T#hBW+JHV;aO#VDH
zy0g};($LV>Q~J^K&uozb>x4yk0H6%-FW-k`%e1%5F;DT<gz@hHWrK1=$ei03psu!m
z@CT3SQ`TF*%S3pxM7o^yEXBGMvw;t(7Xq*GXfeGPlMs5yMy9tE=0+H%G{>x58z~S5
z4n>O<ZlA1hERfKeqxqu~+JFHl4LsdYX>;3r^pkp|aZ><;KEXlt;sThD1$B@3R%`?f
zMx0nJ0m5%rSZZy?85-zXk*_<QPcPe66r1h)v?je(GofCq-u}vmSyO+a_NE?~c%02Q
znm}f$&a|7!4dxXbuyKOf@k1qfKKo&cnQ@q=6EM|Hwy4izLHv$lC9{u>5siVG{VtVQ
zyyZz;xQ(&LQ8Ga;t@lSoeHd1$8w9@R{r=tWn0rseu(Qyj+v75n@eGn?emj<N{Hg?l
z--j%>UlJQL=wSU!Q?Px~<tqU{>64W^K$kig71F*_g7W{hdv8&y4?j*9n>!|<(@&99
zo)MD~sjmf{r+Fa3atN6-#DuqCK^KD&phq`|9en*qTPe%jBmg0QtHS){EaMKK)Ne%7
zJ;+M}S~rO;-#Zstw4y=c7o3<cg?GGQj6QdYyj=5><o)eSV6uIXPv^q@?jihruuN4!
zeLO?;8JEn-8(9!EZ*>%{kh8Fu(xgTbF+BlH8%19N=Qn=d0X!S8Gr-;gHDmL-DK8O-
ziZ{z!q3b+d^Gxa$8`DZ%hNUb$SEOy6v8%j3c+>A~#p*--?XgH^xqC;IoCh^P>1dhB
zW|p!&`nvGe`!<hX+q^citAjTWJ`lhf9>-^k$z)DZGeD&|uTWLg&NNf~us-*^`MUkH
z5qga78J67!STHhPSul>HSt}9AYDG}Po~u`>VuQB%LMgK|0`-9G_!*pgQL9zFKTw|`
zUD3d~_IsV4kMn-0-+xmXMsDih#{RH<Uwk8@6z~RBx^6f)5|~V+Um3jK%}e{0wU_3t
zK)`M{IN!&%Zp@bwC9jG&H88qjid?@mvusEw8&{tF6OgW({*8^Q8~uLNo&#l@xtl2Y
zZuSmf(WuJt)%%NuD;*<NS_vhyjGE_%fOQ$LDPrGXs5R$f;^w0h0uJp*j85h0fnGP5
zd^6fx3bBjQJr9@`wc7Bw@8AE6Z;NZtf&c5heSDT6AD{`*3XIGUnsFX6?W)STXmzg6
zC>Y)P<4^uk7LWS6$(bB81i7WxX2^7}^UAxIYx?k|Q&sAFENw!cFXAKD@R=P`B5#Jg
z?H~DRc)i;=^XwOocn4VzdqRIgUYf%lO_}%Y4?=>`+I9p9qF<VSfj(9V$8QUN8!09{
zUF7ZYq^{1+FSYzJ2T$QVcT3P6JOjrc$1czVj@3b3TwNnk?k3=xWW_O8<%rQ|`|64F
zL;+_E`pygHGQ1+%h{d+>HtWdOsx8*C?PCfYlgfX*H}oE`5-@$ig@lw^Lp=|?J+7at
zmG5K@=I&5$3OPn64EH{bE|wzSr4e&@fq{F`3}mkdcKT8js~8Dcoe45Wx&K(y+fLNc
z)p_JGI%G!{*{UT>8{HBcJ8YYYQu2|_L6kqOZ-{C3r}^S2A+AD4bE>J+%86kQM36K$
z(0+8W;7S2Hj-O};@((6K>gu>fzFqP;j7+fEa6QueRYPThoBrHVMU=STHokdq`@v}3
zE8Z#IEp_}I1JiCucshry*!Rsw__sc5Gxi?5(S1Tcd~rFN&oho(qF7IQQrd!MOeoVt
zmBy0{BV*>7B$=98&FV$&&nYf0s+)!H9SLl<-Xt5WttrOoj7^GE_J4e9agEf2(5xUJ
zfoQOMj<uxQcf4}Xv1~r_AK%H1^}nYaVFmSZrQX=;J#zRByMG7x#U9;XDM$40%VI_8
z*fZ>inf>+0<)qTr7WG0F79imSEf@vQaxi3LmJ1X86fRB@tI;&sBWo<b^S4xMwPx;d
zbcBJBk^}m>NFLDoKjx}v*|DQ$ewMJaYjL>o>(}mITXw^q39NxgVpKZV&o--k`Jndm
zt4ldKsO8Rz{4}0Le6Bh_yRc&-@YhdRgadNxu}h5({;~oS4$b7YS!&LV^!ceK5BdMR
zEg7tjX=ly>fkvYp^&pJ!c^E}&^hz4Vo0iG^7JUmn!%q<hJVo6u5DBhP0X2X=YNW(y
zPkmLL(E6n2(cT2xudYTBo=n*sJ{6Yz@WX>!8kE5Db9xQLSwzhK?07$!$dhXm%cYTe
z$cvNZ2v6@;#wqE0YtU?ulGCu9V5gi+MIF;$yx_s<7JC*-D_wf-X|}17;f!jJ)B)_z
zN83KpqFDW?d+o_v0n(6CtG&`5_Se<5$=5^-TJj{nNJY?Gz=(i7JzoZd>1S_TOJQh}
z)@V5#LqKyR-^8YXGT%6<H;DJMpJ>dZUm`J)3cPM-(>uWHB?TDUsS{!&V5D&BV~;2z
z>th<SM6)4i{L%8Ov}Y|k;%CM>D(tr9HLv>mS);IwE@&k_Zi!+IK~pplE)c5bhdwL%
zZ==*}6_dVLGANP#3dh3({L%kB-^*KelOx)MgNRHltkqf9@KF>u*ie-2On*~gZD0SB
z(My*X3D!XLq4_chc6{mmd&Ncf>W8|1D;CqaCCD0;6U&*Xx0Tt}-sHTg>l&m05fv$_
z*B$0%lExd3iIy^~3bcw2Nlp)rjQz3p9ihlS*+_o{;!56-2A8X@X8f)-HX$ZBn1*r3
z#xUja6d?FW+zbv&3v8D0;SHkKd$xJT)W%CMi>{psR#p(c@Gg|n^NemtHGl7So1jAu
z{W*3f<G6RLN)5cxy?%n;tSFBhW2hDjg>9|IZgPJ9h=|NCfxo~S9?-&K9fP?_Umld_
z{Az1uHfp|ev^2n{_-B1>$R7;m%&k_ii`qZ;y*iunzK8TpDMT@kD8%h@yUK`*3LF0H
z&`)yY!C(#txUDqaFcNt+)fQfMs*Ypjly{iLzn!Q_WKYhN_l82|d)O(E(~s%;*~<$_
z%fQWQH>JeYB^nS81=)`g`>AE?HUc!ASvF^iK#--In_c22v`dZ6JaPHrYkD(z_^PjT
zdu?qiah-fZ_<rUUz`v!{Pg-?Ft3MB#)Z5CWV!XfaAVg+9TKqHcMp=7gyrs5TcNK(A
z5DaZQL*D_eWDU;$7C-+dwcr1`;;g?MPP`vCV8?_N$-ACvU^tiyeWhF`h^J$S#*1Rx
zPW#?+1@>LI=sAiI{Ly^Nh?wd(#QNIQ9B~3EV!hq^aVuD0@?^EI^FY0?&exf`W^C=F
znwxGSWFf-c!8f4ot(?RllavXvtnOiuy%^DN5%!aTOG2rprcaoTiJtdH&tn!;C|*|c
z2x&gBv^B3E5kDQ4^=}PAwp8o?F6aV>80d?<D4NS1bA2O&Q{`EwrLyBExmN29Lhvdf
zE)rnn-_DGc%>v)U#@1v9d@nETWeS0PXaYolDe`;N;d4p1IFD<iy<Y*h-^+Eb5Hi=g
z<4a@+>dz}F5MGrUW-nq@cfldP44r+MU=ZA;9RL6VT(H9d|I|fYcKlCm)_@~kA|-@d
zNamhoVrhYa=#$3y?*h5PO%CsRqH$s*xbp1B<QOl)n!&5fw5rye4Fz8cY8E##geK^E
zpUx>N0ZZ)`=DIvA#d7-_3399!pZ30qAn$v{W5W$(>GGu+m*&WSoR&S$;HC3*K;!4g
z2^p5eJ9RTXSx%JtDwxWKq|kKdfC-ZplqAo|)5YJcj%Ij&Xu_NvW*V4IXbiAwn_Zdn
z7?fg>=#JW@duj>d!b*u)PfwV(k#tQjFHkSorQUJ0{uIO!cJ=5EAhSC~iPaA^U2O|)
zX7X|L$T3i*tRtsQRgseX`cu3^wzIPQ76hffy)0|1&aV@gPv-Ub&BitBc128hin(W0
z%BrRR)@b%vR0xH>0{1uk4OgcX^2AT>PjJpS8<}1!Oq{ha8*{y`rP0yKREm1`N^aYE
zMgp)UF=VAF$JiEl%L0XUyf#+NHXOQVjH~bdYZ#xd59d007|GHp2!bYG9+iu31|Q0Q
z=YYrb8ePR+s9f~gHe~xrL=$<-AVvc8bH`4nqE>sS>tiG0$am^bnY*YQx@F16q~DyY
zml!YvSH<+>ak$L&F`{!VGxrR?YG4_mWeG<4(Z+(|=2d1TFYrCkTlXWgd=K4Dfp8bh
z`UT|yx)&8V<o;k!18(3j9OBQ6H+hu2y;C(;o%SoSn(`TJaRZ#$<9f@C=#5-8mfDx(
zk8q2**HF7rouOmi4|#1cse#8Fv`TWX%Y7~ZLjb<5pUkB&7D`z5!tN7)C--N*pwtW+
zzseGT*8Cxx<5keC8^<`vUy~1cbQL=xiyCql)d10%AqqN@?W5iEpXMl<HOa;QJRD;4
zd)kZMaKdVDUxP;noXW4VpcEpDYon_NkBNt0EzVaqNi|+y>l{#GMWj=Yts{OQ2IgXO
zzrAEu`u2O)GxGQ1@^p!n0dvM`3;nXnc;+L0!^7isfsx2xddJ=I{bD%^0JA$lCu=sC
zI)l;&)4}_Z7TpFJ^0u3=V{oo3fE&!z@Jn?!N?*My#!4UXX|*u>Edmc9eG@QAIG*jt
zvy<#v7M*WsJ+1lez%EBG`&mzIAuW(AUZ*hIPu2@lHj$y}x!USx;J4|we_;IVab%VD
zy42PmJts)H=jjnKnhOyU<dAsV^~&0TY*XUULYVeuk{Js#+F9e$VmVe%p48DB2f9_8
zipTvKP5s$kiL-H4?dw`BM+rCP>@u48Faej+J1pg-h2}D{AY|8LjVM{Lr9mXKsXG_K
zg%V`_E`K1;2+(St+LTzsTz+UV>NfMzj(m=mvp^HICb<LpY_s6U4+)_k7^BYmQGGqP
z%<;XpE9G=nwd<<sV#&)I4M_xXvVH}uNuL}B#dgl(%c17akqX)Kwgw+*Dp@(CJAz-H
z&2{1U;`vFJchkc<+ptj%T5aR;uj1b%&MB8t2@L&8S$yH2S#1ZDt}F1|X~o~3k$lp{
z%j(LYz`qdfS{aP5BW^k*2Z=P9kR?aas5BcEJAgYUSO>oUiF;dcGxHAe;-C;1iG*}6
z6F_SZ%Eg$T*sc5QeQ_6Rg0)1^UdJYz5}^eU8G-gan<)kM&6+{=_0DYN*A1(_nLy)6
zN`R&UC0594IlfgoSzUeI7(YpkJB3FTkhj&4cI4M9?ixgJnE6_98^!z_)l}K~@n*)5
z6P>Tg<M<k%o^2_eKa>F73|k1UH+iY4%=%81!N5VoZU4hay*ohDs4qY_b4-qwnHHfN
zf@ZNtS|z)<ZK|Ke#hEBwRrdGQz3?r@*n`20%Yn`9=pd|sY<fJ**p1Ac6su!v5_4%R
zldAy|CH02NMz!+`AyMHn<%I}*Hn!M~A`@oBVbZD{hiD7)LWfnvFxk(MehKMHPPkPj
zu>_hm+Xz)V-$OA+J#~;HqyR}?;aN>$aIQfd%(r0L%>f?neRqIMj$=$2Vgd4Ng3p%>
zD%IV}GA715NbsOBu5&TZ*81hU*MG|SBrO--CZDR=%1=lu6r_+C3<(^lf`lZ*e{MsI
z-KIx>&&k_5&_>~Fnn!{ZG#-IAxPg$aTlz6He*qB*b+44F_u<<HzOAWm$9=oDTs<&S
zX`ywAxOLqMewQzBdsb)06dwXc@-q<C6ecw2hTPsmJ?XL^|GmS@x1UEmBk=w$en&6V
zMC2!6Ix21T2GX8RJNW>yl*Y!xm!x84>2~s-pwquQHZ9ZfQddO*0PRh1Ms%&^HQCH9
zrI{7%t`3agB;`LOl@z+4kBo4RlGJ^&_60&>%PfTm3G@a#d^|tbRrG4$Cp`sJQFB}_
zXlrc5d45ix+B2BxY{Rv^DEEM6J+rrvN>{dksxof`-oJNfYuL2}#!!qw4_ro13;8Z0
zq{{SXJ!#(QMSsLB#QBp}n`OzLw?V#O_%hETT${K=248H;84W_P&wOyLYz$NB50=XR
zeYJ55-*M5vdzF-n0o_<6JgB8Mt)MH($<QWR=Yx6wPQU0fN>%y^rac%h0YiIL-T@*_
zCtdc`4As*+uW-|+U4Qebr9L`cYfwkMX$4~1o^2*>uVA-4eor8)e2C>6VtU<Mygm%i
z1-%34kDoz;mpG!jw5pq2Dq^bUhpVWVbAehIpO%MUxgpZYxWLr-k=mYps~8e~(Ca7P
zsVekc%a{IoZT{=-y#Nev+}4GuVwzARlRAg6kF+bzpvA&B*&v}NEa`6~QQ$QZlay5l
z9H>`Eg|sJUdW>|ciU`Fqq|$s?CWPuo?#^R+=I^8_`Gy?uREguYm#a>y%&i;AO>&g3
zb}X-EYIa0#bcT7GRAf)JBBBdVW!IBea!}wE@k8{9nafV<C5g*5r0=X;HQSGOc6QD>
zQBz-UzQ@jv@F0r&D^KA$cEd82w<Mx3B3B>oBQ7%@S?qj|cB3zgt?+8Iv4|TOidgP+
z0HI9I1WRfr_%|$thFn==vd%Q1pk=zU=x%1_32Dt-mAu{aO)m*L{TvEmi-6dH7|-cE
zO01Z=MsV=Q1JNI1M7*>IE6OXuYk#x@Z622|Nw7s&&c)wSj9@BeqaAs$m5;D>?XzVZ
zsBQO5<&v%BbDAXb-Us^Z{4tsFQTT`ITlz4>4{y*N;Mr8c%_-)65842GSf~DK+ZC;7
zIhrIIZ9|kn1ce#SoE}lCU@w>&^x~HOa;{xWjgbS{g1?=N7z|(_r@8{UqArCT72E;V
zic71i>LyCwR@H>PtF4QC7cRDq;aAaxK!zSn7?-xRW0YJBAAUEIz*DKhHe&SXU>{n-
zPqeb-Uqdw69PrXMC3JYhtAY44xX`pI!-=;AGj&LTgxoSrtWIaaE3DS01Ne^#HoE-|
zhw*$(n-_(qD`2Zi-WY~AlP?2Bhe0NdNf^eDETg%PLY7Z)<L>}K43Dz5mp_SS$g;U=
zO)4_^U6Yio|JwR~!pz`(e{m2fMsl;RFq2ruxs#qN^o;589pFukh|x}!M`9U=>+J8>
zsn}S5bj$P9OHfJA5r~LA`n=NUZzW@48-zvzA~nqQKUX}bOW#5>I!suQ;f9<oX6KbQ
zdR^Bu&zdTm4r6D4$C+Re)N3<PSSuSUqc7Ib!;N3+sd+;0nq$LF)Tqc2Yx&#ODVGC2
z)=9wwJDl&c_MCbb=4HZ)p5dZH!hMPpSre!8dIzPf4CdiNer-1}-!mmsM1Ig(&}Y|{
z$Gl_qdfn{oc8d|GY@-_37~}bOqlf9D53KHjoj$TQMKQ3TrdiNDrkJ%Xqi{@J)(2Bq
zrBeFmFXZSOr-N3PS*&6WF}X35^h*v!|CIxQ%rbY@Ejl*3QijC`gPLO>#s#tk%|&J9
z`|2a|g(3pdzgk^APRq2e+?g{jGMH0TQH~eKNlkCvEZ4wu3&^rwq94l~cPS*M*0BHY
zGnn+;33%i^H6&gNXGXEUg1a>rrvwP5;Tdo!QGBWaN>)NJv|GDwF)$Ro-0HV2_<g#b
zG2KGg**T$F89dNA$7`#n`_b`vmbOwwF=qbta4jSFmKqt+xvn!2VEnnpsB=?7Xj}Pu
zIm#v}M3w?7)kV|q^FF_3#xb=|Y%=&+$Rx1+A5%9<4IoFjL^d=}A?}G*S(Gp>X3g1J
z^WoNt<!1p`p!-dVs9f!)KX0(!$ZG26ef)AI3?3In+FKdN;L8VTQfh{_%hg}rjy2(u
z`vI^->QGAJLoRPL<;acZpL*DFz<&u1;S^~pZ)gk*c>04iO<bK3T<u9T!7F-3ow*xb
zRD(D-PD(4b;~4lYg5}1WpA-mW<ji80S`|pKu|TgXr7JJklZ(NDqRP^SkZ`sdHobHq
z#`w!}|153CIw?=?gSk3x%v!Ac@75(d?vi%s4~DAWemP~nYx;Ud#~2>+Y!qYDB-_(h
zuadC*2bSHF=-j;R-}NQ3r>m6Ga|6nFyYB#m-W+Q~PvIobI>yhCtzI6)?~(s4MZrv`
zBgStjQ6kC{_WPx$F7KN{yQHg{q$3IniC^j70>h^QI_5a)0#iDXb8Y8RY^;92HV!^4
zD6YA?a<w>U%F#}@QjhI7^DNQT!Fh9Qgyr6z(56MFbva5kEO<@MfkIA~iLJ@44PN3A
ziGLARG|s?{Qs-0IwS5&1Sd&&kBz4?!w|ea@N@O+1Y^s!62qnpufN-wY#k@L~Nzp<p
zTh=u`Vp@NKryCL?;><_yjrs@~t6^p)=e;vpRmsEWOHyB~lRn12$Vv#Q7uzaDu(jKH
zY~A?(c`b2_JF$Q3)n;&7#EqR66<@H^XkeY__DTL-sOH<}43E<@qb|23_L5f)Z*fr+
zyJuyJ8Pcp#>%>ope_Xl(XUR=s6#z~&EJSDq$Gkb~0);4ETNUDpPz&g+1nq(m(=R9!
zW&wnk;i$_9`Ht|8C%kB3PBrppcR=i@zXWJOCz2BD=QfN)T4eP=P<!GdKPPo#uCMl-
z^x^yr@gq{`YD(;gSY0L*riSQ^rB29ge_I_|&Hny3LNCtao%(A77Yz`24HD=}ij+B7
zHnAQeSqKqUvt^BFIAhDgAleFQxOx=qO+O?MonPWE@EG1*Vi6PlGCg4SU1K;m5ZvvH
z$+dLPAqOe)j^`4@G4FKMN*qT96g^4d4gZ*L=0N42kBZr;zMilne&YExShe6^^5klN
zWyZ>#@P+>c+T(BA`+rGWKX3c(6SS5P9hxo6$gJYEMt#KTS(y555T=#E5(!%qM)5wo
zrV0$Ww!g&pBYpXB^d~Il;)?#VtAiOlDebiudb&;5d2e%Zp-xuIGEp}76xaYU0L-Bb
z5yM-3$v={}yy^L?!8I?%g_&Coyspx_c6s*<iHOt$I*Aw<pa%zU<zjni+ckJd?kQ9t
z&ZF(}tSj*C_$O?*cYRc3`laJ{ZJ+t^%<j~BS~zi}H9lu|W)B1>E6M0b>u^m@6=9aX
z|LgMi(CN9tRzz=czV#FOjB~roWGnuk;F>I^o4w|2KWR*>4mBvWZ98=@<Kh^CslNXE
zPvvrdkNB&Pf3JbR`1ort|K=<HdWXN(@YfptTEo9-;IB3Of5aN1dnDV!yv@wt=P9k&
z84TXYE`3OMR|_v(NnN?pEyHlWlz;dCEgewBuEEG>QR-bYp2L}_VBDW_zSfL4lcr9v
zUU+|d|Bfjq`aR0u+iXp6|C*pW$9iAqK|xsV_PAG6*L?aZR^RSidii=Ajfy)Dyf>%t
zB?b5E+E-LGqgbEOdwY-&SzI`RE7-hJt;$p_OpptB)G7%+*Udz$JDYeQXjZpo?Pz-D
zav?iU2o?M><w#w+mHspPfccx<3!eXywCBIBkp7=9-u`>v|0ncQ;p#w-vV7M1*dV{o
z(%OkqC|v*1tPBajLDMJ$&3A+Y8y(5N11zr^GiMYU*whM{>KQ3H+CExjtV}H?O{E7^
zW8P3if0(ek_q=K9Xr-#o1ILzqsD}D}s?R6zAH57jbu&4pRw0{m2Y>|uT)*nP`mz=Y
z?*8DIW0N@3OVa8Pb6smGJ~9J3E|tiO!na7)C1AACpFIT-$IF4U8z3nCB}^x9RtBbj
zzpb-G4=smC%=02iNDAfSYWQBOM4_5!zReBH%?{s!3o@Z}l_ohVCSCU!Z0jpG<@vt7
z|A}MagD;9TI`&V(h~-VvOn+LO8>luM{=%-s`qP!|e)KzTY#Uxd10-|g>TGtr-el>1
z+&i7e-_L{D3aO$otF)y$SWZQD+AdHUm{$^fuv&UBhE|}g+P;cx*>`-TPfxQznciEr
zxHvznKjiK%Ebo9##}PY>%}vLC{mzf`pJgfCNtZ;_Ru?Lm<?q$%>N;%=20s)Y@>6NQ
z!iEt7wym-onwCSE$tTJ`R5v4W18E*rsyy)cG|*L<Ng5ZvaR*qngtFZR`#ibD@Q1ta
z5;(&+!UB4C>GWLgACmxN!+%aUzs`a>W*J+)sjU?8e|N8S5!LH>`V+m!drR%^581Yy
zfE^(+Nvpy~#?BT6yQ%Hmb4{Om*_WAHv)Z*k0>qwmu%xLM+E9CH2iDD8kk8L`im+EP
z@<go1pNV39_~$1Wnei2b%D)&rJhBt}qI&%;hm+UJVo>=8a84(k-X)6l3+;jmxe3T+
zA+fGD*J_QvVVyi7=8EtVak;Xb)Qv%NB8X7y-FxR>9rnLGU~h6bx&yd9@-bw*1|AqK
zqhEQuuVE?(O;fH?(Oq1Z+$=H7Q>R;j@C*P7_%yl;iHd$@_{HtP!JHi3=Jv)d8|^-T
z5^H;`H&(H-H$2pjrzipdlEam3c#3?|!R{xmo*xI>sVFP+BjlygN4keJ%Q!Q&mKV?I
zt37ad{{1}BXdUuR3<KEzIN)02a36?KrQw0VF>jL&hmKwfkMhciYLU&HZ`j+5xwHkH
z#6mgi_aC|0SDeo>iN5M$+9&_V6?CE^F(QDW!8->vk?+ROUDSo*XcnGr5Z?$ZZOJjX
zXd2~szeKzc(m_5>rDY`hz^DPzRd7OhD<SNLx<ARUsmZFme;fLRdr(Lm;43zXd1s`V
z&8;Y6I>75(M%SRax?zrGAo=CviP75x`F|SV;sP5T&;N_Pw+@TC@Aid<P?VIGMnP$i
zZU*E=N=l_uI;1-XLAnG46r`mYx>LHPL%LI7h8$rS-=EKZ_Sv_1pJ(sqefNI%xz0I%
z%*DmU@SFL@TI;jwvzp&%&iW3z3sj<;B=RP_BElz_pbXKP=4%Feu=s7ZU+sVGG?q`X
zWS64%3jsKLu-SmLO;GA`%mu~C(j}5jQwFXaw952>&sSsWG!xW&&v#C0C%t#%W;4lG
zM!9S&Mx%WHO73k?iRQHr-z-MaBV<*ZgTD-S3J~iJt}sMB7!alP*Ho0eK{~waCk(5J
z$d`XvU{j+}>$v8_(-*Ag|3r2q5NLt>^9={>G3T=%a-8BY+jBgWhvrJcdqY@vy$D~N
zrr+5{(F6!rM?G2WXVEq08>-^&c3{R(zJ5bzMt$V7J;EOP(mktf){-N-Yv?xSWpTuZ
zRv;te>U<;N)3hc}v8rSgV;uKq8MQc-GW7bGUzCr(NIzTZIKUdCZ-8RM0~?grH@=Uh
zR_jZAg|3V>Lb;s}%Bmmu0ir{wJZ(wtzw9IvI9ILtdOr@JDv?%iy}p>`WVRHKt)PxB
z)(}~P$WNw(+6~iTCo1@!baNs()iLRf{l`moS9M<`KG3CtY_92IT`z&=9FO411D6N{
zmyztztema`p1<Qykp)?fsvjQiy9`j2+UF^HYiYW~^#X-sO3skqH1W-ZHGAB>qydwh
zJvVpvr#QE=;@Ks49d%DYYI<GMohn#g^@nVnS2-kDR@|cHX7xyn9Hh=MUl?A0km@aZ
z!jUO~%GDu^j>;bV@*<tDimZn+fFMzH1Eeq4RIl!=awVYg?w>0(1s}|mtFbF3^zJgF
zpOQX*KFRK)FQIs)u*;?^2XC>`#jdBvO)o&NKm6?+2xQ?gA!1S<Q^`*%t-Kv#KTryp
z&OZ)713!)ZKD7ZN(PU%lEWOdiAj=fyvf=VT`)M|PxK;}zg3~jOxk)ikEV@nok8H*?
zPzHW(I2(Z$JSl_^r>k<ZIz>@5Sc*Q{N+9mjTY~Yx@2WR9Nc(_<-WQnc74C)o6^e9Z
zCpk5`GOr7gr!VVj#pzR@C9Kg#zkDS{7X;GH%D29lO3C=@Td59Q_&Em^0rU0)ajYG!
z-}X#HB4V`}qx0DSSxk}6Vjod(>`UJ+scj{jO3Y`24jHELv;Jh)Z*cPXDqY}V>Ak9I
zIO&^d;)Wg)D^A67A&_^xBn>}_#?68?2(D$)p-I7BqDGP&nq^KrE*b^3FEfVU^(XDH
z+e2O1nC)NX$?xat!}~*6J0?^C>Ni1c_|5p0J<9`r-^V!2roN%a0wY6_YezTBA=mD2
zF_gS>mMOHe=gGu==^Ls)a<LXFg}eRgzzLS~dNMY)9Gyq(4xK^kZbI0=Vi2mB*VLhU
zD!6Bnc+!5gylncL9cQknNw~1npkvw%kPDy+4>H%5u&o4-W|sEO04e$?PZGECZcQvE
zGXp>Tx3%ma+-s}}-&~Z5yZu(4s-V{lu;lp}w=IjIHk}PzA!KAz08t&G@O=i+{iR3?
zx~DN;D!|uQvq05JDI03LUN?Gri_19bOtgJ2poTXPL0RkVZJVd9<mo9QWs98@rzxba
zHjxZUyZ$BWa}aCo7Yi3!JINaflj8vz%%2AC+*F~HlBBsoqRHzHCuk=lkJr&hgtt?L
zQunaib7DUdqQBhq7qPykXp5d`%DB=O;Rc9?gLK&Fbl?VoD_@Ocv?gs|r5Wk)144yS
zKnifa{+ng_2}V@M_@TT86@tl1-vkre`aR2PG#z%qYR{~7QWInH1|a$KJ+@Y4Vtt>4
z)cZiDS8^n1cGs6MGA3rW((DKOx+5}_y3s3rFPcJ-CL5FvROW4vXmSX4#@v+RdpoeI
zB+M8U-tggx6c(l`)^i!B0ytaSGr9b<hvOe+{4*4UA2tA$$;C=0-Ly2Y(^(zsi>{o6
zj&4S+&3G$Td5Q~Dy8g=R%COMOpy(x3OBRy5(B*1%@7{y33TR;9@C2nDwAgBvG^}}&
z>t0n2F3AAfOD8XEP_vBFugc77dyxaEy9u?3!=uxzZcco#xPx=RTHmb%D4*-^1t6#<
zw=JB!Z8}MH7HCCNN%TxLiRMpw@ctu6ypMl;1Wm?hw?zQ<CB)}dwUXVJv7Hw`5%Fi*
z;QT-90TQ$+HT7byeSXEe_OI+1>Z(7u%d%SlVx;bCVKCMtZkeRhj3iSP4V?mvDo23h
z>1UwN)bg4t)S2Z9I{_1Z=#DDXHT0zNS-N-rYT={B-cP+#P12Vey?FcKhjtmtBsaTo
zP~XFP```3nN;%M5{ia%U`&Dt1)JyTfp&Fs=B=(*WP5GbJ)!IN5RuY@9_%eTQN?_X2
zNFF!tWfDDM><Rs(%JoOFvgzh?+1_icPB5!Y<Bwyxvo2EB%P<r8g1?k-dyyuZg+EGR
zvG3sn6JCjhPS-Aw^>vdZA{bf)A(UpHmB_aDrhZB~OEyn(+LnO_a8M33dgBO}a&F4m
zE=x032!EErU`*b;u2D+7pTehus#71c;R)(jG&ClO-V1+PX+-28;h)~#KnY?lu|8iV
zc;mA7wfIm>`sIy5&S!FIdOT&jcv9D;K|q+uGEQrTM<iH-=9V~~nT-L<NRtq(q`YuW
ztLpRn&f!{*yI;WEKMC!A#b}!`B|tlLrA_n03#tKEXNowoc?{5PIz2*wCOC*xQ*Gka
zNy=^eYMl4`(3hY-_7Lohk4}D{G=ZMOU&ZmIl>`9In!V3B*mNqJ>Sqo6gP+!nPE73s
zmWd183As5tuV@br<3ntQ^^5RjvwmI<M2ur~4r5l{pnW(V#su<g_ZMkkF4ngIiYj5J
zgKo1erB-HqVVn1#UdrpmrVmnrX0Q7bwI@(Rm8oxJmronR4<`F?0K3XaO>2q1PpYUs
zd2&V6R$47u2jx)pAM2k{mH)h1_L~yarvg3=jyIS%`=r#$o6l-f<nd*w-s|+i@L3>t
zxIwjQ5uhHPPHgo#FhFcYC2$oSXjgK-Hn20<CthKNkW4Mn*a3vJ#K_MIZwF`xR-iY}
zzv+}zTUa<(ffM-N+va6v;LTpsc3I=qRN^}AZ2J<MqAA+1xd$lv%dn{F^7+uL!-uE%
zhqyY<Y}|_sr7i3L;@hWlQpUG2_WU8NK+V~|VN+&|;;afjLy~O+2G4leN!!xoJGcSl
z3sux>;8>_Oqnxp)sZoBo_WKi%D<5c=Egnpa1XOd_$zi+R==Fm$vN8~ab=UjUh#1tH
zxx0L>=py-GjKvhb1Z=>jUCVtBiT(o{#dJa|fFPMcmfe;Uo9E*l-!@W$KYPlOG-f3J
z0ccqCC&j)NUCCG>=HWCZ8r2nX>hlr2`|P}t;h?X-onBR{1wb+zbdcbUw@_}J_Uac@
zWc#nEsJz8Wnbb*=0{rZT^U`%3ra>FCMu+ba0EhBLnU9^VsP>L_JX|HYbNj+H=1VO=
z&seW5@xX(V#Xwk0F^?^iwcm^a)0L#$M;@j(_DRhnN!gPopfK!-y!Z`Zr_{8(dLo;I
zS1!A%uEQdF)C;uw>w48i#5~WWcn5B{Q>(V1qnOTV8LeI>Cj?fNU6CZ)E)=P$&fOL;
zd^KtRva)8Lc<4h}V~o^=#`S$8jmh>Xm4uUwb!G2P)mHqG`AN&rQPral>Sk1^9Sx#*
z`0t>i+CQP9I7^J&tnkm10Hb0Q(bYFsai{*V9S{de#Y=w%hL{|X{WWc@{~+qLB*zSI
z|J{yw)j*4|>V}qAIH+94d`|@R8z>5J{Eng3`r8R;M6B8pcN#lqTf0rS{}SAw3R|tN
zNnG_L6Ec2$Buae)py)(0qbvL>53EBWF-=T`OEM-eOK0ZwpStysIBmQ?T~@`Cl_CAI
zODhh`jfZeVp;}FBU2k{B%0Hw~=Iy-z7}rU!q15p?J!wxHyrHHDc4GQC!RK%LpGeVm
zs$y1YXjHH2lXpbm*odSyhY!j{4qm#iQS@xGF<kT8hDMvDK6wN$%AWvGa3<R}8dkFm
zja){N+MS)vDOV&P9hnBql5#PYI22|V@S%xc`vT62@SdR4qLcD*{sFe40yGwqXJ*m=
z0}%1M!*PBBBJBl4@Sg$E2$tgYd*y1mcb_fuhL$Peyej&r*2Q#q6&-#biC1@#jp;G^
zXz_4W8I2=QLU}FBq>jg+JI;T};Q48>!}Aq&CZNe1gLwc%w5yZwKS4y+*AY?cCy(I{
zudAKPG1nr|fww_}4t@1Ck*26De?cHRW7Wdw!L#UjFR3%xNs)@g)#}NMzyLfza$abh
z-&vTGakgbu!Yrf}W-#jCeIkYFO3Lw1g_!><Lh_``v^3)<!x8Csn&f<xa@!fl;Uv#=
z<k`&<^xxSH#E!V3H=~;9mfex>z*Law=Rg;|fxpNwLUj=+BTlDkMdCo<CFg&P79+vg
zx>h<~JUY6Zy_4_DF&Iz5I;}t}ghx@kh-~CZZ`Hmz%Y)kRmm;C-%<e&E)G_A#y^!``
z7#$L^@B_503zRH-nUSCkdMJJt!3v<<uabKZy6}eRdtB0&`8A52^C%Zh4fvvtlI^31
zEV0=R_&m4T3IJY7UO?;PErY+q8-IX4*Zu%eHfJNLU~WN0v%84`Ni425^l=Yu5{>S9
z(^fC3N#1an1ppiP79vHreu`gIF{G((*3`7l49hx*n!tz+XowLTMv(~m{{U@u1JNe*
zC8W(r)q(`j=CRMWC&OlIg)Mc*B#u-PBMpgNEdz3HVTU~lThsNn<j*%t;P}{NEUaJ@
z8#unBSBhk|2P!&;qn1!NS`pK^K$Fh-8zgBKf^~LtNhVk;yUyY0_5-fCn^-zi6DNDV
zh6;`2_9OtQHwSKE9%d0Pt+#{q0twnC1eVzZlmSZ!LJ+`^kTo4YI)wZR7p_g>Z1)E%
zhor>IrW)^HBSDtuZD%I>LqKZ*S`m^GW>;IZVC_ET&f)5MFHu7`QB~`7*`)*(4mt+^
za&V=xwE?2Kme5s9St3kTWe*JWoS!X0WC#pNcvWHyw2cpHeOG2<@Htg^TB_f6iOsdW
z8E4MG1!E%=<zaS74^y*c7~RI6TD)Wo`f>ykOE)8R)*F4*B$KVTBNEO#tCz1$s#QRL
z$1BEx?QuBh=raBF62Yr|v-<j)y6{`7O>yFDLFyQc@oDc%KQt){L<zLI_<(I5v?M}n
z&=?ZkF%Z#S#M3l&rCNv;xR7=Hz={%?&)3I@=2QY=A+Q78LE!X6jGeO|_D{a<H!08c
zAsT@qGAXECL2A8zQSZX@Qz6<av~37R3k@BC6&Mz4{dVnnOUya*+WUKADBOAC?MLD^
zPM6Cu0j@ZgDRU8Q+2Wm0_BZ-MH{Qp2TqK_;Fk=jnFN0r`2I5c^2gah_0jFV*1XSkr
zd6WV@Uq~wm-a)lJU!^qpyI|oDAiekz?|3b`Ur*2AgAB+NVc+3pAH-*Q0%aA99;HZC
zpRXUFPE+CvMT+Km6v-sXPnvjgJTNnV;grYfBuu*sG-&*O$roXH9fo)aUbW;OpeMD-
zEE}QioAMvp^a4jN^Gh0l&buK~1o5&qqlFC>bWk3=qcYXZ3Y>ls(1dlXyt%e9pnqEl
zGlG@aW&P&!*q#Z^tWg<|BQPF9e+5FmyEN<7Ty>=HX+yT2`qq}B2V>WU{4WlEALoy9
z*k*+7C#&8*t5>(8^ds)vX7`j>pEM*vJXe56ze~0&CyCQ#%rYvtCtZh*#qc%Cc2ttq
z0tii0eTE#bxdV*~_9*@_55<-95F|0jL<1x7AJYm&TpxHP9&gcjx$;i{1-rx8dQyx$
z=+9)BKYI}d8rWa^@11w5Sm`^4H+?9wt*07N6H@!<XZtHUhnzZZVlhOYZj%6l2M+Zk
zLa206&R?_?*f>5|Uy-iR;|Z*O9F0}>(`o+Y+W^nIA<hQi@~RXio*`{psIgX-#;dm(
zM$U^BNbTij^6r|%vxW(t0TLn#2EzX5xKBhirGUEj^k3!u`3e`tw%_gGT@E4&V?`kH
zGWf1V;csgi9hD@lrn<|o#B-?9@NDW_wTZ~zL7|M*bHA+=sI&W3m!0%8V+4)(-9gB9
zcum%n=FaLpSSWue07yJfjtbUH@&V8jCd6T}d>B~0Z@j18T2=2|l(fXgF~H2UEuv2F
ztE@lG@&}?s;obc>a%gwjC_DW>zAbzNmeTtHifFo#fmr$mnR8I&nmPY2p_jwmYWHoe
zbb)kS?e_zl_ITb-DI3VQQ_N@iDg3q>uTb3MEk}^6L_Zq<jk1e($db=uTyqSw#i9ML
z64b-vB(ifHz`sj^qX88{eZ}zh9!uelKxL0xcyIA>W#pr_<!Kv0thSP4+Ei{>C#NoE
zx>`6*lRp<bigj8hGuDF7#RGv;X%7OFj~zgY&+!A)-OLjXl0?tP$XKm6Bm;Uo4x{Y$
z52}kia}sY2I=<gDZI4fz1p0-3yLz)879ErpZ>nDB>~J@^WzI^LY<y8MP<o{%N#S=7
zhDu+JBJyQ;5w%|VvA|W9Re1_mn08r{;P)GYMYm!Y>_-8!D|nclt*b&h`1bwXK2f0=
zh4N)U9NU5N-k~i7`La#eda@#0))BYc{hf>Wctu;7;ODbi)p;2+7sjxTOhIK&tozNh
zfbd4cRXXT!J$lrY6t!y76yJqDreHFql45iapP4rK{jxc)T;1&GpromZ$z{k%Z8_x7
zA0VucpjBz49MAISZc<sX<?6anIWsRMiPQNW!8!3ZbDlR^c4C_1FIK{~0uJ$`g{cn>
zbw}9qJ=3F?$BpM*$B3P32qQF&if!3LCm2ip?JG<|d6#PgPEwzZt5sFj>!!%Zd3-3*
z^6!_Tc3;=b1kA3Z1Oq~CMTOMn+3qY9+L`23Sj3~p6UqE}*&BO5|1T8W;Yk$hxbzr@
zOCzaib#<gHQKj8I+4?<Apj(ZA6d@`L&v_%DGr^;X%kw>-;cX^ffJlt7P269}Pckg&
zH6Irybawl#;+;ljv*QO`srB8w<A;=sEtMgvW%U(xm~D>4GW1xOMd$=z>F0lOQ8Kf9
z=wOhL>J(dDm8v?$M)L(K{*Fgjm@Z(Q!=KZml$=+v-iXOS^>$~Yayk~~%d9BuD5U7o
zM!eDV|H6tJgqfJ(r{>LR&7qg+{!!L_yAL}9ZFoc-xF{)b``0d9R1dOj928k+6S+N|
z-gSSo$TMtU12om|$^jS?f;ZYkZX%u*fg39=mSz*i$f;<ApEskCSei4t=Or`s!K-+x
zR_%R`y6vZey<zLd-_CBTG{lb>@w~lZLZl|a#*t=TDuLpFBKYnd4~gzZFM#1nVgiMO
z;L@D5J7pUXO{{PDkeiUW;m_W~6g{7OLdlFV2qa~G6-QQ~Ddsr7%lu5)k>~jt_?lhm
z1Y+WAx)D~VfJ}OuvQR{uKSg))@?`@^qkmr$c{_@13`zGXl~*=gZvQEibNX%lyd+lq
z38{(UNU@Jnmfj9!vgp@&TOwBBXKrOLd(Y9U{^|<N0TiADxE^42TSeKLG||M+cI_<-
zDtSzpUqB<!WKk;IfS_6S9;h!duV~;I+-Hb&S!4W|{IeN*C=)@tto1PZMMVRCBn4zF
zJzuy~9;mQi7gL9gcNp+atWLP5SZ&mW6QaN0GNr=c#m8!-1Sr^kUkg`93+*_PBTM>|
zm1C2eLn3p@M(BK34AXpaOlJ$lxR`EsO+wL=Bb~~k1X*S$5hpg|-!NK9Ai%NaBfQ+$
zcW|QXnU&~)tmS$71$#^UYOfd=(0(1!0a{+{SOvkf4CQ@R-C6@kV}y2`Wmvrv1`DR+
zQmjD;pj*2TNh^jyKH9|+MMXNp59aP?nx?)r!o|N~0)XS+5V^F>=(iI*%4vo1(YUd%
z0#Ay&LMeuyPeaw<ns4}GD0a%NE(V_|+LN@K5%#JcfJ)WAb=UqCX4z?CSf;^hy9omX
zk$m>dv&A&$xYmt3E!|^UNd_eCYD=^K@vIWvI9VX-vrvC*Aad^u<l4mo^!&05Brpws
zq&h<XS^L-qCsa?Kn1A3A*0$HQFR-%qy`@`C46FKfTbdJ4PTHgOf><C)K+UZ7`3$}C
zFP;X?ozdOV(a%k_&as8wle>@W^q4h>LL7l!-lV-8Mch52D-D%qFL*UL8oI#}Ac>VX
z*1-A~H@>0uHiAtCrVj0@iNGzFby$_hj7#dnpxMg=8oI5MZEMPN^ml5*hiqMmrCE!N
z5?%%lTOS|(W}by01U?U7Nx}RBz9vtr>!OdA+!Kc#25)Y#dPsCmI|A$bY`t{ThYD&v
zt&_T+I-svFX9mdPJ2G*P{TF{>6Qget%`P%C{10$n-%5rA12OTaPu20d0ak$i?AjRY
z^Pd@3Zoc74qKft5`tiF-kipX8mls%07ARR5YCIzcE9CSJ=rQ`v)O3M%RJX<~ZI1|<
z`Y~4$i>i9n3fA&xlJuv5jlBIAmW5&^J*b5o7F~K(@JUyNW;${7!1HVOcqGg(;VXbX
zJtq&_=r9eJ^bGX0^(jgoSef46`3xwTn1cNHW!cw+lZoAXtWMyuw4XqhEe>wjVULFx
zR}H?@sZG{iiRhE29`xsw-xlvHsrg-m<~sbS$D3HPWk2nxHMzxB@)XsZBnpeAdrf8e
z^Z3ZG42gDm@g*x4QT16du<>Lk2tSYQJuhMU9rWTWwx{DY2`)E3w%I3Jw9HH90!9Gv
z2GnC^o})L+GG`F*LtfKjx&yGgxEx3kDtILh03HQ97xa+hTgjWLqvG=Te}mkBSxoyE
z$ZZWw8c6;Z%uV}u%)O_d`n&t5zZeAUxVucvn9I6pRn4>VB5q?e##4#)DWG{NY!zVW
zk>DANSDG@8Q#5`5w1_$gfBDu=N4w`Q9PI&w;>r)u-+*`WPv9-3VaQ|d6ZA#oWY^|X
z8cBU^;%zkU-k`e}(SV~3tn3Cnul*1UVWT>7ql!nGbicFgi&;G*$&ubEQ?%pI9}*;p
zr~Wck>$Gq5_^tfLj3DjYSs!sDrT~!PPdPsh@cmKP`~c}a|Bemn7!|vn>EZocNm@DB
z@<2@?n3sDwl9nz1IOhi_trX~hq%;Fsu?&#Bu&GRlqqn2IsEQ+-;yvQB0d7WAZU&%d
z0VwhPv<`6igG*+^K^}=Rs+ckU+~-lwsC%&B_|=q9i%FAY?R$?yHJ;UBZUWi}p9w`O
z8wB2(S_7PV$_8H?*=pEkGCSWAkEp}O*@xTfKvW6<{uWAshGV(ot{9Aom9~qSy<cv<
z9G<}5fULamc#iV51H<kW)c_7MFy4pl39RdKamP`K<d875Qeo&Qj^J2LpDC3Kc?!AQ
z2K-`t9>bs(vSf>d{XEWZ+A(PhDtywg+V->K9zM76kf^|d<GFlc(yybE1pl_|&FUW@
z%<Yzk6J(b!!mTW{I;9fL4c`&T9`la^Zj1_&H3l0p4DCT-^1FHoq}~k7k<Oi=V5kmp
z>*AEBFz!h&;0IDd!_!qZDnwRGMiWh6InG0785v^7zfS{U671~u^y588!0W=(uO>kQ
zx=C;CNRXvjRpoDnZK_7=Jo^gTYPPS66Cvf1xYhPON&sm0`_sw`z3GC}D920p4{f1a
z+WQ;YCMKfPJRf5wG!11y;4euiuhy#*o5U$3R;EYD^LVw1m&uArXxeWEg)lI}cK{gh
z>k(WDOo=lo)s|IR5iMfgrc7c&&jVx;DV?E($oj&j|3Z;nO@5PE8+)Zp_UK{#5<;Dp
z1c*23#vpH51Ar0N9^b=636@_^si1fV2;nTSyxRXFa;0Rmz|vHeJZ0fbGFoLPNSMHY
z^?m&MM?-fY_(<_=YX@sGRpq2d0^2i#Jy>^l5Yw7}T1VVu3$2H@&Lq=>y;16c1%2b~
z_on_>D(ycz#KV5QfnUbJWnZPNFd8~AZAgsDh1BoTW#j=Q4ygOEFDa{^YL(Q@-svWC
z@4qYIjXb%)Zu|AWf&1GJI}a%q<FetXc?YBxN;ie9a7@?e#!7bu`U-cZ$;fRP=H~B3
z%iuqeD!9IuDn3IrO9{Hk`x7n*^XSb-ZCZmp6qvLU!41~TXegJ~<H;YO!)!fQfC<tN
zZ&xR%>vX7TU%WGlJ(B5VBGbc$-QQNTDCn`KH6;rG(qr0yxNuMhocs;IG(LpcP^iTA
zIY+fP$AQ2gU7_o@RSb`~=z{UAx_h1;o7D19V1K~z=>h!!-Ft3B=_7KGAd%u{>TOj<
zBOUwkjx1P}6=2H&nq1rSVR^`ldC0P~MsDD86nTeESj+hRWYIv1$np;<8;r!rAeR@a
z7|0#SRuNEd_@pUjl`FtSiK(O3tN9ZTbWQnFrGnh|lr%8qX|icz&H3w>4FN2x?6>7r
zdD47=az!NfPln%>rHdnlJys!(mFm~@wZTF!BW>l@R1335&^{OZ98mS&`znD*!8Bg4
zq$*shj=f68Nm)w?;T1g;<`@mbi1X5v((4Is^3Fn(YD`ou@Xh;XtJqe4FW;w_*9=Va
zyy-9E#SDPJf93_Ji(DepR0xOQdibr01O_A}simJ{G_at)A3#F(#=zmNlxyYkRdm>T
z#Yq+{ju49euHEvqebltnTw0pwG6ciAMPj;Tz><PvvQ~dl=z;O``HS)`jMnjo{_IFW
zgs=D7g2!XQu3X)>(@FHclc?Pvpek=K*U~bVeUWkbap=kAEg~FU7s4(|d=i4=se-@9
z!-V)!SqV57@5QNbFu0qG1IBaDg%m1z0|?;!-`D^9J)q^jl%Cb!rIdJWW?{>Ctmt`9
zT`Ep4@}tR4JVK)@oX?G{cR5(=-5qag>}EI<N?PI$K$ZKw^(0Lp04Rj)sHUR=$|&Kd
zr_I%awQ4yNWo?%81x&1g81Vs8J=KcP4mgu^4Qj4wV)Ll&rcAie02!p|{ahp*DDm<(
zBke;FboF%UPz^bRC)ErRxk`07zWwZd+>_7WIlqXMgj<9%)l}#<-(TSAjl1d3x`n|J
zSuU~E?=K!64l63X<1zf%>qOupH)A@qpOL$dC4uqjTL%?-m@nIekICvM*l_TdY)ba{
z!N<DUF6>X7eEl&|soOx+Z<C_5N@yBe)TxcQfm{~;V~U4IqrJPNpf;NNyM;*x0&s1(
z5;S3Bu*O-2-9b;97QOOjo6tF?%i5T~_-gnXFuHaK$&%YelT~C*u1%OoL72bW>Aw32
z++G*qE4r$_8OOhUsvA|D<|K6%K$BGR*u<XUqu)EU{TG@zu(j@SkE|(gC29M!pfX(j
zCz$yj3(=jl&Gn=UKy@Z*$Qo5+1i>w9ca4gw=Uul=U3c^D`wKFc;=;DVd>mIrJzY|H
zc0PTq{lKwaj286>r0Uosyfd69{YM%DJl+4aH*?C)tSJa(9M`wWUX<omzD{=p>~t#W
zYp6%bfIKW?I^@tek>AGU3vOfwt9Y}@$aIpHfsYh?V95QY_k-pNf%zV;*t_6`yX&Yb
zv;z{&NXtc0I6+X8Bwq|E@4(IFlCk9`qZ5aYL#{1@pfy7>*%c*%eT4{)iJ^)`9uFpp
zzB9TNV2&LJ=_;j@k1X7_(K@jq5-ur!1P8~JM)zmu@5g_iN)JTQTc7#S8xkPWokiu>
ziz`61OyBNCXIxyKc7a~`sKJ%XS8~UK6I|#oWm7iI`F-}k#x&uJB!BY}_LRt6f$|(}
zoDYi^JIT#pu)iR3U>oui^xY=_I9A6?rC|_cSTfg@rwqU>5)KqRgahsvipir<2ez5>
z5<ki9p8QL52V>1XESk1b$+5h+J=yZQ54DOMO?F#%`&e(6G9mzzcrS_z)jS8VtCUJM
zOdPtThn&^wxJK3{1&on~Gp}*=sr6xe#IHgdA2r~5nS+#v(^OhBXrzrQ-YFm8mDHti
z2!C|bV~f;#Wht_{zUe87Zpz#y;E!<VL!9oNxF@n|ZF`cm)iRzTVSI<7l^)^n6VFY3
z@sFPLdQUQN@jJIlY=S4n)Ydo{)Z*IrbW`>TKZ^9Qwv6w@F3tLjS9YC?K=XnQwnm9$
zC&(?{m3M7&59AB!QNxonm)Q>Q7;c{vc|;3mH|PeGhZzylq-d65h;1eJPjXf7v#p>t
zHP$C{yi}*yV6@jC$F*3pLeE8L7F$zJhm>qh*sa$maQ3swdE%5SgP%*@HNc0LG#7cC
zRyEFb#SKyfw_$TFd=bXr-#uNSBLJ@#v|dirO;w%75bw2+BjPwp`B~P-P$Lz$=A&8^
z0R|vphTST(Z|^k4*KDn-=x!|;bY3#CY_!X&?tf<3=|i%mBQ!ms*0ZjgIfYBZj#P5@
zUz>{II`y1l!1&O%`P6>q20Qd2_#VcG&w@xdC5tF)l?Ej-uXxkjn}$1*(>v{n;vpva
z#IGuEExiAuP=p9Qc7{*~OwQrDTIv)}nE58kKz!|kAg$x{ScL?ownwgJb=~*@wq=1Q
zDwgj3O~+by8kM^l1ol}?V10ONs7ouYVVkWd`$&&y4{5=MJOeiO5@ukG^^VUyvo#xW
z-%=lWPlsfu&quwCAM|gZd}gxaP2&bM0%tf}+voY}Fs(;`E*F9FnMPQme$2+cq+|Vz
zbNn{=;$$5Tj_|orDrK?CGJEz#kDDE3t|`PG>DhY%o}dJs0kd=Ac@f#L;gG}&P`sYr
zotl2X9YzbsGmHz(G^?6)LZqURYmu*x<(kj?Y(ZMh4>1S%RE}xFT_A6L(k(E)kF$62
z!cdlt-cox`+_OeSf1up|vIFTWJd6lg8&aMF*wo)Z9=k=W&sGfF9jL5%6tOemJk3N?
z4?0OTUe#41P^}ND8NjQGV=xgi`V^=~-a$aNXTaDpaetEYO&_jhFQ&qK#*bGcY(!_%
ztK=arY$-#JzZra0#F2HxjHl4ye;Iis)D3wPyVpf`1H8^u1epea_(&AUo8zZxHbxY6
z8p6W2?F+Ax_6_txTQomZ3JdK8B8#l+V#0xWarfpS)0V9#te~@WTpI{1&cj4`%5V4#
zQX^UMUG)6h@T+BuBT}eddIudadw~WpK8z(5{~VzCXTZ;Y^t~|1>!l-Ar0oxoz6vVJ
z>pc9pHRJ~f-wsK$s_(5{*BY?GFUTH7dFT0-`4&Le0AvUM11OBO>3qr!TC;j^D}|yn
z?gq*=$#YEwXNE=4;Qm-v53G9D;^>PdhEw>lzTsNw>yxgRH}<=;nNc`$1cvA7mdLPD
zZaC9EafxA3N5+hF?h_AUIiDTBYz9kY%#^=`Kb$<=#SmMIYQY-Crd2;v>~usYqc%X7
z<Ff=OShFiwO-NB1{Uh1!?N<%q&hePD(97(rSVa6-9Z5{50Wc1CvSsp=!Ye)bNl!hB
zl+K@YABB09o>k*fO+elo-}`7Ful=heWG6eO`Gnd#R+82VcDP~=U2Dvgpd6Nc(pekb
z>OE;f*9nnY8oAP6ImF)qm=jmVPEyPQX78O^*nR7%m#EIfyffQIO$KLF?aq8AG{Krr
z1H#DoUjTsrcRK+837?PA1F@ueax6FIg7>)H8E;Uqw7jOs=sgg?5D!D{DSvsA*u5w#
z>>i~ZQ*gfwVkM}yl1j>ZOw~>AjR{_5b5{8QdTUmC<){MC@parwqk=?nJ!nJcE)*JY
z!7Rr(z26+z{j7sL;56~0fAAL>3KaYq`RV<pXXgq^&a2R~4~$TvdBee!3DbgsI}mPt
z(({f(8fz-Py=HyRS0)TL@=je2B1CmxAR-_Mf~V}6a6IH!vJq*jUfD8d<m)^u)I)fB
zOtoT!@BITjo~e8FWfHsbuM^vh{od0loN(bI9`{JX=97gUzH}(&G-bH?xC3jO`!nfQ
znU4rOB>2?xA?z%ZAo05zC+t&cHVY>3DH~1RnTwV>%}pY~r4Msl+0ixPo^JRVbN4X;
zbk;U-Cl-RBDi)B0PRrEAySu0-g?n_^KGFrAn(@{!{oQAAb~@%pg+j9=%Ui84=g=Ed
z-Nu#T+umBCnCb&&<ic>C(rsu5tdlZADpbVt(Yb<??x-wt2){IYNDuGLM(BDnf!~9p
zJRwn>wg)Y2NwsEXx}gl_20=-d;Mg@7l!k5POVuHRr2%t=ulStFu$9xA#9&dkgO^3K
z(QX4ZC0!?*()}@wl!4?0#aa!wSrwXkab^tfwa0Q|vU&Bx?`$8ns_v(6vKjYu`~cl~
zFwT)z16NO;tzv~Ed(a-;LJ=r@14_23Ammmyc1NCqkK#s@BKMi{8AjmWv5(hbvYl*-
z<YOGCLO(#2Go<bFZyQxqc?3beH$YZM5twgx)GF3QaCy#RJB;rY`xd7s{Z=k_tU-<*
z<h2hT`5W7uM61L#)sHvgWbUdP9+Y@?d!->YUrOF^ZUJ)FvE%@UWvMf=%SHVQ;u!UZ
zz6q*%_?QH(14*2AC%KaX-O1R;omG%vBz-C-Dz0N=d(@QTbwc?(*T5Ad!3l*0YsrCr
zU9_g;%$m}P`WT+?PKsZQ|3sD{Z)9591lDRe<(kk0mqA#*rh>D?$zmX+wzH9|{%jsK
zI6(;Ml|+X*(urE+ZLI=iYpNSi!}&145cHMtfjiK2kl~8glm<a(%bMg<q%r&>UcNpQ
zM^p0k^MLo4Ili|(m$HHJnhZ1a6@0)&EWyfxvfN>zz@%6&zg&M-AG74!VrmxDrWD!L
z=ucfKj3vRt@PZcBx%rMy2*Y8#Bb_Syv@fK*>BqA*K3uSxO&V=idm{au!CjPbd$FPO
zMI&vi%5=56!~@tydN`l^_#sczVYK??Xx+9f!g~Z$;&$?FBx!ba{j&(`(3x+`FI(Zu
zHoboLDi(c|EQ{r=&ZP-i7N4ShKcNe<?tz{6P%<dmXYXd{%6UGTuhKqe^`gtQ$%1Ki
zfWIk8x!M}9aN561j3R!Z76T{pG)EbnpvAx&4=o|`KR{=xUUY##9QNrbWUrqK7&#~o
zr)z6Sicn5=`OXplZ4t<(i}!E2&6@yG8<%PIjG2L44{znNkC};!3-_Hu=-*~gd#m1z
z0<1nQH@pZXO=)=LU5g6RkFH&fUjc)xk{ti2m><C8eq4Gk_4Q-A5!O*5giws2(4z#^
z?<=AELhin)z3^9M`Qf`atDB^k4-s-=R92tldAi(fsLh2%N>24Z(IUi9!T!QDv^_lr
z0^{*&DV>H!<?r7H5LSm`2DYz722O0&4};py48up}zIWTR>b^Nv(QFr5K%7FanA#wB
z*g2x(@k{a2(mD@JlibkuYNI+%igXA%lyo~<_-ZEhOKdI5Uk~#L6Y*3e*a@tO0d3c%
zaPl6-l{x7=t0RoUr>!2&>ntb+)aW-b-P08xJ{TKs&#JgN&zBzG;%834CZ<KDj~|~D
zdTq705?UvtG9ffWVbQCb^3Ml9oZnzq2s}Ew`w0k**{-Eu-~lnR*A)Ox=0ltJ0W@r!
zXTg;*FvG1tYw0F<U84n%6(B60@jyp{U}_U#;k<I0QfEG4_V!W2hPmEt(t2aw5!%U2
z*m(!}BI&5ztHVXCIK@EL_gZD$lQf^V0wrl}VaF(ilpmmG$19sW#6Z^f3$wIJO61x8
zdcW*B)j|A;9e7!tDM*5D_kt-(SF0g$2paZoRrqf0&_{<C_^9f6kGQd^%MP7{=CxwC
zL%Yj$yRg@9mtKQVBxtLCtZ-c$6dCN`0~L81-%xwBd@RH*Jq(nNxKnBaTYTF<9>VT2
ziQ&QxT6cFIpc_nvEd_fCp7liTf0%xx9aGgh>9_p@)Dnt}@+J6N0Eb$o3-bL=31qL>
z@ZwHkIu>O8X$q><@CQgrVG-UP<h}~VRm%O!rzqO+h^HLK-^mL@6@k%_1Z0d(63K^g
z2B-0uAC)s;G9O@NW)N^C@+YlXYEaP4hA+ipU1*jgG8yCBb=qa(8ML30;ODLL|BNlR
z0-oNADWqL$^Xpa2ewyDBckTX#Z8wDSqyi0-@U2&%B%QbqxNQ0qXJ7^iF6?;8(+y>M
zudMIn<&&3*GOj&6#6%=LO9Mujc8N$2W=67zZBSuRe4gbUQQv>Q0%*xSr2-G-tC!E@
zwFZM|#ZFZngAGgfo>n5PO81ic4H1>9no$lE8cGMBA-6ua1I5M95IH8!CM$>7x<mH|
z&b-}%7Vuw`X?07Tw-xzOk2JZuugp=L3=_?EnZgNJd6ZRM+P)Jo<ap7AiE*2)Dq-$8
z`)z36!~#6u7oUyph;w&~vkmPd@z$=$SYGipKjStB8i0%HScMM*c=C26$$aiD&+VyD
zb`{H)><E^`DNN(o3tO0*8O@uNC^=6*tx2bhSa@5=&;P1c@-~&qF58G07VN~sKy!j?
zGkQ(cb*9C@?GFMy;y$LSZ1`bEDMCI^Ur{+x$Q6{SZ`vy_xzoEXtJ3c;0wEp1r6ruA
zb;5+0Bq)2weL_RT-SA9mQ~7>-cj>eXe8Qjsm7w!z)Cl76kt(j8xksTTc6`qXi+1K*
zm|?62MdQKn0+zaQGW({cq_Vp(O|g<XKt&kcUmX1>Gg$>vYUR?Nct<H`VSvw}ceg8x
zUJy&X4XRM;UGUZF4o>6co7!3pQ12BQQ#j}lNK+FKSPJOK6vxTm`1qL7Q;uEo^fLy3
zw)!`&eOJ+2_QiSH`xdJ3{!|JTM~(m9u<uXQms^xgL^=^Wfiae9KmZd(DbPi=?iBz!
zqEwO=ZeX#hLW{^&fp;AQW^Z4(&TE{(m0CPM+zq}G2{ia%AX^B`p)s8ThB(?HXZ-;(
z)i-;q1XnmZVARc8gxU|#?deXs3$iK*63-r11a$JzA(UI_f0B%51Ld|hkRUo(st?d5
zlW8LhB+{mU{7|zD2>7@E&7R_+(wX0+vdVS0&(}AzL646+caGmP9^`mz0(Evn;lTO(
z(8aM47AUXB&w+SQmoL8z$mblZy_HOXXNp@I@c%f8FNk$63_I`)zPKj-thQ{$hD-`%
zZe;tqMJ>gW?pLYa#E&iYsFkcB^HK?D0$bRD1E}KaB|fb&UZ&YdqlimG!6zJ+KR^h|
zr4`Nm3~ccAeFv|IAOOSscq#@k7*G`H&nmiKk1zW_<tc?;A)T$%R$=xWOTf&x)x=dH
zMUDaCfifDQQ)uDl&$)H<DRh^&fePvEHc8qA8Gyt8fAYdg@kr@OV;o1?IA?4p%LL8p
z&dG{4cMgVZ4(HJnCLx&&??AS7MuGA?{?_))NyvJI4fqVV24$=B4o&vgwaEVZ=2A6D
z63DOnK>}%ag=3+DpmYFdur8AIl;r<D<A2fph$uuVz&8_e=9g4fhG>jm<5c40z9Pt@
zDAgM0G;11rb&x9~Z~mIm_4(W47erXK{OhzLfZIUz(`_&>)g6VbW8^`ms~{J*GH@n<
z_~3s<yTd<vCh4XhBm6L&?+1w5U|U2YCQrZ1-kxM`>qBg){dhkAPQtoZDKb&X0@aqd
zG?b5S|9_-H{ol_-{PQb%J|Xb{vG!Ea(+(;ANfwy%(ync%{YBq@rw3}Q$-5Tw9dqUf
zXhwM&Fc;XMv)%tla1eNp*wSiF0u+_ABE-4Bn)a~eJ&(fc*R;}UA@dlBXRL+vGHB{g
zKs2C2L(0<}*pY|Di@2M~LR_W~)XS8O&FF?tic}StYQv2lF-p#y^a3pWr?nl8+Y<D(
zp;7zw{tIF#RlG*LG;!V`FOI)!c5Mkp*i~s*mA1=VR&TL1W5gu23j^}xVKq=rNfWXX
z6Ui46%NOOx{L*<i$&vj*b1x`ns-}qv)~>{+tz@Fps@qsM=f&vB)_OTO)F*!7S}ON1
zQBdYRfm-(l@yY6_;jbm1B8#7+Kk3-(;r|S2Cthp4pf*II`V3NllCLD>Jqb|&fdG!u
z;kSewixmPwf!D=5vn35&24@fCD4)0y-ceSOsHYKUYXl124?zf#y>_zcQN8&N;W`&H
zZgg&cudO{`B*(9YN-sTvkATqnJn?9|VP!l^uD=26Wqsvz_#RNj!~*~vrXI+NQ0vuI
zTnyr|5731m9RZXUd}SNA%)p*?A)d2xd#kUsr6+^USg|EK&wQi)RBST&??kyjA?eRo
z(|ET8CS0JkL|@UOs5{y8@>Wgqrext`e?Q4vyS#|$oKavXPk;{<)*HU>CdY5i-7zV0
za9;PwV2qevIcqd&<^YWMA4n(#a$PQi-is<w1aHhfSrqRD2Lbflv}Qj*w^X75E9?ll
zynH|hdxJPcg^&YOM-`g6KkG^;#;ZBFWOZ$IkW2bl=DcJ~^e5EEy8kFq?np-pIR4Ug
z!1UBn$hP|2H1FCF(Rrr?S&}l4<67BxocW&lv)GX(#z@Ou095k84zD~PxF)<_j$+-D
zhAGG7EU`i-p%p!>MRsT*b$dU_KxF<l2j#!*r)Go?^~k9$SC0W#-2`9boE+2J_oj8V
z9#bld_21<|w70}Gt41Ync+vu8BM;)WftiJ7wa3<{{YT=OD8+}BKR`wU_L~y`&C9jB
z^V{#FxaV$XLqx-3j#VW@j|S1)#6t=)ZUgPizp<*ZeE>!Q2fTuOW3mC7<Zif34kFf2
zQUc&J;%WfV2l$HvJm3Fvd;a1l0mGkBQbN+7v3>P_z){JpYpkszObJ_y7<7#iETek=
z@doXu<mA81qzE6<KzgH!A=8zb(CyYEwDH!xSuhX}iu2e*{b36P?UI}A0Vne<K2V-*
z0D!pd`~F=29p|kXyW4uC&7XdGQx_sos#p5wEs~^s_wND()d6>VOjrjy{8MFIIm08|
zb=;5mNZb+3zk(K|zaCbD^*@D&|BREd!cb$7BR0#W(~G4GG-xvzC6(9;_`z@UTlg)l
zR*6@lM0CUMMceeLhvS}vr3eA_k!x^%>sxQg;E(bDup}W~!XQC=@Q<YVKl^VY;L`#W
zEO(j?&U1FC0@FJu(|oS0T+xmBwpT4=XjeFcz$2?ZCPY({d<p-As;GXWt}bzuQr^tz
zU~2-HclDDU<KL5_|Kh(JsKZ)&M7F|x3|DPMU!<{c6jK+Y-N%+ZrtoAa1!)#e2O{x-
z09?qL{lzZi#AXDm>7Tz_q&<5E!oEzMThcKKiAV0WM3VO*$+AobYt*>tiWapB-`HN8
zX&~l5MJ9|LiAOtLS)yAu*%r>&Xt>cbj({uInjNW$dxT=$X+c8g46Q4=v=8AgBxo=B
zo7^f4b_H!~7RML@Q0r%OTT^8%%#fZIfA1e4YguHJxknt$6Z?p%+h)F`sU2F7>;d-2
zGAJ>B0!XtY71x@Q$&=)paKR8%hY9bS%NK&^>QOQ0{yV2A*PPWDlD?J1^7^=*;c=$7
zvi$w>gTmWxYq2qYOA1>^*-VePwa0ZKx^RQEWbb_<-dRkH&AVH*LePb0`n-w=7h=r>
z&TnIV_syT9n)cD$F5?3T?3(k@7Vp8Gte)>o>G%SidU#SH@#ykZufW~9SQr3`-_c8t
zws(C4pAHe&-n$o|A@IIlmGk`@cHztSVy35shIp!0v<zey8%^cb<cXoPK9w~P*O)qS
ze5`F*nhP$<AE4gT<<<)X(CcC~f@NdE(Rubr(cSjUCPdOS#KSjg-j13Ms`ZQRtw*?e
z*NNFWW-q?G6z^&nHfnP`_lT80a2_7>7x`OZ+%-wo=XaI>gzl|U%+;HH$ca$~f!#ky
zz+v>B8h&R_9=;0XXid?`G5eE7f-3xG0)CQHt~W`qLB7!uwtd1A(5>g>cvJ4FbS#?4
zN__Y1i*wgAdur<ojchCOP^8E!4$gJL9!Hw?e!>{@o*y9H%;gEMtRf$qQF)5FJYm|N
z^Qu;$>33bdN+S7<77$GZ8m|e6J+hWM++cPAibVr?NBdCY%dy%M>X<<d#zo#~K6}=!
zP6H}|WS2<N68bu#_s-)EbX$946-^eTC#@t^H!7Q=$DUNb#2o9Ukw$*ME8hG0B36@s
zfuM`nGD!_c9FLE+#S`;>4FZ|E?|)&&aPOjJPU@)9NPg#b|5zz@LWR%Cs59@b(IY2<
z3FjCc`%oW~o3XZeR{@0ii`MK}V~c`4@AD9qfv<<ZZ^q)MWFtkQ_!Zxm@*#@f*xtYT
znsisS)c{lqMz|GxLZprC35@@7KD7iSbKK_%ap>N85fRXcoP5v6&|JkkC=-)jdF%4d
zp7lVOp3SK)O|O9a2u<xHUe8oBgHqbTno6+Eo|KhK2ahBp(JSGdItQD`pFxy+KR`DD
z=&c4mVJtcOKg{}(c3b<2CJ%Ix>)a@b;n-ijPvsi@)HCQE_d;wCh_;^p>oi6#YkHK|
z_?_F7UPc#?q6{1X3I2%;IPmsW4&0qF18UvD_}hdrnLW!Q=hPZWVPaYh4<<`et;`-~
z7A_p)72DQsppI!f0>4vsAzuFgF)#%ZK=%28m||Q-HI=UhB+^}N=i-fqAct}8?T4Xq
z6b|(u+VAra3`weiHE|WimYTrM3%WDc=JC+A#&Ab=>z<5PE*C(Qo)7^=@)zvvxf|mr
zxuA3x!@v`*mx|G;$7vr<N^H6)Z??K-RRN)b2)^xaIx++D)_3gohwKsEYf2R`lD?u?
zrx^6k*UGpRYa48bu^%s0F=r1W@KcLtEN5LaS|{wjtldpA?xH)NS-$e~zqEJ@7e`go
zb#c(FjQ&w683+9Yu~xrS*nd@{GT$Rcr=Sun$Cv7Ks63Ss$Km9`;9;6tVQ?q=mN<8G
z+6;<v1`bTzZN-61Q?#CtXW*}X-H4kaPvd%MF2f^RC(z9h8#|2^IZ^c&6`Q}Ros#7G
zbZSWN!yZ(-TkFLmRjk_oAjCr31m;6=*}mfEx;^afNJ7YQ(v_x(4LYKBl~^a}j@8!3
zD8Mb|xwS3hoL-fV44)Oe@~cJp+t~jp$B#brpA8}Y(eti5A7fd;vC^O?D*z2tYcTle
zX%pZA8p!LL(W6O%Kv*vU3dn!-wEsW;W@=?XKFTLLP&CA=6fm{=ZPSwhi-$UXcvZ<}
z`rZmSG}$ncAF8QXUfmRI%U{z!UKnKmzH}g%DgQ7Ww72(Xi=kQa3(&~G`^!S14!|k3
z10$Y7R_<R)e@{2R1jpA#S_lu>0kfL?7-92%4AEVT^&S#^PPL%IEk~MG9Tg%Eje*W`
zN%J^e??&?_dsmE?Yv7g7&{?3K-yWp5%PT1+wJJLFY>W)Qrkk6noNlpA80B|b07WR%
zc)u9WYpS;|`%1HCoR2Q*RgSDX87?RZ4+piu!9h@@qWvpMPYye%8Bv?_o$uM=fUQIZ
zNv*2fiXoia*?*YLUwsu}7rsl{Ht!f836INwd6XoEgNkxzhs^S%Y{kbH1}JT<*6&(K
z<U;=h(Mbmot79*7rJ&j+_AX&EV`!7vJNK`!e}GtbSt!&;V<&jZ+Atk}K0ph1ysLNQ
ziTe!{Yubd(QWT`(P7-+LV<o3xoI&MRjK{XOQEcwQh9%=~ZAvoGe-R>0CB5Nj@H(-{
z570|d!>hZ@7;}H+sQt9kKVQH2f|CW>e+upuJ^M@B@#sKIkftY+L+r5~wY;sJ(VhL3
z*9%`D%Z53$EWj}_kKeCITv^uI(ynC<X7qmo)|m$yuz~)v2s&cz9@5b`mP}ii-eU*2
zU_RI%S#(ncWMD1vLS!rK5MTtD5&YUze%HrkUW)MtNaO(MAaXW<y`w}XyF8z-^0JM;
zc}Zf4E+-2j-p0Cn&JPZ2;<j3~6%f_dhi(LQzE!#NJ&R!+hDuAQ2WUyWfD088>QY4I
zo%+P`@YRB8^w9&f+Sk*xNZMOK<~iO>A~mPY%GvwDx6uH~RkdKBI8P)Tp+5VYqltml
z)sS!&m0gl!PMTelO1mSlUM1XNGIIR!l5#FwYb)qsSYXfnpNwi^f%1-+ni^wsgRfT;
zutm~><l0CFJ!m~`q4r{;E*m8-VND4flPhA~OGyAJrVe}>89Li@<<0N42t;4#X+%-Y
z*?=99@nni_U4JqK-uqfKbz=A(w6k=&PlpNss6hXd1)n-8*hdQDxSCGr;jLvkwD4}#
z`^g`(j8$)aKDx6y-9F`?nojqT!s=+)3|R|(O*k`f#-T{pWyR91av3c}r*i_5W;UY_
z;JI}uiSzGyKfh+`nw^?r)B$ItuNc57JagZx0oJ^~2&QPz)CRBBz<m!xWjd;oRM~G5
zH8E3p4kNKnq5Z(PFn!p(*JkD?{pOBNm$_Jn!b1F`TS5})ZrO0AH&8L@2hG#z{AroC
zsH}temFby_nB)0rfTqIHYMG_f-gXO)-|Sk{^J;Fj)}zz$;MC~$kkzgqX@nM>Cc41a
z<w*CdGhSL-CFDHpz&WPZPaKZ~Z5R>XUWN$JW&2bg_vNBr2{zxEQAYcQHXDG_j6gIL
z<`2g`6O7$`KC??^^rp_=6|0nD?fAg!XKSyN8D`>?08CL-PoBg&iZ|Mn-l+Us+}i6e
zq9OlZ#Q9&v`sYu0>nxUX%jC&0!Oqzo&v7Nshm(usj8Bw#<Y+MH+N)o!Sr*%_Iflqh
zYI)sZHH;uXYtUZ`vgb0_vR!RS@`)NT#{#O}>SzpCTT-%jr$u}kT<2pj-f`wQEUqPk
zPO#YqTUT6m3{P;H0aTuZw3&pu>|HhraXuT9jDJ$W%;>_vho%$0)nva~1!GK<&)+#G
zqAJ@Et7x+A_DVks0+=crTuLu)ECO*yMHC;}PL+m5AV7ar6T_L8H}mCfkEo<{Y-*c&
zBi&h$0i0M5VK3P@#rbW+lH&z$5CbC-R%tUxQ3eQ~a;CDOUc0xRj{!Zsb_m&?vqkRd
zoAD-j`i$KI@tm4>4Vnp>L2e|#b^B&3i}E!*DP^DV<Fsn9%X2s3{NQ0)^I^q_!a<=N
ztF;>B^?-EK2A-{8j?LG&s4Q{xlaFcXOaPEdiP8(z8`wX~n4|8&By#M{@~zIf7-8T0
zRZF<zMANM|f7uL6jB(3C1LBsXt_xhR=BRgln9;o$u^$WC4wd2R^NU0y52v_Z<$ByV
z)427-&m81_o`K_{`2o_tGuFCI4*0yjT!?A;<yI=`HD3*1u*&$sGc6<Da;Lh_M$Ivo
zkNriGS%Fffzke;wxB+;IVz_4Hj(fcZtDo6EVgxH^)WF#U4pC~I;3!@jJH$*PDppYB
z<mp6PT5Q(5qymEd>6%x}=s~2th}NE(Mck?G1W2A<Q}=@;X3e|8rxKF@u*Jz!04j6z
z53f#I*Cc6EWTaQ>ImMJ#E|rYO`qcy0xg|SIUxr^?gy*f%r~{-<xdjjt-u7d5`g;_8
znCIYc$)K^UrU4YWa>5UgWaHB14y3!G6cbScrcv=EOU;{S&?&6^9^^SMM?+8zP}{0E
zMscDRXSHWX&$@$#88RqJnSc_a@f^qq=Q--a5S~GxlvRgEwOW!6-P6#~Z~5R>sXthj
zX|9LfgVF5e{;!+y^NhmbDxKc{4}0Go&{V#(9RvjdK~Q=XP*6aWj&zVFVnBLFiZlUf
z(g})y^d_JnO?t1P_l_tXqM`RDCDaHZen<E2F1YL7b?<%4ci;WT#1u}>@64Is%rnnC
z1IBgsU68IFuuhl;`2>)(zfJaoNCNrew??P*y45Lfu}mwi_EpZAQC7}VjP%z!av_u}
z?G1o3sB7@kwHV?TgBSFYOe>Sl1bl1rMH}E}?IB4uF?R|pq@X71Tew>l#5d?HK%=iy
zhuCen^BDG&V!I_tQV9jUq;F+Mi@vF;KDH!Y!n^@fC_V&dSIankY2PaM2sB}~P@?tW
zwX|A~8~}GLg3^83f%JQ^DCu0PM@Y0c!&m1c9n;53cZ(m`r9HgEwX&{R|LsYs?DCSq
z_C27pk0Nl^7&KLgxqLyP3pzc)D8)Lg1H#>4pO(Z2TSE101ysBX0M)`w@zf#7y#CQY
z!!zp4p=Cq0WWP-55wvuk>xG5@MTg?p7wh9OOSf!VY2GK9&vP_o6}O~&F(uncGXI-j
zp-u&aiE4Emu#|o_hn3WXo2Dn<%;0jm!ID0Mj4VXAmOq2iK#H$x_EeE28Rj=?*W!3z
zI-8WnPXf22CVAHS@|BEZH#f-D%D}n3g$t?Q+;0)R(as&-5kM^Q(9RZKHPp9rO0j8Z
z0~kxY*%M3|KERz>${MGs=2lpeGHZpQ{i+wc5-G14)1pV*zvDkGn^se<sd)}S$(nhf
zIvLH}#=uDVA;&A8%@mE~%bct^--W2Z7CwFly8gGn{*BsP?R14GraLbX(r~rh7|%P*
z+wEE9WuNni>)Ncd8*`%GX$J(A=l*r1|F;+=_J!#U2M@43;<mw4D5OMhrnbh9LUgT+
za7Opx1uyz1g!BOgnHtSm<}gw|yeg_^a6Z}=!@?Ru5AIm*SlyNT2e+QX6%wcM_NW%s
z>B5r;j;DP8<<aU_^y`mmkF!Dm%umcgV(xiCKN@a-nCP)c5@KY(Z4Jm=>?h|fDOtL*
zkH_(i0>gwMRc>?*lK?X?Zl>T95j1pv*J7uZ3@vuU>Cg?}4<!X`$Oo(Gf~R;h%iZ-q
zH0{P%xcZ;<lG_iWYpY%VFD@ovfYk=rp?S1hw`+8V_a2sV65c28*jv{rZ)U$U4<V3$
zZJ`jaED>LN5VZ5KetBZCGsF$hn9_60gS1{o$lr!xcV;+0mX33EV{h8ROtj-nyan36
z@<;3T<-Oy{!^&}L0OsAldY}Be0-yzV-N`(<wqdp1*f+Nk;upfP?miGK3K$HP88Grc
z_mOwCNW$0odF11eI|A9X%m`oq$rahF(5|vFU#HEPd*|x3Dca7{4ngs=Y_aU6?WqH3
z?pzO(mIA4vI|m?(bmpHyp6aM8?=e)ac!4G{;6VQ8>n3mcy56ijz^YcL<xFUI^080O
zoyVXi-O#=udm)60`J$0xib#!eYJfn>^)~^FW2(O5sLKFBP4r_tANuib;@%vjDb=^B
zdmPM(C(Gb&WG8(dZI}xnDk@eS;74r3yt!}f<b33qH**|*`BMFtFMXL>B`zG5)^)0)
z%vTK))JblLJ);CMUaH?FECuSPtY{Lu08j`yLwS%4z8odtloZHQB3i?+BB-5Pj)69N
z8AtRn(76xvHx)Zf>|?_r6Tk+J8;!>*Z^~g~iGN%AbjY>T&?Z2r05{zskN;J?2uyUR
z^~-U^NXX;|hP>H*G7ao-eC!D4)D~ZRvA(-!YJcg|Dt#0pxQE;*v@PYEH34<J4k2%`
zl`eX{twN5uks3Qr_56d-^*1lOVT#S7!E#a{<zwG4V_UV7r*bp9#}4Zft3+i3J^naY
zXQjoL&!`;x9I)D|++8^FdV*BOjso~aEc9qqivX4rrBxo!Hz_Wal!y1I0T&+`e*2rR
zfd+5-lQ62@RPxHc21*B8**GLy(+8+x)5|_C`ZQSj%W8kUMCnh4#|N*KKVgw{-0Zyy
zxe^-yl939hppj(7Cjr#<Z)F`u0yBboMF!BQ0;K92;P60?CFf~|lJa0!3ezndl&zW>
zAdl0T{{9`K+{LJpYCFx>cfm6OHoJG?fVk-Ze6U$RrOuLsrK+Ns4N|-YqQ+1Hn_D@S
zuaY7Z$_3p4D@(VqU^$U^^z+J%Rws+k13muFUxicpV4+Fa&x1ZN${Cr>N;z2L76KJ^
z)o;!jLyrni&;=_DE>0CXE!!aag2WJ5s+^@*_mJ*g-nVb<G+I(4SNh|=IU7(Wa|yK4
z07lyTron)M5wLi`EI=S~%>S{H_|Ys<RbD~;PJOJ#gY{MGi+=vZ6j2`p?J%bEey0%T
z>s&UW8#hCc&mFj;egEKOrIC=-W({Je+j8_6l%;rzV;2%qzbKFf&_@B7ol>*}<p|KX
z-*J2fVGtr=y1?*l(GO?<rA?X#>Nj3~C^K{q0(OYaU5~;NozZm!G+jP}Opz;S?^u2G
z2|7f|foQw_HZ_pDYyeH?!H$E9*o=pXGX?tu<`5(fq%HL0XAljf*Ipi=r%IxEV1NWl
z=-<EKhu6UJ)gT*6J;^zGM9D*~QD4omB-*505cBatZP&63MS)UoBJtu%fwSj2xcdXs
z?UqAcSpnrwkHyG8gN|KHOR|<>Pu76$PAH99le5T#^@&z%m9?!?1Rh+vPCkylFd;!J
zCzcVrq*gn>C&dN$IIBIP!OF)N5g<3mKLBxP>86o9S!j-BZ|T}HXqfph`d$LVl&>~<
zCghl*4G$lqbPOgD$Q(B$y5qk)9}w)JJ7!AUkRw+3MJ;vq_!0V!THzOol<=d5EOXoj
zR{%+tzkk5LyaEUtGA-x8=2cG{j#b(-7NlEn7FjiCSh}dsv-R=1<X*{8f~6-Cc!9Fz
zXZe{8-Z@XS#Nia6@G@PztjkY0j~wJ?pia{TyJkGzdB!t=Wd?tWMG`SY(tsvYg2rqZ
zNP!&wi1+zd-XnQDqfZce9x1Qb|9C_we7!u9|1u}4<HPC}2J(LSB7ojD)G>%KZ}^0y
zT>IdBzS)U_{PGQ&e4N#eZeg7KkeWSUc3l8?x^*|&Q-QCgC~iexs!H5n#jSWMr#JHt
zHE9a)5mt58d~Gy3=48WV?{@L*+MEODTxM2Y!75=#DKkm<`hVN~f6@wQ)Lkk;=%_tX
z$XqTv*SLG|kd)Of!|BB}`=!|JfNy9He@x&%%GfzhSSm2+7oEks2bAOxUzlGNp@9jQ
zLqcvT=DV({t*<z>M=5m11X&o(sjbxJtE<T=Vc@cIJG@rn6q2Pd(6krZ(J18q%5(Kl
z)WwbT$|NML)u}2yo*fDuecH$v?vMSVJ%~<%_5ByZ=yA;7^;^6GG<ckZ(me?6qPeox
z)ITqMZbE)eETEFjxpNz23^ZVp_~klB2-9ixZNti4sFcIQb*^FXt}Y86E{}eL-LMji
z5=*16$28ZQ+A=+wFxx7BC@t0|N(mY{ez31)AIvZyMGAmSpKN{k=>fEq@7g|l6X7dQ
z#xrWiJ43*T{5YPqC)T;``=0UiHD!!h#<K-=($XSPk}X=#Z`3~pW<!jkm#6pp#e})&
zJNCWXr^IM?{-8#Jebi^=-Re3@gnWKHn%0EpR~n@V$Le-8$#)KqW2ttU8e&hLvPiF;
zmfdDuy)?8suADg<=xFlb0n_8im0>_y=O4AcUmkPi+~uhCu6sA9kG+i;p?b`_2BeAY
zs8eN&zvpx@6MiXFS-FcEO@*ExL*AE=O2~Q;TNj`3_@&rOY!u!+W?`=WFO*8j8F|)c
z?qtc%8Q`F@<f*v;gxCrb73igikAUb}FLtUD(2HiZ!!82f9~Qq@`&ORqj;OzeF<r;d
zZyBY({OE5_;!pm6#`BUn86TPq-9O-mQgASjQ7Wak(-P72Xuc{f_)1+Sd3hI(_A|-R
zqHc7;ee-IQQviFEmaxBIr$A(b8Ktbp40Aun+=T@`OiA+w$^iX|FR_b7WB^3m`wuQB
z#t)XeO!X|Id2c{NUUCQTR`-wJy0YMPnkm7{R*aHcjpj4RpRovW=Vdaqx_Tm|_ze{X
z?-LiAeKla3-;vt#c_oc#Po|Ld)~XOM_A%pPe<m){sq&Nj?I^tMq%&2&2jzU@Eq{y@
zcHB~GjCO-6E1(-~A;Vi;=cwAS+UDdw5vIA0N67W%$}vUS(8>V~)ru$I{NC^QPk(Kb
z?&<hdn7jB4m_%c_DsXf}vqP%pLBI*Z>wX4;7{j%$-+;Y<0@shZ$^s6=VO{Y!|HhK<
z?n%w7<Qm?j?$IZNTkC5hz4elH2t#R%5TQ?IAK^Y(yIn$!@zw!AFe`ZkX-pffZ#q@Q
z%F$y;w?s%7VJ>o743~S%B;vjQ46+(q<|QjDsyck#&(Hf5U+j}Mg-{q*!r>VWL<%c%
zrjad`GtOU@G4a!amOe2+&`VgZm#yEnP&{cv<y^cj)#u<LuYeJ;JS~hUexk>jRu(GZ
zVZKY|$<k*~H-u7lG2SH_c_~#}<&LP6CgZ2rUUpg6@Vrj3k>QQ8v>T^?c%mxt8E>S%
z^EuTgWAbuyIg^eTbT!aky{CBNnL}!%4614<gF|AlW;|+>z2qtdNewx<RzKkmZxjSD
z59RUT@UYsjsti!KJD#U6w63@!yx|Na>kIB2Q@X5L8$<CQX)g>9x?H&!BKVQ*4))uM
zcF?2UR?%iVGuPX+mxde!99fsF7;J86mlH$+6(LIk@SVD+iYKd?5wK^IZre595|87b
z@)m2^M1p2GDs0itISB*^f-JYpW%$(!ddpRw7_O#k#g}{dQK8ng{JA!SX8WOmrLxdG
z?N+S-rnwg*A8uWcZD2B(Sz1E#$TwWm6b(SBTBhIW*Cu~zduzR>Tv1#2Q|CL7#d}NI
z%ZRAfv2i~)tF)zSw+ww|y=1q-M;DTo24J;H8-wsy^<*4m8UakTes``{OU6flI{hei
zupkMn;3<Vc%c(4fmpCE&ZPQW-q*K0N9al#>AMp$eQn+7R+<+xRN8wUBsiVM2@5@35
zrT`<sl?KR7X(5nl4q}Cw5kTw5obG;u56#7wo*HBp(MBN}vtHP>r*n~s&3Y{T+lP-f
zN0f>OM_Z};S{RKzvBj|Mgk2Amw+lY8Q?4I6%b-$H07B;`Cz1=@Bnh;3-U6+g9dX*M
zZ=i(82mmgRp2o=5n$QRtSAN6Cva5!6T!uEfgQ327!mPR`BKH&BC>}VPb)Arz&)M(A
z?k!b$2qt+~qki^ACw?Xk4HzGo5Q|j#W{>=pOMr2-T`lKs@i8XrF$d}r+LFn0AA#)$
zXYEiUs|~hNX^*6?)PEUj`^r`Uaj>jLguEr6LbIE4W_N2Yzcs4)GKk>Aq*_eNBaI!=
z(;Xj4$W$cW-T_fXhd#qE$am(6^1eKDF3gVb?Q;wQsQt_srh<o^hs>Rd0AfnZ^WM1G
zclaMz^Y`TGBb);B9VSkh$F9W#+~vX&VESlyZxQw0q`j6Nz&rXXD3Xu;DPS6<!L<?C
zEVexcv{t-^d)?5zy3qPadPWm*aqPLPVwuak+{-afLnIb3g-k2wv&_r&co3=?yU_T<
zgmBZ#m*A(oZgnS3k}}yMJyrXVZ~86Qu`SAWm$lT&4S^wK0uB4q74@f(Mz>+^T;}!!
z^?5Q3^m56*dloG-nIj?CwyR<^qEAtBPFY=<=B_oT3Gy<oX+G6tWk?7~DfkS^b)CGg
z1)hNrzg$~gGwfw2l?ZDTPXF|R;3HMWr~M%a{w41Wi>kxjaNBGPGPOr@)|V>7b(tDE
za2t#h0WOUARGz2`qAv2VBn$Z(jWZYC{^0==5t{+E0kGw|5s6WWoP+K7yNhQbopi6s
zyBG&Dj7n7B46q%9G{g+l-u2c*a0KqiuYbhr^5DBw^1R_H)6-i66)RrO?ch5&D<iB8
zMN1p*cVP4b%r2{Ud#}9Nw7DuS*6sv}<H^{_Rw)^9WXFAUI#Y98AcC=(q=CvWvqLl^
z4+IQ-U+zIXfwP-mAbY66?P)CVffLojkDZ}Iw0y=j%4KGm6gEM{9s!pM8!=zS56Yky
z(R_yD!`;3CVtq2~E;oH1v4VuiYC93bbENO<N0Tn=gm*Sz84U)kTRsUy%RiXd#iQFl
zn}lOJETlT6;3OZYT?-v7U6r_p;XFlDdRvypYp2KE%T+xYb`rr=;0rJqSZSO}kA{O7
zJ-_y=7|8`++L#Nvo8&y+&tq~gOk6z7vhxc($-r9#q%!aH%3lNAa_l<*MIGqG-X;>G
zc4~H^ld2eYC$gKZ3l=%xY>z1oi<Vq3jUdc8QN6#lPKP;FPqe7V7i8rN2Y)=g9kN@T
zKz_hDiRM`ZXg>tv--Oz~!)5u=5>N%9zmi-^XR0%Nh`j4{Past3ZFIyvV_IYf<3ObD
zp}3prsg!%RCXVD0<I}tWD#8>R2B96jSYch%Kt1?Q0d)Wc#U05LoH!XUyp6U^H!IGA
zrkG8#`i-6T4^DiV>^;}&dkg3`DA&G^E*$Hy(W^Wj$a(P`4M$nKgw(C_`C3-bi$km<
zWSMwx_Zdr6-;sp4)w;$%6k!QxK&DK|gh!n-Znme!pA20Qqp0JEQz-$ad1{R@R1cjj
zp&#2!krlt&-Y3p<cv5p13Z_7cu<%&PD;5tvz|W3sq{hI-JRI<XoLg<xL|~jj7&WDy
z756p7`3!Q*h6K|6BrFG9%PSyANDVl1k$5rV_RW}8yJGTy(D8@W(r$KU-iioj-_lxn
zHH7Y5{JR<@R!NfLNk3*P`%))*r<GL|p$A;K&QzjX=)~?D1IR>ko{7gCH*qyuI$2rP
zl6@f;dZxtA=MJ>**FLex%6hNy=?#-_%ZM)(n4XI|Oct;$Xbs<VB~S3F-TC>>0i}Tt
zGgZ*1q!$Mrlwhw62(_B~+?i7?sz~Zmu>BnyF>g{7Wg19}&4H;6lX`8qg9)4UE)LfS
z!Gk{p7j90R?P3dj#Tnj7$9u=6?S|sXm5YeA+WS0&tE{>d#!T(^hvVMkPuj3?5`LOV
z)7^0LFMyIeTIxQKh>5+OE-)AP^j?oBa_NwjQEKCG;aMpQPrPYsRd~p>D9<$Xl_W8t
zWC;Iye=+K$)ya=~0ww)p2^2C>)^9(s;XJ?Gxs!Azm_r!>2_n{2mam2Omo_q9ES3X>
zr-NqLz~E-!mQi&l6F%%|S@qbFW%S+FX1G-pp%V4J+SlzY2A$S>q&@@-jaOcxhG%cw
zFC!%5D_Q%jW1nteNyVK9VwL5ti8#L-Qhbv=LU`GZJioyf`9u`=rvj@GqDFE$Sf<Uj
z$8S3WD&>`Ov86Nogi!+axS?#D#~B5qJm*MBL~yiU!RW}u$TDsl-is8X;zAl65aDN#
z#sZWUXo`$ToSsM(eG^Is>6F@VIsj-(7sO~*kK)Y#F5dNweyM8I(7LaK1GFsmk#-xC
z6ouib<|Vz7v=ddr0fqE|&W+gRZ?4S!&o)N>Phl>qtip8i0~xVyG`!uz=G`U{I3$#J
z?6=Nxy6ogYn~|*3LL!{7o%k!lJgeHb4b!Dx@JG(G4q(!-U{?Hy+u_jJSc{n!R4E@~
zf7(f9EkT}hd6zME5TMyAH^tsK!-97oNE!7!J8tJ~no_Lyhz}Q7#OkJ(q`%9UxM@-r
zN7Z{>XYz>v_09>PW=o-7N7KK9Cr_mvXSeabSh(s_5N{MYwRaCKG)L+@#v46%zKzzo
zfl(gsoBh;P&8!UNC@gBiW|I1hB{fR5gfddKqGk&WTCETQ*9Bn+B|yBjGo32;LG6ZV
zbY!kpCTosLgAbC>Q3Xa*wam8%X9wBxNXMsTpR&(IoX>1KH6HJ0F$5GR#*7;FPgT0@
zc2#p;m2H;C52mnP_wL!s&_=p7k5iZqO+vNBtt|R#0^Ulrh!}-;gDHBn7Fp<to^Y~Y
zJ_m?mQB#Eb_{@jMNZ`y<(4^{5MHjCn?oETym#RXqh<=(+-0Mhr6N+}pINW5x6agf-
zrSq=V+7KP+j$X;*oo~K$N<_I~QBZk@hPYX^s;IK&X(xM7ontjNqopzRhRfoOVV~m`
zt<FBPXjIXgcOgnr=2G&5po|Jmkd!0O@dipSK@MMaWlfD`k+XGSwd;OsBHck_#$`6K
zz%5(nj5_HQwNQ5rz?<~jwdeu|=1M9V<pz5ULhR4`9m1A9a7Y$aj&Aiwpa1!&*3?pq
zG;W&ef_c`+>FG1Io`z}KgG3$Kwn#~-5J3NkG}mz8;#Qt`RGrLNwXn-V5x|~5QI>qq
zDqBOr$c65u4d-gOBvJSd^$=AL{t_QtI6u<%f!>?JWM9$izGEqP9RfnMI|Wi8k}iFe
z;Kp!@%f-QHV34eF=j^RMzkM%TT?Ig>M80qPkhDc}X*kOUBml3O-H&i#UeVwLEUP7k
z^ER8_^$T6C)NA2@Wzi-yRRPRihOTBxk@&3qWE11EJv_oN{F~Vyx8VeW1h%nxdCnXX
zu>97s)t3jd<Xf-psfgA?>VqAC$t|LmQ#ORoo;L?qbB90VPMU0CUT?C~2v2;mGdufb
zthXLeVNGg+O!$i;W0yNR8q-|>9%K(Ua4i6%1q!gmH9$pI{3*bZAci1#@+{NM)wKZZ
zuRN&sU2AbRxYElk1m_c&HoinlPX)5|PINsSjERYv1~Ofaz35xAt6wf*a=`Z5tZ?p8
z#iFwiU@^x!^09@#LmJuy{{ovG?L=0@$TR1Kulc*B=>Z~&Q)Y>SC$5LD-3U#y*T>({
zj_bkajm+W$04=$=J5@buADTofOxlG%<#z*gy01l*vc#Ow$U6wiGa?^%wNoj4LaXu9
zK&~W5H-&%Gb6U6QdSqH1{UVTbM!x~_>^rG$XWFlIcm_9$ydYUr4V{iZL3j>nq}Z3y
zpq+V(m2T2Ad%_z8!F`8xDF7EBrN;`2tKuV}QTu$V30%;UHD{YPuN&FlLxp~TbX3eU
zfp1RB6u>mZesf&u5-+}LjIawf9J-i<{|v>ICgYesnpf=tf1sz3LqY!Wwh@iX%y6#7
zzHmr&1~eq)boAJZ>xy$OGy+(Zz!2B_6J|FarSUw4DU!LJ#)@utI}>!>yKy0DMT;%@
zc@9V==&V~mpm+dyqccM6whuQCAI}ijAzHa!(>2hF;x6WuR#ORcn-A}X%iKSk5kWRb
zzk}t}<Gus%cd(ff&(v^Gx3&iPa*ot^3%=MwuUT4xH_$O@`lI9T;m<Bs;ub$OJnu7k
z&lTSd7Z_+Kkf+?BM>Dhz-<@yC1EP~$Gh;JU&z_gip@rEtgwXl6&I(aOnQS4OT~#za
zeVd4$M`fFWP5)V(Mo_4v7<B=PtpEqodrx$|B@v}S_l@Nb{(4`~{=?A4&gXF}h;*sc
z46aVGI=Phhc+9S~-#OiYVyWq4<Je(km!2oyQ@i<s&V|Yz=Jn9kDG&E6p8g9+m~Yxn
zw|N>!Lki;y&_N^v|AIis%Jg2yjy}d>mB)M}Nos_S4*4sclxvvgLihZ5#sR&N8;;Os
zFItVL5gJZ0o*Br|{;&7kp`T8?hrnvSs_Q&IhMxZSEA1RdZ~uFaPcjMUN7c_JBS+9x
ziHDRs>m+T?qEkbm-q3gYs?ges1O<h1*$5vD5yMdfw_a@1<LS?zY}@!V;n%kYu#|IL
zIRfO`<L@8{Ax7FL_T}5ojWrpK1%0&6o=_AM^)W&Tz^?KXoR*?Z4$ofd=keK(?1&XP
zEvn>=glX%!@uBYOlQG1tnI~Khd;?iao0Xgs8Ho(F7o+w04rKoW)t6t9rK9`t?>#@7
zntvlDQ4`s&zsYDxxASpm#gzl)<*>fL8w%__=P_I>*QuSI(8QrQ6HDRoF;YS!ni!38
zVQUhE)?#!LmcS@A0bo3mb0C^H5$C-{2(M1Di<8pK$xF&mV6X$$Ax{32nmr&Z1B&YT
zDJgV-|0kxAe)~u}YTB4~_TI`rDXRZYLF|_s_<Qda2-6|t+;thht~TRAmdn{gKIVDL
z-kj%1|D>LLq_nM3c(z8>gvN~!HM8!iP&>~0V34DOnvBoRq7Zm0UR1NZLB2vVimu_1
z0&)t=lceDHTOa=`sLfvsz{k7gSksSts`D7DgMZRZ7&^x^-5?8Gy;lZ%;0eR$n3t}z
zY=;&F&5_ea72(TaU2i5{4dKB}5oo|XQ8_{3ydby19t<7NFJ~ud@nt#?x))-bU?=6k
zyOs8?RJlDqBFV8whbR^l@uLvRf5PXBOM8eHtA@tjrN?DykLhT=0#kz{DY^wv;(1!%
z$kK!M0ycU`k&k+`k<B@2gXOZMO=Ioh*YCK{RNLw;9QR*d*CA870QR-DlMR`)>;rhM
zD*$ghF%M8Z#MJvraspBb#}ptc90s}~9v8@<So7%6o=`CAjO$m96Po0UKB1^q2KrPj
z-9~;X1i&^$H+WXQ@~e>QTB4{!i$o;lHl(Qv`0EQRDgbQ{_7l76?*sq!r8Y#yHO5-U
zn3~vP?R}g_k6mXU;BO4WY+Tn1KYsfH&8|5y$j4Kk+@+@Qa@;u8mC9J13|EFsgVuE1
z64cQrb%C5VaEjxs)N~^5(*9eq%azY4&O)%f{q!3jlR)*{rV5a0o=lb^6gJV#YS?N6
zwU`N)f;{;R1aSe3?I`y5^Ye|*AhJc$*uB=nyMmQhl?(^+KDhe_8PAsMIA$I-w%=jw
z{cTMD`){AEL{et}(m`F$(rvcQEDe{?yczT04Y)$sa-#G+k+ak7U^@x;%@k(lrzErE
z0PXktI*zuGa}GIi1!pc5rRO{95||9K+YXg^Z0~a}gdj-<%=YujDpNF<qphmO*GOIp
zi!t(x%p~Wep1@(G-#JwSxDhO*eGBEn<2n9-esKAc*B<owZ04>^2MW+DJ6cuy*)IRp
z$E}IepFyqcGl%v~Hk%*x7Ssl?4ald>+WRUo2QJm(R)GD7BjHQKwCsgJwR?W~BK@ka
zoz|Y3kqAA=BoAD3tT9t#WL&F*sk|cC#J^oyjRJd<8$<Z_GEQgHKzBjYJk-6R{$=e{
zynEI&9WOG3LdGfz?2mzBV&wI|dfdh1j`|<O>Z4va<>>A8l~;Y--G~0_u6MrDs*m`3
z(Id|KCr<a@M?SJG{)N>pa#xsq$0uJ>T=B$h*B)a1B6{hSK?la<UV-di4!E2XSDAqV
zL|O1>kbWKj?NIKXVML3S(e11Q&GM{a$mB`9&}TOkf}?6tkF2Z&o|lHloQYzjrgL3o
zOX4l#-JSC$f33pg)X)k7e<v?E$`JgId#<OvQQk<o?kjX}+Cx&cOg67z6k5%eJ?Ho0
zT`w&^W1cJYJm{Ek$Ddc9Q!{-Ag?!{79AEa-e_=H<n)S*!@^RvWa825?l?b(DYFFP<
zxN}iuIdL;hRbjZiLC`{wRgb+Gjq30Dho4{j6D16cW_NI5g#zh73*63n&|R3nHi)2r
zOfGU!8IY5x*7c2t*kqfRRr#cRiiTZh>*LEV>_9sTg{Kyk+OZfLs7CpUV`uU-p!mbL
z1;;EK_VDdf-z{iF3)QA(*m*pPP(lAJ$o@@;O?Xt4PwP+W7N+Dbv!<GrR|PV^U{5yZ
zHKlq+jSH%kvPBctBlPkMmtC_4B5zkdtFe{Hn?C{WdW8rwt;}!wT}6(cdmR6&rlC3p
zf`PB^YN-v?$Yu6a@SL6xHE_z7hd}o*O2KJITd}BoaC;>Vuc9S-?>hJ0<h9&u5J|Cf
z?F<UUa#Ywd7*Wq>&$<%b$)}p~*=cd*S@7jKjb|Z3`|5*$upVt;eQyTlA$-m3pQe)E
zOEJImI!2@<O$)I&Cu=LibBB9j4MArupCT=}W95cWB#%B0m^slc=C;3NXZn;Pg6zZ|
zc&xkQvKLZ6{Su+(Gh>F<c7S{wQw&Ko4MT-^gl|BIzC-9co<RHv0HRUH2Gef#q^uqy
zzQ7iK5+}H~<Qk^P=)y+!I0@uDn5Ysq-rN~`(b=f%Or_kynS>ig>1LQI-#OW@i+9{p
z{wp9F1zVp4Mzl&0Eyg2E?hSDYY<k!+#l~+4&|X*n45ag)_8IjccUss^uy(u1)v`fH
z`K}7~SqAcjm+?l2D}>L_wS&}4ey5Y{D3A9~In0Ok=hk=5h${3O4_Gt#J{lyFhFzia
z_Icn)(M}?-zu~bPm#k~4gp5=3P=hlHR>l#P^+lWr@up~ar-e-Z45E!CJoGU{OIL{k
zMWv3oJP7PLptzYtz}LzECUR#hhh4q8_BugO)ii*Dx0Q=j(J5bG*4XuaO6|aWuL#ko
zKHLHx2e!8~rQfoaJL}#VP7Atnt;MJpH+lvw3)H3xZhnz%%|)i5WrH9)Gp2x0v5Xio
z5+Ys~AP6S0fbVQakc;%OXIBzovB>I}7SbPtBZqlI5YF8KP!CAUrbatcP}wl)UJj1G
zc$=&+cxrtj1pQ`E4=FO<Th=H1q&-ogZ)P7B=X^`_^m{G&6l8W&H%zTGJSt)7`h1oE
z7M~=H?zSNy`FDDS>pik;p_y}e0zT|ZC(^x?O3Y8w_rh`glN&%i(r=&fP*$uO5|ZAx
zj<LD!JKRr|=97wv91(U6eY>xg@ie2)2Bqo%KlRv(#^<#aWyIyX-LBa|_Je4>>B=60
z_ee|eK`0GjYcy}?!^oHH`T5Fo(Tokv4y%bRA%hr|ua`rofWn5hnUbZcT7SXJC9;Tn
zY|)#bJN?Z??aRUh9+WjJQi;H%7M=iDbL`1i!@HgH3Yo8?i1_&N+J*fVmh=LD3v2y}
z4GpAzRDb7#9H75LvwD$#6f$auvkyxe64t+6HeBlVjuYXeJ=WCQA^gIKaiSKajm7DE
z7swn!wxO-=oP%qo8?#lHQa=oFUycJ;^r!;`A~isj`?meWscNm?WVOfZEB{mxYTEO%
z{@79-S$Rcqg2sKaqM)`pC;aP;?Mm&pR&$;p%Yg_jzTgnj3Iu3SkYtWChhpf>%Ar)m
z)ojNX_sqN4Mhr(!-O3K}4g!cuxZZcoYm_%4*bUcqmsy`#8JlV_y^k!8$Z&3_U+v~!
zwyc5yOjDgfU@mgM{vil<It|i!DiU1_gn@mbVrSt?#Q?Z-dW}ckO8qVu_#V|2;l>ZA
zJAktVopk*ov4@LvQ>rQNM=4|>pCCJoG(EfXZ+dFzM}dWA4HES{OLYO=X9E2LY#CsD
z7n(dsVKSKE(m_FnL<TJ)05rv2ompeUGn|p<9HDUI?QNsdq9?2OF32EwT@xTeyVIp8
zz8v{f=U!*a1JeV2pj_BxF8GGY`GxWG`!vqV`wqE;xFgO+vV5*|fe)-M3|gfdM(U)K
zYV=4@p*Cb{9cZZ%#p@7}%zmYK%BJQN99gfU;Il+f=LLcG1z;RRDOsBy!{C4-0?*u4
zI4B**YN}F0?-4~8v1^E^(z>#Sg-jFr+CXWSl_S)O@$OrT;_gdsE`sjOMNFQi{l%qS
z9E4^fEJNG%B=1K;Z`cb*4K<nQo?fahw`u1oxF_msU1MSjROnB<S-p3-+PZC_YQPw#
zG85T8FH;M0mHIgZJMu^k?4`e>QN`LR1YF1O5zfdm|H1#<nm7k(Wkt|QAvjTGH!>;j
zymmV!)O-PDm%0lS3<IYp2wMSwX88tpDhJ$<flsuNevWFx;EWQ|WBT+LXh(A$L-*Eu
zX#D0c6+<Km2xzSQ_ZCq|67v^#$LV_uO5=)NT%9s|F%#7>8T#;{On)h$OeQ#$USyx?
ztYN<I50DP>Ls`vXUJ3FtP309PjXn0UA1!+v36ZI2whzmavjgr5<i(ZS+7)evMr&PB
z1rony&ixqU`yXKf<`ZP7TNYdo`AGQ6(qu(N^>zH~xGk%g57#(dDU+vdaL17l$wb{^
z#MOdJDVAk&l;*_|b{JG{1g_K}Ly&1~RFK{ope6_K0vF}9MbC=PN&<JuN+|j*z^Xt#
zK0Pc#19t{QRx@WU&B#Y&E?qF3lVhux4MM!*@XyT`;@TK}XOgoVA<q^j@+n`=cxEk&
zyy-w01qS4>M7q$m?4rB3N)U`_xgb#u(I}ASfP;K3v4D_jj%5sti#=ylM{AvdZMD0X
ztJi_f?^bhPvR~^X84Uzk;6-TcBcn6%(B-B=7Jh14l&40wWiM3w)Q}LDlfhHgQ7!IU
zV6j`1p3wQab2g`>QopoRM>KU0sF$!)Pp=85ed4FzoB5=OEj~Hs>dZ3+ZjOn4y{x1q
zvm0nRHWet-CP_3H+`O}!YjtIrgR0Xp+tTx5<egID=cR?f9epJQ88^6vI<VD3pS5CC
zA99rLD<x-l7z}EpO$ty=XQluV4P>EeEnjV<mHTWbLd_D`i%Pxkmc1-{XZJ$WNEpXv
ztMNQW{ZyWwE^`}XBbdhMt2cOOE_jQ{xucWi?Tw9$ZJ=50#@56caMFZx=Rh<3WWoE7
zGZ&%UcPs30;5GJPwx3|h$Jhh^-cp4NS^FxXDojWqwK;XE+^JvYk!C-fG%WMIv@B+t
zYjkulZKMfRmb%7S&hRHVO0C*IO*Hs9&G<j_7{Y(S|7D6lQCyZPC^n*IuR)Y(O$Zo5
z=5#CWPQVB5_AA9qK0%3s9P}YK6tR<kJXe<DDJ8pbbEBO_dbE0wmoT%()%|NO%20K!
znHB$uFiwV&*x5LFBdc8_8?q0GP*#JH(2QH^(DI0pkNx83#Jz;l#ndsA+V2bj0uKS%
z0VFC{G8;e!7^?Z(U1!9yYKzJ$NA}zoqY&F2IVy@+4;#;v%AY4<QYsj`shH#e%3S-%
zw%&VjE|rXhK;j+wL(%JMEJ-+4dF;7UXW=8QSdy=AK33l(;W^G@`7uj$Spx!q^BJw|
zT)O&^cVL6&G3~{p9M=T)7%y)ZNaWH{Iy<^6Pq9nNb$>_=b*y>W7-I4%ykuk^bK{-V
zB$$ZLA9cYb^ER&@%QZb|Y1})0mQMujxI!gZev>Hum`3%L%d1IMVlijiIWfbES?(q3
zS!l6f{Gz~VOr*q~Ry^YI(rTI%$@m6`cXDSY4bbqrX=U}U{6i2C`StQQEW9%VG?y3s
z&s$QPWd?v$mAtT%&M&i^fR4u-Wu7D}d$f1Kb20X!yQg7ldD)YGqBEsH{cl@#@JeWd
zN~t0inVMQm-?Mf0dlf;{tFhN+Ho3Jvz~8sdX=zK^(ApQXG!b^FZ2#5+065hT^N3C^
z|IDP>dJmb7L{_rV+22Oo)U$v%axl<c+Z}y%5W9V4wvKVpiL&QuS`4^j$l(Jiy47n|
zo{pX{vjZgsax7I-_uc9GQjG@>TiMR(HWgcSKPs2j&!i7+g8thxd(2me2|w)?^x4`%
zuaC8g%q3ye=i>=x>33(1M4k@T;UjR78BJQAdBG*}v?I?D!4U;-RzfDOiTbj-*6c|F
z)o<nLkgTNg&Wx2ej)Fw*@9@WCS56%Q?Jd7yKmC=eGS=M@aly7NN$OyLdbxaBd6}zs
zAT2;(+AKYoDY(MKHq0|=U@-|tuOBXd@4+sD8w6r7J}E}Sza-C-SKA_TyH|=yl8!Nn
zwf)W+c_|Rcz`!9p##Jreb84N9-CEQ64EL2;Ps6-EG5i3QsbHf3o)8{#RdFxu!c6P!
z6&f*?+T!v`yuF)!tTRjDYGz3|d8?Dqr;;}K4_j)9f$H)GAolWGyE$GZ`xlDbE}?A&
z6qb7Uy`>|0#B=n~ZjsbJ)9P<lnURmz^#U{A?opcL_EXn{r4+Ss%3{GnJdccl_#0FJ
z$Rp~<r!c^3)Y+#(L1yE`Lp$tX1<MrM%(A7Y{ihV2NGCzpJGn6ikEs~|hyu;<THY%9
z`pPA@XRomp%IE}r7T8zBs8m$JtGa?{$SPzVpnnI`!K<85pFwayTyqXcTtVehD(Ins
z`UNx${Tal8>^scKfb<*|9HIebMLdVUzx&^^R*uK%!DXL8P>1zTz`p?Hv<uDi4%wqv
z9Cy1&BY$<)W|dXhC+uA4HGqUw-S-dDk$S=sFiBSqrCBoo?o3C<a=BS8mYZF_68cDo
z$Cbo(f_U34UZ$yC@oS^Ai@H+Dkw#}lY$GYtMXlEIXWUdYdcE^_6>6#!b9MsCYXsu^
zYCgw1;f@as8qBq_o*y5Xp)E8`V0k=X<;BUbvpEiRJ5UE&i4qU=4^V(WDCuH$;&Gc3
zJ$iE77}fz<M~p7z?=Sz4Ef|H!cM8=7REWA1BaSCfhmhT|vAho4;w<K!0;4{h8>e20
zV^L`o${f7*;`rGb0k{`qp$-@+1Mt@=*S#m^N-IR+RR$j!?fs4D*6PI<<q9P738$?}
zhk0FXg4m4MU8W8~MWpnKwfVX@ArnFe1~3~-`!lPld}^Dg=@WP&`1FEO0S$m&tkQpy
z$CEUOBks0A{QVjk6)MOW)B{&9!tSeaernhACYczvK)T&j&_2*~@DO%ni#{+Y6X%s}
z6hu_>&lKDO_2*+YO^~p;E6>PJoDokS73WEMUfR8^T2qeu5L;-zdjDO?#+rY|L?^@~
zWoZ`{Vd~Ms+Y!Ng=Z*&cs{{p*ezf>`jtdkxX+_)lWK(;sR2<LvoQ8K}9b1!2r5<rs
zm94gfT;I;$@Oq=_MGp{yhdp0T9g<18(B0~1W1|(rgyt3B)FAL$#pK3F`7<>~9dOGk
z@4P-ibN*6iyt4Q!3sU6ra{bD=MP(tUhJ1MVbIvFOTp&lA3;<=NS*XFg!_Bik)UCK>
zs+ska;BT#~v-Z@{7H#a7<U7+EN@&RMzT;zF*Sci~+Iipd#ABuRc<6Sl+zzz93FeJy
zkD!c(Z|@P^B#3(;;)K_&J?zDs`S+a;2*3S*;oVk_lWMJiX-Z2ITc1Hd2QdVY?2bbu
zB%AQQG%V5`>6n14W#G{>(;Dn05jy=*73#=)m|U70yW!I;jNTdpdFzJ$<*(mXKY3-u
zP-+y+5X=}X@fwt!l7yL*uil;@Qn+y{-qHnPZvQZb^F@@^?ku$_Gm|>l>c*Is<ijMN
zD3S(%^umq7egtFuAD@Bo-}PJWEhb#+6_U!-d%tw!$>`_@Y8`1t$M<$JY9LziCGDu=
zob7Flb&_d4=3a+dqZ!h|Dxc@-xK$q2UNb3nT%R!XMvfOOy;y)5@Yqu}`zN%}GAIBY
ze@fUiv5f^qg(6{6z>tLcjmJoBv{!U}I1nX@PGN48A7ZdW7|}d^fYRVPir$kH!0j&<
z%mPY;NHG*UAW12&4*=@H4l0V+z{nCDI-mN*)0UqAAw%?8Q9MX5F>Di%IV3rc(f#*v
z|Jphix~opHV=5FCCG^Ob`zmK@UogQIyzND#_xN}c_sv|7tqDv>E7$Zpr^dVPWp5_n
zt{TE3Jr_Rpx-rgre&K7;`9G9TJHy--{p_8HpKV;!m%eKE;(|I(ob5)QF>xVvUPKRG
zZuqU_zQK(*(&B&^gxrx03Om3#<K}>4K@erGYt$?C%e3*<9ZWQ**#TL~Uritf{_9|1
zV0MVW#4(GZJ8Ef*fMB505sQ&IYH3whSTN&{S}H)L{q-ncX0$9oezjC?$glQo`5NHI
z|9#kh+|K`Wk)I$S-Zg?oQ#5y%VRGdG&Pi+`Nps*lxBRDpbbh5R;y&84UYLdNSvza~
zOikwt<1l1;oVD8AY9ZLzSLJ#~aNqNwvk=^=I*L*Gbg674=ccq}{HYmZ{4rxFB=!=j
zSh$e2wm=wBj#8$*-dl4&kv)fRS1;4eg_CZqa#wxXqale<;>dRM?_!W(_MjP3%x;AE
z&pbQ-8Pt+*Q?iU9Gg10{)zITn5k7Wh{vnOAl!L*W<_nKI7>9E#v^?ta(#FhT=5_Gp
zOTJP&YUHBbm2|#0d>VW6-32r2R^^+w;wa>n5g~?<<l9DvaM0RO`Xy^i4LE7ZwY`n~
zo+BPhK8eGD6GprAtm)>7+Olt|J|LyP?f&a_^8d$OZh*{b(mEAqWF(vrV}qZeSSIm?
z;L%GEL+$aAOg}K!Z2G(XYWYUf9L>l&`laYccb7Sg+0!|FWxdzl%#e5N<d^khSel-!
zuxer%;xnRXXfr!u@iXT8f9Y|H(6<gW?0#{&hiKU~QY+3ws!QTRSP4dLT$orpmO7wn
z{%@Ft{5$CCmyPoH=KN0(R!JxGlZVfDov!=SC-4T`{7J<GMzYbi<|cSXrirhgtajtD
z{lidPZuGk?iO-<D9y+i5wVFMEM1hcZUYA7JxtBTJG{5okBT2Vm*k@4H=($C)<G%98
z>LEwn)gL`y_=BB5PwqPn&H$_N$f9Z1(f3)Qq^4F5X+L_-uaQ1`Woj-=?&j@{REq-C
zvE6xx^Lg}fFXq3t&0e}&mgt(gH80a(<DO68@y>B)p&SC>U)p6gbeH0$oqbBj16{}u
zKLD*dSJg*<uVQ-iz<=erp4&7XGEL-?IW2>Jbh9SrtwF+j92!g_hw8#Ut|a%6&CPv4
zDZ<q^WR|suY)$_lB1EbF)CoXwG2gU7<U(Xi-Pw|w%9A!z@1P$|v%wVb$&e3i5F%Zk
zU*I;9WAaom)}wRt6i=o7)db|vP>cQqT@M4SI8-`zi97P{AUj)%JydJnB<T9~$!DE8
zX3LBDK@=Ls*95TC1O5j2zv&89_j4zytFA)q1*KF}B^ZZD78!>X>W|lpxvE#deBIAM
zE4-(%gT^ggjAWj#no3}L?(Cc9f!yN%N;&E$UOI{Yy?os<Wb|i{e2i=Yo}0-TnwfLO
zM(vn$nDtppVpI-lmkRQAm#VsBfMK=5qkN%d+Rr*itT|6<<9gV4(p+hO#v>n0B^|pD
z1IH-FawciF$lmV)xnd3oEWy3F7qfTC2%R#tb-FOcnflm*@f?G~PAfOeIxMNN{BBV8
zgG|*o2woqXX`3?^lsw&7P7hx+6U7G)X>S-1PHB}YVl!_n=vEA)F5>FXT2wg%-}6k}
zyc9aebSO=Q$S<zh)kmh*U6tV&9S~9`1I~X;zQga0M>#X?d@b%TY-yq6%Ci<~df(`$
zpZJE-{p<f*01D+i!fH4OeiH$2#tFCS6lCJpf9_t<^VTh~TDlroRkB!PQuxiiP8Yry
zw(tln%qx7<muDhjfUJvkK+o{b>Fqqq`F;2s`46u_c{Rps?qU25B9%+<wElvNgWNgV
zoq2l0nkfXmB2Lm^qcDIdqy3$j_lOYdU!538-4j|P%<S)e!Nv5!t%=saxXaio30##p
z!o|{}=hSNGrpZytQ^KMeVk8TJd!2`!G6ePBnA(6&3GLUi>ivSL;ZF~Ek{oq~9uaTH
zW7kW!-}`=B^-rdG#P|Pz3&u`>Lt2>;*7I*su{QqGfD-S;S))B~G**R;y`GPbUrRjc
zjOs?*n0Yg0e$<s^QZ{T6WB1j)H?u~gYU_T`90-xKYqJJaw6faA1XBPGRu!3?^*oP}
z_VZ6T4wL){uUpE{oN{hFEq6JZYv~+Z^8SHgMOb_}CX<O>%7D;003Th<l|Qsw8)zw`
z)X}=RH8PrI&T&3IEWugyGEJ?F7Q~+?Fpp5~z$86}H;v;()~tl=1M01&1YqFK``0N?
zq@%|LC~&zl4gInsZhS}9@Spb1|KW^*qo^9KI-;iu4hyIeO&eK^CUjxrlbTgA(ak9g
zLbW&*+!`=+cBqz3)y)rkUATQgjK|{NFVFi&(Z>It_i6^F+FOLRThUh#q%oP=AEZvj
z&fT+gaJ>KNgXe=HY_A&_Vze>;f=L}07y5Q*{_*QgUEe}S_->j5N2l@rt!1^`^60Cz
zYR=tr?Ui$oNmWRbC%s=QE$IOCg_wS63;r|FC*sWolMMkM3WPU$P<QKzb`tUVx{R{D
zbIivdhn|xbrM^aUgg!wllMN7MjfWv0DXdU%C@Y8R(NUfjzoj4ieAE4t$A5v^@^hLq
zg=RM2!xk??kiLq8au9ZNyvEFF<Bt;Y;Y!@ItVngxB>FmJ_bvc?CE>!YlWlU$A5{gX
ztd~{!-w&=;^_AJmQC$FpPvc8z<h3`1K0>B7`QY4}fH30oHAUe^MOVNT1!BJ?Z+>_8
z_>+=|HG7Tvh}+KXx*JBQvfK%Htj6kW2gKR?gMQN97xa$9KYDYi$Xt)BBnaB=ZCmH4
zSFBavbp@><@}3)GyiaLlRLaSU<Sj8<*qbM^W3HUxVKP&9f4UC;i>&gf=Q;YERv7_n
zf%o_diKdO3m2YZxvG>WCHC&9j$3IKC{f<{A?p8^(G~4<Ku5+VN6a_Sg0N-;~t*?G%
zr+yn#uQ3(ULE4P2o%u337o_u@t@C%Il>d~^7GNU*k?@OzZ4)~HHGUCR;G7Q;-%xuz
z6@TkMvHw9VUffKaAD7^|0DGT5W`rxii~WsJaJAMkl=O*QTV8i08SpJE7oU~TPXJqw
z_F}6`*@<oxIY2(`07?g^7lFRpz%K#``G7!z7g&tOkpw6QG_`(FJAi#rJ75OX*RBE@
z2_jV)XbfSH<DfbtFiMn624D*40x}DrgixeLl_+X|IT4AqjR8~A2}QB#(xE*Z!Kf3i
zqEm*z0k&2Eb%t}j*t&lo`A1iK=s3d!2y%~Jnq2*J&OHi4Y#;L`pB(DwkJOn!jme2m
zxCk#|F8zkoJ5|T5F)EXy<s1i=fQR~JkY!@4`=xenU+(-2dQ=_z;HR!hhlf9PO>$$L
zO7sAlD~DmbAx!0!{wDrEIa8i5&Xmc6U`umDxS1G!8|~<C)CIrg#0)dP2%co^{hB^}
zgH_m}Ibf^Ybb<S+F}9;sT^ZWhpU%F-X|%3bQapY>Nd#2^vydY;16bivQ}ep9%o=`t
z31yC08)zjnU*@Q_(jBpL%>37tbVp1Ta&#g8KJd98T<YrYU_$`=sWpMWe}@p)LM?1$
znU$$9O8H{S74J3ht-aNgEp;>lOgdh};nzAE=T3smz734NQcxz&K1aG~_M&WYF0frZ
zpiOzamv@n$Y5$`k4(-k&ZsT*#FqNPugjlKy>I!AU4uQ3t2)>aqiLbp<p{{eD<jd-u
z$VXOqO76?C_zS<bM@hU`s5=9C^k>z7{%r3F3CU0?Us<Hqs5H|PXSe`S6+p2koCN5{
znBGVedmf+kw8?`dJUwU6nU3IJ;Xm5<B;)D{$aeH)2(_8sHE?u4P!l$>@GA`d3I96;
zC!hE^-96sFwGuUzz>XkE@JINmyJhCT;_;~>WFSUux;>irx>5D_?eYJEL-+<w(Ld_5
z0BM{ySL-ZO6B{hD<!SWT7JCkTL)f{_bul{G-??3WSEx+w;CA8QjK=y$tNcEKIqhfB
zVuYDks!^&^xY;Bs2B2%8e6DHHmh(urv=8HTv9P9jBhp5`m~z}Z_N5DHj>D0M*>CWI
ztKHuZ?Jn?lbhG^5EI!P;3(VA>Yt_n6NneV%1EX{q;g4WQqG@#&{&cF!;<utz-`=K2
zf#A&l-r2cZ>(4+)Cq2N0o@HPa5NXbusm;xx3Oxt~^z@QWke|Sz-^9swt&6eBTilD)
zon9-i_DK$NyVfRCv7%Go%zk%%2AG^t6=|x{n{FktAgsZ>U%t<2lz`;MfcF6;!J}vP
zhZ7k7tPlP2Is5Oa?G!NmGOg$vkPM{vdjWreFidp%IWi?}rEAlCe>0d9xqB|ez<$jI
zd{56uLxgK%^GmaVZ)7~sY_Q_O1vDGH4NjQ2M(1mW=^C&gbb9&{Li8zH!2%VB3ONTO
z<4I=8FH(FI?a3s4z5faT_IuwwrSH%EvnFB@(1p>r*7m4e)h3gkuBoVw+A;>{-*_FU
z_@#e?vgwl?(7%C|nAwO@aD*<Dd;!z!E~DpPPCu*3Kridv6j5HS<lp1QSX2R4^M836
z;t#5#koE+OLIgVA(iGxkZynwLQZ;XP_LUJJXaKf40f$Rkr$+gcU<k`%p8vl|EpzE<
zp72v2CqRhQXOHQP^w6fyrO0}pNEGA~*oUPktM>WhF3T=sEQt|(%l<qD^87mZK%(L7
zX;4DKHgo|k8p~=!=FICdt1%riujXX$mE_{WH2jK=xQ1PL6P};cRkNz8cS!>nCR8Is
zr`!s(5vf`pN({&sM{Mp-(U%9Aq}n%p2Ax~gsd5Kzl-$m=Ubt!G6SX>e0c9&j6HIb<
zMY*VWKwGJzDnO7&3~l=$3p<&%vZL(=Ouz=g(X=(nB)u!^{fenXY%v%a-aZom1oTN~
z#pq{gw*lxwX=o>q1`lkxDs4nk6_)mdboLbi=u%;U2qV(4UC~m&ri+ueJ%aybI5^or
z0L3Lnqf7F3xlVLrKJ-SjEo5Hy4fV6Lolw~hrVs&ap2~Y!n#->4PP<O0*>eLcjj8bo
zDtm6b^`6XT4XZ@HoC<VFxbDI>ML;Wi@4h&4274pl`_6DFAo7mxE2`35eJJOM9ps4R
zhz<AR=s$%OhSRakrIVUSEW}O>FW>dPR*9AVUMGx?q?5d3md>>sz~G`dNFkMk=qD_g
zwXciwYNXP}EtQveVW%uRPMK)T7#1Cnw)J|H3}>%+a`kTGg<HBkQs|@DydbfLT|ooP
zwwrie>>x^PF2dk5J8*SanU46vNnMd_7nB8!Q|ms5pNXu^+Ovu<lY7B<m9$^KFv5lb
z3Ol`c+48L;jhg}jyM^$y&QdvpvD!-=gPaTP5`+x3H-4(7{I#KB1;WGiK<`;vx~2E*
zK#f?6LalK0l*{9uN(ykAD~W;gKy%J?;%WUQv5yI|dn28%&cF0Dez5z=3%D>;+v)<7
z`d?cCjlQ%3p1d~JcBB=MH6`g!=<lSmo#GVhx!n%~q;75os%*T9xbgZ@deGZ;5U49c
z0pzr;&QO0&=nCxh$bp!bw%Lo8CQitB`$~V6W%Y_S6?08hMF^|0?mJfA^SGcQDcgyS
zQX%$vA3pnMoeeKWM4I<axAPMeZoOf@whVSWTTJvR!E-&v#wZp9m9is3DQuKRW>bAo
zB45=^eLQq}f94ZRC!`qY@&tyoG|UpMh~Y_*fK`XsxpjH1B+$wvrTpVl@<vP;4GUT4
zG3)|n*FBk>4cpc~Zt9m5w(W*oGP%9WL{NV#Q3bK*#~pb#0VUg?6s~rX)7>wuorXV&
zAUYr;ZMp15cOuPh;=_`Wx`#7CM1yBtuvc_;7FrVVKa2{AK8UcVXol9XE!S_b8K5bW
z2+9JIQ&wCb)f#hfk3=O<uQHv$O_U&{AI6^`u3^PGdmA3e*?niMu#z70iENwLJCI|X
z?`kClO^Lh?K}aK-(=xxZ*&IO>9?}Q9o50XN2h*4Go$T_UT#MkJxsM|XH@GHxZrqE<
zELYgRb)VTUO_pN~@o<I}%S^Xpr(p>>7)uwx4Iw%$T4LQ2A%iZybT_14(ao**RO<x;
z94s&J?F49WKC(b&V<EaKc(^ll?t;|SkHQZH-D0PCK7)wN6D}aY-suC@H|un_a-XT>
zB)|0#pH;-p1j3Im5$|7<;{6V&ODH_>83fpJiAx4uqymEb{_aSh^$dBGO!ZYt0IFU0
zcNOkVnKH^WZw7`B2<2pc2oqqZW2>8rVWjD1P40yT+MG25X8k3<C3~2g&Gly1j<7-i
zdr6G)N1~rU^I4KEl=ud!j$y-RkkmLo?Sa}_D=fQ*VzgpUr~rjq6~KZ?)}%)t*eXH-
z)B(JX)dAo~>Hy_G)d89djavFb+wrl1sOZnrXikuVykt88x6<RT>v%G>r5=Aw_jXw0
zc`mMw1q|uoJU5PKX!80&;%?S?O(v_N(jrdQg!fDkAw>XoR36;XrlIUC;Gue6UatIP
zeRLlr!2DjFkFaF|uj^qr&uF0^zvjiqQG_!gfXDmDlI<FjW0bnI3h{8H=FP_7JQrp^
zK)!-hJDJ!5!5<%!vF6YteLl^bKq>`k2_kGik1_PsI#hUc@3-G95Acw%xgubqp;Q*#
z^=k5=aPU2O1Zz{D{$V(j_~8hC7ZrKqXOJ5m&_c4pl5eDf^q#6^*oN!qlSbLrcLsHw
z6G^p2s_oPzn>uEsC!cw1W41JZy8Paw{m7Ah#gnnDp>fkrKGRXpb>CgN+$>L1{TzEG
zbWRtaayZ^Gr7X|JA>w_m)rBYwepLz~$BxFCJdl1W{%QKNvMb*GmG+2p&7u~iW!k$g
zSD(CSl31V$ArpECPBTH0p=CHIKZ9V?5P`27MXr!k+H!1sccRfl(}WTK0O{7V`!;Q(
z2c|{a*;?%(+%yDRADz@6>`6xZlD`f5f9$<yR8-xTHC*Hjf*?642uKjgIf-PEAVEMt
zC1;UT<Rn2PBcQ0{3`LNfGld{IDY?j*Dv~7><$HYYeQq0`?!Mi9zcJqLZGSLe09AF)
zK5MN#_ug~O*?QmY)IEbVGV;TSuY4{tY@$@CzxpjDtOwshX7PY4t#(<OOs>ILeJ0E4
zrS<zzqH?Aj()4JMvlD&Iip5E8nGpKZ*zv-1CZ?t_Cw;KSiy{?lDzU_1GM1^_zaiiM
z5+~|E3TeyjG`10xs59m1U?#~6otiG&J6Ixuk)tuUQrVJ4h+{I7!XJAZM52E;oBnu^
z_-nK2b6<wxV@E!yDPP^VP~(gWN8C$`x?1q0=6wAZRS*+Cka<-<cbtB&ZYM|g;_uB_
zUJG5uVt}U7;<oWqGU8et?#zu&{uO43ElRzz);WCYOQ@{NYSle05ymaCqs4gSIGSVF
zx!Q~ZX?HrI)t*0iaL2G*PLe-pVK23DnU`zZ7@mZFYehMG`vQwc8*DtyAMko4Z4?Ow
zxZig|Wg}9(wAd&Vv6XqHUgOdG983H8ZG}IRQY^AVQ;oC4wokbjp1*yr0p6y5kzxJ#
zrhp0*q#qt3#ZhFk2?*<G-e6Q$B#$S~Ux^ERMSGfY?v*pX+hn~I&F&|$)Yq>ZeCvwR
zA!<D_hSEF~8?L%5N2wIzwPf~GLJ{)j`N_*9cEvc<JI7g(^fq*G=6I7Kt8M;mMD0_j
zjLNGD8qSAG_)-^?HQS#-Ea7<-e4TT$YBBpe5|Bh^CDl7Umt(Mi$yeE_niNp$B3P@<
z)yUDzww=s^5#Kd=9oS!Wd|655+y<*^bbe5SeWdC$nbkwH%Rw9~P=+*b??e5quxGi@
zESqF+2PYH9C4#0XC+VRjSAz|#XUH-@Xoqp=+~Yamtyl~!&#i6YJtuu)tQWfT8o74S
zS8s=%u2{=di^dA64_yEoIm)za4IZ$9cB>vRq}eOzm!}<eq%`=-YjjO&5(YmOrDSnE
z2HeuajofogF)A?eho-gDd<$eAvc>p;mpAXpU|dpwwNzZn6;#NFjBj$|vXuB3urM`$
z1sUy1apcX~pf8Obot0;SS*Kxll%8lBtsa$OEdU$#7{wc+WelR!p1eX1kb31=?l(SV
zLZCVNF7%y5lGre*%Y`QQvUXz(YdR9V6QC^X^+m0uo~5ss>gK6xx!u_xDE0L`ev)x!
z&KzpH8N1wQa(zM7g!Rs|jAswk*XwaGg92yp#JeTi(U&HK@T<4&-&44FoWb6R3Q*8c
zbk=IiQTbEaikQK}a>r&A*`_Xvd%9tx@<Fa2&1IuqCA#+-9haRib!W^p4zQ_MzLMyq
z%V3K=iIra%n;DTJ$eOodqO2X;Pr~VttiYcMBcc#5a5KR@g+e7xAOacH&G)+4L{!^A
zD;^m*NI#~S7K-W=<@-F@f|U%tmS|q+lx!Y%IGnwru%{szLKbE{alP#N%l96MT)Pa6
zZ=#~CWh0JCTUFrm*{~s+IrY2}$BYHkL5CSGfwZo7fWi*f8zbrn)YW3se%MFeYLe?G
z3jCGHX1rOhQ?^p(rx;M$3__0z`;-83w{u%5QJGg4m4@dl;_s>8i*eBG$M))_WAvn;
zxe<3DPcru=k7lw(*@dv9$nJocLv3uPl_U0>)P(2!Evi(q`P=hn)YPKZQ=oW-$Loyz
zdV5E_J^*}an)DT=YF=&0P%tsnVDD@_>x0IupgG{6;w2M_>6xYcFuq68I`)YyDK<Sz
z#qBa*K_aq%`{7|Xpo$&oE=y}mhb~I4P<Hx2Qlex1{<g~yf}d@jDY%*Rf3lPSHgT|q
z-1d=xw36v&I3TU0PTO2_WL)(R1h()Efn~y+cNxV3x~7zp-021Iu4b>M%nGcS*LS-a
zU8-;_+tB|NfiYSC6SM|XFNDmr<jfGU(FZ}w)5xCXael3Ux896TTKItS_Ex#`(1?q&
zqQ!7+_G3qIeynL&AT=~uB)^UBh0Lu-Vh`siLP3{x_+!<2n-gyZgif=iu_l{4ummMt
zaZWQJ=vZ#0-8RvTblZ+L?xYJ1Ex0QMe<26Ok~LZrj>WU{Od}oU-A$vK5Q?XdSP@sY
z#A21z;>08|>q?C&g!RuDo8ipmCK`+JdGr(Z1ZjStjCm{$@^;ZXY9?LpYQ=FlI<vhw
z%lP5-AeQ5+mb*x@Rih~v<W!fp+q7eMXmTuZuZ}Iy2QU6gWrdSba4c~&s{$TVvOw~1
z*mULNmdM@^Lxq}0V)IK(<wrEJlYxSKQg=O_b83>7nep!{o0luIO|}X>AbknNg4^vM
zT@(7^#?3xz>>mCCo0(rsyN%(nhkq#diGdFCD@c1ZcQkLLYGdB!gMjJlz`NKFYT5@~
zzJj(&vpc;7z&@Rm-a4vlUib<!{PoXxpqmLcSo-yR&sq;Oh0V?^zk;%L8m8M2rHSr<
zzr>lwJA5bhgA+UlQZ{|5a||FSrcK_qb~0DwkVm|}&9m%0Z_cF7?0cA+4}aG)&4)4l
zp*;VU+o;e7Wndu;I(tC45&Cqw!~9OidG?Nsl3>s7YwvTr{9w1|5TXtd3C9h27qVAP
ztWFHQAH+`q&&=9Dol!nAaNhiy=9Lb~&52&e79&T{;>n_JD)qC>%F$71M;hh$zC&EO
z>MVYOLfW0fH)vsdHMr#l{PQ!R{wb9^xvp$+4I(>O(K%?=Tu~(^@zJW6LKY)c%O`FJ
z+08!bi8dQ*WG~S#FbrVNUf8Gcs6zBdy2mXc@gY37Z@<z~W=_c!gaHao9HDzoYc-LE
zdG!`nZX^eRbqpu(IS>#tY^1dwe6JGHUvN9+n(s*Ob;`xY=<avT^{!v^TEkCCK8H(*
zIJn~|zMPeMsWf{-4k{Z8a*;TnuXjZ7brED33r!{7%Sth=V7YZQyp@J&t>G&utS~2?
zP|+nX*!sm+P@Yt{0ByJl6w!MklQVuoM{?ZS<!4|Ve|N_~q>$1=bf6A<P#J|i;bTU!
zB|#lyIWCkGT@@{7b%1$x+xdKz*))JcniDGlo(3trUR$~~jC|s!zhz$&HTbURi<)ep
z^$c^|5kyqOQyZ}sTha}C9xc?<!~LGPs6%BY>Wz8EP?@vZaH2edEX-HluK?-9?K4CF
z`H=lxswQvzX+jQS77d1iCZa{v5F(JJd&1FPqaD)|Dq$Vdk7l0jtuQd7%a_M7Q=VpP
zs4wwF9@FQNx!7_Ux81Yu*L>-+85eRWQ?)?1IXMD8>@a%jQgmO#bG5JSL7h&{#iRGd
z4QWA;O(xFtE+%@F>o`lHO%<<BoLRH4ZKk7J?;~z5%OR}lmmH}L$Cs*VBL^4BZ5bMy
za(b^mL$izRZg66a*!*4p?q9&8|DH=_>a%Eu%=6VNMY3xq&oQ5=tK;Q=T9K6?v+#}W
zn#wf5LU7RvCFX!9M`-hg_hd(tlm(1b5Bj7LamxAZfs$L-;szMI$cKoEyRU>R-;D$M
z|0qv?(S`h<vhe^y!AF2lV2DirD?$N@%<012F-X}igQ~MDMgK+8txnb>;cwc^QcpPl
zWElvz`-;XNsW)4<Q}d|XUi?y{7|UmSZ8qH`CoTX(j`94T<xk_i1^4ukC@-0XLQ2gI
zFI&dHqOlN}EywnxrLte@uHs$ve9_amm@0VD{Kflr=%T%{;jnX=uV<zmyog?%E$%j;
zSRIUu=U>eib7TxaD}6rzTFpvDv`ISBkR%R(v=DxSK~%}l-Af_eA9}a1R+ljIzk=8I
z9kJ${nR$00l3R<mWhh#nHC=Ugw4xNeZ>m!8sGa6A{-BS`wy{4ad=lc~nPpEW7i_$H
z<H5{_kA}E-3fohMCq>iq>C1eVHl{97UrIK*jU!5V@k^N?sooPYJvQRBDh#IFj4dV>
zq&uu;?86h2X+`J9<sbYFD`*ziW6saFl8cvmop!13AcjJ(?>hDu9xnGQ(RgA%h;2)Z
zoNk0qR?CJ|8T&}KR%}f_>bdzPygx1j%ig>|3@<(3yRfKzIpCtLbM~C=B|2Y0n013F
zrhK6M7hMWvKm#P-2(-^@O6zzzVXm`nq*$qK{YiZLkUy7Eao$I0o^5gsIfZ#m=oKCB
zxD4X-K8O|`2Exk|sq{%OdTJyV<-V=nGwt}cw)5@HQF`zw5g6kcCOlWAo$2T+h}lMT
z{>m_9mxqc@w^8-Z$+Soyuw%?`WXd&GDjYzxb?H*(?ZfU0EC%8g&kW)PBHLsalz3&J
zagTZ3JBr(c=O^y(Ii?`4X%{41QB3jfujYBBgo5>zSb|!`XpW`KTkPvb95^cAkeKuv
z+AbtnHy0VA+aG(KPBGgrYTPsn<AZI#x)O#|v%E?F#M(oS%|i&|`s*dHbk#6u=REQF
zbsp?TVyTNI{0+;rY%2_(rMLOo8pAvJE@pFTB$$8#SNQe}f{be_!3XO2N6WdJCwB_2
zhz>kv0O5-An7=s(7c}w1q%{@c`4K|4sCuT=yfYzSjWFq?k&%8U5G{nk*U8J?$A|Ut
zzF#VPnw71olAP*;6+W3ZVgrHzztR~yv`DyOZCuZ1Cd;`lYZ6L3V-}yc&;>&K317zC
z*^QQq<zr=-&m;5zG2xi|X{`#nzJeL1o4{5X@9MPjiJub8ltJW4M#~dPKbYJ_q}kb(
zAs~uvv}50WVK?>icq~5eQ=>#S7Q-D1$1N^0v=yA60h=!Cq#byAIVZd8tV@g2F0LPz
zR(7^9j5i4`NuK#w#%PkxC30O3NX3K7NyaSP1~e$mv%uNyDWdwPB-J&AIhvP~#jd{Y
zPoVIzK*Xe{*nz^8YA17$ajA9iqf?W&1C5Fvbc&W%AYdQ!J)uN^#A{fTt@rd^twdN$
zx)%7;M~k9Be5_&Lg^VMJEZN2>Y8o~DIpX>y4*oA%_l$dQyTt16XquU}s%1?xNBHuU
zE|?;p%+G%XX|@K47>ipTOp8k<aYVVE^8+1nM7t8xL(6w!U9j!xO^o^uLTUQ3T^hHP
zWVrwUdqzfzOkRf8FtJXc`-<Wvgl@FlBB~B9KqKD2mpR_}+ba9NPRsqC^!WYHOxB3>
z_SB(hAzqOw#jtCZ!7IH>s+gcgm3`Cj{Em}T#}Wz<lbALQ)+~s`@PDZoBWD>G(ro#y
zYqty^Lga0cCS~#@sXizkhs7(ZDSj%D6Klf$`{pTw(jW8~Gf33_qzHfaUHsfwe!_Ww
zdTFey)`R~7C|E2$ux&eWTQ>kkIn}!1)(Q|B!QafC1caoyzJhKaqURv@?M$ua(%kG?
zOa<SVPq7|Ay#Eu9Z+$vLKrcHK-Qm%Cdc#2D$4#-Hy7<4JW4VWXi2&`yp~&h5?Dq#V
z0O``!_QBDaRQS65PHa39(Cl0EzuL*3;FeA|%_=m_2t8FRSW{P(F;xE6)V~7kp8VM3
zQbPY$sb34(TB2_0PSs_7ySDRId-&a1&lQ(_<MCg3A^M~hnOmvR8)-vb21dTdm|ysB
zl?V=r%dSVx13mW4NJZiOQ${|(HI+$XVnirf`F4U;GhoVh^)Y5iMbXY@8c6D2cLsfT
z1phB+XZc4G$$Q!2W}3TL|J@k=?=6+%M_PCU-?}PI0L7yYg9GZ8Z$|JT-;Ce~h|t_n
z6mDa~;libWZ$39<-Om7@o8@l~yfkaHWFvJPWB;I3eHSvn@Ff4Me>>b~4uK6_urU>j
zc*LzL(_R=qKY2G0`iU72Q6^tx)RW{`YBTjG%OXGvA7EJkvXYA|f%3i5_+@Mp0W0t9
zWlxA}(2gd`oxJ*M+nt)(TN-Z-6kb)Gl^i>!yP%`$0Os10(|;3V_-i@|sjCkBq|B#4
z-NkX~dB2z${eu`v%R8XOG(SKJ1Yq~#=K*^=3b|iFXe{VA$Cs2W+mr?if!w_^nViA4
z;=agSyo_$U|4gdsM?z|Y-A~7da!hmI1KI!JXS_J{u*6_tHrQD;MQyx{$0A{;xVdDP
z{9!p<Ek52fKetge$567u+U7zf|9cLbm8sa@ZHYg(CH|~EsIQa+^Sh|f)X+30^pV%;
z`k-~f4cE)>rO<4{xXr(SX~b6$l`%LBy5y8yWC*r8)2T}9qtQ`+QrEYV)_PwHx0`AR
zP!<Abqo4Acqfa#v*=NSx%tx2)nLm#PM1$NY4P?(DOR=XHs$<VKWqV?Gohbu`LrVe{
zQ~{_ntbPA0=%hAMcH`!x>^?y72LzUyw1JJyOBG*1ejLbQJb6V|K+kZV6L26Px(9eR
zC!%c7lL+N=d?V=jQTnnRBhK%S|L+d|&q(I=_fO8sUUjM2gI-b*u3zZ<?t~y!mGA-1
zV@(A)rqBOgy52YI`U)c6Hsypzoft9Y^XB$qR}r@BY`T1Km{anvlO|(`8I1&eQHJ4^
zoXBubK%6qcPM2%1u|2s?drz$QN^|NvDZ^ZQZ?mrc0Z&c%>SVsNk0paKgfN&^Q?haa
z<gaJ^{RRFGt^Xe<7AANbeaq1t-JII|vq`Rc7vEB|b?4`42Y=j&Y@dioyhl&TCYu|T
zV^pft@z<iDT*gYJ;YH=z@p9CEZmfI{p#J>17oik__Y5UiU^7KS;7K6Y<p<q@Aa4L9
z9p|=r$%@wDqg~N^<1FD_s;u|!8%c!>*k<=7)|QD4db^r<ROEI-Y^jYLyAq*P9hBC=
zcj?RO9s)a+$Gv6AGwsv)odM4qFc&WJW^dhi$p`BA5ZWew^ni@@^nwl6Hr;;}8~hXh
zFSTuw%7^QFr($X~o@La1qoqB7wOlvG4ZD-|;#R%c0}|J8{qo5c?rrJ@%UJ^tNWNUL
zkVd^KaoghO72O3of0}t@D%tKXo#9$@t>*m4s?cOb#$~*0GWpLf&AzQL>yy>u1(T0p
z@6UIia@LwV$sK&8_$dAr<Q*to6bbZl{7{rfzOUzj5`^68-&bViAIdpsgR?Z?`>bXD
zv6f?HWYvEKeLp7zd{@mfNP~ZW`ghaee{JNse^dd~`2Mj~3g;k98%f?~A-Q#HKlxw}
zu!Y{htmDYcAoKYSs{cpra~LHN%cMn}vsQ2KQ+LZU&-u!Z@;Ey>JZ!Xo^+D0{Q3fby
zJvP^4^6u+mBA+m=yn9K#jPC^HF8-aG^UJ~mpzHiU`#XcnFyJKHEJ_$+pk7hk6y_*g
z(>GQW>in{-Ka8VbKXQA!y#)_&T?&1^tk*kh@d)p{+8gvam9r>ZZ!CyqVLDhMRy?35
zkat9nT6gSKFyy?DZ4pD@@N}X9#94G`W;i4BelO!0;%ynr-PoRN^yFB;#%0?-q#kWB
zS1EgQW58W;y$MQlv@{n2$W?{lGwfehW7q~oC2?p`HkfK$=_fU>0UL56&2N&vI_+Ne
zZYs6)VLDCm^kL9d;E~C*5GMu!U4GS73#a%-0e_R0u2<C4xYMDmtG;dJAqGgsvZ3AW
z0tvaQ8bXtr!o<sXmt7`I<?vAic>(setw$HC{t!DB0(fl>PuMC-;u{)n^jeBz``ISW
zwmW2&a>QKa0QJJ;Wurmr_a1}uI@WtUO=&`FO^v2`$8(sdd81qJQ^~?FYavs5jFiJr
zl0L=iUe0`<mU-gYij0&uiuku&P}}Q#PyN{&UN1{ge?FvstuLr7nYOc7&aBawK?pi+
ziBz(@b$y3Q*COFD2+%T}c0R}EmHk6D8|WV`RxbEBz!Jkf<LR+c%#{#8Jdp|v?x>x}
zjb8KQlQ~B3VzrFePNAV)M^SX}rS#8VfCqA2TcxBlGbscxZ6KAWqWtVJ+2}vwLMhp@
z{}Sf<Wf*&0PxiZi&ktTBO5$}EdQu?9E=r7n;>0w%_D&^UX;ft^BKzvgMY0~?9P+2J
zf?Ue9bYY31Z}eg~(v71C0ND+IDD@1+cUV1?TWSpM21B@l$<{S~e&ks3@uL}O2b1GL
zF0RCi^_a>;>4SkBS-|S<yZ0A<L<_5r^`(GvS<}ad5ThwEu2R0YjKTkqs1n~JQCSZ1
zXD|Nw*_DwT=l1UeZxNW$PAA}sp}4w%%TXxW?CUl{kCV6KS}q@F*fqGY5S{60%CY|;
zGOn$q>1XQz<7f!xV7+V+cMVzw7{XF%o*8QZ5|g3%-=xTk`86mJ&o0NaDU8Gi;UOqN
zr(ELsVe_&AUOIn7Df25}WPW;H8Nnx$n~^iKo!79~lvy17^`wC-`F^<Hq^6~_7F|8A
z6lB1mC}aaDPei)fdTXtfwQ*44S@ODd`(6yxvkamiUj<RVqCxkbzBu~{?HzfP4aT_c
zT_8S#_SpZ3&vqa_<<B8`K+o~bG4wY@^<kVoE}HARrL}%(OV?_aJ(FP-$K7flsMPr}
z<leKvaX`F3-fF&b;l2JVP{!TL#>Z5aI-0O=Tu~|`6Qv#k;wSUQJ=+tedf5K78AL)q
z+zceUB;rru9q(bx5p7L(XFJMSP0Gs+UNO|NZ-2cg&g+hQFRGgmY8dVObq@ZzpWU9(
zu2|mEPWbQ`l!2%HQ#Sh=g}ykzhc(s44=JkZCL*!qF4<%iwd6m%_)gWwAtoQkNDrHN
zFp&4>*VW*&T#(1hqy$yz3eFoFB~eq~=rGRz7X9P0KRvMQuqFBz3)mxluX;8<-WY<Z
z^Hg-wCKz54GA&sL`3nKh{Kqn+5Mb@Xk%BWz(IQyQM(l#r!inT8iY~I<_!eq6#8^Jm
z;~jp}u;(w@>{_(D)cP$WO92A7y!38v<<q)`Fm_fJRTdrPW$mAWxUw2Tris7_|9DJ;
zT@h}0;mBt0j^2wCpkEm>Jh5RFxx~*VkQ3o8aD(-bGEtMN$x1a>W!T;N0p8kQ)Jh-Q
zC*6*FnMr}~$$M#nkXqPB|29N_ityJf>YCiu^dPLAEa?L3c7o=*{st(kcp$*qnIlDd
zmRv@#dWA566`1G0%g%3=(&7nJ=#k1>6Z-6Hy|U44pD!4*c&){-abV;;$d-9CjQ!$=
z7|9FXo8Bm|tqXH(_N^s}?F(ejii^ugki$yQv@852XaPabr|)=N=4T`;+VqlCISz|;
zLE3t`<2)HadaO1*AuT#6V1={4`uT;|3O28BXX7f-66do-T71?&$)JC>6v2cM-?4s}
zL10r9@cm=g#F=OwW}gS=5{>u3D!yo8SKT$46teapj1&MU*kne<KfgOyl~FVhh)Yei
z2}&D<|0u)n?DWZ1M&AD!iT<=e2L3cwiVyl|Ral~eCCBg1%^2;TDRyb?owb;U4vh(6
z2>+Oa#TV|&KM7q-71w3B6dgi*>LN#>t&yMti_S@!Aos3hz(7uzeOI@EGOq_~t*lGz
z58fj%D;<yHM+FrFU`3B!cWk6j`uN?uHy5n5<WZZlKh2L+*q>`^K3rN_qj?z>#1^E=
z91S=Q-~GN;+jR+cyD+~ZF645XjiT{?6v$SxE2}Ve)OdE*&xtKy*6{xE#ZXUB^v4~|
zfcw^^c1M+p*jB1Je}p3lrJ?`*djV5D6*l!`%5@#0f~yY%^u@6*NP`Q3Kr3Q2xPyla
zl;^J?jTDp(5Q<iWwI{jH+AuBGkAVyViegJ;jbGxN{KaKSQ@MQLGVlF7Rajj!Pvd9P
z;fa`|CH+<wk91w{D>%GfPZdiPo86(bM*Lc!GlLH%H{zXLiF3UpW<_MVUdCatEfNBA
z>JJejE-XpFs3Z9g4B>`h7x@iCyr7_2YpRWg>UqflQ5eWG@>9X8N?@xf?%CSty!>K?
zT#hs=D{YO)lEg*I<(e3-G9dxVj_k)LsMYT7>_!9VW!x}rF$PeLP9+zsWVxPpf@&LP
z;HAj?9|Cb~dECJ&PMK=8DQ52PMY<9w(i&<#v~=Rmjw4gwrd?U$VVu+-YnJ{*(zw94
zV{|;0NRSa1?cOfL<2-AL)6;K(zhiwfHT?TYFN5fXuGanbC%KTd7(G1f9$27ksEjHF
z=d>!LHl@Y4C>+Kr_;IjQNxw$}7ry{in)8n;P5%xE!-h8kRYmwRZ*4Fqev0?EHlVC;
za9|>M_I@Y16cCF*eKz|(Q2_vy9R_w{J!DC`dVBfFjfY<%4Xu8F0)fmwg|3P-<of*_
zYAv-zYlkNQ6yU_{{u>lf5k1L>!592CH#Tr(Ot`K6fd)VXDJZ)+V2<|Mhw#2(`>b_q
z#eydRN9=g*N5F~&1r9u9zfe^<pPoAdUXSIr%m+B-fFmjRE9i*)UJEzeBYgQ>WRgTp
z)uJ{`fydF2lh)ya*SheCaYynbLY~P(DTrG7F)q#zLdJj9Rrmko@9xWn$<S>2QzDXc
zmn7-?^Ao<XDFvJ4-t{Sdb3t$dJY=^A99uO#T0VI)TzcK|ZFTc4T84UzyHRgW4Jt?E
zm_*IbByBuIPo``kc09vs??Sm=UR4p>+%<jw&GkV>94Vg%-Z#}SI@D>ZNqTTk<Yti)
z28UGaNpUJb7IGL4*bpxaSh$9!+I7>y<$H<}$9vkuZ=E@#$p)VeCt}OMbsQWR6hm_r
zF2~|dBiH5V6j#S5M+lM~;ep0n_)uA+O`8ld${*kABNz+jkq$@ioh<chH8j}QP0-w?
z!~rGt;5B=?X<@NPXkf=v$hmW=e5NU*{_&;2Rp7;Mq=Vc{$V|&8GAH>~68c~qy6(66
z^|7&n#v+gVI5Wuj5wY!nW1s2Oy2-t2;~B3!-Mb8Gxk?j6vp)LNC_$?bU}ZF*j{c$v
zFSE}I6!ewNR)p=7ecXVn9duh0c9kM$+dRce%$Sg*L(o$bNa*g$$$MwfHxPX6#HuKU
zbNiA~<0b0nS#X1pGGQIv+4xnX%V=@qJv3IbOxrMCU%-VX*=(e7_g$L?#og}38m(H2
zf!b#hNi>XMg8T8)6;&jvRnFwL4XKH*)eF{_&y(>^^{%ZauPv#r$LFN#U*CgXefcKA
z?@)UfZ{9oUg;CFQuLq-4kq2|I>u=&pb1eMbSD4`gfLk!0FyGm#Y)3OaY_0IT68>4f
zg|~iwfPAPp<Kse6>ZT1=UlSjkPZ{3&jHkNT&*;<^!q5P{k~i5GKZw`t4WZP+O9H1a
zn#L~0QkZTV&@~?k%+-0s2x}C#F<AKMYyL7)T${<)ayLc1eVqoA%h?DACV~sJG*|DJ
zb&-W%lD&{UHhOZpHf~5u=!J1-_ssQ8?1`es3oX3JfKCw`*&~MW*8LZNaqB(`XHilX
zWNRRD$slnyw+roJ8;H%AVIG_7{z41aI>PN<6Cf$N%j9LsS$2hAFi(_Iy2l<+DuKNg
zVm>9cGyB{Z5b9$>iLqu%g5=Ew3wD*;do<+kb`2L7#OP_|KS|n=-X62b3Y2<ojKs*=
z_TI}Z8Yo$SUfu0VA&n>uz1|%`%P3wX`@;a1MuIG~BQjOmdld-@PD<&4f<@%EA3<H?
zDcTS^QEb#RQt<Q|F~N{H)x5SG(=}j6{8I+7U~ts|PA~4FxJOXri`!;cVBgJ4o_Fte
zuM5qrfkf_+ik%v$DuNz?Ydar<8#}2}sXiRYlS~eb-omh)-dd(zE}BaD3i@GeP8v9|
z2AhcBA-Cb|&Fm2CLX+9PlU)qeB)N93Zw;1K&6fbmY)_f2wF&9T>C)zLv!anL-A&9q
z3=WyJqvVCkv~Wjvl8$ZfXEtx|V-|*lq^q6Sae~UE5bGV%g3yK)3CLQmrz4wwzY_(O
z4nFZfnzGp&wB81gR6jkXBjD5!{Ai(lp0;{;*E$*O*q@Z3g~d2{Z=HExe-$tVK+ber
zY7vDW+I;pDH0~NLX|a&I)OWJJZ3;M3{5U$(8yTc{Z2+5iKm0UwZZ$d6-EE2=|CJRX
z2(-?M**Ho6qO72sml9(s{rhK9YRg=C@;rOngYJ#dU?y9#C;2RwKpsstE(if+`6+Ny
zLWunKXzrdC))b@02|nJ{1R(_=%jL9VmYT0ef)JWWs{uT8NNURYK|0J70&6B^CINdu
zm4XdYxm8fr3AdddzB!DA*p0|Bl*RgzSTFC=Eod}1rcH}EVZ&gcgq!b{(-wriKL3&h
zV(H-vBqcITUqLqKVW(@`yYu>AK~kJEl^*;-=ufC($T-iG)|gYt+sNE5zKa6K7(ukm
zZvn1{)Lk@fr97}gUIR{Iee;p}`C({m8#En)Dy9;*%ulE$!Rt9g<m-FO42wQf#orW;
zts`6TY?-(b!h7|u#b)xtW7lk!b*JmJnk;+_3W3u8OCU~F`H4s~-zpzn@<@=BwAr1Q
zDaO{yNcZR3rNrm~*t)Q}*e-e>8fRxGUd8Oj!l&2f>M#cVlRAIQ&~H%~4<`%cX<^>{
z?BQXMLapw~nUwkf1Dp84quT0Sc3vO3)={hYrN{%kptt<>3d9yxfQ|0YRlXiZ7VNDV
zg3`1vHQK7J9B^Xbc~XQU8CN)n8xYwn6A9veFT5Y<Ez(-HuytrpjZpWJyxkl5TDM{l
zSJ8X!=XhvNoyM@YC22^|XVb+#7NaS&$sna)!s}#|T_Wj@nyURQk~d(Ydy{f+R(_pz
zx^Cfzr#}U#49MWXP4a_;XoX%&7M4Ep347DjhLu2R9<#t}iZBSzK$wM<xv9U(38Syp
zvt`A40t<0T&vp2#Y|n-(x6kpl&9k7VD#!P)TOJrOCUS*#ny2Aa1OCb&gP1MZ%E4y^
zTb`by_C~?dABF_EiXL2g^jPe3*&`qdjQBov-i*|Zvrm1-*&fLCww3TC6&O4j#D0gP
zD0I5JCEKT9ZblWSE|BfA3X7nK7xS(G_g~}`F&QpWf2KW+KIB$)UGfr*$wyUAjF>f!
z+R4Nof65v}e)!c9r@gDSk;=*fw=f=7tv9;?1^=fs-$LQQvo!!#m}`Ndov0_D6qBl9
za3JpDr$rxw3~f0aa4~vd`eGyhl<@UC{#!ud)uY5%p0?gO&a(BcPRnGfE|8oaOe}hr
zM^g+W=B{ZcfGO7IMUdjT$b~MBdyV7!ysP{?##i*XLx-edy#cp}pQ?B~%ny^92<+5<
zt2R|Nv+8CsTcDFeh1Bx4;k+bVBR|%S)2+C_a5p=0)d{NugDun&D&1mk0({Dk)uK^0
z92laiub}XE3-2uhT-}_hsGh=<<{B%a$WDsuvH~wR)fo3*+ck_V8L6^}$smv2HU-*E
ze<@UC>_ERmn+bjAJWKh+;w0Z{@}T7_?Fo?z#uyy$0bu-6z>SMBiAw;R$JD;o2(ok0
z#9@v>EmUb-m!@|}vBd1>u+thoDmaqH?Nkj@PT=Nt3o<z^*8^RQK^e#{0~b4Kc7dm4
z_ggyZPb$UVzO2d?<(j&^@k=VrA+cb)DV=BPGd|oi&vP5&O`_W6bubvrw@pGRF_ewQ
zSSPD^71WZIVkBp5dFRH8!gX?D{q1{Oe;)4DmWxQ{9I$%ViT7#^#7}B6x9=Mun2l;$
zv_=+>7Xa~@-eraXz!PNH*}Zgw)=1;`w@V@lt5tUdxCMW#Uk249au@DR1B^>Yn<&Ev
z&mIwfV}+uVpeQ+{?L!2?(MfY_ef8OeIF2~Vy@gtFKwZwlz*!Ll&i}Eb-h?v;?Mh)~
zY36=18FFQq;(cril$xSavE75%!G=^$ERL>eVi^wj>dA8#p}203*K{g~dL{W~S+#?*
zpNHG4EVzZl)|3E2VK0)JyV_Mu4_)mmq9!?_+SCPdS+)p0l*$e%G2Ifdmk3t%bYa_x
z`~wm&xUCfdMR0@VE2#I+Ssj?SFzd*eeXor*1r$y%m~M&cmpPLq6yxjQ&)&JC-0XSu
zOFA8u;ULv!+GQAHm8$BKm)PQ0DAYg>6+?C#HW|cxG)U8h9#guyk?W;bYr{O0zNKY#
zi07%n%fEmDL%w+M6b(3OwM@Px00Z6&*VkUVp#|cBq~V#pFvtYRI^d?Spvss~>8?aZ
zXKh?19y#4*4w)q0@SXk4k9Hzc&meZhCkHu2C56GdAtBIeA4Z@yy+N)oqEnV3e(pX4
zcMhiYf*yV%EWD3-#|seH8vo^Xj`;||Psj+6R{aV!X{xYl;!CQa*_k)BV!$b44N!mW
zp)$nPh{?bPjc=HrXIlm-#~TM={(XZte{n~laJ-IlS=jN!&WXWi1EpOm0Q5Uft1e^B
zH`*>;oarZ`z>d(3pJAoC`g3-dZ3KX-Oo;vt_>%|S-fB<W=)Uv#v2^j&x3v$nhZ#pG
zofe$Be!pSD`9Z3?B7awbuA^2nwAve>JN;NHnyuwVmVhh|-w}$q>h-8H^r3;T(*s-q
z7b9IQysOLm7>2+^sZsr|xhZXeckM7K6O`~+iPXOufM360wJ2l&d<zOY5=9uA&YBSQ
zD4E~Tu61(xR&(+vs*WbAe0D_)EMoTNRcNRFmXmg?KVMHZiWe@Z0xx^!P~G?kMyGlA
z2S!g?$C_`}0cOcQUky07GD0+Bzq&Zu^pw_VWqzcmu=);YnRU9^=oh5ZnfHnPRj%Pj
zrJYSj%$p^1DnPyYqF2O;6^RUi&v!0SY;ODbx!RwwUe;u}HrMLp8jtQR<@hzV8S(?0
z2&@+w+1EASHKwg{q!01l0EJXt7dzF5MpWHvQvL;`-}(7kjL{@WzFaV0SKPLKDge<d
zSTnvs^vBSL`=+nHN!3UU?R*7gZ5yp+7WMyu(Lel&(Sd|)_Wt?(OvmW(mv!+j%K`Sx
zSRn|22skIXgme6MVlUI(ZnEO#_)W^-Zy>$*S3L6ut{k%KO9uN2+VN3;ReI$x)#MOF
z&l@9lsuxQQwp-{%(=-j2<|pGj)i@=v5RsIY@~25a9RCVr<-s{R7zNwBcN!pRxt^|U
z$-7QEmOy6aOOdv6mMH?HUPN*0rzwS|=Csx7?*MwzPL&p3)HHf9l`(gPnj5mkGotbi
zq<2F_{HV+d=q5RAWkg*WlkzI<E}FM9@EBEgs)1eBV+s85X~q3ZwCj&cK48Vt2@el*
zL@~pjYY<L)S%-bBH@phspWRs(TP_9=I<Rg2`|B^qz>EXsj3`5~p>H@!jG9b4y)dF|
zUs4T-Zso7?6P#}eL57xW8F_}MLgj0dmrceiovj&6?y|1Mr3G?|zh9)NFH4d#&iDk@
zu^btgHnS%>G*c!2puY<&0f5!*#Q?9CK+g<POTD)f<m!Sze}JlR{Zbje9hzi3t72mD
zU?rLA7403pAcjCc`CggjF{%wSOkeEjlNKq(fJ<(>!tGCQEEz&s;ihC$&domgUCdaY
zko%oFwug=}ds6RhA1m{##sD##_B23?6D#gK&0Vv`S30%(^?F5<8`cO79&@4Hal@DW
zMU19lDcdDJVmp2zYE!jdgsfF`1+?_mt09*GKLWXbkZu3Ft`xst_j?Tg(-<&#fzm@Z
zI>YcSMun_nmhZcFiV`Phe0J79GV40Q#%QHRUz3MPstWlrDf;<?PpY1WoZONgI#Vv+
z9X}ZwLKDC}a+en<aziT~KmC&8d0XJh?E~m|T4y~<Ljl;Xv-g)l$bRA#oi)8Lp0Kp0
zqavsIVQ*obBl7gH-Jf_&iaY~oSbAR{J0RUjmS(*Nof-CEehad-NfnL_ud+Ac)_AID
z>kvflldj{ZD$aJAIt-NHwQ6Pp;5=BUm2%oK^7Nw=wRC6~PY%d$JWl=y+uJ<%?>&Ei
z($Ri@|KI8&@c-R?Un3wSU;~M>os`V^bV(S5xxE)=d~_mdY_YeVEE6eFaYA*-+~pkA
zkRK&ACwiO0_Vn6fhFG!-`V%AG8EdSL4OTre9nmAH_gWDiwWJ=S<EZGRdra<~e$qht
zX-mqrgNb+&<yT5?k8MR?J7=n%5Rd6)CH;OKs}MEdj1otx7a^A{n(7wJvx<GEcv^+(
zwpj7X&gSsyms;|NrKEF_<|@x`kMiowPs?-`r|m!sImU-^fSm|FRk%`QgU72&hUH_k
zVqew+^kvdQG63(l|Fn1HKO&_4{@d^I`zK<c4WSuz#E1LQuh_6zMICFkqgCkL8P~C_
zX-GXKMysjW@_w`taC9|8B4|}ud|fw7bT3nOw|pz$6T@k|sqAuVwD*1_YKB*+B`H@#
zK8F2#C;Pnik94{}$rpsC0f#^@@+6o0rDzN?ow{GfE6|=80y@tlLA{gJUqKg;`zET+
zd1>eq{ZH8Bg_m7XoFVxz<Wwa}0!bK0Q*B05^q!?tIj`8#0NoHjbv^<ul;$2qU4$>o
z!G&v4>WhbEuUvR{+Gv@_$@XF&BG(#DK@Kj;#Hy4k6+MAmSy4Dx8Cd1{|4Dbwf26te
z`)`W>aB2HJ7XSWOP~ohumZsZYo!jlwKS7X;s&j|xG3BH#HhCgK<lqkyM%n3NO2p21
z_`0mosiKOfPy8CE2K;#tQxQ$BzRbD}*3Uin9AG$)6lUx`%dB(E2TJ=u&8jF}ylR-p
zqEt|Y<JOul0;Ytd{UKlI5XL^v<luEPZVFSo={M^<T`3OU31B@YBxW;pTPsGjpKD(W
z;-YHqM}`|A%$pQsnP=&-GIQG->11GQC3xu@9yfb@$V0&VmG|<ol~l#)FmRN4agi$Q
z)v6h?a1_1sFnK_B{4#JvbL_g?b~;t1Ncs3yydoWx4pbCzgOW6mbR0NB`X_18zyI&|
zEcD-ufy0FeU|Ao4b?YSFv1L*Xl^ijvoEE0=(Z^k;GZnNWJQtt_pM1rhT|D1y?~va0
z4~Q2Ki<Yo!VG-CwGab4O2(8}ESn>+5XMXHM>UU;<RR)gjVv?Mq@VjYS=CtA%XWW%j
zWS!L$l7A?DXxa%sTO=d5^XEUY7&CW1r|AU94$RMX<(Lc>hr<0?5Cii<+fR~%DtLFk
zkaLvDcKL<*A<S-r>0!#@O%%^u7|fg|KwrwNwUcCb_--+mHG9<5)SQS^Oi#-*TtZy`
zxb*C1QLG#uX5PQvI_ck0>BRi~`~Ssb&Ar|lWkx-%TnC4S?eWum@T{$<<?-nWAFGf)
zC6x%YMcqYCH`r@rf^{qs;Fj0<rq=Goy2n;H`-jwMYEr^mpH}ZPZAUxi_Z;>Ow5)Ae
zNwU6QecP-llQUV{nI7hy5?f8tR$ZD%gyG_0@D;?Mseg`l_ak#jlPqkGujBNVkyX51
z^2x}l-@4Ndv|gqPAU+VmVxBFkYr$C>CKz3KkBSeOwL*{vAD{RnnpFSZa{bFK*WX*w
z|Kja<szKy(_hYbNhe5-Kb|aN3%cfgjK_xHX#pjykLKy32^k{ZQ(vc?q>^lZJb(%+o
zafjFze#1V3WW9d!WlTtW_}(FOdOam2T)pOU>7Lw%<dv_Ws(?E!(2JTC6DZH6qgo~V
zXmy=8mA!KqQkBedxSGQTpJb@ugXu6bGGm+5CyzLlOmE8A-alV=c0GM8K?rKjwbhqk
ze}(%tZ{})q4pEKR@MFAV>GxZ}f!DwI-haQ}?;QJgV!(_aJ)Cw;B0Vw#j-s%dxveo8
z2o@9@+Gtd+F=}~PmnLa!>vYwzqAL_opcb%)6>q<8r2?1w1m>0=OLp|N?y8{3#t8wB
z_D}2W+m>0g;Jh{2qvxX!YkJQru6>F43i1k*U6eWAtyWhaV;ONX=Dq$AgCvK5&}E#n
zCxEHi;~yr)|6^&9f1-W(_h<ZXl~4NHeTzFk6V2;{)kav~4Lc)_50<2+mp!rj;t9JN
zIPQOK<3f3_dWh`#nUc$CL0L9hu)^$VDuU6YLsmS_AjB6>Yk|r^b*uc2@;O}jID-sg
z^ZRJyUoMmQ`*`TzKPFl7zux8~Lj?}P)5dH)KiFCrZSh7jiiIx?CgjHob7-QTuAdr=
zn_e$RkHej6A5rs4M~xH!+c}xg?Z_`!unFXt3@g}wqh^A7qz5{3e@8Z(4s`YiSSgZ8
zP70gRYz15>t0E(_lW>o2e)~d{*vT;}v_C;&eL4r-i_8YZkdy$vU?2%vm^}%wTdnLe
zJ0S$Na)(nJ`#^`l@p^2e?2(X701~vYtbC%}&3sBHB#Qz8tN}TIAomq?#<~=HPD00w
z28kj^&f^iv=&)!qz!8-mWj_pDf$Wc;ArxTY3p4^|W-9>HLR>%(=ZFxHJ^l)MC&LMR
z<VfaM&>~hqH1j8B%76`<VL*oqqqV0Q6X1jVzL4J|@;gR;XU*Sh)$cm;yR!ak<{CR+
zi79u!3rNG#YU|MbD~)NN<|#iyD*8eqx4A=*s(=|q()xL*v+R*=2I;}?-Piv+cVAoR
z5ZB*wgiBc#eq`4!DPuHe9Tx2i;GsK9ZZSH~6k^Rop73g4B)9X}S~)qqxbhI_IobiF
zSp0ai>|C~uNYjfHqf<N(gP`4ddFZymc3%q!8ECfvz?e!4-=W+Ok64ZmW_ZGnf!AS_
z>1B|TseJ_{d|Ki=!!ZJk=`~DN0h=CF@(_8zN3JPA+|O<kr2$cf4H0h{bw$z`&NO9e
zB5p8qp*gS+8N>n9C>8irunSW$c)+8--jR38H^)1^P5YQt7*Ln%RIu58W(i+=mmH2Z
zcF;sXw{=^HkT)6qxyzWqF~Y6md`=8Aucn?9;1Mq}3D#YZ#zdITZX~d>7QMUCu1|~Y
zt%XY+>T8<`9_%iyG6w8ygLrO>yeF3yy@vK9gE$NRTUU5f#}q7SEd*i5M*()+<vFs=
zx^gmHaX&GxFA|qOu0$L}zG=9?ET!P%n6v3mGiH*!Z1|$&^&Nt!3z&YiFZ~IXy+I?B
zEs|gZjTU=e3GTT^?raw=Y4}&%J1GQ@L9yOKd@(K56T+0`<CmL9_83BO5ujL(3?4FO
z9nj~}#`YGH(I)CFg@^ewJy-Fi&fd04?awAo(QZf(<|D}3CQZfQ6Wy;n3AZ>yOZM(P
z=vj^<*seNaT@dS~#Fz}m$7To_jx<_B;bm>1nc#lOiI8~(Pj@>)p7LbYel&S9=nbia
z8)jt_7J_aJI<{3|^ik8!Z7uqKAFOttZ;W{l(E5-xT1A;JH}kb~+(C~9ADGqlJ$$~?
z3kl}`Tzg|VeoT1WfDA$1?JXKQ7<*op#h!oC7{VYKPv7^jHvOefOxg>KS?&AzF-@+v
zi|Rz&jg5xaDYjOOqhqM8<i*8zyPp^=(B*nrr*x)~OdL0h;BtLN6th_~s=?@4w<AHv
zk=%)JjxG`o=(NR@gm*vj$<C#vX$PmMv~bp7Qc|*tl7NdSgW6H4n`q_{A@$t=g9s}d
zN8C%YkJ|WqdxvOfx6=UCea^BQqcQ@D?5&Pj$k&~z;o(kuFL`j+d7@O?-gD((f(P-B
zyFDAwt$9dm<#fFXC+th*F~+n!nu^-9>1v?Stfo*IVY`&LYV>RPXT!!(T+JB_RxXJ*
z*sNbcOr?kI^CBZCmz>w<?D`)pc;IUMY`hzt3l$8^Kv%Eg?Nl2GEWvg~B`aE8vJpoQ
zD?wEn$E&mvk*_=~46#<LFR!<MD^{db(DpjT;i0a_c7kU9uz`39%BTs!94L$ofDuh(
zS_P}yz7@P8$0YJ)b{88YE{;`Z1Ug}4HX1|8=U>mvorMf!OJ3>AfJG+c({2fnNpGEl
zTienp=0wAVzJkc!V(DD!U$2`WR^Hk1Oso>&Pji_nD6;_y)RL45LQ)NG7O~?7(IL3y
zsU@_wsxm`EUkBB>GfV6pxt5EZC{S<^R)*ugYam!Lt9-DtGvl$$bXKu1$5gLqi3G@I
z&XI2SgdMp8BqksBDAC??*Jq3<Wi>{2+B=pGWr1Dg#{rJAgW3mP4Dw7oY$uFZykM7D
zZ_rT#cOQ?8NRGr@OUhCi(H0X^0xTHHwqqzR_P(!hW)GuGWzzjM8QCT^U0(j<awFr?
zO$M|a#%y96C5C_G0e*|9nQ8WdZ41Vv(~$*-XpyG;_%6OO^S+BQni^S~4Q}mL&9e2F
zB4(P}#e~5#9uQ}mW(2!zc7wcesCvQ6OV^_p?>$s+=N&kQqI^CXNA;qXIfkvHKJSon
zC(6>5RZT`ZQ-I0tjS6kja5g&B(Qd|R2k@+K%Q4j|>W>{0X&7h*qkG)aCSlm|YT;pb
z^=+_HY7p}&p37%LxKNzMamOncrAnT!#OWD_G>Uh|%vS?hV!6~zx4Z;+0~Q?Jiq)&F
zrBE%{x!v2yDmEzUX36NI7jOY(JR-%vR6KA|HyDf_aNszM3p*sh!Y>}L7#fRJ104}^
zLrZ1E=WPcV2a6YZt)Oc0f$H@F1bD*&I72mC`@+mLiqs*C2&U+KQ~Sqv$g_g`1V#mF
zeILZf0B$1rImi&Tsni`?g9;N!PRs2f^1kq%$Ml(tF-f^*624dn-pSX_*W)h*6`Cq|
z`HC*cliN5RWcaSrFbX24ioi2V{;`YwFWpYUmbE9=K~Qr$f!U*3AM5g!Gc7!4MXxI;
z$JZJSp}u;H&Bh8<uWE8Xynf@)l7(imI5Q}kHZfi>Qt-4F&~O$YV2vl$8;=Sm0cj{w
ztr_L_K<HJcg#E7gNg(!lEH5Zf-t%aPdjra@9Y^P521<)W9=IdNL|*whGe4JNEV2<v
zA*qopB!~~VpdD~QKsgt1uZey`XTGH~+f{RoI&Ez4i&T@fhadj{$SAAnHJVy)vXBh|
zGXvBZCvtA<&X$_%DCd#4vWDy$%@ZLjA1*aJY2Y5-ZX7vI!hUX?=J~)P@G<G4cso`k
z=tu$(&MS+l3c$2g^(vBVN=PU-zJ-yXBe5(ET4p;MD#Wa-lMyyC77_*2rGtf|IaHDY
zjZcWT1c&3a!KV~{f^tlN{ii7oVmCboHg5H<IvIZ_|G-lcm%@{nfBK!29>S?pVd_p$
zj;&|v$-5@$>X$IG%m)NRr5I3OExask(}y`Ii@@#2wlde?$AF;0o)hV1pDZI0Y2157
z@k6xjOgRSm!++b=f6T;ztj-22cMI4w<Th<lOzp~eUr?|XlWSIGGaoI_1Jc-blkuc%
zk<kjO6d%TC`0lYcMXnqzU}=~NI_~32PAtB+ovK%ppMReR@VIRer>;XkWy0T4^jd=;
z(k9#st73_4MA2*wf$`i%7E1i>oj8w_e3qG>4g<V4Q)gK0^Aoz3rUu;FoOy77L0k|6
zb-Mfejm!w_i!&@(AJ-Z+FCd@ahSx-k6c^u*;C-|#)-TBvnOzU4iG#+onu7dA>^!wZ
zGV^_<C!MN-5>GzFCo#e=#G-s+jrLHq%hB{u31ibufjXOB!`)SoD!H_PG}$9D*`N&k
zqansk@7fq)J_321rG-rdt!2V3?Ta8S-yDANFHkMXDQ#2k#i1|aW;6j)i2)m02Gv>^
zdcqnvd0ADO$4jZE>BX3q6r(V^wbd^O$PMB_j7#|F1A0ThA(mMHvE*f7b;xj6Aku=E
zD)SXxshVPXFTwQ8xE_Obl(&tm*UT_fm<e}P#W0tg&j~Y|kRyzf`7Y)#po7AcRb<_v
z(s=a|3SVFBGmCYN4c7QZ*$w#T9%Da+t~hXj*)U%fi4rXMW(wQ8N~XY7-KaD?8sT9i
zw5QgTs=hjGp;Mx!oa1Kq&ZFzB?LDLzYk?A5VSB4QJL?T`{3_<QG<-Us_s~^S6WJc0
zejB#5fbe;?NSg7=_iQ+Na$Bn0ZKWaY3m0~M9bt2K^<q`)YO5=WODZpPI9z*#u{l;Y
z87PEeUUn4iX~3Qye2p`!k5C(aH=9+ws>|P|&r0)f{`F!ygKe7BX#Tic-E~+P!3W}6
zm7?z8u-@r`9vVF|5I98*VGvS!Ov0>Ua{ZH40xM=w0S~#V11DA;syGBm<a=t}0q`8n
zaw})6t5*`eI3JHXhLYm7Qex~083->r(;0%dI~S%WwVE)jY%IcV60s69&1ZxlCjuD2
zCu8m0c{#~<%}llgzuYkHXcKgMzdl=lvcZC6#aR^ewnMKZ2NE7SQ~BDANC}s{2jG!k
z;e3b7jcV;`GM#!3wxB62rgQrm1a7g&v&`A88@9DZFUmu?ZEZqx6M69ZK+=Ng8N!D{
zK~m;kxxTj$P7vm&?$I}w4m^1soiS`3<&$0(M_G6<>t&E-xk>A}50Lijs(V2ux2`5V
zdI{PhlXEemT1T@ZD|5h_UEwO@yVoyXGP4)NlqS8vXVMkrFEj)~X(#ra4h*JqgkL{e
z;3AW@O4jJ>kHdXZ9PHX7I6RD(Ibv#3<ZB&N{pzTU5bXUG)Rj2%M&oKBH_a}PTgok<
zBla@n-KFlB=F)%%Thk_MArR(zd$3qy3)TfvzX;mhRL~I@H%FI0+bHT<)<DtLXH0q<
zBn_>#`G~G32MS^8)Jk`3{M@zR6H02*dIUOfGSFoi&>Z;G9E}6azsFnLKxFfeO4(;e
ztE;?vCI5*>fLQgS_YHJ*$o;RNs1~kGz)){_c&BO`Vr~4G>?1^?R7vg;hB)gR5O_U?
z6Dtp4@XP^q8P@;SRV&iV5z>dJ?oPb!ibI1PG!gDyon<#{KYcYBVwb>19al0^l7UOu
z$;v_j%p~Eyw~(*T>laCk<tLk@3vB4BvS@i>4cH}pm6s*&6&-*$^2D}HE8)v%)!J~`
z9p*nwu=BGb5BD#j49BD-OQMPHjO`sa+h-dYM(v0V610m$ACR?hVh!7raaACvs9K6~
z)0Y;Aw`Az;Ln89(`jwB_isGc(#P&^~&zm#>A)0HRWdm5Voer$*VlOe<=d>QA$vzjt
zXjJsN{S`z{v3uE!7;K<Bm4CpRyy_VA3B!`4{9UnS*kf>yq9d4WDed*L{Y><YPxoyb
zsvDAh)MK7tw6`zEsr0fiPX<c%{doqrh^7eW&Gq^UdT2a!PG{d#N(SRVMH-}^P&Iu8
zjpTjzpMSpM_xJxhPC^g)V$$d&K6h?9U)GqCFg`DQEY817LDs(p?EO#Wjj>0H!xCt<
zO|MZFXA_5EKM0XyX7?pWXu%g^7i-frYP?^b@w}44<M<3nn)taKnVT6KbfKl;RcJ!Q
z+r4Ck2tCw{s$|uz)jNL53VS4e3h>IF_sh<B@-94qTlyLD-p!wbI?ribk9&9J$ZgFI
zjHML6f*ur`of8x}Kc769MO~X(eoE0n6}Nm=e5KMqa9rYt1@-P8B(u3HbrR4nyvVA2
zMN~=WhCGS{^f(=R?@=96GrQ!L6|;mmXlLG@c|{&&Hx;vp3=$rA1vi<9y71Jw>UmsF
za_>x3;cn`oqz&pWT+p!jUe#uGEP;vY8g8uk^BPsq?t>eoO7vLqGuZ*tf*n_;KB$wJ
z<UvofDb3SM0h9^&rtU{F(I8U7-O9-AM0hXdds0vZ)68&M=skR!&1e@89k3xw(L_=>
z)LnGv^~)oAb|vSLP@Q1eOTPCJd*Mr1nbF*eqxq`l$xr;<Nf{R7L=$Tnh)LI)1(#BS
zT456KM8laE8cLr~XG-RQ#x$Io4?2(AcjXwH1q{uDsgn%|=&o5=i4o$lr6Tx9QTB<Q
z9u*s=QlsufCQ1{x0&MP8t_8JOVaNFO$ZzX486X~QLu+)9#%-w@s6*4TB<T+k)DG6c
zAnZl*b}LpaSuKp+1}jLuy-2Iw=>K8wy`!4y+qBWp1f&Yms{(@3l->g>O#~E_4p9N=
zU3v*cdWnF5(xpfT>7CH4(jfu@A@rV5BgFXa=bd-Hd7t;poLOg`S!ZT_=lLTm1VXa+
zZ{Pd=-Q~Kj`*6SN#i+uF@AGM{`zpxG=TXQAj-_WB87=!y#LW;rW26H}80q{r+pJdR
z$I1c=n4qQ183?2pTn@0t;dD1JxQn)@b};K-nG+?#cLOg+E-5W-c9l84`Bd$bAi5!^
zxaCVe|L6bs3M9JE2b9%<5`TjrK>tX)3{lsvwESq&N#fFIRz~=fQR1@~peurdP&?6|
z^e3>3-ylF8)yZNU?iwgS)Qe|+m<nfW^L8S98|l%|ha}qAEJE357h11^Bfzwt%e339
zEVFf4CI-OZJS{Qn*cbaFBIG<W+;Krncy{QJH)a_J)OFNi-r>|{aU`qlhPs%cmZpgV
zh*y>`LreI>A?|=&n^1xs6-dB1@ip92EOd3GRgjBu>)2><VdR7M#4VX0$iP$Xgs?-9
z41@mJ+m0k{NOy~7s6&Qf%IBnc_JhoW=U4A7lLQ080JV5tY`z+{=vUS!>;tWgr!(=L
z9zIUPzE6>%6r5gbp&p%mo;eI{G-Vb(Hp<g==I3(o$k2DR*6UB0gh<_4fQUK!1oQ=G
zKE1!9@e*r|Vn)T^&*P;e4Cw?pA`M7;yk|02)rv}0SF-fgCp|UThZy==OL<mIW$#?k
zx-xLtYxtlDKhDVzD4<!Y>Tgrr-;_SCY;?$RKl{Vjd9^_Yt3$RJ#<{s<_u^yHNRPXf
zk+CLS=s?_Er`9NtyGN*L!h3?RSR0+t%d>3E_1gYQ#})smM#>cooz0PlMInX=uZf6;
z?y<N5y!H9E)vlZ)_ocgll-(_$m6uzki%EHZ0SlGf6}0`DM!$VLKqqQo$p#{w9w)tx
z7R75y0fJBF{J^eJVG(a}11&y~Zslhl8Ok5JBW%o@89Jy?BQ~n$@lJV+dEa7Lnezrl
zUaN7oL&is3w^jM<sFyNok>mMXOpaw-kmP>SgX>=u=+t2JC2DFcdIc{+74KP4V6u;&
zOyPyFddH6%9Wu7Kjc<miJuc7~a6yTIS+@@GV64-d2nTtspPmtH^twJ|H!VKA-j2Jl
zx_olQrL+6ZA)U{1&xAOepw{w_xL?2=Jm}rBpU+Y)WU=1p4L}@M6a6hAzj$#>YP;`)
zxb*<@(tZ-DqWF*`bj3T=GhVbS{q!uqWx*WL)4>%HduM^dk7M+!x?{rWKmb3cG7P;j
z_G}!d@1*pxG&b*0(6pAx40L^;7_Gw7_$^VHWtj<QS?W{U(;)1DyxhMzEZElP>;G=@
zp4!j*DeSc3?{pU#W^umF>4Eg!ekzHn6qgl~i9bq<fy@W~7SAw(dx;4gOQ>V>&*IW*
zgHU}RrC1*0?2;(IS~>1dkR7Niv#JEcaCIkPFIOrvJo6Lze$}}xnK;QDKg%5s+fgGs
z2lPP_ZEReM=2UF#=z3fT$yVdl2#c9PhA}?SNA;6nJ0Q;-l}um}W_69Z%aC;q(AVbV
z#Y_4>#-7@cy!A5K2rC;vkxi@fl|P|b(vTS>4i)pa1T=4yIL&u1BKOIQmmE?fM)3|(
zDf`hI*RA66a$LjJt11NuQxH*`4Zm_F+by&SFU^yB-bkID6&v+5+LLyY5*-E!r|(HZ
zqt7p9VZNWuabg(yE>HT0E4dzB%ws=x<Yu^-On0D^ctOq8GE?#@2}L!q2=>0%t3kHf
z?cp*)AAX*j^^#*S6QZq2^_8YW7tf6F+fFodgWoqlxtRG;ZWgtJjIrd@)z-+23b0{y
zTb<N-+zYK@6Y=U4&CVAxi%s}j?FP+|$V6;b03UIONUPnc=7+(j`48`Y>YtWZ9$Mvx
z%j}y!2l-US{|50tMbTVfAiwBIp2Mg1Pif}!=A12!>DW9!2vWw6kl%q4g<+ppu;F#`
zd$~?g@QYhlX>eJ9h#CThpU9<A#YVa?jP=0icn3MuGUS8RF?SgCv9wekIfPjmD@y6)
zyh61hdkX#F*%l}#bVvas`YW^&exh$Eisr#<>f`|TRuOP-MFh+K2F*3%RjD9&VC>gf
z`V2Ju?&nsFcmMq9PP9mc%{^sEGHY#1Tp;6J_<aX9<Z|pDj=tE!N8YrqE%IsWbdtbe
zoRgu<V<`=uOm~7^6T`zmG!&IkR5kKa5fLHTAS(1l<gv)N*6hv*;b2!XXIXZT-)3B0
zhPg}Ee0}(uJx0^v23zFfi-Iy5S7mUx>vHWn?i@~K!t$YJZdr@ic(3&-=4W&H7$eSR
z%5#xAkfv)EF`rOT-2XzkVNW5qhtk!TpLmtsdyM^TnF7Zr9i~8K_u1U((lHLfbVKKU
ztL6Gw04N`wOFi5M?wo&Kf4EPMy4+qhOd70?biJ(XrRrH`;fnVU514a7mF1A)-e3$$
zg`7ntW)dfH%B|@FBO<&5wU);c1c3Mky~K!<Apjz}(X9HC;e8{S#$^?2nx3L8S4pM%
z%GCD!d8biDo0f>gpn-->V&OfMM6%#9AvGxxy3Y!WK(!aey^#$NMV4tTsz04Z40+L}
zT<Z@yhdk}~18IJ<^{MJKN&Sev3Z}M;K`?oJ;%`o%)%<X{%>8tkc+C$`E@Di^cz3tl
z%ApPiV5PezS?#&Ex#o~RO*1!n4~BTN4cpy+gBDCun=e(cmQSYJz*6Dj-3(3}j)U9L
z%3erXT^?d6)tewvY!5Pvri;}%!(;RNl8JJ)mSbvpzb2^XF1MwSyD#^#S>J4Pi9MV{
zK@=ry_&7)FOKakbsmU!TuPAGkm)}zZ@H|y|1QQN!pW&A}c3w<7y!BK25Blic3*S0%
z16nseVL%UrVekA*YCbExFMdr+vcC7VtmR8U7M83^0Q)I-S57ppE+;C8tHyuMF>ScL
zA&%~AX8d<{WSLm<0%)~DD2HtY;kclS{v1}i=x|&)h)Uukr{I(pzoJ0h9?1^)J_sTE
zHV|t07mYfJkONs8W3LOkQhx;;=ZuqgD77bFp)xgV?`TqTIxTnX1Q7^m=#LszU&QP}
zZ8RP(abT|N$M2j!f+e5VL`r6@1ln&RBic)BIeBVZ0<RoE<wh@fe~8D~EZ<?`DHa?L
zQ>MhmqQ2=41Ti^@;u)6UB*Twtx?ImjmyAhskYj?0KMiZJtPa~asywBl>k}5S8nf0P
zA9buV^M!2kv)~-QDQIK-4ttMGZ6Q>atvUMXs-j*_okrtcJz>~X5W(r{_c!02_fJ}l
zTn<!cP!G!#R_;f0afyRKAo^?p!Wlp|fRn4rPHG;$FJIW>%{oMB;2;ZVPY+fC_<PPS
zoZ#Fk8-<g;cJr6EI4vg+Hr1QgW;D902(e*h_N-j{q%TXhQ}ryyTwYhsPQ=wE?m_R;
z1ZKci%%$ovs}GwdENG}qmzNy81uPpIFJ-St^MD#F6`5pz*%BpTJu8;B;lwx>V!Z}O
z<6df-+Z!TNu*cVON~#`U84BjN0YNY!=au+}=ZCygP3+awgZWCq0=TgX6+kX%r99oH
zJ7b^1fb;pmmn6l`otHwb&-_z5!FmoUXi*s3ic?(&HKsmgCU4=<zMUt#^~6Mi&b=WP
z-cWG_DRVAW&ODcPNZXB<<)v@owe1fRtXCSoyiyDLq`P7SrFSmGs5PSzn(eQI>#q?b
z$Ydz3Y^U+u&I6az%S_nN%~gw{BCJDqLmGIF){MMLl01Jt7a4a6qIkinsVMW!lZ&a1
zq1fEcgtK;~iB$_|6g1f)RZ?yHC-2Iq2vEz1+7ivYijldY@k%v8;z@A~K!5`geW{|I
z$knCBPc_c6`bAYpvc2}bX>pyN`5gv-l>8e+SdpPSPud+{NM27?RpCi&re(z~<el)z
z^t1SGOd)zeZB{{ZbzdJPRd03n)a+A2KRE&Av*6t0?>ARv){<-q!B?O|!`L2t8?a5@
z4{a}PGyEe~>iD-<$v&6xOB;|`-DHY_?=g7*@l<-F14aMx(G8zie3v));&w4n6qb*e
z2|~)aw1rwS7SYphD;m@!-C$1;AG05x4C2Gmblua+1)|IuNy%dqH7U141CQXK*YYrB
zf-ZJ_CC+U`3w&?0*zUp&?9ilD5JeQ<n|y><1ham_8e#;yJ1EhK<EMk0Q<7S~1=4I4
zW*?(pskw@gF`Kc!$)$uuSqRJoXro|c=F2`NhYu12znTuc(MW=3i}~CkBZ5KNAzDcw
z-glrK?SK)Cbf0&&z-)jbiea*H4<~8;hNq#qSv$g8sC<v~+%=5r!3l@qfJ+pUoIfCW
zLC(4)|DDmHwSMh`QDVK@cVzO8%z-U|f@V1ch+>S<ut*!*Hp$m3^@1ncA~eeWaj^H^
zJc=ZK<>{&kVaV7lQSFcyb&WNNJU~ME<|t58A^Au8kqar#80&$A)AST<&t8;J9BYf4
z-r6ouH12>-ed(;+RL91D!X7_B<WJJ=YZqp)C`~X!+A88+<Q$}fHkCloAz@&%tlEa3
zn0YeoEr}zYo^V}|OXFh_3b6#gLA(vX^guYE(LUie4XK6VqAqfNy#+3<>VPr>o`VLf
zg1_ez+f{XB41v`fg-yXe0RIDeO^R=xu7+WC;I`h$huhgqv9|c_4_upVIhW^p0nT+z
z<EOxM)??i`$^MV7Uq-<lZx5aX*0w{Do)u{6`)RsptzD*%((}{%-aL&<x0C3>kdJWW
z8-nd=fDFxmS|*3DRp5Xnr~(?$6O)E@h}Zxi3{PsrFyY}qmZh$#e7()INTn1%6~tNJ
z9B&o7H*_257v~MH^6ccb3!+|sl1f7_ShP02s-@72=_x(DAqGAyMS52Kl!F2J5+WA5
zRkAx1pp`d(0t0<*g^Fqy;dyTC=qyhJj+$mgnUeuMFu<flkG5h=wIH0Wnz!+_Zf^*W
z(b1wMyP*pL$(>0WqNJlF$5^!rmbURkh?8HsIvHOR)+@{tmdMz-w>qz3FJ{L=l(=&u
zyj+lnY;)$u8Jg_#KMJfT-c|Fu{fqNpe^n={#IuW6!WiTf;1nD(Oqn5`XZgZ4Df5Au
zv>=vF8QvUw&@gthM9UMELuPkutn2AiXRc*QE59LxyiSC;stjyl2%Q|JQ=?U*RjeI~
zR~2-poD%Q=Y`2$L+HRLYL|~{a!dp3d6MV;%8m%A4@4isx@TxiCc);~Y>klWOUFeIL
zST==};*Y-mEthJ1Y=gK?5P~kSFTvQDwLz%uO_X3IokzaXj0aIkSM+4LsSDAHR7O}f
zR(t$y3@qwkTJa=Jg<+voP`s94dqN#|r3D;*0guD!7Tf!sHBFk>dL&6)lHYvd3-*y3
z?*-jUa@FLocfY&%BY*)L3(Qrpb`uS+Z&v7S4w3fNPEx*z|4IhL?4$RTIbZ|YcNU&t
zAy7{tdz)&Xjqt&BO-}=sb4uu=tqvgjl|pa+3R?lvGgV*yKGEpe4l#82M#_r6Ls<sz
zoK(Ia=6ZqzwN#bDTF3GTT;>!W$#taN21JlAu+Woh${g%RzEVe8aeMc_pLSL;{>pZu
zyO`?b<ZU4|f3$<{J(d=_LexOh926AVUKgxFY{fZqj1Ma@3!uhWloak77>fD0JW2an
z*B&lS((i^v2KQ7AlMU_=Y%McOWSASSBz$q^(L1XS{LIAj-cxpU2guTpRW6&;aH}z;
zl~|2xRqEA6z5S<9)$4~G0a`HBmG?{6(26M=pFDz|+vE%jRQHqddQ8czWrD=9j(||q
z?h0gXc=sVSN5#uVL(i>IXP(zQ3vLnw(*d`p_D_J$6DwU8Yf+Xn|GSV8c|c=2P$}4u
z%9qYGXvWVi`aWCiEjzdV)in*^^g9fXfL+lJxbw$)a!yydj;g@Zzd>s|fQUQB<rlp$
z2#^8=1VaCKxI)RnYkEL2^h?DiK3;OkkQAMaR}~z)yt)M4no{Oi|JOJE_543hHHy;>
z6S;!HR7LcCi+i!l2x@QQu+~MvFguC^%~csVnpI)-PNiGs_ZM06e}kTT+Yi{Lhz}~o
z$#V{17|z;#`Fr7^4IM&F$wuRAF(U>+*75x}o0N)()?I=;mS=;7eCT^yTw;R+9Q-;`
z1QqLAo`2~nF;JtN(^FJmw<xlpL5uhJRRQ1~6qTq^1Fd;Qrf!`^<<(RfSv^(%J`lqb
zJ3pVCF-FEb$IY)thTfYojsK!vpz7w};*}xtBE|~87sVV@r{Y9X9%SBjtvhEio)9+p
ztnSa0v&X5-MR5ZXb~iaocgVmYMSyPUf{Cf|CoNN--23hZyjQ`G(qjY&>skWePerfS
zHYUBCREyT48DMz*FT{7kd&Gjb-#-j}Fw-5E(_a8kB`{S{Qd2`1L>Ij}F^rD*$IjbQ
zJf<akX19BI+MMl^6Iqi2OF%XJcvm0LaW-tKu4}b+$S}HPefe3V=i13Pqr6~RARY#h
zDhs~DzE?2h3h$UfZZAp-+P#I*sZ~y?hO*rM!kzgp&<E8DfW-%e0pvRsqu|3xy$Q)E
zPuHfTi5L252LwXY;ydE|I#}~h4t_cDlJF?j)3EKsV*X@12ksl)0d4PmnV&r&@AsA2
zwrEua5nH`DDIK>vGnoA7w6~8+Y^if2;l~h`14sA|H|DiE+PXZ0Xv)}$;W$`-_HbpP
z(G{Tb%yK0)1{Au~KRM<-SMegud+8{jBB%0>p8z1g>Cov_TQmS?9pR-D5@ieby3f$@
zX3HN@11z)Y-2A-rrDWaRLs=J*yUj}2lC8X8!C#?c`(V3EUM}0;pzIE##h<5Tz!7jd
zV3<rWu<(EfpB>U4i!Wn6^<RIoq<r+1jDK@<vWGiCoyEd$R`EAzph5}XZwjHZP48Q(
zz4JbTv5{F_fpEbnIqW;N+q7Xd@KJ$i|E|VtDl{ayL_qugk)?-(?^xP9!V;w>7Ns>r
zpwK;CmIT{LjfK*dP#UD&$rEC!v(#BzJz$U_?a|-tVYN*c^FR~*xd!OheJnS7TwK*L
zIW70%GL;<xNZ9&9aiY3Fh%ipm3&j$`apqj;b_MWnkTUohfabsY8-(%Pxemywj`Fqr
zDy-vBleg=uOZP(Wvk-U?7ZCap4OUqu49~JfX3N{^*<4Nvy$}!7)&Ij({xEEBt~3u~
z{aYRl4=KSsdK1c&5zG~+YY$k}Sx=rl0pUoL08?$<KGQR!h^%Y08_+blYZN2{m{bg?
zq6DJ;+0NVhs31w*f#T~n-GSHDf_M4Nt1-tgtVK2#pgqn7u-MQfP;AR7U{@nRTI1&f
z#Rmrg_@_>W-yqbkcQ=%-4$f>pX*X-)T;+7<{%cWRN1poxM4$)-T+eCcXbk91TLYsv
zz0j123UArO67c1>%7IPbUrp!+FQM|#Nnu{FQV@nIt|~}u%yNZ_LZhR$URv;0zMBkJ
ztLmQHJJ9aX5ck#dRxKk($K1LG6?R&+YPGPu(l~;jSJMIN0~2<A<-|)r&nNDkTVD*Y
zo^O`_y%Pu-R}!{ex``03%Wx7jjc^FPKjdahC)u64b|ABDe)=ygL1IJ3hI6-{-gi~S
zJQr?W;YuuwAgfrt)<vhvyjA>38Ak$$^fMTr?A{h3=}q<82NM3&c)C;^CcPGLHgi0h
z`L^q-Z(fF$i_xs;<OSbsYzUncy)#d?0+U@}CE<EkVhixGtP<5FoY;#i;{iY-Df({?
zX8sQc<M59T=1&?D|I|fn9sYBh(Uz#~FLjdt(F!d@VUzH+hCgyu1Na5Kp|2U|pQ%I*
zZJsC>>;oK2@op?xy4IVg*PX^&?>--E(BS|6gj7}4rz3V{EILSNLO4K$ABOKfPb6Qd
z4+U91f0;tcOcduOb6y#_vedjPcwD|^ai=y_eu2G!^+TiJ^<V0w1V&+@_og{BpImt#
zq$thBu!epnWooeW{hQ=SqtK%=P_9>xyYBi@tI5yQF=dQD&V5>95cjO4var}r5?mW6
z_tVyEZ+pBLCpgt{!{=BZ?VOQsYho{wj|x=P<9%%*?OJ$tQOilH)4Ux@u>IZ;CLP)#
z6bs(JwmL2M!TdMK@+dMnyVWBejy(_rO8>oVIZO)>yOwV?^SkqwKfRw8ce*7>6MPRP
z<3VsXfjGleeMn$&O5D2uh$KLFMUm-=Y9FqQ<Htk^qZDRv$17NtU*L+n&-vguh8!D<
zZegz9RscZg<hS0{+*x|yM%^8pNhr%piFxOj_|BGSVXM?csm!U;cGj;jgR!AC{54Eb
znMX!x^;20LL7z|BK+yxtXvm6>W7}N4nt|`)m+DWvuA~OYOB%ltOjw^^RahGvbz%Mp
zySK34yVRt+t9FL`VF!6_jRSt7(Nn8x(JuT^DTmHKI&$3BXihY~!s^{{MyHj@tBR>b
zML5<eC(o>h_Hu9iVtgA_2z@`&C3bEHE8_%+zMnL&wM;rz@^KFdk?koD@To{Tx0z~A
zbnyEOsMJm;_rAmW4OL9-8MyXqUB4<-+i0OiqmRhlHi1wm*r3?pbi15X7}J7_?DWFP
z6=jm?yL!|h(!<-NAmp(!XO*fiI6lAyC9KsygoF??=S?$6FF_s=kzFC^9OQm+EjiR(
znSC~>DlgzE+8{%u-2sKERJZ?ZS|%TL_bRoiv*sXC_SH;kMFFCDfpVHFKBb8MAjZ1c
zigyE>gf+c7kKKtP%zpWCB4d^TEa_1{MyWABAV8ZC|7&f+Q{Mc{wWau4!w<Cb*i!re
z1a*Bmeo1_$?Ox%wK|0mc!VZ&%Linokw{<o6-7eBrBA{3*L9kP2D2#;A#rv-;rB#}L
zrN}V*G3fJi>dv0qRLZTU!w9_O^dU|X1!eJxxiFZ_%lcMMa^3f7vCw@a<)(Y_&`uq}
z?lZ$ETW>BprQ3ZXwGNg15p@rE_{v=enwLq5H$wx-2U!3Sng)z_ES}w`qvs)}V$bh0
zthiw$Q1h9fnmefi_1n0xY-$xi_+|=NynYyviBh(r`}#k+W4eTU<2|p2|GKylw?9P6
zLK4YY=VSN~TgD&lC|Tie(FoJYic2$bXa6u=azpBU=O*ag9Ovg?(Ew3QYAp&zi)|Tu
zmM(i^N+e0}MPm4!!gW$!&lSe@J8gzYZyeACp@r{WfPb+l0$9R6B~fhTYM^@05)~Zw
zX!1?}oM*AqkI^}vumhD&=0W1*`Cxh7m~5WufZIs<3e!i4Jgo^vDaPY>d+w5knJzKG
zbDp6SVv85=I>eTd@xKoVHqSRu@LEepyTlk|%b^F}T1}pQGg0(cYfmAxknraVeJ&rY
z)Jrs-oz=qSik8MDA5#4W{SBe7DhzU&P!0I`$)^#;6@xRZ^0CyMp5#tTVw}DeuRF(W
zXg!}xtvSfPhFM5f=2AhhV03#;fMATox6DqD*V|2#u1xL<vkeFx81L$LI@Ze-F6>mk
zhz-W3J+L#7FW!u`{2VCD>qnGn!@|&xNyRTe#|kQavc24|?D!_3y;HuUz6EGgqO(7_
zmHB{Gr=7n`ep`$aAAa_N(TW)ON>hdv3%W@>4;J2a@vOlQXTdQkywB5EmmqMibyt;Q
z<K7MdPXd&B6SA@yi+gIb3iuL2pB9w-$OlU?)5T&?1IW>epou|th=sZ9><>)T2+kh`
zXV6-u0IdDKWJ61{u2`U&Z6ogkVx-lz?zrSoUyz5<{N`IcKh|5LdA1xE$cJl4lsGaS
zq8@*)W@;-Rg5<ml+%C42Y+Xu!T*@APjM^tM<BFRf7I_~;+#}S46oXcmnxIrwz2NAJ
zfNXA9-}a~PZKJ7Y4et)_TtDXy`<bMh%bZK&2KbgPlPZ`*4%^rY<obX}iS;^D<4j(|
z4W_u@Q4o8uy22(AzXY5%z`If%l>sL9k-RClI2oC~p?r0rg!n|3rSpd-DG@VqHb_w|
z2Gjlk0OK(z$QBKi&-qN-BWQ1@nzFq3X|B#I;*o=UbKzmW+;hm%wOV!cL76&pgr_Cd
zSMD`+?tZsD72-f!qLTlPu;Q;^=f7js{|mqKpMo7tR0apvGxXv{PL=j`InQCo#I^To
z*H4M>A!(I)w#}CQ90@hHS+6)iSbQvwAGUZfe;{JdwdzN%n{xcz`J*#2{0eKnx_q^t
z4-Jm%J>x%5H2u2pENrklYa;UklfI?I5ul2w2QygsfcxeHyym}^ThD4l5UmnNfD)6K
zY1N4hyi%MnY2AKrOoR&)V$0@DixZYMj9s6Tg50+>h^FZeO@lyKXxVlL-?Rb*)%xAJ
zes}si9ZmC9%rX)G)m+P9QvGyL=M;2p#}j&i271>Fs;hK2e-+|x^DSRQ)T>4{YWIEx
zT^#TnGx+x_UBP6*d-GRCNwr=d>t5{>(*MGy@gy>=i<m^wBYgo=)Uz<g;bWtbjoOf>
zx&HlOl5nrp9vza&EWzu5h1eY|2Rbpq&=4}Doh4x68sM0Nh9jYHKbK`%Z~}6<0&*NA
zBbjq%TsOhcu!o;sYK1TLAHdNx-7Ps0KvU-?`c{Vf)M8+xLC1@8Z*>`7o2$*6EWB$+
znq#>jc4)WS+W>v+y9$`X4y8WAB}?RRy21<2uoeLh@8Gr@By(zr0}8=kC;-h<@s&lM
z-ZVI)f>Vi)-UVBrPS2CfpVCC<-eglsYc7{-Tsv}zm&I6Jly0wY#a@8fd{AtjDtD5t
zV}{39bsRZd540Pq3IcaGC`siYVG%s&lwa*BSYHdnrsv$<R_}`0659>yO(#xr;_vNx
z(b;$0nBtpCMTvW|s?*xUx-MP0Ny_K(!?0w|*mQfA@ysBRtfFGoC{JbLxf%!;uB*%`
z4B%{Zh=7S3r{BOQmNSR*{CLg2#$RvqfRvlJ402t80wwIyE5{$*CMwx9{bo6B_(Mph
z)H;s>X92A}7c*A3KS&B|YWdmz_N$f)i|8T>Zlg1ryOh_mT}J?=$o#E4Og$~HiaQw-
zL0}|dTUrm-kp~_i<5zKQllWix=zNy`Jgcth_+|)?BYRvp2tksE<v09-MO0ubU3f0V
zju6AKjvoWR$Cj?bnrw-_zR42oP0#6HW;We2IkLS7PPGx!r1jucvh8FcouTq(vLMH1
zpCt<;dbJ?6b&h<?_Mf~~Gqc+783uTwmknAmk2%HAo;WX)J!Nvsw6~cAahs%B@Y}>M
z;@%9%vR1(Qb(!tP@*wkD7mDv!N1B@>9@j<xaQ*5U2x8gJd_r<a=JNo8UhbjN)karE
z)h)E^_;*Rx|KPI#PG}}l|6Py#v$KOck!R8aunU&Ds>^erZoyLZ2<;v2*v7Jw;lwx;
zTW)N}_cBZ<^6=ho5OpVk=`_LWGP^MU)C)8sj@uj|r?^87u>a_im~9r^E%Bs}A+<ic
ztGn6!Qxbvv08ovht_+8{4U~)pC)(^*FsPg>J1ut?Hq1I7s<x1metmoCOxVm7wgj5S
z(OZ^kR!9g#eR=IE-CYQIA!(U@)vG`{^kF-jH?12=4q)8v*85Hif7V2ClG7zsz`A8=
zR?Xot0g9rL(AUut#pC4|Qx(2WqO5OX3OR}VXa-1c4rx7y4GQH@o#C=4TY00YIliEW
zF4vjOZPXQdm~YWnY-DQR;xwA$OPe~saVzE-xVQW+K=Q#pLl2=_d-{KbhE5Z~4hbJX
zSLZ6(&Jt~5;U`8u(xL&6UwGc3jTk@~#7lQW=<w`XZq_T(Q>X2WniPE`t4==A7d6OV
z)HG(4Gv5SP5HSi*QM<ZyIF*+A1*-=p+o?qY1?+KWL^6s-nUtB70KRHKX2hP8Fb4WD
zeyaTAfd{q255Z9-0l=~_UPUXh@#2GXpBE)+f7Uq3YpMCH=Cn9WY!USZkwOQTF%)<>
zP=1|Ao&ww4r`N^s(nAM!Eci2NEZ$P$Z<GOKH)Iy1JN-8(R@76JXJ|$w$rO4=d%)IL
zSHZ2P!g_a^2B!;jKv;fYYde`3m#h!8H!|E^lkUm#z9FU`d!jN*O)WsAyIOW%>AL+*
zGZ(SWn`7r~ecM1Fzi6%-0$<DVars-8d)r~S?I{u#opVj1$jSF)5xlo<GNs*^yyh!L
z;O*F`Dx9FJ7%2-7Tqy01x0UE8P8PD@wsqB^<X)NagCROJpH)Hjh`4}jw$K$p%mro>
zsA`4=dL3q5AZig`v&kkE^gUK#%=UP?_D0x~sl$()vui;I8?wB~cXW#d?oI6o5Fzm5
znv_uT`Z1X}v4^EJUdQ@eRRF@qf;#~yC0hHF<j8-0a(C?fac9+*s_hb18pYJ>Kcb;v
zdnO0ub=-;jLOC9f0SDIHuco=GNaY2+hU4=@iAH+(_&-b_Tl*?_Ro+qc;S0B%+*~Tr
z$Q`B?L_{z%*IX)aq&F&jdwzq4X4HR!EWno!5hYkdog8&^Li``d9M!`2ceTE(IX?p-
zFRTnXm&j+v26!>9N8p;is`pUe%Wq4@kX9JP5A+H38x$3EBV&LI{T6#`c;5Vx1eJ%U
z$FS;A1o92?T9U_5CrkOF2T+77LT?m#qeMA+sLC0WMtB)%K^)J??-<=-XSZxO!x#qR
zo_`K_=)#7*y??8@Nx4zVP`FNd`1-00iO#rRC>butKR4hJW<SHO<0ddg3ZJxkjxna^
zojRY_(I8U#4GPJ<5<t#aflgf!ef(;svdFk?l5qb{?ppSD$pkprX*=Jt9@b?QA~O0~
z<ekL8h$FkD`+;Hqz2URUvX#c*Q!4rue9;P&u8&C7Q>d*=1Ub<{qSypPyfK?~E>wUd
zqv!P&!^mVUgaq_nHc4|}Jg2S#qnS+!3lA_*JU|>n(=W##zt_gIIwJ76v5E0Kk%Tz;
zUBUiOBf5K?#NL%A=Q@abu6aR=hKbYnlb*L=Z#;&W1BccJj)GP2oKPZjcw`$1D&Ap0
zYUv(krY~>ob*tl^u&mLT4DWF#Z+1a)Tqfo7!zd`#Vg2Iku|7^_xHh=g;01}z$}J+9
zp{}mA1QlX-P65JbG^Eeb14Bm%MF2YsMiPoVe@ptdu3bmwbb-o5@MDsy|E(Xz%G{g8
zr>jThT3EcKPnb@!TK1UQ)Xk3p%~g468`cW!FF(Y=R7s~8mar6EUfCq*uYS+#BJ7Og
z8tGHIQtyNKIf4P~a4``;eE9#qp7mGY{ok?b|ApWAPl5OUrOF5h7X72l)bTPAmi`%f
zEJ4ArVrk5Vuc69ya-m$LZ<>Xp<Ha+OYtJXit!MvGt^e1m{r}yw?_p04p?x+j0;dlx
z*0m8bsUQ9ZYV>;jg!RF(wHnQ+oK3qQ!*$S8VD{zzl*gYt(12FKpE}eM1WW%@4)m|%
z_;-zlU=SO&(jSgew61q(ghycVjI#Ef(}jnd`;{+dU2s6GN&Oo%cGmnG6n0ziZ<1TT
zLE+$)<)3&27;VkRg)YL${|15QH}RAOf7k57UkAt=(9KH#T-o*hJ+wOqeTe%Fa>&7o
zCH-A&3#*Uk_zlY02cT$I^qvBfs-Zpb<6o6f<nW`vD|W5uV!iRu`Y{}frutt8@z+ZH
zq2l(JP5gCt{N*S9@|gb*_6~EyNT7U=HB{FYeXPm2XkPHOhUxWdAk8(I{xfdrFWL0}
zAFPM(G#C9T#d(vHU>9rOX}S0is403}@cOGFcs+pRry%NuoalItUH;_4j+5p-wSfNl
zcN2ep`PW<izE*#&%U|~Lzi*tsjNvb1_{$jn+DZP}KK~X+{N)b+k8p>x%V9VR1%vdM
zp~6MGMg#gN{>G*|Ms%NA0hCYSe_;vwPq5|x^FP;NFi~w%V<#$K=&LK}^j0v3s)~cJ
zgFjP-od;DfbSXx8^_W5Nf6o*Bb7lFTxliU_lLoFHq&`#~6&oN7=28`twfyM)aA$Yw
zj{EHs(9@@qUnxZ2PxbTiQib>Xo|V}C=S%%jXyX2-!bBcDx6~IT;Nn35t_e^uVr;UQ
zGS+>gH$3N>Y>xg_O7K4zlJmE$Qc9CfU|y5s>2>Rm2_Vjb8B<|X?dgxH15fH&tk&Ps
z3nrd+<x;%=e=~GepLjyz^NpJ<q<ln_u<o3HV+dRylM|I5KBoV=TkATuuKV{h_~R`8
zqsQ$Ujl>(i98c8^EJKv3^FCO|scw9vRgXIqx(BPcBR3c_5q5h^Wl#dN^Uum#w=1_<
znY^Aqov!Y@&Ql)6!7P^jmOTvkjQ@gOTqR8><VXs8i0>`~$jhk!f*(in8^q(10L*Q;
z1HZWa7li*mH|PKOG7t^p{L!yRAgS7ro}_qwlXY0?BUONx=)mO(pXZ8Fbm(!$J;$(h
zv1V*Hwv1NTxiR5tn%)l=_*L$eaIVH&vbMznz4kZ-LW#LIfv*Y5>~H6Yuo)0)d7X-R
z)NYTpBr0=4{tyb1uI+3}>c&!c1U5`U4@2u`0N6uaT^L1)kDckver5G<P(n@4rp1*7
zEsosqF;M2a+X6&8f#9=nwDl6nv|mcHw^%2KI_hoCWJ^031r3!{2+ZkixT>on|C9g7
zRdB6}(g$pYiTHG;$lABb4HMHp8lXLWy`_|;`@&(HivUMAjuTvm*k?$ZKX>g~gZ$`)
ze%A+xmUU2&0FnL*{S|ch!fg_rGA|X<P=zTYNS!V&ITm_J4$z)+HBFcQM7#{U1cty3
z$ut5)%=eHB;`apc=&KijJWmk{Tz=mZ2_edg&r=?7^)kay4nO!(ZbYxAgsR0De>eeo
zN+R*xT<A#bawq3q-K5F0Q8vNZ{d2+tFq)ARKZo$eq*(;gugvT{p+9Ta43E3ot_f|2
zVaZ&2V?by@|Ah*F)LA6Tu8Vdj9ryZ&G(`ATydj#10>F<*o`#>571>4HD7I&8h<Lrg
zG=IzJJV$kiMIj*tsdRf>zlZZ4_G!KVK}A8MG1-=tG?^J*NV78REEo{VLjDF_;Gvrw
z0M%5laaN+WS;Vqox_l#PI?=USr~GAq5SDa(%kP4<)q)Ql#G5k!K$LEzc&qcR7(kv_
zf4HVhH-|lwhr!a&X4r%U{Iy*NA(P}cu`W#o4{>unQm7wE8f%6%fqC?fA^}^t&<xyS
zkMj>3+3h&*s_Zw*L_YS=d3q!CUiveq0+rV_>Q3$GiuH$cqaHIEaK95sR1nduf+=-$
zzFp%NV;{e{X^WnXyNTm3Ky9>M#WKXFO49@rTwGX1XN53SJiBJ5<$mHS*bLREz4)b8
z`Zel?BkkbpB`IPe`NlW>vfq4D%aAT_<$^w(rS&|j>E1u4I-3hQC2r6>+uSySf~;6`
zA_BB>%^x|R41PYEFv^s07ra8$L@WZOSEk203{)=$IAF-8+teK;Y=uqadH5!UxPruw
zGQ;_+6w=QOQzfE?kM8s{xw!*7+E`%#W<`|9$KeTf4wXfH_$a|#Z1jq)@JJJxx0+m7
z4oXqiZvmSqycyTQ4}fZ@D=G`>Cub$o&qriLkJ7qMyNmmMMyyV*6YS7pSG&ELLMOTC
zwnb&-?+dS4C2z^D&HnOTKkot)ncIGQNu6?LEcH?(Kjmxb@)B=O#+FaHZm8T@VXGP1
zt4dzi?bFzL4-b1*$j7Uj;|$Daj&A^!;9I)%TeNf9eiuub!Y`mA#vRicPk)12bbOQ+
z?KRp|^0f=H3=~cJ>ejg>$D4F->nL|QBH7=8S$`r{(n2Z}JWycTzH%*jJGsCq4Pnc7
zxk+{`5t{7iVko#WumC59zQEEQcAfnO**8v!6dqgIu3a%-n86<tg2UCh(O_24uCS<Z
z)xO@&D2grCS61_->(-CeP#J~knUs|(nt317p4oKaxMWQy`@*M1FU;0s-Ia+-6w3^P
zxm(-nzclz~jC^pam`Y8xAuBuO4>3-6iN#5m|M-=mjd-)$nlSOeJ#Ju&V5sUQyv`+N
znf36*T+J7{!ZrSEV~)KzaXMUfz`gevVUM(|coQUs75ubpn}HLy=1i+Ft!b~D7#=1k
zb{*hv<US?73d+9(ut<YpMbPh0!6(n^cMZ6Xr~#FRN=;n2PfkC!-bjfS8^qzPVLiRt
z5iP<S9&PyYdcKzihhMhbMmt4+i*%HN3X)+GC+q8C=jobQUZc&!f6#y%z8b2cK=av_
zNauKf^ZL|*cKdSFN%3p_i1^AW_Z+uuFe{=OUOT;Su+x1&QRa17)5YxxzAsZHQ3s5b
zoa*rtGDt_+#k*IBxViayS7%{{SYFoo5yY%@(2oEr$To;N2=(%>BIVS%f>?(`J+*E!
z#j^wJF+fM$PC+zJy6=0yL(lL1UmEZx+a0f*1;148H!qGSPt|+Tlx$;mZWk$@)-1~%
zYFXZiHuhZ;aaSkJv9tiY0n$^?9ROq&|8LO4dP|)4<R(H%ajWGqlivKVhHe?_RGx@y
zjA>s%m&GrEGHNY<98UCBp2P`;Iu&8v5T!cLD7+nadbVqD>IBso&(oB2(i!bzU!m$9
z&gl54fM-|-XejhPTAEnTVvB7PmpK<lOS%D>l(`IID=AG<9x%WZo$6$@iBq`kfO27q
z_Ke-FyZ7KM+LX43<z8tp+1froKLWuU?01$`YIo6|+cM=+Q6)UonY#4!=H?XlX_@DW
z1;Nx*7o5v;nR2^EL!v}DpfCJGCP(ouqH^(TZgzkBZ15e(PI^!ZomTO(sd4{)wFSyL
zPTaFoNKKbCCcng|wI^K>SvOt3C^xwYThw)r>QTxCF4Zw)UM2;tmTFi$Jq^1&=X1hB
zk%tkV#@{=f5$VrVrhRR1ZSoSaayGRaW9B`QRoo();Lc|IK<DqPXJqEA$@5~kXZqS~
z9(>yIO{=9xv4!cpvW(b|N7cnR%|0JQPeT)0w6EQ?6Kt32bj$Wz-@A8fpXRw>Sn?Nv
zkHSp-mU~RA=y7TprWmL7x+S*8SVk{9`O2xzpIDI9fo0fG=e9CO1uVWzxWrtzJ}s)Q
zdDAjHUgTXZ*UN0^)g?gkr*NezLMn*9HBGZ=N?5X(u)fVJO(kn|B}IVwY)l5{P+W(p
zI7_)ySimM|K28svi?U4oc}p9wS3RaD!>{P3%yCeH8l&E7BwT)mkhqi`1$!zE3tA$G
zH#tvV?9R(va(X&&olM0-PTv0dImpEimgc1vpKU8!sp`(6c#5v*Xh)gqm+ttL{wiET
zsoi+q%)FVTM$Vs^z80X39BgC2#CDyvys3p+0=mRwPA)vDwBYnmRhIp3_S4htbkKzc
z;C+;dl637me}mp`c0(O6`Ek50x;a^`N^@Kgo%X=8Z$VNHQ;QDsT%k9o4Rz|KuZ}?7
z53W5_9S+vy38^3Az?Lne-{RQtgZQya=lHCQpqXFA*<R50R&NVzKL9G5?II>5<372W
z+Gc}HXm_J7tHg>psd!R2-5dFCRu)M`>r_N+v%apuQR6UIOw`i>b~rmXVATn;D_aN=
z-ZtIJ%hFPB1o;ND2b1%YHl0-tbY-)lX~J^bX6l6XX7av&F<WfE7>ph4d_6kDyE;|x
z3$U+sDYhEq8o~mdUL^k5@jg5oBDyDbl;!TT<M*ls8ok6gp&*F1>6N<R3pMT&UucVo
z`_|mH)gScAmT24=XS}jNE}Y+rc=Mfeo%kKONMb;rBD2*Ijpg|4`*VY{*$Pj^-lwLe
z2X<Dj#iS+tafZ=Y(v>TbC<uv>gA$KJYwP9UvwZU5s8>%LBtf1(8T_VAPTS!0LE_-I
zx0;f;sJ9YbQpt2CZam4w%V&yyA!Yss@>_((D~Og@P-t<{ZhJFPx>l>ciTfHD;foV=
z`uLOr80Emin+X#97NCmO>Xu6g7w$;;{5dNqO1r*SPwGKJMvV?q*X(%99@Y(Eg!m+{
zbd)%hJ~~>q3qjhkuV-DQD}=c#y~JJxofu+7!Z<&8O3&7<ykN7L51P!jIMkl&4=lOR
zf#>f|D5UF@*aQ^2ZY)^`!p%6rtZ1&#AcCnjNWR&Q5;xtF(VUqCW9n-)qnY6dFYaqe
z-lFTHKD|NWXg?oI)JAfFkKRV$Eh=}Ch?kUa_YB>WEcs<RNjYGT-GXVnp)A-}it3k&
zxCez5NT<*AULj$AmWqKbv+F*;LGgGRELa!oU#eTQ-M@6yJ#oO(e4LdPBeL4cPb#C>
ziiz0{qP91bE9(Bn>CnuoX=!|8X@Iv>{to^T2p~4LmVy^d4Ch4vt){v?-0t&bH?Hi~
zPY^?v;RL_*b_fuYcLRVN^0a*-l%mLnZ~oNv=tIl+;h%$_q(1S?M1eyN!<0GKi+tcc
ze(lS168rwzt<C$_r3JnQ1#?2L&R6kbBheW>)mWuty>TI?$I~Z++F!*M#BaX{b0f{x
zA?Vu8^f19wBTnJ0I8M_HiVv?4*-Z794|~InpY1PckY+VGXK8~x{c>UhWb?+>?EMb1
z?4*4@H>*M~H)YHGEb0p#T<hiy3he?}GsR6G*N`YhlExf!Q3u=xbe1Gkp)6TShejXj
z(xjOTAKubb5JAa%^YCsoE!<l<q{8`6(09qb)w4sy+-#0nf=Wrg{=wpHwdPt8m&ppc
z0EB8IZlxL;ttuO5B@n{&99ReXl~|?^JNhiEw$r2^B2^hC#qXVgj<JRx0`!~OFy6gR
zq$`W<)2V0T#ZB$^GMTu<U;JVq=cwr!H`FY_(W5;_qh|ervK>XQLEZe>E3MQynAdPW
zPPtNn%TPNb@k@0>i*48Rb4bJEFOMrNUDUdeXuk`6Php7mL`BC$$qr+~ljIP--ZEzX
zaXLRlJbvt!?JJC3hr5kdG49+lxyd&p8f-R86V5xX#OKp!fDujb^nX|%p?jxCr@77O
z89%S95j#ObmL~5wY5TSk-}vcdkLJvti}4j>r%gj^&H|!Dla%AlUMKo4zguZs(QQ=a
z+p}`BId|mxECb4|^}2NE-PUXrT-DsE{0-mMk6|?x_zHJP?kg^~4DQGYu2PaVsN_<m
z16leVrIMn7;?J4qXJrAq?ZWBSbYjPYW@`yFO8vF3Fh${;@JmXIo0Cgh4HI;WpI$A6
zW$V`aAbJ;BH+vzRCxM*v8(NmWMFs97*LuimZzpp-qXe@aN<u@ksoH^%-81z=s<##k
zt$F^vL<l=0FRn*X1$R%GGv0W<DoP@doT1*yV6+#!c=>QAydxOcY>t-0vlUt);TJ#B
zYbDNu*p084*NldctMVgmq-~MB4iH826(#H)C^)PNUlh*l9dIWY-e7o!%p}@<N2*M^
zMzA+;&|0vYDA8h2WD^j39^W={Yq^q!E8f;HG~h8hfQyQ63g>`ayzuXFtu|W_td8%o
zN+92I3zc)f7iZAex6Hh3?qkzqVh}FaB^})$b?SIGI`pNxoU<6^>KC4Nke}jMJWkNY
z$4MkWvryHQdN%%GoIxoP*x(mpj5eeBA|575v!zUgP%5f$IE>Yeg<6o+OeFPhYB42W
z?`_l@M5#Nky}-d$E)e`^ycQs7Z`y$kI(PqJ$0RWIJ(~IvM{7SAc_U;%FL#`HiTyVy
zIS(WK3-BC!?+oh=W3V20o!H*x(^X(*rHaK2P{}a>$JAG0)dOyqI<P&EEUX=l@e?OF
z3Okj_C6{!ev-M+~D6>D4dc1n4k-n7ig3#SQP}*?HGXq*@=NDeF$Bi6vxid&`!plkJ
zv)nxv3B<?}Y8Y5-V!gw!M}}5R)LwaI45I`rykUD+?vgmGpgYdHf!xkf5`JZfDm#&T
zp?GdY+(|I|ejGd6onTA-2^GlN6go6x0YyXsEQ#9|-xPbLz9^j2t5XVy9cgquS1;iY
zu@DFR7yol$1GC@(g2ckt*kip$Oi>@Ujjzlev%SPVMXTx2;Tiop+17GMX6);Azn4+D
zG>{s=7EcAc?5t57BB=EQMuCIGkFYOe;BaR|{4Smht6glXZ?fHz8u`+%I;ZwWUx~=N
ztIT4We1zZTNd-8JQ)n8ei^ikaqEnspb-WriZFmpaJXqXi71rnx6xrG!@0O})2}R1{
z8Bc$<TQ5^gW5d;6?vW1_PPS?0IkZM3mwjIrqpVpNt$gMm>@N7VO&Xo^Xe#`m0>ij5
z0t9eHua7@By9kJKEiEMJ_$6EcRdV&Cv0B|ra_HG2q}HW%^W_t!Cv!i37Q@9>Kgs-{
zAQXo=*Abj}o)r~syXEgN&CW*iII1<JSW+&9@mgIz=g{rT=9q9+Z78a=oAt;JC^>k_
zOru9W$glyf^Qg19HnH{~!u;V~rMGG`07aYyT|M!%e&n{Ku)#WUns@T(<-8iptGjBl
z{L2Ulf~{GE!Fj`wn}dRW7x%CheS`sLud6-4e+wg*j>H85<r%U8H{O=Of(VTVnaHyJ
zvFQ?)i>qfBAaamZ=G9IpJ61;?UIUMQ6P_dQ#Wr|EQ)JOGvk7H6b<%o@kf0&hP7`+e
zRf$~GC`x8=%4LVrP-`59m|usGD3Eg|2(f91NquGe{ILzSyfo@c({K-9f(MsZ0<}Ux
z%1~+*22Ib3+iNZHp7K)uO3u%83cB#vv5~2EU#@P4{Rcgq3Wy*Mh`HjoiVxz(@~6*-
zGij8EcfN0tDb;_o<79yKgV_~~3n98<+qYfMrClGc2OL$s)l-)lNyhpi$4OhZ@psX)
zW!`7nV91nnrDkUgTfu9WT+*EGhO%zF2<{$wDFpdZ^4FEYZA2<vulEDNm6=RYS^jrM
z><K<qM(EdtO4Z0L`ll^U2qwm-nu1W@;kcaMjbQ0J2}KolenK~$^!4g$;yZTDzE+2w
z3~f{yCYj=dnecaKaGIE_JEIpYT#R=sdZO|kXI>e!2m?`PX%6Mm+@De~U-@Pat=&#P
z$npl;erh%Vz^(+N4$0U}K<F#uIgmZRgKkY%iD8@bv83u#!Y(*Ie@mx|E_Zm#m)506
z$3vj30$MT!Lw}6Hf%XF=kHuG&R1}4*8SGHJU-vloDj-~r%OHlFk=5bd5XR_yyrxSe
zd>7E?do4M%`x|uR2+WJSIrVcu(+*|V#&;=WWZzIgQEgjonj~JoI2?f!(*<PpV5Qiy
zo(uLo4t<lUy>*_OvIh)ooUNMQ%%@J}sZ6HL?GO#;scT3rz=<?pgjr~#S67t616Tab
z{d;GD@fqm_ueO&qfN=e%1ult<H#0N62g8{PztVBjwxuD2x7yaPJX?D)S=Raq85Lr#
zQN)*+)74Fx6Zf?^d@-~%E=dQ(5SlH6&TP!F(xuxLcFX!ivgXS_?tz$ZTR@$jo=3Gg
ztQ<x*c<VYjK^y%0<BkT6(1EVkGC0Tw3g4tbiE-DI-d?<6H41eRCHLXAywf1_N^>)N
z5s20&1lja4-jNc<xOiRjsft@1uhQ2U25_XZmAc*8?3jKSdieN$^Ry7We#S&m3Hf#J
z#(fZ5!jJVJM@z*>`$6<(cMh44$3t~YA}}^1I#%&p-^>Jgk}gG4!o44H$-o$qeQ}e?
z(<aJ!gM7O{x_^syj^Ob@_cFASRi`A{on=_H+U&2Xh($A8=_Xp;c%q{8kzwdNj0WKQ
zY{YVfdXg1Pxja+%;Aq1;+J9@hzL=cY-KZaC0_F^mFX$@YVvRG<X!J{2(Q5XVvVL++
zSpn&`t;|`1vKkMtL<T;Zs9(@H8S)yCJQ2_5eJIvIVPmT(myN3OdGNSq0>}S(d){+r
z*+hkLu=05r`4wGR_MqqexQFPC#1&{5=Z)$K$E3-*vquwU_ej1bhWhf?z=ms(7zI4t
zuZ)vlI^*GOQn6I6*Rm=P)DAnX@Ye~pO^RZ0ig}N3%t*E?jlL3JA9F4JembvXzaLR(
zSvntEA$PQNu-HVmFwCou4U0L-iG-5BVXLB;-woocm#Zu*=@%*R|H%B7TACp4$W?`R
zZR3mQ;=Ld$oYsUS)m7tH<DSt985vUU!%fyyh)O^t<M^E#U@O~hCEI6dt|n&7rVl(^
z-6+K#l^#J`3fAxp8J??PN~7frwkq0f*F~cGyrg}G_ZPIfq~8&VIFE>f&4CW8`Y%lm
z{;d(VH$PHe6(1}m!|hhPge;ND@fcCb>DFBzSa>{Yy$pjRIQ%U+rwO)-w|VU`H8ppK
zYcfL>Rpr|J&wQtyH_@Mq3V#e+X)7ID$;!@`i#_wVqQ|D6vHpn;@{iPz|LkYMFf<b`
zz5~F`e<=m#B^6d4HGv7BgA1$h%d1uR7!%OpfA$G~{r%sccYde+^tAG$rR4r;uh-dl
z<xjrEhEkZvlU>&Kh_FI4d%vu1(|KSj9<R%qqUIK<2ZRr&iOnj;o<BKC4y=r)cuiq;
zw7lOT*SIC`%}Z2-jmHdMn%ULCDce#_T<)AdSWkD`|JC<PxAD=DxV5{G>T&Og<EW*v
zY4HAZ$Zi65J25-2-E!r;TVQjFCZ^4{f8;@gxZFbZonvm6AB!`AptZ9BmT(0@lxUpN
z4W<T0tpcq54_`*7n~pKeDqAs1$DEo2EXc$@kndw!Z4WsW7y1#2I0l}0EphsBkX-uN
zG64?M(tcD=!z6FAkSX^4;c~khegR5$#{NqX(Z+yA^emAEONPU9f(+>(Is}RB%J{7_
zt^|iKxmW!Rl8d&|1H4$RGo@0iVW|RXM7sxpW49`SzT-bNR{yEDk<$K;5|gGKqUeZ^
zt4<se?awP27jGGdgmgC`$=Kid{EP>=;T6#5I9>?Rt9W|PzO1)Q?=Yi!cTJD)_h2f;
zd*)YhdYH73ecoFd5?Wjhkj=IoujAdM>YRMm^D<KbCy6abTE<WT16r=kV&+Xm%tjj<
zdQ$~0gs8RMb?ev@@K6Xj3+D}Pqojta0J3u!2fP+(&)5Yn@;B%aUC!l$*Ay-kOEo#S
zC^nWl->hi-x{iOo)dKJ@-@vY6BQ<6Z)7Q+m^@LJUxBnM=?;Y1vx2}r@sZuSVbWlJL
zM5Kw-fJhUiC=jG72uKM<dJRQ-6A%!Pjua^oq<08aq&Mj#^qx=ygm|Xwch}yZ-{(5}
zp1ptT+;h)ff5}WtGUpiYc*k3w@jRd>+K5O5sg&QE9-s`dorp?hH57nUUY_id>rm!J
zWZz`==Q-DwT#|kz{;Ys&lj6nFag*ikyEYxJ7P)-wjfBQZpWK={8Q(m+IHMMq>w(OP
z58f;B@0q6w<hPAksUL;&b9ir9h-@sa%vt%v&heF^cl`EY6zeA?*}1n0ZsdF&R@8O3
z^j9X!prm<^+0UR68|I2)o6OVSGkp53O#5*sQ*_MvW?b}=CeC0)z!@Gg%Zip?f3h|y
zy3Uz+NpZ?+Xd6Ma4|W34FxbkW>eLy$IMCyf2MQw<gzixH&m29L*WvF;AGgE@vsPHN
zu~AA%q6`VuhMbA2!4m^TSH>;bFMs;v*WE#FFB~&I<SW>O)bhHEPD{O=m%p}(p1N_A
zc7puy9QNgHPWmH9gQm>|5l0$2DP<1D>cCM@vxe6<^7V2+yU&NEswT)#?Nn#%$>sO+
zO*J!@PP{TG&m=q{O30>juke>g4<0K$JbeHykU7q{E%i|{lu3(Pu-dO*UY6B)zQ8p2
zFcK5ib3I$SZi~_(J(;5u*(--id5>c|RkZXt%$n6n$)5`8McC)N(D$jAepk=1+N{?{
z+qL2a$I^8gtT(J{K$j|VK4m?kJSWfR=u1k!W_Y7&{_JX-2a(=gIP|daRr~|nt<Vd8
zzAeG>xK+X@I~rd;4=*;=)`T(Li~HuD>Z{RM182fsFS9nfjY$l@azj;eD(mwV`o0wl
z4m7dwL9s3#<n~H}^Q5xM!HmgPRpmD1`5_XPK;>Z`|55i<vW<jGk~K?l4u_3{;vG_K
z`V)5%f<-V0ws6z|JHVy)Jv`*wIF%OaQ|&pe=I1x<IL>>k7#<7iVI@%^#1w(a-Plyn
zPRS9;rUr5O54lqM?C0+EKO%^(w>k=~mo!5)(agN64SlC)usQqUdGT(wgTLH%mao9X
z?4;G*n3?Z0^3G89uaAlR25UMg?@0wb9WxGgVgggXx|=NO_il2sK=)g5O^wO)2kOPK
zk03X@Hzn86d4PNYRPw0<X!J<cnlqSubDL9xrcu`$!eTulWryl9CdTUR=vIH<RlM6m
zC^IY)oE5$74Z4wq3HEiOVb)h-Ew!0-k_{<&0gdgTdG1c+c|qaziCuFO<>VZ~HQ#XE
zqbU~VO0|#7W=#T7o(V@=ffn(C8xWc6SV82B$u?qBXl5>_$zo4z>nU@cn!Q8`joLv4
z=1W^`Zos_Z_3=m5vE!$5ZyXI2mCa;*w}@T~r_K14oOZC14|xHd!Cb2#rz-y!LKLoK
z^2BB=atoAJV@*gyj<(73gBALAGQ$*AAB67EQ|35<QJ#z-<i4FhD^c0!u=U-WqKdn1
z(azF6L_R{g#O%<WKDTXaAlY`v?mfM4wUyCMq^DaE%jfJTd!JS@2VTmn=D8v|G37;u
z#<9!Ee1RK$zu8q5yGa&ZN}j#n?v%hrB_*DN{WR6a`0~<(fj(mK)}1@L&s^e{9Ae!!
z(lUVGz71YnFNSRZn#-#R*=^~&PBQdANiWV4JoYWnGO>7x=nmo%Sox3u57k1?R5|>S
zMdm@)Uh~Q0BjB*MzOca$kma-Xr3ZA)(YExj1=AO#&v?$Ix2qp>&0Yh(M;_O%jTQTu
zN5}zr#B12<cuAq*V6m5c=FHmFTsf#STjI6I&)*NFMtoQXY;b}ZdaGk3Ppz%!70sUa
z_FMrtqZbEA<1K+K!C3-+<|cp-4Qt4)sjk16gIFlQJuh}V%agj#P28DSWd$c>Sj}#5
zdPlI3UhYT-^fwSde*<7A7UvrgVR7kflb|Yrn@UKRV@SK~svW+j-=`s6Gcr6?hIK{e
z!oI7(_O;?OodNDyi8n#0$vv&%%o>g1$!C36Zg4vKYAvh{50HZp=xGcVaTqyL(JTI@
z);7_`<n;b-$&^$hjaMw7UD0dy%o2g>Y;U??iRT)zH7y;=iQ#v`=1jaTd3p~g)aIDL
zjB5CTFuF2`<M>D=saURit#3tqdROcyDVp;KD8^ts%;%z;XWL2l*n{y&+uZ4f_J~Z1
z52l<K+&dk@Kq&kTH{oU(5;QTUe3*Y>^me>Sxlq^8SAF~Gp6U-T9AgDf06u3+fNEjF
zib7vR$UuouEu=nScg6g<v>Kt0=-78JMs#rzL=kPYo(Q>9PUQ*%Ctc?|N8JY^O`{g#
z)1%;H3z8wI)+d7t+$vvmZ&O3&OsXw|<|!#l0k0&6qzT<Wb44B|+7Y+GtUp)jTZf2I
zt$l_PMc)UBuN_0uz2q^XK~<Ql77w3v2bR{g@qwZ;#i@77dp97`Xj+Tug$n3e8UfZC
zb9cZkto8intcf0Ka@P5Nbee14HE*|O_T`$w-m8c?bgdK@Kutj=cd=?{+Q6`z!tQvq
zs&Zw8lUQ@yU-mGA0><dH!DJl9$}r~KV=5CMr3!TtYNje_FN35J2JDoNyQH7@VN`i3
z@KmwV`hME;4@RnA%!TV*aHcF9rQ=R4!fmx$wdU|wi8`^bHLKYV*`wr+=vLU!{dnf?
zQ0GWz8<lCOLaR;x83rJHKguA*@g_DOrLm830>$ByTfJE+u8o$@vXdz6uR5~U5jw5%
zjTQ<Z@XSN?{5hSuuMR_@Ho*>rv6~)WE_cf;SMU(FHv%-Ua5U@;R<-wVT}BMneSHiM
zbY)LuBxW$i{vzoNG9M<h4FX==Okm?`#dWg0ruJDaoV|hGN({q+9kbSNXj(dcaS!yb
z`q~n7p0qX$^bHFXt~iGQ5^m&Ge1H+41k*m>KPj*KSi9}Y<TvikJ!Six8bzRJS6|em
zcL-%tsTwHPm*yR)sVWbB5z+N}O18QCps48zmg7FAI85LAZrY3J8#foAWe?O1i_fT)
zDnPHSCzpUyxPCE2Gs&c~>V8{ki|K??fiwty9m|wAo#*SNQe>d0>CC_>xad6}@>;2K
znFB3aVU4Ci+;q5XY$ef`O~ifVGJcigIcqv^!0|<+gk<L;iRZ(`NM(K^qlcXr$S*oX
z5KQ_?!4CmJmsnSCKub{t=viy4qquR2{e-aE^b^6tp?bFY8R6!W2esz0<5YH>%Pzvz
z=F{3*yPySfUTNdz6SXQ-gFu_><JSV^14IPOME8KYF7vMUD*_*OShobA1{81`ysr-t
z`>C`glLV*%Spe0*V#C?uTp({fsx=#QuyZGDxh5Yp*&GnC5uk+=Ko-)Ft=@SxY59J#
z_1jnT=e>J^rm>*ySA-_@e2ChEwCGb6Z0zje%Rp!1-RrLRSj{=i7>+>ECB&Y^UZ)mF
zZ@%^)AT}?HkJeX~^<BPLJSncowjTg}^}HB&42bcnht{5@2jkh+_Y5C}a<!KyjIF8*
zDX(jRBp1YGn#WTtA&gbNP3Dy&{PHa@C%l!6c%YemW@DYbQXToaQ@>x@)h{C^^-VP+
z2QW_jI@20LF~g~gTzG$N%P2VCGC{8-NhZY`%6#aUm&keR9^cv))+vLA4WNq>Am6}W
z1r)`LdmM|5<~q2OX4m|Kq#;Y}u@cO2U822K4p=J$P|Xc;nxmYWl82gO6u=Y5BqraK
z`Ed`<WqdeTsBn$Jk)Y4&WBE&};8PP_uMbNNKV=@C)<?r-4!!_qqr+P@reE!SpX@cg
z9nYOYF{Kg|vzsS$g{X?}BxcC>9-OsHiVZV|Xyj`kcB*^t6>8o|Hl=sBe?X#YWzDGS
zlUtnfkcilroxr?4@#78NF0!|#zD={-pINM9v4JRcO1V##cv_74`(a%xUm?Sqb37je
zjr7?I7})NtG7XhZA(as7=i6r4M;I2%eceA*xn4uvTLh7aol-mQ$kNY&xbWkZn23_Q
z-epJzUpxy+{>=IVRs|_=-byc_6xnoTEvB)~(%$Q1tR=_o>>zFOX6B3O24Wc{J%{dP
z@7+B0M$<T$AxBNMM5fo|x>+Yo05l80GkL|$x&smpbEiG5^#ysC^tMWx=5G2^OFN`{
zfEMc=kOF~5M1u)GKpN=v9?qysOs}?=_Bh2CBbsEzxmP8}bFdGY=%u)GZ>Qw-<V}d2
zQ-+#z)<2xPORch!uD1Zh1v2!*&dLW&YX?*&%h$<auO6`wu*hhT_`HePGKw1N2&TGT
zu+L2kI^hM&upMu(o$d4N0j@I*fT+#g_mu*7)Xu<zn=EN))~^oTa>;5piB+6uhlvt!
ze<t>m8Qn~7tay>RTE$p#(5hrXWUlxcu}nWt^TdN-PIN&=Y-rQDe^N|t*qQzks&7SY
zf)hFzG|{g)u+JV9KhTb*Xx(sTsBRj&U4()TPN=??syIZ-bq)mV$TGu$+C0^qHJBV{
z>2#g%cFl5e8O-ZbrQoJv7@njS=Bs!1anA3uyb!MyqfOa)cGKYReY$t0h1xtX8hy01
zgubw#`j~UE#g3dPif5eslLUzG4MwbGjuIQK4SmMA_h`gm+kKPsd_#jWd&FskMFYrj
zuAI8YMoQ2US<U>oV9rpn$M!?DT$;VK{wvn{6CLh$=#7=u6IVooVV33f0bGh_WIgh&
zB4lrOY9B6#hPSFyVj)i$v-rm{3kc(D8v(gjZ!Hi=2FpEL$FKUhY)oWr|4eaGGDT(F
zCPrC^9+q~N5BfY(RPp#Oi(<#J_|^?|K`zCwF=yb9ZYAN)Y!NWaXBAMvH<LbbHeI%t
z-<dAG$4c+^eLtW`o{pO*4T^~6uPiK{diHY(8I&NlzQ!Fd*X>YZ)fIu1^^odHFBHY?
z6rr{f)9@^s`<Qx!U<v={28^iXeB=#8$5G?$&~0#e32OHv75i>0Qi+g(&EEB(B)C5q
z@6icJl#+vDYv3Vz1}Ec)El2grCwo1wIz(8WB`%Xo_X%Rh<yQa#BWY8Brz?=Rhv~zu
zu+9PI0n%g~`MAx2K=74hr`LH?BFnKiQT^WtT+D1dE`0CL7yXE`3qdGg`a+S05-p;9
zJxA@Wp_M6SoG+pXwrWBae5I}6Au^P17J8#OqtK6yLw06dIo>iFe%<TJ?DOe1I(Y$&
z3~sJ1PrF@TFdvES`m^qCA-V%bC_yCNLF$gO%%WAeRPB{Bx9GD=@%`45Hv+6r@6YOE
z8%H^ZoL?cPx^G1?lA0L^nsH#`6HCP57V3m+g4lI+dXgIaaI64N<j*)&;E_cJ%epZg
zRzMz;n^u`TnwQMM+0M%X>~K$j9ZqgPgBqfPHAZ*J57~-J%RdNWQgyn$J^s{bpAF2p
zPY5Wnky-1p1h>vzbc<`5WvLz-<5_$jSMyet(-J{h`ZZ#2IJ4jdmJpfAY3=%H!!@Cl
z`D4*I-)B$z47@J<QTfp3EvNkbI(=o6(kSpv=%`|EYKP>?hm&PrDPd$fqWCI`<jpJ(
zM&V$#IA2||D5j$2oOGV=_Z4oq#vMgs6F>^tiwg<-wxc3?DYdwv?ecL|n&z#q6gQf`
zsfZ(^&M$C`HL$At$*`!d*^2Z+^oLOIm*&6JlE2?)c;awy1FnvK+7kDw)Uwdh;iAf$
zEm!8IrkKx4-xgWL`$$M$5hkDIz!o15!8We}{rlO5WblCseznB09Zxz`5B;dOc2b|H
z$mdS<X`qWP9Lm?-!qRWG1_HQXeNB9&^pWGZL^z8#z#Om0@2TzR0ruNZz1*&s7gEf)
zIA`^2uPut4@~w|%lsId}kOpapm!T<gF3gA;18o%?M)BDR`=zEBl;T`!IL0mE7Evcd
z)^v?g%U8-@?hzq7THp6=%?L&v80!s+01~E-fC_Vtt4?fmve?0<9J9Z)lIU{hAq+jc
zaB2Mn^*v!4O8j*bh|`7-jxs3if`{SZGSY4-?N?+QQz&H~J|g|Pa-MNvox{A4jT*dI
zhuv8Rf-VtA;VV{_p?ZOjH&U`EJ{FgK*fLTTb1`w}o*wgwp7-XK$EX#cm=tToYSX+h
z9R30PbxZUMF&nb<U?w1)h_N=-1@C(~SD@$cD)65Y)>rZVd`fMzETtHW;B6<v2VePZ
z@7mq@taGe;r-l7UQ^yI)J10L_v|o6Cd3J~^NcdV0l#q~n%=fl(JBJ0iZayc^x_9A<
zad0C`CAOttgK;JNfGH&@<NYli!QN66o$j>}f#)O=%*%}taIrBNayLiKv8B->J5g!Y
zb#s1!LoXy<s5s|2YT-=>pqu55Nk^oeN81HL%V(I>Dg$(Cs&!7cI14Y3awc&4s*wU|
zsBzm9ro-1&F9s%b*~TQM!sn~rTve(sO<*caDmgr^+Uspx2%<t<3|w^d>-U&#Ldzr;
zxUmYHH|TMhbaLptRP|nJru40rZO6T476}bf8aRM2{tQ5mpNFfju$WnSJUVIGtTU<X
zGSatps+lC^dLm!9YmnaB@NlPP(rm^5YU`7V&O@uIPFwQoOVCHAA56hKTaa@8OT&ms
zy4+}sWzpgyA3gUR;frZ2%m*3Nu1H9TO$ETylB_h5tC-w3DXAagcbx5{Q6Duy$gyGM
zjY->OyNn%goxLz@U|_`6?HR++A77o%u-_VFx+-X>Scn!wT&;bVc;elWo!xUya;Wur
zzT-G3AUfmTVet;BmneG0-*9CZx|DDzSFv+D-7CixG*5sfNZTh^nY*~eN)N~ms9&D-
zO16n1V>La}@Lz8`yP^P2^%NcZXl9n%oj+};!1B)FxLEwf=NrNwPPC0LxVb*WD8}7L
zD$?WX{qkWRtz9P+(<Otd-v#@!GE$fJeA;l-&9>DSt1%YXH(mlZOorO%_DEA*tWt?v
z7~+wHb-R6K!uUDE#UOTJKR<s0!Y1y?lzFx{GIZnh0(l!JBZ(62Te$n~soT0drlUSj
z&U0jTO9dDe13A-dgw#DR8Ie_zSd(3!ucSRy$174RCGLIJzR~ky!CQ+l{1pv8vwiZ3
z<zZXeG*vT;-tI>k)HIsW2pw=aO;GvH&*0D69E127{6YKF^synta^hQ2qr*M}k4mfF
zn7yXEblfAjO4@Dci&a40vvu+eXL?p-Hk7mX!qf83OPhcsigWt$xKI{8>vlZlAkHr5
zc4}egwFfYvn=hbcir+irT3BfA0~JN}@a<SH&haFcXOA>@^El3|AXG(`!s~NohpC4z
z1-ObXPRDC@YdhBMK2b*+&L*Ps<c8`Q3fy$~QWXus8t+sE6SQXOp{F@KgxdmEYx~lG
z0i95lL|Qf!^Jni4_g;GsZvyOxk|q#;tqenhIJ>U;EaqcHWz;0<j?b$_1@hOD77VN%
z^*akxi!wK{en|E6YbD%uL5mGt5i4J(ApxuR3kCP-OVXcW8Ia)(imF=@D^CVzpSX6u
zxT7V$;R{4M%$^WA0696!jFxkE>T&0+e+%`jOPssOn$!&P1_AKZdHgM4aTs8o0pL0i
zk*#7kCJR%>>uGYZ(QS+}6<*`lH&ouL+FrM(ecRIbA|Or61EM0!%6BRSAnMXXe}FcQ
zVQ~Q1LJY}9xF$m$bu5xw^TM4c!B`sMg^<2OTI}@hKh3TMA)OaEX7X|cvM!**JE#iq
zVfmZ`Y7kYOutPfIGurZh@nQXEc(}B#R#i?qzZ<WL%egXeE%uqgJa1Ia$iW_IM^k8C
z8)OIBdmV;-H`%naB;Wom;5aKSEie5cXr++{_plZ-``N@VjpfQj^hAb~owQUZ+pKi(
zi_QY+otC+P4WSm4-DQ1q;o!2ex86G{%pM-pXX;knSUz;Q_0f5hp)KW_ebb2u^}QN<
zk8~~4Jt-$r@S_0|^Di0SvHoPxihJJ<9lAKJO<=BkG<Ef`3#1=dg-4jl2ctxSM58#h
zB0<{P^yH+n#1jABuliMe#JV2Nj5dyP0-VfR;-pSt-UfwJZT!d^h3DJVmgkvKwP36P
z>rb*Q763m$T&D4NVu}EO31<Od%&L3{M%uf%;=P>vaaX!!S^X3M+zswF%}>^@s2ZS5
zKLL=_2DSi%T^N9{OP>qmK}-iA5YW|9K>JZfVg*m}G8=!D6yWRX1d5I=Htz^lX(8zV
z&~P4L?ZR%PWBFsF|8)od`^R9=4c>ABj@Vzd5q+PNK=$!6d({147qWHf_hTsbC{cye
zParw~>-=AsCgrasfh_WTlou4`=$c{w_=|`Q)#o982Yekh`jRO^D~?=6r%z?R0*?AQ
zL=$OD=;qn-wkw(6AHkV@No~_ei8V0V?uDN&_`kb_JqMVL6^Ff^d84dfy);xi5oX?g
z$@MTcFK|@`H7*Ts$^7$H@Q7P<>!d)q$j;{totw^Nl5w1c*A8@;!%+N<1X#w|)klX%
z<K)y{Nw#YJI48oB(I22+R=DObHwW4-zO_}vf4%&R|2=-BMoc?npf=&>bGdM!`uYdI
z!uH4c&Y+Pk5d(T36gUCYnXZ*bL;0>DSpt8zB>Uuf4!;9YrC&VGA8pSUz&E!Bq1kZQ
z89?4kA3#*Ip)>1A0aqmk!(RCTT7dk~-6{R*=m^cE2s5}toEjXSCvHuel}%2GCEJ&N
zD)Uux43ZjG{~MvtKX26kL%-?hX-S>=!oke`d=TnJm@M^q9U@krp!y9wtr&0yZ>3`g
z5Zai-S*`r~P``{a=qYeXH4i?<)B!SL!0|)INpvSr6{5h(>qw-<K&4z2?}j_}_1*no
z5wK79KN)7}b76b`^J(8F=ljXI_wRelp9gz@=RYukta?Dm_K#c3FBAQ*JBaoD*BJb3
z41fUZ{}Ma+GpsHD7x(c9Yx>%mU%h>@$Yoq(a&}#nlLU1o@;%vz698X!`mfL*{I~q9
z!FUwT)N($WV%ln4(#Y<>W#IC+vb2D;=~F^kW|~g6kQLcs^`P<sOu;Po$%7Dg|I1So
zDf`SvB=xRHSHv356(z`=IjmA~ZRZB_OBV(3tc?#L_l6(Tt_Zu+-ouzsJL-J1+uSxu
zD%P8pri=WPsb!Y76m1byT<&=>hJHpQ=Xvk7(>_=~2xvCmg+iZ~l?RQDaR$xOUhHI~
z<jtoCkth6P#)1C|Tfx6R`>%2RvkjaRUkRI>RauEK4dS}Jy+WWx8LOVlx6mIZBbC@`
z#N(c2Zg_iK@R_39v1biyam3jjNytZ>7dE(*CZN2g(VU=y;le(PjzFhBj9_}43$2b^
z!Es6K9FApEZ*i#G-~Wtq55DHzJfGg|nn9zEy@uYyUo5_S>iHy?u_TlJdy%;R<u2B5
z)0eR{dIz8W5wps_UjN6eGymPkhA#@6gmRM-oj*;K$RD;VdDm_x9{K$|AcaR>d9Pnn
zmL-yI{xjBf;SIV|#E8o;J4XKI-pI>~F*v$mHzs*(wkgWZ0;BeYZtNY0J?7S@wo*0$
z0woX7!9yPSl`)(+Cc)cNGx5<lGF;uWKyOS~$iMUo7s*{00}ayhL8FU6>8Ys`d_oV9
zfHVOoN7^8@8PCI*5<0<pAZNN2*hQ!45Q(Vlmw2jCjxUwUA*n{Pb?H*9T8AaV_=~V8
z*uG%P4-gDEcmf>aa?PqqCzx<cKp<2}!?wpZp6-1}q6?t<0A&Dqj^ITq#^GK!-R+Pm
z@s*?B^J4h!XjD7%cavgWsoxPaDYz-&uKxf5E!kDm06YNg`2o6UXn~kvLaC*r&gWu$
zis@!QK$D(`z7xE(ZNN;-65!)Ru;!#`#NvufkA%BR>SM!*eY-jYSKt(B;D8}t>5ee;
zsQ{Iijq0gu4Th4+wyYrD>tN}%kj%<Q&p;3@Bnc-s*vMtYdM(V3%nGAt**c-UV0l08
z#&UPd)9>&lgS@}ok1Xqs!gH+9xM3MOHNGj-R%ZpGF1&TAkc29U9?njK<dtyw)F@qs
z5d{z*xb*Y0{JD86*Y+6vBR?#@4A_!oQJ_Pzp~G=NDK9gM<`mzAQ*cSAE>90(bUxd_
z_Gm@z&Y(1H3)rE>Y3k&X8l;(nkKTy~wpmbXZOI%UVZVM7<k>)nI=LF`BP55Sl7K>t
zgAB!Qn_B0$eN}xxZ%02dZQcOLC8K<}-41EaxtXmfDvjQji~4%GProkaY_!k2kJMuU
z&zl}1p_U0NvGlnXtd7PB=8m|_LcfE2>r^<a<cy`)Cub{A4Qe+JBzq$7WBd`U+v-Mi
zvPaUSj<Q$kB{S9=B{4QS7bJUJ-LJ)ZhKhd|PK=3Oz{Zk#oQfe%=%Rzl`5tqqMVnQW
zK@AQ}XQFGwxi<`8t>ECo`DkkQs#1Z&(N!v^3DO>8WCWXS-pCoTCGNp6&M<%VuoNqC
zd}~K%!KrWis^FH?YZ@;N(iguqksXA$a3`acm3&8Xglpur=*>D#sw$?cea&&cV+~Sg
z1+7ujx<uuMsFpU@Xrge!xX3a(N%fU53>d3`7Y9_%I!VufMgso2uk>u#E)6*rhFXG$
zZgP)TbXg3=KAL{;<>sww=}KxW+!)}^+GV@4%66p$(B}XLA9O+Y^X#E0%Xf54if+7~
zD-EWwRsl>uKIk5J2RNREp(WVf*XC!H>~c~it6(5X?1nN<-xHr<*R007m#Cv;k`}xl
zvfOhM)>IW!jN9UxzCG`<wN7)YMKJxlRhfm89LBxKvxGQcJI(}dPkIlO-GdgCJ2bQG
z$+E=LC8F+$N~Tj=U059^a~AVUn7nUKhiU1fa$EVW6}v0>I|+oj81Yu7x1EeYBpwzX
zmja$6HV5z=UaoKm@T{0rK$d~NL`putH^+LQJx>}@QDkmLY<kNj!e+nS;;+xD<$_YE
z3^fyf$4>37CSF2;x*NA}rnuVzG?+Rq$Q4`XrTkp)DoPY=0q3U}`C7rqt3MCJ$uqMZ
zox!kS`#T_AY_>XjLmoBNUN_P>@Qo8fDOFEN=_|SHE0N4c({XolW+hOd7$<IDc~bZ0
zRH~@ue(Jh@EDd^l%Sh$VUQC0uZqUedp6V*fC>?bprM<Qu;$b&2@xYqLblJ?_p4O$;
z!x``aAy%x6*zp@5oetBk`SB-P+$l(Pdz6~J?O~E#h3@Y-s0q!*(2}svSMQC-_k&wx
zSyvS3mYXi@!$MA?8teoD4qk2UA5?0`FlyxV)PzbEY(jQ3XdY(ObNtCS!gbJ(bDPYN
z`npo;PE`_RfcjV=3DFfUcMyykSn2W#jz$t+Ff4%Icp1=IWo`Y5L8B<5Mb-d^;AGsL
z`;DpY!Grab+N345>f$;iid+*SNxo}yQdJyLyJ=2|u9kx||LWMaXV?(w44Gq_Tq9m`
zlnFN-nG7;g)m9Nyh;0vZU+GU_d_7*ySzhW*7?C(EL^o_)RghhGQu}Egn_$aRS=Nug
zTYg4ONPTakam1Ai*2AF(TG3Z86?B<*@Ays85|k>u24C2edX~R>7vm;#eCvR?MkiL$
zKBK+Dk2zo(zGMWTEq~p4e$JV}RfM-dr-!wbF*?~wbM`!uvDpMW^!-dzR#c7g*Sg1Y
zw>gJxV+UIe%5PsY@sOb&K1TW8`ptULfd_ekF&<NGwO%K)b(AM2kEp(xm~q8bcL0;v
zu0Xe#COF`8%gC+dWC4*pefLEE-Ko@LA^)c9LGuN8{+U(6u~j%3Kqg|mkbXvK51Tvq
z0YdRjirj<Gqw%TK1w4tGs=8zAvacC6vfcY@dO^ln)#)LVc9Eh?lEi59j08u{2wRG3
z!ydn=jH6!nqu(w<2N-qv4uj>S_qtn;hH6i6{3FUJCM(mJW|ocYapZ`tlyp8K=j-(m
zqnWX>`}SAv=UMiT(-LI=ZXWb!DF=M`p1GBMU1+NX*7JS$G%r=&Qk!hzc^>@rykd|?
zFD)bz8;zKwzwM=z|2W%v0Ff)TIX0N|j_wg!@bds^*>5ZcQvIx`+tfCZzt%bOLFD@P
zMZ6P%G+nco(ons7!Q(tO5-W#^tXt`pH0*|LTT`Rzr`iDU=`TJI!i_#ewCllwmxJ4n
z3S9G35?;m_+_?xf0G4(TZbP-ba<X?W5E$6A)~WRpU;VGWzIpcjoU9XDvP@c#H@`X>
zAmpKWfK7dYk`oIT4Jj$_=W2;G(~-nZ+S7Utkme66xTO^$n<6i*AC>94`IBwVx-$|9
z=T9-1mV5U<(jcwWG`f^Vk414lndR^;QH1$4fOo=<tUx^Qd)UxyoWh86_%kV%Pn{Mo
zD^Jap-rjyW?Y^XL0|8(;zcJMnzapH1DbnpZ=JC*sRhE(f@8{=Q>4|Sit&ExV+=5P9
z_gaviA1g*xGoy5#XMhl{z%yk~hlQb||Focib4tM;;5I`^y_&?ot!92(9ZnTOlgB;%
z<dU`-G|E|F=mIZ6O!L=e@Wti}rIS(zYd=81mRLJz#Fgu2x9~`>;zQyryWiFoC(8k~
zJf{~y$RlZCqbXTpx+T2ypwEptY+N5Yt&}b|X_0*wSkp}(KG4aGe*1N7e{NVh+;5;2
zh3XW#EhwhI>d_cogNH?Arqv5?No`z;fFSR#%*_!gX<C^J4XTeH7!*oHAmyU1U%vdg
zpk-MM{}SK0vQdk`S=Xu<{V-{HEQ_`w{Qk;JmPFgD*?=DR2`^Jc(&mc3%anNJ8;ilx
z&J82L1O9cOjl__1G+r;NFs$i!OX2c&lj8~vI&M7CliC&h>;ixJb6<urzA~n>^MbfL
zAXBaQpx6A}FN%EnXdlMppNFktt?>KZ*FI}x3)ZYcZ>Lhjc~YLJI_W17bXkIqquh23
zj)1x7(2GianMT#5DjEMSX=3{JVkhBSz{D(mxBQI!&?}EIB`MZEjlv_Bb|Fr8+nMi<
zw#*DrV>75{!!nE8y=4OO+jEt#kFbtuSG@f|{H}n^aq~O;>YrQ;58=!zoC6&cfHCQB
z*Ad2s>jy2UDB6|(3`6c-xJM2SXW1AB)a~j$+wg4II%kyi@xHVRy-3x&lvm%rlIKd8
zz9>rnlXd-!Y>M-^zIhmC8C83J3?%wS?RxKTL5MI)F>#?-c`Y3sxUM;I>|-~1)OFRz
z#b!M(muWA9diSrE+Q5xm3J!PLqFxrDpW|9OHAn~@MG&x#HqTQdn<PLR`9;yR`s?FH
z3{3&|KgfNO(ye^=f!HR>F<{3CXc+xwYM;#;(x3vPLs9ANdfy;=x{-*svcgN>kJZja
z9jrS6+ZbQ5o8yAW<aXxm6gYw<V7hCp%Una}dgt@g)F9r(-}=?-E3f(u9F1HtSCz4W
z`Rgur^D|E*CAHs#jxJKv?6oYZTLI$0e+fVi*v>t3i~W1*qP1u6Gj&OC6#`{YCx@-z
ztS#ZQSe@-Tgcu*RP*DAb&ht!J`=8OrN`?DhGnb#4f_omKmkFhq3hx(-5Pby~*|X|l
zw&pS6ntsDf%+|`Z2Ui6w7d-{1#MxTcB-31!{hUOfu{R#r&(^Z0R*D|)s6L>usKrpy
z*Z`T!gN?5*Uji;{fV5gu!9B4J2yApRQS{5`C^%hiGXJRF-FG*I%*yPw4yR;UQ+{is
z74uVuulrkF?&3LX^ivJR&a$+hx0G!{-jbr@S$GIt!j^E}W++d9iIB{T%dIjwF|FvO
zIk{9lbHrQk!f$^H*FZ-eeEmMmYv2na8&k`egaVdD8pd#E6+)=ZuAAm$-ElzqC9*zF
z-uvnDQ9K0ue{tiP89+kI%*sBTJ6eG?8;)JRTO08xr(7-w8JU)pL1U2x93f{~h0*TR
zKXm{H9=tDhN_cSb!O*9-_amq2r1xfhrS*Peo#6<3tAtsmVdPluWh+baa9~ASY&-hN
zGL}PFFo2$`Pj-%8=lsUvm-=T%kG7GHtizq`NA2$YzcnNKCTfv>rnS;_jt-A7BjNY>
zuTNyBWM}HKqP1~_C8ODOiHeQU>Ti`i4tM$M{+?HWYJNBN`ZBZwGW?TnS*_kMgP?_n
zN;gnkNh)TO4jqGYv;-R?nnv=d213-#T$sShfat#`7KYhUQ0YBc)`s7GsnK{&r#p3|
zDQhNs>;eCRelV$I4!IaxzX-wWFk~agTAJ8M)^KouDD4*~OPLWMZTFk1`joDS+W@@b
zFLBLJr&A({oJ~iaNvhOEcZjXIyA5v#4kApXv!g&e$uk&E#*h6$2V_pq-bkdhw*Jg5
zPMPNiNIw3>-#f{W4d8En$L7w$XsrbeEqP10Ld|qI<0ak5B^LmCoeEk=g!L>7wi6uU
z%ut@{Ltnm96H{y|%)@ulwA|DpmxplTH*wd@HR{ibT;gweD1pQxgLJ&#hy#-zj?-Q!
zRvT~8`&L=0^RTr3^_KdFOGS!u+k69f4oeyEh@FjoOKpyeJ*UlWI$+_K-En_9CAyGK
z7O~Riaa`+tL_{OnRDU|fy_Z1+O$W~Bt-drqJppoZkMy8=`N9e8>#uWq+O;E^f>N^<
zb2e#itnWWLX%NXsj(KSotiF{;x{tLU*lI5(eq-*e@H3Lz*22@ROvwlWIb~PV(ZSD@
z#)F4YpqVi}(y3~MCTs_yafuAyC)KiR>arasu>|AY*zwYI<_c_c8Cy@Jx=fZ1n=zrL
zQP*qB@|9Y!=m4KET*c#mmO=D<SQAn4c_FuKMZKZ6PS_<XDH#*o#<YFKBv2f>isP~a
z8sy;sE*+5ZF6_ZU956zsZR3d&)Mb^)rtfy2?_FJN<&lP*Hm7&g0@A*Hcf9~?dS(pl
zCvq1<x8Wfc>P+EH-Abj%m3AWOHij}5-sz$xk(T^0W=Kn*+F4r_exRz#i7p;m+s!Ub
zt#8>YAtB}UT&_0!Wz?i;3DleQn!?NL_}VbqL+h98!(Q0k@hXf`B9|P)SD_v&uH0`5
zcpUk>F?MEb)>wF3S!+vLl3B-$mSBbHkHa>Jj_+)%qq#gWy>ZeyYZ=<q7x2wEg{Q?s
zz?>IGzVRx9IvjrqXnv;y_}E4Odpx?th-;$Vt~g!WPj!IqAKx&q3hp(Ik)+nC)BDTQ
zZtD2()I@zHs;+{hnrd>`o%Tkl|82;H>b(oF<5~&L*e3^02a(2Ggx}c2C0!1l4wLSc
zi2ZRojG`4l3iF26Z71fzBCI?~b~}*>3Dsq4j>!xGkSo>kSac{(zQ_ps`fyHx!n#0$
zfN0iY8sI64el#lam-`uX<K08uNJSAipdM@60SBvZzC$bv%-(B3DmayEkOGf*9)Lmg
zX8}h~U}sjlRF80aDcbc3J;u7ltgf$2_aIC6J6{1?As<lfky?T*T(H+~vr=?F``grR
zv7zIea3=z1M?XMgB`#qg1ZFvNp;ukIGO=|sZ0)d+WWsch^xJ8)RKZr*(ywN*y01Zq
zV=BQ0sG~P^@YkIiM&xVU>-#>b6Z%R%!6J;t4``_R?U2j*{3=P5j_#?T7j^m4Uo;10
zSslJCu$@r?_6UOj0b@yCb0S`5SkyDr>uG-RS&FRAJzUFfca55x=6ANfs{Fsq=7JEs
z<4XKjx5)cfxRjFXX--iMm%>2vPJ0+z{)c0#O&4w@bPI_9Og!IwBY$SD4FSJeL*Jk*
z^IRlc=GwX*HXWgt^?eQh5FWQo)6}QV>s|O^0uzl70*1Az@Mo<vdl0B(@uR5Bdk{J<
zlk@rwDs*r5+|#|bIh|PF)1@zL!P*kjn5U36fq{#!Ls>Q1m+utEbV*~5wML28MJlge
z%;*t$l;IJ}a}Mm6#yjTq6j`kJ*y^BUxvFl0IV$7sP{#Z`<z9MUgIay|JUHk8M(t+(
zBpOoYsZ(8Z=>fyLZNm%;f6wv40fPS%CCH4pPl3WpS8+CMd;_*h(oj~vfjaUNHD-NP
z>zx+IpYvLOn!#YYj)%jN`GvX&!Sov2F7aoebPEug?O%lOHoT#N=IQI#5TimhONZGB
zbpF?5nezqgpiWZ^a61cS{*3#(s@GaSMdb{OvOMfj9$s!50XVA516@^aMfzsr4tI=s
zy`Er;ofpEh^S;|v4rF@eSOk5D0vO^4J-t0Z+SokIjfKwS{&-s>{wt%=6PZ$1rKLJp
z^FD9N<jKUKC6RvR%JuriQz%!aaxAlVJ9u{_`YBE(AZ>x3ja24RWz{ViP7D!|Wr+Ob
z)V&{|=vWD1nr#|&)QR(nE+r-Pe;zXYpTWca-}o6wFcyY9>-Wd07WPW-L-<_eG(zMw
zbgRTq#;YOc3+MEV*W*+zoQc1gF7i|QHNR+KU}>Sh?t4@7nG6SpDlbR`zQy!?C6?`u
zQY9U6nNN-fMAQ*uff%r~H_S3rxpf*gMQpfEz`@@~;?OC6m_fZAwty4Huqk5rzkiYA
zFP`%5%Ijb|8=~Q!3Y!}{=%Jyp?Dfv?U23Hs0QE?^fLuj@x{G^?m*o&qwV@EUGrj&H
z;jzWZxCOHR@>&{CnRTj!qRcZ2&L@;oFZa9f*<qjwpcg{xwxNVBye0OSb6ib~!cF!T
zX+d{0T}&=cZ@}(FwPjXKWdi-A98;jobHaO1KUjQ6`ASam5dySj!#I87w#p0B9hIAO
z^#>X%98xc$KU!cDQFp_Ub=el&Db6lUK0KgSSiMTK%ycqnW3_}s7Mq>9kyv29AsXKn
zY-8eO<M^F~6h2Nj_5b*m*R?y*`{^{+F_vO)jYM{N@3;+;gE|R0KT9|8u|2^yWlR`V
zG}K=e3kjwYk-MLM^xFN5hj1XjD4hly{TL$}Jh?v+&ig@yDMHF(F!-2`CIqLSgEb=d
zR&-nj3%1bDaGa6m)ih^NedX)T!1iW!+h4M#_@2ehYED;rz<_@SmmNN!c&yXGH^ngI
z>8_|f+=OMb0)0_%^x?vEL?TVD*T*l_zNpr3CX|s@QwDiIcB}-`?@NaJv5bD4`E=Ru
zCc%j32WGtN0BJTvG!wh=07ISYbb6lK+BafRN<op-2*$Vy-M&^=6@{ABN?@QBl3)%Z
ztrkV5p9jttc_-o<mhdJ&GvS}jM!rxCY1<ja{d!N)%SO{3F4ewN`Q8+l#{nwgtwN4A
z8Lr`aK})*6oS|E<n-UuJY{gr^Lp5iFsHor)qt2Hb(mw~-$Bjw%kic)_pxq2-31Ivk
z)d9!XbQY6O*f1ojZ|L|iK(p)?bh)o}BcO#Hb3g(I%3$Ns!L^XnGT3To(Tpi-EHHOg
zx}yB)oDj3f+xZ*bp;CBV;Mm9skcSB_^fI*zF?s65QhXM3zwFBp{5t0n&E8@0W6w55
z*P#79&-`ysgj}-ndn7#wWEtN<lF}n3lv4aY&bh;8zgq0}AC$}?@EpVSkMqvHsJ$yA
ztQhQIp~+-h)F3IQ>uhREB^S8RpRHD<p-R{ltA0H{#D*v?bz-ZNH9kh5!;tFsH%l{b
zPS8RxdA1A^*Z}~_T@T*0_)ilXdNyK*mqMXS3_2ZTn{q56g@5#XavobOfo&o7J(n+d
zlacsJQz-ucy;Z0>jd!U}nHLDDu)Bb@e&VfnqMGZ!s&vs_M*BPUJ=Tg1k^l60i+`>o
zbnDz=aCERnMzR#IB-{{-I3M{nZkO#L=nxo-Se3yd70x(2R$z3Tw11U`|A*{cpAsia
zQgfA-t*#zchDK~xCz-M(U9W~ZF4*~tXq!cALKR>90NvU&6-dW2wBpMNR^z*|{V0K8
z+(oP2{F(Ct<jZ_K%9h5%(MZ-6w&;gwIGxXc%(XGPt#W0KA^w!;J8VL)!Lu9`SjuR<
zc@Y6hY<MT*m(DzW17ib8+hmj?msUE;RT_LbZbz0;MiLuYj6KAPZX90`tbAS;k{Y@V
ztDjv#pKG8&TC|AU8Bw{myDUp;23HL)(gT#faucwLbx+KA4b~G4Q9&n#YmP>EB$QN}
znKab^_|?xePw|5|5d3Kd(E}}o2O6KU31pkk{R;&2zZUZRPAvzX*hmNK8b_%gH66OZ
z^R1WXg7t0`=3wD%+?vC-TZC0z7J+ZUeVzVF;6RWO7C;7HmjhhU`yZfUGp`%y*(7lA
z(&+82Yc<sg=8=!`nXmia1MPFJB#-{`U+rg!F+Er%)mNev6rtrCp^VC0A(X-Nl;X|O
zq&|RH102KsFaTjB?C*V3;d87=jY6~^QxL}zOYm1J4~qzBy;#BO6-XmjwWr(to$#Kw
z0X4py#0=AJ`}g1iO=+hnSmeSf|Ce^^(FoUF6QbB}9u~2%3w*#n@xm!~4MG-Sb3HVZ
zevxCPDOVB93yRw5V5P;k#wiTei;B))pl^#NFIbCQj3|}f^HV`<zPFnEWU+MT8ppKQ
z50JrVp<RfF1@5}TYVGZ4hqFA<rin2!6q9Rwi%men!CKrLozi@LAzO$jJv~aPl8A5<
z0q*k^DldEmsM?qfYqGw4GV^si!s8POZ<G2vnvWg=ZN`*qPq25lm-+bIZr>VEp^Z_z
z;7j%uGsS?arlGYwiT3mIKC6J9x3);l^XodM-rSBzn^8V-gw(5G2sJRU;O(OFEv~Jt
z7^1{D2C+a5xej~5xM)Y&tN2R>DFRe(L2HVS?!Bck;9y%b0JxhYSv%W=)_pjtlK1J%
z70BR8Dt*gDzMl9Sb?^XtuD;OX7WQwiYqM!gau}D&!waK>8U?F^wM#9xCLTcp*(5A@
z*V1UzN5VkCogO>E&TCt?<*GM}ZLiv=JE_t;bPVstb*&^H?vT%Q7hs>N)+dFl^4DH9
zo$+k}zlV#C_;AfwCHEG?1D)R4&)rlFcQ%iS{wzhXk#?}*VlDJcw(9z|dveQUiWlyR
zPtw>75bXnKOE++PyTHOb&5_9tunt@&ycy3HEzhVq44niESU)sneR1z}s&=_P8@0;a
zNlyCIniYJv1mJYo`)>Kz!aHaBb_MydEfaxQlo;#6I6dwaAtBOc&$1C5rw+Lx4u~PR
za0vnS+o`^yy&Qq<L@i7jOVYD$p{72V@a*kIKMKTk7sKCp5Ko`f&t9ul)TLv%?n1xE
zQX8{L0=v9v6&z7stlH8DU}xTh4P81cGw{w57mTNzb7vYB2m58vC}FPpJ2CZB8%!Z`
z^`^RMZw>U&$~~i}j8fwCSShxjBN0`J(-<l5FoAw!v!pm1dqTUgPVaL+XIw_06PEed
z@<rZbs?j#{yY9?%5f=lhnB&%lD)5)FPc~F4sz>3dSGlzsZ#xz!Ir>yMD%HRO9w3w#
ziy2#FBYU?@agt`$j4FfFT`~fn0FG$6uzhtlELbtI6_Thk>0MFW`@zTNwH&<~srJ2f
z!Q{P-LZ~V-F-m4Kp+i+@Yw2=p&t(|3=N-JMG@p8VI_=dq2|h~+qjagq&Try#*eivP
zw5V&=(uaKSHd3rVHLwJ_7aUij#vZtR!CgCgNn=w2yKK<e3Oi;q1Du09>^)o-YlifU
zrd}25@d%Ra8KcIe<!5+hobIYG7{So#c%=#0#;o!3&)Q&C7^n;Lc)!*z&{?%h<(Wz4
z>j=racWCCVzcyZ2b&)8>fAoaeu^{xx+N^nlH1u8cNt=33#^LKH9#)gm%V{fC)2)NH
z_-#c393R3<xMUW07elp`n`g?wnZY?25U?9pF_K2Mc;+a}8du^aI4IhnDIgcyNfE57
zphfL?RQsH*wM<5cI}zzENbzN>hR~5!y~|zZpx??zavZ0Rl2o;$^!_v`J6T%zvXnc)
zr<tac`DE;<9lIFbs`tq8p?UmmI-~n{3_|+UNQ*&ARJdB#W|0IEK91}M^e$AwH_y(O
zs5kpuL-z-xY7%unCok_Rp1XS?CoD8-Dx`%Q{I+CAZZM^djrjSnhTpAHWmE3lgQO&w
zW^_k&Ke1aS8*#ViN9*L5?UX5K4ie=#diJ1BB7(UpuK^N8c*&Xrc8tmz@mbaSoWw)Z
zm*;~?mqF(g$?)b4o}H7hz-^nYZ7)^lTNJEI0X=WGIT!9}P<v227?i{<L|U{p3S6nZ
zo%l***=*)8M93r>n-mrkFiyBC{>hl})(**+7jD|UF;%<qO@S{d+oDb6*bF>12nyX0
zh^sQJ)r0%Sl-&|Vl;OhnKbbC^nJcO(8GLXmG$u-_pMeVRqAo|n(o!8T6p!lBDX%<8
zqU{B2i@&ixZ~&Dq*|$Ak#H7s`Xn~2A6`ID_Io+da)kyP+fwJ*HAjolC&q)H_zP4#g
zvT8o^UAd+M;-ZX`h2O`fWLVl`uefh*@@K>jW($gF2J%t_azuTX<_oO=$cX0W4ll)>
zjOTc102iJGXC^>yULecBMq-%K3VEe=f3{M(@c~>BE`|k4sMm{+&U~uyzVU0c{}vr;
zL*?;uiN*)*K(t*b5|R0?5F|&>4n)k3hc>`V`p*Ev9tG}^*wgGK)=|A|c;8LuYv1g5
z<;)NAmvR@@?Zril{~(U1`G3yeZsS{YX3n0-R2F_{ZfXK1^rE7!-{%uZ*`O@#eg;IT
zREOxI9X<QuvBC>4<+?fm3s_?KeMZ&VnX1%nIRyF6UxIBIQ<7W576#sZBn1?=jG#d7
z*1sjPL)&jg)Y+NbETmW*ajiqqo7ZkLofbB5S_GTBiKi>hg>~`v<Ey#x{=B0g0G2i(
z0~{C4JkkXUt50z}_->5S8BJ~H*={=0keHUB{|D$LHX9#2V~RgkM`xdMx3lfbY_J`D
zg#|j%YLJ4@;!x2iY|hcAOW@Y%KmN{urYwN#J5&z?uX>MxcisUR1-Q%$IA|unT?+KE
z^RN&(g@5wTH{erHAx;}fFr?%d)5}NSTPf#RvG8+=ZH%MMQ@7#y4{0oFT>3YRpS&e&
zS$uklK3hCW#P~>y9CU0ur!XdZwYM?F)4q4+n)#W7;f)mZm-efR3{aCV5kEk5ZN6;X
zuVD{QsKY?Jg~tAst6{dzNsMYub-u)GN#Z4yod}8Lq*n<EtU@Ej(BbWNBEhWa3_`k*
z|IY`7)`!Kw+H&E{;_*nu>6RMVEt44H7JABW?jU;!pNjR-r8E*?sTQMXPD!SK_Q+$S
zynnc4Xq|IoMEK=0<FnrBD?d?K54LP!Mb#@IV%z}a(^gOhUVMzh5=E^6wejJOGny%e
zb&&$o54QyGUp7*iH$J{t4m&y20~!CpYG`49Ft!r^Fc1J1`^9K9|7dTu<UEAwe>7O7
zU(9WlCxaUHM}uYi#nkySvU~wB;J<$TZ+_vwIP!YN)Fq<j82p#qb-lC0JfbUt%Kq~a
zB<51S_gKJs4cbyvKR{giZES~BKoe&m*;iWaAL^0*6OrLHcA-~YUD&7(dg_=8pthNn
z0?dQVLT{DiPkcm2#yK!bc$MIgrj6dFk0AH6+*DN3X2yH$o-T><Xz81KUHu;)|Izv?
z%KMLrf&FKk2zVj|y?@!-zikZvKU-(&fmc1sk7RCCjf#dhC{G&Y2uinfYkuKoP3m7W
ziZilC7vk^F3IXMgWWXVo8pZ!Zhe%BOhxo!F4M4WPZA;&V@0Rp6x}n*^4&WEC;RaQs
zc2r;WYXlQCWA;9G$gcVF5c~jLg)J(B5BAs&@*A&A>KkDRUer~Ep*S3`-Q*>GI$R2u
z%kt%$)P1&wp)V?CuZ-9$qi?0@(keqRV?>@R#wsExqcZ%ZTk?R=VRJuHOwGlUMPg_)
zrNE!=KJ1!$xLRpdN?%althoE}5EoUyk!+!e25F2NqTT2gx<6zkY>}%khO-X&3_6nC
zq2^*sn7`I9y#a0mU*@lXQTJzCCJR=I-P4f_0(EhdXU95(9absCkV^zT9l7|{ioOWS
z?v0*oVS>4Hfbj1KI=yZU+%8wAQsLTsOnLPBxKW={C<8<p)mZ=l-ytq{6EW_PgwF;_
z<1Yt;*<uP-GsqM4bW(G-PpJZnOST&y@Fw8`9c8$&;dyTQI*i_<sUv0dZ&I?RA})EW
zSGWN84NOAo>L6^D2?mJA!Z2E}KVE6CX=#uKcxk;=UGQ`Vu}c@-A~?FyP`0BqEU^3x
zF0!E-3d!z0SHl)c2Q)?%v>%X#(P=#g-2vq|sc6P3KoseD5$s{kv;^rS0oi(e+*Lz1
z*WNQ9$4p(X^vN(U2b7gKlF4jMUgd>yMb>8LKZg-&^NT#b(Q16RU$v|<?i4+h#rBQ7
zNdZKsy6M9BTGf^6-NiBv!B<(@CZKMHpTD_hj5TBwI3onQ_W){~H~N>W2Hr5x0!{!!
zqmI$}ba<uGRimqvK~=Sio`}+3z1Zm}**Pl9PoQXPTg&Mg3PQL?XC4MBw#d_6>w5C_
z>+FQOCecG*{QYzXOQ?(AZ73>9uIm!}bDD*xnzEEZ^u;LMjL_?m9@lv^zy#WGr&KXb
z_BqSL#0O5ot?=k?+FyCjQRwsO)7KZOzJe}n{LR9iuJ|*(*JBFFPPl=LRiMmUr&3V>
zX_XC?Z`~^`{ajJOe^ei$Equ_NCzq!?+4ZvOOI6T)!P<NAYBCwx$vo#i4;Lx)Pb#EV
zr%Tq)-E_4Wzt?B=EF)~0gBHVCTBYSoNi%Qtkmnqer@rTdn@}Q+OmRL&Vxkkw(?1;V
zq+@AoR4D&q>Y5N(npVwFz+0L51H|3~KS2Ra$^nw9)_!Jq<o@|(L#c_gC`}T|S#!K_
zS^$f69sKfH3V2ax47PCq+b1xZ_<y%*|G0wxcl_->-oC@K-bgs;blQ7^PldC(TJT<t
z;&YNAHw3lypfy0KU<p2^E4Mp2vpWL;fL&d+aS7)NgfFXZ{1l6jtmro!5K_gyKna}e
z*{vB~i2=q&pXTH!`UgmkuJ4cU$uiF-0dE$9Pv+B4$O^R~j{xtaoqlGoenzDI=|9%B
zDC(s#D#K9ajO!3jk}bb-mDrk=WnlMkoGoAd^U=JY*XQ#5nidP)0`M(A>3J_h3dR%M
znD7s)Lcp6$fbD0BdZhlF$~)~Jru*mLnqy6iguqGS@$&SO^KeeI04`(_eCEmTF$<)W
z>?}(7h8$qWeeBNd2U}De1jwBxUJ+*gu8R8WYu^SdHuzn)B25fq#~f`pdwjovxLGj0
zAj?68f6q7n-d)gECxmtDU`Wpb0L1$KjY8+A&2zij^+1v8`4sHzd_LjG&kD&utor|x
z-s6kGW&?D^h&JPc<+-8S^+g{bb?d%^xq9Ya1@JK1{W7P8za)Bp9^_xIAG_)<STZBE
zE~#hGg4X%O<j1z8<Z??gO`A41H^U6=)rKP$hRXAQH`4@7<V}nG3j(L-;rMX6HSOhJ
zueJUymH+$D{_bB$&m8bA))?;7xl>8Vi0BGrmTgD``ajtF?yx4aZSPPNDS`?}F9M2!
zh$u~3K%|KfI!IMIL_nm48W1T`1q76?^b$aN2kEHvCLkT91`=v$@q3wb=L|4<?>Tek
ze9tZOhfl~W;VoHv@3q&jEXQR90Z3`FbKMQ<2)gI9iH$KJlYiH!lo7e@>U_aaJnU|`
zXfwxMXhjR1a2&@|IZ+=F6tK2ah<;i`^RS@2EKXnW^`{XJ)u0CtNCk6y@<mwl=CwBi
zLQ@T-9P<rt-7{M*)n%$L{o$zi(ewNNdMpQW4kL3L?ViIwj0_!~^x112Y=>=@@WdtK
z^^`2eq5Xo_L-B@mMi)=QIi@7fIrFUCYIdGcB9I`F!{=!@hYaB(O1@Qxhg%M8>;GPL
z;LIw04J<baB1>U-xh@ky0bl=kSW>>85^h@uJZ~+XqB;v;T*l%2b%GC4yuGy@4m!?n
zlk?^6tVVwaiSy#L&9zV4P|i6HzjXORYk0$uPshaZRS5Ar)~{^@o<fcY0|HnYz=)FR
z>nQ(<7>nR+v11`QNkqsMs!s;FTMd}DowbMWOn_hKLK;e*ESw)dvot{y<(lo^<??O}
zltf&ihP{T4FSHz}Xmq)juv|YtS#n>mPVgi7GI*yyeKOcprL5n9i4<zelXXAIq0AF>
zDG2DmC@wAY$gVfwtH|leb^=}0x~ZOwlJ5>~o2_-U3I7?0uqz2%dl==D=*Nl<NvaUG
z6cFIg-+nUs@p||<LZ-{2a;-aVX`WPy=->hG%!L?8ptV|?weQrxjPw}@RT3VaQ_@B&
zQd2}&AV5Uo?U<#iL2lw^L%bMwVe&T5tZ<054y#wh$`_;8Xwl-%Mt8?=<FZ;cZOP4b
zx;MOMKfyhj6vg5pwtBVRB63Xr>*|gYr;+bgt&^HXO6l#FNWrg=2ZqD)dh)y1bP|!2
z*iNc*oZ8NK7g4qR*jgVK6X&gZd4B@mT&tk&=S@q`n#!!3sp1^+Bmi{%*G(G-@rZg&
zep!*D@%?1;j~Cw4P`8Q|0s4`47^_mk>>ViaKs)yJg~GB<_gaS<AKOk3XzDMYCi-33
zLI3`Q%{IpvGmv*%)ncFZ9}vTTFi``?aAdTBwTu*)8TEVMbC;?j>S|Y6%>iEIQt_h8
z;GU-g)6QlDupsiyB%A<hhIBGO5yB*i)c5Zf{p-bF2AbwnH%3)(?Kg6jXd!0o1v{v(
zu#|C=bxs>l%_$kA6`zbfb3#38NN@Im>{XW&G}EDXm-&FGJih_iSwDzMzUQc3tlV<s
z!5isnfH9bNc7bX>`!h87Y;}*x5bxae+*$!arsYIMo+dMk=$b3&vRLKb4Yh9jHy7j|
za7Ep}_<pxNA<=7dE2B!_(N@9*j1QEi;nN~*;**Pb+XG<Fs#|XtX>aO`jvI_DI2H)$
z>Rjv&wfXe;_Ku_2L>Ga<WVNe0<cuE1%)mUQ#`gj*mGZT25swsmg2dVRc408(7|;|!
z+c#_~yV%^3E|9Z<HVIbuRaWUFZ0|iolf+~;(`m`+%r`ybDwWlR&$go>*TX3Zo|Z2r
zz!OuI(8lCIUjqD?Ymr}xtu8X8R+_ZlJnKa*_L>@e+m#43iW*&cE+TJ|VTpk8?&`$l
z#-8=kZ3fRK8ym0B$2lManlO46S<b^i^=vqBQ*h<$ePm5X`RmQlL?`uGda}FoRi~%U
zB7m>Wr0luX1{e7Jmd1qDunfrSGrb4?S)e*ea*bJb<D*6lUzt!`4$D=6vtAuSo8U;0
z%jq9232G>Ty-1rg@X!3?-$A!6OaHr6AP$#nIdgMmrb723$j-tCW8rr}-`0;*6tXJJ
z_MYYd`OQ=K91B9}cWgne1n$0T_IZR00s~J@Enf(I!lU&07T%kwlEoMdP`77c%ma{8
z8SJymc*Ky<7Dm=?#D-S!M|Xiw{=EE))_LD-x8nV$opeFs1gYj2&E|6k7@;-w{%#ek
zTQecE51OYu>Ae>0LJ^NJ5bPZ!IkpNIid`q1xBMQZ^?5MDY6eE-?`;)QDEIplJr*l#
z0zI-YYWCoKr)MZ?&A>SJsJJ-CG5eb4JHsz)nEex$Fa!NQ2kCxZQMJ^X!UvALT^Sq;
zG9Q@<LM4NY!q#(*-jC6tHp?fop@~TO^#sBCFLz2)-AWid^c%_$aJ&(WgTubI9>oH=
z2+@U@)hQ*kTqmkjbqmg2@5$QhW+&!fQIj~;rnxH#`4lFbMTM00Snd++kliDDm#uA%
zR?M3u{<t_Q^(gn+`=~MQLe^6(i%+i;vbiLj6dvTx)6w6%J;3cC$|x9|78J`hW8UDN
zD=ta7#qgMnK6HiNDTc~F2`%HpR_%`;cc;6P3^qgDy5j_NkLz^1SkkB2@Zw8bM)o}N
z+f_#o*%M6gvGKlj5!YSKx0=MLx8Dd*3e^?uG_ToS7CrQx5O88}4ehA>al&m=pSMj6
z`-rWFeh0m6a#45AJ9glwDf8iMj&d3hi2|KH7Gqv2f0no4O165?L!beQ#HS}!ycuM>
z03CvUUGXtk<-<hmuk6PIZO+aAP3h{9y;^^a?<#-H2UtWDY)A%xuHPTsp6MH)Wa_m`
zpY7d(pGQ#G7WdahafK6n0H_X%QZ9gU|JWYkzr%aVDR@!hUcj)xFQ^rCg!3sTeS$d8
zpH?b360y!7Y<25pQI^&jwIEx-eYr&zSfjZ7_FY@PgOUPf4`)cZ2_NvF4{fYJQ8%4?
z!&-Ba^VQ)j-}6@WO{|0leB(WM{j5e-?%`eB?~`ja0ge2zVFjoibvWUR6o1H=%5^CP
zDUfDCK}m1U+rlD$DVuZ1JNWU*=!_iRz|%LNnU9bISFX+6=#XG{jf-1#Z`T8=;-ji{
zHFN{k!wXyT!Rba(u+ikJ?utD(+!yb*NcQr!^R4gF-6<`3EP2)V=@2zrsfz9REd<eJ
z+^Fc3&*mkDy^1CBFoE-*%V!c&BHGe)%w4P!vTZX*hI2HdS;=K{q`!kQI)q&`d?;`N
zp_8JdE%&YT2O+XHv5v+v55%l%uQ{%*BeH&5ln=5C(%XQs92=upQ6Iravz&~gvUT!2
zo_AZUoO<p?m}D93C<@sh&QKURjyHS4L|<*Tl$9x%+m|mCIZmc+aDC+FwYFYrP8L)H
zLpcRb9zeT3addx|r<!;5=z_5!^wZs4@=uVAjcO=XTqtzk72t;@#jHYbfeJ-1kd+J;
zbOB;-ir-D(_;w8p?Nu-CRZd0T6-t;0I;%9l<B%3<L>U>xLT6rBa9s|MEn@IXOtBP5
zrLgBJ@9xKsl{yXquFYhRCnBnXCRW`$A=;n%_sAzlpUiw2pAV~=U6BpyE_8Pc14JJH
zHX?kltEl~a8-jO)x5NjF3W{%E)&ZIa^CCH=dyC{vOM9(U#x6ZsqKJsvU|So`>lUX$
zo4Y&`YOE;I$cpaC9lE5!3Y*U8Ad?s=Ru8Rrp$GhN`m|kSGOSJ4!ahHdz(;m`iAxw=
zwEX=>m@}d~EkYKZmie}mwTP+~eZA1k&;`w6yhDFRlrtw+v*mnG(?e*U_62A)qd^f!
zs7mHJ)tqKxy{AxC=Fzl|5AjJe>cyz|<m797|AvaN7nV#%cIHWBsz<l^|1$Xs?*%5}
zA>4M7y%y*?<-l;sxQ|)g5a0J^)NKMKO(({(TyLp<L^1N*NA;pdBct^N=^3qa?k$q*
z*)zru*7L+rXT|8y*D5ETi)k^#kqp-vH+vFa%M^&oOp7ym{~!vEEbF?VO-$RD7+HV}
zl^+{9sCfjEumc!RzvTn!dWWWk-|x(`wg&izBVU#{g%MhPrPCv1WkqFEDB)|AbPWwl
zLam<)UXY+SCmU6|PViNIeUzm^Cd7P+YXCn+@~Y=Kr&|loV*Nn1^4kUz2xFvH3C%`u
z+`JiADZRoty-eYS8AzdJjD@DuMBA9Z7!ry!PyVn>kSjZzs5=0RX-&o6N9%zUh54nj
zT)o1|?i~<qUtrp>9~sI1D6H=5nq1*1Eoc`v6ErQ7FxqaeEKWUa^K4y|RW(AncYVFI
zBJ6G<Ysqy*S>iZS?<7Rb(Rtw4oyN&M4q!el4XRzbRJ(IkGgUL@*n!`Twj<B^*Y81}
zJH<^5asn2r{+jPnCDk+j0YB4E;iFIN1{t!4IXfI6XU!|3vW15hq9X8x=^iCBhn#BZ
zQ^GUPn%Zgi$6dySfCvfr3_XcBXs#h9-NV1!2_7VwptafbiQd}>;M4K<SY8~%0882M
zB-p4PL|XNQ#l@J*n)U^3&^VJ<IO1e)0YQrSeR$_+?fxFqG$de(u<cAc{WFKpb<?X!
zgyu;vPRi9~0SWVYgS9Q7Yz8O5be#y`I8j~XNEEG9NbZU68KDYLy(KSxEmBmG_gD5)
zHv<J6KfRQR14$5#Y%B8&t#M%!=%j_pb=Zl|BwhF~)!|5D?(JOwlB@OJvy@HueSGgm
z3p0b`b-}$1+`Ct3A}I>bPyohSAT_3Amw;bY99b`8NBnLsYvPwn5Z@|!S1wcTqvdd#
z8D9nd+f9j|znp@9<LN2p)l)0?qNb>MW)<k2=c_$CXT{Gcs{>s#uGY>jk7Kc9=uE?y
zD}6;ODFLK}()dbvb7_@1=6atwLQ+FO8SvkJEs2;yjc0V^-Y!eo^O0^{a#i4~79Sk&
zZ_-{k@!+w<3*6J}$DTjO73&9{UcBgL2(z$PVu$C&qmNys<*MB!Op2!dYt=B|D~V-$
zevT@v|BQpFAnqG%R{<b8tAy`jz|Edlm6fF&Y=o@>U?~r7K6|Xlp$)p6^$q)po~{gs
zX}wE{d#MeiS0^`z{}lLDDV4t5$<l(d)3)>~{#v=ZSLPl|fn1~yDzt$%TO3Fj06lMK
zTWaU|I%xDc5LY$_AXRSK-jr2##PcePBibbT>H72kyXtuOd{=Vjysv#o{xTJROef?i
zT5yDl!uhrbJVX2t*ps6H)QqKk{7}K@GG1&ic!tsp*q)Fd6sj$=<`Y+m3W2_cga^q{
z@jqXxe?sfDCoAIWnwA*Vsio>{HFrt>qVlpdZN<(vHyb0~VU7h2`Plty%FYD45+1Aj
zM6)3n3Y=bL^`gZ&2T}gvozcS6jZhZ%QypT(rk)(fE7i_s$BNm&ko)~|esJsr!_QKH
zLByiLDo!7KaTqAL4~E02uy?GOu+>qXLbL#^MD)-8dlZ)PuIR~S<HzbRLrwvGs{?=@
zS(L2v1(sse@z34)^#;CHR9Eh`x}#gcKKA-YDIL1w0f4cIJYrs-U6JK^O^ch%9@?&f
z$>b4Ja|Hx<4gGJ0>C4ET^T;JDBx8pA2_vKvt)?=*$;*k|C#bn`YJFx9uD+6!)K|0{
zNSDzVwRM(P<qh`Y!>3?Y@pDaA?droDC#M}qa?&q&&76hgQcVUgp)53ODErvBGGHzf
z!{@CF#GQSxKETNG9CY~4gXjsE0zUH!7Kp7H+0oQHvh2RZX+Ii{>h?#r<%g<WKVF-D
zU89b_{z+?=0SAnIvfVFK#B2&GT=_9jYbo7P@)UktYXbrJ?oMu1;bf>6Uo8=)vaup6
zou1ex<CZze6JIvxpf4d`&Wh6vfD21}j52ieg3Xld@Ut&Vt2J0LPoR<dnfuSv0M#k5
z+>FcYL2m<CB{$U`MYo$CB3M!H_Hz3(d8)`$Dph6)Ph1Dc_HLSb14Fl6{(u#h2L<*F
zd8aY#@~BxqB=4&RT}1wai!Uc*uj<6vj%C4GCOaagPgC*^8Ar8in8beajuON-iVJcZ
zPjv(+WC8F7esl0TeP8V_B(a4ma#Vy2N^L8=$;r-jGg6)9@yXGY^^s8Rb=u2#*QOhW
zA8q#3Th%{5lPhtHhI%6pfIxg7b;0LuW&Xl%L)rt_w)uD=)-M^Vp&f2HxW<?B@p5oK
zZVBn*$2SAk$CnfYu<n}J9q_a^aP}xz`h@B8sn9cD7FI1aOAvzMhW=O7hu^?jJ0A^z
ze|MYL?F~-NyYL5^q@|de6#E#SyLBNJk4A9nT@@77B8yH9F3u@bFlK()N=tI?ixGh%
zv=or&s$yvh0puv@Tk7A4Z$=Y|J~1*+ld1qw(u&kaPI9r6qe%yMxSWwhqNiFvY?_`j
zHjkuwS*j#*=?*&w&D|NZvUX>u-(8JJaswP^9YP9w+N%+&R$UG?Y?R{2(D)EJizm9+
z{T=j<cYJ%pV0RAiR0r}bM)|xwysizT<C>bg#?EN2@t9$-QWm<)*tD>AGM1NVht$&G
zfY;{=D8R#vCJ{GUASFd-Y|h+yM_>pvx}*U|+KCBZl#?+dOJWY~O`$^~pPZ?Mw~&jK
zqWsw6F+c@;1*p;uB>`n3JC$G9gq)=)g9bhJ_c6MgJo0=CA8);?!r;3l8GUV`_c+k8
z({EN!jB@LD<?)tEds!QOHVOI~{lzQ*0Le|;39#NV(FZI<{Xr>^GyEC$lz9!sU~<1v
zpUt(Qvk@O&T~;kK%5Qfe*t`@ANa2A*%AE-f>_YKcHXuVQlKp(HqY}k|n3x5pxaNRY
zw?FCNu_m>v{VrBcKAF?D%rGd(tZPxl@-@Q-Cr<`X%P;D@wz>8w=<KWdI-JuHaq&ZW
zcYg3ax=%9sRY0B<@uW8P=w*bZteH-hBU>m305NiHfCzCaEU{rw=uRwB<H@u3vmdVw
zoNk681J*i!cXN5(VkG8cqyrcG3~MT?ESSwj%IkeV1#x?2x3=Nh%eBY8MjqSUTjrWn
zH#!`urS63on5)&bbqJ{pV>?_Z5i?YH+I_lBEM+R0-rjNcd8ThYZyt$*#|bwu+{v(p
z`wDk;b}RX1&of;Er79BM+AgqL^N5@W1`p>17-t@f(_@yOUshJO_H8XC+|5i71Oic0
zQ}+KiEW;d>f+%OeMWn%5P%*k5!=9p%kMpdRSLdO4chw$=yhxhR%u^Pp<SjB^4`g%T
zSj0W4LCuV$r~OvLkrXlM<gYf1+gD1^<-O0Df3zICM$F_le5b;_DA+F37Zw@9O;0MG
z2^d`K0Y&PyjV$;CbWrXH#`*+|$}NI#@AQLFe88CVaR4^|oddu}yz=w_Qb{YoT&Vy?
z<?JF5hINC<Sjqtarw41NV^3B)^eGXr0u<Rr0GvofsD20G>4#!8wZVJ)mWdeJjX_|n
zgzj-7n6MtjkiF9`;KLW8Ck6WJ%m+_9aogqK(J$r#W3^HeWg5%m@1TIYJhe~zB`^?t
zZT^MG=_TRp$B=4!_@OTf9a9o*mj-)Fd8_y9>hjajYU|n48}HvU1v_MXn9B{K(K0>*
zWAWq>qc$HH7HAxG85@=xrBZz6&70c!X;vgLDbM(ys2z0<zL1|BRpf6yZNU*o&!{x$
ziGkGZ=)aj%;9rIYOBqL<`NUdjqU7#5Zy*l+al&{7{#O+JPZ>Fn03_S~K62)Ht^*5$
z>~`*u-wce8sm@iV7@byWWBYACcc9(s+t^pHhZksQke(^-(2`t9i2>Dyafa0UR90!(
zHk3JeL#7YznW0xd0JVhW^?$<z?7R{HpNhixy@jQE=rG98DyF#Nwp?%Z2z~)cb)huE
zWQ+SXF;ex}TcA$#T~zKw34WzRJs_LBKThVbT_rI|?9Bb7B0iQcaz{Wt;bw8+GR&qK
zFz@`&b~Jzq?O#*x|Jh0Z1h==4y^zUlAY#(uK5OlrlQLHyvv#s=%?xG@{;@Ki6y;Rn
z$>LyDW%PIub4_2~wKq?1vxGPg4S>hWwj~7VU6crlyMIg`_!+6-f5malS9_M|sN#us
zVugzCYbu0h<vgwW7u|Au;Qovo^ZiHgD|5Wh>)Q#__ljdAqr)j21)JqSG2dz~|Hd!N
z4V3*Ug!NBw&ol_0RY|)+()INB<HW;8MNU<go};+Zwl&jlfCJsCVeK-ls$JddtAP1M
zRZ4eJF?AfDOLA(@8MLQjY?NzDMrL*DdM-_dy$}un^}Q{q;>&<!VW5h&<s-AY;ss*e
zUJ-Mg8ow*9Fjp1%Vn4Xb`;3yHi>zysf@o)}$egbC%y!$*2~^xk>u+1=-UzPofk!$}
zwnD+^3+UW<1X)zCGH(4^7g#F}drNmmi9qfsPO;$dPbp{ewm}Qv4J07Kg0_he17JNr
zkP7O5)Gz%Bwgj3x3ex6_@J!vDV$IAiJ(HR`qH}pPd_;T(NI5|^-MXbu9d<`OM$}x#
zxgCnv-ZM6}d;m4OZ|9~ReG(iY#ZDJ}eKPbVL-~m<E-EyzKFMSSN2;JgGVKsBjRxh)
zq1ldSHSfI|&erW+#<TtbT?V(D8zTb=5P?h~g;)z#cCQUX<#681bq~Gp9tjKDA=k4y
zM#BIt?U7Gim`XhL*)oS;SLjiBDD{;ad$~L#08GwOL9{kXhrI$0aES`=P!Mjs?7(?p
z$eQYTmur|`-t9kJb~#>#`TP5-4e(SrrmSs?x09l&4DP_qLccG-{teod9f1ja1IdL+
z8$Arm(h?fi5~P2gyzR-P90@3wbKVxX@#F$MBuVCX+Dq`A9{X{SeX$Oz^~MDg4gCBf
zj}}M&DDh)RSBkt<`gZ0c_sckan!=Nv=fM7MJeTsh2Jl`x%2Yby&eDj^*PIww-jkd(
z=c8NU?sRex(?(L0h);P6-954-=Rl|yN`=^cY&Pf=65NPV1%g7fNE3rWR^4hv&`j<k
zQL*Jm&V?f~oJeZA*Ajwz3&<aW@B)*Xdp=brK=)IC2-R&^%~3UY{K(O;J8}_+DxWC0
z*Z8W^9zeI%gJ6SQw*HT{JjrP{YZ#XCPYOA0q*z)VaA_>?#xjv@P(W`kq$NQtA9XSw
z>I}EAdmMe^RixGC480jUn-YOKy#<8@y(J|;PGbNuoOl91RNPdx5*pQ(e4OMHNm(Z<
z&dT@kK!f=!WBeavg>&R48!@J*x0_v!kPi1GzP(Ftmq2D62>`!q+|MdRn1;4!6BF&e
zwK!d60rPGfTj}5364}V9^&2}c#?rM6C^nR;LLnjZ1HwAa{3qRTKeg085c4grp|af6
zupNWBOi2f-3G@njg_Yw-J2!)$p*3sH0@!(~Enw2$1HYJbYL8(PLEb{!;?usgrE$Hk
z^gPzp+PGs3sBGZw-_)w$_j8)scWsO+t*BlXa!7k~MRqdcL|h?GTPG1!n()9TK$*Ch
z4JftpE#XKZF~DxP)vO7Src(Yw<Q6cfC1~UqBa7B^7rs|mtWjC%TrYpCu6{+d_5B`%
zUY$XES`HN;kqy&nd^(vNDb?hy|6IdZRPpBEIC`2A-lX9OxJOWLjG8IRx1Zm{A<0E;
z2jY8!&hgA8qu43hRn<{J1=>R}qlO)QM8+3cP>?przxpFR30yJFQwUCee<5Z@`^o18
z0D+CziY`p4ym(oh883ujdVIJHPBCmQMw^fALajVE(bJ%z@DE>?|3)$~L)MufG>{mI
ze-@M7u(>k<+v8=qFu+w0=Cz)fj&tv95Zib?%~?xS>U-@G(B^uiQ=oP2i;fPO<e}Hc
zTMQj1Z!U^6fCD$$Z$m}#<a*QjOI=1TJNM?u`HY4_s&{BR&|oi3X%u3AEFyCO*Vrq#
zUV(q3?4H|*U+xWw&2&r@;dD<G`&6Ky_BT-;R_7iux#y8jWB|*=%}h7-X(XKzDjt~|
zA*`=As#CEoM`z00($OAPM;rs1cOwT@I_Y3wrOVvQ_Q)4G^49ZKC!;(YBSF83uS|%P
zKc&6lscpa8oN+xOXWXPFN4R9P2Kd;k6Gj<X=|@y3IafVv@0kr$kokjGFIWO(&sO-{
z?L3Ss_Rjv_sA}C%aq7g=eDX+{2D_#V#okUc$IUS)ec@#yX^2N!CC5Y!B@hVg2Vs#?
zyF)bS`Ws+if(evWa1yWTjq@}O-Ll#rq|e+tMVSf6l?_f7%Q?Vl76t`4G?4bK7s^!o
zWJ5j-?McIFH-}LxC&q@&4H)?3adEG`Gtcp(cW(IBGDX=rP~H5~Iq>q2VWDc9pK)4?
zaJmkqvN-xX-P}v2MPV~{B8kpFFUcq9+T@#MBH@)48_F_pf4lgps5XiXBDnOhl;+`=
zwSj7}s@}=XJd<>&%Ycs)t5im3=3Vri*757_MQy$66KeW!UQgtm2KyUm>r~%fX5bgz
z=CQH4)Oka)@7*$J#7oD6CS<lD@l2iwe{?C8(4(kC3m<m(=9^)4;H|-VRkv$^O&*sM
zwm$qj=z=&f%?!hrfTvujbn;?UnDbOE4J=x*yx-<QFITQpf#fBcSK$=6Pe9a0LF##D
z_35}EvM9sFa4oIW+SktTt0Tq^v&3cV>`WO;JlbLe0CRVwd3<AoYArkiGu%8bk1h`N
zci<AWvA4LeE81oL?CGUh5}7G5D-vh||GvA5+q|OI$4!Z?(yOn{eCw@xnTj}bt_xtx
zSjpufs@bS57PX_W`dLfwM9iw~rMB}dI5>);gq^HOTe)T$18y`k4K|bQ#P|9gg#Cyq
z2+iskK0f9Fs9OdBPN88Bs!{E^Il%;eY9}h>ANlv!QS09t7Itd36{o?n_qquuSv)Z?
z_qg<$4|cbJ!+?-hQCb3TguSPNj2srBVnc*+p`&pNme*TVx?AP!8YzEv{v+8yzMHDU
zB+g{uM{W{}%`E{NYO|=}FQsAB%!N0@TJRWL`;n#{-{5#KNxgjkFKsDo<RWry9F$HT
zQZkG4;^!S|LBX62PJ=G`*%|xATydXFVxN4u)?0nwz1eooR%e{Fc1EHHz8DLiv$`)d
z+bDW&tAR?{!mhf1qrWo6agomYUS^y1b=;tcb%c$d!7B4Sc%!{`oj-~6?K?LE)`khB
zzHEHhK+o-*bbNY8zG5wXVCoIy1jbID9C)1;G~*^b@eM8Dd$stqjb@*5f~>fYVXS3+
zvJbOSlwceCK(Pni_&DTY=KSCmx80>!*uebFxOd8*6Enc^PylSb<9>jI=GV}}TP2%-
zuIUlm#UQ7mLzNE7qw1Ti(c@|57$!FL%NLlnC{#grA%@~(hK^A-{&$d8qVzrVIBrES
zt6Isxx~r&4d#TQ7eWA4bD>H&G_Sw%);-5Jsat7LoWr~;_b=5_Qr1<B|>^jDfx!zZF
z4BcX4MJJI-y#4bt5xh<}px8@M8tTwV2>xj1sE9}-eXl#E)zV##*A=1fqs!j7D7Uo4
z3kXBCn)SCDwwNqT^b2$ZKHh+jivYD_1;>);#|A?Z&Q{FfW3U0OFZL!6U%*+#$$!F-
z2OS|2IrO*w0c9AcuwL(UKQA=)zHtn%$!G=D<u7)FC<JZDBuP}y+YMu84>g=`wIu7W
zj8OI!88I{MY<7)CHzKHM7O0X$9J0hfD1S7W4{NMypN&*Z>!J<R=2|2DYD?cNI8q;D
zh0qEmf+Q8?#Kdt5SCIsrGSHo7*l|E4`T(=LHhl0te4SOCa*vSfTjCU#YlGdGf|HG5
z>*mT$YZDD*;v1&0ja;YtF~&-CfF*pGwtY{-F}mRD6_TpgWNhJfb##wKJMYd_0SW3w
z)h76|<N?V*>|pli1}52GW`Cf)dwHf*2Bs2wHn!TKsGUi%6e1@1m^J(>s`iTAAb>z4
z16+KtkrN-Yxnvp=Sg0J^uZOHb1PmXvy5!SL1UYOmZa{U5daJ<b^Rp_0>vPNYR*HPY
zA}^c+@sn^m2^h#`mn;S=LVc_^=(q&xv5Y;%^5rv(7Q4)6o0y&`5^Mt&bMtQMsS7dH
z8*!4Vv>s2hv{z-*R=?VHPzg4V#qTBvQr2VQc?}3#Y%*X*jVgS5cGq?ts@9^UR?5g4
z5SFm6p+tXed;N<yxc!=H9x`3`|JdPVgxVL@0Egu6@p1cU57zIvk+McIep?<JC#GE|
zGN2Eao#w^)j2Tp}sT$z5A+achnD2y{CBQlu4Ds0T)=zJfscI$gqEzPe&sA0QI1o>G
zsp(0Gj0_lmxz%DyKmgY6Mtepp4pfOwpSs{0C@;nHW!vbY(PNK?NMD=Yfo#}xi;#5s
zBxfZ9qhoc#B#zBBe%#CN@e7SfT-+5vj#ye?3ef~g3VD|SeWrF~^km*PrG4nmsvn@E
zpv)Afk8UjgR)S*K%fE}3rM)V|qXLFiH<?II2n-Zy6*I`(@6*vpILpx*VI`{-<fFdM
zAiAIZ3!5G(vp-k6Za65H3U58vf~^KXn66)(Mo9TwtD)})*2X^cbkYZ(4GWR?gt3nk
zF!?wXzdta84`YT8_9gaIemKIs`IAW5vtTk0mT_21;|?~`!NdmN#V9g(>Z<(SQq}Cd
zey~0nN*H^WDY$kKK#RKb#2L{)A(;G(c=EsE_%TXRbwOFJ|922s#MJp{Gvl2Itw4*Q
z%0@BMrA+GP$&ezPK8wTF!@4Vnsgr%$5}P`gxwfoVlhsCp%<yP(4gQ$Y0^h*QyK`;t
z)!vfPr(ppP`}JT}>O1NTkCQ1DF5|rACDmnFVLkD#otXB*MP;>jZFS8G02fDE-GO6)
zM)p0vF|F@d$3U;s5aNxWlK~g*>?)vmKPgY5+H4fV8-BB2Pl5o&`x#+1;nx;$DjB$0
zTxQ~JwIU^4j;suI5Kb44Qj>`VjvZwV&ug)5*}Bn<4dC-63OX8nMI)~!@=@zss8<a%
zEU(X8X`_4W;fdu-1iZrq{K0egs)1!9qqe!C;xZnUTt6R!qQ%2LUcwv}!WV0IL+EGI
zPCW9Y6bFF>L5`_!J!!*I9z2s$QdB&7EB(;2dw{GyF5Thl$ev0(r)x1pn-*<ikuh|3
z@YC~G)8m|FMqe~bF|OLBXePfLzChL8*fI_AoAD_ds>`G@llt(Z1+wIcJWQI1NiK#5
ztD|XyRJiK6YAhH=P*5wetN?PM{E>zSI7Z>{uT{!8SZ#3P6dwkCI*IQiJ&EZnQo>W=
z4HZ7C$<B^P!|QBO>(MkGWZfc|t}K39tNZ?IWeMvP(xQ};Dmgd=Psv=gFXNuNir~5*
zGd4hdzXlz0y?kdXHT?3o;N(ck?lQnE01JcxF0~aGVv0w?hC(?Z!=HkwPAw}7@D<<)
z@gyNS_ybD_!?2l<VG5_+rFWh>3$6pEd6^5ex?xi3b2lx|7KCflDC5$vzXvGqcrO79
zyVypi^-KESK@(~Q)0*q?2C99z2|$IAwDTcZlumn;@#7ZOuXQ_#A4)GL;j61DWr6UL
zaKnu5uw`*9-x8#51McLA55=)m=|@5+plSP*h|Qa^xf;Pz6~zc}gd4?^&G7iVjbT|<
zG~XPhj&go!Kko=a3@I?8+t~G?CaZy9y9*!P8s1zW{XWdo#N-w}<1^K4U(7@J;~1`S
z-(srK42+AN$pumUYx%WZX`t^Q$I6%^)9PVT;UE1u1ZG%X8crBy9H4%AuEAI3y2Ku*
z55|JGLaD!s%5kZ8&WXCjRHV&<y`9{3nvLlmj^2jzN(gxBHQL%|T5a1ZvbK=#wvh8V
zrm)U}8nUSa=i{F!Vg4lH^&PIH`!Nqm3^l0DP6;q&roX)kEvDeu!SPZA#vrTIlSzu3
z4$M!?WqYpQX36*^LV-ypkM^z)o0PpZQGP2QLv?EL+sKmAfHTf4yu^tg(heLc#^_#s
zvTLG$mypfk%M_L(Z_eV^7ILbGdzk}N8!0aZVpgIu$Ft@M=_k?9c)^*&pWn>1f**8x
zT-V`XGGWlX-*3O$SvUlHGPQHY^SR;cGiJR6J(=)&g(<Qfa&9<^gBzWj8vttQ;iKEv
z>`;)o9Syky%8TcaWm}w|_u3w)1Cii(0q9C!FsoihKytVAmA<1fcp9S)><4XV;GY%X
z>sont^Z1S(_<7m%aM8IukrYOL2bG(hv7l{ihiFc6QZ#;<&u(i?U@ey$Q@&5oTtV=>
zm=g(>tF~Bvq<HO2{e1pRo(70fVqTo#$e8%aWb?o7chqb8mUvqS<aZaLckGI_r__VU
z=Lq>Ms~`t@*f1SHh?6$}WJjk#uG$3^z8WMsH%{Hc*SvVh2gzPrX3y&pcySE8kFP0!
zR_+(0!aRFdw|jx<IWyS+pcFbJLdcHHM|b+N^dgMhE&KHhr5?yl038Nf_Sh570~z;d
z-Zwa)@8IB!2j;l7`tfzT;=N7`P>Up-^{Jf`fNm$E4*I0c!Y4&grTZt5@S9i)c)jza
z&CcmztQi16ynS0fj)9190kp$PgHHg~!GubH>0rGbYk~S65oj(W*9lABNeu6@9$W)Y
z%KUZOKk|?bj@Vpe>r9zcRXozx3|g8tE$^}x=*S+B*W5NS_((8vvb@u`qSzOK1{);Q
zF9`d`DtexjeBS_g{_$)NB1Uy2T`l-hKN-rh2PcQoC3BLT-KGWUxccWJ-j+R;3a3#L
zv91O*39P70PH&8f9ba%l>cs9mu|CXWx-~d9C#ro7P<(B5GJd8U`=ONMKVe$uEatw$
zxT-n{su#TscRlS}#aYkDgF=Qrv#-=aXpdc)^5je=j}&`}GuExUayU#vkAxS<UQJW@
zaCjyk3NLX6O3Ds^&-Gh;9*%0Dhl`Y5?cwkQABt+6Zsotu``a-7ub%U<1g7=ygI3S`
zX$*D|<O9_ZoY@+-@1Ow9DaGI^_3cM|4|wBcx^8_VB%6+8&(FIJfM75WZVHU1a(BuF
zg~mJ5vluq|WDgRYEI8So1h@a*1*n}P(E|Th1ow*#xoKeous$93ggArfpS^;ZL5KND
z{q2d7EK43!%jchm+$?4FWt^A@O*IGDq)rWbhO;WDjCXyIJq7#cI*Qf!tNLPiuFHDq
zq8-q8d7?l|qyWfNe_E25f<R+;pnRxQWst{w=<dhJoxwLh96vZmIPZYejOnk*{eSzK
zl5{NX%HzTa!=V`luo_pn0rNy984Z1(dk^q-m_AhB{V8B^M5^*T&~^>t$3(_wa|)K-
zsGau4*5oQ}M3j%!=uq^m>2^U9>8Uwjuc!BC51#)Cf6p1xVnDJe#*V^9+r0fO=X_OD
zYSf6CQtz2rIA?!G5>dq?8`4NKiU9Q<d<}wkL^pK@o0!QO$j;2*Vg1KHX&M|Et}lV6
zr4{-K!+LM{`BPpgg+DY{4z(=ak4%Sm`sD3z8=z8;>Z?3C;3gL1Ym?CLAP-Hz<M%^v
z?QH!Zb}tX3UIAEjZE65Hnb`T-t*>yv!xtfpb>o7sd;ms+&fC8}`EPtemtnYLbnt)#
zX03-Ie6&_IxR>!(nC@=4tacueI0OAP$VAb8dn#C=t}6XRuJ|@=TVLmc5IYLL{lNwI
zQ<QV+kyCo4<Bc_ReZ0^(XQ#)nw$8=}_v;+6Gy&rjQiqXXoBHdiSn2F^*#W8r2#YyZ
z1=9Bb;FAs<f)amayx~adfaYlZna^06w1Sso(4F`e12-_7vd&i#qr+d$wVw-z-`!OB
zna&Nc<ohd}{<{yGWYmc&e!#_AL_EKN-ja934PS|1Of1qP>!|V(<Pv`{wK^kf_f+6i
zmr8bH%mP?$%Ix=5`MXVzJh58_s8V5=u(!HU#&hBB;9$*rVGhLS@e=vPY%xJWt^o(F
zfon;jj#xI-x5S*`@1U$oALEfYB)G9w=?R#q?;qRtA1(p>7eABQv?MUX$ziuQo4+7y
z#IIeQAvnP<S$;~ioVxQ3AK2UNcES}@RARPQ$^GO;^!gCTUTzuEmjKmdJ(w^DM&EUV
z^xL1@=G}Kt%zPkB=trKkB_bvaG(zI|5ou{g><Y+(8s^8$v@VS`tk^kb#wV%Jv%cAb
zBz#xQR{t!52xuAPs-Aava=iv@TmSCIsD`7u%c%%xKZp%>S8FF_4v!&3w>TxZplD?q
zRSXEVIe~5Qp~;+Ml;W?C{<3oYJ0BBOy?L^qDmtKv_HD2ni0C?KwaLZmkJ<B3DC<+A
zq@7bS-qTXynhy6B@pza$Hs<g~j}kn8@2T-etEB&(KgapOLkJUlAJyWwUKxBID}T$R
z;xdvNzhH@--di7W3=i@Y4O9sG)|2x!EKs;EsB!C}G&J_GQ%(gJD^|ROX=8;6`;;^O
z@c;aC9y-cW%CXu#h{-66V$M4uRI4+luf=7s^RwQ_0Z(pa^{agHr&U<Fe2~>Wcu%`p
z=?KOdI6L@8HNa;uE4x=Q$-7|L(xNqy5uH>Cw%7F59fY&##UPhR%IMRZu_>Psh-L&i
zouHD!#ish`W)R7?D1=G3ztUa$!*VAwYVfhV)l;{b7ZlWsop*sod8XR1K&jgDUA{Dg
ziO7C(h=VCuoQy9`7LRQL@CV2#tCD}y?#RV5aFuZ){w-gbirhN=s(ZG|50m$QMAokF
z%6>4_s~D80!P2<7YAd3{NXbfOroRln(d0rCi^n#Kohc9a$eF2qV@ykE<Nma8G~;X}
zAaGM6P?a)*sTu%Ek@LO9uf%Z|&UAQV=pQd)uCt;Lzc2m&Sspq#QYz6}z07iBR?^+)
zN1uMuHetLkif8wJlefYHk#3pMnLe&F%CSF9;#IP5+v9mnS>I?XUXL%2UfVo#N+Nw;
z?vZf}6dHN2Es9RwjAr7o`(jx^MQ>5CknpWy|F8UAgp4||J~t?^yXRb<+?sDqI&H~;
zNJurx(2mU(E@LmH0o=xDq=jZeA~nVvV=j)44_R%v(wMR1^2W=tciFXrES059LeI@f
zuPk|M<qOb^eBFOzm#A3no`I+GqqXeV0<4pD%ob6cG5tS)VS)tAP3#po9khlN9@S&C
zpPd>~FCZAsgI!!_d=|3~(AzGJD5Q^AB=8gj6_0t@&ffi{bZ2VtG4T=YGFR@ys$$=T
zF$p$umNvRPX_XtN_D+N3|7_4%7t)C2{{|s@pEuuDsoKR(g~I9Yh7Y87rFoQ5j;P$o
z&eXtp8FWTk0&tCy??V&^U+PsUbl==k%IQwr)H3$qv##2moEGrgu(GLJBQI5qM!Gmo
zZy_$;0=Xa!CB!!7cz;b=|Ni<XFkOC|Fbls8+6TItmPe}<%2IwZl@ywWEtGc}Sc1CV
zW(_T92>HA#FRXexg)<<VLXx~7b9YToQVBwi+1aUwP?RL5YS$;4L4j$2^F_+uPy>C$
zVvnb&N<h0%T6EfQkrQod*)Gf5d%cR4FQ<dIMHPiNvUwKH+iC5W2$wPT(p7D|plHcm
zeu-lm&|ZK(8Jwy3prHTi@+GGC6d&5R@!HJ`Ij)#qP$LOf1W|yBG)zkU*X2Lv6^vMJ
z-c(e?w-5@4<ahG@xOvB)gvV4#PL#yEn@x|?$UB(W;y-D1D~-AYH2SHwd(RrPx$`d@
zG5vpa#{IKcURkBXCcf#kEpQ_%M}H@dFLw$+?&2&6O)50g6p@=~&(ey40(8=jC-6b+
z#}Oa)Tf=rep2B?UQbbvQbE40cKg3g5;9}oZe@R8>xcx30*<l+Nr^$T?n*se(hERE2
zC?~(7eWRwDE9HGj@+qZ#CR%S^T8n=|mX{<D*5Ov)E$hUaA1o1S2{5iGj-n{*)0e&9
z=f$#YEt3JX5Y?r1DD}hg43AiZaTOOYCv;xrLA^dvK|21}qxf{LS8{FB;^O(9rS`Y;
zZ>2ozEAgxqZG+4rwg>vL@viJm2yP|$``R6%qRGzn@c}~-Pu-oF;?Gw&Ozr7Z_t6e0
zo9;XgHsf$S|G_p<|1{`9+Z%0YE%k;xbmoS(B$U3Lbc*sb2gfXf@02B&@jJ+DZf(wk
zHh{)z-GU7om|^9`#XK6H9G76X<3co7Gzz$a2GVvUZ5ANnN@T-2)Rs(f#c(zzuxcxG
z<}Q)#W6^o$?{X@9Uth3cj&sg%3EJ7%YX{lxVBbuPjFM{cj*>3-?68eOMfk;ZI76hh
zp1|pM`a>x&A)B+4TYhiLou?vHY#F9mu;?(-fw~QL0)`zYMCA%K%v-ep%0SmZi%3ho
zM$ztYzV*$<g;0VKL2M+niIKX$7;@SILD};KS^-V1zbmfH8Ioj=7iTmFu(9czzHWKu
z^2+p1c3qpaxte2#2w~G`IbEAMJ5b5w=Mwxad16tcc1^6CnD=TAE{&%Md7|M-_iTO}
zI%uI5AENY`gVu(rUQ(4one=?6^8$ccXfL>dZL)OCqtJ^2hTpz}Xd>%9alrN02_%|b
zyH5VHtvgmVqdeB41?XO0coYok`^D25;4X3>a2FdDZ0eD#pBL`;7j=I=FBrqK{^*P_
z(K^SZ2m27@WQ567yx5IlKfl})pVb%H2%bmGsYYOtjv4~_mfG&s8#zzqUHzl9;^61<
zTft#~rPDFm$)Du`kN2@kG)Zd_er8YgQu3)X-+>8=r;192=eGma*-o$~Y8Q&VwwU}5
z3XEaynUvScLwqG~Ix`&XW7L~8R~u=Gkx{HJMEeC=U*j?fpo{e%reTmhhf~YOxGys+
zU7D`ni56%m?biOVnJ;xY%0xw-P@@@Q{nnEw*Ix7@_PV6$u+^KA2*n#!mnerj%WDjI
zf_D2{qWmm!+#cu<zifZ$;!;_kl2xW3U^^lxxQQ4lT5QIY+GG&lSBRN!zA4t5&#x1-
z)6E#~B6dwagYLdZv;E3dNYT=0ShG9OL2-&mYwo-Y*l+1gc<;UHatrI8&*wgQ=8A80
zxVRFfXOCkT*KS93bV^i~lxcMieG6&K&h}ajAB6~Z*y;I&6cO($iVCas;FhGOw$Dn@
z(GwET80^`56yIKHcG*CB56#z5^e6SR>3PitK2j#%(*a0~g<j&+LbK0{*)fn*=T2TH
zr-J<`=j%={Rq7ITUr;SZC_-2KW@UsPcX8id8fM=mTPfT}?%M%I^#*4!IvN92<WQ*S
zLMLMQ#+R#~iD)GfqdiYve@rS&(#M2~U3}ZJgq+yd+|{ujW7%(BjxF6WOI#fDyt>EJ
z$IV^E@^0KYP3L~h2@465RuJdl{*njfkOtV7Ya`H|lycA-+nvF4b%w*!bKT%2$aZl-
z;nD9=kK-1=i2kD{kiS_8;&R5qtdS-qWkGTztwsQRd4-x8OWCk@vn*E8TMcEk<da)O
z9LfP04r$l66MNi0Kq&_kFum9-p|s}uHy}|1(%29EWHua<ufFVZZir1N5xn^sHTPdQ
zjx+lmbe6K{wCWvnBav-d`=*to`R+h?d`hBTjs)IV<%Ws9ru5%HeRVyEVoCpccC`?|
z;nBO()q23;LFYmyLz15ipJ?&hpc>7bBabC~zJLzhfUI8$az71nTt7A_DUa}m^&AeH
zC@B#L9QMLcKURP~f*KrDQ&wyJ66kv!?mNUH?+y#sa_q>y4S85j{>G339TC=9?2>Am
zNNT@0D%7H>GjiW*SWjB+jBKjY72>C&8F<{%y~rYiKyBYxqcZ``i;y+_FYfI_3<R^=
zF@ATtiu^E{Q^eA}T&Ii9-0o_8sP`^D<4H0-eT0r&x_)S2xaG+KgLm=5AIXuz0>-w9
z+Pv;Ut4sl67iz)>)QS>LMO_Jak$XE$Ty%#PRM)#s%;h?j?mws;+F9alw0+TE<4F>(
z_@Y<kT85j=rTBE1w<N0X1%%NXU-}yq`ar8yp8w>{@Ef%lbZ&G*g#)s-k(*p!0eaPO
z5SN=nLxmD`>-~xX+BY~$CKqTS-~E6}(~-j{W<>Btqh0U#H=9p@Qu)G^f_!~+j0Co+
zJ9o)JmZ&-hb>I2Ub=FJ<Sf_U7w80q#*Cd$s0IHKh=*4}T0m|(mP3y0CU&3vdI1Rsp
znmkws5K#>hsO9vBuB@Of&HQJw($35YWZP2+Ol3m_;%i7~#^<}&ii0mSdX^DyhQyXp
z<6V?!VQ2z9i2+nmPq}%o<SZ4@RYD_!_7lvP?pBmBUAcNoWTOLGi;{lhkOc!n%4^6r
z5k73!u4`pewrw%vX=!@g9L&pM?7W9cL)c`=R^mrAm0W&~<!bQ`8LG>zm3g`|B3lxu
zT0y0mm00ugvQqn?Cy1Is$T5ky?^uW(tOI|Vq;QSQw+1}mrZd%fc0MM2IMDsphx&&>
z*=MVx!{s_bn(2eyd!&F!#c$eXX92zr?INi97Y5_scOd`M{)XmrY!7^u(|mkmXM6`I
z@6mzK5GNmvjfa}So$RcmdS0s|HfQ3D2$;JFBvRn5=Nquq(+8YtyV@f%L)_tEN$Zrz
z=ae|2vUrq#L}vKg#_J!eejT%l{iy_-B<k|4&r~E{^MZP$uO#04lVxDvp0;F#9N4A#
z&uwozE4p8;T}*jx-dS@)VtqmruJ1nm{yXT@;PWDGx|Y@VctFN!`3&A!l>XIdDbyR&
zMUd1j{p7|`^EV=)pLH6@)A>n18<0Kk52F8I1pHV3{!2Z~hS0AS>rd$O&uyl_q~mj2
zl3N0gi;Sm*A*KMa085z;*ak73-lz=Lska?jAfU~SX0_P*01-2Gv)*cb-&vkpQ?)q@
z$gu+->ybs=L*KbQW^kt}$juLnU&~$oZ_#6K82~f})hWk_Davj8eJkl`4_89J>$kQR
z%9l91vWc6;7$FoGh*A%=Pq_ISNj(4E+8g}tugDsBaVn+k^l{O|nCSZRPNg8kx^qc&
z5K6^fSoiD*n;GLXP5Gmo*ux9g|1kGIEf;q0bu!Wgs?uS_gpxslbb)h(45e`q-OusD
zT{ONv8KXvHgQrFfRC;;)E2wDgtX{QKtFzncpJEsB7H3d6mh}IxV?6%o{!F1_7kWg5
z@$D9AgR5Vvlr&nzni~a8XvD)3k?epVwFD5P8Xy3QA}we$V@A$Mj`cz7#Etwpi8*M*
z;VSZx`f@BLYYOZ$cEKo)PNj-Wg#fU4ce)4oWBk3P)>MuM^ZZ$h&F<oowEHaTf`v~6
zank`zJrK~Nbmjsw4^N0V17I)#kjR?40aLKS15+^eWbFBCfD?pRMLHHo6y(sS$@(2c
zOeF&VLwc&;L7;?Cj8+ABZ)YJ9gTIb5sH_{hcU6xG>+S&A!v##i4Cer6vPHm|jJ%6L
zPYN&vduI>d-T*wY2!a3j>&*Y!)9%I`YhVT&Z#Zo_avu|$r>i3)#A?yydCC9Hw(hL=
z2IbPrU(x~f(>AgtgGIulmzGS4%e2|2!@~Mpy<2zGcP`@vW6ZL@jKg&2V*=rggHo@H
z7V}*qn25$EqX_^`S3#a=U+q)`=ABU%S%d=ms$uhDxAhCt^I}Wo%KAP>X0xA5BntBc
z0~;#hg2T`EXb94XT*$*gC5G@;gX?3gQU-Pc<tQ#_wU~cO**!bpDM}kK13wf$Ktvu6
zJ5Qkn&ak5)By%Y80H8Nl=5XXP9f~}>+_&XShr$+qINp;;EB-q1KliA!j<wdib@Zz$
zs-cGR4|f7abyLH)y6F_3;qXe4eV7$t%19zJK2+tzdyW1M@=HOpKf8vslGD3QqNmj=
zl!A_L3%$3#XF2{%M3O1M?MnLMSx<!RnKdOizPF#jdoM)A+Bhk^i4)DOg&J`yp{*0j
zO%Ns&f>7^0{=D>`2q=C{?Kq<_&vT&KWZu@rr*S`jvE->T6l}bt`?QYf<r7%D1214d
ziCWPbC|)@^V#&x{!oL$(<u!f%RX*MsG1b;-%0x7zQH&Ke?q_ukFhjM@ovA$A`gAm{
z{*h4}x1#vBN<czGRWGpPn>opKZCCwS16%}WHmF$@>O==&DFezpVw`9jUvL3<@_g^`
z3X;)jn8&;qIZ|jdIv?M@0d!meaEN;`&|r=Z*T@l(7p$$7w!R#M)W~-2pXfq<y{%tg
z*G9N8DOfH&twdnZikL2tNmT`TpvbnOPakk4LNSrax(gl@&~`y1^&S(w+ijk+Zf=oV
zU&^VMZFPoE7Fta)k$tw@^aB#LoFp@0Ir_{k0%oAA``yD>(Qzjk@Km-xmI~$*^4RJw
zN>rBVI4eKk9mYFFDt$zHVEDE1bG51V)(N7-!-Ms&W#)g((t7`RFJgUll$o-hY8Bd{
zk&`1OdTv72N09_J!?;Jg0hrVO15wNQ9!mgklSG&9JAili7RNX{-SALT)9-881|9Af
zQ|GFxKKV#1t=6(u_(X0N@pGZx|LRQAIkY+N<f8t~uA&jWb3^P=#1U*>U)Ac7tQh|l
z{dg&mM(?Dn`;7sblZ=AO)MkRrAZW~y#PQE-)cNzh;W3*0hS2X>gugmpk=nKBGXPXn
zpUrr}5g3Jn1+(B4A%<27WNWiKVWtS>)I~JlYP_!&T-e6=(I5RZg8Rc_$oO@zFQ-S<
z)}3GWXi=GOO54&G7aW8yeAeX#h*GR%>q%s{53Mh_Apl$HhuvDC0~<dPb&50mu$SA9
zlKSJvj@|x`WR8a?(K7h+VfVT&q?=s&C8T`ATHu`L0-E$9<juX={o&;+xq)m}bQ#7E
zB(KomGxp&aDE4t}=-n7pDstZ(<hj}{kd@zxb+80<lan7yeBcNe<7DXG-L$nOVn+QQ
z)pFa#qHw}3+-lq(@-Ti^3jKAf{*Sz_jpM_cc&7H9-rKB>SY!Ko-p|j-de}1pY~4=)
zM*|OigV4UHr^>=KXpok&dC^B7s8E08*qwL~dXHS3VS|#Myvf0avXQhvl7m1-KPbic
zEJp2bx#~gL>Q4pF|FIg*pCqrRw`<_M(ZV6jt&~GZc@YM#TiL$s0Z<%sfh`x%h|#s_
zc)a{yc<)Trg0xfb+Pjs~p0c3nctg%neQek?DF3q}AwjAO@(0^r2CiX+OCMwmJGw5I
zva^LJ$IOad{?i>G|A7M6uLZDUqxwIa)NsoZpAVaS8lw-??Trvh^A=h-k6Bo#T_m4V
z6>+M|9S(bWBk}=J7$E8fWu`1R4tIo^We(LWx@KsYcNUVYt!Q#~)-b+9Z5HRk7!7Z0
z$#1p`fSW9?bP(h=vyrdpd;fjU_4EDKKWg6ikBy9j)tlpJuCHEkwB*@`vtWPhX*zE;
zo^caK%y|g<pJfQDHSBx0rx6}!{2f#_b4GNr3y0**%crMWS*z9hi#}RGWvhC*sT``m
zaFKWq`Q8v+jKUaYe(9WSvsaKS%raLkNwiJK&Bh|IL9b?O06?hd*vWqVn*Qi3<>}EJ
zfdRW=-Db9@u;E*0)=dtYeE|LH>6senGIMf@nNAtVYOewQH)hh-fd5T9po1S5@xZP8
zur^KwU>)4k)nrZct3#t_Qx?qfWo`vXVi!@6H@MYAzs<ZyXt}u+N3!QXzY)!UOe=pD
z!^Ug^*rPebGqo^sRrD2o%+_&zP3S9^%uztb6N<kv5wL0bf0JdC23Tl-E<R_&d%+;l
zBv!^9-~q0{z*DrwhCeqr4&Hnf@S#Z@N3Iia)mae-Js>$IcIzEdw9esLrn&vvP?OoQ
zwcU>CHz4Dm#W8<bv~xz?`7C&yqa~v*7vpMvboToo_An0RYU;_Gk+pey-hR=f$^`oE
z-1FBiRCQluO6=~}(1aQQWL7sR(W=1&+sj=b3K=i2I{H}$kd?Al2^u=x6#WDuTHX~T
zuG0uw!<&2pVYpdaYpe77hL8V&HsKs~$ja_p{P;UQ$8Tc-xM;veYKnv3J7X?E&<nD6
z_uH;m5{3J&oZ<lcAoPs*7T<Vsj{h&__t$UXyYyQ@Af^39m59UW@%G?FREtuX(CHRG
z2LL^WdDuPV5!L6xW@3GKLbuHEO8+An{F4(wN=a=6x%EJw9<~tS)#Nq{kGWekodhM8
z3S2g-@+Eq5-79yDI?b{39vHwEZ7#=vv?;HJa&U8RbG7`{D-vcBnK>AJ7t0`!x?R0N
zg9QAas&Y={i?m}Fd(+(K@GK7}iHCpw$C;Ubx8l)vMZlY`pylrkQqA-hZ_rxJFO?F1
zB6V;5;10kUc+E8o1{4^1r5>*lk+7B02tmLJw{-})hJ!Kn6qw7ktE*wLA;;WqQF`^L
zis)fwP!L5t=^(!2%mJPu^Y_*0&)Rp<=wIwY?8#3eB&EyiLYB!Hr*6Kh$Oe?Kdz`G3
z9hJ5S%w3Aw)_(hW+WLLD83m>fayvl+(|RV(ONnSXH(fc8Z?C6bRh3{D^zR6YjYNdn
zi8K2AN+&&{UHg~18vZS$+R*eaUn(?4am`t3)(G0KpK#n-0vNU00lD>yyMkE-`*|Pg
ztVhs;^D(KDpEokrBlTR&O=`x5%*Fp7d+!+*Rhq307lI(M2$G|MqC`P*79@#81thD0
zfLH{{P*7wf3o0l%h$I2Y86<<`Sdu9~a;PE}P?X=cr{`R)_MGW{XU==QbH4snk<H$_
zp0%D8?seb9m6Z?V7|QhcQfV3*E{w2Xz1)Ug!!j=7)N3-kA0G<;W9hMfmq$-USVg*g
z1yOxtg7PWwES<bpO|x?0=4YvP(>xq0oU!_cb*yu4n3uAQFgQ?_$Tanpp8xGS{Qt}I
zpExSKES*xWA(dhl!nwWF?`wWB>a^6ntR5oPA;kcK|6{E=?!3w%fSt!*Y9sOtpXVG2
z(U;#!@BRti@;?#!{F$ir+wWO-*vbkFAE^&X$v5%_mu22+ln$)F@3cMY^jSY$k2V4-
z1&l4Fq`ws)=0H87#V+RWvipz_AmkX!^o8g6$s0qV7p%OV63uob+J5do%Neohp!_5z
zHJy6s7oEEQhAH9St4a55EBrn_9ku(xZT>n@_CxZ;;spqgwQ-^zp4^tboH&24cfTlO
znyocYdfZ`jMYkQJHpFL-;XTdD2BQ;JhWRod$t{*aOHP7~BizIa!xct1%TI|q^vcBj
zx2RuvELuDTSBVp>$}#+(My3Dg?*L4L{J>=tIFRo_=_MC#J)>>{(|jqbrwda%jYzIF
z>ogL3!gVA%vw6a`^c={zm3{z*8^sL6$Mc~sHT6P7qqBT2uA9=@$93H4E665m3T+*X
z&V1kt^tS&d-};^U&^j<#2XqQKT3XHamu83l>;%jCKLkga1!TZ!Q1PdMz;>t@wwJeS
z_QM;0tb}-79k~^mIc;oWQ)5|B(AL#6q(G<ld|4_69&4*n)lYy?EJj6D=dbEj=##6y
z6B%dGc`MtaAHn(<w6XFBN|b-3jQOAR9d4@D2EKv13$~<vwcZCRk6?TvJ1OeD5ew(u
z?iJLaWG6JSiV#L@qY*%aD1@_l?bC}Era_UFMXgVc5&nYQFMqo(e(XsbL-|l-9|=#c
zu6bEl?e&73YJRI3tWRwYTX4*tJh!JVkV(NeWcQ5YzInOkY5GFZG0rLsP4kVR2k7)+
z2T<@+&|V{k7$DL)2#IQ3ApoT7<^aA|qF-8lCkh>Ad$>biK}a5;Dabm(A^~*IS>k~?
zpl?Jy-}-%<U}o3=SPf`tmjd&O*6!<AUr#ga*>4;_-x_{pQotT4Ck+6J&j1`ifBpY|
z>;2FCQOO+D7)<rJ6sitS)Gha)amrSxe(=JbReZ9)QTCPBrJvA79-HyN5ExD2d(EzQ
z=oEGrf{f{QS$Bey?qGmS1mFqbR;nJsT!Gg(d<BITzTjFDxk={M(PaiLRFX{6!}`6S
zbPtg$9^C|Q*&z(>{-%qi1nhPH4NS@a9v)4$_UIaMxT>qaJLiKocW~e~^Z{#-&`9x+
z&?@96o6?T)t4AzvUDLoye=V{9XcPM(Oz8WqhbZ9x$Ey|Ob?JxL;amPgV7R+|2G%A#
zAL-U42(3WL9>m3gHA`>#Sg>>+u||55I<Qh^yioCGZy(EPH=%@@a79^^z4-FnYk@6V
zLmlL{cjrQ!<TLXGPW>=NvIsz4mLBiUFS8E+&Iu&kAatswBUy~)eB`f#5%YdyDxSAf
z<&#nmZA(7XR|2}Xw(F{Rafbpt#bSW&Ex_n}M~y+9s*Q^vawMOd#2>6>>yNf)U#Vp1
z_vbT?A6(w$=>{4OItDVes%*y&S8yA@<wrk+5z*+pzcz)xHl_DJa{q9luV31WPvL{e
zpG!}gO?Qbr1kISSvEDY{Ez<pC#0)<qs`c|#u(MFHkfs`JX<kRJ^zh>+_u2;nDKKp{
zi$Let?H`5J|C`^ZUN)nxBg{kZDh_Y#y@9aD&dhyU`Z9ilQDuS1qewBsm;1Ba*n~@Y
z?Q_#BuNavHLDW6JrDp%vMlAkFKN0v2*Y~6!p2>ee?%dRC4u*aQH7P{%VvX+4PI%sv
zmI?*;1&o`0BaGGkh*9%5x$2zCV8||X{H+bC-4hoJEh+jY^4%naGpnuLB&9Ec>L-35
zb1Qvt1o=tn25XS&zfAV~XOe(F-&y&#PN~msCNTs>w!Ip82+XfdT-ExuV*zlqakema
zZI*QdA+lK~z~0*eXSJM~wy2a9;@{)$z~I*cz$t1V%jHE8+(a2dEA-JrF6^J}#Df*~
z><ITh{*U0PPdYxL?OP3Lqu3cARJ=Hmy~AGrK08>Z6D<quiP~e%`4Bh7`k^9Pkwb?v
z{xuxB&O>J9Az%J8=Q_pl!xm)d*D6JQ=pmds_CVVGLL}KGrJytr=FlDGH3zqnJNq9D
zqQ3inKayWN#hS;3TQWCIEKZD5-}<Pd2d8s+tnja)kYA7hkv@a^m3pT1gEM1G*7QYm
zROf?K8NpdzyzU*F^bkiEL?kn0E)FP8sYDV}>;R3H{rW3$gBu2+9Fy&;(pZ4u^0##C
zgEnlD46WohXi$r+hu;m3{E>c3W|pl8!*u@CD*TMQjsn#+ovH^BQF8m#o^=5qSuTt`
z*|V*eR32Cw*}{%<l(1e?WO^*`7bo2}+y?SIrS3tSware#;}cw#QZJ|Gj?Z=5ZC2es
zB*2~AWqw=$kL0&=@v0YXNnlEN8wV+wf0X<%l5v1)1nDio0NS`xsCfewad^C#z*6+K
z>)m5D)`Vvklsw@Z03zGi!Q<Vmdo$L=Ze10LeRiBQ=1wbEwtn96#Uv*H@5cRx?(RXm
zwH4&Axfv>A6ZsPJCfVHlro=24UOj;4U{2ubKowt~-fICK(kgmPof0m+ly0XbAJYkn
z=dOz5cmV2LPAS6~A2en%qp&J(NW48(#+YcLbw%W0pelY7F9~#R&f9~D_4eI^2GNoG
z@b`PYu$Jw2-qjV8w>T;Nr~N)2;-Z+e2y7Ldd@i7@2lt5~T-}=SI-_=X>s$vv$kC?0
zdA-NP+PU|>bRqJN+6XT%Mil`c-rRai(c#4W=~G?@oOJ=s0NUbumz_Jlatw`!@1BEX
zv>y?@h<Hu_q8bTnMrlSMkmdV9bz@I8_{QW(AiHPM9>_1ms^XSA$#9MBL(CCN)u*}X
zYFS50VE!KOnfro88U(kU_S3*>!FQ|t#WNs-o#~_XH|WnFf8mGTfgt+HR<C}Mo<41*
zxKy8{y!?EV)fntKI8vub6NDJdTfcVt28mM{iD{qlWD}#8%{HAHz#pY<Q3a;r3;`_<
z8#8yAdEV=c35wNvuc%Ji1XBCy3ZoWUYfKu0`x=I~KJ2uHeG-3y1hG^vu$1BCsc5OL
zi02vV6+I{zC+?M))3m#n<B;XS?9Rrp7~g(8Sd1O6K_>SYUgz5`<5?Txf<ZeX78-}^
z`I|M5D1ho*QK;<eG_ti{Yw|=tkad`5n;Lx2fxqVbQ(5k=sOxjHaZM{HIzY)~;_7c&
z;J}7by|H(y&@4JcQ;$6D7=H!O;%@$p7MB%CVKVKp9S-RBqP9ZjM~<FspBr+y{+T<e
z?ZUAr-Z42)Q~cNZZs(n+AGX{x3V7gfnP%s;Wphk<hju4manVf^r~835UxHs`s^`u$
zWb$O)^cPz&^({>iR1sqt9Y@=@gWo@{G?dAF*Y$2KuB$%Xij3ZUk+szam|4!vsAg7Z
z*H<r?vc|Fwz8$qIa6AaP&ZFI`3F*ki)E;YRy7w(Dv=XPSdrBpkreCDLz+xT40itwJ
z{vcCN`VFVbndjbsav3i(Ay)F%*qK%^7I>}5WUxq*l8reYNdSjujkvriQ`c8}aeI_K
zx|c%8Uopm8Hw2g~GLzCG02~`I73?^X9n~8W%2&qdebK9X<mNRFO>9|7u=v6kkc-sl
zO?0^9gB+RUc~boO_Wew-{dvC2yIo>L0#m6wS8(exssd4cS(fh&3~gtaU#M3$JXgk>
zM_AxQ%Y9~YVb#1fisB4g7$}7B@NQ&{2us!-(G-(c<5o+Dm~{f0p^AzQl`ImYdj^}6
ztv(E1j8~JC4_+7QX$2npVWp!DM^R=GY{<6>unAsM>#gyT5)mQ@2r1Adevn4meR5*L
z*KRa9ep3%cQu|y3-*Lc6$8f5}%Z7BccH7^2Ol20&PDc<d(_Xi00xySHH8C8o$*?A>
zMY1VHet~XxM+x|Kb_f^HhHgp;&q))hzRIpiXveE8kKXQ?F+@t&ui%zs6c-Bb57mjd
zc-w)CsZDy%bS+)u%n0y{`w9}@Hb$X}p6T_UsAHHNgz9U%!(Z*n!@M3{A5I0-<VLAu
zQ#ghek+TPA0A?NP9^S(rr3|Us@2A@@v;#A(-vNyCaWtXvSJ1-+w-nAheEr);-YOlk
zW4;o--1k0=Z7x;~7viCmFND6nYJ9DU{kgQFX(0iE@qG$ygUc5q?U&K-MhcJr*1-Ou
zcJRkq4ByHG^ek5g?xSRbg-IEpXKMm8im?Q11?X!8$oKsr346x?uP|idggbX!(!ea!
z1)w%El35PM*ya^UvjQDX6ZS2el&j&g8(E7AdsC@zz6U%0y9x!k{Vw(ZfSlXrxavq~
zn<8y^>y+jT{sZ%^maBj&)M1p=H$rOVK>NMUzV3_^$a~+px1DYm2rAjY=|b-8t!BuV
z?n*6p9812u=&t!Dt(shTZnKkfMG@pI{IAV!Q%svHxr*u1b57*0dX`6(Kdh{Ap7(OS
zq!7d%D}j^~mR`nqXaalU<dObMG;XVBR%6h`;XRWxkXzOkt_e!79!3g2#a|d%sH_Kh
zexdGj*KZ4**DRmxwY(ISZh_$AeJehhv_ppP$ugRR6&?|0Jju5wwFc*QJYEvFGetaz
zc37j8w#F^XsJ16X*Y8K_tt*c>cL`1Fj7zl#B}tT^I;A|L`wR4|P;prvc{BIWZZ{w*
z2D0%|+YTSn97mNrfdQ%lkgJfsIHHI;(sgO4d8yq*_D(5#Uqwv7eU?C$1&nfm^EdD8
zD2T>-2uCU?4VPWrc40J#unxUK^hu&tfKEHf6BzQE2%Fo)vfr-MXE04qGf^l=Kf`z>
zNp+d3pELqQz_BBsS2oKq%Sv%0V|{{g^~Lm6ku6Tj{DopR^U9qxvQJ@4!n3p@$@v`_
ztDY7$@A6Pb!RMb}Y;Snqk$tpJtpsLV6Y(5PNu1}!*_*9sjK^D*_!JZkVsc)LItAQ^
z?OhiW)0Uehq6v{7{im+!d{KMq>3|~~G;hz?fvA5tsR5BO%B~8m^SJ}<Il7?5NA}dQ
z_i2O3=)SZWVsmmWfhWN@X1X;m>ZCHNnu!RsFQ))fR_Nt*N;nLg8&FJ666uHKPD98I
zT0cKxo#9LZ!;l>J#_CiFLY!5$_r=2c(25m7m8B}MAPsz<sx;CX?%??LiLGR!*)=R>
z3j8*QU7X~rn0bQQ%h!+QYnbn}PT0LdY;RUS+U2FE&JftKm_C$0NdS!|+^zIi&4LuS
zXN}i`=!MO0k8JEm%1Evg296CaTllH;5fb?0tdTm3Vg<&&f{OX<T=<EM4Q*aDe=2>y
zw#_mp$MYJGO!*zR8X^SqqWAhbKOh$iTK{_|>E8q>U6duPV=qL*+Ech1MxB={D(apm
zdeD!Au$Z&79<Ud9?*Fk4+pqAPpSJz~-1j};ZQIOi4Y-5OC%u=sRXM7v1jMS9?&A-+
zw~$%m4%&X#wyd!woLJVVsB*yVrmQu8r-EOd8Ya7QTS^g-0EGa9Es5XLMC7fe?hus%
zs9i#!pA_~h7{fu9kU}|_|20l^IiaAp&)ve~4|Uv#GGxOW;aKDHkFkjCsjf<TkU2fT
z=-<CO1${D#n!T+96U!r&G=kSDxcJOaeHeQ0ys|}N@A5R;xlbaAA4=}Q+#x(-god!8
zlHt#Sx@oH_XqHHmuAJ3yN<HwF9OLmhJ0euOo+~9iuUgh^luHt8#Ax~YjOXT*JEnBI
z4fJ3_A$Jn<aF~5`|4LC|L-S&p_PH^E&}*-my`Os9Ds8t^#-amsMxl)JlJ0gXa{Le@
zFzf5<aQde8CVB#?vB+rO2Om((DOEMeBk&l46NM@0($kO8+La(AL0Z;`6qW43XnR50
zx|5BlsPPn6>!m1#^|F}$<&ooovu0p){JrQlg%&Kw@McD192JMC$TWv`N@L94>QHUM
zl924VuOQ2{l68rcY?18TI-h$fy61|sGjdk3-s;XNPhh))vfJr$;6j3yoa}jcn6Y1#
zB00h5yyYXJEzD<N5H$lfD_`uqO_~)FCamsYTv~pd@jC4O<pBcYU7!uUX+Yf|Y<<&L
zWq2wY6Rw7$!YZ&(NPh*D17H<-!xg?dk$4$_5)@&zrI(SbuR>{X-xhF7>m_y20WCH~
zCac%WyXBovvZ_FrHy6nr;ZZMfLJQX6MGLGOW@M{zf@_0K4PM>Few0j(G5s!>4(e|7
z@nq}sRZnQmR)LkE@ZJMn$b$)-7U*QOlyk?4?!>weY3zxKx|8Z?*3kY1*0>!Wc_8E)
ziP=0N6MKKEhUiI{uJSf&rFC;#``9KPs(X=sk>~zG%CdA2NO3`IO!JuxsUH0q8%ESw
zl~YA)C_rBp>y>*75NQnN8cGxe$LqqKz4g>GqTj_q{AD<JqkSa2Mgc-U+j;3T%eOpw
zh-G>@X&o8wiE1|cO2O5l4x47!2KReCRknFuxLpFLUIBur@^TY68zKwCkuymf7+tEm
z6h;a)Cdb6>{aBKW%I>lcTQY};gbiU<u;E$?gT$ple%jdLP=Qaca7m<_=<^hs$xYl9
zrDXF>r1!KVlx3!)UZ1>u>cM<{wGCuBwdx~jYoNDaHUy0gRIQoBwF5+SUv=3gxE+`^
zC(Dex5PO~69BGjnE2tJBA7?#;ubUX5sSK;iuzl62$i<omjD{3;>Eo~(i$2YTBYhR9
za8@emSI~X$*D$LiAJd*)xOjh|M}Gmx`WB=&@eL89IsFtY<dJL~cLZ838hvA!S!VFE
ztbiKWx173?;mHhFeY_$o|F~3^z6BQXLcCpUb$F-}%8eL7HiXqYaU*reQ1bpFvcDOT
z0Gj+eJn(ynvwki-?#F`UPaVo{r8o<8>WzR_EImMZ9f4OHnD$U+!9@>4hl|$JZz=Hf
zc5A-oUCVy=gKKf4ya$!?POMKRDH^VC>Inm;YHPq#!%}z1z=t|J7mn>Tdj<$>3SgZC
z+CWBUBfCdssyb(OL{SDiJ}}&`|A$1^1PXtrV#Gx@o#%XJj8nB1d&WCNbIHaiIx;`%
z*i80turQ>>lu?uH(s5R|=0WYdDslB%)lGN;ICucv3spRbo8k58UwpDa-{+LND#tY1
zP+hQ|FqR7r+&kqPn<1>L4WG=CeCL?rQ17+hZ#w?IGC;2aU4$4Na}l$*GrUT7?g7Pn
zweogp4Hc<`6|;|rV-n?GwnH!qd~xy7OX@fk2Jw!IF;%FM;WRXiiD5suVxoNHIFQWL
z!wRPksU+g}oE#^~96sTDb<Kylsum@U%|-B2DA?vAbPhg0U#+EMtXbIFV>?{c7_3t*
zG;}YVlt)Pi<<!(fM%I6+L<Ql^VU>qh`)n0-k;bL#v9^YM#Ud}f1%r~_KD-&vOsJzQ
zbjsMYY5D#u2(oruHc|LC=Ji6{O^Ua-JU6w6a{<;h7oj^+fA=}jBC<y-sfPn;WK_2m
z?IS&h$q7xw1vasT(UcjLZDvGvAWUp(Cna}!IdZ}X-G10Azxt-IU<{Y6?>uSUvefD9
zSfp}`O^$n}+E{Nl`#tWQXO|VW@Lc+tt#MPoK_*xXDYj4ZX?Gr%&P#i)O6l8XS{s@q
z_mw;lWK2xo`Iv-?=`T{4ZLl?Oonh3ZykW^WRmN&rW8^DuH+7dq;$&2o++Did<l(Hr
zaJjg1ug>|M)-Jjj6OXxEc4>8xqbvn4RGT&kv+1N)>~83+TV5W3lZdzMxa>=6=Z>N=
zfi+!O;IePOvAwIT2gq?c*;d%q%s#U#vTMf^JW^wF*b%&G+r&X)C0v?^Hhv5@q;9Q@
zD9XBZX<l~!E#z=v>tsLeT*C!eXHfoE5d6YdP&(1>G#?{SZ8mXtYh&on+6?L~G1{6;
zEl$_|vVg^1#SW}J^)@maqBR*P+-rZ`TuF2ua8#x@R?&CW5$gt+tE?egp$XHxI#UhT
zG)6(!_QXL01nekCf(fyz_2LbH0>n_^)6;Alnal!fX3>r|vQ015$tWjCyDZm0DH6)w
ztlUzQHM~aC@+C?>k(oAcZgB^!u-b787(@!BGCW~Du*Y21PaXGi^^mnPyKZ#|?OCQ<
z7@qJIm)2DC=0=<yt#8P-%~3c_D;$~-S=5#E0rrnGO&CSb{WpGPXc9)BzK1%mS1Xx(
z=<-Bn7=|{X;-~&`i1#Fx^mL0Ap0VCeeYQy<A0;Aamer%%+`2Pa<2M>~w#QEgFFz$f
zptbN|gmpz|rF}3bi~hmOT7lE)+~}d&iDqPW@Iz!_qI3jR*<hE$u)jXzQ_$qdGNb3%
z<}Y66PcW<e*k1V}bJ6<x`V2+Vy~W3Ie3fHlnXeLLUz<-w6fKyToX3elczc4W(B_(B
z5G3Uq`9>z1HIsktV{~)*dOwu&7d7Dhe!|9XOYdZ(+swY^p_!~oi{RS;mFph@Vf~rj
z2Y0`7G>~O-tx1S~%QArqYKLXD>E#<+N-Xt6RgIxFy1nq=JNm==5``gxYa&%^lQPHN
z^iCa6BG4xH_wgMmqizLU$cXn>Wo6DByl=|NvbUD8znL5Q=O{}B55PWw6#y5(0(ig6
zie_iz<v?XSR9jBbE8OLAvLdw6Vl!Dzs|lUR%8=m}1}4vk#=^~+r5-^dFJ7d)5yI(3
zd&kL!HSj#Tprt@X^%aC;7@#yJr8+NG$ce0vdXcqi>crJ0!Mt;=-RLnYC0Tji(L^yi
zII{$$lv{9`*6D(G)B4u^D_Y-ToMK)n!d&Yeb((<r&<&v@<LV0AyYV)%(~qQl%#uMC
z*5tF3nENTbnp$e>#o5pu4*6@<T=H|CWY~Rcw3D{U9qmymig~sBrG17=qexV!XUuc3
z)Uo5b5rd{5+aN}jrW`-riKm?=YN7vV!u3gPTWQm3yX0Mc8G@S1QM+<5*ml^4*L89^
zq|3nk(LN|93R`cDlR}H)%NBjM<;)Dz@SnY-0!0WnPQP+z+TUkBb*G+yivk>mM9LXv
z#%u94ffG^L4(S{<ug^B4nu{KM-2SYuu+;GtBu#}qJ`XycgOZ0qT^97&muLliy+dEf
zcIvzR@-gl1dkAfdO{T3xUq&VG)sZg-MCUu=Bd4sSPPc);Z#v9J^o(5R(2h)X8-FBh
z(F+N{!LmbP2g%N|$jEHWWf(HXJFD_Eegmu2Cy=x(j(uq>!>Dd<G+2JQ+B)%eOp+3n
z%%jaZD=F^@P}7LZ=B@R1QA5pOp<bz3qgI(wnCm$Z6L}*)XJwH_lD_2px;?qknh&G5
zn{Ig(e@=G1y*=6JZNV><ESg%}MWax9sTsBx#)B?zoby+obD#rn#p3uKs^WgwU%k66
z!`$%p;4uDpf3z=`r0e2T-TjL}%a7a7fv5ri&mgg9%h}FKk{{s*;r6*;!M;z;-`03U
z@fO(ppM3=t*v+6J{8A?G(7sb8^)EH)LLMn>kz7wg9X8%_3&ThNq-~7qUU8N9ir#C9
zHLmS|LTbV-Q+NLMibI);agxRFTd6j`z(%@Hdk#zkKD0~RAMFoSbH#EZGbVePc&uPt
zs`^(-EU&3x@=H<RkOHW3y6QU<N*quJ8@)i)N(*N1a_%%*iB!KCX$|bv@tPnOlg}ox
zSDEm)`^03*aKdwKWJKa`*G8SRGRRLz@s-k4emr+$`bCsjuT#zR^I<4Gg3-plVEf6%
zk&riz#CDM{ODXz4Ovw_hK0;nDhS~AB$kLe_uh!Z5-M{OGTPmX}8)chWj~t8lM$B$p
z<!%0)ho`9E|9a)d{vl@NOnc=b5Dc!#T6erSu#xK7n=D(Z{t60a-O&{4f8Tg4yq1Hc
z$&$_)F2d-0IAvY=Sg|8tiZgJ1nS)FWt2>CcRWKv7rkT*uu(~HYFJG%V)mGypgj4Wq
z*o5mt4eK;&H#?v*JEh?s%J2RD_1`eDzXpl_u)bErj8>kHv^PdohV$%8-}1`$Qa$G{
zey-KL=RwEZSug6pCP9B05cz4;^Wak}ia*eqpLU`JQuz6_kj|_p5(<yDHK+e{P5R0i
zEI{_cW&}Py1h|N9Q1^X@NiY`RAnzbis}LLEidY5#fcoE#i2id||691n4KGXkobhfe
zH}bd{-H8=d#t?+@A%?q%5H`TTe}euB!sxo3*CGI5qD1S>W_$SISgb4{TVf)HbN31z
z=)TV2KOKYlqpY?+EwDoUd6oc~Mg(zC@uxLcjmiqLdOi2PFCEoiU<_+HX=IODOaod0
zZJox7`yY++30$=?;Id$VAcZx^W7!Y3s5JN$v_5WAG`|T(9275r$z~o?05o#b`DXWc
zSnGEdUs7;z@VR1I*qH7+%_RR<x&d0T{s9op#hq_$54l`k1yHqLh`PzSeU*-VC)YZS
z%nVBn4{Tf^r9H*Kuw2n-eN#%HXd+~Gi24db=dE2y!&judL8QpA8F`*7T2Acz@%Man
zXMSy3{nz6UNd5nYdj7u#oc=!F13VHCq9lgAOhj7R;wa)9koz4IVMPYK{oR7zM7zLl
zTsYLXMJnGuvom(%Qhlo}kA{TcH{Rde%fXV*IQ%UD+#Mj`d%=&64Niz0vk`ickLKDO
ze>cb{J7^FsXsEiY<c*32XP@zvT>CNV`d44e<KR&|_Y44Jay<@x36aasglBO-Ia0q*
zwI9aWw!PY=y%8OQ9!vdgGdme|QFM^6%${-bD(_p(FEc?*^>4FnPhDfrVbsmgi5Jz8
zMP_j#WYHD|1{yaA=q`S*lA2fe=C`^pKUM~D^tFczgl!3*6s1!csYRk<<;2*cQs(r)
zKbwVMDj0f|F~2aH+>$L|NtOV6T$ljh|Ne=~#AzgIT;yHgKOro_hEuQVE`9&{?vE$*
zyRUU^ArkF<2A9f9fKo1OOiG(8{`k3gzHk$oab6R1+2_L8Ug}0_@mJ6z0W;A}8LPzI
zSF2^_?>rMg+kYld{onFk?j%%5<X$xHxY6`FK8$N#fzm@@TfE(4QD6BdjgyQSi|WcS
z_uZ14WYy~c-2c@-g!@ajdtT}fm153aIe4K+a_Dem%aOLp6tT<%;Qk#Ae~bIqd%^-j
zVQ5gT4VMO+GlFn8p19*ub7I&U$zdy&fTuzdHns!OCU;?ov*>`YAcb!fbiV3XAy_jp
ziU1pI!U|B&C1R}4>{Baa$<3b0?g_2{P6lswLHVy^{72jm)*o;PF3U6Lkebhgz|@Z=
z+RJl4&v+M(vYnZ^EKgK%gYD!|J^pvI!oOuKk#Rw{AYmJ<)+o_nV0v~?Ja*@k05-om
zhTza!*)B6G5qrh~dv>t%D<}ozb2IFKRAWMI`tr^g?cF$Q7NJM<L~SZ~Cr+m7Z=r&y
zvFNvxs|Pa|2Z!kN9~X@q6!&?i)LY{|4Fjq*=lEM$kLjIZm^1dM%<mVS9BodXEYcry
z1E_+;13;XQm%oA-WPez?IG%qU<^TQr@<Y&Z{rex<u;IU3q`uPlKgKY>eO)&^&zEjH
zH%sFVYgZR!>$W*W1~V>I+P@Yo()-*Z<r%hDgTQiNM2k@evG{tkdX;w$jNbc5vW{x5
zj=16B8a0{nm!lf|UA!bc*aG_9buY11e)3Fm5IiTgRKv9s?MI`3%o(y@Pkgu1%d4AL
zB|h>5Kk}M#j-)D{ORs1B@0P588~Xm)=XxVN1^c`rOYNJulg6!sx3X(KG@X({cXKc*
zWgpOvusQBH+fAiut75e(6T{2FQm<znI5~W2S*GS2A`<AfF2vGj8eELIB_Y;n$&N=c
zrQZXik|EPXY?|^a$m6Y4I`OC{r52YaL8m`CHEj+YaNrI*_aB`FQhYexH?C*H_n)P3
z7SOy4p-{EVAVngA&!3U_T$<<`K5W3p-GIT)QNbcXrWrW^pXqm-22c;Aod=(i)W~9S
zM9~9h*SMm;-!y<W!e0mZ&$%bYKMWESaw4_^U80F)%K3_6Hg0_B4yE{&@@eG23@#Fr
zU-5r9N>B|Z#7GWdSPLH4WJQiH4nJ0}(M^7thiPjtz9Ov&9Uw6KP4e-33CaJ;_l#-V
zWI-lSxgnk>1@`G>wl+OkSvnv6-<n4kxRs4L--x%=-g1<qFpz^h;oTe$pv$<+;r6jj
z6JYlGPsJMyG7vJzg)#e*d|vcRBEfR*X8(yf{6Fkt$JtfQtrr!Y9|Y^s<9SkO0E6uR
zYF_zA{=RdlPCLUkK3>oBQP$bfw)9q1yN0<qdul5KyodnJ{1tQw+&;TM@)fiKPXoLE
zlf3Sq<$eE=pBGV`0(IF%y}`!y{l-09({WP+RDW|#e;8CaTRCG~cxvp>YcY}zf8uUL
zL`;g~(Evf_D(lYK4?r!~{VQmXLZAD3i~lB6;B8?#>nl$l1T9d6aa9j+z>opbk&(IX
zaE<a0_V_ld9^AFzzAKE6=OAm!fOD}|bXUe)Vr2sEym0^)1Js{rO+%6E+Nik9Y}3Yw
z_mq8KE}c1hlek)-Yc6FEfM^>uuqA3&BDXR{V#pJ9)ZA>XJ3DPaM@nMbro!J4dmXaJ
zw7^E$2=G_64G`20nrhC~yUiDDhiz<P)HB*3Z?C~*bVKhJQiSc$eFf1B4%I*OCE{+!
zD9*D+h+x@AE)15@JsQ?=HL@Y$Qd3SLbBh`Ust7+HS8GD3-xAlDZ@lNR1xsWU%n;GQ
zzSbZ;Y$t@8>lKvjoMxJej}RF;H#r(o56nI42f~`QQT^DUPTB3|uOO7mYAU#>?oN)o
zr$L>WMO?zOYD<;TGXX54O&>X{?LYZS)Ns?b!6kaLgNm||`!!RKJM$p(mUseF*PGZY
zyx=k4AI%wOYfnEOO>Brxgw1Pmwk1gEC0NBS_uPA>fxRY3cLL7=(75h#+4Gu_0*~P_
zpV2-9r3TaYoz5f=21{zr?zQQM0~IzVk{s5S=XgA#tQS0Cv%oRSv`y_%RQJ%~*|vIv
z?vl5ncG?PBZf(;&QLV1}5&|j1Sv~*Lb*(iJ)S^fagXU7(X!33I;vG3|rORn`*n?6&
zZ_6=L1AxT&-Bvvr+5{M}VZm4)GoGVh@LAQPDh}5oZXkfkTu417eh!-r0!WhprPh@q
zF|^xzsN#rAcn-!qOWDez;w0TUg3n?~3=#bVo(a%yxZgpiE<B6zcYk`OTI{rW?<=Tb
zt?w0ZrIc$2+Oue%a~m`6V{YVECg~qkoqh$~9w4aDR`hU-7H$k3W8t`l)>IB#zrCXs
z%5cfNF}dYZ2%sPuNsVAdzJxjfS<h4O39=Dm;<+7I=#tn-d{1+p*rjsRgs>`9A4g*$
z3P-wl##bb#P;;L2Fs$q=2;3qX$P>G*Ey`8I$aeqY#JCuT8}Si5;dg#69OQy7YAH)5
zL(1x%@}p<Pr?1~WaHBMGQ<B|)JGu{Fifl3BTOAV-D9ShYI~u_Ic?D%7`pGf(t5Gbe
zWTj~>WUqJgraCWZ>0a;Z+m&PKQlws-xejmOHgGRFm~AoS(U*|-@VQw)S^Oj;Zt(;5
zVoMgtv-hX#^b+wC$#g_)N<d66&}1B}zy<t#OQ;!xWvbIi8MwpI;W_ATjp2>drV2t2
zhn)|}Cb*E>4j%0F9?L%%u^h{`qN6OC3qQkS5x30+X=$D%)$>Mya<u^GI^lNM>VB8~
z91@!;5>Fnl4d~U42?{c3y-n+=ZUdQR)UjhJqoZJZd_dai1CY;!7xWX@&eHHp>6_cn
zOH(p>U+6x~&<(nwUHms2o*BVech)wQoVO>3nwF#Z((yym6=dRKV;~oTR4q1~>a+-o
zwM_wk^t~0sD{ZzNFDE`ed`7vNt{~_)h!h3)3jrdKa}6AiQzVCt)PeQLuO5X|xpbn3
zZh6u^oqW%w+ea5L-|tNM7vp0`?f?!aAu7m`KY~Z6U&|=&-k{bM0f-J5?~wOMuQIGq
z*vpK>tUv7|=P0GrWNXWXMD_~hCj<CxKm7*IDQCy9oU`ZzF)7{5HruS%NoC=bxunrA
zEd+ki%|e-&x5DVt$F}E(p|T`#SDh|SiU(<|v@mCHA3yY!&I?0Eqi@NG1Ia=)!717d
z%U3@Gc(}fXi)&v&<a?VsL$dg*+B1ei96kMXkfJJ7H`(Vx(I4)38rUtPy6B9ldn_<t
zC(u8iuUI}xQpg~zm1*a5$5&l#!M5I~ySefX`r)XZi>1ZRLrao#Jh%=jSf;}?GXI~>
zpk_8Cp}*Bz*|aLWo#D2tr{_ee^2OHkZ``in21|$g+{IbFt8Gf}IBy@h?!?uC_)K!6
zQ(=*xJ4H6iSGq3@MGDB6Gc1l2=xnzPTq?co|A?HQFy<FyhF1a}z#}?(zbMob_AHk5
z+$x31>bvQCorCx?kBrzag*?&c{qcAIwkzE8A*&wSmbz;0I4=p<^OWqwMO_eoUz0nK
zf|1Sat92aCa1LW6O5Jbu+U@g8-)--t^KcgjjJXW}(){G}CZXb^b+DWnv!aN-&JBdh
z$mGiizNM~yCFx>0mH<U%@fgS#>tKs>x4?IzxLafqSJ2A<gb$d{Lcq{9phHjYc4sgJ
z^kEf>ESanzt%WA(P@rJMpZcshk0{gjUayxh=sbY+o-{#cTh8admJ-Nlb9$SX{fhhM
zdsQycr}y0YA1^old{F+D7i(@ZOv6iK56IW-&y@Gvzt6o86Oqt_4$X0I(HJV=K)U#w
znv|V9QkI*%W3wD9IqxgU#oheF`E55aJ@yeDNgvUS*jp@hw#N2QoY^99-3t5)DwSjI
zrB>6A-C?G|nn(y-+A-=JTTyaTIlsx8!rcb@`II`LoJAPJT9kSq3)=vqawxg8>eU0S
zyAZKOf$gZ#^%0P^>5cg!a;Q-mN*cp}A3}1hqjI*cfGD=xZ`OS~0cfrNv_a%0+>L*_
za-d_D7KPeeuo)nMJkObum4aVDvEM<pCnVS)O_P}yR4l%kFa+1G@4dvAMlR4+PSLp^
z4z@msWnN?98*%o^l`?-A=a%nSasDRp>w_qF&IW7T4;dwOYBISHM1j0FC56bl=Pw}i
z^dzUjg4`XybDf{+z=cqq2GmV*_e`ZQ_^m5Ts(P1n&fTee-qFB4Y7NS$Gc!TawyQ|p
z$Z5&4ChyL^)DvzCI4kP_=4{E62wm{^2J9<66K0{<bH#%0X{N(rkt{kgA1XIowDF>;
z#@H=xn~E{my#?|FDgI!>SDNf6<ExkbsNZn85jmSY-z{7=f;lwfy?bT6oeW224`)RC
zp3L<c_>($LFGobaW%cNA_leZ)^ngc-q)qH-HJ1APuHRW%Jq@h3vXtdu@@{bW-m?NB
z#FL&_o*Sw!p3YeaY#8knsROAf@?@40^F-|=upGHZYFF|hG=lik;vBF6-%``0f<nAH
zX%<>O@Bp1N)(h^&yBMFBI9o#6rZy;I19VI_+Mf=}`nJt2o6*vS!#aS1Z>h8E!Ds$u
zIhOd}i5H9KY70CMo8#PAE>{>qOu~;)TtUPk_v_BULI?^#_JhX#(fm-g2Z(p6&2ix_
zxksINPtt??+?Xh(^SgiN>iV$Ej{#5V!mP9}Wtr7s_2feUF2@5m84o6bP1E3`b8S8c
zVrgf8-lg&<IG<q!`-^M_AA8~n*lfE{PODtd(!2Ok{NywqU>5=|Pk$lVX+APKbSa>D
zLP+0GE0XBeAU9<zbSjQ{1$Xqy&uj8CR6wS{1(8U&--*YN*-HA&hOOQSS_2Gxi!vA1
zSa^ra)NG*4598x|9cb=4lRi7B(ByENG`0Udr)SLB;(ez>;yIA!AcTg^OLs6uB~K#w
zFx#_((YN`RO`_f%YTM|?8nAhl`%Ro>mrS}kAuFYIHt#2w07o`Hli{0oPiQ7}lMg24
z{nFNxL48)AAZc4>1ZU&CwyE;`CTzYpHLNHNxfM#<9vjhU^(tNG9t3aao3jG#fBNZ=
z2gx)><7K=uCK>|FCzDF>EBI$V-KAyq>jes3Rj_Br@sZAx5a~Ml?5xGYEk1=bNE%LM
zF3bMM-wCYfzoidRneR+xzoieWkNzut*dK5YhTNKMsfn17x(HF_oi4~^zwox>lR$?j
zX!z&fv*0V}tZgGTKUCkwejY-@4Y?F>H1z&fmWsUo^A2<|U~3P<xZCR#=J|od;o``H
z!M$&Z17d7Kfhcxx`HT3Bq!vNR;P1p8)rMsSHpCjWj|6fZS3WQArx98MHXWUZK2fh8
zhBqZxxW!0_SM$?B-cnTNgFWYEe|Ds=&@k`$WQCR?_4##<vXP(`uJ)YsbjT_(yu)dI
zjG0q`0b1`EMmAZ{{ywbHD)c3JhXaAXGIF^d1o^!)(w<|sowxi7de$SuJ2+o9EEW9V
zVr!n;;(ZH&!!)pFMi`1&tu>V)W0ar01i1&cF0BfRAaY|fFZ&iyYY|jxo6>?q8^nZA
zp;D5dhz}&tpgF75g(7Fb5A51M^XzDaNE%gyH%;7ji{pL5pzq%DP`x*%o2<z;<_9PI
zE#xnBYohgGYe1IQVXu@Mndm0B7IOuG@Fm^x4mv#TqwJ*=%@Lti$nuQo#~C*Xsjl3=
zo0{ma{1~+QJNEMd?Us+ZIpX5=x9s832fLu5Yt=6t7J{Wq<yfK>sS&*Mu&5hRvt&0S
zP$$189XUl*Lr_&zhRLILX@wS~vc(}qLCdrAkcbacK3_raY$t)vZ(VIi!ffk0n6ixJ
z{NQ}eu++<oN}>0*mmRtuY#R6fPB3iluCZ{h7Fi#7j3KtqtD$nFEId=O5GCmKuvF%P
z8M;UliJ@|r>Ehd`a?a;?;^!M~OX;ApMZ23uR`QcauT2eMD2f)o>O!#~Eg~tT7`>6j
zPF$5dStGD#)(3R%xrmpNdH766-Hdr|KfE*j!9i9633L&^3ktvODX4x@bjbW^f2a`J
zrGSXex#Nvu4-j_TsqWh~?T|Z5z1ScKWDw)-CC9TZo*Y01@#IA6w;9BPpRG^NCx9<q
zHl%E|+&a)O957_<zb6odw(}xc3(^wpZ5T$tinqCmgPcjr9h(-T_HZVCZ&9X0#YgI_
za>mU>Bg*zllR32Qa{S!*$TaZ|+W>xSJ)c@$3=8YXqoEASwW|<z!*(TwTjw|Fj_2#l
ze-37gxX@;E5U1uDew0XN-i`CF@GZkLvB4Z35mSD{{#^X{>$B9`zvLI{l-!WN<rlxL
z5j_6CQ>OYOrL6zx?-X+0MQ0;6x$o5uEk^64%n!CYG1_v*=zbs*1R!^l+NLl-Vkw}d
zad)8*Hdk>=7UAIThK0KHV`#eMSo{<{0GtvZ7*G=JkE#X)RL8FXoOn%$*&`HO7HM<|
z<aw4F2&|D+-)1*uB$lzn7MWODf)Lnp2QUuX^yDSZ%6a`%AbXobZe!5vsc7EVXtXg4
zQ2k3~26FwgC0Yb&f1SZ!_u#K}@Ru$8<q!VyiGS@2f9;Kb#Rq@INPoqN|5LH@$2JtK
zMbimSP$B=u@~vX-{`)I_ujedMolN%s?Xa#t3{m)>fIa-dV^TMviLpwvKt}Re7q+JZ
z_b_JlZCr$)W>16k0p56CklV{Yc%(mlwL0ASl+=D51O!>U|At$y(w7_AgYQl+1S<Qt
zp0G+!j$jXH|FSR5Zvlw^SDq`nKsWDyUI<9|LGAPHRBgo;V{wwzuOG}|fsRvWmep6#
z10&f}2JX5-@cb+$Ob>QIT?(LhGipEm+ow$bUj^@Thog!jgkfj-55iZ>COkP=o{SB>
ziu-(A@?3%cL@vTvI&|}DVJHuTDXcJpsN_Q@+diHaLDC9<M8JUaHVy2vhqLVG>H__~
zg1q^@U^)x8HO7Q`AF@iSkMP>FWB2R2*;r$WQX9CT)ZUW)a11Z5bSl5o{QzEYzLI27
z&gNuP%B8cdW2HP}yQ(DlpX#3Ih75#(PPW3(v&!h&g-F`RZH4_#<X=H?Zoap{^W*lN
z@HFeMpt9t7h`Ozu|AQGL@!J-#k4EB{Hjp>P52ko$5G#&m)txAr)y%#%+vGuri#;~!
zK8m>m6|1dmMA1eT7H~#+dAJC<e+doX4xpU#ml!w;iyBg;ZC<a89B14l-^nJ})@Mc%
z=+_pHmdlc?308ZBTe~nqHZ)1XG_J1|hG5Uw7NPe6Wr~t*Y{LbhpPTPLdIR|qsE}an
z=_c(ayvtv$lO;mayY?^9e+6y($+6yqcgb9V7nK9Tq1x+?{a1z`jRs}q>R&K;AQ0fU
zMQ?;XYjzW(h9XDyw@e#pMIQ7G9MLSYKs%0Zu-=ZtaJOLe5wmC|A=#ifvP3%;4?8|V
z@m=P*hv4B0usI=|y^&HyqTslj5iB^5&ZL_1pQyq*QvuKrAZdXeeth73626y)|9(&^
zl0hY6{qW^A4sS&d2s~n+UPk)!3a<9eLGyAO5^FhqCn}~=x26>dAK_QXNvv9SwCoHF
zFq9WB5FH`33w1K*X?9^2<wXhRyNRybJe4!+BU%JQd7swkRV>-r0-isPNLY#?St4{X
zI{%u9ZUTXeyVvW0l|dGT@?rQh(Pqt*#3te*O>S3HpM;+Y(xqQ(q35igAaJ@{D02=f
zRXpTs$}{lcHsiScEfH9K*Z8-dx#rW&>6l9TKKC{cllX{z#>VKH;2^$?@JxeoyWmS~
z+>#u(4Wdy@#kfPoK4(qTuA$6=9yN$gSiVf>eG7iB9iB-oJAL5>-9oGvT;Lr>4Ed$M
z17g%1Yt-YMXsgZR82b8}Ig|Qf%|5`VpLK%-2antXPgmf*&7<{=Or26u`pLymxR19$
z5<C{FHL`zof13;=gxnt<=Ur6cyR0V}Xq;ob|MBiaWgl)mO<xvb2>V8H*1XBa$NJqa
z@0l#0ZA2JoUm|Fm*F4IAWr<p)aqPMnj!bsBhjLRt#Tsg@X4Y?iJ-E7d@beK>@uh@o
zlPX<{zPDmhdZU`FSc%c{noJl~RB)t=w<9D|Ij7gj`8hd*K4ndNHJjgI(w?*|InLf&
z{kTe+<|W407QTD0n5Y4^7@nsbIV__3cLs7h3mIAvrqNmMta`|T$kCz6#~P-pi(Er|
zuBeZ=xc1qeQ%I|zG^AB9@1C018@`8r$$_y~@U|XK6O8$auG0JGK4QB<&vB4d1V+6C
zge@p#c%yOJyoC!xvRf}V>}Zf=6KTTZ6zS)fQmk>udCMUp2j--O={8dNqZi*8gv^n8
zz&lngLJ+yuZ!PRAS_QKSGIhaJP~yRd12YTF0#oC*6`4I1F?NZEg_4vVM4Ar;0-{Eh
z=W_wVE5yyu{LdC{j*cyHRDDJSP}JdfE^ypWa=Yv+ZPkKT8MyaQmE-eARcQdpR{n5Z
zf0)N&XIq$2%|l`{!A0SS%J^M6?K3+W%5fvK*~7I`n}b!RNH+B_Z8vgFs0G+5Wwg(_
z5f{p9pROnxI%Hd~bCc3!O4W6ZMxhJjj{`as@4GI?QcN;ve6ytGqAKIl!U#Inbn3RX
z1`;p8ekJt7lqxP5iAiN<Z*;|<T8U3%XVXv0mjH~>O%_Tt!UGWr))lRx?jb?kY*y4e
z$C|U?z*guD7S5kfJrdt0hQXg<?+g%>mKDDbXH@Z<%!s3x4bq3`YZx^>f*)k8B%Qn6
z-6*@YER2|?%N(&n*CUJ|T&o54c96C@H{vmVL1p=t6}nWz#sz+VQ~IGg;@mYFey`JP
zOS?m}$8k^Fbpo91n8iVR9YQ!8hoY`yT5k#qFZ#1NnCcTXzR9YnsjLfBx0Sln>M5l`
zuQ|`%BE#a&kEO8>;oS#V+kg?xmP8}&2Lg&WZ=cyvz7*OoGqqgeE~_pJ#>%K8AR<ey
zL-v~y{`5v-N5uZ#DqM0h!M@T<Z#asZYqMgsJuRco%G6~a0R5U+>r}u)(qjGha8}(6
z-=#j(GBq<YivMzRn9J_iVps3gs}aEuzqk!W589vxu=R1DAAZpSj#KVBLm>C{+9`>1
zIP`b5-a6AUEjo5kr_R~f`><dPs*re<u~RGXV)_lKg%|V__q@gQ??e%TP;xAvw_-A-
zB67k64WdBQ8ncE&g-hg<k6rKF^5k&J7hMFFV>pJe2)*8cY{}OcK#NRV>poBAJ1m3m
z#-IC8$>XExHFco4M2<a=rj<t~Zyuyx8`_t=7cpR0&+)0dZ@N&GV~?(>?+WhJTER?~
zd3KO!WyQf{!*(*)JD)eg%ckV0^3lqV&oJsa)zvkn6|dY>o?2SCsvNS^VbW4_3#|}`
zEs~ndHUw>0;e=(Kx{)^tS9*HFp3(XG=zz5xa6Zz_`%1TL>YcE|WO!q}+h?xLY8u8h
zSfG{zIFPat7y)xjFGs!rC!ZIFlRYPOp}1)d;PkVajnD<*6&M3lH}`X4Gy+1oIB8~k
z$HQI>@=mP#EUt8k(TkPrF<)uk{YXK{qLQv$gMxO)FG6dqGOzm{Z+cv+YyyKW$MP0h
z#d$SXdCgWpyr(;jH<=FDu)+k*>Q36jQo02g*^%wY9h;Bc<_^8F=6Iyldo5RSE7`L^
zUeq4^9oyt4Ha>*@aLu}FU2d)yQ$Imv<BMMxG5M;nhA^*><u5l*P&FHBB-;}_+nkSa
z;XY|%+OoK$LXq^q6I=txH6Xz)V6Z#OX1NjXt@$<N#1U0pNqU4uE(Zu-+*DALdb&UN
z-o&%Ww#_p6JI^p(x^Aa}9z_BuGe2j3Jj@l8&dPH&^4dxT{x?^ln|1;zsqS$0Io806
z1}UWFyUKZ9jjtfDcF2ag-zz=3%uC96OpC$NHOska;PetupZk8EmMw#2Z^!uNKBFoS
z7^XP(y`Oz9UPOm_Q;*Vb<rPJ^zVP4;4mW?23K3v2kjHP@$8iNoSe7_NiMnX|nx2nW
zvEK7@G0#=14&L4*nH5{P$0Crr<tN8dq?K4}>9;IOaqiBxiZR42cheMt)NebEepbeP
z%54~vHL~XsD0pj`XXPoa<JQM~lEaVNrshak6Zb-*y8Pt5x@rdM$o_;1t%fF{Ef7zu
zD-nR6h<b{%SCDm@e0+V}r0HpxgCRYxFAVo~yzX#%Elup~M90(5t^9%^;;TE$!n>7`
zP=47Kvu6@KK7{otZRIaTK1F?LF1@C4s@(V1N{n6R6&xKsXBAw4Va=IVmfowWqZu-0
zT(#n{jJaDpRew$8co$eWabdgt{+^>t<;bBvwbc}xf~?rjD$6{dvbkSuoMR30WCmSR
zr+C@Qp}<CewaNmVrC&Mfyj~mZKY<;yiGT0d^S%X1AiN7Su*)R3DY1i|4dFIk!b!BQ
zgO@fwB#Dl<3S7T({7M_W+pg$h%8TYiobZ!sdLsaqkIje8?2aT|Pd6+q=$pF4IGL#1
z$$-B7hf&*lr4CIZdwa-cfb(wF-To!pAhg%~rcv80(WF)-MQ`E9SffV@<)$uXuM*ej
z2{E>*$c`pkqxGxhX3uzK(hH1Ldf99%CK&=cdfr+|d(NG~$G?IL=e6gxf4B?bdr%cE
zHcJ)4`Z{-gSu$DjHrfr9*y8A}e0SO=SChGZI%6tS9^WCzh~OO^MeTDX+X8f3!CL&p
zOwb%J!)n2!(a*vopHwbhoRnKgt`nE3b(|U?$ZgBF8J=dm=R$12hwnsrJF8=k?C~e{
z^HH6#?1BzW_b6q`zm#BbkqI_u7-{P(Mi#Ulj@;a=Q;`rbtBp7Yd9SCS@%ZE0OodG}
z6fUQgv{&+JsHw1Mb?o+nypo0$?WxqHa?d{&?AtgG&J{lUF3UUzUqrv+@Pg0b3$6y4
zDq)0(R#ChCGlsgFnJf+&h9Qof&G$nl{&!+=j-S7M0e^nh2nBB`plxR0MrSwC?%34C
zC5DnXPSfM%K4;vfbed&8herYYs{(4jxgrW!v;N#PztI(nt@NI-dc3e(4bqiY3ywio
zBZbs1whytnu4DykA~cI|(H)RnQ;aFH{$0$|F*uwigKpWhc-u|SzDZTeX;qE|ahjj)
zUAh6AplN*ECzUGhwmfX-q|g0ns{scsuTEG18C#RqwCc_&+vu~v?((@VNc*yy?t`0I
z8BF^T5WALEDyd2zrbm>YI(Q!9RB=|HrL!77kFys4UpwA~CJ$pS?4#JRgQ4T=my$<B
zDFXZlI+?82xSKE(2pbsz(^>b*c3M%&ah}by$$?K_DuT`^GX;VC+6l!uj=L6Salt{w
zM(FM)QBj(QGk2rbM!)bgvNMq^#}a;Idoe;0p+!(XDj8{ZyEN&BQ_jQ<fmNo`yvjv&
zkNDR9XK+0;(z5Vr(gem$?>k+VvQoG1Ucdhp<W5N|bF`@xiKK10`j+zmSu-MRpzqSw
zKSA$Wy<UdfNl<Gg3&4LrUhrk}2eU=(FI*LBM2^HNF3H9pFl|gZV&A&v%@9?M_%LDg
z>_Nt}Y91N0N|qmNqHY`0(Czh&=@8)gy63*YYUF7iqrQSBE`CFu0yGF+7jGsmx+pS#
zp40DRVL|q0w?#9d^A1~&+lCY^oxT_;pZ`>)(+6Vo!;!o3k?BQhQ9b%aOM-pao{dnl
zo@nfllAfh9*VAnF7}K-JRK#)!z=VcQk-jx!Wx|J|gj@8~Dy>Q^6ipd|j%jaKlnptr
zt6!ecF6o=Tpy+z`fXkN<1IjJ1-`IYY(6>b#q!4_qla*j#z5$8~j`5ghonY9OFRP0k
zl2#fMvwIi4eGc!|76JT`EGzI3SjO*<Wrkzav!q7>AiU+hLA&XD_|rkGSD0ul`-gm`
zxwf^7hno{8yS?tuI`{sv74uNFI1%;Y<?^TlnI*mEKp3*|3{+}J%JMCLSe;{zYVKo(
zP^)_>EA8yJpUbQgRLIeR$OW|4$d!@y9TU>+0Xbd#A;KQe{Cv*D9t!fiRA_uWmO65c
zE4Z_H@dxd%?XcaaSyl&0n>*0`+0@%s!e1Kc>XdVP3#?P{2e)O~MBXcy7za=20Y0Gr
z0f6+RW$sl2$U77ehX=~z&{ZFJDJ$f}s=pR)=jub31~$yGvn$v@TsJXR#8dF!snTT)
z1uzlf^Xh7w6Uza@iTxFtnJS9)T~Fel3Eb&-ARCfSWDaryL<u_D8)?^$x1aIxvC4l)
z>?$dVlFz%*C*gb~#}Pq!&&e+gv@RoV)+XEB#rMQ+=%%P64iDuSFlSZaZu8B`0B4bh
zsuJGS9EYb9@IZ_i8UmS{CH)Grc7N*iTBv$SW%~(>&T4IJ)b)Nm^Q8TSdat5D*rM7%
z;|4Q;V9OZu6?x2^nC~Ta8-Aw^Pa*#k;;zr-@Wf}EypO8iRJ2hFMR^0PwsR>Y$c;t@
zVH4#x8SbhoZ$9FHZ-z##I7cbA0^;s$;@Agbp828UJ}h9MQ?%#)Kla``Dynu{_bf6J
z1<9$9ASg)$BnJaYL=eeQ1tfz=Dq<0ooCE<uqU2cQSmZ1cBxkC~L7)l=1r+67U++Gn
z_degZ&+Xf1boV`H?7`p<hC^7j)_UhV=X{^}{HVwualTcgd7&=odh4A1xxXR8;5{(I
zg1qpPsEO+fAZ==@^p&P@cKTknJ@6eQcch|5$QF`0TMmt4`5wT9p>ZmE+`@n^&%d3%
z&vVosGys73riJSSSm{*ZtqlzZm*wImL2apWlV}Y#v|yE5wMzG$fp?^*5^I^X7}b1C
zR=2*)VN`{P1iK1AQFyTRNsUY3=uXgf<LPM$m`dnCjs~4&gnG)DsFhdC;jS)VV+Ytw
zO-Q{iWEvsK&ZhSG8oAcSYXm9OLFLXuG?PU5;swXOyY3rSy49ZYApFIY*xCE)@{OOq
zYMT6+^T|V<PtRo_tuZ!%3+`AJeUJIs1Nx2R6#_ZRSGn0!$wn0q11?TY>f=NfgW|Jo
z3LcydyR8sAQ^lacJ#DmAlf$?u3QhT%^PrhK+xJM<coe8)lCsG!tj4qE6OF<LaE4Vn
zH(WcezMB;_rdeR@H4NeXN4TzM!~Ni0lRB}dzd?y5)9rh`(Br4#rqIDDW9Uo-&;%1w
z;+RweCA=l^$tSKVFf;YfTzOub_UboCa4o~Aozu-+eyycd3y}NL-^BRZ_zPtwIx(ea
z+s0C4@w;U`57j1lnx4K|cj6Klz>uhB^+S0ow3y`}cyFI#&UNCgoTcJYFUY6$frqz)
zCF2(_H%hp7-?=I0=;X|2zgy^&<$Oej#btnM!ddra+YbS@mOlD$LEp;RHF=cmW)l<-
z^9aYVIJ0~goqoo6SEBooomIl87`m6~mhriqAkl<t(!hjRT}ypy*hp<-D5NF^E#-P1
zne_Qi@@xE{1g!_=@{-*`2Au(t<0nv%VEf#7+tQP7CLb#~xfLNB)z|uUNJo7p(PtrY
zs%vqKcJ;K25)JRU%x27=cF4g7r2(EzS8jzgK<??SuoD~M4AZSnc>R`J<GrBP7~9m$
zN3MrQGGAlM`auRUkWmC6&c71tW~_O@Iez#mC@<JZL~8_Lh0lgqk9G|irT0a?qYeiX
z1Jf{!$-8*6CSuH_o{z0PhCJ4Sj_L43y0Vyd&3R}14CmXjV=K*6Da(w=!kgk>skRYo
z@t{p$h(4Dn8cfZlBaxvT?B{-ZR(yq9%Zj2WJQuMN<SyjUBXiRGleRYPehy8Iz-_Ze
zFK&f)SDzVmNo<B*!xbd!igprjpC|Ad4@f3acmKry-hmrYeXgB&ciI1$|FWZ7NAl6s
ztJQvrb#2L`DmCF6MdEzKTAxHmVas}eR|a3&%ya-g<hAC_zW2h85{4=6jEc5zhGM@2
z$x)n{S{`Rp8y0CURWH<an?Am&)q2ylE}$^qyP@+ph-n4LGG?aJT58jhlQ*wfLE*a(
z=1l<iC9tVYF-#mIi?9Mr5!}<JHU`JaoZaZ7MXIbbJ~_YP&ZOhV`uvdrCl%ya2SlHG
zy)`XKzd;eyfsHYQW%zj@HC*1e-9{aT%ZbPj!^IZ8Uo61$gFwXsnfZpaq|!SU%G!A5
znq{WYt}aX+NvQ6@n4f%9%L&-iH|R|JB2Y`q<`kwqDLkV!;S4ji7D9R(`ttK#7$o9G
z-^v4c_g2sKgO*7ThF@$aP9?00XOl5X9Nk9y6+71y<LApGhts{^APH<Hm@8yg!@{rz
ztDkF!!H?2S?A(Chf8%zt8LWo$B^83QCl;%(2WXx|!t{+bct=y;bc&wNxkOefE}zGa
z{*k~e*^9~vwbSMt;c!fT?G{hahjV9o@T?~@;&z9WOZBPmqMUB+cL+E$y|`LQ<n&Ej
zmy<+#!>!R4ee>coXAJYVC*L%-#V*y?ZoF}2xv}%B3M>CsiR8!q=7KDLZdE&|!`r>H
zWagxSi$MD&zjL%IGBXLGNxag_L7#TebufY?c>QjUvg4%|XGkmtAXIs*K{?E}S4f=X
z9ymYti7j+;uB>EJ<tc9bc#Ic*2DlOJoS4Z>Bb^RJ_FrYR{e1Vdq<{O`us84Vc-(yA
z({MGMQ58?YTHMJ!&qBxxL}-vdvIS_O-0-jX4KipCH`Np{z4v*p@9kZ0Zn@+U&38EF
zF&96vOO>5@<)xo9RVE7qLbpC|L=!XKp`PG{Qb_^*US`b%wN*`Ev0YSk6dI&r0blzB
zBd^~e3!q=Tt&6v9V4U$G{E?TxlQZ~$IbV0_cyP0fJFlv=@7s3wop0|*VQeUaE_pt4
z)Np3Q8o1WpC+VbFh9u*M)9Soj9nfzu^+34yvrV92^Ef7~g#{7$V1+oPzKG258^_O|
zL%Gr4?xlMSh~pg)e$e@@1hPt;FEO#da9ZCaH&Yq+RyADxKU!aqnW%!v0A8$-3x2o1
zM8Stb)y)-eK4McMp)7MFU4jm2DG68wmKe2Qd$7#TXdD2;KWs=ht#Ni8yRXG8Kf|=Q
zuf$QOCk))%&LkI+eW%n=r8Mh@P%)rHJnV07YekhBHKmB{HOt-mS|e=yh9)`s<Kp_u
zi?!v(tk5))Ksn2TLGRU8t^GFc#?<dWmX>QZXEp?a$=6?=9q%iFRg?wYda8T523aXe
zZw@FvQkO$5Je)AqV0$jI?9Fs1u2^ETjU3}viUIdCChQnTO1?kf227mQ3*LORU?!w&
zL`2(gBF=hU1H>CABvxW|wgLDKZ!PL7kIaet9@DB9f1%(~wFY+4e++1(q3wzd?OEG;
zeVyDI4!!S{uI+^wg0K7CTNXl<rRnU3XbRm?oF_Zzqkihl9#Gfe048ytyID1@z+z7`
zYk&Pa>1T6zeD#@Zn`LIYJ7;?2BxVPY5_aXe)Sg3ae<6PP!S|O|nD^5_DXaOlX{sH?
zKgW0Sd<}(e{+ihksaKovGRK@8no$Rx2xusV;#d-Jr=*fQC}iO$;k8OHzO*$QCv>ph
z1n8BA0s_PwWuq19HX6GCPE>MM8Kmx@j{M6Pt4r})o{t*>DO4Ek*em^|cP8Vhonjv+
zOC(4ds4(llh*zzGv7iOVVf&KE&+lWo?@RMDA+R;4B{CES7Gwc;jWPNHgN3Mr+ArC$
zZ$>|DaavxL4~4|$gnHAv^sF4Yb1(v<y5Os1AJD0F=B-aX)j1!1vR{3~=q4d?QWk(S
zgp{p<fY#EiefQ6^uu3`Z8-SS@|B9Z(w#5y&I^Yu1(0!$I1$G+hKlSzd+mXQofL0PX
zMq<GB<LR}?$MICx^hxM0kP6o!E;t%kn2fv5t%cIg)4?O@MT8T{c8=;K%fU85I7&4H
z+|6<pez;)55;(a<8~)Jp=Wmc$y8l{Mdu&L)=WEF4MkDP{mx#OP0c}ZZioitHx(_A{
zSb0OgLAf>+CXZ0xaiW;^HF;W%%P2E;n04kAr&GDYpdpvdgs>KJFB&+kaVW7n8?W_D
zIc=a7SvD*%;NHb6_4swxOa0+OHP}xY9Dx-PTKcdNjo!LZV<p<bnfZV)7Sji*IO|!K
zYaUmiSb${8=RR+(4(#nG7c99Zbvgv@3Y7iQ`a-MH+GOa`<c+hg=Di%nr)kv*JXK{M
zo15=`t4<GAs9Q59$4KTnC~(xz$eGUgWR@1I2%F_KdK`5}7Y%SG28$)`#|pgYXd_31
zgZ$k5U%feWMa+%CRqQ5fbu78b0WVJ-B~UOmFd{*icANbpkBT)i38>s_tJT@m+f;Qe
z^rh%mfzb}=dO21Zc${;J$9_qz=slde^~#msBjC-_CdmUjzUB^U!E!d<a+Z7A!^MUR
z;u`Y%a81dJ?4uH(!S2PE)dg?qvp9160iC_oeco+48XQ19hgs>Ime~qF(NtO-#_zR{
zzgN;t0p+5gmqxlRz$!FB{&>o&grW;3{e*XD`6s#fe}X#bzhPBt(JDE}+m7&CdLmnI
z6V$gz=eRnTYBS%X6yA@KJa8?y(|7Zhl*ve^jYA{@uHg}-9|scps#SLX79}rclIE}!
zDCN)?@aeZ9SFakeWp&RV8w2Zsq#zrq5&vJNhn?r`m2I~nQC-HKMJ~ruNW1;nC+uFt
zPp_*ocgMR<#@U0;BCQgYNr{bU@T7=7Q>6JrX7<^>XHt)|2ORAx#lez~@%9XiD>AI_
z^m;)Z2xHE4jFQwZ@a<<g10M{??|rL{3-+Nu_;?DVk1E$Nhg;m=-8nFO`tI&JKM8;X
z;mAzax9JvGdejA`@o))~oJlY<dK~H`zb<{}E))MTkqM7G(KDGe(5aDiENPmNmEqd+
zWE&}hUHkHis{G}l4P$$KFItZ|y4|fKV)%qP#<v`^wJJD{Nwd)+GvT{nuWRj->qGc;
zxbtoDoOBRK4EsI9*dW>|Fy{VR%1yZMQ{`lE(W~0zPY0ktrsR=p+%7;zbYHh+O8k;U
z58hVaU~~D^F6r8Z)l60=kTlC8B-$e@3^j|$d6jLp{CeSamU|;iIEi5lHS$*KDwMi+
z)q-izqj=Z2<SKV7;}aLS`CT5ZTIVq{0RS+o`x362lA6n5vv?jhe0)+Yu$ke~<;6jc
z=|t?`64;B%U|Q*w4}P`~&6=;hlT{Lex!7!RiB{m6Jdjwr(UB&9IGaDE=Fk#9D?sx)
z+otl|G|Lq4kJeO-<x@$hHA_-z)5r?nsM+~(pPPZhpjIb!*vcH(+9;pV_pV65+^>U^
zg^a9FevHJbruxB2JMo_6o1-n2Pi2g}4UFNUI%13XcpSsAz_hR48Wb!MRW~7SM%xD*
zwri^F=QfG9Q4x<3Sk{~H_!?9jjI6NAF@D`?<N6`8pOa)W?Xt4}{+pWPr)^pPHK3k<
z)S*b}PEBZPy0pXCVDQ59an+NFC(*=I5VBlmtV4P8)bRo{p;uZ=e#^&<nx{ojE{Eu5
z)MFeC>V9znR^fejk@?*_6Q*oAQWPBxk7`{HhhN!33E-l{ALwwm)nO7w+Uj0%Db6`;
zM@pR0YX#5TqQ^+e9?2Qd2v$Bx=vyq!B_`QczMaPV>9N&=o9j1UC1MPMAlIC*H_;<d
zifx%<_}C%mo7r2mcPitcJg$xO-12X|%U$Sxg9b+-1~|CtQD&fgUOXNTf+}w^z|l=<
zpDq$Guq*$l3!H_VGfHS(90TiINn*3TW(%7rkOcsjz5qWz0To}$EVf|8^b=O!ylnUl
z@=+NfNzNFygOKzY$2Oq_`t;M1vqML^EM06!Z$8(v_82(f!Aran$i$H6%{#PH!XM<X
z2*{UDA!GIQ?>zZD(YRx%NEN_=@ioFktuDzNEx)P%ameh1|GlHg$V^2mfX*YES`AZU
z?UC18i20?)G+C<-%1~9`|BU?Ds>FvPit%c`U+Pd{JMB}Rcu?OGVI6%2iVge2)LJ4#
zTEZXD`D=c{Pw_lbnme}UzL@!p8<i<b2_R^iDB!8jf(!(ns^C=t+5pCEYE!_ngCGP0
zd?v1>tg8=>fFp%%#ZjYT6!hq}5um2gAN>tdi9GzDS~mWdwC?z`UCFhM!EF3Wxfg4i
zB%RYx+i90^hF6~v7HLM%rRRee$0rh-Su{8q<L!OnB&2@i0oK~8RZ(0!OZn&i;h66+
zjHtd2%@_-RsL#_f<)IOh{Mw7nCjp|zfx!=y=j+X?z137)vw-nj5^u5WNbN}Q1jl`A
z59C{h``G0*W~%4EJ5uXiiqlaal=uN@=)R75h!k&$+CDf5BrxM`7d5eo|I%D@CJ#Cr
zWt6*#>h8gbStWE0biUS-Op#Wr+Fxo%aN_9j`VB0R)S(=F=r26U3@YTb-teYx%5l#7
zKvqJ6f<aNxjzbEJ%TUwgjmy_p-Yak0n_u9*`zs!n;plh1<>=lCq@w`Ikb!=INw8F?
z(NJtl#skHAk(rD$^2>b1pZycKi&3PpIi7Z#0D8O#Po*RfZ!BQPp|yg#!{X>Z<`CCa
z3N)aS1I2Li&_Tf#V6P2_9^WZ1gZScTwdQ8D>K-q-6301tkgy%b@;Xw#lN4DqgT=`4
zIjvbxX?$H;9CD#c;7;WNRo-!1u61`37Giu*IsV!+SwPlye`=AUQkm=;wuqpk++z(b
zj+H}IxrjP-HcdU);$kaWI`~%p8w4eC@dL(PK7Q%2I5`)=g%NoMkYNmRAz-uiDM!9c
zBj@<O2!7Lt9~$UQsjaakhtXI(>ov_s%J3F=V}sKj{bY%7e71xz62$}Rkw7WvyvltA
z^6@;-zL^rfzZfe(Ab}a1b-ERHd(#z7A3d%v3&iHD4M-pNK1cI~iLcOayX~-)sc6_$
zzAL1NmbsVN1I-i|-ftsRr6p(fvn(I{x|Jbs@%rPo_rh;b>=?0Dm*zuCgEeprtlU)H
zMfBrW*B>b(h`6H7@@Gm{CFRwwUv9)f7wfzf7%{GS7}cJ%P+0yTm(aQZX<f%0ZG~va
z<niI2uACbxOA}oIb198^c=&Ac)dO&bOGwiL9xG37zIa=LOicHxrY$6{dzornf@FeG
z-{Z#e%{#L;vmowx5+1~_j#AIxAbdGis~GPxGkcbx7_VWWrRkoI^~73ylF8|j7F4M^
z8vMb%75p6D>|1_Ml)de1o_A~8DTEUdVCEo99g?tEVuA_lYd(b)=76_d#CTj{gW6uJ
zVdGjs?^Zw@!&rm0TN9JKiE1&<xpJy)nz>ny`k}E8aZ@rVKISS@U)(0yK2`{|@)QM)
zs1veyl4*!+(~PmM^J_dObUN%;%y<KtKoWmhJ-ja5!cgd4V9$%M&f7-nM?o+f5-TN7
z1bUY#pDHJL`2b>J(WYRYC5L}Q>}|=4oKxcd=50me)6<U(V%#$C30z-82xcUPcX34H
zevgm>7SwxO8jbs3A8RCdeq%OpM)`^!&Ti$u1!kdg3mjYvHP*_#k6rs`y)s(-6;4;M
zo`GTt^xv9)gZiM%kc82#iBs`w{M(m#W_kXPALAqxJKN8J$toJfJq%Fm?vzeqC6F<E
zUB+@g=5dZU8(uU;NZT=;ypbP0-!W34N6}|}kl6RquZL%Pdqlu@bd*Gy7l%LeUv9zj
zK_2ha*+gp-n!k$henwFDCEWhn7_Ckb!Nn0BO{y4PwnDqDjrr1@GB43HN@3u7?!*IG
z%;iL9<?ExoK9plwk){5$)2k-oFKu4&WE0DNZg2tSxeda$s|&-RcCGfTn=}>W_WE-x
zfgA7!5V+*tm5RWkKq9)Kdx^1Me=J7XI`m-WN_nG+oW~zMN@!Ds6;)#8;GPlklR)n6
zzedH~8fQqfb97Pc%DzYpRH$25q?3ChXMqx4Ffn0vTx)F8{P?6Z7SA<3wkO2oHtK<k
zO^~1R8l{U-RZs|T-gu?CtW}NcLNwUtr<@7GOtv?GE~>kndv>l1UHf`YY4-YcI)c8t
zwgl0bpw)fVE=A&F>Doe3v*kxFj(h~4KXo^LJUl}9tM6-Xw-dNKX=&9?`YD&~rnUY=
z3s#FZUCjxKb#}g%-fPLSKc=+k^wDoYVBiwP0z-Cm&-)Va8I-L|1w!W9pQ-Jb>Sc9C
z4VkzW#(^P$cHA2bu4>vuxNX^R0vrL5AFufd*yPw{)h6uV*kiaS_Hz=h(>_ErzCT<~
z&>H@T(FfEf(Dg025I_p!KG!mPmVpXW8pG=4J2Z<Y&bGccH;8Yv{&F)!EOC%Wn)#F?
zskjJ3Hu@YBRtV|S7#!d21M_lf-@ki)4(Mc}ak_Y&e-t7KR|x1CP(rH6`>4jXuV-LV
zaGhR?7eXZkO$Y&bufAr*h)sB=Y|LFeHh$v%ZiX$nv+^qkjX0CBI?6jnEK-L~>kVGd
zO4y$y$e(9ZF(M4G2{E#`W?&o7Wog<wJeSFk#KEa?5ecm#oox&afVwFAhmbRGV<>|s
z?Gun?Q<Ue$6f>O2MzY5j%ECI>yLk7rawEYjR%W+7tS;WP!6)2U`;q1iTsu%sjhVL^
z|4B`<jM31mpT_d$+cP8x^h#8NKV40e5!^l_ydIFWAxT>p(QdbQtMZkgj6{w}>Wz4^
z(si4w9r}Q#(q?Gq)ED*I<}tWlnQgrJg0j$Xer=hhC;vSq3ehY-oT-5qq8-n+ji@qV
zMI&a}E?jKssh9d~_Io~{dvA$A-p)C<%F&Nj56Y2tbuHy0%HvbNh-&uj>XUT*2Zhqp
z17-E%n6Y<IBEfL-QhOKno|$0c*m;wd1e1|hAG#{=q@}lgZp=3yGWhXUqN&4G!`=7w
z&mK=xNiG_L+k>LlfQH*W(%}bAC^xMp&#a#L&C*rYIH3e?-`jIk$e3@ba#zpfiwKfX
zBPj|Em%>Yi^TpoZw79+=8Rqq(<VWUzDv&vNrZseH-d|?cUYsQkUgZq1x*4IPnxjJn
zl<URFeX<E;SkNJt$(Nx^ftx~eL;wtjHC2~_U@WVzF+&!)65Pgl6Rq{(L`X~R@=^6L
zdtR`7dDdt8Ej#(QRCiVB@G{Ua)0$@VO31M-uez|12!lyrp@R8YG`~U^*)w_4lOmkF
z-RaPpBALB$ne)7O*v~WNYpl9bLIc~LRovSSe7%`eWA0kvndGRMFznzVZkDe-P4ySA
z(<n31z|IF%sg4fm!^Fe3o2Y}7)eH_Z0fYJ*^MfN|p(^amTCV}}<@+#%MfYX6j;)h3
zPoy$MY)bSaf&tF0kGgGaJ1f*eaIc~Th|YqxOla1Peu?e@bNrS-*=NtZcls?gErMnk
zP!b>FVow&FZdX%&c5ATPm3rBZ+4st%Mm>u`_}?yb4>$CFFFx_jOI?8KLmay-2n3GE
zriz4HoC2fpA7z0?OJ&#}V#>&MtS>@V5xk>6&DfB*zzfH{tL3D9HZD3k9Vmb`02Y`Y
z4Cp3R0&j0}Dk=o0t^%lJO)Y>0C*iKZJN63j3_f%>iO35TXvEeh$T>fchm4LVcHzKb
zUCS)hKZG_DY@O&z202;32x>`PjFBXGqcJw8*^OVcU(vV0?28Fu9lRfvwwBfeFp;N2
zLqq-wBMw7N39OLogFLZs>6Hd=H65}*s2`)JGn41bo>h0L2XE3cs736B1e3~lt~TbP
z6f}BbCk)ViEzp9Sghuf9!Xyud?gAh}MFibD3kyhl4~GeF-PLM%wM=?TC6=IE_7vE!
zKDq&ux-cYQuTOR|3|5&qro2NbrctlqAjNo%1(%ok$5&ktLJ`jhL)>*V{_V&&srk#u
zo6n#JeRoBb*cf|(`sa=!Rr}t#;<3BlZW|x)E46?E00szTj|mKM{J?G%>8G6IAjz26
zEgW|@jem{6@x4qvtKvay(zrc?L(xuy{<B`%RmKmgK7k$4aU+3p6Q_Q_?Y8+1av2AF
z0%5upE}a}ybtpxkB~`UA{H8H##IE5x$gy5(ZO4ok1o5vgb;`$0UZk0+RYeV{?dQIc
zV*M_97aY4t{Z3#CZdN+KZB8@g!P-R66*-4)yxQda@cclX01ac9!ip9`T25nT#ABYS
zud7={!)`c179TM%YZaYUlq--bd%KZfc@%`E>%K6tx_c&mdl>gxgG02RNgQtkE8o_R
zQv7*ViV5bgaTV$wb!4-m?32<9KOn&O?<mBGA>9=eQ5%I3enzY82HKft?!k2Fgi1`&
zY#}>iFR3z0=Y`$P?jJt#XE2e9O+)#oFBEl!qXUU$Ub^=``DLONoWi1^K^(DG?)7XU
z?{(iiU!T|kDKjvM|29ByOimPO5rrckmy;)rK(^K={5mV=cD74#URCex7?DE68Smiu
z@1hR-Tu3klhXMtkOze2M!w23hYGH}Bp#)}xD+E{>;x9r;OZ%-?N&WN2C!f`Yx;LJg
zew;1p69w+%1SYBsq6W3W*!0#<NVJt<f?sCyIFqtAtkZM9-5UGVXG>6%b}>HRdAQjW
zAw;VvQE0=8Zz)?d!31N#Fc<ZgL1y}W(mBIn!usxnmK)x@uP#`owSwB1Csyz6${fJ%
z$GKciIJml(k`g2~21;GLt_c8{s0!z-Q5uhfMYI~>YWoi>rpPE_0%c#yxE?C80YfYJ
z5C;>qYPg*2D#RK$S@Zdv?3V3NNiuby%-V+HBeT&+1qQ4rD)hsBSjqfyIoyih@ZfVx
zl@wX_$HbLwN)H7wj9xCJ<+-Mjv#@*XE77Qh``!0toY@CX2*CjYwA8^2XFl&475LFA
zuvNmqO(|ikn*m{h{osfE1XU<P7WwvI@gLa_+=x@SYAbn1{Jx9bNKEiaP&?&nHnw`M
zN~lh!R@E0tPosh#)B*COy8sFFDDdtk&x`b15U(sX_q(v&sg`wD8rf^Sq}W2iTwr9F
z@&aQAMHV=B!HVjp@sbi((mfU3mNRxhh$t+aU0a)Quxb^#%yUmJ`fW+JRf4~$IW-EV
z*@(WCf#%k2h)HI*8YZfT3`r%$ZEW&wnccur-uOCe3Yjqf^626Hoqb_l{_T6ufYh^9
zOy!3=AY$FQe_@{DSbzFfcrpg6qot$1o~Xp}>Qdgm{s<$yrz%K$(YOCSzJao?Dzty*
zE%we~f9vb%eq?!H22a#!hKgZss2sLOptPz#dm;KVvSHOC<ifnFqOB!w*K3}t^rjHc
zsZikhi6cHKUmNLYfV~hkV)~0sd4Jj7MO)4)`$Jj^O}}$x?wn4Zbl-GeZ4x{*p9=g(
z05ev;HI0E!W47U1?DLH0C@3BGo`urR#fOU0LX(xbr!~flDm<~u(i8=$B|G{u%c-sf
zyZVE!c5hpFA}(mIsNbq`&ZNLP&Z>Sn9c!^VG&^V9<SplpU(3whuqHv%;U$(Vs;;`s
zyQ#-%y%O|Mt{(zYhkU|l?~8%blhralY=&;u$r><%pzK2(j00~65Y;Bg3rlmXI(nbI
zh#yzqPY01yUfGKx1Vqs{;dZBkxaqNTMVpQzbd9sWEkXGoodDpKr~eJ&rjAqGyHY%s
zE}eHsM7ae1#4`JrEg3Isy`3-XvLnm}tfHj=|4Tn0U+VyZCZC?<6(E7wr!fob6O!@Q
zK$<tuHzy~EtDna1#+I#Mw)s${r3e8DOgv8f(&{(J!PYOU2H_2vWmIS_EweVzDZ|sb
z`+$u`iGv2Uf{Y7<TOvw@o~ZF9922n5=TA^phm0u6S-p(2)PaO`g30^@U^_m_Q^|$G
zIRS`A^tC@X)L+t7E{Y~VE?Bl*+O8S)mJAm`EPGfA!^|yHxog~Nw(sf&?I*~K8VAr|
zH1jYHMlu^4`<pdonJHf78DUHVY`<dfsh{?Oybt^Qg}ZSKGodhv4d_qVM%raB3IpdE
zr+)4N$ztqY9T?va^do{OWANcUCbKrtz4RHI)i|;pg}Xmio=yv4XRj?r7gDo&TFb|s
zOKe#pJi6vHWE43ZO7j5hoyo{jTb8d2P8MKWWl=c#f#z}bZPX2ugr{hU^4{+i#<w0W
z(n(7XK8;N$`+k+>%=pxT24ap1uM;ro=6<}$0CIHnK@<T7l^=ZKKFD$BLBv$e#8d<G
zj8=GJz2wTTHswcmc1*XTaCCM7eA72fYTH_V)aCcN2rdwz?p|Ya12Q+jh>-$1Poh^>
zi}5<W#$!>tyx7MTCl_Dnc3++tgjM!hrUAA*k%vGY;n9wZGDh%V=nL%`yc8GAIj1}{
zpS&z-n4xa^s_piHLd!gr2R*?yQ)ribJAdcCkDv2MawQMh@KkV-w$_Fc#kAv!_SgwI
z{|LwGyxOPB>UhNrZ`GgZ;x0LnVq2Xok>@q7-aJ8#PSJEW9N){R3pwh3CT#`qV;%v8
z!`zJf(!;YyQ?nZfjwX1cp4`E#i!_<%*`xt74h+p+-2!{kR?po6(A|XI8<o4?UAOTw
z{nbt?wECLe=M8?2=FKhMR!?$DojlPQZXsEG)0_cD^kop&Fu+!YY@Va(*Lj%Q7T2@;
zxj7S_$zSWQ^T-rOB>_rQ>02>gZbEP^E;Xxg{J9r^VXR0naD1eUI=c!HY6k}DKF<Rp
z6d+5Q2?tatx6NDgc6Rc%r)3<Ujk4#%-wHJ7ljb~7z#7Oi29~X2K1#+At#2L}KEAa=
zFhuau6lkMTf;{Rrz-)eIr4V0@ara@4^|{fK@7rfD_eH<%BP3Dljq7fK4pV#S=&az{
zEVk|LXH)vhv&&XuJxY)-Oar4#CnT^9B{sbjp#Ka?VOh>Cv7eFp4wLAcv|M3g4g3uX
zV%Z3w6;5RASETLEDG^R(|5UX=`1+fk^?NH?b<X%_4&@CP33sRI?&s*`cCUQ?g;U;7
zUz2b<Lmcu|=lYu;Pz@@m(df8val1FQFI-MNtF<YtJ%iFS-I6Gtc}oLSb=iNa$uZk+
z4=mfq@t9$LxbR7O-3>Qh4B7~!G2jNo(<5Oh`Y%|uxW3RMS1&dNwT6zPfms8E)@_23
z@~yaT#oDW1_7q%U26fk5xKY=vpSt0W9ovmhOZOI>?)UjF3?{JJ{#)WGF^ZY!kl~9h
zvkcLT8Ml4+vibdo1i_O|K#G`CA&8|;I97Ek!>pK1y3Y;>yg9lKcW0}i9?&L{KxJt(
z&%pW6EEi0v21Z7l4J0j}J^{g!s~p%*YBmd9ToKIfV+ga^rN(6Lv*3oCRXdZ=4ox5D
zk9mf+GNvqVQXP}0-wMyJJzHKs;mK5&OGC;%K>0qKtecY<zG2Xg!sUzJvJ*5RTR)K^
z1V%X6z)wKa==L4~3u1G-`zqfwE|;EI2+KmO$PiYbxBlv&0EMJ2oIvZeoEJJ)3%|c?
z(N0D=??FDpe%+QVL00j3AP5B-5vW4Jx|}4HW{6vh?G2hYE8E{~o;Nt2ffC#f)cYNE
zGsQ6m1(*hdFq4M%mT`~If%r#bh<X`XDQR{*LN*_?5?g&MDy$=b231j9x*Szn%vtXl
zt1*=Ly+!T8hxuzlfq11WHJzi~cCB^H&||vNQwx&)H!YECy$YODe(LM#y+l6?2Vd;f
z@bRJhizM0+iUcMQ@+VCbWrr2Q<(ugvgvfW%N+e9D&(F0<varOQ4hmAH*sk+?iU^$_
z|Cf+ws?G!T;+cXl^txTz6fS*ykv!FDwNu||A)F-cQ)a)sLoO80sJ$l~YwN;yY5ZtC
z%8y!vm27LK734jgAs4`WRp_BS$)wBybEuwIMTokxQbCtvQufRziY(@LeEfT_ehyLA
z!QZG`Sq7HK%qXr|gkA8({>+Wija56iIr`B9kDSMQKjE%w)s;YuBEj<6w}xq~Q^l^a
zyA^${H>tS{b?WDUhd@^guT%WOCQ70{I#2RUNi|E4svoF`@bsZ?fVzNILhF(=>xv<1
z_rf{uRqi(0&e)^b#Hi~FcZ@9cu5W@*S{I5j$Pr7BXKFWX;I^3eD|P58h;yGjR&gnt
zir^Fo8SyTm0Br2MJsxIXq0w)SUxQw1eJ`1kxIlh8`r9ke0gok##Pk@kOSn_!S+`7i
zo>D4bO_~J3RD2M2Zy11*MZHf!en;PC&6(uU2kSjl%-S)pGnYk3{Xqk2TBW}B?Y@zH
z_x^>eJk>Q`)iDO}=|~_m+R}U)=I4=(VbqvhAJ3lD<5=Cjr}xFT`olnH2PuTmDxT6J
z3gHrTTx8WgZPV6fs68m&&|spAH^^uEBCfC5g56JQ+|Qf7Wobx0{{(gs)$)#je=nH&
zd8Yq^ZJ%ihFp2TcesF}}s|ttY=kdzv6V)oSxU=u-SW<;!yzjV?cMo{`qtfO)m284?
zEe?wBAp-PVkRsTm_VD(TOFmp&LQ58@pX>yjv3&RJ!t8q&rFw`&jvh^KDDT6ybjt6b
zV+p=cKO!4s+zp53jn?&Fnq^PNhu8w0qEl?T)|Ohvh^hOt&Up>mPter3P=LXdR50p)
zDT{f%N-rpwU6pC-`H1*C&be;4O$?Ra5F;mfKg!Eh2(HsCoxn*>St!4I5*ub`hx}qj
ztjDPT)+qnWwNGGCdVIg`LQZWW=r#M(=EL{Ltt#Wnkb?TB`-&ccc%LpqK4J_$4VTRC
zLhBSV>#GHWM}F+*Sxd9_=!k+te}dmSn6;7gTf0f20Po?ta*i&~@5%8`o@6<OvUzUt
z?HMnFF^V}5n_d>rrh-K?!DMZ5bCdXGx4SRRM#NgS_WOZT5-RxU+6*>fsQuy(<-$YQ
zQ<&I4OmY?x6r-q0fjCF~xTWr+SwKIVGu>6c9@)2m_bk8U19Z_M`?qsU4DTknN4<5<
zkS6_RHo%7?j5?7jJ{EZ|;Ds#bdp-t#Ub=1JGO@qW5<IPcwC=`|FiRntp4n7!)~QHc
zYk@!it@+)M#8UsoWlJ!Nx_m2W^c7|^P;Tu(rXpp)`20p&b{FqdHrLcj;Ll4o5ELQU
z{yg&3|AkKNkK>jMl?&_0>3K1p*#2zrOeOs&WC6JuvDRXnqNC2$9CD?+NGKSw|F@Q^
zX&9FOw9PhW2JTR?o96eJzBb_@V=SQKRN^OKMEH;W@MB!fqF;H$U*j7m9zNklAEW-7
z<gFwwY`mTm<AFL{4Tx>KIbQB8{_EWVb9uVTH$?m+)nEMb7y{0a<<^J&Y7@sxTtc@-
z#`(**<GvZ<Z+K>AZ&kc=%WRT{Nu(g&-#7TR2(j!n?hB#Y5+SO64;#Dw%@r6Cmv$nf
zbU?=SUh#G5&#%vCCKhoDx!i)fmpA$^#+TjS;%25_bPz#kg`3}PMkT`vpIo%Qw~EN{
zE9fU7MOH7~b)<>5nmQ!$6CQ{26%UnZczKoV-3w+pMW5XZ>719Pl^WzZ9p(_nnB+ma
zpGWC48W_KUk>a@su~Gmc)C1Mmf2^O)04WTRZjddgWc4aApoOl!m^2d*#u6xOk_Qe&
zuSw587#Mc)dooo~cQ|+WY|2HOcX(zFIN1#}JmK^tfvp+;@S}~rIAE63T3vE5Z}`x_
zTh~)|L*e|5)Wyro8Ec?<No<H|>FQQWHmIqih%Q)C{dOZ8gpLFu1O8EPWR}t`q`zQ*
zamgNX;%ZN{p|1_(&|A}vrY?MXMOrM;PB`xnfTwj$(?ia4km7p87$qjWm?TqrULYX_
zk<?n4>?gY#WAW$~UF5p)z{3$erDY|7VAsS+D?mpYv35JL2U;unp>~0owk?^#B>CB6
zYr}yDic0NKuM5z?CPMN7h?+now$5y6C-jr~;YZ0fYQ4F*vIvE>HgXQENp~DGZ?Rt{
zMtbG|&EZF@92skj@C@g&S4TQT1eO$1gNIm~qihPGy==|`7)B-{hc8sVRFtVMaCU6*
zQz0=qF8%Zyi4N6%`pp=BWWwfSHQbL9x5>UI?91;<M1O<ozqW<9HrG{GXKtR_uGUA8
zKRLQiZ_wt@+XjNXTiKU6jLd1UEiX(hcci~4Gii{V!4N~|0PP)!2m}JLfo|J=4U{uL
zWMSj}5dZC+LysMg{eW(H!YG;q*Tw^6lEY?)?}27BlHJmDvK+>jscHU7yqF(!lVbmG
z=O7&HK;J1$&Y&C<Og^}grSIv@6;D~5EYv4`xEv@NAOjri^GyQ3x(s|F;gE!0&XPF$
zIg>p|mdub`|DqARbaa}CaUpKi>Qi87K&OOOh-;KaI3ZI%Mt=kuI=x)NCAmBu+jl>t
zn70*Hn6M-II!|*iWRugZ{qD}do)VoLNy&nP0^tu4AuEGNHY`#v&dhWLfKE0I&=^Bi
zmRn&yw~^OZC#=4rPL&^5yZ`WE@||wnIlE6K{r5rCLs@~Qm2RNvR4ZUNvQ^)Z6nTY5
zQ3y88^4W#oKpm=}#9y?2Oxwh5;S@xiP2A%~Tz`s<w!d>#Vk7Bl(pgzk>>*b-6dYe1
z;<|~bj`+L|U3v7Y++v<ur@kKJDVUd}+`BaSn*Z0Y>+ND}J`~j7^|PXIG<KP{W<p!7
zi_L8>n))uIUUbKcwy<5FUE_=d4gfwd=PmA}RPD}B=NIpKJ&Cx=d3Tw~Ye4y)GTnxW
zC$UqiPZOlPCUSn?w*BXgS6F040}_f&1OsY<nKa!CSn$4tMc5GXns5Qo;169G)s|f4
z$^$>m2>Dg6NVQ!B@#>zIk)wrI8TD`(_&L9nP1h#Q@V4j&Gw!yrjMeT5aUkYR?cKzk
z+^HyRv#kiQJjraQpqUZ_`86={j=AKIXQ?H*AM}55rE!NvTv*-s=^6qw$xapV<Yb1}
z`&x?a)9U7!lQtUXqkY#1JQWdo-~5C$IjG~(j#<dK>|Bk8=o?i98}-9!ukpmI@kwts
z@419XzFu;_JmhdVlX();{#yO1{fo=I18$Dl^41$j{U~HRQ~xR@i%~hf6K=$DhWNf&
z;~?MWh?4Z^b0zjA$jUwo&f>ke7lEt?uax4+@ZOw2pQ0W3oc0)YNg8*>0H~wV%<~<}
z?DU(HK9vg9eb*3lER-gMDom~U&=s#*%v-#e{K=$YU0}krY`vjDNb@o4EDE}Et8Np+
zAM!m;8SPw?XXgbLZ}z)a6_=Uq*Bw_Rv4DBh=_45|p7<*7VTUxO_&EFc)8#T~JQIGP
zT;#I6*6LYL22^8GVrW=adECl&eB{TeSl|X8cL9Vaf$AQp(C;yzfr1kFDYmyp-p-p`
zpQF!9ktF)u^eUadD=WoyXTC*?#*edlN=}0>+}#OqYkn}f$urEGiX7a1OUjvvMO^5*
zVj0H|kWJ9*dol$rP(f-6FUf>thRaY%l|m_Q7*8Z<V{3eC3W!O*w)?v9$_J-0xy^Y!
z4eKp&Nb?X>p-JsDj&-|WUe~6!E_U3C<P&64m~=lL?}8<v>svn(+TC<B&7tK=QPbd^
zU)?>&H-k)w>*P0%EBKybOb{!K3$O?|p;G&1z48OEZX13jDm8%yLYREDYIZN^4OVSN
z@Ps<noNU6$THR{mVD-i)>G{Ju8HI~PB<PYXX7N@<9K%_d@X3kGPuT(5Wjg|T^14|`
z?rhevv{GNB6S+EO4hg1)I6aNC+H>_6P&gB2YFb{-(RJ-$=BPU`=SLNMTw`ai9e%ws
z{61q~*AuRJwILt3v!}%N5_1DV0RAj^;Att_HjU}8aMKH*pT`gZ2al2=<#l-SC9K{D
zx8D7bNm+X}IP%2G9idC`M-K$ZT}9#~e&qSDRJq7{Uij~~V-At#ACMN;>^LZY%sl;p
z5bezvm(3UzfO^NdUHE7dZ$KLQ+s{cc0=V{-^M3OQ)2tXd5}P%n<5cHEz6Ke`KHDB8
z_VpwwX<)cM@ScJgq~SR#Ea*euC!F5W(zp3CgjEk&4Fd<pl)A##KrshP{o};x-l#5`
zqXsCMQ$%@2`nJw&-jaj__rpwo?VG2rx=`A+35^wwOBkl^=XVlOF*CVa%L6&PoI#cm
zmI+?lz;JEt@cOL;DTcQLFUYUPysndANjN6)`Y_Hz560W=G@K;6tMWV<s?@1~)6oIW
z*S|rcJc;Qc2LfJw@A9+u1&{&}v#K}dxk#Mx-iYyoQ^6S?KG4o90%f#HVukJasO7B;
zaLR@-lU7D&>fm|;Tl6LMlSyFau@&4u9e*o(;(>=#7S}F5L4i*&HQ`$+Y<M=M2(!KZ
zycRHiHPoapl`!%=S!%IYO^;(eo@Ba_dhQoaJ!$j`3KS06yhalNWb@^VVvw*NpNdxc
zrtb_h&;0V_BXmrpjuAea&7*`6;faoAaH48WbJ`|fMuEs(yy^}LSKL0(68pIXRLRce
zfFlj{Rl%o~_j%M&7Bsq<nm^xDyC^(4gcAWLO&~ji`wRw&i}^h`H}MX9sxi_2@uv3c
zesmLcP&!kGX_@Jq{6*9DRG9@tsO2ChN=1vuZ5ZU^Sj{6USAADkS+M7npd2##bA!Ag
z>||jzPgNeJcTutq2nb%ch(sxH0{gZva`Wpz&$2mewmd1|ms|)52ht1NRRQ>AbfV&d
z+?Vbs<8SkQar+H2vq%PqkpoJfY^p!z3aS3RfzF>ScK+|7&;CEL3HqO~pZ_0U!yW0Z
z$oXr0nU5oxCR<w4?-VifWOfB!+X|gt)`*JG;kVQ|<gV1yV@puq7T9!&gfbt<J)GFi
zWKTkjORGDp=pBT;l`Zl0kiWW<(hG~a0qNQ~j^R*^dKl64Dt_jvVnqAgF*sriq>jo(
zQY;H5$UB&*hCSB*?s_%d!d-c+^<pLa1jLj@g`?kHmTP1r{36eBzbD199Xe$R?(x5%
z9=qaZ`~XGLpi1q`Nh=$Ij~w~tE13KW*@kZRnZ|ZdH8SBhmztRPvKp2<y^1A=eByCc
z$<fnw2T>(SfV>Mo0OBU!$BnqLX>y0O(yEVJEzEJ=(mZ_9(g$-`f$^k=MS38BL+(yj
z3xJI1wDJC(8IM=edYVg=BbI$li%Gd;cK7|#F1ff6QQ|;Zn{o6y8R(>007xAE&P-VK
zA8mvQ#`s~1|KKGI{(BeUY-**iaKPl|@4bYff9E0`C=d9Y0|wiF?<M^FAB>Da$7KJy
zg8%pLL8aU)B&BTMJm<KFx-jkHlbSb6UG)f3ws^?;X@&1Ue}1xG1k`>C3jJIav<&8r
zAZJVG2idGdX8tFi`Qe=2SZ<N^t6<UrE_mA|!XnJ7J^4_5(!+`ATL7f25MQx_=Hu~*
ze5vX`zcOKrEHW<4kI|KPBie0omlmJpXuo?fWRe0z>>ujCSM#se)*eh?rwut>>k|-~
zIsJqt%^-&*1(v`mn?~roD$@RwkMNkR8*T93-G$i>I(ISL@P(y*d&$J1Z@I)5%5A#x
zk3r-g;s?l5q(g|Z{*fzeZ(=rw)yW*`iC#DWaP$J>wN8xBP^U>$srknFb$Q&^SOW4A
zf%0#L{U0L6|DyG|9R!9v$XeZ3VO?l_VOR_KN<&!HOmmZ&kH<;w7q*lHN0%H0;Kr$e
z>08uGMNDMVKmTKZ%p9q1+kSi(lLfRF2mn(J;LO1xSEJ09r7XobWXU!@?|$#*3;1mw
zW(Cv4Q63uIzrWW1A0n$&RYVRX;w7LJD<rfTZxs2D;&36*jL}dA24%u}fPj4$j8z7s
z@@g$EnEbSUgF^6rgL?Ev|D*q3ha3%+u?h7ks?%_?G;K<ju%=mBir|)JT6f~8Tlkl|
z{J$Lb|F@tF0GP$x&eKf3FHc(>A{<XB?<2Gvyg;m<&R%4arBlS&cl|@K`rj|vDbr$r
z7<cy>Q=}>6{mQS6t$0d7UtP$ZKzb#R_8(k2)r`gja@_rk(EY`x;Bms>ds~8fbo_%S
z9i<*yK;Zjt42GaWw|6-)_WLZ=7Xuu+2RwJnD3X8Xm^~7sD)By#lbGFM(Tx3&w_xYv
zPEM3x?HDUM3)Ok1E<acy_Rn*Ve`U1^KxW?rV}XD*(95YVuS$kI*zRg>-LCg|(L(4J
z59yQuw$p!xD`CGVdQ2vR7is*TtqkCqq!mu<!H{u7Yn?dO=+fIvoUw?=qsy#79GLOl
zaK8QgND^D22vK>*+%YpVcCcLQKia@1P%hnZ)DZA+;?qzgms_k>ElvJMm3z?$kk~e{
z?-u>^46y6}U2XH<kC5WLi=(cck$aKvU~oqJEzMBK$tGyynijTJevpajxT7NWKbbQo
z{yV#0^e78tOAGCpYMF0m98fu<S!_H&SWgx8A^ygQ!0h&alaaH3K3cb9aS!_jQ{r)%
z>L-~4l;O0WO&G;;fI<Hhl5E9Al3#Miz3wY)0en}XxBYm(YDJ|oGX4VoS-%ix6tb&o
z@u1%=P7Gs&T3zc;TfPiL+fJ8JPId=x6~$;3ANW#tbFzX-1L)eLDpHK6xva(z&?IW&
zoqkl@DTy0~3UiUnpBqdU$}}yNt6da+myQZVP+4GXY%*)qZD&XJ$c2nBR-8%ic?U=r
zfKUDxrnmp=+UfqwJU@dhKLbn@V^A&iovEq1FTDZ|U<*O_dv}l7TeT`BCNQv`Q;zGX
zlaZ>THm>kj+$5Vxqf5$XirItv7HkeOZB=Wd46Tdb&SX9uf0cR_7vChM`+QsR0$}@T
zAQdU>Gv(2`KK?B&!?LN)&Q?R-4(T;j2i{n9f>!^J$Q9}x9OKx2ZOlCp;d!Et(Phtr
z@4gA%5~F_ND9VOFtW^CvPg=$Z$C2w&3#a0eDZ=N-cg8`9i0=8nzW;R({ukZ>gE+wT
z5GS3|JEPA*6sI}mSiYtuHVD~-ti*Q)`o*e9)8YO6Ge~(4N8dPgfE9hE&<+aGgA6uC
zsNmOYIcCmgQ$`9TV8WoQt+EdqQaVr7y^AEq%RW{U;|rCk1EktuoX2MSKO);fzOD3~
zev(siUd0M|a&`s%Z>qv^L)CX%B9_{7IX+vAw3wVV#yxBHRi=JdB^{x*i;)6n^5g%R
z$8C?X=}}~?@Y5*lEZ^4dERgFk{e!bEn|=sbAL~9hS6^fIU2V;ZJS@jbepPnMyQx+4
zZLE~x+ihnJ>eWRVZIbf8q8rw1>#U3-uVkF`{{XH3sGEHGQZQcy8E2UW8vELq6+WL5
zBfclgfO5`ENrXoW6J$G;2F2!i4SS#c1zghAg31HTynCM!wk9MmctESiup7?!ZY{A>
zelKrkb5aN^Uo@Q8!#k-nuTmEs9U6aoUi73FWcwG_HGLQ&aTqz%CRp8o7LK5=kH^`}
z^BN{SK{CN^#-WMWWyeU$pDRPQBIF*S0~UJH-pdGopqPLCwCfM*>EP@ZB%9ju&nQ*c
z+iJVzuBC$%r|!oEddH3wz+4UA*G6#o1uRZ{t`><Hz9-w`k+=^GSJuX~_*9<QBmV--
zn~3p+u9iRQ{-wD_4nR+phXh?qh=_$sLjtwltt8oDs@Du_QLR`UxWObw?>Z|a^&N8q
z1^VNHI9|>3Mbk%iPC~;y#dI_`y?NX|=n?QF?nI(S{}GA_U+c4=!&<_OOl?`<(_@dT
zof>23K#RIp;~nYIr|i8TRrHHhx@B4PwIk*U)mmO5E;;9uk731E#3U8|HVBt)i=PfW
z=w~ou3Gz=sw=JUo?qk(uh3M`h@C#GEPM6TIo{O}-`C928``|Oz#?{T|3rnid7yT8o
zF$O(QmYdTeuP3mI1arJSQO=u0vbhwVS?xQKpi=;s`vPcJu|*ZRP(5gn!~KB`KeGq%
z!=x|~Wqyw*>U<5c?D?wRZ^oQcm+#Idx~?U&SD8Zp;ze=GB!;8u&q8lz_1=$iC`o0L
zdy=E19bk?pU+m}NwaN-6H`PM=>NQX4ji~};)d#Oyf>j*>q<iF_7^Ka=L1AeC*j3e}
zDXLHAsi&uaqcNXa*QVxBP&day5y3eBSGcgt4eZ++YTT%GA_Dfp0rQM@fag9Qi53zA
zV6xUzj%%$b>^0kouOnSVtlIwuSG5J;s@?tbGd)ApG~s@HxxHQm-ek*`kITH)*R3i~
zD=hv@_xxHV$L&^b4$<#}(wLODmF=$BM(BbHT?qoU9KA}w*G1qj3Nb#?aBiy<pNK|1
z+c^R}j_JWp?nYzK?q7hw8!)aVm@}QGNya`OD^FLhoAtMu%z6@Aa>4e%InEu{f+WE$
zTSoV;`=W9B{orzl*I(Rd$V?dg5ju3O$Jkw_FN8wIVUcSQh#LBG*nZhj`%{1+0^>th
zw4n8edc8bx%s*Z?jnnZZ0z`MiPdbaq;NHxspua*m8?|wK(P=~-WZbX19;V~#?(n&z
z!$|ZOh1+t|VR&;~wEO=3VJz#*loTP+8>QJ!#j(^pUfEP5e|mbY1jv#6HM1uR+AhpH
zJ2rP@$X@~hBi_rMZ$41g=T2;$&@l^Du5c>gx~O5tGDkXK_b?#@Ed^uv3tlgb8x`7)
ze)FqW|1Kozap;P=r%UaV%Az~>6Qn7iQS7BNKxqK??d9Oav^cCfV8n&Un2&2y7{<l#
zXb6)?FU#-o{lyb4*@3wUr`YiB61LdV6ljaqeT(V-HSF3Bh<Mp{+UK%RA9kviy)#|r
z&-z&3+;`mVuCO@DraJob2jxa?04h!ocG^t~rrG?Aqs62M8vIT9(vVL1A#D;1Wh=<n
zHT^o&F!q8D-~Tz+aIKY<n3ZdEBpPTB{|T6T)K1`#MJEE+qT{&z<7?e`w6nQhgl;Io
z2Eea3F9wLYtMh>E{=H6^y{KIp;k}(5H?9S>S31U=JvT3}`tHR2#f!qVUbHmBHk0Y6
zJcYYyH=mRSk<^Gin#;N62{7IL{>F5t{qx6C?eJ>jZAXoduC^%GO=7o*CA4#GSfBmD
zbf0)`$RW`@QwG27<%;|QFx@8$6M?ln=kW*9-EA43^%u7rK7l-_L33-P2~n7C^~i~5
z3}rtCs)%lx4F$#bSGjy^6%Hg5=yrx{qMJncOrTU9V-ZX$ejhg6`q39J%KS9YRVU<D
z&8TB?=kcPX_vBqxR#yP&9dt&<54(p6D#JdRz&>JApc&_CnTTnwQTsv61puHEx+{%A
z$Mb(;fuCd%n>nPk-Kc6r^Hwj|AGYt){2S2y{p~#^)=2}AwY`-ahLE?KNLh)NN$iP*
z(5Jg|A&J4Nb>3lragV(ZyE9ByiF5t^GVhJA)dX?Ba2{kb8_rav@HK#nx>AISrjU8Y
z1x$i2{&X#4V{m130w8-I+ieD*?xSuje}lSryN&?pYk;rtL)qIP=43QdU*UFRNY@2G
zb=UdIv|*bR!K-qhL3Iuo?3Mlnvc4Bte4>#>x%126ZMcWzdsbi>8ytuxDzVfWu%mBi
zqXRPXj0X{WbZ}tE>w9ca701LVk5{kvUxB6Hwo^$cve`f1RqacAXH@$}vHEAUFv81u
zyZ;ANX0Ogjc=g9&UgZPcU6X<7Z51yyy8S=WoDF&;_#g8nN5~5cOoP{I6sg1&6_a>j
zd{l(~A5izUUn_KYd&kesAFU2USEmXiMGz=l7-iq5SR!~iSwgq%sBD<u7zyn8Uy#o0
zc4*Btzs_nDsc^UXLgta6zB#f#)-lNRYokl}MOMu5Z0#CiSXzXAUaO8I`u^Dc{oU@V
zQXurb&t3Z;?7ekdl<l@ZJcNLxbTc5OAO<NpAX1_NBAtRr2}nsZbi)WffS@!8NJ)3M
zNT)PI_Y66}Fuu3XdEc{*XP^C?ea_kY{C@BLV?N5{bzk>d>ss+$-<5Js^a?r$Ku6)f
zPX!lWm`#J9D=5{z?hw9c{<3sCkQ{plX0ht$u~O-&B$aKmP=CjUhFtjlt6LR-kK^4+
zPlc8H>((2P`8m&pxy)Xz@NYZ4ra7t1n_#9LtH}0nR+a??+^qsR>O}^i=GAa(3Kgst
ztTgZ>{-JUL&Dgi0?m^-YUA~QrN&ZzI`*7IxI?U)^rCyUH6-~W(rAQJLnFn;#J*+D>
z!n2H?l|~j<0TbN|qNDP~pH&t8YFd`-aJ=ANvaOLK;m^m0AMJm+YvrpD?+f@go}>MA
zGuCn5R1H;#<&x=*HOeg{e-KH$>NEu;*dEY_GOd6g2XQ-(pm20i@j0%c3&@wz)bA7d
zzQoCeT;1odq9^vSO(lB>40H$JH56!Tm|Bgp3Yqj#4{ykurn>hJhmX&1Nwdt!xtdjm
zHi!s~@QMT*Ylr7JF5MtXhQfyG`v5c0>&><aAwSr5pS^*<erwip+p2&g@{$SXbW=ne
zxP^AVQ27rG3{Y>pV6b`IKwX~Fc9dt6Cjd#J$WaA3(E6w#7VG5}Yx^m*UCmYz1;A8y
zzsE$3SDutYZZ%)_5!3xeCAS)w0mR>>a^^=!39~E(bE}X3I2=!0q!v1fJ)ZeU(u9%S
zL%@FBV59+K8<hV2xFD*W51Vd_Wksmkp3tv2juAF@(CeWAqSA_U-PA*+nZhku5rvV|
zV{w=7l$70TtB`sU(^B2|>lbz+$~%gj7s4+duHiCdbiRG_n=$WGWJK~reoBZ7=Gt%>
zubU^>BtCxIf#&g3Vq85v?ilev^cqg#ul{l2?m|QEVu4cm4b%g{iLEx18{d=|y)!om
zyMJR<nt7R8Pu1hiK~Hw6^szG0o5vB$h?lT_YB=Oa75*0TEY8v)@!L0xDAp0yiBvZ&
z?XJ-B6FjC?(ccx?5(IsVR!BVH?I~eJ1!&Q9S^LbiZ_!HbHQ}ogzk40Qf8=#M78JG1
z9uWLeuGpsQKiT&CO!wFe9g=T_K6}cK)LCZhYK!;_9@Hf)*}q`MvC$`~SKLhmZU2F5
zHGpBZlHwn6IvYpE`sqw(rb+`d-MK_1C}(}d@9~PaQCbOOSb&-Cmnk-sY`1Ob=}B1e
zEjq`k7ysZ&mu88^y?G5$C7<TnY5+}^JxTV=qsY}~r(U{+;mgQ!?*;B@Bns9Bq2sGl
z$dS#kxY_$YbE{&A?r|JUf@zmJ;g7CW^-Ed5ne8}l#mmV1;cF91-p;L_3ZtGL@B6c1
z-xOJXldT$1<V@<R(cpTJ%fT<Yx1K^)RHu>S>a9~}^fWFpq}ohz6x*L>w7H49+U}E&
zSPd_2d!<-!c3@F9;;?4gsw>O}ZiahnTA-P|!ec!8M@@FZ+BwjQM-l0v-a_FrWZ{CY
z1%myY{cnnSlF-IaZygt@0?;?4q&nbFUmo2x{fI!5J$qf#^q1hF033?Bop1>f%u1-(
zy+@mUek{$hDM!5m(EA9%LTX-?T7&(|a(1sJP74+ygWBH0m_BZYfeylc(YiwwoLSeP
zvlfI3{H;d$sB%>dr)ugIyLcZJE700np<^elH(N2HZXabhYFn<l#vc0HO&)FA`RK{I
zqCYSPb#n`|#YkGUG20AeR4j8+%v4<H(9P=C4#-xPFGY&LMImw}RFG}=79>Qmq&qEt
zU%94WBZa4Byk<$%Su29`ZC|)}2$fC5zr_s}I8zqsb&Z`hb8S;(6mC+KgYep6iQlBY
z#SQy_r!naxdFNNF?b4zp);kxNZ;m9XncC>fx4o<Zx;ky&#9bjifHzA0$y25QshP5{
z_8t)!W3a)stg-lSii{hz02SMZ{Av^CrI@T5BuBDG@FNbowie}NpFaW;4t(E2haEeH
zrzJ@R<4$nlTSa-Mz9$2?BU=5H-r}hCCz5p{rw<D93~04Q^sdfs1XjROs&ru(8nTWX
zr#QM_LG!nNKLyvUc-!mP78^q<Sy;m$<m)%N64fe8<S*@XGA$h+6#=k@fKtr6#=RR~
zLApL-_jsF~?ZBRzFr9`6;tCbk)K#zaUK4P1R&B4o=%@PtMSS$W1sz}*2XL01zz8L2
zu&kQ?5bEQW!I=JH%IsIrVO|KbKT5*h#>=XKYG@&5y5oL_9L1B;&PTV}LGH`c`~B!^
z;0U7wyz;N0Ci}0T_VF}V@eV`Qs)4)7oWn7avc1N4nEmbO7E`<ru-1Olx&Uva+q~)O
zu%SY>zIOWN>QY_>!rQ(!3KA^2+1t2aj0O<5sX|2nWfA7Ok5o{4olCQnDDtqcoX0i$
zUXVDsZ95@r#L3%urlq5q$=Y3%GGx66z_kJk&B4h`Z}6^0`68VR?z0XS+-IA5aua87
z6}EVgRR%n3U&KnwAerOSm41g6XSpBJzAg=xRs--moGAxDbPx?a9c=<ABBUS{V~Z+8
z>#9n|#*f+uMECi>tg=_kj$my$Y4t;X+AhP_3r2LC0w~*|2T+x}qd<3os9FWqe#NY4
zXHO+y7|OJgP(2;qtd#?mDD#I(LS#bnOuLMt{Y)M%MUp@X+aDQ@@fmAGkwQ>4pi_ph
zJrx|+#g1c<c++-w{aa1!c$5qwdtX-5MB%kM651`?SIzc~7mw?|f_OmdIYr6PANQ+p
z4I_oh<0>~vjDtO|;IpTz;w5;*J}u%{wHR@fO6Hah9AJOhue?4_13-$#Fl>ns()F8C
ziPXXZ9ZaiW5%FNC73k;#?`jH48$#E(Mq&*x`~oeu;YDf#5=J>asb7@xCU`bTE{R|n
zS&+;{FnK#+O%58GFTxmH)2Eax?FiS4yI($QOTVuuY$F*Z4zDu$>5G7gNI6Bk2=2(b
zCr$ucBO=Z+TK;k8k=-?d{o_g}Zb++vR0e$Wx8duPpV}DHh~CJ&W^EX*jBo@7Vilw}
zxc#(oBZyU)H}?ZL(e1;6%QH@6(7BQ}s=(&ms>OG}s6B_DuKIJG@?wAJM^w<BB&A}d
zmyos_@gN?D4LzU^qJZbODCY^3YKia{Y0t3=pa>=?(s`4?JiIVPsnp}_(hUY&0befA
zYm1qV+pB_D<7$RFi$#pC4P(5N3zGa-nG-OBD_C6kjPB7<haJ$CW>h=CxM^*K#s{Mf
zKwczrZt=coOZeL)vE@3A_npjLZ^;RebXR>R%p0uD4UpbxG=c7?5Bw@pKNeRKpZR)E
z8=LQ^k`9HPto~#LHtkvflL3Q-6f7c1Ut?Pa8hw5m!PYlinbg?;3@$1k{6Vaj-N#`K
zJPHMKTnU+aLVkVl=`yxZ803a{kSib-uD|Z+A<9#Gh2V1qq>e|#`?vwv7iLN7r3Nu%
zV`M>LerKRy)zi>upg?--?wjWk&g{&auYbBF-(-0|<pQd|O-qas5_+(<*tq`&6u|n$
zH%fFj`OvPN<<{stVtG1|G`T1@$B50K(tn>A+2O4ZWSMsU;BwOuMo|r{`kN8S+(W5R
zt=%Sstg?;lfDPyeB=sIIz-#&!n^$LUgvv&W%X{SImTlg4I(U=sAOS*WeQaz8CIzJD
z<f{-^0|5Hw(}zWl3<{C}clhPbq_mJ#fYy8JpN}A~1JAple}gbW$JGInGsAj#9c)3t
zA0TukMfJCfOjab1jg6O3+Ob75y6)2*JW`yGD#P0R&yNE(R6tt8m!xR?49H|-&BkV4
zcJu62_?(_Lrf!cM;bNzBz``=_`WX?g0jp^1)0lF85sZ-pl9>dMIrcr4RTv}6Zl0*0
z1?6kgfhwCI@aTCZwec0?44ss0q@2t_$+n0!!s_I&<sS=(yTxlcEC<|Ex!zeV8T<%J
zX=IEtYGtqsaH128yw3Nkjla+PpwPXR1!xjDtRVz7zF!|plz(fNJt6%{cPcgN%5b_b
z#(ng|{}iJB{~zB=#)(?Z?_D@EBH4J=67%N9Q*ox~7!$MYL!p<G>XP{am$0I#Lzqhh
zw83R5=&(tVbMH!wkF_0uhJ0mKbZ)P*bOpQjKU4Xl4lhC#DI&Tn88UZiCq>*mOrP~l
zo2MRAXPdc^rkP&YE~W8v9aEf$FjMS;14RIUu_isonqe#@bwX$-%i*Im>3||f@d3!;
zf$<vPq@p1O8}^n*G5SQIO60)-K5fK@^qn~MAm?A^N^6jqYL^T+tu~Hu+?q-w{7hBc
zeVd8!S#Xgh=5n!hudrs^g;yOquZli{B*{ip@nZkhMLA;l5$BzuXmPH1Ye6+-j*#Z%
zzFATa!nLb|UqJ;b$AKW{<V%C^5yt^e^(=73rNq7&6Bn4ccGRN8*eKAV@U2bZpZcI)
zgc5iv7g!sLAZ^}f<?0*gO?KTS|8znQyA=%f0qSr6DdQ2*{J8WI2$<7aXx^T3NkVkK
zi^ytx<NB@N%7RxDFyRv(@5tOwDm&-s%ID}$Dm0hYCuQxAEZ(mC1|62)J)i>{mSL@>
zP-1SkTfDYtAWt%@5>+avUN$`>KTSERA^ox;;n<8J9;@>zV$|a_A+oEfi{~`K-TUnE
zx({FdBykSqf(X|_mPOA_?|vMVSy>)m`ORIP%;>m=%+sVH3ux32E^8!OC$~(L`=B?a
zFyYWQ^9APMWr3X?AOX&D<&}lqAA&cX4d0*hHsARS&6d$S_*X^yzgpF2(L;vIm5tj<
z@S3@;xbe?^E-3zJzf=kpqLxs*b~95cDJM<d>w*Y;CD%M-##QqOqfSz$H5Bg^F~Oo7
z)pUG0g(>`+(q*O$pHE&gsicq5cL%hL-YUed23hFJ#VB1O7&qpOa>R6R>)0TJTTS-6
z$&KhrVG?(R&+Th(qXo7NogK3}3p{nd(SgfJWwE}-$IUTO1p5@-N5=a(aUs0+C)X>+
zO215%4Js2q(OaTtjXo~HVp=T#y%ZK11Daj6;v6%__6nDx$#AuJ3(*e{m_QHC*X8Y_
zZRXFzpZf$z1;pTaCls2`m!nJctZE#^-PC@IyOmO-$JQ7#;=tXSLa?dc%Q3v+B28`W
zq9&GM{yGLUbI47FH3V2LY6<Z?!%hqDVM~qx9>xGHB}qJ)+h}`(*xt{=FNgG}KSj$j
z#JM>7q`C<0yF>^X2xyNE?JEsMC1FL7)ZRG>pxl4r%JR-#D+8@NVy;49`Lel-)|TNB
zB!p)bANh?S+uJBYiZN=pTe~PTg2}CiV*7Od<83tW9cZXGbI|GJC}*;x!=+A+D}?Ay
z98p&P<P0WFyVjJ8Yn{zw<MFy)<)iKM<}S%MQH&vk0t3e0&Z~y(g9QgSLY2)dYHb2P
z^UEjn4NN_RU_StP>}2HXtPArS&P{XBAR|gE_gJzgt4xuw*7U_5nn_>S?R{KjSfPkH
zb-$<O$TP91r1yB2sRO2|w>~SWstjC3_X>9!p`6Kr7Ke5O*I8r<bj;7L@Y8l)1B)^N
zj+xF-xizzG^9`rXz-0VIheP~<sMIrtT0?Gxomvc-+|aVQyD}Mv6})|w4iXK?@-PEY
zt7wd*0xT7gca}thaA(i(9!du47rJz&>|NdjAMQZkq!N#!G8Rg+q*BeQG;}1&12b5j
z27}NUlA=s87Z||pWMrEz-OotcGl!Uq&$FbpBz;)lfeU$qP|6Dh;@ZiWGquX7CB5g0
z>9H<cdK@ui_^F#47O3)tdWb^x$Hw7;#R^*SA;ok?EnYtYoNV>s0ag480Umboj~Z$*
zN=?{R2Fmd9psnk=1P!BZW%J#({^s-A5f~;-vT(G53wMhFb6v-NIVk$!$+Dk+?LMn_
zx!ppxzn~lX22C#1jAXfeN|ePN|FLSjGzdBI?rZ>GW1*kf!khb5vzb7r1D<!k*tUaY
zH7f?Ma_2f*S!E0y{ut;AEUkTafhBW1!1K;vIszJAU|VKl6L*)E{6os2EuBBi7OS(m
z&>!AWFVx|iuGeu-4ho*kQk%oN2Yaub(gZZ@&UKKH>P^$Z!%mlFIuoewQJst2gk(8+
zGb3NZ;I0$v<G7#vZ{Yer50kW?_J|mV%opKUC@m=ShWAR%?yT%lCn|ACx8c!)%->@%
z^Y$Iq+Rv+mDo$GS%TR^#a5?UY%*t+v!LmS3DU1zA!3O}!)N(ux1;O0yrNz{x13ad3
zZmS);^=aqaz(h&sHE%K?Fc$z)8bwzc56Gn%AFIiMTw(1glsX&ZFHg;i-f?_P)JSpn
z$*RI(+8-EOZME(vR5=p2ejpmJQ&C}QR%Ox2o$;g;GbW~K*YV(bM~8v%%GlVI>>9U3
zw@b!d-Vaq)pkmt+<mr}i4b;Pjbl09l?OC&}+|LVo9`O#?4_u(sN$n|QZ|5kynKOn<
zd^g%h|FzEtf$jnbk?Z(Fq}`-<`-Ktt2^{WZA7ZA(S1M^mbSUT4Nmu{&=qV%a1RJUc
z0-Z4;iy)k+FPH1NJ83kf$PrxWH9{qmjO&j?iJu;Cj%R-&KtBMf<f3&DD@iZMkX|1U
zX{}1OVd_$C(J8HA(}>lGGCQigNU4{UtUb;A+b<;T2ViMJONMx3o@^P~4^Nk)YZ_wi
z;GNm?<h#=0NbbKI<p3sEfJ4S6<AVcUO}q{1ij23#F&0}KSi(4A?do=vXRis9c;xC|
zy9pE)IAN(cG1d{VMR2g;y!_Z{fc<NjQ2HbM2ApSAbK#Q_@lt$Y?bG2N+FC?Yjt(lz
zz9@~&bLhedhB5wr<#1+{47oO-$Q1aU#73eLi-K62V<Ja2Nq|{Z&pg_T$P96XtPWN0
zQUFyDSp+cr*fulHBi}5oQuTA{!L$;{OCS;MO=49dpIGi+Y+))_Eq5RhgvJ<ss@?^y
z51=YL9eVPvB;8SRxh$f@_<~OA%k#xaA2B03)UF&-#kYvH)Xk(uhu!Y7Ghv$@Qv?Os
zsvZO%vUEQM(`W=l-uE()>MfHRjX~q;B_)1iuACaCxKD60?EUbW?RyPTqCn#4DG+v?
zeg&OktKz5qE%>AsInoGoR~&Y_O^XRMs0XrLl+SnU>Zm1X;`a6Ln?;1c?`(P7$w;##
zAUZKh@xjo|Zr=Pt(}mu$BPeMZqel*hpX=73;Z@bVs|T!mBu)qabg-h9KN`qc#RM<f
zoo+x6tjFs#T(8;iJ$2*THV#}m+h%&A?4`IVO>-r^)VUXW4>6m3qddH=to%CrJ`;rq
zi@%Q-3CL0nz?kr<;6Mj@O@T2SU_=InCfm1h?O8EEaR@`H;y;lCHVRQLK>|pC5bXQ_
z+5$uACgTC!SBagNQ^<leb09U4dTbd%h@2CTL5=~(nh>&J<;sW&vId_4hiD+cU8)5J
zk}~Q|a|Z(2UqN#U=qtd}x$}0X^!d=;4B#A`_=l{b+bjzA#<fre()=wDP~iIhI<->J
z&yeFmLVyoCG_kHbS}-$M9U7n(^AJl^5*Ycsg2W4dUY(-#F~q(8(~W(hU?>vO%wWL<
zrL^3RN}pA^jZsQORS~}<_U5K`m{U$%_Mz12Ak&Q75W?AiK7c>O(7#Q+@b+d;miC+#
zKWRjhEIs<6-d7NF(RCzurwX0*C&Z)*%j@UUHl?_V3U$HnzJh8iN(Euq7L}ZOn#h&l
zr@<du49&qoRNn9Fxm#zMQCHJTdR&U8HcE@ci#Wuwj^se(TVGPim<J@d;SdI+lJ%D&
zv{AihQ^9@hl0DUnkf;Y9yS@$BmST*ZUT{(NQ9G>*#zYtx{V9tPvgxR>Vh(Q9x+(5d
zSuuXl#U>LF#a8~<9fWs5`KQ~4Q>5`&IwVa)9)trT)CH1?Kip{W4`SjYPRI-U@jgR;
zkP^_=l|q0d<2z|n`}yZSrdI(Fj_<`y;Rj(&C2a}o9XLGaZA)}(7~G}U84-njmX@9t
zi;_O1&id<6N9wnQ)~8xQ2S~4cL(Z&Rd+?k2=&A!IoHc9w9~Sg~mH7YfP{RM6tKc=2
zL23rWovLhT)xr*KCa%4|`66>q3}!0LNCh}8|M-XY>2X*YgqX9|S~o&d`9-@4KTZ()
z>j952(8Qn6iT@p%`L9*{+mZUsO8wXOB7cU=XsAvp`|UOh^7^*y8+02kNo&p$nVRn7
zKjVmC!J&U8ImiR+Ok&wLEJds&JVWyKyRqUulJ1JAR3$T>%d(ifJD}4{Y3d;V!G4(4
z#7D|))OKe}ihIsb=dM|mziNy|1h$KfiQ?h}!=|SS(xg)Z(c2!BV(!S?JM!!*aqY|W
zWJX*T*RC}&3^gnpph$ZGJ-Y~;Dy3S*l|f}(b!U1OM_h~Ib*;A5{Y4KO4zQZg!ibeL
z)A@5l6uYcj&K=DW76L3iYY(%x2Y6LQSR1Dz!R0;i$P3Yqr6vOHbuIJzv65uZ59yAJ
z(l+_`TNAm`9FM|#xjwnoc5@JZ_ReM+zz;x6BMDtowEQq*V;1=oH!kBx+pkcInutR$
zEv|1GzFw>+HKIU~ep*yf7d%>vCr{sddgq<*t{>TgLFTD^f+MkNf3~hN6+3z6D_$Ni
zEGBR2Ncf464R<SxOHg_wXSp*MRlv<#AQ{4jX%@g)=#>B?Z@W6mGH4tI#A9R6D$6e@
z;=V2~-BE#LIZnpzq~*Hq5N$u4o|@Lzmt_qBrX5k#DxB|!Z3x<hp1POCGhhO7#~1dQ
zd&_I^&@N1?lFevdv9=ksG%B7YizK7{d8q<NQk(sIu@v>neL<{YPZPv>`-o=ZOqtE)
zskE^9E8QA>8Vw2D5H$_Kub@yvmf%+VtiFhX+;)No>9|+feSM~CaYm3Q<3+CsSR?$k
zcNZX}-H>;uEXhx~Io>)i0c_%*J#UXWOL}qF)eSkFSzB~;?XdcE3<<m8ynZEq2CqHM
z$Tga>5EDEuxjXl)9A+OyO+P7))l|rip%n>+uJ%0s3Tgz7a-<X1T6rI8A9L5h6jR^7
zPu&M?SwZZgPpndoHz1hnkpNS)U3eWiob#jKhJcN27WzOfscn(Y^n4hY0?`VTvqb{l
z14KwemSt0Zx$JHHY903$C7ie;U_)8R>@W@_rud0zrcVEI$Gx@)yc6c)7-<d=i23}1
zQwly`YTb}?&UND`S3^aAh08(et<HG$yeb0+1y>Ue&c((?r-CffH8|X#s^T-li!Ss#
zBH;b^%2;ex-sNoMeFgCmJYpg%R07NB$NNcf$Sy=)SvxIH>fs>m;0hq=c^#9Vui%Ms
z-Y$RZwQ$a;9^czAw6(*DLBGni>!(j8qZ}y|A`6oe2+^4m)LcuysdD+sp3*Z(f$qgM
z-YQhuf>JpdnRfsCmLaJ(gl_lvJ1&D3M<O#03s3u6`XBmtmz4WWUaw_~U_}RN11=pR
zyWQgfdn>|nGArqG%w%>vWfN79+5l5@1gZEzz8C)(04q>{MP(kXh;v5knvR-A+6VN%
zWcAKGC^D->^aVmilQ$KM6V<z2e3ikuokD3g)^_ID&DOZ8cN$;be#HZ8QpJCbwmq8!
z4?)kf4TI+anq5jkqtm@`fRc?m&F#ImmAKTDsf}Z)xCAQpXtj|4_8Np|6)m@D18$C)
zoS2@}-*&B(uPA;$s%jrWLx;YC^C7)%^JiK3@!tFJV?>}I1|hRR3gKztY72OeZ5?vB
zlyXX9sOZ#BZdsvKNpoph?wYcovLj)&^gPQ+^ZGk?jkVM;0vb9KMYv448r21y0W4`2
zFv1$6z?gE1gr1Y|j(9q!^#B~a24D0d$9Y4a813@ETSU@>Bdv8U8O#FS>q&|YP2Q<h
zZpBVxA7*u$*O&w$if~*Tl@QxmeF;UDfnlEvIQFO$R6uz+UF)Zb(*qJuT;M8nUNGeW
z!QCyu0`BRdk@8~2#`Zu?I~Tj2<*ap5IQzz1udFZA%I7C+kLHpEG@qB9@d=Z0bqo<%
z)NBRa^oIn3+_>A%@izE0=ZyULkG8^@KI6R<OTKu-j)OSPqeQD9P6l-52Tctgclt8w
zr9~QzOO796oHrkaU*;DJlBeToWew{#x`=W%-wz7Tz9{hSJV6Y=_|ZYh%9&;Lhu$}g
z2<9=~PPs^=*P{AaJm#W=)4BEM=PR`+^TkdP;eHOH>f4LGfiU9i_pbOGw~VBHr~ppP
z7oZQ7r)EL9m%=c8L^;h}IvFJX+sVISEzXJ|m%OhH>h>s>)X;p4P28}2Oia8Wk0oIi
zyco98Knm?jfSh|bVtiu1w5D6CYS;g!Ym=_qK-9u!5TPIuVT=(n8TvHTLP?#JFN~zD
z%Dfdof7rC!4pRABm6V6Db1P`w)$(4~UHy8*Zs79Bb9$NuPPq%?FPbHg(kxSQ#wc#h
znsHC+Osn{;2cx4U-E4A`B48Q4kw0?+{*S&#3uoRalxz_~Zk?!ZX>B3c!NWnhyD#NX
zFC5|2@4lPYjKPO?%OWe!ogt?}YdEvK{oVqX8-3G=(}Is;i*U^`x`YQj`@0b-dmOR=
z#~ZKFIo%Z;ku%<hUqLBEMrV7C3kpY?Nnb%yG>ym0(3XNhX=+GG+3pDf0PZyMVyK{I
zmUH_H)?Y#1T4<gbDlGMXee|EXO_ZMWaw<6YsqetHc?&_E=rW--jnz3IYqF&H7Sp0-
zbb50<b>Od+7V(qO&*Y#ucj#rwws{Q+`q5?7N$0WI(Eh-p^AjUP!Hw^wgohB6``wEf
z-`{u5wN%2CFS;&h6o5aQi~W|F`A%l2ZNvWc(Qlgd58I~P21+?5v6KkSE2C6aiXb%~
z{5T$6yOyF8BG(>F3!uE|04Pu6ZxyxwCti1pZ-0~VRvqEc!%&l?)J)7zu-EHu<5tve
z1guR2(_#axtrw(;`83?P+A@wo7opU?6S_Pn)e9<H1>zV_KIrZzAm;=ALFg*wK#%|R
z$$!QU;m+ZysW%N@P|Y~Ix9M{WaBNB3sojo&*`O3$z;v0|aZH5J8h|MO+oTCtt8*04
zC4mJpAlnY$wUm}}c;B68(q|x6La#mVzC3%AI2+fD6u_KttXE{ddrb&slP0C9fEx+Q
zTzV}!_t6}poA?bS@^269-%h0xoY`U)AC$()j%NC5r?iEYUZ@iuBuEXqoxw~YM2J7n
zbMN=JV-<#9rgA3E&S7UAfqXeK+F!Q=&bUsLM%WeX#v`wI^eK=>oh!yrEtgfunJK%*
z8U<m2@Hf@fq{-WHZ(_5Bvf~%F<3M7Se!9fRkEUcq@wC}rMPWJNQ}a<_8J$V>V7&Og
zf_5jq*~!wa#?_%Y%sC8^N2Q9*^WlmH)?<LL4@6b=cVZ6g!PJ2Dmj&{fg@e#Fjj2)V
z?dv_-m1itzwv{wnO=ULkD9C_8U0Em~XTZ_Z+IYAWJEma+Q7IoPLtVS}M4Qi8I$FM-
zTEW%|fW-e(Qc{0OgHd<8sxPd(ULY}l42-Z3|6)G!)~V;k+NZ`_cJYJ+OUaqzdfKN7
zVF!}#r#n5$BPP|=Ww(<B@o&A0?o-GS#40xQLcYe_4S{ZP0yZz>f;)-ZafiwY1=}}~
zEW$)kVf`_xLBpeG^MMqZ)X@sBs{^fPA+>`$aU!T#?x}%mwoFOAu!~szJ1x*cbQUQ0
zKq@8DnwK}nj5U`YmxUnpLV9sF(mc4pwm1K@H|8NJVM6dHuZwFChN0x6v9ZrH{q|Iv
zpK$1tnxx5Olato4-FbLD-dx{~flpej_;xJE2ovW^%24|kx|TjHL-Zb{J<0u|#9^^c
zbW!8CPqb|AdtNy>8R^w?c-GOI-ppmuyXn;p+OdUxAFo9?9{a2hU^E8*5J-dzkn{cE
z6O5;LG6FTz%XViM4WMhShW>vwht2Zi9?Gbrfm&GfW$@WW;H+P3R{g`@!;+J6akF{y
zd|V`+T(9ZP3`ah-{6jpY<NUKmsx@KSJCmDQrD3M9=q!5r!vnMhj$zny2ae+W=$e|F
zpGw~ONy_BEZKSrK5qUPYsa+cO;zid`MDFpoH=2a`DfejS_byJ~tw?i82#<X0<v7f8
zP*M4Ee5~8iQo^z6WQyZHy~^$RFi>Jx%LrQSy`Dv4;BrOw(_P!B51ym!y_5ISR&&|2
z9wWFzXblj{dDBL%_PI9Cs^rY3t6z3Jc3Pyu8u=qbrS44)?b7QoI-)c>r@1;Z7ihFc
zgN#2905I`#Ko`V^E9pLj|LDiQQCQ<14Z`j`U<z18;=zZXo&Y)j;UTW!QM;*(8@aP%
z;``K|fnNX0Gf67*+<7EW!pnE_)Jm20e4aISEoPoMi@4Q)O-0%(&s3Ct8)#XLz+6Xc
z7@WtJ=aCD)jNOm-Ur$abU<AI5NZr}Rk&0%KK2CuUKu!o^nS_Ojhj3Qty;+G&eLBlY
zOc>kYnEa;Q(U2SIl>`geDQCW+UK-;`Rr%y{m3dbej>Iccdue73>hJ{{LlV>0qeod=
zT3Wnzw3GL4b3VPoPe&Ro3a`ld{|x*0|6)V^p?e$;z6CQy=XBNs*8L4Y4Y4a)<UF9T
z@!(03%%6hml2M*#jIIF9igr|wl-OrQRl}13zOM0e5?gI-!A(_pf<S(<0SzF}1=*uV
z1piL7ow@gz>dzc$|84Kld{z%9QXyV9SFew<WQ`oX*OFSv&D;epupIxs<SflHlV&Z9
zVH?OV_qZF&w*#l>DDh#!*}!6lL|Tk<e^+$=Q#*tGchgY+3DE4XK<3f~n6FSHA*!~m
zCN7(a$Sz0Jg4iL5!!2SuY8n_BnEm(J^cQn9Q4%C<%-)0G{lb-MaHyCWFf{oh-*diM
zxFi3~yPH04sn|vrEN-D5>OC8_nKde<u?~_pyHP2AeAwr<sh`wP?e+x0FA7g++v<HD
zgYzl(RTSA-HO_F@!P%Rcg9H-|&d(R_oNce`ONB2m<^irLWI|+6C~Hcf<RbpG@$zpe
zrszn}GfS;m@{)nHkMS)v5lbDoLk(}MGoL%Sm`l2wW?PM-Y*v7=U=7hOHV#e`?|GkB
zM#u6ItuC{kLv+1hVG<9r){EDVF_ewf4ZgV6g1CZ@=8bPX8J;`UjEcc<4WVzjLG!M~
zpXTR34f@1N5H3l{Uhz<c8{6l$@)sc$QY#TDtm66*-3?0aFFPzMiL;^?r?aO4SVQM*
z;i4hp=xruixM6sqB66|3EPB!Ml7QW$1EzO8vAY=Mei|RRYc{5b;XV!bO6{95wm+tF
zC)0Od{8*q&J?`8H+F&ruGv{E)sq}a;Wcqy7lCbGuH4S|>aG?>TGdYD4zn{!#VG?KU
z#NQPiXi3mN%U+~DR^z@T1)kop%uvYO&=qPA*KW%x>GIZble~TEK5q1v<4AQ>$m0Q<
zP4ZSvR@<g+1TCw8Q}>qS#`!bXU`3e0fSuqtD}4qV<5{7oI_lCDoQGkph^Qj2(uE1G
zsta~(T(j$B8nL&ZpSxp(s(=4dO7xEhpP?7R4s$oOaf{O#@DWJdN&c$W^P}@XeL>|1
z=R)Q$Oa9L0GC|wHC)_o#Gr$*X&$eVC9C(T-ucKvft{a-x%X?sd880>|p0hGpru#4#
zXz4$8&-N?I-!gXFVd|_9+_1m=`V>d6=BXX&YjdhFjUil3^@%{BRe5=mw9@50nxd{I
zNRv{QU53c~H{y-kr?woA)@U)*Kw}?GB@5li_3Ri{TP`p0&-|iHuR7nEXIY`NT3lSf
z#Jhsb4{6I1-Sl%_Ib<*M%-#2WWa-U{yzcv6F3U=arlGE?LWW9xl6mk`Mj*%0B6vZX
z81;OQX6&F880USjr=j;coHb<brFu#$%yCnHCr>zIzFu>`#ob^;*)oq`C_hHY--5ZK
za(Gy(>9E&Dj1m>sBRAswz>=f7E+HcB)Ja=Pb(MhNkb7jFtiW{L8|Ssopb&3A#SQdB
zXW3eNdf_IoCP^`3*nL9Kmuf`c+jL;g>M+HuXbh3k(;Jtubq#`7SJMs-axe@!lkM|K
zVk_bnkKm8(Ir8X8Q7=1G)Rj^TYrPhT&KY&eV|Y<%F<-bHW0UU1YWDA=$=t&irfUk4
zV_5=oEh=fCCi3k)DKU5S-;wo?9Hf#?{$lF<_BO;BukI|9ng$6+`(1ws>TcRqdg6hX
z^~BEO`BZB1t;=8&fs=s?VLwLKVs8<7m^-ulfTNiRcuB?5EU|wpDfyp%-Ap9p8f`n#
z!ipu$`SycJy!*VVHrXW8{!>Hc7T=$bfB63*ArxSw*z5qWaN<GZflkrApPxy^|05>|
zz^@o+LWwOmBGjU?=!nJqi%*KA3&r75@m_friJrnV{q`L00S-0Us%iR^r(vK6(B@=t
z1;Q|mSj?bAs6G?M)N*UZR)d4$T&ZiNI#NZit{lagRpwBYxK)t$!rM5(8^Y1KX!yEF
zhOa-^`8L~~y&g-R%cS}31lUz;b!;vl&{s+a&1J1~?hr?Z-kxH8$qLTl@D{{Mx^V3O
zWN`d}6xGPA<Xc_&VW?~8*;MH}j8HCOPt+NLKfBIQUbkyQRe)=<OjvqHn$>Z=e;9Vp
z$?!T-vOc7&8WDI<lU~?=>!$Hb4Dv}6GxBtFQvoR)KHvSUj>0N&I^fNMG(kkNPjrOu
z2vE6duC=Og*+oo>qXNsuSvkKz6O5l!b;8uwHx$>bOOb`4*_Lx8wgtvz;XS2+cQ3r6
zk*#)+Ih5>o?+;&SRhd8W9tMJtfG9Vq3ES?IINLPG^**xd{wKQXodu})h4SU3?SQz`
z>hK<mrIt_~MK<5{J_y7L^aT-^R8SP?R9RUOM3dM@8=Dbv_2q=<?G3M9TdiC39y9V@
z6uf*23RT0i9dy9N5T%b*U5itPg~@;DnR25<0A$<Uxg&}iU@TQoJzm|}{2V%z5;}2j
z6PSd^aKHe%k{<RqAA4Y!SpAs)lZBaw19yj-J-9|=m2ls@dC6WZlxE4RVvbu7+0Rhi
zc|SU_`8=}=xN0Lg`qk}%PBdujTUCa&$LJKE(xrMK@gM0tw;_#!Rl=OOhvL@s=sD!~
z3GF&a-JfdC2<@<zPw}-4w$eR`kM{FLC4#olH_}r`U5y?LM!@I4G!?t03Ga4#K3&`|
zaDOTwXHWP5H}~2@{=x`)ZFfJh;k7^1w*NOB@eg_psp7BOk(-0s?YLxQr4_H*%to#t
zv9$@_)%Q$&M+#JqCpY^W_@Q0VWaj||&;#QlnIb7v_cu|198r`5qTuJl`gg1t=T$i7
zDnN$uNbdM~`2@P{K<_v3O<+jv4XKry(^a&2R&TDW*HRfA(>=B`8f<h+v=hz`VHg~A
zR&*|)8Ghuyqc0Bz&q#L8J3xT`F2EfA<Ac`!xC;mS65S<fR)kEULJRKNX>#s@<;9Bt
zxrAj&zlR&?3&_lKV1VZ7lIPQcECb7iD}fK6bL<uR!Rl>SNe-Kvsj$X>3?S8F2My@>
zKX$Pq<hcKbGqX(Kwke(b{IXrzi4Md4)?*fr4~H>d8gyP`PFAPzYOR%X?DFSpD_$w#
zBJ+!@);_heV&sz~$PM&*?8L6U`V`2_m;vwzW2jrug2@Ja&UP1O#f3To?JH*9?Q>?P
z2tL^LedTrY0>}jjoByiw^evS{z0ybxUE-UcJG)qk2^U(|_~CCs(8hnk0{k}_vwd)Q
z;)A$Sw*_Tol*AfGeS(fi$&%Z(85#T!uuqv$LSY<{c;p}r79Vvf{`Fao`r$G?7|~>}
z<YB>-l!=^)PlwiRTXA@Gfy#VQ$f4Ign>#mXBop<?xxXN}ce-)dgF3&lh!p~LG;Sce
zTywGeWQ5_VkLhoHNpmEO=%G#Eu>T;iYxl<2&wT)&O-=-k-%8X-)ona^{i9Q~EeC~<
z{>j^l#f+ED=*<Wq#<&QFo-$AE#eW5brIL<?)z7O0_b()oTJxEpH!8^-hVqx+**yAy
zy*K+oWl>j(8}Xc>KWNu!TT12QOrNi5HR)=PD82+(CJfY+4$#b~CIe{tw3)`MP}GMt
zU|wIa24Xct6Cl?`Qd+%C=aRMcZ0_zL<D2vmTq~S9!vSVPr`VxG<`xYhA3RBrBs&Fe
z&UTA5eiyUd*uyD2!?a&DdVIY7Z7LIdeEvpgE4JtJHk@G!0I#93Z8X7Pjy{7f$$teg
zfZ!G%W+hP?P<W)~<f{Dm!&qWfH@i#x%-dB-(;{g&h(eVgw#!FcmshVj`GOIds{<cI
zqed)tsJ2v}#{Shq>7}D=*UqMHI2nmbwxtXA!`kRq1zqOi(#DGO$2e42Fgbf8M4AN9
zt|(jU{pj05MqSAk<kJ=+P2jsa<579IaVs1F33y}E*)Du*1ZWHF8R{vhv1Q8sHjwgS
zL|eBnqe$T92{WEnpYq#$LvMqRM?o(iYjJ0ziICLqv#cE<5s4P*2^_9S?!Ht%h1s3k
zMJAZ0VaO_wow+Q68o;NNGk2X^V9AB6Tp~JWZ{xmSv8M?sh22Cqy{jYvdS(mlez{bS
zmIk8WyNJ=aq@13kvnuL<c+P3J1QP}IHEA>tEXor!%Q^6<Q?WtJ;8R}-eXHmvpQa-G
zY468aDZgCp7gwAGuhqc98<}I}uk)_0g)_t~_OQN7)@x8$mL^NDWlSNp+}G`;da>mq
zuVJ&j7bA99ME|Rpt(1ZNbdM5>CX5VS%L@w%R&_Z2kNrQZI%w^>6zTnRy{4{>^DD(g
zsKm`j!xHx=oio$0^~i2+wSe4394?}*$$q)stN~9>>-QEkG$O&<TEd8H4*m6=Z<>rN
z4G#kscY_67Gai;z4wkcL_7G>yO82=G-il)I;T_c1LSIp#1R6tj=6-8LYq&^(P}cSf
z)*fqz1&=p+#WUpFs`i@j+2eMjPgHT8wAAxZngA!4Tw`g4QR%e4UN@Dxo#}GvRjisL
zZlNW}4?^-7U@g!#q(%u8SR`|nj5vd-gw8XGJCsdV$OL$#H)b=zE%hqjse?4r1L}U%
z>-mc6JXF}3>PMuWj&48K8X!Whp2fbMv-v-28fe?1u<{|IH}ZXgrHzEQ)8L)xy0=rS
z#vtw@$6g2MC2x8I*Ss_FGg>V%g)epeA{YAK*4m1R*ktdg;{L3)2Vg9;#OqcD$@cf9
zIn0`F*NJm)nKNoxMb=g3a3fO*owVfO5d5hP40FTqmeH1rdS{7v<c?=)a=rB@$if}h
z6io0-bQXZ~$-ya4FR7zPKs6D^A@C6)BMRXxtB{Sc)z9=C#w>c}?nXy=03(jn+zEMO
zhtKUq-uN*oe3ai;kX~bbInqN9z?^koQ-#Ye=iOrSJ~p<0-1yVC7qY_}(IGD2!^s=x
zg!RRqkoN(gsi(f<pY4!E5L7rKX0b!-B`n*jJ9|owT!-z&4#)E)aJ@7$q!oO^WylP4
z`fwDMl++2N7X?cQykG0N^-ibh<4M-bT~-JCsde45|F)dl9|b{w=DA;5CV+CzPYHxI
zp;a*Bb&9Dbd&PwihREU*E$-m{1K_S!gHhTw5cKIr3JMqKgJ=g@9ahHyuv-&%DrrsF
z5_G`?Xm{A(`~aP&1YRPdRRAop0nmaEO7;=k;Ee_}Haz1isJ}25AmmU{KwmQeW4xSI
z(Ae&v&749749#@_E-zJ+jlq%xBZ{4%Cx@dD#Kmu1Q~&zmAGW%hj1<}y-Y!-YthZeG
z=DeZpB|#^t|Jn?G8lWTJ@3H=Fn1pF|zwq0<2|X(!xA*;x$8q^-3qU@`!+vvJnk7xn
z;UW?&=cJ|V^&mD#hQ?Ngs`2}sFaISHTbxg7(MOT$T)K&`Rt@2w-#fvSuO0j~sRoLs
z^pGXRU`&f<<LS-ERE@uiRiW(n_Z{RsqQ(BB=)k^{Ie@W5ANHNxK)#c>0ek~F2grA;
z|8Xm%nVqSDAn$vj1v-8HB60uv<=++c$K8HR8~1ANi;Cro+J$7{$ng<!fBnwCw*9yb
z__Ya6J&_d1O2c)E^Mvk=!NbUgKxnKJP)=@K;#<6NcCiQ(PQ5~#EHM1M&fL0SO2#|x
z_|jXwWe-jL#Wxe?x&7dK2P*zz5n@TJ;e~8E8XS!Z*mrqen0B%r&kx{#82qV({b$VG
zfAk)$WYi+&Y6^{op%84jLKE|Olwf^H(OW_46ABVibSHn?L!knR=kJwi5Yg;HbhneK
zP=Q#oxfy&9G?-qs8<g1Im$C39dxIOpH7QY$ZHVp02PT|dh{u=gvo8LRD;Ra-@FH|z
z9gy&SA`HZ}&+2*V@)m_NNE6%^7(?SU6?bR4B8iv?kWI`dR9G+nWm*3(I7|Mkru0V>
zYp8>4ZFipwI3VF)m2I$AdS7#^t3}YOr|g|)({a(gVKcXbTBS^zAtgcq@T13+(li!-
zB4PGtl4}1ay@$6?ip5iI#PbOpcFEEu?&Zh!_to07%u{by%~m;1wKB$k>>eG!uLFi!
z`~V^_^#7@<2a@?ur^A8V&HcD5tAPu#IGvYc%_IpV$W_vPL?O66oMCe)tL2^tSq~~M
z&luvJWI*B+DlRz3cDZI?IK0`0>h3pQV{B;k^l*FVtts_suCL}4l=4$1bbt59BJ*F(
zu;cuYTFc>q{)D0Ydv9zn5-*yiHg(pr<dVc%mpo=O>M;fvM-7c%Q(aev<QV^;xx3v}
z>Obz@LEWfoty_H~SZvs0j{0y$%9y58yV_#WwgoOk2DACJeaNbcU-RE>;{p4RwORv1
zKZ4R+D`(rYY~YH}(Ld#zByQ`RiRU#8)L)IN6Px8m1n#6<{NhUWz?}8=RWar+neDC)
zuZy`7v~W(ON<hBQBVm=x&#Pc`w>~%W7K(c|VSp_5>3@_J`U&swX8{m@4qNs2mkPfJ
zPPwLR19_Fp6_H;-Mg;(CA;S>~J4U(!e7Fn7_+1s^V^kh9Q7ktQ?mN9b<-j>YbVYpw
z2ghG?kVf#a9AVha4;dgb8EMkLBO&__N;hBmAN!p`yVeH00W{wSD~70e+~VoEq~ZAA
zK62aJVy$-z4QYuld<8MC8FG*89-Q+mFIRsQx1~;hO6Z`K%d|&!544u|gDU>*EcdFX
zU0xEnrLrV@^6pR@@-E^kmk5udiNXvHvxh3a3`Z!H4M$W?82{%^5SgPARdFvvH)VeG
z$KL@<k!}?U`JFjvjuF1QE_bYLMA6+`5rGb}4*A~4_n^U^9+~SbRKqqB;hWvY6-JP)
z7j~Dvg6fp8eI&WUdWPy`vaQ8LN3T8O*Slgf{p2^_7=pt>w}z{(F6UGVN8OQ~77N|5
z6&?}C4#hQocOW%rEoW@qaBHZH=*>2_z_ei(e?>*{NeuaB)Lar*@FFv>VQowwxxJ0M
zzoYI<`*Jr-RSewcBSy$eWQeqlUszACtg+0hee+D*+VykH&BIRADBle@UUaTi^m>U5
zG<&88^Fe$~qJDM2IAzR7>_eEx8$Q$h>s(P(eIkm@^4{-Dfl@iedNM;rl+7JYlB-ix
zYK5z>&ItF5LZogCAI=d9y?ZgMYslB;;FY`w=KJEd<RAl%1ZY6N6~?I(3a!VaSStMB
z=Sil?&b~VGFWM*s)^1CTONz9U;L*DUt6D#p@}8{d?B<?W<pzlQhr*&};f%Ewg?vjo
zY_YN#xm{-LtYI<#Uemg|G5K7q<F#|PKG}@EylTq*1BmJiC}9^uGfQa4kI#<m)H{V;
zXWD<<;RPA|rsH8@R5ei%DjUP9Hv^07(U-9kNuOptAwv_GS>ROs5{dokn%Iv`6+DC~
zi`?i?;4V+x0}x{Jgns|N-rrGT)-@dwJI!kHI-yNCBV!6-<!TuyhrLysW=BR28*G}V
zCfOvN(vlupj0+EJ>@f6(U&IW`KMT{|;227qSc;brJ?l&a9fUj!gLB5wQz%YlWMGrQ
zuO6<jTtfE6XSj+yD7iU1tKZI8Hu$A^#Z9`FylM%n-Nl_Y#A%m&{VT|3_&vZ&T$q2e
zYc@a?FN?ZO8L8E3--;W4)a^MPQ`|x%kJX`<EQ+=^*GGECrV5f92o4!M6kyIL-;E6}
zoSlmV*{SL8gfANK>NN-xR%*ITxe!@*)m1*(?#AEGV*px;8%a;DdT_w(MNacvFV(>g
zz>5Gaix%e-B$;B}$inarUpa{w+_8eq%WgTCI~AAmbgZu)&MeXzcV|=WO?vSZ!<Feh
zFmR}(Ng$@~nk8$)Bb?pnu7E?c{phd>Soa8uc#z`}2itbd<8izfwqvIRZC}kcFPDWe
zJuTv3IGBN8WGWgD+aa$~i3HVjYF28^7dEjxJoWE9)yBwmcdtt`Jl3LjM2gE)Box!6
z34N&Os0*9B>Hp4aD*}UE(<9#Fb*GQ9R!38tOLc8?z+am3`vX&pJ$p@yVI_Jo=wsKY
z)44A186HlwpnVX?OI{0ESo3r3pE*0oc?wGDYOOM6^O3zaKvdPSxP~7?On~Oqtvhak
zAeCK@^%1Yp6)piAlg3-reVh?qjISgw3avf<(Hs45h|9E+*BX&Z=tm<5@+X43m#&WF
z2b)zHa?9+<gV%vmTB~j5`pRmn{ic}Js>Z;3gF92q+T5pYr~KwoC@LTi`nb&N(Ujg`
z{-Lt)jGYT%Fa55cfd7sdL+u}eUw%i|{)Fv!*ZAoPkk}8P3*OhL;C$iN3*u?y)k>>(
zqI<AYULj+&y=H-7Lh9EBWhj*eLz%3PlO{kA%6m~U@+I=0x|*oXL~&W>#}oB8kXBH<
z9g`^D-#qjfU6(8~c$m<2xe!<Tv4VA@O9x&8tu;1PeweK(ojdUqy3O^Mjs4l)yt)n0
zo8Cz;*#^w8;Tl=N)P1uO#bix0@J+&tPyFYiV*OGmJt0EdNts~lMCAe>I(XNePC~}y
zMqs3anVe(IT%=P0>B(~@{h2xP+O08rw<!EZX^2?73}9>F^k$XimT9#C&y@AvpsT6e
z7lF3Lmtm`i{dDWPB$GP5N8xYB4SK9CX%n~r!X9sDJlJ9{xAsU!!m^=`;m1!h9%OO-
zb5SY)71ANq_)WbF0=-N!Z>{2utEK!UH+kDwc!ni}qlw0&SKq*ST`4_dyzo)uSc^u~
z>!;`MU)vG8XpY-ky{MfsXkYH43OXt7Q&^N{DgE8KHnTRoJdBpIfs}DrjBOZQ1%r7~
zG$n)U9k-FP(n_zCNYmpAr!<iTA%XSHeb9SAp89>~Wo3qLMtlXV*x!~exsyNqA^N_E
zA^8Dz2^5uo!WaB#0so3ycY8O)8&Zk#dOvA6t*z`@DM07f$$F=XzMp-vrdFqY^c^kM
zy--sv&{0>fYyW@XSpj1!zQbYtG0^+Zxq<&jebyDyw0m;J8%TE)W&_7gy+^xSWouEe
zd$vDX9nSpdbfeG0nVXNI>9daaOS`u`__9-iSnEPR<PWt{0d)8e@tO3c@AEsFHzEM;
zq_M`$Pe$jsW25S$`FOb*hU?2mUhnaPy#*>Aq5-er_LR}dWxlT<<4%lxg%ns%)@I(|
z%H6Prr-r7lr1mM4xJsN-NKnaOf(;gy5w77xN~-~#Zbo4T$K$H?{`b~7h}pNou!SBH
zv4srF0yx1oJ*U!97Zp}Jij9U&!W!53n%eAVa(p?uC!I??$1T>1PY@F7JXbtIGc6gJ
z-U$z$64nFWA+h1QLYuc|#rAo&Bge<BXX3K99b3Ns{m)1HFRW=9G9lU<65Kd$2tHpb
z<A_}jWtNsazk(BhINzy}FoTD0i{A}@RCT6zXGqDRSdfR_M=iMx>nq4JY;fecr$Ig{
z{_e;UVoUgj>Fpc*hVsi99JcCRw>zK$x;4Rphe;xBE)2VYJ2o0SO=lWO6H@vC&`a!%
z-ZLr^@R;FNcT6#ySJJd?TsV|DbjHTqyw-Mi_ZCEEbHFK;;LyhW!7$q9#?iw-V7OFp
z7tyV-J2Zlepx3YJYe>)C3O(9g63<tP7IMqIF3&xb8!_Fx)5rN*JYJMN;stL;17f8y
z3stjgh}eo#=i9qbRZ)BGro1Sw7exK>A&kH^+o*c@kazQ3!a!%5BYIMy{>fc@j-6)C
zP@*X&RotjN4`lJ9H9S2@aj%+6>9#|buOI<$!x2xTGCw1NPKS*KC)%samEH~nn8rYB
z*OZpy#Gq{RLW@eZ$&DkQ^aPn(pWdMhV7X{afU&E8OEN#w%da!n!185-GG5pu#Tk7K
z&9i0+;(0P)n$I`Hj|5O{TCx@iI+%F7(~wP(lBQ7jwr%Vq*#)aHILD=|fV4}bv{p>U
z9>(4pDjgW+TIBTvGaGXb@;chw7ah-7sWptHn<UUJ70%(JLL_9WB_SVr>}@y{_2;oa
zN%vO@Vud4+;jZ|K97`wnA;_b`<l?%knf+<5CY|?dTxTsV<q6)66*Y0~!f(uaKJf2-
zlG+WtgHw8l?cRI^n;~Dm(kQ}Db-DPJ65c}Pav<)eDSv0g+WiR%$-`DL*aBxMY^<KE
zPGr8YKsdf&&Z1I*Cb6uNR+Bq*-_#){^>~uJ!LR<)U$uP_XFvIg**{`&QhzYA#M@Ae
zT)jG`o)f5bk~kRB0<>J$pqm|=C*211+d1_gtIM8EmbMMXh~wcxb>V2qg+_|?25{rR
z4fElpV&PIbD`ebE{eI-M(+R9`%;&o2t%|U@CNYl=UtLp<n43(+v#s0+kT-S8yr6cS
z&Z43zmZ@GFn}W=1F6%5rT(o^E%JAFHCA(7l|7GXY5v#$r2a(V=U`Dd^pp|<5tB{E}
zRig7PUs#>kGoPCcWV*880In*6hUeqgn2WnXApGH?6>IK?bz`tLD8=mhsi1CB8$SV7
z%!0|yY*tfA2P&t7<HG)?2Ig8sXE3yM_o<&!-O6jHYxm|CN67AF=b?-=E0FA{@KzB`
zq`_z3>jj0rdn-6h$N>bTvjAkW8Rva-yquY9yH1GY-4QJ>PhWg-@l<r|#%*}H(7BQF
zaGg1&jzuLyQAm5kK(Q$HmHt8p+M;ZzyCPZy&Ii>iX+#ROzZ0&wu_9;wR67`|$&ENX
zSma8{bG6eiMFu2uA`apll<f(E;Iq4|0MRWjw5B0Re8oo;#%$yobTqE?R&&tiV1fn%
zxj~Dq<6?aJ0uO)Xg6+nq$`txC506(2j2<+JRJL#T(C4n;<E|V4bVcA=)P70E9tzEt
zwYTG`qj|M^3HGShPuXcZs-e6Vo<gj@aZDpt81EG4-W$qwmClTb<-@eo=2Z1!BB&o#
zWQmKxt4fwr=c_BOyYKF&eYJC5W!b>{8@_JpcYK`|PLZp5M>5~g<kX|;p#mCyhTFzB
zDzy5wI4D5$P0X7E1tu1JY@s37qCdolJtbDfEpJ8}0H_Bhpb6qLbgcH%N}cn<W+Nr)
z#roJI8Kzl>?wV(8F9ZO031ne3G1a=DoJSRUp+=|9M8dv|jXD%jAMPnNT;k||1$>Om
z%c=7%6x<AVVwH&I$98`jp{d|6sGLHI(jC8F3kXwqoP`pP!*UQm)|%H99PjTP!k?V!
z|A)P|4v2Ey`i2KVK@dhHq>&J$L<wnzkWyhlrAq}RMjE6U1nCkGP(V5b2Bo`Gq)X}U
zm>~xk@VnV@j=Hz!xc9rC_kGU!_CF5HFyTGdwbr%P`h`*&h8<9wE)J|-VX5BdR6YqX
zG6uqjO!nackD0h!CznGCBJ}dK<0B0*>hb8)h@Or$f&*&jHcgz!UE=I_f<J?sQlcr=
zE`*&9)ng+~PCny}bI((UwO%u&hguz}I-IYV1U>Taa185#M)R%*K6e!)#Tx%I|NRv|
z-~I(lmI_3`gBl#PjsBo0n2nJ`L3}g~du-rNSn^?W3kD#wxT8a<7oxNTf>uKV7D@K(
z6Xm!~*oHoXbW^<P{SZ4s=ZwQNMnugMe?F0Yzfbfny!YP$e%1L=*hkmJ^p8qH4)N4)
zYQ{121eZ=8tn$e-!F>HWLZ5?G;v1B4*|OoS#34tuPsUq0l8~+`<YNRqjQ;$0odrkT
zX~-X*^xF@E#e3Gfv6dqFcYO-k3RdeV67n5By(@%@bc{<}eX9E;$cW{2qR9>~PeIW@
zcik+}-3VnO-eG^xX7wrec)|+pbI8!PCvU`XUvMO&jZ6ru-3xZEEB9K2Ne62dhlZm;
z5d07+WW-U_q^|SLIM}0j<uH4{(3fv~B$A)prAv;**488KG3Vnxqp=tTrEWj*_K|N`
zIwzD8v<t||3M0(`#3DIxIs5olPjShbtm{6CyO|mkjw^D-u^BQ?hS;HF@57iS!|p5)
zn@oKQv_E%oNXVg+#@(idbudT21ld%cxI7r0>xJO_Akbbl^?uV5*fnFf#nXFpox*P+
z2Z~*%G=OdiiLSO|<a@QDo?iRNS8EDOaPbk8KPbmO=c9(hdyFw1eM!Gvk&Jfh?b{ii
zfozXjXmKTkoz+;1?GU;S<8^mn!n##)irpGvLeGL_?}+$L(*(LInpgXX$|X9)-|iO`
z-8oObAC4PMkoR7-R0!uuD<ocNn{eI}bMp<XOsN!}p;6hMT31>aV%<n{&qFHqoW_2v
z@`*(t9#PrZmtsYCw33eqAU#N!;p2*cIwO@h+mOV-5bdPuft0CAL(VwtggmBCE#9}{
zYQ{}O?G!h7RNCT=41EN%jpuAfTu{hnZyE=%dC~(apj;6Hnf7TlX6D2_1LqE|Z9ihg
ziJSll8vwY|?hIf$vbpYmR?beqJ7-q6yDj65pjd4UfBAF?Bm9JEcLD4jSF36>D3CZL
zjjf6cxjI&9lhg`h#w!xYvf_?zcqmD88EZZmox@GMm=B|)0n~Me_@k#tsQ8|F;p|UP
zfpRAXxF#wo!ozn2n~#J!tn*zU>1`=!XK3%dp^4dq#z>RGZHZ<|Z2z9Gvg%({x(I=N
z=|F|(r)fi)y84R7MZJ{L*AxAi4QLKwZwlSDhNR82HDss~SgTI4BeD=CS~OSNvrN?@
zueJ=UtUc1Grz^pUE3~6E3^J5G6NsgTd%<(eo%YYnLH^^PLpG_8V-&6LE6%5R(O&h%
z1n)WAbv<{nfr@X=N?TN4H{C9s_z?!C(5Q5s_tBAd;uNjZ@CTs{Gen(ig~2Sf5_>U*
zfe-)(>ibnA1>q?E{%#4%vTM(69hiNWw7hn9Myqx#u0{pBPux?B_$^czmmy`bm<Pjh
zG}?PdIL$MAWQiQTw3J7GRosiW*#&>6lH+#KfNg-HQv2@ks8qhJ>r10}rztn03=3?f
zY^*yOqbKktLay{+#0(}^jdYNF4bR?2twx(e#|mD|V-FgHo!(6VOMYhz@P9gW;)w6V
zaN2R~U2dvIXjwF`nVHwgmVhj;#os!FB>+=2C|U~8S*<34Pgnxyb(p?vw^Cp@TR%U?
zXV4YTn8gOKtA}H!ga=Z8%ZL0L^!!`a?B+NC=4#}h3L<DiVTw?Y9rFx1XuiCgx_Ap3
z668dtJg^mD<}6*=W8QSH+$+gVh>}*WL==#Q)?b#fswU)jj#(#o&3hYy;_rTBCcHw@
zdKH<wMrmm?GFQ(2Z>bA^bQqTlH?YWD9K3ek%8zU9fpMzzsK&jJmO*M{)BY3}<7VCd
zGcQ1LOX=~)xIF2B^ZTR|@N(UL$8~?mR0P^D37zVuO?#6{DaHAO(*5U$)a=mv5_DeQ
z+pKyplsZ5m0@mZ(82CcIUc@(dd_UEHu|}|CDv+MKV~SRQdmXFqg-xB}2*QcGw{}#D
zpDM%a&W>;KqhmgUuzijblrAZjw0uuT_@jZjqy62>`t6lbAFQ4WcHq*urR8@27TFE`
zhBx=;<Q~3O3;f6zvUlPme6Rw(kC!Wq9-XAMZ`?oi$}Cai5MgW{7{(nPx~iLEbh*YZ
zSH3sNfv-*ep>CcWKF67PoJ*(NIlKRY4(VTUy8FNR8tT3-<h{As80Tp=^K8V0U`=r3
zM#FphU4#R(jovr_y8pJf6YKKWWU$7H+EyLDN^MRt;d%to!3W*o2tDdT4IYBFsxbr*
zKm^JsxOxE>z`0Fm0=S}|fP)9p&H7u|J%CCxCxH2)AEFZmrkQjA`2496(9}Fe53Yh~
z;a%XH08%j@P>M2kSUz%h(my&GkNg?8SRe|Vge1hc0V%>xK-VR4I(Hvy5soH@*ZqWB
z{QLd?2e1F&SAYh6-<Bbw#3c08C=_#J?m!H!(l&JCNs;T5cV}=*GsI69tWF3i*0Do&
zf;#c7#Xo}}2pRjb$asr4i+~%%kVR3MUt)x-syBEufdFrrkt6w(EFfg}TrNkr1nw>D
zRnxUrA&^nEdb55rhEib(Mf3okc+22$Xzh1L#oy#EHn(eh%M*e@WgOKzLB(e*fp@1z
zoV5OXx&3!-x3BrK*6^>Q2}dHD_u^Jm++{N<yu{e?M7y9}(3t)O`dbE@31C$qzhQUU
zLD4Bk92%y{GrcbI9(Bvz=FcCIi?8rREU0!mOxLG3(h*nn8i-u>_cJrZJ;@?niYHb|
zu}^YyBAysbik7XvYn3+}-c}ky!N&6%fw$TMc}j}a^;gGjHHd!!o{P$)tF&x9NLNY~
zXr^EXt5lx?9g)400a=fO?e;1pC#fB|t;=4=@JH+msK)UE0<I1gO=Z!W{Q#@y=G3Hq
zd748SXUJOWjC6e37N*^a>~}d<zu{KR>Qkmv1#i}IrPq@72JBwS6YtV)n;=;X1lX&`
zP{+T6@qckL`aKk6jM5nPixEbE8DKnuOlMl(+@DcT{%6nod*{%f?ssHuZg*De5*0~R
zOfeO>#?$&lWo%5!%e&6fN-sH0q%GxBD--#Xr<5<ZnKS0xx&G>X^q=s0>QOGdsI|hW
zYI1bAVqZ}8r>$KM+z7hfkgHMQaSkUcWxtU+aTlBVYs%U0mApT|h};|}28u5Z6o(v&
z5mQ7}L#39uz`Ts(gL)tSQ9V(OHJ}1=-rt2S!+7Itjur7n>}L>;=L?HkcYbIM9Ya)u
z+u6d>@{@Md)&o)9ahak<u=(YBcufX&`WF?*ui&t6vix6$i)5?*0`yM0^mSVKMdZ+N
z4dBF(#y9H9$w63NPcaJzy<90~zsdu)zOucb+K9Q;V{VS&DJzOD?YC8kQYma!`_z_R
z^01Q@c?r89DPy6mu&6xglWCDz+1MIcgqQ@Ap!js+zUtCnUSH0NGaB<Qj}gae%-Y>N
zuf2?`m&FI?nO@?l4l;Gn*Yj*RqUha@alt8jCUWTrccBe^g$bGCv^kCsZ{$K@Ya^2}
zMe2L~1+^c|1*5NSnM-W79s?WxsfYLLmjU{t-QYjC0kI%oEB^uW<*(((ekknV`W^Ma
zH#m&PxA({Qv2ySAKxPQ;e+KEH0Ol-Xdfd?1tkj4k%^M<#P;9KdK6gNB7$l4(LGUjF
z*>Br6{}}rHCqGZ4OyHR<H+XzZ-$ct=TW5@BL>|#l+A7w%2E8$axKlTN))syqMiuue
zUB)4NvAxJZ)bx$pgKD-jHZ9^Wu=>B9_x~s!TgHkz6vp{+bT;v^5#ki=S+9$84%!E*
zP{2({IinNc9XY{i{7F!il{)x}YrX{CQ=N{?>2>fTRql>iV{c&>gC=8OQIFFJIi~;#
zlvh*v{Y*v^Me=v)m^_V&gj42L-b{hd-6GyQoZAH4e4gbu5S7uG8&x;Xc+c9vHm^xc
z&tu2My}(-PQ;&=Hb$Y!zyXqY>Iapp%P#Pu#ikc<Pta)H5#474+pJS%objPGET~j($
z!3HsYotgYJi)ePR{WW3ixY3Xspyf*lF42c?Ozd|Cj##@-K06PcZL~i#C0`%+^j$9?
zg#k4BNgUGXiR3J(h7}y)PY$?p7zIthr7J?DSk*F?8|XHj?pt@z;q^(q(9pWV_KGQe
z=C~Mlpls4w4IPm0@AhN@sXlFC8u;CI?vKbEIIdP>ZtI_CDLRNY@@M3gJM63Qb(tQv
z-duxqWrd<c5=UTkBw=QdAoW|Jb_C?up`0#&967}<pgN$U=|(fig;AJnhiDdl2C3TP
zw-yTx0mgp`Gj3#=zrk(&Nx47AwI~#>28!&t8MywD^E1{?9-Wi^;tp88)P6M6g)j$r
z(|M|%r6+ex6k$0UY+R3e&d6IeQ5PxUPJ#Kb#EYlL!3)4B`+jA)MS(j(idEF7xL3^^
z%eogtUeGyG&Q&DWsh5poSj#Z=lEDh8(HF~4ElL*NR<g9(M0Mcq!c3>9h>|boWSCGX
zx$i~|L=n>ARC7nBpZqvszzPCyNQf+Pg!f^LF26EJyS{%nZ#minn=XcWBfV;_8RRPF
zdiqV!w3vZxNind>;w8zi-6@f@$C;7|3Xzzw-Tw>{2CXh+Lr5IrhU=dwx1bbkY^;xT
z3k&p})OL1eY}PpN;S^{exgc)-^)rX@ijT17ic8M%2`y;K>G!ycM6(OB_|J_AO<JPl
z6T1hK*(h=DzW5ES@85MvkFipCIQIfQk74#>Cs^y<n1OjA!!ThvaGEo@w_EgLBl#0O
z6Dn5{fjxEWwsEiV(X~QZ9^>BC3RRj`6V|p1yG@dGvC->{kwTLSNp=o1$}R7$Dd;3g
zLH`n7{~e6h_l_Jt-9PEZs@Z9g`VpNA4FndP4?=vf(5V$`%5a}-{s>#QpGPA(?!5P1
z^<WwHrFw>^6P^;pAIBs!K5CB*wJ;Z#1U>X?Msb|++@p#s0eknfCM#w;uq=LTO@@}W
zzXbFqUKs<hZpp0)b@*@A?#XYUh5rs~_^Uo$R^}Mo$V5FVQMBFyyDeXEv{0eR*%ooR
ztyy@d@?Mk{*!$K(*1;kGU?@L$V?_OKS%P-kMnF#-d59<}6VVlo@>V&mG0jQV+SKD}
zqp}dk9k1WDZq8YdcGRCA{ywr!LCWRR5sHSWQchXMdi=~<p^EF9lii^S@ya%Kb~|3D
z$eW(5E`1aOkPA+)$>ssY1>$Wp)rX4I^|y69EtpQ%M9s?J5_Fu>m_V(L116=@r&la;
zY=a;-omWjAo&`P51HBD|lT2eEXZ%4+3kc!fCgGsCTv!@9Mvlrxx2Vn8H|^Z@)x+Lk
z9}JwTdP<)x&5J)Ls4zBaKlM`sd1&l8NJaBopfX)B#!gBq37;0zmn$u%yVT_s^t#@6
zVC{5605#pynnl1UVA$@fvDt}V2K9f@_)O5kZ~W{<v}?*Iy~gy5i>0v*s<Ujx_)0dO
zi@Fi9b4yKQ6Np|;(*v7WLnE?j{V!c+zU&((5WM&|IwW7RGyYqCCIjp=u&ZYh(Zfe&
z@rP8~>&Kf7Z6)C8B8OPYGgYuHi-{!8zIX;MBA^qyodA~jR`cgr{^@HZ63F9AAjU60
z;}7{@JTF%-2Yd!G>BQGX5KM5~K1FboO?=*pzNegWie$L$wBR|0+j5Ts)r`CgC@T1q
zWYVNXK7{69u?LZaK`nAXHsa*dQ}zK?i{On^BrYZ}?pP)bIH7mNl>q?o=ZjU0{rt~L
z?8B9Z%Xm(a7_Z(;L|fB>mHQFXC63y+OL)uPf*4wV(%!JqC+wC@o+`$k6OQq4efk*A
ztEs*-RM_0af!<oZ!6iPM{k)#}tsgc^-+OoG84@(rnk|?}Izcg0fvo<$1ww1m6Lc*+
z4tHL~A*4<%jv;bvxihX)x#%-U#oqj*-Hv!NW|t4E)gifl=&&hd*1@NV{Pcq!ZXPXm
z!oyMu@j_g`oNZQgOo9w7qZwvtd-zsYfx?b^b8TXmY0rP*0g_}?e|QwOKRbpfYOkVT
zmI(D+l3?Y3Hw7j5h>jk(v=$f&#kTO6A|GZ}T!CZlDdTeFE{L;6NtcFbp<MkJS3oZ-
z!!nv=g=mEupSaN#lULF7nl--H$$rwE)Dizg2LFm&(N&#Z7f4AT9rK`zf@|idhFY)u
zOF<eT>t~hVub*TD(7>oJ-Bmu3K>;G_`(1gRA1D%!hh&?_=l4eLX;=H&^^GAVrL5H8
zIsw7Rt4GUQbkCx<*e8xyh86Fdq@nAYcn0I>OEyzfmoMhK<g*@bb`}vn*(ts<HY9Cl
z0bp*XHJR)d-pfh?YM3{_IdS8DgF00PBoDr#wf`n<0%Zwc<a9x~3je_=0^Js9H9niI
zn>eq7&(9{Y28e*VF&dw`A;^yHd9bi!5X&xzCf2ICCqSP_8a6e&ewM4gpx827kr><5
zoz##XO$f3%){X_%ViWvWnIbM`f=?fP%f%SIS2dI@KAeJxQb5iKE0t!MhK`7aWD4ge
zgHD)rLOa4`fV(eeW{t~PZd^;f@~Yn*3y;$hvi=4%#ed+c1P>&ZyPqLvV7-IAve9<-
zIdO*sZuQuqX|o?6n7A{soxF1DfV6k?g-}?#vXLcIXs3?4<`fiP(;@VNqha*W#;0OQ
zJ8UzD&TX>iqF7wpAHY-KvwEfj$ZK0gw#12$RgjV~b}ULJX9JyE`&QfZYU70h;#vok
zkMsqK4zLcU`elx*krc{cVbJ6ax~%mv6;FOto(wg#N)VCWphwk<xtX4mI#ot7?81Bf
zNrmDPcnjeM_1SguXtu~kCo5OKmBn3Yl(J}6Y!6ceS)gzCKd#_P*S<Jo??<DdIemaA
z6$HxA=wQ4DMIM3-GQpSn7#Rakg6?76R{l+KrHEENmK~&oe^i8TX{3L3?zx2Ba|{qU
zUT+@z9fY!VQ}36qUaV{|Bh7&O{WNH$L^f?WyIwx1i+<*nixIQhQEVTO2Vbe~%B4qA
ztz~t(r~`F=aRVVqqshi6{b_~1&if^El;G|X)?R>Vh5tL@?AH|bXK%scs0DFq6hON2
zZTe_7egL`4R9TSj{qykp*!JqVX>ei6FszJgEyAHZXKm6rzVF1<&^5r^*amWD8x~W2
zrYJn~nw{>sN4<#r{vykeHA<^a7b?)|x3g)Eb~ga|)}mcoy+dMgNDk}C`uYyzW7X>4
zw1yv|qmE>B^^Ypjj`5;~m}|<_;H`vYN_E!dIeuGVujnNzv;OdRG9_M9oWkxkfk%bf
z65Z2Xd?LD+*|hE!<KW)+ux|Ja(gMwjo^B4PFbUZ^(x1P`T@Oa@qHqtr9v(@Rah<P!
zzEGBy3#YAb8G2Ett_H%nP>g-FpIl!><5QpM@^(aY999bR9s><Q@B4%1sz{Q8z^azw
z2AS_q@8G{Ydh~9(U;yF9;ovPMpc()z-{>yB2?}>{&^zU1FpJo%7YAPDn!q*SW!l8r
zbjU5SPP$V}9}eYC(c=!oqTZTb8Pze_kHvm$|74ypM3%Ohbu)no+HgcSX#RLL8HF3j
zd7Hj~LrSmz&aOMny+FEGX|SUGl+PfFb0UONA_P%y>5U>ap1B8GC(xtM&%l!Mkql;9
z<F^OxVsak949ajKq-1>tjXOob?+Ypb2W#$goaYoc2a1cDZO=bhEu4n*DdVzE>4VY!
zuIDrg0fn`+xRt~Yk*1zPIMzbTdQa12@Ao{O;yvvz;s2199$(y|Img<w=G?fhB&#p~
zLAw?nwab$Z4?fnzgwyR$67Joz{hvHx358IhNp7HKy$a)UxJImo-#?Uoyp$4a5Suww
zCgMOoG{j-coFY$bGYEQ+hmo9meZH=!YXoM$XhhnXcg^n6$j1(GWoNbQ+bLZs?}}ys
zw}d`A8Ibt@z_$9c+wuR}^Ai1+#_Vmqr`Tx4H<CTnm;Iyv7q)kgLrCxx9wH~TIF3Jz
zQaQzUlv2JH7m1*reBDrHsFmx<&HSje%lw)|`@l{0y(EhoL+5+y&U((%7U(q5`-u+S
z;@Y>zKRG4RioOE3%zx6~d-_|z%Ad;Gzn95>bKh6V;a>>ux1eM_as4n?GmHl*PTQT9
zF~ETPwUPJ0lUiE<Koz;J7q5p5JaxeFMx$I~JlRe&c~2Xn;*Ei2<%(ILQ>reXIw&*p
ze^7h0q<39#-vat!F!8r}>zktrmJFHJrb=FKzt+yi*e9LITRm@1iGSk5dUWh#(9Qf#
zxB@`r_RU-o!xL*%tLV2~73;UKST%d)eOHkuk!hI4ovT~sZj5Sg4kB{E`9K3fPyN6#
zLT5e=O9+^rbpHT~MLli_(63X#sP+~<-7pzr1ej}dZPv+GN_Uyq03P3GP*8=i=$%RG
zLoTAWNGQ+Ht%;QP_6)ei7u;~Va3y7I#&A)@D7j~k?buGWC8cp>wA3m*U$vAomvwul
zF8y_3{U?j+UyJL1eft-cj-t?=aNyjg4d@Bx4jgAX=TpET?t(UWe;3fYk|e8jF+j@Z
zP6v@F6?7kU&JB;e((eer*VH38F_`dCYG=qU`<#J`WzscaLl7ZIBk6ZK=Kt;Y<x-*{
zlcPp*sOA9kLN1=Afw4KM`(eiKvpqi;)QUMURz~}SIKCy+3!*>f7rRf9uVs7&4P6^~
z+j4+$E8zpZP-i-f2f#f<CU7(!yeVV_a3F_w*&O47q>uQ15|`S61MniDV|Wn*AOQ)<
z#{k1v$#wu4garm<5|0(8J{=vyi{=1$k-HDZ_^1=W#^CZ*V{jnTzer3Op_h+5qxFwY
z(4&$MAOJLp<`|j;5UzuM(wO@D6Z}tq3%TD8dFXKl?2t4`ll|idvhxuX^zisWmP)#x
znNRJ5TQCb^2e;24`EvSF0LjTpIV3;nQzFQ;sC8EvmmWE+S=ujpsmKY?MfF33bC~SD
zfr?B|2vp71cG^U*aCBP0r^3;NFc)z}fd*87!Xf$E)q^6)`epTHJ+H3<*0&w(o2Yk2
z7FZ2jqbi?41!kr9LwC`Kmayl4uc-gRUG>$Gfg}9O?^qXH`*J<G0%g5K(#SV;h+SY(
zK)$he!O4I=0_2qQ1yz`)xPj}0#aRd0DG^RY`lB}Id&~VsfonR>aq6fXdi-T1I=OD&
zE&mj#>=|#u5iX7JPfY#?0Fxic$Tu+82P!znxq?$)Yb(+|WhIdn5Aw!-`<*fDmq`V2
zeoDVS9<33n2GCK4sy_jKwV~topD?2b?i2@Y!4ab>5~O^J0teI*y#>_*9S3CDYDbSo
z%Xcp6OtVrpS%vFB8gjiL$hX@B)VZs<K*-H&=w3bGjwxpq>ey~{5+eoqU(2BLB%3>8
zLqh>LFn0qrm<(>_8nY6F4g6ESyJuFuZb8wh6sw-n{ndv0SNvx>XCQ_*vZAy;gKj`r
zVy3PO>{JEVdXik)z3-DNg%Ft13$<~bw8~seK4K~3Y|9urE5stMDOP`3RwPzkF3EIf
zXvgPamKIH|J^uUH4IW{7O9#k}pVYtq(K`4B_Y44`RZ-C*i`=4&WiBXbp=!$@Msuu+
zs?&5YJLe_N8zbbtP6qT}Cz79Vs$VB0_!pVvXQ1j=>8Sh5O!6~O^^0UA_jM-w87TWz
zHv0Pm{KZ#5ME`3oE?9^7>FnhRA({Ft05aOie&r{?s-lzFZ@MAB+w4~lKI$raee`NF
zhw&!Ca*UjFlN!uXi$}J;_QGJ+;;qgUP2Q`IjG36j!<4!u$QOR;P<`8;`EUN6qxFc~
zVNf3>5a<F;UmDC3D+~xV_aIgD{P1uofux2OHo);)+u{EKhk;+=D?je|MFeY(qXVQ@
zq&AvHUQ`7V1hC<rWIe`$=E?FdC~6=reD5@hlk{#|o@nE9h!c;~$=WEJE~22XCo9);
zP5>es8w#S@MLpZQ-7lQ#zLHM_D5W^KJR!wexcf!3?HgU+A2J5|S3&h3j|ohw1M-y*
zfx$RGAYb|5_1E3g1n`Y-5{O+;gO*IZKOefyl#VV|?-H${PfF_+TkB`glkzu@LsPm%
zZ(nd2y^#mF4s4%tXLwsx+_$w1J5T_~u~#|Y39e=HfM-k_E$InoT+c0QB4yg%xiZ3e
zTHejBUK9ymE(l9Ul8yfmbmt$z`!{v-?*MQHDt2q)QHl=9y2$JCTous6)Kt&jl^*(6
zxOw7o(?B%~Zpbj~p_WJGB=H_|b6;c#0o>e3$@M^wW2d=sm0RA%YZrnYbOAcAuyCw5
zjv+DhpIx-y(E$BM74&ye89(|z_!0ER7l(^~e6`=)N5^#_C(SuV(cPdT`b_T~18J;_
zccr}oj`6^SKw=9(D2{#hx7?~fh|2m+gXKTr`D%}1CP%5|%1X+5ZQHc91HxaWcwfn3
z=x}7pWgd8KrALSkGMT2e*XYSvVJ&vOT2$UL;j`zD0tjMH3cqE(d^2DATGiwaUW`8g
zanpe|tX`Xgf~9j!TFdWt8J$OB^>@PuSi903)}QJYGO?FM+ynY@z_OJfv(33NtkGk}
z&mk~wVF&0d?c9%ZT^e=Vt#7gb!>Hz;&M~vZa}RB;Hm_^lum){^Z18Yh?)rxq<^M~N
z<rfQ@&UG5;B9yz}Cg@8{mJ)xzuVo#^R%389J#oap0P+TT;E8&$$GuA(hB@)iMg2S$
zF{DMx@`yF7=v3Ep-3BD6tc{1ljQ|NMGx2#bK!U1xpT{5$%?C(O{Xlc<k9?KK(#!fE
zM>I!ekFh675nx$03Z@NyF;c8Lm#gJ*z0f|<i*N?mI#|c`C9hrB2&SugssdgkV{bQK
zbs0eDYd4qC2i%#>uV4bEP4^Hsq&^EHBnuL`QvY!g$QcD|E{k%vg%Px08|rbqY<}j}
zWmR8n6Hzm!=(TJ>M_PPnvWAfJ#tf1Bb3%vlzonPHSn)rF_1{V_S<#(ATUktuI&1Xb
z?|WG4su;j$L7_tbLE8f?W{h3@Cm|Rojt4GTx=ZA0bo#^GT&tLYVfxqXX`2f?j{J}E
z3(as92gN%Nlg;K`<Dfj;ucKg2m=q&a0zrN!VK!K-;axrcnToJ0swztgiwYJtCr8Vm
zW_&hM(`?L-DK(slYt!^KhE3IYHFcZkv_GUWD>fLq%JD_J#luoHqzxXPk1)d<rZVSx
zI+)4ag$2vd)aT1GakQ}PD*AN&cGe5=AkW%~?JWM+sSCp90bC=|uEk-y){fz{E5pNa
zj;yrM8{Plh7~c$z{$MXy6ksB=U-Qf~t`d9-#oS~$5Kkbr-U)l14MhwvxbO0hGiCb%
zwp<hsHE2A<Osi7UhnI$Q2VOskSw$on8|tgx_rxrRq75>1;P-XVHY%<|Q9kq6c*6Uq
zX@G&J)XV0B0<4i=BFQ)U`ecwVU8KoQez(q0tL)<}ScueKZgbZ7RFu`pp1|65&IxI1
z@-P@r&m={DD(I$2Ip_^8bC?r;a`u9-g)f&uQ9oBz_ZjQcWcGRY-I;`Li;$?Tt=_N7
zkL#Hfs1-G%2?!J5I71xTG67tDdox$S)H{k;M*?s?R-)C$#l^Aeqk34C_|RSysja8o
z&PP~eJRPB#EE;$P*Rytc@m9}PxfnIzkqPx_EesGLv3hJ6=ExkE(x>I-nYO4tSRAP~
zrrNl<7X_}2aW;&d2*c%cG5{1_z87`B>bLxh5zVhS!p%|G5gWu`%e<%>0OFsdGFx0J
zCip<)+Vb9&qbm!$DUMd36nz8eCEyxvupBt@deXFQG8q+rz@3Z+jVG0Mo<RFmKqm>f
zr0(Y-*}OM+uH3d2(IFlVjddc{rTy;L@VjN-7w7lyJ#L7Okt#+Bcoz~<&7Tk{xp9g~
zg!)bKL=Amio*ON!m}>r6qBbT-9U7X=-4}Pg8<P^BQSZh-pdQx-z!0JuTV{{Zx(_zS
z4>BFk?m>&TrboJP6Ms!k>d_bg3h}(y6TZSSzRx+B`pq3(*csm`HQ5V05+51?nw)yt
zwOsXPUKb<owm48ILs>(6`&6Sl`U+?T)XU$MRTXVMdKdno*leYo`ocWO-BD#w3=qX@
z@2`v~AJK)9o@E^iQ^(Kh5Mq7WE=-wJ;>F@|J(7)-NBGLadroKNR8+UQuJvm4&c3bo
z=_rcA>b26D@Bm~M6YfSnd9I-;ZS*)!=j?@GzE+XDXRyNCLDxE!^ZHcA-fxV}5*Ou5
zvX|Uhuyg?8QGqM2V%LR8TAtySU`^3x>Q8weo7^6_a>#yH5$gvrN&l|mt_6JXZ1pLJ
zBmoBmQIsU>D+&e8D<7MYp+iNJUR)Ew6iw&&@sfpVuur@Nl&-|6YoA!^!tN-L-f1zA
zrg_-<*r?E4l1E3oS=8`FsB|XNJ4#Zli{FO)|3Cb${BDr%_3bHVSIFJG@;Ge2<l+(q
zDsih#kOGZ|P}cU>xWg?h0C@PN8OgsB6Z~~M{NU{$ICdYGo_fwx+~`#Ci;Hwj`jPdT
z*f;vX_gOWVA;IcmUQT2W9IETP(dl*3-XRS5gT(Y~ok)2hSqud}XgH}f9^~K+J?9|R
zv$R0gcY$SKpSPbiaMfksD0f<y|EEy%zoYE`r3HZ9X}b<EVmb8|(*Z`TB4uUKmUaO}
zgk1S$s!IHlbw4LDz(vC#!=(P$MI$TY({mv%dd{lJC??ttj)X3|0E@H6*Mut*Kb*JB
ze#85I#yWk3#&auykm}dS{a4-29$i4Y0fQi^IRYN_+l3D+-q|hXH`!kn>*N4r0T4jQ
zYedHTGNPbf1&5C=oL{|)%?O@&Zn=!U!U!Z#7oZP9n%m%NRL`~X(KKOc$UecQp*y7c
z4DS73r$GM=<LX9?IugJkhHN<#h!B*+?2Afx@^#E>spV^G_(wk03>1+MtVkLs-DS3A
z23<Pg^jCd1|4Fa20r8>(4`M{7A*AD`L(baTdM%0--q+2hKNxf?FnI_MA^>sMZ+7TU
zhFe@c^EFnov+lw{Z}+ruqnfvWHr!Izf?y6!<Iz-r;Z|8UV7Rq>Y`8V}i{X~8F<`j0
z4H$00fQRsx<p9I29Kgp1TkofN0HB6pcWk&dkO^pE<jP?<a_EoT3ZWRnUkta%1^^HO
zL@WL1R3$wUQ2^iD2Mo9Pe=*$p`;GsiOTFp_Y?+o&fx~Br>aF{L+`k~2)jV<xJCcu6
zqR(9J!zWR3Nb2tl1sqq40d5ufd?AG8)s$}_3U0^EL@&5AQgHwPn`hjZjiacVpUuQW
zr&W8Ib)_2J=i5VK-I$o@riv<ra)trcR}ocX?tWH@ngs9bbad1bk=&#N)eGQw`OWG(
z$=%duTZ*JnDZNLO{8(JAb{2IAd;ay>`PDt^ixrrB^u_Y|#XalG6&Qm4=L-7Sx9gwF
z4>I}Bh5L(d*FTrv-|zf?e6_zSe>eaH(wA`n7&yNcrsdge96%OihmI#<Gers#&xbj0
z7-RPv|IX2#qtgWpWVg-${_&Fv8^auMlf`>m8_W=4@I#l7hQUO2Y}Dn`wuL<|CXWIK
zsmPj^y(B+GhPmYBR-MAzsy*(5tJI3BtD$rxmYI1HY=1)8(|alW@F@3tt?6&?rx9pa
zCV19uCaRdu0!X~{27IhpLfO6&_u_#b6n-=r+}Tfyfn{ikAHZHl8prf&7{Y~LcV7%j
z4wYs)k)6$hCnkx&oouV}a?Np|n+&$itXMwL998gQO&`&7BR&HdtsIwQzb9u=uwW<B
zi8uVA=Z%8f!Y%W=6U}jW>oo}k1;<u)e{YHZ_%QH0c%s#w;Tr2EFTfqMWiN)+r+F(^
z?z`=ypW0&oXepuehh#=YxsypB-Psvfu)>_Gbe0FoZT^r$=Vky`<_{|Uk<rwD+u!Jk
zAVV6d#!9Cx$TgRoUhJyvgc0Ld6Z<y5tPiQd-(g3>pN?-RW6S_SROnHV6KL1}Yk@_M
zF4$KXzy!R1SB3wp$N#v=R<0P*0(1N5+Mo*{rNfoduvDh8!eryeM88%oxu5_5P6(#V
z3I@o_i~=7gbJ-{8IQFn_hxH$6Mr{B_=k6jy>>S!JEzB6oiUF_lmOR<z?iYa`5bWDs
z|L;M}U!J|a*9NGUg;p;coRbtaBlUISd0R^#nwgP61fGoO8&J~<dB&Z>?KpW5!axbI
zdB*tw*rW?;^{MWx<9Z-`Dhk!%GmW$Ncnz<oQ2HZNY$JfMwA+uDI{6*tpzn3Re&l|j
z)<1g}ZLi&hvB6^$p%ib-G(hKE6a)s&RxKBt2NU|mv~L}YUbgd~1hhw`x?03u8iY83
zin1xC*>H%T%Q<OHxlt_H^Ey1yCAjUf6n$nMTGFWw^u+)Ytn4kD@l)ldpg%`^`H@e5
z{5OA%is5v1!R1%*Of*bBxUOk#wFmVoa*XBq)3+NEWJ~+E^GwKZyjP9Hs|AFn3slQ~
zR|V}?Y{P%;?VEuiyP(*-o3Mu#IANbb*$zpn+}jsy)L>7M+zmdcc;CWywt~U}Dg&}}
zr+4?_h4f-%g^emf_WeKFPQrSfJAN}2?W|Jm4lp@KXC<aDJWmPi)1&B{9}wlgpE2@=
zbC4L<ih{vrHMY;~3IG@91yF0bZ161-9q2O*wRrg?2lZ<??Y^Wt<Xj1bFJwb6F`tkX
zVnw(vVE0`@&`%zvXSUzZUMvoe8Ge0vaUxigItu&33AcpJ^}FG9>o(@QfY||8d*w=C
zgACbHBPmDRHP7ZskP{c#d^MO~VOV`&%VJfwpELWD*1+VrBfCx0+I0F13|A^f33a{r
zwnI!q@qkuwTuV{Xe2cuq0x5CeJS0kK2K(bB1ia44Ek8|jMBB8?L%;4KOONYp%GI4Q
z`Q@%{F{drWv9(n0C1hk&rbC&Sq8*owilX=ss+-CC0p)PjoY0;`6E5&MD#>PrFM8+O
zPl;*Qap&qGq73V#*{jz-$x|ys?sr0<PTk#;Wys=&ms@y+)a8}JJ0ChSZCEy`PmF>w
zI7e=MSPKQ}ByWtJBH!iew&g5sEbh}taAjXBW`tbXy$tWvH?8YMBq2Y88fbYHyD^fN
zQ`7abIFSn0EE_MegXKV5yUP-E={n5;7-`3Z_T-C6Qgu7qT(g^`v24w^h}&(1`<#m2
zp~UB<i~7xTIA`<KV%lsr5^6<cEl&$lZm}ewp1g>o?#1w1Tu!vIA$7`YF)DM3(D4l1
z0fFZw=rUy-XA#McC<1L8184pypB3i%f^#qD%HZ`8`kRAmZPU8uc7uGKXS7UVsm)gO
zF?LQpC)p@kKvzXc3J$h*6NvWxH-a8;04m|1K`^vU<GPid`THKNPPcHbx|tK#f-&=Z
z4~kr%Q#VJYdh3Ut1c+!s5neV|4!WA%mBjWwgPIjVc62O#>D?H9c*Zb0-vH{o<b{h0
zyG`u6C-!yk)DPKVCUJ_%7df6$fS#Xjv=rw=8t$`taU%*wjc!K~!&9a01YU+SELjEP
zEytU#iqZp)fsX)=wVn!mfzkci!Y}p0AJ3Q>Yg|+1MUg`e1M-igX?`I9WnM}kA~@y%
zJr+*)<TgC!0Ew1pmbIFG2JtEGeMtf`NOWiy*H*JwsZ`$CFocxbtmO6`JOz4f-=eJV
zU<`pB#Ylf}8rW0|waPzJXjJ*Nqw;#V&8P4UJx((#*9X1{<K0s&>p<aR0-Vwh9f3hf
z0u?B8;_$(|9x^95{mHxRO&?As9B!hv8s;6cQoTD9A$aY%Xz>nLY0W-{BI<#Gu^ttw
z1foxmCT1c#C$+1=>xE>cg9ReXrQAvpmggu_g&y502gReoz{F_HI9EiUP)E;i-Nk5%
za@EL@qS3;_iP4{VHE{bgNT{9FeVgq8O7C4leO6UgS}j$ZnMms#aqk5Icx8x^h%#<c
zx1LPeh=xPBdSA1@sEp%%SK8iY!swAb;wH~D-ddrS?dd9588R*=+r(<L7M_VnexSo2
z*v{bi#O8T3h1k2+bqQM9;}HSbtQ&prHaFQa9YaCoKp|d1o350^@%C(eaAHlU&b?A>
zvFuTNb_j*39$|=HrS4^BZO^MN9V7%B9B`tWfhdev9#Ax9<O<{!mLfwMf<zRG`*JTA
ztlq$V<iDgiODRngaxmlesL(Fw{M`W;$*X<anzrlUMharC!kVB|x7p75edjJ*BN@jV
zP+V^pt7NSOH^wOC{Hhm?cCd?GFXg(ho0Uqpr@Q()Nr2^VN>5@|aFh1-RL9s-jboaC
zpz4{12+A6Rf-?tQxN_4WXU80DZoMnXlh>TDy!qr@CX>k-r7Lox_>0T$E6fr@h#aJq
zip*r^Rv|@9&lPO<E?pC#tM`CY^-$%EHxNF#DaNv|%|%pOTT<d76*eLuNDwTAbo>lj
z#s_T)b9kbfip7Ek!YA7ZwtIu-_m@90*LpKFpMl=-?67IpgHfyH_ihpLZ$rW84h1`c
z`*VD}rl;9Qu=>b4Suw!Jdo$ox?tD3B@=$gkl%@?cxd>!|h}*KRB?w4^9%p3*a_%V|
z&~tfIHTc><6Eg2RAujIa-kD}v?CU~emExeUT;5yQuB7c%1TRSaFx+E1WIyXnW9Zqr
zoj}x9w;#LT>HV0WIzlFTN^Fe@=d!hvVe}xvqK1Bh(S&}xem{Eg=iHw5l}W{&%&#=c
zuomxrXZH9I9WGsr;`ZJqq*|s^9pR!|F@o8t?R#KhIH)I^O0BZdN|y@H1gR?m1IHI}
z*WaPSw<#cgh@y%ez+am?z;eX3owtz~&+wSZCN8~N>Hw%0d<9he(L>R{`#Z-qKzD{T
zy^)YxPd^+w_`)QrIj=+LX=mx|@mS>^x~;x-D*p5mm4e8_NU<)3-nIxg!^b=ISm;NI
zNP1uWhOx7GRk4q&B+S;CL`h#04dOhRF`|2>jH~cltoPR{*#8i{#-?x7O4;Z3=HBK|
z4NCL4(!z{`u*MZ+8pvL-&s)+u_1g7{3Rio!ji97E<qMJ!a~SIs7~|_yeP~6$e->dO
ziBxPVoHP?(R~{@BoO9MV`VhIX5{!d?&81{!no`sV5XewSDha_d-7iX>q@IbEw9EL|
z2|yD$;Mwd6i0N&?&QzmxF9T;t0lK_Vz;fyK!`Etu4}vc{;DhOV+{NgCvdL$teQT%e
z(67==#rBhxiAd2j`|Dv@=a3g}c26feS8_?U`I}0o%F+Dkp-+8Q^&|q~POwpkIw|A6
zRnc%G%Nr;-WFCg8zZ-iWM$cmRKr?x@By=!0cc2(pVV+%sVQ6~UK2d|oY4Kdd(t`m?
zEx}}OYswIu{CBNlmbj0VadTAkR420tjkNmg;Dlqa!DPjrbaq3(o%YKL_^BOk%A~Q*
zhgZ`ly~>X>HuXBtIyKfAU0gN3eE&RmX|fO?%1+Wd<PLD=CoOCVrPT(w5iSbZ?f27|
zR`ZIB%7{6*cVqXrFozr*^}7Md7+KHjJ==@?itKBnuOby1#%{VdgMxWCjw%3;4Jg8(
zVT_@o8wj~XABUN_$dfI*ZyDZ}2c?hJQb4Y5Bh)sARZ-xEQ5)$H_40z=$V;g&WEfgb
z@a?I`UcPB~$X0bJKcHUN$0Mn%k0p*;yHt10T%W7hn$FELq|RMT$$xW|eeGcC6k-rH
z27NfW%yvVL^xTWE*(M^L%odtpv7@x`#{IrQH;zJNgI3w%H8<#MNBcS7kHIb3PERn0
zrJyZ#j@E5QE>Q*?r)nRUyMx|rq&ga%F8QaQ$DRYN1CeQ(taK{p(XMJg9|UZ?YhiMj
zNk7C=qC|VYR+O&6ef)U>aP=sb&kN&vaodT=1f_dE>b`W*(eBQ3ycI>0#VBsaRLxO&
zQU$)#OeYt^5@Ox#=G=skfkWq?na}qYx=O(e-kGnirEZc9I!*e}oc)O5=q}*iJ73Vb
zzXhBCBmfW0U)m6V71k7nifSrr_OKNbUYB*at+{r~Vy?NuY)H|GD4uu3q$s~NXhSOa
z<Mss-J)r{ypr@Xb3?E#EFPy6MJZ_<I`TYO8g#t#39NnM~s$K@BJ>9u_D4i%TaXJ(6
zvjcXDcc3Mek**5Gw~C1Zvo^{1EE9qimVlGt4<k{r0;a)xB>cJi8vyT7l3%|DzQMTg
z8MM6yd4+h|Z73_J+){s1!;tv8Rf>x5w9IwA6B#x1ULeO}ubFZ`w+jmQQgg{SZ1Av|
zt2+aU=J~@XB`2<R0klZH5^q<HNLX%>2=7|!LM6J{K(CzUY+Xn9bzhw|>o=#Smt0Lt
zdu#{F4pe$q37c%@Db(HEO4>n=gY^f#v#4S}s)4o@6K1xHmHFvW&yGln-(JYXm@H<Y
zAq}A;+yQ(CiXv*>vI=2}Ef`ydrqiE6Vp%=U&iZ|rVkRLjXe}^j>g7K<5RtAg=v+>q
z?L$jttlENU1X;$PQEqlcTz<{f5J#_hSF_;LZ0Tq*WIol2-^kQH%!JBGEG~+Fj^ctx
z-zD}dj`P?wZiT>(IBgDGc`5JQ&!Av9!1c7Nb>RS(rCL4!lUIOmk>$idNK6F;p4YN^
zZ3~{0!|!R$H^m;A0Lr9G4DMIFnFFtmNL`{7uTaJ%oXp*0j{}};O@D}^k_m4;p6;zs
zd<J#gSX0BhtscQB6MD4i1uE{_O{gVMV!g@`A&cWBJ0Zp^L3h*Q&<76a;T(}TqC`nn
z^Zn;!<)3K^4twA#R_n}1KaSF3!pI^&b!8`eDh12>>c|l_L`w;QrstaO8jV$IE#G=u
z^$^xZ4fED7d*r7Rk|rZ>#`WsK9SdS&8;VQf(DYQ06?yfBwng;{DP)T|<LFW??I4D!
zX!G(yYF{X=O<-mXV|h0Yqm7^+PJ<bb8MW_L`?=aPjkn%0#}LhqC9H}A#!~CLg@B?R
zcEekT041MCL3TxBM`IW3nhys-@YoqRndG!H>{5klGCF#v+hU9D-dUY1x=ZdeS%>2H
z;9x7gSDY&Cl))MU*TqzuBr%uHHoV<q<RdmPuSqr+yDCAapFNJoAL_W8Y(nLhnW6Ol
zt+q5VbC@%#nYOHdocvQ~QtM>M+2#l52)R$&Ti||Rki`~p_4&ZNg;*QD(VLyhGxSlb
zmSG7c^#(e1QtQH5NlM%dKCJmFUQ|bb<0MC$?&TG|k<mI;13!gJC2hP`HP~W+DI^@@
z7tMX>D0AGwttN^{*LIAP@ygaSZirz}9TP(eWyuFnu`_zfP~ay6rUiDtz;phbkNYFE
zr%Vy*ywCcU^SgtX5-mon*C|`~*NE`;)xh;;rqg$kNm{0?RKIXl#SL9f?T(ZPZL^f)
zZw_|?x&mBUV<F*+DA5N4aG8ogH-K|i6UDJ+jOE4yZwUn-KFfh`-OKo09b68P2Ko)I
zrTFc6?jv`YY-oh;jkjk~?s@RwB@n4k=3>G}ISxNTwhRWiy@n=5q0_qsx`P~yFMYD6
zblggErTi~V2Fj7bsEGVML2jgeI9Ej~tQbXoF27G8-{0@TeeNLdaM_h>y#i`QQ#Keq
zH={2<{1j*6<a(0`NvwYtQl>o{Nd9(?k5{T1P57T*>!zrvNVtT3a!astS}%kpJgv=U
z=M~?9T*>lW0lW5QlWB7(IDURlVIHga!;pYMFYqnmY9bNU{IkV@w##CWyTvb>>TYH6
z1V59%0{skn6E)dja^8=>pgXN3s@|AXs%PFLDsZ(ELx3EP-Xf^vg;w7ijJ!5@(up!j
zy?KtER%)^!h}ShT=3+-3nOTmMr{{toMFJr{#|vO>7Xw53L}@_vry0_eT8xrS<^P}p
z@#5Er7-0+DxsN3V6*~zsbP)o=Lx?}Hwb@uVP5E;7xTw|-9po^{h&e%qXQlqkQu8)s
z$^!IvmL)vMUZoLVi14PY3u<s8k)RRqh0NrjwU0^^ffZMIul+Ctjv~<vY08g~#}B|u
z4-Mnyj+4DQY_i*$t8UET81~4I>h7dY#zi;pr1IWui=D%~_hZu*qnp70q?gfMH2iK^
z7j=^xg+BO`3|Zj$H(|PsM15hh5BKa1=4$A3Y<D3W+Gdaya`+Z2;^U{Gm&v}v(z8w0
zesAx)c@~P+o{m*|02L%mQcQjVgdiH$#*zVjqQ%gX_keL`=!(ixu^-<$TGB2CO0qCe
z%ZK4AN`#%Q`BZZTcNYD03D$klgR+mao7tVVM%dGHxm{SkN8^JvW7(BjHA-A$0+<gq
zaxL668tfnU(Nvf{J<6KQ9*f#A%istHepbwsOJ4=;3`^UK)_aw{B+xT?ugITK^W{D&
z6tmphLy_#$D&PG8o0?35VqX>J%Bolp+isRVB+a(WZ26{m?j*?4jk6c=m=Att`MF5|
zct<ozJK&NKak3dFZWjVVvz6s`5w+uEH!0FmF#OKm&i*l~8OPNA61zP)#l)pnp)JJD
z8|hS&fpw<(`!MPjyeIN^$#F9TX}V4cxI<>H_du3?w)uPR7z8l}$^rWyNhS-zu=V}K
zcll~W`vVBoU;FTLqVUN@7r9A-ESQwKN->9>!G)#pCVLh!-uJ*p&Pq>mzbeWwMNx5Q
zQW2sNcoOF86YYs+{)r5nQ?@xy^b>cCLjyVN0_bWBBjQ9(3qvU|mLFF*x-$Oq9&fJL
zyPwPg`um^m@r{!-nNMtKmo%@F!YfKFa-7JlK7-ELYQMfy7vz|J#&qabR)*#kn)Q&d
zs)J+r*Cp(?-^xKFrtA0Hi+w8~_p`O=fhe5!G<KEsO}wQwxTgf}U%f$&v^ab={23$@
z{f`(+GuS}CcXk`TKLy!hP_JME`d4m#z`^4ze4#K$lSv`@>U;l%QB`kA44Vo$-(4B}
zH&;l{fB;jt_ZTkzEjk?3<1%B5BCeG=G0!=A_L&e%UVqPe>B$*A`r_*Ti^U~<H_S`V
z-|A!tFF8FP7i**Uj`VB|h4eXDiZuq(Gx2)tWsAb5x~`dg2QnocF5UP(or9DKU=g&H
z73)rXz}Qgp$|i40muAVvj^`ZNZ4o<_)o7BtNCCf<l&FTt$g(GIvfHev&HW{6;;gS|
zhiGjzdXT<K(+GX&Mp@_HzRj;Uuh473a&FXQC%i>i^lcXX2Y=Ai5jkg@Nfw@ANw~~;
zjoxUNnT!tkPK$E%{8;6Qe10=2GnN6Cf*u5S-mqxay@Z5jJ*!58&!9T(H}I~+tk0n7
zctFWQa{=aw2GSX$++n4{AqNbKqDypiC99~S?8`B*@#HJNmQIU=IZ-eaD?Yy-%3@PU
zdI_*7_C^X|g5&ss?sds$Q0xl;j&w0k|KKEirLO$tgg2{wFtgnA*-v**G>;F2Fw#Rh
zH^Mub#(9lLLjcF}=L^a8gZn%A0zvcotMUj<1OGMI>+;Qt$rtF;)5J`Hnph!bsw03U
z$S`u~p0~z>2!@Rwd%V5-HJ!@5t9r>csf)XL*~Mz)`7M=n8mhh+`OKh#Gu`=;lvm+d
z7jav+wi1Zwr2$vk#wm;a9Uq{62~I=@z)tS^xzNLGD8f#gkLrSDahgMQ_iOP#^m58y
zwDPu0w%U(o_Mp_IlMfx@eep>7M!dxh&}NPdWKz$emS3L4$Y)!YcvRMN)<fw7?)|>c
zpmFJ*EOc2%y%K6Qtvp*ZXUxahoFVLX%m6Dbb;v!)39Ft;VT}iIyfod+zD`*gOdEU@
z4~#`4{my6%zs(p9xdoKjQOoD!@chhHw+Km~{oB-jCz^5OEpe@(rqxp=`t@-v$X&mn
zcLyg^AcmzHl8j^*+~wYmz!{cx`w_3wKj!nl4k|1cxO3*lvm>eOysS($<@d69Ocwy9
zM15a6z8-!s-pEH2^_$LOb(t2I&M`{VM4AgO;PwsLC&F7Q)8K<C`um_vhMt0DhnZjk
z0*x?eRVIFhMFw_s(Hk<U3@nKnkmX4b*Z<M^<=ZBX;qn+|cLmgftg7%n*^G+#mgecY
zqN{OuIfBXZ59E`TGyKUUR&a03Rai{7bJwVm4@T!y&UBC5cpz!&-#}yZ`a^}foSE>b
zR->i+vk2@A^AaY}E}Vkzw6eZ^^Z%yb$wE>ba-|1z5i13ivK%on(tgttHk7S2Gftk`
z-^j53FM~t>3TMz63~>=Xx`_0ejVR@S(_Ma?LIbqnW-jcsQgkNr_w?DcbW1Y(k$hN4
zjpVz)`&{_Ua~@Z~e0>Huo#Q*CPt1j9We_kA4kQ`xKaMcOUk-VMi)@6cdpLMDIYl((
zXD$rvgqb**4IsFg-$uP+e0i2Smaz1GEK$U|?VskL{@FYZ<a0r|-;itb4q379*34+8
zgPWD>Sz5iT4VhbPfT2aX?vt1dZGahsNH#tIm_eG!7OM9{F-vVpErG#_5#IQr&*f4r
z>4{z!(B9NSimq6tDek-${fQC%0<4>TBYf==cGtfGIsDnjHphW>Pvg~TLi<{ajiJb+
zzMf_a7U_cqy7z~;rTqF+xd1bq8Yp?M0bPhk2+XbGC`F%}sMjwZ4+;}Dzv9W&<kFvw
zfOFD6rfNsWSdop+dt5e~(PW5G<~fEvG{`d{6Hfm+R{Ara@sE$9enF~#dHTTys8%MB
zJ+cCe{X>gG(BNAW`i+xsfxPDM8MH;L6W`G3(}^Ouk(Z~a@K~{6PIr!;_sQKr1IuQu
zmF$TFu87L2)v>##G4BE=4EV74e+if00@nVke|I#hr#}I6BSYEy*>Ncel8-A}cTvoq
zk>8{&r7dBsR617ea^n?Ff11cyE4LGo%RGIgg}=p~m~9+w<jYAIoMS{bntAW&ZZZ>7
zB5+_j>hG<dKN>vx4B|$2A7-V)I}dXYkMvQ9kRvkvr_~FZz(KPLitYvgceyp=Tbv((
zT+E6A)Mx*G;tyV&9$IZhY*yt$?4xpS^q|7m7ZTPe&KG}b;as|pi&&CIV+L~99<TID
zuCix*g;Ts_h#p7`e^9^2!Yp!%R_bHZ-q5WCBV5{}2!S2MYXD)sQ@y(fZ_0N&hdy5i
zOkwNI0D`hgSI%V%iuZZ%m#iCZ)ELFzQipy0mVbYD|H~G(z(iXXn(9F|1>8i}ng~9d
zm@D;$O588a!L3GP@tT#EmN)n8^(#D1(beCD_R{gAdh4ik%3Ra^re!?u1g}xhHi2GI
zOqlP|hNRQI?D=xD4kp2<0N^_Twn3I=qrIsHB;ry_%K|J805hvkSnQKOhOdVMqJ153
z)5Y;kU^@I61djrg!@h_UgFyZ9RW$hfsefOlzn8@C?;KN$XFbi=(x=J&W$c8*&fc9N
zp7kI7YQyjsC!&pHkbQS#l1;ianLkiTo^6^Ee&o(?{5zz9Ur%lv^W1@YoG5i4afV?%
zZLP*M1;UEwL;6yp^)>{=&xgH7GLL91m8>23x6EwDc#+<(r!ByWsip)4@zJMi+N4<@
z(f8StVx6yVJIH}f9{IUCi*(wF<yC~0wmz_FMMS@KAxj=X!)wd*LZ2v)Xh|_z`>@Ni
zhOWSzzRTkMmmV>{cG-UCR%o17XDPCZsPAEqZ3({uCQZHIl`ohQ=Nf1>7~;bux;ud>
zorIGw4Fy+DzUIE&M_^L+xTH9!E+g>XwqWaYF!V%KWA4=|v`CVU%XLMEPulHiBh9SC
zoGJ9|9~{qJ+MQ<_jKhFrzBt<?AE+w<gsubq15EX_E<J|58XMk~5437r;!yzm=8I!b
z7p~CX&-?qj{Jma&DFeDrS=2_UBl#LNt{nB0%>bDEHfcStyL_%Bw~&YK?*QTZg2FTU
z?|ttXZu7hSP^7p}T2YuM1Iv1OPfhTY<_Q2c_VVm|O8E<c9wLMOZr`^9bie$A1oA)K
zfcW3|`s)5JR0I5qa?Ng6JPvMGlzE@V^B0;o()bK=nx4g(uv*j`)FVT>)vNZnv7_^b
zc5jsyds}gOm^^rRTkXF4X$m1C=%fVQvJBZ|F@#!Fm$0v!)qUPh?jd23o`hiMNCMb8
zsY0rL8X9nUn_An%h2Z~V@4cg%T;FuzAV@&Eg7l&ws5GUQkbp=NX)3*`Gy&-#0Ro{&
zl_H>^i1Z>|I?{V60@8a+=m;d#00GbI%x}(_J$rv^&9~OfteJE6U%0>pd7t;W`*mLz
zM5p(*@(@GfGKs&|?3UR)fNWfW(L#AP&oARH+fLa8XOAq{d%Ww<cu0C9!2G@HPngVd
z(;^(-cK(|D7ii~W6FvfT<jqgfGBrCNM!02BU_K!p+}G@T*q5Bc{>}rm3xY*G#vO%M
z(vag_JOo7_IA|{PmwH`dl~v`b?jgqz1JVvT5!e{K8T1Y?_`85SU2!_UUS}Q(g^tx*
z`1n#6EKZ7LRY#e!w?!?*ksbU0=3UK9QI42XWAGHY_OvmJ`u$=mwjKe<NZte5D@Whw
z2}&TJ1_lfZO(!S)#@w~xip^A#K8K5=-<`XqFQdh+LDl@xqDcp)NYk&_u~3hKjYr3?
zs=B|$ypnrIy_8G@-~w&Xp)m_szK|({9%z9(<tyhDuk9tIhZ{bb`T(~z`u(W-v8hSV
z?tth=p4fi%yV5+VMGo-Zj>K~@+>OpsgtN(32(9baPUr^B=7yTw<^_Lf{#mLJWGBSW
z3^_8d&be0f3skP3KmNwAubQ>~TEVo<ndvXk$C#r`9f0I@+y!@~V=6aj|C4%yu#&Hy
zVeW1c57jPJ*6K2Nn4V~2(2VXEhyvBgxz7a*UlDx(+DqRTi|L$dip&@>*ZpCxCQ-x`
zDdn=_IGb7zen`{*Te2>t#7ihOW8SQVJjLF}>xOCw65f*)j2Vg4k3hEKaG_^p08VsX
z6p5oJ+TPcHi`POAgac3mdIMX}M(U)Vsl}d#HuAenmo&Y!WuG?yIRbwdL?36<K1CBD
zyk93w+UMioxcF%C{)e|u*|1rjg~&g?P=C3(h}^8%US#IPoCbNI@f-LuJlap$ilhYk
z8vTtk>|An`z|4^}r5D6o=olF&A25(u?Fe0y^W^ODm(AyIh5hl$?K_3~35^h*Wtp1U
zC5f&-YJ<Him2&$0DyVLScpN~_yb{yX5BE@yVr=sc$+msrxGk72qT(p}k!%Ykj%oUf
z+p-KL!)Ky}ui$g$AB-Sw2z_?AE-T(fekc3MTWM|SPX19~!dGu$itj*w=5J?-PIXxL
zSp2l|TO8Bs1ryc$cG5+cE@oiH{^y6b6tWDIw3;$h;2w@xfN}#(Fe9wTK_rWQD9`94
zw1lTS^($JJn0G9{A!~nn%3mN5{*yM&CX_lm&sHPH#A}Q5ZA-a7Db07HRaiDKsMBMN
ztn3}2!fT%Def?^GTHyOhFj3mKKi~TToFuiiKJlC}CK9$LpL%}$=@%$0jm9&hzIPG0
zFQ1Vejo0EeM+m|~i5I3TGG1MN`qhfa&x-gPp<wt0@TkyJjQ$%34~kE40y!j{zA$3Z
z>e!!$_~=$u6AQsuZi%+ZfAxNxlAc2uAuZWvTO0gMN69O<T{!II=ru%vG&LLl-1HH-
zpq}+-#YKa1s;1kqg9<=TX=ts449JWz7@8AWKA`Pn4G=!@k3kqp%<ze=2}xDyxmBrd
zcb$JbkMY|w{$3!?PJhX@VjENnPZPEz<kRC}_o|U%l02qr?MbdxzGV`e8DKbnv;}Q&
z-JqE#b`woqjbVQP01>e>Nl%>b@u;!E`rRTCJ^Vi=7S)J(E`f~xbl?pc1Ph#AcJcZc
zBL`X19P6hKi*e7({^2r+`anJ!^!o4dt7v2xLJ;lc-XPoRx}mquB2}ZqOU})M$XB5!
z+IXk``i}<1@RNgawAf>Sa>C9t!MY#4BDiauydoNp;$i`fXMCdx^Ai{$aAp{r+j`4x
zl&ia5d!a4alWnkltRVM<rn7$j&+o7X7IH2%2C+HIJu6C6%Q}ni**yy7aNIgRZFZl6
z$^5M3|0qyVSNA1Dq?=Osx-u*>n1=>MPh|HeH(OaRjB{!~Sq(1~>m4A~uyJw|>J}o4
zr;Ft9(!NPN@gk!>rsEfgfuO#)!(eW!2c=0mnVNlfqbK~%u{J6rb|e<B4KCLC3wKnp
zR$XrAP5l|^LR6iyF(#e$di8EO0H9nAbdhKLQp}B(j1qSuoi<R<exX$$-do%Ch3)t$
zQP6JCI4m0gjuV7AnUFsMU}t-hfO4Wd$BvRqDs}y{d^k#@9uRa^8OjQL#-hB~=&bCv
zM`TJ9=E1xlL%ksrRg_noGBvv#O_bc#Y$?pPC(rWaPj91Xp((<T8z&sGCH7gdRb>5e
zI8@lR^&#(wHTx54RbpHk4ImbQE1^S}<CJ62f-0Jo*eBz9hr{(c{UkN93eAp;Y(Kzd
zf8~Q~rh0}aTSRkEapKnI+i{{1pri<(y%Kf~8AGtT<f5|S-WrCEI#bH>t3b>J_t2Q6
z_SF2F!1vovE<-u-nL0Sn(5w*;xf}c6#+K7*@4S3}DNFJ@(K+|AUg(?3Pfav%qf_0|
zQv1zM9*+`wlN$}Fn^Rt=wgP)4e_>&{SjP4yT6lRoa<Vot*lJji5E4J|j8}xL`S=~R
zn><Il5(C;OwG(;O(5^b+EuO_IBhWL7heEiYAq*V66Zr#NHE71j*tx@~Cc+KB<U!ed
zrOFJ3>p6M=x>+KL55-+E#rjn`SY_j_HT0Mr+WSPn$Hs1e(Wf+Xc7CJzvr}9}(4i@I
zuHcR4pNzPV4HsK_>Qy^TY8T4G?tqi6<5AFSjo79T-chlwyOpf(V(E>)ynL%keyjk|
z2CFCmFrPnM57W@LrZDf-NbxrXa*x{{+3F}dtrQk>t~fM19KZ8k1z<2L84=h-{5<;L
zmCgcl7npfk_@8domJ&SWJ?>M7=Sj!=<T=t5reY!P@MV7CuEOT4%RV;ZTkk+RW~P{d
z@Dwg=Zn);h9K4?CgPD7AzUlWrboZ<DWVuAFApaPbey2jLt==7DO^ZHMj}E&Fiydjp
zr>oqUDV3!`hke$Fdw_dcq@ij1V(YEA5#R0l^#i?x?t{|V-9YazoB;Ci&)#E(AcdPN
z$K0x<A4SOV#tG_)GCO0w&(^`<)E_uMgFHu`FqSt|2Djr-D-a#gd?egol>u<^e-Yy_
zDXjPgbd*hdlHVuKg>OZI+cpME$>A<ca>pk6r2q-Amt^GmZFqc}pFqRVOUN~$bbF`e
zpWk$NIbHcVB2+Gh5%|G>c1GnDRQG(1fd#5ex0epNwN=r!T+-iP_K=%-VZ{3g%D9Ar
zg-r_nD1Jp>-R&Ee?((Ro#L~wKY1CtX@<t8d#ev8Jb7sSNjr=vIY`OY~uxKVP|3I~4
ze*l3n6)`aGv@%41ec8A=wzA@5Y|H!G&VMH{DXJZC)E_U!Z=d1C7u3iPk8k(mFCB6s
za0&)jwm2UN@U%W-4%H=&0}<@U)__Ro**?#R(8_=(Y7YxSn8lYHDmtaML5Y`%=7T$|
z{^-enr$)Ly6rpv)MUGZ6J#jA{DMtd>Rj$jhOXx-(_@)8YV!a?6?x$g3N=_L}oGR=%
z<NL#V8}=ULS@9=7v~ErV(a(c7DbzHLig^yLMz5zE7)Ti2%bVQ;d6xn?j7NnYETYn<
z2;9balKnom;ahc#t8ua0wJxTGD|7Whe|{77)y=6_>J`x?S9m|>!5^7Q%w~8>Qt~u&
zIYX_8lMZeJ#!5d16~UKij_v$R!$OAJoLqQr-7!SMe<v_L0ZBPfDR>iXmuui3S>^9Y
zs^m4$t`%mq8gyW+t|8p^$gWfa{9%_1`F5L|^LFY3(7xTDqUeF}1$;Cx=!7!IJRWiH
z9Cl>US9EMC13@@H5ch%HEA-_s4t_^%PzJ!2pGjA;e)xD{TIgrh3TU4MOKsot7bex`
z$AM59N0=AS7}%vS#Xkt)w-EWhi2cs2JpWOCt^J%~{Rv>I%r3a<jzN=N7CiN<C$8yL
zy<OmvnLKwuJ%&S|eq_rb8!LcQ5$k4E)iZy4nF!`t3G(rv*Z+VAauB_yMHrpX=N!0^
zspiadVUEY;r+0Z6j-N!g?WNIZX4G^4@w7{fv3}K_XyHo+8{=bC&)l5Z8p>^Mg<7%8
zL;Ptl@~rRl1u+2Naszr9yJ06|9XFM{viSVY&6mN~!kyk-nE<v0V1HqstMk-=*gCvt
z`<z|Bt;|;4iA6*-l;assAoQus^SbG97FJs;-I=c7z>~K!+9ZGW6q$h8M{?X6tyj#o
z9fw{@8lxz99ii5hNLN5h;aY?CmrIJ^?}0er)Z6`-ak>C@8?S77Z;Ihw^=+OuM{O-7
z?m!nHo)`R8Xe)!eJ*pW)Nat?o>*WlgS1u-~QoAt&s+M9zxk@fgK(Ne*%c@t@4(;oY
zS|%X{G4k_VQ<{F-zWn`vQ7neyT`;D`o!WLZ`D?;imF3FZ)NEd#f^2q(hKcuzOAP80
zH3x-v()<U+D=Xqv$Od+ppS-Pi>t_1R3-WK1tI9>;Hyk%`;E0#*1@mAH3kT<Av*p(x
zA}{hmzOXC9SU?9;H%qv1`W+=#UO@SphJF%Q#kVReK5+v%8xIp0a*KV9c>J$o=CoK{
zo^Zt*{_gZUy%2K#cDG$oAc5KMzj<Mnp%tNuYb;sl7}k8BrdGh3dGjro+w#_QOf8Km
zYPXo?kC)|l)?EXLX8Q>O1xu!>*~UK=EH29enyf3PY1_yC+o}Y9`}V2q{_w>j#m5yD
zl8IM;eB`cX{{H$EhSy*G%U=Za3@ogJh7O+DL2K(B^Llx>C`-k<<{2+Nkm!AsU-6gI
zi{S4#7>G2xHAGPOvVM3@mb5})oOdnS`9^z0p*)bn1SEkDBmQK$M+Ou1s_jq90#&j>
zG7)<NVU4gc0z1;mDI4ypq01Nkd6t;)n$2SQv5EPg-K`tP1)NYix`_&y|JxZowoT-4
zLmj@NN~U~DXy$O!L)aA0!JS$?Yb!%irh-Q}%zCZ*&E4`-{8NbduxV5qfBG;R=bQ-D
z@p@A<v-_D=>+ZVqjq-<l&v+?FwHa5mVPQb7BPSBU-&W!$4zHRzL6iNXP&ow(6)7-K
zk<<*DvD@HEI;t7J%Ab>@h{Y)>`~GvaqF?hn*ron+wSrKf2C5Y^(?{Sc!^jPu=I7rf
z2>B{XU|jLzfAb!xc4EvpMhQxbv$v@@HB$}^ihFBY>ms6FTaM?h$JQI^CcEC!SEV!5
z(!LiN(StRs^Fo_nGTfK~p4a#L^3k+}>nGEHbVQu~<0<$51qk#%^y>xDi;up`Ym2Bs
zh|KvA&+*X+t71UGeJJ&(I^%T_nk(Hux_s+|tF*ii=A-<$YRi96zh{_QAM@mYQ&+vb
zWPXgf<nc;w;1c*^2>jUETyW(&$<vRmA<`BHM`@(D%fISg{E!SHRTKY)b|SOqpiAfx
zd_LXn)9d2G)bC8A3yqYGo@CgDf&FN!5}x6N!v%3ZZIhE-u#pqln4J^qS?~QVs1RKE
z{EG0!?+Li=kwP~Y+kjqLs3pJ-M>8S_0&13@11=v3YA>}Eowzv7?{F^h&)cu;OqThk
z@QrQ7T>LqTJKqfW-Srs~`@gDR`QNdJ`uAsYO}T@Avp7J~jI7upo{fE19z@0O?Ly$5
zS<nXS57mD{gHcr6ZT5m8ub+<`D7+WSy>kya#l6G%3?DmG?}LId5fm|WH?joJK4wd(
zOs2WjDx6OrIHffoiW@i2lLJ4rQ4d3(QYUEj`N$*#ecNZ=-_GRLh*RquaWv6{`z5k7
z8{VIL9q#MI@9VPNj(JHm))<1fz#0v=k+NHu)6H%Y)37P7L`<9_y-+0z(_?i`q<HW>
ztXxcNwz2hMCvROMsi9x)*Fz?T;eYa!;P|z<%fNDoI;O8<tI)@N)=BH*52Drw?9AhP
ztf8eSyMqXeHntenT7JkwLvpq}uE?0?So|=M-~T_T`}p@W-~2Cl?<KxSo9sz-FQgko
zWrd=!KrzD;pLqGJ{H#E|ISApiIBc-jju@qWbxqofCgaP}IRhp|@+@5k(#uJv(D3c?
z7ZX0tCyL`6^Y7thDrjLg`}Ujlqm|MFe2Fi8QX(?3fVjDEXA|dvgYoxr?1)D8WO7VJ
z6;)e|V>jONG-9uW2Cv_4COI-I)~mK-ZT)@x@|9Ax?QQtLhVSNNJ;SM-B2A(XdNV*2
zs}x+ms8U|DbjHZ}*lh7xuA!}-&gA;x*QsgcJF)iyp7>qxhm^E%5>=RjdmF|l#qDu{
z*SXI)M9<ex0nR4ORD+AI&V~G7T_zAE=+=vWCsiAuX7Imh+y4Id-)Hgv=MLoMZM>3^
zNEJWN^k68;;&$uhe@cUc&Tg*kgr%|_P`UTzz-_a?4r}Ue`~4h_aoQFhPIUnY8njSN
z%wob|uLQkp4>?n~1P;~>jLCAMrq2fB_czTY;hCK&*KuPRCHbam66Ul<_sF8i*BHQl
zlhS-+g>e4Gu_jDGy)D-3mEA<r;mfe$5n_VIPZ*m=Ne+PqTirGX4!5cb-SSSjb2R)#
zc;~CT!v5+=5(qayOt>&A9>9JSp5+VlB!bHV4#UBXa4i(yg#HgdPHbn?q65V6#TcDY
z2SG{MaG>Dsa?Due+TZr^w}1H0zXM+p#^^J?mL$;)ql#1gSbF~N@sdYRJWux7*Ab@Z
zKFO9OlBue!U!dEB()+n9A5X6XF8^A*ITz4aU>T38S3B(O+tcDFD=K<U64nB_E_}@M
z<6;v#;@%j-CokN|q{D_4nQ5r3*>yH>^l9dtiA_J9Ac1F)$hbC2Fp9aD-lmkhR2WBN
zNTbU!>-YJTCKyS&MG$+tX~q>H8)fM~c+a`p{*2;upS{6;{L2LjSy>0@5Wl)Cyl5-K
zw6x=Lur44pobq=9_g|3A{8uDQ|Godlm*V2IvWleb72SwAdJ#45<cmNrf^gdi;L@35
z?bNW!F^206-77aElAC-y#O0?86#jSk&WU&AIh1gGC{HK^Cpv32tm*&ZXBw>a<7qq6
zt2VXyRfz*$6k7?AwqgwP_&_u!bmdMv=3Gwu6p4s#42m(@YYKppnA5?752o?ewkH;W
z5pCf%8{k2>#ZFaY)_=Z#_}d5nea8QC2O4?t0VS~Tdar^F<D<?aDmJEHpcJ*;92kgZ
zB<Yl<gAw%*n^5XU%`(+vt1PEW&VXwQ5L+It_eq<S35hmdtM8EeaYyikSf0}a0mDw=
zwOUxL-+vWYr;S^{6c+7CE@?vj^)-G={pmV-@KZ>Wc<NXEkY=V3$j^!~xuX3G<Os0h
z>@$=CtN5>ffmlF4G643MYIo$xrHNmlg?q>-&goj%*~OPg>@`@Yzt~LxZL>8CsAyKf
z@U*EImBZ~AfL_O#lR&10`%NVQJM{#17}APj&Pn)ywWqqwU!Wg)C_s<o3IId77cp=?
zI|z^(@&l0I0P=G&<lle%?_>Y_!u@S(e><7~+uW<TEA!&FaI3&42@-3#uTPP5@|XXf
z4**g4KUj44Kj8Nf^&%b!G*Lm6^-CshaE8p;uh6_EGDbK0v*sqR;&!JQ4s4<Xf$4HU
z<)$vPt^4t)%Bh(lYBS=Pb+Kro6rZ>_`C)-|4a0Y~2V@S`X*89;x2ty73F4XXL=5!X
z)$&|LA2u1&a^*6BrM53wU-6F%ZFVW|0n(N7cJsqa0Py)oQe6)S0C6np;#tpwKXINe
z0XPy)Y(4?_0QdT0&UTTVb(d}u14+lf-l;^k7GNdMC?sG<-9QfW6X0Zq{bAb($T|M?
zTBZG0fXV<s4eR=m0@!zJ)cG+CqeA%C%Sy$q5r2P*e=KhOeHQ;`iS6&R`1>sW_7{Kq
zPM|gh$U6Qijy!?VD6uyMZgYj-Q{u>d6_%Ot<*h$|Q!&jVA0a|N^^l<+V42DBm+kqB
zh22YkfA8P5+W4P&PISMyfk6e7v_27dW1XthHmJb2sz>)v95!#qZ?a;M4^HzNAK{PE
zKJ%fu=dVAf(qu@c8-}y8`NF~H7v(u0*&dbJ895XYz;|X^<CT4N{kiwWt?PRi^ut1`
zvD>WDoRTuepKM6>%6G1vJl*;Q@*mIn0S0FyyI<lM&jJA^Q{Lj;8ae)Rb(^rJp9}y;
zM7p>gL22y94=Bf`_xn2f6xrvcH5-LXT-<90EFd&O31^`{f>0L@@#D0;l{bIyL7ykU
zt_udU1^B~fG(~@~1Qa&PDsoPR<Yo4&z$_`4_@-}w0G7`Jtp%ZAryPV#=%Xi`b|cGP
zRtUFBgN$Nd=p*EUa)X3%*i$ZbF_-vZAEG4CUQB4ym2HS(;S3yru{#eD6kn3x^}nYc
ztx2@R<`$V8tx!DQ4&@pq2&d0%oMg?J7E;6qBs}-N9leyo&#~8P#xjDiw?Tj8{RIjy
zDkH<(HMywQ>8#2YAHrRt$=?r^(~u}Y(~!drc`QSA7sUKMtv#Z&7840;7kq>n5sz_r
z`*{l6LnDc|24Rju&DQbY(SU)4nyq-9dH4Vt+4k*uEzaX}N=atj>$sJX+wTU_wQFEI
zLNpH}4hz%`1YRyyRE0mU4!A0X(eckG1#t%JkBNPf^HixDD#7dtI%eEe%`B#ISyR#W
zRRXa{lvtI#IIJ!Hd^2Ha<1UZG)|$$5Y6Xsr5<QiWdhr~*mU7I4A&WTKC(joxW0RK-
zq~)MN5vzV2D9lnSK%e@0$}&!5@GSI2Xh7opc_GcA43NNrJjHa(i~+9jDO6x$+mVcE
zcl51d^DUjQ!TJ%?Tt`FAx!hPl(<NI8-nSBu3(_5$H#eu9S}*sqhP!{T;Jl5wMt<9M
z4h1=4P;5Py!5y{t-IkNR@1r5)0}vjDN9V6m@2X93Kcpom=G&j{l$RTezzOoTr$}I7
z?M0$(9JfcgM}LZ&2rv@KTM0Y}q$cYBd4U=(%`igH#0PsW>J9IkUK({IDCAX5!zV12
z$)}ir_Xb*T;maWdXXuzg&gt=O45^0^@UbaVd7(Xvr7w{wbqf5|a<xP|bJczv@ZB9$
z5^1i5bLK-FL)e|ZN+}ht;J5rXnZ)m<TR8TK*52tSA-He}C1_a<i-$Niw5h#%?cE+k
zrQ+8mqF|77Pg`!bBzhoHyyz-M;RoWbE7zEZaauZ|GTzR{=~@6=IkgLc*I!Noz+Z%&
z%Qawqi$7-C(ore4dna5E@{Xi_Q~#y8+oE~FMlOV!8?J>W=%r4nW9)6kY3up`ZcZJ!
zS3%W|KJLWx4IrP33~dMz+$Mfntv336!e~>*Jw@Xuh*q?piMXqq^6o^CX&;DQKL+s_
zAAr^(!|&WL8~ij7xH1!Ov3zT9+1g5{jx|&kPGUp9nM#E)d!yy>9LA);o5lED=DBf6
z;^tSjrzx{A;F&k~^%<}Os34RXi%&sV!n{sJe0P1gE9j-=odGTmxEvXGrHh^!7w|5(
zY#wp2ja<i`2U`ipl|xvw-yLp<CcDaa60yG^p88TkI$qfnmU>CJ;&j%+<c-;&5btgl
z6%!@RBN<CJ%V<?htl38#1&S8V*{W4=Y%kYdc)cPl85|qH4Q;-lH4Naai!$o%HGlZs
zv6n%3&&&x{4{v9iOR&qOndZ}6GhgQNC9~M<Q(O=Zg9?xP-R@1>>=3l5s`N<dzOIpB
z*(|`y`qdlb!iMVr`Is^+r^w<~>d%F$v9Q3*uuYMhKA*nH^S{h;TyuqPlk;$-fdFZP
z$Ex_!MRpktR~iO|qN1{ojxV$QL0!@g^_B~6EsxjN<vIG4+~&w}RwYpgLHojKzIT>A
z8syS<RiV49P0!`RijF8Po<>!MNkK#WAq8ky6hX@YW6Ix>LTkW1;&lCrczX{kXnVni
z3q%(#C0A;i8dy}XZ=czda;K@Xegv{>5jQEX!!g<{rMoIy=dB;S;jI$&7?Tof0Shl$
z!cj~m1nFE2yDT;--1FFxhA31EeONq>7LKSl28K>;W=ysR@4q$r<QgBNt0F00gPlPP
zt%O`=kT$q<&`f2qK=_SJVwl*L&*M=CLH9R#B;~fffrIyy?`_>`;U<=?rrgtYs<%b|
z0&&7SPuu1$rclXh4u8lV%e_u2;Htt52EBC#b$7ag<!P)l>J^O|@gK1b*T=-Eo^#Tz
z1u7Z8gSSGwr21WAQ~Z}AG1u#0Ecn(J=d`o%g0^bwTO4H8)gLlSwTHO43NDBSD(s69
z&FPqNr_B(w@G)sdc6#2kRiRHy1?>3}D63s>wsko--A<%xZa$Ri)Be$T4WTGgdE`IG
zZ#;0BXXR!kxjbDP6G>eS@e0$_6AWaRyg7}=H=~}h{Rmj1@M8izqz;arW$d#6T6*Db
zFf&)O#f#fyU=q&_Ip3k771`;VLW=|MA@<j8218W#(#XGLG<sq6BO7lZ<c&Xbv^@zS
z4Yat?Uv#6^`eqjqx2`TRPpEXKZ>KcqgavR<TIRU%)+oJBB%NIznugl+!Sy&K4^J#d
zlgYwmA|5u5(4_6g>v+sL?K~K1KPg|G$Vgc_RZRZyE1!=AUY_}A!847zKLU4(yo4|s
z{h2u;L~y#A>Tx^ts>`&0>FV1;`3+gDUrrH07*`!uLeMCL!#b>QRceSoeB;6rJeMAr
zya4jsed{a*0hDeA&D1cQtng0;xN!p49O;Xvb-|Kz^Ihq$6+v%B$Uql}r1<!VnF{A=
z)o?0{{ZTIYeSjvi?TUn2^}Va=*3W|9TDlU`jdPE9f;gs?oMF`U#vWe~w?o?-xf}K@
zqio{PNWsTTDo%^qV1)^N&diNey2jh$oq1UsrEn*CL&{h9NJt!}(Iq~5mCMGTnhMyD
zVZbE#3E_}!zd(%ZCyY_s3nTjtYV~!dnqrr_CW%*?*)Ax%4NH??7=F6{b4$sL65)wC
z(?_d>LAcXrT6Yd})V)@MFHE#XdP-6xY-Fws4D%M_1I~F7;*}bHPP83pK_N*UFDC(_
zOBY;XXDE{`Imnqww82$6CY47qVg<sXP1p~F0n4#X0hd+E?=vJP+fvXE(D$pg0_F@*
zt_h)9h$1+2|9E#SVelTg)lV(vmIJ<&nwB&g`;7X~HV$bVEVSN@F|hvCvlQbrXxo?e
z^!u-uZc2e@Rk_o+4*Ffi&Tk+TM)u|OwXoH}TXC!HGSQb9nGK%A5uqL?Ul{;VCV}>A
z`B9FDySO0DG6&81PQ9a}FLiUMF4LHq{AFjYg(e+Sn>H9HUyM6BU(&^@ks>xFuM4Y0
zG0MzK#6c}<3V;*-h)wKFLPb6{l__uS>{)*v+7n|<zrDHnLqBUg;(P$PK>#AQdGBw0
zc%?RxiDw5V-3A9emVKopyTaa+KKAy<E6#0F;F$DcU?CV&LWqk}Ij?Q`1<JhYFUxt!
zPLieRwV1<$pLsQPr6FDqA}@URPo|y$bc`r80d`OQg@pLRdKzbkiZ{>S=IXn#1am%&
zji0doropO#&%^lgvcEFFs*s`J-sn)7brthkj(jI*#4<io8(g7dCc7}t2yartCqO7L
z6dycDQ+VU1w#7l%?3ONKuHa`~{VGQ5^%@xn<%V(V)V4W+vf=$PUApPs7jYtQNw*(d
z>F(Z?XJ3AXZ^al_VzUY7Z2npW*Gncbw^?20L|ZW1EA{rBC#&rP#2t3ke$wT2jdjjn
z4X15!%xpHysKn+0j@4YmtEs923=K7cwszFR_<-X^gm`R@fyLR}`jd<N)wb6(Y1ol6
zpy3gZ9olsmna$V^Mpb-GfH0}^*1=Hp?1#%x1(e;sy730~>ia@FfhbScXv>>*Dwjnf
zY0?<FH)^xDt52m(?2IDkJeE5@HX2F<&v<&Y`hyqvVfSjr1(4Rg{J%idv!5L9^^*$`
zlL3Ml<<c%8B)&5#AAy~!xQJyxHvH#$(*;vW-H&av?{<q-L4F6CObgDUZBLQj-wJlF
zZYHI6o@!lMtDe*RXaP!nOmP{y7d7qL{1*CRJP-<O9BToPU7|A8()+v8tr-aba_sdQ
z2R}X+$6`PGxXshs@ng0E>|LxDOEQ*PL^oWDn=fF1VZ%(i6vuG>`f*!ryOCv=VXhaK
z;r-YxX>Bs8Rkl<87y{Wa#Lz9vw?ut>p<?j*D9zMQvq{sOYuthW&r{D^Dei2L?<FG8
z1y^5RTl*GahzI6O3(XgX;7prU-eV0+C{v@it8x+YEWPH6d~LZpovd%3z2V1)_gZMM
z(Zy}&UCkNW&ggr}Egb7F>F~IhR+{Z1UpC0wiUD0Kp4*|tVY^-;8UFN#z&7}!tvx04
z4cRN5&OVmOC(kP(oERkCx}OA;6o-lz+z($dG;dAUa|v{I1_1`+?@A^{v@rrCYAU$%
zf^2&u<m>udPHgAbMnF%ui4160!Qe=&76c@s&}V6iw?`kwSe_JBM{<p9qs>LsN&R2O
zv%NPd;lmn%4sY|v;C(T@=B#k_Q`12~n`&O!uJYZ^X3N;rMefw^uZoGaa5OPce!J>n
zxXt4jdF)nJ4o`9?i<*}C!&Q>Yz~RUwf!5FO;D-&cX7SlGYde>^-Q1tY_r<`ct0DSX
z`n^q8t#ApSNfXoX#c*-5G0fIg?|14IU7)G1W}>bx!bvjjfC0qN2?wJJFyF+(ua!wu
zjY(2a8cz!m*h*2vxeBR8j`+A?!-gL#LGmM+!<AS0muI?Z-`=DY-F>Uj)wOO$hn3a9
zX>=?TPOR&wic?9`IS+%&jSD`#m0664`^L;hH|7tG%BWB5<bdEfaxqA}0)g^tHo?Aj
z_uPu|E0(-d0R&RkB=2r!E<CeFp_>BskHyyr8l-g&FCo2kYEOxm*i|u7#PNZEx7TF|
zSQub1f)BJF){bT{wWk$+jgO}f3Nbl4lxt!52RETJk{q`52xuOBEm}Q~5}(rtW8=@2
z_y<le%^}x@0bBonk+SuF!ZUk?qRc5cY2j2mTbNnTtkN12>W2pHLA!0pX8z&zGUd3=
z!LIbd7Ck*?5{|SV;BL-~^-miaaNo6Oy34gj{Hv1VTdVw3V2Y@(7Um}7o#s~%jKYDC
zXD*gs<|p^!#p6?O@keeOxj}f2gPl}Tzw5bg#2AJ=$We!*ffpT6AJJ@Jjx1-^c|f<+
zZryy>7y?v`PYcY?$P2X4%CQo4*iDn+t&#eHmu6z@hHpbbK5;dLeSc^_c)lZAo+t8{
z_SIVa&SKZqWH-zM&wjX9`JuK-4*DFnz*~)Q!S*WQ&iay1ibe^7FCxPPEtN>_lB~K)
zX1k{F;8pSs@Db*h39!+`2Tku15=Q&ET{Si5$XXy<PnCUdXPObb+)wWe?YGN8M_4G&
zT!2fyCPsvU7c8E~FVKXWQB(ue|JLdSYo>j}1+@3ONG0-5#vkLh$=w@#TFq`fv5x3p
zwfyi?H$jOrnsc{Em<qu)>WENrLOZeB$K=^*tCqEqXg=V+)wBFn3j8@AG~j0T9u3HS
zob&&1bobR18QUw-U5pLA_U@4D2WeE%cgCu>v&O1rEh6OHv6_mvm`VH?^o>W0D%h!y
zbnBjSRRm|hOtv9TJK_u2wntU$P!f#rh@xElD<3LPH9cN3M<$_`RAnpveM+SpM?ro!
z5y}bt=8UF>Yf~~(UV=r2290tT5`a0C*H;-JknuOCh`vFYah#6_wxav*@+*}+r$&Ri
zAIU_!{BWgmKTuQ}{8<mnG+H-uzs|32NzQU~#5WQjr<GT%wK$s!kPeRyL~bX*XERU9
zC_`WLZl9)k=Nf^wH#=Z2lzz7()R?S{4q7-emrCpbZHnrJS(}c&MNF0=Tk7*#TkCnQ
zhqtDO<-7qNoP^Wdbu+<J31C}}EV_7NX+9wJ)Vgwu@2!$obxSJgCX@num~K;~$o5#v
zb0sZWexbO7U8N?Ck_J$*FlgjJj*lQuq;Ct;EyC=Csm13{;$M&$*V<UNxcmYU7ssPg
zsKz{Y!cu6*US5m(S<yYZZJ2fG2{}UzxCAsh5RRmt?{uCtUr!7~nGS#QEo$ikCvWk%
z-jV0pi-xcG%WmLkLS@Yl{c&~ENYqy~#jW)fue{U|*rxu}DdzPdax!(|<i5!J2@eGk
zo3pLD0T`C1wKg@RiN*rU``%@B=B!+|!R5y6fE16-rEjameDU3U&}QQ3k>PV%r>V<r
zI_7}9keJ#1&;IWg{CwJNU|UHLp(boH!fOn1ZyuVOmOCk^rPK7j>wtOB7{@S1(8oH=
zM<N92z0C#-3{7ryWHL_nJGXf{Qv2oKHV^irPHpj{jP5zmKUMZJ^T{ZxapVKpG}6<c
z#E4eRuM|}pH^tP_vv?3*F~%7w3kq4u_e6d4p>>Oo9nLE*Ij4iY0U%kh-}oyQB(8P}
zC=s{n?Hz2qa!uc`yJ<NbR)e`X6sA;{T!~0*zz{c+ox@NRvDMk<v+ykPs-Ne>d-1Rx
zhxzey;ut$nHMX~fB_<SNTx^#V8s@&Gi9Rqe$<8}|UAL<a0<mplM#l5U$+5kQs|2no
zkCE!?dwT{=z)>}Kvsnf|@`A*v$*C1@`$H^HD|EQi<~cu!mrMgk)s6E6ABLX?3+BxG
z-3O^}p!CB<#Zg7=*xMaaY@O#8432Wt{H_~XQHfO=8LU*-sWz9PrEJZY8z_kCxKg!K
z<!=(h7Dn5(;ce&}yEPgjvYFSAi<fvl1mT73d}UFbbbj0>rhN<38nO=u7vHs4>o<ws
z-5dZX(>gOo9*EDtg%_7YUlSN5{D)XW>-A4xE;xvY3Ju4|gNgTcOlU$O(m2`0Ow)Cl
zs~>ailOC2cTX^vq^u&SsncqeFi%7FM`^rn3zd50Kvp-KYF$XW`u+6Kle#TuMLK~Yt
z(O%Qc%$+;CGgga?VK$X)iGL_+nF#J5&<s;Xf<`%`psWN1+*p#h;PdTf^VSvz_X6u_
zdR4z;AuYk?ZEue)vv70_^#uG=^VJi{u+>nl6obr3?yjcV8r}2DnymN`uujT5qR9(P
z7s$AF$#%>Hb0C-fMy5(%2fd*!RylgDvwHI6#PJR8)BREn>S3KhN5SjnLagiEHc?>W
zFWt=tR3=AlpQ(MX90rcQ<Zbl5=i|d0hh9gCsBT^X)R`KSBS4uBx$s0C{1N(#JCz+f
z|Dy}adp2QEd^KMW(c@{`lS^AG*qDy$5T!)a6!P7Z(AgIsI;97;H|Ap+**3=K_^NP;
zK|2=Z<3KNmEtg!1m^elG6(Ng*4E4}0J})Nn{MNALprhDlK9#^l#J3&p&uW$s+B@6w
z+&^sA<=Ht~Imvn#fW&=nvZ}}`PepD#InJ<g$^5+n^TC3C`ndFh6L<>F*+%=~u-NM9
z!}#yYlx1vIr4!B|4u5?Wc@Dv%U!d+`yyy9EMt&u&hi4f&mZjL9J3W<~fpT9f2krc*
z#vB`E*3S7OnEKz_+dWTE<f3G?%-lYJ)DGf&T51O(1^2}U7o!zz-K`Q40e5QHMaO~s
z7!pvQL$@F?T)jC}Z+z%<H-^Uk%Z#bu#&O!&&zBfjnA2E8Sv^t@k3=_-<2(1-=V`Jl
z6J*gwI}g7(<bT)H6p`<ARpE+!D<wuWiO_lRcri3As#C%@%75S}`U0RpGf{FU%F29_
zS4$ESS&XbZY>5~iMTp~M(Q2WZI59mA&cR3Wdn!&`vCAmU$jL*JfO(Pt)7&To=Z)3Y
zPbHV|ek7FFLReqSwnp-VdGR&UCj)}B7K?WIh&x!UPQal!ESx84q5dY(SuWy<>iTm)
zJ+g~o-48reybmLJabmigZ)!9x;F@2xz~mEM*|Ww$HTIi;W9leE=vt($XF|?R6IF_<
zXXCmXP>l9P^C^mRwZyX~B|=i&FAycND;JQZjO08KwEu|zw&?q~<DC4wcj$VwdP$`U
z@3?c&i+(Sd(WaQJ;Y)Wai6Li_A4VNl{9TD}`y+Ma88<s&Hlj2HZkYuWU>$o31}mO@
zQ++UNHefD9;2kE|Tx`rM#zWPO!?|lt<@!Inzbf2}>QU%oW|l*l<;DU+=D34J^WgCd
zCQkNW?i-#Tx}gXp;!64W<3>)zEo@ywUfpQ%&!-_|Om8L05?x-pb*d1@sh*5krjX-M
z?GBDTNRAshA2SVMAH+5di9Z_8gghI#r?y}NvP@cs@*|+%aK%wiryk;_H;gPp)Ss@}
z-I3~9a);f1>)Wskx|=raC$<?|SS>Rbo8H0I9dc8#%m45cxP$5Xve>fzO-;ax)MaPY
z4*0(m@)$bKI$Jr3uq9h!*kuljGv*)R2fZ8xEPw19lZQ=AMV9juo&QjJwc7O1M;As6
zynQeb{Y~u3`^8x)>h#ohOk2B#8pogOOP_8aFWkJ4+uF8_u*DH1VYtKLuJx20nAHAZ
zi`GyBANooQXIm;=WebP-;Y&>F4*fMGTdav^WIdJF7kn2yxA|l=J2z}=<i>1W*QFj1
z>N}~ki@yRB#GO0Ev$IyR-NC+P>ND!ifuKyAdRetsUy*;WNmu3)r5EOv>^VCbC{+D&
z>LhfhyML?9hI95*tM9}*esL$%kJ}8-_^<}(f=2!<+(+r}7EMhWp!TX3)D-)F9u*HP
z9DbrYYB8o@op_xvZtohWJl`J0A9SKGmjm?Nwc6C*e9|H>N~p`wxE3etlXn4Pd1mPB
zZ9@_ixxfO-MmL2tN{y#i09`SeAxqUIK}X)m`<|F&+O!n@*&lbJ6qCOa^Noy08{@&9
zP#K(QbR`ZnWdu<3tcmqnQ<8T{N%1^=E8?owDYf;p;&;!B2*XK53B%SB{8%}VNz-z#
zjzc{+tLo;%wJssVaLlQ!(3YFb=Qt*FAW)%`923#915r@nMr_g2os9&>%c|Ft{k9h=
z7BihnI1_coY8&){W*a?}Tfj&wY-|6FSc#fr!MKaZ>#N%jS(}jy^4o3!@@%h4*eA{s
z#UR_0XITcnK;v?I7TDQ{6UNp)3cQMv{Yx*>P8wl$iDL@}eQm5`>=*cr`kO!A4g2+f
zRc74bopE@ItS1A{jDLD@V&2gNnqp^ED;tI=<lNVq%u3LXVu??F_F0u<22<JrQp8o;
z<M*2HP6MO5ovDG@%^(3|nD$66`KjJ7P!_Is_>9%_%;%7hQc2*)?zFRnMh<tT$kqm$
z-lIDYw{moSYa!LW-l+z%iH~zLGQSLEH-)Ecx0(MC)@y4wdIkAt92~3A^~l*-fe%dL
zs<7D%&KM6vuulDM{Bo%QQ%4Tvt*Wil`aa(IVR3KtCgxS1<&@5lSd?6rx!?iMXIJpO
zX7F>G8uJ|fQoP54tP=?DTNvk5F*gJI<lz$O^ztbPRx9hPwj<9b{PXC%qyu?CXgU@5
z(e)~66$WxiS`D}z7R6j&Yxr!E3-M)koLwejKOe;3cMgopx^IpkHw!sW?%EIWN8)oA
zXH`1PF4PaXe;HE$W*Pq8v^A1H&<on?FZvAUTM`H*e__=3UHN&fL!omkHKdzGym{bR
z3(pC$fs6yHQ;Tt;EzfxF#R=8>9`fsYZ`?o8a4i%Zu<fcW8c)r)O~=p?xP}PAF1L;C
z^j=k+GJWnUR}N6+c_sZUb~DBPic$@}J8S*bi7<hC3eq}tmqdThq*x-r-++H<!RHca
z*?mh`7XX*Nn7uG=G|p+zxXZj$V>wxUSN%1y9N28uTfZDW-<jkYP%p=ui%{%wO&D8P
z%!&WX5%f(ibb-IG(2ogUr-4t+z!z^H3YuBFp1ezc{amCuos3!}T@|JI`JyhaIsnRL
z-$a*c5`oeh5pZCmAQM{Qc$CIwB_g})Hr@zuAC_Z>TWX_A3#!|NnTUDwJoYB0rO<P*
z#g`n(zJn8PBe)?1K$sDyQGy%?kQ@7U`m%=u(VY8~fT5r5!|=7kqwX=R@Z3dcdA5B*
z)ve+g)vHWfGi2YNWj>3K4{Gy!M-=-DB+>8-<Xm!=RI3$)%W5KXms-;9!aXR=vZS>_
zL<F7Fu^XS$dlIhCJwZ-2J>8Y?3UWM~Je}pYU+fR{U2Fo`8YyQ*B);lGD=AZwT3WNk
zJikfY2W8#3OOVBxM?r3V>C)@zGuNpS@b1jy<H$-^`~@NsFTsjxrtA(F;Zo9?){{o3
z-|<!0wI};r<v})IbZg?=S4Lie`)z8(J7(u)u5VpVW>%Kx4Bfeu+S*VjKezxqUg%G;
zH%<q7&I0n79a?FpJZV@I=*1x5JB)PzAxo?IGZ*9;$@n|Je%P*-2hHgvpeoDAC^4#!
z$|+0XSx%AAIk;XU9OOp_kfbiMHpm)ANNrm+d5x%WxqL;jM61*$ftDLNuBT2Bcka^d
z-Bu+!6yZg_E%*hhFnC9ht=QfBYNvDjVSjh26UnBR8bn|%1a>VL2s&trE(=qbHl^UK
z<;7@IE$%N1EI;dY7JG%S!d>^2nn)B~Yp9#NnAi$voaKRv!ALUr{I+`f`mO<dw?$xX
zN+LihgO>ZYM9hKThy2yW`G{?ZPuj*DH!k75r>BM3BOc@XuJsDLy7D^7yD*k`m0>?2
zJoUgS<HOQn@iU3*N)=__=`zjQRy?E*SJ{a=Uf|UiSHqm@Uqb9L1)n@et}|7X`7d8v
z2uNwBOa^K3@vQhu4bU0dR|C)Weyj0Ken*a-;00FW@JwonHy$$}u7l%K?{OQTY)l1M
zD^ECoBC%93{Ok*YD&EZtEvJlX_hWA`=A<)ts=U+MleToh*;!fZIhhp1y}h;$Kb=1T
zedq4Lr)8_(>#M|P67b_KaVdC47+~BrZ{xVsh|TpUz?G{l^3{;fxcMfGW!Y4O+}1P~
zW3n9(L@$gN5!bIv7R|JpAbq&@fIGu)3T|s6GQwYJQ_<YJy0WoY-}|i!yA|mGU>?ZW
z+_rtjX&3_$Zdi;-LuzyElwFeG=5eTI?b};nr<Z$&)3|nJqKVQjo@GK(@yhOU6Tq*m
zfNGi6QSXd9_{bpu%Ceo%rppNTgsG~p0*|(D-BZX>xJgcO|MGW(IEu@R-_AfKX*WS7
zSI<&l7*zZG!Ff~Hc*S@a-n^xWmH<X?esK?b>9|iZy_Dc(rbKytwx5VAWJ+~g<R%FJ
zI2b>G*{}Hpiphjzi;ml*xWza=-Y>BjHKHHfF<RxgH{E49JM1`|e9o|PE{69k7Jf6_
z*+^CwGH)<lwK8S#x`qig{1(K8Ns}fmJFpjy<d7_NxT5oQXrGn5bNW+Q4&@M^vqW7o
zCjbgb)+R|U5A1<Z<Xs(j=fOLfYAyu%1$uBO(~eCI5vb=}tTVmZ=B5O?k>%9Donja>
za;`{R>G03wNhZLY`Ix>0_LCn-_cAp+-?tEWet}{i?47q(r=E!Y0DJupr9vY5f8cY2
zZ{diW56vK0%=+;Ahz$|Tif^3{wE$+~l-EdY{-rl{a>!=0n{++A!<EL8Gts%bR&vZ*
zODYUU4A1bNT3Hz1{0uIx%tg5toEK~AsScb9NONk2Hh{d$TVk%7!v{L2<_f-`E}0^2
zS|~m!T$(l@O#IZepW*NJW5+*eYeCW@6tis0X4GDaoq8$MJpE1~YH3M?;&{LL<lhgB
zS5?(k<06{*QCKLFMYll(@>+cZp~~M(y+RO2s~bA#^**FnEsSne4CPxUQiX8pn1%ln
z<X*RW<fl;13x^$tocG>Yt_61pL}?Vdy$E@%Zc_|I=;Yz>C$C2e;`J?_FW+8}W^W-0
zIw;NoaO@O5oKZ=>8Md)zFZ9V-!iEkN6Pp*VycO}wN3yInvLj@X;D*Dzd~+ZP*qjRQ
z>l=`j?|)G2B@KylNv0;{Z^-yRh_+jGBi}UIoVQYJNB;D<`kx6muo49e4#JPCMy)Di
zw~Oz8ahUx;RL!=mBEI%c`(G|6I00V(c<VG=MT!VkIoHYI%K(#lfqnY!gF9d_iCZOH
zYRN`CF%PeZj)_j!5N)4INz8e%+@_fzU)~!Oi;^Z7P~)XatTX&?*|O;7gl10JzPeR5
zHU`Z0fD!jMx$X_SEqZMtGv9m_+|!L}8}-CCVy!*npJ*51kISpevjLHqB5x{sq7^^$
zPUP{{B4>{iw&3brf(c7-^>hxlw0uv0fR5br*o(Dl$)nQ+ID3%Sd=P;ue+_mSp@nAs
z=3q4N#QKhaV@IdC=l4tgQv19Om;bnGPR!SCVJah#+2&wbo3gyyx4py9d|Y0g^0An&
z7Y|Tm%GGlpYXH=f@3g@mkCDv3K&#cSk++&!Yh%cTBd_w8;MG&rY$b&!fuU|ShHZPc
z4vWH=-k|@(iR-;;;K&sU@=g*MY|Hx)Gnw`FLi(u<7Y?r%1!yy#U&ewXN)R?Q5d@zv
z3T_^j!2(6;El(hXb`ZS<Po!mh_qy4qe2Tqn)2N%x;xxA!`yEA>k3Rs?)5+FFgYq0U
z%LE`Arp(b1a)7-9NE1L-x;NbldpEym_O3rK>N}~o<w34Cn0xU)Zg)eJlc77kGW8uI
zJ@@z%;d^vl$lb{E_v8Oo4D^xcMds%q_C8PuD3DC9<9`d9{y~xN?-`NK|EG}G9}eoj
z>D-8o<KL{pgy%*~F(!FEy7|`X^Th2h2R!@5oDYCheiAKwdeI0NlW6ES-UJG!I{<dn
zt9n0;s&1Zc&D$eOU%$39)xk;fB+u&G?<s(L{J^4Kp$9AbqY0Dsql6>pD*=M_1=myC
zFY|XmFC#>TDtE}IHqZIOD{t{WW=Osw>*ai}@X1r+k+&$^0ndm`RZ=P$^!A#k3{RX=
zx_!)&iIHf6uIzg)bB&EQ$N@Vr!))t{RUT5^2+I`s?hHEM{fder@H#^KAsU$<%cD{q
zW2E;_XYD`W;}?pMohQ+;&#3nG&e@{c<~z&Edan&Ui=+i%`11JJF7=H=*$BL4L)n#e
zGJZ*mWQJ3O!Y^}8q6E}LkUU3WVR8EVAYdZH7I-@)yKvoG?7G8aor<!kXohWTgBIv?
zSf7{V&tIUThX{)NHZSKPW7}$y&h}MHD@j_pGID~31wjtm&Uw|t!MM{*@UrRjn|LQ%
zYfG#9AW{?w8>k1wuBp}s@_EU@HCS9oMPR9XUG=Q$)9V^VCg`W~$Wz^Yk64DmAa0QE
zyCu2}{#A3pvZ=)YD&jT!0=!#ad0EZ-rwwI>%$bgb(IQ&+?&2dYlC}^?^kxYefn_Lb
zc<HXW+4S^O$L)hirn2vH*gG`O71C(rn{ei#?gb^~b}WY<ZGmwKB)9JVvjdWqiiMhx
z4U&|(7c0S?k5nf_z8;WxlrUjSfJQ~gt2xeq$}JW35fAmS_Qb~;c|@Vl;_`_jpQbcu
z*x(<WOgEb|SpY0J1vh~IeDHeyvH)6#<h2B;!sdHa&9h{HkFEizgFvr?N#a0karRJC
zq;g<O$?|C7qdwzjHTJLRLiT5qZKew6fkvau=6OxiuJ~R_3oP`|PiUBL1X$D(*?d@D
z^P=eGoA)t&x3g#bmEjX|r~7F%>0*8M55_WV-5VbCA2Wv7+m6XMnP#C&^aBwOu$4`%
zr)T_~jdXft6s}yg75co=L?ruiM3)rUrAeNS&3D4Cns;ZzeH4E1!EJD?U-q7CISEz;
zn?!$l6N&lC-2n0yM@2$JZC^PEK@_vvT&aiY6JraA*A%1~zDAc_uf1dW?7fvViFd@_
zXV`*MprE@|*|*`8ZHzTfo!4he>jNe!^Bm~6Vw=T|K472i{N{!^^|sJb?JzUtA*o_q
z>P?rJhk4TMBH!3GKt4*N%au`eCT1pzP8WRFt(_y99>McjJj3^?p1YBLELyKFr!JkI
z<%v2bPQrx=m}3|_qMlP3p`Gw5VvKiD_N?!zTOy)AOENsyG6C`Xpv=J#Ihv5-N*I+<
zV`Ba~j`f2XdFtwfq=Pgc7_<<{hW3|5hW!HVYSgO$1KQ)J{VN7Y;$NVp*tPi`AVJGa
zDRtjrn1MGPdW|{l82kQ|ki0rh6X|4S#=7w&54toq-uw%6%;PP2It;jl)ifGK0NX;`
z-3WyT{p29_p%A<$R$EgS%^GI$jvSIvh~i@NcW%=5-576cx_}pLyG31{Yj;bIp!d||
z`?y`tCw~D|Hep4)zT~MQ+(xAuOYplM(Ir&m;!7_w<MgtOEH&!eG=XBe(%m~ZsDg$P
z!Hc8njLI!4tWHu8{Te&%M;m(-j+&E`dqG@ZhZ72ZMtQ}|-pHd~pLy5JI7>I4jXf&`
zd1=rv15UDeo9V&MWm47$2mQYMs{_G6#M~cXflCNlw7bn|d>%X0K?!w)@I05o6r)kY
zdj+X<+ZMHe!89@%ZSZHmxHFA9>^743|MKWwsTA97mlTRS`}9OVY4L4sl9GY_G<3Ei
zGw~Jo6Jrzjet^8kM!l$Z+L~T_%7_}Y_~aOCl#{<o`XIuOgfC<LUR$iIVU0VE^jWB@
zGdGTqwhlz+#-FE;+V<S#nkSrn$$;Dac*Mg&R@GlCZ+>d>o+e46sDPc;XxNwiK2O!L
z*whE30wwRExT?>V(+5+U{LS^uPU(aP<Ki#|_?~Xn?wA`@%4fNSa2;owhd~t=K&Zzx
z$)ho0GQuH{YZt5EK!^(_CpTWX-He->+E=}C&*jMT$~Y+c^%Z%}dt>+K__14!>4)T%
zTOzW3(}>WzNT{#Gs`Mcs1dxe2{nE%_E19HT&***9N#E)BVldv#-`DltId6rSQ$Pw$
zC3auW`*V<)dA-Fzov2LJuJm+}KhZjBT#V>V`tN}YJoLPt5g52Am<^lD5hMnM5Yjk+
zhHglxIIGs)m{E1*-ExwE((>xsCzVC>d)h<><7UFx(f5-TwK(ec7rSI1KAKZ5q)8`P
z(!YpnYd=Xy%(C?+jS^M#E$V-^NB6ab^v4s9Nuf;W$ATpN=J|_;Yuz?Jxs?Zl57l4o
z$&^dFrqR;dq!ISyIbzwu#q4<;iz7t}bGc%)?dXu!j!PAc&a5925pTmu_syjFlLNX|
zXY}9TNsZ@2e}S$RpL2G53iii(uxePWB!B21!f+&$g4tC`OFjBX&FTGySpHXg-yPIc
z`>h*lsDg+TsZvBmKzb(v(xfRJLXo0015!f?U5ZFYK#KGt(gZ<zM~Wapss;#zUIao9
z5aQk6Z|>YV-<dh*{&DWPbLY<YNB&?k?7aKkYp-{$XFY2@qi;@zb}D!CW31mnY54?6
zbqtk$f4EIDSJh^Y86IA!wb(wlJT*t%OgND83<7~AYpsR$xiH{YM+?L@TNaWLKhZzc
z*7@GZf5B1=KJ7a}@`7c~O}((6O<HD@SU2FObrOxV)anPKL$HKFO2r{6F(;BwA4Ei8
z5*N>#+nb|MWEbP#xz)G~{K~hxg@CdQ&Js9*il+rK@sRxHC_&A+kIi#N-kVJoqKW}j
zppzi!zAUECf@&q(azVdi#SBoZd{31^vnFeJ_cOW!uQ|GhEc%hBRa-oYzsC3b<Fdj^
z%1aH)geKmcDUsOoy%>iEY-e~ulQzuMf+FK!wstnfm;xN}sn#ywWz((`$wbM1Vib4l
z1z!ixxWT%-j&2~!(;(5@hI-&=eH&#UMj=aTnlp=_#om*Xsm;($@&965je;|z6R_P~
z=k}ca&B(|MRN^bb&27jP_iFUk=)BIfh=37`2`GR#j*^22{Fm>fn0#Sjz6721;%^!m
z<hSfsG;>Vs|L_YSF{9EJe%<q#7u#BwIk0VwUpN3uVwec5O80SxOYt|Bw*0*7)|O6W
zY@FXe{$M09;YETASd6cUU7%_c&-de8wi*-S(r=$YNt4UYH->Mu?Fx{(4e|nG=*H`g
zMHrkcBr2H7D>qLJq;Cql8Aw6Gc$(fUu%kEgh=uTaqilvLJ^UKBIU_%Hf$$uPt+a`@
zp{!Tb?_~mT?^vOgDIeV@O5;cmL5%U4^(%+ua4n?uZIYSFJwTA>S#w=;)EfAru9w>f
zq9RiqOBf9-7qV>)*N*9&ewaeMc??=H&BEDW&{d0xudnInk3{sCdOQzwF5^$edelE%
z2?q<{%;K^JZ~$t;e>wo!?IgqjTsdfVcA(6S!1AT=>;0SjFF%UC6w~K$E<G7Dzx*`U
zBjme#I1=%E!D?RAQlx+HjL%|W8aR<P2FzwU4_*K;{ZpsT6ARFhYbV2o6t&w-*7SR~
zMw0uPZpow(Q=b0#yT2x1sEwHPA1oj<r3aX^THpJx(5xiTDNSLxXbIPxt;Mj$UmBO>
z-~1|luOn5#-bzZ}|A>ahXHXzlc5_COaC@UpcR!-1<w}~kd1Z^G$?g5)1SWs`7a?8L
zRG?E=I{J;4s*!Y*Z;dTn!DgGMu~~~XIG;T>xUAY)?w-qeb(y1G)v4~tHs@aHlDMT}
zUZ{c~wrA$?zDXYKF!EX1aI(Z~#8Wq<9?Q-EyQg1`5-z9^=i09gUs~YWW`YMqPL9-C
z%%Nk_B{)uY!K{NM`6TF2#Y4TRqj@_LrOXc&=)Nn|vpRL4pl_)L^EMV{A0_7}nYMNs
zbm~ZHg2)51&JO#(oYVCN*=z6HgdS@fU*e(;^%~n4Dr1xtrLWa5M*L(bemV_Iw4wC7
zh1ClSe6b+7aIf}@Jj-9fX4MB=w(^f%rUk?4qwPD{$sAwD)qfs$^VC0WidrMhr7TKk
zW;N%1`mJ~J>U7(TCQcCJ@9mRn)0k&CwVR{`_m><A8;KM12nT~pl~2EWEs%Zfk6d<V
z#>ww6=$8E&w5DG#Wv>o;P3Co!Pd(wcWZt0!b>6A&k)RM_O*8SK&k$wMzAs~+o2lSi
zV-st(_L~3owC21jZ^7Wx0H8VTY!XM;3&D=5_S*b%y-YmO7ypfZ@os+AZFFb0<zi+m
zUCQL#Ee~ez%#{X%G4#?rO>JNV6$zw<f-OL`W;40MSoC{um^(tb1ZqhV!8ns#M6ydc
zSc!byn3WdY8|1mI<p>?zA($lY@uU;|44{up2()Xf!1O0#Gt97Gi*KY_XjN(EZK|BF
z7A6e_ygCczop4ub17_gw%2)VTsZAR8ovgwsjk{G8y(SpbGrnYCGb?v(n_@UhFiA4V
zQni;hbOcUooPg0ZkFK74-W4={disU7m{&L7{;3w2<E3B@PPDZ*7a+lhm)Mb24WMA%
zyO}8HzTwq;I_r!lb>X}6S~Wt;&8cKJ{f*?;!y*L)3d&2;WqACbC-cS=J%`Isfeo}a
z1XqzUEoql~eO1t}=^8$b(IPuA)1T$`GZO*Qmq&tA9g?`$Faq<Lub$O$SuBOrv4eX~
z@-Yb)_AcnC)wLpUkSWl7DVJ&V7thOY9^Kv7GklizXwA@U@}2a~k1Zo27#sf;e=3-!
z;ngSIl{gVX*u6-J@{aF;e&J}XsV`|%L~kQzg_rYGT-K7Y+ZeTkHykCGgtQP}!_yf9
z7iIJ8W=k0=@rmQ_pa8rlUu|V_OUwOlbvfaR%B7a`&|kCdUnlpKsc7m`nv9?9>JztV
zU~)ew2=1#s#tM~wY)OxlV?8<}EmUTMp&#%jWQUzv?x!0047WmnSdvA=8x~@kFwkpp
z^VtFC;=^0XnkK9Q<#uz&R81@b5=1)z@K^+-Vva3H+H%5Ofa_osy~)wZ?PZaonbddi
zZ7aDj-O)ZY--qwy`jWLMR-`uqGn`#>#l^zyeZ{Z-=M5>d2BfXG2Mwrm_3l%wum=e`
z_I3z1?T2(JK0iM`MR%83&01<*o|wI+J-%y{hZqAFTKPq*)qT?5uCnf7)8OMfuq-UP
zI!P`-I(hC}QRZ?2U}zKWJMOll3d7FnYRFQfENotc%@v6~2AqqKdtb~cR(+2=&zUz*
zn2$zVifAQ6Xh08gN5Q_R8ynbvF7R4G&f&|rd&z-F<!Q=0mQnGa;hIR5wt&ar0=zOH
z)Vma~+IzUL?Xg)?HYbr(6nS~Zf8|Fy*F1;#bgO*!wzi1Kj_G6NHL1x%2kNGCnq$f3
zJPsfNS6tLTCxl#5-OxvgnLqu3SCpVJaoWpFN*H0hdOilOaN)c?CXt;C`>>q_%ULfr
zW!7Q~ez;a&kR=#n;N+lX=aJ_9Kb^#^KJF$4^80<u_xkgM3bEbhj+C_rJ2zKjx(6(m
zxi8k5fuscKQ-n+XN?>q}&O+)nE2$rzYWk{ZlrA#nm4E^{PKxYHX4&4WoS?@+FP}A~
z**^|04l{nyrctnEQa5kz%ET-Ml)b9b1>Zi?KaEicmRv#!r*ZW|UT3Wmn(x(ZSV-im
zRb@3BBhpFAcyCg(d!>-Syc-e=Xt{aEgL~isr%}AAdg-K;a8iR>EsPywIHdy6Wwc!C
z@qlxg6bp2;LcgW-E#KY$^vw3RhDA!#UL@o|8=?3IWZiioTHPOd=RH)H+H>G>{nr{i
zf=f2Ui|_{o5mB8Puh{J1A8W|85E3z;*n4JeE>vxxPBH_^!gA62$pS2hh<+*4Lmdfd
zkh=Nq&a!7AoS`XRi=)}=4`_REEBF>(^v4l|W@yQsstcu8R&xEFWLq4`2X4-?aPgdk
zChm0wkWVK71+JvHF6;v7aZyTYmmE5^5PuI4q5JC;N_^h>zmB0lpf_y~(04Ag-6S(X
z*DPmM*LGMq?M7p9Cv&BrJ6I8S#u_@wH_sPd+hrTJG{2!AxHrl`5q8s9CHbf0K3)@C
zXXaueSM{lRq6W6dEkF$QH&GMVqP(s!q2_)~TjDjlli28Q(335#8VW4oZ5~~xlM@0`
ztbNy6uB1XXEa%gc)m9>;r5O9Q(JP9swYacFUH1W{+v87jPi_N*`@?x<_R6|Je2PaL
zXKYcfSbwNo6CQ@qa#KQby{?D9%OQns3<-=O=3V{h)s+V&mkIZ9LD*8{gVxAAy$RtI
zrh{k9>mygd?BX1AC)|^rB$BX47Z^3vp7@;EoG#f1uUt~6txla<E<i#kNFN9^-*6`y
zO?zM5p%~Q8ej6WiLb_J<b4yCDq^W6Q54O7~K&%biAHJKX<0a0alkT`6L^@%YH>1zc
zO4O@d=SR7<9DC%bSI*(4butDSrP><|N$lgiK8cC$ouS{!9UgHeeHC%4&mHRfi7$21
z8xZvYgriYf98VaZWhQ_)i>DPE-{2(!{qF4`R7><d^+-k0>LdF3phIizeTcErU0ik<
zj$zr@O8jA@2~5T0tvY+!LbyH`+zE90VsX)=v<$n4kz9*A@r9pTr48z+!8warr&_ON
z+-%;W!^DD4s06<e$Z^#d*4X)zwDP&2(ml<0Dgr`HZLs&vidf^QAW`e`2W0=?rvHE8
zrZotlyq{vbByxV}zG>uLb0(C_12j$;*AQM!1uiAxQ|YdT%w&f=0uA7Jt57bTv=SF)
z&s4o^Tc~3`f8*#YA1E-8JwG=U+<)$ef3h#%O<<mw)AfSAeAe>QYgJI}TAs>v)|exn
z3LG^?FLB8|I*ar3^^<}U7kBn@p|5eRh%x?`(sY&}nSl=1aRe)N_5oH^TPcryhWU_2
z+us|r`qZEMDTq7>tOz8$f%{VDK>e-rdc8YQN10T1(VTjX_`_M9z9<<aVuy-oaA?Cd
zKNSP%4WV%M+Crs;Ww99vkE7?rNfKt2skAo8WhH;$W-&l$SrV@MP@inIsn67Rlu3<s
zbRtQabv=1NreD|2`45QfNVB>i&tgh4$Xf-jL0;h1!VlR!J$K}sBpM7xPH%s}Nq=SX
zrx4~pz!B(wB%5{+xqRA8m+Oo;21A3a$In&{_+%VejGrpLe7ycM_K1tpkNOeTYPZ~@
zMBo3jL6R1KTV<5Y;63#&MtUVXS%FZ&SJ8S{a6jzPf%A(!@9&=9``{qWWF6eH%vl6c
zoFgmCKnY0WLKT<LPe-Mk&$n@UDorW)uqu_^g>vX<sEf1h+*m)(!t%6}93dM>#RTPV
zboRjC{sBW?9@hs;M(i7Q6Bw}}(J%=iD(U8#y}ie&_i|sX-Dj~+Y@xp11#(=teneZE
zL4^xg&}xg7#XyZ4)1}$cx*iu_oqG(<!MS1*djPT%E&yp#`-4HVEKZ!PBj+sw@h!x^
z8yt%qKSD;y*?fiC&;d2R<_xnhN=~ieTUtDgK4dYlabJ*Q#L$4nk0u;l0smy(=8e(M
zC2FE)i(i_~L^s656U!y1aN?M?utle5H;fn*M|v6NEv3#Z0~|p_zd`v|J_55psZIf`
z?@G%bP_+m?-f#W)Y86Tw6R-MEtPtJn?MCXbSpVXqnBq&L^$FhTc0kpQpgd!94A3i*
zYu<NUMaYdSI4=ff4`)^bqN6aaakg1mDb0%2e&4(&DM4on2Tmkam-!8vWn<o*G^k{$
z@}Pi(^vz)yC~V-xXON=*QDx_w07M6KJ1(fIPU1_8Lb9^_?NOR%EWx%m2i1o?A(ZuW
z)GpDcVpdxLHQ0F@P4<G#G?wjzbpdqCB~<g%jQ7ydyxz2Yw(QJ{WEp_%`&i?#22Uve
z=Z=QSdv@*hO$n~%Nm}e5ewi39NG@fOjRXr{mWW6ONxnh_XTBJ8)H6=ZSj7geX4Y;o
zOV%xb>ea+lU2C?#pb*g_P8rno7eNbav~U75Ha&iENBs8<$^0lO`C?DFLe<tt05B>W
z6{?Vj@tL%~j%x<`6J3P4a|z2M4Pt<pnfb2=r-HXM#%9X=fX2?x*!6Hp=xlQ`HB{ko
zfx-~)9jbiz3c+0QV`ChF4Hq&%EGv2YS?s~hFY?3BDeopU@r6?$KP-O{x13MxY9|sY
zY?+o+gqqXm&G-5%*^`WgiUns9hst)6IeTq(e%5Qhw_&*RY2Gs5HljZNK?q0Y`HkNM
zFaW3V{^&&K0cpCTuf>-)&K0=e?T2qAq~KC(b20Zz=;IJ=^!MdFjPZh)3J8Ut@9e{g
z)m*5n=PD;ALU!(Jf+onv9u+F}uPJIGC~<<;RNiGIFEBO6bH;F4<czna<}wVR1*%Oa
z#w#$F`E9Gcc{FvaC5mDl8aiG5aW=dzEZu~qmvgG1e8Z%rCaPNE&PpcC@r%^R#)Fq7
z9!Z+KkVudx7bygQmOIS>J{TfxJ%qvgJ<q~&N2b?Oc8Iw0<f1X$`G%wkm0`L81!|UZ
zy`TmL$N*R3Z(@e6==9V5VO4M521e1Wdojs!6HO($=wHJbYU~HU_1<|trcWWC9ERF&
zJWY#M#b1np1t8rEQNGjeaHTiwzCQ|*S6$C~K8EF_u6cibhLCQ=K5s3;B_lWrtexN7
zQy+!Cd2N;QqQc&7-7RxyF$klAC;AavRgb<oQ!?>(6?VgC_UNJsA6ldRLqbuyH%mwE
zd8$kLbTVBUb58CG(A6<H21e$A5gd!itKH?Boc!ax+b3|Lcjz^<cLSjmRFy<`yFU+j
zSlJ{faAC8%0vx2XGNOyq){^*4u;>wo5Cfv5mx@6HRX(}*a9Ws!>sukH${7pa@+6C`
z{s)nR8)o#%O3Pq$xl;%kLb23kf2$=PT~KBHP&sbl8wX=TG|M{Y3ea@1(jmIB3GQ{L
zb_r0=ldMX}=DFXH&A+Je*hoohg`V-iU-I|4QmuXU#x$zx)wWPopPky%fPjb%4HfyT
zCL%AY8rbes?s04Fl&Pesaeu4J&5u1eQzCYvR;X~S+%^e7e9ydB(8NafMRW6b=ro@O
zLg{Lfb-E*1ZT)kwZkGC1B%fi@1?eMA#eU`PqZ+SjaUdk7#w%h%u5oy2G2hodv2_tT
zEsqgqbYz1w$$M(q4@v$S0|V9WC|Bw|O20HaXQ89*o?BfTaNe5r+UQm5-m)#Jtm-_n
z%lJMo)M(gp+7(q2-N~b2AxGUjy-8S6bNzeYA;yTC(MO7hlcw)FyA-clXjV4tc#iiQ
zW(x5(S(VN10(Gr1a{kCkYvIdM^@7q*xdWPC98$bj&0>DZK=y_bgG#HMZ4P`a)-U~P
z2(P2s#d|ug{7_&m%@(>b@y+yRNm{}tKX0paNSX3aV`vDmv+n}EaNF}#G>7`yP3k@?
zL=y2wtkk-U^1^f|>%KHWD=(&VyI+6RJcJCebSE3Fe_8s>c8g+XjD+Ak&(5lL;9#7A
z#6vLXoPh#~F~*Bvh9Q)Go)fB{Qv8Kr@ZbJFndNhuhd@^<10R!r1vK=^m$5Tn6IpRy
zk3DF=uMl8g4ioPS%F_g-)R7P5OYRyE`XMnj(RjBX`X7KA&{&*?zYB(s<O7&HTzpGr
zCl-`9fR<>$ibOq|DvcM&4j3S-O|{K@%?esPVpWtkeT&eTthU`3=w0Ak_^DV@LGis$
zzVV&X%L}cpb=PYXI9=ZW{ca&*q*3&fDfeR`Hzx{FetbcZrT5?fM8#vrYOSHrx#Q+|
z>4YTIsJZ@~ZBfWr_+O<kPy^X~!}ly}Wd%>DX0F{xB~@C#C!LPzYd<NB0`%gcYX|oP
zGPCs8?3s$ss@aZNKV1iVqAgTlkts$R+Pg&SD<nHB^!#)6#LlV5S%h^YrjvS;lVKdt
zimYNn)9l*k)W=`0*$+t&t#*+90j0j)FS`uvBt&2L`2%9@{8vJz_E$nyf0Re;93UNc
ztj{=$^qWDYFlNbe=scn{JP6HCY>`W~u)c)_5E#5XywFBV!FNVkwT*@(zLMo>l7=zI
z2a=)Vc;O(!6YDytw+MfGu_>8`kLhr*b}G))ANv_vKTTkFN`&1NN1+B>#Yny>xG;vx
zJAy7Lsv}g!b`TKEg)S37v7Vk5xkIxeF7^l15K4rv2%A(Q#|6XGq4T^?rX&nSFIP;&
z$>J`FSh;kT#~zcnBm0cF7=;kbwq<Xo{Tk;ji*ZbS#F~Qj>mU)2VIoWYuw9<o%fdDr
zXV0ZOZcj$;4zP``Am|M1*EeVb1R|6;os`I94NKMTWf;ck!e7p=dd#o_fypP51xbzm
zJSqfa8M-p*X0bMG@PK*8B;oqIE7@VB>;c#yTs}=mV!+q;8NIGma^^`^Hp2|6Ou=?c
zYMve&#K))CElvr#@gcuynF+(DF9=}2=WNtJYlIuvwp*L<rR}-K&UTg&2hTKF`^A)H
zkX1gOIBC7?u81C5$+3yAb*QtjjPEGXi1$rMPJq~pg%h-tfR;bYV&H(Ov4qD%R#p`N
z)WaG8mkac*D=;;5C_iZLbbwG?sus+p<Vo36%hflY4@k<7fI%-^S=Lp{LDFASk$#Qm
z2$kDK@skg`m?8J?>IHj^B}@`I_MbbTkYNq&a=)}K^&NToig0<(+`)WA*5cT}?p&h%
z#7LB)p|*KLtCqQ&a!V%b+nfrRDG7_bABRatWR3hjS9i^o?UvrHlh5eQ8*geI(|aC-
z{XDj#Sj>Cj*bedpCL9g)*pMj3Nq4X|wYIbc)uK?=I^!_H2~APlBAwxpMDW-rHP|98
zF`6ZdrLfgV^XE!o%sY^tKF~ke+RFt7oZ`H#&+F3mDIW>>l)y8R-|l-L(E8juM=jJ^
z8Y`T!JTHYFFv>k(saiXHi)yK0>So_HSq9qEQ+Gwi+n|^Md`2R$T|n{m$Zn=SEEHVg
zbweafq8<FTrSY|pV_V>NLnY5gTlSWp+~1OsddjCh;PmIM3~A5_{3(3FF03bpNF|WB
zS2x+PA#MZ6O@a@F5A~+-j=Q}w*L#;O=?}6*5yUb>D^F)k3!U$8Sa77Ly5Fnob)@QL
z8&UTBcwg)RNm&EPaNqs4P#Zs{_5Je$KqVGMTd27+W&Wv8SWlB>h_(6#B+7<P>84XU
zY9}(nJg83e)&;9Cqy5w)&(Me@za8uMaA)@rN6C`8JCbdK_9@b=rUv(wudf~;z&~u8
z((2#Cp%dJ1S9cbh*n%VC2o7UlY3#f^{^ow-W2|v*m2gQBAI)!;6_svPM~>@Z@_KUX
zxdGO=2)_<u+)xp&{p}n13t8^wfqgk)@(`KMy{sb$IUX{Gpe3y+QRSV}Pn6rjoDOpz
z3H%itm*Hl+P^O6zA0#e~ckMK9UE@n1`M9_k_v~#P`?)W`JL9~9Ep8d;;s}67irKgd
zDPs8$BZHn1`%Xguc4jKQc&Vo!W6h5XDI8>7922r|txOPSvkfkyqyWCYaW0}U4y#vW
z8rJ$ud*Z5T!g88q7RfR+;59iTxwsG|M;CT1zoYsnurX`L_v*{79?AJu7mPZ&$BZHw
z=w(Q~NzQj?%y&C&-`sEGt4qxfGzWuT(IjO4>{VK7(G|gn^jtdXG){V7vI;abJ=h=2
zm?5PP*(n20`qn5<*3Syr=;i583jOP>)cWhJJljLH_2`FY@p(SV3U049`}NK9q}GzQ
zY_{z1I|yhnt?Bhsx~*I4XWx5jg9>nw4{_4);!6@3ZXg^*UwjSTTtBRa=wXpjE4a-i
zMY?_|yN4aQ+Hc5H9AlW^==|%pITcrtJ_8m2s!HL<tBO^NKy6Hqlp4@Xe48zPn~<H@
zm=E$<&Z=1!iO%KP9}$hWn4ey{8B?7POUXYPrQiihAnY|U9V~buY<~p2VoQ!iJJ4Gw
zu~9$6?OSKtN@`ch4+w@cbrBxp)+Sms?;POsJ#8hNE#uzk5>H9D@EjuFhl7rBP>Ezi
z--~(+HQn%0nerQS&XV@skqqm=SnO}Sl`C0BFDzhsnlTE^!GqyVknH*E<ph_2Jn}%2
zt=fCh$(zo1gKG4%)Kc!@XRY2;*iWqSVkO_~PcK2}w>fWMVG*x=D0kb2uF8s%_msQq
zQFG;ge~y>H*%tdXVveIKPAYb!jkKO8?)ZxRcC;EGiVpeEU89SI_gs>6XL#Do1{Izf
zCehC{CU7d}w!Q?h9&ZB;E2aas@$jxtZ)SjOSfHx0bNvs9JMT)!%wfm|PdoM34$^V_
zGkEdbmN@$1xn-%7TI<IszVfriJA-Fn9XOzN1$^)0{_IMb;)<Z-oh<PeTg5r{@4xxw
zUny)e#n|A}Au%?`hXRBImy?gHc*r84?w!j&?XxYr$GL5iG$g09^+d~V;Wib;%IU38
zg$az%q!K+Y8fZ&&NfBxvIpxt-y@}!neG$zquDC<8ZKW|lclGBcgifS>Q$WAbg~%?P
z2H)pKmdzPTf~>w9^&yuGSF|**+S}3||2@6Aq*Wy~!z|Z<Mq|(uPPf#1g~S0~ZL<Uk
z!(Yc<bj@tP7`JqV6D&=T@cSu`rOWN|K_FDI+W^8b3v|r&cdWO$Gy2>crQf?l{tZK=
z&yn-|p>24j`Vw8!s9<qE9W~Cr3T1|H*&ogDxT_&t5OgQPqyHqq^jjiA6cScFvn<@|
zT!fIC;>k5)X8v)Rg}#R$HH%veAW8{2KVHja#y(G8wt1aL|DwU@t-tBG7Adyl*G+fX
zGs8;?p4LmQ#k}a>l1>eZdZ$mO*Iz|20MR!yhnOgGEGO_WShn0*d?T;!v-w<sRtJ)O
zq^jFSY}JxvmxStwE^^^OM?wCt^X<~rrjNi;4^T<mj<h!g5>Okr;bEa34G}a96kA0N
zy7?Pl&>Ukg>H{^>c6NBKs!z~chHX6{0g@+wDWGdoKpV4gz7IJU4k%mBtU<u`OX-NM
zT~asC`8>#-FhQl5xM16DV8Q|GAd7-&nHBDucH91OMw~+~)<r7WU$n2f;|ZIUKbu#M
z?B1raf-`nlWxu_TIV0Z7`9l}+0Ne><159N}QtsZI3m5~7SK#mCycTO{ZCqvo{F1s!
z7*h^>gOCvoDl2#Rmf20<UDQ((1ZG!wJmY6-*RxVl6(Tq_jUyE$s{p%~m2d{uU8SKT
z>d<UbQa8Ztik<GG<&k*0YV;qFYVr=Wg9dvmbJ0u$c2tr5i@Wu$j$M<_v-sM?3@SRE
zD_&y&QMGg<k4{N+^YgZLu|IRLE8j@ss$SKvoIBlv>wH|}O=Uj>aEAL{y(pV#pX}@k
zT>}T`n>%I<S99*5$%&Tv*lA#r3of0c3X1TL!{yGV=jpE%`ZA!b;RQ%b8iydFfd&_x
z2F5fR&tEQ8!8Y%5qlj4PS0FdsGLEAOM3W#6WH@xf`~C5Sy%);;gnNy2g<IHuW3)-U
z@hiLg+ILubxseLwLp3UGIA!dxer?wIo>~H%+2bL;nxL20jo`>kE7RCEu0kAAhe_^x
zO;!wCjpu#cL-fb_j`wsPmJE2}A7*^aO58JU61c%TPKVV$5*FZGNsL4V*kFAMYcrP&
z^wlwU?<NbQD0owHj*bz7)UNLaTW+48&(5Z?hUSl>OR#o??)Z)YYLu);{e3&oFt0eY
zGPMN~jKBd|2T$7iWu!ag$QhXH33-)waK}32rwPzkqMilXyA4cA|L61n?j9^2{S7;w
zah21pZU^QHn09}!ntU!xEHx3a;X2wNLO+YsUfQh*`tZv|1O_ji9binKuDQ)`{&}zp
zg0tiV0>nHHpp->c_ZSStT#^s;%5i*2EUl<2`DDwI+{kHGJ9M6E;j{h+gl+oEIVs7l
z6Q~`E2+ZK<ko5t}KcMaxZ;3V-O#w`)XA!%H$8G1~gi;d!-IeoA!AtJ1I2rc!3eV%e
z*Pmq6ag6IailjRz71OH+?WY2m_<#K0WQo)Wer(>WnrXu5I5c}@Rak`Ykd^KO3y2Hx
zyfqfE*T4N5a4qVH-p<42>X5}RKq-kT!Ovg`t?4j2#8_lM7Iy={1TioD-~@yZ63;ZG
zffuH`@&|-W01BMpzktyX1V*~B&UN$!pbM0U1Fl5{?piq93j$&^4ZNW0-|jo)->f;5
zAA8y(Lgi;~d?P)Zc6^QkecvJHQ!g<cmnyV_0UHdki-oNq8d?Tu^SIyqss3|DA~uDw
z>mmQiQpRrAKmaX)Zp^~j{tN^Q<>&ghj{qR&76Q{~{^JEH694bFW({Gps7N<(6?LnD
zeOHM3U0eAhdtdQ9n-)Rl|M<e<zy>}5BoKo3I<Wx5JCX~VkDvuC<8%SX7}8S@`A=@?
zBX%JgASF{dz1+NEG594Z-GM=AIh{WdVrVh-Up28O)**j;^8a=n4>-fr{QrRd{;dDD
zx1a#B>;J6apFQ~h!w!sL>OHiE+N~42s%(KDtSMD;I4Vo@=-g;M{^mpeog1I@bL_Q%
zzp6JodVj|OYUJzl*UKrZF#Ywv`_&=aW5Nq#JL7gE*GioEOq;0Os)`ThLpO8tmnY+<
zgTt`UZZy}V!6mHPz1sfikM^UErz&zB`5^tt8}R?qJKb66C!&ERw13=|q7*~BBsesS
z+*;+UwGW$3aV_|7_r8Ka7Wbbx%l`}hf04itGFSpUURx;g@`lUb0|KKwit#6l&HU+<
z1=qHi#d*H7s^1-F0A|3#-~Rg+uz&srG5)g$|Lnm(Ht>%P{9^<EM{OYF&#(UhJn!4M

literal 0
HcmV?d00001


From c1e1d5c451f1f565f1c1fe529f333931633d1a71 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 21 Dec 2023 18:50:15 +0100
Subject: [PATCH 0482/1315] irinterp: Don't give bad answers on encountering
 try/catch (#52601)

We generally don't model try/catch in irinterp, but let's at least add
the cases and make them do nothing, rather than assuming these nodes are
literals and giving bad type results.

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
---
 base/compiler/optimize.jl       | 2 +-
 base/compiler/ssair/irinterp.jl | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 57fb1082add5e..64c25584f0449 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -385,7 +385,7 @@ function argextype(
         return Const(x.value)
     elseif isa(x, GlobalRef)
         return abstract_eval_globalref_type(x)
-    elseif isa(x, PhiNode)
+    elseif isa(x, PhiNode) || isa(x, PhiCNode) || isa(x, UpsilonNode)
         return Any
     elseif isa(x, PiNode)
         return x.typ
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index cc93757a60cbc..7e454612a4eb6 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -184,6 +184,11 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
         end
     elseif isa(stmt, PhiNode)
         rt = abstract_eval_phi_stmt(interp, stmt, idx, irsv)
+    elseif isa(stmt, UpsilonNode)
+        rt = argextype(stmt.val, irsv.ir)
+    elseif isa(stmt, PhiCNode)
+        # Currently not modeled
+        return false
     elseif isa(stmt, ReturnNode)
         # Handled at the very end
         return false

From 1290b51a478602f4672e481ba6e5b1eed706843a Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Fri, 22 Dec 2023 11:09:56 +0100
Subject: [PATCH 0483/1315] Lowering: Insert QuoteNode for captured boxed value
 (#52596)

`Core.Box` is not self-quoting so it should be captured in a QuoteNode.
This has been benign until the improved effect system, we handle
`QuoteNode`
of a mutable value as a global access, whereas a direct reference to a
value
is treated as inaccessible memory.

Fixes #52531

---------

Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com>
Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 src/julia-syntax.scm     |  2 +-
 test/compiler/effects.jl | 17 +++++++++++++++--
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index e7899688453c7..4f91c6fc5b023 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -3586,7 +3586,7 @@ f(x) = yt(x)
                   (rhs  (convert-for-type-decl rhs1 (cl-convert vt fname lam #f #f #f interp opaq (table) locals) #t lam))
                   (ex (cond (closed `(call (core setfield!)
                                            ,(if interp
-                                                `($ ,var)
+                                                `($ (call (core QuoteNode) ,var))
                                                 (capt-var-access var fname opaq))
                                            (inert contents)
                                            ,rhs))
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 0c95ca0a29aab..2c303f5335633 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1347,9 +1347,9 @@ const a52531 = Core.Ref(1)
 @test !Core.Compiler.is_consistent(Base.infer_effects(getref52531))
 let
     global set_a52531!, get_a52531
-    _a::Int       = -1
+    _a::Int             = -1
     set_a52531!(a::Int) = (_a = a; return get_a52531())
-    get_a52531()       = _a
+    get_a52531()        = _a
 end
 @test !Core.Compiler.is_consistent(Base.infer_effects(set_a52531!, (Int,)))
 @test !Core.Compiler.is_consistent(Base.infer_effects(get_a52531, ()))
@@ -1357,6 +1357,19 @@ end
 @test set_a52531!(1) == 1
 @test get_a52531() == 1
 
+let
+    global is_initialized52531, set_initialized52531!
+    _is_initialized                   = false
+    set_initialized52531!(flag::Bool) = (_is_initialized = flag)
+    is_initialized52531()             = _is_initialized
+end
+top_52531(_) = (set_initialized52531!(true); nothing)
+@test !Core.Compiler.is_consistent(Base.infer_effects(is_initialized52531))
+@test !Core.Compiler.is_removable_if_unused(Base.infer_effects(set_initialized52531!, (Bool,)))
+@test !is_initialized52531()
+top_52531(0)
+@test is_initialized52531()
+
 @test Core.Compiler.is_inaccessiblememonly(Base.infer_effects(identity∘identity, Tuple{Any}))
 @test Core.Compiler.is_inaccessiblememonly(Base.infer_effects(()->Vararg, Tuple{}))
 

From 878b0c00b9a193c642b2f124753ba3854f2e4112 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 22 Dec 2023 14:07:20 +0100
Subject: [PATCH 0484/1315] sroa: More fixes for KeyValue optimization (#52602)

Fixes some mistakes in #52542 that led to the following issue:
```
function persistent_dict_elim_multiple_phi2(c::Bool)
           z = Base.inferencebarrier(1)::Int
           if c
               a = Base.PersistentDict(:a => z)
           else
               a = Base.PersistentDict(:a => z)
           end
           b = Base.PersistentDict(a, :b => 2)
           return b[:a]
end

julia> persistent_dict_elim_multiple_phi2(true)
ERROR: KeyError: key :a not found
Stacktrace:
 [1] getindex
   @ Base ./dict.jl:1010 [inlined]
 [2] persistent_dict_elim_multiple_phi2(c::Bool)
   @ Main ./REPL[1]:9
 [3] top-level scope
   @ REPL[3]:1
```

i.e. sroa incorrectly thought the value was not found.
---
 base/compiler/ssair/passes.jl | 130 +++++++++++++++++++++-------------
 test/compiler/irpasses.jl     |  12 ++++
 2 files changed, 92 insertions(+), 50 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 754d0a6cefd8b..005545f473f07 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -190,8 +190,18 @@ function collect_leaves(compact::IncrementalCompact, @nospecialize(val), @nospec
     return walk_to_defs(compact, val, typeconstraint, predecessors, 𝕃ₒ)
 end
 
-function simple_walk(compact::IncrementalCompact, @nospecialize(defssa#=::AnySSAValue=#),
-                     callback = (@nospecialize(pi), @nospecialize(idx)) -> false)
+function trivial_walker(@nospecialize(pi), @nospecialize(idx))
+    return nothing
+end
+
+function pi_walker(@nospecialize(pi), @nospecialize(idx))
+    if isa(pi, PiNode)
+        return LiftedValue(pi.val)
+    end
+    return nothing
+end
+
+function simple_walk(compact::IncrementalCompact, @nospecialize(defssa#=::AnySSAValue=#), callback=trivial_walker)
     while true
         if isa(defssa, OldSSAValue)
             if already_inserted(compact, defssa)
@@ -207,27 +217,26 @@ function simple_walk(compact::IncrementalCompact, @nospecialize(defssa#=::AnySSA
             end
         end
         def = compact[defssa][:stmt]
-        if isa(def, PiNode)
-            if callback(def, defssa)
-                return defssa
-            end
-            def = def.val
-            if isa(def, SSAValue)
-                is_old(compact, defssa) && (def = OldSSAValue(def.id))
-            else
-                return def
-            end
-            defssa = def
-        elseif isa(def, AnySSAValue)
+        if isa(def, AnySSAValue)
             callback(def, defssa)
             if isa(def, SSAValue)
                 is_old(compact, defssa) && (def = OldSSAValue(def.id))
             end
             defssa = def
-        elseif isa(def, Union{PhiNode, PhiCNode, Expr, GlobalRef})
+        elseif isa(def, Union{PhiNode, PhiCNode, GlobalRef})
             return defssa
         else
-            return def
+            new_def = callback(def, defssa)
+            if new_def === nothing
+                return defssa
+            end
+            new_def = new_def.val
+            if !isa(new_def, AnySSAValue)
+                return new_def
+            elseif isa(new_def, SSAValue)
+                is_old(compact, defssa) && (new_def = OldSSAValue(new_def.id))
+            end
+            defssa = new_def
         end
     end
 end
@@ -237,8 +246,9 @@ function simple_walk_constraint(compact::IncrementalCompact, @nospecialize(defss
     callback = function (@nospecialize(pi), @nospecialize(idx))
         if isa(pi, PiNode)
             typeconstraint = typeintersect(typeconstraint, widenconst(pi.typ))
+            return LiftedValue(pi.val)
         end
-        return false
+        return nothing
     end
     def = simple_walk(compact, defssa, callback)
     return Pair{Any, Any}(def, typeconstraint)
@@ -623,13 +633,14 @@ end
 struct SkipToken end; const SKIP_TOKEN = SkipToken()
 
 function lifted_value(compact::IncrementalCompact, @nospecialize(old_node_ssa#=::AnySSAValue=#), @nospecialize(old_value),
-                      lifted_philikes::Vector{LiftedPhilike}, lifted_leaves::Union{LiftedLeaves, LiftedDefs}, reverse_mapping::IdDict{AnySSAValue, Int})
+                      lifted_philikes::Vector{LiftedPhilike}, lifted_leaves::Union{LiftedLeaves, LiftedDefs}, reverse_mapping::IdDict{AnySSAValue, Int},
+                      walker_callback)
     val = old_value
     if is_old(compact, old_node_ssa) && isa(val, SSAValue)
         val = OldSSAValue(val.id)
     end
     if isa(val, AnySSAValue)
-        val = simple_walk(compact, val)
+        val = simple_walk(compact, val, def_walker(lifted_leaves, reverse_mapping, walker_callback))
     end
     if val in keys(lifted_leaves)
         lifted_val = lifted_leaves[val]
@@ -639,8 +650,7 @@ function lifted_value(compact::IncrementalCompact, @nospecialize(old_node_ssa#=:
         lifted_val === nothing && return UNDEF_TOKEN
         val = lifted_val.val
         if isa(val, AnySSAValue)
-            callback = (@nospecialize(pi), @nospecialize(idx)) -> true
-            val = simple_walk(compact, val, callback)
+            val = simple_walk(compact, val, pi_walker)
         end
         return val
     elseif isa(val, AnySSAValue) && val in keys(reverse_mapping)
@@ -657,15 +667,16 @@ function is_old(compact, @nospecialize(old_node_ssa))
     return true
 end
 
-struct PhiNest
+struct PhiNest{C}
     visited_philikes::Vector{AnySSAValue}
     lifted_philikes::Vector{LiftedPhilike}
     lifted_leaves::Union{LiftedLeaves, LiftedDefs}
     reverse_mapping::IdDict{AnySSAValue, Int}
+    walker_callback::C
 end
 
 function finish_phi_nest!(compact::IncrementalCompact, nest::PhiNest)
-    (;visited_philikes, lifted_philikes, lifted_leaves, reverse_mapping) = nest
+    (;visited_philikes, lifted_philikes, lifted_leaves, reverse_mapping, walker_callback) = nest
     nphilikes = length(lifted_philikes)
     # Fix up arguments
     for i = 1:nphilikes
@@ -680,7 +691,7 @@ function finish_phi_nest!(compact::IncrementalCompact, nest::PhiNest)
             for i = 1:length(old_node.values)
                 isassigned(old_node.values, i) || continue
                 val = lifted_value(compact, old_node_ssa, old_node.values[i],
-                                   lifted_philikes, lifted_leaves, reverse_mapping)
+                                   lifted_philikes, lifted_leaves, reverse_mapping, walker_callback)
                 val !== SKIP_TOKEN && push!(new_node.edges, old_node.edges[i])
                 if val === UNDEF_TOKEN
                     resize!(new_node.values, length(new_node.values)+1)
@@ -694,9 +705,9 @@ function finish_phi_nest!(compact::IncrementalCompact, nest::PhiNest)
             then_result, else_result = old_node.args[3], old_node.args[4]
 
             then_result = lifted_value(compact, old_node_ssa, then_result,
-                                       lifted_philikes, lifted_leaves, reverse_mapping)
+                                       lifted_philikes, lifted_leaves, reverse_mapping, walker_callback)
             else_result = lifted_value(compact, old_node_ssa, else_result,
-                                       lifted_philikes, lifted_leaves, reverse_mapping)
+                                       lifted_philikes, lifted_leaves, reverse_mapping, walker_callback)
 
             # In cases where the Core.ifelse condition is statically-known, e.g., thanks
             # to a PiNode from a guarding conditional, replace with the remaining branch.
@@ -726,10 +737,20 @@ function finish_phi_nest!(compact::IncrementalCompact, nest::PhiNest)
     end
 end
 
+function def_walker(lifted_leaves::Union{LiftedLeaves, LiftedDefs}, reverse_mapping::IdDict{AnySSAValue, Int}, walker_callback)
+    function (@nospecialize(walk_def), @nospecialize(defssa))
+        if (defssa in keys(lifted_leaves)) || (isa(defssa, AnySSAValue) && defssa in keys(reverse_mapping))
+            return nothing
+        end
+        isa(walk_def, PiNode) && return LiftedValue(walk_def.val)
+        return walker_callback(walk_def, defssa)
+    end
+end
+
 function perform_lifting!(compact::IncrementalCompact,
         visited_philikes::Vector{AnySSAValue}, @nospecialize(cache_key),
         @nospecialize(result_t), lifted_leaves::Union{LiftedLeaves, LiftedDefs}, @nospecialize(stmt_val),
-        lazydomtree::Union{LazyDomtree,Nothing})
+        lazydomtree::Union{LazyDomtree,Nothing}, walker_callback = trivial_walker)
     reverse_mapping = IdDict{AnySSAValue, Int}()
     for id in 1:length(visited_philikes)
         reverse_mapping[visited_philikes[id]] = id
@@ -777,10 +798,10 @@ function perform_lifting!(compact::IncrementalCompact,
             end
         end
         if dominates_all
-            if isa(the_leaf, OldSSAValue)
-                the_leaf = simple_walk(compact, the_leaf)
+            if isa(the_leaf_val, OldSSAValue)
+                the_leaf = LiftedValue(simple_walk(compact, the_leaf_val))
             end
-            return Pair{Any, PhiNest}(the_leaf, PhiNest(visited_philikes, Vector{LiftedPhilike}(undef, 0), lifted_leaves, reverse_mapping))
+            return Pair{Any, PhiNest}(the_leaf, PhiNest(visited_philikes, Vector{LiftedPhilike}(undef, 0), lifted_leaves, reverse_mapping, walker_callback))
         end
     end
 
@@ -812,16 +833,18 @@ function perform_lifting!(compact::IncrementalCompact,
 
     # Fixup the stmt itself
     if isa(stmt_val, Union{SSAValue, OldSSAValue})
-        stmt_val = simple_walk(compact, stmt_val)
+        stmt_val = simple_walk(compact, stmt_val, def_walker(lifted_leaves, reverse_mapping, walker_callback))
     end
 
     if stmt_val in keys(lifted_leaves)
         stmt_val = lifted_leaves[stmt_val]
     elseif isa(stmt_val, AnySSAValue) && stmt_val in keys(reverse_mapping)
         stmt_val = LiftedValue(lifted_philikes[reverse_mapping[stmt_val]].ssa)
+    else
+        error()
     end
 
-    return Pair{Any, PhiNest}(stmt_val, PhiNest(visited_philikes, lifted_philikes, lifted_leaves, reverse_mapping))
+    return Pair{Any, PhiNest}(stmt_val, PhiNest(visited_philikes, lifted_philikes, lifted_leaves, reverse_mapping, walker_callback))
 end
 
 function lift_svec_ref!(compact::IncrementalCompact, idx::Int, stmt::Expr)
@@ -879,9 +902,8 @@ function lift_leaves_keyvalue(compact::IncrementalCompact, @nospecialize(key),
                 end
                 if set_key === key || (egal_tfunc(𝕃ₒ, argextype(key, compact), argextype(set_key, compact)) == Const(true))
                     lift_arg!(compact, leaf, cache_key, def, set_val_idx, lifted_leaves)
-                    break
+                    continue
                 end
-                continue
             end
         end
         return nothing
@@ -889,11 +911,8 @@ function lift_leaves_keyvalue(compact::IncrementalCompact, @nospecialize(key),
     return lifted_leaves
 end
 
-function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 𝕃ₒ::AbstractLattice)
-    collection = stmt.args[end-1]
-    key = stmt.args[end]
-
-    function keyvalue_predecessors(@nospecialize(def), compact::IncrementalCompact)
+function keyvalue_predecessors(@nospecialize(key), 𝕃ₒ::AbstractLattice)
+    function(@nospecialize(def), compact::IncrementalCompact)
         if is_known_invoke_or_call(def, Core.OptimizedGenerics.KeyValue.set, compact)
             @assert isexpr(def, :invoke)
             if length(def.args) in (5, 6)
@@ -921,8 +940,13 @@ function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 
         end
         return phi_or_ifelse_predecessors(def, compact)
     end
+end
+
+function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 𝕃ₒ::AbstractLattice)
+    collection = stmt.args[end-1]
+    key = stmt.args[end]
 
-    leaves, visited_philikes = collect_leaves(compact, collection, Any, 𝕃ₒ, keyvalue_predecessors)
+    leaves, visited_philikes = collect_leaves(compact, collection, Any, 𝕃ₒ, keyvalue_predecessors(key, 𝕃ₒ))
     isempty(leaves) && return
 
     lifted_leaves = lift_leaves_keyvalue(compact, key, leaves, 𝕃ₒ)
@@ -934,8 +958,16 @@ function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 
         result_t = tmerge(𝕃ₒ, result_t, argextype(v.val, compact))
     end
 
+    function keyvalue_walker(@nospecialize(def), _)
+        if is_known_invoke_or_call(def, Core.OptimizedGenerics.KeyValue.set, compact)
+            @assert length(def.args) in (5, 6)
+            return LiftedValue(def.args[end-2])
+        end
+        return nothing
+    end
     (lifted_val, nest) = perform_lifting!(compact,
-        visited_philikes, key, result_t, lifted_leaves, collection, nothing)
+        visited_philikes, key, result_t, lifted_leaves, collection, nothing,
+        keyvalue_walker)
 
     compact[idx] = lifted_val === nothing ? nothing : Expr(:call, GlobalRef(Core, :tuple), lifted_val.val)
     finish_phi_nest!(compact, nest)
@@ -1138,8 +1170,10 @@ struct IntermediaryCollector
     intermediaries::SPCSet
 end
 function (this::IntermediaryCollector)(@nospecialize(pi), @nospecialize(ssa))
-    push!(this.intermediaries, ssa.id)
-    return false
+    if !isa(pi, Expr)
+        push!(this.intermediaries, ssa.id)
+    end
+    return nothing
 end
 
 """
@@ -1212,11 +1246,7 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
                 preserved_arg = stmt.args[pidx]
                 isa(preserved_arg, SSAValue) || continue
                 let intermediaries = SPCSet()
-                    callback = function (@nospecialize(pi), @nospecialize(ssa))
-                        push!(intermediaries, ssa.id)
-                        return false
-                    end
-                    def = simple_walk(compact, preserved_arg, callback)
+                    def = simple_walk(compact, preserved_arg, IntermediaryCollector(intermediaries))
                     isa(def, SSAValue) || continue
                     defidx = def.id
                     def = compact[def][:stmt]
@@ -2302,10 +2332,10 @@ function cfg_simplify!(ir::IRCode)
     bb_rename_pred = zeros(Int, length(bbs))
     for i = 1:length(bbs)
         if bb_rename_succ[i] == 0
-            bb_rename_succ[i] = -1
+            bb_rename_succ[i] = -2
             bb_rename_pred[i] = -2
         elseif bb_rename_succ[i] == typemin(Int)
-            bb_rename_succ[i] = -1
+            bb_rename_succ[i] = -2
         end
     end
 
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 97e80fca6cba1..da717803d93e4 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1575,6 +1575,18 @@ end
 @test_broken fully_eliminated(persistent_dict_elim_multiple_phi)
 @test code_typed(persistent_dict_elim_multiple_phi)[1][1].code[end] == Core.ReturnNode(1)
 
+function persistent_dict_elim_multiple_phi2(c::Bool)
+    z = Base.inferencebarrier(1)::Int
+    if c
+        a = Base.PersistentDict(:a => z)
+    else
+        a = Base.PersistentDict(:a => z)
+    end
+    b = Base.PersistentDict(a, :b => 2)
+    return b[:a]
+end
+@test persistent_dict_elim_multiple_phi2(true) == 1
+
 # Test CFG simplify with try/catch blocks
 let code = Any[
         # Block 1

From 9443c761871c4db9c3213a1e01804286292c3f4d Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Fri, 22 Dec 2023 14:35:14 +0100
Subject: [PATCH 0485/1315] When setting `JULIA_DEPOT_PATH` to `/path:`, omit
 the default user depot (#51448)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit slightly changes how the `DEPOT_PATH` works when overriden using
the env var `JULIA_DEPOT_PATH`, now omitting the default user depot when
specifying a path.

Before:

```
❯ JULIA_DEPOT_PATH=/foo: \
  julia-1.10 -e 'display(DEPOT_PATH)'
4-element Vector{String}:
 "/foo"
 "/home/tim/.julia"
 "/path/to/julia/local/share/julia"
 "/path/to/julia/share/julia"
```

After:

```
❯ JULIA_DEPOT_PATH=/foo: \
  julia-pr -e 'display(DEPOT_PATH)'
3-element Vector{String}:
 "/foo"
 "/path/to/julia/local/share/julia"
 "/path/to/julia/share/julia"
```

This makes it possibly to create a new isolated depot by simply
setting `JULIA_DEPOT_PATH` to `/path:`, while still being able
to load resources that are bundled with Julia.

For a full discussion, see the PR.
---
 NEWS.md                                 |  3 ++
 base/initdefs.jl                        | 22 +++++++++++----
 doc/src/manual/environment-variables.md | 37 +++++++++++++++----------
 test/loading.jl                         | 13 +++++----
 4 files changed, 49 insertions(+), 26 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 0ec643882a4af..6dd7335186a08 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -34,6 +34,9 @@ Language changes
   pkgimage caches for all other packages than the package being tested, likely meaning faster test
   execution. ([#52123])
 
+* Specifying a path in `JULIA_DEPOT_PATH` now results in the expansion of empty strings to
+  omit the default user depot ([#51448]).
+
 Compiler/Runtime improvements
 -----------------------------
 * Updated GC heuristics to count allocated pages instead of individual objects ([#50144]).
diff --git a/base/initdefs.jl b/base/initdefs.jl
index 6309781579500..56c2c0c587272 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -94,9 +94,7 @@ See also [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH), and
 """
 const DEPOT_PATH = String[]
 
-function append_default_depot_path!(DEPOT_PATH)
-    path = joinpath(homedir(), ".julia")
-    path in DEPOT_PATH || push!(DEPOT_PATH, path)
+function append_bundled_depot_path!(DEPOT_PATH)
     path = abspath(Sys.BINDIR, "..", "local", "share", "julia")
     path in DEPOT_PATH || push!(DEPOT_PATH, path)
     path = abspath(Sys.BINDIR, "..", "share", "julia")
@@ -108,17 +106,31 @@ function init_depot_path()
     empty!(DEPOT_PATH)
     if haskey(ENV, "JULIA_DEPOT_PATH")
         str = ENV["JULIA_DEPOT_PATH"]
+
+        # explicitly setting JULIA_DEPOT_PATH to the empty string means using no depot
         isempty(str) && return
+
+        # otherwise, populate the depot path with the entries in JULIA_DEPOT_PATH,
+        # expanding empty strings to the bundled depot
+        populated = false
         for path in eachsplit(str, Sys.iswindows() ? ';' : ':')
             if isempty(path)
-                append_default_depot_path!(DEPOT_PATH)
+                append_bundled_depot_path!(DEPOT_PATH)
             else
                 path = expanduser(path)
                 path in DEPOT_PATH || push!(DEPOT_PATH, path)
+                populated = true
             end
         end
+
+        # backwards compatibility: if JULIA_DEPOT_PATH only contains empty entries
+        # (e.g., JULIA_DEPOT_PATH=':'), make sure to use the default depot
+        if !populated
+            pushfirst!(DEPOT_PATH, joinpath(homedir(), ".julia"))
+        end
     else
-        append_default_depot_path!(DEPOT_PATH)
+        push!(DEPOT_PATH, joinpath(homedir(), ".julia"))
+        append_bundled_depot_path!(DEPOT_PATH)
     end
     nothing
 end
diff --git a/doc/src/manual/environment-variables.md b/doc/src/manual/environment-variables.md
index 4d591faedc8f1..e1e450998f016 100644
--- a/doc/src/manual/environment-variables.md
+++ b/doc/src/manual/environment-variables.md
@@ -136,23 +136,30 @@ as Julia's code loading mechanisms, look for package registries, installed
 packages, named environments, repo clones, cached compiled package images,
 configuration files, and the default location of the REPL's history file.
 
-Unlike the shell `PATH` variable but similar to [`JULIA_LOAD_PATH`](@ref JULIA_LOAD_PATH), empty entries in
-[`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH) are expanded to the default value of `DEPOT_PATH`. This allows
-easy appending, prepending, etc. of the depot path value in shell scripts regardless
-of whether [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH) is already set or not. For example, to prepend the
-directory `/foo/bar` to `DEPOT_PATH` just do
+Unlike the shell `PATH` variable but similar to [`JULIA_LOAD_PATH`](@ref JULIA_LOAD_PATH),
+empty entries in [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH) are expanded to the default
+value of `DEPOT_PATH`, excluding the user depot. This allows easy overriding of the user
+depot, while still retaining access to resources that are bundled with Julia, like cache
+files, artifacts, etc. For example, to switch the user depot to `/foo/bar` just do
 ```sh
-export JULIA_DEPOT_PATH="/foo/bar:$JULIA_DEPOT_PATH"
+export JULIA_DEPOT_PATH="/foo/bar:"
 ```
-If the [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH) environment variable is already set, its old value will be
-prepended with `/foo/bar`. On the other hand, if [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH) is not set, then
-it will be set to `/foo/bar:` which will have the effect of prepending `/foo/bar` to
-the default depot path. If [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH) is set to the empty string, it expands
-to an empty `DEPOT_PATH` array. In other words, the empty string is interpreted as a
-zero-element array, not a one-element array of the empty string. This behavior was
-chosen so that it would be possible to set an empty depot path via the environment
-variable. If you want the default depot path, either unset the environment variable
-or if it must have a value, set it to the string `:`.
+All package operations, like cloning registrise or installing packages, will now write to
+`/foo/bar`, but since the empty entry is expanded to the default system depot, any bundled
+resources will still be available. If you really only want to use the depot at `/foo/bar`,
+and not load any bundled resources, simply set the environment variable to `/foo/bar`
+without the trailing colon.
+
+There are two exceptions to the above rule. First, if [`JULIA_DEPOT_PATH`](@ref
+JULIA_DEPOT_PATH) is set to the empty string, it expands to an empty `DEPOT_PATH` array. In
+other words, the empty string is interpreted as a zero-element array, not a one-element
+array of the empty string. This behavior was chosen so that it would be possible to set an
+empty depot path via the environment variable.
+
+Second, if no user depot is specified in [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH), then
+the empty entry is expanded to the default depot *including* the user depot. This makes
+it possible to use the default depot, as if the environment variable was unset, by setting
+it to the string `:`.
 
 !!! note
 
diff --git a/test/loading.jl b/test/loading.jl
index 826107c8aab87..e17192e6c5571 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -721,16 +721,17 @@ end
 @testset "expansion of JULIA_DEPOT_PATH" begin
     s = Sys.iswindows() ? ';' : ':'
     tmp = "/this/does/not/exist"
-    DEFAULT = Base.append_default_depot_path!(String[])
+    default = joinpath(homedir(), ".julia")
+    bundled = Base.append_bundled_depot_path!(String[])
     cases = Dict{Any,Vector{String}}(
-        nothing => DEFAULT,
+        nothing => [default; bundled],
         "" => [],
-        "$s" => DEFAULT,
-        "$tmp$s" => [tmp; DEFAULT],
-        "$s$tmp" => [DEFAULT; tmp],
+        "$s" => [default; bundled],
+        "$tmp$s" => [tmp; bundled],
+        "$s$tmp" => [bundled; tmp],
         )
     for (env, result) in pairs(cases)
-        script = "DEPOT_PATH == $(repr(result)) || error()"
+        script = "DEPOT_PATH == $(repr(result)) || error(\"actual depot \" * join(DEPOT_PATH,':') * \" does not match expected depot \" * join($(repr(result)), ':'))"
         cmd = `$(Base.julia_cmd()) --startup-file=no -e $script`
         cmd = addenv(cmd, "JULIA_DEPOT_PATH" => env)
         cmd = pipeline(cmd; stdout, stderr)

From 40bc64c2c213f0e3bf6c91f9b5868221ec4b0c05 Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Fri, 22 Dec 2023 12:21:11 -0800
Subject: [PATCH 0486/1315] Fix `show` for `MethodList` when methods are from
 another module (#52354)

When a type is defined in one module but its methods are defined
elsewhere, `show_method_table` errors due to an incorrect lookup of the
defining module used to determine colors for printing. In particular,
the code had been assuming that the type is defined in the module in
which its constructor's first method (in the sense of
`first(methods())`) is defined, which isn't always true.

The color used for printing the module name needs to be determined on a
per-method basis and can't be correctly done based on the method table's
module. For each method, we attempt to derive the module for the method
table to which the method was added, then determine whether it's the
same as the defining module for the method.

Fixes #49382
Fixes #49403
Fixes #52043

Co-Authored-By: Jameson Nash <vtjnash@gmail.com>
---
 base/methodshow.jl | 37 ++++++++++++++++++++++++-------------
 base/reflection.jl |  6 +++++-
 test/show.jl       |  7 +++++++
 3 files changed, 36 insertions(+), 14 deletions(-)

diff --git a/base/methodshow.jl b/base/methodshow.jl
index 0eb99dc88303f..477acd2960c48 100644
--- a/base/methodshow.jl
+++ b/base/methodshow.jl
@@ -286,6 +286,29 @@ function show_method_list_header(io::IO, ms::MethodList, namefmt::Function)
     !iszero(n) && print(io, ":")
 end
 
+# Determine the `modulecolor` value to pass to `show_method`
+function _modulecolor(method::Method)
+    mmt = get_methodtable(method)
+    if mmt === nothing || mmt.module === parentmodule(method)
+        return nothing
+    end
+    # `mmt` is only particularly relevant for external method tables. Since the primary
+    # method table is shared, we now need to distinguish "primary" methods by trying to
+    # check if there is a primary `DataType` to identify it with. c.f. how `jl_method_def`
+    # would derive this same information (for the name).
+    ft = argument_datatype((unwrap_unionall(method.sig)::DataType).parameters[1])
+    # `ft` should be the type associated with the first argument in the method signature.
+    # If it's `Type`, try to unwrap it again.
+    if isType(ft)
+        ft = argument_datatype(ft.parameters[1])
+    end
+    if ft === nothing || parentmodule(method) === parentmodule(ft) !== Core
+        return nothing
+    end
+    m = parentmodule_before_main(method)
+    return get!(() -> popfirst!(STACKTRACE_MODULECOLORS), STACKTRACE_FIXEDCOLORS, m)
+end
+
 function show_method_table(io::IO, ms::MethodList, max::Int=-1, header::Bool=true)
     mt = ms.mt
     name = mt.name
@@ -300,12 +323,6 @@ function show_method_table(io::IO, ms::MethodList, max::Int=-1, header::Bool=tru
     last_shown_line_infos = get(io, :last_shown_line_infos, nothing)
     last_shown_line_infos === nothing || empty!(last_shown_line_infos)
 
-    modul = if mt === _TYPE_NAME.mt && length(ms) > 0 # type constructor
-            which(ms.ms[1].module, ms.ms[1].name)
-        else
-            mt.module
-        end
-
     digit_align_width = length(string(max > 0 ? max : length(ms)))
 
     for meth in ms
@@ -315,13 +332,7 @@ function show_method_table(io::IO, ms::MethodList, max::Int=-1, header::Bool=tru
 
             print(io, " ", lpad("[$n]", digit_align_width + 2), " ")
 
-            modulecolor = if parentmodule(meth) == modul
-                nothing
-            else
-                m = parentmodule_before_main(meth)
-                get!(() -> popfirst!(STACKTRACE_MODULECOLORS), STACKTRACE_FIXEDCOLORS, m)
-            end
-            show_method(io, meth; modulecolor)
+            show_method(io, meth; modulecolor=_modulecolor(meth))
 
             file, line = updated_methodloc(meth)
             if last_shown_line_infos !== nothing
diff --git a/base/reflection.jl b/base/reflection.jl
index adbd20deab636..306f21cbc5f23 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -2507,7 +2507,11 @@ function delete_method(m::Method)
 end
 
 function get_methodtable(m::Method)
-    return ccall(:jl_method_get_table, Any, (Any,), m)::Core.MethodTable
+    mt = ccall(:jl_method_get_table, Any, (Any,), m)
+    if mt === nothing
+        return nothing
+    end
+    return mt::Core.MethodTable
 end
 
 """
diff --git a/test/show.jl b/test/show.jl
index a2ed2bba31f50..08a29612b245c 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2652,3 +2652,10 @@ let buf = IOBuffer()
     Base.show_tuple_as_call(buf, Symbol(""), Tuple{Function,Any})
     @test String(take!(buf)) == "(::Function)(::Any)"
 end
+
+module Issue49382
+    abstract type Type49382 end
+end
+using .Issue49382
+(::Type{Issue49382.Type49382})() = 1
+@test sprint(show, methods(Issue49382.Type49382)) isa String

From 1a64299ef06672d12de53abcda2f23881c0eabf4 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sat, 23 Dec 2023 02:45:20 +0600
Subject: [PATCH 0487/1315] Remove flakey sorting test (#52594)

---
 test/sorting.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/sorting.jl b/test/sorting.jl
index 878c4b36d4611..621c82ae7e7fe 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -704,6 +704,7 @@ end
     safe_algs = [InsertionSort, MergeSort, Base.Sort.ScratchQuickSort(), Base.DEFAULT_STABLE, Base.DEFAULT_UNSTABLE]
 
     n = 1000
+    Random.seed!(0x3588d23f15e74060);
     v = rand(1:5, n);
     s = sort(v);
 
@@ -722,7 +723,7 @@ end
         @test sort(1:n, alg=alg, lt = (i,j) -> v[i]<=v[j]) == perm
     end
     # Broken by the introduction of BracketedSort in #52006 which is unstable
-    @test_broken partialsort(1:n, 172, lt = (i,j) -> v[i]<=v[j]) == perm[172]
+    # @test_broken partialsort(1:n, 172, lt = (i,j) -> v[i]<=v[j]) == perm[172] (sometimes passes due to RNG)
     @test_broken partialsort(1:n, 315:415, lt = (i,j) -> v[i]<=v[j]) == perm[315:415]
 
     # lt can be very poorly behaved and sort will still permute its input in some way.

From b97ffd01908c81ec7c8e48a91f3e50f80daf0cad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Fri, 22 Dec 2023 23:50:03 +0100
Subject: [PATCH 0488/1315] [MbedTLS_jll] Update to v2.28.6 (#52612)

---
 deps/checksums/mbedtls              | 68 ++++++++++++++---------------
 deps/mbedtls.version                |  4 +-
 stdlib/MbedTLS_jll/Project.toml     |  2 +-
 stdlib/MbedTLS_jll/test/runtests.jl |  2 +-
 4 files changed, 39 insertions(+), 37 deletions(-)

diff --git a/deps/checksums/mbedtls b/deps/checksums/mbedtls
index 11ee2786abb98..2db4d7fed384f 100644
--- a/deps/checksums/mbedtls
+++ b/deps/checksums/mbedtls
@@ -1,34 +1,34 @@
-MbedTLS.v2.28.2+1.aarch64-apple-darwin.tar.gz/md5/ef83fb4706100ee678cd8af3f7a5c762
-MbedTLS.v2.28.2+1.aarch64-apple-darwin.tar.gz/sha512/03dda8cc9afa3d79c3c733e45c77891e75d939dc2bcca5ba8eb7aa3bd01fb52011ea9323df9cf7294fe6dcf87eb86c1b1c4b2f3b8af6116929b3371698559fe4
-MbedTLS.v2.28.2+1.aarch64-linux-gnu.tar.gz/md5/ac46c3840d2d0cc7c573f31c2f3d0d61
-MbedTLS.v2.28.2+1.aarch64-linux-gnu.tar.gz/sha512/bb458f1dc9b8684a38f603136ee4ba1c51b47f5047c5a5cfe2c552be266e79dfcd8243b216b0831abf24390eeb6f4524bc7e43b2642eb2ad0227399222cd0d8a
-MbedTLS.v2.28.2+1.aarch64-linux-musl.tar.gz/md5/d74732e0bbcd03666243605e60bb345a
-MbedTLS.v2.28.2+1.aarch64-linux-musl.tar.gz/sha512/90b0699477b697b94c0ab1ba0607fb3e1cd40d66a80a51cb1e0f3b927de03ba201e7e280d453db672e6265db5b07d0145846e53ddbcb4b550afcabef1716470b
-MbedTLS.v2.28.2+1.armv6l-linux-gnueabihf.tar.gz/md5/65ce7c51884b50dcb8343a945644b862
-MbedTLS.v2.28.2+1.armv6l-linux-gnueabihf.tar.gz/sha512/e9df753e9f3a08fd645b15422be7cc0ec3aeac3f8d5f76e0c4c5ec24c54e1b653db320ed0c6799411802a05801241a5363bb449a8765fda7856413c7e3297721
-MbedTLS.v2.28.2+1.armv6l-linux-musleabihf.tar.gz/md5/7b7fc8eafc95416d75e3f1bfb2640e09
-MbedTLS.v2.28.2+1.armv6l-linux-musleabihf.tar.gz/sha512/68362114808fb4f986dea673ef1c7f104caad8233bed1c7f6a365d5d69bb7f7c92b234d6b1bfa5b014e7096411841c115a5cfe9932ae9ce642293cab962f8d38
-MbedTLS.v2.28.2+1.armv7l-linux-gnueabihf.tar.gz/md5/4a477379b15fafbf0c05435f5ab370ac
-MbedTLS.v2.28.2+1.armv7l-linux-gnueabihf.tar.gz/sha512/fd34b475bf94b411e3155f5a5166d1ad081fef3622d7b99f4915b592d4235f63a0b910e0559ba2a0c3d596df9ccc2d7ecb61984091debb20bd4b995942857132
-MbedTLS.v2.28.2+1.armv7l-linux-musleabihf.tar.gz/md5/fc6551ef5f189010a84230dd48f6bdfe
-MbedTLS.v2.28.2+1.armv7l-linux-musleabihf.tar.gz/sha512/d3a7199f3e1ffb1c289c5f0a4384f3b5d1af6e868eb1081d66d6cbfc60e6415e68a7e22afb497f2e7c7900678a19bf1ba2a4c888efa1019c03bce376af62154c
-MbedTLS.v2.28.2+1.i686-linux-gnu.tar.gz/md5/5f06aeeacb93e8419da5dcc6dbadff67
-MbedTLS.v2.28.2+1.i686-linux-gnu.tar.gz/sha512/48dd5de23dd1513dd496b7ae9c88bc5a4f206442c3916ffdd602232b6f5fdc621adf0a3a014821d70092e1c3c90d96e462bc0e7608a984b0ff428c4bdbe42ecf
-MbedTLS.v2.28.2+1.i686-linux-musl.tar.gz/md5/435b864b02d1d2c96e5d8dc32b433ae1
-MbedTLS.v2.28.2+1.i686-linux-musl.tar.gz/sha512/52e3a79a70b3ff4617c93cafdeb702105c13b34687fc0fa31eebc91aa5cacea356d5b6a6bdbbfd81417d77debe256ea8f0f2a43c8d140154099bde097740dce7
-MbedTLS.v2.28.2+1.i686-w64-mingw32.tar.gz/md5/09c0450a373e30ddef1ae31e06b288d4
-MbedTLS.v2.28.2+1.i686-w64-mingw32.tar.gz/sha512/59a3529e7826a2f2266c1482d5dbdae2fb578416b3b6ee3b0c8507df21c1395dcd681be65ad953e8306971c549efad342ee4e0725391a88b202475f56aebc062
-MbedTLS.v2.28.2+1.powerpc64le-linux-gnu.tar.gz/md5/26c8f09aa65e5b70be528311519d4376
-MbedTLS.v2.28.2+1.powerpc64le-linux-gnu.tar.gz/sha512/2d47567388b8554ce7714f4ded013fcbffbf94726dbc6a1b7287dc17b27d1fa35baba55cf7dac17c555892a5f4c74119afdf552b42b0e8f80f26621adaa4dbca
-MbedTLS.v2.28.2+1.x86_64-apple-darwin.tar.gz/md5/dfc263208b1a8d4c29b4ec3b6f10e5ce
-MbedTLS.v2.28.2+1.x86_64-apple-darwin.tar.gz/sha512/3b2941c4b151206a56a9a795f0f30519676ea4bc0c93f66b419b15568edc91bb976954f584116accb7f9bd067580712e61b3c580a249332640e27e6346ca51ff
-MbedTLS.v2.28.2+1.x86_64-linux-gnu.tar.gz/md5/94b908036eecbe59372722b41f0b1985
-MbedTLS.v2.28.2+1.x86_64-linux-gnu.tar.gz/sha512/c37a4c34eb450bd716c076c4105bd6022892731c470d64a854ac0fca6653dcf5a70b23982050e7d82cdfd67d02902d9efe4c94d2cf5e0d29d497c3c5ac03f8e8
-MbedTLS.v2.28.2+1.x86_64-linux-musl.tar.gz/md5/217866be499144eeb2e0944b0b60cc09
-MbedTLS.v2.28.2+1.x86_64-linux-musl.tar.gz/sha512/144180e1968da627c92173277a130283aea711157a04a2655786658234232e397985f63d5407166377fc5f38a7447c19797c51b66a9c4b1773601d9e7e01d0e0
-MbedTLS.v2.28.2+1.x86_64-unknown-freebsd.tar.gz/md5/5a1ec1b183f30cb7998550e5ce15c62d
-MbedTLS.v2.28.2+1.x86_64-unknown-freebsd.tar.gz/sha512/3d07fc1a54a832515a1340eaa5de03707fc52fe8770a75ac80106942f5d23e1d52297c6068d28ab07f55fd2b3f1c683b1e25e82bf4c34b4f14af58287a5b662f
-MbedTLS.v2.28.2+1.x86_64-w64-mingw32.tar.gz/md5/edb5477223f9a35054160585fdb07f7e
-MbedTLS.v2.28.2+1.x86_64-w64-mingw32.tar.gz/sha512/617779d6944ea153c63e6d9ce66d9bb33520e1539324a449151594937e648ef7ccb30364d3e7aa3eed3b68b02366e5724e14787565db565f0686334ab4df3701
-mbedtls-2.28.2.tar.gz/md5/421c47c18ef46095e3ad38ffc0543e11
-mbedtls-2.28.2.tar.gz/sha512/93cdb44f764b200131b8dbefb9363e5fa38760eaf01473a512f93673cc55db3515830e16b813e03b39cb819323ad78cee4cb7f3fa85861ec5e72e0f89541c7fc
+MbedTLS.v2.28.6+0.aarch64-apple-darwin.tar.gz/md5/c97705b08c6bf695fa7a11a42167df94
+MbedTLS.v2.28.6+0.aarch64-apple-darwin.tar.gz/sha512/91825c3a495045ca74ceb5a23e3d7e9387701e401911b147d905a49892b1a5a9f22662a4f16a7f4468c5a807f2980b66e3409ea1ff7e04c6fdac0b105472e200
+MbedTLS.v2.28.6+0.aarch64-linux-gnu.tar.gz/md5/8ebaaeefd75c805227229086c262d0e7
+MbedTLS.v2.28.6+0.aarch64-linux-gnu.tar.gz/sha512/89983c1f9f9d7b901619522afcd12c6bc1996757edeb9f3012954992f82f3b36ae50f49dcf7731623fca197946e4281eecffdc29a5819f04e7f6203afd4eb93a
+MbedTLS.v2.28.6+0.aarch64-linux-musl.tar.gz/md5/b40b2ba247f4ff755e15daad13c5a255
+MbedTLS.v2.28.6+0.aarch64-linux-musl.tar.gz/sha512/4cb4f2213b631dda0caa8baafa8effc9c8592c72a6a5b826fce060cd81f8f77c188c9ddc76595b47078db3c35b3043d9bf0cb891d822a940df87982de56dec44
+MbedTLS.v2.28.6+0.armv6l-linux-gnueabihf.tar.gz/md5/c6dd1cb1aba1075c73c41719a03c5ab5
+MbedTLS.v2.28.6+0.armv6l-linux-gnueabihf.tar.gz/sha512/981a8925dd90418150625e9467cc791e4a9d5223e7df6ead113ec41a279a5dd7e8ebcecb5b87611ef451fc6483fd6eb5bf984cf528037ad742e68b4be94e5c07
+MbedTLS.v2.28.6+0.armv6l-linux-musleabihf.tar.gz/md5/c30ed777bd74d269656f7e9bc8163765
+MbedTLS.v2.28.6+0.armv6l-linux-musleabihf.tar.gz/sha512/f04014181082561195caa4d3b178480bb5cce7f459d76aca8cdaa2f615d105b24871656ce4cbf8d9ec33f0424de35a16f12d4964a1f0fab9a416e5d18a468c94
+MbedTLS.v2.28.6+0.armv7l-linux-gnueabihf.tar.gz/md5/256f8327773ea2d0d6b4649541c34e84
+MbedTLS.v2.28.6+0.armv7l-linux-gnueabihf.tar.gz/sha512/ab4c9e82752386a0fd642a709bc90b712d6aaff78309968f1fdbf1121a790a9c0227ddd8e79373359cea9c75b21e762f600abea42036609571ba999531b50852
+MbedTLS.v2.28.6+0.armv7l-linux-musleabihf.tar.gz/md5/249ada3e9a7ad4eba08270e575ae68ec
+MbedTLS.v2.28.6+0.armv7l-linux-musleabihf.tar.gz/sha512/0682e65f4257c3d237ba8cfc643be4430341888ec4cd17c2dc3018350aa7ff176e834a69ebc9d240b383a7aed439b34e45c237310ad66043956700b782323793
+MbedTLS.v2.28.6+0.i686-linux-gnu.tar.gz/md5/d0a176d2843ac780884395c90971bf68
+MbedTLS.v2.28.6+0.i686-linux-gnu.tar.gz/sha512/c2f96f314d0e5d9bffe46dc7d0adceb038db81e8c9d9a3c0fb0a237849d0d568d249e2df6c275d27a74a9122d0a53b38e5d8521807669a9c82bd67befbea169c
+MbedTLS.v2.28.6+0.i686-linux-musl.tar.gz/md5/9c7501c6b04df53f8d56cd59dd42ae4c
+MbedTLS.v2.28.6+0.i686-linux-musl.tar.gz/sha512/6fd35f9c2e1c5822920bc1d9315dc68b10694ee5507cc512868615c3d35dc389fa67038b9ab79fa86ea7ff6bf5f6f1eed053fafcc519080559057dcaff813ec5
+MbedTLS.v2.28.6+0.i686-w64-mingw32.tar.gz/md5/1eef46b3c89a81973778817a8856673c
+MbedTLS.v2.28.6+0.i686-w64-mingw32.tar.gz/sha512/f202595cf971825601d5e12263eef0dd101e9be971d15592a12187f1d170fafaab358f02db89458f495ddc8922f66fbd662123b0d6df527fffa514e9f410784a
+MbedTLS.v2.28.6+0.powerpc64le-linux-gnu.tar.gz/md5/fec1779ff02d71d5e94b3f1455453fc0
+MbedTLS.v2.28.6+0.powerpc64le-linux-gnu.tar.gz/sha512/e97ae38c555f6b45e33c023c7e07c982d36501f6c2dc36121bb73f2fb08db3fa3ab7f4ab0d9ecb622d25bfe1816eab3a6190d2034a05a66b7425c36a637623e0
+MbedTLS.v2.28.6+0.x86_64-apple-darwin.tar.gz/md5/6d44a0c126affaedad544460da9415ab
+MbedTLS.v2.28.6+0.x86_64-apple-darwin.tar.gz/sha512/bf074429f32f51d954bc0c242fb4455ec6ead0e8337a3e5ab9e5b0df47d8a195947a488169f743db63d70b245be80084cd0d78f2211b6cd4b9524010b2c893cc
+MbedTLS.v2.28.6+0.x86_64-linux-gnu.tar.gz/md5/95641af7a92c8c83d82264dd2275692c
+MbedTLS.v2.28.6+0.x86_64-linux-gnu.tar.gz/sha512/3606ecd5a566e643cc03959a3eac9a45cb4c644006ee5820b852dfc22d40b85d75f5c018c46776954d92001986ecb49238058ca3d99340f9a689875b690aa6e7
+MbedTLS.v2.28.6+0.x86_64-linux-musl.tar.gz/md5/aee58ac107ca0d9e1eb5d7de8146ec8d
+MbedTLS.v2.28.6+0.x86_64-linux-musl.tar.gz/sha512/86219aa5ba3280da39e91beded7455160c1ebc274c3158b9f0703a2c034756a9a9e51e5354d22ce983fcd026157d81f471446e6ee2743cae2663384e3e796176
+MbedTLS.v2.28.6+0.x86_64-unknown-freebsd.tar.gz/md5/67857ac031b10fb6a0620b453477653b
+MbedTLS.v2.28.6+0.x86_64-unknown-freebsd.tar.gz/sha512/118f3c662580c88d092610be08b60236939c7fd7feab4cd524c7c1e2e2e1b557bddbd603902b697142695889ea6c0a8087982020cd5e7267c9c7c82b49622460
+MbedTLS.v2.28.6+0.x86_64-w64-mingw32.tar.gz/md5/15ebd14ae435b64b2a0006ee7bc21bd4
+MbedTLS.v2.28.6+0.x86_64-w64-mingw32.tar.gz/sha512/7b327ecd405417a3be6ad4ba746656c9b25b70f09985e3e53b07416ab6f271f630eee638c98be938d5cb827c92b5bf656c02865685306389efba2275a1b2113f
+mbedtls-2.28.6.tar.gz/md5/768932cee6c42f7f4751362091ac56d4
+mbedtls-2.28.6.tar.gz/sha512/a5c876489bf89908f34626c879f68e8f962d84b50756df17b6b75dfb93e08fe163ed3f32bf70e89bce9080d15257a4cbd2679b743bf8f2e2d7a04606c5811c05
diff --git a/deps/mbedtls.version b/deps/mbedtls.version
index f262476af1684..ef88b8109f68c 100644
--- a/deps/mbedtls.version
+++ b/deps/mbedtls.version
@@ -1,5 +1,7 @@
+# -*- makefile -*-
+
 ## jll artifact
 MBEDTLS_JLL_NAME := MbedTLS
 
 ## source build
-MBEDTLS_VER := 2.28.2
+MBEDTLS_VER := 2.28.6
diff --git a/stdlib/MbedTLS_jll/Project.toml b/stdlib/MbedTLS_jll/Project.toml
index 27d4884d099ad..1fe9b5e702c61 100644
--- a/stdlib/MbedTLS_jll/Project.toml
+++ b/stdlib/MbedTLS_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "MbedTLS_jll"
 uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
-version = "2.28.2+1"
+version = "2.28.6+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/stdlib/MbedTLS_jll/test/runtests.jl b/stdlib/MbedTLS_jll/test/runtests.jl
index 2d82fa564cd18..5813a813a1e1f 100644
--- a/stdlib/MbedTLS_jll/test/runtests.jl
+++ b/stdlib/MbedTLS_jll/test/runtests.jl
@@ -6,5 +6,5 @@ using Test, Libdl, MbedTLS_jll
     vstr = zeros(UInt8, 32)
     ccall((:mbedtls_version_get_string, libmbedcrypto), Cvoid, (Ref{UInt8},), vstr)
     vn = VersionNumber(unsafe_string(pointer(vstr)))
-    @test vn == v"2.28.2"
+    @test vn == v"2.28.6"
 end

From 4975a78a4465942449f8ab1a4dce0117df85b082 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 22 Dec 2023 21:11:49 -0300
Subject: [PATCH 0489/1315] GC page profiler (#52567)

Piggybacks in the sweeping phase of the GC to pretty-print a JSON
representation of every page in the pool allocator.

Usage:

```bash
julia> using Profile

julia> Profile.take_page_profile("/tmp/test-profile.out")
"/tmp/test-profile.out"
```

Output (truncated to one page & after pretty printing):

```json
{
	"address": "0x109dd0000",
	"object_size": 400,
	"objects": [
		"Task",
		"Task",
		"Task",
		"garbage",
		"GenericMemory",
		"garbage",
		"GenericMemory",
		"GenericMemory",
		"garbage",
		"GenericMemory",
		"GenericMemory",
		"Task",
		"Task",
		"Task",
		"garbage",
		"garbage",
		"garbage",
		"String",
		"garbage",
		"garbage",
		"String",
		"GenericMemory",
		"GenericMemory",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
		"garbage",
	]
}
```

This proved particularly useful for us when studying fragmentation in
some of our workloads, though this profiler may possibly have some
repeated functionality compared to the other profilers we already have
in `stdlib`.
---
 src/Makefile                    |   2 +-
 src/gc-page-profiler.c          | 167 ++++++++++++++++++++++++++++++++
 src/gc-page-profiler.h          |  63 ++++++++++++
 src/gc.c                        |  54 ++++++++---
 stdlib/Profile/src/Profile.jl   |  16 +++
 stdlib/Profile/test/runtests.jl |  10 ++
 6 files changed, 297 insertions(+), 15 deletions(-)
 create mode 100644 src/gc-page-profiler.c
 create mode 100644 src/gc-page-profiler.h

diff --git a/src/Makefile b/src/Makefile
index 747090a8dcd83..c78df75bdceb5 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -44,7 +44,7 @@ SRCS := \
 	jltypes gf typemap smallintset ast builtins module interpreter symbol \
 	dlload sys init task array genericmemory staticdata toplevel jl_uv datatype \
 	simplevector runtime_intrinsics precompile jloptions mtarraylist \
-	threading scheduler stackwalk gc gc-debug gc-pages gc-stacks gc-alloc-profiler method \
+	threading scheduler stackwalk gc gc-debug gc-pages gc-stacks gc-alloc-profiler gc-page-profiler method \
 	jlapi signal-handling safepoint timing subtype rtutils gc-heap-snapshot \
 	crc32c APInt-C processor ircode opaque_closure codegen-stubs coverage runtime_ccall
 
diff --git a/src/gc-page-profiler.c b/src/gc-page-profiler.c
new file mode 100644
index 0000000000000..5af1c3d014770
--- /dev/null
+++ b/src/gc-page-profiler.c
@@ -0,0 +1,167 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#include "gc-page-profiler.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// whether page profiling is enabled
+int page_profile_enabled;
+// number of pages written
+size_t page_profile_pages_written;
+// stream to write page profile to
+ios_t *page_profile_stream;
+// mutex for page profile
+uv_mutex_t page_profile_lock;
+
+gc_page_profiler_serializer_t gc_page_serializer_create(void) JL_NOTSAFEPOINT
+{
+    gc_page_profiler_serializer_t serializer;
+    if (__unlikely(page_profile_enabled)) {
+        arraylist_new(&serializer.typestrs, GC_PAGE_SZ);
+    }
+    else {
+        serializer.typestrs.len = 0;
+    }
+    return serializer;
+}
+
+void gc_page_serializer_init(gc_page_profiler_serializer_t *serializer,
+                             jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        serializer->typestrs.len = 0;
+        serializer->data = (char *)pg->data;
+        serializer->osize = pg->osize;
+    }
+}
+
+void gc_page_serializer_destroy(gc_page_profiler_serializer_t *serializer) JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        arraylist_free(&serializer->typestrs);
+    }
+}
+
+void gc_page_serializer_write(gc_page_profiler_serializer_t *serializer,
+                              const char *str) JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        arraylist_push(&serializer->typestrs, (void *)str);
+    }
+}
+
+void gc_enable_page_profile(void) JL_NOTSAFEPOINT
+{
+    page_profile_enabled = 1;
+}
+
+void gc_disable_page_profile(void) JL_NOTSAFEPOINT
+{
+    page_profile_enabled = 0;
+}
+
+int gc_page_profile_is_enabled(void) JL_NOTSAFEPOINT
+{
+    return page_profile_enabled;
+}
+
+void gc_page_profile_write_preamble(gc_page_profiler_serializer_t *serializer)
+    JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        char str[GC_TYPE_STR_MAXLEN];
+        snprintf(str, GC_TYPE_STR_MAXLEN,
+                 "{\"address\": \"%p\",\"object_size\": %d,\"objects\": [",
+                 serializer->data, serializer->osize);
+        ios_write(page_profile_stream, str, strlen(str));
+    }
+}
+
+void gc_page_profile_write_epilogue(gc_page_profiler_serializer_t *serializer)
+    JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        const char *str = "]}";
+        ios_write(page_profile_stream, str, strlen(str));
+    }
+}
+
+void gc_page_profile_write_comma(gc_page_profiler_serializer_t *serializer) JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        // write comma if not first page
+        if (page_profile_pages_written > 0) {
+            const char *str = ",";
+            ios_write(page_profile_stream, str, strlen(str));
+        }
+    }
+}
+
+void gc_page_profile_write_to_file(gc_page_profiler_serializer_t *serializer)
+    JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        // write to file
+        uv_mutex_lock(&page_profile_lock);
+        gc_page_profile_write_comma(serializer);
+        gc_page_profile_write_preamble(serializer);
+        char str[GC_TYPE_STR_MAXLEN];
+        for (size_t i = 0; i < serializer->typestrs.len; i++) {
+            const char *name = (const char *)serializer->typestrs.items[i];
+            if (name == GC_SERIALIZER_EMPTY) {
+                snprintf(str, GC_TYPE_STR_MAXLEN, "\"empty\",");
+            }
+            else if (name == GC_SERIALIZER_GARBAGE) {
+                snprintf(str, GC_TYPE_STR_MAXLEN, "\"garbage\",");
+            }
+            else {
+                snprintf(str, GC_TYPE_STR_MAXLEN, "\"%s\",", name);
+            }
+            // remove trailing comma for last element
+            if (i == serializer->typestrs.len - 1) {
+                str[strlen(str) - 1] = '\0';
+            }
+            ios_write(page_profile_stream, str, strlen(str));
+        }
+        gc_page_profile_write_epilogue(serializer);
+        page_profile_pages_written++;
+        uv_mutex_unlock(&page_profile_lock);
+    }
+}
+
+void gc_page_profile_write_json_preamble(ios_t *stream) JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        uv_mutex_lock(&page_profile_lock);
+        const char *str = "{\"pages\": [";
+        ios_write(stream, str, strlen(str));
+        uv_mutex_unlock(&page_profile_lock);
+    }
+}
+
+void gc_page_profile_write_json_epilogue(ios_t *stream) JL_NOTSAFEPOINT
+{
+    if (__unlikely(page_profile_enabled)) {
+        uv_mutex_lock(&page_profile_lock);
+        const char *str = "]}";
+        ios_write(stream, str, strlen(str));
+        uv_mutex_unlock(&page_profile_lock);
+    }
+}
+
+JL_DLLEXPORT void jl_gc_take_page_profile(ios_t *stream)
+{
+    gc_enable_page_profile();
+    page_profile_pages_written = 0;
+    page_profile_stream = stream;
+    gc_page_profile_write_json_preamble(stream);
+    jl_gc_collect(JL_GC_FULL);
+    gc_page_profile_write_json_epilogue(stream);
+    gc_disable_page_profile();
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/gc-page-profiler.h b/src/gc-page-profiler.h
new file mode 100644
index 0000000000000..b103e23905ba5
--- /dev/null
+++ b/src/gc-page-profiler.h
@@ -0,0 +1,63 @@
+// This file is a part of Julia. License is MIT: https://julialang.org/license
+
+#ifndef GC_PAGE_PROFILER_H
+#define GC_PAGE_PROFILER_H
+
+#include "gc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GC_TYPE_STR_MAXLEN (512)
+
+typedef struct {
+    arraylist_t typestrs;
+    char *data;
+    int osize;
+} gc_page_profiler_serializer_t;
+
+// mutex for page profile
+extern uv_mutex_t page_profile_lock;
+
+// Serializer functions
+gc_page_profiler_serializer_t gc_page_serializer_create(void) JL_NOTSAFEPOINT;
+void gc_page_serializer_init(gc_page_profiler_serializer_t *serializer, jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT;
+void gc_page_serializer_destroy(gc_page_profiler_serializer_t *serializer) JL_NOTSAFEPOINT;
+void gc_page_serializer_write(gc_page_profiler_serializer_t *serializer, const char *str) JL_NOTSAFEPOINT;
+// Page profile functions
+#define GC_SERIALIZER_EMPTY ((const char *)0x1)
+#define GC_SERIALIZER_GARBAGE ((const char *)0x2)
+STATIC_INLINE void gc_page_profile_write_empty_page(gc_page_profiler_serializer_t *serializer,
+                                 int enabled) JL_NOTSAFEPOINT
+{
+    if (__unlikely(enabled)) {
+        gc_page_serializer_write(serializer, GC_SERIALIZER_EMPTY);
+    }
+}
+STATIC_INLINE void gc_page_profile_write_garbage(gc_page_profiler_serializer_t *serializer,
+                                                 int enabled) JL_NOTSAFEPOINT
+{
+    if (__unlikely(enabled)) {
+        gc_page_serializer_write(serializer, GC_SERIALIZER_GARBAGE);
+    }
+}
+STATIC_INLINE void gc_page_profile_write_live_obj(gc_page_profiler_serializer_t *serializer,
+                                                  jl_taggedvalue_t *v,
+                                                  int enabled) JL_NOTSAFEPOINT
+{
+    if (__unlikely(enabled)) {
+        const char *name = jl_typeof_str(jl_valueof(v));
+        gc_page_serializer_write(serializer, name);
+    }
+}
+void gc_enable_page_profile(void) JL_NOTSAFEPOINT;
+void gc_disable_page_profile(void) JL_NOTSAFEPOINT;
+int gc_page_profile_is_enabled(void) JL_NOTSAFEPOINT;
+void gc_page_profile_write_to_file(gc_page_profiler_serializer_t *serializer) JL_NOTSAFEPOINT;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GC_PAGE_PROFILER_H
diff --git a/src/gc.c b/src/gc.c
index d703fb9d26218..0c756d3d2880b 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1,6 +1,7 @@
 // This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "gc.h"
+#include "gc-page-profiler.h"
 #include "julia.h"
 #include "julia_gcext.h"
 #include "julia_assert.h"
@@ -1426,11 +1427,11 @@ STATIC_INLINE void gc_dump_page_utilization_data(void) JL_NOTSAFEPOINT
 int64_t buffered_pages = 0;
 
 // Returns pointer to terminal pointer of list rooted at *pfl.
-static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_page_stack_t *buffered,
+static void gc_sweep_page(gc_page_profiler_serializer_t *s, jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_page_stack_t *buffered,
                           jl_gc_pagemeta_t *pg, int osize) JL_NOTSAFEPOINT
 {
     char *data = pg->data;
-    jl_taggedvalue_t *v = (jl_taggedvalue_t*)(data + GC_PAGE_OFFSET);
+    jl_taggedvalue_t *v0 = (jl_taggedvalue_t*)(data + GC_PAGE_OFFSET);
     char *lim = data + GC_PAGE_SZ - osize;
     char *lim_newpages = data + GC_PAGE_SZ;
     if (gc_page_data((char*)p->newpages - 1) == data) {
@@ -1438,6 +1439,9 @@ static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_pag
     }
     size_t old_nfree = pg->nfree;
     size_t nfree;
+    // avoid loading a global variable in the hot path
+    int page_profile_enabled = gc_page_profile_is_enabled();
+    gc_page_serializer_init(s, pg);
 
     int re_use_page = 1;
     int keep_as_local_buffer = 0;
@@ -1457,6 +1461,7 @@ static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_pag
         }
     #endif
         nfree = (GC_PAGE_SZ - GC_PAGE_OFFSET) / osize;
+        gc_page_profile_write_empty_page(s, page_profile_enabled);
         goto done;
     }
     // For quick sweep, we might be able to skip the page if the page doesn't
@@ -1466,12 +1471,13 @@ static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_pag
         if (!prev_sweep_full || pg->prev_nold == pg->nold) {
             freedall = 0;
             nfree = pg->nfree;
+            gc_page_profile_write_empty_page(s, page_profile_enabled);
             goto done;
         }
     }
 
     pg_skpd = 0;
-    {  // scope to avoid clang goto errors
+    {   // scope to avoid clang goto errors
         int has_marked = 0;
         int has_young = 0;
         int16_t prev_nold = 0;
@@ -1479,6 +1485,22 @@ static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_pag
         jl_taggedvalue_t *fl = NULL;
         jl_taggedvalue_t **pfl = &fl;
         jl_taggedvalue_t **pfl_begin = NULL;
+        // collect page profile
+        jl_taggedvalue_t *v = v0;
+        if (page_profile_enabled) {
+            while ((char*)v <= lim) {
+                int bits = v->bits.gc;
+                if (!gc_marked(bits) || (char*)v >= lim_newpages) {
+                    gc_page_profile_write_garbage(s, page_profile_enabled);
+                }
+                else {
+                    gc_page_profile_write_live_obj(s, v, page_profile_enabled);
+                }
+                v = (jl_taggedvalue_t*)((char*)v + osize);
+            }
+            v = v0;
+        }
+        // sweep the page
         while ((char*)v <= lim) {
             int bits = v->bits.gc;
             // if an object is past `lim_newpages` then we can guarantee it's garbage
@@ -1532,6 +1554,7 @@ static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_pag
             push_lf_back(&global_page_pool_lazily_freed, pg);
         }
     }
+    gc_page_profile_write_to_file(s);
     gc_update_page_fragmentation_data(pg);
     gc_time_count_page(freedall, pg_skpd);
     jl_ptls_t ptls = gc_all_tls_states[pg->thread_n];
@@ -1540,7 +1563,7 @@ static void gc_sweep_page(jl_gc_pool_t *p, jl_gc_page_stack_t *allocd, jl_gc_pag
 }
 
 // the actual sweeping over all allocated pages in a memory pool
-STATIC_INLINE void gc_sweep_pool_page(jl_gc_page_stack_t *allocd, jl_gc_page_stack_t *lazily_freed,
+STATIC_INLINE void gc_sweep_pool_page(gc_page_profiler_serializer_t *s, jl_gc_page_stack_t *allocd, jl_gc_page_stack_t *lazily_freed,
                                       jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT
 {
     int p_n = pg->pool_n;
@@ -1548,7 +1571,7 @@ STATIC_INLINE void gc_sweep_pool_page(jl_gc_page_stack_t *allocd, jl_gc_page_sta
     jl_ptls_t ptls2 = gc_all_tls_states[t_n];
     jl_gc_pool_t *p = &ptls2->heap.norm_pools[p_n];
     int osize = pg->osize;
-    gc_sweep_page(p, allocd, lazily_freed, pg, osize);
+    gc_sweep_page(s, p, allocd, lazily_freed, pg, osize);
 }
 
 // sweep over all memory that is being used and not in a pool
@@ -1585,11 +1608,20 @@ void gc_sweep_wake_all(void)
     uv_mutex_unlock(&gc_threads_lock);
 }
 
+void gc_sweep_wait_for_all(void)
+{
+    jl_atomic_store(&gc_allocd_scratch, NULL);
+    while (jl_atomic_load_relaxed(&gc_n_threads_sweeping) != 0) {
+        jl_cpu_pause();
+    }
+}
+
 void gc_sweep_pool_parallel(void)
 {
     jl_atomic_fetch_add(&gc_n_threads_sweeping, 1);
     jl_gc_page_stack_t *allocd_scratch = jl_atomic_load(&gc_allocd_scratch);
     if (allocd_scratch != NULL) {
+        gc_page_profiler_serializer_t serializer = gc_page_serializer_create();
         while (1) {
             int found_pg = 0;
             for (int t_i = 0; t_i < gc_n_threads; t_i++) {
@@ -1602,25 +1634,18 @@ void gc_sweep_pool_parallel(void)
                 if (pg == NULL) {
                     continue;
                 }
-                gc_sweep_pool_page(allocd, &ptls2->page_metadata_buffered, pg);
+                gc_sweep_pool_page(&serializer, allocd, &ptls2->page_metadata_buffered, pg);
                 found_pg = 1;
             }
             if (!found_pg) {
                 break;
             }
         }
+        gc_page_serializer_destroy(&serializer);
     }
     jl_atomic_fetch_add(&gc_n_threads_sweeping, -1);
 }
 
-void gc_sweep_wait_for_all(void)
-{
-    jl_atomic_store(&gc_allocd_scratch, NULL);
-    while (jl_atomic_load_relaxed(&gc_n_threads_sweeping) != 0) {
-        jl_cpu_pause();
-    }
-}
-
 void gc_free_pages(void)
 {
     while (1) {
@@ -3862,6 +3887,7 @@ void jl_gc_init(void)
 {
     JL_MUTEX_INIT(&heapsnapshot_lock, "heapsnapshot_lock");
     JL_MUTEX_INIT(&finalizers_lock, "finalizers_lock");
+    uv_mutex_init(&page_profile_lock);
     uv_mutex_init(&gc_cache_lock);
     uv_mutex_init(&gc_perm_lock);
     uv_mutex_init(&gc_threads_lock);
diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index 206d2957a91e5..cc29a4503d810 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -16,6 +16,7 @@ public @profile,
     callers,
     init,
     take_heap_snapshot,
+    take_page_profile,
     clear_malloc_data,
     Allocs
 
@@ -1267,6 +1268,21 @@ function take_heap_snapshot(all_one::Bool=false; dir::Union{Nothing,S}=nothing)
     return take_heap_snapshot(fpath, all_one)
 end
 
+"""
+    Profile.take_page_profile(io::IOStream)
+    Profile.take_page_profile(filepath::String)
+
+Write a JSON snapshot of the pages from Julia's pool allocator, printing for every pool allocated object, whether it's garbage, or its type.
+"""
+function take_page_profile(io::IOStream)
+    Base.@_lock_ios(io, ccall(:jl_gc_take_page_profile, Cvoid, (Ptr{Cvoid},), io.handle))
+end
+function take_page_profile(filepath::String)
+    open(filepath, "w") do io
+        take_page_profile(io)
+    end
+    return filepath
+end
 
 include("Allocs.jl")
 include("precompile.jl")
diff --git a/stdlib/Profile/test/runtests.jl b/stdlib/Profile/test/runtests.jl
index ad7c12272d051..d7358dc20e853 100644
--- a/stdlib/Profile/test/runtests.jl
+++ b/stdlib/Profile/test/runtests.jl
@@ -289,4 +289,14 @@ end
     rm(tmpdir, force = true, recursive = true)
 end
 
+@testset "PageProfile" begin
+    fname = "$(getpid())_$(time_ns())"
+    fpath = joinpath(tempdir(), fname)
+    Profile.take_page_profile(fpath)
+    open(fpath) do fs
+        @test readline(fs) != ""
+    end
+    rm(fpath)
+end
+
 include("allocs.jl")

From 44a791526708f0c56633992f38d1445ffad1116e Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 23 Dec 2023 06:07:47 +0100
Subject: [PATCH 0490/1315] ir: Fix incorrect renaming of phinode values
 (#52614)

This fixes #52610. The underlying issue is a left over OldSSAValue after
the adce_pass! (introduced by compaction, it being during adce is
incidental). Compaction introduces `OldSSAValue` when it compacts in
PhiNodes that reference later SSAValues and adds them to a list to
revisit at the end of compaction to fill in the actual renamed result.
There are two separate fixes here:

1. If the result of the final revisit is yet another `OldSSAValue`,
rename it again. I don't this ordinarily happens at all, but I suppose
it is possible in theory during sroa beacuse of the rename-shortcut
optimization [1]. However, this is not not what happened here. Instead
compaction incorrectly used an OldSSAValue for an already-inserted node,
which then ends up in the rename list because we deleted one of the
predecessor edges [2]. To fix that we:

2. Fix an issue where we weren't accounting for the possibility of
previously pending nodes (which have SSAValues beyond the numbering
range of the ordinary statements) in the special already_inserted query
in phinode value processing. To fix this, unify the logic with the
ordinary `already_inserted` query, which handles this case correctly.

[1]
https://github.com/JuliaLang/julia/blob/9443c761871c4db9c3213a1e01804286292c3f4d/base/compiler/ssair/passes.jl#L1385
[2]
https://github.com/JuliaLang/julia/blob/9443c761871c4db9c3213a1e01804286292c3f4d/base/compiler/ssair/ir.jl#L1556

Co-authored-by: Tim Besard <tim@juliahub.com>
---
 base/compiler/ssair/ir.jl     |  8 +++++---
 base/compiler/ssair/passes.jl | 27 +++++++++++++++++----------
 base/compiler/ssair/verify.jl |  2 +-
 test/compiler/irpasses.jl     | 16 ++++++++++++++++
 4 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 045477e615b57..3325b9784996f 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1359,7 +1359,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
     (; result, ssa_rename, late_fixup, used_ssas, new_new_used_ssas) = compact
     (; cfg_transforms_enabled, fold_constant_branches, bb_rename_succ, bb_rename_pred, result_bbs) = compact.cfg_transform
     mark_refined! = Refiner(result.flag, result_idx)
-    already_inserted = (::Int, ssa::OldSSAValue)->ssa.id <= processed_idx
+    already_inserted_phi_arg = already_inserted_ssa(compact, processed_idx)
     if stmt === nothing
         ssa_rename[idx] = stmt
     elseif isa(stmt, OldSSAValue)
@@ -1535,7 +1535,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
             values = stmt.values
         end
 
-        values = process_phinode_values(values, late_fixup, already_inserted, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!)
+        values = process_phinode_values(values, late_fixup, already_inserted_phi_arg, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!)
         # Don't remove the phi node if it is before the definition of its value
         # because doing so can create forward references. This should only
         # happen with dead loops, but can cause problems when optimization
@@ -1574,7 +1574,7 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
                 push!(values, value)
             end
         end
-        result[result_idx][:stmt] = PhiCNode(process_phinode_values(values, late_fixup, already_inserted, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!))
+        result[result_idx][:stmt] = PhiCNode(process_phinode_values(values, late_fixup, already_inserted_phi_arg, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!))
         result_idx += 1
     else
         if isa(stmt, SSAValue)
@@ -1883,6 +1883,8 @@ function fixup_node(compact::IncrementalCompact, @nospecialize(stmt), reify_new_
             compact.used_ssas[node.id] += 1
         elseif isa(node, NewSSAValue)
             compact.new_new_used_ssas[-node.id] += 1
+        elseif isa(node, OldSSAValue)
+            return fixup_node(compact, node, reify_new_nodes)
         end
         return FixedNode(node, needs_fixup)
     else
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 005545f473f07..39109786009aa 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -348,17 +348,23 @@ function record_immutable_preserve!(new_preserves::Vector{Any}, def::Expr, compa
 end
 
 function already_inserted(compact::IncrementalCompact, old::OldSSAValue)
-    id = old.id
-    if id < length(compact.ir.stmts)
-        return id < compact.idx
-    end
-    id -= length(compact.ir.stmts)
-    if id < length(compact.ir.new_nodes)
-        return already_inserted(compact, OldSSAValue(compact.ir.new_nodes.info[id].pos))
+    already_inserted_ssa(compact, compact.idx-1)(0, old)
+end
+
+function already_inserted_ssa(compact::IncrementalCompact, processed_idx::Int)
+    return function did_already_insert(phi_arg::Int, old::OldSSAValue)
+        id = old.id
+        if id <= length(compact.ir.stmts)
+            return id <= processed_idx
+        end
+        id -= length(compact.ir.stmts)
+        if id <= length(compact.ir.new_nodes)
+            return did_already_insert(phi_arg, OldSSAValue(compact.ir.new_nodes.info[id].pos))
+        end
+        id -= length(compact.ir.new_nodes)
+        @assert id <= length(compact.pending_nodes)
+        return !(id in compact.pending_perm)
     end
-    id -= length(compact.ir.new_nodes)
-    @assert id <= length(compact.pending_nodes)
-    return !(id in compact.pending_perm)
 end
 
 function is_pending(compact::IncrementalCompact, old::OldSSAValue)
@@ -2079,6 +2085,7 @@ function adce_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
             end
         end
     end
+
     return Pair{IRCode, Bool}(complete(compact), made_changes)
 end
 
diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index ca3b7c4b64894..6b079c753c003 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -72,7 +72,7 @@ function check_op(ir::IRCode, domtree::DomTree, @nospecialize(op), use_bb::Int,
             end
         end
     elseif isa(op, Union{OldSSAValue, NewSSAValue})
-        @verify_error "Left over SSA marker"
+        @verify_error "At statement %$use_idx: Left over SSA marker ($op)"
         error("")
     elseif isa(op, SlotNumber)
         @verify_error "Left over slot detected in converted IR"
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index da717803d93e4..48a23fd0d5c39 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1709,3 +1709,19 @@ end
 @test scope_folding_opt() == 1
 @test_broken fully_eliminated(scope_folding)
 @test_broken fully_eliminated(scope_folding_opt)
+
+# Function that happened to have lots of sroa that
+# happened to trigger a bad case in the renamer. We
+# just want to check this doesn't crash in inference.
+function f52610()
+    slots_dict = IdDict()
+    for () in Base.inferencebarrier(1)
+       for x in 1
+           if Base.inferencebarrier(true)
+               slots_dict[x] = 0
+           end
+       end
+    end
+    return nothing
+end
+@test code_typed(f52610)[1][2] === Nothing

From f98b8957799b742c0004e18a5e1a77cdef3481fc Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 23 Dec 2023 06:08:49 +0100
Subject: [PATCH 0491/1315] sroa: Better current_scope folding (#52608)

Third time's the charm hopefully. This builds on #52527 and addresses
the TODO left there by keeping track of the appropriate :scope in sroa
as we go along in order to ensure correct current_scope folding, even
when the try body is nothrow (which was left as a todo). As a result, we
also no longer result on lowering assumptions for this transformation,
which enables us to enable the lowering optimization in #52593.
---
 base/compiler/ssair/ir.jl     |  12 ++--
 base/compiler/ssair/passes.jl | 105 ++++++++++++++++++----------------
 base/compiler/ssair/verify.jl |   2 +-
 3 files changed, 65 insertions(+), 54 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 3325b9784996f..9af6647cdbc58 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -2,7 +2,7 @@
 
 Core.PhiNode() = Core.PhiNode(Int32[], Any[])
 
-isterminator(@nospecialize(stmt)) = isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isa(stmt, ReturnNode) || isa(stmt, EnterNode)
+isterminator(@nospecialize(stmt)) = isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isa(stmt, ReturnNode) || isa(stmt, EnterNode) || isexpr(stmt, :leave)
 
 struct CFG
     blocks::Vector{BasicBlock}
@@ -953,11 +953,15 @@ function insert_node!(compact::IncrementalCompact, @nospecialize(before), newins
     end
 end
 
-function maybe_reopen_bb!(compact)
+function did_just_finish_bb(compact)
     result_idx = compact.result_idx
     result_bbs = compact.cfg_transform.result_bbs
-    if (compact.active_result_bb == length(result_bbs) + 1) ||
-        result_idx == first(result_bbs[compact.active_result_bb].stmts)
+    (compact.active_result_bb == length(result_bbs) + 1) ||
+    result_idx == first(result_bbs[compact.active_result_bb].stmts)
+end
+
+function maybe_reopen_bb!(compact)
+    if did_just_finish_bb(compact)
         compact.active_result_bb -= 1
         return true
     end
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 39109786009aa..6476ab0a5a424 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1132,42 +1132,6 @@ function fold_ifelse!(compact::IncrementalCompact, idx::Int, stmt::Expr)
     return false
 end
 
-function fold_current_scope!(compact::IncrementalCompact, idx::Int, stmt::Expr, lazydomtree::LazyDomtree)
-    domtree = get!(lazydomtree)
-
-    # The frontend enforces the invariant that any :enter dominates its active
-    # region, so all we have to do here is walk the domtree to find it.
-    dombb = block_for_inst(compact, SSAValue(idx))
-
-    local bbterminator
-    prevdombb = dombb
-    while true
-        dombb = domtree.idoms_bb[dombb]
-
-        # Did not find any dominating :enter - scope is inherited from the outside
-        dombb == 0 && return nothing
-
-        bbterminator = compact[SSAValue(last(compact.cfg_transform.result_bbs[dombb].stmts))][:stmt]
-        if !isa(bbterminator, EnterNode) || !isdefined(bbterminator, :scope)
-            prevdombb = dombb
-            continue
-        end
-        if bbterminator.catch_dest == 0
-            # TODO: dominance alone is not enough here, we need to actually find the :leaves
-            return nothing
-        end
-        # Check that we are inside the :enter region, i.e. are dominated by the first block in the
-        # enter region - otherwise we've already left this :enter and should keep going
-        if prevdombb != dombb + 1
-            prevdombb = dombb
-            continue
-        end
-        compact[idx] = bbterminator.scope
-        return nothing
-    end
-end
-
-
 # NOTE we use `IdSet{Int}` instead of `BitSet` for in these passes since they work on IR after inlining,
 # which can be very large sometimes, and program counters in question are often very sparse
 const SPCSet = IdSet{Int}
@@ -1182,6 +1146,11 @@ function (this::IntermediaryCollector)(@nospecialize(pi), @nospecialize(ssa))
     return nothing
 end
 
+function update_scope_mapping!(scope_mapping, bb, val)
+    @assert (scope_mapping[bb] in (val, SSAValue(0)))
+    scope_mapping[bb] = val
+end
+
 """
     sroa_pass!(ir::IRCode) -> newir::IRCode
 
@@ -1206,9 +1175,47 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
     defuses = nothing # will be initialized once we encounter mutability in order to reduce dynamic allocations
     # initialization of domtree is delayed to avoid the expensive computation in many cases
     lazydomtree = LazyDomtree(ir)
+    scope_mapping::Union{Vector{SSAValue}, Nothing} = nothing
     for ((old_idx, idx), stmt) in compact
+        # If we encounter any EnterNode with set :scope, propagate the current scope for all basic blocks, so
+        # we have easy access for current_scope folding below.
+        if !isa(stmt, Expr)
+            bb = compact.active_result_bb - 1
+            if scope_mapping !== nothing && did_just_finish_bb(compact)
+                this_scope = scope_mapping[bb]
+                if isa(stmt, GotoIfNot)
+                    update_scope_mapping!(scope_mapping, stmt.dest, this_scope)
+                    update_scope_mapping!(scope_mapping, bb+1, this_scope)
+                elseif isa(stmt, GotoNode)
+                    update_scope_mapping!(scope_mapping, stmt.label, this_scope)
+                elseif isa(stmt, EnterNode)
+                    if stmt.catch_dest != 0
+                        update_scope_mapping!(scope_mapping, stmt.catch_dest, this_scope)
+                    end
+                    isdefined(stmt, :scope) || update_scope_mapping!(scope_mapping, bb+1, this_scope)
+                elseif !isa(stmt, ReturnNode)
+                    update_scope_mapping!(scope_mapping, bb+1, this_scope)
+                end
+            end
+            if isa(stmt, EnterNode)
+                if isdefined(stmt, :scope)
+                    if scope_mapping === nothing
+                        scope_mapping = SSAValue[SSAValue(0) for i = 1:length(compact.cfg_transform.result_bbs)]
+                    end
+                    update_scope_mapping!(scope_mapping, bb+1, SSAValue(idx))
+                end
+            end
+            continue
+        end
+        if scope_mapping !== nothing && did_just_finish_bb(compact)
+            bb = compact.active_result_bb - 1
+            if isexpr(stmt, :leave)
+                update_scope_mapping!(scope_mapping, bb+1, scope_mapping[block_for_inst(compact, scope_mapping[bb])])
+            else
+                update_scope_mapping!(scope_mapping, bb+1, scope_mapping[bb])
+            end
+        end
         # check whether this statement is `getfield` / `setfield!` (or other "interesting" statement)
-        isa(stmt, Expr) || continue
         is_setfield = is_isdefined = is_finalizer = is_keyvalue_get = false
         field_ordering = :unspecified
         if is_known_call(stmt, setfield!, compact)
@@ -1299,7 +1306,13 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
                 2 == (length(stmt.args) - (isexpr(stmt, :invoke) ? 2 : 1)) || continue
                 lift_keyvalue_get!(compact, idx, stmt, 𝕃ₒ)
             elseif is_known_call(stmt, Core.current_scope, compact)
-                fold_current_scope!(compact, idx, stmt, lazydomtree)
+                length(stmt.args) == 1 || continue
+                scope_mapping !== nothing || continue
+                bb = compact.active_result_bb
+                did_just_finish_bb(compact) && (bb -= 1)
+                enter_ssa = scope_mapping[bb]
+                enter_ssa == SSAValue(0) && continue
+                compact[SSAValue(idx)] = (compact[enter_ssa][:stmt]::EnterNode).scope
             elseif isexpr(stmt, :new)
                 refine_new_effects!(𝕃ₒ, compact, idx, stmt)
             end
@@ -2102,14 +2115,6 @@ end
 function is_legal_bb_drop(ir::IRCode, bbidx::Int, bb::BasicBlock)
     # For the time being, don't drop the first bb, because it has special predecessor semantics.
     bbidx == 1 && return false
-    # If the block we're going to is the same as the fallthrow, it's always legal to drop
-    # the block.
-    length(bb.stmts) == 0 && return true
-    if length(bb.stmts) == 1
-        stmt = ir[SSAValue(first(bb.stmts))][:stmt]
-        stmt === nothing && return true
-        ((stmt::GotoNode).label == bbidx + 1) && return true
-    end
     return true
 end
 
@@ -2217,9 +2222,11 @@ function cfg_simplify!(ir::IRCode)
         if length(bb.succs) == 1
             succ = bb.succs[1]
             if length(bbs[succ].preds) == 1 && succ != 1
-                # Can't merge blocks with :enter terminator even if they
-                # only have one successor.
-                if isa(ir[SSAValue(last(bb.stmts))][:stmt], EnterNode)
+                # Can't merge blocks with a non-GotoNode terminator, even if they
+                # only have one successor, because it would not be legal to have that
+                # terminator in the middle of a basic block.
+                terminator = ir[SSAValue(last(bb.stmts))][:stmt]
+                if !isa(terminator, GotoNode) && isterminator(terminator)
                     continue
                 end
                 # Prevent cycles by making sure we don't end up back at `idx`
diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index 6b079c753c003..13656683e8ea9 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -324,7 +324,7 @@ function verify_ir(ir::IRCode, print::Bool=true,
                     error("")
                 end
             end
-        elseif (isa(stmt, GotoNode) || isa(stmt, GotoIfNot) || isa(stmt, EnterNode)) && idx != last(ir.cfg.blocks[bb].stmts)
+        elseif isterminator(stmt) && idx != last(ir.cfg.blocks[bb].stmts)
             @verify_error "Terminator $idx in bb $bb is not the last statement in the block"
             error("")
         else

From 51112082347400ce299aad1bd914f9e2cc34962e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 23 Dec 2023 07:49:04 +0100
Subject: [PATCH 0492/1315] [LibCURL_jll] Update to v8.5.0 (#52611)

---
 deps/checksums/curl             | 68 ++++++++++++++++-----------------
 deps/curl.version               |  2 +-
 stdlib/LibCURL_jll/Project.toml |  2 +-
 3 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/deps/checksums/curl b/deps/checksums/curl
index a6eeccca3833c..854165a8c1225 100644
--- a/deps/checksums/curl
+++ b/deps/checksums/curl
@@ -1,36 +1,36 @@
 LibCURL-a65b64f6eabc932f63c2c0a4a5fb5d75f3e688d0.tar.gz/md5/e8c53aa3fb963c80921787d5d565eb2c
 LibCURL-a65b64f6eabc932f63c2c0a4a5fb5d75f3e688d0.tar.gz/sha512/8e442ea834299df9c02acb87226c121395ad8e550025ac5ee1103df09c6ff43817e9e48dd1bcbc92c80331ef3ddff531962430269115179acbec2bab2de5b011
-LibCURL.v8.4.0+0.aarch64-apple-darwin.tar.gz/md5/7e1b8b96f4f38cd775c1be5bfd4d9b14
-LibCURL.v8.4.0+0.aarch64-apple-darwin.tar.gz/sha512/598c8418731770387f9d1b489eb0794978c4b98c9098f2c9b024fe758e6550ff82202fa4c911a6029ac39a9d395f1dccb9b5539dac788c29a85e79c958ab3bf9
-LibCURL.v8.4.0+0.aarch64-linux-gnu.tar.gz/md5/c8ef2231800a5ad488e2952e14a48710
-LibCURL.v8.4.0+0.aarch64-linux-gnu.tar.gz/sha512/1cc786ce4836e6ae904685bb44e47354eabf66dd82229d84cbeaa0d5b549900b77b68f878d915f04049c4f4118e5849262a6706fa9fac845b8a976e02140dea2
-LibCURL.v8.4.0+0.aarch64-linux-musl.tar.gz/md5/7fdc14704e467d7d9d71b54d48f690f4
-LibCURL.v8.4.0+0.aarch64-linux-musl.tar.gz/sha512/1af938d244e141c6ad77844c115afbff0ab75145e4e1422cf1444226ec0183a7449040c4a86c3dfb445820377278567427f8df77823a5ae0bede705a9b01335e
-LibCURL.v8.4.0+0.armv6l-linux-gnueabihf.tar.gz/md5/77534d50dbb631146c85b6f2b92c7f84
-LibCURL.v8.4.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/b7a4294ae8f7d24b5dcc10df52d76dd35ca1b4d0dc955307968f6f1a6a2edef194d134bcf6891a960d63e8763b1bc2738786db84393183210730d4d2d486dcdb
-LibCURL.v8.4.0+0.armv6l-linux-musleabihf.tar.gz/md5/35e4dee0f70564d3d16d2dd8ef7c2c5d
-LibCURL.v8.4.0+0.armv6l-linux-musleabihf.tar.gz/sha512/e9292a6dc52be228919a9af2b1e73a6968af843d508ffb216ae956a651822ddc1bcbb9fce495da05a11ffb9211903462f7504aa5da78f19f4db5c63c80fc9baf
-LibCURL.v8.4.0+0.armv7l-linux-gnueabihf.tar.gz/md5/dbb847d7f7162b4a2ea5395eca8d7c30
-LibCURL.v8.4.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/3a2c2779392eb19fe9202397688466fc05813a8e35ea6bf85d628e802759c97fae346939902e897313914ce2b38dcfabe0775be6a4a1b1d4264a327687d6a2f3
-LibCURL.v8.4.0+0.armv7l-linux-musleabihf.tar.gz/md5/f9e9557080e09fda47c92f14d5c89de4
-LibCURL.v8.4.0+0.armv7l-linux-musleabihf.tar.gz/sha512/603821f647d17daa1d731a63c7fff35b756b052ee53b6c86d9f35582356d57914336f8b9bb44567f10b437b2c0c677177959ae691e0244bab1262818eb61aa1e
-LibCURL.v8.4.0+0.i686-linux-gnu.tar.gz/md5/eabf3f3392cf8717782c2cb1c1b71478
-LibCURL.v8.4.0+0.i686-linux-gnu.tar.gz/sha512/9584f28cf8f72a6e15afb96a2c27d82b74a12042311c07aecb61732fd6525227f082d448b81950a67c6cc880b39c0921cf039e97bf0bdd4329e2196de42ec81e
-LibCURL.v8.4.0+0.i686-linux-musl.tar.gz/md5/dceef0a3aa971e3b7e3db44b5de159d1
-LibCURL.v8.4.0+0.i686-linux-musl.tar.gz/sha512/483dfe8a3b4589e59794b3b4efba1e60baf9fb45efad6c0b1b9626ad6e492fd803fda3f99545303a32749010df5b9bb89faf608d57eb4fee4c3f387d0b197a5e
-LibCURL.v8.4.0+0.i686-w64-mingw32.tar.gz/md5/2a0a87e126ebaf7bcaff746e30f6905f
-LibCURL.v8.4.0+0.i686-w64-mingw32.tar.gz/sha512/5a2867e8ac27a82e30bb88ea4c3f52faddfbd0b199f25dbef3a77a47be16a4b9299883fc84d50ce965aa2d01d473310b4cbc28c60dad3602f2ee6b56345ea6a5
-LibCURL.v8.4.0+0.powerpc64le-linux-gnu.tar.gz/md5/1f532601778a4dcf9932681e0e47833e
-LibCURL.v8.4.0+0.powerpc64le-linux-gnu.tar.gz/sha512/6ddf56c44124e682eda9cedacb8893ada1e07b6a2cb10fd301afc04b3d1c981b25129b2495efb4d5e37784ee2bb5e47da13be9c2f367ff397a8ce7122136f6e2
-LibCURL.v8.4.0+0.x86_64-apple-darwin.tar.gz/md5/d7c9ab15d9739df8fb4329c0bb2546f6
-LibCURL.v8.4.0+0.x86_64-apple-darwin.tar.gz/sha512/5d5f17534053504dbc3c0b1251f329358bac60c14b734f6b82b4321f96f944b1733254cfd7489504c41d3d2cda5ae991e6cb4f9fa864990a6660cb4464f14530
-LibCURL.v8.4.0+0.x86_64-linux-gnu.tar.gz/md5/f8697c76204df4ac5a04608b6a480f3b
-LibCURL.v8.4.0+0.x86_64-linux-gnu.tar.gz/sha512/ed583b6abc52f6b5a8ee0c93a4e9b877d2830eb131117ac17da044d2fadb218bc293ec6c625a526583aea01f41994a3f9bb5ed5b4263838bab8c251c672b8160
-LibCURL.v8.4.0+0.x86_64-linux-musl.tar.gz/md5/fcb9be4148376414f94d3ddb54f42d12
-LibCURL.v8.4.0+0.x86_64-linux-musl.tar.gz/sha512/8e53219d68fdb4c412de8a19f53572dbd74dc35bba3c6f3c5aab622f05aa76a28e386201d9dd1c78d37d0ea636bb43ad98d1e19599480ba307cc45098600818a
-LibCURL.v8.4.0+0.x86_64-unknown-freebsd.tar.gz/md5/aa4b18c0b8be4be432e24c9cc88670da
-LibCURL.v8.4.0+0.x86_64-unknown-freebsd.tar.gz/sha512/69548673aec3d199a0514ae0e90d6f8700ace47579631522a93ea351151af258127f3bd1fc82f110f22ac6b7c3eab884665773d99842dfc56fa94040a69f1043
-LibCURL.v8.4.0+0.x86_64-w64-mingw32.tar.gz/md5/b477d32139cef0e810e88ceed68b322c
-LibCURL.v8.4.0+0.x86_64-w64-mingw32.tar.gz/sha512/3035a1e9af9eda70018ef56a5a620d5b07b46f63739e0f2e028518c6144577d51a9f9a9e76ed1bf28ee4a5811ea4f502ddeab46694432e441e0151056d5c7e6d
-curl-8.4.0.tar.bz2/md5/1a61fde1fe5c7db5c29c1196435188a5
-curl-8.4.0.tar.bz2/sha512/27a27c5427acce3501833ac37125daaa03c90165692252115329c820a5a6396cdc79c11d12fe962af37a329549c2051addce3c91e8a8bc3ce3a48cb09d860086
+LibCURL.v8.5.0+0.aarch64-apple-darwin.tar.gz/md5/f392ffcb1294f87e24cc10383c8f94e1
+LibCURL.v8.5.0+0.aarch64-apple-darwin.tar.gz/sha512/68c5b9438dee48e758f0837e05ed8ed01669c99dd51bc8803f9c95160579b6749dd41881e552a9847401e679865a63ba2dc07b1974bd26f3f1d712518312aa6a
+LibCURL.v8.5.0+0.aarch64-linux-gnu.tar.gz/md5/6cc08cb80aa779f68fa200dd578b0aae
+LibCURL.v8.5.0+0.aarch64-linux-gnu.tar.gz/sha512/6a09e16a6c20dc19b0d9e98844006d5199b1bbf49aff9126e3a57d07faf69b7da8627ec94a4736ab72525ab90e809cebb8d9976f777487d033786be4ab5dd3ce
+LibCURL.v8.5.0+0.aarch64-linux-musl.tar.gz/md5/89228327d7c5272fdea2c88c2b02ec4e
+LibCURL.v8.5.0+0.aarch64-linux-musl.tar.gz/sha512/c8b00ab354c344c15a24be68f393f7a775a6ef6c3ae4ccde531d7e1aebe49a33173361d357ded0564d73fd03f7c787563061a5d47946f37d0a39722d72a7d5bf
+LibCURL.v8.5.0+0.armv6l-linux-gnueabihf.tar.gz/md5/74f74b891e34893880177f6db05041a2
+LibCURL.v8.5.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/d001bb07c37e87d059bc09ddbf1f19d668f8dd76feafaf0d430cebd03de4c9db8820f1b7ee97fe88128bfda125242e7103b38ba1653c393da349eefc56a35ea8
+LibCURL.v8.5.0+0.armv6l-linux-musleabihf.tar.gz/md5/41d61d599206f917b2045bab814022f3
+LibCURL.v8.5.0+0.armv6l-linux-musleabihf.tar.gz/sha512/9650b18c1a5aa1f71a26ddec9a2659f8332e3eddc570e93f8026e1d74c5ee4a72de989abb0d296e33501ae4223d89dc95670a8f900fb3c0d33d013872ca354bd
+LibCURL.v8.5.0+0.armv7l-linux-gnueabihf.tar.gz/md5/e32cf216cb370de4670437795b01ac85
+LibCURL.v8.5.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/bbd0f186093cdfddcce0b6c310da6e471e51dfa23af8759cdf3e02937b24f55a7a587daac1b7c4538e7e9ed9b9be3538af975d36a6f4e3a2dc30a6fcfb2bdb1d
+LibCURL.v8.5.0+0.armv7l-linux-musleabihf.tar.gz/md5/91f5adf263404e5b7c49b4679ddc9a94
+LibCURL.v8.5.0+0.armv7l-linux-musleabihf.tar.gz/sha512/fdeea044e8fef5d9867f24640bfc2e448e9a7a96e390c6a92898a24c8e73f8bed1a2ad14bee6e3905b581aea12f57fafe2a98800ae05b44e3523a23c26a37bdc
+LibCURL.v8.5.0+0.i686-linux-gnu.tar.gz/md5/89792faedbcf7d51eb5c3298ede593a7
+LibCURL.v8.5.0+0.i686-linux-gnu.tar.gz/sha512/615b98aeb29d3624aa4c4a47d38aba7611ff748ac6ece5c8bebd7fe7132947109199e73b7438a60672af44c943fc5083cd2997e656e6117424e4464cfdc6c0b2
+LibCURL.v8.5.0+0.i686-linux-musl.tar.gz/md5/9417ff0d1866788e72186b4bf18ae721
+LibCURL.v8.5.0+0.i686-linux-musl.tar.gz/sha512/b0a56def69a42163cc3b59102834faa6fc29bee7e6b9854b33e10ac524b143f8a8569ab5069a1c405d2611a173421d68ec86710852aa6b2cec027ccb3b306c20
+LibCURL.v8.5.0+0.i686-w64-mingw32.tar.gz/md5/8d1a76abd11e361dbc1dff4a3bf43d55
+LibCURL.v8.5.0+0.i686-w64-mingw32.tar.gz/sha512/ff4d66a475726933fd1b0f54c92f107bdf36322bc093bda51e03967e1c7d2d6d7ef4afaea9a3b6361a0626db4609358de68b8161fec69367dc3c08347738a299
+LibCURL.v8.5.0+0.powerpc64le-linux-gnu.tar.gz/md5/9b0ffe71aac0a316ca74de264e1e448b
+LibCURL.v8.5.0+0.powerpc64le-linux-gnu.tar.gz/sha512/22c6a5c692e95b2e6da634398871484c8b03a82e2c54beb8c827d298e61629341381e1d3a5a6105c02f880f72688b3cc516c55e4301d6be408e4bbe0fefb7b7a
+LibCURL.v8.5.0+0.x86_64-apple-darwin.tar.gz/md5/8faf119181495ff23d071b289e2737da
+LibCURL.v8.5.0+0.x86_64-apple-darwin.tar.gz/sha512/ed50685336740b2c872d16c7f793e2b5a3189e510dbc60de9b3932a3c14fbd04db0d4dada48b73942f0718f9008ee180024e2e682fba8d718b0781f07bb3c872
+LibCURL.v8.5.0+0.x86_64-linux-gnu.tar.gz/md5/281011966d7cc336b4fd00427073c608
+LibCURL.v8.5.0+0.x86_64-linux-gnu.tar.gz/sha512/8d7f7833e2d21641ae25f6559b1e51362d5f6dac5e5e798a5b1afeb3e9aaef113f91ac6cb6da1b621e484f4ec710370f6beef082a68de7bf2943685bc87b4064
+LibCURL.v8.5.0+0.x86_64-linux-musl.tar.gz/md5/5e0e4cebf892f410b8723b9523556e78
+LibCURL.v8.5.0+0.x86_64-linux-musl.tar.gz/sha512/98d9520311689be84aff0afa96f64561a90eb26252557d62529ff4b1e20386a37615d674f30d33c17a61ffb11c5a02d4788d4608bf820c5dfc71ceecfe25142d
+LibCURL.v8.5.0+0.x86_64-unknown-freebsd.tar.gz/md5/8f54debd5e4e3cfc2c6993a071b8a832
+LibCURL.v8.5.0+0.x86_64-unknown-freebsd.tar.gz/sha512/5da056812a5adc2c5867142c2334a6a0d94009838af256b7fd58a0a31db27d304906f058b5d849ad7fc53f4c04e3d6f93bc6b1ac455c1e3dc58d0a30ff15b17e
+LibCURL.v8.5.0+0.x86_64-w64-mingw32.tar.gz/md5/b0c34ea85a9547313195e05a9c26851b
+LibCURL.v8.5.0+0.x86_64-w64-mingw32.tar.gz/sha512/10dbfd32b72461ee5c573a9059ddcb5de83c9f72398d6c0149a217bcf271e248b7efd97432ca028876580ca24585360e549893e3fcbe6d28191badb170d8f4ec
+curl-8.5.0.tar.bz2/md5/d617745a3fd4456b591da53052a5ea94
+curl-8.5.0.tar.bz2/sha512/7b07b69f8cc80d1aabc7f3b8db12e10ec84c304f7bb8391b8605aa6724c9ad2ce3ab65b111ed011e55d57cd63767adc310bd85d8c897f48e1785502406376005
diff --git a/deps/curl.version b/deps/curl.version
index 288347a9935ed..9194b516aa1b1 100644
--- a/deps/curl.version
+++ b/deps/curl.version
@@ -3,4 +3,4 @@
 CURL_JLL_NAME := LibCURL
 
 ## source build
-CURL_VER := 8.4.0
+CURL_VER := 8.5.0
diff --git a/stdlib/LibCURL_jll/Project.toml b/stdlib/LibCURL_jll/Project.toml
index aa84637e0dc82..3360dc17df34d 100644
--- a/stdlib/LibCURL_jll/Project.toml
+++ b/stdlib/LibCURL_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LibCURL_jll"
 uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
-version = "8.4.0+0"
+version = "8.5.0+0"
 
 [deps]
 LibSSH2_jll = "29816b5a-b9ab-546f-933c-edad1886dfa8"

From 0b5cf42af838f62bb51181f89e4750530cbb9947 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 23 Dec 2023 13:35:12 +0100
Subject: [PATCH 0493/1315] lowering: Optimize lowering of tryfinally with
 trivial finally block (#52593)

This optimizes the lowering of a tryfinally block with empty finally
block to instead use the try/catch lowering, where the catch block is
given as simply `rethrow()`. This is equivalent semantically to
try/finally in this case, but the code structure is a lot simpler with
fewer basic blocks and without the auxiliary slot for tracking the
finally slot. The motivation here is to help the compiler optimize
better when using the `@with` macro, which has an empty `finally` block
(but uses the scope argument of 'tryfinally). The only problem with this
is that it violates the lowering assumptions I made in
https://github.com/JuliaLang/julia/pull/52527, so we'll probably need to
fix that first.
---
 base/scopedvalues.jl |  2 +-
 src/julia-syntax.scm | 22 ++++++++++++++++++----
 test/scopedvalues.jl | 14 ++++++++++++++
 3 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/base/scopedvalues.jl b/base/scopedvalues.jl
index 6eb1004a1d30f..71c8a68785952 100644
--- a/base/scopedvalues.jl
+++ b/base/scopedvalues.jl
@@ -161,7 +161,7 @@ macro with(exprs...)
         error("@with expects at least one argument")
     end
     exprs = map(esc, exprs)
-    Expr(:tryfinally, esc(ex), :(), :(Scope(Core.current_scope()::Union{Nothing, Scope}, $(exprs...))))
+    Expr(:tryfinally, esc(ex), nothing, :(Scope(Core.current_scope()::Union{Nothing, Scope}, $(exprs...))))
 end
 
 """
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 4f91c6fc5b023..6f80611a7f3ea 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -4274,6 +4274,17 @@ f(x) = yt(x)
   ;; returning lambda directly is needed for @generated
   (or (valid-ir-argument? e) (and (pair? e) (memq (car e) '(lambda)))))
 
+(define (code-trivially-effect-free? e)
+  ;; determine whether the execution of this code can be observed.
+  ;; If not it may be deleted. In general, the only thing we can detect here
+  ;; is empty blocks that only have metadata in them.
+  (if (pair? e)
+    (case (car e)
+      ((block) (every code-trivially-effect-free? (cdr e)))
+      ((line null) #t)
+      (else #f))
+    #t))
+
 ;; this pass behaves like an interpreter on the given code.
 ;; to perform stateful operations, it calls `emit` to record that something
 ;; needs to be done. in value position, it returns an expression computing
@@ -4726,10 +4737,13 @@ f(x) = yt(x)
             ((trycatch tryfinally trycatchelse)
              (let ((handler-token (make-ssavalue))
                    (catch (make-label))
+                   (catchcode (if (eq? (car e) 'tryfinally) '(call (top rethrow)) (caddr e)))
                    (els   (and (eq? (car e) 'trycatchelse) (make-label)))
                    (endl  (make-label))
                    (last-finally-handler finally-handler)
-                   (finally           (if (eq? (car e) 'tryfinally) (new-mutable-var) #f))
+                   ;; Special case optimization: If the finally block is trivially empty, don't perform finally
+                   ;; lowering, just lower this as a try/catch block with rethrow and scope hnadling.
+                   (finally           (if (and (eq? (car e) 'tryfinally) (not (code-trivially-effect-free? (caddr e)))) (new-mutable-var) #f))
                    (scope             (if (eq? (car e) 'tryfinally) (cdddr e) '()))
                    (my-finally-handler #f))
                ;; handler block entry
@@ -4738,7 +4752,7 @@ f(x) = yt(x)
                (if finally (begin (set! my-finally-handler (list finally endl '() handler-token-stack catch-token-stack))
                                   (set! finally-handler my-finally-handler)
                                   (emit `(= ,finally -1))))
-               (let* ((v1  (compile (cadr e) break-labels value #f)) ;; emit try block code
+               (let* ((v1 (compile (cadr e) break-labels value #f)) ;; emit try block code
                       (val (if (and value (not tail))
                                (new-mutable-var) #f)))
                  ;; handler block postfix
@@ -4762,7 +4776,7 @@ f(x) = yt(x)
                  ;; separate trycatch and tryfinally blocks earlier.
                  (mark-label catch)
                  (if finally
-                     (begin (enter-finally-block '(call (top rethrow)) #f) ;; enter block via exception
+                     (begin (enter-finally-block catchcode #f) ;; enter block via exception
                             (mark-label endl) ;; non-exceptional control flow enters here
                             (set! finally-handler last-finally-handler)
                             (compile (caddr e) break-labels #f #f)
@@ -4786,7 +4800,7 @@ f(x) = yt(x)
                                     (if skip (mark-label skip))
                                     (loop (cdr actions))))))
                      (begin (set! catch-token-stack (cons handler-token catch-token-stack))
-                            (let ((v2 (compile (caddr e) break-labels value tail)))
+                            (let ((v2 (compile catchcode break-labels value tail)))
                               (if val (emit-assignment val v2))
                               (if (not tail) (emit `(pop_exception ,handler-token)))
                                              ;; else done in emit-return from compile
diff --git a/test/scopedvalues.jl b/test/scopedvalues.jl
index b1f3241af8fc6..7f52707a182f1 100644
--- a/test/scopedvalues.jl
+++ b/test/scopedvalues.jl
@@ -126,3 +126,17 @@ end
         @test sval_float[] == 1.0
     end
 end
+
+# Test that the `@with` macro doesn't introduce unnecessary PhiC nodes
+# (which can be hard for the optimizer to remove).
+function with_macro_slot_cross()
+    a = 1
+    @with sval=>1 begin
+        a = sval_float[]
+    end
+    return a
+end
+
+let code = code_typed(with_macro_slot_cross)[1][1].code
+    @test !any(x->isa(x, Core.PhiCNode), code)
+end

From 52ff55886fdd296c401d281520bca3d87a615e81 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 23 Dec 2023 16:03:47 +0100
Subject: [PATCH 0494/1315] cfg_simplify: Add one more check to avoid merging
 :leave terminator (#52621)

In #52608, I made `:leave` a proper terminator (we already considered it
as such during CFG construction, we just didn't maintain that property
in the optimizer). As part of this, I adjusted one place in cfg_simplify
to avoid merging blocks that end with non-trivial terminators
(previously only EnterNode was considered). Turns out there's another
one, so fix that as well.
---
 base/compiler/ssair/passes.jl | 4 ++--
 test/compiler/irpasses.jl     | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 6476ab0a5a424..7b8ca7ddede3d 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -2140,10 +2140,10 @@ function legalize_bb_drop_pred!(ir::IRCode, bb::BasicBlock, bbidx::Int, bbs::Vec
         end
         ir[last_fallthrough_term_ssa] = nothing
         kill_edge!(bbs, last_fallthrough, terminator.dest)
-    elseif isa(terminator, EnterNode)
-        return false
     elseif isa(terminator, GotoNode)
         return true
+    elseif isterminator(terminator)
+        return false
     end
     # Hack, but effective. If we have a predecessor with a fall-through terminator, change the
     # instruction numbering to merge the blocks now such that below processing will properly
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 48a23fd0d5c39..2297e4de029f4 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1594,7 +1594,7 @@ let code = Any[
         # Block 2
         EnterNode(4),
         # Block 3
-        Expr(:leave),
+        Expr(:leave, SSAValue(2)),
         # Block 4
         GotoNode(5),
         # Block 5
@@ -1603,7 +1603,7 @@ let code = Any[
     ir = make_ircode(code)
     ir = Core.Compiler.cfg_simplify!(ir)
     Core.Compiler.verify_ir(ir)
-    @test length(ir.cfg.blocks) == 4
+    @test length(ir.cfg.blocks) <= 5
 end
 
 # Test CFG simplify with single predecessor phi node

From b51b8094b95f446b5b9bff37adc80e1d041302b7 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Sat, 23 Dec 2023 22:10:19 +0100
Subject: [PATCH 0495/1315] Warn if an already loaded package is attempted to
 be loaded from a different path (#44329)

---
 base/loading.jl | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/base/loading.jl b/base/loading.jl
index 4e7ca940d15a1..81778d41893c0 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1502,6 +1502,7 @@ function _tryrequire_from_serialized(modkey::PkgId, build_id::UInt128)
     assert_havelock(require_lock)
     loaded = nothing
     if root_module_exists(modkey)
+        warn_if_already_loaded_different(modkey)
         loaded = root_module(modkey)
     else
         loaded = start_loading(modkey)
@@ -1532,6 +1533,7 @@ function _tryrequire_from_serialized(modkey::PkgId, path::String, ocachepath::Un
     assert_havelock(require_lock)
     loaded = nothing
     if root_module_exists(modkey)
+        warn_if_already_loaded_different(modkey)
         loaded = root_module(modkey)
     else
         loaded = start_loading(modkey)
@@ -1975,11 +1977,50 @@ function __require_prelocked(uuidkey::PkgId, env=nothing)
         # After successfully loading, notify downstream consumers
         run_package_callbacks(uuidkey)
     else
+        warn_if_already_loaded_different(uuidkey)
         newm = root_module(uuidkey)
     end
     return newm
 end
 
+const already_warned_path_change_pkgs = Set{UUID}()
+# warns if the loaded version of a module is different to the one that locate_package wants to load
+function warn_if_already_loaded_different(uuidkey::PkgId)
+    uuidkey.uuid ∈ already_warned_path_change_pkgs && return
+    pkgorig = get(pkgorigins, uuidkey, nothing)
+    if pkgorig !== nothing && pkgorig.path !== nothing
+        new_path = locate_package(uuidkey)
+        if !samefile(fixup_stdlib_path(pkgorig.path), new_path)
+            if isnothing(pkgorig.version)
+                v = get_pkgversion_from_path(dirname(dirname(pkgorig.path)))
+                cur_vstr = isnothing(v) ? "" : "v$v "
+            else
+                cur_vstr = "v$v "
+            end
+            new_v = get_pkgversion_from_path(dirname(dirname(new_path)))
+            new_vstr = isnothing(new_v) ? "" : "v$new_v "
+            warnstr = """
+            $uuidkey is already loaded from a different path:
+              loaded:    $cur_vstr$(repr(pkgorig.path))
+              requested: $new_vstr$(repr(new_path))
+            """
+            if isempty(already_warned_path_change_pkgs)
+                warnstr *= """
+                This might indicate a change of environment has happened between package loads and can mean that
+                incompatible packages have been loaded"""
+                if JLOptions().startupfile < 2 #(0 = auto, 1 = yes)
+                    warnstr *= """. If this happened due to a startup.jl consider starting julia
+                    directly in the project via the `--project` arg."""
+                else
+                    warnstr *= "."
+                end
+            end
+            @warn warnstr
+            push!(already_warned_path_change_pkgs, uuidkey.uuid)
+        end
+    end
+end
+
 mutable struct PkgOrigin
     path::Union{String,Nothing}
     cachepath::Union{String,Nothing}

From ef549aef46c52ea616d99a3717a55656894c81cf Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 25 Dec 2023 18:21:49 +0530
Subject: [PATCH 0496/1315] Don't access parent of triangular matrix in powm
 (#52583)

Since the values stored in the parent corresponding to the structural
zeros of a tridiagonal matrix aren't well-defined, using it in `ldiv!`
is a footgun that may lead to heisenbugs (one seen in
https://buildkite.com/julialang/julia-master/builds/31285#018c7cc7-6c77-41ac-a01b-1c7d14cb1b15).
This PR changes it to using the tridiagonal matrix directly in `ldiv!`,
which should lead to predictable results, and be bug-free. The failing
tests for #52571 pass locally with this change.
---
 stdlib/LinearAlgebra/src/triangular.jl | 8 ++++----
 stdlib/LinearAlgebra/test/dense.jl     | 5 +++++
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 66e5fd3e4b4c1..8c59c73e7dd21 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -1602,7 +1602,7 @@ end
 #   Higham and Lin, "An improved Schur-Padé algorithm for fractional powers of
 #     a matrix and their Fréchet derivatives", SIAM. J. Matrix Anal. & Appl.,
 #     34(3), (2013) 1341–1360.
-function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real)
+function powm!(A0::UpperTriangular, p::Real)
     if abs(p) >= 1
         throw(ArgumentError("p must be a real number in (-1,1), got $p"))
     end
@@ -1634,7 +1634,7 @@ function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real)
         end
         copyto!(Stmp, S)
         mul!(S, A, c)
-        ldiv!(Stmp, S.data)
+        ldiv!(Stmp, S)
 
         c = (p - j) / (j4 - 2)
         for i = 1:n
@@ -1642,14 +1642,14 @@ function powm!(A0::UpperTriangular{<:BlasFloat}, p::Real)
         end
         copyto!(Stmp, S)
         mul!(S, A, c)
-        ldiv!(Stmp, S.data)
+        ldiv!(Stmp, S)
     end
     for i = 1:n
         S[i, i] = S[i, i] + 1
     end
     copyto!(Stmp, S)
     mul!(S, A, -p)
-    ldiv!(Stmp, S.data)
+    ldiv!(Stmp, S)
     for i = 1:n
         @inbounds S[i, i] = S[i, i] + 1
     end
diff --git a/stdlib/LinearAlgebra/test/dense.jl b/stdlib/LinearAlgebra/test/dense.jl
index 66670f579aa1f..afc1df817a544 100644
--- a/stdlib/LinearAlgebra/test/dense.jl
+++ b/stdlib/LinearAlgebra/test/dense.jl
@@ -1070,6 +1070,11 @@ end
     @test (@inferred Tschurpow LinearAlgebra.schurpow(Aa, 2.0)) ≈ Aa^2
 end
 
+@testset "BigFloat triangular real power" begin
+    A = Float64[3 1; 0 3]
+    @test A^(3/4) ≈ big.(A)^(3/4)
+end
+
 @testset "diagonal integer matrix to real power" begin
     A = Matrix(Diagonal([1, 2, 3]))
     @test A^2.3 ≈ float(A)^2.3

From 4e4c0e5eda31c5d85f8500ad621b89f77e9d4a90 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Mon, 25 Dec 2023 13:53:09 +0100
Subject: [PATCH 0497/1315] simplification in `permutedims!` (#52623)

`strides_1` was never used, and the `@nexprs` that creates `strides_i`
can be replaced with `@ntuple`.

Fixes #52615, credit: ararslan.
---
 base/multidimensional.jl | 10 +++++-----
 test/arrayops.jl         |  3 +++
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 0ca2fbc36e6df..390e8024f79fd 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -1622,17 +1622,17 @@ for (V, PT, BT) in Any[((:N,), BitArray, BitArray), ((:T,:N), Array, StridedArra
 
             #calculates all the strides
             native_strides = size_to_strides(1, size(B)...)
-            strides_1 = 0
-            @nexprs $N d->(strides_{d+1} = native_strides[perm[d]])
+            strides = @ntuple $N d->native_strides[perm[d]]
+            strides::NTuple{$N,Integer}
 
             #Creates offset, because indexing starts at 1
-            offset = 1 - sum(@ntuple $N d->strides_{d+1})
+            offset = 1 - reduce(+, strides, init = 0)
 
             sumc = 0
             ind = 1
             @nloops($N, i, P,
-                    d->(sumc += i_d*strides_{d+1}), # PRE
-                    d->(sumc -= i_d*strides_{d+1}), # POST
+                    d->(sumc += i_d*strides[d]), # PRE
+                    d->(sumc -= i_d*strides[d]), # POST
                     begin # BODY
                         @inbounds P[ind] = B[sumc+offset]
                         ind += 1
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 8e33e209ee88b..b35e65b0aebad 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -741,6 +741,9 @@ end
     v = [1,2,3]
     @test permutedims(v) == [1 2 3]
 
+    zd = fill(0)
+    @test permutedims(zd, ()) == zd
+
     x = PermutedDimsArray([1 2; 3 4], (2, 1))
     @test size(x) == (2, 2)
     @test copy(x) == [1 3; 2 4]

From 933a83af6af1a5d272095a8875192f944b182f29 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Mon, 25 Dec 2023 20:54:47 +0800
Subject: [PATCH 0498/1315] Fix inconsistant logical index behavior (#45869)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1. If we use `BitArray`/`Array{Bool}` to index, `to_indices` has an
optimiztion for linear-iteratable case.
But the corresponding check is not correct. IIUC, this optimization is
legal only when the Boolen array is the only index provided.
The first commit fix it and widen this optimization to all Boolen array.
Before this PR
```julia
julia> A = rand(2,3,4); I = rand(Bool,3,4);

julia> A[1,I] == A[1,view(I,:,:)]
ERROR: BoundsError: attempt to access 2×3×4 Array{Float64, 3} at index [1, 3×4 Matrix{Bool}]
```
After
```julia
julia> A = rand(2,3,4); I = rand(Bool,3,4);

julia> A[1,I] == A[1,view(I,:,:)]
true
```

2. On master, if the index/array has singleton trailing dimension,
boundcheck of logical index show different behavior depending on the
number of indexes provided.
If there's only one index variable, singleton dimension wil not be
ignored. The second commit fix it. (close #45867)

---------

Co-authored-by: Matt Bauman <mbauman@gmail.com>
---
 base/abstractarray.jl    |  41 +++++-------
 base/indices.jl          |  11 +---
 base/multidimensional.jl | 130 +++++++++++++++++++--------------------
 doc/src/manual/arrays.md |  58 +++++++++--------
 test/abstractarray.jl    |  26 +++++++-
 5 files changed, 139 insertions(+), 127 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 200586213cc90..a5acf465219c2 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -678,15 +678,12 @@ function checkbounds(::Type{Bool}, A::AbstractArray, I...)
     checkbounds_indices(Bool, axes(A), I)
 end
 
-# Linear indexing is explicitly allowed when there is only one (non-cartesian) index
+# Linear indexing is explicitly allowed when there is only one (non-cartesian) index;
+# indices that do not allow linear indexing (e.g., logical arrays, cartesian indices, etc)
+# must add specialized methods to implement their restrictions
 function checkbounds(::Type{Bool}, A::AbstractArray, i)
     @inline
-    checkindex(Bool, eachindex(IndexLinear(), A), i)
-end
-# As a special extension, allow using logical arrays that match the source array exactly
-function checkbounds(::Type{Bool}, A::AbstractArray{<:Any,N}, I::AbstractArray{Bool,N}) where N
-    @inline
-    axes(A) == axes(I)
+    return checkindex(Bool, eachindex(IndexLinear(), A), i)
 end
 
 """
@@ -720,16 +717,13 @@ of `IA`.
 
 See also [`checkbounds`](@ref).
 """
-function checkbounds_indices(::Type{Bool}, IA::Tuple, I::Tuple)
-    @inline
-    checkindex(Bool, IA[1], I[1])::Bool & checkbounds_indices(Bool, tail(IA), tail(I))
-end
-function checkbounds_indices(::Type{Bool}, ::Tuple{}, I::Tuple)
+function checkbounds_indices(::Type{Bool}, inds::Tuple, I::Tuple{Any, Vararg})
     @inline
-    checkindex(Bool, OneTo(1), I[1])::Bool & checkbounds_indices(Bool, (), tail(I))
+    return checkindex(Bool, get(inds, 1, OneTo(1)), I[1])::Bool &
+        checkbounds_indices(Bool, safe_tail(inds), tail(I))
 end
-checkbounds_indices(::Type{Bool}, IA::Tuple, ::Tuple{}) = (@inline; all(x->length(x)==1, IA))
-checkbounds_indices(::Type{Bool}, ::Tuple{}, ::Tuple{}) = true
+
+checkbounds_indices(::Type{Bool}, inds::Tuple, ::Tuple{}) = (@inline; all(x->length(x)==1, inds))
 
 # check along a single dimension
 """
@@ -751,20 +745,19 @@ julia> checkindex(Bool, 1:20, 21)
 false
 ```
 """
-checkindex(::Type{Bool}, inds::AbstractUnitRange, i) =
-    throw(ArgumentError("unable to check bounds for indices of type $(typeof(i))"))
+checkindex(::Type{Bool}, inds, i) = throw(ArgumentError("unable to check bounds for indices of type $(typeof(i))"))
 checkindex(::Type{Bool}, inds::AbstractUnitRange, i::Real) = (first(inds) <= i) & (i <= last(inds))
 checkindex(::Type{Bool}, inds::IdentityUnitRange, i::Real) = checkindex(Bool, inds.indices, i)
 checkindex(::Type{Bool}, inds::OneTo{T}, i::T) where {T<:BitInteger} = unsigned(i - one(i)) < unsigned(last(inds))
 checkindex(::Type{Bool}, inds::AbstractUnitRange, ::Colon) = true
 checkindex(::Type{Bool}, inds::AbstractUnitRange, ::Slice) = true
-function checkindex(::Type{Bool}, inds::AbstractUnitRange, r::AbstractRange)
-    @_propagate_inbounds_meta
-    isempty(r) | (checkindex(Bool, inds, first(r)) & checkindex(Bool, inds, last(r)))
-end
-checkindex(::Type{Bool}, indx::AbstractUnitRange, I::AbstractVector{Bool}) = indx == axes1(I)
-checkindex(::Type{Bool}, indx::AbstractUnitRange, I::AbstractArray{Bool}) = false
-function checkindex(::Type{Bool}, inds::AbstractUnitRange, I::AbstractArray)
+checkindex(::Type{Bool}, inds::AbstractUnitRange, i::AbstractRange) =
+    isempty(i) | (checkindex(Bool, inds, first(i)) & checkindex(Bool, inds, last(i)))
+# range like indices with cheap `extrema`
+checkindex(::Type{Bool}, inds::AbstractUnitRange, i::LinearIndices) =
+    isempty(i) | (checkindex(Bool, inds, first(i)) & checkindex(Bool, inds, last(i)))
+
+function checkindex(::Type{Bool}, inds, I::AbstractArray)
     @inline
     b = true
     for i in I
diff --git a/base/indices.jl b/base/indices.jl
index 810b9fd5b8627..ee3d076c5d7ec 100644
--- a/base/indices.jl
+++ b/base/indices.jl
@@ -349,15 +349,8 @@ to_indices(A, I::Tuple{}) = ()
 to_indices(A, I::Tuple{Vararg{Int}}) = I
 to_indices(A, I::Tuple{Vararg{Integer}}) = (@inline; to_indices(A, (), I))
 to_indices(A, inds, ::Tuple{}) = ()
-function to_indices(A, inds, I::Tuple{Any, Vararg{Any}})
-    @inline
-    head = _to_indices1(A, inds, I[1])
-    rest = to_indices(A, _cutdim(inds, I[1]), tail(I))
-    (head..., rest...)
-end
-
-_to_indices1(A, inds, I1) = (to_index(A, I1),)
-_cutdim(inds, I1) = safe_tail(inds)
+to_indices(A, inds, I::Tuple{Any, Vararg}) =
+    (@inline; (to_index(A, I[1]), to_indices(A, safe_tail(inds), tail(I))...))
 
 """
     Slice(indices)
diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 390e8024f79fd..4416d377c63a0 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -4,12 +4,12 @@
 module IteratorsMD
     import .Base: eltype, length, size, first, last, in, getindex, setindex!,
                   min, max, zero, oneunit, isless, eachindex,
-                  convert, show, iterate, promote_rule
+                  convert, show, iterate, promote_rule, to_indices
 
     import .Base: +, -, *, (:)
     import .Base: simd_outer_range, simd_inner_length, simd_index, setindex
-    import .Base: to_indices, to_index, _to_indices1, _cutdim
-    using .Base: IndexLinear, IndexCartesian, AbstractCartesianIndex, fill_to_length, tail,
+    using .Base: to_index, fill_to_length, tail, safe_tail
+    using .Base: IndexLinear, IndexCartesian, AbstractCartesianIndex,
         ReshapedArray, ReshapedArrayLF, OneTo, Fix1
     using .Base.Iterators: Reverse, PartitionIterator
     using .Base: @propagate_inbounds
@@ -465,11 +465,13 @@ module IteratorsMD
     last(iter::CartesianIndices)  = CartesianIndex(map(last, iter.indices))
 
     # When used as indices themselves, CartesianIndices can simply become its tuple of ranges
-    _to_indices1(A, inds, I1::CartesianIndices) = map(Fix1(to_index, A), I1.indices)
-    _cutdim(inds::Tuple, I1::CartesianIndices) = split(inds, Val(ndims(I1)))[2]
-
+    @inline function to_indices(A, inds, I::Tuple{CartesianIndices{N}, Vararg}) where N
+        _, indstail = split(inds, Val(N))
+        (map(Fix1(to_index, A), I[1].indices)..., to_indices(A, indstail, tail(I))...)
+    end
     # but preserve CartesianIndices{0} as they consume a dimension.
-    _to_indices1(A, inds, I1::CartesianIndices{0}) = (I1,)
+    @inline to_indices(A, inds, I::Tuple{CartesianIndices{0}, Vararg}) =
+        (first(I), to_indices(A, inds, tail(I))...)
 
     @inline in(i::CartesianIndex, r::CartesianIndices) = false
     @inline in(i::CartesianIndex{N}, r::CartesianIndices{N}) where {N} = all(map(in, i.I, r.indices))
@@ -682,17 +684,15 @@ using .IteratorsMD
 
 ## Bounds-checking with CartesianIndex
 # Disallow linear indexing with CartesianIndex
-function checkbounds(::Type{Bool}, A::AbstractArray, i::Union{CartesianIndex, AbstractArray{<:CartesianIndex}})
-    @inline
+@inline checkbounds(::Type{Bool}, A::AbstractArray, i::CartesianIndex) =
     checkbounds_indices(Bool, axes(A), (i,))
+# Here we try to consume N of the indices (if there are that many available)
+@inline function checkbounds_indices(::Type{Bool}, inds::Tuple, I::Tuple{CartesianIndex,Vararg})
+    inds1, rest = IteratorsMD.split(inds, Val(length(I[1])))
+    checkindex(Bool, inds1, I[1]) & checkbounds_indices(Bool, rest, tail(I))
 end
-
-@inline checkbounds_indices(::Type{Bool}, ::Tuple{}, I::Tuple{CartesianIndex,Vararg{Any}}) =
-    checkbounds_indices(Bool, (), (I[1].I..., tail(I)...))
-@inline checkbounds_indices(::Type{Bool}, IA::Tuple{Any}, I::Tuple{CartesianIndex,Vararg{Any}}) =
-    checkbounds_indices(Bool, IA, (I[1].I..., tail(I)...))
-@inline checkbounds_indices(::Type{Bool}, IA::Tuple, I::Tuple{CartesianIndex,Vararg{Any}}) =
-    checkbounds_indices(Bool, IA, (I[1].I..., tail(I)...))
+@inline checkindex(::Type{Bool}, inds::Tuple, I::CartesianIndex) =
+    checkbounds_indices(Bool, inds, I.I)
 
 # Indexing into Array with mixtures of Integers and CartesianIndices is
 # extremely performance-sensitive. While the abstract fallbacks support this,
@@ -702,45 +702,17 @@ end
 @propagate_inbounds setindex!(A::Array, v, i1::Union{Integer, CartesianIndex}, I::Union{Integer, CartesianIndex}...) =
     (A[to_indices(A, (i1, I...))...] = v; A)
 
-# Support indexing with an array of CartesianIndex{N}s
+## Bounds-checking with arrays of CartesianIndex{N}
+# Disallow linear indexing with an array of CartesianIndex{N}
+@inline checkbounds(::Type{Bool}, A::AbstractArray, i::AbstractArray{CartesianIndex{N}}) where {N} =
+    checkbounds_indices(Bool, axes(A), (i,))
 # Here we try to consume N of the indices (if there are that many available)
-# The first two simply handle ambiguities
-@inline function checkbounds_indices(::Type{Bool}, ::Tuple{},
-        I::Tuple{AbstractArray{CartesianIndex{N}},Vararg{Any}}) where N
-    checkindex(Bool, (), I[1]) & checkbounds_indices(Bool, (), tail(I))
-end
-@inline function checkbounds_indices(::Type{Bool}, IA::Tuple{Any},
-        I::Tuple{AbstractArray{CartesianIndex{0}},Vararg{Any}})
-    checkbounds_indices(Bool, IA, tail(I))
-end
-@inline function checkbounds_indices(::Type{Bool}, IA::Tuple{Any},
-        I::Tuple{AbstractArray{CartesianIndex{N}},Vararg{Any}}) where N
-    checkindex(Bool, IA, I[1]) & checkbounds_indices(Bool, (), tail(I))
-end
-@inline function checkbounds_indices(::Type{Bool}, IA::Tuple,
-        I::Tuple{AbstractArray{CartesianIndex{N}},Vararg{Any}}) where N
-    IA1, IArest = IteratorsMD.split(IA, Val(N))
-    checkindex(Bool, IA1, I[1]) & checkbounds_indices(Bool, IArest, tail(I))
+@inline function checkbounds_indices(::Type{Bool}, inds::Tuple, I::Tuple{AbstractArray{CartesianIndex{N}},Vararg}) where N
+    inds1, rest = IteratorsMD.split(inds, Val(N))
+    checkindex(Bool, inds1, I[1]) & checkbounds_indices(Bool, rest, tail(I))
 end
-
-
-@inline function checkbounds_indices(::Type{Bool}, IA::Tuple{},
-    I::Tuple{AbstractArray{Bool,N},Vararg{Any}}) where N
-    return checkbounds_indices(Bool, IA, (LogicalIndex(I[1]), tail(I)...))
-end
-@inline function checkbounds_indices(::Type{Bool}, IA::Tuple,
-    I::Tuple{AbstractArray{Bool,N},Vararg{Any}}) where N
-    return checkbounds_indices(Bool, IA, (LogicalIndex(I[1]), tail(I)...))
-end
-
-function checkindex(::Type{Bool}, inds::Tuple, I::AbstractArray{<:CartesianIndex})
-    b = true
-    for i in I
-        b &= checkbounds_indices(Bool, inds, (i,))
-    end
-    b
-end
-checkindex(::Type{Bool}, inds::Tuple, I::CartesianIndices) = all(checkindex.(Bool, inds, I.indices))
+@inline checkindex(::Type{Bool}, inds::Tuple, I::CartesianIndices) =
+    checkbounds_indices(Bool, inds, I.indices)
 
 # combined count of all indices, including CartesianIndex and
 # AbstractArray{CartesianIndex}
@@ -848,11 +820,29 @@ end
     return eltype(L)(i1, irest...), (i1 - tz, Bi, irest, c)
 end
 
-@inline checkbounds(::Type{Bool}, A::AbstractArray, I::LogicalIndex{<:Any,<:AbstractArray{Bool,1}}) =
-    eachindex(IndexLinear(), A) == eachindex(IndexLinear(), I.mask)
-@inline checkbounds(::Type{Bool}, A::AbstractArray, I::LogicalIndex) = axes(A) == axes(I.mask)
-@inline checkindex(::Type{Bool}, indx::AbstractUnitRange, I::LogicalIndex) = (indx,) == axes(I.mask)
-checkindex(::Type{Bool}, inds::Tuple, I::LogicalIndex) = checkbounds_indices(Bool, inds, axes(I.mask))
+## Boundscheck for Logicalindex
+# LogicalIndex: map all calls to mask
+checkbounds(::Type{Bool}, A::AbstractArray, i::LogicalIndex) = checkbounds(Bool, A, i.mask)
+# `checkbounds_indices` has been handled via `I::AbstractArray` fallback
+checkindex(::Type{Bool}, inds::AbstractUnitRange, i::LogicalIndex) = checkindex(Bool, inds, i.mask)
+checkindex(::Type{Bool}, inds::Tuple, i::LogicalIndex) = checkindex(Bool, inds, i.mask)
+
+## Boundscheck for AbstractArray{Bool}
+# Disallow linear indexing with AbstractArray{Bool}
+checkbounds(::Type{Bool}, A::AbstractArray, i::AbstractArray{Bool}) =
+    checkbounds_indices(Bool, axes(A), (i,))
+# But allow linear indexing with AbstractVector{Bool}
+checkbounds(::Type{Bool}, A::AbstractArray, i::AbstractVector{Bool}) =
+    checkindex(Bool, eachindex(IndexLinear(), A), i)
+@inline function checkbounds_indices(::Type{Bool}, inds::Tuple, I::Tuple{AbstractArray{Bool},Vararg})
+    inds1, rest = IteratorsMD.split(inds, Val(ndims(I[1])))
+    checkindex(Bool, inds1, I[1]) & checkbounds_indices(Bool, rest, tail(I))
+end
+checkindex(::Type{Bool}, inds::AbstractUnitRange, I::AbstractVector{Bool}) = axes1(I) == inds
+checkindex(::Type{Bool}, inds::AbstractUnitRange, I::AbstractRange{Bool}) = axes1(I) == inds
+checkindex(::Type{Bool}, inds::Tuple, I::AbstractArray{Bool}) = _check_boolean_axes(inds, axes(I))
+_check_boolean_axes(inds::Tuple, axes::Tuple) = (inds[1] == axes[1]) & _check_boolean_axes(tail(inds), tail(axes))
+_check_boolean_axes(::Tuple{}, axes::Tuple) = all(==(OneTo(1)), axes)
 
 ensure_indexable(I::Tuple{}) = ()
 @inline ensure_indexable(I::Tuple{Any, Vararg{Any}}) = (I[1], ensure_indexable(tail(I))...)
@@ -863,20 +853,28 @@ ensure_indexable(I::Tuple{}) = ()
 @inline to_indices(A, I::Tuple{Vararg{Union{Integer, CartesianIndex}}}) = to_indices(A, (), I)
 # But some index types require more context spanning multiple indices
 # CartesianIndex is unfolded outside the inner to_indices for better inference
-_to_indices1(A, inds, I1::CartesianIndex) = map(Fix1(to_index, A), I1.I)
-_cutdim(inds, I1::CartesianIndex) = IteratorsMD.split(inds, Val(length(I1)))[2]
+@inline function to_indices(A, inds, I::Tuple{CartesianIndex{N}, Vararg}) where N
+    _, indstail = IteratorsMD.split(inds, Val(N))
+    (map(Fix1(to_index, A), I[1].I)..., to_indices(A, indstail, tail(I))...)
+end
 # For arrays of CartesianIndex, we just skip the appropriate number of inds
-_cutdim(inds, I1::AbstractArray{CartesianIndex{N}}) where {N} = IteratorsMD.split(inds, Val(N))[2]
+@inline function to_indices(A, inds, I::Tuple{AbstractArray{CartesianIndex{N}}, Vararg}) where N
+    _, indstail = IteratorsMD.split(inds, Val(N))
+    (to_index(A, I[1]), to_indices(A, indstail, tail(I))...)
+end
 # And boolean arrays behave similarly; they also skip their number of dimensions
-_cutdim(inds::Tuple, I1::AbstractArray{Bool}) = IteratorsMD.split(inds, Val(ndims(I1)))[2]
-# As an optimization, we allow trailing Array{Bool} and BitArray to be linear over trailing dimensions
-@inline to_indices(A, inds, I::Tuple{Union{Array{Bool,N}, BitArray{N}}}) where {N} =
-    (_maybe_linear_logical_index(IndexStyle(A), A, I[1]),)
+@inline function to_indices(A, inds, I::Tuple{AbstractArray{Bool, N}, Vararg}) where N
+    _, indstail = IteratorsMD.split(inds, Val(N))
+    (to_index(A, I[1]), to_indices(A, indstail, tail(I))...)
+end
+# As an optimization, we allow the only `AbstractArray{Bool}` to be linear-iterated
+@inline to_indices(A, I::Tuple{AbstractArray{Bool}}) = (_maybe_linear_logical_index(IndexStyle(A), A, I[1]),)
 _maybe_linear_logical_index(::IndexStyle, A, i) = to_index(A, i)
 _maybe_linear_logical_index(::IndexLinear, A, i) = LogicalIndex{Int}(i)
 
 # Colons get converted to slices by `uncolon`
-_to_indices1(A, inds, I1::Colon) = (uncolon(inds),)
+@inline to_indices(A, inds, I::Tuple{Colon, Vararg}) =
+    (uncolon(inds), to_indices(A, Base.safe_tail(inds), tail(I))...)
 
 uncolon(::Tuple{}) = Slice(OneTo(1))
 uncolon(inds::Tuple) = Slice(inds[1])
diff --git a/doc/src/manual/arrays.md b/doc/src/manual/arrays.md
index 09a095729f174..13b289becf6e0 100644
--- a/doc/src/manual/arrays.md
+++ b/doc/src/manual/arrays.md
@@ -793,38 +793,46 @@ Indexing by a boolean vector `B` is effectively the same as indexing by the
 vector of integers that is returned by [`findall(B)`](@ref). Similarly, indexing
 by a `N`-dimensional boolean array is effectively the same as indexing by the
 vector of `CartesianIndex{N}`s where its values are `true`. A logical index
-must be a vector of the same length as the dimension it indexes into, or it
-must be the only index provided and match the size and dimensionality of the
-array it indexes into. It is generally more efficient to use boolean arrays as
-indices directly instead of first calling [`findall`](@ref).
+must be a array of the same shape as the dimension(s) it indexes into, or it
+must be the only index provided and match the shape of the one-dimensional
+reshaped view of the array it indexes into. It is generally more efficient
+to use boolean arrays as indices directly instead of first calling [`findall`](@ref).
 
 ```jldoctest
-julia> x = reshape(1:16, 4, 4)
-4×4 reshape(::UnitRange{Int64}, 4, 4) with eltype Int64:
- 1  5   9  13
- 2  6  10  14
- 3  7  11  15
- 4  8  12  16
+julia> x = reshape(1:12, 2, 3, 2)
+2×3×2 reshape(::UnitRange{Int64}, 2, 3, 2) with eltype Int64:
+[:, :, 1] =
+ 1  3  5
+ 2  4  6
 
-julia> x[[false, true, true, false], :]
-2×4 Matrix{Int64}:
- 2  6  10  14
- 3  7  11  15
+[:, :, 2] =
+ 7   9  11
+ 8  10  12
+
+julia> x[:, [true false; false true; true false]]
+2×3 Matrix{Int64}:
+ 1  5   9
+ 2  6  10
 
 julia> mask = map(ispow2, x)
-4×4 Matrix{Bool}:
- 1  0  0  0
- 1  0  0  0
- 0  0  0  0
- 1  1  0  1
+2×3×2 Array{Bool, 3}:
+[:, :, 1] =
+ 1  0  0
+ 1  1  0
+
+[:, :, 2] =
+ 0  0  0
+ 1  0  0
 
 julia> x[mask]
-5-element Vector{Int64}:
-  1
-  2
-  4
-  8
- 16
+4-element Vector{Int64}:
+ 1
+ 2
+ 4
+ 8
+
+julia> x[vec(mask)] == x[mask] # we can also index with a single Boolean vector
+true
 ```
 
 ### Number of indices
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 8762440a2f25a..cb704e5bb4bc4 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -84,6 +84,7 @@ end
     @test checkbounds(Bool, A, 1:60) == true
     @test checkbounds(Bool, A, 1:61) == false
     @test checkbounds(Bool, A, 2, 2, 2, 1:1) == true  # extra indices
+    @test checkbounds(Bool, A, 2, 2, 2, 10:9) == true
     @test checkbounds(Bool, A, 2, 2, 2, 1:2) == false
     @test checkbounds(Bool, A, 1:5, 1:4) == false
     @test checkbounds(Bool, A, 1:5, 1:12) == false
@@ -104,6 +105,7 @@ end
     @test checkbounds(Bool, A, trues(5), trues(13)) == false
     @test checkbounds(Bool, A, trues(6), trues(12)) == false
     @test checkbounds(Bool, A, trues(5, 4, 3)) == true
+    @test checkbounds(Bool, A, trues(5, 4, 3, 1)) == true # issue 45867
     @test checkbounds(Bool, A, trues(5, 4, 2)) == false
     @test checkbounds(Bool, A, trues(5, 12)) == false
     @test checkbounds(Bool, A, trues(1, 5), trues(1, 4, 1), trues(1, 1, 3)) == false
@@ -111,7 +113,9 @@ end
     @test checkbounds(Bool, A, trues(1, 5), trues(1, 5, 1), trues(1, 1, 3)) == false
     @test checkbounds(Bool, A, trues(1, 5), :, 2) == false
     @test checkbounds(Bool, A, trues(5, 4), trues(3)) == true
-    @test checkbounds(Bool, A, trues(4, 4), trues(3)) == true
+    @test checkbounds(Bool, A, trues(5), trues(4, 3, 1)) == true
+    @test checkbounds(Bool, A, trues(5, 4), trues(3, 2)) == false
+    @test checkbounds(Bool, A, trues(4, 4), trues(3)) == false
     @test checkbounds(Bool, A, trues(5, 4), trues(2)) == false
     @test checkbounds(Bool, A, trues(6, 4), trues(3)) == false
     @test checkbounds(Bool, A, trues(5, 4), trues(4)) == false
@@ -134,6 +138,10 @@ end
     @test checkbounds(Bool, A, [CartesianIndex((6, 4))], 3) == false
     @test checkbounds(Bool, A, [CartesianIndex((5, 5))], 3) == false
     @test checkbounds(Bool, A, [CartesianIndex((5, 4))], 4) == false
+    @test checkbounds(Bool, A, 5, [CartesianIndex((4, 3, 1))]) == true
+    @test checkbounds(Bool, A, 5, [CartesianIndex((4, 3, 2))]) == false
+    @test_throws ArgumentError checkbounds(Bool, A, [CartesianIndex((4, 3)), CartesianIndex((4,))])
+    @test_throws ArgumentError checkbounds(Bool, A, [CartesianIndex((1,)), 1])
 end
 
 @testset "index conversion" begin
@@ -487,6 +495,13 @@ function test_vector_indexing(::Type{T}, shape, ::Type{TestAbstractArray}) where
 
         mask = bitrand(shape)
         @testset "test logical indexing" begin
+            let
+                masks1 = (mask,)
+                @test only(@inferred(to_indices(A, masks1))) isa Base.LogicalIndex{Int}
+                if IndexStyle(B) isa IndexCartesian
+                    @test only(@inferred(to_indices(B, masks1))) === Base.LogicalIndex(mask)
+                end
+            end
             @test B[mask] == A[mask] == B[findall(mask)] == A[findall(mask)] == LinearIndices(mask)[findall(mask)]
             @test B[vec(mask)] == A[vec(mask)] == LinearIndices(mask)[findall(mask)]
             mask1 = bitrand(size(A, 1))
@@ -496,10 +511,15 @@ function test_vector_indexing(::Type{T}, shape, ::Type{TestAbstractArray}) where
             @test B[mask1, 1, trailing2] == A[mask1, 1, trailing2] == LinearIndices(mask)[findall(mask1)]
 
             if ndims(B) > 1
+                slice = ntuple(Returns(:), ndims(B)-1)
                 maskfront = bitrand(shape[1:end-1])
-                Bslice = B[ntuple(i->(:), ndims(B)-1)..., 1]
-                @test B[maskfront,1] == Bslice[maskfront]
+                Bslicefront = B[slice..., 1]
+                @test B[maskfront, 1] == Bslicefront[maskfront]
                 @test size(B[maskfront, 1:1]) == (sum(maskfront), 1)
+                maskend = bitrand(shape[2:end])
+                Bsliceend = B[1, slice...]
+                @test B[1 ,maskend] == Bsliceend[maskend]
+                @test size(B[1:1, maskend]) == (1, sum(maskend))
             end
         end
     end

From 713560bb4fe190d59b212021a5d0eda5ffba1010 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 25 Dec 2023 18:25:56 +0530
Subject: [PATCH 0499/1315] Specialize axes for structured matrices (#52480)

On master
```julia
julia> S = SMatrix{4,4}(1:16);

julia> A = StructArray{Complex{Int}}((S,S));

julia> axes(Symmetric(A))
(Base.OneTo(4), Base.OneTo(4))
```
The static axes are lost. After this,
```julia
julia> axes(Symmetric(A))
(SOneTo(4), SOneTo(4))
```
Similarly, I've added methods for other structured matrix types. These
help with other cases like infinite arrays.

---------

Co-authored-by: Matt Bauman <mbauman@juliahub.com>
---
 NEWS.md                                 |  1 +
 stdlib/LinearAlgebra/src/bidiag.jl      |  1 +
 stdlib/LinearAlgebra/src/hessenberg.jl  |  1 +
 stdlib/LinearAlgebra/src/symmetric.jl   |  1 +
 stdlib/LinearAlgebra/src/triangular.jl  |  1 +
 stdlib/LinearAlgebra/src/tridiag.jl     |  2 ++
 stdlib/LinearAlgebra/test/bidiag.jl     | 10 ++++++++++
 stdlib/LinearAlgebra/test/hessenberg.jl | 10 ++++++++++
 stdlib/LinearAlgebra/test/symmetric.jl  | 13 ++++++++++++-
 stdlib/LinearAlgebra/test/triangular.jl | 12 ++++++++++++
 stdlib/LinearAlgebra/test/tridiag.jl    | 12 ++++++++++++
 test/testhelpers/SizedArrays.jl         | 10 ++++++++++
 12 files changed, 73 insertions(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index 6dd7335186a08..958c51e3f840f 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -114,6 +114,7 @@ Standard library changes
 * `eigvals/eigen(A, bunchkaufman(B))` and `eigvals/eigen(A, lu(B))`, which utilize the Bunchkaufman (LDL) and LU decomposition of `B`,
    respectively, now efficiently compute the generalized eigenvalues (`eigen`: and eigenvectors) of `A` and `B`. Note: The second
    argument is the output of `bunchkaufman` or `lu` ([#50471]).
+* Structured matrices now retain either the axes of the parent (for `Symmetric`/`Hermitian`/`AbstractTriangular`/`UpperHessenberg`), or that of the principal diagonal (for banded matrices) ([#52480]).
 
 #### Printf
 
diff --git a/stdlib/LinearAlgebra/src/bidiag.jl b/stdlib/LinearAlgebra/src/bidiag.jl
index 78c79b6fcefac..88cc145835df9 100644
--- a/stdlib/LinearAlgebra/src/bidiag.jl
+++ b/stdlib/LinearAlgebra/src/bidiag.jl
@@ -273,6 +273,7 @@ function show(io::IO, M::Bidiagonal)
 end
 
 size(M::Bidiagonal) = (n = length(M.dv); (n, n))
+axes(M::Bidiagonal) = (ax = axes(M.dv, 1); (ax, ax))
 
 #Elementary operations
 for func in (:conj, :copy, :real, :imag)
diff --git a/stdlib/LinearAlgebra/src/hessenberg.jl b/stdlib/LinearAlgebra/src/hessenberg.jl
index 87f7305f0146c..aed8b3c3747a1 100644
--- a/stdlib/LinearAlgebra/src/hessenberg.jl
+++ b/stdlib/LinearAlgebra/src/hessenberg.jl
@@ -56,6 +56,7 @@ UpperHessenberg(A::AbstractMatrix) = UpperHessenberg{eltype(A),typeof(A)}(A)
 Matrix(H::UpperHessenberg{T}) where {T} = Matrix{T}(H)
 Array(H::UpperHessenberg) = Matrix(H)
 size(H::UpperHessenberg) = size(H.data)
+axes(H::UpperHessenberg) = axes(H.data)
 parent(H::UpperHessenberg) = H.data
 
 # similar behaves like UpperTriangular
diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 67ed8afd35c0b..23ea72badcbc5 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -223,6 +223,7 @@ const RealHermSymComplexHerm{T<:Real,S} = Union{Hermitian{T,S}, Symmetric{T,S},
 const RealHermSymComplexSym{T<:Real,S} = Union{Hermitian{T,S}, Symmetric{T,S}, Symmetric{Complex{T},S}}
 
 size(A::HermOrSym) = size(A.data)
+axes(A::HermOrSym) = axes(A.data)
 @inline function Base.isassigned(A::HermOrSym, i::Int, j::Int)
     @boundscheck checkbounds(Bool, A, i, j) || return false
     @inbounds if i == j || ((A.uplo == 'U') == (i < j))
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 8c59c73e7dd21..b18b4f0159a67 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -35,6 +35,7 @@ for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular, :UnitUpperTr
         AbstractMatrix{T}(A::$t{T}) where {T} = copy(A)
 
         size(A::$t) = size(A.data)
+        axes(A::$t) = axes(A.data)
 
         # For A<:AbstractTriangular, similar(A[, neweltype]) should yield a matrix with the same
         # triangular type and underlying storage type as A. The following method covers these cases.
diff --git a/stdlib/LinearAlgebra/src/tridiag.jl b/stdlib/LinearAlgebra/src/tridiag.jl
index da15e1680f53a..ae7373ee79bca 100644
--- a/stdlib/LinearAlgebra/src/tridiag.jl
+++ b/stdlib/LinearAlgebra/src/tridiag.jl
@@ -148,6 +148,7 @@ Matrix(M::SymTridiagonal{T}) where {T} = Matrix{promote_type(T, typeof(zero(T)))
 Array(M::SymTridiagonal) = Matrix(M)
 
 size(A::SymTridiagonal) = (n = length(A.dv); (n, n))
+axes(M::SymTridiagonal) = (ax = axes(M.dv, 1); (ax, ax))
 
 similar(S::SymTridiagonal, ::Type{T}) where {T} = SymTridiagonal(similar(S.dv, T), similar(S.ev, T))
 similar(S::SymTridiagonal, ::Type{T}, dims::Union{Dims{1},Dims{2}}) where {T} = similar(S.dv, T, dims)
@@ -581,6 +582,7 @@ function Tridiagonal{T,V}(A::Tridiagonal) where {T,V<:AbstractVector{T}}
 end
 
 size(M::Tridiagonal) = (n = length(M.d); (n, n))
+axes(M::Tridiagonal) = (ax = axes(M.d,1); (ax, ax))
 
 function Matrix{T}(M::Tridiagonal) where {T}
     A = Matrix{T}(undef, size(M))
diff --git a/stdlib/LinearAlgebra/test/bidiag.jl b/stdlib/LinearAlgebra/test/bidiag.jl
index bf65088dc953b..1c50e1114967e 100644
--- a/stdlib/LinearAlgebra/test/bidiag.jl
+++ b/stdlib/LinearAlgebra/test/bidiag.jl
@@ -19,6 +19,9 @@ using .Main.InfiniteArrays
 isdefined(Main, :FillArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "FillArrays.jl"))
 using .Main.FillArrays
 
+isdefined(Main, :OffsetArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "OffsetArrays.jl"))
+using .Main.OffsetArrays
+
 include("testutils.jl") # test_approx_eq_modphase
 
 n = 10 #Size of test matrix
@@ -851,4 +854,11 @@ end
     end
 end
 
+@testset "custom axes" begin
+    dv, uv = OffsetArray(1:4), OffsetArray(1:3)
+    B = Bidiagonal(dv, uv, :U)
+    ax = axes(dv, 1)
+    @test axes(B) === (ax, ax)
+end
+
 end # module TestBidiagonal
diff --git a/stdlib/LinearAlgebra/test/hessenberg.jl b/stdlib/LinearAlgebra/test/hessenberg.jl
index 105b9f8970ec8..39ae7ec83a5c3 100644
--- a/stdlib/LinearAlgebra/test/hessenberg.jl
+++ b/stdlib/LinearAlgebra/test/hessenberg.jl
@@ -8,6 +8,9 @@ const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
 isdefined(Main, :Furlongs) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "Furlongs.jl"))
 using .Main.Furlongs
 
+isdefined(Main, :SizedArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "SizedArrays.jl"))
+using .Main.SizedArrays
+
 # for tuple tests below
 ≅(x,y) = all(p -> p[1] ≈ p[2], zip(x,y))
 
@@ -240,4 +243,11 @@ using .Main.ImmutableArrays
     @test convert(AbstractMatrix{Float64}, H)::UpperHessenberg{Float64,ImmutableArray{Float64,2,Array{Float64,2}}} == H
 end
 
+@testset "custom axes" begin
+    SZA = SizedArrays.SizedArray{(2,2)}([1 2; 3 4])
+    S = UpperHessenberg(SZA)
+    r = SizedArrays.SOneTo(2)
+    @test axes(S) === (r,r)
+end
+
 end # module TestHessenberg
diff --git a/stdlib/LinearAlgebra/test/symmetric.jl b/stdlib/LinearAlgebra/test/symmetric.jl
index 82236c2a677eb..9d06f2b919481 100644
--- a/stdlib/LinearAlgebra/test/symmetric.jl
+++ b/stdlib/LinearAlgebra/test/symmetric.jl
@@ -9,6 +9,9 @@ const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
 isdefined(Main, :Quaternions) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "Quaternions.jl"))
 using .Main.Quaternions
 
+isdefined(Main, :SizedArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "SizedArrays.jl"))
+using .Main.SizedArrays
+
 Random.seed!(1010)
 
 @testset "Pauli σ-matrices: $σ" for σ in map(Hermitian,
@@ -590,7 +593,6 @@ end
     end
 end
 
-const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
 isdefined(Main, :ImmutableArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "ImmutableArrays.jl"))
 using .Main.ImmutableArrays
 
@@ -900,4 +902,13 @@ end
     end
 end
 
+@testset "custom axes" begin
+    SZA = SizedArrays.SizedArray{(2,2)}([1 2; 3 4])
+    for T in (Symmetric, Hermitian)
+        S = T(SZA)
+        r = SizedArrays.SOneTo(2)
+        @test axes(S) === (r,r)
+    end
+end
+
 end # module TestSymmetric
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index ebff80d3db2ca..74e1028bf109d 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -10,6 +10,9 @@ using LinearAlgebra: BlasFloat, errorbounds, full!, transpose!,
 
 const BASE_TEST_PATH = joinpath(Sys.BINDIR, "..", "share", "julia", "test")
 
+isdefined(Main, :SizedArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "SizedArrays.jl"))
+using .Main.SizedArrays
+
 isdefined(Main, :FillArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "FillArrays.jl"))
 using .Main.FillArrays
 
@@ -876,6 +879,15 @@ end
     end
 end
 
+@testset "custom axes" begin
+    SZA = SizedArrays.SizedArray{(2,2)}([1 2; 3 4])
+    for T in (UpperTriangular, LowerTriangular, UnitUpperTriangular, UnitLowerTriangular)
+        S = T(SZA)
+        r = SizedArrays.SOneTo(2)
+        @test axes(S) === (r,r)
+    end
+end
+
 @testset "arithmetic with an immutable parent" begin
     F = FillArrays.Fill(2, (4,4))
     for UT in (UnitUpperTriangular, UnitLowerTriangular)
diff --git a/stdlib/LinearAlgebra/test/tridiag.jl b/stdlib/LinearAlgebra/test/tridiag.jl
index 0c07e5b160c58..487f808076707 100644
--- a/stdlib/LinearAlgebra/test/tridiag.jl
+++ b/stdlib/LinearAlgebra/test/tridiag.jl
@@ -15,6 +15,9 @@ using .Main.InfiniteArrays
 isdefined(Main, :FillArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "FillArrays.jl"))
 using .Main.FillArrays
 
+isdefined(Main, :OffsetArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "OffsetArrays.jl"))
+using .Main.OffsetArrays
+
 include("testutils.jl") # test_approx_eq_modphase
 
 #Test equivalence of eigenvectors/singular vectors taking into account possible phase (sign) differences
@@ -818,4 +821,13 @@ end
     end
 end
 
+@testset "custom axes" begin
+    dv, uv = OffsetArray(1:4), OffsetArray(1:3)
+    B = Tridiagonal(uv, dv, uv)
+    ax = axes(dv, 1)
+    @test axes(B) === (ax, ax)
+    B = SymTridiagonal(dv, uv)
+    @test axes(B) === (ax, ax)
+end
+
 end # module TestTridiagonal
diff --git a/test/testhelpers/SizedArrays.jl b/test/testhelpers/SizedArrays.jl
index fc2862d844b3f..a4810e297e0f9 100644
--- a/test/testhelpers/SizedArrays.jl
+++ b/test/testhelpers/SizedArrays.jl
@@ -13,6 +13,15 @@ using LinearAlgebra
 
 export SizedArray
 
+struct SOneTo{N} <: AbstractUnitRange{Int} end
+SOneTo(N) = SOneTo{N}()
+Base.length(::SOneTo{N}) where {N} = N
+Base.size(r::SOneTo) = (length(r),)
+Base.axes(r::SOneTo) = (r,)
+Base.first(::SOneTo) = 1
+Base.last(r::SOneTo) = length(r)
+Base.show(io::IO, r::SOneTo) = print(io, "SOneTo(", length(r), ")")
+
 struct SizedArray{SZ,T,N,A<:AbstractArray} <: AbstractArray{T,N}
     data::A
     function SizedArray{SZ}(data::AbstractArray{T,N}) where {SZ,T,N}
@@ -29,6 +38,7 @@ Base.convert(::Type{SizedArray{SZ,T,N,A}}, data::AbstractArray) where {SZ,T,N,A}
 # Minimal AbstractArray interface
 Base.size(a::SizedArray) = size(typeof(a))
 Base.size(::Type{<:SizedArray{SZ}}) where {SZ} = SZ
+Base.axes(a::SizedArray) = map(SOneTo, size(a))
 Base.getindex(A::SizedArray, i...) = getindex(A.data, i...)
 Base.zero(::Type{T}) where T <: SizedArray = SizedArray{size(T)}(zeros(eltype(T), size(T)))
 +(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = SizedArray{SZ}(S1.data + S2.data)

From b4eefd0f8afe91fb8e68c79f1a6615de25005529 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 27 Dec 2023 12:06:08 +0530
Subject: [PATCH 0500/1315] Default uplo in symmetric/hermitian (#52605)

This makes the function signatures match the respective docstrings, as
well as that of `Symmetric/Hermitian`.
---
 stdlib/LinearAlgebra/src/symmetric.jl  |  8 ++++----
 stdlib/LinearAlgebra/test/symmetric.jl | 12 ++++++++++--
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 23ea72badcbc5..d48274855a001 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -73,8 +73,8 @@ If a symmetric view of a matrix is to be constructed of which the elements are n
 matrices nor numbers, an appropriate method of `symmetric` has to be implemented. In that
 case, `symmetric_type` has to be implemented, too.
 """
-symmetric(A::AbstractMatrix, uplo::Symbol) = Symmetric(A, uplo)
-symmetric(A::Number, ::Symbol) = A
+symmetric(A::AbstractMatrix, uplo::Symbol=:U) = Symmetric(A, uplo)
+symmetric(A::Number, ::Symbol=:U) = A
 
 """
     symmetric_type(T::Type)
@@ -164,8 +164,8 @@ If a hermitian view of a matrix is to be constructed of which the elements are n
 matrices nor numbers, an appropriate method of `hermitian` has to be implemented. In that
 case, `hermitian_type` has to be implemented, too.
 """
-hermitian(A::AbstractMatrix, uplo::Symbol) = Hermitian(A, uplo)
-hermitian(A::Number, ::Symbol) = convert(typeof(A), real(A))
+hermitian(A::AbstractMatrix, uplo::Symbol=:U) = Hermitian(A, uplo)
+hermitian(A::Number, ::Symbol=:U) = convert(typeof(A), real(A))
 
 """
     hermitian_type(T::Type)
diff --git a/stdlib/LinearAlgebra/test/symmetric.jl b/stdlib/LinearAlgebra/test/symmetric.jl
index 9d06f2b919481..f7caed17414d9 100644
--- a/stdlib/LinearAlgebra/test/symmetric.jl
+++ b/stdlib/LinearAlgebra/test/symmetric.jl
@@ -729,9 +729,9 @@ end
 end
 
 @testset "symmetric()/hermitian() for Numbers" begin
-    @test LinearAlgebra.symmetric(1, :U) == 1
+    @test LinearAlgebra.symmetric(1) == LinearAlgebra.symmetric(1, :U) == 1
     @test LinearAlgebra.symmetric_type(Int) == Int
-    @test LinearAlgebra.hermitian(1, :U) == 1
+    @test LinearAlgebra.hermitian(1) == LinearAlgebra.hermitian(1, :U) == 1
     @test LinearAlgebra.hermitian_type(Int) == Int
 end
 
@@ -902,6 +902,14 @@ end
     end
 end
 
+@testset "symmetric/hermitian for matrices" begin
+    A = [1 2; 3 4]
+    @test LinearAlgebra.symmetric(A) === Symmetric(A)
+    @test LinearAlgebra.symmetric(A, :L) === Symmetric(A, :L)
+    @test LinearAlgebra.hermitian(A) === Hermitian(A)
+    @test LinearAlgebra.hermitian(A, :L) === Hermitian(A, :L)
+end
+
 @testset "custom axes" begin
     SZA = SizedArrays.SizedArray{(2,2)}([1 2; 3 4])
     for T in (Symmetric, Hermitian)

From 66e941073f400b92a6d8cf4d6bce5a6cb2d00b6c Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 27 Dec 2023 12:06:28 +0530
Subject: [PATCH 0501/1315] Add a fully typed Diagonal constructor from
 `AbstractMatrix`es (#52487)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The following works after this PR:
```julia
julia> oftype(Diagonal(Float32[1,2]), [1 0; 0 2])
2×2 Diagonal{Float32, Vector{Float32}}:
 1.0   ⋅
  ⋅   2.0
```
This changes the behavior of the constructor to copy the diagonal, so
now
```julia
julia> D = Diagonal([1,2]);

julia> typeof(D)(D).diag === D.diag
false
```
whereas this used to be `true` previously. This probably doesn't matter
much, as in most non-trivial cases it'd be copied anyway, and this
conversion is unusual in the trivial case.

---------

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 stdlib/LinearAlgebra/src/diagonal.jl  | 2 +-
 stdlib/LinearAlgebra/test/diagonal.jl | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index bd2958d1b222b..e8638d3d7ff12 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -10,7 +10,6 @@ struct Diagonal{T,V<:AbstractVector{T}} <: AbstractMatrix{T}
         new{T,V}(diag)
     end
 end
-Diagonal{T,V}(d::Diagonal) where {T,V<:AbstractVector{T}} = Diagonal{T,V}(d.diag)
 Diagonal(v::AbstractVector{T}) where {T} = Diagonal{T,typeof(v)}(v)
 Diagonal{T}(v::AbstractVector) where {T} = Diagonal(convert(AbstractVector{T}, v)::AbstractVector{T})
 
@@ -102,6 +101,7 @@ julia> Diagonal(A)
 """
 Diagonal(A::AbstractMatrix) = Diagonal(diag(A))
 Diagonal{T}(A::AbstractMatrix) where T = Diagonal{T}(diag(A))
+Diagonal{T,V}(A::AbstractMatrix) where {T,V<:AbstractVector{T}} = Diagonal{T,V}(diag(A))
 function convert(::Type{T}, A::AbstractMatrix) where T<:Diagonal
     checksquare(A)
     isdiag(A) ? T(A) : throw(InexactError(:convert, T, A))
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 3de868a847b7c..9db7d8071931c 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -50,6 +50,13 @@ Random.seed!(1)
         DI = Diagonal([1,2,3,4])
         @test Diagonal(DI) === DI
         @test isa(Diagonal{elty}(DI), Diagonal{elty})
+
+        # diagonal matrices may be converted to Diagonal
+        local A = [1 0; 0 2]
+        local DA = convert(Diagonal{Float32,Vector{Float32}}, A)
+        @test DA isa Diagonal{Float32,Vector{Float32}}
+        @test DA == A
+
         # issue #26178
         @test_throws MethodError convert(Diagonal, [1,2,3,4])
         @test_throws DimensionMismatch convert(Diagonal, [1 2 3 4])

From e7e8b8900d471f38f90d7150c5123c503aa1ac36 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Wed, 27 Dec 2023 15:59:53 -0300
Subject: [PATCH 0502/1315] update --gcthreads section in command line options
 (#52645)

Make these consistent with what's shown by `julia --help`.

Fixes https://github.com/JuliaLang/www.julialang.org/issues/1997.
---
 doc/man/julia.1                          | 6 +++---
 doc/src/manual/command-line-interface.md | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/man/julia.1 b/doc/man/julia.1
index b0af07539cb41..ee0f973c259fd 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -123,9 +123,9 @@ process affinity is not configured, it uses the number of CPU
 threads.
 
 .TP
---gcthreads <n>
-Enable n GC threads; If unspecified is set to half of the
-compute worker threads.
+--gcthreads=N[,M]
+Use N threads for the mark phase of GC and M (0 or 1) threads for the concurrent sweeping phase of GC.
+N is set to half of the number of compute threads and M is set to 0 if unspecified.
 
 .TP
 -p, --procs {N|auto}
diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index c69d221a80f2e..be442e456c2e0 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -174,7 +174,7 @@ The following is a complete list of command-line switches available when launchi
 |`-E`, `--print <expr>`                 |Evaluate `<expr>` and display the result|
 |`-L`, `--load <file>`                  |Load `<file>` immediately on all processors|
 |`-t`, `--threads {N\|auto}`            |Enable N threads; `auto` tries to infer a useful default number of threads to use but the exact behavior might change in the future.  Currently, `auto` uses the number of CPUs assigned to this julia process based on the OS-specific affinity assignment interface, if supported (Linux and Windows). If this is not supported (macOS) or process affinity is not configured, it uses the number of CPU threads.|
-| `--gcthreads {N}`                     |Enable N GC threads; If unspecified is set to half of the compute worker threads.|
+| `--gcthreads=N[,M]`                   |Use N threads for the mark phase of GC and M (0 or 1) threads for the concurrent sweeping phase of GC. N is set to half of the number of compute threads and M is set to 0 if unspecified.|
 |`-p`, `--procs {N\|auto}`              |Integer value N launches N additional local worker processes; `auto` launches as many workers as the number of local CPU threads (logical cores)|
 |`--machine-file <file>`                |Run processes on hosts listed in `<file>`|
 |`-i`                                   |Interactive mode; REPL runs and `isinteractive()` is true|

From e6e572eb2c316734a7db08e87a060b137d0fe410 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 28 Dec 2023 07:50:02 +0600
Subject: [PATCH 0503/1315] Temporarily remove failing sorting tests (#52643)

Tracked by issue #52642
---
 test/sorting.jl | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/test/sorting.jl b/test/sorting.jl
index 621c82ae7e7fe..35635d8588f93 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -1061,14 +1061,15 @@ end
     # it would be too much trouble to actually construct a valid pathological input, so we
     # construct an invalid pathological input.
     # This test is kind of sketchy because it passes invalid inputs to the function
-    for i in [1:6, 1:483, 1:957, 77:86, 118:478, 223:227, 231:970, 317:958, 500:501, 500:501, 500:501, 614:620, 632:635, 658:665, 933:940, 937:942, 997:1000, 999:1000]
-        x = rand(1:5, 1000)
-        @test partialsort(x, i, lt=(<=)) == sort(x)[i]
-    end
-    for i in [1, 7, 8, 490, 495, 852, 993, 996, 1000]
-        x = rand(1:5, 1000)
-        @test partialsort(x, i, lt=(<=)) == sort(x)[i]
-    end
+    # Temporarily removed due to flakey test failures. See #52642 for details.
+    # for i in [1:6, 1:483, 1:957, 77:86, 118:478, 223:227, 231:970, 317:958, 500:501, 500:501, 500:501, 614:620, 632:635, 658:665, 933:940, 937:942, 997:1000, 999:1000]
+    #     x = rand(1:5, 1000)
+    #     @test partialsort(x, i, lt=(<=)) == sort(x)[i]
+    # end
+    # for i in [1, 7, 8, 490, 495, 852, 993, 996, 1000]
+    #     x = rand(1:5, 1000)
+    #     @test partialsort(x, i, lt=(<=)) == sort(x)[i]
+    # end
 end
 
 # This testset is at the end of the file because it is slow.

From 26d04607c14615631e56973cd30b4fd04d3f4af8 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 28 Dec 2023 02:52:18 -0500
Subject: [PATCH 0504/1315] Show more info on why package precompilation was
 needed (#52619)

---
 base/loading.jl | 53 +++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 42 insertions(+), 11 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 81778d41893c0..1519375099634 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1633,11 +1633,11 @@ end
 
 # returns `nothing` if require found a precompile cache for this sourcepath, but couldn't load it
 # returns the set of modules restored if the cache load succeeded
-@constprop :none function _require_search_from_serialized(pkg::PkgId, sourcepath::String, build_id::UInt128)
+@constprop :none function _require_search_from_serialized(pkg::PkgId, sourcepath::String, build_id::UInt128; reasons=nothing)
     assert_havelock(require_lock)
     paths = find_all_in_cache_path(pkg)
     for path_to_try in paths::Vector{String}
-        staledeps = stale_cachefile(pkg, build_id, sourcepath, path_to_try)
+        staledeps = stale_cachefile(pkg, build_id, sourcepath, path_to_try; reasons)
         if staledeps === true
             continue
         end
@@ -2126,11 +2126,11 @@ function _require(pkg::PkgId, env=nothing)
         set_pkgorigin_version_path(pkg, path)
 
         pkg_precompile_attempted = false # being safe to avoid getting stuck in a Pkg.precompile loop
-
+        reasons = Dict{String,Int}()
         # attempt to load the module file via the precompile cache locations
         if JLOptions().use_compiled_modules != 0
             @label load_from_cache
-            m = _require_search_from_serialized(pkg, path, UInt128(0))
+            m = _require_search_from_serialized(pkg, path, UInt128(0); reasons)
             if m isa Module
                 return m
             end
@@ -2166,7 +2166,7 @@ function _require(pkg::PkgId, env=nothing)
                     # double-check now that we have lock
                     m = _require_search_from_serialized(pkg, path, UInt128(0))
                     m isa Module && return m
-                    compilecache(pkg, path)
+                    compilecache(pkg, path; reasons)
                 end
                 cachefile_or_module isa Module && return cachefile_or_module::Module
                 cachefile = cachefile_or_module
@@ -2568,17 +2568,17 @@ This can be used to reduce package load times. Cache files are stored in
 `DEPOT_PATH[1]/compiled`. See [Module initialization and precompilation](@ref)
 for important notes.
 """
-function compilecache(pkg::PkgId, internal_stderr::IO = stderr, internal_stdout::IO = stdout)
+function compilecache(pkg::PkgId, internal_stderr::IO = stderr, internal_stdout::IO = stdout; reasons::Union{Dict{String,Int},Nothing}=nothing)
     @nospecialize internal_stderr internal_stdout
     path = locate_package(pkg)
     path === nothing && throw(ArgumentError("$pkg not found during precompilation"))
-    return compilecache(pkg, path, internal_stderr, internal_stdout)
+    return compilecache(pkg, path, internal_stderr, internal_stdout; reasons)
 end
 
 const MAX_NUM_PRECOMPILE_FILES = Ref(10)
 
 function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, internal_stdout::IO = stdout,
-                      keep_loaded_modules::Bool = true)
+                      keep_loaded_modules::Bool = true; reasons::Union{Dict{String,Int},Nothing}=nothing)
 
     @nospecialize internal_stderr internal_stdout
     # decide where to put the resulting cache file
@@ -2595,7 +2595,7 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
     end
     # run the expression and cache the result
     verbosity = isinteractive() ? CoreLogging.Info : CoreLogging.Debug
-    @logmsg verbosity "Precompiling $pkg"
+    @logmsg verbosity "Precompiling $pkg $(list_reasons(reasons))"
 
     # create a temporary file in `cachepath` directory, write the cache in it,
     # write the checksum, _and then_ atomically move the file to `cachefile`.
@@ -3311,17 +3311,29 @@ function maybe_cachefile_lock(f, pkg::PkgId, srcpath::String; stale_age=compilec
         f()
     end
 end
+
+function record_reason(reasons::Dict{String,Int}, reason::String)
+    reasons[reason] = get(reasons, reason, 0) + 1
+end
+record_reason(::Nothing, ::String) = nothing
+function list_reasons(reasons::Dict{String,Int})
+    isempty(reasons) && return ""
+    return "(cache misses: $(join(("$k ($v)" for (k,v) in reasons), ", ")))"
+end
+
 # returns true if it "cachefile.ji" is stale relative to "modpath.jl" and build_id for modkey
 # otherwise returns the list of dependencies to also check
-@constprop :none function stale_cachefile(modpath::String, cachefile::String; ignore_loaded::Bool = false)
+@constprop :none function stale_cachefile(modpath::String, cachefile::String; ignore_loaded::Bool = false, reasons=nothing)
     return stale_cachefile(PkgId(""), UInt128(0), modpath, cachefile; ignore_loaded)
 end
-@constprop :none function stale_cachefile(modkey::PkgId, build_id::UInt128, modpath::String, cachefile::String; ignore_loaded::Bool = false)
+@constprop :none function stale_cachefile(modkey::PkgId, build_id::UInt128, modpath::String, cachefile::String;
+                                            ignore_loaded::Bool = false, reasons::Union{Dict{String,Int},Nothing}=nothing)
     io = open(cachefile, "r")
     try
         checksum = isvalid_cache_header(io)
         if iszero(checksum)
             @debug "Rejecting cache file $cachefile due to it containing an invalid cache header"
+            record_reason(reasons, "invalid header")
             return true # invalid cache file
         end
         modules, (includes, _, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags = parse_cache_header(io, cachefile)
@@ -3334,6 +3346,7 @@ end
               current session: $(CacheFlags())
               cache file:      $(CacheFlags(flags))
             """
+            record_reason(reasons, "mismatched flags")
             return true
         end
         pkgimage = !isempty(clone_targets)
@@ -3342,6 +3355,7 @@ end
             if JLOptions().use_pkgimages == 0
                 # presence of clone_targets means native code cache
                 @debug "Rejecting cache file $cachefile for $modkey since it would require usage of pkgimage"
+                record_reason(reasons, "requires pkgimages")
                 return true
             end
             rejection_reasons = check_clone_targets(clone_targets)
@@ -3350,10 +3364,12 @@ end
                     Reasons=rejection_reasons,
                     var"Image Targets"=parse_image_targets(clone_targets),
                     var"Current Targets"=current_image_targets())
+                record_reason(reasons, "target mismatch")
                 return true
             end
             if !isfile(ocachefile)
                 @debug "Rejecting cache file $cachefile for $modkey since pkgimage $ocachefile was not found"
+                record_reason(reasons, "missing ocachefile")
                 return true
             end
         else
@@ -3362,12 +3378,14 @@ end
         id = first(modules)
         if id.first != modkey && modkey != PkgId("")
             @debug "Rejecting cache file $cachefile for $modkey since it is for $id instead"
+            record_reason(reasons, "for different pkgid")
             return true
         end
         if build_id != UInt128(0)
             id_build = (UInt128(checksum) << 64) | id.second
             if id_build != build_id
                 @debug "Ignoring cache file $cachefile for $modkey ($((UUID(id_build)))) since it does not provide desired build_id ($((UUID(build_id))))"
+                record_reason(reasons, "for different buildid")
                 return true
             end
         end
@@ -3389,6 +3407,7 @@ end
                     @goto locate_branch
                 else
                     @debug "Rejecting cache file $cachefile because module $req_key is already loaded and incompatible."
+                    record_reason(reasons, req_key == PkgId(Core) ? "wrong julia version" : "wrong dep version loaded")
                     return true # Won't be able to fulfill dependency
                 end
             else
@@ -3396,6 +3415,7 @@ end
                 path = locate_package(req_key)
                 if path === nothing
                     @debug "Rejecting cache file $cachefile because dependency $req_key not found."
+                    record_reason(reasons, "dep missing source")
                     return true # Won't be able to fulfill dependency
                 end
                 depmods[i] = (path, req_key, req_build_id)
@@ -3415,6 +3435,7 @@ end
                     break
                 end
                 @debug "Rejecting cache file $cachefile because it provides the wrong build_id (got $((UUID(build_id)))) for $req_key (want $(UUID(req_build_id)))"
+                record_reason(reasons, "wrong dep buildid")
                 return true # cachefile doesn't provide the required version of the dependency
             end
         end
@@ -3423,6 +3444,7 @@ end
         if !skip_check
             if !samefile(includes[1].filename, modpath) && !samefile(fixup_stdlib_path(includes[1].filename), modpath)
                 @debug "Rejecting cache file $cachefile because it is for file $(includes[1].filename) not file $modpath"
+                record_reason(reasons, "wrong source")
                 return true # cache file was compiled from a different path
             end
             for (modkey, req_modkey) in requires
@@ -3430,6 +3452,7 @@ end
                 pkg = identify_package(modkey, req_modkey.name)
                 if pkg != req_modkey
                     @debug "Rejecting cache file $cachefile because uuid mapping for $modkey => $req_modkey has changed, expected $modkey => $pkg"
+                    record_reason(reasons, "dep uuid changed")
                     return true
                 end
             end
@@ -3437,6 +3460,7 @@ end
                 f, fsize_req, hash_req, ftime_req = chi.filename, chi.fsize, chi.hash, chi.mtime
                 if startswith(f, "@depot/")
                     @debug("Rejecting stale cache file $cachefile because its depot could not be resolved")
+                    record_reason(reasons, "nonresolveable depot")
                     return true
                 end
                 if !ispath(f)
@@ -3445,6 +3469,7 @@ end
                         continue
                     end
                     @debug "Rejecting stale cache file $cachefile because file $f does not exist"
+                    record_reason(reasons, "missing sourcefile")
                     return true
                 end
                 if ftime_req >= 0.0
@@ -3458,17 +3483,20 @@ end
                                !( 0 < (ftime_req - ftime) < 1e-6 )        # PR #45552: Compensate for Windows tar giving mtimes that may be incorrect by up to one microsecond
                     if is_stale
                         @debug "Rejecting stale cache file $cachefile because mtime of include_dependency $f has changed (mtime $ftime, before $ftime_req)"
+                        record_reason(reasons, "include_dependency mtime change")
                         return true
                     end
                 else
                     fsize = filesize(f)
                     if fsize != fsize_req
                         @debug "Rejecting stale cache file $cachefile because file size of $f has changed (file size $fsize, before $fsize_req)"
+                        record_reason(reasons, "include_dependency fsize change")
                         return true
                     end
                     hash = open(_crc32c, f, "r")
                     if hash != hash_req
                         @debug "Rejecting stale cache file $cachefile because hash of $f has changed (hash $hash, before $hash_req)"
+                        record_reason(reasons, "include_dependency fhash change")
                         return true
                     end
                 end
@@ -3477,12 +3505,14 @@ end
 
         if !isvalid_file_crc(io)
             @debug "Rejecting cache file $cachefile because it has an invalid checksum"
+            record_reason(reasons, "invalid checksum")
             return true
         end
 
         if pkgimage
             if !isvalid_pkgimage_crc(io, ocachefile::String)
                 @debug "Rejecting cache file $cachefile because $ocachefile has an invalid checksum"
+                record_reason(reasons, "ocachefile invalid checksum")
                 return true
             end
         end
@@ -3490,6 +3520,7 @@ end
         curr_prefs_hash = get_preferences_hash(id.uuid, prefs)
         if prefs_hash != curr_prefs_hash
             @debug "Rejecting cache file $cachefile because preferences hash does not match 0x$(string(prefs_hash, base=16)) != 0x$(string(curr_prefs_hash, base=16))"
+            record_reason(reasons, "preferences hash mismatch")
             return true
         end
 

From e96c13aa5b2e2b41e618ac009d43e1fdea0a70d4 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 28 Dec 2023 07:42:28 -0500
Subject: [PATCH 0505/1315] update nthreads info in versioninfo (#52423)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes https://github.com/JuliaLang/julia/issues/52404
@nilshg I opted to make it one line as it fits.
```
julia> versioninfo()
Julia Version 1.11.0-DEV.1011
Commit bb7091c6f2* (2023-12-04 14:58 UTC)
Platform Info:
  OS: macOS (arm64-apple-darwin23.0.0)
  CPU: 10 × Apple M2 Pro
  WORD_SIZE: 64
  LLVM: libLLVM-15.0.7 (ORCJIT, apple-m1)
  Threads: 1 default, 0 interactive, 1 GC (on 6 virtual cores)
Environment:
  JULIA_EDITOR = code
```
---
 stdlib/InteractiveUtils/src/InteractiveUtils.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stdlib/InteractiveUtils/src/InteractiveUtils.jl b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
index 629cf88cd8ce6..9927af1a4db9a 100644
--- a/stdlib/InteractiveUtils/src/InteractiveUtils.jl
+++ b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
@@ -160,7 +160,8 @@ function versioninfo(io::IO=stdout; verbose::Bool=false)
     end
     println(io, "  WORD_SIZE: ", Sys.WORD_SIZE)
     println(io, "  LLVM: libLLVM-",Base.libllvm_version," (", Sys.JIT, ", ", Sys.CPU_NAME, ")")
-    println(io, "  Threads: ", Threads.maxthreadid(), " on ", Sys.CPU_THREADS, " virtual cores")
+    println(io, """Threads: $(Threads.nthreads(:default)) default, $(Threads.nthreads(:interactive)) interactive, \
+      $(Threads.ngcthreads()) GC (on $(Sys.CPU_THREADS) virtual cores)""")
 
     function is_nonverbose_env(k::String)
         return occursin(r"^JULIA_|^DYLD_|^LD_", k)

From 90ae544fb57acdebd5b6ecd592ebd68c3ee629ed Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Thu, 28 Dec 2023 14:18:07 -0500
Subject: [PATCH 0506/1315] fix typo in NEWS (#52652)

Typo from #52461.
---
 NEWS.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 958c51e3f840f..d5ef405b7a913 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -84,9 +84,9 @@ New library features
   write the output to a stream rather than returning a string ([#48625]).
 * `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
 * New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
-* Passing an IOBuffer as a stdout argument for Process spawn now works as
+* Passing an `IOBuffer` as a stdout argument for `Process` spawn now works as
   expected, synchronized with `wait` or `success`, so a `Base.BufferStream` is
-  no longer required there for correctness to avoid data-races ([#TBD]).
+  no longer required there for correctness to avoid data races ([#52461]).
 * After a process exits, `closewrite` will no longer be automatically called on
   the stream passed to it. Call `wait` on the process instead to ensure the
   content is fully written, then call `closewrite` manually to avoid

From ad3769e86d8657ea5cbb566c8826f7c0dbf10696 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Thu, 28 Dec 2023 22:50:59 +0100
Subject: [PATCH 0507/1315] `Base`: make `Tuple(::Pair)` type-stable (#52650)

Fixes #52636
---
 base/tuple.jl | 1 +
 test/tuple.jl | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/base/tuple.jl b/base/tuple.jl
index 2e1c5972c407d..19b88234cbb00 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -417,6 +417,7 @@ _totuple(::Type{Tuple}, itr, s...) = (collect(Iterators.rest(itr,s...))...,)
 _totuple(::Type{Tuple}, itr::Array) = (itr...,)
 _totuple(::Type{Tuple}, itr::SimpleVector) = (itr...,)
 _totuple(::Type{Tuple}, itr::NamedTuple) = (itr...,)
+_totuple(::Type{Tuple}, p::Pair) = (p.first, p.second)
 _totuple(::Type{Tuple}, x::Number) = (x,) # to make Tuple(x) inferable
 
 end
diff --git a/test/tuple.jl b/test/tuple.jl
index b806667fd9d0a..3a8fb51051737 100644
--- a/test/tuple.jl
+++ b/test/tuple.jl
@@ -807,3 +807,9 @@ namedtup = (;a=1, b=2, c=3)
 @test Val{Tuple{Vararg{T,4}} where T} === Val{Tuple{T,T,T,T} where T}
 @test Val{Tuple{Int64, Vararg{Int32,N}} where N} === Val{Tuple{Int64, Vararg{Int32}}}
 @test Val{Tuple{Int32, Vararg{Int64}}} === Val{Tuple{Int32, Vararg{Int64,N}} where N}
+
+@testset "from Pair, issue #52636" begin
+    pair = (1 => "2")
+    @test (1, "2") == @inferred Tuple(pair)
+    @test (1, "2") == @inferred Tuple{Int,String}(pair)
+end

From e8f89682d7b434f1159626a213756b3691f48d03 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Fri, 29 Dec 2023 11:03:19 +0530
Subject: [PATCH 0508/1315] Added Tests for Permute function in
 combinatorics.jl (#52648)

Signed-off-by: happy <happy@Ubunutt.myguest.virtualbox.org>
Co-authored-by: happy <happy@Ubunutt.myguest.virtualbox.org>
---
 test/combinatorics.jl | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/test/combinatorics.jl b/test/combinatorics.jl
index 25a444b70ec36..862e3bfa37e1e 100644
--- a/test/combinatorics.jl
+++ b/test/combinatorics.jl
@@ -129,3 +129,24 @@ end
         end
     end
 end
+
+@testset "permute!" begin
+    #simple array
+    @test permute!([1,2,3,4,5],[3,2,1,5,4]) == [3,2,1,5,4]
+    #empty array
+    @test permute!([],[]) == []
+    #single-element array
+    @test permute!([5],[1]) == [5]
+    #repeated elements in array
+    @test permute!([1,2,2,3,3,3],[2,1,3,5,4,6]) == [2,1,2,3,3,3]
+    #permutation vector contains zero
+    @test_throws BoundsError permute!([1,2,3],[0,1,2])
+    #permutation vector contains negative indices
+    @test_throws BoundsError permute!([1,2,3],[2,-1,1])
+    #permutation vector contains indices larger than array size
+    @test_throws BoundsError permute!([1,2,3],[2,4,1])
+    #permutation vector is empty
+    @test_throws DimensionMismatch permute!([1,2,3],[])
+    #array is empty
+    @test_throws BoundsError permute!([],[2,1])
+end

From 2b2f5344138f2b50ee91132592733743f33c5358 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 29 Dec 2023 20:37:46 -0300
Subject: [PATCH 0509/1315] minor fix in malloc terminology used in docs
 (#52665)

---
 doc/src/manual/performance-tips.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/performance-tips.md b/doc/src/manual/performance-tips.md
index 68ee5132f8592..579413e808f7b 100644
--- a/doc/src/manual/performance-tips.md
+++ b/doc/src/manual/performance-tips.md
@@ -94,8 +94,8 @@ a vector of 64-bit floats so there should be no need to allocate (heap) memory.
 
 We should clarify that what `@time` reports is specifically *heap* allocations, which are typically needed for either
 mutable objects or for creating/growing variable-sized containers (such as `Array` or `Dict`, strings, or "type-unstable"
-objects whose type is only known at runtime).  Allocating (or deallocating) such blocks of memory may require an expensive
-system call (e.g. via `malloc` in C), and they must be tracked for garbage collection.  In contrast, immutable values like
+objects whose type is only known at runtime).  Allocating (or deallocating) such blocks of memory may require an expensive function
+call to libc (e.g. via `malloc` in C), and they must be tracked for garbage collection.  In contrast, immutable values like
 numbers (except bignums), tuples, and immutable `struct`s can be stored much more cheaply, e.g. in stack or CPU-register
 memory, so one doesn’t typically worry about the performance cost of "allocating" them.
 

From 3f4cfc6d19bfe684223c3f27771d1839eafe6aa7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 30 Dec 2023 10:04:07 +0100
Subject: [PATCH 0510/1315] [dSFMT_jll] Upgrade to v2.2.5 (#52667)

Usual memo to self:

* update version number in `stdlib/dSFMT_jll/Project.toml`
* refresh checksums with `make -f contrib/refresh_checksums.mk -j dsfmt`
* update version number in `deps/checksums/dsfmt`
---
 deps/checksums/dsfmt          | 68 +++++++++++++++++------------------
 deps/dsfmt.version            |  4 ++-
 stdlib/dSFMT_jll/Project.toml |  2 +-
 3 files changed, 38 insertions(+), 36 deletions(-)

diff --git a/deps/checksums/dsfmt b/deps/checksums/dsfmt
index 63c7e26f0eb43..0666e51efa994 100644
--- a/deps/checksums/dsfmt
+++ b/deps/checksums/dsfmt
@@ -1,34 +1,34 @@
-dSFMT.v2.2.4+4.aarch64-apple-darwin.tar.gz/md5/43b52709b7794c92931286174854c886
-dSFMT.v2.2.4+4.aarch64-apple-darwin.tar.gz/sha512/018b67a06cdf42dda2a906025e8a12e026af9b39fe8281890dc90d66a422c3af2a8430d42677f79d123fd0ab0e8d5c37db2e0a00ef03731d35cbb65f9e59b108
-dSFMT.v2.2.4+4.aarch64-linux-gnu.tar.gz/md5/260e14855dbc7773a2ca906d58cc57f2
-dSFMT.v2.2.4+4.aarch64-linux-gnu.tar.gz/sha512/820ca4c6afde931e855b74015150f4ffbb513276c3fa7dbcc1ec8d34c02d4989fb7424a6e4f81f93d054811b5f54f8633d955b05acdb088387ee90f1c3b00915
-dSFMT.v2.2.4+4.aarch64-linux-musl.tar.gz/md5/7ddccbad6b5c9de4be187fe76637a0d8
-dSFMT.v2.2.4+4.aarch64-linux-musl.tar.gz/sha512/e3c225da00927096e3a6cd4abc681fba8f469cb74828e7054d4f5684d71dcb8e75c9a81f14fa10bfbb78f62f9567a31a92edcca8d797e5810a2a44a3fc17bc84
-dSFMT.v2.2.4+4.armv6l-linux-gnueabihf.tar.gz/md5/a70329e0a6c57009c6b6950fd34089f6
-dSFMT.v2.2.4+4.armv6l-linux-gnueabihf.tar.gz/sha512/4418c42165660adc050e872ef834f920c89ed6a0d2b816821672b1e862e947aad7efd023289da9bf05bb2eb9ec4b9d2561c403e2d5384d5314a4ba016b1f9cfc
-dSFMT.v2.2.4+4.armv6l-linux-musleabihf.tar.gz/md5/6ffc798b8a0c847fa5cb93640bd66ab3
-dSFMT.v2.2.4+4.armv6l-linux-musleabihf.tar.gz/sha512/94e5ae07d0b1420abd7290519bce6f77deae634bbb4df31e3f02416bf509e555a9b1c9d19dd77ca76a308c2b86d5c9d4718b9ef83c13167b88a8181d8ca7e73a
-dSFMT.v2.2.4+4.armv7l-linux-gnueabihf.tar.gz/md5/660d95aa08580ca1716a89c4d8b1eb24
-dSFMT.v2.2.4+4.armv7l-linux-gnueabihf.tar.gz/sha512/bc757a9f805047be5375f92c10a3f3eab69345a4ec5cc997f763e66be36144a74d414ff926df8e17b9d5a2394189269c3188c55e0b7c75a72495394d65510cef
-dSFMT.v2.2.4+4.armv7l-linux-musleabihf.tar.gz/md5/78c487049092fe61949d506637c713bb
-dSFMT.v2.2.4+4.armv7l-linux-musleabihf.tar.gz/sha512/03ddada4478f05eab7d2971b2deaf2cba91f084d7ce66fc8219bcb3cf5c308ea13959fed95568ca80f4ce11794e197092984919265716de8f2558e2cb30d94ce
-dSFMT.v2.2.4+4.i686-linux-gnu.tar.gz/md5/b0f535336cca76f1dcdacca29c6f8410
-dSFMT.v2.2.4+4.i686-linux-gnu.tar.gz/sha512/cc03a246b32875037a41a45c1004834abc7c67f90bf17e1b41cc604ee9893147b1ca3978a2e103b94c94ac617380570473de1f66bff15de8e4ee05c5a3c21059
-dSFMT.v2.2.4+4.i686-linux-musl.tar.gz/md5/a61405f72c9a3bba5718f078c68e61a5
-dSFMT.v2.2.4+4.i686-linux-musl.tar.gz/sha512/726f130bbbfd0dece4185b89a25a73f3b5b950ebfb7f86aea6e9cbcf9ae932e591d20b854de0b4985103dbf8b4b7cb3560661c5070af971cd2c1f3ec3e1ea7d2
-dSFMT.v2.2.4+4.i686-w64-mingw32.tar.gz/md5/93670f43a98f7c6045427dc9ddd89a4a
-dSFMT.v2.2.4+4.i686-w64-mingw32.tar.gz/sha512/b76c2be073312ffec8c778b83d3e37b5d0c5dba770ffcc95a6ebfba516a948beb08419428192fcd5dda83357a64e90c4e3a40144688f128133400284a7363b8e
-dSFMT.v2.2.4+4.powerpc64le-linux-gnu.tar.gz/md5/fd8c73961ef7c82201e6d86e8bf4324c
-dSFMT.v2.2.4+4.powerpc64le-linux-gnu.tar.gz/sha512/1bd0ebd019cfc6f25f7ba007547c5ee297854655b93c55e90d8ead420875de5a087e38956693d5e901ff2abf667c72aa66fb34f587b82adf4b91b3d5d666b5c7
-dSFMT.v2.2.4+4.x86_64-apple-darwin.tar.gz/md5/b57ec1491ffdd40c72860b9f1869160c
-dSFMT.v2.2.4+4.x86_64-apple-darwin.tar.gz/sha512/c3a192dbcd3e768712d12d3ac851f46bfa1517eca16c9a187025553076c8fb886b925e4e3f5f20531180f72b73e7eaa5281f54d5b7d4e6a4d53f4542c4bb33b6
-dSFMT.v2.2.4+4.x86_64-linux-gnu.tar.gz/md5/fa671f4ca14b171d53c8866d03f9162a
-dSFMT.v2.2.4+4.x86_64-linux-gnu.tar.gz/sha512/2e242a1448da0508ea88cc1a106f1e74f8d7e7562cd82b80d86abf9a8b454653ad7612e25c30ce00c23757e8a5b7b5736253b00a52f9473af6c5d4df768138f2
-dSFMT.v2.2.4+4.x86_64-linux-musl.tar.gz/md5/c648294163882ec539ab646542c74880
-dSFMT.v2.2.4+4.x86_64-linux-musl.tar.gz/sha512/9e96a47d660854b6517364f0db40a2f4e0e3b814499a0349f7cf550b1c8d04589fca5eb4a75bf34f36d1b5d1b2277b3e9a961c887092abedd08f438e025329e7
-dSFMT.v2.2.4+4.x86_64-unknown-freebsd.tar.gz/md5/b4497d34d72ce134ce110b6185a82393
-dSFMT.v2.2.4+4.x86_64-unknown-freebsd.tar.gz/sha512/23d0fb273edbb5a08920a3683398e11d6f4df137dabcfc5f395a9175ddf14ab8999eb961ae8f4b76715a5a2dd2b77757f752abce35c1f752b800201e93aae874
-dSFMT.v2.2.4+4.x86_64-w64-mingw32.tar.gz/md5/d380963292bc54d27d39a3f94adbd5ac
-dSFMT.v2.2.4+4.x86_64-w64-mingw32.tar.gz/sha512/ef2f99b17b1a36e61fb4d149d8a8fccc9e804b3b727f2426fca917c265c2d7ada4e3abaa5383e25136dec8de262c1d11970a01d7cfb513a55f1d86a23534e864
-dsfmt-2.2.4.tar.gz/md5/ed30e63552d62df48d709dde4f755660
-dsfmt-2.2.4.tar.gz/sha512/fe84e986cbf198172340adfac0436b08f087643eca3f1ceccacde146cbfd8c41e3eb0dfbb062f7ca5f462db13c386abd7c269bc0cbefc9a0ecf97a8a8870a2e4
+dSFMT.v2.2.5+0.aarch64-apple-darwin.tar.gz/md5/36284767f523bb297633d7da17a7db5a
+dSFMT.v2.2.5+0.aarch64-apple-darwin.tar.gz/sha512/e6434c154db4c7187f227a550b159a8db8cfffc514323ca31112744a80a007ba5c95f2274cee30c0aa8caf1b20fb643cb814651a622b8e4bb2e5652878e504d2
+dSFMT.v2.2.5+0.aarch64-linux-gnu.tar.gz/md5/260e14855dbc7773a2ca906d58cc57f2
+dSFMT.v2.2.5+0.aarch64-linux-gnu.tar.gz/sha512/820ca4c6afde931e855b74015150f4ffbb513276c3fa7dbcc1ec8d34c02d4989fb7424a6e4f81f93d054811b5f54f8633d955b05acdb088387ee90f1c3b00915
+dSFMT.v2.2.5+0.aarch64-linux-musl.tar.gz/md5/7ddccbad6b5c9de4be187fe76637a0d8
+dSFMT.v2.2.5+0.aarch64-linux-musl.tar.gz/sha512/e3c225da00927096e3a6cd4abc681fba8f469cb74828e7054d4f5684d71dcb8e75c9a81f14fa10bfbb78f62f9567a31a92edcca8d797e5810a2a44a3fc17bc84
+dSFMT.v2.2.5+0.armv6l-linux-gnueabihf.tar.gz/md5/a70329e0a6c57009c6b6950fd34089f6
+dSFMT.v2.2.5+0.armv6l-linux-gnueabihf.tar.gz/sha512/4418c42165660adc050e872ef834f920c89ed6a0d2b816821672b1e862e947aad7efd023289da9bf05bb2eb9ec4b9d2561c403e2d5384d5314a4ba016b1f9cfc
+dSFMT.v2.2.5+0.armv6l-linux-musleabihf.tar.gz/md5/6ffc798b8a0c847fa5cb93640bd66ab3
+dSFMT.v2.2.5+0.armv6l-linux-musleabihf.tar.gz/sha512/94e5ae07d0b1420abd7290519bce6f77deae634bbb4df31e3f02416bf509e555a9b1c9d19dd77ca76a308c2b86d5c9d4718b9ef83c13167b88a8181d8ca7e73a
+dSFMT.v2.2.5+0.armv7l-linux-gnueabihf.tar.gz/md5/660d95aa08580ca1716a89c4d8b1eb24
+dSFMT.v2.2.5+0.armv7l-linux-gnueabihf.tar.gz/sha512/bc757a9f805047be5375f92c10a3f3eab69345a4ec5cc997f763e66be36144a74d414ff926df8e17b9d5a2394189269c3188c55e0b7c75a72495394d65510cef
+dSFMT.v2.2.5+0.armv7l-linux-musleabihf.tar.gz/md5/78c487049092fe61949d506637c713bb
+dSFMT.v2.2.5+0.armv7l-linux-musleabihf.tar.gz/sha512/03ddada4478f05eab7d2971b2deaf2cba91f084d7ce66fc8219bcb3cf5c308ea13959fed95568ca80f4ce11794e197092984919265716de8f2558e2cb30d94ce
+dSFMT.v2.2.5+0.i686-linux-gnu.tar.gz/md5/11463fd3981a8c143d7aed691d18d4e0
+dSFMT.v2.2.5+0.i686-linux-gnu.tar.gz/sha512/db946a4fbd8a3163b8b1c25e02bfc4a841da7d2532892a99037bd48ac98e1840691e8cc0127d9457a82667a0131e4826cb4e9d0a13f127afc62da4eb68af5a3e
+dSFMT.v2.2.5+0.i686-linux-musl.tar.gz/md5/a61405f72c9a3bba5718f078c68e61a5
+dSFMT.v2.2.5+0.i686-linux-musl.tar.gz/sha512/726f130bbbfd0dece4185b89a25a73f3b5b950ebfb7f86aea6e9cbcf9ae932e591d20b854de0b4985103dbf8b4b7cb3560661c5070af971cd2c1f3ec3e1ea7d2
+dSFMT.v2.2.5+0.i686-w64-mingw32.tar.gz/md5/3bc27ef8f26c7a26f096cf1d558d408d
+dSFMT.v2.2.5+0.i686-w64-mingw32.tar.gz/sha512/ea3608d3ae3874ea57a1a08f69abe2a1638bc340db71c6fe3c4fd5637d8c54943bf16b099a46817387c1ed4cb5f3cd1c0ff19ae8a4ed85dd555555821af06374
+dSFMT.v2.2.5+0.powerpc64le-linux-gnu.tar.gz/md5/fd8c73961ef7c82201e6d86e8bf4324c
+dSFMT.v2.2.5+0.powerpc64le-linux-gnu.tar.gz/sha512/1bd0ebd019cfc6f25f7ba007547c5ee297854655b93c55e90d8ead420875de5a087e38956693d5e901ff2abf667c72aa66fb34f587b82adf4b91b3d5d666b5c7
+dSFMT.v2.2.5+0.x86_64-apple-darwin.tar.gz/md5/6be9f2d3cd8d45a3fc1c3feeebcbbf00
+dSFMT.v2.2.5+0.x86_64-apple-darwin.tar.gz/sha512/5d17c2c0eedad6739b41b8a613e9e452df484136ecd11aed1f6b9f426ae1deaef9faf721810080ebc1701a88a3e7ae91b1992893598c33b342c3f876661f2f8e
+dSFMT.v2.2.5+0.x86_64-linux-gnu.tar.gz/md5/fa671f4ca14b171d53c8866d03f9162a
+dSFMT.v2.2.5+0.x86_64-linux-gnu.tar.gz/sha512/2e242a1448da0508ea88cc1a106f1e74f8d7e7562cd82b80d86abf9a8b454653ad7612e25c30ce00c23757e8a5b7b5736253b00a52f9473af6c5d4df768138f2
+dSFMT.v2.2.5+0.x86_64-linux-musl.tar.gz/md5/c648294163882ec539ab646542c74880
+dSFMT.v2.2.5+0.x86_64-linux-musl.tar.gz/sha512/9e96a47d660854b6517364f0db40a2f4e0e3b814499a0349f7cf550b1c8d04589fca5eb4a75bf34f36d1b5d1b2277b3e9a961c887092abedd08f438e025329e7
+dSFMT.v2.2.5+0.x86_64-unknown-freebsd.tar.gz/md5/5b53e6c5b78102f563742b4b3d888ec6
+dSFMT.v2.2.5+0.x86_64-unknown-freebsd.tar.gz/sha512/5db5902c7ec2624add768b9e2866f9aac224a31bcb4114d450c45717e2b244521b7c511c059527d557a71639cff98e190a38cd3e28db5be0b1faf0a1762cb1a5
+dSFMT.v2.2.5+0.x86_64-w64-mingw32.tar.gz/md5/386adb3b7593c222dc7a1060a1356b21
+dSFMT.v2.2.5+0.x86_64-w64-mingw32.tar.gz/sha512/fe2ab5021126807b37042e89a22ef9a869c6a0a028680df445773b2affd11c2b02148be07d53504ea3842bb38bb62fe039529688266c1cba3545a892bd4dc185
+dsfmt-2.2.5.tar.gz/md5/d22e476b52cdee7d5b90d2f289570073
+dsfmt-2.2.5.tar.gz/sha512/951e8669350f750b8915a819e704eae0a9b9c9518b3e3b9a1905f9ca0d25cc4c2486cb479e258a4a114e9c26ceb73a6c4e9f1cc02ed19173aeb8f20189754f6b
diff --git a/deps/dsfmt.version b/deps/dsfmt.version
index bbb63417f46cd..d81db2d10ff09 100644
--- a/deps/dsfmt.version
+++ b/deps/dsfmt.version
@@ -1,5 +1,7 @@
+# -*- makefile -*-
+
 ## jll artifact
 DSFMT_JLL_NAME := dSFMT
 
 ## source build
-DSFMT_VER := 2.2.4
+DSFMT_VER := 2.2.5
diff --git a/stdlib/dSFMT_jll/Project.toml b/stdlib/dSFMT_jll/Project.toml
index a83775f625987..0db19e602f67b 100644
--- a/stdlib/dSFMT_jll/Project.toml
+++ b/stdlib/dSFMT_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "dSFMT_jll"
 uuid = "05ff407c-b0c1-5878-9df8-858cc2e60c36"
-version = "2.2.4+4"
+version = "2.2.5+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 9deee4619209c997077e843b7549abc292884819 Mon Sep 17 00:00:00 2001
From: djturizo <72823727+djturizo@users.noreply.github.com>
Date: Sat, 30 Dec 2023 05:58:31 -0500
Subject: [PATCH 0511/1315] Bunch-Kaufman factorization support for generic
 number types and inertia computations (#51487)

### Introduction
This PR adds a generic implementation of the Bunch-Kaufman factorization
in native Julia code, and a generic implementation of a inertia
calculation function. Right now Julia only support the Bunch-Kaufman
factorization for `Float32`, `Float64` and their complex variants. This
is because the factorization is handled by LAPACK, which only supports
these types. To extend support to generic number types, I translated the
LAPACK implementation to native Julia code, and the code performs the
factorization in-place. I also included the function `inertia` that
computes the number of positive, negative, and zero eigenvalues of an $n
\times n$ Bunch-Kaufman factorized matrix in $\mathcal{O}(n)$ time.

### Changes
- `bunchkaufman` and `bunchkaufman!` now work for any `AbstractFloat`,
`Rational` and their complex variants. Behavior for previously supported
types is not changed (LAPACK is used when possible). `bunchakaufman!`
does not support `Integer` types, as in general the factorization lies
in the arithmetic closure of the number type (the rationals for the
integers). On the other hand, `bunchakaufman` supports `Integer` types,
by making an internal conversion to `Rational{BigInt}`.
- `ldiv!` for a `BunchKaufman` factorization has extended support for
generic number types with type stability.
- Previously, Julia extracted the diagonal factor of an $n \times n$
`BunchKaufman` object by making a copy of the matrix and then calling a
LAPACK function (`dsyconvf`, `csyconvf`, etc., depending on the number
type). This function also computes the triangular factor, so it runs in
$\mathcal{O}(n^2)$ time. Now Julia uses a native implementation of the
LAPACK function with small modifications, so it computes the diagonal
factor in $\mathcal{O}(n)$ time, without making a new copy of the
matrix.
- Added the function `inertia` that computes the number of positive,
negative and zero eigenvalues of the diagonal factor of an $n \times n$
`BunchKaufman` object, in case that the matrix is real symmetric or
Hermitian. For complex symmetric matrices, `inertia` only computes the
number of zero eigenvalues of the diagonal factor. `inertia` runs in
$\mathcal{O}(n)$ time and only uses arithmetic and real absolute value
operations. Therefore, `inertia` can be used for matrices of any generic
number type, including `Rational`. In particular, for rational matrices
the output of `inertia` is exact (unless a positive tolerance is
specified).
- Unit tests of the `BunchKaufman` library has been adapted to handle
low precision number types (approximate comparisons with tolerance
`sqrt(eps(Float64))` do not make sense when the floating point type is
`Float16`, for example). The test-set now also runs on the following
types: `Float16, Complex{Float16}, BigFloat, Complex{BigFloat},
Complex{Int}, BigInt, Complex{BigInt}, Rational{BigInt},
Complex{Rational{BigInt}}`. Unit tests for the `inertia` function have
been added too.
---
 NEWS.md                                   |    1 +
 stdlib/LinearAlgebra/src/bunchkaufman.jl  | 1208 ++++++++++++++++++++-
 stdlib/LinearAlgebra/test/bunchkaufman.jl |   81 +-
 3 files changed, 1263 insertions(+), 27 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index d5ef405b7a913..82ae28a3b420d 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -115,6 +115,7 @@ Standard library changes
    respectively, now efficiently compute the generalized eigenvalues (`eigen`: and eigenvectors) of `A` and `B`. Note: The second
    argument is the output of `bunchkaufman` or `lu` ([#50471]).
 * Structured matrices now retain either the axes of the parent (for `Symmetric`/`Hermitian`/`AbstractTriangular`/`UpperHessenberg`), or that of the principal diagonal (for banded matrices) ([#52480]).
+* `bunchkaufman` and `bunchkaufman!` now work for any `AbstractFloat`, `Rational` and their complex variants. `bunchkaufman` now supports `Integer` types, by making an internal conversion to `Rational{BigInt}`. Added new function `inertia` that computes the inertia of the diagonal factor given by the `BunchKaufman` factorization object of a real symmetric or Hermitian matrix. For complex symmetric matrices, `inertia` only computes the number of zero eigenvalues of the diagonal factor ([#51487]).
 
 #### Printf
 
diff --git a/stdlib/LinearAlgebra/src/bunchkaufman.jl b/stdlib/LinearAlgebra/src/bunchkaufman.jl
index f995b3b8444c4..19f82167495f3 100644
--- a/stdlib/LinearAlgebra/src/bunchkaufman.jl
+++ b/stdlib/LinearAlgebra/src/bunchkaufman.jl
@@ -4,6 +4,15 @@
 ## LD for BunchKaufman, UL for CholeskyDense, LU for LUDense and
 ## define size methods for Factorization types using it.
 
+##----------- Type utilities for generic Bunch-Kaufman implementation ------------
+# Generic real type. Any real number type should able to approximate
+# real numbers, and thus be closed under arithmetic operations.
+# Therefore so Int, Complex{Int}, etc. are excluded.
+ClosedReal = T where T <: Union{AbstractFloat, Rational}
+# Similarly, we also use a closed scalar type
+ClosedScalar = Union{T, Complex{T}} where T <: ClosedReal
+##--------------------------------------------------------------------------------
+
 """
     BunchKaufman <: Factorization
 
@@ -22,10 +31,10 @@ as appropriate given `S.uplo`, and `S.p`.
 
 # Examples
 ```jldoctest
-julia> A = [1 2; 2 3]
-2×2 Matrix{Int64}:
- 1  2
- 2  3
+julia> A = Float64.([1 2; 2 3])
+2×2 Matrix{Float64}:
+ 1.0  2.0
+ 2.0  3.0
 
 julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
 BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
@@ -145,10 +154,10 @@ The following functions are available for `BunchKaufman` objects:
 
 # Examples
 ```jldoctest
-julia> A = [1 2; 2 3]
-2×2 Matrix{Int64}:
- 1  2
- 2  3
+julia> A = Float64.([1 2; 2 3])
+2×2 Matrix{Float64}:
+ 1.0  2.0
+ 2.0  3.0
 
 julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
 BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
@@ -237,37 +246,47 @@ function _ipiv2perm_bk(v::AbstractVector{T}, maxi::Integer, uplo::AbstractChar,
     return p
 end
 
-function getproperty(B::BunchKaufman{T,<:StridedMatrix}, d::Symbol) where {T<:BlasFloat}
+function getproperty(B::BunchKaufman{TS},
+    d::Symbol) where TS <: ClosedScalar{TR} where TR <: ClosedReal
     n = size(B, 1)
     if d === :p
         return _ipiv2perm_bk(getfield(B, :ipiv), n, getfield(B, :uplo), B.rook)
     elseif d === :P
-        return Matrix{T}(I, n, n)[:,invperm(B.p)]
+        return Matrix{TS}(I, n, n)[:,invperm(B.p)]
     elseif d === :L || d === :U || d === :D
-        if getfield(B, :rook)
-            LUD, od = LAPACK.syconvf_rook!(getfield(B, :uplo), 'C', copy(getfield(B, :LD)), getfield(B, :ipiv))
+        if d === :D
+            _, od, md = generic_syconv(B, false)
+        elseif typeof(B) <: BunchKaufman{T,<:StridedMatrix} where {T<:BlasFloat}
+            # We use LAPACK whenever we can
+            if getfield(B, :rook)
+                LUD, _ = LAPACK.syconvf_rook!(getfield(B, :uplo), 'C',
+                    copy(getfield(B, :LD)), getfield(B, :ipiv))
+            else
+                LUD, _ = LAPACK.syconv!(getfield(B, :uplo), copy(getfield(B, :LD)),
+                    getfield(B, :ipiv))
+            end
         else
-            LUD, od = LAPACK.syconv!(getfield(B, :uplo), copy(getfield(B, :LD)), getfield(B, :ipiv))
+            LUD, _ = generic_syconv(B)
         end
         if d === :D
             if getfield(B, :uplo) == 'L'
                 odl = od[1:n - 1]
-                return Tridiagonal(odl, diag(LUD), getfield(B, :symmetric) ? odl : conj.(odl))
+                return Tridiagonal(odl, md, getfield(B, :symmetric) ? odl : conj.(odl))
             else # 'U'
                 odu = od[2:n]
-                return Tridiagonal(getfield(B, :symmetric) ? odu : conj.(odu), diag(LUD), odu)
+                return Tridiagonal(getfield(B, :symmetric) ? odu : conj.(odu), md, odu)
             end
         elseif d === :L
             if getfield(B, :uplo) == 'L'
                 return UnitLowerTriangular(LUD)
             else
-                throw(ArgumentError("factorization is U*D*transpose(U) but you requested L"))
+                throw(ArgumentError("factorization is U*D*U' but you requested L"))
             end
         else # :U
             if B.uplo == 'U'
                 return UnitUpperTriangular(LUD)
             else
-                throw(ArgumentError("factorization is L*D*transpose(L) but you requested U"))
+                throw(ArgumentError("factorization is L*D*L' but you requested U"))
             end
         end
     else
@@ -411,3 +430,1158 @@ end
 ## reconstruct the original matrix
 ## TODO: understand the procedure described at
 ## http://www.nag.com/numeric/FL/nagdoc_fl22/pdf/F07/f07mdf.pdf
+
+
+##--------------------------------------------------------------------------
+##------------- Start of generic Bunch-Kaufman Implementation --------------
+##--------------------------------------------------------------------------
+
+export inertia
+
+function arg_illegal(fun_name::AbstractString,
+    info::Integer,
+    waer::AbstractChar)
+    if waer == 'W'
+        @warn " ** On entry to '$(fun_name)' parameter number " *
+            "$(info) had an illegal value"
+    else
+        error(" ** On entry to '$(fun_name)' parameter number " *
+            "$(info) had an illegal value")
+    end
+end
+
+
+function cabs1(z::T) where T <: Complex
+    return abs(real(z)) + abs(imag(z))
+end
+
+
+function cabsr(z::T) where T <: Complex
+    return abs(real(z))
+end
+
+
+"""
+generic_adr1!(uplo, alpha, x, y, A, syhe) -> nothing
+
+`generic_adr1!` performs the following adjoint (symmetric or Hermitian)
+rank 1 operation
+
+`A[1:K,1:L] = alpha*x*y' + A[1:K,1:L]`
+
+in-place, where `alpha` is a scalar, `x` is a K element vector, `y`
+is an L element vector and `A` is an `NxM` matrix. Note that `y'` can
+denote either the transpose, i.e. `transpose(y)` or the conjugate
+transpose , i.e. `adjoint(y)`.
+
+`uplo` is a character, either `'U'`, `'L'` or `'F'`, indicating whether
+the matrix is stored in the upper triangular part (`uplo=='U'`), the
+lower triangular part (`uplo=='L'`), or the full storage space is used
+(`uplo=='F'`). If `uplo!='F'` then only the corresponding triangular
+part is updated. The values `'U'` or `'L'` can only be used when A is
+square (`N==M`).
+
+`syhe` is a character, either `'S'` or `'H'`, indicating whether the
+symmetric adjoint (`syhe=='S'`, and `y'==transpose(y)`) or the hermitian
+adjoint (`syhe=='H'`, and `y'==adjoint(y)`) must be used.
+"""
+function generic_adr1!(uplo::AbstractChar,
+    alpha::ClosedScalar{TR},
+    x::AbstractVector{TS},
+    y::AbstractVector{TS},
+    A::AbstractMatrix{TS},
+    syhe::AbstractChar
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+
+    # Inputs must be 1-indexed; bounds may not be checked.
+    Base.require_one_based_indexing(x, A)
+
+    # Check argument validity
+    K = length(x)
+    L = length(y)
+    N, M = size(A)
+    info = 0::BlasInt
+    if (uplo != 'U' && uplo != 'L' && uplo != 'F') || (uplo != 'F' && N != M)
+        info = (-1)::BlasInt
+    elseif K > N
+        info = (-3)::BlasInt
+    elseif L > M
+        info = (-4)::BlasInt
+    elseif syhe != 'S' && syhe != 'H'
+        info = (-6)::BlasInt
+    end
+    if info < 0
+        arg_illegal("generic_sadr1!", -info, 'E')
+    end
+
+    # Load the requested adjoining operator
+    adj_op = syhe == 'S' ? identity : conj
+
+    # Define loop range function according to the type of storage
+    # TODO: can we adjust the range without anonymous functions,
+    # but without having to write the same code thrice?
+    i_range = uplo == 'F' ? _ -> (1:K) : uplo == 'U' ? j -> (1:min(j,K)) : j -> (j:K)
+
+    # Compute rank update of A
+    for j in 1:L; @inbounds begin
+        if y[j] != 0
+            temp = alpha * adj_op(y[j])
+            for i in i_range(j)
+                A[i,j] += x[i] * temp
+            end
+        end
+    end; end
+    return
+end
+
+
+"""
+generic_mvpv!(trans, alpha, A, x, beta, y) -> nothing
+
+`generic_mvpv!` performs the following matrix-vector operation:
+
+`y[1:K] = alpha*A'*x[1:L] + beta*y[1:K]`
+
+in-place, where `alpha` and `beta` are scalars, `x` is a vector with at
+least L elements, `y` is a vector with at least K elements, and `A` is
+an `NxM` matrix. `A'` can denote the transpose, i.e. `transpose(A)` or
+the conjugate transpose, i.e. `adjoint(A)`, and then `M==K && N==L`.
+`A'` can also denote no adjoining at all, i.e. `A'==A`, and then
+`N==K && M==L`.
+
+`trans` is a character, either `'T'`, `'C'` or `'N'`, indicating whether
+`A'=transpose(A)`, `A'=adjoint(A)` or `A'=A`, respectively.
+"""
+function generic_mvpv!(trans::AbstractChar,
+    alpha::ClosedScalar{TR},
+    A::AbstractMatrix{TS},
+    x::AbstractVector{TS},
+    beta::ClosedScalar{TR},
+    y::AbstractVector{TS},
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+
+    # Inputs must be 1-indexed; bounds may not be checked.
+    Base.require_one_based_indexing(A, x, y)
+
+    # Check argument validity
+    M, N = size(A)
+    K = trans == 'N' ? M : N
+    L = trans == 'N' ? N : M
+    info = 0::BlasInt
+    if trans != 'T' && trans != 'C' && trans != 'N'
+        info = (-1)::BlasInt
+    elseif length(y) < K
+        info = (-3)::BlasInt
+    elseif length(x) < L
+        info = (-4)::BlasInt
+    end
+    if info < 0
+        arg_illegal("generic_sadr1!", -info, 'E')
+    end
+
+    #   Quick return if possible.
+    if K == 0 || (alpha == 0 && beta == 1); return; end
+
+    #   Start the operations. In this version the elements of A are
+    #   accessed sequentially with one pass through A.
+    #   First form  y := beta*y.
+    @inbounds begin
+        if beta != 1
+            if beta == 0
+                # Way less allocations and way faster for BigFloat.
+                # For Float64 there is some (acceptable IMO) performance loss.
+                y[1:K] .= 0
+            else
+                for i in 1:K; y[i] *= beta; end
+            end
+        end
+        if alpha == 0 || L == 0; return; end
+
+        if trans == 'N'
+            #   Form  y := alpha*A*x + y.
+            for j in 1:L
+                # Faster than a loop
+                axpy!(alpha*x[j], view(A, 1:K, j), view(y, 1:K))
+            end
+        else
+            #   Form  y := alpha*A**T*x + y  or  y := alpha*A**H*x + y.
+            noconj = (trans == 'T')
+            for i = 1:K
+                temp = 0
+                if noconj
+                    for j = 1:L
+                        temp = temp + A[j,i]*x[j]
+                    end
+                else
+                    for j = 1:L
+                        temp = temp + conj(A[j,i])*x[j]
+                    end
+                end
+                y[i] += alpha*temp
+            end
+        end
+    end
+    return
+end
+
+
+"""
+bk_rowcol_swap!(A, k, kp, kstep, upper, herm) -> did_swap::Bool
+
+Performs the row and column interchange of the Bunch-Kaufman factorization.
+If `upper==true` then the rows and columns `kp` of `A[1:k,1:k]` are
+interchanged with either rows and columns `k` or `k-1` of `A[1:k,1:k]`,
+depending on whether `kstep==1` or `kstep==2`, respectively. If
+`upper==false` then the rows and columns `kp-k+1` of `A[k:N,k:N]` are
+interchanged with either rows and columns `1` or `2` of `A[k:N,k:N]`,
+depending on whether `kstep==1` or `kstep==2`, respectively. `herm=true`
+then it is assumed that `A` is Hermitian, and conjugation is applied to
+the appropriate entries of the interchanged rows and columns. If
+`herm=false` no conjugation is performed.
+
+This is an internal helper function for the main Bunch-Kaufman
+factorization function, `generic_bunchkaufman!`. As such, validity of the
+input values is not verified.
+"""
+function bk_rowcol_swap!(
+    A::AbstractMatrix{TS},
+    k::Integer,
+    kp::Integer,
+    kstep::Integer,
+    upper::Bool,
+    herm::Bool
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+    kk = upper ? k - kstep + 1 : k + kstep - 1
+    if kp != kk
+        if kp > 1
+            thisview = upper ? view(A, 1:(kp-1), :) : view(A, (kp+1):size(A,1), :)
+            Base.swapcols!(thisview, kp, kk)
+        end
+        thisrange = upper ? ((kp+1):(kk-1)) : ((kk+1):(kp-1))
+        if !herm
+            # Real/complex symmetric case
+            for j in thisrange
+                A[j,kk], A[kp,j] = A[kp,j], A[j,kk]
+            end
+            A[kk,kk], A[kp,kp] = A[kp,kp], A[kk,kk]
+        else
+            # Hermitian case
+            for j in thisrange
+                A[j,kk], A[kp,j] = conj(A[kp,j]), conj(A[j,kk])
+            end
+            A[kp,kk] = conj(A[kp,kk])
+            A[kk,kk], A[kp,kp] = real(A[kp,kp]), real(A[kk,kk])
+        end
+        if kstep == 2
+            if herm
+                # Force diagonal entry to be purely real
+                A[k,k] = real(A[k,k])
+            end
+            if upper
+                A[k-1,k], A[kp,k] = A[kp,k], A[k-1,k]
+            else
+                A[k+1,k], A[kp,k] = A[kp,k], A[k+1,k]
+            end
+        end
+        return true
+    else
+        return false
+    end
+end
+
+
+"""
+generic_bunchkaufman!(uplo, A, syhe, rook::Bool=false) ->
+LD<:AbstractMatrix, ipiv<:AbstractVector{Integer}, info::BlasInt
+
+Computes the Bunch-Kaufman factorization of a symmetric or Hermitian
+matrix `A` of size `NxN` as `P'*U*D*U'*P` or `P'*L*D*L'*P`, depending on
+which triangle is stored in `A`. Note that if `A` is complex symmetric
+then `U'` and `L'` denote the unconjugated transposes, i.e.
+`transpose(U)` and `transpose(L)`. The resulting `U` or `L` and D are
+stored in-place in `A`, LAPACK style. `LD` is just a reference to `A`
+(that is, `LD===A`). `ipiv` stores the permutation information of the
+algorithm in LAPACK format. `info` indicates whether the factorization
+was successful and non-singular when `info==0`, or else `info` takes a
+different value. The outputs `LD`, `ipiv`, `info` follow the format of
+the LAPACK functions of the Bunch-Kaufman factorization (`dsytrf`,
+`csytrf`, `chetrf`, etc.), so this function can (ideally) be used
+interchangeably with its LAPACK counterparts `LAPACK.sytrf!`,
+`LAPACK.sytrf_rook!`, etc.
+
+`uplo` is a character, either `'U'` or `'L'`, indicating whether the
+matrix is stored in the upper triangular part (`uplo=='U'`) or in the
+lower triangular part (`uplo=='L'`).
+
+`syhe` is a character, either `'S'` or `'H'`, indicating whether the
+matrix is real/complex symmetric (`syhe=='S'`, and the symmetric
+Bunch-Kaufman factorization is performed) or complex hermitian
+(`syhe=='H'`, and the hermitian Bunch-Kaufman factorization is
+performed).
+
+If `rook` is `true`, rook pivoting is used (also called bounded
+Bunch-Kaufman factorization). If `rook` is `false`, rook pivoting is
+not used (standard Bunch-Kaufman factorization). Rook pivoting can
+require up to `~N^3/6` extra comparisons in addition to the `~N^3/3`
+additions and `~N^3/3` multiplications of the standard Bunch-Kaufman
+factorization. However, rook pivoting guarantees that the entries of
+`U` or `L` are bounded.
+
+This function implements the factorization algorithm entirely in
+native Julia, so it supports any number type representing real or
+complex numbers.
+"""
+function generic_bunchkaufman!(
+    uplo::AbstractChar,
+    A::AbstractMatrix{TS},
+    syhe::AbstractChar,
+    rook::Bool=false
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+
+    # Inputs must be 1-indexed; bounds may not be checked.
+    Base.require_one_based_indexing(A)
+
+    # Initialize info integer as 0
+    info = 0::BlasInt
+    # Get size of matrix
+    N, N2 = size(A)
+    # Initialize permutation vector
+    ipiv = Vector{BlasInt}(undef, N)
+
+    # Check input correctness
+    if uplo != 'U' && uplo != 'L'
+        info = (-1)::BlasInt
+    elseif N != N2
+        info = (-2)::BlasInt
+    elseif syhe != 'S' && syhe != 'H'
+        info = (-3)::BlasInt
+    end
+    if info < 0
+        arg_illegal("generic_bunchkaufman!", -info, 'W')
+        return A, ipiv, info
+    end
+    # if rook
+    #     error("Rook pivoting not implemented yet.")
+    # end
+
+    # Initialize `alpha` for use in choosing pivot block size.
+    # The exact value is
+    # (1 + sqrt(17)) / 8 ~= 0.6404
+    # For rational matrices we a the small denominator approximation:
+    # 16/25 = 0.64 ~= (1 + sqrt(17)) / 8
+    # in order to not increase the denominator size too much in computations.
+    # The error of this approximation is ≤0.1%, and it still guarantees that a
+    # 2x2 block in the D factor has a positive-negative eigenvalue pair, as long
+    # as the approximation lies in (0,1).
+    alpha = TR <: AbstractFloat ? (1 + sqrt(TR(17))) / 8 : TR(16//25)
+    # Use complex 1-norm for pivot selection, as in LAPACK
+    abs1_fun = TS <: Real ? abs : cabs1
+
+    # Check if the matrix is symmetric of hermitian
+    if syhe == 'S' || (syhe == 'H' && TS <: Real)
+        # Use symmetric variant if matrix is real, regardless of 'syhe' value
+        syhe = 'S'
+        diag_abs_fun = abs1_fun
+    else
+        diag_abs_fun = cabsr
+    end
+
+    # Compute machine safe minimum when working with floating point numbers.
+    # LAPACK doesn't use this for diagonal pivoting though...
+    if rook
+        if TR <: AbstractFloat
+            # eps(0) gives the smallest subnormal number, and eps(1) gives the floating
+            # point type epsilon. eps(0)/eps(1) gives the smallest normal number, plus
+            # possibly some rounding error.
+            sfmin = nextfloat(eps(TR(0)) / eps(TR(1)), 2)
+            small = 1 / prevfloat(typemax(TR), 2)
+            if small >= sfmin
+                # 1/sfmin may overflow, so use 'small' plus a bit as the safe minimum
+                sfmin = nextfloat(small * (1 + eps(TR(1))), 2)
+            end
+        else
+            # We're working with rationals in this case, so the all results are exact.
+            sfmin = TR(0)
+        end
+    end
+
+    # Run factorization depending on where the data is stored
+    upper = (uplo == 'U')
+    herm = (syhe == 'H')
+    # TODO: Is this gonna inline properly?
+    @inline k_cond = upper ? k -> k >= 1 : k -> k <= N
+    @inline irange = upper ? j -> (j:-1:1) : j -> (j:N)
+    @inline conj_op = herm ? conj : identity
+    @inline diagreal_op = herm ? (j -> A[j,j] = TS(real(A[j,j]))) : _ -> ()
+    k = upper ? N : 1
+    # Main loop, comments refer to the upper triangular version of the factorization.
+    # The lower triangular version is analogous.
+    while k_cond(k); @inbounds begin
+        kstep = 1
+        knext = upper ? k - 1 : k + 1
+        p = k
+        #   Determine rows and columns to be interchanged and whether
+        #   a 1-by-1 or 2-by-2 pivot block will be used
+        absakk = diag_abs_fun(A[k,k])
+        #   IMAX is the row-index of the largest off-diagonal element in
+        #    column K, and COLMAX is its absolute value.
+        #    Determine both COLMAX and IMAX.
+        if upper && k > 1
+            colmax, imax = findmax(abs1_fun, view(A, 1:(k-1), k))
+        elseif (!upper) && k < N
+            colmax, imax = findmax(abs1_fun, view(A, (k+1):N, k))
+            imax += k
+        else
+            colmax = 0
+        end
+        if (max(absakk, colmax) == 0) || isnan(absakk)
+            #   Column K is zero or underflow, or contains a NaN:
+            #   set INFO and continue
+            if info == 0
+                info = k::BlasInt
+            end
+            kp = k
+            if herm
+                # Force diagonal entry to be purely real
+                A[k,k] = real(A[k,k])
+            end
+        else
+            if absakk >= alpha*colmax
+            #   no interchange, use 1-by-1 pivot block
+                kp = k
+            elseif rook
+                #   Loop until pivot found
+                while true
+                    #   Begin pivot search loop body
+                    #   JMAX is the column-index of the largest off-diagonal
+                    #   element in row IMAX, and ROWMAX is its absolute value.
+                    #   Determine both ROWMAX and JMAX.
+                    if imax != k
+                        thisview = upper ? view(A, imax, (imax+1):k) :
+                            view(A, imax, k:(imax-1))
+                        rowmax, jmax = findmax(abs1_fun, thisview)
+                        jmax += upper ? imax : k - 1
+                    else
+                        # LAPACK makes rowmax=0 in this case, but I believe it's
+                        # better to make rowmax=-1, so that we guarantee that jmax
+                        # will be define in the next if-block.
+                        # TODO: is this correct/safe?
+                        rowmax = 0
+                    end
+                    if (upper && imax > 1) || ((!upper) && imax < N)
+                        # Remember that we only have the upper triangular part
+                        # of the matrix. We inspect the part of the row in the
+                        # lower triangular part by traversing the corresponding
+                        # part of the transpose column.
+                        if upper
+                            stemp, itemp = findmax(abs1_fun, view(A, 1:(imax-1), imax))
+                        else
+                            stemp, itemp = findmax(abs1_fun, view(A, (imax+1):N, imax))
+                            itemp += imax
+                        end
+                        if stemp > rowmax
+                            rowmax = stemp
+                            jmax = itemp
+                        end
+                    end
+                    #   Equivalent to testing for (used to handle NaN and Inf)
+                    #   CABS1( A( IMAX, IMAX ) ).GE.ALPHA*ROWMAX
+                    if !(diag_abs_fun(A[imax,imax]) < alpha*rowmax)
+                    #   interchange rows and columns K and IMAX,
+                    #   use 1-by-1 pivot block
+                        kp = imax
+                        break
+                    #   Equivalent to testing for ROWMAX .EQ. COLMAX,
+                    #   used to handle NaN and Inf
+                    elseif (p == jmax || rowmax <= colmax)
+                    #   interchange rows and columns K+1 and IMAX,
+                    #   use 2-by-2 pivot block
+                        kp = imax
+                        kstep = 2
+                        break
+                    else
+                    #   Pivot NOT found, set variables and repeat
+                        p = imax
+                        colmax = rowmax
+                        imax = jmax
+                    end
+                    #   End pivot search loop body
+                end
+            else
+                #   JMAX is the column-index of the largest off-diagonal
+                #   element in row IMAX, and ROWMAX is its absolute value
+                # We don't really need JMAX, se we don't store it
+                thisview = upper ? view(A, imax, (imax+1):k) : view(A, imax, k:(imax-1))
+                rowmax = findmax(abs1_fun, thisview)[1]
+                if (upper && imax > 1) || ((!upper) && imax < N)
+                    # Remember that we only have the upper triangular part
+                    # of the matrix. We inspect the part of the row in the
+                    # lower triangular part by traversing the corresponding
+                    # part of the transpose column.
+                    thisview = upper ? view(A, 1:(imax-1), imax) :
+                        view(A, (imax+1):N, imax)
+                    rowmax = max(rowmax, findmax(abs1_fun, thisview)[1])
+                end
+                if absakk >= alpha * colmax * (colmax/rowmax)
+                    #   no interchange, use 1-by-1 pivot block
+                    kp = k
+                elseif diag_abs_fun(A[imax,imax]) >= alpha * rowmax
+                    #   interchange rows and columns K and IMAX, use 1-by-1
+                    #   pivot block
+                    kp = imax
+                else
+                    #   interchange rows and columns K-1 and IMAX, use 2-by-2
+                    #   pivot block
+                    kp = imax
+                    p = imax
+                    kstep = 2
+                end
+            end
+            #   Swap TWO rows and TWO columns
+            #   First swap
+            # The first swap only needs to be done when using rook pivoting
+            if rook && kstep == 2
+                #   Interchange rows and column K and P in the leading
+                #   submatrix A(1:k,1:k) if we have a 2-by-2 pivot
+                bk_rowcol_swap!(A, k, p, 1, upper, herm)
+            end
+            #   Second swap
+            did_swap = bk_rowcol_swap!(A, k, kp, kstep, upper, herm)
+            if herm && (!did_swap)
+                # Force diagonal entries to be purely real
+                A[k,k] = real(A[k,k])
+                if kstep == 2
+                    A[knext,knext] = real(A[knext,knext])
+                end
+            end
+            if kstep == 1
+                #   1-by-1 pivot block D(k): column k now holds
+                #   W(k) = U(k)*D(k)
+                #   where U(k) is the k-th column of U
+                #   When rook=false, sfmin is not defined, but the short-circuit
+                #   evaluation of the conditional avoids an error.
+                if (!rook) || absakk >= sfmin
+                    #   Perform a rank-1 update of A(1:k-1,1:k-1) as
+                    #   A := A - U(k)*D(k)*U(k)' = A - W(k)*1/D(k)*W(k)'
+                    # Compute 1/D(k)
+                    r1 = !herm ? 1 / A[k,k] : 1 / real(A[k,k])
+                    # Perform rank-1 update to store the Schur complement
+                    # in a submatrix of A
+                    x = upper ? view(A, 1:(k-1), k) : view(A, (k+1):N, k)
+                    # if 'upper' this should assign by reference
+                    thisview = upper ? A : view(A, (k+1):N, (k+1):N)
+                    generic_adr1!(uplo, -r1, x, x, thisview, syhe)
+                    #   Store U(k) in column k
+                    thisrange = upper ? (1:(k-1)) : ((k+1):N)
+                    for i in thisrange
+                        A[i,k] *= r1
+                    end
+                else
+                    # Compute D(k)
+                    r1 = !herm ? A[k,k] : real(A[k,k])
+                    #   Store U(k) in column k
+                    thisrange = upper ? (1:(k-1)) : ((k+1):N)
+                    for i in thisrange
+                        A[i,k] /= r1
+                    end
+                    #   Perform a rank-1 update of A(k+1:n,k+1:n) as
+                    #   A := A - U(k)*D(k)*U(k)**T
+                    #      = A - W(k)*(1/D(k))*W(k)**T
+                    #      = A - (W(k)/D(k))*(D(k))*(W(k)/D(K))**T
+                    # Perform rank-1 update to store the Schur complement
+                    # in a submatrix of A
+                    x = upper ? view(A, 1:(k-1), k) : view(A, (k+1):N, k)
+                    # if 'upper' this should assign by reference
+                    thisview = upper ? A : view(A, (k+1):N, (k+1):N)
+                    generic_adr1!(uplo, -r1, x, x, thisview, syhe)
+                end
+            elseif (upper && k > 2) || ((!upper) && k < N - 1)
+                #   2-by-2 pivot block D(k): columns k and k-1 now hold
+                #   ( W(k-1) W(k) ) = ( U(k-1) U(k) )*D(k)
+                #   where U(k) and U(k-1) are the k-th and (k-1)-th columns
+                #   of U
+                #   Perform a rank-2 update of A(1:k-2,1:k-2) as
+                #   A := A - ( U(k-1) U(k) )*D(k)*( U(k-1) U(k) )'
+                #   = A - ( W(k-1) W(k) )*inv(D(k))*( W(k-1) W(k) )'
+                thisrange = upper ? ((k-2):-1:1) : ((k+2):N)
+                if !herm
+                    # Real/complex symmetric case
+                    #TODO: is this way to compute the inverse backward stable?
+                    # (it probably is as it comes from LAPACK)
+                    dxk = A[knext,k]
+                    dxx = A[knext,knext] / dxk
+                    dkk = A[k,k] / dxk
+                    t = 1 / (dkk * dxx - 1)
+                    dxk = t / dxk
+                    dkx = dxk
+                else
+                    # Hermitian case
+                    # TODO: is this way to compute the inverse backward stable?
+                    # (it probably is as it is a small modification of LAPACK's
+                    # method)
+                    dxk = A[knext,k]
+                    dxx = real(A[knext,knext]) / dxk
+                    dkk = real(A[k,k]) / conj(dxk)
+                    t = 1 / (real(dkk * dxx) - 1)
+                    dkx = t / conj(dxk)
+                    dxk = t / dxk
+                end
+                for j in thisrange
+                    wknext = dxk * (dkk*A[j,knext] - A[j,k])
+                    wk = dkx * (dxx*A[j,k] - A[j,knext])
+                    for i in irange(j)
+                        A[i,j] -= (A[i,k]*conj_op(wk) + A[i,knext]*conj_op(wknext))
+                    end
+                    A[j,k] = wk
+                    A[j,knext] = wknext
+                    # Force diagonal entry to be purely real, but still of
+                    # complex type TS (I don't know why in LAPACK this
+                    # case, unlike the rest, enforces a complex type
+                    # explicitly).
+                    diagreal_op(j)
+                end
+            end
+        end
+        #   Store details of the interchanges in IPIV
+        if kstep == 1
+            ipiv[k] = kp
+        else
+            ipiv[k] = -p
+            ipiv[knext] = -kp
+        end
+        #   Decrease K and return to the start of the main loop
+        # k -= upper ? kstep : -kstep
+        if upper; k -= kstep; else; k += kstep; end
+    end; end
+    return A, ipiv, info
+end
+
+
+"""
+generic_syconv(F, gettri::Bool=true) ->
+(TLU<:Union{AbstractMatrix,Nothing}, e<:AbstractVector,
+    d<:Union{AbstractVector,Nothing})
+
+`generic_syconv` takes the Bunch-Kaufman object `F` and returns the
+block-diagonal factor `D`, and the triangular factor `L` (or `U`) if
+requested. If the `L` or `U` factor is requested then both `L` (or `U`) and
+the main diagonal of `D` will be stored in `TLU`, following LAPACK format,
+and `d` will be set to `nothing`. `e` contains the first subdiagonal of
+`D`. If the triangular factor is not requested, then `TLU` will not be set
+to `nothing`, and the main diagonal of `D` will be stored in `d`.
+
+`gettri` is a `Bool`, indicating whether the `L` (or `U`) triangular factor
+should be computed (`gettri==true`) or not (`gettri==false`). If the
+triangular factor is required, a copy of `A.LD` will be created, and the
+triangular factor will be computed in-place in said copy.
+"""
+function generic_syconv(
+    F::BunchKaufman{TS},
+    gettri::Bool=true
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+
+    # Inputs must be 1-indexed; bounds may not be checked.
+    Base.require_one_based_indexing(F.LD, F.ipiv)
+
+    # Extract necessary variables
+    A, ipiv, rook = gettri ? deepcopy(F.LD) : F.LD, F.ipiv, F.rook
+
+    # Get size of matrix
+    N = size(A)[1]
+
+    # Initialize off-diagonal and diagonal vector
+    e = Vector{TS}(undef, N)
+    d = gettri ? nothing : diag(A, 0)
+
+    #   Quick return if possible
+    if N == 0; return gettri ? A : nothing, e, d; end
+
+    # Main loops
+    upper = (F.uplo == 'U')
+    @inline icond_d = upper ? i -> i > 1 : i -> i < N
+    @inline icond_T = upper ? i -> i >= 1 : i -> i <= N
+    @inline inext = upper ? i -> i - 1 : i -> i + 1
+    #   Convert VALUE
+    i = upper ? N : 1
+    e[N+1-i] = 0
+    while icond_d(i); @inbounds begin
+        if ipiv[i] < 0
+            ix = inext(i)
+            e[i] = A[ix,i]
+            e[ix] = 0
+            if gettri; A[ix,i] = 0; end
+            if upper; i -= 1; else; i += 1; end
+        else
+            e[i] = 0
+        end
+        if upper; i -= 1; else; i += 1; end
+    end; end
+    #   Convert PERMUTATIONS
+    if gettri
+        i = upper ? N : 1
+        while icond_T(i); @inbounds begin
+            thisview = upper ? view(A, :, (i+1):N) : view(A, :, 1:(i-1))
+            ip = ipiv[i]
+            if ip > 0 || rook
+                Base.swaprows!(thisview, abs(ip), i)
+            end
+            if ip <= 0
+                ix = inext(i)
+                Base.swaprows!(thisview, -ipiv[ix], ix)
+                if upper; i -= 1; else; i += 1; end
+            end
+            if upper; i -= 1; else; i += 1; end
+        end; end
+    end
+    return gettri ? A : nothing, e, d
+end
+
+
+"""
+generic_bksolve!(F, B) -> X<:AbstractVecOrMat
+
+`generic_bksolve!` solves a system of linear equations `A*X = B` where
+the Bunch-Kaufman factorization of `A` is provided by `F`.
+"""
+function generic_bksolve!(
+    F::BunchKaufman{TS},
+    B0::AbstractVecOrMat{TS},
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+
+    # Inputs must be 1-indexed; bounds may not be checked.
+    Base.require_one_based_indexing(F.LD, F.ipiv, B0)
+
+    # Get size of matrices
+    N = size(F.LD)[1]
+    if typeof(B0) <: AbstractVector
+        N3 = size(B0)[1]
+        M = 1
+        B = view(B0, :, :)
+    else
+        N3, M = size(B0)
+        B = B0
+    end
+
+    # Initialize info integer as 0
+    info = 0::BlasInt
+
+    # Check input correctness
+    if N3 != N
+        info = (-2)::BlasInt
+    end
+    if info < 0
+        arg_illegal("generic_bksolve!", -info, 'E')
+    end
+
+    #   Quick return if possible
+    if N == 0 || M == 0; return B; end
+
+    # Extract necessary variables
+    A, ipiv, symm, rook = F.LD, F.ipiv, issymmetric(F), F.rook
+
+    # Load the requested adjoining operator
+    adj_op = symm ? identity : conj
+
+    R1 = TR(1)
+    upper = (F.uplo == 'U')
+    @inline kcond1 = upper ? k -> k >= 1 : k -> k <= N
+    @inline kcond2 = upper ? k -> k <= N : k -> k >= 1
+    @inline knext = upper ? k -> k - 1 : k -> k + 1
+    @inline knext2 = upper ? k -> k + 1 : k -> k - 1
+    k = upper ? N : 1
+    while kcond1(k); @inbounds begin
+        kp = ipiv[k]
+        if kp > 0
+            #   1 x 1 diagonal block
+            #   Interchange rows K and IPIV(K).
+            Base.swaprows!(B, k, kp)
+            #   Multiply by inv(U(K)), where U(K) is the transformation
+            #   stored in column K of A.
+            Aview = upper ? view(A, 1:(k-1), k) : view(A, (k+1):N, k)
+            Bview = upper ? B : view(B, (k+1):N, :)
+            generic_adr1!('F', -R1, Aview, view(B, k, :), Bview, 'S')
+            #   Multiply by the inverse of the diagonal block.
+            s = symm ? 1 / A[k,k] : 1 / real(A[k,k])
+            for j in 1:M; B[k,j] *= s; end
+            if upper; k -= 1; else; k += 1; end
+        else
+            #   2 x 2 diagonal block
+            #   Interchange rows K and -IPIV(K) THEN K-1 and -IPIV(K-1)
+            # The first interchange is only needed when rook pivoting is used
+            if rook; Base.swaprows!(B, k, -kp); end
+            kx = knext(k)
+            Base.swaprows!(B, kx, -ipiv[kx])
+            #   Multiply by inv(U(K)), where U(K) is the transformation
+            #   stored in columns K-1 and K of A.
+            Aview = upper ? view(A, 1:(k-2), k) : view(A, (k+2):N, k)
+            Bview = upper ? B : view(B, (k+2):N, :)
+            generic_adr1!('F', -R1, Aview, view(B, k, :), Bview, 'S')
+            Aview = upper ? view(A, 1:(k-2), kx) : view(A, (k+2):N, kx)
+            generic_adr1!('F', -R1, Aview, view(B, kx, :), Bview, 'S')
+            #   Multiply by the inverse of the diagonal block.
+            axk = A[kx,k]
+            axx = A[kx,kx] / axk
+            akk = A[k,k] / adj_op(axk)
+            denom = axx*akk - 1
+            for j in 1:M
+                bx = B[kx,j] / axk
+                bk = B[k,j] / adj_op(axk)
+                B[kx,j] = (akk*bx - bk) / denom
+                B[k,j] = (axx*bk - bx) / denom
+            end
+            if upper; k -= 2; else; k += 2; end
+        end
+    end; end
+    #   Next solve U'*X = B, overwriting B with X.
+    #   K is the main loop index, increasing from 1 to N in steps of
+    #   1 or 2, depending on the size of the diagonal blocks.
+    k = upper ? 1 : N
+    while kcond2(k); @inbounds begin
+        Aview = upper ? view(A, 1:(k-1), k) : view(A, (k+1):N, k)
+        Bview = upper ? view(B, 1:(k-1), :) : view(B, (k+1):N, :)
+        B_row = view(B, k, :)
+        kp = ipiv[k]
+        if kp > 0
+            #   1 x 1 diagonal block
+            #   Multiply by inv(U**T(K)), where U(K) is the transformation
+            #   stored in column K of A.
+            if symm
+                generic_mvpv!('T', -R1, Bview, Aview, R1, B_row)
+            else
+                conj!(B_row)
+                generic_mvpv!('C', -R1, Bview, Aview, R1, B_row)
+                conj!(B_row)
+            end
+            #   Interchange rows K and IPIV(K).
+            Base.swaprows!(B, k, kp)
+            if upper; k += 1; else; k -= 1; end
+        else
+            #   2 x 2 diagonal block
+            #   Multiply by inv(U**T(K+1)), where U(K+1) is the transformation
+            #   stored in columns K and K+1 of A.
+            kx = knext2(k)
+            if symm
+                generic_mvpv!('T', -R1, Bview, Aview, R1, B_row)
+                Aview = upper ? view(A, 1:(k-1), kx) : view(A, (k+1):N, kx)
+                B_row = view(B, kx, :)
+                generic_mvpv!('T', -R1, Bview, Aview, R1, B_row)
+            elseif k > 1
+                conj!(B_row)
+                generic_mvpv!('C', -R1, Bview, Aview, R1, B_row)
+                conj!(B_row)
+                Aview = upper ? view(A, 1:(k-1), kx) : view(A, (k+1):N, kx)
+                B_row = view(B, kx, :)
+                conj!(B_row)
+                generic_mvpv!('C', -R1, Bview, Aview, R1, B_row)
+                conj!(B_row)
+            end
+            #   Interchange rows K and -IPIV(K) THEN K+1 and -IPIV(K+1).
+            # The second interchange is only needed when rook pivoting is used
+            Base.swaprows!(B, k, -kp)
+            if rook; Base.swaprows!(B, kx, -ipiv[kx]); end
+            if upper; k += 2; else; k -= 2; end
+        end
+    end; end
+    return B
+end
+
+
+"""
+inertia(B::BunchKaufman; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ) ->
+    np::Union{Nothing,Integer}, nn::Union{Nothing,Integer}, nz::Integer
+
+`inertia` computes the numerical inertia (the number of positive,
+negative and zero eigenvalues, given by `np`, `nn` and `nz`,
+respectively) of a real symmetric of Hermitian matrix `B` that has been
+factored using the Bunch-Kaufman algorithm. For complex symmetric
+matrices the inertia is not defined. in that case `np` and `nn` are set
+to `nothing`, but the function still returns the number of zero
+eigenvalues. The inertia is computed by counting the eigenvalues signs
+of `B.D`. The number of zero eigenvalues is computed as the number of
+estimated eigenvalues with complex 1-norm (defined as `|re(.)|+|im(.)|`)
+less or equal than `max(atol, rtol*s₁)`, where `s₁` is an upper bound of
+the largest singular value of `B.D`, `σ₁` (more specifically,
+`0.5*s₁ <= σ₁ <= s₁` for real matrices and `0.35*s₁ <= σ₁ <= s₁` for
+complex matrices). `atol` and `rtol` are the absolute and relative
+tolerances, respectively. The default relative tolerance is `n*ϵ`, where
+`n` is the size of  of `A`, and `ϵ` is the [`eps`](@ref) of the number
+type of `A`, if this type is a subtype of `AbstractFloat`. In any other
+case (if the number type of `A` is `Rational`, for example) `ϵ` is set
+to `0`.
+
+!!! note
+    Numerical inertia can be a sensitive and imprecise characterization of
+    ill-conditioned matrices with eigenvalues that are close in magnitude to the
+    threshold tolerance `max(atol, rtol*s₁)`. In such cases, slight perturbations
+    to the Bunch-Kaufman computation or to the matrix can change the result of
+    `rank` by pushing one or more eigenvalues across the threshold. These
+    variations can even occur due to changes in floating-point errors between
+    different Julia versions, architectures, compilers, or operating systems.
+    In particular, the size of the entries of the tringular factor directly
+    influende the scale of the eigenvalues of the diagonal factor, so it is
+    strongly recommended to use rook pivoting is the inertia is going to be
+    computed.
+    On the other hand, if the matrix has rational entries, the inertia
+    computation is guaranteed is to be exact, as long as there is no
+    under/overflow in the underlying integer type (and in such cases Julia itself
+    throws an error), or a positive tolerance (absolute or relative) is
+    specified.
+"""
+function inertia(B::BunchKaufman{TS};
+    atol::TR = TR(0),
+    rtol::TR = TR(0)
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+
+    # Check if matrix is complex symmetric
+    get_inertia = !(issymmetric(B) && TS <: Complex)
+
+    # Initialize outputs
+    np, nn, nz = get_inertia ? (0, 0, 0) : (nothing, nothing, 0)
+
+    # Compute matrix size
+    N = size(B, 1)
+
+    # Quick return if possible
+    if N == 0; return np, nn, nz; end
+
+    # Compute default relative tolerance
+    if rtol <= 0 && atol <= 0
+        rtol = TR <: AbstractFloat ? (N * eps(TR)) : TR(0)
+    end
+
+    # We use the complex 1-norm for complex matrices
+    real_matrix = (TS <: Real)
+    abs1_fun = real_matrix ? abs : cabs1
+    real_fun = real_matrix ? identity : real
+
+    # Check if we must track the largest singular value
+    get_s1 = (rtol > 0)
+
+    # Constant for lower bound estimation of the smallest eigenvalue in 2x2 blocks.
+    # The best (largest) value for complex matrices is 1/sqrt(2), but for rational
+    # matrices we use the small denominator approximation 12/17, in order to not
+    # increase the denominator size too much in computations. The error of this
+    # approximation is ≤0.2%, and we still get a valid lower bound.
+    c = real_matrix ? TR(1) : (TR <: AbstractFloat ? 1/sqrt(TR(2)) : TR(12//17))
+
+    # First pass, estimate largest singular value and group together size-1 blocks
+    D = B.D
+    s1 = TR(0)
+    i = 1
+    while i <= N; @inbounds begin
+        if i < N && D[i,i+1] != 0
+            # 2x2 block
+            # The largest singular value of a 2x2 matrix is between [1, 2] times
+            # its complex max-norm, which is between [c, 1] times the largest
+            # complex 1-norm among the entries of the 2x2 matrix. See "Roger
+            # Horn and Charles Johnson. Matrix Analysis, 2nd Edition, 5.6.P23".
+            abs_Dii = abs1_fun(D[i,i])
+            abs_Dxx = abs1_fun(D[i+1,i+1])
+            s1_block = 2 * max(abs_Dii, abs1_fun(D[i,i+1]), abs_Dxx)
+            if get_s1; s1 = max(s1, s1_block); end
+            # Lower bound on the smallest eigenvalue complex 2-norm is
+            # abs(λ₂) ≥ abs(det(block)) / s1_block
+            # so the bound in terms of the complex 1-norm becomes
+            # abs1_fun(λ₂) ≥ c * abs1_fun(det(block)) / s1_block
+            # For rational matrices, if λ₂=0 then det(block)=0 and then the bound
+            # becomes zero too. If λ₁=0 too then the block has all zero entries
+            # and 's1_block'=0, but 'D[i,i+1]' != 0 and so 's1_block' > 0. However, we
+            # may still have that 'smin_block'≈0, then the value of 'smin_block' may not
+            # be accurate. In that case the counting routine will detect that both
+            # eigenvalues are zero without using 'smin_block', so it doesn't matter.
+            # TODO: is this the most numerically stable way to compute the determinant?
+            # TODO: is this the best way to avoid under/overflow?
+            if abs_Dii >= abs_Dxx
+                smin_block = c * abs1_fun((D[i,i]/s1_block)*D[i+1,i+1] -
+                    (D[i,i+1]/s1_block)*D[i+1,i])
+            else
+                smin_block = c * abs1_fun(D[i,i]*(D[i+1,i+1]/s1_block) -
+                    (D[i,i+1]/s1_block)*D[i+1,i])
+            end
+            # Store lower bound in-place in the lower off-diagonal and upper bound
+            # in-place in the upper off-diagonal. The trace is stored in the first
+            # diagonal entry block, but only if the full inertia is needed.
+            D[i,i+1] = s1_block
+            D[i+1,i] = smin_block
+            if get_inertia; D[i,i] += D[i+1,i+1]; end
+            i += 2
+        else
+            # 1x1 block
+            if get_s1; s1 = max(s1, abs1_fun(D[i,i])); end
+            i += 1
+        end
+    end; end
+
+    # Second pass, count eigenvalue signs
+    tol = max(atol, rtol * s1)
+    i = 1
+    while i <= N; @inbounds begin
+        if i < N && D[i,i+1] != 0
+            # 2x2 block. For the counting of zero eigenvalues we use the lower bound on the
+            # eigenvalues' magnitude. This way, if an eigenvalue is deemed non-zero, then
+            # it is guaranteed that its magnitude is greater than the tolerance.
+            s1_block = real_fun(D[i,i+1])
+            if (c / 2) * s1_block <= tol
+                # Lower bound of largest eigenvalue is smaller than the tolerance,
+                # we consider the both eigenvalues of this block to be zero.
+                nz += 2
+                i += 2
+                continue
+            end
+            # Reaching this part of the lopp implies that 's1_block' != 0.
+            smin_block = real_fun(D[i+1,i])
+            trace_block = real_fun(D[i,i])
+            if smin_block > tol || trace_block == 0
+                # If first condition holds then the lower bound of the smallest eigenvalue
+                # is larger than the tolerance. If the second condition holds then the trace
+                # is exactly zero, so both eigenvalues have the same magnitude, and we
+                # already know that the largest one is non-zero. In any case we conclude
+                # that both eigenvalues are non-zero.
+                if get_inertia
+                    # The eigenvalues of a 2x2 block are guaranteed to be a
+                    # positive-negative pair.
+                    np += 1
+                    nn += 1
+                end
+            else
+                # The lower bound of smallest eigenvalue is smaller than the tolerance and
+                # the trace is non-zero, so we consider the smallest eigenvalues of this
+                # block to be zero.
+                nz += 1
+                if get_inertia
+                    # The trace is non-zero, and its sign is the same of the largest
+                    # eigenvalue.
+                    if trace_block >= 0
+                        np += 1
+                    else
+                        nn += 1
+                    end
+                end
+            end
+            i += 2
+        else
+            # 1x1 block
+            if get_inertia
+                eig = real_fun(D[i,i])
+                if eig > tol
+                    np += 1
+                elseif eig < -tol
+                    nn += 1
+                else
+                    nz += 1
+                end
+            elseif abs1_fun(D[i,i]) <= tol
+                nz += 1
+            end
+            i += 1
+        end
+    end; end
+
+    return np, nn, nz
+end
+
+
+"""
+    bunchkaufman_native!(A, rook::Bool=false; check = true) -> BunchKaufman
+
+`bunchkaufman_native!` is the same as [`bunchkaufman!`](@ref), but it performs
+the factorization in native Julia code instead of calling LAPACK.
+"""
+function bunchkaufman_native!(A::AbstractMatrix{TS},
+    rook::Bool = false;
+    check::Bool = true,
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+    if A isa RealHermSymComplexSym{TR}
+        syhe = 'S'
+    elseif ishermitian(A)
+        syhe = 'H'
+    elseif issymmetric(A)
+        syhe = 'S'
+    else
+        throw(ArgumentError("Bunch-Kaufman decomposition is only valid for " *
+            "symmetric or Hermitian matrices"))
+    end
+    if A isa HermOrSym
+        Adata = A.data
+        uplo = A.uplo
+    else
+        Adata = A
+        uplo = 'U'
+    end
+    LD, ipiv, info = generic_bunchkaufman!(uplo, Adata, syhe, rook)
+    check && checknonsingular(info)
+    return BunchKaufman(LD, ipiv, uplo, syhe == 'S', rook, info)
+end
+
+
+"""
+Overload 'bunchkaufman.jl' methods through multiple dispatch
+"""
+
+function bunchkaufman!(A::AbstractMatrix{TS},
+    rook::Bool = false;
+    check::Bool = true
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+    return bunchkaufman_native!(A, rook; check)
+end
+
+function bunchkaufman(A::AbstractMatrix{TS},
+    rook::Bool = false;
+    check::Bool = true
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+    return bunchkaufman!(eigencopy_oftype(A, TS), rook; check)
+end
+
+function bunchkaufman(A::AbstractMatrix{TS},
+    rook::Bool = false;
+    check::Bool = true
+    ) where TS <:Union{TI, Complex{TI}} where TI <: Integer
+
+    # Identity whether matrix is symmetric or Hermitian or none
+    if A isa Symmetric
+        TA = Symmetric
+    elseif A isa Hermitian
+        TA = Hermitian
+    else
+        TA = Nothing
+    end
+
+    # Create a rational copy of input integer matrix, as the Bunch-Kaufman
+    # algorithm is closed over the rationals but not over the integers.
+    # We promote input to BigInt to avoid overflow problems
+    if TA == Nothing
+        if TS <: Integer
+            M = Rational{BigInt}.(eigencopy_oftype(A, TS))
+        else
+            M = Complex{Rational{BigInt}}.(eigencopy_oftype(A, TS))
+        end
+    else
+        if TS <: Integer
+            M = TA(Rational{BigInt}.(eigencopy_oftype(A, TS)), Symbol(A.uplo))
+        else
+            M = TA(Complex{Rational{BigInt}}.(eigencopy_oftype(A, TS)),
+                Symbol(A.uplo))
+        end
+    end
+
+    return bunchkaufman_native!(M, rook; check)
+end
+
+function ldiv!(B::BunchKaufman{TS},
+    R::AbstractVecOrMat{TS}
+    ) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+    return generic_bksolve!(B, R)
+end
+
+function inv(B::BunchKaufman{TS}) where TS <: ClosedScalar{TR} where TR <: ClosedReal
+    # I don't think there's value in implementing tha LAPACK in-place inverse
+    # functions `dsytri`, `chetri`, etc., unless of course an efficient
+    # in-place inverse function `inv!` is needed.
+    # TODO: reduce the operation count of the inverse by not computing the
+    # lower/upper triangular part.
+    if issymmetric(B)
+        return copytri!(B \ I, B.uplo)
+    else
+        return copytri!(B \ I, B.uplo, true)
+    end
+end
diff --git a/stdlib/LinearAlgebra/test/bunchkaufman.jl b/stdlib/LinearAlgebra/test/bunchkaufman.jl
index 613e4d09a3cc6..d2305844db63e 100644
--- a/stdlib/LinearAlgebra/test/bunchkaufman.jl
+++ b/stdlib/LinearAlgebra/test/bunchkaufman.jl
@@ -21,9 +21,24 @@ a2img  = randn(n,n)/2
 breal = randn(n,2)/2
 bimg  = randn(n,2)/2
 
-@testset "$eltya argument A" for eltya in (Float32, Float64, ComplexF32, ComplexF64, Int)
-    a = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex.(areal, aimg) : areal)
-    a2 = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex.(a2real, a2img) : a2real)
+areint = rand(1:7, n, n)
+aimint = rand(1:7, n, n)
+a2reint = rand(1:7, n, n)
+a2imint = rand(1:7, n, n)
+breint = rand(1:5, n, 2)
+bimint = rand(1:5, n, 2)
+
+@testset "$eltya argument A" for eltya in (Float32, Float64, ComplexF32, ComplexF64, Int, ###
+    Float16, Complex{Float16}, BigFloat, Complex{BigFloat}, Complex{Int}, BigInt,
+    Complex{BigInt}, Rational{BigInt}, Complex{Rational{BigInt}})
+    # a = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex.(areal, aimg) : areal)
+    # a2 = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex.(a2real, a2img) : a2real)
+    a = convert(Matrix{eltya}, eltya <: Complex ? (real(eltya) <: AbstractFloat ?
+        complex.(areal, aimg) : complex.(areint, aimint)) : (eltya <: AbstractFloat ?
+        areal : areint))
+    a2 = convert(Matrix{eltya}, eltya <: Complex ? (real(eltya) <: AbstractFloat ?
+        complex.(a2real, a2img) : complex.(a2reint, a2imint)) : (eltya <: AbstractFloat ?
+        a2real : a2reint))
     asym = transpose(a) + a                  # symmetric indefinite
     aher = a' + a                  # Hermitian indefinite
     apd  = a' * a                  # Positive-definite
@@ -34,9 +49,39 @@ bimg  = randn(n,2)/2
                                 view(apd , 1:n, 1:n)))
         ε = εa = eps(abs(float(one(eltya))))
 
+        # Inertia tests
+        @testset "$uplo Bunch-Kaufman factor inertia" for uplo in (:L, :U)
+            @testset "rook pivoting: $rook" for rook in (false, true)
+                test_list = eltya <: Complex ? (Hermitian(aher, uplo), Hermitian(apd, uplo)) :
+                    (Symmetric(transpose(a) + a, uplo), Hermitian(aher, uplo),
+                Hermitian(apd, uplo))
+                ελ = n*max(eps(Float64), εa) # zero-eigenvalue threshold
+                ελ = typeof(Integer(one(real(eltya)))) <: Signed ? Rational{BigInt}(ελ) :
+                    real(eltya(ελ))
+                for M in test_list
+                    bc = bunchkaufman(M, rook)
+                    D = bc.D
+                    λ = real(eltya <: Complex ? eigen(ComplexF64.(D)).values :
+                        eigen(Float64.(D)).values)
+                    σ₁ = norm(λ, Inf)
+                    np = sum(λ .> ελ*σ₁)
+                    nn = sum(λ .< -ελ*σ₁)
+                    nz = n - np - nn
+                    if real(eltya) <: AbstractFloat
+                        @test inertia(bc) == (np, nn, nz)
+                    else
+                        @test inertia(bc; rtol=ελ) == (np, nn, nz)
+                    end
+                end
+            end
+        end
+
         # check that factorize gives a Bunch-Kaufman
-        @test isa(factorize(asym), LinearAlgebra.BunchKaufman)
-        @test isa(factorize(aher), LinearAlgebra.BunchKaufman)
+        if eltya <: Union{Float32, Float64, ComplexF32, ComplexF64, Int}
+            # Default behaviour only uses Bunch-Kaufman for these types, for now.
+            @test isa(factorize(asym), LinearAlgebra.BunchKaufman)
+            @test isa(factorize(aher), LinearAlgebra.BunchKaufman)
+        end
         @testset "$uplo Bunch-Kaufman factor of indefinite matrix" for uplo in (:L, :U)
             bc1 = bunchkaufman(Hermitian(aher, uplo))
             @test LinearAlgebra.issuccess(bc1)
@@ -89,15 +134,25 @@ bimg  = randn(n,2)/2
             @test Base.propertynames(bc1) == (:p, :P, :L, :U, :D)
         end
 
-        @testset "$eltyb argument B" for eltyb in (Float32, Float64, ComplexF32, ComplexF64, Int)
-            b = eltyb == Int ? rand(1:5, n, 2) : convert(Matrix{eltyb}, eltyb <: Complex ? complex.(breal, bimg) : breal)
+        @testset "$eltyb argument B" for eltyb in (Float32, Float64, ComplexF32, ComplexF64, Int, ###
+            Float16, Complex{Float16}, BigFloat, Complex{BigFloat}, Complex{Int}, BigInt,
+            Complex{BigInt}, Rational{BigInt}, Complex{Rational{BigInt}})
+            # b = eltyb == Int ? rand(1:5, n, 2) : convert(Matrix{eltyb}, eltyb <: Complex ? complex.(breal, bimg) : breal)
+            b = convert(Matrix{eltyb}, eltyb <: Complex ? (real(eltyb) <: AbstractFloat ?
+                complex.(breal, bimg) : complex.(breint, bimint)) : (eltyb <: AbstractFloat ?
+                breal : breint))
             for b in (b, view(b, 1:n, 1:2))
                 εb = eps(abs(float(one(eltyb))))
                 ε = max(εa,εb)
+                epsc = eltya <: Complex ? sqrt(2)*n : n # tolerance scale
 
                 @testset "$uplo Bunch-Kaufman factor of indefinite matrix" for uplo in (:L, :U)
                     bc1 = bunchkaufman(Hermitian(aher, uplo))
-                    @test aher*(bc1\b) ≈ b atol=1000ε
+                    # @test aher*(bc1\b) ≈ b atol=1000ε
+                    cda = eltya <: Complex ? cond(ComplexF64.(aher)) : cond(Float64.(aher))
+                    cda = real(eltya) <: AbstractFloat ? real(eltya(cda)) : cda
+                    @test norm(aher*(bc1\b) - b) <= epsc*sqrt(eps(cda))*max(
+                            norm(aher*(bc1\b)), norm(b))
                 end
 
                 @testset "$uplo Bunch-Kaufman factors of a pos-def matrix" for uplo in (:U, :L)
@@ -112,8 +167,14 @@ bimg  = randn(n,2)/2
                         @test logdet(bc2) ≈ log(det(bc2))
                         @test logabsdet(bc2)[1] ≈ log(abs(det(bc2)))
                         @test logabsdet(bc2)[2] == sign(det(bc2))
-                        @test inv(bc2)*apd ≈ Matrix(I, n, n)
-                        @test apd*(bc2\b) ≈ b rtol=eps(cond(apd))
+                        # @test inv(bc2)*apd ≈ Matrix(I, n, n) rtol=Base.rtoldefault(real(eltya))
+                        # @test apd*(bc2\b) ≈ b rtol=eps(cond(apd))
+                        @test norm(inv(bc2)*apd - Matrix(I, n, n)) <= epsc*Base.rtoldefault(
+                            real(eltya))*max(norm(inv(bc2)*apd), norm(Matrix(I, n, n)))
+                        cda = eltya <: Complex ? cond(ComplexF64.(apd)) : cond(Float64.(apd))
+                        cda = real(eltya) <: AbstractFloat ? real(eltya(cda)) : cda
+                        @test norm(apd*(bc2\b) - b) <= epsc*sqrt(eps(cda))*max(
+                            norm(apd*(bc2\b)), norm(b))
                         @test ishermitian(bc2)
                         @test !issymmetric(bc2) || eltya <: Real
                     end

From 2091058c5a2be7b70f3cad0cf1ce0ea7391863b0 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Sat, 30 Dec 2023 20:20:28 +0800
Subject: [PATCH 0512/1315] Fix :noshift construction of an empty SubString
 (#51923)

---
 base/strings/substring.jl | 2 +-
 test/strings/basic.jl     | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/base/strings/substring.jl b/base/strings/substring.jl
index dfd8770b08d47..ffa78c00cb885 100644
--- a/base/strings/substring.jl
+++ b/base/strings/substring.jl
@@ -37,7 +37,7 @@ struct SubString{T<:AbstractString} <: AbstractString
         return new(s, i-1, nextind(s,j)-i)
     end
     function SubString{T}(s::T, i::Int, j::Int, ::Val{:noshift}) where T<:AbstractString
-        @boundscheck begin
+        @boundscheck if !(i == j == 0)
             si, sj = i + 1, prevind(s, j + i + 1)
             @inbounds isvalid(s, si) || string_index_err(s, si)
             @inbounds isvalid(s, sj) || string_index_err(s, sj)
diff --git a/test/strings/basic.jl b/test/strings/basic.jl
index 225a41bf12be9..87d812c5bf201 100644
--- a/test/strings/basic.jl
+++ b/test/strings/basic.jl
@@ -203,6 +203,12 @@ end
         @test (@views (x[3], x[1:2], x[[1,4]])) isa Tuple{Char, SubString, String}
         @test (@views (x[3], x[1:2], x[[1,4]])) == ('c', "ab", "ad")
     end
+
+    @testset ":noshift constructor" begin
+        @test SubString("", 0, 0, Val(:noshift)) == ""
+        @test SubString("abcd", 0, 1, Val(:noshift)) == "a"
+        @test SubString("abcd", 0, 4, Val(:noshift)) == "abcd"
+    end
 end
 
 

From fe0db7d9474781ee949c7927f806214c7fc00a9a Mon Sep 17 00:00:00 2001
From: Jian Fang <131804380+JianFangAtRai@users.noreply.github.com>
Date: Sat, 30 Dec 2023 06:46:53 -0800
Subject: [PATCH 0513/1315] heap snapshot: add gc roots and gc finalist roots
 to fix unrooted nodes (#52618)

---
 src/gc-heap-snapshot.cpp | 124 +++++++++++++++++++++++++++++++--------
 src/gc-heap-snapshot.h   |  33 +++++++++--
 src/gc.c                 |  33 +++++++++--
 src/gc.h                 |   2 +-
 4 files changed, 157 insertions(+), 35 deletions(-)

diff --git a/src/gc-heap-snapshot.cpp b/src/gc-heap-snapshot.cpp
index 1875a22f64ff6..24df141d053f4 100644
--- a/src/gc-heap-snapshot.cpp
+++ b/src/gc-heap-snapshot.cpp
@@ -3,6 +3,7 @@
 #include "gc-heap-snapshot.h"
 
 #include "julia_internal.h"
+#include "julia_assert.h"
 #include "gc.h"
 
 #include "llvm/ADT/SmallVector.h"
@@ -12,8 +13,11 @@
 #include <vector>
 #include <string>
 #include <sstream>
+#include <iostream>
+#include <set>
 
 using std::string;
+using std::set;
 using std::ostringstream;
 using std::pair;
 using std::make_pair;
@@ -116,6 +120,8 @@ struct HeapSnapshot {
     DenseMap<void *, size_t> node_ptr_to_index_map;
 
     size_t num_edges = 0; // For metadata, updated as you add each edge. Needed because edges owned by nodes.
+    size_t _gc_root_idx = 1; // node index of the GC roots node
+    size_t _gc_finlist_root_idx = 2; // node index of the GC finlist roots node
 };
 
 // global heap snapshot, mutated by garbage collector
@@ -128,13 +134,13 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one
 static inline void _record_gc_edge(const char *edge_type,
                                    jl_value_t *a, jl_value_t *b, size_t name_or_index) JL_NOTSAFEPOINT;
 void _record_gc_just_edge(const char *edge_type, Node &from_node, size_t to_idx, size_t name_or_idx) JL_NOTSAFEPOINT;
-void _add_internal_root(HeapSnapshot *snapshot);
+void _add_synthetic_root_entries(HeapSnapshot *snapshot);
 
 
 JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one)
 {
     HeapSnapshot snapshot;
-    _add_internal_root(&snapshot);
+    _add_synthetic_root_entries(&snapshot);
 
     jl_mutex_lock(&heapsnapshot_lock);
 
@@ -156,10 +162,12 @@ JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one)
     serialize_heap_snapshot((ios_t*)stream, snapshot, all_one);
 }
 
-// adds a node at id 0 which is the "uber root":
-// a synthetic node which points to all the GC roots.
-void _add_internal_root(HeapSnapshot *snapshot)
+// mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L212
+// add synthetic nodes for the uber root, the GC roots, and the GC finalizer list roots
+void _add_synthetic_root_entries(HeapSnapshot *snapshot)
 {
+    // adds a node at id 0 which is the "uber root":
+    // a synthetic node which points to all the GC roots.
     Node internal_root{
         snapshot->node_types.find_or_create_string_id("synthetic"),
         snapshot->names.find_or_create_string_id(""), // name
@@ -170,6 +178,44 @@ void _add_internal_root(HeapSnapshot *snapshot)
         SmallVector<Edge, 0>() // outgoing edges
     };
     snapshot->nodes.push_back(internal_root);
+
+    // Add a node for the GC roots
+    snapshot->_gc_root_idx = snapshot->nodes.size();
+    Node gc_roots{
+        snapshot->node_types.find_or_create_string_id("synthetic"),
+        snapshot->names.find_or_create_string_id("GC roots"), // name
+        snapshot->_gc_root_idx, // id
+        0, // size
+        0, // size_t trace_node_id (unused)
+        0, // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
+        SmallVector<Edge, 0>() // outgoing edges
+    };
+    snapshot->nodes.push_back(gc_roots);
+    snapshot->nodes.front().edges.push_back(Edge{
+        snapshot->edge_types.find_or_create_string_id("internal"),
+        snapshot->names.find_or_create_string_id("GC roots"), // edge label
+        snapshot->_gc_root_idx // to
+    });
+    snapshot->num_edges += 1;
+
+    // add a node for the gc finalizer list roots
+    snapshot->_gc_finlist_root_idx = snapshot->nodes.size();
+    Node gc_finlist_roots{
+        snapshot->node_types.find_or_create_string_id("synthetic"),
+        snapshot->names.find_or_create_string_id("GC finalizer list roots"), // name
+        snapshot->_gc_finlist_root_idx, // id
+        0, // size
+        0, // size_t trace_node_id (unused)
+        0, // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
+        SmallVector<Edge, 0>() // outgoing edges
+    };
+    snapshot->nodes.push_back(gc_finlist_roots);
+    snapshot->nodes.front().edges.push_back(Edge{
+        snapshot->edge_types.find_or_create_string_id("internal"),
+        snapshot->names.find_or_create_string_id("GC finlist roots"), // edge label
+        snapshot->_gc_finlist_root_idx // to
+    });
+    snapshot->num_edges += 1;
 }
 
 // mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L597-L597
@@ -327,6 +373,26 @@ void _gc_heap_snapshot_record_root(jl_value_t *root, char *name) JL_NOTSAFEPOINT
     _record_gc_just_edge("internal", internal_root, to_node_idx, edge_label);
 }
 
+void _gc_heap_snapshot_record_gc_roots(jl_value_t *root, char *name) JL_NOTSAFEPOINT
+{
+    record_node_to_gc_snapshot(root);
+
+    auto from_node_idx = g_snapshot->_gc_root_idx;
+    auto to_node_idx = record_node_to_gc_snapshot(root);
+    auto edge_label = g_snapshot->names.find_or_create_string_id(name);
+    _record_gc_just_edge("internal", g_snapshot->nodes[from_node_idx], to_node_idx, edge_label);
+}
+
+void _gc_heap_snapshot_record_finlist(jl_value_t *obj, size_t index) JL_NOTSAFEPOINT
+{
+    auto from_node_idx = g_snapshot->_gc_finlist_root_idx;
+    auto to_node_idx = record_node_to_gc_snapshot(obj);
+    ostringstream ss;
+    ss << "finlist-" << index;
+    auto edge_label = g_snapshot->names.find_or_create_string_id(ss.str());
+    _record_gc_just_edge("internal", g_snapshot->nodes[from_node_idx], to_node_idx, edge_label);
+}
+
 // Add a node to the heap snapshot representing a Julia stack frame.
 // Each task points at a stack frame, which points at the stack frame of
 // the function it's currently calling, forming a linked list.
@@ -393,27 +459,19 @@ void _gc_heap_snapshot_record_object_edge(jl_value_t *from, jl_value_t *to, void
                     g_snapshot->names.find_or_create_string_id(path));
 }
 
-void _gc_heap_snapshot_record_module_to_binding(jl_module_t *module, jl_binding_t *binding) JL_NOTSAFEPOINT
+void _gc_heap_snapshot_record_module_to_binding(jl_module_t *module, jl_value_t *bindings, jl_value_t *bindingkeyset) JL_NOTSAFEPOINT
 {
-    jl_globalref_t *globalref = binding->globalref;
-    jl_sym_t *name = globalref->name;
     auto from_node_idx = record_node_to_gc_snapshot((jl_value_t*)module);
-    auto to_node_idx = record_pointer_to_gc_snapshot(binding, sizeof(jl_binding_t), jl_symbol_name(name));
-
-    jl_value_t *value = jl_atomic_load_relaxed(&binding->value);
-    auto value_idx = value ? record_node_to_gc_snapshot(value) : 0;
-    jl_value_t *ty = jl_atomic_load_relaxed(&binding->ty);
-    auto ty_idx = ty ? record_node_to_gc_snapshot(ty) : 0;
-    auto globalref_idx = record_node_to_gc_snapshot((jl_value_t*)globalref);
-
+    auto to_bindings_idx = record_node_to_gc_snapshot(bindings);
+    auto to_bindingkeyset_idx = record_node_to_gc_snapshot(bindingkeyset);
     auto &from_node = g_snapshot->nodes[from_node_idx];
-    auto &to_node = g_snapshot->nodes[to_node_idx];
-
-    _record_gc_just_edge("property", from_node, to_node_idx, g_snapshot->names.find_or_create_string_id("<native>"));
-    if (value_idx)     _record_gc_just_edge("internal", to_node, value_idx, g_snapshot->names.find_or_create_string_id("value"));
-    if (ty_idx)        _record_gc_just_edge("internal", to_node, ty_idx, g_snapshot->names.find_or_create_string_id("ty"));
-    if (globalref_idx) _record_gc_just_edge("internal", to_node, globalref_idx, g_snapshot->names.find_or_create_string_id("globalref"));
-}
+    if (to_bindings_idx > 0) {
+        _record_gc_just_edge("internal", from_node, to_bindings_idx, g_snapshot->names.find_or_create_string_id("bindings"));
+    }
+    if (to_bindingkeyset_idx > 0) {
+        _record_gc_just_edge("internal", from_node, to_bindingkeyset_idx, g_snapshot->names.find_or_create_string_id("bindingkeyset"));
+    }
+ }
 
 void _gc_heap_snapshot_record_internal_array_edge(jl_value_t *from, jl_value_t *to) JL_NOTSAFEPOINT
 {
@@ -492,6 +550,8 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one
 
     ios_printf(stream, "\"nodes\":[");
     bool first_node = true;
+    // use a set to track the nodes that do not have parents
+    set<size_t> orphans;
     for (const auto &from_node : snapshot.nodes) {
         if (first_node) {
             first_node = false;
@@ -508,6 +568,14 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one
                             from_node.edges.size(),
                             from_node.trace_node_id,
                             from_node.detachedness);
+        if (from_node.id != snapshot._gc_root_idx && from_node.id != snapshot._gc_finlist_root_idx) {
+            // find the node index from the node object pointer
+            void * ptr = (void*)from_node.id;
+            size_t n_id = snapshot.node_ptr_to_index_map[ptr];
+            orphans.insert(n_id);
+        } else {
+            orphans.insert(from_node.id);
+        }
     }
     ios_printf(stream, "],\n");
 
@@ -525,6 +593,12 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one
                                 edge.type,
                                 edge.name_or_index,
                                 edge.to_node * k_node_number_of_fields);
+            auto n_id = edge.to_node;
+            auto it = orphans.find(n_id);
+            if (it != orphans.end()) {
+                // remove the node from the orphans if it has at least one incoming edge
+                orphans.erase(it);
+            }
         }
     }
     ios_printf(stream, "],\n"); // end "edges"
@@ -534,4 +608,8 @@ void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one
     snapshot.names.print_json_array(stream, true);
 
     ios_printf(stream, "}");
+
+    // remove the uber node from the orphans
+    orphans.erase(0);
+    assert(orphans.size() == 0 && "all nodes except the uber node should have at least one incoming edge");
 }
diff --git a/src/gc-heap-snapshot.h b/src/gc-heap-snapshot.h
index 8c3af5b86bec7..1799063825e83 100644
--- a/src/gc-heap-snapshot.h
+++ b/src/gc-heap-snapshot.h
@@ -20,7 +20,7 @@ void _gc_heap_snapshot_record_task_to_frame_edge(jl_task_t *from, void *to) JL_N
 void _gc_heap_snapshot_record_frame_to_frame_edge(jl_gcframe_t *from, jl_gcframe_t *to) JL_NOTSAFEPOINT;
 void _gc_heap_snapshot_record_array_edge(jl_value_t *from, jl_value_t *to, size_t index) JL_NOTSAFEPOINT;
 void _gc_heap_snapshot_record_object_edge(jl_value_t *from, jl_value_t *to, void* slot) JL_NOTSAFEPOINT;
-void _gc_heap_snapshot_record_module_to_binding(jl_module_t* module, jl_binding_t* binding) JL_NOTSAFEPOINT;
+void _gc_heap_snapshot_record_module_to_binding(jl_module_t* module, jl_value_t *bindings, jl_value_t *bindingkeyset) JL_NOTSAFEPOINT;
 // Used for objects managed by GC, but which aren't exposed in the julia object, so have no
 // field or index.  i.e. they're not reachable from julia code, but we _will_ hit them in
 // the GC mark phase (so we can check their type tag to get the size).
@@ -28,7 +28,10 @@ void _gc_heap_snapshot_record_internal_array_edge(jl_value_t *from, jl_value_t *
 // Used for objects manually allocated in C (outside julia GC), to still tell the heap snapshot about the
 // size of the object, even though we're never going to mark that object.
 void _gc_heap_snapshot_record_hidden_edge(jl_value_t *from, void* to, size_t bytes, uint16_t alloc_type) JL_NOTSAFEPOINT;
-
+// Used for objects that are reachable from the GC roots
+void _gc_heap_snapshot_record_gc_roots(jl_value_t *root, char *name) JL_NOTSAFEPOINT;
+// Used for objects that are reachable from the finalizer list
+void _gc_heap_snapshot_record_finlist(jl_value_t *finlist, size_t index) JL_NOTSAFEPOINT;
 
 extern int gc_heap_snapshot_enabled;
 extern int prev_sweep_full;
@@ -60,6 +63,12 @@ static inline void gc_heap_snapshot_record_root(jl_value_t *root, char *name) JL
         _gc_heap_snapshot_record_root(root, name);
     }
 }
+static inline void gc_heap_snapshot_record_array_edge_index(jl_value_t *from, jl_value_t *to, size_t index) JL_NOTSAFEPOINT
+{
+    if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full && from != NULL && to != NULL)) {
+        _gc_heap_snapshot_record_array_edge(from, to, index);
+    }
+}
 static inline void gc_heap_snapshot_record_array_edge(jl_value_t *from, jl_value_t **to) JL_NOTSAFEPOINT
 {
     if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full)) {
@@ -73,10 +82,10 @@ static inline void gc_heap_snapshot_record_object_edge(jl_value_t *from, jl_valu
     }
 }
 
-static inline void gc_heap_snapshot_record_module_to_binding(jl_module_t* module, jl_binding_t* binding) JL_NOTSAFEPOINT
+static inline void gc_heap_snapshot_record_module_to_binding(jl_module_t* module, jl_value_t *bindings, jl_value_t *bindingkeyset) JL_NOTSAFEPOINT
 {
-    if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full)) {
-        _gc_heap_snapshot_record_module_to_binding(module, binding);
+    if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full) && bindings != NULL && bindingkeyset != NULL) {
+        _gc_heap_snapshot_record_module_to_binding(module, bindings, bindingkeyset);
     }
 }
 
@@ -94,6 +103,20 @@ static inline void gc_heap_snapshot_record_hidden_edge(jl_value_t *from, void* t
     }
 }
 
+static inline void gc_heap_snapshot_record_gc_roots(jl_value_t *root, char *name) JL_NOTSAFEPOINT
+{
+    if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full && root != NULL)) {
+        _gc_heap_snapshot_record_gc_roots(root, name);
+    }
+}
+
+static inline void gc_heap_snapshot_record_finlist(jl_value_t *finlist, size_t index) JL_NOTSAFEPOINT
+{
+    if (__unlikely(gc_heap_snapshot_enabled && prev_sweep_full && finlist != NULL)) {
+        _gc_heap_snapshot_record_finlist(finlist, index);
+    }
+}
+
 // ---------------------------------------------------------------------
 // Functions to call from Julia to take heap snapshot
 // ---------------------------------------------------------------------
diff --git a/src/gc.c b/src/gc.c
index 0c756d3d2880b..57bd81baf4827 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -2358,9 +2358,10 @@ STATIC_INLINE void gc_mark_chunk(jl_ptls_t ptls, jl_gc_markqueue_t *mq, jl_gc_ch
             break;
         }
         case GC_finlist_chunk: {
+            jl_value_t *fl_parent = c->parent;
             jl_value_t **fl_begin = c->begin;
             jl_value_t **fl_end = c->end;
-            gc_mark_finlist_(mq, fl_begin, fl_end);
+            gc_mark_finlist_(mq, fl_parent, fl_begin, fl_end);
             break;
         }
         default: {
@@ -2458,6 +2459,7 @@ STATIC_INLINE void gc_mark_module_binding(jl_ptls_t ptls, jl_module_t *mb_parent
     jl_value_t *bindingkeyset = (jl_value_t *)jl_atomic_load_relaxed(&mb_parent->bindingkeyset);
     gc_assert_parent_validity((jl_value_t *)mb_parent, bindingkeyset);
     gc_try_claim_and_push(mq, bindingkeyset, &nptr);
+    gc_heap_snapshot_record_module_to_binding(mb_parent, bindings, bindingkeyset);
     gc_assert_parent_validity((jl_value_t *)mb_parent, (jl_value_t *)mb_parent->parent);
     gc_try_claim_and_push(mq, (jl_value_t *)mb_parent->parent, &nptr);
     size_t nusings = mb_parent->usings.len;
@@ -2476,7 +2478,7 @@ STATIC_INLINE void gc_mark_module_binding(jl_ptls_t ptls, jl_module_t *mb_parent
     }
 }
 
-void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t **fl_begin, jl_value_t **fl_end)
+void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t *fl_parent, jl_value_t **fl_begin, jl_value_t **fl_end)
 {
     jl_value_t *new_obj;
     // Decide whether need to chunk finlist
@@ -2486,8 +2488,10 @@ void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t **fl_begin, jl_value_t *
         gc_chunkqueue_push(mq, &c);
         fl_end = fl_begin + GC_CHUNK_BATCH_SIZE;
     }
+    size_t i = 0;
     for (; fl_begin < fl_end; fl_begin++) {
-        new_obj = *fl_begin;
+        jl_value_t **slot = fl_begin;
+        new_obj = *slot;
         if (__unlikely(new_obj == NULL))
             continue;
         if (gc_ptr_tag(new_obj, 1)) {
@@ -2498,6 +2502,13 @@ void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t **fl_begin, jl_value_t *
         if (gc_ptr_tag(new_obj, 2))
             continue;
         gc_try_claim_and_push(mq, new_obj, NULL);
+        if (fl_parent != NULL) {
+            gc_heap_snapshot_record_array_edge(fl_parent, slot);
+        } else {
+            // This is a list of objects following the same format as a finlist
+            // if `fl_parent` is NULL
+            gc_heap_snapshot_record_finlist(new_obj, ++i);
+        }
     }
 }
 
@@ -2509,7 +2520,7 @@ void gc_mark_finlist(jl_gc_markqueue_t *mq, arraylist_t *list, size_t start)
         return;
     jl_value_t **fl_begin = (jl_value_t **)list->items + start;
     jl_value_t **fl_end = (jl_value_t **)list->items + len;
-    gc_mark_finlist_(mq, fl_begin, fl_end);
+    gc_mark_finlist_(mq, NULL, fl_begin, fl_end);
 }
 
 JL_DLLEXPORT int jl_gc_mark_queue_obj(jl_ptls_t ptls, jl_value_t *obj)
@@ -3158,28 +3169,38 @@ static void gc_mark_roots(jl_gc_markqueue_t *mq)
 {
     // modules
     gc_try_claim_and_push(mq, jl_main_module, NULL);
-    gc_heap_snapshot_record_root((jl_value_t*)jl_main_module, "main_module");
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_main_module, "main_module");
     // invisible builtin values
     gc_try_claim_and_push(mq, jl_an_empty_vec_any, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_an_empty_vec_any, "an_empty_vec_any");
     gc_try_claim_and_push(mq, jl_module_init_order, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_module_init_order, "module_init_order");
     for (size_t i = 0; i < jl_current_modules.size; i += 2) {
         if (jl_current_modules.table[i + 1] != HT_NOTFOUND) {
             gc_try_claim_and_push(mq, jl_current_modules.table[i], NULL);
-            gc_heap_snapshot_record_root((jl_value_t*)jl_current_modules.table[i], "top level module");
+            gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_current_modules.table[i], "top level module");
         }
     }
     gc_try_claim_and_push(mq, jl_anytuple_type_type, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_anytuple_type_type, "anytuple_type_type");
     for (size_t i = 0; i < N_CALL_CACHE; i++) {
         jl_typemap_entry_t *v = jl_atomic_load_relaxed(&call_cache[i]);
         gc_try_claim_and_push(mq, v, NULL);
+        gc_heap_snapshot_record_array_edge_index((jl_value_t*)jl_anytuple_type_type, (jl_value_t*)v, i);
     }
     gc_try_claim_and_push(mq, jl_all_methods, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_all_methods, "all_methods");
     gc_try_claim_and_push(mq, _jl_debug_method_invalidation, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)_jl_debug_method_invalidation, "debug_method_invalidation");
     // constants
     gc_try_claim_and_push(mq, jl_emptytuple_type, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_emptytuple_type, "emptytuple_type");
     gc_try_claim_and_push(mq, cmpswap_names, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)cmpswap_names, "cmpswap_names");
     gc_try_claim_and_push(mq, jl_global_roots_list, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_global_roots_list, "global_roots_list");
     gc_try_claim_and_push(mq, jl_global_roots_keyset, NULL);
+    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_global_roots_keyset, "global_roots_keyset");
 }
 
 // find unmarked objects that need to be finalized from the finalizer list "list".
diff --git a/src/gc.h b/src/gc.h
index 217b8050e40ac..9de67f6e7c679 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -468,7 +468,7 @@ extern uv_sem_t gc_sweep_assists_needed;
 extern _Atomic(int) gc_n_threads_marking;
 extern _Atomic(int) gc_n_threads_sweeping;
 void gc_mark_queue_all_roots(jl_ptls_t ptls, jl_gc_markqueue_t *mq);
-void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t **fl_begin, jl_value_t **fl_end) JL_NOTSAFEPOINT;
+void gc_mark_finlist_(jl_gc_markqueue_t *mq, jl_value_t *fl_parent, jl_value_t **fl_begin, jl_value_t **fl_end) JL_NOTSAFEPOINT;
 void gc_mark_finlist(jl_gc_markqueue_t *mq, arraylist_t *list, size_t start) JL_NOTSAFEPOINT;
 void gc_mark_loop_serial_(jl_ptls_t ptls, jl_gc_markqueue_t *mq);
 void gc_mark_loop_serial(jl_ptls_t ptls);

From 89cae45ea4f75ce81fff08ca6e731e72e838f4ad Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sat, 30 Dec 2023 22:38:45 +0530
Subject: [PATCH 0514/1315] Optimized arithmetic methods for strided triangular
 matrices (#52571)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This uses broadcasting for operations like `A::UpperTriangular +
B::UpperTriangular` in case the parents are `StridedMatrix`es. Looping
only over the triangular part is usually faster for large matrices,
where presumably memory is the bottleneck.

Some performance comparisons, using
```julia
julia> U = UpperTriangular(rand(1000,1000));

julia> U1 = UnitUpperTriangular(rand(size(U)...));
```
| Operation | master | PR |
| --------------- | ---------- | ----- |
|`-U` |`1.011 ms (3 allocations: 7.63 MiB)` |`559.680 μs (3 allocations:
7.63 MiB)` |
|`U + U`/`U - U` |`971.740 μs (3 allocations: 7.63 MiB)` | `560.063 μs
(3 allocations: 7.63 MiB)` |
|`U + U1`/`U - U1` |`3.014 ms (9 allocations: 22.89 MiB)` | `944.772 μs
(3 allocations: 7.63 MiB)` |
|`U1 + U1` |`4.509 ms (12 allocations: 30.52 MiB)` | `1.687 ms (3
allocations: 7.63 MiB)` |
|`U1 - U1` |`3.357 ms (9 allocations: 22.89 MiB)` | `1.763 ms (3
allocations: 7.63 MiB)` |

I've retained the existing methods as fallback, in case there's current
code that works without broadcasting.
---
 stdlib/LinearAlgebra/src/triangular.jl  | 67 +++++++++++++++++++------
 stdlib/LinearAlgebra/test/triangular.jl | 54 ++++++++++++++++++++
 2 files changed, 107 insertions(+), 14 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index b18b4f0159a67..64e1b320f19dd 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -48,6 +48,7 @@ for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular, :UnitUpperTr
 
         real(A::$t{<:Real}) = A
         real(A::$t{<:Complex}) = (B = real(A.data); $t(B))
+        real(A::$t{<:Complex, <:StridedMaybeAdjOrTransMat}) = $t(real.(A))
     end
 end
 
@@ -156,8 +157,26 @@ const UpperOrLowerTriangular{T,S} = Union{UpperOrUnitUpperTriangular{T,S}, Lower
 
 imag(A::UpperTriangular) = UpperTriangular(imag(A.data))
 imag(A::LowerTriangular) = LowerTriangular(imag(A.data))
-imag(A::UnitLowerTriangular) = LowerTriangular(tril!(imag(A.data),-1))
-imag(A::UnitUpperTriangular) = UpperTriangular(triu!(imag(A.data),1))
+imag(A::UpperTriangular{<:Any,<:StridedMaybeAdjOrTransMat}) = imag.(A)
+imag(A::LowerTriangular{<:Any,<:StridedMaybeAdjOrTransMat}) = imag.(A)
+function imag(A::UnitLowerTriangular)
+    L = LowerTriangular(A.data)
+    Lim = similar(L) # must be mutable to set diagonals to zero
+    Lim .= imag.(L)
+    for i in 1:size(Lim,1)
+        Lim[i,i] = zero(Lim[i,i])
+    end
+    return Lim
+end
+function imag(A::UnitUpperTriangular)
+    U = UpperTriangular(A.data)
+    Uim = similar(U) # must be mutable to set diagonals to zero
+    Uim .= imag.(U)
+    for i in 1:size(Uim,1)
+        Uim[i,i] = zero(Uim[i,i])
+    end
+    return Uim
+end
 
 Array(A::AbstractTriangular) = Matrix(A)
 parent(A::UpperOrLowerTriangular) = A.data
@@ -481,6 +500,11 @@ function -(A::UnitUpperTriangular)
     UpperTriangular(Anew)
 end
 
+# use broadcasting if the parents are strided, where we loop only over the triangular part
+for TM in (:LowerTriangular, :UpperTriangular)
+    @eval -(A::$TM{<:Any, <:StridedMaybeAdjOrTransMat}) = broadcast(-, A)
+end
+
 tr(A::LowerTriangular) = tr(A.data)
 tr(A::UnitLowerTriangular) = size(A, 1) * oneunit(eltype(A))
 tr(A::UpperTriangular) = tr(A.data)
@@ -719,6 +743,16 @@ fillstored!(A::UnitUpperTriangular, x) = (fillband!(A.data, x, 1, size(A,2)-1);
 -(A::UnitLowerTriangular, B::UnitLowerTriangular) = LowerTriangular(tril(A.data, -1) - tril(B.data, -1))
 -(A::AbstractTriangular, B::AbstractTriangular) = copyto!(similar(parent(A)), A) - copyto!(similar(parent(B)), B)
 
+# use broadcasting if the parents are strided, where we loop only over the triangular part
+for op in (:+, :-)
+    for TM1 in (:LowerTriangular, :UnitLowerTriangular), TM2 in (:LowerTriangular, :UnitLowerTriangular)
+        @eval $op(A::$TM1{<:Any, <:StridedMaybeAdjOrTransMat}, B::$TM2{<:Any, <:StridedMaybeAdjOrTransMat}) = broadcast($op, A, B)
+    end
+    for TM1 in (:UpperTriangular, :UnitUpperTriangular), TM2 in (:UpperTriangular, :UnitUpperTriangular)
+        @eval $op(A::$TM1{<:Any, <:StridedMaybeAdjOrTransMat}, B::$TM2{<:Any, <:StridedMaybeAdjOrTransMat}) = broadcast($op, A, B)
+    end
+end
+
 ######################
 # BlasFloat routines #
 ######################
@@ -918,47 +952,52 @@ end
 
 for (t, unitt) in ((UpperTriangular, UnitUpperTriangular),
                    (LowerTriangular, UnitLowerTriangular))
+    tstrided = t{<:Any, <:StridedMaybeAdjOrTransMat}
     @eval begin
         (*)(A::$t, x::Number) = $t(A.data*x)
+        (*)(A::$tstrided, x::Number) = A .* x
 
         function (*)(A::$unitt, x::Number)
-            B = A.data*x
+            B = $t(A.data)*x
             for i = 1:size(A, 1)
-                B[i,i] = x
+                B.data[i,i] = x
             end
-            $t(B)
+            return B
         end
 
         (*)(x::Number, A::$t) = $t(x*A.data)
+        (*)(x::Number, A::$tstrided) = x .* A
 
         function (*)(x::Number, A::$unitt)
-            B = x*A.data
+            B = x*$t(A.data)
             for i = 1:size(A, 1)
-                B[i,i] = x
+                B.data[i,i] = x
             end
-            $t(B)
+            return B
         end
 
         (/)(A::$t, x::Number) = $t(A.data/x)
+        (/)(A::$tstrided, x::Number) = A ./ x
 
         function (/)(A::$unitt, x::Number)
-            B = A.data/x
+            B = $t(A.data)/x
             invx = inv(x)
             for i = 1:size(A, 1)
-                B[i,i] = invx
+                B.data[i,i] = invx
             end
-            $t(B)
+            return B
         end
 
         (\)(x::Number, A::$t) = $t(x\A.data)
+        (\)(x::Number, A::$tstrided) = x .\ A
 
         function (\)(x::Number, A::$unitt)
-            B = x\A.data
+            B = x\$t(A.data)
             invx = inv(x)
             for i = 1:size(A, 1)
-                B[i,i] = invx
+                B.data[i,i] = invx
             end
-            $t(B)
+            return B
         end
     end
 end
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index 74e1028bf109d..b60efba1d941a 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -526,6 +526,23 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo
     end
 end
 
+@testset "non-strided arithmetic" begin
+    for (T,T1) in ((UpperTriangular, UnitUpperTriangular), (LowerTriangular, UnitLowerTriangular))
+        U = T(reshape(1:16, 4, 4))
+        M = Matrix(U)
+        @test -U == -M
+        U1 = T1(reshape(1:16, 4, 4))
+        M1 = Matrix(U1)
+        @test -U1 == -M1
+        for op in (+, -)
+            for (A, MA) in ((U, M), (U1, M1)), (B, MB) in ((U, M), (U1, M1))
+                @test op(A, B) == op(MA, MB)
+            end
+        end
+        @test imag(U) == zero(U)
+    end
+end
+
 # Matrix square root
 Atn = UpperTriangular([-1 1 2; 0 -2 2; 0 0 -3])
 Atp = UpperTriangular([1 1 2; 0 2 2; 0 0 3])
@@ -894,6 +911,11 @@ end
         U = UT(F)
         @test -U == -Array(U)
     end
+
+    F = FillArrays.Fill(3im, (4,4))
+    for U in (UnitUpperTriangular(F), UnitLowerTriangular(F))
+        @test imag(F) == imag(collect(F))
+    end
 end
 
 @testset "error paths" begin
@@ -911,4 +933,36 @@ end
     end
 end
 
+@testset "arithmetic with partly uninitialized matrices" begin
+    @testset "$(typeof(A))" for A in (Matrix{BigFloat}(undef,2,2), Matrix{Complex{BigFloat}}(undef,2,2)')
+        A[1,1] = A[2,2] = A[2,1] = 4
+        B = Matrix{eltype(A)}(undef, size(A))
+        for MT in (LowerTriangular, UnitLowerTriangular)
+            L = MT(A)
+            B .= 0
+            copyto!(B, L)
+            @test L * 2 == 2 * L == 2B
+            @test L/2 == B/2
+            @test 2\L == 2\B
+            @test real(L) == real(B)
+            @test imag(L) == imag(B)
+        end
+    end
+
+    @testset "$(typeof(A))" for A in (Matrix{BigFloat}(undef,2,2), Matrix{Complex{BigFloat}}(undef,2,2)')
+        A[1,1] = A[2,2] = A[1,2] = 4
+        B = Matrix{eltype(A)}(undef, size(A))
+        for MT in (UpperTriangular, UnitUpperTriangular)
+            U = MT(A)
+            B .= 0
+            copyto!(B, U)
+            @test U * 2 == 2 * U == 2B
+            @test U/2 == B/2
+            @test 2\U == 2\B
+            @test real(U) == real(B)
+            @test imag(U) == imag(B)
+        end
+    end
+end
+
 end # module TestTriangular

From 1b183b93f4b78f567241b1e7511138798cea6a0d Mon Sep 17 00:00:00 2001
From: jariji <96840304+jariji@users.noreply.github.com>
Date: Sat, 30 Dec 2023 17:32:59 -0800
Subject: [PATCH 0515/1315] Add Docs.undocumented_names (#52413)

Fixes #51174

---------

Co-authored-by: Steven G. Johnson <stevenj@alum.mit.edu>
Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 NEWS.md                         |  1 +
 base/docs/Docs.jl               | 18 +++++++++++++++++-
 base/docs/utils.jl              |  4 ++--
 base/reflection.jl              |  2 +-
 doc/src/base/base.md            | 10 ++++++++++
 doc/src/manual/documentation.md |  3 ++-
 test/docs.jl                    | 19 +++++++++++++++++++
 7 files changed, 52 insertions(+), 5 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 82ae28a3b420d..488be0f3209b4 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -84,6 +84,7 @@ New library features
   write the output to a stream rather than returning a string ([#48625]).
 * `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
 * New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
+* New function `Docs.undocumented_names(module; all)` returns a module's undocumented names ([#52413]).
 * Passing an `IOBuffer` as a stdout argument for `Process` spawn now works as
   expected, synchronized with `wait` or `success`, so a `Base.BufferStream` is
   no longer required there for correctness to avoid data races ([#52461]).
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 87b4a45c4dc80..5e7126f47c28d 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -3,7 +3,7 @@
 """
     Docs
 
-The `Docs` module provides the `@doc` macro which can be used to set and retrieve
+The `Docs` module provides the [`@doc`](@ref) macro which can be used to set and retrieve
 documentation metadata for Julia objects.
 
 Please see the manual section on [documentation](@ref man-documentation) for more
@@ -675,4 +675,20 @@ function hasdoc(binding::Docs.Binding, sig::Type = Union{})
 end
 
 
+"""
+    undocumented_names(mod::Module; all=false)
+
+Return an array of undocumented symbols in `module` (that is, lacking docstrings).
+`all=false` returns only exported symbols; whereas `all=true` also includes
+non-exported symbols, following the behavior of [`names`](@ref). Only valid identifiers
+are included. Names are returned in sorted order.
+
+See also: [`names`](@ref), [`Docs.hasdoc`](@ref), [`Base.isidentifier`](@ref).
+"""
+function undocumented_names(mod::Module; all::Bool=false)
+    filter!(names(mod; all)) do sym
+        !hasdoc(mod, sym) && Base.isidentifier(sym)
+    end
+end
+
 end
diff --git a/base/docs/utils.jl b/base/docs/utils.jl
index 928dfde01ccf0..1ed576c7362ff 100644
--- a/base/docs/utils.jl
+++ b/base/docs/utils.jl
@@ -23,7 +23,7 @@ You can also use a stream for large amounts of data:
     `HTML` is currently exported to maintain
     backwards compatibility, but this export
     is deprecated. It is recommended to use
-    this type as `Docs.HTML` or to explicitly
+    this type as [`Docs.HTML`](@ref) or to explicitly
     import it from `Docs`.
 """
 mutable struct HTML{T}
@@ -81,7 +81,7 @@ You can also use a stream for large amounts of data:
     `Text` is currently exported to maintain
     backwards compatibility, but this export
     is deprecated. It is recommended to use
-    this type as `Docs.Text` or to explicitly
+    this type as [`Docs.Text`](@ref) or to explicitly
     import it from `Docs`.
 """
 mutable struct Text{T}
diff --git a/base/reflection.jl b/base/reflection.jl
index 306f21cbc5f23..0295657eea1fc 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -79,7 +79,7 @@ Get an array of the public names of a `Module`, excluding deprecated names.
 If `all` is true, then the list also includes non-public names defined in the module,
 deprecated names, and compiler-generated names.
 If `imported` is true, then names explicitly imported from other modules
-are also included.
+are also included. Names are returned in sorted order.
 
 As a special case, all names defined in `Main` are considered \"public\",
 since it is not idiomatic to explicitly mark names from `Main` as public.
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index c5d7320148e97..7172474b40b39 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -462,6 +462,16 @@ Base.functionloc(::Method)
 Base.@locals
 ```
 
+## Documentation
+(See also the [documentation](@ref man-documentation) chapter.)
+```@docs
+Base.@doc
+Docs.HTML
+Docs.Text
+Docs.hasdoc
+Docs.undocumented_names
+```
+
 ## Code loading
 
 ```@docs
diff --git a/doc/src/manual/documentation.md b/doc/src/manual/documentation.md
index 169b27ead15f8..58b1819e97372 100644
--- a/doc/src/manual/documentation.md
+++ b/doc/src/manual/documentation.md
@@ -20,7 +20,8 @@ environments provide a way to access documentation directly:
   under the cursor.
 
 
-`Docs.hasdoc(module, name)::Bool` tells whether a name has a docstring.
+`Docs.hasdoc(module, name)::Bool` tells whether a name has a docstring. `Docs.undocumented_names(module; all)`
+returns the undocumented names in a module.
 
 ## Writing Documentation
 
diff --git a/test/docs.jl b/test/docs.jl
index 1b26c9670e180..7ebef8832cd69 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -76,6 +76,25 @@ function break_me_docs end
 @test !isdefined(Base, :_this_name_doesnt_exist_) && !Docs.hasdoc(Base, :_this_name_doesnt_exist_)
 @test isdefined(Base, :_typed_vcat) && !Docs.hasdoc(Base, :_typed_vcat)
 
+"This module has names without documentation."
+module _ModuleWithUndocumentedNames
+export f
+f() = 1
+end
+
+"This module has some documentation."
+module _ModuleWithSomeDocumentedNames
+export f
+"f() is 1."
+f() = 1
+g() = 2
+end
+
+@test Docs.undocumented_names(_ModuleWithUndocumentedNames) == [:f]
+@test isempty(Docs.undocumented_names(_ModuleWithSomeDocumentedNames))
+@test Docs.undocumented_names(_ModuleWithSomeDocumentedNames; all=true) == [:eval, :g, :include]
+
+
 # issue #11548
 
 module ModuleMacroDoc

From 7baa57718e44228925f61b7f27cfd1d05c94b414 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 1 Jan 2024 20:57:03 -0500
Subject: [PATCH 0516/1315] Add `@create_log_macro` for making custom styled
 logging macros (#52196)

---
 NEWS.md                             |  5 ++++
 base/logging.jl                     | 18 ++++++++------
 stdlib/Logging/docs/src/index.md    | 14 ++++++++++-
 stdlib/Logging/src/ConsoleLogger.jl |  1 +
 stdlib/Logging/src/Logging.jl       | 37 +++++++++++++++++++++++++++++
 stdlib/Logging/test/runtests.jl     | 20 +++++++++++-----
 6 files changed, 81 insertions(+), 14 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 488be0f3209b4..7b4cda50b8985 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -118,6 +118,11 @@ Standard library changes
 * Structured matrices now retain either the axes of the parent (for `Symmetric`/`Hermitian`/`AbstractTriangular`/`UpperHessenberg`), or that of the principal diagonal (for banded matrices) ([#52480]).
 * `bunchkaufman` and `bunchkaufman!` now work for any `AbstractFloat`, `Rational` and their complex variants. `bunchkaufman` now supports `Integer` types, by making an internal conversion to `Rational{BigInt}`. Added new function `inertia` that computes the inertia of the diagonal factor given by the `BunchKaufman` factorization object of a real symmetric or Hermitian matrix. For complex symmetric matrices, `inertia` only computes the number of zero eigenvalues of the diagonal factor ([#51487]).
 
+#### Logging
+* New `@create_log_macro` macro for creating new log macros like `@info`, `@warn` etc. For instance
+  `@create_log_macro MyLog 1500 :magenta` will create `@mylog` to be used like `@mylog "hello"` which
+  will show as `┌ MyLog: hello` etc. ([#52196])
+
 #### Printf
 
 #### Profile
diff --git a/base/logging.jl b/base/logging.jl
index f6a34aee2f516..1853caa16148c 100644
--- a/base/logging.jl
+++ b/base/logging.jl
@@ -162,14 +162,18 @@ const AboveMaxLevel = LogLevel( 1000001)
 # Global log limiting mechanism for super fast but inflexible global log limiting.
 const _min_enabled_level = Ref{LogLevel}(Debug)
 
+# stored as LogLevel => (name, color)
+const custom_log_levels = Dict{LogLevel,Tuple{Symbol,Union{Symbol,Int}}}()
+
 function show(io::IO, level::LogLevel)
-    if     level == BelowMinLevel  print(io, "BelowMinLevel")
-    elseif level == Debug          print(io, "Debug")
-    elseif level == Info           print(io, "Info")
-    elseif level == Warn           print(io, "Warn")
-    elseif level == Error          print(io, "Error")
-    elseif level == AboveMaxLevel  print(io, "AboveMaxLevel")
-    else                           print(io, "LogLevel($(level.level))")
+    if     haskey(custom_log_levels, level) print(io, custom_log_levels[level][1])
+    elseif level == BelowMinLevel           print(io, "BelowMinLevel")
+    elseif level == Debug                   print(io, "Debug")
+    elseif level == Info                    print(io, "Info")
+    elseif level == Warn                    print(io, "Warn")
+    elseif level == Error                   print(io, "Error")
+    elseif level == AboveMaxLevel           print(io, "AboveMaxLevel")
+    else                                    print(io, "LogLevel($(level.level))")
     end
 end
 
diff --git a/stdlib/Logging/docs/src/index.md b/stdlib/Logging/docs/src/index.md
index 55d24c7ae0a26..882c66af2baef 100644
--- a/stdlib/Logging/docs/src/index.md
+++ b/stdlib/Logging/docs/src/index.md
@@ -58,7 +58,7 @@ automatically extracted. Let's examine the user-defined data first:
 * The *log level* is a broad category for the message that is used for early
   filtering. There are several standard levels of type [`LogLevel`](@ref);
   user-defined levels are also possible.
-  Each is distinct in purpose:
+  Each built-in log level is distinct in purpose:
   - [`Logging.Debug`](@ref) (log level -1000) is information intended for the developer of
     the program. These events are disabled by default.
   - [`Logging.Info`](@ref) (log level 0) is for general information to the user.
@@ -70,6 +70,17 @@ automatically extracted. Let's examine the user-defined data first:
     Often this log-level is unneeded as throwing an exception can convey
     all the required information.
 
+    You can create logging macros for custom log levels. For instance:
+    ```julia-repl
+    julia> using Logging
+
+    julia> @create_log_macro MyLog 200 :magenta
+    @mylog (macro with 1 method)
+
+    julia> @mylog "hello"
+    [ MyLog: hello
+    ```
+
 * The *message*  is an object describing the event. By convention
   `AbstractString`s passed as messages are assumed to be in markdown format.
   Other types will be displayed using `print(io, obj)` or `string(obj)` for
@@ -298,6 +309,7 @@ Logging.Debug
 Logging.Info
 Logging.Warn
 Logging.Error
+Logging.@create_log_macro
 ```
 
 ### [Processing events with AbstractLogger](@id AbstractLogger-interface)
diff --git a/stdlib/Logging/src/ConsoleLogger.jl b/stdlib/Logging/src/ConsoleLogger.jl
index 747f8a2b22966..1d45296c907d1 100644
--- a/stdlib/Logging/src/ConsoleLogger.jl
+++ b/stdlib/Logging/src/ConsoleLogger.jl
@@ -58,6 +58,7 @@ end
 showvalue(io, ex::Exception) = showerror(io, ex)
 
 function default_logcolor(level::LogLevel)
+    level in keys(custom_log_levels) ? custom_log_levels[level][2] :
     level < Info  ? Base.debug_color() :
     level < Warn  ? Base.info_color()  :
     level < Error ? Base.warn_color()  :
diff --git a/stdlib/Logging/src/Logging.jl b/stdlib/Logging/src/Logging.jl
index 0743c650326cc..83e93ee396361 100644
--- a/stdlib/Logging/src/Logging.jl
+++ b/stdlib/Logging/src/Logging.jl
@@ -21,6 +21,7 @@ for sym in [
     Symbol("@warn"),
     Symbol("@error"),
     Symbol("@logmsg"),
+    :custom_log_levels,
     :with_logger,
     :current_logger,
     :global_logger,
@@ -29,6 +30,41 @@ for sym in [
     @eval const $sym = Base.CoreLogging.$sym
 end
 
+"""
+    @create_log_macro(name::Symbol, level::Int, color::Union{Int,Symbol})
+
+Creates a custom log macro like `@info`, `@warn` etc. with a given `name`, `level` and
+`color`. The macro created is named with the lowercase form of `name` but the given form
+is used for the printing.
+
+The available color keys can be seen by typing `Base.text_colors` in the help mode of the REPL
+
+```julia-repl
+julia> @create_log_macro(:MyLog, 200, :magenta)
+@mylog (macro with 1 method)
+
+julia> @mylog "hello"
+[ MyLog: hello
+```
+"""
+macro create_log_macro(name, level, color)
+    macro_name = Symbol(lowercase(string(name)))
+    macro_string = QuoteNode(name)
+    loglevel = LogLevel(level)
+    if loglevel in (BelowMinLevel, Debug, Info, Warn, Error, AboveMaxLevel)
+        throw(ArgumentError("Cannot use the same log level as a built in log macro"))
+    end
+    if haskey(custom_log_levels, loglevel)
+        throw(ArgumentError("Custom log macro already exists for given log level"))
+    end
+    quote
+        $(custom_log_levels)[$(esc(loglevel))] = ($(macro_string), $(esc(color)))
+        macro $(esc(macro_name))(exs...)
+            $(Base.CoreLogging.logmsg_code)(($(Base.CoreLogging.@_sourceinfo))..., $(esc(loglevel)), exs...)
+        end
+    end
+end
+
 # LogLevel aliases (re-)documented here (JuliaLang/julia#40978)
 """
     Debug
@@ -67,6 +103,7 @@ export
     @warn,
     @error,
     @logmsg,
+    @create_log_macro,
     with_logger,
     current_logger,
     global_logger,
diff --git a/stdlib/Logging/test/runtests.jl b/stdlib/Logging/test/runtests.jl
index 3a793c4e0bc33..e7b3fbca2098d 100644
--- a/stdlib/Logging/test/runtests.jl
+++ b/stdlib/Logging/test/runtests.jl
@@ -7,8 +7,8 @@ import Logging: min_enabled_level, shouldlog, handle_message
 @noinline func1() = backtrace()
 
 # see "custom log macro" testset
-CustomLog = LogLevel(-500)
-macro customlog(exs...) Base.CoreLogging.logmsg_code((Base.CoreLogging.@_sourceinfo)..., esc(CustomLog), exs...) end
+@create_log_macro CustomLog1 -500 :magenta
+@create_log_macro CustomLog2 1500 1
 
 @testset "Logging" begin
 
@@ -280,16 +280,24 @@ end
 end
 
 @testset "custom log macro" begin
-    @test_logs (CustomLog, "a") min_level=CustomLog @customlog "a"
+    llevel = LogLevel(-500)
+
+    @test_logs (llevel, "foo") min_level=llevel @customlog1 "foo"
 
     buf = IOBuffer()
     io = IOContext(buf, :displaysize=>(30,80), :color=>false)
-    logger = ConsoleLogger(io, CustomLog)
+    logger = ConsoleLogger(io, llevel)
+
+    with_logger(logger) do
+        @customlog1 "foo"
+    end
+    @test occursin("CustomLog1: foo", String(take!(buf)))
+
 
     with_logger(logger) do
-        @customlog "a"
+        @customlog2 "hello"
     end
-    @test occursin("LogLevel(-500): a", String(take!(buf)))
+    @test occursin("CustomLog2: hello", String(take!(buf)))
 end
 
 end

From 0f62824530feb9ab39c179175b3fc4702d21c552 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 1 Jan 2024 20:58:53 -0500
Subject: [PATCH 0517/1315] Profile: Improve module docstring (#52678)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

![Screenshot 2023-12-30 at 7 24
10 PM](https://github.com/JuliaLang/julia/assets/1694067/a7c78943-5e4a-475c-864c-3b0005305471)
---
 stdlib/Profile/src/Profile.jl | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index cc29a4503d810..aad97be683309 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -1,7 +1,24 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
-Profiling support, main entry point is the [`@profile`](@ref) macro.
+    Profile
+
+Profiling support.
+
+## CPU profiling
+- `@profile foo()` to profile a specific call.
+- `Profile.print()` to print the report.
+- `Profile.clear()` to clear the buffer.
+- Send a $(Sys.isbsd() ? "SIGINFO (ctrl-t)" : "SIGUSR1") signal to the process to automatically trigger a profile and print.
+
+## Memory profiling
+- `Profile.Allocs.@profile [sample_rate=0.1] foo()` to sample allocations within a specific call. A sample rate of 1.0 will record everything; 0.0 will record nothing.
+- `Profile.Allocs.print()` to print the report.
+- `Profile.Allocs.clear()` to clear the buffer.
+
+## Heap profiling
+- `Profile.take_heap_snapshot()` to record a `.heapsnapshot` record of the heap.
+- Set `JULIA_PROFILE_PEEK_HEAP_SNAPSHOT=true` to capture a heap snapshot when signal $(Sys.isbsd() ? "SIGINFO (ctrl-t)" : "SIGUSR1") is sent.
 """
 module Profile
 

From 0d9c0d9c049410d23ef7db8f2d4f7c7142998f37 Mon Sep 17 00:00:00 2001
From: Aniket <kathareaniket47@gmail.com>
Date: Tue, 2 Jan 2024 17:30:53 +0530
Subject: [PATCH 0518/1315] Add 3-argument div and rem in doc (#52662)

Resolves #52624
---
 base/div.jl          | 2 ++
 doc/src/base/math.md | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/base/div.jl b/base/div.jl
index 9c2187e662ee9..8988f2b70f27b 100644
--- a/base/div.jl
+++ b/base/div.jl
@@ -22,6 +22,8 @@ See also [`fld`](@ref) and [`cld`](@ref), which are special cases of this functi
 
 # Examples:
 ```jldoctest
+julia> div(4, 3, RoundToZero) # Matches div(4, 3)
+1
 julia> div(4, 3, RoundDown) # Matches fld(4, 3)
 1
 julia> div(4, 3, RoundUp) # Matches cld(4, 3)
diff --git a/doc/src/base/math.md b/doc/src/base/math.md
index cb427c9458fe1..cff841d991880 100644
--- a/doc/src/base/math.md
+++ b/doc/src/base/math.md
@@ -14,10 +14,12 @@ Base.fma
 Base.muladd
 Base.inv(::Number)
 Base.div
+Base.div(::Any, ::Any, ::RoundingMode)
 Base.fld
 Base.cld
 Base.mod
 Base.rem
+Base.rem(::Any, ::Any, ::RoundingMode)
 Base.rem2pi
 Base.Math.mod2pi
 Base.divrem

From acddc62c1acca478d39c73f8c248d519ed4cfe93 Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Tue, 2 Jan 2024 13:04:53 +0100
Subject: [PATCH 0519/1315] Fix docs for Sockets.getaddrinfo() (#52538)

Previously only the two-argument method was documented, which stated
that the default type to be returned was IPv4. But that hasn't been true
since 2ab654ce5b (#36029), so now both methods are documented and
corrected.

I believe this fixes #40306.
---
 stdlib/Sockets/src/addrinfo.jl | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/stdlib/Sockets/src/addrinfo.jl b/stdlib/Sockets/src/addrinfo.jl
index ac4aef8737d1b..bf5819f6388c6 100644
--- a/stdlib/Sockets/src/addrinfo.jl
+++ b/stdlib/Sockets/src/addrinfo.jl
@@ -122,10 +122,20 @@ end
 getalladdrinfo(host::AbstractString) = getalladdrinfo(String(host))
 
 """
-    getaddrinfo(host::AbstractString, IPAddr=IPv4) -> IPAddr
+    getaddrinfo(host::AbstractString, IPAddr) -> IPAddr
 
 Gets the first IP address of the `host` of the specified `IPAddr` type.
-Uses the operating system's underlying getaddrinfo implementation, which may do a DNS lookup.
+Uses the operating system's underlying getaddrinfo implementation, which may do
+a DNS lookup.
+
+# Examples
+```julia-repl
+julia> getaddrinfo("localhost", IPv6)
+ip"::1"
+
+julia> getaddrinfo("localhost", IPv4)
+ip"127.0.0.1"
+```
 """
 function getaddrinfo(host::String, T::Type{<:IPAddr})
     addrs = getalladdrinfo(host)
@@ -137,6 +147,14 @@ function getaddrinfo(host::String, T::Type{<:IPAddr})
     throw(DNSError(host, UV_EAI_NONAME))
 end
 getaddrinfo(host::AbstractString, T::Type{<:IPAddr}) = getaddrinfo(String(host), T)
+
+"""
+    getaddrinfo(host::AbstractString) -> IPAddr
+
+Gets the first available IP address of `host`, which may be either an `IPv4` or
+`IPv6` address. Uses the operating system's underlying getaddrinfo
+implementation, which may do a DNS lookup.
+"""
 function getaddrinfo(host::AbstractString)
     addrs = getalladdrinfo(String(host))
     if !isempty(addrs)

From 567754cb96d55559c31ae2c24b686e22226e8d45 Mon Sep 17 00:00:00 2001
From: Tortar <68152031+Tortar@users.noreply.github.com>
Date: Tue, 2 Jan 2024 15:32:56 +0100
Subject: [PATCH 0520/1315] update latest stable version in README (#52699)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6fa264c57ac21..fde5e8ee8a8bd 100644
--- a/README.md
+++ b/README.md
@@ -94,7 +94,7 @@ and then use the command prompt to change into the resulting julia directory. By
 Julia. However, most users should use the [most recent stable version](https://github.com/JuliaLang/julia/releases)
 of Julia. You can get this version by running:
 
-    git checkout v1.9.4
+    git checkout v1.10.0
 
 To build the `julia` executable, run `make` from within the julia directory.
 

From 1dfd2a65c125c5f2e9eac7937caaeea132dd51c0 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 2 Jan 2024 14:04:17 -0500
Subject: [PATCH 0521/1315] syntax: properly linearize type-for-closure code
 (#52497)

The (core svec) calls are not supposed to be nested like this now. We
would rarely attempt to infer this, which makes it hard to notice, but
we should try to be correct.
---
 src/julia-syntax.scm | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 6f80611a7f3ea..c03700796e72e 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -3428,8 +3428,7 @@ f(x) = yt(x)
 (define (type-for-closure-parameterized name P names fields types super)
   (let ((n (length P))
         (s (make-ssavalue)))
-    `((thunk
-       (lambda ()
+    `((thunk ,(linearize `(lambda ()
          (() () 0 ())
          (block (global ,name) (const ,name)
                 ,@(map (lambda (p n) `(= ,p (call (core TypeVar) ',n (core Any)))) P names)
@@ -3440,22 +3439,22 @@ f(x) = yt(x)
                 (call (core _setsuper!) ,s ,super)
                 (= (outerref ,name) ,s)
                 (call (core _typebody!) ,s (call (core svec) ,@types))
-                (return (null))))))))
+                (return (null)))))))))
 
 (define (type-for-closure name fields super)
   (let ((s (make-ssavalue)))
-    `((thunk (lambda ()
-               (() () 0 ())
-               (block (global ,name) (const ,name)
-                      (= ,s (call (core _structtype) (thismodule) (inert ,name) (call (core svec))
-                                  (call (core svec) ,@(map quotify fields))
-                                  (call (core svec))
-                                  (false) ,(length fields)))
-                      (call (core _setsuper!) ,s ,super)
-                      (= (outerref ,name) ,s)
-                      (call (core _typebody!) ,s
-                            (call (core svec) ,@(map (lambda (v) '(core Box)) fields)))
-                      (return (null))))))))
+    `((thunk ,(linearize `(lambda ()
+       (() () 0 ())
+       (block (global ,name) (const ,name)
+              (= ,s (call (core _structtype) (thismodule) (inert ,name) (call (core svec))
+                          (call (core svec) ,@(map quotify fields))
+                          (call (core svec))
+                          (false) ,(length fields)))
+              (call (core _setsuper!) ,s ,super)
+              (= (outerref ,name) ,s)
+              (call (core _typebody!) ,s
+                    (call (core svec) ,@(map (lambda (v) '(core Box)) fields)))
+              (return (null)))))))))
 
 ;; better versions of above, but they get handled wrong in many places
 ;; need to fix that in order to handle #265 fully (and use the definitions)

From 972f55feedd12b6549002604fb08fde5206bfe37 Mon Sep 17 00:00:00 2001
From: Curtis Vogt <curtis.vogt@gmail.com>
Date: Tue, 2 Jan 2024 13:04:46 -0600
Subject: [PATCH 0522/1315] Mention `@lock` in `lock(f, l)` docstring (#52357)

Follow up to: https://github.com/JuliaLang/julia/issues/36441. Makes
this macro much easier to learn about if you're just viewing the
docstrings.
---
 base/lock.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/base/lock.jl b/base/lock.jl
index b473b4033e2de..e3a8463578074 100644
--- a/base/lock.jl
+++ b/base/lock.jl
@@ -220,6 +220,8 @@ available.
 When this function returns, the `lock` has been released, so the caller should
 not attempt to `unlock` it.
 
+See also: [`@lock`](@ref).
+
 !!! compat "Julia 1.7"
     Using a [`Channel`](@ref) as the second argument requires Julia 1.7 or later.
 """

From 2d0aeca686581276e0da87a9d9e593db1dba5516 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 2 Jan 2024 18:00:26 -0500
Subject: [PATCH 0523/1315] Fix precompile reason print when nothing (#52701)

---
 base/loading.jl    | 7 ++++---
 test/precompile.jl | 6 +++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 1519375099634..97aa9977a7184 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2568,7 +2568,7 @@ This can be used to reduce package load times. Cache files are stored in
 `DEPOT_PATH[1]/compiled`. See [Module initialization and precompilation](@ref)
 for important notes.
 """
-function compilecache(pkg::PkgId, internal_stderr::IO = stderr, internal_stdout::IO = stdout; reasons::Union{Dict{String,Int},Nothing}=nothing)
+function compilecache(pkg::PkgId, internal_stderr::IO = stderr, internal_stdout::IO = stdout; reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
     @nospecialize internal_stderr internal_stdout
     path = locate_package(pkg)
     path === nothing && throw(ArgumentError("$pkg not found during precompilation"))
@@ -2578,7 +2578,7 @@ end
 const MAX_NUM_PRECOMPILE_FILES = Ref(10)
 
 function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, internal_stdout::IO = stdout,
-                      keep_loaded_modules::Bool = true; reasons::Union{Dict{String,Int},Nothing}=nothing)
+                      keep_loaded_modules::Bool = true; reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
 
     @nospecialize internal_stderr internal_stdout
     # decide where to put the resulting cache file
@@ -3320,11 +3320,12 @@ function list_reasons(reasons::Dict{String,Int})
     isempty(reasons) && return ""
     return "(cache misses: $(join(("$k ($v)" for (k,v) in reasons), ", ")))"
 end
+list_reasons(::Nothing) = ""
 
 # returns true if it "cachefile.ji" is stale relative to "modpath.jl" and build_id for modkey
 # otherwise returns the list of dependencies to also check
 @constprop :none function stale_cachefile(modpath::String, cachefile::String; ignore_loaded::Bool = false, reasons=nothing)
-    return stale_cachefile(PkgId(""), UInt128(0), modpath, cachefile; ignore_loaded)
+    return stale_cachefile(PkgId(""), UInt128(0), modpath, cachefile; ignore_loaded, reasons)
 end
 @constprop :none function stale_cachefile(modkey::PkgId, build_id::UInt128, modpath::String, cachefile::String;
                                             ignore_loaded::Bool = false, reasons::Union{Dict{String,Int},Nothing}=nothing)
diff --git a/test/precompile.jl b/test/precompile.jl
index 1ac3999947736..e655dd03b9798 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -3,7 +3,7 @@
 original_depot_path = copy(Base.DEPOT_PATH)
 original_load_path = copy(Base.LOAD_PATH)
 
-using Test, Distributed, Random
+using Test, Distributed, Random, Logging
 using REPL # doc lookup function
 
 Foo_module = :Foo4b3a94a1a081a8cb
@@ -579,7 +579,7 @@ precompile_test_harness(false) do dir
           end
           """)
 
-    @test Base.compilecache(Base.PkgId("OverwriteMethodError")) == Base.PrecompilableError() # due to piracy
+    @test (@test_warn "overwritten in module OverwriteMethodError" Base.compilecache(Base.PkgId("OverwriteMethodError"))) == Base.PrecompilableError() # due to piracy
 
     UseBaz_file = joinpath(dir, "UseBaz.jl")
     write(UseBaz_file,
@@ -624,7 +624,7 @@ precompile_test_harness(false) do dir
           end
           """)
 
-    cachefile, _ = Base.compilecache(Base.PkgId("FooBar"))
+    cachefile, _ = @test_logs (:debug, r"Precompiling FooBar") min_level=Logging.Debug match_mode=:any Base.compilecache(Base.PkgId("FooBar"))
     empty_prefs_hash = Base.get_preferences_hash(nothing, String[])
     @test cachefile == Base.compilecache_path(Base.PkgId("FooBar"), empty_prefs_hash)
     @test isfile(joinpath(cachedir, "FooBar.ji"))

From 3279a1f4d76dd9cb4446705d79c9dd8e90c8662b Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Tue, 2 Jan 2024 23:08:48 -0600
Subject: [PATCH 0524/1315] THIRDPARTY: Consider `base/` and `stdlib/` as
 standard libraries (#52692)

Changes:
- Consider `base/` and `stdlib/` as standard libraries
- Add optional dep: `LibTracyClient`
- Add license for tools, and update link
- Update spdx.json
---
 THIRDPARTY.md   |  9 +++++----
 julia.spdx.json | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/THIRDPARTY.md b/THIRDPARTY.md
index 51950d9e2c6a1..89d1ce3de3d97 100644
--- a/THIRDPARTY.md
+++ b/THIRDPARTY.md
@@ -1,5 +1,5 @@
 The Julia language is licensed under the MIT License (see [LICENSE.md](./LICENSE.md) ). The "language" consists
-of the compiler (the contents of src/), most of the standard library (base/),
+of the compiler (the contents of `src/`), most of the standard library (`base/` and `stdlib/`),
 and some utilities (most of the rest of the files in this repository). See below
 for exceptions.
 
@@ -26,7 +26,8 @@ own licenses:
 
 and optionally:
 
-- [ITTAPI](https://github.com/intel/ittapi/blob/master/LICENSES/BSD-3-Clause.txt) [BSD-3]
+- [LibTracyClient](https://github.com/wolfpld/tracy/blob/master/LICENSE) [BSD-3]
+- [ITTAPI](https://github.com/intel/ittapi/tree/master/LICENSES) [BSD-3 AND GPL2]
 
 Julia's `stdlib` uses the following external libraries, which have their own licenses:
 
@@ -47,8 +48,8 @@ Julia's `stdlib` uses the following external libraries, which have their own lic
 
 Julia's build process uses the following external tools:
 
-- [PATCHELF](https://nixos.org/patchelf.html)
-- [OBJCONV](https://www.agner.org/optimize/#objconv)
+- [PATCHELF](https://github.com/NixOS/patchelf/blob/master/COPYING) [GPL3]
+- [OBJCONV](https://www.agner.org/optimize/#objconv) [GPL3]
 - [LIBWHICH](https://github.com/vtjnash/libwhich/blob/master/LICENSE) [MIT]
 
 Julia bundles the following external programs and libraries:
diff --git a/julia.spdx.json b/julia.spdx.json
index bea7bdc6c3a5d..63683dd302a39 100644
--- a/julia.spdx.json
+++ b/julia.spdx.json
@@ -370,6 +370,32 @@
             "copyrightText": "Copyright © 2014-2019 by Steven G. Johnson, Jiahao Chen, Tony Kelman, Jonas Fonseca, and other contributors listed in the git history.",
             "summary": "utf8proc is a small, clean C library that provides Unicode normalization, case-folding, and other operations for data in the UTF-8 encoding."
         },
+        {
+            "name": "LibTracyClient",
+            "SPDXID": "SPDXRef-LibTracyClient",
+            "downloadLocation": "git+https://github.com/wolfpld/tracy.git",
+            "filesAnalyzed": false,
+            "homepage": "https://github.com/wolfpld/tracy",
+            "sourceInfo": "The git hash of the version in use can be found in the file deps/libtracyclient.version",
+            "licenseConcluded": "BSD-3-Clause",
+            "licenseDeclared": "BSD-3-Clause",
+            "copyrightText": "Copyright (c) 2017-2024, Bartosz Taudul <wolf@nereid.pl>",
+            "summary": "A real time, nanosecond resolution, remote telemetry, hybrid frame and sampling profiler for games and other applications.",
+            "comment": "LibTracyClient is an optional dependency that is not built by default"
+        },
+        {
+            "name": "ittapi",
+            "SPDXID": "SPDXRef-ittapi",
+            "downloadLocation": "git+https://github.com/intel/ittapi.git",
+            "filesAnalyzed": false,
+            "homepage": "https://github.com/intel/ittapi",
+            "sourceInfo": "The git hash of the version in use can be found in the file deps/ittapi.version",
+            "licenseConcluded": "BSD-3-Clause AND GPL-2.0-only",
+            "licenseDeclared": "BSD-3-Clause AND GPL-2.0-only",
+            "copyrightText": "Copyright (c) 2019 Intel Corporation",
+            "summary": "The Instrumentation and Tracing Technology (ITT) API enables your application to generate and control the collection of trace data during its execution across different Intel tools.",
+            "comment": "ITTAPI is an optional dependency that is not built by default"
+        },
         {
             "name": "7-Zip",
             "SPDXID": "SPDXRef-7zip",
@@ -581,6 +607,16 @@
             "relationshipType": "BUILD_DEPENDENCY_OF",
             "relatedSpdxElement": "SPDXRef-JuliaMain"
         },
+        {
+            "spdxElementId": "SPDXRef-LibTracyClient",
+            "relationshipType": "OPTIONAL_DEPENDENCY_OF",
+            "relatedSpdxElement": "SPDXRef-JuliaMain"
+        },
+        {
+            "spdxElementId": "SPDXRef-ittapi",
+            "relationshipType": "OPTIONAL_DEPENDENCY_OF",
+            "relatedSpdxElement": "SPDXRef-JuliaMain"
+        },
         {
             "spdxElementId": "SPDXRef-7zip",
             "relationshipType": "RUNTIME_DEPENDENCY_OF",

From 0ea2b5691abf0f104253a3c619ea66ff00a17565 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Wed, 3 Jan 2024 02:09:38 -0500
Subject: [PATCH 0525/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20SparseArrays=20stdlib=20from=20f154de2=20to=20feb54ee=20(#52?=
 =?UTF-8?q?706)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: SparseArrays
URL: https://github.com/JuliaSparse/SparseArrays.jl.git
Stdlib branch: main
Julia branch: master
Old commit: f154de2
New commit: feb54ee
Julia version: 1.11.0-DEV
SparseArrays version: 1.11.0
Bump invoked by: @giordano
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaSparse/SparseArrays.jl/compare/f154de2b6801ec8d5afaf58b73b830c8e71013c3...feb54ee5e49008bd157227099cafe604a67c36fb

```
$ git log --oneline f154de2..feb54ee
feb54ee fix typo ("ArguementError") (#479)
8308232 Extend sparse kron to adjortrans of dense matrices (#474)
951837f Simplify calling Aqua (#473)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
Co-authored-by: Viral B. Shah <ViralBShah@users.noreply.github.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/SparseArrays.version                                     | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/sha512
 create mode 100644 deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/md5 b/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/md5
deleted file mode 100644
index 9a38667523ea0..0000000000000
--- a/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-e4c17513749ebdd898daf62f932fc9b3
diff --git a/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/sha512 b/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/sha512
deleted file mode 100644
index 6547864574540..0000000000000
--- a/deps/checksums/SparseArrays-f154de2b6801ec8d5afaf58b73b830c8e71013c3.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-15a6dfcf64ebc2ff3893373107f317a1abf8518d852219092ead1bdf1db602dc4ac36d836e0c8412b6b1e0b42147deab95d355741fc72234b52f3399a56ba8f9
diff --git a/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/md5 b/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/md5
new file mode 100644
index 0000000000000..c0aec7507b021
--- /dev/null
+++ b/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/md5
@@ -0,0 +1 @@
+939db38382d3e3796f3d83c4a965ab4c
diff --git a/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/sha512 b/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/sha512
new file mode 100644
index 0000000000000..8e9e0f6158041
--- /dev/null
+++ b/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/sha512
@@ -0,0 +1 @@
+0c20dd814068df0fafaaba05029997b6420812ac3498df7484b8f77ccbcbbc3447e4b4ce6acbed7ab0b8293275d9c3f944bfa7ce5a8069a985b28d002a038005
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 68cdbbf3fca7c..84ffe8b7c5296 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = f154de2b6801ec8d5afaf58b73b830c8e71013c3
+SPARSEARRAYS_SHA1 = feb54ee5e49008bd157227099cafe604a67c36fb
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From fb8d7f1034e6d83c78a7e1f094d5767268603579 Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Wed, 3 Jan 2024 01:21:39 -0600
Subject: [PATCH 0526/1315] README: minor polish (#52691)

changes
- move `write_base_cache.jl` to `contrib/`
    `generate_precompile.jl` is also placed there
- In section "Source Code Organization", add `etc/`, remove `usr/`
    `usr/` appears only at build time.
- Some minor polish

---------

Co-authored-by: Viral B. Shah <ViralBShah@users.noreply.github.com>
---
 Makefile                             |  2 +-
 README.md                            | 14 +++++++-------
 {etc => contrib}/write_base_cache.jl |  0
 3 files changed, 8 insertions(+), 8 deletions(-)
 rename {etc => contrib}/write_base_cache.jl (100%)

diff --git a/Makefile b/Makefile
index 68a316b0a32ae..48c540156ea9b 100644
--- a/Makefile
+++ b/Makefile
@@ -185,7 +185,7 @@ $(build_depsbindir)/stringreplace: $(JULIAHOME)/contrib/stringreplace.c | $(buil
 
 julia-base-cache: julia-sysimg-$(JULIA_BUILD_MODE) | $(DIRS) $(build_datarootdir)/julia
 	@JULIA_BINDIR=$(call cygpath_w,$(build_bindir)) JULIA_FALLBACK_REPL=1 WINEPATH="$(call cygpath_w,$(build_bindir));$$WINEPATH" \
-		$(call spawn, $(JULIA_EXECUTABLE) --startup-file=no $(call cygpath_w,$(JULIAHOME)/etc/write_base_cache.jl) \
+		$(call spawn, $(JULIA_EXECUTABLE) --startup-file=no $(call cygpath_w,$(JULIAHOME)/contrib/write_base_cache.jl) \
 		$(call cygpath_w,$(build_datarootdir)/julia/base.cache))
 
 # public libraries, that are installed in $(prefix)/lib
diff --git a/README.md b/README.md
index fde5e8ee8a8bd..e25cfc758a4d3 100644
--- a/README.md
+++ b/README.md
@@ -77,7 +77,7 @@ interactive prompt into which you can enter expressions for
 evaluation.  You can read about [getting
 started](https://docs.julialang.org/en/v1/manual/getting-started/) in the manual.
 
-**Note**: Although some system package managers provide Julia, such
+**Note**: Although some OS package managers provide Julia, such
 installations are neither maintained nor endorsed by the Julia
 project. They may be outdated, broken and/or unmaintained. We
 recommend you use the official Julia binaries instead.
@@ -90,7 +90,7 @@ Then, acquire the source code by cloning the git repository:
 
     git clone https://github.com/JuliaLang/julia.git
 
-and then use the command prompt to change into the resulting julia directory. By default you will be building the latest unstable version of
+and then use the command prompt to change into the resulting julia directory. By default, you will be building the latest unstable version of
 Julia. However, most users should use the [most recent stable version](https://github.com/JuliaLang/julia/releases)
 of Julia. You can get this version by running:
 
@@ -117,7 +117,7 @@ started](https://docs.julialang.org/en/v1/manual/getting-started/)
 in the manual.
 
 Detailed build instructions, should they be necessary,
-are included in the [build documentation](https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/build/).
+are included in the [build documentation](https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/build/build.md).
 
 ### Uninstalling Julia
 
@@ -132,14 +132,14 @@ The Julia source code is organized as follows:
 | Directory         | Contents                                                           |
 | -                 | -                                                                  |
 | `base/`           | source code for the Base module (part of Julia's standard library) |
-| `stdlib/`         | source code for other standard library packages                    |
 | `cli/`            | source for the command line interface/REPL                         |
 | `contrib/`        | miscellaneous scripts                                              |
 | `deps/`           | external dependencies                                              |
 | `doc/src/`        | source for the user manual                                         |
+| `etc/`            | contains `startup.jl`                                               |
 | `src/`            | source for Julia language core                                     |
+| `stdlib/`         | source code for other standard library packages                    |
 | `test/`           | test suites                                                        |
-| `usr/`            | binaries and shared libraries loaded by Julia's standard libraries |
 
 ## Terminal, Editors and IDEs
 
@@ -147,7 +147,7 @@ The Julia REPL is quite powerful. See the section in the manual on
 [the Julia REPL](https://docs.julialang.org/en/v1/stdlib/REPL/)
 for more details.
 
-On Windows we highly recommend running Julia in a modern terminal,
+On Windows, we highly recommend running Julia in a modern terminal,
 such as [Windows Terminal from the Microsoft Store](https://aka.ms/terminal).
 
 Support for editing Julia is available for many
@@ -158,7 +158,7 @@ Support for editing Julia is available for many
 others.
 
 For users who prefer IDEs, we recommend using VS Code with the
-[julia-vscode](https://www.julia-vscode.org/) plugin.
+[julia-vscode](https://www.julia-vscode.org/) plugin.  
 For notebook users, [Jupyter](https://jupyter.org/) notebook support is available through the
 [IJulia](https://github.com/JuliaLang/IJulia.jl) package, and
 the [Pluto.jl](https://github.com/fonsp/Pluto.jl) package provides Pluto notebooks.
diff --git a/etc/write_base_cache.jl b/contrib/write_base_cache.jl
similarity index 100%
rename from etc/write_base_cache.jl
rename to contrib/write_base_cache.jl

From 792a35b8b5d3dc102622bdead551e485a24e3a54 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Wed, 3 Jan 2024 19:23:38 +0600
Subject: [PATCH 0527/1315] Show Numbers compactly when typeinfo is a Union
 with Nothing or Missing (#48822)

---
 base/rational.jl |  2 +-
 base/ryu/Ryu.jl  |  2 +-
 base/show.jl     |  3 ++-
 test/show.jl     | 14 ++++++++++++++
 4 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/base/rational.jl b/base/rational.jl
index 5288492e72e71..1b060384d95b2 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -95,7 +95,7 @@ end
 function show(io::IO, x::Rational)
     show(io, numerator(x))
 
-    if isone(denominator(x)) && get(io, :typeinfo, Any) <: Rational
+    if isone(denominator(x)) && nonnothing_nonmissing_typeinfo(io) <: Rational
         return
     end
 
diff --git a/base/ryu/Ryu.jl b/base/ryu/Ryu.jl
index 9b236caeb6ff1..89589aa4ab668 100644
--- a/base/ryu/Ryu.jl
+++ b/base/ryu/Ryu.jl
@@ -112,7 +112,7 @@ end
 function Base.show(io::IO, x::T, forceuntyped::Bool=false, fromprint::Bool=false) where {T <: Base.IEEEFloat}
     compact = get(io, :compact, false)::Bool
     buf = Base.StringVector(neededdigits(T))
-    typed = !forceuntyped && !compact && get(io, :typeinfo, Any) != typeof(x)
+    typed = !forceuntyped && !compact && Base.nonnothing_nonmissing_typeinfo(io) != typeof(x)
     pos = writeshortest(buf, 1, x, false, false, true, -1,
         (x isa Float32 && !fromprint) ? UInt8('f') : UInt8('e'), false, UInt8('.'), typed, compact)
     write(io, resize!(buf, pos - 1))
diff --git a/base/show.jl b/base/show.jl
index eb9f7bcece49d..db0b429f3386f 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1231,8 +1231,9 @@ function show(io::IO, tn::Core.TypeName)
     print(io, ")")
 end
 
+nonnothing_nonmissing_typeinfo(io::IO) = nonmissingtype(nonnothingtype(get(io, :typeinfo, Any)))
+show(io::IO, b::Bool) = print(io, nonnothing_nonmissing_typeinfo(io) === Bool ? (b ? "1" : "0") : (b ? "true" : "false"))
 show(io::IO, ::Nothing) = print(io, "nothing")
-show(io::IO, b::Bool) = print(io, get(io, :typeinfo, Any) === Bool ? (b ? "1" : "0") : (b ? "true" : "false"))
 show(io::IO, n::Signed) = (write(io, string(n)); nothing)
 show(io::IO, n::Unsigned) = print(io, "0x", string(n, pad = sizeof(n)<<1, base = 16))
 print(io::IO, n::Unsigned) = print(io, string(n))
diff --git a/test/show.jl b/test/show.jl
index 08a29612b245c..b6106c710931c 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2170,6 +2170,20 @@ replstrcolor(x) = sprint((io, x) -> show(IOContext(io, :limit => true, :color =>
     @test_repr "Bool[1, 0]"
 end
 
+@testset "Unions with Bool (#39590)" begin
+    @test repr([missing, false]) == "Union{Missing, Bool}[missing, 0]"
+    @test_repr "Union{Bool, Nothing}[1, 0, nothing]"
+end
+
+# issue #26847
+@test_repr "Union{Missing, Float32}[1.0]"
+
+# intersection of #45396 and #48822
+@test_repr "Union{Missing, Rational{Int64}}[missing, 1//2, 2]"
+
+# Don't go too far with #48822
+@test_repr "Union{String, Bool}[true]"
+
 # issue #30505
 @test repr(Union{Tuple{Char}, Tuple{Char, Char}}[('a','b')]) == "Union{Tuple{Char}, Tuple{Char, Char}}[('a', 'b')]"
 

From ca0a266e4f6cefc312477aadace00b7d766a82b6 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Wed, 3 Jan 2024 19:34:38 +0600
Subject: [PATCH 0528/1315] Test BracketedSort on fully pathological inputs
 (#52653)

---
 test/sorting.jl | 52 ++++++++++++++++++++-----------------------------
 1 file changed, 21 insertions(+), 31 deletions(-)

diff --git a/test/sorting.jl b/test/sorting.jl
index 35635d8588f93..ad821e38efe55 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -1036,40 +1036,30 @@ end
     @test issorted(sort!(rand(100), Base.Sort.InitialOptimizations(DispatchLoopTestAlg()), Base.Order.Forward))
 end
 
-@testset "partialsort tests added for BracketedSort #52006" begin
-    x = rand(Int, 1000)
-    @test partialsort(x, 1) == minimum(x)
-    @test partialsort(x, 1000) == maximum(x)
-    sx = sort(x)
-    for i in [1, 2, 4, 10, 11, 425, 500, 845, 991, 997, 999, 1000]
-        @test partialsort(x, i) == sx[i]
-    end
-    for i in [1:1, 1:2, 1:5, 1:8, 1:9, 1:11, 1:108, 135:812, 220:586, 363:368, 450:574, 458:597, 469:638, 487:488, 500:501, 584:594, 1000:1000]
-        @test partialsort(x, i) == sx[i]
+# Pathologize 0 is a noop, pathologize 3 is fully pathological
+function pathologize!(x, level)
+    Base.require_one_based_indexing(x)
+    k2 = Int(cbrt(length(x))^2)
+    seed = hash(length(x), Int === Int64 ? 0x85eb830e0216012d : 0xae6c4e15)
+    for a in 1:level
+        seed = hash(a, seed)
+        x[mod.(hash.(1:k2, seed), range.(1:k2,lastindex(x)))] .= a
     end
+    x
+end
 
-    # Semi-pathological input
-    seed = hash(1000, Int === Int64 ? 0x85eb830e0216012d : 0xae6c4e15)
-    seed = hash(1, seed)
-    for i in 1:100
-        j = mod(hash(i, seed), i:1000)
-        x[j] = typemax(Int)
+@testset "partialsort tests added for BracketedSort #52006" begin
+    for x in [pathologize!.(Ref(rand(Int, 1000)), 0:3); pathologize!.(Ref(rand(1000)), 0:3); [pathologize!(rand(Int, 1_000_000), 3)]]
+        @test partialsort(x, 1) == minimum(x)
+        @test partialsort(x, lastindex(x)) == maximum(x)
+        sx = sort(x)
+        for i in [1, 2, 4, 10, 11, 425, 500, 845, 991, 997, 999, 1000]
+            @test partialsort(x, i) == sx[i]
+        end
+        for i in [1:1, 1:2, 1:5, 1:8, 1:9, 1:11, 1:108, 135:812, 220:586, 363:368, 450:574, 458:597, 469:638, 487:488, 500:501, 584:594, 1000:1000]
+            @test partialsort(x, i) == sx[i]
+        end
     end
-    @test partialsort(x, 500) == sort(x)[500]
-
-    # Fully pathological input
-    # it would be too much trouble to actually construct a valid pathological input, so we
-    # construct an invalid pathological input.
-    # This test is kind of sketchy because it passes invalid inputs to the function
-    # Temporarily removed due to flakey test failures. See #52642 for details.
-    # for i in [1:6, 1:483, 1:957, 77:86, 118:478, 223:227, 231:970, 317:958, 500:501, 500:501, 500:501, 614:620, 632:635, 658:665, 933:940, 937:942, 997:1000, 999:1000]
-    #     x = rand(1:5, 1000)
-    #     @test partialsort(x, i, lt=(<=)) == sort(x)[i]
-    # end
-    # for i in [1, 7, 8, 490, 495, 852, 993, 996, 1000]
-    #     x = rand(1:5, 1000)
-    #     @test partialsort(x, i, lt=(<=)) == sort(x)[i]
-    # end
 end
 
 # This testset is at the end of the file because it is slow.

From 3a3af82d47b22c8fad566661ed7ecec2b54e077d Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Wed, 3 Jan 2024 21:29:42 +0600
Subject: [PATCH 0529/1315] Fix whitespace in README.md (#52714)

Fixup for #52691, fixes the whitespace CI check.

cc @inkydragon, @ViralBShah
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index e25cfc758a4d3..c5c4f3f2730ac 100644
--- a/README.md
+++ b/README.md
@@ -136,7 +136,7 @@ The Julia source code is organized as follows:
 | `contrib/`        | miscellaneous scripts                                              |
 | `deps/`           | external dependencies                                              |
 | `doc/src/`        | source for the user manual                                         |
-| `etc/`            | contains `startup.jl`                                               |
+| `etc/`            | contains `startup.jl`                                              |
 | `src/`            | source for Julia language core                                     |
 | `stdlib/`         | source code for other standard library packages                    |
 | `test/`           | test suites                                                        |
@@ -158,7 +158,7 @@ Support for editing Julia is available for many
 others.
 
 For users who prefer IDEs, we recommend using VS Code with the
-[julia-vscode](https://www.julia-vscode.org/) plugin.  
+[julia-vscode](https://www.julia-vscode.org/) plugin.\
 For notebook users, [Jupyter](https://jupyter.org/) notebook support is available through the
 [IJulia](https://github.com/JuliaLang/IJulia.jl) package, and
 the [Pluto.jl](https://github.com/fonsp/Pluto.jl) package provides Pluto notebooks.

From d97ab8a0cce34a8a99c43b4f04810b80d70da642 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 3 Jan 2024 22:17:26 +0100
Subject: [PATCH 0530/1315] sroa: Fix small logic bug (#52717)

This fixes #52703, which happened when a function had a foldable,
try-catch-with-scope inside an ordinary try/catch. The fix is to simply
ignore the ordinary try/catch and treat it as a regular fallthrough
terminator.
---
 base/compiler/ssair/passes.jl |  7 ++++---
 test/compiler/irpasses.jl     | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 7b8ca7ddede3d..5ba8acd03fc7c 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1209,10 +1209,11 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
         end
         if scope_mapping !== nothing && did_just_finish_bb(compact)
             bb = compact.active_result_bb - 1
-            if isexpr(stmt, :leave)
-                update_scope_mapping!(scope_mapping, bb+1, scope_mapping[block_for_inst(compact, scope_mapping[bb])])
+            bbs = scope_mapping[bb]
+            if isexpr(stmt, :leave) && bbs != SSAValue(0)
+                update_scope_mapping!(scope_mapping, bb+1, scope_mapping[block_for_inst(compact, bbs)])
             else
-                update_scope_mapping!(scope_mapping, bb+1, scope_mapping[bb])
+                update_scope_mapping!(scope_mapping, bb+1, bbs)
             end
         end
         # check whether this statement is `getfield` / `setfield!` (or other "interesting" statement)
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 2297e4de029f4..43027ff740e43 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1725,3 +1725,18 @@ function f52610()
     return nothing
 end
 @test code_typed(f52610)[1][2] === Nothing
+
+# Issue #52703
+@eval function f52703()
+    try
+        $(Expr(:tryfinally,
+            Expr(:block,
+                Expr(:tryfinally, :(), :(), 2),
+                :(return Base.inferencebarrier(Core.current_scope)()::Int)),
+        :(), 1))
+    catch
+        return 1
+    end
+    return 0
+end
+@test code_typed(f52703)[1][2] === Int

From 0f6c72c71bc947282ae18715c09f93a22828aab7 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 4 Jan 2024 03:48:50 +0600
Subject: [PATCH 0531/1315] Replace most occurances of http with https when the
 https url is valid (#52566)

This should be minor and mostly NFC.
---
 CONTRIBUTING.md                                        |  2 +-
 HISTORY.md                                             |  4 ++--
 Make.inc                                               |  4 ++--
 Makefile                                               |  2 +-
 base/compiler/sort.jl                                  |  2 +-
 base/fastmath.jl                                       |  6 +++---
 base/math.jl                                           |  2 +-
 base/sort.jl                                           |  2 +-
 base/special/cbrt.jl                                   |  2 +-
 .../llvm-libunwind-freebsd-libgcc-api-compat.patch     |  2 +-
 doc/src/assets/cover.tex                               |  2 +-
 doc/src/assets/custom.sty                              |  4 ++--
 src/crc32c.c                                           |  2 +-
 src/debuginfo.cpp                                      |  2 +-
 src/disasm.cpp                                         |  2 +-
 src/flisp/compiler.lsp                                 |  2 +-
 src/mach_excServer.c                                   |  2 +-
 src/signals-mach.c                                     |  2 +-
 src/support/platform.h                                 |  2 +-
 src/support/strptime.c                                 |  4 ++--
 stdlib/Dates/docs/src/index.md                         |  2 +-
 stdlib/Dates/test/accessors.jl                         |  8 ++++----
 stdlib/Dates/test/io.jl                                |  2 +-
 stdlib/LinearAlgebra/docs/src/index.md                 | 10 +++++-----
 stdlib/LinearAlgebra/src/bitarray.jl                   |  2 +-
 stdlib/LinearAlgebra/src/blas.jl                       |  4 ++--
 stdlib/LinearAlgebra/src/bunchkaufman.jl               |  4 ++--
 stdlib/LinearAlgebra/src/svd.jl                        |  4 ++--
 stdlib/Markdown/docs/src/index.md                      |  2 +-
 stdlib/REPL/src/latex_symbols.jl                       |  2 +-
 stdlib/Random/src/Xoshiro.jl                           |  2 +-
 stdlib/Random/src/generation.jl                        |  2 +-
 stdlib/Random/src/normal.jl                            |  2 +-
 stdlib/Sockets/src/IPAddr.jl                           |  2 +-
 stdlib/Unicode/test/runtests.jl                        |  2 +-
 test/euler.jl                                          |  2 +-
 test/file.jl                                           |  2 +-
 test/mod2pi.jl                                         |  2 +-
 38 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0131dcbc4a278..e028cf486c0f2 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -347,7 +347,7 @@ please remove the `backport-X.Y` tag from the originating pull request for the c
 ### Git Recommendations For Pull Requests
 
  - Avoid working from the `master` branch of your fork, creating a new branch will make it easier if Julia's `master` changes and you need to update your pull request.
- - Try to [squash](http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html) together small commits that make repeated changes to the same section of code so your pull request is easier to review. A reasonable number of separate well-factored commits is fine, especially for larger changes.
+ - Try to [squash](https://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html) together small commits that make repeated changes to the same section of code so your pull request is easier to review. A reasonable number of separate well-factored commits is fine, especially for larger changes.
  - If any conflicts arise due to changes in Julia's `master`, prefer updating your pull request branch with `git rebase` versus `git merge` or `git pull`, since the latter will introduce merge commits that clutter the git history with noise that makes your changes more difficult to review.
  - Descriptive commit messages are good.
  - Using `git add -p` or `git add -i` can be useful to avoid accidentally committing unrelated changes.
diff --git a/HISTORY.md b/HISTORY.md
index 1d46189c74c51..d9486c361b934 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -5291,7 +5291,7 @@ Language tooling improvements
      talk](https://www.youtube.com/watch?v=e6-hcOHO0tc&list=PLP8iPy9hna6SQPwZUDtAM59-wPzCPyD_S&index=5)
      on Gallium shows off various features of the debugger.
 
-   * The [Juno IDE](http://junolab.org) has matured significantly, and now
+   * The [Juno IDE](https://junolab.org) has matured significantly, and now
      also includes support for plotting and debugging.
 
    * [Cxx.jl](https://github.com/Keno/Cxx.jl) provides a convenient FFI for
@@ -5689,7 +5689,7 @@ Library improvements
 
   * Other improvements
 
-    * You can now tab-complete emoji via their [short names](http://www.emoji-cheat-sheet.com/), using `\:name:<tab>` ([#10709]).
+    * You can now tab-complete emoji via their [short names](https://www.emoji-cheat-sheet.com/), using `\:name:<tab>` ([#10709]).
 
     * `gc_enable` subsumes `gc_disable`, and also returns the previous GC state.
 
diff --git a/Make.inc b/Make.inc
index 910fcdc276e3b..9b826ca4a89c8 100644
--- a/Make.inc
+++ b/Make.inc
@@ -571,10 +571,10 @@ CXX_BASE := ccache
 FC_BASE  := ccache
 ifeq ($(USECLANG),1)
 # ccache and Clang don't do well together
-# http://petereisentraut.blogspot.be/2011/05/ccache-and-clang.html
+# https://petereisentraut.blogspot.be/2011/05/ccache-and-clang.html
 CC += -Qunused-arguments
 CXX += -Qunused-arguments
-# http://petereisentraut.blogspot.be/2011/09/ccache-and-clang-part-2.html
+# https://petereisentraut.blogspot.be/2011/09/ccache-and-clang-part-2.html
 export CCACHE_CPP2 := yes
 endif
 else #USECCACHE
diff --git a/Makefile b/Makefile
index 48c540156ea9b..056436af89fe3 100644
--- a/Makefile
+++ b/Makefile
@@ -160,7 +160,7 @@ release-candidate: release testall
 	@echo 8. Replace github release tarball with tarballs created from make light-source-dist and make full-source-dist with USE_BINARYBUILDER=0
 	@echo 9. Check that 'make && make install && make test' succeed with unpacked tarballs even without Internet access.
 	@echo 10. Follow packaging instructions in doc/src/devdocs/build/distributing.md to create binary packages for all platforms
-	@echo 11. Upload to AWS, update https://julialang.org/downloads and http://status.julialang.org/stable links
+	@echo 11. Upload to AWS, update https://julialang.org/downloads and https://status.julialang.org/stable links
 	@echo 12. Update checksums on AWS for tarball and packaged binaries
 	@echo 13. Update versions.json. Wait at least 60 minutes before proceeding to step 14.
 	@echo 14. Push to Juliaup (https://github.com/JuliaLang/juliaup/wiki/Adding-a-Julia-version)
diff --git a/base/compiler/sort.jl b/base/compiler/sort.jl
index 71d2f8a51cd59..6c8571f6198e6 100644
--- a/base/compiler/sort.jl
+++ b/base/compiler/sort.jl
@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # reference on sorted binary search:
-#   http://www.tbray.org/ongoing/When/200x/2003/03/22/Binary
+#   https://www.tbray.org/ongoing/When/200x/2003/03/22/Binary
 
 # index of the first value of vector a that is greater than or equal to x;
 # returns lastindex(v)+1 if x is greater than all values in v.
diff --git a/base/fastmath.jl b/base/fastmath.jl
index 44440ebad2050..a34a4ca66e06b 100644
--- a/base/fastmath.jl
+++ b/base/fastmath.jl
@@ -6,7 +6,7 @@
 # strict IEEE semantics.
 
 # This allows the following transformations. For more information see
-# http://llvm.org/docs/LangRef.html#fast-math-flags:
+# https://llvm.org/docs/LangRef.html#fast-math-flags:
 # nnan: No NaNs - Allow optimizations to assume the arguments and
 #       result are not NaN. Such optimizations are required to retain
 #       defined behavior over NaNs, but the value of the result is
@@ -136,7 +136,7 @@ may violate strict IEEE semantics. This allows the fastest possible operation,
 but results are undefined -- be careful when doing this, as it may change numerical
 results.
 
-This sets the [LLVM Fast-Math flags](http://llvm.org/docs/LangRef.html#fast-math-flags),
+This sets the [LLVM Fast-Math flags](https://llvm.org/docs/LangRef.html#fast-math-flags),
 and corresponds to the `-ffast-math` option in clang. See [the notes on performance
 annotations](@ref man-performance-annotations) for more details.
 
@@ -309,7 +309,7 @@ end
         Complex{T}(c, s)
     end
 
-    # See <http://en.cppreference.com/w/cpp/numeric/complex>
+    # See <https://en.cppreference.com/w/cpp/numeric/complex>
     pow_fast(x::T, y::T) where {T<:ComplexTypes} = exp(y*log(x))
     pow_fast(x::T, y::Complex{T}) where {T<:FloatTypes} = exp(y*log(x))
     pow_fast(x::Complex{T}, y::T) where {T<:FloatTypes} = exp(y*log(x))
diff --git a/base/math.jl b/base/math.jl
index ca2f064e49ee7..752a15b7c7777 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -1294,7 +1294,7 @@ end
 function add22condh(xh::Float64, xl::Float64, yh::Float64, yl::Float64)
     # This algorithm, due to Dekker, computes the sum of two
     # double-double numbers and returns the high double. References:
-    # [1] http://www.digizeitschriften.de/en/dms/img/?PID=GDZPPN001170007
+    # [1] https://www.digizeitschriften.de/en/dms/img/?PID=GDZPPN001170007
     # [2] https://doi.org/10.1007/BF01397083
     r = xh+yh
     s = (abs(xh) > abs(yh)) ? (xh-r+yh+yl+xl) : (yh-r+xh+xl+yl)
diff --git a/base/sort.jl b/base/sort.jl
index 9272846618a0e..eb57da376f4ab 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -172,7 +172,7 @@ partialsort(v::AbstractVector, k::Union{Integer,OrdinalRange}; kws...) =
     partialsort!(copymutable(v), k; kws...)
 
 # reference on sorted binary search:
-#   http://www.tbray.org/ongoing/When/200x/2003/03/22/Binary
+#   https://www.tbray.org/ongoing/When/200x/2003/03/22/Binary
 
 # index of the first value of vector a that is greater than or equivalent to x;
 # returns lastindex(v)+1 if x is greater than all values in v.
diff --git a/base/special/cbrt.jl b/base/special/cbrt.jl
index 9fda5c41fb09e..ce3a3d67e3ba4 100644
--- a/base/special/cbrt.jl
+++ b/base/special/cbrt.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-# Float32/Float64 based on C implementations from FDLIBM (http://www.netlib.org/fdlibm/)
+# Float32/Float64 based on C implementations from FDLIBM (https://www.netlib.org/fdlibm/)
 # and FreeBSD:
 #
 ## ====================================================
diff --git a/deps/patches/llvm-libunwind-freebsd-libgcc-api-compat.patch b/deps/patches/llvm-libunwind-freebsd-libgcc-api-compat.patch
index afb4b941d5b92..0e517d8ec7aa8 100644
--- a/deps/patches/llvm-libunwind-freebsd-libgcc-api-compat.patch
+++ b/deps/patches/llvm-libunwind-freebsd-libgcc-api-compat.patch
@@ -16,7 +16,7 @@ single FDE. I suspect this was just an Apple bug, compensated by Apple-
 specific code in LLVM.
 
 See lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp and
-http://lists.llvm.org/pipermail/llvm-dev/2013-April/061737.html
+https://lists.llvm.org/pipermail/llvm-dev/2013-April/061737.html
 for more detail.
 
 This change is based on the LLVM RTDyldMemoryManager.cpp. It should
diff --git a/doc/src/assets/cover.tex b/doc/src/assets/cover.tex
index 67b77e520acd3..b959477913f59 100644
--- a/doc/src/assets/cover.tex
+++ b/doc/src/assets/cover.tex
@@ -15,7 +15,7 @@
 %% ---- reset page geometry for cover page
 \newgeometry{left=2cm,right=2cm,bottom=3cm}
 % ref: memman@v3.7q, P65, "4.1. Styling the titling"
-%   http://mirrors.ctan.org/macros/latex/contrib/memoir/memman.pdf
+%   https://mirrors.ctan.org/macros/latex/contrib/memoir/memman.pdf
 \begin{titlingpage}
     % set background image
     \BgThispage
diff --git a/doc/src/assets/custom.sty b/doc/src/assets/custom.sty
index 03e6ff805cd3f..ebc11f0414945 100644
--- a/doc/src/assets/custom.sty
+++ b/doc/src/assets/custom.sty
@@ -6,7 +6,7 @@
 \usepackage{geometry}
 % "some": use \BgThispage to change background
 % ref: background@v2.1,# 2.1 Options, "pages="
-%   http://mirrors.ctan.org/macros/latex/contrib/background/background.pdf
+%   https://mirrors.ctan.org/macros/latex/contrib/background/background.pdf
 \usepackage[pages=some]{background}
 
 %% Color definitions for Julia
@@ -27,7 +27,7 @@ contents={
 %% Place the background image `title-bg' in the right place via `tikz'.
 % tikz option "remember picture", "overlay"
 % ref: pgfmanual@3.1.9a, #17.13.1 Referencing a Node in a Different Picture\
-%   http://mirrors.ctan.org/graphics/pgf/base/doc/pgfmanual.pdf
+%   https://mirrors.ctan.org/graphics/pgf/base/doc/pgfmanual.pdf
 \begin{tikzpicture}[remember picture,overlay,draw=white]
   \draw [path picture={
     % ref: pgfmanual, 15.6, "Predefined node path picture bounding box"
diff --git a/src/crc32c.c b/src/crc32c.c
index b38f9d6c0e765..1d667b3dbf656 100644
--- a/src/crc32c.c
+++ b/src/crc32c.c
@@ -3,7 +3,7 @@
  * Version 1.1  1 Aug 2013  Mark Adler, updates from Version 1.2 5 June 2021
  *
  * Code retrieved in August 2016 from August 2013 post by Mark Adler on
- *    http://stackoverflow.com/questions/17645167/implementing-sse-4-2s-crc32c-in-software
+ *    https://stackoverflow.com/questions/17645167/implementing-sse-4-2s-crc32c-in-software
  * Modified for use in libjulia:
  *    - exported function renamed to jl_crc32c, DLL exports added.
  *    - removed main() function
diff --git a/src/debuginfo.cpp b/src/debuginfo.cpp
index b2b4743962fc0..47f8422133600 100644
--- a/src/debuginfo.cpp
+++ b/src/debuginfo.cpp
@@ -1364,7 +1364,7 @@ enum DW_EH_PE : uint8_t {
 // Parse the CIE and return the type of encoding used by FDE
 static DW_EH_PE parseCIE(const uint8_t *Addr, const uint8_t *End)
 {
-    // http://www.airs.com/blog/archives/460
+    // https://www.airs.com/blog/archives/460
     // Length (4 bytes)
     uint32_t cie_size = *(const uint32_t*)Addr;
     const uint8_t *cie_addr = Addr + 4;
diff --git a/src/disasm.cpp b/src/disasm.cpp
index 2e0cb22e43a1c..57896dc2ee4d8 100644
--- a/src/disasm.cpp
+++ b/src/disasm.cpp
@@ -16,7 +16,7 @@
 //
 //    University of Illinois at Urbana-Champaign
 //
-//    http://llvm.org
+//    https://llvm.org
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy of
 // this software and associated documentation files (the "Software"), to deal with
diff --git a/src/flisp/compiler.lsp b/src/flisp/compiler.lsp
index fdc516dce3ea8..e5a79e8fee6bb 100644
--- a/src/flisp/compiler.lsp
+++ b/src/flisp/compiler.lsp
@@ -864,7 +864,7 @@
 
 		 (else #f)))))))
 
-; From SRFI 89 by Marc Feeley (http://srfi.schemers.org/srfi-89/srfi-89.html)
+; From SRFI 89 by Marc Feeley (https://srfi.schemers.org/srfi-89/srfi-89.html)
 ; Copyright (C) Marc Feeley 2006. All Rights Reserved.
 ;
 ; "alist" is a list of pairs of the form "(keyword . value)"
diff --git a/src/mach_excServer.c b/src/mach_excServer.c
index 7e99331fa8554..669fd0e2313aa 100644
--- a/src/mach_excServer.c
+++ b/src/mach_excServer.c
@@ -20,7 +20,7 @@
  * terms of an Apple operating system software license agreement.
  *
  * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * https://www.opensource.apple.com/apsl/ and read it before using this file.
  *
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
diff --git a/src/signals-mach.c b/src/signals-mach.c
index 87a2eb4758d4a..5063aa3e8e0d2 100644
--- a/src/signals-mach.c
+++ b/src/signals-mach.c
@@ -412,7 +412,7 @@ kern_return_t catch_mach_exception_raise_state_identity(
 static void attach_exception_port(thread_port_t thread, int segv_only)
 {
     kern_return_t ret;
-    // http://www.opensource.apple.com/source/xnu/xnu-2782.1.97/osfmk/man/thread_set_exception_ports.html
+    // https://www.opensource.apple.com/source/xnu/xnu-2782.1.97/osfmk/man/thread_set_exception_ports.html
     exception_mask_t mask = EXC_MASK_BAD_ACCESS;
     if (!segv_only)
         mask |= EXC_MASK_ARITHMETIC;
diff --git a/src/support/platform.h b/src/support/platform.h
index 56f8cafbc89fa..9ab28ac1c70c3 100644
--- a/src/support/platform.h
+++ b/src/support/platform.h
@@ -8,7 +8,7 @@
  * based of compiler-specific pre-defined macros. It is based on the
  * information that can be found at the following address:
  *
- *     http://sourceforge.net/p/predef/wiki/Home/
+ *     https://sourceforge.net/p/predef/wiki/Home/
  *
  * Possible values include:
  *      Compiler:
diff --git a/src/support/strptime.c b/src/support/strptime.c
index ab75ee05ee8db..27c86c9e4f2b8 100644
--- a/src/support/strptime.c
+++ b/src/support/strptime.c
@@ -134,7 +134,7 @@ static const char * const nadt[5] = {
 
 /*
  * Table to determine the ordinal date for the start of a month.
- * Ref: http://en.wikipedia.org/wiki/ISO_week_date
+ * Ref: https://en.wikipedia.org/wiki/ISO_week_date
  */
 static const int start_of_month[2][13] = {
 	/* non-leap year */
@@ -147,7 +147,7 @@ static const int start_of_month[2][13] = {
  * Calculate the week day of the first day of a year. Valid for
  * the Gregorian calendar, which began Sept 14, 1752 in the UK
  * and its colonies. Ref:
- * http://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week
+ * https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week
  */
 
 static int
diff --git a/stdlib/Dates/docs/src/index.md b/stdlib/Dates/docs/src/index.md
index db452b1912a27..35ec6771efc55 100644
--- a/stdlib/Dates/docs/src/index.md
+++ b/stdlib/Dates/docs/src/index.md
@@ -18,7 +18,7 @@ represents a continuously increasing machine timeline based on the UT second [^1
 [`DateTime`](@ref) type is not aware of time zones (*naive*, in Python parlance),
 analogous to a *LocalDateTime* in Java 8. Additional time zone functionality
 can be added through the [TimeZones.jl package](https://github.com/JuliaTime/TimeZones.jl/), which
-compiles the [IANA time zone database](http://www.iana.org/time-zones). Both [`Date`](@ref) and
+compiles the [IANA time zone database](https://www.iana.org/time-zones). Both [`Date`](@ref) and
 [`DateTime`](@ref) are based on the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) standard, which follows the proleptic Gregorian calendar.
 One note is that the ISO 8601 standard is particular about BC/BCE dates. In general, the last
 day of the BC/BCE era, 1-12-31 BC/BCE, was followed by 1-1-1 AD/CE, thus no year zero exists.
diff --git a/stdlib/Dates/test/accessors.jl b/stdlib/Dates/test/accessors.jl
index b690a81d70e49..240de42eaa1dc 100644
--- a/stdlib/Dates/test/accessors.jl
+++ b/stdlib/Dates/test/accessors.jl
@@ -153,7 +153,7 @@ end
     @test Dates.week(Dates.Date(2010, 1, 1)) == 53
     @test Dates.week(Dates.Date(2010, 1, 2)) == 53
     @test Dates.week(Dates.Date(2010, 1, 2)) == 53
-    # Tests from http://www.epochconverter.com/date-and-time/weeknumbers-by-year.php?year=1999
+    # Tests from https://www.epochconverter.com/date-and-time/weeknumbers-by-year.php?year=1999
     dt = Dates.DateTime(1999, 12, 27)
     dt1 = Dates.Date(1999, 12, 27)
     check = (52, 52, 52, 52, 52, 52, 52, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2)
@@ -163,7 +163,7 @@ end
         dt = dt + Dates.Day(1)
         dt1 = dt1 + Dates.Day(1)
     end
-    # Tests from http://www.epochconverter.com/date-and-time/weeknumbers-by-year.php?year=2000
+    # Tests from https://www.epochconverter.com/date-and-time/weeknumbers-by-year.php?year=2000
     dt = Dates.DateTime(2000, 12, 25)
     dt1 = Dates.Date(2000, 12, 25)
     for i = 1:21
@@ -172,7 +172,7 @@ end
         dt = dt + Dates.Day(1)
         dt1 = dt1 + Dates.Day(1)
     end
-    # Test from http://www.epochconverter.com/date-and-time/weeknumbers-by-year.php?year=2030
+    # Test from https://www.epochconverter.com/date-and-time/weeknumbers-by-year.php?year=2030
     dt = Dates.DateTime(2030, 12, 23)
     dt1 = Dates.Date(2030, 12, 23)
     for i = 1:21
@@ -181,7 +181,7 @@ end
         dt = dt + Dates.Day(1)
         dt1 = dt1 + Dates.Day(1)
     end
-    # Tests from http://www.epochconverter.com/date-and-time/weeknumbers-by-year.php?year=2004
+    # Tests from https://www.epochconverter.com/date-and-time/weeknumbers-by-year.php?year=2004
     dt = Dates.DateTime(2004, 12, 20)
     dt1 = Dates.Date(2004, 12, 20)
     check = (52, 52, 52, 52, 52, 52, 52, 53, 53, 53, 53, 53, 53, 53, 1, 1, 1, 1, 1, 1, 1)
diff --git a/stdlib/Dates/test/io.jl b/stdlib/Dates/test/io.jl
index 2c99ac45d0c58..092a58d5d70d1 100644
--- a/stdlib/Dates/test/io.jl
+++ b/stdlib/Dates/test/io.jl
@@ -47,7 +47,7 @@ end
 end
 
 @testset "DateTime parsing" begin
-    # Useful reference for different locales: http://library.princeton.edu/departments/tsd/katmandu/reference/months.html
+    # Useful reference for different locales: https://library.princeton.edu/departments/tsd/katmandu/reference/months.html
 
     # Allow parsing of strings which are not representable as a TimeType
     str = "02/15/1996 25:00"
diff --git a/stdlib/LinearAlgebra/docs/src/index.md b/stdlib/LinearAlgebra/docs/src/index.md
index d263dfe299206..177eec936a7db 100644
--- a/stdlib/LinearAlgebra/docs/src/index.md
+++ b/stdlib/LinearAlgebra/docs/src/index.md
@@ -157,7 +157,7 @@ sorts of systems of linear equations.
 
 ## Special matrices
 
-[Matrices with special symmetries and structures](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=3274)
+[Matrices with special symmetries and structures](https://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=3274)
 arise often in linear algebra and are frequently associated with various matrix factorizations.
 Julia features a rich collection of special matrix types, which allow for fast computation with
 specialized routines that are specially developed for particular matrix types.
@@ -300,7 +300,7 @@ of the Linear Algebra documentation.
 | `QRCompactWY`      | Compact WY form of the QR factorization                                                                        |
 | `QRPivoted`        | Pivoted [QR factorization](https://en.wikipedia.org/wiki/QR_decomposition)                                     |
 | `LQ`               | [QR factorization](https://en.wikipedia.org/wiki/QR_decomposition) of `transpose(A)`                           |
-| `Hessenberg`       | [Hessenberg decomposition](http://mathworld.wolfram.com/HessenbergDecomposition.html)                          |
+| `Hessenberg`       | [Hessenberg decomposition](https://mathworld.wolfram.com/HessenbergDecomposition.html)                          |
 | `Eigen`            | [Spectral decomposition](https://en.wikipedia.org/wiki/Eigendecomposition_of_a_matrix)                         |
 | `GeneralizedEigen` | [Generalized spectral decomposition](https://en.wikipedia.org/wiki/Eigendecomposition_of_a_matrix#Generalized_eigenvalue_problem)                            |
 | `SVD`              | [Singular value decomposition](https://en.wikipedia.org/wiki/Singular_value_decomposition)                     |
@@ -402,7 +402,7 @@ up front and cache it for future reuse.
 
 ## Standard functions
 
-Linear algebra functions in Julia are largely implemented by calling functions from [LAPACK](http://www.netlib.org/lapack/).
+Linear algebra functions in Julia are largely implemented by calling functions from [LAPACK](https://www.netlib.org/lapack/).
 Sparse matrix factorizations call functions from [SuiteSparse](http://suitesparse.com).
 Other sparse solvers are available as Julia packages.
 
@@ -586,8 +586,8 @@ LinearAlgebra.rdiv!
 ## BLAS functions
 
 In Julia (as in much of scientific computation), dense linear-algebra operations are based on
-the [LAPACK library](http://www.netlib.org/lapack/), which in turn is built on top of basic linear-algebra
-building-blocks known as the [BLAS](http://www.netlib.org/blas/). There are highly optimized
+the [LAPACK library](https://www.netlib.org/lapack/), which in turn is built on top of basic linear-algebra
+building-blocks known as the [BLAS](https://www.netlib.org/blas/). There are highly optimized
 implementations of BLAS available for every computer architecture, and sometimes in high-performance
 linear algebra routines it is useful to call the BLAS functions directly.
 
diff --git a/stdlib/LinearAlgebra/src/bitarray.jl b/stdlib/LinearAlgebra/src/bitarray.jl
index d1857c3c38659..ccc9138d227a3 100644
--- a/stdlib/LinearAlgebra/src/bitarray.jl
+++ b/stdlib/LinearAlgebra/src/bitarray.jl
@@ -186,7 +186,7 @@ function istril(A::BitMatrix)
 end
 
 # fast 8x8 bit transpose from Henry S. Warrens's "Hacker's Delight"
-# http://www.hackersdelight.org/hdcodetxt/transpose8.c.txt
+# https://www.hackersdelight.org/hdcodetxt/transpose8.c.txt
 function transpose8x8(x::UInt64)
     y = x
     t = xor(y, y >>> 7) & 0x00aa00aa00aa00aa
diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 6cc0edfd9f3a1..5d8821cd6e009 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -10,7 +10,7 @@ using Base: require_one_based_indexing, USE_BLAS64
 
 export
 # Note: `xFUNC_NAME` is a placeholder for not exported BLAS functions
-#   ref: http://www.netlib.org/blas/blasqr.pdf
+#   ref: https://www.netlib.org/blas/blasqr.pdf
 # Level 1
     # xROTG
     # xROTMG
@@ -1065,7 +1065,7 @@ sbmv(uplo, k, A, x)
 Update vector `y` as `alpha*A*x + beta*y` where `A` is a symmetric band matrix of order
 `size(A,2)` with `k` super-diagonals stored in the argument `A`. The storage layout for `A`
 is described the reference BLAS module, level-2 BLAS at
-<http://www.netlib.org/lapack/explore-html/>.
+<https://www.netlib.org/lapack/explore-html/>.
 Only the [`uplo`](@ref stdlib-blas-uplo) triangle of `A` is used.
 
 Return the updated `y`.
diff --git a/stdlib/LinearAlgebra/src/bunchkaufman.jl b/stdlib/LinearAlgebra/src/bunchkaufman.jl
index 19f82167495f3..8d1ded9bf8111 100644
--- a/stdlib/LinearAlgebra/src/bunchkaufman.jl
+++ b/stdlib/LinearAlgebra/src/bunchkaufman.jl
@@ -150,7 +150,7 @@ The following functions are available for `BunchKaufman` objects:
 [`size`](@ref), `\\`, [`inv`](@ref), [`issymmetric`](@ref),
 [`ishermitian`](@ref), [`getindex`](@ref).
 
-[^Bunch1977]: J R Bunch and L Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. [url](http://www.ams.org/journals/mcom/1977-31-137/S0025-5718-1977-0428694-0/).
+[^Bunch1977]: J R Bunch and L Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. [url](https://www.ams.org/journals/mcom/1977-31-137/S0025-5718-1977-0428694-0/).
 
 # Examples
 ```jldoctest
@@ -429,7 +429,7 @@ end
 
 ## reconstruct the original matrix
 ## TODO: understand the procedure described at
-## http://www.nag.com/numeric/FL/nagdoc_fl22/pdf/F07/f07mdf.pdf
+## https://www.nag.com/numeric/FL/nagdoc_fl22/pdf/F07/f07mdf.pdf
 
 
 ##--------------------------------------------------------------------------
diff --git a/stdlib/LinearAlgebra/src/svd.jl b/stdlib/LinearAlgebra/src/svd.jl
index c1b886f616f02..dc8d717932be3 100644
--- a/stdlib/LinearAlgebra/src/svd.jl
+++ b/stdlib/LinearAlgebra/src/svd.jl
@@ -302,8 +302,8 @@ Iterating the decomposition produces the components `U`, `V`, `Q`, `D1`, `D2`, a
 
 The entries of `F.D1` and `F.D2` are related, as explained in the LAPACK
 documentation for the
-[generalized SVD](http://www.netlib.org/lapack/lug/node36.html) and the
-[xGGSVD3](http://www.netlib.org/lapack/explore-html/d6/db3/dggsvd3_8f.html)
+[generalized SVD](https://www.netlib.org/lapack/lug/node36.html) and the
+[xGGSVD3](https://www.netlib.org/lapack/explore-html/d6/db3/dggsvd3_8f.html)
 routine which is called underneath (in LAPACK 3.6.0 and newer).
 
 # Examples
diff --git a/stdlib/Markdown/docs/src/index.md b/stdlib/Markdown/docs/src/index.md
index 44f2f2dbfd688..30f530d1c6263 100644
--- a/stdlib/Markdown/docs/src/index.md
+++ b/stdlib/Markdown/docs/src/index.md
@@ -75,7 +75,7 @@ the text enclosed in square brackets, `[ ]`, is the name of the link and the tex
 parentheses, `( )`, is the URL.
 
 ```
-A paragraph containing a link to [Julia](http://www.julialang.org).
+A paragraph containing a link to [Julia](https://www.julialang.org).
 ```
 
 It's also possible to add cross-references to other documented functions/methods/variables within
diff --git a/stdlib/REPL/src/latex_symbols.jl b/stdlib/REPL/src/latex_symbols.jl
index bc406e1468710..00be62dbb170a 100644
--- a/stdlib/REPL/src/latex_symbols.jl
+++ b/stdlib/REPL/src/latex_symbols.jl
@@ -4,7 +4,7 @@
 # This is used for tab substitution in the REPL.
 
 # The initial symbol listing was generated from the W3C symbol mapping file:
-#         http://www.w3.org/Math/characters/unicode.xml
+#         https://www.w3.org/Math/characters/unicode.xml
 # by the following Julia script:
 #=
 import REPL
diff --git a/stdlib/Random/src/Xoshiro.jl b/stdlib/Random/src/Xoshiro.jl
index b16668e99584b..5569d6d5c1da5 100644
--- a/stdlib/Random/src/Xoshiro.jl
+++ b/stdlib/Random/src/Xoshiro.jl
@@ -10,7 +10,7 @@
 Xoshiro256++ is a fast pseudorandom number generator described by David Blackman and
 Sebastiano Vigna in "Scrambled Linear Pseudorandom Number Generators",
 ACM Trans. Math. Softw., 2021. Reference implementation is available
-at http://prng.di.unimi.it
+at https://prng.di.unimi.it
 
 Apart from the high speed, Xoshiro has a small memory footprint, making it suitable for
 applications where many different random states need to be held for long time.
diff --git a/stdlib/Random/src/generation.jl b/stdlib/Random/src/generation.jl
index 99017c8c76a82..23d53799a40ee 100644
--- a/stdlib/Random/src/generation.jl
+++ b/stdlib/Random/src/generation.jl
@@ -294,7 +294,7 @@ rem_knuth(a::T, b::T) where {T<:Unsigned} = b != 0 ? a % b : a
 # maximum multiple of k <= sup decremented by one,
 # that is 0xFFFF...FFFF if k = (typemax(T) - typemin(T)) + 1 and sup == typemax(T) - 1
 # with intentional underflow
-# see http://stackoverflow.com/questions/29182036/integer-arithmetic-add-1-to-uint-max-and-divide-by-n-without-overflow
+# see https://stackoverflow.com/questions/29182036/integer-arithmetic-add-1-to-uint-max-and-divide-by-n-without-overflow
 
 # sup == 0 means typemax(T) + 1
 maxmultiple(k::T, sup::T=zero(T)) where {T<:Unsigned} =
diff --git a/stdlib/Random/src/normal.jl b/stdlib/Random/src/normal.jl
index 9f663495c1c20..267d9db48fee8 100644
--- a/stdlib/Random/src/normal.jl
+++ b/stdlib/Random/src/normal.jl
@@ -3,7 +3,7 @@
 # Normally distributed random numbers using Ziggurat algorithm
 
 # The Ziggurat Method for generating random variables - Marsaglia and Tsang
-# Paper and reference code: http://www.jstatsoft.org/v05/i08/
+# Paper and reference code: https://www.jstatsoft.org/v05/i08/
 
 # randmtzig (covers also exponential variates)
 
diff --git a/stdlib/Sockets/src/IPAddr.jl b/stdlib/Sockets/src/IPAddr.jl
index 5b480ef30f20e..d3834a8b8bf73 100644
--- a/stdlib/Sockets/src/IPAddr.jl
+++ b/stdlib/Sockets/src/IPAddr.jl
@@ -140,7 +140,7 @@ end
 
 show(io::IO, ip::IPv6) = print(io,"ip\"",ip,"\"")
 # RFC 5952 compliant show function
-# http://tools.ietf.org/html/rfc5952
+# https://tools.ietf.org/html/rfc5952
 function print(io::IO,ip::IPv6)
     i = 8
     m = 0
diff --git a/stdlib/Unicode/test/runtests.jl b/stdlib/Unicode/test/runtests.jl
index 5248bd1e1fd27..2ee7b88ae966b 100644
--- a/stdlib/Unicode/test/runtests.jl
+++ b/stdlib/Unicode/test/runtests.jl
@@ -37,7 +37,7 @@ end
 
 @testset "unicode sa#15" begin
     #Tests from Unicode SA#15, "Unicode normalization forms"
-    #http://www.unicode.org/reports/tr15/
+    #https://www.unicode.org/reports/tr15/
 
     @testset "canonical equivalence" begin
         let ==(a::Array{Char},b::Array{Char}) = normalize(string(a...), :NFC)==normalize(string(b...), :NFC)
diff --git a/test/euler.jl b/test/euler.jl
index 9af79a44cc0d3..c8d0e9a734fd2 100644
--- a/test/euler.jl
+++ b/test/euler.jl
@@ -2,7 +2,7 @@
 
 ## Project Euler
 #
-#  problems: http://projecteuler.net/problems
+#  problems: https://projecteuler.net/problems
 #  solutions: https://code.google.com/p/projecteuler-solutions/wiki/ProjectEulerSolutions
 
 #1: 233168
diff --git a/test/file.jl b/test/file.jl
index 808fba52f9048..2dfd881b8a487 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -355,7 +355,7 @@ chmod(file, filemode(file) | 0o222)
 @test filesize(file) == 0
 
 # issue #26685
-@test !isfile("http://google.com")
+@test !isfile("https://google.com")
 
 if Sys.iswindows()
     permissions = 0o444
diff --git a/test/mod2pi.jl b/test/mod2pi.jl
index 5b0cb906bcef2..0eeac6f1e3ce4 100644
--- a/test/mod2pi.jl
+++ b/test/mod2pi.jl
@@ -26,7 +26,7 @@
 # 3.14159265359, -3.14159265359
 # pi/16*k +/- 0.00001 for k in [-20:20] # to cover all quadrants
 # numerators of continuous fraction approximations to pi
-#   see http://oeis.org/A002485
+#   see https://oeis.org/A002485
 #   (reason: for max cancellation, we want x = k*pi + eps for small eps, so x/k ≈ pi)
 
 testCases = [

From f9b27b38bbbac7f07b1cd778b1278142d95816b8 Mon Sep 17 00:00:00 2001
From: Frames White <oxinabox@ucc.asn.au>
Date: Thu, 4 Jan 2024 19:14:51 +0800
Subject: [PATCH 0532/1315] Print type signature for what was inferring
 whenever an internal error is thrown (#52695)

---
 src/gf.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/gf.c b/src/gf.c
index 268927f60172e..7dd251ff9b746 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -388,14 +388,15 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
     }
     JL_CATCH {
         jl_value_t *e = jl_current_exception();
+        jl_printf((JL_STREAM*)STDERR_FILENO, "Internal error: during type inference of\n");
+        jl_static_show_func_sig((JL_STREAM*)STDERR_FILENO, (jl_value_t*)mi->specTypes);
+        jl_printf((JL_STREAM*)STDERR_FILENO, "\nEncountered ");
         if (e == jl_stackovf_exception) {
-            jl_printf((JL_STREAM*)STDERR_FILENO, "Internal error: stack overflow in type inference of ");
-            jl_static_show_func_sig((JL_STREAM*)STDERR_FILENO, (jl_value_t*)mi->specTypes);
-            jl_printf((JL_STREAM*)STDERR_FILENO, ".\n");
+            jl_printf((JL_STREAM*)STDERR_FILENO, "stack overflow.\n");
             jl_printf((JL_STREAM*)STDERR_FILENO, "This might be caused by recursion over very long tuples or argument lists.\n");
         }
         else {
-            jl_printf((JL_STREAM*)STDERR_FILENO, "Internal error: encountered unexpected error in runtime:\n");
+            jl_printf((JL_STREAM*)STDERR_FILENO, "unexpected error in runtime:\n");
             jl_static_show((JL_STREAM*)STDERR_FILENO, e);
             jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
             jlbacktrace(); // written to STDERR_FILENO

From ec686c3cb75b53c8d6b8685bb59d37b815573f35 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 4 Jan 2024 16:51:49 +0100
Subject: [PATCH 0533/1315] inference: Guard TypeVar special case against
 vararg (#52721)

Fix #52613 by making the TypeVar special case in inference check for
vararg first. There's nothing the special case can really do with vararg
anyway, so fall back to the ordinary abstract call handling.
---
 base/compiler/abstractinterpretation.jl | 4 ++--
 test/compiler/inference.jl              | 3 +++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 199735b201630..4af80cbd20205 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2098,10 +2098,10 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
     elseif isa(f, Core.OpaqueClosure)
         # calling an OpaqueClosure about which we have no information returns no information
         return CallMeta(typeof(f).parameters[2], Any, Effects(), NoCallInfo())
-    elseif f === TypeVar
+    elseif f === TypeVar && !isvarargtype(argtypes[end])
         # Manually look through the definition of TypeVar to
         # make sure to be able to get `PartialTypeVar`s out.
-        (la < 2 || la > 4) && return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
+        2 ≤ la ≤ 4 || return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
         n = argtypes[2]
         ub_var = Const(Any)
         lb_var = Const(Union{})
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 5e302f1743008..a2900fbda01ba 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5614,3 +5614,6 @@ end
 let 𝕃 = Core.Compiler.fallback_lattice
     @test apply_type_tfunc(𝕃, Const(Tuple{Vararg{Any,N}} where N), Int) == Type{NTuple{_A, Any}} where _A
 end
+
+# Issue #52613
+@test (code_typed((Any,)) do x; TypeVar(x...); end)[1][2] === TypeVar

From 5a28cf5ec3863a2f5825a8c4b9aa035791c60ace Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Thu, 4 Jan 2024 12:35:27 -0500
Subject: [PATCH 0534/1315] add doxygen for exported functions in jlapi.c
 (#52324)

This adds some brief doxygen-formatted docstrings to jlapi.c.
The objective of this PR is to set doxygen docstrings as the
documentation method for Julia's C code, and allow for
further development of reference material for the use
of Julia through the C API.

These docstrings are immediately useful for consumption by
C/C++ development extensions such as tooltips.
In the future these can be useful to generate a cohesive API reference,
though this is a separate concern involving the build system.
---
 src/jl_uv.c | 153 +++++++++++++++++++++-
 src/jlapi.c | 371 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 513 insertions(+), 11 deletions(-)

diff --git a/src/jl_uv.c b/src/jl_uv.c
index 32adf9f1ba8f2..dca08f5ddd91d 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -136,11 +136,17 @@ void JL_UV_LOCK(void)
     }
 }
 
+/**
+ * @brief Begin an IO lock.
+ */
 JL_DLLEXPORT void jl_iolock_begin(void)
 {
     JL_UV_LOCK();
 }
 
+/**
+ * @brief End an IO lock.
+ */
 JL_DLLEXPORT void jl_iolock_end(void)
 {
     JL_UV_UNLOCK();
@@ -227,9 +233,16 @@ static void uv_flush_callback(uv_write_t *req, int status)
     free(req);
 }
 
-// Turn a normal write into a blocking write (primarily for use from C and gdb).
-// Warning: This calls uv_run, so it can have unbounded side-effects.
-// Be care where you call it from! - the libuv loop is also not reentrant.
+/**
+ * @brief Flush a UV stream.
+ *
+ * Primarily used from C and gdb to convert a normal write operation on a UV stream
+ * into a blocking write. It calls uv_run, which can have unbounded side-effects.
+ * Caution is advised as the location from where this function is called is critical
+ * due to the non-reentrancy of the libuv loop.
+ *
+ * @param stream A pointer to `uv_stream_t` representing the stream to flush.
+ */
 JL_DLLEXPORT void jl_uv_flush(uv_stream_t *stream)
 {
     if (stream == (void*)STDIN_FILENO ||
@@ -261,21 +274,111 @@ JL_DLLEXPORT void jl_uv_flush(uv_stream_t *stream)
 
 // getters and setters
 // TODO: check if whoever calls these is thread-safe
+/**
+ * @brief Get the process ID of a UV process.
+ *
+ * @param p A pointer to `uv_process_t` representing the UV process.
+ * @return The process ID.
+ */
 JL_DLLEXPORT int jl_uv_process_pid(uv_process_t *p) { return p->pid; }
+
+/**
+ * @brief Get the data associated with a UV process.
+ *
+ * @param p A pointer to `uv_process_t` representing the UV process.
+ * @return A pointer to the process data.
+ */
 JL_DLLEXPORT void *jl_uv_process_data(uv_process_t *p) { return p->data; }
+
+/**
+ * @brief Get the base pointer of a UV buffer.
+ *
+ * @param buf A constant pointer to `uv_buf_t` representing the UV buffer.
+ * @return A pointer to the base of the buffer.
+ */
 JL_DLLEXPORT void *jl_uv_buf_base(const uv_buf_t *buf) { return buf->base; }
+
+/**
+ * @brief Get the length of a UV buffer.
+ *
+ * @param buf A constant pointer to `uv_buf_t` representing the UV buffer.
+ * @return The length of the buffer as `size_t`.
+ */
 JL_DLLEXPORT size_t jl_uv_buf_len(const uv_buf_t *buf) { return buf->len; }
+
+/**
+ * @brief Set the base pointer of a UV buffer.
+ *
+ * @param buf A pointer to `uv_buf_t` representing the UV buffer.
+ * @param b A pointer to `char` representing the new base of the buffer.
+ */
 JL_DLLEXPORT void jl_uv_buf_set_base(uv_buf_t *buf, char *b) { buf->base = b; }
+
+/**
+ * @brief Set the length of a UV buffer.
+ *
+ * @param buf A pointer to `uv_buf_t` representing the UV buffer.
+ * @param n The new length of the buffer as `size_t`.
+ */
 JL_DLLEXPORT void jl_uv_buf_set_len(uv_buf_t *buf, size_t n) { buf->len = n; }
+
+/**
+ * @brief Get the handle associated with a UV connect request.
+ *
+ * @param connect A pointer to `uv_connect_t` representing the connect request.
+ * @return A pointer to the associated handle.
+ */
 JL_DLLEXPORT void *jl_uv_connect_handle(uv_connect_t *connect) { return connect->handle; }
+
+/**
+ * @brief Get the file descriptor from a UV file structure.
+ *
+ * @param f A pointer to `jl_uv_file_t` representing the UV file.
+ * @return The file descriptor as `uv_os_fd_t`.
+ */
 JL_DLLEXPORT uv_os_fd_t jl_uv_file_handle(jl_uv_file_t *f) { return f->file; }
+
+/**
+ * @brief Get the data field from a UV request.
+ *
+ * @param req A pointer to `uv_req_t` representing the request.
+ * @return A pointer to the data associated with the request.
+ */
 JL_DLLEXPORT void *jl_uv_req_data(uv_req_t *req) { return req->data; }
+
+/**
+ * @brief Set the data field of a UV request.
+ *
+ * @param req A pointer to `uv_req_t` representing the request.
+ * @param data A pointer to the data to be associated with the request.
+ */
 JL_DLLEXPORT void jl_uv_req_set_data(uv_req_t *req, void *data) { req->data = data; }
+
+/**
+ * @brief Get the data field from a UV handle.
+ *
+ * @param handle A pointer to `uv_handle_t` representing the handle.
+ * @return A pointer to the data associated with the handle.
+ */
 JL_DLLEXPORT void *jl_uv_handle_data(uv_handle_t *handle) { return handle->data; }
+
+/**
+ * @brief Get the handle associated with a UV write request.
+ *
+ * @param req A pointer to `uv_write_t` representing the write request.
+ * @return A pointer to the handle associated with the write request.
+ */
 JL_DLLEXPORT void *jl_uv_write_handle(uv_write_t *req) { return req->handle; }
 
 extern _Atomic(unsigned) _threadedregion;
 
+/**
+ * @brief Process pending UV events.
+ *
+ * See also `uv_run` in the libuv documentation for status code enumeration.
+ *
+ * @return An integer indicating the status of the event processing.
+ */
 JL_DLLEXPORT int jl_process_events(void)
 {
     jl_task_t *ct = jl_current_task;
@@ -302,6 +405,11 @@ static void jl_proc_exit_cleanup_cb(uv_process_t *process, int64_t exit_status,
     uv_close((uv_handle_t*)process, (uv_close_cb)&free);
 }
 
+/**
+ * @brief Close a UV handle.
+ *
+ * @param handle A pointer to `uv_handle_t` that needs to be closed.
+ */
 JL_DLLEXPORT void jl_close_uv(uv_handle_t *handle)
 {
     JL_UV_LOCK();
@@ -335,6 +443,11 @@ JL_DLLEXPORT void jl_close_uv(uv_handle_t *handle)
     JL_UV_UNLOCK();
 }
 
+/**
+ * @brief Forcefully close a UV handle.
+ *
+ * @param handle A pointer to `uv_handle_t` to be forcefully closed.
+ */
 JL_DLLEXPORT void jl_forceclose_uv(uv_handle_t *handle)
 {
     if (!uv_is_closing(handle)) { // avoid double-closing the stream
@@ -346,12 +459,23 @@ JL_DLLEXPORT void jl_forceclose_uv(uv_handle_t *handle)
     }
 }
 
+/**
+ * @brief Associate a Julia structure with a UV handle.
+ *
+ * @param handle A pointer to `uv_handle_t` to be associated with a Julia structure.
+ * @param data Additional parameters representing the Julia structure to be associated.
+ */
 JL_DLLEXPORT void jl_uv_associate_julia_struct(uv_handle_t *handle,
                                                jl_value_t *data)
 {
     handle->data = data;
 }
 
+/**
+ * @brief Disassociate a Julia structure from a UV handle.
+ *
+ * @param handle A pointer to `uv_handle_t` from which the Julia structure will be disassociated.
+ */
 JL_DLLEXPORT void jl_uv_disassociate_julia_struct(uv_handle_t *handle)
 {
     handle->data = NULL;
@@ -359,6 +483,29 @@ JL_DLLEXPORT void jl_uv_disassociate_julia_struct(uv_handle_t *handle)
 
 #define UV_HANDLE_CLOSED 0x02
 
+/**
+ * @brief Spawn a new process.
+ *
+ * Spawns a new process to execute external programs or scripts within the context of the Julia application.
+ *
+ * @param name A C string representing the name or path of the executable to spawn.
+ * @param argv An array of C strings representing the arguments for the process. The array should be null-terminated.
+ * @param loop A pointer to `uv_loop_t` representing the event loop where the process is registered.
+ * @param proc A pointer to `uv_process_t` where the details of the spawned process are stored.
+ * @param stdio An array of `uv_stdio_container_t` representing the file descriptors for standard input, output, and error.
+ * @param nstdio An integer representing the number of elements in the stdio array.
+ * @param flags A uint32_t representing process creation flags.
+          See also `enum uv_process_flags` in the libuv documentation.
+ * @param env An array of C strings for setting environment variables. The array should be null-terminated.
+ * @param cwd A C string representing the current working directory for the process.
+ * @param cpumask A C string representing the CPU affinity mask for the process.
+          See also the `cpumask` field of the `uv_process_options_t` structure in the libuv documentation.
+ * @param cpumask_size The size of the cpumask.
+ * @param cb A function pointer to `uv_exit_cb` which is the callback function to be called upon process exit.
+ *
+ * @return An integer indicating the success or failure of the spawn operation. A return value of 0 indicates success,
+ *         while a non-zero value indicates an error.
+ */
 JL_DLLEXPORT int jl_spawn(char *name, char **argv,
                           uv_loop_t *loop, uv_process_t *proc,
                           uv_stdio_container_t *stdio, int nstdio,
diff --git a/src/jlapi.c b/src/jlapi.c
index 6003aa5cee7d4..f75d7261acf33 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -26,11 +26,28 @@ extern "C" {
 #include <fenv.h>
 #endif
 
+/**
+ * @brief Check if Julia is already initialized.
+ *
+ * Determine if Julia has been previously initialized
+ * via `jl_init` or `jl_init_with_image`.
+ *
+ * @return Returns 1 if Julia is initialized, 0 otherwise.
+ */
 JL_DLLEXPORT int jl_is_initialized(void)
 {
     return jl_main_module != NULL;
 }
 
+/**
+ * @brief Set Julia command line arguments.
+ *
+ * Allows setting the command line arguments for Julia,
+ * similar to arguments passed in the main function of a C program.
+ *
+ * @param argc The number of command line arguments.
+ * @param argv Array of command line arguments.
+ */
 JL_DLLEXPORT void jl_set_ARGS(int argc, char **argv)
 {
     if (jl_core_module != NULL) {
@@ -51,11 +68,20 @@ JL_DLLEXPORT void jl_set_ARGS(int argc, char **argv)
     }
 }
 
-// First argument is the usr/bin directory where the julia binary is, or NULL to guess.
-// Second argument is the path of a system image file (*.so).
-// A non-absolute path is interpreted as relative to the first argument path, or
-// relative to the default julia home dir.
-// The default is something like ../lib/julia/sys.so
+/**
+ * @brief Initialize Julia with a specified system image file.
+ *
+ * Initializes Julia by specifying the usr/bin directory where the Julia binary is
+ * and the path of a system image file (*.so). If the julia_bindir is NULL, the function
+ * attempts to guess the directory. The image_path is interpreted as a path to the system image
+ * file. A non-absolute path for the system image is considered relative to julia_bindir, or
+ * relative to the default Julia home directory. The default system image is typically
+ * something like ../lib/julia/sys.so.
+ *
+ * @param julia_bindir The usr/bin directory where the Julia binary is located, or NULL to guess.
+ * @param image_path The path of a system image file (*.so). Interpreted as relative to julia_bindir
+ *                   or the default Julia home directory if not an absolute path.
+ */
 JL_DLLEXPORT void jl_init_with_image(const char *julia_bindir,
                                      const char *image_path)
 {
@@ -71,6 +97,12 @@ JL_DLLEXPORT void jl_init_with_image(const char *julia_bindir,
     jl_exception_clear();
 }
 
+/**
+ * @brief Initialize the Julia runtime.
+ *
+ * Initializes the Julia runtime without any specific system image.
+ * It must be called before any other Julia API functions.
+ */
 JL_DLLEXPORT void jl_init(void)
 {
     char *libbindir = NULL;
@@ -105,6 +137,13 @@ static void _jl_exception_clear(jl_task_t *ct) JL_NOTSAFEPOINT
     ct->ptls->previous_exception = NULL;
 }
 
+/**
+ * @brief Evaluate a Julia expression from a string.
+ *
+ * @param str A C string containing the Julia expression to be evaluated.
+ * @return A pointer to `jl_value_t` representing the result of the evaluation.
+ *         Returns `NULL` if an error occurs during parsing or evaluation.
+ */
 JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
 {
     jl_value_t *r;
@@ -125,23 +164,44 @@ JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
     return r;
 }
 
+/**
+ * @brief Get the current exception in the Julia context.
+ *
+ * @return A pointer to `jl_value_t` representing the current exception.
+ *         Returns `NULL` if no exception is currently thrown.
+ */
 JL_DLLEXPORT jl_value_t *jl_current_exception(void) JL_GLOBALLY_ROOTED JL_NOTSAFEPOINT
 {
     jl_excstack_t *s = jl_current_task->excstack;
     return s && s->top != 0 ? jl_excstack_exception(s, s->top) : jl_nothing;
 }
 
+/**
+ * @brief Check if an exception has occurred in the Julia context.
+ *
+ * @return A pointer to `jl_value_t` representing the exception that occurred.
+ *         Returns `NULL` if no exception has occurred.
+ */
 JL_DLLEXPORT jl_value_t *jl_exception_occurred(void)
 {
     return jl_current_task->ptls->previous_exception;
 }
 
+/**
+ * @brief Clear the current exception in the Julia context.
+ *
+ */
 JL_DLLEXPORT void jl_exception_clear(void)
 {
     _jl_exception_clear(jl_current_task);
 }
 
-// get the name of a type as a string
+/**
+ * @brief Get the type name of a Julia value.
+ *
+ * @param v A pointer to `jl_value_t` representing the Julia value.
+ * @return A C string containing the name of the type.
+ */
 JL_DLLEXPORT const char *jl_typename_str(jl_value_t *v)
 {
     if (!jl_is_datatype(v))
@@ -149,22 +209,51 @@ JL_DLLEXPORT const char *jl_typename_str(jl_value_t *v)
     return jl_symbol_name(((jl_datatype_t*)v)->name->name);
 }
 
-// get the name of typeof(v) as a string
+/**
+ * @brief Get the string representation of a Julia value's type.
+ *
+ * @param v A pointer to `jl_value_t` representing the Julia value.
+ * @return A C string describing the type of the value.
+ */
 JL_DLLEXPORT const char *jl_typeof_str(jl_value_t *v)
 {
     return jl_typename_str((jl_value_t*)jl_typeof(v));
 }
 
+/**
+ * @brief Get the element type of a Julia array.
+ *
+ * @param a A pointer to `jl_value_t` representing the Julia array.
+ * @return A pointer to the type of the array elements.
+ */
 JL_DLLEXPORT void *jl_array_eltype(jl_value_t *a)
 {
     return jl_tparam0(jl_typeof(a));
 }
 
+/**
+ * @brief Get the number of dimensions of a Julia array.
+ *
+ * Returns the rank (number of dimensions) of a Julia array.
+ *
+ * @param a A pointer to `jl_value_t` representing the Julia array.
+ * @return An integer representing the number of dimensions of the array.
+ */
 JL_DLLEXPORT int jl_array_rank(jl_value_t *a)
 {
     return jl_array_ndims(a);
 }
 
+/**
+ * @brief Get the size of a specific dimension of a Julia array.
+ *
+ * Returns the size (number of elements) of a specific dimension
+ * of a Julia array.
+ *
+ * @param a A pointer to `jl_array_t` representing the Julia array.
+ * @param d The dimension for which the size is requested.
+ * @return The size of the specified dimension of the array.
+ */
 JL_DLLEXPORT size_t jl_array_size(jl_array_t *a, int d)
 {
     // n.b this functions only use was to violate the vector abstraction, so we have to continue to emulate that
@@ -173,11 +262,25 @@ JL_DLLEXPORT size_t jl_array_size(jl_array_t *a, int d)
     return jl_array_dim(a, d);
 }
 
+/**
+ * @brief Get the C string pointer from a Julia string.
+ *
+ * @param s A pointer to `jl_value_t` representing the Julia string.
+ * @return A C string pointer containing the contents of the Julia string.
+ */
 JL_DLLEXPORT const char *jl_string_ptr(jl_value_t *s)
 {
     return jl_string_data(s);
 }
 
+/**
+ * @brief Call a Julia function with a specified number of arguments.
+ *
+ * @param f A pointer to `jl_function_t` representing the Julia function to call.
+ * @param args An array of pointers to `jl_value_t` representing the arguments.
+ * @param nargs The number of arguments in the array.
+ * @return A pointer to `jl_value_t` representing the result of the function call.
+ */
 JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, uint32_t nargs)
 {
     jl_value_t *v;
@@ -203,6 +306,14 @@ JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, uint32_t n
     return v;
 }
 
+/**
+ * @brief Call a Julia function with no arguments.
+ *
+ * A specialized case of `jl_call` for simpler scenarios.
+ *
+ * @param f A pointer to `jl_function_t` representing the Julia function to call.
+ * @return A pointer to `jl_value_t` representing the result of the function call.
+ */
 JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
 {
     jl_value_t *v;
@@ -223,6 +334,15 @@ JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
     return v;
 }
 
+/**
+ * @brief Call a Julia function with one argument.
+ *
+ * A specialized case of `jl_call` for simpler scenarios.
+ *
+ * @param f A pointer to `jl_function_t` representing the Julia function to call.
+ * @param a A pointer to `jl_value_t` representing the argument to the function.
+ * @return A pointer to `jl_value_t` representing the result of the function call.
+ */
 JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
 {
     jl_value_t *v;
@@ -246,6 +366,16 @@ JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
     return v;
 }
 
+/**
+ * @brief Call a Julia function with two arguments.
+ *
+ * A specialized case of `jl_call` for simpler scenarios.
+ *
+ * @param f A pointer to `jl_function_t` representing the Julia function to call.
+ * @param a A pointer to `jl_value_t` representing the first argument.
+ * @param b A pointer to `jl_value_t` representing the second argument.
+ * @return A pointer to `jl_value_t` representing the result of the function call.
+ */
 JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b)
 {
     jl_value_t *v;
@@ -270,6 +400,17 @@ JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b
     return v;
 }
 
+/**
+ * @brief Call a Julia function with three arguments.
+ *
+ * A specialized case of `jl_call` for simpler scenarios.
+ *
+ * @param f A pointer to `jl_function_t` representing the Julia function to call.
+ * @param a A pointer to `jl_value_t` representing the first argument.
+ * @param b A pointer to `jl_value_t` representing the second argument.
+ * @param c A pointer to `jl_value_t` representing the third argument.
+ * @return A pointer to `jl_value_t` representing the result of the function call.
+ */
 JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
                                   jl_value_t *b, jl_value_t *c)
 {
@@ -296,6 +437,11 @@ JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
     return v;
 }
 
+/**
+ * @brief Yield to the Julia scheduler.
+ *
+ * Yields control to the Julia scheduler, allowing other Julia tasks to run.
+ */
 JL_DLLEXPORT void jl_yield(void)
 {
     static jl_function_t *yieldfunc = NULL;
@@ -305,6 +451,13 @@ JL_DLLEXPORT void jl_yield(void)
         jl_call0(yieldfunc);
 }
 
+/**
+ * @brief Get a field from a Julia object.
+ *
+ * @param o A pointer to `jl_value_t` representing the Julia object.
+ * @param fld A C string representing the name of the field to retrieve.
+ * @return A pointer to `jl_value_t` representing the value of the field.
+ */
 JL_DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
 {
     jl_value_t *v;
@@ -321,11 +474,23 @@ JL_DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
     return v;
 }
 
+/**
+ * @brief Begin an atomic signal-protected region.
+ *
+ * Marks the start of a region of code that should be protected
+ * from interruption by asynchronous signals.
+ */
 JL_DLLEXPORT void jl_sigatomic_begin(void)
 {
     JL_SIGATOMIC_BEGIN();
 }
 
+/**
+ * @brief End an atomic signal-protected region.
+ *
+ * Marks the end of a region of code protected from asynchronous signals.
+ * It should be used in conjunction with `jl_sigatomic_begin` to define signal-protected regions.
+ */
 JL_DLLEXPORT void jl_sigatomic_end(void)
 {
     jl_task_t *ct = jl_current_task;
@@ -334,6 +499,11 @@ JL_DLLEXPORT void jl_sigatomic_end(void)
     JL_SIGATOMIC_END();
 }
 
+/**
+ * @brief Check if Julia is running in debug build mode.
+ *
+ * @return Returns 1 if Julia is in debug build mode, 0 otherwise.
+ */
 JL_DLLEXPORT int jl_is_debugbuild(void) JL_NOTSAFEPOINT
 {
 #ifdef JL_DEBUG_BUILD
@@ -343,6 +513,11 @@ JL_DLLEXPORT int jl_is_debugbuild(void) JL_NOTSAFEPOINT
 #endif
 }
 
+/**
+ * @brief Check if Julia's memory debugging is enabled.
+ *
+ * @return Returns 1 if memory debugging is enabled, 0 otherwise.
+ */
 JL_DLLEXPORT int8_t jl_is_memdebug(void) JL_NOTSAFEPOINT {
 #ifdef MEMDEBUG
     return 1;
@@ -351,41 +526,81 @@ JL_DLLEXPORT int8_t jl_is_memdebug(void) JL_NOTSAFEPOINT {
 #endif
 }
 
+/**
+ * @brief Get the directory path of the Julia binary.
+ *
+ * @return A pointer to `jl_value_t` representing the directory path as a Julia string.
+ */
 JL_DLLEXPORT jl_value_t *jl_get_julia_bindir(void)
 {
     return jl_cstr_to_string(jl_options.julia_bindir);
 }
 
+/**
+ * @brief Get the path to the Julia binary.
+ *
+ * @return A pointer to `jl_value_t` representing the full path as a Julia string.
+ */
 JL_DLLEXPORT jl_value_t *jl_get_julia_bin(void)
 {
     return jl_cstr_to_string(jl_options.julia_bin);
 }
 
+/**
+ * @brief Get the path to the Julia system image file.
+ *
+ * @return A pointer to `jl_value_t` representing the system image file path as a Julia string.
+ */
 JL_DLLEXPORT jl_value_t *jl_get_image_file(void)
 {
     return jl_cstr_to_string(jl_options.image_file);
 }
 
+/**
+ * @brief Get the major version number of Julia.
+ *
+ * @return The major version number as an integer.
+ */
 JL_DLLEXPORT int jl_ver_major(void)
 {
     return JULIA_VERSION_MAJOR;
 }
 
+/**
+ * @brief Get the minor version number of Julia.
+ *
+ * @return The minor version number as an integer.
+ */
 JL_DLLEXPORT int jl_ver_minor(void)
 {
     return JULIA_VERSION_MINOR;
 }
 
+/**
+ * @brief Get the patch version number of Julia.
+ *
+ * @return The patch version number as an integer.
+ */
 JL_DLLEXPORT int jl_ver_patch(void)
 {
     return JULIA_VERSION_PATCH;
 }
 
+/**
+ * @brief Check if the current Julia version is a release version.
+ *
+ * @return Returns 1 if it is a release version, 0 otherwise.
+ */
 JL_DLLEXPORT int jl_ver_is_release(void)
 {
     return JULIA_VERSION_IS_RELEASE;
 }
 
+/**
+ * @brief Get the Julia version as a string.
+ *
+ * @return A C string containing the version information.
+ */
 JL_DLLEXPORT const char *jl_ver_string(void)
 {
    return JULIA_VERSION_STRING;
@@ -402,6 +617,11 @@ static const char *git_info_string(const char *fld)
     return jl_string_data(f);
 }
 
+/**
+ * @brief Get the name of the Git branch for the Julia build.
+ *
+ * @return A C string containing the name of the Git branch.
+ */
 JL_DLLEXPORT const char *jl_git_branch(void)
 {
     static const char *branch = NULL;
@@ -409,6 +629,11 @@ JL_DLLEXPORT const char *jl_git_branch(void)
     return branch;
 }
 
+/**
+ * @brief Get the Git commit hash for the Julia build.
+ *
+ * @return A C string containing the Git commit hash.
+ */
 JL_DLLEXPORT const char *jl_git_commit(void)
 {
     static const char *commit = NULL;
@@ -416,27 +641,63 @@ JL_DLLEXPORT const char *jl_git_commit(void)
     return commit;
 }
 
-// Create function versions of some useful macros for GDB or FFI use
+/**
+ * @brief Convert a Julia value to a tagged value.
+ *
+ * Converts a Julia value into its corresponding tagged value representation.
+ * Tagged values include additional metadata used internally by the Julia runtime.
+ *
+ * @param v A pointer to `jl_value_t` representing the Julia value.
+ * @return A pointer to `jl_taggedvalue_t` representing the tagged value.
+ */
 JL_DLLEXPORT jl_taggedvalue_t *(jl_astaggedvalue)(jl_value_t *v)
 {
     return jl_astaggedvalue(v);
 }
 
+/**
+ * @brief Convert a tagged value back to a Julia value.
+ *
+ * Converts a tagged value back into its original Julia value.
+ * It's the inverse operation of `jl_astaggedvalue`.
+ *
+ * @param v A pointer to `jl_taggedvalue_t` representing the tagged value.
+ * @return A pointer to `jl_value_t` representing the original Julia value.
+ */
 JL_DLLEXPORT jl_value_t *(jl_valueof)(jl_taggedvalue_t *v)
 {
     return jl_valueof(v);
 }
 
+/**
+ * @brief Get the type of a Julia value.
+ *
+ * @param v A pointer to `jl_value_t` representing the Julia value.
+ * @return A pointer to `jl_value_t` representing the type of the value.
+ */
 JL_DLLEXPORT jl_value_t *(jl_typeof)(jl_value_t *v)
 {
     return jl_typeof(v);
 }
 
+/**
+ * @brief Get the field types of a Julia value.
+ *
+ * @param v A pointer to `jl_value_t` representing the Julia value.
+ * @return A pointer to `jl_value_t` representing the field types.
+ */
 JL_DLLEXPORT jl_value_t *(jl_get_fieldtypes)(jl_value_t *v)
 {
     return (jl_value_t*)jl_get_fieldtypes((jl_datatype_t*)v);
 }
 
+/**
+ * @brief Check equality of two Julia values.
+ *
+ * @param a A pointer to `jl_value_t` representing the first Julia value.
+ * @param b A pointer to `jl_value_t` representing the second Julia value.
+ * @return Returns 1 if the values are equal, 0 otherwise.
+ */
 JL_DLLEXPORT int ijl_egal(jl_value_t *a, jl_value_t *b)
 {
     return jl_egal(a, b);
@@ -444,24 +705,56 @@ JL_DLLEXPORT int ijl_egal(jl_value_t *a, jl_value_t *b)
 
 
 #ifndef __clang_gcanalyzer__
+/**
+ * @brief Enter a state where concurrent garbage collection (GC) is considered unsafe.
+ *
+ * Marks the beginning of a code region where garbage collection operations are unsafe.
+ * Used to make it legal to access GC-managed state (almost anything)
+ *
+ * @return An `int8_t` state value representing the previous GC state.
+ */
 JL_DLLEXPORT int8_t (jl_gc_unsafe_enter)(void)
 {
     jl_task_t *ct = jl_current_task;
     return jl_gc_unsafe_enter(ct->ptls);
 }
 
+/**
+ * @brief Leave the state where garbage collection is considered unsafe.
+ *
+ * Ends a code region where garbage collection was marked as unsafe.
+ * It restores the previous GC state using the state value returned by `jl_gc_unsafe_enter`.
+ *
+ * @param state The state value returned by `jl_gc_unsafe_enter` to restore the previous GC state.
+ */
 JL_DLLEXPORT void (jl_gc_unsafe_leave)(int8_t state)
 {
     jl_task_t *ct = jl_current_task;
     jl_gc_unsafe_leave(ct->ptls, state);
 }
 
+/**
+ * @brief Enter a state where garbage collection (GC) is considered safe.
+ *
+ * Marks the beginning of a code region where garbage collection operations are safe.
+ * Used to enable GC in sections of code where it was previously marked as unsafe.
+ *
+ * @return An `int8_t` state value representing the previous GC state.
+ */
 JL_DLLEXPORT int8_t (jl_gc_safe_enter)(void)
 {
     jl_task_t *ct = jl_current_task;
     return jl_gc_safe_enter(ct->ptls);
 }
 
+/**
+ * @brief Leave the state where garbage collection is considered safe.
+ *
+ * Ends a code region where garbage collection was marked as safe.
+ * It restores the previous GC state using the state value returned by `jl_gc_safe_enter`.
+ *
+ * @param state The state value returned by `jl_gc_safe_enter` to restore the previous GC state.
+ */
 JL_DLLEXPORT void (jl_gc_safe_leave)(int8_t state)
 {
     jl_task_t *ct = jl_current_task;
@@ -469,49 +762,96 @@ JL_DLLEXPORT void (jl_gc_safe_leave)(int8_t state)
 }
 #endif
 
+/**
+ * @brief Trigger a garbage collection safepoint in a GC-unsafe region.
+ *
+ * Triggers a safepoint for garbage collection. Used to
+ * ensure that the garbage collector can run at specific points in the code,
+ * particularly in long-running operations or loops.
+ */
 JL_DLLEXPORT void jl_gc_safepoint(void)
 {
     jl_task_t *ct = jl_current_task;
     jl_gc_safepoint_(ct->ptls);
 }
 
+/**
+ * @brief Pause CPU execution for a brief moment.
+ *
+ * Used to pause the CPU briefly, typically to reduce power consumption
+ * or manage CPU resources more effectively in a tight loop or busy wait scenario.
+ */
 JL_DLLEXPORT void (jl_cpu_pause)(void)
 {
     jl_cpu_pause();
 }
 
+/**
+ * @brief Suspend CPU execution.
+ *
+ * Suspends CPU execution until a specific condition or event occurs.
+ */
 JL_DLLEXPORT void (jl_cpu_suspend)(void)
 {
     jl_cpu_suspend();
 }
 
+/**
+ * @brief Wake the CPU from a suspended state.
+ *
+ * Used to resume CPU execution after it has been suspended using `jl_cpu_suspend`.
+ */
 JL_DLLEXPORT void (jl_cpu_wake)(void)
 {
     jl_cpu_wake();
 }
 
+/**
+ * @brief Enable cumulative compile timing.
+ */
 JL_DLLEXPORT void jl_cumulative_compile_timing_enable(void)
 {
     // Increment the flag to allow reentrant callers to `@time`.
     jl_atomic_fetch_add(&jl_measure_compile_time_enabled, 1);
 }
 
+/**
+ * @brief Disable cumulative compile timing.
+ */
 JL_DLLEXPORT void jl_cumulative_compile_timing_disable(void)
 {
     // Decrement the flag when done measuring, allowing other callers to continue measuring.
     jl_atomic_fetch_add(&jl_measure_compile_time_enabled, -1);
 }
 
+/**
+ * @brief Get the cumulative compilation time in nanoseconds.
+ *
+ * @return The cumulative compilation time in nanoseconds.
+ */
 JL_DLLEXPORT uint64_t jl_cumulative_compile_time_ns(void)
 {
     return jl_atomic_load_relaxed(&jl_cumulative_compile_time);
 }
 
+/**
+ * @brief Get the cumulative recompilation time in nanoseconds.
+ *
+ * @return The cumulative recompilation time in nanoseconds.
+ */
 JL_DLLEXPORT uint64_t jl_cumulative_recompile_time_ns(void)
 {
     return jl_atomic_load_relaxed(&jl_cumulative_recompile_time);
 }
 
+/**
+ * @brief Retrieve floating-point environment constants.
+ *
+ * Populates an array with constants related to the floating-point environment,
+ * such as rounding modes and exception flags.
+ *
+ * @param ret An array of integers to be populated with floating-point environment constants.
+ */
 JL_DLLEXPORT void jl_get_fenv_consts(int *ret)
 {
     ret[0] = FE_INEXACT;
@@ -533,6 +873,14 @@ JL_DLLEXPORT int jl_get_fenv_rounding(void)
 {
     return fegetround();
 }
+
+/**
+ * @brief Set the floating-point rounding mode.
+ *
+ * @param i An integer representing the desired floating-point rounding mode.
+          See also "floating-point rounding" macros in `<fenv.h>`.
+ * @return An integer indicating the success or failure of setting the rounding mode.
+ */
 JL_DLLEXPORT int jl_set_fenv_rounding(int i)
 {
     return fesetround(i);
@@ -694,6 +1042,13 @@ static void rr_detach_teleport(void) {
 }
 #endif
 
+/**
+ * @brief Entry point for the Julia REPL (Read-Eval-Print Loop).
+ *
+ * @param argc The number of command-line arguments.
+ * @param argv Array of command-line arguments.
+ * @return An integer indicating the exit status of the REPL session.
+ */
 JL_DLLEXPORT int jl_repl_entrypoint(int argc, char *argv[])
 {
 #ifdef USE_TRACY

From 69343794f9bb162be17623728e2a42cae690ddc2 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Thu, 4 Jan 2024 16:03:29 -0500
Subject: [PATCH 0535/1315] remove method file names with `--strip-metadata`
 (#52722)

These should not appear in binaries when this option is specified.
---
 src/staticdata.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/staticdata.c b/src/staticdata.c
index 8244c5a4373ce..1873bb19f23d2 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -2393,6 +2393,10 @@ static int strip_all_codeinfos__(jl_typemap_entry_t *def, void *_env)
             jl_gc_wb(m, m->source);
         }
     }
+    if (jl_options.strip_metadata) {
+        record_field_change((jl_value_t**)&m->file, (jl_value_t*)jl_empty_sym);
+        m->line = 0;
+    }
     jl_value_t *specializations = jl_atomic_load_relaxed(&m->specializations);
     if (!jl_is_svec(specializations)) {
         strip_specializations_((jl_method_instance_t*)specializations);

From 38b81562d79dfa44816bd3ce5b249cad87904587 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Thu, 4 Jan 2024 16:44:38 -0500
Subject: [PATCH 0536/1315] expand Docs.undocumented_names  to include all
 public symbols (#52743)

Expands the semantics of `Docs.undocumented_names` to include all public
symbols, as described in
https://github.com/JuliaLang/julia/pull/52413#issuecomment-1876266678

cc @jariji, @LilithHafner

---------

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 NEWS.md           |  2 +-
 base/docs/Docs.jl | 19 ++++++++++---------
 test/docs.jl      |  9 +++++++--
 3 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 7b4cda50b8985..cee80f892ec2a 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -84,7 +84,7 @@ New library features
   write the output to a stream rather than returning a string ([#48625]).
 * `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
 * New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
-* New function `Docs.undocumented_names(module; all)` returns a module's undocumented names ([#52413]).
+* New function `Docs.undocumented_names(module)` returns a module's undocumented public names ([#52413]).
 * Passing an `IOBuffer` as a stdout argument for `Process` spawn now works as
   expected, synchronized with `wait` or `success`, so a `Base.BufferStream` is
   no longer required there for correctness to avoid data races ([#52461]).
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 5e7126f47c28d..e5974d3280308 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -676,18 +676,19 @@ end
 
 
 """
-    undocumented_names(mod::Module; all=false)
+    undocumented_names(mod::Module; private=false)
 
-Return an array of undocumented symbols in `module` (that is, lacking docstrings).
-`all=false` returns only exported symbols; whereas `all=true` also includes
-non-exported symbols, following the behavior of [`names`](@ref). Only valid identifiers
-are included. Names are returned in sorted order.
+Return a sorted vector of undocumented symbols in `module` (that is, lacking docstrings).
+`private=false` (the default) returns only identifiers declared with `public` and/or
+`export`, whereas `private=true` returns all symbols in the module (excluding
+compiler-generated hidden symbols starting with `#`).
 
-See also: [`names`](@ref), [`Docs.hasdoc`](@ref), [`Base.isidentifier`](@ref).
+See also: [`names`](@ref), [`Docs.hasdoc`](@ref), [`Base.ispublic`](@ref).
 """
-function undocumented_names(mod::Module; all::Bool=false)
-    filter!(names(mod; all)) do sym
-        !hasdoc(mod, sym) && Base.isidentifier(sym)
+function undocumented_names(mod::Module; private::Bool=false)
+    filter!(names(mod; all=true)) do sym
+        !hasdoc(mod, sym) && !startswith(string(sym), '#') &&
+            (private || Base.ispublic(mod, sym))
     end
 end
 
diff --git a/test/docs.jl b/test/docs.jl
index 7ebef8832cd69..190bcaee6adf5 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -79,7 +79,12 @@ function break_me_docs end
 "This module has names without documentation."
 module _ModuleWithUndocumentedNames
 export f
+public ⨳, @foo
 f() = 1
+g() = 2
+⨳(a,b) = a * b
+macro foo(); nothing; end
+⊕(a,b) = a + b
 end
 
 "This module has some documentation."
@@ -90,9 +95,9 @@ f() = 1
 g() = 2
 end
 
-@test Docs.undocumented_names(_ModuleWithUndocumentedNames) == [:f]
+@test Docs.undocumented_names(_ModuleWithUndocumentedNames) == [Symbol("@foo"), :f, :⨳]
 @test isempty(Docs.undocumented_names(_ModuleWithSomeDocumentedNames))
-@test Docs.undocumented_names(_ModuleWithSomeDocumentedNames; all=true) == [:eval, :g, :include]
+@test Docs.undocumented_names(_ModuleWithSomeDocumentedNames; private=true) == [:eval, :g, :include]
 
 
 # issue #11548

From 31a9f130c34ff0b1ebc418d4bc845856faaba754 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 5 Jan 2024 02:59:49 +0100
Subject: [PATCH 0537/1315] Properly rename EnterNode scope after code coverage
 insertion (#52720)

Fixes #52672 and changes the emission path to move the error to the
point of corruption instead of the point of first use.
---
 base/compiler/optimize.jl | 6 +++++-
 src/codegen.cpp           | 8 ++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 64c25584f0449..c7d2983bced82 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -1379,7 +1379,11 @@ function renumber_ir_elements!(body::Vector{Any}, ssachangemap::Vector{Int}, lab
                     @assert !isdefined(el, :scope)
                     body[i] = nothing
                 else
-                    body[i] = EnterNode(el, tgt + labelchangemap[tgt])
+                    if isdefined(el, :scope) && isa(el.scope, SSAValue)
+                        body[i] = EnterNode(tgt + labelchangemap[tgt], SSAValue(el.scope.id + ssachangemap[el.scope.id]))
+                    else
+                        body[i] = EnterNode(el, tgt + labelchangemap[tgt])
+                    end
                 end
             end
         elseif isa(el, Expr)
diff --git a/src/codegen.cpp b/src/codegen.cpp
index ceef6486f8c31..ca96e1bcc5545 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -8765,6 +8765,14 @@ static jl_llvm_functions_t
             jl_aliasinfo_t scope_ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_gcframe);
             if (jl_enternode_scope(stmt)) {
                 jl_cgval_t new_scope = emit_expr(ctx, jl_enternode_scope(stmt));
+                if (new_scope.typ == jl_bottom_type) {
+                    // Probably dead code, but let's be loud about it in case it isn't, so we fail
+                    // at the point of the miscompile, rather than later when something attempts to
+                    // read the scope.
+                    emit_error(ctx, "(INTERNAL ERROR): Attempted to execute EnterNode with bad scope");
+                    find_next_stmt(-1);
+                    continue;
+                }
                 Value *new_scope_boxed = boxed(ctx, new_scope);
                 scope_ptr = get_scope_field(ctx);
                 old_scope = scope_ai.decorateInst(

From 316cc4aa2378614f0d26d03eeb7da866e2af16d2 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 5 Jan 2024 10:59:58 +0900
Subject: [PATCH 0538/1315] remove outdated handling of `:static_parameter`
 (#52732)

After #51970, `Expr(:static_parameter, i::Int)` is now consistently
outlined during the lowering, so there's no longer a need for
`abstract_eval_value_expr` to handle this expression. This update
removes the outdated handling, clarifying where we need to handle the
expression.
---
 base/compiler/abstractinterpretation.jl | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 4af80cbd20205..3701fa8cf9cae 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2339,21 +2339,8 @@ function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(
     return RTEffects(Const(e), Union{}, EFFECTS_TOTAL)
 end
 
-function abstract_eval_value_expr(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
-    head = e.head
-    if head === :static_parameter
-        n = e.args[1]::Int
-        nothrow = false
-        if 1 <= n <= length(sv.sptypes)
-            sp = sv.sptypes[n]
-            rt = sp.typ
-            nothrow = !sp.undef
-        else
-            rt = Any
-        end
-        merge_effects!(interp, sv, Effects(EFFECTS_TOTAL; nothrow))
-        return rt
-    elseif head === :call
+function abstract_eval_value_expr(interp::AbstractInterpreter, e::Expr, sv::AbsIntState)
+    if e.head === :call
         # TODO: We still have non-linearized cglobal
         @assert e.args[1] === Core.tuple ||
                 e.args[1] === GlobalRef(Core, :tuple)
@@ -2368,7 +2355,7 @@ end
 
 function abstract_eval_value(interp::AbstractInterpreter, @nospecialize(e), vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
     if isa(e, Expr)
-        return abstract_eval_value_expr(interp, e, vtypes, sv)
+        return abstract_eval_value_expr(interp, e, sv)
     else
         (;rt, effects) = abstract_eval_special_value(interp, e, vtypes, sv)
         merge_effects!(interp, sv, effects)
@@ -2668,7 +2655,7 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         t = Bottom
         effects = EFFECTS_THROWS
     else
-        t = abstract_eval_value_expr(interp, e, vtypes, sv)
+        t = abstract_eval_value_expr(interp, e, sv)
         # N.B.: abstract_eval_value_expr can modify the global effects, but
         # we move out any arguments with effects during SSA construction later
         # and recompute the effects.

From 50788cd92e02f2b36f1d9495d472e11e907519e2 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Fri, 5 Jan 2024 16:11:45 +0800
Subject: [PATCH 0539/1315] Generalize `broadcast!(f, ::BitVector)`
 optimization to `BitArray`. (#52736)

Follows #32048.
This PR fully avoids the allocation thus make nd logical broadcast
better scaled for small inputs.

---------

Co-authored-by: Matt Bauman <mbauman@gmail.com>
---
 base/broadcast.jl | 69 ++++++++++++++++++++---------------------------
 test/broadcast.jl | 10 +++++++
 2 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index d6e5513889cee..e653c4086e452 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -974,53 +974,42 @@ preprocess(dest, x) = extrude(broadcast_unalias(dest, x))
     return dest
 end
 
-# Performance optimization: for BitVector outputs, we cache the result
-# in a 64-bit register before writing into memory (to bypass LSQ)
-@inline function copyto!(dest::BitVector, bc::Broadcasted{Nothing})
-    axes(dest) == axes(bc) || throwdm(axes(dest), axes(bc))
-    ischunkedbroadcast(dest, bc) && return chunkedcopyto!(dest, bc)
-    destc = dest.chunks
-    bcp = preprocess(dest, bc)
-    length(bcp) <= 0 && return dest
-    len = Base.num_bit_chunks(Int(length(bcp)))
-    @inbounds for i = 0:(len - 2)
-        z = UInt64(0)
-        for j = 0:63
-           z |= UInt64(bcp[i*64 + j + 1]::Bool) << (j & 63)
-        end
-        destc[i + 1] = z
-    end
-    @inbounds let i = len - 1
-        z = UInt64(0)
-        for j = 0:((length(bcp) - 1) & 63)
-             z |= UInt64(bcp[i*64 + j + 1]::Bool) << (j & 63)
-        end
-        destc[i + 1] = z
-    end
-    return dest
-end
-
 # Performance optimization: for BitArray outputs, we cache the result
-# in a "small" Vector{Bool}, and then copy in chunks into the output
+# in a 64-bit register before writing into memory (to bypass LSQ)
 @inline function copyto!(dest::BitArray, bc::Broadcasted{Nothing})
     axes(dest) == axes(bc) || throwdm(axes(dest), axes(bc))
     ischunkedbroadcast(dest, bc) && return chunkedcopyto!(dest, bc)
-    length(dest) < 256 && return invoke(copyto!, Tuple{AbstractArray, Broadcasted{Nothing}}, dest, bc)
-    tmp = Vector{Bool}(undef, bitcache_size)
-    destc = dest.chunks
-    cind = 1
+    ndims(dest) == 0 && (dest[] = bc[]; return dest)
     bc′ = preprocess(dest, bc)
-    @inbounds for P in Iterators.partition(eachindex(bc′), bitcache_size)
-        ind = 1
-        @simd for I in P
-            tmp[ind] = bc′[I]
-            ind += 1
+    ax = axes(bc′)
+    ax1, out = ax[1], CartesianIndices(tail(ax))
+    destc, indc = dest.chunks, 0
+    bitst, remain = 0, UInt64(0)
+    for I in out
+        i = first(ax1) - 1
+        if ndims(bc) == 1 || bitst >= 64 - length(ax1)
+            if ndims(bc) > 1 && bitst != 0
+                @inbounds @simd for j = bitst:63
+                    remain |= UInt64(convert(Bool, bc′[i+=1, I])) << (j & 63)
+                end
+                @inbounds destc[indc+=1] = remain
+                bitst, remain = 0, UInt64(0)
+            end
+            while i <= last(ax1) - 64
+                z = UInt64(0)
+                @inbounds @simd for j = 0:63
+                    z |= UInt64(convert(Bool, bc′[i+=1, I])) << (j & 63)
+                end
+                @inbounds destc[indc+=1] = z
+            end
         end
-        @simd for i in ind:bitcache_size
-            tmp[i] = false
+        @inbounds @simd for j = i+1:last(ax1)
+            remain |= UInt64(convert(Bool, bc′[j, I])) << (bitst & 63)
+            bitst += 1
         end
-        dumpbitcache(destc, cind, tmp)
-        cind += bitcache_chunks
+    end
+    @inbounds if bitst != 0
+        destc[indc+=1] = remain
     end
     return dest
 end
diff --git a/test/broadcast.jl b/test/broadcast.jl
index 0a111f9523d60..ff0fc1401a703 100644
--- a/test/broadcast.jl
+++ b/test/broadcast.jl
@@ -592,6 +592,16 @@ end
     end
 end
 
+@testset "convert behavior of logical broadcast" begin
+    a = mod.(1:4, 2)
+    @test !isa(a, BitArray)
+    for T in (Array{Bool}, BitArray)
+        la = T(a)
+        la .= mod.(0:3, 2)
+        @test la == [false; true; false; true]
+    end
+end
+
 # Test that broadcast treats type arguments as scalars, i.e. containertype yields Any,
 # even for subtypes of abstract array. (https://github.com/JuliaStats/DataArrays.jl/issues/229)
 @testset "treat type arguments as scalars, DataArrays issue 229" begin

From 3a020532b48a74ba896e07b154206cd677b8ded1 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 5 Jan 2024 13:57:55 +0530
Subject: [PATCH 0540/1315] Fix quotes in the docstring of `copytrito!`
 (#52718)

---
 stdlib/LinearAlgebra/src/generic.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl
index ca01646820ccf..0b4382ccee22b 100644
--- a/stdlib/LinearAlgebra/src/generic.jl
+++ b/stdlib/LinearAlgebra/src/generic.jl
@@ -1903,7 +1903,7 @@ normalize(x, p::Real) = x / norm(x, p)
 
 Copies a triangular part of a matrix `A` to another matrix `B`.
 `uplo` specifies the part of the matrix `A` to be copied to `B`.
-Set `uplo = 'L'` for the lower triangular part or `uplo = 'U'
+Set `uplo = 'L'` for the lower triangular part or `uplo = 'U'`
 for the upper triangular part.
 
 !!! compat "Julia 1.11"

From 67e61270cbaf06ef3e42c556138e616235cc4ae4 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 5 Jan 2024 11:38:31 +0100
Subject: [PATCH 0541/1315] remove very old error hint from using `.data` field
 on a String (#52737)

This field was removed 7 years ago. I think it is fine to not special
case it any longer.
---
 base/errorshow.jl | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index 24663604f1a74..d33c5e3ca569d 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -149,13 +149,7 @@ showerror(io::IO, ::DivideError) = print(io, "DivideError: integer division erro
 showerror(io::IO, ::StackOverflowError) = print(io, "StackOverflowError:")
 showerror(io::IO, ::UndefRefError) = print(io, "UndefRefError: access to undefined reference")
 showerror(io::IO, ::EOFError) = print(io, "EOFError: read end of file")
-function showerror(io::IO, ex::ErrorException)
-    print(io, ex.msg)
-    if ex.msg == "type String has no field data"
-        println(io)
-        print(io, "Use `codeunits(str)` instead.")
-    end
-end
+showerror(io::IO, ex::ErrorException) = print(io, ex.msg)
 showerror(io::IO, ex::KeyError) = (print(io, "KeyError: key ");
                                    show(io, ex.key);
                                    print(io, " not found"))

From f68d7f8d1102824e666cb9af3e1454b6aa616c20 Mon Sep 17 00:00:00 2001
From: Fons van der Plas <fonsvdplas@gmail.com>
Date: Fri, 5 Jan 2024 13:58:06 +0100
Subject: [PATCH 0542/1315] [Markdown] Docstring for html and latex functions
 (#52733)

Part of #52725
---
 stdlib/Markdown/src/render/html.jl  | 15 +++++++++++++++
 stdlib/Markdown/src/render/latex.jl | 14 ++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/stdlib/Markdown/src/render/html.jl b/stdlib/Markdown/src/render/html.jl
index a48180509400f..3831e6acc7bb9 100644
--- a/stdlib/Markdown/src/render/html.jl
+++ b/stdlib/Markdown/src/render/html.jl
@@ -182,6 +182,21 @@ htmlinline(io::IO, x) = tohtml(io, x)
 
 export html
 
+"""
+    html([io::IO], md)
+
+Output the contents of the Markdown object `md` in HTML format, either
+writing to an (optional) `io` stream or returning a string.
+
+One can alternatively use `show(io, "text/html", md)` or `repr("text/html", md)`, which
+differ in that they wrap the output in a `<div class="markdown"> ... </div>` element.
+
+# Example
+```jldoctest
+julia> html(md"hello _world_")
+"<p>hello <em>world</em></p>\\n"
+```
+"""
 html(md) = sprint(html, md)
 
 function show(io::IO, ::MIME"text/html", md::MD)
diff --git a/stdlib/Markdown/src/render/latex.jl b/stdlib/Markdown/src/render/latex.jl
index d18a2e760ef3d..03bb78ba3efec 100644
--- a/stdlib/Markdown/src/render/latex.jl
+++ b/stdlib/Markdown/src/render/latex.jl
@@ -167,6 +167,20 @@ function latexesc(io, s::AbstractString)
     end
 end
 
+"""
+    latex([io::IO], md)
+
+Output the contents of the Markdown object `md` in LaTeX format, either
+writing to an (optional) `io` stream or returning a string.
+
+One can alternatively use `show(io, "text/latex", md)` or `repr("text/latex", md)`.
+
+# Example
+```jldoctest
+julia> latex(md"hello _world_")
+"hello \\\\emph{world}\\n\\n"
+```
+"""
 latex(md) = sprint(latex, md)
 latexinline(md) = sprint(latexinline, md)
 latexesc(s) = sprint(latexesc, s)

From f01898ca0d845ad4d08db56c6141f8395f1d576d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= <lars.goettgens@rwth-aachen.de>
Date: Fri, 5 Jan 2024 14:02:33 +0100
Subject: [PATCH 0543/1315] Fix printing of `InexactError` for `Inf16` arg and
 similar (#52491)

Resolves https://github.com/JuliaLang/julia/issues/51087
Closes https://github.com/JuliaLang/julia/pull/51163

Use `show` as pointed out in
https://github.com/JuliaLang/julia/pull/51163#discussion_r1328682832.
---
 base/errorshow.jl |  8 +++++++-
 test/errorshow.jl | 14 ++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index d33c5e3ca569d..3666c7daf7080 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -181,7 +181,13 @@ function showerror(io::IO, ex::InexactError)
     print(io, "InexactError: ", ex.func, '(')
     T = first(ex.args)
     nameof(T) === ex.func || print(io, T, ", ")
-    join(io, ex.args[2:end], ", ")
+    # `join` calls `string` on its arguments, which shadows the size of e.g. Inf16
+    # as `string(Inf16) == "Inf"` instead of "Inf16". Thus we cannot use `join` here.
+    for arg in ex.args[2:end-1]
+        show(io, arg)
+        print(io, ", ")
+    end
+    show(io, ex.args[end])
     print(io, ")")
     Experimental.show_error_hints(io, ex)
 end
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 28ca2c1bc3c5c..9fd850ff3cdb2 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -1090,3 +1090,17 @@ let e = @test_throws MethodError convert(TypeCompareError{Float64,1}, TypeCompar
     @test  occursin("TypeCompareError{Float64,1}", str)
     @test !occursin("TypeCompareError{Float64{},2}", str) # No {...} for types without params
 end
+
+@testset "InexactError for Inf16 should print '16' (#51087)" begin
+    @test sprint(showerror, InexactError(:UInt128, UInt128, Inf16)) == "InexactError: UInt128(Inf16)"
+
+    for IntType in [Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UInt128]
+        IntStr = string(IntType)
+        for InfVal in Any[Inf, Inf16, Inf32, Inf64]
+            InfStr = repr(InfVal)
+            e = @test_throws InexactError IntType(InfVal)
+            str = sprint(Base.showerror, e.value)
+            @test occursin("InexactError: $IntStr($InfStr)", str)
+        end
+    end
+end

From c9bc2ffd52e558aecf228b17d55e3eb0e4d5f693 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 5 Jan 2024 16:45:09 +0100
Subject: [PATCH 0544/1315] loading: fix finding bundled stdlibs even if they
 are e.g. devved in an environment higher in the load path (#52637)

I noticed this when seeing some weird precompile issues when I had
SparseArrays devved in my main environment but it was with the standard
stdlib format in the current environment:

```
(NearestNeighbors) pkg> st -m
Project NearestNeighbors v0.4.15
Status `~/JuliaPkgs/NearestNeighbors.jl/Manifest.toml`
...
  [2f01184e] SparseArrays v1.10.0
...
```

But even so, `locate_package` claims that the path to SparseArrays is
the one in the main environment:

```
julia> pkg = Base.PkgId(Base.UUID("2f01184e-e22b-5df5-ae63-d93ebab69eaf"), "SparseArrays")
SparseArrays [2f01184e-e22b-5df5-ae63-d93ebab69eaf]

julia> Base.locate_package(pkg)
"/home/kc/JuliaPkgs/SparseArrays.jl/src/SparseArrays.jl"
```

This correctly fixes it so that packages without a `git-tree-sha1` (and
without a `path`) are resolved to the stdlib path.
---
 base/loading.jl | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/base/loading.jl b/base/loading.jl
index 97aa9977a7184..d7d0a4af81382 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -955,7 +955,13 @@ function explicit_manifest_entry_path(manifest_file::String, pkg::PkgId, entry::
         return path
     end
     hash = get(entry, "git-tree-sha1", nothing)::Union{Nothing, String}
-    hash === nothing && return nothing
+    if hash === nothing
+        mbypath = manifest_uuid_path(Sys.STDLIB, pkg)
+        if mbypath isa String
+            return entry_path(mbypath, pkg.name)
+        end
+        return nothing
+    end
     hash = SHA1(hash)
     # Keep the 4 since it used to be the default
     uuid = pkg.uuid::UUID # checked within `explicit_manifest_uuid_path`

From c94b1a3cd810efd35b66ca4f5a60839989e18692 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 5 Jan 2024 15:42:40 -0500
Subject: [PATCH 0545/1315] staticdata: handle cycles in datatypes (#52752)

Handle any sort of cycle encountered in the datatype super fields by
always deferring that field until later and setting a deferred mechanism
for updating the field only after the supertype is ready.

Fix #52660
---
 src/staticdata.c       | 147 +++++++++++++++++++++++------------------
 src/staticdata_utils.c |  13 ++--
 test/precompile.jl     |   6 +-
 3 files changed, 95 insertions(+), 71 deletions(-)

diff --git a/src/staticdata.c b/src/staticdata.c
index 1873bb19f23d2..8ad4a275b743d 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -314,7 +314,6 @@ static arraylist_t deser_sym;
 static htable_t external_objects;
 
 static htable_t serialization_order; // to break cycles, mark all objects that are serialized
-static htable_t unique_ready; // as we serialize types, we need to know if all reachable objects are also already serialized. This tracks whether `immediate` has been set for all of them.
 static htable_t nullptrs;
 // FIFO queue for objects to be serialized. Anything requiring fixup upon deserialization
 // must be "toplevel" in this queue. For types, parameters and field types must appear
@@ -485,6 +484,7 @@ typedef struct {
     arraylist_t relocs_list;    // a list of (location, target) pairs, see description at top
     arraylist_t gctags_list;    //      "
     arraylist_t uniquing_types; // a list of locations that reference types that must be de-duplicated
+    arraylist_t uniquing_super; // a list of datatypes, used in super fields, that need to be marked in uniquing_types once they are reached, for handling unique-ing of them on deserialization
     arraylist_t uniquing_objs;  // a list of locations that reference non-types that must be de-duplicated
     arraylist_t fixup_types;    // a list of locations of types requiring (re)caching
     arraylist_t fixup_objs;     // a list of locations of objects requiring (re)caching
@@ -757,14 +757,13 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
 {
     jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v);
     jl_queue_for_serialization_(s, (jl_value_t*)t, 1, immediate);
+    const jl_datatype_layout_t *layout = t->layout;
 
     if (!recursive)
         goto done_fields;
 
     if (s->incremental && jl_is_datatype(v) && immediate) {
         jl_datatype_t *dt = (jl_datatype_t*)v;
-        // ensure super is queued (though possibly not yet handled, since it may have cycles)
-        jl_queue_for_serialization_(s, (jl_value_t*)dt->super, 1, 1);
         // ensure all type parameters are recached
         jl_queue_for_serialization_(s, (jl_value_t*)dt->parameters, 1, 1);
         if (jl_is_datatype_singleton(dt) && needs_uniquing(dt->instance)) {
@@ -773,7 +772,7 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
             // (it may get serialized from elsewhere though)
             record_field_change(&dt->instance, jl_nothing);
         }
-        immediate = 0; // do not handle remaining fields immediately (just field types remains)
+        goto done_fields; // for now
     }
     if (s->incremental && jl_is_method_instance(v)) {
         jl_method_instance_t *mi = (jl_method_instance_t*)v;
@@ -829,11 +828,9 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
         }
     }
 
-
     if (immediate) // must be things that can be recursively handled, and valid as type parameters
         assert(jl_is_immutable(t) || jl_is_typevar(v) || jl_is_symbol(v) || jl_is_svec(v));
 
-    const jl_datatype_layout_t *layout = t->layout;
     if (layout->npointers == 0) {
         // bitstypes do not require recursion
     }
@@ -896,22 +893,35 @@ done_fields: ;
 
     // We've encountered an item we need to cache
     void **bp = ptrhash_bp(&serialization_order, v);
-    assert(*bp != (void*)(uintptr_t)-1);
-    if (s->incremental) {
-        void **bp2 = ptrhash_bp(&unique_ready, v);
-        if (*bp2 == HT_NOTFOUND)
-            assert(*bp == (void*)(uintptr_t)-2);
-        else if (*bp != (void*)(uintptr_t)-2)
-            return;
-    }
-    else {
-        assert(*bp == (void*)(uintptr_t)-2);
-    }
+    assert(*bp == (void*)(uintptr_t)-2);
     arraylist_push(&serialization_queue, (void*) v);
     size_t idx = serialization_queue.len - 1;
     assert(serialization_queue.len < ((uintptr_t)1 << RELOC_TAG_OFFSET) && "too many items to serialize");
-
     *bp = (void*)((char*)HT_NOTFOUND + 1 + idx);
+
+    // DataType is very unusual, in that some of the fields need to be pre-order, and some
+    // (notably super) must not be (even if `jl_queue_for_serialization_` would otherwise
+    // try to promote itself to be immediate)
+    if (s->incremental && jl_is_datatype(v) && immediate && recursive) {
+        jl_datatype_t *dt = (jl_datatype_t*)v;
+        void **bp = ptrhash_bp(&serialization_order, (void*)dt->super);
+        if (*bp != (void*)-2) {
+            // if super is already on the stack of things to handle when this returns, do
+            // not try to handle it now
+            jl_queue_for_serialization_(s, (jl_value_t*)dt->super, 1, immediate);
+        }
+        immediate = 0;
+        char *data = (char*)jl_data_ptr(v);
+        size_t i, np = layout->npointers;
+        for (i = 0; i < np; i++) {
+            uint32_t ptr = jl_ptr_offset(t, i);
+            if (ptr * sizeof(jl_value_t*) == offsetof(jl_datatype_t, super))
+                continue; // skip the super field, since it might not be quite validly ordered
+            int mutabl = 1;
+            jl_value_t *fld = get_replaceable_field(&((jl_value_t**)data)[ptr], mutabl);
+            jl_queue_for_serialization_(s, fld, 1, immediate);
+        }
+    }
 }
 
 static void jl_queue_for_serialization_(jl_serializer_state *s, jl_value_t *v, int recursive, int immediate) JL_GC_DISABLED
@@ -930,28 +940,19 @@ static void jl_queue_for_serialization_(jl_serializer_state *s, jl_value_t *v, i
     }
 
     void **bp = ptrhash_bp(&serialization_order, v);
-    if (*bp == HT_NOTFOUND) {
-        *bp = (void*)(uintptr_t)(immediate ? -2 : -1);
-    }
-    else {
-        if (!s->incremental || !immediate || !recursive)
-            return;
-        void **bp2 = ptrhash_bp(&unique_ready, v);
-        if (*bp2 == HT_NOTFOUND)
-            *bp2 = v; // now is unique_ready
-        else {
-            assert(*bp != (void*)(uintptr_t)-1);
-            return; // already was unique_ready
-        }
-        assert(*bp != (void*)(uintptr_t)-2); // should be unique_ready then
-        if (*bp == (void*)(uintptr_t)-1)
-            *bp = (void*)(uintptr_t)-2; // now immediate
-    }
+    assert(!immediate || *bp != (void*)(uintptr_t)-2);
+    if (*bp == HT_NOTFOUND)
+        *bp = (void*)(uintptr_t)-1; // now enqueued
+    else if (!s->incremental || !immediate || !recursive || *bp != (void*)(uintptr_t)-1)
+        return;
 
-    if (immediate)
+    if (immediate) {
+        *bp = (void*)(uintptr_t)-2; // now immediate
         jl_insert_into_serialization_queue(s, v, recursive, immediate);
-    else
+    }
+    else {
         arraylist_push(&object_worklist, (void*)v);
+    }
 }
 
 // Do a pre-order traversal of the to-serialize worklist, in the identical order
@@ -1101,8 +1102,10 @@ static void record_uniquing(jl_serializer_state *s, jl_value_t *fld, uintptr_t o
     if (s->incremental && jl_needs_serialization(s, fld) && needs_uniquing(fld)) {
         if (jl_is_datatype(fld) || jl_is_datatype_singleton((jl_datatype_t*)jl_typeof(fld)))
             arraylist_push(&s->uniquing_types, (void*)(uintptr_t)offset);
-        else
+        else if (jl_is_method_instance(fld))
             arraylist_push(&s->uniquing_objs, (void*)(uintptr_t)offset);
+        else
+            assert(0 && "unknown object type with needs_uniquing set");
     }
 }
 
@@ -1301,7 +1304,15 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                     write_pointerfield(s, (jl_value_t*)mi->sparam_vals);
                     continue;
                 }
-                else if (!jl_is_datatype(v)) {
+                else if (jl_is_datatype(v)) {
+                    for (size_t i = 0; i < s->uniquing_super.len; i++) {
+                        if (s->uniquing_super.items[i] == (void*)v) {
+                            s->uniquing_super.items[i] = arraylist_pop(&s->uniquing_super);
+                            arraylist_push(&s->uniquing_types, (void*)(uintptr_t)(reloc_offset|3));
+                        }
+                    }
+                }
+                else {
                     assert(jl_is_datatype_singleton(t) && "unreachable");
                 }
             }
@@ -1698,6 +1709,9 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                         ios_write(s->const_data, (char*)&dyn, sizeof(jl_fielddescdyn_t));
                     }
                 }
+                void *superidx = ptrhash_get(&serialization_order, dt->super);
+                if (s->incremental && superidx != HT_NOTFOUND && (char*)superidx - 1 - (char*)HT_NOTFOUND > item && needs_uniquing((jl_value_t*)dt->super))
+                    arraylist_push(&s->uniquing_super, dt->super);
             }
             else if (jl_is_typename(v)) {
                 assert(f == s->s);
@@ -1741,6 +1755,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
             }
         }
     }
+    assert(s->uniquing_super.len == 0);
 }
 
 // In deserialization, create Symbols and set up the
@@ -2566,7 +2581,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
         ptrhash_put(&fptr_to_id, (void*)(uintptr_t)id_to_fptrs[i], (void*)(i + 2));
     }
     htable_new(&serialization_order, 25000);
-    htable_new(&unique_ready, 0);
     htable_new(&nullptrs, 0);
     arraylist_new(&object_worklist, 0);
     arraylist_new(&serialization_queue, 0);
@@ -2591,6 +2605,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     arraylist_new(&s.relocs_list, 0);
     arraylist_new(&s.gctags_list, 0);
     arraylist_new(&s.uniquing_types, 0);
+    arraylist_new(&s.uniquing_super, 0);
     arraylist_new(&s.uniquing_objs, 0);
     arraylist_new(&s.fixup_types, 0);
     arraylist_new(&s.fixup_objs, 0);
@@ -2842,6 +2857,11 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     arraylist_free(&object_worklist);
     arraylist_free(&serialization_queue);
     arraylist_free(&layout_table);
+    arraylist_free(&s.uniquing_types);
+    arraylist_free(&s.uniquing_super);
+    arraylist_free(&s.uniquing_objs);
+    arraylist_free(&s.fixup_types);
+    arraylist_free(&s.fixup_objs);
     arraylist_free(&s.ccallable_list);
     arraylist_free(&s.memowner_list);
     arraylist_free(&s.memref_list);
@@ -2853,7 +2873,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     if (worklist)
         htable_free(&external_objects);
     htable_free(&serialization_order);
-    htable_free(&unique_ready);
     htable_free(&nullptrs);
     htable_free(&symbol_table);
     htable_free(&fptr_to_id);
@@ -3224,31 +3243,43 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         uintptr_t item = (uintptr_t)s.uniquing_types.items[i];
         // check whether we are operating on the typetag
         // (needing to ignore GC bits) or a regular field
-        int tag = (item & 1) == 1;
-        // check whether this is a gvar index
-        int gvar = (item & 2) == 2;
+        // and check whether this is a gvar index
+        int tag = (item & 3);
         item &= ~(uintptr_t)3;
         uintptr_t *pfld;
         jl_value_t **obj, *newobj;
-        if (gvar) {
+        if (tag == 3) {
+            obj = (jl_value_t**)(image_base + item);
+            pfld = NULL;
+            for (size_t i = 0; i < delay_list.len; i += 2) {
+                if (obj == (jl_value_t **)delay_list.items[i + 0]) {
+                    pfld = (uintptr_t*)delay_list.items[i + 1];
+                    delay_list.items[i + 1] = arraylist_pop(&delay_list);
+                    delay_list.items[i + 0] = arraylist_pop(&delay_list);
+                    break;
+                }
+            }
+            assert(pfld);
+        }
+        else if (tag == 2) {
             if (image->gvars_base == NULL)
                 continue;
             item >>= 2;
             assert(item < s.gvar_record->size / sizeof(reloc_t));
             pfld = sysimg_gvars(image->gvars_base, image->gvars_offsets, item);
             obj = *(jl_value_t***)pfld;
-            assert(tag == 0);
         }
         else {
             pfld = (uintptr_t*)(image_base + item);
-            if (tag)
+            if (tag == 1)
                 obj = (jl_value_t**)jl_typeof(jl_valueof(pfld));
             else
                 obj = *(jl_value_t***)pfld;
             if ((char*)obj > (char*)pfld) {
+                // this must be the super field
                 assert(tag == 0);
-                arraylist_push(&delay_list, pfld);
                 arraylist_push(&delay_list, obj);
+                arraylist_push(&delay_list, pfld);
                 ptrhash_put(&new_dt_objs, (void*)obj, obj); // mark obj as invalid
                 *pfld = (uintptr_t)NULL;
                 continue;
@@ -3298,25 +3329,14 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
             assert(newobj && newobj != jl_nothing);
             arraylist_push(&cleanup_list, (void*)obj);
         }
-        if (tag)
+        if (tag == 1)
             *pfld = (uintptr_t)newobj | GC_OLD | GC_IN_IMAGE;
         else
             *pfld = (uintptr_t)newobj;
         assert(!(image_base < (char*)newobj && (char*)newobj <= image_base + sizeof_sysimg));
         assert(jl_typetagis(obj, otyp));
     }
-    // A few fields (reached via super) might be self-recursive. This is rare, but handle them now.
-    // They cannot be instances though, since the type must fully exist before the singleton field can be allocated
-    for (size_t i = 0; i < delay_list.len; ) {
-        uintptr_t *pfld = (uintptr_t*)delay_list.items[i++];
-        jl_value_t **obj = (jl_value_t **)delay_list.items[i++];
-        assert(jl_is_datatype(obj));
-        jl_datatype_t *dt = (jl_datatype_t*)obj[0];
-        assert(jl_is_datatype(dt));
-        jl_value_t *newobj = (jl_value_t*)dt;
-        *pfld = (uintptr_t)newobj;
-        assert(!(image_base < (char*)newobj && (char*)newobj <= image_base + sizeof_sysimg));
-    }
+    assert(delay_list.len == 0);
     arraylist_free(&delay_list);
     // now that all the fields of dt are assigned and unique, copy them into
     // their final newdt memory location: this ensures we do not accidentally
@@ -3364,11 +3384,12 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     for (size_t i = 0; i < s.uniquing_objs.len; i++) {
         uintptr_t item = (uintptr_t)s.uniquing_objs.items[i];
         // check whether this is a gvar index
-        int gvar = (item & 2) == 2;
+        int tag = (item & 3);
+        assert(tag == 0 || tag == 2);
         item &= ~(uintptr_t)3;
         uintptr_t *pfld;
         jl_value_t **obj, *newobj;
-        if (gvar) {
+        if (tag == 2) {
             if (image->gvars_base == NULL)
                 continue;
             item >>= 2;
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index 35233cf0795f0..9fded902df0bd 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -45,16 +45,15 @@ int must_be_new_dt(jl_value_t *t, htable_t *news, char *image_base, size_t sizeo
         jl_datatype_t *dt = (jl_datatype_t*)t;
         assert(jl_object_in_image((jl_value_t*)dt->name) && "type_in_worklist mistake?");
         jl_datatype_t *super = dt->super;
-        // check if super is news, since then we must be new also
-        // (it is also possible that super is indeterminate now, wait for `t`
-        // to be resolved, then will be determined later and fixed up by the
-        // delay_list, for this and any other references to it).
-        while (super != jl_any_type) {
-            assert(super);
+        // fast-path: check if super is in news, since then we must be new also
+        // (it is also possible that super is indeterminate or NULL right now,
+        // waiting for `t` to be resolved, then will be determined later as
+        // soon as possible afterwards).
+        while (super != NULL && super != jl_any_type) {
             if (ptrhash_has(news, (void*)super))
                 return 1;
             if (!(image_base < (char*)super && (char*)super <= image_base + sizeof_sysimg))
-               break; // fast-path for rejection of super
+               break; // the rest must all be non-new
             // otherwise super might be something that was not cached even though a later supertype might be
             // for example while handling `Type{Mask{4, U} where U}`, if we have `Mask{4, U} <: AbstractSIMDVector{4}`
             super = super->super;
diff --git a/test/precompile.jl b/test/precompile.jl
index e655dd03b9798..a717d543bc0ce 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -115,6 +115,8 @@ precompile_test_harness(false) do dir
                   d = den(a)
                   return h
               end
+              abstract type AbstractAlgebraMap{A} end
+              struct GAPGroupHomomorphism{A, B} <: AbstractAlgebraMap{GAPGroupHomomorphism{B, A}} end
           end
           """)
     write(Foo2_file,
@@ -130,7 +132,7 @@ precompile_test_harness(false) do dir
     write(Foo_file,
           """
           module $Foo_module
-              import $FooBase_module, $FooBase_module.typeA
+              import $FooBase_module, $FooBase_module.typeA, $FooBase_module.GAPGroupHomomorphism
               import $Foo2_module: $Foo2_module, override, overridenc
               import $FooBase_module.hash
               import Test
@@ -213,6 +215,8 @@ precompile_test_harness(false) do dir
               Base.convert(::Type{Some{Value18343}}, ::Value18343{Some}) = 2
               Base.convert(::Type{Ref}, ::Value18343{T}) where {T} = 3
 
+              const GAPType1 = GAPGroupHomomorphism{Nothing, Nothing}
+              const GAPType2 = GAPGroupHomomorphism{1, 2}
 
               # issue #28297
               mutable struct Result

From 103e50a764e4e6bff5cfa43a40f87abef71f2cc7 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 5 Jan 2024 22:37:37 -0300
Subject: [PATCH 0546/1315] also enable gc_assert_parent_validity on GC_VERIFY
 (#52767)

Keeping this functionality untested on CI increases the chance of it
rotting.
---
 src/gc.c      | 2 +-
 src/options.h | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/gc.c b/src/gc.c
index 57bd81baf4827..4937463897f31 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1862,7 +1862,7 @@ STATIC_INLINE uintptr_t gc_read_stack(void *_addr, uintptr_t offset,
 
 STATIC_INLINE void gc_assert_parent_validity(jl_value_t *parent, jl_value_t *child) JL_NOTSAFEPOINT
 {
-#ifdef GC_ASSERT_PARENT_VALIDITY
+#if defined(GC_VERIFY) || defined(GC_ASSERT_PARENT_VALIDITY)
     jl_taggedvalue_t *child_astagged = jl_astaggedvalue(child);
     jl_taggedvalue_t *child_vtag = (jl_taggedvalue_t *)(child_astagged->header & ~(uintptr_t)0xf);
     uintptr_t child_vt = (uintptr_t)child_vtag;
diff --git a/src/options.h b/src/options.h
index 685dea7b981db..8d02703ce7bbe 100644
--- a/src/options.h
+++ b/src/options.h
@@ -64,6 +64,10 @@
 #endif
 #endif
 
+// GC_ASSERT_PARENT_VALIDITY will check whether an object is valid when **pushing**
+// it to the mark queue
+// #define GC_ASSERT_PARENT_VALIDITY
+
 // profiling options
 
 // GC_FINAL_STATS prints total GC stats at exit

From ae5880afd7738874f9ad8f2c958f4da751b2bb86 Mon Sep 17 00:00:00 2001
From: Erik Schnetter <schnetter@gmail.com>
Date: Fri, 5 Jan 2024 22:37:14 -0500
Subject: [PATCH 0547/1315] EscapeAnalysis.jl: Correct grammar in comment
 (#52764)

---
 base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl | 2 +-
 base/compiler/ssair/ir.jl                            | 2 +-
 base/compiler/ssair/passes.jl                        | 4 ++--
 base/compiler/ssair/slot2ssa.jl                      | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index e4ea159ac8824..c1f3cf3f97885 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -42,7 +42,7 @@ const AInfo = IdSet{Any}
     x::EscapeInfo
 
 A lattice for escape information, which holds the following properties:
-- `x.Analyzed::Bool`: not formally part of the lattice, only indicates `x` has not been analyzed or not
+- `x.Analyzed::Bool`: not formally part of the lattice, only indicates whether `x` has been analyzed
 - `x.ReturnEscape::Bool`: indicates `x` can escape to the caller via return
 - `x.ThrownEscape::BitSet`: records SSA statement numbers where `x` can be thrown as exception:
   * `isempty(x.ThrownEscape)`: `x` will never be thrown in this call frame (the bottom)
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 9af6647cdbc58..c4086ff508773 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -82,7 +82,7 @@ block_for_inst(cfg::CFG, inst::Int) = block_for_inst(cfg.index, inst)
             end
         end
     end
-    # and add add one more basic block start after the last statement
+    # and add one more basic block start after the last statement
     for i = length(stmts):-1:1
         if stmts[i] !== nothing
             push!(jump_dests, i+1)
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 5ba8acd03fc7c..62dd4305243ec 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -986,7 +986,7 @@ function lift_keyvalue_get!(compact::IncrementalCompact, idx::Int, stmt::Expr, 
     return
 end
 
-# TODO: We could do the whole lifing machinery here, but really all
+# TODO: We could do the whole lifting machinery here, but really all
 # we want to do is clean this up when it got inserted by inlining,
 # which always targets simple `svec` call or `_compute_sparams`,
 # so this specialized lifting would be enough
@@ -1617,7 +1617,7 @@ function try_resolve_finalizer!(ir::IRCode, idx::Int, finalizer_idx::Int, defuse
     end
 
     # Ok, legality check complete. Figure out the exact statement where we're
-    # gonna inline the finalizer.
+    # going to inline the finalizer.
     loc = bb_insert_idx === nothing ? first(ir.cfg.blocks[bb_insert_block].stmts) : bb_insert_idx::Int
     attach_after = bb_insert_idx !== nothing
 
diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl
index c2a769acbe9e9..7ee07585fae9b 100644
--- a/base/compiler/ssair/slot2ssa.jl
+++ b/base/compiler/ssair/slot2ssa.jl
@@ -229,7 +229,7 @@ Run iterated dominance frontier.
 The algorithm we have here essentially follows LLVM, which itself is a
 a cleaned up version of the linear-time algorithm described in [^SG95].
 
-The algorithm here, is quite straightforward. Suppose we have a CFG:
+The algorithm here is quite straightforward. Suppose we have a CFG:
 
     A -> B -> D -> F
      \\-> C ------>/

From 9aaa8c7a37bae1875396115f0486c79d8c8f20ce Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Sat, 6 Jan 2024 00:09:43 -0600
Subject: [PATCH 0548/1315] Use `jl_types_egal` in `equiv_field_types` (#52748)

Fixes #52686
Fixes https://github.com/timholy/Revise.jl/issues/770

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 src/builtins.c |  2 +-
 test/core.jl   | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/builtins.c b/src/builtins.c
index e6472457cb6a9..f8832e0ac952b 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1786,7 +1786,7 @@ static int equiv_field_types(jl_value_t *old, jl_value_t *ft)
         jl_value_t *ta = jl_svecref(old, i);
         jl_value_t *tb = jl_svecref(ft, i);
         if (jl_has_free_typevars(ta)) {
-            if (!jl_has_free_typevars(tb) || !jl_egal(ta, tb))
+            if (!jl_has_free_typevars(tb) || !jl_types_egal(ta, tb))
                 return 0;
         }
         else if (jl_has_free_typevars(tb) || jl_typetagof(ta) != jl_typetagof(tb) ||
diff --git a/test/core.jl b/test/core.jl
index 7245b488624b0..1f66d72c40c5e 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -111,6 +111,21 @@ let abcd = ABCDconst(1, 2, 3, 4)
         abcd.d = nothing)
     @test (1, 2, "not constant", 4) === (abcd.a, abcd.b, abcd.c, abcd.d)
 end
+# Issue #52686
+struct A52686{T} end
+struct B52686{T, S}
+    a::A52686{<:T}
+end
+function func52686()
+    @eval begin
+        struct A52686{T} end
+        struct B52686{T, S}
+            a::A52686{<:T}
+        end
+    end
+    return true
+end
+@test func52686()
 
 # test `===` handling null pointer in struct #44712
 struct N44712

From b6825924aefb9ca1ca0022b3915a1c94fbf9a861 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 6 Jan 2024 09:41:27 +0100
Subject: [PATCH 0549/1315] [OpenBLAS] Ugrade to v0.3.26 (#52762)

Memo to self:

* update version number in `stdlib/OpenBLAS_jll/Project.toml`
* update version number and sha in `deps/openblas.version`
* refresh checksums with `make -f contrib/refresh_checksums.mk -j
openblas`

In the [release notes of
v0.3.26](https://github.com/OpenMathLib/OpenBLAS/releases/tag/v0.3.26)
one of the more interesting point is perhaps

> included support for Apple M1 and newer targets in DYNAMIC_ARCH builds

Quoting from
https://github.com/JuliaPackaging/Yggdrasil/pull/7911#issuecomment-1878884892

> Some quick benchmarks on M1: with OpenBLAS 0.3.25:
> ```julia
> julia> using LinearAlgebra, BenchmarkTools
>
> julia> peakflops()
> 1.7049262964078418e11
>
> julia> x = randn(1_000); y = randn(size(x));
>
> julia> @btime dot($x, $y);
>   402.705 ns (0 allocations: 0 bytes)
> ```
> with OpenBLAS v0.3.26:
> ```julia
> julia> using LinearAlgebra, BenchmarkTools
>
> julia> peakflops()
> 1.8042546290642157e11
>
> julia> x = randn(1_000); y = randn(size(x));
>
> julia> @btime dot($x, $y);
>   143.777 ns (0 allocations: 0 bytes)
> ```
> Up to OpenBLAS v0.3.25 you can get similar performance on Apple
Silicon by exporting the environment variable
> ```sh
> OPENBLAS_CORETYPE=NEOVERSEN1
> ```
---
 deps/checksums/openblas          | 188 +++++++++++++++----------------
 deps/openblas.version            |   6 +-
 stdlib/OpenBLAS_jll/Project.toml |   2 +-
 3 files changed, 98 insertions(+), 98 deletions(-)

diff --git a/deps/checksums/openblas b/deps/checksums/openblas
index b49af255be0e7..1c6f4242c4fd5 100644
--- a/deps/checksums/openblas
+++ b/deps/checksums/openblas
@@ -1,94 +1,94 @@
-OpenBLAS.v0.3.25+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/1acfa1d2dbebaf274812e36b59cdd0f7
-OpenBLAS.v0.3.25+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/4cf10b1e5a791dcaea814f4f34b328499405b39c68ed652569e3a070f14c51b935e18d04bc10440b19967a40d21d7ef4c061817a5e6abf1403613e25cd45ef2f
-OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/bf8cb41b65e7b60015b67727adca5c50
-OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/710646a8e7bcf1cb0320777006d328b20f90463dac29f37b0c0472d22a8e00e49bd8aad1a0e71772279bf452e5daef9a6e9b51a5ea2af806fcdcae2999039108
-OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/60ff3026347c9a53f88cc90fd0f29950
-OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/1dd600ac2b315a051c84529e4653aad77d43c228538ebe94c36b6f68ed14a15c5d7cfad17b49eeba4ce0ec857d7199b767c241a5e9863f7c60d5f516020a8d20
-OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/5b57d42de0fa82c123f792adb6835195
-OpenBLAS.v0.3.25+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/e534b6c26100a8c841a1a81dee75cd2ae8c34f5bc3ddcd6b5cc9afdc21d46419459046371fa448c5b9c6d02eeccfb64d10c887c53b52c4744e809c50d3b7d41d
-OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/d2417bfa94754ca621c875b926dadd66
-OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/249b95d0502f6f82ac7151a38380c8a6cf9314e856a9f545cc086b14eaa3f7804ff24eb8b3430144c3add912aeec8fbfaee40fe30e4245fcafec3e9df3a73484
-OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/d68bee54d083f93fa9a96ccaa0b10d6c
-OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/909d9d4a9581899c564f6a42f325e50ba7b82f1bf7d2912a9d47cc88e8e13ddda6dff8a40680720f8d0a4a1973f6b6c48ffd0ec51d0323cb08cc73268386a61c
-OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/f103f1d84b9bbac3d73d70efa79f8f8a
-OpenBLAS.v0.3.25+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/ad1bbfbfce09e7a7eb6d33e87f432530a3347d68b033d877029f8da9e290b129b2ab887eac510b27c9a1d9506679fb3e7e554dc0accfa05c5c950ae40c1501e6
-OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/8d92bf601f216b0512e1eb9bb0f4689e
-OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8abd7f22db9d739c90df3c512ec4958989135e894d45ee91bf364e4c4a07b3dd8640351e596ef4b62f314bcf0ed22a35036499756611f5db1f98bdf1a3130033
-OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/c56a5861637867ca4d0a88e2d71e0301
-OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/301a30c2d5c1a6355516a0520caadf83f1e121e95480bbaf3c39baaedfb10902adea826b289f0e5411ec9bb12eeb0a63fb3630b1ef3780304689a2d2bb97add8
-OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/6c8f6582db03396ed30b41deeb706877
-OpenBLAS.v0.3.25+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/22e2c5ba0a9d6fe1dea222d24fe5da9b208525656185945a8ef90e201592e8c2692571bde7824651dde50850b0a81f25b5dfd8d4283a097d2f6193507128b587
-OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/546e7ec9501a6687784c9285b70cf2d4
-OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/8d306c18e810a22b637c5fa2f35b791b44aec67198b1a2632ff245cf5519cf138d2074eea84e85a348075b77b90eb5ff6342a920e66e508501eefd6c8cabfb6b
-OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/494c5b1a2df492723aedc05301958606
-OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/01d413b45df28b6c262d2e1c1859a499d10e24cbf32c8954b5fe5f66c6cbc13e113e7834db304beee02a31228f2c5c1bb83e83455551b63cc972cf0d604db843
-OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/0e14407a456d8354d4759140b8c2dcab
-OpenBLAS.v0.3.25+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/38b045a701d0dc1cc161877944a6db5154b36437d4122460727f489b05b902a7766e760ace5331a4056f804a8008fb3e123c905adae45839d1eeeadf1f209116
-OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/8d92bf601f216b0512e1eb9bb0f4689e
-OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8abd7f22db9d739c90df3c512ec4958989135e894d45ee91bf364e4c4a07b3dd8640351e596ef4b62f314bcf0ed22a35036499756611f5db1f98bdf1a3130033
-OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/c56a5861637867ca4d0a88e2d71e0301
-OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/301a30c2d5c1a6355516a0520caadf83f1e121e95480bbaf3c39baaedfb10902adea826b289f0e5411ec9bb12eeb0a63fb3630b1ef3780304689a2d2bb97add8
-OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/6c8f6582db03396ed30b41deeb706877
-OpenBLAS.v0.3.25+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/22e2c5ba0a9d6fe1dea222d24fe5da9b208525656185945a8ef90e201592e8c2692571bde7824651dde50850b0a81f25b5dfd8d4283a097d2f6193507128b587
-OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/546e7ec9501a6687784c9285b70cf2d4
-OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/8d306c18e810a22b637c5fa2f35b791b44aec67198b1a2632ff245cf5519cf138d2074eea84e85a348075b77b90eb5ff6342a920e66e508501eefd6c8cabfb6b
-OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/494c5b1a2df492723aedc05301958606
-OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/01d413b45df28b6c262d2e1c1859a499d10e24cbf32c8954b5fe5f66c6cbc13e113e7834db304beee02a31228f2c5c1bb83e83455551b63cc972cf0d604db843
-OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/0e14407a456d8354d4759140b8c2dcab
-OpenBLAS.v0.3.25+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/38b045a701d0dc1cc161877944a6db5154b36437d4122460727f489b05b902a7766e760ace5331a4056f804a8008fb3e123c905adae45839d1eeeadf1f209116
-OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran3.tar.gz/md5/fb62eeaa26adad79f27a4871abe4c8f2
-OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/1712755c80f7d48052fdc2ffd254b745ddd5d9a90bcf2f25532448d258317664895efdd8b92054a17271349e6371449b3dbf1cbe44d2bab2b2a11e77a0f8207e
-OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran4.tar.gz/md5/bbb096eb2294179d4bbac42fa08dfa04
-OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/6de33c7a98077c82d2d730b2a3046f9d84cf779c46527e70b4e862c2b51b7487d3b5d66eb1693235ab19bb9b254f85677707bfe496ca96e8b2f9840413d52d86
-OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran5.tar.gz/md5/25e6e7f428ca9d817ce06dfd1ce440d7
-OpenBLAS.v0.3.25+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/3d7d12c9de5d435fd7d9b8919c6b511d3a825e02d9d303a2222f16d13f7c93b620e6099fb290cd36648f51952c187b9100753e107530be2d40c1e006f44ac453
-OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran3.tar.gz/md5/0f09043138753743b33bdc1598ea2f98
-OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran3.tar.gz/sha512/a43510a70e63b534812fb0213af75743c0c78f8d153e61cfa0b3ec0b5a51172db3d3ca5b40429ccfd2fe99eb730db661566d61f825f0c97d079f75933ab17385
-OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran4.tar.gz/md5/b8c78d226bf548306cb0de09c296fcfd
-OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran4.tar.gz/sha512/165b85271b686da7daad21e2d3be683efcf8beb3208d2ba73e753cdc8405236c673ceb5713f84131a5b44045721c98de70242f600f7823c1597d38156f692ca6
-OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran5.tar.gz/md5/1f508ddbb3ef7aff7880b34a8caeb032
-OpenBLAS.v0.3.25+0.i686-linux-musl-libgfortran5.tar.gz/sha512/9f603451d957483b5be45dd8d705f0a45f0fa3fa4e32d9431a15b7dc986fbce200d7d8966717564c588ee3a367c949342b63f03b81de387bb90c691cb3b0d2a5
-OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/e85605ee1a4d33d43a2fb2e516eaa99f
-OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/98512575e60b34df6fe0a2d3f4a0a57d8f9ef1ef7a65b014427776104633acffbbd48bdb8aecdeb54dca1bdee39e1efd6f677dd68028911f2dfbe55f1180f054
-OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/673c70c7f29dab76a154b5171f6112a2
-OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/4ec6313ddbdcf3a98d48bc8510d5c120fb3232433738a28e9ccd9beec1e2a0ef401c625b0b97702cd7be7fd6061e2f8ed48f35ae36b46495d952053e0accaaae
-OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/7242fefbdb29d0ef5f08f39590fb204d
-OpenBLAS.v0.3.25+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/be253db33b2345388550d3e82b8cea4e9416874df5e01b24e96796faace87440178a10e93a47d228b4e31e21754de8b42a067e69aba8ab6267a19e7197f3d54c
-OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/1fd83d8f353195c7ae1a1fa9ea266171
-OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/0cb87fb1dbe6af1f1aef1bb3e346078a9de39d2ef33a51c99c0fafe67cdb494b1aae567429a9bec8fdfd41c651afe63815b7ecec20ea95fb3d0bedf06eb78188
-OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/f2a4141dea91feef792036dd149e552d
-OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/58dc721598f36380c65f34cb5d3efeb77bb03605afb82bb08689674893cb399af34dde47002105f072422d031df8f629fbfb4f463a9900c3b09fd6e98b3d007b
-OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/f472322bd6f463f335d7b9c5b2ae69be
-OpenBLAS.v0.3.25+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/b9530287d7972b599535b4d78a2540e00a49664660c077cf7c50ebcc86e79fb7fb2e6ddd2d1f3e80c1f4f6d6094c4f4a0641e3112994f7b770ac14868c704ec0
-OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/28c498d970d4c659d47981f915448a2e
-OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/f5a5d9d98013b39b26134910ba9e2cbd23caf1bfca1cb9867e972753081cafd90edfa5089747d94b87368aa4cecffcb40314326b82a47ddb4eafa3a63437482e
-OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/2888ac4b4ad4f693b652c0054187360b
-OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/0292f8d1ecbc5b357c1b9891944831cf652d1937d62a4d7486dc5c4dea3a9fa54bd1f0d76ba5553fe009d09e68edb79ee1310ac2b296ba61e33ea1ed794f4713
-OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/f3868395464c24b87fe543a630799cb8
-OpenBLAS.v0.3.25+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/4790f559458a301cb4ca9ce11bb2004b2bc0a72f7cf88c7dc45572f7c56adb154f7ab76a72e463ac0871019248e4b6ed4129356ab036bc71bee3700235f9f805
-OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/83fde9ea432e7c87413ebedea4062070
-OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/00428ed95ef6dd1191911e768d929d9a511f34ad1f098c6311df7f2176fb82d67e763326da95fc390ec05854a7a1482c3e2e4efd4b1975653c45a825b4b3ef68
-OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/415f468e44c3762451b39596eb6dd45d
-OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/bda9c30547cc219fdc00d3854ad02708d225a46850c7a95b786b527722e75185787ab2353185007cb9f692a4cd5a3c38d64018a46ee4d400df9d4612371a2a9b
-OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/7858a2a1c13b6707f6bee3b021811728
-OpenBLAS.v0.3.25+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/0a0e4995652e9459dd54325ee92262261244ace5f065f293459ad91433345efbbdf1e51996ae2629968498a8fc34b0fb64fadde7bc36498a48eeefafde987d5d
-OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/30f5deef5223ee198acb8c213a7c89b1
-OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/a933e33e6070475450312d0608626811bae98e129adb30d84cf5a3c7d525217e805b0ffb88490931a927b1fda1c9479af953282e47af1f469f993d4d2150da95
-OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/86fd8946da2bd4fb97f54c8df5883d5e
-OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/d61187e632a0d49c89854d441b9b42fcd9dc7517f4f38514cd17f599c2f9ad3600054bf8457d0e9fb766fe9c7d0c248cd3e5383be2600ac2c538f2d524a8e1de
-OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/d95539fa91c80db375310ed09d191379
-OpenBLAS.v0.3.25+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/ab786856a1c4ab47808e9ea2167c6ae42e69d6a11e539b7771464bbc0c7bb1d5482ed2c3c0154fae37bfb1579103e862637675e4d81726d4e3ed633cd7548cd9
-OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/09ea7329e39dac562e45f00e6b135ad6
-OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/c0b8b3b6f7c9a326b857e218014bc232165122865c18811bc5c9af28b54c494a4a0ed139101cdf30ff5e8b03f9e8bb4ce32865ab5ba4e5251f841a2bf612eb86
-OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/f874721e0ee45094c62cf4a006c5309c
-OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/03d57202ef4209f23f83a5faef01c772c2c6b04085d8448b835eec793b50b9f2f13dec2ba1d0a7ac55f6be7df8231a04163ac6d1fccb91976e965fd10bc0e3f1
-OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/69de0e673292ccaf3294e785a96cc22b
-OpenBLAS.v0.3.25+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/9ff1dd63a62d5f0d771833a7872d0abdf6e2307aabf57d7b5f1469f75aeda99525beb5a4c2f311cef0b8af3905daab321435b613c9e046a7d7c5c30e2548ba0b
-OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/2cd93681be2f2f781285ca7dbef7eba1
-OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/3163b20884e9be0a6d99735c400ca58f52f097fbbcb396be0ce9c29b3d4adebe5cee4ddb91f095a692e1f812c5558690a603bd455c5576c374e7c49e6cfaac7b
-OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/751aff51cf7674bcb68fe3bb94137603
-OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/b5fa7477f9033f5e55214fb4e0bd3bf923e2c580c6582b7241739237dc50d269448459efebf75da82415ceb2f547033210f118d9b8c9ab2585fc792253331309
-OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/de458200baed33ba568f8222a9b72865
-OpenBLAS.v0.3.25+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/d6acccb3a10e3eb01be2aacb4d77f084f022fef3ca3bbf05530cae5c13224b4ab12b62e8e8a3ce1ef6ab0b2cca9e88c687794a8620fe0af1c478323976268d5a
-openblas-9f815cf1bf16b4e64d4aee681b33558fc090b62a.tar.gz/md5/d890367a6452aa209f396359fb770bc7
-openblas-9f815cf1bf16b4e64d4aee681b33558fc090b62a.tar.gz/sha512/0627960fc2582e08fd039c77aab1f4105f18edb1beba52176a791813bb3f1ebb04f52d174814e156826c45c6adf5f3c1d2242e81fdb520a7fff2170cb1277228
+OpenBLAS.v0.3.26+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/547a98e1757f61f572a414becc563466
+OpenBLAS.v0.3.26+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/7645415bfb9b7bc21f3008aea2a508d727c81dbcf016eea4a86dbdd7cf20af66739fc059b1de10bbfc6d08d1de56ca4e36f1aaa765ab4ee8a30bccfd1824c5bd
+OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/e809969126585f1c1ba64d13d881bb42
+OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/d8d32f1ca319c51a5c34984785790ea1dce1b87913ae7546341e31be49a4c682fddca4e075a3f66875a239952611675872e57a5ca1ca1c5e01320cc176d83ab4
+OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/b464e001789eb4fa2d4e380c0eea3917
+OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/b9b0eb0a58f2684deb2769513c9536091f53eebb7c9b9c9248a84e39c1b9b5d314c08bb95a490e66e94b3848ea29d989ec943b07535be4ad48692006ca688d9c
+OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/0918c6ebace3c81c27f49b5a43217731
+OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/3742bebaa120245aeda02da263a1369d1ff39453c6ba76dc831ce60b4c3334944c8d068a8bf22f9fcbfe634769e7769a4f1645c787496c2ca9335bad9cb914f2
+OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/d5b139d340e28436cb446a6157f64419
+OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/1e4bc19174c8481889eb3cca6380a11ee6013066198e268bc718440b3f5b017915a3f446a1d75c53c4230bace1569ba54e14366b6af47da9bf49e52f6efb631a
+OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/d106ae8404d19375caa0cf153f5c58e1
+OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/e06c765c2da299cbabd558546bd9d4e5f83b567c455ec59d59a3c53c7e36fca1ac51bbb87c59267e31c7b3028c406e1266c0f081232d04bb1b71aa7eba80cd31
+OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/e9ca37632176ede60159d6fb43ad7dfa
+OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/8c7e021a4f24e18bd770ad5e75b5e36ef936857915cfed61b34185a2324a5fbce71bca4905de77d455934f0ad22e10a8d81df30dd8d51cfd0e05e8e9325bde47
+OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/df45b3895e2effb12aeab4517721571e
+OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/e5be7b0e7f2733aa462c36057fcf728f8c87150a6ef856e2039e6a0811a6806ff3ee196febdb3173243b6be9a6da9c6d3a4c55592f19c9aa08dba94715bc3d4b
+OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/b10b159a1e41843bc6de576f42bfcf47
+OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0e831086f4a80d52f3ade88ab9760a4edf3c636e5ca729347f0a173c1f671c6c2cfc732d68e26fa21556257936b9827a7a4230aa222a825a354a2ad1d60e20b5
+OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/b6d08f360a9c5338ebd386fbc52f2064
+OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/2a75296e0216cad110c861139f44c724217116a5488993aae7e501832df2df0074f5cddf868ecadfffc7ba9237316899788b64e834fa93a5bd3672063eb67392
+OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/ea1476eb36613ec5885cc969f2d8face
+OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/10be657bd3f6d579b1b6eb979e42d871d77211bdd2338a8d9de9a2a54f5c6bde45d6a2fbeff1c7a1d965d8553cb248087d93b3745fb0af1fda5af2a8a2d65074
+OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/68017857ebd4fab5564763451b693dcf
+OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/9907e1a60f73b7184c2917713a286660fc9b500122cc546ad3849e65de7f36106d51d0fabb00f7168ff6f63bb7fdfc9898a155c017a37ec0e8faf7aeeef05108
+OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/5a642468819eba2d58d972214ce64039
+OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/b71e305f1e35a25502b1f7d277e59b6078f1f05be5eeb46819fab4f261d00f99a4df4f578fc65add20baa764511ecf4b2aac76a628eeae2e30cbe82577a92bf1
+OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/df45b3895e2effb12aeab4517721571e
+OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/e5be7b0e7f2733aa462c36057fcf728f8c87150a6ef856e2039e6a0811a6806ff3ee196febdb3173243b6be9a6da9c6d3a4c55592f19c9aa08dba94715bc3d4b
+OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/b10b159a1e41843bc6de576f42bfcf47
+OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0e831086f4a80d52f3ade88ab9760a4edf3c636e5ca729347f0a173c1f671c6c2cfc732d68e26fa21556257936b9827a7a4230aa222a825a354a2ad1d60e20b5
+OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/b6d08f360a9c5338ebd386fbc52f2064
+OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/2a75296e0216cad110c861139f44c724217116a5488993aae7e501832df2df0074f5cddf868ecadfffc7ba9237316899788b64e834fa93a5bd3672063eb67392
+OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/ea1476eb36613ec5885cc969f2d8face
+OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/10be657bd3f6d579b1b6eb979e42d871d77211bdd2338a8d9de9a2a54f5c6bde45d6a2fbeff1c7a1d965d8553cb248087d93b3745fb0af1fda5af2a8a2d65074
+OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/68017857ebd4fab5564763451b693dcf
+OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/9907e1a60f73b7184c2917713a286660fc9b500122cc546ad3849e65de7f36106d51d0fabb00f7168ff6f63bb7fdfc9898a155c017a37ec0e8faf7aeeef05108
+OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/5a642468819eba2d58d972214ce64039
+OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/b71e305f1e35a25502b1f7d277e59b6078f1f05be5eeb46819fab4f261d00f99a4df4f578fc65add20baa764511ecf4b2aac76a628eeae2e30cbe82577a92bf1
+OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran3.tar.gz/md5/686269fba3e296013ccb33d4befff265
+OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/b1894c97de594def1f0b37d4d702d56d9ddd6a2897a29bb33b1579c222a7d89409658efcc07c8aa9673ca95821e5ed1b97dd41d8bcf3b2edee065ea92761218f
+OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran4.tar.gz/md5/c36ad067917ac7a6e7d1399cb6f58525
+OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/782b8cbb7b7655b1cf22e6a9bd10aec38f6624525076c74b66804796b3879fd722182705ca6043e16b13fd2a9bef1a2354dfbc8ef12db65dc94aa6864733dce1
+OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran5.tar.gz/md5/ce6d94780c46b55d61faf650d2dfb8fb
+OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/79cb907f77da62c9a28e7d0c3a436eccc1106af7e9f16be7f33cf95324d8668740507fd78baf3f6dc3e6eb76ffad1eaac38268bcb132602b7b258e49668c30e5
+OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran3.tar.gz/md5/d795cd8b35e6d40975db704af83b4720
+OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran3.tar.gz/sha512/8fae3a4501b0ef0203c9b79c2b98b5372393d88e647fc7516532fa425998e6117e7d011ac3c28d41f0c52c9dcc06c2d2817490a275863d920fcab87f48c5886e
+OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran4.tar.gz/md5/7491d844661f1c54f0a57adab6f2bb5b
+OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran4.tar.gz/sha512/d541151270fc5c2d9562a366c48c0aa8b7383f00714fe5ea9cb94f321e13b988e4a5f9ef3e37b0ae924dd0a1049cca5c0ec16f7207b54074ee33e99991fcb35d
+OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran5.tar.gz/md5/59930511bc5e24942776a29587b3abc0
+OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran5.tar.gz/sha512/03cbd1cbfb1f4d2c2462c92fd99fe982b2f472daf4b213929d14142d03ba78e1e24173e0bcc6e0e9947df40902c24712f39f75afc4cbb4232658c3b157b821d3
+OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/2d9793dafd383243fd76cd64a12ebd27
+OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/ee13867467731bd88037d966fd8e085d1c875c6491d182ac3e75cfc8101e9003c3f1fb094b85b2f4d1cea7ac6bed5f38e27228991e098bce614aa1d08f45d634
+OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/cf1ac1fb180432fa3880412865eddfb3
+OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/d3751a5f0604d2cb2dbf4390ad5df916f0faa29b9195b44c9ea419e6052b923c7ad00361229ad576ff07c73ee6475dc9951d8c004e7071536f33960041e1520e
+OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/69e42e661f6f984f7b57e80c9288944b
+OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/a157ef1fe785477f94cf3dfe1b6dc6db0406887fc49e2031148c3ec09e1314f16116ca7be3b0e43487876899343c42d51797f19aa7d76f9ff07cfb8b706b4ff4
+OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/6da004043ff90a8497765210f5edac2a
+OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/bac7e378474769c7f2b4c8acbb960b29ee47f9f49aec95239543451583e83420990a4eb03dd994ebec7f60e95f6cc95668977cf4ad9414ecfedb93fe2d85e338
+OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/3bb442a6331324913d13bda804dabafb
+OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/5a865ea29ae2647e2639b614a5373a5675542cdcab380405f800dca1987b5628a302841e7546f89ad64a8cb87371c2e82dee603a8f732b6bc17e1f0635eda5f1
+OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/f9ed9d491ff44839d663d29ad17e062d
+OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/e365b28397ca0c98f996fda40ab5300046c80c6566a6f5897a9db6b46942eb925b405ad0029f39f77ab13b50ef39d94fd21c1510ddfae652a081277f827a9383
+OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/aada145cdbd5990a5191b5161e8caa57
+OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/e4146f26459d9264c45dd0ca0394ab264ec0154709aabe5cb4d821c341ed937a467ba7e0a82e4bfc0f5b9142921f21d2a732914d8aa94eece67cf29e8e0f3618
+OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/79d25889603731cd9b67bd90171f6785
+OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/ffbafdded8420891e403c42922c5189981b42cf9a1b0a229d7caf75b23afcb1bf0bad07bdeeb40f47db3f0226dc15cfb5e35dc1d7350d65bbfce8895dd1703ab
+OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/86090567892be1cbecd1e0aa3331ba47
+OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/a74c5d635477f39ff28ee83a3fe980a6c5dad9986a44388e8c1bccdbdcb371e9365570938bf47c20e64fa94fb118c8a09eaa468ac79d9362e9448bc5f717c9e9
+OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/f470ceb90d452684f1f8bab0430255f3
+OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/5b7a8f70173cf593d8340fa4dfe25d885b71ee28491cd88d29ae0d3e161ee97828e7373fdeb0fc4f3843b6d4b7ed1dd5f818cf4fbd85f1b965ade69496c0b032
+OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/21937c57336aeee6d1281838091f2ded
+OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/31ea2e95ea67bd068fbc5dec70ed37cbf675a38465612928da63ec727358eba140c407a4d24781eddb61e2a78c21aa5fcbd509e53d2f79133f20348f12a26c3b
+OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/ad6d27048e3258ff7e4612b019089a49
+OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/cc61af1e3b64d8476c3add782213324bf2dfe218c77a9f2ddb835d9294e00970a4c78140be4bb25480c155cde0ad860599b4e6fff89e52530782910d8f1524d6
+OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/a027d4b3cdf3d1696ff9fbcee92cd11c
+OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/2114cab81354e4ce1b7952da4c949d7bb936e6c03f7c74db64c19de564417c1ede8aa7392454d22a80846b624d98278c96c3892a7eade1dc7d2d6492cf995993
+OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/24c27c66ba984ce08e29c8db8e4f0623
+OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/9c64e74d4b2cecb67cb919a801572bda4709c7a7cff016637256689f3e25e15964c681e44df70e7e843dd51cc21c1418c63620c292ba85b2fefc996f2edf6ee2
+OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/be5610c6c7b0e2d434fddd48b6a990c8
+OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/cdf7302ded2deaf9f661d2fa2dacd68a77c20aa839577b4931a4c7e345548e83179a71ad8d3a8f497ee17e5f58903711fca60fd837c4060f3653a3d166ac7402
+OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/246fa31cdf14e93eb04c9fc4c96845a1
+OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/a1eff9bc326976fec67461e5391342fee74ef91c2d3d3b7bde387daf76f2c721d522fd3e78094218c5bfcfd02d1c96288d14c83668acccd92144960e4aea67d2
+OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/06b953ed17b40e8713cc5b3d6e1e825c
+OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/185705657be22c6681133d7fe05d9e890e87b1637d0194c7b39a2194cadbf3a55aa2e252696355fc399db4477e1aeff32062a0fcf2b45925e6f9c64d8f12ce4e
+OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/88d0ad25d8544880902f02bc7e030d33
+OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/126850a7c65413079694791c734c4bd4acacf4766986e60fbb230d95f57e06b685877dfde02a3c0b9d53bf24c58cbd31404142258935dc580d1c54798d08e782
+OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/9be5f51d9676a008483437079797f4c7
+OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/ac9c93541b246563994725573ebdc816b9341389b6f101160575ae25c3e01d3289146d86b54bcaf19f15b035afaf0346c50419601fd7f64a4cafe7754dda5afe
+OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/cbb1711388ee92693459e9de5275510f
+OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/4c0344c43a41f4042787999a1b9b1c8d897dfa42b1af2aaf2f58284efe835cc273cc99703d87212f1433b19764ace01955b89ee1c4e2c928a6025cb1d17b6464
+OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/574bee32c74429934e729ced4078589d
+OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/78e567cfaa808859134bdd829c34508e06dd4ae2719551ee77eac41b4712e0fa439126d08dcaed88c4584c9ff850f63b37debfb5ee53dc0c5606b45fa5df987b
+openblas-6c77e5e314474773a7749357b153caba4ec3817d.tar.gz/md5/4971eeb7adadee085d7c991db416fe7a
+openblas-6c77e5e314474773a7749357b153caba4ec3817d.tar.gz/sha512/7b85c9fb7be54407ba627d77897f40de4395d6d307230aa7df83cf8e0a41f545e4af4ae0576abb40cc9e0c385e1c6a488100dff292ea307439a89587c07ba66f
diff --git a/deps/openblas.version b/deps/openblas.version
index 7b16df95c9c7f..f62282b7ea8cc 100644
--- a/deps/openblas.version
+++ b/deps/openblas.version
@@ -3,9 +3,9 @@
 OPENBLAS_JLL_NAME := OpenBLAS
 
 ## source build
-OPENBLAS_VER := 0.3.25
-OPENBLAS_BRANCH=v0.3.25
-OPENBLAS_SHA1=5e1a429eab44731b6668b8f6043c1ea951b0a80b
+OPENBLAS_VER := 0.3.26
+OPENBLAS_BRANCH=v0.3.26
+OPENBLAS_SHA1=6c77e5e314474773a7749357b153caba4ec3817d
 
 # LAPACK, source-only
 LAPACK_VER := 3.9.0
diff --git a/stdlib/OpenBLAS_jll/Project.toml b/stdlib/OpenBLAS_jll/Project.toml
index 99a75366e24a7..1e3f5b8761701 100644
--- a/stdlib/OpenBLAS_jll/Project.toml
+++ b/stdlib/OpenBLAS_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "OpenBLAS_jll"
 uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
-version = "0.3.25+0"
+version = "0.3.26+0"
 
 [deps]
 # See note in `src/OpenBLAS_jll.jl` about this dependency.

From f18cc43cac2d9995775877fcc76a774dbb2ff626 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 6 Jan 2024 12:07:40 +0100
Subject: [PATCH 0550/1315] [doc] Fix format string of `printf` in `@ccall`
 example (#52770)

The format string of the `@ccall` example for `printf` had a `%d`
specifier but the argument passed was `"5"::Cstring`, which is also
inconsistent with the corresponding `ccall` example.
---
 doc/src/manual/calling-c-and-fortran-code.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/manual/calling-c-and-fortran-code.md b/doc/src/manual/calling-c-and-fortran-code.md
index 2602a8b129b2b..6f4d69b16bc81 100644
--- a/doc/src/manual/calling-c-and-fortran-code.md
+++ b/doc/src/manual/calling-c-and-fortran-code.md
@@ -999,7 +999,7 @@ A table of translations between the macro and function interfaces is given below
 | `@ccall "mylib".f(a::Cint, b::Cdouble)::Cvoid`                               | `ccall((:f, "mylib"), Cvoid, (Cint, Cdouble), (a, b))`                      |
 | `@ccall $fptr.f()::Cvoid`                                                    | `ccall(fptr, f, Cvoid, ())`                                                 |
 | `@ccall printf("%s = %d\n"::Cstring ; "foo"::Cstring, foo::Cint)::Cint`      | `<unavailable>`                                                             |
-| `@ccall printf("%s = %d\n"::Cstring ; "2 + 2"::Cstring, "5"::Cstring)::Cint` | `ccall(:printf, Cint, (Cstring, Cstring...), "%s = %s\n", "2 + 2", "5")`    |
+| `@ccall printf("%s = %s\n"::Cstring ; "2 + 2"::Cstring, "5"::Cstring)::Cint` | `ccall(:printf, Cint, (Cstring, Cstring...), "%s = %s\n", "2 + 2", "5")`    |
 | `<unavailable>`                                                              | `ccall(:gethostname, stdcall, Int32, (Ptr{UInt8}, UInt32), hn, length(hn))` |
 
 ## [Calling Convention](@id calling-convention)

From 11bb62b079aa95eac59deed4184be539563e15df Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Sat, 6 Jan 2024 12:43:09 +0100
Subject: [PATCH 0551/1315] Revert "Generalize `broadcast!(f, ::BitVector)`
 optimization to `BitArray`." (#52775)

This broke many packages on PkgEval.
---
 base/broadcast.jl | 69 +++++++++++++++++++++++++++--------------------
 test/broadcast.jl | 10 -------
 2 files changed, 40 insertions(+), 39 deletions(-)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index e653c4086e452..d6e5513889cee 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -974,42 +974,53 @@ preprocess(dest, x) = extrude(broadcast_unalias(dest, x))
     return dest
 end
 
-# Performance optimization: for BitArray outputs, we cache the result
+# Performance optimization: for BitVector outputs, we cache the result
 # in a 64-bit register before writing into memory (to bypass LSQ)
+@inline function copyto!(dest::BitVector, bc::Broadcasted{Nothing})
+    axes(dest) == axes(bc) || throwdm(axes(dest), axes(bc))
+    ischunkedbroadcast(dest, bc) && return chunkedcopyto!(dest, bc)
+    destc = dest.chunks
+    bcp = preprocess(dest, bc)
+    length(bcp) <= 0 && return dest
+    len = Base.num_bit_chunks(Int(length(bcp)))
+    @inbounds for i = 0:(len - 2)
+        z = UInt64(0)
+        for j = 0:63
+           z |= UInt64(bcp[i*64 + j + 1]::Bool) << (j & 63)
+        end
+        destc[i + 1] = z
+    end
+    @inbounds let i = len - 1
+        z = UInt64(0)
+        for j = 0:((length(bcp) - 1) & 63)
+             z |= UInt64(bcp[i*64 + j + 1]::Bool) << (j & 63)
+        end
+        destc[i + 1] = z
+    end
+    return dest
+end
+
+# Performance optimization: for BitArray outputs, we cache the result
+# in a "small" Vector{Bool}, and then copy in chunks into the output
 @inline function copyto!(dest::BitArray, bc::Broadcasted{Nothing})
     axes(dest) == axes(bc) || throwdm(axes(dest), axes(bc))
     ischunkedbroadcast(dest, bc) && return chunkedcopyto!(dest, bc)
-    ndims(dest) == 0 && (dest[] = bc[]; return dest)
+    length(dest) < 256 && return invoke(copyto!, Tuple{AbstractArray, Broadcasted{Nothing}}, dest, bc)
+    tmp = Vector{Bool}(undef, bitcache_size)
+    destc = dest.chunks
+    cind = 1
     bc′ = preprocess(dest, bc)
-    ax = axes(bc′)
-    ax1, out = ax[1], CartesianIndices(tail(ax))
-    destc, indc = dest.chunks, 0
-    bitst, remain = 0, UInt64(0)
-    for I in out
-        i = first(ax1) - 1
-        if ndims(bc) == 1 || bitst >= 64 - length(ax1)
-            if ndims(bc) > 1 && bitst != 0
-                @inbounds @simd for j = bitst:63
-                    remain |= UInt64(convert(Bool, bc′[i+=1, I])) << (j & 63)
-                end
-                @inbounds destc[indc+=1] = remain
-                bitst, remain = 0, UInt64(0)
-            end
-            while i <= last(ax1) - 64
-                z = UInt64(0)
-                @inbounds @simd for j = 0:63
-                    z |= UInt64(convert(Bool, bc′[i+=1, I])) << (j & 63)
-                end
-                @inbounds destc[indc+=1] = z
-            end
+    @inbounds for P in Iterators.partition(eachindex(bc′), bitcache_size)
+        ind = 1
+        @simd for I in P
+            tmp[ind] = bc′[I]
+            ind += 1
         end
-        @inbounds @simd for j = i+1:last(ax1)
-            remain |= UInt64(convert(Bool, bc′[j, I])) << (bitst & 63)
-            bitst += 1
+        @simd for i in ind:bitcache_size
+            tmp[i] = false
         end
-    end
-    @inbounds if bitst != 0
-        destc[indc+=1] = remain
+        dumpbitcache(destc, cind, tmp)
+        cind += bitcache_chunks
     end
     return dest
 end
diff --git a/test/broadcast.jl b/test/broadcast.jl
index ff0fc1401a703..0a111f9523d60 100644
--- a/test/broadcast.jl
+++ b/test/broadcast.jl
@@ -592,16 +592,6 @@ end
     end
 end
 
-@testset "convert behavior of logical broadcast" begin
-    a = mod.(1:4, 2)
-    @test !isa(a, BitArray)
-    for T in (Array{Bool}, BitArray)
-        la = T(a)
-        la .= mod.(0:3, 2)
-        @test la == [false; true; false; true]
-    end
-end
-
 # Test that broadcast treats type arguments as scalars, i.e. containertype yields Any,
 # even for subtypes of abstract array. (https://github.com/JuliaStats/DataArrays.jl/issues/229)
 @testset "treat type arguments as scalars, DataArrays issue 229" begin

From ae6af5209edbcfad81a72df7153edff806e2b58f Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sat, 6 Jan 2024 19:49:47 +0800
Subject: [PATCH 0552/1315] Revert "Revert "Generalize `broadcast!(f,
 ::BitVector)` optimization to `BitArray`." (#52775)"

This reverts commit 11bb62b079aa95eac59deed4184be539563e15df.
---
 base/broadcast.jl | 69 ++++++++++++++++++++---------------------------
 test/broadcast.jl | 10 +++++++
 2 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index d6e5513889cee..e653c4086e452 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -974,53 +974,42 @@ preprocess(dest, x) = extrude(broadcast_unalias(dest, x))
     return dest
 end
 
-# Performance optimization: for BitVector outputs, we cache the result
-# in a 64-bit register before writing into memory (to bypass LSQ)
-@inline function copyto!(dest::BitVector, bc::Broadcasted{Nothing})
-    axes(dest) == axes(bc) || throwdm(axes(dest), axes(bc))
-    ischunkedbroadcast(dest, bc) && return chunkedcopyto!(dest, bc)
-    destc = dest.chunks
-    bcp = preprocess(dest, bc)
-    length(bcp) <= 0 && return dest
-    len = Base.num_bit_chunks(Int(length(bcp)))
-    @inbounds for i = 0:(len - 2)
-        z = UInt64(0)
-        for j = 0:63
-           z |= UInt64(bcp[i*64 + j + 1]::Bool) << (j & 63)
-        end
-        destc[i + 1] = z
-    end
-    @inbounds let i = len - 1
-        z = UInt64(0)
-        for j = 0:((length(bcp) - 1) & 63)
-             z |= UInt64(bcp[i*64 + j + 1]::Bool) << (j & 63)
-        end
-        destc[i + 1] = z
-    end
-    return dest
-end
-
 # Performance optimization: for BitArray outputs, we cache the result
-# in a "small" Vector{Bool}, and then copy in chunks into the output
+# in a 64-bit register before writing into memory (to bypass LSQ)
 @inline function copyto!(dest::BitArray, bc::Broadcasted{Nothing})
     axes(dest) == axes(bc) || throwdm(axes(dest), axes(bc))
     ischunkedbroadcast(dest, bc) && return chunkedcopyto!(dest, bc)
-    length(dest) < 256 && return invoke(copyto!, Tuple{AbstractArray, Broadcasted{Nothing}}, dest, bc)
-    tmp = Vector{Bool}(undef, bitcache_size)
-    destc = dest.chunks
-    cind = 1
+    ndims(dest) == 0 && (dest[] = bc[]; return dest)
     bc′ = preprocess(dest, bc)
-    @inbounds for P in Iterators.partition(eachindex(bc′), bitcache_size)
-        ind = 1
-        @simd for I in P
-            tmp[ind] = bc′[I]
-            ind += 1
+    ax = axes(bc′)
+    ax1, out = ax[1], CartesianIndices(tail(ax))
+    destc, indc = dest.chunks, 0
+    bitst, remain = 0, UInt64(0)
+    for I in out
+        i = first(ax1) - 1
+        if ndims(bc) == 1 || bitst >= 64 - length(ax1)
+            if ndims(bc) > 1 && bitst != 0
+                @inbounds @simd for j = bitst:63
+                    remain |= UInt64(convert(Bool, bc′[i+=1, I])) << (j & 63)
+                end
+                @inbounds destc[indc+=1] = remain
+                bitst, remain = 0, UInt64(0)
+            end
+            while i <= last(ax1) - 64
+                z = UInt64(0)
+                @inbounds @simd for j = 0:63
+                    z |= UInt64(convert(Bool, bc′[i+=1, I])) << (j & 63)
+                end
+                @inbounds destc[indc+=1] = z
+            end
         end
-        @simd for i in ind:bitcache_size
-            tmp[i] = false
+        @inbounds @simd for j = i+1:last(ax1)
+            remain |= UInt64(convert(Bool, bc′[j, I])) << (bitst & 63)
+            bitst += 1
         end
-        dumpbitcache(destc, cind, tmp)
-        cind += bitcache_chunks
+    end
+    @inbounds if bitst != 0
+        destc[indc+=1] = remain
     end
     return dest
 end
diff --git a/test/broadcast.jl b/test/broadcast.jl
index 0a111f9523d60..ff0fc1401a703 100644
--- a/test/broadcast.jl
+++ b/test/broadcast.jl
@@ -592,6 +592,16 @@ end
     end
 end
 
+@testset "convert behavior of logical broadcast" begin
+    a = mod.(1:4, 2)
+    @test !isa(a, BitArray)
+    for T in (Array{Bool}, BitArray)
+        la = T(a)
+        la .= mod.(0:3, 2)
+        @test la == [false; true; false; true]
+    end
+end
+
 # Test that broadcast treats type arguments as scalars, i.e. containertype yields Any,
 # even for subtypes of abstract array. (https://github.com/JuliaStats/DataArrays.jl/issues/229)
 @testset "treat type arguments as scalars, DataArrays issue 229" begin

From 424998ba610db4329541232f84bf9a83c21199e9 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Sat, 6 Jan 2024 18:20:30 +0530
Subject: [PATCH 0553/1315] Added Docstring for Base.sys
 :CPU_NAME,JIT,cpu_info,cpu_summary

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl      | 49 +++++++++++++++++++++++++++++++++++++++++++-
 doc/src/base/base.md |  4 ++++
 2 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 53835366d3171..df32fddcdb8c5 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -98,7 +98,19 @@ Standard word size on the current machine, in bits.
 """
 const WORD_SIZE = Core.sizeof(Int) * 8
 
-global SC_CLK_TCK::Clong, CPU_NAME::String, JIT::String
+global SC_CLK_TCK::Clong
+"""
+    Sys.CPU_NAME::String
+
+A string representing the name of CPU.
+"""
+global CPU_NAME::String
+"""
+    Sys.JIT::String
+
+A string representing the specific Just-In-Time (JIT) compiler being utilized in the current runtime.
+"""
+global JIT::String
 
 function __init__()
     env_threads = nothing
@@ -201,6 +213,20 @@ function _cpu_summary(io::IO, cpu::AbstractVector{CPUinfo}, i, j)
     println(io)
 end
 
+"""
+    Sys.cpu_summary()
+
+Prints a summary of CPU information, organizing and displaying aggregated data for CPUs with the same model.
+
+# Arguments
+- `io::IO`: Output stream where the summary will be printed (default is `stdout`).
+- `cpu::AbstractVector{CPUinfo}`: Vector of `CPUinfo` objects containing detailed information about each CPU (default is obtained from `cpu_info()`).
+
+# Output
+The summary includes aggregated information for each distinct CPU model,
+providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.
+
+"""
 function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())
     model = cpu[1].model
     first = 1
@@ -213,6 +239,27 @@ function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())
     _cpu_summary(io, cpu, first, length(cpu))
 end
 
+"""
+    Sys.cpu_info()
+
+Retrieves detailed information about the CPUs on the current system.
+
+The function provides information about each CPU, including model, speed, and usage statistics such as user time, nice time, system time, idle time, and interrupt time.
+
+# Returns
+- A vector of `CPUinfo` objects, where each object represents information about a CPU core.
+
+# CPUinfo Type
+The `CPUinfo` type is a mutable struct with the following fields:
+- `model::String`: CPU model information.
+- `speed::Int32`: CPU speed.
+- `cpu_times!user::UInt64`: Time spent in user mode. CPU state shows CPU time used by user space processes.
+- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks. 
+- `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel.
+- `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used.
+- `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts.
+
+"""
 function cpu_info()
     UVcpus = Ref{Ptr{UV_cpu_info_t}}()
     count = Ref{Int32}()
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 7172474b40b39..f91863a3b56d4 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -355,6 +355,10 @@ Base.@allocations
 Base.EnvDict
 Base.ENV
 Base.Sys.STDLIB
+Base.Sys.CPU_NAME
+Base.Sys.JIT
+Base.Sys.cpu_info
+Base.Sys.cpu_summary
 Base.Sys.isunix
 Base.Sys.isapple
 Base.Sys.islinux

From 7fa495651f44a6483b170551afa262a3b87fa7bd Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Sat, 6 Jan 2024 18:29:44 +0530
Subject: [PATCH 0554/1315] Removed Whitespace

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index df32fddcdb8c5..2fd2a73a59271 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -212,7 +212,6 @@ function _cpu_summary(io::IO, cpu::AbstractVector{CPUinfo}, i, j)
     end
     println(io)
 end
-
 """
     Sys.cpu_summary()
 
@@ -225,7 +224,6 @@ Prints a summary of CPU information, organizing and displaying aggregated data f
 # Output
 The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.
-
 """
 function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())
     model = cpu[1].model
@@ -238,7 +236,6 @@ function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())
     end
     _cpu_summary(io, cpu, first, length(cpu))
 end
-
 """
     Sys.cpu_info()
 
@@ -258,7 +255,6 @@ The `CPUinfo` type is a mutable struct with the following fields:
 - `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel.
 - `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used.
 - `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts.
-
 """
 function cpu_info()
     UVcpus = Ref{Ptr{UV_cpu_info_t}}()

From c5dcf4f56d9e51ca0a83f5e320377d28e4d4b11a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 6 Jan 2024 15:12:24 +0100
Subject: [PATCH 0555/1315] [SuiteSparse_jll] Update to v7.4.0 (#52577)

Usual memo to self for the update:

* change version number in `stdlib/SuiteSparse_jll/Project.toml`
* refresh checksums in `deps/checksums/suitesparse` with `make -f
contrib/refresh_checksums.mk -j libsuitesparse`. Note: this will also
delete the files `deps/checksums/SuiteSparse-*.tar.gz/*`, but those
refer to the stdlib which is the julia wrapper around the binary
dependency, those files have to be restored manually, I don't know how
to make the makefile behave nicely. You will also have to remove the
lines `SuiteSparse-*.tar.gz/md5/*` added to the file
`deps/checksums/suitesparse`, they are wrong for the same reason
* update version numbers in `deps/libsuitesparse.version`.

Judging by the changes in
https://github.com/JuliaPackaging/Yggdrasil/pull/7596 we don't need to
touch the manual build system.

I have no idea whether SuiteSparse retains API/ABI compatibility within
the same major version, I surely hope so because I won't have the
strength to try and fix large compatibility errors.
---
 Makefile                                      |  2 +-
 base/Makefile                                 |  2 -
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 deps/checksums/suitesparse                    | 66 +++++++++----------
 deps/libsuitesparse.mk                        | 50 +++++++-------
 deps/libsuitesparse.version                   |  6 +-
 deps/patches/suitesparse-blas-suffix.patch    | 40 +++++++++++
 stdlib/SparseArrays.version                   |  2 +-
 stdlib/SuiteSparse_jll/Project.toml           |  4 +-
 stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl |  4 +-
 13 files changed, 112 insertions(+), 68 deletions(-)
 create mode 100644 deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/sha512
 delete mode 100644 deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/sha512
 create mode 100644 deps/patches/suitesparse-blas-suffix.patch

diff --git a/Makefile b/Makefile
index 056436af89fe3..89fe35b470094 100644
--- a/Makefile
+++ b/Makefile
@@ -203,7 +203,7 @@ else ifeq ($(JULIA_BUILD_MODE),debug)
 JL_PRIVATE_LIBS-0 += libjulia-internal-debug libjulia-codegen-debug
 endif
 ifeq ($(USE_GPL_LIBS), 1)
-JL_PRIVATE_LIBS-$(USE_SYSTEM_LIBSUITESPARSE) += libamd libbtf libcamd libccolamd libcholmod libcholmod_cuda libcolamd libklu libldl librbio libspqr libspqr_cuda libsuitesparseconfig libumfpack
+JL_PRIVATE_LIBS-$(USE_SYSTEM_LIBSUITESPARSE) += libamd libbtf libcamd libccolamd libcholmod libcolamd libklu libldl librbio libspqr libsuitesparseconfig libumfpack
 endif
 JL_PRIVATE_LIBS-$(USE_SYSTEM_LIBBLASTRAMPOLINE) += libblastrampoline
 JL_PRIVATE_LIBS-$(USE_SYSTEM_PCRE) += libpcre2-8
diff --git a/base/Makefile b/base/Makefile
index ad2bb6a63ccc0..493302af78b02 100644
--- a/base/Makefile
+++ b/base/Makefile
@@ -269,11 +269,9 @@ $(eval $(call symlink_system_library,LIBSUITESPARSE,libamd))
 $(eval $(call symlink_system_library,LIBSUITESPARSE,libcamd))
 $(eval $(call symlink_system_library,LIBSUITESPARSE,libccolamd))
 $(eval $(call symlink_system_library,LIBSUITESPARSE,libcholmod))
-$(eval $(call symlink_system_library,LIBSUITESPARSE,libcholmod_cuda))
 $(eval $(call symlink_system_library,LIBSUITESPARSE,libcolamd))
 $(eval $(call symlink_system_library,LIBSUITESPARSE,libumfpack))
 $(eval $(call symlink_system_library,LIBSUITESPARSE,libspqr))
-$(eval $(call symlink_system_library,LIBSUITESPARSE,libspqr_cuda))
 $(eval $(call symlink_system_library,LIBSUITESPARSE,libsuitesparseconfig))
 # EXCLUDED LIBRARIES (installed/used, but not vendored for use with dlopen):
 # libunwind
diff --git a/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/md5 b/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/md5
new file mode 100644
index 0000000000000..7ef02b53c633b
--- /dev/null
+++ b/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/md5
@@ -0,0 +1 @@
+bfb7951c370c7cb5dac9139d2b5720ea
diff --git a/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/sha512 b/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/sha512
new file mode 100644
index 0000000000000..d458020f2b49b
--- /dev/null
+++ b/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/sha512
@@ -0,0 +1 @@
+1228277f51d48f6405ff9f31de6732bce020c2c06b2c768f88e6ff1226a6122fa9f63877228112d8067e0373d370ee26a7404d11948c28c06d4ee951d35407ff
diff --git a/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/md5 b/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/md5
deleted file mode 100644
index c0aec7507b021..0000000000000
--- a/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-939db38382d3e3796f3d83c4a965ab4c
diff --git a/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/sha512 b/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/sha512
deleted file mode 100644
index 8e9e0f6158041..0000000000000
--- a/deps/checksums/SparseArrays-feb54ee5e49008bd157227099cafe604a67c36fb.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-0c20dd814068df0fafaaba05029997b6420812ac3498df7484b8f77ccbcbbc3447e4b4ce6acbed7ab0b8293275d9c3f944bfa7ce5a8069a985b28d002a038005
diff --git a/deps/checksums/suitesparse b/deps/checksums/suitesparse
index 7578826fe3f0e..c55c22b37ab55 100644
--- a/deps/checksums/suitesparse
+++ b/deps/checksums/suitesparse
@@ -1,34 +1,32 @@
-SuiteSparse-7.2.1.tar.gz/md5/c341b4b2943b6d99ec147dc36ae64d51
-SuiteSparse-7.2.1.tar.gz/sha512/6385b699d2f109e8473bb58e95705671b8a5c2f1b281d17bba9f396a94b2e783700c4c64f4ab9495a4a64e23ba279052616054045783b4b8c8eb28a8f4f6be28
-SuiteSparse.v7.2.1+1.aarch64-apple-darwin.tar.gz/md5/1bd9c850b5bb6de56f4dfd0633ce7a6c
-SuiteSparse.v7.2.1+1.aarch64-apple-darwin.tar.gz/sha512/f0e932fa2b6d2843fd75c1e151b8304ed2521b679c732301877495d9a2437ec693ba0ebaaf52cb3a4f5c01bcd8c972a27b1080071c9c77462901fa4dec7de787
-SuiteSparse.v7.2.1+1.aarch64-linux-gnu.tar.gz/md5/ff52a5ef6546bbea2ce2d73db2821522
-SuiteSparse.v7.2.1+1.aarch64-linux-gnu.tar.gz/sha512/f5c2a54e40b36fc0489140397e6324bbd1050a87949fd9be3837012825c3becbef66258d28c286d0c45b0447361b2ddf736370402ed928b909e0fb7c5f4ee69c
-SuiteSparse.v7.2.1+1.aarch64-linux-musl.tar.gz/md5/2baa4103f4070f66d6278fc001317372
-SuiteSparse.v7.2.1+1.aarch64-linux-musl.tar.gz/sha512/17bc9b020850d9cc652d49987c3faa57204ed3beecd04ea812fd03b4f60f541ba7b250fa70c801a8ec3c440f3562a4771a3742299f0d4eb770e58010c43a3823
-SuiteSparse.v7.2.1+1.armv6l-linux-gnueabihf.tar.gz/md5/cdc1c60e50f6551a52e57ac71440564a
-SuiteSparse.v7.2.1+1.armv6l-linux-gnueabihf.tar.gz/sha512/9209f86ac97c061755169412565055847be4890140a389a92468297507cee240219d910bbcef94c52926771a4152762cfa05cfa33c26d31351d68265e5719bd3
-SuiteSparse.v7.2.1+1.armv6l-linux-musleabihf.tar.gz/md5/cd5e177e660d793426e4c4aeb2f9269c
-SuiteSparse.v7.2.1+1.armv6l-linux-musleabihf.tar.gz/sha512/a8a5ca739999a16336b2c98ec88873e00349720b5d966d643d5665338b1f9c8077352d87fac41a165cb65793ae5fb686e954b3eaa3f751aa8d002388a0ce6a13
-SuiteSparse.v7.2.1+1.armv7l-linux-gnueabihf.tar.gz/md5/eb43136009b370e93c6ab4c1b0eec40c
-SuiteSparse.v7.2.1+1.armv7l-linux-gnueabihf.tar.gz/sha512/e20a308911a36037c9b6da3c060f8624b1ff84b0e23cbd62189f62e989f6a5307b07a6286d95459e0886a8d16fd59ad5a34607dd2c644f7bedc786dd6567670c
-SuiteSparse.v7.2.1+1.armv7l-linux-musleabihf.tar.gz/md5/19f9246fc6c8bd2c7a4d2df498725abe
-SuiteSparse.v7.2.1+1.armv7l-linux-musleabihf.tar.gz/sha512/d2cba310fe33ddb11d9ada37ce04905dfc3f058a1cbf7b53ca1dc31c2c51bcf930a4976c39d55bfdacb19195ff772acb1c6876238640a6ed6277777934a8b53f
-SuiteSparse.v7.2.1+1.i686-linux-gnu.tar.gz/md5/8ff91e530528c8761411b8d9be56d1f0
-SuiteSparse.v7.2.1+1.i686-linux-gnu.tar.gz/sha512/42bd937fb1c476164b923b5093d3df3fc3cdd4e3bc148616ba48027d4616479d674a4c8f7291cf7004a43834508b459630f4cafbd90850d10402d53faa34e714
-SuiteSparse.v7.2.1+1.i686-linux-musl.tar.gz/md5/49bc8f22a227748680734d89f64a4cf7
-SuiteSparse.v7.2.1+1.i686-linux-musl.tar.gz/sha512/b78b84d330a8f22e7d9fdd72fe621e9830c1afd908946d4101705f05546aa892b2f5ef87988dec39ccd81cbe4dbeb95adc277d096d60e106485c5b6f81cf4403
-SuiteSparse.v7.2.1+1.i686-w64-mingw32.tar.gz/md5/cd593a3c801ba72bf6d77788c7ca06b9
-SuiteSparse.v7.2.1+1.i686-w64-mingw32.tar.gz/sha512/0b49795ed5cb773a5930d305e65d53ff35ff1d1ee0a84e8762f56ca442c2421752b50b667646fd6a977c0684c2214996011f405ff1c7fd6eeaf16d08262d7d05
-SuiteSparse.v7.2.1+1.powerpc64le-linux-gnu.tar.gz/md5/3858c87b8f62844520ff61c72d7b5a25
-SuiteSparse.v7.2.1+1.powerpc64le-linux-gnu.tar.gz/sha512/ea505fe14155ee69a715339fe7075603c04458d5c7f65fecb92bea69a86117b1d21da75dab832ac0f6cc9aa64bfa6d7f50cb679fefa9ec5b4d4d8826d3137ff9
-SuiteSparse.v7.2.1+1.x86_64-apple-darwin.tar.gz/md5/241dec5338e04fbf6084cec90bbd2f76
-SuiteSparse.v7.2.1+1.x86_64-apple-darwin.tar.gz/sha512/8477d2102be709aa2f74325df91aab4f9c894c8f516cd17d3780aab66bcbf920fa5771fa7e130a63793f94b99c6cfc4db6ab22e6a33a55670e25e36472770d59
-SuiteSparse.v7.2.1+1.x86_64-linux-gnu.tar.gz/md5/c6b6fa99a21a9000892d51b821f304a7
-SuiteSparse.v7.2.1+1.x86_64-linux-gnu.tar.gz/sha512/ad2e1200d0418c531758672b64e849c81cfe74ca73cff0e1a47797e73dbc4675c9a2ec855af628dddef58b135412d06fa18c15565c94de5e1e6d15e3b150ecbd
-SuiteSparse.v7.2.1+1.x86_64-linux-musl.tar.gz/md5/6c14129471a9c92464d36ae00f4c5a08
-SuiteSparse.v7.2.1+1.x86_64-linux-musl.tar.gz/sha512/e9051ceb7d551019deb16480b493d1ac5b622fe86c7e19b1023eb12af28d42f25e911e1e44870c35849d8f95d78e8e28c38699cde1fab250dac32818ebc58a2b
-SuiteSparse.v7.2.1+1.x86_64-unknown-freebsd.tar.gz/md5/ab0f6a9b7789f21aba5ea10659b03ed3
-SuiteSparse.v7.2.1+1.x86_64-unknown-freebsd.tar.gz/sha512/cc9136bfda474914107e68f97a200d46f81a1f36ea51c4e482ef04e818d3ac10d14b2895eef59b2570f6115261e987bd076dd8f9be0e6d2dc77931d3257db142
-SuiteSparse.v7.2.1+1.x86_64-w64-mingw32.tar.gz/md5/e804d9ed593d739326865dc1f60d5800
-SuiteSparse.v7.2.1+1.x86_64-w64-mingw32.tar.gz/sha512/20c9ac62cd41b19e0b9605c8f9a8bece9089f7f69e2cf57ace3058215acefe8cf9ce39d3c05010223443bfc45b1efb8391be677a1b5e9a59bbdfe89f89553f71
+SuiteSparse.v7.4.0+2.aarch64-apple-darwin.tar.gz/md5/6f38a9c86969ad3fa2708c461bcd3b2b
+SuiteSparse.v7.4.0+2.aarch64-apple-darwin.tar.gz/sha512/fa15f40456a6bda38f76caa4aedebe30c3bb3e8cf240c0eb2740169d0e7bf2563d6d1ca84233beec99f222852a49d3394b545c7349eb9573bda9bc60d20e348b
+SuiteSparse.v7.4.0+2.aarch64-linux-gnu.tar.gz/md5/8cac9d510a4c3c6e6a9b0f69fe1e0270
+SuiteSparse.v7.4.0+2.aarch64-linux-gnu.tar.gz/sha512/5590ae9e295bf34de4c19fe166aa6f79579ba74e5ccd9dbc0fc7cd3ae83329dc98c9a97eb80e92bcee04da1ae08697c687ef227d10034927c007f3a6072c0068
+SuiteSparse.v7.4.0+2.aarch64-linux-musl.tar.gz/md5/a74d064ab69db273f81a340f1096bfb7
+SuiteSparse.v7.4.0+2.aarch64-linux-musl.tar.gz/sha512/5d3b113560cb2c92c40a65edfb2f248fcc83d446eee4c8d03dbdbfecebe52b26afc662996d01d023880cd701386c293871331fc5cbf5901a1f97e5b99c68f291
+SuiteSparse.v7.4.0+2.armv6l-linux-gnueabihf.tar.gz/md5/8188603ec5c7fa4c2b2f14d11f856ffa
+SuiteSparse.v7.4.0+2.armv6l-linux-gnueabihf.tar.gz/sha512/0b5dfdce559e526c17700e2158eed8697a9bcb6d6cf95d5b1685b40da0c5668c9ee2ad49ad3e483cfbb174386907b1b74beff2723397556908898fb3b7fa9135
+SuiteSparse.v7.4.0+2.armv6l-linux-musleabihf.tar.gz/md5/76e751060e520db03f2139d9bf4e4eb1
+SuiteSparse.v7.4.0+2.armv6l-linux-musleabihf.tar.gz/sha512/f43991680d401f69dde2aab623615d3ed49435ff6591fc8a9352c98fe1d83cc4dc5ad3709afbb6dd712db0c177da0db9fb8b0cdf999a7812516e23735b0d68b4
+SuiteSparse.v7.4.0+2.armv7l-linux-gnueabihf.tar.gz/md5/277be7e8b7b6c03c0b932a98cf50e5f1
+SuiteSparse.v7.4.0+2.armv7l-linux-gnueabihf.tar.gz/sha512/fa813d4c554b6c6f4c383317ac6e2966a8cd34e8039212eb28d90da4595390cfbaecf920a843a14c50d1b6ffc9b35d0b4eb15521c887f1ec1ceae4a7a2b44e9f
+SuiteSparse.v7.4.0+2.armv7l-linux-musleabihf.tar.gz/md5/e4deba38ec452076d6a1e1ce092de2b6
+SuiteSparse.v7.4.0+2.armv7l-linux-musleabihf.tar.gz/sha512/2dc72a55be4893f4c778f686e3817c58259f81d68e76dc488f039f4e44bbb1de2133547526cb3c545d50a5a9b5646f07485e1bee8bfcfe9a42cc8b4583d15324
+SuiteSparse.v7.4.0+2.i686-linux-gnu.tar.gz/md5/f263960cd809722b1c4f6d15a72eb1ab
+SuiteSparse.v7.4.0+2.i686-linux-gnu.tar.gz/sha512/2c487b48041804273cd5ff5ca9ae90edda0fbe41c9095a9a9dfad19899e83e3f8aa9d601bdcf580cf3259d731af3936b6bceacadcda3f93e2c550bdd1cc4e684
+SuiteSparse.v7.4.0+2.i686-linux-musl.tar.gz/md5/e172f720f04edcf408792df2d3b89572
+SuiteSparse.v7.4.0+2.i686-linux-musl.tar.gz/sha512/d544f711ab88c3fc121d431f7313903ec102a474c54a2580706b73b3b0c5c0f1000fc7cc9658824abc5c912124a44ba56711257dd2ff9117a7fb57e1df4fd618
+SuiteSparse.v7.4.0+2.i686-w64-mingw32.tar.gz/md5/72870e8e03725c022f73e2f0e6f10c8b
+SuiteSparse.v7.4.0+2.i686-w64-mingw32.tar.gz/sha512/17a2b530cc0e3c9397a382ee8550f6bdc6d74b1f678cc27fa45d921e8a6ee72de2ba29e18d33f6950c3944b1c9b26f86def0c45bcb81864e10f57f27f75d55ab
+SuiteSparse.v7.4.0+2.powerpc64le-linux-gnu.tar.gz/md5/e43022f51daa1c98c45b3af3b4933dfe
+SuiteSparse.v7.4.0+2.powerpc64le-linux-gnu.tar.gz/sha512/7cd79f842a90187ff69085964a84fb6531360f4c9fdfdef6e5958f0823aa1c2a00815b4bc04406eca824294adfbe0bce2352d3fb51d0b155e8a559e99fc98f11
+SuiteSparse.v7.4.0+2.x86_64-apple-darwin.tar.gz/md5/be0a2768aa0b61e9f02ccc774a457d24
+SuiteSparse.v7.4.0+2.x86_64-apple-darwin.tar.gz/sha512/bc71f1b93bc9988e251116f46659b1c6eef8098c0bbd41b470102bd25264d1e6ae3e4f7dc452ba6673650f3b1c2d49ba312b67722e89444cd5e113892db4f09f
+SuiteSparse.v7.4.0+2.x86_64-linux-gnu.tar.gz/md5/45a30119c300e16176d06fecf8415931
+SuiteSparse.v7.4.0+2.x86_64-linux-gnu.tar.gz/sha512/16650e560f1ceb779ef2a45053bfbe41e1ecc7d21213a64ddee3e26ec77210ed97b89b0b84c92edf807c1159f329d7f374234286af4d4b9f81458b55ab54ae39
+SuiteSparse.v7.4.0+2.x86_64-linux-musl.tar.gz/md5/6a4dd22176697ec1f1586da6421c626a
+SuiteSparse.v7.4.0+2.x86_64-linux-musl.tar.gz/sha512/d223763e4c59a41a556f3dab11071672fa11f970f606a51eabb6a6b9e31fbd5a3dc35ffe891edfea0bdef8e70f0293c30831b2982c287b573cfcdaff7a050fd0
+SuiteSparse.v7.4.0+2.x86_64-unknown-freebsd.tar.gz/md5/c358b60fa7e8ba9ece545e6d7e41b343
+SuiteSparse.v7.4.0+2.x86_64-unknown-freebsd.tar.gz/sha512/2b93a8c10828eab5948a73b6b800fb321f715468a17142fabd9477543d0312d24fd567fb9fa96372304519ceda2830b259f1da30f943bc9cfa85047e640cf8f7
+SuiteSparse.v7.4.0+2.x86_64-w64-mingw32.tar.gz/md5/924a1a85d178617480178602a2fa2828
+SuiteSparse.v7.4.0+2.x86_64-w64-mingw32.tar.gz/sha512/9e753fffe9a50a3cfd520263b90194555d5f5c9f685b0aaa66ab513b3e0a5529d0efc701650955bf9cf659c930af5357c131591dbd2e02c9e7b4fa03f86a3548
diff --git a/deps/libsuitesparse.mk b/deps/libsuitesparse.mk
index fa1eda94b5c4f..386194221b43c 100644
--- a/deps/libsuitesparse.mk
+++ b/deps/libsuitesparse.mk
@@ -3,26 +3,28 @@ include $(SRCDIR)/libsuitesparse.version
 
 ifneq ($(USE_BINARYBUILDER_LIBSUITESPARSE), 1)
 
-LIBSUITESPARSE_PROJECTS := AMD BTF CAMD CCOLAMD COLAMD CHOLMOD LDL KLU UMFPACK RBio SPQR
-LIBSUITESPARSE_LIBS := $(addsuffix .*$(SHLIB_EXT)*,suitesparseconfig amd btf camd ccolamd colamd cholmod klu ldl umfpack rbio spqr)
+LIBSUITESPARSE_PROJECTS := "amd;btf;camd;ccolamd;colamd;cholmod;klu;ldl;umfpack;rbio;spqr"
+LIBSUITESPARSE_LIBS := $(addsuffix .*$(SHLIB_EXT)*,suitesparseconfig $(subst ;, ,$(LIBSUITESPARSE_PROJECTS)))
 
 LIBSUITESPARSE_CMAKE_FLAGS := $(CMAKE_COMMON) \
 	  -DCMAKE_BUILD_TYPE=Release \
-	  -DENABLE_CUDA=0 \
-	  -DNFORTRAN=1 \
-	  -DNOPENMP=1 \
-	  -DNPARTITION=0 \
-	  -DNSTATIC=1 \
+	  -DBUILD_STATIC_LIBS=OFF \
+	  -DBUILD_TESTING=OFF \
+	  -DSUITESPARSE_ENABLE_PROJECTS="suitesparse_config;$(LIBSUITESPARSE_PROJECTS)" \
+	  -DSUITESPARSE_DEMOS=OFF \
+	  -DSUITESPARSE_USE_STRICT=ON \
+	  -DSUITESPARSE_USE_CUDA=OFF \
+	  -DSUITESPARSE_USE_FORTRAN=OFF \
+	  -DSUITESPARSE_USE_OPENMP=OFF \
+	  -DCHOLMOD_PARTITION=ON \
 	  -DBLAS_FOUND=1 \
 	  -DBLAS_LIBRARIES="$(build_shlibdir)/libblastrampoline.$(SHLIB_EXT)" \
 	  -DBLAS_LINKER_FLAGS="blastrampoline" \
-	  -DBLAS_UNDERSCORE=ON \
 	  -DBLA_VENDOR="blastrampoline" \
-	  -DBLAS64_SUFFIX="_64" \
-	  -DALLOW_64BIT_BLAS=ON \
-	  -DLAPACK_FOUND=1 \
 	  -DLAPACK_LIBRARIES="$(build_shlibdir)/libblastrampoline.$(SHLIB_EXT)" \
-	  -DLAPACK_LINKER_FLAGS="blastrampoline"
+	  -DLAPACK_LINKER_FLAGS="blastrampoline" \
+	  -DBLAS64_SUFFIX="_64" \
+	  -DSUITESPARSE_USE_64BIT_BLAS=YES
 
 ifneq (,$(findstring $(OS),Linux FreeBSD))
 LIBSUITESPARSE_CMAKE_FLAGS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
@@ -40,17 +42,21 @@ $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted: $(SRCCACHE)/Suit
 checksum-libsuitesparse: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER).tar.gz
 	$(JLCHECKSUM) $<
 
+# https://github.com/DrTimothyAldenDavis/SuiteSparse/pull/671
+$(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/suitesparse-blas-suffix.patch-applied: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted
+	cd $(dir $@) && \
+		patch -p1 -f < $(SRCDIR)/patches/suitesparse-blas-suffix.patch
+	echo 1 > $@
+
+$(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-patched: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/suitesparse-blas-suffix.patch-applied
+	echo 1 > $@
+
 $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: | $(build_prefix)/manifest/blastrampoline
 
-$(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted
-	cd $(dir $<); \
-	for PROJ in SuiteSparse_config $(LIBSUITESPARSE_PROJECTS); do \
-		cd $${PROJ}/build || exit 1; \
-		$(CMAKE) .. $(LIBSUITESPARSE_CMAKE_FLAGS) || exit 1; \
-		make || exit 1; \
-		make install || exit 1; \
-		cd ../..; \
-	done
+$(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-patched
+	cd $(dir $<) && $(CMAKE) .. $(LIBSUITESPARSE_CMAKE_FLAGS)
+	make
+	make install
 	echo 1 > $@
 
 ifeq ($(OS),WINNT)
@@ -59,7 +65,7 @@ else
 LIBSUITESPARSE_SHLIB_ENV:=LD_LIBRARY_PATH="$(build_shlibdir)"
 endif
 $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-checked: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled
-	for PROJ in $(LIBSUITESPARSE_PROJECTS); do \
+	for PROJ in $(shell echo $(subst ;, ,$(LIBSUITESPARSE_PROJECTS))); do \
 		$(LIBSUITESPARSE_SHLIB_ENV) $(MAKE) -C $(dir $<)$${PROJ} default $(LIBSUITESPARSE_MFLAGS) || exit 1; \
 	done
 	echo 1 > $@
diff --git a/deps/libsuitesparse.version b/deps/libsuitesparse.version
index eea10d4f2beb8..ca38a96fb0ed3 100644
--- a/deps/libsuitesparse.version
+++ b/deps/libsuitesparse.version
@@ -1,6 +1,8 @@
+# -*- makefile -*-
+
 ## jll artifact
 LIBSUITESPARSE_JLL_NAME := SuiteSparse
 
 ## source build
-LIBSUITESPARSE_VER := 7.2.1
-LIBSUITESPARSE_SHA1=d6c84f7416eaee0d23d61c6c49ad1b73235d2ea2
+LIBSUITESPARSE_VER := 7.4.0
+LIBSUITESPARSE_SHA1=df91d7be262e6b5cddf5dd23ff42dec1713e7947
diff --git a/deps/patches/suitesparse-blas-suffix.patch b/deps/patches/suitesparse-blas-suffix.patch
new file mode 100644
index 0000000000000..c6a04ddee618d
--- /dev/null
+++ b/deps/patches/suitesparse-blas-suffix.patch
@@ -0,0 +1,40 @@
+From b936940aab08dc4bc60ccf2b9daec2105a960ad4 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Markus=20M=C3=BCtzel?= <markus.muetzel@gmx.de>
+Date: Mon, 1 Jan 2024 13:00:17 +0100
+Subject: [PATCH] Add preprocessor definitions also with user-supplied
+ BLAS_LIBRARIES
+
+---
+ SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake   | 4 ++--
+ SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake | 2 +-
+ 2 files changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake b/SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake
+index ca241472d..be7cd2e73 100644
+--- a/SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake
++++ b/SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake
+@@ -36,9 +36,9 @@ if ( DEFINED BLAS_LIBRARIES OR DEFINED BLAS_INCLUDE_DIRS )
+     # User supplied variables for libraries and/or include directories.
+     # Use them as-is.
+     if ( SUITESPARSE_USE_64BIT_BLAS )
+-        set ( SuiteSparse_BLAS_integer "int64_t" )
++        include ( SuiteSparseBLAS64 )
+     else ( )
+-        set ( SuiteSparse_BLAS_integer "int32_t" )
++        include ( SuiteSparseBLAS32 )
+     endif ( )
+     return ( )
+ endif ( )
+diff --git a/SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake b/SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake
+index 744aaef91..1a5c63690 100644
+--- a/SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake
++++ b/SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake
+@@ -37,7 +37,7 @@ set ( SuiteSparse_BLAS_integer "int64_t" )
+ # https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/suite-sparse/package.py
+
+ if ( DEFINED BLAS64_SUFFIX )
+-    # append BLAS64_SUFFIX to each BLAS and LAPACK name
++    # append BLAS64_SUFFIX to each BLAS and LAPACK function name
+     string ( FIND ${BLAS64_SUFFIX} "_" HAS_UNDERSCORE )
+     message ( STATUS "BLAS64_suffix: ${BLAS64_SUFFIX}" )
+     if ( HAS_UNDERSCORE EQUAL -1 )
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 84ffe8b7c5296..00a3f26249c2e 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = feb54ee5e49008bd157227099cafe604a67c36fb
+SPARSEARRAYS_SHA1 = f890a1e13fc04c295cec48a9b08b76c6e1a7039a
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1
diff --git a/stdlib/SuiteSparse_jll/Project.toml b/stdlib/SuiteSparse_jll/Project.toml
index 7518d64e80200..787162c090f20 100644
--- a/stdlib/SuiteSparse_jll/Project.toml
+++ b/stdlib/SuiteSparse_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "SuiteSparse_jll"
 uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
-version = "7.2.1+1"
+version = "7.4.0+2"
 
 [deps]
 libblastrampoline_jll = "8e850b90-86db-534c-a0d3-1478176c7d93"
@@ -8,7 +8,7 @@ Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 
 [compat]
-julia = "1.10"
+julia = "1.11"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl b/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl
index f245759aaf383..08614880a934c 100644
--- a/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl
+++ b/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl
@@ -58,7 +58,7 @@ elseif Sys.isapple()
     const libbtf = "@rpath/libbtf.2.dylib"
     const libcamd = "@rpath/libcamd.3.dylib"
     const libccolamd = "@rpath/libccolamd.3.dylib"
-    const libcholmod = "@rpath/libcholmod.4.dylib"
+    const libcholmod = "@rpath/libcholmod.5.dylib"
     const libcolamd = "@rpath/libcolamd.3.dylib"
     const libklu = "@rpath/libklu.2.dylib"
     const libldl = "@rpath/libldl.3.dylib"
@@ -71,7 +71,7 @@ else
     const libbtf = "libbtf.so.2"
     const libcamd = "libcamd.so.3"
     const libccolamd = "libccolamd.so.3"
-    const libcholmod = "libcholmod.so.4"
+    const libcholmod = "libcholmod.so.5"
     const libcolamd = "libcolamd.so.3"
     const libklu = "libklu.so.2"
     const libldl = "libldl.so.3"

From 513d013d227c50fb8667c0472c396b317b82b73e Mon Sep 17 00:00:00 2001
From: Michael Tiemann <126827163+mitiemann@users.noreply.github.com>
Date: Sat, 6 Jan 2024 15:53:54 +0100
Subject: [PATCH 0556/1315] [Markdown] added doc string for @md_str string
 literal (#52606)

This PR addresses #51168 . I guess this PR wants to have the labels doc
& markdown .

---------

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Steven G. Johnson <stevenj@alum.mit.edu>
---
 stdlib/Markdown/docs/src/index.md  | 14 ++++++++++
 stdlib/Markdown/src/Markdown.jl    | 41 +++++++++++++++++++++++++++++-
 stdlib/Markdown/src/parse/parse.jl |  9 +++++++
 3 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/stdlib/Markdown/docs/src/index.md b/stdlib/Markdown/docs/src/index.md
index 30f530d1c6263..1913909278b54 100644
--- a/stdlib/Markdown/docs/src/index.md
+++ b/stdlib/Markdown/docs/src/index.md
@@ -398,3 +398,17 @@ complex features (such as references) without cluttering the basic syntax.
 
 In principle, the Markdown parser itself can also be arbitrarily extended by packages, or an entirely
 custom flavour of Markdown can be used, but this should generally be unnecessary.
+
+## [Markdown String Literals](@id stdlib-markdown-literals)
+
+Markdown strings can be constructed using the string literal syntax `md"..."`.
+
+## [API reference](@id stdlib-markdown-api)
+
+```@docs
+Markdown.MD
+Markdown.@md_str
+Markdown.@doc_str
+Markdown.html
+Markdown.latex
+```
diff --git a/stdlib/Markdown/src/Markdown.jl b/stdlib/Markdown/src/Markdown.jl
index 781fcbdafddc8..93d8dbc39fc59 100644
--- a/stdlib/Markdown/src/Markdown.jl
+++ b/stdlib/Markdown/src/Markdown.jl
@@ -1,7 +1,11 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
-Tools for working with the Markdown file format. Mainly for documentation.
+    Markdown
+
+Tools for working with the Markdown markup language for formatted text, used within Julia for documentation.
+The `Markdown` module provides the (internal) [`MD`](@ref) type as well as the string
+literals `md"..."` and `doc"..."`.
 """
 module Markdown
 
@@ -40,6 +44,22 @@ function docexpr(source::LineNumberNode, mod::Module, s, flavor = :julia)
     :($doc_str($(mdexpr(s, flavor)), $(QuoteNode(source)), $mod))
 end
 
+"""
+    @md_str -> MD
+
+Parse the given string as Markdown text and return a corresponding [`MD`](@ref) object.
+
+# Examples
+```jldoctest
+julia> s = md"# Hello, world!"
+  Hello, world!
+  ≡≡≡≡≡≡≡≡≡≡≡≡≡
+
+julia> typeof(s)
+Markdown.MD
+
+```
+"""
 macro md_str(s, t...)
     mdexpr(s, t...)
 end
@@ -51,6 +71,25 @@ function doc_str(md, source::LineNumberNode, mod::Module)
 end
 doc_str(md::AbstractString, source::LineNumberNode, mod::Module) = doc_str(parse(md), source, mod)
 
+"""
+    @doc_str -> MD
+
+Parse the given string as Markdown text, add line and module information and return a
+corresponding [`MD`](@ref) object.
+
+`@doc_str` can be used in conjunction with the [`Base.Docs`](@ref) module. Please also refer to
+the manual section on [documentation](@ref man-documentation) for more information.
+
+# Examples
+```
+julia> s = doc"f(x) = 2*x"
+  f(x) = 2*x
+
+julia> typeof(s)
+Markdown.MD
+
+```
+"""
 macro doc_str(s::AbstractString, t...)
     docexpr(__source__, __module__, s, t...)
 end
diff --git a/stdlib/Markdown/src/parse/parse.jl b/stdlib/Markdown/src/parse/parse.jl
index 452d90d1176e1..0f3cbe857c2f9 100644
--- a/stdlib/Markdown/src/parse/parse.jl
+++ b/stdlib/Markdown/src/parse/parse.jl
@@ -1,5 +1,12 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    MD
+
+`MD` represents a Markdown document. Note that the `MD` constructor should not generally be
+used directly, since it constructs the internal data structures. Instead, you can construct
+`MD` objects using the exported macros [`@md_str`](@ref) and [`@doc_str`](@ref).
+"""
 mutable struct MD
     content::Vector{Any}
     meta::Dict{Symbol, Any}
@@ -8,6 +15,8 @@ mutable struct MD
         new(content, meta)
 end
 
+public MD
+
 MD(xs...) = MD(vcat(xs...))
 
 function MD(cfg::Config, xs...)

From dd7f1f860c4f66d1fd93de0bc1ae167c357b5055 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sat, 6 Jan 2024 20:04:28 +0800
Subject: [PATCH 0557/1315] use `Integer` during broadcast when possible.

---
 base/broadcast.jl | 20 ++++++++------------
 test/broadcast.jl | 19 ++++++++++++++++---
 2 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index e653c4086e452..e63631c156c7e 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -571,15 +571,15 @@ an `Int`.
     Any remaining indices in `I` beyond the length of the `keep` tuple are truncated. The `keep` and `default`
     tuples may be created by `newindexer(argument)`.
 """
-Base.@propagate_inbounds newindex(arg, I::CartesianIndex) = CartesianIndex(_newindex(axes(arg), I.I))
-Base.@propagate_inbounds newindex(arg, I::Integer) = CartesianIndex(_newindex(axes(arg), (I,)))
+Base.@propagate_inbounds newindex(arg, I::CartesianIndex) = to_index(_newindex(axes(arg), I.I))
+Base.@propagate_inbounds newindex(arg, I::Integer) = to_index(_newindex(axes(arg), (I,)))
 Base.@propagate_inbounds _newindex(ax::Tuple, I::Tuple) = (ifelse(length(ax[1]) == 1, ax[1][1], I[1]), _newindex(tail(ax), tail(I))...)
 Base.@propagate_inbounds _newindex(ax::Tuple{}, I::Tuple) = ()
 Base.@propagate_inbounds _newindex(ax::Tuple, I::Tuple{}) = (ax[1][1], _newindex(tail(ax), ())...)
 Base.@propagate_inbounds _newindex(ax::Tuple{}, I::Tuple{}) = ()
 
 # If dot-broadcasting were already defined, this would be `ifelse.(keep, I, Idefault)`.
-@inline newindex(I::CartesianIndex, keep, Idefault) = CartesianIndex(_newindex(I.I, keep, Idefault))
+@inline newindex(I::CartesianIndex, keep, Idefault) = to_index(_newindex(I.I, keep, Idefault))
 @inline newindex(i::Integer, keep::Tuple, idefault) = ifelse(keep[1], i, idefault[1])
 @inline newindex(i::Integer, keep::Tuple{}, idefault) = CartesianIndex(())
 @inline _newindex(I, keep, Idefault) =
@@ -599,18 +599,14 @@ Base.@propagate_inbounds _newindex(ax::Tuple{}, I::Tuple{}) = ()
     (Base.length(ind1)::Integer != 1, keep...), (first(ind1), Idefault...)
 end
 
-@inline function Base.getindex(bc::Broadcasted, I::Union{Integer,CartesianIndex})
+@inline function Base.getindex(bc::Broadcasted, Is::Vararg{Union{Integer,CartesianIndex},N}) where {N}
+    I = to_index(Base.IteratorsMD.flatten(Is))
     @boundscheck checkbounds(bc, I)
     @inbounds _broadcast_getindex(bc, I)
 end
-Base.@propagate_inbounds Base.getindex(
-    bc::Broadcasted,
-    i1::Union{Integer,CartesianIndex},
-    i2::Union{Integer,CartesianIndex},
-    I::Union{Integer,CartesianIndex}...,
-) =
-    bc[CartesianIndex((i1, i2, I...))]
-Base.@propagate_inbounds Base.getindex(bc::Broadcasted) = bc[CartesianIndex(())]
+to_index(::Tuple{}) = CartesianIndex()
+to_index(Is::Tuple{Any}) = Is[1]
+to_index(Is::Tuple) = CartesianIndex(Is)
 
 @inline Base.checkbounds(bc::Broadcasted, I::Union{Integer,CartesianIndex}) =
     Base.checkbounds_indices(Bool, axes(bc), (I,)) || Base.throw_boundserror(bc, (I,))
diff --git a/test/broadcast.jl b/test/broadcast.jl
index ff0fc1401a703..1e5752921bc93 100644
--- a/test/broadcast.jl
+++ b/test/broadcast.jl
@@ -49,9 +49,9 @@ ci(x) = CartesianIndex(x)
 @test @inferred(newindex(ci((2,2)), (true, false), (-1,-1)))  == ci((2,-1))
 @test @inferred(newindex(ci((2,2)), (false, true), (-1,-1)))  == ci((-1,2))
 @test @inferred(newindex(ci((2,2)), (false, false), (-1,-1))) == ci((-1,-1))
-@test @inferred(newindex(ci((2,2)), (true,), (-1,-1)))   == ci((2,))
-@test @inferred(newindex(ci((2,2)), (true,), (-1,)))   == ci((2,))
-@test @inferred(newindex(ci((2,2)), (false,), (-1,))) == ci((-1,))
+@test @inferred(newindex(ci((2,2)), (true,), (-1,-1))) == 2
+@test @inferred(newindex(ci((2,2)), (true,), (-1,)))   == 2
+@test @inferred(newindex(ci((2,2)), (false,), (-1,)))  == -1
 @test @inferred(newindex(ci((2,2)), (), ())) == ci(())
 
 end
@@ -1175,3 +1175,16 @@ import Base.Broadcast: BroadcastStyle, DefaultArrayStyle
 
 f51129(v, x) = (1 .- (v ./ x) .^ 2)
 @test @inferred(f51129([13.0], 6.5)) == [-3.0]
+
+@testset "broadcast for `AbstractArray` without `CartesianIndex` support" begin
+    struct BVec52775 <: AbstractVector{Int}
+        a::Vector{Int}
+    end
+    Base.size(a::BVec52775) = size(a.a)
+    Base.getindex(a::BVec52775, i::Real) = a.a[i]
+    Base.getindex(a::BVec52775, i) = error("unsupported index!")
+    a = BVec52775([1,2,3])
+    bc = Base.broadcasted(identity, a)
+    @test bc[1] == bc[CartesianIndex(1)] == bc[1, CartesianIndex()]
+    @test a .+ [1 2] == a.a .+ [1 2]
+end

From ecb668bdf111d8b2be28296eed90cee76074635d Mon Sep 17 00:00:00 2001
From: Mason Protter <mason.protter@icloud.com>
Date: Sat, 6 Jan 2024 17:27:19 +0100
Subject: [PATCH 0558/1315] RFC: Methods for `eigen` on complex hermitian
 tridiagonal matrices (#49546)

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 NEWS.md                                    |  1 +
 stdlib/LinearAlgebra/src/symmetriceigen.jl | 31 ++++++++++++++++++++++
 stdlib/LinearAlgebra/test/eigen.jl         |  3 ++-
 3 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index cee80f892ec2a..2c1da218c1f65 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -115,6 +115,7 @@ Standard library changes
 * `eigvals/eigen(A, bunchkaufman(B))` and `eigvals/eigen(A, lu(B))`, which utilize the Bunchkaufman (LDL) and LU decomposition of `B`,
    respectively, now efficiently compute the generalized eigenvalues (`eigen`: and eigenvectors) of `A` and `B`. Note: The second
    argument is the output of `bunchkaufman` or `lu` ([#50471]).
+* There is now a specialized dispatch for `eigvals/eigen(::Hermitian{<:Tridiagonal})` which performs a similarity transformation to create a real symmetrix triagonal matrix, and solve that using the LAPACK routines ([#49546]).
 * Structured matrices now retain either the axes of the parent (for `Symmetric`/`Hermitian`/`AbstractTriangular`/`UpperHessenberg`), or that of the principal diagonal (for banded matrices) ([#52480]).
 * `bunchkaufman` and `bunchkaufman!` now work for any `AbstractFloat`, `Rational` and their complex variants. `bunchkaufman` now supports `Integer` types, by making an internal conversion to `Rational{BigInt}`. Added new function `inertia` that computes the inertia of the diagonal factor given by the `BunchKaufman` factorization object of a real symmetric or Hermitian matrix. For complex symmetric matrices, `inertia` only computes the number of zero eigenvalues of the diagonal factor ([#51487]).
 
diff --git a/stdlib/LinearAlgebra/src/symmetriceigen.jl b/stdlib/LinearAlgebra/src/symmetriceigen.jl
index 4e35616f62181..246556e88ff02 100644
--- a/stdlib/LinearAlgebra/src/symmetriceigen.jl
+++ b/stdlib/LinearAlgebra/src/symmetriceigen.jl
@@ -294,3 +294,34 @@ function eigvals!(A::StridedMatrix{T}, F::LU{T,<:StridedMatrix}; sortby::Union{F
     rdiv!(A, U)
     return eigvals!(A; sortby)
 end
+
+
+function eigen(A::Hermitian{Complex{T}, <:Tridiagonal}; kwargs...) where {T}
+    (; dl, d, du) = parent(A)
+    N = length(d)
+    if N <= 1
+        eigen(parent(A); kwargs...)
+    else
+        if A.uplo == 'U'
+            E = du'
+            Er = abs.(du)
+        else
+            E = dl
+            Er = abs.(E)
+        end
+        S = Vector{Complex{T}}(undef, N)
+        S[1] = 1
+        for i ∈ 1:N-1
+            S[i+1] = iszero(Er[i]) ? one(Complex{T}) : S[i] * sign(E[i])
+        end
+        B = SymTridiagonal(real(d), Er)
+        Λ, Φ = eigen(B; kwargs...)
+        return Eigen(Λ, Diagonal(S) * Φ)
+    end
+end
+
+function eigvals(A::Hermitian{Complex{T}, <:Tridiagonal}; kwargs...) where {T}
+    (; dl, d, du) = parent(A)
+    E = A.uplo == 'U' ? abs.(du) : abs.(dl)
+    eigvals(SymTridiagonal(real.(d), E); kwargs...)
+end
diff --git a/stdlib/LinearAlgebra/test/eigen.jl b/stdlib/LinearAlgebra/test/eigen.jl
index 85ec5cdf5ab46..73d9147a82a09 100644
--- a/stdlib/LinearAlgebra/test/eigen.jl
+++ b/stdlib/LinearAlgebra/test/eigen.jl
@@ -45,12 +45,13 @@ aimg  = randn(n,n)/2
             @test eigvecs(f) === f.vectors
             @test Array(f) ≈ a
 
-            for T in (Tridiagonal(a), Hermitian(Tridiagonal(a)))
+            for T in (Tridiagonal(a), Hermitian(Tridiagonal(a), :U), Hermitian(Tridiagonal(a), :L))
                 f = eigen(T)
                 d, v = f
                 for i in 1:size(a,2)
                     @test T*v[:,i] ≈ d[i]*v[:,i]
                 end
+                @test eigvals(T) ≈ d
                 @test det(T) ≈ det(f)
                 @test inv(T) ≈ inv(f)
             end

From c827094a4176ec1cbda25654ee985459b7f8b9ee Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Sat, 6 Jan 2024 10:07:26 -0800
Subject: [PATCH 0559/1315] Fix variable naming confusion in
 `warn_if_already_loaded_different()` (#52778)

---
 base/loading.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/loading.jl b/base/loading.jl
index d7d0a4af81382..9a646120df131 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2001,7 +2001,7 @@ function warn_if_already_loaded_different(uuidkey::PkgId)
                 v = get_pkgversion_from_path(dirname(dirname(pkgorig.path)))
                 cur_vstr = isnothing(v) ? "" : "v$v "
             else
-                cur_vstr = "v$v "
+                cur_vstr = "v$(pkgorig.version) "
             end
             new_v = get_pkgversion_from_path(dirname(dirname(new_path)))
             new_vstr = isnothing(new_v) ? "" : "v$new_v "

From 0cb5a0ecd487b7e3d2f6844d1aeb966ca54f75b7 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Sat, 6 Jan 2024 11:11:28 -0800
Subject: [PATCH 0560/1315] Fix `MethodError` when warning about a toplevel
 module (#52782)

---
 base/loading.jl | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/base/loading.jl b/base/loading.jl
index 9a646120df131..fdb6b0e8fff57 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2022,7 +2022,10 @@ function warn_if_already_loaded_different(uuidkey::PkgId)
                 end
             end
             @warn warnstr
-            push!(already_warned_path_change_pkgs, uuidkey.uuid)
+            # Toplevel modules have a `uuid` of `Nothing`
+            if uuidkey.uuid !== nothing
+                push!(already_warned_path_change_pkgs, uuidkey.uuid)
+            end
         end
     end
 end

From ea085ea129135604540d2dc12d35577c4d2f9e69 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 7 Jan 2024 02:43:22 +0530
Subject: [PATCH 0561/1315] Disambiguate structured and abstract matrix
 multiplication (#52464)

Co-authored-by: Daniel Karrasch <Daniel.Karrasch@posteo.de>
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 11 +++++++++
 stdlib/LinearAlgebra/src/bidiag.jl        | 26 ++++++++++----------
 stdlib/LinearAlgebra/src/diagonal.jl      | 26 ++++++--------------
 stdlib/LinearAlgebra/src/hessenberg.jl    | 12 +++++-----
 stdlib/LinearAlgebra/src/matmul.jl        |  5 +++-
 stdlib/LinearAlgebra/src/triangular.jl    | 29 ++++-------------------
 stdlib/LinearAlgebra/test/diagonal.jl     |  8 +++++++
 stdlib/LinearAlgebra/test/triangular.jl   |  8 +++++++
 test/testhelpers/SizedArrays.jl           |  5 ++++
 9 files changed, 67 insertions(+), 63 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index 10cc9a2f3459a..a80c8d0600a78 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -523,6 +523,17 @@ _makevector(x::AbstractVector) = Vector(x)
 _pushzero(A) = (B = similar(A, length(A)+1); @inbounds B[begin:end-1] .= A; @inbounds B[end] = zero(eltype(B)); B)
 _droplast!(A) = deleteat!(A, lastindex(A))
 
+# destination type for matmul
+matprod_dest(A::StructuredMatrix, B::StructuredMatrix, TS) = similar(B, TS, size(B))
+matprod_dest(A, B::StructuredMatrix, TS) = similar(A, TS, size(A))
+matprod_dest(A::StructuredMatrix, B, TS) = similar(B, TS, size(B))
+matprod_dest(A::StructuredMatrix, B::Diagonal, TS) = similar(A, TS)
+matprod_dest(A::Diagonal, B::StructuredMatrix, TS) = similar(B, TS)
+matprod_dest(A::Diagonal, B::Diagonal, TS) = similar(B, TS)
+matprod_dest(A::HermOrSym, B::Diagonal, TS) = similar(A, TS, size(A))
+matprod_dest(A::Diagonal, B::HermOrSym, TS) = similar(B, TS, size(B))
+
+# TODO: remove once not used anymore in SparseArrays.jl
 # some trait like this would be cool
 # onedefined(::Type{T}) where {T} = hasmethod(one, (T,))
 # but we are actually asking for oneunit(T), that is, however, defined for generic T as
diff --git a/stdlib/LinearAlgebra/src/bidiag.jl b/stdlib/LinearAlgebra/src/bidiag.jl
index 88cc145835df9..2b4b2ac98317c 100644
--- a/stdlib/LinearAlgebra/src/bidiag.jl
+++ b/stdlib/LinearAlgebra/src/bidiag.jl
@@ -802,34 +802,35 @@ ldiv!(c::AbstractVecOrMat, A::AdjOrTrans{<:Any,<:Bidiagonal}, b::AbstractVecOrMa
     (t = wrapperop(A); _rdiv!(t(c), t(b), t(A)); return c)
 
 ### Generic promotion methods and fallbacks
-\(A::Bidiagonal, B::AbstractVecOrMat) = ldiv!(_initarray(\, eltype(A), eltype(B), B), A, B)
+\(A::Bidiagonal, B::AbstractVecOrMat) =
+    ldiv!(matprod_dest(A, B, promote_op(\, eltype(A), eltype(B))), A, B)
 \(xA::AdjOrTrans{<:Any,<:Bidiagonal}, B::AbstractVecOrMat) = copy(xA) \ B
 
 ### Triangular specializations
 for tri in (:UpperTriangular, :UnitUpperTriangular)
     @eval function \(B::Bidiagonal, U::$tri)
-        A = ldiv!(_initarray(\, eltype(B), eltype(U), U), B, U)
+        A = ldiv!(matprod_dest(B, U, promote_op(\, eltype(B), eltype(U))), B, U)
         return B.uplo == 'U' ? UpperTriangular(A) : A
     end
     @eval function \(U::$tri, B::Bidiagonal)
-        A = ldiv!(_initarray(\, eltype(U), eltype(B), U), U, B)
+        A = ldiv!(matprod_dest(U, B, promote_op(\, eltype(U), eltype(B))), U, B)
         return B.uplo == 'U' ? UpperTriangular(A) : A
     end
 end
 for tri in (:LowerTriangular, :UnitLowerTriangular)
     @eval function \(B::Bidiagonal, L::$tri)
-        A = ldiv!(_initarray(\, eltype(B), eltype(L), L), B, L)
+        A = ldiv!(matprod_dest(B, L, promote_op(\, eltype(B), eltype(L))), B, L)
         return B.uplo == 'L' ? LowerTriangular(A) : A
     end
     @eval function \(L::$tri, B::Bidiagonal)
-        A = ldiv!(_initarray(\, eltype(L), eltype(B), L), L, B)
+        A = ldiv!(matprod_dest(L, B, promote_op(\, eltype(L), eltype(B))), L, B)
         return B.uplo == 'L' ? LowerTriangular(A) : A
     end
 end
 
 ### Diagonal specialization
 function \(B::Bidiagonal, D::Diagonal)
-    A = ldiv!(_initarray(\, eltype(B), eltype(D), D), B, D)
+    A = ldiv!(similar(D, promote_op(\, eltype(B), eltype(D)), size(D)), B, D)
     return B.uplo == 'U' ? UpperTriangular(A) : LowerTriangular(A)
 end
 
@@ -879,33 +880,34 @@ rdiv!(A::AbstractMatrix, B::AdjOrTrans{<:Any,<:Bidiagonal}) = @inline _rdiv!(A,
 _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::AdjOrTrans{<:Any,<:Bidiagonal}) =
     (t = wrapperop(B); ldiv!(t(C), t(B), t(A)); return C)
 
-/(A::AbstractMatrix, B::Bidiagonal) = _rdiv!(_initarray(/, eltype(A), eltype(B), A), A, B)
+/(A::AbstractMatrix, B::Bidiagonal) =
+    _rdiv!(similar(A, promote_op(/, eltype(A), eltype(B)), size(A)), A, B)
 
 ### Triangular specializations
 for tri in (:UpperTriangular, :UnitUpperTriangular)
     @eval function /(U::$tri, B::Bidiagonal)
-        A = _rdiv!(_initarray(/, eltype(U), eltype(B), U), U, B)
+        A = _rdiv!(matprod_dest(U, B, promote_op(/, eltype(U), eltype(B))), U, B)
         return B.uplo == 'U' ? UpperTriangular(A) : A
     end
     @eval function /(B::Bidiagonal, U::$tri)
-        A = _rdiv!(_initarray(/, eltype(B), eltype(U), U), B, U)
+        A = _rdiv!(matprod_dest(B, U, promote_op(/, eltype(B), eltype(U))), B, U)
         return B.uplo == 'U' ? UpperTriangular(A) : A
     end
 end
 for tri in (:LowerTriangular, :UnitLowerTriangular)
     @eval function /(L::$tri, B::Bidiagonal)
-        A = _rdiv!(_initarray(/, eltype(L), eltype(B), L), L, B)
+        A = _rdiv!(matprod_dest(L, B, promote_op(/, eltype(L), eltype(B))), L, B)
         return B.uplo == 'L' ? LowerTriangular(A) : A
     end
     @eval function /(B::Bidiagonal, L::$tri)
-        A = _rdiv!(_initarray(/, eltype(B), eltype(L), L), B, L)
+        A = _rdiv!(matprod_dest(B, L, promote_op(/, eltype(B), eltype(L))), B, L)
         return B.uplo == 'L' ? LowerTriangular(A) : A
     end
 end
 
 ### Diagonal specialization
 function /(D::Diagonal, B::Bidiagonal)
-    A = _rdiv!(_initarray(/, eltype(D), eltype(B), D), D, B)
+    A = _rdiv!(similar(D, promote_op(/, eltype(D), eltype(B)), size(D)), D, B)
     return B.uplo == 'U' ? UpperTriangular(A) : LowerTriangular(A)
 end
 
diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index e8638d3d7ff12..063dde619bd1a 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -310,15 +310,6 @@ function (*)(D::Diagonal, V::AbstractVector)
     return D.diag .* V
 end
 
-(*)(A::AbstractMatrix, D::Diagonal) =
-    mul!(similar(A, promote_op(*, eltype(A), eltype(D.diag))), A, D)
-(*)(A::HermOrSym, D::Diagonal) =
-    mul!(similar(A, promote_op(*, eltype(A), eltype(D.diag)), size(A)), A, D)
-(*)(D::Diagonal, A::AbstractMatrix) =
-    mul!(similar(A, promote_op(*, eltype(D.diag), eltype(A))), D, A)
-(*)(D::Diagonal, A::HermOrSym) =
-    mul!(similar(A, promote_op(*, eltype(A), eltype(D.diag)), size(A)), D, A)
-
 rmul!(A::AbstractMatrix, D::Diagonal) = @inline mul!(A, A, D)
 lmul!(D::Diagonal, B::AbstractVecOrMat) = @inline mul!(B, D, B)
 
@@ -431,8 +422,8 @@ function (*)(Da::Diagonal, Db::Diagonal, Dc::Diagonal)
     return Diagonal(Da.diag .* Db.diag .* Dc.diag)
 end
 
-/(A::AbstractVecOrMat, D::Diagonal) = _rdiv!(similar(A, _init_eltype(/, eltype(A), eltype(D))), A, D)
-/(A::HermOrSym, D::Diagonal) = _rdiv!(similar(A, _init_eltype(/, eltype(A), eltype(D)), size(A)), A, D)
+/(A::AbstractVecOrMat, D::Diagonal) = _rdiv!(matprod_dest(A, D, promote_op(/, eltype(A), eltype(D))), A, D)
+/(A::HermOrSym, D::Diagonal) = _rdiv!(matprod_dest(A, D, promote_op(/, eltype(A), eltype(D))), A, D)
 
 rdiv!(A::AbstractVecOrMat, D::Diagonal) = @inline _rdiv!(A, A, D)
 # avoid copy when possible via internal 3-arg backend
@@ -458,8 +449,8 @@ function \(D::Diagonal, B::AbstractVector)
     isnothing(j) || throw(SingularException(j))
     return D.diag .\ B
 end
-\(D::Diagonal, B::AbstractMatrix) = ldiv!(similar(B, _init_eltype(\, eltype(D), eltype(B))), D, B)
-\(D::Diagonal, B::HermOrSym) = ldiv!(similar(B, _init_eltype(\, eltype(D), eltype(B)), size(B)), D, B)
+\(D::Diagonal, B::AbstractMatrix) = ldiv!(matprod_dest(D, B, promote_op(\, eltype(D), eltype(B))), D, B)
+\(D::Diagonal, B::HermOrSym) = ldiv!(matprod_dest(D, B, promote_op(\, eltype(D), eltype(B))), D, B)
 
 ldiv!(D::Diagonal, B::AbstractVecOrMat) = @inline ldiv!(B, D, B)
 function ldiv!(B::AbstractVecOrMat, D::Diagonal, A::AbstractVecOrMat)
@@ -479,8 +470,8 @@ function ldiv!(B::AbstractVecOrMat, D::Diagonal, A::AbstractVecOrMat)
 end
 
 # Optimizations for \, / between Diagonals
-\(D::Diagonal, B::Diagonal) = ldiv!(similar(B, promote_op(\, eltype(D), eltype(B))), D, B)
-/(A::Diagonal, D::Diagonal) = _rdiv!(similar(A, promote_op(/, eltype(A), eltype(D))), A, D)
+\(D::Diagonal, B::Diagonal) = ldiv!(matprod_dest(D, B, promote_op(\, eltype(D), eltype(B))), D, B)
+/(A::Diagonal, D::Diagonal) = _rdiv!(matprod_dest(A, D, promote_op(/, eltype(A), eltype(D))), A, D)
 function _rdiv!(Dc::Diagonal, Db::Diagonal, Da::Diagonal)
     n, k = length(Db.diag), length(Da.diag)
     n == k || throw(DimensionMismatch("left hand side has $n columns but D is $k by $k"))
@@ -543,7 +534,7 @@ function (/)(S::SymTridiagonal, D::Diagonal)
     dl = similar(S.ev, T, max(length(S.dv)-1, 0))
     _rdiv!(Tridiagonal(dl, d, du), S, D)
 end
-(/)(T::Tridiagonal, D::Diagonal) = _rdiv!(similar(T, promote_op(/, eltype(T), eltype(D))), T, D)
+(/)(T::Tridiagonal, D::Diagonal) = _rdiv!(matprod_dest(T, D, promote_op(/, eltype(T), eltype(D))), T, D)
 function _rdiv!(T::Tridiagonal, S::Union{SymTridiagonal,Tridiagonal}, D::Diagonal)
     n = size(S, 2)
     dd = D.diag
@@ -876,9 +867,6 @@ function svd(D::Diagonal{T}) where {T<:Number}
     return SVD(U, S, Vt)
 end
 
-# disambiguation methods: * and / of Diagonal and Adj/Trans AbsVec
-*(u::AdjointAbsVec, D::Diagonal) = (D'u')'
-*(u::TransposeAbsVec, D::Diagonal) = transpose(transpose(D) * transpose(u))
 *(x::AdjointAbsVec,   D::Diagonal, y::AbstractVector) = _mapreduce_prod(*, x, D, y)
 *(x::TransposeAbsVec, D::Diagonal, y::AbstractVector) = _mapreduce_prod(*, x, D, y)
 /(u::AdjointAbsVec, D::Diagonal) = (D' \ u')'
diff --git a/stdlib/LinearAlgebra/src/hessenberg.jl b/stdlib/LinearAlgebra/src/hessenberg.jl
index aed8b3c3747a1..3be41baf24b24 100644
--- a/stdlib/LinearAlgebra/src/hessenberg.jl
+++ b/stdlib/LinearAlgebra/src/hessenberg.jl
@@ -133,29 +133,29 @@ for T = (:Number, :UniformScaling, :Diagonal)
 end
 
 function *(H::UpperHessenberg, U::UpperOrUnitUpperTriangular)
-    HH = mul!(_initarray(*, eltype(H), eltype(U), H), H, U)
+    HH = mul!(matprod_dest(H, U, promote_op(matprod, eltype(H), eltype(U))), H, U)
     UpperHessenberg(HH)
 end
 function *(U::UpperOrUnitUpperTriangular, H::UpperHessenberg)
-    HH = mul!(_initarray(*, eltype(U), eltype(H), H), U, H)
+    HH = mul!(matprod_dest(U, H, promote_op(matprod, eltype(U), eltype(H))), U, H)
     UpperHessenberg(HH)
 end
 
 function /(H::UpperHessenberg, U::UpperTriangular)
-    HH = _rdiv!(_initarray(/, eltype(H), eltype(U), H), H, U)
+    HH = _rdiv!(matprod_dest(H, U, promote_op(/, eltype(H), eltype(U))), H, U)
     UpperHessenberg(HH)
 end
 function /(H::UpperHessenberg, U::UnitUpperTriangular)
-    HH = _rdiv!(_initarray(/, eltype(H), eltype(U), H), H, U)
+    HH = _rdiv!(matprod_dest(H, U, promote_op(/, eltype(H), eltype(U))), H, U)
     UpperHessenberg(HH)
 end
 
 function \(U::UpperTriangular, H::UpperHessenberg)
-    HH = ldiv!(_initarray(\, eltype(U), eltype(H), H), U, H)
+    HH = ldiv!(matprod_dest(U, H, promote_op(\, eltype(U), eltype(H))), U, H)
     UpperHessenberg(HH)
 end
 function \(U::UnitUpperTriangular, H::UpperHessenberg)
-    HH = ldiv!(_initarray(\, eltype(U), eltype(H), H), U, H)
+    HH = ldiv!(matprod_dest(U, H, promote_op(\, eltype(U), eltype(H))), U, H)
     UpperHessenberg(HH)
 end
 
diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index cc1c954258a88..afc646c149eaf 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -106,8 +106,11 @@ julia> [1 1; 0 1] * [1 0; 1 1]
 """
 function (*)(A::AbstractMatrix, B::AbstractMatrix)
     TS = promote_op(matprod, eltype(A), eltype(B))
-    mul!(similar(B, TS, (size(A, 1), size(B, 2))), A, B)
+    mul!(matprod_dest(A, B, TS), A, B)
 end
+
+matprod_dest(A, B, TS) = similar(B, TS, (size(A, 1), size(B, 2)))
+
 # optimization for dispatching to BLAS, e.g. *(::Matrix{Float32}, ::Matrix{Float64})
 # but avoiding the case *(::Matrix{<:BlasComplex}, ::Matrix{<:BlasReal})
 # which is better handled by reinterpreting rather than promotion
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 64e1b320f19dd..781e323a0ca43 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -1545,22 +1545,11 @@ rmul!(A::LowerTriangular, B::UnitLowerTriangular) = LowerTriangular(rmul!(tril!(
 ## necessary in the general triangular solve problem.
 
 _inner_type_promotion(op, ::Type{TA}, ::Type{TB}) where {TA<:Integer,TB<:Integer} =
-    _init_eltype(*, TA, TB)
+    promote_op(matprod, TA, TB)
 _inner_type_promotion(op, ::Type{TA}, ::Type{TB}) where {TA,TB} =
-    _init_eltype(op, TA, TB)
+    promote_op(op, TA, TB)
 ## The general promotion methods
-function *(A::AbstractTriangular, B::AbstractTriangular)
-    TAB = _init_eltype(*, eltype(A), eltype(B))
-    mul!(similar(B, TAB, size(B)), A, B)
-end
-
 for mat in (:AbstractVector, :AbstractMatrix)
-    ### Multiplication with triangle to the left and hence rhs cannot be transposed.
-    @eval function *(A::AbstractTriangular, B::$mat)
-        require_one_based_indexing(B)
-        TAB = _init_eltype(*, eltype(A), eltype(B))
-        mul!(similar(B, TAB, size(B)), A, B)
-    end
     ### Left division with triangle to the left hence rhs cannot be transposed. No quotients.
     @eval function \(A::Union{UnitUpperTriangular,UnitLowerTriangular}, B::$mat)
         require_one_based_indexing(B)
@@ -1570,7 +1559,7 @@ for mat in (:AbstractVector, :AbstractMatrix)
     ### Left division with triangle to the left hence rhs cannot be transposed. Quotients.
     @eval function \(A::Union{UpperTriangular,LowerTriangular}, B::$mat)
         require_one_based_indexing(B)
-        TAB = _init_eltype(\, eltype(A), eltype(B))
+        TAB = promote_op(\, eltype(A), eltype(B))
         ldiv!(similar(B, TAB, size(B)), A, B)
     end
     ### Right division with triangle to the right hence lhs cannot be transposed. No quotients.
@@ -1582,20 +1571,10 @@ for mat in (:AbstractVector, :AbstractMatrix)
     ### Right division with triangle to the right hence lhs cannot be transposed. Quotients.
     @eval function /(A::$mat, B::Union{UpperTriangular,LowerTriangular})
         require_one_based_indexing(A)
-        TAB = _init_eltype(/, eltype(A), eltype(B))
+        TAB = promote_op(/, eltype(A), eltype(B))
         _rdiv!(similar(A, TAB, size(A)), A, B)
     end
 end
-### Multiplication with triangle to the right and hence lhs cannot be transposed.
-# Only for AbstractMatrix, hence outside the above loop.
-function *(A::AbstractMatrix, B::AbstractTriangular)
-    require_one_based_indexing(A)
-    TAB = _init_eltype(*, eltype(A), eltype(B))
-    mul!(similar(A, TAB, size(A)), A, B)
-end
-# ambiguity resolution with definitions in matmul.jl
-*(v::AdjointAbsVec, A::AbstractTriangular) = adjoint(adjoint(A) * v.parent)
-*(v::TransposeAbsVec, A::AbstractTriangular) = transpose(transpose(A) * v.parent)
 
 ## Some Triangular-Triangular cases. We might want to write tailored methods
 ## for these cases, but I'm not sure it is worth it.
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 9db7d8071931c..dab8f45ef66c7 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -1242,6 +1242,14 @@ end
     end
 end
 
+@testset "avoid matmul ambiguities with ::MyMatrix * ::AbstractMatrix" begin
+    A = [i+j for i in 1:2, j in 1:2]
+    S = SizedArrays.SizedArray{(2,2)}(A)
+    D = Diagonal([1:2;])
+    @test S * D == A * D
+    @test D * S == D * A
+end
+
 @testset "copy" begin
     @test copy(Diagonal(1:5)) === Diagonal(1:5)
 end
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index b60efba1d941a..e245240335434 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -896,6 +896,14 @@ end
     end
 end
 
+@testset "avoid matmul ambiguities with ::MyMatrix * ::AbstractMatrix" begin
+    A = [i+j for i in 1:2, j in 1:2]
+    S = SizedArrays.SizedArray{(2,2)}(A)
+    U = UpperTriangular(ones(2,2))
+    @test S * U == A * U
+    @test U * S == U * A
+end
+
 @testset "custom axes" begin
     SZA = SizedArrays.SizedArray{(2,2)}([1 2; 3 4])
     for T in (UpperTriangular, LowerTriangular, UnitUpperTriangular, UnitLowerTriangular)
diff --git a/test/testhelpers/SizedArrays.jl b/test/testhelpers/SizedArrays.jl
index a4810e297e0f9..67f5059b36efd 100644
--- a/test/testhelpers/SizedArrays.jl
+++ b/test/testhelpers/SizedArrays.jl
@@ -56,4 +56,9 @@ function *(S1::SizedArrayLike, S2::SizedArrayLike)
     SZ = ndims(data) == 1 ? (size(S1, 1), ) : (size(S1, 1), size(S2, 2))
     SizedArray{SZ}(data)
 end
+
+# deliberately wide method definition to ensure that this doesn't lead to ambiguities with
+# structured matrices
+*(S1::SizedArrayLike, M::AbstractMatrix) = _data(S1) * M
+
 end

From bac95ccffb7b9f0ca7e043117d94003faf00d54a Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sun, 7 Jan 2024 10:36:15 +0900
Subject: [PATCH 0562/1315] inference: thread lattice through memoryop type
 check (#52773)

We would probably need to backport similar changes to 1.10 too.

xref: aviatesk/JET.jl#589
---
 base/compiler/tfuncs.jl | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index c02c76c25ee98..0d15921dbc48e 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -2084,12 +2084,13 @@ function array_type_undefable(@nospecialize(arytype))
     return true
 end
 
-@nospecs function memoryset_typecheck(memtype, elemtype)
+@nospecs function memoryset_typecheck(𝕃::AbstractLattice, memtype, elemtype)
     # Check that we can determine the element type
     isa(memtype, DataType) || return false
     elemtype_expected = memoryref_elemtype(memtype)
     elemtype_expected === Union{} && return false
     # Check that the element type is compatible with the element we're assigning
+    ⊑ = Core.Compiler.:⊑(𝕃)
     elemtype ⊑ elemtype_expected || return false
     return true
 end
@@ -2122,17 +2123,17 @@ function memoryref_builtin_common_nothrow(argtypes::Vector{Any})
     end
 end
 
-function memoryrefop_builtin_common_nothrow(argtypes::Vector{Any}, @nospecialize f)
+function memoryrefop_builtin_common_nothrow(𝕃::AbstractLattice, argtypes::Vector{Any}, @nospecialize f)
     ismemoryset = f === memoryrefset!
     nargs = ismemoryset ? 4 : 3
     length(argtypes) == nargs || return false
     order = argtypes[2 + ismemoryset]
     boundscheck = argtypes[3 + ismemoryset]
     memtype = widenconst(argtypes[1])
-    memoryref_builtin_common_typecheck(boundscheck, memtype, order) || return false
+    memoryref_builtin_common_typecheck(𝕃, boundscheck, memtype, order) || return false
     if ismemoryset
         # Additionally check element type compatibility
-        memoryset_typecheck(memtype, argtypes[2]) || return false
+        memoryset_typecheck(𝕃, memtype, argtypes[2]) || return false
     elseif f === memoryrefget
         # If we could potentially throw undef ref errors, bail out now.
         array_type_undefable(memtype) && return false
@@ -2147,7 +2148,8 @@ function memoryrefop_builtin_common_nothrow(argtypes::Vector{Any}, @nospecialize
     return false
 end
 
-@nospecs function memoryref_builtin_common_typecheck(boundscheck, memtype, order)
+@nospecs function memoryref_builtin_common_typecheck(𝕃::AbstractLattice, boundscheck, memtype, order)
+    ⊑ = Core.Compiler.:⊑(𝕃)
     return boundscheck ⊑ Bool && memtype ⊑ GenericMemoryRef && order ⊑ Symbol
 end
 
@@ -2161,11 +2163,11 @@ end
         memtype = widenconst(argtypes[1])
         return memtype ⊑ GenericMemoryRef
     elseif f === memoryrefset!
-        return memoryrefop_builtin_common_nothrow(argtypes, f)
+        return memoryrefop_builtin_common_nothrow(𝕃, argtypes, f)
     elseif f === memoryrefget
-        return memoryrefop_builtin_common_nothrow(argtypes, f)
+        return memoryrefop_builtin_common_nothrow(𝕃, argtypes, f)
     elseif f === memoryref_isassigned
-        return memoryrefop_builtin_common_nothrow(argtypes, f)
+        return memoryrefop_builtin_common_nothrow(𝕃, argtypes, f)
     elseif f === Core._expr
         length(argtypes) >= 1 || return false
         return argtypes[1] ⊑ Symbol

From c63c3b0a1d185aa025348c7208f40cb30e87b63c Mon Sep 17 00:00:00 2001
From: Matt Stinson <11094799+mestinso@users.noreply.github.com>
Date: Sat, 6 Jan 2024 19:36:37 -0600
Subject: [PATCH 0563/1315] Update performance-tips.md with JET.jl instead of
 Traceur.jl (#52786)

Switch this tip from Traceur to JET as Traceur is no longer maintained.
---
 doc/src/manual/performance-tips.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/manual/performance-tips.md b/doc/src/manual/performance-tips.md
index 579413e808f7b..bdceb5a0c2493 100644
--- a/doc/src/manual/performance-tips.md
+++ b/doc/src/manual/performance-tips.md
@@ -157,7 +157,7 @@ the performance of your code:
   * [Profiling](@ref) allows you to measure the performance of your running code and identify lines
     that serve as bottlenecks. For complex projects, the [ProfileView](https://github.com/timholy/ProfileView.jl)
     package can help you visualize your profiling results.
-  * The [Traceur](https://github.com/JunoLab/Traceur.jl) package can help you find common performance problems in your code.
+  * The [JET](https://github.com/aviatesk/JET.jl) package can help you find common performance problems in your code.
   * Unexpectedly-large memory allocations--as reported by [`@time`](@ref), [`@allocated`](@ref), or
     the profiler (through calls to the garbage-collection routines)--hint that there might be issues
     with your code. If you don't see another reason for the allocations, suspect a type problem.

From e2b31cdb9f45b516fadbe39efc5adc29489de1ec Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Sat, 6 Jan 2024 20:20:50 -0800
Subject: [PATCH 0564/1315] Guard against `nothing` appearing from
 `load_package()` (#52788)

---
 base/loading.jl | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/base/loading.jl b/base/loading.jl
index fdb6b0e8fff57..d13b0176d721b 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1996,6 +1996,11 @@ function warn_if_already_loaded_different(uuidkey::PkgId)
     pkgorig = get(pkgorigins, uuidkey, nothing)
     if pkgorig !== nothing && pkgorig.path !== nothing
         new_path = locate_package(uuidkey)
+
+        # new_path can be `nothing` if `uuidkey` is not loadable in this environment
+        if new_path === nothing
+            return
+        end
         if !samefile(fixup_stdlib_path(pkgorig.path), new_path)
             if isnothing(pkgorig.version)
                 v = get_pkgversion_from_path(dirname(dirname(pkgorig.path)))

From 1205874b61c2a3ebdcfe5ed569c2fd30eb1f7341 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Sun, 7 Jan 2024 17:55:10 +0530
Subject: [PATCH 0565/1315] Incorporated suggestions as per documentation style

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 2fd2a73a59271..93609eec3d5af 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -99,16 +99,30 @@ Standard word size on the current machine, in bits.
 const WORD_SIZE = Core.sizeof(Int) * 8
 
 global SC_CLK_TCK::Clong
+
 """
     Sys.CPU_NAME::String
 
 A string representing the name of CPU.
+
+# Examples
+```jldoctest
+julia> Sys.CPU_NAME
+"tigerlake"
+```
 """
 global CPU_NAME::String
+
 """
     Sys.JIT::String
 
 A string representing the specific Just-In-Time (JIT) compiler being utilized in the current runtime.
+
+# Examples
+```jldoctest
+julia> Sys.JIT
+"ORCJIT"
+```
 """
 global JIT::String
 
@@ -212,16 +226,12 @@ function _cpu_summary(io::IO, cpu::AbstractVector{CPUinfo}, i, j)
     end
     println(io)
 end
-"""
-    Sys.cpu_summary()
 
-Prints a summary of CPU information, organizing and displaying aggregated data for CPUs with the same model.
+"""
+    Sys.cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo}=cpu_info())
 
-# Arguments
-- `io::IO`: Output stream where the summary will be printed (default is `stdout`).
-- `cpu::AbstractVector{CPUinfo}`: Vector of `CPUinfo` objects containing detailed information about each CPU (default is obtained from `cpu_info()`).
+Print a summary of CPU information, organizing and displaying aggregated data for CPUs with the same model.
 
-# Output
 The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.
 """
@@ -236,22 +246,18 @@ function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())
     end
     _cpu_summary(io, cpu, first, length(cpu))
 end
+
 """
     Sys.cpu_info()
 
-Retrieves detailed information about the CPUs on the current system.
+Return a vector of `CPUinfo` objects, where each object represent information about a CPU core.
 
 The function provides information about each CPU, including model, speed, and usage statistics such as user time, nice time, system time, idle time, and interrupt time.
-
-# Returns
-- A vector of `CPUinfo` objects, where each object represents information about a CPU core.
-
-# CPUinfo Type
 The `CPUinfo` type is a mutable struct with the following fields:
 - `model::String`: CPU model information.
 - `speed::Int32`: CPU speed.
 - `cpu_times!user::UInt64`: Time spent in user mode. CPU state shows CPU time used by user space processes.
-- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks. 
+- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks.
 - `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel.
 - `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used.
 - `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts.

From 5cd61ec37e63415ff48ba52633f50894876d3b59 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Sun, 7 Jan 2024 04:39:21 -0800
Subject: [PATCH 0566/1315] Switch `already_warned_path_change_pkgs` to
 `Set{PkgId}()` (#52789)

---
 base/loading.jl | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index d13b0176d721b..de91ac0a433a2 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1989,13 +1989,19 @@ function __require_prelocked(uuidkey::PkgId, env=nothing)
     return newm
 end
 
-const already_warned_path_change_pkgs = Set{UUID}()
+const already_warned_path_change_pkgs = Set{PkgId}()
 # warns if the loaded version of a module is different to the one that locate_package wants to load
 function warn_if_already_loaded_different(uuidkey::PkgId)
-    uuidkey.uuid ∈ already_warned_path_change_pkgs && return
+    uuidkey ∈ already_warned_path_change_pkgs && return
     pkgorig = get(pkgorigins, uuidkey, nothing)
     if pkgorig !== nothing && pkgorig.path !== nothing
-        new_path = locate_package(uuidkey)
+        # `locate_package()` can throw an error; if that happens just skip
+        local new_path
+        try
+            new_path = locate_package(uuidkey)
+        catch
+            return
+        end
 
         # new_path can be `nothing` if `uuidkey` is not loadable in this environment
         if new_path === nothing
@@ -2027,10 +2033,7 @@ function warn_if_already_loaded_different(uuidkey::PkgId)
                 end
             end
             @warn warnstr
-            # Toplevel modules have a `uuid` of `Nothing`
-            if uuidkey.uuid !== nothing
-                push!(already_warned_path_change_pkgs, uuidkey.uuid)
-            end
+            push!(already_warned_path_change_pkgs, uuidkey)
         end
     end
 end

From d70aa64b8e6a6c5dd302d9a1679ab8a6da2739cc Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Sun, 7 Jan 2024 18:25:22 +0530
Subject: [PATCH 0567/1315] Removed Jldoctest

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 93609eec3d5af..bc8c2a973364e 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -106,7 +106,7 @@ global SC_CLK_TCK::Clong
 A string representing the name of CPU.
 
 # Examples
-```jldoctest
+```
 julia> Sys.CPU_NAME
 "tigerlake"
 ```
@@ -119,7 +119,7 @@ global CPU_NAME::String
 A string representing the specific Just-In-Time (JIT) compiler being utilized in the current runtime.
 
 # Examples
-```jldoctest
+```
 julia> Sys.JIT
 "ORCJIT"
 ```

From 9bf84d4d73c1baddc1639331fcdefa7f6fba11c0 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sun, 7 Jan 2024 10:22:16 -0500
Subject: [PATCH 0568/1315] REPL: make alt-m on an empty prompt go to previous
 module (#52670)

---
 NEWS.md                       |  3 ++-
 stdlib/REPL/docs/src/index.md |  9 +++++++--
 stdlib/REPL/src/LineEdit.jl   | 16 ++++++++++++----
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 2c1da218c1f65..34e69535374b0 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -139,7 +139,8 @@ Standard library changes
 
 * Tab complete hints now show in lighter text while typing in the repl. To disable
   set `Base.active_repl.options.hint_tab_completes = false` ([#51229]).
-* Meta-M with an empty prompt now returns the contextual module of the REPL to `Main`.
+* Meta-M with an empty prompt now toggles the contextual module between the previous non-Main
+  contextual module and Main so that switching back and forth is simple. ([#51616], [#52670])
 
 #### SuiteSparse
 
diff --git a/stdlib/REPL/docs/src/index.md b/stdlib/REPL/docs/src/index.md
index ae444e134ad17..0f2441f13cc69 100644
--- a/stdlib/REPL/docs/src/index.md
+++ b/stdlib/REPL/docs/src/index.md
@@ -578,8 +578,9 @@ Main
 
 It is possible to change this contextual module via the function
 `REPL.activate(m)` where `m` is a `Module` or by typing the module in the REPL
-and pressing the keybinding Alt-m (the cursor must be on the module name). The `Main` module can be "activated" with an empty prompt plus the keybinding. The
-active module is shown in the prompt (unless it is `Main`):
+and pressing the keybinding Alt-m with the cursor on the module name (Esc-m on MacOS).
+Pressing the keybinding on an empty prompt toggles the context between the previously active
+non-`Main` module and `Main`. The active module is shown in the prompt (unless it is `Main`):
 
 ```julia-repl
 julia> using REPL
@@ -602,6 +603,10 @@ julia> Core<Alt-m> # using the keybinding to change module
 (Core) julia> <Alt-m> # going back to Main via keybinding
 
 julia>
+
+julia> <Alt-m> # going back to previously-active Core via keybinding
+
+(Core) julia>
 ```
 
 Functions that take an optional module argument often defaults to the REPL
diff --git a/stdlib/REPL/src/LineEdit.jl b/stdlib/REPL/src/LineEdit.jl
index 709eeaa2857d0..c0f6ed5eabdd2 100644
--- a/stdlib/REPL/src/LineEdit.jl
+++ b/stdlib/REPL/src/LineEdit.jl
@@ -1477,11 +1477,13 @@ end
 
 current_word_with_dots(s::MIState) = current_word_with_dots(buffer(s))
 
+previous_active_module = Main
+
 function activate_module(s::MIState)
     word = current_word_with_dots(s);
-    mod = if isempty(word)
-        edit_insert(s, ' ') # makes the `edit_clear` below actually update the prompt
-        Main
+    empty = isempty(word)
+    mod = if empty
+        previous_active_module
     else
         try
             Base.Core.eval(Base.active_module(), Base.Meta.parse(word))
@@ -1489,10 +1491,16 @@ function activate_module(s::MIState)
             nothing
         end
     end
-    if !(mod isa Module)
+    if !(mod isa Module) || mod == Base.active_module()
         beep(s)
         return
     end
+    empty && edit_insert(s, ' ') # makes the `edit_clear` below actually update the prompt
+    if Base.active_module() == Main || mod == Main
+        # At least one needs to be Main. Disallows toggling between two non-Main modules because it's
+        # otherwise hard to get back to Main
+        global previous_active_module = Base.active_module()
+    end
     REPL.activate(mod)
     edit_clear(s)
 end

From 05992e767be9500b18384aa8b77330c93f5a6ee1 Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Sun, 7 Jan 2024 19:33:27 +0100
Subject: [PATCH 0569/1315] Enable rational division with uniform scaling
 (#52785)

---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl   | 2 +-
 stdlib/LinearAlgebra/src/uniformscaling.jl  | 1 +
 stdlib/LinearAlgebra/test/uniformscaling.jl | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index a80c8d0600a78..bace428c1387c 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -7,7 +7,7 @@ functionality.
 """
 module LinearAlgebra
 
-import Base: \, /, *, ^, +, -, ==
+import Base: \, /, //, *, ^, +, -, ==
 import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, asec, asech,
     asin, asinh, atan, atanh, axes, big, broadcast, cbrt, ceil, cis, collect, conj, convert,
     copy, copyto!, copymutable, cos, cosh, cot, coth, csc, csch, eltype, exp, fill!, floor,
diff --git a/stdlib/LinearAlgebra/src/uniformscaling.jl b/stdlib/LinearAlgebra/src/uniformscaling.jl
index 47a282b91b9ea..5c052df1ff48e 100644
--- a/stdlib/LinearAlgebra/src/uniformscaling.jl
+++ b/stdlib/LinearAlgebra/src/uniformscaling.jl
@@ -270,6 +270,7 @@ end
 /(v::AbstractVector, J::UniformScaling) = reshape(v, length(v), 1) / J
 
 /(J::UniformScaling, x::Number) = UniformScaling(J.λ/x)
+//(J::UniformScaling, x::Number) = UniformScaling(J.λ//x)
 
 \(J1::UniformScaling, J2::UniformScaling) = J1.λ == 0 ? throw(SingularException(1)) : UniformScaling(J1.λ\J2.λ)
 \(J::UniformScaling, A::AbstractVecOrMat) = J.λ == 0 ? throw(SingularException(1)) : J.λ\A
diff --git a/stdlib/LinearAlgebra/test/uniformscaling.jl b/stdlib/LinearAlgebra/test/uniformscaling.jl
index 975cbf7bc59bc..6719714049b1e 100644
--- a/stdlib/LinearAlgebra/test/uniformscaling.jl
+++ b/stdlib/LinearAlgebra/test/uniformscaling.jl
@@ -152,6 +152,7 @@ end
     @test α.\UniformScaling(α) == UniformScaling(1.0)
     @test α * UniformScaling(1.0) == UniformScaling(1.0) * α
     @test UniformScaling(α)/α == UniformScaling(1.0)
+    @test 2I//3 == (2//3)*I
     @test (2I)^α == (2I).^α == (2^α)I
 
     β = rand()

From 1d3dd859ff8e5fd5dc73e15b926e200a5aec2c63 Mon Sep 17 00:00:00 2001
From: Milan Bouchet-Valat <nalimilan@club.fr>
Date: Sun, 7 Jan 2024 23:06:46 +0100
Subject: [PATCH 0570/1315] Use `ismissing(x)` instead of `x === missing`
 (#44407)

This is more generic and will allow packages to define custom
`missing`-like types allowing to distinguish several kinds of
missing values like in e.g. Stata and SAS (see
https://github.com/nalimilan/TypedMissings.jl). This should have no
performance impact now thanks to #38905.
---
 base/missing.jl | 34 +++++++++++++++++-----------------
 test/missing.jl | 26 ++++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 17 deletions(-)

diff --git a/base/missing.jl b/base/missing.jl
index 35e1b4034643c..ce174edc297e3 100644
--- a/base/missing.jl
+++ b/base/missing.jl
@@ -241,7 +241,7 @@ function iterate(itr::SkipMissing, state...)
     y = iterate(itr.x, state...)
     y === nothing && return nothing
     item, state = y
-    while item === missing
+    while ismissing(item)
         y = iterate(itr.x, state)
         y === nothing && return nothing
         item, state = y
@@ -251,12 +251,12 @@ end
 
 IndexStyle(::Type{<:SkipMissing{T}}) where {T} = IndexStyle(T)
 eachindex(itr::SkipMissing) =
-    Iterators.filter(i -> @inbounds(itr.x[i]) !== missing, eachindex(itr.x))
+    Iterators.filter(i -> !ismissing(@inbounds(itr.x[i])), eachindex(itr.x))
 keys(itr::SkipMissing) =
-    Iterators.filter(i -> @inbounds(itr.x[i]) !== missing, keys(itr.x))
+    Iterators.filter(i -> !ismissing(@inbounds(itr.x[i])), keys(itr.x))
 @propagate_inbounds function getindex(itr::SkipMissing, I...)
     v = itr.x[I...]
-    v === missing && throw(MissingException(LazyString("the value at index ", I, " is missing")))
+    ismissing(v) && throw(MissingException(LazyString("the value at index ", I, " is missing")))
     v
 end
 
@@ -280,18 +280,18 @@ function _mapreduce(f, op, ::IndexLinear, itr::SkipMissing{<:AbstractArray})
     ilast = last(inds)
     for outer i in i:ilast
         @inbounds ai = A[i]
-        ai !== missing && break
+        !ismissing(ai) && break
     end
-    ai === missing && return mapreduce_empty(f, op, eltype(itr))
+    ismissing(ai) && return mapreduce_empty(f, op, eltype(itr))
     a1::eltype(itr) = ai
     i == typemax(typeof(i)) && return mapreduce_first(f, op, a1)
     i += 1
     ai = missing
     for outer i in i:ilast
         @inbounds ai = A[i]
-        ai !== missing && break
+        !ismissing(ai) && break
     end
-    ai === missing && return mapreduce_first(f, op, a1)
+    ismissing(ai) && return mapreduce_first(f, op, a1)
     # We know A contains at least two non-missing entries: the result cannot be nothing
     something(mapreduce_impl(f, op, itr, first(inds), last(inds)))
 end
@@ -309,7 +309,7 @@ mapreduce_impl(f, op, A::SkipMissing, ifirst::Integer, ilast::Integer) =
         return nothing
     elseif ifirst == ilast
         @inbounds a1 = A[ifirst]
-        if a1 === missing
+        if ismissing(a1)
             return nothing
         else
             return Some(mapreduce_first(f, op, a1))
@@ -320,25 +320,25 @@ mapreduce_impl(f, op, A::SkipMissing, ifirst::Integer, ilast::Integer) =
         i = ifirst
         for outer i in i:ilast
             @inbounds ai = A[i]
-            ai !== missing && break
+            !ismissing(ai) && break
         end
-        ai === missing && return nothing
+        ismissing(ai) && return nothing
         a1 = ai::eltype(itr)
         i == typemax(typeof(i)) && return Some(mapreduce_first(f, op, a1))
         i += 1
         ai = missing
         for outer i in i:ilast
             @inbounds ai = A[i]
-            ai !== missing && break
+            !ismissing(ai) && break
         end
-        ai === missing && return Some(mapreduce_first(f, op, a1))
+        ismissing(ai) && return Some(mapreduce_first(f, op, a1))
         a2 = ai::eltype(itr)
         i == typemax(typeof(i)) && return Some(op(f(a1), f(a2)))
         i += 1
         v = op(f(a1), f(a2))
         @simd for i = i:ilast
             @inbounds ai = A[i]
-            if ai !== missing
+            if !ismissing(ai)
                 v = op(v, f(ai))
             end
         end
@@ -384,7 +384,7 @@ julia> filter(isodd, skipmissing(x))
 function filter(f, itr::SkipMissing{<:AbstractArray})
     y = similar(itr.x, eltype(itr), 0)
     for xi in itr.x
-        if xi !== missing && f(xi)
+        if !ismissing(xi) && f(xi)
             push!(y, xi)
         end
     end
@@ -450,7 +450,7 @@ ERROR: `b` is still missing
 macro coalesce(args...)
     expr = :(missing)
     for arg in reverse(args)
-        expr = :((val = $arg) !== missing ? val : $expr)
+        expr = :(!ismissing((val = $(esc(arg));)) ? val : $expr)
     end
-    return esc(:(let val; $expr; end))
+    return :(let val; $expr; end)
 end
diff --git a/test/missing.jl b/test/missing.jl
index 36155eb32fe49..342ed5a8b8971 100644
--- a/test/missing.jl
+++ b/test/missing.jl
@@ -651,3 +651,29 @@ for func in (round, ceil, floor, trunc)
         @test Core.Compiler.is_foldable(Base.infer_effects(func, (Type{Int},Union{Int,Missing})))
     end
 end
+
+@testset "Custom Missing type" begin
+    struct NewMissing end
+    Base.ismissing(::NewMissing) = true
+    Base.coalesce(x::NewMissing, y...) = coalesce(y...)
+    Base.isless(::NewMissing, ::NewMissing) = false
+    Base.isless(::NewMissing, ::Any) = false
+    Base.isless(::Any, ::NewMissing) = true
+    Base.isequal(::NewMissing, ::Missing) = true
+    Base.isequal(::Missing, ::NewMissing) = true
+    arr = [missing 1 2 3 missing 10 11 12 missing]
+    newarr = Union{Int, NewMissing}[ismissing(v) ? NewMissing() : v for v in arr]
+
+    @test all(skipmissing(arr) .== skipmissing(newarr))
+    @test all(eachindex(skipmissing(arr)) .== eachindex(skipmissing(newarr)))
+    @test all(keys(skipmissing(arr)) .== keys(skipmissing(newarr)))
+    @test_broken sum(skipmissing(arr)) == sum(skipmissing(newarr))
+    @test filter(>(10), skipmissing(arr)) == filter(>(10), skipmissing(newarr))
+    @test isequal(sort(vec(arr)), sort(vec(newarr)))
+
+    @test_throws MissingException skipmissing(newarr)[findfirst(ismissing, newarr)]
+    @test coalesce(NewMissing(), 1) == coalesce(NewMissing(), NewMissing(), 1) == 1
+    @test coalesce(NewMissing()) === coalesce(NewMissing(), NewMissing()) === missing
+    @test @coalesce(NewMissing(), 1) == @coalesce(NewMissing(), NewMissing(), 1) == 1
+    @test @coalesce(NewMissing()) === @coalesce(NewMissing(), NewMissing()) === missing
+end

From edd22237db544c234b6169c086b2f9fe4411f28a Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sun, 7 Jan 2024 19:32:07 -0500
Subject: [PATCH 0571/1315] Revert "Warn if an already loaded package is
 attempted to be loaded from a different path" (#52794)

---
 base/loading.jl | 52 -------------------------------------------------
 1 file changed, 52 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index de91ac0a433a2..0b5d6fe2f39d5 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1508,7 +1508,6 @@ function _tryrequire_from_serialized(modkey::PkgId, build_id::UInt128)
     assert_havelock(require_lock)
     loaded = nothing
     if root_module_exists(modkey)
-        warn_if_already_loaded_different(modkey)
         loaded = root_module(modkey)
     else
         loaded = start_loading(modkey)
@@ -1539,7 +1538,6 @@ function _tryrequire_from_serialized(modkey::PkgId, path::String, ocachepath::Un
     assert_havelock(require_lock)
     loaded = nothing
     if root_module_exists(modkey)
-        warn_if_already_loaded_different(modkey)
         loaded = root_module(modkey)
     else
         loaded = start_loading(modkey)
@@ -1983,61 +1981,11 @@ function __require_prelocked(uuidkey::PkgId, env=nothing)
         # After successfully loading, notify downstream consumers
         run_package_callbacks(uuidkey)
     else
-        warn_if_already_loaded_different(uuidkey)
         newm = root_module(uuidkey)
     end
     return newm
 end
 
-const already_warned_path_change_pkgs = Set{PkgId}()
-# warns if the loaded version of a module is different to the one that locate_package wants to load
-function warn_if_already_loaded_different(uuidkey::PkgId)
-    uuidkey ∈ already_warned_path_change_pkgs && return
-    pkgorig = get(pkgorigins, uuidkey, nothing)
-    if pkgorig !== nothing && pkgorig.path !== nothing
-        # `locate_package()` can throw an error; if that happens just skip
-        local new_path
-        try
-            new_path = locate_package(uuidkey)
-        catch
-            return
-        end
-
-        # new_path can be `nothing` if `uuidkey` is not loadable in this environment
-        if new_path === nothing
-            return
-        end
-        if !samefile(fixup_stdlib_path(pkgorig.path), new_path)
-            if isnothing(pkgorig.version)
-                v = get_pkgversion_from_path(dirname(dirname(pkgorig.path)))
-                cur_vstr = isnothing(v) ? "" : "v$v "
-            else
-                cur_vstr = "v$(pkgorig.version) "
-            end
-            new_v = get_pkgversion_from_path(dirname(dirname(new_path)))
-            new_vstr = isnothing(new_v) ? "" : "v$new_v "
-            warnstr = """
-            $uuidkey is already loaded from a different path:
-              loaded:    $cur_vstr$(repr(pkgorig.path))
-              requested: $new_vstr$(repr(new_path))
-            """
-            if isempty(already_warned_path_change_pkgs)
-                warnstr *= """
-                This might indicate a change of environment has happened between package loads and can mean that
-                incompatible packages have been loaded"""
-                if JLOptions().startupfile < 2 #(0 = auto, 1 = yes)
-                    warnstr *= """. If this happened due to a startup.jl consider starting julia
-                    directly in the project via the `--project` arg."""
-                else
-                    warnstr *= "."
-                end
-            end
-            @warn warnstr
-            push!(already_warned_path_change_pkgs, uuidkey)
-        end
-    end
-end
-
 mutable struct PkgOrigin
     path::Union{String,Nothing}
     cachepath::Union{String,Nothing}

From d07de16f39074c97ab6c70bd2b90320cb2389449 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 7 Jan 2024 20:18:55 -0500
Subject: [PATCH 0572/1315] improve AbstractPipe docs and IOContext handling as
 an AbstractPipe (#52768)

Following some complains that `AbstractPipe` did not mention the
functions that comprise its API, I have updated that and some other
related details of its subtypes.

1. Mention the expected API surface for AbstractPipe
2. Expand the docs for Pipe as well
3. And add better support for explicit type parameters to IOContext.
This gives more options to users, such as creating an explicitly dynamic
`IOContext{IO}(io)` to avoid excess specialization. Any explicitly set
parameter should now be inherited by future `IOContext` constructions
around it, rather than always directly adopting the `typeof(io.io)` type
instead as the new parameter.
---
 base/errorshow.jl |  5 +++--
 base/io.jl        |  9 ++++++++-
 base/show.jl      | 35 ++++++++++++++++++++++-------------
 base/stream.jl    | 19 ++++++++++++++-----
 4 files changed, 47 insertions(+), 21 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index 3666c7daf7080..0433cedc164c0 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -278,7 +278,8 @@ function showerror(io::IO, ex::MethodError)
             f_is_function = true
         end
         print(io, "no method matching ")
-        iob = IOContext(IOBuffer(), io)     # for type abbreviation as in #49795; some, like `convert(T, x)`, should not abbreviate
+        buf = IOBuffer()
+        iob = IOContext(buf, io)     # for type abbreviation as in #49795; some, like `convert(T, x)`, should not abbreviate
         show_signature_function(iob, isa(f, Type) ? Type{f} : typeof(f))
         print(iob, "(")
         for (i, typ) in enumerate(arg_types_param)
@@ -293,7 +294,7 @@ function showerror(io::IO, ex::MethodError)
             end
         end
         print(iob, ")")
-        str = String(take!(unwrapcontext(iob)[1]))
+        str = String(take!(buf))
         str = type_limited_string_from_context(io, str)
         print(io, str)
     end
diff --git a/base/io.jl b/base/io.jl
index fd286297ec090..7d93bc3e6d9c8 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -414,7 +414,14 @@ end
 """
     AbstractPipe
 
-`AbstractPipe` is the abstract supertype for IO pipes that provide for communication between processes.
+`AbstractPipe` is an abstract supertype that exists for the convenience of creating
+pass-through wrappers for other IO objects, so that you only need to implement the
+additional methods relevant to your type. A subtype only needs to implement one or both of
+these methods:
+
+    struct P <: AbstractPipe; ...; end
+    pipe_reader(io::P) = io.out
+    pipe_writer(io::P) = io.in
 
 If `pipe isa AbstractPipe`, it must obey the following interface:
 
diff --git a/base/show.jl b/base/show.jl
index db0b429f3386f..c74e2789e26ed 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -294,27 +294,35 @@ struct IOContext{IO_t <: IO} <: AbstractPipe
     dict::ImmutableDict{Symbol, Any}
 
     function IOContext{IO_t}(io::IO_t, dict::ImmutableDict{Symbol, Any}) where IO_t<:IO
-        @assert !(IO_t <: IOContext) "Cannot create `IOContext` from another `IOContext`."
+        io isa IOContext && (io = io.io) # implicitly unwrap, since the io.dict field is not useful anymore, and could confuse pipe_reader consumers
         return new(io, dict)
     end
 end
 
-# (Note that TTY and TTYTerminal io types have a :color property.)
-unwrapcontext(io::IO) = io, get(io,:color,false) ? ImmutableDict{Symbol,Any}(:color, true) : ImmutableDict{Symbol,Any}()
-unwrapcontext(io::IOContext) = io.io, io.dict
+# (Note that TTY and TTYTerminal io types have an implied :color property.)
+ioproperties(io::IO) = get(io, :color, false) ? ImmutableDict{Symbol,Any}(:color, true) : ImmutableDict{Symbol,Any}()
+ioproperties(io::IOContext) = io.dict
+# these can probably be deprecated, but there is a use in the ecosystem for them
+unwrapcontext(io::IO) = (io,)
+unwrapcontext(io::IOContext) = (io.io,)
 
-function IOContext(io::IO, dict::ImmutableDict)
-    io0 = unwrapcontext(io)[1]
-    IOContext{typeof(io0)}(io0, dict)
+function IOContext(io::IO, dict::ImmutableDict{Symbol, Any})
+    return IOContext{typeof(io)}(io, dict)
 end
 
-convert(::Type{IOContext}, io::IO) = IOContext(unwrapcontext(io)...)::IOContext
+function IOContext(io::IOContext, dict::ImmutableDict{Symbol, Any})
+    return typeof(io)(io.io, dict)
+end
+
+
+convert(::Type{IOContext}, io::IOContext) = io
+convert(::Type{IOContext}, io::IO) = IOContext(io, ioproperties(io))::IOContext
 
 IOContext(io::IO) = convert(IOContext, io)
 
 function IOContext(io::IO, KV::Pair)
-    io0, d = unwrapcontext(io)
-    IOContext(io0, ImmutableDict{Symbol,Any}(d, KV[1], KV[2]))
+    d = ioproperties(io)
+    return IOContext(io, ImmutableDict{Symbol,Any}(d, KV[1], KV[2]))
 end
 
 """
@@ -322,7 +330,7 @@ end
 
 Create an `IOContext` that wraps an alternate `IO` but inherits the properties of `context`.
 """
-IOContext(io::IO, context::IO) = IOContext(unwrapcontext(io)[1], unwrapcontext(context)[2])
+IOContext(io::IO, context::IO) = IOContext(io, ioproperties(context))
 
 """
     IOContext(io::IO, KV::Pair...)
@@ -2548,7 +2556,8 @@ function show_tuple_as_call(out::IO, name::Symbol, sig::Type;
         return
     end
     tv = Any[]
-    io = IOContext(IOBuffer(), out)
+    buf = IOBuffer()
+    io = IOContext(buf, out)
     env_io = io
     while isa(sig, UnionAll)
         push!(tv, sig.var)
@@ -2591,7 +2600,7 @@ function show_tuple_as_call(out::IO, name::Symbol, sig::Type;
     end
     print_within_stacktrace(io, ")", bold=true)
     show_method_params(io, tv)
-    str = String(take!(unwrapcontext(io)[1]))
+    str = String(take!(buf))
     str = type_limited_string_from_context(out, str)
     print(out, str)
     nothing
diff --git a/base/stream.jl b/base/stream.jl
index 3124b8b0c0a24..542e77ec81cdd 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -743,19 +743,28 @@ mutable struct Pipe <: AbstractPipe
 end
 
 """
-Construct an uninitialized Pipe object.
+    Pipe()
 
-The appropriate end of the pipe will be automatically initialized if
-the object is used in process spawning. This can be useful to easily
-obtain references in process pipelines, e.g.:
+Construct an uninitialized Pipe object, especially for IO communication between multiple processes.
+
+The appropriate end of the pipe will be automatically initialized if the object is used in
+process spawning. This can be useful to easily obtain references in process pipelines, e.g.:
 
 ```
 julia> err = Pipe()
 
 # After this `err` will be initialized and you may read `foo`'s
-# stderr from the `err` pipe.
+# stderr from the `err` pipe, or pass `err` to other pipelines.
 julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)
+
+# Now destroy the write half of the pipe, so that the read half will get EOF
+julia> closewrite(err)
+
+julia> read(err, String)
+"stderr messages"
 ```
+
+See also `Base.link_pipe!`.
 """
 Pipe() = Pipe(PipeEndpoint(), PipeEndpoint())
 pipe_reader(p::Pipe) = p.out

From 8dc2c30f1660f297e15502b9001a1a793c277cb7 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 8 Jan 2024 08:31:08 +0530
Subject: [PATCH 0573/1315] Preserve eltype in converting `Symmetric` to
 `Matrix` (#52738)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This allows cases where the `eltype` differs from that of the parent:
```julia
julia> M = [UpperTriangular([1 2; 3 4]) for i in 1:2, j in 1:2]
2×2 Matrix{UpperTriangular{Int64, Matrix{Int64}}}:
 [1 2; 0 4]  [1 2; 0 4]
 [1 2; 0 4]  [1 2; 0 4]

julia> H = Hermitian(M)
2×2 Hermitian{AbstractMatrix, Matrix{UpperTriangular{Int64, Matrix{Int64}}}}:
 [1 2; 2 4]  [1 2; 0 4]
 [1 0; 2 4]  [1 2; 2 4]

julia> Array(H)
2×2 Matrix{AbstractMatrix}:
 [1 2; 2 4]  [1 2; 0 4]
 [1 0; 2 4]  [1 2; 2 4]
```
This conversion throws an error at present on master.
---
 stdlib/LinearAlgebra/src/symmetric.jl  |  9 ++++-----
 stdlib/LinearAlgebra/test/symmetric.jl | 13 +++++++++++++
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index d48274855a001..38035e09b4375 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -289,21 +289,20 @@ end
 similar(A::Union{Symmetric,Hermitian}, ::Type{T}, dims::Dims{N}) where {T,N} = similar(parent(A), T, dims)
 
 # Conversion
-function Matrix(A::Symmetric)
-    B = copytri!(convert(Matrix, copy(A.data)), A.uplo)
+function Matrix{T}(A::Symmetric) where {T}
+    B = copytri!(convert(Matrix{T}, copy(A.data)), A.uplo)
     for i = 1:size(A, 1)
         B[i,i] = symmetric(A[i,i], sym_uplo(A.uplo))::symmetric_type(eltype(A.data))
     end
     return B
 end
-function Matrix(A::Hermitian)
-    B = copytri!(convert(Matrix, copy(A.data)), A.uplo, true)
+function Matrix{T}(A::Hermitian) where {T}
+    B = copytri!(convert(Matrix{T}, copy(A.data)), A.uplo, true)
     for i = 1:size(A, 1)
         B[i,i] = hermitian(A[i,i], sym_uplo(A.uplo))::hermitian_type(eltype(A.data))
     end
     return B
 end
-Array(A::Union{Symmetric,Hermitian}) = convert(Matrix, A)
 
 parent(A::HermOrSym) = A.data
 Symmetric{T,S}(A::Symmetric{T,S}) where {T,S<:AbstractMatrix{T}} = A
diff --git a/stdlib/LinearAlgebra/test/symmetric.jl b/stdlib/LinearAlgebra/test/symmetric.jl
index f7caed17414d9..b3e0b7b560e7a 100644
--- a/stdlib/LinearAlgebra/test/symmetric.jl
+++ b/stdlib/LinearAlgebra/test/symmetric.jl
@@ -919,4 +919,17 @@ end
     end
 end
 
+@testset "Matrix elements" begin
+    M = [UpperTriangular([1 2; 3 4]) for i in 1:2, j in 1:2]
+    for T in (Symmetric, Hermitian)
+        H = T(M)
+        A = Array(H)
+        @test A isa Matrix
+        @test A == H
+        A = Array{Matrix{Int}}(H)
+        @test A isa Matrix{Matrix{Int}}
+        @test A == H
+    end
+end
+
 end # module TestSymmetric

From 55113b5f6459a8a0f267d55bc777dd5453c120a6 Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Mon, 8 Jan 2024 07:59:46 +0100
Subject: [PATCH 0574/1315] Allow `include()` and `include_dependency()` files
 to resolve to different depots (#52750)

Fixes #52161

#52161 is an awkward use of the relocation feature in the sense that it
attempts to load the `include()` and `include_dependency` files of a pkg
from two separate depots.
The problem there is that the value with which we replace the `@depot`
tag for both `include()` and `include_dependency()` files is determined
by trying to relocate only the `include()` files. We then end up not
finding the `include_dependency()` files.

Solution:
@staticfloat noted that the pkg slugs in depot paths like
`@depot/packages/Foo/1a2b3c/src/Foo.jl` are already enough to (weakly)
content-address a depot.
This means that we should be able to load any `include()` file of a pkg
from any `depot` that contains a precompile cache, provided the hashes
match.
The same logic can be extended to `include_dependency()` files, which
this PR does.

Note that we continue to use only one file from the `include()` files to
determine the depot which we use to relocate all `include()` files.
[this behavior is kept from master]
But for `include_dependency()` files we allow each file to resolve to a
different depot. This way the MWE given in #52161 should be extendable
to two README files being located in two different pkgs that lie in two
different depots.

---

Side note: #49866 started with explicitly verifying that all `include()`
files come from the same depot. In #52346 this was already relaxed to
pick the first depot for which any `include()` file can be resolved to.
This works, because if any other file might be missing from that depot
then this is caught in `stalecache()`.
---
 base/loading.jl       |  60 +++++++++++-----------
 test/Makefile         |   4 +-
 test/precompile.jl    |   3 +-
 test/relocatedepot.jl | 113 ++++++++++++++++++++++++++++++++++--------
 4 files changed, 128 insertions(+), 52 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 0b5d6fe2f39d5..d9aac007f1d9e 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2734,22 +2734,10 @@ function restore_depot_path(path::AbstractString, depot::AbstractString)
     replace(path, r"^@depot" => depot; count=1)
 end
 
-# Find depot in DEPOT_PATH for which all @depot tags from the `includes`
-# can be replaced so that they point to a file on disk each.
-function resolve_depot(includes::Union{AbstractVector,AbstractSet})
-    # `all` because it's possible to have a mixture of includes inside and outside of the depot
-    if all(includes) do inc
-            !startswith(inc, "@depot")
-        end
-        return :fully_outside_depot
-    end
+function resolve_depot(inc::AbstractString)
+    startswith(inc, "@depot") || return :not_relocatable
     for depot in DEPOT_PATH
-        # `any` because it's possible to have a mixture of includes inside and outside of the depot
-        if any(includes) do inc
-                isfile(restore_depot_path(inc, depot))
-            end
-            return depot
-        end
+        isfile(restore_depot_path(inc, depot)) && return depot
     end
     return :no_depot_found
 end
@@ -2837,25 +2825,41 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
     l = read(f, Int32)
     clone_targets = read(f, l)
 
-    # determine path for @depot replacement from srctext files only, e.g. ignore any include_dependency files
     srcfiles = srctext_files(f, srctextpos, includes)
-    depot = resolve_depot(srcfiles)
-    keepidx = Int[]
-    for (i, chi) in enumerate(includes)
-        chi.filename ∈ srcfiles && push!(keepidx, i)
-    end
-    if depot === :no_depot_found
-        @debug("Unable to resolve @depot tag in cache file $cachefile", srcfiles)
-    elseif depot === :fully_outside_depot
-        @debug("All include dependencies in cache file $cachefile are outside of a depot.", srcfiles)
+
+    includes_srcfiles = CacheHeaderIncludes[]
+    includes_depfiles = CacheHeaderIncludes[]
+    for (i, inc) in enumerate(includes)
+        if inc.filename ∈ srcfiles
+            push!(includes_srcfiles, inc)
+        else
+            push!(includes_depfiles, inc)
+        end
+    end
+
+    # determine depot for @depot replacement for include() files and include_dependency() files separately
+    srcfiles_depot = resolve_depot(first(srcfiles))
+    if srcfiles_depot === :no_depot_found
+        @debug("Unable to resolve @depot tag include() files from cache file $cachefile", srcfiles)
+    elseif srcfiles_depot === :not_relocatable
+        @debug("include() files from $cachefile are not relocatable", srcfiles)
     else
-        for inc in includes
+        for inc in includes_srcfiles
+            inc.filename = restore_depot_path(inc.filename, srcfiles_depot)
+        end
+    end
+    for inc in includes_depfiles
+        depot = resolve_depot(inc.filename)
+        if depot === :no_depot_found
+            @debug("Unable to resolve @depot tag for include_dependency() file $(inc.filename) from cache file $cachefile", srcfiles)
+        elseif depot === :not_relocatable
+            @debug("include_dependency() file $(inc.filename) from $cachefile is not relocatable", srcfiles)
+        else
             inc.filename = restore_depot_path(inc.filename, depot)
         end
     end
-    includes_srcfiles_only = includes[keepidx]
 
-    return modules, (includes, includes_srcfiles_only, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags
+    return modules, (includes, includes_srcfiles, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags
 end
 
 function parse_cache_header(cachefile::String)
diff --git a/test/Makefile b/test/Makefile
index c3b877793f4b5..d2d6b39747cae 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -43,7 +43,7 @@ relocatedepot:
 	@cp -R $(SRCDIR)/RelocationTestPkg1 $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg2 $(SRCDIR)/relocatedepot
 	@cd $(SRCDIR) && \
-	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading RELOCATEDEPOT="" JULIA_DEPOT_PATH=$(SRCDIR)/relocatedepot/julia $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
+	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading RELOCATEDEPOT="" $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
 
 revise-relocatedepot: revise-% :
 	@rm -rf $(SRCDIR)/relocatedepot
@@ -54,7 +54,7 @@ revise-relocatedepot: revise-% :
 	@cp -R $(SRCDIR)/RelocationTestPkg1 $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg2 $(SRCDIR)/relocatedepot
 	@cd $(SRCDIR) && \
-	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading RELOCATEDEPOT="" JULIA_DEPOT_PATH=$(SRCDIR)/relocatedepot/julia $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
+	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading RELOCATEDEPOT="" $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
 
 embedding:
 	@$(MAKE) -C $(SRCDIR)/$@ check $(EMBEDDING_ARGS)
diff --git a/test/precompile.jl b/test/precompile.jl
index a717d543bc0ce..d87e86ab4911c 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -436,7 +436,8 @@ precompile_test_harness(false) do dir
         modules, (deps, _, requires), required_modules, _... = Base.parse_cache_header(cachefile)
         discard_module = mod_fl_mt -> mod_fl_mt.filename
         @test modules == [ Base.PkgId(Foo) => Base.module_build_id(Foo) % UInt64 ]
-        @test map(x -> x.filename, deps) == [ Foo_file, joinpath(dir, "foo.jl"), joinpath(dir, "bar.jl") ]
+        # foo.jl and bar.jl are never written to disk, so they are not relocatable
+        @test map(x -> x.filename, deps) == [ Foo_file, joinpath("@depot", "foo.jl"), joinpath("@depot", "bar.jl") ]
         @test requires == [ Base.PkgId(Foo) => Base.PkgId(string(FooBase_module)),
                             Base.PkgId(Foo) => Base.PkgId(Foo2),
                             Base.PkgId(Foo) => Base.PkgId(Test),
diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
index 7aaeda1174e29..2f33b8503670d 100644
--- a/test/relocatedepot.jl
+++ b/test/relocatedepot.jl
@@ -5,10 +5,12 @@ using Logging
 include("testenv.jl")
 
 
-function test_harness(@nospecialize(fn))
+function test_harness(@nospecialize(fn); empty_load_path=true, empty_depot_path=true)
     load_path = copy(LOAD_PATH)
     depot_path = copy(DEPOT_PATH)
     try
+        empty_load_path && empty!(LOAD_PATH)
+        empty_depot_path && empty!(DEPOT_PATH)
         fn()
     finally
         copy!(LOAD_PATH, load_path)
@@ -66,9 +68,9 @@ if !test_relocated_depot
 
     @testset "precompile RelocationTestPkg1" begin
         pkgname = "RelocationTestPkg1"
-        test_harness() do
+        test_harness(empty_depot_path=false) do
             push!(LOAD_PATH, @__DIR__)
-            push!(DEPOT_PATH, @__DIR__)
+            push!(DEPOT_PATH, @__DIR__) # required to make relocatable, but cache is written to DEPOT_PATH[1]
             pkg = Base.identify_package(pkgname)
             cachefiles = Base.find_all_in_cache_path(pkg)
             rm.(cachefiles, force=true)
@@ -80,9 +82,9 @@ if !test_relocated_depot
 
     @testset "precompile RelocationTestPkg2 (contains include_dependency)" begin
         pkgname = "RelocationTestPkg2"
-        test_harness() do
+        test_harness(empty_depot_path=false) do
             push!(LOAD_PATH, @__DIR__)
-            push!(DEPOT_PATH, string(@__DIR__, "/"))
+            push!(DEPOT_PATH, @__DIR__) # required to make relocatable, but cache is written to DEPOT_PATH[1]
             pkg = Base.identify_package(pkgname)
             cachefiles = Base.find_all_in_cache_path(pkg)
             rm.(cachefiles, force=true)
@@ -93,27 +95,94 @@ if !test_relocated_depot
         end
     end
 
-else
-
-    # must come before any of the load tests, because the will recompile and generate new cache files
-    @testset "attempt loading precompiled pkgs when depot is missing" begin
+    @testset "#52161" begin
+        # Take the src files from two pkgs Example1 and Example2,
+        # which are each located in depot1 and depot2, respectively, and
+        # add them as include_dependency()s to a new pkg Foo, which will be precompiled into depot3.
+        # After loading the include_dependency()s of Foo should refer to depot1 depot2 each.
         test_harness() do
-            empty!(LOAD_PATH)
-            push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
-            for pkgname in ("RelocationTestPkg1", "RelocationTestPkg2")
-                pkg = Base.identify_package(pkgname)
-                cachefile = only(Base.find_all_in_cache_path(pkg))
-                @test_throws ArgumentError("""
-                  Failed to determine depot from srctext files in cache file $cachefile.
-                  - Make sure you have adjusted DEPOT_PATH in case you relocated depots.""") Base.isprecompiled(pkg)
+            mktempdir() do depot1
+                # precompile Example in depot1
+                example1_root = joinpath(depot1, "Example1")
+                mkpath(joinpath(example1_root, "src"))
+                open(joinpath(example1_root, "src", "Example1.jl"); write=true) do io
+                    println(io, """
+                    module Example1
+                    greet() = println("Hello from Example1!")
+                    end
+                    """)
+                end
+                open(joinpath(example1_root, "Project.toml"); write=true) do io
+                    println(io, """
+                    name = "Example1"
+                    uuid = "00000000-0000-0000-0000-000000000001"
+                    version = "1.0.0"
+                    """)
+                end
+                pushfirst!(LOAD_PATH, depot1); pushfirst!(DEPOT_PATH, depot1)
+                pkg = Base.identify_package("Example1"); Base.require(pkg)
+                mktempdir() do depot2
+                    # precompile Example in depot2
+                    example2_root = joinpath(depot2, "Example2")
+                    mkpath(joinpath(example2_root, "src"))
+                    open(joinpath(example2_root, "src", "Example2.jl"); write=true) do io
+                        println(io, """
+                        module Example2
+                        greet() = println("Hello from Example2!")
+                        end
+                        """)
+                    end
+                    open(joinpath(example2_root, "Project.toml"); write=true) do io
+                        println(io, """
+                        name = "Example2"
+                        uuid = "00000000-0000-0000-0000-000000000002"
+                        version = "1.0.0"
+                        """)
+                    end
+                    pushfirst!(LOAD_PATH, depot2)
+                    pushfirst!(DEPOT_PATH, depot2)
+                    pkg = Base.identify_package("Example2")
+                    Base.require(pkg)
+                    mktempdir() do depot3
+                        # precompile Foo in depot3
+                        open(joinpath(depot3, "Foo.jl"), write=true) do io
+                            println(io, """
+                            module Foo
+                            using Example1
+                            using Example2
+                            srcfile1 = joinpath(pkgdir(Example1), "src", "Example1.jl")
+                            srcfile2 = joinpath(pkgdir(Example2), "src", "Example2.jl")
+                            @show srcfile1
+                            @show srcfile2
+                            include_dependency(srcfile1)
+                            include_dependency(srcfile2)
+                            end
+                            """)
+                        end
+                        pushfirst!(LOAD_PATH, depot3)
+                        pushfirst!(DEPOT_PATH, depot3)
+                        pkg = Base.identify_package("Foo")
+                        Base.require(pkg)
+                        cachefile = joinpath(depot3, "compiled",
+                                             "v$(VERSION.major).$(VERSION.minor)", "Foo.ji")
+                        _, (deps, _, _), _... = Base.parse_cache_header(cachefile)
+                        @test map(x -> x.filename, deps) ==
+                            [ joinpath(depot3, "Foo.jl"),
+                              joinpath(depot1, "Example1", "src", "Example1.jl"),
+                              joinpath(depot2, "Example2", "src", "Example2.jl") ]
+                    end
+                end
             end
         end
     end
 
+
+else
+
     @testset "load stdlib from test/relocatedepot" begin
         test_harness() do
-            push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
-            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(LOAD_PATH, "@stdlib")
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia"))
             # stdlib should be already precompiled
             pkg = Base.identify_package("DelimitedFiles")
             @test Base.isprecompiled(pkg) == true
@@ -124,7 +193,8 @@ else
         pkgname = "RelocationTestPkg1"
         test_harness() do
             push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
-            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot")) # required to find src files
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
             pkg = Base.identify_package(pkgname)
             @test Base.isprecompiled(pkg) == true
             Base.require(pkg) # re-precompile
@@ -136,7 +206,8 @@ else
         pkgname = "RelocationTestPkg2"
         test_harness() do
             push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
-            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot")) # required to find src files
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
             pkg = Base.identify_package(pkgname)
             @test Base.isprecompiled(pkg) == false # moving depot changes mtime of include_dependency
             Base.require(pkg) # re-precompile

From 0afa354c1f19c7fee7bd3dcb2ccefcb4bca5d85e Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Mon, 8 Jan 2024 03:39:52 -0500
Subject: [PATCH 0575/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20SparseArrays=20stdlib=20from=20f890a1e=20to=2063459e5=20(#52?=
 =?UTF-8?q?792)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: SparseArrays
URL: https://github.com/JuliaSparse/SparseArrays.jl.git
Stdlib branch: main
Julia branch: master
Old commit: f890a1e
New commit: 63459e5
Julia version: 1.11.0-DEV
SparseArrays version: 1.11.0
Bump invoked by: @dkarrasch
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaSparse/SparseArrays.jl/compare/f890a1e13fc04c295cec48a9b08b76c6e1a7039a...63459e5ee9e361dbe7cf260030a7407a1f241430

```
$ git log --oneline f890a1e..63459e5
63459e5 Reduce allocation of dense arrays on-the-fly in linalg tests (#485)
c73d6e3 Reduce number of `*` methods by adopting `matprod_dest` (#484)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 stdlib/SparseArrays.version                                     | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/sha512
 delete mode 100644 deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/md5 b/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/md5
new file mode 100644
index 0000000000000..fb2aeb1b6a051
--- /dev/null
+++ b/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/md5
@@ -0,0 +1 @@
+896b34202308bd40cc9aa26e6bc87c1b
diff --git a/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/sha512 b/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/sha512
new file mode 100644
index 0000000000000..00b98b74501dd
--- /dev/null
+++ b/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/sha512
@@ -0,0 +1 @@
+1ff3b84fb03b76bf2d9d04338e9e82fe1ea9a38bc3da09257666362fe722c6e57a133595fe6aa947c7b539f9d43466ff52ba4ec2027a969e44cf6935c461b751
diff --git a/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/md5 b/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/md5
deleted file mode 100644
index 7ef02b53c633b..0000000000000
--- a/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-bfb7951c370c7cb5dac9139d2b5720ea
diff --git a/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/sha512 b/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/sha512
deleted file mode 100644
index d458020f2b49b..0000000000000
--- a/deps/checksums/SparseArrays-f890a1e13fc04c295cec48a9b08b76c6e1a7039a.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-1228277f51d48f6405ff9f31de6732bce020c2c06b2c768f88e6ff1226a6122fa9f63877228112d8067e0373d370ee26a7404d11948c28c06d4ee951d35407ff
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 00a3f26249c2e..a6b0deb355c0f 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = f890a1e13fc04c295cec48a9b08b76c6e1a7039a
+SPARSEARRAYS_SHA1 = 63459e5ee9e361dbe7cf260030a7407a1f241430
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From 17010098ade9b62f114537ce53dde6749c920479 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 8 Jan 2024 07:12:26 -0500
Subject: [PATCH 0576/1315] REPL: make context switch global typed (#52800)

Followup https://github.com/JuliaLang/julia/pull/52670
---
 stdlib/REPL/src/LineEdit.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/REPL/src/LineEdit.jl b/stdlib/REPL/src/LineEdit.jl
index c0f6ed5eabdd2..01daef9d66899 100644
--- a/stdlib/REPL/src/LineEdit.jl
+++ b/stdlib/REPL/src/LineEdit.jl
@@ -1477,7 +1477,7 @@ end
 
 current_word_with_dots(s::MIState) = current_word_with_dots(buffer(s))
 
-previous_active_module = Main
+previous_active_module::Module = Main
 
 function activate_module(s::MIState)
     word = current_word_with_dots(s);

From 2e70a60a4609625762fb498e75331d890cb7616f Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Mon, 8 Jan 2024 18:20:03 +0530
Subject: [PATCH 0577/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index bc8c2a973364e..73118b366aab8 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -251,6 +251,8 @@ end
     Sys.cpu_info()
 
 Return a vector of `CPUinfo` objects, where each object represent information about a CPU core.
+This is displayed in a tabular format by the REPL, so most users will not need to access the `CPUinfo`
+data structures directly.
 
 The function provides information about each CPU, including model, speed, and usage statistics such as user time, nice time, system time, idle time, and interrupt time.
 The `CPUinfo` type is a mutable struct with the following fields:

From 321f497c6068a3671b0a70761d4c3bffc1a69314 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Mon, 8 Jan 2024 18:20:14 +0530
Subject: [PATCH 0578/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 73118b366aab8..8de9b5ef7a1d2 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -122,7 +122,8 @@ A string representing the specific Just-In-Time (JIT) compiler being utilized in
 ```
 julia> Sys.JIT
 "ORCJIT"
-```
+Currently, this returns `"ORCJIT"` for the LLVM "ORC" ("On-Request Compilation") JIT library:
+```jldoctest
 """
 global JIT::String
 

From 28df075764342fd1b63c509ca797a29374ce26fc Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Mon, 8 Jan 2024 18:20:26 +0530
Subject: [PATCH 0579/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 8de9b5ef7a1d2..95eb6afa934b6 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -231,7 +231,8 @@ end
 """
     Sys.cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo}=cpu_info())
 
-Print a summary of CPU information, organizing and displaying aggregated data for CPUs with the same model.
+Print a summary of CPU information to the `io` stream (defaulting to [`stdout`](@ref)), organizing and displaying aggregated data for CPUs with the same model, for a given array of `CPUinfo` data structures
+describing a set of CPUs (which defaults to the return value of the [`Sys.cpuinfo`](@ref) function).
 
 The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.

From 4e20ecc6a148fa2b6a88e590ee8d64ad8e89b3c3 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Mon, 8 Jan 2024 18:31:24 +0530
Subject: [PATCH 0580/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 95eb6afa934b6..683937a1cef5c 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -119,11 +119,11 @@ global CPU_NAME::String
 A string representing the specific Just-In-Time (JIT) compiler being utilized in the current runtime.
 
 # Examples
-```
-julia> Sys.JIT
-"ORCJIT"
 Currently, this returns `"ORCJIT"` for the LLVM "ORC" ("On-Request Compilation") JIT library:
 ```jldoctest
+julia> Sys.JIT
+"ORCJIT"
+```
 """
 global JIT::String
 

From aab05070bacd185622bfc2ad7bf94f4a4c0ef1d1 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Mon, 8 Jan 2024 18:47:45 +0530
Subject: [PATCH 0581/1315] Suggested Changes

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 683937a1cef5c..d47b754e4fc19 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -106,10 +106,10 @@ global SC_CLK_TCK::Clong
 A string representing the name of CPU.
 
 # Examples
-```
-julia> Sys.CPU_NAME
-"tigerlake"
-```
+For example, `Sys.CPU_NAME` might equal `"tigerlake"` on an 
+[Intel Core "Tiger Lake" CPU](https://en.wikipedia.org/wiki/Tiger_Lake),
+or `"apple-m1"` on an [Apple M1 CPU](https://en.wikipedia.org/wiki/Apple_M1).
+
 """
 global CPU_NAME::String
 
@@ -232,7 +232,7 @@ end
     Sys.cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo}=cpu_info())
 
 Print a summary of CPU information to the `io` stream (defaulting to [`stdout`](@ref)), organizing and displaying aggregated data for CPUs with the same model, for a given array of `CPUinfo` data structures
-describing a set of CPUs (which defaults to the return value of the [`Sys.cpuinfo`](@ref) function).
+describing a set of CPUs (which defaults to the return value of the [`Sys.cpu_info`](@ref) function).
 
 The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.

From b7c24ed67bc42d51ee33da5ed5a97361c49313b8 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Mon, 8 Jan 2024 14:17:47 +0100
Subject: [PATCH 0582/1315] use a Dict instead of an IdDict for caching of the
 `cwstring` for Windows env variables (#52758)

Should fix https://github.com/JuliaLang/julia/issues/52711.

My analysis of the invalidation is as follows:

We added code to cache the conversion to `cwstring` in env handling on
Windows (https://github.com/JuliaLang/julia/pull/51371):

```julia
const env_dict = IdDict{String, Vector{UInt16}}()

function memoized_env_lookup(str::AbstractString)
    ...
    env_dict[str] = cwstring(str)
    ...
end

function access_env(onError::Function, str::AbstractString)
    var = memoized_env_lookup(str)
    ...
end
```

Since `IdDict` has `@nospecialize` on `setindex!` we compile this
method:

```julia
setindex!(::IdDict{String, Vector{UInt16}}, ::Any, ::Any)
```

which has an edge to:

```julia
convert(Type{Vector{Int64}}, Any})
```

But then StaticArrays comes along and adds a method

```julia
convert(::Type{Array{T, N}}, ::StaticArray)
```

which invalidates the `setindex!` (due to the edge to `convert`) which
invalidates the whole env handling on Windows which causes 4k other
methods downstream to be invalidated, in particular, the artifact string
macro which causes a significant delay in the next jll package you load
after loading StaticArrays.

There should be no performance penalty to this since strings already
does a hash for their `objectid`.
---
 base/env.jl | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/base/env.jl b/base/env.jl
index 27594acff6b7f..1bebfd2623e61 100644
--- a/base/env.jl
+++ b/base/env.jl
@@ -3,7 +3,7 @@
 if Sys.iswindows()
     const ERROR_ENVVAR_NOT_FOUND = UInt32(203)
 
-    const env_dict = IdDict{String, Vector{Cwchar_t}}()
+    const env_dict = Dict{String, Vector{Cwchar_t}}()
     const env_lock = ReentrantLock()
 
     function memoized_env_lookup(str::AbstractString)
@@ -11,13 +11,14 @@ if Sys.iswindows()
         # incurred allocations because we had to convert a String to a Vector{Cwchar_t} each time
         # an environment variable was looked up. This function memoizes that lookup process, storing
         # the String => Vector{Cwchar_t} pairs in env_dict
-        var = get(env_dict, str, nothing)
-        if isnothing(var)
-            var = @lock env_lock begin
-                env_dict[str] = cwstring(str)
+        @lock env_lock begin
+            var = get(env_dict, str, nothing)
+            if isnothing(var)
+                var = cwstring(str)
+                env_dict[str] = var
             end
+            return var
         end
-        var
     end
 
     _getenvlen(var::Vector{UInt16}) = ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Ptr{UInt16},Ptr{UInt16},UInt32),var,C_NULL,0)

From cc156d90d05f36944c41275cefc73fecb266bd02 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Mon, 8 Jan 2024 14:20:03 +0100
Subject: [PATCH 0583/1315] Improve type stability in Artifacts code (#52759)

This was in an attempt to fix
https://github.com/JuliaLang/julia/issues/52711 which ultimately proved
unsuccessful. This might however still be useful in other scenarios.

```
using JET
 report_opt(Tuple{typeof(Artifacts._artifact_str), Module, String, Base.SubString{String}, String, Base.Dict{String, Any}, Base.SHA1, Base.BinaryPlatforms.Platform, Any}; target_modules=[Artifacts])
```

is quite a bit cleaner with this.
---
 base/parse.jl                     |  5 +-
 stdlib/Artifacts/src/Artifacts.jl | 87 +++++++++++++++++--------------
 2 files changed, 52 insertions(+), 40 deletions(-)

diff --git a/base/parse.jl b/base/parse.jl
index ab1adb7c30895..3f714934206fc 100644
--- a/base/parse.jl
+++ b/base/parse.jl
@@ -251,8 +251,9 @@ function tryparse(::Type{T}, s::AbstractString; base::Union{Nothing,Integer} = n
 end
 
 function parse(::Type{T}, s::AbstractString; base::Union{Nothing,Integer} = nothing) where {T<:Integer}
-    convert(T, tryparse_internal(T, s, firstindex(s), lastindex(s),
-                                 base===nothing ? 0 : check_valid_base(base), true))
+    v = tryparse_internal(T, s, firstindex(s), lastindex(s), base===nothing ? 0 : check_valid_base(base), true)
+    v === nothing && error("should not happoen")
+    convert(T, v)
 end
 tryparse(::Type{Union{}}, slurp...; kwargs...) = error("cannot parse a value as Union{}")
 
diff --git a/stdlib/Artifacts/src/Artifacts.jl b/stdlib/Artifacts/src/Artifacts.jl
index 348d0d8990f58..b7db79b8ef6b4 100644
--- a/stdlib/Artifacts/src/Artifacts.jl
+++ b/stdlib/Artifacts/src/Artifacts.jl
@@ -67,8 +67,8 @@ function parse_mapping(mapping::String, name::String, override_file::String)
     end
     return mapping
 end
-function parse_mapping(mapping::Dict, name::String, override_file::String)
-    return Dict(k => parse_mapping(v, name, override_file) for (k, v) in mapping)
+function parse_mapping(mapping::Dict{String, Any}, name::String, override_file::String)
+    return Dict{String, Any}(k => parse_mapping(v, name, override_file) for (k, v) in mapping)
 end
 # Fallthrough for invalid Overrides.toml files
 parse_mapping(mapping, name::String, override_file::String) = nothing
@@ -96,7 +96,7 @@ overriding to another artifact by its content-hash.
 const ARTIFACT_OVERRIDES = Ref{Union{Dict{Symbol,Any},Nothing}}(nothing)
 function load_overrides(;force::Bool = false)::Dict{Symbol, Any}
     if ARTIFACT_OVERRIDES[] !== nothing && !force
-        return ARTIFACT_OVERRIDES[]
+        return ARTIFACT_OVERRIDES[]::Dict{Symbol,Any}
     end
 
     # We organize our artifact location overrides into two camps:
@@ -106,13 +106,8 @@ function load_overrides(;force::Bool = false)::Dict{Symbol, Any}
     # Overrides per UUID/bound name are intercepted upon Artifacts.toml load, and new
     # entries within the "hash" overrides are generated on-the-fly.  Thus, all redirects
     # mechanistically happen through the "hash" overrides.
-    overrides = Dict{Symbol,Any}(
-        # Overrides by UUID
-        :UUID => Dict{Base.UUID,Dict{String,Union{String,SHA1}}}(),
-
-        # Overrides by hash
-        :hash => Dict{SHA1,Union{String,SHA1}}(),
-    )
+    overrides_uuid = Dict{Base.UUID,Dict{String,Union{String,SHA1}}}()
+    overrides_hash = Dict{SHA1,Union{String,SHA1}}()
 
     for override_file in reverse(artifacts_dirs("Overrides.toml"))
         !isfile(override_file) && continue
@@ -131,7 +126,6 @@ function load_overrides(;force::Bool = false)::Dict{Symbol, Any}
             # Next, determine if this is a hash override or a UUID/name override
             if isa(mapping, String) || isa(mapping, SHA1)
                 # if this mapping is a direct mapping (e.g. a String), store it as a hash override
-                local hash_str
                 hash = tryparse(Base.SHA1, k)
                 if hash === nothing
                     @error("Invalid override in '$(override_file)': Invalid SHA1 hash '$(k)'")
@@ -139,12 +133,12 @@ function load_overrides(;force::Bool = false)::Dict{Symbol, Any}
                 end
 
                 # If this mapping is the empty string, un-override it
-                if mapping == ""
-                    delete!(overrides[:hash], hash)
+                if mapping isa String && isempty(mapping)
+                    delete!(overrides_hash, hash)
                 else
-                    overrides[:hash][hash] = mapping
+                    overrides_hash[hash] = mapping
                 end
-            elseif isa(mapping, Dict)
+            elseif isa(mapping, Dict{String, Any})
                 # Convert `k` into a uuid
                 uuid = tryparse(Base.UUID, k)
                 if uuid === nothing
@@ -153,19 +147,18 @@ function load_overrides(;force::Bool = false)::Dict{Symbol, Any}
                 end
 
                 # If this mapping is itself a dict, store it as a set of UUID/artifact name overrides
-                ovruuid = overrides[:UUID]::Dict{Base.UUID,Dict{String,Union{String,SHA1}}}
-                if !haskey(ovruuid, uuid)
-                    ovruuid[uuid] = Dict{String,Union{String,SHA1}}()
+                if !haskey(overrides_uuid, uuid)
+                    overrides_uuid[uuid] = Dict{String,Union{String,SHA1}}()
                 end
 
                 # For each name in the mapping, update appropriately
                 for (name, override_value) in mapping
                     # If the mapping for this name is the empty string, un-override it
-                    if override_value == ""
-                        delete!(ovruuid[uuid], name)
+                    if override_value isa String && isempty(override_value)
+                        delete!(overrides_uuid[uuid], name)
                     else
                         # Otherwise, store it!
-                        ovruuid[uuid][name] = override_value
+                        overrides_uuid[uuid][name] = override_value::Union{Base.SHA1, String}
                     end
                 end
             else
@@ -174,6 +167,14 @@ function load_overrides(;force::Bool = false)::Dict{Symbol, Any}
         end
     end
 
+    overrides = Dict{Symbol,Any}(
+        # Overrides by UUID
+        :UUID => overrides_uuid,
+
+        # Overrides by hash
+        :hash => overrides_hash
+    )
+
     ARTIFACT_OVERRIDES[] = overrides
     return overrides
 end
@@ -190,11 +191,13 @@ Query the loaded `<DEPOT>/artifacts/Overrides.toml` settings for artifacts that
 redirected to a particular path or another content-hash.
 """
 function query_override(hash::SHA1; overrides::Dict{Symbol,Any} = load_overrides())
-    return map_override_path(get(overrides[:hash], hash, nothing))
+    overrides_hash = overrides[:hash]::Dict{SHA1,Union{String,SHA1}}
+    return map_override_path(get(overrides_hash, hash, nothing))
 end
 function query_override(pkg::Base.UUID, artifact_name::String; overrides::Dict{Symbol,Any} = load_overrides())
-    if haskey(overrides[:UUID], pkg)
-        return map_override_path(get(overrides[:UUID][pkg], artifact_name, nothing))
+    overrides_uuid = overrides[:UUID]::Dict{Base.UUID,Dict{String,Union{String,SHA1}}}
+    if haskey(overrides_uuid, pkg)
+        return map_override_path(get(overrides_uuid[pkg], artifact_name, nothing))
     end
     return nothing
 end
@@ -284,7 +287,7 @@ function unpack_platform(entry::Dict{String,Any}, name::String,
     delete!(tags, "os")
     delete!(tags, "arch")
     delete!(tags, "git-tree-sha1")
-    return Platform(entry["arch"], entry["os"], tags)
+    return Platform(entry["arch"]::String, entry["os"]::String, tags)
 end
 
 function pack_platform!(meta::Dict, p::AbstractPlatform)
@@ -326,8 +329,11 @@ function process_overrides(artifact_dict::Dict, pkg_uuid::Base.UUID)
     # Insert just-in-time hash overrides by looking up the names of anything we need to
     # override for this UUID, and inserting new overrides for those hashes.
     overrides = load_overrides()
-    if haskey(overrides[:UUID], pkg_uuid)
-        pkg_overrides = overrides[:UUID][pkg_uuid]::Dict{String, <:Any}
+    overrides_uuid = overrides[:UUID]::Dict{Base.UUID,Dict{String,Union{String,SHA1}}}
+    overrides_hash = overrides[:hash]::Dict{SHA1,Union{String,SHA1}}
+
+    if haskey(overrides_uuid, pkg_uuid)
+        pkg_overrides = overrides_uuid[pkg_uuid]::Dict{String, <:Any}
 
         for name in keys(artifact_dict)
             # Skip names that we're not overriding
@@ -336,14 +342,16 @@ function process_overrides(artifact_dict::Dict, pkg_uuid::Base.UUID)
             end
 
             # If we've got a platform-specific friend, override all hashes:
-            if isa(artifact_dict[name], Array)
-                for entry in artifact_dict[name]
-                    hash = SHA1(entry["git-tree-sha1"])
-                    overrides[:hash][hash] = overrides[:UUID][pkg_uuid][name]
+            artifact_dict_name = artifact_dict[name]
+            if isa(artifact_dict_name, Array)
+                for entry in artifact_dict_name
+                    entry = entry::Dict{String,Any}
+                    hash = SHA1(entry["git-tree-sha1"]::String)
+                    overrides_hash[hash] = overrides_uuid[pkg_uuid][name]
                 end
-            elseif isa(artifact_dict[name], Dict)
-                hash = SHA1(artifact_dict[name]["git-tree-sha1"])
-                overrides[:hash][hash] = overrides[:UUID][pkg_uuid][name]
+            elseif isa(artifact_dict_name, Dict{String, Any})
+                hash = SHA1(artifact_dict_name["git-tree-sha1"]::String)
+                overrides_hash[hash] = overrides_uuid[pkg_uuid][name]
             end
         end
     end
@@ -388,7 +396,7 @@ function artifact_meta(name::String, artifact_dict::Dict, artifacts_toml::String
     if isa(meta, Vector)
         dl_dict = Dict{AbstractPlatform,Dict{String,Any}}()
         for x in meta
-            x::Dict{String}
+            x = x::Dict{String, Any}
             dl_dict[unpack_platform(x, name, artifacts_toml)] = x
         end
         meta = select_platform(dl_dict, platform)
@@ -399,9 +407,12 @@ function artifact_meta(name::String, artifact_dict::Dict, artifacts_toml::String
     end
 
     # This is such a no-no, we are going to call it out right here, right now.
-    if meta !== nothing && !haskey(meta, "git-tree-sha1")
-        @error("Invalid artifacts file at $(artifacts_toml): artifact '$name' contains no `git-tree-sha1`!")
-        return nothing
+    if meta !== nothing
+        meta = meta::Dict{String, Any}
+        if !haskey(meta, "git-tree-sha1")
+            @error("Invalid artifacts file at $(artifacts_toml): artifact '$name' contains no `git-tree-sha1`!")
+            return nothing
+        end
     end
 
     # Return the full meta-dict.

From f1a62910179d8ee89f452b2c156e8759de1298f0 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Mon, 8 Jan 2024 18:53:18 +0530
Subject: [PATCH 0584/1315] Removed White Space

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 1 -
 1 file changed, 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index d47b754e4fc19..5afda5577e907 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -109,7 +109,6 @@ A string representing the name of CPU.
 For example, `Sys.CPU_NAME` might equal `"tigerlake"` on an 
 [Intel Core "Tiger Lake" CPU](https://en.wikipedia.org/wiki/Tiger_Lake),
 or `"apple-m1"` on an [Apple M1 CPU](https://en.wikipedia.org/wiki/Apple_M1).
-
 """
 global CPU_NAME::String
 

From e84a16a9c38710b5f545bbcd23cd528750c79860 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Mon, 8 Jan 2024 18:53:22 +0530
Subject: [PATCH 0585/1315] Removed White Space

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 5afda5577e907..e494204f1cabc 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -106,7 +106,7 @@ global SC_CLK_TCK::Clong
 A string representing the name of CPU.
 
 # Examples
-For example, `Sys.CPU_NAME` might equal `"tigerlake"` on an 
+For example, `Sys.CPU_NAME` might equal `"tigerlake"` on an
 [Intel Core "Tiger Lake" CPU](https://en.wikipedia.org/wiki/Tiger_Lake),
 or `"apple-m1"` on an [Apple M1 CPU](https://en.wikipedia.org/wiki/Apple_M1).
 """

From 5643c601f4c9819ed055c111a2d7d14cff6c5f7c Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Mon, 8 Jan 2024 08:38:11 -0500
Subject: [PATCH 0586/1315] fix type-stability bugs in Ryu code (#52781)

Fixes #52749.
---
 base/ryu/exp.jl                | 40 +++++++++++++++++-----------------
 stdlib/Printf/test/runtests.jl |  3 +++
 2 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/base/ryu/exp.jl b/base/ryu/exp.jl
index b38b2c7ae9a29..4f749668867e2 100644
--- a/base/ryu/exp.jl
+++ b/base/ryu/exp.jl
@@ -7,7 +7,7 @@ function writeexp(buf, pos, v::T,
     pos = append_sign(x, plus, space, buf, pos)
 
     # special cases
-    if x == 0
+    if iszero(x)
         @inbounds buf[pos] = UInt8('0')
         pos += 1
         if precision > 0 && !trimtrailingzeros
@@ -42,7 +42,7 @@ function writeexp(buf, pos, v::T,
     mant = bits & MANTISSA_MASK
     exp = Int((bits >> 52) & EXP_MASK)
 
-    if exp == 0
+    if iszero(exp)
         e2 = 1 - 1023 - 52
         m2 = mant
     else
@@ -51,7 +51,7 @@ function writeexp(buf, pos, v::T,
     end
     nonzero = false
     precision += 1
-    digits = 0
+    digits = zero(UInt32)
     printedDigits = 0
     availableDigits = 0
     e = 0
@@ -64,14 +64,14 @@ function writeexp(buf, pos, v::T,
             j = p10bits - e2
             #=@inbounds=# mula, mulb, mulc = POW10_SPLIT[POW10_OFFSET[idx + 1] + i + 1]
             digits = mulshiftmod1e9(m2 << 8, mula, mulb, mulc, j + 8)
-            if printedDigits != 0
+            if !iszero(printedDigits)
                 if printedDigits + 9 > precision
                     availableDigits = 9
                     break
                 end
                 pos = append_nine_digits(digits, buf, pos)
                 printedDigits += 9
-            elseif digits != 0
+            elseif !iszero(digits)
                 availableDigits = decimallength(digits)
                 e = i * 9 + availableDigits - 1
                 if availableDigits > precision
@@ -93,26 +93,26 @@ function writeexp(buf, pos, v::T,
             i -= 1
         end
     end
-    if e2 < 0 && availableDigits == 0
+    if e2 < 0 && iszero(availableDigits)
         idx = div(-e2, 16)
-        i = MIN_BLOCK_2[idx + 1]
+        i = Int(MIN_BLOCK_2[idx + 1])
         while i < 200
             j = 120 + (-e2 - 16 * idx)
             p = POW10_OFFSET_2[idx + 1] + i - MIN_BLOCK_2[idx + 1]
             if p >= POW10_OFFSET_2[idx + 2]
-                digits = 0
+                digits = zero(UInt32)
             else
                 #=@inbounds=# mula, mulb, mulc = POW10_SPLIT_2[p + 1]
                 digits = mulshiftmod1e9(m2 << 8, mula, mulb, mulc, j + 8)
             end
-            if printedDigits != 0
+            if !iszero(printedDigits)
                 if printedDigits + 9 > precision
                     availableDigits = 9
                     break
                 end
                 pos = append_nine_digits(digits, buf, pos)
                 printedDigits += 9
-            elseif digits != 0
+            elseif !iszero(digits)
                 availableDigits = decimallength(digits)
                 e = -(i + 1) * 9 + availableDigits - 1
                 if availableDigits > precision
@@ -135,14 +135,14 @@ function writeexp(buf, pos, v::T,
         end
     end
     maximum = precision - printedDigits
-    if availableDigits == 0
-        digits = 0
+    if iszero(availableDigits)
+        digits = zero(UInt32)
     end
-    lastDigit = 0
+    lastDigit = zero(UInt32)
     if availableDigits > maximum
         for k = 0:(availableDigits - maximum - 1)
-            lastDigit = digits % 10
-            digits = div(digits, 10)
+            lastDigit = digits % UInt32(10)
+            digits = div(digits, UInt32(10))
         end
     end
     roundUp = 0
@@ -159,8 +159,8 @@ function writeexp(buf, pos, v::T,
         end
         roundUp = trailingZeros ? 2 : 1
     end
-    if printedDigits != 0
-        if digits == 0
+    if !iszero(printedDigits)
+        if iszero(digits)
             for _ = 1:maximum
                 @inbounds buf[pos] = UInt8('0')
                 pos += 1
@@ -180,7 +180,7 @@ function writeexp(buf, pos, v::T,
             end
         end
     end
-    if roundUp != 0
+    if !iszero(roundUp)
         roundPos = pos
         while true
             roundPos -= 1
@@ -197,7 +197,7 @@ function writeexp(buf, pos, v::T,
                 roundUp = 1
                 continue
             else
-                if roundUp == 2 && UInt8(c) % 2 == 0
+                if roundUp == 2 && iseven(c)
                     break
                 end
                 @inbounds buf[roundPos] = c + 1
@@ -224,7 +224,7 @@ function writeexp(buf, pos, v::T,
         pos += 1
     end
     if e >= 100
-        c = e % 10
+        c = (e % 10) % UInt8
         @inbounds d100 = DIGIT_TABLE16[div(e, 10) + 1]
         @inbounds buf[pos] = d100 % UInt8
         @inbounds buf[pos + 1] = (d100 >> 0x8) % UInt8
diff --git a/stdlib/Printf/test/runtests.jl b/stdlib/Printf/test/runtests.jl
index 33970f78648e2..71ec369af4ef7 100644
--- a/stdlib/Printf/test/runtests.jl
+++ b/stdlib/Printf/test/runtests.jl
@@ -1145,4 +1145,7 @@ end
     @test_throws Printf.InvalidFormatStringError Printf.Format("%z")
 end
 
+# issue #52749
+@test @sprintf("%.160g", 1.38e-23) == "1.380000000000000060010582465734078799297660966782642624395399644741944111814291318296454846858978271484375e-23"
+
 end # @testset "Printf"

From b354ce7c41f0fd6caa8da115be38c53143a3d548 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Mon, 8 Jan 2024 11:29:29 -0300
Subject: [PATCH 0587/1315] reset mark queue indices at the end of GC (#52780)

Should allow us to access fewer pages on the circular buffers owned by
these work-stealing queues.
---
 src/gc.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/gc.c b/src/gc.c
index 4937463897f31..a876b41490a9b 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -3087,6 +3087,17 @@ void gc_mark_clean_reclaim_sets(void)
             free(a);
         }
     }
+    // Reset queue indices
+    for (int i = 0; i < gc_n_threads; i++) {
+        jl_ptls_t ptls2 = gc_all_tls_states[i];
+        if (ptls2 == NULL) {
+            continue;
+        }
+        jl_atomic_store_relaxed(&ptls2->mark_queue.ptr_queue.bottom, 0);
+        jl_atomic_store_relaxed(&ptls2->mark_queue.ptr_queue.top, 0);
+        jl_atomic_store_relaxed(&ptls2->mark_queue.chunk_queue.bottom, 0);
+        jl_atomic_store_relaxed(&ptls2->mark_queue.chunk_queue.top, 0);
+    }
 }
 
 static void gc_premark(jl_ptls_t ptls2)

From 486f4345ba573c00cf57e8013675d383efb8a0fb Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Tue, 9 Jan 2024 03:32:34 +0600
Subject: [PATCH 0588/1315] Do not let `public` unexport names (#52814)

---
 src/module.c       |  2 +-
 test/reflection.jl | 12 ++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/module.c b/src/module.c
index db1d86aa4a3ce..f44238e45c659 100644
--- a/src/module.c
+++ b/src/module.c
@@ -667,7 +667,7 @@ JL_DLLEXPORT void jl_module_public(jl_module_t *from, jl_sym_t *s, int exported)
 {
     jl_binding_t *b = jl_get_module_binding(from, s, 1);
     b->publicp = 1;
-    b->exportp = exported;
+    b->exportp |= exported;
 }
 
 JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var)
diff --git a/test/reflection.jl b/test/reflection.jl
index d866749e12d34..f81605622a806 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1180,3 +1180,15 @@ let (src, rt) = only(code_typed(sub2ind_gen, (NTuple,Int,Int,); optimize=false))
     @test any(iscall((src,sub2ind_gen_fallback)), src.code)
     @test any(iscall((src,error)), src.code)
 end
+
+# marking a symbol as public should not "unexport" it
+# https://github.com/JuliaLang/julia/issues/52812
+module Mod52812
+export a, b
+public a
+end
+
+@test Base.isexported(Mod52812, :a)
+@test Base.isexported(Mod52812, :b)
+@test Base.ispublic(Mod52812, :a)
+@test Base.ispublic(Mod52812, :b)

From bd3eab649c3ec9d405256afc599f37197f8daec7 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 8 Jan 2024 19:57:52 -0500
Subject: [PATCH 0589/1315] static-show: improve accuracy of some printings
 (#52799)

- Show strings with escaping, rather than trying to output the text
unmodified.
- Show symbols with the same formatting as Strings
- Avoid accidentally defining a broken Core.show method for NamedTuple
---
 base/namedtuple.jl                       |   6 +-
 base/show.jl                             |   2 +-
 src/ast.c                                |  10 +-
 src/flisp/print.c                        |   2 +-
 src/julia.h                              |  10 +-
 src/rtutils.c                            | 137 +++++++++++++++--------
 src/support/utf8.c                       |  15 +--
 src/support/utf8.h                       |   4 +-
 stdlib/InteractiveUtils/test/runtests.jl |   2 +-
 test/show.jl                             |  16 ++-
 10 files changed, 126 insertions(+), 78 deletions(-)

diff --git a/base/namedtuple.jl b/base/namedtuple.jl
index 5d9b119b4c38e..170a6e9349917 100644
--- a/base/namedtuple.jl
+++ b/base/namedtuple.jl
@@ -196,9 +196,8 @@ function convert(::Type{NT}, nt::NamedTuple{names}) where {names, NT<:NamedTuple
 end
 
 if nameof(@__MODULE__) === :Base
-    Tuple(nt::NamedTuple) = (nt...,)
-    (::Type{T})(nt::NamedTuple) where {T <: Tuple} = (t = Tuple(nt); t isa T ? t : convert(T, t)::T)
-end
+Tuple(nt::NamedTuple) = (nt...,)
+(::Type{T})(nt::NamedTuple) where {T <: Tuple} = (t = Tuple(nt); t isa T ? t : convert(T, t)::T)
 
 function show(io::IO, t::NamedTuple)
     n = nfields(t)
@@ -232,6 +231,7 @@ function show(io::IO, t::NamedTuple)
         print(io, ")")
     end
 end
+end
 
 eltype(::Type{T}) where T<:NamedTuple = nteltype(T)
 nteltype(::Type) = Any
diff --git a/base/show.jl b/base/show.jl
index c74e2789e26ed..e6990b231bfba 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1792,7 +1792,7 @@ function show_sym(io::IO, sym::Symbol; allow_macroname=false)
         print(io, '@')
         show_sym(io, Symbol(sym_str[2:end]))
     else
-        print(io, "var", repr(string(sym)))
+        print(io, "var", repr(string(sym))) # TODO: this is not quite right, since repr uses String escaping rules, and Symbol uses raw string rules
     end
 end
 
diff --git a/src/ast.c b/src/ast.c
index 7e7e7fb445e00..8816c905ee101 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -990,7 +990,7 @@ JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
     return expr;
 }
 
-JL_DLLEXPORT int jl_is_operator(char *sym)
+JL_DLLEXPORT int jl_is_operator(const char *sym)
 {
     jl_ast_context_t *ctx = jl_ast_ctx_enter(NULL);
     fl_context_t *fl_ctx = &ctx->fl;
@@ -999,7 +999,7 @@ JL_DLLEXPORT int jl_is_operator(char *sym)
     return res;
 }
 
-JL_DLLEXPORT int jl_is_unary_operator(char *sym)
+JL_DLLEXPORT int jl_is_unary_operator(const char *sym)
 {
     jl_ast_context_t *ctx = jl_ast_ctx_enter(NULL);
     fl_context_t *fl_ctx = &ctx->fl;
@@ -1008,7 +1008,7 @@ JL_DLLEXPORT int jl_is_unary_operator(char *sym)
     return res;
 }
 
-JL_DLLEXPORT int jl_is_unary_and_binary_operator(char *sym)
+JL_DLLEXPORT int jl_is_unary_and_binary_operator(const char *sym)
 {
     jl_ast_context_t *ctx = jl_ast_ctx_enter(NULL);
     fl_context_t *fl_ctx = &ctx->fl;
@@ -1017,7 +1017,7 @@ JL_DLLEXPORT int jl_is_unary_and_binary_operator(char *sym)
     return res;
 }
 
-JL_DLLEXPORT int jl_is_syntactic_operator(char *sym)
+JL_DLLEXPORT int jl_is_syntactic_operator(const char *sym)
 {
     jl_ast_context_t *ctx = jl_ast_ctx_enter(NULL);
     fl_context_t *fl_ctx = &ctx->fl;
@@ -1026,7 +1026,7 @@ JL_DLLEXPORT int jl_is_syntactic_operator(char *sym)
     return res;
 }
 
-JL_DLLEXPORT int jl_operator_precedence(char *sym)
+JL_DLLEXPORT int jl_operator_precedence(const char *sym)
 {
     jl_ast_context_t *ctx = jl_ast_ctx_enter(NULL);
     fl_context_t *fl_ctx = &ctx->fl;
diff --git a/src/flisp/print.c b/src/flisp/print.c
index 2b20d0d98b225..a6f633c2e6701 100644
--- a/src/flisp/print.c
+++ b/src/flisp/print.c
@@ -518,7 +518,7 @@ static void print_string(fl_context_t *fl_ctx, ios_t *f, char *str, size_t sz)
     }
     else {
         while (i < sz) {
-            size_t n = u8_escape(buf, sizeof(buf), str, &i, sz, 1, 0);
+            size_t n = u8_escape(buf, sizeof(buf), str, &i, sz, "\"", 0);
             outsn(fl_ctx, buf, f, n-1);
         }
     }
diff --git a/src/julia.h b/src/julia.h
index 44dc913209c6b..1f5da14c40f58 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -2125,11 +2125,11 @@ JL_DLLEXPORT jl_array_t *jl_uncompress_argnames(jl_value_t *syms);
 JL_DLLEXPORT jl_value_t *jl_uncompress_argname_n(jl_value_t *syms, size_t i);
 
 
-JL_DLLEXPORT int jl_is_operator(char *sym);
-JL_DLLEXPORT int jl_is_unary_operator(char *sym);
-JL_DLLEXPORT int jl_is_unary_and_binary_operator(char *sym);
-JL_DLLEXPORT int jl_is_syntactic_operator(char *sym);
-JL_DLLEXPORT int jl_operator_precedence(char *sym);
+JL_DLLEXPORT int jl_is_operator(const char *sym);
+JL_DLLEXPORT int jl_is_unary_operator(const char *sym);
+JL_DLLEXPORT int jl_is_unary_and_binary_operator(const char *sym);
+JL_DLLEXPORT int jl_is_syntactic_operator(const char *sym);
+JL_DLLEXPORT int jl_operator_precedence(const char *sym);
 
 STATIC_INLINE int jl_vinfo_sa(uint8_t vi)
 {
diff --git a/src/rtutils.c b/src/rtutils.c
index 74f66ae0b1769..a4cfa28039805 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -591,7 +591,7 @@ static size_t jl_show_svec(JL_STREAM *out, jl_svec_t *t, const char *head, const
 JL_DLLEXPORT int jl_id_start_char(uint32_t wc) JL_NOTSAFEPOINT;
 JL_DLLEXPORT int jl_id_char(uint32_t wc) JL_NOTSAFEPOINT;
 
-JL_DLLEXPORT int jl_is_identifier(char *str) JL_NOTSAFEPOINT
+JL_DLLEXPORT int jl_is_identifier(const char *str) JL_NOTSAFEPOINT
 {
     size_t i = 0;
     uint32_t wc = u8_nextchar(str, &i);
@@ -674,22 +674,64 @@ static int is_globfunction(jl_value_t *v, jl_datatype_t *dv, jl_sym_t **globname
     return 0;
 }
 
-static size_t jl_static_show_x_sym_escaped(JL_STREAM *out, jl_sym_t *name) JL_NOTSAFEPOINT
+static size_t jl_static_show_string(JL_STREAM *out, const char *str, size_t len, int wrap) JL_NOTSAFEPOINT
 {
     size_t n = 0;
-
-    char *sn = jl_symbol_name(name);
-    int hidden = 0;
-    if (!(jl_is_identifier(sn) || jl_is_operator(sn))) {
-        hidden = 1;
+    if (wrap)
+        n += jl_printf(out, "\"");
+    if (!u8_isvalid(str, len)) {
+        // alternate print algorithm that preserves data if it's not UTF-8
+        static const char hexdig[] = "0123456789abcdef";
+        for (size_t i = 0; i < len; i++) {
+            uint8_t c = str[i];
+            if (c == '\\' || c == '"' || c == '$')
+                n += jl_printf(out, "\\%c", c);
+            else if (c >= 32 && c < 0x7f)
+                n += jl_printf(out, "%c", c);
+            else
+                n += jl_printf(out, "\\x%c%c", hexdig[c>>4], hexdig[c&0xf]);
+        }
     }
-
-    if (hidden) {
-        n += jl_printf(out, "var\"");
+    else {
+        int special = 0;
+        for (size_t i = 0; i < len; i++) {
+            uint8_t c = str[i];
+            if (c < 32 || c == 0x7f || c == '\\' || c == '"' || c == '$') {
+                special = 1;
+                break;
+            }
+        }
+        if (!special) {
+            jl_uv_puts(out, str, len);
+            n += len;
+        }
+        else {
+            char buf[512];
+            size_t i = 0;
+            while (i < len) {
+                size_t r = u8_escape(buf, sizeof(buf), str, &i, len, "\"$", 0);
+                jl_uv_puts(out, buf, r - 1);
+                n += r - 1;
+            }
+        }
     }
-    n += jl_printf(out, "%s", sn);
-    if (hidden) {
+    if (wrap)
         n += jl_printf(out, "\"");
+    return n;
+}
+
+static size_t jl_static_show_symbol(JL_STREAM *out, jl_sym_t *name) JL_NOTSAFEPOINT
+{
+    size_t n = 0;
+    const char *sn = jl_symbol_name(name);
+    int quoted = !jl_is_identifier(sn) && !jl_is_operator(sn);
+    if (quoted) {
+        n += jl_printf(out, "var");
+        // TODO: this is not quite right, since repr uses String escaping rules, and Symbol uses raw string rules
+        n += jl_static_show_string(out, sn, strlen(sn), 1);
+    }
+    else {
+        n += jl_printf(out, "%s", sn);
     }
     return n;
 }
@@ -807,11 +849,6 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         // Types are printed as a fully qualified name, with parameters, e.g.
         // `Base.Set{Int}`, and function types are printed as e.g. `typeof(Main.f)`
         jl_datatype_t *dv = (jl_datatype_t*)v;
-        jl_sym_t *globname;
-        int globfunc = is_globname_binding(v, dv) && is_globfunction(v, dv, &globname);
-        jl_sym_t *sym = globfunc ? globname : dv->name->name;
-        char *sn = jl_symbol_name(sym);
-        size_t quote = 0;
         if (dv->name == jl_tuple_typename) {
             if (dv == jl_tuple_type)
                 return jl_printf(out, "Tuple");
@@ -844,8 +881,13 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
             return n;
         }
         if (ctx.quiet) {
-            return jl_printf(out, "%s", jl_symbol_name(dv->name->name));
+            return jl_static_show_symbol(out, dv->name->name);
         }
+        jl_sym_t *globname;
+        int globfunc = is_globname_binding(v, dv) && is_globfunction(v, dv, &globname);
+        jl_sym_t *sym = globfunc ? globname : dv->name->name;
+        char *sn = jl_symbol_name(sym);
+        size_t quote = 0;
         if (globfunc) {
             n += jl_printf(out, "typeof(");
         }
@@ -858,7 +900,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
                 quote = 1;
             }
         }
-        n += jl_static_show_x_sym_escaped(out, sym);
+        n += jl_static_show_symbol(out, sym);
         if (globfunc) {
             n += jl_printf(out, ")");
             if (quote) {
@@ -927,9 +969,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
         n += jl_printf(out, "nothing");
     }
     else if (vt == jl_string_type) {
-        n += jl_printf(out, "\"");
-        jl_uv_puts(out, jl_string_data(v), jl_string_len(v)); n += jl_string_len(v);
-        n += jl_printf(out, "\"");
+        n += jl_static_show_string(out, jl_string_data(v), jl_string_len(v), 1);
     }
     else if (v == jl_bottom_type) {
         n += jl_printf(out, "Union{}");
@@ -978,7 +1018,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
                 n += jl_printf(out, ")");
             n += jl_printf(out, "<:");
         }
-        n += jl_static_show_x_sym_escaped(out, var->name);
+        n += jl_static_show_symbol(out, var->name);
         if (showbounds && (ub != (jl_value_t*)jl_any_type || lb != jl_bottom_type)) {
             // show type-var upper bound if it is defined, or if we showed the lower bound
             int ua = jl_is_unionall(ub);
@@ -996,18 +1036,11 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
             n += jl_static_show_x(out, (jl_value_t*)m->parent, depth, ctx);
             n += jl_printf(out, ".");
         }
-        n += jl_printf(out, "%s", jl_symbol_name(m->name));
+        n += jl_static_show_symbol(out, m->name);
     }
     else if (vt == jl_symbol_type) {
-        char *sn = jl_symbol_name((jl_sym_t*)v);
-        int quoted = !jl_is_identifier(sn) && jl_operator_precedence(sn) == 0;
-        if (quoted)
-            n += jl_printf(out, "Symbol(\"");
-        else
-            n += jl_printf(out, ":");
-        n += jl_printf(out, "%s", sn);
-        if (quoted)
-            n += jl_printf(out, "\")");
+        n += jl_printf(out, ":");
+        n += jl_static_show_symbol(out, (jl_sym_t*)v);
     }
     else if (vt == jl_ssavalue_type) {
         n += jl_printf(out, "SSAValue(%" PRIuPTR ")",
@@ -1015,8 +1048,12 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     }
     else if (vt == jl_globalref_type) {
         n += jl_static_show_x(out, (jl_value_t*)jl_globalref_mod(v), depth, ctx);
-        char *name = jl_symbol_name(jl_globalref_name(v));
-        n += jl_printf(out, jl_is_identifier(name) ? ".%s" : ".:(%s)", name);
+        jl_sym_t *name = jl_globalref_name(v);
+        n += jl_printf(out, ".");
+        if (jl_is_operator(jl_symbol_name(name)))
+            n += jl_printf(out, ":(%s)", jl_symbol_name(name));
+        else
+            n += jl_static_show_symbol(out, name);
     }
     else if (vt == jl_gotonode_type) {
         n += jl_printf(out, "goto %" PRIuPTR, jl_gotonode_label(v));
@@ -1050,17 +1087,17 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     else if (vt == jl_expr_type) {
         jl_expr_t *e = (jl_expr_t*)v;
         if (e->head == jl_assign_sym && jl_array_nrows(e->args) == 2) {
-            n += jl_static_show_x(out, jl_exprarg(e,0), depth, ctx);
+            n += jl_static_show_x(out, jl_exprarg(e, 0), depth, ctx);
             n += jl_printf(out, " = ");
-            n += jl_static_show_x(out, jl_exprarg(e,1), depth, ctx);
+            n += jl_static_show_x(out, jl_exprarg(e, 1), depth, ctx);
         }
         else {
-            char sep = ' ';
-            n += jl_printf(out, "Expr(:%s", jl_symbol_name(e->head));
+            n += jl_printf(out, "Expr(");
+            n += jl_static_show_x(out, (jl_value_t*)e->head, depth, ctx);
             size_t i, len = jl_array_nrows(e->args);
             for (i = 0; i < len; i++) {
-                n += jl_printf(out, ",%c", sep);
-                n += jl_static_show_x(out, jl_exprarg(e,i), depth, ctx);
+                n += jl_printf(out, ", ");
+                n += jl_static_show_x(out, jl_exprarg(e, i), depth, ctx);
             }
             n += jl_printf(out, ")");
         }
@@ -1195,7 +1232,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
             }
         }
 
-        n += jl_static_show_x_sym_escaped(out, sym);
+        n += jl_static_show_symbol(out, sym);
 
         if (globfunc) {
             if (quote) {
@@ -1231,8 +1268,14 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
             jl_value_t *names = isnamedtuple ? jl_tparam0(vt) : (jl_value_t*)jl_field_names(vt);
             for (; i < tlen; i++) {
                 if (!istuple) {
-                    jl_value_t *fname = isnamedtuple ? jl_fieldref_noalloc(names, i) : jl_svecref(names, i);
-                    n += jl_printf(out, "%s=", jl_symbol_name((jl_sym_t*)fname));
+                    jl_sym_t *fname = (jl_sym_t*)(isnamedtuple ? jl_fieldref_noalloc(names, i) : jl_svecref(names, i));
+                    if (fname == NULL || !jl_is_symbol(fname))
+                        n += jl_static_show_x(out, (jl_value_t*)fname, depth, ctx);
+                    else if (jl_is_operator(jl_symbol_name(fname)))
+                        n += jl_printf(out, "(%s)", jl_symbol_name(fname));
+                    else
+                        n += jl_static_show_symbol(out, fname);
+                    n += jl_printf(out, "=");
                 }
                 size_t offs = jl_field_offset(vt, i);
                 char *fld_ptr = (char*)v + offs;
@@ -1367,7 +1410,7 @@ size_t jl_static_show_func_sig_(JL_STREAM *s, jl_value_t *type, jl_static_show_c
     if ((jl_nparams(ftype) == 0 || ftype == ((jl_datatype_t*)ftype)->name->wrapper) &&
             ((jl_datatype_t*)ftype)->name->mt != jl_type_type_mt &&
             ((jl_datatype_t*)ftype)->name->mt != jl_nonfunction_mt) {
-        n += jl_printf(s, "%s", jl_symbol_name(((jl_datatype_t*)ftype)->name->mt->name));
+        n += jl_static_show_symbol(s, ((jl_datatype_t*)ftype)->name->mt->name);
     }
     else {
         n += jl_printf(s, "(::");
@@ -1466,10 +1509,10 @@ void jl_log(int level, jl_value_t *module, jl_value_t *group, jl_value_t *id,
         }
         jl_printf(str, "\n@ ");
         if (jl_is_string(file)) {
-            jl_uv_puts(str, jl_string_data(file), jl_string_len(file));
+            jl_static_show_string(str, jl_string_data(file), jl_string_len(file), 0);
         }
         else if (jl_is_symbol(file)) {
-            jl_printf(str, "%s", jl_symbol_name((jl_sym_t*)file));
+            jl_static_show_string(str, jl_symbol_name((jl_sym_t*)file), strlen(jl_symbol_name((jl_sym_t*)file)), 0);
         }
         jl_printf(str, ":");
         jl_static_show(str, line);
diff --git a/src/support/utf8.c b/src/support/utf8.c
index 42a420fb0c499..17dcf5f1efd51 100644
--- a/src/support/utf8.c
+++ b/src/support/utf8.c
@@ -410,7 +410,7 @@ int u8_escape_wchar(char *buf, size_t sz, uint32_t ch)
 }
 
 size_t u8_escape(char *buf, size_t sz, const char *src, size_t *pi, size_t end,
-                 int escape_quotes, int ascii)
+                 const char *escapes, int ascii)
 {
     size_t i = *pi, i0;
     uint32_t ch;
@@ -420,12 +420,9 @@ size_t u8_escape(char *buf, size_t sz, const char *src, size_t *pi, size_t end,
 
     while (i<end && buf<blim) {
         // sz-11: leaves room for longest escape sequence
-        if (escape_quotes && src[i] == '"') {
-            buf += buf_put2c(buf, "\\\"");
-            i++;
-        }
-        else if (src[i] == '\\') {
-            buf += buf_put2c(buf, "\\\\");
+        if ((src[i] == '\\') || (escapes && strchr(escapes, src[i]))) {
+            *buf++ = '\\';
+            *buf++ = src[i];
             i++;
         }
         else {
@@ -571,8 +568,8 @@ int u8_isvalid(const char *str, size_t len)
             return 0;
         // Check for surrogate chars
         if (byt == 0xed && *pnt > 0x9f) return 0;
-	// Check for overlong encoding
-	if (byt == 0xe0 && *pnt < 0xa0) return 0;
+        // Check for overlong encoding
+        if (byt == 0xe0 && *pnt < 0xa0) return 0;
         pnt += 2;
     } else {                        // 4-byte sequence
         // Must have 3 valid continuation characters
diff --git a/src/support/utf8.h b/src/support/utf8.h
index 1d8e31c043838..f1c886e764064 100644
--- a/src/support/utf8.h
+++ b/src/support/utf8.h
@@ -63,7 +63,7 @@ int u8_escape_wchar(char *buf, size_t sz, uint32_t ch);
 
    sz is buf size in bytes. must be at least 12.
 
-   if escape_quotes is nonzero, quote characters will be escaped.
+   if escapes is given, given characters will also be escaped (in addition to \\).
 
    if ascii is nonzero, the output is 7-bit ASCII, no UTF-8 survives.
 
@@ -75,7 +75,7 @@ int u8_escape_wchar(char *buf, size_t sz, uint32_t ch);
    returns number of bytes placed in buf, including a NUL terminator.
 */
 size_t u8_escape(char *buf, size_t sz, const char *src, size_t *pi, size_t end,
-                 int escape_quotes, int ascii);
+                 const char *escapes, int ascii);
 
 /* utility predicates used by the above */
 int octal_digit(char c);
diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index 10dfbd1aca0ed..1309e11280bfa 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -364,7 +364,7 @@ let err = tempname(),
             @test startswith(errstr, """start
                 end
                 Internal error: encountered unexpected error during compilation of f_broken_code:
-                ErrorException(\"unsupported or misplaced expression \"invalid\" in function f_broken_code\")
+                ErrorException(\"unsupported or misplaced expression \\\"invalid\\\" in function f_broken_code\")
                 """) || errstr
             @test !endswith(errstr, "\nend\n") || errstr
         end
diff --git a/test/show.jl b/test/show.jl
index b6106c710931c..3e67155d0acb7 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1462,12 +1462,20 @@ end
 @test static_shown(:+) == ":+"
 @test static_shown(://) == "://"
 @test static_shown(://=) == "://="
-@test static_shown(Symbol("")) == "Symbol(\"\")"
-@test static_shown(Symbol("a/b")) == "Symbol(\"a/b\")"
-@test static_shown(Symbol("a-b")) == "Symbol(\"a-b\")"
+@test static_shown(Symbol("")) == ":var\"\""
+@test static_shown(Symbol("a/b")) == ":var\"a/b\""
+@test static_shown(Symbol("a-b")) == ":var\"a-b\""
 @test static_shown(UnionAll) == "UnionAll"
-
 @test static_shown(QuoteNode(:x)) == ":(:x)"
+@test static_shown(:!) == ":!"
+@test static_shown("\"") == "\"\\\"\""
+@test static_shown("\$") == "\"\\\$\""
+@test static_shown("\\") == "\"\\\\\""
+@test static_shown("a\x80b") == "\"a\\x80b\""
+@test static_shown("a\x80\$\\b") == "\"a\\x80\\\$\\\\b\""
+@test static_shown(GlobalRef(Main, :var"a#b")) == "Main.var\"a#b\""
+@test static_shown(GlobalRef(Main, :+)) == "Main.:(+)"
+@test static_shown((a = 3, ! = 4, var"a b" = 5)) == "(a=3, (!)=4, var\"a b\"=5)"
 
 # PR #38049
 @test static_shown(sum) == "Base.sum"

From 17280b2c4dcaeb5b2cf3605d2347e3a276714a59 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 9 Jan 2024 09:41:45 +0530
Subject: [PATCH 0590/1315] Widen eltype in complex hermitian tridiagonal eigen
 (#52802)

Close #52801 by widening the `eltype` appropriately.
---
 stdlib/LinearAlgebra/src/symmetriceigen.jl  | 10 +++++-----
 stdlib/LinearAlgebra/test/symmetriceigen.jl |  7 +++++++
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/symmetriceigen.jl b/stdlib/LinearAlgebra/src/symmetriceigen.jl
index 246556e88ff02..0c86383685807 100644
--- a/stdlib/LinearAlgebra/src/symmetriceigen.jl
+++ b/stdlib/LinearAlgebra/src/symmetriceigen.jl
@@ -309,12 +309,12 @@ function eigen(A::Hermitian{Complex{T}, <:Tridiagonal}; kwargs...) where {T}
             E = dl
             Er = abs.(E)
         end
-        S = Vector{Complex{T}}(undef, N)
+        S = Vector{eigtype(eltype(A))}(undef, N)
         S[1] = 1
         for i ∈ 1:N-1
-            S[i+1] = iszero(Er[i]) ? one(Complex{T}) : S[i] * sign(E[i])
+            S[i+1] = iszero(Er[i]) ? oneunit(eltype(S)) : S[i] * sign(E[i])
         end
-        B = SymTridiagonal(real(d), Er)
+        B = SymTridiagonal(float.(real.(d)), Er)
         Λ, Φ = eigen(B; kwargs...)
         return Eigen(Λ, Diagonal(S) * Φ)
     end
@@ -322,6 +322,6 @@ end
 
 function eigvals(A::Hermitian{Complex{T}, <:Tridiagonal}; kwargs...) where {T}
     (; dl, d, du) = parent(A)
-    E = A.uplo == 'U' ? abs.(du) : abs.(dl)
-    eigvals(SymTridiagonal(real.(d), E); kwargs...)
+    Er = A.uplo == 'U' ? abs.(du) : abs.(dl)
+    eigvals(SymTridiagonal(float.(real.(d)), Er); kwargs...)
 end
diff --git a/stdlib/LinearAlgebra/test/symmetriceigen.jl b/stdlib/LinearAlgebra/test/symmetriceigen.jl
index e2f475323b292..b3a5472c511f4 100644
--- a/stdlib/LinearAlgebra/test/symmetriceigen.jl
+++ b/stdlib/LinearAlgebra/test/symmetriceigen.jl
@@ -144,4 +144,11 @@ end
     @test e0 ≈ eu
 end
 
+@testset "Hermitian tridiagonal eigen with Complex{Int} elements (#52801)" begin
+    dv, ev = fill(complex(2), 4), fill(3-4im, 3)
+    HT = Hermitian(Tridiagonal(ev, dv, ev))
+    λ, V = eigen(HT)
+    @test HT * V ≈ V * Diagonal(λ)
+end
+
 end # module TestSymmetricEigen

From 4b642035f4b3099bf26984c2914a35604c02647d Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 9 Jan 2024 14:01:44 +0100
Subject: [PATCH 0591/1315] add an error hint for min/max on an iterable
 (#52716)

Inspired by the discussion in
https://discourse.julialang.org/t/max-of-a-vector/108294/15

```julia
julia> max([1,2,3])
ERROR: MethodError: no method matching max(::Vector{Int64})
Finding the maximum element of an iterable is performed with `maximum`.
....
```
---
 base/errorshow.jl | 12 ++++++++++++
 test/errorshow.jl | 10 ++++++++++
 2 files changed, 22 insertions(+)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index 0433cedc164c0..c10d1e25e6e7e 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -1024,6 +1024,18 @@ end
 
 Experimental.register_error_hint(string_concatenation_hint_handler, MethodError)
 
+
+# Display a hint in case the user tries to use the min or max function on an iterable
+function min_max_on_iterable(io, ex, arg_types, kwargs)
+    @nospecialize
+    if (ex.f === max || ex.f === min) && length(arg_types) == 1 && Base.isiterable(only(arg_types))
+        f_correct = ex.f === max ? "maximum" : "minimum"
+        print(io, "\nFinding the $f_correct of an iterable is performed with `$f_correct`.")
+    end
+end
+
+Experimental.register_error_hint(min_max_on_iterable, MethodError)
+
 # ExceptionStack implementation
 size(s::ExceptionStack) = size(s.stack)
 getindex(s::ExceptionStack, i::Int) = s.stack[i]
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 9fd850ff3cdb2..f6a5ccf2a93f9 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -8,6 +8,7 @@ include("testenv.jl")
 # re-register only the error hints that are being tested here (
 Base.Experimental.register_error_hint(Base.noncallable_number_hint_handler, MethodError)
 Base.Experimental.register_error_hint(Base.string_concatenation_hint_handler, MethodError)
+Base.Experimental.register_error_hint(Base.min_max_on_iterable, MethodError)
 
 @testset "SystemError" begin
     err = try; systemerror("reason", Cint(0)); false; catch ex; ex; end::SystemError
@@ -998,6 +999,15 @@ let err_str
     @test occursin("String concatenation is performed with *", err_str)
 end
 
+let err_str
+    err_str = @except_str min([1,2,3]) MethodError
+    @test occursin("Finding the minimum of an iterable is performed with `minimum`.", err_str)
+    err_str = @except_str min((i for i in 1:3)) MethodError
+    @test occursin("Finding the minimum of an iterable is performed with `minimum`.", err_str)
+    err_str = @except_str max([1,2,3]) MethodError
+    @test occursin("Finding the maximum of an iterable is performed with `maximum`.", err_str)
+end
+
 @testset "unused argument names" begin
     g(::Int) = backtrace()
     bt = g(1)

From c0c676b3c8af3078f5cbc7da03acb8eff09f6c1d Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 10 Jan 2024 00:07:05 +0900
Subject: [PATCH 0592/1315] compiler: eliminate `Core.Compiler.` qualifier
 (#52790)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

To avoid symbol name clashes, this commit defines and uses
`partialorder(𝕃::AbstractLattice) = ⊑(𝕃)`. While I have a preference for
a 2-arg binary operator for lattice operations, it's currently
coexisting with a 3-arg version, suggesting that a unification might be
beneficial.
---
 base/compiler/abstractlattice.jl |  9 ++++++---
 base/compiler/ssair/ir.jl        |  2 +-
 base/compiler/tfuncs.jl          | 33 ++++++++++++++++----------------
 3 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/base/compiler/abstractlattice.jl b/base/compiler/abstractlattice.jl
index 18b6a5473abd0..0102a59667c1e 100644
--- a/base/compiler/abstractlattice.jl
+++ b/base/compiler/abstractlattice.jl
@@ -285,9 +285,12 @@ has_extended_unionsplit(::AnyMustAliasesLattice) = true
 has_extended_unionsplit(::JLTypeLattice) = false
 
 # Curried versions
-⊑(lattice::AbstractLattice) = (@nospecialize(a), @nospecialize(b)) -> ⊑(lattice, a, b)
-⊏(lattice::AbstractLattice) = (@nospecialize(a), @nospecialize(b)) -> ⊏(lattice, a, b)
-⋤(lattice::AbstractLattice) = (@nospecialize(a), @nospecialize(b)) -> ⋤(lattice, a, b)
+⊑(𝕃::AbstractLattice) = (@nospecialize(a), @nospecialize(b)) -> ⊑(𝕃, a, b)
+⊏(𝕃::AbstractLattice) = (@nospecialize(a), @nospecialize(b)) -> ⊏(𝕃, a, b)
+⋤(𝕃::AbstractLattice) = (@nospecialize(a), @nospecialize(b)) -> ⋤(𝕃, a, b)
+partialorder(𝕃::AbstractLattice) = ⊑(𝕃)
+strictpartialorder(𝕃::AbstractLattice) = ⊏(𝕃)
+strictneqpartialorder(𝕃::AbstractLattice) = ⋤(𝕃)
 
 # Fallbacks for external packages using these methods
 const fallback_lattice = InferenceLattice(BaseInferenceLattice.instance)
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index c4086ff508773..8029f6c57fb83 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1117,7 +1117,7 @@ function find_ssavalue_uses1(compact::IncrementalCompact)
 end
 
 function _oracle_check(compact::IncrementalCompact)
-    (observed_used_ssas, observed_used_newssas) = Core.Compiler.find_ssavalue_uses1(compact)
+    (observed_used_ssas, observed_used_newssas) = find_ssavalue_uses1(compact)
     for i = 1:length(observed_used_ssas)
         if observed_used_ssas[i] != compact.used_ssas[i]
             return (observed_used_ssas, observed_used_newssas, SSAValue(i))
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 0d15921dbc48e..1cba3e7795c47 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -331,7 +331,7 @@ end
 add_tfunc(Core.ifelse, 3, 3, ifelse_tfunc, 1)
 
 @nospecs function ifelse_nothrow(𝕃::AbstractLattice, cond, x, y)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     return cond ⊑ Bool
 end
 
@@ -380,7 +380,7 @@ function isdefined_nothrow(𝕃::AbstractLattice, argtypes::Vector{Any})
     return isdefined_nothrow(𝕃, argtypes[1], argtypes[2])
 end
 @nospecs function isdefined_nothrow(𝕃::AbstractLattice, x, name)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     isvarargtype(x) && return false
     isvarargtype(name) && return false
     if hasintersect(widenconst(x), Module)
@@ -600,7 +600,8 @@ add_tfunc(svec, 0, INT_INF, @nospecs((𝕃::AbstractLattice, args...)->SimpleVec
     end
     return TypeVar
 end
-@nospecs function typebound_nothrow(b)
+@nospecs function typebound_nothrow(𝕃::AbstractLattice, b)
+    ⊑ = partialorder(𝕃)
     b = widenconst(b)
     (b ⊑ TypeVar) && return true
     if isType(b)
@@ -609,10 +610,10 @@ end
     return false
 end
 @nospecs function typevar_nothrow(𝕃::AbstractLattice, n, lb, ub)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     n ⊑ Symbol || return false
-    typebound_nothrow(lb) || return false
-    typebound_nothrow(ub) || return false
+    typebound_nothrow(𝕃, lb) || return false
+    typebound_nothrow(𝕃, ub) || return false
     return true
 end
 add_tfunc(Core._typevar, 3, 3, typevar_tfunc, 100)
@@ -813,7 +814,7 @@ end
 add_tfunc(typeassert, 2, 2, typeassert_tfunc, 4)
 
 @nospecs function typeassert_nothrow(𝕃::AbstractLattice, v, t)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     # ty, exact = instanceof_tfunc(t, true)
     # return exact && v ⊑ ty
     if (isType(t) && !has_free_typevars(t) && v ⊑ t.parameters[1]) ||
@@ -859,7 +860,7 @@ end
 add_tfunc(isa, 2, 2, isa_tfunc, 1)
 
 @nospecs function isa_nothrow(𝕃::AbstractLattice, obj, typ)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     return typ ⊑ Type
 end
 
@@ -882,7 +883,7 @@ end
 add_tfunc(<:, 2, 2, subtype_tfunc, 10)
 
 @nospecs function subtype_nothrow(𝕃::AbstractLattice, lty, rty)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     return lty ⊑ Type && rty ⊑ Type
 end
 
@@ -981,7 +982,7 @@ end
         isa(name, Const) || return false
     end
 
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
 
     # If we have s00 being a const, we can potentially refine our type-based analysis above
     if isa(s00, Const) || isconstType(s00)
@@ -1340,7 +1341,6 @@ end
     return setfield!_nothrow(𝕃, s00, name, v)
 end
 @nospecs function setfield!_nothrow(𝕃::AbstractLattice, s00, name, v)
-    ⊑ = Core.Compiler.:⊑(𝕃)
     s0 = widenconst(s00)
     s = unwrap_unionall(s0)
     if isa(s, Union)
@@ -1357,6 +1357,7 @@ end
         isconst(s, field) && return false
         isfieldatomic(s, field) && return false # TODO: currently we're only testing for ordering === :not_atomic
         v_expected = fieldtype(s0, field)
+        ⊑ = partialorder(𝕃)
         return v ⊑ v_expected
     end
     return false
@@ -1431,7 +1432,7 @@ add_tfunc(replacefield!, 4, 6, replacefield!_tfunc, 3)
 
 @nospecs function fieldtype_nothrow(𝕃::AbstractLattice, s0, name)
     s0 === Bottom && return true # unreachable
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     if s0 === Any || s0 === Type || DataType ⊑ s0 || UnionAll ⊑ s0
         # We have no idea
         return false
@@ -2090,7 +2091,7 @@ end
     elemtype_expected = memoryref_elemtype(memtype)
     elemtype_expected === Union{} && return false
     # Check that the element type is compatible with the element we're assigning
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     elemtype ⊑ elemtype_expected || return false
     return true
 end
@@ -2149,13 +2150,13 @@ function memoryrefop_builtin_common_nothrow(𝕃::AbstractLattice, argtypes::Vec
 end
 
 @nospecs function memoryref_builtin_common_typecheck(𝕃::AbstractLattice, boundscheck, memtype, order)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     return boundscheck ⊑ Bool && memtype ⊑ GenericMemoryRef && order ⊑ Symbol
 end
 
 # Query whether the given builtin is guaranteed not to throw given the argtypes
 @nospecs function _builtin_nothrow(𝕃::AbstractLattice, f, argtypes::Vector{Any}, rt)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     if f === memoryref
         return memoryref_builtin_common_nothrow(argtypes)
     elseif f === memoryrefoffset
@@ -3108,7 +3109,7 @@ end
 add_tfunc(Core.get_binding_type, 2, 2, get_binding_type_tfunc, 0)
 
 @nospecs function get_binding_type_nothrow(𝕃::AbstractLattice, M, s)
-    ⊑ = Core.Compiler.:⊑(𝕃)
+    ⊑ = partialorder(𝕃)
     return M ⊑ Module && s ⊑ Symbol
 end
 

From b4d857be0c05ce6c7840694d1a0241e67ff9732f Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Wed, 10 Jan 2024 00:17:39 +0530
Subject: [PATCH 0593/1315] [RFC:] Docstring for Unicode module (#52761)

Part of #52725.
Thank you

---------

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 stdlib/Unicode/docs/src/index.md | 4 ++++
 stdlib/Unicode/src/Unicode.jl    | 6 +++++-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/stdlib/Unicode/docs/src/index.md b/stdlib/Unicode/docs/src/index.md
index 2771c8a9f01cc..75cedc188657d 100644
--- a/stdlib/Unicode/docs/src/index.md
+++ b/stdlib/Unicode/docs/src/index.md
@@ -1,6 +1,10 @@
 # Unicode
 
+The `Unicode` module provides essential functionality for managing Unicode characters and strings.
+It includes validation, category determination, normalization, case transformation, and grapheme segmentation, enabling effective Unicode data handling.
+
 ```@docs
+Unicode
 Unicode.julia_chartransform
 Unicode.isassigned
 Unicode.isequal_normalized
diff --git a/stdlib/Unicode/src/Unicode.jl b/stdlib/Unicode/src/Unicode.jl
index 9d86f6f9cbe7b..b9822d0073c73 100644
--- a/stdlib/Unicode/src/Unicode.jl
+++ b/stdlib/Unicode/src/Unicode.jl
@@ -1,5 +1,9 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
-
+"""
+The `Unicode` module provides essential functionality for managing Unicode characters and strings.
+It includes validation, category determination, normalization, case transformation, and grapheme segmentation,
+enabling effective Unicode data handling.
+"""
 module Unicode
 
 export graphemes, isequal_normalized

From dceeafeb783a33fb7cd6a6b197e4db2d9b011065 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 9 Jan 2024 20:06:42 -0500
Subject: [PATCH 0594/1315] InteractiveUtils: avoid side-effect compilation in
 first `@time_imports` print (#52832)

---
 base/loading.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index d9aac007f1d9e..2e766d211ac5d 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1212,13 +1212,13 @@ function run_module_init(mod::Module, i::Int=1)
             cumulative_compile_timing(false);
             comp_time, recomp_time = (cumulative_compile_time_ns() .- compile_elapsedtimes) ./ 1e6
 
-            print(round(elapsedtime, digits=1), " ms $mod.__init__() ")
+            print("$(round(elapsedtime, digits=1)) ms $mod.__init__() ")
             if comp_time > 0
                 printstyled(Ryu.writefixed(Float64(100 * comp_time / elapsedtime), 2), "% compilation time", color = Base.info_color())
             end
             if recomp_time > 0
                 perc = Float64(100 * recomp_time / comp_time)
-                printstyled(" (", perc < 1 ? "<1" : Ryu.writefixed(perc, 0), "% recompilation)", color = Base.warn_color())
+                printstyled(" ($(perc < 1 ? "<1" : Ryu.writefixed(perc, 0))% recompilation)", color = Base.warn_color())
             end
             println()
         end

From 8e4221f676cc0cc242b93389b2f65084931e581c Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Wed, 10 Jan 2024 03:47:02 +0100
Subject: [PATCH 0595/1315] Bump Julia to LLVM 16 (#51720)

Current Status:

- [x] Self test of Julia-GCChecker :: `MissingRoots.c`
- [x] ASAN: `error: <unknown>:0: Cannot represent a difference across
sections`
- [x] x86_64-apple-darwin fails in ranges
- [x] llvmpasses

---------

Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com>
Co-authored-by: Prem Chintalapudi <prem.chintalapudi@gmail.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Tim Besard <tim.besard@gmail.com>
---
 Make.inc                                    |   2 +-
 deps/checksums/clang                        | 216 ++++----
 deps/checksums/lld                          | 216 ++++----
 deps/checksums/llvm                         | 436 ++++++++--------
 deps/clang.version                          |   2 +-
 deps/lld.version                            |   2 +-
 deps/llvm-tools.version                     |   4 +-
 deps/llvm.mk                                |   2 +-
 deps/llvm.version                           |  12 +-
 src/Makefile                                |   4 +
 src/aotcompile.cpp                          |  19 +-
 src/cgutils.cpp                             |  10 +-
 src/clangsa/GCChecker.cpp                   |  16 +-
 src/codegen.cpp                             |  50 +-
 src/jitlayers.cpp                           |  45 +-
 src/jitlayers.h                             |   1 +
 src/julia.h                                 |   1 +
 src/llvm-pass-helpers.cpp                   |   2 +-
 src/llvm-version.h                          |   4 +-
 src/pipeline.cpp                            |  10 +-
 src/processor.h                             |   4 +-
 src/processor_fallback.cpp                  |   2 +-
 src/processor_x86.cpp                       |   6 +-
 src/runtime_intrinsics.c                    |  13 +-
 src/support/win32-clang-ABI-bug/optional    | 531 ++++++++++++++++++++
 stdlib/LLD_jll/Project.toml                 |   6 +-
 stdlib/libLLVM_jll/Project.toml             |   4 +-
 test/clangsa/MissingRoots.c                 |   2 +-
 test/compiler/codegen.jl                    |   6 +-
 test/llvmpasses/julia-simdloop-memoryssa.ll |   6 +-
 test/llvmpasses/names.jl                    |  18 +-
 test/llvmpasses/safepoint_stress.jl         |   2 +-
 32 files changed, 1125 insertions(+), 529 deletions(-)
 create mode 100644 src/support/win32-clang-ABI-bug/optional

diff --git a/Make.inc b/Make.inc
index 9b826ca4a89c8..a6de773b88dcd 100644
--- a/Make.inc
+++ b/Make.inc
@@ -501,7 +501,7 @@ JCPPFLAGS_COMMON  := -fasynchronous-unwind-tables
 JCPPFLAGS_CLANG   := $(JCPPFLAGS_COMMON) -mllvm -enable-tail-merge=0
 JCPPFLAGS_GCC     := $(JCPPFLAGS_COMMON) -fno-tree-tail-merge
 
-JCXXFLAGS_COMMON  := -pipe $(fPIC) -fno-rtti -std=c++14
+JCXXFLAGS_COMMON  := -pipe $(fPIC) -fno-rtti -std=c++17
 JCXXFLAGS_CLANG   := $(JCXXFLAGS_COMMON) -pedantic
 JCXXFLAGS_GCC     := $(JCXXFLAGS_COMMON) -fno-gnu-unique
 
diff --git a/deps/checksums/clang b/deps/checksums/clang
index 78743a32a2956..0786be8219f37 100644
--- a/deps/checksums/clang
+++ b/deps/checksums/clang
@@ -1,108 +1,108 @@
-Clang.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/b064c4494822dc829611629c4f2bd5eb
-Clang.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/6f4fcfebbea9df7964eb6f7b4c33b91baaa2abb03c44e0c51150d894d22d4f99e1ccb6b6f9acfb45f532bbb61e2ff11515d306a56004be46f67d60134259bdfd
-Clang.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/8a17e03287b24b2e9e08a4f753e12fe0
-Clang.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/065a53430ddfc2cf202ad0d18933967af3f4ebe07bd59ac41856d0ea9e67a59f958850b7bb2312f98b1927d5e74bdd9015867145eebd242930a081c58a9bbd19
-Clang.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/d7d43a6f98be3c09c3c5b9cebd6fc930
-Clang.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/290cc24e1278b7e6648d006669bccfec1c41d797718e16c9996588969b7fc9eda360cfa0d2a7d100b0c5e403fabdc77487c11d0a812fe51e9cc2ec2a814192e7
-Clang.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/95036da7fb8a37330ea3a74f721460e7
-Clang.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/7d1df0c6c8514153a7295a75b79f827d724d53542f39773d0572be9cc24d8793ab02e35ca818f17661bd777bae7e346e8318f139e9f141736f10214b80d7461f
-Clang.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/81854d7e53af48122a80448106a5cec9
-Clang.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0744f60891c18a8fdfe8e4c11b827fa42ed98285bb0557837f7b6dafcb1eabcf763d787c4b4b541d0a3e40905008c6e7b2d76d76ac7edf8a470cfc39e635f43d
-Clang.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/e381e3ec37796905cf0d1863f34d316e
-Clang.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/417218e1447ffcdf642d9e28e7ffae98138efafe5292f6dae83cf2490eb89b3cf39cbff5c77b6c442a0e04173f9eb22ff0dbb0469cdfc622f7eefe8bdd65a5ef
-Clang.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/7972214282a5b81512a185e023488970
-Clang.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/01483ffbb7e5878ed95843d8e750ae163018fb7fd2bc044aa42d55024248d17fbc094154968b7297aad6131aa7976630af282be4dbda1b9b6114cd660d8cb075
-Clang.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/22d08b77071e480d81a1e3c0b7ad7f66
-Clang.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/b7e3c2b1cb6f00fe1280b0bb9f72f43e5883df37fc50b750e663845083d7c797f4a4a47c4703169a29a0c70899e92b8f9d861674563164590b4689d7bf39cf4f
-Clang.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/abb72f91e3ee55c95a5364e1ec22c161
-Clang.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/899fb8b9734c0041b524d6e8befe61d7c0980fb697be82297f4c091a71c30e1f56c1f8fd76149853d7f7a4026148d934aef906ef4a35fb00d9dbc51a56bdb5e7
-Clang.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/745d75f7eb0d8b905182f08c0c1f9911
-Clang.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/9f249ad4078fc023874c8d8990b981aef1663828533c41841bb5ed860832fde7f9b37f19d78dcf06bbbff73b24286204a686d051abeada7dc484a1fc5bf8d9ee
-Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d2b4126d32ff0b9e28b85d91feeced15
-Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/d319064266d2d264ffec849d44efddc6f1835058a7a0e33d3e78dd2122ddc18b0303c38a265d86145debfc5cae9b98c3794b447fa688e042bbcb4f75119f9788
-Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/4161a2b194e54c35badc65124a19b81f
-Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/7302ecb2f05b697ad212fe1d3a1d24740d3d5a8bd1b01a61955ba84c1592f80e7ca3b5ceb7b62361ee61eaadec762a2eb7c899c53b7b4e06fccd8c71ab3ead46
-Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/c2d179b7b8d9afd783e9be03f258884b
-Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/4455aed97627d50caaa28624ab15a099b9e174988bddd13ca558e1796791606c25a22689beec358e03d4e2760f6778a2d54a76538e370637169e3b9120e664a8
-Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/c6aa69e3061de0bc80b17108ac89f6d6
-Clang.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/012aa640b4359842081c06c76bf51c208bba6a494e6c8167c1abf57b8a01677376c23917b0bf66edc7afd5dcf83f08090fb5a51ac1604213d6e3ed48bdd64118
-Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/1abf2235894e554d19b1e5372149f38f
-Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/f35cceb0f39dc444435e9db90c6bd8d39adf49cc9c885bc190df051e38c13379e5d5ea5618034763c608abcce06f363c93397fcccc493989f4fdb910e800aa7e
-Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/5ecd609bac911e14fd7e36fef5ad8e65
-Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/d05457ce07abd12eeee5a036742f66ec4dac99190e98e4fa26c7b59d00b5c90a98bfc65352355ccc609ffb7114106f66dfea166de1eff1d3553180c2cc5484c7
-Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/49a60af7a47d4a5ba9838594af44b695
-Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/06bc663411ea5b156fee0deab246abbce42d8c180489cd38cc0a1bfa9c73c4d21e382407decec65750423269bb71c758bf2401788aea884394e8ce40aa75f9bc
-Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/b555bc479f57daae26101118b71e5b9a
-Clang.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/aabe9e63b6f11101d6b9be4c56b945014c49373ddf670346baec1ef255c504341c9c3f8e729684c17df8ca50b108e0f4b2441b7d5b55a8e2afde3934866b5f6c
-Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/5ef0a90f103a00c80c68309b5bcf1f4d
-Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/37266e4253e853b68a41d4ae21e3c6f8b76d9799f8b802d347b8de72e33e529364c4ff48de0e11fabfb85f5d982a3b0fba594f4098f6b428c883fced9767517c
-Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/915cacbf726988039454f100fd007f76
-Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/15bfafb2b04655617190f8ba8cf1f5a92ed277eefb84e22b8ebbe05f19b384cf296db893e2d2abffb1228749c07e3e5a59e42d8becb3c32591970d060beb71db
-Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/dc2c2c78c6446cd17fc55e7499ebd9b5
-Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/a4713dc6fabe3b374632534452a4ffc997588d2e15f4ba08087a9c0dc23b1f447ab5d33557f56eb0523433ce534da2def7de76600021825781d662bfbe09e094
-Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/855f38cf2d8b2761319ed6670897a32a
-Clang.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/eca1511c2eaaca9a538efe2f04f17234dc2c0920d2e4081b7e1b92565000028749f7d379574c636f04754e51baa04c193437e9bf755fcdbbfd5ce3a96c7c5a1e
-Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/8601f1d8e99af31a38e044daeddc3622
-Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/dca2e5434f83ed1829e16e6cf7abed86bdd3251492998bfc808dd117a253a08886234d5e1086bcec76a38f3373ae76a36a4c1a81a1967fda567b95aadbc354c7
-Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/82c18bf06d579467d7eebeb646238b25
-Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/4669a4a7e62af66271259bc15b38dc63e72227097eab35b93d44c483d48205b45403a83fa779c10f926bed2fab1347a73d93956930550194343525e3ff642855
-Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/99f9eb32064c66ad460fbf73d4ec379b
-Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/074773e19ba60ddf152e7a65689bcb2c0ff255813cd4079190ddad14442be698edbf9917a9f042b005a666a879261c026f265309254d2c4e6ac07e85dfefddee
-Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/ab5c8cac975d0348bdab3f55850db1a8
-Clang.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/f8ded9ea7c2209a63349e5ba221adfc76689c1299087680108939474c6bc965506245632788c9af4975b3cf099c9a85e94aa3fdf0f2f139b8462ee2f9b306704
-Clang.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/9cd24f4c1519ed384dbe5a5325943e86
-Clang.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/579177600090fe900edf8e6bd5ab7e8617d74c411769e6726a424492f468c3fa9938101673ee2a13ae1e3ce5b0fc22d74589e4eb6e31e6a411d2f0b50eac05f2
-Clang.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/970230c1742c8005358514ff5c44e6b5
-Clang.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f24e1bf1c92bea7519a6b767c4391566bc80d1668e2562f4c083f7d68b7166e9330b83fa45406129ba3a0caba5ff8d18a90273e9c7992d93f4b915ee54c6f5a9
-Clang.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/6b331d43437f38918216388402529ff4
-Clang.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d302d08b7ed46a7c907a0b04e25947ba0f84e5e12486d3dcd4b0b875e9d686902fffe89eb7db631b9be33606c05b83a13181295bcde45653c6959f7f5c1ba9d8
-Clang.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/46e24960499c926aa047f1b29da282e3
-Clang.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/6efddeb8de7bb9f6245c604c1f80a1a1449278b1b63ac8787b27092713324e4cfb483a03684b7e58e2dd14d15f39fe6e315bd654d2cf788c03b333fe5068ed10
-Clang.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/1540ce6fb7925df9124ebfe27ace9ae1
-Clang.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/9acc77743c34ccab9f362dcd5cdf761ecfc2dc0c7974d3f62b4dde852427de327e9c53981988cf5ebd6c29ea89221d938bfd23783ba64522fcb7bad5cff7f79c
-Clang.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/2bc9b9a0d15a35e7311ea30d6240d04d
-Clang.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/4ec99c6c90a870485bc4eb526bbed1cc1aba5f35f23ff47d32c86e64871806d6ff94244869b14600f82d5e8f0dc91ae307e87d808c3b89ec92b1e9c8519fbec1
-Clang.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/73b8c5fee1a5c1f3a59d75e4ab7482fd
-Clang.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/f4eb27d2dac224585e274ae5bd9012e60c044220d39daa2a46e00da54e8cb26b20f9447f111c71364d05594683773d73fd22e06cacd465c64ce5c0fe0b51eb43
-Clang.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/7c2c723aebc97f0df6a06ab04117e7a6
-Clang.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/e2d28c9a69c7d384cc82c077138fad2f8c87c89ae4400a6ebb468dd8c26695db42e4889542fb91f515cd53d9e7d71859ff7b9614cdbb6a6c6a40a67402737495
-Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/e58dfa6c7f5647eeb320e12b0be71e94
-Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/1817b521f096597b8be1a08ba4cff23725c4191988844423c1ee13c62202093c9fdc677554c8a416e68c2c8efadcf39b7b2011d4ef6662704f2793121827508b
-Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/a617b5275ee7b13a9ca8d45a8a1bbcc4
-Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/074b61e67d6ac161912ac8cba8dad2b5d0daa310dc7a23a91659f9734248c94a31f1a3af97aa02cc3aa8d226bed6cd25d80a4dcd15024b68b417df973a37e59b
-Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2fc553d70042a737fb6f8919ba8c7586
-Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/98a4ac67f40d48c86819ceb5fe7692f367207b039bcaea7068d04137e529c7019d7369f7495ee8aadec66968736e665e81185732da26be12ba06be331f7e9bff
-Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7191ddb4f1263b75b475a4ca7e258dad
-Clang.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/91dc613500fa03aa0f972800ea33a5602b25542314ed47f4e3457aed1d218b14f988f3d6a6a66d0ff14df152aab7df4ff798a5725078edb208c06540e9ec93e2
-Clang.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/5c8b2900fe9fc12db25ee97dcb489f85
-Clang.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/bc7b36f3ba8f7ba3463a36b49f2eed6e5a3683c50f02c2901f6828d0e8ef31e61850aeb2f3668df206703123b34281a1038820be9ea38381a4be1204b5af1325
-Clang.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/f4567028c971108cb7f6970041eb58eb
-Clang.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/9f6f5e65480720bebefd46a207ce32958304ded6f6ba6135ab700ee6263bf9e5fca55cba6eebb9f651fa8b6bd03de5df1bcdcddd17ce33c3b19ef137e998eb20
-Clang.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/6e3487ee5dc66c1d30bc269b53f78176
-Clang.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/0479baed38a2810e0ccb813f00d40c1159acaa54270d7074df364e7d39dcfab524cd83a63b712ed3bd992792eee596a53202ec5363097f019fbaa07a7a5123e6
-Clang.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ac5de702c96c77d8257d72dc003ab347
-Clang.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f74a9ba8cef5cb0fdc4a2229ccd911c4c9f612a6f2446a85fdca13918a034a6e43f365e0b46580a0a0a690c871a07a17ef8cd0d40da74ed210b78de8cfa6c253
-Clang.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/1889148c5bef3f759430f78c9806ffaf
-Clang.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/7e5f5a3834abd1a95b03bc5b2bd095d4c16950d6a67d015d82e7985f5b918cc879ae1197a636ec6582fb71929d392a5758dba48d8a9ab6563454170caeb46421
-Clang.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/1c2833125dea9030c8d36c372367ed4b
-Clang.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/0399915bd90fc8d798494b4eaf21dcc8587b8634003bd0bff0be66f4986587b8fdec3fb324defc3fd2ebf6793db8d3444e1188d2d300b8b1aacd3d1eb5a48114
-Clang.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/64c0ac9f6a4a4f8a47c9a944f79f6760
-Clang.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/901ac11e5f210c0a6f06e88e816333316c880f0b92df482eef7154393535b3a4342534167b1e572b529284d42adbb251e5522dfec1ca027443cba346bb89c467
-Clang.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/bbf33438b1316d8900155c74583e9bcf
-Clang.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/5c3eb14173b1bd623007820d8731cf15a2e30cc02cb28d0552bc2e79029cdeaa8e86a516e980fdbd87988acb3667254902287e7a78e1a753f1b338e17e1e183f
-Clang.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/725287948e706bfc5749b0bc0844980d
-Clang.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/e419a863044afc67471b5f0f1f53dc19f26cd0ee06cbe6aa3f5367e5e8056564abc6625b9323cf24a0a625bf07a9783b0a569738e4ab8c2ee841c0c37c0f6b17
-Clang.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/55adeeb7f199bdfdb0c72e50420bbc38
-Clang.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/94272d7b12ec6342c03865b6f8eda72d71119bc153aa14958f6c324e9844f870feeb97adb2e7950162897aa606c74e95f37aeaaefb1b37985025055212255aea
-Clang.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/a8e552a0a30f6f764a40c525bebdd220
-Clang.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/ccd1d96adfb4aeba8b8502c25f747acb0a33c8806c956898ad80f1289077a5ea3f16877129db76af965d7cb232f8ff029b35319bf331ebc3fb4d4f291f11ac65
-Clang.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/182c624c223b3b50be67c59293b990c0
-Clang.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/3e60390a5d20812998554836f249e404ef3e3b63c86852a710c3a47794fe8cd661632f5e0ffbbb7ed71df003491255a4c05ae7bc64fbcef07fe8556c98c294fa
-Clang.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/a181cc98814d4a0725664e9e8a1f785d
-Clang.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/d19646a1d9413048fed8e63786a5e4a2adabb36bba625c4be02ef3302780e3e67bc1096f94d265aeb77e146986cfc86513004c19962de7bed156e3e2779270fc
-Clang.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/7ea1ff3c09bc37acee30d727a81dde09
-Clang.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/b862b29b4fba7d218e5dcb7a4c4bd48d5fdd7417032f1caa9f9c0889d934a1f9bae6bedc25194feece6a768bdc28fce319c7ff5e0bdce2540e3c6e6904eb1a89
-Clang.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/df89bf4ab33ec28f42994939e793388e
-Clang.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/e68f083291a3b8f16132dadb779c35b23e3755fd401a86ba8f4619245c3f5e3bd13a8f938800941853fe8fd508e8844b8dcaf061b6ebc9fb0adb955636680123
-Clang.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/f77f3bfa69a9f2e0e8f7191a364d720a
-Clang.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/3502d48863f5936cf136a9c61cc56dd4efb92ddf11ef4cc07f9e49f3ee420403bb9dc2480247052e5a99ed467d6e4fc83d1251ed6873787e994693c4b8dc2011
+Clang.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/79cf4b063209aeb369c518c89a40c805
+Clang.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/04caf2c5bd448dbbcb56a1a0f1ff938241eea6e5e8e4fb849764c49b291cc37379c9980063a9ec72b86a6ed7f416c85f4cedd808c75b904960070cd0f4f1e669
+Clang.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/6c4442df77d1874988fa81464c61083d
+Clang.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/06b30fd222e83bcca4bb0f9d0800b3072e8a860be8eb089e472a21a4cf960137834bdc28fb5fcdb5c588c3808995c6d27e3d90ccec86072088c7d0acb2cb3ad2
+Clang.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/922d89517c75d08e900e826accca6a38
+Clang.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/482aef0dfedc25030b0aab1e93a70eae517649dfab6ee8738c3cfb173cf2969daa962caaa637c1886966cf1697ee646d104d286f22b111064a600b0e4f845cd0
+Clang.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/70f5687634977f70105d772ce05b4ab7
+Clang.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/4b406d4d285e4a3e5c150d68cc1e9996d078f13c1cb95feb741484a0bacfba622886c6b5cc87a2c4e8441d937fecf0469989748fef5a4aa6cb28bcff39dc1e2e
+Clang.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/4e5cbd2f00fc3388a895e71d487e1605
+Clang.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/6a724195e8fba5e0c93f2e632abac53e05275e844ed81f349d812f2db8ca61a61ff95ab252ab70b5f7c277cde78a6f2e78c7a930b2c5646daf916734ba20592f
+Clang.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/3f823d697b2493792a1db2133e0d45cb
+Clang.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/1371140e74b3d78653ab0493b4a2333f5db34fc0ee133b1f162480fca043d90d44b73ec72c7c49549a6b78fdc2ebae300b0e2b09e0a511085ecb7fc08a13e0c8
+Clang.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/c2b68898a98e3e36af32800667bf6514
+Clang.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/78efac6a7a1f9931a0986e27e73ff12e8bf8333b8bdf5b20dfe1f7468e3cc05ba1161e535a457287f24fa75a91afe172f41226bc6521d12768b71c7dbcfaf43c
+Clang.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/f23fa130c02da99396dc8c48f72872f2
+Clang.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/73f59d59d4a1eb4d5d5d46db34fd9828633b66a45a0c192169c0516d510a561c01b95f5e752d1177325297b111a5d924080e6233c6459759d27f267c80f2bfa4
+Clang.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/5fc6579ee98075b4098251ff64e20962
+Clang.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/8f357152c3da7d668a9abd2133a77fd6c3685258341339b6e46b4d9af04f8e27c655c5e21479f07657c0089dccf4872f7e4e7b13e8ace1cb076aba8dc8574abd
+Clang.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/9509469c23a03a6726dec3b7fd817329
+Clang.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/6a4ec6151febd9a6953afd19217a12f5a492b19064b5f49063d83cd82cf770cd2a865cdc78fc0c1af4fb331de4584e57c2068ef8f1353434861535e0a28dfb3f
+Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/4d4b30c0f40c9056cd43d0e412d62538
+Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/96586e9a6d1194b6846d37f0367fdfb30cace917e7c9ffd4972127883083cd810a05baae6d36bcdfc64ca1b761047efd029e04e88bc4fbf533b43561ce29c0a0
+Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/b502a954b8d079a832ce40342d43f2e3
+Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/1234fe9562524de80730d4a41ab609c7143ab71d51d941336a43acde99152d5976086d0e1323dd7dc4190df58f20e6c94c40fa1d75caff00353b6bbe1b11236c
+Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/b3b961ed6de57d6b70a5de30efcf5364
+Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/23ddb6c0c2b6b8b8c35f4c3f2c26d8e55fcadbc7d110c031c31c6f60416875781d8fc9458dc9e9d03434e393329632da79094342490d1a83ccea601eb942236f
+Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/cb5197d2fdbf5b920bcff6defc99ad40
+Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/05b7acf5ab6cf07478361225a53f6016d1936e1b50de367932628e9b6554badd80e7f54214dd826cb52269bda07faa1fabc32050e1a25367973ba69fab021c31
+Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/216c69141f1b6c5adccd2a9733a2926a
+Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/a4fd3cfd099d46b29536c471d445f5bca150f275803a9b66d8f1da14c8c652e28d273f2d24c76467dcb7afe36acb27dac014d990f90ce6824c86fb261ebcfa5d
+Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/dd63f176e27c13b6483caa2d9d26153b
+Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/7fbcdc2817a7811b4d9544dc6e4cfb0c0046b47e240f98c6ac8601b97cc41746b56650fd80e3ffcb3c8c9b211ce8cce66729abe9af3fdea7d6af7fe7c8d14090
+Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/1f7a7d83377b5b23a40027e213b4a7b2
+Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/9b631b1f9016bff95195cdf6595c2902298824fadd1f88ec0849c1b099fde27fb7b1f54edea735e8bd503a0586074ae7651f29b89889cf9d85c1e23b5021e09e
+Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/397efa429183dd2567da133426b2aae8
+Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/a9ca114bb18b50c2f06ddf8d437ac10582a92a8e00038b6de5839d70a41f9ee91382ce9a9988da5b74d90059c8f9b6e2807d14256c23fad9e0f73279a94b8b10
+Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/f5bdb88aba348da4c9b928f09fc163b6
+Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/cbc2aa07a8912e9e8599a85145882f379d51d32b214ee1a12480e1abbae951b546085388ff8d437be0ed49fb9818acf4c09c353d5f35ba66adf9c81ab6657027
+Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/fb4109dedc0c6bb97a8b4d148107bd44
+Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/7cc729206a9fee458e52d3c2d12f86fa59b1379636ac5720b4103163207e2369611ee91251d990a37eefb31fc68c8708b95fed236d472f51fc50edc38a35a6f3
+Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/b390875b3b1c37742e8fa3b10799df03
+Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/7b651570e629b9accd87e4907d3c6574f0fd9b906d7ebb0f310d3e96447d3f7d3d39630a5f63491cf307fc5aa746b1aeb02ba6aa76f390c8d8b7d06f77f87705
+Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/760eb90bf8559f4a73a66461a1154926
+Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/386e4a6f7161077f5034b10f46f3e9e43919e9b247d693ba5df354d2d6682f25c986cd3b988b699e3c40a61c6b84360bd5f401840f7eaa379069f5755fb2812a
+Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/b3894812924861431fa789b096601d6e
+Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/7436260ca18b1ca0a2515fd9afe12c8ff252efa55a48ee44c84508c970b21e8edec7e1a418c4fa8b0aa6b1bcaa22450f864a1b147883b5e231d519b5e3f91498
+Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/fe0fcfcd0ae8ee11f35aa9a5b2e61675
+Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/1d2556d91174b076a6dba5715760a859041573b545ac20354072bab61e75687a263dd75d0f746b291dd20fc3044aebd9fcccc6fa16d54bd49bff40c2f11133a1
+Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/4e01a10df5cf3e13977c3017e6c35f9d
+Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/9289d6697cc31397278e793badbfdb33f48becc57938de73f42c4c1119af4c88497a2036201da2e3ba1e3a3e5f73190162f39a845a999c385bf58df5d706b543
+Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/b23d0408db616c2d1bb30d168de20936
+Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/2d7835d2679d3bc2647f9678ba1706d28e844ea04d5240fd50faa4e94b32d40add42daa079719eaaea6d42319c27d8e5ca6662a15c4ddcd1196662cf26a03807
+Clang.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/2d86562992d581dc69c7c9dd7187af84
+Clang.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/7755a9029a0a742aacd0a3c7609372a5b9dd8060d2bf9e12b362fdea1d68ae46eaa3c8e6fae3ff331977774d4bec857e017e2c52e5a06b519ad8cd2ab551ca3b
+Clang.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/21267aaee5c129a8a036d30541c12dd5
+Clang.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/b8f0b3a437a326274bd1fe82f14acfb50e07ad1f858996787da9e1faea11c8e9c017467d726ed23e41ca9eeb298fe2f4a203c64ab21a74c4a2a3a4b2920fc5f5
+Clang.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/64ee96aa2b5d07665020fda19a696e41
+Clang.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/201c68dcb08b1c92b3a7f7af951cbf481c14377d09310c426bb92c46d5c084ea735c28c56a99979216ac1343bd6869257355a7f1410e1c35fa59a9448271074c
+Clang.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/da1e866abb3123d3be433220f13350b3
+Clang.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/10979264f94a8de88f514521e509b703116b30290da088ddb8fd210205c1a9184ed6770bd103b69bee756dc529c7060994b89213ca37ee353b9a367579367c75
+Clang.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/116b89d6337487431613ee804771b5dc
+Clang.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/587e85d2c64953cfecefffb556631683dbcb56ccb63de26194977d64e9c2cbabbe37893e9c750f784b107228e17fce1cb8412b757aa71a7ee02f305730c4338b
+Clang.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/af031e3ea7b5eeedbd9994e0717176d0
+Clang.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/10f85637060d46f17141b5461073a1631c9784213d5a1f1579ea9bbb601026599eaf563e027991c277d5cba56ed933aef3e56594d3bc9ff09f3957b6a294ca44
+Clang.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/5e0c36cc096f964d9d00875847972899
+Clang.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/f18c027e709eb7a456c7c6c37cd0ec0a537a68eccb806756eee5fefeb47b368dd15e1d3b81ddf910e0eb6a9e33801718d1a2dffaa9e6606ba7caa64e14d41389
+Clang.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4c070224ea19e61ebf375a5721663405
+Clang.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/b2cd67e9d1db9792c71bc0544082abd80a473c4e3002b0ad10047d0610cfaf8242a1e0f86b3f481c4fcdc2598d3bc2ece6c0c5e4c4224c036e7656a6c1a654db
+Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/f0e51e78eac3f4363fe57ee82942d551
+Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/fd4f08d0b4fab17db7bca0869bd2ded70b9c12dce095d22bb7956d87af4df82b7a67f615a9f60506c31baa456f10818d0013627498e53af0d2a5f2bc616eefed
+Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/a3e0a99be915754f43f3c293365fa4c5
+Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/912c75c32dd9c1e07312a1ad2ca3904974bf7b68fba01a605b33ce933d8bfc51afdc8ba548c5ceeb94238f1d9a0de20dfd0dd58aa9456daf31b2bda49ac8c8b5
+Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/c675d1e35584b0c55f5531df88c544c1
+Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/5286394414dee278bc45daa499a57e0f5c73d6715bcdb40148f29055802fc38fb099c3615063f87d84cea2279c278391fa1263180321e04d8f7caaeb05d55be6
+Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/373b5c0efd9b4ad9505832689e44c5a6
+Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/118f3f1a9de66d7f05006055af3c51602c8f239abc8076069d009201d4e87a35271eaaf91fb6a8edd9a4f85955ebd837c34e0983111f600e2207bc57730a7a25
+Clang.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/2713c9bb02b81e61afd1e16fb451cf8c
+Clang.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/b70087d577c1692364f4085b897bf9fdf4ab0cd8c4e02d7388e108071293548b656a7081c37ee1e8c1b0b40cc52bd66651bf9cfbcc21110a2db12d853a6c9c5a
+Clang.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/2397884f2b331762654fa67390788ad7
+Clang.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/09c76fddb118d60ae5c886374fa188393f68ac392d13c395f26df786174237e5ed0b92fccb95e3f67a4aee8fafadead534aafa263843ca80dd2167b58f6dccd3
+Clang.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/b3bd1e24275c7cec1105be50c04cdf15
+Clang.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/72b58b9397edf8ee69393b101df7a741de084ae059dc7617388e6de857bd000a1eb73d33a9575f80ea4ad0cef48682225de4ff674844579dd415be1aa7dee4e6
+Clang.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/a3626ef235f593e77fb7b3329d55fbb3
+Clang.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/1e78e8ccfac8cfb05e612a038666bb1fc721fed6ad48e351fa57115125e8493dd77a47b12244a5e3cbf880aec57063753a0889bb051b312ad58dc64174e350e1
+Clang.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/cf1c314577c88e026f83cb1d119c9db6
+Clang.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/31a21ab9e153d5963a331165d0ee0b1f7c00716b777fb9634a77b78012608386a724c84871a93809bd9da1b2286ba3dcef8dab1888214e9297758e5c4518de00
+Clang.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/17e10dbb8a20c235a344543a8abbae2e
+Clang.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/57559a589d0b8a94f586bc9d00d8502e11b4172dd8afd6b9c241ab8ca3a404e3d8106f8e6f1a9cc96a4be2141acbfaabdb7835eac1a18a0d9bb7fdfd2fd308e1
+Clang.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/13cec7e091f8eda85c43531053eb2c4c
+Clang.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/3cb6884bd34fbb9eff6b366da6f476b5e863f3637a0b3a677500c05503c5ee96aa5ec3d6fad4bddf46bb60aaf647c689e77656ebec3e7cb274ade6b481ec75f4
+Clang.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/1f21f372454290315e24affb757f2557
+Clang.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/79b3d0882172babe4cdd388b55308a3d0d943d9ccd937abed35325e96e7ba43426f80d8366affd0803fe374d44659f07093d9fb5d791127a8437b5e10319107b
+Clang.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/026caf653d390ddb7bc71ca151966e41
+Clang.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/4194880c9549ca6bb200b5475afa00b6fe617a40f1f6b89c9fe82ae183c6c5c4b03e1537b8f6c82b2c416591faaf916114b27832efaec8a491ac7cc441c902ff
+Clang.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/ad63b1a419254f52b37188b0e540281f
+Clang.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/fe94de0c1f97d7f0007d02853a2b1126857b6ee819dad812d9ac4bb5509e75869b39783858237dd50f3cfd284ddab46564b412370393f7d3eb314106fe5bf628
+Clang.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/7700937fa4b17af97f85be8d4c78f170
+Clang.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/a5a223386962523f43235dcde3fa359509573475c0f3b2234e2f8f28b0b1f1a47682fa5593546d38cadaac99aa9b283cffc8f8fc8fb43b257e9eafa0d81297c8
+Clang.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/6cd4d351d8d9d9f4e967e7cd915f1ca9
+Clang.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/d76e0daaca853d718c6a633a4e28606d70168504e9055b06ef98ccaa150753e43cba12c57304ba0b45b2a103d717274e2cc31fb5b869395e0e0eda32fb0d03cc
+Clang.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/722c5ce1ae12dde7b2b2f1f9e38ded6d
+Clang.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/0c6224662e09ac9ab104320f4e93b8e3a9b9ce5b55eb51894efad5aae707604b57e5eb8691cd6b39f10199a5b393353e3042f87a2e0a04344f2bdeae75e17464
+Clang.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/cd1dec35e0ddb3fa344e96dc36dc0936
+Clang.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/df10fd021961ce9e9e7b7b5408cf7c96a869030e4290a9bfbfac3fae03343005ed33eceb82fa0d5ccb36e53382838261d4c6d148208739608036825b83166cc8
+Clang.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/f5ab229d661d2d70988ffee4302c8700
+Clang.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/fd6fd77f1065de2089368bb816822987f13b18da3b33dbd027b8efa393ba69abb3d9ed6395875839c79ff8f9ef65546a6fb98d1206f1542e9069a43083e85e22
+Clang.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/e0208a9170c37add95044a55eafb950f
+Clang.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/dff5eaa5719dab7c543e1da8993cac49b358811b1805debcc6ec2a115d9fbf3ec9add863fdcd7a16fbacbb980743cebb4643b36e39b8dcca4a896824a7ecd8d5
diff --git a/deps/checksums/lld b/deps/checksums/lld
index 63a7d923451d0..d78f858c0f136 100644
--- a/deps/checksums/lld
+++ b/deps/checksums/lld
@@ -1,108 +1,108 @@
-LLD.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/09c320b356e69a8d2c91aafdb0d735c8
-LLD.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/42d0ef4bce4425832c535f16b83a86570c0851736ec671f94248b3216600e0c0d8fb0a9f7133d9f1ed6a3bb95e9ea5536db99b35f2f29050faa77a13db21d5a9
-LLD.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/ed7b9ba513235c91d96e0258355eefec
-LLD.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/4cfbb5198a0f59c54f81c3bac4d880b09e02531c113b985bb512a161dfb66d28e1ebe5a2d27eb567e067545141d25c5b6f7658439dc20c39f0cb324b406d87d4
-LLD.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/0fccd87c8d6016a812c842255b4318ca
-LLD.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/6b44fe0337b74bc80f387ef41dc11b06f7277375ddae3de079071cc0bb743b42a90068453c3d9e2613d7cbced47d134c67297fb7dce6ce098673354fe49a6292
-LLD.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/bbce3af58d39cb571ca851bf86c38ca6
-LLD.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/e577f2ec2f1a15115d850a850bc0679c80e2dcff6a9f3982ac84cea6497c71d7bc269ff1fd262d427d3a98bff9f72eb4a127ea841471af96078f7e43bea6c5c5
-LLD.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/a461bae1e190f5f7f72a64336db88df8
-LLD.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/312f465093817c39f8b17cd004108166241322bd6559545f64bcc5b0c3247f7f7b85e618587a37e51cbeb8decaaebdc69d60f34bf8ddc53e5efebc4d9192ca9b
-LLD.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/017a1ffae7b74dc5ae069c00b4ee16e9
-LLD.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/62cc6fced8358ac46562887fa03c4196d77b61031b4f80ce3ad339bc6b8ff1f6079b99a862bfbf899d11201b744bc495f7b44315672e72886ae6046c6130d488
-LLD.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/417d35e8169ef5ab07ba41d2de46d7e4
-LLD.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/fff169fe51910680110fd3df8d369fe529f69785a151b4274b127223fe9c660f160366044b74c17a63c24abc8f8c659cfec50624e98c99e7d60ab84716f12888
-LLD.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/a2bedb0bfad8a556040b7e5ca0e2848e
-LLD.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/0bcc2183e787547d5181d203f1c132b63186a100f1b9348886443eb268eff70086009c3dce17266d6cfcf6285bd15c50e18bbe1a30517cbdc5b1769e5f01ea94
-LLD.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/773083d5c46259aab09522dd7be7586c
-LLD.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/d6e240cdb8fef431f88ff80364c0c493eb198ef599db13e91628da08b624ed13070a1add19d2507fc4bc006f3fb9709a4de601a4e2adbb30b3967c72082da583
-LLD.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/b44023d4e9557f997fba9fdcbedabc2e
-LLD.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/1a4f92bf5eb73919384c89d84ad3059c3ac585258662f8b450c1cb878c7271659cf1a3e90ed7337123348399580b39fbd29e9a68b64e94a66ac56f1637b6f9d1
-LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/f6fa081c30f619170b9607d9c374a19e
-LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/4ce50a67739d5aebd8b96ee6c7441685a7fb00e816b23f685c102c84300b9da98b83b8f9f2d7bcdfd1ddc288c1b7a03e884dbdeedb665aa16108e97e58a8f4d9
-LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/ac3a61e234e6ad8d6a7b8f56ea3fdd59
-LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/45a6ffaffd514628569f9463a4467d07049c9c115fae7cdffe8881e1151968e5b5f1f196b969e4a4319fdf7af4e667e5bba5401b98b26038fba72fbed95d9fe3
-LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/8843ae687a9a697c49e7b2718a819fc5
-LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/6eddcb1ceaeada1134c4b8cc8641e4c7c8998b975b98adf6c0b460bfb891f0ea7bdfa086bc41f58d0c9ffadcd44d8ccb9e15895cdf7127317d9bb11659c3e0b9
-LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/d21e19634ba816b5d8ed06e8e29fe264
-LLD.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/098c299191c527ca953a201e27e9ca7202c5a8093e3f338b31c5f54fafb243bf2aaa366eb32b18a3770f86036f7583bc5d55d7ae39cb7bd61af280e20d57a5c7
-LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/5962ef5d8db691edc3483e8b94ac445b
-LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/076f1b0995e1ad40a4237a25c5de03ce29025eed9e65db33a935537bc93e84b886af6ecf88ff1a5efd075c3837ab2b80addde99580325043a190a4cd6864cf59
-LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/e8c0db4a2c24728314fa5d338144277e
-LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/703fc4caf03390afea0dc070c6ca9b2b402bee87d8c62053503395e858a67eeab369bae4ec3ec52fbb618856fd582aaa10db1b3843648e5343ba10359e2846dd
-LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/eb595bc0386677a420f356ffa2eb16a0
-LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/a9c6c1b8464332ec5ab9eaf405ae18efd06a339a970f8f28cc88fe8d45712b1420e5b8add02e97f82204c49b653ed1c7f3fc87a0b4eada873e46e53d0e132f0c
-LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/553a1eaa6982bcd82dea38f81c6e024a
-LLD.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/9e0007d255c01dbd08e0c51355200d53219850b0ea60d5747a99a4f3241a79f5c171315f7b9fa2529ab6f870d281c76d9b5a4ec3e10d58e41b3d2486d3a38861
-LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/713c09bb19b6f47ede0b4ced61d5039b
-LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/553b9d20b7291521e607b2df7a2964e69a58599622ca3084f795bcb77239617a88c08bbf0bde07cd7e37cab0f53dc6d500bebad957415a5e66223af9acd0373b
-LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/f878e4d2464cc1a70eeb5fa57e80978e
-LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/3e341e44f54434d70b99ac1d71a9e79999a31656b0d442c1692731e4bdca9b95863ea9f83c3da968a774f6f693c9088374aad25836da924846f5ba05f05f968a
-LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/2e4fae7565ddd6717a34c8240dab8115
-LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/f1bc27876f546e0f926a63c0e0b878bc33c2836e5902809f186c54a148f9c96f2f88d892910d4cac14ab4697723212ce0389a79364d74420aec075f034bb3867
-LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/e064f11cf58b6a870212a9082a2a4844
-LLD.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/75bb485d234b077ef3cd607d30568943559cc50ccc5d5aabe9556c7fc104a1cbab24ada562cd6b8b1060af58bed10da6697fcd9f05fc7d669ae694ca5fe010fd
-LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/b0754db228f635d247ffb5ea9938aab9
-LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/650b7ebcc5aca07b1a9a4a8d7c2d1dac60bb61586279aafebaa718283933735929dc2fc8b08c8901626533d1834be4071fc03cb5a8183311e519d245cff33bad
-LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/ddd06a6b9f67a95053f4f06d85ad118d
-LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/e7e87fb0e2c394dce36134bf0024c6ed613ab6707da6a472a708771f7f2915ccbe4539aeaf3fef2c5db08eb5cd5b9fadc30c18f6b34cadc9d56e1aca89fc0b25
-LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/89673b45e8b6ad861df5c469ce9e0dc4
-LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/ad654354e7da47d6d1db8b9acc26a02412ed02e842e0c6eb8c403785fa502bf75453d575ee01927db4f39e4803549b25b3ed4cd2e0354b01292877b45a4a7b84
-LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/84a8693bdf7a669b523bcc1475b6e868
-LLD.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/d784c66624069a51b7df50773e9946db73e7015af617ba745c8dd7e926936295e88bdbdaeb175c363903340c422193ef0437e035a15cc7595c4fbc0fd3bd56c1
-LLD.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/d4005209edfb3793556a946c6a6943a7
-LLD.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/80c21eee46810d4a5dae35cd42604266c463e73f399e7d0c9cc62b90ae14f3c8fb49b34254612b0efc7af2bc52213c35f1a50c3a4b4fb30d4b9f06273e31d7fe
-LLD.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/0563df5ee7aa191b4c1054fed3ed228c
-LLD.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/578dc162a37c38a3ebc9f45f5ce220ded71df1104a1bd830fd5055ae78d634e3110fe6a0b8c86bc08aae145c16e7c964dbe301a1df752db4a597f98b653a5e17
-LLD.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/d0e448c7694f03e7221020a5deac6fe8
-LLD.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/f1e1605bc9a0872d19e74dfde78982b39fb0cd3b28c8af65b2960ac292c4910afc84328ac1edbf70fd2c20e697d2e826b729a6325949831aa008d3ac565d4d4b
-LLD.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/881ca8f1640a296af635e255f671b3cf
-LLD.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/67146381b1debe7cd71d819d3d4e930b5e9f904b30a41cbd87681675e6a263ee8008347f1b6879d13098f2f261555eda7e67494e111536b11299561d9bde4b08
-LLD.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/3054aa99b31c9fe01f018542b1ee1628
-LLD.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/57326651e05dc18436166dbe31cc2e373de78a705d1c12204db6126a905092cb81e81f66d81229b6694b82ae279049ccdc3a1decc14dd0e5d9706b9079aefcd2
-LLD.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/2ba48f3fb8db80e4145e5495583279d5
-LLD.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/ddb3ffb64a7326ae511e65bc825b01cc14a403fd129b29e9b01f00f87346cec127ffb4eadb994d4c00ae49b78f59f8d32f2ab131ed7dc59e636f83aa182ca2f7
-LLD.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/03df4914136836a7ac62e5f9c74e2c58
-LLD.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/0e5d0e32a1c817cb81169503a94ee428a4fde8b39cc2174f749e8df2b23526e738e21b028e66b44c8abba1e0be0d93ef3f341c7ae7d20fbc22bac60c38ee887b
-LLD.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/58c367d5d536469831b740d6181e1909
-LLD.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/e55d2a0152fcc7629007416f8af7601de163da794939c0f1bff9b9083641b15fb365f7ab9e78f984e77246d994781a74c56397da26d81aa66cf926ed280cc2e7
-LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/c822be796e7e20e1b081a1c6c9fcb4c6
-LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/a057a957b55f97c0da5991d0f8f73049ac30733aad062645614b32db17e4f6efced6c82b77a689c90bbc37b610219f235bb02b6b29d1476ed1b5f615b30b5267
-LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8dad1af20464f8e3e96f77d8acf7b180
-LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f6769fecba508ec9136dbe03035ce0bbf7eea14f3c806b3e21b2e32de449fd9a698a489507412f6f603af86e8139dd67f2c91d51ac3385d82fae02ae4bf41531
-LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/454a8a9c011d795de525c088b0fdc329
-LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/904f8846ccd8885d15eeca2ce08d327f3b13cead1368f50cbee3986edba590bfd6d696b9e0fc081f7a8a127a3b83daaa99dd74a0597027c84797099c9b0c807e
-LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/36302281868d2a02af18601d5b7625a1
-LLD.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/fcbb43e37308c99dcc7e2e152923eaf3413e4143124dc598d18467fdb6e8c561c0b99ef19d5d0797565f6a18f86a087de95bc21599c65ccdba42089a678b9796
-LLD.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/4468fed82218b2380295799030f1fad6
-LLD.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/37cddefa5e24c8451e9ae2d64a931f4dd2bffea498cc818a9b7dd08d4df57ac81f96dc573e18e90449e63cb104cb641286cd755e24d6749c8f9bc943e248c5c4
-LLD.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/3089a2c2700d0a645d1ef4cc26a7dca8
-LLD.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/e935b01349d844e8c6cb9693e6d0dcb8a99973bb63b53df010a207833c4ea78da3493421c28f26122e92bc109f4fbfd55c547a7459bea2fc39ebb3c9318571dd
-LLD.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/aa3aa224c3403e9a955e8cabd4efab4b
-LLD.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/255f6f5eba7835041d510a57cf706b273f87153bfa402b4e0950a418c71a582232a99c94cec4262fb8e3e2ece973f5ef9197a625425515541c61fce398f439b1
-LLD.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/363e88347921c781d163844446f78f0c
-LLD.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/2e12a0d74cfe145a2c12224d9a2fc5be0a0e7f1332d17b89fcd694b0d72c1bfe7dfff030cbee16d02cc7c9df1d350541685fcfe1ebfac38e4fa4d6172216bba6
-LLD.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/7abf726bc36460e40dc2799b65dcb0b4
-LLD.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/19b4a38448d503a6dbfd5f972f8bb60df4d54735541559271be242d977519436d83a9558b42984a4128a2b467bc3e22bf5c37725db2e03c8bd3fc4369a526d7d
-LLD.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/f1f685b8f111ab299a3979de7f5b3718
-LLD.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/657d404e9295170696830f94bedffc7a3b638ce5e515c24b3a60e3da1ee9ef9d00919db6bf324f9fe9692b916394ea1d93a47840358ec1d56a9734fff0c6f9f0
-LLD.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/7968b42dd7370573a820c3a4aa9765fa
-LLD.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/716a6ded0379cdb441b51031919814afab5ead38cd8004491e022b20c2a2aaf6a1481d4b6396e70e30a8f2c4b81f03450ac5c1591e001bfac345d492933c1556
-LLD.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/8a375261e55943a26956036a3f99b72b
-LLD.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/4678ef639b1b4ecdf9bd818881f3f01b134f19b3f43c152f2f05cc8ee2b2f8f68526788cab1b0f0d3154bf55683488ce05e21df93767e749eecfa78e7c5146b5
-LLD.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/9e654f59807553bc6b63649561d42db1
-LLD.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/bb4401fc7733e00469d73a761e7eb9e1c6c4a2a9ebd420bd048fbd189b25a6d17e3eec177479b63e8e71471189de1d5becc68022cd9e4d8b0ef96890400eff24
-LLD.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/967160242a405064609a4828e5506e53
-LLD.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/a2e02f065dff865c2447e689d1a080073fc0a160a8a4492912633f8748b0637cbc6bf6923560fc7f31091bfbb968f339f48ffa62e768440dbfcc8f1c7ea2ef38
-LLD.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/89be1c975c0c240608f40fc89de9cc79
-LLD.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/86fa05bdd9f544dee43dd5ed701a43bbaac137d0f05e3bccb0ff32cb51fba790a6446c814f7dfe644ee82661a25e34ae4fa905b88bd65c71978d905489240c5f
-LLD.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/b8dafd04d9213317e7c6c99e2cc02c4f
-LLD.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/107d0a97eece870f86d658531478a5930597210fb05458fdf5ceee48953b126a206c910837caa3637cd7b626a343ca5bf6684f2da47ab9a3e83166d4d0de4b86
-LLD.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/249c60b944d6ee16c4b28fec414353ac
-LLD.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/2ff5ae01910b33c49331cd60d1f3eb9906d28f81c1c8e6a56c4079c74d56bfedd316707a7fec38385112e873e0be4a05d587f9863394d7d62945bdfc8c1e81e1
-LLD.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/a331a6f81958efc3ef061f1282ae63dd
-LLD.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/aa93b56e06f8e0ffbe15f50c36b1d7bb5f77022d731fafbbb6d502f93dc229ccd79f44adf6f6d1dd0ea94ecc5a05490c326533a8d25bb1df316922f86c6371b1
-LLD.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/72427b0c7a896027a47c27b0ab2bafab
-LLD.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/5aaa2fdf91385133bcb0b563a7f2ed3c8c5ff3fb307b02387c94afea863759b78de097855a7949ba41449e7ee444f166fa4f6867f41ed3a561bb6c53bd747729
-LLD.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/6985692a2c8a41b34c5d2d103a969348
-LLD.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/8339b3aa2143b105c7133171ecfdb375a19fb9358e9fde0c41fcb57baca9a5603c23cbe8ee70936fba86452c1a57b4c84ba20250805513445ac609804f35adc9
+LLD.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/599ad46632e530e3d41ecd932efda7a8
+LLD.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/54633d81e768574141db94683d2ad1831bc49c7a796c611cb614981b24f29853819887ff0ad73acf4a48d38ab189f807f7858f9bfeac08df8b889d432ff4ef3d
+LLD.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/fd91feb409b825226419b8406d3d4ab1
+LLD.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/cb26d2222cc9c77a844e2d2bb83ffa36faf60643ad41b73050f8ab6abd1c561a592ebc40fab7d4b6bef91fc3f7895da0349457d6bfa45cca9077ae0c64d0167b
+LLD.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/9a181992b515ee4e9d5eb38e5501170b
+LLD.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/d6091bbfcb1a47259f81b9b48471aaf2fe5cb8a918e2625921c43742249a68c7dcbeccc5a5beff020e018f0c893d287308b3496a322ec727ec83608a67dfc373
+LLD.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/91e6f8fcdd20257109db232f01af6d84
+LLD.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/439f4fc3ad4b57b1987d8682886b42166029befa5b7315b20dd44fe8172806b0809a00fbab92ab66b04c3bfe2ea5f86c760dbd9990c466f060bfde169381651c
+LLD.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d7dfb72e7158d6cb7fee0a53dffa6be0
+LLD.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/96f24a4a5789ec4258b3057cb59803a1467523b647ae0bf71268d100ed3faea467e61e9a1c03007f85d76067e31d266cec2fd507a8b1f90fc0972e12296ad885
+LLD.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/4a9beafd6ba76e03c8e99d8318913553
+LLD.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/2c741974262a81796d38b2b24d3301b1b2dc4f990ed0fcd024b88968766cb9652c3eb39471b3ac0331254fdbe1a6999d957a1cb45a928bc3b34631fadea0abdf
+LLD.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/95a8d5172ef13fabd920ce5328507ba8
+LLD.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/f28a981f4dd85d182ba6c4e0319b33b254c952c83975fe124e0aca44b4a7fa23725794d8e2db62cd41e61caf2dcde1cfc69e446097d9770bb8b9518818ffdf79
+LLD.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/10a1f8ab8643c56e7a3b6786552bd11a
+LLD.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/a7473cc47ee06de07a0e9b609ed1bbc39704faaee542e60eaf19d10746ffba2b537ccbe36028264dcd9eed4ff9f62cb91f483169691315a75ecbeca5a5f6d008
+LLD.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/1d0874bc726f5dd0af9f96f1f5888da3
+LLD.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/b800180d1b4b6c1091fa4a72739173c5e14ec2def4f694dfb4d6b904ae8c6c095fe013a20c803860664e1db27acbad30f27ce163f697fdaf05b8726f10a88461
+LLD.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/ea8a617d1a806cefad6b8a37fb083f0b
+LLD.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/e0ba812d24d9700aa03c5f55b8e5104952cc8fff21b7a9f484cfb7c26a827e5df0bd3a088b9d24c71d320fb1163fe2ca94f5b3130ee540991a9ec8091129ecc5
+LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/78fa5a3fe420f5432939dafee2a6386e
+LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/69b5e35b24b0f2bc0535100ef5f976491fadc377097ec4809ab564218dae6df9f538ba71a33477f29307752e94a72ff63213d2180fa0be50679b087dff191fe5
+LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/297abafe1f4ead4d403ca4d58559059c
+LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/2ef19b5902e8a59e644e86c65f4ec31d71e72d922ee6e735fd7a81d68826cc81e1143474a80dc23c46be33d5612f712b5275e453cf6573be402195a6d7723888
+LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/20cb187a65da78242ff87660fcc080ad
+LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/070d1e39ac25073571a2f10db47e01a84d2d5e7d3e07a7e2c1383c835dbafbf8d6f3d01a1b33bf9a329458c083ef8ab0b8102b3fb6f6bfcd980a4c908034d692
+LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/fc141dd0812b749382b45320b27fb23b
+LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/dca5cbc7d93c3520f3f8dc8e249c24fe883c5738b1091eb168ea950b8c56b488e09f2043cd8ed2c7828af7f4c5b65110e39da73047cc859521c6808f92a6a2c1
+LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/5f92376c38bffb13ecf3cbcc9ff92e87
+LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/2bcb960ad48b280f37b15f037a3a1fd04e1f8603d9be5a99f5381eb1b1b022e114b670b4cbe74d3ace1bb29114cb20ea7bf580a81a0e8b547c0f68a79f55577a
+LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/b78cf01ba612f8de427fcea38a10f603
+LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/8454ad15a7999993b1bb65d9126d1e53da39becabf9e9674ed8e703d2818217ee008a14aaecef69b381e9fa964c2ef280c77dbf90a2b3015cfd20591484d8e9f
+LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/9f5db6e6898e469aa894d23820ad9bd2
+LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/ef11812d924cbc4b6e3da162c366d228d7c0b3e3c054f08a7fad749cdc2e8af1f3026d55455fc3a490e41a9caf353b69fb7288dc967a09e9c6c066a9a4b7010c
+LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/f1c032083add023cca0c5b0f17b5c8b5
+LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/1348ddf226850a4a87ae49f11186fc4ffeab1ae607211c82b67b9ea1923a07bba8d41b80d26ff72653999a69fdc96020d727a1d252c3376e32816c3c0714735b
+LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/7a9d3124554f9d045cc4af96f5547d06
+LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/1f42fe7d6fd487fdcbbfa5547a6f740874deb6ca2c5e78a3a6c1f0982724ea297f300044d0c07157e723dc1c9c430b02c32b0a09ae28d4d8bdf143ab40bb098b
+LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/fd67bd4a34b3ac3786b3ae736fa30ed6
+LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/853ba456747fa93bf8503d884abdb4cdca3b4a2b3164382fc3a0392fbc87753283851222fee184fe776d0b7eba0a690933975d630d5ce9156472ab81266f2414
+LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/182b420234d92d07f0bcb3e4916de673
+LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/d30840465c94ae4187aaa8946e5e3d664302682b0e5078459c80f8b094d58c38461d87fc46c0052443f3eefe8d043d3fc52c75fb42a4ee8fc072dbd27cb8d5a4
+LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/6159e0d2daa9fba0c6e0c47f5f47dad7
+LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/ef8591cde887860d05cc6d8fb055b0c66ccb3d157f7debe396cc7cea1e7af822561919d00f99d7cb65d511777d8abcd6754cf8a0518aa7137f8c3dd8907a4b42
+LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/6eb77fa6378392113eab8dd513eef598
+LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/3e6fb326d473fae9399a43515b5fded64dbbdfb21435b8b6066177cdf2c0cd50a6d8531a4115a98ecdf69829d55bd9c456c546906c5d75d06840d68fce00c29d
+LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/def219edbe028b64f82e88c9effa0a65
+LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/aab70b8978ed3aaa1110596e1d01e7b3df6484ae29c5e9b6cbbbd45f515da3a47ddf41d7296a5d040410befad1fc1e3505501b699a51e340c5e43a15d78c999e
+LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/b12c36519c6d347944c8cc6b112f13a2
+LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/be04ce4289ee682fb922a71794f119f2834282c0d20e432469ae7646d8565b1ef5c009af7a288b79aa1c5a84363b5a9dd6308fdfd6ce4902ba9a15160ec6503c
+LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/51549d01690941f8bfb9111b1f02ac50
+LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/fb029c0a7711b48292a265d6dafb020ee8675a43eb6f1317e7cbc096bfe821bba6de61b91fa9930edb9ecc4d16256a712dd2592164f6426a4c1043646eecfba7
+LLD.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/eaf8db25bb7172c5f418659252144abb
+LLD.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/26b14ef2ce784732e0810be4e698f209818d2353b9889d810b5b88ae2f775186e2b4577c162c10525facddce6aa3f291ab70ce1fae614889dd1738c68cb07738
+LLD.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/868692166c1497b47888d11b0a046755
+LLD.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/9087d10cecb469ae4eb8fab2914e6bf5a4d0ac2c7caeda4b1b8148c63260261675ed1153df5aa2a21ae68f51e3d3a1ac854584b645543ab16eaf1085aeacd822
+LLD.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/a97ce7d452c937639053227a7e9f35cf
+LLD.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/26d51d873b84982850c1c92a7bfc2600b375ad6f2318c32abb99d4bc6982102ff16a8df910d57c65f3cc7374ac9c35350f580c32390f3c7d2ba559b2ef243e43
+LLD.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/d4da8336836b5f3583084941186c1cac
+LLD.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/112c92e2ce81fbbec223269f3a528184e0e37842e67c53b1f58ce576a9b2bdb657fdf6c354492dd58df77b4f7d7a07eb45ad6aa069bfd921b336b49dab485f4a
+LLD.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/19d49ad6cbda589c649f4ec8cd5ec7a6
+LLD.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/9a6d7f5e23987469048e796266eb311b545b491b12698d24ff701273d78176e558c38da4b95a82d8823dc7bf2ec30fe31877769356d30bd73322b13f80256d54
+LLD.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/efd34e5a69b5ea5678e7cf6ecd8a7ee4
+LLD.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/be591cb32ebba4f67e4c4dfefd379a6fad299a27eabc76a94dd3e4fdc4de7221bb804bf44d10048512c3a3708499300a7df90389b586ab74596141592fbd2fb9
+LLD.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/1f1608b98c97bcd48310c7d09b110125
+LLD.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/4e18dc55759aa9f983a8e78d85da6eb9372286f7a4d8e251fa2a87e52d011f643e74b51114468d3c85be15bfd287444716960aab6ac86f8639b327f6c180543a
+LLD.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4bfe149fe223a20c7fd85c6d5196c4d3
+LLD.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/715c0e919cbb3df22d8645ad086f34d58d33fcf3e0424993fc1eaebf9af0c747de711bd7e6234ce99c99a639d584802f8e2ce5fb1170a93adc13920e804288af
+LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/42e37b0d2147065407afae53412cf5a8
+LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/5fcd94a924d2425b7dbb1d1557e5f1bfeb4541f2cdd665cf6a3afe119d6503e5c362ff427d41e05360c584d07ec36e330311246ec06bf6e8e079e9382ee5a067
+LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/f12263e627e5f054a6cb5d95cc9c2976
+LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/784dd0c01c1e911e40809014df2672264324762cddb60adb0a2dbff346613d03535407a7b9a0825ccc09ef6b4e0cfdc46e572c2bd932c4ecd99427767b54531b
+LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/8b8941c2114fca20dfe4659ee1d0c2f7
+LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/a0ef72140f71b9a206a3920fa0aeed494e28f0d39c27b83294391d95e2cdde1457c3bce30c0846c298bbd7f2cf87d1a31b1b28c0c7962412a0e60313470281bc
+LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/a3a3441c845758f9789f7e399f64ff74
+LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/ed7496049dfe5b54f9226377dc4544ce80583bc6fe35ed3b673b0f9650a8b236bf6952c001903756109a9df4d1965ea80a73b2d8aab03d088f8a54a0309caa5f
+LLD.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/1e46c787e795a17e780e290a262865d2
+LLD.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/665357e8524e726582bbcf141c32c1ecd6a650741065a4fb3893934f23c7afcad11f5c8a931dadbb031d302d2dbb1db5df8aec77210e685ba7a80e35bcc96c99
+LLD.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/67b54e07967803e63c67d5a12cc1eefa
+LLD.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/dcfb4b57d3875c7235195023f71eb56c7f4a12d3251b0d0ab1820fb0d93d9ee22b4456f51d09d4d332056ae70b6cda5ee0bf347306d81180cf0553497caf48c7
+LLD.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/208fa1702b2165e3e95f718e23102075
+LLD.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/f3acf92eebdc54dd648c614acec9aaf9cf95ac8953f6b1b5e9bac89afc2f936924ff06720249ac49c3efb3f6a18cb17085d0aa105d1c3c1b83134b748b38a04a
+LLD.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/c5e11811db38163d270d368d46571e7b
+LLD.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ea4e501ce8ef58584e508537552a2ec6d59b8ce411a0cff87efd064f864ac9a822139442cf6dd3682aa5d4bcc4e29b64f8a8521d17640d139ce90b6a19c932c6
+LLD.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/84cdeeb91c53c9186da3d58f45cf16f9
+LLD.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/9fade260fbea23c09d932c481f668273a90431a129b449c3adf9a99bda2f7f1c0a1dd4abaf451736fa1b14e37bbe6e364118049df09f27a72679a815f793201b
+LLD.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/587508a8534555017ec9191608a214cd
+LLD.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/1bca07c8105d9aae4e98e91c103115939a5122e615770af18dca5d894d4dad0c79b3918ceea94044098627f2cff467f3085df3f4614ffd93c64e18d2169ec30f
+LLD.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/717b88f92a660358590c5988c3b08b1b
+LLD.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/c5e911ef190f6ae26c3d99ae1fc4949a154b833c7457b108ed0b94a85d395991bbf5ef04793bb2b2e5b9da213dfbe0a20acb1d6e17c92ac9fe304e06aaa822ee
+LLD.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/02ee75b1b1771c4019c513ca5f9cc682
+LLD.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/ca71528db12fa4eca4e1ef34141fe196712c5b869eaf0bef04232102404331c6e5c0252c4bcf90e6b44b1c12bfb95306df91e1b5f47e6f23384cb67394accfbd
+LLD.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/7b1e478eae99ba2c5686949465e0d511
+LLD.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/362c9e62e918d654c986a94c7f94270bee772cfbc002ba773c1cb20f6fa1f2e62a75ac970990f47a6ec649799e7dfb89c7860066b4d13a5fc3dab051f36f9003
+LLD.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/3590b32b2e5f719060db43603fccc24b
+LLD.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/b3dc31ae9f9469c1123e6eb2c21f7e3786619a29d61b99406fd582019c40ee5d25c6f905aac1df68109d62bdcee3a19ffc97b54e39e32bbc152cf71133879077
+LLD.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/72b30e00dfa370f4640a83776f46f12c
+LLD.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/2c136c19fb376d0dcbfac76ba141a3366bb7cefc5241d8be61d8229b042268191c069f68d543b48a24583ee807e42176aa0902a2a39fb313e25c2b3f64545303
+LLD.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/694894b75e44b967a2e23f4fe1d1d7cd
+LLD.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/7f1814967fd59d89c797a8bdac731bafc077b2ea2735860f092e5c542356f7271983054638e943174d7e137c3daeed1997fc14336071ef2e4205094ad080d874
+LLD.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/6da9ee2ac8adced1228103a504ea2949
+LLD.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/a9ad116da319fbfb35b0355464569763d587947ed95168dad99e74733e634f0489cc4e882e7c3488bdaaab5390e955d4e660d3fbe089bfef48117613650ee1d6
+LLD.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/dd9f8c224c962e2d98e23fbc0820acff
+LLD.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/cd0706b32cb598d8d84e70523554faade0f549c4814c992358f9453890ca66ac2fbf686dd76d5739c24c56935664d96aaafd85ad23238e83101f8c5f6324ceba
+LLD.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/a09c1fc7f7855679578330f250522fa2
+LLD.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/4768d9c73c6a5f45eb7ef4e406e21211ee7592825ecaeded49a2b1858b1d58f8d460bdd1fef1bea7213a7eebf4e8a51da6b1f67824ab4bb6e286ca95494047d6
+LLD.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/d875d699afc8e35a3e660fa7c7cf8aee
+LLD.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/e93b4edf2fde1f6396315d315827fc3ada9906178b0c278f0197657b18f9d8d647116266a4024b3c1ebf39af1a6d74e8ab6d99dcc43654f9aa3daf2d554c2ecc
diff --git a/deps/checksums/llvm b/deps/checksums/llvm
index 715ba89ad559e..199779c304a9c 100644
--- a/deps/checksums/llvm
+++ b/deps/checksums/llvm
@@ -1,111 +1,111 @@
-LLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/0d30873e7f66a55acee43d5948fa9c1f
-LLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/5e18d759332b99aa4af44d4c74215e5bad61bda576681f9347a6824b12cc9920fd9c6e87aa73f8acf1f484184e21bf0929fde66f25a091c1189f946f10ff9e18
-LLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/def878000c77970c9fd35071788d73b2
-LLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/3b47f231f283d0a15171e3e8d3f41dd6354a86a5f986e85c739d5413426d0731afcdf0464b7d6c127a895d3d351aa867996004f69f9e8fb74a324421ad85c0f8
-LLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/d507299a26c0a7a4f3d7c7e06a97fd63
-LLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/56cc59f05e595c44a8ef9209f2760db1c312394d91afb09d37ad403cfedab956bb0dfc28c9c461d15e97f000037379404d3a14bc551b579c592f5f3d5f43af93
-LLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8b587dcc1feb233e7c503f3e89d707c0
-LLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/592158975df17c5156ca1fc94518af938cdf76920eca4dd02cf15d8c6bf2a8e98588689ef863bbc24d1a538abdb11e15dd53444d9ce54c1d517902d4cdcdea4c
-LLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/c0c9f2db22ca738bb71e11735a469d7b
-LLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0901683e377aae6ccc649103dcaad238968ef750c569b530c77f775dd6320343cb0337eeb99e5c69fca0de907705630994073025db288d267215624cb5993d77
-LLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/91933ede30f956f2cbc66aa42760e5c8
-LLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b4388126af2c542471cba0a6224aec92c59dc0376a7733a890e020fa267710ef3f77b73d7d1a4013c865d9ae3ddd80814b7c55e451cf930ca37a0bdb20f22a43
-LLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/9bd64f73682db24333e149ffeb909ba9
-LLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/5d2eaac3976de1a29dcce8dffa0ce49fe839d68ba288f6e06e902f359095fc6a0c40d22533ad49401629c21e0363f82c34d8ac0d8c348b201c5a0738390f97da
-LLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/4893c85dc5294deb7d13932bd396569b
-LLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/25f3d4596fea8e3a7375ea1e8cc282fb7ac4afaa68d1c9b02947457d53dd78aa5d0b4ba97ee7d5c2c7138fb78a25e16c3075e113465b70b73f99e9b553d19079
-LLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/dfd4fbfcdf9d114982a8a332879ff69a
-LLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/11d00cb09fb1d73dc55a4fe4dbaedabb266c56b7fdb0254f5c003b27d77373c1823322b2b03d40e06fab1a5015a0370b867e88e53a28c2e9714b66e97ea61c40
-LLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/7f4da380cdfb8285c3449b97abdd89ba
-LLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/714f50b99a44c00d4a03782c5472c6bafbaba8e2c35c82e1a94c82ef74a1cad94675ba58f5e414ff9ed53bd2ca0baf6b96d8a044ab88eeaed68ca9b1d80aa27d
-LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/7061ed8e6c7ff30e641d09a986a6d48a
-LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/96e50a24a5ce85fc2a8f784fb8c6fac027d01ef6236790dadae565c6d7abbf2733747263a6d32da4a01d26042786d960d9dfbb1a8817f3c8dc247e8f27007fec
-LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/5f3d4e151c628eb1ea81fd0b56af9847
-LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/8ec01f93cc7234abf710ff43025bc19661747cc2844dd1f93464802f3f42c83eb1f200ad2855e01657b7bcd3123d786de9a54c4687a62c499b326a40aa555590
-LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5a744d9068877b4455c26a0cf1ae2ead
-LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/c1ca99bf3516eceb06409a428e6b988e6b5fc3f6097dd3800f6cdac8ea90278977b0b494285ef4c59bf34f52d17648d4ff46c119b46b6048235869cefaa08c8c
-LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/b0cd7594ce3ace35ca733df1524df121
-LLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/1b856a2283a676162574f42acba2b59c2bd7e12888a83b21dd656774afad6cf40240bb1dfd2e544ab5f13d43d7b103d03886594f42ea31866b6f7bb0cdb84801
-LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d3d114c4c3dbf78c4657bb35472b9626
-LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/8834f6685accdda8a64f16a907e7f980c435d327c19d6beb01dcd792b99db7e3f4e2b218a63dbf8b90079821a5c21b5c57b761484956d2f9f2547068fc03079e
-LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/ffcb4dea25ca467e2c2ea448caf697f3
-LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/41927a4ada35a543653c4dc10161b3186e826f7eb49507fb02bdcb7ac06c68685114cddeb7d5d0449e7407eda162522549d4597d1c216c2dbbe2bb8ace86724c
-LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/d64410cb9328a1056bfa4244d6ec1ef8
-LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/24b41c566851d0b98e4432657221f60e57f1cf04c073483401a8ea9b928d8e0676b5ce484bbf25209e2ff71d24ba7bef2b327f56be936fef1c7db7e75f3e4306
-LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/34c1baed09eb46be39a532b305d1edc1
-LLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/53c5c59d773057296f4b51a32abaea949326ddbbe2c8342beef3939ee13778361012d0b6826bbbd8d8a4e7959e52bde5b4791b5d689bc1b0adfd264215b217b0
-LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/785db67d3898a9ba9621259053e170b4
-LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/3dfea783f30e85c51129d025912b50a57e9c8275096d6cc52fa1a93752b8c39c804f26dd8dc6fd4db01deaf283c48ebb5671ea45816f3d4d3d507e764b5e3281
-LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/f4bc8c6adc9b21e3b034199c8585c50d
-LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/2eb3a4d559d7885894e787942a719a433d955abfd9587af0e910a75ef77330c557bbaea3db600488e008696f05a56ffd24d367e1b91d692b31cf28d4ac3212de
-LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/b7eb28506784b718d6dd9654ac9742c6
-LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/6ed8273693c7b8947ff20d130c09e9d945fc39f50c2c306b0c5437ac97eaf29befca180e6e8f61f7eb7b4c5193f647032f9846aac68327e8194453d765791426
-LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/4a6b352370dd9dfb5536d6a6788d4072
-LLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/289ad6c530ed1fc43ad355fce7420335e30df4cbd02b5b27373008f91a4f8415eee2681dd7a0c5704da83d4a21752089f5f7202cdbb2a9d3b3ece8fcb26d46b9
-LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/1675466bc589ffb48c4626d7aca1e061
-LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/1d36039fa1d9ccc4715a2bb6db76bc238c65a7416d5e31c15bc9526bfb6c3171d8f2541d5958710837009b95ff315ea09126f1d8ed1c41016352a40ac268b13b
-LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/37525ca67fbaaf5e125f95943e804377
-LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/30a1679e8bfb392a8ff66e30a7f704bff88da4fdbfb0694b0384451148219ee2fc9c256306775ce655ff193b993f11cf6ccaebde2bc8fe2b1553945400e32aa4
-LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/aaf3be684e78fedc69be62ea69cc31ec
-LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/8c6c9b027913439c3456a209539f25e30cb247b297523de18530aac51649717522c5d14ec531a9053f9c82392ef7e36e03d53bd32e329e90fbd9966467a560e0
-LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/2514cd3b344b1c1df29b6ed42bb4e78d
-LLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/5ecbf336054fa831a1aecdb29c01641b3c5a67d44faf64fec1d4b9c86f997b561e58fd011ebb450234371257680222f12ec6bd24aa29b0cc1b4578f8692d4239
-LLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/eb1c80df14af9b80176bcf3e9798e1ce
-LLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/7e4f70d61e2e8b05e8561253968ff3677ea818314753101488f6df8c3024027ff5189b09d42a3b71855a9b919527e7d1a099463f77d21af5bac143acb50cad93
-LLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/50b6ea315963df2469e7d014a0e190dd
-LLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f57ccc09f6ec82a9bb93626953a3ec07a0c1fe265c5b862e16c65751c5ef1d7a34d2c8d32275e2b140ea5ef0657abc0408a9f3f770c6ba615e057bfb63c5c99f
-LLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/4b31b77bda90b61804fb82e75f3df05e
-LLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/dcaa8dc33b02eed25e6a5b7315e56ac65b81352c8cb7966007a4018e54f29f02f4ead95e723e6ea70a378b893fc1036f3df7aac792f5a44552f4b0e2d4ee5dad
-LLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/25a8fec502b17af9b56896436c8c9815
-LLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/05f05b128c151a0946470ac2f609899299e74102817e7e46176728b6ce96612a32b9255603bc770d7f64976dbed0a06ccd289ca30d2d3cabec2a835b8756c750
-LLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/464e16e268b36f7a9edf4a281cc83fa9
-LLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/bec094bf52d95de0f6c49ed4e18be75e5cd655a7e9246c49b361d72db82ac7aa5838c154cf70eba4c6f292fbc867ad83ac0cedea6a278a4c4acca994226a9742
-LLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/18dbfb7b104d56a1167e66e0de830287
-LLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/71c0d3aa067d8a397ab55cd18621124fbe02038dbdac8b67e44485a49c4c5a55cecbda5827f87311448030e1ac98ebb5cfec242e8697907ced74ccde3b41e254
-LLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/cb44e73504c3704c0909f55fe63a3e92
-LLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/e1889df0eced29d82e20087169fcb8cf82fd9e230a9911ec49ff365a76b2cfc3e19ca7c7d14ab9a537d7abce9c169104f400b2756dd032a20fc5e8b211d1b52e
-LLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/df717a78c5393e4a954047e8fe22814d
-LLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/1957b6f3bb3f570f918e13a387c55b294808c3b690b99db4062be6321d4f8336911b17535fa04b359b6943a842ee9b54f136d203b1397d99e780c41c95876249
-LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/92d555d261eda37e9e6cb078e3c2c6eb
-LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/b89b748241bfe4537ff8b64686fa63dc495e64a5ba011240297add47adedb74547547dc2f80b87c686e36218471770ea3253b5b117bfc2e990eb7a524a774ccd
-LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8fec352d4d5499426c978be761d3ce82
-LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/3dcd842bb640a2772f802bae326e92a09be33a25be51931c4bb1b7ec75b9f839a29fedb857aa86ef2b674d6265b1251589572debcacdb02ee7452bd5896af932
-LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/96603a41127d3ccd9b832dfae5b26a30
-LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/088473b8c712fa9e21d70515a7f829456970f0a93f592754905b107adeab5c144b5761382fe1e67fcfab911584e481133ea1f705207f8868e9ae2cc408fd14d4
-LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/252df3705f7ae6544f502f0fd67701b5
-LLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/6c75f1f5e2539c50b6d8d35b483c8d24d1d701e6dbfc59d169d69e5db24c654dae021e1e7ae9c1e7f693ecb296ad08abbc6091f3c8d1df8edf0fc7bf973d1223
-LLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/34c6138393b5407126f43f308d735b41
-LLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/abee7517a142ca79041ef4a669969d86e93f421a40a25530ba21d92f88e13e91958002c967f1911ddfcb5950fa095e3f5e9b60ef8ed305439990f9ad6a697297
-LLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/6e6baa28e352134d12b03326597866d4
-LLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/20c259ce68504c318e3d2789090dcad5a2ca247b9ed3e5d2a6714193b117033003c4df262015fb86b3a2d2fcfc72d2135dff7bdcf71126e50182d2c608863b24
-LLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/a97ee35283986ae5ce0f57ec58d459e9
-LLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/6e529cb46a5d7f9be12c7c9fbb4e0db4d0cb009d55655fefcdf901923f9636f28110de7ae18fe634d551aebf4990c1f5c350b5c9d705daa2e30b08e35a218360
-LLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/1d09d79c4c30ec32b7dc1f513cc6ba3b
-LLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/91024fd81157e0d496fe5c4fdb9f2812a19eb87ffdba009a819ac0e2c6f60145631509f200286369826db707e03825dc62c8c2af02176d10d266e2230cade81d
-LLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/81f2a02cb792bd664b782d7734029d66
-LLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/ddad49a9fbbe902e7efc4849e4980d98b21be0e8af0be71b6e66ac50da01e73058984784863b2a4f4aa12ae62f8b3806a6298e8de38198547d03ab0ada17d853
-LLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/bf7683be32c7792e1947e00062d7b8ef
-LLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b3ebeeed5c428fd5ed2643ef45511b74ee0bf0b02653b9211f002e7ecc9f8ff5437139ca0b282c7f25a0918b0e25d316e97b2522a69099d7614d3d1cbe243f84
-LLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/371fd22021c2d6a150e7a7500dea52d7
-LLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/635cc4cfbf7809b679d5fde80b3af72e22dc056778eb7fc66ff80dcb7706809b4819655e922ea3a1b78c913c116444805b05b8fb98ce84c062ea67b12bac417c
-LLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/a60ed90e12ec86fd71be1e7c00626429
-LLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/d86264d3d89c647ba75b919b338f2ce6dc496536970a3459abb88b3850216561603e4ef43e821d64a1db8cb53f27be12a2a462648b8aa8e5478290e78fc1b66c
-LLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/8f6abe2c11ecadc4e7aced1373bab7b9
-LLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/8746bf3261aeefd3af48b6cb277530add2d1ad7988140d0c086c386213d9c7e0c81c04569237d1f6194b6c7636166b78e87d19ab231a6963aa460e557e94ab3e
-LLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/d81588b9e5be65ee8099f5ff063421d7
-LLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/23f35975c450e0ad84617ed61d0a8fbe0c52e2152fb3f2207913e8c9ea4ec4cd7e1ecbfef283ea8c69ddf453e9978f9015965ac18bbedb95b8f802cea2a44c56
-LLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/bb23932f8c246ba09182c9f35c714714
-LLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/78ab81475ad9e62eae7068a7e0def61c9e10e5f1f97182de3fd1dbc5f4925b05c7f239a151035b086ea7bab97e697073643c26d762be63a0da67b1c1cb03a9a7
-LLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/5c84a61bc941cb920e09a195080195a9
-LLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/083fe443b5b8223ebc12e9f3393394ae790f2a9defcb81b8a1ccbbdb9d2631a6e5e8b4f3b000744d6cd2db6bafce18a1919da80bb563b79b7b008484eb5b4997
-LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/5078269b5db1fd0ba11b9dab936ec538
-LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/69ac651d6229cf4cdc1360ffd17a2a0b5ee3c1efcb13b70f651c3d58d50e9dceb6c53acf0d1f05fdeacf7361460be564662340b4e6eef82cc2422f8f46eede94
-LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/96c2dd5b8c37c516a45d30088bc9c67f
-LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/9f9904cbf0ecbe5e599cf6fee2c689d1b9bf28b1fcb434f98f732af9f02c8ed69fe6107abe12247dc50f7a7f7900a6b5d6e5ea38a0153d4f4e0238dcdecee7b6
-LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/45ac91912beee2f1a348c300830dba87
-LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/034dfb8ede8e63d208d7b07102108f1d69e28644d21919d5478e894d42f77e8bcd54774eb85080cb0b03dfd76f70fbd218d94b0d77867f78a8db5ec492d39545
-LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/82701bc015acc0ab092fac5eb1b7c854
-LLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/1e72b2ed04759607907a9931b8180fbde059f04b1066f4eb3272e16752ab854aca1ce3579cb58853bf87a3ecf2b1acfe14fbad324b5bcfa31824987d45ecc225
+LLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/12c3fa6093cc5653e5fa26d13f950dd2
+LLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/f71fe6373c44cf5671c31f01a373e166175f504bfcf567279928fb9dad2bdbc713d5ebad23f907bd787c6bf5e25d92978b9824d296ee7e7c5611b7fa1d48d576
+LLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/3309cc37575d6e572d0b2029eef6f79f
+LLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/8fba3a677b50793a0e290d8ad53ac4a084016acdf493191669da4269f725e66bd637b63658fda726295c428d53e8f89d865e2f207e4ec3e446e24c8aa9d7892c
+LLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/aa6636ae57ed2994c4c5d6f918b876f9
+LLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/76f27ba7ba8f5fa74f095d31563ca471b559e43b646e0270b721eeaf8e182f41575ff798a7d05e111f9b3ffde6bd487ca8634e3e8f2df73b543666d59d9745a5
+LLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/0d72e13578776a16e57f65e11d87af7e
+LLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/4c217e3ced052226eb43eedc15dcfb21740d36599013bc960734a1cc97abf82198b868181cff425a1a8f5483077657fc36634d6229bac69d13b7bb336c3e3ce0
+LLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/b95d26632c61c68669238cf4f5567a11
+LLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/b65f48ae408e6307b8dccbf6e274da5dd06ad73c25ab1094cc415bb2fda92ed703a1e95c2da44818cefa771ca2bf8b61f465fc815b5a916c961cfe75c44256ab
+LLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/f3c732d4824703770a41dbdb482e95d1
+LLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/0a8e4d5979f4fa560d6c612749848cd8d7354e8b5e621534153f025c9a41eff49ad1010f97938883b4030d7c0042505bfe7cfd4e97459304e3fa18889ba956af
+LLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/22210cb1127bc92daef20200ea8d97f6
+LLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/0f7e8732bcc7b312fb576fc4ca325474db352d82bb6f28f2e559cb4ccd18c7ea339a023c01eac96841a3fac352938f20d4854e7a81774f6b87611f5d5df2c16b
+LLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/63080de3607a2b6fff38f3e0ade67c0f
+LLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/b3ccfc3c9d7c58682b884baa6f19f82394bb66a242c6f6faebd19dc1fb644fb67353f2eb53eee166fde39779ab20b5e9e0fd578a3259cf4a167faa9c25ff97f5
+LLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/2014b5a49dbc9d003a17a188e2ca1d28
+LLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/fb550470378248d64db4e7d090be8006a9b733fdfb7b1bab06b41d72db070212f45e9c2657e250cb229971e95a9113d97e0b5f7b4c1f10793437a61ea11e2a86
+LLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/eeae2d30c3d5be04fcc6fe9c015b6e26
+LLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/4dc990d49cf20093da21aeeeaa5e4e70357c6e4e65c0ec171d245efa49ec8dd969830a92c5395b976fa65a9935475795c63f7200cb1a5fdccc444bb674944bc4
+LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/42481abfdeae9437e20622b292727ce4
+LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/284b967aa9318c3beeba7db40c57130ee820f9c654ee98cc3750dafda0db9fb3781d9dcfe5ef9bb6279c4c39438dc598322bf13acab6f564c845ebf96e00568c
+LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/6231967cfd7d647c2dbbf8212e09fba8
+LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/6be1bec2355c3f433a508c4f7e457b56be0773eca1f5a1c4bf3dab3cfc88c36ce1a733990d0f97d0d9a7d2fc4de3aba7288d4d176e07571c8d4b166dcfab0f5b
+LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/9710043ddda6a2e900973f55cfb8cac1
+LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/4572625f82ab882d2f87fff18e95ae61f25bc30479dea1b59e4eed8b988248fcc7545d83c1a79dee404a26f3581dbf3da1640216e01cdfc33ab52f5da4fa04da
+LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/3edde791f05f1a21c78394f8647d0cdf
+LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/4af32be3fa16b42f75405262c48cbdc79c2bfce8d0e7340ca5fe0a9729ef77ba79233e676a6b42784ea5e93f75730d644f9e11708577dd344de3e89cc073228a
+LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/787c218fe565eca2ec41a4b48e9dc684
+LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/2a98c6ab6523ece4b1f73fe5182e6eecfb7685f631a2db5d36bd081327828a27e73bcc483e4513998cfb83e65fa26ebaff983d8ab6d85b44c63150ca275eaca3
+LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/edb0b203c4375c18d3f2639e58817951
+LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/1e98eaeaa81c0a0cd0543ab673e358998ebac3fd461d91bd81b1373732ca79b585d1eb5554df452552e9d8c7a89227f7eb66b5e4e9cc32924c6d5e018e0d596e
+LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/18ef443c2b6a3942827a0ff9e7a41925
+LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/02709b7681a467571100e57749962816bb72521002179d00112251e0507fc89e4f99564285fdb57b11890cc24b395a659b66cbad0183ab376b6c524d74cae8e3
+LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/c5df91221776250134147bae07fba6a3
+LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/32278bb44eff6ea69ef6b57fc1bd7c3d5894e8ccd411bbd94fac649a567bd51569f0b116349afbcbfd99bf2eeb04d34774e07fe2774890d7676cb1ce552b28e5
+LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/313db1d794cc09c3a09b3d484e1e4998
+LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/3cdcc3d7703839a6d9a1e5f91c96ea04f9308e6706dfc0e62b90f7303224e0849e0fc2609f8de72197b9e0c7b6cd0053f5702c6d509ccf09aa1afc4e5c4a2510
+LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/3eb4fd17af67901c05c35f0239eb6c40
+LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/802ff440d24ffe9e3a276e09c103911569aa6d4fe22d2d541e275658d82cedd65a2af49d10761bbff34a971d1d6d63de59c5e3010c9bdfbd0f1a4123b9a9315b
+LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/46acf77fe40b1c7c2e0572fdc6de3d08
+LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/17ea32d6772ca4382386922f600518ef27f6cc144e9aaeeb5810aa19f39fa2b5d64baa6969047168ad185734f4093acee4638e79c2de8b036b0c14e3f34240ba
+LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/e89e0d5b3c6a1204257e9d1a4f48280e
+LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/08872b5a85463880f1ae71b574b9c4f631c9c466e12d5b268651b877ac3f4544af71ef3d2d5610159a8b67c412c5b9c30d9771764be8e36d6d7a4190b2c9b549
+LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/603eb573cd8892a96bfc700c62a29f70
+LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/486398c7056567f96a398a9248485bdb9dd11c8bf16f22c03052d19dd15d6abc46fa5bb3fd4c65ca0875e51e720896ca8d07b121a97e918b514e05238172af98
+LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/c26795b166048daaf4791337d31070f8
+LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/9739f8281c700df242acdad74493ee3aee33cb72af4d066b6866485e0dffa8d988435a47349acca1de89e6ed6de128ec8342c38606b27d86957c8a5a8d6c8adf
+LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/872456e07981deeba1813b887112cc3a
+LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/6e8410bf106bcc015ce59d716e4f20833c3711e509deb5687427d6a4c60d2081192e05185d95a1f1d3b9d5b9c0b3e66af6fd3eedfb35ed2caf6ce392218e8d9d
+LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/c1c23e2934b5d706bf622f5442bc8288
+LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/8df50c5a168ed70483738ed6c8af2ae41e99f955c2dfbe664844df70b5a72ecbde1c6df2c92abd8e3c66d9b12d8d356e0e812f81f4bc8a0abd33f674c629150d
+LLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ae4281c07b0bd6fd86f575485bac7fd7
+LLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/3b9fac037bef45a6d4807ee8bc92dcc243ac7e773db6f13ba1573afd21e3d7dc87261b692f8ff9f6a9ef54ffa95397840945f9e2f9cb4fdfb076cf3c7dbce0d1
+LLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/5f155150efbc0928150bb8038d2f8376
+LLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/42b369856b1349b18bb6352a7e48a09d89461ccecefbfd1ccca6e839c055181562430fbd6c3fc799e475eb3623ff0ed476ada528751494053fa84a28db7469b8
+LLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6625e69f2053ff151c681b54a5b4f066
+LLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/e5de111a1b22b01c4cb1072f5e30dc2e8df95d06f3c08385e525679db6cd2f54c5298589f1674b8f39268feaf5fcaeaab42558e35f37e9f40dcaf217cc4f0d9c
+LLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/00f8b33c8690104be0fed932224b5ce7
+LLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/41fb024f6568f4b444c1572b4807460d879925729eff64192a3a2f3ee3039da2e00cdc2431d47050565f817d9e0509fb38f9efdfe3f7f0c600566360ec29c8eb
+LLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/57db53c41f8368ae6e8af099395aea4e
+LLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/e0158df4cca8fa133c7b33a1a48b64a5d3ea459f2d4dd27baee556790a7592616ee903d30ec9b63e8ec40dfe840ac694d7ad954ce875583edd91ed7eefeca07b
+LLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/0c397a2ccae8e682b373ce8621abbffc
+LLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/e6dfc3adfff2bff9738ea1e20bbbd1303837a71bc1085413a89d6c284191656e407c873e47f856261b1b0af24c083e4ab167353adc8a5b10d50a509fb40b0d74
+LLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/80cd9387365f58fdb1c1a0a0671b0859
+LLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/64df0443841267e8b049f206445fa7bdcaab82faaa257fcb580d66e7acf5afaded3c3345f2c1568336906432e43eef95c09eec9da5664af5ec5e3d547362280c
+LLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/d02e01273a853875e96e11353441a8c4
+LLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/2f92eceec6fcb1523e0ded8868b30a2d48a1602a2940c78db8a94eaf379460ec480e9f9e90a2738e78d798cc742fd4305303a2414c853211bb2bacf7a167e161
+LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/2748a942e1d98ab0860501ff794fc632
+LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/ccaec0d3602a115e90403f665f0d726f4e0a47abb3c282b159cbe86fea057afcfe86a410193eb3757ace5460a9cf0c78a65c300eaec97dc0cb17c8c7fc01ed64
+LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/835d5665ff9d5074fead9384b57ed98b
+LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/a9c4e0a0c73c0bff96c6150f8f16f19bcfc19ebf9d57d7ff211fff16f2fa5240d5bca319fec9eb9ce86ea71a1f3eba53c246b4a5d0880a1f7652b6e3c6d7c743
+LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6090940682dca61e55da5679ac9b14d3
+LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/9667aab8dac88934deb3d81d91ad460ae841f598dc12d4a140a5690f8358c7765fbea18e5e6e60a727b6ec6e22fd662c4a4443edd1e9ca979deb5a63544dec01
+LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/0576eba702f4e969773c2a5d20cd6961
+LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/bb6b44716bdb9847042f8102a5a48a7bfae4f87e23d22907b96fbb4ad7f85bb9f97607f8a957edb6ff628e410b87f4db674ea43d7ef606d01e3be727c33403c9
+LLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/0c2d909ab7f080be3b15f9bb73dff1db
+LLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/d7bb2a593240f1fe0a0b47be742e40fa45da158b2f0f49a1e6ae20dffb5bfbdbe63fb9479a5502eafa214b38d4ba08752a35b95d2877bed847e93c39131e7fc5
+LLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/f6e521d1f0305a7c358f8018a6d3df5e
+LLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/8cc409d17aa18f3c841b09f93d03d66e2d34266b373d6e1ede0b01ec4758a65919942956bbef0cbea307125fbcfc3308001c001bb0d820072ea96141f8b88cb0
+LLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/58b1ac68917ea270aa92d81c78e1d089
+LLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/281b68a2f58cde167d50623d148df542d57454f818a95ed068446f9f7505f2f9f62eab3f1558cf8818ac55b129809beb0809b0fb1e4fa7deeaf2f883831832be
+LLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/7eb9716113fad1d48ff2a6eee4905f38
+LLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/60bbe9cd7a090c149766ac91c20dd0205bb30112265b1508c7a8417a318a86c349faae6e969866440615f6925690c6abe76cb5d66733c38063ff0fef0deff65c
+LLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/587c6b7d6e9f4594858ae8f6579e5d33
+LLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/6cd8ccec9bc25e5404d1f5e90d2a8a567fc5a99c5883f27f590cceaba2c8836c68ed3ee6f050a68fd9b4e774e210678a0bb79dfd20ceb8188e2f9e0e272bf458
+LLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/f1ddf447dda04ed967f5f36ffe0cb1f2
+LLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/b7f1ddc117f1ac4a042aa64828f840cf253dad57c6cba01c2547f258aa7afd1dc38746b3b4c10eb0eb488752542b01cc66e4c60cadeb6e5b02b588ed2241be08
+LLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/14428c76528d068bc85f2e7118641904
+LLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/03a2046bf672f360b8d3264d893f79c1f4d586e082b07527045dc5a86b7a588c4a8582ab3bec0b45cf05a7d6a3b2cb3071df7e8bf29254037dbf177e82dad85a
+LLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/446eaa5a78b2233d2680deb6ad5e7f07
+LLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/402ac0383c8d6612086b67fb5a00139fd9c099c3f40fea07d5ed6df828b70a94374399c03e727f5e4199b85b86874ea889d934f8f7f182214237b088c141b054
+LLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/a7ea8c17587eed02af5fd9c3d6e0e140
+LLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/2ec6221e3f6d0668e96fd591627f050c683c8b4acde5997a3474a510a4075db03873378a5494f4ae4859cc59739c1650ab73469ac7e431ebc981e9682e76de4f
+LLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/d72375b9860833944e75d9725c91c868
+LLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/c4b183930c633c0845a4d32ccf68d0407bbc4c87b8402b3d50908d0493bca2f78205c529566299a328860187cc4d54d85d53ac23f1b9be05524b91ee84d55d0c
+LLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/85b5fb4034cccd32f61c5d8413615cf8
+LLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/4c29053db95641bba91e22c5ec1bcc7e176313c4ac99cef5a27094a28ea36c10911b734c272049ae2064ccad7e77d81759ca8904cbbb9572bfe8ad99ba62a2c8
+LLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/5f5a0af4cea5cd867c34f70f3b03e6e9
+LLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/93fdf4b0a04adb9031ce671f10f95513de505a79a6db1fe4b97316c8b9fef0d8c3b40e3fe464b9bfd2f8325a798f3421c290ff5cce99c1c297b6816f07b84b86
+LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/4af50d211a55eb032d7fa6499c6a24b6
+LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/a9a39a87150dbda78dfb572c316b5c763749f92222ffde636e6b0e902385921f0176a0ca943c7bb99226153e6c837e61b257dc1de28cfe8261f493cbec4f3df4
+LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/955dec5e8aa76fc2a9d4be0a4f279764
+LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/51550218470003056eda7303ccc19615fb1586d6fb6b76eeb77a94295a72f24a1dbea449f884c603ba4c495fea920323f7033715166bd3921ae326c170d3645c
+LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/61583d1f198cb17e5e3b9bcfd100caac
+LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/0cb8393050114b2c273af745bb1fd8919fbdae7eb929270449573750b7f3c245570f1abdd0406200c93152c5b26d04537abab61f196212ebb3f018f2ca06ce89
+LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/5e57fd18ef38986436d93d029b779e3f
+LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/fd5c1408c7a4a8eb82a59d7dfa8762bbd9e8bada613c97238b824f94bd11eb6a895ecc83cd17b7e8376d16ddf14e0a151c4d6c3357ab8bdb0016f7a55550f6a5
 LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/md5/b95ad4844e649bf46db43683b55b9f4f
 LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/sha512/15e0996aebe6db91fe58121001aa7ea4b23685ead3c26b5d89afae34b535e34b4e801a971f4854d8e1a1fbc805cece06272470622eef863e225358113a127913
 LLVMLibUnwind.v12.0.1+0.aarch64-linux-gnu.tar.gz/md5/6d8783dc9b86c9884e0877f0d8ac4167
@@ -138,115 +138,115 @@ LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/md5/54ac594b4c8e7f261034a8
 LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/sha512/a43756afd92081e6dd7244d162862fc318b41ca110a5e8be6e4ee2d8fdfd8fb0f79961ae55e48913e055779791bd1c0ecd34fd59281fb66b3c4f24a1f44128f0
 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/md5/83cf8fc2a085a73b8af4245a82b7d32f
 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/sha512/297a5c7b33bd3f57878871eccb3b9879ea5549639523a1b9db356b710cafb232906a74d668315340d60ba0c5087d3400f14ab92c3704e32e062e6b546abf7df6
-libLLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/aafac8a677723e932e6a4cdb6bbb4411
-libLLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/b584923d317db14a72434ec9d684a34e0c7df2c9b88fc4f005922784fa0fea6975894fd5aae3842b81dd7c7cabd34ecc8faadfa0b808bbb582c7eac0ca94ebd0
-libLLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/d890bc7254bf75563c79261b35feb8fd
-libLLVM.v15.0.7+10.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/55a6bdc18476cb2b98b6e9370da8efd519c2a25624eda32fd301cdd3f9d9863f4a113b631536b6e982d551bb3a0f3e8cdb690699ef0513926ae5c86f65db1f8a
-libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/f4c53b8cea77f992d3c24088cf0c49ed
-libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/2b61db1a554f33c5f46b00f4032c722922755267de8f05de04165907329b6b4e33986255084699291be8a2faa7aa5e36aa0bcb5eec2aa324cb8c16e451518adf
-libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/52c355a71a585f09aef28ad4605cb51e
-libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/3a010828b7a6fb51101cf08a74702d2d3d5d85579a3e23a91dff1b3622ca6fd8f04948cefbbf74d03e3cf7955b566dc439f04ce73ba77efce9d8c8e1cc37d790
-libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/bb96ff22c46a5587b066e5994c1d806d
-libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d643d142777122cc745dfe853070007f70abcb32a9fe5bdaff3ca0eae77f5b774323ccf1c51340ad2f18c72fbbf83bece673dde0c48f94b1ee4204a69bbcdbe4
-libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/9a68655b71b38c61b59959ee890199f0
-libLLVM.v15.0.7+10.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1b9e20d00114819029aad078aa201a1bcabbf5a5b66bf9867019479180a37cc930cd50127657f87474ae045d1ee808298378e3ac2b8079492a8a3ce4663bdd60
-libLLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/ad4fb8227d147a16b19442b194a22467
-libLLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/fb9c1184de6ea663b3c1b20ba5a5f65afa6bd2a0ea70472db8dd15246b7f0cbe7a0d29eb3dda66d969a6a9b48269f34c200431279e2215760f64e74de6f865c7
-libLLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/8981bd41cb59d4680fff276a5cea6b17
-libLLVM.v15.0.7+10.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/5992cce6b5bfd38f62b3b370f1ac72d106ffe42c075d26cb6462651f4e9ca1d8bf8a91a254ae4d36b656643f5926229d5ff6fe96e1b31151c7e96f85160a2571
-libLLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/f25e87b0d1c66dff45971bb6c5d2a6d1
-libLLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/581ea7266aa711b355f3a0c676bb3e7bdd33e0297e24afdf420bc5e2ac9cc4bd9330150b8f49af977c9fbfad3c0987bf6f901e93743c844a3a1ee3a4d7902717
-libLLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/a6a0cc01bdaafc1f34d35453ecc89fd7
-libLLVM.v15.0.7+10.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/cea08396c6617a6ab8ef8749c4af9d15b60171462fded556726f35dbccab888b763637002987f95dcccead210f70c947458068c9ab1fef696cba61334010ee9a
-libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d0694876f0a4af8f738b1ef5b15b7483
-libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9dc388988ad1a05212e7306a494a8800be76378bb797c01bb9148b8db02f6734d7bf74b1ac2d19eead331aee4121c0eeda7e05635196f5eb44ae4fada1e8f2be
-libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/92868cf79a7e9af62d91f4d1418aad4a
-libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/093ec44f15ec8f8cd855f4c56a70f51b244837cabff3804cd8d5513b3ba7a1ce4d021009a2cd1e484e8705aeab2af5c3f470af2d03b9c21cc3619ba3e5e80621
-libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/9ef52c4ddb07b6edb399fd6050af7067
-libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/e109335b53f7bc98dc837c4f90c085ba37864ee9e4c9b8c0888b6f00c5f083a2639e3af6c4a29287b3e9b0da6af555832b1cd4a8a514a963d8f45458d70bc291
-libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/894ceace311aad57cde915bc4f7e3068
-libLLVM.v15.0.7+10.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/a075d62dbcec46612ee7b58e00698a8aabcb53705396e8aaae9488517eca34c52bdb5daadd6d21ba721f87a0a46b79bfbbf2268e545020fd60bbd8222249f939
-libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/3a6cb7ab61c9739915ff6697ca6584ae
-libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/7e50687474b0cf3b1d01737b82d5d8076b2559e43a3fbdd9fd376d2f0e68cfb6535e458d7b8781a4a0535f00f28b3b29d0fe390cdceddb84ca4bfd360e814b66
-libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/3213bdb23eacbbf1dbb21e5758c038f1
-libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/51fb41605c5167486c866885eead1c95ccc11e9b96ca222875fc0965fd97c020afd11aea52abb883870138d5029434cdc5a27d6b5fd5d7966a61a9a11c5d1fe0
-libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/0ebd2f002adbfd00a1a39959b45dd4d1
-libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/01793b10cab22b3a78c53a9394655572696b2bad368d0f9432582109cd363432ce709c2de04130395ef66453479f154cef1d6a2249340ab6391f85ba4111ab1a
-libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/8ff3ccd7327e47d1772f6a7ed2d33bf4
-libLLVM.v15.0.7+10.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/cb01d95f48f41e17b3b4c6549d5fdf5b1c6c8d0e38462796eef6966ad75a81e05a829ed732b189d34e2d3af7f70dcc2530b6b2692cf151f43d804c88a1ce466e
-libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/dd9e9d296953f7cf32cbe39b519c9e59
-libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/e2e3d398c83bf3b7a0cb084577493455ce24ef551edc59297761a8df4007c07e6a7e3727a33f3a650a69639ba3d5de96051fdb6230a985a907582db3ef0e5d2f
-libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/62df2ac64bb8195960a93cf1f1fee8b4
-libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/ba01d9e1e6ed1096a04fedec5f319497620a8df655535104726a1497f27a2df4766955d4ac1e161296c313bbd5f0cd8c2d524c41aec234a8c38a1717caf56a63
-libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/69e44d007b7f44fefb1622533e2964f9
-libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/9d934d951c3e67c6f008438db3159f7a4628b22db25e5f47fde21669120ae766bcea839adfee748a9b1dd7f3f3d758e88fd7bcf95e0d9289d378062805bfb954
-libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/0a8eb8bac53734bec7f153ec6a46bd34
-libLLVM.v15.0.7+10.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/1ffab09538ec5267840d4d74f8b9fccc1213707471b19ed7a45789da49bcda2d78a4da0d6954de828b444a33fb020b771d3453fe943334ee12af62984a96b409
-libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/320247c2e5d1bfbe966ff93e194bc6ca
-libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/4b38a64de0794befd2be7256419de25eb0be7642db922f15dc359c1ecbfd647e3e1e75f0671f71e66455853af34912dfc2960d313f269d9318040583d48d05e1
-libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/1a15e742f9109325842b08296b900d73
-libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/1c3844c7eb23b7829bdc9d5928199cdaff42e98ee0a931912e9931724e110b965e7ec5b8443c3af79f4694397fa5093786e7e7257344df895cbb22cd827df86e
-libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/d88d9d0e9eab5681bf92c91cf5d8ddde
-libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/a956df66e3a71fd995aeee43cd2ff8838c346de0a12ea4ec849742bf2f9530e9959a316b16c4ecdf184d5692293125309ac7668d2992f81f17b207657e2c1bf4
-libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/1c0ce845334af339b4e797af5bda727f
-libLLVM.v15.0.7+10.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/8be9c57a67331cdd5dbcf9466bd2346d21fcb100beae0e2027961d8b7b57d26ba03e785dc701f2cbbff60cc298e6aff54a8890fdafe4f4e505d3e91b8ac6adcb
-libLLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/2bbbd07363fda9e70bfce36a6c5ad6eb
-libLLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/0e4be179ecff5be8a715b744ac441a73cd742d98ee7ac521de4cec1d150fbb2485c29138d6f489289c7a15f74b5a68418133375162caa324a72f4ab1f95232f4
-libLLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/dd655c71803ffae63e89e44f627a1649
-libLLVM.v15.0.7+10.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/467974be3051359de81e2d08c7895cfdcac9ec9d6ba850c7515915b2358745795ed2ddd3c5cc12744942fa72a0eb28ce5f4ad4f622106d4a19f9e289e5357a27
-libLLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/79c051e8492e8c6696f356bf450c641d
-libLLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/da679eea0673b1c117363785147d08f372e3be95c8e00bfc5277e662784be3232a1a66c1552c9bb538a5343fcdca0f7a4131805acd239216b26c05b81eedd97d
-libLLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7d910217dcf88c9c59d3a1c4383c5067
-libLLVM.v15.0.7+10.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/10ad390312d937f40e05c3444509f8adfbe0ee8fb6829d35a9a8ec7736106e75d6d5f48b9154e140e4cb59ce4d659dff624ae4a3f6353523d462f63fde4122d2
-libLLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/168402080c3d56f85a298bbaea1c1b17
-libLLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/27c29f50968c01adca981939bf1aba2010341ab4aafe60c4554b954209ef04e793a572404028a63f51ad9ed962bc72540f2270486b9a1f4501535fb547df11b3
-libLLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/92a55a6891a199d49b1d523a3fb24766
-libLLVM.v15.0.7+10.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/82e52b2b177758ee8c410407c6dc4a5f72816e2b97f9c971b6250e27d9bca1ebf73c5700dfd67c648a0ab0a48c48d6eabee0ee9bfa820ee8cf4fec64a708fc43
-libLLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/441231777c430560297c930f1e41191c
-libLLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/6ecbb8a014ab4e9ba5c930d81020d9ca47feb2105335e874a5f46a08aa0a2d8ad3622434a21d4361191baf5868e1fd6b9a04a69ada27d3ec1dac4334e92cd640
-libLLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/5418d900f7eaecaa8d0258a498757fda
-libLLVM.v15.0.7+10.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/fb25c480cc1826b3aa4a4d861281b6e701b1c792ac4030ad25265ab9510a159994a74aaf33d20fb8ed545526ca11eb693ae7cb0e79499d3248097d39f9691073
-libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/06b1e8271b1551b32c1cdadee06c40c1
-libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/7c8c10225e9cf75a6b23317e8a277cd548e8f2de41ccfef91cbc66338f94ba59c520c7fa3b4baecce8dbca6ec3e0f241aa09f898d44b1b459b738b7c243f636c
-libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/527a5f29eb6141c2ae43c186cd6c9f2c
-libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/466c863bde18d1ff889379ff18c79b7566b755a8207fe09e7a3faa770de242345e781aaa446bd2b656136905f0d2462f9062061052d0472c1079c966a03c68b1
-libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/bc24a37e40f45480aa5e458f022cc7ce
-libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/83121dad17e11c6bb2984ff1e7232ad77da362d3699f7ee1c15a8778d21635d87d89d483cb5848034552f23c2448f47c05419247a326c1b843eacd6cb9e99d0a
-libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/0b0ee5ee232cf0da7ad227609d1c09d1
-libLLVM.v15.0.7+10.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/8465b942c400e7a811bd4d46596ca57bcb5ddfed80358f7256d5671db3f797342e9a8ca800d74785874c8643c45367c952f4109d63cebce4cba897db3671e0db
-libLLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/558e9e1ca9306d382a32f7fdd076a509
-libLLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/7d1d0e8366a3541edeae36ef0a198db9bfaf7eaf54064c8b3eff34fc5efa5628d41001a7a94cea4ba6f960b64ab6849780ac79d25bfb5e30fb7255439c2fa012
-libLLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/8c5afffc8d684d7fc42ad46d2b3e0eb8
-libLLVM.v15.0.7+10.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/7a857e2b4842c2520600b245f9f3aa44e5206959fd013ab36ca2a9274862f04f5953d460e6024ed572f1ee9099d4afbc74187c310546476e6e3763cb4a68ac14
-libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/97b51e70fb151f680d268ef348f4e8ba
-libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/5da888921c4bd3bb801c136c02a37f8866e468a02e7716290dc73ba85cfc3adb42c66c881e7bc55366b3d98f4190aa8aa10c5477464e1f53b6c3dbffd9b396a4
-libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/c505b9ab36ce3f2c3f22a03edd8c17ad
-libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/c69f17c49286c352557bf2d5d34a6872184558612f435d0cda2b55892d3cbad91862f19cd0dd2129d5e8ccf6172127445b17a5d9b7c8a136abb15175f49b1c78
-libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/9aabdd2b8c2c448fa346727c89468d93
-libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/25372337eb7b55bcd51407e9ee202d55633786b6742e38ad12677b0939c824bbcb2e10cef0d6f1bff6f4c0ad8b461c30fde862daf4ddc8a4bc4ea3d91436d4e7
-libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/58466a504b06dbfb8dc48c15184193c8
-libLLVM.v15.0.7+10.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/d1d76bdaf3e74a1003fef3a623675be7a9ec0c64f7c5a0c88e7da0bd0384791b39e46dc297b3544f634a1820ffd051a3843c2e91d9f53319609d66542ea30e23
-libLLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/6b6f0d707452691ba0c3504616f2548b
-libLLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/6c4bad2ab972cc89316f246b0af6c1907650d17685c0923ca2f23144aac7ecc4fdbc29308fcb76d1c67ec99b6148cb0e48f49319d62834c8cbe750a68735d604
-libLLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/319a680fa35212f8327c5f3cf8348241
-libLLVM.v15.0.7+10.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/c9ba68a75a3491320e9e7c6eae378ce30cb504450fca5e7e3953175182ba4ef7347fc5aff0219617200b508244aa8691427469cfc49a230ac70a690504ffee6a
-libLLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/230bf82575576a349873550a4e3f3f40
-libLLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/1a7cab070cc58b5bc1d5c3397f0218fb7c24758d0a1b0e1f8ed3baf71e45b3014afc6c0ff94b3f9c8627dbd62603240a320a84888b4c69df1cfc485e16c9c1f6
-libLLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/bce28b0fde016756db056611d119b49a
-libLLVM.v15.0.7+10.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/8247dcba4f31dcc22d9771b3c5e6e96b29c5019df24a5b3f026c88a822877bbab75987e512108523951ec938b47113b0f6c161067b2935e9fb5735839b18fee2
-libLLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/7ac5d8081c414e6ca91bedb0f5cd5f78
-libLLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/86899309b86b542dae0812e4ba78ba9dfb7dd6c5d9a9db3fb868d78930a906cd70e2dc63bcadf8a085b0fd5690af1df80c0cec9df3c1dabe2c312c049defff39
-libLLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/b5c2edca868b332968d63d161ad7a0fa
-libLLVM.v15.0.7+10.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/352e5abb30d78cae34d10d25f3cc0f856d79ff034a8905610ae6c25944216d3dd78444593f3b1355a7e541fb47adcb88df312ffb374604638cd08d3105c7dcca
-libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/3a818c98e5b2dcb086a58390ef61d82d
-libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/c238fd4f9cb573f5b47c3b71e3d7b7a26457267a049f318295f3e2ab2498ac6418d79e0734dde6dc47df859b670d8e8588ab29dc47fd7bd6e4f49db1c4b252b6
-libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/3533470b13310d9cff7e7a7c3619d921
-libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/89a533d3485dba9611ad799f9b3f26af83ed5dede874943c230236a09c2e6ab36df167dbe34f7121af5f291d0720d0975096df46b5f5db34c9822602654572e5
-libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/bfa2faaee4ffa22513c5109e7c76e788
-libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/dbc995dfcc6da651c990b2b9254aab4d46a8dc05fc2961d5fb7199fc9af3b44d0e90b3206f605d9f0e3e9acfac6b534c3e9e5b8d05f0dd17f5c3c664e72c6d7f
-libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/e92c1827d1e7b815675740bbc5000cde
-libLLVM.v15.0.7+10.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/b098df199c1f30b0a5084c91af8cc444fbf9699474ea78513489a5cc434f8235952359f0d769871c7a8b344216c8de4893c517ec7a6b12c4098b585cfa67666a
-llvm-julia-15.0.7-10.tar.gz/md5/e74093b6e760645ca1567aecce27d463
-llvm-julia-15.0.7-10.tar.gz/sha512/9d2b466c0368996bfa825cdc4fb8e00d0cd43521761946b310c8bc6fff461771f4454bf0b7f8be44d723462a9a2c3721504c4250a3fccdf969ffa789ee40d058
+libLLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/c26ce3cae44c64c52dcbf813d42bcd53
+libLLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/c00c51a3ae82217da929e2a5e5c6418085da77f04447406af91d9ad48875f1d53e1dc692bdba62828d0e2c7a00ad76a1123e88b30404a945a1bad762b2ee6926
+libLLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/558677141b34c66b975d5795bfff71b0
+libLLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/0441d6a2f627a5c0c1dd7a118d3e5adbee0693f2587c7ceb8e969e933311c6dae96b9a6999f3c1376a9aa195d0747e4257f3c6f928307cc7f2bf24076ec8d965
+libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/5c77609ed227d348df1bfd8063706317
+libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/2eae7778da9aa4725911b68a9006c7f08627c7ea980cd355260c2c26e38aea2c831bdf97a1796db967ed76ff72f822c810c27268073b102ef64cc9b56ff8d053
+libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/1444c73725196aa585024599fde8b6de
+libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/d37f3f9135207f675471d858d6dcf13bd38a8b0159153a8dfebb69885326de330cbbae74ce5dd4744cd7ad48af45f802eef1a3133521517fe1de4ee3e7f42868
+libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/e107910180ae316cdd3aeae0d0b264c4
+libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/19912be8ba86bcc3507ea308834ad0c5effcc19b1478eb1491693a7595d080cddcf610089e902e159f8e88c37e26dc330c465e920c4aa652a7c02a6bbc0e3ecf
+libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/f3ef392b873bbd75c12667a06d8a5cce
+libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/71fcc827fbc0eee2e2c5e98ca9bb6ea4bfb4301b5532140df3cd63558f6fa5a3eb42e0bd1e77b100efa915d3d5cf64dfcee49cf8720f2ce49f3eeff78ceea0a8
+libLLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/0ae09acda1cf4c2e1577cbca08e71b32
+libLLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/6f96687b3eec662f95d4537ea73da03986fed30962d3aa44ac5c8d79845c298ddddaca6ea655a824653ea17aade961b0bcfdd9bf0b13eb1cc82aec67a6e7921a
+libLLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/29a26fd89536fe6616e2a2d383b30eaf
+libLLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/0cfc60d39c7a75c7b758a7ca3aa409b09091a10e5f1e9ba75ca6e806d12e2b486ef617ec140095e035af5e3858200266a81a19837f94072ba16fc5ae5f014fa8
+libLLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/b4deb520de74282d8e4ec9c48420fddb
+libLLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/16337b87b183367690b509261411e92f73679cefab1c3941eba43c4ef6b884fb9f450c0f3032831cba7ded0dbeba412920d183a2b18e20560bd9453be26634f2
+libLLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/0f537899cec525d5ff2414648178b39f
+libLLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/0baa91b57669acab34d0d8f28de38aba83e6ddefa8904019195715bd21440d586e2ee38354a2ee1faeea8b655b11f33fed988a6526c2c02c7298fe69d11ac5ee
+libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/515d36bec34c4988e84eae6248e05cb7
+libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/5d3011095d52722202409e9e1324e1f8f8f0248535a4f6622f38321106f7ee67a61999ce3713bfd750612ea0bc90ef8530b02d9e17ddfdde7159f39115293f20
+libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/05abe658c81a6fa9b4762f46850ee8c8
+libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/7f6feb745735e8cc7e644d40ace1649f7d81da22d344bd20aa7b14dff039c076e82af053bd3d03fd0fd048f7724eb1378c90e543015fa4484845cca79ac411bf
+libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/ed8deb655ded1d10ded32fdd1a002191
+libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/47a55c9f67b2268fee32b5fb3eff34dc9af1d0ce140343d653345b3ab7f333e256a059e257a25c03982eb4ed0b6e2226e1fe2b603c3f9cdff28516a85b11de8e
+libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/4fab909e5c21259a0d677aff7d7c4b9d
+libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/2e98ac6f9215fd4bb3bd7adfb111078ae7c017fcf9360049d250ecb6a926ee36d79526c54f4193d774364b30188d17d3237d702c9023485675fad59d37f81223
+libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/1776a7013121522e3964d4fa4a378a29
+libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/da83ef347e2479e0c5dbda6e41e5ae2810cdef21c64a380cbabcd4f77957b1b185a5899da121ceca4b8860aa5abad82fb67672e1a3b88491bcae9c063e01a293
+libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/d5b2bbcb2c50d17a33b37a1e96c5e181
+libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/5bcfc83011bc6cec870d471c7c6c13cbd72e310cf43b582fa0ea46cbca448eef63ad8b376275a47047a8187ba8c1c83af4027613ca87bade5d798f2367ce3039
+libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/c2cb6fd28984d18a025b6905f6390044
+libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/d06646f38cbe91ea4cc1a2ab1f10a1d2e83aec55c046c7762d6d45c40ab98a368350e4103068b50d90ce76860cea65e1cb52ee5dba408725d4f291cb649b6a03
+libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/63e36fd036f87c8143118d6ac43766f9
+libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/eb90365497fc6bfeb9007e982576db604a27876c94988902fd519a11a053e20fe89f29307d84b492adf10a3005eba6042b24d05dba889c81e307b6cd9f040991
+libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/9a71682426992456392dd7a46f148c99
+libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/7412fe32f9a224e086c05417549d6c1b995ed87320fddc1efa85efdc60dfa0072406a876341a07228c913415e056c3263bdad8f789856970d7f24b4e78445f74
+libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/5387befc374331e1ad99c8886e4c9315
+libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/eefd4f115513a7532a495307e1ab5dbfcb8ca178e4cc3fcc034588ac8142ff85310f7186ff154ab2ac9ad813dd40a550a0e9bfbabc117861d5c05981698a4b87
+libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/ac1d5437b754fdb46126d0cdd104ccc5
+libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/8ae367cffb7fa2f632c7e18a1dfbebba7500ed3e3c66b9af0637c8b15c1f674f8a3fbee5b8157f5d6d9eba7f290825644220ae99ad60393e1fc2f1d2ddef7c00
+libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/f896dcd15b8ca46c8206fb7b6cf7805d
+libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/c777ea1767d42c84a9a78f01b20cc5156245f6f056596c283d4877025b7e3783eafec9f89db65eee47f974cef6e85d89555b303ff5a594831ed4408d76ffeb32
+libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/e1a21d625111bd4fd0234348cb07c342
+libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/192d90311f4ee069e371084680ee3e959d0a11004d50ac6d9786942c87f2c14c887996674a89ffe9a0d3c6e9057cf9db03208bf6980da72460a004bd2f005e90
+libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/678ed2858666f6fe08d91398ef76b45e
+libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/cb9846fe1db101f242ae85c25afc6591077fbf6705c44898a370ff53ce75c619ce0a4f760952254017c5e72f2ef2befc87d1f0b22c1fda23a42f4cc7f35a7e7a
+libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/01ae54de30b68736c183af26d692d97d
+libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/3ad4848dd986a2a41605979e99d0eae8f397813df1ffec9f63d66f810a26700344ca3fdf73eb64e734e03e86dcaf39deedfd68f0fd814cad46c44b7ed97b4cf6
+libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/f2731aadb95c07f8f50be885ab7ae10e
+libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/c90df10819e7a70f67a59708a4ef9768eb45d031b54f8dd69393fd6107cb7a3cdf943cf4ffcfd96f9a13541bbf1094fb1b151c1cf1a41c154bb7e5b9f4cce024
+libLLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/b24bfc1aefcf199295c5053fc8c3125e
+libLLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/497d657c9daf479d2d1da8de9611e32f531c66adfbc45e5bac2d0375280a694b0b213d31d8134ca9cd50c1dfa62980426a5d9582e27395ba33bc4c29e638ac73
+libLLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/c029eff316b3d2313ed37f1afea5f58e
+libLLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/127ee3303146397552034459d7ee1520940dbaa2fef04d1457a56d91baaa6c20dfb1432bfc33394cc3ae1aa1aa1d198185446b0dac4727c72f4c341bfea2ca28
+libLLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/c09cc4037506f653eb0efa00743f29eb
+libLLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/aaaeed57c2bdea708719fe8ba14b76c4fd972ab7ba888998ae93240a3d7290cd424602b3495ce22777bf14c61ce75c4552c1c6174c351f8dd76468d8bf346b55
+libLLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/75844675e2a2cf1f184fe14c064202c0
+libLLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/a524ed10afe6f736e42e9ea2fe0afde3b1d8ca9a84be648f7a998f80fe6fa059057f994289d576c7e993835836d9756e6df277771f69db7f05b153826b016337
+libLLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/5098da200f43628e8783dccf3fe07c2c
+libLLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/7f37e926746fbb2537e70998c921d7c5b8b825e6baebba8d7136ab28b5c26c741458ee874ea9e193658d0b76b6b7dd3b543873b563f5124f270500c62cd9717e
+libLLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/636dfc4e622fabd91b7a1dc6b5d0938f
+libLLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/a000b3365be2069561451355f6c39626a0c10334559c21cfb9991b69eb2ab2ca120a7b60ec0d227fbbf44e5c05dec824dc2b43f2eda151d44940376cc050785b
+libLLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/a2d05e71a65a0dcb78b6d5eb5661c627
+libLLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/b66b60a9c7aff46a314d400a71fa6d798becf625b91985b1c5695fe759c9364353f54727d5f88b2e4517bc8efe5acd5ae419068cfc82285ee1ac4c49c048c726
+libLLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4e4b88747cd274b7b1c7e49bffc6cc12
+libLLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/225fc0128068f5fc4e8d9ef6ae1e2d655f2b6ed655754429f93461b962f82ddb3dc4223e66ee642ad063020e6c97c27dd25cb810a038f9a3c9be5eb21eb9cf70
+libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/5490540be6910471221fde1a09b01fae
+libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/59c34838777bbf4c9382b21c06359662c586e47c1eff59b428eed07e58a907e0c1934647ec7cdd00cfb391f30df7782a745a6dcb4e9c421ad67ec0c28cebce92
+libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/d662aeeedbeff55d7c769437252cb4ab
+libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/c4eefd0a1b50bb815c108b1a9fe39100f3d61079199f2ec5f62d83c07baa0f8cf5a2ace14cf92c0741659df287329bdf89e48327397a9371ae08327594a45794
+libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/369a47a5c50051084e1f84bf6f79f9d2
+libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/3aeb7f533eb00f7d17dd535826f9a4f706291d00ef2a5853be3e6472e92af9e973324c5491710f0474963342cd9d44bd855102d829c04adb4e5fffb8dbe0b0d2
+libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/a1daeeedd9ef2c5f702e2c8d515f676b
+libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/413c1b6bd44bed1210353da5335f0dd663fa72b0608167acb7f5cde4a2a2b45f171bb58dacc89532c9a18ccdf81cc2734d7b807dfd2fc9649f584e1505a3361b
+libLLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/288cca68b558cb5eaed44267759b4c29
+libLLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/89da650382d788c1221c8c8fc2d6f79a8476bcb0bd1e5f2aa5a6ae1d43ab4b8d904d95f34db88146a0345437761fe4aa48869a54e474b50cbf58c3daf5494c5f
+libLLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/46b30d4cb9c6b1c9bf567c34dff005f6
+libLLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/44e5cea2609c79d3269a758f063d0011d0ff0de50d64f1c2090eeb47ae052bb92357aeed7455567b5c29c5825287f5b991c740c371841631f27d8499ce0360d3
+libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/aa7533f8d2a42c8b99409b9103a09be2
+libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/97d7530b317ba16ad1f275a193b160fcc4f571f18d52deb48db0adde3a1c569be6aa64ac080f0e2cabe550439612ed822689e23d707223b98eeef58ef8c51b5d
+libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/abe9dc9d7b96712bb3f8693f0c3e3e98
+libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/5629105bd3fdb9fbfc8607254352dcbbc21370b1b28a71950d73c6c902cb5ae33d73ebd047a8c5f556c63596e758b18c4fee267870053d0fce89297cdd442daf
+libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d2371214faea05c2143937f3a18f3b6c
+libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/82eb0cf01964f34d150b3f1dc7563ae88b586074b368dd9cdc690ca7a75b53de8a1f78c8ce44eaa9276c5c06e4bdacdf8c3901a717c867949c7944e564f6e0a5
+libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/c4460768b4185848615abbf4ea3c5232
+libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/768e8f16103dba47e396079cb652d6333f8f558178b21cbc6a4b1a65b869353b75b8567f76b0f06421be44cd72df6a78b901f56b85a22b1e114b78644cba6785
+libLLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/2c6a7b15126cb4158e0a54b02d9d812a
+libLLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/4c76cfe122c59bb45fe64c8c5bf5ebf7ef2efaafd1ac0a1b1aac8d47f0010e3e5d454e33da5066df02eb383ef6aafc9c434e90f88df8f3a8f179315e8684a57f
+libLLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/fb515854e492a32722dda370f6c09aa3
+libLLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/195f1d391e936dd82f8efbd952d32b452e30d98ea0fd2653f2fc1332242245b2d74ed9a0ab9051dcc17a4ba02fa3d25137d72dc5135376270a49e9bcf131fb9a
+libLLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/788ab9d676633e38ea1815cff2ab14b3
+libLLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/9c38abfa4fc462093e7226e07890b85a85a55ef07fbb0e36da74c32fc95710054b29a0b192b893caeefd0f592aedc89901b85e0b29ce0db259d97a3eb49ae417
+libLLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/043759732d4bb279866bb2362c0b6172
+libLLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/f6032c36b85849104aaf95a1cf4082851ff63bcde2d437eca0c5145dbe040236b8f452dcdd5aab12536bf4f9ad3982d36c95c2f77d0222ebc00052f724453229
+libLLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/c27a112e2f097b86252df8243d5dd634
+libLLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/8734e7991819440b3dbfea66a86b808ff08788adcfd96c254a07f9c6edf7ecca8990447cee92e9a33713fe8bab078fae405e7a6245c9c3f5679a68b86e523743
+libLLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/d23ec5a65abba215c1bde92191df792c
+libLLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/90aded28ccb1ce1ebbb4fbd9092998730f50cda58913d99617833be666d3ec0efea50bc0cb01c524e1abe42df466af1a9061aa7eb7c69510dc89a5cb43f37c07
+libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/b1512ca40c4fb2f771dbe5486c71941a
+libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/8343bf6cfffcaa0b8b2bdbfccbf0d8e69e0ace390e9112c5a7c1229c2c7d9dd186c7b350b26f0e2e51ab85c1ec8e77e31e9a619276676ecba86d05c4d15e005a
+libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/723bd254520545cfa441d92f1be270d4
+libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/3db6b330a49ceb7193ddc17a00c2f9866eb98b364c58ab90acd38bd0b2c8bb0e0b319d0e308fb310ed6701456f60788dd371dd211ed4fb7a99a55296c62944bf
+libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/ca01f13bb88048870732f65ecc05aeb0
+libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/ad4779d51f88165782ef49b657dd03520f093a5097d20c7bb3e7b7198e268afbbd04347ce7acae2d683dd75c0b255dea7bf39d15cd25369a4796b14dfc1ab627
+libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/594bec1e655f5a4433ee9c266fa891b4
+libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/03c907b4671e1571166c049a43ee81647481d1e236ec482be84eb4430691cbb44cb5ff701993c3cd7963bbcc8b8ddb97b97bb80cec692ee3f059713fc1adb960
+llvm-julia-16.0.6-2.tar.gz/md5/f05607b71ac8d1e7c30430d2a9efa0a6
+llvm-julia-16.0.6-2.tar.gz/sha512/5f2f88b4673b13780fa819c78cb27fc5dab77c2976768ae4f7863b904c911e39fc18ee85d212e512a7c60081c74efd1fa2e7142b78002982533b7326ff808f24
 llvmunwind-12.0.1.tar.xz/md5/4ec327cee517fdb1f6a20e83748e2c7b
 llvmunwind-12.0.1.tar.xz/sha512/847b6ba03010a43f4fdbfdc49bf16d18fd18474d01584712e651b11191814bf7c1cf53475021d9ee447ed78413202b4ed97973d7bdd851d3e49f8d06f55a7af4
diff --git a/deps/clang.version b/deps/clang.version
index 6e50e2413f622..853a22d1dfc7d 100644
--- a/deps/clang.version
+++ b/deps/clang.version
@@ -1,4 +1,4 @@
 ## jll artifact
 # Clang (paired with LLVM, only here as a JLL download)
 CLANG_JLL_NAME := Clang
-CLANG_JLL_VER  := 15.0.7+10
+CLANG_JLL_VER  := 16.0.6+3
diff --git a/deps/lld.version b/deps/lld.version
index 56303e3dc0292..d61d973917b80 100644
--- a/deps/lld.version
+++ b/deps/lld.version
@@ -1,3 +1,3 @@
 ## jll artifact
 LLD_JLL_NAME := LLD
-LLD_JLL_VER := 15.0.7+10
+LLD_JLL_VER := 16.0.6+3
diff --git a/deps/llvm-tools.version b/deps/llvm-tools.version
index e7fd7ae57622a..54a1fa6b531a9 100644
--- a/deps/llvm-tools.version
+++ b/deps/llvm-tools.version
@@ -1,5 +1,5 @@
 ## jll artifact
 # LLVM_tools (downloads LLVM_jll to get things like `lit` and `opt`)
 LLVM_TOOLS_JLL_NAME := LLVM
-LLVM_TOOLS_JLL_VER := 15.0.7+10
-LLVM_TOOLS_ASSERT_JLL_VER := 15.0.7+10
+LLVM_TOOLS_JLL_VER := 16.0.6+3
+LLVM_TOOLS_ASSERT_JLL_VER := 16.0.6+3
diff --git a/deps/llvm.mk b/deps/llvm.mk
index a06db1fb0781b..18dab5dbceb30 100644
--- a/deps/llvm.mk
+++ b/deps/llvm.mk
@@ -133,7 +133,7 @@ endif # USE_PERF_JITEVENTS
 
 ifeq ($(BUILD_LLDB),1)
 ifeq ($(USECLANG),0)
-LLVM_CXXFLAGS += -std=c++0x
+LLVM_CXXFLAGS += -std=c++17
 endif # USECLANG
 ifeq ($(LLDB_DISABLE_PYTHON),1)
 LLVM_CXXFLAGS += -DLLDB_DISABLE_PYTHON
diff --git a/deps/llvm.version b/deps/llvm.version
index 918889e016f2c..1f12302452c31 100644
--- a/deps/llvm.version
+++ b/deps/llvm.version
@@ -2,14 +2,14 @@
 
 ## jll artifact
 LLVM_JLL_NAME := libLLVM
-LLVM_ASSERT_JLL_VER := 15.0.7+10
+LLVM_ASSERT_JLL_VER := 16.0.6+3
 ## source build
 # Version number of LLVM
-LLVM_VER := 15.0.7
+LLVM_VER := 16.0.6
 # Git branch name in `LLVM_GIT_URL` repository
-LLVM_BRANCH=julia-15.0.7-10
+LLVM_BRANCH=julia-16.0.6-2
 # Git ref in `LLVM_GIT_URL` repository
-LLVM_SHA1=julia-15.0.7-10
+LLVM_SHA1=julia-16.0.6-2
 
 ## Following options are used to automatically fetch patchset from Julia's fork.  This is
 ## useful if you want to build an external LLVM while still applying Julia's patches.
@@ -18,6 +18,6 @@ LLVM_APPLY_JULIA_PATCHES := 0
 # GitHub repository to use for fetching the Julia patches to apply to LLVM source code.
 LLVM_JULIA_DIFF_GITHUB_REPO := https://github.com/llvm/llvm-project
 # Base GitHub ref for generating the diff.
-LLVM_BASE_REF := llvm:llvmorg-15.0.7
+LLVM_BASE_REF := llvm:llvmorg-16.0.6
 # Julia fork's GitHub ref for generating the diff.
-LLVM_JULIA_REF := JuliaLang:julia-15.0.7-9
+LLVM_JULIA_REF := JuliaLang:julia-16.0.6-0
diff --git a/src/Makefile b/src/Makefile
index c78df75bdceb5..95614d506ba45 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -114,6 +114,10 @@ PUBLIC_HEADER_TARGETS := $(addprefix $(build_includedir)/julia/,$(notdir $(PUBLI
 LLVM_LDFLAGS := $(shell $(LLVM_CONFIG_HOST) --ldflags)
 LLVM_CXXFLAGS := $(shell $(LLVM_CONFIG_HOST) --cxxflags)
 
+ifeq ($(OS)_$(BINARY),WINNT_32)
+LLVM_CXXFLAGS += -I$(SRCDIR)/support/win32-clang-ABI-bug
+endif
+
 # llvm-config --cxxflags does not return -DNDEBUG
 ifeq ($(shell $(LLVM_CONFIG_HOST) --assertion-mode),OFF)
 LLVM_CXXFLAGS += -DNDEBUG
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index be70016e45f21..658de49561d82 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1049,8 +1049,21 @@ static AOTOutputs add_output_impl(Module &M, TargetMachine &SourceTM, ShardTimer
             // but LLVM doesn't let us emit a GlobalAlias to a declaration...
             // So for now we inject a definition of these functions that calls our runtime
             // functions. We do so after optimization to avoid cloning these functions.
-
             // Float16 conversion routines
+#if defined(_CPU_X86_64_) && defined(_OS_DARWIN_) && JL_LLVM_VERSION >= 160000
+            // LLVM 16 reverted to soft-float ABI for passing half on x86_64 Darwin
+            // https://github.com/llvm/llvm-project/commit/2bcf51c7f82ca7752d1bba390a2e0cb5fdd05ca9
+            injectCRTAlias(M, "__gnu_h2f_ieee", "julia_half_to_float",
+                    FunctionType::get(Type::getFloatTy(M.getContext()), { Type::getInt16Ty(M.getContext()) }, false));
+            injectCRTAlias(M, "__extendhfsf2", "julia_half_to_float",
+                    FunctionType::get(Type::getFloatTy(M.getContext()), { Type::getInt16Ty(M.getContext()) }, false));
+            injectCRTAlias(M, "__gnu_f2h_ieee", "julia_float_to_half",
+                    FunctionType::get(Type::getInt16Ty(M.getContext()), { Type::getFloatTy(M.getContext()) }, false));
+            injectCRTAlias(M, "__truncsfhf2", "julia_float_to_half",
+                    FunctionType::get(Type::getInt16Ty(M.getContext()), { Type::getFloatTy(M.getContext()) }, false));
+            injectCRTAlias(M, "__truncdfhf2", "julia_double_to_half",
+                    FunctionType::get(Type::getInt16Ty(M.getContext()), { Type::getDoubleTy(M.getContext()) }, false));
+#else
             injectCRTAlias(M, "__gnu_h2f_ieee", "julia__gnu_h2f_ieee",
                     FunctionType::get(Type::getFloatTy(M.getContext()), { Type::getHalfTy(M.getContext()) }, false));
             injectCRTAlias(M, "__extendhfsf2", "julia__gnu_h2f_ieee",
@@ -1061,6 +1074,7 @@ static AOTOutputs add_output_impl(Module &M, TargetMachine &SourceTM, ShardTimer
                     FunctionType::get(Type::getHalfTy(M.getContext()), { Type::getFloatTy(M.getContext()) }, false));
             injectCRTAlias(M, "__truncdfhf2", "julia__truncdfhf2",
                     FunctionType::get(Type::getHalfTy(M.getContext()), { Type::getDoubleTy(M.getContext()) }, false));
+#endif
 
             // BFloat16 conversion routines
             injectCRTAlias(M, "__truncsfbf2", "julia__truncsfbf2",
@@ -1361,6 +1375,7 @@ static SmallVector<AOTOutputs, 16> add_output(Module &M, TargetMachine &TM, Stri
         for (unsigned i = 0; i < threads; i++) {
             std::function<void()> func = [&, i]() {
                 LLVMContext ctx;
+                SetOpaquePointer(ctx);
                 // Lazily deserialize the entire module
                 timers[i].deserialize.startTimer();
                 auto EM = getLazyBitcodeModule(MemoryBufferRef(StringRef(serialized.data(), serialized.size()), "Optimized"), ctx);
@@ -1562,6 +1577,7 @@ void jl_dump_native_impl(void *native_code,
     if (z) {
         JL_TIMING(NATIVE_AOT, NATIVE_Sysimg);
         LLVMContext Context;
+        SetOpaquePointer(Context);
         Module sysimgM("sysimg", Context);
         sysimgM.setTargetTriple(TheTriple.str());
         sysimgM.setDataLayout(DL);
@@ -1698,6 +1714,7 @@ void jl_dump_native_impl(void *native_code,
     {
         JL_TIMING(NATIVE_AOT, NATIVE_Metadata);
         LLVMContext Context;
+        SetOpaquePointer(Context);
         Module metadataM("metadata", Context);
         metadataM.setTargetTriple(TheTriple.str());
         metadataM.setDataLayout(DL);
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 8c6880d7245cd..b4716b13f2dd1 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -911,7 +911,7 @@ static bool is_tupletype_homogeneous(jl_svec_t *t, bool allow_va = false)
 }
 
 static bool for_each_uniontype_small(
-        std::function<void(unsigned, jl_datatype_t*)> f,
+        llvm::function_ref<void(unsigned, jl_datatype_t*)> f,
         jl_value_t *ty,
         unsigned &counter)
 {
@@ -4046,12 +4046,12 @@ static jl_cgval_t emit_memoryref(jl_codectx_t &ctx, const jl_cgval_t &ref, jl_cg
             Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
             Value *inbound = ctx.builder.CreateICmpULT(newdata, mlen);
             ctx.builder.CreateCondBr(inbound, endBB, failBB);
-            ctx.f->getBasicBlockList().push_back(failBB);
+            failBB->insertInto(ctx.f);
             ctx.builder.SetInsertPoint(failBB);
             ctx.builder.CreateCall(prepare_call(jlboundserror_func),
                 { mark_callee_rooted(ctx, boxed(ctx, ref)), i });
             ctx.builder.CreateUnreachable();
-            ctx.f->getBasicBlockList().push_back(endBB);
+            endBB->insertInto(ctx.f);
             ctx.builder.SetInsertPoint(endBB);
         }
     }
@@ -4119,12 +4119,12 @@ static jl_cgval_t emit_memoryref(jl_codectx_t &ctx, const jl_cgval_t &ref, jl_cg
             Value *inbound = ctx.builder.CreateICmpULT(idx0, mlen);
 #endif
             ctx.builder.CreateCondBr(inbound, endBB, failBB);
-            ctx.f->getBasicBlockList().push_back(failBB);
+            failBB->insertInto(ctx.f);
             ctx.builder.SetInsertPoint(failBB);
             ctx.builder.CreateCall(prepare_call(jlboundserror_func),
                 { mark_callee_rooted(ctx, boxed(ctx, ref)), i });
             ctx.builder.CreateUnreachable();
-            ctx.f->getBasicBlockList().push_back(endBB);
+            endBB->insertInto(ctx.f);
             ctx.builder.SetInsertPoint(endBB);
         }
     }
diff --git a/src/clangsa/GCChecker.cpp b/src/clangsa/GCChecker.cpp
index 8aa0ef009f4eb..f8e73c486a862 100644
--- a/src/clangsa/GCChecker.cpp
+++ b/src/clangsa/GCChecker.cpp
@@ -1,5 +1,6 @@
 // This file is a part of Julia. License is MIT: https://julialang.org/license
 
+#include "clang/AST/Type.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/StaticAnalyzer/Checkers/SValExplainer.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
@@ -14,6 +15,7 @@
 #include "clang/Tooling/Tooling.h"
 #include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
 
+#include "llvm/Support/Debug.h"
 #include <iostream>
 #include <memory>
 
@@ -894,9 +896,11 @@ bool GCChecker::isSafepoint(const CallEvent &Call, CheckerContext &C) const {
     if (!Decl || !FD) {
       if (Callee == nullptr) {
         isCalleeSafepoint = true;
-      } else if (const TypedefType *TDT = dyn_cast<TypedefType>(Callee->getType())) {
-        isCalleeSafepoint =
-            !declHasAnnotation(TDT->getDecl(), "julia_not_safepoint");
+      } else if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(Callee->getType())){
+        if (const TypedefType *TDT = dyn_cast<TypedefType>(ET->getNamedType())) {
+          isCalleeSafepoint =
+              !declHasAnnotation(TDT->getDecl(), "julia_not_safepoint");
+        }
       } else if (const CXXPseudoDestructorExpr *PDE =
                      dyn_cast<CXXPseudoDestructorExpr>(Callee)) {
         // A pseudo-destructor is an expression that looks like a member
@@ -941,7 +945,7 @@ bool GCChecker::processPotentialSafepoint(const CallEvent &Call,
             isGCTrackedType(ParmType->getPointeeType())) {
           // This is probably an out parameter. Find the value it refers to now.
           SVal Loaded =
-              State->getSVal(Call.getArgSVal(i).getAs<Loc>().getValue());
+              State->getSVal(*(Call.getArgSVal(i).getAs<Loc>()));
           SpeciallyRootedSymbol = Loaded.getAsSymbol();
           continue;
         }
@@ -1520,7 +1524,7 @@ bool GCChecker::evalCall(const CallEvent &Call, CheckerContext &C) const {
       }
     }
     if (FD) {
-      Loc ItemsLoc = State->getLValue(FD, ArrayList).getAs<Loc>().getValue();
+      Loc ItemsLoc = *(State->getLValue(FD, ArrayList).getAs<Loc>());
       SVal Items = State->getSVal(ItemsLoc);
       if (Items.isUnknown()) {
         Items = C.getSValBuilder().conjureSymbolVal(
@@ -1688,7 +1692,7 @@ void GCChecker::checkLocation(SVal SLoc, bool IsLoad, const Stmt *S,
   // better than this.
   if (IsLoad && (RS = State->get<GCRootMap>(SLoc.getAsRegion()))) {
     SymbolRef LoadedSym =
-        State->getSVal(SLoc.getAs<Loc>().getValue()).getAsSymbol();
+        State->getSVal(*SLoc.getAs<Loc>()).getAsSymbol();
     if (LoadedSym) {
       const ValueState *ValS = State->get<GCValueMap>(LoadedSym);
       if (!ValS || !ValS->isRooted() || ValS->RootDepth > RS->RootedAtDepth) {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index ca96e1bcc5545..d9038e2c21671 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1055,7 +1055,7 @@ static const auto jl_alloc_obj_func = new JuliaFunction<TypeFnContextAndSizeT>{
         FnAttrs.addAllocKindAttr(AllocFnKind::Alloc);
 #endif
 #if JL_LLVM_VERSION >= 160000
-        FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | inaccessibleMemOnly(ModRefInfo::ModRef));
+        FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef));
 #endif
         FnAttrs.addAttribute(Attribute::WillReturn);
         FnAttrs.addAttribute(Attribute::NoUnwind);
@@ -1314,7 +1314,7 @@ static const auto jl_allocgenericmemory = new JuliaFunction<TypeFnContextAndSize
             AttrBuilder FnAttrs(C);
             AttrBuilder RetAttrs(C);
 #if JL_LLVM_VERSION >= 160000
-            FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef) | argMemOnly(MemoryEffects::ModRefInfo::Ref));
+            FnAttrs.addMemoryAttr(MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef) | MemoryEffects::argMemOnly(ModRefInfo::Ref));
 #endif
             FnAttrs.addAttribute(Attribute::WillReturn);
             RetAttrs.addAlignmentAttr(Align(16));
@@ -1423,11 +1423,24 @@ static const auto gc_loaded_func = new JuliaFunction<>{
     [](LLVMContext &C) { return FunctionType::get(PointerType::get(JuliaType::get_prjlvalue_ty(C), AddressSpace::Loaded),
             {JuliaType::get_prjlvalue_ty(C), PointerType::get(JuliaType::get_prjlvalue_ty(C), 0)}, false); },
     [](LLVMContext &C) {
-        AttributeSet FnAttrs = Attributes(C, {Attribute::ReadNone, Attribute::NoSync, Attribute::NoUnwind, Attribute::Speculatable, Attribute::WillReturn, Attribute::NoRecurse});
-        AttributeSet RetAttrs = Attributes(C, {Attribute::NonNull, Attribute::NoUndef});
-        return AttributeList::get(C, FnAttrs, RetAttrs,
+        AttrBuilder FnAttrs(C);
+        FnAttrs.addAttribute(Attribute::NoSync);
+        FnAttrs.addAttribute(Attribute::NoUnwind);
+        FnAttrs.addAttribute(Attribute::Speculatable);
+        FnAttrs.addAttribute(Attribute::WillReturn);
+        FnAttrs.addAttribute(Attribute::NoRecurse);
+#if JL_LLVM_VERSION >= 160000
+        FnAttrs.addMemoryAttr(MemoryEffects::none());
+#else
+        FnAttrs.addAttribute(Attribute::ReadNone);
+#endif
+        AttrBuilder RetAttrs(C);
+        RetAttrs.addAttribute(Attribute::NonNull);
+        RetAttrs.addAttribute(Attribute::NoUndef);
+        return AttributeList::get(C, AttributeSet::get(C,FnAttrs), AttributeSet::get(C,RetAttrs),
                 { Attributes(C, {Attribute::NonNull, Attribute::NoUndef, Attribute::ReadNone, Attribute::NoCapture}),
-                  Attributes(C, {Attribute::NonNull, Attribute::NoUndef, Attribute::ReadNone}) }); },
+                  Attributes(C, {Attribute::NonNull, Attribute::NoUndef, Attribute::ReadNone}) });
+                  },
 };
 
 // julia.call represents a call with julia calling convention, it is used as
@@ -3714,11 +3727,11 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                 failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
                 endBB = BasicBlock::Create(ctx.builder.getContext(), "load");
                 ctx.builder.CreateCondBr(ctx.builder.CreateIsNull(mlen), failBB, endBB);
-                ctx.f->getBasicBlockList().push_back(failBB);
+                failBB->insertInto(ctx.f);
                 ctx.builder.SetInsertPoint(failBB);
                 ctx.builder.CreateCall(prepare_call(jlboundserror_func), { mark_callee_rooted(ctx, mem), ConstantInt::get(ctx.types().T_size, 1) });
                 ctx.builder.CreateUnreachable();
-                ctx.f->getBasicBlockList().push_back(endBB);
+                endBB->insertInto(ctx.f);
                 ctx.builder.SetInsertPoint(endBB);
             }
             bool isboxed = layout->flags.arrayelem_isboxed;
@@ -3787,11 +3800,11 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                 failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
                 endBB = BasicBlock::Create(ctx.builder.getContext(), "load");
                 ctx.builder.CreateCondBr(ctx.builder.CreateIsNull(mlen), failBB, endBB);
-                ctx.f->getBasicBlockList().push_back(failBB);
+                failBB->insertInto(ctx.f);
                 ctx.builder.SetInsertPoint(failBB);
                 ctx.builder.CreateCall(prepare_call(jlboundserror_func), { mark_callee_rooted(ctx, mem), ConstantInt::get(ctx.types().T_size, 1) });
                 ctx.builder.CreateUnreachable();
-                ctx.f->getBasicBlockList().push_back(endBB);
+                endBB->insertInto(ctx.f);
                 ctx.builder.SetInsertPoint(endBB);
             }
             emit_typecheck(ctx, val, ety, "memoryset");
@@ -3891,8 +3904,9 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                     BasicBlock *passBB, *endBB, *fromBB;
                     passBB = BasicBlock::Create(ctx.builder.getContext(), "load");
                     endBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
-                    ctx.f->getBasicBlockList().push_back(passBB);
-                    ctx.f->getBasicBlockList().push_back(endBB);
+
+                    passBB->insertInto(ctx.f);
+                    endBB->insertInto(ctx.f);
                     fromBB = ctx.builder.CreateCondBr(oob, endBB, passBB)->getParent();
                     ctx.builder.SetInsertPoint(endBB);
                     result = ctx.builder.CreatePHI(getInt1Ty(ctx.builder.getContext()), 2);
@@ -5286,9 +5300,9 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
             Instruction *phi = dest->clone();
             phi->insertAfter(dest);
             PHINode *Tindex_phi = PHINode::Create(getInt8Ty(ctx.builder.getContext()), jl_array_nrows(edges), "tindex_phi");
-            BB->getInstList().insert(InsertPt, Tindex_phi);
+            Tindex_phi->insertInto(BB, InsertPt);
             PHINode *ptr_phi = PHINode::Create(ctx.types().T_prjlvalue, jl_array_nrows(edges), "ptr_phi");
-            BB->getInstList().insert(InsertPt, ptr_phi);
+            ptr_phi->insertInto(BB, InsertPt);
             Value *isboxed = ctx.builder.CreateICmpNE(
                     ctx.builder.CreateAnd(Tindex_phi, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), UNION_BOX_MARKER)),
                     ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0));
@@ -5306,7 +5320,7 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
         }
         else if (allunbox) {
             PHINode *Tindex_phi = PHINode::Create(getInt8Ty(ctx.builder.getContext()), jl_array_nrows(edges), "tindex_phi");
-            BB->getInstList().insert(InsertPt, Tindex_phi);
+            Tindex_phi->insertInto(BB, InsertPt);
             jl_cgval_t val = mark_julia_slot(NULL, phiType, Tindex_phi, ctx.tbaa().tbaa_stack);
             ctx.PhiNodes.push_back(std::make_tuple(val, BB, dest, (PHINode*)NULL, r));
             ctx.SAvalues[idx] = val;
@@ -5340,7 +5354,7 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
     }
     else {
         value_phi = PHINode::Create(vtype, jl_array_nrows(edges), "value_phi");
-        BB->getInstList().insert(InsertPt, value_phi);
+        value_phi->insertInto(BB, InsertPt);
         slot = mark_julia_type(ctx, value_phi, isboxed, phiType);
     }
     ctx.PhiNodes.push_back(std::make_tuple(slot, BB, dest, value_phi, r));
@@ -9547,6 +9561,8 @@ char jl_using_perf_jitevents = 0;
 
 int jl_is_timing_passes = 0;
 
+int jl_opaque_ptrs_set = 0;
+
 extern "C" void jl_init_llvm(void)
 {
     jl_page_size = jl_getpagesize();
@@ -9604,6 +9620,8 @@ extern "C" void jl_init_llvm(void)
     clopt = llvmopts.lookup("opaque-pointers");
     if (clopt && clopt->getNumOccurrences() == 0) {
         clopt->addOccurrence(1, clopt->ArgStr, "false", true);
+    } else {
+        jl_opaque_ptrs_set = 1;
     }
 
     clopt = llvmopts.lookup("time-passes");
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 3ed86c688f6dd..74b9acf10bce3 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -1655,7 +1655,7 @@ void optimizeDLSyms(Module &M) {
     JuliaOJIT::DLSymOptimizer(true)(M);
 }
 
-void fixupTM(TargetMachine &TM){
+void fixupTM(TargetMachine &TM) {
     auto TheTriple = TM.getTargetTriple();
     if (jl_options.opt_level < 2) {
         if (!TheTriple.isARM() && !TheTriple.isPPC64() && !TheTriple.isAArch64())
@@ -1665,6 +1665,17 @@ void fixupTM(TargetMachine &TM){
     }
 }
 
+extern int jl_opaque_ptrs_set;
+void SetOpaquePointer(LLVMContext &ctx) {
+    if (jl_opaque_ptrs_set)
+        return;
+#ifndef JL_LLVM_OPAQUE_POINTERS
+    ctx.setOpaquePointers(false);
+#else
+    ctx.setOpaquePointers(true);
+#endif
+}
+
 llvm::DataLayout jl_create_datalayout(TargetMachine &TM) {
     // Mark our address spaces as non-integral
     auto jl_data_layout = TM.createDataLayout();
@@ -1686,12 +1697,7 @@ JuliaOJIT::JuliaOJIT()
     DLSymOpt(std::make_unique<DLSymOptimizer>(false)),
     ContextPool([](){
         auto ctx = std::make_unique<LLVMContext>();
-        if (!ctx->hasSetOpaquePointersValue())
-#ifndef JL_LLVM_OPAQUE_POINTERS
-            ctx->setOpaquePointers(false);
-#else
-            ctx->setOpaquePointers(true);
-#endif
+        SetOpaquePointer(*ctx);
         return orc::ThreadSafeContext(std::move(ctx));
     }),
 #ifdef JL_USE_JITLINK
@@ -1793,15 +1799,24 @@ JuliaOJIT::JuliaOJIT()
 
     orc::SymbolAliasMap jl_crt = {
         // Float16 conversion routines
-        { mangle("__gnu_h2f_ieee"), { mangle("julia__gnu_h2f_ieee"), JITSymbolFlags::Exported } },
-        { mangle("__extendhfsf2"),  { mangle("julia__gnu_h2f_ieee"), JITSymbolFlags::Exported } },
-        { mangle("__gnu_f2h_ieee"), { mangle("julia__gnu_f2h_ieee"), JITSymbolFlags::Exported } },
-        { mangle("__truncsfhf2"),   { mangle("julia__gnu_f2h_ieee"), JITSymbolFlags::Exported } },
-        { mangle("__truncdfhf2"),   { mangle("julia__truncdfhf2"),   JITSymbolFlags::Exported } },
-
+#if defined(_CPU_X86_64_) && defined(_OS_DARWIN_) && JL_LLVM_VERSION >= 160000
+        // LLVM 16 reverted to soft-float ABI for passing half on x86_64 Darwin
+        // https://github.com/llvm/llvm-project/commit/2bcf51c7f82ca7752d1bba390a2e0cb5fdd05ca9
+        { mangle("__gnu_h2f_ieee"), { mangle("julia_half_to_float"),  JITSymbolFlags::Exported } },
+        { mangle("__extendhfsf2"),  { mangle("julia_half_to_float"),  JITSymbolFlags::Exported } },
+        { mangle("__gnu_f2h_ieee"), { mangle("julia_float_to_half"),  JITSymbolFlags::Exported } },
+        { mangle("__truncsfhf2"),   { mangle("julia_float_to_half"),  JITSymbolFlags::Exported } },
+        { mangle("__truncdfhf2"),   { mangle("julia_double_to_half"), JITSymbolFlags::Exported } },
+#else
+        { mangle("__gnu_h2f_ieee"), { mangle("julia__gnu_h2f_ieee"),  JITSymbolFlags::Exported } },
+        { mangle("__extendhfsf2"),  { mangle("julia__gnu_h2f_ieee"),  JITSymbolFlags::Exported } },
+        { mangle("__gnu_f2h_ieee"), { mangle("julia__gnu_f2h_ieee"),  JITSymbolFlags::Exported } },
+        { mangle("__truncsfhf2"),   { mangle("julia__gnu_f2h_ieee"),  JITSymbolFlags::Exported } },
+        { mangle("__truncdfhf2"),   { mangle("julia__truncdfhf2"),    JITSymbolFlags::Exported } },
+#endif
         // BFloat16 conversion routines
-        { mangle("__truncsfbf2"),   { mangle("julia__truncsfbf2"),   JITSymbolFlags::Exported } },
-        { mangle("__truncdfbf2"),   { mangle("julia__truncdfbf2"),   JITSymbolFlags::Exported } },
+        { mangle("__truncsfbf2"),   { mangle("julia__truncsfbf2"),    JITSymbolFlags::Exported } },
+        { mangle("__truncdfbf2"),   { mangle("julia__truncdfbf2"),    JITSymbolFlags::Exported } },
     };
     cantFail(GlobalJD.define(orc::symbolAliases(jl_crt)));
 
diff --git a/src/jitlayers.h b/src/jitlayers.h
index 622fe9131861d..35d950f82f38a 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -612,6 +612,7 @@ Module &jl_codegen_params_t::shared_module() JL_NOTSAFEPOINT {
     return *_shared_module;
 }
 void fixupTM(TargetMachine &TM) JL_NOTSAFEPOINT;
+void SetOpaquePointer(LLVMContext &ctx) JL_NOTSAFEPOINT;
 
 void optimizeDLSyms(Module &M);
 
diff --git a/src/julia.h b/src/julia.h
index 1f5da14c40f58..8c757f538f5f4 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -954,6 +954,7 @@ extern void JL_GC_PUSH2(void *, void *) JL_NOTSAFEPOINT;
 extern void JL_GC_PUSH3(void *, void *, void *)  JL_NOTSAFEPOINT;
 extern void JL_GC_PUSH4(void *, void *, void *, void *)  JL_NOTSAFEPOINT;
 extern void JL_GC_PUSH5(void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT;
+extern void JL_GC_PUSH6(void *, void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT;
 extern void JL_GC_PUSH7(void *, void *, void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT;
 extern void JL_GC_PUSH8(void *, void *, void *, void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT;
 extern void _JL_GC_PUSHARGS(jl_value_t **, size_t) JL_NOTSAFEPOINT;
diff --git a/src/llvm-pass-helpers.cpp b/src/llvm-pass-helpers.cpp
index d17ce3105135c..9c62a8a5711a5 100644
--- a/src/llvm-pass-helpers.cpp
+++ b/src/llvm-pass-helpers.cpp
@@ -128,7 +128,7 @@ namespace jl_intrinsics {
     {
         auto FnAttrs = AttrBuilder(target->getContext());
 #if JL_LLVM_VERSION >= 160000
-        FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | inaccessibleMemOnly(ModRefInfo::ModRef));
+        FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef));
 #endif
         FnAttrs.addAllocKindAttr(AllocFnKind::Alloc);
         FnAttrs.addAttribute(Attribute::WillReturn);
diff --git a/src/llvm-version.h b/src/llvm-version.h
index 7b8dfbbae92d6..f7da953a99562 100644
--- a/src/llvm-version.h
+++ b/src/llvm-version.h
@@ -10,8 +10,8 @@
 #define JL_LLVM_VERSION (LLVM_VERSION_MAJOR * 10000 + LLVM_VERSION_MINOR * 100 \
                         + LLVM_VERSION_PATCH)
 
-#if JL_LLVM_VERSION < 140000
-    #error Only LLVM versions >= 14.0.0 are supported by Julia
+#if JL_LLVM_VERSION < 150000
+    #error Only LLVM versions >= 15.0.0 are supported by Julia
 #endif
 
 #if JL_LLVM_VERSION >= 160000
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index 4b099521d33f9..c4b07914907e6 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -79,7 +79,6 @@
 #include <llvm/Transforms/Vectorize/LoopVectorize.h>
 #include <llvm/Transforms/Vectorize/SLPVectorizer.h>
 #include <llvm/Transforms/Vectorize/VectorCombine.h>
-
 #ifdef _COMPILER_GCC_
 #pragma GCC diagnostic pop
 #endif
@@ -158,10 +157,16 @@ namespace {
             // Opts.UseAfterScope = CodeGenOpts.SanitizeAddressUseAfterScope;
             // Opts.UseAfterReturn = CodeGenOpts.getSanitizeAddressUseAfterReturn();
             // MPM.addPass(RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
+            //Let's assume the defaults are actually fine for our purposes
+    #if JL_LLVM_VERSION < 160000
             // MPM.addPass(ModuleAddressSanitizerPass(
             //     Opts, UseGlobalGC, UseOdrIndicator, DestructorKind));
-            //Let's assume the defaults are actually fine for our purposes
             MPM.addPass(ModuleAddressSanitizerPass(AddressSanitizerOptions()));
+    #else // LLVM 16+
+            // MPM.addPass(AddressSanitizerPass(
+            //     Opts, UseGlobalGC, UseOdrIndicator, DestructorKind));
+            MPM.addPass(AddressSanitizerPass(AddressSanitizerOptions(), true, false));
+    #endif
         //   }
         };
         ASanPass(/*SanitizerKind::Address, */false);
@@ -545,6 +550,7 @@ static void buildIntrinsicLoweringPipeline(ModulePassManager &MPM, PassBuilder *
             MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
         }
         JULIA_PASS(MPM.addPass(LowerPTLSPass(options.dump_native)));
+        MPM.addPass(RemoveJuliaAddrspacesPass()); //TODO: Make this conditional on arches (GlobalISel doesn't like our addrsspaces)
         if (O.getSpeedupLevel() >= 1) {
             FunctionPassManager FPM;
             FPM.addPass(InstCombinePass());
diff --git a/src/processor.h b/src/processor.h
index a4c8deb9a8796..e49af919f67b5 100644
--- a/src/processor.h
+++ b/src/processor.h
@@ -244,7 +244,7 @@ JL_DLLEXPORT int32_t jl_get_default_nans(void);
 #include <vector>
 
 extern JL_DLLEXPORT bool jl_processor_print_help;
-
+// NOLINTBEGIN(clang-diagnostic-return-type-c-linkage)
 /**
  * Returns the CPU name and feature string to be used by LLVM JIT.
  *
@@ -278,7 +278,7 @@ struct jl_target_spec_t {
 extern "C" JL_DLLEXPORT llvm::SmallVector<jl_target_spec_t, 0> jl_get_llvm_clone_targets(void) JL_NOTSAFEPOINT;
 std::string jl_get_cpu_name_llvm(void) JL_NOTSAFEPOINT;
 std::string jl_get_cpu_features_llvm(void) JL_NOTSAFEPOINT;
-
+// NOLINTEND(clang-diagnostic-return-type-c-linkage)
 struct FeatureName {
     const char *name;
     uint32_t bit; // bit index into a `uint32_t` array;
diff --git a/src/processor_fallback.cpp b/src/processor_fallback.cpp
index 399d31af05ebf..92842d3db6c64 100644
--- a/src/processor_fallback.cpp
+++ b/src/processor_fallback.cpp
@@ -145,7 +145,7 @@ const std::pair<std::string,std::string> &jl_get_llvm_disasm_target(void)
     return res;
 }
 
-extern "C" llvm::SmallVector<jl_target_spec_t, 0> jl_get_llvm_clone_targets(void)
+llvm::SmallVector<jl_target_spec_t, 0> jl_get_llvm_clone_targets(void)
 {
     if (jit_targets.empty())
         jl_error("JIT targets not initialized");
diff --git a/src/processor_x86.cpp b/src/processor_x86.cpp
index 3f8c62acaed11..652a21a3a3286 100644
--- a/src/processor_x86.cpp
+++ b/src/processor_x86.cpp
@@ -1089,21 +1089,21 @@ jl_image_t jl_init_processor_pkgimg(void *hdl)
     return parse_sysimg(hdl, pkgimg_init_cb);
 }
 
-extern "C" JL_DLLEXPORT std::pair<std::string,llvm::SmallVector<std::string, 0>> jl_get_llvm_target(bool imaging, uint32_t &flags)
+std::pair<std::string,llvm::SmallVector<std::string, 0>> jl_get_llvm_target(bool imaging, uint32_t &flags)
 {
     ensure_jit_target(imaging);
     flags = jit_targets[0].en.flags;
     return get_llvm_target_vec(jit_targets[0]);
 }
 
-extern "C" JL_DLLEXPORT const std::pair<std::string,std::string> &jl_get_llvm_disasm_target(void)
+const std::pair<std::string,std::string> &jl_get_llvm_disasm_target(void)
 {
     static const auto res = get_llvm_target_str(TargetData<feature_sz>{"generic", "",
             {feature_masks, 0}, {{}, 0}, 0});
     return res;
 }
 
-extern "C" JL_DLLEXPORT llvm::SmallVector<jl_target_spec_t, 0> jl_get_llvm_clone_targets(void)
+llvm::SmallVector<jl_target_spec_t, 0> jl_get_llvm_clone_targets(void)
 {
     if (jit_targets.empty())
         jl_error("JIT targets not initialized");
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index 4569c2081ae88..2a84532c4c76b 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -213,7 +213,7 @@ static inline uint16_t double_to_half(double param) JL_NOTSAFEPOINT
 // x86-specific helpers for emulating the (B)Float16 ABI
 #if defined(_CPU_X86_) || defined(_CPU_X86_64_)
 #include <xmmintrin.h>
-static inline __m128 return_in_xmm(uint16_t input) JL_NOTSAFEPOINT {
+__attribute__((unused)) static inline __m128 return_in_xmm(uint16_t input) JL_NOTSAFEPOINT {
     __m128 xmm_output;
     asm (
         "movd %[input], %%xmm0\n\t"
@@ -224,7 +224,7 @@ static inline __m128 return_in_xmm(uint16_t input) JL_NOTSAFEPOINT {
     );
     return xmm_output;
 }
-static inline uint16_t take_from_xmm(__m128 xmm_input) JL_NOTSAFEPOINT {
+__attribute__((unused)) static inline uint16_t take_from_xmm(__m128 xmm_input) JL_NOTSAFEPOINT {
     uint32_t output;
     asm (
         "movss %[xmm_input], %%xmm0\n\t"
@@ -239,11 +239,14 @@ static inline uint16_t take_from_xmm(__m128 xmm_input) JL_NOTSAFEPOINT {
 
 // float16 conversion API
 
-// for use in APInt (without the ABI shenanigans from below)
-uint16_t julia_float_to_half(float param) {
+// for use in APInt and other soft-float ABIs (i.e. without the ABI shenanigans from below)
+JL_DLLEXPORT uint16_t julia_float_to_half(float param) {
     return float_to_half(param);
 }
-float julia_half_to_float(uint16_t param) {
+JL_DLLEXPORT uint16_t julia_double_to_half(double param) {
+    return double_to_half(param);
+}
+JL_DLLEXPORT float julia_half_to_float(uint16_t param) {
     return half_to_float(param);
 }
 
diff --git a/src/support/win32-clang-ABI-bug/optional b/src/support/win32-clang-ABI-bug/optional
new file mode 100644
index 0000000000000..135888d415f73
--- /dev/null
+++ b/src/support/win32-clang-ABI-bug/optional
@@ -0,0 +1,531 @@
+//===- optional.h - Simple variant for passing optional values --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///  This file provides optional, a template class modeled in the spirit of
+///  OCaml's 'opt' variant.  The idea is to strongly type whether or not
+///  a value can be optional.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef JL_OPTIONAL_H
+#define JL_OPTIONAL_H
+
+//#include "llvm/ADT/STLForwardCompat.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/type_traits.h"
+#include <cassert>
+#include <new>
+#include <utility>
+#include <type_traits>
+
+namespace std {
+
+//#include "llvm/ADT/None.h"
+/// A simple null object to allow implicit construction of optional<T>
+/// and similar types without having to spell out the specialization's name.
+// (constant value 1 in an attempt to workaround MSVC build issue... )
+enum class nullopt_t { nullopt = 1 };
+const nullopt_t nullopt = nullopt_t::nullopt;
+
+class raw_ostream;
+
+namespace optional_detail {
+
+/// Storage for any type.
+//
+// The specialization condition intentionally uses
+// llvm::is_trivially_{copy/move}_constructible instead of
+// std::is_trivially_{copy/move}_constructible. GCC versions prior to 7.4 may
+// instantiate the copy/move constructor of `T` when
+// std::is_trivially_{copy/move}_constructible is instantiated.  This causes
+// compilation to fail if we query the trivially copy/move constructible
+// property of a class which is not copy/move constructible.
+//
+// The current implementation of OptionalStorage insists that in order to use
+// the trivial specialization, the value_type must be trivially copy
+// constructible and trivially copy assignable due to =default implementations
+// of the copy/move constructor/assignment.  It does not follow that this is
+// necessarily the case std::is_trivially_copyable is true (hence the expanded
+// specialization condition).
+//
+// The move constructible / assignable conditions emulate the remaining behavior
+// of std::is_trivially_copyable.
+template <typename T,
+          bool = (llvm::is_trivially_copy_constructible<T>::value &&
+                  std::is_trivially_copy_assignable<T>::value &&
+                  (llvm::is_trivially_move_constructible<T>::value ||
+                   !std::is_move_constructible<T>::value) &&
+                  (std::is_trivially_move_assignable<T>::value ||
+                   !std::is_move_assignable<T>::value))>
+class OptionalStorage {
+  union {
+    char empty;
+    T val;
+  };
+  bool hasVal = false;
+
+public:
+  ~OptionalStorage() { reset(); }
+
+  constexpr OptionalStorage() noexcept : empty() {}
+
+  constexpr OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
+    if (other.has_value()) {
+      emplace(other.val);
+    }
+  }
+  constexpr OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
+    if (other.has_value()) {
+      emplace(std::move(other.val));
+    }
+  }
+
+  template <class... Args>
+  constexpr explicit OptionalStorage(in_place_t, Args &&...args)
+      : val(std::forward<Args>(args)...), hasVal(true) {}
+
+  void reset() noexcept {
+    if (hasVal) {
+      val.~T();
+      hasVal = false;
+    }
+  }
+
+  constexpr bool has_value() const noexcept { return hasVal; }
+  constexpr bool hasValue() const noexcept { return hasVal; }
+
+  T &value() &noexcept {
+    assert(hasVal);
+    return val;
+  }
+  T &getValue() &noexcept {
+    assert(hasVal);
+    return val;
+  }
+  constexpr T const &value() const &noexcept {
+    assert(hasVal);
+    return val;
+  }
+  constexpr T const &getValue() const &noexcept {
+    assert(hasVal);
+    return val;
+  }
+  T &&value() &&noexcept {
+    assert(hasVal);
+    return std::move(val);
+  }
+  T &&getValue() &&noexcept {
+    assert(hasVal);
+    return std::move(val);
+  }
+
+  template <class... Args> void emplace(Args &&...args) {
+    reset();
+    ::new ((void *)std::addressof(val)) T(std::forward<Args>(args)...);
+    hasVal = true;
+  }
+
+  OptionalStorage &operator=(T const &y) {
+    if (has_value()) {
+      val = y;
+    } else {
+      ::new ((void *)std::addressof(val)) T(y);
+      hasVal = true;
+    }
+    return *this;
+  }
+  OptionalStorage &operator=(T &&y) {
+    if (has_value()) {
+      val = std::move(y);
+    } else {
+      ::new ((void *)std::addressof(val)) T(std::move(y));
+      hasVal = true;
+    }
+    return *this;
+  }
+
+  OptionalStorage &operator=(OptionalStorage const &other) {
+    if (other.has_value()) {
+      if (has_value()) {
+        val = other.val;
+      } else {
+        ::new ((void *)std::addressof(val)) T(other.val);
+        hasVal = true;
+      }
+    } else {
+      reset();
+    }
+    return *this;
+  }
+
+  OptionalStorage &operator=(OptionalStorage &&other) {
+    if (other.has_value()) {
+      if (has_value()) {
+        val = std::move(other.val);
+      } else {
+        ::new ((void *)std::addressof(val)) T(std::move(other.val));
+        hasVal = true;
+      }
+    } else {
+      reset();
+    }
+    return *this;
+  }
+};
+
+template <typename T> class OptionalStorage<T, true> {
+  union {
+    char empty;
+    T val;
+  };
+  bool hasVal = false;
+
+public:
+  ~OptionalStorage() = default;
+
+  constexpr OptionalStorage() noexcept : empty{} {}
+
+  constexpr OptionalStorage(OptionalStorage const &other) = default;
+  constexpr OptionalStorage(OptionalStorage &&other) = default;
+
+  OptionalStorage &operator=(OptionalStorage const &other) = default;
+  OptionalStorage &operator=(OptionalStorage &&other) = default;
+
+  template <class... Args>
+  constexpr explicit OptionalStorage(in_place_t, Args &&...args)
+      : val(std::forward<Args>(args)...), hasVal(true) {}
+
+  void reset() noexcept {
+    if (hasVal) {
+      val.~T();
+      hasVal = false;
+    }
+  }
+
+  constexpr bool has_value() const noexcept { return hasVal; }
+  constexpr bool hasValue() const noexcept { return hasVal; }
+
+  T &value() &noexcept {
+    assert(hasVal);
+    return val;
+  }
+  T &getValue() &noexcept {
+    assert(hasVal);
+    return val;
+  }
+  constexpr T const &value() const &noexcept {
+    assert(hasVal);
+    return val;
+  }
+  constexpr T const &getValue() const &noexcept {
+    assert(hasVal);
+    return val;
+  }
+  T &&value() &&noexcept {
+    assert(hasVal);
+    return std::move(val);
+  }
+  T &&getValue() &&noexcept {
+    assert(hasVal);
+    return std::move(val);
+  }
+
+  template <class... Args> void emplace(Args &&...args) {
+    reset();
+    ::new ((void *)std::addressof(val)) T(std::forward<Args>(args)...);
+    hasVal = true;
+  }
+
+  OptionalStorage &operator=(T const &y) {
+    if (has_value()) {
+      val = y;
+    } else {
+      ::new ((void *)std::addressof(val)) T(y);
+      hasVal = true;
+    }
+    return *this;
+  }
+  OptionalStorage &operator=(T &&y) {
+    if (has_value()) {
+      val = std::move(y);
+    } else {
+      ::new ((void *)std::addressof(val)) T(std::move(y));
+      hasVal = true;
+    }
+    return *this;
+  }
+};
+
+} // namespace optional_detail
+
+template <typename T> class optional {
+  optional_detail::OptionalStorage<T> Storage;
+
+public:
+  using value_type = T;
+
+  constexpr optional() = default;
+  constexpr optional(nullopt_t) {}
+
+  constexpr optional(const T &y) : Storage(in_place, y) {}
+  constexpr optional(const optional &O) = default;
+
+  constexpr optional(T &&y) : Storage(in_place, std::move(y)) {}
+  constexpr optional(optional &&O) = default;
+
+  template <typename... ArgTypes>
+  constexpr optional(in_place_t, ArgTypes &&...Args)
+      : Storage(in_place, std::forward<ArgTypes>(Args)...) {}
+
+  optional &operator=(T &&y) {
+    Storage = std::move(y);
+    return *this;
+  }
+  optional &operator=(optional &&O) = default;
+
+  /// Create a new object by constructing it in place with the given arguments.
+  template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
+    Storage.emplace(std::forward<ArgTypes>(Args)...);
+  }
+
+  static constexpr optional create(const T *y) {
+    return y ? optional(*y) : optional();
+  }
+
+  optional &operator=(const T &y) {
+    Storage = y;
+    return *this;
+  }
+  optional &operator=(const optional &O) = default;
+
+  void reset() { Storage.reset(); }
+
+  constexpr const T *getPointer() const { return &Storage.value(); }
+  T *getPointer() { return &Storage.value(); }
+  constexpr const T &value() const & { return Storage.value(); }
+  constexpr const T &getValue() const & { return Storage.value(); }
+  T &value() & { return Storage.value(); }
+  T &getValue() & { return Storage.value(); }
+
+  constexpr explicit operator bool() const { return has_value(); }
+  constexpr bool has_value() const { return Storage.has_value(); }
+  constexpr bool hasValue() const { return Storage.has_value(); }
+  constexpr const T *operator->() const { return getPointer(); }
+  T *operator->() { return getPointer(); }
+  constexpr const T &operator*() const & { return value(); }
+  T &operator*() & { return value(); }
+
+  template <typename U> constexpr T value_or(U &&alt) const & {
+    return has_value() ? value() : std::forward<U>(alt);
+  }
+  template <typename U>
+  [[deprecated("Use value_or instead.")]] constexpr T
+  getValueOr(U &&alt) const & {
+    return has_value() ? value() : std::forward<U>(alt);
+  }
+
+  /// Apply a function to the value if present; otherwise return nullopt.
+  template <class Function>
+  auto map(const Function &F) const & -> optional<decltype(F(value()))> {
+    if (*this)
+      return F(value());
+    return nullopt;
+  }
+
+  T &&value() && { return std::move(Storage.value()); }
+  T &&getValue() && { return std::move(Storage.value()); }
+  T &&operator*() && { return std::move(Storage.value()); }
+
+  template <typename U> T value_or(U &&alt) && {
+    return has_value() ? std::move(value()) : std::forward<U>(alt);
+  }
+  template <typename U>
+  [[deprecated("Use value_or instead.")]] T getValueOr(U &&alt) && {
+    return has_value() ? std::move(value()) : std::forward<U>(alt);
+  }
+
+  /// Apply a function to the value if present; otherwise return nullopt.
+  template <class Function>
+  auto map(const Function &F)
+      && -> optional<decltype(F(std::move(*this).value()))> {
+    if (*this)
+      return F(std::move(*this).value());
+    return nullopt;
+  }
+};
+
+//template <class T> llvm::hash_code hash_value(const optional<T> &O) {
+//  return O ? hash_combine(true, *O) : hash_value(false);
+//}
+
+template <typename T, typename U>
+constexpr bool operator==(const optional<T> &X, const optional<U> &Y) {
+  if (X && Y)
+    return *X == *Y;
+  return X.has_value() == Y.has_value();
+}
+
+template <typename T, typename U>
+constexpr bool operator!=(const optional<T> &X, const optional<U> &Y) {
+  return !(X == Y);
+}
+
+template <typename T, typename U>
+constexpr bool operator<(const optional<T> &X, const optional<U> &Y) {
+  if (X && Y)
+    return *X < *Y;
+  return X.has_value() < Y.has_value();
+}
+
+template <typename T, typename U>
+constexpr bool operator<=(const optional<T> &X, const optional<U> &Y) {
+  return !(Y < X);
+}
+
+template <typename T, typename U>
+constexpr bool operator>(const optional<T> &X, const optional<U> &Y) {
+  return Y < X;
+}
+
+template <typename T, typename U>
+constexpr bool operator>=(const optional<T> &X, const optional<U> &Y) {
+  return !(X < Y);
+}
+
+template <typename T>
+constexpr bool operator==(const optional<T> &X, nullopt_t) {
+  return !X;
+}
+
+template <typename T>
+constexpr bool operator==(nullopt_t, const optional<T> &X) {
+  return X == nullopt;
+}
+
+template <typename T>
+constexpr bool operator!=(const optional<T> &X, nullopt_t) {
+  return !(X == nullopt);
+}
+
+template <typename T>
+constexpr bool operator!=(nullopt_t, const optional<T> &X) {
+  return X != nullopt;
+}
+
+template <typename T> constexpr bool operator<(const optional<T> &, nullopt_t) {
+  return false;
+}
+
+template <typename T> constexpr bool operator<(nullopt_t, const optional<T> &X) {
+  return X.has_value();
+}
+
+template <typename T>
+constexpr bool operator<=(const optional<T> &X, nullopt_t) {
+  return !(nullopt < X);
+}
+
+template <typename T>
+constexpr bool operator<=(nullopt_t, const optional<T> &X) {
+  return !(X < nullopt);
+}
+
+template <typename T> constexpr bool operator>(const optional<T> &X, nullopt_t) {
+  return nullopt < X;
+}
+
+template <typename T> constexpr bool operator>(nullopt_t, const optional<T> &X) {
+  return X < nullopt;
+}
+
+template <typename T>
+constexpr bool operator>=(const optional<T> &X, nullopt_t) {
+  return nullopt <= X;
+}
+
+template <typename T>
+constexpr bool operator>=(nullopt_t, const optional<T> &X) {
+  return X <= nullopt;
+}
+
+template <typename T>
+constexpr bool operator==(const optional<T> &X, const T &Y) {
+  return X && *X == Y;
+}
+
+template <typename T>
+constexpr bool operator==(const T &X, const optional<T> &Y) {
+  return Y && X == *Y;
+}
+
+template <typename T>
+constexpr bool operator!=(const optional<T> &X, const T &Y) {
+  return !(X == Y);
+}
+
+template <typename T>
+constexpr bool operator!=(const T &X, const optional<T> &Y) {
+  return !(X == Y);
+}
+
+template <typename T>
+constexpr bool operator<(const optional<T> &X, const T &Y) {
+  return !X || *X < Y;
+}
+
+template <typename T>
+constexpr bool operator<(const T &X, const optional<T> &Y) {
+  return Y && X < *Y;
+}
+
+template <typename T>
+constexpr bool operator<=(const optional<T> &X, const T &Y) {
+  return !(Y < X);
+}
+
+template <typename T>
+constexpr bool operator<=(const T &X, const optional<T> &Y) {
+  return !(Y < X);
+}
+
+template <typename T>
+constexpr bool operator>(const optional<T> &X, const T &Y) {
+  return Y < X;
+}
+
+template <typename T>
+constexpr bool operator>(const T &X, const optional<T> &Y) {
+  return Y < X;
+}
+
+template <typename T>
+constexpr bool operator>=(const optional<T> &X, const T &Y) {
+  return !(X < Y);
+}
+
+template <typename T>
+constexpr bool operator>=(const T &X, const optional<T> &Y) {
+  return !(X < Y);
+}
+
+raw_ostream &operator<<(raw_ostream &OS, nullopt_t);
+
+template <typename T, typename = decltype(std::declval<raw_ostream &>()
+                                          << std::declval<const T &>())>
+raw_ostream &operator<<(raw_ostream &OS, const optional<T> &O) {
+  if (O)
+    OS << *O;
+  else
+    OS << nullopt;
+  return OS;
+}
+
+} // end namespace
+
+#endif // JL_OPTIONAL_H
diff --git a/stdlib/LLD_jll/Project.toml b/stdlib/LLD_jll/Project.toml
index 454da0a0b221b..6f886279ab786 100644
--- a/stdlib/LLD_jll/Project.toml
+++ b/stdlib/LLD_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LLD_jll"
 uuid = "d55e3150-da41-5e91-b323-ecfd1eec6109"
-version = "15.0.7+10"
+version = "16.0.6+3"
 
 [deps]
 Zlib_jll = "83775a58-1f1d-513f-b197-d71354ab007a"
@@ -9,8 +9,8 @@ libLLVM_jll = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 
 [compat]
-julia = "1.9"
-libLLVM_jll = "15.0.7"
+julia = "1.11"
+libLLVM_jll = "16.0.6"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/libLLVM_jll/Project.toml b/stdlib/libLLVM_jll/Project.toml
index 92867293c3116..d74b2bb4892b0 100644
--- a/stdlib/libLLVM_jll/Project.toml
+++ b/stdlib/libLLVM_jll/Project.toml
@@ -1,13 +1,13 @@
 name = "libLLVM_jll"
 uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
-version = "15.0.7+10"
+version = "16.0.6+3"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 
 [compat]
-julia = "1.8"
+julia = "1.11"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/test/clangsa/MissingRoots.c b/test/clangsa/MissingRoots.c
index 0ff5e633622ce..b71b2571e8a3e 100644
--- a/test/clangsa/MissingRoots.c
+++ b/test/clangsa/MissingRoots.c
@@ -415,7 +415,7 @@ void stack_rooted(jl_value_t *lb JL_MAYBE_UNROOTED, jl_value_t *ub JL_MAYBE_UNRO
 JL_DLLEXPORT jl_value_t *jl_totally_used_function(int i)
 {
     jl_value_t *v = jl_box_int32(i); // expected-note{{Started tracking value here}}
-    jl_safepoint(); // expected-note{{Value may have been GCed here}}
+    jl_gc_safepoint(); // expected-note{{Value may have been GCed here}}
     return v; // expected-warning{{Return value may have been GCed}}
               // expected-note@-1{{Return value may have been GCed}}
 }
diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl
index 94396bf7a7a49..805e5c7acc817 100644
--- a/test/compiler/codegen.jl
+++ b/test/compiler/codegen.jl
@@ -130,14 +130,14 @@ if !is_debug_build && opt_level > 0
     # Array
     test_loads_no_call(strip_debug_calls(get_llvm(sizeof, Tuple{Vector{Int}})), [Iptr])
     # As long as the eltype is known we don't need to load the elsize, but do need to check isvector
-    @test_skip test_loads_no_call(strip_debug_calls(get_llvm(sizeof, Tuple{Array{Any}})), ["atomic $Iptr", "{} addrspace(10)* addrspace(10)*", "$Iptr addrspace(10)*", Iptr, Iptr, "{ i64, {} addrspace(10)** } addrspace(10)*",  Iptr])
+    @test_skip test_loads_no_call(strip_debug_calls(get_llvm(sizeof, Tuple{Array{Any}})), ["atomic $Iptr", "ptr", "ptr", Iptr, Iptr, "ptr",  Iptr])
     # Memory
     test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory{Int}})), [Iptr])
     # As long as the eltype is known we don't need to load the elsize
     test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory{Any}})), [Iptr])
     # Check that we load the elsize and isunion from the typeof layout
-    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory})), [Iptr, "atomic $Iptr", "i32*", "i32", "i16"])
-    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory})), [Iptr, "atomic $Iptr", "i32*", "i32", "i16"])
+    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory})), [Iptr, "atomic $Iptr", "ptr", "i32", "i16"])
+    test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Memory})), [Iptr, "atomic $Iptr", "ptr", "i32", "i16"])
     # Primitive Type size should be folded to a constant
     test_loads_no_call(strip_debug_calls(get_llvm(core_sizeof, Tuple{Ptr})), String[])
 
diff --git a/test/llvmpasses/julia-simdloop-memoryssa.ll b/test/llvmpasses/julia-simdloop-memoryssa.ll
index 0c1c4ac021996..863e5234caa67 100644
--- a/test/llvmpasses/julia-simdloop-memoryssa.ll
+++ b/test/llvmpasses/julia-simdloop-memoryssa.ll
@@ -16,10 +16,10 @@ loop:
   %i = phi i64 [0, %top], [%nexti, %loop]
   %aptr = getelementptr double, double *%a, i64 %i
   %bptr = getelementptr double, double *%b, i64 %i
-; CHECK: MemoryUse([[MPHI]]) MayAlias
+; CHECK: MemoryUse([[MPHI]])
 ; CHECK: llvm.mem.parallel_loop_access
   %aval = load double, double *%aptr
-; CHECK: MemoryUse([[MPHI]]) MayAlias
+; CHECK: MemoryUse([[MPHI]])
   %bval = load double, double *%aptr
   %cval = fadd double %aval, %bval
 ; CHECK: [[MSSA_USE]] = MemoryDef([[MPHI]])
@@ -40,7 +40,7 @@ loop:
   %i = phi i64 [0, %top], [%nexti, %loop]
   %v = phi double [0.000000e+00, %top], [%nextv, %loop]
   %aptr = getelementptr double, double *%a, i64 %i
-; CHECK: MemoryUse(liveOnEntry) MayAlias
+; CHECK: MemoryUse(liveOnEntry) 
   %aval = load double, double *%aptr
   %nextv = fsub double %v, %aval
 ; CHECK: fsub reassoc contract double %v, %aval
diff --git a/test/llvmpasses/names.jl b/test/llvmpasses/names.jl
index 344738abc3802..fe692d0fab787 100644
--- a/test/llvmpasses/names.jl
+++ b/test/llvmpasses/names.jl
@@ -96,12 +96,12 @@ end
 # CHECK: ret double
 # CHECK: }
 
-# CHECK-LABEL: define nonnull {} addrspace(10)* @jfptr_f1
+# CHECK-LABEL: define nonnull ptr @jfptr_f1
 # CHECK-SAME: %"function::Core.Function"
 # CHECK-SAME: %"args::Any[]"
 # CHECK-SAME: %"nargs::UInt32"
 # CHECK: %"+Core.Float64
-# CHECK: ret {} addrspace(10)*
+# CHECK: ret ptr
 # CHECK: }
 emit(f1, Float64, Float64, Float64, Float64)
 
@@ -133,22 +133,20 @@ emit(f2, Float64, Float64, Float64, Float64, Float64, Float64)
 # CHECK-SAME: double %"e[3]::Float64"
 emit(f2, Float64, Float64, Float64, Float64, Float64, Float64, Float64)
 
-# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_f5
+# CHECK: define {{(swiftcc )?}}nonnull ptr @julia_f5
 # CHECK-SAME: %"a::A"
 # CHECK: %"a::A.b_ptr.c_ptr.d
 emit(f5, A)
 
-# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_f6
+# CHECK: define {{(swiftcc )?}}nonnull ptr @julia_f6
 # CHECK-SAME: %"e::E"
 # CHECK: %jlcallframe
 # CHECK: %gcframe
-# CHECK: %frame.nroots
 # CHECK: %frame.prev
 # CHECK: %task.gcstack
 # CHECK: %ptls_field
 # CHECK: %ptls_load
 # CHECK: %safepoint
-# CHECK: %"e::E.f_ptr"
 # CHECK: %"e::E.f"
 # CHECK: %"e::E.f.tag_addr"
 # CHECK: %"e::E.f.tag"
@@ -164,7 +162,7 @@ emit(f6, E)
 # CHECK: %"a::Tuple[2]_ptr.unbox
 emit(f7, Tuple{Int,Int})
 
-# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_f8
+# CHECK: define {{(swiftcc )?}}nonnull ptr @julia_f8
 # CHECK-SAME: %"y::Int64"
 # CHECK: %parent_bits
 # CHECK: %parent_old_marked
@@ -172,15 +170,13 @@ emit(f7, Tuple{Int,Int})
 # CHECK: %child_not_marked
 emit(f8, Barrier, Int)
 
-# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_Barrier
+# CHECK: define {{(swiftcc )?}}nonnull ptr @julia_Barrier
 # CHECK-SAME: %"b::Named"
 # CHECK: %"new::Barrier"
 # CHECK: %"box::Named"
-# CHECK: %parent_bits
-# CHECK: %parent_old_marked
 emit(Barrier, Named)
 
-# CHECK: define {{(swiftcc )?}}nonnull {} addrspace(10)* @julia_fmemory
+# CHECK: define {{(swiftcc )?}}nonnull ptr @julia_fmemory
 # CHECK-SAME: %"nel::Int64"
 # CHECK: %"Memory{Int64}[]"
 emit(fmemory, Int64)
diff --git a/test/llvmpasses/safepoint_stress.jl b/test/llvmpasses/safepoint_stress.jl
index c1867decc7f25..e02aee7206b12 100644
--- a/test/llvmpasses/safepoint_stress.jl
+++ b/test/llvmpasses/safepoint_stress.jl
@@ -14,7 +14,7 @@ define void @stress(i64 %a, i64 %b) {
     %ptls = call {}*** @julia.ptls_states()
 """)
 
-# CHECK: %gcframe = alloca {} addrspace(10)*, i32 10002
+# CHECK: %gcframe = alloca ptr addrspace(10), i32 10002
 for i = 1:10000
     println("\t%arg$i = call {} addrspace(10)* @alloc()")
 end

From bf13a564c8e7059d2989103c47a0dcc96402d9f6 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 10 Jan 2024 10:08:04 +0530
Subject: [PATCH 0596/1315] Remove 3-term mul! methods involving
 AbstractTriangular (#52826)

The multiplication can be handled by the 5-term methods, and constant
propagation should eliminate the branch. This should reduce some
potential method ambiguities.
---
 stdlib/LinearAlgebra/src/triangular.jl | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 781e323a0ca43..f85ef9fcd2ee3 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -773,10 +773,6 @@ isunit_char(::LowerTriangular) = 'N'
 isunit_char(::UnitLowerTriangular) = 'U'
 
 lmul!(A::Tridiagonal, B::AbstractTriangular) = A*full!(B)
-mul!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVector) = _trimul!(C, A, B)
-mul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractMatrix) = _trimul!(C, A, B)
-mul!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractTriangular) = _trimul!(C, A, B)
-mul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractTriangular) = _trimul!(C, A, B)
 
 # generic fallback for AbstractTriangular matrices outside of the four subtypes provided here
 _trimul!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVector) =
@@ -809,7 +805,7 @@ rmul!(A::AbstractMatrix, B::AbstractTriangular)   = @inline _trimul!(A, A, B)
 for TC in (:AbstractVector, :AbstractMatrix)
     @eval @inline function mul!(C::$TC, A::AbstractTriangular, B::AbstractVector, alpha::Number, beta::Number)
         if isone(alpha) && iszero(beta)
-            return mul!(C, A, B)
+            return _trimul!(C, A, B)
         else
             return generic_matvecmul!(C, 'N', A, B, MulAddMul(alpha, beta))
         end
@@ -821,7 +817,7 @@ for (TA, TB) in ((:AbstractTriangular, :AbstractMatrix),
                 )
     @eval @inline function mul!(C::AbstractMatrix, A::$TA, B::$TB, alpha::Number, beta::Number)
         if isone(alpha) && iszero(beta)
-            return mul!(C, A, B)
+            return _trimul!(C, A, B)
         else
             return generic_matmatmul!(C, 'N', 'N', A, B, MulAddMul(alpha, beta))
         end

From 124ce943ef748b7fdb6631559694282823a2748f Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Wed, 10 Jan 2024 15:48:28 +0100
Subject: [PATCH 0597/1315] Add indirection to inplace matrix scaling (#52840)

---
 stdlib/LinearAlgebra/src/generic.jl    | 10 ++++++++--
 stdlib/LinearAlgebra/src/triangular.jl |  6 ++----
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl
index 0b4382ccee22b..a51b155cf3785 100644
--- a/stdlib/LinearAlgebra/src/generic.jl
+++ b/stdlib/LinearAlgebra/src/generic.jl
@@ -129,7 +129,10 @@ match the length of the second, $(length(X))."))
     C
 end
 
-@inline function mul!(C::AbstractArray, s::Number, X::AbstractArray, alpha::Number, beta::Number)
+@inline mul!(C::AbstractArray, s::Number, X::AbstractArray, alpha::Number, beta::Number) =
+    _lscale_add!(C, s, X, alpha, beta)
+
+@inline function _lscale_add!(C::AbstractArray, s::Number, X::AbstractArray, alpha::Number, beta::Number)
     if axes(C) == axes(X)
         C .= (s .* X) .*ₛ alpha .+ C .*ₛ beta
     else
@@ -137,7 +140,10 @@ end
     end
     return C
 end
-@inline function mul!(C::AbstractArray, X::AbstractArray, s::Number, alpha::Number, beta::Number)
+@inline mul!(C::AbstractArray, X::AbstractArray, s::Number, alpha::Number, beta::Number) =
+    _rscale_add!(C, X, s, alpha, beta)
+
+@inline function _rscale_add!(C::AbstractArray, X::AbstractArray, s::Number, alpha::Number, beta::Number)
     if axes(C) == axes(X)
         C .= (X .* s) .*ₛ alpha .+ C .*ₛ beta
     else
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index f85ef9fcd2ee3..d6bc08b270d78 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -532,11 +532,9 @@ function copyto!(A::T, B::T) where {T<:Union{LowerTriangular,UnitLowerTriangular
     return A
 end
 
-# Define `mul!` for (Unit){Upper,Lower}Triangular matrices times a number.
-# be permissive here and require compatibility later in _triscale!
-@inline mul!(A::AbstractTriangular, B::AbstractTriangular, C::Number, alpha::Number, beta::Number) =
+@inline _rscale_add!(A::AbstractTriangular, B::AbstractTriangular, C::Number, alpha::Number, beta::Number) =
     _triscale!(A, B, C, MulAddMul(alpha, beta))
-@inline mul!(A::AbstractTriangular, B::Number, C::AbstractTriangular, alpha::Number, beta::Number) =
+@inline _lscale_add!(A::AbstractTriangular, B::Number, C::AbstractTriangular, alpha::Number, beta::Number) =
     _triscale!(A, B, C, MulAddMul(alpha, beta))
 
 function checksize1(A, B)

From 2afc20c18a840f4b05d5ca32c9451a1c153dcb47 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 10 Jan 2024 22:08:49 +0530
Subject: [PATCH 0598/1315] Disambiguate mul! for matvec and matmat through
 indirection (#52837)

This forwards `mul!` for matrix-matrix and matrix-vector multiplications
to the internal `_mul!`, which is then specialized for the various array
types. With this, packages would not encounter any method ambiguity when
they define
```julia
mul!(::AbstractMatrix, ::MyMatrix, ::AbstractMatrix, alpha::Number, beta::Number)
```
This should reduce the number of methods that packages need to define to
work around ambiguities with `LinearAlgebra`.

There was already an existing internal function named `_mul!`, but the
new methods don't clash with the existing ones, and since both sets of
methods usually forward structured multiplications to specialized
functions, it's fitting for them to have the same name.
---
 NEWS.md                                 |  1 +
 stdlib/LinearAlgebra/src/bidiag.jl      | 26 ++++++++++++-------------
 stdlib/LinearAlgebra/src/matmul.jl      |  9 ++++++++-
 stdlib/LinearAlgebra/src/special.jl     |  6 ++----
 stdlib/LinearAlgebra/src/triangular.jl  |  4 ++--
 stdlib/LinearAlgebra/test/bidiag.jl     | 23 ++++++++++++++++++++++
 stdlib/LinearAlgebra/test/diagonal.jl   | 12 ++++++++++++
 stdlib/LinearAlgebra/test/triangular.jl | 12 ++++++++++++
 test/testhelpers/SizedArrays.jl         | 20 ++++++++++++++-----
 9 files changed, 88 insertions(+), 25 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 34e69535374b0..9dba8544cecbf 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -118,6 +118,7 @@ Standard library changes
 * There is now a specialized dispatch for `eigvals/eigen(::Hermitian{<:Tridiagonal})` which performs a similarity transformation to create a real symmetrix triagonal matrix, and solve that using the LAPACK routines ([#49546]).
 * Structured matrices now retain either the axes of the parent (for `Symmetric`/`Hermitian`/`AbstractTriangular`/`UpperHessenberg`), or that of the principal diagonal (for banded matrices) ([#52480]).
 * `bunchkaufman` and `bunchkaufman!` now work for any `AbstractFloat`, `Rational` and their complex variants. `bunchkaufman` now supports `Integer` types, by making an internal conversion to `Rational{BigInt}`. Added new function `inertia` that computes the inertia of the diagonal factor given by the `BunchKaufman` factorization object of a real symmetric or Hermitian matrix. For complex symmetric matrices, `inertia` only computes the number of zero eigenvalues of the diagonal factor ([#51487]).
+* Packages that specialize matrix-matrix `mul!` with a method signature of the form `mul!(::AbstractMatrix, ::MyMatrix, ::AbstractMatrix, ::Number, ::Number)` no longer encounter method ambiguities when interacting with `LinearAlgebra`. Previously, ambiguities used to arise when multiplying a `MyMatrix` with a structured matrix type provided by LinearAlgebra, such as `AbstractTriangular`, which used to necessitate additional methods to resolve such ambiguities. Similar sources of ambiguities have also been removed for matrix-vector `mul!` operations ([#52837]).
 
 #### Logging
 * New `@create_log_macro` macro for creating new log macros like `@info`, `@warn` etc. For instance
diff --git a/stdlib/LinearAlgebra/src/bidiag.jl b/stdlib/LinearAlgebra/src/bidiag.jl
index 2b4b2ac98317c..00c972f7f990b 100644
--- a/stdlib/LinearAlgebra/src/bidiag.jl
+++ b/stdlib/LinearAlgebra/src/bidiag.jl
@@ -429,11 +429,11 @@ const BandedMatrix = Union{Bidiagonal,Diagonal,Tridiagonal,SymTridiagonal} # or
 const BiTriSym = Union{Bidiagonal,Tridiagonal,SymTridiagonal}
 const TriSym = Union{Tridiagonal,SymTridiagonal}
 const BiTri = Union{Bidiagonal,Tridiagonal}
-@inline mul!(C::AbstractVector, A::BandedMatrix, B::AbstractVector, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
-@inline mul!(C::AbstractMatrix, A::BandedMatrix, B::AbstractVector, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
-@inline mul!(C::AbstractMatrix, A::BandedMatrix, B::AbstractMatrix, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
-@inline mul!(C::AbstractMatrix, A::AbstractMatrix, B::BandedMatrix, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
-@inline mul!(C::AbstractMatrix, A::BandedMatrix, B::BandedMatrix, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
+@inline _mul!(C::AbstractVector, A::BandedMatrix, B::AbstractVector, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
+@inline _mul!(C::AbstractMatrix, A::BandedMatrix, B::AbstractVector, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
+@inline _mul!(C::AbstractMatrix, A::BandedMatrix, B::AbstractMatrix, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
+@inline _mul!(C::AbstractMatrix, A::AbstractMatrix, B::BandedMatrix, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
+@inline _mul!(C::AbstractMatrix, A::BandedMatrix, B::BandedMatrix, alpha::Number, beta::Number) = _mul!(C, A, B, MulAddMul(alpha, beta))
 
 lmul!(A::Bidiagonal, B::AbstractVecOrMat) = @inline _mul!(B, A, B, MulAddMul())
 rmul!(B::AbstractMatrix, A::Bidiagonal) = @inline _mul!(B, B, A, MulAddMul())
@@ -465,9 +465,9 @@ function _diag(A::Bidiagonal, k)
     end
 end
 
-_mul!(C::AbstractMatrix, A::BiTriSym, B::TriSym, _add::MulAddMul = MulAddMul()) =
+_mul!(C::AbstractMatrix, A::BiTriSym, B::TriSym, _add::MulAddMul) =
     _bibimul!(C, A, B, _add)
-_mul!(C::AbstractMatrix, A::BiTriSym, B::Bidiagonal, _add::MulAddMul = MulAddMul()) =
+_mul!(C::AbstractMatrix, A::BiTriSym, B::Bidiagonal, _add::MulAddMul) =
     _bibimul!(C, A, B, _add)
 function _bibimul!(C, A, B, _add)
     check_A_mul_B!_sizes(C, A, B)
@@ -526,7 +526,7 @@ function _bibimul!(C, A, B, _add)
     C
 end
 
-function _mul!(C::AbstractMatrix, A::BiTriSym, B::Diagonal, _add::MulAddMul = MulAddMul())
+function _mul!(C::AbstractMatrix, A::BiTriSym, B::Diagonal, _add::MulAddMul)
     require_one_based_indexing(C)
     check_A_mul_B!_sizes(C, A, B)
     n = size(A,1)
@@ -562,7 +562,7 @@ function _mul!(C::AbstractMatrix, A::BiTriSym, B::Diagonal, _add::MulAddMul = Mu
     C
 end
 
-function _mul!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat, _add::MulAddMul = MulAddMul())
+function _mul!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat, _add::MulAddMul)
     require_one_based_indexing(C, B)
     nA = size(A,1)
     nB = size(B,2)
@@ -592,7 +592,7 @@ function _mul!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat, _add::MulA
     C
 end
 
-function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::TriSym, _add::MulAddMul = MulAddMul())
+function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::TriSym, _add::MulAddMul)
     require_one_based_indexing(C, A)
     check_A_mul_B!_sizes(C, A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
@@ -627,7 +627,7 @@ function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::TriSym, _add::MulAddMul
     C
 end
 
-function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::Bidiagonal, _add::MulAddMul = MulAddMul())
+function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::Bidiagonal, _add::MulAddMul)
     require_one_based_indexing(C, A)
     check_A_mul_B!_sizes(C, A, B)
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
@@ -653,9 +653,9 @@ function _mul!(C::AbstractMatrix, A::AbstractMatrix, B::Bidiagonal, _add::MulAdd
     C
 end
 
-_mul!(C::AbstractMatrix, A::Diagonal, B::Bidiagonal, _add::MulAddMul = MulAddMul()) =
+_mul!(C::AbstractMatrix, A::Diagonal, B::Bidiagonal, _add::MulAddMul) =
     _dibimul!(C, A, B, _add)
-_mul!(C::AbstractMatrix, A::Diagonal, B::TriSym, _add::MulAddMul = MulAddMul()) =
+_mul!(C::AbstractMatrix, A::Diagonal, B::TriSym, _add::MulAddMul) =
     _dibimul!(C, A, B, _add)
 function _dibimul!(C, A, B, _add)
     require_one_based_indexing(C)
diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index afc646c149eaf..9f163f8d394b4 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -65,9 +65,14 @@ end
 (*)(a::AbstractVector, adjB::AdjointAbsMat) = reshape(a, length(a), 1) * adjB
 (*)(a::AbstractVector, B::AbstractMatrix) = reshape(a, length(a), 1) * B
 
+# Add a level of indirection and specialize _mul! to avoid ambiguities in mul!
 @inline mul!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector,
+                alpha::Number, beta::Number) = _mul!(y, A, x, alpha, beta)
+
+@inline _mul!(y::AbstractVector, A::AbstractVecOrMat, x::AbstractVector,
                 alpha::Number, beta::Number) =
     generic_matvecmul!(y, wrapper_char(A), _unwrap(A), x, MulAddMul(alpha, beta))
+
 # BLAS cases
 # equal eltypes
 @inline generic_matvecmul!(y::StridedVector{T}, tA, A::StridedVecOrMat{T}, x::StridedVector{T},
@@ -277,7 +282,9 @@ julia> C == A * B * α + C_original * β
 true
 ```
 """
-@inline mul!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat, α::Number, β::Number) =
+@inline mul!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat, α::Number, β::Number) = _mul!(C, A, B, α, β)
+# Add a level of indirection and specialize _mul! to avoid ambiguities in mul!
+@inline _mul!(C::AbstractMatrix, A::AbstractVecOrMat, B::AbstractVecOrMat, α::Number, β::Number) =
     generic_matmatmul!(
         C,
         wrapper_char(A),
diff --git a/stdlib/LinearAlgebra/src/special.jl b/stdlib/LinearAlgebra/src/special.jl
index d028fe43e6338..136f566f68447 100644
--- a/stdlib/LinearAlgebra/src/special.jl
+++ b/stdlib/LinearAlgebra/src/special.jl
@@ -108,11 +108,9 @@ for op in (:+, :-)
 end
 
 # disambiguation between triangular and banded matrices, banded ones "dominate"
-mul!(C::AbstractMatrix, A::AbstractTriangular, B::BandedMatrix) = _mul!(C, A, B, MulAddMul())
-mul!(C::AbstractMatrix, A::BandedMatrix, B::AbstractTriangular) = _mul!(C, A, B, MulAddMul())
-mul!(C::AbstractMatrix, A::AbstractTriangular, B::BandedMatrix, alpha::Number, beta::Number) =
+_mul!(C::AbstractMatrix, A::AbstractTriangular, B::BandedMatrix, alpha::Number, beta::Number) =
     _mul!(C, A, B, MulAddMul(alpha, beta))
-mul!(C::AbstractMatrix, A::BandedMatrix, B::AbstractTriangular, alpha::Number, beta::Number) =
+_mul!(C::AbstractMatrix, A::BandedMatrix, B::AbstractTriangular, alpha::Number, beta::Number) =
     _mul!(C, A, B, MulAddMul(alpha, beta))
 
 function *(H::UpperHessenberg, B::Bidiagonal)
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index d6bc08b270d78..4931e314d0d5c 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -801,7 +801,7 @@ rmul!(A::AbstractMatrix, B::AbstractTriangular)   = @inline _trimul!(A, A, B)
 
 
 for TC in (:AbstractVector, :AbstractMatrix)
-    @eval @inline function mul!(C::$TC, A::AbstractTriangular, B::AbstractVector, alpha::Number, beta::Number)
+    @eval @inline function _mul!(C::$TC, A::AbstractTriangular, B::AbstractVector, alpha::Number, beta::Number)
         if isone(alpha) && iszero(beta)
             return _trimul!(C, A, B)
         else
@@ -813,7 +813,7 @@ for (TA, TB) in ((:AbstractTriangular, :AbstractMatrix),
                     (:AbstractMatrix, :AbstractTriangular),
                     (:AbstractTriangular, :AbstractTriangular)
                 )
-    @eval @inline function mul!(C::AbstractMatrix, A::$TA, B::$TB, alpha::Number, beta::Number)
+    @eval @inline function _mul!(C::AbstractMatrix, A::$TA, B::$TB, alpha::Number, beta::Number)
         if isone(alpha) && iszero(beta)
             return _trimul!(C, A, B)
         else
diff --git a/stdlib/LinearAlgebra/test/bidiag.jl b/stdlib/LinearAlgebra/test/bidiag.jl
index 1c50e1114967e..8d48c42a7f7ea 100644
--- a/stdlib/LinearAlgebra/test/bidiag.jl
+++ b/stdlib/LinearAlgebra/test/bidiag.jl
@@ -22,6 +22,9 @@ using .Main.FillArrays
 isdefined(Main, :OffsetArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "OffsetArrays.jl"))
 using .Main.OffsetArrays
 
+isdefined(Main, :SizedArrays) || @eval Main include(joinpath($(BASE_TEST_PATH), "testhelpers", "SizedArrays.jl"))
+using .Main.SizedArrays
+
 include("testutils.jl") # test_approx_eq_modphase
 
 n = 10 #Size of test matrix
@@ -861,4 +864,24 @@ end
     @test axes(B) === (ax, ax)
 end
 
+@testset "avoid matmul ambiguities with ::MyMatrix * ::AbstractMatrix" begin
+    A = [i+j for i in 1:2, j in 1:2]
+    S = SizedArrays.SizedArray{(2,2)}(A)
+    B = Bidiagonal([1:2;], [1;], :U)
+    @test S * B == A * B
+    @test B * S == B * A
+    C1, C2 = zeros(2,2), zeros(2,2)
+    @test mul!(C1, S, B) == mul!(C2, A, B)
+    @test mul!(C1, S, B, 1, 2) == mul!(C2, A, B, 1 ,2)
+    @test mul!(C1, B, S) == mul!(C2, B, A)
+    @test mul!(C1, B, S, 1, 2) == mul!(C2, B, A, 1 ,2)
+
+    v = [i for i in 1:2]
+    sv = SizedArrays.SizedArray{(2,)}(v)
+    @test B * sv == B * v
+    C1, C2 = zeros(2), zeros(2)
+    @test mul!(C1, B, sv) == mul!(C2, B, v)
+    @test mul!(C1, B, sv, 1, 2) == mul!(C2, B, v, 1 ,2)
+end
+
 end # module TestBidiagonal
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index dab8f45ef66c7..20d807c4b9c65 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -1248,6 +1248,18 @@ end
     D = Diagonal([1:2;])
     @test S * D == A * D
     @test D * S == D * A
+    C1, C2 = zeros(2,2), zeros(2,2)
+    @test mul!(C1, S, D) == mul!(C2, A, D)
+    @test mul!(C1, S, D, 1, 2) == mul!(C2, A, D, 1 ,2)
+    @test mul!(C1, D, S) == mul!(C2, D, A)
+    @test mul!(C1, D, S, 1, 2) == mul!(C2, D, A, 1 ,2)
+
+    v = [i for i in 1:2]
+    sv = SizedArrays.SizedArray{(2,)}(v)
+    @test D * sv == D * v
+    C1, C2 = zeros(2), zeros(2)
+    @test mul!(C1, D, sv) == mul!(C2, D, v)
+    @test mul!(C1, D, sv, 1, 2) == mul!(C2, D, v, 1 ,2)
 end
 
 @testset "copy" begin
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index e245240335434..dfe3f60d2a639 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -902,6 +902,18 @@ end
     U = UpperTriangular(ones(2,2))
     @test S * U == A * U
     @test U * S == U * A
+    C1, C2 = zeros(2,2), zeros(2,2)
+    @test mul!(C1, S, U) == mul!(C2, A, U)
+    @test mul!(C1, S, U, 1, 2) == mul!(C2, A, U, 1 ,2)
+    @test mul!(C1, U, S) == mul!(C2, U, A)
+    @test mul!(C1, U, S, 1, 2) == mul!(C2, U, A, 1 ,2)
+
+    v = [i for i in 1:2]
+    sv = SizedArrays.SizedArray{(2,)}(v)
+    @test U * sv == U * v
+    C1, C2 = zeros(2), zeros(2)
+    @test mul!(C1, U, sv) == mul!(C2, U, v)
+    @test mul!(C1, U, sv, 1, 2) == mul!(C2, U, v, 1 ,2)
 end
 
 @testset "custom axes" begin
diff --git a/test/testhelpers/SizedArrays.jl b/test/testhelpers/SizedArrays.jl
index 67f5059b36efd..43bc27e630479 100644
--- a/test/testhelpers/SizedArrays.jl
+++ b/test/testhelpers/SizedArrays.jl
@@ -10,6 +10,7 @@ module SizedArrays
 import Base: +, *, ==
 
 using LinearAlgebra
+import LinearAlgebra: mul!
 
 export SizedArray
 
@@ -33,6 +34,8 @@ struct SizedArray{SZ,T,N,A<:AbstractArray} <: AbstractArray{T,N}
         new{SZ,T,N,A}(A(data))
     end
 end
+SizedMatrix{SZ,T,A<:AbstractArray} = SizedArray{SZ,T,2,A}
+SizedVector{SZ,T,A<:AbstractArray} = SizedArray{SZ,T,1,A}
 Base.convert(::Type{SizedArray{SZ,T,N,A}}, data::AbstractArray) where {SZ,T,N,A} = SizedArray{SZ,T,N,A}(data)
 
 # Minimal AbstractArray interface
@@ -44,21 +47,28 @@ Base.zero(::Type{T}) where T <: SizedArray = SizedArray{size(T)}(zeros(eltype(T)
 +(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = SizedArray{SZ}(S1.data + S2.data)
 ==(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = S1.data == S2.data
 
-const SizedArrayLike = Union{SizedArray, Transpose{<:Any, <:SizedArray}, Adjoint{<:Any, <:SizedArray}}
+const SizedMatrixLike = Union{SizedMatrix, Transpose{<:Any, <:SizedMatrix}, Adjoint{<:Any, <:SizedMatrix}}
 
 _data(S::SizedArray) = S.data
 _data(T::Transpose{<:Any, <:SizedArray}) = transpose(_data(parent(T)))
 _data(T::Adjoint{<:Any, <:SizedArray}) = adjoint(_data(parent(T)))
 
-function *(S1::SizedArrayLike, S2::SizedArrayLike)
+function *(S1::SizedMatrixLike, S2::SizedMatrixLike)
     0 < ndims(S1) < 3 && 0 < ndims(S2) < 3 && size(S1, 2) == size(S2, 1) || throw(ArgumentError("size mismatch!"))
     data = _data(S1) * _data(S2)
     SZ = ndims(data) == 1 ? (size(S1, 1), ) : (size(S1, 1), size(S2, 2))
     SizedArray{SZ}(data)
 end
 
-# deliberately wide method definition to ensure that this doesn't lead to ambiguities with
-# structured matrices
-*(S1::SizedArrayLike, M::AbstractMatrix) = _data(S1) * M
+# deliberately wide method definitions to test for method ambiguties in LinearAlgebra
+*(S1::SizedMatrixLike, M::AbstractMatrix) = _data(S1) * M
+mul!(dest::AbstractMatrix, S1::SizedMatrix, M::AbstractMatrix, α::Number, β::Number) =
+    mul!(dest, _data(S1), M, α, β)
+mul!(dest::AbstractMatrix, M::AbstractMatrix, S2::SizedMatrix, α::Number, β::Number) =
+    mul!(dest, M, _data(S2), α, β)
+mul!(dest::AbstractMatrix, S1::SizedMatrix, S2::SizedMatrix, α::Number, β::Number) =
+    mul!(dest, _data(S1), _data(S2), α, β)
+mul!(dest::AbstractVector, M::AbstractMatrix, v::SizedVector, α::Number, β::Number) =
+    mul!(dest, M, _data(v), α, β)
 
 end

From 0f7b598ad2a690cae4fe67b3f834e476a77399f4 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Wed, 10 Jan 2024 21:11:41 +0100
Subject: [PATCH 0599/1315] BinaryPlatforms: prevent creating an identical
 regex every time a `Platform` is parsed (#52829)

Pkg likes to call `HostPlatform()` a bit too often for its own good
which shows up in some profiles. This makes `HostPlatform()` go from 250
us to 150 us with a quite trivial code change so should be fairly
uncontroversial. (Pkg should probably also be fixed, alt. `HostPlatform`
should be cached in Base.)
---
 base/binaryplatforms.jl | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/base/binaryplatforms.jl b/base/binaryplatforms.jl
index b374d57ce9731..e0ee107c4ec73 100644
--- a/base/binaryplatforms.jl
+++ b/base/binaryplatforms.jl
@@ -661,18 +661,12 @@ const libstdcxx_version_mapping = Dict{String,String}(
     "libstdcxx" => "-libstdcxx\\d+",
 )
 
-"""
-    parse(::Type{Platform}, triplet::AbstractString)
-
-Parses a string platform triplet back into a `Platform` object.
-"""
-function Base.parse(::Type{Platform}, triplet::String; validate_strict::Bool = false)
+const triplet_regex = let
     # Helper function to collapse dictionary of mappings down into a regex of
     # named capture groups joined by "|" operators
     c(mapping) = string("(",join(["(?<$k>$v)" for (k, v) in mapping], "|"), ")")
 
-    # We're going to build a mondo regex here to parse everything:
-    triplet_regex = Regex(string(
+    Regex(string(
         "^",
         # First, the core triplet; arch/os/libc/call_abi
         c(arch_mapping),
@@ -687,7 +681,14 @@ function Base.parse(::Type{Platform}, triplet::String; validate_strict::Bool = f
         "(?<tags>(?:-[^-]+\\+[^-]+)*)?",
         "\$",
     ))
+end
 
+"""
+    parse(::Type{Platform}, triplet::AbstractString)
+
+Parses a string platform triplet back into a `Platform` object.
+"""
+function Base.parse(::Type{Platform}, triplet::String; validate_strict::Bool = false)
     m = match(triplet_regex, triplet)
     if m !== nothing
         # Helper function to find the single named field within the giant regex

From 73cdfd8a240f18cec698ace2fd5a426a57a2cbe9 Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Thu, 11 Jan 2024 09:43:57 +0100
Subject: [PATCH 0600/1315] Code validation and IR verification improvements
 (#52844)

---
 base/compiler/ssair/verify.jl | 3 ++-
 base/compiler/validation.jl   | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index 13656683e8ea9..ae294990b40d0 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -2,7 +2,8 @@
 
 function maybe_show_ir(ir::IRCode)
     if isdefined(Core, :Main)
-        invokelatest(Core.Main.Base.display, ir)
+        # ensure we use I/O that does not yield, as this gets called during compilation
+        invokelatest(Core.Main.Base.show, Core.stdout, "text/plain", ir)
     end
 end
 
diff --git a/base/compiler/validation.jl b/base/compiler/validation.jl
index 2428ea8a38892..9a46a2411de13 100644
--- a/base/compiler/validation.jl
+++ b/base/compiler/validation.jl
@@ -253,7 +253,7 @@ end
 
 function is_valid_rvalue(@nospecialize(x))
     is_valid_argument(x) && return true
-    if isa(x, Expr) && x.head in (:new, :splatnew, :the_exception, :isdefined, :call, :invoke, :invoke_modify, :foreigncall, :cfunction, :gc_preserve_begin, :copyast)
+    if isa(x, Expr) && x.head in (:new, :splatnew, :the_exception, :isdefined, :call, :invoke, :invoke_modify, :foreigncall, :cfunction, :gc_preserve_begin, :copyast, :new_opaque_closure)
         return true
     end
     return false

From 3dcc07ce0007e6222d6996fb4e340e3423102937 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Thu, 11 Jan 2024 17:52:56 +0900
Subject: [PATCH 0601/1315] effects: fix #52843, account for mutable values
 directly embedded to IR

Fixes another variant of #52531.
---
 base/compiler/abstractinterpretation.jl | 14 +++++++-------
 test/compiler/effects.jl                |  6 ++++++
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 3701fa8cf9cae..5c27edea6d686 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2310,11 +2310,7 @@ function abstract_eval_cfunction(interp::AbstractInterpreter, e::Expr, vtypes::U
 end
 
 function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(e), vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
-    if isa(e, QuoteNode)
-        effects = Effects(EFFECTS_TOTAL;
-            inaccessiblememonly = is_mutation_free_argtype(typeof(e.value)) ? ALWAYS_TRUE : ALWAYS_FALSE)
-        return RTEffects(Const(e.value), Union{}, effects)
-    elseif isa(e, SSAValue)
+    if isa(e, SSAValue)
         return RTEffects(abstract_eval_ssavalue(e, sv), Union{}, EFFECTS_TOTAL)
     elseif isa(e, SlotNumber)
         if vtypes !== nothing
@@ -2335,8 +2331,12 @@ function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(
     elseif isa(e, GlobalRef)
         return abstract_eval_globalref(interp, e, sv)
     end
-
-    return RTEffects(Const(e), Union{}, EFFECTS_TOTAL)
+    if isa(e, QuoteNode)
+        e = e.value
+    end
+    effects = Effects(EFFECTS_TOTAL;
+        inaccessiblememonly = is_mutation_free_argtype(typeof(e)) ? ALWAYS_TRUE : ALWAYS_FALSE)
+    return RTEffects(Const(e), Union{}, effects)
 end
 
 function abstract_eval_value_expr(interp::AbstractInterpreter, e::Expr, sv::AbsIntState)
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 2c303f5335633..71eb50cd42760 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1370,6 +1370,12 @@ top_52531(_) = (set_initialized52531!(true); nothing)
 top_52531(0)
 @test is_initialized52531()
 
+const ref52843 = Ref{Int}()
+@eval func52843() = ($ref52843[] = 1; nothing)
+@test !Core.Compiler.is_foldable(Base.infer_effects(func52843))
+let; Base.Experimental.@force_compile; func52843(); end
+@test ref52843[] == 1
+
 @test Core.Compiler.is_inaccessiblememonly(Base.infer_effects(identity∘identity, Tuple{Any}))
 @test Core.Compiler.is_inaccessiblememonly(Base.infer_effects(()->Vararg, Tuple{}))
 

From 2096423e7b5dc3bf69604a070d907f2aabfdc7d4 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Thu, 11 Jan 2024 15:40:50 +0530
Subject: [PATCH 0602/1315] Added show function

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl      | 15 +++++++++++++++
 doc/src/base/base.md |  1 +
 2 files changed, 16 insertions(+)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index e494204f1cabc..132fe806efd17 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -32,9 +32,11 @@ export BINDIR,
        isunix,
        iswindows,
        isjsvm,
+       show,
        isexecutable,
        username,
        which
+       
 
 import ..Base: show
 
@@ -640,5 +642,18 @@ function username()
     isempty(pw.username) && Base.uv_error("username", Base.UV_ENOENT)
     return pw.username
 end
+"""
+    Sys.show(io::IO, ::MIME"text/plain", cpu::AbstractVector{CPUinfo})
+
+Print a summary of CPU information to the `io` stream (defaulting to [`stdout`](@ref)), 
+organizing and displaying aggregated data for CPUs with the same model, 
+for a given array of `CPUinfo` data structures.
+
+"""
+function show(io::IO,::MIME"text/plain",cpu::AbstractVector{CPUinfo})
+    summary(io, cpu)
+    println(io, ':')
+    cpu_summary(io, cpu)
+end
 
 end # module Sys
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index f91863a3b56d4..26713294046e7 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -378,6 +378,7 @@ Base.Sys.isjsvm
 Base.Sys.loadavg
 Base.Sys.isexecutable
 Base.Sys.username
+Base.Sys.show
 Base.@static
 ```
 

From 3e63af56691f3f8dec63793d0259ce3f837eca3b Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Thu, 11 Jan 2024 15:47:30 +0530
Subject: [PATCH 0603/1315] Formatted the code

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 132fe806efd17..5342f27f4501f 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -36,7 +36,6 @@ export BINDIR,
        isexecutable,
        username,
        which
-       
 
 import ..Base: show
 
@@ -645,10 +644,9 @@ end
 """
     Sys.show(io::IO, ::MIME"text/plain", cpu::AbstractVector{CPUinfo})
 
-Print a summary of CPU information to the `io` stream (defaulting to [`stdout`](@ref)), 
-organizing and displaying aggregated data for CPUs with the same model, 
+Print a summary of CPU information to the `io` stream (defaulting to [`stdout`](@ref)),
+organizing and displaying aggregated data for CPUs with the same model,
 for a given array of `CPUinfo` data structures.
-
 """
 function show(io::IO,::MIME"text/plain",cpu::AbstractVector{CPUinfo})
     summary(io, cpu)

From c5d7b87a35b5beaef9d4d3aa53c0a2686f3445b9 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 11 Jan 2024 18:56:23 +0530
Subject: [PATCH 0604/1315] Fix variable name in scaling an
 `AbstractTriangular` with zero alpha (#52855)

There is no `C` defined in these methods, so this branch used to error.
---
 stdlib/LinearAlgebra/src/triangular.jl  | 16 ++++++++--------
 stdlib/LinearAlgebra/test/triangular.jl |  5 +++++
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 4931e314d0d5c..6e92b9f07dd84 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -545,7 +545,7 @@ end
 
 function _triscale!(A::UpperTriangular, B::UpperTriangular, c::Number, _add)
     n = checksize1(A, B)
-    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    iszero(_add.alpha) && return _rmul_or_fill!(A, _add.beta)
     for j = 1:n
         for i = 1:j
             @inbounds _modify!(_add, B.data[i,j] * c, A.data, (i,j))
@@ -555,7 +555,7 @@ function _triscale!(A::UpperTriangular, B::UpperTriangular, c::Number, _add)
 end
 function _triscale!(A::UpperTriangular, c::Number, B::UpperTriangular, _add)
     n = checksize1(A, B)
-    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    iszero(_add.alpha) && return _rmul_or_fill!(A, _add.beta)
     for j = 1:n
         for i = 1:j
             @inbounds _modify!(_add, c * B.data[i,j], A.data, (i,j))
@@ -565,7 +565,7 @@ function _triscale!(A::UpperTriangular, c::Number, B::UpperTriangular, _add)
 end
 function _triscale!(A::UpperOrUnitUpperTriangular, B::UnitUpperTriangular, c::Number, _add)
     n = checksize1(A, B)
-    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    iszero(_add.alpha) && return _rmul_or_fill!(A, _add.beta)
     for j = 1:n
         @inbounds _modify!(_add, c, A, (j,j))
         for i = 1:(j - 1)
@@ -576,7 +576,7 @@ function _triscale!(A::UpperOrUnitUpperTriangular, B::UnitUpperTriangular, c::Nu
 end
 function _triscale!(A::UpperOrUnitUpperTriangular, c::Number, B::UnitUpperTriangular, _add)
     n = checksize1(A, B)
-    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    iszero(_add.alpha) && return _rmul_or_fill!(A, _add.beta)
     for j = 1:n
         @inbounds _modify!(_add, c, A, (j,j))
         for i = 1:(j - 1)
@@ -587,7 +587,7 @@ function _triscale!(A::UpperOrUnitUpperTriangular, c::Number, B::UnitUpperTriang
 end
 function _triscale!(A::LowerTriangular, B::LowerTriangular, c::Number, _add)
     n = checksize1(A, B)
-    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    iszero(_add.alpha) && return _rmul_or_fill!(A, _add.beta)
     for j = 1:n
         for i = j:n
             @inbounds _modify!(_add, B.data[i,j] * c, A.data, (i,j))
@@ -597,7 +597,7 @@ function _triscale!(A::LowerTriangular, B::LowerTriangular, c::Number, _add)
 end
 function _triscale!(A::LowerTriangular, c::Number, B::LowerTriangular, _add)
     n = checksize1(A, B)
-    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    iszero(_add.alpha) && return _rmul_or_fill!(A, _add.beta)
     for j = 1:n
         for i = j:n
             @inbounds _modify!(_add, c * B.data[i,j], A.data, (i,j))
@@ -607,7 +607,7 @@ function _triscale!(A::LowerTriangular, c::Number, B::LowerTriangular, _add)
 end
 function _triscale!(A::LowerOrUnitLowerTriangular, B::UnitLowerTriangular, c::Number, _add)
     n = checksize1(A, B)
-    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    iszero(_add.alpha) && return _rmul_or_fill!(A, _add.beta)
     for j = 1:n
         @inbounds _modify!(_add, c, A, (j,j))
         for i = (j + 1):n
@@ -618,7 +618,7 @@ function _triscale!(A::LowerOrUnitLowerTriangular, B::UnitLowerTriangular, c::Nu
 end
 function _triscale!(A::LowerOrUnitLowerTriangular, c::Number, B::UnitLowerTriangular, _add)
     n = checksize1(A, B)
-    iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
+    iszero(_add.alpha) && return _rmul_or_fill!(A, _add.beta)
     for j = 1:n
         @inbounds _modify!(_add, c, A, (j,j))
         for i = (j + 1):n
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index dfe3f60d2a639..7de1d10fe6d6c 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -252,6 +252,11 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo
                 A2tmp = unitt(A1)
                 mul!(A1tmp, cr, A2tmp)
                 @test A1tmp == cr * A2tmp
+
+                A1tmp .= A1
+                @test mul!(A1tmp, A2tmp, cr, 0, 2) == 2A1
+                A1tmp .= A1
+                @test mul!(A1tmp, cr, A2tmp, 0, 2) == 2A1
             else
                 A1tmp = copy(A1)
                 rmul!(A1tmp, ci)

From 3f38416006a57b588b16b682c5ba76f8f55e28ef Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Thu, 11 Jan 2024 20:00:26 +0530
Subject: [PATCH 0605/1315] Fixed/Added Suggested Changes

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl      | 13 +++++--------
 doc/src/base/base.md |  2 --
 2 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 5342f27f4501f..551bdc2ee5496 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -32,7 +32,6 @@ export BINDIR,
        isunix,
        iswindows,
        isjsvm,
-       show,
        isexecutable,
        username,
        which
@@ -236,6 +235,10 @@ describing a set of CPUs (which defaults to the return value of the [`Sys.cpu_in
 
 The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.
+
+!!! compat "Julia 1.11"
+As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g. 
+`display` for REPL output), so it need not be called directly.
 """
 function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())
     model = cpu[1].model
@@ -641,14 +644,8 @@ function username()
     isempty(pw.username) && Base.uv_error("username", Base.UV_ENOENT)
     return pw.username
 end
-"""
-    Sys.show(io::IO, ::MIME"text/plain", cpu::AbstractVector{CPUinfo})
 
-Print a summary of CPU information to the `io` stream (defaulting to [`stdout`](@ref)),
-organizing and displaying aggregated data for CPUs with the same model,
-for a given array of `CPUinfo` data structures.
-"""
-function show(io::IO,::MIME"text/plain",cpu::AbstractVector{CPUinfo})
+function show(io::IO, ::MIME"text/plain", cpu::AbstractVector{CPUinfo})
     summary(io, cpu)
     println(io, ':')
     cpu_summary(io, cpu)
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 26713294046e7..4f7d493777e98 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -358,7 +358,6 @@ Base.Sys.STDLIB
 Base.Sys.CPU_NAME
 Base.Sys.JIT
 Base.Sys.cpu_info
-Base.Sys.cpu_summary
 Base.Sys.isunix
 Base.Sys.isapple
 Base.Sys.islinux
@@ -378,7 +377,6 @@ Base.Sys.isjsvm
 Base.Sys.loadavg
 Base.Sys.isexecutable
 Base.Sys.username
-Base.Sys.show
 Base.@static
 ```
 

From 0a3cf6f97154935505548044d0ee1ed23094c488 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Thu, 11 Jan 2024 20:04:40 +0530
Subject: [PATCH 0606/1315] Removed WhiteSpace

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 551bdc2ee5496..ddfab7f6e5809 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -237,7 +237,7 @@ The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.
 
 !!! compat "Julia 1.11"
-As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g. 
+As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g.
 `display` for REPL output), so it need not be called directly.
 """
 function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())

From e11dfd98bc5c2f8f7b5334738ca80885a86e2540 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Thu, 11 Jan 2024 20:10:25 +0530
Subject: [PATCH 0607/1315] Added Space

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index ddfab7f6e5809..495c3a009aa7f 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -237,7 +237,7 @@ The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.
 
 !!! compat "Julia 1.11"
-As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g.
+    As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g.
 `display` for REPL output), so it need not be called directly.
 """
 function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())

From eaf73a8e30162183ec97df0d481187b2da70be6a Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Thu, 11 Jan 2024 20:16:52 +0530
Subject: [PATCH 0608/1315] Added Proper Indent

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 495c3a009aa7f..8ec3cc6249a2a 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -237,8 +237,8 @@ The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.
 
 !!! compat "Julia 1.11"
-    As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g.
-`display` for REPL output), so it need not be called directly.
+     As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g.
+     `display` for REPL output), so it need not be called directly.
 """
 function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())
     model = cpu[1].model

From 3f6bec76c25318dfbeeecb31ccfffb24e3bfa48d Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Thu, 11 Jan 2024 23:44:27 +0530
Subject: [PATCH 0609/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 8ec3cc6249a2a..28ff1cbbe5e2e 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -118,7 +118,7 @@ global CPU_NAME::String
 A string representing the specific Just-In-Time (JIT) compiler being utilized in the current runtime.
 
 # Examples
-Currently, this returns `"ORCJIT"` for the LLVM "ORC" ("On-Request Compilation") JIT library:
+Currently, this equals `"ORCJIT"` for the LLVM "ORC" ("On-Request Compilation") JIT library:
 ```jldoctest
 julia> Sys.JIT
 "ORCJIT"

From 88e6fae0f340a01ae2d49893cefdb02f7d233124 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Thu, 11 Jan 2024 23:44:37 +0530
Subject: [PATCH 0610/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 28ff1cbbe5e2e..b52215d57454b 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -255,7 +255,7 @@ end
 """
     Sys.cpu_info()
 
-Return a vector of `CPUinfo` objects, where each object represent information about a CPU core.
+Return a vector of `CPUinfo` objects, where each object represents information about a CPU core.
 This is displayed in a tabular format by the REPL, so most users will not need to access the `CPUinfo`
 data structures directly.
 

From f35cb86ed4b0c692bf3e1b01263c7bd9b4c32f34 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Thu, 11 Jan 2024 23:49:43 +0530
Subject: [PATCH 0611/1315] suggested changed

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 8ec3cc6249a2a..1827a717f2192 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -200,7 +200,7 @@ function _show_cpuinfo(io::IO, info::Sys.CPUinfo, header::Bool=true, prefix::Abs
     end
 end
 
-show(io::IO, info::CPUinfo) = _show_cpuinfo(io, info, true, "    ")
+show(io::IO, ::MIME"text/plain", info::CPUinfo) = _show_cpuinfo(io, info, true, "    ")
 
 function _cpu_summary(io::IO, cpu::AbstractVector{CPUinfo}, i, j)
     if j-i < 9

From 403a80a6f8d707359ca1aeab4ed9d1acfb49660c Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Fri, 12 Jan 2024 00:48:52 +0600
Subject: [PATCH 0612/1315] Precision of language in `names` docstring (#52744)

---
 base/reflection.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index 0295657eea1fc..67044350e6b25 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -75,7 +75,7 @@ end
 """
     names(x::Module; all::Bool = false, imported::Bool = false)
 
-Get an array of the public names of a `Module`, excluding deprecated names.
+Get a vector of the public names of a `Module`, excluding deprecated names.
 If `all` is true, then the list also includes non-public names defined in the module,
 deprecated names, and compiler-generated names.
 If `imported` is true, then names explicitly imported from other modules

From 0fdd55b163ec0b7c73745d5395d12cff300be6fd Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 12 Jan 2024 04:04:19 +0100
Subject: [PATCH 0613/1315] Fix inconsistency between exct and nothrow effect
 (#52853)

Fixes #52846. Different unreachability checks use different definitions
for this and were inconsistenct, causing the assertion.

Since the exct modeling isn't fully plubmed through all corners of the
compiler yet, also change the caller code to force the nothrow effect to
be authoritative for the time being.
---
 base/compiler/abstractinterpretation.jl | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 5c27edea6d686..1c075fd4d8a25 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2119,8 +2119,14 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
             abstract_call_gf_by_type(interp, f, ArgInfo(nothing, T), si, atype, sv, max_methods)
         end
         pT = typevar_tfunc(𝕃ᵢ, n, lb_var, ub_var)
-        effects = builtin_effects(𝕃ᵢ, Core._typevar, Any[n, lb_var, ub_var], pT)
-        return CallMeta(pT, Any, effects, call.info)
+        typevar_argtypes = Any[n, lb_var, ub_var]
+        effects = builtin_effects(𝕃ᵢ, Core._typevar, typevar_argtypes, pT)
+        if effects.nothrow
+            exct = Union{}
+        else
+            exct = builtin_exct(𝕃ᵢ, Core._typevar, typevar_argtypes, pT)
+        end
+        return CallMeta(pT, exct, effects, call.info)
     elseif f === UnionAll
         call = abstract_call_gf_by_type(interp, f, ArgInfo(nothing, Any[Const(UnionAll), Any, Any]), si, Tuple{Type{UnionAll}, Any, Any}, sv, max_methods)
         return abstract_call_unionall(interp, argtypes, call)
@@ -3288,10 +3294,12 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             # Process non control-flow statements
             (; changes, rt, exct) = abstract_eval_basic_statement(interp,
                 stmt, currstate, frame)
-            if exct !== Union{}
-                update_exc_bestguess!(interp, exct, frame)
-            end
             if !has_curr_ssaflag(frame, IR_FLAG_NOTHROW)
+                if exct !== Union{}
+                    update_exc_bestguess!(interp, exct, frame)
+                    # TODO: assert that these conditions match. For now, we assume the `nothrow` flag
+                    # to be correct, but allow the exct to be an over-approximation.
+                end
                 propagate_to_error_handler!(currstate, frame, 𝕃ᵢ)
             end
             if rt === Bottom

From 526ac1ec34c0072b706caf965316fdec042f395e Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Fri, 12 Jan 2024 12:06:44 +0530
Subject: [PATCH 0614/1315] Public CPUinfo,Added Tests for show

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/exports.jl      |  1 +
 base/sysinfo.jl      | 21 +++++++++++++--------
 doc/src/base/base.md |  1 +
 test/sysinfo.jl      | 11 +++++++++++
 4 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/base/exports.jl b/base/exports.jl
index 92525b85c7635..f1b6a3ee75ff4 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1088,6 +1088,7 @@ public
     Event,
     Fix1,
     Fix2,
+    CPUinfo,
     Generator,
     ImmutableDict,
     OneTo,
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index c4c88354bf2eb..a04e48ba07de3 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -165,6 +165,18 @@ mutable struct UV_cpu_info_t
     cpu_times!idle::UInt64
     cpu_times!irq::UInt64
 end
+"""
+    Sys.CPUinfo
+
+The `CPUinfo` type is a mutable struct with the following fields:
+- `model::String`: CPU model information.
+- `speed::Int32`: CPU speed.
+- `cpu_times!user::UInt64`: Time spent in user mode. CPU state shows CPU time used by user space processes.
+- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks.
+- `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel.
+- `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used.
+- `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts.
+"""
 mutable struct CPUinfo
     model::String
     speed::Int32
@@ -260,14 +272,7 @@ This is displayed in a tabular format by the REPL, so most users will not need t
 data structures directly.
 
 The function provides information about each CPU, including model, speed, and usage statistics such as user time, nice time, system time, idle time, and interrupt time.
-The `CPUinfo` type is a mutable struct with the following fields:
-- `model::String`: CPU model information.
-- `speed::Int32`: CPU speed.
-- `cpu_times!user::UInt64`: Time spent in user mode. CPU state shows CPU time used by user space processes.
-- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks.
-- `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel.
-- `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used.
-- `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts.
+
 """
 function cpu_info()
     UVcpus = Ref{Ptr{UV_cpu_info_t}}()
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 4f7d493777e98..bcfca2d31938e 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -356,6 +356,7 @@ Base.EnvDict
 Base.ENV
 Base.Sys.STDLIB
 Base.Sys.CPU_NAME
+Base.Sys.CPUinfo
 Base.Sys.JIT
 Base.Sys.cpu_info
 Base.Sys.isunix
diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index 8864e3a48efc7..c624052fc4217 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -54,3 +54,14 @@ end
         @test !isempty(Sys.username())
     end
 end
+
+@testset "show" begin
+    example_cpus = [Base.Sys.CPUinfo("Apple M1 Pro", 2400, 0x000000000d913b08, 0x0000000000000000, 0x0000000005f4243c, 0x00000000352a550a, 0x0000000000000000)
+    Base.Sys.CPUinfo("Apple M1 Pro", 2400, 0x000000000d9040c2, 0x0000000000000000, 0x0000000005d4768c, 0x00000000356b3d22, 0x0000000000000000)
+    Base.Sys.CPUinfo("Apple M1 Pro", 2400, 0x00000000026784da, 0x0000000000000000, 0x0000000000fda30e, 0x0000000046a731ea, 0x0000000000000000)
+    Base.Sys.CPUinfo("Apple M1 Pro", 2400, 0x00000000017726c0, 0x0000000000000000, 0x00000000009491de, 0x0000000048134f1e, 0x0000000000000000)]
+
+    @test repr(example_cpus[1]) == "Base.Sys.CPUinfo(\"Apple M1 Pro\", 2400, 0x000000000d913b08, 0x0000000000000000, 0x0000000005f4243c, 0x00000000352a550a, 0x0000000000000000)"
+    @test repr("text/plain", example_cpus[1]) == "Apple M1 Pro: \n        speed         user         nice          sys         idle          irq\n     2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s"
+    @test repr("text/plain", example_cpus) == "4-element Vector{Base.Sys.CPUinfo}:\nApple M1 Pro: \n       speed         user         nice          sys         idle          irq\n#1  2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s\n#2  2400 MHz    2275576 s          0 s     978101 s    8962204 s          0 s\n#3  2400 MHz     403386 s          0 s     166224 s   11853624 s          0 s\n#4  2400 MHz     245859 s          0 s      97367 s   12092250 s          0 s\n"
+end

From 9836f2d61dfaaac58e314636b1702b0f070571e8 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 12 Jan 2024 15:18:08 +0100
Subject: [PATCH 0615/1315] staticdata: Some refactors for clarity (#52852)

I was reading this code as part of looking into #52797. To recap, when
we serialize objects for package images, we classify each method as
either internal or external, depending on whether the method extends a
function in the ambient set of modules ( system image, other previously
loaded package images, etc) or whether it is private to the module we're
currently serializing (in which case we call it internal).

One of my primary confusions in reading this code was that the
`new_specializations` object holds only external code instances in most
of the code, but towards the end of loading, we used to also add any
internal code instances that had dependencies on other external method
instances in order to share the code instance validation code between
the two cases.

I don't think this design is that great. Conceptually, internal
CodeInstances are already in the CI cache at the point that validation
happens (their max_world is just set to 1, so they're not eligible to
run). We do guard the cache insertion by a check whether a code instance
already exists, which also catches this case, but I think it's cleaner
to just not add any internal code instances to the list and instead
simply re-activate the code instance in situ.

Another issue with the old code that I didn't observe, but I think is
possible in theory is that any CodeInstances that are not part of the
cache hierarchy (e.g. because they were created by external abstract
interpreters) should not accidentally get added to the cache hierarchy
by this code path. I think this was possible in the old code, but I
didn't observe it.

With this change, `new_specializations` now always only holds external
cis, so rename it appropriately. While we're at it, also do some other
clarity changes.
---
 src/precompile_utils.c |  6 +--
 src/staticdata.c       | 98 +++++++++++++++++++++---------------------
 src/staticdata_utils.c | 70 ++++++++++++++++++------------
 test/precompile.jl     |  4 +-
 4 files changed, 97 insertions(+), 81 deletions(-)

diff --git a/src/precompile_utils.c b/src/precompile_utils.c
index 0203569f33c37..338c62b7e2d72 100644
--- a/src/precompile_utils.c
+++ b/src/precompile_utils.c
@@ -279,7 +279,7 @@ static void *jl_precompile(int all)
     return native_code;
 }
 
-static void *jl_precompile_worklist(jl_array_t *worklist, jl_array_t *extext_methods, jl_array_t *new_specializations)
+static void *jl_precompile_worklist(jl_array_t *worklist, jl_array_t *extext_methods, jl_array_t *new_ext_cis)
 {
     if (!worklist)
         return NULL;
@@ -310,9 +310,9 @@ static void *jl_precompile_worklist(jl_array_t *worklist, jl_array_t *extext_met
             }
         }
     }
-    n = jl_array_nrows(new_specializations);
+    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_specializations, 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);
diff --git a/src/staticdata.c b/src/staticdata.c
index 8ad4a275b743d..ee605d06cc2c5 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -88,6 +88,8 @@ External links:
 #include "valgrind.h"
 #include "julia_assert.h"
 
+static const size_t WORLD_AGE_REVALIDATION_SENTINEL = 0x1;
+
 #include "staticdata_utils.c"
 #include "precompile_utils.c"
 
@@ -501,6 +503,8 @@ typedef struct {
     jl_array_t *link_ids_gvars;
     jl_array_t *link_ids_external_fnvars;
     jl_ptls_t ptls;
+    // Set (implemented has a hasmap of MethodInstances to themselves) of which MethodInstances have (forward) edges
+    // to other MethodInstances.
     htable_t callers_with_edges;
     jl_image_t *image;
     int8_t incremental;
@@ -1596,37 +1600,37 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
             }
             else if (jl_is_code_instance(v)) {
                 assert(f == s->s);
+
                 // Handle the native-code pointers
-                assert(f == s->s);
-                jl_code_instance_t *m = (jl_code_instance_t*)v;
-                jl_code_instance_t *newm = (jl_code_instance_t*)&f->buf[reloc_offset];
+                jl_code_instance_t *ci = (jl_code_instance_t*)v;
+                jl_code_instance_t *newci = (jl_code_instance_t*)&f->buf[reloc_offset];
 
                 if (s->incremental) {
                     arraylist_push(&s->fixup_objs, (void*)reloc_offset);
-                    if (m->min_world > 1)
-                        newm->min_world = ~(size_t)0;     // checks that we reprocess this upon deserialization
-                    if (m->max_world != ~(size_t)0)
-                        newm->max_world = 0;
+                    if (ci->min_world > 1)
+                        newci->min_world = ~(size_t)0;     // checks that we reprocess this upon deserialization
+                    if (ci->max_world != ~(size_t)0)
+                        newci->max_world = 0;
                     else {
-                        if (jl_atomic_load_relaxed(&m->inferred)  && ptrhash_has(&s->callers_with_edges, m->def))
-                            newm->max_world = 1;  // sentinel value indicating this will need validation
-                        if (m->min_world > 0 && jl_atomic_load_relaxed(&m->inferred) ) {
+                        if (jl_atomic_load_relaxed(&ci->inferred) && ptrhash_has(&s->callers_with_edges, ci->def))
+                            newci->max_world = WORLD_AGE_REVALIDATION_SENTINEL;
+                        if (ci->min_world > 0 && jl_atomic_load_relaxed(&ci->inferred) ) {
                             // TODO: also check if this object is part of the codeinst cache
                             // will check on deserialize if this cache entry is still valid
                         }
                     }
                 }
-                jl_atomic_store_relaxed(&newm->invoke, NULL);
-                jl_atomic_store_relaxed(&newm->specsigflags, 0);
-                jl_atomic_store_relaxed(&newm->specptr.fptr, NULL);
+                jl_atomic_store_relaxed(&newci->invoke, NULL);
+                jl_atomic_store_relaxed(&newci->specsigflags, 0);
+                jl_atomic_store_relaxed(&newci->specptr.fptr, NULL);
                 int8_t fptr_id = JL_API_NULL;
                 int8_t builtin_id = 0;
-                if (jl_atomic_load_relaxed(&m->invoke) == jl_fptr_const_return) {
+                if (jl_atomic_load_relaxed(&ci->invoke) == jl_fptr_const_return) {
                     fptr_id = JL_API_CONST;
                 }
                 else {
-                    if (jl_is_method(m->def->def.method)) {
-                        builtin_id = jl_fptr_id(jl_atomic_load_relaxed(&m->specptr.fptr));
+                    if (jl_is_method(ci->def->def.method)) {
+                        builtin_id = jl_fptr_id(jl_atomic_load_relaxed(&ci->specptr.fptr));
                         if (builtin_id) { // found in the table of builtins
                             assert(builtin_id >= 2);
                             fptr_id = JL_API_BUILTIN;
@@ -1634,7 +1638,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                         else {
                             int32_t invokeptr_id = 0;
                             int32_t specfptr_id = 0;
-                            jl_get_function_id(native_functions, m, &invokeptr_id, &specfptr_id); // see if we generated code for it
+                            jl_get_function_id(native_functions, ci, &invokeptr_id, &specfptr_id); // see if we generated code for it
                             if (invokeptr_id) {
                                 if (invokeptr_id == -1) {
                                     fptr_id = JL_API_BOXED;
@@ -1666,7 +1670,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                         }
                     }
                 }
-                jl_atomic_store_relaxed(&newm->invoke, NULL); // relocation offset
+                jl_atomic_store_relaxed(&newci->invoke, NULL); // relocation offset
                 if (fptr_id != JL_API_NULL) {
                     assert(fptr_id < BuiltinFunctionTag && "too many functions to serialize");
                     arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_code_instance_t, invoke))); // relocation location
@@ -2514,7 +2518,7 @@ JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val, int insert)
 }
 
 static void jl_prepare_serialization_data(jl_array_t *mod_array, jl_array_t *newly_inferred, uint64_t worklist_key,
-                           /* outputs */  jl_array_t **extext_methods, jl_array_t **new_specializations,
+                           /* outputs */  jl_array_t **extext_methods, jl_array_t **new_ext_cis,
                                           jl_array_t **method_roots_list, jl_array_t **ext_targets, jl_array_t **edges)
 {
     // extext_methods: [method1, ...], worklist-owned "extending external" methods added to functions owned by modules outside the worklist
@@ -2526,7 +2530,7 @@ static void jl_prepare_serialization_data(jl_array_t *mod_array, jl_array_t *new
     assert(edges_map == NULL);
 
     // Save the inferred code from newly inferred, external methods
-    *new_specializations = queue_external_cis(newly_inferred);
+    *new_ext_cis = queue_external_cis(newly_inferred);
 
     // Collect method extensions and edges data
     JL_GC_PUSH1(&edges_map);
@@ -2552,9 +2556,9 @@ static void jl_prepare_serialization_data(jl_array_t *mod_array, jl_array_t *new
         *ext_targets = jl_alloc_vec_any(0);
         *edges = jl_alloc_vec_any(0);
         *method_roots_list = jl_alloc_vec_any(0);
-        // Collect the new method roots
-        jl_collect_new_roots(*method_roots_list, *new_specializations, worklist_key);
-        jl_collect_edges(*edges, *ext_targets, *new_specializations, world);
+        // Collect the new method roots for external specializations
+        jl_collect_new_roots(*method_roots_list, *new_ext_cis, worklist_key);
+        jl_collect_edges(*edges, *ext_targets, *new_ext_cis, world);
     }
     assert(edges_map == NULL); // jl_collect_edges clears this when done
 
@@ -2564,7 +2568,7 @@ static void jl_prepare_serialization_data(jl_array_t *mod_array, jl_array_t *new
 // In addition to the system image (where `worklist = NULL`), this can also save incremental images with external linkage
 static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
                                            jl_array_t *worklist, jl_array_t *extext_methods,
-                                           jl_array_t *new_specializations, jl_array_t *method_roots_list,
+                                           jl_array_t *new_ext_cis, jl_array_t *method_roots_list,
                                            jl_array_t *ext_targets, jl_array_t *edges) JL_GC_DISABLED
 {
     htable_new(&field_replace, 0);
@@ -2680,7 +2684,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
             // Queue method extensions
             jl_queue_for_serialization(&s, extext_methods);
             // Queue the new specializations
-            jl_queue_for_serialization(&s, new_specializations);
+            jl_queue_for_serialization(&s, new_ext_cis);
             // Queue the new roots
             jl_queue_for_serialization(&s, method_roots_list);
             // Queue the edges
@@ -2836,7 +2840,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
             }
             jl_write_value(&s, jl_module_init_order);
             jl_write_value(&s, extext_methods);
-            jl_write_value(&s, new_specializations);
+            jl_write_value(&s, new_ext_cis);
             jl_write_value(&s, method_roots_list);
             jl_write_value(&s, ext_targets);
             jl_write_value(&s, edges);
@@ -2924,24 +2928,24 @@ JL_DLLEXPORT void jl_create_system_image(void **_native_data, jl_array_t *workli
         ff = f;
     }
 
-    jl_array_t *mod_array = NULL, *extext_methods = NULL, *new_specializations = NULL;
+    jl_array_t *mod_array = NULL, *extext_methods = NULL, *new_ext_cis = NULL;
     jl_array_t *method_roots_list = NULL, *ext_targets = NULL, *edges = NULL;
     int64_t checksumpos = 0;
     int64_t checksumpos_ff = 0;
     int64_t datastartpos = 0;
-    JL_GC_PUSH6(&mod_array, &extext_methods, &new_specializations, &method_roots_list, &ext_targets, &edges);
+    JL_GC_PUSH6(&mod_array, &extext_methods, &new_ext_cis, &method_roots_list, &ext_targets, &edges);
 
     if (worklist) {
         mod_array = jl_get_loaded_modules();  // __toplevel__ modules loaded in this session (from Base.loaded_modules_array)
         // Generate _native_data`
         if (_native_data != NULL) {
             jl_prepare_serialization_data(mod_array, newly_inferred, jl_worklist_key(worklist),
-                                          &extext_methods, &new_specializations, NULL, NULL, NULL);
+                                          &extext_methods, &new_ext_cis, NULL, NULL, NULL);
             jl_precompile_toplevel_module = (jl_module_t*)jl_array_ptr_ref(worklist, jl_array_len(worklist)-1);
-            *_native_data = jl_precompile_worklist(worklist, extext_methods, new_specializations);
+            *_native_data = jl_precompile_worklist(worklist, extext_methods, new_ext_cis);
             jl_precompile_toplevel_module = NULL;
             extext_methods = NULL;
-            new_specializations = NULL;
+            new_ext_cis = NULL;
         }
         jl_write_header_for_incremental(f, worklist, mod_array, udeps, srctextpos, &checksumpos);
         if (emit_split) {
@@ -2964,7 +2968,7 @@ JL_DLLEXPORT void jl_create_system_image(void **_native_data, jl_array_t *workli
     ct->reentrant_timing |= 0b1000;
     if (worklist) {
         jl_prepare_serialization_data(mod_array, newly_inferred, jl_worklist_key(worklist),
-                                      &extext_methods, &new_specializations, &method_roots_list, &ext_targets, &edges);
+                                      &extext_methods, &new_ext_cis, &method_roots_list, &ext_targets, &edges);
         if (!emit_split) {
             write_int32(f, 0); // No clone_targets
             write_padding(f, LLT_ALIGN(ios_pos(f), JL_CACHE_BYTE_ALIGNMENT) - ios_pos(f));
@@ -2976,7 +2980,7 @@ JL_DLLEXPORT void jl_create_system_image(void **_native_data, jl_array_t *workli
     }
     if (_native_data != NULL)
         native_functions = *_native_data;
-    jl_save_system_image_to_stream(ff, mod_array, worklist, extext_methods, new_specializations, method_roots_list, ext_targets, edges);
+    jl_save_system_image_to_stream(ff, mod_array, worklist, extext_methods, new_ext_cis, method_roots_list, ext_targets, edges);
     if (_native_data != NULL)
         native_functions = NULL;
     // make sure we don't run any Julia code concurrently before this point
@@ -3058,7 +3062,7 @@ extern void export_jl_small_typeof(void);
 static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl_array_t *depmods, uint64_t checksum,
                                 /* outputs */    jl_array_t **restored,         jl_array_t **init_order,
                                                  jl_array_t **extext_methods,
-                                                 jl_array_t **new_specializations, jl_array_t **method_roots_list,
+                                                 jl_array_t **new_ext_cis, jl_array_t **method_roots_list,
                                                  jl_array_t **ext_targets, jl_array_t **edges,
                                                  char **base, arraylist_t *ccallable_list, pkgcachesizes *cachesizes) JL_GC_DISABLED
 {
@@ -3120,7 +3124,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     ios_seek(f, LLT_ALIGN(ios_pos(f), 8));
     assert(!ios_eof(f));
     s.s = f;
-    uintptr_t offset_restored = 0, offset_init_order = 0, offset_extext_methods = 0, offset_new_specializations = 0, offset_method_roots_list = 0;
+    uintptr_t offset_restored = 0, offset_init_order = 0, offset_extext_methods = 0, offset_new_ext_cis = 0, offset_method_roots_list = 0;
     uintptr_t offset_ext_targets = 0, offset_edges = 0;
     if (!s.incremental) {
         size_t i;
@@ -3152,7 +3156,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         offset_restored = jl_read_offset(&s);
         offset_init_order = jl_read_offset(&s);
         offset_extext_methods = jl_read_offset(&s);
-        offset_new_specializations = jl_read_offset(&s);
+        offset_new_ext_cis = jl_read_offset(&s);
         offset_method_roots_list = jl_read_offset(&s);
         offset_ext_targets = jl_read_offset(&s);
         offset_edges = jl_read_offset(&s);
@@ -3181,16 +3185,14 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     uint32_t external_fns_begin = read_uint32(f);
     jl_read_arraylist(s.s, ccallable_list ? ccallable_list : &s.ccallable_list);
     if (s.incremental) {
-        assert(restored && init_order && extext_methods && new_specializations && method_roots_list && ext_targets && edges);
+        assert(restored && init_order && extext_methods && new_ext_cis && method_roots_list && ext_targets && edges);
         *restored = (jl_array_t*)jl_delayed_reloc(&s, offset_restored);
         *init_order = (jl_array_t*)jl_delayed_reloc(&s, offset_init_order);
         *extext_methods = (jl_array_t*)jl_delayed_reloc(&s, offset_extext_methods);
-        *new_specializations = (jl_array_t*)jl_delayed_reloc(&s, offset_new_specializations);
+        *new_ext_cis = (jl_array_t*)jl_delayed_reloc(&s, offset_new_ext_cis);
         *method_roots_list = (jl_array_t*)jl_delayed_reloc(&s, offset_method_roots_list);
         *ext_targets = (jl_array_t*)jl_delayed_reloc(&s, offset_ext_targets);
         *edges = (jl_array_t*)jl_delayed_reloc(&s, offset_edges);
-        if (!*new_specializations)
-            *new_specializations = jl_alloc_vec_any(0);
     }
     s.s = NULL;
 
@@ -3454,8 +3456,6 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
             jl_code_instance_t *ci = (jl_code_instance_t*)obj;
             assert(s.incremental);
             ci->min_world = world;
-            if (ci->max_world != 0)
-                jl_array_ptr_1d_push(*new_specializations, (jl_value_t*)ci);
         }
         else if (jl_is_globalref(obj)) {
             continue; // wait until all the module binding tables have been initialized
@@ -3601,11 +3601,11 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
     assert(datastartpos > 0 && datastartpos < dataendpos);
     needs_permalloc = jl_options.permalloc_pkgimg || needs_permalloc;
     jl_value_t *restored = NULL;
-    jl_array_t *init_order = NULL, *extext_methods = NULL, *new_specializations = NULL, *method_roots_list = NULL, *ext_targets = NULL, *edges = NULL;
+    jl_array_t *init_order = NULL, *extext_methods = NULL, *new_ext_cis = NULL, *method_roots_list = NULL, *ext_targets = NULL, *edges = NULL;
     jl_svec_t *cachesizes_sv = NULL;
     char *base;
     arraylist_t ccallable_list;
-    JL_GC_PUSH8(&restored, &init_order, &extext_methods, &new_specializations, &method_roots_list, &ext_targets, &edges, &cachesizes_sv);
+    JL_GC_PUSH8(&restored, &init_order, &extext_methods, &new_ext_cis, &method_roots_list, &ext_targets, &edges, &cachesizes_sv);
 
     { // make a permanent in-memory copy of f (excluding the header)
         ios_bufmode(f, bm_none);
@@ -3629,17 +3629,18 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
                 ios_close(f);
             ios_static_buffer(f, sysimg, len);
             pkgcachesizes cachesizes;
-            jl_restore_system_image_from_stream_(f, image, depmods, checksum, (jl_array_t**)&restored, &init_order, &extext_methods, &new_specializations, &method_roots_list, &ext_targets, &edges, &base, &ccallable_list, &cachesizes);
+            jl_restore_system_image_from_stream_(f, image, depmods, checksum, (jl_array_t**)&restored, &init_order, &extext_methods, &new_ext_cis, &method_roots_list,
+                                                 &ext_targets, &edges, &base, &ccallable_list, &cachesizes);
             JL_SIGATOMIC_END();
 
             // Insert method extensions
             jl_insert_methods(extext_methods);
-            // No special processing of `new_specializations` is required because recaching handled it
+            // No special processing of `new_ext_cis` is required because recaching handled it
             // Add roots to methods
             jl_copy_roots(method_roots_list, jl_worklist_key((jl_array_t*)restored));
             // Handle edges
             size_t world = jl_atomic_load_acquire(&jl_world_counter);
-            jl_insert_backedges((jl_array_t*)edges, (jl_array_t*)ext_targets, (jl_array_t*)new_specializations, world); // restore external backedges (needs to be last)
+            jl_insert_backedges((jl_array_t*)edges, (jl_array_t*)ext_targets, (jl_array_t*)new_ext_cis, world); // restore external backedges (needs to be last)
             // reinit ccallables
             jl_reinit_ccallable(&ccallable_list, base, pkgimage_handle);
             arraylist_free(&ccallable_list);
@@ -3653,7 +3654,8 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
                 jl_svecset(cachesizes_sv, 4, jl_box_long(cachesizes.reloclist));
                 jl_svecset(cachesizes_sv, 5, jl_box_long(cachesizes.gvarlist));
                 jl_svecset(cachesizes_sv, 6, jl_box_long(cachesizes.fptrlist));
-                restored = (jl_value_t*)jl_svec(8, restored, init_order, extext_methods, new_specializations, method_roots_list,
+                restored = (jl_value_t*)jl_svec(8, restored, init_order, extext_methods,
+                                                   new_ext_cis ? (jl_value_t*)new_ext_cis : jl_nothing, method_roots_list,
                                                    ext_targets, edges, cachesizes_sv);
             }
             else {
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index 9fded902df0bd..982f4b104eb74 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -168,7 +168,7 @@ static int has_backedge_to_worklist(jl_method_instance_t *mi, htable_t *visited,
     // HT_NOTFOUND: not yet analyzed
     // HT_NOTFOUND + 1: no link back
     // HT_NOTFOUND + 2: does link back
-    // HT_NOTFOUND + 3: does link back, and included in new_specializations already
+    // HT_NOTFOUND + 3: does link back, and included in new_ext_cis already
     // HT_NOTFOUND + 4 + depth: in-progress
     int found = (char*)*bp - (char*)HT_NOTFOUND;
     if (found)
@@ -224,8 +224,8 @@ static jl_array_t *queue_external_cis(jl_array_t *list)
     size_t n0 = jl_array_nrows(list);
     htable_new(&visited, n0);
     arraylist_new(&stack, 0);
-    jl_array_t *new_specializations = jl_alloc_vec_any(0);
-    JL_GC_PUSH1(&new_specializations);
+    jl_array_t *new_ext_cis = jl_alloc_vec_any(0);
+    JL_GC_PUSH1(&new_ext_cis);
     for (i = n0; i-- > 0; ) {
         jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(list, i);
         assert(jl_is_code_instance(ci));
@@ -241,7 +241,7 @@ static jl_array_t *queue_external_cis(jl_array_t *list)
                 void **bp = ptrhash_bp(&visited, mi);
                 if (*bp != (void*)((char*)HT_NOTFOUND + 3)) {
                     *bp = (void*)((char*)HT_NOTFOUND + 3);
-                    jl_array_ptr_1d_push(new_specializations, (jl_value_t*)ci);
+                    jl_array_ptr_1d_push(new_ext_cis, (jl_value_t*)ci);
                 }
             }
         }
@@ -249,25 +249,25 @@ static jl_array_t *queue_external_cis(jl_array_t *list)
     htable_free(&visited);
     arraylist_free(&stack);
     JL_GC_POP();
-    // reverse new_specializations
-    n0 = jl_array_nrows(new_specializations);
-    jl_value_t **news = jl_array_data(new_specializations, jl_value_t*);
+    // reverse new_ext_cis
+    n0 = jl_array_nrows(new_ext_cis);
+    jl_value_t **news = jl_array_data(new_ext_cis, jl_value_t*);
     for (i = 0; i < n0; i++) {
         jl_value_t *temp = news[i];
         news[i] = news[n0 - i - 1];
         news[n0 - i - 1] = temp;
     }
-    return new_specializations;
+    return new_ext_cis;
 }
 
 // New roots for external methods
-static void jl_collect_new_roots(jl_array_t *roots, jl_array_t *new_specializations, uint64_t key)
+static void jl_collect_new_roots(jl_array_t *roots, jl_array_t *new_ext_cis, uint64_t key)
 {
     htable_t mset;
     htable_new(&mset, 0);
-    size_t l = new_specializations ? jl_array_nrows(new_specializations) : 0;
+    size_t l = new_ext_cis ? jl_array_nrows(new_ext_cis) : 0;
     for (size_t i = 0; i < l; i++) {
-        jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(new_specializations, i);
+        jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(new_ext_cis, i);
         assert(jl_is_code_instance(ci));
         jl_method_t *m = ci->def->def.method;
         assert(jl_is_method(m));
@@ -1103,29 +1103,29 @@ static void jl_verify_graph(jl_array_t *edges, jl_array_t *maxvalids2)
 // Restore backedges to external targets
 // `edges` = [caller1, targets_indexes1, ...], the list of worklist-owned methods calling external methods.
 // `ext_targets` is [invokesig1, callee1, matches1, ...], the global set of non-worklist callees of worklist-owned methods.
-static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_array_t *ci_list, size_t minworld)
+static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_array_t *ext_ci_list, size_t minworld)
 {
     // determine which CodeInstance objects are still valid in our image
     jl_array_t *valids = jl_verify_edges(ext_targets, minworld);
     JL_GC_PUSH1(&valids);
     valids = jl_verify_methods(edges, valids); // consumes edges valids, initializes methods valids
     jl_verify_graph(edges, valids); // propagates methods valids for each edge
-    size_t i, l;
+
+    size_t n_ext_cis = ext_ci_list ? jl_array_nrows(ext_ci_list) : 0;
+    htable_t cis_pending_validation;
+    htable_new(&cis_pending_validation, n_ext_cis);
 
     // next build a map from external MethodInstances to their CodeInstance for insertion
-    l = jl_array_nrows(ci_list);
-    htable_t visited;
-    htable_new(&visited, l);
-    for (i = 0; i < l; i++) {
-        jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(ci_list, i);
+    for (size_t i = 0; i < n_ext_cis; i++) {
+        jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(ext_ci_list, i);
         assert(ci->min_world == minworld);
-        if (ci->max_world == 1) { // sentinel value: has edges to external callables
-            ptrhash_put(&visited, (void*)ci->def, (void*)ci);
+        if (ci->max_world == WORLD_AGE_REVALIDATION_SENTINEL) {
+            ptrhash_put(&cis_pending_validation, (void*)ci->def, (void*)ci);
         }
         else {
             assert(ci->max_world == ~(size_t)0);
             jl_method_instance_t *caller = ci->def;
-            if (jl_atomic_load_relaxed(&ci->inferred)  && jl_rettype_inferred(caller, minworld, ~(size_t)0) == jl_nothing) {
+            if (jl_atomic_load_relaxed(&ci->inferred) && jl_rettype_inferred(caller, minworld, ~(size_t)0) == jl_nothing) {
                 jl_mi_cache_insert(caller, ci);
             }
             //jl_static_show((jl_stream*)ios_stderr, (jl_value_t*)caller);
@@ -1134,8 +1134,8 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
     }
 
     // next enable any applicable new codes
-    l = jl_array_nrows(edges) / 2;
-    for (i = 0; i < l; i++) {
+    size_t nedges = jl_array_nrows(edges) / 2;
+    for (size_t i = 0; i < nedges; i++) {
         jl_method_instance_t *caller = (jl_method_instance_t*)jl_array_ptr_ref(edges, 2 * i);
         size_t maxvalid = jl_array_data(valids, size_t)[i];
         if (maxvalid == ~(size_t)0) {
@@ -1162,21 +1162,35 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
             }
         }
         // then enable any methods associated with it
-        void *ci = ptrhash_get(&visited, (void*)caller);
+        void *ci = ptrhash_get(&cis_pending_validation, (void*)caller);
         //assert(ci != HT_NOTFOUND);
         if (ci != HT_NOTFOUND) {
-            // have some new external code to use
+            // Update any external CIs and add them to the cache.
             assert(jl_is_code_instance(ci));
             jl_code_instance_t *codeinst = (jl_code_instance_t*)ci;
             assert(codeinst->min_world == minworld && jl_atomic_load_relaxed(&codeinst->inferred) );
             codeinst->max_world = maxvalid;
-            if (jl_rettype_inferred(caller, minworld, maxvalid) == jl_nothing) {
-                jl_mi_cache_insert(caller, codeinst);
+
+            if (jl_rettype_inferred(caller, minworld, maxvalid) != jl_nothing) {
+                // We already got a code instance for this world age range from somewhere else - we don't need
+                // this one.
+                continue;
+            }
+
+            jl_mi_cache_insert(caller, codeinst);
+        } else {
+            // Likely internal. Find the CI already in the cache hierarchy.
+            for (jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&caller->cache); codeinst; codeinst=jl_atomic_load_relaxed(&codeinst->next)) {
+                if (codeinst->min_world != minworld)
+                    continue;
+                if (codeinst->max_world != WORLD_AGE_REVALIDATION_SENTINEL)
+                    continue;
+                codeinst->max_world = maxvalid;
             }
         }
     }
+    htable_free(&cis_pending_validation);
 
-    htable_free(&visited);
     JL_GC_POP();
 }
 
diff --git a/test/precompile.jl b/test/precompile.jl
index d87e86ab4911c..8a6b81e1aa96e 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1798,10 +1798,10 @@ precompile_test_harness("PkgCacheInspector") do load_path
         sv = ccall(:jl_restore_incremental, Any, (Cstring, Any, Cint, Cstring), cachefile, depmods, true, "PCI")
     end
 
-    modules, init_order, external_methods, new_specializations, new_method_roots, external_targets, edges = sv
+    modules, init_order, external_methods, new_ext_cis, new_method_roots, external_targets, edges = sv
     m = only(external_methods)
     @test m.name == :repl_cmd && m.nargs < 2
-    @test any(new_specializations) do ci
+    @test new_ext_cis === nothing || any(new_ext_cis) do ci
         mi = ci.def
         mi.specTypes == Tuple{typeof(Base.repl_cmd), Int, String}
     end

From 314d40f1bf956dd49521be20ad48a449c3da6808 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 12 Jan 2024 15:18:39 +0100
Subject: [PATCH 0616/1315] ir: Don't accidentally consider pending statements
 from previous block (#52863)

When IncremetnalCompact deletes and edge between blocks, it needs to go
to the target and delete any reference to the edge from the PhiNodes
therein. What happened in #52858, is that we had a situtation like:

```
# Block n-1
%a Expr(...)
Expr(...) # <- This node is pending at the start of compaction
# Block n
%b PhiNode
```

To do the deletion, we use `CompactPeekIterator`, which gets a list of
original statements and iterates over all the statements inside the
range, including pending ones. However, there is a semantic confusion
about whether to include all all statements since the previous statement
(%a above), or only those statements that are actually attached to the
first instruction (%b above). This of course doesn't really matter
usually unless you're at a BasicBlock boundary.

For the present case, we really do not want the instructions in the
previous basic block - the iteration of PhiNodes terminates if it seems
a stmt that cannot be in the phi block, so mistakenly seeing one of
those instructions causes it to fail to fix a PhiNode that it should
have, causing #52858.

We fix #52858 by giving the CompactPeekIterator a flag to only return
stmts in the correct basic block. While we're at it, also fix the
condition for what kinds of statements are allowed in the phi block, as
that was clarified more recently than this code was written.
---
 base/compiler/ssair/ir.jl | 24 +++++++++++++++++++-----
 test/compiler/irpasses.jl | 24 ++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 5 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 8029f6c57fb83..759997feb04da 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1340,8 +1340,8 @@ function kill_edge!(compact::IncrementalCompact, active_bb::Int, from::Int, to::
         else
             stmts = compact.ir.cfg.blocks[to].stmts
             for stmt in CompactPeekIterator(compact, first(stmts), last(stmts))
-                stmt === nothing && continue
-                isa(stmt, PhiNode) || break
+                is_valid_phiblock_stmt(stmt) || break
+                isa(stmt, PhiNode) || continue
                 i = findfirst(x::Int32->x==from, stmt.edges)
                 if i !== nothing
                     deleteat!(stmt.edges, i)
@@ -1684,13 +1684,27 @@ struct CompactPeekIterator
     compact::IncrementalCompact
     start_idx::Int
     end_idx::Int
+    include_stmts_before_start::Bool
 end
+CompactPeekIterator(compact::IncrementalCompact, start_idx::Int, end_idx::Int) =
+    CompactPeekIterator(compact, start_idx, end_idx, false)
+
 
 function CompactPeekIterator(compact::IncrementalCompact, start_idx::Int)
     return CompactPeekIterator(compact, start_idx, 0)
 end
 
-entry_at_idx(entry::NewNodeInfo, idx::Int) = entry.attach_after ? entry.pos == idx - 1 : entry.pos == idx
+function entry_at_idx(entry::NewNodeInfo, idx::Int, start_idx::Int, include_stmts_before_start::Bool)
+    if entry.attach_after
+        if !include_stmts_before_start
+            entry.pos >= start_idx || return false
+        end
+        return entry.pos == idx - 1
+    else
+        return entry.pos == idx
+    end
+end
+
 function iterate(it::CompactPeekIterator, (idx, aidx, bidx)::NTuple{3, Int}=(it.start_idx, it.compact.new_nodes_idx, 1))
     if it.end_idx > 0 && idx > it.end_idx
         return nothing
@@ -1702,7 +1716,7 @@ function iterate(it::CompactPeekIterator, (idx, aidx, bidx)::NTuple{3, Int}=(it.
     if compact.new_nodes_idx <= length(compact.perm)
         new_nodes = compact.ir.new_nodes
         for eidx in aidx:length(compact.perm)
-            if entry_at_idx(new_nodes.info[compact.perm[eidx]], idx)
+            if entry_at_idx(new_nodes.info[compact.perm[eidx]], idx, it.start_idx, it.include_stmts_before_start)
                 entry = new_nodes.stmts[compact.perm[eidx]]
                 return (entry[:stmt], (idx, eidx+1, bidx))
             end
@@ -1710,7 +1724,7 @@ function iterate(it::CompactPeekIterator, (idx, aidx, bidx)::NTuple{3, Int}=(it.
     end
     if !isempty(compact.pending_perm)
         for eidx in bidx:length(compact.pending_perm)
-            if entry_at_idx(compact.pending_nodes.info[compact.pending_perm[eidx]], idx)
+            if entry_at_idx(compact.pending_nodes.info[compact.pending_perm[eidx]], idx, it.start_idx, it.include_stmts_before_start)
                 entry = compact.pending_nodes.stmts[compact.pending_perm[eidx]]
                 return (entry[:stmt], (idx, aidx, eidx+1))
             end
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 43027ff740e43..4f4faf3ae6617 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1740,3 +1740,27 @@ end
     return 0
 end
 @test code_typed(f52703)[1][2] === Int
+
+# Issue #52858 - compaction gets confused by pending node
+let code = Any[
+    # Block 1
+    GotoIfNot(true, 6),
+    # Block 2
+    Expr(:call, println, 1),
+    Expr(:call, Base.inferencebarrier, true),
+    GotoIfNot(SSAValue(3), 6),
+    # Block 3
+    nothing,
+    # Block 4
+    PhiNode(Int32[1, 4, 5], Any[1, 2, 3]),
+    ReturnNode(SSAValue(6))
+]
+    ir = make_ircode(code)
+    Core.Compiler.insert_node!(ir, SSAValue(5),
+        Core.Compiler.NewInstruction(
+            Expr(:call, println, 2), Nothing, Int32(1)),
+            #= attach_after = =# true)
+    ir = Core.Compiler.compact!(ir, true)
+    @test Core.Compiler.verify_ir(ir) === nothing
+    @test count(x->isa(x, GotoIfNot), ir.stmts.stmt) == 1
+end

From 270ea64d434363624d269306de286ce6d041347b Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 12 Jan 2024 15:19:07 +0100
Subject: [PATCH 0617/1315] sroa: Relax scope assertion (#52866)

It's possible for this assertion to be violated if there's dead code in
the middle of the function. I think the best thing to do here is just to
relax the assertion to allow this particular case. Fixes #52819.
---
 base/compiler/ssair/passes.jl | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 62dd4305243ec..cee54db59f14c 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1147,7 +1147,18 @@ function (this::IntermediaryCollector)(@nospecialize(pi), @nospecialize(ssa))
 end
 
 function update_scope_mapping!(scope_mapping, bb, val)
-    @assert (scope_mapping[bb] in (val, SSAValue(0)))
+    current_mapping = scope_mapping[bb]
+    if current_mapping != SSAValue(0)
+        if val == SSAValue(0)
+            # Unreachable bbs will have SSAValue(0), but can branch into
+            # try/catch regions. We could validate with the domtree, but that's
+            # quite expensive for a debug check, so simply allow this without
+            # making any changes to mapping.
+            return
+        end
+        @assert current_mapping == val
+        return
+    end
     scope_mapping[bb] = val
 end
 

From 5b6a94da5af35a4aa91759cac2f8db7669a6ec2a Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 12 Jan 2024 15:20:44 +0100
Subject: [PATCH 0618/1315] docs: Clarify that `donotdelete` does not affect
 unreachable code (#52869)

In generally accepted compiler terminology, dead code is all code that
if removed does not affect the observable behavior of the program.
However, people sometimes use the phrase dead code to mean *unreachable*
code, which is a subset of dead code (being dead because it is never
semantically executed). If one assumes that definition, the docstring
for `donotdelete` may be confusing, as it may in fact be deleted from
the code if it is unreachable (existence or non-existence in the IR is
not ever semantically observable in Julia, so there could not be such an
intrinsic, but of course knowing that requires a deep understanding of
Julia semantics). Add an extra note to the docs to clarify this point.
---
 base/docs/basedocs.jl | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index b2d81f482b646..bc7d001a06f51 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -3312,7 +3312,7 @@ kw"atomic"
 
 This function prevents dead-code elimination (DCE) of itself and any arguments
 passed to it, but is otherwise the lightest barrier possible. In particular,
-it is not a GC safepoint, does model an observable heap effect, does not expand
+it is not a GC safepoint, does not model an observable heap effect, does not expand
 to any code itself and may be re-ordered with respect to other side effects
 (though the total number of executions may not change).
 
@@ -3330,6 +3330,14 @@ unused and delete the entire benchmark code).
     `donotdelete(1+1)`, no add instruction needs to be executed at runtime and
     the code is semantically equivalent to `donotdelete(2).`
 
+!!! note
+    This intrinsic does not affect the semantics of code that is dead because it is
+    *unreachable*. For example, the body of the function `f(x) = false && donotdelete(x)`
+    may be deleted in its entirety. The semantics of this intrinsic only guarantee that
+    *if* the intrinsic is semantically executed, then there is some program state at
+    which the value of the arguments of this intrinsic were available (in a register,
+    in memory, etc.).
+
 # Examples
 
 ```julia

From 6f7380661c70eb11858b7039a710b23564ba7606 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sat, 13 Jan 2024 02:41:42 +0600
Subject: [PATCH 0619/1315] Improve comment in toplevel.c [NFC] (#52810)

---
 src/toplevel.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/toplevel.c b/src/toplevel.c
index cb078a05d0ce4..60d5b2f6310fd 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -759,14 +759,14 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
                 if (name != NULL)
                     u = (jl_module_t*)jl_eval_global_var(import, name);
                 if (from) {
-                    // `using A: B` syntax
+                    // `using A: B` and `using A: B.c` syntax
                     jl_module_use(m, import, name);
                 }
                 else {
                     if (!jl_is_module(u))
                         jl_eval_errorf(m, "invalid using path: \"%s\" does not name a module",
                                        jl_symbol_name(name));
-                    // `using A.B` syntax
+                    // `using A` and `using A.B` syntax
                     jl_module_using(m, u);
                     if (m == jl_main_module && name == NULL) {
                         // TODO: for now, `using A` in Main also creates an explicit binding for `A`

From f14bf29a74d82a84a2a829e250cb60bed49a78e7 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 13 Jan 2024 02:57:08 +0100
Subject: [PATCH 0620/1315] sroa: Fix affinity of inserted undef check (#52864)

There is a bit of complexity here making sure that this instruction ends
up in the correct basic block because there's a fair number of corner
cases (e.g. whether we're deleting the first instruction of a basic
block or the last or both). Side-step all that by never doing the
delete-then-insert dance and instead doing regular instruction
replacement if necessary. Fixes #52857.
---
 base/compiler/ssair/passes.jl | 20 +++++++++++++-------
 test/compiler/irpasses.jl     | 14 ++++++++++++++
 2 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index cee54db59f14c..691876011b576 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1403,7 +1403,7 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
         (lifted_val, nest) = perform_lifting!(compact,
             visited_philikes, field, result_t, lifted_leaves, val, lazydomtree)
 
-        node_was_deleted = false
+        should_delete_node = false
         line = compact[SSAValue(idx)][:line]
         if lifted_val !== nothing && !⊑(𝕃ₒ, compact[SSAValue(idx)][:type], result_t)
             compact[idx] = lifted_val === nothing ? nothing : lifted_val.val
@@ -1412,9 +1412,8 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
             # Save some work in a later compaction, by inserting this into the renamer now,
             # but only do this if we didn't set the REFINED flag, to save work for irinterp
             # in revisiting only the renamings that came through *this* idx.
-            delete_inst_here!(compact)
             compact.ssa_rename[old_idx] = lifted_val === nothing ? nothing : lifted_val.val
-            node_was_deleted = true
+            should_delete_node = true
         else
             compact[idx] = lifted_val === nothing ? nothing : lifted_val.val
         end
@@ -1435,17 +1434,24 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
                 def_val = (def_val::LiftedValue).val
                 finish_phi_nest!(compact, nest)
             end
-            ni = NewInstruction(
-                Expr(:throw_undef_if_not, Symbol("##getfield##"), def_val), Nothing, line)
-            if node_was_deleted
-                insert_node_here!(compact, ni, true)
+            throw_expr = Expr(:throw_undef_if_not, Symbol("##getfield##"), def_val)
+            if should_delete_node
+                # Replace the node we already have rather than deleting/re-inserting.
+                # This way it is easier to handle BB boundary corner cases.
+                compact[SSAValue(idx)] = throw_expr
+                compact[SSAValue(idx)][:type] = Nothing
+                compact[SSAValue(idx)][:flag] = IR_FLAG_EFFECT_FREE | IR_FLAG_CONSISTENT | IR_FLAG_NOUB
+                should_delete_node = false
             else
+                ni = NewInstruction(throw_expr, Nothing, line)
                 insert_node!(compact, SSAValue(idx), ni)
             end
         else
             # val must be defined
             @assert lifted_val !== nothing
         end
+
+        should_delete_node && delete_inst_here!(compact)
     end
 
     non_dce_finish!(compact)
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 4f4faf3ae6617..34a8d81f2c646 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1764,3 +1764,17 @@ let code = Any[
     @test Core.Compiler.verify_ir(ir) === nothing
     @test count(x->isa(x, GotoIfNot), ir.stmts.stmt) == 1
 end
+
+# Issue #52857 - Affinity of sroa definedness check
+let code = Any[
+    Expr(:new, ImmutableRef{Any}),
+    GotoIfNot(Argument(1), 4),
+    Expr(:call, GlobalRef(Base, :getfield), SSAValue(1), 1), # Will throw
+    ReturnNode(1)
+]
+    ir = make_ircode(code; ssavaluetypes = Any[ImmutableRef{Any}, Any, Any, Any], slottypes=Any[Bool], verify=true)
+    ir = Core.Compiler.sroa_pass!(ir)
+    @test Core.Compiler.verify_ir(ir) === nothing
+    @test !any(iscall((ir, getfield)), ir.stmts.stmt)
+    @test length(ir.cfg.blocks[end].stmts) == 1
+end

From 893e720fe89d10f44edc1109d0dfde6e2ddc6d83 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 12 Jan 2024 21:56:22 -0500
Subject: [PATCH 0621/1315] REPLCompletions: async cache PATH scan (#52833)

---
 stdlib/REPL/src/REPLCompletions.jl  | 127 ++++++++++++++++++----------
 stdlib/REPL/test/replcompletions.jl |   7 ++
 2 files changed, 87 insertions(+), 47 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index da5d20270c5b6..40e5921820a32 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -269,6 +269,78 @@ function do_string_escape(s)
     return escape_string(s, ('\"','$'))
 end
 
+const PATH_cache_lock = Base.ReentrantLock()
+const PATH_cache = Set{String}()
+cached_PATH_string::Union{String,Nothing} = nothing
+function cached_PATH_changed()
+    global cached_PATH_string
+    @lock(PATH_cache_lock, cached_PATH_string) !== get(ENV, "PATH", nothing)
+end
+const PATH_cache_finished = Base.Condition() # used for sync in tests
+
+# caches all reachable files in PATH dirs
+function cache_PATH()
+    global cached_PATH_string
+    path = @lock PATH_cache_lock begin
+        empty!(PATH_cache)
+        cached_PATH_string = get(ENV, "PATH", nothing)
+    end
+    path isa String || return
+
+    @debug "caching PATH files" PATH=path
+    pathdirs = split(path, @static Sys.iswindows() ? ";" : ":")
+
+    t = @elapsed for pathdir in pathdirs
+        actualpath = try
+            realpath(pathdir)
+        catch ex
+            ex isa Base.IOError || rethrow()
+            # Bash doesn't expect every folder in PATH to exist, so neither shall we
+            continue
+        end
+
+        if actualpath != pathdir && in(actualpath, pathdirs)
+            # Remove paths which (after resolving links) are in the env path twice.
+            # Many distros eg. point /bin to /usr/bin but have both in the env path.
+            continue
+        end
+
+        filesinpath = try
+            readdir(pathdir)
+        catch e
+            # Bash allows dirs in PATH that can't be read, so we should as well.
+            if isa(e, Base.IOError) || isa(e, Base.ArgumentError)
+                continue
+            else
+                # We only handle IOError and ArgumentError here
+                rethrow()
+            end
+        end
+        for file in filesinpath
+            # In a perfect world, we would filter on whether the file is executable
+            # here, or even on whether the current user can execute the file in question.
+            try
+                if isfile(joinpath(pathdir, file))
+                    @lock PATH_cache_lock push!(PATH_cache, file)
+                end
+            catch e
+                # `isfile()` can throw in rare cases such as when probing a
+                # symlink that points to a file within a directory we do not
+                # have read access to.
+                if isa(e, Base.IOError)
+                    continue
+                else
+                    rethrow()
+                end
+            end
+            yield() # so startup doesn't block when -t1
+        end
+    end
+    notify(PATH_cache_finished)
+    @debug "caching PATH files took $t seconds" length(pathdirs) length(PATH_cache)
+    return PATH_cache
+end
+
 function complete_path(path::AbstractString;
                        use_envpath=false,
                        shell_escape=false,
@@ -308,54 +380,15 @@ function complete_path(path::AbstractString;
     end
 
     if use_envpath && isempty(dir)
-        # Look for files in PATH as well
-        pathdirs = split(ENV["PATH"], @static Sys.iswindows() ? ";" : ":")
-
-        for pathdir in pathdirs
-            actualpath = try
-                realpath(pathdir)
-            catch ex
-                ex isa Base.IOError || rethrow()
-                # Bash doesn't expect every folder in PATH to exist, so neither shall we
-                continue
-            end
-
-            if actualpath != pathdir && in(actualpath, pathdirs)
-                # Remove paths which (after resolving links) are in the env path twice.
-                # Many distros eg. point /bin to /usr/bin but have both in the env path.
-                continue
-            end
-
-            filesinpath = try
-                readdir(pathdir)
-            catch e
-                # Bash allows dirs in PATH that can't be read, so we should as well.
-                if isa(e, Base.IOError) || isa(e, Base.ArgumentError)
-                    continue
-                else
-                    # We only handle IOError and ArgumentError here
-                    rethrow()
-                end
-            end
-
-            for file in filesinpath
-                # In a perfect world, we would filter on whether the file is executable
-                # here, or even on whether the current user can execute the file in question.
-                try
-                    if startswith(file, prefix) && isfile(joinpath(pathdir, file))
-                        push!(matches, file)
-                    end
-                catch e
-                    # `isfile()` can throw in rare cases such as when probing a
-                    # symlink that points to a file within a directory we do not
-                    # have read access to.
-                    if isa(e, Base.IOError)
-                        continue
-                    else
-                        rethrow()
-                    end
-                end
+        # Look for files in PATH as well. These are cached in `cache_PATH` in a separate task in REPL init.
+        # If we cannot get lock because its still caching just pass over this so that initial
+        # typing isn't laggy. If the PATH string has changed since last cache re-cache it
+        cached_PATH_changed() && Base.errormonitor(Threads.@spawn REPLCompletions.cache_PATH())
+        if trylock(PATH_cache_lock)
+            for file in PATH_cache
+                startswith(file, prefix) && push!(matches, file)
             end
+            unlock(PATH_cache_lock)
         end
     end
 
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 2fe6c987de63d..dd6bf9d93b1b9 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -1147,6 +1147,11 @@ let s, c, r
             withenv("PATH" => string(path, ":", unreadable)) do
                 s = "tmp-execu"
                 c,r = test_scomplete(s)
+                # Files reachable by PATH are cached async when PATH is seen to have been changed by `complete_path`
+                # so changes are unlikely to appear in the first complete. For testing purposes we can wait for
+                # caching to finish
+                wait(REPL.REPLCompletions.PATH_cache_finished)
+                c,r = test_scomplete(s)
                 @test "tmp-executable" in c
                 @test r == 1:9
                 @test s[r] == "tmp-execu"
@@ -1175,6 +1180,8 @@ let s, c, r
             withenv("PATH" => string(tempdir(), ":", dir)) do
                 s = string("repl-completio")
                 c,r = test_scomplete(s)
+                wait(REPL.REPLCompletions.PATH_cache_finished) # wait for caching to complete
+                c,r = test_scomplete(s)
                 @test ["repl-completion"] == c
                 @test s[r] == "repl-completio"
             end

From 231fda37f0a211304a1c6b655e5f4cfdda9b2cbd Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 12 Jan 2024 23:48:30 -0500
Subject: [PATCH 0622/1315] REPL: Fix precompilation and add tests (#52783)

---
 base/loading.jl                    |  5 +++
 contrib/generate_precompile.jl     |  6 ++++
 src/gf.c                           | 41 +++++++------------------
 src/jl_exported_funcs.inc          |  1 -
 stdlib/REPL/src/REPL.jl            | 13 --------
 stdlib/REPL/src/precompile.jl      | 19 ++++++++----
 stdlib/REPL/test/precompilation.jl | 49 ++++++++++++++++++++++++++++++
 stdlib/REPL/test/runtests.jl       |  4 +++
 8 files changed, 88 insertions(+), 50 deletions(-)
 create mode 100644 stdlib/REPL/test/precompilation.jl

diff --git a/base/loading.jl b/base/loading.jl
index 2e766d211ac5d..8ea8354031c30 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1033,8 +1033,13 @@ function cache_file_entry(pkg::PkgId)
         uuid === nothing ? pkg.name : package_slug(uuid)
 end
 
+# for use during running the REPL precompilation subprocess script, given we don't
+# want it to pick up caches that already exist for other optimization levels
+const ignore_compiled_cache = PkgId[]
+
 function find_all_in_cache_path(pkg::PkgId)
     paths = String[]
+    pkg in ignore_compiled_cache && return paths
     entrypath, entryfile = cache_file_entry(pkg)
     for path in joinpath.(DEPOT_PATH, entrypath)
         isdir(path) || continue
diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index a685f28a2c735..04162ae68000e 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -50,6 +50,12 @@ precompile(Tuple{typeof(Base.hashindex), String, Int64})
 precompile(Tuple{typeof(Base.write), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
 precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Int64}, Int64})
 precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Int64}, Int64, Int64})
+precompile(Tuple{typeof(Base._typeddict), Base.Dict{String, Any}, Base.Dict{String, Any}, Vararg{Base.Dict{String, Any}}})
+precompile(Tuple{typeof(Base.promoteK), Type, Base.Dict{String, Any}, Base.Dict{String, Any}})
+precompile(Tuple{typeof(Base.promoteK), Type, Base.Dict{String, Any}})
+precompile(Tuple{typeof(Base.promoteV), Type, Base.Dict{String, Any}, Base.Dict{String, Any}})
+precompile(Tuple{typeof(Base.eval_user_input), Base.PipeEndpoint, Any, Bool})
+precompile(Tuple{typeof(Base.get), Base.PipeEndpoint, Symbol, Bool})
 
 # used by Revise.jl
 precompile(Tuple{typeof(Base.parse_cache_header), String})
diff --git a/src/gf.c b/src/gf.c
index 7dd251ff9b746..e4fcee9a8ed7f 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -2341,24 +2341,11 @@ jl_code_instance_t *jl_method_compiled(jl_method_instance_t *mi, size_t world)
 }
 
 jl_mutex_t precomp_statement_out_lock;
-ios_t f_precompile;
-JL_STREAM* s_precompile = NULL;
-
-static void init_precompile_output(void)
-{
-    const char *t = jl_options.trace_compile;
-    if (!strncmp(t, "stderr", 6)) {
-        s_precompile = JL_STDERR;
-    }
-    else {
-        if (ios_file(&f_precompile, t, 1, 1, 1, 1) == NULL)
-            jl_errorf("cannot open precompile statement file \"%s\" for writing", t);
-        s_precompile = (JL_STREAM*) &f_precompile;
-    }
-}
 
 static void record_precompile_statement(jl_method_instance_t *mi)
 {
+    static ios_t f_precompile;
+    static JL_STREAM* s_precompile = NULL;
     jl_method_t *def = mi->def.method;
     if (jl_options.trace_compile == NULL)
         return;
@@ -2367,7 +2354,15 @@ static void record_precompile_statement(jl_method_instance_t *mi)
 
     JL_LOCK(&precomp_statement_out_lock);
     if (s_precompile == NULL) {
-        init_precompile_output();
+        const char *t = jl_options.trace_compile;
+        if (!strncmp(t, "stderr", 6)) {
+            s_precompile = JL_STDERR;
+        }
+        else {
+            if (ios_file(&f_precompile, t, 1, 1, 1, 1) == NULL)
+                jl_errorf("cannot open precompile statement file \"%s\" for writing", t);
+            s_precompile = (JL_STREAM*) &f_precompile;
+        }
     }
     if (!jl_has_free_typevars(mi->specTypes)) {
         jl_printf(s_precompile, "precompile(");
@@ -2379,20 +2374,6 @@ static void record_precompile_statement(jl_method_instance_t *mi)
     JL_UNLOCK(&precomp_statement_out_lock);
 }
 
-JL_DLLEXPORT void jl_write_precompile_statement(char* statement)
-{
-    if (jl_options.trace_compile == NULL)
-        return;
-    JL_LOCK(&precomp_statement_out_lock);
-    if (s_precompile == NULL) {
-        init_precompile_output();
-    }
-    jl_printf(s_precompile, "%s\n", statement);
-    if (s_precompile != JL_STDERR)
-        ios_flush(&f_precompile);
-    JL_UNLOCK(&precomp_statement_out_lock);
-}
-
 jl_method_instance_t *jl_normalize_to_compilable_mi(jl_method_instance_t *mi JL_PROPAGATES_ROOT);
 
 jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t world)
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 8e850b47f2fe7..5f6e5169a9180 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -355,7 +355,6 @@
     XX(jl_new_typevar) \
     XX(jl_next_from_addrinfo) \
     XX(jl_normalize_to_compilable_sig) \
-    XX(jl_write_precompile_statement) \
     XX(jl_no_exc_handler) \
     XX(jl_object_id) \
     XX(jl_object_id_) \
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index 8c55883a04fb9..b300f34e32617 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -14,21 +14,8 @@ REPL.run_repl(repl)
 """
 module REPL
 
-const PRECOMPILE_STATEMENTS = Vector{String}()
-
 function __init__()
     Base.REPL_MODULE_REF[] = REPL
-    # We can encounter the situation where the sub-ordinate process used
-    # during precompilation of REPL, can load a valid cache-file.
-    # We need to replay the statements such that the parent process
-    # can also include those. See JuliaLang/julia#51532
-    if Base.JLOptions().trace_compile !== C_NULL && !isempty(PRECOMPILE_STATEMENTS)
-        for statement in PRECOMPILE_STATEMENTS
-            ccall(:jl_write_precompile_statement, Cvoid, (Cstring,), statement)
-        end
-    else
-        empty!(PRECOMPILE_STATEMENTS)
-    end
 end
 
 Base.Experimental.@optlevel 1
diff --git a/stdlib/REPL/src/precompile.jl b/stdlib/REPL/src/precompile.jl
index 97c494cb331d3..7baf55e2f57bf 100644
--- a/stdlib/REPL/src/precompile.jl
+++ b/stdlib/REPL/src/precompile.jl
@@ -78,11 +78,18 @@ generate_precompile_statements() = try
         # Collect statements from running a REPL process and replaying our REPL script
         touch(precompile_file)
         pts, ptm = open_fake_pty()
-        cmdargs = `-e 'import REPL; REPL.Terminals.is_precompiling[] = true'`
-        p = run(addenv(addenv(```$(julia_exepath()) -O0 --trace-compile=$precompile_file
-                --cpu-target=native --startup-file=no --compiled-modules=existing --color=yes -i $cmdargs```, procenv),
-                "JULIA_PKG_PRECOMPILE_AUTO" => "0"),
-            pts, pts, pts; wait=false)
+        # we don't want existing REPL caches to be used so ignore them
+        setup_cmd = """
+        push!(Base.ignore_compiled_cache, Base.PkgId(Base.UUID("3fa0cd96-eef1-5676-8a61-b3b8758bbffb"), "REPL"))
+        import REPL
+        REPL.Terminals.is_precompiling[] = true
+        """
+        p = run(
+                addenv(```$(julia_exepath()) -O0 --trace-compile=$precompile_file
+                    --cpu-target=native --startup-file=no --compiled-modules=existing
+                    --color=yes -i -e "$setup_cmd"```, procenv),
+                pts, pts, pts; wait=false
+            )
         Base.close_stdio(pts)
         # Prepare a background process to copy output from process until `pts` is closed
         output_copy = Base.BufferStream()
@@ -181,9 +188,9 @@ generate_precompile_statements() = try
             if !isexpr(ps, :call)
                 # these are typically comments
                 @debug "skipping statement because it does not parse as an expression" statement
+                delete!(statements, statement)
                 continue
             end
-            push!(REPL.PRECOMPILE_STATEMENTS, statement)
             popfirst!(ps.args) # precompile(...)
             ps.head = :tuple
             # println(ps)
diff --git a/stdlib/REPL/test/precompilation.jl b/stdlib/REPL/test/precompilation.jl
new file mode 100644
index 0000000000000..bf0c4e924a3c0
--- /dev/null
+++ b/stdlib/REPL/test/precompilation.jl
@@ -0,0 +1,49 @@
+
+## Tests that compilation in the interactive session startup are as expected
+
+using Test
+Base.include(@__MODULE__, joinpath(Sys.BINDIR, "..", "share", "julia", "test", "testhelpers", "FakePTYs.jl"))
+import .FakePTYs: open_fake_pty
+
+if !Sys.iswindows()
+    # TODO: reenable this on Windows. Without it we're not checking that Windows startup has no compilation.
+    # On Windows CI runners using `open_fake_pty` is causing:
+    # ----
+    # `stty: 'standard input': Inappropriate ioctl for device
+    # Unhandled Task ERROR: failed process: Process(`stty raw -echo onlcr -ocrnl opost`, ProcessExited(1)) [1]
+    # ----
+    @testset "No interactive startup compilation" begin
+        f, _ = mktemp()
+
+        # start an interactive session
+        cmd = `$(Base.julia_cmd()[1]) --trace-compile=$f -q --startup-file=no -i`
+        pts, ptm = open_fake_pty()
+        p = run(cmd, pts, pts, pts; wait=false)
+        Base.close_stdio(pts)
+        std = readuntil(ptm, "julia>")
+        # check for newlines instead of equality with "julia>" because color may be on
+        occursin("\n", std) && @info "There was output before the julia prompt:\n$std"
+        sleep(1) # sometimes precompiles output just after prompt appears
+        tracecompile_out = read(f, String)
+        close(ptm) # close after reading so we don't get precompiles from error shutdown
+
+        expected_precompiles = 0
+
+        n_precompiles = count(r"precompile\(", tracecompile_out)
+
+        @test n_precompiles <= expected_precompiles
+
+        if n_precompiles == 0
+            @debug "REPL: trace compile output: (none)"
+        elseif n_precompiles > expected_precompiles
+            @info "REPL: trace compile output:\n$tracecompile_out"
+        else
+            @debug "REPL: trace compile output:\n$tracecompile_out"
+        end
+        # inform if lowered
+        if expected_precompiles > 0 && (n_precompiles < expected_precompiles)
+            @info "REPL: Actual number of precompiles has dropped below expected." n_precompiles expected_precompiles
+        end
+
+    end
+end
diff --git a/stdlib/REPL/test/runtests.jl b/stdlib/REPL/test/runtests.jl
index e152677ccf7bb..d3eb6b9964981 100644
--- a/stdlib/REPL/test/runtests.jl
+++ b/stdlib/REPL/test/runtests.jl
@@ -3,6 +3,10 @@
 # Make a copy of the original environment
 original_env = copy(ENV)
 
+module PrecompilationTests
+    include("precompilation.jl")
+end
+
 module REPLTests
     include("repl.jl")
 end

From 60fdb2fc9d89bdbbb75a9615830254b3cc15354e Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Sat, 13 Jan 2024 12:20:21 +0530
Subject: [PATCH 0623/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index a04e48ba07de3..92fb15344a38c 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -165,6 +165,7 @@ mutable struct UV_cpu_info_t
     cpu_times!idle::UInt64
     cpu_times!irq::UInt64
 end
+
 """
     Sys.CPUinfo
 

From fc3d65275dda09c80ca9495bd930dbb75fc1cb61 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Sat, 13 Jan 2024 12:20:59 +0530
Subject: [PATCH 0624/1315] Update test/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 test/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index c624052fc4217..32c76bed88b0b 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -63,5 +63,5 @@ end
 
     @test repr(example_cpus[1]) == "Base.Sys.CPUinfo(\"Apple M1 Pro\", 2400, 0x000000000d913b08, 0x0000000000000000, 0x0000000005f4243c, 0x00000000352a550a, 0x0000000000000000)"
     @test repr("text/plain", example_cpus[1]) == "Apple M1 Pro: \n        speed         user         nice          sys         idle          irq\n     2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s"
-    @test repr("text/plain", example_cpus) == "4-element Vector{Base.Sys.CPUinfo}:\nApple M1 Pro: \n       speed         user         nice          sys         idle          irq\n#1  2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s\n#2  2400 MHz    2275576 s          0 s     978101 s    8962204 s          0 s\n#3  2400 MHz     403386 s          0 s     166224 s   11853624 s          0 s\n#4  2400 MHz     245859 s          0 s      97367 s   12092250 s          0 s\n"
+    @test Sys.cpu_summary(example_cpus) == "Apple M1 Pro: \n       speed         user         nice          sys         idle          irq\n#1  2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s\n#2  2400 MHz    2275576 s          0 s     978101 s    8962204 s          0 s\n#3  2400 MHz     403386 s          0 s     166224 s   11853624 s          0 s\n#4  2400 MHz     245859 s          0 s      97367 s   12092250 s          0 s\n"
 end

From 4b3722afcf1881b54d38f45cdea0ed9a383ac568 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Sat, 13 Jan 2024 12:27:20 +0530
Subject: [PATCH 0625/1315] minor fixes

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/exports.jl |  1 -
 base/sysinfo.jl | 14 ++++++++------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/base/exports.jl b/base/exports.jl
index f1b6a3ee75ff4..92525b85c7635 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1088,7 +1088,6 @@ public
     Event,
     Fix1,
     Fix2,
-    CPUinfo,
     Generator,
     ImmutableDict,
     OneTo,
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 92fb15344a38c..8d285d022606e 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -171,12 +171,12 @@ end
 
 The `CPUinfo` type is a mutable struct with the following fields:
 - `model::String`: CPU model information.
-- `speed::Int32`: CPU speed.
-- `cpu_times!user::UInt64`: Time spent in user mode. CPU state shows CPU time used by user space processes.
-- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks.
-- `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel.
-- `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used.
-- `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts.
+- `speed::Int32`: CPU speed. unit: MHz.
+- `cpu_times!user::UInt64`: Time spent in user mode. CPU state shows CPU time used by user space processes. unit: second.
+- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks.unit: second.
+- `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel. unit: second.
+- `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used. unit: second.
+- `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts. unit: second.
 """
 mutable struct CPUinfo
     model::String
@@ -192,6 +192,8 @@ CPUinfo(info::UV_cpu_info_t) = CPUinfo(unsafe_string(info.model), info.speed,
     info.cpu_times!user, info.cpu_times!nice, info.cpu_times!sys,
     info.cpu_times!idle, info.cpu_times!irq)
 
+public CPUinfo
+
 function _show_cpuinfo(io::IO, info::Sys.CPUinfo, header::Bool=true, prefix::AbstractString="    ")
     tck = SC_CLK_TCK
     if header

From e3a64e885927cc6d9bf90f74a49bf46bfe4add28 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sat, 13 Jan 2024 17:48:12 +0900
Subject: [PATCH 0626/1315] lowering: remove `QuoteNode` wrapping for captured
 variables (#52878)

Issues like #52531 were more broadly fixed by #52856. This commit
partially reverts #52596, while leaving the added tests.
---
 src/julia-syntax.scm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index c03700796e72e..855102276a6e5 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -3585,7 +3585,7 @@ f(x) = yt(x)
                   (rhs  (convert-for-type-decl rhs1 (cl-convert vt fname lam #f #f #f interp opaq (table) locals) #t lam))
                   (ex (cond (closed `(call (core setfield!)
                                            ,(if interp
-                                                `($ (call (core QuoteNode) ,var))
+                                                `($ ,var)
                                                 (capt-var-access var fname opaq))
                                            (inert contents)
                                            ,rhs))

From 6dc0da43db04f9885f6781326af49ae52391d234 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Sat, 13 Jan 2024 05:30:07 -0500
Subject: [PATCH 0627/1315] show UUID as Base.UUID(...) when not imported
 (#52881)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes the problem identified in
https://github.com/JuliaLang/julia/pull/52795#issuecomment-1884000786
thanks to @IanButterworth — currently, a `UUID` displays as:
```jl
julia> Base.UUID("30b93cbd-6b28-44ea-8d3f-42a2b647d023")
UUID("30b93cbd-6b28-44ea-8d3f-42a2b647d023")
```
even if the `UUID` symbol has not been imported. It should display as a
qualified name `Base.UUID` unless `UUID` is imported (e.g. by doing
`using UUIDs`). That is, after this PR you will get
```jl
julia> Base.UUID("30b93cbd-6b28-44ea-8d3f-42a2b647d023")
Base.UUID("30b93cbd-6b28-44ea-8d3f-42a2b647d023")
```

This is a tiny patch that just uses the standard type-printing machinery
to decide how to display the `UUID` type name.
---
 base/uuid.jl | 2 +-
 test/misc.jl | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/base/uuid.jl b/base/uuid.jl
index ff4df68ddb7c8..1ed0b81b3f178 100644
--- a/base/uuid.jl
+++ b/base/uuid.jl
@@ -101,7 +101,7 @@ let groupings = [36:-1:25; 23:-1:20; 18:-1:15; 13:-1:10; 8:-1:1]
 end
 
 print(io::IO, u::UUID) = print(io, string(u))
-show(io::IO, u::UUID) = print(io, "UUID(\"", u, "\")")
+show(io::IO, u::UUID) = print(io, UUID, "(\"", u, "\")")
 
 isless(a::UUID, b::UUID) = isless(a.value, b.value)
 
diff --git a/test/misc.jl b/test/misc.jl
index 249175a0ed1d3..caa4a5fb599bf 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1300,6 +1300,11 @@ end
     @test sort([a, b]) == [b, a]
 end
 
+@testset "UUID display" begin
+    a = Base.UUID("dbd321ed-e87e-4f33-9511-65b7d01cdd55")
+    @test repr(a) == "$(Base.UUID)(\"dbd321ed-e87e-4f33-9511-65b7d01cdd55\")"
+end
+
 @testset "Libc.rand" begin
     low, high = extrema(Libc.rand(Float64) for i=1:10^4)
     # these fail with probability 2^(-10^4) ≈ 5e-3011

From 537ea4ba1ee6c32088569423120b2f90b1dd02d1 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Sat, 13 Jan 2024 07:44:09 -0500
Subject: [PATCH 0628/1315] doc: fix latex formatting in cis docstring (#52845)

---
 base/complex.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/complex.jl b/base/complex.jl
index 148bbdcf11f5e..31b4ba5d3365a 100644
--- a/base/complex.jl
+++ b/base/complex.jl
@@ -570,7 +570,7 @@ end
 """
     cis(x)
 
-More efficient method for `exp(im*x)` by using Euler's formula: ``cos(x) + i sin(x) = \\exp(i x)``.
+More efficient method for `exp(im*x)` by using Euler's formula: ``\\cos(x) + i \\sin(x) = \\exp(i x)``.
 
 See also [`cispi`](@ref), [`sincos`](@ref), [`exp`](@ref), [`angle`](@ref).
 

From 4d670fbd8bf6d85ced39fb549c199b58d482c6bd Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Sat, 13 Jan 2024 09:37:45 -0500
Subject: [PATCH 0629/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Downloads=20stdlib=20from=208a614d5=20to=20a9d274f=20(#52885?=
 =?UTF-8?q?)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Downloads
URL: https://github.com/JuliaLang/Downloads.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 8a614d5
New commit: a9d274f
Julia version: 1.11.0-DEV
Downloads version: 1.6.0(It's okay that it doesn't match)
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Downloads.jl/compare/8a614d592810b15d17885838dec61da244a12e09...a9d274ff6588cc5dbfa90e908ee34c2408bab84a

```
$ git log --oneline 8a614d5..a9d274f
a9d274f Close Multi timers atexit. Add 1.6 CI (#234)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/Downloads.version                                        | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Downloads-8a614d592810b15d17885838dec61da244a12e09.tar.gz/md5
 delete mode 100644 deps/checksums/Downloads-8a614d592810b15d17885838dec61da244a12e09.tar.gz/sha512
 create mode 100644 deps/checksums/Downloads-a9d274ff6588cc5dbfa90e908ee34c2408bab84a.tar.gz/md5
 create mode 100644 deps/checksums/Downloads-a9d274ff6588cc5dbfa90e908ee34c2408bab84a.tar.gz/sha512

diff --git a/deps/checksums/Downloads-8a614d592810b15d17885838dec61da244a12e09.tar.gz/md5 b/deps/checksums/Downloads-8a614d592810b15d17885838dec61da244a12e09.tar.gz/md5
deleted file mode 100644
index d59a1fcc37890..0000000000000
--- a/deps/checksums/Downloads-8a614d592810b15d17885838dec61da244a12e09.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-e88a4630ab5cd62b1d2a6213cd2942b8
diff --git a/deps/checksums/Downloads-8a614d592810b15d17885838dec61da244a12e09.tar.gz/sha512 b/deps/checksums/Downloads-8a614d592810b15d17885838dec61da244a12e09.tar.gz/sha512
deleted file mode 100644
index af6d2ecf264ac..0000000000000
--- a/deps/checksums/Downloads-8a614d592810b15d17885838dec61da244a12e09.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-988a20fdd50c11dd66318d00032f14ae4c8b7809b507639d9907744cfdd0cff75c299ac67f99e62c25f527de1557ea6f736ee54ef18f2c54fbee76035de88aa5
diff --git a/deps/checksums/Downloads-a9d274ff6588cc5dbfa90e908ee34c2408bab84a.tar.gz/md5 b/deps/checksums/Downloads-a9d274ff6588cc5dbfa90e908ee34c2408bab84a.tar.gz/md5
new file mode 100644
index 0000000000000..fc3bce951cafb
--- /dev/null
+++ b/deps/checksums/Downloads-a9d274ff6588cc5dbfa90e908ee34c2408bab84a.tar.gz/md5
@@ -0,0 +1 @@
+97bb33510fadec7f4cc4c718c739e9a0
diff --git a/deps/checksums/Downloads-a9d274ff6588cc5dbfa90e908ee34c2408bab84a.tar.gz/sha512 b/deps/checksums/Downloads-a9d274ff6588cc5dbfa90e908ee34c2408bab84a.tar.gz/sha512
new file mode 100644
index 0000000000000..bf2821e8252b0
--- /dev/null
+++ b/deps/checksums/Downloads-a9d274ff6588cc5dbfa90e908ee34c2408bab84a.tar.gz/sha512
@@ -0,0 +1 @@
+a362aaf762f42deebb8632a7a7980cd22b2777e8c4dc629e418580269e24a64217ad846d61acad70438cfdc190e47ba2ff7716edd4e04d8d10c1d765efce604d
diff --git a/stdlib/Downloads.version b/stdlib/Downloads.version
index c5bd4d7a0d473..7805348a4b2f5 100644
--- a/stdlib/Downloads.version
+++ b/stdlib/Downloads.version
@@ -1,4 +1,4 @@
 DOWNLOADS_BRANCH = master
-DOWNLOADS_SHA1 = 8a614d592810b15d17885838dec61da244a12e09
+DOWNLOADS_SHA1 = a9d274ff6588cc5dbfa90e908ee34c2408bab84a
 DOWNLOADS_GIT_URL := https://github.com/JuliaLang/Downloads.jl.git
 DOWNLOADS_TAR_URL = https://api.github.com/repos/JuliaLang/Downloads.jl/tarball/$1

From 8f84372f167e038bd99192a368a7e6be0adf0526 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Sat, 13 Jan 2024 21:24:09 +0530
Subject: [PATCH 0630/1315] added cpu_summary method

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 doc/src/base/base.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index bcfca2d31938e..c50557cf2aa9f 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -356,6 +356,7 @@ Base.EnvDict
 Base.ENV
 Base.Sys.STDLIB
 Base.Sys.CPU_NAME
+Base.Sys.cpu_summary
 Base.Sys.CPUinfo
 Base.Sys.JIT
 Base.Sys.cpu_info

From c3836e1b4d934ce9dfbd4e4a529840842490b1dd Mon Sep 17 00:00:00 2001
From: Mark Kittisopikul <mkitti@users.noreply.github.com>
Date: Sat, 13 Jan 2024 19:24:35 -0500
Subject: [PATCH 0631/1315] Do not hide libssp.dll.a (Windows import library)
 in private library dir (#52820)

Fix #51740

Since we are providing libssp.dll on Windows and we want to dynamically
link to it, exposing libssp.dll.a is necessary. The inconsistency is
that libjulia-codegen.so looks in build_libdir and build_private_libdir
while standard library precompilation looks in build_shlibdir and
build_private_dir.
---
 deps/csl.mk | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/deps/csl.mk b/deps/csl.mk
index aaebc8f50c053..1fb12ad394b12 100644
--- a/deps/csl.mk
+++ b/deps/csl.mk
@@ -111,6 +111,7 @@ install-csl:
 	cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libgcc.a $(build_private_libdir)/
 	cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libmsvcrt.a $(build_private_libdir)/
 	cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libssp.dll.a $(build_private_libdir)/
+	cp -a $(build_libdir)/gcc/$(BB_TRIPLET)/13/libssp.dll.a $(build_libdir)/
 endif
 endif
 ifeq ($(OS),WINNT)
@@ -120,4 +121,5 @@ uninstall-gcc-libraries:
 	-rm -f $(build_private_libdir)/libgcc.a
 	-rm -f $(build_private_libdir)/libmsvcrt.a
 	-rm -f $(build_private_libdir)/libssp.dll.a
+	-rm -f $(build_libdir)/libssp.dll.a
 endif

From cd4f44da76e78ad0472fddaa9f59e60e755d24ca Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 14 Jan 2024 07:53:21 +0530
Subject: [PATCH 0632/1315] Use `similar` in `empty` (#49958)

After this,
```julia
julia> S = StructArray{Complex{Int}}(([1,2], [3,4]))
2-element StructArray(::Vector{Int64}, ::Vector{Int64}) with eltype Complex{Int64}:
 1 + 3im
 2 + 4im

julia> empty(S)
0-element StructArray(::Vector{Int64}, ::Vector{Int64}) with eltype Complex{Int64}
```
instead of
```julia
julia> empty(S)
Complex{Int64}[]
```
This behavior matches the docstring now: "Create an empty vector similar
to `v`". Often, `similar` will fall back to creating a `Vector`, so the
current behavior will be preserved.

~I'm unsure about what test to add for this, so suggestions are
welcome.~ Test added for a `StructArray` through a new test helper
---
 base/abstractarray.jl            |  2 +-
 test/abstractarray.jl            | 13 +++++++++++
 test/testhelpers/StructArrays.jl | 39 ++++++++++++++++++++++++++++++++
 3 files changed, 53 insertions(+), 1 deletion(-)
 create mode 100644 test/testhelpers/StructArrays.jl

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index a5acf465219c2..743aca7395c91 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -881,7 +881,7 @@ julia> empty([1.0, 2.0, 3.0], String)
 String[]
 ```
 """
-empty(a::AbstractVector{T}, ::Type{U}=T) where {T,U} = Vector{U}()
+empty(a::AbstractVector{T}, ::Type{U}=T) where {T,U} = similar(a, U, 0)
 
 # like empty, but should return a mutable collection, a Vector by default
 emptymutable(a::AbstractVector{T}, ::Type{U}=T) where {T,U} = Vector{U}()
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index cb704e5bb4bc4..d1987bbe0b668 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -5,6 +5,9 @@ using Random, LinearAlgebra
 isdefined(Main, :InfiniteArrays) || @eval Main include("testhelpers/InfiniteArrays.jl")
 using .Main.InfiniteArrays
 
+isdefined(Main, :StructArrays) || @eval Main include("testhelpers/StructArrays.jl")
+using .Main.StructArrays
+
 A = rand(5,4,3)
 @testset "Bounds checking" begin
     @test checkbounds(Bool, A, 1, 1, 1) == true
@@ -1019,6 +1022,16 @@ end
     @test isempty(v)
     @test isempty(v2::Vector{Int})
     @test isempty(v3::Vector{Float64})
+
+    S = StructArrays.StructArray{Complex{Int}}((v, v))
+    for T in (Complex{Int}, ComplexF64)
+        S0 = empty(S, T)
+        @test S0 isa StructArrays.StructArray{T}
+        @test length(S0) == 0
+    end
+    S0 = empty(S, String)
+    @test S0 isa Vector{String}
+    @test length(S0) == 0
 end
 
 @testset "CartesianIndices" begin
diff --git a/test/testhelpers/StructArrays.jl b/test/testhelpers/StructArrays.jl
new file mode 100644
index 0000000000000..f03b07f4e60ad
--- /dev/null
+++ b/test/testhelpers/StructArrays.jl
@@ -0,0 +1,39 @@
+module StructArrays
+
+struct StructArray{T,N,C <: Tuple{Vararg{AbstractArray{<:Any,N}}}} <: AbstractArray{T,N}
+    components :: C
+
+    function StructArray{T,N,C}(components::C) where {T,N,C}
+        fieldcount(T) == length(components) || throw(ArgumentError("number of components incompatible with eltype"))
+        allequal(axes.(components)) || throw(ArgumentError("component arrays must have the same axes"))
+        new{T,N,C}(components)
+    end
+end
+
+function StructArray{T}(components::Tuple{Vararg{AbstractArray{<:Any,N}}}) where {T,N}
+    StructArray{T,N,typeof(components)}(components)
+end
+
+Base.size(S::StructArray) = size(S.components[1])
+Base.axes(S::StructArray) = axes(S.components[1])
+function Base.getindex(S::StructArray{T,N}, inds::Vararg{Int,N}) where {T,N}
+    vals = map(x -> x[inds...], S.components)
+    T(vals...)
+end
+function Base.setindex!(S::StructArray{T,N}, val, inds::Vararg{Int,N}) where {T,N}
+    vals = getfield.(Ref(convert(T, val)), fieldnames(T))
+    for (A,v) in zip(S.components, vals)
+        A[inds...] = v
+    end
+    S
+end
+
+isnonemptystructtype(::Type{T}) where {T} = isstructtype(T) && fieldcount(T) != 0
+
+function Base.similar(S::StructArray, ::Type{T}, dims::Tuple{Int, Vararg{Int}}) where {T}
+    isnonemptystructtype(T) || return similar(S.components[1], T, dims)
+    arrs = similar.(S.components, fieldtypes(T), Ref(dims))
+    StructArray{T}(arrs)
+end
+
+end

From 46e6f235d7288ae4797b666f2a57cf0f042934fd Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Sat, 13 Jan 2024 21:54:05 -0500
Subject: [PATCH 0633/1315] Revert inlined method signature stacktrace lookup
 code (#52754)

The fallback code that was written for #41099 is causing unintended
issues with some inlined stack frames (one previous #51405, new #52709),
since the main piece, linetable storage and lookup, was removed in
#50546. Probably better to strip it all back to how it was previously,
until it can all be revisited more fully.

Should be backported to 1.10.
---
 base/stacktraces.jl | 99 +--------------------------------------------
 1 file changed, 2 insertions(+), 97 deletions(-)

diff --git a/base/stacktraces.jl b/base/stacktraces.jl
index bb70b7ea1c099..e82fd8118b2d7 100644
--- a/base/stacktraces.jl
+++ b/base/stacktraces.jl
@@ -97,87 +97,6 @@ function hash(frame::StackFrame, h::UInt)
     return h
 end
 
-get_inlinetable(::Any) = nothing
-function get_inlinetable(mi::MethodInstance)
-    isdefined(mi, :def) && mi.def isa Method && isdefined(mi, :cache) && isdefined(mi.cache, :inferred) &&
-        mi.cache.inferred !== nothing || return nothing
-    linetable = ccall(:jl_uncompress_ir, Any, (Any, Any, Any), mi.def, mi.cache, mi.cache.inferred).linetable
-    return filter!(x -> x.inlined_at > 0, linetable)
-end
-
-get_method_instance_roots(::Any) = nothing
-function get_method_instance_roots(mi::Union{Method, MethodInstance})
-    m = mi isa MethodInstance ? mi.def : mi
-    m isa Method && isdefined(m, :roots) || return nothing
-    return filter(x -> x isa MethodInstance, m.roots)
-end
-
-function lookup_inline_frame_info(func::Symbol, file::Symbol, linenum::Int, inlinetable::Vector{Core.LineInfoNode})
-    #REPL frames and some base files lack this prefix while others have it; should fix?
-    filestripped = Symbol(lstrip(string(file), ('.', '\\', '/')))
-    linfo = nothing
-    #=
-    Some matching entries contain the MethodInstance directly.
-    Other matching entries contain only a Method or Symbol (function name); such entries
-    are located after the entry with the MethodInstance, so backtracking is required.
-    If backtracking fails, the Method or Module is stored for return, but we continue
-    the search in case a MethodInstance is found later.
-    TODO: If a backtrack has failed, do we need to backtrack again later if another Method
-    or Symbol match is found? Or can a limit on the subsequent backtracks be placed?
-    =#
-    for (i, line) in enumerate(inlinetable)
-        Base.IRShow.method_name(line) === func && line.file ∈ (file, filestripped) && line.line == linenum || continue
-        if line.method isa MethodInstance
-            linfo = line.method
-            break
-        elseif line.method isa Method || line.method isa Symbol
-            linfo = line.method isa Method ? line.method : line.module
-            # backtrack to find the matching MethodInstance, if possible
-            for j in (i - 1):-1:1
-                nextline = inlinetable[j]
-                nextline.inlined_at == line.inlined_at && Base.IRShow.method_name(line) === Base.IRShow.method_name(nextline) && line.file === nextline.file || break
-                if nextline.method isa MethodInstance
-                    linfo = nextline.method
-                    break
-                end
-            end
-        end
-    end
-    return linfo
-end
-
-function lookup_inline_frame_info(func::Symbol, file::Symbol, miroots::Vector{Any})
-    # REPL frames and some base files lack this prefix while others have it; should fix?
-    filestripped = Symbol(lstrip(string(file), ('.', '\\', '/')))
-    matches = filter(miroots) do x
-        x.def isa Method || return false
-        m = x.def::Method
-        return m.name == func && m.file ∈ (file, filestripped)
-    end
-    if length(matches) > 1
-        # ambiguous, check if method is same and return that instead
-        all_matched = true
-        for m in matches
-            all_matched = m.def.line == matches[1].def.line &&
-                m.def.module == matches[1].def.module
-            all_matched || break
-        end
-        if all_matched
-            return matches[1].def
-        end
-        # all else fails, return module if they match, or give up
-        all_matched = true
-        for m in matches
-            all_matched = m.def.module == matches[1].def.module
-            all_matched || break
-        end
-        return all_matched ? matches[1].def.module : nothing
-    elseif length(matches) == 1
-        return matches[1]
-    end
-    return nothing
-end
-
 """
     lookup(pointer::Ptr{Cvoid}) -> Vector{StackFrame}
 
@@ -189,25 +108,11 @@ Base.@constprop :none function lookup(pointer::Ptr{Cvoid})
     infos = ccall(:jl_lookup_code_address, Any, (Ptr{Cvoid}, Cint), pointer, false)::Core.SimpleVector
     pointer = convert(UInt64, pointer)
     isempty(infos) && return [StackFrame(empty_sym, empty_sym, -1, nothing, true, false, pointer)] # this is equal to UNKNOWN
-    parent_linfo = infos[end][4]
-    inlinetable = get_inlinetable(parent_linfo)
-    miroots = inlinetable === nothing ? get_method_instance_roots(parent_linfo) : nothing # fallback if linetable missing
     res = Vector{StackFrame}(undef, length(infos))
-    for i in reverse(1:length(infos))
+    for i in 1:length(infos)
         info = infos[i]::Core.SimpleVector
         @assert(length(info) == 6)
-        func = info[1]::Symbol
-        file = info[2]::Symbol
-        linenum = info[3]::Int
-        linfo = info[4]
-        if i < length(infos)
-            if inlinetable !== nothing
-                linfo = lookup_inline_frame_info(func, file, linenum, inlinetable)
-            elseif miroots !== nothing
-                linfo = lookup_inline_frame_info(func, file, miroots)
-            end
-        end
-        res[i] = StackFrame(func, file, linenum, linfo, info[5]::Bool, info[6]::Bool, pointer)
+        res[i] = StackFrame(info[1]::Symbol, info[2]::Symbol, info[3]::Int, info[4], info[5]::Bool, info[6]::Bool, pointer)
     end
     return res
 end

From 8a69745bdcb06409ab7e4fc84718f34d7d54a7f9 Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Sun, 14 Jan 2024 09:39:14 +0100
Subject: [PATCH 0634/1315] Add compat note to @lock (#52894)

Fixes #52879.

CC @IanButterworth
---
 base/lock.jl | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/base/lock.jl b/base/lock.jl
index e3a8463578074..73722050699ee 100644
--- a/base/lock.jl
+++ b/base/lock.jl
@@ -260,6 +260,9 @@ end
 ```
 This is similar to using [`lock`](@ref) with a `do` block, but avoids creating a closure
 and thus can improve the performance.
+
+!!! compat
+    `@lock` was added in Julia 1.3, and exported in Julia 1.10.
 """
 macro lock(l, expr)
     quote

From a034aa130d859cbdd8d1d5c78963a42e0f0bfda4 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Sun, 14 Jan 2024 03:42:02 -0500
Subject: [PATCH 0635/1315] domtree: Optimize `DFS!` allocations (#52880)

Since `DFS!` is a decent fraction of the work for updating the domtree,
this should be a noticeable improvement to semi-concrete eval for very
large functions.

Profiling downstream shows a lot of time spent `push!`ing into the
worklist and creating temporary arrays.
---
 base/compiler/ssair/domtree.jl | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/base/compiler/ssair/domtree.jl b/base/compiler/ssair/domtree.jl
index 934cd456dd945..dfe0550d7a06d 100644
--- a/base/compiler/ssair/domtree.jl
+++ b/base/compiler/ssair/domtree.jl
@@ -82,6 +82,8 @@ struct DFSTree
     # (preorder number -> preorder number)
     # Storing it this way saves a few lookups in the snca_compress! algorithm
     to_parent_pre::Vector{PreNumber}
+
+    _worklist::Vector{Tuple{BBNumber, PreNumber, Bool}}
 end
 
 function DFSTree(n_blocks::Int)
@@ -89,14 +91,16 @@ function DFSTree(n_blocks::Int)
                    Vector{BBNumber}(undef, n_blocks),
                    zeros(PostNumber, n_blocks),
                    Vector{BBNumber}(undef, n_blocks),
-                   zeros(PreNumber, n_blocks))
+                   zeros(PreNumber, n_blocks),
+                   Vector{Tuple{BBNumber, PreNumber, Bool}}())
 end
 
 copy(D::DFSTree) = DFSTree(copy(D.to_pre),
                            copy(D.from_pre),
                            copy(D.to_post),
                            copy(D.from_post),
-                           copy(D.to_parent_pre))
+                           copy(D.to_parent_pre),
+                           copy(D._worklist))
 
 function copy!(dst::DFSTree, src::DFSTree)
     copy!(dst.to_pre, src.to_pre)
@@ -106,17 +110,26 @@ function copy!(dst::DFSTree, src::DFSTree)
     copy!(dst.to_parent_pre, src.to_parent_pre)
     return dst
 end
+function resize!(D::DFSTree, n::Integer)
+    resize!(D.to_pre, n)
+    resize!(D.from_pre, n)
+    resize!(D.to_post, n)
+    resize!(D.from_post, n)
+    resize!(D.to_parent_pre, n)
+end
 
 length(D::DFSTree) = length(D.from_pre)
 
 function DFS!(D::DFSTree, blocks::Vector{BasicBlock}, is_post_dominator::Bool)
-    copy!(D, DFSTree(length(blocks)))
+    resize!(D, length(blocks))
+    fill!(D.to_pre, 0)
+    to_visit = D._worklist # always starts empty
     if is_post_dominator
         # TODO: We're using -1 as the virtual exit node here. Would it make
         #       sense to actually have a real BB for the exit always?
-        to_visit = Tuple{BBNumber, PreNumber, Bool}[(-1, 0, false)]
+        push!(to_visit, (-1, 0, false))
     else
-        to_visit = Tuple{BBNumber, PreNumber, Bool}[(1, 0, false)]
+        push!(to_visit, (1, 0, false))
     end
     pre_num = is_post_dominator ? 0 : 1
     post_num = 1

From 77652fd2204573eea1a034bb255680309346b95e Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Sun, 14 Jan 2024 12:28:37 +0100
Subject: [PATCH 0636/1315] Validate more on assertion builds, and abort on
 errors (#52830)

This PR add a `jl_is_assertsbuild` function (cfr. `jl_is_debugbuild`)
for checking if this is an assertions build.
It's used in two places:

1. to enable additional validation, which currently often requires`-g2`
2. to make internal compiler errors fatal

Both these changes are intended to help PkgEval in detecting more issues
(invalid Julia IR) and make for more robust detection (a fatal signal
instead of having to grep logs for `Internal error`, which leads to
false positives).
---
 base/compiler/inferencestate.jl          |  2 +-
 base/compiler/optimize.jl                | 11 +++++++----
 base/compiler/typeinfer.jl               |  2 +-
 base/compiler/utilities.jl               |  4 ++++
 base/compiler/validation.jl              |  6 +++---
 src/codegen.cpp                          |  3 +++
 src/gf.c                                 |  3 +++
 src/jl_exported_funcs.inc                |  1 +
 src/jlapi.c                              | 13 +++++++++++++
 stdlib/InteractiveUtils/test/runtests.jl |  5 ++++-
 10 files changed, 40 insertions(+), 10 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 1961099e1d02f..2add6c631713f 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -479,7 +479,7 @@ function InferenceState(result::InferenceResult, cache_mode::UInt8, interp::Abst
     world = get_world_counter(interp)
     src = retrieve_code_info(result.linfo, world)
     src === nothing && return nothing
-    validate_code_in_debug_mode(result.linfo, src, "lowered")
+    maybe_validate_code(result.linfo, src, "lowered")
     return InferenceState(result, src, cache_mode, interp)
 end
 InferenceState(result::InferenceResult, cache_mode::Symbol, interp::AbstractInterpreter) =
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index c7d2983bced82..d170a062be499 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -186,7 +186,7 @@ function ir_to_codeinf!(opt::OptimizationState)
     (; linfo, src) = opt
     src = ir_to_codeinf!(src, opt.ir::IRCode)
     opt.ir = nothing
-    validate_code_in_debug_mode(linfo, src, "optimized")
+    maybe_validate_code(linfo, src, "optimized")
     return src
 end
 
@@ -934,8 +934,11 @@ function run_passes_ipo_safe(
     if made_changes
         @pass "compact 3" ir = compact!(ir, true)
     end
-    if JLOptions().debug_level == 2
-        @timeit "verify 3" (verify_ir(ir, true, false, optimizer_lattice(sv.inlining.interp)); verify_linetable(ir.linetable))
+    if is_asserts()
+        @timeit "verify 3" begin
+            verify_ir(ir, true, false, optimizer_lattice(sv.inlining.interp))
+            verify_linetable(ir.linetable)
+        end
     end
     @label __done__  # used by @pass
     return ir
@@ -1056,7 +1059,7 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                     ssaflags[block_end] = IR_FLAG_NOTHROW
 
                     # Verify that type-inference did its job
-                    if JLOptions().debug_level == 2
+                    if is_asserts()
                         for i = (oldidx + 1):last(sv.cfg.blocks[block].stmts)
                             @assert i in sv.unreachable
                         end
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 958993847a48e..7c9871581536a 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -581,7 +581,7 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
         end
     end
 
-    validate_code_in_debug_mode(me.linfo, me.src, "inferred")
+    maybe_validate_code(me.linfo, me.src, "inferred")
     nothing
 end
 
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index d8ca4d9551656..368395e714054 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -520,6 +520,7 @@ end
 is_root_module(m::Module) = false
 
 inlining_enabled() = (JLOptions().can_inline == 1)
+
 function coverage_enabled(m::Module)
     generating_output() && return false # don't alter caches
     cov = JLOptions().code_coverage
@@ -533,9 +534,12 @@ function coverage_enabled(m::Module)
     end
     return false
 end
+
 function inbounds_option()
     opt_check_bounds = JLOptions().check_bounds
     opt_check_bounds == 0 && return :default
     opt_check_bounds == 1 && return :on
     return :off
 end
+
+is_asserts() = ccall(:jl_is_assertsbuild, Cint, ()) == 1
diff --git a/base/compiler/validation.jl b/base/compiler/validation.jl
index 9a46a2411de13..1a78792b3d4e1 100644
--- a/base/compiler/validation.jl
+++ b/base/compiler/validation.jl
@@ -61,9 +61,8 @@ struct InvalidCodeError <: Exception
 end
 InvalidCodeError(kind::AbstractString) = InvalidCodeError(kind, nothing)
 
-function validate_code_in_debug_mode(linfo::MethodInstance, src::CodeInfo, kind::String)
-    if JLOptions().debug_level == 2
-        # this is a debug build of julia, so let's validate linfo
+function maybe_validate_code(linfo::MethodInstance, src::CodeInfo, kind::String)
+    if is_asserts()
         errors = validate_code(linfo, src)
         if !isempty(errors)
             for e in errors
@@ -75,6 +74,7 @@ function validate_code_in_debug_mode(linfo::MethodInstance, src::CodeInfo, kind:
                             linfo.def, ": ", e)
                 end
             end
+            error("")
         end
     end
 end
diff --git a/src/codegen.cpp b/src/codegen.cpp
index d9038e2c21671..824464382cd97 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -9187,6 +9187,9 @@ jl_llvm_functions_t jl_emit_code(
         jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
         jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
         jlbacktrace(); // written to STDERR_FILENO
+#ifndef JL_NDEBUG
+        abort();
+#endif
     }
 
     return decls;
diff --git a/src/gf.c b/src/gf.c
index e4fcee9a8ed7f..3c5870487ec9b 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -402,6 +402,9 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
             jlbacktrace(); // written to STDERR_FILENO
         }
         src = NULL;
+#ifndef JL_NDEBUG
+        abort();
+#endif
     }
     ct->world_age = last_age;
     ct->reentrant_timing -= 0b10;
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 5f6e5169a9180..f9587d33518a2 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -284,6 +284,7 @@
     XX(jl_is_binding_deprecated) \
     XX(jl_is_char_signed) \
     XX(jl_is_const) \
+    XX(jl_is_assertsbuild) \
     XX(jl_is_debugbuild) \
     XX(jl_is_foreign_type) \
     XX(jl_is_identifier) \
diff --git a/src/jlapi.c b/src/jlapi.c
index f75d7261acf33..bde8b4f9f1245 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -513,6 +513,19 @@ JL_DLLEXPORT int jl_is_debugbuild(void) JL_NOTSAFEPOINT
 #endif
 }
 
+/**
+ * @brief Check if Julia has been build with assertions enabled.
+ *
+ * @return Returns 1 if assertions are enabled, 0 otherwise.
+ */
+JL_DLLEXPORT int8_t jl_is_assertsbuild(void) JL_NOTSAFEPOINT {
+#ifndef JL_NDEBUG
+    return 1;
+#else
+    return 0;
+#endif
+}
+
 /**
  * @brief Check if Julia's memory debugging is enabled.
  *
diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index 1309e11280bfa..795f267ff4520 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -330,7 +330,9 @@ let _true = Ref(true), f, g, h
 end
 
 # manually generate a broken function, which will break codegen
-# and make sure Julia doesn't crash
+# and make sure Julia doesn't crash (when using a non-asserts build)
+is_asserts() = ccall(:jl_is_assertsbuild, Cint, ()) == 1
+if !is_asserts()
 @eval @noinline Base.@constprop :none f_broken_code() = 0
 let m = which(f_broken_code, ())
    let src = Base.uncompressed_ast(m)
@@ -371,6 +373,7 @@ let err = tempname(),
         rm(err)
     end
 end
+end
 
 # Issue #33163
 A33163(x; y) = x + y

From eadec438fa8a1796f072783b081de1042eaae395 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sun, 14 Jan 2024 08:50:36 -0500
Subject: [PATCH 0637/1315] REPLCompletions: PATH caching tweaks (#52893)

---
 stdlib/REPL/src/REPLCompletions.jl  | 52 +++++++++++++++++++----------
 stdlib/REPL/test/replcompletions.jl | 14 ++++++--
 2 files changed, 45 insertions(+), 21 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 40e5921820a32..06341361819c1 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -271,25 +271,34 @@ end
 
 const PATH_cache_lock = Base.ReentrantLock()
 const PATH_cache = Set{String}()
-cached_PATH_string::Union{String,Nothing} = nothing
-function cached_PATH_changed()
-    global cached_PATH_string
-    @lock(PATH_cache_lock, cached_PATH_string) !== get(ENV, "PATH", nothing)
+PATH_cache_task::Union{Task,Nothing} = nothing # used for sync in tests
+next_cache_update::Float64 = 0.0
+function maybe_spawn_cache_PATH()
+    global PATH_cache_task, next_cache_update
+    @lock PATH_cache_lock begin
+        PATH_cache_task isa Task && !istaskdone(PATH_cache_task) && return
+        time() < next_cache_update && return
+        PATH_cache_task = Threads.@spawn REPLCompletions.cache_PATH()
+        Base.errormonitor(PATH_cache_task)
+    end
 end
-const PATH_cache_finished = Base.Condition() # used for sync in tests
 
 # caches all reachable files in PATH dirs
 function cache_PATH()
-    global cached_PATH_string
-    path = @lock PATH_cache_lock begin
-        empty!(PATH_cache)
-        cached_PATH_string = get(ENV, "PATH", nothing)
-    end
+    path = get(ENV, "PATH", nothing)
     path isa String || return
 
+    global next_cache_update
+
+    # Calling empty! on PATH_cache would be annoying for async typing hints as completions would temporarily disappear.
+    # So keep track of what's added this time and at the end remove any that didn't appear this time from the global cache.
+    this_PATH_cache = Set{String}()
+
     @debug "caching PATH files" PATH=path
     pathdirs = split(path, @static Sys.iswindows() ? ";" : ":")
 
+    next_yield_time = time() + 0.01
+
     t = @elapsed for pathdir in pathdirs
         actualpath = try
             realpath(pathdir)
@@ -322,6 +331,7 @@ function cache_PATH()
             try
                 if isfile(joinpath(pathdir, file))
                     @lock PATH_cache_lock push!(PATH_cache, file)
+                    push!(this_PATH_cache, file)
                 end
             catch e
                 # `isfile()` can throw in rare cases such as when probing a
@@ -333,10 +343,18 @@ function cache_PATH()
                     rethrow()
                 end
             end
-            yield() # so startup doesn't block when -t1
+            if time() >= next_yield_time
+                yield() # to avoid blocking typing when -t1
+                next_yield_time = time() + 0.01
+            end
         end
     end
-    notify(PATH_cache_finished)
+
+    @lock PATH_cache_lock begin
+        intersect!(PATH_cache, this_PATH_cache) # remove entries from PATH_cache that weren't found this time
+        next_cache_update = time() + 10 # earliest next update can run is 10s after
+    end
+
     @debug "caching PATH files took $t seconds" length(pathdirs) length(PATH_cache)
     return PATH_cache
 end
@@ -380,15 +398,13 @@ function complete_path(path::AbstractString;
     end
 
     if use_envpath && isempty(dir)
-        # Look for files in PATH as well. These are cached in `cache_PATH` in a separate task in REPL init.
-        # If we cannot get lock because its still caching just pass over this so that initial
-        # typing isn't laggy. If the PATH string has changed since last cache re-cache it
-        cached_PATH_changed() && Base.errormonitor(Threads.@spawn REPLCompletions.cache_PATH())
-        if trylock(PATH_cache_lock)
+        # Look for files in PATH as well. These are cached in `cache_PATH` in an async task to not block typing.
+        # If we cannot get lock because its still caching just pass over this so that typing isn't laggy.
+        maybe_spawn_cache_PATH() # only spawns if enough time has passed and the previous caching task has completed
+        @lock PATH_cache_lock begin
             for file in PATH_cache
                 startswith(file, prefix) && push!(matches, file)
             end
-            unlock(PATH_cache_lock)
         end
     end
 
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index dd6bf9d93b1b9..1de42f86d2283 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -1146,11 +1146,15 @@ let s, c, r
             # PATH can also contain folders which we aren't actually allowed to read.
             withenv("PATH" => string(path, ":", unreadable)) do
                 s = "tmp-execu"
-                c,r = test_scomplete(s)
                 # Files reachable by PATH are cached async when PATH is seen to have been changed by `complete_path`
                 # so changes are unlikely to appear in the first complete. For testing purposes we can wait for
                 # caching to finish
-                wait(REPL.REPLCompletions.PATH_cache_finished)
+                @lock REPL.REPLCompletions.PATH_cache_lock begin
+                    # force the next cache update to happen immediately
+                    REPL.REPLCompletions.next_cache_update = 0
+                end
+                c,r = test_scomplete(s)
+                wait(REPL.REPLCompletions.PATH_cache_task::Task) # wait for caching to complete
                 c,r = test_scomplete(s)
                 @test "tmp-executable" in c
                 @test r == 1:9
@@ -1179,8 +1183,12 @@ let s, c, r
 
             withenv("PATH" => string(tempdir(), ":", dir)) do
                 s = string("repl-completio")
+                @lock REPL.REPLCompletions.PATH_cache_lock begin
+                    # force the next cache update to happen immediately
+                    REPL.REPLCompletions.next_cache_update = 0
+                end
                 c,r = test_scomplete(s)
-                wait(REPL.REPLCompletions.PATH_cache_finished) # wait for caching to complete
+                wait(REPL.REPLCompletions.PATH_cache_task::Task) # wait for caching to complete
                 c,r = test_scomplete(s)
                 @test ["repl-completion"] == c
                 @test s[r] == "repl-completio"

From 681816cedf610ebc2e90d2fd499a57b8d3fac83a Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 14 Jan 2024 20:33:44 +0530
Subject: [PATCH 0638/1315] [WIP] Specialize `chklapackerror` to improve error
 messages (#51645)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is an attempt at resolving
https://github.com/JuliaLang/julia/issues/46636. Since each LAPACK
function generally has a specific meaning attached to a positive error
code, this PR tries to specialize `chklapackerror` for the caller to
throw a more informative error instead of a `LAPACKException`. For
example:
```julia
julia> U = UpperTriangular([1 2; 0 0])
2×2 UpperTriangular{Int64, Matrix{Int64}}:
 1  2
 ⋅  0

julia> inv(U)
ERROR: SingularException(2)
[...]
```
Currently, I've only specialized it for `trtrs!`, but if this seems
reasonable, I'll add others.

Functions to be implemented:

- [ ] `gbtrf`
- [ ] `gbtrs`
- [ ] `gebal!`
- [ ] `gebak!`
- [ ] `gebrd!`
- [ ] `gelqf!`
- [ ] `geqlf!`
- [ ] `geqp3!`
- [ ] `geqrt!`
- [ ] `geqrt3!`
- [ ] `geqrf!`
- [ ] `gerqf!`
- [ ] `getrf!`
- [ ] `tzrzf!`
- [ ] `ormrz!`
- [ ] `gels!`
- [ ] `gesv!`
- [ ] `getrs!`
- [ ] `getri!`
- [ ] `gesvx!`
- [ ] `gelsd!`
- [ ] `gelsy!`
- [ ] `gglse!`
- [ ] `geev!`
- [ ] `gesdd!`
- [ ] `gesvd!`
- [ ] `ggsvd!`
- [ ] `ggsvd3!`
- [ ] `geevx!`
- [ ] `ggev!`
- [ ] `ggev3!`
- [ ] `gtsv!`
- [ ] `gttrf!`
- [ ] `gttrs!`
- [ ] `orglq!`
- [ ] `orgqr!`
- [ ] `orgql!`
- [ ] `orgrq!`
- [ ] `ormlq!`
- [ ] `ormqr!`
- [ ] `ormql!`
- [ ] `ormrq!`
- [ ] `gemqrt!`
- [ ] `potrs!`
- [ ] `ptsv!`
- [ ] `pttrf!`
- [ ] `pttrs!`
- [ ] `trtri!`
- [x] `trtrs!`
- [ ] `trcon!`
- [ ] `trevc!`
- [ ] `trrfs!`
- [ ] `stev!`
- [ ] `stebz!`
- [ ] `stegr!`
- [ ] `stein!`
- [ ] `syconv!`
- [ ] `sytrs!`
- [ ] `sytrs_rook!`
- [ ] `syconvf_rook!`
- [ ] `hesv!`
- [ ] `hetri!`
- [ ] `hetrs!`
- [ ] `hesv_rook!`
- [ ] `hetri_rook!`
- [ ] `hetrs_rook!`
- [ ] `sytri!`
- [ ] `sytri_rook!`
- [ ] `syconvf_rook!`
- [ ] `syev!`
- [ ] `syevr!`
- [ ] `syevd!`
- [ ] `bdsqr!`
- [ ] `bdsdc!`
- [ ] `gecon!`
- [ ] `gehrd!`
- [ ] `orghr!`
- [ ] `ormhr!`
- [ ] `hseqr!`
- [ ] `hetrd!`
- [ ] `ormtr!`
- [ ] `gees!`
- [ ] `gges!`
- [ ] `gges3!`
- [ ] `trexc!`
- [ ] `trsen!`
- [ ] `tgsen!`
- [ ] `trsyl!`
---
 stdlib/LinearAlgebra/src/lapack.jl      | 9 ++++++---
 stdlib/LinearAlgebra/test/triangular.jl | 6 +-----
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/lapack.jl b/stdlib/LinearAlgebra/src/lapack.jl
index 51dd73f517a31..a85978435bf46 100644
--- a/stdlib/LinearAlgebra/src/lapack.jl
+++ b/stdlib/LinearAlgebra/src/lapack.jl
@@ -31,16 +31,18 @@ function chkargsok(ret::BlasInt)
 end
 
 "Handle all nonzero info codes"
-function chklapackerror(ret::BlasInt)
+function chklapackerror(ret::BlasInt, f...)
     if ret == 0
         return
     elseif ret < 0
         throw(ArgumentError("invalid argument #$(-ret) to LAPACK call"))
     else # ret > 0
-        throw(LAPACKException(ret))
+        chklapackerror_positive(ret, f...)
     end
 end
 
+chklapackerror_positive(ret, f...) = throw(LAPACKException(ret))
+
 function chknonsingular(ret::BlasInt)
     if ret > 0
         throw(SingularException(ret))
@@ -3571,11 +3573,12 @@ for (trtri, trtrs, elty) in
                   uplo, trans, diag, n, size(B,2), A, max(1,stride(A,2)),
                   B, max(1,stride(B,2)), info,
                   1, 1, 1)
-            chklapackerror(info[])
+            chklapackerror(info[], trtrs!)
             B
         end
     end
 end
+chklapackerror_positive(ret, ::typeof(trtrs!)) = chknonsingular(ret)
 
 """
     trtri!(uplo, diag, A)
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index 7de1d10fe6d6c..43cafaaa74c9e 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -510,11 +510,7 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo
             @test_throws DimensionMismatch Ann'\bm
             @test_throws DimensionMismatch transpose(Ann)\bm
             if t1 == UpperTriangular || t1 == LowerTriangular
-                if elty1 === eltyB <: BlasFloat
-                    @test_throws LAPACKException ldiv!(t1(zeros(elty1, n, n)), fill(eltyB(1), n))
-                else
-                    @test_throws SingularException ldiv!(t1(zeros(elty1, n, n)), fill(eltyB(1), n))
-                end
+                @test_throws SingularException ldiv!(t1(zeros(elty1, n, n)), fill(eltyB(1), n))
             end
             @test B/A1 ≈ B/Matrix(A1)
             @test B/transpose(A1) ≈ B/transpose(Matrix(A1))

From 25c41662894d9cefe19ccb2e3c7cb7b3375120be Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Sun, 14 Jan 2024 18:00:41 -0500
Subject: [PATCH 0639/1315] add tests for undocumented symbols (#52723)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Following #52413 by @jariji and the discussion in #51174, this adds
tests to ensure that there are no undocumented *(= lacking docstrings)*
public symbols in any documented module.

Many of the tests are broken — we have a lot of undocumented exports. In
such cases I added both a `@test_broken` and a `@test` to ensure that
there are no additional regressions added in the future.

~~(This PR may have to be updated when
https://github.com/JuliaLang/julia/pull/52413#discussion_r1441068405 is
fixed, i.e. when ~~#52727~~ #52743 is merged.)~~ Has been updated.

---------

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/docs/Docs.jl                        | 28 +++++++++++++++++++++++-
 base/libc.jl                             |  5 +++++
 stdlib/Artifacts/test/runtests.jl        |  6 +++++
 stdlib/Base64/test/runtests.jl           |  7 +++++-
 stdlib/CRC32c/test/runtests.jl           |  4 ++++
 stdlib/Dates/test/runtests.jl            |  8 +++++++
 stdlib/FileWatching/test/runtests.jl     |  6 +++++
 stdlib/Future/test/runtests.jl           |  4 ++++
 stdlib/InteractiveUtils/test/runtests.jl |  6 +++++
 stdlib/LibGit2/test/runtests.jl          |  7 +++++-
 stdlib/Libdl/test/runtests.jl            |  6 +++++
 stdlib/LinearAlgebra/test/runtests.jl    |  7 ++++++
 stdlib/Logging/test/runtests.jl          |  6 +++++
 stdlib/Markdown/test/runtests.jl         |  4 ++++
 stdlib/Mmap/test/runtests.jl             |  4 ++++
 stdlib/Printf/test/runtests.jl           |  6 +++++
 stdlib/Profile/test/runtests.jl          |  6 +++++
 stdlib/REPL/src/docview.jl               | 20 -----------------
 stdlib/REPL/test/repl.jl                 |  6 +++++
 stdlib/Random/test/runtests.jl           |  4 ++++
 stdlib/Serialization/test/runtests.jl    |  6 +++++
 stdlib/SharedArrays/test/runtests.jl     |  4 ++++
 stdlib/Sockets/test/runtests.jl          |  4 ++++
 stdlib/TOML/test/runtests.jl             |  6 +++++
 stdlib/Test/test/runtests.jl             |  4 ++++
 stdlib/UUIDs/test/runtests.jl            |  4 ++++
 stdlib/Unicode/test/runtests.jl          |  4 ++++
 test/broadcast.jl                        |  6 +++++
 test/checked.jl                          |  4 ++++
 test/docs.jl                             |  6 +++++
 test/filesystem.jl                       |  6 +++++
 test/gc.jl                               |  4 ++++
 test/iterators.jl                        |  4 ++++
 test/math.jl                             |  4 ++++
 test/meta.jl                             |  4 ++++
 test/misc.jl                             | 10 +++++++++
 test/ordering.jl                         |  6 +++++
 test/sorting.jl                          |  6 +++++
 test/stacktraces.jl                      |  4 ++++
 test/sysinfo.jl                          |  6 +++++
 test/threads.jl                          |  4 ++++
 41 files changed, 233 insertions(+), 23 deletions(-)

diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index e5974d3280308..95724dc97bb73 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -650,11 +650,37 @@ function loaddocs(docs::Vector{Core.SimpleVector})
     nothing
 end
 
+# FIXME: formatdoc, parsedoc, apropos, and doc are defined here (but only doc is exported)
+# for historical reasons (#25738), but are *implemented* in REPL/src/docview.jl, while
+# apropos is *exported* by InteractiveUtils and doc is exported by Docs.  Seems
+# like a more sensible refactoring should be possible.
+
 function formatdoc end
 function parsedoc end
+
+"""
+    apropos([io::IO=stdout], pattern::Union{AbstractString,Regex})
+
+Search available docstrings for entries containing `pattern`.
+
+When `pattern` is a string, case is ignored. Results are printed to `io`.
+
+`apropos` can be called from the help mode in the REPL by wrapping the query in double quotes:
+```
+help?> "pattern"
+```
+"""
 function apropos end
-function doc end
 
+"""
+    Docs.doc(binding, sig)
+
+Return all documentation that matches both `binding` and `sig`.
+
+If `getdoc` returns a non-`nothing` result on the value of the binding, then a
+dynamic docstring is returned instead of one based on the binding itself.
+"""
+function doc end
 
 """
     Docs.hasdoc(mod::Module, sym::Symbol)::Bool
diff --git a/base/libc.jl b/base/libc.jl
index 1fcf763e4e124..359ca6a7f8c31 100644
--- a/base/libc.jl
+++ b/base/libc.jl
@@ -45,6 +45,11 @@ show(io::IO, fd::RawFD) = print(io, "RawFD(", bitcast(UInt32, fd), ')')  # avoid
 
 # Wrapper for an OS file descriptor (for Windows)
 if Sys.iswindows()
+    @doc """
+        WindowsRawSocket
+
+    Primitive type which wraps the native Windows file `HANDLE`.
+    """
     primitive type WindowsRawSocket sizeof(Ptr) * 8 end # On Windows file descriptors are HANDLE's and 64-bit on 64-bit Windows
     WindowsRawSocket(handle::Ptr{Cvoid}) = bitcast(WindowsRawSocket, handle)
     WindowsRawSocket(handle::WindowsRawSocket) = handle
diff --git a/stdlib/Artifacts/test/runtests.jl b/stdlib/Artifacts/test/runtests.jl
index db0d5d4c53ab1..2255930baf8e4 100644
--- a/stdlib/Artifacts/test/runtests.jl
+++ b/stdlib/Artifacts/test/runtests.jl
@@ -261,3 +261,9 @@ end
     @test length(Base.manifest_names) == 2n # there are two manifest names per project name
     @test length(Base.preferences_names) == n
 end
+
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(Artifacts)
+    @test_broken isempty(undoc)
+    @test undoc == [:Artifacts]
+end
diff --git a/stdlib/Base64/test/runtests.jl b/stdlib/Base64/test/runtests.jl
index 11d0a3cca4348..145576f6ea3f4 100644
--- a/stdlib/Base64/test/runtests.jl
+++ b/stdlib/Base64/test/runtests.jl
@@ -1,7 +1,8 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Test, Random
-import Base64:
+using Base64:
+    Base64,
     Base64EncodePipe,
     base64encode,
     Base64DecodePipe,
@@ -142,3 +143,7 @@ end
         @test String(base64decode(splace(longEncodedText))) == longDecodedText
     end
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Base64))
+end
diff --git a/stdlib/CRC32c/test/runtests.jl b/stdlib/CRC32c/test/runtests.jl
index 41a7ea2ab62fa..e1bd75d0e15f6 100644
--- a/stdlib/CRC32c/test/runtests.jl
+++ b/stdlib/CRC32c/test/runtests.jl
@@ -77,3 +77,7 @@ end
 crc32c_sw(io::IO, crc::UInt32=0x00000000) = crc32c_sw(io, typemax(Int64), crc)
 test_crc32c(crc32c)
 test_crc32c(crc32c_sw)
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(CRC32c))
+end
diff --git a/stdlib/Dates/test/runtests.jl b/stdlib/Dates/test/runtests.jl
index de063135427a9..7ac46bd69139c 100644
--- a/stdlib/Dates/test/runtests.jl
+++ b/stdlib/Dates/test/runtests.jl
@@ -2,8 +2,16 @@
 
 module DateTests
 
+using Test, Dates
+
 for file in readlines(joinpath(@__DIR__, "testgroups"))
     include(file * ".jl")
 end
 
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(Dates)
+    @test_broken isempty(undoc)
+    @test undoc == [:adjust]
+end
+
 end
diff --git a/stdlib/FileWatching/test/runtests.jl b/stdlib/FileWatching/test/runtests.jl
index 75b17b5f0e511..a02ed3931a349 100644
--- a/stdlib/FileWatching/test/runtests.jl
+++ b/stdlib/FileWatching/test/runtests.jl
@@ -447,4 +447,10 @@ rm(dir)
     include("pidfile.jl")
 end
 
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(FileWatching)
+    @test_broken isempty(undoc)
+    @test undoc == [:FDWatcher, :FileMonitor, :FolderMonitor, :PollingFileWatcher]
+end
+
 end # testset
diff --git a/stdlib/Future/test/runtests.jl b/stdlib/Future/test/runtests.jl
index 6deffe74d891c..6e02f17358ab3 100644
--- a/stdlib/Future/test/runtests.jl
+++ b/stdlib/Future/test/runtests.jl
@@ -2,3 +2,7 @@
 
 using Test
 using Future
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Future))
+end
diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index 795f267ff4520..cb0621516189a 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -724,3 +724,9 @@ end
 end
 
 @test Base.infer_effects(sin, (Int,)) == InteractiveUtils.@infer_effects sin(42)
+
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(InteractiveUtils)
+    @test_broken isempty(undoc)
+    @test undoc == [:InteractiveUtils]
+end
diff --git a/stdlib/LibGit2/test/runtests.jl b/stdlib/LibGit2/test/runtests.jl
index 88aea77f25671..4d2f4f9104c4e 100644
--- a/stdlib/LibGit2/test/runtests.jl
+++ b/stdlib/LibGit2/test/runtests.jl
@@ -1,6 +1,11 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-using Test
+using Test, LibGit2
+
 @testset verbose=true "LibGit2 $test" for test in eachline(joinpath(@__DIR__, "testgroups"))
     include("$test.jl")
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(LibGit2))
+end
diff --git a/stdlib/Libdl/test/runtests.jl b/stdlib/Libdl/test/runtests.jl
index e500b68dec34b..cbff36c870fe7 100644
--- a/stdlib/Libdl/test/runtests.jl
+++ b/stdlib/Libdl/test/runtests.jl
@@ -329,3 +329,9 @@ end
     lazy_name_lazy_lib = LazyLibrary(libname)
     @test dlpath(lazy_name_lazy_lib) == realpath(string(libname))
 end; end
+
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(Libdl)
+    @test_broken isempty(undoc)
+    @test undoc == [:Libdl]
+end
diff --git a/stdlib/LinearAlgebra/test/runtests.jl b/stdlib/LinearAlgebra/test/runtests.jl
index 29581313c18d5..55bc119756ce8 100644
--- a/stdlib/LinearAlgebra/test/runtests.jl
+++ b/stdlib/LinearAlgebra/test/runtests.jl
@@ -1,5 +1,12 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
+using Test, LinearAlgebra
 
 for file in readlines(joinpath(@__DIR__, "testgroups"))
     include(file * ".jl")
 end
+
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(LinearAlgebra)
+    @test_broken isempty(undoc)
+    @test undoc == [:ColumnNorm, :LAPACKException, :NoPivot, :RankDeficientException, :RowMaximum, :RowNonZero, :copy_transpose!]
+end
diff --git a/stdlib/Logging/test/runtests.jl b/stdlib/Logging/test/runtests.jl
index e7b3fbca2098d..e0fc6a0bc3770 100644
--- a/stdlib/Logging/test/runtests.jl
+++ b/stdlib/Logging/test/runtests.jl
@@ -300,4 +300,10 @@ end
     @test occursin("CustomLog2: hello", String(take!(buf)))
 end
 
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(Logging)
+    @test_broken isempty(undoc)
+    @test undoc == [:AboveMaxLevel, :BelowMinLevel]
+end
+
 end
diff --git a/stdlib/Markdown/test/runtests.jl b/stdlib/Markdown/test/runtests.jl
index 84f0868747567..116282a0bea3b 100644
--- a/stdlib/Markdown/test/runtests.jl
+++ b/stdlib/Markdown/test/runtests.jl
@@ -1293,3 +1293,7 @@ end
     # see issue #42139
     @test md"<一轮红日初升>" |> html == """<p>&lt;一轮红日初升&gt;</p>\n"""
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Markdown))
+end
diff --git a/stdlib/Mmap/test/runtests.jl b/stdlib/Mmap/test/runtests.jl
index 0b3cb0b9f1a42..ebd16a45ba0ed 100644
--- a/stdlib/Mmap/test/runtests.jl
+++ b/stdlib/Mmap/test/runtests.jl
@@ -339,3 +339,7 @@ open(file, "r+") do s
     finalize(A); A = nothing; GC.gc()
 end
 rm(file)
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Mmap))
+end
diff --git a/stdlib/Printf/test/runtests.jl b/stdlib/Printf/test/runtests.jl
index 71ec369af4ef7..a80affff37d11 100644
--- a/stdlib/Printf/test/runtests.jl
+++ b/stdlib/Printf/test/runtests.jl
@@ -1145,6 +1145,12 @@ end
     @test_throws Printf.InvalidFormatStringError Printf.Format("%z")
 end
 
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(Printf)
+    @test_broken isempty(undoc)
+    @test undoc == [:Printf]
+end
+
 # issue #52749
 @test @sprintf("%.160g", 1.38e-23) == "1.380000000000000060010582465734078799297660966782642624395399644741944111814291318296454846858978271484375e-23"
 
diff --git a/stdlib/Profile/test/runtests.jl b/stdlib/Profile/test/runtests.jl
index d7358dc20e853..169e70bfa7f36 100644
--- a/stdlib/Profile/test/runtests.jl
+++ b/stdlib/Profile/test/runtests.jl
@@ -300,3 +300,9 @@ end
 end
 
 include("allocs.jl")
+
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(Profile)
+    @test_broken isempty(undoc)
+    @test undoc == [:Allocs]
+end
diff --git a/stdlib/REPL/src/docview.jl b/stdlib/REPL/src/docview.jl
index 41f3020447090..1d5bd12cdda58 100644
--- a/stdlib/REPL/src/docview.jl
+++ b/stdlib/REPL/src/docview.jl
@@ -198,14 +198,6 @@ function insert_internal_warning(other, internal_access::Set{Pair{Module,Symbol}
     other
 end
 
-"""
-    Docs.doc(binding, sig)
-
-Return all documentation that matches both `binding` and `sig`.
-
-If `getdoc` returns a non-`nothing` result on the value of the binding, then a
-dynamic docstring is returned instead of one based on the binding itself.
-"""
 function doc(binding::Binding, sig::Type = Union{})
     if defined(binding)
         result = getdoc(resolve(binding), sig)
@@ -920,18 +912,6 @@ stripmd(x::Markdown.Footnote) = "$(stripmd(x.id)) $(stripmd(x.text))"
 stripmd(x::Markdown.Table) =
     join([join(map(stripmd, r), " ") for r in x.rows], " ")
 
-"""
-    apropos([io::IO=stdout], pattern::Union{AbstractString,Regex})
-
-Search available docstrings for entries containing `pattern`.
-
-When `pattern` is a string, case is ignored. Results are printed to `io`.
-
-`apropos` can be called from the help mode in the REPL by wrapping the query in double quotes:
-```
-help?> "pattern"
-```
-"""
 apropos(string) = apropos(stdout, string)
 apropos(io::IO, string) = apropos(io, Regex("\\Q$string", "i"))
 
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 7896b589612e3..f16ac0e07689a 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -1749,3 +1749,9 @@ let io = IOBuffer()
     seek(io, 0)
     @test countlines(io) == 2
 end
+
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(REPL)
+    @test_broken isempty(undoc)
+    @test undoc == [:AbstractREPL, :BasicREPL, :LineEditREPL, :StreamREPL]
+end
diff --git a/stdlib/Random/test/runtests.jl b/stdlib/Random/test/runtests.jl
index 61cee5c952c51..16a2f89753f3b 100644
--- a/stdlib/Random/test/runtests.jl
+++ b/stdlib/Random/test/runtests.jl
@@ -1232,3 +1232,7 @@ end
     @test xs isa Vector{Pair{Bool, Char}}
     @test length(xs) == 3
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Random))
+end
diff --git a/stdlib/Serialization/test/runtests.jl b/stdlib/Serialization/test/runtests.jl
index 46749d4375538..a7d5023e1ec51 100644
--- a/stdlib/Serialization/test/runtests.jl
+++ b/stdlib/Serialization/test/runtests.jl
@@ -655,3 +655,9 @@ end
     @test l2 == l1
     @test l2.parts === ()
 end
+
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(Serialization)
+    @test_broken isempty(undoc)
+    @test undoc == [:AbstractSerializer, :Serializer]
+end
diff --git a/stdlib/SharedArrays/test/runtests.jl b/stdlib/SharedArrays/test/runtests.jl
index 7f1bbb6891ce0..84dffafb3d92a 100644
--- a/stdlib/SharedArrays/test/runtests.jl
+++ b/stdlib/SharedArrays/test/runtests.jl
@@ -324,3 +324,7 @@ end
 @test SharedMatrix([0.1 0.2; 0.3 0.4]) == [0.1 0.2; 0.3 0.4]
 @test_throws MethodError SharedVector(rand(4,4))
 @test_throws MethodError SharedMatrix(rand(4))
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(SharedArrays))
+end
diff --git a/stdlib/Sockets/test/runtests.jl b/stdlib/Sockets/test/runtests.jl
index 02a994460afbf..2a812388d8373 100644
--- a/stdlib/Sockets/test/runtests.jl
+++ b/stdlib/Sockets/test/runtests.jl
@@ -682,3 +682,7 @@ end
 
 
 close(sockets_watchdog_timer)
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Sockets))
+end
diff --git a/stdlib/TOML/test/runtests.jl b/stdlib/TOML/test/runtests.jl
index 7376fab914636..e471068f36e7f 100644
--- a/stdlib/TOML/test/runtests.jl
+++ b/stdlib/TOML/test/runtests.jl
@@ -25,3 +25,9 @@ include("print.jl")
 include("parse.jl")
 
 @inferred TOML.parse("foo = 3")
+
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(TOML)
+    @test_broken isempty(undoc)
+    @test undoc == [:TOML]
+end
diff --git a/stdlib/Test/test/runtests.jl b/stdlib/Test/test/runtests.jl
index 1f93db2b5ed72..4f1077835c632 100644
--- a/stdlib/Test/test/runtests.jl
+++ b/stdlib/Test/test/runtests.jl
@@ -1582,3 +1582,7 @@ let
         end
     end
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Test))
+end
diff --git a/stdlib/UUIDs/test/runtests.jl b/stdlib/UUIDs/test/runtests.jl
index 1770b24b3abae..d2b9ee17f2e38 100644
--- a/stdlib/UUIDs/test/runtests.jl
+++ b/stdlib/UUIDs/test/runtests.jl
@@ -73,3 +73,7 @@ str = "22b4a8a1-e548-4eeb-9270-60426d66a48e"
 for r in rand(UInt128, 10^3)
     @test UUID(r) == UUID(string(UUID(r)))
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(UUIDs))
+end
diff --git a/stdlib/Unicode/test/runtests.jl b/stdlib/Unicode/test/runtests.jl
index 2ee7b88ae966b..7fa57508cffbf 100644
--- a/stdlib/Unicode/test/runtests.jl
+++ b/stdlib/Unicode/test/runtests.jl
@@ -534,3 +534,7 @@ isequal_normalized_naive(s1, s2; kws...) = normalize(s1; kws...) == normalize(s2
         @test !isequal_normalized("x\u0334\u0335", "x\u0335\u0334")
     end
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Unicode))
+end
diff --git a/test/broadcast.jl b/test/broadcast.jl
index 1e5752921bc93..2ae3d96b2a709 100644
--- a/test/broadcast.jl
+++ b/test/broadcast.jl
@@ -1176,6 +1176,12 @@ import Base.Broadcast: BroadcastStyle, DefaultArrayStyle
 f51129(v, x) = (1 .- (v ./ x) .^ 2)
 @test @inferred(f51129([13.0], 6.5)) == [-3.0]
 
+@testset "Docstrings" begin
+    undoc = Docs.undocumented_names(Broadcast)
+    @test_broken isempty(undoc)
+    @test undoc == [:dotview]
+end
+
 @testset "broadcast for `AbstractArray` without `CartesianIndex` support" begin
     struct BVec52775 <: AbstractVector{Int}
         a::Vector{Int}
diff --git a/test/checked.jl b/test/checked.jl
index bacda3db75dec..bbc53ddb55ed2 100644
--- a/test/checked.jl
+++ b/test/checked.jl
@@ -358,3 +358,7 @@ end
     @test checked_mul(1, 2, 3, 4, 5, 6, 7) === 5040
     @test checked_mul(1, 2, 3, 4, 5, 6, 7, 8) === 40320
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(Base.Checked))
+end
diff --git a/test/docs.jl b/test/docs.jl
index 190bcaee6adf5..4eab0dd36361d 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -1556,3 +1556,9 @@ Base.@ccallable c51586_long()::Int = 3
 
 @test docstrings_equal(@doc(c51586_short()), doc"ensure we can document ccallable functions")
 @test docstrings_equal(@doc(c51586_long()), doc"ensure we can document ccallable functions")
+
+@testset "Docs docstrings" begin
+    undoc = Docs.undocumented_names(Docs)
+    @test_broken isempty(undoc)
+    @test undoc == [Symbol("@var")]
+end
diff --git a/test/filesystem.jl b/test/filesystem.jl
index 79beea9f66ac1..c9bab69c586b3 100644
--- a/test/filesystem.jl
+++ b/test/filesystem.jl
@@ -40,3 +40,9 @@ import Base.Filesystem: S_IRUSR, S_IRGRP, S_IROTH
   @test S_IRUSR & ~S_IRGRP == S_IRUSR
   @test typeof(S_IRUSR) == typeof(S_IRGRP) == typeof(S_IROTH)
 end
+
+@testset "Base.Filesystem docstrings" begin
+  undoc = Docs.undocumented_names(Base.Filesystem)
+  @test_broken isempty(undoc)
+  @test undoc == [:File, :Filesystem, :JL_O_APPEND, :JL_O_ASYNC, :JL_O_CLOEXEC, :JL_O_CREAT, :JL_O_DIRECT, :JL_O_DIRECTORY, :JL_O_DSYNC, :JL_O_EXCL, :JL_O_FSYNC, :JL_O_LARGEFILE, :JL_O_NDELAY, :JL_O_NOATIME, :JL_O_NOCTTY, :JL_O_NOFOLLOW, :JL_O_NONBLOCK, :JL_O_PATH, :JL_O_RANDOM, :JL_O_RDONLY, :JL_O_RDWR, :JL_O_RSYNC, :JL_O_SEQUENTIAL, :JL_O_SHORT_LIVED, :JL_O_SYNC, :JL_O_TEMPORARY, :JL_O_TMPFILE, :JL_O_TRUNC, :JL_O_WRONLY, :S_IRGRP, :S_IROTH, :S_IRUSR, :S_IRWXG, :S_IRWXO, :S_IRWXU, :S_IWGRP, :S_IWOTH, :S_IWUSR, :S_IXGRP, :S_IXOTH, :S_IXUSR, :cptree, :futime, :rename, :sendfile, :unlink]
+end
diff --git a/test/gc.jl b/test/gc.jl
index 99b96a5ae1fd2..d5990582cc00a 100644
--- a/test/gc.jl
+++ b/test/gc.jl
@@ -33,3 +33,7 @@ end
     run_gctest("gc/chunks.jl")
     run_nonzero_page_utilization_test()
 end
+
+@testset "Base.GC docstrings" begin
+    @test isempty(Docs.undocumented_names(GC))
+end
diff --git a/test/iterators.jl b/test/iterators.jl
index 46e7c8b454335..74d7d61f0a496 100644
--- a/test/iterators.jl
+++ b/test/iterators.jl
@@ -1009,3 +1009,7 @@ end
 @testset "collect partition substring" begin
     @test collect(Iterators.partition(lstrip("01111", '0'), 2)) == ["11", "11"]
 end
+
+@testset "Iterators docstrings" begin
+    @test isempty(Docs.undocumented_names(Iterators))
+end
diff --git a/test/math.jl b/test/math.jl
index 248f99cebd987..f3c6dc5bb103f 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -1599,3 +1599,7 @@ end === Float64
     @test tanpi(big(1//1)) == big(0.0)
     @test cospi(big(1//1)) == big(-1.0)
 end
+
+@testset "Docstrings" begin
+    @test isempty(Docs.undocumented_names(MathConstants))
+end
diff --git a/test/meta.jl b/test/meta.jl
index be0ecf0cdb827..5fb1ebc0d3647 100644
--- a/test/meta.jl
+++ b/test/meta.jl
@@ -277,3 +277,7 @@ ci = code_lowered(g, Tuple{Val{true}})[1]
                                  [], 0, 0, :propagate)[1] == Expr(:isdefined, GlobalRef(Base, :foo))
 
 end
+
+@testset "Base.Meta docstrings" begin
+    @test isempty(Docs.undocumented_names(Meta))
+end
diff --git a/test/misc.jl b/test/misc.jl
index caa4a5fb599bf..03cf59acb59a3 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1407,3 +1407,13 @@ end
     GC.gc(true); yield()
     @test in_fin[]
 end
+
+@testset "Base docstrings" begin
+    undoc = Docs.undocumented_names(Base)
+    @test_broken isempty(undoc)
+    @test undoc == [:BufferStream, :CanonicalIndexError, :CapturedException, :Filesystem, :IOServer, :InvalidStateException, :Order, :PipeEndpoint, :Sort, :TTY]
+end
+
+@testset "Base.Libc docstrings" begin
+    @test isempty(Docs.undocumented_names(Libc))
+end
diff --git a/test/ordering.jl b/test/ordering.jl
index 972d48c17b1af..3b5385b99be68 100644
--- a/test/ordering.jl
+++ b/test/ordering.jl
@@ -51,3 +51,9 @@ struct SomeOtherOrder <: Base.Order.Ordering end
 @test ord(<, abs, false, Forward) === By(abs, Lt(<))
 @test ord(<, abs, true, Forward) === ReverseOrdering(By(abs, Lt(<)))
 @test ord(<, abs, true, Reverse) === By(abs, Lt(<))
+
+@testset "Base.Order docstrings" begin
+    undoc = Docs.undocumented_names(Base.Order)
+    @test_broken isempty(undoc)
+    @test undoc == [:DirectOrdering, :ForwardOrdering, :Order, :ordtype]
+end
diff --git a/test/sorting.jl b/test/sorting.jl
index ad821e38efe55..d1875c9727a29 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -9,6 +9,12 @@ using Test
 isdefined(Main, :OffsetArrays) || @eval Main include("testhelpers/OffsetArrays.jl")
 using .Main.OffsetArrays
 
+@testset "Base.Sort docstrings" begin
+    undoc = Docs.undocumented_names(Base.Sort)
+    @test_broken isempty(undoc)
+    @test undoc == [:Algorithm, :SMALL_ALGORITHM, :SMALL_THRESHOLD, :Sort]
+end
+
 @testset "Order" begin
     @test Forward == ForwardOrdering()
     @test ReverseOrdering(Forward) == ReverseOrdering() == Reverse
diff --git a/test/stacktraces.jl b/test/stacktraces.jl
index be035e31833d3..caea8158315ff 100644
--- a/test/stacktraces.jl
+++ b/test/stacktraces.jl
@@ -268,3 +268,7 @@ struct F49231{a,b,c,d,e,f,g} end
     str = sprint(Base.show_backtrace, st, context = (:limit=>true, :stacktrace_types_limited => Ref(false), :color=>true, :displaysize=>(50,132)))
     @test contains(str, "[2] \e[0m\e[1m(::$F49231{Vector, Val{…}, Vector{…}, NTuple{…}, $Int, $Int, $Int})\e[22m\e[0m\e[1m(\e[22m\e[90ma\e[39m::\e[0m$Int, \e[90mb\e[39m::\e[0m$Int, \e[90mc\e[39m::\e[0m$Int\e[0m\e[1m)\e[22m\n\e[90m")
 end
+
+@testset "Base.StackTraces docstrings" begin
+    @test isempty(Docs.undocumented_names(StackTraces))
+end
diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index 8864e3a48efc7..4bdc9aeba48f2 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -54,3 +54,9 @@ end
         @test !isempty(Sys.username())
     end
 end
+
+@testset "Base.Sys docstrings" begin
+    undoc = Docs.undocumented_names(Sys)
+    @test_broken isempty(undoc)
+    @test undoc == [:CPU_NAME, :JIT, :cpu_info, :cpu_summary]
+end
diff --git a/test/threads.jl b/test/threads.jl
index ad09304bbd80d..307742a4c292b 100644
--- a/test/threads.jl
+++ b/test/threads.jl
@@ -337,3 +337,7 @@ end
     # There must be at least two: one for the root test task and one for the async task:
     @test fetch(@async(@ccall(jl_get_num_stack_mappings()::Cint))) >= 2
 end
+
+@testset "Base.Threads docstrings" begin
+    @test isempty(Docs.undocumented_names(Threads))
+end

From fc6295df630603bbe4ada01f471316fb457240ae Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Mon, 15 Jan 2024 00:47:28 -0500
Subject: [PATCH 0640/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=203c86ba27e=20to=20ba4955e2e=20(#52903)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5     | 1 -
 .../Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512  | 1 -
 .../Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5     | 1 +
 .../Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512

diff --git a/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5 b/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5
deleted file mode 100644
index 3e7b0ffe63bd8..0000000000000
--- a/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-5723739fcb31b88a2e2513c05bea2952
diff --git a/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512 b/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512
deleted file mode 100644
index bb5ed6f7ae970..0000000000000
--- a/deps/checksums/Pkg-3c86ba27e904807e13beb8cb0466ed70365b0b2d.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-265e293ee24eac484f45311019c22ada29db413e783fb9e8f3eb4c94925ea79557580839a6b1e6ea655d91c198e6e62043fcfd07da025ce3e03fb2379207aca8
diff --git a/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5 b/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5
new file mode 100644
index 0000000000000..116a199728e95
--- /dev/null
+++ b/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5
@@ -0,0 +1 @@
+84c5ed6280fe8108590a4eff6ac441c0
diff --git a/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512 b/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512
new file mode 100644
index 0000000000000..0bfdf11cd0c33
--- /dev/null
+++ b/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512
@@ -0,0 +1 @@
+9e19fa5e01fdc51963e1699b318c329e0ac002757bb3ede2dbb17bda60198d3671b964f162b75b47a0afb51adbf7d94df8dc8696f01b8fe78519b31519eecb0b
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index f7b6068e3768c..1c0c3c244c168 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 3c86ba27e904807e13beb8cb0466ed70365b0b2d
+PKG_SHA1 = ba4955e2e0eb64e47861d0a7d96569c05d41f1f5
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 8d92a49ae02a58f123b1b2c5ba76521fd8896ada Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Mon, 15 Jan 2024 23:33:30 +0530
Subject: [PATCH 0641/1315] removed export of
 Sys.JIT,Sys.CPU_NAME,Sys.cpu_summary,Sys.cpu_info

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl      | 20 ++++++++++++++------
 doc/src/base/base.md |  5 -----
 test/sysinfo.jl      |  8 +++++++-
 3 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 8d285d022606e..3846969d11a22 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -109,6 +109,8 @@ A string representing the name of CPU.
 For example, `Sys.CPU_NAME` might equal `"tigerlake"` on an
 [Intel Core "Tiger Lake" CPU](https://en.wikipedia.org/wiki/Tiger_Lake),
 or `"apple-m1"` on an [Apple M1 CPU](https://en.wikipedia.org/wiki/Apple_M1).
+
+Note: Included in the detailed system information via `versioninfo(verbose=true)`.
 """
 global CPU_NAME::String
 
@@ -123,6 +125,8 @@ Currently, this equals `"ORCJIT"` for the LLVM "ORC" ("On-Request Compilation")
 julia> Sys.JIT
 "ORCJIT"
 ```
+
+Note: Included in the detailed system information via `versioninfo(verbose=true)`.
 """
 global JIT::String
 
@@ -171,12 +175,14 @@ end
 
 The `CPUinfo` type is a mutable struct with the following fields:
 - `model::String`: CPU model information.
-- `speed::Int32`: CPU speed. unit: MHz.
-- `cpu_times!user::UInt64`: Time spent in user mode. CPU state shows CPU time used by user space processes. unit: second.
-- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks.unit: second.
-- `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel. unit: second.
-- `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used. unit: second.
-- `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts. unit: second.
+- `speed::Int32`: CPU speed (in MHz).
+- `cpu_times!user::UInt64`: Time spent in user mode. CPU state shows CPU time used by user space processes.
+- `cpu_times!nice::UInt64`: Time spent in nice mode. CPU state is a subset of the "user" state and shows the CPU time used by processes that have a positive niceness, meaning a lower priority than other tasks.
+- `cpu_times!sys::UInt64`: Time spent in system mode. CPU state shows the amount of CPU time used by the kernel.
+- `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used.
+- `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts.
+
+Note: Included in the detailed system information via `versioninfo(verbose=true)`.
 """
 mutable struct CPUinfo
     model::String
@@ -254,6 +260,8 @@ providing details such as average CPU speed and total time spent in different mo
 !!! compat "Julia 1.11"
      As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g.
      `display` for REPL output), so it need not be called directly.
+
+Note: Included in the detailed system information via `versioninfo(verbose=true)`.
 """
 function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())
     model = cpu[1].model
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index c50557cf2aa9f..7172474b40b39 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -355,11 +355,6 @@ Base.@allocations
 Base.EnvDict
 Base.ENV
 Base.Sys.STDLIB
-Base.Sys.CPU_NAME
-Base.Sys.cpu_summary
-Base.Sys.CPUinfo
-Base.Sys.JIT
-Base.Sys.cpu_info
 Base.Sys.isunix
 Base.Sys.isapple
 Base.Sys.islinux
diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index 32c76bed88b0b..7b98ba34fa08b 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -55,6 +55,10 @@ end
     end
 end
 
+@testset "Base.Sys docstrings" begin
+    @test isempty(Docs.undocumented_names(Sys))
+end
+
 @testset "show" begin
     example_cpus = [Base.Sys.CPUinfo("Apple M1 Pro", 2400, 0x000000000d913b08, 0x0000000000000000, 0x0000000005f4243c, 0x00000000352a550a, 0x0000000000000000)
     Base.Sys.CPUinfo("Apple M1 Pro", 2400, 0x000000000d9040c2, 0x0000000000000000, 0x0000000005d4768c, 0x00000000356b3d22, 0x0000000000000000)
@@ -63,5 +67,7 @@ end
 
     @test repr(example_cpus[1]) == "Base.Sys.CPUinfo(\"Apple M1 Pro\", 2400, 0x000000000d913b08, 0x0000000000000000, 0x0000000005f4243c, 0x00000000352a550a, 0x0000000000000000)"
     @test repr("text/plain", example_cpus[1]) == "Apple M1 Pro: \n        speed         user         nice          sys         idle          irq\n     2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s"
-    @test Sys.cpu_summary(example_cpus) == "Apple M1 Pro: \n       speed         user         nice          sys         idle          irq\n#1  2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s\n#2  2400 MHz    2275576 s          0 s     978101 s    8962204 s          0 s\n#3  2400 MHz     403386 s          0 s     166224 s   11853624 s          0 s\n#4  2400 MHz     245859 s          0 s      97367 s   12092250 s          0 s\n"
+    buf = IOBuffer()
+    Sys.cpu_summary(buf,example_cpus)
+    @test String(take!(buf)) == "Apple M1 Pro: \n       speed         user         nice          sys         idle          irq\n#1  2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s\n#2  2400 MHz    2275576 s          0 s     978101 s    8962204 s          0 s\n#3  2400 MHz     403386 s          0 s     166224 s   11853624 s          0 s\n#4  2400 MHz     245859 s          0 s      97367 s   12092250 s          0 s\n"
 end

From 89710bf8a1914e22fe61e4e087f5ff5e97a32f02 Mon Sep 17 00:00:00 2001
From: jam-khan <jamkhan@connect.hku.hk>
Date: Mon, 15 Jan 2024 15:32:31 -0500
Subject: [PATCH 0642/1315] Add docstring for TOML stdlib module (#52834)

---
 base/docs/temp.cpp           | 0
 base/toml_parser.jl          | 5 +++++
 stdlib/TOML/src/TOML.jl      | 5 +++++
 stdlib/TOML/test/runtests.jl | 4 +---
 4 files changed, 11 insertions(+), 3 deletions(-)
 create mode 100644 base/docs/temp.cpp

diff --git a/base/docs/temp.cpp b/base/docs/temp.cpp
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/base/toml_parser.jl b/base/toml_parser.jl
index 086b7d99580c0..eb7ffda2f5940 100644
--- a/base/toml_parser.jl
+++ b/base/toml_parser.jl
@@ -1,5 +1,10 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+`Base.TOML` is an undocumented internal part of Julia's TOML parser
+implementation.  Users should call the the documented interface in the
+TOML.jl standard library instead (by `import TOML` or `using TOML`).
+"""
 module TOML
 
 using Base: IdSet
diff --git a/stdlib/TOML/src/TOML.jl b/stdlib/TOML/src/TOML.jl
index a2ea1869b4079..a94eb926f8b88 100644
--- a/stdlib/TOML/src/TOML.jl
+++ b/stdlib/TOML/src/TOML.jl
@@ -1,5 +1,10 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+TOML.jl is a Julia standard library for parsing and writing TOML v1.0 files.
+This module provides functions to parse TOML strings and files into Julia data structures
+and to serialize Julia data structures to TOML format.
+"""
 module TOML
 
 module Internals
diff --git a/stdlib/TOML/test/runtests.jl b/stdlib/TOML/test/runtests.jl
index e471068f36e7f..47c762d054711 100644
--- a/stdlib/TOML/test/runtests.jl
+++ b/stdlib/TOML/test/runtests.jl
@@ -27,7 +27,5 @@ include("parse.jl")
 @inferred TOML.parse("foo = 3")
 
 @testset "Docstrings" begin
-    undoc = Docs.undocumented_names(TOML)
-    @test_broken isempty(undoc)
-    @test undoc == [:TOML]
+    @test isempty(Docs.undocumented_names(TOML))
 end

From d4796606b136f7cba333d8da5b8961e52a5cdd15 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 16 Jan 2024 10:15:22 +0900
Subject: [PATCH 0643/1315] inference: always bail out const-prop' with
 non-const result limited (#52836)

Investigating into #52763, I've found that `AbstractInterpreters` which
enables the `aggressive_constprop` option, such as `REPLInterpreter`,
might perform const-prop' even if the result of a non-const call is
`LimitedAccuracy`. This can lead to an unintended infinite loop with a
custom aggressive const-prop' implementation.

This commit restricts const-prop' for such cases where the non-const
call result is limited to avoid the issue. This fix is conservative, but
given that accurate inference is mostly impossible when there are
unresolvable cycles (which is indicated by limited result), aggressive
const-prop' isn't necessary for such cases, and I don't anticipate this
leading to any obvious regression.

fix #52763
---
 base/compiler/abstractinterpretation.jl | 56 +++++++++++++------------
 test/compiler/inference.jl              | 13 +++++-
 2 files changed, 42 insertions(+), 27 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 1c075fd4d8a25..b492d07f4ba3a 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -814,12 +814,7 @@ end
 function abstract_call_method_with_const_args(interp::AbstractInterpreter,
     result::MethodCallResult, @nospecialize(f), arginfo::ArgInfo, si::StmtInfo,
     match::MethodMatch, sv::AbsIntState, invokecall::Union{Nothing,InvokeCall}=nothing)
-
-    if !const_prop_enabled(interp, sv, match)
-        return nothing
-    end
-    if bail_out_const_call(interp, result, si)
-        add_remark!(interp, sv, "[constprop] No more information to be gained")
+    if !const_prop_enabled(interp, match, sv) || bail_out_const_call(interp, result, si, sv)
         return nothing
     end
     eligibility = concrete_eval_eligible(interp, f, result, arginfo, sv)
@@ -852,7 +847,7 @@ function abstract_call_method_with_const_args(interp::AbstractInterpreter,
     return const_prop_call(interp, mi, result, arginfo, sv, concrete_eval_result)
 end
 
-function const_prop_enabled(interp::AbstractInterpreter, sv::AbsIntState, match::MethodMatch)
+function const_prop_enabled(interp::AbstractInterpreter, match::MethodMatch, sv::AbsIntState)
     if !InferenceParams(interp).ipo_constant_propagation
         add_remark!(interp, sv, "[constprop] Disabled by parameter")
         return false
@@ -864,9 +859,11 @@ function const_prop_enabled(interp::AbstractInterpreter, sv::AbsIntState, match:
     return true
 end
 
-function bail_out_const_call(interp::AbstractInterpreter, result::MethodCallResult, si::StmtInfo)
+function bail_out_const_call(interp::AbstractInterpreter, result::MethodCallResult,
+                             si::StmtInfo, sv::AbsIntState)
     if is_removable_if_unused(result.effects)
         if isa(result.rt, Const) || call_result_unused(si)
+            add_remark!(interp, sv, "[constprop] No more information to be gained (const)")
             return true
         end
     elseif result.rt === Bottom
@@ -876,6 +873,7 @@ function bail_out_const_call(interp::AbstractInterpreter, result::MethodCallResu
             # precise enough to let us determine :consistency of `exct`, so we
             # would have to force constprop just to determine this, which is too
             # expensive.
+            add_remark!(interp, sv, "[constprop] No more information to be gained (bottom)")
             return true
         end
     end
@@ -974,7 +972,10 @@ function maybe_get_const_prop_profitable(interp::AbstractInterpreter,
     match::MethodMatch, sv::AbsIntState)
     method = match.method
     force = force_const_prop(interp, f, method)
-    force || const_prop_entry_heuristic(interp, result, si, sv) || return nothing
+    if !const_prop_entry_heuristic(interp, result, si, sv, force)
+        # N.B. remarks are emitted within `const_prop_entry_heuristic`
+        return nothing
+    end
     nargs::Int = method.nargs
     method.isva && (nargs -= 1)
     length(arginfo.argtypes) < nargs && return nothing
@@ -1001,8 +1002,17 @@ function maybe_get_const_prop_profitable(interp::AbstractInterpreter,
     return mi
 end
 
-function const_prop_entry_heuristic(interp::AbstractInterpreter, result::MethodCallResult, si::StmtInfo, sv::AbsIntState)
-    if call_result_unused(si) && result.edgecycle
+function const_prop_entry_heuristic(interp::AbstractInterpreter, result::MethodCallResult,
+                                    si::StmtInfo, sv::AbsIntState, force::Bool)
+    if result.rt isa LimitedAccuracy
+        # optimizations like inlining are disabled for limited frames,
+        # thus there won't be much benefit in constant-prop' here
+        # N.B. don't allow forced constprop' for safety (xref #52763)
+        add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (limited accuracy)")
+        return false
+    elseif force
+        return true
+    elseif call_result_unused(si) && result.edgecycle
         add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (edgecycle with unused result)")
         return false
     end
@@ -1015,27 +1025,21 @@ function const_prop_entry_heuristic(interp::AbstractInterpreter, result::MethodC
         if rt === Bottom
             add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (erroneous result)")
             return false
-        else
-            return true
         end
+        return true
     elseif isa(rt, PartialStruct) || isa(rt, InterConditional) || isa(rt, InterMustAlias)
         # could be improved to `Const` or a more precise wrapper
         return true
-    elseif isa(rt, LimitedAccuracy)
-        # optimizations like inlining are disabled for limited frames,
-        # thus there won't be much benefit in constant-prop' here
-        add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (limited accuracy)")
-        return false
-    else
-        if isa(rt, Const)
-            if !is_nothrow(result.effects)
-                # Could still be improved to Bottom (or at least could see the effects improved)
-                return true
-            end
+    elseif isa(rt, Const)
+        if is_nothrow(result.effects)
+            add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (nothrow const)")
+            return false
         end
-        add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (unimprovable result)")
-        return false
+        # Could still be improved to Bottom (or at least could see the effects improved)
+        return true
     end
+    add_remark!(interp, sv, "[constprop] Disabled by entry heuristic (unimprovable result)")
+    return false
 end
 
 # determines heuristically whether if constant propagation can be worthwhile
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index a2900fbda01ba..a797467ff6173 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -4937,10 +4937,21 @@ g() = empty_nt_values(Base.inferencebarrier(Tuple{}))
 # This is somewhat sensitive to the exact recursion level that inference is willing to do, but the intention
 # is to test the case where inference limited a recursion, but then a forced constprop nevertheless managed
 # to terminate the call.
+@newinterp RecurseInterpreter
+let CC = Core.Compiler
+    function CC.const_prop_entry_heuristic(interp::RecurseInterpreter, result::CC.MethodCallResult,
+                                           si::CC.StmtInfo, sv::CC.AbsIntState, force::Bool)
+        if result.rt isa CC.LimitedAccuracy
+            return force # allow forced constprop to recurse into unresolved cycles
+        end
+        return @invoke CC.const_prop_entry_heuristic(interp::CC.AbstractInterpreter, result::CC.MethodCallResult,
+                                                     si::CC.StmtInfo, sv::CC.AbsIntState, force::Bool)
+    end
+end
 Base.@constprop :aggressive type_level_recurse1(x...) = x[1] == 2 ? 1 : (length(x) > 100 ? x : type_level_recurse2(x[1] + 1, x..., x...))
 Base.@constprop :aggressive type_level_recurse2(x...) = type_level_recurse1(x...)
 type_level_recurse_entry() = Val{type_level_recurse1(1)}()
-@test Base.return_types(type_level_recurse_entry, ()) |> only == Val{1}
+@test Base.infer_return_type(type_level_recurse_entry, (); interp=RecurseInterpreter()) == Val{1}
 
 # Test that inference doesn't give up if it can potentially refine effects,
 # even if the return type is Any.

From b058146cafec8405aa07f9647642fd485ea3b5d7 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 16 Jan 2024 10:18:01 +0900
Subject: [PATCH 0644/1315] add `:import`/`:using`/`:export` heads to
 `VALID_EXPR_HEADS` (#52906)

Typically, top-level thunks that include these exprs aren't compiled.
However, in certain `AbstractInterpreter`s such as JET, there's a need
to perform inference on arbitrary top-level thunks for analysis
purposes. So this commit updates the IR validator so that it does not
raise errors on these exprs.
---
 base/compiler/validation.jl | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/base/compiler/validation.jl b/base/compiler/validation.jl
index 1a78792b3d4e1..fe3d002a43d6e 100644
--- a/base/compiler/validation.jl
+++ b/base/compiler/validation.jl
@@ -34,7 +34,10 @@ const VALID_EXPR_HEADS = IdDict{Symbol,UnitRange{Int}}(
     :throw_undef_if_not => 2:2,
     :aliasscope => 0:0,
     :popaliasscope => 0:0,
-    :new_opaque_closure => 4:typemax(Int)
+    :new_opaque_closure => 4:typemax(Int),
+    :import => 1:typemax(Int),
+    :using => 1:typemax(Int),
+    :export => 1:typemax(Int),
 )
 
 # @enum isn't defined yet, otherwise I'd use it for this

From 3309d862e59b2fc39e15b72c4fff491d1827d2ff Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Tue, 16 Jan 2024 19:54:13 +0530
Subject: [PATCH 0645/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 3846969d11a22..519c38406b9e5 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -257,10 +257,6 @@ describing a set of CPUs (which defaults to the return value of the [`Sys.cpu_in
 The summary includes aggregated information for each distinct CPU model,
 providing details such as average CPU speed and total time spent in different modes (user, nice, sys, idle, irq) across all cores with the same model.
 
-!!! compat "Julia 1.11"
-     As of Julia 1.11, the `Sys.cpu_summary(io, cpu)` output is replicated by `show(io, "text/plain", cpu)` (which is called by e.g.
-     `display` for REPL output), so it need not be called directly.
-
 Note: Included in the detailed system information via `versioninfo(verbose=true)`.
 """
 function cpu_summary(io::IO=stdout, cpu::AbstractVector{CPUinfo} = cpu_info())

From 5e2cdbdcf52f3e72e942720deff61787190607b3 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Tue, 16 Jan 2024 19:54:43 +0530
Subject: [PATCH 0646/1315] Update test/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 test/sysinfo.jl | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index 7b98ba34fa08b..3efdb85eda9ee 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -67,7 +67,7 @@ end
 
     @test repr(example_cpus[1]) == "Base.Sys.CPUinfo(\"Apple M1 Pro\", 2400, 0x000000000d913b08, 0x0000000000000000, 0x0000000005f4243c, 0x00000000352a550a, 0x0000000000000000)"
     @test repr("text/plain", example_cpus[1]) == "Apple M1 Pro: \n        speed         user         nice          sys         idle          irq\n     2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s"
-    buf = IOBuffer()
-    Sys.cpu_summary(buf,example_cpus)
-    @test String(take!(buf)) == "Apple M1 Pro: \n       speed         user         nice          sys         idle          irq\n#1  2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s\n#2  2400 MHz    2275576 s          0 s     978101 s    8962204 s          0 s\n#3  2400 MHz     403386 s          0 s     166224 s   11853624 s          0 s\n#4  2400 MHz     245859 s          0 s      97367 s   12092250 s          0 s\n"
+    Sys.SC_CLK_TCK, save_SC_CLK_TCK = 100, Sys.SC_CLK_TCK
+    @test sprint(Sys.cpu_summary, example_cpus) == "Apple M1 Pro: \n       speed         user         nice          sys         idle          irq\n#1  2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s\n#2  2400 MHz    2275576 s          0 s     978101 s    8962204 s          0 s\n#3  2400 MHz     403386 s          0 s     166224 s   11853624 s          0 s\n#4  2400 MHz     245859 s          0 s      97367 s   12092250 s          0 s\n"
+    Sys.SC_CLK_TCK = save_SC_CLK_TCK
 end

From 06f5a4c081c616d5b5b8f19e5d383334b24dc7af Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Tue, 16 Jan 2024 19:55:18 +0530
Subject: [PATCH 0647/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 519c38406b9e5..9c094b91bfdd5 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -182,6 +182,9 @@ The `CPUinfo` type is a mutable struct with the following fields:
 - `cpu_times!idle::UInt64`: Time spent in idle mode. CPU state shows the CPU time that's not actively being used.
 - `cpu_times!irq::UInt64`: Time spent handling interrupts. CPU state shows the amount of time the CPU has been servicing hardware interrupts.
 
+The times are in units of `1/Sys.SC_CLK_TCK` seconds if `Sys.SC_CLK_TCK > 0`; otherwise they are in
+unknown units.
+
 Note: Included in the detailed system information via `versioninfo(verbose=true)`.
 """
 mutable struct CPUinfo

From 6cf7d26bf9b402260545d3224baac9a81e510434 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Tue, 16 Jan 2024 19:55:35 +0530
Subject: [PATCH 0648/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 9c094b91bfdd5..b97ee725c7400 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -278,7 +278,9 @@ end
     Sys.cpu_info()
 
 Return a vector of `CPUinfo` objects, where each object represents information about a CPU core.
-This is displayed in a tabular format by the REPL, so most users will not need to access the `CPUinfo`
+
+This is pretty-printed in a tabular format by `Sys.cpu_summary`, which is included in the output
+of `versioninfo(verbose=true)`, so most users will not need to access the `CPUinfo`
 data structures directly.
 
 The function provides information about each CPU, including model, speed, and usage statistics such as user time, nice time, system time, idle time, and interrupt time.

From 718740e13dbceacc8262a1dd63b841e71857477e Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Tue, 16 Jan 2024 19:55:56 +0530
Subject: [PATCH 0649/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index b97ee725c7400..ab33e9b0d9d3a 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -662,10 +662,4 @@ function username()
     return pw.username
 end
 
-function show(io::IO, ::MIME"text/plain", cpu::AbstractVector{CPUinfo})
-    summary(io, cpu)
-    println(io, ':')
-    cpu_summary(io, cpu)
-end
-
 end # module Sys

From adbf6b08fd9812ba5e36731fa8d414967667c8b8 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Tue, 16 Jan 2024 21:38:09 +0530
Subject: [PATCH 0650/1315] Update base/sysinfo.jl

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sysinfo.jl | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index ab33e9b0d9d3a..c1017ce5da686 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -98,6 +98,14 @@ Standard word size on the current machine, in bits.
 """
 const WORD_SIZE = Core.sizeof(Int) * 8
 
+"""
+    Sys.SC_CLK_TCK:
+    
+The number of system "clock ticks" per second, corresponding to `sysconf(_SC_CLK_TCK)` on
+POSIX systems, or `0` if it is unknown.
+
+CPU times, e.g. as returned by `Sys.cpu_info()`, are in units of ticks, i.e. units of `1 / Sys.SC_CLK_TCK` seconds if `Sys.SC_CLK_TCK > 0`.
+"""
 global SC_CLK_TCK::Clong
 
 """

From a391a4e18f57b0dd68125532672288bf7fb20f26 Mon Sep 17 00:00:00 2001
From: 11happy <soni5happy@gmail.com>
Date: Tue, 16 Jan 2024 21:47:35 +0530
Subject: [PATCH 0651/1315] Formatted the code

Signed-off-by: 11happy <soni5happy@gmail.com>
---
 base/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index c1017ce5da686..5cb37721c138c 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -100,7 +100,7 @@ const WORD_SIZE = Core.sizeof(Int) * 8
 
 """
     Sys.SC_CLK_TCK:
-    
+
 The number of system "clock ticks" per second, corresponding to `sysconf(_SC_CLK_TCK)` on
 POSIX systems, or `0` if it is unknown.
 

From a327a9594fa469a2d5df32a79a86965286968e54 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Wed, 17 Jan 2024 05:09:30 +0600
Subject: [PATCH 0652/1315] Insert hardcoded backlinks to stdlib doc pages
 (#51375)

This is #48814 times 23. It solves most of but not all of #50035.
---
 stdlib/Artifacts/docs/src/index.md        | 4 ++++
 stdlib/Base64/docs/src/index.md           | 4 ++++
 stdlib/CRC32c/docs/src/index.md           | 4 ++++
 stdlib/FileWatching/docs/src/index.md     | 4 ++++
 stdlib/Future/docs/src/index.md           | 4 ++++
 stdlib/InteractiveUtils/docs/src/index.md | 4 ++++
 stdlib/LibGit2/docs/src/index.md          | 4 ++++
 stdlib/Libdl/docs/src/index.md            | 4 ++++
 stdlib/LinearAlgebra/docs/src/index.md    | 4 ++++
 stdlib/Logging/docs/src/index.md          | 4 ++++
 stdlib/Markdown/docs/src/index.md         | 4 ++++
 stdlib/Mmap/docs/src/index.md             | 4 ++++
 stdlib/Printf/docs/src/index.md           | 4 ++++
 stdlib/Profile/docs/src/index.md          | 4 ++++
 stdlib/REPL/docs/src/index.md             | 4 ++++
 stdlib/Random/docs/src/index.md           | 4 ++++
 stdlib/Serialization/docs/src/index.md    | 4 ++++
 stdlib/SharedArrays/docs/src/index.md     | 4 ++++
 stdlib/Sockets/docs/src/index.md          | 4 ++++
 stdlib/TOML/docs/src/index.md             | 4 ++++
 stdlib/Test/docs/src/index.md             | 4 ++++
 stdlib/UUIDs/docs/src/index.md            | 4 ++++
 stdlib/Unicode/docs/src/index.md          | 4 ++++
 23 files changed, 92 insertions(+)

diff --git a/stdlib/Artifacts/docs/src/index.md b/stdlib/Artifacts/docs/src/index.md
index 80f4c62cbf77f..2f6c9a07a8761 100644
--- a/stdlib/Artifacts/docs/src/index.md
+++ b/stdlib/Artifacts/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Artifacts/docs/src/index.md"
+```
+
 # Artifacts
 
 ```@meta
diff --git a/stdlib/Base64/docs/src/index.md b/stdlib/Base64/docs/src/index.md
index 6bc647f8a2e67..26e9d70f2ff9f 100644
--- a/stdlib/Base64/docs/src/index.md
+++ b/stdlib/Base64/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Base64/docs/src/index.md"
+```
+
 # Base64
 
 ```@docs
diff --git a/stdlib/CRC32c/docs/src/index.md b/stdlib/CRC32c/docs/src/index.md
index 24a073d1e3938..c00a792232c70 100644
--- a/stdlib/CRC32c/docs/src/index.md
+++ b/stdlib/CRC32c/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/CRC32c/docs/src/index.md"
+```
+
 # CRC32c
 
 Standard library module for computing the CRC-32c checksum.
diff --git a/stdlib/FileWatching/docs/src/index.md b/stdlib/FileWatching/docs/src/index.md
index a420d49232345..1b2212fcc5a28 100644
--- a/stdlib/FileWatching/docs/src/index.md
+++ b/stdlib/FileWatching/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/FileWatching/docs/src/index.md"
+```
+
 # [File Events](@id lib-filewatching)
 
 ```@docs
diff --git a/stdlib/Future/docs/src/index.md b/stdlib/Future/docs/src/index.md
index dcb1a36541b6e..99250296f2c7d 100644
--- a/stdlib/Future/docs/src/index.md
+++ b/stdlib/Future/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Future/docs/src/index.md"
+```
+
 # Future
 
 The `Future` module implements future behavior of already existing functions,
diff --git a/stdlib/InteractiveUtils/docs/src/index.md b/stdlib/InteractiveUtils/docs/src/index.md
index 5ee8e57adc848..d0c46676127e6 100644
--- a/stdlib/InteractiveUtils/docs/src/index.md
+++ b/stdlib/InteractiveUtils/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/InteractiveUtils/docs/src/index.md"
+```
+
 # [Interactive Utilities](@id man-interactive-utils)
 
 This module is intended for interactive work. It is loaded automatically in [interactive mode](@ref command-line-interface).
diff --git a/stdlib/LibGit2/docs/src/index.md b/stdlib/LibGit2/docs/src/index.md
index 3205c4c5d6987..aa4ebf2e784b6 100644
--- a/stdlib/LibGit2/docs/src/index.md
+++ b/stdlib/LibGit2/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/LibGit2/docs/src/index.md"
+```
+
 # LibGit2
 
 The LibGit2 module provides bindings to [libgit2](https://libgit2.org/), a portable C library that
diff --git a/stdlib/Libdl/docs/src/index.md b/stdlib/Libdl/docs/src/index.md
index 62f9837831d55..608562cfb410d 100644
--- a/stdlib/Libdl/docs/src/index.md
+++ b/stdlib/Libdl/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Libdl/docs/src/index.md"
+```
+
 # Dynamic Linker
 
 ```@docs
diff --git a/stdlib/LinearAlgebra/docs/src/index.md b/stdlib/LinearAlgebra/docs/src/index.md
index 177eec936a7db..138e505c79a46 100644
--- a/stdlib/LinearAlgebra/docs/src/index.md
+++ b/stdlib/LinearAlgebra/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/LinearAlgebra/docs/src/index.md"
+```
+
 # [Linear Algebra](@id man-linalg)
 
 ```@meta
diff --git a/stdlib/Logging/docs/src/index.md b/stdlib/Logging/docs/src/index.md
index 882c66af2baef..ed17c23efdba6 100644
--- a/stdlib/Logging/docs/src/index.md
+++ b/stdlib/Logging/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Logging/docs/src/index.md"
+```
+
 # [Logging](@id man-logging)
 
 The [`Logging`](@ref Logging.Logging) module provides a way to record the history and progress of a
diff --git a/stdlib/Markdown/docs/src/index.md b/stdlib/Markdown/docs/src/index.md
index 1913909278b54..3da136c0692ec 100644
--- a/stdlib/Markdown/docs/src/index.md
+++ b/stdlib/Markdown/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Markdown/docs/src/index.md"
+```
+
 # [Markdown](@id markdown_stdlib)
 
 This section describes Julia's markdown syntax, which is enabled by the
diff --git a/stdlib/Mmap/docs/src/index.md b/stdlib/Mmap/docs/src/index.md
index 5c40f11db4a4c..5ec2d5064eaf0 100644
--- a/stdlib/Mmap/docs/src/index.md
+++ b/stdlib/Mmap/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Mmap/docs/src/index.md"
+```
+
 # Memory-mapped I/O
 
 Low level module for mmap (memory mapping of files).
diff --git a/stdlib/Printf/docs/src/index.md b/stdlib/Printf/docs/src/index.md
index 7a5bae778ea36..e1dd5587d8407 100644
--- a/stdlib/Printf/docs/src/index.md
+++ b/stdlib/Printf/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Printf/docs/src/index.md"
+```
+
 # [Printf](@id man-printf)
 
 ```@docs
diff --git a/stdlib/Profile/docs/src/index.md b/stdlib/Profile/docs/src/index.md
index ab670866e086c..7e8259e0eea09 100644
--- a/stdlib/Profile/docs/src/index.md
+++ b/stdlib/Profile/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Profile/docs/src/index.md"
+```
+
 # [Profiling](@id lib-profiling)
 
 ## CPU Profiling
diff --git a/stdlib/REPL/docs/src/index.md b/stdlib/REPL/docs/src/index.md
index 0f2441f13cc69..d2a17e3a6b4a3 100644
--- a/stdlib/REPL/docs/src/index.md
+++ b/stdlib/REPL/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/REPL/docs/src/index.md"
+```
+
 # The Julia REPL
 
 Julia comes with a full-featured interactive command-line REPL (read-eval-print loop) built into
diff --git a/stdlib/Random/docs/src/index.md b/stdlib/Random/docs/src/index.md
index 70d27dc021875..c8451a3fe21fa 100644
--- a/stdlib/Random/docs/src/index.md
+++ b/stdlib/Random/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Random/docs/src/index.md"
+```
+
 # Random Numbers
 
 ```@meta
diff --git a/stdlib/Serialization/docs/src/index.md b/stdlib/Serialization/docs/src/index.md
index 9f593a2e807d9..0d00e47ed84ce 100644
--- a/stdlib/Serialization/docs/src/index.md
+++ b/stdlib/Serialization/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Serialization/docs/src/index.md"
+```
+
 # Serialization
 
 Provides serialization of Julia objects.
diff --git a/stdlib/SharedArrays/docs/src/index.md b/stdlib/SharedArrays/docs/src/index.md
index 67ceabf42115a..91ef63bf18aed 100644
--- a/stdlib/SharedArrays/docs/src/index.md
+++ b/stdlib/SharedArrays/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/SharedArrays/docs/src/index.md"
+```
+
 # Shared Arrays
 
 `SharedArray` represents an array, which is shared across multiple processes, on a single machine.
diff --git a/stdlib/Sockets/docs/src/index.md b/stdlib/Sockets/docs/src/index.md
index c294461151d7d..feb1744179261 100644
--- a/stdlib/Sockets/docs/src/index.md
+++ b/stdlib/Sockets/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Sockets/docs/src/index.md"
+```
+
 # Sockets
 
 ```@docs
diff --git a/stdlib/TOML/docs/src/index.md b/stdlib/TOML/docs/src/index.md
index 380a4d4ee820d..c6fe514ea39f4 100644
--- a/stdlib/TOML/docs/src/index.md
+++ b/stdlib/TOML/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/TOML/docs/src/index.md"
+```
+
 # TOML
 
 TOML.jl is a Julia standard library for parsing and writing [TOML
diff --git a/stdlib/Test/docs/src/index.md b/stdlib/Test/docs/src/index.md
index 99f1a93286a37..dc3e56bb8bb59 100644
--- a/stdlib/Test/docs/src/index.md
+++ b/stdlib/Test/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Test/docs/src/index.md"
+```
+
 # Unit Testing
 
 ```@meta
diff --git a/stdlib/UUIDs/docs/src/index.md b/stdlib/UUIDs/docs/src/index.md
index 1e6c950dd8999..c9529a4a38170 100644
--- a/stdlib/UUIDs/docs/src/index.md
+++ b/stdlib/UUIDs/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/UUIDs/docs/src/index.md"
+```
+
 # UUIDs
 
 ```@docs
diff --git a/stdlib/Unicode/docs/src/index.md b/stdlib/Unicode/docs/src/index.md
index 75cedc188657d..fdf07685a4492 100644
--- a/stdlib/Unicode/docs/src/index.md
+++ b/stdlib/Unicode/docs/src/index.md
@@ -1,3 +1,7 @@
+```@meta
+EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Unicode/docs/src/index.md"
+```
+
 # Unicode
 
 The `Unicode` module provides essential functionality for managing Unicode characters and strings.

From 6fa896d748e1c6228e269ea19b72e3c16d2d38b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Tue, 16 Jan 2024 23:23:57 +0000
Subject: [PATCH 0653/1315] [OpenBLAS_jll] Use new build compiled with GCC 11
 (#52928)

This enables SVE kernels on aarch64, and sapphire rapids kernels on
x86_64.

For the record, corresponding PR in Yggdrasil:
https://github.com/JuliaPackaging/Yggdrasil/pull/7952.
---
 deps/checksums/openblas          | 184 +++++++++++++++----------------
 stdlib/OpenBLAS_jll/Project.toml |   2 +-
 2 files changed, 93 insertions(+), 93 deletions(-)

diff --git a/deps/checksums/openblas b/deps/checksums/openblas
index 1c6f4242c4fd5..d4671bff2c6f2 100644
--- a/deps/checksums/openblas
+++ b/deps/checksums/openblas
@@ -1,94 +1,94 @@
-OpenBLAS.v0.3.26+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/547a98e1757f61f572a414becc563466
-OpenBLAS.v0.3.26+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/7645415bfb9b7bc21f3008aea2a508d727c81dbcf016eea4a86dbdd7cf20af66739fc059b1de10bbfc6d08d1de56ca4e36f1aaa765ab4ee8a30bccfd1824c5bd
-OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/e809969126585f1c1ba64d13d881bb42
-OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/d8d32f1ca319c51a5c34984785790ea1dce1b87913ae7546341e31be49a4c682fddca4e075a3f66875a239952611675872e57a5ca1ca1c5e01320cc176d83ab4
-OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/b464e001789eb4fa2d4e380c0eea3917
-OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/b9b0eb0a58f2684deb2769513c9536091f53eebb7c9b9c9248a84e39c1b9b5d314c08bb95a490e66e94b3848ea29d989ec943b07535be4ad48692006ca688d9c
-OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/0918c6ebace3c81c27f49b5a43217731
-OpenBLAS.v0.3.26+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/3742bebaa120245aeda02da263a1369d1ff39453c6ba76dc831ce60b4c3334944c8d068a8bf22f9fcbfe634769e7769a4f1645c787496c2ca9335bad9cb914f2
-OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/d5b139d340e28436cb446a6157f64419
-OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/1e4bc19174c8481889eb3cca6380a11ee6013066198e268bc718440b3f5b017915a3f446a1d75c53c4230bace1569ba54e14366b6af47da9bf49e52f6efb631a
-OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/d106ae8404d19375caa0cf153f5c58e1
-OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/e06c765c2da299cbabd558546bd9d4e5f83b567c455ec59d59a3c53c7e36fca1ac51bbb87c59267e31c7b3028c406e1266c0f081232d04bb1b71aa7eba80cd31
-OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/e9ca37632176ede60159d6fb43ad7dfa
-OpenBLAS.v0.3.26+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/8c7e021a4f24e18bd770ad5e75b5e36ef936857915cfed61b34185a2324a5fbce71bca4905de77d455934f0ad22e10a8d81df30dd8d51cfd0e05e8e9325bde47
-OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/df45b3895e2effb12aeab4517721571e
-OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/e5be7b0e7f2733aa462c36057fcf728f8c87150a6ef856e2039e6a0811a6806ff3ee196febdb3173243b6be9a6da9c6d3a4c55592f19c9aa08dba94715bc3d4b
-OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/b10b159a1e41843bc6de576f42bfcf47
-OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0e831086f4a80d52f3ade88ab9760a4edf3c636e5ca729347f0a173c1f671c6c2cfc732d68e26fa21556257936b9827a7a4230aa222a825a354a2ad1d60e20b5
-OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/b6d08f360a9c5338ebd386fbc52f2064
-OpenBLAS.v0.3.26+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/2a75296e0216cad110c861139f44c724217116a5488993aae7e501832df2df0074f5cddf868ecadfffc7ba9237316899788b64e834fa93a5bd3672063eb67392
-OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/ea1476eb36613ec5885cc969f2d8face
-OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/10be657bd3f6d579b1b6eb979e42d871d77211bdd2338a8d9de9a2a54f5c6bde45d6a2fbeff1c7a1d965d8553cb248087d93b3745fb0af1fda5af2a8a2d65074
-OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/68017857ebd4fab5564763451b693dcf
-OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/9907e1a60f73b7184c2917713a286660fc9b500122cc546ad3849e65de7f36106d51d0fabb00f7168ff6f63bb7fdfc9898a155c017a37ec0e8faf7aeeef05108
-OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/5a642468819eba2d58d972214ce64039
-OpenBLAS.v0.3.26+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/b71e305f1e35a25502b1f7d277e59b6078f1f05be5eeb46819fab4f261d00f99a4df4f578fc65add20baa764511ecf4b2aac76a628eeae2e30cbe82577a92bf1
-OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/df45b3895e2effb12aeab4517721571e
-OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/e5be7b0e7f2733aa462c36057fcf728f8c87150a6ef856e2039e6a0811a6806ff3ee196febdb3173243b6be9a6da9c6d3a4c55592f19c9aa08dba94715bc3d4b
-OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/b10b159a1e41843bc6de576f42bfcf47
-OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0e831086f4a80d52f3ade88ab9760a4edf3c636e5ca729347f0a173c1f671c6c2cfc732d68e26fa21556257936b9827a7a4230aa222a825a354a2ad1d60e20b5
-OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/b6d08f360a9c5338ebd386fbc52f2064
-OpenBLAS.v0.3.26+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/2a75296e0216cad110c861139f44c724217116a5488993aae7e501832df2df0074f5cddf868ecadfffc7ba9237316899788b64e834fa93a5bd3672063eb67392
-OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/ea1476eb36613ec5885cc969f2d8face
-OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/10be657bd3f6d579b1b6eb979e42d871d77211bdd2338a8d9de9a2a54f5c6bde45d6a2fbeff1c7a1d965d8553cb248087d93b3745fb0af1fda5af2a8a2d65074
-OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/68017857ebd4fab5564763451b693dcf
-OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/9907e1a60f73b7184c2917713a286660fc9b500122cc546ad3849e65de7f36106d51d0fabb00f7168ff6f63bb7fdfc9898a155c017a37ec0e8faf7aeeef05108
-OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/5a642468819eba2d58d972214ce64039
-OpenBLAS.v0.3.26+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/b71e305f1e35a25502b1f7d277e59b6078f1f05be5eeb46819fab4f261d00f99a4df4f578fc65add20baa764511ecf4b2aac76a628eeae2e30cbe82577a92bf1
-OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran3.tar.gz/md5/686269fba3e296013ccb33d4befff265
-OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/b1894c97de594def1f0b37d4d702d56d9ddd6a2897a29bb33b1579c222a7d89409658efcc07c8aa9673ca95821e5ed1b97dd41d8bcf3b2edee065ea92761218f
-OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran4.tar.gz/md5/c36ad067917ac7a6e7d1399cb6f58525
-OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/782b8cbb7b7655b1cf22e6a9bd10aec38f6624525076c74b66804796b3879fd722182705ca6043e16b13fd2a9bef1a2354dfbc8ef12db65dc94aa6864733dce1
-OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran5.tar.gz/md5/ce6d94780c46b55d61faf650d2dfb8fb
-OpenBLAS.v0.3.26+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/79cb907f77da62c9a28e7d0c3a436eccc1106af7e9f16be7f33cf95324d8668740507fd78baf3f6dc3e6eb76ffad1eaac38268bcb132602b7b258e49668c30e5
-OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran3.tar.gz/md5/d795cd8b35e6d40975db704af83b4720
-OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran3.tar.gz/sha512/8fae3a4501b0ef0203c9b79c2b98b5372393d88e647fc7516532fa425998e6117e7d011ac3c28d41f0c52c9dcc06c2d2817490a275863d920fcab87f48c5886e
-OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran4.tar.gz/md5/7491d844661f1c54f0a57adab6f2bb5b
-OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran4.tar.gz/sha512/d541151270fc5c2d9562a366c48c0aa8b7383f00714fe5ea9cb94f321e13b988e4a5f9ef3e37b0ae924dd0a1049cca5c0ec16f7207b54074ee33e99991fcb35d
-OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran5.tar.gz/md5/59930511bc5e24942776a29587b3abc0
-OpenBLAS.v0.3.26+0.i686-linux-musl-libgfortran5.tar.gz/sha512/03cbd1cbfb1f4d2c2462c92fd99fe982b2f472daf4b213929d14142d03ba78e1e24173e0bcc6e0e9947df40902c24712f39f75afc4cbb4232658c3b157b821d3
-OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/2d9793dafd383243fd76cd64a12ebd27
-OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/ee13867467731bd88037d966fd8e085d1c875c6491d182ac3e75cfc8101e9003c3f1fb094b85b2f4d1cea7ac6bed5f38e27228991e098bce614aa1d08f45d634
-OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/cf1ac1fb180432fa3880412865eddfb3
-OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/d3751a5f0604d2cb2dbf4390ad5df916f0faa29b9195b44c9ea419e6052b923c7ad00361229ad576ff07c73ee6475dc9951d8c004e7071536f33960041e1520e
-OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/69e42e661f6f984f7b57e80c9288944b
-OpenBLAS.v0.3.26+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/a157ef1fe785477f94cf3dfe1b6dc6db0406887fc49e2031148c3ec09e1314f16116ca7be3b0e43487876899343c42d51797f19aa7d76f9ff07cfb8b706b4ff4
-OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/6da004043ff90a8497765210f5edac2a
-OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/bac7e378474769c7f2b4c8acbb960b29ee47f9f49aec95239543451583e83420990a4eb03dd994ebec7f60e95f6cc95668977cf4ad9414ecfedb93fe2d85e338
-OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/3bb442a6331324913d13bda804dabafb
-OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/5a865ea29ae2647e2639b614a5373a5675542cdcab380405f800dca1987b5628a302841e7546f89ad64a8cb87371c2e82dee603a8f732b6bc17e1f0635eda5f1
-OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/f9ed9d491ff44839d663d29ad17e062d
-OpenBLAS.v0.3.26+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/e365b28397ca0c98f996fda40ab5300046c80c6566a6f5897a9db6b46942eb925b405ad0029f39f77ab13b50ef39d94fd21c1510ddfae652a081277f827a9383
-OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/aada145cdbd5990a5191b5161e8caa57
-OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/e4146f26459d9264c45dd0ca0394ab264ec0154709aabe5cb4d821c341ed937a467ba7e0a82e4bfc0f5b9142921f21d2a732914d8aa94eece67cf29e8e0f3618
-OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/79d25889603731cd9b67bd90171f6785
-OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/ffbafdded8420891e403c42922c5189981b42cf9a1b0a229d7caf75b23afcb1bf0bad07bdeeb40f47db3f0226dc15cfb5e35dc1d7350d65bbfce8895dd1703ab
-OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/86090567892be1cbecd1e0aa3331ba47
-OpenBLAS.v0.3.26+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/a74c5d635477f39ff28ee83a3fe980a6c5dad9986a44388e8c1bccdbdcb371e9365570938bf47c20e64fa94fb118c8a09eaa468ac79d9362e9448bc5f717c9e9
-OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/f470ceb90d452684f1f8bab0430255f3
-OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/5b7a8f70173cf593d8340fa4dfe25d885b71ee28491cd88d29ae0d3e161ee97828e7373fdeb0fc4f3843b6d4b7ed1dd5f818cf4fbd85f1b965ade69496c0b032
-OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/21937c57336aeee6d1281838091f2ded
-OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/31ea2e95ea67bd068fbc5dec70ed37cbf675a38465612928da63ec727358eba140c407a4d24781eddb61e2a78c21aa5fcbd509e53d2f79133f20348f12a26c3b
-OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/ad6d27048e3258ff7e4612b019089a49
-OpenBLAS.v0.3.26+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/cc61af1e3b64d8476c3add782213324bf2dfe218c77a9f2ddb835d9294e00970a4c78140be4bb25480c155cde0ad860599b4e6fff89e52530782910d8f1524d6
-OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/a027d4b3cdf3d1696ff9fbcee92cd11c
-OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/2114cab81354e4ce1b7952da4c949d7bb936e6c03f7c74db64c19de564417c1ede8aa7392454d22a80846b624d98278c96c3892a7eade1dc7d2d6492cf995993
-OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/24c27c66ba984ce08e29c8db8e4f0623
-OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/9c64e74d4b2cecb67cb919a801572bda4709c7a7cff016637256689f3e25e15964c681e44df70e7e843dd51cc21c1418c63620c292ba85b2fefc996f2edf6ee2
-OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/be5610c6c7b0e2d434fddd48b6a990c8
-OpenBLAS.v0.3.26+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/cdf7302ded2deaf9f661d2fa2dacd68a77c20aa839577b4931a4c7e345548e83179a71ad8d3a8f497ee17e5f58903711fca60fd837c4060f3653a3d166ac7402
-OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/246fa31cdf14e93eb04c9fc4c96845a1
-OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/a1eff9bc326976fec67461e5391342fee74ef91c2d3d3b7bde387daf76f2c721d522fd3e78094218c5bfcfd02d1c96288d14c83668acccd92144960e4aea67d2
-OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/06b953ed17b40e8713cc5b3d6e1e825c
-OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/185705657be22c6681133d7fe05d9e890e87b1637d0194c7b39a2194cadbf3a55aa2e252696355fc399db4477e1aeff32062a0fcf2b45925e6f9c64d8f12ce4e
-OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/88d0ad25d8544880902f02bc7e030d33
-OpenBLAS.v0.3.26+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/126850a7c65413079694791c734c4bd4acacf4766986e60fbb230d95f57e06b685877dfde02a3c0b9d53bf24c58cbd31404142258935dc580d1c54798d08e782
-OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/9be5f51d9676a008483437079797f4c7
-OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/ac9c93541b246563994725573ebdc816b9341389b6f101160575ae25c3e01d3289146d86b54bcaf19f15b035afaf0346c50419601fd7f64a4cafe7754dda5afe
-OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/cbb1711388ee92693459e9de5275510f
-OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/4c0344c43a41f4042787999a1b9b1c8d897dfa42b1af2aaf2f58284efe835cc273cc99703d87212f1433b19764ace01955b89ee1c4e2c928a6025cb1d17b6464
-OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/574bee32c74429934e729ced4078589d
-OpenBLAS.v0.3.26+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/78e567cfaa808859134bdd829c34508e06dd4ae2719551ee77eac41b4712e0fa439126d08dcaed88c4584c9ff850f63b37debfb5ee53dc0c5606b45fa5df987b
+OpenBLAS.v0.3.26+1.aarch64-apple-darwin-libgfortran5.tar.gz/md5/547a98e1757f61f572a414becc563466
+OpenBLAS.v0.3.26+1.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/7645415bfb9b7bc21f3008aea2a508d727c81dbcf016eea4a86dbdd7cf20af66739fc059b1de10bbfc6d08d1de56ca4e36f1aaa765ab4ee8a30bccfd1824c5bd
+OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran3.tar.gz/md5/e809969126585f1c1ba64d13d881bb42
+OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/d8d32f1ca319c51a5c34984785790ea1dce1b87913ae7546341e31be49a4c682fddca4e075a3f66875a239952611675872e57a5ca1ca1c5e01320cc176d83ab4
+OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran4.tar.gz/md5/b464e001789eb4fa2d4e380c0eea3917
+OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/b9b0eb0a58f2684deb2769513c9536091f53eebb7c9b9c9248a84e39c1b9b5d314c08bb95a490e66e94b3848ea29d989ec943b07535be4ad48692006ca688d9c
+OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran5.tar.gz/md5/650898300d9ead8e3baf3a6b66a931b8
+OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/033a558868fb20872c37257a4b440a121136e3c22d8df9cbed19b66ef859948215f0edd3cba8767bc66869102ff9fd6f6661e7b3a307819cf8e89077052b5451
+OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran3.tar.gz/md5/d5b139d340e28436cb446a6157f64419
+OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran3.tar.gz/sha512/1e4bc19174c8481889eb3cca6380a11ee6013066198e268bc718440b3f5b017915a3f446a1d75c53c4230bace1569ba54e14366b6af47da9bf49e52f6efb631a
+OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran4.tar.gz/md5/d106ae8404d19375caa0cf153f5c58e1
+OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran4.tar.gz/sha512/e06c765c2da299cbabd558546bd9d4e5f83b567c455ec59d59a3c53c7e36fca1ac51bbb87c59267e31c7b3028c406e1266c0f081232d04bb1b71aa7eba80cd31
+OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran5.tar.gz/md5/35348019d6532f9632ec5f42c9e63fbe
+OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran5.tar.gz/sha512/3bcbd0a5ee955ce8617f00de6440675cf3bc89adca6d7eaed46f9087c9a77f701737bc019993a488eef0cec7712323287c418a632fee66e38e756d5b550cf3a0
+OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/df45b3895e2effb12aeab4517721571e
+OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/e5be7b0e7f2733aa462c36057fcf728f8c87150a6ef856e2039e6a0811a6806ff3ee196febdb3173243b6be9a6da9c6d3a4c55592f19c9aa08dba94715bc3d4b
+OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/b10b159a1e41843bc6de576f42bfcf47
+OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0e831086f4a80d52f3ade88ab9760a4edf3c636e5ca729347f0a173c1f671c6c2cfc732d68e26fa21556257936b9827a7a4230aa222a825a354a2ad1d60e20b5
+OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/2aa72a7dfcc19d414a6f8f81de482e69
+OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/d31d2e3129b173b844917006a2fcdd9c08ecb5cba62c431c30651e4088dd2d25cf00ee5fb0f6b403c6ff599ddff59e895bf0669f124839f753b213e2bae4579a
+OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/ea1476eb36613ec5885cc969f2d8face
+OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/10be657bd3f6d579b1b6eb979e42d871d77211bdd2338a8d9de9a2a54f5c6bde45d6a2fbeff1c7a1d965d8553cb248087d93b3745fb0af1fda5af2a8a2d65074
+OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/68017857ebd4fab5564763451b693dcf
+OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/9907e1a60f73b7184c2917713a286660fc9b500122cc546ad3849e65de7f36106d51d0fabb00f7168ff6f63bb7fdfc9898a155c017a37ec0e8faf7aeeef05108
+OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/f531cec3c06a0513d68571b118dc20b6
+OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/41ae9860625323686adf0b2d0cb4a9df59d99a8df2fe0f4a01a0b9ce0aea06017d9132191d883eba62893e43189667a7dc13caf89dced5666ce5d4346be656ce
+OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/df45b3895e2effb12aeab4517721571e
+OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/e5be7b0e7f2733aa462c36057fcf728f8c87150a6ef856e2039e6a0811a6806ff3ee196febdb3173243b6be9a6da9c6d3a4c55592f19c9aa08dba94715bc3d4b
+OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/b10b159a1e41843bc6de576f42bfcf47
+OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0e831086f4a80d52f3ade88ab9760a4edf3c636e5ca729347f0a173c1f671c6c2cfc732d68e26fa21556257936b9827a7a4230aa222a825a354a2ad1d60e20b5
+OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/2aa72a7dfcc19d414a6f8f81de482e69
+OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/d31d2e3129b173b844917006a2fcdd9c08ecb5cba62c431c30651e4088dd2d25cf00ee5fb0f6b403c6ff599ddff59e895bf0669f124839f753b213e2bae4579a
+OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/ea1476eb36613ec5885cc969f2d8face
+OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/10be657bd3f6d579b1b6eb979e42d871d77211bdd2338a8d9de9a2a54f5c6bde45d6a2fbeff1c7a1d965d8553cb248087d93b3745fb0af1fda5af2a8a2d65074
+OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/68017857ebd4fab5564763451b693dcf
+OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/9907e1a60f73b7184c2917713a286660fc9b500122cc546ad3849e65de7f36106d51d0fabb00f7168ff6f63bb7fdfc9898a155c017a37ec0e8faf7aeeef05108
+OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/f531cec3c06a0513d68571b118dc20b6
+OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/41ae9860625323686adf0b2d0cb4a9df59d99a8df2fe0f4a01a0b9ce0aea06017d9132191d883eba62893e43189667a7dc13caf89dced5666ce5d4346be656ce
+OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran3.tar.gz/md5/686269fba3e296013ccb33d4befff265
+OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran3.tar.gz/sha512/b1894c97de594def1f0b37d4d702d56d9ddd6a2897a29bb33b1579c222a7d89409658efcc07c8aa9673ca95821e5ed1b97dd41d8bcf3b2edee065ea92761218f
+OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran4.tar.gz/md5/c36ad067917ac7a6e7d1399cb6f58525
+OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran4.tar.gz/sha512/782b8cbb7b7655b1cf22e6a9bd10aec38f6624525076c74b66804796b3879fd722182705ca6043e16b13fd2a9bef1a2354dfbc8ef12db65dc94aa6864733dce1
+OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran5.tar.gz/md5/814c2bcb8e25eda7559849867aec9c80
+OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran5.tar.gz/sha512/a9407e78f37953558ea48b4c395bcd1382b9c869043fd445a38a1f1db13551a0fe99dec5d503701ef86ac75e1f1ef46e2cd8912486cdf382ebe38efd9996baa1
+OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran3.tar.gz/md5/d795cd8b35e6d40975db704af83b4720
+OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran3.tar.gz/sha512/8fae3a4501b0ef0203c9b79c2b98b5372393d88e647fc7516532fa425998e6117e7d011ac3c28d41f0c52c9dcc06c2d2817490a275863d920fcab87f48c5886e
+OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran4.tar.gz/md5/7491d844661f1c54f0a57adab6f2bb5b
+OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran4.tar.gz/sha512/d541151270fc5c2d9562a366c48c0aa8b7383f00714fe5ea9cb94f321e13b988e4a5f9ef3e37b0ae924dd0a1049cca5c0ec16f7207b54074ee33e99991fcb35d
+OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran5.tar.gz/md5/d780f3734c2503931354b5bb385156b6
+OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran5.tar.gz/sha512/44f5c4a9c6f7b7b13761d0ba997c3c5582b17ec6455c7dc06f3984533e99f2b66f26371747648f3997b200f917fa413e8b07634da1c7cb4736f653cb38170aee
+OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran3.tar.gz/md5/c8bda88720dfe9415a93ee639ab8061e
+OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran3.tar.gz/sha512/2b9396f92c0883811c5dcf13ac10781ba0a46ce7bb6c839ec83e9e7bc75b9d805d8cb6d74e52502bf9210a02bc066cd1a11235bc754b62e103e9d9912b8dc39d
+OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran4.tar.gz/md5/d92cea9c2931480cd80f2e6845ef0fa2
+OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran4.tar.gz/sha512/8870c89a3f43efd3c681b36e8bf6ec8876e30c29256c6c5ab2021ea4318d898fa2a231dae285f60760d7559e6bb730814e3e9ed88f1509afa5d1d9c0e7c78a05
+OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran5.tar.gz/md5/ddecd7f5bf7b621e76bbd7f10d860f9d
+OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran5.tar.gz/sha512/8755d2931d8c8ec48fd52050071edaed8d5f401110a9ccef4019ba4c25434a55c443e8d35e8e84cb6bb109161a5a40861970c99c2452bc2a1c51f5937c7f68ea
+OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/6da004043ff90a8497765210f5edac2a
+OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/bac7e378474769c7f2b4c8acbb960b29ee47f9f49aec95239543451583e83420990a4eb03dd994ebec7f60e95f6cc95668977cf4ad9414ecfedb93fe2d85e338
+OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/3bb442a6331324913d13bda804dabafb
+OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/5a865ea29ae2647e2639b614a5373a5675542cdcab380405f800dca1987b5628a302841e7546f89ad64a8cb87371c2e82dee603a8f732b6bc17e1f0635eda5f1
+OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/a27d102271dd18fdcc3f8fcc722285d6
+OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/37f92d7e6549bbfd7c67287d28dc366f2943f8063629e1e09afd1e4e82191bee4aa0201add0c99d9945304eedaacfad6b88d1fc8c6b00c05f73de78ca70c3e40
+OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran3.tar.gz/md5/aada145cdbd5990a5191b5161e8caa57
+OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/e4146f26459d9264c45dd0ca0394ab264ec0154709aabe5cb4d821c341ed937a467ba7e0a82e4bfc0f5b9142921f21d2a732914d8aa94eece67cf29e8e0f3618
+OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran4.tar.gz/md5/79d25889603731cd9b67bd90171f6785
+OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/ffbafdded8420891e403c42922c5189981b42cf9a1b0a229d7caf75b23afcb1bf0bad07bdeeb40f47db3f0226dc15cfb5e35dc1d7350d65bbfce8895dd1703ab
+OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran5.tar.gz/md5/4eb2c9142dcaf9482066d659d8f01420
+OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/4ab556be0a45c177770085d79a09b2374eb88d447bc4fe73e3ee9ab298b1ff62b7442576439dbe5c05ee18121e971b26e58c2cdc6470136c320b59c0d6db5c9e
+OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran3.tar.gz/md5/f470ceb90d452684f1f8bab0430255f3
+OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/5b7a8f70173cf593d8340fa4dfe25d885b71ee28491cd88d29ae0d3e161ee97828e7373fdeb0fc4f3843b6d4b7ed1dd5f818cf4fbd85f1b965ade69496c0b032
+OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran4.tar.gz/md5/21937c57336aeee6d1281838091f2ded
+OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/31ea2e95ea67bd068fbc5dec70ed37cbf675a38465612928da63ec727358eba140c407a4d24781eddb61e2a78c21aa5fcbd509e53d2f79133f20348f12a26c3b
+OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran5.tar.gz/md5/12bea9681837bd876dca337d5dff0310
+OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/fe60a87f77b94fa0601ce626ad564b3185b818f0cf0e1ffe71ed7ac9e3ed381f785e0e40ade48137a3982f26a25937a0281d8af0ee90525d8b83aa0c7d6c246b
+OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran3.tar.gz/md5/a027d4b3cdf3d1696ff9fbcee92cd11c
+OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran3.tar.gz/sha512/2114cab81354e4ce1b7952da4c949d7bb936e6c03f7c74db64c19de564417c1ede8aa7392454d22a80846b624d98278c96c3892a7eade1dc7d2d6492cf995993
+OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran4.tar.gz/md5/24c27c66ba984ce08e29c8db8e4f0623
+OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran4.tar.gz/sha512/9c64e74d4b2cecb67cb919a801572bda4709c7a7cff016637256689f3e25e15964c681e44df70e7e843dd51cc21c1418c63620c292ba85b2fefc996f2edf6ee2
+OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran5.tar.gz/md5/0815934674727f808723ca59c2c4def1
+OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran5.tar.gz/sha512/15036bfd5ca5d8770a7fdce63790756475d1f94ad301b4985b38445d9660bb0591fc4bd96280e07cbf9da52d0be1fda97a3629e0956bee84e501f19ca85472ac
+OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/246fa31cdf14e93eb04c9fc4c96845a1
+OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/a1eff9bc326976fec67461e5391342fee74ef91c2d3d3b7bde387daf76f2c721d522fd3e78094218c5bfcfd02d1c96288d14c83668acccd92144960e4aea67d2
+OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/06b953ed17b40e8713cc5b3d6e1e825c
+OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/185705657be22c6681133d7fe05d9e890e87b1637d0194c7b39a2194cadbf3a55aa2e252696355fc399db4477e1aeff32062a0fcf2b45925e6f9c64d8f12ce4e
+OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/9e2362434fdc10a570f231c65d31c936
+OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/c2913cdab07096d1c6e1beaca7dedbfccc9ca91f0f32f76d476b37684fc0dcd55e4ace96cba668106564011c15f29f6703fdf76d0a7b1c757f1eaa3289891039
+OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/9be5f51d9676a008483437079797f4c7
+OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/ac9c93541b246563994725573ebdc816b9341389b6f101160575ae25c3e01d3289146d86b54bcaf19f15b035afaf0346c50419601fd7f64a4cafe7754dda5afe
+OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/cbb1711388ee92693459e9de5275510f
+OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/4c0344c43a41f4042787999a1b9b1c8d897dfa42b1af2aaf2f58284efe835cc273cc99703d87212f1433b19764ace01955b89ee1c4e2c928a6025cb1d17b6464
+OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/d4a7332e9a7a490a8da7fcbaeb290043
+OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/ebe4f1d619925638a5628a0ab47ebf219a7f7302cb52f409912a3aa4f614097a5595cc97060b1417aaa059d817d6a3607f8a0a563466ac6d9f82770a9ff1d87b
 openblas-6c77e5e314474773a7749357b153caba4ec3817d.tar.gz/md5/4971eeb7adadee085d7c991db416fe7a
 openblas-6c77e5e314474773a7749357b153caba4ec3817d.tar.gz/sha512/7b85c9fb7be54407ba627d77897f40de4395d6d307230aa7df83cf8e0a41f545e4af4ae0576abb40cc9e0c385e1c6a488100dff292ea307439a89587c07ba66f
diff --git a/stdlib/OpenBLAS_jll/Project.toml b/stdlib/OpenBLAS_jll/Project.toml
index 1e3f5b8761701..4eeea867b8bce 100644
--- a/stdlib/OpenBLAS_jll/Project.toml
+++ b/stdlib/OpenBLAS_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "OpenBLAS_jll"
 uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
-version = "0.3.26+0"
+version = "0.3.26+1"
 
 [deps]
 # See note in `src/OpenBLAS_jll.jl` about this dependency.

From b1c4fbfc63379385aff18555b50ce39dbca3b069 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Wed, 17 Jan 2024 09:25:25 +0800
Subject: [PATCH 0654/1315] Fix `widen_diagonal` bug for nested `UnionAll`
 (#52924)

Fix #52919.
---
 src/subtype.c | 9 ++++-----
 test/core.jl  | 4 ++--
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/subtype.c b/src/subtype.c
index 17a6bf7041e3b..50b62c9b6e3da 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -4460,19 +4460,18 @@ static jl_value_t *insert_nondiagonal(jl_value_t *type, jl_varbinding_t *troot,
         jl_value_t *newbody = insert_nondiagonal(body, troot, widen2ub);
         if (v) v->var = var; // And restore it after inner insertation.
         jl_value_t *newvar = NULL;
-        JL_GC_PUSH2(&newbody, &newvar);
+        JL_GC_PUSH3(&newbody, &newvar, &type);
         if (body == newbody || jl_has_typevar(newbody, var)) {
             if (body != newbody)
-                newbody = jl_new_struct(jl_unionall_type, var, newbody);
+                type = jl_new_struct(jl_unionall_type, var, newbody);
             // n.b. we do not widen lb, since that would be the wrong direction
             newvar = insert_nondiagonal(var->ub, troot, widen2ub);
             if (newvar != var->ub) {
                 newvar = (jl_value_t*)jl_new_typevar(var->name, var->lb, newvar);
-                newbody = jl_apply_type1(newbody, newvar);
-                newbody = jl_type_unionall((jl_tvar_t*)newvar, newbody);
+                newbody = jl_apply_type1(type, newvar);
+                type = jl_type_unionall((jl_tvar_t*)newvar, newbody);
             }
         }
-        type = newbody;
         JL_GC_POP();
     }
     else if (jl_is_uniontype(type)) {
diff --git a/test/core.jl b/test/core.jl
index 1f66d72c40c5e..67e0102bc164a 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8076,14 +8076,14 @@ let src = code_lowered(check_globalref_lowering)[1]
 end
 
 # Test correctness of widen_diagonal
-let widen_diagonal(x::UnionAll) = Base.rewrap_unionall(Base.widen_diagonal(Base.unwrap_unionall(x), x), x),
-    check_widen_diagonal(x, y) = !<:(x, y) && x <: widen_diagonal(y)
+let widen_diagonal(x::UnionAll) = Base.rewrap_unionall(Base.widen_diagonal(Base.unwrap_unionall(x), x), x)
     @test Tuple{Int,Float64} <: widen_diagonal(NTuple)
     @test Tuple{Int,Float64} <: widen_diagonal(Tuple{T,T} where {T})
     @test Tuple{Real,Int,Float64} <: widen_diagonal(Tuple{S,Vararg{T}} where {S, T<:S})
     @test Tuple{Int,Int,Float64,Float64} <: widen_diagonal(Tuple{S,S,Vararg{T}} where {S, T<:S})
     @test Union{Tuple{T}, Tuple{T,Int}} where {T} === widen_diagonal(Union{Tuple{T}, Tuple{T,Int}} where {T})
     @test Tuple === widen_diagonal(Union{Tuple{Vararg{S}}, Tuple{Vararg{T}}} where {S, T})
+    @test Tuple{Vararg{Val{<:Set}}} == widen_diagonal(Tuple{Vararg{T}} where T<:Val{<:Set})
 end
 
 # Test try/catch/else ordering

From d4e3a3d52ad01ae6e3dd2f77cd8b592d6f3340a6 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@mit.edu>
Date: Tue, 16 Jan 2024 20:26:47 -0500
Subject: [PATCH 0655/1315] Update test/sysinfo.jl

---
 test/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index 3efdb85eda9ee..f02d8ffe36091 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -65,9 +65,9 @@ end
     Base.Sys.CPUinfo("Apple M1 Pro", 2400, 0x00000000026784da, 0x0000000000000000, 0x0000000000fda30e, 0x0000000046a731ea, 0x0000000000000000)
     Base.Sys.CPUinfo("Apple M1 Pro", 2400, 0x00000000017726c0, 0x0000000000000000, 0x00000000009491de, 0x0000000048134f1e, 0x0000000000000000)]
 
+    Sys.SC_CLK_TCK, save_SC_CLK_TCK = 100, Sys.SC_CLK_TCK # use platform-independent tick units
     @test repr(example_cpus[1]) == "Base.Sys.CPUinfo(\"Apple M1 Pro\", 2400, 0x000000000d913b08, 0x0000000000000000, 0x0000000005f4243c, 0x00000000352a550a, 0x0000000000000000)"
     @test repr("text/plain", example_cpus[1]) == "Apple M1 Pro: \n        speed         user         nice          sys         idle          irq\n     2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s"
-    Sys.SC_CLK_TCK, save_SC_CLK_TCK = 100, Sys.SC_CLK_TCK
     @test sprint(Sys.cpu_summary, example_cpus) == "Apple M1 Pro: \n       speed         user         nice          sys         idle          irq\n#1  2400 MHz    2276216 s          0 s     998861 s    8919667 s          0 s\n#2  2400 MHz    2275576 s          0 s     978101 s    8962204 s          0 s\n#3  2400 MHz     403386 s          0 s     166224 s   11853624 s          0 s\n#4  2400 MHz     245859 s          0 s      97367 s   12092250 s          0 s\n"
     Sys.SC_CLK_TCK = save_SC_CLK_TCK
 end

From 45b18395c7712b8081e9d0d4d870fe8467946ef7 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Tue, 16 Jan 2024 20:38:01 -0500
Subject: [PATCH 0656/1315] Sys.SC_CLK_TCK value on windows

---
 src/sys.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/sys.c b/src/sys.c
index 7407da4e3514e..f025310e9e7e5 100644
--- a/src/sys.c
+++ b/src/sys.c
@@ -631,7 +631,7 @@ JL_DLLEXPORT long jl_SC_CLK_TCK(void)
 #ifndef _OS_WINDOWS_
     return sysconf(_SC_CLK_TCK);
 #else
-    return 0;
+    return 1000; # uv_cpu_info returns times in ms
 #endif
 }
 

From 313cd7916533f5ea9a7ecee3c50f31a41557cc76 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Tue, 16 Jan 2024 20:51:49 -0500
Subject: [PATCH 0657/1315] Update sys.c: whoops

---
 src/sys.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/sys.c b/src/sys.c
index f025310e9e7e5..0c0016ee07657 100644
--- a/src/sys.c
+++ b/src/sys.c
@@ -631,7 +631,7 @@ JL_DLLEXPORT long jl_SC_CLK_TCK(void)
 #ifndef _OS_WINDOWS_
     return sysconf(_SC_CLK_TCK);
 #else
-    return 1000; # uv_cpu_info returns times in ms
+    return 1000; /* uv_cpu_info returns times in ms on Windows */
 #endif
 }
 

From b4f7263bcef14bd2de17fe04bc0f2b0f027ec0b1 Mon Sep 17 00:00:00 2001
From: Mason Protter <mason.protter@icloud.com>
Date: Wed, 17 Jan 2024 03:21:10 +0100
Subject: [PATCH 0658/1315] make `Base.remove_linenums!` public (#52911)

---
 base/expr.jl | 43 ++++++++++++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 17 deletions(-)

diff --git a/base/expr.jl b/base/expr.jl
index 553f5a360dff1..ab4314fbd6cc8 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -998,27 +998,36 @@ function findmeta_block(exargs, argsmatch=args->true)
     return 0, []
 end
 
-remove_linenums!(ex) = ex
-function remove_linenums!(ex::Expr)
-    if ex.head === :block || ex.head === :quote
-        # remove line number expressions from metadata (not argument literal or inert) position
-        filter!(ex.args) do x
-            isa(x, Expr) && x.head === :line && return false
-            isa(x, LineNumberNode) && return false
-            return true
+"""
+    Base.remove_linenums!(ex)
+
+Remove all line-number metadata from expression-like object `ex`.
+"""
+function remove_linenums!(@nospecialize ex)
+    if ex isa Expr
+        if ex.head === :block || ex.head === :quote
+            # remove line number expressions from metadata (not argument literal or inert) position
+            filter!(ex.args) do x
+                isa(x, Expr) && x.head === :line && return false
+                isa(x, LineNumberNode) && return false
+                return true
+            end
         end
+        for subex in ex.args
+            subex isa Expr && remove_linenums!(subex)
+        end
+        return ex
+    elseif ex isa CodeInfo
+        ex.codelocs .= 0
+        length(ex.linetable) > 1 && resize!(ex.linetable, 1)
+        return ex
+    else
+        return ex
     end
-    for subex in ex.args
-        subex isa Expr && remove_linenums!(subex)
-    end
-    return ex
-end
-function remove_linenums!(src::CodeInfo)
-    src.codelocs .= 0
-    length(src.linetable) > 1 && resize!(src.linetable, 1)
-    return src
 end
 
+public remove_linenums!
+
 replace_linenums!(ex, ln::LineNumberNode) = ex
 function replace_linenums!(ex::Expr, ln::LineNumberNode)
     if ex.head === :block || ex.head === :quote

From 3ed49fdb3a9c500d0134320151614d39d517def3 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 17 Jan 2024 15:57:37 +0900
Subject: [PATCH 0659/1315] absint: merge `const_prop_enabled` into
 `bail_out_const_call` (#52921)

Both of these interfaces have nearly identical roles. Considering the
simplicity in the codebase and the possible overloads by external
abstract interpreters, it seems more sensible to unify them into one
interface. Also tweaks remarks a bit.
---
 base/compiler/abstractinterpretation.jl | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index b492d07f4ba3a..6735aa3d35e58 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -814,7 +814,7 @@ end
 function abstract_call_method_with_const_args(interp::AbstractInterpreter,
     result::MethodCallResult, @nospecialize(f), arginfo::ArgInfo, si::StmtInfo,
     match::MethodMatch, sv::AbsIntState, invokecall::Union{Nothing,InvokeCall}=nothing)
-    if !const_prop_enabled(interp, match, sv) || bail_out_const_call(interp, result, si, sv)
+    if bail_out_const_call(interp, result, si, match, sv)
         return nothing
     end
     eligibility = concrete_eval_eligible(interp, f, result, arginfo, sv)
@@ -847,26 +847,26 @@ function abstract_call_method_with_const_args(interp::AbstractInterpreter,
     return const_prop_call(interp, mi, result, arginfo, sv, concrete_eval_result)
 end
 
-function const_prop_enabled(interp::AbstractInterpreter, match::MethodMatch, sv::AbsIntState)
+function bail_out_const_call(interp::AbstractInterpreter, result::MethodCallResult,
+                             si::StmtInfo, match::MethodMatch, sv::AbsIntState)
     if !InferenceParams(interp).ipo_constant_propagation
         add_remark!(interp, sv, "[constprop] Disabled by parameter")
-        return false
+        return true
     end
     if is_no_constprop(match.method)
         add_remark!(interp, sv, "[constprop] Disabled by method parameter")
-        return false
+        return true
     end
-    return true
-end
-
-function bail_out_const_call(interp::AbstractInterpreter, result::MethodCallResult,
-                             si::StmtInfo, sv::AbsIntState)
     if is_removable_if_unused(result.effects)
-        if isa(result.rt, Const) || call_result_unused(si)
+        if isa(result.rt, Const)
             add_remark!(interp, sv, "[constprop] No more information to be gained (const)")
             return true
+        elseif call_result_unused(si)
+            add_remark!(interp, sv, "[constprop] No more information to be gained (unused result)")
+            return true
         end
-    elseif result.rt === Bottom
+    end
+    if result.rt === Bottom
         if is_terminates(result.effects) && is_effect_free(result.effects)
             # In the future, we may want to add `&& isa(result.exct, Const)` to
             # the list of conditions here, but currently, our effect system isn't

From 0b0e3bfaea35d8e971a673946b96ae650988b419 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Thu, 18 Jan 2024 04:17:17 +0100
Subject: [PATCH 0660/1315] doc: fix typos, Markdown, language in the Manual
 section on `Main.main` (#52939)

---
 doc/src/manual/command-line-interface.md | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index be442e456c2e0..c2bef7c9b73c2 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -41,10 +41,12 @@ See also [Scripting](@ref man-scripting) for more information on writing Julia s
 
 ## The `Main.main` entry point
 
-As of Julia, 1.11, Base export a special macro `@main`. This macro simply expands to the symbol `main`,
+As of Julia, 1.11, `Base` exports the macro `@main`. This macro expands to the symbol `main`,
 but at the conclusion of executing a script or expression, `julia` will attempt to execute the function
 `Main.main(ARGS)` if such a function has been defined and this behavior was opted into
-using the `@main macro`. This feature is intended to aid in the unification
+by using the `@main` macro.
+
+This feature is intended to aid in the unification
 of compiled and interactive workflows. In compiled workflows, loading the code that defines the `main`
 function may be spatially and temporally separated from the invocation. However, for interactive workflows,
 the behavior is equivalent to explicitly calling `exit(main(ARGS))` at the end of the evaluated script or
@@ -62,10 +64,10 @@ Hello World!
 $
 ```
 
-Only the `main` binding in the `Main`, module has this special behavior and only if
+Only the `main` binding in the `Main` module has this behavior and only if
 the macro `@main` was used within the defining module.
 
-For example, using `hello` instead of `main` will result not result in the `hello` function executing:
+For example, using `hello` instead of `main` will not result in the `hello` function executing:
 
 ```
 $ julia -e 'hello(ARGS) = println("Hello World!")'
@@ -79,11 +81,13 @@ $
 ```
 
 However, the opt-in need not occur at definition time:
+```
 $ julia -e 'main(ARGS) = println("Hello World!"); @main'
 Hello World!
 $
+```
 
-The `main` binding may be imported from a package. A hello package defined as
+The `main` binding may be imported from a package. A *hello world* package defined as
 
 ```
 module Hello

From 94db36472f03b4e47644b88304d3f9fea6226a3f Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 18 Jan 2024 12:18:17 +0900
Subject: [PATCH 0661/1315] replace the `depwarn` special case with the recent
 compiler annotations (#52918)

The special handling for `depwarn`, originating from
JuliaLang/julia#27918 in 2018, is now set to be replaced by the more
recent compiler annotations, esp. `@nospecializeinfer`. Assessing
potential regressions from this change might be challenging, but I
confirmed this only has a minimal impact on image sizes at least.
---
 base/compiler/abstractinterpretation.jl |  4 ----
 base/deprecated.jl                      | 10 +++++++++-
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 6735aa3d35e58..99c291ff8ec4b 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -517,10 +517,6 @@ const RECURSION_MSG_HARDLIMIT = "Bounded recursion detected under hardlimit. Cal
 function abstract_call_method(interp::AbstractInterpreter,
                               method::Method, @nospecialize(sig), sparams::SimpleVector,
                               hardlimit::Bool, si::StmtInfo, sv::AbsIntState)
-    if method.name === :depwarn && isdefined(Main, :Base) && method.module === Main.Base
-        add_remark!(interp, sv, "Refusing to infer into `depwarn`")
-        return MethodCallResult(Any, Any, false, false, nothing, Effects())
-    end
     sigtuple = unwrap_unionall(sig)
     sigtuple isa DataType ||
         return MethodCallResult(Any, Any, false, false, nothing, Effects())
diff --git a/base/deprecated.jl b/base/deprecated.jl
index 5a7ec69979728..7e7fa5596ca25 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -118,7 +118,15 @@ macro deprecate(old, new, export_old=true)
     end
 end
 
-function depwarn(msg, funcsym; force::Bool=false)
+@nospecializeinfer function depwarn(msg, funcsym; force::Bool=false)
+    @nospecialize
+    # N.B. With this use of `@invokelatest`, we're preventing the addition of backedges from
+    # callees, such as `convert`, to this user-facing method. This approach is designed to
+    # enhance the resilience of packages that utilize `depwarn` against invalidation.
+    return @invokelatest _depwarn(msg, funcsym, force)
+end
+@nospecializeinfer function _depwarn(msg, funcsym, force::Bool)
+    @nospecialize
     opts = JLOptions()
     if opts.depwarn == 2
         throw(ErrorException(msg))

From 82740882cf269b86f7e4d1bdf58fa07d093a7982 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 18 Jan 2024 12:21:13 +0900
Subject: [PATCH 0662/1315] irinterp: don't add backedges to top-level thunks
 (#52916)

irinterp utilizes `store_backedges(::MethodInstance, edges)`, but it
doesn't check to prevent adding backedges to top-level thunks. This is
no issue in native compilation, however, it can become problematic when
an external `AbstractInterpreter` that does irinterp on top-level thunks
tries precompilation (this could, for instance, trigger [this
assert](https://github.com/JuliaLang/julia/blob/b058146cafec8405aa07f9647642fd485ea3b5d7/src/staticdata_utils.c#L450)).
This commit tries to resolve this issue by performing the top-level
thunk check within `store_backedges(::MethodInstance, edges)` instead of
`store_backedges(::InferenceResult, edges)`
---
 base/compiler/typeinfer.jl | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 7c9871581536a..afae4abc2a07d 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -586,12 +586,9 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
 end
 
 # record the backedges
-function store_backedges(caller::InferenceResult, edges::Vector{Any})
-    isa(caller.linfo.def, Method) || return nothing # don't add backedges to toplevel method instance
-    return store_backedges(caller.linfo, edges)
-end
-
+store_backedges(caller::InferenceResult, edges::Vector{Any}) = store_backedges(caller.linfo, edges)
 function store_backedges(caller::MethodInstance, edges::Vector{Any})
+    isa(caller.def, Method) || return nothing # don't add backedges to toplevel method instance
     for itr in BackedgeIterator(edges)
         callee = itr.caller
         if isa(callee, MethodInstance)

From 8f2f178cc2d2a75607453525260a026e2c38da97 Mon Sep 17 00:00:00 2001
From: jariji <96840304+jariji@users.noreply.github.com>
Date: Wed, 17 Jan 2024 20:17:24 -0800
Subject: [PATCH 0663/1315] Make `hasdoc` public (#52708)

Making `Docs.hasdoc` `public` per @LilithHafner
https://github.com/JuliaLang/julia/pull/52139#issuecomment-1874748877.

---------

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/docs/Docs.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 95724dc97bb73..7ddb556d40871 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -65,7 +65,7 @@ import .Base: Callable, with_output_color
 using .Base: RefValue, mapany
 import ..CoreDocs: lazy_iterpolate
 
-export doc
+export doc, hasdoc, undocumented_names
 
 # Basic API / Storage
 

From 8562af55521e264c7213a0d2c2bcc614a3507900 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 18 Jan 2024 20:01:17 +0900
Subject: [PATCH 0664/1315] minor refactors on REPLCompletions.jl (#52953)

Those I found while working on #52952.
---
 stdlib/REPL/src/REPLCompletions.jl | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 06341361819c1..549488e195d94 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -812,7 +812,7 @@ function complete_any_methods(ex_org::Expr, callee_module::Module, context_modul
             isa(c, TextCompletion) && return false
             isa(c, MethodCompletion) || return true
             sig = Base.unwrap_unionall(c.method.sig)::DataType
-            return !all(T -> T === Any || T === Vararg{Any}, sig.parameters[2:end])
+            return !all(@nospecialize(T) -> T === Any || T === Vararg{Any}, sig.parameters[2:end])
         end
     end
 
@@ -1400,7 +1400,7 @@ function shell_completions(string, pos)
         r = pos+1:pos
         paths, dir, success = complete_path("", use_envpath=false, shell_escape=true)
         return paths, r, success
-    elseif all(arg -> arg isa AbstractString, ex.args)
+    elseif all(@nospecialize(arg) -> arg isa AbstractString, ex.args)
         # Join these and treat this as a path
         path::String = join(ex.args)
         r = last_arg_start:pos
@@ -1479,22 +1479,28 @@ function UndefVarError_hint(io::IO, ex::UndefVarError)
     else
         scope = undef
     end
-    warnfor(m, var) = Base.isbindingresolved(m, var) && (Base.isexported(m, var) || Base.ispublic(m, var)) && (print(io, "\nHint: a global variable of this name also exists in $m."); true)
-    if scope !== Base && !warnfor(Base, var)
+    if scope !== Base && !_UndefVarError_warnfor(Base, var)
         warned = false
         for m in Base.loaded_modules_order
             m === Core && continue
             m === Base && continue
             m === Main && continue
             m === scope && continue
-            warned = warnfor(m, var) || warned
+            warned = _UndefVarError_warnfor(m, var) || warned
         end
-        warned = warned || warnfor(Core, var)
-        warned = warned || warnfor(Main, var)
+        warned = warned || _UndefVarError_warnfor(Core, var)
+        warned = warned || _UndefVarError_warnfor(Main, var)
     end
     nothing
 end
 
+function _UndefVarError_warnfor(io::IO, m::Module, var::Symbol)
+    Base.isbindingresolved(m, var) || return false
+    (Base.isexported(m, var) || Base.ispublic(m, var)) || return false
+    print(io, "\nHint: a global variable of this name also exists in $m.")
+    return true
+end
+
 function __init__()
     Base.Experimental.register_error_hint(UndefVarError_hint, UndefVarError)
     COMPLETION_WORLD[] = Base.get_world_counter()

From 8c49e5e476e3a7a65212f0eedf16557fbf071474 Mon Sep 17 00:00:00 2001
From: Frederik Banning <65158285+fbanning@users.noreply.github.com>
Date: Thu, 18 Jan 2024 15:41:29 +0100
Subject: [PATCH 0665/1315] Fix eachslice docstring typo (#52926)

---
 base/slicearray.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/slicearray.jl b/base/slicearray.jl
index e5a433cdb8d2a..de4272550bdb0 100644
--- a/base/slicearray.jl
+++ b/base/slicearray.jl
@@ -78,7 +78,7 @@ end
     eachslice(A::AbstractArray; dims, drop=true)
 
 Create a [`Slices`](@ref) object that is an array of slices over dimensions `dims` of `A`, returning
-views that select all the data from the other dimensions in `A`. `dims` can either by an
+views that select all the data from the other dimensions in `A`. `dims` can either be an
 integer or a tuple of integers.
 
 If `drop = true` (the default), the outer `Slices` will drop the inner dimensions, and

From a28e553e509ce5f7fc6304c8d361f97958b4196b Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Thu, 18 Jan 2024 16:49:40 +0100
Subject: [PATCH 0666/1315] Remove single-argument methods for `map`,
 `foreach`, `Iterators.map` (#52631)

In the case of `map` and `foreach`, this removes awkward functionality.
`Iterators.map(::Any)`, on the other hand, already threw.
---
 NEWS.md                              |  2 ++
 base/abstractarray.jl                |  9 ++-------
 base/iterators.jl                    |  2 +-
 base/tuple.jl                        |  4 ++--
 stdlib/LinearAlgebra/src/adjtrans.jl | 10 ++++++++--
 test/abstractarray.jl                |  3 +--
 test/functional.jl                   |  3 ---
 test/iterators.jl                    |  9 +++++++++
 8 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 9dba8544cecbf..fed1fae81dd83 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -171,6 +171,8 @@ Standard library changes
 Deprecated or removed
 ---------------------
 
+* `Base.map`, `Iterators.map`, and `foreach` lost their single-argument methods ([#52631]).
+
 
 External dependencies
 ---------------------
diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 743aca7395c91..7248e9f8038e6 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -3108,9 +3108,8 @@ julia> foreach((x, y) -> println(x, " with ", y), tri, 'a':'z')
 7 with c
 ```
 """
-foreach(f) = (f(); nothing)
 foreach(f, itr) = (for x in itr; f(x); end; nothing)
-foreach(f, itrs...) = (for z in zip(itrs...); f(z...); end; nothing)
+foreach(f, itr, itrs...) = (for z in zip(itr, itrs...); f(z...); end; nothing)
 
 ## map over arrays ##
 
@@ -3282,10 +3281,6 @@ end
 concatenate_setindex!(R, v, I...) = (R[I...] .= (v,); R)
 concatenate_setindex!(R, X::AbstractArray, I...) = (R[I...] = X)
 
-## 0 arguments
-
-map(f) = f()
-
 ## 1 argument
 
 function map!(f::F, dest::AbstractArray, A::AbstractArray) where F
@@ -3421,7 +3416,7 @@ julia> map(+, [1 2; 3 4], [1,10,100,1000], zeros(3,1))  # iterates until 3rd is
  102.0
 ```
 """
-map(f, iters...) = collect(Generator(f, iters...))
+map(f, it, iters...) = collect(Generator(f, it, iters...))
 
 # multi-item push!, pushfirst! (built on top of type-specific 1-item version)
 # (note: must not cause a dispatch loop when 1-item case is not defined)
diff --git a/base/iterators.jl b/base/iterators.jl
index 14cbd104c09d1..a03d426e05622 100644
--- a/base/iterators.jl
+++ b/base/iterators.jl
@@ -59,7 +59,7 @@ julia> collect(Iterators.map(x -> x^2, 1:3))
  9
 ```
 """
-map(f, args...) = Base.Generator(f, args...)
+map(f, arg, args...) = Base.Generator(f, arg, args...)
 
 tail_if_any(::Tuple{}) = ()
 tail_if_any(x::Tuple) = tail(x)
diff --git a/base/tuple.jl b/base/tuple.jl
index 19b88234cbb00..274f8d8354890 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -321,7 +321,7 @@ end
 # n argument function
 heads(ts::Tuple...) = map(t -> t[1], ts)
 tails(ts::Tuple...) = map(tail, ts)
-map(f, ::Tuple{}...) = ()
+map(f, ::Tuple{}, ::Tuple{}...) = ()
 anyempty(x::Tuple{}, xs...) = true
 anyempty(x::Tuple, xs...) = anyempty(xs...)
 anyempty() = false
@@ -615,4 +615,4 @@ Return an empty tuple, `()`.
 empty(@nospecialize x::Tuple) = ()
 
 foreach(f, itr::Tuple) = foldl((_, x) -> (f(x); nothing), itr, init=nothing)
-foreach(f, itrs::Tuple...) = foldl((_, xs) -> (f(xs...); nothing), zip(itrs...), init=nothing)
+foreach(f, itr::Tuple, itrs::Tuple...) = foldl((_, xs) -> (f(xs...); nothing), zip(itr, itrs...), init=nothing)
diff --git a/stdlib/LinearAlgebra/src/adjtrans.jl b/stdlib/LinearAlgebra/src/adjtrans.jl
index 5ad678e82f014..24ad7960f00b4 100644
--- a/stdlib/LinearAlgebra/src/adjtrans.jl
+++ b/stdlib/LinearAlgebra/src/adjtrans.jl
@@ -396,8 +396,14 @@ hcat(tvs::Transpose{T,Vector{T}}...) where {T} = _transpose_hcat(tvs...)
 #
 # note that the caller's operation f operates in the domain of the wrapped vectors' entries.
 # hence the adjoint->f->adjoint shenanigans applied to the parent vectors' entries.
-map(f, avs::AdjointAbsVec...) = adjoint(map((xs...) -> adjoint(f(adjoint.(xs)...)), parent.(avs)...))
-map(f, tvs::TransposeAbsVec...) = transpose(map((xs...) -> transpose(f(transpose.(xs)...)), parent.(tvs)...))
+function map(f, av::AdjointAbsVec, avs::AdjointAbsVec...)
+    s = (av, avs...)
+    adjoint(map((xs...) -> adjoint(f(adjoint.(xs)...)), parent.(s)...))
+end
+function map(f, tv::TransposeAbsVec, tvs::TransposeAbsVec...)
+    s = (tv, tvs...)
+    transpose(map((xs...) -> transpose(f(transpose.(xs)...)), parent.(s)...))
+end
 quasiparentt(x) = parent(x); quasiparentt(x::Number) = x # to handle numbers in the defs below
 quasiparenta(x) = parent(x); quasiparenta(x::Number) = conj(x) # to handle numbers in the defs below
 quasiparentc(x) = parent(parent(x)); quasiparentc(x::Number) = conj(x) # to handle numbers in the defs below
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index d1987bbe0b668..21b80c257872f 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -822,9 +822,8 @@ Base.getindex(A::TSlowNIndexes{T,2}, i::Int, j::Int) where {T} = A.data[i,j]
     @test isa(map(Set, Array[[1,2],[3,4]]), Vector{Set{Int}})
 end
 
-@testset "mapping over scalars and empty arguments:" begin
+@testset "mapping over scalars" begin
     @test map(sin, 1) === sin(1)
-    @test map(()->1234) === 1234
 end
 
 function test_UInt_indexing(::Type{TestAbstractArray})
diff --git a/test/functional.jl b/test/functional.jl
index fce64c0e5720a..3436fb8911cc1 100644
--- a/test/functional.jl
+++ b/test/functional.jl
@@ -52,9 +52,6 @@ end
 
 # foreach
 let a = []
-    foreach(()->push!(a,0))
-    @test a == [0]
-    a = []
     foreach(x->push!(a,x), [1,5,10])
     @test a == [1,5,10]
     a = []
diff --git a/test/iterators.jl b/test/iterators.jl
index 74d7d61f0a496..d8184eab7b656 100644
--- a/test/iterators.jl
+++ b/test/iterators.jl
@@ -1010,6 +1010,15 @@ end
     @test collect(Iterators.partition(lstrip("01111", '0'), 2)) == ["11", "11"]
 end
 
+@testset "no single-argument map methods" begin
+    maps = (tuple, Returns(nothing), (() -> nothing))
+    mappers = (Iterators.map, map, foreach)
+    for f ∈ maps, m ∈ mappers
+        @test !applicable(m, f)
+        @test !hasmethod(m, Tuple{typeof(f)})
+    end
+end
+
 @testset "Iterators docstrings" begin
     @test isempty(Docs.undocumented_names(Iterators))
 end

From 877c05ed6caee22957bee18e1b67423fd9817a28 Mon Sep 17 00:00:00 2001
From: "Viral B. Shah" <ViralBShah@users.noreply.github.com>
Date: Thu, 18 Jan 2024 14:10:52 -0500
Subject: [PATCH 0667/1315] Bump to SuiteSparse 7.5.1 (#52960)

---
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 deps/checksums/suitesparse                    | 36 +++++++++++++++++++
 deps/libsuitesparse.version                   |  4 +--
 stdlib/SparseArrays.version                   |  2 +-
 stdlib/SuiteSparse_jll/Project.toml           |  2 +-
 10 files changed, 42 insertions(+), 8 deletions(-)
 create mode 100644 deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/sha512
 delete mode 100644 deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/sha512
 delete mode 100644 deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
 delete mode 100644 deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/md5 b/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/md5
new file mode 100644
index 0000000000000..f1f8bd5b49f78
--- /dev/null
+++ b/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/md5
@@ -0,0 +1 @@
+245fd2ef87631f69e2fb863443b00a0b
diff --git a/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/sha512 b/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/sha512
new file mode 100644
index 0000000000000..06ff2c15103e1
--- /dev/null
+++ b/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/sha512
@@ -0,0 +1 @@
+52a7a0a873d34d33737ad08a91d1a63ba4cde63ced5eca8fb89ecb628ee1a5efb7ab8e0e032737cc6cbf13dd872b0f2548916909ac87bb3d5b28e42072f741e2
diff --git a/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/md5 b/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/md5
deleted file mode 100644
index fb2aeb1b6a051..0000000000000
--- a/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-896b34202308bd40cc9aa26e6bc87c1b
diff --git a/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/sha512 b/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/sha512
deleted file mode 100644
index 00b98b74501dd..0000000000000
--- a/deps/checksums/SparseArrays-63459e5ee9e361dbe7cf260030a7407a1f241430.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-1ff3b84fb03b76bf2d9d04338e9e82fe1ea9a38bc3da09257666362fe722c6e57a133595fe6aa947c7b539f9d43466ff52ba4ec2027a969e44cf6935c461b751
diff --git a/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5 b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
deleted file mode 100644
index 2f81a0d9191b5..0000000000000
--- a/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-46541001073d1c3c85e18d910f8308f3
diff --git a/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512 b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512
deleted file mode 100644
index e2eb44845e276..0000000000000
--- a/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-f7470a447b934ca9315e216a07b97e363f11bc93186f9aa057b20b2d05092c58ae4f1b733de362de4a0730861c00be4ca5588d0b3ba65f018c1798b9122b9672
diff --git a/deps/checksums/suitesparse b/deps/checksums/suitesparse
index c55c22b37ab55..162e9881b41b9 100644
--- a/deps/checksums/suitesparse
+++ b/deps/checksums/suitesparse
@@ -1,3 +1,7 @@
+SuiteSparse-7.5.1.tar.gz/md5/58942756690dfc048a176bbb7dedecf6
+SuiteSparse-7.5.1.tar.gz/sha512/1265ab3795119925dab3bd3a96aed5f48547dc24014f2fd91847ce83f00733caf4ea4026825d01960c2d3a2a316ed3762ed815e9dccc8f7d9dd9e5bd7387c1a1
+SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5/46541001073d1c3c85e18d910f8308f3
+SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512/f7470a447b934ca9315e216a07b97e363f11bc93186f9aa057b20b2d05092c58ae4f1b733de362de4a0730861c00be4ca5588d0b3ba65f018c1798b9122b9672
 SuiteSparse.v7.4.0+2.aarch64-apple-darwin.tar.gz/md5/6f38a9c86969ad3fa2708c461bcd3b2b
 SuiteSparse.v7.4.0+2.aarch64-apple-darwin.tar.gz/sha512/fa15f40456a6bda38f76caa4aedebe30c3bb3e8cf240c0eb2740169d0e7bf2563d6d1ca84233beec99f222852a49d3394b545c7349eb9573bda9bc60d20e348b
 SuiteSparse.v7.4.0+2.aarch64-linux-gnu.tar.gz/md5/8cac9d510a4c3c6e6a9b0f69fe1e0270
@@ -30,3 +34,35 @@ SuiteSparse.v7.4.0+2.x86_64-unknown-freebsd.tar.gz/md5/c358b60fa7e8ba9ece545e6d7
 SuiteSparse.v7.4.0+2.x86_64-unknown-freebsd.tar.gz/sha512/2b93a8c10828eab5948a73b6b800fb321f715468a17142fabd9477543d0312d24fd567fb9fa96372304519ceda2830b259f1da30f943bc9cfa85047e640cf8f7
 SuiteSparse.v7.4.0+2.x86_64-w64-mingw32.tar.gz/md5/924a1a85d178617480178602a2fa2828
 SuiteSparse.v7.4.0+2.x86_64-w64-mingw32.tar.gz/sha512/9e753fffe9a50a3cfd520263b90194555d5f5c9f685b0aaa66ab513b3e0a5529d0efc701650955bf9cf659c930af5357c131591dbd2e02c9e7b4fa03f86a3548
+SuiteSparse.v7.5.1+0.aarch64-apple-darwin.tar.gz/md5/71cafe9018d81e633129be8674001294
+SuiteSparse.v7.5.1+0.aarch64-apple-darwin.tar.gz/sha512/693512198d04639927d0245061b3db4ca23026af3373d47958a94540371f71e546786e55c06637d2ad54d2ef5d3e16a606f6c307f9babf1813528573e7942a63
+SuiteSparse.v7.5.1+0.aarch64-linux-gnu.tar.gz/md5/e8324c4a0a946705be889de3952ad584
+SuiteSparse.v7.5.1+0.aarch64-linux-gnu.tar.gz/sha512/eac5ecc5fa0e781c4b6e5d95ec2e33e436e617f5b8eae7e35fca16c58bbe2d6f7c3ad0c16942f9846f0f0b9696657c869a2fa15b6cd53183b50f4c224f2ce0f4
+SuiteSparse.v7.5.1+0.aarch64-linux-musl.tar.gz/md5/f758985ab451c8fb805b5e6f1389ca0f
+SuiteSparse.v7.5.1+0.aarch64-linux-musl.tar.gz/sha512/0c91411114e91658113c7615b94a93e5a4c8850bbe398e862084003c27d8471af7c17397364784dde59cb88cca79d93acd895d1ff81d7ccdade534de317df3a5
+SuiteSparse.v7.5.1+0.armv6l-linux-gnueabihf.tar.gz/md5/3bc5b6773e5304e4504566804aefe5e3
+SuiteSparse.v7.5.1+0.armv6l-linux-gnueabihf.tar.gz/sha512/1f6e25af8179d915d7765225f7579b4f11bf9806e71ff886921c99c9f8c2b4f3327c9a544e7ee8690a44709292aaa9474718cdbda9ed9cc8648a3f9ee3d74273
+SuiteSparse.v7.5.1+0.armv6l-linux-musleabihf.tar.gz/md5/dbb931d46d094ab573197f8f869d3b5f
+SuiteSparse.v7.5.1+0.armv6l-linux-musleabihf.tar.gz/sha512/ce68ceefcca46ac855142cf896a0490dfc2247560805d44e7b50b967b7b5cdcbf34262327207af24b24c3f068eb2d3248a0f5a61da7ed96be25a334591f32e11
+SuiteSparse.v7.5.1+0.armv7l-linux-gnueabihf.tar.gz/md5/bea7c160cdc4d896ed448631fe6e68ce
+SuiteSparse.v7.5.1+0.armv7l-linux-gnueabihf.tar.gz/sha512/57ab75d68dd7cb8cfce2954c8a86cdff2f4e80043578b7d3086eba02142cfdceb0e9a33f8441f489ca1bcf18670e7cd43b6cde8e9e349e173604619e613e90b0
+SuiteSparse.v7.5.1+0.armv7l-linux-musleabihf.tar.gz/md5/38f91cc6672ce6a84e4e2a272de45b12
+SuiteSparse.v7.5.1+0.armv7l-linux-musleabihf.tar.gz/sha512/66a697403c827115902a6976e9d8e344733723c4a5e03903e6cb0d0e0dce9e48cd0848c500907aa7ba5540a6ecf90c464de5be0f839233388af4459b95eee413
+SuiteSparse.v7.5.1+0.i686-linux-gnu.tar.gz/md5/4d1e621cbfa05dd28b30a1b6e4bcd808
+SuiteSparse.v7.5.1+0.i686-linux-gnu.tar.gz/sha512/322d20a78cf3a305ec9fe3c8158fba2887c682160037bdfe19798b106231366282c804e0a11f1f7c7747c6e7dbf49b01fdf5ceb6806c25d5ed660aa05b04e424
+SuiteSparse.v7.5.1+0.i686-linux-musl.tar.gz/md5/c14baf67cec686827e7d04c997b05f2b
+SuiteSparse.v7.5.1+0.i686-linux-musl.tar.gz/sha512/c9ddffcc0a8a8dbe00bded156f89c2e7278fa47edcaf528d0c829013b68120e3d87c8f3bf254d7a89f7eb8795c0ca3a361a04d935383dcccda2847efa6bda19f
+SuiteSparse.v7.5.1+0.i686-w64-mingw32.tar.gz/md5/8980dc09d1e170157595d337b52dde44
+SuiteSparse.v7.5.1+0.i686-w64-mingw32.tar.gz/sha512/f132bbf9e632f01327822bc6a3b69ccabb4ecdea17e91de1e18f76f3eb634281218902e4b80a1c1cda6e0897f01cbf0e7dcf15859aed53022e73280cdc07cc8d
+SuiteSparse.v7.5.1+0.powerpc64le-linux-gnu.tar.gz/md5/11f2e1b1dc7fd4984b7999f2fba11a9f
+SuiteSparse.v7.5.1+0.powerpc64le-linux-gnu.tar.gz/sha512/5497e623b7df790b013e295b80042b5a304809159d9b9d22f61c120b9753ee12bf0ef63c765d188bd44e094cac18202ea7496110ee2215c6b1ae88fd722a4007
+SuiteSparse.v7.5.1+0.x86_64-apple-darwin.tar.gz/md5/421a7f24c29640be6bb3cfaa7614aee9
+SuiteSparse.v7.5.1+0.x86_64-apple-darwin.tar.gz/sha512/5e578b5c050af37681228bdaa1ad7c92e88c20c31fe402e1b623d78c1e837072927aed40f0281e6467d5e6101a49e3554c04b6e8948bf31fb11e9e303ba39892
+SuiteSparse.v7.5.1+0.x86_64-linux-gnu.tar.gz/md5/7e5dcb0d632cce77e3edc898b3576201
+SuiteSparse.v7.5.1+0.x86_64-linux-gnu.tar.gz/sha512/1d13e4130af8a389378b4e781e28518c9be0a5141ac96012984675014bc753f7de2817d49bad04b91306f519a13066c81f2ac48b8e3f6364031c6237f7181dc0
+SuiteSparse.v7.5.1+0.x86_64-linux-musl.tar.gz/md5/fc49feee13cd9c0db0f0264dd121602d
+SuiteSparse.v7.5.1+0.x86_64-linux-musl.tar.gz/sha512/3fd0cb57a8c88dc9e289a05575d2a2b83916c057e2c990ab57ad941ea8352e219387ece0115030eb41c9d9c9289e4425be6ec655a50748a4190924d3a9b079c0
+SuiteSparse.v7.5.1+0.x86_64-unknown-freebsd.tar.gz/md5/7f1dd8357b8ad5972ce22f843e1b79ba
+SuiteSparse.v7.5.1+0.x86_64-unknown-freebsd.tar.gz/sha512/952bcee00bab30868463329f2f12003b6ee3ceb0bba4c7b291ade490e23e277a80d127d03797fcb91ffb2af4c94411abee573100c9413d50cdd9e835fb63cbb5
+SuiteSparse.v7.5.1+0.x86_64-w64-mingw32.tar.gz/md5/3e2f5c42edc75bdbcb6da7f886ee6522
+SuiteSparse.v7.5.1+0.x86_64-w64-mingw32.tar.gz/sha512/768b0f39cb0182d6424255e848020bac0d55cd0be2b30d40dd7f4f5a7ac18971f53aeecb87d8b45e7dbe5ba3cfe318aecfe2c02eb27375b9a8adcad791f692bc
diff --git a/deps/libsuitesparse.version b/deps/libsuitesparse.version
index ca38a96fb0ed3..28adbba97e5c6 100644
--- a/deps/libsuitesparse.version
+++ b/deps/libsuitesparse.version
@@ -4,5 +4,5 @@
 LIBSUITESPARSE_JLL_NAME := SuiteSparse
 
 ## source build
-LIBSUITESPARSE_VER := 7.4.0
-LIBSUITESPARSE_SHA1=df91d7be262e6b5cddf5dd23ff42dec1713e7947
+LIBSUITESPARSE_VER := 7.5.1
+LIBSUITESPARSE_SHA1=71d6d42cb60b533bd001d3e5514e11120919c43a
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index a6b0deb355c0f..bc744a15c601c 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 63459e5ee9e361dbe7cf260030a7407a1f241430
+SPARSEARRAYS_SHA1 = 46cb50099094cdcf4a1789047e360914ce6f39e3
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1
diff --git a/stdlib/SuiteSparse_jll/Project.toml b/stdlib/SuiteSparse_jll/Project.toml
index 787162c090f20..93a594d0b7537 100644
--- a/stdlib/SuiteSparse_jll/Project.toml
+++ b/stdlib/SuiteSparse_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "SuiteSparse_jll"
 uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
-version = "7.4.0+2"
+version = "7.5.1+0"
 
 [deps]
 libblastrampoline_jll = "8e850b90-86db-534c-a0d3-1478176c7d93"

From 607b2b90738158cc7d0c8b839f8ee83223a0f693 Mon Sep 17 00:00:00 2001
From: "Viral B. Shah" <ViralBShah@users.noreply.github.com>
Date: Thu, 18 Jan 2024 14:51:44 -0500
Subject: [PATCH 0668/1315] Bump SparseArrays to latest master at f37477
 (#52968)

@DilumAluthge BumpStdlibs did not work:
https://github.com/JuliaLang/BumpStdlibs.jl/actions/runs/7574895316/job/20630289750
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/SparseArrays.version                                     | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/sha512
 create mode 100644 deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/md5 b/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/md5
deleted file mode 100644
index f1f8bd5b49f78..0000000000000
--- a/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-245fd2ef87631f69e2fb863443b00a0b
diff --git a/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/sha512 b/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/sha512
deleted file mode 100644
index 06ff2c15103e1..0000000000000
--- a/deps/checksums/SparseArrays-46cb50099094cdcf4a1789047e360914ce6f39e3.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-52a7a0a873d34d33737ad08a91d1a63ba4cde63ced5eca8fb89ecb628ee1a5efb7ab8e0e032737cc6cbf13dd872b0f2548916909ac87bb3d5b28e42072f741e2
diff --git a/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/md5 b/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/md5
new file mode 100644
index 0000000000000..b7c00193592cf
--- /dev/null
+++ b/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/md5
@@ -0,0 +1 @@
+b03c158b11d19bd46430692cd8fde54a
diff --git a/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/sha512 b/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/sha512
new file mode 100644
index 0000000000000..3b4444daea951
--- /dev/null
+++ b/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/sha512
@@ -0,0 +1 @@
+f869333b0c568fa3bfa9a70188069bf61c712159e6f4451f806e396db58825c8fbfc1127de84b6f9ea1fb80b79c947631a5c186c11bb8eeef89aaa1161e55511
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index bc744a15c601c..2f7358219ca25 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 46cb50099094cdcf4a1789047e360914ce6f39e3
+SPARSEARRAYS_SHA1 = f37477bc4881e9c540573aecb9e5809bbc306c79
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From 3a63f25fd58875e732e9ce8cbb9ad8b6905bf460 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 19 Jan 2024 08:10:57 +0900
Subject: [PATCH 0669/1315] fixup! #52953, follow up the refactor on
 REPLCompletions.jl (#52959)

---
 stdlib/REPL/src/REPLCompletions.jl |  9 +++++----
 stdlib/REPL/test/repl.jl           | 21 +++++++++++++++++++++
 2 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 549488e195d94..958f231aa5b0d 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -1479,17 +1479,18 @@ function UndefVarError_hint(io::IO, ex::UndefVarError)
     else
         scope = undef
     end
-    if scope !== Base && !_UndefVarError_warnfor(Base, var)
+    if scope !== Base && !_UndefVarError_warnfor(io, Base, var)
         warned = false
         for m in Base.loaded_modules_order
             m === Core && continue
             m === Base && continue
             m === Main && continue
             m === scope && continue
-            warned = _UndefVarError_warnfor(m, var) || warned
+            warned |= _UndefVarError_warnfor(io, m, var)
         end
-        warned = warned || _UndefVarError_warnfor(Core, var)
-        warned = warned || _UndefVarError_warnfor(Main, var)
+        warned ||
+            _UndefVarError_warnfor(io, Core, var) ||
+            _UndefVarError_warnfor(io, Main, var)
     end
     nothing
 end
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index f16ac0e07689a..05ff66229ed2c 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -1675,6 +1675,27 @@ fake_repl() do stdin_write, stdout_read, repl
     @test contains(txt, "Some type information was truncated. Use `show(err)` to see complete types.")
 end
 
+try # test the functionality of `UndefVarError_hint` against `Base.remove_linenums!`
+    @assert isempty(Base.Experimental._hint_handlers)
+    Base.Experimental.register_error_hint(REPL.REPLCompletions.UndefVarError_hint, UndefVarError)
+
+    # check the requirement to trigger the hint via `UndefVarError_hint`
+    @test !isdefined(Main, :remove_linenums!) && Base.ispublic(Base, :remove_linenums!)
+
+    fake_repl() do stdin_write, stdout_read, repl
+        backend = REPL.REPLBackend()
+        repltask = @async REPL.run_repl(repl; backend)
+        write(stdin_write,
+              "remove_linenums!\n\"ZZZZZ\"\n")
+        txt = readuntil(stdout_read, "ZZZZZ")
+        write(stdin_write, '\x04')
+        wait(repltask)
+        @test occursin("Hint: a global variable of this name also exists in Base.", txt)
+    end
+finally
+    empty!(Base.Experimental._hint_handlers)
+end
+
 # Hints for tab completes
 
 fake_repl() do stdin_write, stdout_read, repl

From a0d55cd4b53adf91770ff5cbdab5b30ba81fbe96 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 19 Jan 2024 08:13:58 +0900
Subject: [PATCH 0670/1315] [REPLCompletions] enable completions for `using
 Module.Inner|` (#52952)

---
 stdlib/REPL/src/REPLCompletions.jl  | 53 +++++++++++++++++++++++++----
 stdlib/REPL/test/replcompletions.jl | 44 ++++++++++++++++++++++++
 2 files changed, 90 insertions(+), 7 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 958f231aa5b0d..4bcba3d183e5c 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -1090,7 +1090,10 @@ function project_deps_get_completion_candidates(pkgstarts::String, project_file:
     return Completion[PackageCompletion(name) for name in loading_candidates]
 end
 
-function complete_identifiers!(suggestions::Vector{Completion}, @nospecialize(ffunc::Function), context_module::Module, string::String, name::String, pos::Int, dotpos::Int, startpos::Int, comp_keywords=false)
+function complete_identifiers!(suggestions::Vector{Completion}, @nospecialize(ffunc),
+                               context_module::Module, string::String, name::String,
+                               pos::Int, dotpos::Int, startpos::Int;
+                               comp_keywords=false)
     ex = nothing
     if comp_keywords
         append!(suggestions, complete_keyword(name))
@@ -1132,10 +1135,41 @@ function complete_identifiers!(suggestions::Vector{Completion}, @nospecialize(ff
             if something(findlast(in(non_identifier_chars), s), 0) < something(findlast(isequal('.'), s), 0)
                 lookup_name, name = rsplit(s, ".", limit=2)
                 name = String(name)
-
                 ex = Meta.parse(lookup_name, raise=false, depwarn=false)
             end
             isexpr(ex, :incomplete) && (ex = nothing)
+        elseif isexpr(ex, (:using, :import))
+            arg1 = ex.args[1]
+            if isexpr(arg1, :.)
+                # We come here for cases like:
+                # - `string`: "using Mod1.Mod2.M"
+                # - `ex`: :(using Mod1.Mod2)
+                # - `name`: "M"
+                # Now we transform `ex` to `:(Mod1.Mod2)` to allow `complete_symbol` to
+                # complete for inner modules whose name starts with `M`.
+                # Note that `ffunc` is set to `module_filter` within `completions`
+                ex = nothing
+                firstdot = true
+                for arg = arg1.args
+                    if arg === :.
+                        # override `context_module` if multiple `.` accessors are used
+                        if firstdot
+                            firstdot = false
+                        else
+                            context_module = parentmodule(context_module)
+                        end
+                    elseif arg isa Symbol
+                        if ex === nothing
+                            ex = arg
+                        else
+                            ex = Expr(:., out, QuoteNode(arg))
+                        end
+                    else # invalid expression
+                        ex = nothing
+                        break
+                    end
+                end
+            end
         elseif isexpr(ex, :call) && length(ex.args) > 1
             isinfix = s[end] != ')'
             # A complete call expression that does not finish with ')' is an infix call.
@@ -1216,8 +1250,9 @@ function completions(string::String, pos::Int, context_module::Module=Main, shif
         ok && return ret
         startpos = first(varrange) + 4
         dotpos = something(findprev(isequal('.'), string, first(varrange)-1), 0)
-        return complete_identifiers!(Completion[], ffunc, context_module, string,
-            string[startpos:pos], pos, dotpos, startpos)
+        name = string[startpos:pos]
+        return complete_identifiers!(Completion[], ffunc, context_module, string, name, pos,
+                                     dotpos, startpos)
     elseif inc_tag === :cmd
         # TODO: should this call shell_completions instead of partially reimplementing it?
         let m = match(r"[\t\n\r\"`><=*?|]| (?!\\)", reverse(partial)) # fuzzy shell_parse in reverse
@@ -1365,16 +1400,20 @@ function completions(string::String, pos::Int, context_module::Module=Main, shif
                 end
             end
         end
-        ffunc = (mod,x)->(Base.isbindingresolved(mod, x) && isdefined(mod, x) && isa(getfield(mod, x), Module))
+        ffunc = module_filter
         comp_keywords = false
     end
 
     startpos == 0 && (pos = -1)
     dotpos < startpos && (dotpos = startpos - 1)
-    return complete_identifiers!(suggestions, ffunc, context_module, string,
-        name, pos, dotpos, startpos, comp_keywords)
+    return complete_identifiers!(suggestions, ffunc, context_module, string, name, pos,
+                                 dotpos, startpos;
+                                 comp_keywords)
 end
 
+module_filter(mod::Module, x::Symbol) =
+    Base.isbindingresolved(mod, x) && isdefined(mod, x) && isa(getglobal(mod, x), Module)
+
 function shell_completions(string, pos)
     # First parse everything up to the current position
     scs = string[1:pos]
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 1de42f86d2283..280b23a68c4e2 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2203,3 +2203,47 @@ replinterp_invalidation_caller() = replinterp_invalidation_callee().value
 @test REPLCompletions.repl_eval_ex(:(replinterp_invalidation_caller()), @__MODULE__) == Regex
 replinterp_invalidation_callee(c::Bool=rand(Bool)) = Some(c ? "foo" : "bar")
 @test REPLCompletions.repl_eval_ex(:(replinterp_invalidation_caller()), @__MODULE__) == String
+
+# JuliaLang/julia#52922
+let s = "using Base.Th"
+    c, r, res = test_complete_context(s)
+    @test res
+    @test "Threads" in c
+end
+let s = "using Base."
+    c, r, res = test_complete_context(s)
+    @test res
+    @test "BinaryPlatforms" in c
+end
+# test cases with the `.` accessor
+module Issue52922
+module Inner1
+module Inner12 end
+end
+module Inner2 end
+end
+let s = "using .Iss"
+    c, r, res = test_complete_context(s)
+    @test res
+    @test "Issue52922" in c
+end
+let s = "using .Issue52922.Inn"
+    c, r, res = test_complete_context(s)
+    @test res
+    @test "Inner1" in c
+end
+let s = "using .Inner1.Inn"
+    c, r, res = test_complete_context(s, Issue52922)
+    @test res
+    @test "Inner12" in c
+end
+let s = "using ..Issue52922.Inn"
+    c, r, res = test_complete_context(s, Issue52922.Inner1)
+    @test res
+    @test "Inner2" in c
+end
+let s = "using ...Issue52922.Inn"
+    c, r, res = test_complete_context(s, Issue52922.Inner1.Inner12)
+    @test res
+    @test "Inner2" in c
+end

From ab9573f8e6b3b4091e18cb3cc84693b7fca0af14 Mon Sep 17 00:00:00 2001
From: William Moses <gh@wsmoses.com>
Date: Thu, 18 Jan 2024 20:47:11 -0500
Subject: [PATCH 0671/1315] Add option to disable vector pipeline (#52544)

This will allow tools like Enzyme to use the internal julia pass
pipeline, rather than having their own version.
---
 src/codegen-stubs.c |   3 +-
 src/jitlayers.h     |  24 ++-
 src/pipeline.cpp    | 381 ++++++++++++++++++++++++--------------------
 3 files changed, 234 insertions(+), 174 deletions(-)

diff --git a/src/codegen-stubs.c b/src/codegen-stubs.c
index 0ce3a9b188df2..26b8226b6e4be 100644
--- a/src/codegen-stubs.c
+++ b/src/codegen-stubs.c
@@ -107,8 +107,7 @@ JL_DLLEXPORT uint64_t jl_getUnwindInfo_fallback(uint64_t dwAddr)
     return 0;
 }
 
-JL_DLLEXPORT void jl_build_newpm_pipeline_fallback(void *MPM, void *PB, int Speedup, int Size,
-    int lower_intrinsics, int dump_native, int external_use, int llvm_only) UNAVAILABLE
+JL_DLLEXPORT void jl_build_newpm_pipeline_fallback(void *MPM, void *PB, void *config) UNAVAILABLE
 
 JL_DLLEXPORT void jl_register_passbuilder_callbacks_fallback(void *PB) { }
 
diff --git a/src/jitlayers.h b/src/jitlayers.h
index 35d950f82f38a..d0de6829804df 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -90,13 +90,33 @@ struct OptimizationOptions {
     bool dump_native;
     bool external_use;
     bool llvm_only;
+    bool always_inline;
+    bool enable_early_simplifications;
+    bool enable_early_optimizations;
+    bool enable_scalar_optimizations;
+    bool enable_loop_optimizations;
+    bool enable_vector_pipeline;
+    bool remove_ni;
+    bool cleanup;
 
     static constexpr OptimizationOptions defaults(
         bool lower_intrinsics=true,
         bool dump_native=false,
         bool external_use=false,
-        bool llvm_only=false) {
-        return {lower_intrinsics, dump_native, external_use, llvm_only};
+        bool llvm_only=false,
+        bool always_inline=true,
+        bool enable_early_simplifications=true,
+        bool enable_early_optimizations=true,
+        bool enable_scalar_optimizations=true,
+        bool enable_loop_optimizations=true,
+        bool enable_vector_pipeline=true,
+        bool remove_ni=true,
+        bool cleanup=true) {
+        return {lower_intrinsics, dump_native, external_use, llvm_only,
+                always_inline, enable_early_simplifications,
+                enable_early_optimizations, enable_scalar_optimizations,
+                enable_loop_optimizations, enable_vector_pipeline,
+                remove_ni, cleanup};
     }
 };
 
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index c4b07914907e6..81f68df0c8870 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -338,190 +338,200 @@ static void buildEarlySimplificationPipeline(ModulePassManager &MPM, PassBuilder
 #ifdef JL_DEBUG_BUILD
     addVerificationPasses(MPM, options.llvm_only);
 #endif
-    // Place after verification in case we want to force it anyways
-    MPM.addPass(ForceFunctionAttrsPass());
-    invokePipelineStartCallbacks(MPM, PB, O);
-    MPM.addPass(Annotation2MetadataPass());
-    MPM.addPass(ConstantMergePass());
-    {
-        FunctionPassManager FPM;
-        FPM.addPass(LowerExpectIntrinsicPass());
-        if (O.getSpeedupLevel() >= 2) {
-            JULIA_PASS(FPM.addPass(PropagateJuliaAddrspacesPass()));
-        }
-        // DCE must come before simplifycfg
-        // codegen can generate unused statements when generating builtin calls,
-        // and those dead statements can alter how simplifycfg optimizes the CFG
-        FPM.addPass(DCEPass());
-        FPM.addPass(SimplifyCFGPass(basicSimplifyCFGOptions()));
-        if (O.getSpeedupLevel() >= 1) {
+    if (options.enable_early_simplifications) {
+      // Place after verification in case we want to force it anyways
+      MPM.addPass(ForceFunctionAttrsPass());
+      invokePipelineStartCallbacks(MPM, PB, O);
+      MPM.addPass(Annotation2MetadataPass());
+      MPM.addPass(ConstantMergePass());
+      {
+          FunctionPassManager FPM;
+          FPM.addPass(LowerExpectIntrinsicPass());
+          if (O.getSpeedupLevel() >= 2) {
+              JULIA_PASS(FPM.addPass(PropagateJuliaAddrspacesPass()));
+          }
+          // DCE must come before simplifycfg
+          // codegen can generate unused statements when generating builtin calls,
+          // and those dead statements can alter how simplifycfg optimizes the CFG
+          FPM.addPass(DCEPass());
+          FPM.addPass(SimplifyCFGPass(basicSimplifyCFGOptions()));
+          if (O.getSpeedupLevel() >= 1) {
 #if JL_LLVM_VERSION >= 160000
-            // TODO check the LLVM 15 default.
-            FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
+              // TODO check the LLVM 15 default.
+              FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
 #else
-            FPM.addPass(SROAPass());
+              FPM.addPass(SROAPass());
 #endif
-        }
-        MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+          }
+          MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+      }
+      invokeEarlySimplificationCallbacks(MPM, PB, O);
     }
-    invokeEarlySimplificationCallbacks(MPM, PB, O);
     MPM.addPass(AfterEarlySimplificationMarkerPass());
 }
 
 static void buildEarlyOptimizerPipeline(ModulePassManager &MPM, PassBuilder *PB, OptimizationLevel O, const OptimizationOptions &options) JL_NOTSAFEPOINT {
     MPM.addPass(BeforeEarlyOptimizationMarkerPass());
-    invokeOptimizerEarlyCallbacks(MPM, PB, O);
-    {
-        CGSCCPassManager CGPM;
-        invokeCGSCCCallbacks(CGPM, PB, O);
-        if (O.getSpeedupLevel() >= 2) {
-            FunctionPassManager FPM;
-            JULIA_PASS(FPM.addPass(AllocOptPass()));
-            FPM.addPass(Float2IntPass());
-            FPM.addPass(LowerConstantIntrinsicsPass());
-            CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
-        }
-        MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
-    }
-    if (O.getSpeedupLevel() >= 2) {
-        MPM.addPass(RequireAnalysisPass<GlobalsAA, Module>());
-    }
-    // MPM.addPass(createModuleToFunctionPassAdaptor(InvalidateAnalysisPass<AAManager>()));
-    if (options.dump_native) {
-        MPM.addPass(StripDeadPrototypesPass());
-        JULIA_PASS(MPM.addPass(MultiVersioningPass(options.external_use)));
-    }
-    JULIA_PASS(MPM.addPass(CPUFeaturesPass()));
-    if (O.getSpeedupLevel() >= 1) {
-        FunctionPassManager FPM;
-        if (O.getSpeedupLevel() >= 2) {
+    if (options.enable_early_optimizations) {
+      invokeOptimizerEarlyCallbacks(MPM, PB, O);
+      {
+          CGSCCPassManager CGPM;
+          invokeCGSCCCallbacks(CGPM, PB, O);
+          if (O.getSpeedupLevel() >= 2) {
+              FunctionPassManager FPM;
+              JULIA_PASS(FPM.addPass(AllocOptPass()));
+              FPM.addPass(Float2IntPass());
+              FPM.addPass(LowerConstantIntrinsicsPass());
+              CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
+          }
+          MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
+      }
+      if (O.getSpeedupLevel() >= 2) {
+          MPM.addPass(RequireAnalysisPass<GlobalsAA, Module>());
+      }
+      // MPM.addPass(createModuleToFunctionPassAdaptor(InvalidateAnalysisPass<AAManager>()));
+      if (options.dump_native) {
+          MPM.addPass(StripDeadPrototypesPass());
+          JULIA_PASS(MPM.addPass(MultiVersioningPass(options.external_use)));
+      }
+      JULIA_PASS(MPM.addPass(CPUFeaturesPass()));
+      if (O.getSpeedupLevel() >= 1) {
+          FunctionPassManager FPM;
+          if (O.getSpeedupLevel() >= 2) {
 #if JL_LLVM_VERSION >= 160000
-            // TODO check the LLVM 15 default.
-            FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
+              // TODO check the LLVM 15 default.
+              FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
 #else
-            FPM.addPass(SROAPass());
+              FPM.addPass(SROAPass());
 #endif
-            // SROA can duplicate PHI nodes which can block LowerSIMD
-            FPM.addPass(InstCombinePass());
-            FPM.addPass(JumpThreadingPass());
-            FPM.addPass(CorrelatedValuePropagationPass());
-            FPM.addPass(ReassociatePass());
-            FPM.addPass(EarlyCSEPass());
-            JULIA_PASS(FPM.addPass(AllocOptPass()));
-        } else { // if (O.getSpeedupLevel() >= 1) (exactly)
-            FPM.addPass(InstCombinePass());
-            FPM.addPass(EarlyCSEPass());
-        }
-        invokePeepholeEPCallbacks(FPM, PB, O);
-        MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+              // SROA can duplicate PHI nodes which can block LowerSIMD
+              FPM.addPass(InstCombinePass());
+              FPM.addPass(JumpThreadingPass());
+              FPM.addPass(CorrelatedValuePropagationPass());
+              FPM.addPass(ReassociatePass());
+              FPM.addPass(EarlyCSEPass());
+              JULIA_PASS(FPM.addPass(AllocOptPass()));
+          } else { // if (O.getSpeedupLevel() >= 1) (exactly)
+              FPM.addPass(InstCombinePass());
+              FPM.addPass(EarlyCSEPass());
+          }
+          invokePeepholeEPCallbacks(FPM, PB, O);
+          MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+      }
+      MPM.addPass(GlobalDCEPass());
     }
-    MPM.addPass(GlobalDCEPass());
     MPM.addPass(AfterEarlyOptimizationMarkerPass());
 }
 
 static void buildLoopOptimizerPipeline(FunctionPassManager &FPM, PassBuilder *PB, OptimizationLevel O, const OptimizationOptions &options) JL_NOTSAFEPOINT {
     FPM.addPass(BeforeLoopOptimizationMarkerPass());
-    {
-        LoopPassManager LPM;
-        LPM.addPass(LowerSIMDLoopPass());
+    if (options.enable_loop_optimizations) {
+        {
+            LoopPassManager LPM;
+            LPM.addPass(LowerSIMDLoopPass());
+            if (O.getSpeedupLevel() >= 2) {
+                LPM.addPass(LoopRotatePass());
+            }
+            invokeLateLoopOptimizationCallbacks(LPM, PB, O);
+            //We don't know if the loop callbacks support MSSA
+            FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA = */false));
+        }
         if (O.getSpeedupLevel() >= 2) {
-            LPM.addPass(LoopRotatePass());
+            LoopPassManager LPM;
+            LPM.addPass(BeforeLICMMarkerPass());
+            LPM.addPass(LICMPass(LICMOptions()));
+            LPM.addPass(JuliaLICMPass());
+            LPM.addPass(SimpleLoopUnswitchPass(/*NonTrivial*/true, true));
+            LPM.addPass(LICMPass(LICMOptions()));
+            LPM.addPass(JuliaLICMPass());
+            LPM.addPass(AfterLICMMarkerPass());
+            //LICM needs MemorySSA now, so we must use it
+            FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA = */true));
         }
-        invokeLateLoopOptimizationCallbacks(LPM, PB, O);
-        //We don't know if the loop callbacks support MSSA
-        FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA = */false));
-    }
-    if (O.getSpeedupLevel() >= 2) {
-        LoopPassManager LPM;
-        LPM.addPass(BeforeLICMMarkerPass());
-        LPM.addPass(LICMPass(LICMOptions()));
-        LPM.addPass(JuliaLICMPass());
-        LPM.addPass(SimpleLoopUnswitchPass(/*NonTrivial*/true, true));
-        LPM.addPass(LICMPass(LICMOptions()));
-        LPM.addPass(JuliaLICMPass());
-        LPM.addPass(AfterLICMMarkerPass());
-        //LICM needs MemorySSA now, so we must use it
-        FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA = */true));
-    }
-    if (O.getSpeedupLevel() >= 2) {
-        FPM.addPass(IRCEPass());
-    }
-    {
-        LoopPassManager LPM;
-        LPM.addPass(BeforeLoopSimplificationMarkerPass());
         if (O.getSpeedupLevel() >= 2) {
-            LPM.addPass(LoopInstSimplifyPass());
-            LPM.addPass(LoopIdiomRecognizePass());
-            LPM.addPass(IndVarSimplifyPass());
-            LPM.addPass(LoopDeletionPass());
-            // This unroll will only unroll loops when the trip count is known and small,
-            // so that no loop remains
-            LPM.addPass(LoopFullUnrollPass());
+            FPM.addPass(IRCEPass());
+        }
+        {
+            LoopPassManager LPM;
+            LPM.addPass(BeforeLoopSimplificationMarkerPass());
+            if (O.getSpeedupLevel() >= 2) {
+                LPM.addPass(LoopInstSimplifyPass());
+                LPM.addPass(LoopIdiomRecognizePass());
+                LPM.addPass(IndVarSimplifyPass());
+                LPM.addPass(LoopDeletionPass());
+                // This unroll will only unroll loops when the trip count is known and small,
+                // so that no loop remains
+                LPM.addPass(LoopFullUnrollPass());
+            }
+            invokeLoopOptimizerEndCallbacks(LPM, PB, O);
+            LPM.addPass(AfterLoopSimplificationMarkerPass());
+            //We don't know if the loop end callbacks support MSSA
+            FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA = */false));
         }
-        invokeLoopOptimizerEndCallbacks(LPM, PB, O);
-        LPM.addPass(AfterLoopSimplificationMarkerPass());
-        //We don't know if the loop end callbacks support MSSA
-        FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), /*UseMemorySSA = */false));
     }
     FPM.addPass(AfterLoopOptimizationMarkerPass());
 }
 
 static void buildScalarOptimizerPipeline(FunctionPassManager &FPM, PassBuilder *PB, OptimizationLevel O, const OptimizationOptions &options) JL_NOTSAFEPOINT {
     FPM.addPass(BeforeScalarOptimizationMarkerPass());
-    if (O.getSpeedupLevel() >= 2) {
-        JULIA_PASS(FPM.addPass(AllocOptPass()));
-#if JL_LLVM_VERSION >= 160000
-        // TODO check the LLVM 15 default.
-        FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
-#else
-        FPM.addPass(SROAPass());
-#endif
-        FPM.addPass(InstSimplifyPass());
-        FPM.addPass(GVNPass());
-        FPM.addPass(MemCpyOptPass());
-        FPM.addPass(SCCPPass());
-        FPM.addPass(CorrelatedValuePropagationPass());
-        FPM.addPass(DCEPass());
-        FPM.addPass(IRCEPass());
-        FPM.addPass(InstCombinePass());
-        FPM.addPass(JumpThreadingPass());
-    }
-    if (O.getSpeedupLevel() >= 3) {
-        FPM.addPass(GVNPass());
-    }
-    if (O.getSpeedupLevel() >= 2) {
-        FPM.addPass(DSEPass());
-        invokePeepholeEPCallbacks(FPM, PB, O);
-        FPM.addPass(SimplifyCFGPass(aggressiveSimplifyCFGOptions()));
-        JULIA_PASS(FPM.addPass(AllocOptPass()));
-        {
-            LoopPassManager LPM;
-            LPM.addPass(LoopDeletionPass());
-            LPM.addPass(LoopInstSimplifyPass());
-            FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
+    if (options.enable_scalar_optimizations) {
+        if (O.getSpeedupLevel() >= 2) {
+            JULIA_PASS(FPM.addPass(AllocOptPass()));
+    #if JL_LLVM_VERSION >= 160000
+            // TODO check the LLVM 15 default.
+            FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
+    #else
+            FPM.addPass(SROAPass());
+    #endif
+            FPM.addPass(InstSimplifyPass());
+            FPM.addPass(GVNPass());
+            FPM.addPass(MemCpyOptPass());
+            FPM.addPass(SCCPPass());
+            FPM.addPass(CorrelatedValuePropagationPass());
+            FPM.addPass(DCEPass());
+            FPM.addPass(IRCEPass());
+            FPM.addPass(InstCombinePass());
+            FPM.addPass(JumpThreadingPass());
+        }
+        if (O.getSpeedupLevel() >= 3) {
+            FPM.addPass(GVNPass());
         }
-        FPM.addPass(LoopDistributePass());
+        if (O.getSpeedupLevel() >= 2) {
+            FPM.addPass(DSEPass());
+            invokePeepholeEPCallbacks(FPM, PB, O);
+            FPM.addPass(SimplifyCFGPass(aggressiveSimplifyCFGOptions()));
+            JULIA_PASS(FPM.addPass(AllocOptPass()));
+            {
+                LoopPassManager LPM;
+                LPM.addPass(LoopDeletionPass());
+                LPM.addPass(LoopInstSimplifyPass());
+                FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
+            }
+            FPM.addPass(LoopDistributePass());
+        }
+        invokeScalarOptimizerCallbacks(FPM, PB, O);
     }
-    invokeScalarOptimizerCallbacks(FPM, PB, O);
     FPM.addPass(AfterScalarOptimizationMarkerPass());
 }
 
 static void buildVectorPipeline(FunctionPassManager &FPM, PassBuilder *PB, OptimizationLevel O, const OptimizationOptions &options) JL_NOTSAFEPOINT {
     FPM.addPass(BeforeVectorizationMarkerPass());
-    //TODO look into loop vectorize options
-    FPM.addPass(InjectTLIMappings());
-    FPM.addPass(LoopVectorizePass());
-    FPM.addPass(LoopLoadEliminationPass());
-    FPM.addPass(InstCombinePass());
-    FPM.addPass(SimplifyCFGPass(aggressiveSimplifyCFGOptions()));
-    FPM.addPass(SLPVectorizerPass());
-    invokeVectorizerCallbacks(FPM, PB, O);
-    FPM.addPass(VectorCombinePass());
-    FPM.addPass(ADCEPass());
-    //TODO add BDCEPass here?
-    // This unroll will unroll vectorized loops
-    // as well as loops that we tried but failed to vectorize
-    FPM.addPass(LoopUnrollPass(LoopUnrollOptions(O.getSpeedupLevel(), /*OnlyWhenForced = */ false, /*ForgetSCEV = */false)));
+    if (options.enable_vector_pipeline) {
+        //TODO look into loop vectorize options
+        FPM.addPass(InjectTLIMappings());
+        FPM.addPass(LoopVectorizePass());
+        FPM.addPass(LoopLoadEliminationPass());
+        FPM.addPass(InstCombinePass());
+        FPM.addPass(SimplifyCFGPass(aggressiveSimplifyCFGOptions()));
+        FPM.addPass(SLPVectorizerPass());
+        invokeVectorizerCallbacks(FPM, PB, O);
+        FPM.addPass(VectorCombinePass());
+        FPM.addPass(ADCEPass());
+        //TODO add BDCEPass here?
+        // This unroll will unroll vectorized loops
+        // as well as loops that we tried but failed to vectorize
+        FPM.addPass(LoopUnrollPass(LoopUnrollOptions(O.getSpeedupLevel(), /*OnlyWhenForced = */ false, /*ForgetSCEV = */false)));
+    }
     FPM.addPass(AfterVectorizationMarkerPass());
 }
 
@@ -537,6 +547,7 @@ static void buildIntrinsicLoweringPipeline(ModulePassManager &MPM, PassBuilder *
         }
         // Needed **before** LateLowerGCFrame on LLVM < 12
         // due to bug in `CreateAlignmentAssumption`.
+        assert(options.remove_ni);
         JULIA_PASS(MPM.addPass(RemoveNIPass()));
         {
             FunctionPassManager FPM;
@@ -557,7 +568,7 @@ static void buildIntrinsicLoweringPipeline(ModulePassManager &MPM, PassBuilder *
             FPM.addPass(SimplifyCFGPass(aggressiveSimplifyCFGOptions()));
             MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
         }
-    } else {
+    } else if (!options.remove_ni) {
         JULIA_PASS(MPM.addPass(RemoveNIPass()));
     }
     MPM.addPass(AfterIntrinsicLoweringMarkerPass());
@@ -565,22 +576,24 @@ static void buildIntrinsicLoweringPipeline(ModulePassManager &MPM, PassBuilder *
 
 static void buildCleanupPipeline(ModulePassManager &MPM, PassBuilder *PB, OptimizationLevel O, const OptimizationOptions &options) JL_NOTSAFEPOINT {
     MPM.addPass(BeforeCleanupMarkerPass());
-    if (O.getSpeedupLevel() >= 2) {
-        FunctionPassManager FPM;
-        JULIA_PASS(FPM.addPass(CombineMulAddPass()));
-        FPM.addPass(DivRemPairsPass());
-        MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
-    }
-    invokeOptimizerLastCallbacks(MPM, PB, O);
-    MPM.addPass(createModuleToFunctionPassAdaptor(AnnotationRemarksPass()));
-    addSanitizerPasses(MPM, O);
-    {
-        FunctionPassManager FPM;
-        JULIA_PASS(FPM.addPass(DemoteFloat16Pass()));
+    if (options.cleanup) {
         if (O.getSpeedupLevel() >= 2) {
-            FPM.addPass(GVNPass());
+            FunctionPassManager FPM;
+            JULIA_PASS(FPM.addPass(CombineMulAddPass()));
+            FPM.addPass(DivRemPairsPass());
+            MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+        }
+        invokeOptimizerLastCallbacks(MPM, PB, O);
+        MPM.addPass(createModuleToFunctionPassAdaptor(AnnotationRemarksPass()));
+        addSanitizerPasses(MPM, O);
+        {
+            FunctionPassManager FPM;
+            JULIA_PASS(FPM.addPass(DemoteFloat16Pass()));
+            if (O.getSpeedupLevel() >= 2) {
+                FPM.addPass(GVNPass());
+            }
+            MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
         }
-        MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
     }
     MPM.addPass(AfterCleanupMarkerPass());
 }
@@ -588,7 +601,8 @@ static void buildCleanupPipeline(ModulePassManager &MPM, PassBuilder *PB, Optimi
 static void buildPipeline(ModulePassManager &MPM, PassBuilder *PB, OptimizationLevel O, const OptimizationOptions &options) JL_NOTSAFEPOINT {
     MPM.addPass(BeforeOptimizationMarkerPass());
     buildEarlySimplificationPipeline(MPM, PB, O, options);
-    MPM.addPass(AlwaysInlinerPass());
+    if (options.always_inline)
+        MPM.addPass(AlwaysInlinerPass());
     buildEarlyOptimizerPipeline(MPM, PB, O, options);
     {
         FunctionPassManager FPM;
@@ -605,11 +619,27 @@ static void buildPipeline(ModulePassManager &MPM, PassBuilder *PB, OptimizationL
     MPM.addPass(AfterOptimizationMarkerPass());
 }
 
-extern "C" JL_DLLEXPORT_CODEGEN void jl_build_newpm_pipeline_impl(void *MPM, void *PB, int Speedup, int Size,
-    int lower_intrinsics, int dump_native, int external_use, int llvm_only) JL_NOTSAFEPOINT
+struct PipelineConfig {
+    int Speedup;
+    int Size;
+    int lower_intrinsics;
+    int dump_native;
+    int external_use;
+    int llvm_only;
+    int always_inline;
+    int enable_early_simplifications;
+    int enable_early_optimizations;
+    int enable_scalar_optimizations;
+    int enable_loop_optimizations;
+    int enable_vector_pipeline;
+    int remove_ni;
+    int cleanup;
+};
+
+extern "C" JL_DLLEXPORT_CODEGEN void jl_build_newpm_pipeline_impl(void *MPM, void *PB, PipelineConfig* config) JL_NOTSAFEPOINT
 {
     OptimizationLevel O;
-    switch (Size) {
+    switch (config->Size) {
         case 1:
             O = OptimizationLevel::Os;
             break;
@@ -617,7 +647,7 @@ extern "C" JL_DLLEXPORT_CODEGEN void jl_build_newpm_pipeline_impl(void *MPM, voi
             O = OptimizationLevel::Oz;
             break;
         case 0:
-            switch (Speedup) {
+            switch (config->Speedup) {
                 case 0:
                     O = OptimizationLevel::O0;
                     break;
@@ -633,7 +663,18 @@ extern "C" JL_DLLEXPORT_CODEGEN void jl_build_newpm_pipeline_impl(void *MPM, voi
             }
     }
     buildPipeline(*reinterpret_cast<ModulePassManager*>(MPM), reinterpret_cast<PassBuilder*>(PB), O,
-                    OptimizationOptions{!!lower_intrinsics, !!dump_native, !!external_use, !!llvm_only});
+                    OptimizationOptions{!!config->lower_intrinsics,
+                                        !!config->dump_native,
+                                        !!config->external_use,
+                                        !!config->llvm_only,
+                                        !!config->always_inline,
+                                        !!config->enable_early_simplifications,
+                                        !!config->enable_early_optimizations,
+                                        !!config->enable_scalar_optimizations,
+                                        !!config->enable_loop_optimizations,
+                                        !!config->enable_vector_pipeline,
+                                        !!config->remove_ni,
+                                        !!config->cleanup});
 }
 
 #undef JULIA_PASS

From ca1e51984b620e291ef27fb2484512f3c2fe0cac Mon Sep 17 00:00:00 2001
From: Richie Wilynnton <90733565+RichieWilynnton@users.noreply.github.com>
Date: Fri, 19 Jan 2024 10:33:16 +0800
Subject: [PATCH 0672/1315] Documentation for "Printf" Module (#52791)

Part of https://github.com/JuliaLang/julia/issues/52725

---------

Co-authored-by: RichieWilynnton <richiewilynton@gmail.com>
---
 stdlib/Printf/docs/src/index.md | 2 ++
 stdlib/Printf/src/Printf.jl     | 4 +++-
 stdlib/Printf/test/runtests.jl  | 4 +---
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/stdlib/Printf/docs/src/index.md b/stdlib/Printf/docs/src/index.md
index e1dd5587d8407..1c6f98ce22e58 100644
--- a/stdlib/Printf/docs/src/index.md
+++ b/stdlib/Printf/docs/src/index.md
@@ -4,6 +4,8 @@ EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Printf/docs/src
 
 # [Printf](@id man-printf)
 
+The `Printf` module provides formatted output functions similar to the C standard library's `printf`. It allows formatted printing to an output stream or to a string.
+
 ```@docs
 Printf.@printf
 Printf.@sprintf
diff --git a/stdlib/Printf/src/Printf.jl b/stdlib/Printf/src/Printf.jl
index ae9bf45786295..860ef3610f728 100644
--- a/stdlib/Printf/src/Printf.jl
+++ b/stdlib/Printf/src/Printf.jl
@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
-
+"""
+The `Printf` module provides formatted output functions similar to the C standard library's `printf`. It allows formatted printing to an output stream or to a string.
+"""
 module Printf
 
 using Base.Ryu
diff --git a/stdlib/Printf/test/runtests.jl b/stdlib/Printf/test/runtests.jl
index a80affff37d11..f00d7abe362c5 100644
--- a/stdlib/Printf/test/runtests.jl
+++ b/stdlib/Printf/test/runtests.jl
@@ -1146,9 +1146,7 @@ end
 end
 
 @testset "Docstrings" begin
-    undoc = Docs.undocumented_names(Printf)
-    @test_broken isempty(undoc)
-    @test undoc == [:Printf]
+    @test isempty(Docs.undocumented_names(Printf))
 end
 
 # issue #52749

From d6adba13a3684bae310250532803d42ac5b9f95c Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Wed, 17 Jan 2024 04:58:47 -0500
Subject: [PATCH 0673/1315] irinterp: Add Tarjan SCC algorithm for reachability

This optimizes `kill_edge!` for IR interp. The basic algorithm flow is:

   1. Check whether `target` of dead edge is unreachable, i.e. iff:

       - Reducible CFG node: there is no live incoming forward edge

       - Irreducible CFG node: Tarjan's SCC algorithm reports no live
         incoming forward edges to the SCC

   2. If `target` is dead, repeat (1) for all of its outgoing edges

This maintains reachability information very efficiently, especially
for reducible CFG's which are overwhelmingly common. As an added bonus
CFGReachability can also be consulted to check which BasicBlocks are
part of an irreducible loop.
---
 base/compiler/compiler.jl       |   1 +
 base/compiler/inferencestate.jl |  17 +-
 base/compiler/ssair/irinterp.jl |  23 +--
 base/compiler/ssair/tarjan.jl   | 299 ++++++++++++++++++++++++++++++++
 test/choosetests.jl             |   7 +-
 test/compiler/tarjan.jl         | 167 ++++++++++++++++++
 6 files changed, 487 insertions(+), 27 deletions(-)
 create mode 100644 base/compiler/ssair/tarjan.jl
 create mode 100644 test/compiler/tarjan.jl

diff --git a/base/compiler/compiler.jl b/base/compiler/compiler.jl
index 6868f3ea03477..8b9c26be2ec81 100644
--- a/base/compiler/compiler.jl
+++ b/base/compiler/compiler.jl
@@ -200,6 +200,7 @@ include("compiler/validation.jl")
 include("compiler/ssair/basicblock.jl")
 include("compiler/ssair/domtree.jl")
 include("compiler/ssair/ir.jl")
+include("compiler/ssair/tarjan.jl")
 
 include("compiler/abstractlattice.jl")
 include("compiler/inferenceresult.jl")
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 2add6c631713f..3765cc34d6869 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -170,6 +170,17 @@ function getindex(tpdum::TwoPhaseDefUseMap, idx::Int)
     return TwoPhaseVectorView(tpdum.data, nelems, range)
 end
 
+mutable struct LazyCFGReachability
+    ir::IRCode
+    reachability::CFGReachability
+    LazyCFGReachability(ir::IRCode) = new(ir)
+end
+function get!(x::LazyCFGReachability)
+    isdefined(x, :reachability) && return x.reachability
+    domtree = construct_domtree(x.ir.cfg.blocks)
+    return x.reachability = CFGReachability(x.ir.cfg, domtree)
+end
+
 mutable struct LazyGenericDomtree{IsPostDom}
     ir::IRCode
     domtree::GenericDomTree{IsPostDom}
@@ -744,7 +755,7 @@ mutable struct IRInterpretationState
     const sptypes::Vector{VarState}
     const tpdum::TwoPhaseDefUseMap
     const ssa_refined::BitSet
-    const lazydomtree::LazyDomtree
+    const lazyreachability::LazyCFGReachability
     valid_worlds::WorldRange
     const edges::Vector{Any}
     parent # ::Union{Nothing,AbsIntState}
@@ -764,12 +775,12 @@ mutable struct IRInterpretationState
         append!(ir.argtypes, given_argtypes)
         tpdum = TwoPhaseDefUseMap(length(ir.stmts))
         ssa_refined = BitSet()
-        lazydomtree = LazyDomtree(ir)
+        lazyreachability = LazyCFGReachability(ir)
         valid_worlds = WorldRange(min_world, max_world == typemax(UInt) ? get_world_counter() : max_world)
         edges = Any[]
         parent = nothing
         return new(method_info, ir, mi, world, curridx, argtypes_refined, ir.sptypes, tpdum,
-                   ssa_refined, lazydomtree, valid_worlds, edges, parent)
+                   ssa_refined, lazyreachability, valid_worlds, edges, parent)
     end
 end
 
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 7e454612a4eb6..d740b3517a0ec 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -63,6 +63,7 @@ function kill_block!(ir::IRCode, bb::Int)
     ir[SSAValue(last(stmts))][:stmt] = ReturnNode()
     return
 end
+kill_block!(ir::IRCode) = (bb::Int)->kill_block!(ir, bb)
 
 function update_phi!(irsv::IRInterpretationState, from::Int, to::Int)
     ir = irsv.ir
@@ -102,26 +103,8 @@ function kill_terminator_edges!(irsv::IRInterpretationState, term_idx::Int, bb::
 end
 
 function kill_edge!(irsv::IRInterpretationState, from::Int, to::Int)
-    ir = irsv.ir
-    kill_edge!(ir, from, to, update_phi!(irsv))
-
-    lazydomtree = irsv.lazydomtree
-    domtree = nothing
-    if isdefined(lazydomtree, :domtree)
-        domtree = get!(lazydomtree)
-        domtree_delete_edge!(domtree, ir.cfg.blocks, from, to)
-    elseif length(ir.cfg.blocks[to].preds) != 0
-        # TODO: If we're not maintaining the domtree, computing it just for this
-        # is slightly overkill - just the dfs tree would be enough.
-        domtree = get!(lazydomtree)
-    end
-
-    if domtree !== nothing && bb_unreachable(domtree, to)
-        kill_block!(ir, to)
-        for edge in ir.cfg.blocks[to].succs
-            kill_edge!(irsv, to, edge)
-        end
-    end
+    kill_edge!(get!(irsv.lazyreachability), irsv.ir.cfg, from, to,
+               update_phi!(irsv), kill_block!(irsv.ir))
 end
 
 function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction, idx::Int,
diff --git a/base/compiler/ssair/tarjan.jl b/base/compiler/ssair/tarjan.jl
new file mode 100644
index 0000000000000..8285fcd3f29b7
--- /dev/null
+++ b/base/compiler/ssair/tarjan.jl
@@ -0,0 +1,299 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+using Core.Compiler: DomTree, CFG, BasicBlock, StmtRange, dominates
+
+struct SCCStackItem
+    v::Int32
+    # which child of `v` to scan
+    child::Int32
+    # the location of `parent` in the stack
+    parent::Int32
+    # the index in the (pre-order traversal of the) DFS tree
+    preorder::Int32
+    # the minimum node (by pre-order index) reachable from any node in the DFS sub-tree rooted at `v`
+    minpreorder::Int32
+    # whether this node is reachable from BasicBlock #1
+    live::Bool
+end
+
+function SCCStackItem(item::SCCStackItem; child=item.child,
+                      minpreorder=item.minpreorder, live=item.live)
+    return SCCStackItem(
+        item.v,        # v
+        child,         # child
+        item.parent,   # parent
+        item.preorder, # preorder
+        minpreorder,   # minpreorder
+        live,          # live
+    )
+end
+
+struct CFGReachability
+    irreducible::BitVector # BBNumber -> Bool
+    scc::Vector{Int}       # BBNumber -> SCCNumber
+    domtree::DomTree
+
+    _worklist::Vector{Int}       # for node removal
+    _stack::Vector{SCCStackItem} # for Tarjan's SCC algorithm
+end
+
+function CFGReachability(cfg::CFG, domtree::DomTree)
+    n_blocks = length(cfg.blocks)
+    reachability = CFGReachability(
+        BitVector(undef, n_blocks), # irreducible
+        zeros(Int, n_blocks),       # scc
+        domtree,                    # domtree
+        Int[],                      # _worklist
+        SCCStackItem[],             # _stack
+    )
+    tarjan!(reachability, cfg)
+    return reachability
+end
+
+bb_unreachable(reach::CFGReachability, bb::Int) = reach.scc[bb] == 0
+
+bb_in_irreducible_loop(reach::CFGReachability, bb::Int) = reach.irreducible[bb]
+
+# Returns `true` if a node is 'rooted' as reachable, i.e. it is has an incoming
+# edge from a resolved SCC other than its own (or it is BasicBlock #1).
+#
+# `tarjan!` takes the transitive closure of this relation in order to detect
+# which BasicBlocks are unreachable.
+function _bb_externally_reachable(reach::CFGReachability, cfg::CFG, bb::Int)
+    (; scc) = reach
+    bb == 1 && return true
+    for pred in cfg.blocks[bb].preds
+        scc[pred] <= 0 && continue
+        dominates(reach.domtree, bb, pred) && continue
+        @assert scc[pred] != scc[bb]
+        return true
+    end
+    return false
+end
+
+"""
+    tarjan!(reach::CFGReachability, cfg::CFG, root::Int=1)
+
+Tarjan's strongly-connected components algorithm. Traverses the CFG starting at `root`, ignoring
+nodes with resolved SCC's and updating outputs for all un-resolved nodes.
+
+Returns true if any node was discovered to be unreachable, false otherwise.
+
+Outputs:
+  - `reach.scc`: strongly-connected components, ignoring backedges to (natural) loops
+  - `reach.irreducible`: true iff a BasicBlock is part of a (non-trivial) SCC / irreducible loop
+  - `reach._worklist`: if performing an incremental update (`root != 1`), any traversed nodes that
+    are unreachable from BasicBlock #1 are enqueued to this worklist
+"""
+function tarjan!(reach::CFGReachability, cfg::CFG; root::Int=1)
+    (; scc, irreducible, domtree) = reach
+    scc[root] != 0 && return scc
+    live = _bb_externally_reachable(reach, cfg, root)
+
+    # the original algorithm has a separate stack and worklist (unrelated to `reach._worklist`)
+    # here we use a single combined stack for improved memory/cache efficiency
+    stack = reach._stack
+    push!(stack, SCCStackItem(
+        root, # v
+        1,    # child
+        0,    # parent
+        1,    # preorder
+        1,    # minpreorder
+        live, # live
+    ))
+    scc[root] = -1
+    cursor = length(stack)
+
+    # worklist length before any new unreachable nodes are added
+    worklist_len = length(reach._worklist)
+
+    # last (pre-order) DFS label assigned to a node
+    preorder_id = 1
+    while true
+        (; v, child, minpreorder, live) = item = stack[cursor]
+
+        bb = cfg.blocks[v]
+        if child <= length(bb.succs) # queue next child
+            stack[cursor] = item = SCCStackItem(item; child=child+1)
+            succ = bb.succs[child]
+
+            # ignore any back-edges in a (natural) loop (see `kill_edge!`)
+            if dominates(domtree, succ, convert(Int, v))
+                # This check ensures that reducible CFG's will contain no SCC's. The vast majority
+                # of functions have reducible CFG's, so this optimization is very important.
+                continue
+            end
+
+            if scc[succ] < 0
+                # next child is already in DFS tree
+                child_preorder = stack[-scc[succ]].preorder
+
+                # only need to update `minpreorder` for `v`
+                stack[cursor] = item = SCCStackItem(item;
+                                                    minpreorder=min(minpreorder, child_preorder))
+            elseif scc[succ] == 0
+                # next child is a new element in DFS tree
+                preorder_id += 1
+                live = live || _bb_externally_reachable(reach, cfg, succ)
+                push!(stack, SCCStackItem(
+                    succ,        # v
+                    1,           # child
+                    cursor,      # parent (index in stack)
+                    preorder_id, # preorder
+                    preorder_id, # minpreorder
+                    live,        # live
+                ))
+                scc[succ] = -length(stack)
+                cursor = length(stack)
+            else end # next child is a resolved SCC (do nothing)
+        else # v's children are processed, finalize v
+            if item.minpreorder == item.preorder
+                has_one_element = stack[end].v == v
+                while true
+                    item = pop!(stack)
+                    if live
+                        scc[item.v] = v
+                        scan_subgraph!(reach, cfg, convert(Int, item.v),
+                            #= filter =# (pred,x)->(!dominates(domtree, x, pred) && scc[x] > typemax(Int)÷2),
+                            #= action =# (x)->(scc[x] -= typemax(Int)÷2;),
+                        )
+                    else # this offset marks a node as 'maybe-dead'
+                        scc[item.v] = v + typemax(Int)÷2
+                        push!(reach._worklist, item.v)
+                    end
+                    irreducible[item.v] = !has_one_element
+                    (item.v == v) && break
+                end
+                item.parent == 0 && break # all done
+            elseif live
+                stack[item.parent] = SCCStackItem(stack[item.parent]; live=true)
+            end
+
+            # update `minpreorder` for parent
+            parent = stack[item.parent]
+            minpreorder = min(parent.minpreorder, item.minpreorder)
+            stack[item.parent] = SCCStackItem(parent; minpreorder)
+
+            cursor = item.parent
+        end
+    end
+
+    worklist = reach._worklist
+
+    # filter the worklist, leaving any nodes not proven to be reachable from BB #1
+    n_filtered = 0
+    for i = (worklist_len + 1):length(worklist)
+        @assert worklist[i] != 1
+        @assert scc[worklist[i]] > 0
+        if scc[worklist[i]] > typemax(Int)÷2
+            # node is unreachable, enqueue it
+            scc[worklist[i]] = 0
+            worklist[i - n_filtered] = worklist[i]
+        else
+            n_filtered += 1
+        end
+    end
+    resize!(worklist, length(worklist) - n_filtered)
+
+    return length(worklist) > worklist_len # if true, a (newly) unreachable node was enqueued
+end
+
+"""
+Scan the subtree rooted at `root`, excluding `root` itself
+
+Note: This function will not detect cycles for you. The `filter` provided must
+      protect against infinite cycle traversal.
+"""
+function scan_subgraph!(reach::CFGReachability, cfg::CFG, root::Int, filter, action)
+    worklist = reach._worklist
+    start_len = length(worklist)
+
+    push!(worklist, root)
+    while length(worklist) > start_len
+        v = pop!(worklist)
+        for succ in cfg.blocks[v].succs
+            !filter(v, succ) && continue
+            action(succ)
+            push!(worklist, succ)
+        end
+    end
+end
+
+function enqueue_if_unreachable!(reach::CFGReachability, cfg::CFG, bb::Int)
+    (; domtree, scc) = reach
+    @assert scc[bb] != 0
+
+    bb == 1 && return false
+    if bb_in_irreducible_loop(reach, bb)
+        # irreducible CFG
+        # this requires a full scan of the irreducible loop
+
+        scc′ = scc[bb]
+        scc[bb] = 0
+        scan_subgraph!(reach, cfg, bb, # set this SCC to 0
+            #= filter =# (pred,x)->(!dominates(domtree, x, pred) && scc[x] == scc′),
+            #= action =# (x)->(scc[x] = 0;),
+        )
+
+        # re-compute the SCC's for this portion of the CFG, adding any freshly
+        # unreachable nodes to `reach._worklist`
+        return tarjan!(reach, cfg; root=bb)
+    else
+        # target is a reducible CFG node
+        # this node lives iff it still has an incoming forward edge
+        for pred in cfg.blocks[bb].preds
+            !dominates(domtree, bb, pred) && return false # forward-edge
+        end
+        scc[bb] = 0
+        push!(reach._worklist, bb)
+        return true
+    end
+end
+
+"""
+Remove from `cfg` and `reach` the edge (from → to), as well as any blocks/edges
+this causes to become unreachable.
+
+Calls:
+  - `block_callback` for every unreachable block.
+  - `edge_callback` for every unreachable edge into a reachable block (may also
+     be called for blocks which are later discovered to be unreachable).
+"""
+function kill_edge!(reach::CFGReachability, cfg::CFG, from::Int, to::Int,
+                    edge_callback=nothing, block_callback=nothing)
+    (reach.scc[from] == 0) && return # source is already unreachable
+    @assert reach.scc[to] != 0
+
+    # delete (from → to) edge
+    preds, succs = cfg.blocks[to].preds, cfg.blocks[from].succs
+    deleteat!(preds, findfirst(x::Int->x==from, preds)::Int)
+    deleteat!(succs, findfirst(x::Int->x==to, succs)::Int)
+
+    # check for unreachable target
+    enqueued = enqueue_if_unreachable!(reach, cfg, to)
+    if !enqueued && edge_callback !== nothing
+        edge_callback(from, to)
+    end
+    while !isempty(reach._worklist)
+        node = convert(Int, pop!(reach._worklist))
+
+        # already marked unreachable, just need to notify
+        @assert reach.scc[node] == 0 && node != 1
+        if block_callback !== nothing
+            block_callback(node)
+        end
+
+        for succ in cfg.blocks[node].succs
+            # delete (node → succ) edge
+            preds = cfg.blocks[succ].preds
+            deleteat!(preds, findfirst(x::Int->x==node, preds)::Int)
+
+            # check for newly unreachable target
+            reach.scc[succ] == 0 && continue
+            enqueued = enqueue_if_unreachable!(reach, cfg, succ)
+            if !enqueued && edge_callback !== nothing
+                edge_callback(node, succ)
+            end
+        end
+    end
+end
diff --git a/test/choosetests.jl b/test/choosetests.jl
index beed4e15a58df..36da1ab39bc57 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -156,10 +156,9 @@ function choosetests(choices = [])
     filtertests!(tests, "subarray")
     filtertests!(tests, "compiler", [
         "compiler/datastructures", "compiler/inference", "compiler/effects",
-        "compiler/validation", "compiler/ssair", "compiler/irpasses",
-        "compiler/codegen", "compiler/inline", "compiler/contextual",
-        "compiler/invalidation", "compiler/AbstractInterpreter",
-        "compiler/EscapeAnalysis/EscapeAnalysis"])
+        "compiler/validation", "compiler/ssair", "compiler/irpasses", "compiler/tarjan",
+        "compiler/codegen", "compiler/inline", "compiler/contextual", "compiler/invalidation",
+        "compiler/AbstractInterpreter", "compiler/EscapeAnalysis/EscapeAnalysis"])
     filtertests!(tests, "compiler/EscapeAnalysis", [
         "compiler/EscapeAnalysis/EscapeAnalysis"])
     filtertests!(tests, "stdlib", STDLIBS)
diff --git a/test/compiler/tarjan.jl b/test/compiler/tarjan.jl
new file mode 100644
index 0000000000000..c23388b39621f
--- /dev/null
+++ b/test/compiler/tarjan.jl
@@ -0,0 +1,167 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+using Core.Compiler: CFGReachability, DomTree, CFG, BasicBlock, StmtRange, dominates,
+                     bb_unreachable, kill_edge!
+
+const CC = Core.Compiler
+
+function reachable(g::CFG, a::Int, b::Int; domtree=nothing)
+    visited = BitVector(false for _ = 1:length(g.blocks))
+    worklist = Int[a]
+    while !isempty(worklist)
+        node = pop!(worklist)
+        node == b && return true
+        visited[node] = true
+        for child in g.blocks[node].succs
+            if domtree !== nothing && dominates(domtree, child, node)
+                continue # if provided `domtree`, ignore back-edges
+            end
+
+            !visited[child] && push!(worklist, child)
+        end
+    end
+    return false
+end
+
+function rand_cfg(V, E)
+    bbs = [BasicBlock(StmtRange(0,0), Int[], Int[]) for _ = 1:V]
+
+    reachable = BitVector(false for _ = 1:V)
+    reachable[1] = true
+
+    targets = BitVector(false for _ = 1:V)
+
+    for _ = 1:E
+        # Pick any source (with at least 1 missing edge)
+        source, dest = 0, 0
+        while true
+            source = rand(findall(reachable))
+            for v = 1:V
+                targets[v] = !in(v, bbs[source].succs)
+            end
+            any(targets) && break
+        end
+
+        # Pick any new target for source
+        dest = rand(findall(targets))
+
+        # Add edge to graph
+        push!(bbs[source].succs, dest)
+        push!(bbs[dest].preds, source)
+
+        reachable[dest] = true
+    end
+
+    return CFG(bbs, zeros(Int, V + 1))
+end
+
+function get_random_edge(cfg::CFG, V)
+    source = rand(1:V)
+    while length(cfg.blocks[source].succs) == 0
+        source = rand(1:V)
+    end
+    target = rand(cfg.blocks[source].succs)
+    return source, target
+end
+
+# Generate a random CFG with the requested number of vertices and edges, then simulate
+# `deletions` edge removals and verify that reachability is maintained correctly.
+#
+# If `all_checks` is true, verify internal data structures as well with O(E^2) checks.
+function test_reachability(V, E; deletions = 2E ÷ 3, all_checks=false)
+
+    function check_reachability(reachability, cfg, domtree, all_checks)
+        for i = 1:V
+            # All nodes should be reported as unreachable only if we cannot reach them from BB #1.
+            @test reachable(cfg, 1, i) == !bb_unreachable(reachability, i)
+
+            # All predecessors of a reachable block should be reachable.
+            if !bb_unreachable(reachability, i)
+                for pred in cfg.blocks[i].preds
+                    @test !bb_unreachable(reachability, pred)
+                end
+            end
+        end
+
+        if all_checks # checks for internal data structures - O(E^2)
+
+            # Nodes should be mutually reachable iff they are in the same SCC.
+            scc = reachability.scc
+            reachable_nodes = BitSet(v for v = 1:V if !bb_unreachable(reachability, v))
+            for i ∈ reachable_nodes
+                for j ∈ reachable_nodes
+                    @test (reachable(cfg, i, j; domtree) && reachable(cfg, j, i; domtree)) == (scc[i] == scc[j])
+                end
+            end
+
+            # Nodes in any non-trivial SCC (ignoring backedges) should be marked irreducible.
+            irreducible = reachability.irreducible
+            for i ∈ reachable_nodes
+                in_nontrivial_scc = any(v != i && scc[v] == scc[i] for v = 1:V)
+                @test CC.getindex(irreducible, i) == in_nontrivial_scc
+            end
+        end
+    end
+
+    cfg = rand_cfg(V, E)
+    domtree = Core.Compiler.construct_domtree(cfg.blocks)
+    reachability = CFGReachability(cfg, domtree)
+    check_reachability(reachability, cfg, domtree, all_checks)
+
+    # track the reachable blocks/edges so that we can verify callbacks below
+    blocks = Set{Int}()
+    edges = Set{Tuple{Int,Int}}()
+    for bb in 1:V
+        !bb_unreachable(reachability, bb) && push!(blocks, bb)
+        for succ in cfg.blocks[bb].succs
+            push!(edges, (bb, succ))
+        end
+    end
+
+    killed_edges = Tuple{Int,Int}[]
+    killed_blocks = Int[]
+    for k = 1:deletions
+        from, to = get_random_edge(cfg, V)
+        kill_edge!(reachability, cfg, from, to,
+            (from::Int, to::Int) -> push!(killed_edges, (from, to)),
+            (bb::Int) -> push!(killed_blocks, bb),
+        )
+
+        # If these nodes are still reachable, to and from edges should have been removed.
+        @test !reachable(cfg, 1, from) || !in(to, cfg.blocks[from].succs)
+        @test !reachable(cfg, 1, to)   || !in(from, cfg.blocks[to].preds)
+
+        check_reachability(reachability, cfg, domtree, all_checks)
+
+        for bb in 1:V
+            if bb_unreachable(reachability, bb) && in(bb, blocks)
+                # If the block changed from reachable -> unreachable, we should have gotten a callback.
+                @test bb in killed_blocks
+                delete!(blocks, bb)
+            end
+        end
+        for (from, to) in edges
+            if !in(from, cfg.blocks[to].preds) && !bb_unreachable(reachability, to)
+                # If the edge changed from reachable -> unreachable and feeds into a reachable BasicBlock,
+                # we should have gotten a callback.
+                @test (from, to) in killed_edges
+                delete!(edges, (from, to))
+            end
+        end
+
+        empty!(killed_edges)
+        empty!(killed_blocks)
+    end
+end
+
+@testset "CFGReachability tests" begin
+    test_reachability(1, 0; all_checks=true)
+
+    test_reachability(10, 15; all_checks=true)
+    test_reachability(10, 15; all_checks=true)
+    test_reachability(10, 15; all_checks=true)
+
+    test_reachability(100, 150; all_checks=false)
+    test_reachability(100, 150; all_checks=false)
+    test_reachability(100, 1000; all_checks=false)
+end

From 48ef5e9da929eaded123395fe887477b59037894 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 19 Jan 2024 10:10:50 -0300
Subject: [PATCH 0674/1315] NFC: move memory pressure callback declaration to
 julia_gcext.h (#52962)

It should probably be in `julia_gcext.h` together with the other
callbacks for consistency.
---
 src/gc.c          | 1 -
 src/julia_gcext.h | 4 ++++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/gc.c b/src/gc.c
index a876b41490a9b..ca53132fcbc16 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -51,7 +51,6 @@ static jl_gc_callback_list_t *gc_cblist_post_gc;
 static jl_gc_callback_list_t *gc_cblist_notify_external_alloc;
 static jl_gc_callback_list_t *gc_cblist_notify_external_free;
 static jl_gc_callback_list_t *gc_cblist_notify_gc_pressure;
-typedef void (*jl_gc_cb_notify_gc_pressure_t)(void);
 
 #define gc_invoke_callbacks(ty, list, args) \
     do { \
diff --git a/src/julia_gcext.h b/src/julia_gcext.h
index 27f0a6b5ec11c..c65586b85547a 100644
--- a/src/julia_gcext.h
+++ b/src/julia_gcext.h
@@ -34,6 +34,10 @@ JL_DLLEXPORT void jl_gc_set_cb_notify_external_alloc(jl_gc_cb_notify_external_al
 JL_DLLEXPORT void jl_gc_set_cb_notify_external_free(jl_gc_cb_notify_external_free_t cb,
         int enable);
 
+// Memory pressure callback
+typedef void (*jl_gc_cb_notify_gc_pressure_t)(void) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_gc_set_cb_notify_gc_pressure(jl_gc_cb_notify_gc_pressure_t cb, int enable);
+
 // Types for custom mark and sweep functions.
 typedef uintptr_t (*jl_markfunc_t)(jl_ptls_t, jl_value_t *obj);
 typedef void (*jl_sweepfunc_t)(jl_value_t *obj);

From d384a366d443b441ebccd79686cc47c7e67f64e8 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Fri, 19 Jan 2024 10:39:33 -0300
Subject: [PATCH 0675/1315] Add detection for apple m2 and m3 cpus, and cleanup
 code (#52396)

This only makes a difference with LLVM 16
---
 src/processor_arm.cpp | 41 +++++++++++++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 6 deletions(-)

diff --git a/src/processor_arm.cpp b/src/processor_arm.cpp
index 6a09e00cf23e7..d7672016f00d0 100644
--- a/src/processor_arm.cpp
+++ b/src/processor_arm.cpp
@@ -164,7 +164,11 @@ enum class CPU : uint32_t {
     apple_a12,
     apple_a13,
     apple_a14,
+    apple_a15,
+    apple_a16,
     apple_m1,
+    apple_m2,
+    apple_m3,
     apple_s4,
     apple_s5,
 
@@ -349,7 +353,11 @@ constexpr auto apple_a11 = armv8_2a_crypto | get_feature_masks(fullfp16);
 constexpr auto apple_a12 = armv8_3a_crypto | get_feature_masks(fullfp16);
 constexpr auto apple_a13 = armv8_4a_crypto | get_feature_masks(fp16fml, fullfp16, sha3);
 constexpr auto apple_a14 = armv8_5a_crypto | get_feature_masks(dotprod,fp16fml, fullfp16, sha3);
+constexpr auto apple_a15 = armv8_5a_crypto | get_feature_masks(dotprod,fp16fml, fullfp16, sha3, i8mm, bf16);
+constexpr auto apple_a16 = armv8_5a_crypto | get_feature_masks(dotprod,fp16fml, fullfp16, sha3, i8mm, bf16);
 constexpr auto apple_m1 = armv8_5a_crypto | get_feature_masks(dotprod,fp16fml, fullfp16, sha3);
+constexpr auto apple_m2 = armv8_5a_crypto | get_feature_masks(dotprod,fp16fml, fullfp16, sha3, i8mm, bf16);
+constexpr auto apple_m3 = armv8_5a_crypto | get_feature_masks(dotprod,fp16fml, fullfp16, sha3, i8mm, bf16);
 // Features based on https://github.com/llvm/llvm-project/blob/82507f1798768280cf5d5aab95caaafbc7fe6f47/llvm/include/llvm/Support/AArch64TargetParser.def
 // and sysctl -a hw.optional
 constexpr auto apple_s4 = apple_a12;
@@ -431,7 +439,11 @@ static constexpr CPUSpec<CPU, feature_sz> cpus[] = {
     {"apple-a12", CPU::apple_a12, CPU::generic, 100000, Feature::apple_a12},
     {"apple-a13", CPU::apple_a13, CPU::generic, 100000, Feature::apple_a13},
     {"apple-a14", CPU::apple_a14, CPU::apple_a13, 120000, Feature::apple_a14},
+    {"apple-a15", CPU::apple_a15, CPU::apple_a14, 160000, Feature::apple_a15},
+    {"apple-a16", CPU::apple_a16, CPU::apple_a14, 160000, Feature::apple_a16},
     {"apple-m1", CPU::apple_m1, CPU::apple_a14, 130000, Feature::apple_m1},
+    {"apple-m2", CPU::apple_m2, CPU::apple_m1, 160000, Feature::apple_m2},
+    {"apple-m3", CPU::apple_m3, CPU::apple_m2, 180000, Feature::apple_m3},
     {"apple-s4", CPU::apple_s4, CPU::generic, 100000, Feature::apple_s4},
     {"apple-s5", CPU::apple_s5, CPU::generic, 100000, Feature::apple_s5},
     {"thunderx3t110", CPU::marvell_thunderx3t110, CPU::cavium_thunderx2t99, 110000,
@@ -699,16 +711,17 @@ static inline const char *find_cpu_name(uint32_t cpu)
 
 static NOINLINE std::pair<uint32_t,FeatureList<feature_sz>> _get_host_cpu()
 {
+    using namespace llvm;
     char buffer[128];
     size_t bufferlen = 128;
     sysctlbyname("machdep.cpu.brand_string",&buffer,&bufferlen,NULL,0);
-
-    if(strcmp(buffer,"Apple M1") == 0)
-        return std::make_pair((uint32_t)CPU::apple_m1, Feature::apple_m1);
-    else if(strcmp(buffer,"Apple M1 Max") == 0)
-        return std::make_pair((uint32_t)CPU::apple_m1, Feature::apple_m1);
-    else if(strcmp(buffer,"Apple M1 Pro") == 0)
+    StringRef cpu_name(buffer);
+    if (cpu_name.find("M1") != StringRef ::npos)
         return std::make_pair((uint32_t)CPU::apple_m1, Feature::apple_m1);
+    else if (cpu_name.find("M2") != StringRef ::npos)
+        return std::make_pair((uint32_t)CPU::apple_m2, Feature::apple_m2);
+    else if (cpu_name.find("M3") != StringRef ::npos)
+        return std::make_pair((uint32_t)CPU::apple_m3, Feature::apple_m3);
     else
         return std::make_pair((uint32_t)CPU::apple_m1, Feature::apple_m1);
 }
@@ -1053,7 +1066,23 @@ static CPU get_cpu_name(CPUID cpuid)
             return CPU::apple_a14;
         case 0x22: // Icestorm m1
         case 0x23: // Firestorm m1
+        case 0x24:
+        case 0x25: // From https://github.com/AsahiLinux/m1n1/blob/3b9a71422e45209ef57c563e418f877bf54358be/src/chickens.c#L9
+        case 0x28:
+        case 0x29:
             return CPU::apple_m1;
+        case 0x30: // Blizzard m2
+        case 0x31: // Avalanche m2
+        case 0x32:
+        case 0x33:
+        case 0x34:
+        case 0x35:
+        case 0x38:
+        case 0x39:
+            return CPU::apple_m2;
+        case 0x49: // Everest m3
+        case 0x48: // Sawtooth m3
+            return CPU::apple_m3;
         default: return CPU::generic;
         }
     case 0x68: // 'h': Huaxintong Semiconductor

From fb2d946b885af5d09902dd2eb3175792644730ba Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 19 Jan 2024 12:22:51 -0300
Subject: [PATCH 0676/1315] ensure a few GC verify functions conform with the
 new page metadata layout (#52975)

Fix https://github.com/JuliaLang/julia/issues/52973.
---
 src/gc-debug.c | 47 +++++++++--------------------------------------
 1 file changed, 9 insertions(+), 38 deletions(-)

diff --git a/src/gc-debug.c b/src/gc-debug.c
index 108983ad8992d..b91bab876b11c 100644
--- a/src/gc-debug.c
+++ b/src/gc-debug.c
@@ -349,44 +349,15 @@ static void gc_verify_tags_page(jl_gc_pagemeta_t *pg)
     }
 }
 
-static void gc_verify_tags_pagetable0(pagetable0_t *pagetable0)
-{
-    for (int pg_i = 0; pg_i < REGION0_PG_COUNT / 32; pg_i++) {
-        uint32_t line = pagetable0->allocmap[pg_i];
-        if (line) {
-            for (int j = 0; j < 32; j++) {
-                if ((line >> j) & 1) {
-                    gc_verify_tags_page(pagetable0->meta[pg_i * 32 + j]);
-                }
-            }
-        }
-    }
-}
-
-static void gc_verify_tags_pagetable1(pagetable1_t *pagetable1)
+static void gc_verify_tags_pagestack(void)
 {
-    for (int pg_i = 0; pg_i < REGION1_PG_COUNT / 32; pg_i++) {
-        uint32_t line = pagetable1->allocmap0[pg_i];
-        if (line) {
-            for (int j = 0; j < 32; j++) {
-                if ((line >> j) & 1) {
-                    gc_verify_tags_pagetable0(pagetable1->meta0[pg_i * 32 + j]);
-                }
-            }
-        }
-    }
-}
-
-static void gc_verify_tags_pagetable(void)
-{
-    for (int pg_i = 0; pg_i < (REGION2_PG_COUNT + 31) / 32; pg_i++) {
-        uint32_t line = memory_map.allocmap1[pg_i];
-        if (line) {
-            for (int j = 0; j < 32; j++) {
-                if ((line >> j) & 1) {
-                    gc_verify_tags_pagetable1(memory_map.meta1[pg_i * 32 + j]);
-                }
-            }
+    for (int i = 0; i < gc_n_threads; i++) {
+        jl_ptls_t ptls2 = gc_all_tls_states[i];
+        jl_gc_page_stack_t *pgstk = &ptls2->page_metadata_allocd;
+        jl_gc_pagemeta_t *pg = jl_atomic_load_relaxed(&pgstk->bottom);
+        while (pg != NULL) {
+            gc_verify_tags_page(pg);
+            pg = pg->next;
         }
     }
 }
@@ -423,7 +394,7 @@ void gc_verify_tags(void)
 
     // verify that all the objects on every page are either valid julia objects
     // or are part of the freelist or are on the allocated half of a page
-    gc_verify_tags_pagetable();
+    gc_verify_tags_pagestack();
 }
 #endif
 

From 63188d58c094a82f4b8e48cc39014800f7920b8f Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 19 Jan 2024 18:30:03 -0500
Subject: [PATCH 0677/1315] Effects-tune PersitentDict (#52954)

To in particular allow elimination of dead PersistentDict constructions.
---
 base/array.jl             |  9 +++++-
 base/compiler/tfuncs.jl   |  2 ++
 base/dict.jl              | 21 +++++++++++--
 base/essentials.jl        | 65 +++++++++++++++++++++++++++++++++++++++
 base/genericmemory.jl     |  2 +-
 base/hamt.jl              | 10 +++---
 test/compiler/irpasses.jl |  5 ++-
 7 files changed, 105 insertions(+), 9 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index beb5246a0cbda..25c931f0aadd5 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -343,6 +343,9 @@ See also [`copy!`](@ref Base.copy!), [`copyto!`](@ref), [`deepcopy`](@ref).
 copy
 
 @eval function copy(a::Array{T}) where {T}
+    # `jl_genericmemory_copy_slice` only throws when the size exceeds the max allocation
+    # size, but since we're copying an existing array, we're guaranteed that this will not happen.
+    @_nothrow_meta
     ref = a.ref
     newmem = ccall(:jl_genericmemory_copy_slice, Ref{Memory{T}}, (Any, Ptr{Cvoid}, Int), ref.mem, ref.ptr_or_offset, length(a))
     return $(Expr(:new, :(typeof(a)), :(Core.memoryref(newmem)), :(a.size)))
@@ -1040,6 +1043,7 @@ end
 array_new_memory(mem::Memory, newlen::Int) = typeof(mem)(undef, newlen) # when implemented, this should attempt to first expand mem
 
 function _growbeg!(a::Vector, delta::Integer)
+    @_noub_meta
     delta = Int(delta)
     delta == 0 && return # avoid attempting to index off the end
     delta >= 0 || throw(ArgumentError("grow requires delta >= 0"))
@@ -1077,6 +1081,7 @@ function _growbeg!(a::Vector, delta::Integer)
 end
 
 function _growend!(a::Vector, delta::Integer)
+    @_noub_meta
     delta = Int(delta)
     delta >= 0 || throw(ArgumentError("grow requires delta >= 0"))
     ref = a.ref
@@ -1113,6 +1118,7 @@ function _growend!(a::Vector, delta::Integer)
 end
 
 function _growat!(a::Vector, i::Integer, delta::Integer)
+    @_terminates_globally_noub_meta
     delta = Int(delta)
     i = Int(i)
     i == 1 && return _growbeg!(a, delta)
@@ -1715,10 +1721,11 @@ julia> insert!(Any[1:6;], 3, "here")
 ```
 """
 function insert!(a::Array{T,1}, i::Integer, item) where T
+    @_noub_meta
     # Throw convert error before changing the shape of the array
     _item = item isa T ? item : convert(T, item)::T
     _growat!(a, i, 1)
-    # _growat! already did bound check
+    # :noub, because _growat! already did bound check
     @inbounds a[i] = _item
     return a
 end
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 1cba3e7795c47..d4485783c191c 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -3128,6 +3128,8 @@ function foreigncall_effects(@specialize(abstract_eval), e::Expr)
     if name === :jl_alloc_genericmemory
         nothrow = new_genericmemory_nothrow(abstract_eval, args)
         return Effects(EFFECTS_TOTAL; consistent=CONSISTENT_IF_NOTRETURNED, nothrow)
+    elseif name === :jl_genericmemory_copy_slice
+        return Effects(EFFECTS_TOTAL; consistent=CONSISTENT_IF_NOTRETURNED, nothrow=false)
     end
     return EFFECTS_UNKNOWN
 end
diff --git a/base/dict.jl b/base/dict.jl
index 89592d06d7bb6..db65f46509b40 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -901,14 +901,31 @@ struct PersistentDict{K,V} <: AbstractDict{K,V}
     @noinline function KeyValue.set(::Type{PersistentDict{K, V}}, ::Nothing, key, val) where {K, V}
         new{K, V}(HAMT.HAMT{K, V}(key => val))
     end
-    @noinline function KeyValue.set(dict::PersistentDict{K, V}, key, val) where {K, V}
+    @noinline @Base.assume_effects :effect_free function KeyValue.set(dict::PersistentDict{K, V}, key, val) where {K, V}
         trie = dict.trie
         h = HAMT.HashState(key)
         found, present, trie, i, bi, top, hs = HAMT.path(trie, key, h, #=persistent=# true)
         HAMT.insert!(found, present, trie, i, bi, hs, val)
         return new{K, V}(top)
     end
-    @noinline function KeyValue.set(dict::PersistentDict{K, V}, key) where {K, V}
+    @noinline @Base.assume_effects :nothrow :effect_free function KeyValue.set(dict::PersistentDict{K, V}, key::K, val::V) where {K, V}
+        trie = dict.trie
+        h = HAMT.HashState(key)
+        found, present, trie, i, bi, top, hs = HAMT.path(trie, key, h, #=persistent=# true)
+        HAMT.insert!(found, present, trie, i, bi, hs, val)
+        return new{K, V}(top)
+    end
+    @noinline @Base.assume_effects :effect_free function KeyValue.set(dict::PersistentDict{K, V}, key) where {K, V}
+        trie = dict.trie
+        h = HAMT.HashState(key)
+        found, present, trie, i, bi, top, _ = HAMT.path(trie, key, h, #=persistent=# true)
+        if found && present
+            deleteat!(trie.data, i)
+            HAMT.unset!(trie, bi)
+        end
+        return new{K, V}(top)
+    end
+    @noinline @Base.assume_effects :nothrow :effect_free function KeyValue.set(dict::PersistentDict{K, V}, key::K) where {K, V}
         trie = dict.trie
         h = HAMT.HashState(key)
         found, present, trie, i, bi, top, _ = HAMT.path(trie, key, h, #=persistent=# true)
diff --git a/base/essentials.jl b/base/essentials.jl
index a9f3bfc40f622..51f3ac43f3a14 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -253,6 +253,32 @@ macro _terminates_globally_meta()
         #=:noub=#false,
         #=:noub_if_noinbounds=#false))
 end
+# can be used in place of `@assume_effects :terminates_globally :notaskstate` (supposed to be used for bootstrapping)
+macro _terminates_globally_notaskstate_meta()
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
+        #=:consistent=#false,
+        #=:effect_free=#false,
+        #=:nothrow=#false,
+        #=:terminates_globally=#true,
+        #=:terminates_locally=#true,
+        #=:notaskstate=#true,
+        #=:inaccessiblememonly=#false,
+        #=:noub=#false,
+        #=:noub_if_noinbounds=#false))
+end
+# can be used in place of `@assume_effects :terminates_globally :noub` (supposed to be used for bootstrapping)
+macro _terminates_globally_noub_meta()
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
+        #=:consistent=#false,
+        #=:effect_free=#false,
+        #=:nothrow=#false,
+        #=:terminates_globally=#true,
+        #=:terminates_locally=#true,
+        #=:notaskstate=#false,
+        #=:inaccessiblememonly=#false,
+        #=:noub=#true,
+        #=:noub_if_noinbounds=#false))
+end
 # can be used in place of `@assume_effects :effect_free :terminates_locally` (supposed to be used for bootstrapping)
 macro _effect_free_terminates_locally_meta()
     return _is_internal(__module__) && Expr(:meta, Expr(:purity,
@@ -279,6 +305,45 @@ macro _nothrow_noub_meta()
         #=:noub=#true,
         #=:noub_if_noinbounds=#false))
 end
+# can be used in place of `@assume_effects :nothrow` (supposed to be used for bootstrapping)
+macro _nothrow_meta()
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
+        #=:consistent=#false,
+        #=:effect_free=#false,
+        #=:nothrow=#true,
+        #=:terminates_globally=#false,
+        #=:terminates_locally=#false,
+        #=:notaskstate=#false,
+        #=:inaccessiblememonly=#false,
+        #=:noub=#false,
+        #=:noub_if_noinbounds=#false))
+end
+# can be used in place of `@assume_effects :nothrow` (supposed to be used for bootstrapping)
+macro _noub_meta()
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
+        #=:consistent=#false,
+        #=:effect_free=#false,
+        #=:nothrow=#false,
+        #=:terminates_globally=#false,
+        #=:terminates_locally=#false,
+        #=:notaskstate=#false,
+        #=:inaccessiblememonly=#false,
+        #=:noub=#true,
+        #=:noub_if_noinbounds=#false))
+end
+# can be used in place of `@assume_effects :notaskstate` (supposed to be used for bootstrapping)
+macro _notaskstate_meta()
+    return _is_internal(__module__) && Expr(:meta, Expr(:purity,
+        #=:consistent=#false,
+        #=:effect_free=#false,
+        #=:nothrow=#false,
+        #=:terminates_globally=#false,
+        #=:terminates_locally=#false,
+        #=:notaskstate=#true,
+        #=:inaccessiblememonly=#false,
+        #=:noub=#false,
+        #=:noub_if_noinbounds=#false))
+end
 # can be used in place of `@assume_effects :noub_if_noinbounds` (supposed to be used for bootstrapping)
 macro _noub_if_noinbounds_meta()
     return _is_internal(__module__) && Expr(:meta, Expr(:purity,
diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index 51b25d453e5c4..9892a94b8dd89 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -70,7 +70,7 @@ isassigned(a::GenericMemoryRef) = memoryref_isassigned(a, :not_atomic, @_boundsc
 
 ## copy ##
 function unsafe_copyto!(dest::MemoryRef{T}, src::MemoryRef{T}, n) where {T}
-    @_terminates_globally_meta
+    @_terminates_globally_notaskstate_meta
     n == 0 && return dest
     @boundscheck GenericMemoryRef(dest, n), GenericMemoryRef(src, n)
     ccall(:jl_genericmemory_copyto, Cvoid, (Any, Ptr{Cvoid}, Any, Ptr{Cvoid}, Int), dest.mem, dest.ptr_or_offset, src.mem, src.ptr_or_offset, Int(n))
diff --git a/base/hamt.jl b/base/hamt.jl
index b8bf60cb22afb..e3e4b4bd03ba9 100644
--- a/base/hamt.jl
+++ b/base/hamt.jl
@@ -92,7 +92,7 @@ struct HashState{K}
 end
 HashState(key) = HashState(key, objectid(key), 0, 0)
 # Reconstruct
-function HashState(other::HashState, key)
+Base.@assume_effects :terminates_locally function HashState(other::HashState, key)
     h = HashState(key)
     while h.depth !== other.depth
         h = next(h)
@@ -103,7 +103,8 @@ end
 function next(h::HashState)
     depth = h.depth + 1
     shift = h.shift + BITS_PER_LEVEL
-    @assert h.shift <= MAX_SHIFT
+    # Assert disabled for effect precision
+    # @assert h.shift <= MAX_SHIFT
     if shift > MAX_SHIFT
         # Note we use `UInt(depth ÷ BITS_PER_LEVEL)` to seed the hash function
         # the hash docs, do we need to hash `UInt(depth ÷ BITS_PER_LEVEL)` first?
@@ -154,7 +155,7 @@ as the current `level`.
 If a copy function is provided `copyf` use the return `top` for the
 new persistent tree.
 """
-@inline function path(trie::HAMT{K,V}, key, h::HashState, copy=false) where {K, V}
+@inline @Base.assume_effects :noub :terminates_locally function path(trie::HAMT{K,V}, key, h::HashState, copy=false) where {K, V}
     if copy
         trie = top = HAMT{K,V}(Base.copy(trie.data), trie.bitmap)
     else
@@ -172,6 +173,7 @@ new persistent tree.
             end
             if copy
                 next = HAMT{K,V}(Base.copy(next.data), next.bitmap)
+                # :noub because entry_index is guaranteed to be inbounds for trie.data
                 @inbounds trie.data[i] = next
             end
             trie = next::HAMT{K,V}
@@ -187,7 +189,7 @@ end
 Internal function that given an obtained path, either set the value
 or grows the HAMT by inserting a new trie instead.
 """
-@inline function insert!(found, present, trie::HAMT{K,V}, i, bi, h, val) where {K,V}
+@inline @Base.assume_effects :terminates_locally function insert!(found, present, trie::HAMT{K,V}, i, bi, h, val) where {K,V}
     if found # we found a slot, just set it to the new leaf
         # replace or insert
         if present # replace
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 34a8d81f2c646..f4d0130ad757b 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1561,7 +1561,10 @@ function persistent_dict_elim_multiple()
     return b[:a]
 end
 @test_broken fully_eliminated(persistent_dict_elim_multiple)
-@test code_typed(persistent_dict_elim_multiple)[1][1].code[end] == Core.ReturnNode(1)
+let code = code_typed(persistent_dict_elim_multiple)[1][1].code
+    @test count(x->isexpr(x, :invoke), code) == 0
+    @test code[end] == Core.ReturnNode(1)
+end
 
 function persistent_dict_elim_multiple_phi(c::Bool)
     if c

From 6246074e21e229ec9d1f37b02e8f246ecb7672aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 20 Jan 2024 10:44:31 +0000
Subject: [PATCH 0678/1315] Remove debug `@show`s in tests (#52983)

Ref:
https://github.com/JuliaLang/julia/pull/52750#discussion_r1457756113
---
 test/relocatedepot.jl | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
index 2f33b8503670d..10149ffc2398a 100644
--- a/test/relocatedepot.jl
+++ b/test/relocatedepot.jl
@@ -152,8 +152,6 @@ if !test_relocated_depot
                             using Example2
                             srcfile1 = joinpath(pkgdir(Example1), "src", "Example1.jl")
                             srcfile2 = joinpath(pkgdir(Example2), "src", "Example2.jl")
-                            @show srcfile1
-                            @show srcfile2
                             include_dependency(srcfile1)
                             include_dependency(srcfile2)
                             end

From ce8269622a3e133de943d1fd89e2869b7d12fcaa Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Sat, 20 Jan 2024 07:50:10 -0300
Subject: [PATCH 0679/1315] Add detection for zen 4 cpus in processor_x86
 (#52944)

---
 src/processor_x86.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/processor_x86.cpp b/src/processor_x86.cpp
index 652a21a3a3286..bfada3c88fb1d 100644
--- a/src/processor_x86.cpp
+++ b/src/processor_x86.cpp
@@ -95,6 +95,7 @@ enum class CPU : uint32_t {
     amd_znver1,
     amd_znver2,
     amd_znver3,
+    amd_znver4,
 };
 
 static constexpr size_t feature_sz = 11;
@@ -235,6 +236,8 @@ constexpr auto znver1 = haswell | get_feature_masks(adx, aes, clflushopt, clzero
                                                     rdseed, sha, sse4a, xsavec);
 constexpr auto znver2 = znver1 | get_feature_masks(clwb, rdpid, wbnoinvd);
 constexpr auto znver3 = znver2 | get_feature_masks(shstk, pku, vaes, vpclmulqdq);
+constexpr auto znver4 = znver3 | get_feature_masks(avx512f, avx512cd, avx512dq, avx512bw, avx512vl, avx512ifma, avx512vbmi,
+                                                   avx512vbmi2, avx512vnni, avx512bitalg, avx512vpopcntdq, avx512bf16, gfni, shstk, xsaves);
 
 }
 
@@ -296,6 +299,7 @@ static constexpr CPUSpec<CPU, feature_sz> cpus[] = {
     {"znver1", CPU::amd_znver1, CPU::generic, 0, Feature::znver1},
     {"znver2", CPU::amd_znver2, CPU::generic, 0, Feature::znver2},
     {"znver3", CPU::amd_znver3, CPU::amd_znver2, 120000, Feature::znver3},
+    {"znver4", CPU::amd_znver4, CPU::amd_znver3, 160000, Feature::znver4},
 };
 static constexpr size_t ncpu_names = sizeof(cpus) / sizeof(cpus[0]);
 
@@ -563,9 +567,15 @@ static CPU get_amd_processor_name(uint32_t family, uint32_t model, const uint32_
         if (model >= 0x30)
             return CPU::amd_znver2;
         return CPU::amd_znver1;
-    case 0x19:  // AMD Family 19h
-        if (model <= 0x0f || model == 0x21)
+    case 25:  // AMD Family 19h
+        if (model <= 0x0f || (model >= 0x20 && model <= 0x5f))
             return CPU::amd_znver3;  // 00h-0Fh, 21h: Zen3
+        if ((model >= 0x10 && model <= 0x1f) ||
+            (model >= 0x60 && model <= 0x74) ||
+            (model >= 0x78 && model <= 0x7b) ||
+            (model >= 0xA0 && model <= 0xAf)) {
+                return CPU::amd_znver4;
+            }
         return CPU::amd_znver3; // fallback
     }
 }

From 690a87e72571491d637873f2a17c5e46f46d42aa Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Sat, 20 Jan 2024 12:29:56 -0300
Subject: [PATCH 0680/1315] check for ptls == NULL in a few places in the GC
 codebase (#52984)

Also add a few `assert(ptls != NULL)` where necessary.
---
 src/gc.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index ca53132fcbc16..53b329a76aa8e 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1601,6 +1601,7 @@ void gc_sweep_wake_all(void)
     uv_mutex_lock(&gc_threads_lock);
     for (int i = gc_first_tid; i < gc_first_tid + jl_n_markthreads; i++) {
         jl_ptls_t ptls2 = gc_all_tls_states[i];
+        assert(ptls2 != NULL); // should be a GC thread
         jl_atomic_fetch_add(&ptls2->gc_sweeps_requested, 1);
     }
     uv_cond_broadcast(&gc_threads_cond);
@@ -2953,6 +2954,7 @@ void gc_mark_and_steal(jl_ptls_t ptls)
 
 size_t gc_count_work_in_queue(jl_ptls_t ptls) JL_NOTSAFEPOINT
 {
+    assert(ptls != NULL);
     // assume each chunk is worth 256 units of work and each pointer
     // is worth 1 unit of work
     size_t work = 256 * (jl_atomic_load_relaxed(&ptls->mark_queue.chunk_queue.bottom) -
@@ -2994,7 +2996,7 @@ size_t gc_count_work_in_queue(jl_ptls_t ptls) JL_NOTSAFEPOINT
  * and therefore won't enter the mark-loop.
  */
 
-int gc_should_mark(jl_ptls_t ptls)
+int gc_should_mark(void)
 {
     int should_mark = 0;
     int n_threads_marking = jl_atomic_load(&gc_n_threads_marking);
@@ -3016,7 +3018,11 @@ int gc_should_mark(jl_ptls_t ptls)
         }
         size_t work = gc_count_work_in_queue(gc_all_tls_states[tid]);
         for (tid = gc_first_tid; tid < gc_first_tid + jl_n_markthreads; tid++) {
-            work += gc_count_work_in_queue(gc_all_tls_states[tid]);
+            jl_ptls_t ptls2 = gc_all_tls_states[tid];
+            if (ptls2 == NULL) {
+                continue;
+            }
+            work += gc_count_work_in_queue(ptls2);
         }
         // if there is a lot of work left, enter the mark loop
         if (work >= 16 * n_threads_marking) {
@@ -3047,7 +3053,7 @@ void gc_mark_loop_parallel(jl_ptls_t ptls, int master)
         jl_atomic_fetch_add(&gc_n_threads_marking, -1);
     }
     while (1) {
-        int should_mark = gc_should_mark(ptls);
+        int should_mark = gc_should_mark();
         if (!should_mark) {
             break;
         }
@@ -3079,6 +3085,9 @@ void gc_mark_clean_reclaim_sets(void)
     // Clean up `reclaim-sets`
     for (int i = 0; i < gc_n_threads; i++) {
         jl_ptls_t ptls2 = gc_all_tls_states[i];
+        if (ptls2 == NULL) {
+            continue;
+        }
         arraylist_t *reclaim_set2 = &ptls2->mark_queue.reclaim_set;
         ws_array_t *a = NULL;
         while ((a = (ws_array_t *)arraylist_pop(reclaim_set2)) != NULL) {

From 32534ddeda5d364fa6af00b11460624e81ae4580 Mon Sep 17 00:00:00 2001
From: Eric Hanson <5846501+ericphanson@users.noreply.github.com>
Date: Sat, 20 Jan 2024 17:00:29 +0100
Subject: [PATCH 0681/1315] implement `@time` and `@timev` in terms of `@timed`
 (#52889)

closes https://github.com/JuliaLang/julia/issues/47056

I suspect there was some reason this wasn't done in the first place, but
I figured opening a PR could be a way to discuss that.

~~Needs tests still for the new `@timed` fields.~~

---------

Co-authored-by: inky <git@wo-class.cn>
---
 NEWS.md        |  1 +
 base/timing.jl | 59 +++++++++++++++++++++++---------------------------
 test/misc.jl   |  3 +++
 3 files changed, 31 insertions(+), 32 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index fed1fae81dd83..ed065939ad067 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -93,6 +93,7 @@ New library features
   content is fully written, then call `closewrite` manually to avoid
   data-races. Or use the callback form of `open` to have all that handled
   automatically.
+* `@timed` now additionally returns the elapsed compilation and recompilation time ([#52889])
 
 Standard library changes
 ------------------------
diff --git a/base/timing.jl b/base/timing.jl
index 472efcd94cb08..e980cb9a05e93 100644
--- a/base/timing.jl
+++ b/base/timing.jl
@@ -281,20 +281,10 @@ macro time(ex)
 end
 macro time(msg, ex)
     quote
-        Experimental.@force_compile
-        local stats = gc_num()
-        local elapsedtime = time_ns()
-        cumulative_compile_timing(true)
-        local compile_elapsedtimes = cumulative_compile_time_ns()
-        local val = @__tryfinally($(esc(ex)),
-            (elapsedtime = time_ns() - elapsedtime;
-            cumulative_compile_timing(false);
-            compile_elapsedtimes = cumulative_compile_time_ns() .- compile_elapsedtimes)
-        )
-        local diff = GC_Diff(gc_num(), stats)
+        local ret = @timed $(esc(ex))
         local _msg = $(esc(msg))
-        time_print(stdout, elapsedtime, diff.allocd, diff.total_time, gc_alloc_count(diff), first(compile_elapsedtimes), last(compile_elapsedtimes), true; msg=_msg)
-        val
+        time_print(stdout, ret.time*1e9, ret.gcstats.allocd, ret.gcstats.total_time, gc_alloc_count(ret.gcstats), ret.compile_time*1e9, ret.recompile_time*1e9, true; msg=_msg)
+        ret.value
     end
 end
 
@@ -363,20 +353,10 @@ macro timev(ex)
 end
 macro timev(msg, ex)
     quote
-        Experimental.@force_compile
-        local stats = gc_num()
-        local elapsedtime = time_ns()
-        cumulative_compile_timing(true)
-        local compile_elapsedtimes = cumulative_compile_time_ns()
-        local val = @__tryfinally($(esc(ex)),
-            (elapsedtime = time_ns() - elapsedtime;
-            cumulative_compile_timing(false);
-            compile_elapsedtimes = cumulative_compile_time_ns() .- compile_elapsedtimes)
-        )
-        local diff = GC_Diff(gc_num(), stats)
+        local ret = @timed $(esc(ex))
         local _msg = $(esc(msg))
-        timev_print(elapsedtime, diff, compile_elapsedtimes; msg=_msg)
-        val
+        timev_print(ret.time*1e9, ret.gcstats, (ret.compile_time*1e9, ret.recompile_time*1e9); msg=_msg)
+        ret.value
     end
 end
 
@@ -472,9 +452,9 @@ end
 """
     @timed
 
-A macro to execute an expression, and return the value of the expression, elapsed time,
-total bytes allocated, garbage collection time, and an object with various memory allocation
-counters.
+A macro to execute an expression, and return the value of the expression, elapsed time in seconds,
+total bytes allocated, garbage collection time, an object with various memory allocation
+counters, compilation time in seconds, and recompilation time in seconds.
 
 In some cases the system will look inside the `@timed` expression and compile some of the
 called code before execution of the top-level expression begins. When that happens, some
@@ -500,19 +480,34 @@ julia> propertynames(stats.gcstats)
 
 julia> stats.gcstats.total_time
 5576500
+
+julia> stats.compile_time
+0.0
+
+julia> stats.recompile_time
+0.0
+
 ```
 
 !!! compat "Julia 1.5"
     The return type of this macro was changed from `Tuple` to `NamedTuple` in Julia 1.5.
+
+!!! compat "Julia 1.11"
+    The `compile_time` and `recompile_time` fields were added in Julia 1.11.
 """
 macro timed(ex)
     quote
         Experimental.@force_compile
         local stats = gc_num()
         local elapsedtime = time_ns()
-        local val = $(esc(ex))
-        elapsedtime = time_ns() - elapsedtime
+        cumulative_compile_timing(true)
+        local compile_elapsedtimes = cumulative_compile_time_ns()
+        local val = @__tryfinally($(esc(ex)),
+            (elapsedtime = time_ns() - elapsedtime;
+            cumulative_compile_timing(false);
+            compile_elapsedtimes = cumulative_compile_time_ns() .- compile_elapsedtimes)
+        )
         local diff = GC_Diff(gc_num(), stats)
-        (value=val, time=elapsedtime/1e9, bytes=diff.allocd, gctime=diff.total_time/1e9, gcstats=diff)
+        (value=val, time=elapsedtime/1e9, bytes=diff.allocd, gctime=diff.total_time/1e9, gcstats=diff, compile_time=compile_elapsedtimes[1]/1e9, recompile_time=compile_elapsedtimes[2]/1e9)
     end
 end
diff --git a/test/misc.jl b/test/misc.jl
index 03cf59acb59a3..6f6dd3d806a7b 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -265,6 +265,9 @@ let
     stats = @timed sin(1)
     @test stats.value == sin(1)
     @test isa(stats.time, Real) && stats.time >= 0
+    @test isa(stats.compile_time, Real) && stats.compile_time >= 0
+    @test isa(stats.recompile_time, Real) && stats.recompile_time >= 0
+    @test stats.compile_time <= stats.time
 
     # The return type of gcstats was changed in Julia 1.4 (# 34147)
     # Test that the 1.0 API still works

From 8bb01092b6d1099fe0c442668075a26dda0b6013 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Sat, 20 Jan 2024 19:18:28 +0100
Subject: [PATCH 0682/1315] Add note to `names` docstring about not implying
 isdefined (#51593)

---
 base/reflection.jl | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/base/reflection.jl b/base/reflection.jl
index 67044350e6b25..31e9d6de3a70c 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -84,6 +84,11 @@ are also included. Names are returned in sorted order.
 As a special case, all names defined in `Main` are considered \"public\",
 since it is not idiomatic to explicitly mark names from `Main` as public.
 
+!!! note
+    `sym ∈ names(SomeModule)` does *not* imply `isdefined(SomeModule, sym)`.
+    `names` will return symbols marked with `public` or `export`, even if
+    they are not defined in the module.
+
 See also: [`isexported`](@ref), [`ispublic`](@ref), [`@locals`](@ref Base.@locals), [`@__MODULE__`](@ref).
 """
 names(m::Module; all::Bool = false, imported::Bool = false) =

From 1f111e1326a8de32264171c07c7007595a063524 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 20 Jan 2024 14:02:52 -0500
Subject: [PATCH 0683/1315] aotcompile: remove most offset code (#52865)

Use absolute addresses for fvars, to avoid needing some of the copies
and complexity around them, and the buggy-ness of LLVM linker features
with doing this.

This may replace
https://github.com/JuliaLang/llvm-project/commit/a5ccdfbba7e54ea4792ff4bd61e163d209af36e1
---
 src/aotcompile.cpp                            | 106 +++++++++++++++---
 src/debuginfo.cpp                             |   7 +-
 src/llvm-multiversioning.cpp                  |  93 ++++++---------
 src/processor.cpp                             |  80 +++++++------
 src/processor.h                               |  42 +++----
 src/staticdata.c                              |  19 ++--
 test/llvmpasses/multiversioning-clone-only.ll |  37 +++---
 test/llvmpasses/multiversioning-x86.ll        |  35 +++---
 8 files changed, 225 insertions(+), 194 deletions(-)

diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 658de49561d82..773aa0c62b29b 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -144,11 +144,76 @@ GlobalValue* jl_get_llvm_function_impl(void *native_code, uint32_t idx)
 }
 
 
-static void emit_offset_table(Module &mod, ArrayRef<GlobalValue*> vars,
-                              StringRef name, Type *T_psize)
+
+template<typename T>
+static inline SmallVector<T*, 0> consume_gv(Module &M, const char *name, bool allow_bad_fvars)
+{
+    // Get information about sysimg export functions from the two global variables.
+    // Strip them from the Module so that it's easier to handle the uses.
+    GlobalVariable *gv = M.getGlobalVariable(name);
+    assert(gv && gv->hasInitializer());
+    ArrayType *Ty = cast<ArrayType>(gv->getInitializer()->getType());
+    unsigned nele = Ty->getArrayNumElements();
+    SmallVector<T*, 0> res(nele);
+    ConstantArray *ary = nullptr;
+    if (gv->getInitializer()->isNullValue()) {
+        for (unsigned i = 0; i < nele; ++i)
+            res[i] = cast<T>(Constant::getNullValue(Ty->getArrayElementType()));
+    }
+    else {
+        ary = cast<ConstantArray>(gv->getInitializer());
+        unsigned i = 0;
+        while (i < nele) {
+            llvm::Value *val = ary->getOperand(i)->stripPointerCasts();
+            if (allow_bad_fvars && (!isa<T>(val) || (isa<Function>(val) && cast<Function>(val)->isDeclaration()))) {
+                // Shouldn't happen in regular use, but can happen in bugpoint.
+                nele--;
+                continue;
+            }
+            res[i++] = cast<T>(val);
+        }
+        res.resize(nele);
+    }
+    assert(gv->use_empty());
+    gv->eraseFromParent();
+    if (ary && ary->use_empty())
+        ary->destroyConstant();
+    return res;
+}
+
+static Constant *get_ptrdiff32(Type *T_size, Constant *ptr, Constant *base)
+{
+    if (ptr->getType()->isPointerTy())
+        ptr = ConstantExpr::getPtrToInt(ptr, T_size);
+    auto ptrdiff = ConstantExpr::getSub(ptr, base);
+    return T_size->getPrimitiveSizeInBits() > 32 ? ConstantExpr::getTrunc(ptrdiff, Type::getInt32Ty(ptr->getContext())) : ptrdiff;
+}
+
+static Constant *emit_offset_table(Module &M, Type *T_size, ArrayRef<Constant*> vars,
+                                   StringRef name, StringRef suffix)
+{
+    auto T_int32 = Type::getInt32Ty(M.getContext());
+    uint32_t nvars = vars.size();
+    ArrayType *vars_type = ArrayType::get(T_int32, nvars + 1);
+    auto gv = new GlobalVariable(M, vars_type, true,
+                                 GlobalVariable::ExternalLinkage,
+                                 nullptr,
+                                 name + "_offsets" + suffix);
+    auto vbase = ConstantExpr::getPtrToInt(gv, T_size);
+    SmallVector<Constant*, 0> offsets(nvars + 1);
+    offsets[0] = ConstantInt::get(T_int32, nvars);
+    for (uint32_t i = 0; i < nvars; i++)
+        offsets[i + 1] = get_ptrdiff32(T_size, vars[i], vbase);
+    gv->setInitializer(ConstantArray::get(vars_type, offsets));
+    gv->setVisibility(GlobalValue::HiddenVisibility);
+    gv->setDSOLocal(true);
+    return vbase;
+}
+
+static void emit_table(Module &mod, ArrayRef<GlobalValue*> vars,
+                       StringRef name, Type *T_psize)
 {
     // Emit a global variable with all the variable addresses.
-    // The cloning pass will convert them into offsets.
     size_t nvars = vars.size();
     SmallVector<Constant*, 0> addrs(nvars);
     for (size_t i = 0; i < nvars; i++) {
@@ -529,14 +594,13 @@ static GlobalVariable *emit_shard_table(Module &M, Type *T_size, Type *T_psize,
             return gv;
         };
         auto table = tables.data() + i * sizeof(jl_image_shard_t) / sizeof(void *);
-        table[offsetof(jl_image_shard_t, fvar_base) / sizeof(void*)] = create_gv("jl_fvar_base", false);
-        table[offsetof(jl_image_shard_t, fvar_offsets) / sizeof(void*)] = create_gv("jl_fvar_offsets", true);
+        table[offsetof(jl_image_shard_t, fvar_count) / sizeof(void*)] = create_gv("jl_fvar_count", true);
+        table[offsetof(jl_image_shard_t, fvar_ptrs) / sizeof(void*)] = create_gv("jl_fvar_ptrs", true);
         table[offsetof(jl_image_shard_t, fvar_idxs) / sizeof(void*)] = create_gv("jl_fvar_idxs", true);
-        table[offsetof(jl_image_shard_t, gvar_base) / sizeof(void*)] = create_gv("jl_gvar_base", false);
         table[offsetof(jl_image_shard_t, gvar_offsets) / sizeof(void*)] = create_gv("jl_gvar_offsets", true);
         table[offsetof(jl_image_shard_t, gvar_idxs) / sizeof(void*)] = create_gv("jl_gvar_idxs", true);
         table[offsetof(jl_image_shard_t, clone_slots) / sizeof(void*)] = create_gv("jl_clone_slots", true);
-        table[offsetof(jl_image_shard_t, clone_offsets) / sizeof(void*)] = create_gv("jl_clone_offsets", true);
+        table[offsetof(jl_image_shard_t, clone_ptrs) / sizeof(void*)] = create_gv("jl_clone_ptrs", true);
         table[offsetof(jl_image_shard_t, clone_idxs) / sizeof(void*)] = create_gv("jl_clone_idxs", true);
     }
     auto tables_arr = ConstantArray::get(ArrayType::get(T_psize, tables.size()), tables);
@@ -1223,7 +1287,7 @@ static void materializePreserved(Module &M, Partition &partition) {
 }
 
 // Reconstruct jl_fvars, jl_gvars, jl_fvars_idxs, and jl_gvars_idxs from the partition
-static void construct_vars(Module &M, Partition &partition) {
+static void construct_vars(Module &M, Partition &partition, StringRef suffix) {
     SmallVector<std::pair<uint32_t, GlobalValue *>> fvar_pairs;
     fvar_pairs.reserve(partition.fvars.size());
     for (auto &fvar : partition.fvars) {
@@ -1249,7 +1313,7 @@ static void construct_vars(Module &M, Partition &partition) {
         assert(!GV->isDeclaration());
         gvar_pairs.push_back({ gvar.second, GV });
     }
-    SmallVector<GlobalValue *, 0> gvars;
+    SmallVector<Constant*, 0> gvars;
     SmallVector<uint32_t, 0> gvar_idxs;
     gvars.reserve(gvar_pairs.size());
     gvar_idxs.reserve(gvar_pairs.size());
@@ -1260,9 +1324,9 @@ static void construct_vars(Module &M, Partition &partition) {
     }
 
     // Now commit the fvars, gvars, and idxs
-    auto T_psize = M.getDataLayout().getIntPtrType(M.getContext())->getPointerTo();
-    emit_offset_table(M, fvars, "jl_fvars", T_psize);
-    emit_offset_table(M, gvars, "jl_gvars", T_psize);
+    auto T_size = M.getDataLayout().getIntPtrType(M.getContext());
+    emit_table(M, fvars, "jl_fvars", T_size->getPointerTo());
+    emit_offset_table(M, T_size, gvars, "jl_gvar", suffix);
     auto fidxs = ConstantDataArray::get(M.getContext(), fvar_idxs);
     auto fidxs_var = new GlobalVariable(M, fidxs->getType(), true,
                                         GlobalVariable::ExternalLinkage,
@@ -1272,7 +1336,7 @@ static void construct_vars(Module &M, Partition &partition) {
     auto gidxs = ConstantDataArray::get(M.getContext(), gvar_idxs);
     auto gidxs_var = new GlobalVariable(M, gidxs->getType(), true,
                                         GlobalVariable::ExternalLinkage,
-                                        gidxs, "jl_gvar_idxs");
+                                        gidxs, "jl_gvar_idxs" + suffix);
     gidxs_var->setVisibility(GlobalValue::HiddenVisibility);
     gidxs_var->setDSOLocal(true);
 }
@@ -1330,6 +1394,13 @@ static SmallVector<AOTOutputs, 16> add_output(Module &M, TargetMachine &TM, Stri
         output_timer.startTimer();
         {
             JL_TIMING(NATIVE_AOT, NATIVE_Opt);
+            // convert gvars to the expected offset table format for shard 0
+            if (M.getGlobalVariable("jl_gvars")) {
+                auto gvars = consume_gv<Constant>(M, "jl_gvars", false);
+                Type *T_size = M.getDataLayout().getIntPtrType(M.getContext());
+                emit_offset_table(M, T_size, gvars, "jl_gvar", "_0"); // module flag "julia.mv.suffix"
+                M.getGlobalVariable("jl_gvar_idxs")->setName("jl_gvar_idxs_0");
+            }
             outputs[0] = add_output_impl(M, TM, timers[0], unopt_out, opt_out, obj_out, asm_out);
         }
         output_timer.stopTimer();
@@ -1392,8 +1463,9 @@ static SmallVector<AOTOutputs, 16> add_output(Module &M, TargetMachine &TM, Stri
                 timers[i].materialize.stopTimer();
 
                 timers[i].construct.startTimer();
-                construct_vars(*M, partitions[i]);
-                M->setModuleFlag(Module::Error, "julia.mv.suffix", MDString::get(M->getContext(), "_" + std::to_string(i)));
+                std::string suffix = "_" + std::to_string(i);
+                construct_vars(*M, partitions[i], suffix);
+                M->setModuleFlag(Module::Error, "julia.mv.suffix", MDString::get(M->getContext(), suffix));
                 // The DICompileUnit file is not used for anything, but ld64 requires it be a unique string per object file
                 // or it may skip emitting debug info for that file. Here set it to ./julia#N
                 DIFile *topfile = DIFile::get(M->getContext(), "julia#" + std::to_string(i), ".");
@@ -1665,8 +1737,8 @@ void jl_dump_native_impl(void *native_code,
             LLVM_DEBUG(dbgs() << "Using " << threads << " to emit aot image\n");
             nfvars = data->jl_sysimg_fvars.size();
             ngvars = data->jl_sysimg_gvars.size();
-            emit_offset_table(dataM, data->jl_sysimg_gvars, "jl_gvars", T_psize);
-            emit_offset_table(dataM, data->jl_sysimg_fvars, "jl_fvars", T_psize);
+            emit_table(dataM, data->jl_sysimg_gvars, "jl_gvars", T_psize);
+            emit_table(dataM, data->jl_sysimg_fvars, "jl_fvars", T_psize);
             SmallVector<uint32_t, 0> idxs;
             idxs.resize(data->jl_sysimg_gvars.size());
             std::iota(idxs.begin(), idxs.end(), 0);
diff --git a/src/debuginfo.cpp b/src/debuginfo.cpp
index 47f8422133600..5cb7401a036d4 100644
--- a/src/debuginfo.cpp
+++ b/src/debuginfo.cpp
@@ -1137,7 +1137,7 @@ bool jl_dylib_DI_for_fptr(size_t pointer, object::SectionRef *Section, int64_t *
     if (entry.obj)
         *Section = getModuleSectionForAddress(entry.obj, pointer + entry.slide);
     // Assume we only need base address for sysimg for now
-    if (!inimage || !image_info.fptrs.base)
+    if (!inimage || 0 == image_info.fptrs.nptrs)
         saddr = nullptr;
     get_function_name_and_base(*Section, pointer, entry.slide, inimage, saddr, name, untrusted_dladdr);
     return true;
@@ -1180,9 +1180,8 @@ static int jl_getDylibFunctionInfo(jl_frame_t **frames, size_t pointer, int skip
         JITDebugInfoRegistry::image_info_t image;
         bool inimage = getJITDebugRegistry().get_image_info(fbase, &image);
         if (isImage && saddr && inimage) {
-            intptr_t diff = (uintptr_t)saddr - (uintptr_t)image.fptrs.base;
             for (size_t i = 0; i < image.fptrs.nclones; i++) {
-                if (diff == image.fptrs.clone_offsets[i]) {
+                if (saddr == image.fptrs.clone_ptrs[i]) {
                     uint32_t idx = image.fptrs.clone_idxs[i] & jl_sysimg_val_mask;
                     if (idx < image.fvars_n) // items after this were cloned but not referenced directly by a method (such as our ccall PLT thunks)
                         frame0->linfo = image.fvars_linfo[idx];
@@ -1190,7 +1189,7 @@ static int jl_getDylibFunctionInfo(jl_frame_t **frames, size_t pointer, int skip
                 }
             }
             for (size_t i = 0; i < image.fvars_n; i++) {
-                if (diff == image.fptrs.offsets[i]) {
+                if (saddr == image.fptrs.ptrs[i]) {
                     frame0->linfo = image.fvars_linfo[i];
                     break;
                 }
diff --git a/src/llvm-multiversioning.cpp b/src/llvm-multiversioning.cpp
index cf6afaf153fb1..d1c3f9bc464eb 100644
--- a/src/llvm-multiversioning.cpp
+++ b/src/llvm-multiversioning.cpp
@@ -384,7 +384,6 @@ struct CloneCtx {
     SmallVector<Group, 0> groups{};
     SmallVector<Target *, 0> linearized;
     SmallVector<Function*, 0> fvars;
-    SmallVector<Constant*, 0> gvars;
     Module &M;
     Type *T_size;
     Triple TT;
@@ -441,7 +440,6 @@ CloneCtx::CloneCtx(Module &M, bool allow_bad_fvars)
     : tbaa_const(tbaa_make_child_with_context(M.getContext(), "jtbaa_const", nullptr, true).first),
       specs(*get_target_specs(M)),
       fvars(consume_gv<Function>(M, "jl_fvars", allow_bad_fvars)),
-      gvars(consume_gv<Constant>(M, "jl_gvars", false)),
       M(M),
       T_size(M.getDataLayout().getIntPtrType(M.getContext())),
       TT(M.getTargetTriple()),
@@ -876,47 +874,28 @@ static Constant *get_ptrdiff32(Type *T_size, Constant *ptr, Constant *base)
     if (ptr->getType()->isPointerTy())
         ptr = ConstantExpr::getPtrToInt(ptr, T_size);
     auto ptrdiff = ConstantExpr::getSub(ptr, base);
-    return sizeof(void*) == 8 ? ConstantExpr::getTrunc(ptrdiff, Type::getInt32Ty(ptr->getContext())) : ptrdiff;
+    return T_size->getPrimitiveSizeInBits() > 32 ? ConstantExpr::getTrunc(ptrdiff, Type::getInt32Ty(ptr->getContext())) : ptrdiff;
 }
 
-template<typename T>
-static Constant *emit_offset_table(Module &M, Type *T_size, const SmallVectorImpl<T*> &vars,
-                                   StringRef name, StringRef suffix)
+static void emit_table(Module &M, Type *T_size, ArrayRef<Constant*> vars, StringRef name, StringRef suffix)
 {
-    auto T_int32 = Type::getInt32Ty(M.getContext());
     uint32_t nvars = vars.size();
-    Constant *base = nullptr;
-    if (nvars > 0) {
-        base = ConstantExpr::getBitCast(vars[0], T_size->getPointerTo());
-        auto ga = GlobalAlias::create(T_size, 0, GlobalVariable::ExternalLinkage,
-                                       name + "_base" + suffix,
-                                       base, &M);
-        ga->setVisibility(GlobalValue::HiddenVisibility);
-        ga->setDSOLocal(true);
-    } else {
-        auto gv = new GlobalVariable(M, T_size, true, GlobalValue::ExternalLinkage, Constant::getNullValue(T_size), name + "_base" + suffix);
-        gv->setVisibility(GlobalValue::HiddenVisibility);
-        gv->setDSOLocal(true);
-        base = gv;
-    }
-    auto vbase = ConstantExpr::getPtrToInt(base, T_size);
-    SmallVector<Constant*, 0> offsets(nvars + 1);
-    offsets[0] = ConstantInt::get(T_int32, nvars);
-    if (nvars > 0) {
-        offsets[1] = ConstantInt::get(T_int32, 0);
-        for (uint32_t i = 1; i < nvars; i++)
-            offsets[i + 1] = get_ptrdiff32(T_size, vars[i], vbase);
-    }
-    ArrayType *vars_type = ArrayType::get(T_int32, nvars + 1);
-    auto gv = new GlobalVariable(M, vars_type, true,
-                                  GlobalVariable::ExternalLinkage,
-                                  ConstantArray::get(vars_type, offsets),
-                                  name + "_offsets" + suffix);
+    SmallVector<Constant*,0> castvars(nvars);
+    for (size_t i = 0; i < nvars; i++)
+        castvars[i] = ConstantExpr::getBitCast(vars[i], T_size->getPointerTo());
+    auto gv = new GlobalVariable(M, T_size, true, GlobalValue::ExternalLinkage, ConstantInt::get(T_size, nvars), name + "_count" + suffix);
+    gv->setVisibility(GlobalValue::HiddenVisibility);
+    gv->setDSOLocal(true);
+    ArrayType *vars_type = ArrayType::get(T_size->getPointerTo(), nvars);
+    gv = new GlobalVariable(M, vars_type, false,
+                            GlobalVariable::ExternalLinkage,
+                            ConstantArray::get(vars_type, castvars),
+                            name + "_ptrs" + suffix);
     gv->setVisibility(GlobalValue::HiddenVisibility);
     gv->setDSOLocal(true);
-    return vbase;
 }
 
+
 void CloneCtx::emit_metadata()
 {
     uint32_t nfvars = fvars.size();
@@ -931,11 +910,8 @@ void CloneCtx::emit_metadata()
     }
 
     // Store back the information about exported functions.
-    auto fbase = emit_offset_table(M, T_size, fvars, "jl_fvar", suffix);
-    auto gbase = emit_offset_table(M, T_size, gvars, "jl_gvar", suffix);
-
+    emit_table(M, T_size, ArrayRef<Constant*>((Constant* const*)fvars.data(), fvars.size()), "jl_fvar", suffix);
     M.getGlobalVariable("jl_fvar_idxs")->setName("jl_fvar_idxs" + suffix);
-    M.getGlobalVariable("jl_gvar_idxs")->setName("jl_gvar_idxs" + suffix);
 
     uint32_t ntargets = specs.size();
 
@@ -944,8 +920,8 @@ void CloneCtx::emit_metadata()
     {
         auto T_int32 = Type::getInt32Ty(M.getContext());
         std::sort(gv_relocs.begin(), gv_relocs.end(),
-                         [] (const std::pair<Constant*,uint32_t> &lhs,
-                             const std::pair<Constant*,uint32_t> &rhs) {
+                         [] (const std::pair<Constant*, uint32_t> &lhs,
+                             const std::pair<Constant*, uint32_t> &rhs) {
                              return lhs.second < rhs.second;
                          });
         SmallVector<Constant*, 0> values{nullptr};
@@ -960,28 +936,31 @@ void CloneCtx::emit_metadata()
                  gv_reloc_idx++) {
                 shared_relocs.insert(id);
                 values.push_back(id_v);
-                values.push_back(get_ptrdiff32(T_size, gv_relocs[gv_reloc_idx].first, gbase));
+                values.push_back(gv_relocs[gv_reloc_idx].first);
             }
             auto it = const_relocs.find(id);
             if (it != const_relocs.end()) {
                 shared_relocs.insert(id);
                 values.push_back(id_v);
-                values.push_back(get_ptrdiff32(T_size, it->second, gbase));
+                values.push_back(it->second);
             }
         }
         values[0] = ConstantInt::get(T_int32, values.size() / 2);
         ArrayType *vars_type = ArrayType::get(T_int32, values.size());
-        auto gv = new GlobalVariable(M, vars_type, true, GlobalVariable::ExternalLinkage,
-                                      ConstantArray::get(vars_type, values),
-                                      "jl_clone_slots" + suffix);
+        auto gv = new GlobalVariable(M, vars_type, true, GlobalVariable::ExternalLinkage, nullptr, "jl_clone_slots" + suffix);
+        auto gbase = ConstantExpr::getPtrToInt(gv, T_size);
+        for (size_t i = 2; i < values.size(); i += 2)
+            values[i] = get_ptrdiff32(T_size, values[i], gbase);
+        gv->setInitializer(ConstantArray::get(vars_type, values));
         gv->setVisibility(GlobalValue::HiddenVisibility);
         gv->setDSOLocal(true);
     }
 
-    // Generate `jl_dispatch_fvars_idxs` and `jl_dispatch_fvars_offsets`
+    // Generate `jl_dispatch_fvars_idxs` and `jl_dispatch_fvars`
     {
         SmallVector<uint32_t, 0> idxs;
-        SmallVector<Constant*, 0> offsets;
+        SmallVector<Constant*, 0> fptrs;
+        Type *Tfptr = T_size->getPointerTo();
         for (uint32_t i = 0; i < ntargets; i++) {
             auto tgt = linearized[i];
             auto &spec = specs[i];
@@ -997,7 +976,7 @@ void CloneCtx::emit_metadata()
                         idxs.push_back(j);
                     }
                     if (i != 0) {
-                        offsets.push_back(get_ptrdiff32(T_size, grp->base_func(fvars[j]), fbase));
+                        fptrs.push_back(grp->base_func(fvars[j]));
                     }
                 }
             }
@@ -1011,12 +990,12 @@ void CloneCtx::emit_metadata()
                         count++;
                         idxs.push_back(jl_sysimg_tag_mask | j);
                         auto f = map_get(*tgt->vmap, base_f, base_f);
-                        offsets.push_back(get_ptrdiff32(T_size, cast<Function>(f), fbase));
+                        fptrs.push_back(cast<Function>(f));
                     }
                     else if (auto f = map_get(*tgt->vmap, base_f)) {
                         count++;
                         idxs.push_back(j);
-                        offsets.push_back(get_ptrdiff32(T_size, cast<Function>(f), fbase));
+                        fptrs.push_back(cast<Function>(f));
                     }
                 }
             }
@@ -1028,11 +1007,13 @@ void CloneCtx::emit_metadata()
                                       idxval, "jl_clone_idxs" + suffix);
         gv1->setVisibility(GlobalValue::HiddenVisibility);
         gv1->setDSOLocal(true);
-        ArrayType *offsets_type = ArrayType::get(Type::getInt32Ty(M.getContext()), offsets.size());
+        for (size_t i = 0; i < fptrs.size(); i++)
+            fptrs[i] = ConstantExpr::getBitCast(fptrs[i], Tfptr);
+        ArrayType *offsets_type = ArrayType::get(Tfptr, fptrs.size());
         auto gv2 = new GlobalVariable(M, offsets_type, true,
                                       GlobalVariable::ExternalLinkage,
-                                      ConstantArray::get(offsets_type, offsets),
-                                      "jl_clone_offsets" + suffix);
+                                      ConstantArray::get(offsets_type, fptrs),
+                                      "jl_clone_ptrs" + suffix);
         gv2->setVisibility(GlobalValue::HiddenVisibility);
         gv2->setDSOLocal(true);
     }
@@ -1065,9 +1046,7 @@ static bool runMultiVersioning(Module &M, bool allow_bad_fvars)
     }
 
     GlobalVariable *fvars = M.getGlobalVariable("jl_fvars");
-    GlobalVariable *gvars = M.getGlobalVariable("jl_gvars");
-    if (allow_bad_fvars && (!fvars || !fvars->hasInitializer() || !isa<ConstantArray>(fvars->getInitializer()) ||
-                            !gvars || !gvars->hasInitializer() || !isa<ConstantArray>(gvars->getInitializer())))
+    if (allow_bad_fvars && (!fvars || !fvars->hasInitializer() || !isa<ConstantArray>(fvars->getInitializer())))
         return false;
 
     CloneCtx clone(M, allow_bad_fvars);
diff --git a/src/processor.cpp b/src/processor.cpp
index ee521bd05c8b2..34d5dff3c43ee 100644
--- a/src/processor.cpp
+++ b/src/processor.cpp
@@ -649,48 +649,42 @@ static inline jl_image_t parse_sysimg(void *hdl, F &&callback)
         jl_error("Image file is not compatible with this version of Julia");
     }
 
-    llvm::SmallVector<const char *, 0> fvars(pointers->header->nfvars);
-    llvm::SmallVector<const char *, 0> gvars(pointers->header->ngvars);
+    llvm::SmallVector<void*, 0> fvars(pointers->header->nfvars);
+    llvm::SmallVector<const char*, 0> gvars(pointers->header->ngvars);
 
-    llvm::SmallVector<std::pair<uint32_t, const char *>, 0> clones;
+    llvm::SmallVector<std::pair<uint32_t, void*>, 0> clones;
 
     for (unsigned i = 0; i < pointers->header->nshards; i++) {
         auto shard = pointers->shards[i];
 
-        // .data base
-        char *data_base = (char *)shard.gvar_base;
-
-        // .text base
-        const char *text_base = shard.fvar_base;
-
-        const int32_t *offsets = shard.fvar_offsets;
-        uint32_t nfunc = offsets[0];
+        void **fvar_shard = shard.fvar_ptrs;
+        uintptr_t nfunc = *shard.fvar_count;
         assert(nfunc <= pointers->header->nfvars);
-        offsets++;
         const int32_t *reloc_slots = shard.clone_slots;
         const uint32_t nreloc = reloc_slots[0];
-        reloc_slots += 1;
+        reloc_slots++;
         const uint32_t *clone_idxs = shard.clone_idxs;
-        const int32_t *clone_offsets = shard.clone_offsets;
+        void **clone_ptrs = shard.clone_ptrs;
         uint32_t tag_len = clone_idxs[0];
-        clone_idxs += 1;
+        clone_idxs++;
 
         assert(tag_len & jl_sysimg_tag_mask);
-        llvm::SmallVector<const int32_t*, 0> base_offsets = {offsets};
+        llvm::SmallVector<void**, 0> base_ptrs(0);
+        base_ptrs.push_back(fvar_shard);
         // Find target
-        for (uint32_t i = 0;i < target_idx;i++) {
+        for (uint32_t i = 0; i < target_idx; i++) {
             uint32_t len = jl_sysimg_val_mask & tag_len;
             if (jl_sysimg_tag_mask & tag_len) {
-                if (i != 0)
-                    clone_offsets += nfunc;
                 clone_idxs += len + 1;
+                if (i != 0)
+                    clone_ptrs += nfunc;
             }
             else {
-                clone_offsets += len;
+                clone_ptrs += len;
                 clone_idxs += len + 2;
             }
             tag_len = clone_idxs[-1];
-            base_offsets.push_back(tag_len & jl_sysimg_tag_mask ? clone_offsets : nullptr);
+            base_ptrs.push_back(tag_len & jl_sysimg_tag_mask ? clone_ptrs : nullptr);
         }
 
         bool clone_all = (tag_len & jl_sysimg_tag_mask) != 0;
@@ -698,22 +692,22 @@ static inline jl_image_t parse_sysimg(void *hdl, F &&callback)
         if (clone_all) {
             // clone_all
             if (target_idx != 0) {
-                offsets = clone_offsets;
+                fvar_shard = clone_ptrs;
             }
         }
         else {
             uint32_t base_idx = clone_idxs[0];
             assert(base_idx < target_idx);
             if (target_idx != 0) {
-                offsets = base_offsets[base_idx];
-                assert(offsets);
+                fvar_shard = base_ptrs[base_idx];
+                assert(fvar_shard);
             }
             clone_idxs++;
             unsigned start = clones.size();
             clones.resize(start + tag_len);
             auto idxs = shard.fvar_idxs;
             for (unsigned i = 0; i < tag_len; i++) {
-                clones[start + i] = {(clone_idxs[i] & ~jl_sysimg_val_mask) | idxs[clone_idxs[i] & jl_sysimg_val_mask], clone_offsets[i] + text_base};
+                clones[start + i] = {(clone_idxs[i] & ~jl_sysimg_val_mask) | idxs[clone_idxs[i] & jl_sysimg_val_mask], clone_ptrs[i]};
             }
         }
         // Do relocation
@@ -721,13 +715,13 @@ static inline jl_image_t parse_sysimg(void *hdl, F &&callback)
         uint32_t len = jl_sysimg_val_mask & tag_len;
         for (uint32_t i = 0; i < len; i++) {
             uint32_t idx = clone_idxs[i];
-            int32_t offset;
+            void *fptr;
             if (clone_all) {
-                offset = offsets[idx];
+                fptr = fvar_shard[idx];
             }
             else if (idx & jl_sysimg_tag_mask) {
                 idx = idx & jl_sysimg_val_mask;
-                offset = clone_offsets[i];
+                fptr = clone_ptrs[i];
             }
             else {
                 continue;
@@ -737,9 +731,10 @@ static inline jl_image_t parse_sysimg(void *hdl, F &&callback)
                 auto reloc_idx = ((const uint32_t*)reloc_slots)[reloc_i * 2];
                 if (reloc_idx == idx) {
                     found = true;
+                    const char *data_base = (const char*)shard.clone_slots;
                     auto slot = (const void**)(data_base + reloc_slots[reloc_i * 2 + 1]);
                     assert(slot);
-                    *slot = offset + text_base;
+                    *slot = fptr;
                 }
                 else if (reloc_idx > idx) {
                     break;
@@ -751,34 +746,35 @@ static inline jl_image_t parse_sysimg(void *hdl, F &&callback)
 
         auto fidxs = shard.fvar_idxs;
         for (uint32_t i = 0; i < nfunc; i++) {
-            fvars[fidxs[i]] = text_base + offsets[i];
+            fvars[fidxs[i]] = fvar_shard[i];
         }
 
+        // .data base
         auto gidxs = shard.gvar_idxs;
         unsigned ngvars = shard.gvar_offsets[0];
         assert(ngvars <= pointers->header->ngvars);
+        char *data_base = (char*)shard.gvar_offsets;
         for (uint32_t i = 0; i < ngvars; i++) {
             gvars[gidxs[i]] = data_base + shard.gvar_offsets[i+1];
         }
     }
 
     if (!fvars.empty()) {
-        auto offsets = (int32_t *) malloc(sizeof(int32_t) * fvars.size());
-        res.fptrs.base = fvars[0];
+        auto ptrs = (void**) malloc(sizeof(void*) * fvars.size());
         for (size_t i = 0; i < fvars.size(); i++) {
             assert(fvars[i] && "Missing function pointer!");
-            offsets[i] = fvars[i] - res.fptrs.base;
+            ptrs[i] = fvars[i];
         }
-        res.fptrs.offsets = offsets;
-        res.fptrs.noffsets = fvars.size();
+        res.fptrs.ptrs = ptrs;
+        res.fptrs.nptrs = fvars.size();
     }
 
     if (!gvars.empty()) {
-        auto offsets = (int32_t *) malloc(sizeof(int32_t) * gvars.size());
-        res.gvars_base = (uintptr_t *)gvars[0];
+        auto offsets = (int32_t*)malloc(sizeof(int32_t) * gvars.size());
+        res.gvars_base = (const char*)pointers->header;
         for (size_t i = 0; i < gvars.size(); i++) {
             assert(gvars[i] && "Missing global variable pointer!");
-            offsets[i] = gvars[i] - (const char *)res.gvars_base;
+            offsets[i] = gvars[i] - res.gvars_base;
         }
         res.gvars_offsets = offsets;
         res.ngvars = gvars.size();
@@ -787,17 +783,17 @@ static inline jl_image_t parse_sysimg(void *hdl, F &&callback)
     if (!clones.empty()) {
         assert(!fvars.empty());
         std::sort(clones.begin(), clones.end(),
-            [](const std::pair<uint32_t, const char *> &a, const std::pair<uint32_t, const char *> &b) {
+            [](const std::pair<uint32_t, const void*> &a, const std::pair<uint32_t, const void*> &b) {
                 return (a.first & jl_sysimg_val_mask) < (b.first & jl_sysimg_val_mask);
         });
-        auto clone_offsets = (int32_t *) malloc(sizeof(int32_t) * clones.size());
+        auto clone_ptrs = (void**) malloc(sizeof(void*) * clones.size());
         auto clone_idxs = (uint32_t *) malloc(sizeof(uint32_t) * clones.size());
         for (size_t i = 0; i < clones.size(); i++) {
             clone_idxs[i] = clones[i].first;
-            clone_offsets[i] = clones[i].second - res.fptrs.base;
+            clone_ptrs[i] = clones[i].second;
         }
         res.fptrs.clone_idxs = clone_idxs;
-        res.fptrs.clone_offsets = clone_offsets;
+        res.fptrs.clone_ptrs = clone_ptrs;
         res.fptrs.nclones = clones.size();
     }
 
diff --git a/src/processor.h b/src/processor.h
index e49af919f67b5..5d80943d363ad 100644
--- a/src/processor.h
+++ b/src/processor.h
@@ -65,28 +65,26 @@ static const uint32_t jl_sysimg_tag_mask = 0x80000000u;
 static const uint32_t jl_sysimg_val_mask = ~((uint32_t)0x80000000u);
 
 typedef struct _jl_image_fptrs_t {
-    // base function pointer
-    const char *base;
     // number of functions
-    uint32_t noffsets;
-    // function pointer offsets
-    const int32_t *offsets;
+    uint32_t nptrs;
+    // function pointers
+    void **ptrs;
 
     // Following fields contains the information about the selected target.
     // All of these fields are 0 if the selected targets have all the functions cloned.
-    // Instead the offsets are stored in `noffsets` and `offsets`.
+    // Instead the offsets are stored in `nptrs` and `ptrs`.
 
     // number of cloned functions
     uint32_t nclones;
-    // function pointer offsets of cloned functions
-    const int32_t *clone_offsets;
+    // function pointer of cloned functions
+    void **clone_ptrs;
     // sorted indices of the cloned functions (including the tag bit)
     const uint32_t *clone_idxs;
 } jl_image_fptrs_t;
 
 typedef struct {
     uint64_t base;
-    uintptr_t *gvars_base;
+    const char *gvars_base;
     const int32_t *gvars_offsets;
     uint32_t ngvars;
     jl_image_fptrs_t fptrs;
@@ -109,31 +107,25 @@ typedef struct {
 
 // Per-shard data for image shards. Each image contains header->nshards of these.
 typedef struct {
-
-    // This is the base function pointer
-    // (all other function pointers are stored as offsets to this address)
-    const char *fvar_base;
-    // The array of function pointer offsets (`int32_t`) from the base pointer.
+    // The array of function pointers (`void*`).
     // This includes all julia functions in sysimg as well as all other functions that are cloned.
     // The default function pointer is used if the function is cloned.
-    // The first element is the size of the array, which should **NOT** be used as the number
+    // The first element is the size of the array, which should **NOT** be used is the number
     // of julia functions in the sysimg.
     // Each entry in this array uniquely identifies a function we are interested in
     // (the function may have multiple function pointers corresponding to different versions).
-    // In other sysimg info, all references to functions are stored as their `uint32_t` index
-    // in this array.
-    const int32_t *fvar_offsets;
+    const uintptr_t *fvar_count;
+    void **fvar_ptrs;
     // This is the mapping of shard function index -> global function index
     // staticdata.c relies on the same order of functions in the global function array being
     // the same as what it saw when serializing the global function array. However, partitioning
     // into multiple shards will cause functions to be reordered. This array is used to map
     // back to the original function array for loading.
     const uint32_t *fvar_idxs;
-    // This is the base data pointer
-    // (all other data pointers in this shard are stored as offsets to this address)
-    uintptr_t *gvar_base;
     // This array of global variable offsets (`int32_t`) from the base pointer.
     // Similar to fvar_offsets, but for gvars
+    // This is also the base data pointer
+    // (all data pointers in this shard are stored as offsets to this address)
     const int32_t *gvar_offsets;
     // This is the mapping of shard global variable index -> global global variable index
     // Similar to fvar_idxs, but for gvars
@@ -161,14 +153,12 @@ typedef struct {
     //  this array as the original/base function offsets.
     //  For other targets, this variable contains an offset array with the length defined in
     //  `jl_dispatch_fvars_idxs`. Tagged indices need relocations.
-    const int32_t *clone_offsets;
+    void **clone_ptrs;
     //  Target-specific function indices.
     //  For each target, this includes a tagged `uint32_t` length, an optional `uint32_t` index
     //  of the base target followed by an array of tagged function indices.
     //  The base target index is required to be smaller than the index of the current target
     //  and must be the default (`0`) or a `clone_all` target.
-    //  If it's not `0`, the function pointer array for the `clone_all` target will be used as
-    //  the base function pointer offsets instead.
     //  The tag bits for both the length and the indices are the top bit.
     //  A tagged length indicates that all of the functions are cloned and the indices follows
     //  are the ones that requires relocation. The base target index is omitted in this case.
@@ -177,10 +167,8 @@ typedef struct {
     //  all other cloned functions that requires relocation.
     //  A tagged index means that the function pointer should be filled into the GOT slots
     //  identified by `jl_dispatch_reloc_slots`. There could be more than one slot per function.
-    //  (Note that a tagged index could corresponds to a functions pointer that's the same as
+    //  (Note that a tagged index could corresponds to a function's pointer that's the same as
     //  the base one since this is the only way we currently represent relocations.)
-    //  A tagged length implicitly tags all the indices and the indices will not have the tag bit
-    //  set. The lengths in this variable is needed to decode `jl_dispatch_fvars_offsets`.
     const uint32_t *clone_idxs;
 } jl_image_shard_t;
 
diff --git a/src/staticdata.c b/src/staticdata.c
index ee605d06cc2c5..e8ac99043b78d 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -583,9 +583,9 @@ typedef struct {
 static void *jl_sysimg_handle = NULL;
 static jl_image_t sysimage;
 
-static inline uintptr_t *sysimg_gvars(uintptr_t *base, const int32_t *offsets, size_t idx)
+static inline uintptr_t *sysimg_gvars(const char *base, const int32_t *offsets, size_t idx)
 {
-    return base + offsets[idx] / sizeof(base[0]);
+    return (uintptr_t*)(base + offsets[idx]);
 }
 
 JL_DLLEXPORT int jl_running_on_valgrind(void)
@@ -601,7 +601,7 @@ static void jl_load_sysimg_so(void)
     int imaging_mode = jl_generating_output() && !jl_options.incremental;
     // in --build mode only use sysimg data, not precompiled native code
     if (!imaging_mode && jl_options.use_sysimage_native_code==JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES) {
-        assert(sysimage.fptrs.base);
+        assert(sysimage.fptrs.ptrs);
     }
     else {
         memset(&sysimage.fptrs, 0, sizeof(sysimage.fptrs));
@@ -1880,11 +1880,11 @@ static inline uintptr_t get_item_for_reloc(jl_serializer_state *s, uintptr_t bas
         }
         switch ((jl_callingconv_t)offset) {
         case JL_API_BOXED:
-            if (s->image->fptrs.base)
+            if (s->image->fptrs.nptrs)
                 return (uintptr_t)jl_fptr_args;
             JL_FALLTHROUGH;
         case JL_API_WITH_PARAMETERS:
-            if (s->image->fptrs.base)
+            if (s->image->fptrs.nptrs)
                 return (uintptr_t)jl_fptr_sparam;
             return (uintptr_t)NULL;
         case JL_API_CONST:
@@ -2139,8 +2139,7 @@ static void jl_update_all_fptrs(jl_serializer_state *s, jl_image_t *image)
     jl_image_fptrs_t fvars = image->fptrs;
     // make these NULL now so we skip trying to restore GlobalVariable pointers later
     image->gvars_base = NULL;
-    image->fptrs.base = NULL;
-    if (fvars.base == NULL)
+    if (fvars.nptrs == 0)
         return;
 
     memcpy(image->jl_small_typeof, &jl_small_typeof, sizeof(jl_small_typeof));
@@ -2163,20 +2162,18 @@ static void jl_update_all_fptrs(jl_serializer_state *s, jl_image_t *image)
                 offset = ~offset;
             }
             jl_code_instance_t *codeinst = (jl_code_instance_t*)(base + offset);
-            uintptr_t base = (uintptr_t)fvars.base;
             assert(jl_is_method(codeinst->def->def.method) && jl_atomic_load_relaxed(&codeinst->invoke) != jl_fptr_const_return);
             assert(specfunc ? jl_atomic_load_relaxed(&codeinst->invoke) != NULL : jl_atomic_load_relaxed(&codeinst->invoke) == NULL);
             linfos[i] = codeinst->def;     // now it's a MethodInstance
-            int32_t offset = fvars.offsets[i];
+            void *fptr = fvars.ptrs[i];
             for (; clone_idx < fvars.nclones; clone_idx++) {
                 uint32_t idx = fvars.clone_idxs[clone_idx] & jl_sysimg_val_mask;
                 if (idx < i)
                     continue;
                 if (idx == i)
-                    offset = fvars.clone_offsets[clone_idx];
+                    fptr = fvars.clone_ptrs[clone_idx];
                 break;
             }
-            void *fptr = (void*)(base + offset);
             if (specfunc) {
                 jl_atomic_store_relaxed(&codeinst->specptr.fptr, fptr);
                 jl_atomic_store_relaxed(&codeinst->specsigflags, 0b111); // TODO: set only if confirmed to be true
diff --git a/test/llvmpasses/multiversioning-clone-only.ll b/test/llvmpasses/multiversioning-clone-only.ll
index 6cd407f2e461f..59a3f64a25c35 100644
--- a/test/llvmpasses/multiversioning-clone-only.ll
+++ b/test/llvmpasses/multiversioning-clone-only.ll
@@ -4,33 +4,34 @@
 
 ; RUN: opt -enable-new-pm=1 --opaque-pointers=1 --load-pass-plugin=libjulia-codegen%shlibext -passes='JuliaMultiVersioning' -S %s | FileCheck %s --allow-unused-prefixes=false --check-prefixes=CHECK,OPAQUE
 
+; CHECK: @jl_gvar_base = hidden constant i64 0
+; CHECK: @jl_gvar_offsets = hidden constant [0 x i32] zeroinitializer
 ; CHECK: @jl_fvar_idxs = hidden constant [1 x i32] zeroinitializer
 ; CHECK: @jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer
 ; TYPED: @subtarget_cloned_gv = hidden global i64* null
 ; OPAQUE: @subtarget_cloned_gv = hidden global ptr null
 ; TYPED: @subtarget_cloned.reloc_slot = hidden global i32 (i32)* null
 ; OPAQUE: @subtarget_cloned.reloc_slot = hidden global ptr null
-; CHECK: @jl_fvar_offsets = hidden constant [2 x i32] [i32 1, i32 0]
-; CHECK: @jl_gvar_base = hidden constant i64 0
-; CHECK: @jl_gvar_offsets = hidden constant [1 x i32] zeroinitializer
+; CHECK: @jl_fvar_count = hidden constant i64 1
+; TYPED: @jl_fvar_ptrs = hidden global [1 x i64*] [i64* bitcast (i32 (i32)* @subtarget_cloned to i64*)] 
+; OPAQUE: @jl_fvar_ptrs = hidden global [1 x ptr] [ptr @subtarget_cloned] 
 ; CHECK: @jl_clone_slots = hidden constant [5 x i32]
-; CHECK-SAME: i32 2, i32 0, {{.*}} sub {{.*}}@subtarget_cloned.reloc_slot{{.*}}@jl_gvar_base
+; CHECK-SAME: i32 2, i32 0, {{.*}} sub {{.*}}@subtarget_cloned.reloc_slot{{.*}}@jl_clone_slots
 ; CHECK: @jl_clone_idxs = hidden constant [13 x i32]
 ; COM: TODO actually check the clone idxs maybe?
-; CHECK: @jl_clone_offsets = hidden constant [4 x i32]
-; CHECK-SAME: sub
-; CHECK-SAME: @subtarget_cloned.1
-; CHECK-SAME: @subtarget_cloned
-; CHECK-SAME: sub
-; CHECK-SAME: @subtarget_cloned.2
-; CHECK-SAME: @subtarget_cloned
-; CHECK-SAME: sub
-
-@jl_fvars = global [1 x i64*] [i64* bitcast (i32 (i32)* @subtarget_cloned to i64*)], align 16
-@jl_gvars = global [0 x i64*] zeroinitializer, align 16
-@jl_fvar_idxs = hidden constant [1 x i32] [i32 0], align 16
-@jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer, align 16
-@subtarget_cloned_gv = hidden global i64* bitcast (i32 (i32)* @subtarget_cloned to i64*), align 16
+; TYPED: @jl_clone_ptrs = hidden constant [4 x i64*]
+; TYPED-SAME: @subtarget_cloned.1
+; TYPED-SAME: @subtarget_cloned.2
+; TYPED-SAME: @subtarget_cloned
+; TYPED-SAME: @subtarget_cloned
+; OPAQUE: @jl_clone_ptrs = hidden constant [4 x ptr] [ptr @subtarget_cloned.1, ptr @subtarget_cloned.2, ptr @subtarget_cloned, ptr @subtarget_cloned]
+
+@jl_fvars = global [1 x i64*] [i64* bitcast (i32 (i32)* @subtarget_cloned to i64*)], align 8
+@jl_gvar_base = hidden constant i64 zeroinitializer, align 8
+@jl_gvar_offsets = hidden constant [0 x i32] zeroinitializer, align 8
+@jl_fvar_idxs = hidden constant [1 x i32] [i32 0], align 8
+@jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer, align 8
+@subtarget_cloned_gv = hidden global i64* bitcast (i32 (i32)* @subtarget_cloned to i64*), align 8
 
 @subtarget_cloned_aliased = alias i32 (i32), i32 (i32)* @subtarget_cloned
 
diff --git a/test/llvmpasses/multiversioning-x86.ll b/test/llvmpasses/multiversioning-x86.ll
index ca43462e1eda9..1bc1b288a5879 100644
--- a/test/llvmpasses/multiversioning-x86.ll
+++ b/test/llvmpasses/multiversioning-x86.ll
@@ -1,29 +1,28 @@
 ; This file is a part of Julia. License is MIT: https://julialang.org/license
 
-; RUN: opt -enable-new-pm=1 --opaque-pointers=0 --load-pass-plugin=libjulia-codegen%shlibext -passes='JuliaMultiVersioning,CPUFeatures' -S %s | FileCheck %s
+; RUN: opt -enable-new-pm=1 --opaque-pointers=0 --load-pass-plugin=libjulia-codegen%shlibext -passes='JuliaMultiVersioning,CPUFeatures' -S %s | FileCheck %s --allow-unused-prefixes=false --check-prefixes=CHECK,TYPED
+
+; RUN: opt -enable-new-pm=1 --opaque-pointers=1 --load-pass-plugin=libjulia-codegen%shlibext -passes='JuliaMultiVersioning,CPUFeatures' -S %s | FileCheck %s --allow-unused-prefixes=false --check-prefixes=CHECK,OPAQUE
 
-; RUN: opt -enable-new-pm=1 --opaque-pointers=1 --load-pass-plugin=libjulia-codegen%shlibext -passes='JuliaMultiVersioning,CPUFeatures' -S %s | FileCheck %s
 
 ; COM: This test checks that multiversioning actually happens from start to finish
 ; COM: We need the fvars for a proper test
 
 
 
-; CHECK: @jl_fvar_idxs = hidden constant [5 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4], align 16
-; CHECK: @jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer, align 16
+; TYPED: @jl_gvar_ptrs = global [0 x i64*] zeroinitializer, align 8
+; OPAQUE: @jl_gvar_ptrs = global [0 x ptr] zeroinitializer, align 8
+; CHECK: @jl_fvar_idxs = hidden constant [5 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4], align 8
+; CHECK: @jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer, align 8
 ; TYPED: @simd_test.reloc_slot = hidden global i32 (<4 x i32>)* null
 ; OPAQUE: @simd_test.reloc_slot = hidden global ptr null
-; TYPED: @jl_fvar_offsets = hidden constant [6 x i32] [i32 5, i32 0, i32 trunc (i64 sub (i64 ptrtoint (float (float, float)* @fastmath_test to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (i32)* @loop_test to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test_call to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32)]
-; OPAQUE: @jl_fvar_offsets = hidden constant [6 x i32] [i32 5, i32 0, i32 trunc (i64 sub (i64 ptrtoint (ptr @fastmath_test to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @loop_test to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test_call to i64), i64 ptrtoint (ptr @boring to i64)) to i32)]
-; CHECK: @jl_gvar_base = hidden constant i64 0
-; CHECK: @jl_gvar_offsets = hidden constant [1 x i32] zeroinitializer
-; TYPED: @jl_clone_slots = hidden constant [3 x i32] [i32 1, i32 3, i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)** @simd_test.reloc_slot to i64), i64 ptrtoint (i64* @jl_gvar_base to i64)) to i32)]
-; OPAQUE: @jl_clone_slots = hidden constant [3 x i32] [i32 1, i32 3, i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test.reloc_slot to i64), i64 ptrtoint (ptr @jl_gvar_base to i64)) to i32)]
+; TYPED: @jl_fvar_ptrs = hidden global [5 x i64*] [i64* bitcast (i32 (i32)* @boring to i64*), i64* bitcast (float (float, float)* @fastmath_test to i64*), i64* bitcast (i32 (i32)* @loop_test to i64*), i64* bitcast (i32 (<4 x i32>)* @simd_test to i64*), i64* bitcast (i32 (<4 x i32>)* @simd_test_call to i64*)]
+; OPAQUE: @jl_fvar_ptrs = hidden global [5 x ptr] [ptr @boring, ptr @fastmath_test, ptr @loop_test, ptr @simd_test, ptr @simd_test_call]
+; TYPED: @jl_clone_slots = hidden constant [3 x i32] [i32 1, i32 3, i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)** @simd_test.reloc_slot to i64), i64 ptrtoint ([3 x i32]* @jl_clone_slots to i64)) to i32)]
+; OPAQUE: @jl_clone_slots = hidden constant [3 x i32] [i32 1, i32 3, i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test.reloc_slot to i64), i64 ptrtoint (ptr @jl_clone_slots to i64)) to i32)]
 ; CHECK: @jl_clone_idxs = hidden constant [10 x i32] [i32 -2147483647, i32 3, i32 -2147483647, i32 3, i32 4, i32 1, i32 1, i32 2, i32 -2147483645, i32 4]
-; TYPED: @jl_clone_offsets = hidden constant [9 x i32] [i32 trunc (i64 sub (i64 ptrtoint (i32 (i32)* @boring.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (float (float, float)* @fastmath_test.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (i32)* @loop_test.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test_call.1 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (float (float, float)* @fastmath_test.2 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (i32)* @loop_test.2 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test.2 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (i32 (<4 x i32>)* @simd_test_call.2 to i64), i64 ptrtoint (i32 (i32)* @boring to i64)) to i32)]
-; OPAQUE: @jl_clone_offsets = hidden constant [9 x i32] [i32 trunc (i64 sub (i64 ptrtoint (ptr @boring.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @fastmath_test.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @loop_test.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test_call.1 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @fastmath_test.2 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @loop_test.2 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test.2 to i64), i64 ptrtoint (ptr @boring to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint (ptr @simd_test_call.2 to i64), i64 ptrtoint (ptr @boring to i64)) to i32)]
-; TYPED: @jl_fvar_base = hidden alias i64, bitcast (i32 (i32)* @boring to i64*)
-; OPAQUE: @jl_fvar_base = hidden alias i64, ptr @boring
+; TYPED: @jl_clone_ptrs = hidden constant [9 x i64*] [i64* bitcast (i32 (i32)* @boring.1 to i64*), i64* bitcast (float (float, float)* @fastmath_test.1 to i64*), i64* bitcast (i32 (i32)* @loop_test.1 to i64*), i64* bitcast (i32 (<4 x i32>)* @simd_test.1 to i64*), i64* bitcast (i32 (<4 x i32>)* @simd_test_call.1 to i64*), i64* bitcast (float (float, float)* @fastmath_test.2 to i64*), i64* bitcast (i32 (i32)* @loop_test.2 to i64*), i64* bitcast (i32 (<4 x i32>)* @simd_test.2 to i64*), i64* bitcast (i32 (<4 x i32>)* @simd_test_call.2 to i64*)]
+; OPAQUE: @jl_clone_ptrs = hidden constant [9 x ptr] [ptr @boring.1, ptr @fastmath_test.1, ptr @loop_test.1, ptr @simd_test.1, ptr @simd_test_call.1, ptr @fastmath_test.2, ptr @loop_test.2, ptr @simd_test.2, ptr @simd_test_call.2]
 
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12:13"
@@ -34,10 +33,10 @@ target triple = "x86_64-linux-gnu"
                                i64* bitcast (i32 (i32)* @loop_test to i64*),
                                i64* bitcast (i32 (<4 x i32>)* @simd_test to i64*),
                                i64* bitcast (i32 (<4 x i32>)* @simd_test_call to i64*)
-                              ], align 16
-@jl_gvars = global [0 x i64*] zeroinitializer, align 16
-@jl_fvar_idxs = hidden constant [5 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4], align 16
-@jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer, align 16
+                              ], align 8
+@jl_gvar_ptrs = global [0 x i64*] zeroinitializer, align 8
+@jl_fvar_idxs = hidden constant [5 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4], align 8
+@jl_gvar_idxs = hidden constant [0 x i32] zeroinitializer, align 8
 
 declare i1 @julia.cpu.have_fma.f32()
 

From a9e2bd4713523f7780d24143789d9a9b993401b7 Mon Sep 17 00:00:00 2001
From: Bhuminjay Soni <76656712+11happy@users.noreply.github.com>
Date: Sun, 21 Jan 2024 16:46:12 +0530
Subject: [PATCH 0684/1315] Add general fallback for rem2pi (#52955)

**Overview:**
- This PR fixes #44715 by adding a general fallback.

**Testing:**
- Tested the updated code.
- Verified that other functionalities remain unaffected.

**Dependencies:**
- No dependencies on other pull requests.

**CC:**
- @N5N3

---------

Signed-off-by: 11happy <soni5happy@gmail.com>
Co-authored-by: N5N3 <2642243996@qq.com>
---
 base/math.jl    | 8 +++++---
 test/numbers.jl | 2 +-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/base/math.jl b/base/math.jl
index 752a15b7c7777..47f3afb56979e 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -1469,9 +1469,11 @@ end
 rem2pi(x::Float32, r::RoundingMode) = Float32(rem2pi(Float64(x), r))
 rem2pi(x::Float16, r::RoundingMode) = Float16(rem2pi(Float64(x), r))
 rem2pi(x::Int32, r::RoundingMode) = rem2pi(Float64(x), r)
-function rem2pi(x::Int64, r::RoundingMode)
-    fx = Float64(x)
-    fx == x || throw(ArgumentError("Int64 argument to rem2pi is too large: $x"))
+
+# general fallback
+function rem2pi(x::Integer, r::RoundingMode)
+    fx = float(x)
+    fx == x || throw(ArgumentError(LazyString(typeof(x), " argument to rem2pi is too large: ", x)))
     rem2pi(fx, r)
 end
 
diff --git a/test/numbers.jl b/test/numbers.jl
index a9d126aa33d5a..33b0b73c1bad3 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -2686,7 +2686,7 @@ end
     @test divrem(a,-(a-20), RoundDown) == (div(a,-(a-20), RoundDown), rem(a,-(a-20), RoundDown))
 end
 
-@testset "rem2pi $T" for T in (Float16, Float32, Float64, BigFloat)
+@testset "rem2pi $T" for T in (Float16, Float32, Float64, BigFloat, Int8, Int16, Int32, Int64, Int128)
     @test rem2pi(T(1), RoundToZero)  == 1
     @test rem2pi(T(1), RoundNearest) == 1
     @test rem2pi(T(1), RoundDown)    == 1

From 9c78420b2705636fe5f3ff111950294a2addc515 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Sun, 21 Jan 2024 16:57:20 -0300
Subject: [PATCH 0685/1315] reduce contention on page metadata lists during the
 sweeping phase (#52943)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

**EDIT**: fixes https://github.com/JuliaLang/julia/issues/52937 by
decreasing the contention on the page lists and only waking GC threads
up if we have a sufficiently large number of pages.

Seems to address the regression from the MWE of
https://github.com/JuliaLang/julia/issues/52937:

- master:
```
../julia-master/julia --project=. run_benchmarks.jl serial obj_arrays issue-52937 -n5 --gcthreads=1
bench = "issue-52937.jl"
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │      24841 │     818 │        78 │        740 │           44 │             10088 │       96 │          3 │
│  median │      24881 │     834 │        83 │        751 │           45 │             10738 │       97 │          3 │
│ maximum │      25002 │     891 │        87 │        803 │           48 │             11074 │      112 │          4 │
│   stdev │         78 │      29 │         4 │         26 │            1 │               393 │        7 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
 ../julia-master/julia --project=. run_benchmarks.jl serial obj_arrays issue-52937 -n5 --gcthreads=8
bench = "issue-52937.jl"
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │      29113 │    5200 │        68 │       5130 │           12 │              9724 │       95 │         18 │
│  median │      29354 │    5274 │        69 │       5204 │           12 │             10456 │       96 │         18 │
│ maximum │      29472 │    5333 │        70 │       5264 │           14 │             11913 │       97 │         18 │
│   stdev │        138 │      54 │         1 │         55 │            1 │               937 │        1 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```

- PR:
```
../julia-master/julia --project=. run_benchmarks.jl serial obj_arrays issue-52937 -n5 --gcthreads=1
bench = "issue-52937.jl"
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │      24475 │     761 │        77 │        681 │           40 │              9499 │       94 │          3 │
│  median │      24845 │     775 │        80 │        698 │           43 │             10793 │       97 │          3 │
│ maximum │      25128 │     811 │        85 │        726 │           47 │             12820 │      113 │          3 │
│   stdev │        240 │      22 │         3 │         21 │            3 │              1236 │        8 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
../julia-master/julia --project=. run_benchmarks.jl serial obj_arrays issue-52937 -n5 --gcthreads=8
bench = "issue-52937.jl"
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │      24709 │     679 │        70 │        609 │           11 │              9981 │       95 │          3 │
│  median │      24869 │     702 │        70 │        631 │           12 │             10705 │       96 │          3 │
│ maximum │      24911 │     708 │        72 │        638 │           13 │             10820 │       98 │          3 │
│   stdev │         79 │      12 │         1 │         12 │            1 │               401 │        1 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```

Also, performance on `objarray.jl` (an example of benchmark in which
sweeping parallelizes well with the current implementation) seems fine:

- master:
```
../julia-master/julia --project=. run_benchmarks.jl multithreaded bigarrays -n5 --gcthreads=1
bench = "objarray.jl"
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │      19301 │   10792 │      7485 │       3307 │         1651 │               196 │     4519 │         56 │
│  median │      21415 │   12646 │      9094 │       3551 │         1985 │               241 │     6576 │         59 │
│ maximum │      21873 │   13118 │      9353 │       3765 │         2781 │               330 │     8793 │         60 │
│   stdev │       1009 │     932 │       757 │        190 │          449 │                50 │     1537 │          2 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
../julia-master/julia --project=. run_benchmarks.jl multithreaded bigarrays -n5 --gcthreads=8
bench = "objarray.jl"
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │      13135 │    4377 │      3350 │       1007 │          491 │               231 │     6062 │         33 │
│  median │      13164 │    4540 │      3370 │       1177 │          669 │               256 │     6383 │         35 │
│ maximum │      13525 │    4859 │      3675 │       1184 │          748 │               320 │     7528 │         36 │
│   stdev │        183 │     189 │       146 │         77 │          129 │                42 │      584 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```

- PR:
```
../julia-master/julia --project=. run_benchmarks.jl multithreaded bigarrays -n5 --gcthreads=1
bench = "objarray.jl"
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │      19642 │   10931 │      7566 │       3365 │         1653 │               204 │     5688 │         56 │
│  median │      21441 │   12717 │      8948 │       3770 │         1796 │               217 │     6972 │         59 │
│ maximum │      23494 │   14643 │     10576 │       4067 │         2513 │               248 │     8229 │         62 │
│   stdev │       1408 │    1339 │      1079 │        267 │          393 │                19 │      965 │          2 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
../julia-master/julia --project=. run_benchmarks.jl multithreaded bigarrays -n5 --gcthreads=8
bench = "objarray.jl"
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │      13365 │    4544 │      3389 │       1104 │          516 │               255 │     6349 │         34 │
│  median │      13445 │    4624 │      3404 │       1233 │          578 │               275 │     6385 │         34 │
│ maximum │      14413 │    5278 │      3837 │       1441 │          753 │               300 │     7547 │         37 │
│   stdev │        442 │     303 │       194 │        121 │           89 │                18 │      522 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```
---
 src/gc.c        | 124 +++++++++++++++++++++++++++++++++++++++++-------
 src/gc.h        |  46 +++++++++++++++++-
 src/scheduler.c |   2 +-
 3 files changed, 154 insertions(+), 18 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 53b329a76aa8e..5d2093c3d24a3 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -21,8 +21,8 @@ int jl_n_sweepthreads;
 _Atomic(int) gc_n_threads_marking;
 // Number of threads sweeping
 _Atomic(int) gc_n_threads_sweeping;
-// Temporary for the `ptls->page_metadata_allocd` used during parallel sweeping
-_Atomic(jl_gc_page_stack_t *) gc_allocd_scratch;
+// Temporary for the `ptls->page_metadata_allocd` used during parallel sweeping (padded to avoid false sharing)
+_Atomic(jl_gc_padded_page_stack_t *) gc_allocd_scratch;
 // `tid` of mutator thread that triggered GC
 _Atomic(int) gc_master_tid;
 // `tid` of first GC thread
@@ -1596,8 +1596,72 @@ static void gc_pool_sync_nfree(jl_gc_pagemeta_t *pg, jl_taggedvalue_t *last) JL_
     pg->nfree = nfree;
 }
 
-void gc_sweep_wake_all(void)
+// pre-scan pages to check whether there are enough pages so that's worth parallelizing
+// also sweeps pages that don't need to be linearly scanned
+int gc_sweep_prescan(jl_ptls_t ptls, jl_gc_padded_page_stack_t *new_gc_allocd_scratch)
 {
+    // 4MB worth of pages is worth parallelizing
+    const int n_pages_worth_parallel_sweep = (int)(4 * (1 << 20) / GC_PAGE_SZ);
+    int n_pages_to_scan = 0;
+    gc_page_profiler_serializer_t serializer = gc_page_serializer_create();
+    for (int t_i = 0; t_i < gc_n_threads; t_i++) {
+        jl_ptls_t ptls2 = gc_all_tls_states[t_i];
+        if (ptls2 == NULL) {
+            continue;
+        }
+        jl_gc_page_stack_t *dest = &new_gc_allocd_scratch[ptls2->tid].stack;
+        jl_gc_page_stack_t tmp;
+        jl_gc_pagemeta_t *tail = NULL;
+        memset(&tmp, 0, sizeof(tmp));
+        while (1) {
+            jl_gc_pagemeta_t *pg = pop_lf_back_nosync(&ptls2->page_metadata_allocd);
+            if (pg == NULL) {
+                break;
+            }
+            int should_scan = 1;
+            if (!pg->has_marked) {
+                should_scan = 0;
+            }
+            if (!current_sweep_full && !pg->has_young) {
+                assert(!prev_sweep_full || pg->prev_nold >= pg->nold);
+                if (!prev_sweep_full || pg->prev_nold == pg->nold) {
+                    should_scan = 0;
+                }
+            }
+            if (should_scan) {
+                if (tail == NULL) {
+                    tail = pg;
+                }
+                n_pages_to_scan++;
+                push_lf_back_nosync(&tmp, pg);
+            }
+            else {
+                gc_sweep_pool_page(&serializer, dest, &ptls2->page_metadata_buffered, pg);
+            }
+            if (n_pages_to_scan >= n_pages_worth_parallel_sweep) {
+                break;
+            }
+        }
+        if (tail != NULL) {
+            tail->next = jl_atomic_load_relaxed(&ptls2->page_metadata_allocd.bottom);
+        }
+        ptls2->page_metadata_allocd = tmp;
+        if (n_pages_to_scan >= n_pages_worth_parallel_sweep) {
+            break;
+        }
+    }
+    gc_page_serializer_destroy(&serializer);
+    return n_pages_to_scan >= n_pages_worth_parallel_sweep;
+}
+
+// wake up all threads to sweep the pages
+void gc_sweep_wake_all(jl_ptls_t ptls, jl_gc_padded_page_stack_t *new_gc_allocd_scratch)
+{
+    int parallel_sweep_worthwhile = gc_sweep_prescan(ptls, new_gc_allocd_scratch);
+    jl_atomic_store(&gc_allocd_scratch, new_gc_allocd_scratch);
+    if (!parallel_sweep_worthwhile) {
+        return;
+    }
     uv_mutex_lock(&gc_threads_lock);
     for (int i = gc_first_tid; i < gc_first_tid + jl_n_markthreads; i++) {
         jl_ptls_t ptls2 = gc_all_tls_states[i];
@@ -1608,6 +1672,7 @@ void gc_sweep_wake_all(void)
     uv_mutex_unlock(&gc_threads_lock);
 }
 
+// wait for all threads to finish sweeping
 void gc_sweep_wait_for_all(void)
 {
     jl_atomic_store(&gc_allocd_scratch, NULL);
@@ -1616,36 +1681,58 @@ void gc_sweep_wait_for_all(void)
     }
 }
 
-void gc_sweep_pool_parallel(void)
+// sweep all pools
+void gc_sweep_pool_parallel(jl_ptls_t ptls)
 {
     jl_atomic_fetch_add(&gc_n_threads_sweeping, 1);
-    jl_gc_page_stack_t *allocd_scratch = jl_atomic_load(&gc_allocd_scratch);
+    jl_gc_padded_page_stack_t *allocd_scratch = jl_atomic_load(&gc_allocd_scratch);
     if (allocd_scratch != NULL) {
         gc_page_profiler_serializer_t serializer = gc_page_serializer_create();
         while (1) {
             int found_pg = 0;
+            // sequentially walk the threads and sweep the pages
             for (int t_i = 0; t_i < gc_n_threads; t_i++) {
                 jl_ptls_t ptls2 = gc_all_tls_states[t_i];
+                // skip foreign threads that already exited
                 if (ptls2 == NULL) {
                     continue;
                 }
-                jl_gc_page_stack_t *allocd = &allocd_scratch[t_i];
-                jl_gc_pagemeta_t *pg = pop_lf_back(&ptls2->page_metadata_allocd);
+                jl_gc_page_stack_t *dest = &allocd_scratch[ptls2->tid].stack;
+                jl_gc_pagemeta_t *pg = try_pop_lf_back(&ptls2->page_metadata_allocd);
+                // failed steal attempt
                 if (pg == NULL) {
                     continue;
                 }
-                gc_sweep_pool_page(&serializer, allocd, &ptls2->page_metadata_buffered, pg);
+                gc_sweep_pool_page(&serializer, dest, &ptls2->page_metadata_buffered, pg);
                 found_pg = 1;
             }
             if (!found_pg) {
-                break;
+                // check for termination
+                int no_more_work = 1;
+                for (int t_i = 0; t_i < gc_n_threads; t_i++) {
+                    jl_ptls_t ptls2 = gc_all_tls_states[t_i];
+                    // skip foreign threads that already exited
+                    if (ptls2 == NULL) {
+                        continue;
+                    }
+                    jl_gc_pagemeta_t *pg = jl_atomic_load_relaxed(&ptls2->page_metadata_allocd.bottom);
+                    if (pg != NULL) {
+                        no_more_work = 0;
+                        break;
+                    }
+                }
+                if (no_more_work) {
+                    break;
+                }
             }
+            jl_cpu_pause();
         }
         gc_page_serializer_destroy(&serializer);
     }
     jl_atomic_fetch_add(&gc_n_threads_sweeping, -1);
 }
 
+// free all pages (i.e. through `madvise` on Linux) that were lazily freed
 void gc_free_pages(void)
 {
     while (1) {
@@ -1670,7 +1757,7 @@ static void gc_sweep_pool(void)
 
     // allocate enough space to hold the end of the free list chain
     // for every thread and pool size
-    jl_taggedvalue_t ***pfl = (jl_taggedvalue_t ***) alloca(n_threads * JL_GC_N_POOLS * sizeof(jl_taggedvalue_t**));
+    jl_taggedvalue_t ***pfl = (jl_taggedvalue_t ***) malloc_s(n_threads * JL_GC_N_POOLS * sizeof(jl_taggedvalue_t**));
 
     // update metadata of pages that were pointed to by freelist or newpages from a pool
     // i.e. pages being the current allocation target
@@ -1712,17 +1799,18 @@ static void gc_sweep_pool(void)
     }
 
     // the actual sweeping
-    jl_gc_page_stack_t *tmp = (jl_gc_page_stack_t *)alloca(n_threads * sizeof(jl_gc_page_stack_t));
-    memset(tmp, 0, n_threads * sizeof(jl_gc_page_stack_t));
-    jl_atomic_store(&gc_allocd_scratch, tmp);
-    gc_sweep_wake_all();
-    gc_sweep_pool_parallel();
+    jl_gc_padded_page_stack_t *new_gc_allocd_scratch = (jl_gc_padded_page_stack_t *) malloc_s(n_threads * sizeof(jl_gc_padded_page_stack_t));
+    memset(new_gc_allocd_scratch, 0, n_threads * sizeof(jl_gc_padded_page_stack_t));
+    jl_ptls_t ptls = jl_current_task->ptls;
+    gc_sweep_wake_all(ptls, new_gc_allocd_scratch);
+    gc_sweep_pool_parallel(ptls);
     gc_sweep_wait_for_all();
 
+    // reset half-pages pointers
     for (int t_i = 0; t_i < n_threads; t_i++) {
         jl_ptls_t ptls2 = gc_all_tls_states[t_i];
         if (ptls2 != NULL) {
-            ptls2->page_metadata_allocd = tmp[t_i];
+            ptls2->page_metadata_allocd = new_gc_allocd_scratch[t_i].stack;
             for (int i = 0; i < JL_GC_N_POOLS; i++) {
                 jl_gc_pool_t *p = &ptls2->heap.norm_pools[i];
                 p->newpages = NULL;
@@ -1760,6 +1848,10 @@ static void gc_sweep_pool(void)
         }
     }
 
+    // cleanup
+    free(pfl);
+    free(new_gc_allocd_scratch);
+
 #ifdef _P64 // only enable concurrent sweeping on 64bit
     // wake thread up to sweep concurrently
     if (jl_n_sweepthreads > 0) {
diff --git a/src/gc.h b/src/gc.h
index 9de67f6e7c679..60ed90fb3415b 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -199,6 +199,23 @@ extern jl_gc_page_stack_t global_page_pool_freed;
 // in the sweeping phase, which also doesn't push a node into the
 // same stack after it's popped
 
+STATIC_INLINE void push_lf_back_nosync(jl_gc_page_stack_t *pool, jl_gc_pagemeta_t *elt) JL_NOTSAFEPOINT
+{
+    jl_gc_pagemeta_t *old_back = jl_atomic_load_relaxed(&pool->bottom);
+    elt->next = old_back;
+    jl_atomic_store_relaxed(&pool->bottom, elt);
+}
+
+STATIC_INLINE jl_gc_pagemeta_t *pop_lf_back_nosync(jl_gc_page_stack_t *pool) JL_NOTSAFEPOINT
+{
+    jl_gc_pagemeta_t *old_back = jl_atomic_load_relaxed(&pool->bottom);
+    if (old_back == NULL) {
+        return NULL;
+    }
+    jl_atomic_store_relaxed(&pool->bottom, old_back->next);
+    return old_back;
+}
+
 STATIC_INLINE void push_lf_back(jl_gc_page_stack_t *pool, jl_gc_pagemeta_t *elt) JL_NOTSAFEPOINT
 {
     while (1) {
@@ -211,6 +228,23 @@ STATIC_INLINE void push_lf_back(jl_gc_page_stack_t *pool, jl_gc_pagemeta_t *elt)
     }
 }
 
+#define MAX_POP_ATTEMPTS (1 << 10)
+
+STATIC_INLINE jl_gc_pagemeta_t *try_pop_lf_back(jl_gc_page_stack_t *pool) JL_NOTSAFEPOINT
+{
+    for (int i = 0; i < MAX_POP_ATTEMPTS; i++) {
+        jl_gc_pagemeta_t *old_back = jl_atomic_load_relaxed(&pool->bottom);
+        if (old_back == NULL) {
+            return NULL;
+        }
+        if (jl_atomic_cmpswap(&pool->bottom, &old_back, old_back->next)) {
+            return old_back;
+        }
+        jl_cpu_pause();
+    }
+    return NULL;
+}
+
 STATIC_INLINE jl_gc_pagemeta_t *pop_lf_back(jl_gc_page_stack_t *pool) JL_NOTSAFEPOINT
 {
     while (1) {
@@ -224,6 +258,16 @@ STATIC_INLINE jl_gc_pagemeta_t *pop_lf_back(jl_gc_page_stack_t *pool) JL_NOTSAFE
         jl_cpu_pause();
     }
 }
+typedef struct {
+    jl_gc_page_stack_t stack;
+    // pad to 128 bytes to avoid false-sharing
+#ifdef _P64
+    void *_pad[15];
+#else
+    void *_pad[31];
+#endif
+} jl_gc_padded_page_stack_t;
+static_assert(sizeof(jl_gc_padded_page_stack_t) == 128, "jl_gc_padded_page_stack_t is not 128 bytes");
 
 typedef struct {
     _Atomic(size_t) n_freed_objs;
@@ -473,7 +517,7 @@ void gc_mark_finlist(jl_gc_markqueue_t *mq, arraylist_t *list, size_t start) JL_
 void gc_mark_loop_serial_(jl_ptls_t ptls, jl_gc_markqueue_t *mq);
 void gc_mark_loop_serial(jl_ptls_t ptls);
 void gc_mark_loop_parallel(jl_ptls_t ptls, int master);
-void gc_sweep_pool_parallel(void);
+void gc_sweep_pool_parallel(jl_ptls_t ptls);
 void gc_free_pages(void);
 void sweep_stack_pools(void);
 void jl_gc_debug_init(void);
diff --git a/src/scheduler.c b/src/scheduler.c
index 50e15b286a8eb..2af88db89ca14 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -147,7 +147,7 @@ void jl_parallel_gc_threadfun(void *arg)
             gc_mark_loop_parallel(ptls, 0);
         }
         if (may_sweep(ptls)) { // not an else!
-            gc_sweep_pool_parallel();
+            gc_sweep_pool_parallel(ptls);
             jl_atomic_fetch_add(&ptls->gc_sweeps_requested, -1);
         }
     }

From 188cc9320940d32930580dae7e33f488a7499251 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 22 Jan 2024 11:02:13 +0900
Subject: [PATCH 0686/1315] move `REPL.REPLCompletions.UndefVarError_hint` to
 `REPL` module (#52990)

Since `UndefVarError_hint` is an interactive feature and isn't directly
related to completion, it seems more appropriate to place it within
`REPL` module rather than its `REPLCompletions` submodule.
---
 stdlib/REPL/src/REPL.jl            | 76 ++++++++++++++++++++++++++++--
 stdlib/REPL/src/REPLCompletions.jl | 71 +---------------------------
 stdlib/REPL/test/repl.jl           |  2 +-
 3 files changed, 75 insertions(+), 74 deletions(-)

diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index b300f34e32617..5cd0c3abe917e 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -14,13 +14,83 @@ REPL.run_repl(repl)
 """
 module REPL
 
+Base.Experimental.@optlevel 1
+Base.Experimental.@max_methods 1
+
+function UndefVarError_hint(io::IO, ex::UndefVarError)
+    var = ex.var
+    if var === :or
+        print(io, "\nSuggestion: Use `||` for short-circuiting boolean OR.")
+    elseif var === :and
+        print(io, "\nSuggestion: Use `&&` for short-circuiting boolean AND.")
+    elseif var === :help
+        println(io)
+        # Show friendly help message when user types help or help() and help is undefined
+        show(io, MIME("text/plain"), Base.Docs.parsedoc(Base.Docs.keywords[:help]))
+    elseif var === :quit
+        print(io, "\nSuggestion: To exit Julia, use Ctrl-D, or type exit() and press enter.")
+    end
+    if isdefined(ex, :scope)
+        scope = ex.scope
+        if scope isa Module
+            bnd = ccall(:jl_get_module_binding, Any, (Any, Any, Cint), scope, var, true)::Core.Binding
+            if isdefined(bnd, :owner)
+                owner = bnd.owner
+                if owner === bnd
+                    print(io, "\nSuggestion: add an appropriate import or assignment. This global was declared but not assigned.")
+                end
+            else
+                owner = ccall(:jl_binding_owner, Ptr{Cvoid}, (Any, Any), scope, var)
+                if C_NULL == owner
+                    # No global of this name exists in this module.
+                    # This is the common case, so do not print that information.
+                    print(io, "\nSuggestion: check for spelling errors or missing imports.")
+                    owner = bnd
+                else
+                    owner = unsafe_pointer_to_objref(owner)::Core.Binding
+                end
+            end
+            if owner !== bnd
+                # this could use jl_binding_dbgmodule for the exported location in the message too
+                print(io, "\nSuggestion: this global was defined as `$(owner.globalref)` but not assigned a value.")
+            end
+        elseif scope === :static_parameter
+            print(io, "\nSuggestion: run Test.detect_unbound_args to detect method arguments that do not fully constrain a type parameter.")
+        elseif scope === :local
+            print(io, "\nSuggestion: check for an assignment to a local variable that shadows a global of the same name.")
+        end
+    else
+        scope = undef
+    end
+    if scope !== Base && !_UndefVarError_warnfor(io, Base, var)
+        warned = false
+        for m in Base.loaded_modules_order
+            m === Core && continue
+            m === Base && continue
+            m === Main && continue
+            m === scope && continue
+            warned |= _UndefVarError_warnfor(io, m, var)
+        end
+        warned ||
+            _UndefVarError_warnfor(io, Core, var) ||
+            _UndefVarError_warnfor(io, Main, var)
+    end
+    return nothing
+end
+
+function _UndefVarError_warnfor(io::IO, m::Module, var::Symbol)
+    Base.isbindingresolved(m, var) || return false
+    (Base.isexported(m, var) || Base.ispublic(m, var)) || return false
+    print(io, "\nHint: a global variable of this name also exists in $m.")
+    return true
+end
+
 function __init__()
     Base.REPL_MODULE_REF[] = REPL
+    Base.Experimental.register_error_hint(UndefVarError_hint, UndefVarError)
+    return nothing
 end
 
-Base.Experimental.@optlevel 1
-Base.Experimental.@max_methods 1
-
 using Base.Meta, Sockets
 import InteractiveUtils
 
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 4bcba3d183e5c..02e6f36ad93ca 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -1473,78 +1473,9 @@ function shell_completions(string, pos)
     return Completion[], 0:-1, false
 end
 
-function UndefVarError_hint(io::IO, ex::UndefVarError)
-    var = ex.var
-    if var === :or
-        print(io, "\nSuggestion: Use `||` for short-circuiting boolean OR.")
-    elseif var === :and
-        print(io, "\nSuggestion: Use `&&` for short-circuiting boolean AND.")
-    elseif var === :help
-        println(io)
-        # Show friendly help message when user types help or help() and help is undefined
-        show(io, MIME("text/plain"), Base.Docs.parsedoc(Base.Docs.keywords[:help]))
-    elseif var === :quit
-        print(io, "\nSuggestion: To exit Julia, use Ctrl-D, or type exit() and press enter.")
-    end
-    if isdefined(ex, :scope)
-        scope = ex.scope
-        if scope isa Module
-            bnd = ccall(:jl_get_module_binding, Any, (Any, Any, Cint), scope, var, true)::Core.Binding
-            if isdefined(bnd, :owner)
-                owner = bnd.owner
-                if owner === bnd
-                    print(io, "\nSuggestion: add an appropriate import or assignment. This global was declared but not assigned.")
-                end
-            else
-                owner = ccall(:jl_binding_owner, Ptr{Cvoid}, (Any, Any), scope, var)
-                if C_NULL == owner
-                    # No global of this name exists in this module.
-                    # This is the common case, so do not print that information.
-                    print(io, "\nSuggestion: check for spelling errors or missing imports.")
-                    owner = bnd
-                else
-                    owner = unsafe_pointer_to_objref(owner)::Core.Binding
-                end
-            end
-            if owner !== bnd
-                # this could use jl_binding_dbgmodule for the exported location in the message too
-                print(io, "\nSuggestion: this global was defined as `$(owner.globalref)` but not assigned a value.")
-            end
-        elseif scope === :static_parameter
-            print(io, "\nSuggestion: run Test.detect_unbound_args to detect method arguments that do not fully constrain a type parameter.")
-        elseif scope === :local
-            print(io, "\nSuggestion: check for an assignment to a local variable that shadows a global of the same name.")
-        end
-    else
-        scope = undef
-    end
-    if scope !== Base && !_UndefVarError_warnfor(io, Base, var)
-        warned = false
-        for m in Base.loaded_modules_order
-            m === Core && continue
-            m === Base && continue
-            m === Main && continue
-            m === scope && continue
-            warned |= _UndefVarError_warnfor(io, m, var)
-        end
-        warned ||
-            _UndefVarError_warnfor(io, Core, var) ||
-            _UndefVarError_warnfor(io, Main, var)
-    end
-    nothing
-end
-
-function _UndefVarError_warnfor(io::IO, m::Module, var::Symbol)
-    Base.isbindingresolved(m, var) || return false
-    (Base.isexported(m, var) || Base.ispublic(m, var)) || return false
-    print(io, "\nHint: a global variable of this name also exists in $m.")
-    return true
-end
-
 function __init__()
-    Base.Experimental.register_error_hint(UndefVarError_hint, UndefVarError)
     COMPLETION_WORLD[] = Base.get_world_counter()
-    nothing
+    return nothing
 end
 
 end # module
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 05ff66229ed2c..83df34a056578 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -1677,7 +1677,7 @@ end
 
 try # test the functionality of `UndefVarError_hint` against `Base.remove_linenums!`
     @assert isempty(Base.Experimental._hint_handlers)
-    Base.Experimental.register_error_hint(REPL.REPLCompletions.UndefVarError_hint, UndefVarError)
+    Base.Experimental.register_error_hint(REPL.UndefVarError_hint, UndefVarError)
 
     # check the requirement to trigger the hint via `UndefVarError_hint`
     @test !isdefined(Main, :remove_linenums!) && Base.ispublic(Base, :remove_linenums!)

From 400ee71e7c186ae9c2a4b81ca90ca9e30934c1af Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Mon, 22 Jan 2024 00:07:23 -0500
Subject: [PATCH 0687/1315] Add `filter` parameter to `tarjan!`

This still isn't an entirely generic version of the algorithm, but it's
certainly a step in the right direction.
---
 base/compiler/ssair/tarjan.jl | 57 +++++++++++++++++++++--------------
 test/compiler/tarjan.jl       |  8 ++---
 2 files changed, 38 insertions(+), 27 deletions(-)

diff --git a/base/compiler/ssair/tarjan.jl b/base/compiler/ssair/tarjan.jl
index 8285fcd3f29b7..bc0500901fb03 100644
--- a/base/compiler/ssair/tarjan.jl
+++ b/base/compiler/ssair/tarjan.jl
@@ -46,7 +46,10 @@ function CFGReachability(cfg::CFG, domtree::DomTree)
         Int[],                      # _worklist
         SCCStackItem[],             # _stack
     )
-    tarjan!(reachability, cfg)
+    tarjan!(reachability, cfg;
+        # reducible back-edges don't need to be considered for reachability
+        filter = (from::Int,to::Int)->!dominates(domtree, to, from)
+    )
     return reachability
 end
 
@@ -59,12 +62,12 @@ bb_in_irreducible_loop(reach::CFGReachability, bb::Int) = reach.irreducible[bb]
 #
 # `tarjan!` takes the transitive closure of this relation in order to detect
 # which BasicBlocks are unreachable.
-function _bb_externally_reachable(reach::CFGReachability, cfg::CFG, bb::Int)
+function _bb_externally_reachable(reach::CFGReachability, cfg::CFG, bb::Int; filter)
     (; scc) = reach
     bb == 1 && return true
     for pred in cfg.blocks[bb].preds
         scc[pred] <= 0 && continue
-        dominates(reach.domtree, bb, pred) && continue
+        !filter(pred, bb) && continue
         @assert scc[pred] != scc[bb]
         return true
     end
@@ -85,10 +88,12 @@ Outputs:
   - `reach._worklist`: if performing an incremental update (`root != 1`), any traversed nodes that
     are unreachable from BasicBlock #1 are enqueued to this worklist
 """
-function tarjan!(reach::CFGReachability, cfg::CFG; root::Int=1)
-    (; scc, irreducible, domtree) = reach
+function tarjan!(reach::CFGReachability, cfg::CFG; root::Int=1,
+    filter = (from::Int,to::Int)->true,
+)
+    (; scc, irreducible) = reach
     scc[root] != 0 && return scc
-    live = _bb_externally_reachable(reach, cfg, root)
+    live = _bb_externally_reachable(reach, cfg, root; filter)
 
     # the original algorithm has a separate stack and worklist (unrelated to `reach._worklist`)
     # here we use a single combined stack for improved memory/cache efficiency
@@ -117,12 +122,8 @@ function tarjan!(reach::CFGReachability, cfg::CFG; root::Int=1)
             stack[cursor] = item = SCCStackItem(item; child=child+1)
             succ = bb.succs[child]
 
-            # ignore any back-edges in a (natural) loop (see `kill_edge!`)
-            if dominates(domtree, succ, convert(Int, v))
-                # This check ensures that reducible CFG's will contain no SCC's. The vast majority
-                # of functions have reducible CFG's, so this optimization is very important.
-                continue
-            end
+            # ignore any edges that don't pass the filter
+            !filter(convert(Int, v), succ) && continue
 
             if scc[succ] < 0
                 # next child is already in DFS tree
@@ -134,7 +135,7 @@ function tarjan!(reach::CFGReachability, cfg::CFG; root::Int=1)
             elseif scc[succ] == 0
                 # next child is a new element in DFS tree
                 preorder_id += 1
-                live = live || _bb_externally_reachable(reach, cfg, succ)
+                live = live || _bb_externally_reachable(reach, cfg, succ; filter)
                 push!(stack, SCCStackItem(
                     succ,        # v
                     1,           # child
@@ -154,7 +155,7 @@ function tarjan!(reach::CFGReachability, cfg::CFG; root::Int=1)
                     if live
                         scc[item.v] = v
                         scan_subgraph!(reach, cfg, convert(Int, item.v),
-                            #= filter =# (pred,x)->(!dominates(domtree, x, pred) && scc[x] > typemax(Int)÷2),
+                            #= filter =# (pred,x)->(filter(pred, x) && scc[x] > typemax(Int)÷2),
                             #= action =# (x)->(scc[x] -= typemax(Int)÷2;),
                         )
                     else # this offset marks a node as 'maybe-dead'
@@ -181,19 +182,19 @@ function tarjan!(reach::CFGReachability, cfg::CFG; root::Int=1)
     worklist = reach._worklist
 
     # filter the worklist, leaving any nodes not proven to be reachable from BB #1
-    n_filtered = 0
+    n_popped = 0
     for i = (worklist_len + 1):length(worklist)
         @assert worklist[i] != 1
         @assert scc[worklist[i]] > 0
         if scc[worklist[i]] > typemax(Int)÷2
             # node is unreachable, enqueue it
             scc[worklist[i]] = 0
-            worklist[i - n_filtered] = worklist[i]
+            worklist[i - n_popped] = worklist[i]
         else
-            n_filtered += 1
+            n_popped += 1
         end
     end
-    resize!(worklist, length(worklist) - n_filtered)
+    resize!(worklist, length(worklist) - n_popped)
 
     return length(worklist) > worklist_len # if true, a (newly) unreachable node was enqueued
 end
@@ -228,16 +229,20 @@ function enqueue_if_unreachable!(reach::CFGReachability, cfg::CFG, bb::Int)
         # irreducible CFG
         # this requires a full scan of the irreducible loop
 
+        # any reducible back-edges do not need to be considered as part of reachability
+        # (very important optimization, since it means reducible CFGs will have no SCCs)
+        filter = (from::Int, to::Int)->!dominates(domtree, to, from)
+
         scc′ = scc[bb]
         scc[bb] = 0
         scan_subgraph!(reach, cfg, bb, # set this SCC to 0
-            #= filter =# (pred,x)->(!dominates(domtree, x, pred) && scc[x] == scc′),
+            #= filter =# (pred,x)->(filter(pred, x) && scc[x] == scc′),
             #= action =# (x)->(scc[x] = 0;),
         )
 
         # re-compute the SCC's for this portion of the CFG, adding any freshly
         # unreachable nodes to `reach._worklist`
-        return tarjan!(reach, cfg; root=bb)
+        return tarjan!(reach, cfg; root=bb, filter)
     else
         # target is a reducible CFG node
         # this node lives iff it still has an incoming forward edge
@@ -250,6 +255,13 @@ function enqueue_if_unreachable!(reach::CFGReachability, cfg::CFG, bb::Int)
     end
 end
 
+function kill_cfg_edge!(cfg::CFG, from::Int, to::Int)
+    preds, succs = cfg.blocks[to].preds, cfg.blocks[from].succs
+    deleteat!(preds, findfirst(x::Int->x==from, preds)::Int)
+    deleteat!(succs, findfirst(x::Int->x==to, succs)::Int)
+    return nothing
+end
+
 """
 Remove from `cfg` and `reach` the edge (from → to), as well as any blocks/edges
 this causes to become unreachable.
@@ -265,9 +277,7 @@ function kill_edge!(reach::CFGReachability, cfg::CFG, from::Int, to::Int,
     @assert reach.scc[to] != 0
 
     # delete (from → to) edge
-    preds, succs = cfg.blocks[to].preds, cfg.blocks[from].succs
-    deleteat!(preds, findfirst(x::Int->x==from, preds)::Int)
-    deleteat!(succs, findfirst(x::Int->x==to, succs)::Int)
+    kill_cfg_edge!(cfg, from, to)
 
     # check for unreachable target
     enqueued = enqueue_if_unreachable!(reach, cfg, to)
@@ -295,5 +305,6 @@ function kill_edge!(reach::CFGReachability, cfg::CFG, from::Int, to::Int,
                 edge_callback(node, succ)
             end
         end
+        empty!(cfg.blocks[node].succs)
     end
 end
diff --git a/test/compiler/tarjan.jl b/test/compiler/tarjan.jl
index c23388b39621f..44acafb2ca5f4 100644
--- a/test/compiler/tarjan.jl
+++ b/test/compiler/tarjan.jl
@@ -56,10 +56,8 @@ function rand_cfg(V, E)
 end
 
 function get_random_edge(cfg::CFG, V)
-    source = rand(1:V)
-    while length(cfg.blocks[source].succs) == 0
-        source = rand(1:V)
-    end
+    has_edge = [length(cfg.blocks[bb].succs) != 0 for bb in 1:V]
+    source = rand(findall(has_edge))
     target = rand(cfg.blocks[source].succs)
     return source, target
 end
@@ -121,6 +119,8 @@ function test_reachability(V, E; deletions = 2E ÷ 3, all_checks=false)
     killed_edges = Tuple{Int,Int}[]
     killed_blocks = Int[]
     for k = 1:deletions
+        length(blocks) == 1 && break # no more reachable blocks
+
         from, to = get_random_edge(cfg, V)
         kill_edge!(reachability, cfg, from, to,
             (from::Int, to::Int) -> push!(killed_edges, (from, to)),

From 47d31acd1494dfed4f8f361d67fe1fb8c3888656 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 22 Jan 2024 18:46:23 +0900
Subject: [PATCH 0688/1315] refactor the optimization flags set and utilities
 (#52998)

---
 base/compiler/abstractinterpretation.jl       |  2 +-
 base/compiler/optimize.jl                     | 96 ++++++++++++++-----
 .../ssair/EscapeAnalysis/EscapeAnalysis.jl    | 12 +--
 base/compiler/ssair/inlining.jl               | 77 ++++-----------
 base/compiler/ssair/ir.jl                     | 30 ++----
 base/compiler/ssair/irinterp.jl               |  4 +-
 base/compiler/ssair/passes.jl                 | 10 +-
 src/julia.h                                   | 19 ++--
 8 files changed, 124 insertions(+), 126 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 99c291ff8ec4b..292a39e42e77b 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2722,7 +2722,7 @@ end
 function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e), vtypes::VarTable, sv::InferenceState)
     if !isa(e, Expr)
         if isa(e, PhiNode)
-            add_curr_ssaflag!(sv, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
+            add_curr_ssaflag!(sv, IR_FLAGS_REMOVABLE)
             return RTEffects(abstract_eval_phi(interp, e, vtypes, sv), Union{}, EFFECTS_TOTAL)
         end
         (; rt, exct, effects) = abstract_eval_special_value(interp, e, vtypes, sv)
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index d170a062be499..2e8c6f913d365 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -23,32 +23,61 @@ const IR_FLAG_INBOUNDS    = one(UInt32) << 0
 const IR_FLAG_INLINE      = one(UInt32) << 1
 # This statement is marked as @noinline by user
 const IR_FLAG_NOINLINE    = one(UInt32) << 2
+# This statement is on a code path that eventually `throw`s.
 const IR_FLAG_THROW_BLOCK = one(UInt32) << 3
-# This statement was proven :effect_free
-const IR_FLAG_EFFECT_FREE = one(UInt32) << 4
-# This statement was proven not to throw
-const IR_FLAG_NOTHROW     = one(UInt32) << 5
-# This is :consistent
-const IR_FLAG_CONSISTENT  = one(UInt32) << 6
 # An optimization pass has updated this statement in a way that may
 # have exposed information that inference did not see. Re-running
 # inference on this statement may be profitable.
-const IR_FLAG_REFINED     = one(UInt32) << 7
-# This is :noub == ALWAYS_TRUE
-const IR_FLAG_NOUB        = one(UInt32) << 8
-
+const IR_FLAG_REFINED     = one(UInt32) << 4
+# This statement is proven :consistent
+const IR_FLAG_CONSISTENT  = one(UInt32) << 5
+# This statement is proven :effect_free
+const IR_FLAG_EFFECT_FREE = one(UInt32) << 6
+# This statement is proven :nothrow
+const IR_FLAG_NOTHROW     = one(UInt32) << 7
+# This statement is proven :terminates
+const IR_FLAG_TERMINATES  = one(UInt32) << 8
+# This statement is proven :noub
+const IR_FLAG_NOUB        = one(UInt32) << 9
 # TODO: Both of these should eventually go away once
-# This is :effect_free == EFFECT_FREE_IF_INACCESSIBLEMEMONLY
-const IR_FLAG_EFIIMO      = one(UInt32) << 9
-# This is :inaccessiblememonly == INACCESSIBLEMEM_OR_ARGMEMONLY
-const IR_FLAG_INACCESSIBLE_OR_ARGMEM = one(UInt32) << 10
+# This statement is :effect_free == EFFECT_FREE_IF_INACCESSIBLEMEMONLY
+const IR_FLAG_EFIIMO      = one(UInt32) << 10
+# This statement is :inaccessiblememonly == INACCESSIBLEMEM_OR_ARGMEMONLY
+const IR_FLAG_INACCESSIBLEMEM_OR_ARGMEM = one(UInt32) << 11
+
+const NUM_IR_FLAGS = 12 # sync with julia.h
 
-const NUM_IR_FLAGS = 11 # sync with julia.h
+const IR_FLAGS_EFFECTS =
+    IR_FLAG_CONSISTENT | IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW | IR_FLAG_NOUB
 
-const IR_FLAGS_EFFECTS = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW | IR_FLAG_CONSISTENT | IR_FLAG_NOUB
+const IR_FLAGS_REMOVABLE = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+
+const IR_FLAGS_NEEDS_EA = IR_FLAG_EFIIMO | IR_FLAG_INACCESSIBLEMEM_OR_ARGMEM
 
 has_flag(curr::UInt32, flag::UInt32) = (curr & flag) == flag
 
+function flags_for_effects(effects::Effects)
+    flags = zero(UInt32)
+    if is_consistent(effects)
+        flags |= IR_FLAG_CONSISTENT
+    end
+    if is_effect_free(effects)
+        flags |= IR_FLAG_EFFECT_FREE
+    elseif is_effect_free_if_inaccessiblememonly(effects)
+        flags |= IR_FLAG_EFIIMO
+    end
+    if is_nothrow(effects)
+        flags |= IR_FLAG_NOTHROW
+    end
+    if is_inaccessiblemem_or_argmemonly(effects)
+        flags |= IR_FLAG_INACCESSIBLEMEM_OR_ARGMEM
+    end
+    if is_noub(effects)
+        flags |= IR_FLAG_NOUB
+    end
+    return flags
+end
+
 const TOP_TUPLE = GlobalRef(Core, :tuple)
 
 # This corresponds to the type of `CodeInfo`'s `inlining_cost` field
@@ -263,9 +292,9 @@ end
 
 """
     stmt_effect_flags(stmt, rt, src::Union{IRCode,IncrementalCompact}) ->
-        (consistent::Bool, effect_free_and_nothrow::Bool, nothrow::Bool)
+        (consistent::Bool, removable::Bool, nothrow::Bool)
 
-Returns a tuple of `(:consistent, :effect_free_and_nothrow, :nothrow)` flags for a given statement.
+Returns a tuple of `(:consistent, :removable, :nothrow)` flags for a given statement.
 """
 function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospecialize(rt), src::Union{IRCode,IncrementalCompact})
     # TODO: We're duplicating analysis from inference here.
@@ -309,7 +338,8 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
             consistent = is_consistent(effects)
             effect_free = is_effect_free(effects)
             nothrow = is_nothrow(effects)
-            return (consistent, effect_free & nothrow, nothrow)
+            removable = effect_free & nothrow
+            return (consistent, removable, nothrow)
         elseif head === :new
             return new_expr_effect_flags(𝕃ₒ, args, src)
         elseif head === :foreigncall
@@ -319,7 +349,8 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
             consistent = is_consistent(effects)
             effect_free = is_effect_free(effects)
             nothrow = is_nothrow(effects)
-            return (consistent, effect_free & nothrow, nothrow)
+            removable = effect_free & nothrow
+            return (consistent, removable, nothrow)
         elseif head === :new_opaque_closure
             length(args) < 4 && return (false, false, false)
             typ = argextype(args[1], src)
@@ -346,6 +377,29 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
     return (true, true, true)
 end
 
+function recompute_effects_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospecialize(rt),
+                                 src::Union{IRCode,IncrementalCompact})
+    flag = IR_FLAG_NULL
+    (consistent, removable, nothrow) = stmt_effect_flags(𝕃ₒ, stmt, rt, src)
+    if consistent
+        flag |= IR_FLAG_CONSISTENT
+    end
+    if removable
+        flag |= IR_FLAGS_REMOVABLE
+    elseif nothrow
+        flag |= IR_FLAG_NOTHROW
+    end
+    if !(isexpr(stmt, :call) || isexpr(stmt, :invoke))
+        # There is a bit of a subtle point here, which is that some non-call
+        # statements (e.g. PiNode) can be UB:, however, we consider it
+        # illegal to introduce such statements that actually cause UB (for any
+        # input). Ideally that'd be handled at insertion time (TODO), but for
+        # the time being just do that here.
+        flag |= IR_FLAG_NOUB
+    end
+    return flag
+end
+
 """
     argextype(x, src::Union{IRCode,IncrementalCompact}) -> t
     argextype(x, src::CodeInfo, sptypes::Vector{VarState}) -> t
@@ -694,8 +748,6 @@ function is_conditional_noub(inst::Instruction, sv::PostOptAnalysisState)
     return true
 end
 
-const IR_FLAGS_NEEDS_EA = IR_FLAG_EFIIMO | IR_FLAG_INACCESSIBLE_OR_ARGMEM
-
 function scan_non_dataflow_flags!(inst::Instruction, sv::PostOptAnalysisState)
     flag = inst[:flag]
     # If we can prove that the argmem does not escape the current function, we can
diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index c1f3cf3f97885..f74cb90e6ab51 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -25,9 +25,9 @@ using ._TOP_MOD:     # Base definitions
     unwrap_unionall, !, !=, !==, &, *, +, -, :, <, <<, =>, >, |, ∈, ∉, ∩, ∪, ≠, ≤, ≥, ⊆
 using Core.Compiler: # Core.Compiler specific definitions
     Bottom, IRCode, IR_FLAG_NOTHROW, InferenceResult, SimpleInferenceLattice,
-    argextype, check_effect_free!, fieldcount_noerror, hasintersect, has_flag,
-    intrinsic_nothrow, is_meta_expr_head, isbitstype, isexpr, println, setfield!_nothrow,
-    singleton_type, try_compute_field, try_compute_fieldidx, widenconst, ⊑, AbstractLattice
+    argextype, fieldcount_noerror, hasintersect, has_flag, intrinsic_nothrow,
+    is_meta_expr_head, isbitstype, isexpr, println, setfield!_nothrow, singleton_type,
+    try_compute_field, try_compute_fieldidx, widenconst, ⊑, AbstractLattice
 
 include(x) = _TOP_MOD.include(@__MODULE__, x)
 if _TOP_MOD === Core.Compiler
@@ -597,12 +597,12 @@ struct LivenessChange <: Change
 end
 const Changes = Vector{Change}
 
-struct AnalysisState{T, L <: AbstractLattice}
+struct AnalysisState{GetEscapeCache, Lattice<:AbstractLattice}
     ir::IRCode
     estate::EscapeState
     changes::Changes
-    𝕃ₒ::L
-    get_escape_cache::T
+    𝕃ₒ::Lattice
+    get_escape_cache::GetEscapeCache
 end
 
 """
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 650af8248883c..bacaf68db4332 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -366,7 +366,7 @@ function ir_prepare_inlining!(insert_node!::Inserter, inline_target::Union{IRCod
     if !validate_sparams(mi.sparam_vals)
         # N.B. This works on the caller-side argexprs, (i.e. before the va fixup below)
         spvals_ssa = insert_node!(
-            effect_free_and_nothrow(NewInstruction(Expr(:call, Core._compute_sparams, def, argexprs...), SimpleVector, topline)))
+            removable_if_unused(NewInstruction(Expr(:call, Core._compute_sparams, def, argexprs...), SimpleVector, topline)))
     end
     if def.isva
         nargs_def = Int(def.nargs::Int32)
@@ -425,7 +425,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
                 inline_compact.result[idx′][:type] =
                     argextype(val, isa(val, Argument) || isa(val, Expr) ? compact : inline_compact)
                 # Everything legal in value position is guaranteed to be effect free in stmt position
-                inline_compact.result[idx′][:flag] = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+                inline_compact.result[idx′][:flag] = IR_FLAGS_REMOVABLE
                 break
             elseif isexpr(stmt′, :boundscheck)
                 adjust_boundscheck!(inline_compact, idx′, stmt′, boundscheck)
@@ -692,7 +692,7 @@ function batch_inline!(ir::IRCode, todo::Vector{Pair{Int,Any}}, propagate_inboun
                 for aidx in 1:length(argexprs)
                     aexpr = argexprs[aidx]
                     if isa(aexpr, Expr) || isa(aexpr, GlobalRef)
-                        ninst = effect_free_and_nothrow(NewInstruction(aexpr, argextype(aexpr, compact), compact.result[idx][:line]))
+                        ninst = removable_if_unused(NewInstruction(aexpr, argextype(aexpr, compact), compact.result[idx][:line]))
                         argexprs[aidx] = insert_node_here!(compact, ninst)
                     end
                 end
@@ -996,28 +996,6 @@ function retrieve_ir_for_inlining(::MethodInstance, ir::IRCode, preserve_local_s
     return ir
 end
 
-function flags_for_effects(effects::Effects)
-    flags::UInt32 = 0
-    if is_consistent(effects)
-        flags |= IR_FLAG_CONSISTENT
-    end
-    if is_effect_free(effects)
-        flags |= IR_FLAG_EFFECT_FREE
-    elseif is_effect_free_if_inaccessiblememonly(effects)
-        flags |= IR_FLAG_EFIIMO
-    end
-    if is_inaccessiblemem_or_argmemonly(effects)
-        flags |= IR_FLAG_INACCESSIBLE_OR_ARGMEM
-    end
-    if is_nothrow(effects)
-        flags |= IR_FLAG_NOTHROW
-    end
-    if is_noub(effects)
-        flags |= IR_FLAG_NOUB
-    end
-    return flags
-end
-
 function handle_single_case!(todo::Vector{Pair{Int,Any}},
     ir::IRCode, idx::Int, stmt::Expr, @nospecialize(case),
     isinvoke::Bool = false)
@@ -1252,29 +1230,12 @@ end
 # As a matter of convenience, this pass also computes effect-freenes.
 # For primitives, we do that right here. For proper calls, we will
 # discover this when we consult the caches.
-function check_effect_free!(ir::IRCode, idx::Int, @nospecialize(stmt), @nospecialize(rt), state::InliningState)
-    return check_effect_free!(ir, idx, stmt, rt, optimizer_lattice(state.interp))
-end
-function check_effect_free!(ir::IRCode, idx::Int, @nospecialize(stmt), @nospecialize(rt), 𝕃ₒ::AbstractLattice)
-    (consistent, effect_free_and_nothrow, nothrow) = stmt_effect_flags(𝕃ₒ, stmt, rt, ir)
-    inst = ir.stmts[idx]
-    if consistent
-        add_flag!(inst, IR_FLAG_CONSISTENT)
-    end
-    if effect_free_and_nothrow
-        add_flag!(inst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
-    elseif nothrow
-        add_flag!(inst, IR_FLAG_NOTHROW)
-    end
-    if !(isexpr(stmt, :call) || isexpr(stmt, :invoke))
-        # There is a bit of a subtle point here, which is that some non-call
-        # statements (e.g. PiNode) can be UB:, however, we consider it
-        # illegal to introduce such statements that actually cause UB (for any
-        # input). Ideally that'd be handled at insertion time (TODO), but for
-        # the time being just do that here.
-        add_flag!(inst, IR_FLAG_NOUB)
-    end
-    return effect_free_and_nothrow
+add_inst_flag!(inst::Instruction, ir::IRCode, state::InliningState) =
+    add_inst_flag!(inst, ir, optimizer_lattice(state.interp))
+function add_inst_flag!(inst::Instruction, ir::IRCode, 𝕃ₒ::AbstractLattice)
+    flags = recompute_effects_flags(𝕃ₒ, inst[:stmt], inst[:type], ir)
+    add_flag!(inst, flags)
+    return !iszero(flags & IR_FLAGS_REMOVABLE)
 end
 
 # Handles all analysis and inlining of intrinsics and builtins. In particular,
@@ -1283,11 +1244,11 @@ end
 function process_simple!(todo::Vector{Pair{Int,Any}}, ir::IRCode, idx::Int, state::InliningState)
     inst = ir[SSAValue(idx)]
     stmt = inst[:stmt]
-    rt = inst[:type]
     if !(stmt isa Expr)
-        check_effect_free!(ir, idx, stmt, rt, state)
+        add_inst_flag!(inst, ir, state)
         return nothing
     end
+    rt = inst[:type]
     head = stmt.head
     if head !== :call
         if head === :splatnew
@@ -1299,7 +1260,7 @@ function process_simple!(todo::Vector{Pair{Int,Any}}, ir::IRCode, idx::Int, stat
             sig === nothing && return nothing
             return stmt, sig
         end
-        check_effect_free!(ir, idx, stmt, rt, state)
+        add_inst_flag!(inst, ir, state)
         return nothing
     end
 
@@ -1317,7 +1278,7 @@ function process_simple!(todo::Vector{Pair{Int,Any}}, ir::IRCode, idx::Int, stat
         return nothing
     end
 
-    if check_effect_free!(ir, idx, stmt, rt, state)
+    if add_inst_flag!(inst, ir, state)
         if sig.f === typeassert || ⊑(optimizer_lattice(state.interp), sig.ft, typeof(typeassert))
             # typeassert is a no-op if effect free
             inst[:stmt] = stmt.args[2]
@@ -1335,7 +1296,7 @@ function process_simple!(todo::Vector{Pair{Int,Any}}, ir::IRCode, idx::Int, stat
     lateres = late_inline_special_case!(ir, idx, stmt, rt, sig, state)
     if isa(lateres, SomeCase)
         inst[:stmt] = lateres.val
-        check_effect_free!(ir, idx, lateres.val, rt, state)
+        add_inst_flag!(inst, ir, state)
         return nothing
     end
 
@@ -1683,7 +1644,7 @@ function inline_const_if_inlineable!(inst::Instruction)
         inst[:stmt] = quoted(rt.val)
         return true
     end
-    add_flag!(inst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
+    add_flag!(inst, IR_FLAGS_REMOVABLE)
     return false
 end
 
@@ -1808,7 +1769,7 @@ function late_inline_special_case!(
             return SomeCase(quoted(type.val))
         end
         cmp_call = Expr(:call, GlobalRef(Core, :(===)), stmt.args[2], stmt.args[3])
-        cmp_call_ssa = insert_node!(ir, idx, effect_free_and_nothrow(NewInstruction(cmp_call, Bool)))
+        cmp_call_ssa = insert_node!(ir, idx, removable_if_unused(NewInstruction(cmp_call, Bool)))
         not_call = Expr(:call, GlobalRef(Core.Intrinsics, :not_int), cmp_call_ssa)
         return SomeCase(not_call)
     elseif length(argtypes) == 3 && istopfunction(f, :(>:))
@@ -1853,13 +1814,13 @@ end
 
 function insert_spval!(insert_node!::Inserter, spvals_ssa::SSAValue, spidx::Int, do_isdefined::Bool)
     ret = insert_node!(
-        effect_free_and_nothrow(NewInstruction(Expr(:call, Core._svec_ref, spvals_ssa, spidx), Any)))
+        removable_if_unused(NewInstruction(Expr(:call, Core._svec_ref, spvals_ssa, spidx), Any)))
     tcheck_not = nothing
     if do_isdefined
         tcheck = insert_node!(
-            effect_free_and_nothrow(NewInstruction(Expr(:call, Core.isa, ret, Core.TypeVar), Bool)))
+            removable_if_unused(NewInstruction(Expr(:call, Core.isa, ret, Core.TypeVar), Bool)))
         tcheck_not = insert_node!(
-            effect_free_and_nothrow(NewInstruction(Expr(:call, not_int, tcheck), Bool)))
+            removable_if_unused(NewInstruction(Expr(:call, not_int, tcheck), Bool)))
     end
     return (ret, tcheck_not)
 end
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 759997feb04da..80d6d5fde556d 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -342,7 +342,7 @@ function NewInstruction(inst::Instruction;
     return NewInstruction(stmt, type, info, line, flag)
 end
 @specialize
-effect_free_and_nothrow(newinst::NewInstruction) = add_flag(newinst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
+removable_if_unused(newinst::NewInstruction) = add_flag(newinst, IR_FLAGS_REMOVABLE)
 function add_flag(newinst::NewInstruction, newflag::UInt32)
     flag = newinst.flag
     if flag === nothing
@@ -595,7 +595,7 @@ function insert_node!(ir::IRCode, pos::SSAValue, newinst::NewInstruction, attach
     end
     node = add_inst!(ir.new_nodes, posid, attach_after)
     newline = something(newinst.line, ir[pos][:line])
-    newflag = recompute_inst_flag(newinst, ir)
+    newflag = recompute_newinst_flag(newinst, ir)
     node = inst_from_newinst!(node, newinst, newline, newflag)
     return SSAValue(length(ir.stmts) + node.idx)
 end
@@ -873,29 +873,14 @@ function inst_from_newinst!(node::Instruction, newinst::NewInstruction,
     return node
 end
 
-function recompute_inst_flag(newinst::NewInstruction, src::Union{IRCode,IncrementalCompact})
+function recompute_newinst_flag(newinst::NewInstruction, src::Union{IRCode,IncrementalCompact})
     flag = newinst.flag
     flag !== nothing && return flag
-    flag = IR_FLAG_NULL
-    (consistent, effect_free_and_nothrow, nothrow) = stmt_effect_flags(
-        fallback_lattice, newinst.stmt, newinst.type, src)
-    if consistent
-        flag |= IR_FLAG_CONSISTENT
-    end
-    if effect_free_and_nothrow
-        flag |= IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
-    elseif nothrow
-        flag |= IR_FLAG_NOTHROW
-    end
-    if !isexpr(newinst.stmt, :call) && !isexpr(newinst.stmt, :invoke)
-        # See comment in check_effect_free!
-        flag |= IR_FLAG_NOUB
-    end
-    return flag
+    return recompute_effects_flags(fallback_lattice, newinst.stmt, newinst.type, src)
 end
 
 function insert_node!(compact::IncrementalCompact, @nospecialize(before), newinst::NewInstruction, attach_after::Bool=false)
-    newflag = recompute_inst_flag(newinst, compact)
+    newflag = recompute_newinst_flag(newinst, compact)
     if isa(before, SSAValue)
         if before.id < compact.result_idx
             count_added_node!(compact, newinst.stmt)
@@ -978,7 +963,7 @@ function insert_node_here!(compact::IncrementalCompact, newinst::NewInstruction,
         @assert result_idx == length(compact.result) + 1
         resize!(compact, result_idx)
     end
-    newflag = recompute_inst_flag(newinst, compact)
+    newflag = recompute_newinst_flag(newinst, compact)
     node = inst_from_newinst!(compact.result[result_idx], newinst, newline, newflag)
     count_added_node!(compact, newinst.stmt) && push!(compact.late_fixup, result_idx)
     compact.result_idx = result_idx + 1
@@ -1840,8 +1825,7 @@ function maybe_erase_unused!(callback::Function, compact::IncrementalCompact, id
     stmt = inst[:stmt]
     stmt === nothing && return false
     inst[:type] === Bottom && return false
-    effect_free = has_flag(inst, (IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW))
-    effect_free || return false
+    has_flag(inst, IR_FLAGS_REMOVABLE) || return false
     foreachssa(stmt) do val::SSAValue
         if compact.used_ssas[val.id] == 1
             if val.id < idx || in_worklist
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 7e454612a4eb6..79d2ee695b0b6 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -58,7 +58,7 @@ function kill_block!(ir::IRCode, bb::Int)
         inst = ir[SSAValue(bidx)]
         inst[:stmt] = nothing
         inst[:type] = Bottom
-        inst[:flag] = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+        inst[:flag] = IR_FLAGS_REMOVABLE
     end
     ir[SSAValue(last(stmts))][:stmt] = ReturnNode()
     return
@@ -204,7 +204,7 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
     if rt !== nothing
         if isa(rt, Const)
             inst[:type] = rt
-            if is_inlineable_constant(rt.val) && has_flag(inst, (IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW))
+            if is_inlineable_constant(rt.val) && has_flag(inst, IR_FLAGS_REMOVABLE)
                 inst[:stmt] = quoted(rt.val)
             end
             return true
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 691876011b576..e4237e282a9aa 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -820,7 +820,7 @@ function perform_lifting!(compact::IncrementalCompact,
         old_node = old_inst[:stmt]::Union{PhiNode,Expr}
         if isa(old_node, PhiNode)
             new_node = PhiNode()
-            ssa = insert_node!(compact, old_ssa, effect_free_and_nothrow(NewInstruction(new_node, result_t)))
+            ssa = insert_node!(compact, old_ssa, removable_if_unused(NewInstruction(new_node, result_t)))
             lifted_philikes[i] = LiftedPhilike(ssa, new_node, true)
         else
             @assert is_known_call(old_node, Core.ifelse, compact)
@@ -1101,15 +1101,15 @@ end
 
 function refine_new_effects!(𝕃ₒ::AbstractLattice, compact::IncrementalCompact, idx::Int, stmt::Expr)
     inst = compact[SSAValue(idx)]
-    if has_flag(inst, (IR_FLAG_NOTHROW | IR_FLAG_EFFECT_FREE))
+    if has_flag(inst, IR_FLAGS_REMOVABLE)
         return # already accurate
     end
-    (consistent, effect_free_and_nothrow, nothrow) = new_expr_effect_flags(𝕃ₒ, stmt.args, compact, pattern_match_typeof)
+    (consistent, removable, nothrow) = new_expr_effect_flags(𝕃ₒ, stmt.args, compact, pattern_match_typeof)
     if consistent
         add_flag!(inst, IR_FLAG_CONSISTENT)
     end
-    if effect_free_and_nothrow
-        add_flag!(inst, IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW)
+    if removable
+        add_flag!(inst, IR_FLAGS_REMOVABLE)
     elseif nothrow
         add_flag!(inst, IR_FLAG_NOTHROW)
     end
diff --git a/src/julia.h b/src/julia.h
index 8c757f538f5f4..12c920cc6899d 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -266,7 +266,7 @@ typedef union __jl_purity_overrides_t {
 } _jl_purity_overrides_t;
 
 #define NUM_EFFECTS_OVERRIDES 9
-#define NUM_IR_FLAGS 11
+#define NUM_IR_FLAGS 12
 
 // This type describes a single function body
 typedef struct _jl_code_info_t {
@@ -279,14 +279,15 @@ typedef struct _jl_code_info_t {
         // 1 << 1 = callsite inline region
         // 1 << 2 = callsite noinline region
         // 1 << 3 = throw block
-        // 1 << 4 = :effect_free
-        // 1 << 5 = :nothrow
-        // 1 << 6 = :consistent
-        // 1 << 7 = :refined
-        // 1 << 8 = :noub
-        // 1 << 9 = :effect_free_if_inaccessiblememonly
-        // 1 << 10 = :inaccessiblemem_or_argmemonly
-        // 1 << 11-18 = callsite effects overrides
+        // 1 << 4 = refined statement
+        // 1 << 5 = :consistent
+        // 1 << 6 = :effect_free
+        // 1 << 7 = :nothrow
+        // 1 << 8 = :terminates
+        // 1 << 9 = :noub
+        // 1 << 10 = :effect_free_if_inaccessiblememonly
+        // 1 << 11 = :inaccessiblemem_or_argmemonly
+        // 1 << 12-19 = callsite effects overrides
     // miscellaneous data:
     jl_value_t *method_for_inference_limit_heuristics; // optional method used during inference
     jl_value_t *linetable; // Table of locations [TODO: make this volatile like slotnames]

From 59e505c378373a4be75fd504341a31bdc85572bf Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 22 Jan 2024 15:14:55 -0500
Subject: [PATCH 0689/1315] NEWS: improve the hint for disabling on-the-fly tab
 completion (#53006)

Followup to https://github.com/JuliaLang/julia/pull/51229
---
 NEWS.md | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index ed065939ad067..d1f9ca49bb4c7 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -140,7 +140,14 @@ Standard library changes
 #### REPL
 
 * Tab complete hints now show in lighter text while typing in the repl. To disable
-  set `Base.active_repl.options.hint_tab_completes = false` ([#51229]).
+  set `Base.active_repl.options.hint_tab_completes = false` interactively, or in startup.jl:
+  ```
+  if VERSION >= v"1.11.0-0"
+    atreplinit() do repl
+        repl.options.hint_tab_completes = false
+    end
+  end
+  ``` ([#51229]).
 * Meta-M with an empty prompt now toggles the contextual module between the previous non-Main
   contextual module and Main so that switching back and forth is simple. ([#51616], [#52670])
 

From 68c0b2da4bd029776d48b728f94115ab0510cab7 Mon Sep 17 00:00:00 2001
From: "Navid C. Constantinou" <navidcy@users.noreply.github.com>
Date: Mon, 22 Jan 2024 22:16:32 +0200
Subject: [PATCH 0690/1315] doc: add a few missing spaces in `functions.md`
 (#53005)

---
 doc/src/devdocs/functions.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/src/devdocs/functions.md b/doc/src/devdocs/functions.md
index 283f63b2d0dce..777afaa56348d 100644
--- a/doc/src/devdocs/functions.md
+++ b/doc/src/devdocs/functions.md
@@ -15,14 +15,14 @@ has a `TypeName`.
 
 ## [Function calls](@id Function-calls)
 
-Given the call `f(x,y)`, the following steps are performed: first, the method table to use is
+Given the call `f(x, y)`, the following steps are performed: first, the method table to use is
 accessed as `typeof(f).name.mt`. Second, an argument tuple type is formed, `Tuple{typeof(f), typeof(x), typeof(y)}`.
 Note that the type of the function itself is the first element. This is because the type might
 have parameters, and so needs to take part in dispatch. This tuple type is looked up in the method
 table.
 
 This dispatch process is performed by `jl_apply_generic`, which takes two arguments: a pointer
-to an array of the values f, x, and y, and the number of values (in this case 3).
+to an array of the values `f`, `x`, and `y`, and the number of values (in this case 3).
 
 Throughout the system, there are two kinds of APIs that handle functions and argument lists: those
 that accept the function and arguments separately, and those that accept a single argument structure.
@@ -214,16 +214,16 @@ use keyword arguments are dispatched directly to the called function's kwsorter.
 call:
 
 ```julia
-circle((0,0), 1.0, color = red; other...)
+circle((0, 0), 1.0, color = red; other...)
 ```
 
 is lowered to:
 
 ```julia
-kwcall(merge((color = red,), other), circle, (0,0), 1.0)
+kwcall(merge((color = red,), other), circle, (0, 0), 1.0)
 ```
 
- `kwcall` (also in`Core`) denotes a kwcall signature and dispatch.
+`kwcall` (also in`Core`) denotes a kwcall signature and dispatch.
 The keyword splatting operation (written as `other...`) calls the named tuple `merge` function.
 This function further unpacks each *element* of `other`, expecting each one to contain two values
 (a symbol and a value).
@@ -267,7 +267,7 @@ element instead of the second.
 The front end generates type declarations for all closures. Initially, this was implemented by
 generating normal type declarations. However, this produced an extremely large number of constructors,
 all of which were trivial (simply passing all arguments through to [`new`](@ref)). Since methods are partially
-ordered, inserting all of these methods is O(n^2), plus there are just too many of them to keep
+ordered, inserting all of these methods is O(n²), plus there are just too many of them to keep
 around. This was optimized by generating `struct_type` expressions directly (bypassing default
 constructor generation), and using `new` directly to create closure instances. Not the prettiest
 thing ever, but you do what you gotta do.

From 081f0458a7a874c5af8d71a57a0c81f77ab7481c Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Mon, 22 Jan 2024 21:20:21 +0100
Subject: [PATCH 0691/1315] doc: Explicitly document how to add docstrings for
 inner constructors (#52995)

xref https://github.com/JuliaLang/julia/issues/14962
---
 doc/src/manual/documentation.md | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/doc/src/manual/documentation.md b/doc/src/manual/documentation.md
index 58b1819e97372..f35ebafd7e582 100644
--- a/doc/src/manual/documentation.md
+++ b/doc/src/manual/documentation.md
@@ -314,8 +314,9 @@ end
 @doc "`subtract(a,b)` subtracts `b` from `a`" subtract
 ```
 
-Documentation in non-toplevel blocks, such as `begin`, `if`, `for`, and `let`, should be
-added to the documentation system via `@doc` as well. For example:
+Documentation in non-toplevel blocks, such as `begin`, `if`, `for`, `let`, and
+inner constructors, should be added to the documentation system via `@doc` as
+well. For example:
 
 ```julia
 if condition()
@@ -464,11 +465,17 @@ struct T
     x
     "y"
     y
+
+    @doc "Inner constructor"
+    function T()
+        new(...)
+    end
 end
 ```
 
-Adds docstring `"..."` to type `T`, `"x"` to field `T.x` and `"y"` to field `T.y`. Also applicable
-to `mutable struct` types.
+Adds docstring `"..."` to type `T`, `"x"` to field `T.x`, `"y"` to field `T.y`,
+and `"Inner constructor"` to the inner constructor `T()`. Also applicable to
+`mutable struct` types.
 
 ### Modules
 

From 4d26be084722d5638e4aafd126acf4aa370cacaf Mon Sep 17 00:00:00 2001
From: Christian Guinard <28689358+christiangnrd@users.noreply.github.com>
Date: Mon, 22 Jan 2024 17:30:30 -0400
Subject: [PATCH 0692/1315] Fix string output of `Base.format_bytes` when
 `binary=false` (#52932)

Introduced in [50572](https://github.com/JuliaLang/julia/pull/50572)

Before:
```
julia> Base.format_bytes(1, binary=false)
"1 "

julia> Base.format_bytes(11, binary=false)
"11 s"
```

This PR:
```
julia> Base.format_bytes(1, binary=false)
"1 byte"

julia> Base.format_bytes(11, binary=false)
"11 bytes"
```
Also add tests.
---
 base/timing.jl |  2 +-
 test/misc.jl   | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/base/timing.jl b/base/timing.jl
index e980cb9a05e93..1b93f97c122c1 100644
--- a/base/timing.jl
+++ b/base/timing.jl
@@ -140,7 +140,7 @@ function format_bytes(bytes; binary=true) # also used by InteractiveUtils
     factor = binary ? 1024 : 1000
     bytes, mb = prettyprint_getunits(bytes, length(units), Int64(factor))
     if mb == 1
-        return string(Int(bytes), " ", units[mb], bytes==1 ? "" : "s")
+        return string(Int(bytes), " ", _mem_units[mb], bytes==1 ? "" : "s")
     else
         return string(Ryu.writefixed(Float64(bytes), 3), binary ? " $(units[mb])" : "$(units[mb])B")
     end
diff --git a/test/misc.jl b/test/misc.jl
index 6f6dd3d806a7b..aeef937cac9fa 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1396,6 +1396,21 @@ end
     @test (@allocations "a" * Base.inferencebarrier("b")) == 1
 end
 
+#TODO: merge with `@testset "Base/timing.jl"` once https://github.com/JuliaLang/julia/issues/52948 is resolved
+@testset "Base/timing.jl2" begin
+    # Test the output of `format_bytes()`
+    inputs = [(factor * (Int64(1000)^e),binary) for binary in (false,true), factor in (1,2), e in 0:6][:]
+    expected_output = ["1 byte", "1 byte", "2 bytes", "2 bytes", "1000 bytes", "1000 bytes", "2.000 kB", "1.953 KiB",
+                        "1000.000 kB", "976.562 KiB", "2.000 MB", "1.907 MiB", "1000.000 MB", "953.674 MiB",
+                        "2.000 GB", "1.863 GiB", "1000.000 GB", "931.323 GiB", "2.000 TB", "1.819 TiB",
+                        "1000.000 TB", "909.495 TiB", "2.000 PB", "1.776 PiB", "1000.000 PB", "888.178 PiB",
+                        "2000.000 PB", "1776.357 PiB"]
+
+    for ((n, binary), expected) in zip(inputs, expected_output)
+        @test Base.format_bytes(n; binary) == expected
+    end
+end
+
 @testset "in_finalizer" begin
     @test !GC.in_finalizer()
 

From bc642cf1d68e2d9b909d899bae26361ff9b4f944 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Mon, 22 Jan 2024 21:56:13 -0500
Subject: [PATCH 0693/1315] NFC: Remove stale code from external objects
 handling (#53009)

Thanks to @gbaraldi for pointing this out.
---
 src/staticdata.c | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/src/staticdata.c b/src/staticdata.c
index e8ac99043b78d..88304e0525e25 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -312,8 +312,6 @@ static uintptr_t nsym_tag;
 // array of definitions for the predefined tagged object types
 // (reverse of symbol_table)
 static arraylist_t deser_sym;
-// Predefined tags that do not have special handling in `externally_linked`
-static htable_t external_objects;
 
 static htable_t serialization_order; // to break cycles, mark all objects that are serialized
 static htable_t nullptrs;
@@ -2661,13 +2659,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
             jl_queue_for_serialization(&s, s.ptls->root_task->tls);
         }
         else {
-            // To ensure we don't have to manually update the list, go through all tags and queue any that are not otherwise
-            // judged to be externally-linked
-            htable_new(&external_objects, NUM_TAGS);
-            for (size_t i = 0; tags[i] != NULL; i++) {
-                jl_value_t *tag = *tags[i];
-                ptrhash_put(&external_objects, tag, tag);
-            }
             // Queue the worklist itself as the first item we serialize
             jl_queue_for_serialization(&s, worklist);
             jl_queue_for_serialization(&s, jl_module_init_order);
@@ -2871,8 +2862,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     arraylist_free(&gvars);
     arraylist_free(&external_fns);
     htable_free(&field_replace);
-    if (worklist)
-        htable_free(&external_objects);
     htable_free(&serialization_order);
     htable_free(&nullptrs);
     htable_free(&symbol_table);

From 9f36490f02e92302d93e9f993cadbde04c104f9c Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Tue, 23 Jan 2024 09:20:08 -0300
Subject: [PATCH 0694/1315] place work-stealing queue indices on different
 cache lines to avoid false-sharing (#52994)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

For some reason this only shows up in the `many_refs.jl` benchmark,
since it's the only one that hammers the work-stealing queue (we also
didn't test this benchmark on a large number of GC threads in our
[previous
analysis](https://github.com/JuliaLang/julia/pull/48600#issuecomment-1518944785)).

- master:
```
bench = "many_refs.jl"
(gcthreads, threads) = (1, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       4268 │    3243 │      3048 │        194 │         1126 │                15 │      868 │         76 │
│  median │       4270 │    3246 │      3051 │        195 │         1128 │                17 │      868 │         76 │
│ maximum │       4278 │    3247 │      3052 │        195 │         1128 │                18 │      868 │         76 │
│   stdev │          5 │       2 │         2 │          0 │            1 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (2, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2728 │    1692 │      1551 │        141 │          598 │                23 │      868 │         62 │
│  median │       2732 │    1709 │      1567 │        141 │          603 │                23 │      868 │         62 │
│ maximum │       2744 │    1712 │      1571 │        143 │          607 │                24 │      868 │         63 │
│   stdev │          6 │       9 │         9 │          1 │            4 │                 0 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (4, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2105 │    1082 │       987 │         95 │          405 │                23 │      875 │         51 │
│  median │       2115 │    1089 │       994 │         95 │          409 │                23 │      875 │         52 │
│ maximum │       2127 │    1100 │      1003 │         97 │          417 │                25 │      875 │         52 │
│   stdev │          8 │       8 │         7 │          1 │            5 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (8, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       3861 │    2755 │      2676 │         79 │         1301 │                22 │      878 │         68 │
│  median │       3864 │    2835 │      2756 │         80 │         1342 │                25 │      879 │         73 │
│ maximum │       4032 │    2877 │      2797 │         80 │         1378 │                26 │      880 │         74 │
│   stdev │         73 │      45 │        45 │          1 │           28 │                 2 │        1 │          2 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (16, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       7455 │    6425 │      6344 │         80 │         3262 │                24 │      882 │         86 │
│  median │       7703 │    6682 │      6602 │         81 │         3313 │                25 │      884 │         87 │
│ maximum │       7826 │    6806 │      6725 │         81 │         3422 │                27 │      887 │         87 │
│   stdev │        152 │     153 │       153 │          0 │           68 │                 1 │        2 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```

- PR:
```
bench = "many_refs.jl"
(gcthreads, threads) = (1, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       4264 │    3240 │      3048 │        192 │         1127 │                15 │      868 │         76 │
│  median │       4271 │    3244 │      3052 │        192 │         1129 │                17 │      868 │         76 │
│ maximum │       4514 │    3481 │      3289 │        193 │         1247 │                18 │      868 │         77 │
│   stdev │        109 │     106 │       106 │          0 │           53 │                 1 │        0 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (2, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2712 │    1680 │      1541 │        138 │          591 │                22 │      868 │         62 │
│  median │       2713 │    1691 │      1552 │        140 │          594 │                24 │      868 │         62 │
│ maximum │       2732 │    1710 │      1569 │        141 │          606 │                25 │      868 │         63 │
│   stdev │         11 │      12 │        12 │          1 │            6 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (4, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2090 │    1057 │       962 │         95 │          398 │                22 │      874 │         50 │
│  median │       2103 │    1070 │       974 │         95 │          401 │                24 │      874 │         51 │
│ maximum │       2140 │    1074 │       978 │         96 │          402 │                25 │      875 │         51 │
│   stdev │         19 │       6 │         6 │          0 │            1 │                 1 │        1 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (8, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2236 │    1208 │      1129 │         79 │          528 │                23 │      880 │         54 │
│  median │       2238 │    1214 │      1135 │         79 │          533 │                23 │      880 │         54 │
│ maximum │       2246 │    1218 │      1138 │         80 │          534 │                35 │      880 │         54 │
│   stdev │          4 │       4 │         4 │          0 │            3 │                 5 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (16, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2326 │    1297 │      1216 │         80 │          595 │                24 │      884 │         56 │
│  median │       2348 │    1325 │      1245 │         80 │          620 │                25 │      885 │         56 │
│ maximum │       2370 │    1341 │      1262 │         81 │          631 │                26 │      887 │         57 │
│   stdev │         17 │      19 │        19 │          0 │           14 │                 1 │        1 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```
---
 src/work-stealing-queue.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/work-stealing-queue.h b/src/work-stealing-queue.h
index 38429e02886e9..084e421fd58b3 100644
--- a/src/work-stealing-queue.h
+++ b/src/work-stealing-queue.h
@@ -36,7 +36,8 @@ static inline ws_array_t *create_ws_array(size_t capacity, int32_t eltsz) JL_NOT
 
 typedef struct {
     _Atomic(int64_t) top;
-    _Atomic(int64_t) bottom;
+    char _padding[128 - sizeof(int64_t)];
+    _Atomic(int64_t) bottom; // put on a separate cache line. conservatively estimate cache line size as 128 bytes
     _Atomic(ws_array_t *) array;
 } ws_queue_t;
 

From e6bf976fdf634644e664eaeee84d94cffaf33b91 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Tue, 23 Jan 2024 07:36:19 -0500
Subject: [PATCH 0695/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20StyledStrings=20stdlib=20from=2061e7b10=20to=20302a0d0=20(#5?=
 =?UTF-8?q?3012)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: StyledStrings
URL: https://github.com/JuliaLang/StyledStrings.jl.git
Stdlib branch: main
Julia branch: master
Old commit: 61e7b10
New commit: 302a0d0
Julia version: 1.11.0-DEV
StyledStrings version: 1.11.0
Bump invoked by: @vchuravy
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/StyledStrings.jl/compare/61e7b105b157b40807ed0b4840166a25b0948549...302a0d023a58d38cddf0a1b82c618621613c8d2a

```
$ git log --oneline 61e7b10..302a0d0
302a0d0 Directly import ScopedValue
3fab35e Fix showing AnnotatedChar with colour
44f5fd7 Restrict the Base docstrings included in the docs
4dee5d9 Add readme
c49ae82 Add documentation task to CI
38ae1b3 Setting the terminal colour to :default is special
2709150 Adjust face merge tests after inheritance change
036631f Swap inheritance processing in face merge
9b35f08 Merge branch 'jn/Statefulempty' [#21]
508ab57 Refactor zip of eachindex to just use pairs
02b3f81 Remove use of length of Stateful
41c8218 Merge branch 'lh/ci-codecov' [#15]
d581fda Disable codecov commenting in every PR
a8a25ba Merge branch 'lh/ci-old-julia' [#13]
b7fca5b Merge branch 'lh/newline' [#16]
984485e Adjust newline parsing to work with CLRF encoding
27b02d1 Test styled"" parsing of \-continued newlines
a7981fe Merge pull request #17 from caleb-allen/add-beep-face
c1ab675 Add repl_prompt_beep face
0d8f5df Merge pull request #18 from JuliaLang/whitespace-fixup
1ef0f90 Nicer whitespace alignment
91a24f8 Disable CI for older versions of Julia
63ff132 add tagbot
792fda7 add CI
506afe3 add .gitignore
74e7135 Load the JULIA_*_COLOR env vars for compat
87d1fb5 Replace within-module eval with hygienic eval
4777e60 Touchups to documented examples
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 stdlib/StyledStrings.version                                    | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/sha512
 delete mode 100644 deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/sha512

diff --git a/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/md5 b/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/md5
new file mode 100644
index 0000000000000..1439d220e9cab
--- /dev/null
+++ b/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/md5
@@ -0,0 +1 @@
+1767902e25a2154a94ddfdc507754602
diff --git a/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/sha512 b/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/sha512
new file mode 100644
index 0000000000000..3098a0b23f238
--- /dev/null
+++ b/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/sha512
@@ -0,0 +1 @@
+7cc74330c9e2721cd4721fdff924a1c81c611497d0e16fe43dab380b631fb118dfd36e69f23998f96f2b8e33670d5a129f475a5da2d6f6675487330937da9aea
diff --git a/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/md5 b/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/md5
deleted file mode 100644
index 5d9fdfb8ebd7e..0000000000000
--- a/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-311f5b6b7e109fea852303ec09324b00
diff --git a/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/sha512 b/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/sha512
deleted file mode 100644
index 8a3c1c9238514..0000000000000
--- a/deps/checksums/StyledStrings-61e7b105b157b40807ed0b4840166a25b0948549.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-fbf4b2fdde4fd2c2bb321b915d9833ea34952aec1bf9fdcf51e229e6bae5fc0fbfd30db31e410c634955144c6a4295289a313185621e2c5f16b06f22a049739f
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index bca2e9dca3e67..f287f7d81b714 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = 61e7b105b157b40807ed0b4840166a25b0948549
+STYLEDSTRINGS_SHA1 = 302a0d023a58d38cddf0a1b82c618621613c8d2a
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1

From 32ad80bbdb6d80589e0232221dd66e52a8da205b Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 23 Jan 2024 20:10:41 +0530
Subject: [PATCH 0696/1315] Add type assertion in iterate for logicalindex
 (#53015)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The type-assertion helps convey the information that
`iterate(tail(s)...)` would never return `nothing`, which makes JET
happy.
On master
```julia
julia> L = Base.LogicalIndex([true])
1-element Base.LogicalIndex{Int64, Vector{Bool}}:
 1

julia> @report_call iterate(L)
═════ 2 possible errors found ═════
┌ iterate(L::Base.LogicalIndex{Int64, Vector{Bool}}) @ Base ./multidimensional.jl:778
│┌ iterate(L::Base.LogicalIndex{Int64, Vector{Bool}}, s::Tuple{Int64, LinearIndices{1, Tuple{Base.OneTo{Int64}}}}) @ Base ./multidimensional.jl:789
││┌ indexed_iterate(I::Nothing, i::Int64) @ Base ./tuple.jl:94
│││ no matching method found `iterate(::Nothing)`: x = iterate(I::Nothing)
││└────────────────────
││┌ indexed_iterate(I::Nothing, i::Int64, state::Int64) @ Base ./tuple.jl:99
│││ no matching method found `iterate(::Nothing, ::Int64)`: x = iterate(I::Nothing, state::Int64)
```
This PR
```julia
julia> @report_call iterate(L)
No errors detected
```

Close https://github.com/JuliaArrays/StaticArrays.jl/issues/1225
---
 base/multidimensional.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 4416d377c63a0..4b462c8e2079b 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -786,11 +786,11 @@ end
     n = s[1]
     n > length(L) && return nothing
     #unroll once to help inference, cf issue #29418
-    idx, i = iterate(tail(s)...)
+    idx, i = iterate(tail(s)...)::Tuple{Any,Any}
     s = (n+1, s[2], i)
     L.mask[idx] && return (idx, s)
     while true
-        idx, i = iterate(tail(s)...)
+        idx, i = iterate(tail(s)...)::Tuple{Any,Any}
         s = (n+1, s[2], i)
         L.mask[idx] && return (idx, s)
     end

From 4dcd271fb579cfa50faa4a66542456e554801efd Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Tue, 23 Jan 2024 15:44:08 +0100
Subject: [PATCH 0697/1315] Base: prevent `precision` infinite recursion
 (#52910)

Make the single-argument method of `_precision` into its own function.

Now `precision(Union{Float16,Float32})` results in a `MethodError`
instead of in a `StackOverflowError`.

Fixes #52909
---
 base/float.jl   | 10 +++++-----
 base/mpfr.jl    | 10 +++++-----
 test/numbers.jl | 23 +++++++++++++++++++++++
 3 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/base/float.jl b/base/float.jl
index d26d279e47895..5e40652490835 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -836,12 +836,12 @@ number of significand digits in that base.
 """
 function precision end
 
-_precision(::Type{Float16}) = 11
-_precision(::Type{Float32}) = 24
-_precision(::Type{Float64}) = 53
-function _precision(x, base::Integer=2)
+_precision_with_base_2(::Type{Float16}) = 11
+_precision_with_base_2(::Type{Float32}) = 24
+_precision_with_base_2(::Type{Float64}) = 53
+function _precision(x, base::Integer)
     base > 1 || throw(DomainError(base, "`base` cannot be less than 2."))
-    p = _precision(x)
+    p = _precision_with_base_2(x)
     return base == 2 ? Int(p) : floor(Int, p / log2(base))
 end
 precision(::Type{T}; base::Integer=2) where {T<:AbstractFloat} = _precision(T, base)
diff --git a/base/mpfr.jl b/base/mpfr.jl
index 276fd430ff1e0..c12154fa517c3 100644
--- a/base/mpfr.jl
+++ b/base/mpfr.jl
@@ -16,7 +16,7 @@ import
         cosh, sinh, tanh, sech, csch, coth, acosh, asinh, atanh, lerpi,
         cbrt, typemax, typemin, unsafe_trunc, floatmin, floatmax, rounding,
         setrounding, maxintfloat, widen, significand, frexp, tryparse, iszero,
-        isone, big, _string_n, decompose, minmax,
+        isone, big, _string_n, decompose, minmax, _precision_with_base_2,
         sinpi, cospi, sincospi, tanpi, sind, cosd, tand, asind, acosd, atand,
         uinttype, exponent_max, exponent_min, ieee754_representation, significand_mask,
         RawBigIntRoundingIncrementHelper, truncated, RawBigInt
@@ -221,7 +221,7 @@ widen(::Type{Float64}) = BigFloat
 widen(::Type{BigFloat}) = BigFloat
 
 function BigFloat(x::BigFloat, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[])
-    if precision == _precision(x)
+    if precision == _precision_with_base_2(x)
         return x
     else
         z = BigFloat(;precision=precision)
@@ -232,7 +232,7 @@ function BigFloat(x::BigFloat, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::I
 end
 
 function _duplicate(x::BigFloat)
-    z = BigFloat(;precision=_precision(x))
+    z = BigFloat(;precision=_precision_with_base_2(x))
     ccall((:mpfr_set, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Int32), z, x, 0)
     return z
 end
@@ -954,12 +954,12 @@ function sign(x::BigFloat)
     return c < 0 ? -one(x) : one(x)
 end
 
-function _precision(x::BigFloat)  # precision of an object of type BigFloat
+function _precision_with_base_2(x::BigFloat)  # precision of an object of type BigFloat
     return ccall((:mpfr_get_prec, libmpfr), Clong, (Ref{BigFloat},), x)
 end
 precision(x::BigFloat; base::Integer=2) = _precision(x, base)
 
-_precision(::Type{BigFloat}) = Int(DEFAULT_PRECISION[]) # default precision of the type BigFloat itself
+_precision_with_base_2(::Type{BigFloat}) = Int(DEFAULT_PRECISION[]) # default precision of the type BigFloat itself
 
 """
     setprecision([T=BigFloat,] precision::Int; base=2)
diff --git a/test/numbers.jl b/test/numbers.jl
index 33b0b73c1bad3..0a01fc136e167 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -3141,3 +3141,26 @@ end
         @test n == G(F(n)) == F(G(n))
     end
 end
+
+@testset "`precision`" begin
+    Fs = (Float16, Float32, Float64, BigFloat)
+
+    @testset "type vs instance" begin
+        @testset "F: $F" for F ∈ Fs
+            @test precision(F) == precision(one(F))
+            @test precision(F, base = 2) == precision(one(F), base = 2)
+            @test precision(F, base = 3) == precision(one(F), base = 3)
+        end
+    end
+
+    @testset "`precision` of `Union` shouldn't recur infinitely, #52909" begin
+        @testset "i: $i" for i ∈ eachindex(Fs)
+            @testset "j: $j" for j ∈ (i + 1):lastindex(Fs)
+                S = Fs[i]
+                T = Fs[j]
+                @test_throws MethodError precision(Union{S,T})
+                @test_throws MethodError precision(Union{S,T}, base = 3)
+            end
+        end
+    end
+end

From d741c2412eae5cc0d26a425c6aa54e5ae9e92170 Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Tue, 23 Jan 2024 09:57:41 -0500
Subject: [PATCH 0698/1315] Make empty `Dict` only have space for 0 rather than
 16 elements (and the minimum size for non-empty `Dict` down to 4). (#52912)

This improves speed and reduces allocation for small Dicts.
```
#before
julia> @btime Dict{Int,Int}()
  46.815 ns (4 allocations: 448 bytes)

#after
julia> @btime Dict{Int, Int}()
  9.429 ns (1 allocation: 80 bytes)
```
The initialization to 16 before made sense when `Dict` was `Vector`
backed since `Vectors` were slow to instantiate, but Memory is much
faster).
---
 base/dict.jl | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/base/dict.jl b/base/dict.jl
index db65f46509b40..2b6fd41d8d075 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -74,10 +74,10 @@ mutable struct Dict{K,V} <: AbstractDict{K,V}
     maxprobe::Int
 
     function Dict{K,V}() where V where K
-        n = 16
+        n = 0
         slots = Memory{UInt8}(undef,n)
         fill!(slots, 0x0)
-        new(slots, Memory{K}(undef, n), Memory{V}(undef, n), 0, 0, 0, n, 0)
+        new(slots, Memory{K}(undef, n), Memory{V}(undef, n), 0, 0, 0, max(1, n), 0)
     end
     function Dict{K,V}(d::Dict{K,V}) where V where K
         new(copy(d.slots), copy(d.keys), copy(d.vals), d.ndel, d.count, d.age,
@@ -266,7 +266,7 @@ function empty!(h::Dict{K,V}) where V where K
     h.count = 0
     h.maxprobe = 0
     h.age += 1
-    h.idxfloor = sz
+    h.idxfloor = max(1, sz)
     return h
 end
 
@@ -302,6 +302,11 @@ end
 # This version is for use by setindex! and get!
 function ht_keyindex2_shorthash!(h::Dict{K,V}, key) where V where K
     sz = length(h.keys)
+    if sz == 0 # if Dict was empty resize and then return location to insert
+        rehash!(h, 4)
+        index, sh = hashindex(key, length(h.keys))
+        return -index, sh
+    end
     iter = 0
     maxprobe = h.maxprobe
     index, sh = hashindex(key, sz)
@@ -367,7 +372,7 @@ ht_keyindex2!(h::Dict, key) = ht_keyindex2_shorthash!(h, key)[1]
     # Rehash now if necessary
     if (h.count + h.ndel)*3 > sz*2
         # > 2/3 full (including tombstones)
-        rehash!(h, h.count > 64000 ? h.count*2 : h.count*4)
+        rehash!(h, h.count > 64000 ? h.count*2 : max(h.count*4, 4))
     end
     nothing
 end

From 128e6e4ef01af8a8141f765a795ee902c8ed81cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Wed, 24 Jan 2024 01:33:37 +0000
Subject: [PATCH 0699/1315] [nghttp2_jll] Update to v1.59.0 (#53010)

---
 deps/checksums/nghttp2              | 68 ++++++++++++++---------------
 deps/nghttp2.version                |  2 +-
 stdlib/nghttp2_jll/Project.toml     |  4 +-
 stdlib/nghttp2_jll/test/runtests.jl |  2 +-
 4 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/deps/checksums/nghttp2 b/deps/checksums/nghttp2
index 9c419f5234ffc..cfe5dbbab17ee 100644
--- a/deps/checksums/nghttp2
+++ b/deps/checksums/nghttp2
@@ -1,34 +1,34 @@
-nghttp2-1.58.0.tar.bz2/md5/f60a0340da2638eba448df73b6783bc3
-nghttp2-1.58.0.tar.bz2/sha512/7a40afe80587a13bdd7fd85fc7eb666c0dcc18b951a03c65ab4b52429bdf5d2eae27a9bfaa7303e7517e275239397f60dd466170364dfbd1077e25188ba54aca
-nghttp2.v1.58.0+0.aarch64-apple-darwin.tar.gz/md5/528dec6d4a54854532d527067dccade7
-nghttp2.v1.58.0+0.aarch64-apple-darwin.tar.gz/sha512/cfc993f23f95ef3b2841d40e704c17816dec22a173a16c5d0bc3c85a092f1d63b69e47112a8a1aeb4e85603a7087746b97fbf9ea91a0ec42b45d38deb78f3e0b
-nghttp2.v1.58.0+0.aarch64-linux-gnu.tar.gz/md5/c358e3407e956bddab6fde752c2bd2b5
-nghttp2.v1.58.0+0.aarch64-linux-gnu.tar.gz/sha512/207ef70f4ba231e8e4fd570a5da7931a488a297d2d525983499d874abef268440d3e8408cc953c3deab5219bc8c93034b89bf2f3e4c1179b52cede354ae6d27f
-nghttp2.v1.58.0+0.aarch64-linux-musl.tar.gz/md5/eef1a1209fdbf30a71af878e307c4fb2
-nghttp2.v1.58.0+0.aarch64-linux-musl.tar.gz/sha512/9ad61002303add92b3d9842a408092b8b35ac8ac5ab17fabb77f144261c4829a2695111177b4794901efba87f97ed9274aac9935fc702c60189395abbb4d9a3f
-nghttp2.v1.58.0+0.armv6l-linux-gnueabihf.tar.gz/md5/2864d534833745ff12ebb86378a90b0b
-nghttp2.v1.58.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/091c367466cd547859d06b6d0bd37d424b0ccefc0f41dd4819156a61f98e0cc1eebf6da4171810e2a876fec9b919675efd9240089681ca8d3cd8620f5f40f8f3
-nghttp2.v1.58.0+0.armv6l-linux-musleabihf.tar.gz/md5/30a7b272ed36c45a3a5f58e7406150e5
-nghttp2.v1.58.0+0.armv6l-linux-musleabihf.tar.gz/sha512/c1c96c2e987a700929c0158232ef745a0fe8d93c722174a91b32c767cdc0441ee73059da9f64daca4010367ee005a9037919cdb73079a12f9612f45852549b0d
-nghttp2.v1.58.0+0.armv7l-linux-gnueabihf.tar.gz/md5/3940e07955102a7a71030fe4c8aed59f
-nghttp2.v1.58.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/5b628901371a36937a16802211707334b02632c8651a5fd01d2e1508926e51c960b693abbea6f629cfb7ca750b6039b5e4385324f2d431f1fe6e47b121a57f30
-nghttp2.v1.58.0+0.armv7l-linux-musleabihf.tar.gz/md5/2d6d0b8adba7bfea20dabde3c87333df
-nghttp2.v1.58.0+0.armv7l-linux-musleabihf.tar.gz/sha512/10c72fdc2e635add9f0364dd95fd8404f187068bce05587531d4865f75126c8eaf4f7c154762175d3ed0e85914b21df90c193766f610da91bb6dd75fe93df5fa
-nghttp2.v1.58.0+0.i686-linux-gnu.tar.gz/md5/8753bf62f8863b5c3041ef73ed3fe36a
-nghttp2.v1.58.0+0.i686-linux-gnu.tar.gz/sha512/741a8f2bd5902df9f06de67ecdcb041951a21e0d32f5acffac780cba7a41be5d67507ca49f65bf636849baf1b07e53871d9ee5624d4e33e1d4ff4137bd785bda
-nghttp2.v1.58.0+0.i686-linux-musl.tar.gz/md5/a1b0f85e40bef6f2647a9e1dfa415196
-nghttp2.v1.58.0+0.i686-linux-musl.tar.gz/sha512/0e438073cc6fe39e2b47d7b89467c1cab1abe953e357f782b2cb16de5f9238f063b925ab602558a1d562b3c3f608167dd339a4ec54ec93b27c4f43bd2e54aaed
-nghttp2.v1.58.0+0.i686-w64-mingw32.tar.gz/md5/7cf81bd21105f4d9fd5dd4dbf61fcb70
-nghttp2.v1.58.0+0.i686-w64-mingw32.tar.gz/sha512/47624f56df68983d3bd881cab1e88be249b678cb184cc426443c4a8c85481af03cddc65f642f1d88afd300cad88950662a99c5dbd75a459bd99dc56d3f38231c
-nghttp2.v1.58.0+0.powerpc64le-linux-gnu.tar.gz/md5/a6e9e975026f658cb2b68418c5f2cee9
-nghttp2.v1.58.0+0.powerpc64le-linux-gnu.tar.gz/sha512/2007cf1420ac0866b4b6b5b463aa9c491abd85b2559bea259efa075e308301b10f1d8e72f86c36c21cf42e891f672ac289b5c81640a83f002c89aefebeefb355
-nghttp2.v1.58.0+0.x86_64-apple-darwin.tar.gz/md5/06c250253f1969f1c8460f3c65ec02a9
-nghttp2.v1.58.0+0.x86_64-apple-darwin.tar.gz/sha512/397bd1ea32617ff005ad4217cdd5652a6a58d5c98837cdb8366aa4d0fd86824673864850aeb3771c3304755d8d5466b881b4007603a9cded924cd6b8b18384f4
-nghttp2.v1.58.0+0.x86_64-linux-gnu.tar.gz/md5/2be0cc258a81106eaea132fbbdfce04f
-nghttp2.v1.58.0+0.x86_64-linux-gnu.tar.gz/sha512/1be2b3906b9a5e2cb9af24ea358b92b50e3c7be85e9533784e3721b28219bce555700ebe3edf789123ff471a062dfc22f10eef1d21a6f060a43151f8904495d0
-nghttp2.v1.58.0+0.x86_64-linux-musl.tar.gz/md5/55898f6770dd85835d76e52003e8a1f6
-nghttp2.v1.58.0+0.x86_64-linux-musl.tar.gz/sha512/ad2266563dca33543c5fae9d0cb4daf9f0c6f4ccab8efc30e2eb273be9df33ae43da3007bcf83d19f39b830c11c17f8577014c81fcf5e76dce159f28937166f2
-nghttp2.v1.58.0+0.x86_64-unknown-freebsd.tar.gz/md5/5f9886a4e321bc393dd086106a685466
-nghttp2.v1.58.0+0.x86_64-unknown-freebsd.tar.gz/sha512/d86ba3730bb63143f990bdbe453fa4a0692b434beab372aa9a8e7673c2fddc8c97ebd2e47ac109ffe50172121f2d56ddd40d8d500b73e61a58635edcede8d071
-nghttp2.v1.58.0+0.x86_64-w64-mingw32.tar.gz/md5/98ecb527506234cc69cb8a958a74a002
-nghttp2.v1.58.0+0.x86_64-w64-mingw32.tar.gz/sha512/3941233fdfa82af9a5590f5975728d51e42791eb1b966a4ae7913a24f52500c24dea05e66911b3c5768535b145c99b31e2dc2ab50354648492df4b4b63434578
+nghttp2-1.59.0.tar.bz2/md5/ed847a9f718b0bed4491a51344e8e6c8
+nghttp2-1.59.0.tar.bz2/sha512/63c497afdebb98a3a38fe41ff9ef0027d670231fbd118cef22b6340829df5de91df3d4f503135d54e54f9ee056f71efbda640b78f4fbb9ff56ba085177bb41f8
+nghttp2.v1.59.0+0.aarch64-apple-darwin.tar.gz/md5/531f9c56fe3d2d4e4457cf4245fc8a81
+nghttp2.v1.59.0+0.aarch64-apple-darwin.tar.gz/sha512/497b26a66da86ad8d0a28323a18b4ee9cd9682b6ff8ef681d760cd17bc3e82ea98385e2d621e8060a706b50531afdf6f63fa3717005446c4159780f73d17f8da
+nghttp2.v1.59.0+0.aarch64-linux-gnu.tar.gz/md5/9e853f884f638534b5ce88112c7b1fbd
+nghttp2.v1.59.0+0.aarch64-linux-gnu.tar.gz/sha512/72da4843e3b2b01f568d61894a7c83ace1f175667e0b64663f8bcca9a7315509f5b91f96b21508aba6009d7d33ccdf75f4aed8a8dc45ed0934654512ef2200f0
+nghttp2.v1.59.0+0.aarch64-linux-musl.tar.gz/md5/25f1489b3cc3a5bef92af5bf136e62b5
+nghttp2.v1.59.0+0.aarch64-linux-musl.tar.gz/sha512/abe1f8c5faa2a1ae6308d1c13850cc6288b13f744576de574fa6e0871f372da9121059814b467b9d5763c2bdd54ef4a38ba842a394e23735a2cc5b9c7fec13fe
+nghttp2.v1.59.0+0.armv6l-linux-gnueabihf.tar.gz/md5/33448bd8e19b63811f07e7f8f6d84fbd
+nghttp2.v1.59.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/b327d63e3742528f2d3b17dc97923429acd71156e4b688118295f7e7257c6313869e742b2475ee2540436d5cd68ac9224298c9ca0be4ec7c8a8b9741b65d210e
+nghttp2.v1.59.0+0.armv6l-linux-musleabihf.tar.gz/md5/8e6836af6f1e7532b1ada585a31bc9ad
+nghttp2.v1.59.0+0.armv6l-linux-musleabihf.tar.gz/sha512/db17877b4bafd608fe844959e1640060161a6e36ba762053b9f7153d075c3c3eadea61d72dd9f9683cec3c4b0564f284eb0b443d1715a5af77afa6f8abfa2ed4
+nghttp2.v1.59.0+0.armv7l-linux-gnueabihf.tar.gz/md5/f537e4776bbb1d9e85f8eea76df99679
+nghttp2.v1.59.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/60bb3612a8021c194a0766775583b137f5f48ed3c7d4e1afbbeeef617a5a959494c35df34d2e9a68e53b8bb676b67de5b0b47f6e98543ecccd8fe10cee2ea3dd
+nghttp2.v1.59.0+0.armv7l-linux-musleabihf.tar.gz/md5/ffecbf49f667cd0a2c09919299ffa54e
+nghttp2.v1.59.0+0.armv7l-linux-musleabihf.tar.gz/sha512/c34cdbe0074012c6889dfb9c93c44a4b1b0ed86197428f97b1d7b1bcd829f384121b8fc60f2c608e4206dc203739df9382a0653e75362eef282616c65251de24
+nghttp2.v1.59.0+0.i686-linux-gnu.tar.gz/md5/bb8b7668b5de15e3cdab955f905b6681
+nghttp2.v1.59.0+0.i686-linux-gnu.tar.gz/sha512/42be179bbe6a9b4c9a7f086177a23bfa0d99ec3b8ff4741a7656bcd302de9613cdb1bf556e483d924a3362c150d3286de30531d226ac402ca4a464fad3271175
+nghttp2.v1.59.0+0.i686-linux-musl.tar.gz/md5/298fb89147eb458a5f948ac6298213c1
+nghttp2.v1.59.0+0.i686-linux-musl.tar.gz/sha512/693b41d8e764f1475b79aff74c036697779dc82ac5dc79cd4d25c15ef9627e398c50cc43ad4296b96c3b6fdbb4c7514a041396570b82b3d35ef27c6c2286e8e1
+nghttp2.v1.59.0+0.i686-w64-mingw32.tar.gz/md5/b69df3b2a034b0309b5ae97ecf6e803a
+nghttp2.v1.59.0+0.i686-w64-mingw32.tar.gz/sha512/1c349ccb0799942f117f56f0e2f83f898b5913071651e4bb8d1750d7ab6fdc9b6e3e894ee760623b27ae23ba7910a6674b5bbda7db3a8388fef68c0908e2ec7d
+nghttp2.v1.59.0+0.powerpc64le-linux-gnu.tar.gz/md5/fc101f34e22f8885ed4141514572f2ea
+nghttp2.v1.59.0+0.powerpc64le-linux-gnu.tar.gz/sha512/c7377429fcf47a0a7e9c2a1ca78d4eeba819f6f7f2fb1191fa46b7ce516db6a489994993abe50e2848cc7ab600a747cbc13e8e6484077cb8ca8fe37775bd0016
+nghttp2.v1.59.0+0.x86_64-apple-darwin.tar.gz/md5/9f81d5bd0aa9b1b4e1536020f59496ee
+nghttp2.v1.59.0+0.x86_64-apple-darwin.tar.gz/sha512/c8a0641b5255a70e305b4baf5689914fc4abf795ade4ddb636243d40828195bdf2d2df394e4f8680beb70f0e497d5ceae90f6453b32ebf5d77ed03239bbb64c4
+nghttp2.v1.59.0+0.x86_64-linux-gnu.tar.gz/md5/954ef507adf403630588734a5c1ec42e
+nghttp2.v1.59.0+0.x86_64-linux-gnu.tar.gz/sha512/e4de84a962e2a9a4b9b61fa69d0816db5daa271fa3440f01eb116856e5f8c9cdd0cf0aa63ff9fffd51073548ee81e94d83b4d3fd096efa6c38983047ac8a556a
+nghttp2.v1.59.0+0.x86_64-linux-musl.tar.gz/md5/d14e89c0473ccbfa0ccb6291069f605b
+nghttp2.v1.59.0+0.x86_64-linux-musl.tar.gz/sha512/5255c8e9b501b636fd78b90b46c7e46d583f1ec3328a512153f2460c3f5136ac024e9c9f05c44be8efb8eee687b95080154c6c086358755c167ff9defac37146
+nghttp2.v1.59.0+0.x86_64-unknown-freebsd.tar.gz/md5/3a396ec020b3e9f067ffbe36315f250a
+nghttp2.v1.59.0+0.x86_64-unknown-freebsd.tar.gz/sha512/bfc14de5851428548816f289032dce4adcfd17d3ffddd77785777f573df5950ae40df006164ef256eda19a9402101c05dcd994e8bf4f566ddb73a51b8cc1a641
+nghttp2.v1.59.0+0.x86_64-w64-mingw32.tar.gz/md5/300bf8563122e081a17a836fd0d62b6e
+nghttp2.v1.59.0+0.x86_64-w64-mingw32.tar.gz/sha512/7967faa9ff64897e4ea6cddff8e70c823472b9b0a814055b7032546cdada76904b28d4b3d0408377108e54b5aac67b83177c03afd71424bb2d4a5bd1d3f96827
diff --git a/deps/nghttp2.version b/deps/nghttp2.version
index 680be055e4443..a893c5ee8085e 100644
--- a/deps/nghttp2.version
+++ b/deps/nghttp2.version
@@ -3,4 +3,4 @@
 NGHTTP2_JLL_NAME := nghttp2
 
 ## source build
-NGHTTP2_VER := 1.58.0
+NGHTTP2_VER := 1.59.0
diff --git a/stdlib/nghttp2_jll/Project.toml b/stdlib/nghttp2_jll/Project.toml
index 560a9537a3b21..ea7ca1615f050 100644
--- a/stdlib/nghttp2_jll/Project.toml
+++ b/stdlib/nghttp2_jll/Project.toml
@@ -1,13 +1,13 @@
 name = "nghttp2_jll"
 uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
-version = "1.58.0+0"
+version = "1.59.0+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
 
 [compat]
-julia = "1.6"
+julia = "1.11"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/stdlib/nghttp2_jll/test/runtests.jl b/stdlib/nghttp2_jll/test/runtests.jl
index 8155e4e787fcc..daa848d19f9b6 100644
--- a/stdlib/nghttp2_jll/test/runtests.jl
+++ b/stdlib/nghttp2_jll/test/runtests.jl
@@ -11,5 +11,5 @@ end
 
 @testset "nghttp2_jll" begin
     info = unsafe_load(ccall((:nghttp2_version,libnghttp2), Ptr{nghttp2_info}, (Cint,), 0))
-    @test VersionNumber(unsafe_string(info.version_str)) == v"1.58.0"
+    @test VersionNumber(unsafe_string(info.version_str)) == v"1.59.0"
 end

From 35c0498ceb1668fbc05ff5ae24ac1e696fdfa6a5 Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Wed, 24 Jan 2024 13:31:28 +0100
Subject: [PATCH 0700/1315] Fix a list in GC devdocs (#53032)

When splitting a Markdown list item into multiple lines, the following
lines must be indented or else a new paragraph starts.
---
 doc/src/devdocs/gc.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/src/devdocs/gc.md b/doc/src/devdocs/gc.md
index 2f75e4d911f69..9b9038c9445f3 100644
--- a/doc/src/devdocs/gc.md
+++ b/doc/src/devdocs/gc.md
@@ -26,10 +26,10 @@ Julia's pool allocator follows a "tiered" allocation discipline. When requesting
 - If it failed claiming a page from `page_pool_lazily_freed`, it will try to claim a page from `the page_pool_clean`, which contains pages which were mmaped on a previous page allocation request but never accessed.
 
 - If it failed claiming a page from `pool_page_clean` and from `page_pool_lazily_freed`, it will try to claim a page
-from `page_pool_freed`, which contains pages which have already been madvised by a concurrent sweeper GC thread and whose underlying virtual address can be recycled.
+  from `page_pool_freed`, which contains pages which have already been madvised by a concurrent sweeper GC thread and whose underlying virtual address can be recycled.
 
 - If it failed in all of the attempts mentioned above, it will mmap a batch of pages, claim one page for itself, and
-insert the remaining pages into `page_pool_clean`.
+  insert the remaining pages into `page_pool_clean`.
 
 ![Diagram of tiered pool allocation](./img/gc-tiered-allocation.jpg)
 

From 91ec2bb646ca1ef14a86232da2aa80a9c9f46d40 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Wed, 24 Jan 2024 10:20:40 -0300
Subject: [PATCH 0701/1315] Apple silicon has 128 byte alignment so fix our
 defines to match (#52996)

https://github.com/JuliaLang/julia/blob/8a69745bdcb06409ab7e4fc84718f34d7d54a7f9/base/lock.jl#L33-L50
this probably also needs a fix, and maybe other places as well
---
 src/julia_internal.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/julia_internal.h b/src/julia_internal.h
index 4f92c3eb500e3..d8e9a909f1761 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -485,7 +485,11 @@ STATIC_INLINE uint8_t JL_CONST_FUNC jl_gc_szclass_align8(unsigned sz) JL_NOTSAFE
 }
 
 #define JL_SMALL_BYTE_ALIGNMENT 16
+#if defined(_CPU_AARCH64_) && defined(_OS_DARWIN_) // Apple silicon has 128 cache lines
+#define JL_CACHE_BYTE_ALIGNMENT 128
+#else
 #define JL_CACHE_BYTE_ALIGNMENT 64
+#endif
 // JL_HEAP_ALIGNMENT is the maximum alignment that the GC can provide
 #define JL_HEAP_ALIGNMENT JL_SMALL_BYTE_ALIGNMENT
 #define GC_MAX_SZCLASS (2032-sizeof(void*))

From 81c4f8e1b3dc16738d136967c1b32f3e1ee969ba Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Wed, 24 Jan 2024 14:20:49 +0100
Subject: [PATCH 0702/1315] Replace `&hArr;` by `&harr;` in documentation
 (#52078)

There is no HTML entity `&hArr;` and accordingly all the usual browsers
(Chrome, Firefox, Safari) don't render it.

My guess is that there is confusion because GitHub supports `&hArr;` and
shows it as &hArr; (and `&harr;` as &harr;).

But here is for example what Firefox shows:
<img width="853" alt="Screen Shot 2023-11-08 at 14 02 01"
src="https://github.com/JuliaLang/julia/assets/241512/af7d9e27-a5c3-46c3-94d9-82ed52653cb4">


This patch could be backported to 1.9 and 1.10.
---
 doc/src/manual/noteworthy-differences.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/src/manual/noteworthy-differences.md b/doc/src/manual/noteworthy-differences.md
index ef47a7635d50a..ef8fe471c4be7 100644
--- a/doc/src/manual/noteworthy-differences.md
+++ b/doc/src/manual/noteworthy-differences.md
@@ -353,7 +353,7 @@ For users coming to Julia from R, these are some noteworthy differences:
     it's more general than that since methods are dispatched on every argument type, not only `this`,
     using the most-specific-declaration rule).
 
-### Julia &hArr; C/C++: Namespaces
+### Julia &harr; C/C++: Namespaces
   * C/C++ `namespace`s correspond roughly to Julia `module`s.
   * There are no private globals or fields in Julia.  Everything is publicly accessible
     through fully qualified paths (or relative paths, if desired).
@@ -365,7 +365,7 @@ For users coming to Julia from R, these are some noteworthy differences:
   * Caveat: `import`/`using` (Julia) works only at the global scope level (`module`s)
     * In C++, `using namespace X` works within arbitrary scopes (ex: function scope).
 
-### Julia &hArr; C/C++: Module loading
+### Julia &harr; C/C++: Module loading
   * When you think of a C/C++ "**library**", you are likely looking for a Julia "**package**".
     * Caveat: C/C++ libraries often house multiple "software modules" whereas Julia
       "packages" typically house one.
@@ -396,7 +396,7 @@ For users coming to Julia from R, these are some noteworthy differences:
     * Directory-based package repositories are the **quickest solution** to developing local
       libraries of "software modules".
 
-### Julia &hArr; C/C++: Assembling modules
+### Julia &harr; C/C++: Assembling modules
   * In C/C++, `.c`/`.cpp` files are compiled & added to a library with build/`make` scripts.
     * In Julia, `import [PkgName]`/`using [PkgName]` statements load `[PkgName].jl` located
       in a package's `[PkgName]/src/` subdirectory.
@@ -413,7 +413,7 @@ For users coming to Julia from R, these are some noteworthy differences:
       Julia package* ("software module"). It is therefore relatively straightforward to ensure
       file are `include`d only once (No `#ifdef` confusion).
 
-### Julia &hArr; C/C++: Module interface
+### Julia &harr; C/C++: Module interface
   * C++ exposes interfaces using "public" `.h`/`.hpp` files whereas Julia `module`s mark
     specific symbols that are intended for their users as `public`or `export`ed.
     * Often, Julia `module`s simply add functionality by generating new "methods" to existing
@@ -427,7 +427,7 @@ For users coming to Julia from R, these are some noteworthy differences:
     * Users might be expected to access these components by qualifying functions/structs/...
       with the package/module name (ex: `MyModule.run_this_task(...)`).
 
-### Julia &hArr; C/C++: Quick reference
+### Julia &harr; C/C++: Quick reference
 
 | Software Concept   | Julia | C/C++ |
 | :---               | :---  | :---  |

From e74f9e4dfba109544f276a1bf204b90b1b34eca4 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Wed, 24 Jan 2024 23:25:13 +0800
Subject: [PATCH 0703/1315] Introduce new syntax highlighting stdlib (#51810)

Having this as a standard library allows for syntax highlighting to be
used in the Markdown and REPL standard libraries. As a bonus, this
provides an easy and canonical way of obtaining syntax highlighted code
across the ecosystem.

This is a pretty tiny library, at just ~200 lines, but a useful one.
---
 NEWS.md                                                     | 6 ++++++
 .../md5                                                     | 1 +
 .../sha512                                                  | 1 +
 pkgimage.mk                                                 | 1 +
 stdlib/.gitignore                                           | 2 ++
 stdlib/JuliaSyntaxHighlighting.version                      | 4 ++++
 stdlib/Makefile                                             | 3 ++-
 stdlib/stdlib.mk                                            | 6 +++---
 8 files changed, 20 insertions(+), 4 deletions(-)
 create mode 100644 deps/checksums/JuliaSyntaxHighlighting-4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63.tar.gz/md5
 create mode 100644 deps/checksums/JuliaSyntaxHighlighting-4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63.tar.gz/sha512
 create mode 100644 stdlib/JuliaSyntaxHighlighting.version

diff --git a/NEWS.md b/NEWS.md
index d1f9ca49bb4c7..f4dd8c8600041 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -109,6 +109,12 @@ Standard library changes
 * The new `@styled_str` string macro provides a convenient way of creating a
   `AnnotatedString` with various faces or other attributes applied ([#49586]).
 
+#### JuliaSyntaxHighlighting
+
+* A new standard library for applying syntax highlighting to Julia code, this
+  uses `JuliaSyntax` and `StyledStrings` to implement a `highlight` function
+  that creates an `AnnotatedString` with syntax highlighting applied.
+
 #### Package Manager
 
 #### LinearAlgebra
diff --git a/deps/checksums/JuliaSyntaxHighlighting-4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63.tar.gz/md5 b/deps/checksums/JuliaSyntaxHighlighting-4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63.tar.gz/md5
new file mode 100644
index 0000000000000..5e99f7453cfe2
--- /dev/null
+++ b/deps/checksums/JuliaSyntaxHighlighting-4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63.tar.gz/md5
@@ -0,0 +1 @@
+08230d0801fda3c81927d558452215e4
diff --git a/deps/checksums/JuliaSyntaxHighlighting-4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63.tar.gz/sha512 b/deps/checksums/JuliaSyntaxHighlighting-4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63.tar.gz/sha512
new file mode 100644
index 0000000000000..16d15cdef3104
--- /dev/null
+++ b/deps/checksums/JuliaSyntaxHighlighting-4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63.tar.gz/sha512
@@ -0,0 +1 @@
+0386841dcf30ee53f7f95dd3206e1208482507d157aa09739873de2a56e5ca3d7bbf27eccd9f4ed81c1c0fea229673475f6454fe94df0ff960563ca4c29ed36c
diff --git a/pkgimage.mk b/pkgimage.mk
index 83c66bd94c702..3c741db2c2202 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -94,6 +94,7 @@ $(eval $(call stdlib_builder,Printf,Unicode))
 $(eval $(call stdlib_builder,Random,SHA))
 $(eval $(call stdlib_builder,Tar,ArgTools,SHA))
 $(eval $(call stdlib_builder,DelimitedFiles,Mmap))
+$(eval $(call stdlib_builder,JuliaSyntaxHighlighting,))
 
 # 2-depth packages
 $(eval $(call stdlib_builder,LLD_jll,Zlib_jll libLLVM_jll Artifacts Libdl))
diff --git a/stdlib/.gitignore b/stdlib/.gitignore
index ce744aa43d9f5..93668857189af 100644
--- a/stdlib/.gitignore
+++ b/stdlib/.gitignore
@@ -27,6 +27,8 @@
 /Distributed
 /StyledStrings-*
 /StyledStrings
+/JuliaSyntaxHighlighting-*
+/JuliaSyntaxHighlighting
 /*_jll/StdlibArtifacts.toml
 /*/Manifest.toml
 /*.image
diff --git a/stdlib/JuliaSyntaxHighlighting.version b/stdlib/JuliaSyntaxHighlighting.version
new file mode 100644
index 0000000000000..4a819d056e70e
--- /dev/null
+++ b/stdlib/JuliaSyntaxHighlighting.version
@@ -0,0 +1,4 @@
+JULIASYNTAXHIGHLIGHTING_BRANCH = main
+JULIASYNTAXHIGHLIGHTING_SHA1 = 4110caaf4fcdf0c614fd3ecd7c5bf589ca82ac63
+JULIASYNTAXHIGHLIGHTING_GIT_URL := https://github.com/julialang/JuliaSyntaxHighlighting.jl.git
+JULIASYNTAXHIGHLIGHTING_TAR_URL = https://api.github.com/repos/julialang/JuliaSyntaxHighlighting.jl/tarball/$1
diff --git a/stdlib/Makefile b/stdlib/Makefile
index 1c8a2849d75f1..ebc40c9db2b12 100644
--- a/stdlib/Makefile
+++ b/stdlib/Makefile
@@ -47,7 +47,8 @@ STDLIBS = Artifacts Base64 CRC32c Dates FileWatching \
           $(JLL_NAMES)
 
 STDLIBS_EXT = Pkg Statistics LazyArtifacts LibCURL DelimitedFiles Downloads ArgTools \
-              Tar NetworkOptions SuiteSparse SparseArrays StyledStrings SHA Distributed
+              Tar NetworkOptions SuiteSparse SparseArrays StyledStrings SHA Distributed \
+              JuliaSyntaxHighlighting
 
 $(foreach module, $(STDLIBS_EXT), $(eval $(call stdlib-external,$(module),$(shell echo $(module) | tr a-z A-Z))))
 
diff --git a/stdlib/stdlib.mk b/stdlib/stdlib.mk
index 696b24a8f8bf1..eeb0e085c8790 100644
--- a/stdlib/stdlib.mk
+++ b/stdlib/stdlib.mk
@@ -4,9 +4,9 @@ STDLIBS_WITHIN_SYSIMG := \
 
 INDEPENDENT_STDLIBS := \
 	ArgTools Base64 CRC32c Dates DelimitedFiles Distributed Downloads Future \
-	InteractiveUtils LazyArtifacts LibGit2 LibCURL Logging Markdown Mmap \
-	NetworkOptions Profile Printf Pkg REPL Serialization SharedArrays SparseArrays \
-	Statistics StyledStrings Tar Test TOML Unicode UUIDs \
+	InteractiveUtils JuliaSyntaxHighlighting LazyArtifacts LibGit2 LibCURL Logging \
+    Markdown Mmap NetworkOptions Profile Printf Pkg REPL Serialization SharedArrays \
+    SparseArrays Statistics StyledStrings Tar Test TOML Unicode UUIDs \
 	dSFMT_jll GMP_jll libLLVM_jll LLD_jll LLVMLibUnwind_jll LibUnwind_jll LibUV_jll \
 	LibCURL_jll LibSSH2_jll LibGit2_jll nghttp2_jll  MozillaCACerts_jll MbedTLS_jll \
 	MPFR_jll OpenLibm_jll PCRE2_jll p7zip_jll Zlib_jll

From f5816f4f904242ac298ef3e68a0179866d08e5b7 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Wed, 24 Jan 2024 10:59:44 -0500
Subject: [PATCH 0704/1315] Int64 -> Int in fixed precompile statements
 (#53029)

Fixes https://github.com/JuliaLang/julia/issues/53025
---
 contrib/generate_precompile.jl | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index 04162ae68000e..956b3b38a0e72 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -46,10 +46,10 @@ precompile(Base.check_open, (Base.TTY,))
 precompile(Base.getproperty, (Base.TTY, Symbol))
 precompile(write, (Base.TTY, String))
 precompile(Tuple{typeof(Base.get), Base.TTY, Symbol, Bool})
-precompile(Tuple{typeof(Base.hashindex), String, Int64})
+precompile(Tuple{typeof(Base.hashindex), String, Int})
 precompile(Tuple{typeof(Base.write), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
-precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Int64}, Int64})
-precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Int64}, Int64, Int64})
+precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Int}, Int})
+precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Int}, Int, Int})
 precompile(Tuple{typeof(Base._typeddict), Base.Dict{String, Any}, Base.Dict{String, Any}, Vararg{Base.Dict{String, Any}}})
 precompile(Tuple{typeof(Base.promoteK), Type, Base.Dict{String, Any}, Base.Dict{String, Any}})
 precompile(Tuple{typeof(Base.promoteK), Type, Base.Dict{String, Any}})
@@ -72,8 +72,8 @@ precompile(Tuple{typeof(Base.exit)})
 precompile(Tuple{typeof(Base.require), Base.PkgId})
 precompile(Tuple{typeof(Base.recursive_prefs_merge), Base.Dict{String, Any}})
 precompile(Tuple{typeof(Base.recursive_prefs_merge), Base.Dict{String, Any}, Base.Dict{String, Any}, Vararg{Base.Dict{String, Any}}})
-precompile(Tuple{typeof(Base.hashindex), Tuple{Base.PkgId, Nothing}, Int64})
-precompile(Tuple{typeof(Base.hashindex), Tuple{Base.PkgId, String}, Int64})
+precompile(Tuple{typeof(Base.hashindex), Tuple{Base.PkgId, Nothing}, Int})
+precompile(Tuple{typeof(Base.hashindex), Tuple{Base.PkgId, String}, Int})
 precompile(Tuple{typeof(isassigned), Core.SimpleVector, Int})
 precompile(Tuple{typeof(getindex), Core.SimpleVector, Int})
 precompile(Tuple{typeof(Base.Experimental.register_error_hint), Any, Type})

From 919c3908066da7ac361fa5677a6af11acbdc3153 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Wed, 24 Jan 2024 14:08:42 -0300
Subject: [PATCH 0705/1315] use proper cache-line size variable in
 work-stealing queue (#53035)

---
 src/julia_atomics.h       | 9 +++++++++
 src/julia_internal.h      | 5 -----
 src/work-stealing-queue.h | 2 +-
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/julia_atomics.h b/src/julia_atomics.h
index c4488f774c987..76be881067805 100644
--- a/src/julia_atomics.h
+++ b/src/julia_atomics.h
@@ -56,6 +56,15 @@ enum jl_memory_order {
     jl_memory_order_seq_cst
 };
 
+/**
+ * Cache line size
+*/
+#if defined(_CPU_AARCH64_) && defined(_OS_DARWIN_) // Apple silicon has 128 cache lines
+#define JL_CACHE_BYTE_ALIGNMENT 128
+#else
+#define JL_CACHE_BYTE_ALIGNMENT 64
+#endif
+
 /**
  * Thread synchronization primitives:
  *
diff --git a/src/julia_internal.h b/src/julia_internal.h
index d8e9a909f1761..b85ccdede884d 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -485,11 +485,6 @@ STATIC_INLINE uint8_t JL_CONST_FUNC jl_gc_szclass_align8(unsigned sz) JL_NOTSAFE
 }
 
 #define JL_SMALL_BYTE_ALIGNMENT 16
-#if defined(_CPU_AARCH64_) && defined(_OS_DARWIN_) // Apple silicon has 128 cache lines
-#define JL_CACHE_BYTE_ALIGNMENT 128
-#else
-#define JL_CACHE_BYTE_ALIGNMENT 64
-#endif
 // JL_HEAP_ALIGNMENT is the maximum alignment that the GC can provide
 #define JL_HEAP_ALIGNMENT JL_SMALL_BYTE_ALIGNMENT
 #define GC_MAX_SZCLASS (2032-sizeof(void*))
diff --git a/src/work-stealing-queue.h b/src/work-stealing-queue.h
index 084e421fd58b3..5902c2ac6af9f 100644
--- a/src/work-stealing-queue.h
+++ b/src/work-stealing-queue.h
@@ -36,7 +36,7 @@ static inline ws_array_t *create_ws_array(size_t capacity, int32_t eltsz) JL_NOT
 
 typedef struct {
     _Atomic(int64_t) top;
-    char _padding[128 - sizeof(int64_t)];
+    char _padding[JL_CACHE_BYTE_ALIGNMENT - sizeof(_Atomic(int64_t))];
     _Atomic(int64_t) bottom; // put on a separate cache line. conservatively estimate cache line size as 128 bytes
     _Atomic(ws_array_t *) array;
 } ws_queue_t;

From e42ffa63deb489dec7f971b897eaa43ecc85a322 Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Wed, 24 Jan 2024 19:17:31 +0100
Subject: [PATCH 0706/1315] Add GC.logging_enabled() (#51647)

---
 NEWS.md              | 1 +
 base/gcutils.jl      | 9 +++++++++
 doc/src/base/base.md | 1 +
 src/gc-debug.c       | 4 ++++
 src/gc.h             | 1 +
 test/misc.jl         | 2 ++
 6 files changed, 18 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index f4dd8c8600041..87623395d9b68 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -74,6 +74,7 @@ New library functions
 * `eachrsplit(string, pattern)` iterates split substrings right to left.
 * `Sys.username()` can be used to return the current user's username ([#51897]).
 * `wrap(Array, m::Union{MemoryRef{T}, Memory{T}}, dims)` which is the safe counterpart to `unsafe_wrap` ([#52049]).
+* `GC.logging_enabled()` can be used to test whether GC logging has been enabled via `GC.enable_logging` ([#51647]).
 
 New library features
 --------------------
diff --git a/base/gcutils.jl b/base/gcutils.jl
index ea39bc8ab6130..25f098e407223 100644
--- a/base/gcutils.jl
+++ b/base/gcutils.jl
@@ -262,4 +262,13 @@ function enable_logging(on::Bool=true)
     ccall(:jl_enable_gc_logging, Cvoid, (Cint,), on)
 end
 
+"""
+    GC.logging_enabled()
+
+Return whether GC logging has been enabled via [`GC.enable_logging`](@ref).
+"""
+function logging_enabled()
+    ccall(:jl_is_gc_logging_enabled, Cint, ()) != 0
+end
+
 end # module GC
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 7172474b40b39..ee9cede4e6455 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -491,6 +491,7 @@ Base.GC.enable
 Base.GC.@preserve
 Base.GC.safepoint
 Base.GC.enable_logging
+Base.GC.logging_enabled
 Meta.lower
 Meta.@lower
 Meta.parse(::AbstractString, ::Int)
diff --git a/src/gc-debug.c b/src/gc-debug.c
index b91bab876b11c..124b7da74dee1 100644
--- a/src/gc-debug.c
+++ b/src/gc-debug.c
@@ -1207,6 +1207,10 @@ JL_DLLEXPORT void jl_enable_gc_logging(int enable) {
     gc_logging_enabled = enable;
 }
 
+JL_DLLEXPORT int jl_is_gc_logging_enabled(void) {
+    return gc_logging_enabled;
+}
+
 void _report_gc_finished(uint64_t pause, uint64_t freed, int full, int recollect, int64_t live_bytes) JL_NOTSAFEPOINT {
     if (!gc_logging_enabled) {
         return;
diff --git a/src/gc.h b/src/gc.h
index 60ed90fb3415b..4bb8828910e6c 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -726,6 +726,7 @@ void gc_count_pool(void);
 size_t jl_genericmemory_nbytes(jl_genericmemory_t *a) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT void jl_enable_gc_logging(int enable);
+JL_DLLEXPORT int jl_is_gc_logging_enabled(void);
 JL_DLLEXPORT uint32_t jl_get_num_stack_mappings(void);
 void _report_gc_finished(uint64_t pause, uint64_t freed, int full, int recollect, int64_t live_bytes) JL_NOTSAFEPOINT;
 
diff --git a/test/misc.jl b/test/misc.jl
index aeef937cac9fa..11410a497a4f5 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1343,8 +1343,10 @@ end
         open(tmppath, "w") do tmpio
             redirect_stderr(tmpio) do
                 GC.enable_logging(true)
+                @test GC.logging_enabled()
                 GC.gc()
                 GC.enable_logging(false)
+                @test !GC.logging_enabled()
             end
         end
         @test occursin("GC: pause", read(tmppath, String))

From ca7b9c37de31ee72b4c68c07f54ad376edb9ce9f Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Thu, 25 Jan 2024 05:22:28 +0800
Subject: [PATCH 0707/1315] Make concatenation of SubString{AnnotatedString}
 preserve annotations (#51806)

`SubStrings` have been overlooked, and thanks to a few compiler quirks
(relating to inlining and effect analysis), adding support for them is
unfortunately a little more complicated than adding a `|| s isa
SubString{<:AnnotatedString}` clause thanks to the new generated
runtime-checks.

To maintain the zero-overhead non-annotated code path, we need to
implement a separate function `_isannotated`, which we also make use of
to simplify the current join method.
---
 base/strings/basic.jl     | 10 +++++++---
 base/strings/io.jl        |  5 +----
 base/strings/substring.jl |  2 ++
 base/strings/util.jl      |  4 ++--
 test/strings/annotated.jl |  5 +++--
 5 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/base/strings/basic.jl b/base/strings/basic.jl
index 4136571963f99..2d5f0cea26e36 100644
--- a/base/strings/basic.jl
+++ b/base/strings/basic.jl
@@ -259,9 +259,7 @@ julia> 'j' * "ulia"
 ```
 """
 function (*)(s1::Union{AbstractChar, AbstractString}, ss::Union{AbstractChar, AbstractString}...)
-    isannotated = s1 isa AnnotatedString || s1 isa AnnotatedChar ||
-        any(s -> s isa AnnotatedString || s isa AnnotatedChar, ss)
-    if isannotated
+    if _isannotated(s1) || any(_isannotated, ss)
         annotatedstring(s1, ss...)
     else
         string(s1, ss...)
@@ -270,6 +268,12 @@ end
 
 one(::Union{T,Type{T}}) where {T<:AbstractString} = convert(T, "")
 
+# This could be written as a single statement with three ||-clauses, however then effect
+# analysis thinks it may throw and runtime checks are added.
+# Also see `substring.jl` for the `::SubString{T}` method.
+_isannotated(S::Type) = S != Union{} && (S <: AnnotatedString || S <: AnnotatedChar)
+_isannotated(s) = _isannotated(typeof(s))
+
 ## generic string comparison ##
 
 """
diff --git a/base/strings/io.jl b/base/strings/io.jl
index c1e45775f6ca0..6db737532637d 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -365,10 +365,7 @@ function join_annotated(iterator, delim="", last=delim)
 end
 
 function _join_maybe_annotated(args...)
-    if any(function (arg)
-               t = eltype(arg)
-               !(t == Union{}) && (t <: AnnotatedString || t <: AnnotatedChar)
-           end, args)
+    if any(_isannotated ∘ eltype, args)
         join_annotated(args...)
     else
         sprint(join, args...)
diff --git a/base/strings/substring.jl b/base/strings/substring.jl
index ffa78c00cb885..2a6b4ae7b9a22 100644
--- a/base/strings/substring.jl
+++ b/base/strings/substring.jl
@@ -140,6 +140,8 @@ function hash(s::SubString{String}, h::UInt)
     ccall(memhash, UInt, (Ptr{UInt8}, Csize_t, UInt32), s, sizeof(s), h % UInt32) + h
 end
 
+_isannotated(::SubString{T}) where {T} = _isannotated(T)
+
 """
     reverse(s::AbstractString) -> AbstractString
 
diff --git a/base/strings/util.jl b/base/strings/util.jl
index a3f8e9a4773a6..b5eb9185c3766 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -459,7 +459,7 @@ function lpad(
     n::Integer,
     p::Union{AbstractChar,AbstractString}=' ',
 )
-    stringfn = if any(isa.((s, p), Union{AnnotatedString, AnnotatedChar, SubString{<:AnnotatedString}}))
+    stringfn = if _isannotated(s) || _isannotated(p)
         annotatedstring else string end
     n = Int(n)::Int
     m = signed(n) - Int(textwidth(s))::Int
@@ -491,7 +491,7 @@ function rpad(
     n::Integer,
     p::Union{AbstractChar,AbstractString}=' ',
 )
-    stringfn = if any(isa.((s, p), Union{AnnotatedString, AnnotatedChar, SubString{<:AnnotatedString}}))
+    stringfn = if _isannotated(s) || _isannotated(p)
         annotatedstring else string end
     n = Int(n)::Int
     m = signed(n) - Int(textwidth(s))::Int
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index be70578d149f5..70f490f4787ca 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -34,8 +34,9 @@
         Base.AnnotatedString("ab", [(1:1, :a => 1), (2:2, :b => 2)])
     let allstrings =
         ['a', Base.AnnotatedChar('a'), Base.AnnotatedChar('a', [:aaa => 0x04]),
-        "a string", Base.AnnotatedString("a string"),
-        Base.AnnotatedString("a string", [(1:2, :hmm => '%')])]
+         "a string", Base.AnnotatedString("a string"),
+         Base.AnnotatedString("a string", [(1:2, :hmm => '%')]),
+         SubString(Base.AnnotatedString("a string", [(1:2, :hmm => '%')]), 1:1)]
         for str1 in repeat(allstrings, 2)
             for str2 in repeat(allstrings, 2)
                 @test String(str1 * str2) ==

From 3da897b1ce604d79d0b59efabdcd0b0908a39dcf Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 25 Jan 2024 08:36:15 +0530
Subject: [PATCH 0708/1315] Don't access uninitialized indices in
 `tril!`/`triu!` for numeric arrays (#52528)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This specializes the generic `triu!` and `tril!` methods for arrays of
numbers, where a zero is known to exist. In such cases, we don't need to
read the possibly uninitialized values of the elements at the indices
that are to be assigned to. After this, the following would be possible:
```julia
julia> M = Matrix{BigFloat}(undef, 3, 3)
3×3 Matrix{BigFloat}:
 #undef  #undef  #undef
 #undef  #undef  #undef
 #undef  #undef  #undef

julia> triu!(M)
3×3 Matrix{BigFloat}:
 #undef  #undef  #undef
   0.0   #undef  #undef
   0.0     0.0   #undef
```
---
 stdlib/LinearAlgebra/src/dense.jl       | 12 +++++++---
 stdlib/LinearAlgebra/test/triangular.jl | 29 +++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 683f7e45cb28d..91c38e7f0b09b 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -106,6 +106,11 @@ norm1(x::Union{Array{T},StridedVector{T}}) where {T<:BlasReal} =
 norm2(x::Union{Array{T},StridedVector{T}}) where {T<:BlasFloat} =
     length(x) < NRM2_CUTOFF ? generic_norm2(x) : BLAS.nrm2(x)
 
+# Conservative assessment of types that have zero(T) defined for themselves
+haszero(::Type) = false
+haszero(::Type{T}) where {T<:Number} = isconcretetype(T)
+@propagate_inbounds _zero(M::AbstractArray{T}, i, j) where {T} = haszero(T) ? zero(T) : zero(M[i,j])
+
 """
     triu!(M, k::Integer)
 
@@ -136,7 +141,7 @@ function triu!(M::AbstractMatrix, k::Integer)
     m, n = size(M)
     for j in 1:min(n, m + k)
         for i in max(1, j - k + 1):m
-            @inbounds M[i,j] = zero(M[i,j])
+            @inbounds M[i,j] = _zero(M, i,j)
         end
     end
     M
@@ -173,12 +178,13 @@ function tril!(M::AbstractMatrix, k::Integer)
     require_one_based_indexing(M)
     m, n = size(M)
     for j in max(1, k + 1):n
-        @inbounds for i in 1:min(j - k - 1, m)
-            M[i,j] = zero(M[i,j])
+        for i in 1:min(j - k - 1, m)
+            @inbounds M[i,j] = _zero(M, i,j)
         end
     end
     M
 end
+
 tril(M::Matrix, k::Integer) = tril!(copy(M), k)
 
 """
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index 43cafaaa74c9e..d8948ae109735 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -897,6 +897,35 @@ end
     end
 end
 
+@testset "tril!/triu! for non-bitstype matrices" begin
+    @testset "numeric" begin
+        M = Matrix{BigFloat}(undef, 3, 3)
+        tril!(M)
+        L = LowerTriangular(ones(3,3))
+        copytrito!(M, L, 'L')
+        @test M == L
+
+        M = Matrix{BigFloat}(undef, 3, 3)
+        triu!(M)
+        U = UpperTriangular(ones(3,3))
+        copytrito!(M, U, 'U')
+        @test M == U
+    end
+    @testset "array elements" begin
+        M = fill(ones(2,2), 4, 4)
+        tril!(M)
+        L = LowerTriangular(fill(fill(2,2,2),4,4))
+        copytrito!(M, L, 'L')
+        @test M == L
+
+        M = fill(ones(2,2), 4, 4)
+        triu!(M)
+        U = UpperTriangular(fill(fill(2,2,2),4,4))
+        copytrito!(M, U, 'U')
+        @test M == U
+    end
+end
+
 @testset "avoid matmul ambiguities with ::MyMatrix * ::AbstractMatrix" begin
     A = [i+j for i in 1:2, j in 1:2]
     S = SizedArrays.SizedArray{(2,2)}(A)

From b3ecd615b436964aabd9af8b5a7c03d7fd2d088a Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Thu, 25 Jan 2024 02:22:13 -0500
Subject: [PATCH 0709/1315] make `isassigned(::ScopedValue)` more compatible
 with the generic meaning (#53022)

---
 base/scopedvalues.jl | 13 +++++++++----
 test/scopedvalues.jl | 10 ++++++++++
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/base/scopedvalues.jl b/base/scopedvalues.jl
index 71c8a68785952..ee4571b8ae497 100644
--- a/base/scopedvalues.jl
+++ b/base/scopedvalues.jl
@@ -52,9 +52,14 @@ Base.eltype(::ScopedValue{T}) where {T} = T
 """
     isassigned(val::ScopedValue)
 
-Test if the ScopedValue has a default value.
+Test whether a ScopedValue has an assigned value.
 """
-Base.isassigned(val::ScopedValue) = val.has_default
+function Base.isassigned(val::ScopedValue)
+    val.has_default && return true
+    scope = Core.current_scope()::Union{Scope, Nothing}
+    scope === nothing && return false
+    return haskey((scope::Scope).values, val)
+end
 
 const ScopeStorage = Base.PersistentDict{ScopedValue, Any}
 
@@ -111,11 +116,11 @@ value.
 function get(val::ScopedValue{T}) where {T}
     scope = Core.current_scope()::Union{Scope, Nothing}
     if scope === nothing
-        isassigned(val) && return Some{T}(val.default)
+        val.has_default && return Some{T}(val.default)
         return nothing
     end
     scope = scope::Scope
-    if isassigned(val)
+    if val.has_default
         return Some{T}(Base.get(scope.values, val, val.default)::T)
     else
         v = Base.get(scope.values, val, novalue)
diff --git a/test/scopedvalues.jl b/test/scopedvalues.jl
index 7f52707a182f1..39de22bc2bee5 100644
--- a/test/scopedvalues.jl
+++ b/test/scopedvalues.jl
@@ -127,6 +127,16 @@ end
     end
 end
 
+@testset "isassigned" begin
+    sv = ScopedValue(1)
+    @test isassigned(sv)
+    sv = ScopedValue{Int}()
+    @test !isassigned(sv)
+    with(sv => 2) do
+        @test isassigned(sv)
+    end
+end
+
 # Test that the `@with` macro doesn't introduce unnecessary PhiC nodes
 # (which can be hard for the optimizer to remove).
 function with_macro_slot_cross()

From 0eec0317b1991c477b87d1760233bed1043e052d Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Thu, 25 Jan 2024 04:58:15 -0300
Subject: [PATCH 0710/1315] fix cache line size of PPC7+ (#53044)

Ref: https://reviews.llvm.org/D33656.

---------

Co-authored-by: Keno Fischer <keno@juliacomputing.com>
---
 src/julia_atomics.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/julia_atomics.h b/src/julia_atomics.h
index 76be881067805..7e7c8052a278b 100644
--- a/src/julia_atomics.h
+++ b/src/julia_atomics.h
@@ -59,7 +59,7 @@ enum jl_memory_order {
 /**
  * Cache line size
 */
-#if defined(_CPU_AARCH64_) && defined(_OS_DARWIN_) // Apple silicon has 128 cache lines
+#if (defined(_CPU_AARCH64_) && defined(_OS_DARWIN_)) || defined(_CPU_PPC64_)  // Apple silicon and PPC7+ have 128 byte cache lines
 #define JL_CACHE_BYTE_ALIGNMENT 128
 #else
 #define JL_CACHE_BYTE_ALIGNMENT 64

From 14cf64fd3d5b3b5856c0afa930d5286a5246cf04 Mon Sep 17 00:00:00 2001
From: Jeremie Knuesel <knuesel@gmail.com>
Date: Thu, 25 Jan 2024 12:18:30 +0100
Subject: [PATCH 0711/1315] Remove wrong entries from NEWS.md (#53036)

This removes the `hardlink` and `diskstat` entries in `NEWS.md` that I
think were wrongly copied from the 1.8 release notes.

(I took the opportunity to fix also a couple of unrelated typos)
---
 NEWS.md | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 87623395d9b68..dd16151ffa74c 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -7,7 +7,7 @@ New language features
   API. Symbols marked with `export` are now also treated as public API. The
   difference between `public` and `export` is that `public` names do not become
   available when `using` a package/module ([#50105]).
-* `ScopedValue` implement dynamic scope with inheritance across tasks ([#50958]).
+* `ScopedValue` implements dynamic scope with inheritance across tasks ([#50958]).
 * The new macro `Base.Cartesian.@ncallkw` is analogous to `Base.Cartesian.@ncall`,
   but allows to add keyword arguments to the function call ([#51501]).
 * Support for Unicode 15.1 ([#51799]).
@@ -30,7 +30,7 @@ Language changes
   wants to begin exiting.
 * Code coverage and malloc tracking is no longer generated during the package precompilation stage.
   Further, during these modes pkgimage caches are now used for packages that are not being tracked.
-  Meaning that coverage testing (the default for `julia-actions/julia-runtest`) will by default use
+  This means that coverage testing (the default for `julia-actions/julia-runtest`) will by default use
   pkgimage caches for all other packages than the package being tested, likely meaning faster test
   execution. ([#52123])
 
@@ -42,7 +42,7 @@ Compiler/Runtime improvements
 * Updated GC heuristics to count allocated pages instead of individual objects ([#50144]).
 * A new `LazyLibrary` type is exported from `Libdl` for use in building chained lazy library
   loads, primarily to be used within JLLs ([#50074]).
-* Added a support for annotating `Base.@assume_effects` on code block ([#52400]).
+* Added support for annotating `Base.@assume_effects` on code blocks ([#52400]).
 
 Command-line option changes
 ---------------------------
@@ -68,12 +68,10 @@ New library functions
 
 * `in!(x, s::AbstractSet)` will return whether `x` is in `s`, and insert `x` in `s` if not.
 * The new `Libc.mkfifo` function wraps the `mkfifo` C function on Unix platforms ([#34587]).
-* `hardlink(src, dst)` can be used to create hard links ([#41639]).
-* `diskstat(path=pwd())` can be used to return statistics about the disk ([#42248]).
 * `copyuntil(out, io, delim)` and `copyline(out, io)` copy data into an `out::IO` stream ([#48273]).
 * `eachrsplit(string, pattern)` iterates split substrings right to left.
 * `Sys.username()` can be used to return the current user's username ([#51897]).
-* `wrap(Array, m::Union{MemoryRef{T}, Memory{T}}, dims)` which is the safe counterpart to `unsafe_wrap` ([#52049]).
+* `wrap(Array, m::Union{MemoryRef{T}, Memory{T}}, dims)` is the safe counterpart to `unsafe_wrap` ([#52049]).
 * `GC.logging_enabled()` can be used to test whether GC logging has been enabled via `GC.enable_logging` ([#51647]).
 
 New library features

From 936701e3c55fa159fddeccfee75ff554aa644f60 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 25 Jan 2024 20:46:47 +0530
Subject: [PATCH 0712/1315] Avoid `StackOverflowError` in generic recursive
 `dot` (#53030)

A quick check to throw an error early if `first(x) == x && first(y) ==
y`, in which case the recursive `dot` will lead to a stack overflow.

Close https://github.com/JuliaLang/julia/issues/35654
---
 stdlib/LinearAlgebra/src/generic.jl  | 2 ++
 stdlib/LinearAlgebra/test/generic.jl | 6 ++++++
 2 files changed, 8 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl
index a51b155cf3785..d0a985f3b6e51 100644
--- a/stdlib/LinearAlgebra/src/generic.jl
+++ b/stdlib/LinearAlgebra/src/generic.jl
@@ -864,6 +864,8 @@ function dot(x, y) # arbitrary iterables
     end
     (vx, xs) = ix
     (vy, ys) = iy
+    typeof(vx) == typeof(x) && typeof(vy) == typeof(y) && throw(ArgumentError(
+            "cannot evaluate dot recursively if the type of an element is identical to that of the container"))
     s = dot(vx, vy)
     while true
         ix = iterate(x, xs)
diff --git a/stdlib/LinearAlgebra/test/generic.jl b/stdlib/LinearAlgebra/test/generic.jl
index b8cb15ff695cb..6318b8e405ede 100644
--- a/stdlib/LinearAlgebra/test/generic.jl
+++ b/stdlib/LinearAlgebra/test/generic.jl
@@ -606,6 +606,12 @@ end
     end
 end
 
+@testset "avoid stackoverflow in dot" begin
+    @test_throws "cannot evaluate dot recursively" dot('a', 'c')
+    @test_throws "cannot evaluate dot recursively" dot('a', 'b':'c')
+    @test_throws "x and y are of different lengths" dot(1, 1:2)
+end
+
 @testset "generalized dot #32739" begin
     for elty in (Int, Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFloat})
         n = 10

From 55c13d234c1523861b278f7989b1af105ef0e88f Mon Sep 17 00:00:00 2001
From: Harmen Stoppels <me@harmenstoppels.nl>
Date: Thu, 25 Jan 2024 18:06:21 +0100
Subject: [PATCH 0713/1315] Symlink lld and dsymutil in correct
 build_depsbindir when `USE_SYSTEM_LLD=1` (#53050)

Fixes #53049.

Two things are addressed:

1. `dsymutil` wasn't linked
2. `lld` was put in `build_bindir`, but on install was looked for in
`build_depsbindir`
---
 base/Makefile | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/base/Makefile b/base/Makefile
index 493302af78b02..6abf9b285ce34 100644
--- a/base/Makefile
+++ b/base/Makefile
@@ -205,18 +205,24 @@ $(build_bindir)/7z$(EXE):
 	rm -f "$@" && \
 	ln -svf "$(7Z_PATH)" "$@"
 
-symlink_lld: $(build_bindir)/lld$(EXE)
+symlink_llvm_utils: $(build_depsbindir)/lld$(EXE) $(build_depsbindir)/dsymutil$(EXE)
 
 ifneq ($(USE_SYSTEM_LLD),0)
-SYMLINK_SYSTEM_LIBRARIES += symlink_lld
+SYMLINK_SYSTEM_LIBRARIES += symlink_llvm_utils
 LLD_PATH := $(shell which lld$(EXE))
+DSYMUTIL_PATH := $(shell which dsymutil$(EXE))
 endif
 
-$(build_bindir)/lld$(EXE):
+$(build_depsbindir)/lld$(EXE):
 	[ -e "$(LLD_PATH)" ] && \
 	rm -f "$@" && \
 	ln -svf "$(LLD_PATH)" "$@"
 
+$(build_depsbindir)/dsymutil$(EXE):
+	[ -e "$(DSYMUTIL_PATH)" ] && \
+	rm -f "$@" && \
+	ln -svf "$(DSYMUTIL_PATH)" "$@"
+
 # the following excludes: libuv.a, libutf8proc.a
 
 ifneq ($(USE_SYSTEM_LIBM),0)

From 4919dd79dfd848eb6d9929768666977f374c7f10 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 25 Jan 2024 14:50:47 -0500
Subject: [PATCH 0714/1315] Profile: use full terminal cols to show function
 name (#53055)

---
 stdlib/Profile/src/Profile.jl | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index aad97be683309..e01f5ae7d2d6b 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -891,7 +891,6 @@ function tree_format(frames::Vector{<:StackFrameTree}, level::Int, cols::Int, ma
     ndigline = ndigits(maximum(frame.frame.line for frame in frames)) + 6
     ntext = max(30, cols - ndigoverhead - nindent - ndigcounts - ndigline - 6)
     widthfile = 2*ntext÷5 # min 12
-    widthfunc = 3*ntext÷5 # min 18
     strs = Vector{String}(undef, length(frames))
     showextra = false
     if level > nindent
@@ -933,11 +932,12 @@ function tree_format(frames::Vector{<:StackFrameTree}, level::Int, cols::Int, ma
                     ":",
                     li.line == -1 ? "?" : string(li.line),
                     "; ",
-                    ltruncto(fname, widthfunc))
+                    fname)
             end
         else
             strs[i] = string(stroverhead, "╎", base, strcount, " [unknown stackframe]")
         end
+        strs[i] = ltruncto(strs[i], cols)
     end
     return strs
 end
@@ -1193,17 +1193,17 @@ end
 
 # Utilities
 function rtruncto(str::String, w::Int)
-    if length(str) <= w
+    if textwidth(str) <= w
         return str
     else
-        return string("...", str[prevind(str, end, w-4):end])
+        return string("…", str[prevind(str, end, w-2):end])
     end
 end
 function ltruncto(str::String, w::Int)
-    if length(str) <= w
+    if textwidth(str) <= w
         return str
     else
-        return string(str[1:nextind(str, 1, w-4)], "...")
+        return string(str[1:nextind(str, 1, w-2)], "…")
     end
 end
 

From 1e45aba072171e24e6f006ba0c7385cca5920fb4 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 26 Jan 2024 07:16:45 +0530
Subject: [PATCH 0715/1315] Fix indexing triangular matrices with `undef`
 elements in the parent (#52530)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I'm not totally sure about specializing`getindex` for numeric arrays,
but this lets us display a triangular matrix where the parent is not
initialized.
```julia
julia> M = Matrix{BigFloat}(undef, 4, 4)
4×4 Matrix{BigFloat}:
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

julia> UpperTriangular(M)
4×4 UpperTriangular{BigFloat, Matrix{BigFloat}}:
 #undef  #undef  #undef  #undef
    ⋅    #undef  #undef  #undef
    ⋅       ⋅    #undef  #undef
    ⋅       ⋅       ⋅    #undef
```
---
 stdlib/LinearAlgebra/src/triangular.jl  |  4 ++--
 stdlib/LinearAlgebra/test/triangular.jl | 13 +++++++++++++
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 6e92b9f07dd84..9590944f7b406 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -262,11 +262,11 @@ Base.isstored(A::UpperTriangular, i::Int, j::Int) =
 @propagate_inbounds getindex(A::UnitLowerTriangular{T}, i::Integer, j::Integer) where {T} =
     i > j ? A.data[i,j] : ifelse(i == j, oneunit(T), zero(T))
 @propagate_inbounds getindex(A::LowerTriangular, i::Integer, j::Integer) =
-    i >= j ? A.data[i,j] : zero(A.data[j,i])
+    i >= j ? A.data[i,j] : _zero(A.data,j,i)
 @propagate_inbounds getindex(A::UnitUpperTriangular{T}, i::Integer, j::Integer) where {T} =
     i < j ? A.data[i,j] : ifelse(i == j, oneunit(T), zero(T))
 @propagate_inbounds getindex(A::UpperTriangular, i::Integer, j::Integer) =
-    i <= j ? A.data[i,j] : zero(A.data[j,i])
+    i <= j ? A.data[i,j] : _zero(A.data,j,i)
 
 @propagate_inbounds function setindex!(A::UpperTriangular, x, i::Integer, j::Integer)
     if i > j
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index d8948ae109735..36c5b78bd9a21 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -811,6 +811,14 @@ end
     end
 end
 
+@testset "indexing partly initialized matrices" begin
+    M = Matrix{BigFloat}(undef, 2, 2)
+    U = UpperTriangular(M)
+    @test iszero(U[2,1])
+    L = LowerTriangular(M)
+    @test iszero(L[1,2])
+end
+
 @testset "special printing of Lower/UpperTriangular" begin
     @test occursin(r"3×3 (LinearAlgebra\.)?LowerTriangular{Int64, Matrix{Int64}}:\n 2  ⋅  ⋅\n 2  2  ⋅\n 2  2  2",
                    sprint(show, MIME"text/plain"(), LowerTriangular(2ones(Int64,3,3))))
@@ -820,6 +828,11 @@ end
                    sprint(show, MIME"text/plain"(), UpperTriangular(2ones(Int64,3,3))))
     @test occursin(r"3×3 (LinearAlgebra\.)?UnitUpperTriangular{Int64, Matrix{Int64}}:\n 1  2  2\n ⋅  1  2\n ⋅  ⋅  1",
                    sprint(show, MIME"text/plain"(), UnitUpperTriangular(2ones(Int64,3,3))))
+
+    # don't access non-structural elements while displaying
+    M = Matrix{BigFloat}(undef, 2, 2)
+    @test sprint(show, UpperTriangular(M)) == "BigFloat[#undef #undef; 0.0 #undef]"
+    @test sprint(show, LowerTriangular(M)) == "BigFloat[#undef 0.0; #undef #undef]"
 end
 
 @testset "adjoint/transpose triangular/vector multiplication" begin

From 5cf10211fe9097a2551b1d1bc0a2ce670fa4df7f Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Fri, 26 Jan 2024 10:37:39 +0800
Subject: [PATCH 0716/1315] Subtype: Fix some diagonal rule related false alarm
 (#53034)

close #33137
close #53021

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 src/jltypes.c   | 80 ++++++++++++++++++++++++++++++-------------------
 src/julia.h     |  2 ++
 src/subtype.c   |  6 ++--
 test/core.jl    | 15 ++++++++--
 test/subtype.jl | 19 ++++++------
 5 files changed, 77 insertions(+), 45 deletions(-)

diff --git a/src/jltypes.c b/src/jltypes.c
index 5bd5ec31185d9..21c3cebbb8de7 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -556,6 +556,43 @@ static void isort_union(jl_value_t **a, size_t len) JL_NOTSAFEPOINT
     }
 }
 
+static int simple_subtype(jl_value_t *a, jl_value_t *b, int hasfree, int isUnion)
+{
+    if (a == jl_bottom_type || b == (jl_value_t*)jl_any_type)
+        return 1;
+    if (jl_egal(a, b))
+        return 1;
+    if (hasfree == 0) {
+        int mergeable = isUnion;
+        if (!mergeable) // issue #24521: don't merge Type{T} where typeof(T) varies
+            mergeable = !(jl_is_type_type(a) && jl_is_type_type(b) &&
+             jl_typeof(jl_tparam0(a)) != jl_typeof(jl_tparam0(b)));
+        return mergeable && jl_subtype(a, b);
+    }
+    if (jl_is_typevar(a)) {
+        jl_value_t *na = ((jl_tvar_t*)a)->ub;
+        hasfree &= jl_has_free_typevars(na);
+        return simple_subtype(na, b, hasfree, isUnion);
+    }
+    if (jl_is_typevar(b)) {
+        jl_value_t *nb = ((jl_tvar_t*)b)->lb;
+        // This branch is not valid if `b` obeys diagonal rule,
+        // as it might normalize `Union` into a single `TypeVar`, e.g.
+        // Tuple{Union{Int,T},T} where {T>:Int} != Tuple{T,T} where {T>:Int}
+        if (is_leaf_bound(nb))
+            return 0;
+        hasfree &= jl_has_free_typevars(nb) << 1;
+        return simple_subtype(a, nb, hasfree, isUnion);
+    }
+    if (b==(jl_value_t*)jl_datatype_type || b==(jl_value_t*)jl_typeofbottom_type) {
+        // This branch is not valid for `Union`/`UnionAll`, e.g.
+        // (Type{Union{Int,T2} where {T2<:T1}} where {T1}){Int} == Type{Int64}
+        // (Type{Union{Int,T1}} where {T1}){Int} == Type{Int64}
+        return jl_is_type_type(a) && jl_typeof(jl_tparam0(a)) == b;
+    }
+    return 0;
+}
+
 JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n)
 {
     if (n == 0)
@@ -580,13 +617,9 @@ JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n)
         int has_free = temp[i] != NULL && jl_has_free_typevars(temp[i]);
         for (j = 0; j < nt; j++) {
             if (j != i && temp[i] && temp[j]) {
-                if (temp[i] == jl_bottom_type ||
-                    temp[j] == (jl_value_t*)jl_any_type ||
-                    jl_egal(temp[i], temp[j]) ||
-                    (!has_free && !jl_has_free_typevars(temp[j]) &&
-                     jl_subtype(temp[i], temp[j]))) {
+                int has_free2 = has_free | (jl_has_free_typevars(temp[j]) << 1);
+                if (simple_subtype(temp[i], temp[j], has_free2, 1))
                     temp[i] = NULL;
-                }
             }
         }
     }
@@ -608,17 +641,7 @@ JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n)
     return tu;
 }
 
-// note: this is turned off as `Union` doesn't do such normalization.
-// static int simple_subtype(jl_value_t *a, jl_value_t *b)
-// {
-//     if (jl_is_kind(b) && jl_is_type_type(a) && jl_typeof(jl_tparam0(a)) == b)
-//         return 1;
-//     if (jl_is_typevar(b) && obviously_egal(a, ((jl_tvar_t*)b)->lb))
-//         return 1;
-//     return 0;
-// }
-
-static int simple_subtype2(jl_value_t *a, jl_value_t *b, int hasfree)
+static int simple_subtype2(jl_value_t *a, jl_value_t *b, int hasfree, int isUnion)
 {
     int subab = 0, subba = 0;
     if (jl_egal(a, b)) {
@@ -630,9 +653,9 @@ static int simple_subtype2(jl_value_t *a, jl_value_t *b, int hasfree)
     else if (b == jl_bottom_type || a == (jl_value_t*)jl_any_type) {
         subba = 1;
     }
-    else if (hasfree) {
-        // subab = simple_subtype(a, b);
-        // subba = simple_subtype(b, a);
+    else if (hasfree != 0) {
+        subab = simple_subtype(a, b, hasfree, isUnion);
+        subba = simple_subtype(b, a, hasfree, isUnion);
     }
     else if (jl_is_type_type(a) && jl_is_type_type(b) &&
              jl_typeof(jl_tparam0(a)) != jl_typeof(jl_tparam0(b))) {
@@ -664,10 +687,11 @@ jl_value_t *simple_union(jl_value_t *a, jl_value_t *b)
     // first remove cross-redundancy and check if `a >: b` or `a <: b`.
     for (i = 0; i < nta; i++) {
         if (temp[i] == NULL) continue;
-        int hasfree = jl_has_free_typevars(temp[i]);
+        int has_free = jl_has_free_typevars(temp[i]);
         for (j = nta; j < nt; j++) {
             if (temp[j] == NULL) continue;
-            int subs = simple_subtype2(temp[i], temp[j], hasfree || jl_has_free_typevars(temp[j]));
+            int has_free2 = has_free | (jl_has_free_typevars(temp[j]) << 1);
+            int subs = simple_subtype2(temp[i], temp[j], has_free2, 0);
             int subab = subs & 1, subba = subs >> 1;
             if (subab) {
                 temp[i] = NULL;
@@ -697,15 +721,9 @@ jl_value_t *simple_union(jl_value_t *a, jl_value_t *b)
         size_t jmax = i < nta ? nta : nt;
         for (j = jmin; j < jmax; j++) {
             if (j != i && temp[i] && temp[j]) {
-                if (temp[i] == jl_bottom_type ||
-                    temp[j] == (jl_value_t*)jl_any_type ||
-                    jl_egal(temp[i], temp[j]) ||
-                    (!has_free && !jl_has_free_typevars(temp[j]) &&
-                     // issue #24521: don't merge Type{T} where typeof(T) varies
-                     !(jl_is_type_type(temp[i]) && jl_is_type_type(temp[j]) && jl_typeof(jl_tparam0(temp[i])) != jl_typeof(jl_tparam0(temp[j]))) &&
-                     jl_subtype(temp[i], temp[j]))) {
+                int has_free2 = has_free | (jl_has_free_typevars(temp[j]) << 1);
+                if (simple_subtype(temp[i], temp[j], has_free2, 0))
                     temp[i] = NULL;
-                }
             }
         }
     }
@@ -769,7 +787,7 @@ jl_value_t *simple_intersect(jl_value_t *a, jl_value_t *b, int overesi)
         int hasfree = jl_has_free_typevars(temp[i]);
         for (j = nta; j < nt; j++) {
             if (temp[j] == NULL) continue;
-            int subs = simple_subtype2(temp[i], temp[j], hasfree || jl_has_free_typevars(temp[j]));
+            int subs = simple_subtype2(temp[i], temp[j], hasfree || jl_has_free_typevars(temp[j]), 0);
             int subab = subs & 1, subba = subs >> 1;
             if (subba && !subab) {
                 stemp[i] = -1;
diff --git a/src/julia.h b/src/julia.h
index 12c920cc6899d..3e794e85030fe 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1496,6 +1496,8 @@ static inline int jl_field_isconst(jl_datatype_t *st, int i) JL_NOTSAFEPOINT
 
 JL_DLLEXPORT int jl_subtype(jl_value_t *a, jl_value_t *b);
 
+int is_leaf_bound(jl_value_t *v) JL_NOTSAFEPOINT;
+
 STATIC_INLINE int jl_is_kind(jl_value_t *v) JL_NOTSAFEPOINT
 {
     return (v==(jl_value_t*)jl_uniontype_type || v==(jl_value_t*)jl_datatype_type ||
diff --git a/src/subtype.c b/src/subtype.c
index 50b62c9b6e3da..600df9da8757e 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -805,7 +805,7 @@ static int subtype_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int R, int pa
 // check that a type is concrete or quasi-concrete (Type{T}).
 // this is used to check concrete typevars:
 // issubtype is false if the lower bound of a concrete type var is not concrete.
-static int is_leaf_bound(jl_value_t *v) JL_NOTSAFEPOINT
+int is_leaf_bound(jl_value_t *v) JL_NOTSAFEPOINT
 {
     if (v == jl_bottom_type)
         return 1;
@@ -1997,7 +1997,7 @@ static int obvious_subtype(jl_value_t *x, jl_value_t *y, jl_value_t *y0, int *su
                     if (var_occurs_invariant(body, (jl_tvar_t*)b))
                         return 0;
                 }
-                if (nparams_expanded_x > npy && jl_is_typevar(b) && concrete_min(a1) > 1) {
+                if (nparams_expanded_x > npy && jl_is_typevar(b) && is_leaf_typevar((jl_tvar_t *)b) && concrete_min(a1) > 1) {
                     // diagonal rule for 2 or more elements: they must all be concrete on the LHS
                     *subtype = 0;
                     return 1;
@@ -2008,7 +2008,7 @@ static int obvious_subtype(jl_value_t *x, jl_value_t *y, jl_value_t *y0, int *su
                 }
                 for (; i < nparams_expanded_x; i++) {
                     jl_value_t *a = (vx != JL_VARARG_NONE && i >= npx - 1) ? vxt : jl_tparam(x, i);
-                    if (i > npy && jl_is_typevar(b)) { // i == npy implies a == a1
+                    if (i > npy && jl_is_typevar(b) && is_leaf_typevar((jl_tvar_t *)b)) { // i == npy implies a == a1
                         // diagonal rule: all the later parameters are also constrained to be type-equal to the first
                         jl_value_t *a2 = a;
                         jl_value_t *au = jl_unwrap_unionall(a);
diff --git a/test/core.jl b/test/core.jl
index 67e0102bc164a..050127a5621c5 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -239,8 +239,8 @@ k11840(::Type{Union{Tuple{Int32}, Tuple{Int64}}}) = '2'
 # issue #20511
 f20511(x::DataType) = 0
 f20511(x) = 1
-Type{Integer}  # cache this
-@test f20511(Union{Integer,T} where T <: Unsigned) == 1
+Type{AbstractSet}  # cache this
+@test f20511(Union{AbstractSet,Set{T}} where T) == 1
 
 # join
 @test typejoin(Int8,Int16) === Signed
@@ -8101,3 +8101,14 @@ end
 
 # #52433
 @test_throws ErrorException Core.Intrinsics.pointerref(Ptr{Vector{Int64}}(C_NULL), 1, 0)
+
+# #53034 (Union normalization for typevar elimination)
+@test Tuple{Int,Any} <: Tuple{Union{Int,T},T} where {T>:Int}
+@test Tuple{Int,Any} <: Tuple{Union{Int,T},T} where {T>:Integer}
+# #53034 (Union normalization for Type elimination)
+@test Int isa Type{Union{Int,T2} where {T2<:T1}} where {T1}
+@test Int isa Type{Union{Int,T1}} where {T1}
+@test Int isa Union{UnionAll, Type{Union{Int,T2} where {T2<:T1}}} where {T1}
+@test Int isa Union{Union, Type{Union{Int,T1}}} where {T1}
+@test_broken Int isa Union{UnionAll, Type{Union{Int,T2} where {T2<:T1}} where {T1}}
+@test_broken Int isa Union{Union, Type{Union{Int,T1}} where {T1}}
diff --git a/test/subtype.jl b/test/subtype.jl
index edc38c8556f3c..c8197dbddbf6d 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -146,6 +146,14 @@ function test_diagonal()
     @test  isequal_type(Ref{Tuple{T, T} where Int<:T<:Int},
                         Ref{Tuple{S, S}} where Int<:S<:Int)
 
+    # issue #53021
+    @test Tuple{X, X} where {X<:Union{}} <: Tuple{X, X, Vararg{Any}} where {Int<:X<:Int}
+    @test Tuple{Integer, X, Vararg{X}} where {X<:Int} <: Tuple{Any, Vararg{X}} where {X>:Int}
+    @test Tuple{Any, X, Vararg{X}} where {X<:Int} <: Tuple{Vararg{X}} where X>:Integer
+    @test Tuple{Integer, Integer, Any, Vararg{Any}} <: Tuple{Vararg{X}} where X>:Integer
+    # issue #53019
+    @test Tuple{T,T} where {T<:Int} <: Tuple{T,T} where {T>:Int}
+
     let A = Tuple{Int,Int8,Vector{Integer}},
         B = Tuple{T,T,Vector{T}} where T>:Integer,
         C = Tuple{T,T,Vector{Union{Integer,T}}} where T
@@ -1260,14 +1268,7 @@ let a = Tuple{Tuple{T2,4},T6} where T2 where T6,
 end
 let a = Tuple{T3,Int64,Tuple{T3}} where T3,
     b = Tuple{S3,S3,S4} where S4 where S3
-    I1 = typeintersect(a, b)
-    I2 = typeintersect(b, a)
-    @test I1 <: I2
-    @test I2 <: I1
-    @test_broken I1 <: a
-    @test I2 <: a
-    @test I1 <: b
-    @test I2 <: b
+    @testintersect(a, b, Tuple{Int64, Int64, Tuple{Int64}})
 end
 let a = Tuple{T1,Val{T2},T2} where T2 where T1,
     b = Tuple{Float64,S1,S2} where S2 where S1
@@ -2445,7 +2446,7 @@ abstract type P47654{A} end
     @test_broken typeintersect(Type{Tuple{Array{T,1} where T}}, UnionAll) != Union{}
 
     #issue 33137
-    @test_broken (Tuple{Q,Int} where Q<:Int) <: Tuple{T,T} where T
+    @test (Tuple{Q,Int} where Q<:Int) <: Tuple{T,T} where T
 
     # issue 24333
     @test (Type{Union{Ref,Cvoid}} <: Type{Union{T,Cvoid}} where T)

From 5d4d6ab498ab7a612ccbd908ab0fff2b686570ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Fri, 26 Jan 2024 10:17:58 +0000
Subject: [PATCH 0717/1315] [OpenBLAS_jll] Update to new build with BFloat16
 kernels (#53059)

This also

* drops a patch (`deps/patches/neoverse-generic-kernels.patch`) not
needed anymore for an [old
bug](https://github.com/OpenMathLib/OpenBLAS/issues/2998) fixed upstream
in OpenBLAS. This results in ~5x speedup in the computation of
`BLAS.nrm2` (and hence `LinearAlgebra.norm` for vectors longer than
`LinearAlgebra.NRM2_CUTOFF` (== 32) elements) when the neoversen1
kernels are used, e.g. by default on all Apple Silicon CPUs
* adds a regression test for the above bug
* updates other patches when building openblas from source

Corresponding PR in Yggdrasil:
https://github.com/JuliaPackaging/Yggdrasil/pull/7202.
---
 deps/checksums/openblas                       | 184 +++++++++---------
 deps/openblas.mk                              |  19 +-
 deps/patches/neoverse-generic-kernels.patch   |  19 --
 deps/patches/openblas-avx512bf-kernels.patch  | 107 ++++++++++
 deps/patches/openblas-darwin-sve.patch        |  34 ++++
 .../openblas-gemv-multithreading.patch        |  22 +++
 deps/patches/openblas-ofast-power.patch       |  28 ++-
 stdlib/LinearAlgebra/test/blas.jl             |   9 +
 stdlib/OpenBLAS_jll/Project.toml              |   2 +-
 9 files changed, 301 insertions(+), 123 deletions(-)
 delete mode 100644 deps/patches/neoverse-generic-kernels.patch
 create mode 100644 deps/patches/openblas-avx512bf-kernels.patch
 create mode 100644 deps/patches/openblas-darwin-sve.patch
 create mode 100644 deps/patches/openblas-gemv-multithreading.patch

diff --git a/deps/checksums/openblas b/deps/checksums/openblas
index d4671bff2c6f2..34eca34c4ec2c 100644
--- a/deps/checksums/openblas
+++ b/deps/checksums/openblas
@@ -1,94 +1,94 @@
-OpenBLAS.v0.3.26+1.aarch64-apple-darwin-libgfortran5.tar.gz/md5/547a98e1757f61f572a414becc563466
-OpenBLAS.v0.3.26+1.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/7645415bfb9b7bc21f3008aea2a508d727c81dbcf016eea4a86dbdd7cf20af66739fc059b1de10bbfc6d08d1de56ca4e36f1aaa765ab4ee8a30bccfd1824c5bd
-OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran3.tar.gz/md5/e809969126585f1c1ba64d13d881bb42
-OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/d8d32f1ca319c51a5c34984785790ea1dce1b87913ae7546341e31be49a4c682fddca4e075a3f66875a239952611675872e57a5ca1ca1c5e01320cc176d83ab4
-OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran4.tar.gz/md5/b464e001789eb4fa2d4e380c0eea3917
-OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/b9b0eb0a58f2684deb2769513c9536091f53eebb7c9b9c9248a84e39c1b9b5d314c08bb95a490e66e94b3848ea29d989ec943b07535be4ad48692006ca688d9c
-OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran5.tar.gz/md5/650898300d9ead8e3baf3a6b66a931b8
-OpenBLAS.v0.3.26+1.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/033a558868fb20872c37257a4b440a121136e3c22d8df9cbed19b66ef859948215f0edd3cba8767bc66869102ff9fd6f6661e7b3a307819cf8e89077052b5451
-OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran3.tar.gz/md5/d5b139d340e28436cb446a6157f64419
-OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran3.tar.gz/sha512/1e4bc19174c8481889eb3cca6380a11ee6013066198e268bc718440b3f5b017915a3f446a1d75c53c4230bace1569ba54e14366b6af47da9bf49e52f6efb631a
-OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran4.tar.gz/md5/d106ae8404d19375caa0cf153f5c58e1
-OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran4.tar.gz/sha512/e06c765c2da299cbabd558546bd9d4e5f83b567c455ec59d59a3c53c7e36fca1ac51bbb87c59267e31c7b3028c406e1266c0f081232d04bb1b71aa7eba80cd31
-OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran5.tar.gz/md5/35348019d6532f9632ec5f42c9e63fbe
-OpenBLAS.v0.3.26+1.aarch64-linux-musl-libgfortran5.tar.gz/sha512/3bcbd0a5ee955ce8617f00de6440675cf3bc89adca6d7eaed46f9087c9a77f701737bc019993a488eef0cec7712323287c418a632fee66e38e756d5b550cf3a0
-OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/df45b3895e2effb12aeab4517721571e
-OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/e5be7b0e7f2733aa462c36057fcf728f8c87150a6ef856e2039e6a0811a6806ff3ee196febdb3173243b6be9a6da9c6d3a4c55592f19c9aa08dba94715bc3d4b
-OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/b10b159a1e41843bc6de576f42bfcf47
-OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0e831086f4a80d52f3ade88ab9760a4edf3c636e5ca729347f0a173c1f671c6c2cfc732d68e26fa21556257936b9827a7a4230aa222a825a354a2ad1d60e20b5
-OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/2aa72a7dfcc19d414a6f8f81de482e69
-OpenBLAS.v0.3.26+1.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/d31d2e3129b173b844917006a2fcdd9c08ecb5cba62c431c30651e4088dd2d25cf00ee5fb0f6b403c6ff599ddff59e895bf0669f124839f753b213e2bae4579a
-OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/ea1476eb36613ec5885cc969f2d8face
-OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/10be657bd3f6d579b1b6eb979e42d871d77211bdd2338a8d9de9a2a54f5c6bde45d6a2fbeff1c7a1d965d8553cb248087d93b3745fb0af1fda5af2a8a2d65074
-OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/68017857ebd4fab5564763451b693dcf
-OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/9907e1a60f73b7184c2917713a286660fc9b500122cc546ad3849e65de7f36106d51d0fabb00f7168ff6f63bb7fdfc9898a155c017a37ec0e8faf7aeeef05108
-OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/f531cec3c06a0513d68571b118dc20b6
-OpenBLAS.v0.3.26+1.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/41ae9860625323686adf0b2d0cb4a9df59d99a8df2fe0f4a01a0b9ce0aea06017d9132191d883eba62893e43189667a7dc13caf89dced5666ce5d4346be656ce
-OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/df45b3895e2effb12aeab4517721571e
-OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/e5be7b0e7f2733aa462c36057fcf728f8c87150a6ef856e2039e6a0811a6806ff3ee196febdb3173243b6be9a6da9c6d3a4c55592f19c9aa08dba94715bc3d4b
-OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/b10b159a1e41843bc6de576f42bfcf47
-OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0e831086f4a80d52f3ade88ab9760a4edf3c636e5ca729347f0a173c1f671c6c2cfc732d68e26fa21556257936b9827a7a4230aa222a825a354a2ad1d60e20b5
-OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/2aa72a7dfcc19d414a6f8f81de482e69
-OpenBLAS.v0.3.26+1.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/d31d2e3129b173b844917006a2fcdd9c08ecb5cba62c431c30651e4088dd2d25cf00ee5fb0f6b403c6ff599ddff59e895bf0669f124839f753b213e2bae4579a
-OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/ea1476eb36613ec5885cc969f2d8face
-OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/10be657bd3f6d579b1b6eb979e42d871d77211bdd2338a8d9de9a2a54f5c6bde45d6a2fbeff1c7a1d965d8553cb248087d93b3745fb0af1fda5af2a8a2d65074
-OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/68017857ebd4fab5564763451b693dcf
-OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/9907e1a60f73b7184c2917713a286660fc9b500122cc546ad3849e65de7f36106d51d0fabb00f7168ff6f63bb7fdfc9898a155c017a37ec0e8faf7aeeef05108
-OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/f531cec3c06a0513d68571b118dc20b6
-OpenBLAS.v0.3.26+1.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/41ae9860625323686adf0b2d0cb4a9df59d99a8df2fe0f4a01a0b9ce0aea06017d9132191d883eba62893e43189667a7dc13caf89dced5666ce5d4346be656ce
-OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran3.tar.gz/md5/686269fba3e296013ccb33d4befff265
-OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran3.tar.gz/sha512/b1894c97de594def1f0b37d4d702d56d9ddd6a2897a29bb33b1579c222a7d89409658efcc07c8aa9673ca95821e5ed1b97dd41d8bcf3b2edee065ea92761218f
-OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran4.tar.gz/md5/c36ad067917ac7a6e7d1399cb6f58525
-OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran4.tar.gz/sha512/782b8cbb7b7655b1cf22e6a9bd10aec38f6624525076c74b66804796b3879fd722182705ca6043e16b13fd2a9bef1a2354dfbc8ef12db65dc94aa6864733dce1
-OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran5.tar.gz/md5/814c2bcb8e25eda7559849867aec9c80
-OpenBLAS.v0.3.26+1.i686-linux-gnu-libgfortran5.tar.gz/sha512/a9407e78f37953558ea48b4c395bcd1382b9c869043fd445a38a1f1db13551a0fe99dec5d503701ef86ac75e1f1ef46e2cd8912486cdf382ebe38efd9996baa1
-OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran3.tar.gz/md5/d795cd8b35e6d40975db704af83b4720
-OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran3.tar.gz/sha512/8fae3a4501b0ef0203c9b79c2b98b5372393d88e647fc7516532fa425998e6117e7d011ac3c28d41f0c52c9dcc06c2d2817490a275863d920fcab87f48c5886e
-OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran4.tar.gz/md5/7491d844661f1c54f0a57adab6f2bb5b
-OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran4.tar.gz/sha512/d541151270fc5c2d9562a366c48c0aa8b7383f00714fe5ea9cb94f321e13b988e4a5f9ef3e37b0ae924dd0a1049cca5c0ec16f7207b54074ee33e99991fcb35d
-OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran5.tar.gz/md5/d780f3734c2503931354b5bb385156b6
-OpenBLAS.v0.3.26+1.i686-linux-musl-libgfortran5.tar.gz/sha512/44f5c4a9c6f7b7b13761d0ba997c3c5582b17ec6455c7dc06f3984533e99f2b66f26371747648f3997b200f917fa413e8b07634da1c7cb4736f653cb38170aee
-OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran3.tar.gz/md5/c8bda88720dfe9415a93ee639ab8061e
-OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran3.tar.gz/sha512/2b9396f92c0883811c5dcf13ac10781ba0a46ce7bb6c839ec83e9e7bc75b9d805d8cb6d74e52502bf9210a02bc066cd1a11235bc754b62e103e9d9912b8dc39d
-OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran4.tar.gz/md5/d92cea9c2931480cd80f2e6845ef0fa2
-OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran4.tar.gz/sha512/8870c89a3f43efd3c681b36e8bf6ec8876e30c29256c6c5ab2021ea4318d898fa2a231dae285f60760d7559e6bb730814e3e9ed88f1509afa5d1d9c0e7c78a05
-OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran5.tar.gz/md5/ddecd7f5bf7b621e76bbd7f10d860f9d
-OpenBLAS.v0.3.26+1.i686-w64-mingw32-libgfortran5.tar.gz/sha512/8755d2931d8c8ec48fd52050071edaed8d5f401110a9ccef4019ba4c25434a55c443e8d35e8e84cb6bb109161a5a40861970c99c2452bc2a1c51f5937c7f68ea
-OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/6da004043ff90a8497765210f5edac2a
-OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/bac7e378474769c7f2b4c8acbb960b29ee47f9f49aec95239543451583e83420990a4eb03dd994ebec7f60e95f6cc95668977cf4ad9414ecfedb93fe2d85e338
-OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/3bb442a6331324913d13bda804dabafb
-OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/5a865ea29ae2647e2639b614a5373a5675542cdcab380405f800dca1987b5628a302841e7546f89ad64a8cb87371c2e82dee603a8f732b6bc17e1f0635eda5f1
-OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/a27d102271dd18fdcc3f8fcc722285d6
-OpenBLAS.v0.3.26+1.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/37f92d7e6549bbfd7c67287d28dc366f2943f8063629e1e09afd1e4e82191bee4aa0201add0c99d9945304eedaacfad6b88d1fc8c6b00c05f73de78ca70c3e40
-OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran3.tar.gz/md5/aada145cdbd5990a5191b5161e8caa57
-OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/e4146f26459d9264c45dd0ca0394ab264ec0154709aabe5cb4d821c341ed937a467ba7e0a82e4bfc0f5b9142921f21d2a732914d8aa94eece67cf29e8e0f3618
-OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran4.tar.gz/md5/79d25889603731cd9b67bd90171f6785
-OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/ffbafdded8420891e403c42922c5189981b42cf9a1b0a229d7caf75b23afcb1bf0bad07bdeeb40f47db3f0226dc15cfb5e35dc1d7350d65bbfce8895dd1703ab
-OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran5.tar.gz/md5/4eb2c9142dcaf9482066d659d8f01420
-OpenBLAS.v0.3.26+1.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/4ab556be0a45c177770085d79a09b2374eb88d447bc4fe73e3ee9ab298b1ff62b7442576439dbe5c05ee18121e971b26e58c2cdc6470136c320b59c0d6db5c9e
-OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran3.tar.gz/md5/f470ceb90d452684f1f8bab0430255f3
-OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/5b7a8f70173cf593d8340fa4dfe25d885b71ee28491cd88d29ae0d3e161ee97828e7373fdeb0fc4f3843b6d4b7ed1dd5f818cf4fbd85f1b965ade69496c0b032
-OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran4.tar.gz/md5/21937c57336aeee6d1281838091f2ded
-OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/31ea2e95ea67bd068fbc5dec70ed37cbf675a38465612928da63ec727358eba140c407a4d24781eddb61e2a78c21aa5fcbd509e53d2f79133f20348f12a26c3b
-OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran5.tar.gz/md5/12bea9681837bd876dca337d5dff0310
-OpenBLAS.v0.3.26+1.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/fe60a87f77b94fa0601ce626ad564b3185b818f0cf0e1ffe71ed7ac9e3ed381f785e0e40ade48137a3982f26a25937a0281d8af0ee90525d8b83aa0c7d6c246b
-OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran3.tar.gz/md5/a027d4b3cdf3d1696ff9fbcee92cd11c
-OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran3.tar.gz/sha512/2114cab81354e4ce1b7952da4c949d7bb936e6c03f7c74db64c19de564417c1ede8aa7392454d22a80846b624d98278c96c3892a7eade1dc7d2d6492cf995993
-OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran4.tar.gz/md5/24c27c66ba984ce08e29c8db8e4f0623
-OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran4.tar.gz/sha512/9c64e74d4b2cecb67cb919a801572bda4709c7a7cff016637256689f3e25e15964c681e44df70e7e843dd51cc21c1418c63620c292ba85b2fefc996f2edf6ee2
-OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran5.tar.gz/md5/0815934674727f808723ca59c2c4def1
-OpenBLAS.v0.3.26+1.x86_64-linux-musl-libgfortran5.tar.gz/sha512/15036bfd5ca5d8770a7fdce63790756475d1f94ad301b4985b38445d9660bb0591fc4bd96280e07cbf9da52d0be1fda97a3629e0956bee84e501f19ca85472ac
-OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/246fa31cdf14e93eb04c9fc4c96845a1
-OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/a1eff9bc326976fec67461e5391342fee74ef91c2d3d3b7bde387daf76f2c721d522fd3e78094218c5bfcfd02d1c96288d14c83668acccd92144960e4aea67d2
-OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/06b953ed17b40e8713cc5b3d6e1e825c
-OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/185705657be22c6681133d7fe05d9e890e87b1637d0194c7b39a2194cadbf3a55aa2e252696355fc399db4477e1aeff32062a0fcf2b45925e6f9c64d8f12ce4e
-OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/9e2362434fdc10a570f231c65d31c936
-OpenBLAS.v0.3.26+1.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/c2913cdab07096d1c6e1beaca7dedbfccc9ca91f0f32f76d476b37684fc0dcd55e4ace96cba668106564011c15f29f6703fdf76d0a7b1c757f1eaa3289891039
-OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/9be5f51d9676a008483437079797f4c7
-OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/ac9c93541b246563994725573ebdc816b9341389b6f101160575ae25c3e01d3289146d86b54bcaf19f15b035afaf0346c50419601fd7f64a4cafe7754dda5afe
-OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/cbb1711388ee92693459e9de5275510f
-OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/4c0344c43a41f4042787999a1b9b1c8d897dfa42b1af2aaf2f58284efe835cc273cc99703d87212f1433b19764ace01955b89ee1c4e2c928a6025cb1d17b6464
-OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/d4a7332e9a7a490a8da7fcbaeb290043
-OpenBLAS.v0.3.26+1.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/ebe4f1d619925638a5628a0ab47ebf219a7f7302cb52f409912a3aa4f614097a5595cc97060b1417aaa059d817d6a3607f8a0a563466ac6d9f82770a9ff1d87b
+OpenBLAS.v0.3.26+2.aarch64-apple-darwin-libgfortran5.tar.gz/md5/62b6e0f8591668113a4985d88f386a16
+OpenBLAS.v0.3.26+2.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/fa5a15d853701818604c48bd152b599438eeeb1da67db552beb21b284027c313a9c7d8779b7236831a5f2631912baf881b0d2165aa77cb7ffec975a5c113a631
+OpenBLAS.v0.3.26+2.aarch64-linux-gnu-libgfortran3.tar.gz/md5/bc83bc702eb292c4491229cd6142fe06
+OpenBLAS.v0.3.26+2.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/d4e872be87cc450e1547e51ba15540f5f0082a874788c6ba414cab839147e69f7f37b2c4080a79bdcd411efec829e3510b83df8a9c319a3b132a117614d205cc
+OpenBLAS.v0.3.26+2.aarch64-linux-gnu-libgfortran4.tar.gz/md5/436ae51ef0b2f7a053ed8fb19fd55fd1
+OpenBLAS.v0.3.26+2.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/686c9c04a11d2f8a4879876ae34c410ad9e5cb0fddecd44aea9d642e662af9766a07bf4846405685835968253f2cda004a7d7ca1a0a04b2799984489294ed4c5
+OpenBLAS.v0.3.26+2.aarch64-linux-gnu-libgfortran5.tar.gz/md5/fa57f3598b2c24ec3111c60f84bb6ed9
+OpenBLAS.v0.3.26+2.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/d6111ab03a8940892e8023af548de52da7b8c3c76ad2cfcf98a78cadf11b95ef4c39830dedc5a3c6a20e8d95c64fb24a4ed655971ea83ba11f69ff7a3ba34292
+OpenBLAS.v0.3.26+2.aarch64-linux-musl-libgfortran3.tar.gz/md5/184444acaf2f975b4bf5168a32577863
+OpenBLAS.v0.3.26+2.aarch64-linux-musl-libgfortran3.tar.gz/sha512/419da1e017208596e89482ac42005ed2adebfc917419cf900fad3b45ec40f7da46acffc3e6461f46862e3c4642588cd629f6dde151fd02edd6642c8d98d77ea6
+OpenBLAS.v0.3.26+2.aarch64-linux-musl-libgfortran4.tar.gz/md5/2aef4330a9995541bae287a3c2583ea6
+OpenBLAS.v0.3.26+2.aarch64-linux-musl-libgfortran4.tar.gz/sha512/caf7ae4ec0c4fddfe522409d1a5c3be5a376620baa9ddce63f62e4856cea4b1ab2818ef54f3fb5ffbcc4ae73247459d0de2ac7b93eba4bcc1ca744f4fe69695e
+OpenBLAS.v0.3.26+2.aarch64-linux-musl-libgfortran5.tar.gz/md5/308471abda2c5eba60976d227f6d1c1e
+OpenBLAS.v0.3.26+2.aarch64-linux-musl-libgfortran5.tar.gz/sha512/225242f309d343994176664f590471ec2e56254ebec877d97291c1334517993510422954774749d23da4c52f32a41e06aaba072bf2e3cbb3b2a8dac6c01dba8c
+OpenBLAS.v0.3.26+2.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/69618373222d15ede34de1f913a93dac
+OpenBLAS.v0.3.26+2.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/585fa3233d6c88c7ee5571da4dce7b83c53643937a0077d816c24c556b471926c808bcbd46c9ddddafbe24567f91039525b3a260505854e62e9b9b09acaede54
+OpenBLAS.v0.3.26+2.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/874b639fcce8fb077d1a9cdecc916a6c
+OpenBLAS.v0.3.26+2.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0a065ccd197822b028da36e157aed19fbe440d7eedc94fe1955cd8980423d477bdb73db7e0f99a6ea683701a2c8fc649e3967a781694a7219d82915d1c22767c
+OpenBLAS.v0.3.26+2.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/03683c3d2310870905bc386c5fc89eb5
+OpenBLAS.v0.3.26+2.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/2e0f4ae61623cf094cb8396522dfb6e2a7cf7de23a4dd25fb3fb2f0a414fd0b8d6397ce1c74d3a88296fe4fe76d1a61e1df87b2814bf87852564c097aa1f45e2
+OpenBLAS.v0.3.26+2.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/9c9dbe9afb8fc5d1f2fae971e1dfce1d
+OpenBLAS.v0.3.26+2.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/e592f91a2c0a303a059a9694565555247b76ab20ecfcf9c9f7235e0b67b458d530b35e9a2263f3c37b7ecc884c02124fac134f6061788348475fe1d546e07f1e
+OpenBLAS.v0.3.26+2.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/ede329cb3e37e7c9008fec5273e38ce2
+OpenBLAS.v0.3.26+2.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/bbb081f217c977e77d77c2091918aeff99855dbe99f4396059954e057edf41c63e926769afc3a2360eb87cef5612a2c0de519852182dba51d9306be10c4508fe
+OpenBLAS.v0.3.26+2.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/c884cc9c752857a6a020891040c1bbd4
+OpenBLAS.v0.3.26+2.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/67e671c05964b2a1456b9bddfe300cf29f88f4712cbe0c11cae01955abb31e70d9ad9a31175d2e29e4c5dd02d22febcafac8abe47d78dc179aa1e40776c51883
+OpenBLAS.v0.3.26+2.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/69618373222d15ede34de1f913a93dac
+OpenBLAS.v0.3.26+2.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/585fa3233d6c88c7ee5571da4dce7b83c53643937a0077d816c24c556b471926c808bcbd46c9ddddafbe24567f91039525b3a260505854e62e9b9b09acaede54
+OpenBLAS.v0.3.26+2.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/874b639fcce8fb077d1a9cdecc916a6c
+OpenBLAS.v0.3.26+2.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/0a065ccd197822b028da36e157aed19fbe440d7eedc94fe1955cd8980423d477bdb73db7e0f99a6ea683701a2c8fc649e3967a781694a7219d82915d1c22767c
+OpenBLAS.v0.3.26+2.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/03683c3d2310870905bc386c5fc89eb5
+OpenBLAS.v0.3.26+2.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/2e0f4ae61623cf094cb8396522dfb6e2a7cf7de23a4dd25fb3fb2f0a414fd0b8d6397ce1c74d3a88296fe4fe76d1a61e1df87b2814bf87852564c097aa1f45e2
+OpenBLAS.v0.3.26+2.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/9c9dbe9afb8fc5d1f2fae971e1dfce1d
+OpenBLAS.v0.3.26+2.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/e592f91a2c0a303a059a9694565555247b76ab20ecfcf9c9f7235e0b67b458d530b35e9a2263f3c37b7ecc884c02124fac134f6061788348475fe1d546e07f1e
+OpenBLAS.v0.3.26+2.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/ede329cb3e37e7c9008fec5273e38ce2
+OpenBLAS.v0.3.26+2.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/bbb081f217c977e77d77c2091918aeff99855dbe99f4396059954e057edf41c63e926769afc3a2360eb87cef5612a2c0de519852182dba51d9306be10c4508fe
+OpenBLAS.v0.3.26+2.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/c884cc9c752857a6a020891040c1bbd4
+OpenBLAS.v0.3.26+2.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/67e671c05964b2a1456b9bddfe300cf29f88f4712cbe0c11cae01955abb31e70d9ad9a31175d2e29e4c5dd02d22febcafac8abe47d78dc179aa1e40776c51883
+OpenBLAS.v0.3.26+2.i686-linux-gnu-libgfortran3.tar.gz/md5/030e3714c2544175861a411fc2520dc2
+OpenBLAS.v0.3.26+2.i686-linux-gnu-libgfortran3.tar.gz/sha512/5ea2318d786b423770e77cd820fef4bd995da7f6aaea70f73f55eb9210508e89f61fb0c6a728421c6fd3859ab11774f3111979c53a6c48ddf7a528a04295c4ba
+OpenBLAS.v0.3.26+2.i686-linux-gnu-libgfortran4.tar.gz/md5/ef935e9cf567efa381de917a0cf66fbc
+OpenBLAS.v0.3.26+2.i686-linux-gnu-libgfortran4.tar.gz/sha512/81a463ca756d4d363fd32f735d32d7b6e8c6f325401e943a8210fcf258ecd25507beac17b9b24ecddef0eb8521a58fdfcf6633794724f86e6977b162e099c70e
+OpenBLAS.v0.3.26+2.i686-linux-gnu-libgfortran5.tar.gz/md5/ce1a4b1dc5e3c001b5c12f9cd81cb3fb
+OpenBLAS.v0.3.26+2.i686-linux-gnu-libgfortran5.tar.gz/sha512/8f82012c0e9f955be2ab87551742a334f865cbdec95f0a62103c5127d6176838653884a6790234c5548940cec63e73ce95095bfcfaf241dc445020ab449c6687
+OpenBLAS.v0.3.26+2.i686-linux-musl-libgfortran3.tar.gz/md5/acfe348c1c1f33376469dd9106603222
+OpenBLAS.v0.3.26+2.i686-linux-musl-libgfortran3.tar.gz/sha512/2048723ce88ef28b2b7fa42cc73eccae8b663466a496709931ccecf06b4f4a9455fdfa3b5bd05bba4d847d3c0489251ecc3a34e7e3fb49bcdb40aacd4b53c140
+OpenBLAS.v0.3.26+2.i686-linux-musl-libgfortran4.tar.gz/md5/d82eb058ea705286058230f68b43c9fe
+OpenBLAS.v0.3.26+2.i686-linux-musl-libgfortran4.tar.gz/sha512/c97ca8dd352c3067ec437b1a8b2b9ee06bd92157f0806dca55fcc3107a94e784cdf8f6d5986aae93ccb608fb90ba2ab9bba4acf7562c1fd519804897ab158c10
+OpenBLAS.v0.3.26+2.i686-linux-musl-libgfortran5.tar.gz/md5/014aa93d275d56e6176ab50f4040ede2
+OpenBLAS.v0.3.26+2.i686-linux-musl-libgfortran5.tar.gz/sha512/cd3d1dd1aab373fe4e1135042dee3fc959371fcbebe70f6c60327df35e389442a2f47351757db84cdc1d181b659ce2d6a0892508de6af27b01324e3119d9dabb
+OpenBLAS.v0.3.26+2.i686-w64-mingw32-libgfortran3.tar.gz/md5/0b3f11710883a3cac2551cac0d72aad5
+OpenBLAS.v0.3.26+2.i686-w64-mingw32-libgfortran3.tar.gz/sha512/7d86f74c585dff33ed9384dc1c77b600a6893ceca335340232536f6e2cec1bbc86e85763c932c4b81c4012f12d68d7f37634e2f685aff6a999b875eae596cd9c
+OpenBLAS.v0.3.26+2.i686-w64-mingw32-libgfortran4.tar.gz/md5/64d7806e859c804161a59641db744f7f
+OpenBLAS.v0.3.26+2.i686-w64-mingw32-libgfortran4.tar.gz/sha512/7ebefd3ee2abd284c82e15d2497fd08bd4eccb264af7aacc1378c75d4b1dffb11ab95eafd98029c513ee7c667749a4917e26e4d57c65ccb77c5ba52cd8770009
+OpenBLAS.v0.3.26+2.i686-w64-mingw32-libgfortran5.tar.gz/md5/2a91e979a37722549d95cbd607e822fa
+OpenBLAS.v0.3.26+2.i686-w64-mingw32-libgfortran5.tar.gz/sha512/f08880e18e6a361458a495c8860382a00001fe5d2989852b034ff9623b4517c8b75cd3f03986f62d72222e3cf07f8f2eb123785577500c7cf0e79109b9eed960
+OpenBLAS.v0.3.26+2.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/a417db847b1d610e3f52a891f98ae2e0
+OpenBLAS.v0.3.26+2.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/16da5454b0987ecae76b6fe547d28f699684aa5fbf05a0e579960b71b3ab75dc1f3602fc60182fea3556eda8d905a870f03dd976009ea1972e9693a584e584f3
+OpenBLAS.v0.3.26+2.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/c63388278f7e037c232d9e7b29d3c725
+OpenBLAS.v0.3.26+2.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/bedbb30539530e16314c97b87df59caf38c75de7b68616cdca78d27e241dce06527d7265924902d557394a14a6348dc2b5e45c4a006158a6b9182382183bd0ff
+OpenBLAS.v0.3.26+2.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/5785f320f43600a791b543fb0bd8b00b
+OpenBLAS.v0.3.26+2.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/37ae82c2f57ec7c6ce0cd3f93b33870602f44bffdbeb2cb9bceef4515f5851aba73214d4a1fd24606fe4fa9bf0bf0a5552e1aebd65027ae57f76f3379a04344e
+OpenBLAS.v0.3.26+2.x86_64-apple-darwin-libgfortran3.tar.gz/md5/ebd368ef0d4fd4f39534bb52b506e109
+OpenBLAS.v0.3.26+2.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/a81bf2244b160786530ae449be1e81981d17146ccf833ea5afcea84eb24644002d5824591c96b7e89fe9642911a865a292be062d325ff2307d850b4cfbd0e7d6
+OpenBLAS.v0.3.26+2.x86_64-apple-darwin-libgfortran4.tar.gz/md5/f453ba9786d0916c9fc8c46281588c5d
+OpenBLAS.v0.3.26+2.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/7dea0549e3fec7e18043b8b4f93491ddbb4e041325330a2e6e28d137c25431c12371b534bae5170b22c5077d285ee23fda1579bae54c894a46a885b4571daf84
+OpenBLAS.v0.3.26+2.x86_64-apple-darwin-libgfortran5.tar.gz/md5/3be8449cb3046322f21b1d17be41bd1f
+OpenBLAS.v0.3.26+2.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/89bb94d645879bd2daa8e83fc9b391b84f32b8bc1f633caacc5eda138c8034b726bc5c7ddb931040f24b77482743cd2038fed6d1d17698f287c09f176a6085c8
+OpenBLAS.v0.3.26+2.x86_64-linux-gnu-libgfortran3.tar.gz/md5/2410734a7fc47705361267023c001272
+OpenBLAS.v0.3.26+2.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/e9b239a75ee7521145f30caa52ec4e8b42d99f5246df47c8e203497c577f161ec4f3e7df7d7fa8135b4f947f941314bbbb00fa56ed813bbbefd6f887af1a768b
+OpenBLAS.v0.3.26+2.x86_64-linux-gnu-libgfortran4.tar.gz/md5/06212c9081e7d355bce7e7960e17371d
+OpenBLAS.v0.3.26+2.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/aeb9913167f6e860c4f2082dc15310fa4fb2a0edcf70a6aa31626c59e132d2af9265544f1b18161d994405649f2923abd4cb21521466768f1ed4fe0ef8243bcd
+OpenBLAS.v0.3.26+2.x86_64-linux-gnu-libgfortran5.tar.gz/md5/e21eb44972f00ff7c054e3fade50602d
+OpenBLAS.v0.3.26+2.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/8d9c1bb8c300e2523fd7a42ef4d4bcfbaba94e29e69c630008a194a62e575648c9f89a42301d1cbd0e74613ba41e5282d69bd8e24376c64fedb1d2657dd1e4a4
+OpenBLAS.v0.3.26+2.x86_64-linux-musl-libgfortran3.tar.gz/md5/aa1501555419f9bc6c243e77d1a413c8
+OpenBLAS.v0.3.26+2.x86_64-linux-musl-libgfortran3.tar.gz/sha512/8a4c5166e76c14bf6c65953bdcb8a4b222dee61123cfdb243876ee5af2d5d04e3125149936ce71c25cd90b0af5208d733ed9a1944b3134634de6a2ddfd1796a8
+OpenBLAS.v0.3.26+2.x86_64-linux-musl-libgfortran4.tar.gz/md5/597ff5c5a516278129a3077daeb4ffd0
+OpenBLAS.v0.3.26+2.x86_64-linux-musl-libgfortran4.tar.gz/sha512/0b4b3e58d046e7a5f3eac36e967025983575df1979c5bdc73330481982e229f832735d1a7bce373009e666b9094ba5877d290bd06d9baf5f8a9efef0d3b0b4ac
+OpenBLAS.v0.3.26+2.x86_64-linux-musl-libgfortran5.tar.gz/md5/410507ba0176c16180163556294d359e
+OpenBLAS.v0.3.26+2.x86_64-linux-musl-libgfortran5.tar.gz/sha512/659167ca4b307c00afbfbc08a8bade4c144a0567c13354c81ef17dbd210f2a98b40289bb9f166a70cd447193c236561c7a6df2603ebcd0dec501529d4e976508
+OpenBLAS.v0.3.26+2.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/e12abdd6fa5a9211cdf3472ec9e2bf2c
+OpenBLAS.v0.3.26+2.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/cc68370a2e2c76303272e0d91a71ae1a9408233d7f39292682fc901b8474d8272ac42f233c2d0c3cdc07c481968bee2486831e8df48d9f34877b45e3af694b62
+OpenBLAS.v0.3.26+2.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/a02fcf5127ae14a00204c1b43b1c6807
+OpenBLAS.v0.3.26+2.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/e502418902d1af01efa1c9d6db94659b1472db8af812cd2507fb324836e5bab3364e54bca9a2ee809114947b4210f5fe3ec640d7bb741114a66e110d2668ddab
+OpenBLAS.v0.3.26+2.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/f4d49963b37686671d1d6f1f5b4b680e
+OpenBLAS.v0.3.26+2.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/0c395e956243b40bc29a820ac755740efd932f56eaba85a554041c223238300f0370ef2d051cb67357bf9a740950bbc78de1fba52522bd53a9d3a8f24799f975
+OpenBLAS.v0.3.26+2.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/fecab0026d2b7b7e0261ccf1f9aeb282
+OpenBLAS.v0.3.26+2.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/a9032b79cbc18448b141bc61b404e156af2ccaccd3919f0d38d5f2963e9e89c93f4992ed58217f969a7f5201b4489e0bdb91761fe507ee7f07e65e712f9ed584
+OpenBLAS.v0.3.26+2.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/28d440488310d3730db018612078bad7
+OpenBLAS.v0.3.26+2.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/a24e5e8f8da4734ce10b6d959b566df0ece3f3ba30737584ad3e7795d07b950e2bd57fb13d4a4f21eb92b29c38cf40fd846b5f771eb820a769e50f4074e36142
+OpenBLAS.v0.3.26+2.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/7202113787553198c32b0b6964630b5a
+OpenBLAS.v0.3.26+2.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/9553d90d0580bd6f1e6676be85029db615564bbada470ee8751619b5888e79ee23e1e699f1aba1e770a29c5ef1e4d13eb8c24cfa787ef22167c9100ed6af478e
 openblas-6c77e5e314474773a7749357b153caba4ec3817d.tar.gz/md5/4971eeb7adadee085d7c991db416fe7a
 openblas-6c77e5e314474773a7749357b153caba4ec3817d.tar.gz/sha512/7b85c9fb7be54407ba627d77897f40de4395d6d307230aa7df83cf8e0a41f545e4af4ae0576abb40cc9e0c385e1c6a488100dff292ea307439a89587c07ba66f
diff --git a/deps/openblas.mk b/deps/openblas.mk
index d890a5be6046a..c24ce47d359c1 100644
--- a/deps/openblas.mk
+++ b/deps/openblas.mk
@@ -20,6 +20,9 @@ endif
 # don't touch scheduler affinity since we manage this ourselves
 OPENBLAS_BUILD_OPTS += NO_AFFINITY=1
 
+# Build BFloat16 kernels
+OPENBLAS_BUILD_OPTS += BUILD_BFLOAT16=1
+
 # Build for all architectures - required for distribution
 ifeq ($(SANITIZE_MEMORY),1)
 OPENBLAS_BUILD_OPTS += TARGET=GENERIC
@@ -95,12 +98,22 @@ $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-ofast-power.patch-applied: $(BUILDDIR)/
 		patch -p1 -f < $(SRCDIR)/patches/openblas-ofast-power.patch
 	echo 1 > $@
 
-$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/neoverse-generic-kernels.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-ofast-power.patch-applied
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-avx512bf-kernels.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-ofast-power.patch-applied
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && \
+		patch -p1 -f < $(SRCDIR)/patches/openblas-avx512bf-kernels.patch
+	echo 1 > $@
+
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-gemv-multithreading.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-avx512bf-kernels.patch-applied
+	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && \
+		patch -p1 -f < $(SRCDIR)/patches/openblas-gemv-multithreading.patch
+	echo 1 > $@
+
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-darwin-sve.patch-applied: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-gemv-multithreading.patch-applied
 	cd $(BUILDDIR)/$(OPENBLAS_SRC_DIR) && \
-		patch -p1 -f < $(SRCDIR)/patches/neoverse-generic-kernels.patch
+		patch -p1 -f < $(SRCDIR)/patches/openblas-darwin-sve.patch
 	echo 1 > $@
 
-$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/neoverse-generic-kernels.patch-applied
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/openblas-darwin-sve.patch-applied
 	echo 1 > $@
 
 $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-compiled: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/build-configured
diff --git a/deps/patches/neoverse-generic-kernels.patch b/deps/patches/neoverse-generic-kernels.patch
deleted file mode 100644
index ab37e3783bf3e..0000000000000
--- a/deps/patches/neoverse-generic-kernels.patch
+++ /dev/null
@@ -1,19 +0,0 @@
-diff --git a/kernel/arm64/KERNEL.NEOVERSEN1 b/kernel/arm64/KERNEL.NEOVERSEN1
-index ea010db4..074d7215 100644
---- a/kernel/arm64/KERNEL.NEOVERSEN1
-+++ b/kernel/arm64/KERNEL.NEOVERSEN1
-@@ -91,10 +91,10 @@ IDAMAXKERNEL   = iamax_thunderx2t99.c
- ICAMAXKERNEL   = izamax_thunderx2t99.c
- IZAMAXKERNEL   = izamax_thunderx2t99.c
- 
--SNRM2KERNEL    = scnrm2_thunderx2t99.c
--DNRM2KERNEL    = dznrm2_thunderx2t99.c
--CNRM2KERNEL    = scnrm2_thunderx2t99.c
--ZNRM2KERNEL    = dznrm2_thunderx2t99.c
-+SNRM2KERNEL    = nrm2.S
-+DNRM2KERNEL    = nrm2.S
-+CNRM2KERNEL    = znrm2.S
-+ZNRM2KERNEL    = znrm2.S
- 
- DDOTKERNEL     = dot_thunderx2t99.c
- SDOTKERNEL     = dot_thunderx2t99.c
diff --git a/deps/patches/openblas-avx512bf-kernels.patch b/deps/patches/openblas-avx512bf-kernels.patch
new file mode 100644
index 0000000000000..7e99cdf7c53ee
--- /dev/null
+++ b/deps/patches/openblas-avx512bf-kernels.patch
@@ -0,0 +1,107 @@
+From 1dada6d65d89d19b2cf89b12169f6b2196c90f1d Mon Sep 17 00:00:00 2001
+From: Martin Kroeker <martin@ruby.chemie.uni-freiburg.de>
+Date: Fri, 12 Jan 2024 00:10:56 +0100
+Subject: [PATCH 1/2] Add compiler test and flag for AVX512BF16 capability
+
+---
+ c_check | 22 ++++++++++++++++++++++
+ 1 file changed, 22 insertions(+)
+
+diff --git a/c_check b/c_check
+index b5e4a9ad00..3e507be818 100755
+--- a/c_check
++++ b/c_check
+@@ -244,6 +244,7 @@ case "$data" in
+ esac
+ 
+ no_avx512=0
++no_avx512bf=0
+ if [ "$architecture" = "x86" ] || [ "$architecture" = "x86_64" ]; then
+     tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
+     tmpf="$tmpd/a.c"
+@@ -262,6 +263,25 @@ if [ "$architecture" = "x86" ] || [ "$architecture" = "x86_64" ]; then
+     }
+ 
+     rm -rf "$tmpd"
++    if [ "$no_avx512" -eq 0 ]; then
++    tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
++    tmpf="$tmpd/a.c"
++    code='"__m512 a= _mm512_dpbf16_ps(a, (__m512bh) _mm512_loadu_si512(%1]), (__m512bh) _mm512_loadu_si512(%2]));"'
++    printf "#include <immintrin.h>\n\nint main(void){ %s; }\n" "$code" >> "$tmpf"
++    if [ "$compiler" = "PGI" ]; then
++        args=" -tp cooperlake -c -o $tmpf.o $tmpf"
++    else
++        args=" -march=cooperlake -c -o $tmpf.o $tmpf"
++    fi
++    no_avx512bf=0
++    {
++        $compiler_name $flags $args >/dev/null 2>&1
++    } || {
++        no_avx512bf=1
++    }
++
++    rm -rf "$tmpd"
++  fi
+ fi
+ 
+ no_rv64gv=0
+@@ -409,6 +429,7 @@ done
+  [ "$makefile" = "-" ] && {
+     [ "$no_rv64gv" -eq 1 ] && printf "NO_RV64GV=1\n"
+     [ "$no_avx512" -eq 1 ] && printf "NO_AVX512=1\n"
++    [ "$no_avx512bf" -eq 1 ] && printf "NO_AVX512BF16=1\n"
+     [ "$no_avx2" -eq 1 ] && printf "NO_AVX2=1\n"
+     [ "$oldgcc" -eq 1 ] && printf "OLDGCC=1\n"
+     exit 0
+@@ -437,6 +458,7 @@ done
+     [ "$no_sve" -eq 1 ] && printf "NO_SVE=1\n"
+     [ "$no_rv64gv" -eq 1 ] && printf "NO_RV64GV=1\n"
+     [ "$no_avx512" -eq 1 ] && printf "NO_AVX512=1\n"
++    [ "$no_avx512bf" -eq 1 ] && printf "NO_AVX512BF16=1\n"
+     [ "$no_avx2" -eq 1 ] && printf "NO_AVX2=1\n"
+     [ "$oldgcc" -eq 1 ] && printf "OLDGCC=1\n"
+     [ "$no_lsx" -eq 1 ] && printf "NO_LSX=1\n"
+
+From 995a990e24fdcc8080128a8abc17b4ccc66bd4fd Mon Sep 17 00:00:00 2001
+From: Martin Kroeker <martin@ruby.chemie.uni-freiburg.de>
+Date: Fri, 12 Jan 2024 00:12:46 +0100
+Subject: [PATCH 2/2] Make AVX512 BFLOAT16 kernels conditional on compiler
+ capability
+
+---
+ kernel/x86_64/KERNEL.COOPERLAKE     | 3 ++-
+ kernel/x86_64/KERNEL.SAPPHIRERAPIDS | 2 ++
+ 2 files changed, 4 insertions(+), 1 deletion(-)
+
+diff --git a/kernel/x86_64/KERNEL.COOPERLAKE b/kernel/x86_64/KERNEL.COOPERLAKE
+index dba94aea86..22b042029f 100644
+--- a/kernel/x86_64/KERNEL.COOPERLAKE
++++ b/kernel/x86_64/KERNEL.COOPERLAKE
+@@ -1,5 +1,5 @@
+ include $(KERNELDIR)/KERNEL.SKYLAKEX
+-
++ifneq ($(NO_AVX512BF16), 1)
+ SBGEMM_SMALL_M_PERMIT = sbgemm_small_kernel_permit_cooperlake.c
+ SBGEMM_SMALL_K_NN = sbgemm_small_kernel_nn_cooperlake.c
+ SBGEMM_SMALL_K_B0_NN = sbgemm_small_kernel_nn_cooperlake.c
+@@ -20,3 +20,4 @@ SBGEMMINCOPYOBJ =  sbgemm_incopy$(TSUFFIX).$(SUFFIX)
+ SBGEMMITCOPYOBJ =  sbgemm_itcopy$(TSUFFIX).$(SUFFIX)
+ SBGEMMONCOPYOBJ =  sbgemm_oncopy$(TSUFFIX).$(SUFFIX)
+ SBGEMMOTCOPYOBJ =  sbgemm_otcopy$(TSUFFIX).$(SUFFIX)
++endif
+diff --git a/kernel/x86_64/KERNEL.SAPPHIRERAPIDS b/kernel/x86_64/KERNEL.SAPPHIRERAPIDS
+index 3a832e9174..0ab2b4ddcf 100644
+--- a/kernel/x86_64/KERNEL.SAPPHIRERAPIDS
++++ b/kernel/x86_64/KERNEL.SAPPHIRERAPIDS
+@@ -1,5 +1,6 @@
+ include $(KERNELDIR)/KERNEL.COOPERLAKE
+ 
++ifneq ($(NO_AVX512BF16), 1)
+ SBGEMM_SMALL_M_PERMIT =
+ SBGEMM_SMALL_K_NN     =
+ SBGEMM_SMALL_K_B0_NN  =
+@@ -20,3 +21,4 @@ SBGEMMINCOPYOBJ =  sbgemm_incopy$(TSUFFIX).$(SUFFIX)
+ SBGEMMITCOPYOBJ =  sbgemm_itcopy$(TSUFFIX).$(SUFFIX)
+ SBGEMMONCOPYOBJ =  sbgemm_oncopy$(TSUFFIX).$(SUFFIX)
+ SBGEMMOTCOPYOBJ =  sbgemm_otcopy$(TSUFFIX).$(SUFFIX)
++endif
diff --git a/deps/patches/openblas-darwin-sve.patch b/deps/patches/openblas-darwin-sve.patch
new file mode 100644
index 0000000000000..a2166db9379f1
--- /dev/null
+++ b/deps/patches/openblas-darwin-sve.patch
@@ -0,0 +1,34 @@
+From 03688a42622cf76e696859ce384e45aa26d927fc Mon Sep 17 00:00:00 2001
+From: Ian McInerney <i.mcinerney17@imperial.ac.uk>
+Date: Tue, 23 Jan 2024 10:29:57 +0000
+Subject: [PATCH] Build with proper aarch64 flags on Neoverse Darwin
+
+We aren't affected by the problems in AppleClang that prompted this
+fallback to an older architecture.
+---
+ Makefile.arm64 | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/Makefile.arm64 b/Makefile.arm64
+index ed52a9424..a8f3cb0f0 100644
+--- a/Makefile.arm64
++++ b/Makefile.arm64
+@@ -135,11 +135,11 @@ ifeq ($(CORE), NEOVERSEN2)
+ ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
+ ifeq (1, $(filter 1,$(GCCVERSIONGTEQ10) $(ISCLANG)))
+ ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ4) $(GCCVERSIONGTEQ11) $(ISCLANG)))
+-ifneq ($(OSNAME), Darwin)
++#ifneq ($(OSNAME), Darwin)
+ CCOMMON_OPT += -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2
+-else
+-CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
+-endif
++#else
++#CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
++#endif
+ ifneq ($(F_COMPILER), NAG)
+ FCOMMON_OPT += -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2
+ endif
+-- 
+2.43.0
+
diff --git a/deps/patches/openblas-gemv-multithreading.patch b/deps/patches/openblas-gemv-multithreading.patch
new file mode 100644
index 0000000000000..827c72fa48b1a
--- /dev/null
+++ b/deps/patches/openblas-gemv-multithreading.patch
@@ -0,0 +1,22 @@
+From d2fc4f3b4d7f41527bc7dc8f62e9aa6229cfac89 Mon Sep 17 00:00:00 2001
+From: Martin Kroeker <martin@ruby.chemie.uni-freiburg.de>
+Date: Wed, 17 Jan 2024 20:59:24 +0100
+Subject: [PATCH] Increase multithreading threshold by a factor of 50
+
+---
+ interface/gemv.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/interface/gemv.c b/interface/gemv.c
+index 1f07635799..2c121f1308 100644
+--- a/interface/gemv.c
++++ b/interface/gemv.c
+@@ -226,7 +226,7 @@ void CNAME(enum CBLAS_ORDER order,
+ 
+ #ifdef SMP
+ 
+-  if ( 1L * m * n < 2304L * GEMM_MULTITHREAD_THRESHOLD )
++  if ( 1L * m * n < 115200L * GEMM_MULTITHREAD_THRESHOLD )
+     nthreads = 1;
+   else
+     nthreads = num_cpu_avail(2);
diff --git a/deps/patches/openblas-ofast-power.patch b/deps/patches/openblas-ofast-power.patch
index 405e3f7581331..01089286257f7 100644
--- a/deps/patches/openblas-ofast-power.patch
+++ b/deps/patches/openblas-ofast-power.patch
@@ -1,17 +1,29 @@
 diff --git a/Makefile.power b/Makefile.power
-index 28a0bae0..b4869fbd 100644
+index aa1ca080a..42c417a78 100644
 --- a/Makefile.power
 +++ b/Makefile.power
-@@ -11,7 +11,7 @@ endif
- 
- ifeq ($(CORE), POWER10)
+@@ -13,16 +13,16 @@ ifeq ($(CORE), POWER10)
  ifneq ($(C_COMPILER), PGI)
+ ifeq ($(C_COMPILER), GCC))
+ ifeq ($(GCCVERSIONGTEQ10), 1)
 -CCOMMON_OPT += -Ofast -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
 +CCOMMON_OPT += -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
- ifeq ($(F_COMPILER), IBM)
- FCOMMON_OPT += -O2 -qrecur -qnosave
+ else ifneq ($(GCCVERSIONGT4), 1)
+ $(warning your compiler is too old to fully support POWER9, getting a newer version of gcc is recommended)
+-CCOMMON_OPT += -Ofast -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math
++CCOMMON_OPT += -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math
+ else
+ $(warning your compiler is too old to fully support POWER10, getting a newer version of gcc is recommended)
+-CCOMMON_OPT += -Ofast -mcpu=power9 -mtune=power9 -mvsx -fno-fast-math
++CCOMMON_OPT += -mcpu=power9 -mtune=power9 -mvsx -fno-fast-math
+ endif
  else
-@@ -22,7 +22,7 @@ endif
+-CCOMMON_OPT += -Ofast -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
++CCOMMON_OPT += -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
+ endif
+ ifeq ($(F_COMPILER), IBM)
+ FCOMMON_OPT += -O2 -qrecur -qnosave -qarch=pwr10 -qtune=pwr10 -qfloat=nomaf -qzerosize
+@@ -34,7 +34,7 @@ endif
  
  ifeq ($(CORE), POWER9)
  ifneq ($(C_COMPILER), PGI)
@@ -20,7 +32,7 @@ index 28a0bae0..b4869fbd 100644
  ifeq ($(C_COMPILER), GCC)
  ifneq ($(GCCVERSIONGT4), 1)
  $(warning your compiler is too old to fully support POWER9, getting a newer version of gcc is recommended)
-@@ -59,7 +59,7 @@ endif
+@@ -70,7 +70,7 @@ endif
  
  ifeq ($(CORE), POWER8)
  ifneq ($(C_COMPILER), PGI)
diff --git a/stdlib/LinearAlgebra/test/blas.jl b/stdlib/LinearAlgebra/test/blas.jl
index dd432952cb56e..d853b211e7817 100644
--- a/stdlib/LinearAlgebra/test/blas.jl
+++ b/stdlib/LinearAlgebra/test/blas.jl
@@ -126,6 +126,15 @@ Random.seed!(100)
                 @test BLAS.iamax(b) == findmax(fabs, b)[2] * (step(ind) >= 0)
             end
         end
+        @testset "nrm2 with non-finite elements" begin
+            # These tests would have caught <https://github.com/OpenMathLib/OpenBLAS/issues/2998>
+            # when running on appropriate hardware.
+            a = zeros(elty,n)
+            a[begin] = elty(-Inf)
+            @test BLAS.nrm2(a) === abs2(elty(Inf))
+            a[begin] = elty(NaN)
+            @test BLAS.nrm2(a) === abs2(elty(NaN))
+        end
         @testset "scal" begin
             α = rand(elty)
             a = rand(elty,n)
diff --git a/stdlib/OpenBLAS_jll/Project.toml b/stdlib/OpenBLAS_jll/Project.toml
index 4eeea867b8bce..10e8285027d42 100644
--- a/stdlib/OpenBLAS_jll/Project.toml
+++ b/stdlib/OpenBLAS_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "OpenBLAS_jll"
 uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
-version = "0.3.26+1"
+version = "0.3.26+2"
 
 [deps]
 # See note in `src/OpenBLAS_jll.jl` about this dependency.

From c42df604d99c521ad721e64d8be6286cd597e8f9 Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Fri, 26 Jan 2024 17:41:20 +0100
Subject: [PATCH 0718/1315] Improve type inference for `@something` (#52381)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`@something` eagerly unwraps any `Some` given to it, while keeping the
variable between its arguments the same. This can be an issue if a
previously unpacked value is used as input to `@something`, leading to a
type instability on more than two arguments (e.g. because of a fallback
to `Some(nothing)`). By using different variables for each argument,
type inference has an easier time handling these cases that are isolated
to single branches anyway.

This also adds some comments to the macro, since it's non-obvious what
it does.

Benchmarking the specific case I encountered this in led to a ~2x
performance improvement on multiple machines.

1.10-beta3/master:

```
[sukera@tower 01]$ jl1100 -q --project=. -L 01.jl -e 'bench()'
v"1.10.0-beta3"

BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  38.670 μs … 70.350 μs  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     43.340 μs              ┊ GC (median):    0.00%
 Time  (mean ± σ):   43.395 μs ±  1.518 μs  ┊ GC (mean ± σ):  0.00% ± 0.00%

                              ▆█▂ ▁▁
  ▂▂▂▂▂▂▂▂▂▁▂▂▂▃▃▃▂▂▃▃▃▂▂▂▂▂▄▇███▆██▄▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂ ▃
  38.7 μs         Histogram: frequency by time          48 μs <

 Memory estimate: 0 bytes, allocs estimate: 0.
```

This PR:

```
[sukera@tower 01]$ julia -q --project=. -L 01.jl -e 'bench()'
v"1.11.0-DEV.970"

BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  22.820 μs …  44.980 μs  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     24.300 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   24.370 μs ± 832.239 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

                ▂▅▇██▇▆▅▁
  ▂▂▂▂▂▂▂▂▃▃▄▅▇███████████▅▄▃▃▂▂▂▂▂▂▂▂▂▂▁▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▁▂▂ ▃
  22.8 μs         Histogram: frequency by time         27.7 μs <

 Memory estimate: 0 bytes, allocs estimate: 0.
```


<details>
<summary>Benchmarking code (spoilers for Advent Of Code 2023 Day 01,
Part 01). Running this requires the input of that Advent Of Code
day.</summary>

```julia
using BenchmarkTools
using InteractiveUtils

isdigit(d::UInt8) = UInt8('0') <= d <= UInt8('9')
someDigit(c::UInt8) = isdigit(c) ? Some(c - UInt8('0')) : nothing

function part1(data)
    total = 0
    may_a = nothing
    may_b = nothing

    for c in data
        digitRes = someDigit(c)
        may_a = @something may_a digitRes Some(nothing)
        may_b = @something digitRes may_b Some(nothing)
        if c == UInt8('\n')
            digit_a = may_a::UInt8
            digit_b = may_b::UInt8
            total += digit_a*0xa + digit_b
            may_a = nothing
            may_b = nothing
        end
    end

    return total
end

function bench()
    data = read("input.txt")
    display(VERSION)
    println()
    display(@benchmark part1($data))
    nothing
end
```
</details>

<details>
<summary>`@code_warntype` before</summary>

```julia
julia> @code_warntype part1(data)
MethodInstance for part1(::Vector{UInt8})
  from part1(data) @ Main ~/Documents/projects/AOC/2023/01/01.jl:7
Arguments
  #self#::Core.Const(part1)
  data::Vector{UInt8}
Locals
  @_3::Union{Nothing, Tuple{UInt8, Int64}}
  may_b::Union{Nothing, UInt8}
  may_a::Union{Nothing, UInt8}
  total::Int64
  c::UInt8
  digit_b::UInt8
  digit_a::UInt8
  val@_10::Any
  val@_11::Any
  digitRes::Union{Nothing, Some{UInt8}}
  @_13::Union{Some{Nothing}, Some{UInt8}, UInt8}
  @_14::Union{Some{Nothing}, Some{UInt8}}
  @_15::Some{Nothing}
  @_16::Union{Some{Nothing}, Some{UInt8}, UInt8}
  @_17::Union{Some{Nothing}, UInt8}
  @_18::Some{Nothing}
Body::Int64
1 ──       (total = 0)
│          (may_a = Main.nothing)
│          (may_b = Main.nothing)
│    %4  = data::Vector{UInt8}
│          (@_3 = Base.iterate(%4))
│    %6  = (@_3 === nothing)::Bool
│    %7  = Base.not_int(%6)::Bool
└───       goto #24 if not %7
2 ┄─       Core.NewvarNode(:(digit_b))
│          Core.NewvarNode(:(digit_a))
│          Core.NewvarNode(:(val@_10))
│    %12 = @_3::Tuple{UInt8, Int64}
│          (c = Core.getfield(%12, 1))
│    %14 = Core.getfield(%12, 2)::Int64
│          (digitRes = Main.someDigit(c))
│          (val@_11 = may_a)
│    %17 = (val@_11::Union{Nothing, UInt8} !== Base.nothing)::Bool
└───       goto #4 if not %17
3 ──       (@_13 = val@_11::UInt8)
└───       goto #11
4 ──       (val@_11 = digitRes)
│    %22 = (val@_11::Union{Nothing, Some{UInt8}} !== Base.nothing)::Bool
└───       goto #6 if not %22
5 ──       (@_14 = val@_11::Some{UInt8})
└───       goto #10
6 ──       (val@_11 = Main.Some(Main.nothing))
│    %27 = (val@_11::Core.Const(Some(nothing)) !== Base.nothing)::Core.Const(true)
└───       goto #8 if not %27
7 ──       (@_15 = val@_11::Core.Const(Some(nothing)))
└───       goto #9
8 ──       Core.Const(:(@_15 = Base.nothing))
9 ┄─       (@_14 = @_15)
10 ┄       (@_13 = @_14)
11 ┄ %34 = @_13::Union{Some{Nothing}, Some{UInt8}, UInt8}
│          (may_a = Base.something(%34))
│          (val@_10 = digitRes)
│    %37 = (val@_10::Union{Nothing, Some{UInt8}} !== Base.nothing)::Bool
└───       goto #13 if not %37
12 ─       (@_16 = val@_10::Some{UInt8})
└───       goto #20
13 ─       (val@_10 = may_b)
│    %42 = (val@_10::Union{Nothing, UInt8} !== Base.nothing)::Bool
└───       goto #15 if not %42
14 ─       (@_17 = val@_10::UInt8)
└───       goto #19
15 ─       (val@_10 = Main.Some(Main.nothing))
│    %47 = (val@_10::Core.Const(Some(nothing)) !== Base.nothing)::Core.Const(true)
└───       goto #17 if not %47
16 ─       (@_18 = val@_10::Core.Const(Some(nothing)))
└───       goto #18
17 ─       Core.Const(:(@_18 = Base.nothing))
18 ┄       (@_17 = @_18)
19 ┄       (@_16 = @_17)
20 ┄ %54 = @_16::Union{Some{Nothing}, Some{UInt8}, UInt8}
│          (may_b = Base.something(%54))
│    %56 = c::UInt8
│    %57 = Main.UInt8('\n')::Core.Const(0x0a)
│    %58 = (%56 == %57)::Bool
└───       goto #22 if not %58
21 ─       (digit_a = Core.typeassert(may_a, Main.UInt8))
│          (digit_b = Core.typeassert(may_b, Main.UInt8))
│    %62 = total::Int64
│    %63 = (digit_a * 0x0a)::UInt8
│    %64 = (%63 + digit_b)::UInt8
│          (total = %62 + %64)
│          (may_a = Main.nothing)
└───       (may_b = Main.nothing)
22 ┄       (@_3 = Base.iterate(%4, %14))
│    %69 = (@_3 === nothing)::Bool
│    %70 = Base.not_int(%69)::Bool
└───       goto #24 if not %70
23 ─       goto #2
24 ┄       return total
```
</details>

<details>
<summary>`@code_native debuginfo=:none` Before </summary>

```julia
julia> @code_native debuginfo=:none part1(data)
	.text
	.file	"part1"
	.globl	julia_part1_418                 # -- Begin function julia_part1_418
	.p2align	4, 0x90
	.type	julia_part1_418,@function
julia_part1_418:                        # @julia_part1_418
# %bb.0:                                # %top
	push	rbp
	mov	rbp, rsp
	push	r15
	push	r14
	push	r13
	push	r12
	push	rbx
	sub	rsp, 40
	mov	rax, qword ptr [rdi + 8]
	test	rax, rax
	je	.LBB0_1
# %bb.2:                                # %L17
	mov	rcx, qword ptr [rdi]
	dec	rax
	mov	r10b, 1
	xor	r14d, r14d
                                        # implicit-def: $r12b
                                        # implicit-def: $r13b
                                        # implicit-def: $r9b
                                        # implicit-def: $sil
	mov	qword ptr [rbp - 64], rax       # 8-byte Spill
	mov	al, 1
	mov	dword ptr [rbp - 48], eax       # 4-byte Spill
                                        # implicit-def: $al
                                        # kill: killed $al
	xor	eax, eax
	mov	qword ptr [rbp - 56], rax       # 8-byte Spill
	mov	qword ptr [rbp - 72], rcx       # 8-byte Spill
                                        # implicit-def: $cl
	jmp	.LBB0_3
	.p2align	4, 0x90
.LBB0_8:                                #   in Loop: Header=BB0_3 Depth=1
	mov	dword ptr [rbp - 48], 0         # 4-byte Folded Spill
.LBB0_24:                               # %post_union_move
                                        #   in Loop: Header=BB0_3 Depth=1
	movzx	r13d, byte ptr [rbp - 41]       # 1-byte Folded Reload
	mov	r12d, r8d
	cmp	qword ptr [rbp - 64], r14       # 8-byte Folded Reload
	je	.LBB0_13
.LBB0_25:                               # %guard_exit113
                                        #   in Loop: Header=BB0_3 Depth=1
	inc	r14
	mov	r10d, ebx
.LBB0_3:                                # %L19
                                        # =>This Inner Loop Header: Depth=1
	mov	rax, qword ptr [rbp - 72]       # 8-byte Reload
	xor	ebx, ebx
	xor	edi, edi
	movzx	r15d, r9b
	movzx	ecx, cl
	movzx	esi, sil
	mov	r11b, 1
                                        # implicit-def: $r9b
	movzx	edx, byte ptr [rax + r14]
	lea	eax, [rdx - 58]
	lea	r8d, [rdx - 48]
	cmp	al, -10
	setae	bl
	setb	dil
	test	r10b, 1
	cmovne	r15d, edi
	mov	edi, 0
	cmovne	ecx, ebx
	mov	bl, 1
	cmovne	esi, edi
	test	r15b, 1
	jne	.LBB0_7
# %bb.4:                                # %L76
                                        #   in Loop: Header=BB0_3 Depth=1
	mov	r11b, 2
	test	cl, 1
	jne	.LBB0_5
# %bb.6:                                # %L78
                                        #   in Loop: Header=BB0_3 Depth=1
	mov	ebx, r10d
	mov	r9d, r15d
	mov	byte ptr [rbp - 41], r13b       # 1-byte Spill
	test	sil, 1
	je	.LBB0_26
.LBB0_7:                                # %L82
                                        #   in Loop: Header=BB0_3 Depth=1
	cmp	al, -11
	jbe	.LBB0_9
	jmp	.LBB0_8
	.p2align	4, 0x90
.LBB0_5:                                #   in Loop: Header=BB0_3 Depth=1
	mov	ecx, r8d
	mov	sil, 1
	xor	ebx, ebx
	mov	byte ptr [rbp - 41], r8b        # 1-byte Spill
	xor	r9d, r9d
	xor	ecx, ecx
	cmp	al, -11
	ja	.LBB0_8
.LBB0_9:                                # %L90
                                        #   in Loop: Header=BB0_3 Depth=1
	test	byte ptr [rbp - 48], 1          # 1-byte Folded Reload
	jne	.LBB0_23
# %bb.10:                               # %L115
                                        #   in Loop: Header=BB0_3 Depth=1
	cmp	dl, 10
	jne	.LBB0_11
# %bb.14:                               # %L122
                                        #   in Loop: Header=BB0_3 Depth=1
	test	r15b, 1
	jne	.LBB0_15
# %bb.12:                               # %L130.thread
                                        #   in Loop: Header=BB0_3 Depth=1
	movzx	eax, byte ptr [rbp - 41]        # 1-byte Folded Reload
	mov	bl, 1
	add	eax, eax
	lea	eax, [rax + 4*rax]
	add	al, r12b
	movzx	eax, al
	add	qword ptr [rbp - 56], rax       # 8-byte Folded Spill
	mov	al, 1
	mov	dword ptr [rbp - 48], eax       # 4-byte Spill
	cmp	qword ptr [rbp - 64], r14       # 8-byte Folded Reload
	jne	.LBB0_25
	jmp	.LBB0_13
	.p2align	4, 0x90
.LBB0_23:                               # %L115.thread
                                        #   in Loop: Header=BB0_3 Depth=1
	mov	al, 1
                                        # implicit-def: $r8b
	mov	dword ptr [rbp - 48], eax       # 4-byte Spill
	cmp	dl, 10
	jne	.LBB0_24
	jmp	.LBB0_21
.LBB0_11:                               #   in Loop: Header=BB0_3 Depth=1
	mov	r8d, r12d
	jmp	.LBB0_24
.LBB0_1:
	xor	eax, eax
	mov	qword ptr [rbp - 56], rax       # 8-byte Spill
.LBB0_13:                               # %L159
	mov	rax, qword ptr [rbp - 56]       # 8-byte Reload
	add	rsp, 40
	pop	rbx
	pop	r12
	pop	r13
	pop	r14
	pop	r15
	pop	rbp
	ret
.LBB0_21:                               # %L122.thread
	test	r15b, 1
	jne	.LBB0_15
# %bb.22:                               # %post_box_union58
	movabs	rdi, offset .L_j_str1
	movabs	rax, offset ijl_type_error
	movabs	rsi, 140008511215408
	movabs	rdx, 140008667209736
	call	rax
.LBB0_15:                               # %fail
	cmp	r11b, 1
	je	.LBB0_19
# %bb.16:                               # %fail
	movzx	eax, r11b
	cmp	eax, 2
	jne	.LBB0_17
# %bb.20:                               # %box_union54
	movzx	eax, byte ptr [rbp - 41]        # 1-byte Folded Reload
	movabs	rcx, offset jl_boxed_uint8_cache
	mov	rdx, qword ptr [rcx + 8*rax]
	jmp	.LBB0_18
.LBB0_26:                               # %L80
	movabs	rax, offset ijl_throw
	movabs	rdi, 140008495049392
	call	rax
.LBB0_19:                               # %box_union
	movabs	rdx, 140008667209736
	jmp	.LBB0_18
.LBB0_17:
	xor	edx, edx
.LBB0_18:                               # %post_box_union
	movabs	rdi, offset .L_j_str1
	movabs	rax, offset ijl_type_error
	movabs	rsi, 140008511215408
	call	rax
.Lfunc_end0:
	.size	julia_part1_418, .Lfunc_end0-julia_part1_418
                                        # -- End function
	.type	.L_j_str1,@object               # @_j_str1
	.section	.rodata.str1.1,"aMS",@progbits,1
.L_j_str1:
	.asciz	"typeassert"
	.size	.L_j_str1, 11

	.section	".note.GNU-stack","",@progbits
```
</details>

<details>
<summary>`@code_warntype` After</summary>

```julia

[sukera@tower 01]$ julia -q --project=. -L 01.jl
julia> data = read("input.txt");

julia> @code_warntype part1(data)
MethodInstance for part1(::Vector{UInt8})
  from part1(data) @ Main ~/Documents/projects/AOC/2023/01/01.jl:7
Arguments
  #self#::Core.Const(part1)
  data::Vector{UInt8}
Locals
  @_3::Union{Nothing, Tuple{UInt8, Int64}}
  may_b::Union{Nothing, UInt8}
  may_a::Union{Nothing, UInt8}
  total::Int64
  val@_7::Union{}
  val@_8::Union{}
  c::UInt8
  digit_b::UInt8
  digit_a::UInt8
  ##215::Some{Nothing}
  ##216::Union{Nothing, UInt8}
  ##217::Union{Nothing, Some{UInt8}}
  ##212::Some{Nothing}
  ##213::Union{Nothing, Some{UInt8}}
  ##214::Union{Nothing, UInt8}
  digitRes::Union{Nothing, Some{UInt8}}
  @_19::Union{Nothing, UInt8}
  @_20::Union{Nothing, UInt8}
  @_21::Nothing
  @_22::Union{Nothing, UInt8}
  @_23::Union{Nothing, UInt8}
  @_24::Nothing
Body::Int64
1 ──        (total = 0)
│           (may_a = Main.nothing)
│           (may_b = Main.nothing)
│    %4   = data::Vector{UInt8}
│           (@_3 = Base.iterate(%4))
│    %6   = @_3::Union{Nothing, Tuple{UInt8, Int64}}
│    %7   = (%6 === nothing)::Bool
│    %8   = Base.not_int(%7)::Bool
└───        goto #24 if not %8
2 ┄─        Core.NewvarNode(:(val@_7))
│           Core.NewvarNode(:(val@_8))
│           Core.NewvarNode(:(digit_b))
│           Core.NewvarNode(:(digit_a))
│           Core.NewvarNode(:(##215))
│           Core.NewvarNode(:(##216))
│           Core.NewvarNode(:(##217))
│           Core.NewvarNode(:(##212))
│           Core.NewvarNode(:(##213))
│    %19  = @_3::Tuple{UInt8, Int64}
│           (c = Core.getfield(%19, 1))
│    %21  = Core.getfield(%19, 2)::Int64
│    %22  = c::UInt8
│           (digitRes = Main.someDigit(%22))
│    %24  = may_a::Union{Nothing, UInt8}
│           (##214 = %24)
│    %26  = Base.:!::Core.Const(!)
│    %27  = ##214::Union{Nothing, UInt8}
│    %28  = Base.isnothing(%27)::Bool
│    %29  = (%26)(%28)::Bool
└───        goto #4 if not %29
3 ── %31  = ##214::UInt8
│           (@_19 = Base.something(%31))
└───        goto #11
4 ── %34  = digitRes::Union{Nothing, Some{UInt8}}
│           (##213 = %34)
│    %36  = Base.:!::Core.Const(!)
│    %37  = ##213::Union{Nothing, Some{UInt8}}
│    %38  = Base.isnothing(%37)::Bool
│    %39  = (%36)(%38)::Bool
└───        goto #6 if not %39
5 ── %41  = ##213::Some{UInt8}
│           (@_20 = Base.something(%41))
└───        goto #10
6 ── %44  = Main.Some::Core.Const(Some)
│    %45  = Main.nothing::Core.Const(nothing)
│           (##212 = (%44)(%45))
│    %47  = Base.:!::Core.Const(!)
│    %48  = ##212::Core.Const(Some(nothing))
│    %49  = Base.isnothing(%48)::Core.Const(false)
│    %50  = (%47)(%49)::Core.Const(true)
└───        goto #8 if not %50
7 ── %52  = ##212::Core.Const(Some(nothing))
│           (@_21 = Base.something(%52))
└───        goto #9
8 ──        Core.Const(nothing)
│           Core.Const(:(val@_8 = Base.something(Base.nothing)))
│           Core.Const(nothing)
│           Core.Const(:(val@_8))
└───        Core.Const(:(@_21 = %58))
9 ┄─ %60  = @_21::Core.Const(nothing)
└───        (@_20 = %60)
10 ┄ %62  = @_20::Union{Nothing, UInt8}
└───        (@_19 = %62)
11 ┄ %64  = @_19::Union{Nothing, UInt8}
│           (may_a = %64)
│    %66  = digitRes::Union{Nothing, Some{UInt8}}
│           (##217 = %66)
│    %68  = Base.:!::Core.Const(!)
│    %69  = ##217::Union{Nothing, Some{UInt8}}
│    %70  = Base.isnothing(%69)::Bool
│    %71  = (%68)(%70)::Bool
└───        goto #13 if not %71
12 ─ %73  = ##217::Some{UInt8}
│           (@_22 = Base.something(%73))
└───        goto #20
13 ─ %76  = may_b::Union{Nothing, UInt8}
│           (##216 = %76)
│    %78  = Base.:!::Core.Const(!)
│    %79  = ##216::Union{Nothing, UInt8}
│    %80  = Base.isnothing(%79)::Bool
│    %81  = (%78)(%80)::Bool
└───        goto #15 if not %81
14 ─ %83  = ##216::UInt8
│           (@_23 = Base.something(%83))
└───        goto #19
15 ─ %86  = Main.Some::Core.Const(Some)
│    %87  = Main.nothing::Core.Const(nothing)
│           (##215 = (%86)(%87))
│    %89  = Base.:!::Core.Const(!)
│    %90  = ##215::Core.Const(Some(nothing))
│    %91  = Base.isnothing(%90)::Core.Const(false)
│    %92  = (%89)(%91)::Core.Const(true)
└───        goto #17 if not %92
16 ─ %94  = ##215::Core.Const(Some(nothing))
│           (@_24 = Base.something(%94))
└───        goto #18
17 ─        Core.Const(nothing)
│           Core.Const(:(val@_7 = Base.something(Base.nothing)))
│           Core.Const(nothing)
│           Core.Const(:(val@_7))
└───        Core.Const(:(@_24 = %100))
18 ┄ %102 = @_24::Core.Const(nothing)
└───        (@_23 = %102)
19 ┄ %104 = @_23::Union{Nothing, UInt8}
└───        (@_22 = %104)
20 ┄ %106 = @_22::Union{Nothing, UInt8}
│           (may_b = %106)
│    %108 = Main.:(==)::Core.Const(==)
│    %109 = c::UInt8
│    %110 = Main.UInt8('\n')::Core.Const(0x0a)
│    %111 = (%108)(%109, %110)::Bool
└───        goto #22 if not %111
21 ─ %113 = may_a::Union{Nothing, UInt8}
│           (digit_a = Core.typeassert(%113, Main.UInt8))
│    %115 = may_b::Union{Nothing, UInt8}
│           (digit_b = Core.typeassert(%115, Main.UInt8))
│    %117 = Main.:+::Core.Const(+)
│    %118 = total::Int64
│    %119 = Main.:+::Core.Const(+)
│    %120 = Main.:*::Core.Const(*)
│    %121 = digit_a::UInt8
│    %122 = (%120)(%121, 0x0a)::UInt8
│    %123 = digit_b::UInt8
│    %124 = (%119)(%122, %123)::UInt8
│           (total = (%117)(%118, %124))
│           (may_a = Main.nothing)
└───        (may_b = Main.nothing)
22 ┄        (@_3 = Base.iterate(%4, %21))
│    %129 = @_3::Union{Nothing, Tuple{UInt8, Int64}}
│    %130 = (%129 === nothing)::Bool
│    %131 = Base.not_int(%130)::Bool
└───        goto #24 if not %131
23 ─        goto #2
24 ┄ %134 = total::Int64
└───        return %134
```
</details>


<details>
<summary>`@code_native debuginfo=:none` After </summary>

```julia

julia> @code_native debuginfo=:none part1(data)
	.text
	.file	"part1"
	.globl	julia_part1_1203                # -- Begin function julia_part1_1203
	.p2align	4, 0x90
	.type	julia_part1_1203,@function
julia_part1_1203:                       # @julia_part1_1203
; Function Signature: part1(Array{UInt8, 1})
# %bb.0:                                # %top
	#DEBUG_VALUE: part1:data <- [DW_OP_deref] $rdi
	push	rbp
	mov	rbp, rsp
	push	r15
	push	r14
	push	r13
	push	r12
	push	rbx
	sub	rsp, 40
	vxorps	xmm0, xmm0, xmm0
	#APP
	mov	rax, qword ptr fs:[0]
	#NO_APP
	lea	rdx, [rbp - 64]
	vmovaps	xmmword ptr [rbp - 64], xmm0
	mov	qword ptr [rbp - 48], 0
	mov	rcx, qword ptr [rax - 8]
	mov	qword ptr [rbp - 64], 4
	mov	rax, qword ptr [rcx]
	mov	qword ptr [rbp - 72], rcx       # 8-byte Spill
	mov	qword ptr [rbp - 56], rax
	mov	qword ptr [rcx], rdx
	#DEBUG_VALUE: part1:data <- [DW_OP_deref] 0
	mov	r15, qword ptr [rdi + 16]
	test	r15, r15
	je	.LBB0_1
# %bb.2:                                # %L34
	mov	r14, qword ptr [rdi]
	dec	r15
	mov	r11b, 1
	mov	r13b, 1
                                        # implicit-def: $r12b
                                        # implicit-def: $r10b
	xor	eax, eax
	jmp	.LBB0_3
	.p2align	4, 0x90
.LBB0_4:                                #   in Loop: Header=BB0_3 Depth=1
	xor	r11d, r11d
	mov	ebx, edi
	mov	r10d, r8d
.LBB0_9:                                # %L114
                                        #   in Loop: Header=BB0_3 Depth=1
	mov	r12d, esi
	test	r15, r15
	je	.LBB0_12
.LBB0_10:                               # %guard_exit126
                                        #   in Loop: Header=BB0_3 Depth=1
	inc	r14
	dec	r15
	mov	r13d, ebx
.LBB0_3:                                # %L36
                                        # =>This Inner Loop Header: Depth=1
	movzx	edx, byte ptr [r14]
	test	r13b, 1
	movzx	edi, r13b
	mov	ebx, 1
	mov	ecx, 0
	cmove	ebx, edi
	cmovne	edi, ecx
	movzx	ecx, r10b
	lea	esi, [rdx - 48]
	lea	r9d, [rdx - 58]
	movzx	r8d, sil
	cmove	r8d, ecx
	cmp	r9b, -11
	ja	.LBB0_4
# %bb.5:                                # %L89
                                        #   in Loop: Header=BB0_3 Depth=1
	test	r11b, 1
	jne	.LBB0_8
# %bb.6:                                # %L102
                                        #   in Loop: Header=BB0_3 Depth=1
	cmp	dl, 10
	jne	.LBB0_7
# %bb.13:                               # %L106
                                        #   in Loop: Header=BB0_3 Depth=1
	test	r13b, 1
	jne	.LBB0_14
# %bb.11:                               # %L114.thread
                                        #   in Loop: Header=BB0_3 Depth=1
	add	ecx, ecx
	mov	bl, 1
	mov	r11b, 1
	lea	ecx, [rcx + 4*rcx]
	add	cl, r12b
	movzx	ecx, cl
	add	rax, rcx
	test	r15, r15
	jne	.LBB0_10
	jmp	.LBB0_12
	.p2align	4, 0x90
.LBB0_8:                                # %L102.thread
                                        #   in Loop: Header=BB0_3 Depth=1
	mov	r11b, 1
                                        # implicit-def: $sil
	cmp	dl, 10
	jne	.LBB0_9
	jmp	.LBB0_15
.LBB0_7:                                #   in Loop: Header=BB0_3 Depth=1
	mov	esi, r12d
	jmp	.LBB0_9
.LBB0_1:
	xor	eax, eax
.LBB0_12:                               # %L154
	mov	rcx, qword ptr [rbp - 56]
	mov	rdx, qword ptr [rbp - 72]       # 8-byte Reload
	mov	qword ptr [rdx], rcx
	add	rsp, 40
	pop	rbx
	pop	r12
	pop	r13
	pop	r14
	pop	r15
	pop	rbp
	ret
.LBB0_15:                               # %L106.thread
	test	r13b, 1
	jne	.LBB0_14
# %bb.16:                               # %post_box_union47
	movabs	rax, offset jl_nothing
	movabs	rcx, offset jl_small_typeof
	movabs	rdi, offset ".L_j_str_typeassert#1"
	mov	rdx, qword ptr [rax]
	mov	rsi, qword ptr [rcx + 336]
	movabs	rax, offset ijl_type_error
	mov	qword ptr [rbp - 48], rsi
	call	rax
.LBB0_14:                               # %post_box_union
	movabs	rax, offset jl_nothing
	movabs	rcx, offset jl_small_typeof
	movabs	rdi, offset ".L_j_str_typeassert#1"
	mov	rdx, qword ptr [rax]
	mov	rsi, qword ptr [rcx + 336]
	movabs	rax, offset ijl_type_error
	mov	qword ptr [rbp - 48], rsi
	call	rax
.Lfunc_end0:
	.size	julia_part1_1203, .Lfunc_end0-julia_part1_1203
                                        # -- End function
	.type	".L_j_str_typeassert#1",@object # @"_j_str_typeassert#1"
	.section	.rodata.str1.1,"aMS",@progbits,1
".L_j_str_typeassert#1":
	.asciz	"typeassert"
	.size	".L_j_str_typeassert#1", 11

	.section	".note.GNU-stack","",@progbits
```
</details>

Co-authored-by: Sukera <Seelengrab@users.noreply.github.com>
---
 base/some.jl | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/base/some.jl b/base/some.jl
index 0d538cbed6c23..46b912243f859 100644
--- a/base/some.jl
+++ b/base/some.jl
@@ -138,10 +138,31 @@ true
     This macro is available as of Julia 1.7.
 """
 macro something(args...)
-    expr = :(nothing)
+    noth = GlobalRef(Base, :nothing)
+    something = GlobalRef(Base, :something)
+
+    # This preserves existing semantics of throwing on `nothing`
+    expr = :($something($noth))
+
+    #=
+    We go through the arguments in reverse
+    because we're building a nested if/else
+    expression from the inside out.
+    The innermost thing to check is the last argument,
+    which is why we need the last argument first
+    when building the final expression.
+    =#
     for arg in reverse(args)
-        expr = :(val = $(esc(arg)); val !== nothing ? val : ($expr))
+        val = gensym()
+        expr = quote
+            $val = $(esc(arg))
+            if !isnothing($val)
+                # unwrap eagerly to help type inference
+                $something($val)
+            else
+                $expr
+            end
+        end
     end
-    something = GlobalRef(Base, :something)
-    return :($something($expr))
+    return expr
 end

From 77dc56bdf8fca66316289f4258440c6937b5dcc8 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Sat, 27 Jan 2024 02:35:44 +0100
Subject: [PATCH 0719/1315] Fix some missing xrefs in collections.md (#53047)

---
 doc/src/base/collections.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/doc/src/base/collections.md b/doc/src/base/collections.md
index 23cb8d6dab7c2..909f968b30baf 100644
--- a/doc/src/base/collections.md
+++ b/doc/src/base/collections.md
@@ -36,15 +36,15 @@ Fully implemented by:
 
   * [`AbstractRange`](@ref)
   * [`UnitRange`](@ref)
-  * `Tuple`
-  * `Number`
+  * [`Tuple`](@ref)
+  * [`Number`](@ref)
   * [`AbstractArray`](@ref)
   * [`BitSet`](@ref)
   * [`IdDict`](@ref)
   * [`Dict`](@ref)
   * [`WeakKeyDict`](@ref)
   * `EachLine`
-  * `AbstractString`
+  * [`AbstractString`](@ref)
   * [`Set`](@ref)
   * [`Pair`](@ref)
   * [`NamedTuple`](@ref)
@@ -74,14 +74,14 @@ Fully implemented by:
 
   * [`AbstractRange`](@ref)
   * [`UnitRange`](@ref)
-  * `Tuple`
-  * `Number`
+  * [`Tuple`](@ref)
+  * [`Number`](@ref)
   * [`AbstractArray`](@ref)
   * [`BitSet`](@ref)
   * [`IdDict`](@ref)
   * [`Dict`](@ref)
   * [`WeakKeyDict`](@ref)
-  * `AbstractString`
+  * [`AbstractString`](@ref)
   * [`Set`](@ref)
   * [`NamedTuple`](@ref)
 
@@ -166,8 +166,8 @@ Partially implemented by:
 
   * [`AbstractRange`](@ref)
   * [`UnitRange`](@ref)
-  * `Tuple`
-  * `AbstractString`
+  * [`Tuple`](@ref)
+  * [`AbstractString`](@ref)
   * [`Dict`](@ref)
   * [`IdDict`](@ref)
   * [`WeakKeyDict`](@ref)

From c32aeb5751b8527d49173c0aa64449645f35d5c5 Mon Sep 17 00:00:00 2001
From: Hendrik Ranocha <ranocha@users.noreply.github.com>
Date: Sat, 27 Jan 2024 02:38:42 +0100
Subject: [PATCH 0720/1315] Clarify documentation of do-block syntax (#52807)

The previous version

> The `do x` syntax creates an anonymous function with argument `x` and
passes *it* as the first argument

could be misunderstood since one may think that *it* refers to the
argument `x`, not the anonymous function.

---------

Co-authored-by: inky <git@wo-class.cn>
---
 doc/src/manual/functions.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/functions.md b/doc/src/manual/functions.md
index af7f150a74e42..6f065c11c9dcd 100644
--- a/doc/src/manual/functions.md
+++ b/doc/src/manual/functions.md
@@ -923,8 +923,10 @@ map([A, B, C]) do x
 end
 ```
 
-The `do x` syntax creates an anonymous function with argument `x` and passes it as the first argument
-to [`map`](@ref). Similarly, `do a,b` would create a two-argument anonymous function. Note that `do (a,b)` would create a one-argument anonymous function,
+The `do x` syntax creates an anonymous function with argument `x` and passes
+the anonymous function as the first argument
+to the "outer" function - [`map`](@ref) in this example.
+Similarly, `do a,b` would create a two-argument anonymous function. Note that `do (a,b)` would create a one-argument anonymous function,
 whose argument is a tuple to be deconstructed. A plain `do` would declare that what follows is an anonymous function of the form `() -> ...`.
 
 How these arguments are initialized depends on the "outer" function; here, [`map`](@ref) will

From 26e54d351b9ec659ddaaf7d0ed5264a6e988045d Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sat, 27 Jan 2024 22:47:04 +0800
Subject: [PATCH 0721/1315] Subtype: fix mis-usage of `simple_subtype(2)`
 (#53078)

---
 src/jltypes.c | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/jltypes.c b/src/jltypes.c
index 21c3cebbb8de7..23c025be14292 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -558,6 +558,7 @@ static void isort_union(jl_value_t **a, size_t len) JL_NOTSAFEPOINT
 
 static int simple_subtype(jl_value_t *a, jl_value_t *b, int hasfree, int isUnion)
 {
+    assert(hasfree == (jl_has_free_typevars(a) | (jl_has_free_typevars(b) << 1)));
     if (a == jl_bottom_type || b == (jl_value_t*)jl_any_type)
         return 1;
     if (jl_egal(a, b))
@@ -571,7 +572,7 @@ static int simple_subtype(jl_value_t *a, jl_value_t *b, int hasfree, int isUnion
     }
     if (jl_is_typevar(a)) {
         jl_value_t *na = ((jl_tvar_t*)a)->ub;
-        hasfree &= jl_has_free_typevars(na);
+        hasfree &= (jl_has_free_typevars(na) | 2);
         return simple_subtype(na, b, hasfree, isUnion);
     }
     if (jl_is_typevar(b)) {
@@ -581,7 +582,7 @@ static int simple_subtype(jl_value_t *a, jl_value_t *b, int hasfree, int isUnion
         // Tuple{Union{Int,T},T} where {T>:Int} != Tuple{T,T} where {T>:Int}
         if (is_leaf_bound(nb))
             return 0;
-        hasfree &= jl_has_free_typevars(nb) << 1;
+        hasfree &= ((jl_has_free_typevars(nb) << 1) | 1);
         return simple_subtype(a, nb, hasfree, isUnion);
     }
     if (b==(jl_value_t*)jl_datatype_type || b==(jl_value_t*)jl_typeofbottom_type) {
@@ -643,6 +644,7 @@ JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n)
 
 static int simple_subtype2(jl_value_t *a, jl_value_t *b, int hasfree, int isUnion)
 {
+    assert(hasfree == (jl_has_free_typevars(a) | (jl_has_free_typevars(b) << 1)));
     int subab = 0, subba = 0;
     if (jl_egal(a, b)) {
         subab = subba = 1;
@@ -655,7 +657,7 @@ static int simple_subtype2(jl_value_t *a, jl_value_t *b, int hasfree, int isUnio
     }
     else if (hasfree != 0) {
         subab = simple_subtype(a, b, hasfree, isUnion);
-        subba = simple_subtype(b, a, hasfree, isUnion);
+        subba = simple_subtype(b, a, ((hasfree & 2) >> 1) | ((hasfree & 1) << 1), isUnion);
     }
     else if (jl_is_type_type(a) && jl_is_type_type(b) &&
              jl_typeof(jl_tparam0(a)) != jl_typeof(jl_tparam0(b))) {
@@ -784,10 +786,11 @@ jl_value_t *simple_intersect(jl_value_t *a, jl_value_t *b, int overesi)
     for (i = 0; i < nta; i++) {
         if (temp[i] == NULL) continue;
         all_disjoint = 0;
-        int hasfree = jl_has_free_typevars(temp[i]);
+        int has_free = jl_has_free_typevars(temp[i]);
         for (j = nta; j < nt; j++) {
             if (temp[j] == NULL) continue;
-            int subs = simple_subtype2(temp[i], temp[j], hasfree || jl_has_free_typevars(temp[j]), 0);
+            int has_free2 = has_free | (jl_has_free_typevars(temp[j]) << 1);
+            int subs = simple_subtype2(temp[i], temp[j], has_free2, 0);
             int subab = subs & 1, subba = subs >> 1;
             if (subba && !subab) {
                 stemp[i] = -1;

From 20085f49a32c9d8eb9adfc21edf27597031a88d2 Mon Sep 17 00:00:00 2001
From: jam-khan <jamkhan@connect.hku.hk>
Date: Sat, 27 Jan 2024 10:45:12 -0500
Subject: [PATCH 0722/1315] Add docstring for Dates.adjust (#52914)

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 stdlib/Dates/src/adjusters.jl | 35 +++++++++++++++++++++++++++++++++++
 stdlib/Dates/test/runtests.jl |  4 +---
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/stdlib/Dates/src/adjusters.jl b/stdlib/Dates/src/adjusters.jl
index 245e2678a9d77..dee2894ff5d4e 100644
--- a/stdlib/Dates/src/adjusters.jl
+++ b/stdlib/Dates/src/adjusters.jl
@@ -204,6 +204,41 @@ function adjust(df::DateFunction, start, step, limit)
     throw(ArgumentError("Adjustment limit reached: $limit iterations"))
 end
 
+"""
+    adjust(df, start[, step, limit]) -> TimeType
+    adjust(df, start) -> TimeType
+
+Adjusts the date in `start` until the `f::Function` passed using `df` returns `true`.
+The optional `step` parameter dictates the change in `start` on every iteration.
+If `limit` iterations occur, then an [`ArgumentError`](@ref) is thrown.
+
+The default values for parameters `start` and `limit` are 1 Day and 10,000 respectively.
+
+# Examples
+```jldoctest
+julia> adjust(date -> month(date) == 10, Date(2022, 1, 1), step=Month(3), limit=10)
+2022-10-01
+
+julia> adjust(date -> year(date) == 2025, Date(2022, 1, 1), step=Year(1), limit=4)
+2025-01-01
+
+julia> adjust(date -> day(date) == 15, Date(2022, 1, 1), step=Year(1), limit=3)
+ERROR: ArgumentError: Adjustment limit reached: 3 iterations
+Stacktrace:
+[...]
+
+julia> adjust(date -> month(date) == 10, Date(2022, 1, 1))
+2022-10-01
+
+julia> adjust(date -> year(date) == 2025, Date(2022, 1, 1))
+2025-01-01
+
+julia> adjust(date -> year(date) == 2224, Date(2022, 1, 1))
+ERROR: ArgumentError: Adjustment limit reached: 10000 iterations
+Stacktrace:
+[...]
+```
+"""
 function adjust(func::Function, start; step::Period=Day(1), limit::Int=10000)
     return adjust(DateFunction(func, start), start, step, limit)
 end
diff --git a/stdlib/Dates/test/runtests.jl b/stdlib/Dates/test/runtests.jl
index 7ac46bd69139c..ad2ee43cedfb1 100644
--- a/stdlib/Dates/test/runtests.jl
+++ b/stdlib/Dates/test/runtests.jl
@@ -9,9 +9,7 @@ for file in readlines(joinpath(@__DIR__, "testgroups"))
 end
 
 @testset "Docstrings" begin
-    undoc = Docs.undocumented_names(Dates)
-    @test_broken isempty(undoc)
-    @test undoc == [:adjust]
+    @test isempty(Docs.undocumented_names(Dates))
 end
 
 end

From ecc14ca3888d128594286310109c9a93eb353985 Mon Sep 17 00:00:00 2001
From: jariji <96840304+jariji@users.noreply.github.com>
Date: Sat, 27 Jan 2024 07:45:57 -0800
Subject: [PATCH 0723/1315] Don't export Dates.adjust (#53027)

`Dates.adjust` has been exported for a while, but has no docstring and is not in the manual in 1.10.

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 NEWS.md                   | 2 ++
 stdlib/Dates/src/Dates.jl | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index dd16151ffa74c..6eb7e6509c69f 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -165,6 +165,8 @@ Standard library changes
 
 #### Dates
 
+The undocumented function `adjust` is no longer exported but is now documented
+
 #### Statistics
 
 * Statistics is now an upgradeable standard library ([#46501]).
diff --git a/stdlib/Dates/src/Dates.jl b/stdlib/Dates/src/Dates.jl
index a111ea24089c4..bbfcdbee3f3d1 100644
--- a/stdlib/Dates/src/Dates.jl
+++ b/stdlib/Dates/src/Dates.jl
@@ -77,7 +77,7 @@ export Period, DatePeriod, TimePeriod,
        firstdayofmonth, lastdayofmonth,
        firstdayofyear, lastdayofyear,
        firstdayofquarter, lastdayofquarter,
-       adjust, tonext, toprev, tofirst, tolast,
+       tonext, toprev, tofirst, tolast,
        # io.jl
        ISODateTimeFormat, ISODateFormat, ISOTimeFormat, DateFormat, RFC1123Format, @dateformat_str
 

From 6ce6d3193391e9cbe719d79d54b9fd6fef0ef43e Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 27 Jan 2024 12:45:03 -0500
Subject: [PATCH 0724/1315] methods: add a lock around method table changes
 (#52997)

Ensures that only one update can occur simultaneously by adding a lock
around it, and that the acquire-release on the world-age will be
sequenced after all of the invalidations to the caches, by updating it
last.

It should now be safe to add methods in parallel, concurrently with
running code. However, there are still no locks here to ensure that only
one module is deserialized at a time, which means that parallel require
calls are still unsafe. (and also because the loading.jl code is
currently a thread-safety disaster zone)

As future work, all of the method inserting and (separately) the
validation/insertion work could run in parallel after loading an image,
since there is a fine-grained lock on each individual part of that, as
well as the big lock so that only one module at a time can load methods.

The min/max fields are always written behind a lock, but they are not
usually read from behind a lock, so add relaxed atomic markers to all
uses of that field to make any data-race analysis tools happy. These are
never used in a comparison with a value greater than
`jl_atomic_load_acquire(&jl_world_counter)`, and therefore the results
achieved are consistent.
---
 src/aotcompile.cpp                        |   2 +-
 src/clangsa/GCChecker.cpp                 |   3 +-
 src/codegen.cpp                           |   5 +-
 src/gc.c                                  |   2 -
 src/gf.c                                  | 163 ++++++++++++++--------
 src/ircode.c                              |   5 +-
 src/jitlayers.cpp                         |   7 +-
 src/jltypes.c                             |  14 +-
 src/julia.h                               |  19 ++-
 src/julia_internal.h                      |   3 +-
 src/method.c                              |  20 +--
 src/module.c                              |   1 -
 src/opaque_closure.c                      |   7 +-
 src/options.h                             |   5 -
 src/staticdata.c                          | 136 +++++++++---------
 src/staticdata_utils.c                    |  86 +++++++++---
 src/toplevel.c                            |  10 +-
 src/typemap.c                             |  40 +++---
 stdlib/Serialization/src/Serialization.jl |  13 +-
 test/core.jl                              |   8 +-
 test/precompile.jl                        |   2 +-
 21 files changed, 320 insertions(+), 231 deletions(-)

diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 773aa0c62b29b..7b51579ce430f 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -395,7 +395,7 @@ void *jl_create_native_impl(jl_array_t *methods, LLVMOrcThreadSafeModuleRef llvm
             // if this method is generally visible to the current compilation world,
             // and this is either the primary world, or not applicable in the primary world
             // then we want to compile and emit this
-            if (mi->def.method->primary_world <= params.world && params.world <= mi->def.method->deleted_world) {
+            if (jl_atomic_load_relaxed(&mi->def.method->primary_world) <= params.world && params.world <= jl_atomic_load_relaxed(&mi->def.method->deleted_world)) {
                 // find and prepare the source code to compile
                 jl_code_instance_t *codeinst = NULL;
                 jl_ci_cache_lookup(*cgparams, mi, params.world, &codeinst, &src);
diff --git a/src/clangsa/GCChecker.cpp b/src/clangsa/GCChecker.cpp
index f8e73c486a862..97def0fac59f2 100644
--- a/src/clangsa/GCChecker.cpp
+++ b/src/clangsa/GCChecker.cpp
@@ -1444,7 +1444,8 @@ bool GCChecker::evalCall(const CallEvent &Call, CheckerContext &C) const {
   } else if (name == "JL_GC_PUSH1" || name == "JL_GC_PUSH2" ||
              name == "JL_GC_PUSH3" || name == "JL_GC_PUSH4" ||
              name == "JL_GC_PUSH5" || name == "JL_GC_PUSH6" ||
-             name == "JL_GC_PUSH7" || name == "JL_GC_PUSH8") {
+             name == "JL_GC_PUSH7" || name == "JL_GC_PUSH8" ||
+             name == "JL_GC_PUSH9") {
     ProgramStateRef State = C.getState();
     // Transform slots to roots, transform values to rooted
     unsigned NumArgs = CE->getNumArgs();
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 824464382cd97..39f938ea313e8 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -9324,8 +9324,9 @@ void jl_compile_workqueue(
         auto proto = it.second;
         params.workqueue.pop_back();
         // try to emit code for this item from the workqueue
-        assert(codeinst->min_world <= params.world && codeinst->max_world >= params.world &&
-            "invalid world for code-instance");
+        assert(jl_atomic_load_relaxed(&codeinst->min_world) <= params.world &&
+               jl_atomic_load_relaxed(&codeinst->max_world) >= params.world &&
+               "invalid world for code-instance");
         StringRef preal_decl = "";
         bool preal_specsig = false;
         auto invoke = jl_atomic_load_acquire(&codeinst->invoke);
diff --git a/src/gc.c b/src/gc.c
index 5d2093c3d24a3..044dcf8113e9f 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -3299,8 +3299,6 @@ static void gc_mark_roots(jl_gc_markqueue_t *mq)
         gc_try_claim_and_push(mq, v, NULL);
         gc_heap_snapshot_record_array_edge_index((jl_value_t*)jl_anytuple_type_type, (jl_value_t*)v, i);
     }
-    gc_try_claim_and_push(mq, jl_all_methods, NULL);
-    gc_heap_snapshot_record_gc_roots((jl_value_t*)jl_all_methods, "all_methods");
     gc_try_claim_and_push(mq, _jl_debug_method_invalidation, NULL);
     gc_heap_snapshot_record_gc_roots((jl_value_t*)_jl_debug_method_invalidation, "debug_method_invalidation");
     // constants
diff --git a/src/gf.c b/src/gf.c
index 3c5870487ec9b..cc551e8cee90f 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -25,6 +25,7 @@ extern "C" {
 #endif
 
 JL_DLLEXPORT _Atomic(size_t) jl_world_counter = 1; // uses atomic acquire/release
+jl_mutex_t world_counter_lock;
 JL_DLLEXPORT size_t jl_get_world_counter(void) JL_NOTSAFEPOINT
 {
     jl_task_t *ct = jl_current_task;
@@ -437,7 +438,7 @@ JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_method_instance_t *mi, size_t mi
 {
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
     while (codeinst) {
-        if (codeinst->min_world <= min_world && max_world <= codeinst->max_world) {
+        if (jl_atomic_load_relaxed(&codeinst->min_world) <= min_world && max_world <= jl_atomic_load_relaxed(&codeinst->max_world)) {
             jl_value_t *code = jl_atomic_load_relaxed(&codeinst->inferred);
             if (code && (code == jl_nothing || jl_ir_flag_inferred(code)))
                 return (jl_value_t*)codeinst;
@@ -455,8 +456,8 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
 {
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
     while (codeinst) {
-        if (codeinst->min_world == min_world &&
-            codeinst->max_world == max_world &&
+        if (jl_atomic_load_relaxed(&codeinst->min_world) == min_world &&
+            jl_atomic_load_relaxed(&codeinst->max_world) == max_world &&
             jl_egal(codeinst->rettype, rettype)) {
             return codeinst;
         }
@@ -492,8 +493,8 @@ JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
     jl_code_instance_t *codeinst = (jl_code_instance_t*)jl_gc_alloc(ct->ptls, sizeof(jl_code_instance_t),
             jl_code_instance_type);
     codeinst->def = mi;
-    codeinst->min_world = min_world;
-    codeinst->max_world = max_world;
+    jl_atomic_store_relaxed(&codeinst->min_world, min_world);
+    jl_atomic_store_relaxed(&codeinst->max_world, max_world);
     codeinst->rettype = rettype;
     codeinst->exctype = exctype;
     jl_atomic_store_release(&codeinst->inferred, inferred);
@@ -1226,7 +1227,7 @@ static inline jl_typemap_entry_t *lookup_leafcache(jl_genericmemory_t *leafcache
     jl_typemap_entry_t *entry = (jl_typemap_entry_t*)jl_eqtable_get(leafcache, (jl_value_t*)tt, NULL);
     if (entry) {
         do {
-            if (entry->min_world <= world && world <= entry->max_world) {
+            if (jl_atomic_load_relaxed(&entry->min_world) <= world && world <= jl_atomic_load_relaxed(&entry->max_world)) {
                 if (entry->simplesig == (void*)jl_nothing || concretesig_equal(tt, (jl_value_t*)entry->simplesig))
                     return entry;
             }
@@ -1501,8 +1502,8 @@ static int get_intersect_visitor(jl_typemap_entry_t *oldentry, struct typemap_in
 {
     struct matches_env *closure = container_of(closure0, struct matches_env, match);
     assert(oldentry != closure->newentry && "entry already added");
-    assert(oldentry->min_world <= closure->newentry->min_world && "old method cannot be newer than new method");
-    assert(oldentry->max_world != closure->newentry->min_world && "method cannot be added at the same time as method deleted");
+    assert(jl_atomic_load_relaxed(&oldentry->min_world) <= jl_atomic_load_relaxed(&closure->newentry->min_world) && "old method cannot be newer than new method");
+    assert(jl_atomic_load_relaxed(&oldentry->max_world) != jl_atomic_load_relaxed(&closure->newentry->min_world) && "method cannot be added at the same time as method deleted");
     // don't need to consider other similar methods if this oldentry will always fully intersect with them and dominates all of them
     typemap_slurp_search(oldentry, &closure->match);
     jl_method_t *oldmethod = oldentry->func.method;
@@ -1678,11 +1679,11 @@ static void invalidate_method_instance(jl_method_instance_t *replaced, size_t ma
     JL_LOCK(&replaced->def.method->writelock);
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&replaced->cache);
     while (codeinst) {
-        if (codeinst->max_world == ~(size_t)0) {
-            assert(codeinst->min_world - 1 <= max_world && "attempting to set illogical world constraints (probable race condition)");
-            codeinst->max_world = max_world;
+        if (jl_atomic_load_relaxed(&codeinst->max_world) == ~(size_t)0) {
+            assert(jl_atomic_load_relaxed(&codeinst->min_world) - 1 <= max_world && "attempting to set illogical world constraints (probable race condition)");
+            jl_atomic_store_release(&codeinst->max_world, max_world);
         }
-        assert(codeinst->max_world <= max_world);
+        assert(jl_atomic_load_relaxed(&codeinst->max_world) <= max_world);
         codeinst = jl_atomic_load_relaxed(&codeinst->next);
     }
     JL_GC_PUSH1(&replaced);
@@ -1799,7 +1800,7 @@ static int invalidate_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
 {
     struct invalidate_mt_env *env = (struct invalidate_mt_env*)closure0;
     JL_GC_PROMISE_ROOTED(env->newentry);
-    if (oldentry->max_world == ~(size_t)0) {
+    if (jl_atomic_load_relaxed(&oldentry->max_world) == ~(size_t)0) {
         jl_method_instance_t *mi = oldentry->func.linfo;
         int intersects = 0;
         jl_method_instance_t **d = (jl_method_instance_t**)jl_array_ptr_data(env->shadowed);
@@ -1835,7 +1836,7 @@ static int invalidate_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
                 jl_array_ptr_1d_push(_jl_debug_method_invalidation, loctag);
                 JL_GC_POP();
             }
-            oldentry->max_world = env->max_world;
+            jl_atomic_store_relaxed(&oldentry->max_world, env->max_world);
             env->invalidated = 1;
         }
     }
@@ -1844,11 +1845,11 @@ static int invalidate_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
 static int disable_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
 {
     struct invalidate_mt_env *env = (struct invalidate_mt_env*)closure0;
-    if (oldentry->max_world < ~(size_t)0)
+    if (jl_atomic_load_relaxed(&oldentry->max_world) < ~(size_t)0)
         return 1;
     jl_method_t *m = oldentry->func.linfo->def.method;
     if (m == env->newentry->func.method)
-        oldentry->max_world = env->max_world;
+        jl_atomic_store_relaxed(&oldentry->max_world, env->max_world);
     return 1;
 }
 
@@ -1878,7 +1879,10 @@ static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *m
         jl_error("Method deletion is not possible during Module precompile.");
     jl_method_t *method = methodentry->func.method;
     assert(!method->is_for_opaque_closure);
-    method->deleted_world = methodentry->max_world = max_world;
+    assert(jl_atomic_load_relaxed(&jl_world_counter) == max_world);
+    assert(jl_atomic_load_relaxed(&method->deleted_world) == ~(size_t)0);
+    jl_atomic_store_relaxed(&method->deleted_world, max_world);
+    jl_atomic_store_relaxed(&methodentry->max_world, max_world);
     // drop this method from mt->cache
     struct invalidate_mt_env mt_cache_env;
     mt_cache_env.max_world = max_world;
@@ -1892,8 +1896,8 @@ static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *m
         jl_typemap_entry_t *oldentry = (jl_typemap_entry_t*)jl_genericmemory_ptr_ref(leafcache, i);
         if (oldentry) {
             while ((jl_value_t*)oldentry != jl_nothing) {
-                if (oldentry->max_world == ~(size_t)0)
-                    oldentry->max_world = mt_cache_env.max_world;
+                if (jl_atomic_load_relaxed(&oldentry->max_world) == ~(size_t)0)
+                    jl_atomic_store_relaxed(&oldentry->max_world, mt_cache_env.max_world);
                 oldentry = jl_atomic_load_relaxed(&oldentry->next);
             }
         }
@@ -1928,11 +1932,14 @@ static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *m
 JL_DLLEXPORT void jl_method_table_disable(jl_methtable_t *mt, jl_method_t *method)
 {
     jl_typemap_entry_t *methodentry = do_typemap_search(mt, method);
+    JL_LOCK(&world_counter_lock);
     JL_LOCK(&mt->writelock);
     // Narrow the world age on the method to make it uncallable
-    size_t world = jl_atomic_fetch_add(&jl_world_counter, 1);
+    size_t world = jl_atomic_load_relaxed(&jl_world_counter);
     jl_method_table_invalidate(mt, methodentry, world);
+    jl_atomic_store_release(&jl_world_counter, world + 1);
     JL_UNLOCK(&mt->writelock);
+    JL_UNLOCK(&world_counter_lock);
 }
 
 static int jl_type_intersection2(jl_value_t *t1, jl_value_t *t2, jl_value_t **isect JL_REQUIRE_ROOTED_SLOT, jl_value_t **isect2 JL_REQUIRE_ROOTED_SLOT)
@@ -1994,29 +2001,51 @@ static int is_replacing(char ambig, jl_value_t *type, jl_method_t *m, jl_method_
     return 1;
 }
 
-JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype)
+jl_typemap_entry_t *jl_method_table_add(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype)
 {
     JL_TIMING(ADD_METHOD, ADD_METHOD);
     assert(jl_is_method(method));
     assert(jl_is_mtable(mt));
     jl_timing_show_method(method, JL_TIMING_DEFAULT_BLOCK);
-    jl_value_t *type = method->sig;
+    jl_typemap_entry_t *newentry = NULL;
+    JL_GC_PUSH1(&newentry);
+    JL_LOCK(&mt->writelock);
+    // add our new entry
+    assert(jl_atomic_load_relaxed(&method->primary_world) == ~(size_t)0); // min-world
+    assert(jl_atomic_load_relaxed(&method->deleted_world) == 1); // max-world
+    newentry = jl_typemap_alloc((jl_tupletype_t*)method->sig, simpletype, jl_emptysvec, (jl_value_t*)method,
+            jl_atomic_load_relaxed(&method->primary_world), jl_atomic_load_relaxed(&method->deleted_world));
+    jl_typemap_insert(&mt->defs, (jl_value_t*)mt, newentry, jl_cachearg_offset(mt));
+    update_max_args(mt, method->sig);
+    JL_UNLOCK(&mt->writelock);
+    JL_GC_POP();
+    return newentry;
+}
+
+void jl_method_table_activate(jl_methtable_t *mt, jl_typemap_entry_t *newentry)
+{
+    JL_TIMING(ADD_METHOD, ADD_METHOD);
+    jl_method_t *method = newentry->func.method;
+    assert(jl_is_mtable(mt));
+    assert(jl_is_method(method));
+    jl_timing_show_method(method, JL_TIMING_DEFAULT_BLOCK);
+    jl_value_t *type = (jl_value_t*)newentry->sig;
     jl_value_t *oldvalue = NULL;
     jl_array_t *oldmi = NULL;
-    if (method->primary_world == 1)
-        method->primary_world = jl_atomic_fetch_add(&jl_world_counter, 1) + 1;
-    size_t max_world = method->primary_world - 1;
+    JL_LOCK(&mt->writelock);
+    size_t world = jl_atomic_load_relaxed(&method->primary_world);
+    assert(world == jl_atomic_load_relaxed(&jl_world_counter) + 1); // min-world
+    assert(jl_atomic_load_relaxed(&method->deleted_world) == ~(size_t)0); // max-world
+    assert(jl_atomic_load_relaxed(&newentry->min_world) == ~(size_t)0);
+    assert(jl_atomic_load_relaxed(&newentry->max_world) == 1);
+    jl_atomic_store_relaxed(&newentry->min_world, world);
+    jl_atomic_store_relaxed(&method->primary_world, world);
+    size_t max_world = world - 1;
     jl_value_t *loctag = NULL;  // debug info for invalidation
     jl_value_t *isect = NULL;
     jl_value_t *isect2 = NULL;
     jl_value_t *isect3 = NULL;
-    jl_typemap_entry_t *newentry = NULL;
-    JL_GC_PUSH7(&oldvalue, &oldmi, &newentry, &loctag, &isect, &isect2, &isect3);
-    JL_LOCK(&mt->writelock);
-    // add our new entry
-    newentry = jl_typemap_alloc((jl_tupletype_t*)type, simpletype, jl_emptysvec,
-            (jl_value_t*)method, method->primary_world, method->deleted_world);
-    jl_typemap_insert(&mt->defs, (jl_value_t*)mt, newentry, jl_cachearg_offset(mt));
+    JL_GC_PUSH6(&oldvalue, &oldmi, &loctag, &isect, &isect2, &isect3);
     jl_typemap_entry_t *replaced = NULL;
     // then check what entries we replaced
     oldvalue = get_intersect_matches(jl_atomic_load_relaxed(&mt->defs), newentry, &replaced, jl_cachearg_offset(mt), max_world);
@@ -2200,11 +2229,25 @@ JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method
         loctag = jl_cstr_to_string("jl_method_table_insert");
         jl_array_ptr_1d_push(_jl_debug_method_invalidation, loctag);
     }
-    update_max_args(mt, type);
+    jl_atomic_store_relaxed(&newentry->max_world, jl_atomic_load_relaxed(&method->deleted_world));
     JL_UNLOCK(&mt->writelock);
     JL_GC_POP();
 }
 
+JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype)
+{
+    jl_typemap_entry_t *newentry = jl_method_table_add(mt, method, simpletype);
+    JL_GC_PUSH1(&newentry);
+    JL_LOCK(&world_counter_lock);
+    size_t world = jl_atomic_load_relaxed(&jl_world_counter) + 1;
+    jl_atomic_store_relaxed(&method->primary_world, world);
+    jl_atomic_store_relaxed(&method->deleted_world, ~(size_t)0);
+    jl_method_table_activate(mt, newentry);
+    jl_atomic_store_release(&jl_world_counter, world);
+    JL_UNLOCK(&world_counter_lock);
+    JL_GC_POP();
+}
+
 static void JL_NORETURN jl_method_error_bare(jl_function_t *f, jl_value_t *args, size_t world)
 {
     if (jl_methoderror_type) {
@@ -2334,7 +2377,7 @@ jl_code_instance_t *jl_method_compiled(jl_method_instance_t *mi, size_t world)
 {
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
     while (codeinst) {
-        if (codeinst->min_world <= world && world <= codeinst->max_world) {
+        if (jl_atomic_load_relaxed(&codeinst->min_world) <= world && world <= jl_atomic_load_relaxed(&codeinst->max_world)) {
             if (jl_atomic_load_relaxed(&codeinst->invoke) != NULL)
                 return codeinst;
         }
@@ -2393,7 +2436,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         jl_code_instance_t *codeinst2 = jl_compile_method_internal(mi2, world);
         jl_code_instance_t *codeinst = jl_get_method_inferred(
                 mi, codeinst2->rettype,
-                codeinst2->min_world, codeinst2->max_world);
+                jl_atomic_load_relaxed(&codeinst2->min_world), jl_atomic_load_relaxed(&codeinst2->max_world));
         if (jl_atomic_load_relaxed(&codeinst->invoke) == NULL) {
             codeinst->rettype_const = codeinst2->rettype_const;
             uint8_t specsigflags = jl_atomic_load_acquire(&codeinst2->specsigflags);
@@ -2778,7 +2821,7 @@ static void jl_compile_now(jl_method_instance_t *mi)
     size_t world = jl_atomic_load_acquire(&jl_world_counter);
     size_t tworld = jl_typeinf_world;
     _generate_from_hint(mi, world);
-    if (jl_typeinf_func && mi->def.method->primary_world <= tworld) {
+    if (jl_typeinf_func && jl_atomic_load_relaxed(&mi->def.method->primary_world) <= tworld) {
         // if it's part of the compiler, also attempt to compile for the compiler world too
         _generate_from_hint(mi, tworld);
     }
@@ -2805,7 +2848,7 @@ JL_DLLEXPORT void jl_compile_method_instance(jl_method_instance_t *mi, jl_tuplet
             jl_atomic_store_relaxed(&mi2->precompiled, 1);
             if (jl_rettype_inferred(mi2, world, world) == jl_nothing)
                 (void)jl_type_infer(mi2, world, 1);
-            if (jl_typeinf_func && mi->def.method->primary_world <= tworld) {
+            if (jl_typeinf_func && jl_atomic_load_relaxed(&mi->def.method->primary_world) <= tworld) {
                 if (jl_rettype_inferred(mi2, tworld, tworld) == jl_nothing)
                     (void)jl_type_infer(mi2, tworld, 1);
             }
@@ -2880,7 +2923,7 @@ STATIC_INLINE jl_value_t *_jl_invoke(jl_value_t *F, jl_value_t **args, uint32_t
     // manually inlined copy of jl_method_compiled
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mfunc->cache);
     while (codeinst) {
-        if (codeinst->min_world <= world && world <= codeinst->max_world) {
+        if (jl_atomic_load_relaxed(&codeinst->min_world) <= world && world <= jl_atomic_load_relaxed(&codeinst->max_world)) {
             jl_callptr_t invoke = jl_atomic_load_acquire(&codeinst->invoke);
             if (invoke != NULL) {
                 jl_value_t *res = invoke(F, args, nargs, codeinst);
@@ -2997,7 +3040,7 @@ STATIC_INLINE jl_method_instance_t *jl_lookup_generic_(jl_value_t *F, jl_value_t
             entry = jl_atomic_load_relaxed(&call_cache[cache_idx[i]]); \
             if (entry && nargs == jl_svec_len(entry->sig->parameters) && \
                 sig_match_fast(FT, args, jl_svec_data(entry->sig->parameters), nargs) && \
-                world >= entry->min_world && world <= entry->max_world) { \
+                world >= jl_atomic_load_relaxed(&entry->min_world) && world <= jl_atomic_load_relaxed(&entry->max_world)) { \
                 goto have_entry; \
             } \
         } while (0);
@@ -3254,24 +3297,26 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
     struct ml_matches_env *closure = container_of(closure0, struct ml_matches_env, match);
     if (closure->intersections == 0 && !closure0->issubty)
         return 1;
-    if (closure->world < ml->min_world) {
+    size_t min_world = jl_atomic_load_relaxed(&ml->min_world);
+    size_t max_world = jl_atomic_load_relaxed(&ml->max_world);
+    if (closure->world < min_world) {
         // ignore method table entries that are part of a later world
-        if (closure->match.max_valid >= ml->min_world)
-            closure->match.max_valid = ml->min_world - 1;
+        if (closure->match.max_valid >= min_world)
+            closure->match.max_valid = min_world - 1;
         return 1;
     }
-    else if (closure->world > ml->max_world) {
+    else if (closure->world > max_world) {
         // ignore method table entries that have been replaced in the current world
-        if (closure->match.min_valid <= ml->max_world)
-            closure->match.min_valid = ml->max_world + 1;
+        if (closure->match.min_valid <= max_world)
+            closure->match.min_valid = max_world + 1;
         return 1;
     }
     else {
         // intersect the env valid range with method's inclusive valid range
-        if (closure->match.min_valid < ml->min_world)
-            closure->match.min_valid = ml->min_world;
-        if (closure->match.max_valid > ml->max_world)
-            closure->match.max_valid = ml->max_world;
+        if (closure->match.min_valid < min_world)
+            closure->match.min_valid = min_world;
+        if (closure->match.max_valid > max_world)
+            closure->match.max_valid = max_world;
     }
     jl_method_t *meth = ml->func.method;
     if (closure->lim >= 0 && jl_is_dispatch_tupletype(meth->sig)) {
@@ -3638,10 +3683,12 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
                     env.match.env, meth, FULLY_COVERS);
                 env.t = (jl_value_t*)jl_alloc_vec_any(1);
                 jl_array_ptr_set(env.t, 0, env.matc);
-                if (*min_valid < entry->min_world)
-                    *min_valid = entry->min_world;
-                if (*max_valid > entry->max_world)
-                    *max_valid = entry->max_world;
+                size_t min_world = jl_atomic_load_relaxed(&entry->min_world);
+                size_t max_world = jl_atomic_load_relaxed(&entry->max_world);
+                if (*min_valid < min_world)
+                    *min_valid = min_world;
+                if (*max_valid > max_world)
+                    *max_valid = max_world;
                 JL_GC_POP();
                 return env.t;
             }
@@ -3664,10 +3711,12 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
                     env.match.env, meth, FULLY_COVERS);
                 env.t = (jl_value_t*)jl_alloc_vec_any(1);
                 jl_array_ptr_set(env.t, 0, env.matc);
-                if (*min_valid < entry->min_world)
-                    *min_valid = entry->min_world;
-                if (*max_valid > entry->max_world)
-                    *max_valid = entry->max_world;
+                size_t min_world = jl_atomic_load_relaxed(&entry->min_world);
+                size_t max_world = jl_atomic_load_relaxed(&entry->max_world);
+                if (*min_valid < min_world)
+                    *min_valid = min_world;
+                if (*max_valid > max_world)
+                    *max_valid = max_world;
                 JL_GC_POP();
                 return env.t;
             }
diff --git a/src/ircode.c b/src/ircode.c
index b238e79a239ff..09f039db76424 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -976,8 +976,9 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
     JL_UNLOCK(&m->writelock); // Might GC
     JL_GC_POP();
     if (metadata) {
-        code->min_world = metadata->min_world;
-        code->max_world = metadata->max_world;
+        code->min_world = jl_atomic_load_relaxed(&metadata->min_world);
+        // n.b. this should perhaps be capped to jl_world_counter max here, since we don't have backedges on it after return
+        code->max_world = jl_atomic_load_relaxed(&metadata->max_world);
         code->rettype = metadata->rettype;
         code->parent = metadata->def;
     }
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 74b9acf10bce3..8521ab5502f32 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -198,8 +198,11 @@ static jl_callptr_t _jl_compile_codeinst(
         start_time = jl_hrtime();
 
     assert(jl_is_code_instance(codeinst));
-    assert(codeinst->min_world <= world && (codeinst->max_world >= world || codeinst->max_world == 0) &&
+#ifndef NDEBUG
+    size_t max_world = jl_atomic_load_relaxed(&codeinst->max_world);
+    assert(jl_atomic_load_relaxed(&codeinst->min_world) <= world && (max_world >= world || max_world == 0) &&
         "invalid world for method-instance");
+#endif
 
     JL_TIMING(CODEINST_COMPILE, CODEINST_COMPILE);
 #ifdef USE_TRACY
@@ -588,7 +591,7 @@ void jl_generate_fptr_for_unspecialized_impl(jl_code_instance_t *unspec)
         if (src) {
             assert(jl_is_code_info(src));
             ++UnspecFPtrCount;
-            _jl_compile_codeinst(unspec, src, unspec->min_world, *jl_ExecutionEngine->getContext(), 0);
+            _jl_compile_codeinst(unspec, src, jl_atomic_load_relaxed(&unspec->min_world), *jl_ExecutionEngine->getContext(), 0);
         }
         jl_callptr_t null = nullptr;
         // if we hit a codegen bug (or ran into a broken generated function or llvmcall), fall back to the interpreter as a last resort
diff --git a/src/jltypes.c b/src/jltypes.c
index 23c025be14292..84e90303affaa 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -2923,8 +2923,8 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_bool_type),
                         jl_emptysvec,
                         0, 1, 4);
-    const static uint32_t typemap_entry_constfields[1] = { 0x000003fe }; // (1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<<7)|(1<<8)|(1<<9)
-    const static uint32_t typemap_entry_atomicfields[1] = { 0x00000001 }; // (1<<0)
+    const static uint32_t typemap_entry_constfields[1] = { 0x000003ce }; // (1<<1)|(1<<2)|(1<<3)|(1<<6)|(1<<7)|(1<<8)|(1<<9)
+    const static uint32_t typemap_entry_atomicfields[1] = { 0x00000031 }; // (1<<0)|(1<<4)|(1<<5)
     jl_typemap_entry_type->name->constfields = typemap_entry_constfields;
     jl_typemap_entry_type->name->atomicfields = typemap_entry_atomicfields;
 
@@ -3198,8 +3198,8 @@ void jl_init_types(void) JL_GC_DISABLED
                             "module",
                             "file",
                             "line",
-                            "primary_world",
-                            "deleted_world", // !const
+                            "primary_world", // atomic
+                            "deleted_world", // atomic
                             "sig",
                             "specializations", // !const
                             "speckeyset", // !const
@@ -3257,8 +3257,10 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_uint16_type),
                         jl_emptysvec,
                         0, 1, 10);
-    //const static uint32_t method_constfields[1] = { 0x03fc065f }; // (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<6)|(1<<9)|(1<<10)|(1<<18)|(1<<19)|(1<<20)|(1<<21)|(1<<22)|(1<<23)|(1<<24)|(1<<25);
+    //const static uint32_t method_constfields[1] = { 0x03fc065f }; // (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<6)|(1<<9)|(1<<10)|(1<<18)|(1<<19)|(1<<20)|(1<<21)|(1<<22)|(1<<23)|(1<<24)|(1<<25);
     //jl_method_type->name->constfields = method_constfields;
+    const static uint32_t method_atomicfields[1] = { 0x00000030 }; // (1<<4)|(1<<5)
+    jl_method_type->name->atomicfields = method_atomicfields;
 
     jl_method_instance_type =
         jl_new_datatype(jl_symbol("MethodInstance"), core,
@@ -3333,7 +3335,7 @@ void jl_init_types(void) JL_GC_DISABLED
                         0, 1, 1);
     jl_svecset(jl_code_instance_type->types, 1, jl_code_instance_type);
     const static uint32_t code_instance_constfields[1]  = { 0b0000010101110001 }; // Set fields 1, 5-7, 9, 11 as const
-    const static uint32_t code_instance_atomicfields[1] = { 0b1101001010000010 }; // Set fields 2, 8, 10, 13, 15-16 as atomic
+    const static uint32_t code_instance_atomicfields[1] = { 0b1101001010001110 }; // Set fields 2-4, 8, 10, 13, 15-16 as atomic
     //Fields 3-4 are only operated on by construction and deserialization, so are const at runtime
     //Fields 11 and 15 must be protected by locks, and thus all operations on jl_code_instance_t are threadsafe
     jl_code_instance_type->name->constfields = code_instance_constfields;
diff --git a/src/julia.h b/src/julia.h
index 3e794e85030fe..43df87fd45266 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -321,8 +321,8 @@ typedef struct _jl_method_t {
     struct _jl_module_t *module;
     jl_sym_t *file;
     int32_t line;
-    size_t primary_world;
-    size_t deleted_world;
+    _Atomic(size_t) primary_world;
+    _Atomic(size_t) deleted_world;
 
     // method's type signature. redundant with TypeMapEntry->specTypes
     jl_value_t *sig;
@@ -415,8 +415,8 @@ typedef struct _jl_code_instance_t {
     _Atomic(struct _jl_code_instance_t*) next; // pointer to the next cache entry
 
     // world range for which this object is valid to use
-    size_t min_world;
-    size_t max_world;
+    _Atomic(size_t) min_world;
+    _Atomic(size_t) max_world;
 
     // inference state cache
     jl_value_t *rettype; // return type for fptr
@@ -625,7 +625,6 @@ typedef struct _jl_module_t {
     arraylist_t usings;  // modules with all bindings potentially imported
     jl_uuid_t build_id;
     jl_uuid_t uuid;
-    size_t primary_world;
     _Atomic(uint32_t) counter;
     int32_t nospecialize;  // global bit flags: initialization for new methods
     int8_t optlevel;
@@ -650,8 +649,8 @@ typedef struct _jl_typemap_entry_t {
     jl_tupletype_t *sig; // the type signature for this entry
     jl_tupletype_t *simplesig; // a simple signature for fast rejection
     jl_svec_t *guardsigs;
-    size_t min_world;
-    size_t max_world;
+    _Atomic(size_t) min_world;
+    _Atomic(size_t) max_world;
     union {
         jl_value_t *value; // generic accessor
         jl_method_instance_t *linfo; // [nullable] for guard entries
@@ -958,6 +957,7 @@ extern void JL_GC_PUSH5(void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT
 extern void JL_GC_PUSH6(void *, void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT;
 extern void JL_GC_PUSH7(void *, void *, void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT;
 extern void JL_GC_PUSH8(void *, void *, void *, void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT;
+extern void JL_GC_PUSH9(void *, void *, void *, void *, void *, void *, void *, void *, void *)  JL_NOTSAFEPOINT;
 extern void _JL_GC_PUSHARGS(jl_value_t **, size_t) JL_NOTSAFEPOINT;
 // This is necessary, because otherwise the analyzer considers this undefined
 // behavior and terminates the exploration
@@ -997,10 +997,15 @@ extern void JL_GC_POP() JL_NOTSAFEPOINT;
 #define JL_GC_PUSH7(arg1, arg2, arg3, arg4, arg5, arg6, arg7)                                           \
   void *__gc_stkf[] = {(void*)JL_GC_ENCODE_PUSH(7), jl_pgcstack, arg1, arg2, arg3, arg4, arg5, arg6, arg7}; \
   jl_pgcstack = (jl_gcframe_t*)__gc_stkf;
+
 #define JL_GC_PUSH8(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)                                     \
   void *__gc_stkf[] = {(void*)JL_GC_ENCODE_PUSH(8), jl_pgcstack, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8}; \
   jl_pgcstack = (jl_gcframe_t*)__gc_stkf;
 
+#define JL_GC_PUSH9(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)                               \
+  void *__gc_stkf[] = {(void*)JL_GC_ENCODE_PUSH(9), jl_pgcstack, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9}; \
+  jl_pgcstack = (jl_gcframe_t*)__gc_stkf;
+
 
 #define JL_GC_PUSHARGS(rts_var,n)                                                                       \
   rts_var = ((jl_value_t**)alloca(((n)+2)*sizeof(jl_value_t*)))+2;                                      \
diff --git a/src/julia_internal.h b/src/julia_internal.h
index b85ccdede884d..94b7e5609f06d 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -337,7 +337,6 @@ extern JL_DLLEXPORT size_t jl_page_size;
 extern jl_function_t *jl_typeinf_func JL_GLOBALLY_ROOTED;
 extern JL_DLLEXPORT size_t jl_typeinf_world;
 extern _Atomic(jl_typemap_entry_t*) call_cache[N_CALL_CACHE] JL_GLOBALLY_ROOTED;
-extern jl_array_t *jl_all_methods JL_GLOBALLY_ROOTED;
 
 JL_DLLEXPORT extern int jl_lineno;
 JL_DLLEXPORT extern const char *jl_filename;
@@ -715,6 +714,8 @@ int jl_has_concrete_subtype(jl_value_t *typ);
 jl_tupletype_t *jl_inst_arg_tuple_type(jl_value_t *arg1, jl_value_t **args, size_t nargs, int leaf);
 jl_tupletype_t *jl_lookup_arg_tuple_type(jl_value_t *arg1 JL_PROPAGATES_ROOT, jl_value_t **args, size_t nargs, int leaf);
 JL_DLLEXPORT void jl_method_table_insert(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype);
+void jl_method_table_activate(jl_methtable_t *mt, jl_typemap_entry_t *newentry);
+jl_typemap_entry_t *jl_method_table_add(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype);
 jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_args_t fptr) JL_GC_DISABLED;
 int jl_obviously_unequal(jl_value_t *a, jl_value_t *b);
 JL_DLLEXPORT jl_array_t *jl_find_free_typevars(jl_value_t *v);
diff --git a/src/method.c b/src/method.c
index 30bf9c5774f11..3d3cc4cb7ea4e 100644
--- a/src/method.c
+++ b/src/method.c
@@ -625,7 +625,9 @@ JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo, siz
 
     JL_TRY {
         ct->ptls->in_pure_callback = 1;
-        ct->world_age = def->primary_world;
+        ct->world_age = jl_atomic_load_relaxed(&def->primary_world);
+        if (ct->world_age > jl_atomic_load_acquire(&jl_world_counter) || jl_atomic_load_relaxed(&def->deleted_world) < ct->world_age)
+            jl_error("The generator method cannot run until it is added to a method table.");
 
         // invoke code generator
         jl_tupletype_t *ttdt = (jl_tupletype_t*)jl_unwrap_unionall(tt);
@@ -851,8 +853,8 @@ JL_DLLEXPORT jl_method_t *jl_new_method_uninit(jl_module_t *module)
     m->recursion_relation = NULL;
     m->isva = 0;
     m->nargs = 0;
-    m->primary_world = 1;
-    m->deleted_world = ~(size_t)0;
+    jl_atomic_store_relaxed(&m->primary_world, ~(size_t)0);
+    jl_atomic_store_relaxed(&m->deleted_world, 1);
     m->is_for_opaque_closure = 0;
     m->nospecializeinfer = 0;
     m->constprop = 0;
@@ -1008,8 +1010,6 @@ JL_DLLEXPORT jl_methtable_t *jl_method_get_table(jl_method_t *method JL_PROPAGAT
     return method->external_mt ? (jl_methtable_t*)method->external_mt : jl_method_table_for(method->sig);
 }
 
-jl_array_t *jl_all_methods JL_GLOBALLY_ROOTED;
-
 JL_DLLEXPORT jl_method_t* jl_method_def(jl_svec_t *argdata,
                                         jl_methtable_t *mt,
                                         jl_code_info_t *f,
@@ -1139,16 +1139,6 @@ JL_DLLEXPORT jl_method_t* jl_method_def(jl_svec_t *argdata,
     m->line = line;
     jl_method_set_source(m, f);
 
-#ifdef RECORD_METHOD_ORDER
-    if (jl_all_methods == NULL)
-        jl_all_methods = jl_alloc_vec_any(0);
-#endif
-    if (jl_all_methods != NULL) {
-        while (jl_array_nrows(jl_all_methods) < m->primary_world)
-            jl_array_ptr_1d_push(jl_all_methods, NULL);
-        jl_array_ptr_1d_push(jl_all_methods, (jl_value_t*)m);
-    }
-
     jl_method_table_insert(mt, m, NULL);
     if (jl_newmeth_tracer)
         jl_call_tracer(jl_newmeth_tracer, (jl_value_t*)m);
diff --git a/src/module.c b/src/module.c
index f44238e45c659..787ea947d0480 100644
--- a/src/module.c
+++ b/src/module.c
@@ -29,7 +29,6 @@ JL_DLLEXPORT jl_module_t *jl_new_module_(jl_sym_t *name, jl_module_t *parent, ui
     if (!m->build_id.lo)
         m->build_id.lo++; // build id 0 is invalid
     m->build_id.hi = ~(uint64_t)0;
-    m->primary_world = 0;
     jl_atomic_store_relaxed(&m->counter, 1);
     m->nospecialize = 0;
     m->optlevel = -1;
diff --git a/src/opaque_closure.c b/src/opaque_closure.c
index 7fd6d5a0f8666..0b0d1052bd449 100644
--- a/src/opaque_closure.c
+++ b/src/opaque_closure.c
@@ -146,12 +146,15 @@ JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tuplet
     root = jl_new_struct(jl_linenumbernode_type, root, file);
     jl_method_t *meth = jl_make_opaque_closure_method(mod, jl_nothing, nargs, root, ci, isva);
     root = (jl_value_t*)meth;
-    meth->primary_world = jl_current_task->world_age;
+    size_t world = jl_current_task->world_age;
+    // these are only legal in the current world since they are not in any tables
+    jl_atomic_store_release(&meth->primary_world, world);
+    jl_atomic_store_release(&meth->deleted_world, world);
 
     sigtype = jl_argtype_with_function(env, (jl_value_t*)argt);
     jl_method_instance_t *mi = jl_specializations_get_linfo((jl_method_t*)root, sigtype, jl_emptysvec);
     inst = jl_new_codeinst(mi, rt_ub, (jl_value_t*)jl_any_type, NULL, (jl_value_t*)ci,
-        0, meth->primary_world, -1, 0, 0, jl_nothing, 0);
+        0, world, world, 0, 0, jl_nothing, 0);
     jl_mi_cache_insert(mi, inst);
 
     jl_opaque_closure_t *oc = new_opaque_closure(argt, rt_lb, rt_ub, root, env, do_compile);
diff --git a/src/options.h b/src/options.h
index 8d02703ce7bbe..da8d38e1b6a38 100644
--- a/src/options.h
+++ b/src/options.h
@@ -33,11 +33,6 @@
 // delete julia IR for non-inlineable functions after they're codegen'd
 #define JL_DELETE_NON_INLINEABLE 1
 
-// fill in the jl_all_methods in world-counter order
-// so that it is possible to map (in a debugger) from
-// an inferred world validity range back to the offending definition
-// #define RECORD_METHOD_ORDER
-
 // GC options -----------------------------------------------------------------
 
 // debugging options
diff --git a/src/staticdata.c b/src/staticdata.c
index 88304e0525e25..e7ebcea7bd061 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -1157,7 +1157,6 @@ static void jl_write_module(jl_serializer_state *s, uintptr_t item, jl_module_t
     jl_atomic_store_relaxed(&newm->bindingkeyset, NULL);
     arraylist_push(&s->relocs_list, (void*)(reloc_offset + offsetof(jl_module_t, bindingkeyset)));
     arraylist_push(&s->relocs_list, (void*)backref_id(s, jl_atomic_load_relaxed(&m->bindingkeyset), s->link_ids_relocs));
-    newm->primary_world = ~(size_t)0;
 
     // write out the usings list
     memset(&newm->usings._space, 0, sizeof(newm->usings._space));
@@ -1562,16 +1561,17 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
             if (s->incremental && jl_typetagis(v, jl_typemap_entry_type)) {
                 assert(f == s->s);
                 jl_typemap_entry_t *newentry = (jl_typemap_entry_t*)&s->s->buf[reloc_offset];
-                if (newentry->max_world == ~(size_t)0) {
-                    if (newentry->min_world > 1) {
-                        newentry->min_world = ~(size_t)0;
+                if (jl_atomic_load_relaxed(&newentry->max_world) == ~(size_t)0) {
+                    if (jl_atomic_load_relaxed(&newentry->min_world) > 1) {
+                        jl_atomic_store_release(&newentry->min_world, ~(size_t)0);
+                        jl_atomic_store_release(&newentry->max_world, WORLD_AGE_REVALIDATION_SENTINEL);
                         arraylist_push(&s->fixup_objs, (void*)reloc_offset);
                     }
                 }
                 else {
                     // garbage newentry - delete it :(
-                    newentry->min_world = 1;
-                    newentry->max_world = 0;
+                    jl_atomic_store_release(&newentry->min_world, 1);
+                    jl_atomic_store_release(&newentry->max_world, 0);
                 }
             }
             else if (jl_is_method(v)) {
@@ -1580,12 +1580,19 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 jl_method_t *m = (jl_method_t*)v;
                 jl_method_t *newm = (jl_method_t*)&f->buf[reloc_offset];
                 if (s->incremental) {
-                    if (newm->deleted_world != ~(size_t)0)
-                        newm->deleted_world = 1;
-                    else
-                        arraylist_push(&s->fixup_objs, (void*)reloc_offset);
-                    newm->primary_world = ~(size_t)0;
-                } else {
+                    if (jl_atomic_load_relaxed(&newm->deleted_world) == ~(size_t)0) {
+                        if (jl_atomic_load_relaxed(&newm->primary_world) > 1) {
+                            jl_atomic_store_relaxed(&newm->primary_world, ~(size_t)0); // min-world
+                            jl_atomic_store_relaxed(&newm->deleted_world, 1); // max_world
+                            arraylist_push(&s->fixup_objs, (void*)reloc_offset);
+                        }
+                    }
+                    else {
+                        jl_atomic_store_relaxed(&newm->primary_world, 1);
+                        jl_atomic_store_relaxed(&newm->deleted_world, 0);
+                    }
+                }
+                else {
                     newm->nroots_sysimg = m->roots ? jl_array_len(m->roots) : 0;
                 }
                 if (m->ccallable)
@@ -1604,19 +1611,18 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 jl_code_instance_t *newci = (jl_code_instance_t*)&f->buf[reloc_offset];
 
                 if (s->incremental) {
-                    arraylist_push(&s->fixup_objs, (void*)reloc_offset);
-                    if (ci->min_world > 1)
-                        newci->min_world = ~(size_t)0;     // checks that we reprocess this upon deserialization
-                    if (ci->max_world != ~(size_t)0)
-                        newci->max_world = 0;
-                    else {
-                        if (jl_atomic_load_relaxed(&ci->inferred) && ptrhash_has(&s->callers_with_edges, ci->def))
-                            newci->max_world = WORLD_AGE_REVALIDATION_SENTINEL;
-                        if (ci->min_world > 0 && jl_atomic_load_relaxed(&ci->inferred) ) {
-                            // TODO: also check if this object is part of the codeinst cache
-                            // will check on deserialize if this cache entry is still valid
+                    if (jl_atomic_load_relaxed(&ci->max_world) == ~(size_t)0) {
+                        if (jl_atomic_load_relaxed(&newci->min_world) > 1) {
+                            jl_atomic_store_release(&newci->min_world, ~(size_t)0);
+                            jl_atomic_store_release(&newci->max_world, WORLD_AGE_REVALIDATION_SENTINEL);
+                            arraylist_push(&s->fixup_objs, (void*)reloc_offset);
                         }
                     }
+                    else {
+                        // garbage object - delete it :(
+                        jl_atomic_store_release(&newci->min_world, 1);
+                        jl_atomic_store_release(&newci->max_world, 0);
+                    }
                 }
                 jl_atomic_store_relaxed(&newci->invoke, NULL);
                 jl_atomic_store_relaxed(&newci->specsigflags, 0);
@@ -2447,6 +2453,8 @@ static void jl_strip_all_codeinfos(void)
 jl_genericmemory_t *jl_global_roots_list;
 jl_genericmemory_t *jl_global_roots_keyset;
 jl_mutex_t global_roots_lock;
+extern jl_mutex_t world_counter_lock;
+extern size_t jl_require_world;
 
 JL_DLLEXPORT int jl_is_globally_rooted(jl_value_t *val JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT
 {
@@ -3047,7 +3055,7 @@ extern void export_jl_small_typeof(void);
 
 static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl_array_t *depmods, uint64_t checksum,
                                 /* outputs */    jl_array_t **restored,         jl_array_t **init_order,
-                                                 jl_array_t **extext_methods,
+                                                 jl_array_t **extext_methods, jl_array_t **internal_methods,
                                                  jl_array_t **new_ext_cis, jl_array_t **method_roots_list,
                                                  jl_array_t **ext_targets, jl_array_t **edges,
                                                  char **base, arraylist_t *ccallable_list, pkgcachesizes *cachesizes) JL_GC_DISABLED
@@ -3133,12 +3141,12 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         jl_init_box_caches();
 
         uint32_t gs_ctr = read_uint32(f);
-        jl_atomic_store_release(&jl_world_counter, read_uint(f));
+        jl_require_world = read_uint(f);
+        jl_atomic_store_release(&jl_world_counter, jl_require_world);
         jl_typeinf_world = read_uint(f);
         jl_set_gs_ctr(gs_ctr);
     }
     else {
-        jl_atomic_fetch_add(&jl_world_counter, 1);
         offset_restored = jl_read_offset(&s);
         offset_init_order = jl_read_offset(&s);
         offset_extext_methods = jl_read_offset(&s);
@@ -3171,7 +3179,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     uint32_t external_fns_begin = read_uint32(f);
     jl_read_arraylist(s.s, ccallable_list ? ccallable_list : &s.ccallable_list);
     if (s.incremental) {
-        assert(restored && init_order && extext_methods && new_ext_cis && method_roots_list && ext_targets && edges);
+        assert(restored && init_order && extext_methods && internal_methods && new_ext_cis && method_roots_list && ext_targets && edges);
         *restored = (jl_array_t*)jl_delayed_reloc(&s, offset_restored);
         *init_order = (jl_array_t*)jl_delayed_reloc(&s, offset_init_order);
         *extext_methods = (jl_array_t*)jl_delayed_reloc(&s, offset_extext_methods);
@@ -3179,6 +3187,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         *method_roots_list = (jl_array_t*)jl_delayed_reloc(&s, offset_method_roots_list);
         *ext_targets = (jl_array_t*)jl_delayed_reloc(&s, offset_ext_targets);
         *edges = (jl_array_t*)jl_delayed_reloc(&s, offset_edges);
+        *internal_methods = jl_alloc_vec_any(0);
     }
     s.s = NULL;
 
@@ -3368,7 +3377,6 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         jl_cache_type_((jl_datatype_t*)obj);
     }
     // Perform fixups: things like updating world ages, inserting methods & specializations, etc.
-    size_t world = jl_atomic_load_acquire(&jl_world_counter);
     for (size_t i = 0; i < s.uniquing_objs.len; i++) {
         uintptr_t item = (uintptr_t)s.uniquing_objs.items[i];
         // check whether this is a gvar index
@@ -3425,34 +3433,29 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     for (size_t i = 0; i < s.fixup_objs.len; i++) {
         uintptr_t item = (uintptr_t)s.fixup_objs.items[i];
         jl_value_t *obj = (jl_value_t*)(image_base + item);
-        if (jl_typetagis(obj, jl_typemap_entry_type)) {
-            jl_typemap_entry_t *entry = (jl_typemap_entry_t*)obj;
-            entry->min_world = world;
-        }
-        else if (jl_is_method(obj)) {
-            jl_method_t *m = (jl_method_t*)obj;
-            m->primary_world = world;
+        if (jl_typetagis(obj, jl_typemap_entry_type) || jl_is_method(obj) || jl_is_code_instance(obj)) {
+            jl_array_ptr_1d_push(*internal_methods, obj);
+            assert(s.incremental);
         }
         else if (jl_is_method_instance(obj)) {
             jl_method_instance_t *newobj = jl_specializations_get_or_insert((jl_method_instance_t*)obj);
             assert(newobj == (jl_method_instance_t*)obj); // strict insertion expected
             (void)newobj;
         }
-        else if (jl_is_code_instance(obj)) {
-            jl_code_instance_t *ci = (jl_code_instance_t*)obj;
-            assert(s.incremental);
-            ci->min_world = world;
-        }
         else if (jl_is_globalref(obj)) {
-            continue; // wait until all the module binding tables have been initialized
+            jl_globalref_t *r = (jl_globalref_t*)obj;
+            if (r->binding == NULL) {
+                jl_globalref_t *gr = (jl_globalref_t*)jl_module_globalref(r->mod, r->name);
+                r->binding = gr->binding;
+                jl_gc_wb(r, gr->binding);
+            }
         }
         else if (jl_is_module(obj)) {
-            // rebuild the binding table for module v
+            // rebuild the usings table for module v
             // TODO: maybe want to hold the lock on `v`, but that only strongly matters for async / thread safety
             // and we are already bad at that
             jl_module_t *mod = (jl_module_t*)obj;
             mod->build_id.hi = checksum;
-            mod->primary_world = world;
             if (mod->usings.items != &mod->usings._space[0]) {
                 // arraylist_t assumes we called malloc to get this memory, so make that true now
                 void **newitems = (void**)malloc_s(mod->usings.max * sizeof(void*));
@@ -3464,19 +3467,6 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
             abort();
         }
     }
-    // Now pick up the globalref binding pointer field
-    for (size_t i = 0; i < s.fixup_objs.len; i++) {
-        uintptr_t item = (uintptr_t)s.fixup_objs.items[i];
-        jl_value_t *obj = (jl_value_t*)(image_base + item);
-        if (jl_is_globalref(obj)) {
-            jl_globalref_t *r = (jl_globalref_t*)obj;
-            if (r->binding == NULL) {
-                jl_globalref_t *gr = (jl_globalref_t*)jl_module_globalref(r->mod, r->name);
-                r->binding = gr->binding;
-                jl_gc_wb(r, gr->binding);
-            }
-        }
-    }
     arraylist_free(&s.fixup_types);
     arraylist_free(&s.fixup_objs);
 
@@ -3543,6 +3533,9 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
 
     // jl_printf(JL_STDOUT, "%ld blobs to link against\n", jl_linkage_blobs.len >> 1);
     jl_gc_enable(en);
+
+    if (s.incremental)
+        jl_add_methods(*extext_methods);
 }
 
 static jl_value_t *jl_validate_cache_file(ios_t *f, jl_array_t *depmods, uint64_t *checksum, int64_t *dataendpos, int64_t *datastartpos)
@@ -3586,12 +3579,13 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
 
     assert(datastartpos > 0 && datastartpos < dataendpos);
     needs_permalloc = jl_options.permalloc_pkgimg || needs_permalloc;
-    jl_value_t *restored = NULL;
-    jl_array_t *init_order = NULL, *extext_methods = NULL, *new_ext_cis = NULL, *method_roots_list = NULL, *ext_targets = NULL, *edges = NULL;
-    jl_svec_t *cachesizes_sv = NULL;
     char *base;
     arraylist_t ccallable_list;
-    JL_GC_PUSH8(&restored, &init_order, &extext_methods, &new_ext_cis, &method_roots_list, &ext_targets, &edges, &cachesizes_sv);
+
+    jl_value_t *restored = NULL;
+    jl_array_t *init_order = NULL, *extext_methods = NULL, *internal_methods = NULL, *new_ext_cis = NULL, *method_roots_list = NULL, *ext_targets = NULL, *edges = NULL;
+    jl_svec_t *cachesizes_sv = NULL;
+    JL_GC_PUSH9(&restored, &init_order, &extext_methods, &internal_methods, &new_ext_cis, &method_roots_list, &ext_targets, &edges, &cachesizes_sv);
 
     { // make a permanent in-memory copy of f (excluding the header)
         ios_bufmode(f, bm_none);
@@ -3615,18 +3609,24 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
                 ios_close(f);
             ios_static_buffer(f, sysimg, len);
             pkgcachesizes cachesizes;
-            jl_restore_system_image_from_stream_(f, image, depmods, checksum, (jl_array_t**)&restored, &init_order, &extext_methods, &new_ext_cis, &method_roots_list,
+            jl_restore_system_image_from_stream_(f, image, depmods, checksum, (jl_array_t**)&restored, &init_order, &extext_methods, &internal_methods, &new_ext_cis, &method_roots_list,
                                                  &ext_targets, &edges, &base, &ccallable_list, &cachesizes);
             JL_SIGATOMIC_END();
 
-            // Insert method extensions
-            jl_insert_methods(extext_methods);
             // No special processing of `new_ext_cis` is required because recaching handled it
             // Add roots to methods
             jl_copy_roots(method_roots_list, jl_worklist_key((jl_array_t*)restored));
-            // Handle edges
-            size_t world = jl_atomic_load_acquire(&jl_world_counter);
+            // Insert method extensions and handle edges
+            JL_LOCK(&world_counter_lock);
+              // allocate a world for the new methods, and insert them there, invalidating content as needed
+            size_t world = jl_atomic_load_relaxed(&jl_world_counter) + 1;
+            jl_activate_methods(extext_methods, internal_methods, world);
+              // allow users to start running in this updated world
+            jl_atomic_store_release(&jl_world_counter, world);
+              // but one of those immediate users is going to be our cache updates
             jl_insert_backedges((jl_array_t*)edges, (jl_array_t*)ext_targets, (jl_array_t*)new_ext_cis, world); // restore external backedges (needs to be last)
+              // now permit more methods to be added again
+            JL_UNLOCK(&world_counter_lock);
             // reinit ccallables
             jl_reinit_ccallable(&ccallable_list, base, pkgimage_handle);
             arraylist_free(&ccallable_list);
@@ -3641,8 +3641,8 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
                 jl_svecset(cachesizes_sv, 5, jl_box_long(cachesizes.gvarlist));
                 jl_svecset(cachesizes_sv, 6, jl_box_long(cachesizes.fptrlist));
                 restored = (jl_value_t*)jl_svec(8, restored, init_order, extext_methods,
-                                                   new_ext_cis ? (jl_value_t*)new_ext_cis : jl_nothing, method_roots_list,
-                                                   ext_targets, edges, cachesizes_sv);
+                                                   new_ext_cis ? (jl_value_t*)new_ext_cis : jl_nothing,
+                                                   method_roots_list, ext_targets, edges, cachesizes_sv);
             }
             else {
                 restored = (jl_value_t*)jl_svec(2, restored, init_order);
@@ -3657,7 +3657,7 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
 static void jl_restore_system_image_from_stream(ios_t *f, jl_image_t *image, uint32_t checksum)
 {
     JL_TIMING(LOAD_IMAGE, LOAD_Sysimg);
-    jl_restore_system_image_from_stream_(f, image, NULL, checksum | ((uint64_t)0xfdfcfbfa << 32), NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+    jl_restore_system_image_from_stream_(f, image, NULL, checksum | ((uint64_t)0xfdfcfbfa << 32), NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 JL_DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(void* pkgimage_handle, const char *buf, jl_image_t *image, size_t sz, jl_array_t *depmods, int completeinfo, const char *pkgname, int needs_permalloc)
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index 982f4b104eb74..199724e54ae00 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -85,6 +85,7 @@ static uint64_t jl_worklist_key(jl_array_t *worklist) JL_NOTSAFEPOINT
 static jl_array_t *newly_inferred JL_GLOBALLY_ROOTED /*FIXME*/;
 // Mutex for newly_inferred
 jl_mutex_t newly_inferred_mutex;
+extern jl_mutex_t world_counter_lock;
 
 // Register array of newly-inferred MethodInstances
 // This gets called as the first step of Base.include_package_for_output
@@ -237,7 +238,7 @@ static jl_array_t *queue_external_cis(jl_array_t *list)
             int found = has_backedge_to_worklist(mi, &visited, &stack);
             assert(found == 0 || found == 1 || found == 2);
             assert(stack.len == 0);
-            if (found == 1 && ci->max_world == ~(size_t)0) {
+            if (found == 1 && jl_atomic_load_relaxed(&ci->max_world) == ~(size_t)0) {
                 void **bp = ptrhash_bp(&visited, mi);
                 if (*bp != (void*)((char*)HT_NOTFOUND + 3)) {
                     *bp = (void*)((char*)HT_NOTFOUND + 3);
@@ -828,16 +829,57 @@ static int64_t write_dependency_list(ios_t *s, jl_array_t* worklist, jl_array_t
 // Deserialization
 
 // Add methods to external (non-worklist-owned) functions
-static void jl_insert_methods(jl_array_t *list)
+// mutating external to point at the new methodtable entry instead of the new method
+static void jl_add_methods(jl_array_t *external)
 {
-    size_t i, l = jl_array_nrows(list);
+    size_t i, l = jl_array_nrows(external);
     for (i = 0; i < l; i++) {
-        jl_method_t *meth = (jl_method_t*)jl_array_ptr_ref(list, i);
+        jl_method_t *meth = (jl_method_t*)jl_array_ptr_ref(external, i);
         assert(jl_is_method(meth));
         assert(!meth->is_for_opaque_closure);
         jl_methtable_t *mt = jl_method_get_table(meth);
         assert((jl_value_t*)mt != jl_nothing);
-        jl_method_table_insert(mt, meth, NULL);
+        jl_typemap_entry_t *entry = jl_method_table_add(mt, meth, NULL);
+        jl_array_ptr_set(external, i, entry);
+    }
+}
+
+static void jl_activate_methods(jl_array_t *external, jl_array_t *internal, size_t world)
+{
+    size_t i, l = jl_array_nrows(internal);
+    for (i = 0; i < l; i++) {
+        jl_value_t *obj = jl_array_ptr_ref(internal, i);
+        if (jl_typetagis(obj, jl_typemap_entry_type)) {
+            jl_typemap_entry_t *entry = (jl_typemap_entry_t*)obj;
+            assert(jl_atomic_load_relaxed(&entry->min_world) == ~(size_t)0);
+            assert(jl_atomic_load_relaxed(&entry->max_world) == WORLD_AGE_REVALIDATION_SENTINEL);
+            jl_atomic_store_release(&entry->min_world, world);
+            jl_atomic_store_release(&entry->max_world, ~(size_t)0);
+        }
+        else if (jl_is_method(obj)) {
+            jl_method_t *m = (jl_method_t*)obj;
+            assert(jl_atomic_load_relaxed(&m->primary_world) == ~(size_t)0);
+            assert(jl_atomic_load_relaxed(&m->deleted_world) == WORLD_AGE_REVALIDATION_SENTINEL);
+            jl_atomic_store_release(&m->primary_world, world);
+            jl_atomic_store_release(&m->deleted_world, ~(size_t)0);
+        }
+        else if (jl_is_code_instance(obj)) {
+            jl_code_instance_t *ci = (jl_code_instance_t*)obj;
+            assert(jl_atomic_load_relaxed(&ci->min_world) == ~(size_t)0);
+            assert(jl_atomic_load_relaxed(&ci->max_world) == WORLD_AGE_REVALIDATION_SENTINEL);
+            jl_atomic_store_relaxed(&ci->min_world, world);
+            // n.b. ci->max_world is not updated until edges are verified
+        }
+        else {
+            abort();
+        }
+    }
+    l = jl_array_nrows(external);
+    for (i = 0; i < l; i++) {
+        jl_typemap_entry_t *entry = (jl_typemap_entry_t*)jl_array_ptr_ref(external, i);
+        jl_methtable_t *mt = jl_method_get_table(entry->func.method);
+        assert((jl_value_t*)mt != jl_nothing);
+        jl_method_table_activate(mt, entry);
     }
 }
 
@@ -880,7 +922,7 @@ static jl_array_t *jl_verify_edges(jl_array_t *targets, size_t minworld)
             jl_method_t *m = ((jl_method_instance_t*)callee)->def.method;
             if (jl_egal(invokesig, m->sig)) {
                 // the invoke match is `m` for `m->sig`, unless `m` is invalid
-                if (m->deleted_world < max_valid)
+                if (jl_atomic_load_relaxed(&m->deleted_world) < max_valid)
                     max_valid = 0;
             }
             else {
@@ -958,7 +1000,7 @@ static jl_array_t *jl_verify_edges(jl_array_t *targets, size_t minworld)
         }
         //jl_static_show((JL_STREAM*)ios_stderr, (jl_value_t*)invokesig);
         //jl_static_show((JL_STREAM*)ios_stderr, (jl_value_t*)callee);
-        //ios_puts(valid ? "valid\n" : "INVALID\n", ios_stderr);
+        //ios_puts(max_valid == ~(size_t)0 ? "valid\n" : "INVALID\n", ios_stderr);
     }
     JL_GC_POP();
     return maxvalids;
@@ -1005,7 +1047,7 @@ static jl_array_t *jl_verify_methods(jl_array_t *edges, jl_array_t *maxvalids)
             }
         }
         //jl_static_show((JL_STREAM*)ios_stderr, (jl_value_t*)caller);
-        //ios_puts(maxvalid2_data[i] == ~(size_t)0 ? "valid\n" : "INVALID\n", ios_stderr);
+        //ios_puts(maxvalids2_data[i] == ~(size_t)0 ? "valid\n" : "INVALID\n", ios_stderr);
     }
     JL_GC_POP();
     return maxvalids2;
@@ -1118,17 +1160,18 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
     // next build a map from external MethodInstances to their CodeInstance for insertion
     for (size_t i = 0; i < n_ext_cis; i++) {
         jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(ext_ci_list, i);
-        assert(ci->min_world == minworld);
-        if (ci->max_world == WORLD_AGE_REVALIDATION_SENTINEL) {
+        if (jl_atomic_load_relaxed(&ci->max_world) == WORLD_AGE_REVALIDATION_SENTINEL) {
+            assert(jl_atomic_load_relaxed(&ci->min_world) == minworld);
             ptrhash_put(&cis_pending_validation, (void*)ci->def, (void*)ci);
         }
         else {
-            assert(ci->max_world == ~(size_t)0);
+            assert(jl_atomic_load_relaxed(&ci->min_world) == 1);
+            assert(jl_atomic_load_relaxed(&ci->max_world) == ~(size_t)0);
             jl_method_instance_t *caller = ci->def;
             if (jl_atomic_load_relaxed(&ci->inferred) && jl_rettype_inferred(caller, minworld, ~(size_t)0) == jl_nothing) {
                 jl_mi_cache_insert(caller, ci);
             }
-            //jl_static_show((jl_stream*)ios_stderr, (jl_value_t*)caller);
+            //jl_static_show((JL_STREAM*)ios_stderr, (jl_value_t*)caller);
             //ios_puts("free\n", ios_stderr);
         }
     }
@@ -1168,8 +1211,10 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
             // Update any external CIs and add them to the cache.
             assert(jl_is_code_instance(ci));
             jl_code_instance_t *codeinst = (jl_code_instance_t*)ci;
-            assert(codeinst->min_world == minworld && jl_atomic_load_relaxed(&codeinst->inferred) );
-            codeinst->max_world = maxvalid;
+            assert(jl_atomic_load_relaxed(&codeinst->min_world) == minworld);
+            assert(jl_atomic_load_relaxed(&codeinst->max_world) == WORLD_AGE_REVALIDATION_SENTINEL);
+            assert(jl_atomic_load_relaxed(&codeinst->inferred));
+            jl_atomic_store_relaxed(&codeinst->max_world, maxvalid);
 
             if (jl_rettype_inferred(caller, minworld, maxvalid) != jl_nothing) {
                 // We already got a code instance for this world age range from somewhere else - we don't need
@@ -1178,14 +1223,13 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
             }
 
             jl_mi_cache_insert(caller, codeinst);
-        } else {
+        }
+        else {
             // Likely internal. Find the CI already in the cache hierarchy.
-            for (jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&caller->cache); codeinst; codeinst=jl_atomic_load_relaxed(&codeinst->next)) {
-                if (codeinst->min_world != minworld)
-                    continue;
-                if (codeinst->max_world != WORLD_AGE_REVALIDATION_SENTINEL)
-                    continue;
-                codeinst->max_world = maxvalid;
+            for (jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&caller->cache); codeinst; codeinst = jl_atomic_load_relaxed(&codeinst->next)) {
+                if (jl_atomic_load_relaxed(&codeinst->min_world) == minworld && jl_atomic_load_relaxed(&codeinst->max_world) == WORLD_AGE_REVALIDATION_SENTINEL) {
+                    jl_atomic_store_relaxed(&codeinst->max_world, maxvalid);
+                }
             }
         }
     }
diff --git a/src/toplevel.c b/src/toplevel.c
index 60d5b2f6310fd..e4438da991e1e 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -214,7 +214,6 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
         ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
         (void)jl_toplevel_eval_flex(newm, form, 1, 1);
     }
-    newm->primary_world = jl_atomic_load_acquire(&jl_world_counter);
     ct->world_age = last_age;
 
 #if 0
@@ -462,21 +461,24 @@ static void body_attributes(jl_array_t *body, int *has_ccall, int *has_defs, int
     *forced_compile = jl_has_meta(body, jl_force_compile_sym);
 }
 
+size_t jl_require_world = ~(size_t)0;
 static jl_module_t *call_require(jl_module_t *mod, jl_sym_t *var) JL_GLOBALLY_ROOTED
 {
     JL_TIMING(LOAD_IMAGE, LOAD_Require);
     jl_timing_printf(JL_TIMING_DEFAULT_BLOCK, "%s", jl_symbol_name(var));
 
-    static jl_value_t *require_func = NULL;
-    int build_mode = jl_generating_output();
+    int build_mode = jl_options.incremental && jl_generating_output();
     jl_module_t *m = NULL;
     jl_task_t *ct = jl_current_task;
+    static jl_value_t *require_func = NULL;
     if (require_func == NULL && jl_base_module != NULL) {
         require_func = jl_get_global(jl_base_module, jl_symbol("require"));
     }
     if (require_func != NULL) {
         size_t last_age = ct->world_age;
-        ct->world_age = (build_mode ? jl_base_module->primary_world : jl_atomic_load_acquire(&jl_world_counter));
+        ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
+        if (build_mode && jl_require_world < ct->world_age)
+            ct->world_age = jl_require_world;
         jl_value_t *reqargs[3];
         reqargs[0] = require_func;
         reqargs[1] = (jl_value_t*)mod;
diff --git a/src/typemap.c b/src/typemap.c
index 32fda9166f8f0..1f69d5da8af6e 100644
--- a/src/typemap.c
+++ b/src/typemap.c
@@ -531,9 +531,9 @@ static int jl_typemap_intersection_node_visitor(jl_typemap_entry_t *ml, struct t
     // that can be absolutely critical for speed
     register jl_typemap_intersection_visitor_fptr fptr = closure->fptr;
     for (;  ml != (void*)jl_nothing; ml = jl_atomic_load_relaxed(&ml->next)) {
-        if (closure->max_valid < ml->min_world)
+        if (closure->max_valid < jl_atomic_load_relaxed(&ml->min_world))
             continue;
-        if (closure->min_valid > ml->max_world)
+        if (closure->min_valid > jl_atomic_load_relaxed(&ml->max_world))
             continue;
         jl_svec_t **penv = NULL;
         if (closure->env) {
@@ -836,9 +836,9 @@ static jl_typemap_entry_t *jl_typemap_entry_assoc_by_type(
     size_t n = jl_nparams(unw);
     int typesisva = n == 0 ? 0 : jl_is_vararg(jl_tparam(unw, n-1));
     for (; ml != (void*)jl_nothing; ml = jl_atomic_load_relaxed(&ml->next)) {
-        if (search->max_valid < ml->min_world)
+        if (search->max_valid < jl_atomic_load_relaxed(&ml->min_world))
             continue;
-        if (search->min_valid > ml->max_world)
+        if (search->min_valid > jl_atomic_load_relaxed(&ml->max_world))
             continue;
         size_t lensig = jl_nparams(jl_unwrap_unionall((jl_value_t*)ml->sig));
         if (lensig == n || (ml->va && lensig <= n+1)) {
@@ -877,22 +877,24 @@ static jl_typemap_entry_t *jl_typemap_entry_assoc_by_type(
                     }
                 }
                 if (ismatch) {
-                    if (search->world < ml->min_world) {
+                    size_t min_world = jl_atomic_load_relaxed(&ml->min_world);
+                    size_t max_world = jl_atomic_load_relaxed(&ml->max_world);
+                    if (search->world < min_world) {
                         // ignore method table entries that are part of a later world
-                        if (search->max_valid >= ml->min_world)
-                            search->max_valid = ml->min_world - 1;
+                        if (search->max_valid >= min_world)
+                            search->max_valid = min_world - 1;
                     }
-                    else if (search->world > ml->max_world) {
+                    else if (search->world > max_world) {
                         // ignore method table entries that have been replaced in the current world
-                        if (search->min_valid <= ml->max_world)
-                            search->min_valid = ml->max_world + 1;
+                        if (search->min_valid <= max_world)
+                            search->min_valid = max_world + 1;
                     }
                     else {
                         // intersect the env valid range with method's valid range
-                        if (search->min_valid < ml->min_world)
-                            search->min_valid = ml->min_world;
-                        if (search->max_valid > ml->max_world)
-                            search->max_valid = ml->max_world;
+                        if (search->min_valid < min_world)
+                            search->min_valid = min_world;
+                        if (search->max_valid > max_world)
+                            search->max_valid = max_world;
                         return ml;
                     }
                 }
@@ -908,7 +910,7 @@ static jl_typemap_entry_t *jl_typemap_entry_lookup_by_type(
         jl_typemap_entry_t *ml, struct jl_typemap_assoc *search)
 {
     for (; ml != (void*)jl_nothing; ml = jl_atomic_load_relaxed(&ml->next)) {
-        if (search->world < ml->min_world || search->world > ml->max_world)
+        if (search->world < jl_atomic_load_relaxed(&ml->min_world) || search->world > jl_atomic_load_relaxed(&ml->max_world))
             continue;
         // unroll the first few cases here, to the extent that is possible to do fast and easily
         jl_value_t *types = search->types;
@@ -1120,7 +1122,7 @@ jl_typemap_entry_t *jl_typemap_entry_assoc_exact(jl_typemap_entry_t *ml, jl_valu
     // some manually-unrolled common special cases
     while (ml->simplesig == (void*)jl_nothing && ml->guardsigs == jl_emptysvec && ml->isleafsig) {
         // use a tight loop for as long as possible
-        if (world >= ml->min_world && world <= ml->max_world) {
+        if (world >= jl_atomic_load_relaxed(&ml->min_world) && world <= jl_atomic_load_relaxed(&ml->max_world)) {
             if (n == jl_nparams(ml->sig) && jl_typeof(arg1) == jl_tparam(ml->sig, 0)) {
                 if (n == 1)
                     return ml;
@@ -1145,7 +1147,7 @@ jl_typemap_entry_t *jl_typemap_entry_assoc_exact(jl_typemap_entry_t *ml, jl_valu
     }
 
     for (; ml != (void*)jl_nothing; ml = jl_atomic_load_relaxed(&ml->next)) {
-        if (world < ml->min_world || world > ml->max_world)
+        if (world < jl_atomic_load_relaxed(&ml->min_world) || world > jl_atomic_load_relaxed(&ml->max_world))
             continue; // ignore replaced methods
         size_t lensig = jl_nparams(ml->sig);
         if (lensig == n || (ml->va && lensig <= n+1)) {
@@ -1517,8 +1519,8 @@ jl_typemap_entry_t *jl_typemap_alloc(
     newrec->func.value = newvalue;
     newrec->guardsigs = guardsigs;
     jl_atomic_store_relaxed(&newrec->next, (jl_typemap_entry_t*)jl_nothing);
-    newrec->min_world = min_world;
-    newrec->max_world = max_world;
+    jl_atomic_store_relaxed(&newrec->min_world, min_world);
+    jl_atomic_store_relaxed(&newrec->max_world, max_world);
     newrec->va = isva;
     newrec->issimplesig = issimplesig;
     newrec->isleafsig = isleafsig;
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index 46081f38cf9aa..b03936afd5c03 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -1448,16 +1448,9 @@ function deserialize_typename(s::AbstractSerializer, number)
         tag = Int32(read(s.io, UInt8)::UInt8)
         if tag != UNDEFREF_TAG
             kws = handle_deserialize(s, tag)
-            if makenew
-                if kws isa Vector{Method}
-                    for def in kws
-                        kwmt = typeof(Core.kwcall).name.mt
-                        ccall(:jl_method_table_insert, Cvoid, (Any, Any, Ptr{Cvoid}), mt, def, C_NULL)
-                    end
-                else
-                    # old object format -- try to forward from old to new
-                    @eval Core.kwcall(kwargs::NamedTuple, f::$ty, args...) = $kws(kwargs, f, args...)
-                end
+            if makenew && !(kws isa Vector{Method})
+                # old object format -- try to forward from old to new
+                @eval Core.kwcall(kwargs::NamedTuple, f::$ty, args...) = $kws(kwargs, f, args...)
             end
         end
     elseif makenew
diff --git a/test/core.jl b/test/core.jl
index 050127a5621c5..4f67dd2c0bdbc 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -18,7 +18,7 @@ for (T, c) in (
         (Core.Method, [#=:name, :module, :file, :line, :primary_world, :sig, :slot_syms, :external_mt, :nargs, :called, :nospecialize, :nkw, :isva, :is_for_opaque_closure, :constprop=#]),
         (Core.MethodInstance, [#=:def, :specTypes, :sparam_vals=#]),
         (Core.MethodTable, [:module]),
-        (Core.TypeMapEntry, [:sig, :simplesig, :guardsigs, :min_world, :max_world, :func, :isleafsig, :issimplesig, :va]),
+        (Core.TypeMapEntry, [:sig, :simplesig, :guardsigs, :func, :isleafsig, :issimplesig, :va]),
         (Core.TypeMapLevel, []),
         (Core.TypeName, [:name, :module, :names, :wrapper, :mt, :hash, :n_uninitialized, :flags]),
         (DataType, [:name, :super, :parameters, :instance, :hash]),
@@ -32,11 +32,11 @@ end
 # sanity tests that our built-in types are marked correctly for atomic fields
 for (T, c) in (
         (Core.CodeInfo, []),
-        (Core.CodeInstance, [:next, :inferred, :purity_bits, :invoke, :specptr, :precompile]),
-        (Core.Method, []),
+        (Core.CodeInstance, [:next, :min_world, :max_world, :inferred, :purity_bits, :invoke, :specptr, :precompile]),
+        (Core.Method, [:primary_world, :deleted_world]),
         (Core.MethodInstance, [:uninferred, :cache, :precompiled]),
         (Core.MethodTable, [:defs, :leafcache, :cache, :max_args]),
-        (Core.TypeMapEntry, [:next]),
+        (Core.TypeMapEntry, [:next, :min_world, :max_world]),
         (Core.TypeMapLevel, [:arg1, :targ, :name1, :tname, :list, :any]),
         (Core.TypeName, [:cache, :linearcache]),
         (DataType, [:types, :layout]),
diff --git a/test/precompile.jl b/test/precompile.jl
index 8a6b81e1aa96e..1eed9b1418a63 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1799,7 +1799,7 @@ precompile_test_harness("PkgCacheInspector") do load_path
     end
 
     modules, init_order, external_methods, new_ext_cis, new_method_roots, external_targets, edges = sv
-    m = only(external_methods)
+    m = only(external_methods).func::Method
     @test m.name == :repl_cmd && m.nargs < 2
     @test new_ext_cis === nothing || any(new_ext_cis) do ci
         mi = ci.def

From 35a5711d4fa3c91265fa143dbfc4085171ac841f Mon Sep 17 00:00:00 2001
From: jam-khan <jamkhan@connect.hku.hk>
Date: Sun, 28 Jan 2024 10:43:26 -0500
Subject: [PATCH 0725/1315] Added reference to UnionAll manual for UnionAll
 docstrings. (#52838)

---
 base/docs/basedocs.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index bc7d001a06f51..ae0e350c1c138 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -2893,7 +2893,7 @@ Union
     UnionAll
 
 A union of types over all values of a type parameter. `UnionAll` is used to describe parametric types
-where the values of some parameters are not known.
+where the values of some parameters are not known. See the manual section on [UnionAll Types](@ref).
 
 # Examples
 ```jldoctest

From d298c44bc60eebdfc77b7f9c64ca913af1e5079d Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Sun, 28 Jan 2024 17:27:37 +0100
Subject: [PATCH 0726/1315] Document that findnext(f,x,i) and findprev(f,x,i)
 work for strings. (#52625)

---
 base/array.jl | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index 25c931f0aadd5..dc84a2fcad96c 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -2301,7 +2301,9 @@ findfirst(A::AbstractArray) = findnext(A, first(keys(A)))
     findnext(predicate::Function, A, i)
 
 Find the next index after or including `i` of an element of `A`
-for which `predicate` returns `true`, or `nothing` if not found.
+for which `predicate` returns `true`, or `nothing` if not found. This works for
+Arrays, Strings, and most other collections that support [`getindex`](@ref),
+[`keys(A)`](@ref), and [`nextind`](@ref).
 
 Indices are of the same type as those returned by [`keys(A)`](@ref)
 and [`pairs(A)`](@ref).
@@ -2319,6 +2321,9 @@ julia> A = [1 4; 2 2];
 
 julia> findnext(isodd, A, CartesianIndex(1, 1))
 CartesianIndex(1, 1)
+
+julia> findnext(isspace, "a b c", 3)
+4
 ```
 """
 function findnext(testf::Function, A, start)
@@ -2475,7 +2480,9 @@ findlast(A::AbstractArray) = findprev(A, last(keys(A)))
     findprev(predicate::Function, A, i)
 
 Find the previous index before or including `i` of an element of `A`
-for which `predicate` returns `true`, or `nothing` if not found.
+for which `predicate` returns `true`, or `nothing` if not found. This works for
+Arrays, Strings, and most other collections that support [`getindex`](@ref),
+[`keys(A)`](@ref), and [`nextind`](@ref).
 
 Indices are of the same type as those returned by [`keys(A)`](@ref)
 and [`pairs(A)`](@ref).
@@ -2501,6 +2508,9 @@ julia> A = [4 6; 1 2]
 
 julia> findprev(isodd, A, CartesianIndex(1, 2))
 CartesianIndex(2, 1)
+
+julia> findprev(isspace, "a b c", 3)
+2
 ```
 """
 function findprev(testf::Function, A, start)

From 0ce62fea1d3324d020cf87522a7fdd4761b84b43 Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Sun, 28 Jan 2024 22:38:20 +0100
Subject: [PATCH 0727/1315] Document the generic functions nextind() and
 prevind() (#52658)

Co-authored-by: inky <git@wo-class.cn>
Co-authored-by: Denis Barucic <barucic.d@gmail.com>
Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/tuple.jl           | 68 +++++++++++++++++++++++++++++++++++++++++
 doc/src/base/arrays.md  |  2 ++
 doc/src/base/strings.md |  4 +--
 3 files changed, 72 insertions(+), 2 deletions(-)

diff --git a/base/tuple.jl b/base/tuple.jl
index 274f8d8354890..6d0ab4b4f9b24 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -73,6 +73,74 @@ end
 
 keys(@nospecialize t::Tuple) = OneTo(length(t))
 
+"""
+    prevind(A, i)
+
+Return the index before `i` in `A`. The returned index is often equivalent to `i
+- 1` for an integer `i`. This function can be useful for generic code.
+
+!!! warning
+    The returned index might be out of bounds. Consider using
+    [`checkbounds`](@ref).
+
+See also: [`nextind`](@ref).
+
+# Examples
+```jldoctest
+julia> x = [1 2; 3 4]
+2×2 Matrix{Int64}:
+ 1  2
+ 3  4
+
+julia> prevind(x, 4) # valid result
+3
+
+julia> prevind(x, 1) # invalid result
+0
+
+julia> prevind(x, CartesianIndex(2, 2)) # valid result
+CartesianIndex(1, 2)
+
+julia> prevind(x, CartesianIndex(1, 1)) # invalid result
+CartesianIndex(2, 0)
+```
+"""
+function prevind end
+
+"""
+    nextind(A, i)
+
+Return the index after `i` in `A`. The returned index is often equivalent to `i
++ 1` for an integer `i`. This function can be useful for generic code.
+
+!!! warning
+    The returned index might be out of bounds. Consider using
+    [`checkbounds`](@ref).
+
+See also: [`prevind`](@ref).
+
+# Examples
+```jldoctest
+julia> x = [1 2; 3 4]
+2×2 Matrix{Int64}:
+ 1  2
+ 3  4
+
+julia> nextind(x, 1) # valid result
+2
+
+julia> nextind(x, 4) # invalid result
+5
+
+julia> nextind(x, CartesianIndex(1, 1)) # valid result
+CartesianIndex(2, 1)
+
+julia> nextind(x, CartesianIndex(2, 2)) # invalid result
+CartesianIndex(1, 3)
+```
+"""
+function nextind end
+
 prevind(@nospecialize(t::Tuple), i::Integer) = Int(i)-1
 nextind(@nospecialize(t::Tuple), i::Integer) = Int(i)+1
 
diff --git a/doc/src/base/arrays.md b/doc/src/base/arrays.md
index ada748fdbe713..20e8e81614b9e 100644
--- a/doc/src/base/arrays.md
+++ b/doc/src/base/arrays.md
@@ -97,6 +97,8 @@ Base.Broadcast.result_style
 ```@docs
 Base.getindex(::AbstractArray, ::Any...)
 Base.setindex!(::AbstractArray, ::Any, ::Any...)
+Base.nextind
+Base.prevind
 Base.copyto!(::AbstractArray, ::CartesianIndices, ::AbstractArray, ::CartesianIndices)
 Base.copy!
 Base.isassigned
diff --git a/doc/src/base/strings.md b/doc/src/base/strings.md
index 2b70a4f53198e..ef470be6b55cc 100644
--- a/doc/src/base/strings.md
+++ b/doc/src/base/strings.md
@@ -80,8 +80,8 @@ Base.chopprefix
 Base.chopsuffix
 Base.chomp
 Base.thisind
-Base.nextind
-Base.prevind
+Base.nextind(::AbstractString, ::Integer, ::Integer)
+Base.prevind(::AbstractString, ::Integer, ::Integer)
 Base.textwidth
 Base.isascii
 Base.iscntrl

From dcb196e4ca59d9b291de45030500d01bbaa28d1b Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Sun, 28 Jan 2024 16:53:31 -0500
Subject: [PATCH 0728/1315] Revert "Don't export Dates.adjust" (#53089)

Reverts JuliaLang/julia#53027

#53027 broke the `doctest` job in CI.
---
 NEWS.md                   | 2 --
 stdlib/Dates/src/Dates.jl | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 6eb7e6509c69f..dd16151ffa74c 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -165,8 +165,6 @@ Standard library changes
 
 #### Dates
 
-The undocumented function `adjust` is no longer exported but is now documented
-
 #### Statistics
 
 * Statistics is now an upgradeable standard library ([#46501]).
diff --git a/stdlib/Dates/src/Dates.jl b/stdlib/Dates/src/Dates.jl
index bbfcdbee3f3d1..a111ea24089c4 100644
--- a/stdlib/Dates/src/Dates.jl
+++ b/stdlib/Dates/src/Dates.jl
@@ -77,7 +77,7 @@ export Period, DatePeriod, TimePeriod,
        firstdayofmonth, lastdayofmonth,
        firstdayofyear, lastdayofyear,
        firstdayofquarter, lastdayofquarter,
-       tonext, toprev, tofirst, tolast,
+       adjust, tonext, toprev, tofirst, tolast,
        # io.jl
        ISODateTimeFormat, ISODateFormat, ISOTimeFormat, DateFormat, RFC1123Format, @dateformat_str
 

From 746fad00a4fb11fe34502c1b89e966fa129b645c Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Mon, 29 Jan 2024 02:43:22 +0100
Subject: [PATCH 0729/1315] doc: replace harr HTML entity by unicode (#53066)

Documenter does not support HTML entities. See discussion in PR #52078
for further background.

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 doc/src/manual/noteworthy-differences.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/src/manual/noteworthy-differences.md b/doc/src/manual/noteworthy-differences.md
index ef8fe471c4be7..16cf46e0dfc4a 100644
--- a/doc/src/manual/noteworthy-differences.md
+++ b/doc/src/manual/noteworthy-differences.md
@@ -353,7 +353,7 @@ For users coming to Julia from R, these are some noteworthy differences:
     it's more general than that since methods are dispatched on every argument type, not only `this`,
     using the most-specific-declaration rule).
 
-### Julia &harr; C/C++: Namespaces
+### Julia ⇔ C/C++: Namespaces
   * C/C++ `namespace`s correspond roughly to Julia `module`s.
   * There are no private globals or fields in Julia.  Everything is publicly accessible
     through fully qualified paths (or relative paths, if desired).
@@ -365,7 +365,7 @@ For users coming to Julia from R, these are some noteworthy differences:
   * Caveat: `import`/`using` (Julia) works only at the global scope level (`module`s)
     * In C++, `using namespace X` works within arbitrary scopes (ex: function scope).
 
-### Julia &harr; C/C++: Module loading
+### Julia ⇔ C/C++: Module loading
   * When you think of a C/C++ "**library**", you are likely looking for a Julia "**package**".
     * Caveat: C/C++ libraries often house multiple "software modules" whereas Julia
       "packages" typically house one.
@@ -396,7 +396,7 @@ For users coming to Julia from R, these are some noteworthy differences:
     * Directory-based package repositories are the **quickest solution** to developing local
       libraries of "software modules".
 
-### Julia &harr; C/C++: Assembling modules
+### Julia ⇔ C/C++: Assembling modules
   * In C/C++, `.c`/`.cpp` files are compiled & added to a library with build/`make` scripts.
     * In Julia, `import [PkgName]`/`using [PkgName]` statements load `[PkgName].jl` located
       in a package's `[PkgName]/src/` subdirectory.
@@ -413,7 +413,7 @@ For users coming to Julia from R, these are some noteworthy differences:
       Julia package* ("software module"). It is therefore relatively straightforward to ensure
       file are `include`d only once (No `#ifdef` confusion).
 
-### Julia &harr; C/C++: Module interface
+### Julia ⇔ C/C++: Module interface
   * C++ exposes interfaces using "public" `.h`/`.hpp` files whereas Julia `module`s mark
     specific symbols that are intended for their users as `public`or `export`ed.
     * Often, Julia `module`s simply add functionality by generating new "methods" to existing
@@ -427,7 +427,7 @@ For users coming to Julia from R, these are some noteworthy differences:
     * Users might be expected to access these components by qualifying functions/structs/...
       with the package/module name (ex: `MyModule.run_this_task(...)`).
 
-### Julia &harr; C/C++: Quick reference
+### Julia ⇔ C/C++: Quick reference
 
 | Software Concept   | Julia | C/C++ |
 | :---               | :---  | :---  |

From 5b64a0d0085008a3057c08b2a338fc4fd58ad638 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 29 Jan 2024 11:15:18 +0900
Subject: [PATCH 0730/1315] forward-port the test cases added in #53076
 (#53077)

The fix for #53062 was included in #50805, but it lacked explicit test
cases added. This commit cherry-picks the test cases from #53076 to
prevent future regression.
---
 base/compiler/ssair/inlining.jl |  2 +-
 test/compiler/inline.jl         | 17 +++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index bacaf68db4332..48e9dd431747c 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1396,7 +1396,7 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
         fully_covered &= split_fully_covered
     end
 
-    (handled_all_cases && fully_covered) || (joint_effects = Effects(joint_effects; nothrow=false))
+    (handled_all_cases & fully_covered) || (joint_effects = Effects(joint_effects; nothrow=false))
 
     if handled_all_cases && revisit_idx !== nothing
         # we handled everything except one match with unmatched sparams,
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 9e58f23fd755c..0ef7f6def1057 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -2116,3 +2116,20 @@ let src = code_typed1() do
     end
     @test count(isinvoke(:iterate), src.code) == 0
 end
+
+# JuliaLang/julia#53062: proper `joint_effects` for call with empty method matches
+let ir = first(only(Base.code_ircode(setproperty!, (Base.RefValue{Int},Symbol,Base.RefValue{Int}))))
+    i = findfirst(iscall((ir, convert)), ir.stmts.stmt)::Int
+    @test iszero(ir.stmts.flag[i] & Core.Compiler.IR_FLAG_NOTHROW)
+end
+function issue53062(cond)
+    x = Ref{Int}(0)
+    if cond
+        x[] = x
+    else
+        return -1
+    end
+end
+@test !Core.Compiler.is_nothrow(Base.infer_effects(issue53062, (Bool,)))
+@test issue53062(false) == -1
+@test_throws MethodError issue53062(true)

From 0588cd407862715e1f0544703d69cfb5d653681c Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 29 Jan 2024 11:21:47 +0900
Subject: [PATCH 0731/1315] remove unnecessary `true &&` part from `at-view`
 macro (#53064)

The modification that expands `@view A[i]` to `true && view(A, i)`
appears to go back as far as #20247. However, I'm not entirely sure why
this is necessary. Considering that just expanding it to `view(A, i)`
still seems to pass the base test suite, I wonder if it might be just
better to get rid of that part.
---
 base/views.jl    | 23 ++++++++++++-----------
 test/subarray.jl | 18 ++++++++++++++++++
 2 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/base/views.jl b/base/views.jl
index d83005c86f46c..6898abdda1471 100644
--- a/base/views.jl
+++ b/base/views.jl
@@ -123,20 +123,21 @@ julia> A
 ```
 """
 macro view(ex)
+    Meta.isexpr(ex, :ref) || throw(ArgumentError(
+        "Invalid use of @view macro: argument must be a reference expression A[...]."))
+    ex = replace_ref_begin_end!(ex)
+    # NOTE We embed `view` as a function object itself directly into the AST.
+    #      By doing this, we prevent the creation of function definitions like
+    #      `view(A, idx) = xxx` in cases such as `@view(A[idx]) = xxx.`
     if Meta.isexpr(ex, :ref)
-        ex = replace_ref_begin_end!(ex)
-        if Meta.isexpr(ex, :ref)
-            ex = Expr(:call, view, ex.args...)
-        else # ex replaced by let ...; foo[...]; end
-            if !(Meta.isexpr(ex, :let) && Meta.isexpr(ex.args[2], :ref))
-                error("invalid expression")
-            end
-            ex.args[2] = Expr(:call, view, ex.args[2].args...)
-        end
-        Expr(:&&, true, esc(ex))
+        ex = Expr(:call, view, ex.args...)
+    elseif Meta.isexpr(ex, :let) && (arg2 = ex.args[2]; Meta.isexpr(arg2, :ref))
+        # ex replaced by let ...; foo[...]; end
+        ex.args[2] = Expr(:call, view, arg2.args...)
     else
-        throw(ArgumentError("Invalid use of @view macro: argument must be a reference expression A[...]."))
+        error("invalid expression")
     end
+    return esc(ex)
 end
 
 ############################################################################
diff --git a/test/subarray.jl b/test/subarray.jl
index ad68496e38245..40877d842df76 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -937,3 +937,21 @@ end
     v = view(1:2, r)
     @test v == view(1:2, collect(r))
 end
+
+# https://github.com/JuliaLang/julia/pull/53064
+# `@view(A[idx]) = xxx` should raise syntax error always
+@test try
+    Core.eval(@__MODULE__, :(@view(A[idx]) = 2))
+    false
+catch err
+    err isa ErrorException && startswith(err.msg, "syntax:")
+end
+module Issue53064
+import Base: view
+end
+@test try
+    Core.eval(Issue53064, :(@view(A[idx]) = 2))
+    false
+catch err
+    err isa ErrorException && startswith(err.msg, "syntax:")
+end

From 741b5dacab3a1e29517535e28a535e506faa3ab5 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 29 Jan 2024 15:28:39 +0900
Subject: [PATCH 0732/1315] forward-port #53096 to nightly, fix the
 intermittent REPL test failure (#53097)

While the original issue #52739 has been observed only in v1.10, the
necessity to enhance the robustness of the corresponding test code is
still applicable in the nightly. See #53096 for the details.
---
 stdlib/REPL/test/replcompletions.jl | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 280b23a68c4e2..ac4f34b7b9180 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -648,7 +648,7 @@ let s = "CompletionFoo.?([1,2,3], 2.0)"
     c, r, res = test_complete(s)
     @test !res
     @test length(c) == 1
-    @test occursin("test(x::AbstractArray{T}, y) where T<:Real", c[1])
+    @test occursin("test(x::AbstractArray{T}, y) where T<:Real", only(c))
     # In particular, this checks that test(args...) is not a valid completion
     # since it is strictly less specific than test(x::AbstractArray{T}, y)
 end
@@ -682,15 +682,15 @@ let s = "CompletionFoo.?(false, \"a\", 3, "
     c, r, res = test_complete(s)
     @test !res
     @test length(c) == 2
-    @test occursin("test(args...)", c[1])
-    @test occursin("test11(a::Integer, b, c)", c[2])
+    @test any(s->occursin("test(args...)", s), c)
+    @test any(s->occursin("test11(a::Integer, b, c)", s), c)
 end
 
 let s = "CompletionFoo.?(false, \"a\", 3, "
     c, r, res = test_complete_noshift(s)
     @test !res
     @test length(c) == 1
-    @test occursin("test11(a::Integer, b, c)", c[1])
+    @test occursin("test11(a::Integer, b, c)", only(c))
 end
 
 let s = "CompletionFoo.?(\"a\", 3, "
@@ -713,7 +713,7 @@ let s = "CompletionFoo.?()"
     c, r, res = test_complete_noshift(s)
     @test !res
     @test length(c) == 1
-    @test occursin("test10(s::String...)", c[1])
+    @test occursin("test10(s::String...)", only(c))
 end
 
 #= TODO: restrict the number of completions when a semicolon is present in ".?(" syntax
@@ -731,7 +731,7 @@ let s = "CompletionFoo.?(3; len2=5, "
     c, r, res = test_complete_noshift(s)
     @test !res
     @test length(c) == 1
-    @test occursin("kwtest3(a::Integer; namedarg, foobar, slurp...)", c[1])
+    @test occursin("kwtest3(a::Integer; namedarg, foobar, slurp...)", only(c))
     # the other two kwtest3 methods should not appear because of specificity
 end
 =#

From 9669eecc99bc4553e28d94d7dd3dc9fd40b3bf3f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Mon, 29 Jan 2024 08:34:37 +0000
Subject: [PATCH 0733/1315] Drop support for LLVM 14 (#53094)

---
 src/cgutils.cpp   |  2 --
 src/codegen.cpp   |  9 ---------
 src/disasm.cpp    | 19 -------------------
 src/jitlayers.cpp |  6 +-----
 src/jitlayers.h   | 10 +---------
 src/pipeline.cpp  |  3 ---
 6 files changed, 2 insertions(+), 47 deletions(-)

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index b4716b13f2dd1..2a53cf0528694 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -3489,10 +3489,8 @@ static Value *emit_allocobj(jl_codectx_t &ctx, size_t static_size, Value *jt,
     if (static_size > 0)
         call->addRetAttr(Attribute::getWithDereferenceableBytes(call->getContext(), static_size));
     call->addRetAttr(Attribute::getWithAlignment(call->getContext(), Align(align)));
-#if JL_LLVM_VERSION >= 150000
     if (fully_initialized)
         call->addFnAttr(Attribute::get(call->getContext(), Attribute::AllocKind, uint64_t(AllocFnKind::Alloc | AllocFnKind::Uninitialized)));
-#endif
     return call;
 }
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 39f938ea313e8..c91e70b5e508e 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1051,9 +1051,7 @@ static const auto jl_alloc_obj_func = new JuliaFunction<TypeFnContextAndSizeT>{
     [](LLVMContext &C) {
         auto FnAttrs = AttrBuilder(C);
         FnAttrs.addAllocSizeAttr(1, None); // returns %1 bytes
-#if JL_LLVM_VERSION >= 150000
         FnAttrs.addAllocKindAttr(AllocFnKind::Alloc);
-#endif
 #if JL_LLVM_VERSION >= 160000
         FnAttrs.addMemoryAttr(MemoryEffects::argMemOnly(ModRefInfo::Ref) | MemoryEffects::inaccessibleMemOnly(ModRefInfo::ModRef));
 #endif
@@ -2628,11 +2626,7 @@ static void jl_init_function(Function *F, const Triple &TT)
         attr.addStackAlignmentAttr(16);
     }
     if (TT.isOSWindows() && TT.getArch() == Triple::x86_64) {
-#if JL_LLVM_VERSION < 150000
-        attr.addAttribute(Attribute::UWTable); // force NeedsWinEH
-#else
         attr.addUWTableAttr(llvm::UWTableKind::Default); // force NeedsWinEH
-#endif
     }
     if (jl_fpo_disabled(TT))
         attr.addAttribute("frame-pointer", "all");
@@ -9580,9 +9574,6 @@ extern "C" void jl_init_llvm(void)
     // Initialize passes
     PassRegistry &Registry = *PassRegistry::getPassRegistry();
     initializeCore(Registry);
-#if JL_LLVM_VERSION < 150000
-    initializeCoroutines(Registry);
-#endif
     initializeScalarOpts(Registry);
     initializeVectorization(Registry);
     initializeAnalysis(Registry);
diff --git a/src/disasm.cpp b/src/disasm.cpp
index 57896dc2ee4d8..c2a55f23d12f2 100644
--- a/src/disasm.cpp
+++ b/src/disasm.cpp
@@ -797,11 +797,7 @@ static const char *SymbolLookup(void *DisInfo, uint64_t ReferenceValue, uint64_t
 
 static int OpInfoLookup(void *DisInfo, uint64_t PC,
                         uint64_t Offset,
-#if JL_LLVM_VERSION < 150000
-                        uint64_t Size,
-#else
                         uint64_t OpSize, uint64_t InstSize,
-#endif
                         int TagType, void *TagBuf)
 {
     // SymbolTable *SymTab = (SymbolTable*)DisInfo;
@@ -910,11 +906,7 @@ static void jl_dump_asm_internal(
     std::unique_ptr<MCCodeEmitter> CE;
     std::unique_ptr<MCAsmBackend> MAB;
     if (ShowEncoding) {
-#if JL_LLVM_VERSION >= 150000
         CE.reset(TheTarget->createMCCodeEmitter(*MCII, Ctx));
-#else
-        CE.reset(TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
-#endif
         MAB.reset(TheTarget->createMCAsmBackend(*STI, *MRI, Options));
     }
 
@@ -929,11 +921,7 @@ static void jl_dump_asm_internal(
                                          IP.release(),
                                          std::move(CE), std::move(MAB),
                                          /*ShowInst*/ false));
-#if JL_LLVM_VERSION >= 140000
     Streamer->initSections(true, *STI);
-#else
-    Streamer->InitSections(true);
-#endif
 
     // Make the MemoryObject wrapper
     ArrayRef<uint8_t> memoryObject(const_cast<uint8_t*>((const uint8_t*)Fptr),Fsize);
@@ -1049,9 +1037,6 @@ static void jl_dump_asm_internal(
             MCInst Inst;
             MCDisassembler::DecodeStatus S;
             FuncMCView view = memoryObject.slice(Index);
-#if JL_LLVM_VERSION < 150000
-#define getCommentOS() GetCommentOS()
-#endif
             S = DisAsm->getInstruction(Inst, insSize, view, 0,
                                       /*CStream*/ pass != 0 ? Streamer->getCommentOS () : nulls());
             if (pass != 0 && Streamer->getCommentOS ().tell() > 0)
@@ -1256,11 +1241,7 @@ jl_value_t *jl_dump_function_asm_impl(jl_llvmf_dump_t* dump, char emit_mc, const
                 STI, MRI, TM->Options.MCOptions));
             std::unique_ptr<MCCodeEmitter> MCE;
             if (binary) { // enable MCAsmStreamer::AddEncodingComment printing
-#if JL_LLVM_VERSION >= 150000
                 MCE.reset(TM->getTarget().createMCCodeEmitter(MII, *Context));
-#else
-                MCE.reset(TM->getTarget().createMCCodeEmitter(MII, MRI, *Context));
-#endif
             }
             auto FOut = std::make_unique<formatted_raw_ostream>(asmfile);
             std::unique_ptr<MCStreamer> S(TM->getTarget().createAsmStreamer(
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 8521ab5502f32..cb6267866eac1 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -41,9 +41,7 @@ using namespace llvm;
 # include <llvm/ExecutionEngine/Orc/DebuggerSupportPlugin.h>
 # include <llvm/ExecutionEngine/JITLink/EHFrameSupport.h>
 # include <llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h>
-# if JL_LLVM_VERSION >= 150000
 # include <llvm/ExecutionEngine/Orc/MapperJITLinkMemoryManager.h>
-# endif
 # include <llvm/ExecutionEngine/SectionMemoryManager.h>
 
 #define DEBUG_TYPE "julia_jitlayers"
@@ -1006,9 +1004,7 @@ class JLMemoryUsagePlugin : public ObjectLinkingLayer::Plugin {
 // TODO: Port our memory management optimisations to JITLink instead of using the
 // default InProcessMemoryManager.
 std::unique_ptr<jitlink::JITLinkMemoryManager> createJITLinkMemoryManager() {
-#if JL_LLVM_VERSION < 150000
-    return cantFail(jitlink::InProcessMemoryManager::Create());
-#elif JL_LLVM_VERSION < 160000
+#if JL_LLVM_VERSION < 160000
     return cantFail(orc::MapperJITLinkMemoryManager::CreateWithMapper<orc::InProcessMemoryMapper>());
 #else
     return cantFail(orc::MapperJITLinkMemoryManager::CreateWithMapper<orc::InProcessMemoryMapper>(/*Reservation Granularity*/ 16 * 1024 * 1024));
diff --git a/src/jitlayers.h b/src/jitlayers.h
index d0de6829804df..3da4c28af6601 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -53,16 +53,8 @@
 #endif
 // The sanitizers don't play well with our memory manager
 
-#if defined(JL_FORCE_JITLINK) || JL_LLVM_VERSION >= 150000 && defined(HAS_SANITIZER)
+#if defined(JL_FORCE_JITLINK) || defined(_CPU_AARCH64_) || defined(HAS_SANITIZER)
 # define JL_USE_JITLINK
-#else
-# if defined(_CPU_AARCH64_)
-#  if defined(_OS_LINUX_) && JL_LLVM_VERSION < 150000
-#   pragma message("On aarch64-gnu-linux, LLVM version >= 15 is required for JITLink; fallback suffers from occasional segfaults")
-#  else
-#   define JL_USE_JITLINK
-#  endif
-# endif
 #endif
 
 # include <llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h>
diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index 81f68df0c8870..aafce01856634 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -215,9 +215,6 @@ namespace {
             // .sinkCommonInsts(true)
             ;
     }
-#if JL_LLVM_VERSION < 150000
-#define LICMOptions()
-#endif
 
 // At any given time exactly one of each pair of overloads is strictly unused
 #ifdef _COMPILER_GCC_

From 08d229f4a7cb0c3ef5becddd1b3bc4f8f178b8e4 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Mon, 29 Jan 2024 12:51:55 +0100
Subject: [PATCH 0734/1315] Extensions: make loading of extensions independent
 of what packages are in the sysimage (#52841)

When triggers of extension are in the sysimage it is easy to end up with
cycles in package loading. Say we have a package A with exts BExt and
CExt and say that B and C is in the sysimage.

- Upon loading A, we will immidiately start to precompile BExt (because
the trigger B is "loaded" by virtue of being in the sysimage).
- BExt will load A which will cause CExt to start precompiling (again
because C is in the sysimage).
- CExt will load A which will now cause BExt to start loading and we get
a cycle.

This is fixed in this PR by instead of looking at what modules are
loaded, we look at what modules are actually `require`d and only use
that to drive the loading of extensions.

Fixes https://github.com/JuliaLang/julia/issues/52132.
---
 base/Base.jl                                   |  1 +
 base/loading.jl                                | 10 +++++++++-
 test/loading.jl                                | 18 ++++++++++++++++++
 .../HasDepWithExtensions.jl/Manifest.toml      |  9 +++++++--
 .../Extensions/HasExtensions.jl/Project.toml   |  2 ++
 .../HasExtensions.jl/ext/LinearAlgebraExt.jl   |  3 +++
 6 files changed, 40 insertions(+), 3 deletions(-)
 create mode 100644 test/project/Extensions/HasExtensions.jl/ext/LinearAlgebraExt.jl

diff --git a/base/Base.jl b/base/Base.jl
index 0ca13265adc4f..87e1fe94b0ad2 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -627,6 +627,7 @@ function __init__()
     init_load_path()
     init_active_project()
     append!(empty!(_sysimage_modules), keys(loaded_modules))
+    empty!(explicit_loaded_modules)
     if haskey(ENV, "JULIA_MAX_NUM_PRECOMPILE_FILES")
         MAX_NUM_PRECOMPILE_FILES[] = parse(Int, ENV["JULIA_MAX_NUM_PRECOMPILE_FILES"])
     end
diff --git a/base/loading.jl b/base/loading.jl
index 8ea8354031c30..fb056f5f61c7c 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1354,7 +1354,7 @@ function _insert_extension_triggers(parent::PkgId, extensions::Dict{String, Any}
             # TODO: Better error message if this lookup fails?
             uuid_trigger = UUID(weakdeps[trigger]::String)
             trigger_id = PkgId(uuid_trigger, trigger)
-            if !haskey(Base.loaded_modules, trigger_id) || haskey(package_locks, trigger_id)
+            if !haskey(explicit_loaded_modules, trigger_id) || haskey(package_locks, trigger_id)
                 trigger1 = get!(Vector{ExtensionId}, EXT_DORMITORY, trigger_id)
                 push!(trigger1, gid)
             else
@@ -1986,6 +1986,11 @@ function __require_prelocked(uuidkey::PkgId, env=nothing)
         # After successfully loading, notify downstream consumers
         run_package_callbacks(uuidkey)
     else
+        m = get(loaded_modules, uuidkey, nothing)
+        if m !== nothing
+            explicit_loaded_modules[uuidkey] = m
+            run_package_callbacks(uuidkey)
+        end
         newm = root_module(uuidkey)
     end
     return newm
@@ -2000,6 +2005,8 @@ PkgOrigin() = PkgOrigin(nothing, nothing, nothing)
 const pkgorigins = Dict{PkgId,PkgOrigin}()
 
 const loaded_modules = Dict{PkgId,Module}()
+# Emptied on Julia start
+const explicit_loaded_modules = Dict{PkgId,Module}()
 const loaded_modules_order = Vector{Module}()
 const module_keys = IdDict{Module,PkgId}() # the reverse
 
@@ -2023,6 +2030,7 @@ root_module_key(m::Module) = @lock require_lock module_keys[m]
     end
     push!(loaded_modules_order, m)
     loaded_modules[key] = m
+    explicit_loaded_modules[key] = m
     module_keys[m] = key
     end
     nothing
diff --git a/test/loading.jl b/test/loading.jl
index e17192e6c5571..5d43cd085f5d6 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1113,6 +1113,24 @@ end
             cmd_proj_ext = addenv(cmd_proj_ext, "JULIA_LOAD_PATH" => join([joinpath(proj, "HasExtensions.jl"), joinpath(proj, "EnvWithDeps")], sep))
             run(cmd_proj_ext)
         end
+
+        # Sysimage extensions
+        # The test below requires that LinearAlgebra is in the sysimage and that it has not been loaded yet.
+        # if it gets moved out, this test will need to be updated.
+        # We run this test in a new process so we are not vulnerable to a previous test having loaded LinearAlgebra
+        sysimg_ext_test_code = """
+            uuid_key = Base.PkgId(Base.UUID("37e2e46d-f89d-539d-b4ee-838fcccc9c8e"), "LinearAlgebra")
+            Base.in_sysimage(uuid_key) || error("LinearAlgebra not in sysimage")
+            haskey(Base.explicit_loaded_modules, uuid_key) && error("LinearAlgebra already loaded")
+            using HasExtensions
+            Base.get_extension(HasExtensions, :LinearAlgebraExt) === nothing || error("unexpectedly got an extension")
+            using LinearAlgebra
+            haskey(Base.explicit_loaded_modules, uuid_key) || error("LinearAlgebra not loaded")
+            Base.get_extension(HasExtensions, :LinearAlgebraExt) isa Module || error("expected extension to load")
+        """
+        cmd =  `$(Base.julia_cmd()) --startup-file=no -e $sysimg_ext_test_code`
+        cmd = addenv(cmd, "JULIA_LOAD_PATH" => join([proj, "@stdlib"], sep))
+        run(cmd)
     finally
         try
             rm(depot_path, force=true, recursive=true)
diff --git a/test/project/Extensions/HasDepWithExtensions.jl/Manifest.toml b/test/project/Extensions/HasDepWithExtensions.jl/Manifest.toml
index 52542fc822094..15f068f250ce3 100644
--- a/test/project/Extensions/HasDepWithExtensions.jl/Manifest.toml
+++ b/test/project/Extensions/HasDepWithExtensions.jl/Manifest.toml
@@ -1,6 +1,6 @@
 # This file is machine-generated - editing it directly is not advised
 
-julia_version = "1.10.0-DEV"
+julia_version = "1.10.0"
 manifest_format = "2.0"
 project_hash = "d523b3401f72a1ed34b7b43749fd2655c6b78542"
 
@@ -19,11 +19,16 @@ version = "0.1.0"
 path = "../HasExtensions.jl"
 uuid = "4d3288b3-3afc-4bb6-85f3-489fffe514c8"
 version = "0.1.0"
-weakdeps = ["ExtDep", "ExtDep2"]
 
     [deps.HasExtensions.extensions]
     Extension = "ExtDep"
     ExtensionFolder = ["ExtDep", "ExtDep2"]
+    LinearAlgebraExt = "LinearAlgebra"
+
+    [deps.HasExtensions.weakdeps]
+    ExtDep = "fa069be4-f60b-4d4c-8b95-f8008775090c"
+    ExtDep2 = "55982ee5-2ad5-4c40-8cfe-5e9e1b01500d"
+    LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [[deps.SomePackage]]
 path = "../SomePackage"
diff --git a/test/project/Extensions/HasExtensions.jl/Project.toml b/test/project/Extensions/HasExtensions.jl/Project.toml
index 72577de36d65d..a5f9bb1e42d29 100644
--- a/test/project/Extensions/HasExtensions.jl/Project.toml
+++ b/test/project/Extensions/HasExtensions.jl/Project.toml
@@ -5,7 +5,9 @@ version = "0.1.0"
 [weakdeps]
 ExtDep = "fa069be4-f60b-4d4c-8b95-f8008775090c"
 ExtDep2 = "55982ee5-2ad5-4c40-8cfe-5e9e1b01500d"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [extensions]
 Extension = "ExtDep"
 ExtensionFolder = ["ExtDep", "ExtDep2"]
+LinearAlgebraExt = "LinearAlgebra"
diff --git a/test/project/Extensions/HasExtensions.jl/ext/LinearAlgebraExt.jl b/test/project/Extensions/HasExtensions.jl/ext/LinearAlgebraExt.jl
new file mode 100644
index 0000000000000..19f87cb849417
--- /dev/null
+++ b/test/project/Extensions/HasExtensions.jl/ext/LinearAlgebraExt.jl
@@ -0,0 +1,3 @@
+module LinearAlgebraExt
+
+end

From aec8823bcacdc87930874c5b0d2c62a4d5c68d6e Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 29 Jan 2024 12:35:06 -0500
Subject: [PATCH 0735/1315] gf: small perf optimization to
 jl_method_table_add_backedge (#53085)

If this table gets very large, doing a jl_types_equal against every
element can be costly. Often they might all be the same signature also,
just from different specializations. Try to short-circuit the
comparisons to scan in a more optimal order.
---
 src/gf.c | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/gf.c b/src/gf.c
index cc551e8cee90f..efe624f518a2b 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1772,16 +1772,24 @@ JL_DLLEXPORT void jl_method_table_add_backedge(jl_methtable_t *mt, jl_value_t *t
         jl_array_ptr_set(mt->backedges, 1, caller);
     }
     else {
-        // TODO: use jl_cache_type_(tt) like cache_method does, instead of a linear scan
+        // check if the edge is already present and avoid adding a duplicate
         size_t i, l = jl_array_nrows(mt->backedges);
         for (i = 1; i < l; i += 2) {
-            if (jl_types_equal(jl_array_ptr_ref(mt->backedges, i - 1), typ)) {
-                if (jl_array_ptr_ref(mt->backedges, i) == caller) {
+            if (jl_array_ptr_ref(mt->backedges, i) == caller) {
+                if (jl_types_equal(jl_array_ptr_ref(mt->backedges, i - 1), typ)) {
                     JL_UNLOCK(&mt->writelock);
                     return;
                 }
-                // reuse the already cached instance of this type
-                typ = jl_array_ptr_ref(mt->backedges, i - 1);
+            }
+        }
+        // reuse an already cached instance of this type, if possible
+        // TODO: use jl_cache_type_(tt) like cache_method does, instead of this linear scan?
+        for (i = 1; i < l; i += 2) {
+            if (jl_array_ptr_ref(mt->backedges, i) != caller) {
+                if (jl_types_equal(jl_array_ptr_ref(mt->backedges, i - 1), typ)) {
+                    typ = jl_array_ptr_ref(mt->backedges, i - 1);
+                    break;
+                }
             }
         }
         jl_array_ptr_1d_push(mt->backedges, typ);

From 67f73207aaf9f07100d0bb3912f2ad0918608386 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 29 Jan 2024 12:35:30 -0500
Subject: [PATCH 0736/1315] builtin: allow equal types in set_global_type
 without error (#53086)

Use the julia notion of equality (type-equal) instead of the strictly C
notion (pointer-equal). Also add tests and docs for this function.
---
 base/docs/basedocs.jl       | 16 ++++++++++++++++
 doc/src/devdocs/builtins.md |  2 ++
 src/builtins.c              |  8 ++++----
 test/core.jl                | 11 +++++++++++
 4 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index ae0e350c1c138..896cbf30b6520 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -2358,6 +2358,22 @@ julia> M.a
 """
 setglobal!
 
+"""
+    Core.get_binding_type(module::Module, name::Symbol)
+
+Retrieve the declared type of the binding `name` from the module `module`.
+"""
+Core.get_binding_type
+
+"""
+    Core.set_binding_type!(module::Module, name::Symbol, [type::Type])
+
+Set the declared type of the binding `name` in the module `module` to `type`. Error if the
+binding already has a type that is not equivalent to `type`. If the `type` argument is
+absent, set the binding type to `Any` if unset, but do not error.
+"""
+Core.set_binding_type!
+
 """
     typeof(x)
 
diff --git a/doc/src/devdocs/builtins.md b/doc/src/devdocs/builtins.md
index eef5cbd04dd8c..02c64f4839fd7 100644
--- a/doc/src/devdocs/builtins.md
+++ b/doc/src/devdocs/builtins.md
@@ -12,6 +12,8 @@ Core.memoryrefoffset
 Core.memoryrefget
 Core.memoryrefset!
 Core.memoryref_isassigned
+Core.get_binding_type
+Core.set_binding_type!
 Core.IntrinsicFunction
 Core.Intrinsics
 Core.IR
diff --git a/src/builtins.c b/src/builtins.c
index f8832e0ac952b..3c4e8215fc572 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1355,13 +1355,13 @@ JL_CALLABLE(jl_f_set_binding_type)
     JL_TYPECHK(set_binding_type!, type, ty);
     jl_binding_t *b = jl_get_binding_wr(m, s);
     jl_value_t *old_ty = NULL;
-    if (!jl_atomic_cmpswap_relaxed(&b->ty, &old_ty, ty) && ty != old_ty) {
-        if (nargs == 2)
-            return jl_nothing;
+    if (jl_atomic_cmpswap_relaxed(&b->ty, &old_ty, ty)) {
+        jl_gc_wb(b, ty);
+    }
+    else if (nargs != 2 && !jl_types_equal(ty, old_ty)) {
         jl_errorf("cannot set type for global %s.%s. It already has a value or is already set to a different type.",
                   jl_symbol_name(m->name), jl_symbol_name(s));
     }
-    jl_gc_wb(b, ty);
     return jl_nothing;
 }
 
diff --git a/test/core.jl b/test/core.jl
index 4f67dd2c0bdbc..ba42687acd0d0 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8112,3 +8112,14 @@ end
 @test Int isa Union{Union, Type{Union{Int,T1}}} where {T1}
 @test_broken Int isa Union{UnionAll, Type{Union{Int,T2} where {T2<:T1}} where {T1}}
 @test_broken Int isa Union{Union, Type{Union{Int,T1}} where {T1}}
+
+let M = @__MODULE__
+    @test Core.set_binding_type!(M, :a_typed_global, Tuple{Union{Integer,Nothing}}) === nothing
+    @test Core.get_binding_type(M, :a_typed_global) === Tuple{Union{Integer,Nothing}}
+    @test Core.set_binding_type!(M, :a_typed_global, Tuple{Union{Integer,Nothing}}) === nothing
+    @test Core.set_binding_type!(M, :a_typed_global, Union{Tuple{Integer},Tuple{Nothing}}) === nothing
+    @test_throws(ErrorException("cannot set type for global $(nameof(M)).a_typed_global. It already has a value or is already set to a different type."),
+                 Core.set_binding_type!(M, :a_typed_global, Union{Nothing,Tuple{Union{Integer,Nothing}}}))
+    @test Core.set_binding_type!(M, :a_typed_global) === nothing
+    @test Core.get_binding_type(M, :a_typed_global) === Tuple{Union{Integer,Nothing}}
+end

From b16c4d4412950f983beeacaac510195fd50a102d Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Mon, 29 Jan 2024 20:28:38 +0100
Subject: [PATCH 0737/1315] extend `divrem(x, y)` for `BigInt` to `divrem(x, y,
 rm)` (#53106)

Previously `divrem(x, y, rm)` was dispatched to a more generic code path
that called `div`, causing unnecessary allocation. Xref #45159.

Also replaced the `big` call with `BigInt`, which seems more correct to
me. The issue is that a user may define some `<:Integer` type for which
`big` doesn't convert to `BigInt`, which seems like it would lead to
infinite recursion in this case.
---
 base/gmp.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/gmp.jl b/base/gmp.jl
index b66c2eed9ae8d..beeec879ed487 100644
--- a/base/gmp.jl
+++ b/base/gmp.jl
@@ -606,8 +606,8 @@ function top_set_bit(x::BigInt)
     x.size * sizeof(Limb) << 3 - leading_zeros(GC.@preserve x unsafe_load(x.d, x.size))
 end
 
-divrem(x::BigInt, y::BigInt) = MPZ.tdiv_qr(x, y)
-divrem(x::BigInt, y::Integer) = MPZ.tdiv_qr(x, big(y))
+divrem(x::BigInt, y::BigInt,  ::typeof(RoundToZero) = RoundToZero) = MPZ.tdiv_qr(x, y)
+divrem(x::BigInt, y::Integer, ::typeof(RoundToZero) = RoundToZero) = MPZ.tdiv_qr(x, BigInt(y))
 
 cmp(x::BigInt, y::BigInt) = sign(MPZ.cmp(x, y))
 cmp(x::BigInt, y::ClongMax) = sign(MPZ.cmp_si(x, y))

From a26bd7fc6d96064af999b5c95be9298f5462d4e6 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 30 Jan 2024 04:29:12 +0900
Subject: [PATCH 0738/1315] optimize away `ifelse` when given values are egal
 (#53102)

---
 base/compiler/ssair/inlining.jl |  2 ++
 base/compiler/ssair/passes.jl   |  7 +++++--
 test/compiler/irpasses.jl       | 12 +++++++++---
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 48e9dd431747c..c39616143d933 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1749,6 +1749,8 @@ function early_inline_special_case(
             elseif cond.val === false
                 return SomeCase(stmt.args[4])
             end
+        elseif ⊑(optimizer_lattice(state.interp), cond, Bool) && stmt.args[3] === stmt.args[4]
+            return SomeCase(stmt.args[3])
         end
     end
     return nothing
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index e4237e282a9aa..fe587f82a9def 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1116,7 +1116,7 @@ function refine_new_effects!(𝕃ₒ::AbstractLattice, compact::IncrementalCompa
     return nothing
 end
 
-function fold_ifelse!(compact::IncrementalCompact, idx::Int, stmt::Expr)
+function fold_ifelse!(compact::IncrementalCompact, idx::Int, stmt::Expr, 𝕃ₒ::AbstractLattice)
     length(stmt.args) == 4 || return false
     condarg = stmt.args[2]
     condtyp = argextype(condarg, compact)
@@ -1128,6 +1128,9 @@ function fold_ifelse!(compact::IncrementalCompact, idx::Int, stmt::Expr)
             compact[idx] = stmt.args[4]
             return true
         end
+    elseif ⊑(𝕃ₒ, condtyp, Bool) && stmt.args[3] === stmt.args[4]
+        compact[idx] = stmt.args[3]
+        return true
     end
     return false
 end
@@ -1313,7 +1316,7 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
             elseif is_known_call(stmt, isa, compact)
                 lift_comparison!(isa, compact, idx, stmt, 𝕃ₒ)
             elseif is_known_call(stmt, Core.ifelse, compact)
-                fold_ifelse!(compact, idx, stmt)
+                fold_ifelse!(compact, idx, stmt, 𝕃ₒ)
             elseif is_known_invoke_or_call(stmt, Core.OptimizedGenerics.KeyValue.get, compact)
                 2 == (length(stmt.args) - (isexpr(stmt, :invoke) ? 2 : 1)) || continue
                 lift_keyvalue_get!(compact, idx, stmt, 𝕃ₒ)
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index f4d0130ad757b..2e14fdb8d3013 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1386,15 +1386,21 @@ end
 # ifelse folding
 @test Core.Compiler.is_removable_if_unused(Base.infer_effects(exp, (Float64,)))
 @test !Core.Compiler.is_inlineable(code_typed1(exp, (Float64,)))
-fully_eliminated(; retval=Core.Argument(2)) do x::Float64
+@test fully_eliminated(; retval=Core.Argument(2)) do x::Float64
     return Core.ifelse(true, x, exp(x))
 end
-fully_eliminated(; retval=Core.Argument(2)) do x::Float64
+@test fully_eliminated(; retval=Core.Argument(2)) do x::Float64
     return ifelse(true, x, exp(x)) # the optimization should be applied to post-inlining IR too
 end
-fully_eliminated(; retval=Core.Argument(2)) do x::Float64
+@test fully_eliminated(; retval=Core.Argument(2)) do x::Float64
     return ifelse(isa(x, Float64), x, exp(x))
 end
+func_coreifelse(c, x) = Core.ifelse(c, x, x)
+func_ifelse(c, x) = ifelse(c, x, x)
+@test fully_eliminated(func_coreifelse, (Bool,Float64); retval=Core.Argument(3))
+@test !fully_eliminated(func_coreifelse, (Any,Float64))
+@test fully_eliminated(func_ifelse, (Bool,Float64); retval=Core.Argument(3))
+@test !fully_eliminated(func_ifelse, (Any,Float64))
 
 # PhiC fixup of compact! with cfg modification
 @inline function big_dead_throw_catch()

From a3357cdcb6fd1787b712994143dd54d7bdc2e4d7 Mon Sep 17 00:00:00 2001
From: Denis Barucic <barucden@fel.cvut.cz>
Date: Mon, 29 Jan 2024 22:04:24 +0100
Subject: [PATCH 0739/1315] Docs: cross-reference `username` and `homedir`
 (#52451)

To improve discoverability (mainly) of `username`.
---
 base/path.jl    | 2 ++
 base/sysinfo.jl | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/base/path.jl b/base/path.jl
index 493add6b0f6d0..6d2fe933e4ec6 100644
--- a/base/path.jl
+++ b/base/path.jl
@@ -77,6 +77,8 @@ Return the current user's home directory.
     `homedir` determines the home directory via `libuv`'s `uv_os_homedir`. For details
     (for example on how to specify the home directory via environment variables), see the
     [`uv_os_homedir` documentation](http://docs.libuv.org/en/v1.x/misc.html#c.uv_os_homedir).
+
+See also [`Sys.username`](@ref).
 """
 function homedir()
     buf = Base.StringVector(AVG_PATH - 1) # space for null-terminator implied by StringVector
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 5cb37721c138c..69ee93864aadc 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -663,6 +663,8 @@ user = get(Sys.username, ENV, "USER")
 
 !!! compat "Julia 1.11"
     This function requires at least Julia 1.11.
+
+See also [`homedir`](@ref).
 """
 function username()
     pw = Libc.getpw()

From 9edf1dd8e971a6f43af4b39992fcb6eb81f8fb5d Mon Sep 17 00:00:00 2001
From: Pablo San-Jose <lekand@gmail.com>
Date: Tue, 30 Jan 2024 01:25:02 +0100
Subject: [PATCH 0740/1315] Ensure elision of `require_one_based_indexing` with
 high-dim array views  (#53091)

Closes #49332

---------

Co-authored-by: Denis Barucic <barucic.d@gmail.com>
---
 base/abstractarray.jl | 11 +++++++----
 test/abstractarray.jl |  4 ++++
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 7248e9f8038e6..1af8e07584d0d 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -103,17 +103,20 @@ end
     has_offset_axes(A, B, ...)
 
 Return `true` if the indices of `A` start with something other than 1 along any axis.
-If multiple arguments are passed, equivalent to `has_offset_axes(A) | has_offset_axes(B) | ...`.
+If multiple arguments are passed, equivalent to `has_offset_axes(A) || has_offset_axes(B) || ...`.
 
 See also [`require_one_based_indexing`](@ref).
 """
+has_offset_axes() = false
 has_offset_axes(A) = _any_tuple(x->Int(first(x))::Int != 1, false, axes(A)...)
 has_offset_axes(A::AbstractVector) = Int(firstindex(A))::Int != 1 # improve performance of a common case (ranges)
-# Use `_any_tuple` to avoid unneeded invoke.
-# note: this could call `any` directly if the compiler can infer it
-has_offset_axes(As...) = _any_tuple(has_offset_axes, false, As...)
 has_offset_axes(::Colon) = false
 has_offset_axes(::Array) = false
+# note: this could call `any` directly if the compiler can infer it. We don't use _any_tuple
+# here because it stops full elision in some cases (#49332) and we don't need handling of
+# `missing` (has_offset_axes(A) always returns a Bool)
+has_offset_axes(A, As...) = has_offset_axes(A) || has_offset_axes(As...)
+
 
 """
     require_one_based_indexing(A::AbstractArray)
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 21b80c257872f..d32bd5794b5fc 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1907,13 +1907,17 @@ end
 
 @testset "type-based offset axes check" begin
     a = randn(ComplexF64, 10)
+    b = randn(ComplexF64, 4, 4, 4, 4)
     ta = reinterpret(Float64, a)
     tb = reinterpret(Float64, view(a, 1:2:10))
     tc = reinterpret(Float64, reshape(view(a, 1:3:10), 2, 2, 1))
+    td = view(b, :, :, 1, 1)
     # Issue #44040
     @test IRUtils.fully_eliminated(Base.require_one_based_indexing, Base.typesof(ta, tc))
     @test IRUtils.fully_eliminated(Base.require_one_based_indexing, Base.typesof(tc, tc))
     @test IRUtils.fully_eliminated(Base.require_one_based_indexing, Base.typesof(ta, tc, tb))
+    # Issue #49332
+    @test IRUtils.fully_eliminated(Base.require_one_based_indexing, Base.typesof(td, td, td))
     # Ranges && CartesianIndices
     @test IRUtils.fully_eliminated(Base.require_one_based_indexing, Base.typesof(1:10, Base.OneTo(10), 1.0:2.0, LinRange(1.0, 2.0, 2), 1:2:10, CartesianIndices((1:2:10, 1:2:10))))
     # Remind us to call `any` in `Base.has_offset_axes` once our compiler is ready.

From 3f468cd580d1592bb82e1c60a2c88a3b1ee9bcaa Mon Sep 17 00:00:00 2001
From: Pablo San-Jose <lekand@gmail.com>
Date: Tue, 30 Jan 2024 01:39:11 +0100
Subject: [PATCH 0741/1315] Add a test to avoid #53054 regressions (#53079)

Tests issue #53054. The same test is included in backport #53074.
---
 stdlib/LinearAlgebra/test/blas.jl | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/stdlib/LinearAlgebra/test/blas.jl b/stdlib/LinearAlgebra/test/blas.jl
index d853b211e7817..80494da7babbe 100644
--- a/stdlib/LinearAlgebra/test/blas.jl
+++ b/stdlib/LinearAlgebra/test/blas.jl
@@ -135,6 +135,19 @@ Random.seed!(100)
             a[begin] = elty(NaN)
             @test BLAS.nrm2(a) === abs2(elty(NaN))
         end
+        @testset "deterministic mul!" begin
+            # mul! should be deterministic, see #53054
+            function tester_53054()
+                C = ComplexF32
+                mat = zeros(C, 1, 1)
+                for _ in 1:100
+                    v = [C(1-0.2im) C(2+0.3im)]
+                    mul!(mat, v, v', C(1+im), 1)
+                end
+                return mat
+            end
+            @test allequal(tester_53054() for _ in 1:10000)
+        end
         @testset "scal" begin
             α = rand(elty)
             a = rand(elty,n)

From fbd14a25f44bbd2b7ef750f869df4a2529466807 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 30 Jan 2024 09:57:05 +0900
Subject: [PATCH 0742/1315] post-opt: fix minor logic errors (#53100)

I've identified and am addressing some minor bugs and optimizations in
the post-opt analysis code upon reviewing it.
---
 base/compiler/optimize.jl | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 2e8c6f913d365..68a0cdcdf7480 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -526,8 +526,8 @@ function visit_bb_phis!(callback, ir::IRCode, bb::Int)
 end
 
 function any_stmt_may_throw(ir::IRCode, bb::Int)
-    for stmt in ir.cfg.blocks[bb].stmts
-        if has_flag(ir[SSAValue(stmt)], IR_FLAG_NOTHROW)
+    for idx in ir.cfg.blocks[bb].stmts
+        if !has_flag(ir[SSAValue(idx)], IR_FLAG_NOTHROW)
             return true
         end
     end
@@ -865,13 +865,14 @@ function ((; sv)::ScanStmt)(inst::Instruction, lstmt::Int, bb::Int)
 end
 
 function check_inconsistentcy!(sv::PostOptAnalysisState, scanner::BBScanner)
+    (; ir, inconsistent, tpdum) = sv
+
     scan!(ScanStmt(sv), scanner, false)
-    complete!(sv.tpdum); push!(scanner.bb_ip, 1)
-    populate_def_use_map!(sv.tpdum, scanner)
+    complete!(tpdum); push!(scanner.bb_ip, 1)
+    populate_def_use_map!(tpdum, scanner)
 
-    (; ir, inconsistent, tpdum) = sv
     stmt_ip = BitSetBoundedMinPrioritySet(length(ir.stmts))
-    for def in sv.inconsistent
+    for def in inconsistent
         for use in tpdum[def]
             if !(use in inconsistent)
                 push!(inconsistent, use)
@@ -879,6 +880,7 @@ function check_inconsistentcy!(sv::PostOptAnalysisState, scanner::BBScanner)
             end
         end
     end
+    lazydomtree = LazyDomtree(ir)
     while !isempty(stmt_ip)
         idx = popfirst!(stmt_ip)
         inst = ir[SSAValue(idx)]
@@ -895,12 +897,11 @@ function check_inconsistentcy!(sv::PostOptAnalysisState, scanner::BBScanner)
             any_non_boundscheck_inconsistent || continue
         elseif isa(stmt, ReturnNode)
             sv.all_retpaths_consistent = false
-        else isa(stmt, GotoIfNot)
+        elseif isa(stmt, GotoIfNot)
             bb = block_for_inst(ir, idx)
             cfg = ir.cfg
             blockliveness = BlockLiveness(cfg.blocks[bb].succs, nothing)
-            domtree = construct_domtree(cfg.blocks)
-            for succ in iterated_dominance_frontier(cfg, blockliveness, domtree)
+            for succ in iterated_dominance_frontier(cfg, blockliveness, get!(lazydomtree))
                 visit_bb_phis!(ir, succ) do phiidx::Int
                     push!(inconsistent, phiidx)
                     push!(stmt_ip, phiidx)

From aa1057356f9cd374c9c4b122cca019bb3b844072 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 27 Jan 2024 18:05:03 +0000
Subject: [PATCH 0743/1315] inference: avoid having one over-widened type
 poison the whole union

I observed `UnitLowerTriangular{T, AbstractMatrix{T}} where T` being
widened to `UnitLowerTriangular{F64, <:Matrix}`, which then forced it to
become `Any`. Avoid that by only widening at most to the wrapper as
required by the earlier check in this function.
---
 base/compiler/typelimits.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/base/compiler/typelimits.jl b/base/compiler/typelimits.jl
index 55502bfb75d2b..933cf4c7b9ab4 100644
--- a/base/compiler/typelimits.jl
+++ b/base/compiler/typelimits.jl
@@ -807,6 +807,7 @@ end
                         end
                         if usep
                             widen = rewrap_unionall(wr{p...}, wr)
+                            widen <: wr || (widen = wr) # sometimes there are cross-constraints on wr that we may lose in this process, but that would cause future calls to this to need to return Any, which is undesirable
                         end
                         simplify[j] = !usep
                     end

From eeebb6eca64fda919acfefb109d23c7cd3f57cc7 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 27 Jan 2024 18:07:47 +0000
Subject: [PATCH 0744/1315] inference: slightly relax union complexity limit

Permits forming AbstractVecOrMat from tmerge(AbstractVector,
AbstractMatrix}. With the standard limit of 3, this now permits a
maximum of either:

 - 2 dispatch-leaf types + 1 other type
 - 2 non-dispatch-leaf types
---
 base/compiler/typelimits.jl |  2 +-
 test/compiler/inference.jl  | 23 ++++++++++++++---------
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/base/compiler/typelimits.jl b/base/compiler/typelimits.jl
index 933cf4c7b9ab4..318ac0b5c27e5 100644
--- a/base/compiler/typelimits.jl
+++ b/base/compiler/typelimits.jl
@@ -312,7 +312,7 @@ union_count_abstract(@nospecialize(x)) = !isdispatchelem(x)
 function issimpleenoughtype(@nospecialize t)
     ut = unwrap_unionall(t)
     ut isa DataType && ut.name.wrapper == t && return true
-    return unionlen(t) + union_count_abstract(t) <= MAX_TYPEUNION_LENGTH &&
+    return max(unionlen(t), union_count_abstract(t) + 1) <= MAX_TYPEUNION_LENGTH &&
            unioncomplexity(t) <= MAX_TYPEUNION_COMPLEXITY
 end
 
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index a797467ff6173..0d46ed1319ae5 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -238,13 +238,18 @@ tuplemerge_test(Tuple{}, Tuple{Complex, Vararg{Union{ComplexF32, ComplexF64}}},
 @test Core.Compiler.tmerge(Union{Nothing, Tuple{Char, Int}}, Tuple{Union{Char, String, SubString{String}, Symbol}, Int}) == Union{Nothing, Tuple{Union{Char, String, SubString{String}, Symbol}, Int}}
 @test Core.Compiler.tmerge(Nothing, Tuple{Integer, Int}) == Union{Nothing, Tuple{Integer, Int}}
 @test Core.Compiler.tmerge(Union{Nothing, Tuple{Int, Int}}, Tuple{Integer, Int}) == Union{Nothing, Tuple{Integer, Int}}
-@test Core.Compiler.tmerge(Union{Nothing, AbstractVector{Int}}, Vector) == Union{Nothing, AbstractVector}
-@test Core.Compiler.tmerge(Union{Nothing, AbstractVector{Int}}, Matrix) == Union{Nothing, AbstractArray}
-@test Core.Compiler.tmerge(Union{Nothing, AbstractVector{Int}}, Matrix{Int}) == Union{Nothing, AbstractArray{Int}}
-@test Core.Compiler.tmerge(Union{Nothing, AbstractVector{Int}}, Array) == Union{Nothing, AbstractArray}
-@test Core.Compiler.tmerge(Union{Nothing, AbstractArray{Int}}, Vector) == Union{Nothing, AbstractArray}
-@test Core.Compiler.tmerge(Union{Nothing, AbstractVector}, Matrix{Int}) == Union{Nothing, AbstractArray}
+@test Core.Compiler.tmerge(Union{Nothing, Int, AbstractVector{Int}}, Vector) == Union{Nothing, Int, AbstractVector}
+@test Core.Compiler.tmerge(Union{Nothing, Int, AbstractVector{Int}}, Matrix) == Union{Nothing, Int, AbstractArray}
+@test Core.Compiler.tmerge(Union{Nothing, Int, AbstractVector{Int}}, Matrix{Int}) == Union{Nothing, Int, AbstractArray{Int}}
+@test Core.Compiler.tmerge(Union{Nothing, Int, AbstractVector{Int}}, Array) == Union{Nothing, Int, AbstractArray}
+@test Core.Compiler.tmerge(Union{Nothing, Int, AbstractArray{Int}}, Vector) == Union{Nothing, Int, AbstractArray}
+@test Core.Compiler.tmerge(Union{Nothing, Int, AbstractVector}, Matrix{Int}) == Union{Nothing, Int, AbstractArray}
 @test Core.Compiler.tmerge(Union{Nothing, AbstractFloat}, Integer) == Union{Nothing, AbstractFloat, Integer}
+@test Core.Compiler.tmerge(AbstractVector, AbstractMatrix) == Union{AbstractVector, AbstractMatrix}
+@test Core.Compiler.tmerge(Union{AbstractVector, Nothing}, AbstractMatrix) == Union{Nothing, AbstractVector, AbstractMatrix}
+@test Core.Compiler.tmerge(Union{AbstractVector, Int}, AbstractMatrix) == Union{Int, AbstractVector, AbstractMatrix}
+@test Core.Compiler.tmerge(Union{AbstractVector, Integer}, AbstractMatrix) == Union{Integer, AbstractArray}
+@test Core.Compiler.tmerge(Union{AbstractVector, Nothing, Int}, AbstractMatrix) == Union{Nothing, Int, AbstractArray}
 
 # test that recursively more complicated types don't widen all the way to Any when there is a useful valid type upper bound
 # Specifically test with base types of a trivial type, a simple union, a complicated union, and a tuple.
@@ -4680,11 +4685,11 @@ end
 
     a = Tuple{Vararg{Tuple{}}}
     a = Core.Compiler.tmerge(Core.Compiler.JLTypeLattice(), Tuple{a}, a)
-    @test a == Tuple{Vararg{Tuple{Vararg{Tuple{}}}}}
+    @test a == Union{Tuple{Tuple{Vararg{Tuple{}}}}, Tuple{Vararg{Tuple{}}}}
     a = Core.Compiler.tmerge(Core.Compiler.JLTypeLattice(), Tuple{a}, a)
-    @test a == Tuple{Vararg{Tuple{Vararg{Tuple{Vararg{Tuple{}}}}}}}
+    @test a == Tuple{Vararg{Union{Tuple{Tuple{Vararg{Tuple{}}}}, Tuple{Vararg{Tuple{}}}}}}
     a = Core.Compiler.tmerge(Core.Compiler.JLTypeLattice(), Tuple{a}, a)
-    @test a == Tuple{Vararg{Tuple{Vararg{Tuple{Vararg{Tuple{Vararg{Tuple{}}}}}}}}}
+    @test a == Tuple
     a = Core.Compiler.tmerge(Core.Compiler.JLTypeLattice(), Tuple{a}, a)
     @test a == Tuple
 end

From 8fdda09eed008c82f2c354af5f39ae70a2886169 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 27 Jan 2024 18:09:46 +0000
Subject: [PATCH 0745/1315] reorder the code in LinearAlgebra.wrap to be
 slightly more inferrable abstractly

By adding a type-assert at the end, we can try to ensure that eltype and
ndims info is preserved, even if inference decides not to preserve the
giant Union in detail. This avoids complete loss of precision in the
subsequent calls (generic_matmatmul! -> _generic_matmatmul!), which has
a type-assert on each input of AbstractVecOrMat.

Closes #53075
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index bace428c1387c..be46a700ab44c 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -480,21 +480,25 @@ wrapper_char(A::Hermitian{<:Real}) = A.uplo == 'U' ? 'S' : 's'
 wrapper_char(A::Symmetric) = A.uplo == 'U' ? 'S' : 's'
 
 Base.@constprop :aggressive function wrap(A::AbstractVecOrMat, tA::AbstractChar)
-    if tA == 'N'
-        return A
+    # merge the result of this before return, so that we can type-assert the return such
+    # that even if the tmerge is inaccurate, inference can still identify that the
+    # `_generic_matmatmul` signature still matches and doesn't require missing backedges
+    B = if tA == 'N'
+        A
     elseif tA == 'T'
-        return transpose(A)
+        transpose(A)
     elseif tA == 'C'
-        return adjoint(A)
+        adjoint(A)
     elseif tA == 'H'
-        return Hermitian(A, :U)
+        Hermitian(A, :U)
     elseif tA == 'h'
-        return Hermitian(A, :L)
+        Hermitian(A, :L)
     elseif tA == 'S'
-        return Symmetric(A, :U)
+        Symmetric(A, :U)
     else # tA == 's'
-        return Symmetric(A, :L)
+        Symmetric(A, :L)
     end
+    return B::AbstractVecOrMat
 end
 
 _unwrap(A::AbstractVecOrMat) = A

From 2f845bb2e19aa05da868f2c55d1994f8d5d4d964 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 29 Jan 2024 21:36:22 -0500
Subject: [PATCH 0746/1315] some minor code cleanup of getHostCPUName handling
 (#53083)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Try to minimize the places the code depends on this library function,
since it is useful for generic code as long as LLVM is available, but we
would also be happy with returning the text "native" here in most cases.

Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com>
---
 src/Makefile               |  7 +++---
 src/processor.cpp          | 49 ++++++++++++++++++++++++++++++++++++++
 src/processor.h            |  2 --
 src/processor_arm.cpp      | 10 --------
 src/processor_fallback.cpp | 10 --------
 src/processor_x86.cpp      | 10 --------
 src/runtime_ccall.cpp      | 37 ----------------------------
 7 files changed, 52 insertions(+), 73 deletions(-)

diff --git a/src/Makefile b/src/Makefile
index 95614d506ba45..5f58c7fa57627 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -77,10 +77,9 @@ else
 # JULIACODEGEN != LLVM
 endif
 
-RT_LLVM_LIBS := support
-
-ifeq ($(LLVM_VER_MAJ),16)
-RT_LLVM_LIBS += targetparser
+RT_LLVM_LIBS := support # for APMath and some other useful ADT
+ifneq ($(LLVM_VER_MAJ),15)
+RT_LLVM_LIBS += targetparser # for getHostCPUName on LLVM 16+
 endif
 
 ifeq ($(OS),WINNT)
diff --git a/src/processor.cpp b/src/processor.cpp
index 34d5dff3c43ee..fc56a93be9787 100644
--- a/src/processor.cpp
+++ b/src/processor.cpp
@@ -6,6 +6,8 @@
 #include <llvm/ADT/StringRef.h>
 #include <llvm/ADT/ArrayRef.h>
 #include <llvm/ADT/SmallVector.h>
+#include <llvm/ADT/StringMap.h>
+#include <llvm/Support/Host.h>
 #include <llvm/Support/MathExtras.h>
 #include <llvm/Support/raw_ostream.h>
 
@@ -961,6 +963,43 @@ static inline void dump_cpu_spec(uint32_t cpu, const FeatureList<n> &features,
 
 }
 
+static std::string jl_get_cpu_name_llvm(void)
+{
+    return llvm::sys::getHostCPUName().str();
+}
+
+static std::string jl_get_cpu_features_llvm(void)
+{
+    llvm::StringMap<bool> HostFeatures;
+    llvm::sys::getHostCPUFeatures(HostFeatures);
+    std::string attr;
+    for (auto &ele: HostFeatures) {
+        if (ele.getValue()) {
+            if (!attr.empty()) {
+                attr.append(",+");
+            }
+            else {
+                attr.append("+");
+            }
+            attr.append(ele.getKey().str());
+        }
+    }
+    // Explicitly disabled features need to be added at the end so that
+    // they are not re-enabled by other features that implies them by default.
+    for (auto &ele: HostFeatures) {
+        if (!ele.getValue()) {
+            if (!attr.empty()) {
+                attr.append(",-");
+            }
+            else {
+                attr.append("-");
+            }
+            attr.append(ele.getKey().str());
+        }
+    }
+    return attr;
+}
+
 #if defined(_CPU_X86_) || defined(_CPU_X86_64_)
 
 #include "processor_x86.cpp"
@@ -975,6 +1014,16 @@ static inline void dump_cpu_spec(uint32_t cpu, const FeatureList<n> &features,
 
 #endif
 
+JL_DLLEXPORT jl_value_t *jl_get_cpu_name(void)
+{
+    return jl_cstr_to_string(host_cpu_name().c_str());
+}
+
+JL_DLLEXPORT jl_value_t *jl_get_cpu_features(void)
+{
+    return jl_cstr_to_string(jl_get_cpu_features_llvm().c_str());
+}
+
 extern "C" JL_DLLEXPORT jl_value_t* jl_reflect_clone_targets() {
     auto specs = jl_get_llvm_clone_targets();
     const uint32_t base_flags = 0;
diff --git a/src/processor.h b/src/processor.h
index 5d80943d363ad..82a1121aaf7c4 100644
--- a/src/processor.h
+++ b/src/processor.h
@@ -264,8 +264,6 @@ struct jl_target_spec_t {
  * Return the list of targets to clone
  */
 extern "C" JL_DLLEXPORT llvm::SmallVector<jl_target_spec_t, 0> jl_get_llvm_clone_targets(void) JL_NOTSAFEPOINT;
-std::string jl_get_cpu_name_llvm(void) JL_NOTSAFEPOINT;
-std::string jl_get_cpu_features_llvm(void) JL_NOTSAFEPOINT;
 // NOLINTEND(clang-diagnostic-return-type-c-linkage)
 struct FeatureName {
     const char *name;
diff --git a/src/processor_arm.cpp b/src/processor_arm.cpp
index d7672016f00d0..0d069b085ac47 100644
--- a/src/processor_arm.cpp
+++ b/src/processor_arm.cpp
@@ -1827,16 +1827,6 @@ JL_DLLEXPORT void jl_dump_host_cpu(void)
                   cpus, ncpu_names);
 }
 
-JL_DLLEXPORT jl_value_t *jl_get_cpu_name(void)
-{
-    return jl_cstr_to_string(host_cpu_name().c_str());
-}
-
-JL_DLLEXPORT jl_value_t *jl_get_cpu_features(void)
-{
-    return jl_cstr_to_string(jl_get_cpu_features_llvm().c_str());
-}
-
 JL_DLLEXPORT jl_value_t *jl_cpu_has_fma(int bits)
 {
 #ifdef _CPU_AARCH64_
diff --git a/src/processor_fallback.cpp b/src/processor_fallback.cpp
index 92842d3db6c64..1c266e29e9dd7 100644
--- a/src/processor_fallback.cpp
+++ b/src/processor_fallback.cpp
@@ -162,16 +162,6 @@ llvm::SmallVector<jl_target_spec_t, 0> jl_get_llvm_clone_targets(void)
     return res;
 }
 
-JL_DLLEXPORT jl_value_t *jl_get_cpu_name(void)
-{
-    return jl_cstr_to_string(host_cpu_name().c_str());
-}
-
-JL_DLLEXPORT jl_value_t *jl_get_cpu_features(void)
-{
-    return jl_cstr_to_string(jl_get_cpu_features_llvm().c_str());
-}
-
 JL_DLLEXPORT jl_value_t *jl_cpu_has_fma(int bits)
 {
     return jl_false; // Match behaviour of have_fma in src/llvm-cpufeatures.cpp (assume false)
diff --git a/src/processor_x86.cpp b/src/processor_x86.cpp
index bfada3c88fb1d..24363d2d9d28f 100644
--- a/src/processor_x86.cpp
+++ b/src/processor_x86.cpp
@@ -1063,16 +1063,6 @@ JL_DLLEXPORT jl_value_t* jl_check_pkgimage_clones(char *data)
     return jl_nothing;
 }
 
-JL_DLLEXPORT jl_value_t *jl_get_cpu_name(void)
-{
-    return jl_cstr_to_string(host_cpu_name().c_str());
-}
-
-JL_DLLEXPORT jl_value_t *jl_get_cpu_features(void)
-{
-    return jl_cstr_to_string(jl_get_cpu_features_llvm().c_str());
-}
-
 JL_DLLEXPORT jl_value_t *jl_cpu_has_fma(int bits)
 {
     TargetData<feature_sz> target = jit_targets.front();
diff --git a/src/runtime_ccall.cpp b/src/runtime_ccall.cpp
index 652dbedc7ebf3..25be49d6d2f3f 100644
--- a/src/runtime_ccall.cpp
+++ b/src/runtime_ccall.cpp
@@ -4,7 +4,6 @@
 #include <map>
 #include <string>
 #include <llvm/ADT/StringMap.h>
-#include <llvm/Support/Host.h>
 #include <llvm/Support/raw_ostream.h>
 
 #include "julia.h"
@@ -84,42 +83,6 @@ void *jl_lazy_load_and_lookup(jl_value_t *lib_val, const char *f_name)
 }
 
 // miscellany
-std::string jl_get_cpu_name_llvm(void)
-{
-    return llvm::sys::getHostCPUName().str();
-}
-
-std::string jl_get_cpu_features_llvm(void)
-{
-    StringMap<bool> HostFeatures;
-    llvm::sys::getHostCPUFeatures(HostFeatures);
-    std::string attr;
-    for (auto &ele: HostFeatures) {
-        if (ele.getValue()) {
-            if (!attr.empty()) {
-                attr.append(",+");
-            }
-            else {
-                attr.append("+");
-            }
-            attr.append(ele.getKey().str());
-        }
-    }
-    // Explicitly disabled features need to be added at the end so that
-    // they are not re-enabled by other features that implies them by default.
-    for (auto &ele: HostFeatures) {
-        if (!ele.getValue()) {
-            if (!attr.empty()) {
-                attr.append(",-");
-            }
-            else {
-                attr.append("-");
-            }
-            attr.append(ele.getKey().str());
-        }
-    }
-    return attr;
-}
 
 extern "C" JL_DLLEXPORT
 jl_value_t *jl_get_JIT(void)

From 8cb585404ea508fcd29cb6e9d86d24727199d100 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Mon, 29 Jan 2024 20:42:51 -0600
Subject: [PATCH 0747/1315] fix fd_in_limits test on Windows (#52779)

Closes #52506
Note that this test dates back to #26341
---
 stdlib/FileWatching/test/runtests.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/FileWatching/test/runtests.jl b/stdlib/FileWatching/test/runtests.jl
index a02ed3931a349..1538be77d1695 100644
--- a/stdlib/FileWatching/test/runtests.jl
+++ b/stdlib/FileWatching/test/runtests.jl
@@ -24,7 +24,7 @@ for i in 1:n
         uv_error("pipe", ccall(:uv_pipe, Cint, (Ptr{NTuple{2, Base.OS_HANDLE}}, Cint, Cint), Ref(pipe_fds, i), 0, 0))
     end
     Ctype = Sys.iswindows() ? Ptr{Cvoid} : Cint
-    FDmax = Sys.iswindows() ? 0x7fff : (n + 60 + (isdefined(Main, :Revise) * 30)) # expectations on reasonable values
+    FDmax = Sys.iswindows() ? typemax(Int32) : (n + 60 + (isdefined(Main, :Revise) * 30)) # expectations on reasonable values
     fd_in_limits =
         0 <= Int(Base.cconvert(Ctype, pipe_fds[i][1])) <= FDmax &&
         0 <= Int(Base.cconvert(Ctype, pipe_fds[i][2])) <= FDmax

From 9816a0b9772f157899b98044145802e133812473 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Mon, 29 Jan 2024 23:34:15 -0600
Subject: [PATCH 0748/1315] Reland "Don't export Dates.adjust" (#53092)

---
 NEWS.md                       |  2 ++
 stdlib/Dates/src/Dates.jl     |  2 +-
 stdlib/Dates/src/adjusters.jl | 12 ++++++------
 3 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index dd16151ffa74c..6eb7e6509c69f 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -165,6 +165,8 @@ Standard library changes
 
 #### Dates
 
+The undocumented function `adjust` is no longer exported but is now documented
+
 #### Statistics
 
 * Statistics is now an upgradeable standard library ([#46501]).
diff --git a/stdlib/Dates/src/Dates.jl b/stdlib/Dates/src/Dates.jl
index a111ea24089c4..bbfcdbee3f3d1 100644
--- a/stdlib/Dates/src/Dates.jl
+++ b/stdlib/Dates/src/Dates.jl
@@ -77,7 +77,7 @@ export Period, DatePeriod, TimePeriod,
        firstdayofmonth, lastdayofmonth,
        firstdayofyear, lastdayofyear,
        firstdayofquarter, lastdayofquarter,
-       adjust, tonext, toprev, tofirst, tolast,
+       tonext, toprev, tofirst, tolast,
        # io.jl
        ISODateTimeFormat, ISODateFormat, ISOTimeFormat, DateFormat, RFC1123Format, @dateformat_str
 
diff --git a/stdlib/Dates/src/adjusters.jl b/stdlib/Dates/src/adjusters.jl
index dee2894ff5d4e..0d6cea5dc3e6b 100644
--- a/stdlib/Dates/src/adjusters.jl
+++ b/stdlib/Dates/src/adjusters.jl
@@ -216,24 +216,24 @@ The default values for parameters `start` and `limit` are 1 Day and 10,000 respe
 
 # Examples
 ```jldoctest
-julia> adjust(date -> month(date) == 10, Date(2022, 1, 1), step=Month(3), limit=10)
+julia> Dates.adjust(date -> month(date) == 10, Date(2022, 1, 1), step=Month(3), limit=10)
 2022-10-01
 
-julia> adjust(date -> year(date) == 2025, Date(2022, 1, 1), step=Year(1), limit=4)
+julia> Dates.adjust(date -> year(date) == 2025, Date(2022, 1, 1), step=Year(1), limit=4)
 2025-01-01
 
-julia> adjust(date -> day(date) == 15, Date(2022, 1, 1), step=Year(1), limit=3)
+julia> Dates.adjust(date -> day(date) == 15, Date(2022, 1, 1), step=Year(1), limit=3)
 ERROR: ArgumentError: Adjustment limit reached: 3 iterations
 Stacktrace:
 [...]
 
-julia> adjust(date -> month(date) == 10, Date(2022, 1, 1))
+julia> Dates.adjust(date -> month(date) == 10, Date(2022, 1, 1))
 2022-10-01
 
-julia> adjust(date -> year(date) == 2025, Date(2022, 1, 1))
+julia> Dates.adjust(date -> year(date) == 2025, Date(2022, 1, 1))
 2025-01-01
 
-julia> adjust(date -> year(date) == 2224, Date(2022, 1, 1))
+julia> Dates.adjust(date -> year(date) == 2224, Date(2022, 1, 1))
 ERROR: ArgumentError: Adjustment limit reached: 10000 iterations
 Stacktrace:
 [...]

From 75c38e3fdb0875bf0f5df3a7f0f6625556c9e2e8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Tue, 30 Jan 2024 08:30:00 +0000
Subject: [PATCH 0749/1315] Make relocatedepot test more robust (#53110)

As discussed in the `#ci-dev` call (see
https://github.com/JuliaLang/julia/issues/53103#issuecomment-1915458694
and
https://github.com/JuliaLang/julia/pull/53104#discussion_r1470021366)
there were two problems:

* the use of `Base.require` caused the package to be loaded
* the name of the package was a generic placeholder, and clashed with
other packages loaded during the tests called with the same generic
name.

The solution was to rename test module with a more specific name, and
replace `Base.require` with `Base.compilecache`, the latter only
compiles the package without loading it.

Should fix #53103, close #53104.
---
 test/relocatedepot.jl | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
index 10149ffc2398a..0a514e7786916 100644
--- a/test/relocatedepot.jl
+++ b/test/relocatedepot.jl
@@ -145,9 +145,9 @@ if !test_relocated_depot
                     Base.require(pkg)
                     mktempdir() do depot3
                         # precompile Foo in depot3
-                        open(joinpath(depot3, "Foo.jl"), write=true) do io
+                        open(joinpath(depot3, "Module52161.jl"), write=true) do io
                             println(io, """
-                            module Foo
+                            module Module52161
                             using Example1
                             using Example2
                             srcfile1 = joinpath(pkgdir(Example1), "src", "Example1.jl")
@@ -159,13 +159,13 @@ if !test_relocated_depot
                         end
                         pushfirst!(LOAD_PATH, depot3)
                         pushfirst!(DEPOT_PATH, depot3)
-                        pkg = Base.identify_package("Foo")
-                        Base.require(pkg)
+                        pkg = Base.identify_package("Module52161")
+                        Base.compilecache(pkg)
                         cachefile = joinpath(depot3, "compiled",
-                                             "v$(VERSION.major).$(VERSION.minor)", "Foo.ji")
+                                             "v$(VERSION.major).$(VERSION.minor)", "Module52161.ji")
                         _, (deps, _, _), _... = Base.parse_cache_header(cachefile)
                         @test map(x -> x.filename, deps) ==
-                            [ joinpath(depot3, "Foo.jl"),
+                            [ joinpath(depot3, "Module52161.jl"),
                               joinpath(depot1, "Example1", "src", "Example1.jl"),
                               joinpath(depot2, "Example2", "src", "Example2.jl") ]
                     end

From b7520d954bfb93339ac249ef500fabe2d173357f Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Tue, 30 Jan 2024 15:55:20 +0100
Subject: [PATCH 0750/1315] `stale_cachefile`: account for path separator when
 checking @depot  (#53058)

---
 base/loading.jl | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index fb056f5f61c7c..37e49708239d9 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2748,7 +2748,7 @@ function restore_depot_path(path::AbstractString, depot::AbstractString)
 end
 
 function resolve_depot(inc::AbstractString)
-    startswith(inc, "@depot") || return :not_relocatable
+    startswith(inc, string("@depot", Filesystem.pathsep())) || return :not_relocatable
     for depot in DEPOT_PATH
         isfile(restore_depot_path(inc, depot)) && return depot
     end
@@ -2927,7 +2927,7 @@ function _read_dependency_src(io::IO, filename::AbstractString, includes::Vector
         filenamelen == 0 && break
         depotfn = String(read(io, filenamelen))
         len = read(io, UInt64)
-        fn = if !startswith(depotfn, "@depot")
+        fn = if !startswith(depotfn, string("@depot", Filesystem.pathsep()))
             depotfn
         else
             basefn = restore_depot_path(depotfn, "")
@@ -3441,7 +3441,7 @@ end
             end
             for chi in includes
                 f, fsize_req, hash_req, ftime_req = chi.filename, chi.fsize, chi.hash, chi.mtime
-                if startswith(f, "@depot/")
+                if startswith(f, string("@depot", Filesystem.pathsep()))
                     @debug("Rejecting stale cache file $cachefile because its depot could not be resolved")
                     record_reason(reasons, "nonresolveable depot")
                     return true

From 9f5f540e52fd3928fb32f50b91f6f66754362ef0 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 30 Jan 2024 13:58:00 -0500
Subject: [PATCH 0751/1315] remove length from Stateful (#51747)

Stateful iterators do not have a consistent notion of length, as it is
continuously changing as elements are removed. As the main purpose of
Stateful is to take elements from multiple places, any notion of
HaveShape is invalid for those cases, and thus not useful in general.

Fix #47790
---
 base/iterators.jl | 50 ++++++++++++-----------------------------------
 test/iterators.jl | 31 +++++++++++++++++++----------
 2 files changed, 33 insertions(+), 48 deletions(-)

diff --git a/base/iterators.jl b/base/iterators.jl
index a03d426e05622..b51920cdddb68 100644
--- a/base/iterators.jl
+++ b/base/iterators.jl
@@ -973,7 +973,7 @@ cycle(xs) = Cycle(xs)
 
 eltype(::Type{Cycle{I}}) where {I} = eltype(I)
 IteratorEltype(::Type{Cycle{I}}) where {I} = IteratorEltype(I)
-IteratorSize(::Type{Cycle{I}}) where {I} = IsInfinite()
+IteratorSize(::Type{Cycle{I}}) where {I} = IsInfinite() # XXX: this is false if iterator ever becomes empty
 
 iterate(it::Cycle) = iterate(it.xs)
 isdone(it::Cycle) = isdone(it.xs)
@@ -1422,43 +1422,30 @@ julia> sum(a) # Sum the remaining elements
 7
 ```
 """
-mutable struct Stateful{T, VS, N<:Integer}
+mutable struct Stateful{T, VS}
     itr::T
     # A bit awkward right now, but adapted to the new iteration protocol
     nextvalstate::Union{VS, Nothing}
-
-    # Number of remaining elements, if itr is HasLength or HasShape.
-    # if not, store -1 - number_of_consumed_elements.
-    # This allows us to defer calculating length until asked for.
-    # See PR #45924
-    remaining::N
     @inline function Stateful{<:Any, Any}(itr::T) where {T}
-        itl = iterlength(itr)
-        new{T, Any, typeof(itl)}(itr, iterate(itr), itl)
+        return new{T, Any}(itr, iterate(itr))
     end
     @inline function Stateful(itr::T) where {T}
         VS = approx_iter_type(T)
-        itl = iterlength(itr)
-        return new{T, VS, typeof(itl)}(itr, iterate(itr)::VS, itl)
+        return new{T, VS}(itr, iterate(itr)::VS)
     end
 end
 
-function iterlength(it)::Signed
-    if IteratorSize(it) isa Union{HasShape, HasLength}
-       return length(it)
-    else
-        -1
-    end
+function reset!(s::Stateful)
+    setfield!(s, :nextvalstate, iterate(s.itr)) # bypass convert call of setproperty!
+    return s
 end
-
-function reset!(s::Stateful{T,VS}, itr::T=s.itr) where {T,VS}
+function reset!(s::Stateful{T}, itr::T) where {T}
     s.itr = itr
-    itl = iterlength(itr)
-    setfield!(s, :nextvalstate, iterate(itr))
-    s.remaining = itl
-    s
+    reset!(s)
+    return s
 end
 
+
 # Try to find an appropriate type for the (value, state tuple),
 # by doing a recursive unrolling of the iteration protocol up to
 # fixpoint.
@@ -1480,7 +1467,6 @@ end
 
 Stateful(x::Stateful) = x
 convert(::Type{Stateful}, itr) = Stateful(itr)
-
 @inline isdone(s::Stateful, st=nothing) = s.nextvalstate === nothing
 
 @inline function popfirst!(s::Stateful)
@@ -1490,8 +1476,6 @@ convert(::Type{Stateful}, itr) = Stateful(itr)
     else
         val, state = vs
         Core.setfield!(s, :nextvalstate, iterate(s.itr, state))
-        rem = s.remaining
-        s.remaining = rem - typeof(rem)(1)
         return val
     end
 end
@@ -1501,20 +1485,10 @@ end
     return ns !== nothing ? ns[1] : sentinel
 end
 @inline iterate(s::Stateful, state=nothing) = s.nextvalstate === nothing ? nothing : (popfirst!(s), nothing)
-IteratorSize(::Type{<:Stateful{T}}) where {T} = IteratorSize(T) isa HasShape ? HasLength() : IteratorSize(T)
+IteratorSize(::Type{<:Stateful{T}}) where {T} = IteratorSize(T) isa IsInfinite ? IsInfinite() : SizeUnknown()
 eltype(::Type{<:Stateful{T}}) where {T} = eltype(T)
 IteratorEltype(::Type{<:Stateful{T}}) where {T} = IteratorEltype(T)
 
-function length(s::Stateful)
-    rem = s.remaining
-    # If rem is actually remaining length, return it.
-    # else, rem is number of consumed elements.
-    if rem >= 0
-        rem
-    else
-        length(s.itr) - (typeof(rem)(1) - rem)
-    end
-end
 end # if statement several hundred lines above
 
 """
diff --git a/test/iterators.jl b/test/iterators.jl
index d8184eab7b656..6fd308a31d746 100644
--- a/test/iterators.jl
+++ b/test/iterators.jl
@@ -853,8 +853,10 @@ end
         v, s = iterate(z)
         @test Base.isdone(z, s)
     end
-    # Stateful wrapping mutable iterators of known length (#43245)
-    @test length(Iterators.Stateful(Iterators.Stateful(1:5))) == 5
+    # Stateful does not define length
+    let s = Iterators.Stateful(Iterators.Stateful(1:5))
+        @test_throws MethodError length(s)
+    end
 end
 
 @testset "pair for Svec" begin
@@ -866,6 +868,10 @@ end
 @testset "inference for large zip #26765" begin
     x = zip(1:2, ["a", "b"], (1.0, 2.0), Base.OneTo(2), Iterators.repeated("a"), 1.0:0.2:2.0,
             (1 for i in 1:2), Iterators.Stateful(["a", "b", "c"]), (1.0 for i in 1:2, j in 1:3))
+    @test Base.IteratorSize(x) isa Base.SizeUnknown
+    x = zip(1:2, ["a", "b"], (1.0, 2.0), Base.OneTo(2), Iterators.repeated("a"), 1.0:0.2:2.0,
+            (1 for i in 1:2), Iterators.cycle(Iterators.Stateful(["a", "b", "c"])), (1.0 for i in 1:2, j in 1:3))
+    @test Base.IteratorSize(x) isa Base.HasLength
     @test @inferred(length(x)) == 2
     z = Iterators.filter(x -> x[1] >= 1, x)
     @test @inferred(eltype(z)) <: Tuple{Int,String,Float64,Int,String,Float64,Any,String,Any}
@@ -874,20 +880,20 @@ end
 end
 
 @testset "Stateful fix #30643" begin
-    @test Base.IteratorSize(1:10) isa Base.HasShape
+    @test Base.IteratorSize(1:10) isa Base.HasShape{1}
     a = Iterators.Stateful(1:10)
-    @test Base.IteratorSize(a) isa Base.HasLength
-    @test length(a) == 10
+    @test Base.IteratorSize(a) isa Base.SizeUnknown
+    @test !Base.isdone(a)
     @test length(collect(a)) == 10
-    @test length(a) == 0
+    @test Base.isdone(a)
     b = Iterators.Stateful(Iterators.take(1:10,3))
-    @test Base.IteratorSize(b) isa Base.HasLength
-    @test length(b) == 3
+    @test Base.IteratorSize(b) isa Base.SizeUnknown
+    @test !Base.isdone(b)
     @test length(collect(b)) == 3
-    @test length(b) == 0
+    @test Base.isdone(b)
     c = Iterators.Stateful(Iterators.countfrom(1))
     @test Base.IteratorSize(c) isa Base.IsInfinite
-    @test length(Iterators.take(c,3)) == 3
+    @test !Base.isdone(Iterators.take(c,3))
     @test length(collect(Iterators.take(c,3))) == 3
     d = Iterators.Stateful(Iterators.filter(isodd,1:10))
     @test Base.IteratorSize(d) isa Base.SizeUnknown
@@ -1010,6 +1016,11 @@ end
     @test collect(Iterators.partition(lstrip("01111", '0'), 2)) == ["11", "11"]
 end
 
+let itr = (i for i in 1:9) # Base.eltype == Any
+    @test first(Iterators.partition(itr, 3)) isa Vector{Any}
+    @test collect(zip(repeat([Iterators.Stateful(itr)], 3)...)) == [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
+end
+
 @testset "no single-argument map methods" begin
     maps = (tuple, Returns(nothing), (() -> nothing))
     mappers = (Iterators.map, map, foreach)

From ef69db66352130660ef73f98ddf3a3a4d0585b96 Mon Sep 17 00:00:00 2001
From: Frames White <oxinabox@ucc.asn.au>
Date: Wed, 31 Jan 2024 04:40:16 +0800
Subject: [PATCH 0752/1315] Don't mention __precompile__(false) in error
 message (#53099)

I am fairly sure nothing in my dep tree uses `__precompile__(false)` so
this message is misleading.
I know we changed another of them a while ago
---
 base/loading.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/loading.jl b/base/loading.jl
index 37e49708239d9..a262537963375 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2153,7 +2153,7 @@ function _require(pkg::PkgId, env=nothing)
                 elseif isa(cachefile, Exception)
                     if precompilableerror(cachefile)
                         verbosity = isinteractive() ? CoreLogging.Info : CoreLogging.Debug
-                        @logmsg verbosity "Skipping precompilation since __precompile__(false). Importing $pkg."
+                        @logmsg verbosity "Skipping precompilation due to precompilable error. Importing $pkg." exception=m
                     else
                         @warn "The call to compilecache failed to create a usable precompiled cache file for $pkg" exception=m
                     end

From fdb342c56d91a1262d70abc31383a9d6084042b6 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Tue, 30 Jan 2024 21:40:35 +0100
Subject: [PATCH 0753/1315] make `keytype` and `valtype` work for `UnionAll`
 `AbstractDict`s (#53116)

Fixes #53115
---
 base/abstractdict.jl |  4 ++--
 test/dict.jl         | 21 +++++++++++++++++++++
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/base/abstractdict.jl b/base/abstractdict.jl
index 39898ae71970f..5ca485610f053 100644
--- a/base/abstractdict.jl
+++ b/base/abstractdict.jl
@@ -301,7 +301,7 @@ julia> keytype(Dict(Int32(1) => "foo"))
 Int32
 ```
 """
-keytype(::Type{<:AbstractDict{K,V}}) where {K,V} = K
+keytype(::Type{<:AbstractDict{K}}) where {K} = K
 keytype(a::AbstractDict) = keytype(typeof(a))
 
 """
@@ -315,7 +315,7 @@ julia> valtype(Dict(Int32(1) => "foo"))
 String
 ```
 """
-valtype(::Type{<:AbstractDict{K,V}}) where {K,V} = V
+valtype(::Type{<:AbstractDict{<:Any,V}}) where {V} = V
 valtype(a::AbstractDict) = valtype(typeof(a))
 
 """
diff --git a/test/dict.jl b/test/dict.jl
index f00c7c4747672..f44c6d696bc74 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -1519,3 +1519,24 @@ let d = Dict()
     d[1.0] = 'b'
     @test only(d) === Pair{Any,Any}(1.0, 'b')
 end
+
+@testset "UnionAll `keytype` and `valtype` (issue #53115)" begin
+    K = Int8
+    V = Int16
+    dicts = (
+        AbstractDict, IdDict, Dict, WeakKeyDict, Base.ImmutableDict,
+        Base.PersistentDict, Iterators.Pairs
+    )
+
+    @testset "D: $D" for D ∈ dicts
+        @test_throws MethodError keytype(D)
+        @test_throws MethodError keytype(D{<:Any,V})
+        @test                    keytype(D{K      }) == K
+        @test                    keytype(D{K,    V}) == K
+
+        @test_throws MethodError valtype(D)
+        @test                    valtype(D{<:Any,V}) == V
+        @test_throws MethodError valtype(D{K      })
+        @test                    valtype(D{K,    V}) == V
+    end
+end

From 9f643a01a96d12363cd3f202a6b4ba43a21440f4 Mon Sep 17 00:00:00 2001
From: Matt Bauman <mbauman@juliahub.com>
Date: Tue, 30 Jan 2024 16:06:19 -0500
Subject: [PATCH 0754/1315] Fix invalid let syntax from LHS views (#53108)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When the frontend lowers an expression like `lhs .+= rhs`, it needs to
prevent evaluating the LHS more than once before re-writing to `lhs .=
lhs .+ rhs`. If the LHS was a `let` block — commonly generated by
`@views` and (since #53064) `@view` — the lowering pass had previously
been emitting an invalid `let` temporary. This very directly addresses
that case.

Fixes #53107.
Fixes #44356.
---
 src/julia-syntax.scm |  6 ++++--
 test/subarray.jl     | 44 ++++++++++++++++++++++++++++++++++++++++++++
 test/syntax.jl       | 18 ++++++++++++++++++
 3 files changed, 66 insertions(+), 2 deletions(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 855102276a6e5..674a04cb1e563 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1653,8 +1653,10 @@
                  (let ((g (make-ssavalue)))
                    (begin (set! a (cons `(= ,g ,x) a))
                           g)))))
-        (cons (cons (car e) (map arg-to-temp (cdr e)))
-              (reverse a)))))
+        (if (eq? (car e) 'let)
+          (cons (arg-to-temp e) (reverse a))
+          (cons (cons (car e) (map arg-to-temp (cdr e)))
+                (reverse a))))))
 
 (define (lower-kw-call f args)
   (let* ((para (if (has-parameters? args) (cdar args) '()))
diff --git a/test/subarray.jl b/test/subarray.jl
index 40877d842df76..dd71b1c770b3a 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -637,6 +637,44 @@ end
         @test foo == [X, X]
     end
 
+    # Test as an assignment's left hand side
+    let x = [1,2,3,4]
+        @test Meta.@lower(@view(x[1]) = 1).head == :error
+        @test Meta.@lower(@view(x[1]) += 1).head == :error
+        @test Meta.@lower(@view(x[end]) = 1).head == :error
+        @test Meta.@lower(@view(x[end]) += 1).head == :error
+        @test Meta.@lower(@view(f(x)[end]) = 1).head == :error
+        @test Meta.@lower(@view(f(x)[end]) += 1).head == :error
+        @test (@view(x[1]) .+= 1) == fill(2)
+        @test x == [2,2,3,4]
+        @test (@view(reshape(x,2,2)[1,1]) .+= 10) == fill(12)
+        @test x == [12,2,3,4]
+        @test (@view(x[end]) .+= 1) == fill(5)
+        @test x == [12,2,3,5]
+        @test (@view(reshape(x,2,2)[end]) .+= 10) == fill(15)
+        @test x == [12,2,3,15]
+        @test (@view(reshape(x,2,2)[[begin],[begin,end]])::AbstractMatrix{Int} .+= [2]) == [14 5]
+        @test x == [14,2,5,15]
+
+        x = [1,2,3,4]
+        @test Meta.@lower(@views(x[[1]]) = 1).head == :error
+        @test Meta.@lower(@views(x[[1]]) += 1).head == :error
+        @test Meta.@lower(@views(x[[end]]) = 1).head == :error
+        @test Meta.@lower(@views(x[[end]]) += 1).head == :error
+        @test Meta.@lower(@views(f(x)[end]) = 1).head == :error
+        @test Meta.@lower(@views(f(x)[end]) += 1).head == :error
+        @test (@views(x[[1]]) .+= 1) == [2]
+        @test x == [2,2,3,4]
+        @test (@views(reshape(x,2,2)[[1],1]) .+= 10) == [12]
+        @test x == [12,2,3,4]
+        @test (@views(x[[end]]) .+= 1) == [5]
+        @test x == [12,2,3,5]
+        @test (@views(reshape(x,2,2)[[end]]) .+= 10) == [15]
+        @test x == [12,2,3,15]
+        @test (@views(reshape(x,2,2)[[begin],[begin,end]])::AbstractMatrix{Int} .+= [2]) == [14 5]
+        @test x == [14,2,5,15]
+    end
+
     # test @views macro
     @views let f!(x) = x[begin:end-1] .+= x[begin+1:end].^2
         x = [1,2,3,4]
@@ -663,6 +701,12 @@ end
         @test x == [5,8,12,9] && i == [4,3]
         @. x[3:end] = 0       # make sure @. works with end expressions in @views
         @test x == [5,8,0,0]
+        x[begin:end] .+= 1
+        @test x == [6,9,1,1]
+        x[[begin,2,end]] .-= [1,2,3]
+        @test x == [5,7,1,-2]
+        @. x[[begin,2,end]] .+= [1,2,3]
+        @test x == [6,9,1,1]
     end
     @views @test isa(X[1:3], SubArray)
     @test X[begin:end] == @views X[begin:end]
diff --git a/test/syntax.jl b/test/syntax.jl
index 4d204f3e29364..a0021864da0e0 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -3619,3 +3619,21 @@ end
     @test p("public[7] = 5") == Expr(:(=), Expr(:ref, :public, 7), 5)
     @test p("public() = 6") == Expr(:(=), Expr(:call, :public), Expr(:block, 6))
 end
+
+@testset "removing argument sideeffects" begin
+    # Allow let blocks in broadcasted LHSes, but only evaluate them once:
+    execs = 0
+    array = [1]
+    let x = array; execs += 1; x; end .+= 2
+    @test array == [3]
+    @test execs == 1
+    let; execs += 1; array; end .= 4
+    @test array == [4]
+    @test execs == 2
+    let x = array; execs += 1; x; end::Vector{Int} .+= 2
+    @test array == [6]
+    @test execs == 3
+    let; execs += 1; array; end::Vector{Int} .= 7
+    @test array == [7]
+    @test execs == 4
+end

From 432d248ccbf6fb8a56baea3330649bc989bf6f9e Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Tue, 30 Jan 2024 23:13:49 +0100
Subject: [PATCH 0755/1315] Restrict some argument types for
 _truncate_at_width_or_chars (#53031)

This resolved some invalidations for me in a package
---
 base/show.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/show.jl b/base/show.jl
index e6990b231bfba..8c59bb3bd9f6d 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -80,7 +80,7 @@ function iterate(I::ANSIIterator, (i, m_st)=(1, iterate(I.captures)))
 end
 textwidth(I::ANSIIterator) = mapreduce(textwidth∘last, +, I; init=0)
 
-function _truncate_at_width_or_chars(ignore_ANSI::Bool, str, width, rpad=false, chars="\r\n", truncmark="…")
+function _truncate_at_width_or_chars(ignore_ANSI::Bool, str::AbstractString, width::Int, rpad::Bool=false, chars="\r\n", truncmark="…")
     truncwidth = textwidth(truncmark)
     (width <= 0 || width < truncwidth) && return ""
     wid = truncidx = lastidx = 0

From 4b1bbeb2f22107d210bdd76d2a9b46ee59f5aaf5 Mon Sep 17 00:00:00 2001
From: Lorenzo Van Munoz <66997677+lxvm@users.noreply.github.com>
Date: Tue, 30 Jan 2024 17:27:09 -0500
Subject: [PATCH 0756/1315] make `Base.reduced_indices` more type-stable
 (#52905)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This fixes #35199 by rewriting `Base.reduced_indices` to be
type stable (and grounded). I was also able to remove a method since
that case is covered by the general case.

The changes are illustrated by the following quick benchmarks:

```julia
julia> VERSION
v"1.10.0"

julia> using BenchmarkTools

julia> M = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> @btime sum($M, dims=$(2))
  194.816 ns (5 allocations: 160 bytes)
2×1 Matrix{Int64}:
 3
 7

julia> @btime sum($M, dims=$((2,)))
  209.385 ns (5 allocations: 224 bytes)
2×1 Matrix{Int64}:
 3
 7

julia> function my_reduced_indices(inds::Base.Indices{N}, region) where N
           rinds = inds
           for i in region
               isa(i, Integer) || throw(ArgumentError("reduced dimension(s) must be integers"))
               d = Int(i)
               if d < 1
                   throw(ArgumentError("region dimension(s) must be ≥ 1, got $d"))
               elseif d <= N
                   rinds = let rinds_=rinds
                       ntuple(j -> j == d ? Base.reduced_index(rinds_[d]) : rinds_[j], Val(N))
                   end
               end
           end
           rinds
       end
my_reduced_indices (generic function with 1 method)

julia> Base.reduced_indices(inds::Base.Indices{N}, region::Int) where N = my_reduced_indices(inds, region)

julia> Base.reduced_indices(inds::Base.Indices{N}, region) where N = my_reduced_indices(inds, region)

julia> @btime sum($M, dims=$(2))
  43.582 ns (1 allocation: 80 bytes)
2×1 Matrix{Int64}:
 3
 7

julia> @btime sum($M, dims=$((2,)))
  43.882 ns (1 allocation: 80 bytes)
2×1 Matrix{Int64}:
 3
 7
```

I also rewrote `Base.reduced_indices0` in the same fashion. I wasn't
sure how to add tests for this since the improvements are to
type-groundedness. Since these changes affect all reductions I hope this
solution is robust.
---
 base/reducedim.jl | 58 ++++++++---------------------------------------
 test/reducedim.jl | 12 ++++++++++
 2 files changed, 22 insertions(+), 48 deletions(-)

diff --git a/base/reducedim.jl b/base/reducedim.jl
index 21dff3b46ab37..1a7a6feb33d5e 100644
--- a/base/reducedim.jl
+++ b/base/reducedim.jl
@@ -17,59 +17,21 @@ reduced_indices(a::AbstractArrayOrBroadcasted, region) = reduced_indices(axes(a)
 # for reductions that keep 0 dims as 0
 reduced_indices0(a::AbstractArray, region) = reduced_indices0(axes(a), region)
 
-function reduced_indices(inds::Indices{N}, d::Int) where N
-    d < 1 && throw(ArgumentError("dimension must be ≥ 1, got $d"))
-    if d == 1
-        return (reduced_index(inds[1]), tail(inds)...)::typeof(inds)
-    elseif 1 < d <= N
-        return tuple(inds[1:d-1]..., oftype(inds[d], reduced_index(inds[d])), inds[d+1:N]...)::typeof(inds)
-    else
-        return inds
-    end
+function reduced_indices(axs::Indices{N}, region) where N
+    _check_valid_region(region)
+    ntuple(d -> d in region ? reduced_index(axs[d]) : axs[d], Val(N))
 end
 
-function reduced_indices0(inds::Indices{N}, d::Int) where N
-    d < 1 && throw(ArgumentError("dimension must be ≥ 1, got $d"))
-    if d <= N
-        ind = inds[d]
-        rd = isempty(ind) ? ind : reduced_index(inds[d])
-        if d == 1
-            return (rd, tail(inds)...)::typeof(inds)
-        else
-            return tuple(inds[1:d-1]..., oftype(inds[d], rd), inds[d+1:N]...)::typeof(inds)
-        end
-    else
-        return inds
-    end
+function reduced_indices0(axs::Indices{N}, region) where N
+    _check_valid_region(region)
+    ntuple(d -> d in region && !isempty(axs[d]) ? reduced_index(axs[d]) : axs[d], Val(N))
 end
 
-function reduced_indices(inds::Indices{N}, region) where N
-    rinds = collect(inds)
-    for i in region
-        isa(i, Integer) || throw(ArgumentError("reduced dimension(s) must be integers"))
-        d = Int(i)
-        if d < 1
-            throw(ArgumentError("region dimension(s) must be ≥ 1, got $d"))
-        elseif d <= N
-            rinds[d] = reduced_index(rinds[d])
-        end
-    end
-    tuple(rinds...)::typeof(inds)
-end
-
-function reduced_indices0(inds::Indices{N}, region) where N
-    rinds = collect(inds)
-    for i in region
-        isa(i, Integer) || throw(ArgumentError("reduced dimension(s) must be integers"))
-        d = Int(i)
-        if d < 1
-            throw(ArgumentError("region dimension(s) must be ≥ 1, got $d"))
-        elseif d <= N
-            rind = rinds[d]
-            rinds[d] = isempty(rind) ? rind : reduced_index(rind)
-        end
+function _check_valid_region(region)
+    for d in region
+        isa(d, Integer) || throw(ArgumentError("reduced dimension(s) must be integers"))
+        Int(d) < 1 && throw(ArgumentError("region dimension(s) must be ≥ 1, got $d"))
     end
-    tuple(rinds...)::typeof(inds)
 end
 
 ###### Generic reduction functions #####
diff --git a/test/reducedim.jl b/test/reducedim.jl
index f4767dd7a472c..77ed94664539f 100644
--- a/test/reducedim.jl
+++ b/test/reducedim.jl
@@ -124,6 +124,18 @@ fill!(r, -6.3)
 fill!(r, -1.1)
 @test sum!(abs2, r, Breduc, init=false) ≈ safe_sumabs2(Breduc, 1) .- 1.1
 
+# issue #35199
+function issue35199_test(sizes, dims)
+    M = rand(Float64, sizes)
+    ax = axes(M)
+    n1 = @allocations Base.reduced_indices(ax, dims)
+    return @test n1 == 0
+end
+for dims in (1, 2, (1,), (2,), (1,2))
+    sizes = (64, 3)
+    issue35199_test(sizes, dims)
+end
+
 # Small arrays with init=false
 let A = reshape(1:15, 3, 5)
     R = fill(1, 3)

From 9df7a67f026d99741b0cb477397016717310394b Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Tue, 30 Jan 2024 18:09:05 -0500
Subject: [PATCH 0757/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20ArgTools=20stdlib=20from=204eccde4=20to=20997089b=20(#53124)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: ArgTools
URL: https://github.com/JuliaIO/ArgTools.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 4eccde4
New commit: 997089b
Julia version: 1.11.0-DEV
ArgTools version: 1.1.2(Does not match)
Bump invoked by: @vtjnash
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaIO/ArgTools.jl/compare/4eccde45ddc27e4f7fc9094b2861c684e062adb2...997089b9cd56404b40ff766759662e16dc1aab4b

```
$ git log --oneline 4eccde4..997089b
997089b fix tests for TEMP_CLEANUP, which might be a Lockable (#35)
4a5f003 build(deps): bump actions/cache from 3 to 4 (#36)
84ba9e8 Hardcode doc edit backlink (#34)
9238839 build(deps): bump actions/checkout from 3 to 4 (#33)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/ArgTools.version                                         | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/ArgTools-4eccde45ddc27e4f7fc9094b2861c684e062adb2.tar.gz/md5
 delete mode 100644 deps/checksums/ArgTools-4eccde45ddc27e4f7fc9094b2861c684e062adb2.tar.gz/sha512
 create mode 100644 deps/checksums/ArgTools-997089b9cd56404b40ff766759662e16dc1aab4b.tar.gz/md5
 create mode 100644 deps/checksums/ArgTools-997089b9cd56404b40ff766759662e16dc1aab4b.tar.gz/sha512

diff --git a/deps/checksums/ArgTools-4eccde45ddc27e4f7fc9094b2861c684e062adb2.tar.gz/md5 b/deps/checksums/ArgTools-4eccde45ddc27e4f7fc9094b2861c684e062adb2.tar.gz/md5
deleted file mode 100644
index e0fdf5c76bcc5..0000000000000
--- a/deps/checksums/ArgTools-4eccde45ddc27e4f7fc9094b2861c684e062adb2.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-87d5afd4bf8c66b6e598da521dafad41
diff --git a/deps/checksums/ArgTools-4eccde45ddc27e4f7fc9094b2861c684e062adb2.tar.gz/sha512 b/deps/checksums/ArgTools-4eccde45ddc27e4f7fc9094b2861c684e062adb2.tar.gz/sha512
deleted file mode 100644
index 3339d6d582c3e..0000000000000
--- a/deps/checksums/ArgTools-4eccde45ddc27e4f7fc9094b2861c684e062adb2.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-0586684ecb31c68840643fa0006a3bb5c042845b89182ca9c67dd6c92863e73c045f5c5dabe9e2d758c9c42288c957935dab1b48c91820cfcf2b240b6902f015
diff --git a/deps/checksums/ArgTools-997089b9cd56404b40ff766759662e16dc1aab4b.tar.gz/md5 b/deps/checksums/ArgTools-997089b9cd56404b40ff766759662e16dc1aab4b.tar.gz/md5
new file mode 100644
index 0000000000000..3e85638390011
--- /dev/null
+++ b/deps/checksums/ArgTools-997089b9cd56404b40ff766759662e16dc1aab4b.tar.gz/md5
@@ -0,0 +1 @@
+44175a2843f243a8f2e01cd1e781ecc9
diff --git a/deps/checksums/ArgTools-997089b9cd56404b40ff766759662e16dc1aab4b.tar.gz/sha512 b/deps/checksums/ArgTools-997089b9cd56404b40ff766759662e16dc1aab4b.tar.gz/sha512
new file mode 100644
index 0000000000000..f5690055f63f4
--- /dev/null
+++ b/deps/checksums/ArgTools-997089b9cd56404b40ff766759662e16dc1aab4b.tar.gz/sha512
@@ -0,0 +1 @@
+8a9d0f20cd8fa0ed072966debc691597bb09b34836465f52595b9b2525e80b194c7176781495573dd2f9a02b142e832e59f0dccef15afa184543775d58dc7987
diff --git a/stdlib/ArgTools.version b/stdlib/ArgTools.version
index ad2febe81e46e..09090a62ce0bf 100644
--- a/stdlib/ArgTools.version
+++ b/stdlib/ArgTools.version
@@ -1,4 +1,4 @@
 ARGTOOLS_BRANCH = master
-ARGTOOLS_SHA1 = 4eccde45ddc27e4f7fc9094b2861c684e062adb2
+ARGTOOLS_SHA1 = 997089b9cd56404b40ff766759662e16dc1aab4b
 ARGTOOLS_GIT_URL := https://github.com/JuliaIO/ArgTools.jl.git
 ARGTOOLS_TAR_URL = https://api.github.com/repos/JuliaIO/ArgTools.jl/tarball/$1

From 12953797e0a2fc2739f6383cf56e362993851f36 Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Tue, 30 Jan 2024 20:24:10 -0500
Subject: [PATCH 0758/1315] put a try catch around calls to `propertynames` in
 tab completion. (#53127)

fixes https://github.com/JuliaLang/julia/issues/53126
---
 stdlib/REPL/src/REPLCompletions.jl  | 11 +++++++----
 stdlib/REPL/test/replcompletions.jl |  5 +++++
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 02e6f36ad93ca..ed58e41be470a 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -190,11 +190,14 @@ function complete_symbol(@nospecialize(ex), name::String, @nospecialize(ffunc),
             append!(suggestions, filtered_mod_names(p, mod, name, true, false))
         end
     elseif val !== nothing # looking for a property of an instance
-        for property in propertynames(val, false)
-            # TODO: support integer arguments (#36872)
-            if property isa Symbol && startswith(string(property), name)
-                push!(suggestions, PropertyCompletion(val, property))
+        try
+            for property in propertynames(val, false)
+                # TODO: support integer arguments (#36872)
+                if property isa Symbol && startswith(string(property), name)
+                    push!(suggestions, PropertyCompletion(val, property))
+                end
             end
+        catch
         end
     elseif field_completion_eligible(t)
         # Looking for a member of a type
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index ac4f34b7b9180..49838d4879dab 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2247,3 +2247,8 @@ let s = "using ...Issue52922.Inn"
     @test res
     @test "Inner2" in c
 end
+
+struct Issue53126
+end
+Base.propertynames(::Type{A}) = error()
+@test isempty(test_complete_foo(A))

From dc474d8b2af54a8d2c48774aa92b0b47f9740032 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 30 Jan 2024 20:28:11 -0500
Subject: [PATCH 0759/1315] inference: avoid adding duplicate edges as invoke
 targets (#53121)

This was inefficient, though not wrong.

Fixes #53020
---
 base/compiler/ssair/inlining.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index c39616143d933..e6438b3f9325f 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -827,7 +827,7 @@ function compileable_specialization(mi::MethodInstance, effects::Effects,
         end
     end
     add_inlining_backedge!(et, mi) # to the dispatch lookup
-    push!(et.edges, method.sig, mi_invoke) # add_inlining_backedge to the invoke call
+    mi_invoke !== mi && push!(et.edges, method.sig, mi_invoke) # add_inlining_backedge to the invoke call, if that is different
     return InvokeCase(mi_invoke, effects, info)
 end
 

From 2730f29e6d5c1d0f4dabfc21693aab057aae941b Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sat, 21 Oct 2023 19:48:18 +0800
Subject: [PATCH 0760/1315] Introduce AnnotatedIOBuffer

This allows for styled content to be constructed incrementally, without
resorting to repeated concatenation. It operates very similarly to
IOContext, just with a special `write` method and specifically wrapping
an IOBuffer.
---
 base/strings/annotated.jl | 50 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index c0f3623f41696..05bd366a80782 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -386,3 +386,53 @@ annotations(s::SubString{<:AnnotatedString}, pos::UnitRange{<:Integer}) =
 Get all annotations of `chr`.
 """
 annotations(c::AnnotatedChar) = c.annotations
+
+## AnnotatedIOBuffer
+
+struct AnnotatedIOBuffer <: IO
+    io::IOBuffer
+    annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+end
+
+AnnotatedIOBuffer(io::IOBuffer) = AnnotatedIOBuffer(io, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
+AnnotatedIOBuffer() = AnnotatedIOBuffer(IOBuffer())
+
+function show(io::IO, annio::AnnotatedIOBuffer)
+    show(io, AnnotatedIOBuffer)
+    print(io, '(', annio.io.size, " bytes)")
+end
+
+position(io::AnnotatedIOBuffer) = position(io.io)
+lock(io::AnnotatedIOBuffer) = lock(io.io)
+unlock(io::AnnotatedIOBuffer) = unlock(io.io)
+
+function write(io::AnnotatedIOBuffer, astr::Union{AnnotatedString, SubString{<:AnnotatedString}})
+    astr = AnnotatedString(astr)
+    offset = position(io.io)
+    for (region, annot) in astr.annotations
+        start, stop = first(region), last(region)
+        push!(io.annotations, (start+offset:stop+offset, annot))
+    end
+    write(io.io, String(astr))
+end
+write(io::AnnotatedIOBuffer, c::AnnotatedChar) = write(io, AnnotatedString(c))
+write(io::AnnotatedIOBuffer, x::AbstractString) = write(io.io, x)
+write(io::AnnotatedIOBuffer, s::Union{SubString{String}, String}) = write(io.io, s)
+write(io::AnnotatedIOBuffer, x::UInt8) = write(io.io, x)
+
+"""
+    read(io::AnnotatedIOBuffer, AnnotatedString)
+
+Read the entirety of `io`, as an `AnnotatedString`. This preserves the
+annotations of any `AnnotatedString`s written to `io` and otherwise acts like
+`read(io::IO, String)`.
+"""
+function read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{String}})
+    str = String(take!(io.io))
+    annots = copy(io.annotations)
+    empty!(io.annotations)
+    seekstart(io.io)
+    AnnotatedString(str, annots)
+end
+read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{AbstractString}}) = read(io, AnnotatedString{String})
+read(io::AnnotatedIOBuffer, ::Type{AnnotatedString}) = read(io, AnnotatedString{String})

From 311553e4987e0dd426fc9d0bc9e8587f04b89281 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 14 Dec 2023 23:09:51 +0800
Subject: [PATCH 0761/1315] Make AnnotatedIOBuffer behave more like IOBuffer

A few extra methods help a lot. It also turns out that we don't actually
need to implement lock/unlock, the fallback implementations are enough.
---
 base/strings/annotated.jl | 56 ++++++++++++++++++++++++++++++---------
 1 file changed, 43 insertions(+), 13 deletions(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 05bd366a80782..4a23fd037e62e 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -397,14 +397,27 @@ end
 AnnotatedIOBuffer(io::IOBuffer) = AnnotatedIOBuffer(io, Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}())
 AnnotatedIOBuffer() = AnnotatedIOBuffer(IOBuffer())
 
-function show(io::IO, annio::AnnotatedIOBuffer)
+function show(io::IO, aio::AnnotatedIOBuffer)
     show(io, AnnotatedIOBuffer)
-    print(io, '(', annio.io.size, " bytes)")
+    print(io, '(', aio.io.size, " byte", ifelse(aio.io.size == 1, "", "s"), ", ",
+          length(aio.annotations), " annotation", ifelse(length(aio.annotations) == 1, "", "s"), ")")
 end
 
+isopen(io::AnnotatedIOBuffer) = isopen(io.io)
+close(io::AnnotatedIOBuffer) = close(io.io)
+closewrite(io::AnnotatedIOBuffer) = closewrite(io.io)
+eof(io::AnnotatedIOBuffer) = eof(io.io)
+peek(io::AnnotatedIOBuffer) = peek(io.io)
 position(io::AnnotatedIOBuffer) = position(io.io)
-lock(io::AnnotatedIOBuffer) = lock(io.io)
-unlock(io::AnnotatedIOBuffer) = unlock(io.io)
+seek(io::AnnotatedIOBuffer, n::Integer) = (seek(io.io, n); io)
+skip(io::AnnotatedIOBuffer, n::Integer) = (skip(io.io, n); io)
+mark(io::AnnotatedIOBuffer) = mark(io.io)
+reset(io::AnnotatedIOBuffer) = reset(io.io)
+unmark(io::AnnotatedIOBuffer) = unmark(io.io)
+ismarked(io::AnnotatedIOBuffer) = ismarked(io.io)
+copy(io::AnnotatedIOBuffer) = AnnotatedIOBuffer(copy(io.io), copy(io.annotations))
+unsafe_write(io::AnnotatedIOBuffer, b::Ptr{UInt8}, len::UInt) = unsafe_write(io.io, b, len)
+unsafe_read(io::AnnotatedIOBuffer, b::Ptr{UInt8}, len::UInt) = unsafe_read(io.io, b, len)
 
 function write(io::AnnotatedIOBuffer, astr::Union{AnnotatedString, SubString{<:AnnotatedString}})
     astr = AnnotatedString(astr)
@@ -418,21 +431,38 @@ end
 write(io::AnnotatedIOBuffer, c::AnnotatedChar) = write(io, AnnotatedString(c))
 write(io::AnnotatedIOBuffer, x::AbstractString) = write(io.io, x)
 write(io::AnnotatedIOBuffer, s::Union{SubString{String}, String}) = write(io.io, s)
-write(io::AnnotatedIOBuffer, x::UInt8) = write(io.io, x)
+write(io::AnnotatedIOBuffer, b::UInt8) = write(io.io, b)
 
 """
     read(io::AnnotatedIOBuffer, AnnotatedString)
 
-Read the entirety of `io`, as an `AnnotatedString`. This preserves the
-annotations of any `AnnotatedString`s written to `io` and otherwise acts like
-`read(io::IO, String)`.
+Read `io` as an `AnnotatedString`, jumping to the start if `eof(io)` holds.
+This preserves the annotations of any `AnnotatedString`s written to `io` and
+otherwise acts like `read(io::IO, String)`.
 """
 function read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{String}})
-    str = String(take!(io.io))
-    annots = copy(io.annotations)
-    empty!(io.annotations)
-    seekstart(io.io)
-    AnnotatedString(str, annots)
+    if eof(io)
+        seekstart(io.io)
+        AnnotatedString(read(io.io, String), copy(io.annotations))
+    else
+        start = position(io.io)
+        annots = map(((range, val),) -> (max(1, first(range) - start):last(range)-start, val),
+                     filter(((range, _),) -> last(range) > start,
+                            io.annotations))
+        AnnotatedString(read(io.io, String), annots)
+    end
 end
 read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{AbstractString}}) = read(io, AnnotatedString{String})
 read(io::AnnotatedIOBuffer, ::Type{AnnotatedString}) = read(io, AnnotatedString{String})
+read(io::AnnotatedIOBuffer, x) = read(io.io, x)
+# Avoid method ambiguity
+read(io::AnnotatedIOBuffer, s::Type{String}) = read(io.io, s)
+read(io::AnnotatedIOBuffer, b::Type{UInt8}) = read(io.io, b)
+
+function truncate(io::AnnotatedIOBuffer, size::Integer)
+    truncate(io.io, size)
+    filter!(((range, _),) -> first(range) <= size, io.annotations)
+    map!(((range, val),) -> (first(range):min(size, last(range)), val),
+         io.annotations, io.annotations)
+    io
+end

From cb9b00d7e6fc1594ace128c46e2cf8b33bdb4b8e Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 31 Jan 2024 17:18:01 +0900
Subject: [PATCH 0762/1315] follow up #53127, fix the broken test case (#53134)

---
 stdlib/REPL/test/replcompletions.jl | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 49838d4879dab..22ef938002514 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2248,7 +2248,10 @@ let s = "using ...Issue52922.Inn"
     @test "Inner2" in c
 end
 
-struct Issue53126
+struct Issue53126 end
+Base.propertynames(::Issue53126) = error("this should not be called")
+let s = "Issue53126()."
+    c, r, res = test_complete_context(s)
+    @test res
+    @test isempty(c)
 end
-Base.propertynames(::Type{A}) = error()
-@test isempty(test_complete_foo(A))

From cc74d241be9f023ceb6d2ded7314bfbd02f8b17c Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 31 Jan 2024 17:39:57 +0530
Subject: [PATCH 0763/1315] Inplace transpose for unit Triangular may skip
 diagonal (#53101)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Since the diagonal elements of a `UnitUpperTriangular` are given by
`onelement`, these should be unchanged under `transpose/adjoint`, and we
don't need to access these elements in the parent array when performing
in-place operations.

Fixes
```julia
julia> using LinearAlgebra

julia> M = Matrix{BigFloat}(undef, 2, 2);

julia> M[1,2] = 3;

julia> U = UnitUpperTriangular(M)
2×2 UnitUpperTriangular{BigFloat, Matrix{BigFloat}}:
 1.0  3.0
  ⋅   1.0

julia> transpose!(U)
ERROR: UndefRefError: access to undefined reference
Stacktrace:
 [1] getindex
   @ ./essentials.jl:882 [inlined]
 [2] getindex
   @ ./array.jl:915 [inlined]
 [3] copytri!
   @ ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/matmul.jl:414 [inlined]
 [4] transpose!(A::UnitUpperTriangular{BigFloat, Matrix{BigFloat}})
   @ LinearAlgebra ~/packages/julias/julia-latest/share/julia/stdlib/v1.11/LinearAlgebra/src/triangular.jl:470
 [5] top-level scope
   @ REPL[5]:1
```
After this PR:
```julia
julia> transpose!(U)
2×2 UnitLowerTriangular{BigFloat, Matrix{BigFloat}}:
 1.0   ⋅
 3.0  1.0
```
---
 stdlib/LinearAlgebra/src/triangular.jl  |  8 ++++----
 stdlib/LinearAlgebra/test/triangular.jl | 26 ++++++++++++++++++++++---
 2 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 9590944f7b406..18c2edf15eb54 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -465,13 +465,13 @@ transpose(A::UnitLowerTriangular) = UnitUpperTriangular(transpose(A.data))
 transpose(A::UnitUpperTriangular) = UnitLowerTriangular(transpose(A.data))
 
 transpose!(A::LowerTriangular) = UpperTriangular(copytri!(A.data, 'L', false, true))
-transpose!(A::UnitLowerTriangular) = UnitUpperTriangular(copytri!(A.data, 'L', false, true))
+transpose!(A::UnitLowerTriangular) = UnitUpperTriangular(copytri!(A.data, 'L', false, false))
 transpose!(A::UpperTriangular) = LowerTriangular(copytri!(A.data, 'U', false, true))
-transpose!(A::UnitUpperTriangular) = UnitLowerTriangular(copytri!(A.data, 'U', false, true))
+transpose!(A::UnitUpperTriangular) = UnitLowerTriangular(copytri!(A.data, 'U', false, false))
 adjoint!(A::LowerTriangular) = UpperTriangular(copytri!(A.data, 'L' , true, true))
-adjoint!(A::UnitLowerTriangular) = UnitUpperTriangular(copytri!(A.data, 'L' , true, true))
+adjoint!(A::UnitLowerTriangular) = UnitUpperTriangular(copytri!(A.data, 'L' , true, false))
 adjoint!(A::UpperTriangular) = LowerTriangular(copytri!(A.data, 'U' , true, true))
-adjoint!(A::UnitUpperTriangular) = UnitLowerTriangular(copytri!(A.data, 'U' , true, true))
+adjoint!(A::UnitUpperTriangular) = UnitLowerTriangular(copytri!(A.data, 'U' , true, false))
 
 diag(A::LowerTriangular) = diag(A.data)
 diag(A::UnitLowerTriangular) = fill(oneunit(eltype(A)), size(A,1))
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index 36c5b78bd9a21..69011e69167a3 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -26,7 +26,7 @@ debug && println("Test basic type functionality")
 @test LowerTriangular(randn(3, 3)) |> t -> [size(t, i) for i = 1:3] == [size(Matrix(t), i) for i = 1:3]
 
 # The following test block tries to call all methods in base/linalg/triangular.jl in order for a combination of input element types. Keep the ordering when adding code.
-for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFloat}, Int)
+@testset for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFloat}, Int)
     # Begin loop for first Triangular matrix
     for (t1, uplo1) in ((UpperTriangular, :U),
                         (UnitUpperTriangular, :U),
@@ -998,9 +998,12 @@ end
 
 @testset "arithmetic with partly uninitialized matrices" begin
     @testset "$(typeof(A))" for A in (Matrix{BigFloat}(undef,2,2), Matrix{Complex{BigFloat}}(undef,2,2)')
-        A[1,1] = A[2,2] = A[2,1] = 4
+        A[2,1] = eltype(A) <: Complex ? 4 + 3im : 4
         B = Matrix{eltype(A)}(undef, size(A))
         for MT in (LowerTriangular, UnitLowerTriangular)
+            if MT == LowerTriangular
+                A[1,1] = A[2,2] = eltype(A) <: Complex ? 4 + 3im : 4
+            end
             L = MT(A)
             B .= 0
             copyto!(B, L)
@@ -1009,13 +1012,23 @@ end
             @test 2\L == 2\B
             @test real(L) == real(B)
             @test imag(L) == imag(B)
+            if A isa Matrix
+                @test transpose!(MT(copy(A))) == transpose(L)
+                @test adjoint!(MT(copy(A))) == adjoint(L)
+            else
+                @test_broken transpose!(MT(copy(A))) == transpose(L)
+                @test_broken adjoint!(MT(copy(A))) == adjoint(L)
+            end
         end
     end
 
     @testset "$(typeof(A))" for A in (Matrix{BigFloat}(undef,2,2), Matrix{Complex{BigFloat}}(undef,2,2)')
-        A[1,1] = A[2,2] = A[1,2] = 4
+        A[1,2] = eltype(A) <: Complex ? 4 + 3im : 4
         B = Matrix{eltype(A)}(undef, size(A))
         for MT in (UpperTriangular, UnitUpperTriangular)
+            if MT == UpperTriangular
+                A[1,1] = A[2,2] = eltype(A) <: Complex ? 4 + 3im : 4
+            end
             U = MT(A)
             B .= 0
             copyto!(B, U)
@@ -1024,6 +1037,13 @@ end
             @test 2\U == 2\B
             @test real(U) == real(B)
             @test imag(U) == imag(B)
+            if A isa Matrix
+                @test transpose!(MT(copy(A))) == transpose(U)
+                @test adjoint!(MT(copy(A))) == adjoint(U)
+            else
+                @test_broken transpose!(MT(copy(A))) == transpose(U)
+                @test_broken adjoint!(MT(copy(A))) == adjoint(U)
+            end
         end
     end
 end

From 81deb5edd1242c3be027bbfdf762d34fe68c472c Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Wed, 31 Jan 2024 11:01:30 -0500
Subject: [PATCH 0764/1315] fix pkgimage.mk tree (#53133)

Taken from https://github.com/JuliaLang/julia/pull/53111
---
 pkgimage.mk      | 6 +++---
 stdlib/stdlib.mk | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pkgimage.mk b/pkgimage.mk
index 3c741db2c2202..4fd23fbe8fa2c 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -73,6 +73,7 @@ $(eval $(call stdlib_builder,Sockets,))
 $(eval $(call stdlib_builder,Unicode,))
 $(eval $(call stdlib_builder,Profile,))
 $(eval $(call stdlib_builder,StyledStrings,))
+$(eval $(call stdlib_builder,SuiteSparse_jll,))
 
 # 1-depth packages
 $(eval $(call stdlib_builder,GMP_jll,Artifacts Libdl))
@@ -94,7 +95,7 @@ $(eval $(call stdlib_builder,Printf,Unicode))
 $(eval $(call stdlib_builder,Random,SHA))
 $(eval $(call stdlib_builder,Tar,ArgTools,SHA))
 $(eval $(call stdlib_builder,DelimitedFiles,Mmap))
-$(eval $(call stdlib_builder,JuliaSyntaxHighlighting,))
+$(eval $(call stdlib_builder,JuliaSyntaxHighlighting,StyledStrings))
 
 # 2-depth packages
 $(eval $(call stdlib_builder,LLD_jll,Zlib_jll libLLVM_jll Artifacts Libdl))
@@ -130,6 +131,5 @@ $(eval $(call stdlib_builder,Pkg, Artifacts Dates Downloads FileWatching LibGit2
 # 7-depth packages
 $(eval $(call stdlib_builder,LazyArtifacts,Artifacts Pkg))
 
-$(eval $(call stdlib_builder,SparseArrays,Libdl LinearAlgebra Random Serialization))
+$(eval $(call stdlib_builder,SparseArrays,Libdl LinearAlgebra Random Serialization SuiteSparse_jll))
 $(eval $(call stdlib_builder,Statistics,LinearAlgebra SparseArrays))
-# SuiteSparse_jll
diff --git a/stdlib/stdlib.mk b/stdlib/stdlib.mk
index eeb0e085c8790..4b3b138b374f3 100644
--- a/stdlib/stdlib.mk
+++ b/stdlib/stdlib.mk
@@ -6,7 +6,7 @@ INDEPENDENT_STDLIBS := \
 	ArgTools Base64 CRC32c Dates DelimitedFiles Distributed Downloads Future \
 	InteractiveUtils JuliaSyntaxHighlighting LazyArtifacts LibGit2 LibCURL Logging \
     Markdown Mmap NetworkOptions Profile Printf Pkg REPL Serialization SharedArrays \
-    SparseArrays Statistics StyledStrings Tar Test TOML Unicode UUIDs \
+    SparseArrays Statistics StyledStrings SuiteSparse_jll Tar Test TOML Unicode UUIDs \
 	dSFMT_jll GMP_jll libLLVM_jll LLD_jll LLVMLibUnwind_jll LibUnwind_jll LibUV_jll \
 	LibCURL_jll LibSSH2_jll LibGit2_jll nghttp2_jll  MozillaCACerts_jll MbedTLS_jll \
 	MPFR_jll OpenLibm_jll PCRE2_jll p7zip_jll Zlib_jll

From 83041110e1812a21e1a94a21834694ffd2664d81 Mon Sep 17 00:00:00 2001
From: Nathan Daly <NHDaly@gmail.com>
Date: Wed, 31 Jan 2024 16:49:59 +0000
Subject: [PATCH 0765/1315] Add `Base.checked_pow(x,y)` to `Base.Checked`
 library (#52849)

Fixes #52262.

Performs `^(x, y)` but throws OverflowError on overflow.

Example:
```julia
julia> 2^62
4611686018427387904

julia> 2^63
-9223372036854775808

julia> checked_pow(2, 63)
ERROR: OverflowError: 2147483648 * 4294967296 overflowed for type Int64
```

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
---
 base/checked.jl        | 15 ++++++++++++++-
 base/intfuncs.jl       | 11 ++++++-----
 doc/src/base/math.md   |  1 +
 test/checked.jl        | 22 ++++++++++++++++++++-
 test/compiler/ssair.jl | 43 ++++++++++++++++++++----------------------
 5 files changed, 62 insertions(+), 30 deletions(-)

diff --git a/base/checked.jl b/base/checked.jl
index d5b4112397e84..b374d34830280 100644
--- a/base/checked.jl
+++ b/base/checked.jl
@@ -13,7 +13,7 @@ return both the unchecked results and a boolean value denoting the presence of a
 module Checked
 
 export checked_neg, checked_abs, checked_add, checked_sub, checked_mul,
-       checked_div, checked_rem, checked_fld, checked_mod, checked_cld,
+       checked_div, checked_rem, checked_fld, checked_mod, checked_cld, checked_pow,
        checked_length, add_with_overflow, sub_with_overflow, mul_with_overflow
 
 import Core.Intrinsics:
@@ -358,6 +358,19 @@ The overflow protection may impose a perceptible performance penalty.
 """
 checked_cld(x::T, y::T) where {T<:Integer} = cld(x, y) # Base.cld already checks
 
+"""
+    Base.checked_pow(x, y)
+
+Calculates `^(x,y)`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+checked_pow(x::Integer, y::Integer) = checked_power_by_squaring(x, y)
+
+checked_power_by_squaring(x_, p::Integer) = Base.power_by_squaring(x_, p; mul = checked_mul)
+# For Booleans, the default implementation covers all cases.
+checked_power_by_squaring(x::Bool, p::Integer) = Base.power_by_squaring(x, p)
+
 """
     Base.checked_length(r)
 
diff --git a/base/intfuncs.jl b/base/intfuncs.jl
index ea35da0910736..916cd28a32c6f 100644
--- a/base/intfuncs.jl
+++ b/base/intfuncs.jl
@@ -309,14 +309,15 @@ to_power_type(x) = convert(Base._return_type(*, Tuple{typeof(x), typeof(x)}), x)
     "\nMake x a float matrix by adding a zero decimal ",
     "(e.g., [2.0 1.0;1.0 0.0]^", p, " instead of [2 1;1 0]^", p, ")",
     "or write float(x)^", p, " or Rational.(x)^", p, ".")))
-@assume_effects :terminates_locally function power_by_squaring(x_, p::Integer)
+# The * keyword supports `*=checked_mul` for `checked_pow`
+@assume_effects :terminates_locally function power_by_squaring(x_, p::Integer; mul=*)
     x = to_power_type(x_)
     if p == 1
         return copy(x)
     elseif p == 0
         return one(x)
     elseif p == 2
-        return x*x
+        return mul(x, x)
     elseif p < 0
         isone(x) && return copy(x)
         isone(-x) && return iseven(p) ? one(x) : copy(x)
@@ -325,16 +326,16 @@ to_power_type(x) = convert(Base._return_type(*, Tuple{typeof(x), typeof(x)}), x)
     t = trailing_zeros(p) + 1
     p >>= t
     while (t -= 1) > 0
-        x *= x
+        x = mul(x, x)
     end
     y = x
     while p > 0
         t = trailing_zeros(p) + 1
         p >>= t
         while (t -= 1) >= 0
-            x *= x
+            x = mul(x, x)
         end
-        y *= x
+        y = mul(y, x)
     end
     return y
 end
diff --git a/doc/src/base/math.md b/doc/src/base/math.md
index cff841d991880..86a7e4d8d3173 100644
--- a/doc/src/base/math.md
+++ b/doc/src/base/math.md
@@ -151,6 +151,7 @@ Base.Checked.checked_rem
 Base.Checked.checked_fld
 Base.Checked.checked_mod
 Base.Checked.checked_cld
+Base.Checked.checked_pow
 Base.Checked.add_with_overflow
 Base.Checked.sub_with_overflow
 Base.Checked.mul_with_overflow
diff --git a/test/checked.jl b/test/checked.jl
index bbc53ddb55ed2..7ee28186f9783 100644
--- a/test/checked.jl
+++ b/test/checked.jl
@@ -3,7 +3,7 @@
 # Checked integer arithmetic
 
 import Base: checked_abs, checked_neg, checked_add, checked_sub, checked_mul,
-             checked_div, checked_rem, checked_fld, checked_mod, checked_cld,
+             checked_div, checked_rem, checked_fld, checked_mod, checked_cld, checked_pow,
              add_with_overflow, sub_with_overflow, mul_with_overflow
 
 # checked operations
@@ -166,6 +166,19 @@ import Base: checked_abs, checked_neg, checked_add, checked_sub, checked_mul,
     @test checked_cld(typemin(T), T(1)) === typemin(T)
     @test_throws DivideError checked_cld(typemin(T), T(0))
     @test_throws DivideError checked_cld(typemin(T), T(-1))
+
+    @test checked_pow(T(1), T(0)) === T(1)
+    @test checked_pow(typemax(T), T(0)) === T(1)
+    @test checked_pow(typemin(T), T(0)) === T(1)
+    @test checked_pow(T(1), T(1)) === T(1)
+    @test checked_pow(T(1), typemax(T)) === T(1)
+    @test checked_pow(T(2), T(2)) === T(4)
+    @test_throws OverflowError checked_pow(T(2), typemax(T))
+    @test_throws OverflowError checked_pow(T(-2), typemax(T))
+    @test_throws OverflowError checked_pow(typemax(T), T(2))
+    @test_throws OverflowError checked_pow(typemin(T), T(2))
+    @test_throws DomainError checked_pow(T(2), -T(1))
+    @test_throws DomainError checked_pow(-T(2), -T(1))
 end
 
 @testset for T in (UInt8, UInt16, UInt32, UInt64, UInt128)
@@ -296,6 +309,10 @@ end
     @test checked_cld(true, true) === true
     @test checked_cld(false, true) === false
     @test_throws DivideError checked_cld(true, false)
+
+    @test checked_pow(true, 1) === true
+    @test checked_pow(true, 1000000) === true
+    @test checked_pow(false, 1000000) === false
 end
 @testset "BigInt" begin
     @test checked_abs(BigInt(-1)) == BigInt(1)
@@ -310,6 +327,9 @@ end
     @test checked_fld(BigInt(10), BigInt(3)) == BigInt(3)
     @test checked_mod(BigInt(9), BigInt(4)) == BigInt(1)
     @test checked_cld(BigInt(10), BigInt(3)) == BigInt(4)
+
+    @test checked_pow(BigInt(2), 2) == BigInt(4)
+    @test checked_pow(BigInt(2), 100) == BigInt(1267650600228229401496703205376)
 end
 
 @testset "Additional tests" begin
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 491638f7596d9..c640ee4f82f2b 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -549,21 +549,23 @@ import Core.Compiler: NewInstruction, insert_node!
 let ir = Base.code_ircode((Int,Int); optimize_until="inlining") do a, b
         a^b
     end |> only |> first
-    @test length(ir.stmts) == 2
-    @test Meta.isexpr(ir.stmts[1][:stmt], :invoke)
+    nstmts = length(ir.stmts)
+    invoke_idx = findfirst(@nospecialize(stmt)->Meta.isexpr(stmt, :invoke), ir.stmts.stmt)
+    @test invoke !== nothing
 
-    newssa = insert_node!(ir, SSAValue(1), NewInstruction(Expr(:call, println, SSAValue(1)), Nothing), #=attach_after=#true)
+    invoke_ssa = SSAValue(invoke_idx)
+    newssa = insert_node!(ir, invoke_ssa, NewInstruction(Expr(:call, println, invoke_ssa), Nothing), #=attach_after=#true)
     newssa = insert_node!(ir, newssa, NewInstruction(Expr(:call, println, newssa), Nothing), #=attach_after=#true)
 
     ir = Core.Compiler.compact!(ir)
-    @test length(ir.stmts) == 4
-    @test Meta.isexpr(ir.stmts[1][:stmt], :invoke)
-    call1 = ir.stmts[2][:stmt]
+    @test length(ir.stmts) == nstmts + 2
+    @test Meta.isexpr(ir.stmts[invoke_idx][:stmt], :invoke)
+    call1 = ir.stmts[invoke_idx+1][:stmt]
     @test iscall((ir,println), call1)
-    @test call1.args[2] === SSAValue(1)
-    call2 = ir.stmts[3][:stmt]
+    @test call1.args[2] === invoke_ssa
+    call2 = ir.stmts[invoke_idx+2][:stmt]
     @test iscall((ir,println), call2)
-    @test call2.args[2] === SSAValue(2)
+    @test call2.args[2] === SSAValue(invoke_idx+1)
 end
 
 # Issue #50379 - insert_node!(::IncrementalCompact, ...) at end of basic block
@@ -608,26 +610,23 @@ end
 let ir = Base.code_ircode((Int,Int); optimize_until="inlining") do a, b
         a^b
     end |> only |> first
-    invoke_idx = findfirst(ir.stmts.stmt) do @nospecialize(x)
-        Meta.isexpr(x, :invoke)
-    end
+    invoke_idx = findfirst(@nospecialize(stmt)->Meta.isexpr(stmt, :invoke), ir.stmts.stmt)
     @test invoke_idx !== nothing
     invoke_expr = ir.stmts.stmt[invoke_idx]
+    invoke_ssa = SSAValue(invoke_idx)
 
     # effect-ful node
     let compact = Core.Compiler.IncrementalCompact(Core.Compiler.copy(ir))
-        insert_node!(compact, SSAValue(1), NewInstruction(Expr(:call, println, SSAValue(1)), Nothing), #=attach_after=#true)
+        insert_node!(compact, invoke_ssa, NewInstruction(Expr(:call, println, invoke_ssa), Nothing), #=attach_after=#true)
         state = Core.Compiler.iterate(compact)
         while state !== nothing
             state = Core.Compiler.iterate(compact, state[2])
         end
         ir = Core.Compiler.finish(compact)
-        new_invoke_idx = findfirst(ir.stmts.stmt) do @nospecialize(x)
-            x == invoke_expr
-        end
+        new_invoke_idx = findfirst(@nospecialize(stmt)->stmt==invoke_expr, ir.stmts.stmt)
         @test new_invoke_idx !== nothing
-        new_call_idx = findfirst(ir.stmts.stmt) do @nospecialize(x)
-            iscall((ir,println), x) && x.args[2] === SSAValue(invoke_idx)
+        new_call_idx = findfirst(ir.stmts.stmt) do @nospecialize(stmt)
+            iscall((ir,println), stmt) && stmt.args[2] === SSAValue(new_invoke_idx)
         end
         @test new_call_idx !== nothing
         @test new_call_idx == new_invoke_idx+1
@@ -635,7 +634,7 @@ let ir = Base.code_ircode((Int,Int); optimize_until="inlining") do a, b
 
     # effect-free node
     let compact = Core.Compiler.IncrementalCompact(Core.Compiler.copy(ir))
-        insert_node!(compact, SSAValue(1), NewInstruction(Expr(:call, GlobalRef(Base, :add_int), SSAValue(1), SSAValue(1)), Int), #=attach_after=#true)
+        insert_node!(compact, invoke_ssa, NewInstruction(Expr(:call, GlobalRef(Base, :add_int), invoke_ssa, invoke_ssa), Int), #=attach_after=#true)
         state = Core.Compiler.iterate(compact)
         while state !== nothing
             state = Core.Compiler.iterate(compact, state[2])
@@ -643,12 +642,10 @@ let ir = Base.code_ircode((Int,Int); optimize_until="inlining") do a, b
         ir = Core.Compiler.finish(compact)
 
         ir = Core.Compiler.finish(compact)
-        new_invoke_idx = findfirst(ir.stmts.stmt) do @nospecialize(x)
-            x == invoke_expr
-        end
+        new_invoke_idx = findfirst(@nospecialize(stmt)->stmt==invoke_expr, ir.stmts.stmt)
         @test new_invoke_idx !== nothing
         new_call_idx = findfirst(ir.stmts.stmt) do @nospecialize(x)
-            iscall((ir,Base.add_int), x) && x.args[2] === SSAValue(invoke_idx)
+            iscall((ir,Base.add_int), x) && x.args[2] === SSAValue(new_invoke_idx)
         end
         @test new_call_idx === nothing # should be deleted during the compaction
     end

From 95ae27f6255fdb5f10d32ab6e8134632171bb822 Mon Sep 17 00:00:00 2001
From: Mason Protter <mason.protter@icloud.com>
Date: Wed, 31 Jan 2024 18:10:30 +0100
Subject: [PATCH 0766/1315] Try to fix incorrect documentation of `nthreads`
 (#53117)

Since https://github.com/JuliaLang/julia/pull/49094, the docstring of
`nthreads` has been incorrect. It currently states that

> The threads in default have id numbers `1:nthreads(:default)`.

whereas that is no longer true:
```julia
julia> filter(i -> Threads.threadpool(i) == :interactive, 1:Threads.maxthreadid())
3-element Vector{Int64}:
 1
 2
 3

julia> filter(i -> Threads.threadpool(i) == :default, 1:Threads.maxthreadid())
6-element Vector{Int64}:
 4
 5
 6
 7
 8
 9
```
---
 base/threadingconstructs.jl | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index a5a1294be049b..e202bb0acb317 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -44,8 +44,9 @@ maxthreadid() = Int(Core.Intrinsics.atomic_pointerref(cglobal(:jl_n_threads, Cin
 """
     Threads.nthreads(:default | :interactive) -> Int
 
-Get the current number of threads within the specified thread pool. The threads in default
-have id numbers `1:nthreads(:default)`.
+Get the current number of threads within the specified thread pool. The threads in `:interactive`
+have id numbers `1:nthreads(:interactive)`, and the threads in `:default` have id numbers in
+`nthreads(:interactive) .+ (1:nthreads(:default))`.
 
 See also `BLAS.get_num_threads` and `BLAS.set_num_threads` in the [`LinearAlgebra`](@ref
 man-linalg) standard library, and `nprocs()` in the [`Distributed`](@ref man-distributed)

From 886d7a45cae251f7214d49e34581c102086b0101 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Wed, 31 Jan 2024 12:19:45 -0500
Subject: [PATCH 0767/1315] get_bool_env: add method with a lazy default
 option. Add kwarg to throw (#52950)

Based on need here
https://github.com/JuliaLang/Pkg.jl/pull/3764#discussion_r1456534459
---
 base/env.jl | 27 ++++++++++++++++++---------
 test/env.jl | 10 ++++++++++
 2 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/base/env.jl b/base/env.jl
index 1bebfd2623e61..3092efbe372e0 100644
--- a/base/env.jl
+++ b/base/env.jl
@@ -129,25 +129,34 @@ const get_bool_env_falsy = (
     "0")
 
 """
-    Base.get_bool_env(name::String, default::Bool)::Union{Bool,Nothing}
+    Base.get_bool_env(name::String, default::Bool; throw=false)::Union{Bool,Nothing}
+    Base.get_bool_env(f_default::Callable, name::String; throw=false)::Union{Bool,Nothing}
 
 Evaluate whether the value of environnment variable `name` is a truthy or falsy string,
-and return `nothing` if it is not recognized as either. If the variable is not set, or is set to "",
-return `default`.
+and return `nothing` (or throw if `throw=true`) if it is not recognized as either. If
+the variable is not set, or is set to "", return `default` or the result of executing `f_default()`.
 
 Recognized values are the following, and their Capitalized and UPPERCASE forms:
     truthy: "t", "true", "y", "yes", "1"
     falsy:  "f", "false", "n", "no", "0"
 """
-function get_bool_env(name::String, default::Bool)
-    haskey(ENV, name) || return default
-    val = ENV[name]
-    if isempty(val)
-        return default
-    elseif val in get_bool_env_truthy
+get_bool_env(name::String, default::Bool; kwargs...) = get_bool_env(Returns(default), name; kwargs...)
+function get_bool_env(f_default::Callable, name::String; kwargs...)
+    if haskey(ENV, name)
+        val = ENV[name]
+        if !isempty(val)
+            return parse_bool_env(name, val; kwargs...)
+        end
+    end
+    return f_default()
+end
+function parse_bool_env(name::String, val::String = ENV[name]; throw::Bool=false)
+    if val in get_bool_env_truthy
         return true
     elseif val in get_bool_env_falsy
         return false
+    elseif throw
+        Base.throw(ArgumentError("Value for environment variable `$name` could not be parsed as Boolean: $(repr(val))"))
     else
         return nothing
     end
diff --git a/test/env.jl b/test/env.jl
index 4a3529f6d4081..7f6962cf675aa 100644
--- a/test/env.jl
+++ b/test/env.jl
@@ -133,7 +133,9 @@ end
             for _v in (v, uppercasefirst(v), uppercase(v))
                 ENV["testing_gbe"] = _v
                 @test Base.get_bool_env("testing_gbe", false) == true
+                @test Base.get_bool_env(() -> false, "testing_gbe") == true
                 @test Base.get_bool_env("testing_gbe", true) == true
+                @test Base.get_bool_env(() -> true, "testing_gbe") == true
             end
         end
     end
@@ -142,26 +144,34 @@ end
             for _v in (v, uppercasefirst(v), uppercase(v))
                 ENV["testing_gbe"] = _v
                 @test Base.get_bool_env("testing_gbe", true) == false
+                @test Base.get_bool_env(() -> true, "testing_gbe") == false
                 @test Base.get_bool_env("testing_gbe", false) == false
+                @test Base.get_bool_env(() -> false, "testing_gbe") == false
             end
         end
     end
     @testset "empty" begin
         ENV["testing_gbe"] = ""
         @test Base.get_bool_env("testing_gbe", true) == true
+        @test Base.get_bool_env(() -> true, "testing_gbe") == true
         @test Base.get_bool_env("testing_gbe", false) == false
+        @test Base.get_bool_env(() -> false, "testing_gbe") == false
     end
     @testset "undefined" begin
         delete!(ENV, "testing_gbe")
         @test !haskey(ENV, "testing_gbe")
         @test Base.get_bool_env("testing_gbe", true) == true
+        @test Base.get_bool_env(() -> true, "testing_gbe") == true
         @test Base.get_bool_env("testing_gbe", false) == false
+        @test Base.get_bool_env(() -> false, "testing_gbe") == false
     end
     @testset "unrecognized" begin
         for v in ("truw", "falls")
             ENV["testing_gbe"] = v
             @test Base.get_bool_env("testing_gbe", true) === nothing
+            @test_throws ArgumentError Base.get_bool_env("testing_gbe", true, throw=true)
             @test Base.get_bool_env("testing_gbe", false) === nothing
+            @test_throws ArgumentError Base.get_bool_env("testing_gbe", false, throw=true)
         end
     end
 

From c2b441b8c67a619020c33b18097c95fa4b9c4413 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 28 Dec 2023 18:00:36 +0800
Subject: [PATCH 0768/1315] Make AnnotatedIOBuffer reading more generic

While `String` is the only concrete type for which `read(::IOBuffer,
::Type{<:AbstractString})` is defined, is is entirely conceivable that
some other custom string type could define a similar `read` method.

Since making reading an `AnnotatedString` from an `AnnotatedIOBuffer`
more generic is as easy as replacing the hardcoded `String` with a type
parameter, we may as well do so.
---
 base/strings/annotated.jl | 86 +++++++++++++++++++++++----------------
 1 file changed, 52 insertions(+), 34 deletions(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 4a23fd037e62e..c1de401300327 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -389,7 +389,7 @@ annotations(c::AnnotatedChar) = c.annotations
 
 ## AnnotatedIOBuffer
 
-struct AnnotatedIOBuffer <: IO
+struct AnnotatedIOBuffer <: AbstractPipe
     io::IOBuffer
     annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
 end
@@ -403,61 +403,79 @@ function show(io::IO, aio::AnnotatedIOBuffer)
           length(aio.annotations), " annotation", ifelse(length(aio.annotations) == 1, "", "s"), ")")
 end
 
-isopen(io::AnnotatedIOBuffer) = isopen(io.io)
-close(io::AnnotatedIOBuffer) = close(io.io)
-closewrite(io::AnnotatedIOBuffer) = closewrite(io.io)
-eof(io::AnnotatedIOBuffer) = eof(io.io)
-peek(io::AnnotatedIOBuffer) = peek(io.io)
+pipe_reader(io::AnnotatedIOBuffer) = io.io
+pipe_writer(io::AnnotatedIOBuffer) = io.io
+
+# Useful `IOBuffer` methods that we don't get from `AbstractPipe`
 position(io::AnnotatedIOBuffer) = position(io.io)
 seek(io::AnnotatedIOBuffer, n::Integer) = (seek(io.io, n); io)
+seekend(io::AnnotatedIOBuffer) = seekend(io.io)
 skip(io::AnnotatedIOBuffer, n::Integer) = (skip(io.io, n); io)
-mark(io::AnnotatedIOBuffer) = mark(io.io)
-reset(io::AnnotatedIOBuffer) = reset(io.io)
-unmark(io::AnnotatedIOBuffer) = unmark(io.io)
-ismarked(io::AnnotatedIOBuffer) = ismarked(io.io)
 copy(io::AnnotatedIOBuffer) = AnnotatedIOBuffer(copy(io.io), copy(io.annotations))
-unsafe_write(io::AnnotatedIOBuffer, b::Ptr{UInt8}, len::UInt) = unsafe_write(io.io, b, len)
-unsafe_read(io::AnnotatedIOBuffer, b::Ptr{UInt8}, len::UInt) = unsafe_read(io.io, b, len)
+
+annotations(io::AnnotatedIOBuffer) = io.annotations
 
 function write(io::AnnotatedIOBuffer, astr::Union{AnnotatedString, SubString{<:AnnotatedString}})
     astr = AnnotatedString(astr)
     offset = position(io.io)
-    for (region, annot) in astr.annotations
-        start, stop = first(region), last(region)
-        push!(io.annotations, (start+offset:stop+offset, annot))
+    if !eof(io)
+        # If we are overwriting an existing span in the AnnotatedIOBuffer,
+        # clear out any overlapping pre-existing annotations.
+        span = offset+1:offset+ncodeunits(astr)
+        filter!(((range, _),) -> first(range) < first(span) || last(range) > last(span), io.annotations)
+        extras = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
+        for i in eachindex(io.annotations)
+            range, annot = io.annotations[i]
+            # Test for partial overlap
+            if first(range) <= first(span) <= last(range) || first(range) <= last(span) <= last(range)
+                io.annotations[i] = (if first(range) < first(span)
+                                         first(range):first(span)-1
+                                     else last(span)+1:last(range) end, annot)
+                # If `span` fits exactly within `range`, then we've only copied over
+                # the beginning overhang, but also need to conserve the end overhang.
+                if first(range) < first(span) && last(span) < last(range)
+                    push!(extras, (last(span)+1:last(range), annot))
+                end
+            end
+            # Insert any extra entries in the appropriate position
+            for entry in extras
+                indices = searchsorted(io.annotations, (first(entry),), by=first)
+                splice!(io.annotations, indices, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[entry])
+            end
+        end
+        # Fill in the annotations from `astr`, accounting for `offset`
+        for (region, annot) in astr.annotations
+            region = first(region)+offset:last(region)+offset
+            indices = searchsorted(io.annotations, (region,), by=first)
+            splice!(io.annotations, indices, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[(region, annot)])
+        end
+    else
+        # Fill in the annotations from `astr`, accounting for `offset`
+        for (region, annot) in astr.annotations
+            region = first(region)+offset:last(region)+offset
+            push!(io.annotations, (region, annot))
+        end
     end
     write(io.io, String(astr))
 end
+
 write(io::AnnotatedIOBuffer, c::AnnotatedChar) = write(io, AnnotatedString(c))
 write(io::AnnotatedIOBuffer, x::AbstractString) = write(io.io, x)
 write(io::AnnotatedIOBuffer, s::Union{SubString{String}, String}) = write(io.io, s)
 write(io::AnnotatedIOBuffer, b::UInt8) = write(io.io, b)
 
-"""
-    read(io::AnnotatedIOBuffer, AnnotatedString)
 
-Read `io` as an `AnnotatedString`, jumping to the start if `eof(io)` holds.
-This preserves the annotations of any `AnnotatedString`s written to `io` and
-otherwise acts like `read(io::IO, String)`.
-"""
-function read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{String}})
-    if eof(io)
-        seekstart(io.io)
-        AnnotatedString(read(io.io, String), copy(io.annotations))
+function read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{T}}) where {T <: AbstractString}
+    if (start = position(io)) == 0
+        AnnotatedString(read(io.io, T), copy(io.annotations))
     else
-        start = position(io.io)
-        annots = map(((range, val),) -> (max(1, first(range) - start):last(range)-start, val),
-                     filter(((range, _),) -> last(range) > start,
-                            io.annotations))
-        AnnotatedString(read(io.io, String), annots)
+        annots = [(max(1, first(region) - start):last(region)-start, val)
+                  for (region, val) in io.annotations if last(region) > start]
+        AnnotatedString(read(io.io, T), annots)
     end
 end
 read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{AbstractString}}) = read(io, AnnotatedString{String})
 read(io::AnnotatedIOBuffer, ::Type{AnnotatedString}) = read(io, AnnotatedString{String})
-read(io::AnnotatedIOBuffer, x) = read(io.io, x)
-# Avoid method ambiguity
-read(io::AnnotatedIOBuffer, s::Type{String}) = read(io.io, s)
-read(io::AnnotatedIOBuffer, b::Type{UInt8}) = read(io.io, b)
 
 function truncate(io::AnnotatedIOBuffer, size::Integer)
     truncate(io.io, size)

From f4c5e13a6ec85bbab83d29601342c33a44f787b2 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 28 Dec 2023 18:00:48 +0800
Subject: [PATCH 0769/1315] Also read AnnotatedChars from an AnnotatedIOBuffer

The `read(::AnnotatedIOBuffer, AnnotatedString)` method is intended as
an approximate analogue to `read(::IOBuffer, String)`. In the same
sense, it makes sense to define `read(::AnnotatedIOBuffer,
AnnotatedChar)` as an analogue to `read(::IOBuffer, Char)`.
---
 base/strings/annotated.jl | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index c1de401300327..ee75bb923b742 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -477,6 +477,15 @@ end
 read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{AbstractString}}) = read(io, AnnotatedString{String})
 read(io::AnnotatedIOBuffer, ::Type{AnnotatedString}) = read(io, AnnotatedString{String})
 
+function read(io::AnnotatedIOBuffer, ::Type{AnnotatedChar{T}}) where {T <: AbstractChar}
+    pos = position(io)
+    char = read(io.io, T)
+    annots = [annot for (range, annot) in io.annotations if pos+1 in range]
+    AnnotatedChar(char, annots)
+end
+read(io::AnnotatedIOBuffer, ::Type{AnnotatedChar{AbstractChar}}) = read(io, AnnotatedChar{Char})
+read(io::AnnotatedIOBuffer, ::Type{AnnotatedChar}) = read(io, AnnotatedChar{Char})
+
 function truncate(io::AnnotatedIOBuffer, size::Integer)
     truncate(io.io, size)
     filter!(((range, _),) -> first(range) <= size, io.annotations)

From d49ba4f912848b0a0dcf71e6f3602f2533ffff27 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Tue, 23 Jan 2024 18:04:00 +0800
Subject: [PATCH 0770/1315] Writing from one AnnotatedIOBuffer to another

---
 base/strings/annotated.jl | 84 +++++++++++++++++++++++----------------
 1 file changed, 50 insertions(+), 34 deletions(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index ee75bb923b742..10d5c43addf52 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -418,53 +418,69 @@ annotations(io::AnnotatedIOBuffer) = io.annotations
 function write(io::AnnotatedIOBuffer, astr::Union{AnnotatedString, SubString{<:AnnotatedString}})
     astr = AnnotatedString(astr)
     offset = position(io.io)
-    if !eof(io)
-        # If we are overwriting an existing span in the AnnotatedIOBuffer,
-        # clear out any overlapping pre-existing annotations.
-        span = offset+1:offset+ncodeunits(astr)
-        filter!(((range, _),) -> first(range) < first(span) || last(range) > last(span), io.annotations)
-        extras = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
-        for i in eachindex(io.annotations)
-            range, annot = io.annotations[i]
-            # Test for partial overlap
-            if first(range) <= first(span) <= last(range) || first(range) <= last(span) <= last(range)
-                io.annotations[i] = (if first(range) < first(span)
-                                         first(range):first(span)-1
-                                     else last(span)+1:last(range) end, annot)
-                # If `span` fits exactly within `range`, then we've only copied over
-                # the beginning overhang, but also need to conserve the end overhang.
-                if first(range) < first(span) && last(span) < last(range)
-                    push!(extras, (last(span)+1:last(range), annot))
-                end
-            end
-            # Insert any extra entries in the appropriate position
-            for entry in extras
-                indices = searchsorted(io.annotations, (first(entry),), by=first)
-                splice!(io.annotations, indices, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[entry])
+    eof(io) || _clear_annotations_in_region!(io.annotations, offset+1:offset+ncodeunits(astr))
+    _insert_annotations!(io, astr.annotations)
+    write(io.io, String(astr))
+end
+
+write(io::AnnotatedIOBuffer, c::AnnotatedChar) = write(io, AnnotatedString(c))
+write(io::AnnotatedIOBuffer, x::AbstractString) = write(io.io, x)
+write(io::AnnotatedIOBuffer, s::Union{SubString{String}, String}) = write(io.io, s)
+write(io::AnnotatedIOBuffer, b::UInt8) = write(io.io, b)
+
+function write(dest::AnnotatedIOBuffer, src::AnnotatedIOBuffer)
+    destpos = position(dest)
+    isappending = eof(dest)
+    srcpos = position(src)
+    nb = write(dest.io, src.io)
+    isappending || _clear_annotations_in_region!(dest.annotations, destpos:destpos+nb)
+    srcannots = [(max(1 + srcpos, first(region)):last(region), annot)
+                 for (region, annot) in src.annotations if first(region) >= srcpos]
+    _insert_annotations!(dest, srcannots, destpos - srcpos)
+    nb
+end
+
+function _clear_annotations_in_region!(annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}, span::UnitRange{Int})
+    # Clear out any overlapping pre-existing annotations.
+    filter!(((region, _),) -> first(region) < first(span) || last(region) > last(span), annotations)
+    extras = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
+    for i in eachindex(annotations)
+        region, annot = annotations[i]
+        # Test for partial overlap
+        if first(region) <= first(span) <= last(region) || first(region) <= last(span) <= last(region)
+            annotations[i] = (if first(region) < first(span)
+                                        first(region):first(span)-1
+                                    else last(span)+1:last(region) end, annot)
+            # If `span` fits exactly within `region`, then we've only copied over
+            # the beginning overhang, but also need to conserve the end overhang.
+            if first(region) < first(span) && last(span) < last(region)
+                push!(extras, (last(span)+1:last(region), annot))
             end
         end
-        # Fill in the annotations from `astr`, accounting for `offset`
-        for (region, annot) in astr.annotations
+        # Insert any extra entries in the appropriate position
+        for entry in extras
+            indices = searchsorted(annotations, (first(entry),), by=first)
+            splice!(annotations, indices, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[entry])
+        end
+    end
+    annotations
+end
+
+function _insert_annotations!(io::AnnotatedIOBuffer, annotations::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}, offset::Int = position(io))
+    if !eof(io)
+        for (region, annot) in annotations
             region = first(region)+offset:last(region)+offset
             indices = searchsorted(io.annotations, (region,), by=first)
             splice!(io.annotations, indices, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[(region, annot)])
         end
     else
-        # Fill in the annotations from `astr`, accounting for `offset`
-        for (region, annot) in astr.annotations
+        for (region, annot) in annotations
             region = first(region)+offset:last(region)+offset
             push!(io.annotations, (region, annot))
         end
     end
-    write(io.io, String(astr))
 end
 
-write(io::AnnotatedIOBuffer, c::AnnotatedChar) = write(io, AnnotatedString(c))
-write(io::AnnotatedIOBuffer, x::AbstractString) = write(io.io, x)
-write(io::AnnotatedIOBuffer, s::Union{SubString{String}, String}) = write(io.io, s)
-write(io::AnnotatedIOBuffer, b::UInt8) = write(io.io, b)
-
-
 function read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{T}}) where {T <: AbstractString}
     if (start = position(io)) == 0
         AnnotatedString(read(io.io, T), copy(io.annotations))

From 2e6ebb94d083ae21c310dc842762b824a8a88b80 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Sat, 16 Dec 2023 02:13:57 +0800
Subject: [PATCH 0771/1315] Tests for AnnotatedIOBuffer

---
 test/strings/annotated.jl | 54 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index 70f490f4787ca..2a9fd4a702465 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -107,3 +107,57 @@ end
     @test reverse(str1) == Base.AnnotatedString("tset", [(1:4, :label => 5)])
     @test reverse(str2) == Base.AnnotatedString("esac", [(2:3, :label => "oomph")])
 end
+
+@testset "AnnotatedIOBuffer" begin
+    aio = Base.AnnotatedIOBuffer()
+    # Append-only writing
+    @test write(aio, Base.AnnotatedString("hello", [(1:5, :tag => 1)])) == 5
+    @test write(aio, ' ') == 1
+    @test write(aio, Base.AnnotatedString("world", [(1:5, :tag => 2)])) == 5
+    @test Base.annotations(aio) == [(1:5, :tag => 1), (7:11, :tag => 2)]
+    # Reading
+    @test read(seekstart(deepcopy(aio.io)), String) == "hello world"
+    @test read(seekstart(deepcopy(aio)), String) == "hello world"
+    @test read(seek(aio, 0), Base.AnnotatedString) == Base.AnnotatedString("hello world", [(1:5, :tag => 1), (7:11, :tag => 2)])
+    @test read(seek(aio, 1), Base.AnnotatedString) == Base.AnnotatedString("ello world", [(1:4, :tag => 1), (6:10, :tag => 2)])
+    @test read(seek(aio, 4), Base.AnnotatedString) == Base.AnnotatedString("o world", [(1:1, :tag => 1), (3:7, :tag => 2)])
+    @test read(seek(aio, 5), Base.AnnotatedString) == Base.AnnotatedString(" world", [(2:6, :tag => 2)])
+    @test read(seekstart(truncate(deepcopy(aio), 5)), Base.AnnotatedString) == Base.AnnotatedString("hello", [(1:5, :tag => 1)])
+    @test read(seekstart(truncate(deepcopy(aio), 6)), Base.AnnotatedString) == Base.AnnotatedString("hello ", [(1:5, :tag => 1)])
+    @test read(seekstart(truncate(deepcopy(aio), 7)), Base.AnnotatedString) == Base.AnnotatedString("hello w", [(1:5, :tag => 1), (7:7, :tag => 2)])
+    @test read(seek(aio, 0), Base.AnnotatedChar) == Base.AnnotatedChar('h', [:tag => 1])
+    @test read(seek(aio, 5), Base.AnnotatedChar) == Base.AnnotatedChar(' ', Pair{Symbol, Any}[])
+    @test read(seek(aio, 6), Base.AnnotatedChar) == Base.AnnotatedChar('w', [:tag => 2])
+    # Check method compatibility with IOBuffer
+    @test position(aio) == 7
+    @test seek(aio, 4) === aio
+    @test skip(aio, 2) === aio
+    @test Base.annotations(copy(aio)) == Base.annotations(aio)
+    @test take!(copy(aio).io) == take!(copy(aio.io))
+    # Writing into the middle of the buffer
+    @test write(seek(aio, 6), "alice") == 5 # Replace 'world' with 'alice'
+    @test read(seekstart(aio), String) == "hello alice"
+    @test Base.annotations(aio) == [(1:5, :tag => 1), (7:11, :tag => 2)] # Should be unchanged
+    @test write(seek(aio, 0), Base.AnnotatedString("hey-o", [(1:5, :hey => 'o')])) == 5
+    @test read(seekstart(aio), String) == "hey-o alice"
+    @test Base.annotations(aio) == [(1:5, :hey => 'o'), (7:11, :tag => 2)] # First annotation should have been entirely replaced
+    @test write(seek(aio, 7), Base.AnnotatedString("bbi", [(1:3, :hey => 'a')])) == 3 # a[lic => bbi]e ('alice' => 'abbie')
+    @test read(seekstart(aio), String) == "hey-o abbie"
+    @test Base.annotations(aio) == [(1:5, :hey => 'o'), (7:7, :tag => 2), (8:10, :hey => 'a'), (11:11, :tag => 2)]
+    @test write(seek(aio, 0), Base.AnnotatedString("ab")) == 2 # Check first annotation's region is adjusted correctly
+    @test read(seekstart(aio), String) == "aby-o abbie"
+    @test Base.annotations(aio) == [(3:5, :hey => 'o'), (7:7, :tag => 2), (8:10, :hey => 'a'), (11:11, :tag => 2)]
+    @test write(seek(aio, 3), Base.AnnotatedString("ss")) == 2
+    @test read(seekstart(aio), String) == "abyss abbie"
+    @test Base.annotations(aio) == [(3:3, :hey => 'o'), (7:7, :tag => 2), (8:10, :hey => 'a'), (11:11, :tag => 2)]
+    # Writing one buffer to another
+    newaio = Base.AnnotatedIOBuffer()
+    @test write(newaio, seekstart(aio)) == 11
+    @test read(seekstart(newaio), String) == "abyss abbie"
+    @test Base.annotations(newaio) == Base.annotations(aio)
+    @test write(seek(newaio, 5), seek(aio, 5)) == 6
+    @test Base.annotations(newaio) == Base.annotations(aio)
+    @test write(newaio, seek(aio, 5)) == 6
+    @test read(seekstart(newaio), String) == "abyss abbie abbie"
+    @test Base.annotations(newaio) == vcat(Base.annotations(aio), [(13:13, :tag => 2), (14:16, :hey => 'a'), (17:17, :tag => 2)])
+end

From 39839acf5363dc90f5253688c964a8f9a07e8efd Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 28 Dec 2023 18:35:15 +0800
Subject: [PATCH 0772/1315] Update the mention of annotated features in NEWS

---
 NEWS.md | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 6eb7e6509c69f..5dd6481a4f0b2 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -11,11 +11,20 @@ New language features
 * The new macro `Base.Cartesian.@ncallkw` is analogous to `Base.Cartesian.@ncall`,
   but allows to add keyword arguments to the function call ([#51501]).
 * Support for Unicode 15.1 ([#51799]).
-* A new `AbstractString` type, `AnnotatedString`, is introduced that allows for
-  regional annotations to be attached to an underlying string. This type is
-  particularly useful for holding styling information, and is used extensively
-  in the new `StyledStrings` standard library. There is also a new `AnnotatedChar`
-  type, that is the equivalent new `AbstractChar` type.
+* Three new types around the idea of text with "annotations" (`Pair{Symbol, Any}`
+  entries, e.g. `:lang => "en"` or `:face => :magenta`). These annotations
+  are preserved across operations (e.g. string concatenation with `*`) when
+  possible.
+  * `AnnotatedString` is a new `AbstractString` type. It wraps an underlying
+    string and allows for annotations to be attached to regions of the string.
+    This type is used extensively in the new `StyledStrings` standard library to
+    hold styling information.
+  * `AnnotatedChar` is a new `AbstractChar` type. It wraps another char and
+    holds a list of annotations that apply to it.
+  * `AnnotatedIOBuffer` is a new `IO` type that mimics an `IOBuffer`, but has
+    specialised `read`/`write` methods for annotated content. This can be
+    thought of both as a "string builder" of sorts and also as glue between
+    annotated and unannotated content.
 * `Manifest.toml` files can now be renamed in the format `Manifest-v{major}.{minor}.toml`
   to be preferentially picked up by the given julia version. i.e. in the same folder,
   a `Manifest-v1.11.toml` would be used by v1.11 and `Manifest.toml` by every other julia

From 2b9839b14aed9c56477cdda61edcc959c2d76caa Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Wed, 31 Jan 2024 16:22:45 +0800
Subject: [PATCH 0773/1315] Use insert! not splice! for new annotations

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/strings/annotated.jl | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 10d5c43addf52..20ad53b78a757 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -323,14 +323,15 @@ To remove existing `label` annotations, use a value of `nothing`.
 """
 function annotate!(s::AnnotatedString, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any}))
     label, val = labelval
-    indices = searchsorted(s.annotations, (range,), by=first)
     if val === nothing
+        indices = searchsorted(s.annotations, (range,), by=first)
         labelindex = filter(i -> first(s.annotations[i][2]) === label, indices)
         for index in Iterators.reverse(labelindex)
             deleteat!(s.annotations, index)
         end
     else
-        splice!(s.annotations, indices, [(range, Pair{Symbol, Any}(label, val))])
+        sortedindex = searchsortedlast(s.annotations, (range,), by=first) + 1
+        insert!(s.annotations, sortedindex, (range, Pair{Symbol, Any}(label, val)))
     end
     s
 end
@@ -459,8 +460,8 @@ function _clear_annotations_in_region!(annotations::Vector{Tuple{UnitRange{Int},
         end
         # Insert any extra entries in the appropriate position
         for entry in extras
-            indices = searchsorted(annotations, (first(entry),), by=first)
-            splice!(annotations, indices, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[entry])
+            sortedindex = searchsortedlast(annotations, (first(entry),), by=first) + 1
+            insert!(annotations, sortedindex, entry)
         end
     end
     annotations
@@ -470,8 +471,8 @@ function _insert_annotations!(io::AnnotatedIOBuffer, annotations::Vector{Tuple{U
     if !eof(io)
         for (region, annot) in annotations
             region = first(region)+offset:last(region)+offset
-            indices = searchsorted(io.annotations, (region,), by=first)
-            splice!(io.annotations, indices, Tuple{UnitRange{Int}, Pair{Symbol, Any}}[(region, annot)])
+            sortedindex = searchsortedlast(io.annotations, (region,), by=first) + 1
+            insert!(io.annotations, sortedindex, (region, annot))
         end
     else
         for (region, annot) in annotations

From 444e14eefb18e66bb9035ca41559fde61c6ce2f6 Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Wed, 31 Jan 2024 21:37:53 +0100
Subject: [PATCH 0774/1315] Make FDWatcher check for file descriptors equal to
 -1 (#52902)

---
 base/libc.jl                            |  2 +-
 stdlib/FileWatching/src/FileWatching.jl | 16 +++++++++++++---
 stdlib/FileWatching/test/runtests.jl    |  3 +++
 3 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/base/libc.jl b/base/libc.jl
index 359ca6a7f8c31..c4a93eae6f3a3 100644
--- a/base/libc.jl
+++ b/base/libc.jl
@@ -41,7 +41,7 @@ dup(src::RawFD, target::RawFD) = systemerror("dup", -1 ==
     ccall((@static Sys.iswindows() ? :_dup2 : :dup2), Int32,
                 (RawFD, RawFD), src, target))
 
-show(io::IO, fd::RawFD) = print(io, "RawFD(", bitcast(UInt32, fd), ')')  # avoids invalidation via show_default
+show(io::IO, fd::RawFD) = print(io, "RawFD(", bitcast(Int32, fd), ')')  # avoids invalidation via show_default
 
 # Wrapper for an OS file descriptor (for Windows)
 if Sys.iswindows()
diff --git a/stdlib/FileWatching/src/FileWatching.jl b/stdlib/FileWatching/src/FileWatching.jl
index 0e68cd97681ff..0ee572ec47d92 100644
--- a/stdlib/FileWatching/src/FileWatching.jl
+++ b/stdlib/FileWatching/src/FileWatching.jl
@@ -164,10 +164,13 @@ mutable struct _FDWatcher
         @static if Sys.isunix()
             _FDWatcher(fd::RawFD, mask::FDEvent) = _FDWatcher(fd, mask.readable, mask.writable)
             function _FDWatcher(fd::RawFD, readable::Bool, writable::Bool)
-                if !readable && !writable
+                fdnum = Core.Intrinsics.bitcast(Int32, fd) + 1
+                if fdnum <= 0
+                    throw(ArgumentError("Passed file descriptor fd=$(fd) is not a valid file descriptor"))
+                elseif !readable && !writable
                     throw(ArgumentError("must specify at least one of readable or writable to create a FDWatcher"))
                 end
-                fdnum = Core.Intrinsics.bitcast(Int32, fd) + 1
+
                 iolock_begin()
                 if fdnum > length(FDWatchers)
                     old_len = length(FDWatchers)
@@ -232,12 +235,19 @@ mutable struct _FDWatcher
     @static if Sys.iswindows()
         _FDWatcher(fd::RawFD, mask::FDEvent) = _FDWatcher(fd, mask.readable, mask.writable)
         function _FDWatcher(fd::RawFD, readable::Bool, writable::Bool)
+            fdnum = Core.Intrinsics.bitcast(Int32, fd) + 1
+            if fdnum <= 0
+                throw(ArgumentError("Passed file descriptor fd=$(fd) is not a valid file descriptor"))
+            end
+
             handle = Libc._get_osfhandle(fd)
             return _FDWatcher(handle, readable, writable)
         end
         _FDWatcher(fd::WindowsRawSocket, mask::FDEvent) = _FDWatcher(fd, mask.readable, mask.writable)
         function _FDWatcher(fd::WindowsRawSocket, readable::Bool, writable::Bool)
-            if !readable && !writable
+            if fd == Base.INVALID_OS_HANDLE
+                throw(ArgumentError("Passed file descriptor fd=$(fd) is not a valid file descriptor"))
+            elseif !readable && !writable
                 throw(ArgumentError("must specify at least one of readable or writable to create a FDWatcher"))
             end
 
diff --git a/stdlib/FileWatching/test/runtests.jl b/stdlib/FileWatching/test/runtests.jl
index 1538be77d1695..9ba6456d20a98 100644
--- a/stdlib/FileWatching/test/runtests.jl
+++ b/stdlib/FileWatching/test/runtests.jl
@@ -443,6 +443,9 @@ unwatch_folder(dir)
 rm(file)
 rm(dir)
 
+# Test that creating a FDWatcher with a (probably) negative FD fails
+@test_throws ArgumentError FDWatcher(RawFD(-1), true, true)
+
 @testset "Pidfile" begin
     include("pidfile.jl")
 end

From 08e3c2ebcabf2de5007f2d715f5e55e60d98eae9 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 1 Feb 2024 02:08:30 +0530
Subject: [PATCH 0775/1315] Access only stored inds in `copy` for strided
 `AbstractTriangular` (#52907)

---
 stdlib/LinearAlgebra/src/triangular.jl  | 3 +++
 stdlib/LinearAlgebra/test/triangular.jl | 2 ++
 2 files changed, 5 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 18c2edf15eb54..6ed9e43d6f507 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -181,6 +181,9 @@ end
 Array(A::AbstractTriangular) = Matrix(A)
 parent(A::UpperOrLowerTriangular) = A.data
 
+# For strided matrices, we may only loop over the filled triangle
+copy(A::UpperOrLowerTriangular{<:Any, <:StridedMaybeAdjOrTransMat}) = copyto!(similar(A), A)
+
 # then handle all methods that requires specific handling of upper/lower and unit diagonal
 
 function Matrix{T}(A::LowerTriangular) where T
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index 69011e69167a3..97bf756044c66 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -1007,6 +1007,7 @@ end
             L = MT(A)
             B .= 0
             copyto!(B, L)
+            @test copy(L) == B
             @test L * 2 == 2 * L == 2B
             @test L/2 == B/2
             @test 2\L == 2\B
@@ -1032,6 +1033,7 @@ end
             U = MT(A)
             B .= 0
             copyto!(B, U)
+            @test copy(U) == B
             @test U * 2 == 2 * U == 2B
             @test U/2 == B/2
             @test 2\U == 2\B

From 353d7b70290af956a8429a07dd4f963547e82e07 Mon Sep 17 00:00:00 2001
From: Alexander Plavin <alexander@plav.in>
Date: Wed, 31 Jan 2024 21:46:09 -0500
Subject: [PATCH 0776/1315] Define valtype(::Tuple) and keytype(::Tuple)
 (#49179)

Same as https://github.com/JuliaLang/julia/pull/46555, but for Tuples

Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
---
 base/tuple.jl | 7 +++++++
 test/tuple.jl | 7 ++++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/base/tuple.jl b/base/tuple.jl
index 6d0ab4b4f9b24..3e39e8d63cb86 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -308,6 +308,13 @@ end
 #  @ tuple.jl:209
 typeof(function eltype end).name.max_methods = UInt8(4)
 
+# key/val types
+keytype(@nospecialize t::Tuple) = keytype(typeof(t))
+keytype(@nospecialize T::Type{<:Tuple}) = Int
+
+valtype(@nospecialize t::Tuple) = valtype(typeof(t))
+valtype(@nospecialize T::Type{<:Tuple}) = eltype(T)
+
 # version of tail that doesn't throw on empty tuples (used in array indexing)
 safe_tail(t::Tuple) = tail(t)
 safe_tail(t::Tuple{}) = ()
diff --git a/test/tuple.jl b/test/tuple.jl
index 3a8fb51051737..ee9f3e9ac7a2c 100644
--- a/test/tuple.jl
+++ b/test/tuple.jl
@@ -212,7 +212,7 @@ end
 end
 
 
-@testset "element type" begin
+@testset "elelement/value/key types" begin
     @test eltype((1,2,3)) === Int
     @test eltype((1.0,2.0,3.0)) <: AbstractFloat
     @test eltype((true, false)) === Bool
@@ -227,6 +227,11 @@ end
         typejoin(Int, Float64, Bool)
     @test eltype(Tuple{Int, Missing}) === Union{Missing, Int}
     @test eltype(Tuple{Int, Nothing}) === Union{Nothing, Int}
+
+    @test valtype((1,2,3)) === eltype((1,2,3))
+    @test valtype(Tuple{Int, Missing}) === eltype(Tuple{Int, Missing})
+    @test keytype((1,2,3)) === Int
+    @test keytype(Tuple{Int, Missing}) === Int
 end
 
 @testset "map with Nothing and Missing" begin

From 6db867b06e6b79ba73a7bfb04b6c06bd2048e0a6 Mon Sep 17 00:00:00 2001
From: Fengyang Wang <fengyang.wang.0@gmail.com>
Date: Thu, 1 Feb 2024 13:16:57 +0800
Subject: [PATCH 0777/1315] Better libuv error message for ENOENT ~ (#22647)

---
 base/libuv.jl     | 8 +++++++-
 test/errorshow.jl | 4 ++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/base/libuv.jl b/base/libuv.jl
index 4c56af29e7e60..66dfcfb3414ad 100644
--- a/base/libuv.jl
+++ b/base/libuv.jl
@@ -82,7 +82,13 @@ struct IOError <: Exception
     IOError(msg::AbstractString, code::Integer) = new(msg, code)
 end
 
-showerror(io::IO, e::IOError) = print(io, "IOError: ", e.msg)
+function showerror(io::IO, e::IOError)
+    print(io, "IOError: ", e.msg)
+    if e.code == UV_ENOENT && '~' in e.msg
+        print(io, "\nMany shells expand '~' to the home directory in unquoted strings. To replicate this behavior, call",
+                  " `expanduser` to expand the '~' character to the user’s home directory.")
+    end
+end
 
 function _UVError(pfx::AbstractString, code::Integer)
     code = Int32(code)
diff --git a/test/errorshow.jl b/test/errorshow.jl
index f6a5ccf2a93f9..89bab3be96a6b 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -1114,3 +1114,7 @@ end
         end
     end
 end
+
+# error message hint from PR #22647
+@test_throws "Many shells" cd("~")
+@test occursin("Many shells", sprint(showerror, Base.IOError("~", Base.UV_ENOENT)))

From f064e1bac1d514fa5c933b1a25ac0df857aaf947 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 1 Feb 2024 11:42:14 +0530
Subject: [PATCH 0778/1315] forward `repeat(A, cts..)` to `repeat(A; kw..)`
 (#49830)

This would mean that custom array types that seek to extend `repeat`
only need to add the method `repeat(A::CustomArray; kw...)`
---
 base/abstractarraymath.jl      |  2 +-
 test/abstractarray.jl          | 14 ++++++++++++++
 test/testhelpers/FillArrays.jl | 27 +++++++++++++++++++++++++++
 3 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/base/abstractarraymath.jl b/base/abstractarraymath.jl
index 70c304d9060c1..6ed3fff14928f 100644
--- a/base/abstractarraymath.jl
+++ b/base/abstractarraymath.jl
@@ -353,7 +353,7 @@ julia> repeat([1, 2, 3], 2, 3)
 ```
 """
 function repeat(A::AbstractArray, counts...)
-    return _RepeatInnerOuter.repeat(A, outer=counts)
+    return repeat(A, outer=counts)
 end
 
 """
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index d32bd5794b5fc..099ffc653e8d6 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -8,6 +8,9 @@ using .Main.InfiniteArrays
 isdefined(Main, :StructArrays) || @eval Main include("testhelpers/StructArrays.jl")
 using .Main.StructArrays
 
+isdefined(Main, :FillArrays) || @eval Main include("testhelpers/FillArrays.jl")
+using .Main.FillArrays
+
 A = rand(5,4,3)
 @testset "Bounds checking" begin
     @test checkbounds(Bool, A, 1, 1, 1) == true
@@ -1936,3 +1939,14 @@ f45952(x) = [x;;]
     @test_throws "invalid index: true of type Bool" isassigned(A, 1, true)
     @test_throws "invalid index: true of type Bool" isassigned(A, true)
 end
+
+@testset "repeat for FillArrays" begin
+    f = FillArrays.Fill(3, (4,))
+    @test repeat(f, 2) === FillArrays.Fill(3, (8,))
+    @test repeat(f, 2, 3) === FillArrays.Fill(3, (8, 3))
+    @test repeat(f, inner=(1,2), outer=(3,1)) === repeat(f, 3, 2) === FillArrays.Fill(3, (12,2))
+    f = FillArrays.Fill(3, (4, 2))
+    @test repeat(f, 2, 3) === FillArrays.Fill(3, (8, 6))
+    @test repeat(f, 2, 3, 4) === FillArrays.Fill(3, (8, 6, 4))
+    @test repeat(f, inner=(1,2), outer=(3,1)) === FillArrays.Fill(3, (12, 4))
+end
diff --git a/test/testhelpers/FillArrays.jl b/test/testhelpers/FillArrays.jl
index 7ba18f22307ca..ee988e0f0aa9c 100644
--- a/test/testhelpers/FillArrays.jl
+++ b/test/testhelpers/FillArrays.jl
@@ -32,4 +32,31 @@ end
 Base.show(io::IO, F::Fill) = print(io, "Fill($(F.value), $(F.size))")
 Base.show(io::IO, ::MIME"text/plain", F::Fill) = show(io, F)
 
+_first_or_one(t::Tuple) = t[1]
+_first_or_one(t::Tuple{}) = 1
+
+_match_size(sz::Tuple{}, inner::Tuple{}, outer::Tuple{}) = ()
+function _match_size(sz::Tuple, inner::Tuple, outer::Tuple)
+    t1 = (_first_or_one(sz), _first_or_one(inner), _first_or_one(outer))
+    t2 = _match_size(sz[2:end], inner[2:end], outer[2:end])
+    (t1, t2...)
+end
+
+function _repeat_size(sz::Tuple, inner::Tuple, outer::Tuple)
+    t = _match_size(sz, inner, outer)
+    map(*, getindex.(t, 1), getindex.(t, 2), getindex.(t, 3))
+end
+
+function Base.repeat(A::Fill; inner=ntuple(x->1, ndims(A)), outer=ntuple(x->1, ndims(A)))
+    Base.require_one_based_indexing(A)
+    length(inner) >= ndims(A) ||
+        throw(ArgumentError("number of inner repetitions $(length(inner)) cannot be "*
+            "less than number of dimensions of input array $(ndims(A))"))
+    length(outer) >= ndims(A) ||
+        throw(ArgumentError("number of outer repetitions $(length(outer)) cannot be "*
+            "less than number of dimensions of input array $(ndims(A))"))
+    sz = _repeat_size(size(A), Tuple(inner), Tuple(outer))
+    Fill(getindex_value(A), sz)
+end
+
 end

From e7a1c7f690647eb51ff4f35572abd6ea496460c0 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Thu, 1 Feb 2024 04:46:54 -0500
Subject: [PATCH 0779/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20ba4955e2e=20to=20f3b81f1aa=20(#53138)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: ba4955e2e
New commit: f3b81f1aa
Julia version: 1.11.0-DEV
Pkg version: 1.11.0
Bump invoked by: @KristofferC
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/ba4955e2e0eb64e47861d0a7d96569c05d41f1f5...f3b81f1aac77acf08f5d847ead29ad0a228dec67

```
$ git log --oneline ba4955e2e..f3b81f1aa
f3b81f1aa disable `julia_version` tests (#3773)
b13bd2ddf support the "path" key in Project.toml, (#3756)
731105126 why: show more when package is both a direct and indirect dep (#3771)
a83783ecb Avoid deleting existing artifacts when ignoring hashes. (#3768)
b43187590 ignore tree hashes on Windows w/o symlink capability (#3764)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5     | 1 -
 .../Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512  | 1 -
 .../Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5     | 1 +
 .../Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512

diff --git a/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5 b/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5
deleted file mode 100644
index 116a199728e95..0000000000000
--- a/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-84c5ed6280fe8108590a4eff6ac441c0
diff --git a/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512 b/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512
deleted file mode 100644
index 0bfdf11cd0c33..0000000000000
--- a/deps/checksums/Pkg-ba4955e2e0eb64e47861d0a7d96569c05d41f1f5.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-9e19fa5e01fdc51963e1699b318c329e0ac002757bb3ede2dbb17bda60198d3671b964f162b75b47a0afb51adbf7d94df8dc8696f01b8fe78519b31519eecb0b
diff --git a/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5 b/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5
new file mode 100644
index 0000000000000..93e66678953cc
--- /dev/null
+++ b/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5
@@ -0,0 +1 @@
+97bb9e102d5a173aad9b17d16d244b7b
diff --git a/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512 b/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512
new file mode 100644
index 0000000000000..82bdcc9857777
--- /dev/null
+++ b/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512
@@ -0,0 +1 @@
+2942a381f56ef739addb369de078739861a46a6e98481d5b7e7b0858a6de18e42e630e2ed4f9a3bfad4245a082f44de928d6e449f61f84a72fb521154b402a3b
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 1c0c3c244c168..fa41353d3e0a1 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = ba4955e2e0eb64e47861d0a7d96569c05d41f1f5
+PKG_SHA1 = f3b81f1aac77acf08f5d847ead29ad0a228dec67
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 1552116221016722bb97fff18fdcb9d417e6f2e9 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Wed, 25 Oct 2023 23:59:05 +0800
Subject: [PATCH 0780/1315] Update StyledStrings version

This gets us two particular commits of interest:
- Replace within-module eval with hygienic eval: which makes it possible
  to include StyledStrings in the sysimage without running into
  precompile errors.
- Load the JULIA_*_COLOR env vars for compat: which mirrors the current
  behaviour to the relevant faces.
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/StyledStrings.version                                    | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/sha512
 create mode 100644 deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512

diff --git a/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/md5 b/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/md5
deleted file mode 100644
index 1439d220e9cab..0000000000000
--- a/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-1767902e25a2154a94ddfdc507754602
diff --git a/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/sha512 b/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/sha512
deleted file mode 100644
index 3098a0b23f238..0000000000000
--- a/deps/checksums/StyledStrings-302a0d023a58d38cddf0a1b82c618621613c8d2a.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-7cc74330c9e2721cd4721fdff924a1c81c611497d0e16fe43dab380b631fb118dfd36e69f23998f96f2b8e33670d5a129f475a5da2d6f6675487330937da9aea
diff --git a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5 b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
new file mode 100644
index 0000000000000..fc675ee83125a
--- /dev/null
+++ b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
@@ -0,0 +1 @@
+c1fd1bb7e3f9ab00afe0758a8a101374
diff --git a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512 b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
new file mode 100644
index 0000000000000..09d5a8a619295
--- /dev/null
+++ b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
@@ -0,0 +1 @@
+373302f1d32a5b5ad0efacf14fa82a16fd877c11ca589fc1f1492eb1d4bcd0f49a2a5a3f471f8577649309c8a03634e7467e31b403cfd6ab8a8e4a775d7f4e53
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index f287f7d81b714..8180223575f05 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = 302a0d023a58d38cddf0a1b82c618621613c8d2a
+STYLEDSTRINGS_SHA1 = a1b2ae2434cd7d8199fa8647339422fe0e1d0324
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1

From 30ccace4277ac457ad3dfd2c611e22a8aa3b1ac0 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Wed, 25 Oct 2023 23:51:33 +0800
Subject: [PATCH 0781/1315] Load StyledStrings in REPL

By loading the StyledStrings stdlib in REPL, we load the privateered
print/show methods for the Annotated{String,Char} types defined there.

This is nice to have, because it means that styled annotated strings can
be constructed in Base and elsewhere without loading the StyledStrings
stdlib, but they will be displayed as intended in the REPL.
---
 doc/Manifest.toml             | 5 ++++-
 pkgimage.mk                   | 2 +-
 stdlib/REPL/Project.toml      | 1 +
 stdlib/REPL/src/REPL.jl       | 2 +-
 stdlib/REPL/src/precompile.jl | 1 +
 5 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/doc/Manifest.toml b/doc/Manifest.toml
index 3e973e043f60a..f3e4b08306bd2 100644
--- a/doc/Manifest.toml
+++ b/doc/Manifest.toml
@@ -205,7 +205,7 @@ uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 version = "1.11.0"
 
 [[deps.REPL]]
-deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
+deps = ["InteractiveUtils", "Markdown", "Sockets", "StyledStrings", "Unicode"]
 uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
 version = "1.11.0"
 
@@ -242,6 +242,9 @@ deps = ["ArgTools", "SHA"]
 uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"
 version = "1.10.0"
 
+[[deps.StyledStrings]]
+uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b"
+
 [[deps.Test]]
 deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
 uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/pkgimage.mk b/pkgimage.mk
index 4fd23fbe8fa2c..776a97e65a950 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -111,7 +111,7 @@ $(eval $(call stdlib_builder,InteractiveUtils,Markdown))
  # 3-depth packages
 $(eval $(call stdlib_builder,LibGit2_jll,MbedTLS_jll LibSSH2_jll Artifacts Libdl))
 $(eval $(call stdlib_builder,LibCURL_jll,LibSSH2_jll nghttp2_jll MbedTLS_jll Zlib_jll Artifacts Libdl))
-$(eval $(call stdlib_builder,REPL,InteractiveUtils Markdown Sockets Unicode))
+$(eval $(call stdlib_builder,REPL,InteractiveUtils Markdown Sockets StyledStrings Unicode))
 $(eval $(call stdlib_builder,SharedArrays,Distributed Mmap Random Serialization))
 $(eval $(call stdlib_builder,TOML,Dates))
 $(eval $(call stdlib_builder,Test,Logging Random Serialization InteractiveUtils))
diff --git a/stdlib/REPL/Project.toml b/stdlib/REPL/Project.toml
index 77eca2bfe4240..6318bd0258ab3 100644
--- a/stdlib/REPL/Project.toml
+++ b/stdlib/REPL/Project.toml
@@ -6,6 +6,7 @@ version = "1.11.0"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
 Sockets = "6462fe0b-24de-5631-8697-dd941f90decc"
+StyledStrings = "f489334b-da3d-4c2e-b8f0-e476e12c162b"
 Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
 
 [extras]
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index 5cd0c3abe917e..39b09a55c6e30 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -91,7 +91,7 @@ function __init__()
     return nothing
 end
 
-using Base.Meta, Sockets
+using Base.Meta, Sockets, StyledStrings
 import InteractiveUtils
 
 export
diff --git a/stdlib/REPL/src/precompile.jl b/stdlib/REPL/src/precompile.jl
index 7baf55e2f57bf..0eea4c140e39b 100644
--- a/stdlib/REPL/src/precompile.jl
+++ b/stdlib/REPL/src/precompile.jl
@@ -16,6 +16,7 @@ end
 using Base.Meta
 
 import Markdown
+import StyledStrings
 
 ## Debugging options
 # Disable parallel precompiles generation by setting `false`

From 453e9d0e585a27b4e66275b90876cccb3a87c42e Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Thu, 1 Feb 2024 15:35:22 +0100
Subject: [PATCH 0782/1315] `typemin`, `typemax` for irrationals (#50894)

Fixes #36978
---
 base/irrationals.jl | 3 +++
 test/numbers.jl     | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/base/irrationals.jl b/base/irrationals.jl
index 6513e3269a4d7..eafe388162353 100644
--- a/base/irrationals.jl
+++ b/base/irrationals.jl
@@ -28,6 +28,9 @@ See also [`AbstractIrrational`](@ref).
 """
 struct Irrational{sym} <: AbstractIrrational end
 
+typemin(::Type{T}) where {T<:Irrational} = T()
+typemax(::Type{T}) where {T<:Irrational} = T()
+
 show(io::IO, x::Irrational{sym}) where {sym} = print(io, sym)
 
 function show(io::IO, ::MIME"text/plain", x::Irrational{sym}) where {sym}
diff --git a/test/numbers.jl b/test/numbers.jl
index 0a01fc136e167..922fa0da3337e 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -3164,3 +3164,9 @@ end
         end
     end
 end
+
+@testset "irrational special values" begin
+    for v ∈ (π, ℯ, γ, catalan, φ)
+        @test v === typemin(v) === typemax(v)
+    end
+end

From 88218c671b13fe84721ee59ec328a31357d23996 Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Thu, 1 Feb 2024 09:39:45 -0500
Subject: [PATCH 0783/1315] Clarify error when arrays are too big for the
 system bit width (#52545)

On Slack, was helping someone who encountered an "Invalid Array size"
error message on a 32-bit system. The cause wasn't clear, so I had to
dig around and realized that it only triggers if an array is created
that is too large for the bit width of the system.

So I figured it would be better to clarify that in the error message.

---------

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
---
 src/array.c         | 8 ++++++--
 src/genericmemory.c | 4 ++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/array.c b/src/array.c
index fcae8ac26fa22..198215831497d 100644
--- a/src/array.c
+++ b/src/array.c
@@ -82,7 +82,9 @@ STATIC_INLINE jl_array_t *_new_array(jl_value_t *atype, jl_genericmemory_t *mem,
 STATIC_INLINE jl_array_t *new_array(jl_value_t *atype, uint32_t ndims, size_t *dims)
 {
     size_t nel;
-    if (jl_array_validate_dims(&nel, ndims, dims) || *(size_t*)jl_tparam1(atype) != ndims)
+    if (jl_array_validate_dims(&nel, ndims, dims))
+        jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions: too large for system address width");
+    if (*(size_t*)jl_tparam1(atype) != ndims)
         jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
     jl_value_t *mtype = jl_field_type_concrete((jl_datatype_t*)jl_field_type_concrete((jl_datatype_t*)atype, 0), 1);
     // extra byte for all julia allocated byte vectors
@@ -132,7 +134,9 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
     assert(is_ntuple_long(_dims));
     size_t *dims = (size_t*)_dims;
     size_t nel;
-    if (jl_array_validate_dims(&nel, ndims, dims) || *(size_t*)jl_tparam1(atype) != ndims)
+    if (jl_array_validate_dims(&nel, ndims, dims))
+        jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions: too large for system address width");
+    if (*(size_t*)jl_tparam1(atype) != ndims)
         jl_exceptionf(jl_argumenterror_type, "invalid Array dimensions");
     jl_value_t *mtype = jl_field_type_concrete((jl_datatype_t*)jl_field_type_concrete((jl_datatype_t*)atype, 0), 1);
     jl_genericmemory_t *mem = jl_ptr_to_genericmemory(mtype, data, nel, own_buffer);
diff --git a/src/genericmemory.c b/src/genericmemory.c
index 24b2bac6b2ac1..4543c869e6c74 100644
--- a/src/genericmemory.c
+++ b/src/genericmemory.c
@@ -69,7 +69,7 @@ jl_genericmemory_t *_new_genericmemory_(jl_value_t *mtype, size_t nel, int8_t is
         prod += nel;
     }
     if (nel >= MAXINTVAL || prod >= (wideint_t) MAXINTVAL)
-        jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory size");
+        jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory size: too large for system address width");
     size_t tot = (size_t)prod + LLT_ALIGN(sizeof(jl_genericmemory_t),JL_SMALL_BYTE_ALIGNMENT);
 
     int pooled = tot <= GC_MAX_SZCLASS;
@@ -178,7 +178,7 @@ JL_DLLEXPORT jl_genericmemory_t *jl_ptr_to_genericmemory(jl_value_t *mtype, void
         prod += nel;
     }
     if (nel >= MAXINTVAL || prod >= (wideint_t) MAXINTVAL)
-        jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory size");
+        jl_exceptionf(jl_argumenterror_type, "invalid GenericMemory size: too large for system address width");
     int tsz = sizeof(jl_genericmemory_t) + sizeof(void*);
     m = (jl_genericmemory_t*)jl_gc_alloc(ct->ptls, tsz, mtype);
     m->ptr = data;

From 8b88e3bb9a7eb76c5e36ea3ad09d32819c6ebe99 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Thu, 1 Feb 2024 15:57:13 +0100
Subject: [PATCH 0784/1315] delete unnecessary abstract type in `Base.Rounding`
 (#53093)

---
 base/rounding.jl | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/base/rounding.jl b/base/rounding.jl
index 2da605bc36f8f..d80edda1e418f 100644
--- a/base/rounding.jl
+++ b/base/rounding.jl
@@ -131,15 +131,14 @@ rounds_away_from_zero(t::Tuple{Any,Bool}) = rounds_away_from_zero(t...)
 tie_breaker_is_to_even(t::Tuple{Any,Bool}) = tie_breaker_is_to_even(first(t))
 tie_breaker_rounds_away_from_zero(t::Tuple{Any,Bool}) = tie_breaker_rounds_away_from_zero(t...)
 
-abstract type RoundingIncrementHelper end
-struct FinalBit <: RoundingIncrementHelper end
-struct RoundBit <: RoundingIncrementHelper end
-struct StickyBit <: RoundingIncrementHelper end
+struct FinalBit end
+struct RoundBit end
+struct StickyBit end
 
 function correct_rounding_requires_increment(x, rounding_mode, sign_bit::Bool)
     r = (rounding_mode, sign_bit)
     f = let y = x
-        (z::RoundingIncrementHelper) -> y(z)::Bool
+        (z::Union{FinalBit,RoundBit,StickyBit}) -> y(z)::Bool
     end
     if rounds_to_nearest(r)
         if f(RoundBit())

From c16472b001487d89e0e685a96873205f0efbfdbc Mon Sep 17 00:00:00 2001
From: Jian Fang <131804380+JianFangAtRai@users.noreply.github.com>
Date: Thu, 1 Feb 2024 06:59:17 -0800
Subject: [PATCH 0785/1315] Change to streaming out the heap snapshot data
 (#52854)

This PR is to continue the work on the following PR:

Prevent OOMs during heap snapshot: Change to streaming out the snapshot
data (https://github.com/JuliaLang/julia/pull/51518 )

Here are the commit history:

```
* Streaming the heap snapshot!

This should prevent the engine from OOMing while recording the snapshot!

Now we just need to sample the files, either online, before downloading, or offline after downloading :)

If we're gonna do it offline, we'll want to gzip the files before downloading them.

* Allow custom filename; use original API

* Support legacy heap snapshot interface. Add reassembly function.

* Add tests

* Apply suggestions from code review

* Update src/gc-heap-snapshot.cpp

* Change to always save the parts in the same directory

This way you can always recover from an OOM

* Fix bug in reassembler: from_node and to_node were in the wrong order

* Fix correctness mistake: The edges have to be reordered according to the node order. That's the whole reason this is tricky.

But i'm not sure now whether the SoAs approach is actually an optimization.... It seems like we should probably prefer to inline the Edges right into the vector, rather than having to do another random lookup into the edges table?

* Debugging messed up edge array idxs

* Disable log message

* Write the .nodes and .edges as binary data

* Remove unnecessary logging

* fix merge issues

* attempt to add back the orphan node checking logic
```

---------

Co-authored-by: Nathan Daly <nathan.daly@relational.ai>
Co-authored-by: Nathan Daly <NHDaly@gmail.com>
---
 src/gc-heap-snapshot.cpp                      | 397 +++++++++---------
 src/gc-heap-snapshot.h                        |   3 +-
 stdlib/Profile/docs/src/index.md              |  19 +
 stdlib/Profile/src/Profile.jl                 |  69 ++-
 stdlib/Profile/src/heapsnapshot_reassemble.jl | 231 ++++++++++
 .../Profile/test/heapsnapshot_reassemble.jl   |  54 +++
 stdlib/Profile/test/runtests.jl               |   1 +
 7 files changed, 571 insertions(+), 203 deletions(-)
 create mode 100644 stdlib/Profile/src/heapsnapshot_reassemble.jl
 create mode 100644 stdlib/Profile/test/heapsnapshot_reassemble.jl

diff --git a/src/gc-heap-snapshot.cpp b/src/gc-heap-snapshot.cpp
index 24df141d053f4..5007f88939701 100644
--- a/src/gc-heap-snapshot.cpp
+++ b/src/gc-heap-snapshot.cpp
@@ -58,8 +58,9 @@ void print_str_escape_json(ios_t *stream, StringRef s)
 // mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L2598-L2601
 
 struct Edge {
-    size_t type; // These *must* match the Enums on the JS side; control interpretation of name_or_index.
+    uint8_t type; // These *must* match the Enums on the JS side; control interpretation of name_or_index.
     size_t name_or_index; // name of the field (for objects/modules) or index of array
+    size_t from_node;  // This is a deviation from the .heapsnapshot format to support streaming.
     size_t to_node;
 };
 
@@ -68,29 +69,34 @@ struct Edge {
 //   [ "type", "name", "id", "self_size", "edge_count", "trace_node_id", "detachedness" ]
 // mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L2568-L2575
 
-const int k_node_number_of_fields = 7;
 struct Node {
-    size_t type; // index into snapshot->node_types
+    uint8_t type; // index into snapshot->node_types
     size_t name;
     size_t id; // This should be a globally-unique counter, but we use the memory address
     size_t self_size;
     size_t trace_node_id;  // This is ALWAYS 0 in Javascript heap-snapshots.
     // whether the from_node is attached or detached from the main application state
     // https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/include/v8-profiler.h#L739-L745
-    int detachedness;  // 0 - unknown, 1 - attached, 2 - detached
-    SmallVector<Edge, 0> edges;
+    uint8_t detachedness;  // 0 - unknown, 1 - attached, 2 - detached
 
     ~Node() JL_NOTSAFEPOINT = default;
 };
 
-struct StringTable {
+class StringTable {
+protected:
     StringMap<size_t> map;
     SmallVector<StringRef, 0> strings;
+    size_t next_id;
+
+public:
+    StringTable() JL_NOTSAFEPOINT : map(), strings(), next_id(0) {};
 
     size_t find_or_create_string_id(StringRef key) JL_NOTSAFEPOINT {
-        auto val = map.insert(make_pair(key, map.size()));
-        if (val.second)
+        auto val = map.insert(make_pair(key, next_id));
+        if (val.second) {
             strings.push_back(val.first->first());
+            next_id++;
+        }
         return val.first->second;
     }
 
@@ -110,16 +116,65 @@ struct StringTable {
     }
 };
 
-struct HeapSnapshot {
-    SmallVector<Node, 0> nodes;
-    // edges are stored on each from_node
+// a string table with partial strings in memory and all strings serialized to a file
+class SerializedStringTable: public StringTable {
+    public:
+
+    // serialize the string only if it's not already in the table
+    size_t serialize_if_necessary(ios_t *stream, StringRef key) JL_NOTSAFEPOINT {
+        auto val = map.insert(make_pair(key, next_id));
+        if (val.second) {
+            strings.push_back(val.first->first());
+            // persist the string size first, then the string itself
+            // so that we could read it back in the same order
+            size_t s_size = key.size();
+            ios_write(stream, reinterpret_cast<const char*>(&s_size), sizeof(size_t));
+            ios_write(stream, key.data(), s_size);
+            next_id++;
+        }
+        return val.first->second;
+    }
 
-    StringTable names;
+    // serialize the string without checking if it is in the table or not
+    // and return its index. This means that we might have duplicates in the
+    // output string file.
+    size_t serialize(ios_t *stream, StringRef key) JL_NOTSAFEPOINT {
+        size_t s_size = key.size();
+        ios_write(stream, reinterpret_cast<const char*>(&s_size), sizeof(size_t));
+        ios_write(stream, key.data(), s_size);
+        size_t current = next_id;
+        next_id++;
+        return current;
+    }
+};
+
+struct HeapSnapshot {
+    // names could be very large, so we keep them in a separate binary file
+    // and use a StringTable to keep track of the indices of frequently used strings
+    // to reduce duplicates in the output file to some degree
+    SerializedStringTable names;
+    // node types and edge types are very small and keep them in memory
     StringTable node_types;
     StringTable edge_types;
     DenseMap<void *, size_t> node_ptr_to_index_map;
 
-    size_t num_edges = 0; // For metadata, updated as you add each edge. Needed because edges owned by nodes.
+    size_t num_nodes = 0; // Since we stream out to files,
+    size_t num_edges = 0; // we need to track the counts here.
+
+    // Node internal_root;
+
+    // Used for streaming
+    // Since nodes and edges are just one giant array of integers, we stream them as
+    // *BINARY DATA*: a sequence of bytes, each of which is a 64-bit integer (big enough to
+    // fit the pointer ids).
+    ios_t *nodes;
+    ios_t *edges;
+    // strings are serialized to a file in binary format
+    ios_t *strings;
+    // the following file is written out as json data.
+    ios_t *json;
+
+    size_t internal_root_idx = 0; // node index of the internal root node
     size_t _gc_root_idx = 1; // node index of the GC roots node
     size_t _gc_finlist_root_idx = 2; // node index of the GC finlist roots node
 };
@@ -130,17 +185,22 @@ int gc_heap_snapshot_enabled = 0;
 HeapSnapshot *g_snapshot = nullptr;
 extern jl_mutex_t heapsnapshot_lock;
 
+void final_serialize_heap_snapshot(ios_t *json, ios_t *strings, HeapSnapshot &snapshot, char all_one);
 void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one);
 static inline void _record_gc_edge(const char *edge_type,
                                    jl_value_t *a, jl_value_t *b, size_t name_or_index) JL_NOTSAFEPOINT;
-void _record_gc_just_edge(const char *edge_type, Node &from_node, size_t to_idx, size_t name_or_idx) JL_NOTSAFEPOINT;
-void _add_synthetic_root_entries(HeapSnapshot *snapshot);
+void _record_gc_just_edge(const char *edge_type, size_t from_idx, size_t to_idx, size_t name_or_idx) JL_NOTSAFEPOINT;
+void _add_synthetic_root_entries(HeapSnapshot *snapshot) JL_NOTSAFEPOINT;
 
 
-JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one)
+JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *nodes, ios_t *edges,
+    ios_t *strings, ios_t *json, char all_one)
 {
     HeapSnapshot snapshot;
-    _add_synthetic_root_entries(&snapshot);
+    snapshot.nodes = nodes;
+    snapshot.edges = edges;
+    snapshot.strings = strings;
+    snapshot.json = json;
 
     jl_mutex_lock(&heapsnapshot_lock);
 
@@ -148,6 +208,8 @@ JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one)
     g_snapshot = &snapshot;
     gc_heap_snapshot_enabled = true;
 
+    _add_synthetic_root_entries(&snapshot);
+
     // Do a full GC mark (and incremental sweep), which will invoke our callbacks on `g_snapshot`
     jl_gc_collect(JL_GC_FULL);
 
@@ -159,70 +221,96 @@ JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one)
 
     // When we return, the snapshot is full
     // Dump the snapshot
-    serialize_heap_snapshot((ios_t*)stream, snapshot, all_one);
+    final_serialize_heap_snapshot((ios_t*)json, (ios_t*)strings, snapshot, all_one);
+}
+
+void serialize_node(HeapSnapshot *snapshot, const Node &node) JL_NOTSAFEPOINT
+{
+    // ["type","name","id","self_size","edge_count","trace_node_id","detachedness"]
+    ios_write(snapshot->nodes, (char*)&node.type, sizeof(node.type));
+    ios_write(snapshot->nodes, (char*)&node.name, sizeof(node.name));
+    ios_write(snapshot->nodes, (char*)&node.id, sizeof(node.id));
+    ios_write(snapshot->nodes, (char*)&node.self_size, sizeof(node.self_size));
+    // NOTE: We don't write edge_count, since it's always 0. It will be reconstructed in
+    // post-processing.
+    ios_write(snapshot->nodes, (char*)&node.trace_node_id, sizeof(node.trace_node_id));
+    ios_write(snapshot->nodes, (char*)&node.detachedness, sizeof(node.detachedness));
+
+    g_snapshot->num_nodes += 1;
+}
+
+void serialize_edge(HeapSnapshot *snapshot, const Edge &edge) JL_NOTSAFEPOINT
+{
+    // ["type","name_or_index","to_node"]
+    ios_write(snapshot->edges, (char*)&edge.type, sizeof(edge.type));
+    ios_write(snapshot->edges, (char*)&edge.name_or_index, sizeof(edge.name_or_index));
+    // NOTE: Row numbers for nodes (not adjusted for k_node_number_of_fields, which is 7)
+    ios_write(snapshot->edges, (char*)&edge.from_node, sizeof(edge.from_node));
+    ios_write(snapshot->edges, (char*)&edge.to_node, sizeof(edge.to_node));
+
+    g_snapshot->num_edges += 1;
 }
 
 // mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L212
 // add synthetic nodes for the uber root, the GC roots, and the GC finalizer list roots
-void _add_synthetic_root_entries(HeapSnapshot *snapshot)
+void _add_synthetic_root_entries(HeapSnapshot *snapshot) JL_NOTSAFEPOINT
 {
     // adds a node at id 0 which is the "uber root":
     // a synthetic node which points to all the GC roots.
     Node internal_root{
-        snapshot->node_types.find_or_create_string_id("synthetic"),
-        snapshot->names.find_or_create_string_id(""), // name
+        (uint8_t)snapshot->node_types.find_or_create_string_id("synthetic"),
+        snapshot->names.serialize_if_necessary(snapshot->strings, ""), // name
         0, // id
         0, // size
         0, // size_t trace_node_id (unused)
-        0, // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
-        SmallVector<Edge, 0>() // outgoing edges
+        0 // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
     };
-    snapshot->nodes.push_back(internal_root);
+    serialize_node(snapshot, internal_root);
 
     // Add a node for the GC roots
-    snapshot->_gc_root_idx = snapshot->nodes.size();
+    snapshot->_gc_root_idx = snapshot->internal_root_idx + 1;
     Node gc_roots{
-        snapshot->node_types.find_or_create_string_id("synthetic"),
-        snapshot->names.find_or_create_string_id("GC roots"), // name
+        (uint8_t)snapshot->node_types.find_or_create_string_id("synthetic"),
+        snapshot->names.serialize_if_necessary(snapshot->strings, "GC roots"), // name
         snapshot->_gc_root_idx, // id
         0, // size
         0, // size_t trace_node_id (unused)
-        0, // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
-        SmallVector<Edge, 0>() // outgoing edges
+        0 // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
     };
-    snapshot->nodes.push_back(gc_roots);
-    snapshot->nodes.front().edges.push_back(Edge{
-        snapshot->edge_types.find_or_create_string_id("internal"),
-        snapshot->names.find_or_create_string_id("GC roots"), // edge label
+    serialize_node(snapshot, gc_roots);
+    Edge root_to_gc_roots{
+        (uint8_t)snapshot->edge_types.find_or_create_string_id("internal"),
+        snapshot->names.serialize_if_necessary(snapshot->strings, "GC roots"), // edge label
+        snapshot->internal_root_idx, // from
         snapshot->_gc_root_idx // to
-    });
-    snapshot->num_edges += 1;
+    };
+    serialize_edge(snapshot, root_to_gc_roots);
 
     // add a node for the gc finalizer list roots
-    snapshot->_gc_finlist_root_idx = snapshot->nodes.size();
+    snapshot->_gc_finlist_root_idx = snapshot->internal_root_idx + 2;
     Node gc_finlist_roots{
-        snapshot->node_types.find_or_create_string_id("synthetic"),
-        snapshot->names.find_or_create_string_id("GC finalizer list roots"), // name
+        (uint8_t)snapshot->node_types.find_or_create_string_id("synthetic"),
+        snapshot->names.serialize_if_necessary(snapshot->strings, "GC finalizer list roots"), // name
         snapshot->_gc_finlist_root_idx, // id
         0, // size
         0, // size_t trace_node_id (unused)
-        0, // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
-        SmallVector<Edge, 0>() // outgoing edges
+        0 // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
     };
-    snapshot->nodes.push_back(gc_finlist_roots);
-    snapshot->nodes.front().edges.push_back(Edge{
-        snapshot->edge_types.find_or_create_string_id("internal"),
-        snapshot->names.find_or_create_string_id("GC finlist roots"), // edge label
+    serialize_node(snapshot, gc_finlist_roots);
+    Edge root_to_gc_finlist_roots{
+        (uint8_t)snapshot->edge_types.find_or_create_string_id("internal"),
+        snapshot->names.serialize_if_necessary(snapshot->strings, "GC finalizer list roots"), // edge label
+        snapshot->internal_root_idx, // from
         snapshot->_gc_finlist_root_idx // to
-    });
-    snapshot->num_edges += 1;
+    };
+    serialize_edge(snapshot, root_to_gc_finlist_roots);
 }
 
 // mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L597-L597
 // returns the index of the new node
 size_t record_node_to_gc_snapshot(jl_value_t *a) JL_NOTSAFEPOINT
 {
-    auto val = g_snapshot->node_ptr_to_index_map.insert(make_pair(a, g_snapshot->nodes.size()));
+    auto val = g_snapshot->node_ptr_to_index_map.insert(make_pair(a, g_snapshot->num_nodes));
     if (!val.second) {
         return val.first->second;
     }
@@ -292,17 +380,17 @@ size_t record_node_to_gc_snapshot(jl_value_t *a) JL_NOTSAFEPOINT
         name = StringRef((const char*)str_.buf, str_.size);
     }
 
-    g_snapshot->nodes.push_back(Node{
-        g_snapshot->node_types.find_or_create_string_id(node_type), // size_t type;
-        g_snapshot->names.find_or_create_string_id(name), // size_t name;
+    auto node = Node{
+        (uint8_t)g_snapshot->node_types.find_or_create_string_id(node_type), // size_t type;
+        g_snapshot->names.serialize(g_snapshot->strings, name), // size_t name;
         (size_t)a,     // size_t id;
         // We add 1 to self-size for the type tag that all heap-allocated objects have.
         // Also because the Chrome Snapshot viewer ignores size-0 leaves!
         sizeof(void*) + self_size, // size_t self_size;
         0,             // size_t trace_node_id (unused)
         0,             // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
-        SmallVector<Edge, 0>() // outgoing edges
-    });
+    };
+    serialize_node(g_snapshot, node);
 
     if (ios_need_close)
         ios_close(&str_);
@@ -312,20 +400,20 @@ size_t record_node_to_gc_snapshot(jl_value_t *a) JL_NOTSAFEPOINT
 
 static size_t record_pointer_to_gc_snapshot(void *a, size_t bytes, StringRef name) JL_NOTSAFEPOINT
 {
-    auto val = g_snapshot->node_ptr_to_index_map.insert(make_pair(a, g_snapshot->nodes.size()));
+    auto val = g_snapshot->node_ptr_to_index_map.insert(make_pair(a, g_snapshot->num_nodes));
     if (!val.second) {
         return val.first->second;
     }
 
-    g_snapshot->nodes.push_back(Node{
-        g_snapshot->node_types.find_or_create_string_id( "object"), // size_t type;
-        g_snapshot->names.find_or_create_string_id(name), // size_t name;
+    auto node = Node{
+        (uint8_t)g_snapshot->node_types.find_or_create_string_id( "object"), // size_t type;
+        g_snapshot->names.serialize(g_snapshot->strings, name), // size_t name;
         (size_t)a,     // size_t id;
         bytes,         // size_t self_size;
         0,             // size_t trace_node_id (unused)
         0,             // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
-        SmallVector<Edge, 0>() // outgoing edges
-    });
+    };
+    serialize_node(g_snapshot, node);
 
     return val.first->second;
 }
@@ -361,36 +449,29 @@ static string _fieldpath_for_slot(void *obj, void *slot) JL_NOTSAFEPOINT
     }
 }
 
-
 void _gc_heap_snapshot_record_root(jl_value_t *root, char *name) JL_NOTSAFEPOINT
 {
-    record_node_to_gc_snapshot(root);
-
-    auto &internal_root = g_snapshot->nodes.front();
-    auto to_node_idx = g_snapshot->node_ptr_to_index_map[root];
-    auto edge_label = g_snapshot->names.find_or_create_string_id(name);
+    size_t to_node_idx = record_node_to_gc_snapshot(root);
+    auto edge_label = g_snapshot->names.serialize(g_snapshot->strings, name);
 
-    _record_gc_just_edge("internal", internal_root, to_node_idx, edge_label);
+    _record_gc_just_edge("internal", g_snapshot->internal_root_idx, to_node_idx, edge_label);
 }
 
 void _gc_heap_snapshot_record_gc_roots(jl_value_t *root, char *name) JL_NOTSAFEPOINT
 {
-    record_node_to_gc_snapshot(root);
-
-    auto from_node_idx = g_snapshot->_gc_root_idx;
     auto to_node_idx = record_node_to_gc_snapshot(root);
-    auto edge_label = g_snapshot->names.find_or_create_string_id(name);
-    _record_gc_just_edge("internal", g_snapshot->nodes[from_node_idx], to_node_idx, edge_label);
+    auto edge_label = g_snapshot->names.serialize(g_snapshot->strings, name);
+
+    _record_gc_just_edge("internal", g_snapshot->_gc_root_idx, to_node_idx, edge_label);
 }
 
 void _gc_heap_snapshot_record_finlist(jl_value_t *obj, size_t index) JL_NOTSAFEPOINT
 {
-    auto from_node_idx = g_snapshot->_gc_finlist_root_idx;
     auto to_node_idx = record_node_to_gc_snapshot(obj);
     ostringstream ss;
     ss << "finlist-" << index;
-    auto edge_label = g_snapshot->names.find_or_create_string_id(ss.str());
-    _record_gc_just_edge("internal", g_snapshot->nodes[from_node_idx], to_node_idx, edge_label);
+    auto edge_label = g_snapshot->names.serialize_if_necessary(g_snapshot->strings, ss.str());
+    _record_gc_just_edge("internal", g_snapshot->_gc_finlist_root_idx, to_node_idx, edge_label);
 }
 
 // Add a node to the heap snapshot representing a Julia stack frame.
@@ -399,20 +480,20 @@ void _gc_heap_snapshot_record_finlist(jl_value_t *obj, size_t index) JL_NOTSAFEP
 // Stack frame nodes point at the objects they have as local variables.
 size_t _record_stack_frame_node(HeapSnapshot *snapshot, void *frame) JL_NOTSAFEPOINT
 {
-    auto val = g_snapshot->node_ptr_to_index_map.insert(make_pair(frame, g_snapshot->nodes.size()));
+    auto val = g_snapshot->node_ptr_to_index_map.insert(make_pair(frame, g_snapshot->num_nodes));
     if (!val.second) {
         return val.first->second;
     }
 
-    snapshot->nodes.push_back(Node{
-        snapshot->node_types.find_or_create_string_id("synthetic"),
-        snapshot->names.find_or_create_string_id("(stack frame)"), // name
+    auto node = Node{
+        (uint8_t)snapshot->node_types.find_or_create_string_id("synthetic"),
+        snapshot->names.serialize_if_necessary(snapshot->strings, "(stack frame)"), // name
         (size_t)frame, // id
         1, // size
         0, // size_t trace_node_id (unused)
         0, // int detachedness;  // 0 - unknown,  1 - attached;  2 - detached
-        SmallVector<Edge, 0>() // outgoing edges
-    });
+    };
+    serialize_node(snapshot, node);
 
     return val.first->second;
 }
@@ -421,30 +502,27 @@ void _gc_heap_snapshot_record_frame_to_object_edge(void *from, jl_value_t *to) J
 {
     auto from_node_idx = _record_stack_frame_node(g_snapshot, (jl_gcframe_t*)from);
     auto to_idx = record_node_to_gc_snapshot(to);
-    Node &from_node = g_snapshot->nodes[from_node_idx];
 
-    auto name_idx = g_snapshot->names.find_or_create_string_id("local var");
-    _record_gc_just_edge("internal", from_node, to_idx, name_idx);
+    auto name_idx = g_snapshot->names.serialize_if_necessary(g_snapshot->strings, "local var");
+    _record_gc_just_edge("internal", from_node_idx, to_idx, name_idx);
 }
 
 void _gc_heap_snapshot_record_task_to_frame_edge(jl_task_t *from, void *to) JL_NOTSAFEPOINT
 {
     auto from_node_idx = record_node_to_gc_snapshot((jl_value_t*)from);
     auto to_node_idx = _record_stack_frame_node(g_snapshot, to);
-    Node &from_node = g_snapshot->nodes[from_node_idx];
 
-    auto name_idx = g_snapshot->names.find_or_create_string_id("stack");
-    _record_gc_just_edge("internal", from_node, to_node_idx, name_idx);
+    auto name_idx = g_snapshot->names.serialize_if_necessary(g_snapshot->strings, "stack");
+    _record_gc_just_edge("internal", from_node_idx, to_node_idx, name_idx);
 }
 
 void _gc_heap_snapshot_record_frame_to_frame_edge(jl_gcframe_t *from, jl_gcframe_t *to) JL_NOTSAFEPOINT
 {
     auto from_node_idx = _record_stack_frame_node(g_snapshot, from);
     auto to_node_idx = _record_stack_frame_node(g_snapshot, to);
-    Node &from_node = g_snapshot->nodes[from_node_idx];
 
-    auto name_idx = g_snapshot->names.find_or_create_string_id("next frame");
-    _record_gc_just_edge("internal", from_node, to_node_idx, name_idx);
+    auto name_idx = g_snapshot->names.serialize_if_necessary(g_snapshot->strings, "next frame");
+    _record_gc_just_edge("internal", from_node_idx, to_node_idx, name_idx);
 }
 
 void _gc_heap_snapshot_record_array_edge(jl_value_t *from, jl_value_t *to, size_t index) JL_NOTSAFEPOINT
@@ -456,7 +534,7 @@ void _gc_heap_snapshot_record_object_edge(jl_value_t *from, jl_value_t *to, void
 {
     string path = _fieldpath_for_slot(from, slot);
     _record_gc_edge("property", from, to,
-                    g_snapshot->names.find_or_create_string_id(path));
+                    g_snapshot->names.serialize_if_necessary(g_snapshot->strings, path));
 }
 
 void _gc_heap_snapshot_record_module_to_binding(jl_module_t *module, jl_value_t *bindings, jl_value_t *bindingkeyset) JL_NOTSAFEPOINT
@@ -464,46 +542,44 @@ void _gc_heap_snapshot_record_module_to_binding(jl_module_t *module, jl_value_t
     auto from_node_idx = record_node_to_gc_snapshot((jl_value_t*)module);
     auto to_bindings_idx = record_node_to_gc_snapshot(bindings);
     auto to_bindingkeyset_idx = record_node_to_gc_snapshot(bindingkeyset);
-    auto &from_node = g_snapshot->nodes[from_node_idx];
+
     if (to_bindings_idx > 0) {
-        _record_gc_just_edge("internal", from_node, to_bindings_idx, g_snapshot->names.find_or_create_string_id("bindings"));
+        _record_gc_just_edge("internal", from_node_idx, to_bindings_idx, g_snapshot->names.serialize_if_necessary(g_snapshot->strings, "bindings"));
     }
     if (to_bindingkeyset_idx > 0) {
-        _record_gc_just_edge("internal", from_node, to_bindingkeyset_idx, g_snapshot->names.find_or_create_string_id("bindingkeyset"));
+        _record_gc_just_edge("internal", from_node_idx, to_bindingkeyset_idx, g_snapshot->names.serialize_if_necessary(g_snapshot->strings, "bindingkeyset"));
     }
  }
 
 void _gc_heap_snapshot_record_internal_array_edge(jl_value_t *from, jl_value_t *to) JL_NOTSAFEPOINT
 {
     _record_gc_edge("internal", from, to,
-                    g_snapshot->names.find_or_create_string_id("<internal>"));
+                    g_snapshot->names.serialize_if_necessary(g_snapshot->strings, "<internal>"));
 }
 
 void _gc_heap_snapshot_record_hidden_edge(jl_value_t *from, void* to, size_t bytes, uint16_t alloc_type) JL_NOTSAFEPOINT
 {
-    size_t name_or_idx = g_snapshot->names.find_or_create_string_id("<native>");
+    // valid alloc_type values are 0, 1, 2
+    assert(alloc_type <= 2);
+    size_t name_or_idx = g_snapshot->names.serialize_if_necessary(g_snapshot->strings, "<native>");
 
     auto from_node_idx = record_node_to_gc_snapshot(from);
-    const char *alloc_kind;
+    const char *alloc_kind = NULL;
     switch (alloc_type)
     {
     case 0:
-        alloc_kind = "<malloc>";
+        alloc_kind = "<generic memory - malloc>";
         break;
     case 1:
-        alloc_kind = "<pooled>";
+        alloc_kind = "<generic memory - pool alloc>";
         break;
     case 2:
-        alloc_kind = "<inline>";
-        break;
-    default:
-        alloc_kind = "<undef>";
+        alloc_kind = "<generic memory - inline alloc>";
         break;
     }
     auto to_node_idx = record_pointer_to_gc_snapshot(to, bytes, alloc_kind);
-    auto &from_node = g_snapshot->nodes[from_node_idx];
 
-    _record_gc_just_edge("hidden", from_node, to_node_idx, name_or_idx);
+    _record_gc_just_edge("hidden", from_node_idx, to_node_idx, name_or_idx);
 }
 
 static inline void _record_gc_edge(const char *edge_type, jl_value_t *a,
@@ -512,104 +588,39 @@ static inline void _record_gc_edge(const char *edge_type, jl_value_t *a,
     auto from_node_idx = record_node_to_gc_snapshot(a);
     auto to_node_idx = record_node_to_gc_snapshot(b);
 
-    auto &from_node = g_snapshot->nodes[from_node_idx];
-
-    _record_gc_just_edge(edge_type, from_node, to_node_idx, name_or_idx);
+    _record_gc_just_edge(edge_type, from_node_idx, to_node_idx, name_or_idx);
 }
 
-void _record_gc_just_edge(const char *edge_type, Node &from_node, size_t to_idx, size_t name_or_idx) JL_NOTSAFEPOINT
+void _record_gc_just_edge(const char *edge_type, size_t from_idx, size_t to_idx, size_t name_or_idx) JL_NOTSAFEPOINT
 {
-    from_node.edges.push_back(Edge{
-        g_snapshot->edge_types.find_or_create_string_id(edge_type),
+    auto edge = Edge{
+        (uint8_t)g_snapshot->edge_types.find_or_create_string_id(edge_type),
         name_or_idx, // edge label
+        from_idx, // from
         to_idx // to
-    });
+    };
 
-    g_snapshot->num_edges += 1;
+    serialize_edge(g_snapshot, edge);
 }
 
-void serialize_heap_snapshot(ios_t *stream, HeapSnapshot &snapshot, char all_one)
+void final_serialize_heap_snapshot(ios_t *json, ios_t *strings, HeapSnapshot &snapshot, char all_one)
 {
     // mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L2567-L2567
-    ios_printf(stream, "{\"snapshot\":{");
-    ios_printf(stream, "\"meta\":{");
-    ios_printf(stream, "\"node_fields\":[\"type\",\"name\",\"id\",\"self_size\",\"edge_count\",\"trace_node_id\",\"detachedness\"],");
-    ios_printf(stream, "\"node_types\":[");
-    snapshot.node_types.print_json_array(stream, false);
-    ios_printf(stream, ",");
-    ios_printf(stream, "\"string\", \"number\", \"number\", \"number\", \"number\", \"number\"],");
-    ios_printf(stream, "\"edge_fields\":[\"type\",\"name_or_index\",\"to_node\"],");
-    ios_printf(stream, "\"edge_types\":[");
-    snapshot.edge_types.print_json_array(stream, false);
-    ios_printf(stream, ",");
-    ios_printf(stream, "\"string_or_number\",\"from_node\"]");
-    ios_printf(stream, "},\n"); // end "meta"
-    ios_printf(stream, "\"node_count\":%zu,", snapshot.nodes.size());
-    ios_printf(stream, "\"edge_count\":%zu", snapshot.num_edges);
-    ios_printf(stream, "},\n"); // end "snapshot"
-
-    ios_printf(stream, "\"nodes\":[");
-    bool first_node = true;
-    // use a set to track the nodes that do not have parents
-    set<size_t> orphans;
-    for (const auto &from_node : snapshot.nodes) {
-        if (first_node) {
-            first_node = false;
-        }
-        else {
-            ios_printf(stream, ",");
-        }
-        // ["type","name","id","self_size","edge_count","trace_node_id","detachedness"]
-        ios_printf(stream, "%zu,%zu,%zu,%zu,%zu,%zu,%d\n",
-                            from_node.type,
-                            from_node.name,
-                            from_node.id,
-                            all_one ? (size_t)1 : from_node.self_size,
-                            from_node.edges.size(),
-                            from_node.trace_node_id,
-                            from_node.detachedness);
-        if (from_node.id != snapshot._gc_root_idx && from_node.id != snapshot._gc_finlist_root_idx) {
-            // find the node index from the node object pointer
-            void * ptr = (void*)from_node.id;
-            size_t n_id = snapshot.node_ptr_to_index_map[ptr];
-            orphans.insert(n_id);
-        } else {
-            orphans.insert(from_node.id);
-        }
-    }
-    ios_printf(stream, "],\n");
-
-    ios_printf(stream, "\"edges\":[");
-    bool first_edge = true;
-    for (const auto &from_node : snapshot.nodes) {
-        for (const auto &edge : from_node.edges) {
-            if (first_edge) {
-                first_edge = false;
-            }
-            else {
-                ios_printf(stream, ",");
-            }
-            ios_printf(stream, "%zu,%zu,%zu\n",
-                                edge.type,
-                                edge.name_or_index,
-                                edge.to_node * k_node_number_of_fields);
-            auto n_id = edge.to_node;
-            auto it = orphans.find(n_id);
-            if (it != orphans.end()) {
-                // remove the node from the orphans if it has at least one incoming edge
-                orphans.erase(it);
-            }
-        }
-    }
-    ios_printf(stream, "],\n"); // end "edges"
-
-    ios_printf(stream, "\"strings\":");
-
-    snapshot.names.print_json_array(stream, true);
-
-    ios_printf(stream, "}");
-
-    // remove the uber node from the orphans
-    orphans.erase(0);
-    assert(orphans.size() == 0 && "all nodes except the uber node should have at least one incoming edge");
+    ios_printf(json, "{\"snapshot\":{");
+    ios_printf(json, "\"meta\":{");
+    ios_printf(json, "\"node_fields\":[\"type\",\"name\",\"id\",\"self_size\",\"edge_count\",\"trace_node_id\",\"detachedness\"],");
+    ios_printf(json, "\"node_types\":[");
+    snapshot.node_types.print_json_array(json, false);
+    ios_printf(json, ",");
+    ios_printf(json, "\"string\", \"number\", \"number\", \"number\", \"number\", \"number\"],");
+    ios_printf(json, "\"edge_fields\":[\"type\",\"name_or_index\",\"to_node\"],");
+    ios_printf(json, "\"edge_types\":[");
+    snapshot.edge_types.print_json_array(json, false);
+    ios_printf(json, ",");
+    ios_printf(json, "\"string_or_number\",\"from_node\"]");
+    ios_printf(json, "},\n"); // end "meta"
+    ios_printf(json, "\"node_count\":%zu,", snapshot.num_nodes);
+    ios_printf(json, "\"edge_count\":%zu", snapshot.num_edges);
+    ios_printf(json, "}\n"); // end "snapshot"
+    ios_printf(json, "}");
 }
diff --git a/src/gc-heap-snapshot.h b/src/gc-heap-snapshot.h
index 1799063825e83..70884f5f62d6a 100644
--- a/src/gc-heap-snapshot.h
+++ b/src/gc-heap-snapshot.h
@@ -120,7 +120,8 @@ static inline void gc_heap_snapshot_record_finlist(jl_value_t *finlist, size_t i
 // ---------------------------------------------------------------------
 // Functions to call from Julia to take heap snapshot
 // ---------------------------------------------------------------------
-JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one);
+JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *nodes, ios_t *edges,
+    ios_t *strings, ios_t *json, char all_one);
 
 
 #ifdef __cplusplus
diff --git a/stdlib/Profile/docs/src/index.md b/stdlib/Profile/docs/src/index.md
index 7e8259e0eea09..5b4db77b9cb16 100644
--- a/stdlib/Profile/docs/src/index.md
+++ b/stdlib/Profile/docs/src/index.md
@@ -134,5 +134,24 @@ Traces and records julia objects on the heap. This only records objects known to
 garbage collector. Memory allocated by external libraries not managed by the garbage
 collector will not show up in the snapshot.
 
+To avoid OOMing while recording the snapshot, we added a streaming option to stream out the heap snapshot
+into four files,
+
+```julia-repl
+julia> using Profile
+
+julia> Profile.take_heap_snapshot("snapshot"; streaming=true)
+```
+
+where "snapshot" is the filepath as the prefix for the generated files.
+
+Once the snapshot files are generated, they could be assembled offline with the following command:
+
+```julia-repl
+julia> using Profile
+
+julia> Profile.HeapSnapshot.assemble_snapshot("snapshot", "snapshot.heapsnapshot")
+```
+
 The resulting heap snapshot file can be uploaded to chrome devtools to be viewed.
 For more information, see the [chrome devtools docs](https://developer.chrome.com/docs/devtools/memory-problems/heap-snapshots/#view_snapshots).
diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index e01f5ae7d2d6b..6be5ad4b75894 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -1245,9 +1245,8 @@ end
 
 
 """
-    Profile.take_heap_snapshot(io::IOStream, all_one::Bool=false)
-    Profile.take_heap_snapshot(filepath::String, all_one::Bool=false)
-    Profile.take_heap_snapshot(all_one::Bool=false; dir::String)
+    Profile.take_heap_snapshot(filepath::String, all_one::Bool=false, streaming=false)
+    Profile.take_heap_snapshot(all_one::Bool=false; dir::String, streaming=false)
 
 Write a snapshot of the heap, in the JSON format expected by the Chrome
 Devtools Heap Snapshot viewer (.heapsnapshot extension) to a file
@@ -1257,16 +1256,67 @@ full file path, or IO stream.
 
 If `all_one` is true, then report the size of every object as one so they can be easily
 counted. Otherwise, report the actual size.
+
+If `streaming` is true, we will stream the snapshot data out into four files, using filepath
+as the prefix, to avoid having to hold the entire snapshot in memory. This option should be
+used for any setting where your memory is constrained. These files can then be reassembled
+by calling Profile.HeapSnapshot.assemble_snapshot(), which can
+be done offline.
+
+NOTE: We strongly recommend setting streaming=true for performance reasons. Reconstructing
+the snapshot from the parts requires holding the entire snapshot in memory, so if the
+snapshot is large, you can run out of memory while processing it. Streaming allows you to
+reconstruct the snapshot offline, after your workload is done running.
+If you do attempt to collect a snapshot with streaming=false (the default, for
+backwards-compatibility) and your process is killed, note that this will always save the
+parts in the same directory as your provided filepath, so you can still reconstruct the
+snapshot after the fact, via `assemble_snapshot()`.
 """
-function take_heap_snapshot(io::IOStream, all_one::Bool=false)
-    Base.@_lock_ios(io, ccall(:jl_gc_take_heap_snapshot, Cvoid, (Ptr{Cvoid}, Cchar), io.handle, Cchar(all_one)))
-end
-function take_heap_snapshot(filepath::String, all_one::Bool=false)
-    open(filepath, "w") do io
-        take_heap_snapshot(io, all_one)
+function take_heap_snapshot(filepath::AbstractString, all_one::Bool=false; streaming::Bool=false)
+    if streaming
+        _stream_heap_snapshot(filepath, all_one)
+    else
+        # Support the legacy, non-streaming mode, by first streaming the parts, then
+        # reassembling it after we're done.
+        prefix = filepath
+        _stream_heap_snapshot(prefix, all_one)
+        Profile.HeapSnapshot.assemble_snapshot(prefix, filepath)
     end
     return filepath
 end
+function take_heap_snapshot(io::IO, all_one::Bool=false)
+    # Support the legacy, non-streaming mode, by first streaming the parts to a tempdir,
+    # then reassembling it after we're done.
+    dir = tempdir()
+    prefix = joinpath(dir, "snapshot")
+    _stream_heap_snapshot(prefix, all_one)
+    Profile.HeapSnapshot.assemble_snapshot(prefix, io)
+end
+function _stream_heap_snapshot(prefix::AbstractString, all_one::Bool)
+    # Nodes and edges are binary files
+    open("$prefix.nodes", "w") do nodes
+        open("$prefix.edges", "w") do edges
+            open("$prefix.strings", "w") do strings
+                # The following file is json data
+                open("$prefix.metadata.json", "w") do json
+                    Base.@_lock_ios(nodes,
+                    Base.@_lock_ios(edges,
+                    Base.@_lock_ios(strings,
+                    Base.@_lock_ios(json,
+                        ccall(:jl_gc_take_heap_snapshot,
+                            Cvoid,
+                            (Ptr{Cvoid},Ptr{Cvoid},Ptr{Cvoid},Ptr{Cvoid}, Cchar),
+                            nodes.handle, edges.handle, strings.handle, json.handle,
+                            Cchar(all_one))
+                    )
+                    )
+                    )
+                    )
+                end
+            end
+        end
+    end
+end
 function take_heap_snapshot(all_one::Bool=false; dir::Union{Nothing,S}=nothing) where {S <: AbstractString}
     fname = "$(getpid())_$(time_ns()).heapsnapshot"
     if isnothing(dir)
@@ -1302,6 +1352,7 @@ function take_page_profile(filepath::String)
 end
 
 include("Allocs.jl")
+include("heapsnapshot_reassemble.jl")
 include("precompile.jl")
 
 end # module
diff --git a/stdlib/Profile/src/heapsnapshot_reassemble.jl b/stdlib/Profile/src/heapsnapshot_reassemble.jl
new file mode 100644
index 0000000000000..b39f53a8bda03
--- /dev/null
+++ b/stdlib/Profile/src/heapsnapshot_reassemble.jl
@@ -0,0 +1,231 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+module HeapSnapshot
+
+"""
+    assemble_snapshot(filepath::AbstractString, out_file::AbstractString)
+
+Assemble a .heapsnapshot file from the .json files produced by `Profile.take_snapshot`.
+"""
+
+# SoA layout to reduce padding
+struct Edges
+    type::Vector{Int8}       # index into `snapshot.meta.edge_types`
+    name_or_index::Vector{UInt} # Either an index into `snapshot.strings`, or the index in an array, depending on edge_type
+    to_pos::Vector{UInt}   # index into `snapshot.nodes`
+end
+function Edges(n::Int)
+    Edges(
+        Vector{Int8}(undef, n),
+        Vector{UInt}(undef, n),
+        Vector{UInt}(undef, n),
+    )
+end
+Base.length(n::Edges) = length(n.type)
+
+# trace_node_id and detachedness are always 0 in the snapshots Julia produces so we don't store them
+struct Nodes
+    type::Vector{Int8}         # index into `snapshot.meta.node_types`
+    name_idx::Vector{UInt32} # index into `snapshot.strings`
+    id::Vector{UInt}           # unique id, in julia it is the address of the object
+    self_size::Vector{Int}     # size of the object itself, not including the size of its fields
+    edge_count::Vector{UInt} # number of outgoing edges
+    edges::Edges               # outgoing edges
+    # This is the main complexity of the .heapsnapshot format, and it's the reason we need
+    # to read in all the data before writing it out. The edges vector contains all edges,
+    # but organized by which node they came from. First, it contains all the edges coming
+    # out of node 0, then all edges leaving node 1, etc. So we need to have visited all
+    # edges, and assigned them to their corresponding nodes, before we can emit the file.
+    edge_idxs::Vector{Vector{UInt}} # indexes into edges, keeping per-node outgoing edge ids
+end
+function Nodes(n::Int, e::Int)
+    Nodes(
+        Vector{Int8}(undef, n),
+        Vector{UInt32}(undef, n),
+        Vector{UInt}(undef, n),
+        Vector{Int}(undef, n),
+        Vector{UInt32}(undef, n),
+        Edges(e),
+        [Vector{UInt}() for _ in 1:n],  # Take care to construct n separate empty vectors
+    )
+end
+Base.length(n::Nodes) = length(n.type)
+
+const k_node_number_of_fields = 7
+
+# Like Base.dec, but doesn't allocate a string and writes directly to the io object
+# We know all of the numbers we're about to write fit into a UInt and are non-negative
+let _dec_d100 = UInt16[(0x30 + i % 10) << 0x8 + (0x30 + i ÷ 10) for i = 0:99]
+    global _write_decimal_number
+    _write_decimal_number(io, x::Integer, buf) = _write_decimal_number(io, unsigned(x), buf)
+    function _write_decimal_number(io, x::Unsigned, digits_buf)
+        buf = digits_buf
+        n = ndigits(x)
+        i = n
+        @inbounds while i >= 2
+            d, r = divrem(x, 0x64)
+            d100 = _dec_d100[(r % Int)::Int + 1]
+            buf[i-1] = d100 % UInt8
+            buf[i] = (d100 >> 0x8) % UInt8
+            x = oftype(x, d)
+            i -= 2
+        end
+        if i > 0
+            @inbounds buf[i] = 0x30 + (rem(x, 0xa) % UInt8)::UInt8
+        end
+        write(io, @view buf[max(i, 1):n])
+    end
+end
+
+function assemble_snapshot(in_prefix, out_file::AbstractString = in_prefix)
+    open(out_file, "w") do io
+        assemble_snapshot(in_prefix, io)
+    end
+end
+
+# Manually parse and write the .json files, given that we don't have JSON import/export in
+# julia's stdlibs.
+function assemble_snapshot(in_prefix, io::IO)
+    preamble = read(string(in_prefix, ".metadata.json"), String)
+    pos = last(findfirst("node_count\":", preamble)) + 1
+    endpos = findnext(==(','), preamble, pos) - 1
+    node_count = parse(Int, String(@view preamble[pos:endpos]))
+
+    pos = last(findnext("edge_count\":", preamble, endpos)) + 1
+    endpos = findnext(==('}'), preamble, pos) - 1
+    edge_count = parse(Int, String(@view preamble[pos:endpos]))
+
+    nodes = Nodes(node_count, edge_count)
+
+    orphans = Set{UInt}() # nodes that have no incoming edges
+    # Parse nodes with empty edge counts that we need to fill later
+    nodes_file = open(string(in_prefix, ".nodes"), "r")
+    for i in 1:length(nodes)
+        node_type = read(nodes_file, Int8)
+        node_name_idx = read(nodes_file, UInt)
+        id = read(nodes_file, UInt)
+        self_size = read(nodes_file, Int)
+        @assert read(nodes_file, Int) == 0 # trace_node_id
+        @assert read(nodes_file, Int8) == 0 # detachedness
+
+        nodes.type[i] = node_type
+        nodes.name_idx[i] = node_name_idx
+        nodes.id[i] = id
+        nodes.self_size[i] = self_size
+        nodes.edge_count[i] = 0 # edge_count
+        # populate the orphans set with node index
+        push!(orphans, i-1)
+    end
+
+    # Parse the edges to fill in the edge counts for nodes and correct the to_node offsets
+    edges_file = open(string(in_prefix, ".edges"), "r")
+    for i in 1:length(nodes.edges)
+        edge_type = read(edges_file, Int8)
+        edge_name_or_index = read(edges_file, UInt)
+        from_node = read(edges_file, UInt)
+        to_node = read(edges_file, UInt)
+
+        nodes.edges.type[i] = edge_type
+        nodes.edges.name_or_index[i] = edge_name_or_index
+        nodes.edges.to_pos[i] = to_node * k_node_number_of_fields # 7 fields per node, the streaming format doesn't multiply the offset by 7
+        nodes.edge_count[from_node + 1] += UInt32(1)  # C and JSON use 0-based indexing
+        push!(nodes.edge_idxs[from_node + 1], i) # Index into nodes.edges
+        # remove the node from the orphans if it has at least one incoming edge
+        if to_node in orphans
+            delete!(orphans, to_node)
+        end
+    end
+
+    _digits_buf = zeros(UInt8, ndigits(typemax(UInt)))
+    println(io, @view(preamble[1:end-2]), ",") # remove trailing "}\n", we don't end the snapshot here
+    println(io, "\"nodes\":[")
+    for i in 1:length(nodes)
+        i > 1 && println(io, ",")
+        _write_decimal_number(io, nodes.type[i], _digits_buf)
+        print(io, ",")
+        _write_decimal_number(io, nodes.name_idx[i], _digits_buf)
+        print(io, ",")
+        _write_decimal_number(io, nodes.id[i], _digits_buf)
+        print(io, ",")
+        _write_decimal_number(io, nodes.self_size[i], _digits_buf)
+        print(io, ",")
+        _write_decimal_number(io, nodes.edge_count[i], _digits_buf)
+        print(io, ",0,0")
+    end
+    print(io, "],\"edges\":[")
+    e = 1
+    for n in 1:length(nodes)
+        count = nodes.edge_count[n]
+        len_edges = length(nodes.edge_idxs[n])
+        @assert count == len_edges "For node $n: $count != $len_edges"
+        for i in nodes.edge_idxs[n]
+            e > 1 && print(io, ",")
+            println(io)
+            _write_decimal_number(io, nodes.edges.type[i], _digits_buf)
+            print(io, ",")
+            _write_decimal_number(io, nodes.edges.name_or_index[i], _digits_buf)
+            print(io, ",")
+            _write_decimal_number(io, nodes.edges.to_pos[i], _digits_buf)
+            if !(nodes.edges.to_pos[i] % k_node_number_of_fields == 0)
+                @warn "Bug in to_pos for edge $i from node $n: $(nodes.edges.to_pos[i])"
+            end
+            e += 1
+        end
+    end
+    println(io, "],")
+
+    println(io, "\"strings\":[")
+    open(string(in_prefix, ".strings"), "r") do strings_io
+        first = true
+        while !eof(strings_io)
+            str_size = read(strings_io, UInt)
+            str_bytes = read(strings_io, str_size)
+            str = String(str_bytes)
+            if first
+                print_str_escape_json(io, str)
+                first = false
+            else
+                print(io, ",\n")
+                print_str_escape_json(io, str)
+            end
+        end
+    end
+    print(io, "]}")
+
+    # remove the uber node from the orphans
+    if 0 in orphans
+        delete!(orphans, 0)
+    end
+
+    @assert isempty(orphans) "Orphaned nodes: $(orphans), node count: $(length(nodes)), orphan node count: $(length(orphans))"
+
+    return nothing
+end
+
+function print_str_escape_json(stream::IO, s::AbstractString)
+    print(stream, '"')
+    for c in s
+        if c == '"'
+            print(stream, "\\\"")
+        elseif c == '\\'
+            print(stream, "\\\\")
+        elseif c == '\b'
+            print(stream, "\\b")
+        elseif c == '\f'
+            print(stream, "\\f")
+        elseif c == '\n'
+            print(stream, "\\n")
+        elseif c == '\r'
+            print(stream, "\\r")
+        elseif c == '\t'
+            print(stream, "\\t")
+        elseif '\x00' <= c <= '\x1f'
+            print(stream, "\\u", lpad(string(UInt16(c), base=16), 4, '0'))
+        else
+            print(stream, c)
+        end
+    end
+    print(stream, '"')
+end
+
+end
diff --git a/stdlib/Profile/test/heapsnapshot_reassemble.jl b/stdlib/Profile/test/heapsnapshot_reassemble.jl
new file mode 100644
index 0000000000000..e1d6621647671
--- /dev/null
+++ b/stdlib/Profile/test/heapsnapshot_reassemble.jl
@@ -0,0 +1,54 @@
+using Test
+
+@testset "_write_decimal_number" begin
+    _digits_buf = zeros(UInt8, ndigits(typemax(UInt)))
+    io = IOBuffer()
+
+    test_write(d) = begin
+        Profile.HeapSnapshot._write_decimal_number(io, d, _digits_buf)
+        s = String(take!(io))
+        seekstart(io)
+        return s
+    end
+    @test test_write(0) == "0"
+    @test test_write(99) == "99"
+
+    @test test_write(UInt8(0)) == "0"
+    @test test_write(UInt32(0)) == "0"
+    @test test_write(Int32(0)) == "0"
+
+    @test test_write(UInt8(99)) == "99"
+    @test test_write(UInt32(99)) == "99"
+    @test test_write(Int32(99)) == "99"
+
+    # Sample among possible UInts we might print
+    for x in typemin(UInt8):typemax(UInt8)
+        @test test_write(x) == string(x)
+    end
+    for x in typemin(UInt):typemax(UInt)÷10001:typemax(UInt)
+        @test test_write(x) == string(x)
+    end
+end
+
+function test_print_str_escape_json(input::AbstractString, expected::AbstractString)
+    output = IOBuffer()
+    Profile.HeapSnapshot.print_str_escape_json(output, input)
+    @test String(take!(output)) == expected
+end
+
+@testset "print_str_escape_json" begin
+    # Test basic string escaping
+    test_print_str_escape_json("\"hello\"", "\"\\\"hello\\\"\"")
+
+    # Test escaping of control characters
+    test_print_str_escape_json("\x01\x02\x03", "\"\\u0001\\u0002\\u0003\"")
+
+    # Test escaping of other special characters
+    test_print_str_escape_json("\b\f\n\r\t", "\"\\b\\f\\n\\r\\t\"")
+
+    # Test handling of mixed characters
+    test_print_str_escape_json("abc\ndef\"ghi", "\"abc\\ndef\\\"ghi\"")
+
+    # Test handling of empty string
+    test_print_str_escape_json("", "\"\"")
+end
diff --git a/stdlib/Profile/test/runtests.jl b/stdlib/Profile/test/runtests.jl
index 169e70bfa7f36..cbfdde61d7054 100644
--- a/stdlib/Profile/test/runtests.jl
+++ b/stdlib/Profile/test/runtests.jl
@@ -306,3 +306,4 @@ include("allocs.jl")
     @test_broken isempty(undoc)
     @test undoc == [:Allocs]
 end
+include("heapsnapshot_reassemble.jl")

From 058b511622539a943436c38ca19258eec3eff02d Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Fri, 2 Feb 2024 00:42:19 -0600
Subject: [PATCH 0786/1315] deps/libsuitesparse: fix source build (#53150)

fix #53122
---
 deps/libsuitesparse.mk                     | 44 ++++++++++++----------
 deps/patches/suitesparse-blas-suffix.patch | 40 --------------------
 2 files changed, 24 insertions(+), 60 deletions(-)
 delete mode 100644 deps/patches/suitesparse-blas-suffix.patch

diff --git a/deps/libsuitesparse.mk b/deps/libsuitesparse.mk
index 386194221b43c..7e36bce8f4f9d 100644
--- a/deps/libsuitesparse.mk
+++ b/deps/libsuitesparse.mk
@@ -3,14 +3,20 @@ include $(SRCDIR)/libsuitesparse.version
 
 ifneq ($(USE_BINARYBUILDER_LIBSUITESPARSE), 1)
 
-LIBSUITESPARSE_PROJECTS := "amd;btf;camd;ccolamd;colamd;cholmod;klu;ldl;umfpack;rbio;spqr"
+LIBSUITESPARSE_PROJECTS := "suitesparse_config;amd;btf;camd;ccolamd;colamd;cholmod;klu;ldl;umfpack;rbio;spqr"
 LIBSUITESPARSE_LIBS := $(addsuffix .*$(SHLIB_EXT)*,suitesparseconfig $(subst ;, ,$(LIBSUITESPARSE_PROJECTS)))
 
+ifeq ($(OS),WINNT)
+BLAS_LIB_NAME_NO_EXT:=blastrampoline-5
+else
+BLAS_LIB_NAME_NO_EXT:=blastrampoline
+endif
+
 LIBSUITESPARSE_CMAKE_FLAGS := $(CMAKE_COMMON) \
 	  -DCMAKE_BUILD_TYPE=Release \
 	  -DBUILD_STATIC_LIBS=OFF \
 	  -DBUILD_TESTING=OFF \
-	  -DSUITESPARSE_ENABLE_PROJECTS="suitesparse_config;$(LIBSUITESPARSE_PROJECTS)" \
+	  -DSUITESPARSE_ENABLE_PROJECTS=$(LIBSUITESPARSE_PROJECTS) \
 	  -DSUITESPARSE_DEMOS=OFF \
 	  -DSUITESPARSE_USE_STRICT=ON \
 	  -DSUITESPARSE_USE_CUDA=OFF \
@@ -18,13 +24,17 @@ LIBSUITESPARSE_CMAKE_FLAGS := $(CMAKE_COMMON) \
 	  -DSUITESPARSE_USE_OPENMP=OFF \
 	  -DCHOLMOD_PARTITION=ON \
 	  -DBLAS_FOUND=1 \
-	  -DBLAS_LIBRARIES="$(build_shlibdir)/libblastrampoline.$(SHLIB_EXT)" \
-	  -DBLAS_LINKER_FLAGS="blastrampoline" \
-	  -DBLA_VENDOR="blastrampoline" \
-	  -DLAPACK_LIBRARIES="$(build_shlibdir)/libblastrampoline.$(SHLIB_EXT)" \
-	  -DLAPACK_LINKER_FLAGS="blastrampoline" \
-	  -DBLAS64_SUFFIX="_64" \
-	  -DSUITESPARSE_USE_64BIT_BLAS=YES
+	  -DBLAS_LIBRARIES="$(build_shlibdir)/lib$(BLAS_LIB_NAME_NO_EXT).$(SHLIB_EXT)" \
+	  -DBLAS_LINKER_FLAGS="$(BLAS_LIB_NAME_NO_EXT)" \
+	  -DBLA_VENDOR="$(BLAS_LIB_NAME_NO_EXT)" \
+	  -DLAPACK_LIBRARIES="$(build_shlibdir)/lib$(BLAS_LIB_NAME_NO_EXT).$(SHLIB_EXT)" \
+	  -DLAPACK_LINKER_FLAGS="${BLAS_LIB_NAME_NO_EXT}"
+
+ifeq ($(BINARY),64)
+LIBSUITESPARSE_CMAKE_FLAGS += -DBLAS64_SUFFIX="_64" -DSUITESPARSE_USE_64BIT_BLAS=YES
+else
+LIBSUITESPARSE_CMAKE_FLAGS += -DSUITESPARSE_USE_64BIT_BLAS=NO
+endif
 
 ifneq (,$(findstring $(OS),Linux FreeBSD))
 LIBSUITESPARSE_CMAKE_FLAGS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
@@ -42,21 +52,15 @@ $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted: $(SRCCACHE)/Suit
 checksum-libsuitesparse: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER).tar.gz
 	$(JLCHECKSUM) $<
 
-# https://github.com/DrTimothyAldenDavis/SuiteSparse/pull/671
-$(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/suitesparse-blas-suffix.patch-applied: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted
-	cd $(dir $@) && \
-		patch -p1 -f < $(SRCDIR)/patches/suitesparse-blas-suffix.patch
-	echo 1 > $@
-
-$(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-patched: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/suitesparse-blas-suffix.patch-applied
+$(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-patched: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted
 	echo 1 > $@
 
 $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: | $(build_prefix)/manifest/blastrampoline
 
-$(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-patched
-	cd $(dir $<) && $(CMAKE) .. $(LIBSUITESPARSE_CMAKE_FLAGS)
-	make
-	make install
+$(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-patched
+	cd $(dir $<) && $(CMAKE) . $(LIBSUITESPARSE_CMAKE_FLAGS)
+	make -C $(dir $<)
+	make -C $(dir $<) install
 	echo 1 > $@
 
 ifeq ($(OS),WINNT)
diff --git a/deps/patches/suitesparse-blas-suffix.patch b/deps/patches/suitesparse-blas-suffix.patch
deleted file mode 100644
index c6a04ddee618d..0000000000000
--- a/deps/patches/suitesparse-blas-suffix.patch
+++ /dev/null
@@ -1,40 +0,0 @@
-From b936940aab08dc4bc60ccf2b9daec2105a960ad4 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Markus=20M=C3=BCtzel?= <markus.muetzel@gmx.de>
-Date: Mon, 1 Jan 2024 13:00:17 +0100
-Subject: [PATCH] Add preprocessor definitions also with user-supplied
- BLAS_LIBRARIES
-
----
- SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake   | 4 ++--
- SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake | 2 +-
- 2 files changed, 3 insertions(+), 3 deletions(-)
-
-diff --git a/SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake b/SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake
-index ca241472d..be7cd2e73 100644
---- a/SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake
-+++ b/SuiteSparse_config/cmake_modules/SuiteSparseBLAS.cmake
-@@ -36,9 +36,9 @@ if ( DEFINED BLAS_LIBRARIES OR DEFINED BLAS_INCLUDE_DIRS )
-     # User supplied variables for libraries and/or include directories.
-     # Use them as-is.
-     if ( SUITESPARSE_USE_64BIT_BLAS )
--        set ( SuiteSparse_BLAS_integer "int64_t" )
-+        include ( SuiteSparseBLAS64 )
-     else ( )
--        set ( SuiteSparse_BLAS_integer "int32_t" )
-+        include ( SuiteSparseBLAS32 )
-     endif ( )
-     return ( )
- endif ( )
-diff --git a/SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake b/SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake
-index 744aaef91..1a5c63690 100644
---- a/SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake
-+++ b/SuiteSparse_config/cmake_modules/SuiteSparseBLAS64.cmake
-@@ -37,7 +37,7 @@ set ( SuiteSparse_BLAS_integer "int64_t" )
- # https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/suite-sparse/package.py
-
- if ( DEFINED BLAS64_SUFFIX )
--    # append BLAS64_SUFFIX to each BLAS and LAPACK name
-+    # append BLAS64_SUFFIX to each BLAS and LAPACK function name
-     string ( FIND ${BLAS64_SUFFIX} "_" HAS_UNDERSCORE )
-     message ( STATUS "BLAS64_suffix: ${BLAS64_SUFFIX}" )
-     if ( HAS_UNDERSCORE EQUAL -1 )

From d54a4550cbe2892014609c1cc797f129a9ccb1ee Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 2 Feb 2024 12:39:12 +0530
Subject: [PATCH 0787/1315] Hoist boundscheck in vector setindex for arrays
 (#53149)

As noted by @N5N3 in
https://github.com/JuliaLang/julia/issues/40962#issuecomment-1921469633,
the bounds-check on the elementwise `setindex!` prevents vectorization.
Explicitly performing the bounds-check and marking the `setindex!` as
`@inbounds` speeds up the operation.
```julia
julia> A = zeros(1000); B = rand(1000);

julia> @btime $A[1:end] = @view $B[1:end];
  689.940 ns (0 allocations: 0 bytes) # master
  97.629 ns (0 allocations: 0 bytes) # PR
```
---
 base/array.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index dc84a2fcad96c..600ae73d2338e 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -991,13 +991,13 @@ __safe_setindex!(A::Vector{T}, x,    i::Int) where {T} = (@inline;
 function setindex!(A::Array, X::AbstractArray, I::AbstractVector{Int})
     @_propagate_inbounds_meta
     @boundscheck setindex_shape_check(X, length(I))
+    @boundscheck checkbounds(A, I)
     require_one_based_indexing(X)
     X′ = unalias(A, X)
     I′ = unalias(A, I)
     count = 1
     for i in I′
-        @inbounds x = X′[count]
-        A[i] = x
+        @inbounds A[i] = X′[count]
         count += 1
     end
     return A

From f2e168a0a8bbd6be82b4a0dfa205bc8080a48824 Mon Sep 17 00:00:00 2001
From: Alexander Plavin <alexander@plav.in>
Date: Fri, 2 Feb 2024 11:59:15 -0500
Subject: [PATCH 0788/1315] Add filter(f, ::Namedtuple) (#50795)

---
 NEWS.md            | 1 +
 base/namedtuple.jl | 2 ++
 test/namedtuple.jl | 8 ++++++++
 3 files changed, 11 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index 5dd6481a4f0b2..c6b5469143638 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -102,6 +102,7 @@ New library features
   data-races. Or use the callback form of `open` to have all that handled
   automatically.
 * `@timed` now additionally returns the elapsed compilation and recompilation time ([#52889])
+* `filter` can now act on a `NamedTuple` ([#50795]).
 
 Standard library changes
 ------------------------
diff --git a/base/namedtuple.jl b/base/namedtuple.jl
index 170a6e9349917..5131a4f513ff4 100644
--- a/base/namedtuple.jl
+++ b/base/namedtuple.jl
@@ -268,6 +268,8 @@ function map(f, nt::NamedTuple{names}, nts::NamedTuple...) where names
     NamedTuple{names}(map(f, map(Tuple, (nt, nts...))...))
 end
 
+filter(f, xs::NamedTuple) = xs[filter(k -> f(xs[k]), keys(xs))]
+
 function merge_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
     @nospecialize
     @_total_meta
diff --git a/test/namedtuple.jl b/test/namedtuple.jl
index 20737d68db1bb..0d9c6f420ced1 100644
--- a/test/namedtuple.jl
+++ b/test/namedtuple.jl
@@ -134,6 +134,14 @@ end
 @test map(string, (x=1, y=2)) == (x="1", y="2")
 @test map(round, (x=UInt, y=Int), (x=3.1, y=2//3)) == (x=UInt(3), y=1)
 
+@testset "filter" begin
+    @test filter(isodd, (a=1,b=2,c=3)) === (a=1, c=3)
+    @test filter(i -> true, (;)) === (;)
+    longnt = NamedTuple{ntuple(i -> Symbol(:a, i), 20)}(ntuple(identity, 20))
+    @test filter(iseven, longnt) === NamedTuple{ntuple(i -> Symbol(:a, 2i), 10)}(ntuple(i -> 2i, 10))
+    @test filter(x -> x<2, (longnt..., z=1.5)) === (a1=1, z=1.5)
+end
+
 @test merge((a=1, b=2), (a=10,)) == (a=10, b=2)
 @test merge((a=1, b=2), (a=10, z=20)) == (a=10, b=2, z=20)
 @test merge((a=1, b=2), (z=20,)) == (a=1, b=2, z=20)

From 98e4f01d26e5d466aeddacf6ac7107ec42903b31 Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Fri, 2 Feb 2024 22:11:16 +0100
Subject: [PATCH 0789/1315] Fix `size` on `GenericMemory` with non-`Int`
 `Integer` argument (#53161)

I found this through fuzzing. The nature of the issue indicates to me
that this was untested, but coverage doesn't seem to have run for the
past three months so I can't check, which is why I added an explicit
test.

I'm not sure `arrayops.jl` is the best place for tests related to
`GenericMemory`, so feel free to suggest a better one.

Co-authored-by: Sukera <Seelengrab@users.noreply.github.com>
---
 base/genericmemory.jl | 2 +-
 test/arrayops.jl      | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index 9892a94b8dd89..13f54216581df 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -23,7 +23,7 @@ size(a::GenericMemory, d::Int) =
     d < 1 ? error("dimension out of range") :
     d == 1 ? length(a) :
     1
-size(a::GenericMemory, d::Integer) =  size(a, convert(d, Int))
+size(a::GenericMemory, d::Integer) =  size(a, convert(Int, d))
 size(a::GenericMemory) = (length(a),)
 
 IndexStyle(::Type{<:GenericMemory}) = IndexLinear()
diff --git a/test/arrayops.jl b/test/arrayops.jl
index b35e65b0aebad..62df7550e90e5 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -3192,3 +3192,12 @@ end
     @test_throws DimensionMismatch wrap(Array, memref2, 9)
     @test_throws DimensionMismatch wrap(Array, memref2, 10)
 end
+
+@testset "Memory size" begin
+    len = 5
+    mem = Memory{Int}(undef, len)
+    @test size(mem, 1) == len
+    @test size(mem, 0x1) == len
+    @test size(mem, 2) == 1
+    @test size(mem, 0x2) == 1
+end

From 12c5d2dff8d0c34ac4c8a8b10c9a6f467d8f9d46 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 2 Feb 2024 18:48:54 -0500
Subject: [PATCH 0790/1315] Add count of lock conflicts to `@time` etc. Add
 `@lock_conflicts` (#52883)

---
 NEWS.md              |  2 ++
 base/atomics.jl      |  7 ++++
 base/exports.jl      |  1 +
 base/lock.jl         |  1 +
 base/timing.jl       | 82 ++++++++++++++++++++++++++++++++++++++------
 doc/src/base/base.md |  1 +
 test/misc.jl         | 23 ++++++++++---
 7 files changed, 102 insertions(+), 15 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index c6b5469143638..6e7384e730efb 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -30,6 +30,8 @@ New language features
   a `Manifest-v1.11.toml` would be used by v1.11 and `Manifest.toml` by every other julia
   version. This makes managing environments for multiple julia versions at the same time
   easier ([#43845]).
+* `@time` now reports a count of any lock conflicts where a `ReentrantLock` had to wait, plus a new macro
+  `@lock_conflicts` which returns that count ([#52883]).
 
 Language changes
 ----------------
diff --git a/base/atomics.jl b/base/atomics.jl
index 7312206c19896..dde981b8c0e6a 100644
--- a/base/atomics.jl
+++ b/base/atomics.jl
@@ -80,6 +80,13 @@ end
 
 Atomic() = Atomic{Int}()
 
+const LOCK_PROFILING = Atomic{Int}(0)
+lock_profiling(state::Bool) = state ? atomic_add!(LOCK_PROFILING, 1) : atomic_sub!(LOCK_PROFILING, 1)
+lock_profiling() = LOCK_PROFILING[] > 0
+
+const LOCK_CONFLICT_COUNT = Atomic{Int}(0);
+inc_lock_conflict_count() = atomic_add!(LOCK_CONFLICT_COUNT, 1)
+
 """
     Threads.atomic_cas!(x::Atomic{T}, cmp::T, newval::T) where T
 
diff --git a/base/exports.jl b/base/exports.jl
index 92525b85c7635..a9a753d0fda52 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1036,6 +1036,7 @@ export
     @elapsed,
     @allocated,
     @allocations,
+    @lock_conflicts,
 
     # tasks
     @sync,
diff --git a/base/lock.jl b/base/lock.jl
index 73722050699ee..eb76a3b30e6a4 100644
--- a/base/lock.jl
+++ b/base/lock.jl
@@ -145,6 +145,7 @@ Each `lock` must be matched by an [`unlock`](@ref).
 """
 @inline function lock(rl::ReentrantLock)
     trylock(rl) || (@noinline function slowlock(rl::ReentrantLock)
+        Threads.lock_profiling() && Threads.inc_lock_conflict_count()
         c = rl.cond_wait
         lock(c.lock)
         try
diff --git a/base/timing.jl b/base/timing.jl
index 1b93f97c122c1..382a16e61b1e4 100644
--- a/base/timing.jl
+++ b/base/timing.jl
@@ -146,7 +146,8 @@ function format_bytes(bytes; binary=true) # also used by InteractiveUtils
     end
 end
 
-function time_print(io::IO, elapsedtime, bytes=0, gctime=0, allocs=0, compile_time=0, recompile_time=0, newline=false; msg::Union{String,Nothing}=nothing)
+function time_print(io::IO, elapsedtime, bytes=0, gctime=0, allocs=0, lock_conflicts=0, compile_time=0, recompile_time=0, newline=false;
+                    msg::Union{String,Nothing}=nothing)
     timestr = Ryu.writefixed(Float64(elapsedtime/1e9), 6)
     str = sprint() do io
         if msg isa String
@@ -172,6 +173,10 @@ function time_print(io::IO, elapsedtime, bytes=0, gctime=0, allocs=0, compile_ti
             end
             print(io, Ryu.writefixed(Float64(100*gctime/elapsedtime), 2), "% gc time")
         end
+        if lock_conflicts > 0
+            plural = lock_conflicts == 1 ? "" : "s"
+            print(io, ", ", lock_conflicts, " lock conflict$plural")
+        end
         if compile_time > 0
             if bytes != 0 || allocs != 0 || gctime > 0
                 print(io, ", ")
@@ -190,11 +195,11 @@ function time_print(io::IO, elapsedtime, bytes=0, gctime=0, allocs=0, compile_ti
     nothing
 end
 
-function timev_print(elapsedtime, diff::GC_Diff, compile_times; msg::Union{String,Nothing}=nothing)
+function timev_print(elapsedtime, diff::GC_Diff, lock_conflicts, compile_times; msg::Union{String,Nothing}=nothing)
     allocs = gc_alloc_count(diff)
     compile_time = first(compile_times)
     recompile_time = last(compile_times)
-    time_print(stdout, elapsedtime, diff.allocd, diff.total_time, allocs, compile_time, recompile_time, true; msg)
+    time_print(stdout, elapsedtime, diff.allocd, diff.total_time, allocs, lock_conflicts, compile_time, recompile_time, true; msg)
     padded_nonzero_print(elapsedtime,       "elapsed time (ns)")
     padded_nonzero_print(diff.total_time,   "gc time (ns)")
     padded_nonzero_print(diff.allocd,       "bytes allocated")
@@ -226,7 +231,8 @@ end
 A macro to execute an expression, printing the time it took to execute, the number of
 allocations, and the total number of bytes its execution caused to be allocated, before
 returning the value of the expression. Any time spent garbage collecting (gc), compiling
-new code, or recompiling invalidated code is shown as a percentage.
+new code, or recompiling invalidated code is shown as a percentage. Any lock conflicts
+where a [`ReentrantLock`](@ref) had to wait are shown as a count.
 
 Optionally provide a description string to print before the time report.
 
@@ -247,6 +253,9 @@ See also [`@showtime`](@ref), [`@timev`](@ref), [`@timed`](@ref), [`@elapsed`](@
 
     Recompilation time being shown separately from compilation time was introduced in Julia 1.8
 
+!!! compat "Julia 1.11"
+    The reporting of any lock conflicts was added in Julia 1.11.
+
 ```julia-repl
 julia> x = rand(10,10);
 
@@ -283,7 +292,7 @@ macro time(msg, ex)
     quote
         local ret = @timed $(esc(ex))
         local _msg = $(esc(msg))
-        time_print(stdout, ret.time*1e9, ret.gcstats.allocd, ret.gcstats.total_time, gc_alloc_count(ret.gcstats), ret.compile_time*1e9, ret.recompile_time*1e9, true; msg=_msg)
+        time_print(stdout, ret.time*1e9, ret.gcstats.allocd, ret.gcstats.total_time, gc_alloc_count(ret.gcstats), ret.lock_conflicts, ret.compile_time*1e9, ret.recompile_time*1e9, true; msg=_msg)
         ret.value
     end
 end
@@ -355,7 +364,7 @@ macro timev(msg, ex)
     quote
         local ret = @timed $(esc(ex))
         local _msg = $(esc(msg))
-        timev_print(ret.time*1e9, ret.gcstats, (ret.compile_time*1e9, ret.recompile_time*1e9); msg=_msg)
+        timev_print(ret.time*1e9, ret.gcstats, ret.lock_conflicts, (ret.compile_time*1e9, ret.recompile_time*1e9); msg=_msg)
         ret.value
     end
 end
@@ -449,19 +458,57 @@ macro allocations(ex)
     end
 end
 
+"""
+    @lock_conflicts
+
+A macro to evaluate an expression, discard the resulting value, and instead return the
+total number of lock conflicts during evaluation, where a lock attempt on a [`ReentrantLock`](@ref)
+resulted in a wait because the lock was already held.
+
+See also [`@time`](@ref), [`@timev`](@ref) and [`@timed`](@ref).
+
+```julia-repl
+julia> @lock_conflicts begin
+    l = ReentrantLock()
+    Threads.@threads for i in 1:Threads.nthreads()
+        lock(l) do
+        sleep(1)
+        end
+    end
+end
+5
+```
+
+!!! compat "Julia 1.11"
+    This macro was added in Julia 1.11.
+"""
+macro lock_conflicts(ex)
+    quote
+        Threads.lock_profiling(true)
+        local lock_conflicts = Threads.LOCK_CONFLICT_COUNT[]
+        try
+            $(esc(ex))
+        finally
+            Threads.lock_profiling(false)
+        end
+        Threads.LOCK_CONFLICT_COUNT[] - lock_conflicts
+    end
+end
+
 """
     @timed
 
 A macro to execute an expression, and return the value of the expression, elapsed time in seconds,
 total bytes allocated, garbage collection time, an object with various memory allocation
-counters, compilation time in seconds, and recompilation time in seconds.
+counters, compilation time in seconds, and recompilation time in seconds. Any lock conflicts
+where a [`ReentrantLock`](@ref) had to wait are shown as a count.
 
 In some cases the system will look inside the `@timed` expression and compile some of the
 called code before execution of the top-level expression begins. When that happens, some
 compilation time will not be counted. To include this time you can run `@timed @eval ...`.
 
 See also [`@time`](@ref), [`@timev`](@ref), [`@elapsed`](@ref),
-[`@allocated`](@ref), and [`@allocations`](@ref).
+[`@allocated`](@ref), [`@allocations`](@ref), and [`@lock_conflicts`](@ref).
 
 ```julia-repl
 julia> stats = @timed rand(10^6);
@@ -493,11 +540,13 @@ julia> stats.recompile_time
     The return type of this macro was changed from `Tuple` to `NamedTuple` in Julia 1.5.
 
 !!! compat "Julia 1.11"
-    The `compile_time` and `recompile_time` fields were added in Julia 1.11.
+    The `lock_conflicts`, `compile_time`, and `recompile_time` fields were added in Julia 1.11.
 """
 macro timed(ex)
     quote
         Experimental.@force_compile
+        Threads.lock_profiling(true)
+        local lock_conflicts = Threads.LOCK_CONFLICT_COUNT[]
         local stats = gc_num()
         local elapsedtime = time_ns()
         cumulative_compile_timing(true)
@@ -505,9 +554,20 @@ macro timed(ex)
         local val = @__tryfinally($(esc(ex)),
             (elapsedtime = time_ns() - elapsedtime;
             cumulative_compile_timing(false);
-            compile_elapsedtimes = cumulative_compile_time_ns() .- compile_elapsedtimes)
+            compile_elapsedtimes = cumulative_compile_time_ns() .- compile_elapsedtimes;
+            lock_conflicts = Threads.LOCK_CONFLICT_COUNT[] - lock_conflicts;
+            Threads.lock_profiling(false))
         )
         local diff = GC_Diff(gc_num(), stats)
-        (value=val, time=elapsedtime/1e9, bytes=diff.allocd, gctime=diff.total_time/1e9, gcstats=diff, compile_time=compile_elapsedtimes[1]/1e9, recompile_time=compile_elapsedtimes[2]/1e9)
+        (
+            value=val,
+            time=elapsedtime/1e9,
+            bytes=diff.allocd,
+            gctime=diff.total_time/1e9,
+            gcstats=diff,
+            lock_conflicts=lock_conflicts,
+            compile_time=compile_elapsedtimes[1]/1e9,
+            recompile_time=compile_elapsedtimes[2]/1e9
+        )
     end
 end
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index ee9cede4e6455..0d1692b0ed581 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -352,6 +352,7 @@ Base.@timed
 Base.@elapsed
 Base.@allocated
 Base.@allocations
+Base.@lock_conflicts
 Base.EnvDict
 Base.ENV
 Base.Sys.STDLIB
diff --git a/test/misc.jl b/test/misc.jl
index 11410a497a4f5..e0961c538921a 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1392,10 +1392,25 @@ end
 @testset "Base/timing.jl" begin
     @test Base.jit_total_bytes() >= 0
 
-    # sanity check `@allocations` returns what we expect in some very simple cases
-    @test (@allocations "a") == 0
-    @test (@allocations "a" * "b") == 0 # constant propagation
-    @test (@allocations "a" * Base.inferencebarrier("b")) == 1
+    # sanity check `@allocations` returns what we expect in some very simple cases.
+    # These are inside functions because `@allocations` uses `Experimental.@force_compile`
+    # so can be affected by other code in the same scope.
+    @test (() -> @allocations "a")() == 0
+    @test (() -> @allocations "a" * "b")() == 0 # constant propagation
+    @test (() -> @allocations "a" * Base.inferencebarrier("b"))() == 1
+
+    _lock_conflicts, _nthreads = eval(Meta.parse(read(`$(Base.julia_cmd()) -tauto -E '
+        _lock_conflicts = @lock_conflicts begin
+            l = ReentrantLock()
+            Threads.@threads for i in 1:Threads.nthreads()
+                 lock(l) do
+                    sleep(1)
+                end
+            end
+        end
+        _lock_conflicts,Threads.nthreads()
+    '`, String)))
+    @test _lock_conflicts > 0 skip=(_nthreads < 2) # can only test if the worker can multithread
 end
 
 #TODO: merge with `@testset "Base/timing.jl"` once https://github.com/JuliaLang/julia/issues/52948 is resolved

From fda9321d6dca28ed0fc2815853c9371d11a80009 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateus=20Ara=C3=BAjo?= <maltusan@gmail.com>
Date: Sat, 3 Feb 2024 02:07:49 +0100
Subject: [PATCH 0791/1315] stdlib: make dot product of Hermitian matrices real
 (#52318)

Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 stdlib/LinearAlgebra/src/symmetric.jl | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 38035e09b4375..d0066ddecbfe0 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -461,17 +461,17 @@ for (T, trans, real) in [(:Symmetric, :transpose, :identity), (:(Hermitian{<:Uni
                 throw(DimensionMismatch("A has dimensions $(size(A)) but B has dimensions $(size(B))"))
             end
 
-            dotprod = zero(dot(first(A), first(B)))
+            dotprod = $real(zero(dot(first(A), first(B))))
             @inbounds if A.uplo == 'U' && B.uplo == 'U'
                 for j in 1:n
                     for i in 1:(j - 1)
                         dotprod += 2 * $real(dot(A.data[i, j], B.data[i, j]))
                     end
-                    dotprod += dot(A[j, j], B[j, j])
+                    dotprod += $real(dot(A[j, j], B[j, j]))
                 end
             elseif A.uplo == 'L' && B.uplo == 'L'
                 for j in 1:n
-                    dotprod += dot(A[j, j], B[j, j])
+                    dotprod += $real(dot(A[j, j], B[j, j]))
                     for i in (j + 1):n
                         dotprod += 2 * $real(dot(A.data[i, j], B.data[i, j]))
                     end
@@ -481,11 +481,11 @@ for (T, trans, real) in [(:Symmetric, :transpose, :identity), (:(Hermitian{<:Uni
                     for i in 1:(j - 1)
                         dotprod += 2 * $real(dot(A.data[i, j], $trans(B.data[j, i])))
                     end
-                    dotprod += dot(A[j, j], B[j, j])
+                    dotprod += $real(dot(A[j, j], B[j, j]))
                 end
             else
                 for j in 1:n
-                    dotprod += dot(A[j, j], B[j, j])
+                    dotprod += $real(dot(A[j, j], B[j, j]))
                     for i in (j + 1):n
                         dotprod += 2 * $real(dot(A.data[i, j], $trans(B.data[j, i])))
                     end

From fc062919c3f474b365ebfd153fc16e0cfc9536fa Mon Sep 17 00:00:00 2001
From: apaz <aarpazdera@gmail.com>
Date: Fri, 2 Feb 2024 20:49:59 -0600
Subject: [PATCH 0792/1315] Improve error message for `which(fn, types)`
 (#47369)

Error messages for `MethodError` are much more helpful in determining
why the method was not successfully dispatched than simply "No unique
matching method found."

Fixes #47322
---
 base/errorshow.jl                | 81 ++++++++++++++++----------------
 base/experimental.jl             |  1 +
 base/namedtuple.jl               |  1 +
 base/reflection.jl               | 12 ++++-
 doc/src/manual/constructors.md   |  4 ++
 doc/src/manual/faq.md            |  1 +
 doc/src/manual/functions.md      |  1 +
 doc/src/manual/methods.md        | 12 +++++
 doc/src/manual/types.md          |  7 ++-
 stdlib/Test/docs/src/index.md    |  2 +
 test/ambiguous.jl                |  2 +-
 test/embedding/embedding-test.jl |  1 +
 test/error.jl                    |  6 ++-
 test/errorshow.jl                |  7 ++-
 test/missing.jl                  |  5 +-
 15 files changed, 94 insertions(+), 49 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index c10d1e25e6e7e..d7cacb66eb76d 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -246,14 +246,15 @@ end
 function showerror(io::IO, ex::MethodError)
     # ex.args is a tuple type if it was thrown from `invoke` and is
     # a tuple of the arguments otherwise.
-    is_arg_types = isa(ex.args, DataType)
-    arg_types = (is_arg_types ? ex.args : typesof(ex.args...))::DataType
+    is_arg_types = !isa(ex.args, Tuple)
+    arg_types = is_arg_types ? ex.args : typesof(ex.args...)
+    arg_types_param::SimpleVector = (unwrap_unionall(arg_types)::DataType).parameters
+    san_arg_types_param = Any[rewrap_unionall(a, arg_types) for a in arg_types_param]
     f = ex.f
     meth = methods_including_ambiguous(f, arg_types)
     if isa(meth, MethodList) && length(meth) > 1
         return showerror_ambiguous(io, meth, f, arg_types)
     end
-    arg_types_param::SimpleVector = arg_types.parameters
     print(io, "MethodError: ")
     ft = typeof(f)
     f_is_function = false
@@ -262,10 +263,11 @@ function showerror(io::IO, ex::MethodError)
         f = (ex.args::Tuple)[2]
         ft = typeof(f)
         arg_types_param = arg_types_param[3:end]
+        san_arg_types_param = san_arg_types_param[3:end]
         kwargs = pairs(ex.args[1])
         ex = MethodError(f, ex.args[3:end::Int], ex.world)
+        arg_types = Tuple{arg_types_param...}
     end
-    name = ft.name.mt.name
     if f === Base.convert && length(arg_types_param) == 2 && !is_arg_types
         f_is_function = true
         show_convert_error(io, ex, arg_types_param)
@@ -277,36 +279,28 @@ function showerror(io::IO, ex::MethodError)
         if ft <: Function && isempty(ft.parameters) && _isself(ft)
             f_is_function = true
         end
-        print(io, "no method matching ")
+        if is_arg_types
+            print(io, "no method matching invoke ")
+        else
+            print(io, "no method matching ")
+        end
         buf = IOBuffer()
         iob = IOContext(buf, io)     # for type abbreviation as in #49795; some, like `convert(T, x)`, should not abbreviate
         show_signature_function(iob, isa(f, Type) ? Type{f} : typeof(f))
-        print(iob, "(")
-        for (i, typ) in enumerate(arg_types_param)
-            print(iob, "::", typ)
-            i == length(arg_types_param) || print(iob, ", ")
-        end
-        if !isempty(kwargs)
-            print(iob, "; ")
-            for (i, (k, v)) in enumerate(kwargs)
-                print(iob, k, "::", typeof(v))
-                i == length(kwargs)::Int || print(iob, ", ")
-            end
-        end
-        print(iob, ")")
+        show_tuple_as_call(iob, :function, arg_types; hasfirst=false, kwargs = !isempty(kwargs) ? Any[(k, typeof(v)) for (k, v) in kwargs] : nothing)
         str = String(take!(buf))
         str = type_limited_string_from_context(io, str)
         print(io, str)
     end
     # catch the two common cases of element-wise addition and subtraction
-    if (f === Base.:+ || f === Base.:-) && length(arg_types_param) == 2
+    if (f === Base.:+ || f === Base.:-) && length(san_arg_types_param) == 2
         # we need one array of numbers and one number, in any order
-        if any(x -> x <: AbstractArray{<:Number}, arg_types_param) &&
-            any(x -> x <: Number, arg_types_param)
+        if any(x -> x <: AbstractArray{<:Number}, san_arg_types_param) &&
+            any(x -> x <: Number, san_arg_types_param)
 
             nounf = f === Base.:+ ? "addition" : "subtraction"
             varnames = ("scalar", "array")
-            first, second = arg_types_param[1] <: Number ? varnames : reverse(varnames)
+            first, second = san_arg_types_param[1] <: Number ? varnames : reverse(varnames)
             fstring = f === Base.:+ ? "+" : "-"  # avoid depending on show_default for functions (invalidation)
             print(io, "\nFor element-wise $nounf, use broadcasting with dot syntax: $first .$fstring $second")
         end
@@ -315,17 +309,25 @@ function showerror(io::IO, ex::MethodError)
         print(io, "\nUse square brackets [] for indexing an Array.")
     end
     # Check for local functions that shadow methods in Base
-    if f_is_function && isdefined(Base, name)
-        basef = getfield(Base, name)
-        if basef !== ex.f && hasmethod(basef, arg_types)
-            print(io, "\nYou may have intended to import ")
-            show_unquoted(io, Expr(:., :Base, QuoteNode(name)))
+    let name = ft.name.mt.name
+        if f_is_function && isdefined(Base, name)
+            basef = getfield(Base, name)
+            if basef !== f && hasmethod(basef, arg_types)
+                print(io, "\nYou may have intended to import ")
+                show_unquoted(io, Expr(:., :Base, QuoteNode(name)))
+            end
         end
     end
-    if (ex.world != typemax(UInt) && hasmethod(ex.f, arg_types) &&
-        !hasmethod(ex.f, arg_types, world = ex.world))
+    if (ex.world != typemax(UInt) && hasmethod(f, arg_types) &&
+        !hasmethod(f, arg_types, world = ex.world))
         curworld = get_world_counter()
         print(io, "\nThe applicable method may be too new: running in world age $(ex.world), while current world is $(curworld).")
+    elseif f isa Function
+        print(io, "\nThe function `$f` exists, but no method is defined for this combination of argument types.")
+    elseif f isa Type
+        print(io, "\nThe type `$f` exists, but no method is defined for this combination of argument types when trying to construct it.")
+    else
+        print(io, "\nThe object of type `$(typeof(f))` exists, but no method is defined for this combination of argument types when trying to treat it as a callable object.")
     end
     if !is_arg_types
         # Check for row vectors used where a column vector is intended.
@@ -342,7 +344,7 @@ function showerror(io::IO, ex::MethodError)
                       "\nYou can convert to a column vector with the vec() function.")
         end
     end
-    Experimental.show_error_hints(io, ex, arg_types_param, kwargs)
+    Experimental.show_error_hints(io, ex, san_arg_types_param, kwargs)
     try
         show_method_candidates(io, ex, kwargs)
     catch ex
@@ -354,16 +356,12 @@ end
 striptype(::Type{T}) where {T} = T
 striptype(::Any) = nothing
 
-function showerror_ambiguous(io::IO, meths, f, args)
+function showerror_ambiguous(io::IO, meths, f, args::Type)
+    @nospecialize f args
     print(io, "MethodError: ")
     show_signature_function(io, isa(f, Type) ? Type{f} : typeof(f))
-    print(io, "(")
-    p = args.parameters
-    for (i,a) in enumerate(p)
-        print(io, "::", a)
-        i < length(p) && print(io, ", ")
-    end
-    println(io, ") is ambiguous.\n\nCandidates:")
+    show_tuple_as_call(io, :var"", args, hasfirst=false)
+    println(io, " is ambiguous.\n\nCandidates:")
     sigfix = Any
     for m in meths
         print(io, "  ")
@@ -375,7 +373,7 @@ function showerror_ambiguous(io::IO, meths, f, args)
         let sigfix=sigfix
             if all(m->morespecific(sigfix, m.sig), meths)
                 print(io, "\nPossible fix, define\n  ")
-                Base.show_tuple_as_call(io, :function,  sigfix)
+                show_tuple_as_call(io, :function,  sigfix)
             else
                 print(io, "To resolve the ambiguity, try making one of the methods more specific, or ")
                 print(io, "adding a new method more specific than any of the existing applicable methods.")
@@ -401,9 +399,10 @@ stacktrace_contract_userdir()::Bool = Base.get_bool_env("JULIA_STACKTRACE_CONTRA
 stacktrace_linebreaks()::Bool = Base.get_bool_env("JULIA_STACKTRACE_LINEBREAKS", false) === true
 
 function show_method_candidates(io::IO, ex::MethodError, @nospecialize kwargs=())
-    is_arg_types = isa(ex.args, DataType)
+    is_arg_types = !isa(ex.args, Tuple)
     arg_types = is_arg_types ? ex.args : typesof(ex.args...)
-    arg_types_param = Any[arg_types.parameters...]
+    arg_types_param = Any[(unwrap_unionall(arg_types)::DataType).parameters...]
+    arg_types_param = Any[rewrap_unionall(a, arg_types) for a in arg_types_param]
     # Displays the closest candidates of the given function by looping over the
     # functions methods and counting the number of matching arguments.
     f = ex.f
diff --git a/base/experimental.jl b/base/experimental.jl
index ccc041b41ec05..c599d973b0a76 100644
--- a/base/experimental.jl
+++ b/base/experimental.jl
@@ -280,6 +280,7 @@ Then if you call `Hinter.only_int` on something that isn't an `Int` (thereby tri
 ```
 julia> Hinter.only_int(1.0)
 ERROR: MethodError: no method matching only_int(::Float64)
+The function `only_int` exists, but no method is defined for this combination of argument types.
 Did you mean to call `any_number`?
 Closest candidates are:
     ...
diff --git a/base/namedtuple.jl b/base/namedtuple.jl
index 5131a4f513ff4..cc82edf3d3e3a 100644
--- a/base/namedtuple.jl
+++ b/base/namedtuple.jl
@@ -526,6 +526,7 @@ Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}
 
 julia> sum("julia"; init=1)
 ERROR: MethodError: no method matching +(::Char, ::Char)
+The function `+` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   +(::Any, ::Any, ::Any, ::Any...)
diff --git a/base/reflection.jl b/base/reflection.jl
index 31e9d6de3a70c..7ab330de2b9d0 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -2192,7 +2192,17 @@ See also: [`parentmodule`](@ref), [`@which`](@ref Main.InteractiveUtils.@which),
 """
 function which(@nospecialize(f), @nospecialize(t))
     tt = signature_type(f, t)
-    return which(tt)
+    world = get_world_counter()
+    match, _ = Core.Compiler._findsup(tt, nothing, world)
+    if match === nothing
+        me = MethodError(f, t, world)
+        ee = ErrorException(sprint(io -> begin
+            println(io, "Calling invoke(f, t, args...) would throw:");
+            Base.showerror(io, me);
+        end))
+        throw(ee)
+    end
+    return match.method
 end
 
 """
diff --git a/doc/src/manual/constructors.md b/doc/src/manual/constructors.md
index 27e2c9396c437..2cfa6e25503d2 100644
--- a/doc/src/manual/constructors.md
+++ b/doc/src/manual/constructors.md
@@ -293,6 +293,8 @@ Point{Float64}(1.0, 2.5)
 
 julia> Point(1,2.5) ## implicit T ##
 ERROR: MethodError: no method matching Point(::Int64, ::Float64)
+The type `Point` exists, but no method is defined for this combination of argument types when trying to construct it.
+
 Closest candidates are:
   Point(::T, ::T) where T<:Real at none:2
 
@@ -372,6 +374,7 @@ However, other similar calls still don't work:
 ```jldoctest parametric2
 julia> Point(1.5,2)
 ERROR: MethodError: no method matching Point(::Float64, ::Int64)
+The type `Point` exists, but no method is defined for this combination of argument types when trying to construct it.
 
 Closest candidates are:
   Point(::T, !Matched::T) where T<:Real
@@ -556,6 +559,7 @@ julia> struct SummedArray{T<:Number,S<:Number}
 
 julia> SummedArray(Int32[1; 2; 3], Int32(6))
 ERROR: MethodError: no method matching SummedArray(::Vector{Int32}, ::Int32)
+The type `SummedArray` exists, but no method is defined for this combination of argument types when trying to construct it.
 
 Closest candidates are:
   SummedArray(::Vector{T}) where T
diff --git a/doc/src/manual/faq.md b/doc/src/manual/faq.md
index ccea44f922a8e..c7f2325410a37 100644
--- a/doc/src/manual/faq.md
+++ b/doc/src/manual/faq.md
@@ -804,6 +804,7 @@ foo (generic function with 1 method)
 
 julia> foo([1])
 ERROR: MethodError: no method matching foo(::Vector{Int64})
+The function `foo` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   foo(!Matched::Vector{Real})
diff --git a/doc/src/manual/functions.md b/doc/src/manual/functions.md
index 6f065c11c9dcd..58d093d200bc9 100644
--- a/doc/src/manual/functions.md
+++ b/doc/src/manual/functions.md
@@ -730,6 +730,7 @@ julia> args = [1, 2, 3]
 
 julia> baz(args...)
 ERROR: MethodError: no method matching baz(::Int64, ::Int64, ::Int64)
+The function `baz` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   baz(::Any, ::Any)
diff --git a/doc/src/manual/methods.md b/doc/src/manual/methods.md
index ee68ee265ff95..4745ae886e8d0 100644
--- a/doc/src/manual/methods.md
+++ b/doc/src/manual/methods.md
@@ -76,6 +76,7 @@ Applying it to any other types of arguments will result in a [`MethodError`](@re
 ```jldoctest fofxy
 julia> f(2.0, 3)
 ERROR: MethodError: no method matching f(::Float64, ::Int64)
+The function `f` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   f(::Float64, !Matched::Float64)
@@ -86,6 +87,7 @@ Stacktrace:
 
 julia> f(Float32(2.0), 3.0)
 ERROR: MethodError: no method matching f(::Float32, ::Float64)
+The function `f` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   f(!Matched::Float64, ::Float64)
@@ -96,6 +98,7 @@ Stacktrace:
 
 julia> f(2.0, "3.0")
 ERROR: MethodError: no method matching f(::Float64, ::String)
+The function `f` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   f(::Float64, !Matched::Float64)
@@ -106,6 +109,7 @@ Stacktrace:
 
 julia> f("2.0", "3.0")
 ERROR: MethodError: no method matching f(::String, ::String)
+The function `f` exists, but no method is defined for this combination of argument types.
 ```
 
 As you can see, the arguments must be precisely of type [`Float64`](@ref). Other numeric
@@ -164,6 +168,7 @@ and applying it will still result in a [`MethodError`](@ref):
 ```jldoctest fofxy
 julia> f("foo", 3)
 ERROR: MethodError: no method matching f(::String, ::Int64)
+The function `f` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   f(!Matched::Number, ::Number)
@@ -174,6 +179,7 @@ Stacktrace:
 
 julia> f()
 ERROR: MethodError: no method matching f()
+The function `f` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   f(!Matched::Float64, !Matched::Float64)
@@ -432,6 +438,7 @@ julia> myappend([1,2,3],4)
 
 julia> myappend([1,2,3],2.5)
 ERROR: MethodError: no method matching myappend(::Vector{Int64}, ::Float64)
+The function `myappend` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   myappend(::Vector{T}, !Matched::T) where T
@@ -449,6 +456,7 @@ julia> myappend([1.0,2.0,3.0],4.0)
 
 julia> myappend([1.0,2.0,3.0],4)
 ERROR: MethodError: no method matching myappend(::Vector{Float64}, ::Int64)
+The function `myappend` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   myappend(::Vector{T}, !Matched::T) where T
@@ -494,6 +502,7 @@ true
 
 julia> same_type_numeric("foo", 2.0)
 ERROR: MethodError: no method matching same_type_numeric(::String, ::Float64)
+The function `same_type_numeric` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   same_type_numeric(!Matched::T, ::T) where T<:Number
@@ -506,6 +515,7 @@ Stacktrace:
 
 julia> same_type_numeric("foo", "bar")
 ERROR: MethodError: no method matching same_type_numeric(::String, ::String)
+The function `same_type_numeric` exists, but no method is defined for this combination of argument types.
 
 julia> same_type_numeric(Int32(1), Int64(2))
 false
@@ -888,6 +898,7 @@ bar (generic function with 1 method)
 
 julia> bar(1,2,3)
 ERROR: MethodError: no method matching bar(::Int64, ::Int64, ::Int64)
+The function `bar` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   bar(::Any, ::Any, ::Any, !Matched::Any)
@@ -901,6 +912,7 @@ julia> bar(1,2,3,4)
 
 julia> bar(1,2,3,4,5)
 ERROR: MethodError: no method matching bar(::Int64, ::Int64, ::Int64, ::Int64, ::Int64)
+The function `bar` exists, but no method is defined for this combination of argument types.
 
 Closest candidates are:
   bar(::Any, ::Any, ::Any, ::Any)
diff --git a/doc/src/manual/types.md b/doc/src/manual/types.md
index f3ce600091aca..0d7b2795401f1 100644
--- a/doc/src/manual/types.md
+++ b/doc/src/manual/types.md
@@ -713,10 +713,12 @@ For the default constructor, exactly one argument must be supplied for each fiel
 ```jldoctest pointtype
 julia> Point{Float64}(1.0)
 ERROR: MethodError: no method matching Point{Float64}(::Float64)
+The type `Point{Float64}` exists, but no method is defined for this combination of argument types when trying to construct it.
 [...]
 
-julia> Point{Float64}(1.0,2.0,3.0)
+julia> Point{Float64}(1.0, 2.0, 3.0)
 ERROR: MethodError: no method matching Point{Float64}(::Float64, ::Float64, ::Float64)
+The type `Point{Float64}` exists, but no method is defined for this combination of argument types when trying to construct it.
 [...]
 ```
 
@@ -748,6 +750,7 @@ to `Point` have the same type. When this isn't the case, the constructor will fa
 ```jldoctest pointtype
 julia> Point(1,2.5)
 ERROR: MethodError: no method matching Point(::Int64, ::Float64)
+The type `Point` exists, but no method is defined for this combination of argument types when trying to construct it.
 
 Closest candidates are:
   Point(::T, !Matched::T) where T
@@ -1413,6 +1416,8 @@ is raised:
 ```jldoctest; filter = r"Closest candidates.*"s
 julia> supertype(Union{Float64,Int64})
 ERROR: MethodError: no method matching supertype(::Type{Union{Float64, Int64}})
+The function `supertype` exists, but no method is defined for this combination of argument types.
+
 Closest candidates are:
 [...]
 ```
diff --git a/stdlib/Test/docs/src/index.md b/stdlib/Test/docs/src/index.md
index dc3e56bb8bb59..3241ff13ca029 100644
--- a/stdlib/Test/docs/src/index.md
+++ b/stdlib/Test/docs/src/index.md
@@ -73,6 +73,8 @@ Error During Test
   Test threw an exception of type MethodError
   Expression: foo(:cat) == 1
   MethodError: no method matching length(::Symbol)
+  The function `length` exists, but no method is defined for this combination of argument types.
+
   Closest candidates are:
     length(::SimpleVector) at essentials.jl:256
     length(::Base.MethodList) at reflection.jl:521
diff --git a/test/ambiguous.jl b/test/ambiguous.jl
index bbbe509439083..ac5b524931046 100644
--- a/test/ambiguous.jl
+++ b/test/ambiguous.jl
@@ -75,7 +75,7 @@ let io = IOBuffer()
     cf = @eval @cfunction(ambig, Int, (UInt8, Int))  # test for a crash (doesn't throw an error)
     @test_throws(MethodError(ambig, (UInt8(1), Int(2)), get_world_counter()),
                  ccall(cf, Int, (UInt8, Int), 1, 2))
-    @test_throws(ErrorException("no unique matching method found for the specified argument types"),
+    @test_throws("Calling invoke(f, t, args...) would throw:\nMethodError: no method matching ambig",
                  which(ambig, (UInt8, Int)))
     @test length(code_typed(ambig, (UInt8, Int))) == 0
 end
diff --git a/test/embedding/embedding-test.jl b/test/embedding/embedding-test.jl
index c10cc6a16fee8..34ef9a796ba56 100644
--- a/test/embedding/embedding-test.jl
+++ b/test/embedding/embedding-test.jl
@@ -21,6 +21,7 @@ end
     close(err.in)
     out_task = @async readlines(out)
     @test readline(err) == "MethodError: no method matching this_function_has_no_methods()"
+    @test readline(err) == "The function `this_function_has_no_methods` exists, but no method is defined for this combination of argument types."
     @test success(p)
     lines = fetch(out_task)
     @test length(lines) == 11
diff --git a/test/error.jl b/test/error.jl
index e9cdfa100bc81..8cd9a07f6655e 100644
--- a/test/error.jl
+++ b/test/error.jl
@@ -96,7 +96,11 @@ end
         f44319(1)
     catch e
         s = sprint(showerror, e)
-        @test s == "MethodError: no method matching f44319(::Int$(Sys.WORD_SIZE))\n\nClosest candidates are:\n  f44319()\n   @ $curmod_str none:0\n"
+        @test s == """MethodError: no method matching f44319(::Int$(Sys.WORD_SIZE))
+                      The function `f44319` exists, but no method is defined for this combination of argument types.
+
+                      Closest candidates are:\n  f44319()\n   @ $curmod_str none:0
+                      """
     end
 end
 
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 89bab3be96a6b..5c5b4e3ac45f8 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -590,7 +590,8 @@ let
 
     # Test that it shows a special message when no constructors have been defined by the user.
     @test sprint(showerror, method_error) ==
-        "MethodError: no constructors have been defined for $(EnclosingModule.AbstractTypeNoConstructors)"
+        """MethodError: no constructors have been defined for $(EnclosingModule.AbstractTypeNoConstructors)
+           The type `$(EnclosingModule.AbstractTypeNoConstructors)` exists, but no method is defined for this combination of argument types when trying to construct it."""
 
     # Does it go back to previous behaviour when there *is* at least
     # one constructor defined?
@@ -1118,3 +1119,7 @@ end
 # error message hint from PR #22647
 @test_throws "Many shells" cd("~")
 @test occursin("Many shells", sprint(showerror, Base.IOError("~", Base.UV_ENOENT)))
+
+# issue #47559"
+@test_throws("MethodError: no method matching invoke Returns(::Any, ::Val{N}) where N",
+             invoke(Returns, Tuple{Any,Val{N}} where N, 1, Val(1)))
diff --git a/test/missing.jl b/test/missing.jl
index 342ed5a8b8971..f588b2dabe904 100644
--- a/test/missing.jl
+++ b/test/missing.jl
@@ -596,7 +596,7 @@ end
     @test @coalesce(missing) === missing
 
     @test @coalesce(1, error("failed")) === 1
-    @test_throws ErrorException @coalesce(missing, error("failed"))
+    @test_throws ErrorException("failed") @coalesce(missing, error("failed"))
 end
 
 mutable struct Obj; x; end
@@ -615,8 +615,7 @@ mutable struct Obj; x; end
 end
 
 @testset "showerror missing function" begin
-    me = try missing(1) catch e e end
-    @test sprint(showerror, me) == "MethodError: objects of type Missing are not callable"
+    @test_throws "MethodError: objects of type Missing are not callable" missing(1)
 end
 
 @testset "sort and sortperm with $(eltype(X))" for (X, P, RP) in

From 6f7cfa7dbba7406b292008ffa6b77a39e9887109 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Sat, 3 Feb 2024 23:12:52 +0800
Subject: [PATCH 0793/1315] Collect test results into BuildKit-compatible JSON
 (#53145)

---
 .gitignore                |   3 +
 test/buildkitetestjson.jl | 142 ++++++++++++++++++++++++++++++++++++++
 test/runtests.jl          |   7 ++
 3 files changed, 152 insertions(+)
 create mode 100644 test/buildkitetestjson.jl

diff --git a/.gitignore b/.gitignore
index f0072fec9c91e..524a12d066c4d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,6 +39,9 @@
 # Buildkite: Ignore the entire .buildkite directory
 /.buildkite
 
+# Builtkite: json test data
+/test/results.json
+
 # Buildkite: Ignore the unencrypted repo_key
 repo_key
 
diff --git a/test/buildkitetestjson.jl b/test/buildkitetestjson.jl
new file mode 100644
index 0000000000000..fc6d5859a7ca1
--- /dev/null
+++ b/test/buildkitetestjson.jl
@@ -0,0 +1,142 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+# Convert test(set) results to a Buildkit-compatible JSON representation.
+# Based on <https://buildkite.com/docs/test-analytics/importing-json#json-test-results-data-reference>.
+
+module BuildKiteTestJSON
+
+using Test
+using Dates
+
+export write_testset_json
+
+# Bootleg JSON writer
+
+"""
+    json_repr(io::IO, value; kwargs...) -> Nothing
+
+Obtain a JSON representation of `value`, and print it to `io`.
+
+This may not be the best, most feature-complete, or fastest implementation.
+However, it works for its intended purpose.
+"""
+function json_repr end
+
+function json_repr(io::IO, val::String; indent::Int=0)
+    print(io, '"')
+    escape_string(io, val, ('"',))
+    print(io, '"')
+end
+json_repr(io::IO, val::Integer; indent::Int=0) = print(io, val)
+json_repr(io::IO, val::Float64; indent::Int=0) = print(io, val)
+function json_repr(io::IO, val::Vector; indent::Int=0)
+    print(io, '[')
+    for elt in val
+        print(io, '\n', ' '^(indent + 2))
+        json_repr(io, elt; indent=indent+2)
+        elt === last(val) || print(io, ',')
+    end
+    print(io, '\n', ' '^indent, ']')
+end
+function json_repr(io::IO, val::Dict; indent::Int=0)
+    print(io, '{')
+    for (i, (k, v)) in enumerate(pairs(val))
+        print(io, '\n', ' '^(indent + 2))
+        json_repr(io, string(k))
+        print(io, ": ")
+        json_repr(io, v; indent=indent+2)
+        i === length(val) || print(io, ',')
+    end
+    print(io, '\n', ' '^indent, '}')
+end
+json_repr(io::IO, val::Any; indent::Int=0) = json_repr(io, string(val))
+
+# Test result processing
+
+function result_dict(testset::Test.DefaultTestSet, prefix::String="")
+    Dict{String, Any}(
+        "id" => Base.UUID(rand(UInt128)),
+        "scope" => join((prefix, testset.description), '/'),
+        "history" => if !isnothing(testset.time_end)
+            Dict{String, Any}(
+                "start_at" => testset.time_start,
+                "end_at" => testset.time_end,
+                "duration" => testset.time_end - testset.time_start)
+        else
+            Dict{String, Any}("start_at" => testset.time_start, "duration" => 0.0)
+        end)
+end
+
+function result_dict(result::Test.Result)
+    file, line = if !hasproperty(result, :source) || isnothing(result.source)
+        "unknown", 0
+    else
+        something(result.source.file, "unknown"), result.source.line
+    end
+    status = if result isa Test.Pass && result.test_type === :skipped
+        "skipped"
+    elseif result isa Test.Pass
+        "passed"
+    elseif result isa Test.Fail || result isa Test.Error
+        "failed"
+    else
+        "unknown"
+    end
+    data = Dict{String, Any}(
+        "name" => "$(result.test_type): $(result.orig_expr)",
+        "location" => string(file, ':', line),
+        "file_name" => file,
+        "result" => status)
+    add_failure_info!(data, result)
+end
+
+function add_failure_info!(data::Dict{String, Any}, result::Test.Result)
+    if result isa Test.Fail
+        data["failure_reason"] = if result.test_type === :test && !isnothing(result.data)
+            "Evaluated: $(result.data)"
+        elseif result.test_type === :test_throws_nothing
+            "No exception thrown"
+        elseif result.test_type === :test_throws_wrong
+            "Wrong exception type thrown"
+        else
+            "unknown"
+        end
+    elseif result isa Test.Error
+        data["failure_reason"] = if result.test_type === :test_error
+            if occursin("\nStacktrace:\n", result.backtrace)
+                err, trace = split(result.backtrace, "\nStacktrace:\n", limit=2)
+                data["failure_expanded"] = Dict{String, Any}(
+                    "expanded" => split(err, '\n'),
+                    "backtrace" => split(trace, '\n'))
+            end
+            "Exception (unexpectedly) thrown during test"
+        elseif result.test_type === :test_nonbool
+            "Expected the expression to evaluate to a Bool, not a $(typeof(result.data))"
+        elseif result.test_nonbool === :test_unbroken
+            "Expected this test to be broken, but it passed"
+        else
+            "unknown"
+        end
+    end
+    data
+end
+
+function collect_results!(results::Vector{Dict{String, Any}}, testset::Test.DefaultTestSet, prefix::String="")
+    common_data = result_dict(testset, prefix)
+    for (i, result) in enumerate(testset.results)
+        if result isa Test.Result
+            push!(results, merge(common_data, result_dict(result)))
+        elseif result isa Test.DefaultTestSet
+            collect_results!(results, result, common_data["scope"])
+        end
+    end
+    results
+end
+
+function write_testset_json(io::IO, testset::Test.DefaultTestSet)
+    data = Dict{String, Any}[]
+    collect_results!(data, testset)
+    json_repr(io, data)
+end
+
+end
diff --git a/test/runtests.jl b/test/runtests.jl
index 1b839a41bf0e0..8ce4053b19195 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -9,6 +9,9 @@ using Base: Experimental
 
 include("choosetests.jl")
 include("testenv.jl")
+include("buildkitetestjson.jl")
+
+using .BuildKiteTestJSON
 
 (; tests, net_on, exit_on_error, use_revise, seed) = choosetests(ARGS)
 tests = unique(tests)
@@ -424,6 +427,10 @@ cd(@__DIR__) do
         Test.record(o_ts, fake)
         Test.pop_testset()
     end
+
+    Base.get_bool_env("CI", false) &&
+        open(io -> write_testset_json(io, o_ts), "results.json", "w")
+
     Test.TESTSET_PRINT_ENABLE[] = true
     println()
     # o_ts.verbose = true # set to true to show all timings when successful

From 831cc145793095e3c7fa65be51496f3484ac89ce Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Sun, 4 Feb 2024 03:48:55 +0800
Subject: [PATCH 0794/1315] Fix typo in BuildKite test data generation CI code
 (#53168)

---
 test/buildkitetestjson.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/buildkitetestjson.jl b/test/buildkitetestjson.jl
index fc6d5859a7ca1..15bd8b8194a93 100644
--- a/test/buildkitetestjson.jl
+++ b/test/buildkitetestjson.jl
@@ -112,7 +112,7 @@ function add_failure_info!(data::Dict{String, Any}, result::Test.Result)
             "Exception (unexpectedly) thrown during test"
         elseif result.test_type === :test_nonbool
             "Expected the expression to evaluate to a Bool, not a $(typeof(result.data))"
-        elseif result.test_nonbool === :test_unbroken
+        elseif result.test_type === :test_unbroken
             "Expected this test to be broken, but it passed"
         else
             "unknown"

From 47663bd28c91a629f7bf13ff1df979865b661f1c Mon Sep 17 00:00:00 2001
From: "Tamas K. Papp" <tkpapp@gmail.com>
Date: Sun, 4 Feb 2024 02:32:02 +0100
Subject: [PATCH 0795/1315] Normalize indices in promote_shape error messages
 (#41311)

Seeing implementation details like `Base.OneTo` in error messages may
be confusing to some users (cf discussion in #39242,
[discourse](https://discourse.julialang.org/t/promote-shape-dimension-mismatch/57529/)).

This PR turns
```julia
julia> ones(2, 3) + ones(3, 2)
ERROR: DimensionMismatch("dimensions must match: a has dims (Base.OneTo(2), Base.OneTo(3)), b has dims (Base.OneTo(3), Base.OneTo(2)), mismatch at 1")
```
into
```julia
julia> ones(2, 3) + ones(3, 2)
ERROR: DimensionMismatch("dimensions must match: a has size (2, 3), b has size (3, 2), mismatch at 1")
```

Fixes #40118.

(This is basically #40124, but redone because I made a mess rebasing).

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/indices.jl                               | 57 ++++++++++++-------
 stdlib/LinearAlgebra/src/matmul.jl            |  4 +-
 .../LinearAlgebra/src/structuredbroadcast.jl  |  4 +-
 .../LinearAlgebra/test/structuredbroadcast.jl |  5 ++
 4 files changed, 46 insertions(+), 24 deletions(-)

diff --git a/base/indices.jl b/base/indices.jl
index ee3d076c5d7ec..9f2115e692564 100644
--- a/base/indices.jl
+++ b/base/indices.jl
@@ -106,26 +106,49 @@ IndexStyle(::IndexStyle, ::IndexStyle) = IndexCartesian()
 
 promote_shape(::Tuple{}, ::Tuple{}) = ()
 
-function promote_shape(a::Tuple{Int,}, b::Tuple{Int,})
-    if a[1] != b[1]
-        throw(DimensionMismatch("dimensions must match: a has dims $a, b has dims $b"))
+# Consistent error message for promote_shape mismatch, hiding type details like
+# OneTo. When b ≡ nothing, it is omitted; i can be supplied for an index.
+function throw_promote_shape_mismatch(a::Tuple, b::Union{Nothing,Tuple}, i = nothing)
+    if a isa Tuple{Vararg{Base.OneTo}} && (b === nothing || b isa Tuple{Vararg{Base.OneTo}})
+        a = map(lastindex, a)::Dims
+        b === nothing || (b = map(lastindex, b)::Dims)
+    end
+    _has_axes = !(a isa Dims && (b === nothing || b isa Dims))
+    if _has_axes
+        _normalize(d) = map(x -> firstindex(x):lastindex(x), d)
+        a = _normalize(a)
+        b === nothing || (b = _normalize(b))
+        _things = "axes "
+    else
+        _things = "size "
+    end
+    msg = IOBuffer()
+    print(msg, "a has ", _things)
+    print(msg, a)
+    if b ≢ nothing
+        print(msg, ", b has ", _things)
+        print(msg, b)
     end
+    if i ≢ nothing
+        print(msg, ", mismatch at dim ", i)
+    end
+    throw(DimensionMismatch(String(take!(msg))))
+end
+
+function promote_shape(a::Tuple{Int,}, b::Tuple{Int,})
+    a[1] != b[1] && throw_promote_shape_mismatch(a, b)
     return a
 end
 
 function promote_shape(a::Tuple{Int,Int}, b::Tuple{Int,})
-    if a[1] != b[1] || a[2] != 1
-        throw(DimensionMismatch("dimensions must match: a has dims $a, b has dims $b"))
-    end
+    (a[1] != b[1] || a[2] != 1) && throw_promote_shape_mismatch(a, b)
     return a
 end
 
 promote_shape(a::Tuple{Int,}, b::Tuple{Int,Int}) = promote_shape(b, a)
 
 function promote_shape(a::Tuple{Int, Int}, b::Tuple{Int, Int})
-    if a[1] != b[1] || a[2] != b[2]
-        throw(DimensionMismatch("dimensions must match: a has dims $a, b has dims $b"))
-    end
+    (a[1] != b[1] || a[2] != b[2]) && throw_promote_shape_mismatch(a, b)
     return a
 end
 
@@ -153,14 +176,10 @@ function promote_shape(a::Dims, b::Dims)
         return promote_shape(b, a)
     end
     for i=1:length(b)
-        if a[i] != b[i]
-            throw(DimensionMismatch("dimensions must match: a has dims $a, b has dims $b, mismatch at $i"))
-        end
+        a[i] != b[i] && throw_promote_shape_mismatch(a, b, i)
     end
     for i=length(b)+1:length(a)
-        if a[i] != 1
-            throw(DimensionMismatch("dimensions must match: a has dims $a, must have singleton at dim $i"))
-        end
+        a[i] != 1 && throw_promote_shape_mismatch(a, nothing, i)
     end
     return a
 end
@@ -174,14 +193,10 @@ function promote_shape(a::Indices, b::Indices)
         return promote_shape(b, a)
     end
     for i=1:length(b)
-        if a[i] != b[i]
-            throw(DimensionMismatch("dimensions must match: a has dims $a, b has dims $b, mismatch at $i"))
-        end
+        a[i] != b[i] && throw_promote_shape_mismatch(a, b, i)
     end
     for i=length(b)+1:length(a)
-        if a[i] != 1:1
-            throw(DimensionMismatch("dimensions must match: a has dims $a, must have singleton at dim $i"))
-        end
+        a[i] != 1:1 && throw_promote_shape_mismatch(a, nothing, i)
     end
     return a
 end
diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index 9f163f8d394b4..c84a85ebc7c81 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -184,7 +184,7 @@ function Base.muladd(A::AbstractMatrix, y::AbstractVecOrMat, z::Union{Number, Ab
     end
     for d in ndims(Ay)+1:ndims(z)
         # Similar error to what Ay + z would give, to match (Any,Any,Any) method:
-        size(z,d) > 1 && throw(DimensionMismatch(string("dimensions must match: z has dims ",
+        size(z,d) > 1 && throw(DimensionMismatch(string("z has dims ",
             axes(z), ", must have singleton at dim ", d)))
     end
     Ay .+ z
@@ -197,7 +197,7 @@ function Base.muladd(u::AbstractVector, v::AdjOrTransAbsVec, z::Union{Number, Ab
     end
     for d in 3:ndims(z)
         # Similar error to (u*v) + z:
-        size(z,d) > 1 && throw(DimensionMismatch(string("dimensions must match: z has dims ",
+        size(z,d) > 1 && throw(DimensionMismatch(string("z has dims ",
             axes(z), ", must have singleton at dim ", d)))
     end
     (u .* v) .+ z
diff --git a/stdlib/LinearAlgebra/src/structuredbroadcast.jl b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
index 02e39b199679b..a227b678c9934 100644
--- a/stdlib/LinearAlgebra/src/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
@@ -251,6 +251,8 @@ end
 # We can also implement `map` and its promotion in terms of broadcast with a stricter dimension check
 function map(f, A::StructuredMatrix, Bs::StructuredMatrix...)
     sz = size(A)
-    all(map(B->size(B)==sz, Bs)) || throw(DimensionMismatch("dimensions must match"))
+    for B in Bs
+        size(B) == sz || Base.throw_promote_shape_mismatch(sz, size(B))
+    end
     return f.(A, Bs...)
 end
diff --git a/stdlib/LinearAlgebra/test/structuredbroadcast.jl b/stdlib/LinearAlgebra/test/structuredbroadcast.jl
index 2ca1904b2ff2d..fab6cd80141b2 100644
--- a/stdlib/LinearAlgebra/test/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/test/structuredbroadcast.jl
@@ -142,6 +142,11 @@ end
             @test map!(*, Z, X, Y) == broadcast(*, fX, fY)
         end
     end
+    # these would be valid for broadcast, but not for map
+    @test_throws DimensionMismatch map(+, D, Diagonal(rand(1)))
+    @test_throws DimensionMismatch map(+, D, Diagonal(rand(1)), D)
+    @test_throws DimensionMismatch map(+, D, D, Diagonal(rand(1)))
+    @test_throws DimensionMismatch map(+, Diagonal(rand(1)), D, D)
 end
 
 @testset "Issue #33397" begin

From 6be4235ec9d1d82b6b574070e5bdb6f0bc3759ae Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Sun, 4 Feb 2024 11:53:45 +0800
Subject: [PATCH 0796/1315] Write test result data to static location, and log
 (#53173)

---
 test/runtests.jl | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/test/runtests.jl b/test/runtests.jl
index 8ce4053b19195..0f7a08446e014 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -428,8 +428,11 @@ cd(@__DIR__) do
         Test.pop_testset()
     end
 
-    Base.get_bool_env("CI", false) &&
-        open(io -> write_testset_json(io, o_ts), "results.json", "w")
+    if Base.get_bool_env("CI", false)
+        testresults = joinpath(@__DIR__, "results.json")
+        @info "Writing test result data to $testresults"
+        open(io -> write_testset_json(io, o_ts), testresults, "w")
+    end
 
     Test.TESTSET_PRINT_ENABLE[] = true
     println()

From 3d8b10770a7a7317dde13ae36881991db356326c Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 3 Feb 2024 22:58:55 -0500
Subject: [PATCH 0797/1315] Improve printing for length and size method error
 (#53146)

---
 base/errorshow.jl | 23 +++++++++++++++++++----
 test/errorshow.jl | 27 +++++++++++++++++++++++----
 2 files changed, 42 insertions(+), 8 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index d7cacb66eb76d..c08e75029afab 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -1025,15 +1025,30 @@ Experimental.register_error_hint(string_concatenation_hint_handler, MethodError)
 
 
 # Display a hint in case the user tries to use the min or max function on an iterable
-function min_max_on_iterable(io, ex, arg_types, kwargs)
+# or tries to use something like `collect` on an iterator without defining either IteratorSize or length
+function methods_on_iterable(io, ex, arg_types, kwargs)
     @nospecialize
-    if (ex.f === max || ex.f === min) && length(arg_types) == 1 && Base.isiterable(only(arg_types))
-        f_correct = ex.f === max ? "maximum" : "minimum"
+    f = ex.f
+    if (f === max || f === min) && length(arg_types) == 1 && Base.isiterable(only(arg_types))
+        f_correct = f === max ? "maximum" : "minimum"
         print(io, "\nFinding the $f_correct of an iterable is performed with `$f_correct`.")
     end
+    if (f === Base.length || f === Base.size) && length(arg_types) >= 1
+        arg_type_tuple = Tuple{arg_types...}
+        if hasmethod(iterate, arg_type_tuple)
+            iterkind = IteratorSize(arg_types[1])
+            if iterkind isa HasLength
+                print(io, "\nYou may need to implement the `length` method or define `IteratorSize` for this type to be `SizeUnknown`.")
+            elseif iterkind isa HasShape
+                print(io, "\nYou may need to implement the `length` and `size` methods for `IteratorSize` `HasShape`.")
+            end
+        end
+    end
+    nothing
 end
 
-Experimental.register_error_hint(min_max_on_iterable, MethodError)
+Experimental.register_error_hint(methods_on_iterable, MethodError)
+
 
 # ExceptionStack implementation
 size(s::ExceptionStack) = size(s.stack)
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 5c5b4e3ac45f8..84d55fcb80de1 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -8,7 +8,7 @@ include("testenv.jl")
 # re-register only the error hints that are being tested here (
 Base.Experimental.register_error_hint(Base.noncallable_number_hint_handler, MethodError)
 Base.Experimental.register_error_hint(Base.string_concatenation_hint_handler, MethodError)
-Base.Experimental.register_error_hint(Base.min_max_on_iterable, MethodError)
+Base.Experimental.register_error_hint(Base.methods_on_iterable, MethodError)
 
 @testset "SystemError" begin
     err = try; systemerror("reason", Cint(0)); false; catch ex; ex; end::SystemError
@@ -1000,13 +1000,32 @@ let err_str
     @test occursin("String concatenation is performed with *", err_str)
 end
 
+struct MissingLength; end
+struct MissingSize; end
+Base.IteratorSize(::Type{MissingSize}) = Base.HasShape{2}()
+Base.iterate(::MissingLength) = nothing
+Base.iterate(::MissingSize) = nothing
+
 let err_str
+    expected = "Finding the minimum of an iterable is performed with `minimum`."
     err_str = @except_str min([1,2,3]) MethodError
-    @test occursin("Finding the minimum of an iterable is performed with `minimum`.", err_str)
+    @test occursin(expected, err_str)
     err_str = @except_str min((i for i in 1:3)) MethodError
-    @test occursin("Finding the minimum of an iterable is performed with `minimum`.", err_str)
+    @test occursin(expected, err_str)
+    expected = "Finding the maximum of an iterable is performed with `maximum`."
     err_str = @except_str max([1,2,3]) MethodError
-    @test occursin("Finding the maximum of an iterable is performed with `maximum`.", err_str)
+    @test occursin(expected, err_str)
+
+    expected = "You may need to implement the `length` method or define `IteratorSize` for this type to be `SizeUnknown`."
+    err_str = @except_str length(MissingLength()) MethodError
+    @test occursin(expected, err_str)
+    err_str = @except_str collect(MissingLength()) MethodError
+    @test occursin(expected, err_str)
+    expected = "You may need to implement the `length` and `size` methods for `IteratorSize` `HasShape`."
+    err_str = @except_str size(MissingSize()) MethodError
+    @test occursin(expected, err_str)
+    err_str = @except_str collect(MissingSize()) MethodError
+    @test occursin(expected, err_str)
 end
 
 @testset "unused argument names" begin

From 8db129472ea88a9c5c4a6e94dff7b330723aed28 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 4 Feb 2024 19:51:02 -0500
Subject: [PATCH 0798/1315] add atomic operators for globals, memory, and
 setonce (#52868)

This implements `AtomicMemory`, atomic operations for globals, and the
class of atomic function for setting a field or global or memory exactly
once (setting undef => value). It is quite similar to an
`@atomicreplace`, but where there was not a previous value. This is not
needed for pointers, since it is simply calling C_NULL => pointer in
that case, since there is no "undef" value that throws after load.

plenty of future work still, for a later PR:
- syntax lowering for `@atomic global x = y` and `@atomic closedover =
y`
   - adding `Core.AtomicBox` for closure capture
   - generic functions for `atomicsetindex` & friends
   - macro for `@atomic x = y` and `@atomic x[] = y`, etc
   - design for `@atomiconce f()`
---
 base/Base.jl                            |  30 +
 base/boot.jl                            |  32 +-
 base/compiler/abstractinterpretation.jl |  10 +-
 base/compiler/ssair/inlining.jl         |  22 +-
 base/compiler/stmtinfo.jl               |  15 +-
 base/compiler/tfuncs.jl                 | 200 +++++--
 base/deepcopy.jl                        |   2 +-
 base/docs/basedocs.jl                   | 114 +++-
 base/docs/intrinsicsdocs.jl             | 117 ++++
 base/essentials.jl                      |  15 +-
 base/exports.jl                         |   2 +
 base/expr.jl                            |  57 ++
 base/genericmemory.jl                   |  47 +-
 doc/src/base/base.md                    |  13 +-
 doc/src/base/multi-threading.md         |  16 +-
 doc/src/devdocs/builtins.md             |   9 +
 doc/src/manual/multi-threading.md       |   5 +-
 src/builtin_proto.h                     |  45 +-
 src/builtins.c                          | 359 +++++++++--
 src/ccall.cpp                           |   6 +-
 src/cgutils.cpp                         | 366 +++++++-----
 src/codegen.cpp                         | 764 +++++++++++++++++-------
 src/datatype.c                          | 684 +++++++++++++--------
 src/genericmemory.c                     | 364 ++++++-----
 src/intrinsics.cpp                      |  86 +--
 src/jl_exported_funcs.inc               |   4 +-
 src/julia.h                             |  25 +-
 src/julia_atomics.h                     |  16 +-
 src/julia_internal.h                    |  32 +
 src/julia_locks.h                       |   5 +
 src/llvm-late-gc-lowering.cpp           |   1 +
 src/module.c                            |  77 ++-
 src/runtime_intrinsics.c                |  20 +-
 src/staticdata.c                        |  19 +-
 test/atomics.jl                         | 627 ++++++++++++++++++-
 test/compiler/effects.jl                |   2 +-
 test/compiler/inference.jl              |  26 +-
 test/compiler/inline.jl                 |  18 +
 38 files changed, 3211 insertions(+), 1041 deletions(-)

diff --git a/base/Base.jl b/base/Base.jl
index 87e1fe94b0ad2..c729ab9ca707e 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -91,6 +91,36 @@ function replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol
     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
diff --git a/base/boot.jl b/base/boot.jl
index 13bb6bcd7cd4b..9f34f02981cf6 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -65,7 +65,7 @@
 #end
 
 # struct GenericMemoryRef{kind::Symbol, T, AS::AddrSpace}
-#    mem::Memory{kind, T, AS}
+#    mem::GenericMemory{kind, T, AS}
 #    data::Ptr{Cvoid} # make this GenericPtr{addrspace, Cvoid}
 #end
 
@@ -191,8 +191,8 @@ export
     Tuple, Type, UnionAll, TypeVar, Union, Nothing, Cvoid,
     AbstractArray, DenseArray, NamedTuple, Pair,
     # special objects
-    Function, Method, Array, Memory, MemoryRef, GenericMemory, GenericMemoryRef,
-    Module, Symbol, Task, UndefInitializer, undef, WeakRef, VecElement,
+    Function, Method, Module, Symbol, Task, UndefInitializer, undef, WeakRef, VecElement,
+    Array, Memory, MemoryRef, AtomicMemory, AtomicMemoryRef, GenericMemory, GenericMemoryRef,
     # numeric types
     Number, Real, Integer, Bool, Ref, Ptr,
     AbstractFloat, Float16, Float32, Float64,
@@ -209,10 +209,10 @@ export
     # AST representation
     Expr, QuoteNode, LineNumberNode, GlobalRef,
     # object model functions
-    fieldtype, getfield, setfield!, swapfield!, modifyfield!, replacefield!,
+    fieldtype, getfield, setfield!, swapfield!, modifyfield!, replacefield!, setfieldonce!,
     nfields, throw, tuple, ===, isdefined, eval,
     # access to globals
-    getglobal, setglobal!,
+    getglobal, setglobal!, swapglobal!, modifyglobal!, replaceglobal!, setglobalonce!,
     # ifelse, sizeof    # not exported, to avoid conflicting with Base
     # type reflection
     <:, typeof, isa, typeassert,
@@ -516,22 +516,24 @@ const undef = UndefInitializer()
 (self::Type{GenericMemory{kind,T,addrspace}})(::UndefInitializer, d::NTuple{1,Int}) where {T,kind,addrspace} = self(undef, getfield(d,1))
 # empty vector constructor
 (self::Type{GenericMemory{kind,T,addrspace}})() where {T,kind,addrspace} = self(undef, 0)
-# copy constructors
 
-const Memory{T} = GenericMemory{:not_atomic, T, CPU}
-const MemoryRef{T} = GenericMemoryRef{:not_atomic, T, CPU}
 GenericMemoryRef(mem::GenericMemory) = memoryref(mem)
 GenericMemoryRef(ref::GenericMemoryRef, i::Integer) = memoryref(ref, Int(i), @_boundscheck)
 GenericMemoryRef(mem::GenericMemory, i::Integer) = memoryref(memoryref(mem), Int(i), @_boundscheck)
-MemoryRef(mem::Memory) = memoryref(mem)
-MemoryRef(ref::MemoryRef, i::Integer) = memoryref(ref, Int(i), @_boundscheck)
-MemoryRef(mem::Memory, i::Integer) = memoryref(memoryref(mem), Int(i), @_boundscheck)
-MemoryRef{T}(mem::Memory{T}) where {T} = memoryref(mem)
-MemoryRef{T}(ref::MemoryRef{T}, i::Integer) where {T} = memoryref(ref, Int(i), @_boundscheck)
-MemoryRef{T}(mem::Memory{T}, i::Integer) where {T} = memoryref(memoryref(mem), Int(i), @_boundscheck)
+GenericMemoryRef{kind,<:Any,AS}(mem::GenericMemory{kind,<:Any,AS}) where {kind,AS} = memoryref(mem)
+GenericMemoryRef{kind,<:Any,AS}(ref::GenericMemoryRef{kind,<:Any,AS}, i::Integer) where {kind,AS} = memoryref(ref, Int(i), @_boundscheck)
+GenericMemoryRef{kind,<:Any,AS}(mem::GenericMemory{kind,<:Any,AS}, i::Integer) where {kind,AS}  = memoryref(memoryref(mem), Int(i), @_boundscheck)
+GenericMemoryRef{kind,T,AS}(mem::GenericMemory{kind,T,AS}) where {kind,T,AS}  = memoryref(mem)
+GenericMemoryRef{kind,T,AS}(ref::GenericMemoryRef{kind,T,AS}, i::Integer) where {kind,T,AS} = memoryref(ref, Int(i), @_boundscheck)
+GenericMemoryRef{kind,T,AS}(mem::GenericMemory{kind,T,AS}, i::Integer) where {kind,T,AS} = memoryref(memoryref(mem), Int(i), @_boundscheck)
+
+const Memory{T} = GenericMemory{:not_atomic, T, CPU}
+const MemoryRef{T} = GenericMemoryRef{:not_atomic, T, CPU}
+const AtomicMemory{T} = GenericMemory{:atomic, T, CPU}
+const AtomicMemoryRef{T} = GenericMemoryRef{:atomic, T, CPU}
 
 # construction helpers for Array
-new_as_memoryref(self::Type{GenericMemoryRef{isatomic,T,addrspace}}, m::Int) where {T,isatomic,addrspace} = memoryref(fieldtype(self, :mem)(undef, m))
+new_as_memoryref(self::Type{GenericMemoryRef{kind,T,addrspace}}, m::Int) where {T,kind,addrspace} = memoryref(fieldtype(self, :mem)(undef, m))
 
 # checked-multiply intrinsic function for dimensions
 _checked_mul_dims() = 1, false
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 292a39e42e77b..889a9a541246e 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1113,12 +1113,12 @@ function const_prop_function_heuristic(interp::AbstractInterpreter, @nospecializ
                 if !still_nothrow || ismutabletype(arrty)
                     return false
                 end
-            elseif ⊑(𝕃ᵢ, arrty, Array)
+            elseif ⊑(𝕃ᵢ, arrty, Array) || ⊑(𝕃ᵢ, arrty, GenericMemory)
                 return false
             end
         elseif istopfunction(f, :iterate)
             itrty = argtypes[2]
-            if ⊑(𝕃ᵢ, itrty, Array)
+            if ⊑(𝕃ᵢ, itrty, Array) || ⊑(𝕃ᵢ, itrty, GenericMemory)
                 return false
             end
         end
@@ -1501,7 +1501,7 @@ function abstract_iteration(interp::AbstractInterpreter, @nospecialize(itft), @n
     # Return Bottom if this is not an iterator.
     # WARNING: Changes to the iteration protocol must be reflected here,
     # this is not just an optimization.
-    # TODO: this doesn't realize that Array, SimpleVector, Tuple, and NamedTuple do not use the iterate protocol
+    # TODO: this doesn't realize that Array, GenericMemory, SimpleVector, Tuple, and NamedTuple do not use the iterate protocol
     stateordonet === Bottom && return AbstractIterationResult(Any[Bottom], AbstractIterationInfo(CallMeta[CallMeta(Bottom, Any, call.effects, info)], true))
     valtype = statetype = Bottom
     ret = Any[]
@@ -2076,8 +2076,8 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
             return abstract_apply(interp, argtypes, si, sv, max_methods)
         elseif f === invoke
             return abstract_invoke(interp, arginfo, si, sv)
-        elseif f === modifyfield!
-            return abstract_modifyfield!(interp, argtypes, si, sv)
+        elseif f === modifyfield! || f === Core.modifyglobal! || f === Core.memoryrefmodify! || f === atomic_pointermodify
+            return abstract_modifyop!(interp, f, argtypes, si, sv)
         elseif f === Core.finalizer
             return abstract_finalizer(interp, argtypes, sv)
         elseif f === applicable
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index e6438b3f9325f..74d3987ee0257 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1286,10 +1286,18 @@ function process_simple!(todo::Vector{Pair{Int,Any}}, ir::IRCode, idx::Int, stat
         end
     end
 
-    if (sig.f !== Core.invoke && sig.f !== Core.finalizer && sig.f !== modifyfield!) &&
-        is_builtin(optimizer_lattice(state.interp), sig)
-        # No inlining for builtins (other invoke/apply/typeassert/finalizer)
-        return nothing
+    if is_builtin(optimizer_lattice(state.interp), sig)
+        let f = sig.f
+            if (f !== Core.invoke &&
+                f !== Core.finalizer &&
+                f !== modifyfield! &&
+                f !== Core.modifyglobal! &&
+                f !== Core.memoryrefmodify! &&
+                f !== atomic_pointermodify)
+                # No inlining defined for most builtins (just invoke/apply/typeassert/finalizer), so attempt an early exit for them
+                return nothing
+            end
+        end
     end
 
     # Special case inliners for regular functions
@@ -1571,7 +1579,7 @@ function handle_opaque_closure_call!(todo::Vector{Pair{Int,Any}},
     return nothing
 end
 
-function handle_modifyfield!_call!(ir::IRCode, idx::Int, stmt::Expr, info::ModifyFieldInfo, state::InliningState)
+function handle_modifyop!_call!(ir::IRCode, idx::Int, stmt::Expr, info::ModifyOpInfo, state::InliningState)
     info = info.info
     info isa MethodResultPure && (info = info.info)
     info isa ConstCallInfo && (info = info.call)
@@ -1679,8 +1687,8 @@ function assemble_inline_todo!(ir::IRCode, state::InliningState)
         # handle special cased builtins
         if isa(info, OpaqueClosureCallInfo)
             handle_opaque_closure_call!(todo, ir, idx, stmt, info, flag, sig, state)
-        elseif isa(info, ModifyFieldInfo)
-            handle_modifyfield!_call!(ir, idx, stmt, info, state)
+        elseif isa(info, ModifyOpInfo)
+            handle_modifyop!_call!(ir, idx, stmt, info, state)
         elseif isa(info, InvokeCallInfo)
             handle_invoke_call!(todo, ir, idx, stmt, info, flag, sig, state)
         elseif isa(info, FinalizerInfo)
diff --git a/base/compiler/stmtinfo.jl b/base/compiler/stmtinfo.jl
index e28858eea60aa..25f5bb894eaa9 100644
--- a/base/compiler/stmtinfo.jl
+++ b/base/compiler/stmtinfo.jl
@@ -222,13 +222,18 @@ struct FinalizerInfo <: CallInfo
 end
 
 """
-    info::ModifyFieldInfo <: CallInfo
+    info::ModifyOpInfo <: CallInfo
 
-Represents a resolved all of `modifyfield!(obj, name, op, x, [order])`.
-`info.info` wraps the call information of `op(getfield(obj, name), x)`.
+Represents a resolved call of one of:
+ - `modifyfield!(obj, name, op, x, [order])`
+ - `modifyglobal!(mod, var, op, x, order)`
+ - `memoryrefmodify!(memref, op, x, order, boundscheck)`
+ - `Intrinsics.atomic_pointermodify(ptr, op, x, order)`
+
+`info.info` wraps the call information of `op(getval(), x)`.
 """
-struct ModifyFieldInfo <: CallInfo
-    info::CallInfo # the callinfo for the `op(getfield(obj, name), x)` call
+struct ModifyOpInfo <: CallInfo
+    info::CallInfo # the callinfo for the `op(getval(), x)` call
 end
 
 @specialize
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index d4485783c191c..b817c2af9c49c 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -1363,40 +1363,88 @@ end
     return false
 end
 
-@nospecs function swapfield!_tfunc(𝕃::AbstractLattice, o, f, v, order)
+@nospecs function swapfield!_tfunc(𝕃::AbstractLattice, o, f, v, order=Symbol)
+    setfield!_tfunc(𝕃, o, f, v) === Bottom && return Bottom
     return getfield_tfunc(𝕃, o, f)
 end
-@nospecs function swapfield!_tfunc(𝕃::AbstractLattice, o, f, v)
-    return getfield_tfunc(𝕃, o, f)
-end
-@nospecs function modifyfield!_tfunc(𝕃::AbstractLattice, o, f, op, v, order)
-    return modifyfield!_tfunc(𝕃, o, f, op, v)
-end
-@nospecs function modifyfield!_tfunc(𝕃::AbstractLattice, o, f, op, v)
+@nospecs function modifyfield!_tfunc(𝕃::AbstractLattice, o, f, op, v, order=Symbol)
     T = _fieldtype_tfunc(𝕃, o, f, isconcretetype(o))
     T === Bottom && return Bottom
     PT = Const(Pair)
     return instanceof_tfunc(apply_type_tfunc(𝕃, PT, T, T), true)[1]
 end
-function abstract_modifyfield!(interp::AbstractInterpreter, argtypes::Vector{Any}, si::StmtInfo, sv::AbsIntState)
+@nospecs function replacefield!_tfunc(𝕃::AbstractLattice, o, f, x, v, success_order=Symbol, failure_order=Symbol)
+    T = _fieldtype_tfunc(𝕃, o, f, isconcretetype(o))
+    T === Bottom && return Bottom
+    PT = Const(ccall(:jl_apply_cmpswap_type, Any, (Any,), T) where T)
+    return instanceof_tfunc(apply_type_tfunc(𝕃, PT, T), true)[1]
+end
+@nospecs function setfieldonce!_tfunc(𝕃::AbstractLattice, o, f, v, success_order=Symbol, failure_order=Symbol)
+    setfield!_tfunc(𝕃, o, f, v) === Bottom && return Bottom
+    isdefined_tfunc(𝕃, o, f) === Const(true) && return Const(false)
+    return Bool
+end
+
+@nospecs function abstract_modifyop!(interp::AbstractInterpreter, ff, argtypes::Vector{Any}, si::StmtInfo, sv::AbsIntState)
+    if ff === modifyfield!
+        minargs = 5
+        maxargs = 6
+        op_argi = 4
+        v_argi = 5
+    elseif ff === Core.modifyglobal!
+        minargs = 5
+        maxargs = 6
+        op_argi = 4
+        v_argi = 5
+    elseif ff === Core.memoryrefmodify!
+        minargs = 6
+        maxargs = 6
+        op_argi = 3
+        v_argi = 4
+    elseif ff === atomic_pointermodify
+        minargs = 5
+        maxargs = 5
+        op_argi = 3
+        v_argi = 4
+    else
+        @assert false "unreachable"
+    end
+
     nargs = length(argtypes)
     if !isempty(argtypes) && isvarargtype(argtypes[nargs])
-        nargs - 1 <= 6 || return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
-        nargs > 3 || return CallMeta(Any, Any, Effects(), NoCallInfo())
+        nargs - 1 <= maxargs || return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
+        nargs + 1 >= op_argi || return CallMeta(Any, Any, Effects(), NoCallInfo())
     else
-        5 <= nargs <= 6 || return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
+        minargs <= nargs <= maxargs || return CallMeta(Bottom, Any, EFFECTS_THROWS, NoCallInfo())
     end
     𝕃ᵢ = typeinf_lattice(interp)
-    o = unwrapva(argtypes[2])
-    f = unwrapva(argtypes[3])
-    RT = modifyfield!_tfunc(𝕃ᵢ, o, f, Any, Any)
+    if ff === modifyfield!
+        o = unwrapva(argtypes[2])
+        f = unwrapva(argtypes[3])
+        RT = modifyfield!_tfunc(𝕃ᵢ, o, f, Any, Any, Symbol)
+        TF = getfield_tfunc(𝕃ᵢ, o, f)
+    elseif ff === Core.modifyglobal!
+        o = unwrapva(argtypes[2])
+        f = unwrapva(argtypes[3])
+        RT = modifyglobal!_tfunc(𝕃ᵢ, o, f, Any, Any, Symbol)
+        TF = getglobal_tfunc(𝕃ᵢ, o, f, Symbol)
+    elseif ff === Core.memoryrefmodify!
+        o = unwrapva(argtypes[2])
+        RT = memoryrefmodify!_tfunc(𝕃ᵢ, o, Any, Any, Symbol, Bool)
+        TF = memoryrefget_tfunc(𝕃ᵢ, o, Symbol, Bool)
+    elseif ff === atomic_pointermodify
+        o = unwrapva(argtypes[2])
+        RT = atomic_pointermodify_tfunc(𝕃ᵢ, o, Any, Any, Symbol)
+        TF = atomic_pointerref_tfunc(𝕃ᵢ, o, Symbol)
+    else
+        @assert false "unreachable"
+    end
     info = NoCallInfo()
-    if nargs >= 5 && RT !== Bottom
+    if nargs >= v_argi && RT !== Bottom
         # we may be able to refine this to a PartialStruct by analyzing `op(o.f, v)::T`
         # as well as compute the info for the method matches
-        op = unwrapva(argtypes[4])
-        v = unwrapva(argtypes[5])
-        TF = getfield_tfunc(𝕃ᵢ, o, f)
+        op = unwrapva(argtypes[op_argi])
+        v = unwrapva(argtypes[v_argi])
         callinfo = abstract_call(interp, ArgInfo(nothing, Any[op, TF, v]), StmtInfo(true), sv, #=max_methods=#1)
         TF2 = tmeet(callinfo.rt, widenconst(TF))
         if TF2 === Bottom
@@ -1404,31 +1452,19 @@ function abstract_modifyfield!(interp::AbstractInterpreter, argtypes::Vector{Any
         elseif isconcretetype(RT) && has_nontrivial_extended_info(𝕃ᵢ, TF2) # isconcrete condition required to form a PartialStruct
             RT = PartialStruct(RT, Any[TF, TF2])
         end
-        info = ModifyFieldInfo(callinfo.info)
+        info = ModifyOpInfo(callinfo.info)
     end
     return CallMeta(RT, Any, Effects(), info)
 end
-@nospecs function replacefield!_tfunc(𝕃::AbstractLattice, o, f, x, v, success_order, failure_order)
-    return replacefield!_tfunc(𝕃, o, f, x, v)
-end
-@nospecs function replacefield!_tfunc(𝕃::AbstractLattice, o, f, x, v, success_order)
-    return replacefield!_tfunc(𝕃, o, f, x, v)
-end
-@nospecs function replacefield!_tfunc(𝕃::AbstractLattice, o, f, x, v)
-    T = _fieldtype_tfunc(𝕃, o, f, isconcretetype(o))
-    T === Bottom && return Bottom
-    PT = Const(ccall(:jl_apply_cmpswap_type, Any, (Any,), T) where T)
-    return instanceof_tfunc(apply_type_tfunc(𝕃, PT, T), true)[1]
-end
 
 # we could use tuple_tfunc instead of widenconst, but `o` is mutable, so that is unlikely to be beneficial
 
 add_tfunc(getfield, 2, 4, getfield_tfunc, 1)
 add_tfunc(setfield!, 3, 4, setfield!_tfunc, 3)
-
 add_tfunc(swapfield!, 3, 4, swapfield!_tfunc, 3)
 add_tfunc(modifyfield!, 4, 5, modifyfield!_tfunc, 3)
 add_tfunc(replacefield!, 4, 6, replacefield!_tfunc, 3)
+add_tfunc(setfieldonce!, 3, 5, setfieldonce!_tfunc, 3)
 
 @nospecs function fieldtype_nothrow(𝕃::AbstractLattice, s0, name)
     s0 === Bottom && return true # unreachable
@@ -1976,19 +2012,45 @@ function tuple_tfunc(𝕃::AbstractLattice, argtypes::Vector{Any})
 end
 
 @nospecs function memoryrefget_tfunc(𝕃::AbstractLattice, mem, order, boundscheck)
-    return _memoryrefget_tfunc(𝕃, mem, order, boundscheck)
-end
-@nospecs function _memoryrefget_tfunc(𝕃::AbstractLattice, mem, order, boundscheck)
     memoryref_builtin_common_errorcheck(mem, order, boundscheck) || return Bottom
     return memoryref_elemtype(mem)
 end
-add_tfunc(memoryrefget, 3, 3, memoryrefget_tfunc, 20)
-
 @nospecs function memoryrefset!_tfunc(𝕃::AbstractLattice, mem, item, order, boundscheck)
-    hasintersect(widenconst(item), _memoryrefget_tfunc(𝕃, mem, order, boundscheck)) || return Bottom
-    return mem
+    hasintersect(widenconst(item), memoryrefget_tfunc(𝕃, mem, order, boundscheck)) || return Bottom
+    return item
+end
+@nospecs function memoryrefswap!_tfunc(𝕃::AbstractLattice, mem, v, order, boundscheck)
+    memoryrefset!_tfunc(𝕃, mem, v, order, boundscheck) === Bottom && return Bottom
+    return memoryrefget_tfunc(𝕃, mem, order, boundscheck)
+end
+@nospecs function memoryrefmodify!_tfunc(𝕃::AbstractLattice, mem, op, v, order, boundscheck)
+    memoryrefget_tfunc(𝕃, mem, order, boundscheck) === Bottom && return Bottom
+    T = _memoryref_elemtype(mem)
+    T === Bottom && return Bottom
+    PT = Const(Pair)
+    return instanceof_tfunc(apply_type_tfunc(𝕃, PT, T, T), true)[1]
+end
+@nospecs function memoryrefreplace!_tfunc(𝕃::AbstractLattice, mem, x, v, success_order, failure_order, boundscheck)
+    memoryrefset!_tfunc(𝕃, mem, v, success_order, boundscheck) === Bottom && return Bottom
+    hasintersect(widenconst(failure_order), Symbol) || return Bottom
+    T = _memoryref_elemtype(mem)
+    T === Bottom && return Bottom
+    PT = Const(ccall(:jl_apply_cmpswap_type, Any, (Any,), T) where T)
+    return instanceof_tfunc(apply_type_tfunc(𝕃, PT, T), true)[1]
+end
+@nospecs function memoryrefsetonce!_tfunc(𝕃::AbstractLattice, mem, v, success_order, failure_order, boundscheck)
+    memoryrefset!_tfunc(𝕃, mem, v, success_order, boundscheck) === Bottom && return Bottom
+    hasintersect(widenconst(failure_order), Symbol) || return Bottom
+    return Bool
 end
-add_tfunc(memoryrefset!, 4, 4, memoryrefset!_tfunc, 20)
+
+add_tfunc(Core.memoryrefget, 3, 3, memoryrefget_tfunc, 20)
+add_tfunc(Core.memoryrefset!, 4, 4, memoryrefset!_tfunc, 20)
+add_tfunc(Core.memoryrefswap!, 4, 4, memoryrefswap!_tfunc, 20)
+add_tfunc(Core.memoryrefmodify!, 5, 5, memoryrefmodify!_tfunc, 20)
+add_tfunc(Core.memoryrefreplace!, 6, 6, memoryrefreplace!_tfunc, 20)
+add_tfunc(Core.memoryrefsetonce!, 5, 5, memoryrefsetonce!_tfunc, 20)
+
 
 @nospecs function memoryref_isassigned_tfunc(𝕃::AbstractLattice, mem, order, boundscheck)
     return _memoryref_isassigned_tfunc(𝕃, mem, order, boundscheck)
@@ -2039,7 +2101,7 @@ add_tfunc(memoryrefoffset, 1, 1, memoryrefoffset_tfunc, 5)
     return true
 end
 
-function memoryref_elemtype(@nospecialize mem)
+@nospecs function memoryref_elemtype(@nospecialize mem)
     m = widenconst(mem)
     if !has_free_typevars(m) && m <: GenericMemoryRef
         m0 = m
@@ -2055,6 +2117,23 @@ function memoryref_elemtype(@nospecialize mem)
     return Any
 end
 
+@nospecs function _memoryref_elemtype(@nospecialize mem)
+    m = widenconst(mem)
+    if !has_free_typevars(m) && m <: GenericMemoryRef
+        m0 = m
+        if isa(m, UnionAll)
+            m = unwrap_unionall(m0)
+        end
+        if isa(m, DataType)
+            T = m.parameters[2]
+            valid_as_lattice(T, true) || return Bottom
+            has_free_typevars(T) || return Const(T)
+            return rewrap_unionall(Type{T}, m0)
+        end
+    end
+    return Type
+end
+
 @nospecs function opaque_closure_tfunc(𝕃::AbstractLattice, arg, lb, ub, source, env::Vector{Any}, linfo::MethodInstance)
     argt, argt_exact = instanceof_tfunc(arg)
     lbt, lb_exact = instanceof_tfunc(lb)
@@ -3059,6 +3138,8 @@ end
     elseif !(hasintersect(widenconst(M), Module) && hasintersect(widenconst(s), Symbol))
         return Bottom
     end
+    T = get_binding_type_tfunc(𝕃, M, s)
+    T isa Const && return T.val
     return Any
 end
 @nospecs function setglobal!_tfunc(𝕃::AbstractLattice, M, s, v, order=Symbol)
@@ -3067,8 +3148,39 @@ end
     end
     return v
 end
-add_tfunc(getglobal, 2, 3, getglobal_tfunc, 1)
-add_tfunc(setglobal!, 3, 4, setglobal!_tfunc, 3)
+@nospecs function swapglobal!_tfunc(𝕃::AbstractLattice, M, s, v, order=Symbol)
+    setglobal!_tfunc(𝕃, M, s, v) === Bottom && return Bottom
+    return getglobal_tfunc(𝕃, M, s)
+end
+@nospecs function modifyglobal!_tfunc(𝕃::AbstractLattice, M, s, op, v, order=Symbol)
+    T = get_binding_type_tfunc(𝕃, M, s)
+    T === Bottom && return Bottom
+    T isa Const || return Pair
+    T = T.val
+    return Pair{T, T}
+end
+@nospecs function replaceglobal!_tfunc(𝕃::AbstractLattice, M, s, x, v, success_order=Symbol, failure_order=Symbol)
+    v = setglobal!_tfunc(𝕃, M, s, v)
+    v === Bottom && return Bottom
+    T = get_binding_type_tfunc(𝕃, M, s)
+    T === Bottom && return Bottom
+    T isa Const || return ccall(:jl_apply_cmpswap_type, Any, (Any,), T) where T
+    T = T.val
+    return ccall(:jl_apply_cmpswap_type, Any, (Any,), T)
+end
+@nospecs function setglobalonce!_tfunc(𝕃::AbstractLattice, M, s, v, success_order=Symbol, failure_order=Symbol)
+    setglobal!_tfunc(𝕃, M, s, v) === Bottom && return Bottom
+    return Bool
+end
+
+add_tfunc(Core.getglobal, 2, 3, getglobal_tfunc, 1)
+add_tfunc(Core.setglobal!, 3, 4, setglobal!_tfunc, 3)
+add_tfunc(Core.swapglobal!, 3, 4, swapglobal!_tfunc, 3)
+add_tfunc(Core.modifyglobal!, 4, 5, modifyglobal!_tfunc, 3)
+add_tfunc(Core.replaceglobal!, 4, 6, replaceglobal!_tfunc, 3)
+add_tfunc(Core.setglobalonce!, 3, 5, setglobalonce!_tfunc, 3)
+
+
 @nospecs function setglobal!_nothrow(M, s, newty, o)
     global_order_nothrow(o, #=loading=#false, #=storing=#true) || return false
     return setglobal!_nothrow(M, s, newty)
diff --git a/base/deepcopy.jl b/base/deepcopy.jl
index d2e675dc53bf5..bee1f7994a150 100644
--- a/base/deepcopy.jl
+++ b/base/deepcopy.jl
@@ -115,7 +115,7 @@ function _deepcopy_memory_t(@nospecialize(x::Memory), T, stackdict::IdDict)
                 xi = deepcopy_internal(xi, stackdict)::typeof(xi)
             end
             di = Core.memoryref(dr, i, false)
-            di = Core.memoryrefset!(di, xi, :not_atomic, false)
+            Core.memoryrefset!(di, xi, :not_atomic, false)
         end
     end
     return dest
diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 896cbf30b6520..383ae2c683182 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -1,4 +1,5 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
+#
 
 module BaseDocs
 
@@ -2235,11 +2236,14 @@ setfield!
     swapfield!(value, name::Symbol, x, [order::Symbol])
     swapfield!(value, i::Int, x, [order::Symbol])
 
-These atomically perform the operations to simultaneously get and set a field:
+Atomically perform the operations to simultaneously get and set a field:
 
     y = getfield(value, name)
     setfield!(value, name, x)
     return y
+
+!!! compat "Julia 1.7"
+    This function requires Julia 1.7 or later.
 """
 swapfield!
 
@@ -2247,7 +2251,7 @@ swapfield!
     modifyfield!(value, name::Symbol, op, x, [order::Symbol]) -> Pair
     modifyfield!(value, i::Int, op, x, [order::Symbol]) -> Pair
 
-These atomically perform the operations to get and set a field after applying
+Atomically perform the operations to get and set a field after applying
 the function `op`.
 
     y = getfield(value, name)
@@ -2257,6 +2261,9 @@ the function `op`.
 
 If supported by the hardware (for example, atomic increment), this may be
 optimized to the appropriate hardware instruction, otherwise it'll use a loop.
+
+!!! compat "Julia 1.7"
+    This function requires Julia 1.7 or later.
 """
 modifyfield!
 
@@ -2266,7 +2273,7 @@ modifyfield!
     replacefield!(value, i::Int, expected, desired,
                   [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)
 
-These atomically perform the operations to get and conditionally set a field to
+Atomically perform the operations to get and conditionally set a field to
 a given value.
 
     y = getfield(value, name, fail_order)
@@ -2278,9 +2285,30 @@ a given value.
 
 If supported by the hardware, this may be optimized to the appropriate hardware
 instruction, otherwise it'll use a loop.
+
+!!! compat "Julia 1.7"
+    This function requires Julia 1.7 or later.
 """
 replacefield!
 
+"""
+    setfieldonce!(value, name::Union{Int,Symbol}, desired,
+                  [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool
+
+Atomically perform the operations to set a field to
+a given value, only if it was previously not set.
+
+    ok = !isdefined(value, name, fail_order)
+    if ok
+        setfield!(value, name, desired, success_order)
+    end
+    return ok
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+"""
+setfieldonce!
+
 """
     getglobal(module::Module, name::Symbol, [order::Symbol=:monotonic])
 
@@ -2321,6 +2349,7 @@ julia> getglobal(M, :a)
 """
 getglobal
 
+
 """
     setglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])
 
@@ -2362,6 +2391,9 @@ setglobal!
     Core.get_binding_type(module::Module, name::Symbol)
 
 Retrieve the declared type of the binding `name` from the module `module`.
+
+!!! compat "Julia 1.9"
+    This function requires Julia 1.9 or later.
 """
 Core.get_binding_type
 
@@ -2371,9 +2403,65 @@ Core.get_binding_type
 Set the declared type of the binding `name` in the module `module` to `type`. Error if the
 binding already has a type that is not equivalent to `type`. If the `type` argument is
 absent, set the binding type to `Any` if unset, but do not error.
+
+!!! compat "Julia 1.9"
+    This function requires Julia 1.9 or later.
 """
 Core.set_binding_type!
 
+"""
+    swapglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])
+
+Atomically perform the operations to simultaneously get and set a global.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+
+See also [`swapproperty!`](@ref Base.swapproperty!) and [`setglobal!`](@ref).
+"""
+swapglobal!
+
+"""
+    modifyglobal!(module::Module, name::Symbol, op, x, [order::Symbol=:monotonic]) -> Pair
+
+Atomically perform the operations to get and set a global after applying
+the function `op`.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+
+See also [`modifyproperty!`](@ref Base.modifyproperty!) and [`setglobal!`](@ref).
+"""
+modifyglobal!
+
+"""
+    replaceglobal!(module::Module, name::Symbol, expected, desired,
+                  [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)
+
+Atomically perform the operations to get and conditionally set a global to
+a given value.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+
+See also [`replaceproperty!`](@ref Base.replaceproperty!) and [`setglobal!`](@ref).
+"""
+replaceglobal!
+
+"""
+    setglobalonce!(module::Module, name::Symbol, value,
+                  [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool
+
+Atomically perform the operations to set a global to
+a given value, only if it was previously not set.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+
+See also [`setpropertyonce!`](@ref Base.setpropertyonce!) and [`setglobal!`](@ref).
+"""
+setglobalonce!
+
 """
     typeof(x)
 
@@ -3177,14 +3265,30 @@ Base.modifyproperty!
     replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
 
 Perform a compare-and-swap operation on `x.f` from `expected` to `desired`, per
-egal. The syntax `@atomic_replace! x.f expected => desired` can be used instead
+egal. The syntax `@atomicreplace x.f expected => desired` can be used instead
 of the function call form.
 
 See also [`replacefield!`](@ref Core.replacefield!)
-and [`setproperty!`](@ref Base.setproperty!).
+[`setproperty!`](@ref Base.setproperty!),
+[`setpropertyonce!`](@ref Base.setpropertyonce!).
 """
 Base.replaceproperty!
 
+"""
+    setpropertyonce!(x, f::Symbol, value, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
+
+Perform a compare-and-swap operation on `x.f` to set it to `value` if previously unset.
+The syntax `@atomiconce x.f = value` can be used instead of the function call form.
+
+See also [`setfieldonce!`](@ref Core.replacefield!),
+[`setproperty!`](@ref Base.setproperty!),
+[`replaceproperty!`](@ref Base.replaceproperty!).
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+"""
+Base.setpropertyonce!
+
 
 """
     StridedArray{T, N}
diff --git a/base/docs/intrinsicsdocs.jl b/base/docs/intrinsicsdocs.jl
index 9f6ec773ff9a8..ca06ad678bdbf 100644
--- a/base/docs/intrinsicsdocs.jl
+++ b/base/docs/intrinsicsdocs.jl
@@ -27,6 +27,9 @@ Core.Intrinsics
     Core.memoryref(::GenericMemoryRef, index::Int, [boundscheck::Bool])
 
 Return a `GenericMemoryRef` for a `GenericMemory`. See [`MemoryRef`](@ref).
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
 """
 Core.memoryref
 
@@ -34,6 +37,9 @@ Core.memoryref
     Core..memoryrefoffset(::GenericMemoryRef)
 
 Return the offset index that was used to construct the `MemoryRef`. See [`Core.memoryref`](@ref).
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
 """
 Core.memoryrefoffset
 
@@ -42,6 +48,9 @@ Core.memoryrefoffset
 
 Return the value stored at the `MemoryRef`, throwing a `BoundsError` if the `Memory` is empty. See `ref[]`.
 The memory ordering specified must be compatible with the `isatomic` parameter.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
 """
 Core.memoryrefget
 
@@ -50,6 +59,9 @@ Core.memoryrefget
 
 Store the value to the `MemoryRef`, throwing a `BoundsError` if the `Memory` is empty. See `ref[] = value`.
 The memory ordering specified must be compatible with the `isatomic` parameter.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
 """
 Core.memoryrefset!
 
@@ -59,5 +71,110 @@ Core.memoryrefset!
 Return whether there is a value stored at the `MemoryRef`, returning false if the `Memory`
 is empty. See [`isassigned(::Base.RefValue)`](@ref), [`Core.memoryrefget`](@ref).
 The memory ordering specified must be compatible with the `isatomic` parameter.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
 """
 Core.memoryref_isassigned
+
+"""
+    Core.memoryrefswap!(::GenericMemoryRef, value, ordering::Symbol, boundscheck::Bool)
+
+Atomically perform the operations to simultaneously get and set a `MemoryRef` value.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+
+See also [`swapproperty!`](@ref Base.swapproperty!) and [`Core.memoryrefset!`](@ref).
+"""
+Core.memoryrefswap!
+
+"""
+    Core.memoryrefmodify!(::GenericMemoryRef, op, value, ordering::Symbol, boundscheck::Bool) -> Pair
+
+Atomically perform the operations to get and set a `MemoryRef` value after applying
+the function `op`.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+
+See also [`modifyproperty!`](@ref Base.modifyproperty!) and [`Core.memoryrefset!`](@ref).
+"""
+Core.memoryrefmodify!
+
+"""
+    Core.memoryrefreplace!(::GenericMemoryRef, expected, desired,
+                           success_order::Symbol, fail_order::Symbol=success_order, boundscheck::Bool) -> (; old, success::Bool)
+
+Atomically perform the operations to get and conditionally set a `MemoryRef` value.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+
+See also [`replaceproperty!`](@ref Base.replaceproperty!) and [`Core.memoryrefset!`](@ref).
+"""
+Core.memoryrefreplace!
+
+"""
+    Core.memoryrefsetonce!(::GenericMemoryRef, value,
+                           success_order::Symbol, fail_order::Symbol=success_order, boundscheck::Bool) -> success::Bool
+
+Atomically perform the operations to set a `MemoryRef` to
+a given value, only if it was previously not set.
+
+!!! compat "Julia 1.11"
+    This function requires Julia 1.11 or later.
+
+See also [`setpropertyonce!`](@ref Base.replaceproperty!) and [`Core.memoryrefset!`](@ref).
+"""
+Core.memoryrefsetonce!
+
+"""
+    Core.Intrinsics.atomic_pointerref(pointer::Ptr{T}, order::Symbol) --> T
+
+!!! compat "Julia 1.7"
+    This function requires Julia 1.7 or later.
+
+See [`unsafe_load`](@ref Base.unsafe_load).
+"""
+Core.Intrinsics.atomic_pointerref
+
+"""
+    Core.Intrinsics.atomic_pointerset(pointer::Ptr{T}, new::T, order::Symbol) --> pointer
+
+!!! compat "Julia 1.7"
+    This function requires Julia 1.7 or later.
+
+See [`unsafe_store!`](@ref Base.unsafe_store!).
+"""
+Core.Intrinsics.atomic_pointerset
+
+"""
+    Core.Intrinsics.atomic_pointerswap(pointer::Ptr{T}, new::T, order::Symbol) --> old
+
+!!! compat "Julia 1.7"
+    This function requires Julia 1.7 or later.
+
+See [`unsafe_swap!`](@ref Base.unsafe_swap!).
+"""
+Core.Intrinsics.atomic_pointerswap
+
+"""
+    Core.Intrinsics.atomic_pointermodify(pointer::Ptr{T}, function::(old::T,arg::S)->T, arg::S, order::Symbol) --> old
+
+!!! compat "Julia 1.7"
+    This function requires Julia 1.7 or later.
+
+See [`unsafe_modify!`](@ref Base.unsafe_modify!).
+"""
+Core.Intrinsics.atomic_pointermodify
+
+"""
+    Core.Intrinsics.atomic_pointerreplace(pointer::Ptr{T}, expected::Any, new::T, success_order::Symbol, failure_order::Symbol) --> (old, cmp)
+
+!!! compat "Julia 1.7"
+    This function requires Julia 1.7 or later.
+
+See [`unsafe_replace!`](@ref Base.unsafe_replace!).
+"""
+Core.Intrinsics.atomic_pointerreplace
diff --git a/base/essentials.jl b/base/essentials.jl
index 51f3ac43f3a14..8e329c4f7c4d9 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -366,9 +366,14 @@ macro _nospecializeinfer_meta()
     return Expr(:meta, :nospecializeinfer)
 end
 
-getindex(A::GenericMemory{:not_atomic}, i::Int) = (@_noub_if_noinbounds_meta;
-    memoryrefget(memoryref(memoryref(A), i, @_boundscheck), :not_atomic, false))
-getindex(A::GenericMemoryRef{:not_atomic}) = memoryrefget(A, :not_atomic, @_boundscheck)
+default_access_order(a::GenericMemory{:not_atomic}) = :not_atomic
+default_access_order(a::GenericMemory{:atomic}) = :monotonic
+default_access_order(a::GenericMemoryRef{:not_atomic}) = :not_atomic
+default_access_order(a::GenericMemoryRef{:atomic}) = :monotonic
+
+getindex(A::GenericMemory, i::Int) = (@_noub_if_noinbounds_meta;
+    memoryrefget(memoryref(memoryref(A), i, @_boundscheck), default_access_order(A), false))
+getindex(A::GenericMemoryRef) = memoryrefget(A, default_access_order(A), @_boundscheck)
 
 function iterate end
 
@@ -889,8 +894,8 @@ function setindex!(A::Array{Any}, @nospecialize(x), i::Int)
     return A
 end
 setindex!(A::Memory{Any}, @nospecialize(x), i::Int) = (memoryrefset!(memoryref(memoryref(A), i, @_boundscheck), x, :not_atomic, @_boundscheck); A)
-setindex!(A::MemoryRef{T}, x) where {T} = memoryrefset!(A, convert(T, x), :not_atomic, @_boundscheck)
-setindex!(A::MemoryRef{Any}, @nospecialize(x)) = memoryrefset!(A, x, :not_atomic, @_boundscheck)
+setindex!(A::MemoryRef{T}, x) where {T} = (memoryrefset!(A, convert(T, x), :not_atomic, @_boundscheck); A)
+setindex!(A::MemoryRef{Any}, @nospecialize(x)) = (memoryrefset!(A, x, :not_atomic, @_boundscheck); A)
 
 # SimpleVector
 
diff --git a/base/exports.jl b/base/exports.jl
index a9a753d0fda52..6b783eff9179b 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -756,6 +756,7 @@ export
     swapproperty!,
     modifyproperty!,
     replaceproperty!,
+    setpropertyonce!,
     fieldoffset,
     fieldname,
     fieldnames,
@@ -1065,6 +1066,7 @@ export
     @atomic,
     @atomicswap,
     @atomicreplace,
+    @atomiconce,
     @__dot__,
     @enum,
     @label,
diff --git a/base/expr.jl b/base/expr.jl
index ab4314fbd6cc8..f6ca12f07a63d 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -1333,3 +1333,60 @@ function make_atomicreplace(success_order, fail_order, ex, old_new)
         return :(replaceproperty!($ll, $lr, $old_new::Pair..., $success_order, $fail_order))
     end
 end
+
+"""
+    @atomiconce a.b.x = value
+    @atomiconce :sequentially_consistent a.b.x = value
+    @atomiconce :sequentially_consistent :monotonic a.b.x = value
+
+Perform the conditional assignment of value atomically if it was previously
+unset, returning the value `success::Bool`. Where `success` indicates whether
+the assignment was completed.
+
+This operation translates to a `setpropertyonce!(a.b, :x, value)` call.
+
+See [Per-field atomics](@ref man-atomics) section in the manual for more details.
+
+# Examples
+```jldoctest
+julia> mutable struct AtomicOnce
+           @atomic x
+           AtomicOnce() = new()
+       end
+
+julia> a = AtomicOnce()
+AtomicOnce(#undef)
+
+julia> @atomiconce a.x = 1 # set field x of a to 1, if unset, with sequential consistency
+true
+
+julia> @atomic a.x # fetch field x of a, with sequential consistency
+1
+
+julia> @atomiconce a.x = 1 # set field x of a to 1, if unset, with sequential consistency
+false
+```
+
+!!! compat "Julia 1.11"
+    This functionality requires at least Julia 1.11.
+"""
+macro atomiconce(success_order, fail_order, ex)
+    fail_order isa QuoteNode || (fail_order = esc(fail_order))
+    success_order isa QuoteNode || (success_order = esc(success_order))
+    return make_atomiconce(success_order, fail_order, ex)
+end
+macro atomiconce(order, ex)
+    order isa QuoteNode || (order = esc(order))
+    return make_atomiconce(order, order, ex)
+end
+macro atomiconce(ex)
+    return make_atomiconce(QuoteNode(:sequentially_consistent), QuoteNode(:sequentially_consistent), ex)
+end
+function make_atomiconce(success_order, fail_order, ex)
+    @nospecialize
+    is_expr(ex, :(=), 2) || error("@atomiconce expression missing assignment")
+    l, val = ex.args[1], esc(ex.args[2])
+    is_expr(l, :., 2) || error("@atomiconce expression missing field access")
+    ll, lr = esc(l.args[1]), esc(l.args[2])
+    return :(setpropertyonce!($ll, $lr, $val, $success_order, $fail_order))
+end
diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index 13f54216581df..b5f519a0f854d 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -3,18 +3,36 @@
 ## genericmemory.jl: Managed Memory
 
 """
-    GenericMemory{kind::Symbol, T, addrspace::Int} <: AbstractVector{T}
+    GenericMemory{kind::Symbol, T, addrspace=Core.CPU} <: AbstractVector{T}
 
 One-dimensional dense array with elements of type `T`.
+
+!!! compat "Julia 1.11"
+    This type requires Julia 1.11 or later.
 """
 GenericMemory
+
 """
     Memory{T} == GenericMemory{:not_atomic, T, Core.CPU}
 
 One-dimensional dense array with elements of type `T`.
+
+!!! compat "Julia 1.11"
+    This type requires Julia 1.11 or later.
 """
 Memory
 
+"""
+    AtomicMemory{T} == GenericMemory{:atomic, T, Core.CPU}
+
+One-dimensional dense array with elements of type `T`, where each element is
+independently atomic when accessed, and cannot be set non-atomically.
+
+!!! compat "Julia 1.11"
+    This type requires Julia 1.11 or later.
+"""
+AtomicMemory
+
 ## Basic functions ##
 
 using Core: memoryrefoffset, memoryref_isassigned # import more functions which were not essential
@@ -48,6 +66,7 @@ function _unsetindex!(A::MemoryRef{T}) where T
     elseif arrayelem != isunion
         if !datatype_pointerfree(T::DataType)
             for j = 1:Core.sizeof(Ptr{Cvoid}):elsz
+                # XXX: this violates memory ordering, since it writes more than one C_NULL to each
                 Intrinsics.atomic_pointerset(p + j - 1, C_NULL, :monotonic)
             end
         end
@@ -56,17 +75,17 @@ function _unsetindex!(A::MemoryRef{T}) where T
     return A
 end
 
-elsize(@nospecialize _::Type{A}) where {T,A<:GenericMemory{<:Any,T}} = aligned_sizeof(T)
+elsize(@nospecialize _::Type{A}) where {T,A<:GenericMemory{<:Any,T}} = aligned_sizeof(T) # XXX: probably supposed to be the stride?
 sizeof(a::GenericMemory) = Core.sizeof(a)
 
 # multi arg case will be overwritten later. This is needed for bootstrapping
-function isassigned(a::Memory, i::Int)
+function isassigned(a::GenericMemory, i::Int)
     @inline
     @boundscheck (i - 1)%UInt < length(a)%UInt || return false
-    return @inbounds memoryref_isassigned(GenericMemoryRef(a, i), :not_atomic, false)
+    return @inbounds memoryref_isassigned(GenericMemoryRef(a, i), default_access_order(a), false)
 end
 
-isassigned(a::GenericMemoryRef) = memoryref_isassigned(a, :not_atomic, @_boundscheck)
+isassigned(a::GenericMemoryRef) = memoryref_isassigned(a, default_access_order(a), @_boundscheck)
 
 ## copy ##
 function unsafe_copyto!(dest::MemoryRef{T}, src::MemoryRef{T}, n) where {T}
@@ -128,11 +147,16 @@ end
 
 ## Constructors ##
 
-similar(a::Memory{T}) where {T}                   = Memory{T}(undef, length(a))
-similar(a::Memory{T}, S::Type) where {T}          = Memory{S}(undef, length(a))
-similar(a::Memory{T}, m::Int) where {T}           = Memory{T}(undef, m)
-similar(a::Memory, T::Type, dims::Dims{1})        = Memory{T}(undef, dims[1])
-similar(a::Memory{T}, dims::Dims{1}) where {T}    = Memory{T}(undef, dims[1])
+similar(a::GenericMemory) =
+    typeof(a)(undef, length(a))
+similar(a::GenericMemory{kind,<:Any,AS}, T::Type) where {kind,AS} =
+    GenericMemory{kind,T,AS}(undef, length(a))
+similar(a::GenericMemory, m::Int) =
+    typeof(a)(undef, m)
+similar(a::GenericMemory{kind,<:Any,AS}, T::Type, dims::Dims{1}) where {kind,AS} =
+    GenericMemory{kind,T,AS}(undef, dims[1])
+similar(a::GenericMemory, dims::Dims{1}) =
+    typeof(a)(undef, dims[1])
 
 function fill!(a::Union{Memory{UInt8}, Memory{Int8}}, x::Integer)
     t = @_gc_preserve_begin a
@@ -145,10 +169,9 @@ end
 
 ## Conversions ##
 
-convert(::Type{T}, a::AbstractArray) where {T<:GenericMemory} = a isa T ? a : T(a)::T
+convert(::Type{T}, a::AbstractArray) where {T<:Memory} = a isa T ? a : T(a)::T
 
 promote_rule(a::Type{Memory{T}}, b::Type{Memory{S}}) where {T,S} = el_same(promote_type(T,S), a, b)
-promote_rule(a::Type{GenericMemory{:atomic,T,Core.CPU}}, b::Type{GenericMemory{:atomic,S,Core.CPU}}) where {T,S} = el_same(promote_type(T,S), a, b)
 
 ## Constructors ##
 
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 0d1692b0ed581..64c635ed3043b 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -1,4 +1,4 @@
-# Essentials
+#replacefield Essentials
 
 ## Introduction
 
@@ -148,6 +148,7 @@ Base.setproperty!
 Base.replaceproperty!
 Base.swapproperty!
 Base.modifyproperty!
+Base.setpropertyonce!
 Base.propertynames
 Base.hasproperty
 Core.getfield
@@ -155,9 +156,8 @@ Core.setfield!
 Core.modifyfield!
 Core.replacefield!
 Core.swapfield!
+Core.setfieldonce!
 Core.isdefined
-Core.getglobal
-Core.setglobal!
 Base.@isdefined
 Base.convert
 Base.promote
@@ -461,8 +461,15 @@ Base.nameof(::Function)
 Base.functionloc(::Any, ::Any)
 Base.functionloc(::Method)
 Base.@locals
+Core.getglobal
+Core.setglobal!
+Core.modifyglobal!
+Core.swapglobal!
+Core.setglobalonce!
+Core.replaceglobal!
 ```
 
+
 ## Documentation
 (See also the [documentation](@ref man-documentation) chapter.)
 ```@docs
diff --git a/doc/src/base/multi-threading.md b/doc/src/base/multi-threading.md
index 45a60b14d541a..9e3bc49acf6dc 100644
--- a/doc/src/base/multi-threading.md
+++ b/doc/src/base/multi-threading.md
@@ -25,19 +25,13 @@ atomic
 Base.@atomic
 Base.@atomicswap
 Base.@atomicreplace
+Base.@atomiconce
+Base.AtomicMemory
 ```
 
-!!! note
-
-    The following APIs are fairly primitive, and will likely be exposed through an `unsafe_*`-like wrapper.
-
-```
-Core.Intrinsics.atomic_pointerref(pointer::Ptr{T}, order::Symbol) --> T
-Core.Intrinsics.atomic_pointerset(pointer::Ptr{T}, new::T, order::Symbol) --> pointer
-Core.Intrinsics.atomic_pointerswap(pointer::Ptr{T}, new::T, order::Symbol) --> old
-Core.Intrinsics.atomic_pointermodify(pointer::Ptr{T}, function::(old::T,arg::S)->T, arg::S, order::Symbol) --> old
-Core.Intrinsics.atomic_pointerreplace(pointer::Ptr{T}, expected::Any, new::T, success_order::Symbol, failure_order::Symbol) --> (old, cmp)
-```
+There are also optional memory ordering parameters for the `unsafe` set of functions, that
+select the C/C++-compatible versions of these atomic operations, if that parameter is specified to
+[`unsafe_load`](@ref), [`unsafe_store!`](@ref), [`unsafe_swap!`](@ref), [`unsafe_replace!`](@ref), and [`unsafe_modify!`](@ref).
 
 !!! warning
 
diff --git a/doc/src/devdocs/builtins.md b/doc/src/devdocs/builtins.md
index 02c64f4839fd7..5ce7fae16f488 100644
--- a/doc/src/devdocs/builtins.md
+++ b/doc/src/devdocs/builtins.md
@@ -12,6 +12,15 @@ Core.memoryrefoffset
 Core.memoryrefget
 Core.memoryrefset!
 Core.memoryref_isassigned
+Core.memoryrefswap!
+Core.memoryrefmodify!
+Core.memoryrefreplace!
+Core.memoryrefsetonce!
+Core.Intrinsics.atomic_pointerref
+Core.Intrinsics.atomic_pointerset
+Core.Intrinsics.atomic_pointerswap
+Core.Intrinsics.atomic_pointermodify
+Core.Intrinsics.atomic_pointerreplace
 Core.get_binding_type
 Core.set_binding_type!
 Core.IntrinsicFunction
diff --git a/doc/src/manual/multi-threading.md b/doc/src/manual/multi-threading.md
index 71e49e65b19a8..085c6b835c87c 100644
--- a/doc/src/manual/multi-threading.md
+++ b/doc/src/manual/multi-threading.md
@@ -385,8 +385,9 @@ julia> acc[]
 #### [Per-field atomics](@id man-atomics)
 
 We can also use atomics on a more granular level using the [`@atomic`](@ref
-Base.@atomic), [`@atomicswap`](@ref Base.@atomicswap), and
-[`@atomicreplace`](@ref Base.@atomicreplace) macros.
+Base.@atomic), [`@atomicswap`](@ref Base.@atomicswap),
+[`@atomicreplace`](@ref Base.@atomicreplace) macros, and
+[`@atomiconce`](@ref Base.@atomiconce) macros.
 
 Specific details of the memory model and other details of the design are written
 in the [Julia Atomics
diff --git a/src/builtin_proto.h b/src/builtin_proto.h
index a009b535ac951..b0536bef24e27 100644
--- a/src/builtin_proto.h
+++ b/src/builtin_proto.h
@@ -21,48 +21,57 @@ extern "C" {
     JL_DLLEXPORT extern jl_fptr_args_t jl_f_##name##_addr
 #endif
 
-DECLARE_BUILTIN(applicable);
 DECLARE_BUILTIN(_apply_iterate);
 DECLARE_BUILTIN(_apply_pure);
-DECLARE_BUILTIN(apply_type);
-DECLARE_BUILTIN(memoryref);
-DECLARE_BUILTIN(memoryrefoffset);
-DECLARE_BUILTIN(memoryrefget);
-DECLARE_BUILTIN(memoryrefset);
-DECLARE_BUILTIN(memoryref_isassigned);
 DECLARE_BUILTIN(_call_in_world);
 DECLARE_BUILTIN(_call_in_world_total);
 DECLARE_BUILTIN(_call_latest);
-DECLARE_BUILTIN(replacefield);
+DECLARE_BUILTIN(_compute_sparams);
 DECLARE_BUILTIN(_expr);
+DECLARE_BUILTIN(_svec_ref);
+DECLARE_BUILTIN(_typebody);
+DECLARE_BUILTIN(_typevar);
+DECLARE_BUILTIN(applicable);
+DECLARE_BUILTIN(apply_type);
+DECLARE_BUILTIN(compilerbarrier);
+DECLARE_BUILTIN(current_scope);
+DECLARE_BUILTIN(donotdelete);
 DECLARE_BUILTIN(fieldtype);
+DECLARE_BUILTIN(finalizer);
 DECLARE_BUILTIN(getfield);
+DECLARE_BUILTIN(getglobal);
 DECLARE_BUILTIN(ifelse);
 DECLARE_BUILTIN(invoke);
 DECLARE_BUILTIN(is);
 DECLARE_BUILTIN(isa);
 DECLARE_BUILTIN(isdefined);
 DECLARE_BUILTIN(issubtype);
+DECLARE_BUILTIN(memoryref);
+DECLARE_BUILTIN(memoryref_isassigned);
+DECLARE_BUILTIN(memoryrefget);
+DECLARE_BUILTIN(memoryrefmodify);
+DECLARE_BUILTIN(memoryrefoffset);
+DECLARE_BUILTIN(memoryrefreplace);
+DECLARE_BUILTIN(memoryrefset);
+DECLARE_BUILTIN(memoryrefsetonce);
+DECLARE_BUILTIN(memoryrefswap);
 DECLARE_BUILTIN(modifyfield);
+DECLARE_BUILTIN(modifyglobal);
 DECLARE_BUILTIN(nfields);
+DECLARE_BUILTIN(replacefield);
+DECLARE_BUILTIN(replaceglobal);
 DECLARE_BUILTIN(setfield);
+DECLARE_BUILTIN(setfieldonce);
+DECLARE_BUILTIN(setglobal);
+DECLARE_BUILTIN(setglobalonce);
 DECLARE_BUILTIN(sizeof);
 DECLARE_BUILTIN(svec);
 DECLARE_BUILTIN(swapfield);
+DECLARE_BUILTIN(swapglobal);
 DECLARE_BUILTIN(throw);
 DECLARE_BUILTIN(tuple);
 DECLARE_BUILTIN(typeassert);
-DECLARE_BUILTIN(_typebody);
 DECLARE_BUILTIN(typeof);
-DECLARE_BUILTIN(_typevar);
-DECLARE_BUILTIN(donotdelete);
-DECLARE_BUILTIN(compilerbarrier);
-DECLARE_BUILTIN(getglobal);
-DECLARE_BUILTIN(setglobal);
-DECLARE_BUILTIN(finalizer);
-DECLARE_BUILTIN(_compute_sparams);
-DECLARE_BUILTIN(_svec_ref);
-DECLARE_BUILTIN(current_scope);
 
 JL_CALLABLE(jl_f__structtype);
 JL_CALLABLE(jl_f__abstracttype);
diff --git a/src/builtins.c b/src/builtins.c
index 3c4e8215fc572..412ccaf8bab04 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -626,7 +626,7 @@ STATIC_INLINE void _grow_to(jl_value_t **root, jl_value_t ***oldargs, jl_svec_t
 
 static jl_value_t *jl_arrayref(jl_array_t *a, size_t i)
 {
-    return jl_memoryrefget(jl_memoryrefindex(a->ref, i));
+    return jl_memoryrefget(jl_memoryrefindex(a->ref, i), 0);
 }
 
 static jl_value_t *do_apply(jl_value_t **args, uint32_t nargs, jl_value_t *iterate)
@@ -1035,9 +1035,11 @@ JL_CALLABLE(jl_f_getfield)
         jl_atomic_error("getfield: non-atomic field cannot be accessed atomically");
     if (isatomic && order == jl_memory_order_notatomic)
         jl_atomic_error("getfield: atomic field cannot be accessed non-atomically");
-    v = jl_get_nth_field_checked(v, idx);
-    if (order >= jl_memory_order_acq_rel || order == jl_memory_order_acquire)
-        jl_fence(); // `v` already had at least consume ordering
+    if (order >= jl_memory_order_seq_cst)
+        jl_fence();
+    v = jl_get_nth_field_checked(v, idx); // `v` already had at least consume ordering
+    if (order >= jl_memory_order_acquire)
+        jl_fence();
     return v;
 }
 
@@ -1059,7 +1061,7 @@ JL_CALLABLE(jl_f_setfield)
     jl_value_t *ft = jl_field_type_concrete(st, idx);
     if (!jl_isa(args[2], ft))
         jl_type_error("setfield!", ft, args[2]);
-    if (order >= jl_memory_order_acq_rel || order == jl_memory_order_release)
+    if (order >= jl_memory_order_release)
         jl_fence(); // `st->[idx]` will have at least relaxed ordering
     set_nth_field(st, v, idx, args[2], isatomic);
     return args[2];
@@ -1133,6 +1135,35 @@ JL_CALLABLE(jl_f_replacefield)
     return v;
 }
 
+JL_CALLABLE(jl_f_setfieldonce)
+{
+    enum jl_memory_order success_order = jl_memory_order_notatomic;
+    JL_NARGS(setfieldonce!, 3, 5);
+    if (nargs >= 4) {
+        JL_TYPECHK(setfieldonce!, symbol, args[3]);
+        success_order = jl_get_atomic_order_checked((jl_sym_t*)args[3], 1, 1);
+    }
+    enum jl_memory_order failure_order = success_order;
+    if (nargs == 5) {
+        JL_TYPECHK(setfieldonce!, symbol, args[4]);
+        failure_order = jl_get_atomic_order_checked((jl_sym_t*)args[4], 1, 0);
+    }
+    if (failure_order > success_order)
+        jl_atomic_error("invalid atomic ordering");
+    // TODO: filter more invalid ordering combinations?
+    jl_value_t *v = args[0];
+    jl_datatype_t *st = (jl_datatype_t*)jl_typeof(v);
+    size_t idx = get_checked_fieldindex("setfieldonce!", st, v, args[1], 1);
+    int isatomic = !!jl_field_isatomic(st, idx);
+    if (isatomic == (success_order == jl_memory_order_notatomic))
+        jl_atomic_error(isatomic ? "setfieldonce!: atomic field cannot be written non-atomically"
+                                 : "setfieldonce!: non-atomic field cannot be written atomically");
+    if (isatomic == (failure_order == jl_memory_order_notatomic))
+        jl_atomic_error(isatomic ? "setfieldonce!: atomic field cannot be accessed non-atomically"
+                                 : "setfieldonce!: non-atomic field cannot be accessed atomically");
+    int success = set_nth_fieldonce(st, v, idx, args[2], isatomic); // always seq_cst, if isatomic needed at all
+    return success ? jl_true : jl_false;
+}
 
 static jl_value_t *get_fieldtype(jl_value_t *t, jl_value_t *f, int dothrow)
 {
@@ -1241,7 +1272,12 @@ JL_CALLABLE(jl_f_isdefined)
         JL_TYPECHK(isdefined, symbol, args[1]);
         m = (jl_module_t*)args[0];
         s = (jl_sym_t*)args[1];
-        return jl_boundp(m, s) ? jl_true : jl_false; // is seq_cst already
+        if (order == jl_memory_order_unspecified)
+            order = jl_memory_order_unordered;
+        if (order < jl_memory_order_unordered)
+            jl_atomic_error("isdefined: module binding cannot be accessed non-atomically");
+        int bound = jl_boundp(m, s); // seq_cst always
+        return bound ? jl_true : jl_false;
     }
     jl_datatype_t *vt = (jl_datatype_t*)jl_typeof(args[0]);
     assert(jl_is_datatype(vt));
@@ -1268,15 +1304,11 @@ JL_CALLABLE(jl_f_isdefined)
         jl_atomic_error("isdefined: non-atomic field cannot be accessed atomically");
     if (isatomic && order == jl_memory_order_notatomic)
         jl_atomic_error("isdefined: atomic field cannot be accessed non-atomically");
-    int v = jl_field_isdefined(args[0], idx);
-    if (v == 2) {
-        if (order > jl_memory_order_notatomic)
-            jl_fence(); // isbits case has no ordering already
-    }
-    else {
-        if (order >= jl_memory_order_acq_rel || order == jl_memory_order_acquire)
-            jl_fence(); // `v` already gave at least consume ordering
-    }
+    if (order >= jl_memory_order_seq_cst)
+        jl_fence();
+    int v = jl_field_isdefined(args[0], idx); // relaxed ordering
+    if (order >= jl_memory_order_acquire)
+        jl_fence();
     return v ? jl_true : jl_false;
 }
 
@@ -1297,8 +1329,11 @@ JL_CALLABLE(jl_f_getglobal)
     JL_TYPECHK(getglobal, symbol, (jl_value_t*)sym);
     if (order == jl_memory_order_notatomic)
         jl_atomic_error("getglobal: module binding cannot be read non-atomically");
-    jl_value_t *v = jl_eval_global_var(mod, sym);
-    // is seq_cst already, no fence needed
+    else if (order >= jl_memory_order_seq_cst)
+        jl_fence();
+    jl_value_t *v = jl_eval_global_var(mod, sym); // relaxed load
+    if (order >= jl_memory_order_acquire)
+        jl_fence();
     return v;
 }
 
@@ -1316,9 +1351,12 @@ JL_CALLABLE(jl_f_setglobal)
     JL_TYPECHK(setglobal!, symbol, (jl_value_t*)var);
     if (order == jl_memory_order_notatomic)
         jl_atomic_error("setglobal!: module binding cannot be written non-atomically");
-    // is seq_cst already, no fence needed
+    else if (order >= jl_memory_order_seq_cst)
+        jl_fence();
     jl_binding_t *b = jl_get_binding_wr(mod, var);
-    jl_checked_assignment(b, mod, var, args[2]);
+    jl_checked_assignment(b, mod, var, args[2]); // release store
+    if (order >= jl_memory_order_seq_cst)
+        jl_fence();
     return args[2];
 }
 
@@ -1365,6 +1403,104 @@ JL_CALLABLE(jl_f_set_binding_type)
     return jl_nothing;
 }
 
+JL_CALLABLE(jl_f_swapglobal)
+{
+    enum jl_memory_order order = jl_memory_order_release;
+    JL_NARGS(swapglobal!, 3, 4);
+    if (nargs == 4) {
+        JL_TYPECHK(swapglobal!, symbol, args[3]);
+        order = jl_get_atomic_order_checked((jl_sym_t*)args[3], 1, 1);
+    }
+    jl_module_t *mod = (jl_module_t*)args[0];
+    jl_sym_t *var = (jl_sym_t*)args[1];
+    JL_TYPECHK(swapglobal!, module, (jl_value_t*)mod);
+    JL_TYPECHK(swapglobal!, symbol, (jl_value_t*)var);
+    if (order == jl_memory_order_notatomic)
+        jl_atomic_error("swapglobal!: module binding cannot be written non-atomically");
+    // is seq_cst already, no fence needed
+    jl_binding_t *b = jl_get_binding_wr(mod, var);
+    return jl_checked_swap(b, mod, var, args[2]);
+}
+
+JL_CALLABLE(jl_f_modifyglobal)
+{
+    enum jl_memory_order order = jl_memory_order_release;
+    JL_NARGS(modifyglobal!, 4, 5);
+    if (nargs == 5) {
+        JL_TYPECHK(modifyglobal!, symbol, args[4]);
+        order = jl_get_atomic_order_checked((jl_sym_t*)args[4], 1, 1);
+    }
+    jl_module_t *mod = (jl_module_t*)args[0];
+    jl_sym_t *var = (jl_sym_t*)args[1];
+    JL_TYPECHK(modifyglobal!, module, (jl_value_t*)mod);
+    JL_TYPECHK(modifyglobal!, symbol, (jl_value_t*)var);
+    if (order == jl_memory_order_notatomic)
+        jl_atomic_error("modifyglobal!: module binding cannot be written non-atomically");
+    jl_binding_t *b = jl_get_binding_wr(mod, var);
+    // is seq_cst already, no fence needed
+    return jl_checked_modify(b, mod, var, args[2], args[3]);
+}
+
+JL_CALLABLE(jl_f_replaceglobal)
+{
+    enum jl_memory_order success_order = jl_memory_order_release;
+    JL_NARGS(replaceglobal!, 4, 6);
+    if (nargs >= 5) {
+        JL_TYPECHK(replaceglobal!, symbol, args[4]);
+        success_order = jl_get_atomic_order_checked((jl_sym_t*)args[4], 1, 1);
+    }
+    enum jl_memory_order failure_order = success_order;
+    if (nargs == 6) {
+        JL_TYPECHK(replaceglobal!, symbol, args[5]);
+        failure_order = jl_get_atomic_order_checked((jl_sym_t*)args[5], 1, 0);
+    }
+    if (failure_order > success_order)
+        jl_atomic_error("invalid atomic ordering");
+    // TODO: filter more invalid ordering combinations?
+    jl_module_t *mod = (jl_module_t*)args[0];
+    jl_sym_t *var = (jl_sym_t*)args[1];
+    JL_TYPECHK(replaceglobal!, module, (jl_value_t*)mod);
+    JL_TYPECHK(replaceglobal!, symbol, (jl_value_t*)var);
+    if (success_order == jl_memory_order_notatomic)
+        jl_atomic_error("replaceglobal!: module binding cannot be written non-atomically");
+    if (failure_order == jl_memory_order_notatomic)
+        jl_atomic_error("replaceglobal!: module binding cannot be accessed non-atomically");
+    jl_binding_t *b = jl_get_binding_wr(mod, var);
+    // is seq_cst already, no fence needed
+    return jl_checked_replace(b, mod, var, args[2], args[3]);
+}
+
+JL_CALLABLE(jl_f_setglobalonce)
+{
+    enum jl_memory_order success_order = jl_memory_order_release;
+    JL_NARGS(setglobalonce!, 3, 5);
+    if (nargs >= 4) {
+        JL_TYPECHK(setglobalonce!, symbol, args[3]);
+        success_order = jl_get_atomic_order_checked((jl_sym_t*)args[3], 1, 1);
+    }
+    enum jl_memory_order failure_order = success_order;
+    if (nargs == 5) {
+        JL_TYPECHK(setglobalonce!, symbol, args[4]);
+        failure_order = jl_get_atomic_order_checked((jl_sym_t*)args[4], 1, 0);
+    }
+    if (failure_order > success_order)
+        jl_atomic_error("invalid atomic ordering");
+    // TODO: filter more invalid ordering combinations?
+    jl_module_t *mod = (jl_module_t*)args[0];
+    jl_sym_t *var = (jl_sym_t*)args[1];
+    JL_TYPECHK(setglobalonce!, module, (jl_value_t*)mod);
+    JL_TYPECHK(setglobalonce!, symbol, (jl_value_t*)var);
+    if (success_order == jl_memory_order_notatomic)
+        jl_atomic_error("setglobalonce!: module binding cannot be written non-atomically");
+    if (failure_order == jl_memory_order_notatomic)
+        jl_atomic_error("setglobalonce!: module binding cannot be accessed non-atomically");
+    jl_binding_t *b = jl_get_binding_wr(mod, var);
+    // is seq_cst already, no fence needed
+    jl_value_t *old = jl_checked_assignonce(b, mod, var, args[2]);
+    return old == NULL ? jl_true : jl_false;
+}
+
+
 
 // apply_type -----------------------------------------------------------------
 
@@ -1590,51 +1726,197 @@ JL_CALLABLE(jl_f_memoryrefoffset)
 
 JL_CALLABLE(jl_f_memoryrefget)
 {
+    enum jl_memory_order order = jl_memory_order_notatomic;
     JL_NARGS(memoryrefget, 3, 3);
     JL_TYPECHK(memoryrefget, genericmemoryref, args[0]);
     JL_TYPECHK(memoryrefget, symbol, args[1]);
     JL_TYPECHK(memoryrefget, bool, args[2]);
     jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
-    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem));
-    if (isatomic == jl_false)
-        if (args[1] != (jl_value_t*)jl_not_atomic_sym)
-            jl_atomic_error("memoryrefget!: non-atomic memory cannot be accessed atomically");
+    jl_value_t *kind = jl_tparam0(jl_typetagof(m.mem));
+    if (kind == (jl_value_t*)jl_not_atomic_sym) {
+        if (args[1] != kind) {
+            order = jl_get_atomic_order_checked((jl_sym_t*)args[1], 1, 0);
+            jl_atomic_error("memoryrefget: non-atomic memory cannot be accessed atomically");
+        }
+    }
+    else if (kind == (jl_value_t*)jl_atomic_sym) {
+        order = jl_get_atomic_order_checked((jl_sym_t*)args[1], 1, 0);
+        if (order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryrefget: atomic memory cannot be accessed non-atomically");
+    }
     if (m.mem->length == 0)
         jl_bounds_error_int((jl_value_t*)m.mem, 1);
-    return jl_memoryrefget(m);
+    return jl_memoryrefget(m, kind == (jl_value_t*)jl_atomic_sym);
 }
 
 JL_CALLABLE(jl_f_memoryrefset)
 {
+    enum jl_memory_order order = jl_memory_order_notatomic;
     JL_NARGS(memoryrefset!, 4, 4);
     JL_TYPECHK(memoryrefset!, genericmemoryref, args[0]);
     JL_TYPECHK(memoryrefset!, symbol, args[2]);
     JL_TYPECHK(memoryrefset!, bool, args[3]);
     jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
-    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem));
-    if (isatomic == jl_false)
-        if (args[2] != (jl_value_t*)jl_not_atomic_sym)
+    jl_value_t *kind = jl_tparam0(jl_typetagof(m.mem));
+    if (kind == (jl_value_t*)jl_not_atomic_sym) {
+        if (args[2] != kind) {
+            order = jl_get_atomic_order_checked((jl_sym_t*)args[2], 0, 1);
             jl_atomic_error("memoryrefset!: non-atomic memory cannot be written atomically");
+        }
+    }
+    else if (kind == (jl_value_t*)jl_atomic_sym) {
+        order = jl_get_atomic_order_checked((jl_sym_t*)args[2], 0, 1);
+        if (order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryrefset!: atomic memory cannot be written non-atomically");
+    }
     if (m.mem->length == 0)
         jl_bounds_error_int((jl_value_t*)m.mem, 1);
-    jl_memoryrefset(m, args[1]);
-    return args[0];
+    jl_memoryrefset(m, args[1], kind == (jl_value_t*)jl_atomic_sym);
+    return args[1];
 }
 
 JL_CALLABLE(jl_f_memoryref_isassigned)
 {
+    enum jl_memory_order order = jl_memory_order_notatomic;
     JL_NARGS(memoryref_isassigned, 3, 3);
     JL_TYPECHK(memoryref_isassigned, genericmemoryref, args[0]);
     JL_TYPECHK(memoryref_isassigned, symbol, args[1]);
     JL_TYPECHK(memoryref_isassigned, bool, args[2]);
     jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
-    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem));
-    if (isatomic == jl_false)
-        if (args[1] != (jl_value_t*)jl_not_atomic_sym)
-            jl_atomic_error("memoryref_isassigned!: non-atomic memory cannot be accessed atomically");
+    jl_value_t *kind = jl_tparam0(jl_typetagof(m.mem));
+    if (kind == (jl_value_t*)jl_not_atomic_sym) {
+        if (args[1] != kind) {
+            order = jl_get_atomic_order_checked((jl_sym_t*)args[1], 1, 0);
+            jl_atomic_error("memoryref_isassigned: non-atomic memory cannot be accessed atomically");
+        }
+    }
+    else if (kind == (jl_value_t*)jl_atomic_sym) {
+        order = jl_get_atomic_order_checked((jl_sym_t*)args[1], 1, 0);
+        if (order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryref_isassigned: atomic memory cannot be accessed non-atomically");
+    }
     if (m.mem->length == 0)
+        // TODO(jwn): decide on the fences required for ordering here
         return jl_false;
-    return jl_memoryref_isassigned(m);
+    return jl_memoryref_isassigned(m, kind == (jl_value_t*)jl_atomic_sym);
+}
+
+JL_CALLABLE(jl_f_memoryrefswap)
+{
+    enum jl_memory_order order = jl_memory_order_notatomic;
+    JL_NARGS(memoryrefswap!, 4, 4);
+    JL_TYPECHK(memoryrefswap!, genericmemoryref, args[0]);
+    JL_TYPECHK(memoryrefswap!, symbol, args[2]);
+    JL_TYPECHK(memoryrefswap!, bool, args[3]);
+    jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
+    jl_value_t *kind = jl_tparam0(jl_typetagof(m.mem));
+    if (kind == (jl_value_t*)jl_not_atomic_sym) {
+        if (args[2] != kind) {
+            order = jl_get_atomic_order_checked((jl_sym_t*)args[2], 1, 1);
+            jl_atomic_error("memoryrefswap!: non-atomic memory cannot be written atomically");
+        }
+    }
+    else if (kind == (jl_value_t*)jl_atomic_sym) {
+        order = jl_get_atomic_order_checked((jl_sym_t*)args[2], 1, 1);
+        if (order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryrefswap!: atomic memory cannot be written non-atomically");
+    }
+    if (m.mem->length == 0)
+        jl_bounds_error_int((jl_value_t*)m.mem, 1);
+    return jl_memoryrefswap(m, args[1], kind == (jl_value_t*)jl_atomic_sym);
+}
+
+JL_CALLABLE(jl_f_memoryrefmodify)
+{
+    enum jl_memory_order order = jl_memory_order_notatomic;
+    JL_NARGS(memoryrefmodify!, 5, 5);
+    JL_TYPECHK(memoryrefmodify!, genericmemoryref, args[0]);
+    JL_TYPECHK(memoryrefmodify!, symbol, args[3]);
+    JL_TYPECHK(memoryrefmodify!, bool, args[4]);
+    jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
+    jl_value_t *kind = jl_tparam0(jl_typetagof(m.mem));
+    if (kind == (jl_value_t*)jl_not_atomic_sym) {
+        if (args[3] != kind) {
+            order = jl_get_atomic_order_checked((jl_sym_t*)args[3], 1, 1);
+            jl_atomic_error("memoryrefmodify!: non-atomic memory cannot be written atomically");
+        }
+    }
+    else if (kind == (jl_value_t*)jl_atomic_sym) {
+        order = jl_get_atomic_order_checked((jl_sym_t*)args[3], 1, 1);
+        if (order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryrefmodify!: atomic memory cannot be written non-atomically");
+    }
+    if (m.mem->length == 0)
+        jl_bounds_error_int((jl_value_t*)m.mem, 1);
+    return jl_memoryrefmodify(m, args[1], args[2], kind == (jl_value_t*)jl_atomic_sym);
+}
+
+JL_CALLABLE(jl_f_memoryrefreplace)
+{
+    enum jl_memory_order success_order = jl_memory_order_notatomic;
+    enum jl_memory_order failure_order = jl_memory_order_notatomic;
+    JL_NARGS(memoryrefreplace!, 6, 6);
+    JL_TYPECHK(memoryrefreplace!, genericmemoryref, args[0]);
+    JL_TYPECHK(memoryrefreplace!, symbol, args[3]);
+    JL_TYPECHK(memoryrefreplace!, symbol, args[4]);
+    JL_TYPECHK(memoryrefreplace!, bool, args[5]);
+    jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
+    jl_value_t *kind = jl_tparam0(jl_typetagof(m.mem));
+    if (kind == (jl_value_t*)jl_not_atomic_sym) {
+        if (args[4] != kind)
+            jl_atomic_error("invalid atomic ordering"); // because either it is invalid, or failure_order > success_order
+        if (args[3] != kind) {
+            success_order = jl_get_atomic_order_checked((jl_sym_t*)args[3], 1, 1);
+            jl_atomic_error("memoryrefreplace!: non-atomic memory cannot be written atomically");
+        }
+    }
+    else if (kind == (jl_value_t*)jl_atomic_sym) {
+        success_order = jl_get_atomic_order_checked((jl_sym_t*)args[3], 1, 1);
+        failure_order = jl_get_atomic_order_checked((jl_sym_t*)args[4], 1, 0);
+        if (failure_order > success_order)
+            jl_atomic_error("invalid atomic ordering"); // because either it is invalid, or failure_order > success_order
+        if (success_order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryrefreplace!: atomic memory cannot be written non-atomically");
+        if (failure_order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryrefreplace!: atomic memory cannot be accessed non-atomically");
+    }
+    if (m.mem->length == 0)
+        jl_bounds_error_int((jl_value_t*)m.mem, 1);
+    return jl_memoryrefreplace(m, args[1], args[2], kind == (jl_value_t*)jl_atomic_sym);
+}
+
+JL_CALLABLE(jl_f_memoryrefsetonce)
+{
+    enum jl_memory_order success_order = jl_memory_order_notatomic;
+    enum jl_memory_order failure_order = jl_memory_order_notatomic;
+    JL_NARGS(memoryrefsetonce!, 5, 5);
+    JL_TYPECHK(memoryrefsetonce!, genericmemoryref, args[0]);
+    JL_TYPECHK(memoryrefsetonce!, symbol, args[2]);
+    JL_TYPECHK(memoryrefsetonce!, symbol, args[3]);
+    JL_TYPECHK(memoryrefsetonce!, bool, args[4]);
+    jl_genericmemoryref_t m = *(jl_genericmemoryref_t*)args[0];
+    jl_value_t *kind = jl_tparam0(jl_typetagof(m.mem));
+    if (kind == (jl_value_t*)jl_not_atomic_sym) {
+        if (args[3] != kind)
+            jl_atomic_error("invalid atomic ordering"); // because either it is invalid, or failure_order > success_order
+        if (args[2] != kind) {
+            success_order = jl_get_atomic_order_checked((jl_sym_t*)args[2], 1, 1);
+            jl_atomic_error("memoryrefsetonce!: non-atomic memory cannot be written atomically");
+        }
+    }
+    else if (kind == (jl_value_t*)jl_atomic_sym) {
+        success_order = jl_get_atomic_order_checked((jl_sym_t*)args[2], 1, 1);
+        failure_order = jl_get_atomic_order_checked((jl_sym_t*)args[3], 1, 0);
+        if (failure_order > success_order)
+            jl_atomic_error("invalid atomic ordering"); // because either it is invalid, or failure_order > success_order
+        if (success_order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryrefsetonce!: atomic memory cannot be written non-atomically");
+        if (failure_order == jl_memory_order_notatomic)
+            jl_atomic_error("memoryrefsetonce!: atomic memory cannot be accessed non-atomically");
+    }
+    if (m.mem->length == 0)
+        jl_bounds_error_int((jl_value_t*)m.mem, 1);
+    return jl_memoryrefsetonce(m, args[1], kind == (jl_value_t*)jl_atomic_sym);
 }
 
 // type definition ------------------------------------------------------------
@@ -2119,6 +2401,7 @@ void jl_init_primitives(void) JL_GC_DISABLED
     // field access
     jl_builtin_getfield = add_builtin_func("getfield",  jl_f_getfield);
     jl_builtin_setfield = add_builtin_func("setfield!",  jl_f_setfield);
+    jl_builtin_setfieldonce = add_builtin_func("setfieldonce!",  jl_f_setfieldonce);
     jl_builtin_swapfield = add_builtin_func("swapfield!",  jl_f_swapfield);
     jl_builtin_modifyfield = add_builtin_func("modifyfield!",  jl_f_modifyfield);
     jl_builtin_replacefield = add_builtin_func("replacefield!",  jl_f_replacefield);
@@ -2131,6 +2414,10 @@ void jl_init_primitives(void) JL_GC_DISABLED
     jl_builtin_setglobal = add_builtin_func("setglobal!", jl_f_setglobal);
     add_builtin_func("get_binding_type", jl_f_get_binding_type);
     add_builtin_func("set_binding_type!", jl_f_set_binding_type);
+    jl_builtin_swapglobal = add_builtin_func("swapglobal!", jl_f_swapglobal);
+    jl_builtin_replaceglobal = add_builtin_func("replaceglobal!", jl_f_replaceglobal);
+    jl_builtin_modifyglobal = add_builtin_func("modifyglobal!", jl_f_modifyglobal);
+    jl_builtin_setglobalonce = add_builtin_func("setglobalonce!", jl_f_setglobalonce);
 
     // memory primitives
     jl_builtin_memoryref = add_builtin_func("memoryref", jl_f_memoryref);
@@ -2138,6 +2425,10 @@ void jl_init_primitives(void) JL_GC_DISABLED
     jl_builtin_memoryrefget = add_builtin_func("memoryrefget", jl_f_memoryrefget);
     jl_builtin_memoryrefset = add_builtin_func("memoryrefset!", jl_f_memoryrefset);
     jl_builtin_memoryref_isassigned = add_builtin_func("memoryref_isassigned", jl_f_memoryref_isassigned);
+    jl_builtin_memoryrefswap = add_builtin_func("memoryrefswap!", jl_f_memoryrefswap);
+    jl_builtin_memoryrefreplace = add_builtin_func("memoryrefreplace!", jl_f_memoryrefreplace);
+    jl_builtin_memoryrefmodify = add_builtin_func("memoryrefmodify!", jl_f_memoryrefmodify);
+    jl_builtin_memoryrefsetonce = add_builtin_func("memoryrefsetonce!", jl_f_memoryrefsetonce);
 
     // method table utils
     jl_builtin_applicable = add_builtin_func("applicable", jl_f_applicable);
diff --git a/src/ccall.cpp b/src/ccall.cpp
index 92ede74402791..b71d86623065f 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -669,7 +669,7 @@ static void interpret_symbol_arg(jl_codectx_t &ctx, native_sym_arg_t &out, jl_va
 
 // --- code generator for cglobal ---
 
-static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, const jl_cgval_t *argv, size_t nargs);
+static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, ArrayRef<jl_cgval_t> argv, size_t nargs);
 
 static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
 {
@@ -684,7 +684,7 @@ static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t narg
         rt = static_eval(ctx, args[2]);
         if (rt == NULL) {
             JL_GC_POP();
-            jl_cgval_t argv[2] = {jl_cgval_t(), jl_cgval_t()};
+            jl_cgval_t argv[2];
             argv[0] = emit_expr(ctx, args[1]);
             argv[1] = emit_expr(ctx, args[2]);
             return emit_runtime_call(ctx, JL_I::cglobal, argv, nargs);
@@ -1999,7 +1999,7 @@ jl_cgval_t function_sig_t::emit_a_ccall(
     }
     else if (symarg.jl_ptr != NULL) {
         ++LiteralCCalls;
-        null_pointer_check(ctx, symarg.jl_ptr);
+        null_pointer_check(ctx, symarg.jl_ptr, nullptr);
         Type *funcptype = PointerType::get(functype, 0);
         llvmf = emit_inttoptr(ctx, symarg.jl_ptr, funcptype);
     }
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 2a53cf0528694..007e4c5936a4f 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1381,16 +1381,31 @@ static void raise_exception_unless(jl_codectx_t &ctx, Value *cond, Value *exc)
     raise_exception(ctx, exc, passBB);
 }
 
+static void undef_var_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *name, jl_value_t *scope)
+{
+    ++EmittedUndefVarErrors;
+    BasicBlock *err = BasicBlock::Create(ctx.builder.getContext(), "err", ctx.f);
+    BasicBlock *ifok = BasicBlock::Create(ctx.builder.getContext(), "ok");
+    ctx.builder.CreateCondBr(ok, ifok, err);
+    ctx.builder.SetInsertPoint(err);
+    ctx.builder.CreateCall(prepare_call(jlundefvarerror_func), {
+            mark_callee_rooted(ctx, literal_pointer_val(ctx, (jl_value_t*)name)),
+            mark_callee_rooted(ctx, literal_pointer_val(ctx, scope))});
+    ctx.builder.CreateUnreachable();
+    ifok->insertInto(ctx.f);
+    ctx.builder.SetInsertPoint(ifok);
+}
+
 static Value *null_pointer_cmp(jl_codectx_t &ctx, Value *v)
 {
     ++EmittedNullchecks;
-    return ctx.builder.CreateICmpNE(v, Constant::getNullValue(v->getType()));
+    return ctx.builder.CreateIsNotNull(v);
 }
 
 
 // If `nullcheck` is not NULL and a pointer NULL check is necessary
 // store the pointer to be checked in `*nullcheck` instead of checking it
-static void null_pointer_check(jl_codectx_t &ctx, Value *v, Value **nullcheck = nullptr)
+static void null_pointer_check(jl_codectx_t &ctx, Value *v, Value **nullcheck)
 {
     if (nullcheck) {
         *nullcheck = v;
@@ -1400,6 +1415,16 @@ static void null_pointer_check(jl_codectx_t &ctx, Value *v, Value **nullcheck =
             literal_pointer_val(ctx, jl_undefref_exception));
 }
 
+
+static void null_load_check(jl_codectx_t &ctx, Value *v, jl_module_t *scope, jl_sym_t *name)
+{
+    Value *notnull = null_pointer_cmp(ctx, v);
+    if (name && scope)
+        undef_var_error_ifnot(ctx, notnull, name, (jl_value_t*)scope);
+    else
+        raise_exception_unless(ctx, notnull, literal_pointer_val(ctx, jl_undefref_exception));
+}
+
 template<typename Func>
 static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, Value *defval, Func &&func)
 {
@@ -1887,16 +1912,16 @@ Value *extract_first_ptr(jl_codectx_t &ctx, Value *V)
 static void emit_lockstate_value(jl_codectx_t &ctx, Value *strct, bool newstate)
 {
     ++EmittedLockstates;
-    Value *v = mark_callee_rooted(ctx, strct);
-    ctx.builder.CreateCall(prepare_call(newstate ? jllockvalue_func : jlunlockvalue_func), v);
-}
-static void emit_lockstate_value(jl_codectx_t &ctx, const jl_cgval_t &strct, bool newstate)
-{
-    assert(strct.isboxed);
-    emit_lockstate_value(ctx, boxed(ctx, strct), newstate);
+    if (strct->getType()->getPointerAddressSpace() == AddressSpace::Loaded) {
+        Value *v = emit_bitcast(ctx, strct, PointerType::get(ctx.types().T_jlvalue, AddressSpace::Loaded));
+        ctx.builder.CreateCall(prepare_call(newstate ? jllockfield_func : jlunlockfield_func), v);
+    }
+    else {
+        Value *v = mark_callee_rooted(ctx, strct);
+        ctx.builder.CreateCall(prepare_call(newstate ? jllockvalue_func : jlunlockvalue_func), v);
+    }
 }
 
-
 // If `nullcheck` is not NULL and a pointer NULL check is necessary
 // store the pointer to be checked in `*nullcheck` instead of checking it
 static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, jl_value_t *jltype,
@@ -1906,8 +1931,11 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j
 {
     // TODO: we should use unordered loads for anything with CountTrackedPointers(elty).count > 0 (if not otherwise locked)
     Type *elty = isboxed ? ctx.types().T_prjlvalue : julia_type_to_llvm(ctx, jltype);
-    if (type_is_ghost(elty))
+    if (type_is_ghost(elty)) {
+        if (isStrongerThanMonotonic(Order))
+            ctx.builder.CreateFence(Order);
         return ghostValue(ctx, jltype);
+    }
     unsigned nb = isboxed ? sizeof(void*) : jl_datatype_size(jltype);
     // note that nb == jl_Module->getDataLayout().getTypeAllocSize(elty) or getTypeStoreSize, depending on whether it is a struct or primitive type
     AllocaInst *intcast = NULL;
@@ -2007,12 +2035,13 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j
 }
 
 static jl_cgval_t typed_store(jl_codectx_t &ctx,
-        Value *ptr, Value *idx_0based, jl_cgval_t rhs, jl_cgval_t cmp,
+        Value *ptr, jl_cgval_t rhs, jl_cgval_t cmp,
         jl_value_t *jltype, MDNode *tbaa, MDNode *aliasscope,
         Value *parent,  // for the write barrier, NULL if no barrier needed
         bool isboxed, AtomicOrdering Order, AtomicOrdering FailOrder, unsigned alignment,
-        bool needlock, bool issetfield, bool isreplacefield, bool isswapfield, bool ismodifyfield,
-        bool maybe_null_if_boxed, const jl_cgval_t *modifyop, const Twine &fname)
+        Value *needlock, bool issetfield, bool isreplacefield, bool isswapfield, bool ismodifyfield, bool issetfieldonce,
+        bool maybe_null_if_boxed, const jl_cgval_t *modifyop, const Twine &fname,
+        jl_module_t *mod, jl_sym_t *var)
 {
     auto newval = [&](const jl_cgval_t &lhs) {
         const jl_cgval_t argv[3] = { cmp, lhs, rhs };
@@ -2028,9 +2057,10 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
         ret = update_julia_type(ctx, ret, jltype);
         return ret;
     };
-    assert(!needlock || parent != nullptr);
     Type *elty = isboxed ? ctx.types().T_prjlvalue : julia_type_to_llvm(ctx, jltype);
-    if (type_is_ghost(elty)) {
+    if (type_is_ghost(elty) ||
+            (issetfieldonce && !maybe_null_if_boxed) ||
+            (issetfieldonce && !isboxed && !jl_type_hasptr(jltype))) {
         if (isStrongerThanMonotonic(Order))
             ctx.builder.CreateFence(Order);
         if (issetfield) {
@@ -2046,13 +2076,21 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
         else if (isswapfield) {
             return ghostValue(ctx, jltype);
         }
-        else { // modifyfield
+        else if (ismodifyfield) {
             jl_cgval_t oldval = ghostValue(ctx, jltype);
             const jl_cgval_t argv[2] = { oldval, newval(oldval) };
             jl_datatype_t *rettyp = jl_apply_modify_type(jltype);
             return emit_new_struct(ctx, (jl_value_t*)rettyp, 2, argv);
         }
+        else { // issetfieldonce
+            return mark_julia_const(ctx, jl_false);
+        }
     }
+    // if FailOrder was inherited from Order, may need to remove Load-only effects now
+    if (FailOrder == AtomicOrdering::AcquireRelease)
+        FailOrder = AtomicOrdering::Acquire;
+    if (FailOrder == AtomicOrdering::Release)
+        FailOrder = AtomicOrdering::Monotonic;
     unsigned nb = isboxed ? sizeof(void*) : jl_datatype_size(jltype);
     AllocaInst *intcast = nullptr;
     if (!isboxed && Order != AtomicOrdering::NotAtomic && !elty->isIntOrPtrTy()) {
@@ -2069,7 +2107,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             elty = Type::getIntNTy(ctx.builder.getContext(), 8 * nb2);
     }
     Value *r = nullptr;
-    if (issetfield || isswapfield || isreplacefield)  {
+    if (issetfield || isswapfield || isreplacefield || issetfieldonce)  {
         if (isboxed)
             r = boxed(ctx, rhs);
         else if (aliasscope || Order != AtomicOrdering::NotAtomic || CountTrackedPointers(realelty).count) {
@@ -2081,8 +2119,6 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
     Type *ptrty = PointerType::get(elty, ptr->getType()->getPointerAddressSpace());
     if (ptr->getType() != ptrty)
         ptr = ctx.builder.CreateBitCast(ptr, ptrty);
-    if (idx_0based)
-        ptr = ctx.builder.CreateInBoundsGEP(elty, ptr, idx_0based);
     if (isboxed)
         alignment = sizeof(void*);
     else if (!alignment)
@@ -2092,12 +2128,13 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
     Value *Success = nullptr;
     BasicBlock *DoneBB = nullptr;
     if (needlock)
-        emit_lockstate_value(ctx, parent, true);
+        emit_lockstate_value(ctx, needlock, true);
     jl_cgval_t oldval = rhs;
+    // TODO: we should do Release ordering for anything with CountTrackedPointers(elty).count > 0, instead of just isboxed
     if (issetfield || (Order == AtomicOrdering::NotAtomic && isswapfield)) {
         if (isswapfield) {
             auto *load = ctx.builder.CreateAlignedLoad(elty, ptr, Align(alignment));
-            setName(ctx.emission_context, load, "swapfield_load");
+            setName(ctx.emission_context, load, "swap_load");
             if (isboxed)
                 load->setOrdering(AtomicOrdering::Unordered);
             jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
@@ -2118,17 +2155,19 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             emit_unbox_store(ctx, rhs, ptr, tbaa, alignment);
         }
     }
-    else if (isswapfield && isStrongerThanMonotonic(Order)) {
+    else if (isswapfield) {
+        if (Order == AtomicOrdering::Unordered)
+            Order = AtomicOrdering::Monotonic;
         assert(Order != AtomicOrdering::NotAtomic && r);
         auto *store = ctx.builder.CreateAtomicRMW(AtomicRMWInst::Xchg, ptr, r, Align(alignment), Order);
-        setName(ctx.emission_context, store, "swapfield_atomicrmw");
+        setName(ctx.emission_context, store, "swap_atomicrmw");
         jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
         ai.noalias = MDNode::concatenate(aliasscope, ai.noalias);
         ai.decorateInst(store);
         instr = store;
     }
     else {
-        // replacefield, modifyfield, or swapfield (isboxed && atomic)
+        // replacefield, modifyfield, swapfield, setfieldonce (isboxed && atomic)
         DoneBB = BasicBlock::Create(ctx.builder.getContext(), "done_xchg", ctx.f);
         bool needloop;
         PHINode *Succ = nullptr, *Current = nullptr;
@@ -2146,7 +2185,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                     ctx.builder.CreateCondBr(SameType, BB, SkipBB);
                     ctx.builder.SetInsertPoint(SkipBB);
                     LoadInst *load = ctx.builder.CreateAlignedLoad(elty, ptr, Align(alignment));
-                    setName(ctx.emission_context, load, "atomic_replacefield_initial");
+                    setName(ctx.emission_context, load, "atomic_replace_initial");
                     load->setOrdering(FailOrder == AtomicOrdering::NotAtomic && isboxed ? AtomicOrdering::Monotonic : FailOrder);
                     jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
                     ai.noalias = MDNode::concatenate(aliasscope, ai.noalias);
@@ -2174,6 +2213,11 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                 needloop = true;
             }
         }
+        else if (issetfieldonce) {
+            needloop = !isboxed && Order != AtomicOrdering::NotAtomic && nb > sizeof(void*);
+            if (Order != AtomicOrdering::NotAtomic)
+                Compare = Constant::getNullValue(elty);
+        }
         else { // swap or modify
             LoadInst *Current = ctx.builder.CreateAlignedLoad(elty, ptr, Align(alignment));
             Current->setOrdering(Order == AtomicOrdering::NotAtomic && !isboxed ? Order : AtomicOrdering::Monotonic);
@@ -2196,7 +2240,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
         }
         if (ismodifyfield) {
             if (needlock)
-                emit_lockstate_value(ctx, parent, false);
+                emit_lockstate_value(ctx, needlock, false);
             Value *realCompare = Compare;
             if (realelty != elty)
                 realCompare = ctx.builder.CreateTrunc(realCompare, realelty);
@@ -2208,7 +2252,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             if (maybe_null_if_boxed) {
                 Value *first_ptr = isboxed ? Compare : extract_first_ptr(ctx, Compare);
                 if (first_ptr)
-                    null_pointer_check(ctx, first_ptr, nullptr);
+                    null_load_check(ctx, first_ptr, mod, var);
             }
             if (intcast)
                 oldval = mark_julia_slot(intcast, jltype, NULL, ctx.tbaa().tbaa_stack);
@@ -2224,12 +2268,12 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                     r = ctx.builder.CreateZExt(r, elty);
             }
             if (needlock)
-                emit_lockstate_value(ctx, parent, true);
+                emit_lockstate_value(ctx, needlock, true);
             cmp = oldval;
         }
         Value *Done;
         if (Order == AtomicOrdering::NotAtomic) {
-            // modifyfield or replacefield
+            // modifyfield or replacefield or setfieldonce
             assert(elty == realelty && !intcast);
             auto *load = ctx.builder.CreateAlignedLoad(elty, ptr, Align(alignment));
             jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
@@ -2241,9 +2285,11 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             if (maybe_null_if_boxed && !ismodifyfield)
                 first_ptr = isboxed ? load : extract_first_ptr(ctx, load);
             oldval = mark_julia_type(ctx, load, isboxed, jltype);
-            Success = emit_nullcheck_guard(ctx, first_ptr, [&] {
-                return emit_f_is(ctx, oldval, cmp);
-            });
+            assert(!issetfieldonce || first_ptr != nullptr);
+            if (issetfieldonce)
+                Success = ctx.builder.CreateIsNull(first_ptr);
+            else
+                Success = emit_f_is(ctx, oldval, cmp, first_ptr, nullptr);
             if (needloop && ismodifyfield)
                 CmpPhi->addIncoming(load, ctx.builder.GetInsertBlock());
             assert(Succ == nullptr);
@@ -2263,13 +2309,13 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             ctx.builder.CreateBr(DoneBB);
             instr = load;
         }
-        else {
+        else { // something atomic
             assert(r);
             if (Order == AtomicOrdering::Unordered)
                 Order = AtomicOrdering::Monotonic;
             if (Order == AtomicOrdering::Monotonic && isboxed)
                 Order = AtomicOrdering::Release;
-            if (!isreplacefield)
+            if (!isreplacefield && !issetfieldonce)
                 FailOrder = AtomicOrdering::Monotonic;
             else if (FailOrder == AtomicOrdering::Unordered)
                 FailOrder = AtomicOrdering::Monotonic;
@@ -2280,7 +2326,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             instr = ctx.builder.Insert(ExtractValueInst::Create(store, 0));
             Success = ctx.builder.Insert(ExtractValueInst::Create(store, 1));
             Done = Success;
-            if (isreplacefield && needloop) {
+            if ((isreplacefield || issetfieldonce) && needloop) {
                 Value *realinstr = instr;
                 if (realelty != elty)
                     realinstr = ctx.builder.CreateTrunc(realinstr, realelty);
@@ -2293,15 +2339,22 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                 else {
                     oldval = mark_julia_type(ctx, realinstr, isboxed, jltype);
                 }
-                Done = emit_guarded_test(ctx, ctx.builder.CreateNot(Success), false, [&] {
-                    Value *first_ptr = nullptr;
-                    if (maybe_null_if_boxed)
-                        first_ptr = isboxed ? realinstr : extract_first_ptr(ctx, realinstr);
-                    return emit_nullcheck_guard(ctx, first_ptr, [&] {
-                        return emit_f_is(ctx, oldval, cmp);
+                if (issetfieldonce) {
+                    assert(!isboxed && maybe_null_if_boxed);
+                    Value *first_ptr = extract_first_ptr(ctx, realinstr);
+                    assert(first_ptr != nullptr);
+                    Done = ctx.builder.CreateIsNotNull(first_ptr);
+                }
+                else {
+                    // Done = !(!Success && (first_ptr != NULL && oldval == cmp))
+                    Done = emit_guarded_test(ctx, ctx.builder.CreateNot(Success), false, [&] {
+                        Value *first_ptr = nullptr;
+                        if (maybe_null_if_boxed)
+                            first_ptr = isboxed ? realinstr : extract_first_ptr(ctx, realinstr);
+                        return emit_f_is(ctx, oldval, cmp, first_ptr, nullptr);
                     });
-                });
-                Done = ctx.builder.CreateNot(Done);
+                    Done = ctx.builder.CreateNot(Done);
+                }
             }
             if (needloop)
                 ctx.builder.CreateCondBr(Done, DoneBB, BB);
@@ -2320,9 +2373,9 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
     if (DoneBB)
         ctx.builder.SetInsertPoint(DoneBB);
     if (needlock)
-        emit_lockstate_value(ctx, parent, false);
+        emit_lockstate_value(ctx, needlock, false);
     if (parent != NULL) {
-        if (isreplacefield) {
+        if (isreplacefield || issetfieldonce) {
             // TODO: avoid this branch if we aren't making a write barrier
             BasicBlock *BB = BasicBlock::Create(ctx.builder.getContext(), "xchg_wb", ctx.f);
             DoneBB = BasicBlock::Create(ctx.builder.getContext(), "done_xchg_wb", ctx.f);
@@ -2335,7 +2388,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             else if (!type_is_permalloc(rhs.typ))
                 emit_write_barrier(ctx, parent, r);
         }
-        if (isreplacefield) {
+        if (isreplacefield || issetfieldonce) {
             ctx.builder.CreateBr(DoneBB);
             ctx.builder.SetInsertPoint(DoneBB);
         }
@@ -2345,6 +2398,9 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
         jl_datatype_t *rettyp = jl_apply_modify_type(jltype);
         oldval = emit_new_struct(ctx, (jl_value_t*)rettyp, 2, argv);
     }
+    else if (issetfieldonce) {
+        oldval = mark_julia_type(ctx, Success, false, jl_bool_type);
+    }
     else if (!issetfield) { // swapfield or replacefield
         if (realelty != elty)
             instr = ctx.builder.Insert(CastInst::Create(Instruction::Trunc, instr, realelty));
@@ -2357,7 +2413,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                 instr = ctx.builder.CreateLoad(intcast->getAllocatedType(), intcast);
             Value *first_ptr = isboxed ? instr : extract_first_ptr(ctx, instr);
             if (first_ptr)
-                null_pointer_check(ctx, first_ptr, nullptr);
+                null_load_check(ctx, first_ptr, mod, var);
             if (intcast && !first_ptr)
                 instr = nullptr;
         }
@@ -2472,7 +2528,7 @@ static bool emit_getfield_unknownidx(jl_codectx_t &ctx,
             setName(ctx.emission_context, fld, "getfield");
             jl_value_t *jft = issame ? jl_svecref(types, 0) : (jl_value_t*)jl_any_type;
             if (isboxed && maybe_null)
-                null_pointer_check(ctx, fld);
+                null_pointer_check(ctx, fld, nullptr);
             *ret = mark_julia_type(ctx, fld, isboxed, jft);
             return true;
         }
@@ -2511,7 +2567,7 @@ static bool emit_getfield_unknownidx(jl_codectx_t &ctx,
             ai.decorateInst(fld);
             maybe_mark_load_dereferenceable(fld, maybe_null, minimum_field_size, minimum_align);
             if (maybe_null)
-                null_pointer_check(ctx, fld);
+                null_pointer_check(ctx, fld, nullptr);
             *ret = mark_julia_type(ctx, fld, true, jl_any_type);
             return true;
         }
@@ -2601,7 +2657,6 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
     };
     jl_value_t *jfty = jl_field_type(jt, idx);
     bool isatomic = jl_field_isatomic(jt, idx);
-    bool needlock = isatomic && !jl_field_isptr(jt, idx) && jl_datatype_size(jfty) > MAX_ATOMIC_SIZE;
     if (!isatomic && order != jl_memory_order_notatomic && order != jl_memory_order_unspecified) {
         emit_atomic_error(ctx, "getfield: non-atomic field cannot be accessed atomically");
         return jl_cgval_t(); // unreachable
@@ -2619,6 +2674,11 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
     }
     if (type_is_ghost(julia_type_to_llvm(ctx, jfty)))
         return ghostValue(ctx, jfty);
+    Value *needlock = nullptr;
+    if (isatomic && !jl_field_isptr(jt, idx) && jl_datatype_size(jfty) > MAX_ATOMIC_SIZE) {
+        assert(strct.isboxed);
+        needlock = boxed(ctx, strct);
+    }
     size_t nfields = jl_datatype_nfields(jt);
     bool maybe_null = idx >= nfields - (unsigned)jt->name->n_uninitialized;
     size_t byte_offset = jl_field_offset(jt, idx);
@@ -2694,7 +2754,7 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
         }
         unsigned align = jl_field_align(jt, idx);
         if (needlock)
-            emit_lockstate_value(ctx, strct, true);
+            emit_lockstate_value(ctx, needlock, true);
         jl_cgval_t ret = typed_load(ctx, addr, NULL, jfty, tbaa, nullptr, false,
                 needlock ? AtomicOrdering::NotAtomic : get_llvm_atomic_order(order),
                 maybe_null, align, nullcheck);
@@ -2702,7 +2762,7 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
             setNameWithField(ctx.emission_context, ret.V, get_objname, jt, idx, Twine());
         }
         if (needlock)
-            emit_lockstate_value(ctx, strct, false);
+            emit_lockstate_value(ctx, needlock, false);
         return ret;
     }
     else if (isa<UndefValue>(strct.V)) {
@@ -3563,11 +3623,97 @@ static void emit_write_multibarrier(jl_codectx_t &ctx, Value *parent, Value *agg
     emit_write_barrier(ctx, parent, ptrs);
 }
 
+static jl_cgval_t union_store(jl_codectx_t &ctx,
+        Value *ptr, Value *ptindex, jl_cgval_t rhs, jl_cgval_t cmp,
+        jl_value_t *jltype, MDNode *tbaa, MDNode *aliasscope, MDNode *tbaa_tindex,
+        AtomicOrdering Order, AtomicOrdering FailOrder,
+        Value *needlock, bool issetfield, bool isreplacefield, bool isswapfield, bool ismodifyfield, bool issetfieldonce,
+        const jl_cgval_t *modifyop, const Twine &fname)
+{
+    assert(Order == AtomicOrdering::NotAtomic);
+    if (issetfieldonce)
+        return mark_julia_const(ctx, jl_false);
+    size_t fsz = 0, al = 0;
+    int union_max = jl_islayout_inline(jltype, &fsz, &al);
+    assert(union_max > 0);
+    // compute tindex from rhs
+    jl_cgval_t rhs_union = convert_julia_type(ctx, rhs, jltype);
+    if (rhs_union.typ == jl_bottom_type)
+        return jl_cgval_t();
+    if (needlock)
+        emit_lockstate_value(ctx, needlock, true);
+    BasicBlock *ModifyBB = NULL;
+    if (ismodifyfield) {
+        ModifyBB = BasicBlock::Create(ctx.builder.getContext(), "modify_xchg", ctx.f);
+        ctx.builder.CreateBr(ModifyBB);
+        ctx.builder.SetInsertPoint(ModifyBB);
+    }
+    jl_cgval_t oldval = rhs;
+    if (!issetfield)
+        oldval = emit_unionload(ctx, ptr, ptindex, jltype, fsz, al, tbaa, true, union_max, tbaa_tindex);
+    Value *Success = NULL;
+    BasicBlock *DoneBB = NULL;
+    if (isreplacefield || ismodifyfield) {
+        if (ismodifyfield) {
+            if (needlock)
+                emit_lockstate_value(ctx, needlock, false);
+            const jl_cgval_t argv[3] = { cmp, oldval, rhs };
+            if (modifyop) {
+                rhs = emit_invoke(ctx, *modifyop, argv, 3, (jl_value_t*)jl_any_type);
+            }
+            else {
+                Value *callval = emit_jlcall(ctx, jlapplygeneric_func, nullptr, argv, 3, julia_call);
+                rhs = mark_julia_type(ctx, callval, true, jl_any_type);
+            }
+            emit_typecheck(ctx, rhs, jltype, fname);
+            rhs = update_julia_type(ctx, rhs, jltype);
+            rhs_union = convert_julia_type(ctx, rhs, jltype);
+            if (rhs_union.typ == jl_bottom_type)
+                return jl_cgval_t();
+            if (needlock)
+                emit_lockstate_value(ctx, needlock, true);
+            cmp = oldval;
+            oldval = emit_unionload(ctx, ptr, ptindex, jltype, fsz, al, tbaa, true, union_max, tbaa_tindex);
+        }
+        BasicBlock *XchgBB = BasicBlock::Create(ctx.builder.getContext(), "xchg", ctx.f);
+        DoneBB = BasicBlock::Create(ctx.builder.getContext(), "done_xchg", ctx.f);
+        Success = emit_f_is(ctx, oldval, cmp);
+        ctx.builder.CreateCondBr(Success, XchgBB, ismodifyfield ? ModifyBB : DoneBB);
+        ctx.builder.SetInsertPoint(XchgBB);
+    }
+    Value *tindex = compute_tindex_unboxed(ctx, rhs_union, jltype);
+    tindex = ctx.builder.CreateNUWSub(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 1));
+    jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_unionselbyte);
+    ai.decorateInst(ctx.builder.CreateAlignedStore(tindex, ptindex, Align(1)));
+    // copy data
+    if (!rhs.isghost) {
+        emit_unionmove(ctx, ptr, tbaa, rhs, nullptr);
+    }
+    if (isreplacefield || ismodifyfield) {
+        ctx.builder.CreateBr(DoneBB);
+        ctx.builder.SetInsertPoint(DoneBB);
+    }
+    if (needlock)
+        emit_lockstate_value(ctx, needlock, false);
+    if (isreplacefield) {
+        Success = ctx.builder.CreateZExt(Success, getInt8Ty(ctx.builder.getContext()));
+        jl_cgval_t argv[2] = {oldval, mark_julia_type(ctx, Success, false, jl_bool_type)};
+        jl_datatype_t *rettyp = jl_apply_cmpswap_type(jltype);
+        oldval = emit_new_struct(ctx, (jl_value_t*)rettyp, 2, argv);
+    }
+    else if (ismodifyfield) {
+        jl_cgval_t argv[2] = {oldval, rhs};
+        jl_datatype_t *rettyp = jl_apply_modify_type(jltype);
+        oldval = emit_new_struct(ctx, (jl_value_t*)rettyp, 2, argv);
+    }
+    return oldval;
+}
+
 static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
         jl_datatype_t *sty, const jl_cgval_t &strct, size_t idx0,
         jl_cgval_t rhs, jl_cgval_t cmp,
         bool wb, AtomicOrdering Order, AtomicOrdering FailOrder,
-        bool needlock, bool issetfield, bool isreplacefield, bool isswapfield, bool ismodifyfield,
+        Value *needlock, bool issetfield, bool isreplacefield, bool isswapfield, bool ismodifyfield, bool issetfieldonce,
         const jl_cgval_t *modifyop, const Twine &fname)
 {
     auto get_objname = [&]() {
@@ -3582,111 +3728,33 @@ static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
         addr = ctx.builder.CreateInBoundsGEP(
                 getInt8Ty(ctx.builder.getContext()),
                 emit_bitcast(ctx, addr, getInt8PtrTy(ctx.builder.getContext())),
-                ConstantInt::get(ctx.types().T_size, byte_offset)); // TODO: use emit_struct_gep
+                ConstantInt::get(ctx.types().T_size, byte_offset));
         setNameWithField(ctx.emission_context, addr, get_objname, sty, idx0, Twine("_ptr"));
     }
     jl_value_t *jfty = jl_field_type(sty, idx0);
-    if (!jl_field_isptr(sty, idx0) && jl_is_uniontype(jfty)) {
-        size_t fsz = 0, al = 0;
-        int union_max = jl_islayout_inline(jfty, &fsz, &al);
-        bool isptr = (union_max == 0);
-        assert(!isptr && fsz < jl_field_size(sty, idx0)); (void)isptr;
+    bool isboxed = jl_field_isptr(sty, idx0);
+    if (!isboxed && jl_is_uniontype(jfty)) {
         size_t fsz1 = jl_field_size(sty, idx0) - 1;
-        // compute tindex from rhs
-        jl_cgval_t rhs_union = convert_julia_type(ctx, rhs, jfty);
-        if (rhs_union.typ == jl_bottom_type)
-            return jl_cgval_t();
         Value *ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()),
                 emit_bitcast(ctx, addr, getInt8PtrTy(ctx.builder.getContext())),
                 ConstantInt::get(ctx.types().T_size, fsz1));
         setNameWithField(ctx.emission_context, ptindex, get_objname, sty, idx0, Twine(".tindex_ptr"));
-        if (needlock)
-            emit_lockstate_value(ctx, strct, true);
-        BasicBlock *ModifyBB = NULL;
-        if (ismodifyfield) {
-            ModifyBB = BasicBlock::Create(ctx.builder.getContext(), "modify_xchg", ctx.f);
-            ctx.builder.CreateBr(ModifyBB);
-            ctx.builder.SetInsertPoint(ModifyBB);
-        }
-        jl_cgval_t oldval = rhs;
-        if (!issetfield)
-            oldval = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, true, union_max, ctx.tbaa().tbaa_unionselbyte);
-        Value *Success = NULL;
-        BasicBlock *DoneBB = NULL;
-        if (isreplacefield || ismodifyfield) {
-            if (ismodifyfield) {
-                if (needlock)
-                    emit_lockstate_value(ctx, strct, false);
-                const jl_cgval_t argv[3] = { cmp, oldval, rhs };
-                if (modifyop) {
-                    rhs = emit_invoke(ctx, *modifyop, argv, 3, (jl_value_t*)jl_any_type);
-                }
-                else {
-                    Value *callval = emit_jlcall(ctx, jlapplygeneric_func, nullptr, argv, 3, julia_call);
-                    rhs = mark_julia_type(ctx, callval, true, jl_any_type);
-                }
-                emit_typecheck(ctx, rhs, jfty, fname);
-                rhs = update_julia_type(ctx, rhs, jfty);
-                rhs_union = convert_julia_type(ctx, rhs, jfty);
-                if (rhs_union.typ == jl_bottom_type)
-                    return jl_cgval_t();
-                if (needlock)
-                    emit_lockstate_value(ctx, strct, true);
-                cmp = oldval;
-                oldval = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, true, union_max, ctx.tbaa().tbaa_unionselbyte);
-            }
-            BasicBlock *XchgBB = BasicBlock::Create(ctx.builder.getContext(), "xchg", ctx.f);
-            DoneBB = BasicBlock::Create(ctx.builder.getContext(), "done_xchg", ctx.f);
-            Success = emit_f_is(ctx, oldval, cmp);
-            ctx.builder.CreateCondBr(Success, XchgBB, ismodifyfield ? ModifyBB : DoneBB);
-            ctx.builder.SetInsertPoint(XchgBB);
-        }
-        Value *tindex = compute_tindex_unboxed(ctx, rhs_union, jfty);
-        tindex = ctx.builder.CreateNUWSub(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 1));
-        jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_unionselbyte);
-        ai.decorateInst(ctx.builder.CreateAlignedStore(tindex, ptindex, Align(1)));
-        // copy data
-        if (!rhs.isghost) {
-            emit_unionmove(ctx, addr, tbaa, rhs, nullptr);
-        }
-        if (isreplacefield || ismodifyfield) {
-            ctx.builder.CreateBr(DoneBB);
-            ctx.builder.SetInsertPoint(DoneBB);
-        }
-        if (needlock)
-            emit_lockstate_value(ctx, strct, false);
-        if (isreplacefield) {
-            Success = ctx.builder.CreateZExt(Success, getInt8Ty(ctx.builder.getContext()));
-            jl_cgval_t argv[2] = {oldval, mark_julia_type(ctx, Success, false, jl_bool_type)};
-            jl_datatype_t *rettyp = jl_apply_cmpswap_type(jfty);
-            oldval = emit_new_struct(ctx, (jl_value_t*)rettyp, 2, argv);
-            if (oldval.V) {
-                setNameWithField(ctx.emission_context, oldval.V, get_objname, sty, idx0, Twine());
-            }
-        }
-        else if (ismodifyfield) {
-            jl_cgval_t argv[2] = {oldval, rhs};
-            jl_datatype_t *rettyp = jl_apply_modify_type(jfty);
-            oldval = emit_new_struct(ctx, (jl_value_t*)rettyp, 2, argv);
-            if (oldval.V) {
-                setNameWithField(ctx.emission_context, oldval.V, get_objname, sty, idx0, Twine());
-            }
-        }
-        return oldval;
-    }
-    else {
-        unsigned align = jl_field_align(sty, idx0);
-        bool isboxed = jl_field_isptr(sty, idx0);
-        size_t nfields = jl_datatype_nfields(sty);
-        bool maybe_null = idx0 >= nfields - (unsigned)sty->name->n_uninitialized;
-        return typed_store(ctx, addr, NULL, rhs, cmp, jfty, tbaa, nullptr,
-            wb ? boxed(ctx, strct) : nullptr,
-            isboxed, Order, FailOrder, align,
-            needlock, issetfield, isreplacefield, isswapfield, ismodifyfield, maybe_null, modifyop, fname);
+        return union_store(ctx, addr, ptindex, rhs, cmp, jfty, tbaa, nullptr, ctx.tbaa().tbaa_unionselbyte,
+            Order, FailOrder,
+            needlock, issetfield, isreplacefield, isswapfield, ismodifyfield, issetfieldonce,
+            modifyop, fname);
     }
+    unsigned align = jl_field_align(sty, idx0);
+    size_t nfields = jl_datatype_nfields(sty);
+    bool maybe_null = idx0 >= nfields - (unsigned)sty->name->n_uninitialized;
+    return typed_store(ctx, addr, rhs, cmp, jfty, tbaa, nullptr,
+        wb ? boxed(ctx, strct) : nullptr,
+        isboxed, Order, FailOrder, align,
+        needlock, issetfield, isreplacefield, isswapfield, ismodifyfield, issetfieldonce,
+        maybe_null, modifyop, fname, nullptr, nullptr);
 }
 
-static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t nargs, const jl_cgval_t *argv, bool is_promotable)
+static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t nargs, ArrayRef<jl_cgval_t> argv, bool is_promotable)
 {
     ++EmittedNewStructs;
     assert(jl_is_datatype(ty));
@@ -3930,7 +3998,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
             rhs = update_julia_type(ctx, rhs, ft);
             if (rhs.typ == jl_bottom_type)
                 return jl_cgval_t();
-            emit_setfield(ctx, sty, strctinfo, i, rhs, jl_cgval_t(), need_wb, AtomicOrdering::NotAtomic, AtomicOrdering::NotAtomic, false, true, false, false, false, nullptr, "");
+            emit_setfield(ctx, sty, strctinfo, i, rhs, jl_cgval_t(), need_wb, AtomicOrdering::NotAtomic, AtomicOrdering::NotAtomic, nullptr, true, false, false, false, false, nullptr, "new");
         }
         return strctinfo;
     }
diff --git a/src/codegen.cpp b/src/codegen.cpp
index c91e70b5e508e..6de2669ac0f7d 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -879,6 +879,42 @@ static const auto jlcheckassign_func = new JuliaFunction<>{
             {T_pjlvalue, T_pjlvalue, T_pjlvalue, PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::CalleeRooted)}, false); },
     nullptr,
 };
+static const auto jlcheckreplace_func = new JuliaFunction<>{
+    XSTR(jl_checked_replace),
+    [](LLVMContext &C) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        auto T_prjlvalue = JuliaType::get_prjlvalue_ty(C);
+        return FunctionType::get(T_prjlvalue,
+            {T_pjlvalue, T_pjlvalue, T_pjlvalue, T_prjlvalue, T_prjlvalue}, false); },
+    nullptr,
+};
+static const auto jlcheckmodify_func = new JuliaFunction<>{
+    XSTR(jl_checked_modify),
+    [](LLVMContext &C) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        auto T_prjlvalue = JuliaType::get_prjlvalue_ty(C);
+        return FunctionType::get(T_prjlvalue,
+            {T_pjlvalue, T_pjlvalue, T_pjlvalue, T_prjlvalue, T_prjlvalue}, false); },
+    nullptr,
+};
+static const auto jlcheckswap_func = new JuliaFunction<>{
+    XSTR(jl_checked_swap),
+    [](LLVMContext &C) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        auto T_prjlvalue = JuliaType::get_prjlvalue_ty(C);
+        return FunctionType::get(T_prjlvalue,
+            {T_pjlvalue, T_pjlvalue, T_pjlvalue, PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::CalleeRooted)}, false); },
+    nullptr,
+};
+static const auto jlcheckassignonce_func = new JuliaFunction<>{
+    XSTR(jl_checked_assignonce),
+    [](LLVMContext &C) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        auto T_prjlvalue = JuliaType::get_prjlvalue_ty(C);
+        return FunctionType::get(T_prjlvalue,
+            {T_pjlvalue, T_pjlvalue, T_pjlvalue, PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::CalleeRooted)}, false); },
+    nullptr,
+};
 static const auto jldeclareconst_func = new JuliaFunction<>{
     XSTR(jl_declare_constant),
     [](LLVMContext &C) {
@@ -992,6 +1028,24 @@ static const auto jlunlockvalue_func = new JuliaFunction<>{
             AttributeSet(),
             {Attributes(C, {Attribute::NoCapture})}); },
 };
+static const auto jllockfield_func = new JuliaFunction<>{
+    XSTR(jl_lock_field),
+    [](LLVMContext &C) { return FunctionType::get(getVoidTy(C),
+            {PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::Loaded)}, false); },
+    [](LLVMContext &C) { return AttributeList::get(C,
+            AttributeSet(),
+            AttributeSet(),
+            {Attributes(C, {Attribute::NoCapture})}); },
+};
+static const auto jlunlockfield_func = new JuliaFunction<>{
+    XSTR(jl_unlock_field),
+    [](LLVMContext &C) { return FunctionType::get(getVoidTy(C),
+            {PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::Loaded)}, false); },
+    [](LLVMContext &C) { return AttributeList::get(C,
+            AttributeSet(),
+            AttributeSet(),
+            {Attributes(C, {Attribute::NoCapture})}); },
+};
 static const auto jlenter_func = new JuliaFunction<>{
     XSTR(jl_enter_handler),
     [](LLVMContext &C) { return FunctionType::get(getVoidTy(C),
@@ -1525,6 +1579,10 @@ static const auto &builtin_func_map() {
           { jl_f_memoryref_addr,          new JuliaFunction<>{XSTR(jl_f_memoryref), get_func_sig, get_func_attrs} },
           { jl_f_memoryrefoffset_addr,    new JuliaFunction<>{XSTR(jl_f_memoryrefoffset), get_func_sig, get_func_attrs} },
           { jl_f_memoryrefset_addr,       new JuliaFunction<>{XSTR(jl_f_memoryrefset), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefswap_addr,      new JuliaFunction<>{XSTR(jl_f_memoryswapset), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefreplace_addr,   new JuliaFunction<>{XSTR(jl_f_memoryreplaceset), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefmodify_addr,    new JuliaFunction<>{XSTR(jl_f_memorymodifyset), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefsetonce_addr,   new JuliaFunction<>{XSTR(jl_f_memoryrefsetonce), get_func_sig, get_func_attrs} },
           { jl_f_memoryref_isassigned_addr,new JuliaFunction<>{XSTR(jl_f_memoryref_isassigned), get_func_sig, get_func_attrs} },
           { jl_f_apply_type_addr,         new JuliaFunction<>{XSTR(jl_f_apply_type), get_func_sig, get_func_attrs} },
           { jl_f_donotdelete_addr,        new JuliaFunction<>{XSTR(jl_f_donotdelete), get_donotdelete_sig, get_donotdelete_func_attrs} },
@@ -1999,13 +2057,13 @@ static Value *get_current_ptls(jl_codectx_t &ctx);
 static Value *get_last_age_field(jl_codectx_t &ctx);
 static void CreateTrap(IRBuilder<> &irbuilder, bool create_new_block = true);
 static CallInst *emit_jlcall(jl_codectx_t &ctx, FunctionCallee theFptr, Value *theF,
-                             const jl_cgval_t *args, size_t nargs, JuliaFunction<> *trampoline);
+                             ArrayRef<jl_cgval_t> args, size_t nargs, JuliaFunction<> *trampoline);
 static CallInst *emit_jlcall(jl_codectx_t &ctx, JuliaFunction<> *theFptr, Value *theF,
-                             const jl_cgval_t *args, size_t nargs, JuliaFunction<> *trampoline);
+                             ArrayRef<jl_cgval_t> args, size_t nargs, JuliaFunction<> *trampoline);
 static Value *emit_f_is(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2,
                         Value *nullcheck1 = nullptr, Value *nullcheck2 = nullptr);
-static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t nargs, const jl_cgval_t *argv, bool is_promotable=false);
-static jl_cgval_t emit_invoke(jl_codectx_t &ctx, const jl_cgval_t &lival, const jl_cgval_t *argv, size_t nargs, jl_value_t *rt);
+static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t nargs, ArrayRef<jl_cgval_t> argv, bool is_promotable=false);
+static jl_cgval_t emit_invoke(jl_codectx_t &ctx, const jl_cgval_t &lival, ArrayRef<jl_cgval_t> argv, size_t nargs, jl_value_t *rt);
 
 static Value *literal_pointer_val(jl_codectx_t &ctx, jl_value_t *p);
 static unsigned julia_alignment(jl_value_t *jt);
@@ -2766,7 +2824,7 @@ static void cg_bdw(jl_codectx_t &ctx, jl_sym_t *var, jl_binding_t *b)
     }
 }
 
-static jl_value_t *static_apply_type(jl_codectx_t &ctx, const jl_cgval_t *args, size_t nargs)
+static jl_value_t *static_apply_type(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> args, size_t nargs)
 {
     assert(nargs > 1);
     SmallVector<jl_value_t *, 0> v(nargs);
@@ -3104,27 +3162,80 @@ static jl_cgval_t emit_globalref(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *
     return emit_checked_var(ctx, bp, name, (jl_value_t*)mod, false, ctx.tbaa().tbaa_binding);
 }
 
-static bool emit_globalset(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *sym, const jl_cgval_t &rval_info, AtomicOrdering Order)
+static jl_cgval_t emit_globalop(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *sym, jl_cgval_t rval, const jl_cgval_t &cmp,
+                                AtomicOrdering Order, AtomicOrdering FailOrder,
+                                bool issetglobal, bool isreplaceglobal, bool isswapglobal, bool ismodifyglobal, bool issetglobalonce,
+                                const jl_cgval_t *modifyop)
 {
     jl_binding_t *bnd = NULL;
     Value *bp = global_binding_pointer(ctx, mod, sym, &bnd, true);
     if (bp == NULL)
-        return false;
-    Value *rval = boxed(ctx, rval_info);
+        return jl_cgval_t();
     if (bnd && !bnd->constp) {
         jl_value_t *ty = jl_atomic_load_relaxed(&bnd->ty);
-        if (ty && jl_subtype(rval_info.typ, ty)) { // TODO: use typeassert here instead
-            StoreInst *v = ctx.builder.CreateAlignedStore(rval, julia_binding_pvalue(ctx, bp), Align(sizeof(void*)));
-            v->setOrdering(Order);
-            jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_binding);
-            ai.decorateInst(v);
-            emit_write_barrier(ctx, bp, rval);
-            return true;
-        }
-    }
-    ctx.builder.CreateCall(prepare_call(jlcheckassign_func),
-            { bp, literal_pointer_val(ctx, (jl_value_t*)mod), literal_pointer_val(ctx, (jl_value_t*)sym), mark_callee_rooted(ctx, rval) });
-    return true;
+        if (ty != nullptr) {
+            const std::string fname = issetglobal ? "setglobal!" : isreplaceglobal ? "replaceglobal!" : isswapglobal ? "swapglobal!" : ismodifyglobal ? "modifyglobal!" : "setglobalonce!";
+            if (!ismodifyglobal) {
+                // TODO: use typeassert in jl_check_binding_wr too
+                emit_typecheck(ctx, rval, ty, "typeassert");
+                rval = update_julia_type(ctx, rval, ty);
+                if (rval.typ == jl_bottom_type)
+                    return jl_cgval_t();
+            }
+            bool isboxed = true;
+            bool maybe_null = jl_atomic_load_relaxed(&bnd->value) == NULL;
+            return typed_store(ctx,
+                               julia_binding_pvalue(ctx, bp),
+                               rval, cmp, ty,
+                               ctx.tbaa().tbaa_binding,
+                               nullptr,
+                               bp,
+                               isboxed,
+                               Order,
+                               FailOrder,
+                               0,
+                               nullptr,
+                               issetglobal,
+                               isreplaceglobal,
+                               isswapglobal,
+                               ismodifyglobal,
+                               issetglobalonce,
+                               maybe_null,
+                               modifyop,
+                               fname,
+                               mod,
+                               sym);
+
+        }
+    }
+    Value *m = literal_pointer_val(ctx, (jl_value_t*)mod);
+    Value *s = literal_pointer_val(ctx, (jl_value_t*)sym);
+    if (issetglobal) {
+        ctx.builder.CreateCall(prepare_call(jlcheckassign_func),
+                { bp, m, s, mark_callee_rooted(ctx, boxed(ctx, rval)) });
+        return rval;
+    }
+    else if (isreplaceglobal) {
+        Value *r = ctx.builder.CreateCall(prepare_call(jlcheckreplace_func),
+                { bp, m, s, boxed(ctx, cmp), boxed(ctx, rval) });
+        return mark_julia_type(ctx, r, true, jl_any_type);
+    }
+    else if (isswapglobal) {
+        Value *r = ctx.builder.CreateCall(prepare_call(jlcheckswap_func),
+                { bp, m, s, mark_callee_rooted(ctx, boxed(ctx, rval)) });
+        return mark_julia_type(ctx, r, true, jl_any_type);
+    }
+    else if (ismodifyglobal) {
+        Value *r = ctx.builder.CreateCall(prepare_call(jlcheckmodify_func),
+                { bp, m, s, boxed(ctx, cmp), boxed(ctx, rval) });
+        return mark_julia_type(ctx, r, true, jl_any_type);
+    }
+    else if (issetglobalonce) {
+        Value *r = ctx.builder.CreateCall(prepare_call(jlcheckassignonce_func),
+                { bp, m, s, mark_callee_rooted(ctx, boxed(ctx, rval)) });
+        return mark_julia_type(ctx, r, true, jl_bool_type);
+    }
+    abort(); // unreachable
 }
 
 static Value *emit_box_compare(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgval_t &arg2,
@@ -3405,37 +3516,69 @@ static Value *emit_f_is(jl_codectx_t &ctx, const jl_cgval_t &arg1, const jl_cgva
 }
 
 static bool emit_f_opglobal(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
-                            const jl_cgval_t *argv, size_t nargs, const jl_cgval_t *modifyop)
+                            ArrayRef<jl_cgval_t> argv, size_t nargs, const jl_cgval_t *modifyop)
 {
+    bool issetglobal = f == jl_builtin_setglobal;
+    bool isreplaceglobal = f == jl_builtin_replaceglobal;
+    bool isswapglobal = f == jl_builtin_swapglobal;
+    bool ismodifyglobal = f == jl_builtin_modifyglobal;
+    bool issetglobalonce = f == jl_builtin_setglobalonce;
+    const jl_cgval_t undefval;
     const jl_cgval_t &mod = argv[1];
     const jl_cgval_t &sym = argv[2];
-    const jl_cgval_t &val = argv[3];
-    enum jl_memory_order order = jl_memory_order_unspecified;
-    assert(f == jl_builtin_setglobal && modifyop == nullptr && "unimplemented");
-
-    if (nargs == 4) {
-        const jl_cgval_t &arg4 = argv[4];
-        if (arg4.constant && jl_is_symbol(arg4.constant))
-            order = jl_get_atomic_order((jl_sym_t*)arg4.constant, false, true);
-        else
+    jl_cgval_t val = argv[isreplaceglobal || ismodifyglobal ? 4 : 3];
+    const jl_cgval_t &cmp = isreplaceglobal || ismodifyglobal ? argv[3] : undefval;
+    enum jl_memory_order order = jl_memory_order_release;
+    const std::string fname = issetglobal ? "setglobal!" : isreplaceglobal ? "replaceglobal!" : isswapglobal ? "swapglobal!" : ismodifyglobal ? "modifyglobal!" : "setglobalonce!";
+    if (nargs >= (isreplaceglobal || ismodifyglobal ? 5 : 4)) {
+        const jl_cgval_t &ord = argv[isreplaceglobal || ismodifyglobal ? 5 : 4];
+        emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, fname);
+        if (!ord.constant)
             return false;
+        order = jl_get_atomic_order((jl_sym_t*)ord.constant, !issetglobal, true);
+    }
+    enum jl_memory_order fail_order = order;
+    if ((isreplaceglobal || issetglobalonce) && nargs == (isreplaceglobal ? 6 : 5)) {
+        const jl_cgval_t &ord = argv[isreplaceglobal ? 6 : 5];
+        emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, fname);
+        if (!ord.constant)
+            return false;
+        fail_order = jl_get_atomic_order((jl_sym_t*)ord.constant, true, false);
+    }
+    if (order == jl_memory_order_invalid || fail_order == jl_memory_order_invalid || fail_order > order) {
+        emit_atomic_error(ctx, "invalid atomic ordering");
+        *ret = jl_cgval_t(); // unreachable
+        return true;
     }
-    else
-        order = jl_memory_order_release;
 
-    if (order == jl_memory_order_invalid || order == jl_memory_order_notatomic) {
-        emit_atomic_error(ctx, order == jl_memory_order_invalid ? "invalid atomic ordering" : "setglobal!: module binding cannot be written non-atomically");
+    if (order == jl_memory_order_notatomic) {
+        emit_atomic_error(ctx,
+                issetglobal ? "setglobal!: module binding cannot be written non-atomically" :
+                isreplaceglobal ? "replaceglobal!: module binding cannot be written non-atomically" :
+                isswapglobal ? "swapglobal!: module binding cannot be written non-atomically" :
+                ismodifyglobal ? "modifyglobal!: module binding cannot be written non-atomically" :
+                "setglobalonce!: module binding cannot be written non-atomically");
+        *ret = jl_cgval_t(); // unreachable
+        return true;
+    }
+    else if (fail_order == jl_memory_order_notatomic) {
+        emit_atomic_error(ctx,
+                isreplaceglobal ? "replaceglobal!: module binding cannot be accessed non-atomically" :
+                "setglobalonce!: module binding cannot be accessed non-atomically");
         *ret = jl_cgval_t(); // unreachable
         return true;
     }
 
     if (sym.constant && jl_is_symbol(sym.constant)) {
-        jl_sym_t *name = (jl_sym_t*)sym.constant;
         if (mod.constant && jl_is_module(mod.constant)) {
-            if (emit_globalset(ctx, (jl_module_t*)mod.constant, name, val, get_llvm_atomic_order(order)))
-                *ret = val;
-            else
-                *ret = jl_cgval_t(); // unreachable
+            *ret = emit_globalop(ctx, (jl_module_t*)mod.constant, (jl_sym_t*)sym.constant, val, cmp,
+                                 get_llvm_atomic_order(order), get_llvm_atomic_order(fail_order),
+                                 issetglobal,
+                                 isreplaceglobal,
+                                 isswapglobal,
+                                 ismodifyglobal,
+                                 issetglobalonce,
+                                 modifyop);
             return true;
         }
     }
@@ -3444,20 +3587,21 @@ static bool emit_f_opglobal(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
 }
 
 static bool emit_f_opfield(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
-                           const jl_cgval_t *argv, size_t nargs, const jl_cgval_t *modifyop)
+                           ArrayRef<jl_cgval_t> argv, size_t nargs, const jl_cgval_t *modifyop)
 {
     ++EmittedOpfields;
     bool issetfield = f == jl_builtin_setfield;
     bool isreplacefield = f == jl_builtin_replacefield;
     bool isswapfield = f == jl_builtin_swapfield;
     bool ismodifyfield = f == jl_builtin_modifyfield;
+    bool issetfieldonce = f == jl_builtin_setfieldonce;
     const jl_cgval_t undefval;
     const jl_cgval_t &obj = argv[1];
     const jl_cgval_t &fld = argv[2];
     jl_cgval_t val = argv[isreplacefield || ismodifyfield ? 4 : 3];
     const jl_cgval_t &cmp = isreplacefield || ismodifyfield ? argv[3] : undefval;
     enum jl_memory_order order = jl_memory_order_notatomic;
-    const std::string fname = issetfield ? "setfield!" : isreplacefield ? "replacefield!" : isswapfield ? "swapfield!" : "modifyfield!";
+    const std::string fname = issetfield ? "setfield!" : isreplacefield ? "replacefield!" : isswapfield ? "swapfield!" : ismodifyfield ? "modifyfield!" : "setfieldonce!";
     if (nargs >= (isreplacefield || ismodifyfield ? 5 : 4)) {
         const jl_cgval_t &ord = argv[isreplacefield || ismodifyfield ? 5 : 4];
         emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, fname);
@@ -3466,8 +3610,8 @@ static bool emit_f_opfield(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         order = jl_get_atomic_order((jl_sym_t*)ord.constant, !issetfield, true);
     }
     enum jl_memory_order fail_order = order;
-    if (isreplacefield && nargs == 6) {
-        const jl_cgval_t &ord = argv[6];
+    if ((isreplacefield || issetfieldonce) && nargs == (isreplacefield ? 6 : 5)) {
+        const jl_cgval_t &ord = argv[isreplacefield ? 6 : 5];
         emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, fname);
         if (!ord.constant)
             return false;
@@ -3515,13 +3659,19 @@ static bool emit_f_opfield(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                             isswapfield ?
                             (isatomic ? "swapfield!: atomic field cannot be written non-atomically"
                                       : "swapfield!: non-atomic field cannot be written atomically") :
+                            ismodifyfield ?
                             (isatomic ? "modifyfield!: atomic field cannot be written non-atomically"
-                                      : "modifyfield!: non-atomic field cannot be written atomically"));
+                                      : "modifyfield!: non-atomic field cannot be written atomically") :
+                            (isatomic ? "setfieldonce!: atomic field cannot be written non-atomically"
+                                      : "setfieldonce!: non-atomic field cannot be written atomically"));
                 }
                 else if (isatomic == (fail_order == jl_memory_order_notatomic)) {
                     emit_atomic_error(ctx,
+                            isreplacefield ?
                             (isatomic ? "replacefield!: atomic field cannot be accessed non-atomically"
-                                      : "replacefield!: non-atomic field cannot be accessed atomically"));
+                                      : "replacefield!: non-atomic field cannot be accessed atomically") :
+                            (isatomic ? "setfieldonce!: atomic field cannot be accessed non-atomically"
+                                      : "setfieldonce!: non-atomic field cannot be accessed atomically"));
                 }
                 else if (!uty->name->mutabl) {
                     std::string msg = fname + ": immutable struct of type "
@@ -3538,6 +3688,7 @@ static bool emit_f_opfield(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                     emit_error(ctx, msg);
                 }
                 else {
+                    assert(obj.isboxed);
                     *ret = emit_setfield(ctx, uty, obj, idx, val, cmp, true,
                             (needlock || order <= jl_memory_order_notatomic)
                                 ? AtomicOrdering::NotAtomic
@@ -3545,7 +3696,8 @@ static bool emit_f_opfield(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                             (needlock || fail_order <= jl_memory_order_notatomic)
                                 ? AtomicOrdering::NotAtomic
                                 : get_llvm_atomic_order(fail_order),
-                            needlock, issetfield, isreplacefield, isswapfield, ismodifyfield,
+                            needlock ? boxed(ctx, obj) : nullptr,
+                            issetfield, isreplacefield, isswapfield, ismodifyfield, issetfieldonce,
                             modifyop, fname);
                 }
                 return true;
@@ -3555,6 +3707,185 @@ static bool emit_f_opfield(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
     return false;
 }
 
+static bool emit_f_opmemory(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
+                            ArrayRef<jl_cgval_t> argv, size_t nargs, const jl_cgval_t *modifyop)
+{
+    bool issetmemory = f == jl_builtin_memoryrefset;
+    bool isreplacememory = f == jl_builtin_memoryrefreplace;
+    bool isswapmemory = f == jl_builtin_memoryrefswap;
+    bool ismodifymemory = f == jl_builtin_memoryrefmodify;
+    bool issetmemoryonce = f == jl_builtin_memoryrefsetonce;
+
+    const jl_cgval_t undefval;
+    const jl_cgval_t &ref = argv[1];
+    jl_cgval_t val = argv[isreplacememory || ismodifymemory ? 3 : 2];
+    jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
+    if (!jl_is_genericmemoryref_type(mty_dt) || !jl_is_concrete_type(mty_dt))
+        return false;
+
+    jl_value_t *kind = jl_tparam0(mty_dt);
+    jl_value_t *ety = jl_tparam1(mty_dt);
+    jl_value_t *addrspace = jl_tparam2(mty_dt); (void)addrspace; // TODO
+    mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
+    if (kind != (jl_value_t*)jl_not_atomic_sym && kind != (jl_value_t*)jl_atomic_sym)
+        return false;
+
+    const jl_cgval_t &cmp = isreplacememory || ismodifymemory ? argv[2] : undefval;
+    enum jl_memory_order order = jl_memory_order_notatomic;
+    const std::string fname = issetmemory ? "memoryrefset!" : isreplacememory ? "memoryrefreplace!" : isswapmemory ? "memoryrefswap!" : ismodifymemory ? "memoryrefmodify!" : "memoryrefsetonce!";
+    {
+        const jl_cgval_t &ord = argv[isreplacememory || ismodifymemory ? 4 : 3];
+        emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, fname);
+        if (!ord.constant)
+            return false;
+        order = jl_get_atomic_order((jl_sym_t*)ord.constant, !issetmemory, true);
+    }
+    enum jl_memory_order fail_order = order;
+    if (isreplacememory || issetmemoryonce) {
+        const jl_cgval_t &ord = argv[isreplacememory ? 5 : 4];
+        emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, fname);
+        if (!ord.constant)
+            return false;
+        fail_order = jl_get_atomic_order((jl_sym_t*)ord.constant, true, false);
+    }
+    if (order == jl_memory_order_invalid || fail_order == jl_memory_order_invalid || fail_order > order) {
+        emit_atomic_error(ctx, "invalid atomic ordering");
+        *ret = jl_cgval_t(); // unreachable
+        return true;
+    }
+
+    jl_value_t *boundscheck = argv[nargs].constant;
+    emit_typecheck(ctx, argv[nargs], (jl_value_t*)jl_bool_type, fname);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
+    bool isboxed = layout->flags.arrayelem_isboxed;
+    bool isunion = layout->flags.arrayelem_isunion;
+    bool isatomic = kind == (jl_value_t*)jl_atomic_sym;
+    bool needlock = isatomic && layout->size > MAX_ATOMIC_SIZE;
+    size_t elsz = layout->size;
+    size_t al = layout->alignment;
+    if (isatomic == (order == jl_memory_order_notatomic)) {
+        emit_atomic_error(ctx,
+                issetmemory ?
+                (isatomic ? "memoryrefset!: atomic memory cannot be written non-atomically"
+                          : "memoryrefset!: non-atomic memory cannot be written atomically") :
+                isreplacememory ?
+                (isatomic ? "memoryrefreplace!: atomic memory cannot be written non-atomically"
+                          : "memoryrefreplace!: non-atomic memory cannot be written atomically") :
+                isswapmemory ?
+                (isatomic ? "memoryrefswap!: atomic memory cannot be written non-atomically"
+                          : "memoryrefswap!: non-atomic memory cannot be written atomically") :
+                ismodifymemory ?
+                (isatomic ? "memoryrefmodify!: atomic memory cannot be written non-atomically"
+                          : "memoryrefmodify!: non-atomic memory cannot be written atomically") :
+                (isatomic ? "memoryrefsetonce!: atomic memory cannot be written non-atomically"
+                          : "memoryrefsetonce!: non-atomic memory cannot be written atomically"));
+        *ret = jl_cgval_t();
+        return true;
+    }
+    else if (isatomic == (fail_order == jl_memory_order_notatomic)) {
+        emit_atomic_error(ctx,
+                isreplacememory ?
+                (isatomic ? "memoryrefreplace!: atomic memory cannot be accessed non-atomically"
+                          : "memoryrefreplace!: non-atomic memory cannot be accessed atomically") :
+                (isatomic ? "memoryrefsetonce!: atomic memory cannot be accessed non-atomically"
+                          : "memoryrefsetonce!: non-atomic memory cannot be accessed atomically"));
+        *ret = jl_cgval_t();
+        return true;
+    }
+    Value *mem = emit_memoryref_mem(ctx, ref, layout);
+    Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
+    if (bounds_check_enabled(ctx, boundscheck)) {
+        BasicBlock *failBB, *endBB;
+        failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
+        endBB = BasicBlock::Create(ctx.builder.getContext(), "load");
+        ctx.builder.CreateCondBr(ctx.builder.CreateIsNull(mlen), failBB, endBB);
+        failBB->insertInto(ctx.f);
+        ctx.builder.SetInsertPoint(failBB);
+        ctx.builder.CreateCall(prepare_call(jlboundserror_func), { mark_callee_rooted(ctx, mem), ConstantInt::get(ctx.types().T_size, 1) });
+        ctx.builder.CreateUnreachable();
+        endBB->insertInto(ctx.f);
+        ctx.builder.SetInsertPoint(endBB);
+    }
+    if (!ismodifymemory) {
+        emit_typecheck(ctx, val, ety, fname);
+        val = update_julia_type(ctx, val, ety);
+        if (val.typ == jl_bottom_type)
+            return true;
+    }
+    AtomicOrdering Order = (needlock || order <= jl_memory_order_notatomic)
+                            ? AtomicOrdering::NotAtomic
+                            : get_llvm_atomic_order(order);
+    AtomicOrdering FailOrder = (needlock || fail_order <= jl_memory_order_notatomic)
+                        ? AtomicOrdering::NotAtomic
+                        : get_llvm_atomic_order(fail_order);
+    if (isunion) {
+        assert(!isatomic && !needlock);
+        Value *V = emit_memoryref_FCA(ctx, ref, layout);
+        Value *idx0 = CreateSimplifiedExtractValue(ctx, V, 0);
+        Value *mem = CreateSimplifiedExtractValue(ctx, V, 1);
+        Value *data = emit_genericmemoryptr(ctx, mem, layout, AddressSpace::Loaded);
+        Type *AT = ArrayType::get(IntegerType::get(ctx.builder.getContext(), 8 * al), (elsz + al - 1) / al);
+        data = emit_bitcast(ctx, data, AT->getPointerTo());
+        // compute tindex from val
+        Value *ptindex;
+        if (elsz == 0) {
+            ptindex = data;
+        }
+        else {
+            data = emit_bitcast(ctx, data, AT->getPointerTo());
+            // isbits union selector bytes are stored after mem->length
+            ptindex = ctx.builder.CreateInBoundsGEP(AT, data, mlen);
+            data = ctx.builder.CreateInBoundsGEP(AT, data, idx0);
+        }
+        ptindex = emit_bitcast(ctx, ptindex, getInt8PtrTy(ctx.builder.getContext()));
+        ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), ptindex, idx0);
+        *ret = union_store(ctx, data, ptindex, val, cmp, ety,
+            ctx.tbaa().tbaa_arraybuf, nullptr, ctx.tbaa().tbaa_arrayselbyte,
+            Order, FailOrder,
+            nullptr, issetmemory, isreplacememory, isswapmemory, ismodifymemory, issetmemoryonce,
+            modifyop, fname);
+    }
+    else {
+        Value *ptr = (layout->size == 0 ? nullptr : emit_memoryref_ptr(ctx, ref, layout));
+        Value *lock = nullptr;
+        bool maybenull = true;
+        if (needlock) {
+            assert(ptr);
+            lock = ptr;
+            // ptr += sizeof(lock);
+            ptr = emit_bitcast(ctx, ptr, getInt8PtrTy(ctx.builder.getContext()));
+            ptr = ctx.builder.CreateConstInBoundsGEP1_32(getInt8Ty(ctx.builder.getContext()), ptr, LLT_ALIGN(sizeof(jl_mutex_t), JL_SMALL_BYTE_ALIGNMENT));
+        }
+        Value *data_owner = NULL; // owner object against which the write barrier must check
+        if (isboxed || layout->first_ptr >= 0) { // if elements are just bits, don't need a write barrier
+            Value *V = emit_memoryref_FCA(ctx, ref, layout);
+            data_owner = emit_genericmemoryowner(ctx, CreateSimplifiedExtractValue(ctx, V, 1));
+        }
+        *ret = typed_store(ctx,
+                    ptr,
+                    val, cmp, ety,
+                    isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf,
+                    ctx.noalias().aliasscope.current,
+                    data_owner,
+                    isboxed,
+                    Order,
+                    FailOrder,
+                    al,
+                    lock,
+                    issetmemory,
+                    isreplacememory,
+                    isswapmemory,
+                    ismodifymemory,
+                    issetmemoryonce,
+                    maybenull,
+                    modifyop,
+                    fname,
+                    nullptr,
+                    nullptr);
+    }
+    return true;
+}
+
 static jl_llvm_functions_t
     emit_function(
         orc::ThreadSafeModule &TSM,
@@ -3566,7 +3897,7 @@ static jl_llvm_functions_t
 static void emit_hasnofield_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *type, jl_cgval_t name);
 
 static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
-                              const jl_cgval_t *argv, size_t nargs, jl_value_t *rt,
+                              ArrayRef<jl_cgval_t> argv, size_t nargs, jl_value_t *rt,
                               jl_expr_t *ex, bool is_promotable)
 // returns true if the call has been handled
 {
@@ -3652,7 +3983,7 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
             return true;
         }
         if (jl_is_tuple_type(rt) && jl_is_concrete_type(rt) && nargs == jl_datatype_nfields(rt)) {
-            *ret = emit_new_struct(ctx, rt, nargs, &argv[1], is_promotable);
+            *ret = emit_new_struct(ctx, rt, nargs, argv.drop_front(), is_promotable);
             return true;
         }
     }
@@ -3704,13 +4035,40 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         const jl_cgval_t &ref = argv[1];
         jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
         if (jl_is_genericmemoryref_type(mty_dt) && jl_is_concrete_type(mty_dt)) {
-            jl_value_t *isatomic = jl_tparam0(mty_dt); (void)isatomic; // TODO
+            jl_value_t *kind = jl_tparam0(mty_dt);
             jl_value_t *ety = jl_tparam1(mty_dt);
             jl_value_t *addrspace = jl_tparam2(mty_dt); (void)addrspace; // TODO
             mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
-            jl_value_t *order = argv[2].constant;
-            if (order != (jl_value_t*)jl_not_atomic_sym)
+            if (kind != (jl_value_t*)jl_not_atomic_sym && kind != (jl_value_t*)jl_atomic_sym)
                 return false;
+            enum jl_memory_order order = jl_memory_order_unspecified;
+            const std::string fname = "memoryrefget";
+            {
+                const jl_cgval_t &ord = argv[2];
+                emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, fname);
+                if (!ord.constant)
+                    return false;
+                order = jl_get_atomic_order((jl_sym_t*)ord.constant, true, false);
+            }
+            if (order == jl_memory_order_invalid) {
+                emit_atomic_error(ctx, "invalid atomic ordering");
+                *ret = jl_cgval_t(); // unreachable
+                return true;
+            }
+            bool isatomic = kind == (jl_value_t*)jl_atomic_sym;
+            if (!isatomic && order != jl_memory_order_notatomic && order != jl_memory_order_unspecified) {
+                emit_atomic_error(ctx, "memoryrefget: non-atomic memory cannot be accessed atomically");
+                *ret = jl_cgval_t(); // unreachable
+                return true;
+            }
+            if (isatomic && order == jl_memory_order_notatomic) {
+                emit_atomic_error(ctx, "memoryrefget: atomic memory cannot be accessed non-atomically");
+                *ret = jl_cgval_t(); // unreachable
+                return true;
+            }
+            if (order == jl_memory_order_unspecified) {
+                order = isatomic ? jl_memory_order_unordered : jl_memory_order_notatomic;
+            }
             jl_value_t *boundscheck = argv[3].constant;
             emit_typecheck(ctx, argv[3], (jl_value_t*)jl_bool_type, "memoryref");
             const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
@@ -3732,11 +4090,19 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
             bool isunion = layout->flags.arrayelem_isunion;
             size_t elsz = layout->size;
             size_t al = layout->alignment;
+            bool needlock = isatomic && !isboxed && elsz > MAX_ATOMIC_SIZE;
+            AtomicOrdering Order = (needlock || order <= jl_memory_order_notatomic)
+                                    ? (isboxed ? AtomicOrdering::Unordered : AtomicOrdering::NotAtomic)
+                                    : get_llvm_atomic_order(order);
+            bool maybenull = true;
             if (!isboxed && !isunion && elsz == 0) {
                 assert(jl_is_datatype(ety) && jl_is_datatype_singleton((jl_datatype_t*)ety));
                 *ret = ghostValue(ctx, ety);
+                if (isStrongerThanMonotonic(Order))
+                    ctx.builder.CreateFence(Order);
             }
             else if (isunion) {
+                assert(!isatomic && !needlock);
                 Value *V = emit_memoryref_FCA(ctx, ref, layout);
                 Value *idx0 = CreateSimplifiedExtractValue(ctx, V, 0);
                 Value *mem = CreateSimplifiedExtractValue(ctx, V, 1);
@@ -3760,139 +4126,85 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                 *ret = emit_unionload(ctx, data, ptindex, ety, elsz_c, al, ctx.tbaa().tbaa_arraybuf, true, union_max, ctx.tbaa().tbaa_arrayselbyte);
             }
             else {
-                *ret = typed_load(ctx,
-                        emit_memoryref_ptr(ctx, ref, layout),
-                        nullptr, ety,
+                Value *ptr = (layout->size == 0 ? nullptr : emit_memoryref_ptr(ctx, ref, layout));
+                Value *lock = nullptr;
+                if (needlock) {
+                    assert(ptr);
+                    lock = ptr;
+                    // ptr += sizeof(lock);
+                    ptr = emit_bitcast(ctx, ptr, getInt8PtrTy(ctx.builder.getContext()));
+                    ptr = ctx.builder.CreateConstInBoundsGEP1_32(getInt8Ty(ctx.builder.getContext()), ptr, LLT_ALIGN(sizeof(jl_mutex_t), JL_SMALL_BYTE_ALIGNMENT));
+                    emit_lockstate_value(ctx, lock, true);
+                }
+                *ret = typed_load(ctx, ptr, nullptr, ety,
                         isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf,
                         ctx.noalias().aliasscope.current,
-                        isboxed,
-                        AtomicOrdering::NotAtomic);
+                        isboxed, Order, maybenull, al);
+                if (needlock) {
+                    emit_lockstate_value(ctx, lock, false);
+                }
             }
             return true;
         }
     }
 
-    else if (f == jl_builtin_memoryrefset && nargs == 4) {
+    else if ((f == jl_builtin_memoryrefset && nargs == 4) ||
+             (f == jl_builtin_memoryrefswap && nargs == 4) ||
+             (f == jl_builtin_memoryrefreplace && nargs == 6) ||
+             (f == jl_builtin_memoryrefmodify && nargs == 5) ||
+             (f == jl_builtin_memoryrefsetonce && nargs == 5)) {
+        return emit_f_opmemory(ctx, ret, f, argv, nargs, nullptr);
+    }
+
+
+    else if (f == jl_builtin_memoryref_isassigned && nargs == 3) {
         const jl_cgval_t &ref = argv[1];
-        jl_cgval_t val = argv[2];
         jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
         if (jl_is_genericmemoryref_type(mty_dt) && jl_is_concrete_type(mty_dt)) {
-            jl_value_t *isatomic = jl_tparam0(mty_dt); (void)isatomic; // TODO
-            jl_value_t *ety = jl_tparam1(mty_dt);
-            jl_value_t *addrspace = jl_tparam2(mty_dt); (void)addrspace; // TODO
+            jl_value_t *kind = jl_tparam0(mty_dt);
             mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
-            jl_value_t *order = argv[3].constant;
-            if (order != (jl_value_t*)jl_not_atomic_sym)
+            if (kind != (jl_value_t*)jl_not_atomic_sym && kind != (jl_value_t*)jl_atomic_sym)
                 return false;
-            jl_value_t *boundscheck = argv[4].constant;
-            emit_typecheck(ctx, argv[4], (jl_value_t*)jl_bool_type, "memoryset");
-            const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
-            Value *mem = emit_memoryref_mem(ctx, ref, layout);
-            Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
-            if (bounds_check_enabled(ctx, boundscheck)) {
-                BasicBlock *failBB, *endBB;
-                failBB = BasicBlock::Create(ctx.builder.getContext(), "oob");
-                endBB = BasicBlock::Create(ctx.builder.getContext(), "load");
-                ctx.builder.CreateCondBr(ctx.builder.CreateIsNull(mlen), failBB, endBB);
-                failBB->insertInto(ctx.f);
-                ctx.builder.SetInsertPoint(failBB);
-                ctx.builder.CreateCall(prepare_call(jlboundserror_func), { mark_callee_rooted(ctx, mem), ConstantInt::get(ctx.types().T_size, 1) });
-                ctx.builder.CreateUnreachable();
-                endBB->insertInto(ctx.f);
-                ctx.builder.SetInsertPoint(endBB);
+            enum jl_memory_order order = jl_memory_order_unspecified;
+            const std::string fname = "memoryref_isassigned";
+            {
+                const jl_cgval_t &ord = argv[2];
+                emit_typecheck(ctx, ord, (jl_value_t*)jl_symbol_type, fname);
+                if (!ord.constant)
+                    return false;
+                order = jl_get_atomic_order((jl_sym_t*)ord.constant, true, false);
             }
-            emit_typecheck(ctx, val, ety, "memoryset");
-            val = update_julia_type(ctx, val, ety);
-            if (val.typ == jl_bottom_type)
+            if (order == jl_memory_order_invalid) {
+                emit_atomic_error(ctx, "invalid atomic ordering");
+                *ret = jl_cgval_t(); // unreachable
                 return true;
-            bool isboxed = layout->flags.arrayelem_isboxed;
-            bool isunion = layout->flags.arrayelem_isunion;
-            size_t elsz = layout->size;
-            size_t al = layout->alignment;
-            if (isboxed)
-               ety = (jl_value_t*)jl_any_type;
-            if (!isboxed && !isunion && elsz == 0) {
-                assert(jl_is_datatype(ety) && jl_datatype_size(ety) == 0);
-                // no-op
             }
-            else {
-                Value *V = emit_memoryref_FCA(ctx, ref, layout);
-                Value *data_owner = NULL; // owner object against which the write barrier must check
-                if (isboxed || layout->first_ptr >= 0) { // if elements are just bits, don't need a write barrier
-                    data_owner = emit_genericmemoryowner(ctx, CreateSimplifiedExtractValue(ctx, V, 1));
-                }
-                if (isunion) {
-                    Value *idx0 = CreateSimplifiedExtractValue(ctx, V, 0);
-                    Value *mem = CreateSimplifiedExtractValue(ctx, V, 1);
-                    Value *data = emit_genericmemoryptr(ctx, mem, layout, AddressSpace::Loaded);
-                    Type *AT = ArrayType::get(IntegerType::get(ctx.builder.getContext(), 8 * al), (elsz + al - 1) / al);
-                    data = emit_bitcast(ctx, data, AT->getPointerTo());
-                    // compute tindex from val
-                    jl_cgval_t rhs_union = convert_julia_type(ctx, val, ety);
-                    Value *tindex = compute_tindex_unboxed(ctx, rhs_union, ety);
-                    tindex = ctx.builder.CreateNUWSub(tindex, ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 1));
-                    Value *ptindex;
-                    if (elsz == 0) {
-                        ptindex = data;
-                    }
-                    else {
-                        data = emit_bitcast(ctx, data, AT->getPointerTo());
-                        // isbits union selector bytes are stored after mem->length
-                        ptindex = ctx.builder.CreateInBoundsGEP(AT, data, mlen);
-                        data = ctx.builder.CreateInBoundsGEP(AT, data, idx0);
-                    }
-                    ptindex = emit_bitcast(ctx, ptindex, getInt8PtrTy(ctx.builder.getContext()));
-                    ptindex = ctx.builder.CreateInBoundsGEP(getInt8Ty(ctx.builder.getContext()), ptindex, idx0);
-                    jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_arrayselbyte);
-                    ai.decorateInst(ctx.builder.CreateStore(tindex, ptindex));
-                    if (elsz > 0 && (!jl_is_datatype(val.typ) || jl_datatype_size(val.typ) > 0)) {
-                        // copy data (if any)
-                        emit_unionmove(ctx, data, ctx.tbaa().tbaa_arraybuf, val, nullptr);
-                    }
-                }
-                else {
-                    typed_store(ctx,
-                                emit_memoryref_ptr(ctx, ref, layout),
-                                nullptr, val, jl_cgval_t(), ety,
-                                isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf,
-                                ctx.noalias().aliasscope.current,
-                                data_owner,
-                                isboxed,
-                                isboxed ? AtomicOrdering::Release : AtomicOrdering::NotAtomic, // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
-                                /*FailOrder*/AtomicOrdering::NotAtomic, // TODO: we should do this for anything with CountTrackedPointers(elty).count > 0
-                                0,
-                                false,
-                                true,
-                                false,
-                                false,
-                                false,
-                                false,
-                                nullptr,
-                                "");
-                }
+            bool isatomic = kind == (jl_value_t*)jl_atomic_sym;
+            if (!isatomic && order != jl_memory_order_notatomic && order != jl_memory_order_unspecified) {
+                emit_atomic_error(ctx, "memoryref_isassigned: non-atomic memory cannot be accessed atomically");
+                *ret = jl_cgval_t(); // unreachable
+                return true;
+            }
+            if (isatomic && order == jl_memory_order_notatomic) {
+                emit_atomic_error(ctx, "memoryref_isassigned: atomic memory cannot be accessed non-atomically");
+                *ret = jl_cgval_t(); // unreachable
+                return true;
+            }
+            if (order == jl_memory_order_unspecified) {
+                order = isatomic ? jl_memory_order_unordered : jl_memory_order_notatomic;
             }
-            *ret = ref;
-            return true;
-        }
-    }
-
-    else if (f == jl_builtin_memoryref_isassigned && nargs == 3) {
-        const jl_cgval_t &ref = argv[1];
-        jl_value_t *mty_dt = jl_unwrap_unionall(ref.typ);
-        if (jl_is_genericmemoryref_type(mty_dt) && jl_is_concrete_type(mty_dt)) {
-            jl_value_t *isatomic = jl_tparam0(mty_dt); (void)isatomic; // TODO
-            mty_dt = jl_field_type_concrete((jl_datatype_t*)mty_dt, 1);
-            jl_value_t *order = argv[2].constant;
-            if (order != (jl_value_t*)jl_not_atomic_sym)
-                return false;
             jl_value_t *boundscheck = argv[3].constant;
-            emit_typecheck(ctx, argv[3], (jl_value_t*)jl_bool_type, "memory_isassigned");
+            emit_typecheck(ctx, argv[3], (jl_value_t*)jl_bool_type, fname);
             const jl_datatype_layout_t *layout = ((jl_datatype_t*)mty_dt)->layout;
             Value *mem = emit_memoryref_mem(ctx, ref, layout);
             Value *mlen = emit_genericmemorylen(ctx, mem, ref.typ);
             Value *oob = bounds_check_enabled(ctx, boundscheck) ? ctx.builder.CreateIsNull(mlen) : nullptr;
             bool isboxed = layout->flags.arrayelem_isboxed;
             if (isboxed || layout->first_ptr >= 0) {
+                bool needlock = isatomic && !isboxed && layout->size > MAX_ATOMIC_SIZE;
+                AtomicOrdering Order = (needlock || order <= jl_memory_order_notatomic)
+                                        ? (isboxed ? AtomicOrdering::Unordered : AtomicOrdering::NotAtomic)
+                                        : get_llvm_atomic_order(order);
                 PHINode *result = nullptr;
                 if (oob) {
                     BasicBlock *passBB, *endBB, *fromBB;
@@ -3909,6 +4221,12 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                     ctx.builder.SetInsertPoint(passBB);
                 }
                 Value *elem = emit_memoryref_ptr(ctx, ref, layout);
+                if (needlock) {
+                    // n.b. no actual lock acquire needed, as the check itself only needs to load a single pointer and check for null
+                    // elem += sizeof(lock);
+                    elem = emit_bitcast(ctx, elem, getInt8PtrTy(ctx.builder.getContext()));
+                    elem = ctx.builder.CreateConstInBoundsGEP1_32(getInt8Ty(ctx.builder.getContext()), elem, LLT_ALIGN(sizeof(jl_mutex_t), JL_SMALL_BYTE_ALIGNMENT));
+                }
                 elem = emit_bitcast(ctx, elem, ctx.types().T_pprjlvalue);
                 if (!isboxed)
                     elem = ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue, elem, layout->first_ptr);
@@ -3917,10 +4235,10 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                 auto tbaa = isboxed ? ctx.tbaa().tbaa_ptrarraybuf : ctx.tbaa().tbaa_arraybuf;
                 jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa);
                 LoadInst *fldv = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, elem, ctx.types().alignof_ptr);
-                //fldv->setOrdering(AtomicOrdering::Unordered);
+                fldv->setOrdering(Order);
                 ai.decorateInst(fldv);
                 Value *isdef = ctx.builder.CreateIsNotNull(fldv);
-                setName(ctx.emission_context, isdef, "memoryref_isassigned");
+                setName(ctx.emission_context, isdef, fname);
                 if (oob) {
                     assert(result);
                     result->addIncoming(isdef, ctx.builder.CreateBr(result->getParent())->getParent());
@@ -4134,14 +4452,19 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         return false;
     }
 
-    else if (f == jl_builtin_setglobal && (nargs == 3 || nargs == 4)) {
+    else if ((f == jl_builtin_setglobal && (nargs == 3 || nargs == 4)) ||
+             (f == jl_builtin_swapglobal && (nargs == 3 || nargs == 4)) ||
+             (f == jl_builtin_replaceglobal && (nargs == 4 || nargs == 5 || nargs == 6)) ||
+             (f == jl_builtin_modifyglobal && (nargs == 4 || nargs == 5)) ||
+             (f == jl_builtin_setglobalonce && (nargs == 3 || nargs == 4 || nargs == 5))) {
         return emit_f_opglobal(ctx, ret, f, argv, nargs, nullptr);
     }
 
     else if ((f == jl_builtin_setfield && (nargs == 3 || nargs == 4)) ||
              (f == jl_builtin_swapfield && (nargs == 3 || nargs == 4)) ||
              (f == jl_builtin_replacefield && (nargs == 4 || nargs == 5 || nargs == 6)) ||
-             (f == jl_builtin_modifyfield && (nargs == 4 || nargs == 5))) {
+             (f == jl_builtin_modifyfield && (nargs == 4 || nargs == 5)) ||
+             (f == jl_builtin_setfieldonce && (nargs == 3 || nargs == 4 || nargs == 5))) {
         return emit_f_opfield(ctx, ret, f, argv, nargs, nullptr);
     }
 
@@ -4413,7 +4736,7 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
 
 // Returns ctx.types().T_prjlvalue
 static CallInst *emit_jlcall(jl_codectx_t &ctx, FunctionCallee theFptr, Value *theF,
-                             const jl_cgval_t *argv, size_t nargs, JuliaFunction<> *trampoline)
+                             ArrayRef<jl_cgval_t> argv, size_t nargs, JuliaFunction<> *trampoline)
 {
     ++EmittedJLCalls;
     Function *TheTrampoline = prepare_call(trampoline);
@@ -4434,13 +4757,13 @@ static CallInst *emit_jlcall(jl_codectx_t &ctx, FunctionCallee theFptr, Value *t
 
 // Returns ctx.types().T_prjlvalue
 static CallInst *emit_jlcall(jl_codectx_t &ctx, JuliaFunction<> *theFptr, Value *theF,
-                             const jl_cgval_t *argv, size_t nargs, JuliaFunction<> *trampoline)
+                             ArrayRef<jl_cgval_t> argv, size_t nargs, JuliaFunction<> *trampoline)
 {
     return emit_jlcall(ctx, prepare_call(theFptr), theF, argv, nargs, trampoline);
 }
 
 static jl_cgval_t emit_call_specfun_other(jl_codectx_t &ctx, bool is_opaque_closure, jl_value_t *specTypes, jl_value_t *jlretty, llvm::Value *callee, StringRef specFunctionObject, jl_code_instance_t *fromexternal,
-                                          const jl_cgval_t *argv, size_t nargs, jl_returninfo_t::CallingConv *cc, unsigned *return_roots, jl_value_t *inferred_retty)
+                                          ArrayRef<jl_cgval_t> argv, size_t nargs, jl_returninfo_t::CallingConv *cc, unsigned *return_roots, jl_value_t *inferred_retty)
 {
     ++EmittedSpecfunCalls;
     // emit specialized call site
@@ -4589,7 +4912,7 @@ static jl_cgval_t emit_call_specfun_other(jl_codectx_t &ctx, bool is_opaque_clos
 }
 
 static jl_cgval_t emit_call_specfun_other(jl_codectx_t &ctx, jl_method_instance_t *mi, jl_value_t *jlretty, StringRef specFunctionObject, jl_code_instance_t *fromexternal,
-                                          const jl_cgval_t *argv, size_t nargs, jl_returninfo_t::CallingConv *cc, unsigned *return_roots, jl_value_t *inferred_retty)
+                                          ArrayRef<jl_cgval_t> argv, size_t nargs, jl_returninfo_t::CallingConv *cc, unsigned *return_roots, jl_value_t *inferred_retty)
 {
     bool is_opaque_closure = jl_is_method(mi->def.value) && mi->def.method->is_for_opaque_closure;
     return emit_call_specfun_other(ctx, is_opaque_closure, mi->specTypes, jlretty, NULL,
@@ -4597,7 +4920,7 @@ static jl_cgval_t emit_call_specfun_other(jl_codectx_t &ctx, jl_method_instance_
 }
 
 static jl_cgval_t emit_call_specfun_boxed(jl_codectx_t &ctx, jl_value_t *jlretty, StringRef specFunctionObject, jl_code_instance_t *fromexternal,
-                                          const jl_cgval_t *argv, size_t nargs, jl_value_t *inferred_retty)
+                                          ArrayRef<jl_cgval_t> argv, size_t nargs, jl_value_t *inferred_retty)
 {
     Value *theFptr;
     if (fromexternal) {
@@ -4638,10 +4961,10 @@ static jl_cgval_t emit_invoke(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt)
         if (argv[i].typ == jl_bottom_type)
             return jl_cgval_t();
     }
-    return emit_invoke(ctx, lival, argv.data(), nargs, rt);
+    return emit_invoke(ctx, lival, argv, nargs, rt);
 }
 
-static jl_cgval_t emit_invoke(jl_codectx_t &ctx, const jl_cgval_t &lival, const jl_cgval_t *argv, size_t nargs, jl_value_t *rt)
+static jl_cgval_t emit_invoke(jl_codectx_t &ctx, const jl_cgval_t &lival, ArrayRef<jl_cgval_t> argv, size_t nargs, jl_value_t *rt)
 {
     ++EmittedInvokes;
     bool handled = false;
@@ -4760,27 +5083,45 @@ static jl_cgval_t emit_invoke_modify(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_
             return jl_cgval_t();
     }
     const jl_cgval_t &f = argv[0];
-    jl_cgval_t ret;
-    if (f.constant && f.constant == jl_builtin_modifyfield) {
-        if (emit_f_opfield(ctx, &ret, jl_builtin_modifyfield, argv.data(), nargs - 1, &lival))
-            return ret;
-        auto it = builtin_func_map().find(jl_f_modifyfield_addr);
-        assert(it != builtin_func_map().end());
-        Value *oldnew = emit_jlcall(ctx, it->second, Constant::getNullValue(ctx.types().T_prjlvalue), &argv[1], nargs - 1, julia_call);
-        return mark_julia_type(ctx, oldnew, true, rt);
-    }
-    if (f.constant && jl_typetagis(f.constant, jl_intrinsic_type)) {
-        JL_I::intrinsic fi = (intrinsic)*(uint32_t*)jl_data_ptr(f.constant);
-        if (fi == JL_I::atomic_pointermodify && jl_intrinsic_nargs((int)fi) == nargs - 1)
-            return emit_atomic_pointerop(ctx, fi, argv.data(), nargs - 1, &lival);
+    if (f.constant) {
+        jl_cgval_t ret;
+        auto it = builtin_func_map().end();
+        if (f.constant == jl_builtin_modifyfield) {
+            if (emit_f_opfield(ctx, &ret, jl_builtin_modifyfield, argv, nargs - 1, &lival))
+                return ret;
+            it = builtin_func_map().find(jl_f_modifyfield_addr);
+            assert(it != builtin_func_map().end());
+        }
+        else if (f.constant == jl_builtin_modifyglobal) {
+            if (emit_f_opglobal(ctx, &ret, jl_builtin_modifyglobal, argv, nargs - 1, &lival))
+                return ret;
+            it = builtin_func_map().find(jl_f_modifyglobal_addr);
+            assert(it != builtin_func_map().end());
+        }
+        else if (f.constant == jl_builtin_memoryrefmodify) {
+            if (emit_f_opmemory(ctx, &ret, jl_builtin_memoryrefmodify, argv, nargs - 1, &lival))
+                return ret;
+            it = builtin_func_map().find(jl_f_memoryrefmodify_addr);
+            assert(it != builtin_func_map().end());
+        }
+        else if (jl_typetagis(f.constant, jl_intrinsic_type)) {
+            JL_I::intrinsic fi = (intrinsic)*(uint32_t*)jl_data_ptr(f.constant);
+            if (fi == JL_I::atomic_pointermodify && jl_intrinsic_nargs((int)fi) == nargs - 1)
+                return emit_atomic_pointerop(ctx, fi, ArrayRef<jl_cgval_t>(argv).drop_front(), nargs - 1, &lival);
+        }
+
+        if (it != builtin_func_map().end()) {
+            Value *oldnew = emit_jlcall(ctx, it->second, Constant::getNullValue(ctx.types().T_prjlvalue), ArrayRef<jl_cgval_t>(argv).drop_front(), nargs - 1, julia_call);
+            return mark_julia_type(ctx, oldnew, true, rt);
+        }
     }
 
     // emit function and arguments
-    Value *callval = emit_jlcall(ctx, jlapplygeneric_func, nullptr, argv.data(), nargs, julia_call);
+    Value *callval = emit_jlcall(ctx, jlapplygeneric_func, nullptr, argv, nargs, julia_call);
     return mark_julia_type(ctx, callval, true, rt);
 }
 
-static jl_cgval_t emit_specsig_oc_call(jl_codectx_t &ctx, jl_value_t *oc_type, jl_value_t *sigtype, jl_cgval_t *argv, size_t nargs)
+static jl_cgval_t emit_specsig_oc_call(jl_codectx_t &ctx, jl_value_t *oc_type, jl_value_t *sigtype, MutableArrayRef<jl_cgval_t> argv /*n.b. this mutation is unusual */, size_t nargs)
 {
     jl_datatype_t *oc_argt = (jl_datatype_t *)jl_tparam0(oc_type);
     jl_value_t *oc_rett = jl_tparam1(oc_type);
@@ -4827,8 +5168,7 @@ static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt, bo
 
     size_t n_generic_args = nargs;
 
-    SmallVector<jl_cgval_t, 0> generic_argv(n_generic_args);
-    jl_cgval_t *argv = generic_argv.data();
+    SmallVector<jl_cgval_t, 0> argv(n_generic_args);
 
     argv[0] = f;
     for (size_t i = 1; i < nargs; ++i) {
@@ -4849,7 +5189,7 @@ static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt, bo
             // special case for some known builtin not handled by emit_builtin_call
             auto it = builtin_func_map().find(jl_get_builtin_fptr((jl_datatype_t*)jl_typeof(f.constant)));
             if (it != builtin_func_map().end()) {
-                Value *ret = emit_jlcall(ctx, it->second, Constant::getNullValue(ctx.types().T_prjlvalue), &argv[1], nargs - 1, julia_call);
+                Value *ret = emit_jlcall(ctx, it->second, Constant::getNullValue(ctx.types().T_prjlvalue), ArrayRef<jl_cgval_t>(argv).drop_front(), nargs - 1, julia_call);
                 setName(ctx.emission_context, ret, it->second->name + "_ret");
                 return mark_julia_type(ctx, ret, true, rt);
             }
@@ -4868,7 +5208,7 @@ static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt, bo
             F = boxed(ctx, f);
             cc = julia_call;
         }
-        Value *ret = emit_jlcall(ctx, fptr, F, &argv[1], nargs - 1, cc);
+        Value *ret = emit_jlcall(ctx, fptr, F, ArrayRef<jl_cgval_t>(argv).drop_front(), nargs - 1, cc);
         setName(ctx.emission_context, ret, "Builtin_ret");
         return mark_julia_type(ctx, ret, true, rt);
     }
@@ -4889,27 +5229,12 @@ static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *rt, bo
     }
 
     // emit function and arguments
-    Value *callval = emit_jlcall(ctx, jlapplygeneric_func, nullptr, generic_argv.data(), n_generic_args, julia_call);
+    Value *callval = emit_jlcall(ctx, jlapplygeneric_func, nullptr, argv, n_generic_args, julia_call);
     return mark_julia_type(ctx, callval, true, rt);
 }
 
 // --- accessing and assigning variables ---
 
-static void undef_var_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *name, jl_value_t *scope)
-{
-    ++EmittedUndefVarErrors;
-    BasicBlock *err = BasicBlock::Create(ctx.builder.getContext(), "err", ctx.f);
-    BasicBlock *ifok = BasicBlock::Create(ctx.builder.getContext(), "ok");
-    ctx.builder.CreateCondBr(ok, ifok, err);
-    ctx.builder.SetInsertPoint(err);
-    ctx.builder.CreateCall(prepare_call(jlundefvarerror_func), {
-            mark_callee_rooted(ctx, literal_pointer_val(ctx, (jl_value_t*)name)),
-            mark_callee_rooted(ctx, literal_pointer_val(ctx, scope))});
-    ctx.builder.CreateUnreachable();
-    ifok->insertInto(ctx.f);
-    ctx.builder.SetInsertPoint(ifok);
-}
-
 static void emit_hasnofield_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *type, jl_cgval_t name)
 {
     ++EmittedUndefVarErrors;
@@ -5483,7 +5808,8 @@ static void emit_assignment(jl_codectx_t &ctx, jl_value_t *l, jl_value_t *r, ssi
         mod = jl_globalref_mod(l);
         sym = jl_globalref_name(l);
     }
-    emit_globalset(ctx, mod, sym, rval_info, AtomicOrdering::Release);
+    emit_globalop(ctx, mod, sym, rval_info, jl_cgval_t(), AtomicOrdering::Release, AtomicOrdering::NotAtomic,
+                  true, false, false, false, false, nullptr);
     // Global variable. Does not need debug info because the debugger knows about
     // its memory location.
 }
@@ -5950,12 +6276,12 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
                 jl_is_datatype(jl_tparam0(ty)) &&
                 jl_is_concrete_type(jl_tparam0(ty))) {
             assert(nargs <= jl_datatype_nfields(jl_tparam0(ty)) + 1);
-            jl_cgval_t res = emit_new_struct(ctx, jl_tparam0(ty), nargs - 1, argv.data() + 1, is_promotable);
+            jl_cgval_t res = emit_new_struct(ctx, jl_tparam0(ty), nargs - 1, ArrayRef<jl_cgval_t>(argv).drop_front(), is_promotable);
             if (is_promotable && res.promotion_point && res.promotion_ssa==-1)
                 res.promotion_ssa = ssaidx_0based;
             return res;
         }
-        Value *val = emit_jlcall(ctx, jlnew_func, nullptr, argv.data(), nargs, julia_call);
+        Value *val = emit_jlcall(ctx, jlnew_func, nullptr, argv, nargs, julia_call);
         // temporarily mark as `Any`, expecting `emit_ssaval_assign` to update
         // it to the inferred type.
         return mark_julia_type(ctx, val, true, (jl_value_t*)jl_any_type);
@@ -6022,7 +6348,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
                         fptr = mark_julia_type(ctx, Constant::getNullValue(ctx.types().T_size), false, jl_voidpointer_type);
 
                     // TODO: Inline the env at the end of the opaque closure and generate a descriptor for GC
-                    jl_cgval_t env = emit_new_struct(ctx, env_t, nargs-4, &argv.data()[4]);
+                    jl_cgval_t env = emit_new_struct(ctx, env_t, nargs-4, ArrayRef<jl_cgval_t>(argv).drop_front(4));
 
                     jl_cgval_t closure_fields[5] = {
                         env,
@@ -6043,7 +6369,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
         }
 
         return mark_julia_type(ctx,
-                emit_jlcall(ctx, jl_new_opaque_closure_jlcall_func, Constant::getNullValue(ctx.types().T_prjlvalue), argv.data(), nargs, julia_call),
+                emit_jlcall(ctx, jl_new_opaque_closure_jlcall_func, Constant::getNullValue(ctx.types().T_prjlvalue), argv, nargs, julia_call),
                 true, jl_any_type);
     }
     else if (head == jl_exc_sym) {
@@ -6293,7 +6619,7 @@ static void emit_cfunc_invalidate(
         }
     }
     assert(AI == gf_thunk->arg_end());
-    Value *gf_ret = emit_jlcall(ctx, target, nullptr, myargs.data(), nargs, julia_call);
+    Value *gf_ret = emit_jlcall(ctx, target, nullptr, myargs, nargs, julia_call);
     jl_cgval_t gf_retbox = mark_julia_type(ctx, gf_ret, true, jl_any_type);
     if (cc != jl_returninfo_t::Boxed) {
         emit_typecheck(ctx, gf_retbox, rettype, "cfunction");
@@ -6703,11 +7029,11 @@ static Function* gen_cfun_wrapper(
             // for jlcall, we need to pass the function object even if it is a ghost.
             Value *theF = boxed(ctx, inputargs[0]);
             assert(theF);
-            ret_jlcall = emit_jlcall(ctx, theFptr, theF, &inputargs[1], nargs, julia_call);
+            ret_jlcall = emit_jlcall(ctx, theFptr, theF, ArrayRef<jl_cgval_t>(inputargs).drop_front(), nargs, julia_call);
             ctx.builder.CreateBr(b_after);
             ctx.builder.SetInsertPoint(b_generic);
         }
-        Value *ret = emit_jlcall(ctx, jlapplygeneric_func, NULL, inputargs.data(), nargs + 1, julia_call);
+        Value *ret = emit_jlcall(ctx, jlapplygeneric_func, NULL, inputargs, nargs + 1, julia_call);
         if (age_ok) {
             ctx.builder.CreateBr(b_after);
             ctx.builder.SetInsertPoint(b_after);
@@ -8275,12 +8601,12 @@ static jl_llvm_functions_t
                 vargs[i - nreq] = get_specsig_arg(argType, llvmArgType, isboxed);
             }
             if (jl_is_concrete_type(vi.value.typ)) {
-                jl_cgval_t tuple = emit_new_struct(ctx, vi.value.typ, ctx.nvargs, vargs.data());
+                jl_cgval_t tuple = emit_new_struct(ctx, vi.value.typ, ctx.nvargs, vargs);
                 emit_varinfo_assign(ctx, vi, tuple);
             }
             else {
                 restTuple = emit_jlcall(ctx, jltuple_func, Constant::getNullValue(ctx.types().T_prjlvalue),
-                    vargs.data(), ctx.nvargs, julia_call);
+                    vargs, ctx.nvargs, julia_call);
                 jl_cgval_t tuple = mark_julia_type(ctx, restTuple, true, vi.value.typ);
                 emit_varinfo_assign(ctx, vi, tuple);
             }
@@ -9518,6 +9844,10 @@ static void init_jit_functions(void)
     add_named_global(except_enter_func, (void*)NULL);
     add_named_global(julia_call, (void*)NULL);
     add_named_global(julia_call2, (void*)NULL);
+    add_named_global(jllockvalue_func, &jl_lock_value);
+    add_named_global(jlunlockvalue_func, &jl_unlock_value);
+    add_named_global(jllockfield_func, &jl_lock_field);
+    add_named_global(jlunlockfield_func, &jl_unlock_field);
 
 #ifdef _OS_WINDOWS_
 #if defined(_CPU_X86_64_)
diff --git a/src/datatype.c b/src/datatype.c
index 7a04bfd7f2046..f9f7dec3d1b13 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -488,7 +488,7 @@ static int is_type_identityfree(jl_value_t *t)
 // make a copy of the layout of st, but with nfields=0
 void jl_get_genericmemory_layout(jl_datatype_t *st)
 {
-    jl_value_t *isatomic = jl_tparam0(st);
+    jl_value_t *kind = jl_tparam0(st);
     jl_value_t *eltype = jl_tparam1(st);
     jl_value_t *addrspace = jl_tparam2(st);
     if (!jl_is_typevar(eltype) && !jl_is_type(eltype)) {
@@ -499,18 +499,25 @@ void jl_get_genericmemory_layout(jl_datatype_t *st)
         return;
     }
 
-    size_t elsz = 0, al = 0;
-    int isunboxed = jl_islayout_inline(eltype, &elsz, &al);
+    size_t elsz = 0, al = 1;
+    int isunboxed = jl_islayout_inline(eltype, &elsz, &al) && (kind != (jl_value_t*)jl_atomic_sym || jl_is_datatype(eltype));
     int isunion = isunboxed && jl_is_uniontype(eltype);
-    int haspadding = 1; // we may want to eventually actually compute this
+    int haspadding = 1; // we may want to eventually actually compute this more precisely
     int nfields = 0; // aka jl_is_layout_opaque
     int npointers = 1;
     int zi;
     uint32_t first_ptr = -1;
     uint32_t *pointers = &first_ptr;
+    int needlock = 0;
 
     if (isunboxed) {
         elsz = LLT_ALIGN(elsz, al);
+        if (kind == (jl_value_t*)jl_atomic_sym) {
+            if (elsz > MAX_ATOMIC_SIZE)
+                needlock = 1;
+            else if (elsz > 0)
+                al = elsz = next_power_of_two(elsz);
+        }
         if (isunion) {
             zi = 1;
         }
@@ -532,6 +539,13 @@ void jl_get_genericmemory_layout(jl_datatype_t *st)
                 }
             }
         }
+        if (needlock) {
+            assert(al <= JL_SMALL_BYTE_ALIGNMENT);
+            size_t offset = LLT_ALIGN(sizeof(jl_mutex_t), JL_SMALL_BYTE_ALIGNMENT);
+            elsz += offset;
+            haspadding = 1;
+            zi = 1;
+        }
     }
     else {
         elsz = sizeof(void*);
@@ -554,13 +568,15 @@ void jl_get_genericmemory_layout(jl_datatype_t *st)
     //st->ismutationfree = 0;
     //st->isidentityfree = 0;
 
-    if (isatomic == (jl_value_t*)jl_not_atomic_sym && jl_is_addrspacecore(addrspace) && jl_unbox_uint8(addrspace) == 0) {
-        jl_genericmemory_t *zeroinst = (jl_genericmemory_t*)jl_gc_permobj(LLT_ALIGN(sizeof(jl_genericmemory_t), JL_SMALL_BYTE_ALIGNMENT) + (elsz ? elsz : isunion), st);
-        zeroinst->length = 0;
-        zeroinst->ptr = (char*)zeroinst + JL_SMALL_BYTE_ALIGNMENT;
-        memset(zeroinst->ptr, 0, elsz ? elsz : isunion);
-        assert(!st->instance);
-        st->instance = (jl_value_t*)zeroinst;
+    if (jl_is_addrspacecore(addrspace) && jl_unbox_uint8(addrspace) == 0) {
+        if (kind == (jl_value_t*)jl_not_atomic_sym || kind == (jl_value_t*)jl_atomic_sym) {
+            jl_genericmemory_t *zeroinst = (jl_genericmemory_t*)jl_gc_permobj(LLT_ALIGN(sizeof(jl_genericmemory_t), JL_SMALL_BYTE_ALIGNMENT) + (elsz ? elsz : isunion), st);
+            zeroinst->length = 0;
+            zeroinst->ptr = (char*)zeroinst + JL_SMALL_BYTE_ALIGNMENT;
+            memset(zeroinst->ptr, 0, elsz ? elsz : isunion);
+            assert(!st->instance);
+            st->instance = (jl_value_t*)zeroinst;
+        }
     }
 }
 
@@ -1060,6 +1076,7 @@ JL_DLLEXPORT jl_value_t *jl_new_bits(jl_value_t *dt, const void *data)
     assert(!bt->smalltag);
     jl_task_t *ct = jl_current_task;
     jl_value_t *v = jl_gc_alloc(ct->ptls, nb, bt);
+    // TODO: make this a memmove_refs if relevant
     memcpy(jl_assume_aligned(v, sizeof(void*)), data, nb);
     return v;
 }
@@ -1214,13 +1231,10 @@ JL_DLLEXPORT int jl_atomic_bool_cmpswap_bits(char *dst, const jl_value_t *expect
     return success;
 }
 
-JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t *rettyp, char *dst, const jl_value_t *expected, const jl_value_t *src, int nb)
+JL_DLLEXPORT int jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_value_t *y /* pre-allocated output */, char *dst, const jl_value_t *expected, const jl_value_t *src, int nb)
 {
     // dst must have the required alignment for an atomic of the given size
     // n.b.: this does not spuriously fail if there are padding bits
-    jl_task_t *ct = jl_current_task;
-    int isptr = jl_field_isptr(rettyp, 0);
-    jl_value_t *y = jl_gc_alloc(ct->ptls, isptr ? nb : jl_datatype_size(rettyp), isptr ? dt : rettyp);
     int success;
     jl_datatype_t *et = (jl_datatype_t*)jl_typeof(expected);
     if (nb == 0) {
@@ -1307,16 +1321,54 @@ JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t
     else {
         abort();
     }
-    if (isptr) {
-        JL_GC_PUSH1(&y);
-        jl_value_t *z = jl_gc_alloc(ct->ptls, jl_datatype_size(rettyp), rettyp);
-        *(jl_value_t**)z = y;
-        JL_GC_POP();
-        y = z;
-        nb = sizeof(jl_value_t*);
+    return success;
+}
+
+JL_DLLEXPORT int jl_atomic_storeonce_bits(jl_datatype_t *dt, char *dst, const jl_value_t *src, int nb)
+{
+    // dst must have the required alignment for an atomic of the given size
+    // n.b.: this does not spuriously fail
+    // n.b.: hasptr == 1 therefore nb >= sizeof(void*), because ((jl_datatype_t*)ty)->layout->has_ptr >= 0
+    int success;
+#ifdef _P64
+    if (nb <= 4) {
+        uint32_t y32 = 0;
+        uint32_t z32 = zext_read32(src, nb);
+        success = jl_atomic_cmpswap((_Atomic(uint32_t)*)dst, &y32, z32);
     }
-    *((uint8_t*)y + nb) = success ? 1 : 0;
-    return y;
+#if MAX_POINTERATOMIC_SIZE >= 8
+    else if (nb <= 8) {
+        uint64_t y64 = 0;
+        uint64_t z64 = zext_read64(src, nb);
+        while (1) {
+            success = jl_atomic_cmpswap((_Atomic(uint64_t)*)dst, &y64, z64);
+            if (success || undefref_check(dt, (jl_value_t*)&y64) != NULL)
+                break;
+        }
+    }
+#endif
+#else
+    if (nb <= 8) {
+        uint64_t y64 = 0;
+        uint64_t z64 = zext_read64(src, nb);
+        success = jl_atomic_cmpswap((_Atomic(uint64_t)*)dst, &y64, z64);
+    }
+#endif
+#if MAX_POINTERATOMIC_SIZE >= 16
+    else if (nb <= 16) {
+        jl_uint128_t y128 = 0;
+        jl_uint128_t z128 = zext_read128(src, nb);
+        while (1) {
+            success = jl_atomic_cmpswap((_Atomic(jl_uint128_t)*)dst, &y128, z128);
+            if (success || undefref_check(dt, (jl_value_t*)&y128) != NULL)
+                break;
+        }
+    }
+#endif
+    else {
+        abort();
+    }
+    return success;
 }
 
 #define PERMBOXN_FUNC(nb)                                               \
@@ -1607,14 +1659,51 @@ JL_DLLEXPORT jl_value_t *jl_new_struct_uninit(jl_datatype_t *type)
 
 // field access ---------------------------------------------------------------
 
-JL_DLLEXPORT void jl_lock_value(jl_value_t *v) JL_NOTSAFEPOINT
+// TODO(jwn): these lock/unlock pairs must be full seq-cst fences
+JL_DLLEXPORT void jl_lock_value(jl_mutex_t *v) JL_NOTSAFEPOINT
+{
+    JL_LOCK_NOGC(v);
+}
+
+JL_DLLEXPORT void jl_unlock_value(jl_mutex_t *v) JL_NOTSAFEPOINT
+{
+    JL_UNLOCK_NOGC(v);
+}
+
+JL_DLLEXPORT void jl_lock_field(jl_mutex_t *v) JL_NOTSAFEPOINT
 {
-    JL_LOCK_NOGC((jl_mutex_t*)v);
+    JL_LOCK_NOGC(v);
+}
+
+JL_DLLEXPORT void jl_unlock_field(jl_mutex_t *v) JL_NOTSAFEPOINT
+{
+    JL_UNLOCK_NOGC(v);
+}
+
+static inline char *lock(char *p, jl_value_t *parent, int needlock, enum atomic_kind isatomic) JL_NOTSAFEPOINT
+{
+    if (needlock) {
+        if (isatomic == isatomic_object) {
+            jl_lock_value((jl_mutex_t*)parent);
+        }
+        else {
+            jl_lock_field((jl_mutex_t*)p);
+            return p + LLT_ALIGN(sizeof(jl_mutex_t), JL_SMALL_BYTE_ALIGNMENT);
+        }
+    }
+    return p;
 }
 
-JL_DLLEXPORT void jl_unlock_value(jl_value_t *v) JL_NOTSAFEPOINT
+static inline void unlock(char *p, jl_value_t *parent, int needlock, enum atomic_kind isatomic) JL_NOTSAFEPOINT
 {
-    JL_UNLOCK_NOGC((jl_mutex_t*)v);
+    if (needlock) {
+        if (isatomic == isatomic_object) {
+            jl_unlock_value((jl_mutex_t*)parent);
+        }
+        else {
+            jl_unlock_field((jl_mutex_t*)p);
+        }
+    }
 }
 
 JL_DLLEXPORT int jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err)
@@ -1672,11 +1761,12 @@ JL_DLLEXPORT jl_value_t *jl_get_nth_field(jl_value_t *v, size_t i)
     else if (needlock) {
         jl_task_t *ct = jl_current_task;
         r = jl_gc_alloc(ct->ptls, fsz, ty);
-        jl_lock_value(v);
+        jl_lock_value((jl_mutex_t*)v);
         memcpy((char*)r, (char*)v + offs, fsz);
-        jl_unlock_value(v);
+        jl_unlock_value((jl_mutex_t*)v);
     }
     else {
+        // TODO: a finalizer here could make the isunion case not quite right
         r = jl_new_bits(ty, (char*)v + offs);
     }
     return undefref_check((jl_datatype_t*)ty, r);
@@ -1699,30 +1789,7 @@ JL_DLLEXPORT jl_value_t *jl_get_nth_field_checked(jl_value_t *v, size_t i)
     return r;
 }
 
-static inline void memassign_safe(int hasptr, jl_value_t *parent, char *dst, const jl_value_t *src, size_t nb) JL_NOTSAFEPOINT
-{
-    if (hasptr) {
-        // assert that although dst might have some undefined bits, the src heap box should be okay with that
-        assert(LLT_ALIGN(nb, sizeof(void*)) == LLT_ALIGN(jl_datatype_size(jl_typeof(src)), sizeof(void*)));
-        size_t nptr = nb / sizeof(void*);
-        memmove_refs((_Atomic(void*)*)dst, (_Atomic(void*)*)src, nptr);
-        jl_gc_multi_wb(parent, src);
-        src = (jl_value_t*)((char*)src + nptr * sizeof(void*));
-        dst = dst + nptr * sizeof(void*);
-        nb -= nptr * sizeof(void*);
-    }
-    else {
-        // src must be a heap box.
-        assert(nb == jl_datatype_size(jl_typeof(src)));
-        if (nb >= 16) {
-            memcpy(dst, jl_assume_aligned(src, 16), nb);
-            return;
-        }
-    }
-    memcpy(dst, jl_assume_aligned(src, sizeof(void*)), nb);
-}
-
-void set_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs, int isatomic) JL_NOTSAFEPOINT
+inline void set_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs, int isatomic) JL_NOTSAFEPOINT
 {
     size_t offs = jl_field_offset(st, i);
     if (rhs == NULL) { // TODO: this should be invalid, but it happens frequently in ircode.c
@@ -1751,24 +1818,75 @@ void set_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs,
             hasptr = 0;
         }
         else {
-            hasptr = ((jl_datatype_t*)ty)->layout->npointers > 0;
+            hasptr = ((jl_datatype_t*)ty)->layout->first_ptr >= 0;
         }
         size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
+        assert(!isatomic || jl_typeis(rhs, ty));
         int needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
         if (isatomic && !needlock) {
             jl_atomic_store_bits((char*)v + offs, rhs, fsz);
-            if (hasptr)
-                jl_gc_multi_wb(v, rhs); // rhs is immutable
         }
         else if (needlock) {
-            jl_lock_value(v);
+            jl_lock_value((jl_mutex_t*)v);
             memcpy((char*)v + offs, (char*)rhs, fsz);
-            jl_unlock_value(v);
+            jl_unlock_value((jl_mutex_t*)v);
+        }
+        else {
+            memassign_safe(hasptr, (char*)v + offs, rhs, fsz);
+        }
+        if (hasptr)
+            jl_gc_multi_wb(v, rhs); // rhs is immutable
+    }
+}
+
+inline jl_value_t *swap_bits(jl_value_t *ty, char *v, uint8_t *psel, jl_value_t *parent, jl_value_t *rhs, enum atomic_kind isatomic)
+{
+    jl_value_t *rty = jl_typeof(rhs);
+    int hasptr;
+    int isunion = psel != NULL;
+    if (isunion) {
+        assert(!isatomic);
+        hasptr = 0;
+    }
+    else {
+        hasptr = ((jl_datatype_t*)ty)->layout->first_ptr >= 0;
+    }
+    size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
+    int needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
+    assert(!isatomic || jl_typeis(rhs, ty));
+    jl_value_t *r;
+    if (isatomic && !needlock) {
+        r = jl_atomic_swap_bits(rty, v, rhs, fsz);
+    }
+    else {
+        if (needlock) {
+            jl_task_t *ct = jl_current_task;
+            r = jl_gc_alloc(ct->ptls, fsz, ty);
+            char *px = lock(v, parent, needlock, isatomic);
+            memcpy((char*)r, px, fsz);
+            memcpy(px, (char*)rhs, fsz);
+            unlock(v, parent, needlock, isatomic);
         }
         else {
-            memassign_safe(hasptr, v, (char*)v + offs, rhs, fsz);
+            r = jl_new_bits(isunion ? jl_nth_union_component(ty, *psel) : ty, v);
+            if (isunion) {
+                unsigned nth = 0;
+                if (!jl_find_union_component(ty, rty, &nth))
+                    assert(0 && "invalid field assignment to isbits union");
+                *psel = nth;
+                if (jl_is_datatype_singleton((jl_datatype_t*)rty))
+                    return r;
+            }
+            memassign_safe(hasptr, v, rhs, fsz);
         }
     }
+    if (!isunion)
+        r = undefref_check((jl_datatype_t*)ty, r);
+    if (hasptr)
+        jl_gc_multi_wb(parent, rhs); // rhs is immutable
+    if (__unlikely(r == NULL))
+        jl_throw(jl_undefref_exception);
+    return r;
 }
 
 jl_value_t *swap_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs, int isatomic)
@@ -1778,139 +1896,139 @@ jl_value_t *swap_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_
        jl_type_error("swapfield!", ty, rhs);
     size_t offs = jl_field_offset(st, i);
     jl_value_t *r;
+    char *p = (char*)v + offs;
     if (jl_field_isptr(st, i)) {
         if (isatomic)
-            r = jl_atomic_exchange((_Atomic(jl_value_t*)*)((char*)v + offs), rhs);
+            r = jl_atomic_exchange((_Atomic(jl_value_t*)*)p, rhs);
         else
-            r = jl_atomic_exchange_relaxed((_Atomic(jl_value_t*)*)((char*)v + offs), rhs);
+            r = jl_atomic_exchange_release((_Atomic(jl_value_t*)*)p, rhs);
         jl_gc_wb(v, rhs);
+        if (__unlikely(r == NULL))
+            jl_throw(jl_undefref_exception);
+        return r;
     }
     else {
-        jl_value_t *rty = jl_typeof(rhs);
-        int hasptr;
-        int isunion = jl_is_uniontype(ty);
-        if (isunion) {
-            assert(!isatomic);
-            r = jl_get_nth_field(v, i);
-            size_t fsz = jl_field_size(st, i);
-            uint8_t *psel = &((uint8_t*)v)[offs + fsz - 1];
-            unsigned nth = 0;
-            if (!jl_find_union_component(ty, rty, &nth))
-                assert(0 && "invalid field assignment to isbits union");
-            *psel = nth;
-            if (jl_is_datatype_singleton((jl_datatype_t*)rty))
-                return r;
-            hasptr = 0;
-        }
-        else {
-            hasptr = ((jl_datatype_t*)ty)->layout->npointers > 0;
-            r = NULL;
-        }
-        size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
-        int needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
-        if (isatomic && !needlock) {
-            r = jl_atomic_swap_bits(rty, (char*)v + offs, rhs, fsz);
-            if (hasptr)
-                jl_gc_multi_wb(v, rhs); // rhs is immutable
+        uint8_t *psel = jl_is_uniontype(ty) ? (uint8_t*)&p[jl_field_size(st, i) - 1] : NULL;
+        return swap_bits(ty, p, psel, v, rhs, isatomic ? isatomic_object : isatomic_none);
+    }
+}
+
+inline jl_value_t *modify_value(jl_value_t *ty, _Atomic(jl_value_t*) *p, jl_value_t *parent, jl_value_t *op, jl_value_t *rhs, int isatomic, jl_module_t *mod, jl_sym_t *name)
+{
+    jl_value_t *r = isatomic ? jl_atomic_load(p) : jl_atomic_load_relaxed(p);
+    if (__unlikely(r == NULL)) {
+        if (mod && name)
+            jl_undefined_var_error(name, (jl_value_t*)mod);
+        jl_throw(jl_undefref_exception);
+    }
+    jl_value_t **args;
+    JL_GC_PUSHARGS(args, 2);
+    args[0] = r;
+    while (1) {
+        args[1] = rhs;
+        jl_value_t *y = jl_apply_generic(op, args, 2);
+        args[1] = y;
+        if (!jl_isa(y, ty)) {
+            if (mod && name)
+                jl_errorf("cannot assign an incompatible value to the global %s.%s.", jl_symbol_name(mod->name), jl_symbol_name(name));
+            jl_type_error(jl_is_genericmemory(parent) ? "memoryrefmodify!" : "modifyfield!", ty, y);
         }
-        else {
-            if (needlock) {
-                jl_task_t *ct = jl_current_task;
-                r = jl_gc_alloc(ct->ptls, fsz, ty);
-                jl_lock_value(v);
-                memcpy((char*)r, (char*)v + offs, fsz);
-                memcpy((char*)v + offs, (char*)rhs, fsz);
-                jl_unlock_value(v);
-            }
-            else {
-                if (!isunion)
-                    r = jl_new_bits(ty, (char*)v + offs);
-                memassign_safe(hasptr, v, (char*)v + offs, rhs, fsz);
-            }
-            if (needlock || !isunion)
-                r = undefref_check((jl_datatype_t*)ty, r);
+        if (isatomic ? jl_atomic_cmpswap(p, &r, y) : jl_atomic_cmpswap_release(p, &r, y)) {
+            jl_gc_wb(parent, y);
+            break;
         }
+        args[0] = r;
+        jl_gc_safepoint();
     }
-    if (__unlikely(r == NULL))
-        jl_throw(jl_undefref_exception);
-    return r;
+    // args[0] == r (old)
+    // args[1] == y (new)
+    jl_datatype_t *rettyp = jl_apply_modify_type(ty);
+    JL_GC_PROMISE_ROOTED(rettyp); // (JL_ALWAYS_LEAFTYPE)
+    args[0] = jl_new_struct(rettyp, args[0], args[1]);
+    JL_GC_POP();
+    return args[0];
 }
 
-jl_value_t *modify_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *op, jl_value_t *rhs, int isatomic)
+inline jl_value_t *modify_bits(jl_value_t *ty, char *p, uint8_t *psel, jl_value_t *parent, jl_value_t *op, jl_value_t *rhs, enum atomic_kind isatomic)
 {
-    size_t offs = jl_field_offset(st, i);
-    jl_value_t *ty = jl_field_type_concrete(st, i);
-    jl_value_t *r = jl_get_nth_field_checked(v, i);
-    if (isatomic && jl_field_isptr(st, i))
-        jl_fence(); // load was previously only relaxed
+    int hasptr;
+    int isunion = psel != NULL;
+    if (isunion) {
+        assert(!isatomic);
+        hasptr = 0;
+    }
+    else {
+        hasptr = ((jl_datatype_t*)ty)->layout->first_ptr >= 0;
+    }
     jl_value_t **args;
     JL_GC_PUSHARGS(args, 2);
-    args[0] = r;
     while (1) {
+        jl_value_t *r;
+        jl_value_t *rty = isunion ? jl_nth_union_component(ty, *psel) : ty;
+        size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the initial copy
+        int needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
+        if (isatomic && !needlock) {
+            r = jl_atomic_new_bits(rty, p);
+        }
+        else if (needlock) {
+            jl_task_t *ct = jl_current_task;
+            r = jl_gc_alloc(ct->ptls, fsz, rty);
+            char *px = lock(p, parent, needlock, isatomic);
+            memcpy((char*)r, px, fsz);
+            unlock(p, parent, needlock, isatomic);
+        }
+        else {
+            r = jl_new_bits(rty, p);
+        }
+        r = undefref_check((jl_datatype_t*)rty, r);
+        if (__unlikely(r == NULL))
+            jl_throw(jl_undefref_exception);
+        args[0] = r;
         args[1] = rhs;
         jl_value_t *y = jl_apply_generic(op, args, 2);
         args[1] = y;
-        if (!jl_isa(y, ty))
-            jl_type_error("modifyfield!", ty, y);
-        if (jl_field_isptr(st, i)) {
-            _Atomic(jl_value_t*) *p = (_Atomic(jl_value_t*)*)((char*)v + offs);
-            if (isatomic ? jl_atomic_cmpswap(p, &r, y) : jl_atomic_cmpswap_relaxed(p, &r, y))
+        if (!jl_isa(y, ty)) {
+            jl_type_error(jl_is_genericmemory(parent) ? "memoryrefmodify!" : "modifyfield!", ty, y);
+        }
+        jl_value_t *yty = jl_typeof(y);
+        if (isatomic && !needlock) {
+            assert(yty == rty);
+            if (jl_atomic_bool_cmpswap_bits(p, r, y, fsz)) {
+                if (hasptr)
+                    jl_gc_multi_wb(parent, y); // y is immutable
                 break;
+            }
         }
         else {
-            jl_value_t *yty = jl_typeof(y);
-            jl_value_t *rty = jl_typeof(r);
-            int hasptr;
-            int isunion = jl_is_uniontype(ty);
-            if (isunion) {
-                assert(!isatomic);
-                hasptr = 0;
-            }
-            else {
-                hasptr = ((jl_datatype_t*)ty)->layout->npointers > 0;
-            }
-            size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
-            int needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
-            if (isatomic && !needlock) {
-                if (jl_atomic_bool_cmpswap_bits((char*)v + offs, r, y, fsz)) {
-                    if (hasptr)
-                        jl_gc_multi_wb(v, y); // y is immutable
-                    break;
-                }
-                r = jl_atomic_new_bits(ty, (char*)v + offs);
-            }
-            else {
-                if (needlock)
-                    jl_lock_value(v);
-                int success = memcmp((char*)v + offs, r, fsz) == 0;
-                if (success) {
-                    if (isunion) {
-                        size_t fsz_i = jl_field_size(st, i);
-                        uint8_t *psel = &((uint8_t*)v)[offs + fsz_i - 1];
-                        success = (jl_typeof(r) == jl_nth_union_component(ty, *psel));
-                        if (success) {
-                            unsigned nth = 0;
-                            if (!jl_find_union_component(ty, yty, &nth))
-                                assert(0 && "invalid field assignment to isbits union");
-                            *psel = nth;
-                            if (jl_is_datatype_singleton((jl_datatype_t*)yty))
-                                break;
-                        }
-                        fsz = jl_datatype_size((jl_datatype_t*)yty); // need to shrink-wrap the final copy
-                    }
-                    else {
-                        assert(yty == ty && rty == ty);
+            char *px = lock(p, parent, needlock, isatomic);
+            int success = memcmp(px, (char*)r, fsz) == 0;
+            if (!success && ((jl_datatype_t*)rty)->layout->flags.haspadding)
+                success = jl_egal__bits((jl_value_t*)px, r, (jl_datatype_t*)rty);
+            if (success) {
+                if (isunion) {
+                    success = (rty == jl_nth_union_component(ty, *psel));
+                    if (success) {
+                        unsigned nth = 0;
+                        if (!jl_find_union_component(ty, yty, &nth))
+                            assert(0 && "invalid field assignment to isbits union");
+                        *psel = nth;
+                        if (jl_is_datatype_singleton((jl_datatype_t*)yty))
+                            break;
                     }
-                    memassign_safe(hasptr, v, (char*)v + offs, y, fsz);
+                    fsz = jl_datatype_size((jl_datatype_t*)yty); // need to shrink-wrap the final copy
                 }
-                if (needlock)
-                    jl_unlock_value(v);
-                if (success)
-                    break;
-                r = jl_get_nth_field(v, i);
+                else {
+                    assert(yty == ty && rty == ty);
+                }
+                memassign_safe(hasptr, px, y, fsz);
+            }
+            unlock(p, parent, needlock, isatomic);
+            if (success) {
+                if (hasptr)
+                    jl_gc_multi_wb(parent, y); // y is immutable
+                break;
             }
         }
-        args[0] = r;
         jl_gc_safepoint();
     }
     // args[0] == r (old)
@@ -1922,91 +2040,105 @@ jl_value_t *modify_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_valu
     return args[0];
 }
 
-jl_value_t *replace_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *expected, jl_value_t *rhs, int isatomic)
+jl_value_t *modify_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *op, jl_value_t *rhs, int isatomic)
 {
-    jl_value_t *ty = jl_field_type_concrete(st, i);
-    if (!jl_isa(rhs, ty))
-        jl_type_error("replacefield!", ty, rhs);
     size_t offs = jl_field_offset(st, i);
-    jl_value_t *r = expected;
+    jl_value_t *ty = jl_field_type_concrete(st, i);
+    char *p = (char*)v + offs;
+    if (jl_field_isptr(st, i)) {
+        return modify_value(ty, (_Atomic(jl_value_t*)*)p, v, op, rhs, isatomic, NULL, NULL);
+    }
+    else {
+        uint8_t *psel = jl_is_uniontype(ty) ? (uint8_t*)&p[jl_field_size(st, i) - 1] : NULL;
+        return modify_bits(ty, p, psel, v, op, rhs, isatomic ? isatomic_object : isatomic_none);
+    }
+}
+
+inline jl_value_t *replace_value(jl_value_t *ty, _Atomic(jl_value_t*) *p, jl_value_t *parent, jl_value_t *expected, jl_value_t *rhs, int isatomic, jl_module_t *mod, jl_sym_t *name)
+{
     jl_datatype_t *rettyp = jl_apply_cmpswap_type(ty);
     JL_GC_PROMISE_ROOTED(rettyp); // (JL_ALWAYS_LEAFTYPE)
-    if (jl_field_isptr(st, i)) {
-        _Atomic(jl_value_t*) *p = (_Atomic(jl_value_t*)*)((char*)v + offs);
-        int success;
-        while (1) {
-            success = isatomic ? jl_atomic_cmpswap(p, &r, rhs) : jl_atomic_cmpswap_relaxed(p, &r, rhs);
-            if (success)
-                jl_gc_wb(v, rhs);
-            if (__unlikely(r == NULL))
-                jl_throw(jl_undefref_exception);
-            if (success || !jl_egal(r, expected))
-                break;
+    jl_value_t *r = expected;
+    int success;
+    while (1) {
+        success = isatomic ? jl_atomic_cmpswap(p, &r, rhs) : jl_atomic_cmpswap_release(p, &r, rhs);
+        if (success)
+            jl_gc_wb(parent, rhs);
+        if (__unlikely(r == NULL)) {
+            if (mod && name)
+                jl_undefined_var_error(name, (jl_value_t*)mod);
+            jl_throw(jl_undefref_exception);
         }
-        JL_GC_PUSH1(&r);
-        r = jl_new_struct(rettyp, r, success ? jl_true : jl_false);
-        JL_GC_POP();
+        if (success || !jl_egal(r, expected))
+            break;
+    }
+    JL_GC_PUSH1(&r);
+    r = jl_new_struct(rettyp, r, success ? jl_true : jl_false);
+    JL_GC_POP();
+    return r;
+}
+
+inline jl_value_t *replace_bits(jl_value_t *ty, char *p, uint8_t *psel, jl_value_t *parent, jl_value_t *expected, jl_value_t *rhs, enum atomic_kind isatomic)
+{
+    jl_datatype_t *rettyp = jl_apply_cmpswap_type(ty);
+    JL_GC_PROMISE_ROOTED(rettyp); // (JL_ALWAYS_LEAFTYPE)
+    int hasptr;
+    int isunion = psel != NULL;
+    size_t fsz = jl_field_size(rettyp, 0);
+    int needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
+    assert(jl_field_offset(rettyp, 1) == fsz);
+    jl_value_t *rty = ty;
+    if (isunion) {
+        assert(!isatomic);
+        hasptr = 0;
+        isatomic = isatomic_none; // this makes GCC happy
     }
     else {
-        int hasptr;
-        int isunion = jl_is_uniontype(ty);
-        int needlock;
-        jl_value_t *rty = ty;
-        size_t fsz = jl_field_size(st, i);
-        if (isunion) {
-            assert(!isatomic);
-            hasptr = 0;
-            needlock = 0;
-            isatomic = 0; // this makes GCC happy
-        }
-        else {
-            hasptr = ((jl_datatype_t*)ty)->layout->npointers > 0;
-            fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
-            needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
-        }
-        if (isatomic && !needlock) {
-            r = jl_atomic_cmpswap_bits((jl_datatype_t*)ty, rettyp, (char*)v + offs, r, rhs, fsz);
-            int success = *((uint8_t*)r + fsz);
-            if (success && hasptr)
-                jl_gc_multi_wb(v, rhs); // rhs is immutable
+        hasptr = ((jl_datatype_t*)ty)->layout->first_ptr >= 0;
+        assert(jl_typeis(rhs, ty));
+    }
+    int success;
+    jl_task_t *ct = jl_current_task;
+    assert(!jl_field_isptr(rettyp, 0));
+    jl_value_t *r = jl_gc_alloc(ct->ptls, jl_datatype_size(rettyp), rettyp);
+    if (isatomic && !needlock) {
+        size_t rsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the compare
+        success = jl_atomic_cmpswap_bits((jl_datatype_t*)rty, r, p, expected, rhs, rsz);
+        *((uint8_t*)r + fsz) = success ? 1 : 0;
+    }
+    else {
+        char *px = lock(p, parent, needlock, isatomic);
+        if (isunion)
+            rty = jl_nth_union_component(rty, *psel);
+        size_t rsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the compare
+        memcpy((char*)r, px, rsz); // copy field // TODO: make this a memmove_refs if relevant
+        if (isunion)
+            *((uint8_t*)r + fsz - 1) = *psel; // copy union bits
+        success = (rty == jl_typeof(expected));
+        if (success) {
+            success = memcmp((char*)r, (char*)expected, rsz) == 0;
+            if (!success && ((jl_datatype_t*)rty)->layout->flags.haspadding)
+                success = jl_egal__bits(r, expected, (jl_datatype_t*)rty);
         }
-        else {
-            jl_task_t *ct = jl_current_task;
-            uint8_t *psel = NULL;
+        *((uint8_t*)r + fsz) = success ? 1 : 0;
+        if (success) {
+            jl_value_t *rty = jl_typeof(rhs);
             if (isunion) {
-                psel = &((uint8_t*)v)[offs + fsz - 1];
-                rty = jl_nth_union_component(rty, *psel);
-            }
-            assert(!jl_field_isptr(rettyp, 0));
-            r = jl_gc_alloc(ct->ptls, jl_datatype_size(rettyp), (jl_value_t*)rettyp);
-            int success = (rty == jl_typeof(expected));
-            if (needlock)
-                jl_lock_value(v);
-            memcpy((char*)r, (char*)v + offs, fsz); // copy field, including union bits
-            if (success) {
-                size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
-                if (((jl_datatype_t*)rty)->layout->flags.haspadding)
-                    success = jl_egal__bits(r, expected, (jl_datatype_t*)rty);
-                else
-                    success = memcmp((char*)r, (char*)expected, fsz) == 0;
+                rsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
+                unsigned nth = 0;
+                if (!jl_find_union_component(ty, rty, &nth))
+                    assert(0 && "invalid field assignment to isbits union");
+                *psel = nth;
+                if (jl_is_datatype_singleton((jl_datatype_t*)rty))
+                    return r;
             }
-            *((uint8_t*)r + fsz) = success ? 1 : 0;
-            if (success) {
-                jl_value_t *rty = jl_typeof(rhs);
-                size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
-                if (isunion) {
-                    unsigned nth = 0;
-                    if (!jl_find_union_component(ty, rty, &nth))
-                        assert(0 && "invalid field assignment to isbits union");
-                    *psel = nth;
-                    if (jl_is_datatype_singleton((jl_datatype_t*)rty))
-                        return r;
-                }
-                memassign_safe(hasptr, v, (char*)v + offs, rhs, fsz);
-            }
-            if (needlock)
-                jl_unlock_value(v);
+            memassign_safe(hasptr, px, rhs, rsz);
         }
+        unlock(p, parent, needlock, isatomic);
+    }
+    if (success && hasptr)
+        jl_gc_multi_wb(parent, rhs); // rhs is immutable
+    if (!isunion) {
         r = undefref_check((jl_datatype_t*)rty, r);
         if (__unlikely(r == NULL))
             jl_throw(jl_undefref_exception);
@@ -2014,6 +2146,74 @@ jl_value_t *replace_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_val
     return r;
 }
 
+jl_value_t *replace_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *expected, jl_value_t *rhs, int isatomic)
+{
+    jl_value_t *ty = jl_field_type_concrete(st, i);
+    if (!jl_isa(rhs, ty))
+        jl_type_error("replacefield!", ty, rhs);
+    size_t offs = jl_field_offset(st, i);
+    char *p = (char*)v + offs;
+    if (jl_field_isptr(st, i)) {
+        return replace_value(ty, (_Atomic(jl_value_t*)*)p, v, expected, rhs, isatomic, NULL, NULL);
+    }
+    else {
+        size_t fsz = jl_field_size(st, i);
+        int isunion = jl_is_uniontype(ty);
+        uint8_t *psel = isunion ? (uint8_t*)&p[fsz - 1] : NULL;
+        return replace_bits(ty, p, psel, v, expected, rhs, isatomic ? isatomic_object : isatomic_none);
+    }
+}
+
+inline int setonce_bits(jl_datatype_t *rty, char *p, jl_value_t *parent, jl_value_t *rhs, enum atomic_kind isatomic)
+{
+    size_t fsz = jl_datatype_size((jl_datatype_t*)rty); // need to shrink-wrap the final copy
+    assert(rty->layout->first_ptr >= 0);
+    int hasptr = 1;
+    int needlock = (isatomic && fsz > MAX_ATOMIC_SIZE);
+    int success;
+    if (isatomic && !needlock) {
+        success = jl_atomic_storeonce_bits(rty, p, rhs, fsz);
+    }
+    else {
+        char *px = lock(p, parent, needlock, isatomic);
+        success = undefref_check(rty, (jl_value_t*)px) != NULL;
+        if (success)
+            memassign_safe(hasptr, px, rhs, fsz);
+        unlock(p, parent, needlock, isatomic);
+    }
+    if (success)
+        jl_gc_multi_wb(parent, rhs); // rhs is immutable
+    return success;
+}
+
+int set_nth_fieldonce(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs, int isatomic)
+{
+    jl_value_t *ty = jl_field_type_concrete(st, i);
+    if (!jl_isa(rhs, ty))
+        jl_type_error("setfieldonce!", ty, rhs);
+    size_t offs = jl_field_offset(st, i);
+    int success;
+    char *p = (char*)v + offs;
+    if (jl_field_isptr(st, i)) {
+        _Atomic(jl_value_t*) *px = (_Atomic(jl_value_t*)*)p;
+        jl_value_t *r = NULL;
+        success = isatomic ? jl_atomic_cmpswap(px, &r, rhs) : jl_atomic_cmpswap_release(px, &r, rhs);
+        if (success)
+            jl_gc_wb(v, rhs);
+    }
+    else {
+        int isunion = jl_is_uniontype(ty);
+        if (isunion)
+            return 0;
+        int hasptr = ((jl_datatype_t*)ty)->layout->first_ptr >= 0;
+        if (!hasptr)
+            return 0;
+        assert(ty == jl_typeof(rhs));
+        success = setonce_bits((jl_datatype_t*)ty, p, v, rhs, isatomic ? isatomic_object : isatomic_none);
+    }
+    return success;
+}
+
 JL_DLLEXPORT int jl_field_isdefined(jl_value_t *v, size_t i) JL_NOTSAFEPOINT
 {
     jl_datatype_t *st = (jl_datatype_t*)jl_typeof(v);
diff --git a/src/genericmemory.c b/src/genericmemory.c
index 4543c869e6c74..0bd4db30fd690 100644
--- a/src/genericmemory.c
+++ b/src/genericmemory.c
@@ -16,30 +16,6 @@
 extern "C" {
 #endif
 
-static inline void genericmemoryassign_safe(int hasptr, jl_value_t *parent, char *dst, const jl_value_t *src) JL_NOTSAFEPOINT
-{
-    size_t nb = jl_datatype_size(jl_typeof(src)); // make sure to shrink-wrap this copy
-    if (hasptr) {
-        size_t nptr = nb / sizeof(void*);
-        memmove_refs((_Atomic(void*)*)dst, (_Atomic(void*)*)src, nptr);
-        jl_gc_multi_wb(parent, src);
-    }
-    else {
-        // genericmemory can assume more alignment than a field would normally have
-        switch (nb) {
-        case  0: break;
-        case  1: *(uint8_t*)dst  = *(uint8_t*)src;  break;
-        case  2: *(uint16_t*)dst = *(uint16_t*)src; break;
-        case  4: *(uint32_t*)dst = *(uint32_t*)src; break;
-        case  8: *(uint64_t*)dst = *(uint64_t*)src; break;
-        case 16:
-            memcpy(jl_assume_aligned(dst, 16), jl_assume_aligned(src, 16), 16);
-            break;
-        default: memcpy(dst, src, nb);
-        }
-    }
-}
-
 // genericmemory constructors ---------------------------------------------------------
 JL_DLLEXPORT char *jl_genericmemory_typetagdata(jl_genericmemory_t *m) JL_NOTSAFEPOINT
 {
@@ -100,8 +76,9 @@ JL_DLLEXPORT jl_genericmemory_t *jl_alloc_genericmemory(jl_value_t *mtype, size_
     jl_genericmemory_t *m = (jl_genericmemory_t*)((jl_datatype_t*)mtype)->instance;
     const jl_datatype_layout_t *layout = ((jl_datatype_t*)mtype)->layout;
     if (m == NULL) {
-        if (jl_tparam0((jl_datatype_t*)mtype) != (jl_value_t*)jl_not_atomic_sym)
-            jl_error("GenericMemory kind must be :not_atomic");
+        jl_value_t *kind = jl_tparam0((jl_datatype_t*)mtype);
+        if (kind != (jl_value_t*)jl_not_atomic_sym && kind != (jl_value_t*)jl_atomic_sym)
+            jl_error("GenericMemory kind must be :not_atomic or :atomic");
         jl_value_t *addrspace = jl_tparam2((jl_datatype_t*)mtype);
         if (!jl_is_addrspacecore(addrspace) || jl_unbox_uint8(addrspace) != 0)
             jl_error("GenericMemory addrspace must be Core.CPU");
@@ -109,7 +86,6 @@ JL_DLLEXPORT jl_genericmemory_t *jl_alloc_genericmemory(jl_value_t *mtype, size_
             jl_type_error_rt("GenericMemory", "element type", (jl_value_t*)jl_type_type, jl_tparam1(mtype));
         abort(); // this is checked already by jl_get_genericmemory_layout
     }
-    assert(jl_tparam0((jl_datatype_t*)mtype) == (jl_value_t*)jl_not_atomic_sym);
     assert(((jl_datatype_t*)mtype)->has_concrete_subtype && layout != NULL);
     if (nel == 0) // zero-sized allocation optimization fast path
         return m;
@@ -143,8 +119,9 @@ JL_DLLEXPORT jl_genericmemory_t *jl_ptr_to_genericmemory(jl_value_t *mtype, void
     jl_genericmemory_t *m = (jl_genericmemory_t*)((jl_datatype_t*)mtype)->instance;
     const jl_datatype_layout_t *layout = ((jl_datatype_t*)mtype)->layout;
     if (m == NULL) {
-        if (jl_tparam0((jl_datatype_t*)mtype) != (jl_value_t*)jl_not_atomic_sym)
-            jl_error("GenericMemory kind must be :not_atomic");
+        jl_value_t *kind = jl_tparam0((jl_datatype_t*)mtype);
+        if (kind != (jl_value_t*)jl_not_atomic_sym && kind != (jl_value_t*)jl_atomic_sym)
+            jl_error("GenericMemory kind must be :not_atomic or :atomic");
         jl_value_t *addrspace = jl_tparam2((jl_datatype_t*)mtype);
         if (!jl_is_addrspacecore(addrspace) || jl_unbox_uint8(addrspace) != 0)
             jl_error("GenericMemory addrspace must be Core.CPU");
@@ -152,7 +129,6 @@ JL_DLLEXPORT jl_genericmemory_t *jl_ptr_to_genericmemory(jl_value_t *mtype, void
             jl_type_error_rt("GenericMemory", "element type", (jl_value_t*)jl_type_type, jl_tparam1(mtype));
         abort();
     }
-    assert(jl_tparam0((jl_datatype_t*)mtype) == (jl_value_t*)jl_not_atomic_sym);
     assert(((jl_datatype_t*)mtype)->has_concrete_subtype && layout != NULL);
     //if (nel == 0) {// zero-sized allocation optimization fast path
     //    if (own_buffer)
@@ -350,97 +326,14 @@ JL_DLLEXPORT void jl_genericmemory_copyto(jl_genericmemory_t *dest, char* destda
 
 // genericmemory primitives -----------------------------------------------------------
 
-JL_DLLEXPORT jl_value_t *jl_ptrmemref(jl_genericmemory_t *m JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT
-{
-    assert(i < m->length);
-    assert(((jl_datatype_t*)jl_typetagof(m))->layout->flags.arrayelem_isboxed);
-    jl_value_t *elt = jl_atomic_load_relaxed(((_Atomic(jl_value_t*)*)m->ptr) + i);
-    if (elt == NULL)
-        jl_throw(jl_undefref_exception);
-    return elt;
-}
-
-JL_DLLEXPORT jl_value_t *jl_genericmemoryref(jl_genericmemory_t *m, size_t i)
-{
-    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
-    if (layout->flags.arrayelem_isboxed)
-        return jl_ptrmemref(m, i);
-    assert(i < m->length);
-    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m)); (void)isatomic; // TODO
-    jl_value_t *eltype = jl_tparam1(jl_typetagof(m));
-    if (layout->flags.arrayelem_isunion) {
-        // isbits union selector bytes are always stored directly after the last memory element
-        uint8_t sel = jl_genericmemory_typetagdata(m)[i];
-        eltype = jl_nth_union_component(eltype, sel);
-        if (jl_is_datatype_singleton((jl_datatype_t*)eltype))
-            return ((jl_datatype_t*)eltype)->instance;
-    }
-    jl_value_t *r = undefref_check((jl_datatype_t*)eltype, jl_new_bits(eltype, &((char*)m->ptr)[i * layout->size]));
-    if (__unlikely(r == NULL))
-        jl_throw(jl_undefref_exception);
-    return r;
-}
-
-JL_DLLEXPORT int jl_genericmemory_isassigned(jl_genericmemory_t *m, size_t i)
-{
-    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
-    if (layout->flags.arrayelem_isboxed) {
-        return jl_atomic_load_relaxed(((_Atomic(jl_value_t*)*)m->ptr) + i) != NULL;
-    }
-    else if (layout->first_ptr >= 0) {
-         jl_value_t **elem = (jl_value_t**)((char*)m->ptr + i * layout->size);
-         return elem[layout->first_ptr] != NULL;
-    }
-    return 1;
-}
-
-JL_DLLEXPORT void jl_genericmemoryset(jl_genericmemory_t *m JL_ROOTING_ARGUMENT, jl_value_t *rhs JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, size_t i)
+JL_DLLEXPORT jl_value_t *jl_genericmemoryref(jl_genericmemory_t *mem, size_t i)
 {
-    assert(i < m->length);
-    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m)); (void)isatomic; // TODO
-    jl_value_t *eltype = jl_tparam1(jl_typetagof(m));
-    if (eltype != (jl_value_t*)jl_any_type && !jl_typeis(rhs, eltype)) {
-        JL_GC_PUSH1(&rhs);
-        if (!jl_isa(rhs, eltype))
-            jl_type_error("genericmemoryset", eltype, rhs);
-        JL_GC_POP();
-    }
-    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
-    if (layout->flags.arrayelem_isboxed) {
-        jl_atomic_store_release(((_Atomic(jl_value_t*)*)m->ptr) + i, rhs);
-        jl_gc_wb(jl_genericmemory_owner(m), rhs);
-    }
-    else {
-        int hasptr;
-        if (jl_is_uniontype(eltype)) {
-            uint8_t *psel = &((uint8_t*)jl_genericmemory_typetagdata(m))[i];
-            unsigned nth = 0;
-            if (!jl_find_union_component(eltype, jl_typeof(rhs), &nth))
-                assert(0 && "invalid genericmemoryset to isbits union");
-            *psel = nth;
-            if (jl_is_datatype_singleton((jl_datatype_t*)jl_typeof(rhs)))
-                return;
-            hasptr = 0;
-        }
-        else {
-            hasptr = layout->first_ptr >= 0;
-        }
-        genericmemoryassign_safe(hasptr, jl_genericmemory_owner(m), &((char*)m->ptr)[i * layout->size], rhs);
-    }
-}
-
-JL_DLLEXPORT void jl_genericmemoryunset(jl_genericmemory_t *m, size_t i)
-{
-    if (i >= m->length)
-        jl_bounds_error_int((jl_value_t*)m, i + 1);
-    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m))->layout;
-    if (layout->flags.arrayelem_isboxed)
-        jl_atomic_store_relaxed(((_Atomic(jl_value_t*)*)m->ptr) + i, NULL);
-    else if (layout->first_ptr >= 0) {
-        size_t elsize = layout->size;
-        jl_assume(elsize >= sizeof(void*) && elsize % sizeof(void*) == 0);
-        memset((char*)m->ptr + elsize * i, 0, elsize);
-    }
+    int isatomic = (jl_tparam0(jl_typetagof(mem)) == (jl_value_t*)jl_atomic_sym);
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(mem))->layout;
+    jl_genericmemoryref_t m;
+    m.mem = mem;
+    m.ptr_or_offset = (layout->flags.arrayelem_isunion || layout->size == 0) ? (void*)i : (void*)((char*)mem->ptr + layout->size * i);
+    return jl_memoryrefget(m, isatomic);
 }
 
 JL_DLLEXPORT jl_genericmemory_t *jl_genericmemory_copy_slice(jl_genericmemory_t *mem, void *data, size_t len)
@@ -499,25 +392,27 @@ JL_DLLEXPORT jl_genericmemoryref_t jl_memoryrefindex(jl_genericmemoryref_t m JL_
     return m;
 }
 
-JL_DLLEXPORT jl_value_t *jl_ptrmemrefget(jl_genericmemoryref_t m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
+static jl_value_t *jl_ptrmemrefget(jl_genericmemoryref_t m JL_PROPAGATES_ROOT, int isatomic) JL_NOTSAFEPOINT
 {
     assert((char*)m.ptr_or_offset - (char*)m.mem->ptr < sizeof(jl_value_t*) * m.mem->length);
     assert(((jl_datatype_t*)jl_typetagof(m.mem))->layout->flags.arrayelem_isboxed);
-    jl_value_t *elt = jl_atomic_load_relaxed((_Atomic(jl_value_t*)*)m.ptr_or_offset);
+    _Atomic(jl_value_t*) *ptr = (_Atomic(jl_value_t*)*)m.ptr_or_offset;
+    jl_value_t *elt = isatomic ? jl_atomic_load(ptr) : jl_atomic_load_relaxed(ptr);
     if (elt == NULL)
         jl_throw(jl_undefref_exception);
     return elt;
 }
 
-JL_DLLEXPORT jl_value_t *jl_memoryrefget(jl_genericmemoryref_t m)
+JL_DLLEXPORT jl_value_t *jl_memoryrefget(jl_genericmemoryref_t m, int isatomic)
 {
+    assert(isatomic == (jl_tparam0(jl_typetagof(m.mem)) == (jl_value_t*)jl_atomic_sym));
     const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
     if (layout->flags.arrayelem_isboxed)
-        return jl_ptrmemrefget(m);
-    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem)); (void)isatomic; // TODO
+        return jl_ptrmemrefget(m, isatomic);
     jl_value_t *eltype = jl_tparam1(jl_typetagof(m.mem));
     char *data = (char*)m.ptr_or_offset;
     if (layout->flags.arrayelem_isunion) {
+        assert(!isatomic);
         assert(jl_is_uniontype(eltype));
         size_t i = (size_t)data;
         assert(i < m.mem->length);
@@ -531,33 +426,55 @@ JL_DLLEXPORT jl_value_t *jl_memoryrefget(jl_genericmemoryref_t m)
         return ((jl_datatype_t*)eltype)->instance;
     }
     assert(data - (char*)m.mem->ptr < layout->size * m.mem->length);
-    jl_value_t *r = undefref_check((jl_datatype_t*)eltype, jl_new_bits(eltype, data));
+    jl_value_t *r;
+    size_t fsz = jl_datatype_size(eltype);
+    int needlock = isatomic && fsz > MAX_ATOMIC_SIZE;
+    if (isatomic && !needlock) {
+        r = jl_atomic_new_bits(eltype, data);
+    }
+    else if (needlock) {
+        jl_task_t *ct = jl_current_task;
+        r = jl_gc_alloc(ct->ptls, fsz, eltype);
+        jl_lock_field((jl_mutex_t*)data);
+        memcpy((char*)r, data + LLT_ALIGN(sizeof(jl_mutex_t), JL_SMALL_BYTE_ALIGNMENT), fsz);
+        jl_unlock_field((jl_mutex_t*)data);
+    }
+    else {
+        // TODO: a finalizer here could make the isunion case not quite right
+        r = jl_new_bits(eltype, data);
+    }
+    r = undefref_check((jl_datatype_t*)eltype, r);
     if (__unlikely(r == NULL))
         jl_throw(jl_undefref_exception);
     return r;
 }
 
-static int _jl_memoryref_isassigned(jl_genericmemoryref_t m)
+static int _jl_memoryref_isassigned(jl_genericmemoryref_t m, int isatomic)
 {
     const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    _Atomic(jl_value_t*) *elem = (_Atomic(jl_value_t*)*)m.ptr_or_offset;
     if (layout->flags.arrayelem_isboxed) {
-        return jl_atomic_load_relaxed((_Atomic(jl_value_t*)*)m.ptr_or_offset) != NULL;
     }
     else if (layout->first_ptr >= 0) {
-         jl_value_t **elem = (jl_value_t**)m.ptr_or_offset;
-         return elem[layout->first_ptr] != NULL;
+        int needlock = isatomic && layout->size > MAX_ATOMIC_SIZE;
+        if (needlock)
+            elem = elem + LLT_ALIGN(sizeof(jl_mutex_t), JL_SMALL_BYTE_ALIGNMENT) / sizeof(jl_value_t*);
+        elem = &elem[layout->first_ptr];
+    }
+    else {
+        return 1;
     }
-    return 1;
+    return (isatomic ? jl_atomic_load(elem) : jl_atomic_load_relaxed(elem)) != NULL;
 }
 
-JL_DLLEXPORT jl_value_t *jl_memoryref_isassigned(jl_genericmemoryref_t m)
+JL_DLLEXPORT jl_value_t *jl_memoryref_isassigned(jl_genericmemoryref_t m, int isatomic)
 {
-    return _jl_memoryref_isassigned(m) ? jl_true : jl_false;
+    return _jl_memoryref_isassigned(m, isatomic) ? jl_true : jl_false;
 }
 
-JL_DLLEXPORT void jl_memoryrefset(jl_genericmemoryref_t m JL_ROOTING_ARGUMENT, jl_value_t *rhs JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED)
+JL_DLLEXPORT void jl_memoryrefset(jl_genericmemoryref_t m JL_ROOTING_ARGUMENT, jl_value_t *rhs JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, int isatomic)
 {
-    jl_value_t *isatomic = jl_tparam0(jl_typetagof(m.mem)); (void)isatomic; // TODO
+    assert(isatomic == (jl_tparam0(jl_typetagof(m.mem)) == (jl_value_t*)jl_atomic_sym));
     jl_value_t *eltype = jl_tparam1(jl_typetagof(m.mem));
     if (eltype != (jl_value_t*)jl_any_type && !jl_typeis(rhs, eltype)) {
         JL_GC_PUSH1(&rhs);
@@ -568,47 +485,170 @@ JL_DLLEXPORT void jl_memoryrefset(jl_genericmemoryref_t m JL_ROOTING_ARGUMENT, j
     const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
     if (layout->flags.arrayelem_isboxed) {
         assert((char*)m.ptr_or_offset - (char*)m.mem->ptr < sizeof(jl_value_t*) * m.mem->length);
-        jl_atomic_store_release((_Atomic(jl_value_t*)*)m.ptr_or_offset, rhs);
+        if (isatomic)
+            jl_atomic_store((_Atomic(jl_value_t*)*)m.ptr_or_offset, rhs);
+        else
+            jl_atomic_store_release((_Atomic(jl_value_t*)*)m.ptr_or_offset, rhs);
         jl_gc_wb(jl_genericmemory_owner(m.mem), rhs);
+        return;
+    }
+    int hasptr;
+    char *data = (char*)m.ptr_or_offset;
+    if (layout->flags.arrayelem_isunion) {
+        assert(!isatomic);
+        assert(jl_is_uniontype(eltype));
+        size_t i = (size_t)data;
+        assert(i < m.mem->length);
+        uint8_t *psel = (uint8_t*)jl_genericmemory_typetagdata(m.mem) + i;
+        unsigned nth = 0;
+        if (!jl_find_union_component(eltype, jl_typeof(rhs), &nth))
+            assert(0 && "invalid genericmemoryset to isbits union");
+        *psel = nth;
+        hasptr = 0;
+        data = (char*)m.mem->ptr + i * layout->size;
     }
     else {
-        int hasptr;
-        char *data = (char*)m.ptr_or_offset;
-        if (layout->flags.arrayelem_isunion) {
-            assert(jl_is_uniontype(eltype));
-            size_t i = (size_t)data;
-            assert(i < m.mem->length);
-            uint8_t *psel = (uint8_t*)jl_genericmemory_typetagdata(m.mem) + i;
-            unsigned nth = 0;
-            if (!jl_find_union_component(eltype, jl_typeof(rhs), &nth))
-                assert(0 && "invalid genericmemoryset to isbits union");
-            *psel = nth;
-            hasptr = 0;
-            data = (char*)m.mem->ptr + i * layout->size;
+        hasptr = layout->first_ptr >= 0;
+    }
+    if (layout->size != 0) {
+        assert(data - (char*)m.mem->ptr < layout->size * m.mem->length);
+        int needlock = isatomic && layout->size > MAX_ATOMIC_SIZE;
+        size_t fsz = jl_datatype_size((jl_datatype_t*)jl_typeof(rhs)); // need to shrink-wrap the final copy
+        if (isatomic && !needlock) {
+            jl_atomic_store_bits(data, rhs, fsz);
         }
-        else {
-            hasptr = layout->first_ptr >= 0;
+        else if (needlock) {
+            jl_lock_field((jl_mutex_t*)data);
+            memassign_safe(hasptr, data + LLT_ALIGN(sizeof(jl_mutex_t), JL_SMALL_BYTE_ALIGNMENT), rhs, fsz);
+            jl_unlock_field((jl_mutex_t*)data);
         }
-        if (layout->size != 0) {
-            assert(data - (char*)m.mem->ptr < layout->size * m.mem->length);
-            genericmemoryassign_safe(hasptr, jl_genericmemory_owner(m.mem), data, rhs);
+        else {
+            memassign_safe(hasptr, data, rhs, fsz);
         }
+        if (hasptr)
+            jl_gc_multi_wb(jl_genericmemory_owner(m.mem), rhs); // rhs is immutable
     }
 }
 
-JL_DLLEXPORT void jl_memoryrefunset(jl_genericmemoryref_t m)
+JL_DLLEXPORT jl_value_t *jl_memoryrefswap(jl_genericmemoryref_t m, jl_value_t *rhs, int isatomic)
 {
-    if (m.mem->length == 0)
-        jl_bounds_error_int((jl_value_t*)m.mem, 1);
+    jl_value_t *eltype = jl_tparam1(jl_typetagof(m.mem));
+    if (eltype != (jl_value_t*)jl_any_type && !jl_typeis(rhs, eltype)) {
+        if (!jl_isa(rhs, eltype))
+            jl_type_error("memoryrefswap!", eltype, rhs);
+    }
     const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    jl_value_t *owner = jl_genericmemory_owner(m.mem);
+    char *data = (char*)m.ptr_or_offset;
     if (layout->flags.arrayelem_isboxed) {
-        jl_atomic_store_relaxed((_Atomic(jl_value_t*)*)m.ptr_or_offset, NULL);
+        assert(data - (char*)m.mem->ptr < sizeof(jl_value_t*) * m.mem->length);
+        jl_value_t *r;
+        if (isatomic)
+            r = jl_atomic_exchange((_Atomic(jl_value_t*)*)data, rhs);
+        else
+            r = jl_atomic_exchange_release((_Atomic(jl_value_t*)*)data, rhs);
+        jl_gc_wb(owner, rhs);
+        if (__unlikely(r == NULL))
+            jl_throw(jl_undefref_exception);
+        return r;
+    }
+    uint8_t *psel = NULL;
+    if (layout->flags.arrayelem_isunion) {
+        assert(!isatomic);
+        assert(jl_is_uniontype(eltype));
+        size_t i = (size_t)data;
+        assert(i < m.mem->length);
+        psel = (uint8_t*)jl_genericmemory_typetagdata(m.mem) + i;
+        data = (char*)m.mem->ptr + i * layout->size;
     }
-    else if (layout->first_ptr >= 0) {
-        size_t elsize = layout->size;
-        jl_assume(elsize >= sizeof(void*) && elsize % sizeof(void*) == 0);
-        memset(m.ptr_or_offset, 0, elsize);
+    return swap_bits(eltype, data, psel, owner, rhs, isatomic ? isatomic_field : isatomic_none);
+}
+
+JL_DLLEXPORT jl_value_t *jl_memoryrefmodify(jl_genericmemoryref_t m, jl_value_t *op, jl_value_t *rhs, int isatomic)
+{
+    jl_value_t *eltype = jl_tparam1(jl_typetagof(m.mem));
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    jl_value_t *owner = jl_genericmemory_owner(m.mem);
+    char *data = (char*)m.ptr_or_offset;
+    if (layout->flags.arrayelem_isboxed) {
+        assert(data - (char*)m.mem->ptr < sizeof(jl_value_t*) * m.mem->length);
+        return modify_value(eltype, (_Atomic(jl_value_t*)*)data, owner, op, rhs, isatomic, NULL, NULL);
+    }
+    size_t fsz = layout->size;
+    uint8_t *psel = NULL;
+    if (layout->flags.arrayelem_isunion) {
+        assert(!isatomic);
+        assert(jl_is_uniontype(eltype));
+        size_t i = (size_t)data;
+        assert(i < m.mem->length);
+        psel = (uint8_t*)jl_genericmemory_typetagdata(m.mem) + i;
+        data = (char*)m.mem->ptr + i * fsz;
+    }
+    return modify_bits(eltype, data, psel, owner, op, rhs, isatomic ? isatomic_field : isatomic_none);
+}
+
+JL_DLLEXPORT jl_value_t *jl_memoryrefreplace(jl_genericmemoryref_t m, jl_value_t *expected, jl_value_t *rhs, int isatomic)
+{
+    jl_value_t *eltype = jl_tparam1(jl_typetagof(m.mem));
+    if (eltype != (jl_value_t*)jl_any_type && !jl_typeis(rhs, eltype)) {
+        if (!jl_isa(rhs, eltype))
+            jl_type_error("memoryrefreplace!", eltype, rhs);
+    }
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    jl_value_t *owner = jl_genericmemory_owner(m.mem);
+    char *data = (char*)m.ptr_or_offset;
+    if (layout->flags.arrayelem_isboxed) {
+        assert(data - (char*)m.mem->ptr < sizeof(jl_value_t*) * m.mem->length);
+        return replace_value(eltype, (_Atomic(jl_value_t*)*)data, owner, expected, rhs, isatomic, NULL, NULL);
+    }
+    uint8_t *psel = NULL;
+    if (layout->flags.arrayelem_isunion) {
+        assert(!isatomic);
+        assert(jl_is_uniontype(eltype));
+        size_t i = (size_t)data;
+        assert(i < m.mem->length);
+        psel = (uint8_t*)jl_genericmemory_typetagdata(m.mem) + i;
+        data = (char*)m.mem->ptr + i * layout->size;
+    }
+    return replace_bits(eltype, data, psel, owner, expected, rhs, isatomic ? isatomic_field : isatomic_none);
+}
+
+JL_DLLEXPORT jl_value_t *jl_memoryrefsetonce(jl_genericmemoryref_t m, jl_value_t *rhs, int isatomic)
+{
+    jl_value_t *eltype = jl_tparam1(jl_typetagof(m.mem));
+    if (eltype != (jl_value_t*)jl_any_type && !jl_typeis(rhs, eltype)) {
+        if (!jl_isa(rhs, eltype))
+            jl_type_error("memoryrefsetonce!", eltype, rhs);
+    }
+    const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typetagof(m.mem))->layout;
+    jl_value_t *owner = jl_genericmemory_owner(m.mem);
+    char *data = (char*)m.ptr_or_offset;
+    int success;
+    if (layout->flags.arrayelem_isboxed) {
+        assert(data - (char*)m.mem->ptr < sizeof(jl_value_t*) * m.mem->length);
+        jl_value_t *r = NULL;
+        _Atomic(jl_value_t*) *px = (_Atomic(jl_value_t*)*)data;
+        success = isatomic ? jl_atomic_cmpswap(px, &r, rhs) : jl_atomic_cmpswap_release(px, &r, rhs);
+        if (success)
+            jl_gc_wb(owner, rhs);
+    }
+    else {
+        if (layout->flags.arrayelem_isunion) {
+            assert(!isatomic);
+            assert(jl_is_uniontype(eltype));
+            size_t i = (size_t)data;
+            assert(i < m.mem->length);
+            (void)i;
+            success = 0;
+        }
+        else if (layout->first_ptr < 0) {
+            success = 0;
+        }
+        else {
+            success = setonce_bits((jl_datatype_t*)eltype, data, owner, rhs, isatomic ? isatomic_field : isatomic_none);
+        }
     }
+    return success ? jl_true : jl_false;
 }
 
 JL_DLLEXPORT jl_value_t *ijl_genericmemory_owner(jl_genericmemory_t *m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index c784727c4f598..3a98850ddca68 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -535,7 +535,7 @@ static jl_datatype_t *staticeval_bitstype(const jl_cgval_t &targ)
     return NULL;
 }
 
-static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, const jl_cgval_t *argv, size_t nargs)
+static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, ArrayRef<jl_cgval_t> argv, size_t nargs)
 {
     Function *func = prepare_call(runtime_func()[f]);
     SmallVector<Value *, 0> argvalues(nargs);
@@ -547,7 +547,7 @@ static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, const
 }
 
 // put a bits type tag on some value (despite the name, this doesn't necessarily actually change anything about the value however)
-static jl_cgval_t generic_bitcast(jl_codectx_t &ctx, const jl_cgval_t *argv)
+static jl_cgval_t generic_bitcast(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 {
     // Give the arguments names //
     const jl_cgval_t &bt_value = argv[0];
@@ -650,7 +650,7 @@ static jl_cgval_t generic_bitcast(jl_codectx_t &ctx, const jl_cgval_t *argv)
 static jl_cgval_t generic_cast(
         jl_codectx_t &ctx,
         intrinsic f, Instruction::CastOps Op,
-        const jl_cgval_t *argv, bool toint, bool fromint)
+        ArrayRef<jl_cgval_t> argv, bool toint, bool fromint)
 {
     auto &TT = ctx.emission_context.TargetTriple;
     auto &DL = ctx.emission_context.DL;
@@ -707,12 +707,12 @@ static jl_cgval_t generic_cast(
     }
 }
 
-static jl_cgval_t emit_runtime_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
+static jl_cgval_t emit_runtime_pointerref(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 {
     return emit_runtime_call(ctx, pointerref, argv, 3);
 }
 
-static jl_cgval_t emit_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
+static jl_cgval_t emit_pointerref(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 {
     const jl_cgval_t &e = argv[0];
     const jl_cgval_t &i = argv[1];
@@ -769,7 +769,8 @@ static jl_cgval_t emit_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
         assert(!isboxed);
         if (!type_is_ghost(ptrty)) {
             Value *thePtr = emit_unbox(ctx, ptrty->getPointerTo(), e, e.typ);
-            auto load = typed_load(ctx, thePtr, im1, ety, ctx.tbaa().tbaa_data, nullptr, isboxed, AtomicOrdering::NotAtomic, false, align_nb);
+            thePtr = ctx.builder.CreateInBoundsGEP(ptrty, thePtr, im1);
+            auto load = typed_load(ctx, thePtr, nullptr, ety, ctx.tbaa().tbaa_data, nullptr, isboxed, AtomicOrdering::NotAtomic, false, align_nb);
             setName(ctx.emission_context, load.V, "pointerref");
             return load;
         }
@@ -779,13 +780,13 @@ static jl_cgval_t emit_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
     }
 }
 
-static jl_cgval_t emit_runtime_pointerset(jl_codectx_t &ctx, jl_cgval_t *argv)
+static jl_cgval_t emit_runtime_pointerset(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 {
     return emit_runtime_call(ctx, pointerset, argv, 4);
 }
 
 // e[i] = x
-static jl_cgval_t emit_pointerset(jl_codectx_t &ctx, jl_cgval_t *argv)
+static jl_cgval_t emit_pointerset(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 {
     const jl_cgval_t &e = argv[0];
     const jl_cgval_t &x = argv[1];
@@ -844,14 +845,15 @@ static jl_cgval_t emit_pointerset(jl_codectx_t &ctx, jl_cgval_t *argv)
         assert(!isboxed);
         if (!type_is_ghost(ptrty)) {
             thePtr = emit_unbox(ctx, ptrty->getPointerTo(), e, e.typ);
-            typed_store(ctx, thePtr, im1, x, jl_cgval_t(), ety, ctx.tbaa().tbaa_data, nullptr, nullptr, isboxed,
-                        AtomicOrdering::NotAtomic, AtomicOrdering::NotAtomic, align_nb, false, true, false, false, false, false, nullptr, "");
+            thePtr = ctx.builder.CreateInBoundsGEP(ptrty, thePtr, im1);
+            typed_store(ctx, thePtr, x, jl_cgval_t(), ety, ctx.tbaa().tbaa_data, nullptr, nullptr, isboxed,
+                        AtomicOrdering::NotAtomic, AtomicOrdering::NotAtomic, align_nb, nullptr, true, false, false, false, false, false, nullptr, "atomic_pointerset", nullptr, nullptr);
         }
     }
     return e;
 }
 
-static jl_cgval_t emit_atomicfence(jl_codectx_t &ctx, jl_cgval_t *argv)
+static jl_cgval_t emit_atomicfence(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 {
     const jl_cgval_t &ord = argv[0];
     if (ord.constant && jl_is_symbol(ord.constant)) {
@@ -867,7 +869,7 @@ static jl_cgval_t emit_atomicfence(jl_codectx_t &ctx, jl_cgval_t *argv)
     return emit_runtime_call(ctx, atomic_fence, argv, 1);
 }
 
-static jl_cgval_t emit_atomic_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
+static jl_cgval_t emit_atomic_pointerref(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 {
     const jl_cgval_t &e = argv[0];
     const jl_cgval_t &ord = argv[1];
@@ -945,7 +947,7 @@ static jl_cgval_t emit_atomic_pointerref(jl_codectx_t &ctx, jl_cgval_t *argv)
 // e[i] <= x (swap)
 // e[i] y => x (replace)
 // x(e[i], y) (modify)
-static jl_cgval_t emit_atomic_pointerop(jl_codectx_t &ctx, intrinsic f, const jl_cgval_t *argv, int nargs, const jl_cgval_t *modifyop)
+static jl_cgval_t emit_atomic_pointerop(jl_codectx_t &ctx, intrinsic f, ArrayRef<jl_cgval_t> argv, int nargs, const jl_cgval_t *modifyop)
 {
     bool issetfield = f == atomic_pointerset;
     bool isreplacefield = f == atomic_pointerreplace;
@@ -982,8 +984,8 @@ static jl_cgval_t emit_atomic_pointerop(jl_codectx_t &ctx, intrinsic f, const jl
         // n.b.: the expected value (y) must be rooted, but not the others
         Value *thePtr = emit_unbox(ctx, ctx.types().T_pprjlvalue, e, e.typ);
         bool isboxed = true;
-        jl_cgval_t ret = typed_store(ctx, thePtr, nullptr, x, y, ety, ctx.tbaa().tbaa_data, nullptr, nullptr, isboxed,
-                    llvm_order, llvm_failorder, sizeof(jl_value_t*), false, issetfield, isreplacefield, isswapfield, ismodifyfield, false, modifyop, "atomic_pointermodify");
+        jl_cgval_t ret = typed_store(ctx, thePtr, x, y, ety, ctx.tbaa().tbaa_data, nullptr, nullptr, isboxed,
+                    llvm_order, llvm_failorder, sizeof(jl_value_t*), nullptr, issetfield, isreplacefield, isswapfield, ismodifyfield, false, false, modifyop, "atomic_pointermodify", nullptr, nullptr);
         if (issetfield)
             ret = e;
         return ret;
@@ -1021,8 +1023,8 @@ static jl_cgval_t emit_atomic_pointerop(jl_codectx_t &ctx, intrinsic f, const jl
             thePtr = emit_unbox(ctx, ptrty->getPointerTo(), e, e.typ);
         else
             thePtr = nullptr; // could use any value here, since typed_store will not use it
-        jl_cgval_t ret = typed_store(ctx, thePtr, nullptr, x, y, ety, ctx.tbaa().tbaa_data, nullptr, nullptr, isboxed,
-                    llvm_order, llvm_failorder, nb, false, issetfield, isreplacefield, isswapfield, ismodifyfield, false, modifyop, "atomic_pointermodify");
+        jl_cgval_t ret = typed_store(ctx, thePtr, x, y, ety, ctx.tbaa().tbaa_data, nullptr, nullptr, isboxed,
+                    llvm_order, llvm_failorder, nb, nullptr, issetfield, isreplacefield, isswapfield, ismodifyfield, false, false, modifyop, "atomic_pointermodify", nullptr, nullptr);
         if (issetfield)
             ret = e;
         return ret;
@@ -1082,7 +1084,7 @@ struct math_builder {
     }
 };
 
-static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **argvalues, size_t nargs,
+static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, ArrayRef<Value*> argvalues, size_t nargs,
                                      jl_datatype_t **newtyp, jl_value_t *xtyp);
 
 
@@ -1263,72 +1265,72 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
     case pointerref:
         ++Emitted_pointerref;
         assert(nargs == 3);
-        return emit_pointerref(ctx, argv.data());
+        return emit_pointerref(ctx, argv);
     case pointerset:
         ++Emitted_pointerset;
         assert(nargs == 4);
-        return emit_pointerset(ctx, argv.data());
+        return emit_pointerset(ctx, argv);
     case atomic_fence:
         ++Emitted_atomic_fence;
         assert(nargs == 1);
-        return emit_atomicfence(ctx, argv.data());
+        return emit_atomicfence(ctx, argv);
     case atomic_pointerref:
         ++Emitted_atomic_pointerref;
         assert(nargs == 2);
-        return emit_atomic_pointerref(ctx, argv.data());
+        return emit_atomic_pointerref(ctx, argv);
     case atomic_pointerset:
     case atomic_pointerswap:
     case atomic_pointermodify:
     case atomic_pointerreplace:
         ++Emitted_atomic_pointerop;
-        return emit_atomic_pointerop(ctx, f, argv.data(), nargs, nullptr);
+        return emit_atomic_pointerop(ctx, f, argv, nargs, nullptr);
     case bitcast:
         ++Emitted_bitcast;
         assert(nargs == 2);
-        return generic_bitcast(ctx, argv.data());
+        return generic_bitcast(ctx, argv);
     case trunc_int:
         ++Emitted_trunc_int;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::Trunc, argv.data(), true, true);
+        return generic_cast(ctx, f, Instruction::Trunc, argv, true, true);
     case sext_int:
         ++Emitted_sext_int;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::SExt, argv.data(), true, true);
+        return generic_cast(ctx, f, Instruction::SExt, argv, true, true);
     case zext_int:
         ++Emitted_zext_int;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::ZExt, argv.data(), true, true);
+        return generic_cast(ctx, f, Instruction::ZExt, argv, true, true);
     case uitofp:
         ++Emitted_uitofp;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::UIToFP, argv.data(), false, true);
+        return generic_cast(ctx, f, Instruction::UIToFP, argv, false, true);
     case sitofp:
         ++Emitted_sitofp;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::SIToFP, argv.data(), false, true);
+        return generic_cast(ctx, f, Instruction::SIToFP, argv, false, true);
     case fptoui:
         ++Emitted_fptoui;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::FPToUI, argv.data(), true, false);
+        return generic_cast(ctx, f, Instruction::FPToUI, argv, true, false);
     case fptosi:
         ++Emitted_fptosi;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::FPToSI, argv.data(), true, false);
+        return generic_cast(ctx, f, Instruction::FPToSI, argv, true, false);
     case fptrunc:
         ++Emitted_fptrunc;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::FPTrunc, argv.data(), false, false);
+        return generic_cast(ctx, f, Instruction::FPTrunc, argv, false, false);
     case fpext:
         ++Emitted_fpext;
         assert(nargs == 2);
-        return generic_cast(ctx, f, Instruction::FPExt, argv.data(), false, false);
+        return generic_cast(ctx, f, Instruction::FPExt, argv, false, false);
 
     case not_int: {
         ++Emitted_not_int;
         assert(nargs == 1);
         const jl_cgval_t &x = argv[0];
         if (!jl_is_primitivetype(x.typ))
-            return emit_runtime_call(ctx, f, argv.data(), nargs);
+            return emit_runtime_call(ctx, f, argv, nargs);
         Type *xt = INTT(bitstype_to_llvm(x.typ, ctx.builder.getContext(), true), DL);
         Value *from = emit_unbox(ctx, xt, x, x.typ);
         Value *ans = ctx.builder.CreateNot(from);
@@ -1340,7 +1342,7 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
         assert(nargs == 1);
         const jl_cgval_t &x = argv[0];
         if (!x.constant || !jl_is_datatype(x.constant))
-            return emit_runtime_call(ctx, f, argv.data(), nargs);
+            return emit_runtime_call(ctx, f, argv, nargs);
         jl_datatype_t *dt = (jl_datatype_t*) x.constant;
 
         // select the appropriated overloaded intrinsic
@@ -1350,7 +1352,7 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
         else if (dt == jl_float64_type)
             intr_name += "f64";
         else
-            return emit_runtime_call(ctx, f, argv.data(), nargs);
+            return emit_runtime_call(ctx, f, argv, nargs);
 
         FunctionCallee intr = jl_Module->getOrInsertFunction(intr_name, getInt1Ty(ctx.builder.getContext()));
         auto ret = ctx.builder.CreateCall(intr);
@@ -1363,14 +1365,14 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
 
         // verify argument types
         if (!jl_is_primitivetype(xinfo.typ))
-            return emit_runtime_call(ctx, f, argv.data(), nargs);
+            return emit_runtime_call(ctx, f, argv, nargs);
         Type *xtyp = bitstype_to_llvm(xinfo.typ, ctx.builder.getContext(), true);
         if (float_func()[f])
             xtyp = FLOATT(xtyp);
         else
             xtyp = INTT(xtyp, DL);
         if (!xtyp)
-            return emit_runtime_call(ctx, f, argv.data(), nargs);
+            return emit_runtime_call(ctx, f, argv, nargs);
         ////Bool are required to be in the range [0,1]
         ////so while they are represented as i8,
         ////the operations need to be done in mod 1
@@ -1386,13 +1388,13 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
 
         if (f == shl_int || f == lshr_int || f == ashr_int) {
             if (!jl_is_primitivetype(argv[1].typ))
-                return emit_runtime_call(ctx, f, argv.data(), nargs);
+                return emit_runtime_call(ctx, f, argv, nargs);
             argt[1] = INTT(bitstype_to_llvm(argv[1].typ, ctx.builder.getContext(), true), DL);
         }
         else {
             for (size_t i = 1; i < nargs; ++i) {
                 if (xinfo.typ != argv[i].typ)
-                    return emit_runtime_call(ctx, f, argv.data(), nargs);
+                    return emit_runtime_call(ctx, f, argv, nargs);
                 argt[i] = xtyp;
             }
         }
@@ -1405,7 +1407,7 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
 
         // call the intrinsic
         jl_value_t *newtyp = xinfo.typ;
-        Value *r = emit_untyped_intrinsic(ctx, f, argvalues.data(), nargs, (jl_datatype_t**)&newtyp, xinfo.typ);
+        Value *r = emit_untyped_intrinsic(ctx, f, argvalues, nargs, (jl_datatype_t**)&newtyp, xinfo.typ);
         // Turn Bool operations into mod 1 now, if needed
         if (newtyp == (jl_value_t*)jl_bool_type && !r->getType()->isIntegerTy(1))
             r = ctx.builder.CreateTrunc(r, getInt1Ty(ctx.builder.getContext()));
@@ -1415,7 +1417,7 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
     assert(0 && "unreachable");
 }
 
-static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, Value **argvalues, size_t nargs,
+static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, ArrayRef<Value*> argvalues, size_t nargs,
                                      jl_datatype_t **newtyp, jl_value_t *xtyp)
 {
     ++EmittedUntypedIntrinsics;
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index f9587d33518a2..138bde4a0830a 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -28,11 +28,8 @@
     XX(jl_array_ptr) \
     XX(jl_array_ptr_1d_append) \
     XX(jl_array_ptr_1d_push) \
-    XX(jl_genericmemory_isassigned) \
     XX(jl_genericmemory_owner) \
     XX(jl_genericmemoryref) \
-    XX(jl_genericmemoryset) \
-    XX(jl_genericmemoryunset) \
     XX(jl_array_rank) \
     XX(jl_array_to_string) \
     XX(jl_atexit_hook) \
@@ -41,6 +38,7 @@
     XX(jl_atomic_error) \
     XX(jl_atomic_new_bits) \
     XX(jl_atomic_store_bits) \
+    XX(jl_atomic_storeonce_bits) \
     XX(jl_atomic_swap_bits) \
     XX(jl_backtrace_from_here) \
     XX(jl_base_relative_to) \
diff --git a/src/julia.h b/src/julia.h
index 43df87fd45266..7d143a3daa3fc 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1744,10 +1744,11 @@ JL_DLLEXPORT jl_datatype_t *jl_new_primitivetype(jl_value_t *name,
 // constructors
 JL_DLLEXPORT jl_value_t *jl_new_bits(jl_value_t *bt, const void *src);
 JL_DLLEXPORT jl_value_t *jl_atomic_new_bits(jl_value_t *dt, const char *src);
-JL_DLLEXPORT void jl_atomic_store_bits(char *dst, const jl_value_t *src, int nb);
+JL_DLLEXPORT void jl_atomic_store_bits(char *dst, const jl_value_t *src, int nb) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_atomic_swap_bits(jl_value_t *dt, char *dst, const jl_value_t *src, int nb);
-JL_DLLEXPORT int jl_atomic_bool_cmpswap_bits(char *dst, const jl_value_t *expected, const jl_value_t *src, int nb);
-JL_DLLEXPORT jl_value_t *jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_datatype_t *rettype, char *dst, const jl_value_t *expected, const jl_value_t *src, int nb);
+JL_DLLEXPORT int jl_atomic_bool_cmpswap_bits(char *dst, const jl_value_t *expected, const jl_value_t *src, int nb) JL_NOTSAFEPOINT;
+JL_DLLEXPORT int jl_atomic_cmpswap_bits(jl_datatype_t *dt, jl_value_t *y, char *dst, const jl_value_t *expected, const jl_value_t *src, int nb) JL_NOTSAFEPOINT;
+JL_DLLEXPORT int jl_atomic_storeonce_bits(jl_datatype_t *dt, char *dst, const jl_value_t *src, int nb) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_new_struct(jl_datatype_t *type, ...);
 JL_DLLEXPORT jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args, uint32_t na);
 JL_DLLEXPORT jl_value_t *jl_new_structt(jl_datatype_t *type, jl_value_t *tup);
@@ -1875,17 +1876,17 @@ JL_DLLEXPORT jl_genericmemory_t *jl_pchar_to_memory(const char *str, size_t len)
 JL_DLLEXPORT jl_value_t *jl_genericmemory_to_string(jl_genericmemory_t *m, size_t len);
 JL_DLLEXPORT jl_genericmemory_t *jl_alloc_memory_any(size_t n);
 JL_DLLEXPORT jl_value_t *jl_genericmemoryref(jl_genericmemory_t *m, size_t i);  // 0-indexed
-JL_DLLEXPORT void jl_genericmemoryset(jl_genericmemory_t *m JL_ROOTING_ARGUMENT, jl_value_t *v JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, size_t i);  // 0-indexed
-JL_DLLEXPORT void jl_genericmemoryunset(jl_genericmemory_t *m, size_t i);  // 0-indexed
-JL_DLLEXPORT int jl_genericmemory_isassigned(jl_genericmemory_t *m, size_t i);  // 0-indexed
 
 JL_DLLEXPORT jl_genericmemoryref_t *jl_new_memoryref(jl_value_t *typ, jl_genericmemory_t *mem, void *data);
-JL_DLLEXPORT jl_value_t *jl_memoryrefget(jl_genericmemoryref_t m JL_PROPAGATES_ROOT);
+JL_DLLEXPORT jl_value_t *jl_memoryrefget(jl_genericmemoryref_t m JL_PROPAGATES_ROOT, int isatomic);
 JL_DLLEXPORT jl_value_t *jl_ptrmemoryrefget(jl_genericmemoryref_t m JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
-JL_DLLEXPORT jl_value_t *jl_memoryref_isassigned(jl_genericmemoryref_t m) JL_GLOBALLY_ROOTED;
+JL_DLLEXPORT jl_value_t *jl_memoryref_isassigned(jl_genericmemoryref_t m, int isatomic) JL_GLOBALLY_ROOTED;
 JL_DLLEXPORT jl_genericmemoryref_t jl_memoryrefindex(jl_genericmemoryref_t m JL_PROPAGATES_ROOT, size_t idx) JL_NOTSAFEPOINT;
-JL_DLLEXPORT void jl_memoryrefset(jl_genericmemoryref_t m JL_ROOTING_ARGUMENT, jl_value_t *v JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED);
-JL_DLLEXPORT void jl_memoryrefunset(jl_genericmemoryref_t m);
+JL_DLLEXPORT void jl_memoryrefset(jl_genericmemoryref_t m JL_ROOTING_ARGUMENT, jl_value_t *v JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, int isatomic);
+JL_DLLEXPORT jl_value_t *jl_memoryrefswap(jl_genericmemoryref_t m, jl_value_t *v, int isatomic);
+JL_DLLEXPORT jl_value_t *jl_memoryrefmodify(jl_genericmemoryref_t m, jl_value_t *op, jl_value_t *v, int isatomic);
+JL_DLLEXPORT jl_value_t *jl_memoryrefreplace(jl_genericmemoryref_t m, jl_value_t *expected, jl_value_t *v, int isatomic);
+JL_DLLEXPORT jl_value_t *jl_memoryrefsetonce(jl_genericmemoryref_t m, jl_value_t *v, int isatomic);
 
 // strings
 JL_DLLEXPORT const char *jl_string_ptr(jl_value_t *s);
@@ -1925,6 +1926,10 @@ JL_DLLEXPORT jl_value_t *jl_get_global(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym
 JL_DLLEXPORT void jl_set_global(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT);
 JL_DLLEXPORT void jl_set_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT);
 JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs JL_MAYBE_UNROOTED);
+JL_DLLEXPORT jl_value_t *jl_checked_swap(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs JL_MAYBE_UNROOTED);
+JL_DLLEXPORT jl_value_t *jl_checked_replace(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *expected, jl_value_t *rhs);
+JL_DLLEXPORT jl_value_t *jl_checked_modify(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *op, jl_value_t *rhs);
+JL_DLLEXPORT jl_value_t *jl_checked_assignonce(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs JL_MAYBE_UNROOTED);
 JL_DLLEXPORT void jl_declare_constant(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var);
 JL_DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from);
 JL_DLLEXPORT void jl_module_use(jl_module_t *to, jl_module_t *from, jl_sym_t *s);
diff --git a/src/julia_atomics.h b/src/julia_atomics.h
index 7e7c8052a278b..c094afcc54cd5 100644
--- a/src/julia_atomics.h
+++ b/src/julia_atomics.h
@@ -174,6 +174,11 @@ bool jl_atomic_cmpswap_acqrel(std::atomic<T> *ptr, T *expected, S val)
 {
      return std::atomic_compare_exchange_strong_explicit<T>(ptr, expected, val, memory_order_acq_rel, memory_order_acquire);
 }
+template<class T, class S>
+bool jl_atomic_cmpswap_release(std::atomic<T> *ptr, T *expected, S val)
+{
+     return std::atomic_compare_exchange_strong_explicit<T>(ptr, expected, val, memory_order_release, memory_order_relaxed);
+}
 #define jl_atomic_cmpswap_relaxed(ptr, expected, val) jl_atomic_cmpswap_explicit(ptr, expected, val, memory_order_relaxed)
 template<class T, class S>
 T jl_atomic_exchange(std::atomic<T> *ptr, S desired)
@@ -185,6 +190,7 @@ T jl_atomic_exchange_explicit(std::atomic<T> *ptr, S desired, std::memory_order
 {
      return std::atomic_exchange_explicit<T>(ptr, desired, order);
 }
+#define jl_atomic_exchange_release(ptr, val) jl_atomic_exchange_explicit(ptr, val, memory_order_reease)
 #define jl_atomic_exchange_relaxed(ptr, val) jl_atomic_exchange_explicit(ptr, val, memory_order_relaxed)
 extern "C" {
 #else
@@ -205,11 +211,15 @@ extern "C" {
     atomic_compare_exchange_strong(obj, expected, desired)
 #  define jl_atomic_cmpswap_relaxed(obj, expected, desired) \
     atomic_compare_exchange_strong_explicit(obj, expected, desired, memory_order_relaxed, memory_order_relaxed)
-#define jl_atomic_cmpswap_acqrel(obj, expected, desired) \
+#  define jl_atomic_cmpswap_release(obj, expected, desired) \
+    atomic_compare_exchange_strong_explicit(obj, expected, desired, memory_order_release, memory_order_relaxed)
+#  define jl_atomic_cmpswap_acqrel(obj, expected, desired) \
     atomic_compare_exchange_strong_explicit(obj, expected, desired, memory_order_acq_rel, memory_order_acquire)
 // TODO: Maybe add jl_atomic_cmpswap_weak for spin lock
 #  define jl_atomic_exchange(obj, desired)       \
     atomic_exchange(obj, desired)
+#  define jl_atomic_exchange_release(obj, desired)      \
+    atomic_exchange_explicit(obj, desired, memory_order_release)
 #  define jl_atomic_exchange_relaxed(obj, desired)      \
     atomic_exchange_explicit(obj, desired, memory_order_relaxed)
 #  define jl_atomic_store(obj, val)                     \
@@ -256,6 +266,7 @@ extern "C" {
 #define _Atomic(T) T
 
 #undef jl_atomic_exchange
+#undef jl_atomic_exchange_release
 #undef jl_atomic_exchange_relaxed
 #define jl_atomic_exchange(obj, desired) \
     (__extension__({ \
@@ -264,10 +275,12 @@ extern "C" {
             *p__analyzer__ = (desired); \
             temp__analyzer__; \
         }))
+#define jl_atomic_exchange_release jl_atomic_exchange
 #define jl_atomic_exchange_relaxed jl_atomic_exchange
 
 #undef jl_atomic_cmpswap
 #undef jl_atomic_cmpswap_acqrel
+#undef jl_atomic_cmpswap_release
 #undef jl_atomic_cmpswap_relaxed
 #define jl_atomic_cmpswap(obj, expected, desired) \
     (__extension__({ \
@@ -282,6 +295,7 @@ extern "C" {
             eq__analyzer__; \
         }))
 #define jl_atomic_cmpswap_acqrel jl_atomic_cmpswap
+#define jl_atomic_cmpswap_release jl_atomic_cmpswap
 #define jl_atomic_cmpswap_relaxed jl_atomic_cmpswap
 
 #undef jl_atomic_store
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 94b7e5609f06d..e140dfa205d8e 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -308,6 +308,25 @@ static inline void memmove_refs(_Atomic(void*) *dstp, _Atomic(void*) *srcp, size
     }
 }
 
+static inline void memassign_safe(int hasptr, char *dst, const jl_value_t *src, size_t nb) JL_NOTSAFEPOINT
+{
+    assert(nb == jl_datatype_size(jl_typeof(src)));
+    if (hasptr) {
+        size_t nptr = nb / sizeof(void*);
+        memmove_refs((_Atomic(void*)*)dst, (_Atomic(void*)*)src, nptr);
+        nb -= nptr * sizeof(void*);
+        if (__likely(nb == 0))
+            return;
+        src = (jl_value_t*)((char*)src + nptr * sizeof(void*));
+        dst = dst + nptr * sizeof(void*);
+    }
+    else if (nb >= 16) {
+        memcpy(dst, jl_assume_aligned(src, 16), nb);
+        return;
+    }
+    memcpy(dst, jl_assume_aligned(src, sizeof(void*)), nb);
+}
+
 // -- gc.c -- //
 
 #define GC_CLEAN  0 // freshly allocated
@@ -708,6 +727,12 @@ typedef struct jl_typeenv_t {
 int jl_tuple_isa(jl_value_t **child, size_t cl, jl_datatype_t *pdt);
 int jl_tuple1_isa(jl_value_t *child1, jl_value_t **child, size_t cl, jl_datatype_t *pdt);
 
+enum atomic_kind {
+    isatomic_none = 0,
+    isatomic_object = 1,
+    isatomic_field = 2
+};
+
 JL_DLLEXPORT int jl_has_intersect_type_not_kind(jl_value_t *t);
 int jl_subtype_invariant(jl_value_t *a, jl_value_t *b, int ta);
 int jl_has_concrete_subtype(jl_value_t *typ);
@@ -753,6 +778,13 @@ void set_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs,
 jl_value_t *swap_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs, int isatomic);
 jl_value_t *modify_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *op, jl_value_t *rhs, int isatomic);
 jl_value_t *replace_nth_field(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *expected, jl_value_t *rhs, int isatomic);
+int set_nth_fieldonce(jl_datatype_t *st, jl_value_t *v, size_t i, jl_value_t *rhs, int isatomic);
+jl_value_t *swap_bits(jl_value_t *ty, char *v, uint8_t *psel, jl_value_t *parent, jl_value_t *rhs, enum atomic_kind isatomic);
+jl_value_t *replace_value(jl_value_t *ty, _Atomic(jl_value_t*) *p, jl_value_t *parent, jl_value_t *expected, jl_value_t *rhs, int isatomic, jl_module_t *mod, jl_sym_t *name);
+jl_value_t *replace_bits(jl_value_t *ty, char *p, uint8_t *psel, jl_value_t *parent, jl_value_t *expected, jl_value_t *rhs, enum atomic_kind isatomic);
+jl_value_t *modify_value(jl_value_t *ty, _Atomic(jl_value_t*) *p, jl_value_t *parent, jl_value_t *op, jl_value_t *rhs, int isatomic, jl_module_t *mod, jl_sym_t *name);
+jl_value_t *modify_bits(jl_value_t *ty, char *p, uint8_t *psel, jl_value_t *parent, jl_value_t *op, jl_value_t *rhs, enum atomic_kind isatomic);
+int setonce_bits(jl_datatype_t *rty, char *p, jl_value_t *owner, jl_value_t *rhs, enum atomic_kind isatomic);
 jl_expr_t *jl_exprn(jl_sym_t *head, size_t n);
 jl_function_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module);
 jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_t *module, jl_datatype_t *st);
diff --git a/src/julia_locks.h b/src/julia_locks.h
index 47e258f69aab2..5774ddada60c6 100644
--- a/src/julia_locks.h
+++ b/src/julia_locks.h
@@ -96,6 +96,11 @@ static inline void jl_mutex_init(jl_mutex_t *lock, const char *name) JL_NOTSAFEP
 #define JL_LOCK_NOGC(m) jl_mutex_lock_nogc(m)
 #define JL_UNLOCK_NOGC(m) jl_mutex_unlock_nogc(m)
 
+JL_DLLEXPORT void jl_lock_value(jl_mutex_t *v) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_unlock_value(jl_mutex_t *v) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_lock_field(jl_mutex_t *v) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_unlock_field(jl_mutex_t *v) JL_NOTSAFEPOINT;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index edb3aad8f2328..e081c6f067245 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -1620,6 +1620,7 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                         callee == gc_preserve_end_func || callee == typeof_func ||
                         callee == pgcstack_getter || callee->getName() == XSTR(jl_egal__unboxed) ||
                         callee->getName() == XSTR(jl_lock_value) || callee->getName() == XSTR(jl_unlock_value) ||
+                        callee->getName() == XSTR(jl_lock_field) || callee->getName() == XSTR(jl_unlock_field) ||
                         callee == write_barrier_func || callee == gc_loaded_func ||
                         callee->getName() == "memcmp") {
                         continue;
diff --git a/src/module.c b/src/module.c
index 787ea947d0480..44b89bc236afc 100644
--- a/src/module.c
+++ b/src/module.c
@@ -669,10 +669,10 @@ JL_DLLEXPORT void jl_module_public(jl_module_t *from, jl_sym_t *s, int exported)
     b->exportp |= exported;
 }
 
-JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var) // unlike most queries here, this is currently seq_cst
 {
     jl_binding_t *b = jl_get_binding(m, var);
-    return b && (jl_atomic_load_relaxed(&b->value) != NULL);
+    return b && (jl_atomic_load(&b->value) != NULL);
 }
 
 JL_DLLEXPORT int jl_defines_or_exports_p(jl_module_t *m, jl_sym_t *var)
@@ -875,7 +875,7 @@ void jl_binding_deprecation_warning(jl_module_t *m, jl_sym_t *s, jl_binding_t *b
     }
 }
 
-JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs)
+jl_value_t *jl_check_binding_wr(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs JL_MAYBE_UNROOTED, int reassign)
 {
     jl_value_t *old_ty = NULL;
     if (!jl_atomic_cmpswap_relaxed(&b->ty, &old_ty, (jl_value_t*)jl_any_type)) {
@@ -887,24 +887,73 @@ JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_module_t *mod, jl_sy
             JL_GC_POP();
         }
     }
+    else {
+        old_ty = (jl_value_t*)jl_any_type;
+    }
     if (b->constp) {
-        jl_value_t *old = NULL;
-        if (jl_atomic_cmpswap(&b->value, &old, rhs)) {
-            jl_gc_wb(b, rhs);
-            return;
+        if (reassign) {
+            jl_value_t *old = NULL;
+            if (jl_atomic_cmpswap(&b->value, &old, rhs)) {
+                jl_gc_wb(b, rhs);
+                return NULL;
+            }
+            if (jl_egal(rhs, old))
+                return NULL;
+            if (jl_typeof(rhs) != jl_typeof(old) || jl_is_type(rhs) || jl_is_module(rhs))
+                reassign = 0;
+            else
+                jl_safe_printf("WARNING: redefinition of constant %s.%s. This may fail, cause incorrect answers, or produce other errors.\n",
+                               jl_symbol_name(mod->name), jl_symbol_name(var));
         }
-        if (jl_egal(rhs, old))
-            return;
-        if (jl_typeof(rhs) != jl_typeof(old) || jl_is_type(rhs) || jl_is_module(rhs)) {
+        if (!reassign)
             jl_errorf("invalid redefinition of constant %s.%s",
                       jl_symbol_name(mod->name), jl_symbol_name(var));
+    }
+    return old_ty;
+}
 
-        }
-        jl_safe_printf("WARNING: redefinition of constant %s.%s. This may fail, cause incorrect answers, or produce other errors.\n",
-                       jl_symbol_name(mod->name), jl_symbol_name(var));
+JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs)
+{
+    if (jl_check_binding_wr(b, mod, var, rhs, 1) != NULL) {
+        jl_atomic_store_release(&b->value, rhs);
+        jl_gc_wb(b, rhs);
     }
-    jl_atomic_store_release(&b->value, rhs);
+}
+
+JL_DLLEXPORT jl_value_t *jl_checked_swap(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs)
+{
+    jl_check_binding_wr(b, mod, var, rhs, 0);
+    jl_value_t *old = jl_atomic_exchange(&b->value, rhs);
     jl_gc_wb(b, rhs);
+    if (__unlikely(old == NULL))
+        jl_undefined_var_error(var, (jl_value_t*)mod);
+    return old;
+}
+
+JL_DLLEXPORT jl_value_t *jl_checked_replace(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *expected, jl_value_t *rhs)
+{
+    jl_value_t *ty = jl_check_binding_wr(b, mod, var, rhs, 0);
+    return replace_value(ty, &b->value, (jl_value_t*)b, expected, rhs, 1, mod, var);
+}
+
+JL_DLLEXPORT jl_value_t *jl_checked_modify(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *op, jl_value_t *rhs)
+{
+    jl_value_t *ty = NULL;
+    if (jl_atomic_cmpswap_relaxed(&b->ty, &ty, (jl_value_t*)jl_any_type))
+        ty = (jl_value_t*)jl_any_type;
+    if (b->constp)
+        jl_errorf("invalid redefinition of constant %s.%s",
+                  jl_symbol_name(mod->name), jl_symbol_name(var));
+    return modify_value(ty, &b->value, (jl_value_t*)b, op, rhs, 1, mod, var);
+}
+
+JL_DLLEXPORT jl_value_t *jl_checked_assignonce(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs )
+{
+    jl_check_binding_wr(b, mod, var, rhs, 0);
+    jl_value_t *old = NULL;
+    if (jl_atomic_cmpswap(&b->value, &old, rhs))
+        jl_gc_wb(b, rhs);
+    return old;
 }
 
 JL_DLLEXPORT void jl_declare_constant(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var)
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index 2a84532c4c76b..ff479a4d30959 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -584,9 +584,9 @@ JL_DLLEXPORT jl_value_t *jl_atomic_pointerreplace(jl_value_t *p, jl_value_t *exp
     char *pp = (char*)jl_unbox_long(p);
     jl_datatype_t *rettyp = jl_apply_cmpswap_type(ety);
     JL_GC_PROMISE_ROOTED(rettyp); // (JL_ALWAYS_LEAFTYPE)
+    jl_value_t *result = NULL;
+    JL_GC_PUSH1(&result);
     if (ety == (jl_value_t*)jl_any_type) {
-        jl_value_t *result;
-        JL_GC_PUSH1(&result);
         result = expected;
         int success;
         while (1) {
@@ -595,8 +595,6 @@ JL_DLLEXPORT jl_value_t *jl_atomic_pointerreplace(jl_value_t *p, jl_value_t *exp
                 break;
         }
         result = jl_new_struct(rettyp, result, success ? jl_true : jl_false);
-        JL_GC_POP();
-        return result;
     }
     else {
         if (jl_typeof(x) != ety)
@@ -604,8 +602,20 @@ JL_DLLEXPORT jl_value_t *jl_atomic_pointerreplace(jl_value_t *p, jl_value_t *exp
         size_t nb = jl_datatype_size(ety);
         if ((nb & (nb - 1)) != 0 || nb > MAX_POINTERATOMIC_SIZE)
             jl_error("atomic_pointerreplace: invalid pointer for atomic operation");
-        return jl_atomic_cmpswap_bits((jl_datatype_t*)ety, rettyp, pp, expected, x, nb);
+        int isptr = jl_field_isptr(rettyp, 0);
+        jl_task_t *ct = jl_current_task;
+        result = jl_gc_alloc(ct->ptls, isptr ? nb : jl_datatype_size(rettyp), isptr ? ety : (jl_value_t*)rettyp);
+        int success = jl_atomic_cmpswap_bits((jl_datatype_t*)ety, result, pp, expected, x, nb);
+        if (isptr) {
+            jl_value_t *z = jl_gc_alloc(ct->ptls, jl_datatype_size(rettyp), rettyp);
+            *(jl_value_t**)z = result;
+            result = z;
+            nb = sizeof(jl_value_t*);
+        }
+        *((uint8_t*)result + nb) = success ? 1 : 0;
     }
+    JL_GC_POP();
+    return result;
 }
 
 JL_DLLEXPORT jl_value_t *jl_atomic_fence(jl_value_t *order_sym)
diff --git a/src/staticdata.c b/src/staticdata.c
index e7ebcea7bd061..8489fa116688e 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -100,7 +100,7 @@ extern "C" {
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
-#define NUM_TAGS    179
+#define NUM_TAGS    188
 
 // An array of references that need to be restored from the sysimg
 // This is a manually constructed dual of the gvars array, which would be produced by codegen for Julia code, for C.
@@ -283,12 +283,17 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_builtin_swapfield);
         INSERT_TAG(jl_builtin_modifyfield);
         INSERT_TAG(jl_builtin_replacefield);
+        INSERT_TAG(jl_builtin_setfieldonce);
         INSERT_TAG(jl_builtin_fieldtype);
         INSERT_TAG(jl_builtin_memoryref);
         INSERT_TAG(jl_builtin_memoryrefoffset);
         INSERT_TAG(jl_builtin_memoryrefget);
         INSERT_TAG(jl_builtin_memoryrefset);
         INSERT_TAG(jl_builtin_memoryref_isassigned);
+        INSERT_TAG(jl_builtin_memoryrefswap);
+        INSERT_TAG(jl_builtin_memoryrefmodify);
+        INSERT_TAG(jl_builtin_memoryrefreplace);
+        INSERT_TAG(jl_builtin_memoryrefsetonce);
         INSERT_TAG(jl_builtin_apply_type);
         INSERT_TAG(jl_builtin_applicable);
         INSERT_TAG(jl_builtin_invoke);
@@ -299,6 +304,10 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_builtin_compilerbarrier);
         INSERT_TAG(jl_builtin_getglobal);
         INSERT_TAG(jl_builtin_setglobal);
+        INSERT_TAG(jl_builtin_swapglobal);
+        INSERT_TAG(jl_builtin_modifyglobal);
+        INSERT_TAG(jl_builtin_replaceglobal);
+        INSERT_TAG(jl_builtin_setglobalonce);
         // n.b. must update NUM_TAGS when you add something here
 #undef INSERT_TAG
         assert(i == NUM_TAGS - 1);
@@ -461,14 +470,16 @@ static const jl_fptr_args_t id_to_fptrs[] = {
     &jl_f_typeassert, &jl_f__apply_iterate, &jl_f__apply_pure,
     &jl_f__call_latest, &jl_f__call_in_world, &jl_f__call_in_world_total, &jl_f_isdefined,
     &jl_f_tuple, &jl_f_svec, &jl_f_intrinsic_call,
-    &jl_f_getfield, &jl_f_setfield, &jl_f_swapfield, &jl_f_modifyfield,
+    &jl_f_getfield, &jl_f_setfield, &jl_f_swapfield, &jl_f_modifyfield, &jl_f_setfieldonce,
     &jl_f_replacefield, &jl_f_fieldtype, &jl_f_nfields, &jl_f_apply_type,
-    &jl_f_memoryref, &jl_f_memoryrefoffset, &jl_f_memoryrefget, &jl_f_memoryrefset, &jl_f_memoryref_isassigned,
+    &jl_f_memoryref, &jl_f_memoryrefoffset, &jl_f_memoryrefget, &jl_f_memoryref_isassigned,
+    &jl_f_memoryrefset,  &jl_f_memoryrefswap, &jl_f_memoryrefmodify, &jl_f_memoryrefreplace, &jl_f_memoryrefsetonce,
     &jl_f_applicable, &jl_f_invoke, &jl_f_sizeof, &jl_f__expr, &jl_f__typevar,
     &jl_f_ifelse, &jl_f__structtype, &jl_f__abstracttype, &jl_f__primitivetype,
     &jl_f__typebody, &jl_f__setsuper, &jl_f__equiv_typedef, &jl_f_get_binding_type,
     &jl_f_set_binding_type, &jl_f_opaque_closure_call, &jl_f_donotdelete, &jl_f_compilerbarrier,
-    &jl_f_getglobal, &jl_f_setglobal, &jl_f_finalizer, &jl_f__compute_sparams, &jl_f__svec_ref,
+    &jl_f_getglobal, &jl_f_setglobal, &jl_f_swapglobal, &jl_f_modifyglobal, &jl_f_replaceglobal, &jl_f_setglobalonce,
+    &jl_f_finalizer, &jl_f__compute_sparams, &jl_f__svec_ref,
     &jl_f_current_scope,
     NULL };
 
diff --git a/test/atomics.jl b/test/atomics.jl
index dd50fb96be49f..0d6c841073ad5 100644
--- a/test/atomics.jl
+++ b/test/atomics.jl
@@ -44,6 +44,13 @@ copy(r::Union{Refxy,ARefxy}) = typeof(r)(r.x, r.y)
 function add(x::T, y)::T where {T}; x + y; end
 swap(x, y) = y
 
+struct UndefComplex{T}
+    re::T
+    im::T
+    UndefComplex{T}() where {T} = new{T}()
+end
+Base.convert(T::Type{<:UndefComplex}, S) = T()
+
 let T1 = Refxy{NTuple{3,UInt8}},
     T2 = ARefxy{NTuple{3,UInt8}}
     @test sizeof(T1) == 6
@@ -60,10 +67,13 @@ end
 
 # check that very large types are getting locks
 let (x, y) = (Complex{Int128}(10, 30), Complex{Int128}(20, 40))
-    ar = ARefxy(x, y)
     r = Refxy(x, y)
+    ar = ARefxy(x, y)
+    mr = AtomicMemory{Pair{typeof(x),typeof(y)}}(undef, 20)
     @test 64 == sizeof(r) < sizeof(ar)
-    @test sizeof(r) == sizeof(ar) - Int(fieldoffset(typeof(ar), 1))
+    @test sizeof(ar) == sizeof(r) + Int(fieldoffset(typeof(ar), 1))
+    @test_broken Base.elsize(mr) == sizeof(ar)
+    @test sizeof(mr) == length(mr) * (sizeof(r) + 16)
 end
 
 struct PadIntA <: Number # internal padding
@@ -87,6 +97,8 @@ Base.show(io::IO, x::PadIntA) = print(io, "PadIntA(", x.b, ")")
 Base.show(io::IO, x::PadIntB) = print(io, "PadIntB(", Int(x), ")")
 Base.show(io::IO, x::Int24) = print(io, "Int24(", Core.Intrinsics.zext_int(Int, x), ")")
 
+## Fields
+
 @noinline function _test_field_operators(r)
     r = r[]
     TT = fieldtype(typeof(r), :x)
@@ -264,6 +276,26 @@ test_field_operators(ARefxy{Float64}(123_10, 123_20))
     @test replacefield!(r, :x, x, y, :sequentially_consistent, :sequentially_consistent) === ReplaceType{TT}((x, true))
     @test replacefield!(r, :x, x, y, :sequentially_consistent, :sequentially_consistent) === ReplaceType{TT}((y, x === y))
     @test replacefield!(r, :x, y, x, :sequentially_consistent) === ReplaceType{TT}((y, true))
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x, x, :u, :not_atomic)
+    @test_throws ConcurrencyViolationError("setfieldonce!: atomic field cannot be written non-atomically") setfieldonce!(r, :x, x)
+    @test_throws ConcurrencyViolationError("setfieldonce!: atomic field cannot be written non-atomically") setfieldonce!(r, :x, y, :not_atomic, :not_atomic)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x,  x, :unordered, :not_atomic)
+    @test_throws ConcurrencyViolationError("setfieldonce!: atomic field cannot be accessed non-atomically") setfieldonce!(r, :x, x, :monotonic, :not_atomic)
+    @test_throws ConcurrencyViolationError("setfieldonce!: atomic field cannot be accessed non-atomically") setfieldonce!(r, :x, x, :acquire, :not_atomic)
+    @test_throws ConcurrencyViolationError("setfieldonce!: atomic field cannot be accessed non-atomically") setfieldonce!(r, :x, x, :release, :not_atomic)
+    @test_throws ConcurrencyViolationError("setfieldonce!: atomic field cannot be accessed non-atomically") setfieldonce!(r, :x, x, :acquire_release, :not_atomic)
+    @test_throws ConcurrencyViolationError("setfieldonce!: atomic field cannot be accessed non-atomically") setfieldonce!(r, :x, x, :sequentially_consistent, :not_atomic)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x, x, :not_atomic, :u)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x, x, :not_atomic, :unordered)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x, x, :not_atomic, :monotonic)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x, x, :not_atomic, :acquire)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x, x, :not_atomic, :release)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x, x, :not_atomic, :acquire_release)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") setfieldonce!(r, :x, x, :not_atomic, :sequentially_consistent)
+    @test setfieldonce!(r, :x, y, :sequentially_consistent, :sequentially_consistent) === false
+    @test setfieldonce!(r, :x, y, :sequentially_consistent, :sequentially_consistent) === false
+    @test setfieldonce!(r, :x, x, :sequentially_consistent) === false
     nothing
 end
 @noinline function test_field_orderings(r, x, y)
@@ -287,12 +319,6 @@ test_field_orderings(Complex{Int128}(10, 30), Complex{Int128}(20, 40))
 test_field_orderings(10.0, 20.0)
 test_field_orderings(NaN, Inf)
 
-struct UndefComplex{T}
-    re::T
-    im::T
-    UndefComplex{T}() where {T} = new{T}()
-end
-Base.convert(T::Type{<:UndefComplex}, S) = T()
 @noinline function _test_field_undef(r)
     r = r[]
     TT = fieldtype(typeof(r), :x)
@@ -318,6 +344,29 @@ test_field_undef(ARefxy{Union{Nothing,Integer}})
 test_field_undef(ARefxy{UndefComplex{Any}})
 test_field_undef(ARefxy{UndefComplex{UndefComplex{Any}}})
 
+@noinline function _test_once_undef(r)
+    r = r[]
+    TT = fieldtype(typeof(r), :x)
+    x = convert(TT, 12345_10)
+    @test_throws UndefRefError getfield(r, :x)
+    @test setfieldonce!(r, :x, x, :sequentially_consistent) === true
+    @test getfield(r, :x, :sequentially_consistent) === x
+    @test setfieldonce!(r, :x, convert(TT, 12345_20), :sequentially_consistent) === false
+    nothing
+end
+
+@noinline function test_once_undef(TT)
+    _test_once_undef(Ref(TT()))
+    _test_once_undef(Ref{Any}(TT()))
+    nothing
+end
+
+test_once_undef(ARefxy{BigInt})
+test_once_undef(ARefxy{Any})
+test_once_undef(ARefxy{Union{Nothing,Integer}})
+test_once_undef(ARefxy{UndefComplex{Any}})
+test_once_undef(ARefxy{UndefComplex{UndefComplex{Any}}})
+
 @test_throws ErrorException @macroexpand @atomic foo()
 @test_throws ErrorException @macroexpand @atomic foo += bar
 @test_throws ErrorException @macroexpand @atomic foo += bar
@@ -374,6 +423,13 @@ let a = ARefxy(1, -1)
     @test_throws ConcurrencyViolationError @atomicreplace :monotonic :acquire a.x xchg
 end
 
+let a = ARefxy{Union{Nothing,Integer}}()
+    @test_throws ConcurrencyViolationError @atomiconce :not_atomic a.x = 2
+    @test true === @atomiconce a.x = 1
+    @test 1 === @atomic a.x
+    @test false === @atomiconce a.x = 2
+end
+
 # atomic getfield with boundcheck
 # via codegen
 getx(a, boundcheck) = getfield(a, :x, :sequentially_consistent, boundcheck)
@@ -384,3 +440,558 @@ ans = getfield(ARefxy{Any}(42, 42), :x, :sequentially_consistent, true)
 @test ans == 42
 ans = getfield(ARefxy{Any}(42, 42), :x, :sequentially_consistent, false)
 @test ans == 42
+
+
+## Globals
+
+# the optimizer is terrible at handling PhiC nodes, so this must be a function
+# generator with a custom inlining here of r, instead of being able to assume
+# the inlining pass can inline a constant value correctly
+function gen_test_global_operators(@nospecialize r)
+    M = @__MODULE__
+    return quote
+        TT = Core.get_binding_type($M, $r)
+        T = typeof(getglobal($M, $r))
+        @test getglobal($M, $r, :sequentially_consistent) === T(123_10)
+        @test setglobal!($M, $r, T(123_1), :sequentially_consistent) === T(123_1)
+        @test getglobal($M, $r, :sequentially_consistent) === T(123_1)
+        @test replaceglobal!($M, $r, 123_1 % UInt, T(123_30), :sequentially_consistent, :sequentially_consistent) === ReplaceType{TT}((T(123_1), false))
+        @test replaceglobal!($M, $r, T(123_1), T(123_30), :sequentially_consistent, :sequentially_consistent) === ReplaceType{TT}((T(123_1), true))
+        @test getglobal($M, $r, :sequentially_consistent) === T(123_30)
+        @test replaceglobal!($M, $r, T(123_1), T(123_1), :sequentially_consistent, :sequentially_consistent) === ReplaceType{TT}((T(123_30), false))
+        @test getglobal($M, $r, :sequentially_consistent) === T(123_30)
+        @test modifyglobal!($M, $r, add, 1, :sequentially_consistent) === Pair{TT,TT}(T(123_30), T(123_31))
+        @test modifyglobal!($M, $r, add, 1, :sequentially_consistent) === Pair{TT,TT}(T(123_31), T(123_32))
+        @test getglobal($M, $r, :sequentially_consistent) === T(123_32)
+        @test swapglobal!($M, $r, T(123_1), :sequentially_consistent) === T(123_32)
+        @test getglobal($M, $r, :sequentially_consistent) === T(123_1)
+    end
+end
+@noinline function test_global_operators(T::Type)
+    r = Symbol("g1_$T")
+    @eval global $r::$T = 123_10
+    invokelatest(@eval(() -> $(gen_test_global_operators(QuoteNode(r)))))
+    r = Symbol("g2_$T")
+    @eval global $r::$T = 123_10
+    invokelatest(@eval(r -> $(gen_test_global_operators(:r))), r)
+    nothing
+end
+test_global_operators(Int)
+test_global_operators(Any)
+test_global_operators(Union{Nothing,Int})
+test_global_operators(Complex{Int32})
+test_global_operators(Complex{Int128})
+test_global_operators(PadIntA)
+test_global_operators(PadIntB)
+#FIXME: test_global_operators(Int24)
+test_global_operators(Float64)
+
+function gen_test_global_orderings(@nospecialize r)
+    M = @__MODULE__
+    return quote
+        @nospecialize x y
+        TT = Core.get_binding_type($M, $r)
+
+        @test getglobal($M, $r) === x
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") getglobal($M, $r, :u)
+        @test_throws ConcurrencyViolationError("getglobal: module binding cannot be read non-atomically") getglobal($M, $r, :not_atomic)
+        @test getglobal($M, $r, :unordered) === x
+        @test getglobal($M, $r, :monotonic) === x
+        @test getglobal($M, $r, :acquire) === x
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") getglobal($M, $r, :release) === x
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") getglobal($M, $r, :acquire_release) === x
+        @test getglobal($M, $r, :sequentially_consistent) === x
+        @test isdefined($M, $r)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") isdefined($M, $r, :u)
+        @test_throws ConcurrencyViolationError("isdefined: module binding cannot be accessed non-atomically") isdefined($M, $r, :not_atomic)
+        @test isdefined($M, $r, :unordered)
+        @test isdefined($M, $r, :monotonic)
+        @test isdefined($M, $r, :acquire)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") isdefined($M, $r, :release)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") isdefined($M, $r, :acquire_release)
+        @test isdefined($M, $r, :sequentially_consistent)
+
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobal!($M, $r, y, :u)
+        @test_throws ConcurrencyViolationError("setglobal!: module binding cannot be written non-atomically") setglobal!($M, $r, y, :not_atomic)
+        @test getglobal($M, $r) === x
+        @test setglobal!($M, $r, y) === y
+        @test setglobal!($M, $r, y, :unordered) === y
+        @test setglobal!($M, $r, y, :monotonic) === y
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobal!($M, $r, y, :acquire) === y
+        @test setglobal!($M, $r, y, :release) === y
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobal!($M, $r, y, :acquire_release) === y
+        @test setglobal!($M, $r, y, :sequentially_consistent) === y
+        @test getglobal($M, $r) === y
+
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") swapglobal!($M, $r, x, :u)
+        @test_throws ConcurrencyViolationError("swapglobal!: module binding cannot be written non-atomically") swapglobal!($M, $r, x, :not_atomic)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") swapglobal!($M, $r, x, :unordered) === y
+        @test swapglobal!($M, $r, x, :monotonic) === y
+        @test swapglobal!($M, $r, x, :acquire) === x
+        @test swapglobal!($M, $r, x, :release) === x
+        @test swapglobal!($M, $r, x, :acquire_release) === x
+        @test swapglobal!($M, $r, x, :sequentially_consistent) === x
+        @test swapglobal!($M, $r, x) === x
+
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") modifyglobal!($M, $r, swap, x, :u)
+        @test_throws ConcurrencyViolationError("modifyglobal!: module binding cannot be written non-atomically") modifyglobal!($M, $r, swap, x, :not_atomic)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") modifyglobal!($M, $r, swap, x, :unordered)
+        @test modifyglobal!($M, $r, swap, x, :monotonic) === Pair{TT,TT}(x, x)
+        @test modifyglobal!($M, $r, swap, x, :acquire) === Pair{TT,TT}(x, x)
+        @test modifyglobal!($M, $r, swap, x, :release) === Pair{TT,TT}(x, x)
+        @test modifyglobal!($M, $r, swap, x, :acquire_release) === Pair{TT,TT}(x, x)
+        @test modifyglobal!($M, $r, swap, x, :sequentially_consistent) === Pair{TT,TT}(x, x)
+        @test modifyglobal!($M, $r, swap, x) === Pair{TT,TT}(x, x)
+
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :u, :not_atomic)
+        @test_throws ConcurrencyViolationError("replaceglobal!: module binding cannot be written non-atomically") replaceglobal!($M, $r, y, x, :not_atomic, :not_atomic)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :unordered, :not_atomic)
+        @test_throws ConcurrencyViolationError("replaceglobal!: module binding cannot be accessed non-atomically") replaceglobal!($M, $r, x, x, :monotonic, :not_atomic)
+        @test_throws ConcurrencyViolationError("replaceglobal!: module binding cannot be accessed non-atomically") replaceglobal!($M, $r, x, x, :acquire, :not_atomic)
+        @test_throws ConcurrencyViolationError("replaceglobal!: module binding cannot be accessed non-atomically") replaceglobal!($M, $r, x, x, :release, :not_atomic)
+        @test_throws ConcurrencyViolationError("replaceglobal!: module binding cannot be accessed non-atomically") replaceglobal!($M, $r, x, x, :acquire_release, :not_atomic)
+        @test_throws ConcurrencyViolationError("replaceglobal!: module binding cannot be accessed non-atomically") replaceglobal!($M, $r, x, x, :sequentially_consistent, :not_atomic)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :not_atomic, :u)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :not_atomic, :unordered)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :not_atomic, :monotonic)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :not_atomic, :acquire)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :not_atomic, :release)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :not_atomic, :acquire_release)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") replaceglobal!($M, $r, x, x, :not_atomic, :sequentially_consistent)
+        @test replaceglobal!($M, $r, x, y, :sequentially_consistent, :sequentially_consistent) === ReplaceType{TT}((x, true))
+        @test replaceglobal!($M, $r, x, y, :sequentially_consistent, :sequentially_consistent) === ReplaceType{TT}((y, x === y))
+        @test replaceglobal!($M, $r, y, x, :sequentially_consistent) === ReplaceType{TT}((y, true))
+        @test replaceglobal!($M, $r, x, x) === ReplaceType{TT}((x, true))
+
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r, x, :u, :not_atomic)
+        @test_throws ConcurrencyViolationError("setglobalonce!: module binding cannot be written non-atomically") setglobalonce!($M, $r, y, :not_atomic, :not_atomic)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r,  x, :unordered, :not_atomic)
+        @test_throws ConcurrencyViolationError("setglobalonce!: module binding cannot be accessed non-atomically") setglobalonce!($M, $r, x, :monotonic, :not_atomic)
+        @test_throws ConcurrencyViolationError("setglobalonce!: module binding cannot be accessed non-atomically") setglobalonce!($M, $r, x, :acquire, :not_atomic)
+        @test_throws ConcurrencyViolationError("setglobalonce!: module binding cannot be accessed non-atomically") setglobalonce!($M, $r, x, :release, :not_atomic)
+        @test_throws ConcurrencyViolationError("setglobalonce!: module binding cannot be accessed non-atomically") setglobalonce!($M, $r, x, :acquire_release, :not_atomic)
+        @test_throws ConcurrencyViolationError("setglobalonce!: module binding cannot be accessed non-atomically") setglobalonce!($M, $r, x, :sequentially_consistent, :not_atomic)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r, x, :not_atomic, :u)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r, x, :not_atomic, :unordered)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r, x, :not_atomic, :monotonic)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r, x, :not_atomic, :acquire)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r, x, :not_atomic, :release)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r, x, :not_atomic, :acquire_release)
+        @test_throws ConcurrencyViolationError("invalid atomic ordering") setglobalonce!($M, $r, x, :not_atomic, :sequentially_consistent)
+        @test setglobalonce!($M, $r, x) === false
+        @test setglobalonce!($M, $r, y, :sequentially_consistent, :sequentially_consistent) === false
+        @test setglobalonce!($M, $r, y, :sequentially_consistent, :sequentially_consistent) === false
+        @test setglobalonce!($M, $r, x, :sequentially_consistent) === false
+    end
+end
+@noinline function test_global_orderings(T::Type, x, y)
+    @nospecialize
+    r = Symbol("h1_$T")
+    @eval global $r::$T = $(QuoteNode(x))
+    invokelatest(@eval((x, y) -> $(gen_test_global_orderings(QuoteNode(r)))), x, y)
+    r = Symbol("h2_$T")
+    @eval global $r::$T = $(QuoteNode(x))
+    invokelatest(@eval((r, x, y) -> $(gen_test_global_orderings(:r))), r, x, y)
+    nothing
+end
+test_global_orderings(Int, 10, 20)
+test_global_orderings(Bool, true, false)
+test_global_orderings(String, "hi", "bye")
+test_global_orderings(Symbol, :hi, :bye)
+test_global_orderings(Nothing, nothing, nothing)
+test_global_orderings(Any, 123_10, 123_20)
+test_global_orderings(Any, true, false)
+test_global_orderings(Union{Nothing,Missing}, nothing, missing)
+test_global_orderings(Union{Nothing,Int}, nothing, 123_1)
+test_global_orderings(Complex{Int128}, Complex{Int128}(10, 30), Complex{Int128}(20, 40))
+test_global_orderings(Float64, 10.0, 20.0)
+test_global_orderings(Float64, NaN, Inf)
+
+function gen_test_global_undef(@nospecialize r)
+    M = @__MODULE__
+    return quote
+        TT = Core.get_binding_type($M, $r)
+        x = convert(TT, 12345_10)
+        @test_throws UndefVarError getglobal($M, $r)
+        @test_throws UndefVarError getglobal($M, $r, :sequentially_consistent)
+        @test_throws UndefVarError modifyglobal!($M, $r, add, 1, :sequentially_consistent)
+        @test_throws (TT === Any ? UndefVarError : Union{TypeError,ErrorException}) replaceglobal!($M, $r, 1, 1.0, :sequentially_consistent) # TODO: should this be TypeError or ErrorException
+        @test_throws UndefVarError replaceglobal!($M, $r, 1, x, :sequentially_consistent)
+        @test_throws UndefVarError getglobal($M, $r, :sequentially_consistent)
+        @test_throws UndefVarError swapglobal!($M, $r, x, :sequentially_consistent)
+        @test getglobal($M, $r, :sequentially_consistent) === x === getglobal($M, $r)
+    end
+end
+@noinline function test_global_undef(T)
+    r = Symbol("u1_$T")
+    @eval global $r::$T
+    invokelatest(@eval(() -> $(gen_test_global_undef(QuoteNode(r)))))
+    r = Symbol("u2_$T")
+    @eval global $r::$T
+    invokelatest(@eval(r -> $(gen_test_global_undef(:r))), r)
+    nothing
+end
+test_global_undef(BigInt)
+test_global_undef(Any)
+test_global_undef(Union{Nothing,Integer})
+test_global_undef(UndefComplex{Any})
+test_global_undef(UndefComplex{UndefComplex{Any}})
+test_global_undef(Int)
+
+function gen_test_globalonce(@nospecialize r)
+    M = @__MODULE__
+    return quote
+        TT = Core.get_binding_type($M, $r)
+        x = convert(TT, 12345_10)
+        @test_throws UndefVarError getglobal($M, $r)
+        @test setglobalonce!($M, $r, x, :sequentially_consistent) === true
+        @test getglobal($M, $r, :sequentially_consistent) === x
+        @test setglobalonce!($M, $r, convert(TT, 12345_20), :sequentially_consistent) === false
+    end
+end
+@noinline function test_globalonce(T)
+    r = Symbol("o1_$T")
+    @eval global $r::$T
+    invokelatest(@eval(() -> $(gen_test_globalonce(QuoteNode(r)))))
+    r = Symbol("o2_$T")
+    @eval global $r::$T
+    invokelatest(@eval(r -> $(gen_test_globalonce(:r))), r)
+    nothing
+end
+test_globalonce(BigInt)
+test_globalonce(Any)
+test_globalonce(Union{Nothing,Integer})
+test_globalonce(UndefComplex{Any})
+test_globalonce(UndefComplex{UndefComplex{Any}})
+test_globalonce(Int)
+
+# test macroexpansions
+global x::Int
+let a = @__MODULE__
+    @test_throws ConcurrencyViolationError @atomiconce :not_atomic a.x = 2
+    @test true === @atomiconce a.x = 1
+    @test 1 === @atomic a.x
+    @test false === @atomiconce a.x = 2
+end
+let a = @__MODULE__
+    @test 1 === @atomic a.x
+    @test 2 === @atomic :sequentially_consistent a.x = 2
+    @test 3 === @atomic :monotonic a.x = 3
+    local four = 4
+    @test 4 === @atomic :monotonic a.x = four
+    @test 3 === @atomic :monotonic a.x = four - 1
+    @test_throws ConcurrencyViolationError @atomic :not_atomic a.x = 2
+    @test_throws ConcurrencyViolationError @atomic :not_atomic a.x
+    @test_throws ConcurrencyViolationError @atomic :not_atomic a.x += 1
+
+    @test 3 === @atomic :monotonic a.x
+    @test 5 === @atomic a.x += 2
+    @test 4 === @atomic :monotonic a.x -= 1
+    @test 12 === @atomic :monotonic a.x *= 3
+
+    @test 12 === @atomic a.x
+    @test (12 => 13) === @atomic a.x + 1
+    @test (13 => 15) === @atomic :monotonic a.x + 2
+    @test (15 => 19) === @atomic a.x max 19
+    @test (19 => 20) === @atomic :monotonic a.x max 20
+    @test_throws ConcurrencyViolationError @atomic :not_atomic a.x + 1
+    @test_throws ConcurrencyViolationError @atomic :not_atomic a.x max 30
+
+    @test 20 === @atomic a.x
+    @test 20 === @atomicswap a.x = 1
+    @test 1 === @atomicswap :monotonic a.x = 2
+    @test_throws ConcurrencyViolationError @atomicswap :not_atomic a.x = 1
+
+    @test 2 === @atomic a.x
+    @test ReplaceType{Int}((2, true)) === @atomicreplace a.x 2 => 1
+    @test ReplaceType{Int}((1, false)) === @atomicreplace :monotonic a.x 2 => 1
+    @test ReplaceType{Int}((1, false)) === @atomicreplace :monotonic :monotonic a.x 2 => 1
+    @test_throws ConcurrencyViolationError @atomicreplace :not_atomic a.x 1 => 2
+    @test_throws ConcurrencyViolationError @atomicreplace :monotonic :acquire a.x 1 => 2
+
+    @test 1 === @atomic a.x
+    xchg = 1 => 2
+    @test ReplaceType{Int}((1, true)) === @atomicreplace a.x xchg
+    @test ReplaceType{Int}((2, false)) === @atomicreplace :monotonic a.x xchg
+    @test ReplaceType{Int}((2, false)) === @atomicreplace :acquire_release :monotonic a.x xchg
+    @test_throws ConcurrencyViolationError @atomicreplace :not_atomic a.x xchg
+    @test_throws ConcurrencyViolationError @atomicreplace :monotonic :acquire a.x xchg
+end
+
+## Memory
+
+using InteractiveUtils
+using Core: memoryrefget, memoryrefset!, memoryrefswap!, memoryrefreplace!, memoryrefmodify!, memoryrefsetonce!, memoryref_isassigned
+
+@noinline function _test_memory_operators(r)
+    r = r[]
+    TT = eltype(r)
+    T = typeof(r[])
+    @test memoryrefget(r, :sequentially_consistent, true) === T(123_10)
+    @test memoryrefset!(r, T(123_1), :sequentially_consistent, true) === T(123_1)
+    @test memoryrefget(r, :sequentially_consistent, true) === T(123_1)
+    @test memoryrefreplace!(r, 123_1 % UInt, T(123_30), :sequentially_consistent, :sequentially_consistent, true) === ReplaceType{TT}((T(123_1), false))
+    @test memoryrefreplace!(r, T(123_1), T(123_30), :sequentially_consistent, :sequentially_consistent, true) === ReplaceType{TT}((T(123_1), true))
+    @test memoryrefget(r, :sequentially_consistent, true) === T(123_30)
+    @test memoryrefreplace!(r, T(123_1), T(123_1), :sequentially_consistent, :sequentially_consistent, true) === ReplaceType{TT}((T(123_30), false))
+    @test memoryrefget(r, :sequentially_consistent, true) === T(123_30)
+    @test memoryrefmodify!(r, add, 1, :sequentially_consistent, true) === Pair{TT,TT}(T(123_30), T(123_31))
+    @test memoryrefmodify!(r, add, 1, :sequentially_consistent, true) === Pair{TT,TT}(T(123_31), T(123_32))
+    @test memoryrefget(r, :sequentially_consistent, true) === T(123_32)
+    @test memoryrefswap!(r, T(123_1), :sequentially_consistent, true) === T(123_32)
+    @test memoryrefget(r, :sequentially_consistent, true) === T(123_1)
+    nothing
+end
+@noinline function test_memory_operators(T::Type)
+    x = convert(T, 123_10)
+    r = GenericMemoryRef(AtomicMemory{T}(undef, 1))
+    memoryrefset!(r, x, :unordered, true) # @atomic r[] = x
+    _test_memory_operators(Ref(r))
+    r = GenericMemoryRef(AtomicMemory{T}(undef, 1))
+    memoryrefset!(r, x, :unordered, true) # @atomic r[] = x
+    _test_memory_operators(Ref{Any}(r))
+    nothing
+end
+test_memory_operators(Int)
+test_memory_operators(Any)
+test_memory_operators(Union{Nothing,Int})
+test_memory_operators(Complex{Int32})
+test_memory_operators(Complex{Int128})
+test_memory_operators(PadIntA)
+test_memory_operators(PadIntB)
+#FIXME: test_memory_operators(Int24)
+test_memory_operators(Float64)
+
+@noinline function _test_memory_orderings(xr, yr, x, y)
+    @nospecialize x y
+    xr = xr[]
+    yr = yr[]
+    TT = eltype(yr)
+    @test TT == eltype(xr)
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefget(xr, :u, true)
+    @test_throws ConcurrencyViolationError("memoryrefget: atomic memory cannot be accessed non-atomically") memoryrefget(xr, :not_atomic, true)
+    @test memoryrefget(xr, :unordered, true) === x
+    @test memoryrefget(xr, :monotonic, true) === x
+    @test memoryrefget(xr, :acquire, true) === x
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefget(xr, :release, true) === x
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefget(xr, :acquire_release, true) === x
+    @test memoryrefget(xr, :sequentially_consistent, true) === x
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryref_isassigned(xr, :u, true)
+    @test_throws ConcurrencyViolationError("memoryref_isassigned: atomic memory cannot be accessed non-atomically") memoryref_isassigned(xr, :not_atomic, true)
+    @test memoryref_isassigned(xr, :unordered, true)
+    @test memoryref_isassigned(xr, :monotonic, true)
+    @test memoryref_isassigned(xr, :acquire, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryref_isassigned(xr, :release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryref_isassigned(xr, :acquire_release, true)
+    @test memoryref_isassigned(xr, :sequentially_consistent, true)
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefget(yr, :u, true)
+    @test memoryrefget(yr, :not_atomic, true) === y
+    @test_throws ConcurrencyViolationError("memoryrefget: non-atomic memory cannot be accessed atomically") memoryrefget(yr, :unordered, true)
+    @test_throws ConcurrencyViolationError("memoryrefget: non-atomic memory cannot be accessed atomically") memoryrefget(yr, :monotonic, true)
+    @test_throws ConcurrencyViolationError("memoryrefget: non-atomic memory cannot be accessed atomically") memoryrefget(yr, :acquire, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefget(yr, :release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefget(yr, :acquire_release, true)
+    @test_throws ConcurrencyViolationError("memoryrefget: non-atomic memory cannot be accessed atomically") memoryrefget(yr, :sequentially_consistent, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryref_isassigned(yr, :u, true)
+    @test memoryref_isassigned(yr, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryref_isassigned: non-atomic memory cannot be accessed atomically") memoryref_isassigned(yr, :unordered, true)
+    @test_throws ConcurrencyViolationError("memoryref_isassigned: non-atomic memory cannot be accessed atomically") memoryref_isassigned(yr, :monotonic, true)
+    @test_throws ConcurrencyViolationError("memoryref_isassigned: non-atomic memory cannot be accessed atomically") memoryref_isassigned(yr, :acquire, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryref_isassigned(yr, :release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryref_isassigned(yr, :acquire_release, true)
+    @test_throws ConcurrencyViolationError("memoryref_isassigned: non-atomic memory cannot be accessed atomically") memoryref_isassigned(yr, :sequentially_consistent, true)
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefset!(xr, y, :u, true)
+    @test_throws ConcurrencyViolationError("memoryrefset!: atomic memory cannot be written non-atomically") memoryrefset!(xr, y, :not_atomic, true)
+    @test memoryrefget(xr, :unordered, true) === x
+    @test memoryrefset!(xr, y, :unordered, true) === y
+    @test memoryrefset!(xr, y, :monotonic, true) === y
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefset!(xr, y, :acquire, true) === y
+    @test memoryrefset!(xr, y, :release, true) === y
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefset!(xr, y, :acquire_release, true) === y
+    @test memoryrefset!(xr, y, :sequentially_consistent, true) === y
+    @test memoryrefget(xr, :unordered, true) === y
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefset!(yr, x, :u, true)
+    @test_throws ConcurrencyViolationError("memoryrefset!: non-atomic memory cannot be written atomically") memoryrefset!(yr, x, :unordered, true)
+    @test_throws ConcurrencyViolationError("memoryrefset!: non-atomic memory cannot be written atomically") memoryrefset!(yr, x, :monotonic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefset!(yr, x, :acquire, true)
+    @test_throws ConcurrencyViolationError("memoryrefset!: non-atomic memory cannot be written atomically") memoryrefset!(yr, x, :release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefset!(yr, x, :acquire_release, true)
+    @test_throws ConcurrencyViolationError("memoryrefset!: non-atomic memory cannot be written atomically") memoryrefset!(yr, x, :sequentially_consistent, true)
+    @test memoryrefget(yr, :not_atomic, true) === y
+    @test memoryrefset!(yr, x, :not_atomic, true) === x
+    @test memoryrefset!(yr, x, :not_atomic, true) === x
+    @test memoryrefget(yr, :not_atomic, true) === x
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefswap!(yr, y, :u, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefswap!(yr, y, :unordered, true)
+    @test_throws ConcurrencyViolationError("memoryrefswap!: non-atomic memory cannot be written atomically") memoryrefswap!(yr, y, :monotonic, true)
+    @test_throws ConcurrencyViolationError("memoryrefswap!: non-atomic memory cannot be written atomically") memoryrefswap!(yr, y, :acquire, true)
+    @test_throws ConcurrencyViolationError("memoryrefswap!: non-atomic memory cannot be written atomically") memoryrefswap!(yr, y, :release, true)
+    @test_throws ConcurrencyViolationError("memoryrefswap!: non-atomic memory cannot be written atomically") memoryrefswap!(yr, y, :acquire_release, true)
+    @test_throws ConcurrencyViolationError("memoryrefswap!: non-atomic memory cannot be written atomically") memoryrefswap!(yr, y, :sequentially_consistent, true)
+    @test memoryrefswap!(yr, y, :not_atomic, true) === x
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefmodify!(yr, swap, y, :u, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefmodify!(yr, swap, y, :unordered, true)
+    @test_throws ConcurrencyViolationError("memoryrefmodify!: non-atomic memory cannot be written atomically") memoryrefmodify!(yr, swap, y, :monotonic, true)
+    @test_throws ConcurrencyViolationError("memoryrefmodify!: non-atomic memory cannot be written atomically") memoryrefmodify!(yr, swap, y, :acquire, true)
+    @test_throws ConcurrencyViolationError("memoryrefmodify!: non-atomic memory cannot be written atomically") memoryrefmodify!(yr, swap, y, :release, true)
+    @test_throws ConcurrencyViolationError("memoryrefmodify!: non-atomic memory cannot be written atomically") memoryrefmodify!(yr, swap, y, :acquire_release, true)
+    @test_throws ConcurrencyViolationError("memoryrefmodify!: non-atomic memory cannot be written atomically") memoryrefmodify!(yr, swap, y, :sequentially_consistent, true)
+    @test memoryrefmodify!(yr, swap, x, :not_atomic, true) === Pair{TT,TT}(y, x)
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :u, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :unordered, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: non-atomic memory cannot be written atomically") memoryrefreplace!(yr, y, y, :monotonic, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: non-atomic memory cannot be written atomically") memoryrefreplace!(yr, y, y, :acquire, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: non-atomic memory cannot be written atomically") memoryrefreplace!(yr, y, y, :release, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: non-atomic memory cannot be written atomically") memoryrefreplace!(yr, y, y, :acquire_release, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: non-atomic memory cannot be written atomically") memoryrefreplace!(yr, y, y, :sequentially_consistent, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :not_atomic, :u, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :not_atomic, :unordered, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :not_atomic, :monotonic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :not_atomic, :acquire, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :not_atomic, :release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :not_atomic, :acquire_release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(yr, y, y, :not_atomic, :sequentially_consistent, true)
+    @test memoryrefreplace!(yr, x, y, :not_atomic, :not_atomic, true) === ReplaceType{TT}((x, true))
+    @test memoryrefreplace!(yr, x, y, :not_atomic, :not_atomic, true) === ReplaceType{TT}((y, x === y))
+    @test memoryrefreplace!(yr, y, y, :not_atomic, :not_atomic, true) === ReplaceType{TT}((y, true))
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefswap!(xr, x, :u, true)
+    @test_throws ConcurrencyViolationError("memoryrefswap!: atomic memory cannot be written non-atomically") memoryrefswap!(xr, x, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefswap!(xr, x, :unordered, true) === y
+    @test memoryrefswap!(xr, x, :monotonic, true) === y
+    @test memoryrefswap!(xr, x, :acquire, true) === x
+    @test memoryrefswap!(xr, x, :release, true) === x
+    @test memoryrefswap!(xr, x, :acquire_release, true) === x
+    @test memoryrefswap!(xr, x, :sequentially_consistent, true) === x
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefmodify!(xr, swap, x, :u, true)
+    @test_throws ConcurrencyViolationError("memoryrefmodify!: atomic memory cannot be written non-atomically") memoryrefmodify!(xr, swap, x, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefmodify!(xr, swap, x, :unordered, true)
+    @test memoryrefmodify!(xr, swap, x, :monotonic, true) === Pair{TT,TT}(x, x)
+    @test memoryrefmodify!(xr, swap, x, :acquire, true) === Pair{TT,TT}(x, x)
+    @test memoryrefmodify!(xr, swap, x, :release, true) === Pair{TT,TT}(x, x)
+    @test memoryrefmodify!(xr, swap, x, :acquire_release, true) === Pair{TT,TT}(x, x)
+    @test memoryrefmodify!(xr, swap, x, :sequentially_consistent, true) === Pair{TT,TT}(x, x)
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :u, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: atomic memory cannot be written non-atomically") memoryrefreplace!(xr, y, x, :not_atomic, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :unordered, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: atomic memory cannot be accessed non-atomically") memoryrefreplace!(xr, x, x, :monotonic, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: atomic memory cannot be accessed non-atomically") memoryrefreplace!(xr, x, x, :acquire, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: atomic memory cannot be accessed non-atomically") memoryrefreplace!(xr, x, x, :release, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: atomic memory cannot be accessed non-atomically") memoryrefreplace!(xr, x, x, :acquire_release, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefreplace!: atomic memory cannot be accessed non-atomically") memoryrefreplace!(xr, x, x, :sequentially_consistent, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :not_atomic, :u, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :not_atomic, :unordered, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :not_atomic, :monotonic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :not_atomic, :acquire, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :not_atomic, :release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :not_atomic, :acquire_release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefreplace!(xr, x, x, :not_atomic, :sequentially_consistent, true)
+    @test memoryrefreplace!(xr, x, y, :sequentially_consistent, :sequentially_consistent, true) === ReplaceType{TT}((x, true))
+    @test memoryrefreplace!(xr, x, y, :sequentially_consistent, :sequentially_consistent, true) === ReplaceType{TT}((y, x === y))
+    @test memoryrefreplace!(xr, y, x, :sequentially_consistent, :sequentially_consistent, true) === ReplaceType{TT}((y, true))
+
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr, x, :u, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefsetonce!: atomic memory cannot be written non-atomically") memoryrefsetonce!(xr, y, :not_atomic, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr,  x, :unordered, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefsetonce!: atomic memory cannot be accessed non-atomically") memoryrefsetonce!(xr, x, :monotonic, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefsetonce!: atomic memory cannot be accessed non-atomically") memoryrefsetonce!(xr, x, :acquire, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefsetonce!: atomic memory cannot be accessed non-atomically") memoryrefsetonce!(xr, x, :release, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefsetonce!: atomic memory cannot be accessed non-atomically") memoryrefsetonce!(xr, x, :acquire_release, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("memoryrefsetonce!: atomic memory cannot be accessed non-atomically") memoryrefsetonce!(xr, x, :sequentially_consistent, :not_atomic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr, x, :not_atomic, :u, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr, x, :not_atomic, :unordered, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr, x, :not_atomic, :monotonic, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr, x, :not_atomic, :acquire, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr, x, :not_atomic, :release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr, x, :not_atomic, :acquire_release, true)
+    @test_throws ConcurrencyViolationError("invalid atomic ordering") memoryrefsetonce!(xr, x, :not_atomic, :sequentially_consistent, true)
+    @test memoryrefsetonce!(xr, y, :sequentially_consistent, :sequentially_consistent, true) === false
+    @test memoryrefsetonce!(xr, y, :sequentially_consistent, :sequentially_consistent, true) === false
+    @test memoryrefsetonce!(xr, x, :sequentially_consistent, :sequentially_consistent, true) === false
+    nothing
+end
+@noinline function test_memory_orderings(T::Type, x, y)
+    @nospecialize
+    xr = GenericMemoryRef(AtomicMemory{T}(undef, 1))
+    memoryrefset!(xr, x, :unordered, true) # @atomic xr[] = x
+    yr = GenericMemoryRef(Memory{T}(undef, 1))
+    yr[] = y
+    _test_memory_orderings(Ref(xr), Ref(yr), x, y)
+    xr = GenericMemoryRef(AtomicMemory{T}(undef, 1))
+    memoryrefset!(xr, x, :unordered, true) # @atomic xr[] = x
+    yr = GenericMemoryRef(Memory{T}(undef, 1))
+    yr[] = y
+    _test_memory_orderings(Ref{Any}(xr), Ref{Any}(yr), x, y)
+    nothing
+end
+@noinline test_memory_orderings(x, y) = (@nospecialize; test_memory_orderings(typeof(x), x, y))
+test_memory_orderings(10, 20)
+test_memory_orderings(true, false)
+test_memory_orderings("hi", "bye")
+test_memory_orderings(:hi, :bye)
+test_memory_orderings(nothing, nothing)
+test_memory_orderings(Any, 123_10, 123_20)
+test_memory_orderings(Any, true, false)
+test_memory_orderings(Union{Nothing,Missing}, nothing, missing)
+test_memory_orderings(Union{Nothing,Int}, nothing, 123_1)
+test_memory_orderings(Complex{Int128}(10, 30), Complex{Int128}(20, 40))
+test_memory_orderings(10.0, 20.0)
+test_memory_orderings(NaN, Inf)
+
+@noinline function _test_memory_undef(r)
+    r = r[]
+    TT = eltype(r)
+    x = convert(TT, 12345_10)
+    @test_throws UndefRefError memoryrefget(r, :sequentially_consistent, true)
+    @test_throws UndefRefError memoryrefmodify!(r, add, 1, :sequentially_consistent, true)
+    @test_throws (TT === Any ? UndefRefError : TypeError) memoryrefreplace!(r, 1, 1.0, :sequentially_consistent, :sequentially_consistent, true)
+    @test_throws UndefRefError memoryrefreplace!(r, 1, x, :sequentially_consistent, :sequentially_consistent, true)
+    @test_throws UndefRefError memoryrefget(r, :sequentially_consistent, true)
+    @test_throws UndefRefError memoryrefswap!(r, x, :sequentially_consistent, true)
+    @test memoryrefget(r, :sequentially_consistent, true) === x
+    nothing
+end
+@noinline function test_memory_undef(T)
+    r = GenericMemoryRef(AtomicMemory{T}(undef, 1))
+    _test_memory_undef(Ref(r))
+    r = GenericMemoryRef(AtomicMemory{T}(undef, 1))
+    _test_memory_undef(Ref{Any}(r))
+    nothing
+end
+test_memory_undef(BigInt)
+test_memory_undef(Any)
+test_memory_undef(Union{Nothing,Integer})
+test_memory_undef(UndefComplex{Any})
+test_memory_undef(UndefComplex{UndefComplex{Any}})
+
+@noinline function _test_once_undef(r)
+    r = r[]
+    TT = eltype(r)
+    x = convert(TT, 12345_10)
+    @test_throws UndefRefError memoryrefget(r, :sequentially_consistent, true)
+    @test memoryrefsetonce!(r, x, :sequentially_consistent, :sequentially_consistent, true) === true
+    @test memoryrefget(r, :sequentially_consistent, true) === x
+    @test memoryrefsetonce!(r, convert(TT, 12345_20), :sequentially_consistent, :sequentially_consistent, true) === false
+    nothing
+end
+@noinline function test_once_undef(T)
+    r = GenericMemoryRef(AtomicMemory{T}(undef, 1))
+    _test_once_undef(Ref(r))
+    r = GenericMemoryRef(AtomicMemory{T}(undef, 1))
+    _test_once_undef(Ref{Any}(r))
+    nothing
+end
+test_once_undef(BigInt)
+test_once_undef(Any)
+test_once_undef(Union{Nothing,Integer})
+test_once_undef(UndefComplex{Any})
+test_once_undef(UndefComplex{UndefComplex{Any}})
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index 71eb50cd42760..f5ecb8a0d347c 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -446,7 +446,7 @@ let effects = Base.infer_effects() do
     end
     @test !Core.Compiler.is_nothrow(effects)
 end
-@test_throws ErrorException setglobal!_nothrow_undefinedyet()
+@test_throws Union{ErrorException,TypeError} setglobal!_nothrow_undefinedyet() # TODO: what kind of error should this be?
 
 # Nothrow for setfield!
 mutable struct SetfieldNothrow
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 0d46ed1319ae5..65729ab01cb9f 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -1627,24 +1627,24 @@ let memoryref_tfunc(@nospecialize xs...) = Core.Compiler.memoryref_tfunc(Core.Co
     @test memoryref_isassigned_tfunc(Any, Any, Any) === Bool
     @test builtin_tfunction(Core.memoryref_isassigned, Any[MemoryRef{Int}, Vararg{Any}]) == Bool
     @test builtin_tfunction(Core.memoryref_isassigned, Any[MemoryRef{Int}, Symbol, Bool, Vararg{Bool}]) == Bool
-    @test memoryrefset!_tfunc(MemoryRef{Int}, Int, Symbol, Bool) === MemoryRef{Int}
+    @test memoryrefset!_tfunc(MemoryRef{Int}, Int, Symbol, Bool) === Int
     let ua = MemoryRef{<:Integer}
-        @test memoryrefset!_tfunc(ua, Int, Symbol, Bool) === ua
+        @test memoryrefset!_tfunc(ua, Int, Symbol, Bool) === Int
     end
-    @test memoryrefset!_tfunc(GenericMemoryRef, Int, Symbol, Bool) === GenericMemoryRef
-    @test memoryrefset!_tfunc(GenericMemoryRef{:not_atomic}, Int, Symbol, Bool) === GenericMemoryRef{:not_atomic}
-    @test memoryrefset!_tfunc(Any, Int, Symbol, Bool) === Any
+    @test memoryrefset!_tfunc(GenericMemoryRef, Int, Symbol, Bool) === Int
+    @test memoryrefset!_tfunc(GenericMemoryRef{:not_atomic}, Int, Symbol, Bool) === Int
+    @test memoryrefset!_tfunc(Any, Int, Symbol, Bool) === Int
     @test memoryrefset!_tfunc(MemoryRef{String}, Int, Symbol, Bool) === Union{}
     @test memoryrefset!_tfunc(String, Char, Symbol, Bool) === Union{}
-    @test memoryrefset!_tfunc(MemoryRef{Int}, Any, Symbol, Bool) === MemoryRef{Int}
-    @test memoryrefset!_tfunc(MemoryRef{Int}, Any, Any, Any) === MemoryRef{Int}
-    @test memoryrefset!_tfunc(GenericMemoryRef{:not_atomic}, Any, Any, Any) === GenericMemoryRef{:not_atomic}
-    @test memoryrefset!_tfunc(GenericMemoryRef, Any, Any, Any) === GenericMemoryRef
-    @test memoryrefset!_tfunc(Any, Any, Any, Any) === Any # also probably could be GenericMemoryRef
-    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Vararg{Any}]) == MemoryRef{Int}
+    @test memoryrefset!_tfunc(MemoryRef{Int}, Any, Symbol, Bool) === Any # could improve this to Int
+    @test memoryrefset!_tfunc(MemoryRef{Int}, Any, Any, Any) === Any # could improve this to Int
+    @test memoryrefset!_tfunc(GenericMemoryRef{:not_atomic}, Any, Any, Any) === Any
+    @test memoryrefset!_tfunc(GenericMemoryRef, Any, Any, Any) === Any
+    @test memoryrefset!_tfunc(Any, Any, Any, Any) === Any
+    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Vararg{Any}]) == Any
     @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Vararg{Symbol}]) == Union{}
-    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Any, Symbol, Vararg{Bool}]) == MemoryRef{Int}
-    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Any, Symbol, Bool, Vararg{Any}]) == MemoryRef{Int}
+    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Any, Symbol, Vararg{Bool}]) === Any # could improve this to Int
+    @test builtin_tfunction(Core.memoryrefset!, Any[MemoryRef{Int}, Any, Symbol, Bool, Vararg{Any}]) === Any # could improve this to Int
     @test memoryrefoffset_tfunc(MemoryRef) == memoryrefoffset_tfunc(GenericMemoryRef) == Int
     @test memoryrefoffset_tfunc(Memory) == memoryrefoffset_tfunc(GenericMemory) == Union{}
     @test builtin_tfunction(Core.memoryrefoffset, Any[Vararg{MemoryRef}]) == Int
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 0ef7f6def1057..71331fd30fb3a 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -1793,6 +1793,24 @@ let src = code_typed1((Atomic{Int},Union{Int,Float64})) do a, b
     end
     @test count(isinvokemodify(:mymax), src.code) == 2
 end
+global x_global_inc::Int = 1
+let src = code_typed1(()) do
+        @atomic (@__MODULE__).x_global_inc += 1
+    end
+    @test count(isinvokemodify(:+), src.code) == 1
+end
+let src = code_typed1((Ptr{Int},)) do a
+        unsafe_modify!(a, +, 1)
+    end
+    @test count(isinvokemodify(:+), src.code) == 1
+end
+let src = code_typed1((AtomicMemoryRef{Int},)) do a
+        Core.memoryrefmodify!(a, +, 1, :sequentially_consistent, true)
+    end
+    @test count(isinvokemodify(:+), src.code) == 1
+end
+
+
 
 # apply `ssa_inlining_pass` multiple times
 let interp = Core.Compiler.NativeInterpreter()

From 37a0e65da2a572d2299979a07c46120271e1d475 Mon Sep 17 00:00:00 2001
From: Paul Berg <paul@plutojl.org>
Date: Mon, 5 Feb 2024 02:01:31 +0100
Subject: [PATCH 0799/1315] Do not resolve binding `Module` in Main during
 sysimg generation (#53162)

Currently, the use of `Module` in the precompilation scripts makes the
Module binding automatically resolved in Main because it is embedded in
the sysimage. This prevents users from using the name Module for their
own variables in Main.
---
 base/sysimg.jl                 | 2 +-
 contrib/generate_precompile.jl | 2 +-
 test/core.jl                   | 4 ++++
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/base/sysimg.jl b/base/sysimg.jl
index 4ae876a929f0e..62241de9ffd4a 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -90,7 +90,7 @@ let
     tot_time_stdlib = 0.0
     # use a temp module to avoid leaving the type of this closure in Main
     push!(empty!(LOAD_PATH), "@stdlib")
-    m = Module()
+    m = Core.Module()
     GC.@preserve m begin
         print_time = @eval m (mod, t) -> (print(rpad(string(mod) * "  ", $maxlen + 3, "─"));
                                           Base.time_print(stdout, t * 10^9); println())
diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index 956b3b38a0e72..57af6c1f32679 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Prevent this from putting anything into the Main namespace
-@eval Module() begin
+@eval Core.Module() begin
 
 if Threads.maxthreadid() != 1
     @warn "Running this file with multiple Julia threads may lead to a build error" Threads.maxthreadid()
diff --git a/test/core.jl b/test/core.jl
index ba42687acd0d0..a2c3b3cff9e6b 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -1180,6 +1180,10 @@ let A = [1]
     @test x == 1
 end
 
+# Make sure that `Module` is not resolved to `Core.Module` during sysimg generation
+# so that users can define their own binding named `Module` in Main.
+@test !Base.isbindingresolved(Main, :Module)
+
 # Module() constructor
 @test names(Module(:anonymous), all = true, imported = true) == [:anonymous]
 @test names(Module(:anonymous, false), all = true, imported = true) == [:anonymous]

From d91a7fa7a10473a61607e14a1f801d0aae4bfdb4 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 4 Feb 2024 20:03:52 -0500
Subject: [PATCH 0800/1315] further improve clarity of MethodError printing
 (#53164)

Distinguish some of the cases of manually thrown MethodError by looking
for a method in the specified world. Also refactor some of the kwcall
handling to be closer to supporting `invoke`d calls (although it does
not guaranteed to have a value for `f`, which is often required later).

Fixes #36182
---
 base/errorshow.jl | 38 ++++++++++++++++++++++++++------------
 test/errorshow.jl | 29 ++++++++++++++++++++++++-----
 2 files changed, 50 insertions(+), 17 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index c08e75029afab..74afc191fcc4d 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -244,6 +244,7 @@ function show_convert_error(io::IO, ex::MethodError, arg_types_param)
 end
 
 function showerror(io::IO, ex::MethodError)
+    @nospecialize io
     # ex.args is a tuple type if it was thrown from `invoke` and is
     # a tuple of the arguments otherwise.
     is_arg_types = !isa(ex.args, Tuple)
@@ -258,15 +259,22 @@ function showerror(io::IO, ex::MethodError)
     print(io, "MethodError: ")
     ft = typeof(f)
     f_is_function = false
-    kwargs = ()
-    if f === Core.kwcall && !is_arg_types
-        f = (ex.args::Tuple)[2]
-        ft = typeof(f)
+    kwargs = []
+    if f === Core.kwcall && length(arg_types_param) >= 2 && arg_types_param[1] <: NamedTuple && !is_arg_types
+        # if this is a kwcall, reformat it as a call with kwargs
+        # TODO: handle !is_arg_types here (aka invoke with kwargs), which needs a value for `f`
+        local kwt
+        let args = ex.args::Tuple
+            f = args[2]
+            ft = typeof(f)
+            kwt = typeof(args[1])
+            ex = MethodError(f, args[3:end], ex.world)
+        end
         arg_types_param = arg_types_param[3:end]
         san_arg_types_param = san_arg_types_param[3:end]
-        kwargs = pairs(ex.args[1])
-        ex = MethodError(f, ex.args[3:end::Int], ex.world)
-        arg_types = Tuple{arg_types_param...}
+        keys = kwt.parameters[1]::Tuple
+        kwargs = Any[(keys[i], fieldtype(kwt, i)) for i in 1:length(keys)]
+        arg_types = rewrap_unionall(Tuple{arg_types_param...}, arg_types)
     end
     if f === Base.convert && length(arg_types_param) == 2 && !is_arg_types
         f_is_function = true
@@ -286,8 +294,8 @@ function showerror(io::IO, ex::MethodError)
         end
         buf = IOBuffer()
         iob = IOContext(buf, io)     # for type abbreviation as in #49795; some, like `convert(T, x)`, should not abbreviate
-        show_signature_function(iob, isa(f, Type) ? Type{f} : typeof(f))
-        show_tuple_as_call(iob, :function, arg_types; hasfirst=false, kwargs = !isempty(kwargs) ? Any[(k, typeof(v)) for (k, v) in kwargs] : nothing)
+        show_signature_function(iob, Core.Typeof(f))
+        show_tuple_as_call(iob, :function, arg_types; hasfirst=false, kwargs = isempty(kwargs) ? nothing : kwargs)
         str = String(take!(buf))
         str = type_limited_string_from_context(io, str)
         print(io, str)
@@ -318,8 +326,13 @@ function showerror(io::IO, ex::MethodError)
             end
         end
     end
-    if (ex.world != typemax(UInt) && hasmethod(f, arg_types) &&
-        !hasmethod(f, arg_types, world = ex.world))
+    if ex.world == typemax(UInt) || hasmethod(f, arg_types, world=ex.world)
+        if ex.world == typemax(UInt) || isempty(kwargs)
+            print(io, "\nThis error has been manually thrown, explicitly, so the method may exist but be intentionally marked as unimplemented.")
+        else
+            print(io, "\nThis method may not support any kwargs.")
+        end
+    elseif hasmethod(f, arg_types) && !hasmethod(f, arg_types, world=ex.world)
         curworld = get_world_counter()
         print(io, "\nThe applicable method may be too new: running in world age $(ex.world), while current world is $(curworld).")
     elseif f isa Function
@@ -398,7 +411,8 @@ stacktrace_expand_basepaths()::Bool = Base.get_bool_env("JULIA_STACKTRACE_EXPAND
 stacktrace_contract_userdir()::Bool = Base.get_bool_env("JULIA_STACKTRACE_CONTRACT_HOMEDIR", true) === true
 stacktrace_linebreaks()::Bool = Base.get_bool_env("JULIA_STACKTRACE_LINEBREAKS", false) === true
 
-function show_method_candidates(io::IO, ex::MethodError, @nospecialize kwargs=())
+function show_method_candidates(io::IO, ex::MethodError, kwargs=[])
+    @nospecialize io
     is_arg_types = !isa(ex.args, Tuple)
     arg_types = is_arg_types ? ex.args : typesof(ex.args...)
     arg_types_param = Any[(unwrap_unionall(arg_types)::DataType).parameters...]
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 84d55fcb80de1..a12224554fd11 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -586,12 +586,12 @@ module EnclosingModule
     abstract type AbstractTypeNoConstructors end
 end
 let
-    method_error = MethodError(EnclosingModule.AbstractTypeNoConstructors, ())
+    method_error = MethodError(EnclosingModule.AbstractTypeNoConstructors, (), Base.get_world_counter())
 
     # Test that it shows a special message when no constructors have been defined by the user.
-    @test sprint(showerror, method_error) ==
+    @test startswith(sprint(showerror, method_error),
         """MethodError: no constructors have been defined for $(EnclosingModule.AbstractTypeNoConstructors)
-           The type `$(EnclosingModule.AbstractTypeNoConstructors)` exists, but no method is defined for this combination of argument types when trying to construct it."""
+           The type `$(EnclosingModule.AbstractTypeNoConstructors)` exists, but no method is defined for this combination of argument types when trying to construct it.""")
 
     # Does it go back to previous behaviour when there *is* at least
     # one constructor defined?
@@ -650,6 +650,24 @@ end
         @test startswith(str, "MethodError: no method matching f21006(::Tuple{})")
         @test !occursin("The applicable method may be too new", str)
     end
+
+    str = sprint(Base.showerror, MethodError(+, (1.0, 2.0)))
+    @test startswith(str, "MethodError: no method matching +(::Float64, ::Float64)")
+    @test occursin("This error has been manually thrown, explicitly", str)
+
+    str = sprint(Base.showerror, MethodError(+, (1.0, 2.0), Base.get_world_counter()))
+    @test startswith(str, "MethodError: no method matching +(::Float64, ::Float64)")
+    @test occursin("This error has been manually thrown, explicitly", str)
+
+    str = sprint(Base.showerror, MethodError(Core.kwcall, ((; a=3.0), +, 1.0, 2.0)))
+    @test startswith(str, "MethodError: no method matching +(::Float64, ::Float64; a::Float64)")
+    @test occursin("This error has been manually thrown, explicitly", str)
+
+    str = sprint(Base.showerror, MethodError(Core.kwcall, ((; a=3.0), +, 1.0, 2.0), Base.get_world_counter()))
+    @test startswith(str, "MethodError: no method matching +(::Float64, ::Float64; a::Float64)")
+    @test occursin("This method may not support any kwargs", str)
+
+    @test_throws "MethodError: no method matching kwcall()" Core.kwcall()
 end
 
 # Issue #50200
@@ -658,8 +676,9 @@ using Base.Experimental: @opaque
     test_no_error(f) = @test f() === nothing
     function test_worldage_error(f)
         ex = try; f(); error("Should not have been reached") catch ex; ex; end
-        @test occursin("The applicable method may be too new", sprint(Base.showerror, ex))
-        @test !occursin("!Matched::", sprint(Base.showerror, ex))
+        strex = sprint(Base.showerror, ex)
+        @test occursin("The applicable method may be too new", strex)
+        @test !occursin("!Matched::", sprint(Base.showerror, strex))
     end
 
     global callback50200

From 9aba4a8db97771e49d7b99bc2140780a1dd49a9c Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 4 Feb 2024 20:17:26 -0500
Subject: [PATCH 0801/1315] try improving check_top_bit error message (#53166)

Fixes #30247

@staticfloat this was your issue, so what do you think of this? I think
the main problem was already solved (showing the wrong type), but I am
wondering if this wording is still clearer, since it tries to align it
with functions users might actually have encountered (trunc, convert,
signbit)
---
 base/boot.jl            | 68 +++++++++++++++++++++--------------------
 src/common_symbols2.inc |  2 +-
 2 files changed, 36 insertions(+), 34 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 9f34f02981cf6..f60a4c861ecb9 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -744,12 +744,14 @@ function is_top_bit_set(x::Union{Int8,UInt8})
     eq_int(lshr_int(x, 7), trunc_int(typeof(x), 1))
 end
 
-#TODO delete this function (but see #48097):
+# n.b. This function exists for CUDA to overload to configure error behavior (see #48097)
 throw_inexacterror(args...) = throw(InexactError(args...))
 
-function check_top_bit(::Type{To}, x) where {To}
+function check_sign_bit(::Type{To}, x) where {To}
     @inline
-    is_top_bit_set(x) && throw_inexacterror(:check_top_bit, To, x)
+    # the top bit is the sign bit of x but "sign bit" sounds better in stacktraces
+    # n.b. if x is signed, then sizeof(x) === sizeof(To), otherwise sizeof(x) >= sizeof(To)
+    is_top_bit_set(x) && throw_inexacterror(sizeof(x) === sizeof(To) ? :convert : :trunc, To, x)
     x
 end
 
@@ -774,11 +776,11 @@ toInt8(x::Int16)      = checked_trunc_sint(Int8, x)
 toInt8(x::Int32)      = checked_trunc_sint(Int8, x)
 toInt8(x::Int64)      = checked_trunc_sint(Int8, x)
 toInt8(x::Int128)     = checked_trunc_sint(Int8, x)
-toInt8(x::UInt8)      = bitcast(Int8, check_top_bit(Int8, x))
-toInt8(x::UInt16)     = checked_trunc_sint(Int8, check_top_bit(Int8, x))
-toInt8(x::UInt32)     = checked_trunc_sint(Int8, check_top_bit(Int8, x))
-toInt8(x::UInt64)     = checked_trunc_sint(Int8, check_top_bit(Int8, x))
-toInt8(x::UInt128)    = checked_trunc_sint(Int8, check_top_bit(Int8, x))
+toInt8(x::UInt8)      = bitcast(Int8, check_sign_bit(Int8, x))
+toInt8(x::UInt16)     = checked_trunc_sint(Int8, check_sign_bit(Int8, x))
+toInt8(x::UInt32)     = checked_trunc_sint(Int8, check_sign_bit(Int8, x))
+toInt8(x::UInt64)     = checked_trunc_sint(Int8, check_sign_bit(Int8, x))
+toInt8(x::UInt128)    = checked_trunc_sint(Int8, check_sign_bit(Int8, x))
 toInt8(x::Bool)       = and_int(bitcast(Int8, x), Int8(1))
 toInt16(x::Int8)      = sext_int(Int16, x)
 toInt16(x::Int16)     = x
@@ -786,10 +788,10 @@ toInt16(x::Int32)     = checked_trunc_sint(Int16, x)
 toInt16(x::Int64)     = checked_trunc_sint(Int16, x)
 toInt16(x::Int128)    = checked_trunc_sint(Int16, x)
 toInt16(x::UInt8)     = zext_int(Int16, x)
-toInt16(x::UInt16)    = bitcast(Int16, check_top_bit(Int16, x))
-toInt16(x::UInt32)    = checked_trunc_sint(Int16, check_top_bit(Int16, x))
-toInt16(x::UInt64)    = checked_trunc_sint(Int16, check_top_bit(Int16, x))
-toInt16(x::UInt128)   = checked_trunc_sint(Int16, check_top_bit(Int16, x))
+toInt16(x::UInt16)    = bitcast(Int16, check_sign_bit(Int16, x))
+toInt16(x::UInt32)    = checked_trunc_sint(Int16, check_sign_bit(Int16, x))
+toInt16(x::UInt64)    = checked_trunc_sint(Int16, check_sign_bit(Int16, x))
+toInt16(x::UInt128)   = checked_trunc_sint(Int16, check_sign_bit(Int16, x))
 toInt16(x::Bool)      = and_int(zext_int(Int16, x), Int16(1))
 toInt32(x::Int8)      = sext_int(Int32, x)
 toInt32(x::Int16)     = sext_int(Int32, x)
@@ -798,9 +800,9 @@ toInt32(x::Int64)     = checked_trunc_sint(Int32, x)
 toInt32(x::Int128)    = checked_trunc_sint(Int32, x)
 toInt32(x::UInt8)     = zext_int(Int32, x)
 toInt32(x::UInt16)    = zext_int(Int32, x)
-toInt32(x::UInt32)    = bitcast(Int32, check_top_bit(Int32, x))
-toInt32(x::UInt64)    = checked_trunc_sint(Int32, check_top_bit(Int32, x))
-toInt32(x::UInt128)   = checked_trunc_sint(Int32, check_top_bit(Int32, x))
+toInt32(x::UInt32)    = bitcast(Int32, check_sign_bit(Int32, x))
+toInt32(x::UInt64)    = checked_trunc_sint(Int32, check_sign_bit(Int32, x))
+toInt32(x::UInt128)   = checked_trunc_sint(Int32, check_sign_bit(Int32, x))
 toInt32(x::Bool)      = and_int(zext_int(Int32, x), Int32(1))
 toInt64(x::Int8)      = sext_int(Int64, x)
 toInt64(x::Int16)     = sext_int(Int64, x)
@@ -810,8 +812,8 @@ toInt64(x::Int128)    = checked_trunc_sint(Int64, x)
 toInt64(x::UInt8)     = zext_int(Int64, x)
 toInt64(x::UInt16)    = zext_int(Int64, x)
 toInt64(x::UInt32)    = zext_int(Int64, x)
-toInt64(x::UInt64)    = bitcast(Int64, check_top_bit(Int64, x))
-toInt64(x::UInt128)   = checked_trunc_sint(Int64, check_top_bit(Int64, x))
+toInt64(x::UInt64)    = bitcast(Int64, check_sign_bit(Int64, x))
+toInt64(x::UInt128)   = checked_trunc_sint(Int64, check_sign_bit(Int64, x))
 toInt64(x::Bool)      = and_int(zext_int(Int64, x), Int64(1))
 toInt128(x::Int8)     = sext_int(Int128, x)
 toInt128(x::Int16)    = sext_int(Int128, x)
@@ -822,9 +824,9 @@ toInt128(x::UInt8)    = zext_int(Int128, x)
 toInt128(x::UInt16)   = zext_int(Int128, x)
 toInt128(x::UInt32)   = zext_int(Int128, x)
 toInt128(x::UInt64)   = zext_int(Int128, x)
-toInt128(x::UInt128)  = bitcast(Int128, check_top_bit(Int128, x))
+toInt128(x::UInt128)  = bitcast(Int128, check_sign_bit(Int128, x))
 toInt128(x::Bool)     = and_int(zext_int(Int128, x), Int128(1))
-toUInt8(x::Int8)      = bitcast(UInt8, check_top_bit(UInt8, x))
+toUInt8(x::Int8)      = bitcast(UInt8, check_sign_bit(UInt8, x))
 toUInt8(x::Int16)     = checked_trunc_uint(UInt8, x)
 toUInt8(x::Int32)     = checked_trunc_uint(UInt8, x)
 toUInt8(x::Int64)     = checked_trunc_uint(UInt8, x)
@@ -835,8 +837,8 @@ toUInt8(x::UInt32)    = checked_trunc_uint(UInt8, x)
 toUInt8(x::UInt64)    = checked_trunc_uint(UInt8, x)
 toUInt8(x::UInt128)   = checked_trunc_uint(UInt8, x)
 toUInt8(x::Bool)      = and_int(bitcast(UInt8, x), UInt8(1))
-toUInt16(x::Int8)     = sext_int(UInt16, check_top_bit(UInt16, x))
-toUInt16(x::Int16)    = bitcast(UInt16, check_top_bit(UInt16, x))
+toUInt16(x::Int8)     = sext_int(UInt16, check_sign_bit(UInt16, x))
+toUInt16(x::Int16)    = bitcast(UInt16, check_sign_bit(UInt16, x))
 toUInt16(x::Int32)    = checked_trunc_uint(UInt16, x)
 toUInt16(x::Int64)    = checked_trunc_uint(UInt16, x)
 toUInt16(x::Int128)   = checked_trunc_uint(UInt16, x)
@@ -846,9 +848,9 @@ toUInt16(x::UInt32)   = checked_trunc_uint(UInt16, x)
 toUInt16(x::UInt64)   = checked_trunc_uint(UInt16, x)
 toUInt16(x::UInt128)  = checked_trunc_uint(UInt16, x)
 toUInt16(x::Bool)     = and_int(zext_int(UInt16, x), UInt16(1))
-toUInt32(x::Int8)     = sext_int(UInt32, check_top_bit(UInt32, x))
-toUInt32(x::Int16)    = sext_int(UInt32, check_top_bit(UInt32, x))
-toUInt32(x::Int32)    = bitcast(UInt32, check_top_bit(UInt32, x))
+toUInt32(x::Int8)     = sext_int(UInt32, check_sign_bit(UInt32, x))
+toUInt32(x::Int16)    = sext_int(UInt32, check_sign_bit(UInt32, x))
+toUInt32(x::Int32)    = bitcast(UInt32, check_sign_bit(UInt32, x))
 toUInt32(x::Int64)    = checked_trunc_uint(UInt32, x)
 toUInt32(x::Int128)   = checked_trunc_uint(UInt32, x)
 toUInt32(x::UInt8)    = zext_int(UInt32, x)
@@ -857,10 +859,10 @@ toUInt32(x::UInt32)   = x
 toUInt32(x::UInt64)   = checked_trunc_uint(UInt32, x)
 toUInt32(x::UInt128)  = checked_trunc_uint(UInt32, x)
 toUInt32(x::Bool)     = and_int(zext_int(UInt32, x), UInt32(1))
-toUInt64(x::Int8)     = sext_int(UInt64, check_top_bit(UInt64, x))
-toUInt64(x::Int16)    = sext_int(UInt64, check_top_bit(UInt64, x))
-toUInt64(x::Int32)    = sext_int(UInt64, check_top_bit(UInt64, x))
-toUInt64(x::Int64)    = bitcast(UInt64, check_top_bit(UInt64, x))
+toUInt64(x::Int8)     = sext_int(UInt64, check_sign_bit(UInt64, x))
+toUInt64(x::Int16)    = sext_int(UInt64, check_sign_bit(UInt64, x))
+toUInt64(x::Int32)    = sext_int(UInt64, check_sign_bit(UInt64, x))
+toUInt64(x::Int64)    = bitcast(UInt64, check_sign_bit(UInt64, x))
 toUInt64(x::Int128)   = checked_trunc_uint(UInt64, x)
 toUInt64(x::UInt8)    = zext_int(UInt64, x)
 toUInt64(x::UInt16)   = zext_int(UInt64, x)
@@ -868,11 +870,11 @@ toUInt64(x::UInt32)   = zext_int(UInt64, x)
 toUInt64(x::UInt64)   = x
 toUInt64(x::UInt128)  = checked_trunc_uint(UInt64, x)
 toUInt64(x::Bool)     = and_int(zext_int(UInt64, x), UInt64(1))
-toUInt128(x::Int8)    = sext_int(UInt128, check_top_bit(UInt128, x))
-toUInt128(x::Int16)   = sext_int(UInt128, check_top_bit(UInt128, x))
-toUInt128(x::Int32)   = sext_int(UInt128, check_top_bit(UInt128, x))
-toUInt128(x::Int64)   = sext_int(UInt128, check_top_bit(UInt128, x))
-toUInt128(x::Int128)  = bitcast(UInt128, check_top_bit(UInt128, x))
+toUInt128(x::Int8)    = sext_int(UInt128, check_sign_bit(UInt128, x))
+toUInt128(x::Int16)   = sext_int(UInt128, check_sign_bit(UInt128, x))
+toUInt128(x::Int32)   = sext_int(UInt128, check_sign_bit(UInt128, x))
+toUInt128(x::Int64)   = sext_int(UInt128, check_sign_bit(UInt128, x))
+toUInt128(x::Int128)  = bitcast(UInt128, check_sign_bit(UInt128, x))
 toUInt128(x::UInt8)   = zext_int(UInt128, x)
 toUInt128(x::UInt16)  = zext_int(UInt128, x)
 toUInt128(x::UInt32)  = zext_int(UInt128, x)
diff --git a/src/common_symbols2.inc b/src/common_symbols2.inc
index a4583fe39f186..ee2a0e2edd9fe 100644
--- a/src/common_symbols2.inc
+++ b/src/common_symbols2.inc
@@ -8,7 +8,7 @@ jl_symbol("structdiff"),
 jl_symbol("UnitRange"),
 jl_symbol("unitrange_last"),
 jl_symbol("sizeof"),
-jl_symbol("check_top_bit"),
+jl_symbol("check_sign_bit"),
 jl_symbol("is_top_bit_set"),
 jl_symbol("data"),
 jl_symbol("kwerr"),

From 914de06663165dfe7ffa65960c6e9839b55684b8 Mon Sep 17 00:00:00 2001
From: Jerry Ling <proton@jling.dev>
Date: Sun, 4 Feb 2024 21:27:55 -0500
Subject: [PATCH 0802/1315] improve error when broadcast failed due to axistype
 (#45922)

---
 base/broadcast.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index e63631c156c7e..90453ccf19aa3 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -520,7 +520,7 @@ end
 _bcs1(a::Integer, b::Integer) = a == 1 ? b : (b == 1 ? a : (a == b ? a : throw(DimensionMismatch("arrays could not be broadcast to a common size; got a dimension with lengths $a and $b"))))
 _bcs1(a::Integer, b) = a == 1 ? b : (first(b) == 1 && last(b) == a ? b : throw(DimensionMismatch("arrays could not be broadcast to a common size; got a dimension with lengths $a and $(length(b))")))
 _bcs1(a, b::Integer) = _bcs1(b, a)
-_bcs1(a, b) = _bcsm(b, a) ? axistype(b, a) : (_bcsm(a, b) ? axistype(a, b) : throw(DimensionMismatch("arrays could not be broadcast to a common size; got a dimension with lengths $(length(a)) and $(length(b))")))
+_bcs1(a, b) = _bcsm(b, a) ? axistype(b, a) : _bcsm(a, b) ? axistype(a, b) : throw(DimensionMismatch(LazyString("arrays could not be broadcast to a common size: a has axes ", a, " and b has axes ", b)))
 # _bcsm tests whether the second index is consistent with the first
 _bcsm(a, b) = a == b || length(b) == 1
 _bcsm(a, b::Number) = b == 1

From 6defd59986503acc3891938be47563fd385fe2c6 Mon Sep 17 00:00:00 2001
From: KronosTheLate <61620837+KronosTheLate@users.noreply.github.com>
Date: Mon, 5 Feb 2024 03:30:50 +0100
Subject: [PATCH 0803/1315] Implement empty! for Channel (#53137)

---
 base/channels.jl | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/base/channels.jl b/base/channels.jl
index 75207e9fac76b..3ddf9cff7634c 100644
--- a/base/channels.jl
+++ b/base/channels.jl
@@ -218,6 +218,22 @@ end
 # does this right for you).
 isopen(c::Channel) = ((@atomic :acquire c.state) === :open)
 
+"""
+    empty!(c::Channel)
+
+Empty a Channel `c` by calling `empty!` on the internal buffer.
+Return the empty channel.
+"""
+function Base.empty!(c::Channel)
+    @lock c begin
+        ndrop = length(c.data)
+        empty!(c.data)
+        _increment_n_avail(c, -ndrop)
+        notify(c.cond_put)
+    end
+    return c
+end
+
 """
     bind(chnl::Channel, task::Task)
 

From 26d17a80b21519214fed18a9ee1670c123211b24 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 5 Feb 2024 10:27:48 +0530
Subject: [PATCH 0804/1315] Remove Matrix constructor for AbstractTriangular
 (#53167)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This seems redundant, as the fallback constructor does the same.
```julia
julia> using LinearAlgebra

julia> Revise.track(LinearAlgebra)

julia> U = UpperTriangular(rand(4,4))
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 0.798171  0.484117  0.988126  0.986837
  ⋅        0.186955  0.827882  0.600041
  ⋅         ⋅        0.344573  0.344545
  ⋅         ⋅         ⋅        0.29875

julia> Matrix(U)
4×4 Matrix{Float64}:
 0.798171  0.484117  0.988126  0.986837
 0.0       0.186955  0.827882  0.600041
 0.0       0.0       0.344573  0.344545
 0.0       0.0       0.0       0.29875

julia> @which Matrix(U)
(Array{T, N} where T)(x::AbstractArray{S, N}) where {S, N}
     @ Core boot.jl:599
```
---
 stdlib/LinearAlgebra/src/triangular.jl | 2 --
 1 file changed, 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 6ed9e43d6f507..aff87e3ae50ba 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -29,8 +29,6 @@ for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular, :UnitUpperTr
         $t{T}(A::AbstractMatrix) where {T} = $t(convert(AbstractMatrix{T}, A))
         $t{T}(A::$t) where {T} = $t(convert(AbstractMatrix{T}, A.data))
 
-        Matrix(A::$t{T}) where {T} = Matrix{T}(A)
-
         AbstractMatrix{T}(A::$t) where {T} = $t{T}(A)
         AbstractMatrix{T}(A::$t{T}) where {T} = copy(A)
 

From cfcf8a026276f31eff170fac6ede9d07297d56cf Mon Sep 17 00:00:00 2001
From: "Viral B. Shah" <ViralBShah@users.noreply.github.com>
Date: Mon, 5 Feb 2024 00:41:46 -0500
Subject: [PATCH 0805/1315] Bump SparseArrays to use SuiteSparse 7.6.0 (#53180)

This is using commits that are on a branch of SparseArrays.jl. The PR
for SuiteSparse 7.6 in SparseArrays.jl -
https://github.com/JuliaSparse/SparseArrays.jl/pull/502 - should be
merged first. Then the commits should be updated here, and then this PR
should be merged.
---
 .../md5                                       |   1 +
 .../sha512                                    |   1 +
 .../md5                                       |   1 -
 .../sha512                                    |   1 -
 .../md5                                       |   1 +
 .../sha512                                    |   1 +
 deps/checksums/suitesparse                    | 102 ++++++------------
 deps/libsuitesparse.version                   |   4 +-
 stdlib/SparseArrays.version                   |   2 +-
 stdlib/SuiteSparse_jll/Project.toml           |   2 +-
 10 files changed, 42 insertions(+), 74 deletions(-)
 create mode 100644 deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/sha512
 delete mode 100644 deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/sha512
 create mode 100644 deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
 create mode 100644 deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/md5 b/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/md5
new file mode 100644
index 0000000000000..190ea5ea307d8
--- /dev/null
+++ b/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/md5
@@ -0,0 +1 @@
+b765873c42674134d74758200885e454
diff --git a/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/sha512 b/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/sha512
new file mode 100644
index 0000000000000..aaf4f293d7d8b
--- /dev/null
+++ b/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/sha512
@@ -0,0 +1 @@
+37f5bca4d94bc74528079c039792017b7c363c53baf97671f458059f65134944e4c0ca87d474761ae082c8cf22090477559a40a84af53316aa117234d3145fa2
diff --git a/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/md5 b/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/md5
deleted file mode 100644
index b7c00193592cf..0000000000000
--- a/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-b03c158b11d19bd46430692cd8fde54a
diff --git a/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/sha512 b/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/sha512
deleted file mode 100644
index 3b4444daea951..0000000000000
--- a/deps/checksums/SparseArrays-f37477bc4881e9c540573aecb9e5809bbc306c79.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-f869333b0c568fa3bfa9a70188069bf61c712159e6f4451f806e396db58825c8fbfc1127de84b6f9ea1fb80b79c947631a5c186c11bb8eeef89aaa1161e55511
diff --git a/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5 b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
new file mode 100644
index 0000000000000..2f81a0d9191b5
--- /dev/null
+++ b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5
@@ -0,0 +1 @@
+46541001073d1c3c85e18d910f8308f3
diff --git a/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512 b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512
new file mode 100644
index 0000000000000..e2eb44845e276
--- /dev/null
+++ b/deps/checksums/SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512
@@ -0,0 +1 @@
+f7470a447b934ca9315e216a07b97e363f11bc93186f9aa057b20b2d05092c58ae4f1b733de362de4a0730861c00be4ca5588d0b3ba65f018c1798b9122b9672
diff --git a/deps/checksums/suitesparse b/deps/checksums/suitesparse
index 162e9881b41b9..88f5195bb021a 100644
--- a/deps/checksums/suitesparse
+++ b/deps/checksums/suitesparse
@@ -1,68 +1,34 @@
-SuiteSparse-7.5.1.tar.gz/md5/58942756690dfc048a176bbb7dedecf6
-SuiteSparse-7.5.1.tar.gz/sha512/1265ab3795119925dab3bd3a96aed5f48547dc24014f2fd91847ce83f00733caf4ea4026825d01960c2d3a2a316ed3762ed815e9dccc8f7d9dd9e5bd7387c1a1
-SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5/46541001073d1c3c85e18d910f8308f3
-SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512/f7470a447b934ca9315e216a07b97e363f11bc93186f9aa057b20b2d05092c58ae4f1b733de362de4a0730861c00be4ca5588d0b3ba65f018c1798b9122b9672
-SuiteSparse.v7.4.0+2.aarch64-apple-darwin.tar.gz/md5/6f38a9c86969ad3fa2708c461bcd3b2b
-SuiteSparse.v7.4.0+2.aarch64-apple-darwin.tar.gz/sha512/fa15f40456a6bda38f76caa4aedebe30c3bb3e8cf240c0eb2740169d0e7bf2563d6d1ca84233beec99f222852a49d3394b545c7349eb9573bda9bc60d20e348b
-SuiteSparse.v7.4.0+2.aarch64-linux-gnu.tar.gz/md5/8cac9d510a4c3c6e6a9b0f69fe1e0270
-SuiteSparse.v7.4.0+2.aarch64-linux-gnu.tar.gz/sha512/5590ae9e295bf34de4c19fe166aa6f79579ba74e5ccd9dbc0fc7cd3ae83329dc98c9a97eb80e92bcee04da1ae08697c687ef227d10034927c007f3a6072c0068
-SuiteSparse.v7.4.0+2.aarch64-linux-musl.tar.gz/md5/a74d064ab69db273f81a340f1096bfb7
-SuiteSparse.v7.4.0+2.aarch64-linux-musl.tar.gz/sha512/5d3b113560cb2c92c40a65edfb2f248fcc83d446eee4c8d03dbdbfecebe52b26afc662996d01d023880cd701386c293871331fc5cbf5901a1f97e5b99c68f291
-SuiteSparse.v7.4.0+2.armv6l-linux-gnueabihf.tar.gz/md5/8188603ec5c7fa4c2b2f14d11f856ffa
-SuiteSparse.v7.4.0+2.armv6l-linux-gnueabihf.tar.gz/sha512/0b5dfdce559e526c17700e2158eed8697a9bcb6d6cf95d5b1685b40da0c5668c9ee2ad49ad3e483cfbb174386907b1b74beff2723397556908898fb3b7fa9135
-SuiteSparse.v7.4.0+2.armv6l-linux-musleabihf.tar.gz/md5/76e751060e520db03f2139d9bf4e4eb1
-SuiteSparse.v7.4.0+2.armv6l-linux-musleabihf.tar.gz/sha512/f43991680d401f69dde2aab623615d3ed49435ff6591fc8a9352c98fe1d83cc4dc5ad3709afbb6dd712db0c177da0db9fb8b0cdf999a7812516e23735b0d68b4
-SuiteSparse.v7.4.0+2.armv7l-linux-gnueabihf.tar.gz/md5/277be7e8b7b6c03c0b932a98cf50e5f1
-SuiteSparse.v7.4.0+2.armv7l-linux-gnueabihf.tar.gz/sha512/fa813d4c554b6c6f4c383317ac6e2966a8cd34e8039212eb28d90da4595390cfbaecf920a843a14c50d1b6ffc9b35d0b4eb15521c887f1ec1ceae4a7a2b44e9f
-SuiteSparse.v7.4.0+2.armv7l-linux-musleabihf.tar.gz/md5/e4deba38ec452076d6a1e1ce092de2b6
-SuiteSparse.v7.4.0+2.armv7l-linux-musleabihf.tar.gz/sha512/2dc72a55be4893f4c778f686e3817c58259f81d68e76dc488f039f4e44bbb1de2133547526cb3c545d50a5a9b5646f07485e1bee8bfcfe9a42cc8b4583d15324
-SuiteSparse.v7.4.0+2.i686-linux-gnu.tar.gz/md5/f263960cd809722b1c4f6d15a72eb1ab
-SuiteSparse.v7.4.0+2.i686-linux-gnu.tar.gz/sha512/2c487b48041804273cd5ff5ca9ae90edda0fbe41c9095a9a9dfad19899e83e3f8aa9d601bdcf580cf3259d731af3936b6bceacadcda3f93e2c550bdd1cc4e684
-SuiteSparse.v7.4.0+2.i686-linux-musl.tar.gz/md5/e172f720f04edcf408792df2d3b89572
-SuiteSparse.v7.4.0+2.i686-linux-musl.tar.gz/sha512/d544f711ab88c3fc121d431f7313903ec102a474c54a2580706b73b3b0c5c0f1000fc7cc9658824abc5c912124a44ba56711257dd2ff9117a7fb57e1df4fd618
-SuiteSparse.v7.4.0+2.i686-w64-mingw32.tar.gz/md5/72870e8e03725c022f73e2f0e6f10c8b
-SuiteSparse.v7.4.0+2.i686-w64-mingw32.tar.gz/sha512/17a2b530cc0e3c9397a382ee8550f6bdc6d74b1f678cc27fa45d921e8a6ee72de2ba29e18d33f6950c3944b1c9b26f86def0c45bcb81864e10f57f27f75d55ab
-SuiteSparse.v7.4.0+2.powerpc64le-linux-gnu.tar.gz/md5/e43022f51daa1c98c45b3af3b4933dfe
-SuiteSparse.v7.4.0+2.powerpc64le-linux-gnu.tar.gz/sha512/7cd79f842a90187ff69085964a84fb6531360f4c9fdfdef6e5958f0823aa1c2a00815b4bc04406eca824294adfbe0bce2352d3fb51d0b155e8a559e99fc98f11
-SuiteSparse.v7.4.0+2.x86_64-apple-darwin.tar.gz/md5/be0a2768aa0b61e9f02ccc774a457d24
-SuiteSparse.v7.4.0+2.x86_64-apple-darwin.tar.gz/sha512/bc71f1b93bc9988e251116f46659b1c6eef8098c0bbd41b470102bd25264d1e6ae3e4f7dc452ba6673650f3b1c2d49ba312b67722e89444cd5e113892db4f09f
-SuiteSparse.v7.4.0+2.x86_64-linux-gnu.tar.gz/md5/45a30119c300e16176d06fecf8415931
-SuiteSparse.v7.4.0+2.x86_64-linux-gnu.tar.gz/sha512/16650e560f1ceb779ef2a45053bfbe41e1ecc7d21213a64ddee3e26ec77210ed97b89b0b84c92edf807c1159f329d7f374234286af4d4b9f81458b55ab54ae39
-SuiteSparse.v7.4.0+2.x86_64-linux-musl.tar.gz/md5/6a4dd22176697ec1f1586da6421c626a
-SuiteSparse.v7.4.0+2.x86_64-linux-musl.tar.gz/sha512/d223763e4c59a41a556f3dab11071672fa11f970f606a51eabb6a6b9e31fbd5a3dc35ffe891edfea0bdef8e70f0293c30831b2982c287b573cfcdaff7a050fd0
-SuiteSparse.v7.4.0+2.x86_64-unknown-freebsd.tar.gz/md5/c358b60fa7e8ba9ece545e6d7e41b343
-SuiteSparse.v7.4.0+2.x86_64-unknown-freebsd.tar.gz/sha512/2b93a8c10828eab5948a73b6b800fb321f715468a17142fabd9477543d0312d24fd567fb9fa96372304519ceda2830b259f1da30f943bc9cfa85047e640cf8f7
-SuiteSparse.v7.4.0+2.x86_64-w64-mingw32.tar.gz/md5/924a1a85d178617480178602a2fa2828
-SuiteSparse.v7.4.0+2.x86_64-w64-mingw32.tar.gz/sha512/9e753fffe9a50a3cfd520263b90194555d5f5c9f685b0aaa66ab513b3e0a5529d0efc701650955bf9cf659c930af5357c131591dbd2e02c9e7b4fa03f86a3548
-SuiteSparse.v7.5.1+0.aarch64-apple-darwin.tar.gz/md5/71cafe9018d81e633129be8674001294
-SuiteSparse.v7.5.1+0.aarch64-apple-darwin.tar.gz/sha512/693512198d04639927d0245061b3db4ca23026af3373d47958a94540371f71e546786e55c06637d2ad54d2ef5d3e16a606f6c307f9babf1813528573e7942a63
-SuiteSparse.v7.5.1+0.aarch64-linux-gnu.tar.gz/md5/e8324c4a0a946705be889de3952ad584
-SuiteSparse.v7.5.1+0.aarch64-linux-gnu.tar.gz/sha512/eac5ecc5fa0e781c4b6e5d95ec2e33e436e617f5b8eae7e35fca16c58bbe2d6f7c3ad0c16942f9846f0f0b9696657c869a2fa15b6cd53183b50f4c224f2ce0f4
-SuiteSparse.v7.5.1+0.aarch64-linux-musl.tar.gz/md5/f758985ab451c8fb805b5e6f1389ca0f
-SuiteSparse.v7.5.1+0.aarch64-linux-musl.tar.gz/sha512/0c91411114e91658113c7615b94a93e5a4c8850bbe398e862084003c27d8471af7c17397364784dde59cb88cca79d93acd895d1ff81d7ccdade534de317df3a5
-SuiteSparse.v7.5.1+0.armv6l-linux-gnueabihf.tar.gz/md5/3bc5b6773e5304e4504566804aefe5e3
-SuiteSparse.v7.5.1+0.armv6l-linux-gnueabihf.tar.gz/sha512/1f6e25af8179d915d7765225f7579b4f11bf9806e71ff886921c99c9f8c2b4f3327c9a544e7ee8690a44709292aaa9474718cdbda9ed9cc8648a3f9ee3d74273
-SuiteSparse.v7.5.1+0.armv6l-linux-musleabihf.tar.gz/md5/dbb931d46d094ab573197f8f869d3b5f
-SuiteSparse.v7.5.1+0.armv6l-linux-musleabihf.tar.gz/sha512/ce68ceefcca46ac855142cf896a0490dfc2247560805d44e7b50b967b7b5cdcbf34262327207af24b24c3f068eb2d3248a0f5a61da7ed96be25a334591f32e11
-SuiteSparse.v7.5.1+0.armv7l-linux-gnueabihf.tar.gz/md5/bea7c160cdc4d896ed448631fe6e68ce
-SuiteSparse.v7.5.1+0.armv7l-linux-gnueabihf.tar.gz/sha512/57ab75d68dd7cb8cfce2954c8a86cdff2f4e80043578b7d3086eba02142cfdceb0e9a33f8441f489ca1bcf18670e7cd43b6cde8e9e349e173604619e613e90b0
-SuiteSparse.v7.5.1+0.armv7l-linux-musleabihf.tar.gz/md5/38f91cc6672ce6a84e4e2a272de45b12
-SuiteSparse.v7.5.1+0.armv7l-linux-musleabihf.tar.gz/sha512/66a697403c827115902a6976e9d8e344733723c4a5e03903e6cb0d0e0dce9e48cd0848c500907aa7ba5540a6ecf90c464de5be0f839233388af4459b95eee413
-SuiteSparse.v7.5.1+0.i686-linux-gnu.tar.gz/md5/4d1e621cbfa05dd28b30a1b6e4bcd808
-SuiteSparse.v7.5.1+0.i686-linux-gnu.tar.gz/sha512/322d20a78cf3a305ec9fe3c8158fba2887c682160037bdfe19798b106231366282c804e0a11f1f7c7747c6e7dbf49b01fdf5ceb6806c25d5ed660aa05b04e424
-SuiteSparse.v7.5.1+0.i686-linux-musl.tar.gz/md5/c14baf67cec686827e7d04c997b05f2b
-SuiteSparse.v7.5.1+0.i686-linux-musl.tar.gz/sha512/c9ddffcc0a8a8dbe00bded156f89c2e7278fa47edcaf528d0c829013b68120e3d87c8f3bf254d7a89f7eb8795c0ca3a361a04d935383dcccda2847efa6bda19f
-SuiteSparse.v7.5.1+0.i686-w64-mingw32.tar.gz/md5/8980dc09d1e170157595d337b52dde44
-SuiteSparse.v7.5.1+0.i686-w64-mingw32.tar.gz/sha512/f132bbf9e632f01327822bc6a3b69ccabb4ecdea17e91de1e18f76f3eb634281218902e4b80a1c1cda6e0897f01cbf0e7dcf15859aed53022e73280cdc07cc8d
-SuiteSparse.v7.5.1+0.powerpc64le-linux-gnu.tar.gz/md5/11f2e1b1dc7fd4984b7999f2fba11a9f
-SuiteSparse.v7.5.1+0.powerpc64le-linux-gnu.tar.gz/sha512/5497e623b7df790b013e295b80042b5a304809159d9b9d22f61c120b9753ee12bf0ef63c765d188bd44e094cac18202ea7496110ee2215c6b1ae88fd722a4007
-SuiteSparse.v7.5.1+0.x86_64-apple-darwin.tar.gz/md5/421a7f24c29640be6bb3cfaa7614aee9
-SuiteSparse.v7.5.1+0.x86_64-apple-darwin.tar.gz/sha512/5e578b5c050af37681228bdaa1ad7c92e88c20c31fe402e1b623d78c1e837072927aed40f0281e6467d5e6101a49e3554c04b6e8948bf31fb11e9e303ba39892
-SuiteSparse.v7.5.1+0.x86_64-linux-gnu.tar.gz/md5/7e5dcb0d632cce77e3edc898b3576201
-SuiteSparse.v7.5.1+0.x86_64-linux-gnu.tar.gz/sha512/1d13e4130af8a389378b4e781e28518c9be0a5141ac96012984675014bc753f7de2817d49bad04b91306f519a13066c81f2ac48b8e3f6364031c6237f7181dc0
-SuiteSparse.v7.5.1+0.x86_64-linux-musl.tar.gz/md5/fc49feee13cd9c0db0f0264dd121602d
-SuiteSparse.v7.5.1+0.x86_64-linux-musl.tar.gz/sha512/3fd0cb57a8c88dc9e289a05575d2a2b83916c057e2c990ab57ad941ea8352e219387ece0115030eb41c9d9c9289e4425be6ec655a50748a4190924d3a9b079c0
-SuiteSparse.v7.5.1+0.x86_64-unknown-freebsd.tar.gz/md5/7f1dd8357b8ad5972ce22f843e1b79ba
-SuiteSparse.v7.5.1+0.x86_64-unknown-freebsd.tar.gz/sha512/952bcee00bab30868463329f2f12003b6ee3ceb0bba4c7b291ade490e23e277a80d127d03797fcb91ffb2af4c94411abee573100c9413d50cdd9e835fb63cbb5
-SuiteSparse.v7.5.1+0.x86_64-w64-mingw32.tar.gz/md5/3e2f5c42edc75bdbcb6da7f886ee6522
-SuiteSparse.v7.5.1+0.x86_64-w64-mingw32.tar.gz/sha512/768b0f39cb0182d6424255e848020bac0d55cd0be2b30d40dd7f4f5a7ac18971f53aeecb87d8b45e7dbe5ba3cfe318aecfe2c02eb27375b9a8adcad791f692bc
+SuiteSparse-7.6.0.tar.gz/md5/79a68c2eca2d4b213a304bd08180c630
+SuiteSparse-7.6.0.tar.gz/sha512/6cffb283e7620afd31c6f7517ca9d28c2927515af582680d346e0e8a4ee1289daec0b4d83660f88f309e53e54a87403291fc4b0b45fe50dffd59781ec0129a8f
+SuiteSparse.v7.6.0+0.aarch64-apple-darwin.tar.gz/md5/dd7cb2ded54840648d9bb28099dfbc66
+SuiteSparse.v7.6.0+0.aarch64-apple-darwin.tar.gz/sha512/64edba78b463dffebf7a1dbcc21665a8229fc795f22ea669e648b03595bb2bc646d0e5d8d9326adca525f325523f50bb8aeb1f1d6da12ba2c465f16f87ed6726
+SuiteSparse.v7.6.0+0.aarch64-linux-gnu.tar.gz/md5/f7e30ff16e597cae91031dd84fcc790a
+SuiteSparse.v7.6.0+0.aarch64-linux-gnu.tar.gz/sha512/a3bfdaef6a2108d0179de3a3fa56c58af4a6cc36d12f987baa6ce15842bff2473c5ea92e5ce0e28d97744c5b8ffae5fb178c14a2e504f8d0291d5dc67370836d
+SuiteSparse.v7.6.0+0.aarch64-linux-musl.tar.gz/md5/763d9208eb9a8d134d8a0fcdf01745c2
+SuiteSparse.v7.6.0+0.aarch64-linux-musl.tar.gz/sha512/657d78d577dade8ddb6b863208c3baf9e15e4cae83853f3730dce49a5f227eb48164f60b39cfd4a22f1d4bcf6d9c6e4b3fcf340bdc6c36345c60fb235bc2cfd7
+SuiteSparse.v7.6.0+0.armv6l-linux-gnueabihf.tar.gz/md5/7c71369a2edfe3eca0061339b8a30e3a
+SuiteSparse.v7.6.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/bc197a50a1031e17721a63405438c2705da456c5ad97dcae0ccc538b0a5d46fa474b49e14a8d3db3d32402e7234e4d9523659a0ec2318901b5e6cd8a5fe7ea8f
+SuiteSparse.v7.6.0+0.armv6l-linux-musleabihf.tar.gz/md5/2933e936ec3cdbbbd015206124d2a98e
+SuiteSparse.v7.6.0+0.armv6l-linux-musleabihf.tar.gz/sha512/d3e3382b982198b5d37928ca0e2354bb110b327069b9dfeb72e9aef1d82e79e5a1536679112c0c82c20acf7e005269f0168c84d498b4ef87c5521bd18b133134
+SuiteSparse.v7.6.0+0.armv7l-linux-gnueabihf.tar.gz/md5/df109c03141c3c34dcbcee180c255539
+SuiteSparse.v7.6.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/cbffe6e5c023f3efbb60a78d6c403feb2b2ca0ff4cac4586c82ffba65d87a4bd1cff63370abfff91882d64e6cf2bb2e10e792ab21f4b7380f413c6a78b89f242
+SuiteSparse.v7.6.0+0.armv7l-linux-musleabihf.tar.gz/md5/5a82f651831d0e83214791156637c38b
+SuiteSparse.v7.6.0+0.armv7l-linux-musleabihf.tar.gz/sha512/0436c0a83d2fb40f21cdd49817182a12824b903050fb47a717a55040445393e5312596e27654a0dabe059059b8dabf82c37e4754a71f189ee1561ddeb11098dc
+SuiteSparse.v7.6.0+0.i686-linux-gnu.tar.gz/md5/b58d6186f54c4f10d1e37ac1b82ebd1c
+SuiteSparse.v7.6.0+0.i686-linux-gnu.tar.gz/sha512/7d3f1cdd2f9786fa072d8820e4ec424d282595051aa2355c84de0530c957459408f7a4d7eb213863fe91a78c03b96346f8c6f8c088ee6e2bad91c576a5e7e39c
+SuiteSparse.v7.6.0+0.i686-linux-musl.tar.gz/md5/c43f347674f1d983d76d453a1ce26c63
+SuiteSparse.v7.6.0+0.i686-linux-musl.tar.gz/sha512/467a4e3af813c7a550b097699ca45083fcdad4ad04689bf53c302b2cf769962c23b62bc39a7afa851c4a1226cd6fbb37e1e8590fd1dbca3c680f7138eb029a8b
+SuiteSparse.v7.6.0+0.i686-w64-mingw32.tar.gz/md5/cd92ad4bef9109ab60357b78ae3c444b
+SuiteSparse.v7.6.0+0.i686-w64-mingw32.tar.gz/sha512/41557b4e4254469bd1f264f0bea4335761ee18328e22d3626dd9ddb69ab8501c40d31c2848ac3c28b361454d80b8d97514478b8db96a335aa4b8580eba22de93
+SuiteSparse.v7.6.0+0.powerpc64le-linux-gnu.tar.gz/md5/8ba38d83ee767ef1a3108ad2fbdc9edf
+SuiteSparse.v7.6.0+0.powerpc64le-linux-gnu.tar.gz/sha512/37ae98d9557ae8d2ce6edbcf2b18f49690b98daa5a19fab2cda747d2f19c735430031414fc8f23bca35899cb21995170e6fe72623dc6dae25b207870b9396698
+SuiteSparse.v7.6.0+0.x86_64-apple-darwin.tar.gz/md5/21cedd18cf9f5aa83b1bdaaf2d4253af
+SuiteSparse.v7.6.0+0.x86_64-apple-darwin.tar.gz/sha512/e86ea34ac3d1d1123be7d6989893948d26a98ae28198740272c108c434650d1616f89c9176ea51c0dbc3550a1a4f0611935eec29b2aafd96d80717c99916a2b1
+SuiteSparse.v7.6.0+0.x86_64-linux-gnu.tar.gz/md5/10674b26e56d1cb4345012b965cac926
+SuiteSparse.v7.6.0+0.x86_64-linux-gnu.tar.gz/sha512/d1dba73e5449768ac728923edf665f1c11e6d54654ab14190fa3c7cd128642b2dac5b21f3c2d91313ab35e5054e6406542e074b6de2b8c0bce49269a9ab89dd4
+SuiteSparse.v7.6.0+0.x86_64-linux-musl.tar.gz/md5/9f2b78216d7474b064c710f6966b15d9
+SuiteSparse.v7.6.0+0.x86_64-linux-musl.tar.gz/sha512/32a3c124ca8041390b0e6d4ebcfe536d25c88fee28e178fb78279e52428613cb6e109ec99b3801331740985226dd40684bf20f75dd5c99c4c74335177d3a8307
+SuiteSparse.v7.6.0+0.x86_64-unknown-freebsd.tar.gz/md5/724ee53946f949618be56ded74c15d29
+SuiteSparse.v7.6.0+0.x86_64-unknown-freebsd.tar.gz/sha512/2fc9b2fdcabfe8e98a14f74ad1f94689cbde704e9f5635f6e5677af9090920627e46e903790231edb4de998eea3a732ad88b0c3ebc2ae5a158433b487e739340
+SuiteSparse.v7.6.0+0.x86_64-w64-mingw32.tar.gz/md5/57c4bd66dfd1bdf824017150d798f8aa
+SuiteSparse.v7.6.0+0.x86_64-w64-mingw32.tar.gz/sha512/26d9c15de1b5b68b9f01775a758f322b5a9f8600c66fa713b5de1009a90cec8e6db755305c19485406f9a9e88d752871b70fff5e336d09fca9bdf61bcb4de3ba
diff --git a/deps/libsuitesparse.version b/deps/libsuitesparse.version
index 28adbba97e5c6..2602a449e3a4e 100644
--- a/deps/libsuitesparse.version
+++ b/deps/libsuitesparse.version
@@ -4,5 +4,5 @@
 LIBSUITESPARSE_JLL_NAME := SuiteSparse
 
 ## source build
-LIBSUITESPARSE_VER := 7.5.1
-LIBSUITESPARSE_SHA1=71d6d42cb60b533bd001d3e5514e11120919c43a
+LIBSUITESPARSE_VER := 7.6.0
+LIBSUITESPARSE_SHA1=1a4d4fb0c399b261f4ed11aa980c6bab754aefa6
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 2f7358219ca25..ec090d653f616 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = f37477bc4881e9c540573aecb9e5809bbc306c79
+SPARSEARRAYS_SHA1 = c9f7293c10e6bea775feceabd4554ab55c34e3a8
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1
diff --git a/stdlib/SuiteSparse_jll/Project.toml b/stdlib/SuiteSparse_jll/Project.toml
index 93a594d0b7537..24d2e42dbaea9 100644
--- a/stdlib/SuiteSparse_jll/Project.toml
+++ b/stdlib/SuiteSparse_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "SuiteSparse_jll"
 uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
-version = "7.5.1+0"
+version = "7.6.0+0"
 
 [deps]
 libblastrampoline_jll = "8e850b90-86db-534c-a0d3-1478176c7d93"

From 28db6c7a1159bba9e1745416df0f2917c5e9324c Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Tue, 6 Feb 2024 06:36:10 +0800
Subject: [PATCH 0806/1315] AnnotatedIOBuffer: prevent despecialization of
 annotations list (#53155)

In f117a500ca93 code modifying annotations via list comprehensions was
introduced. However, when (1) there are annotations present and (2) all
annotations are filtered out, this comprehension is inferred to a wider
type incompatible with the AnnotatedString constructor. This can be
fixed by changing the first element of the tuple to directly use the
UnitRange{Int} constructor, which stops it being inferred as an Any.
---
 base/strings/annotated.jl | 2 +-
 test/strings/annotated.jl | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 20ad53b78a757..4644d89283b18 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -486,7 +486,7 @@ function read(io::AnnotatedIOBuffer, ::Type{AnnotatedString{T}}) where {T <: Abs
     if (start = position(io)) == 0
         AnnotatedString(read(io.io, T), copy(io.annotations))
     else
-        annots = [(max(1, first(region) - start):last(region)-start, val)
+        annots = [(UnitRange{Int}(max(1, first(region) - start), last(region)-start), val)
                   for (region, val) in io.annotations if last(region) > start]
         AnnotatedString(read(io.io, T), annots)
     end
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index 2a9fd4a702465..74898e09eb008 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -122,6 +122,7 @@ end
     @test read(seek(aio, 1), Base.AnnotatedString) == Base.AnnotatedString("ello world", [(1:4, :tag => 1), (6:10, :tag => 2)])
     @test read(seek(aio, 4), Base.AnnotatedString) == Base.AnnotatedString("o world", [(1:1, :tag => 1), (3:7, :tag => 2)])
     @test read(seek(aio, 5), Base.AnnotatedString) == Base.AnnotatedString(" world", [(2:6, :tag => 2)])
+    @test read(aio, Base.AnnotatedString) == Base.AnnotatedString("")
     @test read(seekstart(truncate(deepcopy(aio), 5)), Base.AnnotatedString) == Base.AnnotatedString("hello", [(1:5, :tag => 1)])
     @test read(seekstart(truncate(deepcopy(aio), 6)), Base.AnnotatedString) == Base.AnnotatedString("hello ", [(1:5, :tag => 1)])
     @test read(seekstart(truncate(deepcopy(aio), 7)), Base.AnnotatedString) == Base.AnnotatedString("hello w", [(1:5, :tag => 1), (7:7, :tag => 2)])

From 353884c7e818f0412386feac72c16b243a08cd1a Mon Sep 17 00:00:00 2001
From: Frames White <oxinabox@ucc.asn.au>
Date: Tue, 6 Feb 2024 21:30:35 +0800
Subject: [PATCH 0807/1315] Don't tell people to use Pkg to install Pkg
 (#53197)

---
 base/loading.jl | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index a262537963375..33ad95620188d 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1885,10 +1885,14 @@ function __require(into::Module, mod::Symbol)
                     end
                 end
                 hint_message = hint ? ", maybe you meant `import/using $(dots)$(mod)`" : ""
-                start_sentence = hint ? "Otherwise, run" : "Run"
-                throw(ArgumentError("""
-                    Package $mod not found in current path$hint_message.
-                    - $start_sentence `import Pkg; Pkg.add($(repr(String(mod))))` to install the $mod package."""))
+                install_message = if mod != :Pkg
+                    start_sentence = hint ? "Otherwise, run" : "Run"
+                    "\n- $start_sentence `import Pkg; Pkg.add($(repr(String(mod))))` to install the $mod package."
+                else  # for some reason Pkg itself isn't availability so do not tell them to use Pkg to install it.
+                    ""
+                end
+
+                throw(ArgumentError("Package $mod not found in current path$hint_message.$install_message"))
             else
                 manifest_warnings = collect_manifest_warnings()
                 throw(ArgumentError("""

From 94fd312df03d5075796fbd2e8b47288a84a1c6de Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Tue, 6 Feb 2024 14:32:19 +0100
Subject: [PATCH 0808/1315] Add `:greedy` scheduler to `@threads` (#52096)

---
 NEWS.md                     |  2 +
 base/threadingconstructs.jl | 63 +++++++++++++++++++++++++-----
 test/threads_exec.jl        | 78 +++++++++++++++++++++++++++++++++++++
 3 files changed, 133 insertions(+), 10 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 6e7384e730efb..6db22fa1f8be7 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -71,6 +71,8 @@ difference between defining a `main` function and executing the code directly at
 Multi-threading changes
 -----------------------
 
+* `Threads.@threads` now supports the `:greedy` scheduler, intended for non-uniform workloads ([#52096]).
+
 Build system changes
 --------------------
 
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index e202bb0acb317..eef75916880da 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -176,9 +176,46 @@ end
 function _threadsfor(iter, lbody, schedule)
     lidx = iter.args[1]         # index
     range = iter.args[2]
+    esc_range = esc(range)
+    func = if schedule === :greedy
+        greedy_func(esc_range, lidx, lbody)
+    else
+        default_func(esc_range, lidx, lbody)
+    end
     quote
         local threadsfor_fun
-        let range = $(esc(range))
+        $func
+        if $(schedule === :greedy || schedule === :dynamic || schedule === :default)
+            threading_run(threadsfor_fun, false)
+        elseif ccall(:jl_in_threaded_region, Cint, ()) != 0 # :static
+            error("`@threads :static` cannot be used concurrently or nested")
+        else # :static
+            threading_run(threadsfor_fun, true)
+        end
+        nothing
+    end
+end
+
+function greedy_func(itr, lidx, lbody)
+    quote
+        let c = Channel{eltype($itr)}(0,spawn=true) do ch
+            for item in $itr
+                put!(ch, item)
+            end
+        end
+        function threadsfor_fun(tid)
+            for item in c
+                local $(esc(lidx)) = item
+                $(esc(lbody))
+            end
+        end
+        end
+    end
+end
+
+function default_func(itr, lidx, lbody)
+    quote
+        let range = $itr
         function threadsfor_fun(tid = 1; onethread = false)
             r = range # Load into local variable
             lenr = length(r)
@@ -216,14 +253,6 @@ function _threadsfor(iter, lbody, schedule)
             end
         end
         end
-        if $(schedule === :dynamic || schedule === :default)
-            threading_run(threadsfor_fun, false)
-        elseif ccall(:jl_in_threaded_region, Cint, ()) != 0 # :static
-            error("`@threads :static` cannot be used concurrently or nested")
-        else # :static
-            threading_run(threadsfor_fun, true)
-        end
-        nothing
     end
 end
 
@@ -289,6 +318,20 @@ microseconds).
 !!! compat "Julia 1.8"
     The `:dynamic` option for the `schedule` argument is available and the default as of Julia 1.8.
 
+### `:greedy`
+
+`:greedy` scheduler spawns up to [`Threads.threadpoolsize()`](@ref) tasks, each greedily working on
+the given iterated values as they are produced. As soon as one task finishes its work, it takes
+the next value from the iterator. Work done by any individual task is not necessarily on
+contiguous values from the iterator. The given iterator may produce values forever, only the
+iterator interface is required (no indexing).
+
+This scheduling option is generally a good choice if the workload of individual iterations
+is not uniform/has a large spread.
+
+!!! compat "Julia 1.11"
+    The `:greedy` option for the `schedule` argument is available as of Julia 1.11.
+
 ### `:static`
 
 `:static` scheduler creates one task per thread and divides the iterations equally among
@@ -344,7 +387,7 @@ macro threads(args...)
             # for now only allow quoted symbols
             sched = nothing
         end
-        if sched !== :static && sched !== :dynamic
+        if sched !== :static && sched !== :dynamic && sched !== :greedy
             throw(ArgumentError("unsupported schedule argument in @threads"))
         end
     elseif na == 1
diff --git a/test/threads_exec.jl b/test/threads_exec.jl
index 7953468f9c6f3..e18e4ad8809fb 100644
--- a/test/threads_exec.jl
+++ b/test/threads_exec.jl
@@ -803,6 +803,84 @@ function _atthreads_dynamic_with_error(a)
 end
 @test_throws "user error in the loop body" _atthreads_dynamic_with_error(zeros(threadpoolsize()))
 
+####
+# :greedy
+###
+
+function _atthreads_greedy_schedule(n)
+    inc = Threads.Atomic{Int}(0)
+    flags = zeros(Int, n)
+    Threads.@threads :greedy for i = 1:n
+        Threads.atomic_add!(inc, 1)
+        flags[i] = 1
+    end
+    return inc[], flags
+end
+@test _atthreads_greedy_schedule(threadpoolsize()) == (threadpoolsize(), ones(threadpoolsize()))
+@test _atthreads_greedy_schedule(1) == (1, ones(1))
+@test _atthreads_greedy_schedule(10) == (10, ones(10))
+@test _atthreads_greedy_schedule(threadpoolsize() * 2) == (threadpoolsize() * 2, ones(threadpoolsize() * 2))
+
+# nested greedy schedule
+function _atthreads_greedy_greedy_schedule()
+    inc = Threads.Atomic{Int}(0)
+    Threads.@threads :greedy for _ = 1:threadpoolsize()
+        Threads.@threads :greedy for _ = 1:threadpoolsize()
+            Threads.atomic_add!(inc, 1)
+        end
+    end
+    return inc[]
+end
+@test _atthreads_greedy_greedy_schedule() == threadpoolsize() * threadpoolsize()
+
+function _atthreads_greedy_dynamic_schedule()
+    inc = Threads.Atomic{Int}(0)
+    Threads.@threads :greedy for _ = 1:threadpoolsize()
+        Threads.@threads :dynamic for _ = 1:threadpoolsize()
+            Threads.atomic_add!(inc, 1)
+        end
+    end
+    return inc[]
+end
+@test _atthreads_greedy_dynamic_schedule() == threadpoolsize() * threadpoolsize()
+
+function _atthreads_dymamic_greedy_schedule()
+    inc = Threads.Atomic{Int}(0)
+    Threads.@threads :dynamic for _ = 1:threadpoolsize()
+        Threads.@threads :greedy for _ = 1:threadpoolsize()
+            Threads.atomic_add!(inc, 1)
+        end
+    end
+    return inc[]
+end
+@test _atthreads_dymamic_greedy_schedule() == threadpoolsize() * threadpoolsize()
+
+function _atthreads_static_greedy_schedule()
+    ids = zeros(Int, threadpoolsize())
+    inc = Threads.Atomic{Int}(0)
+    Threads.@threads :static for i = 1:threadpoolsize()
+        ids[i] = Threads.threadid()
+        Threads.@threads :greedy for _ = 1:threadpoolsize()
+            Threads.atomic_add!(inc, 1)
+        end
+    end
+    return ids, inc[]
+end
+@test _atthreads_static_greedy_schedule() == (1:threadpoolsize(), threadpoolsize() * threadpoolsize())
+
+# errors inside @threads :greedy
+function _atthreads_greedy_with_error(a)
+    Threads.@threads :greedy for i in eachindex(a)
+        error("user error in the loop body")
+    end
+    a
+end
+@test_throws "user error in the loop body" _atthreads_greedy_with_error(zeros(threadpoolsize()))
+
+####
+# multi-argument loop
+####
+
 try
     @macroexpand @threads(for i = 1:10, j = 1:10; end)
 catch ex

From da8a441137797613aee9fe47d7f66a3e25ddcff8 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Wed, 7 Feb 2024 00:11:32 +0800
Subject: [PATCH 0809/1315] Improved terminfo parser (#51198)

This bundles up the following changes:

- Rejiged TermInfo struct
- Read the extended terminfo table using the same method as the
  non-extended table
- Use signed integer types for most numeric values, as per term(5)
- More robust get(::TermInfo, ...) methods
- Better match the terminfo(5) "Fetching Compiled Descriptions" behaviour
---
 base/terminfo.jl | 185 +++++++++++++++++++++++++++--------------------
 test/terminfo.jl |  16 ++--
 2 files changed, 116 insertions(+), 85 deletions(-)

diff --git a/base/terminfo.jl b/base/terminfo.jl
index ff7e6fab7f1f7..25648b2b477e8 100644
--- a/base/terminfo.jl
+++ b/base/terminfo.jl
@@ -1,5 +1,8 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+# Since this code is in the startup-path, we go to some effort to
+# be easier on the compiler, such as using `map` over broadcasting.
+
 include("terminfo_data.jl")
 
 """
@@ -15,7 +18,7 @@ particular capabilities, solely based on `term(5)`.
 
 - `names::Vector{String}`: The names this terminal is known by.
 - `flags::BitVector`: A list of 0–$(length(TERM_FLAGS)) flag values.
-- `numbers::Union{Vector{UInt16}, Vector{UInt32}}`: A list of 0–$(length(TERM_NUMBERS))
+- `numbers::Union{Vector{Int16}, Vector{Int32}}`: A list of 0–$(length(TERM_NUMBERS))
   number values. A value of `typemax(eltype(numbers))` is used to skip over
   unspecified capabilities while ensuring value indices are correct.
 - `strings::Vector{Union{String, Nothing}}`: A list of 0–$(length(TERM_STRINGS))
@@ -30,9 +33,9 @@ See also: `TermInfo` and `TermCapability`.
 struct TermInfoRaw
     names::Vector{String}
     flags::BitVector
-    numbers::Union{Vector{UInt16}, Vector{UInt32}}
+    numbers::Vector{Int}
     strings::Vector{Union{String, Nothing}}
-    extended::Union{Nothing, Dict{Symbol, Union{Bool, Int, String}}}
+    extended::Union{Nothing, Dict{Symbol, Union{Bool, Int, String, Nothing}}}
 end
 
 """
@@ -59,59 +62,48 @@ See also: `TermInfoRaw` and `TermCapability`.
 """
 struct TermInfo
     names::Vector{String}
-    flags::Int
-    numbers::BitVector
-    strings::BitVector
-    extensions::Vector{Symbol}
-    capabilities::Dict{Symbol, Union{Bool, Int, String}}
+    flags::Dict{Symbol, Bool}
+    numbers::Dict{Symbol, Int}
+    strings::Dict{Symbol, String}
+    extensions::Union{Nothing, Set{Symbol}}
 end
 
-TermInfo() = TermInfo([], 0, [], [], [], Dict())
+TermInfo() = TermInfo([], Dict(), Dict(), Dict(), nothing)
 
 function read(data::IO, ::Type{TermInfoRaw})
     # Parse according to `term(5)`
     # Header
     magic = read(data, UInt16) |> ltoh
     NumInt = if magic == 0o0432
-        UInt16
+        Int16
     elseif magic == 0o01036
-        UInt32
+        Int32
     else
         throw(ArgumentError("Terminfo data did not start with the magic number 0o0432 or 0o01036"))
     end
-    name_bytes = read(data, UInt16) |> ltoh
-    flag_bytes = read(data, UInt16) |> ltoh
-    numbers_count = read(data, UInt16) |> ltoh
-    string_count = read(data, UInt16) |> ltoh
-    table_bytes = read(data, UInt16) |> ltoh
+    name_bytes, flag_bytes, numbers_count, string_count, table_bytes =
+        @ntuple 5 _->read(data, Int16) |> ltoh
     # Terminal Names
-    term_names = split(String(read(data, name_bytes - 1)), '|') .|> String
+    term_names = map(String, split(String(read(data, name_bytes - 1)), '|'))
     0x00 == read(data, UInt8) ||
         throw(ArgumentError("Terminfo data did not contain a null byte after the terminal names section"))
     # Boolean Flags
-    flags = read(data, flag_bytes) .== 0x01
+    flags = map(==(0x01), read(data, flag_bytes))
     if position(data) % 2 != 0
         0x00 == read(data, UInt8) ||
             throw(ArgumentError("Terminfo did not contain a null byte after the flag section, expected to position the start of the numbers section on an even byte"))
     end
     # Numbers, Strings, Table
-    numbers = map(ltoh, reinterpret(NumInt, read(data, numbers_count * sizeof(NumInt))))
-    string_indices = map(ltoh, reinterpret(UInt16, read(data, string_count * sizeof(UInt16))))
+    numbers = map(Int ∘ ltoh, reinterpret(NumInt, read(data, numbers_count * sizeof(NumInt))))
+    string_indices = map(ltoh, reinterpret(Int16, read(data, string_count * sizeof(Int16))))
     strings_table = read(data, table_bytes)
-    strings = map(string_indices) do idx
-        if idx ∉ (0xffff, 0xfffe)
-            len = findfirst(==(0x00), view(strings_table, 1+idx:length(strings_table)))
-            !isnothing(len) ||
-                throw(ArgumentError("Terminfo string table entry does not terminate with a null byte"))
-            String(strings_table[1+idx:idx+len-1])
-        end
-    end
+    strings = _terminfo_read_strings(strings_table, string_indices)
     TermInfoRaw(term_names, flags, numbers, strings,
                 if !eof(data) extendedterminfo(data, NumInt) end)
 end
 
 """
-    extendedterminfo(data::IO; NumInt::Union{Type{UInt16}, Type{UInt32}})
+    extendedterminfo(data::IO; NumInt::Union{Type{Int16}, Type{Int32}})
 
 Read an extended terminfo section from `data`, with `NumInt` as the numbers type.
 
@@ -119,34 +111,56 @@ This will accept any terminfo content that conforms with `term(5)`.
 
 See also: `read(::IO, ::Type{TermInfoRaw})`
 """
-function extendedterminfo(data::IO, NumInt::Union{Type{UInt16}, Type{UInt32}})
+function extendedterminfo(data::IO, NumInt::Union{Type{Int16}, Type{Int32}})
     # Extended info
     if position(data) % 2 != 0
         0x00 == read(data, UInt8) ||
-            throw(ArgumentError("Terminfo did not contain a null byte before the extended section, expected to position the start on an even byte"))
+            throw(ArgumentError("Terminfo did not contain a null byte before the extended section; expected to position the start on an even byte"))
     end
     # Extended header
-    flag_bytes = read(data, UInt16) |> ltoh
-    numbers_count = read(data, UInt16) |> ltoh
-    string_count = read(data, UInt16) |> ltoh
-    table_count = read(data, UInt16) |> ltoh
-    table_bytes = read(data, UInt16) |> ltoh
+    flag_bytes, numbers_count, string_count, table_count, table_bytes =
+        @ntuple 5 _->read(data, Int16) |> ltoh
     # Extended flags/numbers/strings
-    flags = read(data, flag_bytes) .== 0x01
+    flags = map(==(0x01), read(data, flag_bytes))
     if flag_bytes % 2 != 0
         0x00 == read(data, UInt8) ||
-            throw(ArgumentError("Terminfo did not contain a null byte after the extended flag section, expected to position the start of the numbers section on an even byte"))
+            throw(ArgumentError("Terminfo did not contain a null byte after the extended flag section; expected to position the start of the numbers section on an even byte"))
+    end
+    numbers = map(Int ∘ ltoh, reinterpret(NumInt, read(data, numbers_count * sizeof(NumInt))))
+    table_indices = map(ltoh, reinterpret(Int16, read(data, table_count * sizeof(Int16))))
+    table_data = read(data, table_bytes)
+    strings = _terminfo_read_strings(table_data, table_indices[1:string_count])
+    table_halfoffset = Int16(get(table_indices, string_count, 0) +
+        ncodeunits(something(get(strings, length(strings), ""), "")) + 1)
+    for index in string_count+1:lastindex(table_indices)
+        table_indices[index] += table_halfoffset
     end
-    numbers = map(n -> Int(ltoh(n)), reinterpret(NumInt, read(data, numbers_count * sizeof(NumInt))))
-    table_indices = map(ltoh, reinterpret(UInt16, read(data, table_count * sizeof(UInt16))))
-    table_strings = [String(readuntil(data, 0x00)) for _ in 1:length(table_indices)]
-    info = Dict{Symbol, Union{Bool, Int, String}}()
-    strings = table_strings[1:string_count]
-    labels = table_strings[string_count+1:end]
-    for (label, val) in zip(labels, vcat(flags, numbers, strings))
-        info[Symbol(label)] = val
+    labels = map(Symbol, _terminfo_read_strings(table_data, table_indices[string_count+1:end]))
+    Dict{Symbol, Union{Bool, Int, String, Nothing}}(
+        zip(labels, Iterators.flatten((flags, numbers, strings))))
+end
+
+"""
+    _terminfo_read_strings(table::Vector{UInt8}, indices::Vector{Int16})
+
+From `table`, read a string starting at each position in `indices`. Each string
+must be null-terminated. Should an index be -1 or -2, `nothing` is given instead
+of a string.
+"""
+function _terminfo_read_strings(table::Vector{UInt8}, indices::Vector{Int16})
+    strings = Vector{Union{Nothing, String}}(undef, length(indices))
+    map!(strings, indices) do idx
+        if idx >= 0
+            len = findfirst(==(0x00), view(table, 1+idx:length(table)))
+            !isnothing(len) ||
+                throw(ArgumentError("Terminfo table entry @$idx does not terminate with a null byte"))
+            String(table[1+idx:idx+len-1])
+        elseif idx ∈ (-1, -2)
+        else
+            throw(ArgumentError("Terminfo table index is invalid: -2 ≰ $idx"))
+        end
     end
-    return info
+    strings
 end
 
 """
@@ -158,45 +172,60 @@ NCurses 6.3, see `TERM_FLAGS`, `TERM_NUMBERS`, and `TERM_STRINGS`).
 function TermInfo(raw::TermInfoRaw)
     capabilities = Dict{Symbol, Union{Bool, Int, String}}()
     sizehint!(capabilities, 2 * (length(raw.flags) + length(raw.numbers) + length(raw.strings)))
+    flags = Dict{Symbol, Bool}()
+    numbers = Dict{Symbol, Int}()
+    strings = Dict{Symbol, String}()
+    extensions = nothing
     for (flag, value) in zip(TERM_FLAGS, raw.flags)
-        capabilities[flag.short] = value
-        capabilities[flag.long] = value
+        flags[flag.short] = value
+        flags[flag.long] = value
     end
     for (num, value) in zip(TERM_NUMBERS, raw.numbers)
-        if value != typemax(eltype(raw.numbers))
-            capabilities[num.short] = Int(value)
-            capabilities[num.long] = Int(value)
-        end
+        numbers[num.short] = Int(value)
+        numbers[num.long] = Int(value)
     end
     for (str, value) in zip(TERM_STRINGS, raw.strings)
         if !isnothing(value)
-            capabilities[str.short] = value
-            capabilities[str.long] = value
+            strings[str.short] = value
+            strings[str.long] = value
         end
     end
-    extensions = if !isnothing(raw.extended)
-        capabilities = merge(capabilities, raw.extended)
-        keys(raw.extended) |> collect
-    else
-        Symbol[]
+    if !isnothing(raw.extended)
+        extensions = Set{Symbol}()
+        for (key, value) in raw.extended
+            push!(extensions, key)
+            if value isa Bool
+                flags[key] = value
+            elseif value isa Int
+                numbers[key] = value
+            elseif value isa String
+                strings[key] = value
+            end
+        end
     end
-    TermInfo(raw.names, length(raw.flags),
-             map(n-> n != typemax(typeof(n)), raw.numbers),
-             map(!isnothing, raw.strings),
-             extensions, capabilities)
+    TermInfo(raw.names, flags, numbers, strings, extensions)
+end
+
+get(ti::TermInfo, key::Symbol, default::Bool) = get(ti.flags, key, default)
+get(ti::TermInfo, key::Symbol, default::Int) = get(ti.numbers, key, default)
+get(ti::TermInfo, key::Symbol, default::String) = get(ti.strings, key, default)
+
+haskey(ti::TermInfo, key::Symbol) =
+    haskey(ti.flags, key) || haskey(ti.numbers, key) || haskey(ti.strings, key)
+
+function getindex(ti::TermInfo, key::Symbol)
+    haskey(ti.flags, key) && return ti.flags[key]
+    haskey(ti.numbers, key) && return ti.numbers[key]
+    haskey(ti.strings, key) && return ti.strings[key]
+    throw(KeyError(key))
 end
 
-getindex(ti::TermInfo, key::Symbol) = ti.capabilities[key]
-get(ti::TermInfo, key::Symbol, default::D) where D<:Union{Bool, Int, String} =
-    get(ti.capabilities, key, default)::D
-get(ti::TermInfo, key::Symbol, default) = get(ti.capabilities, key, default)
-keys(ti::TermInfo) = keys(ti.capabilities)
-haskey(ti::TermInfo, key::Symbol) = haskey(ti.capabilities, key)
+keys(ti::TermInfo) = keys(ti.flags) ∪ keys(ti.numbers) ∪ keys(ti.strings)
 
 function show(io::IO, ::MIME"text/plain", ti::TermInfo)
-    print(io, "TermInfo(", ti.names, "; ", ti.flags, " flags, ",
-          sum(ti.numbers), " numbers, ", sum(ti.strings), " strings")
-    !isempty(ti.extensions) > 0 &&
+    print(io, "TermInfo(", ti.names, "; ", length(ti.flags), " flags, ",
+          length(ti.numbers), " numbers, ", length(ti.strings), " strings")
+    !isnothing(ti.extensions) &&
         print(io, ", ", length(ti.extensions), " extended capabilities")
     print(io, ')')
 end
@@ -216,13 +245,15 @@ function find_terminfo_file(term::String)
         [ENV["TERMINFO"]]
     elseif isdir(joinpath(homedir(), ".terminfo"))
         [joinpath(homedir(), ".terminfo")]
-    elseif haskey(ENV, "TERMINFO_DIRS")
-        split(ENV["TERMINFO_DIRS"], ':')
-    elseif Sys.isunix()
-        ["/usr/share/terminfo"]
     else
         String[]
     end
+    haskey(ENV, "TERMINFO_DIRS") &&
+        append!(terminfo_dirs,
+                replace(split(ENV["TERMINFO_DIRS"], ':'),
+                        "" => "/usr/share/terminfo"))
+    Sys.isunix() &&
+        push!(terminfo_dirs, "/etc/terminfo", "/usr/share/terminfo")
     for dir in terminfo_dirs
         if isfile(joinpath(dir, chr, term))
             return joinpath(dir, chr, term)
diff --git a/test/terminfo.jl b/test/terminfo.jl
index cbaab346a617b..809b0374ad3e1 100644
--- a/test/terminfo.jl
+++ b/test/terminfo.jl
@@ -889,20 +889,20 @@ let
 @testset "terminfo" begin
     dumb = Base.TermInfo(read(IOBuffer(dumb_terminfo), Base.TermInfoRaw))
     @test dumb.names == ["dumb", "80-column dumb tty"]
-    @test dumb.flags == 2
-    @test dumb.numbers == [true]
-    @test dumb.extensions == Symbol[]
-    @test length(dumb.capabilities) == 14
+    @test length(dumb.flags) == 4
+    @test length(dumb.numbers) == 2
+    @test length(dumb.strings) == 8
+    @test isnothing(dumb.extensions)
     for (key, value) in dumb_capabilities
         @test dumb[key] == value
     end
 
     xterm = Base.TermInfo(read(IOBuffer(xterm_terminfo), Base.TermInfoRaw))
     @test xterm.names == ["xterm", "xterm terminal emulator (X Window System)"]
-    @test xterm.flags == 38
-    @test xterm.numbers == Bool[1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1]
-    @test sort(xterm.extensions) == sort(xterm_extensions)
-    @test length(xterm.capabilities) == 519
+    @test length(xterm.flags) == 78
+    @test length(xterm.numbers) == 29
+    @test length(xterm.strings) == 432
+    @test sort(xterm.extensions |> collect) == sort(xterm_extensions)
     for (key, value) in xterm_capabilities
         @test xterm[key] == value
     end

From 31ae77542dbdd18bc43eed9e151421f5c6c416de Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 6 Feb 2024 17:12:40 +0100
Subject: [PATCH 0810/1315] fix typo in AnnotatedChar constructor (#53204)

Found randomly when using JET for something completely different.
---
 base/strings/annotated.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 4644d89283b18..f84a85eaf62ab 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -112,7 +112,7 @@ AnnotatedString(s::AnnotatedString, annots::Vector{Tuple{UnitRange{Int}, Pair{Sy
     AnnotatedString(s.string, vcat(s.annotations, annots))
 
 AnnotatedChar(c::AnnotatedChar, annots::Vector{Pair{Symbol, Any}}) =
-    AnnotatedChar(c.char, vcat(s.annotations, annots))
+    AnnotatedChar(c.char, vcat(c.annotations, annots))
 
 String(s::AnnotatedString{String}) = s.string # To avoid pointless overhead
 

From eb82072647a1142e2e3ab64f428e27c29531ff6b Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Tue, 6 Feb 2024 12:19:25 -0600
Subject: [PATCH 0811/1315] deps/ittapi: Update ittapi clean target (#52693)

Change:
- clean `libittnotify` and `libjitprofiling`, not `libopenlibm`

c.f. https://github.com/JuliaLang/julia/blob/0f62824530feb9ab39c179175b3fc4702d21c552/deps/ittapi.mk#L23-L25
---
 deps/ittapi.mk | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/deps/ittapi.mk b/deps/ittapi.mk
index 1a47c3ae89390..b62b981a34ddb 100644
--- a/deps/ittapi.mk
+++ b/deps/ittapi.mk
@@ -40,4 +40,5 @@ fastcheck-ittapi: #none
 check-ittapi: #none
 
 clean-ittapi:
-	-rm -f $(BUILDDIR)/$(ITTAPI_SRC_DIR)/build-compiled $(build_libdir)/libopenlibm.a
+	-rm -f $(BUILDDIR)/$(ITTAPI_SRC_DIR)/build-compiled
+	-rm -f $(build_libdir)/libittnotify.a $(build_libdir)/libjitprofiling.a

From 9bafc5334a6a883408ba70761111158f97cc288d Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 6 Feb 2024 13:36:53 -0500
Subject: [PATCH 0812/1315] Profile: add notes to `print()` docs (#53205)

---
 stdlib/Profile/src/Profile.jl | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index 6be5ad4b75894..e426884f058b9 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -233,6 +233,13 @@ The keyword arguments can be any combination of:
 
  - `tasks::Union{Int,AbstractVector{Int}}` -- Specify which tasks to include snapshots from in the report. Note that this
     does not control which tasks samples are collected within.
+
+!!! compat "Julia 1.8"
+    The `groupby`, `threads`, and `tasks` keyword arguments were introduced in Julia 1.8.
+
+!!! note
+    Profiling on windows is limited to the main thread. Other threads have not been sampled and will not show in the report.
+
 """
 function print(io::IO,
         data::Vector{<:Unsigned} = fetch(),

From 0c4900397c25d591c7301579db9002f437bf8f91 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Tue, 6 Feb 2024 15:56:33 -0300
Subject: [PATCH 0813/1315] Update LLVM version to 16.0.6+4 (#53195)

This has a build change for enzyme, but should be NFC
---
 deps/checksums/clang            | 216 ++++++++--------
 deps/checksums/lld              | 216 ++++++++--------
 deps/checksums/llvm             | 436 ++++++++++++++++----------------
 deps/clang.version              |   2 +-
 deps/lld.version                |   2 +-
 deps/llvm-tools.version         |   4 +-
 deps/llvm.version               |   2 +-
 stdlib/LLD_jll/Project.toml     |   2 +-
 stdlib/libLLVM_jll/Project.toml |   2 +-
 9 files changed, 441 insertions(+), 441 deletions(-)

diff --git a/deps/checksums/clang b/deps/checksums/clang
index 0786be8219f37..f27067bf6cb85 100644
--- a/deps/checksums/clang
+++ b/deps/checksums/clang
@@ -1,108 +1,108 @@
-Clang.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/79cf4b063209aeb369c518c89a40c805
-Clang.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/04caf2c5bd448dbbcb56a1a0f1ff938241eea6e5e8e4fb849764c49b291cc37379c9980063a9ec72b86a6ed7f416c85f4cedd808c75b904960070cd0f4f1e669
-Clang.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/6c4442df77d1874988fa81464c61083d
-Clang.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/06b30fd222e83bcca4bb0f9d0800b3072e8a860be8eb089e472a21a4cf960137834bdc28fb5fcdb5c588c3808995c6d27e3d90ccec86072088c7d0acb2cb3ad2
-Clang.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/922d89517c75d08e900e826accca6a38
-Clang.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/482aef0dfedc25030b0aab1e93a70eae517649dfab6ee8738c3cfb173cf2969daa962caaa637c1886966cf1697ee646d104d286f22b111064a600b0e4f845cd0
-Clang.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/70f5687634977f70105d772ce05b4ab7
-Clang.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/4b406d4d285e4a3e5c150d68cc1e9996d078f13c1cb95feb741484a0bacfba622886c6b5cc87a2c4e8441d937fecf0469989748fef5a4aa6cb28bcff39dc1e2e
-Clang.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/4e5cbd2f00fc3388a895e71d487e1605
-Clang.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/6a724195e8fba5e0c93f2e632abac53e05275e844ed81f349d812f2db8ca61a61ff95ab252ab70b5f7c277cde78a6f2e78c7a930b2c5646daf916734ba20592f
-Clang.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/3f823d697b2493792a1db2133e0d45cb
-Clang.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/1371140e74b3d78653ab0493b4a2333f5db34fc0ee133b1f162480fca043d90d44b73ec72c7c49549a6b78fdc2ebae300b0e2b09e0a511085ecb7fc08a13e0c8
-Clang.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/c2b68898a98e3e36af32800667bf6514
-Clang.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/78efac6a7a1f9931a0986e27e73ff12e8bf8333b8bdf5b20dfe1f7468e3cc05ba1161e535a457287f24fa75a91afe172f41226bc6521d12768b71c7dbcfaf43c
-Clang.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/f23fa130c02da99396dc8c48f72872f2
-Clang.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/73f59d59d4a1eb4d5d5d46db34fd9828633b66a45a0c192169c0516d510a561c01b95f5e752d1177325297b111a5d924080e6233c6459759d27f267c80f2bfa4
-Clang.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/5fc6579ee98075b4098251ff64e20962
-Clang.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/8f357152c3da7d668a9abd2133a77fd6c3685258341339b6e46b4d9af04f8e27c655c5e21479f07657c0089dccf4872f7e4e7b13e8ace1cb076aba8dc8574abd
-Clang.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/9509469c23a03a6726dec3b7fd817329
-Clang.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/6a4ec6151febd9a6953afd19217a12f5a492b19064b5f49063d83cd82cf770cd2a865cdc78fc0c1af4fb331de4584e57c2068ef8f1353434861535e0a28dfb3f
-Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/4d4b30c0f40c9056cd43d0e412d62538
-Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/96586e9a6d1194b6846d37f0367fdfb30cace917e7c9ffd4972127883083cd810a05baae6d36bcdfc64ca1b761047efd029e04e88bc4fbf533b43561ce29c0a0
-Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/b502a954b8d079a832ce40342d43f2e3
-Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/1234fe9562524de80730d4a41ab609c7143ab71d51d941336a43acde99152d5976086d0e1323dd7dc4190df58f20e6c94c40fa1d75caff00353b6bbe1b11236c
-Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/b3b961ed6de57d6b70a5de30efcf5364
-Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/23ddb6c0c2b6b8b8c35f4c3f2c26d8e55fcadbc7d110c031c31c6f60416875781d8fc9458dc9e9d03434e393329632da79094342490d1a83ccea601eb942236f
-Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/cb5197d2fdbf5b920bcff6defc99ad40
-Clang.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/05b7acf5ab6cf07478361225a53f6016d1936e1b50de367932628e9b6554badd80e7f54214dd826cb52269bda07faa1fabc32050e1a25367973ba69fab021c31
-Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/216c69141f1b6c5adccd2a9733a2926a
-Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/a4fd3cfd099d46b29536c471d445f5bca150f275803a9b66d8f1da14c8c652e28d273f2d24c76467dcb7afe36acb27dac014d990f90ce6824c86fb261ebcfa5d
-Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/dd63f176e27c13b6483caa2d9d26153b
-Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/7fbcdc2817a7811b4d9544dc6e4cfb0c0046b47e240f98c6ac8601b97cc41746b56650fd80e3ffcb3c8c9b211ce8cce66729abe9af3fdea7d6af7fe7c8d14090
-Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/1f7a7d83377b5b23a40027e213b4a7b2
-Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/9b631b1f9016bff95195cdf6595c2902298824fadd1f88ec0849c1b099fde27fb7b1f54edea735e8bd503a0586074ae7651f29b89889cf9d85c1e23b5021e09e
-Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/397efa429183dd2567da133426b2aae8
-Clang.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/a9ca114bb18b50c2f06ddf8d437ac10582a92a8e00038b6de5839d70a41f9ee91382ce9a9988da5b74d90059c8f9b6e2807d14256c23fad9e0f73279a94b8b10
-Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/f5bdb88aba348da4c9b928f09fc163b6
-Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/cbc2aa07a8912e9e8599a85145882f379d51d32b214ee1a12480e1abbae951b546085388ff8d437be0ed49fb9818acf4c09c353d5f35ba66adf9c81ab6657027
-Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/fb4109dedc0c6bb97a8b4d148107bd44
-Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/7cc729206a9fee458e52d3c2d12f86fa59b1379636ac5720b4103163207e2369611ee91251d990a37eefb31fc68c8708b95fed236d472f51fc50edc38a35a6f3
-Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/b390875b3b1c37742e8fa3b10799df03
-Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/7b651570e629b9accd87e4907d3c6574f0fd9b906d7ebb0f310d3e96447d3f7d3d39630a5f63491cf307fc5aa746b1aeb02ba6aa76f390c8d8b7d06f77f87705
-Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/760eb90bf8559f4a73a66461a1154926
-Clang.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/386e4a6f7161077f5034b10f46f3e9e43919e9b247d693ba5df354d2d6682f25c986cd3b988b699e3c40a61c6b84360bd5f401840f7eaa379069f5755fb2812a
-Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/b3894812924861431fa789b096601d6e
-Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/7436260ca18b1ca0a2515fd9afe12c8ff252efa55a48ee44c84508c970b21e8edec7e1a418c4fa8b0aa6b1bcaa22450f864a1b147883b5e231d519b5e3f91498
-Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/fe0fcfcd0ae8ee11f35aa9a5b2e61675
-Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/1d2556d91174b076a6dba5715760a859041573b545ac20354072bab61e75687a263dd75d0f746b291dd20fc3044aebd9fcccc6fa16d54bd49bff40c2f11133a1
-Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/4e01a10df5cf3e13977c3017e6c35f9d
-Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/9289d6697cc31397278e793badbfdb33f48becc57938de73f42c4c1119af4c88497a2036201da2e3ba1e3a3e5f73190162f39a845a999c385bf58df5d706b543
-Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/b23d0408db616c2d1bb30d168de20936
-Clang.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/2d7835d2679d3bc2647f9678ba1706d28e844ea04d5240fd50faa4e94b32d40add42daa079719eaaea6d42319c27d8e5ca6662a15c4ddcd1196662cf26a03807
-Clang.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/2d86562992d581dc69c7c9dd7187af84
-Clang.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/7755a9029a0a742aacd0a3c7609372a5b9dd8060d2bf9e12b362fdea1d68ae46eaa3c8e6fae3ff331977774d4bec857e017e2c52e5a06b519ad8cd2ab551ca3b
-Clang.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/21267aaee5c129a8a036d30541c12dd5
-Clang.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/b8f0b3a437a326274bd1fe82f14acfb50e07ad1f858996787da9e1faea11c8e9c017467d726ed23e41ca9eeb298fe2f4a203c64ab21a74c4a2a3a4b2920fc5f5
-Clang.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/64ee96aa2b5d07665020fda19a696e41
-Clang.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/201c68dcb08b1c92b3a7f7af951cbf481c14377d09310c426bb92c46d5c084ea735c28c56a99979216ac1343bd6869257355a7f1410e1c35fa59a9448271074c
-Clang.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/da1e866abb3123d3be433220f13350b3
-Clang.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/10979264f94a8de88f514521e509b703116b30290da088ddb8fd210205c1a9184ed6770bd103b69bee756dc529c7060994b89213ca37ee353b9a367579367c75
-Clang.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/116b89d6337487431613ee804771b5dc
-Clang.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/587e85d2c64953cfecefffb556631683dbcb56ccb63de26194977d64e9c2cbabbe37893e9c750f784b107228e17fce1cb8412b757aa71a7ee02f305730c4338b
-Clang.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/af031e3ea7b5eeedbd9994e0717176d0
-Clang.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/10f85637060d46f17141b5461073a1631c9784213d5a1f1579ea9bbb601026599eaf563e027991c277d5cba56ed933aef3e56594d3bc9ff09f3957b6a294ca44
-Clang.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/5e0c36cc096f964d9d00875847972899
-Clang.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/f18c027e709eb7a456c7c6c37cd0ec0a537a68eccb806756eee5fefeb47b368dd15e1d3b81ddf910e0eb6a9e33801718d1a2dffaa9e6606ba7caa64e14d41389
-Clang.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4c070224ea19e61ebf375a5721663405
-Clang.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/b2cd67e9d1db9792c71bc0544082abd80a473c4e3002b0ad10047d0610cfaf8242a1e0f86b3f481c4fcdc2598d3bc2ece6c0c5e4c4224c036e7656a6c1a654db
-Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/f0e51e78eac3f4363fe57ee82942d551
-Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/fd4f08d0b4fab17db7bca0869bd2ded70b9c12dce095d22bb7956d87af4df82b7a67f615a9f60506c31baa456f10818d0013627498e53af0d2a5f2bc616eefed
-Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/a3e0a99be915754f43f3c293365fa4c5
-Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/912c75c32dd9c1e07312a1ad2ca3904974bf7b68fba01a605b33ce933d8bfc51afdc8ba548c5ceeb94238f1d9a0de20dfd0dd58aa9456daf31b2bda49ac8c8b5
-Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/c675d1e35584b0c55f5531df88c544c1
-Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/5286394414dee278bc45daa499a57e0f5c73d6715bcdb40148f29055802fc38fb099c3615063f87d84cea2279c278391fa1263180321e04d8f7caaeb05d55be6
-Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/373b5c0efd9b4ad9505832689e44c5a6
-Clang.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/118f3f1a9de66d7f05006055af3c51602c8f239abc8076069d009201d4e87a35271eaaf91fb6a8edd9a4f85955ebd837c34e0983111f600e2207bc57730a7a25
-Clang.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/2713c9bb02b81e61afd1e16fb451cf8c
-Clang.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/b70087d577c1692364f4085b897bf9fdf4ab0cd8c4e02d7388e108071293548b656a7081c37ee1e8c1b0b40cc52bd66651bf9cfbcc21110a2db12d853a6c9c5a
-Clang.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/2397884f2b331762654fa67390788ad7
-Clang.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/09c76fddb118d60ae5c886374fa188393f68ac392d13c395f26df786174237e5ed0b92fccb95e3f67a4aee8fafadead534aafa263843ca80dd2167b58f6dccd3
-Clang.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/b3bd1e24275c7cec1105be50c04cdf15
-Clang.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/72b58b9397edf8ee69393b101df7a741de084ae059dc7617388e6de857bd000a1eb73d33a9575f80ea4ad0cef48682225de4ff674844579dd415be1aa7dee4e6
-Clang.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/a3626ef235f593e77fb7b3329d55fbb3
-Clang.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/1e78e8ccfac8cfb05e612a038666bb1fc721fed6ad48e351fa57115125e8493dd77a47b12244a5e3cbf880aec57063753a0889bb051b312ad58dc64174e350e1
-Clang.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/cf1c314577c88e026f83cb1d119c9db6
-Clang.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/31a21ab9e153d5963a331165d0ee0b1f7c00716b777fb9634a77b78012608386a724c84871a93809bd9da1b2286ba3dcef8dab1888214e9297758e5c4518de00
-Clang.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/17e10dbb8a20c235a344543a8abbae2e
-Clang.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/57559a589d0b8a94f586bc9d00d8502e11b4172dd8afd6b9c241ab8ca3a404e3d8106f8e6f1a9cc96a4be2141acbfaabdb7835eac1a18a0d9bb7fdfd2fd308e1
-Clang.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/13cec7e091f8eda85c43531053eb2c4c
-Clang.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/3cb6884bd34fbb9eff6b366da6f476b5e863f3637a0b3a677500c05503c5ee96aa5ec3d6fad4bddf46bb60aaf647c689e77656ebec3e7cb274ade6b481ec75f4
-Clang.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/1f21f372454290315e24affb757f2557
-Clang.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/79b3d0882172babe4cdd388b55308a3d0d943d9ccd937abed35325e96e7ba43426f80d8366affd0803fe374d44659f07093d9fb5d791127a8437b5e10319107b
-Clang.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/026caf653d390ddb7bc71ca151966e41
-Clang.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/4194880c9549ca6bb200b5475afa00b6fe617a40f1f6b89c9fe82ae183c6c5c4b03e1537b8f6c82b2c416591faaf916114b27832efaec8a491ac7cc441c902ff
-Clang.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/ad63b1a419254f52b37188b0e540281f
-Clang.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/fe94de0c1f97d7f0007d02853a2b1126857b6ee819dad812d9ac4bb5509e75869b39783858237dd50f3cfd284ddab46564b412370393f7d3eb314106fe5bf628
-Clang.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/7700937fa4b17af97f85be8d4c78f170
-Clang.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/a5a223386962523f43235dcde3fa359509573475c0f3b2234e2f8f28b0b1f1a47682fa5593546d38cadaac99aa9b283cffc8f8fc8fb43b257e9eafa0d81297c8
-Clang.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/6cd4d351d8d9d9f4e967e7cd915f1ca9
-Clang.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/d76e0daaca853d718c6a633a4e28606d70168504e9055b06ef98ccaa150753e43cba12c57304ba0b45b2a103d717274e2cc31fb5b869395e0e0eda32fb0d03cc
-Clang.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/722c5ce1ae12dde7b2b2f1f9e38ded6d
-Clang.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/0c6224662e09ac9ab104320f4e93b8e3a9b9ce5b55eb51894efad5aae707604b57e5eb8691cd6b39f10199a5b393353e3042f87a2e0a04344f2bdeae75e17464
-Clang.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/cd1dec35e0ddb3fa344e96dc36dc0936
-Clang.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/df10fd021961ce9e9e7b7b5408cf7c96a869030e4290a9bfbfac3fae03343005ed33eceb82fa0d5ccb36e53382838261d4c6d148208739608036825b83166cc8
-Clang.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/f5ab229d661d2d70988ffee4302c8700
-Clang.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/fd6fd77f1065de2089368bb816822987f13b18da3b33dbd027b8efa393ba69abb3d9ed6395875839c79ff8f9ef65546a6fb98d1206f1542e9069a43083e85e22
-Clang.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/e0208a9170c37add95044a55eafb950f
-Clang.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/dff5eaa5719dab7c543e1da8993cac49b358811b1805debcc6ec2a115d9fbf3ec9add863fdcd7a16fbacbb980743cebb4643b36e39b8dcca4a896824a7ecd8d5
+Clang.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/669e6bc49ff1715e259ea4d60dd3f0b5
+Clang.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/e81c11d4d3c5a96a646a535362dc7f18d1be25b11304faf65b002ca68255c57e067f3022d53e3ae19e2319b1267e71da66bbb8afc0be53632c558bf08aa47f52
+Clang.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/22e32a15d23de5a4b5fa01f56c48e8b3
+Clang.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/4228e5a66f21058d181b67e4b959f84aceb2195e90af0f28908c537e42b72b32cbd3e813e9261476597ba04d76549cedf6b5aa72eddf6cda63a34df00106a8c5
+Clang.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/2defb4a5181b381201a6d16c6711e89b
+Clang.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/3386402e8fcfd1c0f6d154cd8b966f308759e13919a38d148a1ad3539e046330982eefaff074f7ab454cd1d396cb92d992dda6589fa73e00fdcb237ec1cfc843
+Clang.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/f96d1684861a5b78ec1ce22c68659907
+Clang.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/09327b84e86cf117a0e492d39b531690c700f4dbd3e1469ecd3d269fa5e788c173d62f972d474194999a12a3cf88e3151cc07ac418511207c8d2494c4e493f41
+Clang.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/dd27b64b1c8a4b66647de4dda29e76bb
+Clang.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/1fc68f4c2132eca09bb8cf9d51a1d6c223c4c705de181d973dbc5d818222da1a68eb4dc8f944750c0a715ddd73e61e7da6a4aa44c8a682bb549f0bcfe83a4044
+Clang.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/e343df2dcacf98d7366ea9d3206f8655
+Clang.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/75ad869bd6ff350c37300ed6f0ceb2815023a8132c3025eb6992f33728b3c67556a503a05613a36bb6f3be39d06256bf51ba2b710f68ac2ed18004e2cd4ed133
+Clang.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/71f7ffde41325bf4946fb71429e641c9
+Clang.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/bbeedf07ee304016c23b57b30bb9e3d9de6186805c38ada808c2f742d61b0650a40626333fe452d2491ff758a07e4ff7e438e9bb66b6a93627381ee5a772e2e5
+Clang.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/02a5e1d72a7707c4a8dff484f7b06127
+Clang.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/591265593d59938744b7753ccff22622bcef5dac9779228ec599db0da250e39082a4dcdbf76cab6c4b79e3b9b8dcc458a426d410c70f739678e4abbd02dbcf42
+Clang.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/6e23a222df648d83a871a9e70092be22
+Clang.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/2ab4e861762ebd9c6e269b8cb10b3238cc0535620956ce63da0b34dd2faf4a925622ee879807ca6af6ff808fdd7f8a1d69dcfbdd499da2cb9d35daf4111b5406
+Clang.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/a9a8572068bb9ba3d4fff517e4141158
+Clang.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/addc84d7245b000e13fd128856fe7125c9cd7d66b943867b17623d73f77634638e7a4d5417ddbd441204fe0e7c26c6668d661e7f336d8e83af93f37ea92c7ce9
+Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/82466ead7526e9f7e676d5281618592b
+Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/6dc81a93532d7c039e115173de8d6dd28cb1dbc39a41426eb477d3c9172baa5ba0a30e1a5d4db74a9793a32fb19c691daf99794a6339d47b250ab4ea9a042dfb
+Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/9add4c5f6f4649baecdeb16ce8429c64
+Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/48276bd860514c27458c2d02ec047c6eabc7364c2b6f429abc081ac78bdd2ad4c9536c501029818676d8d7b1347e900f39ad58a01ba75a1cd8c14ccb78ba995c
+Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/4a4a38af087d005b713348ac1290fd2f
+Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/380975fdecfe0a33b71dcadaa652402764f08af0bd5d9d2cffbedc34a9acc7b5a5e2c92169f35bfd7427d9a431002bbcb4381d0662c58c2d46db9e5709d0c8ae
+Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/602d51818dbe23cc36ddc60083ebcbb0
+Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/4593cc80d9ff046961f7f68c30502429ef7b270556b4153c5e47945e8032100470d74e9c9b62c34dd97fc9c81001615b10c31b171bfef2c67c1cd0574d0d2c95
+Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/e7aba5ab085a0893c4b46a4a8f0d963b
+Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/690b7623af2ca8c1be696b80ac42aa99ec006a5c96a2560250425bcc1c41ceec31d1e6396174ef5fa071ea1d6ecc19bfce9f5606cfaba2176ecb0993e2beb901
+Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/6544aa4614c5f95fa26194b4812a2ab3
+Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/4b4c5aa1449416d807cbb9546c31bba655f413f6f5cffd26b20ad53d452ada64235342c430aae5ac1faaa52496bcd097d6b7ec6027b9f6dcb6ea5cb6d0c77a0d
+Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/296309f5d25708e632866c688b5abce6
+Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/29082d6a4b1c9f0d2ab650fe0fd3e9d2085ad7225ea7c4cb7dc38ee8dfc03189a5c7b060af75022f81cca17aa71e3ff96b67255398d06db77a429b2cd0bc2017
+Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/de7837fe7342a448586a5a176bd98549
+Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/194df7bbf67fa70bf78baffecfe5438307804743a4093a5bc123cafc8085d61be9f48c5c1bda47d5b9ca65e7614119c3a235c2ddb1d311623ac92135ebcc3f0d
+Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/71036efacbec706ea6bb4124ac42aa14
+Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/f4f98648e8708b5053b7086d823651a1fd8df5333a0ea571f9a39f7cc4449ad19abf0556bf756d4e12ab5cbadca771f36bdece6087cf45e4377da9f572e4b4ed
+Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/52374b994418675552d0004c4c304329
+Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/51385ef025b1c3d06ed4db078d6458a92d3826b733051e1513c94908e9475b2a27d0a9d5df8ee3f442ac009d1bac4597c0338ed0cb06e2ec5e9d6267ad9c1be3
+Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/4fbd519b4be6fc20180bfc770b38e1a8
+Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/7807b20b344186aa0fa54cebcab4371995f8d3a4e6fb1ae43fcceffd7d20be227f43346f6408375ecbfc40244be7d0cca690ba2000a8715deab19b729e2cf28f
+Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/3017cea85ad3f416ad0ad1131562ca38
+Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/0ad5f18a3d33d849af2055ea833764c2d77d81fc5a33d41987fb4c89ac9eaa647da10d32b3a3c86317e60bfc4af431e855ba0bc2e5ccd0800950ccb77bc0e03e
+Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/e06e17cd995cb424628d02e0a40b7110
+Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/e0466a2cbf651684ad51ee9f2a34f10b12c0f114ab795b0b16c8f18d944d956101a913e7762ddca36bfb146c5930d1e8b6a6a8508517e44276fd4e21663118d9
+Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/3a3357bc382a3e32f98ac557f47ee626
+Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/bcc34b8ed6f3876c5f11b87f4779cc6106aa54055886c55d2f8d0ba420ddd5e498907b44b2fafcec1efd4cc9b513f26e09163cddefad60a1d07493b6a3c3d0ef
+Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/2a938d18681235edbfb6ebb1868246f4
+Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/6df520c1443b1750d5cb397389bde9478510042cdacead6420c08db9e80d69957a93e17c9918a83bf6c3b46d5b7fab71ba7efd52da641619ae3308ae510e9a54
+Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/304f130084074e3e4ac5d37f1c1bea57
+Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/bf893e5ab3f572e1db081b484ffcddd7dc2f6c15060099a76ef00685885d8f71b9196272c5b973014f2492cd7f94cf1e3c32b9222e97d4b580baae9235539a29
+Clang.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/c1f5add69bea21e906485c0267345084
+Clang.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/72b08d5001e713505a3185dc179bf1d2614e77518ad6439f92e6df69b6b328e48ba449865fdda20f5cd4a10482dd8c07398e28ffcec7ca29216c12170e34825b
+Clang.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/c58327d44901fb4c51bd98639be97dcd
+Clang.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/21d92e946dd96e32000ab114b29db233d41e3731a6ebac9d9c876cc8e7b225be570d3751f74c98a0747121638fc6d6e63c3c3e8734cfd53a3c056dc4aec9f96a
+Clang.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d8c025b9240ed4c8742ea8381b975d2c
+Clang.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/2631a139162c4acdf990054eef55e68fcd83608ee708a85589a82bb4b4a2e0a0e91dfca6f4b7c2aad9b4fed61fedca9237c6f55cd1cb91a9d9bfa1c279b3cabb
+Clang.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/62f5a0d34e3e39ff0832f5566e77b43e
+Clang.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/911c9e5a545500dac325faddbdbf33983862ebf2d2b55baf07f8003ce045710d15dc386f65c6a1c01a1c3500b831030ea686953b86631d1870ea4c6016784928
+Clang.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/aca138da6dbb96b923c3b444760901be
+Clang.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/21768ce38c29c012b36037ed7d5232b53c388d6fdfee81f13f7b04e4168957b2d8477b821452b8f602455899c779cd5d32e69a213fdaaa25e4e83d1e3c9621fd
+Clang.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/10de75baa15af9f99a0a936a7c1fdcd0
+Clang.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/686db38e54436b2816ca658cdd17b7f8de3c71d4f5bcca629968d5c2a11b91b55269aa506f8ba4a4f059f482804d7c622cdd92dbef445e2377f2cd1c6fe7265a
+Clang.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/c1f92df83f99e7d920da36b470e39a4d
+Clang.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/8f67d8fc779ee738ceba20389bd68560696e94497b0455b3894027bb9773ea0f4933cac6a3c4d10fd7a391d934cff0487722be509f37654736a23c3b4f3d2dde
+Clang.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/660393c8f29f5127bb32f5b1135028db
+Clang.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/a4366e839d1d4fbba30fa6599cc7cdee4d32474abb6ae5fa499e83546543917e9737ff38994bc7a9421d4fa88b8c466a50a49196482c2ddd4ab0b8a3f7556903
+Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/1689b18599e772b79c2bdd09bbf8f8fa
+Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/d7a74189addfe6ab7fca0dd7408b8b0476e3befe1cac65150a3558c6cd1cbb4b919c5f079fc892dee46b6776bad8d3251799ebb7d76d7fcaa4ef45830a551adc
+Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/33c06a9914fea54f71d3a546583e43d1
+Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/bcfbb536df4b0929a3cba2b6366d7cf0b3362c3eabd7f1e94f774a617f5134a26f3e4c41c44896c7a3e2f6c734b7efd2301de34d9883f6e2d42619d7fb9281bb
+Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/bd983991a186c350303e1108534ab713
+Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/7b96d52d66fe1bf4d967022067d5336b016947c120df7c892c03fa5b1b95a5fdbe24f220c13afc76ee25142c15aaa70000c11dab2b7e5db1445b0c73a7d3eaf5
+Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/1add4ae2faa3bf120b29a7d80b173b2b
+Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/7996347224e4b973a1174e253d022784b5a6e7fd7813d7ed47a0dccc3728bbe0432d94a89ced9e406e2ff5860d4b1646a40ec889f5dc1aec264f13608bb05661
+Clang.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/fd02d184d64e04010a5a31c1a9dd9d43
+Clang.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/56d4be2fa7f0d2f1a6d17014ac4a8a6b302a542464c733c4637b1a3bbfc2bcf42755783445ba0f272d9bbbfb9f755eedb46d3ade8252136d9f3c4f328aac78d8
+Clang.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/8977be77d1e9c9fd7d4c509fd20e96d5
+Clang.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/852290b61a1489f9251471d9863bdec6bbf179c325df6dd5acfc77937cd3cdecf0c988cc9eb02ce3ac5a5b7a44eb1c72ecb66f8cdd27b4f5b7bda237aa1ab1c2
+Clang.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/e28a61211a0ff79356ce55126f934f6c
+Clang.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/4a842bc9758d3ffba3143aabc4f4c91f5a73531565d7ed0a53191996b3e157c0cd0117bf5f9deb28a226f1bbd2a5c5bc880fb58d79673db2661d95baa73463fc
+Clang.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/31647f7142d211ce00910f806b203193
+Clang.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/15e10f67a5276aad4ac27fa6134b10b917b4e3dbeb19e615cf2691edc045029ece958a0208e347cab7c50fe0125e7b5cff97a0f73b5f05fc29dd9f4bbd439917
+Clang.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/143114515a5460f569ab2b2bbb6f38a6
+Clang.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/4cbb239fae8d8677165a3ecf8b43a5583eb053bd6861fc16db0090574c3e588b07af9b195ab615d02836e28f069341d29540863578f3455c76a109aa81888672
+Clang.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/bb7c9cedba80462c3414aafe3abe1960
+Clang.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/faaade14199c876784ecdb7a6a60a937591a6cc8ecef58a2cbcd52b7f94a9f282bb3a9ef51e1956081f1898bdfe6a63e3bbf1da677331888e164d25cb270690e
+Clang.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/477eac2f9d86be87ac488141acda2e5b
+Clang.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/205a2bde47551dd09d5eb8bed193f1b64b18d423464c5bf7379553576d88fd33c23b6d43c4ad37587373fe41d7a3f1c3e0921efa7013dce1f314e88c6c3641a0
+Clang.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/e885ef6dc19efc4160eac81e99f9a220
+Clang.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/30f6ab9e0c4b1f1ac8b1429f0e3b8d222b371c4c1198332d11268930cf425d3660cfda0fcddf0d2ba57afb74ebee1c39c0a3e92aaf1fb7564c33c053e58fa872
+Clang.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/d962d03f5a979124cde704add0e2a801
+Clang.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/d677f1abff6c06411327ab78bd5276a6f880c3eb5e3ef32dcb02fbd64efe6751d24fb6bee0a45498a0e38f678a922ac95813da0ba025d5363f7a20c9dec44155
+Clang.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/4ea0a8e61ee8058982a1a4df1b30c001
+Clang.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/ce95b6798901a84116542bf8566f520dccd5aacb4af8f8c7542abec62dc3c1d7136e6aa8922c5c2f2f61103730e7629e507acbff670b6f59ee62aa1f9a3d6e7f
+Clang.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/03304c40a1e4727b9db5052e59ae5884
+Clang.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/70467c23ab0a25c490803f78de10ae10b0afafcb76b77fd3ec325c4fecfcf03463c2b0a1842a7657f57c668811f4854776328e9af28227587f8268bb79363440
+Clang.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/461da00bc30e1dad361dce9ef79e0e42
+Clang.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/51bc60c08fb0df8a565c88563642ef4a9ed4f8bb956a18f12ff570b673f69a26a2c8e8775c785a753727586336f276c42ce25385e7a813e227a93d2b532378e1
+Clang.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/3e6d5b7230676a2c149524cba960706c
+Clang.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/906d17378d957138de5f54bf0c8e8bda505a299d79c8b34b3db5113d2f9f732535ec464abbd198504f2a73c905f9209491ba30616e99258162c5045eb8e722d1
+Clang.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/a2c0cc701b90f580700a6d60186db8f0
+Clang.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/e85533953837ed4caa6c429ce4228fa85e8b667c0212211755ea9be0029149d6e08f19b1d02cf5e69134250f1aa8918630b1623ad1ae2cd0b0e8535ee769c9cb
+Clang.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/5de809c792f82069cd68693e90ae8521
+Clang.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/b62502667136444890b85e589e3dd19153d71d23f9e989baa0cf83af09022b7ea042e6da5eff9094e50f0ba8200cbfc7a20ca76b89c251d0b887a0a970b28e65
+Clang.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4b4c3064a5e613e2ac2d558a29d34a42
+Clang.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/93739f9b85ae4d345c7522ca8ce8edb1c699d16756bec7fbbe44d5d3429a5c9ed2bd587c4ccf57df8a1758b8e52be009448db86e1de372fea02e3ab2a0221837
diff --git a/deps/checksums/lld b/deps/checksums/lld
index d78f858c0f136..c703c2c2d041f 100644
--- a/deps/checksums/lld
+++ b/deps/checksums/lld
@@ -1,108 +1,108 @@
-LLD.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/599ad46632e530e3d41ecd932efda7a8
-LLD.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/54633d81e768574141db94683d2ad1831bc49c7a796c611cb614981b24f29853819887ff0ad73acf4a48d38ab189f807f7858f9bfeac08df8b889d432ff4ef3d
-LLD.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/fd91feb409b825226419b8406d3d4ab1
-LLD.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/cb26d2222cc9c77a844e2d2bb83ffa36faf60643ad41b73050f8ab6abd1c561a592ebc40fab7d4b6bef91fc3f7895da0349457d6bfa45cca9077ae0c64d0167b
-LLD.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/9a181992b515ee4e9d5eb38e5501170b
-LLD.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/d6091bbfcb1a47259f81b9b48471aaf2fe5cb8a918e2625921c43742249a68c7dcbeccc5a5beff020e018f0c893d287308b3496a322ec727ec83608a67dfc373
-LLD.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/91e6f8fcdd20257109db232f01af6d84
-LLD.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/439f4fc3ad4b57b1987d8682886b42166029befa5b7315b20dd44fe8172806b0809a00fbab92ab66b04c3bfe2ea5f86c760dbd9990c466f060bfde169381651c
-LLD.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d7dfb72e7158d6cb7fee0a53dffa6be0
-LLD.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/96f24a4a5789ec4258b3057cb59803a1467523b647ae0bf71268d100ed3faea467e61e9a1c03007f85d76067e31d266cec2fd507a8b1f90fc0972e12296ad885
-LLD.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/4a9beafd6ba76e03c8e99d8318913553
-LLD.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/2c741974262a81796d38b2b24d3301b1b2dc4f990ed0fcd024b88968766cb9652c3eb39471b3ac0331254fdbe1a6999d957a1cb45a928bc3b34631fadea0abdf
-LLD.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/95a8d5172ef13fabd920ce5328507ba8
-LLD.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/f28a981f4dd85d182ba6c4e0319b33b254c952c83975fe124e0aca44b4a7fa23725794d8e2db62cd41e61caf2dcde1cfc69e446097d9770bb8b9518818ffdf79
-LLD.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/10a1f8ab8643c56e7a3b6786552bd11a
-LLD.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/a7473cc47ee06de07a0e9b609ed1bbc39704faaee542e60eaf19d10746ffba2b537ccbe36028264dcd9eed4ff9f62cb91f483169691315a75ecbeca5a5f6d008
-LLD.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/1d0874bc726f5dd0af9f96f1f5888da3
-LLD.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/b800180d1b4b6c1091fa4a72739173c5e14ec2def4f694dfb4d6b904ae8c6c095fe013a20c803860664e1db27acbad30f27ce163f697fdaf05b8726f10a88461
-LLD.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/ea8a617d1a806cefad6b8a37fb083f0b
-LLD.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/e0ba812d24d9700aa03c5f55b8e5104952cc8fff21b7a9f484cfb7c26a827e5df0bd3a088b9d24c71d320fb1163fe2ca94f5b3130ee540991a9ec8091129ecc5
-LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/78fa5a3fe420f5432939dafee2a6386e
-LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/69b5e35b24b0f2bc0535100ef5f976491fadc377097ec4809ab564218dae6df9f538ba71a33477f29307752e94a72ff63213d2180fa0be50679b087dff191fe5
-LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/297abafe1f4ead4d403ca4d58559059c
-LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/2ef19b5902e8a59e644e86c65f4ec31d71e72d922ee6e735fd7a81d68826cc81e1143474a80dc23c46be33d5612f712b5275e453cf6573be402195a6d7723888
-LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/20cb187a65da78242ff87660fcc080ad
-LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/070d1e39ac25073571a2f10db47e01a84d2d5e7d3e07a7e2c1383c835dbafbf8d6f3d01a1b33bf9a329458c083ef8ab0b8102b3fb6f6bfcd980a4c908034d692
-LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/fc141dd0812b749382b45320b27fb23b
-LLD.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/dca5cbc7d93c3520f3f8dc8e249c24fe883c5738b1091eb168ea950b8c56b488e09f2043cd8ed2c7828af7f4c5b65110e39da73047cc859521c6808f92a6a2c1
-LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/5f92376c38bffb13ecf3cbcc9ff92e87
-LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/2bcb960ad48b280f37b15f037a3a1fd04e1f8603d9be5a99f5381eb1b1b022e114b670b4cbe74d3ace1bb29114cb20ea7bf580a81a0e8b547c0f68a79f55577a
-LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/b78cf01ba612f8de427fcea38a10f603
-LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/8454ad15a7999993b1bb65d9126d1e53da39becabf9e9674ed8e703d2818217ee008a14aaecef69b381e9fa964c2ef280c77dbf90a2b3015cfd20591484d8e9f
-LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/9f5db6e6898e469aa894d23820ad9bd2
-LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/ef11812d924cbc4b6e3da162c366d228d7c0b3e3c054f08a7fad749cdc2e8af1f3026d55455fc3a490e41a9caf353b69fb7288dc967a09e9c6c066a9a4b7010c
-LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/f1c032083add023cca0c5b0f17b5c8b5
-LLD.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/1348ddf226850a4a87ae49f11186fc4ffeab1ae607211c82b67b9ea1923a07bba8d41b80d26ff72653999a69fdc96020d727a1d252c3376e32816c3c0714735b
-LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/7a9d3124554f9d045cc4af96f5547d06
-LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/1f42fe7d6fd487fdcbbfa5547a6f740874deb6ca2c5e78a3a6c1f0982724ea297f300044d0c07157e723dc1c9c430b02c32b0a09ae28d4d8bdf143ab40bb098b
-LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/fd67bd4a34b3ac3786b3ae736fa30ed6
-LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/853ba456747fa93bf8503d884abdb4cdca3b4a2b3164382fc3a0392fbc87753283851222fee184fe776d0b7eba0a690933975d630d5ce9156472ab81266f2414
-LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/182b420234d92d07f0bcb3e4916de673
-LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/d30840465c94ae4187aaa8946e5e3d664302682b0e5078459c80f8b094d58c38461d87fc46c0052443f3eefe8d043d3fc52c75fb42a4ee8fc072dbd27cb8d5a4
-LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/6159e0d2daa9fba0c6e0c47f5f47dad7
-LLD.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/ef8591cde887860d05cc6d8fb055b0c66ccb3d157f7debe396cc7cea1e7af822561919d00f99d7cb65d511777d8abcd6754cf8a0518aa7137f8c3dd8907a4b42
-LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/6eb77fa6378392113eab8dd513eef598
-LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/3e6fb326d473fae9399a43515b5fded64dbbdfb21435b8b6066177cdf2c0cd50a6d8531a4115a98ecdf69829d55bd9c456c546906c5d75d06840d68fce00c29d
-LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/def219edbe028b64f82e88c9effa0a65
-LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/aab70b8978ed3aaa1110596e1d01e7b3df6484ae29c5e9b6cbbbd45f515da3a47ddf41d7296a5d040410befad1fc1e3505501b699a51e340c5e43a15d78c999e
-LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/b12c36519c6d347944c8cc6b112f13a2
-LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/be04ce4289ee682fb922a71794f119f2834282c0d20e432469ae7646d8565b1ef5c009af7a288b79aa1c5a84363b5a9dd6308fdfd6ce4902ba9a15160ec6503c
-LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/51549d01690941f8bfb9111b1f02ac50
-LLD.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/fb029c0a7711b48292a265d6dafb020ee8675a43eb6f1317e7cbc096bfe821bba6de61b91fa9930edb9ecc4d16256a712dd2592164f6426a4c1043646eecfba7
-LLD.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/eaf8db25bb7172c5f418659252144abb
-LLD.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/26b14ef2ce784732e0810be4e698f209818d2353b9889d810b5b88ae2f775186e2b4577c162c10525facddce6aa3f291ab70ce1fae614889dd1738c68cb07738
-LLD.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/868692166c1497b47888d11b0a046755
-LLD.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/9087d10cecb469ae4eb8fab2914e6bf5a4d0ac2c7caeda4b1b8148c63260261675ed1153df5aa2a21ae68f51e3d3a1ac854584b645543ab16eaf1085aeacd822
-LLD.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/a97ce7d452c937639053227a7e9f35cf
-LLD.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/26d51d873b84982850c1c92a7bfc2600b375ad6f2318c32abb99d4bc6982102ff16a8df910d57c65f3cc7374ac9c35350f580c32390f3c7d2ba559b2ef243e43
-LLD.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/d4da8336836b5f3583084941186c1cac
-LLD.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/112c92e2ce81fbbec223269f3a528184e0e37842e67c53b1f58ce576a9b2bdb657fdf6c354492dd58df77b4f7d7a07eb45ad6aa069bfd921b336b49dab485f4a
-LLD.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/19d49ad6cbda589c649f4ec8cd5ec7a6
-LLD.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/9a6d7f5e23987469048e796266eb311b545b491b12698d24ff701273d78176e558c38da4b95a82d8823dc7bf2ec30fe31877769356d30bd73322b13f80256d54
-LLD.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/efd34e5a69b5ea5678e7cf6ecd8a7ee4
-LLD.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/be591cb32ebba4f67e4c4dfefd379a6fad299a27eabc76a94dd3e4fdc4de7221bb804bf44d10048512c3a3708499300a7df90389b586ab74596141592fbd2fb9
-LLD.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/1f1608b98c97bcd48310c7d09b110125
-LLD.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/4e18dc55759aa9f983a8e78d85da6eb9372286f7a4d8e251fa2a87e52d011f643e74b51114468d3c85be15bfd287444716960aab6ac86f8639b327f6c180543a
-LLD.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4bfe149fe223a20c7fd85c6d5196c4d3
-LLD.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/715c0e919cbb3df22d8645ad086f34d58d33fcf3e0424993fc1eaebf9af0c747de711bd7e6234ce99c99a639d584802f8e2ce5fb1170a93adc13920e804288af
-LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/42e37b0d2147065407afae53412cf5a8
-LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/5fcd94a924d2425b7dbb1d1557e5f1bfeb4541f2cdd665cf6a3afe119d6503e5c362ff427d41e05360c584d07ec36e330311246ec06bf6e8e079e9382ee5a067
-LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/f12263e627e5f054a6cb5d95cc9c2976
-LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/784dd0c01c1e911e40809014df2672264324762cddb60adb0a2dbff346613d03535407a7b9a0825ccc09ef6b4e0cfdc46e572c2bd932c4ecd99427767b54531b
-LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/8b8941c2114fca20dfe4659ee1d0c2f7
-LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/a0ef72140f71b9a206a3920fa0aeed494e28f0d39c27b83294391d95e2cdde1457c3bce30c0846c298bbd7f2cf87d1a31b1b28c0c7962412a0e60313470281bc
-LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/a3a3441c845758f9789f7e399f64ff74
-LLD.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/ed7496049dfe5b54f9226377dc4544ce80583bc6fe35ed3b673b0f9650a8b236bf6952c001903756109a9df4d1965ea80a73b2d8aab03d088f8a54a0309caa5f
-LLD.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/1e46c787e795a17e780e290a262865d2
-LLD.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/665357e8524e726582bbcf141c32c1ecd6a650741065a4fb3893934f23c7afcad11f5c8a931dadbb031d302d2dbb1db5df8aec77210e685ba7a80e35bcc96c99
-LLD.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/67b54e07967803e63c67d5a12cc1eefa
-LLD.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/dcfb4b57d3875c7235195023f71eb56c7f4a12d3251b0d0ab1820fb0d93d9ee22b4456f51d09d4d332056ae70b6cda5ee0bf347306d81180cf0553497caf48c7
-LLD.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/208fa1702b2165e3e95f718e23102075
-LLD.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/f3acf92eebdc54dd648c614acec9aaf9cf95ac8953f6b1b5e9bac89afc2f936924ff06720249ac49c3efb3f6a18cb17085d0aa105d1c3c1b83134b748b38a04a
-LLD.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/c5e11811db38163d270d368d46571e7b
-LLD.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ea4e501ce8ef58584e508537552a2ec6d59b8ce411a0cff87efd064f864ac9a822139442cf6dd3682aa5d4bcc4e29b64f8a8521d17640d139ce90b6a19c932c6
-LLD.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/84cdeeb91c53c9186da3d58f45cf16f9
-LLD.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/9fade260fbea23c09d932c481f668273a90431a129b449c3adf9a99bda2f7f1c0a1dd4abaf451736fa1b14e37bbe6e364118049df09f27a72679a815f793201b
-LLD.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/587508a8534555017ec9191608a214cd
-LLD.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/1bca07c8105d9aae4e98e91c103115939a5122e615770af18dca5d894d4dad0c79b3918ceea94044098627f2cff467f3085df3f4614ffd93c64e18d2169ec30f
-LLD.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/717b88f92a660358590c5988c3b08b1b
-LLD.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/c5e911ef190f6ae26c3d99ae1fc4949a154b833c7457b108ed0b94a85d395991bbf5ef04793bb2b2e5b9da213dfbe0a20acb1d6e17c92ac9fe304e06aaa822ee
-LLD.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/02ee75b1b1771c4019c513ca5f9cc682
-LLD.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/ca71528db12fa4eca4e1ef34141fe196712c5b869eaf0bef04232102404331c6e5c0252c4bcf90e6b44b1c12bfb95306df91e1b5f47e6f23384cb67394accfbd
-LLD.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/7b1e478eae99ba2c5686949465e0d511
-LLD.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/362c9e62e918d654c986a94c7f94270bee772cfbc002ba773c1cb20f6fa1f2e62a75ac970990f47a6ec649799e7dfb89c7860066b4d13a5fc3dab051f36f9003
-LLD.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/3590b32b2e5f719060db43603fccc24b
-LLD.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/b3dc31ae9f9469c1123e6eb2c21f7e3786619a29d61b99406fd582019c40ee5d25c6f905aac1df68109d62bdcee3a19ffc97b54e39e32bbc152cf71133879077
-LLD.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/72b30e00dfa370f4640a83776f46f12c
-LLD.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/2c136c19fb376d0dcbfac76ba141a3366bb7cefc5241d8be61d8229b042268191c069f68d543b48a24583ee807e42176aa0902a2a39fb313e25c2b3f64545303
-LLD.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/694894b75e44b967a2e23f4fe1d1d7cd
-LLD.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/7f1814967fd59d89c797a8bdac731bafc077b2ea2735860f092e5c542356f7271983054638e943174d7e137c3daeed1997fc14336071ef2e4205094ad080d874
-LLD.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/6da9ee2ac8adced1228103a504ea2949
-LLD.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/a9ad116da319fbfb35b0355464569763d587947ed95168dad99e74733e634f0489cc4e882e7c3488bdaaab5390e955d4e660d3fbe089bfef48117613650ee1d6
-LLD.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/dd9f8c224c962e2d98e23fbc0820acff
-LLD.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/cd0706b32cb598d8d84e70523554faade0f549c4814c992358f9453890ca66ac2fbf686dd76d5739c24c56935664d96aaafd85ad23238e83101f8c5f6324ceba
-LLD.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/a09c1fc7f7855679578330f250522fa2
-LLD.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/4768d9c73c6a5f45eb7ef4e406e21211ee7592825ecaeded49a2b1858b1d58f8d460bdd1fef1bea7213a7eebf4e8a51da6b1f67824ab4bb6e286ca95494047d6
-LLD.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/d875d699afc8e35a3e660fa7c7cf8aee
-LLD.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/e93b4edf2fde1f6396315d315827fc3ada9906178b0c278f0197657b18f9d8d647116266a4024b3c1ebf39af1a6d74e8ab6d99dcc43654f9aa3daf2d554c2ecc
+LLD.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/0e1fb589a6f0d95c4952c141fcc6edca
+LLD.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/f6f3bf38d9263c26f25191fbf8ac867167afdb700055f5fe34a06a1759fe2fb39a716760839d91e55a8149ff96a0821386aae8e5e0d4953e8a4cf9e7e627c4eb
+LLD.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/4526e34074b99a330b0bd1cf2f1bbab7
+LLD.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/24ce4daf534084bb20f123bfe6c85cd2f706f552262d831de34dd393d1466e8cd905812f9f1dbfeb394401508240a66a397c006cc7bb067d6a6baf73dee168ee
+LLD.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ad127f66681d145045e47076d8d8e962
+LLD.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/b63aec7e18f3c92b9f098779fe04f2bde454f981b2d39ac688ed6bb5ed9f1d78a00f8f5607bcf57bfa2b7c7e85f02ed405802642c9567acbc64a3dc5a430f226
+LLD.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/83945b3b814c496fbb0d7351877a0fb1
+LLD.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/3243f222dfc7dca9878606caf1593b5776c6066ffac25a195b9624b532fd5cdf5576faccb26db802c36f2d9bc3c84cfc62a83c77449d0056e190af1ccd0239bb
+LLD.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/aa335fce63e6cbcc7018c56d7ef16a78
+LLD.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/8d82a46d9f2e428a745687bff5b183bf91b1850c1e815aac56209c5a8817dbdc8d26fd0012917b5a14476ad8ec6ac450e01238da9024637b76be2899a1ca04ff
+LLD.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/56cc8663e0390eda08d05a491a172c71
+LLD.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/dc056292c94b2a0619eb49f94521912c5f3cfbb9cb00bbd7b701a8c6a172e50dcbee719bdb43622a0c8fb32404d742efb416dea6922a3799af9ca7dda0400fa6
+LLD.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/19f4bddcbb68108301580a16b4cef32f
+LLD.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/1694c0d7cc63680f7c04b22a5d842acf3f48568e682a1a7acf29529ffe9d6ca027c33f9ae5cf4cdb1b703d28f30a654bd1f4e0586eee49ddf64bfb40c8a9206c
+LLD.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/eedfa092b0f4a2867cdb5bd4102a27d9
+LLD.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/dd895f9c5d4c76186c7d2172f56e1052f2b8926466fd0deb725683ab4d98b85b695b7d571f076bc6eda679747946ffa380e1c23f497ed8cf1fdbde89132ec653
+LLD.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/d46f65ed03a071779bd5277040905721
+LLD.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/1b3bf0d64ab0481b11f6776a249c252622b23f125eaef733dec4473ced554ba6b876632c0e4855d0f93a9e4eab06cbbfff8fe568661f569a08263543d8ccd930
+LLD.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/05ae31c675789b5b87bf800e971e8886
+LLD.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/02342bb5a5c78f7c876bb75dd0c9b7140b4e41878203469a573c190baa2be82ce64101bffb93524b24444a69e15fa6eabda8f7f006e934595e52c97d4865faa9
+LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/46ecafa64b02b6a72cbf33000728e023
+LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/72df77be62ede0737f2c9bbf58fe617ce8358ce3f08e3d3b9fbf8aa29c0ab4db4eb49e426fa43156d05f9f8c83b974594026029e67bf8a8fddf6ab33b1c2126b
+LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/ea36fa4169f9862db75bb1ff19b45645
+LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/7795affc068e64a5c3b68e9d0a773d21acec68eb2a4fb28c791938c993d0f0f8e9b1ce8b16cab3f25a48c2d7b8097449831f2e6340af4b47c59f9c35636e23b6
+LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/ba2e078e52583ff43f3b840e3a144726
+LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/0af8ea82206204ed515bb6c222d2b51a16b360858a1a4c9db7b3749cab79e08a9b0a91b54b389a19f0b40586d0f0ab3665fd2df415a90aa401728d592c9a5716
+LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/4f6c8a05367f8e70f6247f667737bc79
+LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/f5ddaa2c14dd6fe85456701d60f279bbb30f2d9c63948ec3212a2fe15670be11ca8db815c914cdd069cdc469e3ad37d848220c7d5e1feff5ab6913a94be22d17
+LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/758f27b74dea4231ca5ad4bb1eb812f8
+LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/6f378dc8ab2a4b0f59a8107ddf6ef10ececdb03d616b6ba1741dc9ad0b7d96a8d506b45b1f3129c6f58b9ad8b3f97d300cea246c6687bedbe2b2abaec5738e95
+LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/7491cd8edcbd4933e0e897b2378e4f96
+LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/ebfda1800a564de252c1e0bfa8ba505589cb15a137a731df927449714379c64478d51d08f973f59d29274eac66a205dfcb96d809b4ac431e4618d68068ff02c7
+LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/23303f8b1baa11890f92ce44a1210706
+LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/45f5f696f0b4cdd3491c8601d24576628ac9ddea992ed0ea969d38389f50b547835b2b74b7df0b3710b8b1048ee11665c9dc40f6ba71aca428dffc81ce716b11
+LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/d46db7e7e1c7aded195d6eedb280f21b
+LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/8cc4958e9cd55ce3180b17fe171446fe222ce38c76778e77a34998eeb3f3fea3de09fb2590c2f4c2a1015575c1f5e1a37356695ccba0041f8381a2e4389563a3
+LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/6892dea9c18297dfe41710092abb1d01
+LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/c7841b05942dc5edef6002e02452651d74e85ae4f8b575505e9955949efb47ccb8447a9157b52c88686c4334842fecf415912e228c58a2632002a4d1e72af0b8
+LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/35525045309d318400241205333f366f
+LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/a7176919817fd94c0ea39c4efd53f494958441a53c5ca18e0932f77b66a5a5aa7b2b4801ff776deb45161b6e099b5b626a83eab5258e9648307c8010b2baac09
+LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/087b8f9b88ddfd488e196d6e1b966e45
+LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/68cef6e1f29d18e92ae70cf9c6c4e21c96b4ab86993f58f7addff16281debd50051dad828bf18b2ebe297d03ea1efe16b8fec3daf9f8cc33dd6124e77db28134
+LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/5594492322eba79eea3141e29a71fc28
+LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/3745179518285c1e30ec4c554c6ecb630943985796e62713d85de79ff0d4585d790bdcd1d2ba50ad12333671e7bf45dcea09f7cdf84bbb25440348203f4f512e
+LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/c751963cf072766374881f79cc5de719
+LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/22d351e65de75276969c1bd9f78f8873878ac21035311fc138bb399c250e45d3c689bda1d13b00f0a1c1a93afe90292be749a0184acfba5bf2a17a2f9aab0c60
+LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/03fd8f5ec6894645206d1e8e1f2939ce
+LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/025a12586a3370d1e604daecb5eaaf6b3300fa8c57d68fb09cc39e0fa5c353160be2c1493fcbbc7df28a6c345c46731d77422a282cef7b8a90d0df12739326fc
+LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/5ff5a4efb63282ba6e08663070c030e3
+LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/16bc7d275079d10ba197910bd194edd4d67ba29bb8d86b110cf71658b10abef83c9ff37d5ee366a015302966382705f79c77c810ef9e37e8ab25c3e5be09c78e
+LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/e92652c998ce524305d1af766f12b273
+LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/a451ee76668601477459a474265d390a777a7a985ef976fa430766369d378ec71c32fcdcc8f99066fb6fcec8c56fa0154126d9f2d03d4d19b393508f8e0641d1
+LLD.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ed523fd79f3f2b42d1f8e752346906bd
+LLD.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/34053f32db29857315eee9dfcae9067bfd517c42e761ee3e56218a9439725955a673756eb593ab2aec3d0b1eabadf0e4011f4a72fd1e14938a6bed0cd6592cf3
+LLD.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/6c6f042e199db6e7fcb6fc9d877e9d4e
+LLD.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/b884c46cd26b9312a7e07e3684806a42263635dd63c3127be7ea8c0ad3c76c7de4fe089da73f58306d65689116c7e83de73fb06533b322ba5eacdcf02241140f
+LLD.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d2516d66916580f58cd2d79bd3372faa
+LLD.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/0204064425018cc2b08d0f8bceb5f73f7823f3494b9200fce64de600c653cd28f9b65634a45d50e9fa1ba5b19d2182d3f599425e69ee38dd08effe065e5db2fc
+LLD.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/5f27602a98ef1a642fd1cf49141b92ac
+LLD.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/267a0c91b1c9c44fd4bbcad09a7db13c94288368f45763f11796e575eedddf5218a17405eb737647c552c2c62aaa5761ca069f0063bb7aaed9c2c3d82f13f1d0
+LLD.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/07104f4a51ade84b7e2d218cb2e10c5f
+LLD.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/a22de36fcedfdb03f0d73c8bb12a1d4541d76a4b1af5d15c6b6f943b691c26cdb86003581b98d57bdcebf746d901e15c2c2e404fd0569846c7e12107d0280622
+LLD.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f0e7f72818dde68f5b0ca858ce1370ba
+LLD.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/a6d010fcefb5a20cdeb328b2bf259b7c380598b488c00c4cd11dc5b3040457829e31979da0e7529b5a613257af6b95e666bbfa5c0ddd6baf97dccb507ca823f3
+LLD.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/2d81caa1f5e04e1b99d1e64c204ecf3a
+LLD.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/bcd5d9442aeaab69390b36f5c3be112dcf753fe57c9bbc36cfec35a7e17151860c421bd5bb30846fb4d4eb690b5de1d85f589c4f1b951e50838fbb2a2216fc97
+LLD.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/eda482cc028138e1a3999a637abe8a25
+LLD.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/19cbb8fdf828f3f38a91c8e33c4c29bf21901fb344020e03903591c13c22fe4093bf0c78a07288d1edbfe2e4a7044510125ca5007f6eb0e9da506bc72240501a
+LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/cbbe928d4453ad9b2ef7852a79a77be3
+LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/31e85d5d253ea24740ff0f1b784a4eb425fa8a39e5c816f7d62eaa8fa68b38cdf4d4dbcf25136bf4aeacd35600ebce52aca535251af64c41709b9993162aa97e
+LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/9ff5f80c86c0ac582af93811d51237cc
+LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ad97304983ff2b5307ca9dc41d642bc5fb20be47f93629b92d977fa6f9b989f7234360c9b8cae07f8bdc800fc3b3f9b9970f15bc2b552dbb62072a12e7e716d3
+LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/f3d9c3944080a14bbb728e672958f9b6
+LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/c741c0f11212773eb8a98b43ecdd67a86ca58afba5c1a35055f96ee688f2d1b7d7ebdaa7532131497b3b943f22c4985eaa9330b7efbc7f663b230f65ab80e2ac
+LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/99a5bd1365d968249130a0823e29cae9
+LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/018f80627982006ae5ee21251929a57e9cd69fbb575ab47a831a889f8b87769357144385ddd575a7943c11221bd5c59e02fd7ba861c4bb40940531dae8735c8a
+LLD.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/063171318971a85982d02b597c1ecbca
+LLD.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/4bdeddbe74994aeccb8a24fe0255271fbb453e1e06daf2f34389770fd9b5ed71c88e50833ffcb44a052b886c8aaf38dcc5b90ee590d85a8479fc574cfaf142c9
+LLD.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/5bb545b987ab4ef00b7d04fa70c493a9
+LLD.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/5adeebca1e5923c0121117f5cc08eaef3c798212c22b929019ada92fe545401a27ebabad6680470a720cc9a9d2421cb1cb24c4e524ee4b6d9e6cc453f78f2bcc
+LLD.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/c9508e437190c2448a0561905910c92b
+LLD.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/a07a4dd7ea2bf59cc3afeabc488fe1b8f729cd8eb6572421b94693c6efd8e7163113aa5d392767e4eec9083fe6e667240dfbe49ea7de9f1ac7051ab478af5435
+LLD.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/ea8ab6c04ddefdaec0a1273db6f20700
+LLD.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/c2ec35d58a115796aecdc37f967539d70138af22ea738b7e28d7427cc556a4729bd57e8971189e3291d5c739b4f55f4607680125bb9dbb6a8289185a1464c126
+LLD.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6747ca50400f608985d8e571c876b2a5
+LLD.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/3df9f8a361290f7a78cc20588cccbb22dd2eda1d9709568eb468008a345594270fd7df6c5c7b22bb5bd6c8338fccb508b7ec1b7e1dd855092bac2b25a954c3c5
+LLD.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/38171d910690cebc8e6caf53ccae16dc
+LLD.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/d6073f4cdfa7b291ce7cff44d4978b0258c0a81f95e563f9db9fa946be64e7611cc164859aeed55929b174fd9536bbc213a41605c12cbafc1cff91c38c9cc26b
+LLD.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/7f8f893ae41c0bb12c84f60d6c9e9dc6
+LLD.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/0a80b6e351f4efe79796fec98adfaca0b206783b38333056d35be1d6077a09b6fb00ea0e33daf3bec9261b31b1c024d545e5047507567caa925c9abd52660ff6
+LLD.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/7a7db99f2d12c8b73eda81d06116bebb
+LLD.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/09e99cd7cb0200296c6efc313be2c36635ac490f5d4100c62e830dfb40d5064d38430435ea9df7e49dcb1490f4d31fbbaaf706f21eebc0e3c78765db7e376ded
+LLD.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/674055d6ff38ba166f9721647841fcbf
+LLD.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/5ff89cceff288ca9df2ba35a8acc08e75204c200a2204c6d5f2ffadadd1440c18398ed70c4f6a0133cb58fcdd5d95e4f67f03ce4faa4661c9d9e4965b1c9b38e
+LLD.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/a30fbc6a5fa69f879d04e47a94e0b07d
+LLD.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/394db6aed33be75b7783aa0c1f98b678f0f96cb16946dadd1c143cd4b0378707d37fd0b35a4a9687de91ea293635142e9c433befe9be7fc2899612d48b94ae8f
+LLD.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/ff14d881b50746ff4be6642233091bc4
+LLD.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/6918a29cabcf3d4fa598cfc8390e534be63c049f8c69157629a0e02488f09b461fcf7cab5e0678b38b4c5be6d80a45a70b434889a7d1740100edadd3a32dbcb9
+LLD.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/2ec3ef1bea40aa16de080605f082b616
+LLD.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/1d69b07dd179b1e146c4df8879beadd26ac5ba2c1fe0052bd5c40f0788f274c9c2e4e53a53703d95298fa889d2470197411c867247284de48834e7440a0c7977
+LLD.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/21e359427a484e7876f4b9d9145b0273
+LLD.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/d1da7c1740f1c7ac07247b554f7cc76a64aa03200b44e41d1a10d66458caaa466099eb82d8d33327ec77eb784a5be91454c17d20c2fbefe049a128a2bf0956f5
+LLD.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f2975d69c12e91660a84df715f971130
+LLD.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/8fe4bfd7c692c66d871f2f0c67a8450076d7639addd2874cf6068427462a8656da96fe7c91bc93e5f0cb016ee3908e1b70c5212311f65ca7f0dc64f1f921e2ef
+LLD.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/1e9103f812fe163e2fc6c868da4fd9ba
+LLD.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/e75bbedd72cb5f0337dac014d78d1276992a6f1d6c8832d16bd58ef83b2cd8602d023b45e1235e96ccdd13300e4b67c28f0a17cc0b9ff1ccb89263105a9a66db
+LLD.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/b664032e83cddee3d1157f8c670ebe5f
+LLD.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/d7c36b0aa74b5d36446bb0aab413e4e12f042532d15e55eb79a807efabb93e590538cfedf7e3a6abe33da3f2326d631c2a041da2e00dc4051934fed17aed0c4e
diff --git a/deps/checksums/llvm b/deps/checksums/llvm
index 199779c304a9c..7effa4955a5f3 100644
--- a/deps/checksums/llvm
+++ b/deps/checksums/llvm
@@ -1,111 +1,111 @@
-LLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/12c3fa6093cc5653e5fa26d13f950dd2
-LLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/f71fe6373c44cf5671c31f01a373e166175f504bfcf567279928fb9dad2bdbc713d5ebad23f907bd787c6bf5e25d92978b9824d296ee7e7c5611b7fa1d48d576
-LLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/3309cc37575d6e572d0b2029eef6f79f
-LLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/8fba3a677b50793a0e290d8ad53ac4a084016acdf493191669da4269f725e66bd637b63658fda726295c428d53e8f89d865e2f207e4ec3e446e24c8aa9d7892c
-LLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/aa6636ae57ed2994c4c5d6f918b876f9
-LLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/76f27ba7ba8f5fa74f095d31563ca471b559e43b646e0270b721eeaf8e182f41575ff798a7d05e111f9b3ffde6bd487ca8634e3e8f2df73b543666d59d9745a5
-LLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/0d72e13578776a16e57f65e11d87af7e
-LLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/4c217e3ced052226eb43eedc15dcfb21740d36599013bc960734a1cc97abf82198b868181cff425a1a8f5483077657fc36634d6229bac69d13b7bb336c3e3ce0
-LLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/b95d26632c61c68669238cf4f5567a11
-LLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/b65f48ae408e6307b8dccbf6e274da5dd06ad73c25ab1094cc415bb2fda92ed703a1e95c2da44818cefa771ca2bf8b61f465fc815b5a916c961cfe75c44256ab
-LLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/f3c732d4824703770a41dbdb482e95d1
-LLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/0a8e4d5979f4fa560d6c612749848cd8d7354e8b5e621534153f025c9a41eff49ad1010f97938883b4030d7c0042505bfe7cfd4e97459304e3fa18889ba956af
-LLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/22210cb1127bc92daef20200ea8d97f6
-LLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/0f7e8732bcc7b312fb576fc4ca325474db352d82bb6f28f2e559cb4ccd18c7ea339a023c01eac96841a3fac352938f20d4854e7a81774f6b87611f5d5df2c16b
-LLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/63080de3607a2b6fff38f3e0ade67c0f
-LLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/b3ccfc3c9d7c58682b884baa6f19f82394bb66a242c6f6faebd19dc1fb644fb67353f2eb53eee166fde39779ab20b5e9e0fd578a3259cf4a167faa9c25ff97f5
-LLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/2014b5a49dbc9d003a17a188e2ca1d28
-LLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/fb550470378248d64db4e7d090be8006a9b733fdfb7b1bab06b41d72db070212f45e9c2657e250cb229971e95a9113d97e0b5f7b4c1f10793437a61ea11e2a86
-LLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/eeae2d30c3d5be04fcc6fe9c015b6e26
-LLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/4dc990d49cf20093da21aeeeaa5e4e70357c6e4e65c0ec171d245efa49ec8dd969830a92c5395b976fa65a9935475795c63f7200cb1a5fdccc444bb674944bc4
-LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/42481abfdeae9437e20622b292727ce4
-LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/284b967aa9318c3beeba7db40c57130ee820f9c654ee98cc3750dafda0db9fb3781d9dcfe5ef9bb6279c4c39438dc598322bf13acab6f564c845ebf96e00568c
-LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/6231967cfd7d647c2dbbf8212e09fba8
-LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/6be1bec2355c3f433a508c4f7e457b56be0773eca1f5a1c4bf3dab3cfc88c36ce1a733990d0f97d0d9a7d2fc4de3aba7288d4d176e07571c8d4b166dcfab0f5b
-LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/9710043ddda6a2e900973f55cfb8cac1
-LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/4572625f82ab882d2f87fff18e95ae61f25bc30479dea1b59e4eed8b988248fcc7545d83c1a79dee404a26f3581dbf3da1640216e01cdfc33ab52f5da4fa04da
-LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/3edde791f05f1a21c78394f8647d0cdf
-LLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/4af32be3fa16b42f75405262c48cbdc79c2bfce8d0e7340ca5fe0a9729ef77ba79233e676a6b42784ea5e93f75730d644f9e11708577dd344de3e89cc073228a
-LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/787c218fe565eca2ec41a4b48e9dc684
-LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/2a98c6ab6523ece4b1f73fe5182e6eecfb7685f631a2db5d36bd081327828a27e73bcc483e4513998cfb83e65fa26ebaff983d8ab6d85b44c63150ca275eaca3
-LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/edb0b203c4375c18d3f2639e58817951
-LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/1e98eaeaa81c0a0cd0543ab673e358998ebac3fd461d91bd81b1373732ca79b585d1eb5554df452552e9d8c7a89227f7eb66b5e4e9cc32924c6d5e018e0d596e
-LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/18ef443c2b6a3942827a0ff9e7a41925
-LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/02709b7681a467571100e57749962816bb72521002179d00112251e0507fc89e4f99564285fdb57b11890cc24b395a659b66cbad0183ab376b6c524d74cae8e3
-LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/c5df91221776250134147bae07fba6a3
-LLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/32278bb44eff6ea69ef6b57fc1bd7c3d5894e8ccd411bbd94fac649a567bd51569f0b116349afbcbfd99bf2eeb04d34774e07fe2774890d7676cb1ce552b28e5
-LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/313db1d794cc09c3a09b3d484e1e4998
-LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/3cdcc3d7703839a6d9a1e5f91c96ea04f9308e6706dfc0e62b90f7303224e0849e0fc2609f8de72197b9e0c7b6cd0053f5702c6d509ccf09aa1afc4e5c4a2510
-LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/3eb4fd17af67901c05c35f0239eb6c40
-LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/802ff440d24ffe9e3a276e09c103911569aa6d4fe22d2d541e275658d82cedd65a2af49d10761bbff34a971d1d6d63de59c5e3010c9bdfbd0f1a4123b9a9315b
-LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/46acf77fe40b1c7c2e0572fdc6de3d08
-LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/17ea32d6772ca4382386922f600518ef27f6cc144e9aaeeb5810aa19f39fa2b5d64baa6969047168ad185734f4093acee4638e79c2de8b036b0c14e3f34240ba
-LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/e89e0d5b3c6a1204257e9d1a4f48280e
-LLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/08872b5a85463880f1ae71b574b9c4f631c9c466e12d5b268651b877ac3f4544af71ef3d2d5610159a8b67c412c5b9c30d9771764be8e36d6d7a4190b2c9b549
-LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/603eb573cd8892a96bfc700c62a29f70
-LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/486398c7056567f96a398a9248485bdb9dd11c8bf16f22c03052d19dd15d6abc46fa5bb3fd4c65ca0875e51e720896ca8d07b121a97e918b514e05238172af98
-LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/c26795b166048daaf4791337d31070f8
-LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/9739f8281c700df242acdad74493ee3aee33cb72af4d066b6866485e0dffa8d988435a47349acca1de89e6ed6de128ec8342c38606b27d86957c8a5a8d6c8adf
-LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/872456e07981deeba1813b887112cc3a
-LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/6e8410bf106bcc015ce59d716e4f20833c3711e509deb5687427d6a4c60d2081192e05185d95a1f1d3b9d5b9c0b3e66af6fd3eedfb35ed2caf6ce392218e8d9d
-LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/c1c23e2934b5d706bf622f5442bc8288
-LLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/8df50c5a168ed70483738ed6c8af2ae41e99f955c2dfbe664844df70b5a72ecbde1c6df2c92abd8e3c66d9b12d8d356e0e812f81f4bc8a0abd33f674c629150d
-LLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ae4281c07b0bd6fd86f575485bac7fd7
-LLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/3b9fac037bef45a6d4807ee8bc92dcc243ac7e773db6f13ba1573afd21e3d7dc87261b692f8ff9f6a9ef54ffa95397840945f9e2f9cb4fdfb076cf3c7dbce0d1
-LLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/5f155150efbc0928150bb8038d2f8376
-LLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/42b369856b1349b18bb6352a7e48a09d89461ccecefbfd1ccca6e839c055181562430fbd6c3fc799e475eb3623ff0ed476ada528751494053fa84a28db7469b8
-LLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6625e69f2053ff151c681b54a5b4f066
-LLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/e5de111a1b22b01c4cb1072f5e30dc2e8df95d06f3c08385e525679db6cd2f54c5298589f1674b8f39268feaf5fcaeaab42558e35f37e9f40dcaf217cc4f0d9c
-LLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/00f8b33c8690104be0fed932224b5ce7
-LLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/41fb024f6568f4b444c1572b4807460d879925729eff64192a3a2f3ee3039da2e00cdc2431d47050565f817d9e0509fb38f9efdfe3f7f0c600566360ec29c8eb
-LLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/57db53c41f8368ae6e8af099395aea4e
-LLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/e0158df4cca8fa133c7b33a1a48b64a5d3ea459f2d4dd27baee556790a7592616ee903d30ec9b63e8ec40dfe840ac694d7ad954ce875583edd91ed7eefeca07b
-LLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/0c397a2ccae8e682b373ce8621abbffc
-LLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/e6dfc3adfff2bff9738ea1e20bbbd1303837a71bc1085413a89d6c284191656e407c873e47f856261b1b0af24c083e4ab167353adc8a5b10d50a509fb40b0d74
-LLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/80cd9387365f58fdb1c1a0a0671b0859
-LLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/64df0443841267e8b049f206445fa7bdcaab82faaa257fcb580d66e7acf5afaded3c3345f2c1568336906432e43eef95c09eec9da5664af5ec5e3d547362280c
-LLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/d02e01273a853875e96e11353441a8c4
-LLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/2f92eceec6fcb1523e0ded8868b30a2d48a1602a2940c78db8a94eaf379460ec480e9f9e90a2738e78d798cc742fd4305303a2414c853211bb2bacf7a167e161
-LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/2748a942e1d98ab0860501ff794fc632
-LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/ccaec0d3602a115e90403f665f0d726f4e0a47abb3c282b159cbe86fea057afcfe86a410193eb3757ace5460a9cf0c78a65c300eaec97dc0cb17c8c7fc01ed64
-LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/835d5665ff9d5074fead9384b57ed98b
-LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/a9c4e0a0c73c0bff96c6150f8f16f19bcfc19ebf9d57d7ff211fff16f2fa5240d5bca319fec9eb9ce86ea71a1f3eba53c246b4a5d0880a1f7652b6e3c6d7c743
-LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6090940682dca61e55da5679ac9b14d3
-LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/9667aab8dac88934deb3d81d91ad460ae841f598dc12d4a140a5690f8358c7765fbea18e5e6e60a727b6ec6e22fd662c4a4443edd1e9ca979deb5a63544dec01
-LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/0576eba702f4e969773c2a5d20cd6961
-LLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/bb6b44716bdb9847042f8102a5a48a7bfae4f87e23d22907b96fbb4ad7f85bb9f97607f8a957edb6ff628e410b87f4db674ea43d7ef606d01e3be727c33403c9
-LLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/0c2d909ab7f080be3b15f9bb73dff1db
-LLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/d7bb2a593240f1fe0a0b47be742e40fa45da158b2f0f49a1e6ae20dffb5bfbdbe63fb9479a5502eafa214b38d4ba08752a35b95d2877bed847e93c39131e7fc5
-LLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/f6e521d1f0305a7c358f8018a6d3df5e
-LLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/8cc409d17aa18f3c841b09f93d03d66e2d34266b373d6e1ede0b01ec4758a65919942956bbef0cbea307125fbcfc3308001c001bb0d820072ea96141f8b88cb0
-LLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/58b1ac68917ea270aa92d81c78e1d089
-LLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/281b68a2f58cde167d50623d148df542d57454f818a95ed068446f9f7505f2f9f62eab3f1558cf8818ac55b129809beb0809b0fb1e4fa7deeaf2f883831832be
-LLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/7eb9716113fad1d48ff2a6eee4905f38
-LLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/60bbe9cd7a090c149766ac91c20dd0205bb30112265b1508c7a8417a318a86c349faae6e969866440615f6925690c6abe76cb5d66733c38063ff0fef0deff65c
-LLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/587c6b7d6e9f4594858ae8f6579e5d33
-LLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/6cd8ccec9bc25e5404d1f5e90d2a8a567fc5a99c5883f27f590cceaba2c8836c68ed3ee6f050a68fd9b4e774e210678a0bb79dfd20ceb8188e2f9e0e272bf458
-LLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/f1ddf447dda04ed967f5f36ffe0cb1f2
-LLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/b7f1ddc117f1ac4a042aa64828f840cf253dad57c6cba01c2547f258aa7afd1dc38746b3b4c10eb0eb488752542b01cc66e4c60cadeb6e5b02b588ed2241be08
-LLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/14428c76528d068bc85f2e7118641904
-LLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/03a2046bf672f360b8d3264d893f79c1f4d586e082b07527045dc5a86b7a588c4a8582ab3bec0b45cf05a7d6a3b2cb3071df7e8bf29254037dbf177e82dad85a
-LLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/446eaa5a78b2233d2680deb6ad5e7f07
-LLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/402ac0383c8d6612086b67fb5a00139fd9c099c3f40fea07d5ed6df828b70a94374399c03e727f5e4199b85b86874ea889d934f8f7f182214237b088c141b054
-LLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/a7ea8c17587eed02af5fd9c3d6e0e140
-LLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/2ec6221e3f6d0668e96fd591627f050c683c8b4acde5997a3474a510a4075db03873378a5494f4ae4859cc59739c1650ab73469ac7e431ebc981e9682e76de4f
-LLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/d72375b9860833944e75d9725c91c868
-LLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/c4b183930c633c0845a4d32ccf68d0407bbc4c87b8402b3d50908d0493bca2f78205c529566299a328860187cc4d54d85d53ac23f1b9be05524b91ee84d55d0c
-LLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/85b5fb4034cccd32f61c5d8413615cf8
-LLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/4c29053db95641bba91e22c5ec1bcc7e176313c4ac99cef5a27094a28ea36c10911b734c272049ae2064ccad7e77d81759ca8904cbbb9572bfe8ad99ba62a2c8
-LLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/5f5a0af4cea5cd867c34f70f3b03e6e9
-LLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/93fdf4b0a04adb9031ce671f10f95513de505a79a6db1fe4b97316c8b9fef0d8c3b40e3fe464b9bfd2f8325a798f3421c290ff5cce99c1c297b6816f07b84b86
-LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/4af50d211a55eb032d7fa6499c6a24b6
-LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/a9a39a87150dbda78dfb572c316b5c763749f92222ffde636e6b0e902385921f0176a0ca943c7bb99226153e6c837e61b257dc1de28cfe8261f493cbec4f3df4
-LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/955dec5e8aa76fc2a9d4be0a4f279764
-LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/51550218470003056eda7303ccc19615fb1586d6fb6b76eeb77a94295a72f24a1dbea449f884c603ba4c495fea920323f7033715166bd3921ae326c170d3645c
-LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/61583d1f198cb17e5e3b9bcfd100caac
-LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/0cb8393050114b2c273af745bb1fd8919fbdae7eb929270449573750b7f3c245570f1abdd0406200c93152c5b26d04537abab61f196212ebb3f018f2ca06ce89
-LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/5e57fd18ef38986436d93d029b779e3f
-LLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/fd5c1408c7a4a8eb82a59d7dfa8762bbd9e8bada613c97238b824f94bd11eb6a895ecc83cd17b7e8376d16ddf14e0a151c4d6c3357ab8bdb0016f7a55550f6a5
+LLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/a01c365e50cb49bbb9ad7c63320afaea
+LLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/b53adde91d5e21c734a85056e779f26f85b6fe084fa89b679e3d211c1209d14d0b7db627f9ed9692edae31554d76d8e1e85cc34737c4b29273c2a8ee908347e2
+LLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/536058393999e62a2829b5a2b1e85f66
+LLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/e9d1f6280da11ad3cd956cd4f9520f344a2657c65833ea2c88844cad7005ac7e5ba16f607623ff80d03b7b362752102366d8c5928abe827187f74669b80d56ad
+LLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/e923316d8d68df6ed6fbd8deb7aad6e7
+LLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/9fc91d10805660a46bf10084c04a9bc53bc540f390ea3d88cd4614a9328d0f3b386862190ffcebe09331dc0324649c052a50326c44be2477062d1573f2ad3b09
+LLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/5b600b39079942129b78474ddbc32fa1
+LLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ae46cd569e408b4365f8e953aa1f7cce1f735872d032c71f4a6cfaa53e4d67829bb5a6c8f2c99cebc0eb224b02bba4c24771faeb79c6b99e641d11f5c83d31c2
+LLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6f0980a7d08783cacb5613752b04d41b
+LLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/d45e5be28d6c786582bf79b3fa65d67eec12b2f792a408b32be91d76452bbf95255b6e60019b6f1af409dee4bd95120ac1c6fcf3e139613a774e684f4ab6595a
+LLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/e25c9371e8d59d69dcd8009a892bbe38
+LLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/0c67ec6ad0e31b98f1e13883ee2436a4eee61ce5cf53da01df3d12b670e7fe9d6ae408d2dbf622604fe95fe0ae14bb0240c1882616ff1d6c2bbfe8045077a90e
+LLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/039f50bf67a682eaa9d69474f5980302
+LLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/03a77ca15883b7e7535f606566d782af8b5706b5d2eda5caf33a3484baaba1f657b65d3e5be9bc40050f0a61521977839da8ef4008f4593296fe318cb3772377
+LLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/30b471f0630f67245effe1481ad1ba6d
+LLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/ba7c039b13915ed7b374a75c81578ddd5a8d569cd1022fd39cd40f089c39463d97c3306668ef072becae38171aea44713e27c4d34f4893c671f12ed08824939d
+LLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/38110539776130f9fb2bdbdb1b6a4598
+LLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/d8dc28c542ff6a07083e60feb8d7b731cc1b3b0a55ca332200b62e8b0218c2db30af6a5870923db70ba4f47a35f245a6b82504ea1af410e9a43dde03f41981d8
+LLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/7916ed51676598067620090a9744e110
+LLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/46d9be864409108b2c87fac4b87582637fc10d96382ba265a008cf6edcb046f10c5d4e0de4f8f824c2dcfb32fdbacf05dd13928ea9905e3e338f7aa4d5f5fc4a
+LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/9c51e4d7f15a1a7662d8acb674cb809b
+LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/e72918bc0af4806cd68f199decaadcc892a70dd9dd4f1cc23f59d361b3e01c7f3542ae295ea954fc8aa7d0121cdde2d06d53616d3196a532b1b9f45f9665ab9e
+LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/10ed73102caf2bbd27766c292b939f89
+LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/9f08eefe7c0027d7c84955160cf6bd25527688598c6191f9822c12c6558f534567f0c61e4f1397e62202c02f4c8cb61eb0094c343cdcaaad5221d90f147be210
+LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/b4fc948b8532d6add7177b77b89feccb
+LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/6a7c022e4ad205112a1c4665e28286672ed0460925d1e55fca04af9afb6a6a5fcac4e641ae0c1040181d81b1762b2a2ce05cdc532725d5da0702a44668bb8893
+LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/7b795c94a4f3dd8d79c5c4a85ecdc8e7
+LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/bd6cb0c2f2ee25823fd9ad9ef931d7d1518c5315db70c33ddb959fece0fbdd1eb030630a5c63dc9f9e50b1bcf1cae9c2f7d24585f9de100e6fc56c4a4b6f7a06
+LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/9812ca2eb64521bfd052821824227598
+LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/f939353f3fc667fab78b1083365c51bb15eb218bada2e061900bcd16550db5ed6765569ac9990e91294f030c04787228fed14324e2f192ffec26c6dfe851c9a3
+LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/cc4e38e0a6cb55e16935f70e2e9035a9
+LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/297d7268808ab95317d576301f81fa52db3d8f9e91e7a2fa554e87afc21bf195fb904a585c39b4e83c7ede6a2ab64efcdeb929cc109894c3caaa7de9cfd41ae1
+LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/40459a6691760b6c5a986221bb1d3c7e
+LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/4b3e4bfeb1e1ddddec786d50a018588d6eb6c2b97fb6e68e1c24026f51aab59229cb8a389be075da5abf3fa50ea7fa36b870ef17c374e97d8e85377abf4846ec
+LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/07958dcb7b13ee0fba1379d729fae641
+LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/358c454d66b48846888fd696c64ca0d154bf9df81c27859169e6b3274fa9aafbd49935309e976761a4d95c3f2b80481834ce9691d08a2a456c20be15f92319e7
+LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/53572cb82b955197819eabdc1164073a
+LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/cd7da353ddbb1a18305a3b4b20bdaa92f60bc3bac1fdab32878cf53e921b8782f4e87bbfb55a7c7076ce927c42f02d86c890f8b82498eb41d58e2702efb0e044
+LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/7420d73f14f4124c79e6477e72ecce25
+LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/992f5ecb3c9b162946bc16e8ce680bc56e5ee5b928e05600b87620554b9f7a22998a03e7380171d659b25790b8408ff656649e9c0cb7a8f91625ca38b0b4cb2d
+LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/c52e1f13d082a786e02b9a28a5192ad1
+LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/fcb6e45b4627b6e62cdfaa9bb333863f99ac4b629082fffcad62f223711e1c36c72be497a6905b74f99f259213eabade3cd7d9b2d95ef6c77049380b46476a4d
+LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/abe229cb1c155815bbf39735fa2395bc
+LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/41ce4c5dda1d85818387a8c0b8061290ecb630b243542b9d8f9f28d5c4364b010ec9dad682a5c62859165d61664b1f43b5343a79bb7afccb79de0746ba4eb0ba
+LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/7f78b28890669a0140ef864153edf179
+LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/f610aeeb183e6c85e0e50d0a2b483b16d11cce83a237e70ab1297914062d78288dffe14f0a63e03dc8680c5bfc096b9e66a2fa6620833648896535c221640202
+LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/106d266049c26933d4398ddd9c7e3af9
+LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/fff0928621c86fc50283ed5e929f88ac6191822d2af8280a61a08628d099203002b9a43c69df96d85de36efc364c7dd317e0db48d9e25699440e2279fed4789d
+LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/47e42e23351ddc592ed7e4c0acec01bd
+LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/90f9e8b3f54373ee738115e9105b0ac94f298c574d96f8698ca72cb917181d82146c9f7dcde4468022b36cb2767a194d643e0c044af0397922b13b28bf2f6177
+LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/29923410db87d76d9a86362713378f3e
+LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/c1cf57dc3a3da5b16d14b80fec560c2886fc619addff07d388469aebf04b625d700d89aea52f6f0d50767dc2a4e426b017743fd66ebc15185fecd65904267b8c
+LLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/540a5a6a7b785271e5354abb505868c5
+LLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/61807c0e2f0cd25a234db25d171aa078c09d70d683ee874de79ea647c52a5875b8802853051b0f47a12809ddfc88e868cfda6551b789ba1633093fdd325ebe6a
+LLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/7195f5e0bb86694fe6c6708510806a11
+LLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ea058346b3a600ca5fd3496d0a7f8ce7634a97eeedacc5013e458088462d82762eb92f8d82e6355bfebe4befe397cf0970fb8ec0005f8a80a4e8396b24f7205d
+LLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/c59ab62f38a937f322326472a6faf6d8
+LLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/54e6b32c0c3599804d44cfebc2d772a00130c3f41403b9211d16bf36112b9de9070fb3f663d09d239c4392daf4238b939cca1267369277a74bb7d176e841d732
+LLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/b5e5b32c0573a376ed4eb76473f98cae
+LLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/9f2fb572354d13b6444bd7ce786de90e8b394ecc6b69bce537b9636f3e6906971da317c6ac5a1da4a9ddb4a879060fde75aba5c96059cef5338cafdea78b47b4
+LLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/f4f58134ca48a8485d70ac135a7b8cbf
+LLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/84d3ff5c4d62c56b0fcdce4d9f6c83a5b079d182ac3dd6521ed4df3fa7e8f370cf4c0a3ca284f25a034525141094ec422e3383951c35c8fcfec97339fe477fb6
+LLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f797f871fc6c676da2c8006f2b2f1863
+LLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/a7b74a8e4d3f0ec5a76b2fb96ad3131c4847eaa46209667cd1dcc6e60c05fed3a584e9f302a05169a04088674529d2fec4deda5a9174735dbc21f98a681375b1
+LLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/445e297dcd1aa83d9f7d29cca4f5e3fc
+LLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/b90c9c7daf05b9afe7d8725c97491efe7e401f055614061ed894f140eb24c2f02f542daa15a4506037eec09a777070fefdec2e6594f1eb34af3eb113954b9543
+LLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/401ea6f6290a5fffdf4cf55a72b41655
+LLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/87349bc4dc337f86e192068b82acc374bce467af8b1ec696fa5b9a98f174647ca8a7aaa98e48bb7ed308d2dd8dff459c8af622f7f2f9761898779879a7069de2
+LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/977e40f66ead0070ee1b10c16b4821c4
+LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/de1431693f04469f280b512874836a03ada21d0dda05070e8486043999380fb73bddfcd15d1ba98cbb173bce90b2b69589064c02551785a868dc34b45a9dd17a
+LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/e74514de403eed67e4fbb647426a0fc0
+LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/3994895cbb78320048ac330cfd29700ef71ee48081a1eea4c881bee7e307c95caf8fa74be02f8dbc39a5a73b47e7498ede7e42b0c432fb263984f5122a6922d8
+LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/2fa81725e463088df57dbfe286319e77
+LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/c3d58b6537674ac8b4a3281df3204a7ca6071c8acff7aa54fcd506e898ce872dde81147e955a708fd2ac3ddad31c4d7809c7bb152574e19bbdb72dfed2a75221
+LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/397ae293e48777f768c2e98f9e6c558a
+LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/526536b102e0650b3fda0c8f59639a3d97b8fd72c75c4a066da0955637cbaa5f331d4c1e5e11af48cbaaa813a274f6dbc360f75da9de357a14762703290a1fbe
+LLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/3524c7e60e752ba00e982730e76fa40f
+LLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/39d5dd8905e51ec8fddd4c29142e1923f6379eeec6e5ce9e52ecafcebbc1642bb06bc912259082ece485071c32f35d56ecd1c19af270794d54a1e0a52b28ac2b
+LLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/b7e92004bf50eb5634b0134a41acd80c
+LLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/ecf7dc9f70b74879ad067de733fe482e058231b76a2c220d0eed055f4967b0a9ae5d3e572b03bc20916beafe29f40a404c0e03ae18398ee8f7f95801b085e536
+LLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/8356012f5f046bf0c931ddbb600e18cb
+LLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/e9324a4bb5342c65dc978425c2da2c61baf1999dff9d30163576699b5be347217bf8750ded3f5a80c166f65ef94c150ee58e7f708791a41f045c2d9d10ed9f67
+LLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/f28b04fbb4f1781d36d4bf0d667737f6
+LLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/62a6cff9bd8a73a17f8fe851cf4ad69fe70b12a3688323f3d5e169b942b8d2b5a7a2b1a6583a23e0d0c98fc9631b77cf0a21078999d45086f4620f08c0906782
+LLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/ed5489b9b7d1c2fa7632c91630079c88
+LLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/ac27506410deb7ff4046def2bf277315e11a7cbf503631d62a749bee50fd09c4cfdd21ee7621f2232ecdac20c7be8b87dfa2125832aff8bb5cd65b7f9e7ae875
+LLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/c99551c46f7ae080f3d881247d83ad2a
+LLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/35b8df0053c904ff31db74d5d2b65fda7585b30753a6a96bb0237fc72e51cc39503fa93a0bfefe453941b047f82fa5aa08429ae1431b1590ef7bb358326485e1
+LLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/1cdb2a5b49fe2a096d094ebfb5f298e1
+LLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/8919a3d2ccf821ad313bdae173db7519d627a6006804cd695e9836fd25ac2b4db5a4c3ba4faa673b89b33ccbc0c23f2b37ef4759f167ceba9a5564275840029b
+LLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/74e55203c31cafee26add48f1016796e
+LLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/2fd6a34c49fb4c62e8104b91d34c01fef8cb79ecb076bd0c6e325db46a77b79652a741b9e9a4fbff454e7810b3b4352d62eee098b0a155496bec79add7f9ed5c
+LLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/2ba719127a88be8d60251d0b324c4aed
+LLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/f117558f61da9a2ded579ed0f44151a6480f001aac9c082e3fc6fcb0737d400f97a3e9aa66a311ad6cd7a0b9c53dc2c37be7a0f1d7bad7b742ace2d80f20fed5
+LLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/4bd2592a0f027b04599b35fe79dcc2de
+LLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/6240c9f909a222b7c6f51b388d1b49be5ecb51e9a5c17bbf3aab53782e5de23c3e60877208fb0117d46306b9d3a1527ce8debf3790e5e66255938465c11d7570
+LLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/1f161fb77f9b880a8d825e60b83a288c
+LLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/0913c1033dd51c79db2169ea3a40a0809eea49c04e59aac7502a86cb561d7a1a2d61a903b77f92d7fbcf1f26bd9e9e956e3c88124792e9a0d8400fd7cfb593e2
+LLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/78e5ea646651847d21af1a710b709660
+LLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/c8789f8fc1b8695f1dc1e49fe8d8512b5a1b23554d651479c39dd64570e3fe141018b5d168fedc5a6f5141a2e71a65dc30f87376374f8f549981e326c87ab39f
+LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/8bec2b0452f7c87fc98ed9ccc103759f
+LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/adb89f7904850c31c42f8326fc67fc0331d652d02546368e1db0242fc940074ccdf569b065d77d4803e1ad6cc39ed3353caddf4d0f8cbd92db7d9e95c5564bc4
+LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/2765a9d83b62b29719f3c5ee63370565
+LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/4e67a737e953b9147dd143d5d7b6ab6a3bf5811510664be41dc9a1572f89d75d97c4c2b334fc4c60320a8552845444ba3f12230e9843edc63884264db7d6e3bb
+LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/4e9a5587cbc5926224ae0d4a36c581ff
+LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/247c989e3843fc4da54f4c133a96d5bcfc111b84801f52b1b322b548d667657a932e94fb7e0778d1d0151d8c5cc1d0a21d3aec555254bb4d8c8bd37593554ed0
+LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/8a71fcf24c6758307f0491ccd29e99ae
+LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/cbe1131e1202e15ffead552a8176c1a86e03556c9d85c6fcf886d0f32bdf31898e3d588e2d6e5723e89267b98cf111abf1bf90b1c6ec6879b7ef8c87d52a7e6f
 LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/md5/b95ad4844e649bf46db43683b55b9f4f
 LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/sha512/15e0996aebe6db91fe58121001aa7ea4b23685ead3c26b5d89afae34b535e34b4e801a971f4854d8e1a1fbc805cece06272470622eef863e225358113a127913
 LLVMLibUnwind.v12.0.1+0.aarch64-linux-gnu.tar.gz/md5/6d8783dc9b86c9884e0877f0d8ac4167
@@ -138,115 +138,115 @@ LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/md5/54ac594b4c8e7f261034a8
 LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/sha512/a43756afd92081e6dd7244d162862fc318b41ca110a5e8be6e4ee2d8fdfd8fb0f79961ae55e48913e055779791bd1c0ecd34fd59281fb66b3c4f24a1f44128f0
 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/md5/83cf8fc2a085a73b8af4245a82b7d32f
 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/sha512/297a5c7b33bd3f57878871eccb3b9879ea5549639523a1b9db356b710cafb232906a74d668315340d60ba0c5087d3400f14ab92c3704e32e062e6b546abf7df6
-libLLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/c26ce3cae44c64c52dcbf813d42bcd53
-libLLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/c00c51a3ae82217da929e2a5e5c6418085da77f04447406af91d9ad48875f1d53e1dc692bdba62828d0e2c7a00ad76a1123e88b30404a945a1bad762b2ee6926
-libLLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/558677141b34c66b975d5795bfff71b0
-libLLVM.v16.0.6+3.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/0441d6a2f627a5c0c1dd7a118d3e5adbee0693f2587c7ceb8e969e933311c6dae96b9a6999f3c1376a9aa195d0747e4257f3c6f928307cc7f2bf24076ec8d965
-libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/5c77609ed227d348df1bfd8063706317
-libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/2eae7778da9aa4725911b68a9006c7f08627c7ea980cd355260c2c26e38aea2c831bdf97a1796db967ed76ff72f822c810c27268073b102ef64cc9b56ff8d053
-libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/1444c73725196aa585024599fde8b6de
-libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/d37f3f9135207f675471d858d6dcf13bd38a8b0159153a8dfebb69885326de330cbbae74ce5dd4744cd7ad48af45f802eef1a3133521517fe1de4ee3e7f42868
-libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/e107910180ae316cdd3aeae0d0b264c4
-libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/19912be8ba86bcc3507ea308834ad0c5effcc19b1478eb1491693a7595d080cddcf610089e902e159f8e88c37e26dc330c465e920c4aa652a7c02a6bbc0e3ecf
-libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/f3ef392b873bbd75c12667a06d8a5cce
-libLLVM.v16.0.6+3.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/71fcc827fbc0eee2e2c5e98ca9bb6ea4bfb4301b5532140df3cd63558f6fa5a3eb42e0bd1e77b100efa915d3d5cf64dfcee49cf8720f2ce49f3eeff78ceea0a8
-libLLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/0ae09acda1cf4c2e1577cbca08e71b32
-libLLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/6f96687b3eec662f95d4537ea73da03986fed30962d3aa44ac5c8d79845c298ddddaca6ea655a824653ea17aade961b0bcfdd9bf0b13eb1cc82aec67a6e7921a
-libLLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/29a26fd89536fe6616e2a2d383b30eaf
-libLLVM.v16.0.6+3.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/0cfc60d39c7a75c7b758a7ca3aa409b09091a10e5f1e9ba75ca6e806d12e2b486ef617ec140095e035af5e3858200266a81a19837f94072ba16fc5ae5f014fa8
-libLLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/b4deb520de74282d8e4ec9c48420fddb
-libLLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/16337b87b183367690b509261411e92f73679cefab1c3941eba43c4ef6b884fb9f450c0f3032831cba7ded0dbeba412920d183a2b18e20560bd9453be26634f2
-libLLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/0f537899cec525d5ff2414648178b39f
-libLLVM.v16.0.6+3.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/0baa91b57669acab34d0d8f28de38aba83e6ddefa8904019195715bd21440d586e2ee38354a2ee1faeea8b655b11f33fed988a6526c2c02c7298fe69d11ac5ee
-libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/515d36bec34c4988e84eae6248e05cb7
-libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/5d3011095d52722202409e9e1324e1f8f8f0248535a4f6622f38321106f7ee67a61999ce3713bfd750612ea0bc90ef8530b02d9e17ddfdde7159f39115293f20
-libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/05abe658c81a6fa9b4762f46850ee8c8
-libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/7f6feb745735e8cc7e644d40ace1649f7d81da22d344bd20aa7b14dff039c076e82af053bd3d03fd0fd048f7724eb1378c90e543015fa4484845cca79ac411bf
-libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/ed8deb655ded1d10ded32fdd1a002191
-libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/47a55c9f67b2268fee32b5fb3eff34dc9af1d0ce140343d653345b3ab7f333e256a059e257a25c03982eb4ed0b6e2226e1fe2b603c3f9cdff28516a85b11de8e
-libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/4fab909e5c21259a0d677aff7d7c4b9d
-libLLVM.v16.0.6+3.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/2e98ac6f9215fd4bb3bd7adfb111078ae7c017fcf9360049d250ecb6a926ee36d79526c54f4193d774364b30188d17d3237d702c9023485675fad59d37f81223
-libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/1776a7013121522e3964d4fa4a378a29
-libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/da83ef347e2479e0c5dbda6e41e5ae2810cdef21c64a380cbabcd4f77957b1b185a5899da121ceca4b8860aa5abad82fb67672e1a3b88491bcae9c063e01a293
-libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/d5b2bbcb2c50d17a33b37a1e96c5e181
-libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/5bcfc83011bc6cec870d471c7c6c13cbd72e310cf43b582fa0ea46cbca448eef63ad8b376275a47047a8187ba8c1c83af4027613ca87bade5d798f2367ce3039
-libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/c2cb6fd28984d18a025b6905f6390044
-libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/d06646f38cbe91ea4cc1a2ab1f10a1d2e83aec55c046c7762d6d45c40ab98a368350e4103068b50d90ce76860cea65e1cb52ee5dba408725d4f291cb649b6a03
-libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/63e36fd036f87c8143118d6ac43766f9
-libLLVM.v16.0.6+3.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/eb90365497fc6bfeb9007e982576db604a27876c94988902fd519a11a053e20fe89f29307d84b492adf10a3005eba6042b24d05dba889c81e307b6cd9f040991
-libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/9a71682426992456392dd7a46f148c99
-libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/7412fe32f9a224e086c05417549d6c1b995ed87320fddc1efa85efdc60dfa0072406a876341a07228c913415e056c3263bdad8f789856970d7f24b4e78445f74
-libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/5387befc374331e1ad99c8886e4c9315
-libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/eefd4f115513a7532a495307e1ab5dbfcb8ca178e4cc3fcc034588ac8142ff85310f7186ff154ab2ac9ad813dd40a550a0e9bfbabc117861d5c05981698a4b87
-libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/ac1d5437b754fdb46126d0cdd104ccc5
-libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/8ae367cffb7fa2f632c7e18a1dfbebba7500ed3e3c66b9af0637c8b15c1f674f8a3fbee5b8157f5d6d9eba7f290825644220ae99ad60393e1fc2f1d2ddef7c00
-libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/f896dcd15b8ca46c8206fb7b6cf7805d
-libLLVM.v16.0.6+3.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/c777ea1767d42c84a9a78f01b20cc5156245f6f056596c283d4877025b7e3783eafec9f89db65eee47f974cef6e85d89555b303ff5a594831ed4408d76ffeb32
-libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/e1a21d625111bd4fd0234348cb07c342
-libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/192d90311f4ee069e371084680ee3e959d0a11004d50ac6d9786942c87f2c14c887996674a89ffe9a0d3c6e9057cf9db03208bf6980da72460a004bd2f005e90
-libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/678ed2858666f6fe08d91398ef76b45e
-libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/cb9846fe1db101f242ae85c25afc6591077fbf6705c44898a370ff53ce75c619ce0a4f760952254017c5e72f2ef2befc87d1f0b22c1fda23a42f4cc7f35a7e7a
-libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/01ae54de30b68736c183af26d692d97d
-libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/3ad4848dd986a2a41605979e99d0eae8f397813df1ffec9f63d66f810a26700344ca3fdf73eb64e734e03e86dcaf39deedfd68f0fd814cad46c44b7ed97b4cf6
-libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/f2731aadb95c07f8f50be885ab7ae10e
-libLLVM.v16.0.6+3.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/c90df10819e7a70f67a59708a4ef9768eb45d031b54f8dd69393fd6107cb7a3cdf943cf4ffcfd96f9a13541bbf1094fb1b151c1cf1a41c154bb7e5b9f4cce024
-libLLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/b24bfc1aefcf199295c5053fc8c3125e
-libLLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/497d657c9daf479d2d1da8de9611e32f531c66adfbc45e5bac2d0375280a694b0b213d31d8134ca9cd50c1dfa62980426a5d9582e27395ba33bc4c29e638ac73
-libLLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/c029eff316b3d2313ed37f1afea5f58e
-libLLVM.v16.0.6+3.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/127ee3303146397552034459d7ee1520940dbaa2fef04d1457a56d91baaa6c20dfb1432bfc33394cc3ae1aa1aa1d198185446b0dac4727c72f4c341bfea2ca28
-libLLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/c09cc4037506f653eb0efa00743f29eb
-libLLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/aaaeed57c2bdea708719fe8ba14b76c4fd972ab7ba888998ae93240a3d7290cd424602b3495ce22777bf14c61ce75c4552c1c6174c351f8dd76468d8bf346b55
-libLLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/75844675e2a2cf1f184fe14c064202c0
-libLLVM.v16.0.6+3.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/a524ed10afe6f736e42e9ea2fe0afde3b1d8ca9a84be648f7a998f80fe6fa059057f994289d576c7e993835836d9756e6df277771f69db7f05b153826b016337
-libLLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/5098da200f43628e8783dccf3fe07c2c
-libLLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/7f37e926746fbb2537e70998c921d7c5b8b825e6baebba8d7136ab28b5c26c741458ee874ea9e193658d0b76b6b7dd3b543873b563f5124f270500c62cd9717e
-libLLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/636dfc4e622fabd91b7a1dc6b5d0938f
-libLLVM.v16.0.6+3.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/a000b3365be2069561451355f6c39626a0c10334559c21cfb9991b69eb2ab2ca120a7b60ec0d227fbbf44e5c05dec824dc2b43f2eda151d44940376cc050785b
-libLLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/a2d05e71a65a0dcb78b6d5eb5661c627
-libLLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/b66b60a9c7aff46a314d400a71fa6d798becf625b91985b1c5695fe759c9364353f54727d5f88b2e4517bc8efe5acd5ae419068cfc82285ee1ac4c49c048c726
-libLLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4e4b88747cd274b7b1c7e49bffc6cc12
-libLLVM.v16.0.6+3.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/225fc0128068f5fc4e8d9ef6ae1e2d655f2b6ed655754429f93461b962f82ddb3dc4223e66ee642ad063020e6c97c27dd25cb810a038f9a3c9be5eb21eb9cf70
-libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/5490540be6910471221fde1a09b01fae
-libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/59c34838777bbf4c9382b21c06359662c586e47c1eff59b428eed07e58a907e0c1934647ec7cdd00cfb391f30df7782a745a6dcb4e9c421ad67ec0c28cebce92
-libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/d662aeeedbeff55d7c769437252cb4ab
-libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/c4eefd0a1b50bb815c108b1a9fe39100f3d61079199f2ec5f62d83c07baa0f8cf5a2ace14cf92c0741659df287329bdf89e48327397a9371ae08327594a45794
-libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/369a47a5c50051084e1f84bf6f79f9d2
-libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/3aeb7f533eb00f7d17dd535826f9a4f706291d00ef2a5853be3e6472e92af9e973324c5491710f0474963342cd9d44bd855102d829c04adb4e5fffb8dbe0b0d2
-libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/a1daeeedd9ef2c5f702e2c8d515f676b
-libLLVM.v16.0.6+3.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/413c1b6bd44bed1210353da5335f0dd663fa72b0608167acb7f5cde4a2a2b45f171bb58dacc89532c9a18ccdf81cc2734d7b807dfd2fc9649f584e1505a3361b
-libLLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/288cca68b558cb5eaed44267759b4c29
-libLLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/89da650382d788c1221c8c8fc2d6f79a8476bcb0bd1e5f2aa5a6ae1d43ab4b8d904d95f34db88146a0345437761fe4aa48869a54e474b50cbf58c3daf5494c5f
-libLLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/46b30d4cb9c6b1c9bf567c34dff005f6
-libLLVM.v16.0.6+3.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/44e5cea2609c79d3269a758f063d0011d0ff0de50d64f1c2090eeb47ae052bb92357aeed7455567b5c29c5825287f5b991c740c371841631f27d8499ce0360d3
-libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/aa7533f8d2a42c8b99409b9103a09be2
-libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/97d7530b317ba16ad1f275a193b160fcc4f571f18d52deb48db0adde3a1c569be6aa64ac080f0e2cabe550439612ed822689e23d707223b98eeef58ef8c51b5d
-libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/abe9dc9d7b96712bb3f8693f0c3e3e98
-libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/5629105bd3fdb9fbfc8607254352dcbbc21370b1b28a71950d73c6c902cb5ae33d73ebd047a8c5f556c63596e758b18c4fee267870053d0fce89297cdd442daf
-libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d2371214faea05c2143937f3a18f3b6c
-libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/82eb0cf01964f34d150b3f1dc7563ae88b586074b368dd9cdc690ca7a75b53de8a1f78c8ce44eaa9276c5c06e4bdacdf8c3901a717c867949c7944e564f6e0a5
-libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/c4460768b4185848615abbf4ea3c5232
-libLLVM.v16.0.6+3.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/768e8f16103dba47e396079cb652d6333f8f558178b21cbc6a4b1a65b869353b75b8567f76b0f06421be44cd72df6a78b901f56b85a22b1e114b78644cba6785
-libLLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/2c6a7b15126cb4158e0a54b02d9d812a
-libLLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/4c76cfe122c59bb45fe64c8c5bf5ebf7ef2efaafd1ac0a1b1aac8d47f0010e3e5d454e33da5066df02eb383ef6aafc9c434e90f88df8f3a8f179315e8684a57f
-libLLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/fb515854e492a32722dda370f6c09aa3
-libLLVM.v16.0.6+3.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/195f1d391e936dd82f8efbd952d32b452e30d98ea0fd2653f2fc1332242245b2d74ed9a0ab9051dcc17a4ba02fa3d25137d72dc5135376270a49e9bcf131fb9a
-libLLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/788ab9d676633e38ea1815cff2ab14b3
-libLLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/9c38abfa4fc462093e7226e07890b85a85a55ef07fbb0e36da74c32fc95710054b29a0b192b893caeefd0f592aedc89901b85e0b29ce0db259d97a3eb49ae417
-libLLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/043759732d4bb279866bb2362c0b6172
-libLLVM.v16.0.6+3.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/f6032c36b85849104aaf95a1cf4082851ff63bcde2d437eca0c5145dbe040236b8f452dcdd5aab12536bf4f9ad3982d36c95c2f77d0222ebc00052f724453229
-libLLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/c27a112e2f097b86252df8243d5dd634
-libLLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/8734e7991819440b3dbfea66a86b808ff08788adcfd96c254a07f9c6edf7ecca8990447cee92e9a33713fe8bab078fae405e7a6245c9c3f5679a68b86e523743
-libLLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/d23ec5a65abba215c1bde92191df792c
-libLLVM.v16.0.6+3.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/90aded28ccb1ce1ebbb4fbd9092998730f50cda58913d99617833be666d3ec0efea50bc0cb01c524e1abe42df466af1a9061aa7eb7c69510dc89a5cb43f37c07
-libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/b1512ca40c4fb2f771dbe5486c71941a
-libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/8343bf6cfffcaa0b8b2bdbfccbf0d8e69e0ace390e9112c5a7c1229c2c7d9dd186c7b350b26f0e2e51ab85c1ec8e77e31e9a619276676ecba86d05c4d15e005a
-libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/723bd254520545cfa441d92f1be270d4
-libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/3db6b330a49ceb7193ddc17a00c2f9866eb98b364c58ab90acd38bd0b2c8bb0e0b319d0e308fb310ed6701456f60788dd371dd211ed4fb7a99a55296c62944bf
-libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/ca01f13bb88048870732f65ecc05aeb0
-libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/ad4779d51f88165782ef49b657dd03520f093a5097d20c7bb3e7b7198e268afbbd04347ce7acae2d683dd75c0b255dea7bf39d15cd25369a4796b14dfc1ab627
-libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/594bec1e655f5a4433ee9c266fa891b4
-libLLVM.v16.0.6+3.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/03c907b4671e1571166c049a43ee81647481d1e236ec482be84eb4430691cbb44cb5ff701993c3cd7963bbcc8b8ddb97b97bb80cec692ee3f059713fc1adb960
-llvm-julia-16.0.6-2.tar.gz/md5/f05607b71ac8d1e7c30430d2a9efa0a6
-llvm-julia-16.0.6-2.tar.gz/sha512/5f2f88b4673b13780fa819c78cb27fc5dab77c2976768ae4f7863b904c911e39fc18ee85d212e512a7c60081c74efd1fa2e7142b78002982533b7326ff808f24
+libLLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/bcdb469da04c788fb81a723ed285d268
+libLLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/d44eec8843f4b22fb8319e1a6e138f96795d82000a8f90f8157455e6a08c4706d2a2704a70ba96c33226bed6fdd27ac52da6a78c5f2eefddd98f8911fcaa966f
+libLLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/237d2d1a2fc596e502502ecf35a23623
+libLLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/9619bc2c0cb38cf38a53624a0a6f2711154d409178d7d9e510babef007c7eda33a9ffa4e5ae29c56bd52c77a230c4fa74f1730150232ebf0491736ede5805c85
+libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/2963b428aa281238a11df94715ccc7ab
+libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/04f34b768de43175f7b453e5e5d4516b1f42f42fae04be511a01fa865e7a778b4044e0d0cacec4c8efffbcd7b462a1b61c3c7a796c7c8ee474085b40d59e9e9b
+libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/bad975489e45f75190a930e2adffdc5b
+libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/48cb7d77d85d9ba6826105e3707914f773e1b54412b0165da407f9248ad1b9f262c477a11b0d2fd2efbc638e9fe20102b3a6ad4e51d8169ecde0a8ded863be26
+libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/e47e1d4be6d503f069dad542c04f2391
+libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/d6e98a2effa12796f305a90e401ddff5f29df7203d017fa08c681ef0b91a807f5dcecc63ec8a690c25a664c6a02bb55a205e238eb6696dd421888ce771fd7ffe
+libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/9289127a28c909e8e7d5f3c44a20b4ba
+libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/5c253a38b9b06f227123fc3d7d9f2f55ca7445169f6c6f0ed73dce1b369039da6edee91a69cff88d6dda1651989685570c7fb40e2e196b0cc73e40a3e68df2b8
+libLLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/9219850cd1c29f480f7ac7545fcbaf50
+libLLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/42ac83c9ddda05b0ff83159bbd72190daf05d6573f715ea7d2e0c015365ee81471069e43b2a58be4ffe340139f4ef5902c543820920537d0918f15ad9510bead
+libLLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/1ec5846ddedf6c8a57bc3b5633df9626
+libLLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/a40b5b13f3ceb0a261e7fc28209334a6ee4fd7d9490535810b1471f7dee1a5ff6f80fa98c4adbe3f56a6fdc10f2b2b22d835b974ef8bec4909aaaff4a87f1bcb
+libLLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/1f65b8354b9235b442400560acd0e7c3
+libLLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/c2b82578425e2a378cef3a1028b1a55492d3ef8aa4e2509ef06ba30475b95d1896764a3745de4eb905711f57b9ac7fb451d5d5f44afc5c95c9a0526a08197f97
+libLLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/57b2b92268a1bd13f042cb8cc4f652a7
+libLLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/187a925182cefa8eaf42b9b4df42e9b5999deb27d864887ef65ba97fb09b1f6fbac1b0c7675aef0df91dce5b51adf35493bb6edf1d5049a73d1b76eac26144f9
+libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/04bd3427ebb23c98f580ab27b8b73809
+libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/fa2fc5bfcb2ddd555ef173e95bcde24320cd5e54af7dc3e24f2ba6828753cb52f2c59381191d5b14a76ce53634203c40d126d533afcd1b620b718a75e38a51a8
+libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/c4e68d1829702b7cde26bae87817273c
+libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/4f656cd0b95f7bbb17acb49ef125c46e4d3d9e3336db5dbe80322e5089fad53248172acbae068b35ea82204839a11309336c8296e672c2d0b4aa8778bcc003fa
+libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/9372fa9a23ad5efe86fa002834cd8b71
+libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/6eacf49a32264fc88d5a034a96c6621e0ff9e5ebcfece0c702718c4d2027adb02ecce4a11096755010052ee4b61f99216f0c3f4bc3e31ef643dd6eae028220fb
+libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/535eae6a95d4d6be3be3b69eb180b4d6
+libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/df9820469c84d9c354dac9ac8ebddee3df878602ce2abbced63e77dd0f67e7e12929003e4c62def63be5b8cb90337707535bbebcca5fe1c730bafd90523fdf3d
+libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/b82947eae6dff1fb15445b7dfd98c0db
+libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/a314e0297f60e55952960889445f4a9347782d8416644cbbabffef2af08cb1c9e59940a6f59b09627aba8783287749489d94ac2614aef4bd7f58b572bce146ad
+libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/78457fbe2cb70afc8db031808080c732
+libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/6ffb4628c4f2ec4651d0605709a67a5d5b86f1fdbd27a47551adef9b95d402c6bf0cee916f06f8d07de82cddb7e3b9fd5a557f98197e0c5431296917f6294dce
+libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/72725d8f28c4e22596e8181e632b3d87
+libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/90dcfbefbc58529616f64d7b1add5d8cb4a2e01406f7897aec64003e6c73b822be50c63cb8c2c9805d73cb3e7cd729846a39b6813d4f11872489c88d298249db
+libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/494f84c84942b12d0bf26e4d2e8e946f
+libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/b5e1f1e2be533e7e5cbfb2dcec3ed573e4d6a7ada20442ee29122a2ff4d79246f140b7381eb33d56c436f893a65626a949474fc7d1a33502e40b857aeb5c01b0
+libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/6f7e0ad54d6bc43bd539a3026c2dc564
+libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/c9a4b83795605d0550c8ed065e94df2523a45ff451b6cc894300b642cccc2778b9134e77a609ba62aaa838761c5b1572bd90436dfc96dab02319808036358a59
+libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/e2ace2d6f83a72208f4475c6b19bac4f
+libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/83b537561732308f126efc2b62433b3a0410d6e33834e2593dfdd029c1f874287c4c4c005564f64ded7b7127f839522d24626077f260b0a79cd9be64f9773d32
+libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/3f92c8b09401190a5b5d7699b3e6e5e8
+libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/460e99bf7735ea4dde2adaced43c66c9e91a515e13a516775fee0a02a75d1c1270ff7390d2632af683912ffbef4e142e9d55e8870c3307fbdb4261515ccd1447
+libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/dfc28578d1a2eaa0fb95dee5763024e2
+libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/9188d85d365c65cdfc487ab354e7593193efa3be09b5dc95701cb6244ba276409aa52ae0dbd3907be1b6e156a7d0506c6fa2ba8b60035b774d7ca5451233b287
+libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/8a8f929967e0d26152f145d93a79a4fd
+libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/9d474211b4ec025a56fe2a77bb78e6865fe14235620accc5110a4170a672295419bab55c750d2f7fc0fa1cbecbfa959e07126b8355c95231658446697f489b58
+libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/a8f7ff725142e3de01b6d76ac20fad71
+libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/f29e03f0d7cd5610972c5b1538fa5714484641ce1281871d9f960f026ae9107076cfb9c45ad6bc5cd65f85cac395d978222c95600f4c91556f9386a84ce3088a
+libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/f641a49cd631ade07e66c46c30c66570
+libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/2081495e58ea755f43b76cc4ebc1d09e726f26893e2642b036165f75d417184e2038f97ccbe537f431aead46f8151036cfd4afe96a32192395e48fada13c83aa
+libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/51b06c324130d8e8935bbd8a0b5a5740
+libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/4150ad22761ed19493338d6d155e8c5ecdddf979b212f0fc6cae5ee3722ab4b6b0d4b0493778c665b81f2d4468e43589745b14b270b32953dfe71631d59ea4f5
+libLLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ed66dbfebe14efcdcc1b71ff3a491fff
+libLLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/550db082a181cc53e5336f13cdc34c469f9d5934caf2fde41935068fd7bddc74102b822181d7cfb38848e7409e38975b100bdc2a96c112df335fd91ca326a90b
+libLLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/703841665078d4061bb8f6839c49546f
+libLLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/c48786852da4b367356fc87703ec2dc4efbe9bbd66a16a1edff2f60f009ecac9fd95c54fd5de2e0a56ff8c59bcbf24df2609080c245aa8da166806a55f9868ec
+libLLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/8d8bc21967705c1310219f9f91699a3f
+libLLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/52c44373d708f80409a1a83271effef97dffcb4828bf6d7094119378bc625cf3a2f3f7af649a590dc827fd2859ec3d302287cd235b65cbac9d1273ff241aed8b
+libLLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/59ca3888cdbf9ff4b55d7a1092bbaba3
+libLLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/8b30cc6eecbb496bfdaf2b9c81d5f0a08ae1c02f2433e1bf9dfcbb936d438e12c2a0de99014f325d76dddfda9b833207f615fbcd1d9a25cfc393593c32478621
+libLLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/9298b06192d36c20b56f76348122eec7
+libLLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/ed173f7e0e7663f2186a519cc53429ad326958773a2211dfaff15ac20326617bf85c1233019b5ee996071b1158353ceea307c6ef2f6f617b81771a69072d3c49
+libLLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/b267df02f127fbe710a75ce1b24ec70b
+libLLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/4d78a547ef718810b4e5f2ff81e1edce7492808218e3313587afbc25d59877a2529df3405a9000eb254f88c59822da5a00e764153143b9f7418b0f4adc46c5c9
+libLLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/8719ff4479ca28614a530a97540be161
+libLLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/d913eb261dabe4074566cb4620d7559613ac539b5f4fa5bde8db5d93c0c729ed5c59d177972f283a449a24df0ec76548ac7db26f8e162d7f08619e9bbfdc11cc
+libLLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/f3c3cbbaa2fe0289815dd022608721c3
+libLLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/951adf71911a4b4ec8ad2342c6d4e27797874499e10b8467b56cda5d36496130e72db7e8cda58f0512e04d94c1c144bd66d076451f6048c4c399a9af162202ea
+libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/f9ee9ffa905583656c3405f553667e06
+libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/91a96e8b8eba7d6505d6bdb28af993c7f8724a61c0d7179228035cd631535e5307880884249947f481a82b4f6a37f91c3cc15025383c7ce7302c010eb1130f99
+libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/d80972a0609c688f0a1064cb995e84ff
+libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/136c5f35ad7c41080472bac15f1a433134468f6b512d4ab7d41408da1d27a3aa6b0e5a6480ec185e4a1eee84ab222231f4de21fae7f852a324dfc702a80afd25
+libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/cc16d38262b9f3e1057d50bc57739ea0
+libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/c62bcbde36850de855fe7c0e010a2a403c8b923da1c1bbc8384410e356c112186d1dc874f664260a8e819b0bde8a457746a32a1fc988b103e1277cf00912000f
+libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/70b7a3e70f0f6566e34dcfba524d3ae7
+libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/ae211588739af26ce61f2503adfc9e9711ecb1db5b8ff9072086accbfa55de8ba2086fd09d766d2de15ab3fa6a6a2790be363f20f03b146bd81764a8c6651506
+libLLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/f2e71e81105619177a8d007f6ad8e9a6
+libLLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/dd4f6ee07f69ebd2f49da99d3de3b4394d0520fae6e506fdf4a028e3602c147b0a725f02b0e4712e6568815a460876cfcc05aa453e10ca30f9378925ca12b1d7
+libLLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/fd64aaf12cac1e97a2d6c6a8a73b6bdc
+libLLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/8917408e6f023de7d1f05027d389d9aac7f77623506e9d621487f601e3bc53053b99510266d31840985a380082e7af578c29c400a6dbccc31165bb90bf55bc41
+libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/d05a0f7df67d362e0c48e6a81a7efa73
+libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/8a8adf8b13b02af3ac4ab29e314f689089359b35ac088cf30e0ae8d4d3cc24ca7d63ab908ecc18b6617935a01909e4eae2cdc392b6c7ee69fa0f3cbadff41349
+libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/d84ad34377aceaafcfb2922141b06790
+libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/785bf236810f8c9ff0a6477c978059c136e936150e97bf2c45ec23b23accc0aa2df28442cb456d64f31350d1c49811fa4997029fd9f1044890284be494d68500
+libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/275083a9fb3c2cf281f64f08c840249b
+libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/01598d993a34faa33948d5a56a91401e100018b154112431c4b124e6e5356afa89870699006a6a4358d1bee1bc8155a1c96efba1c62a6fbcbf796087e1334f41
+libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/a7e0e0734e86acf47998c94441922a68
+libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/a96b8e9fa2f34711c7826c4a8615d326fba3b6857ee77b9bf6120dfb3f64638da54fe50c7d6b2fac5aed77755da8d2529ae45daee7f1182b04f8248a34d02f9e
+libLLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/359b3ec71148c1467f3c763e90b5a7ce
+libLLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/673dca9861ec87cc349678fad4b29489cda2a2f8ed02eb87baa893055e9574a0457c69bcacb17a8b3899a380dd43c44cd9632fd6e60bfc26625ceaa8ddf56385
+libLLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/118c299f09ffd7946ab66844e056c9c4
+libLLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/880df9edee1f67ad1c68b504f03dcac492809aa1252589634300441b469cb84e9697771fd0c516ce25da5223814303b0c1d2bea48342d2b42bdda028272e9cbe
+libLLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/ecb34de28c31cdcab980c45d2c90faca
+libLLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/bfb6cbb1ef7a712cb36c7d26de346b3bd7d10f3bbc8fa412b23e7332d2eb432a1bbec338cf92d7899d29036915871ecf70148468ef06dfe0042f5ae547505b1f
+libLLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/eff0891d113de03516e229eb0d9d9c33
+libLLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/078df9260d75354eeab5c6213e3ae926aa4050bc5c3f8691fffa4ce83e32648fefaa78bc67ee3d76a42dc4bad432ffc132e0733d15fe5f85a60f344fd51be639
+libLLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/b28f51c7f01699b1b7488d3c9b7afaa1
+libLLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/297895fcbfd2b46e62e9e685eb08aa7710177a753ee7d6f3211dccd790f2677c9c57f8738785c35368c43dcedabb374ec57c7dd54110e0f153b0b8cc4b40bd5c
+libLLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/3822dc96d157aa849a5c73bafe221b19
+libLLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/a74d9ca78fa7daab47a9a0191356803ce98c8f3d7180073a949fe491d4364f148ff3fdc35d4960dff8ff7f6ecb65b31a471b171c7cab32e89b8252827b059775
+libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/ab93b1ece593bf2fd37902d7cfcb26b9
+libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/3ee486621ec970ba991162a7ac80bc75be46b528a277d256b385a15c96018077862d0708eaa36234530d47d2f83fa934dc7993d4aa32cee0b2885e1c45cb16ab
+libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/22a246271f82a70c9a72d8387fa340ea
+libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/f61f51bb3b7c9d253dcb40ca6a478ac44a6c47bb1f81fc7f562ee682d16081b2307695fb4feb0f3ca495fb8349aafd2b659a4f82b395f7d82e02dc909354b780
+libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/f642a67480e79f269e3bbfe7b3ceed33
+libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/45930e3ae3bf3922c8b3096474cbe22035432e80d2b0f4ccbd424c69e874a76acf4a724e055a5ef73ce40ae00ee6ede60b210b8847c30239a6ec242550a3e464
+libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/344f2a9d2b85a6c527fd6fa024d6763e
+libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/73909c58087568d8654d48ed5fc952289d8b3a4e26e956e9220cf254b8fb2c4b6630ebc9258502a6c3b67ed3cfe0cbe3a92ee3d346b228d842af03f0a42794c7
+llvm-julia-16.0.6-2.tar.gz/md5/71ca2225b042ec5ae666c99fa1bd19b1
+llvm-julia-16.0.6-2.tar.gz/sha512/6f2513adea1b939229c9be171e7ce41e488b3cfaa2e615912c4bc1ddaf0ab2e75df213a5d5db80105d6473a8017b0656016bbbb085ef00a38073519668885884
 llvmunwind-12.0.1.tar.xz/md5/4ec327cee517fdb1f6a20e83748e2c7b
 llvmunwind-12.0.1.tar.xz/sha512/847b6ba03010a43f4fdbfdc49bf16d18fd18474d01584712e651b11191814bf7c1cf53475021d9ee447ed78413202b4ed97973d7bdd851d3e49f8d06f55a7af4
diff --git a/deps/clang.version b/deps/clang.version
index 853a22d1dfc7d..a950bc32aca6b 100644
--- a/deps/clang.version
+++ b/deps/clang.version
@@ -1,4 +1,4 @@
 ## jll artifact
 # Clang (paired with LLVM, only here as a JLL download)
 CLANG_JLL_NAME := Clang
-CLANG_JLL_VER  := 16.0.6+3
+CLANG_JLL_VER  := 16.0.6+4
diff --git a/deps/lld.version b/deps/lld.version
index d61d973917b80..949577bdacae2 100644
--- a/deps/lld.version
+++ b/deps/lld.version
@@ -1,3 +1,3 @@
 ## jll artifact
 LLD_JLL_NAME := LLD
-LLD_JLL_VER := 16.0.6+3
+LLD_JLL_VER := 16.0.6+4
diff --git a/deps/llvm-tools.version b/deps/llvm-tools.version
index 54a1fa6b531a9..8191c8742dcbb 100644
--- a/deps/llvm-tools.version
+++ b/deps/llvm-tools.version
@@ -1,5 +1,5 @@
 ## jll artifact
 # LLVM_tools (downloads LLVM_jll to get things like `lit` and `opt`)
 LLVM_TOOLS_JLL_NAME := LLVM
-LLVM_TOOLS_JLL_VER := 16.0.6+3
-LLVM_TOOLS_ASSERT_JLL_VER := 16.0.6+3
+LLVM_TOOLS_JLL_VER := 16.0.6+4
+LLVM_TOOLS_ASSERT_JLL_VER := 16.0.6+4
diff --git a/deps/llvm.version b/deps/llvm.version
index 1f12302452c31..7e74cf2e4fd65 100644
--- a/deps/llvm.version
+++ b/deps/llvm.version
@@ -2,7 +2,7 @@
 
 ## jll artifact
 LLVM_JLL_NAME := libLLVM
-LLVM_ASSERT_JLL_VER := 16.0.6+3
+LLVM_ASSERT_JLL_VER := 16.0.6+4
 ## source build
 # Version number of LLVM
 LLVM_VER := 16.0.6
diff --git a/stdlib/LLD_jll/Project.toml b/stdlib/LLD_jll/Project.toml
index 6f886279ab786..fccea03ebd80e 100644
--- a/stdlib/LLD_jll/Project.toml
+++ b/stdlib/LLD_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LLD_jll"
 uuid = "d55e3150-da41-5e91-b323-ecfd1eec6109"
-version = "16.0.6+3"
+version = "16.0.6+4"
 
 [deps]
 Zlib_jll = "83775a58-1f1d-513f-b197-d71354ab007a"
diff --git a/stdlib/libLLVM_jll/Project.toml b/stdlib/libLLVM_jll/Project.toml
index d74b2bb4892b0..3decbf5f81512 100644
--- a/stdlib/libLLVM_jll/Project.toml
+++ b/stdlib/libLLVM_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "libLLVM_jll"
 uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
-version = "16.0.6+3"
+version = "16.0.6+4"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 321cc2d5423175fade20bf823e7402f278768eac Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Tue, 6 Feb 2024 16:35:49 -0500
Subject: [PATCH 0814/1315] add specialized `reverse` implementation for
 `NTuple` (#50113)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This adds a specialized version of `reverse` for NTuple
using a simple constructor.

1.9:
```
julia> a = tuple(rand(Int, 256)...);

julia> @benchmark reverse($a)
BenchmarkTools.Trial: 7099 samples with 1 evaluation.
 Range (min … max):  611.280 μs …   5.698 ms  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     670.392 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   700.950 μs ± 144.952 μs  ┊ GC (mean ± σ):  1.37% ± 5.70%

   ▃▄██▇▆▆▆▆▄▂                                                  ▂
  ▇███████████▇▇▆▄▇█▅▅▅▃▄▁▁▁▁▃▄▄▁▁▁▃▁▃▁▁▄▃▄▅▆▅▆▆▅▅▆▇▆▆▇▇▇█▇▆▇▇▆ █
  611 μs        Histogram: log(frequency) by time       1.33 ms <

 Memory estimate: 794.42 KiB, allocs estimate: 33663.
```

This commit:
```
julia> @benchmark reverse($a)
BenchmarkTools.Trial: 10000 samples with 995 evaluations.
 Range (min … max):  26.252 ns … 52.545 ns  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     26.285 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   26.578 ns ±  0.940 ns  ┊ GC (mean ± σ):  0.00% ± 0.00%

  █▆▂                                                      ▁  ▁
  ████▆▅▆▅▄▄▄▂▃▄███▇▆▆▆▅▆▄▅▅▆█▇▆▄▅▆▆▅▆██▅▅▅▄▅▅▄▅▄▅▅▅▄▅▃▅▂▄▄██ █
  26.3 ns      Histogram: log(frequency) by time      30.2 ns <

 Memory estimate: 0 bytes, allocs estimate: 0.
```
---
 base/ntuple.jl | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/base/ntuple.jl b/base/ntuple.jl
index 4720e7a3915a8..74dc9f3796dbf 100644
--- a/base/ntuple.jl
+++ b/base/ntuple.jl
@@ -88,3 +88,11 @@ end
         (t..., fill(val, N-M)...)
     end
 end
+
+
+# Specialized extensions for NTuple
+function reverse(t::NTuple{N}) where N
+    ntuple(Val{N}()) do i
+        t[end+1-i]
+    end
+end

From 522cf3befcffcefbd3b3ad64ad3e4f810fadaffa Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Tue, 6 Feb 2024 16:40:20 -0500
Subject: [PATCH 0815/1315] add docstring and doctest for `Base.format_bytes`
 (#52976)

There are many uses of this function throughout the package
ecosystem. In addition, it is common to see it re-implemented.
This adds some docstrings and tests for `Base.format_bytes`.
---
 base/timing.jl | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/base/timing.jl b/base/timing.jl
index 382a16e61b1e4..ecb67a2375d92 100644
--- a/base/timing.jl
+++ b/base/timing.jl
@@ -135,6 +135,30 @@ function padded_nonzero_print(value, str, always_print = true)
     end
 end
 
+"""
+    format_bytes(bytes; binary=true)
+
+Format a given number of bytes into a human-readable string.
+
+# Arguments
+- `bytes`: The number of bytes to format.
+- `binary=true`: If `true`, formats the bytes in binary units (powers of 1024). If `false`, uses decimal units (powers of 1000).
+
+# Returns
+`String`: A human-readable string representation of the bytes, formatted in either binary or decimal units based on the `binary` argument.
+
+# Examples
+```jldoctest
+julia> Base.format_bytes(1024)
+"1024 bytes"
+
+julia> Base.format_bytes(10000)
+"9.766 KiB"
+
+julia> Base.format_bytes(10000, binary=false)
+"10.000 kB"
+```
+"""
 function format_bytes(bytes; binary=true) # also used by InteractiveUtils
     units = binary ? _mem_units : _cnt_units
     factor = binary ? 1024 : 1000

From 34f14961cde9070ed09dae17bfb11f90eb80b22b Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 6 Feb 2024 16:45:41 -0500
Subject: [PATCH 0816/1315] rename init.c func `abspath` -> `absrealpath`
 (#52574)

For clarification given its behavior is not the same as julia's
`abspath`

Related https://github.com/JuliaLang/julia/issues/52458
---
 src/init.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/init.c b/src/init.c
index d4128c8ae9e40..801f12ec53930 100644
--- a/src/init.c
+++ b/src/init.c
@@ -539,7 +539,7 @@ int jl_isabspath(const char *in) JL_NOTSAFEPOINT
     return 0; // relative path
 }
 
-static char *abspath(const char *in, int nprefix)
+static char *absrealpath(const char *in, int nprefix)
 { // compute an absolute realpath location, so that chdir doesn't change the file reference
   // ignores (copies directly over) nprefix characters at the start of abspath
 #ifndef _OS_WINDOWS_
@@ -655,7 +655,7 @@ static void jl_resolve_sysimg_location(JL_IMAGE_SEARCH rel)
         }
     }
     if (jl_options.julia_bindir)
-        jl_options.julia_bindir = abspath(jl_options.julia_bindir, 0);
+        jl_options.julia_bindir = absrealpath(jl_options.julia_bindir, 0);
     free(free_path);
     free_path = NULL;
     if (jl_options.image_file) {
@@ -670,33 +670,33 @@ static void jl_resolve_sysimg_location(JL_IMAGE_SEARCH rel)
             jl_options.image_file = free_path;
         }
         if (jl_options.image_file)
-            jl_options.image_file = abspath(jl_options.image_file, 0);
+            jl_options.image_file = absrealpath(jl_options.image_file, 0);
         if (free_path) {
             free(free_path);
             free_path = NULL;
         }
     }
     if (jl_options.outputo)
-        jl_options.outputo = abspath(jl_options.outputo, 0);
+        jl_options.outputo = absrealpath(jl_options.outputo, 0);
     if (jl_options.outputji)
-        jl_options.outputji = abspath(jl_options.outputji, 0);
+        jl_options.outputji = absrealpath(jl_options.outputji, 0);
     if (jl_options.outputbc)
-        jl_options.outputbc = abspath(jl_options.outputbc, 0);
+        jl_options.outputbc = absrealpath(jl_options.outputbc, 0);
     if (jl_options.outputasm)
-        jl_options.outputasm = abspath(jl_options.outputasm, 0);
+        jl_options.outputasm = absrealpath(jl_options.outputasm, 0);
     if (jl_options.machine_file)
-        jl_options.machine_file = abspath(jl_options.machine_file, 0);
+        jl_options.machine_file = absrealpath(jl_options.machine_file, 0);
     if (jl_options.output_code_coverage)
         jl_options.output_code_coverage = absformat(jl_options.output_code_coverage);
     if (jl_options.tracked_path)
-        jl_options.tracked_path = abspath(jl_options.tracked_path, 0);
+        jl_options.tracked_path = absrealpath(jl_options.tracked_path, 0);
 
     const char **cmdp = jl_options.cmds;
     if (cmdp) {
         for (; *cmdp; cmdp++) {
             const char *cmd = *cmdp;
             if (cmd[0] == 'L') {
-                *cmdp = abspath(cmd, 1);
+                *cmdp = absrealpath(cmd, 1);
             }
         }
     }

From 101aa3911d438580921a6e9721f193d9694c26d8 Mon Sep 17 00:00:00 2001
From: Rafael Schouten <rafaelschouten@gmail.com>
Date: Tue, 6 Feb 2024 22:49:05 +0100
Subject: [PATCH 0817/1315] Remove allocation from PermutedDimsArray
 constructor (#53185)

Remove allocation from PermutedDimsArray constructor by
replacing `all(map(pred, ...))` with `all(pred, ...)`.
---
 base/permuteddimsarray.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/permuteddimsarray.jl b/base/permuteddimsarray.jl
index c66f441d6f963..c7fe5a9dfe0db 100644
--- a/base/permuteddimsarray.jl
+++ b/base/permuteddimsarray.jl
@@ -12,7 +12,7 @@ struct PermutedDimsArray{T,N,perm,iperm,AA<:AbstractArray} <: AbstractArray{T,N}
     function PermutedDimsArray{T,N,perm,iperm,AA}(data::AA) where {T,N,perm,iperm,AA<:AbstractArray}
         (isa(perm, NTuple{N,Int}) && isa(iperm, NTuple{N,Int})) || error("perm and iperm must both be NTuple{$N,Int}")
         isperm(perm) || throw(ArgumentError(string(perm, " is not a valid permutation of dimensions 1:", N)))
-        all(map(d->iperm[perm[d]]==d, 1:N)) || throw(ArgumentError(string(perm, " and ", iperm, " must be inverses")))
+        all(d->iperm[perm[d]]==d, 1:N) || throw(ArgumentError(string(perm, " and ", iperm, " must be inverses")))
         new(data)
     end
 end

From 32687b044514db3af1b5e815d09f001402885b73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Leandro=20Mart=C3=ADnez?=
 <31046348+lmiq@users.noreply.github.com>
Date: Tue, 6 Feb 2024 21:59:21 -0300
Subject: [PATCH 0818/1315] Clarify the docs of @__DIR__ (#52442)

The original docs start with `Expand`, which is already a concept that
might not be clear to the reader. Furthermore, in this version there is
an example to illustrate how this macro is different from `pwd()`.
---
 base/loading.jl | 29 ++++++++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 33ad95620188d..2815195363b8a 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -3533,9 +3533,32 @@ end
 """
     @__DIR__ -> String
 
-Expand to a string with the absolute path to the directory of the file
-containing the macrocall.
-Return the current working directory if run from a REPL or if evaluated by `julia -e <expr>`.
+Macro to obtain the absolute path of the current directory as a string.
+
+If in a script, returns the directory of the script containing the `@__DIR__` macrocall. If run from a
+REPL or if evaluated by `julia -e <expr>`, returns the current working directory.
+
+# Example
+
+The example illustrates the difference in the behaviors of `@__DIR__` and `pwd()`, by creating
+a simple script in a different directory than the current working one and executing both commands:
+
+```julia-repl
+julia> cd("/home/JuliaUser") # working directory
+
+julia> # create script at /home/JuliaUser/Projects
+       open("/home/JuliaUser/Projects/test.jl","w") do io
+           print(io, """
+               println("@__DIR__ = ", @__DIR__)
+               println("pwd() = ", pwd())
+           """)
+       end
+
+julia> # outputs script directory and current working directory
+       include("/home/JuliaUser/Projects/test.jl")
+@__DIR__ = /home/JuliaUser/Projects
+pwd() = /home/JuliaUser
+```
 """
 macro __DIR__()
     __source__.file === nothing && return nothing

From fc1c1cd0e7c0e48c05bd2f7e9e56b4e08b757514 Mon Sep 17 00:00:00 2001
From: re1san <105774228+re1san@users.noreply.github.com>
Date: Wed, 7 Feb 2024 08:01:00 +0530
Subject: [PATCH 0819/1315] Add missing artifact functions to docs output
 (#52698)

Fixes #52688

Co-authored-by: re1san <kathareaniket47@gmail.com>
---
 stdlib/Artifacts/docs/src/index.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/stdlib/Artifacts/docs/src/index.md b/stdlib/Artifacts/docs/src/index.md
index 2f6c9a07a8761..1bd75832fb8d3 100644
--- a/stdlib/Artifacts/docs/src/index.md
+++ b/stdlib/Artifacts/docs/src/index.md
@@ -22,4 +22,7 @@ Artifacts.artifact_meta
 Artifacts.artifact_hash
 Artifacts.find_artifacts_toml
 Artifacts.@artifact_str
+Artifacts.artifact_exists
+Artifacts.artifact_path
+Artifacts.select_downloadable_artifacts
 ```

From 76b8b2acbb40c3a41a14742fec8d440375ef5445 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Wed, 7 Feb 2024 03:36:51 +0100
Subject: [PATCH 0820/1315] improve return type inference for `string` (#52806)

Packages like URIs.jl overload `joinpath` with methods that return
non-strings. This prevents good return type inference for `string` when
the types of its arguments are unknown. Even if this is a URIs.jl bug,
it makes sense to be defensive about this in the Julia implementation.
Also note that URIs.jl is widely-used, JuliaHub says it's got in excess
of a thousand (indirect) dependents.

So, IMO, this is a Julia bug that we should fix:

```julia-repl
julia> all(T -> T <: AbstractString, Base.return_types(string))
true

julia> import URIs

julia> all(T -> T <: AbstractString, Base.return_types(string))
false
```

Fixed by adding a `::String` type assertion in `base/libdl.jl`.
---
 base/libdl.jl      | 2 +-
 test/strings/io.jl | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/base/libdl.jl b/base/libdl.jl
index 09f4ad4ea2159..38dd86ca55f62 100644
--- a/base/libdl.jl
+++ b/base/libdl.jl
@@ -334,7 +334,7 @@ struct LazyLibraryPath
     LazyLibraryPath(pieces::Vector) = new(pieces)
 end
 LazyLibraryPath(args...) = LazyLibraryPath(collect(args))
-Base.string(llp::LazyLibraryPath) = joinpath(string.(llp.pieces)...)
+Base.string(llp::LazyLibraryPath) = joinpath(string.(llp.pieces)...)::String
 Base.cconvert(::Type{Cstring}, llp::LazyLibraryPath) = Base.cconvert(Cstring, string(llp))
 # Define `print` so that we can wrap this in a `LazyString`
 Base.print(io::IO, llp::LazyLibraryPath) = print(io, string(llp))
diff --git a/test/strings/io.jl b/test/strings/io.jl
index 5f657297af08f..f1fe0c24e8aea 100644
--- a/test/strings/io.jl
+++ b/test/strings/io.jl
@@ -330,3 +330,12 @@ end
     # test empty args
     @test string() == ""
 end
+
+module StringsIOStringReturnTypesTestModule
+    struct S end
+    Base.joinpath(::S) = S()
+end
+
+@testset "`string` return types" begin
+    @test all(T -> T <: AbstractString, Base.return_types(string))
+end

From 0c804bd54b96d24ff2e9d4680ba3baed4771aec7 Mon Sep 17 00:00:00 2001
From: Jeremie Knuesel <knuesel@gmail.com>
Date: Wed, 7 Feb 2024 03:37:53 +0100
Subject: [PATCH 0821/1315] Add InteractiveUtils in doc refs to define_editor
 (#52927)

Otherwise since `define_editor` is not exported, it's hard for the user
to find what it's referring to.

(Another possibility would be to export `define_editor`)
---
 stdlib/InteractiveUtils/src/editless.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stdlib/InteractiveUtils/src/editless.jl b/stdlib/InteractiveUtils/src/editless.jl
index 539e9b12f4071..74fc5c6becfbd 100644
--- a/stdlib/InteractiveUtils/src/editless.jl
+++ b/stdlib/InteractiveUtils/src/editless.jl
@@ -223,7 +223,7 @@ Edit a file or directory optionally providing a line number to edit the file at.
 Return to the `julia` prompt when you quit the editor. The editor can be changed
 by setting `JULIA_EDITOR`, `VISUAL` or `EDITOR` as an environment variable.
 
-See also [`define_editor`](@ref).
+See also [`InteractiveUtils.define_editor`](@ref).
 """
 function edit(path::AbstractString, line::Integer=0, column::Integer=0)
     path isa String || (path = convert(String, path))
@@ -255,7 +255,7 @@ method to edit. For modules, open the main source file. The module needs to be l
     `edit` on modules requires at least Julia 1.1.
 
 To ensure that the file can be opened at the given line, you may need to call
-`define_editor` first.
+`InteractiveUtils.define_editor` first.
 """
 function edit(@nospecialize f)
     ms = methods(f).ms

From 41bbfb45964d9962fa2d65c7efc170561e781d99 Mon Sep 17 00:00:00 2001
From: Michael Abbott <32575566+mcabbott@users.noreply.github.com>
Date: Tue, 6 Feb 2024 21:39:00 -0500
Subject: [PATCH 0822/1315] Add explicit mention of branch cuts to `log`,
 `sqrt`, `angle` docstrings (#52970)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I realised that `angle` doesn't even specify that it's in -π to π.

These are all pretty standard but perhaps we should be explicit.
---
 base/complex.jl | 12 +++++++++---
 base/math.jl    | 27 ++++++++++++++++++++++-----
 2 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/base/complex.jl b/base/complex.jl
index 31b4ba5d3365a..f14b7f2f5336f 100644
--- a/base/complex.jl
+++ b/base/complex.jl
@@ -625,7 +625,10 @@ end
 
 Compute the phase angle in radians of a complex number `z`.
 
-See also: [`atan`](@ref), [`cis`](@ref).
+Returns a number `-pi ≤ angle(z) ≤ pi`, and is thus discontinuous
+along the negative real axis.
+
+See also: [`atan`](@ref), [`cis`](@ref), [`rad2deg`](@ref).
 
 # Examples
 ```jldoctest
@@ -635,8 +638,11 @@ julia> rad2deg(angle(1 + im))
 julia> rad2deg(angle(1 - im))
 -45.0
 
-julia> rad2deg(angle(-1 - im))
--135.0
+julia> rad2deg(angle(-1 + 1e-20im))
+180.0
+
+julia> rad2deg(angle(-1 - 1e-20im))
+-180.0
 ```
 """
 angle(z::Complex) = atan(imag(z), real(z))
diff --git a/base/math.jl b/base/math.jl
index 47f3afb56979e..b0870c60016f7 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -453,7 +453,7 @@ tanh(x::Number)
 
 Compute the inverse tangent of `y` or `y/x`, respectively.
 
-For one argument, this is the angle in radians between the positive *x*-axis and the point
+For one real argument, this is the angle in radians between the positive *x*-axis and the point
 (1, *y*), returning a value in the interval ``[-\\pi/2, \\pi/2]``.
 
 For two arguments, this is the angle in radians between the positive *x*-axis and the
@@ -581,8 +581,11 @@ atanh(x::Number)
 """
     log(x)
 
-Compute the natural logarithm of `x`. Throws [`DomainError`](@ref) for negative
-[`Real`](@ref) arguments. Use complex negative arguments to obtain complex results.
+Compute the natural logarithm of `x`.
+
+Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
+Use complex arguments to obtain complex results.
+Has a branch cut along the negative real axis, for which `-0.0im` is taken to be below the axis.
 
 See also [`ℯ`](@ref), [`log1p`](@ref), [`log2`](@ref), [`log10`](@ref).
 
@@ -598,6 +601,12 @@ Stacktrace:
  [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
 [...]
 
+julia> log(-3 + 0im)
+1.0986122886681098 + 3.141592653589793im
+
+julia> log(-3 - 0.0im)
+1.0986122886681098 - 3.141592653589793im
+
 julia> log.(exp.(-1:1))
 3-element Vector{Float64}:
  -1.0
@@ -695,8 +704,13 @@ end
 """
     sqrt(x)
 
-Return ``\\sqrt{x}``. Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
-Use complex negative arguments instead. The prefix operator `√` is equivalent to `sqrt`.
+Return ``\\sqrt{x}``.
+
+Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
+Use complex negative arguments instead. Note that `sqrt` has a branch cut
+along the negative real axis.
+
+The prefix operator `√` is equivalent to `sqrt`.
 
 See also: [`hypot`](@ref).
 
@@ -715,6 +729,9 @@ Stacktrace:
 julia> sqrt(big(complex(-81)))
 0.0 + 9.0im
 
+julia> sqrt(-81 - 0.0im)  # -0.0im is below the branch cut
+0.0 - 9.0im
+
 julia> .√(1:4)
 4-element Vector{Float64}:
  1.0

From d453af81c8c70f06b2c8b70cef566ffdc5705958 Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Tue, 6 Feb 2024 23:53:09 -0500
Subject: [PATCH 0823/1315] Fix escaping of docstring in `@__DIR__` (#53225)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This issue was introduced in #52442.
The markdown parser had issues with the triple-quotes.
Usually you can use quadruple-quotes to fix this, but
this does not appear to be supported, so we escape
each with backslash.

Here is the corrected docstring rendered:

```julia-repl
help?> @__DIR__
  @__DIR__ -> String

  Macro to obtain the absolute path of the current directory as a string.

  If in a script, returns the directory of the script containing the @__DIR__ macrocall. If run from a REPL or if
  evaluated by julia -e <expr>, returns the current working directory.

  Example
  ≡≡≡≡≡≡≡

  The example illustrates the difference in the behaviors of @__DIR__ and pwd(), by creating a simple script in a
  different directory than the current working one and executing both commands:

  julia> cd("/home/JuliaUser") # working directory

  julia> # create script at /home/JuliaUser/Projects
         open("/home/JuliaUser/Projects/test.jl","w") do io
             print(io, """
                 println("@__DIR__ = ", @__DIR__)
                 println("pwd() = ", pwd())
             """)
         end

  julia> # outputs script directory and current working directory
         include("/home/JuliaUser/Projects/test.jl")
  @__DIR__ = /home/JuliaUser/Projects
  pwd() = /home/JuliaUser
```
---
 base/loading.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 2815195363b8a..cb4bdf518b816 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -3548,10 +3548,10 @@ julia> cd("/home/JuliaUser") # working directory
 
 julia> # create script at /home/JuliaUser/Projects
        open("/home/JuliaUser/Projects/test.jl","w") do io
-           print(io, """
+           print(io, \"\"\"
                println("@__DIR__ = ", @__DIR__)
                println("pwd() = ", pwd())
-           """)
+           \"\"\")
        end
 
 julia> # outputs script directory and current working directory

From e22db88127197cb3236e350cdb4ccbfff6cde232 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Wed, 7 Feb 2024 13:08:24 +0000
Subject: [PATCH 0824/1315] [deps] Do not build OpenBLAS Bfloat16 kernels in
 from source build (#53221)

Not clear why OpenBLAS build fails, GCC 10 should be sufficient to
compile the Bfloat16 kernels and [from what I can
tell](https://github.com/JuliaLang/julia/issues/53172#issuecomment-1930144786)
that's the compiler version used in CI, but I don't know how to verify
it since this is a nightly job. If someone who knows more about the
setup can chime in, that'd be great. In the meantime, disabling these
kernels should fix #53172.
---
 deps/openblas.mk | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/deps/openblas.mk b/deps/openblas.mk
index c24ce47d359c1..d1e0c03aabb1c 100644
--- a/deps/openblas.mk
+++ b/deps/openblas.mk
@@ -20,9 +20,6 @@ endif
 # don't touch scheduler affinity since we manage this ourselves
 OPENBLAS_BUILD_OPTS += NO_AFFINITY=1
 
-# Build BFloat16 kernels
-OPENBLAS_BUILD_OPTS += BUILD_BFLOAT16=1
-
 # Build for all architectures - required for distribution
 ifeq ($(SANITIZE_MEMORY),1)
 OPENBLAS_BUILD_OPTS += TARGET=GENERIC

From d765ad1533d8a43b8a1500bcea7aa43b7d67eead Mon Sep 17 00:00:00 2001
From: Arjun R Maniyani <74970809+mokshablr@users.noreply.github.com>
Date: Wed, 7 Feb 2024 19:26:14 +0530
Subject: [PATCH 0825/1315] Added documentation for the Markdown Macro (#52607)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 stdlib/Markdown/docs/src/index.md | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/stdlib/Markdown/docs/src/index.md b/stdlib/Markdown/docs/src/index.md
index 3da136c0692ec..ad620c22eae5d 100644
--- a/stdlib/Markdown/docs/src/index.md
+++ b/stdlib/Markdown/docs/src/index.md
@@ -392,6 +392,16 @@ If no title text is specified after the admonition type, then the type name will
 
 Admonitions, like most other toplevel elements, can contain other toplevel elements (e.g. lists, images).
 
+## [Markdown String Literals](@id stdlib-markdown-literals)
+
+The `md""` macro allows you to embed Markdown strings directly into your Julia code.
+This macro is designed to simplify the inclusion of Markdown-formatted text within your Julia source files.
+
+### Usage
+
+```julia
+result = md"This is a **custom** Markdown string with [a link](http://example.com)."
+```
 ## Markdown Syntax Extensions
 
 Julia's markdown supports interpolation in a very similar way to basic string literals, with the
@@ -403,9 +413,6 @@ complex features (such as references) without cluttering the basic syntax.
 In principle, the Markdown parser itself can also be arbitrarily extended by packages, or an entirely
 custom flavour of Markdown can be used, but this should generally be unnecessary.
 
-## [Markdown String Literals](@id stdlib-markdown-literals)
-
-Markdown strings can be constructed using the string literal syntax `md"..."`.
 
 ## [API reference](@id stdlib-markdown-api)
 

From bead1d32f1ad09e22cb40ce6e7ec268189359644 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Wed, 7 Feb 2024 09:50:51 -0500
Subject: [PATCH 0826/1315] fix spurious overflow for Float16(::Rational)
 (#52395)

Fixes #52394.

Also fixes `Float32` for `UInt128`, since currently
`Float32((typemax(UInt128)-0x01) // typemax(UInt128))` gives `Nan32`.
---
 base/rational.jl | 8 ++++++++
 test/float16.jl  | 5 +++++
 2 files changed, 13 insertions(+)

diff --git a/base/rational.jl b/base/rational.jl
index 1b060384d95b2..d419ac83636e8 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -145,6 +145,14 @@ function (::Type{T})(x::Rational{S}) where T<:AbstractFloat where S
     P = promote_type(T,S)
     convert(T, convert(P,x.num)/convert(P,x.den))::T
 end
+ # avoid spurious overflow (#52394).  (Needed for UInt16 or larger;
+ # we also include Int16 for consistency of accuracy.)
+Float16(x::Rational{<:Union{Int16,Int32,Int64,UInt16,UInt32,UInt64}}) =
+    Float16(Float32(x))
+Float16(x::Rational{<:Union{Int128,UInt128}}) =
+    Float16(Float64(x)) # UInt128 overflows Float32, include Int128 for consistency
+Float32(x::Rational{<:Union{Int128,UInt128}}) =
+    Float32(Float64(x)) # UInt128 overflows Float32, include Int128 for consistency
 
 function Rational{T}(x::AbstractFloat) where T<:Integer
     r = rationalize(T, x, tol=0)
diff --git a/test/float16.jl b/test/float16.jl
index 75f9b55b6d51c..10fb6b37db16d 100644
--- a/test/float16.jl
+++ b/test/float16.jl
@@ -203,6 +203,11 @@ const minsubf16_32 = Float32(minsubf16)
 # issues #33076
 @test Float16(1f5) == Inf16
 
+# issue #52394
+@test Float16(10^8 // (10^9 + 1)) == convert(Float16, 10^8 // (10^9 + 1)) == Float16(0.1)
+@test Float16((typemax(UInt128)-0x01) // typemax(UInt128)) == Float16(1.0)
+@test Float32((typemax(UInt128)-0x01) // typemax(UInt128)) == Float32(1.0)
+
 @testset "conversion to Float16 from" begin
     for T in (Float32, Float64, BigFloat)
         @testset "conversion from $T" begin

From 736eeda72493f02247994785d5b5a9c8f9dca2f5 Mon Sep 17 00:00:00 2001
From: Michael Goerz <mail@michaelgoerz.net>
Date: Wed, 7 Feb 2024 10:03:21 -0500
Subject: [PATCH 0827/1315] docs: remove outdated discussion about externally
 changing module bindings (#53170)

As of Julia 1.9, bindings in modules can be changed directly.

See https://discourse.julialang.org/t/clarify-the-documentation-about-modifying-module-variables/109668/3
---
 doc/src/manual/variables-and-scoping.md | 27 +------------------------
 1 file changed, 1 insertion(+), 26 deletions(-)

diff --git a/doc/src/manual/variables-and-scoping.md b/doc/src/manual/variables-and-scoping.md
index 6a6f176650b2a..e921ed8931e84 100644
--- a/doc/src/manual/variables-and-scoping.md
+++ b/doc/src/manual/variables-and-scoping.md
@@ -67,32 +67,7 @@ Each module introduces a new global scope, separate from the global scope of all
 is no all-encompassing global scope. Modules can introduce variables of other modules into their
 scope through the [using or import](@ref modules) statements or through qualified access using the
 dot-notation, i.e. each module is a so-called *namespace* as well as a first-class data structure
-associating names with values. Note that while variable bindings can be read externally, they can only
-be changed within the module to which they belong. As an escape hatch, you can always evaluate code
-inside that module to modify a variable; this guarantees, in particular, that module bindings cannot
-be modified externally by code that never calls `eval`.
-
-```jldoctest
-julia> module A
-           a = 1 # a global in A's scope
-       end;
-
-julia> module B
-           module C
-               c = 2
-           end
-           b = C.c    # can access the namespace of a nested global scope
-                      # through a qualified access
-           import ..A # makes module A available
-           d = A.a
-       end;
-
-julia> module D
-           b = a # errors as D's global scope is separate from A's
-       end;
-ERROR: UndefVarError: `a` not defined in `D`
-Suggestion: check for spelling errors or missing imports.
-```
+associating names with values.
 
 If a top-level expression contains a variable declaration with keyword `local`,
 then that variable is not accessible outside that expression.

From d24316ac6465302aa32d9616ab731499c3734bce Mon Sep 17 00:00:00 2001
From: Nathan Zimmerberg <39104088+nhz2@users.noreply.github.com>
Date: Wed, 7 Feb 2024 10:53:14 -0500
Subject: [PATCH 0828/1315] Fix Int8(-128) // Int8(-128)  (#51944)

Fixes #51731 and #51730

Also fixes one of the previously broken tests:
```julia
@test_broken Rational{Int64}(UInt(1), typemin(Int32)) == Int64(1) // Int64(typemin(Int32))
```

This PR ensures the `Rational{T}` constructor with concrete `T` will
only throw if the final numerator and denominator cannot be represented
by `T`, or are both zero.

If the `T` in `Rational{T}` is not concrete, this PR tries to ensure the
numerator and denominator are promoted to the same type.
This means `-1*Rational{Integer}(-1, 0x01) == 1` doesn't throw now. A
side effect of this is that `Rational{Integer}(Int8(-1), 0x01)` now
throws.

Also, related to
<https://github.com/JuliaLang/julia/pull/25702#issuecomment-359821951>,
now `divgcd` doesn't change the types of its inputs and can handle
`typemin`, but it still throws a `DivideError` if both inputs are zero.
---
 base/rational.jl | 21 +++++++++++++-----
 test/rational.jl | 58 +++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 73 insertions(+), 6 deletions(-)

diff --git a/base/rational.jl b/base/rational.jl
index d419ac83636e8..b27baf5973d3b 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -30,16 +30,27 @@ checked_den(num::Integer, den::Integer) = checked_den(promote(num, den)...)
 @noinline __throw_rational_argerror_zero(T) = throw(ArgumentError("invalid rational: zero($T)//zero($T)"))
 function Rational{T}(num::Integer, den::Integer) where T<:Integer
     iszero(den) && iszero(num) && __throw_rational_argerror_zero(T)
-    num, den = divgcd(num, den)
-    return checked_den(T, T(num), T(den))
+    if T <: Union{Unsigned, Bool}
+        # Throw InexactError if the result is negative.
+        if !iszero(num) && (signbit(den) ⊻ signbit(num))
+            throw(InexactError(:Rational, Rational{T}, num, den))
+        end
+        unum = uabs(num)
+        uden = uabs(den)
+        r_unum, r_uden = divgcd(unum, uden)
+        return unsafe_rational(T, promote(T(r_unum), T(r_uden))...)
+    else
+        r_num, r_den = divgcd(num, den)
+        return checked_den(T, promote(T(r_num), T(r_den))...)
+    end
 end
 
 Rational(n::T, d::T) where {T<:Integer} = Rational{T}(n, d)
 Rational(n::Integer, d::Integer) = Rational(promote(n, d)...)
 Rational(n::Integer) = unsafe_rational(n, one(n))
 
-function divgcd(x::Integer,y::Integer)
-    g = gcd(x,y)
+function divgcd(x::TX, y::TY)::Tuple{TX, TY} where {TX<:Integer, TY<:Integer}
+    g = gcd(uabs(x), uabs(y))
     div(x,g), div(y,g)
 end
 
@@ -130,7 +141,7 @@ function Rational{T}(x::Rational) where T<:Integer
     unsafe_rational(T, convert(T, x.num), convert(T, x.den))
 end
 function Rational{T}(x::Integer) where T<:Integer
-    unsafe_rational(T, convert(T, x), one(T))
+    unsafe_rational(T, T(x), T(one(x)))
 end
 
 Rational(x::Rational) = x
diff --git a/test/rational.jl b/test/rational.jl
index 118f2e6289228..b59b25c20656e 100644
--- a/test/rational.jl
+++ b/test/rational.jl
@@ -52,11 +52,54 @@ using Test
     @test_throws OverflowError Int8(-128)//Int8(-1)
     @test_throws OverflowError Int8(-1)//Int8(-128)
     @test Int8(-128)//Int8(-2) == 64
+    # issue 51731
+    @test Rational{Int8}(-128) / Rational{Int8}(-128) === Rational{Int8}(1)
+    # issue 51731
+    @test Rational{Int8}(-128) / Rational{Int8}(0) === Rational{Int8}(-1, 0)
+    @test Rational{Int8}(0) / Rational{Int8}(-128) === Rational{Int8}(0, 1)
 
     @test_throws InexactError Rational(UInt(1), typemin(Int32))
     @test iszero(Rational{Int}(UInt(0), 1))
     @test Rational{BigInt}(UInt(1), Int(-1)) == -1
-    @test_broken Rational{Int64}(UInt(1), typemin(Int32)) == Int64(1) // Int64(typemin(Int32))
+    @test Rational{Int64}(UInt(1), typemin(Int32)) == Int64(1) // Int64(typemin(Int32))
+
+    @testset "Rational{T} constructor with concrete T" begin
+        test_types = [Bool, Int8, Int64, Int128, UInt8, UInt64, UInt128, BigInt]
+        test_values = Any[
+            Any[zero(T) for T in test_types];
+            Any[one(T) for T in test_types];
+            big(-1);
+            collect(Iterators.flatten(
+                (T(j) for T in (Int8, Int64, Int128)) for j in [-3:-1; -128:-126;]
+            ));
+            collect(Iterators.flatten(
+                (T(j) for T in (Int8, Int64, Int128, UInt8, UInt64, UInt128)) for j in [2:3; 126:127;]
+            ));
+            Any[typemax(T) for T in (Int64, Int128, UInt8, UInt64, UInt128)];
+            Any[typemax(T)-one(T) for T in (Int64, Int128, UInt8, UInt64, UInt128)];
+            Any[typemin(T) for T in (Int64, Int128)];
+            Any[typemin(T)+one(T) for T in (Int64, Int128)];
+        ]
+        for x in test_values, y in test_values
+            local big_r = iszero(x) && iszero(y) ? nothing : big(x) // big(y)
+            for T in test_types
+                if iszero(x) && iszero(y)
+                    @test_throws Exception Rational{T}(x, y)
+                elseif Base.hastypemax(T)
+                    local T_range = typemin(T):typemax(T)
+                    if numerator(big_r) ∈ T_range && denominator(big_r) ∈ T_range
+                        @test big_r == Rational{T}(x, y)
+                        @test Rational{T} == typeof(Rational{T}(x, y))
+                    else
+                        @test_throws Exception Rational{T}(x, y)
+                    end
+                else
+                    @test big_r == Rational{T}(x, y)
+                    @test Rational{T} == typeof(Rational{T}(x, y))
+                end
+            end
+        end
+    end
 
     for a = -5:5, b = -5:5
         if a == b == 0; continue; end
@@ -721,6 +764,19 @@ end
 
 @testset "Rational{T} with non-concrete T (issue #41222)" begin
     @test @inferred(Rational{Integer}(2,3)) isa Rational{Integer}
+    @test @inferred(Rational{Unsigned}(2,3)) isa Rational{Unsigned}
+    @test @inferred(Rational{Signed}(2,3)) isa Rational{Signed}
+    @test_throws InexactError Rational{Unsigned}(-1,1)
+    @test_throws InexactError Rational{Unsigned}(-1)
+    @test Rational{Unsigned}(Int8(-128), Int8(-128)) === Rational{Unsigned}(0x01, 0x01)
+    @test Rational{Unsigned}(Int8(-128), Int8(-1)) === Rational{Unsigned}(0x80, 0x01)
+    @test Rational{Unsigned}(Int8(0), Int8(-128)) === Rational{Unsigned}(0x00, 0x01)
+    # Numerator and denominator should have the same type.
+    @test Rational{Integer}(0x02) === Rational{Integer}(0x02, 0x01)
+    @test Rational{Integer}(Int16(3)) === Rational{Integer}(Int16(3), Int16(1))
+    @test Rational{Integer}(0x01,-1) === Rational{Integer}(-1, 1)
+    @test Rational{Integer}(-1, 0x01) === Rational{Integer}(-1, 1)
+    @test_throws InexactError Rational{Integer}(Int8(-1), UInt8(1))
 end
 
 @testset "issue #41489" begin

From e2c8809ef505d2aeff9c22eba79ff628fb9e44f6 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Wed, 7 Feb 2024 14:36:12 -0500
Subject: [PATCH 0829/1315] Disambiguate get_world_counter and
 get_inference_world (#53088)

Add brief docs to `Base.get_world_counter` and add `Base.tls_wold_age`.
Furthermore to disambiguate `get_world_counter` from the inference world
rename the abstract interpreter accessor to `get_inference_world`
---
 base/boot.jl                            |  2 +-
 base/compiler/abstractinterpretation.jl |  4 ++--
 base/compiler/inferencestate.jl         |  7 +++++--
 base/compiler/optimize.jl               |  4 ++--
 base/compiler/ssair/irinterp.jl         |  2 +-
 base/compiler/typeinfer.jl              |  8 ++++----
 base/compiler/types.jl                  |  8 ++++----
 base/reflection.jl                      | 16 ++++++++++++++++
 src/gf.c                                |  3 +++
 stdlib/REPL/src/REPLCompletions.jl      |  2 +-
 test/compiler/AbstractInterpreter.jl    |  6 +++---
 test/compiler/EscapeAnalysis/EAUtils.jl |  4 ++--
 test/compiler/invalidation.jl           |  2 +-
 test/compiler/newinterp.jl              |  2 +-
 test/worlds.jl                          |  3 +--
 15 files changed, 47 insertions(+), 26 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index f60a4c861ecb9..ed26536b961ff 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -958,7 +958,7 @@ struct Pair{A, B}
 end
 
 function _hasmethod(@nospecialize(tt)) # this function has a special tfunc
-    world = ccall(:jl_get_tls_world_age, UInt, ())
+    world = ccall(:jl_get_tls_world_age, UInt, ()) # tls_world_age()
     return Intrinsics.not_int(ccall(:jl_gf_invoke_lookup, Any, (Any, Any, UInt), tt, nothing, world) === nothing)
 end
 
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 889a9a541246e..2b736dbeff9d8 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -681,7 +681,7 @@ function edge_matches_sv(interp::AbstractInterpreter, frame::AbsIntState,
     # necessary in order to retrieve this field from the generated `CodeInfo`, if it exists.
     # The other `CodeInfo`s we inspect will already have this field inflated, so we just
     # access it directly instead (to avoid regeneration).
-    world = get_world_counter(interp)
+    world = get_inference_world(interp)
     callee_method2 = method_for_inference_heuristics(method, sig, sparams, world) # Union{Method, Nothing}
 
     inf_method2 = method_for_inference_limit_heuristics(frame) # limit only if user token match
@@ -935,7 +935,7 @@ function concrete_eval_call(interp::AbstractInterpreter,
         pushfirst!(args, f, invokecall.types)
         f = invoke
     end
-    world = get_world_counter(interp)
+    world = get_inference_world(interp)
     edge = result.edge::MethodInstance
     value = try
         Core._call_in_world_total(world, f, args...)
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 3765cc34d6869..5c1fea2e78e9f 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -277,7 +277,10 @@ mutable struct InferenceState
     function InferenceState(result::InferenceResult, src::CodeInfo, cache_mode::UInt8,
                             interp::AbstractInterpreter)
         linfo = result.linfo
-        world = get_world_counter(interp)
+        world = get_inference_world(interp)
+        if world == typemax(UInt)
+            error("Entering inference from a generated function with an invalid world")
+        end
         def = linfo.def
         mod = isa(def, Method) ? def.module : def
         sptypes = sptypes_from_meth_instance(linfo)
@@ -487,7 +490,7 @@ end
 
 function InferenceState(result::InferenceResult, cache_mode::UInt8, interp::AbstractInterpreter)
     # prepare an InferenceState object for inferring lambda
-    world = get_world_counter(interp)
+    world = get_inference_world(interp)
     src = retrieve_code_info(result.linfo, world)
     src === nothing && return nothing
     maybe_validate_code(result.linfo, src, "lowered")
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 68a0cdcdf7480..f634fc0bcb7e4 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -134,7 +134,7 @@ function InliningState(sv::InferenceState, interp::AbstractInterpreter)
     return InliningState(edges, sv.world, interp)
 end
 function InliningState(interp::AbstractInterpreter)
-    return InliningState(Any[], get_world_counter(interp), interp)
+    return InliningState(Any[], get_inference_world(interp), interp)
 end
 
 # get `code_cache(::AbstractInterpreter)` from `state::InliningState`
@@ -193,7 +193,7 @@ function OptimizationState(linfo::MethodInstance, src::CodeInfo, interp::Abstrac
     return OptimizationState(linfo, src, nothing, stmt_info, mod, sptypes, slottypes, inlining, cfg, unreachable, bb_vartables, false)
 end
 function OptimizationState(linfo::MethodInstance, interp::AbstractInterpreter)
-    world = get_world_counter(interp)
+    world = get_inference_world(interp)
     src = retrieve_code_info(linfo, world)
     src === nothing && return nothing
     return OptimizationState(linfo, src, interp)
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 102f01350f658..3b6cfa9019d76 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -17,7 +17,7 @@ function concrete_eval_invoke(interp::AbstractInterpreter,
     if (is_foldable(effects) && is_all_const_arg(argtypes, #=start=#1) &&
         (is_nonoverlayed(interp) || is_nonoverlayed(effects)))
         args = collect_const_args(argtypes, #=start=#1)
-        value = let world = get_world_counter(interp)
+        value = let world = get_inference_world(interp)
             try
                 Core._call_in_world_total(world, args...)
             catch
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index afae4abc2a07d..e9edd04e59d40 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -1030,7 +1030,7 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance)
         end
     end
     if ccall(:jl_get_module_infer, Cint, (Any,), method.module) == 0 && !generating_output(#=incremental=#false)
-        return retrieve_code_info(mi, get_world_counter(interp))
+        return retrieve_code_info(mi, get_inference_world(interp))
     end
     lock_mi_inference(interp, mi)
     result = InferenceResult(mi, typeinf_lattice(interp))
@@ -1094,7 +1094,7 @@ function typeinf_ext_toplevel(interp::AbstractInterpreter, mi::MethodInstance)
 end
 
 function return_type(@nospecialize(f), t::DataType) # this method has a special tfunc
-    world = ccall(:jl_get_tls_world_age, UInt, ())
+    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))
 end
@@ -1104,7 +1104,7 @@ function return_type(@nospecialize(f), t::DataType, world::UInt)
 end
 
 function return_type(t::DataType)
-    world = ccall(:jl_get_tls_world_age, UInt, ())
+    world = tls_world_age()
     return return_type(t, world)
 end
 
@@ -1122,7 +1122,7 @@ function _return_type(interp::AbstractInterpreter, t::DataType)
         rt = builtin_tfunction(interp, f, args, nothing)
         rt = widenconst(rt)
     else
-        for match in _methods_by_ftype(t, -1, get_world_counter(interp))::Vector
+        for match in _methods_by_ftype(t, -1, get_inference_world(interp))::Vector
             ty = typeinf_type(interp, match::MethodMatch)
             ty === nothing && return Any
             rt = tmerge(rt, ty)
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index b98cf09ff7cf1..cdf90a3a6e78c 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -12,7 +12,7 @@ If `interp::NewInterpreter` is an `AbstractInterpreter`, it is expected to provi
 the following methods to satisfy the `AbstractInterpreter` API requirement:
 - `InferenceParams(interp::NewInterpreter)` - return an `InferenceParams` instance
 - `OptimizationParams(interp::NewInterpreter)` - return an `OptimizationParams` instance
-- `get_world_counter(interp::NewInterpreter)` - return the world age for this interpreter
+- `get_inference_world(interp::NewInterpreter)` - return the world age for this interpreter
 - `get_inference_cache(interp::NewInterpreter)` - return the local inference cache
 - `code_cache(interp::NewInterpreter)` - return the global inference cache
 """
@@ -402,9 +402,9 @@ end
 # Quickly and easily satisfy the AbstractInterpreter API contract
 InferenceParams(interp::NativeInterpreter) = interp.inf_params
 OptimizationParams(interp::NativeInterpreter) = interp.opt_params
-get_world_counter(interp::NativeInterpreter) = interp.world
+get_inference_world(interp::NativeInterpreter) = interp.world
 get_inference_cache(interp::NativeInterpreter) = interp.inf_cache
-code_cache(interp::NativeInterpreter) = WorldView(GLOBAL_CI_CACHE, get_world_counter(interp))
+code_cache(interp::NativeInterpreter) = WorldView(GLOBAL_CI_CACHE, get_inference_world(interp))
 
 """
     already_inferred_quick_test(::AbstractInterpreter, ::MethodInstance)
@@ -458,7 +458,7 @@ Returns a method table this `interp` uses for method lookup.
 External `AbstractInterpreter` can optionally return `OverlayMethodTable` here
 to incorporate customized dispatches for the overridden methods.
 """
-method_table(interp::AbstractInterpreter) = InternalMethodTable(get_world_counter(interp))
+method_table(interp::AbstractInterpreter) = InternalMethodTable(get_inference_world(interp))
 method_table(interp::NativeInterpreter) = interp.method_table
 
 """
diff --git a/base/reflection.jl b/base/reflection.jl
index 7ab330de2b9d0..8c3ec226d6e22 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1123,6 +1123,7 @@ function code_lowered(@nospecialize(f), @nospecialize(t=Tuple); generated::Bool=
         throw(ArgumentError("'debuginfo' must be either :source or :none"))
     end
     world = get_world_counter()
+    world == typemax(UInt) && error("code reflection cannot be used from generated functions")
     return map(method_instances(f, t, world)) do m
         if generated && hasgenerator(m)
             if may_invoke_generator(m)
@@ -2329,6 +2330,7 @@ end
 
 function hasmethod(f, t, kwnames::Tuple{Vararg{Symbol}}; world::UInt=get_world_counter())
     @nospecialize
+    world == typemax(UInt) && error("code reflection cannot be used from generated functions")
     isempty(kwnames) && return hasmethod(f, t; world)
     t = to_tuple_type(t)
     ft = Core.Typeof(f)
@@ -2550,8 +2552,22 @@ min_world(m::Core.CodeInstance) = m.min_world
 max_world(m::Core.CodeInstance) = m.max_world
 min_world(m::Core.CodeInfo) = m.min_world
 max_world(m::Core.CodeInfo) = m.max_world
+
+"""
+    get_world_counter()
+
+Returns the current maximum world-age counter. This counter is global and monotonically
+increasing.
+"""
 get_world_counter() = ccall(:jl_get_world_counter, UInt, ())
 
+"""
+    tls_world_age()
+
+Returns the world the [current_task()](@ref) is executing within.
+"""
+tls_world_age() = ccall(:jl_get_tls_world_age, UInt, ())
+
 """
     propertynames(x, private=false)
 
diff --git a/src/gf.c b/src/gf.c
index efe624f518a2b..e8a5f7450b724 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -373,6 +373,8 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
 #ifdef _OS_WINDOWS_
     DWORD last_error = GetLastError();
 #endif
+    int last_pure = ct->ptls->in_pure_callback;
+    ct->ptls->in_pure_callback = 0;
     size_t last_age = ct->world_age;
     ct->world_age = jl_typeinf_world;
     mi->inInference = 1;
@@ -409,6 +411,7 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
     }
     ct->world_age = last_age;
     ct->reentrant_timing -= 0b10;
+    ct->ptls->in_pure_callback = last_pure;
     mi->inInference = 0;
 #ifdef _OS_WINDOWS_
     SetLastError(last_error);
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index ed58e41be470a..cd779b8868a37 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -567,7 +567,7 @@ struct REPLInterpreter <: CC.AbstractInterpreter
 end
 CC.InferenceParams(interp::REPLInterpreter) = interp.inf_params
 CC.OptimizationParams(interp::REPLInterpreter) = interp.opt_params
-CC.get_world_counter(interp::REPLInterpreter) = interp.world
+CC.get_inference_world(interp::REPLInterpreter) = interp.world
 CC.get_inference_cache(interp::REPLInterpreter) = interp.inf_cache
 CC.code_cache(interp::REPLInterpreter) = CC.WorldView(interp.code_cache, CC.WorldRange(interp.world))
 CC.get(wvc::CC.WorldView{REPLInterpreterCache}, mi::MethodInstance, default) = get(wvc.cache.dict, mi, default)
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 121e7fad55c90..77636bfba9a17 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -21,7 +21,7 @@ end
 
 @newinterp MTOverlayInterp
 @MethodTable OverlayedMT
-CC.method_table(interp::MTOverlayInterp) = CC.OverlayMethodTable(CC.get_world_counter(interp), OverlayedMT)
+CC.method_table(interp::MTOverlayInterp) = CC.OverlayMethodTable(CC.get_inference_world(interp), OverlayedMT)
 
 function CC.add_remark!(interp::MTOverlayInterp, ::CC.InferenceState, remark)
     if interp.meta !== nothing
@@ -120,7 +120,7 @@ end |> only === Nothing
 # https://github.com/JuliaLang/julia/issues/48097
 @newinterp Issue48097Interp
 @MethodTable Issue48097MT
-CC.method_table(interp::Issue48097Interp) = CC.OverlayMethodTable(CC.get_world_counter(interp), Issue48097MT)
+CC.method_table(interp::Issue48097Interp) = CC.OverlayMethodTable(CC.get_inference_world(interp), Issue48097MT)
 CC.InferenceParams(::Issue48097Interp) = CC.InferenceParams(; unoptimize_throw_blocks=false)
 function CC.concrete_eval_eligible(interp::Issue48097Interp,
     @nospecialize(f), result::CC.MethodCallResult, arginfo::CC.ArgInfo, sv::CC.AbsIntState)
@@ -141,7 +141,7 @@ end
 # Should not concrete-eval overlayed methods in semi-concrete interpretation
 @newinterp OverlaySinInterp
 @MethodTable OverlaySinMT
-CC.method_table(interp::OverlaySinInterp) = CC.OverlayMethodTable(CC.get_world_counter(interp), OverlaySinMT)
+CC.method_table(interp::OverlaySinInterp) = CC.OverlayMethodTable(CC.get_inference_world(interp), OverlaySinMT)
 overlay_sin1(x) = error("Not supposed to be called.")
 @overlay OverlaySinMT overlay_sin1(x) = cos(x)
 @overlay OverlaySinMT Base.sin(x::Union{Float32,Float64}) = overlay_sin1(x)
diff --git a/test/compiler/EscapeAnalysis/EAUtils.jl b/test/compiler/EscapeAnalysis/EAUtils.jl
index 27a971173ac70..2a4f04f8f79ea 100644
--- a/test/compiler/EscapeAnalysis/EAUtils.jl
+++ b/test/compiler/EscapeAnalysis/EAUtils.jl
@@ -118,7 +118,7 @@ end
 
 CC.InferenceParams(interp::EscapeAnalyzer) = interp.inf_params
 CC.OptimizationParams(interp::EscapeAnalyzer) = interp.opt_params
-CC.get_world_counter(interp::EscapeAnalyzer) = interp.world
+CC.get_inference_world(interp::EscapeAnalyzer) = interp.world
 CC.get_inference_cache(interp::EscapeAnalyzer) = interp.inf_cache
 
 struct EscapeAnalyzerCacheView
@@ -127,7 +127,7 @@ struct EscapeAnalyzerCacheView
 end
 
 function CC.code_cache(interp::EscapeAnalyzer)
-    worlds = WorldRange(get_world_counter(interp))
+    worlds = WorldRange(CC.get_inference_world(interp))
     return WorldView(EscapeAnalyzerCacheView(interp.code_cache, interp.escape_cache), worlds)
 end
 CC.haskey(wvc::WorldView{EscapeAnalyzerCacheView}, mi::MethodInstance) = haskey(wvc.cache.code_cache.cache, mi)
diff --git a/test/compiler/invalidation.jl b/test/compiler/invalidation.jl
index 0d1cfeee56ea8..e3263156499c8 100644
--- a/test/compiler/invalidation.jl
+++ b/test/compiler/invalidation.jl
@@ -39,7 +39,7 @@ end
 
 CC.InferenceParams(interp::InvalidationTester) = interp.inf_params
 CC.OptimizationParams(interp::InvalidationTester) = interp.opt_params
-CC.get_world_counter(interp::InvalidationTester) = interp.world
+CC.get_inference_world(interp::InvalidationTester) = interp.world
 CC.get_inference_cache(interp::InvalidationTester) = interp.inf_cache
 CC.code_cache(interp::InvalidationTester) = WorldView(InvalidationTesterCacheView(interp.code_cache.dict), WorldRange(interp.world))
 CC.get(wvc::WorldView{InvalidationTesterCacheView}, mi::MethodInstance, default) = get(wvc.cache.dict, mi, default)
diff --git a/test/compiler/newinterp.jl b/test/compiler/newinterp.jl
index b454cdd3a40d8..4b2cabcf33c3b 100644
--- a/test/compiler/newinterp.jl
+++ b/test/compiler/newinterp.jl
@@ -36,7 +36,7 @@ macro newinterp(InterpName)
         end
         $CC.InferenceParams(interp::$InterpName) = interp.inf_params
         $CC.OptimizationParams(interp::$InterpName) = interp.opt_params
-        $CC.get_world_counter(interp::$InterpName) = interp.world
+        $CC.get_inference_world(interp::$InterpName) = interp.world
         $CC.get_inference_cache(interp::$InterpName) = interp.inf_cache
         $CC.code_cache(interp::$InterpName) = $CC.WorldView(interp.code_cache, $CC.WorldRange(interp.world))
         $CC.get(wvc::$CC.WorldView{$InterpCacheName}, mi::$C.MethodInstance, default) = get(wvc.cache.dict, mi, default)
diff --git a/test/worlds.jl b/test/worlds.jl
index 8e820bdab88df..ecd76549e9e29 100644
--- a/test/worlds.jl
+++ b/test/worlds.jl
@@ -2,8 +2,7 @@
 
 # tests for accurate updating of method tables
 
-using Base: get_world_counter
-tls_world_age() = ccall(:jl_get_tls_world_age, UInt, ())
+using Base: get_world_counter, tls_world_age
 @test typemax(UInt) > get_world_counter() == tls_world_age() > 0
 
 # test simple method replacement

From 18df941d50aafdcc134f3048b298bd301f336617 Mon Sep 17 00:00:00 2001
From: "Navid C. Constantinou" <navidcy@users.noreply.github.com>
Date: Wed, 7 Feb 2024 22:44:57 +0200
Subject: [PATCH 0830/1315] doc: cosmetic whitespace changes in
 documentation.md (#53183)

---
 doc/src/manual/documentation.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/src/manual/documentation.md b/doc/src/manual/documentation.md
index f35ebafd7e582..41eb4e4d6dde5 100644
--- a/doc/src/manual/documentation.md
+++ b/doc/src/manual/documentation.md
@@ -307,11 +307,11 @@ Or for use with Julia's metaprogramming functionality:
 ```julia
 for (f, op) in ((:add, :+), (:subtract, :-), (:multiply, :*), (:divide, :/))
     @eval begin
-        $f(a,b) = $op(a,b)
+        $f(a, b) = $op(a, b)
     end
 end
-@doc "`add(a,b)` adds `a` and `b` together" add
-@doc "`subtract(a,b)` subtracts `b` from `a`" subtract
+@doc "`add(a, b)` adds `a` and `b` together" add
+@doc "`subtract(a, b)` subtracts `b` from `a`" subtract
 ```
 
 Documentation in non-toplevel blocks, such as `begin`, `if`, `for`, `let`, and
@@ -407,7 +407,7 @@ f(x) = x
 
 "..."
 function f(x)
-    x
+    return x
 end
 
 "..."

From 72d3abeb0e86ec3a8689bad199801720e2e05fb5 Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Wed, 7 Feb 2024 22:28:09 +0100
Subject: [PATCH 0831/1315] Fix potential instability/invalidation in dlpath
 (#53232)

While debugging some invalidations and instabilities in code in packages
I work on, one of the issues I stumbled over is this code in this
`dlpath` method:
```julia
function dlpath(libname::Union{AbstractString, Symbol})
    handle = dlopen(libname)
    path = dlpath(handle)
    dlclose(handle)
    return path
end
```
The `dlopen` modified in this PR can in principle return `nothing`. But
there is no `dlpath` method for this. If one loads just a plain Julia,
all is fine, but under certain conditions (deep in a call chain analyzed
with Cthulhu.jl) it ended up not being able to prove that `path` will be
a string, and only inferred it as `Any`.

But if `throw_error` is set to `true` (the default, and used in the
relevant code path) then `dlopen` cannot return `nothing`, it always
returns a `String`. But the Julia compiler can't know that, as the
exception is thrown by a C helper. So instead modify the Julia code a
bit to help Julia deduce this fact by itself.
---
 base/libdl.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/libdl.jl b/base/libdl.jl
index 38dd86ca55f62..bd909bb7b90eb 100644
--- a/base/libdl.jl
+++ b/base/libdl.jl
@@ -118,7 +118,7 @@ dlopen(s::Symbol, flags::Integer = default_rtld_flags; kwargs...) =
 
 function dlopen(s::AbstractString, flags::Integer = default_rtld_flags; throw_error::Bool = true)
     ret = ccall(:jl_load_dynamic_library, Ptr{Cvoid}, (Cstring,UInt32,Cint), s, flags, Cint(throw_error))
-    if ret == C_NULL
+    if !throw_error && ret == C_NULL
         return nothing
     end
     return ret

From a6ce761fd3c345c3c17d52d0a972bbc1cb325197 Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Wed, 7 Feb 2024 23:50:19 -0500
Subject: [PATCH 0832/1315] add docs and jldoctests for `Base.shell_split` and
 `Base.rstrip_shell` (#52520)

These were undocumented and I have seen `Base.shell_split` used in
the package ecosystem. This adds some docs for clarity although neither
of
these functions are part of Base's exports.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/shell.jl | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/base/shell.jl b/base/shell.jl
index 48214418bdee5..dd4533c182534 100644
--- a/base/shell.jl
+++ b/base/shell.jl
@@ -4,7 +4,19 @@
 
 const shell_special = "#{}()[]<>|&*?~;"
 
-# strips the end but respects the space when the string ends with "\\ "
+@doc raw"""
+    rstrip_shell(s::AbstractString)
+
+Strip trailing whitespace from a shell command string, while respecting a trailing backslash followed by a space ("\\ ").
+
+```jldoctest
+julia> Base.rstrip_shell("echo 'Hello World' \\ ")
+"echo 'Hello World' \\ "
+
+julia> Base.rstrip_shell("echo 'Hello World'    ")
+"echo 'Hello World'"
+```
+""" ->
 function rstrip_shell(s::AbstractString)
     c_old = nothing
     for (i, c) in Iterators.reverse(pairs(s))
@@ -140,6 +152,21 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
     return ex, last_arg
 end
 
+"""
+    shell_split(command::AbstractString)
+
+Split a shell command string into its individual components.
+
+# Examples
+```jldoctest
+julia> Base.shell_split("git commit -m 'Initial commit'")
+4-element Vector{String}:
+ "git"
+ "commit"
+ "-m"
+ "Initial commit"
+```
+"""
 function shell_split(s::AbstractString)
     parsed = shell_parse(s, false)[1]
     args = String[]

From 2bd4cf8090f2c651543f562a4c469d73e4b15bd6 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 8 Feb 2024 11:52:24 +0530
Subject: [PATCH 0833/1315] Avoid allocations in views of views (#53231)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Currently, views-of-views construct their re-indexed indices by slicing
into the parent indices. This PR changes this to use views of the parent
indices instead. This makes the operation faster and non-allocating if
the `parentindices` for the original view are `Vector`s.

```julia
julia> a = rand(200, 200);

julia> av = view(a, collect.(axes(a))...);

julia> @btime view($av, axes($av)...);
  312.393 ns (4 allocations: 3.25 KiB) # master
  7.354 ns (0 allocations: 0 bytes) # PR
```
Indexing into the resulting view seems equally fast in simple cases:
```julia
julia> av2 = view(av, axes(av)...);

julia> @btime sum($av2);
  66.883 μs (0 allocations: 0 bytes) # master
  66.888 μs (0 allocations: 0 bytes) # PR

julia> av2 = view(av, collect.(axes(av))...);

julia> @btime sum($av2);
  66.886 μs (0 allocations: 0 bytes) # master
  66.891 μs (0 allocations: 0 bytes) # PR
```

---------

Co-authored-by: N5N3 <2642243996@qq.com>
---
 base/subarray.jl |  6 +++---
 test/subarray.jl | 25 +++++++++++++++++++++++++
 2 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index fcc417fa1d157..d419a65a5d618 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -290,18 +290,18 @@ reindex(idxs::Tuple{Slice, Vararg{Any}}, subidxs::Tuple{Any, Vararg{Any}}) =
 
 # Re-index into parent vectors with one subindex
 reindex(idxs::Tuple{AbstractVector, Vararg{Any}}, subidxs::Tuple{Any, Vararg{Any}}) =
-    (@_propagate_inbounds_meta; (idxs[1][subidxs[1]], reindex(tail(idxs), tail(subidxs))...))
+    (@_propagate_inbounds_meta; (maybeview(idxs[1], subidxs[1]), reindex(tail(idxs), tail(subidxs))...))
 
 # Parent matrices are re-indexed with two sub-indices
 reindex(idxs::Tuple{AbstractMatrix, Vararg{Any}}, subidxs::Tuple{Any, Any, Vararg{Any}}) =
-    (@_propagate_inbounds_meta; (idxs[1][subidxs[1], subidxs[2]], reindex(tail(idxs), tail(tail(subidxs)))...))
+    (@_propagate_inbounds_meta; (maybeview(idxs[1], subidxs[1], subidxs[2]), reindex(tail(idxs), tail(tail(subidxs)))...))
 
 # In general, we index N-dimensional parent arrays with N indices
 @generated function reindex(idxs::Tuple{AbstractArray{T,N}, Vararg{Any}}, subidxs::Tuple{Vararg{Any}}) where {T,N}
     if length(subidxs.parameters) >= N
         subs = [:(subidxs[$d]) for d in 1:N]
         tail = [:(subidxs[$d]) for d in N+1:length(subidxs.parameters)]
-        :(@_propagate_inbounds_meta; (idxs[1][$(subs...)], reindex(tail(idxs), ($(tail...),))...))
+        :(@_propagate_inbounds_meta; (maybeview(idxs[1], $(subs...)), reindex(tail(idxs), ($(tail...),))...))
     else
         :(throw(ArgumentError("cannot re-index SubArray with fewer indices than dimensions\nThis should not occur; please submit a bug report.")))
     end
diff --git a/test/subarray.jl b/test/subarray.jl
index dd71b1c770b3a..10c21ff6cef20 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -999,3 +999,28 @@ end
 catch err
     err isa ErrorException && startswith(err.msg, "syntax:")
 end
+
+
+@testset "avoid allocating in reindex" begin
+    a = reshape(1:16, 4, 4)
+    inds = ([2,3], [3,4])
+    av = view(a, inds...)
+    av2 = view(av, 1, 1)
+    @test parentindices(av2) === (2,3)
+    av2 = view(av, 2:2, 2:2)
+    @test parentindices(av2) === (view(inds[1], 2:2), view(inds[2], 2:2))
+
+    inds = (reshape([eachindex(a);], size(a)),)
+    av = view(a, inds...)
+    av2 = view(av, 1, 1)
+    @test parentindices(av2) === (1,)
+    av2 = view(av, 2:2, 2:2)
+    @test parentindices(av2) === (view(inds[1], 2:2, 2:2),)
+
+    inds = (reshape([eachindex(a);], size(a)..., 1),)
+    av = view(a, inds...)
+    av2 = view(av, 1, 1, 1)
+    @test parentindices(av2) === (1,)
+    av2 = view(av, 2:2, 2:2, 1:1)
+    @test parentindices(av2) === (view(inds[1], 2:2, 2:2, 1:1),)
+end

From 4d0a469e6f8fe30a5e152ac7c93b7569c41e3c39 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Thu, 8 Feb 2024 14:22:48 +0800
Subject: [PATCH 0834/1315] SubArray: avoid invalid elimination of singleton
 indices (#53228)

close #53209
---
 base/subarray.jl | 14 ++++++++------
 test/subarray.jl | 13 ++++++++++---
 2 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index d419a65a5d618..6f1e20af2b966 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -154,6 +154,11 @@ _maybe_reshape_parent(A::AbstractArray, ::NTuple{1, Bool}) = reshape(A, Val(1))
 _maybe_reshape_parent(A::AbstractArray{<:Any,1}, ::NTuple{1, Bool}) = reshape(A, Val(1))
 _maybe_reshape_parent(A::AbstractArray{<:Any,N}, ::NTuple{N, Bool}) where {N} = A
 _maybe_reshape_parent(A::AbstractArray, ::NTuple{N, Bool}) where {N} = reshape(A, Val(N))
+# The trailing singleton indices could be eliminated after bounds checking.
+rm_singleton_indices(ndims::Tuple, J1, Js...) = (J1, rm_singleton_indices(IteratorsMD._splitrest(ndims, index_ndims(J1)), Js...)...)
+rm_singleton_indices(::Tuple{}, ::ScalarIndex, Js...) = rm_singleton_indices((), Js...)
+rm_singleton_indices(::Tuple) = ()
+
 """
     view(A, inds...)
 
@@ -200,15 +205,12 @@ julia> view(2:5, 2:3) # returns a range as type is immutable
 3:4
 ```
 """
-function view(A::AbstractArray{<:Any,N}, I::Vararg{Any,M}) where {N,M}
+function view(A::AbstractArray, I::Vararg{Any,M}) where {M}
     @inline
     J = map(i->unalias(A,i), to_indices(A, I))
     @boundscheck checkbounds(A, J...)
-    if length(J) > ndims(A) && J[N+1:end] isa Tuple{Vararg{Int}}
-        # view([1,2,3], :, 1) does not need to reshape
-        return unsafe_view(A, J[1:N]...)
-    end
-    unsafe_view(_maybe_reshape_parent(A, index_ndims(J...)), J...)
+    J′ = rm_singleton_indices(ntuple(Returns(true), Val(ndims(A))), J...)
+    unsafe_view(_maybe_reshape_parent(A, index_ndims(J′...)), J′...)
 end
 
 # Ranges implement getindex to return recomputed ranges; use that for views, too (when possible)
diff --git a/test/subarray.jl b/test/subarray.jl
index 10c21ff6cef20..a556260c4717e 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -923,9 +923,9 @@ end
 
 @testset "issue #41221: view(::Vector, :, 1)" begin
     v = randn(3)
-    @test view(v,:,1) == v
-    @test parent(view(v,:,1)) === v
-    @test parent(view(v,2:3,1,1)) === v
+    @test @inferred(view(v,:,1)) == v
+    @test parent(@inferred(view(v,:,1))) === v
+    @test parent(@inferred(view(v,2:3,1,1))) === v
     @test_throws BoundsError view(v,:,2)
     @test_throws BoundsError view(v,:,1,2)
 
@@ -934,6 +934,13 @@ end
     @test parent(view(m, 1:2, 3, 1, 1)) === m
 end
 
+@testset "issue #53209: avoid invalid elimination of singleton indices" begin
+    A = randn(4,5)
+    @test A[CartesianIndices(()), :, 3] == @inferred(view(A, CartesianIndices(()), :, 3))
+    @test parent(@inferred(view(A, :, 3, 1, CartesianIndices(()), 1))) === A
+    @test_throws BoundsError view(A, :, 3, 2, CartesianIndices(()), 1)
+end
+
 @testset "replace_in_print_matrix" begin
     struct MyIdentity <: AbstractMatrix{Bool}
         n :: Int

From 4414599689fdf8eb0ff5e0909e68e7b0763f026e Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 8 Feb 2024 04:24:39 -0500
Subject: [PATCH 0835/1315] Fix PkgId repr (#52795)

Fixes #52793

```
% ./julia  --startup-file=no -E 'repr(Base.PkgId(Base.UUID("295af30f-e4ad-537b-8983-00126c2a3abe"), "Revise"))'
"Base.PkgId(UUID(\"295af30f-e4ad-537b-8983-00126c2a3abe\"), \"Revise\")"
```
```
julia> Base.PkgId(Base.UUID("295af30f-e4ad-537b-8983-00126c2a3abe"), "Revise")
Revise [295af30f-e4ad-537b-8983-00126c2a3abe]
```
---
 base/loading.jl | 38 +++++++++++++++++++-------------------
 base/pkgid.jl   |  2 +-
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index cb4bdf518b816..7f359695a290a 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1124,10 +1124,10 @@ function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{No
     end
 
     if ocachepath !== nothing
-        @debug "Loading object cache file $ocachepath for $pkg"
+        @debug "Loading object cache file $ocachepath for $(repr("text/plain", pkg))"
         sv = ccall(:jl_restore_package_image_from_file, Any, (Cstring, Any, Cint, Cstring, Cint), ocachepath, depmods, false, pkg.name, ignore_native)
     else
-        @debug "Loading cache file $path for $pkg"
+        @debug "Loading cache file $path for $(repr("text/plain", pkg))"
         sv = ccall(:jl_restore_incremental, Any, (Cstring, Any, Cint, Cstring), path, depmods, false, pkg.name)
     end
     if isa(sv, Exception)
@@ -1160,7 +1160,7 @@ function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{No
             return M
         end
     end
-    return ErrorException("Required dependency $pkg failed to load from a cache file.")
+    return ErrorException("Required dependency $(repr("text/plain", pkg)) failed to load from a cache file.")
 
     finally
         timing_imports && cumulative_compile_timing(false)
@@ -2101,7 +2101,7 @@ function _require(pkg::PkgId, env=nothing)
         path = locate_package(pkg, env)
         if path === nothing
             throw(ArgumentError("""
-                Package $pkg is required but does not seem to be installed:
+                Package $(repr("text/plain", pkg)) is required but does not seem to be installed:
                  - Run `Pkg.instantiate()` to install all recorded dependencies.
                 """))
         end
@@ -2123,7 +2123,7 @@ function _require(pkg::PkgId, env=nothing)
         for (concrete_pkg, concrete_build_id) in _concrete_dependencies
             if pkg == concrete_pkg
                 @warn """Module $(pkg.name) with build ID $((UUID(concrete_build_id))) is missing from the cache.
-                     This may mean $pkg does not support precompilation but is imported by a module that does."""
+                     This may mean $(repr("text/plain", pkg)) does not support precompilation but is imported by a module that does."""
                 if JLOptions().incremental != 0
                     # during incremental precompilation, this should be fail-fast
                     throw(PrecompilableError())
@@ -2157,16 +2157,16 @@ function _require(pkg::PkgId, env=nothing)
                 elseif isa(cachefile, Exception)
                     if precompilableerror(cachefile)
                         verbosity = isinteractive() ? CoreLogging.Info : CoreLogging.Debug
-                        @logmsg verbosity "Skipping precompilation due to precompilable error. Importing $pkg." exception=m
+                        @logmsg verbosity "Skipping precompilation due to precompilable error. Importing $(repr("text/plain", pkg))." exception=m
                     else
-                        @warn "The call to compilecache failed to create a usable precompiled cache file for $pkg" exception=m
+                        @warn "The call to compilecache failed to create a usable precompiled cache file for $(repr("text/plain", pkg))" exception=m
                     end
                     # fall-through to loading the file locally if not incremental
                 else
                     cachefile, ocachefile = cachefile::Tuple{String, Union{Nothing, String}}
                     m = _tryrequire_from_serialized(pkg, cachefile, ocachefile)
                     if !isa(m, Module)
-                        @warn "The call to compilecache failed to create a usable precompiled cache file for $pkg" exception=m
+                        @warn "The call to compilecache failed to create a usable precompiled cache file for $(repr("text/plain", pkg))" exception=m
                     else
                         return m
                     end
@@ -2393,7 +2393,7 @@ function check_src_module_wrap(pkg::PkgId, srcpath::String)
         inside_string && continue
         if contains(s, module_rgx)
             if load_seen
-                throw(ErrorException("Package $pkg source file $srcpath has a using/import before a module declaration."))
+                throw(ErrorException("Package $(repr("text/plain", pkg)) source file $srcpath has a using/import before a module declaration."))
             end
             return true
         end
@@ -2401,7 +2401,7 @@ function check_src_module_wrap(pkg::PkgId, srcpath::String)
             load_seen = true
         end
     end
-    throw(ErrorException("Package $pkg source file $srcpath does not contain a module declaration."))
+    throw(ErrorException("Package $(repr("text/plain", pkg)) source file $srcpath does not contain a module declaration."))
 end
 
 # this is called in the external process that generates precompiled package files
@@ -2480,12 +2480,12 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     end
 
     if output_o !== nothing
-        @debug "Generating object cache file for $pkg"
+        @debug "Generating object cache file for $(repr("text/plain", pkg))"
         cpu_target = get(ENV, "JULIA_CPU_TARGET", nothing)
         opt_level = Base.JLOptions().opt_level
         opts = `-O$(opt_level) --output-o $(output_o) --output-ji $(output) --output-incremental=yes`
     else
-        @debug "Generating cache file for $pkg"
+        @debug "Generating cache file for $(repr("text/plain", pkg))"
         cpu_target = nothing
         opts = `-O0 --output-ji $(output) --output-incremental=yes`
     end
@@ -2553,7 +2553,7 @@ for important notes.
 function compilecache(pkg::PkgId, internal_stderr::IO = stderr, internal_stdout::IO = stdout; reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
     @nospecialize internal_stderr internal_stdout
     path = locate_package(pkg)
-    path === nothing && throw(ArgumentError("$pkg not found during precompilation"))
+    path === nothing && throw(ArgumentError("$(repr("text/plain", pkg)) not found during precompilation"))
     return compilecache(pkg, path, internal_stderr, internal_stdout; reasons)
 end
 
@@ -2577,7 +2577,7 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
     end
     # run the expression and cache the result
     verbosity = isinteractive() ? CoreLogging.Info : CoreLogging.Debug
-    @logmsg verbosity "Precompiling $pkg $(list_reasons(reasons))"
+    @logmsg verbosity "Precompiling $(repr("text/plain", pkg)) $(list_reasons(reasons))"
 
     # create a temporary file in `cachepath` directory, write the cache in it,
     # write the checksum, _and then_ atomically move the file to `cachefile`.
@@ -2621,7 +2621,7 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
             # append extra crc to the end of the .ji file:
             open(tmppath, "r+") do f
                 if iszero(isvalid_cache_header(f))
-                    error("Invalid header for $pkg in new cache file $(repr(tmppath)).")
+                    error("Invalid header for $(repr("text/plain", pkg)) in new cache file $(repr(tmppath)).")
                 end
                 seekend(f)
                 write(f, crc_so)
@@ -2692,7 +2692,7 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
     if p.exitcode == 125
         return PrecompilableError()
     else
-        error("Failed to precompile $pkg to $(repr(tmppath)).")
+        error("Failed to precompile $(repr("text/plain", pkg)) to $(repr(tmppath)).")
     end
 end
 
@@ -3283,9 +3283,9 @@ function maybe_cachefile_lock(f, pkg::PkgId, srcpath::String; stale_age=compilec
             pid, hostname, age = invokelatest(parse_pidfile_hook, pidfile)
             verbosity = isinteractive() ? CoreLogging.Info : CoreLogging.Debug
             if isempty(hostname) || hostname == gethostname()
-                @logmsg verbosity "Waiting for another process (pid: $pid) to finish precompiling $pkg. Pidfile: $pidfile"
+                @logmsg verbosity "Waiting for another process (pid: $pid) to finish precompiling $(repr("text/plain", pkg)). Pidfile: $pidfile"
             else
-                @logmsg verbosity "Waiting for another machine (hostname: $hostname, pid: $pid) to finish precompiling $pkg. Pidfile: $pidfile"
+                @logmsg verbosity "Waiting for another machine (hostname: $hostname, pid: $pid) to finish precompiling $(repr("text/plain", pkg)). Pidfile: $pidfile"
             end
             # wait until the lock is available, but don't actually acquire it
             # returning nothing indicates a process waited for another
@@ -3438,7 +3438,7 @@ end
                 # verify that `require(modkey, name(req_modkey))` ==> `req_modkey`
                 pkg = identify_package(modkey, req_modkey.name)
                 if pkg != req_modkey
-                    @debug "Rejecting cache file $cachefile because uuid mapping for $modkey => $req_modkey has changed, expected $modkey => $pkg"
+                    @debug "Rejecting cache file $cachefile because uuid mapping for $modkey => $req_modkey has changed, expected $modkey => $(repr("text/plain", pkg))"
                     record_reason(reasons, "dep uuid changed")
                     return true
                 end
diff --git a/base/pkgid.jl b/base/pkgid.jl
index 20d9de559b334..a3d3ead184bb8 100644
--- a/base/pkgid.jl
+++ b/base/pkgid.jl
@@ -23,7 +23,7 @@ function hash(pkg::PkgId, h::UInt)
     return h
 end
 
-show(io::IO, pkg::PkgId) =
+show(io::IO,  ::MIME"text/plain", pkg::PkgId) =
     print(io, pkg.name, " [", pkg.uuid === nothing ? "top-level" : pkg.uuid, "]")
 
 function binpack(pkg::PkgId)

From 5cb5cd8727b6d67aafaa0d7d263b0372459c5dea Mon Sep 17 00:00:00 2001
From: Artem Pelenitsyn <a.pelenitsyn@gmail.com>
Date: Thu, 8 Feb 2024 04:25:36 -0500
Subject: [PATCH 0836/1315] code_warntype docs: more neutral reference to
 @code_warntype (#51361)

fix #51358

---------

Co-authored-by: Fredrik Ekre <ekrefredrik@gmail.com>
Co-authored-by: Max Horn <max@quendi.de>
---
 stdlib/InteractiveUtils/src/codeview.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/InteractiveUtils/src/codeview.jl b/stdlib/InteractiveUtils/src/codeview.jl
index 4e5141c0de08e..877e023bc28ed 100644
--- a/stdlib/InteractiveUtils/src/codeview.jl
+++ b/stdlib/InteractiveUtils/src/codeview.jl
@@ -70,7 +70,7 @@ Small unions of concrete types are usually not a concern, so these are highlight
 
 Keyword argument `debuginfo` may be one of `:source` or `:none` (default), to specify the verbosity of code comments.
 
-See [`@code_warntype`](@ref man-code-warntype) for more information.
+See the [`@code_warntype`](@ref man-code-warntype) section in the Performance Tips page of the manual for more information.
 
 See also: [`@code_warntype`](@ref), [`code_typed`](@ref), [`code_lowered`](@ref), [`code_llvm`](@ref), [`code_native`](@ref).
 """

From 41a6e7b6c839f4828f1dbda66725aabc78b75d50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Thu, 8 Feb 2024 10:03:05 +0000
Subject: [PATCH 0837/1315] [LibCURL_jll] Upgrade to v8.6.0 (#53222)

---
 deps/checksums/curl             | 68 ++++++++++++++++-----------------
 deps/curl.mk                    | 11 +++++-
 deps/curl.version               |  2 +-
 deps/patches/curl-memdup.patch  | 24 ++++++++++++
 stdlib/LibCURL_jll/Project.toml |  4 +-
 5 files changed, 71 insertions(+), 38 deletions(-)
 create mode 100644 deps/patches/curl-memdup.patch

diff --git a/deps/checksums/curl b/deps/checksums/curl
index 854165a8c1225..e6f7989db33d7 100644
--- a/deps/checksums/curl
+++ b/deps/checksums/curl
@@ -1,36 +1,36 @@
 LibCURL-a65b64f6eabc932f63c2c0a4a5fb5d75f3e688d0.tar.gz/md5/e8c53aa3fb963c80921787d5d565eb2c
 LibCURL-a65b64f6eabc932f63c2c0a4a5fb5d75f3e688d0.tar.gz/sha512/8e442ea834299df9c02acb87226c121395ad8e550025ac5ee1103df09c6ff43817e9e48dd1bcbc92c80331ef3ddff531962430269115179acbec2bab2de5b011
-LibCURL.v8.5.0+0.aarch64-apple-darwin.tar.gz/md5/f392ffcb1294f87e24cc10383c8f94e1
-LibCURL.v8.5.0+0.aarch64-apple-darwin.tar.gz/sha512/68c5b9438dee48e758f0837e05ed8ed01669c99dd51bc8803f9c95160579b6749dd41881e552a9847401e679865a63ba2dc07b1974bd26f3f1d712518312aa6a
-LibCURL.v8.5.0+0.aarch64-linux-gnu.tar.gz/md5/6cc08cb80aa779f68fa200dd578b0aae
-LibCURL.v8.5.0+0.aarch64-linux-gnu.tar.gz/sha512/6a09e16a6c20dc19b0d9e98844006d5199b1bbf49aff9126e3a57d07faf69b7da8627ec94a4736ab72525ab90e809cebb8d9976f777487d033786be4ab5dd3ce
-LibCURL.v8.5.0+0.aarch64-linux-musl.tar.gz/md5/89228327d7c5272fdea2c88c2b02ec4e
-LibCURL.v8.5.0+0.aarch64-linux-musl.tar.gz/sha512/c8b00ab354c344c15a24be68f393f7a775a6ef6c3ae4ccde531d7e1aebe49a33173361d357ded0564d73fd03f7c787563061a5d47946f37d0a39722d72a7d5bf
-LibCURL.v8.5.0+0.armv6l-linux-gnueabihf.tar.gz/md5/74f74b891e34893880177f6db05041a2
-LibCURL.v8.5.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/d001bb07c37e87d059bc09ddbf1f19d668f8dd76feafaf0d430cebd03de4c9db8820f1b7ee97fe88128bfda125242e7103b38ba1653c393da349eefc56a35ea8
-LibCURL.v8.5.0+0.armv6l-linux-musleabihf.tar.gz/md5/41d61d599206f917b2045bab814022f3
-LibCURL.v8.5.0+0.armv6l-linux-musleabihf.tar.gz/sha512/9650b18c1a5aa1f71a26ddec9a2659f8332e3eddc570e93f8026e1d74c5ee4a72de989abb0d296e33501ae4223d89dc95670a8f900fb3c0d33d013872ca354bd
-LibCURL.v8.5.0+0.armv7l-linux-gnueabihf.tar.gz/md5/e32cf216cb370de4670437795b01ac85
-LibCURL.v8.5.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/bbd0f186093cdfddcce0b6c310da6e471e51dfa23af8759cdf3e02937b24f55a7a587daac1b7c4538e7e9ed9b9be3538af975d36a6f4e3a2dc30a6fcfb2bdb1d
-LibCURL.v8.5.0+0.armv7l-linux-musleabihf.tar.gz/md5/91f5adf263404e5b7c49b4679ddc9a94
-LibCURL.v8.5.0+0.armv7l-linux-musleabihf.tar.gz/sha512/fdeea044e8fef5d9867f24640bfc2e448e9a7a96e390c6a92898a24c8e73f8bed1a2ad14bee6e3905b581aea12f57fafe2a98800ae05b44e3523a23c26a37bdc
-LibCURL.v8.5.0+0.i686-linux-gnu.tar.gz/md5/89792faedbcf7d51eb5c3298ede593a7
-LibCURL.v8.5.0+0.i686-linux-gnu.tar.gz/sha512/615b98aeb29d3624aa4c4a47d38aba7611ff748ac6ece5c8bebd7fe7132947109199e73b7438a60672af44c943fc5083cd2997e656e6117424e4464cfdc6c0b2
-LibCURL.v8.5.0+0.i686-linux-musl.tar.gz/md5/9417ff0d1866788e72186b4bf18ae721
-LibCURL.v8.5.0+0.i686-linux-musl.tar.gz/sha512/b0a56def69a42163cc3b59102834faa6fc29bee7e6b9854b33e10ac524b143f8a8569ab5069a1c405d2611a173421d68ec86710852aa6b2cec027ccb3b306c20
-LibCURL.v8.5.0+0.i686-w64-mingw32.tar.gz/md5/8d1a76abd11e361dbc1dff4a3bf43d55
-LibCURL.v8.5.0+0.i686-w64-mingw32.tar.gz/sha512/ff4d66a475726933fd1b0f54c92f107bdf36322bc093bda51e03967e1c7d2d6d7ef4afaea9a3b6361a0626db4609358de68b8161fec69367dc3c08347738a299
-LibCURL.v8.5.0+0.powerpc64le-linux-gnu.tar.gz/md5/9b0ffe71aac0a316ca74de264e1e448b
-LibCURL.v8.5.0+0.powerpc64le-linux-gnu.tar.gz/sha512/22c6a5c692e95b2e6da634398871484c8b03a82e2c54beb8c827d298e61629341381e1d3a5a6105c02f880f72688b3cc516c55e4301d6be408e4bbe0fefb7b7a
-LibCURL.v8.5.0+0.x86_64-apple-darwin.tar.gz/md5/8faf119181495ff23d071b289e2737da
-LibCURL.v8.5.0+0.x86_64-apple-darwin.tar.gz/sha512/ed50685336740b2c872d16c7f793e2b5a3189e510dbc60de9b3932a3c14fbd04db0d4dada48b73942f0718f9008ee180024e2e682fba8d718b0781f07bb3c872
-LibCURL.v8.5.0+0.x86_64-linux-gnu.tar.gz/md5/281011966d7cc336b4fd00427073c608
-LibCURL.v8.5.0+0.x86_64-linux-gnu.tar.gz/sha512/8d7f7833e2d21641ae25f6559b1e51362d5f6dac5e5e798a5b1afeb3e9aaef113f91ac6cb6da1b621e484f4ec710370f6beef082a68de7bf2943685bc87b4064
-LibCURL.v8.5.0+0.x86_64-linux-musl.tar.gz/md5/5e0e4cebf892f410b8723b9523556e78
-LibCURL.v8.5.0+0.x86_64-linux-musl.tar.gz/sha512/98d9520311689be84aff0afa96f64561a90eb26252557d62529ff4b1e20386a37615d674f30d33c17a61ffb11c5a02d4788d4608bf820c5dfc71ceecfe25142d
-LibCURL.v8.5.0+0.x86_64-unknown-freebsd.tar.gz/md5/8f54debd5e4e3cfc2c6993a071b8a832
-LibCURL.v8.5.0+0.x86_64-unknown-freebsd.tar.gz/sha512/5da056812a5adc2c5867142c2334a6a0d94009838af256b7fd58a0a31db27d304906f058b5d849ad7fc53f4c04e3d6f93bc6b1ac455c1e3dc58d0a30ff15b17e
-LibCURL.v8.5.0+0.x86_64-w64-mingw32.tar.gz/md5/b0c34ea85a9547313195e05a9c26851b
-LibCURL.v8.5.0+0.x86_64-w64-mingw32.tar.gz/sha512/10dbfd32b72461ee5c573a9059ddcb5de83c9f72398d6c0149a217bcf271e248b7efd97432ca028876580ca24585360e549893e3fcbe6d28191badb170d8f4ec
-curl-8.5.0.tar.bz2/md5/d617745a3fd4456b591da53052a5ea94
-curl-8.5.0.tar.bz2/sha512/7b07b69f8cc80d1aabc7f3b8db12e10ec84c304f7bb8391b8605aa6724c9ad2ce3ab65b111ed011e55d57cd63767adc310bd85d8c897f48e1785502406376005
+LibCURL.v8.6.0+0.aarch64-apple-darwin.tar.gz/md5/83854e8cdd078ec1fc5f92da2816e379
+LibCURL.v8.6.0+0.aarch64-apple-darwin.tar.gz/sha512/f3b3cc5804d9a7986ed9ea7c3186caa8dba0f4d6bbcb9b5d2070b4e6412234f2ed7908446dbe217323510c6d3b042540e18ec7839093c2c3c66f3195937a6a3b
+LibCURL.v8.6.0+0.aarch64-linux-gnu.tar.gz/md5/880014fface52bddaa1a0240e0668dde
+LibCURL.v8.6.0+0.aarch64-linux-gnu.tar.gz/sha512/a29b923e14425ad729484648ce15577e717a97acf6138e0ec3d35a8000aeef17f27ce01d1fdc1642c6eda72d8d8b46642d79844ef9a50f30a0148e29452565c1
+LibCURL.v8.6.0+0.aarch64-linux-musl.tar.gz/md5/b84fcb98f1305803d941f7a5accbfdb1
+LibCURL.v8.6.0+0.aarch64-linux-musl.tar.gz/sha512/0880dc91109aedd9b108f2e28a25bf7091ac976a6f94e65000f647802c57a01e8111d421b91a91244c3cfb56990155af2c47b3499997be2af8ab93d344b8331d
+LibCURL.v8.6.0+0.armv6l-linux-gnueabihf.tar.gz/md5/24249f42db0bc99c2dde4cf61d61f11f
+LibCURL.v8.6.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/350443c86f7b6733fb6a28f8a2fe7a6c0e91462b9e4078fed3475059ec7e12fef5014e22d0d0babe44f172ace7258292de577a0ab90f90c65d825d74940c9c47
+LibCURL.v8.6.0+0.armv6l-linux-musleabihf.tar.gz/md5/375c01cef98204c4f63ac218b08c4c7b
+LibCURL.v8.6.0+0.armv6l-linux-musleabihf.tar.gz/sha512/ed0981d458c6ddc9f380b90f1ec25cbaa6be910f0dab5d5485e4d1e9a33f8a918d210722a5e6685b4d3b917e0800194856f826164ee2e90b8a886ada7498a52b
+LibCURL.v8.6.0+0.armv7l-linux-gnueabihf.tar.gz/md5/4c81aa99065cf797d6e09ce172dd2fa7
+LibCURL.v8.6.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/08bbb1bc80411a5fd65699a0d721fc70a9bba1005194f2937accc2e98f7f803bac4a704c88aa1fc1d72e54e7c327a113963f8a4c52ebb1e5921778d1dd549143
+LibCURL.v8.6.0+0.armv7l-linux-musleabihf.tar.gz/md5/6865b2f2d93754b5206d618048c32b57
+LibCURL.v8.6.0+0.armv7l-linux-musleabihf.tar.gz/sha512/c1a5891f4c487d5f7cf91db7cd2d85394d9686cda01c89cddaf7afba09782aa9f00713592d72ed8a0dd20439884dd75c1e001a9ecb16dd8ce5f08f79c194c7c8
+LibCURL.v8.6.0+0.i686-linux-gnu.tar.gz/md5/3f35cc6a2dc7e9dba5e3b4aeaf130160
+LibCURL.v8.6.0+0.i686-linux-gnu.tar.gz/sha512/b34c5ba2fee272e6ca848c42335ffa0c4d0c06337608504a3a2cfeb111e228da3f82d91c0c4387c76fc347babbf50b368992b5b8d5fda1a60ed5c0ce5d9242db
+LibCURL.v8.6.0+0.i686-linux-musl.tar.gz/md5/0072b83eaf91d9da4a8d25ef65fd8ca8
+LibCURL.v8.6.0+0.i686-linux-musl.tar.gz/sha512/029552e3dac29857726988352a01a3b57859bfe5e327e7b759bd9968ed5af5498fd27ab490810d2d3ef05b1003c1a950fd092d1dbce7732a911f7cb6e5714303
+LibCURL.v8.6.0+0.i686-w64-mingw32.tar.gz/md5/d58ef948bc9a04a8c934a88b7ab5599d
+LibCURL.v8.6.0+0.i686-w64-mingw32.tar.gz/sha512/1e1742ea39f2fe1f13b0aff5907f96401276e3fc469a8f09f2bc31fffc72367a92856973db66eb9b05d20fd708764ad9429e385913f6236ce8067ec4e11dbb33
+LibCURL.v8.6.0+0.powerpc64le-linux-gnu.tar.gz/md5/60ec16b6dfd3e30eb0655cf177b026c7
+LibCURL.v8.6.0+0.powerpc64le-linux-gnu.tar.gz/sha512/f591897972c8b01edf64701885f636fc1d5c04cce8fc63577d06108e14e5480bad74306d6ee31515911bd8ba3db10d1f2c733a6149aceae32aa4b77e263087c3
+LibCURL.v8.6.0+0.x86_64-apple-darwin.tar.gz/md5/c6bc0d9cd0a9f9c35ed2aac058ae332f
+LibCURL.v8.6.0+0.x86_64-apple-darwin.tar.gz/sha512/038f55bfb06dce877540ea7d50f5a0b8fdc070539c505774139a7c23df276a5fc75b5cecabecbc2826417e091028382d79298a51ed73c3d776249b4ff35f9f26
+LibCURL.v8.6.0+0.x86_64-linux-gnu.tar.gz/md5/18bf9d909dd5eebc0554d23bf4a4ee0f
+LibCURL.v8.6.0+0.x86_64-linux-gnu.tar.gz/sha512/35e60faa1ee072003fdd5cd510295bc310aa99375aee6ef94eee3ee2d5e0b7844145866a74927c588c14131939c1d9865d6f5128ac4f6b93606a68042a94f39f
+LibCURL.v8.6.0+0.x86_64-linux-musl.tar.gz/md5/213190e1d79c9c291ff460e1648a61d3
+LibCURL.v8.6.0+0.x86_64-linux-musl.tar.gz/sha512/4ea063982520400c02dcdf44ed3f018dec19607ad20762231316eb745cdb1cd054b18677fee1b5c5fb0bd55eb845121a2113704c5301be1d76edfc8a4a09d93f
+LibCURL.v8.6.0+0.x86_64-unknown-freebsd.tar.gz/md5/30dda5aaeb7977eb3563c603af08cd6c
+LibCURL.v8.6.0+0.x86_64-unknown-freebsd.tar.gz/sha512/edf603a6c013d3f6e01fc4fd6f12caf93ff99df9baf14bc73b610638a5b5ff90ec3118b112d9a39221294f5f419f3bf12232c16eaf91b07a68d92342a5c56912
+LibCURL.v8.6.0+0.x86_64-w64-mingw32.tar.gz/md5/9a2c980db329393f5274d42f87c2aec6
+LibCURL.v8.6.0+0.x86_64-w64-mingw32.tar.gz/sha512/6b926a87a3470796eb111e448c459a8ff1267533513f14d58f6e08cbebfb3e838c114827fcf39298bcefe8d76b8578bb4d3903c848bfafb0590022e6a49b2a00
+curl-8.6.0.tar.bz2/md5/4418e0d94f29d352afafdab445e37a3d
+curl-8.6.0.tar.bz2/sha512/726fe7e21f8a2a925ab4ab6fe4e4ad099105f00656bfdc702beec12e1549ba2cb63d908d1d19f43b90feeb1d950ae5a6ac9a72a27447f5acf1907df396d1823c
diff --git a/deps/curl.mk b/deps/curl.mk
index a063dfe07fba0..8454ec5f38b1e 100644
--- a/deps/curl.mk
+++ b/deps/curl.mk
@@ -57,7 +57,16 @@ CURL_TLS_CONFIGURE_FLAGS := --with-mbedtls=$(build_prefix)
 endif
 CURL_CONFIGURE_FLAGS += $(CURL_TLS_CONFIGURE_FLAGS)
 
-$(BUILDDIR)/curl-$(CURL_VER)/build-configured: $(SRCCACHE)/curl-$(CURL_VER)/source-extracted
+$(BUILDDIR)/curl-$(CURL_VER)/source-extracted/curl-memdup.patch-applied: $(SRCCACHE)/curl-$(CURL_VER)/source-extracted
+	mkdir -p $(dir $@)
+	cd $(SRCCACHE)/curl-$(CURL_VER) && \
+		patch -p1 -f < $(SRCDIR)/patches/curl-memdup.patch
+	echo 1 > $@
+
+$(SRCCACHE)/curl-$(CURL_VER)/source-patched: $(BUILDDIR)/curl-$(CURL_VER)/source-extracted/curl-memdup.patch-applied
+	echo 1 > $@
+
+$(BUILDDIR)/curl-$(CURL_VER)/build-configured: $(SRCCACHE)/curl-$(CURL_VER)/source-patched
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CURL_CONFIGURE_FLAGS) \
diff --git a/deps/curl.version b/deps/curl.version
index 9194b516aa1b1..5ecfcc2b642a1 100644
--- a/deps/curl.version
+++ b/deps/curl.version
@@ -3,4 +3,4 @@
 CURL_JLL_NAME := LibCURL
 
 ## source build
-CURL_VER := 8.5.0
+CURL_VER := 8.6.0
diff --git a/deps/patches/curl-memdup.patch b/deps/patches/curl-memdup.patch
new file mode 100644
index 0000000000000..596606027c447
--- /dev/null
+++ b/deps/patches/curl-memdup.patch
@@ -0,0 +1,24 @@
+From 5cc2b016c36aaf5a08e2feb7c068fca5bb0a8052 Mon Sep 17 00:00:00 2001
+From: Daniel Stenberg <daniel@haxx.se>
+Date: Mon, 5 Feb 2024 15:22:08 +0100
+Subject: [PATCH] md4: include strdup.h for the memdup proto
+
+Reported-by: Erik Schnetter
+Fixes #12849
+Closes #12863
+---
+ lib/md4.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/lib/md4.c b/lib/md4.c
+index 067c211e420afd..58dd1166cf924f 100644
+--- a/lib/md4.c
++++ b/lib/md4.c
+@@ -28,6 +28,7 @@
+ 
+ #include <string.h>
+ 
++#include "strdup.h"
+ #include "curl_md4.h"
+ #include "warnless.h"
+ 
diff --git a/stdlib/LibCURL_jll/Project.toml b/stdlib/LibCURL_jll/Project.toml
index 3360dc17df34d..d17090a1e5c3b 100644
--- a/stdlib/LibCURL_jll/Project.toml
+++ b/stdlib/LibCURL_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LibCURL_jll"
 uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
-version = "8.5.0+0"
+version = "8.6.0+0"
 
 [deps]
 LibSSH2_jll = "29816b5a-b9ab-546f-933c-edad1886dfa8"
@@ -17,4 +17,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 test = ["Test"]
 
 [compat]
-julia = "1.8"
+julia = "1.11"

From 2673c14581f1074794338eddc837691e571a6721 Mon Sep 17 00:00:00 2001
From: Matt Bauman <mbauman@juliahub.com>
Date: Thu, 8 Feb 2024 06:39:42 -0500
Subject: [PATCH 0838/1315] Clarify `==` docs for collections (#52495)

Alright, here's my spitball at fixing
https://github.com/JuliaLang/julia/issues/52484.

This also clarifies the non-missing behaviors, and adds a reference to
`all` which should be a useful breadcrumb. I don't want to say `all(x
.== y)` because that has all sorts of broadcasting semantics, but we
could perhaps add a comparison to `all(splat(==), zip(x, y))` or
`all(map(==, x, y))`, but even those feel sketchy to reference as they
may miss other properties (like array shape).

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: inky <git@wo-class.cn>
Co-authored-by: Max Horn <max@quendi.de>
---
 base/operators.jl | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/base/operators.jl b/base/operators.jl
index 5c403e5764563..2138888c82d9f 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -52,8 +52,9 @@ Generic equality operator. Falls back to [`===`](@ref).
 Should be implemented for all types with a notion of equality, based on the abstract value
 that an instance represents. For example, all numeric types are compared by numeric value,
 ignoring type. Strings are compared as sequences of characters, ignoring encoding.
-For collections, `==` is generally called recursively on all contents,
-though other properties (like the shape for arrays) may also be taken into account.
+Collections of the same type generally compare their key sets, and if those are `==`, then compare the values
+for each of those keys, returning true if all such pairs are `==`.
+Other properties are typically not taken into account (such as the exact type).
 
 This operator follows IEEE semantics for floating-point numbers: `0.0 == -0.0` and
 `NaN != NaN`.
@@ -61,8 +62,8 @@ This operator follows IEEE semantics for floating-point numbers: `0.0 == -0.0` a
 The result is of type `Bool`, except when one of the operands is [`missing`](@ref),
 in which case `missing` is returned
 ([three-valued logic](https://en.wikipedia.org/wiki/Three-valued_logic)).
-For collections, `missing` is returned if at least one of the operands contains
-a `missing` value and all non-missing values are equal.
+Collections generally implement three-valued logic akin to [`all`](@ref), returning
+missing if any operands contain missing values and all other pairs are equal.
 Use [`isequal`](@ref) or [`===`](@ref) to always get a `Bool` result.
 
 # Implementation

From c5ad46789dcf85c70a847d62f5859e59686fb532 Mon Sep 17 00:00:00 2001
From: Knut Andreas Meyer <knutam@gmail.com>
Date: Thu, 8 Feb 2024 12:44:55 +0100
Subject: [PATCH 0839/1315] Document --heap-size-hint in Command-line Interface
 (#50480)

Almost a direct copy of the output in `julia --help`.


Closes #50588

Co-authored-by: Max Horn <max@quendi.de>
---
 doc/src/manual/command-line-interface.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index c2bef7c9b73c2..b27c6bee1be38 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -213,6 +213,7 @@ The following is a complete list of command-line switches available when launchi
 |`--output-incremental={yes\|no*}`      |Generate an incremental output file (rather than complete)|
 |`--trace-compile={stderr,name}`        |Print precompile statements for methods compiled during execution or save to a path|
 |`--image-codegen`                      |Force generate code in imaging mode|
+|`--heap-size-hint=<size>`              |Forces garbage collection if memory usage is higher than that value. The memory hint might be specified in megabytes (e.g., 500M) or gigabytes (e.g., 1G)|
 
 
 !!! compat "Julia 1.1"

From 15e2af2c917fb6f343fc9973b3fc633e4b6efaea Mon Sep 17 00:00:00 2001
From: jam-khan <jamkhan@connect.hku.hk>
Date: Thu, 8 Feb 2024 06:52:35 -0500
Subject: [PATCH 0840/1315] Added docstring for Artifacts.jl (#52913)

This is a part of issue #52725.

---------

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
Co-authored-by: Max Horn <max@quendi.de>
---
 stdlib/Artifacts/src/Artifacts.jl | 6 ++++++
 stdlib/Artifacts/test/runtests.jl | 4 +---
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/stdlib/Artifacts/src/Artifacts.jl b/stdlib/Artifacts/src/Artifacts.jl
index b7db79b8ef6b4..968d190c2b443 100644
--- a/stdlib/Artifacts/src/Artifacts.jl
+++ b/stdlib/Artifacts/src/Artifacts.jl
@@ -1,5 +1,11 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+Artifacts.jl is a Julia module that is used for managing and accessing
+artifacts in Julia packages. Artifacts are containers for
+platform-specific binaries, datasets, text, or any other kind of data
+that would be convenient to place within an immutable, life-cycled datastore.
+"""
 module Artifacts
 
 import Base: get, SHA1
diff --git a/stdlib/Artifacts/test/runtests.jl b/stdlib/Artifacts/test/runtests.jl
index 2255930baf8e4..a09b3c7531996 100644
--- a/stdlib/Artifacts/test/runtests.jl
+++ b/stdlib/Artifacts/test/runtests.jl
@@ -263,7 +263,5 @@ end
 end
 
 @testset "Docstrings" begin
-    undoc = Docs.undocumented_names(Artifacts)
-    @test_broken isempty(undoc)
-    @test undoc == [:Artifacts]
+    @test isempty(Docs.undocumented_names(Artifacts))
 end

From b5bd10e5917f15289cfe176f27ef4566261d5081 Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Thu, 8 Feb 2024 12:54:08 +0100
Subject: [PATCH 0841/1315] Add `track_content` option to allow hashing of
 `include_dependency`s (#51798)

Continuation of #49866.
Fixes #52462

So far any `include_dependency` was tracked by `mtime`.
A package using `include_dependency` can't be relocated without
recompilation if the dependency also needs to be relocated.

With `include_dependency(path, track_content=true)` the tracking works
like for `include`,
i.e. recompilation is only triggered when the file's content changes.
In case `path` is a directory we use the string `join(readdir(path))` as
content.

---------

Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com>
---
 base/loading.jl                               | 25 ++++---
 test/Makefile                                 | 10 +--
 test/RelocationTestPkg1/Project.toml          |  1 -
 test/RelocationTestPkg2/Project.toml          |  1 -
 .../src/RelocationTestPkg2.jl                 |  1 +
 test/RelocationTestPkg3/Project.toml          |  3 +
 .../src/RelocationTestPkg3.jl                 |  7 ++
 test/RelocationTestPkg3/src/bar.txt           |  0
 test/loading.jl                               | 28 ++++++++
 test/relocatedepot.jl                         | 67 ++++++++++++++-----
 10 files changed, 108 insertions(+), 35 deletions(-)
 create mode 100644 test/RelocationTestPkg3/Project.toml
 create mode 100644 test/RelocationTestPkg3/src/RelocationTestPkg3.jl
 create mode 100644 test/RelocationTestPkg3/src/bar.txt

diff --git a/base/loading.jl b/base/loading.jl
index 7f359695a290a..34d1e848ecb98 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1780,13 +1780,11 @@ function _include_dependency(mod::Module, _path::AbstractString; track_content=t
     if _track_dependencies[]
         @lock require_lock begin
             if track_content
-                @assert isfile(path) "can only hash files"
+                hash = isdir(path) ? _crc32c(join(readdir(path))) : open(_crc32c, path, "r")
                 # use mtime=-1.0 here so that fsize==0 && mtime==0.0 corresponds to a missing include_dependency
-                push!(_require_dependencies,
-                      (mod, path, filesize(path), open(_crc32c, path, "r"), -1.0))
+                push!(_require_dependencies, (mod, path, filesize(path), hash, -1.0))
             else
-                push!(_require_dependencies,
-                      (mod, path, UInt64(0), UInt32(0), mtime(path)))
+                push!(_require_dependencies, (mod, path, UInt64(0), UInt32(0), mtime(path)))
             end
         end
     end
@@ -1794,17 +1792,22 @@ function _include_dependency(mod::Module, _path::AbstractString; track_content=t
 end
 
 """
-    include_dependency(path::AbstractString)
+    include_dependency(path::AbstractString; track_content::Bool=false)
 
 In a module, declare that the file, directory, or symbolic link specified by `path`
 (relative or absolute) is a dependency for precompilation; that is, the module will need
-to be recompiled if the modification time of `path` changes.
+to be recompiled if the modification time `mtime` of `path` changes.
+If `track_content=true` recompilation is triggered when the content of `path` changes
+(if `path` is a directory the content equals `join(readdir(path))`).
 
 This is only needed if your module depends on a path that is not used via [`include`](@ref). It has
 no effect outside of compilation.
+
+!!! compat "Julia 1.11"
+    Keyword argument `track_content` requires at least Julia 1.11.
 """
-function include_dependency(path::AbstractString)
-    _include_dependency(Main, path, track_content=false)
+function include_dependency(path::AbstractString; track_content::Bool=false)
+    _include_dependency(Main, path, track_content=track_content)
     return nothing
 end
 
@@ -2754,7 +2757,7 @@ end
 function resolve_depot(inc::AbstractString)
     startswith(inc, string("@depot", Filesystem.pathsep())) || return :not_relocatable
     for depot in DEPOT_PATH
-        isfile(restore_depot_path(inc, depot)) && return depot
+        ispath(restore_depot_path(inc, depot)) && return depot
     end
     return :no_depot_found
 end
@@ -3480,7 +3483,7 @@ end
                         record_reason(reasons, "include_dependency fsize change")
                         return true
                     end
-                    hash = open(_crc32c, f, "r")
+                    hash = isdir(f) ? _crc32c(join(readdir(f))) : open(_crc32c, f, "r")
                     if hash != hash_req
                         @debug "Rejecting stale cache file $cachefile because hash of $f has changed (hash $hash, before $hash_req)"
                         record_reason(reasons, "include_dependency fhash change")
diff --git a/test/Makefile b/test/Makefile
index d2d6b39747cae..e522ec811b167 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -37,24 +37,26 @@ $(addprefix revise-, $(TESTS)): revise-% :
 relocatedepot:
 	@rm -rf $(SRCDIR)/relocatedepot
 	@cd $(SRCDIR) && \
-	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
+	$(call PRINT_JULIA, $(call spawn,$(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
 	@mkdir $(SRCDIR)/relocatedepot
 	@cp -R $(build_datarootdir)/julia $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg1 $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg2 $(SRCDIR)/relocatedepot
+	@cp -R $(SRCDIR)/RelocationTestPkg3 $(SRCDIR)/relocatedepot
 	@cd $(SRCDIR) && \
-	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading RELOCATEDEPOT="" $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
+	$(call PRINT_JULIA, $(call spawn,RELOCATEDEPOT="" $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
 
 revise-relocatedepot: revise-% :
 	@rm -rf $(SRCDIR)/relocatedepot
 	@cd $(SRCDIR) && \
-	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
+	$(call PRINT_JULIA, $(call spawn,$(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
 	@mkdir $(SRCDIR)/relocatedepot
 	@cp -R $(build_datarootdir)/julia $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg1 $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg2 $(SRCDIR)/relocatedepot
+	@cp -R $(SRCDIR)/RelocationTestPkg3 $(SRCDIR)/relocatedepot
 	@cd $(SRCDIR) && \
-	$(call PRINT_JULIA, $(call spawn,JULIA_DEBUG=loading RELOCATEDEPOT="" $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
+	$(call PRINT_JULIA, $(call spawn,RELOCATEDEPOT="" $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
 
 embedding:
 	@$(MAKE) -C $(SRCDIR)/$@ check $(EMBEDDING_ARGS)
diff --git a/test/RelocationTestPkg1/Project.toml b/test/RelocationTestPkg1/Project.toml
index 826980207d508..4b5b67c3aef2d 100644
--- a/test/RelocationTestPkg1/Project.toml
+++ b/test/RelocationTestPkg1/Project.toml
@@ -1,4 +1,3 @@
 name = "RelocationTestPkg1"
 uuid = "854e1adb-5a97-46bf-a391-1cfe05ac726d"
-authors = ["flo "]
 version = "0.1.0"
diff --git a/test/RelocationTestPkg2/Project.toml b/test/RelocationTestPkg2/Project.toml
index 68da889785215..b909269a0894c 100644
--- a/test/RelocationTestPkg2/Project.toml
+++ b/test/RelocationTestPkg2/Project.toml
@@ -1,4 +1,3 @@
 name = "RelocationTestPkg2"
 uuid = "8d933983-b090-4b0b-a37e-c34793f459d1"
-authors = ["flo "]
 version = "0.1.0"
diff --git a/test/RelocationTestPkg2/src/RelocationTestPkg2.jl b/test/RelocationTestPkg2/src/RelocationTestPkg2.jl
index 0d8b5e15edf06..dc36a06cb48d4 100644
--- a/test/RelocationTestPkg2/src/RelocationTestPkg2.jl
+++ b/test/RelocationTestPkg2/src/RelocationTestPkg2.jl
@@ -1,6 +1,7 @@
 module RelocationTestPkg2
 
 include_dependency("foo.txt")
+include_dependency("foodir")
 greet() = print("Hello World!")
 
 end # module RelocationTestPkg2
diff --git a/test/RelocationTestPkg3/Project.toml b/test/RelocationTestPkg3/Project.toml
new file mode 100644
index 0000000000000..61882cb5cda65
--- /dev/null
+++ b/test/RelocationTestPkg3/Project.toml
@@ -0,0 +1,3 @@
+name = "RelocationTestPkg3"
+uuid = "1ba4f954-9da9-4cd2-9ca7-6250235df52c"
+version = "0.1.0"
diff --git a/test/RelocationTestPkg3/src/RelocationTestPkg3.jl b/test/RelocationTestPkg3/src/RelocationTestPkg3.jl
new file mode 100644
index 0000000000000..6ed8e1e560a99
--- /dev/null
+++ b/test/RelocationTestPkg3/src/RelocationTestPkg3.jl
@@ -0,0 +1,7 @@
+module RelocationTestPkg3
+
+include_dependency("bar.txt", track_content=true)
+include_dependency("bardir", track_content=true)
+greet() = print("Hello World!")
+
+end # module RelocationTestPkg3
diff --git a/test/RelocationTestPkg3/src/bar.txt b/test/RelocationTestPkg3/src/bar.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/test/loading.jl b/test/loading.jl
index 5d43cd085f5d6..3740babcd17ed 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1504,3 +1504,31 @@ end
         @test occursin(r"Loading object cache file .+ for Parent", log)
     end
 end
+
+@testset "including non-existent file throws proper error #52462" begin
+    mktempdir() do depot
+        project_path = joinpath(depot, "project")
+        mkpath(project_path)
+
+        # Create a `Foo.jl` package
+        foo_path = joinpath(depot, "dev", "Foo52462")
+        mkpath(joinpath(foo_path, "src"))
+        open(joinpath(foo_path, "src", "Foo52462.jl"); write=true) do io
+            println(io, """
+            module Foo52462
+            include("non-existent.jl")
+            end
+            """)
+        end
+        open(joinpath(foo_path, "Project.toml"); write=true) do io
+            println(io, """
+            name = "Foo52462"
+            uuid = "00000000-0000-0000-0000-000000000001"
+            version = "1.0.0"
+            """)
+        end
+
+        file = joinpath(depot, "dev", "non-existent.jl")
+        @test_throws SystemError("opening file $(repr(file))") include(file)
+    end
+end
diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
index 0a514e7786916..b2a539ac330d3 100644
--- a/test/relocatedepot.jl
+++ b/test/relocatedepot.jl
@@ -1,5 +1,4 @@
 using Test
-using Logging
 
 
 include("testenv.jl")
@@ -18,6 +17,10 @@ function test_harness(@nospecialize(fn); empty_load_path=true, empty_depot_path=
     end
 end
 
+# We test relocation with three dummy pkgs:
+# - RelocationTestPkg1 - no include_dependency
+# - RelocationTestPkg2 - with include_dependency tracked by `mtime`
+# - RelocationTestPkg3 - with include_dependency tracked by content
 
 if !test_relocated_depot
 
@@ -70,27 +73,46 @@ if !test_relocated_depot
         pkgname = "RelocationTestPkg1"
         test_harness(empty_depot_path=false) do
             push!(LOAD_PATH, @__DIR__)
-            push!(DEPOT_PATH, @__DIR__) # required to make relocatable, but cache is written to DEPOT_PATH[1]
+            push!(DEPOT_PATH, @__DIR__) # make src files available for relocation
             pkg = Base.identify_package(pkgname)
             cachefiles = Base.find_all_in_cache_path(pkg)
             rm.(cachefiles, force=true)
             @test Base.isprecompiled(pkg) == false
-            Base.require(pkg) # precompile
+            Base.require(pkg)
             @test Base.isprecompiled(pkg, ignore_loaded=true) == true
         end
     end
 
-    @testset "precompile RelocationTestPkg2 (contains include_dependency)" begin
+    @testset "precompile RelocationTestPkg2" begin
         pkgname = "RelocationTestPkg2"
         test_harness(empty_depot_path=false) do
             push!(LOAD_PATH, @__DIR__)
-            push!(DEPOT_PATH, @__DIR__) # required to make relocatable, but cache is written to DEPOT_PATH[1]
+            push!(DEPOT_PATH, @__DIR__) # make src files available for relocation
             pkg = Base.identify_package(pkgname)
             cachefiles = Base.find_all_in_cache_path(pkg)
             rm.(cachefiles, force=true)
+            rm(joinpath(@__DIR__, pkgname, "src", "foodir"), force=true, recursive=true)
             @test Base.isprecompiled(pkg) == false
             touch(joinpath(@__DIR__, pkgname, "src", "foo.txt"))
-            Base.require(pkg) # precompile
+            mkdir(joinpath(@__DIR__, pkgname, "src", "foodir"))
+            Base.require(pkg)
+            @test Base.isprecompiled(pkg, ignore_loaded=true) == true
+        end
+    end
+
+    @testset "precompile RelocationTestPkg3" begin
+        pkgname = "RelocationTestPkg3"
+        test_harness(empty_depot_path=false) do
+            push!(LOAD_PATH, @__DIR__)
+            push!(DEPOT_PATH, @__DIR__) # make src files available for relocation
+            pkg = Base.identify_package(pkgname)
+            cachefiles = Base.find_all_in_cache_path(pkg)
+            rm.(cachefiles, force=true)
+            rm(joinpath(@__DIR__, pkgname, "src", "bardir"), force=true, recursive=true)
+            @test Base.isprecompiled(pkg) == false
+            touch(joinpath(@__DIR__, pkgname, "src", "bar.txt"))
+            mkdir(joinpath(@__DIR__, pkgname, "src", "bardir"))
+            Base.require(pkg)
             @test Base.isprecompiled(pkg, ignore_loaded=true) == true
         end
     end
@@ -139,10 +161,8 @@ if !test_relocated_depot
                         version = "1.0.0"
                         """)
                     end
-                    pushfirst!(LOAD_PATH, depot2)
-                    pushfirst!(DEPOT_PATH, depot2)
-                    pkg = Base.identify_package("Example2")
-                    Base.require(pkg)
+                    pushfirst!(LOAD_PATH, depot2); pushfirst!(DEPOT_PATH, depot2)
+                    pkg = Base.identify_package("Example2"); Base.require(pkg)
                     mktempdir() do depot3
                         # precompile Foo in depot3
                         open(joinpath(depot3, "Module52161.jl"), write=true) do io
@@ -157,10 +177,8 @@ if !test_relocated_depot
                             end
                             """)
                         end
-                        pushfirst!(LOAD_PATH, depot3)
-                        pushfirst!(DEPOT_PATH, depot3)
-                        pkg = Base.identify_package("Module52161")
-                        Base.compilecache(pkg)
+                        pushfirst!(LOAD_PATH, depot3); pushfirst!(DEPOT_PATH, depot3)
+                        pkg = Base.identify_package("Module52161"); Base.compilecache(pkg)
                         cachefile = joinpath(depot3, "compiled",
                                              "v$(VERSION.major).$(VERSION.minor)", "Module52161.ji")
                         _, (deps, _, _), _... = Base.parse_cache_header(cachefile)
@@ -195,12 +213,10 @@ else
             push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
             pkg = Base.identify_package(pkgname)
             @test Base.isprecompiled(pkg) == true
-            Base.require(pkg) # re-precompile
-            @test Base.isprecompiled(pkg) == true
         end
     end
 
-    @testset "load RelocationTestPkg2 (contains include_dependency) from test/relocatedepot" begin
+    @testset "load RelocationTestPkg2 from test/relocatedepot" begin
         pkgname = "RelocationTestPkg2"
         test_harness() do
             push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
@@ -208,8 +224,23 @@ else
             push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
             pkg = Base.identify_package(pkgname)
             @test Base.isprecompiled(pkg) == false # moving depot changes mtime of include_dependency
-            Base.require(pkg) # re-precompile
+            Base.require(pkg)
             @test Base.isprecompiled(pkg) == true
+            touch(joinpath(@__DIR__, "relocatedepot", "RelocationTestPkg2", "src", "foodir", "foofoo"))
+            @test Base.isprecompiled(pkg) == false
+        end
+    end
+
+    @testset "load RelocationTestPkg3 from test/relocatedepot" begin
+        pkgname = "RelocationTestPkg3"
+        test_harness() do
+            push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
+            pkg = Base.identify_package(pkgname)
+            @test Base.isprecompiled(pkg) == true
+            touch(joinpath(@__DIR__, "relocatedepot", "RelocationTestPkg3", "src", "bardir", "barbar"))
+            @test Base.isprecompiled(pkg) == false
         end
     end
 

From 4c2df211bf0fdb331347e283a164311feed59f1b Mon Sep 17 00:00:00 2001
From: James Wrigley <JamesWrigley@users.noreply.github.com>
Date: Thu, 8 Feb 2024 12:55:17 +0100
Subject: [PATCH 0842/1315] Add `Pipe` to the documentation (#53202)

The reasoning is that `Pipe` is specifically documented in other
functions that are part of the public API (e.g. `redirect_stdio()`), so
it should be documented too. Same goes for `link_pipe!()` since it's
mentioned in the `Pipe` docstring.

The other function that could be documented is `open_pipe!()`, but that
specifically applies to `PipeEndpoint`'s and I could imagine that we
want it to be difficult to create a half-initialized `Pipe`
:sweat_smile: I wrote a docstring for `link_pipe!()` based off the libuv
docs: https://docs.libuv.org/en/v1.x/pipe.html#c.uv_pipe
---
 base/exports.jl            |  2 ++
 base/expr.jl               |  2 --
 base/stream.jl             | 22 ++++++++++++++++------
 doc/src/base/io-network.md |  2 ++
 4 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/base/exports.jl b/base/exports.jl
index 6b783eff9179b..b1b84539c07a3 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1137,6 +1137,7 @@ public
     summarysize,
     isexported,
     ispublic,
+    remove_linenums!,
 
 # Opperators
     operator_associativity,
@@ -1168,6 +1169,7 @@ public
     TTY,
     # functions
     reseteof,
+    link_pipe!,
 
 # misc
     notnothing,
diff --git a/base/expr.jl b/base/expr.jl
index f6ca12f07a63d..39da1408a77b3 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -1026,8 +1026,6 @@ function remove_linenums!(@nospecialize ex)
     end
 end
 
-public remove_linenums!
-
 replace_linenums!(ex, ln::LineNumberNode) = ex
 function replace_linenums!(ex::Expr, ln::LineNumberNode)
     if ex.head === :block || ex.head === :quote
diff --git a/base/stream.jl b/base/stream.jl
index 542e77ec81cdd..14621c464ce1b 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -764,12 +764,21 @@ julia> read(err, String)
 "stderr messages"
 ```
 
-See also `Base.link_pipe!`.
+See also [`Base.link_pipe!`](@ref).
 """
 Pipe() = Pipe(PipeEndpoint(), PipeEndpoint())
 pipe_reader(p::Pipe) = p.out
 pipe_writer(p::Pipe) = p.in
 
+"""
+    link_pipe!(pipe; reader_supports_async=false, writer_supports_async=false)
+
+Initialize `pipe` and link the `in` endpoint to the `out` endpoint. The keyword
+arguments `reader_supports_async`/`writer_supports_async` correspond to
+`OVERLAPPED` on Windows and `O_NONBLOCK` on POSIX systems. They should be `true`
+unless they'll be used by an external program (e.g. the output of a command
+executed with [`run`](@ref)).
+"""
 function link_pipe!(pipe::Pipe;
                     reader_supports_async = false,
                     writer_supports_async = false)
@@ -1285,7 +1294,7 @@ the pipe.
 
 !!! note
     `stream` must be a compatible objects, such as an `IOStream`, `TTY`,
-    `Pipe`, socket, or `devnull`.
+    [`Pipe`](@ref), socket, or `devnull`.
 
 See also [`redirect_stdio`](@ref).
 """
@@ -1298,7 +1307,7 @@ Like [`redirect_stdout`](@ref), but for [`stderr`](@ref).
 
 !!! note
     `stream` must be a compatible objects, such as an `IOStream`, `TTY`,
-    `Pipe`, socket, or `devnull`.
+    [`Pipe`](@ref), socket, or `devnull`.
 
 See also [`redirect_stdio`](@ref).
 """
@@ -1312,7 +1321,7 @@ Note that the direction of the stream is reversed.
 
 !!! note
     `stream` must be a compatible objects, such as an `IOStream`, `TTY`,
-    `Pipe`, socket, or `devnull`.
+    [`Pipe`](@ref), socket, or `devnull`.
 
 See also [`redirect_stdio`](@ref).
 """
@@ -1322,7 +1331,8 @@ redirect_stdin
     redirect_stdio(;stdin=stdin, stderr=stderr, stdout=stdout)
 
 Redirect a subset of the streams `stdin`, `stderr`, `stdout`.
-Each argument must be an `IOStream`, `TTY`, `Pipe`, socket, or `devnull`.
+Each argument must be an `IOStream`, `TTY`, [`Pipe`](@ref), socket, or
+`devnull`.
 
 !!! compat "Julia 1.7"
     `redirect_stdio` requires Julia 1.7 or later.
@@ -1342,7 +1352,7 @@ call `f()` and restore each stream.
 Possible values for each stream are:
 * `nothing` indicating the stream should not be redirected.
 * `path::AbstractString` redirecting the stream to the file at `path`.
-* `io` an `IOStream`, `TTY`, `Pipe`, socket, or `devnull`.
+* `io` an `IOStream`, `TTY`, [`Pipe`](@ref), socket, or `devnull`.
 
 # Examples
 ```julia-repl
diff --git a/doc/src/base/io-network.md b/doc/src/base/io-network.md
index 33fc113375e4e..f99f592e0fb5c 100644
--- a/doc/src/base/io-network.md
+++ b/doc/src/base/io-network.md
@@ -12,6 +12,8 @@ Base.open
 Base.IOStream
 Base.IOBuffer
 Base.take!(::Base.GenericIOBuffer)
+Base.Pipe
+Base.link_pipe!
 Base.fdio
 Base.flush
 Base.close

From e68e4321d0b5a982bbd858372af6a8c887ebe3cb Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Thu, 8 Feb 2024 12:56:45 +0100
Subject: [PATCH 0843/1315] allow printing some TOML dictionaries inline by
 marking them with an IdSet (#53233)

This was one way I came up with to "mark" what dictionaries one wants to
print inline. I am not sure `IdSet` is even considered public but it
seemed the most reasonable for this.
---
 stdlib/TOML/src/TOML.jl   |  5 ++--
 stdlib/TOML/src/print.jl  | 52 ++++++++++++++++++++++--------------
 stdlib/TOML/test/print.jl | 55 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 91 insertions(+), 21 deletions(-)

diff --git a/stdlib/TOML/src/TOML.jl b/stdlib/TOML/src/TOML.jl
index a94eb926f8b88..64d715ceef832 100644
--- a/stdlib/TOML/src/TOML.jl
+++ b/stdlib/TOML/src/TOML.jl
@@ -110,10 +110,11 @@ const ParserError = Internals.ParserError
 
 
 """
-    print([to_toml::Function], io::IO [=stdout], data::AbstractDict; sorted=false, by=identity)
+    print([to_toml::Function], io::IO [=stdout], data::AbstractDict; sorted=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict})
 
 Write `data` as TOML syntax to the stream `io`. If the keyword argument `sorted` is set to `true`,
-sort tables according to the function given by the keyword argument `by`.
+sort tables according to the function given by the keyword argument `by`. If the keyword argument
+`inline_tables` is given, it should be a set of tables that should be printed "inline".
 
 The following data types are supported: `AbstractDict`, `AbstractVector`, `AbstractString`, `Integer`, `AbstractFloat`, `Bool`,
 `Dates.DateTime`, `Dates.Time`, `Dates.Date`. Note that the integers and floats
diff --git a/stdlib/TOML/src/print.jl b/stdlib/TOML/src/print.jl
index 1fa9f97405504..06e4f08f35c46 100644
--- a/stdlib/TOML/src/print.jl
+++ b/stdlib/TOML/src/print.jl
@@ -74,21 +74,21 @@ end
 ##########
 
 # Fallback
-function printvalue(f::MbyFunc, io::IO, value)
+function printvalue(f::MbyFunc, io::IO, value, sorted::Bool)
     toml_value = to_toml_value(f, value)
     @invokelatest printvalue(f, io, toml_value)
 end
 
-function printvalue(f::MbyFunc, io::IO, value::AbstractVector)
+function printvalue(f::MbyFunc, io::IO, value::AbstractVector, sorted::Bool)
     Base.print(io, "[")
     for (i, x) in enumerate(value)
         i != 1 && Base.print(io, ", ")
-        printvalue(f, io, x)
+        printvalue(f, io, x, sorted)
     end
     Base.print(io, "]")
 end
 
-function printvalue(f::MbyFunc, io::IO, value::TOMLValue)
+function printvalue(f::MbyFunc, io::IO, value::TOMLValue, sorted::Bool)
     value isa Dates.DateTime ? Base.print(io, Dates.format(value, Dates.dateformat"YYYY-mm-dd\THH:MM:SS.sss\Z")) :
     value isa Dates.Time     ? Base.print(io, Dates.format(value, Dates.dateformat"HH:MM:SS.sss")) :
     value isa Dates.Date     ? Base.print(io, Dates.format(value, Dates.dateformat"YYYY-mm-dd")) :
@@ -100,7 +100,7 @@ function printvalue(f::MbyFunc, io::IO, value::TOMLValue)
     value isa AbstractString ? (Base.print(io, "\"");
                                 print_toml_escaped(io, value);
                                 Base.print(io, "\"")) :
-    value isa AbstractDict ? print_inline_table(f, io, value) :
+    value isa AbstractDict ? print_inline_table(f, io, value, sorted) :
     error("internal error in TOML printing, unhandled value")
 end
 
@@ -112,13 +112,18 @@ function print_integer(io::IO, value::Integer)
     return
 end
 
-function print_inline_table(f::MbyFunc, io::IO, value::AbstractDict)
+function print_inline_table(f::MbyFunc, io::IO, value::AbstractDict, sorted::Bool)
+    vkeys = collect(keys(value))
+    if sorted
+        sort!(vkeys)
+    end
     Base.print(io, "{")
-    for (i, (k,v)) in enumerate(value)
+    for (i, k) in enumerate(vkeys)
+        v = value[k]
         i != 1 && Base.print(io, ", ")
         printkey(io, [String(k)])
         Base.print(io, " = ")
-        printvalue(f, io, v)
+        printvalue(f, io, v, sorted)
     end
     Base.print(io, "}")
 end
@@ -141,11 +146,18 @@ function print_table(f::MbyFunc, io::IO, a::AbstractDict,
     indent::Int = 0,
     first_block::Bool = true,
     sorted::Bool = false,
+    inline_tables::Base.IdSet,
     by::Function = identity,
 )
+
+    if a in inline_tables
+        @invokelatest print_inline_table(f, io, a)
+        return
+    end
+
     akeys = keys(a)
     if sorted
-        akeys = sort!(collect(akeys); by=by)
+        akeys = sort!(collect(akeys); by)
     end
 
     # First print non-tabular entries
@@ -154,12 +166,14 @@ function print_table(f::MbyFunc, io::IO, a::AbstractDict,
         if !isa(value, TOMLValue)
             value = to_toml_value(f, value)
         end
-        is_tabular(value) && continue
+        if is_tabular(value) && !(value in inline_tables)
+            continue
+        end
 
         Base.print(io, ' '^4max(0,indent-1))
         printkey(io, [String(key)])
         Base.print(io, " = ") # print separator
-        printvalue(f, io, value)
+        printvalue(f, io, value, sorted)
         Base.print(io, "\n")  # new line?
         first_block = false
     end
@@ -169,10 +183,10 @@ function print_table(f::MbyFunc, io::IO, a::AbstractDict,
         if !isa(value, TOMLValue)
             value = to_toml_value(f, value)
         end
-        if is_table(value)
+        if is_table(value) && !(value in inline_tables)
             push!(ks, String(key))
             _values = @invokelatest values(value)
-            header = isempty(value) || !all(is_tabular(v) for v in _values)::Bool
+            header = isempty(value) || !all(is_tabular(v) for v in _values)::Bool || any(v in inline_tables for v in _values)::Bool
             if header
                 # print table
                 first_block || println(io)
@@ -183,7 +197,7 @@ function print_table(f::MbyFunc, io::IO, a::AbstractDict,
                 Base.print(io,"]\n")
             end
             # Use runtime dispatch here since the type of value seems not to be enforced other than as AbstractDict
-            @invokelatest print_table(f, io, value, ks; indent = indent + header, first_block = header, sorted=sorted, by=by)
+            @invokelatest print_table(f, io, value, ks; indent = indent + header, first_block = header, sorted, by, inline_tables)
             pop!(ks)
         elseif @invokelatest(is_array_of_tables(value))
             # print array of tables
@@ -197,7 +211,7 @@ function print_table(f::MbyFunc, io::IO, a::AbstractDict,
                 Base.print(io,"]]\n")
                 # TODO, nicer error here
                 !isa(v, AbstractDict) && error("array should contain only tables")
-                @invokelatest print_table(f, io, v, ks; indent = indent + 1, sorted=sorted, by=by)
+                @invokelatest print_table(f, io, v, ks; indent = indent + 1, sorted, by, inline_tables)
             end
             pop!(ks)
         end
@@ -209,7 +223,7 @@ end
 # API #
 #######
 
-print(f::MbyFunc, io::IO, a::AbstractDict; sorted::Bool=false, by=identity) = print_table(f, io, a; sorted=sorted, by=by)
-print(f::MbyFunc, a::AbstractDict; sorted::Bool=false, by=identity) = print(f, stdout, a; sorted=sorted, by=by)
-print(io::IO, a::AbstractDict; sorted::Bool=false, by=identity) = print_table(nothing, io, a; sorted=sorted, by=by)
-print(a::AbstractDict; sorted::Bool=false, by=identity) = print(nothing, stdout, a; sorted=sorted, by=by)
+print(f::MbyFunc, io::IO, a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict}=Base.IdSet{Dict{String}}()) = print_table(f, io, a; sorted, by, inline_tables)
+print(f::MbyFunc,         a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict}=Base.IdSet{Dict{String}}()) = print(f, stdout, a; sorted, by, inline_tables)
+print(io::IO, a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict}=Base.IdSet{Dict{String}}()) = print_table(nothing, io, a; sorted, by, inline_tables)
+print(        a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict}=Base.IdSet{Dict{String}}()) = print(nothing, stdout, a; sorted, by, inline_tables)
diff --git a/stdlib/TOML/test/print.jl b/stdlib/TOML/test/print.jl
index 765b6feb491a5..9698a2871ae27 100644
--- a/stdlib/TOML/test/print.jl
+++ b/stdlib/TOML/test/print.jl
@@ -140,3 +140,58 @@ d = "hello"
 a = 2
 b = 9.9
 """
+
+
+inline_dict = Dict("a" => [1,2], "b" => Dict("a" => "b"), "c" => "foo")
+d = Dict(
+    "x" => "y",
+    "y" => inline_dict,
+    "z" => [1,2,3],
+)
+inline_tables = Base.IdSet{Dict}()
+push!(inline_tables, inline_dict)
+@test toml_str(d; sorted=true, inline_tables) ==
+"""
+x = "y"
+y = {a = [1, 2], b = {a = "b"}, c = "foo"}
+z = [1, 2, 3]
+"""
+
+
+d = Dict("deps" => Dict(
+        "LocalPkg" => "fcf55292-0d03-4e8a-9e0b-701580031fc3",
+        "Example" => "7876af07-990d-54b4-ab0e-23690620f79a"),
+   "sources" => Dict(
+        "LocalPkg" => Dict("path" => "LocalPkg"),
+        "Example" => Dict("url" => "https://github.com/JuliaLang/Example.jl")))
+
+inline_tables = Base.IdSet{Dict}()
+push!(inline_tables, d["sources"]["LocalPkg"])
+push!(inline_tables, d["sources"]["Example"])
+
+@test toml_str(d; sorted=true, inline_tables) ==
+"""
+[deps]
+Example = "7876af07-990d-54b4-ab0e-23690620f79a"
+LocalPkg = "fcf55292-0d03-4e8a-9e0b-701580031fc3"
+
+[sources]
+Example = {url = "https://github.com/JuliaLang/Example.jl"}
+LocalPkg = {path = "LocalPkg"}
+"""
+
+inline_tables = Base.IdSet{Dict}()
+push!(inline_tables, d["sources"]["LocalPkg"])
+s = """
+[deps]
+Example = "7876af07-990d-54b4-ab0e-23690620f79a"
+LocalPkg = "fcf55292-0d03-4e8a-9e0b-701580031fc3"
+
+[sources]
+LocalPkg = {path = "LocalPkg"}
+
+    [sources.Example]
+    url = "https://github.com/JuliaLang/Example.jl"
+"""
+@test toml_str(d; sorted=true, inline_tables) == s
+@test roundtrip(s)

From ebe947e95eb818d7ad10495f114124e9be42dd6b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= <lars.goettgens@rwth-aachen.de>
Date: Thu, 8 Feb 2024 12:57:22 +0100
Subject: [PATCH 0844/1315] Add docstring for InteractiveUtils module (#53206)

Handles the `InteractiveUtils` part of
https://github.com/JuliaLang/julia/issues/52725.

cc @stevengj
---
 stdlib/InteractiveUtils/docs/src/index.md       | 4 +++-
 stdlib/InteractiveUtils/src/InteractiveUtils.jl | 5 +++++
 stdlib/InteractiveUtils/test/runtests.jl        | 4 +---
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/stdlib/InteractiveUtils/docs/src/index.md b/stdlib/InteractiveUtils/docs/src/index.md
index d0c46676127e6..dbfb42b9a931d 100644
--- a/stdlib/InteractiveUtils/docs/src/index.md
+++ b/stdlib/InteractiveUtils/docs/src/index.md
@@ -4,7 +4,9 @@ EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/InteractiveUtil
 
 # [Interactive Utilities](@id man-interactive-utils)
 
-This module is intended for interactive work. It is loaded automatically in [interactive mode](@ref command-line-interface).
+The `InteractiveUtils` module provides utilities for interactive use of Julia,
+such as code introspection and clipboard access.
+It is intended for interactive work and is loaded automatically in [interactive mode](@ref command-line-interface).
 
 ```@docs
 InteractiveUtils.apropos
diff --git a/stdlib/InteractiveUtils/src/InteractiveUtils.jl b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
index 9927af1a4db9a..7391a0d6b2f00 100644
--- a/stdlib/InteractiveUtils/src/InteractiveUtils.jl
+++ b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
@@ -1,5 +1,10 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+The `InteractiveUtils` module provides utilities for interactive use of Julia,
+such as code introspection and clipboard access.
+It is intended for interactive work and is loaded automatically in interactive mode.
+"""
 module InteractiveUtils
 
 Base.Experimental.@optlevel 1
diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index cb0621516189a..94c0c42e2d2da 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -726,7 +726,5 @@ end
 @test Base.infer_effects(sin, (Int,)) == InteractiveUtils.@infer_effects sin(42)
 
 @testset "Docstrings" begin
-    undoc = Docs.undocumented_names(InteractiveUtils)
-    @test_broken isempty(undoc)
-    @test undoc == [:InteractiveUtils]
+    @test isempty(Docs.undocumented_names(InteractiveUtils))
 end

From c1a7bb2787695334c56f504d1f8447dadeb29e3a Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 8 Feb 2024 07:05:47 -0500
Subject: [PATCH 0845/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20f3b81f1aa=20to=206dd0e7c9e=20(take=202?=
 =?UTF-8?q?)=20(#53220)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces https://github.com/JuliaLang/julia/pull/53216 (I can't push to
that repo branch)

Adds
- making pkgimages for REPLExt
- Fixes PkgCompletionProvider location

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: f3b81f1aa
New commit: 6dd0e7c9e
Julia version: 1.11.0-DEV
Pkg version: 1.11.0
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/f3b81f1aac77acf08f5d847ead29ad0a228dec67...6dd0e7c9e99d578aa5477e2c78c91a161ce4c357

```
$ git log --oneline f3b81f1aa..6dd0e7c9e
6dd0e7c9e Revert "add test for recurring precompile" (#3779)
dbf114fa9 Merge pull request #3777 from JuliaLang/kc/repl_extension
a49d47981 fixup
e3edf3917 avoid prompting for git creds on CI (#3778)
510454343 make the `REPL` specific code into an extension
12d2de14e make `pkgstr` independent of REPL
```

---------

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com>
Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 .../md5                                        |  1 +
 .../sha512                                     |  1 +
 .../md5                                        |  1 -
 .../sha512                                     |  1 -
 pkgimage.mk                                    | 18 ++++++++++++++++--
 stdlib/Pkg.version                             |  2 +-
 stdlib/REPL/src/REPL.jl                        |  3 ++-
 stdlib/stdlib.mk                               | 16 ++++++++++++----
 8 files changed, 33 insertions(+), 10 deletions(-)
 create mode 100644 deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512

diff --git a/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5 b/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5
new file mode 100644
index 0000000000000..0bd59e0f13bab
--- /dev/null
+++ b/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5
@@ -0,0 +1 @@
+fcf25a83bfb9c68eb34ecf50612ef2e5
diff --git a/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512 b/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512
new file mode 100644
index 0000000000000..03fc867f28070
--- /dev/null
+++ b/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512
@@ -0,0 +1 @@
+25fa3274513292c5e28502a8d9ffbf193ba44e32550e10dfcb880b7544780270ad155ef64d4346f9d10b8068fb8feb271c16a76aa93a99ede7f16ad5caafca38
diff --git a/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5 b/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5
deleted file mode 100644
index 93e66678953cc..0000000000000
--- a/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-97bb9e102d5a173aad9b17d16d244b7b
diff --git a/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512 b/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512
deleted file mode 100644
index 82bdcc9857777..0000000000000
--- a/deps/checksums/Pkg-f3b81f1aac77acf08f5d847ead29ad0a228dec67.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-2942a381f56ef739addb369de078739861a46a6e98481d5b7e7b0858a6de18e42e630e2ed4f9a3bfad4245a082f44de928d6e449f61f84a72fb521154b402a3b
diff --git a/pkgimage.mk b/pkgimage.mk
index 776a97e65a950..9a46a8d581bf8 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -28,11 +28,11 @@ all-release: $(addprefix cache-release-, $(STDLIBS))
 all-debug:   $(addprefix cache-debug-, $(STDLIBS))
 
 define stdlib_builder
-ifneq ($(filter $(1),$(INDEPENDENT_STDLIBS)),)
+ifneq ($(filter $(1),$(INDEPENDENT_STDLIBS) $(PKG_EXTS)),)
 # Define target-specific export for `JULIA_CPU_TARGET`
 $$(BUILDDIR)/stdlib/$1.release.image: export JULIA_CPU_TARGET=$(JULIA_CPU_TARGET)
 $$(BUILDDIR)/stdlib/$1.debug.image: export JULIA_CPU_TARGET=$(JULIA_CPU_TARGET)
-
+ifneq ($(filter $(1),$(INDEPENDENT_STDLIBS)),)
 $$(BUILDDIR)/stdlib/$1.release.image: $$($1_SRCS) $$(addsuffix .release.image,$$(addprefix $$(BUILDDIR)/stdlib/,$2)) $(build_private_libdir)/sys.$(SHLIB_EXT)
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.compilecache(Base.identify_package("$1"))')
@@ -41,6 +41,19 @@ $$(BUILDDIR)/stdlib/$1.debug.image: $$($1_SRCS) $$(addsuffix .debug.image,$$(add
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
 	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.compilecache(Base.identify_package("$1"))')
 	touch $$@
+endif
+ifneq ($(filter $(1),$(PKG_EXTS)),)
+# This is weird. It set up for multiple Pkg exts because that suits the structure here better
+# but it hard codes the deps and `import REPL, Pkg`
+$$(BUILDDIR)/stdlib/REPLExt.release.image: $$(REPLExt_SRCS) $$(BUILDDIR)/stdlib/Pkg.release.image $$(BUILDDIR)/stdlib/REPL.release.image
+	@$$(call PRINT_JULIA, $$(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'using REPL; using Pkg')
+	@$$(call PRINT_JULIA, $$(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no -e 'using REPL; using Pkg')
+	touch $$@
+$$(BUILDDIR)/stdlib/REPLExt.debug.image: $$(REPLExt_SRCS) $(BUILDDIR)/stdlib/Pkg.debug.image $$(BUILDDIR)/stdlib/REPL.debug.image
+	@$$(call PRINT_JULIA, $$(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'using REPL; using Pkg')
+	@$$(call PRINT_JULIA, $$(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no -e 'using REPL; using Pkg')
+	touch $$@
+endif
 else
 ifneq ($(filter $(1),$(STDLIBS_WITHIN_SYSIMG)),)
 $$(BUILDDIR)/stdlib/$1.release.image:
@@ -130,6 +143,7 @@ $(eval $(call stdlib_builder,Pkg, Artifacts Dates Downloads FileWatching LibGit2
 
 # 7-depth packages
 $(eval $(call stdlib_builder,LazyArtifacts,Artifacts Pkg))
+$(eval $(call stdlib_builder,REPLExt,Pkg REPL))
 
 $(eval $(call stdlib_builder,SparseArrays,Libdl LinearAlgebra Random Serialization SuiteSparse_jll))
 $(eval $(call stdlib_builder,Statistics,LinearAlgebra SparseArrays))
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index fa41353d3e0a1..52524cb88083c 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = f3b81f1aac77acf08f5d847ead29ad0a228dec67
+PKG_SHA1 = 6dd0e7c9e99d578aa5477e2c78c91a161ce4c357
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index 39b09a55c6e30..f39aed51cebaf 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -1190,10 +1190,11 @@ function setup_interface(
                 pkgid = Base.PkgId(Base.UUID("44cfe95a-1eb2-52ea-b672-e2afdf69b78f"), "Pkg")
                 if Base.locate_package(pkgid) !== nothing # Only try load Pkg if we can find it
                     Pkg = Base.require(pkgid)
+                    REPLExt = Base.get_extension(Pkg, :REPLExt)
                     # Pkg should have loaded its REPL mode by now, let's find it so we can transition to it.
                     pkg_mode = nothing
                     for mode in repl.interface.modes
-                        if mode isa LineEdit.Prompt && mode.complete isa Pkg.REPLMode.PkgCompletionProvider
+                        if mode isa LineEdit.Prompt && mode.complete isa REPLExt.PkgCompletionProvider
                             pkg_mode = mode
                             break
                         end
diff --git a/stdlib/stdlib.mk b/stdlib/stdlib.mk
index 4b3b138b374f3..b23754f3a3cac 100644
--- a/stdlib/stdlib.mk
+++ b/stdlib/stdlib.mk
@@ -5,20 +5,28 @@ STDLIBS_WITHIN_SYSIMG := \
 INDEPENDENT_STDLIBS := \
 	ArgTools Base64 CRC32c Dates DelimitedFiles Distributed Downloads Future \
 	InteractiveUtils JuliaSyntaxHighlighting LazyArtifacts LibGit2 LibCURL Logging \
-    Markdown Mmap NetworkOptions Profile Printf Pkg REPL Serialization SharedArrays \
-    SparseArrays Statistics StyledStrings SuiteSparse_jll Tar Test TOML Unicode UUIDs \
+	Markdown Mmap NetworkOptions Profile Printf Pkg REPL Serialization SharedArrays \
+	SparseArrays Statistics StyledStrings SuiteSparse_jll Tar Test TOML Unicode UUIDs \
 	dSFMT_jll GMP_jll libLLVM_jll LLD_jll LLVMLibUnwind_jll LibUnwind_jll LibUV_jll \
 	LibCURL_jll LibSSH2_jll LibGit2_jll nghttp2_jll  MozillaCACerts_jll MbedTLS_jll \
 	MPFR_jll OpenLibm_jll PCRE2_jll p7zip_jll Zlib_jll
 
+PKG_EXTS := \
+	REPLExt
 
-STDLIBS := $(STDLIBS_WITHIN_SYSIMG) $(INDEPENDENT_STDLIBS)
+STDLIBS := $(STDLIBS_WITHIN_SYSIMG) $(INDEPENDENT_STDLIBS) $(PKG_EXTS)
 VERSDIR := v$(shell cut -d. -f1-2 < $(JULIAHOME)/VERSION)
 
 SYSIMG_STDLIB_SRCS =
 define STDLIB_srcs
-$1_SRCS := $$(shell find $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/$1/src -name \*.jl) \
+ifneq ($(filter $(1),$(PKG_EXTS)),)
+	$1_SRCS := $$(shell find $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/Pkg/ext/$1 -name \*.jl) \
+	$$(wildcard $$(build_prefix)/manifest/$$(VERSDIR)/Pkg) $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/Pkg/Project.toml
+else
+	$1_SRCS := $$(shell find $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/$1/src -name \*.jl) \
 	$$(wildcard $$(build_prefix)/manifest/$$(VERSDIR)/$1) $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/$1/Project.toml
+endif
+
 ifneq ($(filter $(1),$(STDLIBS_WITHIN_SYSIMG)),)
 	SYSIMG_STDLIB_SRCS += $$($1_SRCS)
 endif

From 815cfd597bfbb37794116aea0c776ff1bb9ab7c1 Mon Sep 17 00:00:00 2001
From: Richie Wilynnton <90733565+RichieWilynnton@users.noreply.github.com>
Date: Thu, 8 Feb 2024 20:13:23 +0800
Subject: [PATCH 0846/1315] Added documentation to libdl module (#52825)

Part of #52725

---------

Co-authored-by: RichieWilynnton <richiewilynton@gmail.com>
Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: inky <git@wo-class.cn>
Co-authored-by: Max Horn <max@quendi.de>
---
 stdlib/Libdl/docs/src/index.md | 4 ++++
 stdlib/Libdl/src/Libdl.jl      | 7 ++++++-
 stdlib/Libdl/test/runtests.jl  | 4 +---
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/stdlib/Libdl/docs/src/index.md b/stdlib/Libdl/docs/src/index.md
index 608562cfb410d..2d7ef2fffc41a 100644
--- a/stdlib/Libdl/docs/src/index.md
+++ b/stdlib/Libdl/docs/src/index.md
@@ -2,6 +2,10 @@
 EditURL = "https://github.com/JuliaLang/julia/blob/master/stdlib/Libdl/docs/src/index.md"
 ```
 
+```@docs
+Libdl
+```
+
 # Dynamic Linker
 
 ```@docs
diff --git a/stdlib/Libdl/src/Libdl.jl b/stdlib/Libdl/src/Libdl.jl
index 0df70ea1daac5..2a8f800c69194 100644
--- a/stdlib/Libdl/src/Libdl.jl
+++ b/stdlib/Libdl/src/Libdl.jl
@@ -1,5 +1,10 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
-
+"""
+The Libdl module in Julia provides specialized and lower-level facilities for dynamic linking with shared libraries. While Julia
+inherently supports linking to runtime shared libraries through the `ccall` intrinsic, `Libdl` extends this capability by offering additional, more
+granular control. It enables users to search for shared libraries both in memory and the filesystem, manually load them with specific runtime linker options, and look up
+library symbols as low-level pointers.
+"""
 module Libdl
 # Just re-export Base.Libc.Libdl:
 export DL_LOAD_PATH, RTLD_DEEPBIND, RTLD_FIRST, RTLD_GLOBAL, RTLD_LAZY, RTLD_LOCAL,
diff --git a/stdlib/Libdl/test/runtests.jl b/stdlib/Libdl/test/runtests.jl
index cbff36c870fe7..ef7b8abf83337 100644
--- a/stdlib/Libdl/test/runtests.jl
+++ b/stdlib/Libdl/test/runtests.jl
@@ -331,7 +331,5 @@ end
 end; end
 
 @testset "Docstrings" begin
-    undoc = Docs.undocumented_names(Libdl)
-    @test_broken isempty(undoc)
-    @test undoc == [:Libdl]
+    @test isempty(Docs.undocumented_names(Libdl))
 end

From 2b939f7829e4d33acfbabc969545968fa7953c87 Mon Sep 17 00:00:00 2001
From: Christian Guinard <28689358+christiangnrd@users.noreply.github.com>
Date: Thu, 8 Feb 2024 08:26:11 -0400
Subject: [PATCH 0847/1315] Add Debian terminfo directory default to
 find_terminfo_file (#51809)

Without this, `Base.current_terminfo` returns `TermInfo(String[]; 0
flags, 0 numbers, 0 strings)` because it cannot find the correct
terminfo files. In the regular terminal, there was basic color and
formatting functionality because `$TERM`s starting with `xterm` are
treated specially, but in a tmux session, where the `$TERM =
tmux-256color`, there was no color at all.

This also has the side-effect of enabling strikethrough and italics in
the default gnome terminal emulator.

The readme found in `/etc/terminfo/README` (as mentioned in `terminfo(5)
"Fetching Compiled Descriptions"`) says the following:

```
/etc/terminfo/README
This directory is for system-local terminfo descriptions. By default,
ncurses will search ${HOME}/.terminfo first, then /etc/terminfo (this
directory), then /lib/terminfo, and last not least /usr/share/terminfo.
```

I believe the manual might be different depending on the distro.
---
 base/terminfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/terminfo.jl b/base/terminfo.jl
index 25648b2b477e8..b8cfef85df193 100644
--- a/base/terminfo.jl
+++ b/base/terminfo.jl
@@ -253,7 +253,7 @@ function find_terminfo_file(term::String)
                 replace(split(ENV["TERMINFO_DIRS"], ':'),
                         "" => "/usr/share/terminfo"))
     Sys.isunix() &&
-        push!(terminfo_dirs, "/etc/terminfo", "/usr/share/terminfo")
+        push!(terminfo_dirs, "/etc/terminfo", "/lib/terminfo", "/usr/share/terminfo")
     for dir in terminfo_dirs
         if isfile(joinpath(dir, chr, term))
             return joinpath(dir, chr, term)

From 667cdde78478234bfa8a3a2e78b4194afb06dbde Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 8 Feb 2024 21:39:13 +0900
Subject: [PATCH 0848/1315] compiler: fix the XXX test case in ssair.jl
 (#53245)

This should live in test/compiler/inline.jl instead.
---
 test/compiler/inline.jl | 8 ++++++++
 test/compiler/ssair.jl  | 7 -------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 71331fd30fb3a..d4c6659593fe6 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -1005,6 +1005,14 @@ end
         end |> only |> first
         @test count(iscall((src,UnionAll)), src.code) == 0
     end
+    # test >:
+    let src = code_typed((Any,Any)) do x, y
+            x >: y
+        end |> only |> first
+        idx = findfirst(iscall((src,<:)), src.code)
+        @test idx !== nothing
+        @test src.code[idx].args[2:3] == Any[#=y=#Argument(3), #=x=#Argument(2)]
+    end
 end
 
 # have_fma elimination inside ^
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index c640ee4f82f2b..bab11d3ead522 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -92,13 +92,6 @@ let cfg = CFG(BasicBlock[
     end
 end
 
-# test >:
-let
-    f(a, b) = a >: b
-    code_typed(f, Tuple{Any, Any})
-    # XXX: missing @test
-end
-
 for compile in ("min", "yes")
     cmd = `$(Base.julia_cmd()) --compile=$compile interpreter_exec.jl`
     if !success(pipeline(Cmd(cmd, dir=@__DIR__); stdout=stdout, stderr=stderr))

From 3dadada6298f189003a5a270438a69564022b8c7 Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Thu, 8 Feb 2024 13:53:28 +0100
Subject: [PATCH 0849/1315] Allow using an unexported custom `AbstractTestSet`
 in `@testset` (#53212)

Co-authored-by: Sukera <Seelengrab@users.noreply.github.com>
---
 stdlib/Test/src/Test.jl      |  3 ++-
 stdlib/Test/test/runtests.jl | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/stdlib/Test/src/Test.jl b/stdlib/Test/src/Test.jl
index 9742975d7c464..25d7b0c3127ab 100644
--- a/stdlib/Test/src/Test.jl
+++ b/stdlib/Test/src/Test.jl
@@ -1731,7 +1731,8 @@ function parse_testset_args(args)
     options = :(Dict{Symbol, Any}())
     for arg in args
         # a standalone symbol is assumed to be the test set we should use
-        if isa(arg, Symbol)
+        # the same is true for a symbol that's not exported from a module
+        if isa(arg, Symbol) || Base.isexpr(arg, :.)
             testsettype = esc(arg)
         # a string is the description
         elseif isa(arg, AbstractString) || (isa(arg, Expr) && arg.head === :string)
diff --git a/stdlib/Test/test/runtests.jl b/stdlib/Test/test/runtests.jl
index 4f1077835c632..ecabe85250906 100644
--- a/stdlib/Test/test/runtests.jl
+++ b/stdlib/Test/test/runtests.jl
@@ -1586,3 +1586,21 @@ end
 @testset "Docstrings" begin
     @test isempty(Docs.undocumented_names(Test))
 end
+
+module CustomTestSetModule
+    using Test
+    struct CustomTestSet <: Test.AbstractTestSet
+        description::String
+    end
+    Test.record(::CustomTestSet, result) = result
+    Test.finish(cts::CustomTestSet) = cts
+end
+
+@testset "Unexported custom TestSet" begin
+    using .CustomTestSetModule
+    let res = @testset CustomTestSetModule.CustomTestSet begin
+                @test true
+            end
+        @test res isa CustomTestSetModule.CustomTestSet
+    end
+end

From 95df060cb8f841142709a8d034eea0b409e39a6f Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Thu, 8 Feb 2024 08:15:15 -0800
Subject: [PATCH 0850/1315] Qualify public, unexported bindings in REPL help
 (#52524)

Fixes #52472, which was caused by `names` being changed to also return
public, unexported symbols in #50105. Note that this restores previous
behavior. A case could be made to instead add the public, unexported
bindings as suggestions with the appropriate qualification.

Not entirely sure how to test this so I'd welcome any suggestions.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 stdlib/REPL/src/docview.jl          | 93 +++++++++++++++++++++++------
 stdlib/REPL/test/docview.jl         | 36 ++++++++++-
 stdlib/REPL/test/replcompletions.jl |  2 +-
 test/docs.jl                        |  2 +-
 4 files changed, 110 insertions(+), 23 deletions(-)

diff --git a/stdlib/REPL/src/docview.jl b/stdlib/REPL/src/docview.jl
index 1d5bd12cdda58..79cc6b48d2f4d 100644
--- a/stdlib/REPL/src/docview.jl
+++ b/stdlib/REPL/src/docview.jl
@@ -9,7 +9,7 @@ using Base.Docs: catdoc, modules, DocStr, Binding, MultiDoc, keywords, isfield,
 
 import Base.Docs: doc, formatdoc, parsedoc, apropos
 
-using Base: with_output_color, mapany
+using Base: with_output_color, mapany, isdeprecated, isexported
 
 import REPL
 
@@ -424,8 +424,31 @@ end
 
 # repl search and completions for help
 
+# This type is returned from `accessible` and denotes a binding that is accessible within
+# some context. It differs from `Base.Docs.Binding`, which is also used by the REPL, in
+# that it doesn't track the defining module for a symbol unless the symbol is public but
+# not exported, i.e. it's accessible but requires qualification. Using this type rather
+# than `Base.Docs.Binding` simplifies things considerably, partially because REPL searching
+# is based on `String`s, which this type stores, but `Base.Docs.Binding` stores a module
+# and symbol and does not have any notion of the context from which the binding is accessed.
+struct AccessibleBinding
+    source::Union{String,Nothing}
+    name::String
+end
+
+function AccessibleBinding(mod::Module, name::Symbol)
+    m = isexported(mod, name) ? nothing : String(nameof(mod))
+    return AccessibleBinding(m, String(name))
+end
+AccessibleBinding(name::Symbol) = AccessibleBinding(nothing, String(name))
+
+function Base.show(io::IO, b::AccessibleBinding)
+    b.source === nothing || print(io, b.source, '.')
+    print(io, b.name)
+end
 
 quote_spaces(x) = any(isspace, x) ? "'" * x * "'" : x
+quote_spaces(x::AccessibleBinding) = AccessibleBinding(x.source, quote_spaces(x.name))
 
 function repl_search(io::IO, s::Union{Symbol,String}, mod::Module)
     pre = "search:"
@@ -669,6 +692,9 @@ function matchinds(needle, haystack; acronym::Bool = false)
     return is
 end
 
+matchinds(needle, (; name)::AccessibleBinding; acronym::Bool=false) =
+    matchinds(needle, name; acronym)
+
 longer(x, y) = length(x) ≥ length(y) ? (x, true) : (y, false)
 
 bestmatch(needle, haystack) =
@@ -728,7 +754,17 @@ function fuzzyscore(needle::AbstractString, haystack::AbstractString)
     1 - (string_distance(needle, lena, haystack, lenb) / max(lena, lenb))
 end
 
-function fuzzysort(search::String, candidates::Vector{String})
+function fuzzyscore(needle::AbstractString, haystack::AccessibleBinding)
+    score = fuzzyscore(needle, haystack.name)
+    haystack.source === nothing && return score
+    # Apply a "penalty" of half an edit if the comparator binding is public but not
+    # exported so that exported/local names that exactly match the search query are
+    # listed first
+    penalty = 1 / (2 * max(length(needle), length(haystack.name)))
+    return max(score - penalty, 0)
+end
+
+function fuzzysort(search::String, candidates::Vector{AccessibleBinding})
     scores = map(cand -> fuzzyscore(search, cand), candidates)
     candidates[sortperm(scores)] |> reverse
 end
@@ -753,12 +789,14 @@ function levenshtein(s1, s2)
     return d[m+1, n+1]
 end
 
-function levsort(search::String, candidates::Vector{String})
-    scores = map(cand -> (Float64(levenshtein(search, cand)), -fuzzyscore(search, cand)), candidates)
+function levsort(search::String, candidates::Vector{AccessibleBinding})
+    scores = map(candidates) do cand
+        (Float64(levenshtein(search, cand.name)), -fuzzyscore(search, cand))
+    end
     candidates = candidates[sortperm(scores)]
     i = 0
     for outer i = 1:length(candidates)
-        levenshtein(search, candidates[i]) > 3 && break
+        levenshtein(search, candidates[i].name) > 3 && break
     end
     return candidates[1:i]
 end
@@ -776,24 +814,39 @@ function printmatch(io::IO, word, match)
     end
 end
 
+function printmatch(io::IO, word, match::AccessibleBinding)
+    match.source === nothing || print(io, match.source, '.')
+    printmatch(io, word, match.name)
+end
+
+function matchlength(x::AccessibleBinding)
+    n = length(x.name)
+    if x.source !== nothing
+        n += length(x.source) + 1  # the +1 is for the `.` separator
+    end
+    return n
+end
+matchlength(x) = length(x)
+
 function printmatches(io::IO, word, matches; cols::Int = _displaysize(io)[2])
     total = 0
     for match in matches
-        total + length(match) + 1 > cols && break
+        ml = matchlength(match)
+        total + ml + 1 > cols && break
         fuzzyscore(word, match) < 0.5 && break
         print(io, " ")
         printmatch(io, word, match)
-        total += length(match) + 1
+        total += ml + 1
     end
 end
 
 printmatches(args...; cols::Int = _displaysize(stdout)[2]) = printmatches(stdout, args..., cols = cols)
 
-function print_joined_cols(io::IO, ss::Vector{String}, delim = "", last = delim; cols::Int = _displaysize(io)[2])
+function print_joined_cols(io::IO, ss::Vector{AccessibleBinding}, delim = "", last = delim; cols::Int = _displaysize(io)[2])
     i = 0
     total = 0
     for outer i = 1:length(ss)
-        total += length(ss[i])
+        total += matchlength(ss[i])
         total + max(i-2,0)*length(delim) + (i>1 ? 1 : 0)*length(last) > cols && (i-=1; break)
     end
     join(io, ss[1:i], delim, last)
@@ -815,27 +868,31 @@ print_correction(word, mod::Module) = print_correction(stdout, word, mod)
 
 # Completion data
 
-
 moduleusings(mod) = ccall(:jl_module_usings, Any, (Any,), mod)
 
-filtervalid(names) = filter(x->!occursin(r"#", x), map(string, names))
-
-accessible(mod::Module) =
-    Symbol[filter!(s -> !Base.isdeprecated(mod, s), names(mod, all=true, imported=true));
-           map(names, moduleusings(mod))...;
-           collect(keys(Base.Docs.keywords))] |> unique |> filtervalid
+function accessible(mod::Module)
+    bindings = Set(AccessibleBinding(s) for s in names(mod; all=true, imported=true)
+                   if !isdeprecated(mod, s))
+    for used in moduleusings(mod)
+        union!(bindings, (AccessibleBinding(used, s) for s in names(used)
+                          if !isdeprecated(used, s)))
+    end
+    union!(bindings, (AccessibleBinding(k) for k in keys(Base.Docs.keywords)))
+    filter!(b -> !occursin('#', b.name), bindings)
+    return collect(bindings)
+end
 
 function doc_completions(name, mod::Module=Main)
     res = fuzzysort(name, accessible(mod))
 
     # to insert an entry like `raw""` for `"@raw_str"` in `res`
-    ms = match.(r"^@(.*?)_str$", res)
+    ms = map(c -> match(r"^@(.*?)_str$", c.name), res)
     idxs = findall(!isnothing, ms)
 
     # avoid messing up the order while inserting
     for i in reverse!(idxs)
         c = only((ms[i]::AbstractMatch).captures)
-        insert!(res, i, "$(c)\"\"")
+        insert!(res, i, AccessibleBinding(res[i].source, "$(c)\"\""))
     end
     res
 end
diff --git a/stdlib/REPL/test/docview.jl b/stdlib/REPL/test/docview.jl
index 897a69a9266ab..123ff820bc939 100644
--- a/stdlib/REPL/test/docview.jl
+++ b/stdlib/REPL/test/docview.jl
@@ -4,9 +4,9 @@ using Test
 import REPL, REPL.REPLCompletions
 import Markdown
 
-function get_help_io(input)
+function get_help_io(input, mod=Main)
     buf = IOBuffer()
-    eval(REPL.helpmode(buf, input))
+    eval(REPL.helpmode(buf, input, mod))
     String(take!(buf))
 end
 get_help_standard(input) = string(eval(REPL.helpmode(IOBuffer(), input)))
@@ -40,7 +40,7 @@ end
     symbols = "@" .* checks .* "_str"
     results = checks .* "\"\""
     for (i,r) in zip(symbols,results)
-        @test r ∈ REPL.doc_completions(i)
+        @test r ∈ string.(REPL.doc_completions(i))
     end
 end
 @testset "fuzzy score" begin
@@ -56,6 +56,13 @@ end
     # Unicode
     @test 1.0 > REPL.fuzzyscore("αkδψm", "αkδm") > 0.0
     @test 1.0 > REPL.fuzzyscore("αkδψm", "α") > 0.0
+
+    exact_match_export = REPL.fuzzyscore("thing", REPL.AccessibleBinding(:thing))
+    exact_match_public = REPL.fuzzyscore("thing", REPL.AccessibleBinding("A", "thing"))
+    inexact_match_export = REPL.fuzzyscore("thing", REPL.AccessibleBinding(:thang))
+    inexact_match_public = REPL.fuzzyscore("thing", REPL.AccessibleBinding("A", "thang"))
+    @test exact_match_export > exact_match_public > inexact_match_export > inexact_match_public
+    @test exact_match_export ≈ 1.0
 end
 
 @testset "Unicode doc lookup (#41589)" begin
@@ -135,3 +142,26 @@ end
 
 # Issue #51344, don't print "internal binding" warning for non-existent bindings.
 @test string(eval(REPL.helpmode("Base.no_such_symbol"))) == "No documentation found.\n\nBinding `Base.no_such_symbol` does not exist.\n"
+
+module TestSuggestPublic
+    export dingo
+    public dango
+    dingo(x) = x + 1
+    dango(x) = x = 2
+end
+using .TestSuggestPublic
+helplines(s) = map(strip, split(get_help_io(s, @__MODULE__), '\n'; keepempty=false))
+@testset "search lists public names" begin
+    lines = helplines("dango")
+    # Ensure that public names that exactly match the search query are listed first
+    # even if they aren't exported, as long as no exact exported/local match exists
+    @test startswith(lines[1], "search: TestSuggestPublic.dango dingo")
+    @test lines[2] == "Couldn't find dango"  # 🙈🍡
+    @test startswith(lines[3], "Perhaps you meant TestSuggestPublic.dango, dingo")
+end
+dango() = "🍡"
+@testset "search prioritizes exported names" begin
+    # Prioritize exported/local names if they exactly match
+    lines = helplines("dango")
+    @test startswith(lines[1], "search: dango TestSuggestPublic.dango dingo")
+end
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 22ef938002514..7fd36e3d147e6 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -8,7 +8,7 @@ using REPL
 @testset "Check symbols previously not shown by REPL.doc_completions()" begin
     symbols = ["?","=","[]","[","]","{}","{","}",";","","'","&&","||","julia","Julia","new","@var_str"]
     for i in symbols
-        @test i ∈ REPL.doc_completions(i, Main)
+        @test i ∈ string.(REPL.doc_completions(i, Main))
     end
 end
 
diff --git a/test/docs.jl b/test/docs.jl
index 4eab0dd36361d..36893b8614170 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -1465,7 +1465,7 @@ end
 end
 
 struct t_docs_abc end
-@test "t_docs_abc" in accessible(@__MODULE__)
+@test "t_docs_abc" in string.(accessible(@__MODULE__))
 
 # Call overloading issues #20087 and #44889
 """

From a0989f42b9bd0b46ec675748fca8f567ed4d13cb Mon Sep 17 00:00:00 2001
From: Shruti Dalvi <123170794+ShrutiRDalvi@users.noreply.github.com>
Date: Thu, 8 Feb 2024 21:55:54 +0530
Subject: [PATCH 0851/1315] Added tests for kron! for diagonal matrices 
 (#53184)

Co-authored-by: Jishnu Bhattacharya <jishnub.github@gmail.com>
---
 stdlib/LinearAlgebra/test/diagonal.jl | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 20d807c4b9c65..18abc6940eded 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -1266,4 +1266,15 @@ end
     @test copy(Diagonal(1:5)) === Diagonal(1:5)
 end
 
+@testset "kron! for Diagonal" begin
+    a = Diagonal([2,2])
+    b = Diagonal([1,1])
+    c = Diagonal([0,0,0,0])
+    kron!(c,b,a)
+    @test c == Diagonal([2,2,2,2])
+    c=Diagonal(Vector{Float64}(undef, 4))
+    kron!(c,a,b)
+    @test c == Diagonal([2,2,2,2])
+end
+
 end # module TestDiagonal

From dd83530d72ddcea67c76dc7671b913fb6298248e Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Thu, 8 Feb 2024 12:47:15 -0600
Subject: [PATCH 0852/1315] deps/csl: Use platform-dependent path separator
 (#52687)

When building julia from source in MSYS2, you need to use `;` as a path
separator, otherwise you won't be able to find the required DLLs!


## pr changes
- On win, use `;` as path separator
- Always search for DLLs in the `bin/` directory

### test steps
Clean csl first: `make -C deps/ USE_SYSTEM_CSL=1  clean-csl`

Before pr:
```sh
$ make -C deps/ USE_SYSTEM_CSL=1  install-csl
make: Entering directory '/d/jl/julia/deps'
make: [/d/jl/julia/deps/csl.mk:59: /d/jl/julia/usr/bin/libgfortran-3.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:60: /d/jl/julia/usr/bin/libgfortran-4.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:61: /d/jl/julia/usr/bin/libgfortran-5.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:64: /d/jl/julia/usr/bin/libquadmath-0.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:65: /d/jl/julia/usr/bin/libstdc++-6.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:66: /d/jl/julia/usr/bin/libssp-0.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:67: /d/jl/julia/usr/bin/libatomic-1.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:68: /d/jl/julia/usr/bin/libgomp-1.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:75: /d/jl/julia/usr/bin/libgcc_s_seh-1.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:86: /d/jl/julia/usr/bin/libwinpthread-1.dll] Error 1 (ignored)
make: Leaving directory '/d/jl/julia/deps'
```

After pr:
```sh
$ make -C deps/ USE_SYSTEM_CSL=1  install-csl
make: Entering directory '/d/jl/julia/deps'
make: [/d/jl/julia/deps/csl.mk:59: /d/jl/julia/usr/bin/libgfortran-3.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:60: /d/jl/julia/usr/bin/libgfortran-4.dll] Error 1 (ignored)
make: [/d/jl/julia/deps/csl.mk:66: /d/jl/julia/usr/bin/libssp-0.dll] Error 1 (ignored)
make: Leaving directory '/d/jl/julia/deps'
```


## Env

- Win 11
- MSYS2

`STD_LIB_PATH`
```
$ uname -a
MINGW64_NT-10.0-22631 A309-Y9000P 3.4.10.x86_64 2023-11-30 06:09 UTC x86_64 Msys

$ make -C deps/  print-PATHSEP print-STD_LIB_PATH
make: Entering directory '/d/jl/julia/deps'
PATHSEP=;
STD_LIB_PATH=D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/;D:/env/msys64/mingw64/bin/../bin/gcc/;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/x86_64-w64-mingw32/13.2.0/;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/ ;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/;D:/env/msys64/mingw64/bin/../bin/gcc/;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/x86_64-w64-mingw32/13.2.0/;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/../bin/;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/../../../x86_64-w64-mingw32/13.2.0/;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/../../../../bin/;D:/a/msys64/mingw64/bin/x86_64-w64-mingw32/13.2.0/;D:/a/msys64/mingw64/bin/../bin/;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/;D:/env/msys64/mingw64/bin/../bin/gcc/x86_64-w64-mingw32/13.2.0/../../../;D:/a/msys64/mingw64/bin/
make: Leaving directory '/d/jl/julia/deps'
```
---
 deps/csl.mk | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/deps/csl.mk b/deps/csl.mk
index 1fb12ad394b12..fefe71a5e871c 100644
--- a/deps/csl.mk
+++ b/deps/csl.mk
@@ -1,13 +1,13 @@
 # Interrogate the fortran compiler (which is always GCC based) on where it is keeping its libraries
 STD_LIB_PATH := $(shell LANG=C $(FC) -print-search-dirs 2>/dev/null | grep '^programs: =' | sed -e "s/^programs: =//")
-STD_LIB_PATH += :$(shell LANG=C $(FC) -print-search-dirs 2>/dev/null | grep '^libraries: =' | sed -e "s/^libraries: =//")
-ifneq (,$(findstring CYGWIN,$(BUILD_OS))) # the cygwin-mingw32 compiler lies about it search directory paths
+STD_LIB_PATH += $(PATHSEP)$(shell LANG=C $(FC) -print-search-dirs 2>/dev/null | grep '^libraries: =' | sed -e "s/^libraries: =//")
+ifeq ($(BUILD_OS),WINNT)  # the mingw compiler lies about it search directory paths
 STD_LIB_PATH := $(shell echo '$(STD_LIB_PATH)' | sed -e "s!/lib/!/bin/!g")
 endif
 
 # Given a colon-separated list of paths in $(2), find the location of the library given in $(1)
 define pathsearch
-$(firstword $(wildcard $(addsuffix /$(1),$(subst :, ,$(2)))))
+$(firstword $(wildcard $(addsuffix /$(1),$(subst $(PATHSEP), ,$(2)))))
 endef
 
 # CSL bundles lots of system compiler libraries, and while it is quite bleeding-edge

From aba8afc95ac647af941342d084f43e6f19abe3e6 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Fri, 9 Feb 2024 04:35:32 +0800
Subject: [PATCH 0853/1315] Improve truecolor terminal capability detection
 (#53235)

Terminal color detection is a fickle beast, but it should behave as
expected more often with these changes.

Note to self: don't go "investigating" informal terminal standards again
if I value my time, or sanity.
---
 base/terminfo.jl | 50 ++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/base/terminfo.jl b/base/terminfo.jl
index b8cfef85df193..958fe459fb3d8 100644
--- a/base/terminfo.jl
+++ b/base/terminfo.jl
@@ -303,19 +303,49 @@ end
 
 Return a boolean signifying whether the current terminal supports 24-bit colors.
 
-This uses the `COLORTERM` environment variable if possible, returning true if it
-is set to either `"truecolor"` or `"24bit"`.
-
-As a fallback, first on unix systems the `colors` terminal capability is checked
-— should more than 256 colors be reported, this is taken to signify 24-bit
-support.
+Multiple conditions are taken as signifying truecolor support, specifically any of the following:
+- The `COLORTERM` environment variable is set to `"truecolor"` or `"24bit"`
+- The current terminfo sets the [`RGB`[^1]
+  capability](https://invisible-island.net/ncurses/man/user_caps.5.html#h3-Recognized-Capabilities)
+  (or the legacy `Tc` capability[^2]) flag
+- The current terminfo provides `setrgbf` and `setrgbb` strings[^3]
+- The current terminfo has a `colors` number greater that `256`, on a unix system
+- The VTE version is at least 3600 (detected via the `VTE_VERSION` environment variable)
+- The current terminal has the `XTERM_VERSION` environment variable set
+- The current terminal appears to be iTerm according to the `TERMINAL_PROGRAM` environment variable
+- The `TERM` environment variable corresponds to: linuxvt, rxvt, or st
+
+[^1]: Added to Ncurses 6.1, and used in `TERM=*-direct` terminfos.
+[^2]: Convention [added to tmux in 2016](https://github.com/tmux/tmux/commit/427b8204268af5548d09b830e101c59daa095df9),
+      superseded by `RGB`.
+[^3]: Proposed by [Rüdiger Sonderfeld in 2013](https://lists.gnu.org/archive/html/bug-ncurses/2013-10/msg00007.html),
+      adopted by a few terminal emulators.
+
+!!! note
+    The set of conditions is messy, because the situation is a mess, and there's
+    no resolution in sight. `COLORTERM` is widely accepted, but an imperfect
+    solution because only `TERM` is passed across `ssh` sessions. Terminfo is
+    the obvious place for a terminal to declare capabilities, but it's taken
+    enough years for ncurses/terminfo to declare a standard capability (`RGB`)
+    that a number of other approaches have taken root. Furthermore, the official
+    `RGB` capability is *incompatible* with 256-color operation, and so is
+    unable to resolve the fragmentation in the terminal ecosystem.
 """
 function ttyhastruecolor()
+    # Lasciate ogne speranza, voi ch'intrate
     get(ENV, "COLORTERM", "") ∈ ("truecolor", "24bit") ||
-        @static if Sys.isunix()
-            get(current_terminfo, :colors, 0) > 256
-        else
-            false
+        get(current_terminfo, :RGB, false) || get(current_terminfo, :Tc, false) ||
+        (haskey(current_terminfo, :setrgbf) && haskey(current_terminfo, :setrgbb)) ||
+        @static if Sys.isunix() get(current_terminfo, :colors, 0) > 256 else false end ||
+        something(tryparse(Int, get(ENV, "VTE_VERSION", "")), 0) >= 3600 || # Per GNOME bug #685759 <https://bugzilla.gnome.org/show_bug.cgi?id=685759>
+        haskey(ENV, "XTERM_VERSION") ||
+        get(ENV, "TERMINAL_PROGRAM", "") == "iTerm.app" || # Why does Apple need to be special?
+        haskey(ENV, "KONSOLE_PROFILE_NAME") || # Per commentary in VT102Emulation.cpp
+        haskey(ENV, "KONSOLE_DBUS_SESSION") ||
+        let term = get(ENV, "TERM", "")
+            startswith(term, "linux") || # Linux 4.8+ supports true-colour SGR.
+                startswith(term, "rxvt") || # See <http://lists.schmorp.de/pipermail/rxvt-unicode/2016q2/002261.html>
+                startswith(term, "st") # From experimentation
         end
 end
 

From e50778520b4ec7db350607188dc18bc6c0719b94 Mon Sep 17 00:00:00 2001
From: Simon Etter <ettersi@users.noreply.github.com>
Date: Fri, 9 Feb 2024 06:30:27 +0800
Subject: [PATCH 0854/1315] Support escape expressions in @kwdef (#53230)

`@kwdef` currently does not handle escaped type names and default values
correctly. This makes it impossible to write a (correctly escaped) macro
that internally uses `@kwdef`:

```julia
julia> module M
       macro define_struct(name)
           quote
               @kwdef struct $(esc(name)) field::Int end
           end
       end
       end;

julia> @macroexpand M.@define_struct(Foo)
ERROR: Invalid usage of @kwdef
Stacktrace:
 [1] error(s::String)
   @ Base ./error.jl:35
 [2] var"@kwdef"(__source__::LineNumberNode, __module__::Module, expr::Any)
   @ Base ./util.jl:603
 [3] #macroexpand#66
   @ Base ./expr.jl:122 [inlined]
 [4] top-level scope
   @ REPL[5]:1
```

This PR patches `@kwdef` so various types of escaping are handled
correctly. Specifically, all of the following now works (see new test
case
[here](https://github.com/ettersi/julia/blob/adf7e20378ae7d0c3cf24a2cc3c815e560913b78/test/misc.jl#L1290-L1332)):

```julia
module KwdefWithEsc
    const Int1 = Int
    const val1 = 42
    macro define_struct()
        quote
            @kwdef struct $(esc(:Struct))
                a
                b = val1
                c::Int1
                d::Int1 = val1


                $(esc(quote
                    e
                    f = val2
                    g::Int2
                    h::Int2 = val2
                end))


                $(esc(:(i = val2)))
                $(esc(:(j::Int2)))
                $(esc(:(k::Int2 = val2)))


                l::$(esc(:Int2))
                m::$(esc(:Int2)) = val1


                n = $(esc(:val2))
                o::Int1 = $(esc(:val2))


                $(esc(:p))
                $(esc(:q)) = val1
                $(esc(:s))::Int1
                $(esc(:t))::Int1 = val1
            end
        end
    end
end


module KwdefWithEsc_TestModule
    using ..KwdefWithEsc
    const Int2 = Int
    const val2 = 42
    KwdefWithEsc.@define_struct()
end
```

---------

Co-authored-by: inky <git@wo-class.cn>
---
 base/docs/Docs.jl |  25 +---------
 base/meta.jl      |  41 +++++++++++++++++
 base/util.jl      | 113 ++++++++++++++++++++++------------------------
 test/misc.jl      |  45 ++++++++++++++++++
 4 files changed, 142 insertions(+), 82 deletions(-)

diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 7ddb556d40871..637a8e1a50bd9 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -60,7 +60,7 @@ function.
 
 include("bindings.jl")
 
-import .Base.Meta: quot, isexpr
+import .Base.Meta: quot, isexpr, unblock, unescape, uncurly
 import .Base: Callable, with_output_color
 using .Base: RefValue, mapany
 import ..CoreDocs: lazy_iterpolate
@@ -285,29 +285,6 @@ catdoc(xs...) = vcat(xs...)
 
 const keywords = Dict{Symbol, DocStr}()
 
-function unblock(@nospecialize ex)
-    while isexpr(ex, :var"hygienic-scope")
-        isexpr(ex.args[1], :escape) || break
-        ex = ex.args[1].args[1]
-    end
-    isexpr(ex, :block) || return ex
-    exs = filter(ex -> !(isa(ex, LineNumberNode) || isexpr(ex, :line)), ex.args)
-    length(exs) == 1 || return ex
-    return unblock(exs[1])
-end
-
-# peek through ex to figure out what kind of expression it may eventually act like
-# but ignoring scopes and line numbers
-function unescape(@nospecialize ex)
-    ex = unblock(ex)
-    while isexpr(ex, :escape) || isexpr(ex, :var"hygienic-scope")
-       ex = unblock(ex.args[1])
-    end
-    return ex
-end
-
-uncurly(@nospecialize ex) = isexpr(ex, :curly) ? ex.args[1] : ex
-
 namify(@nospecialize x) = astname(x, isexpr(x, :macro))::Union{Symbol,Expr,GlobalRef}
 
 function astname(x::Expr, ismacro::Bool)
diff --git a/base/meta.jl b/base/meta.jl
index 545b1dbf5243b..bc07a7efa6c74 100644
--- a/base/meta.jl
+++ b/base/meta.jl
@@ -461,4 +461,45 @@ end
 
 _instantiate_type_in_env(x, spsig, spvals) = ccall(:jl_instantiate_type_in_env, Any, (Any, Any, Ptr{Any}), x, spsig, spvals)
 
+"""
+    Meta.unblock(expr)
+
+Peel away redundant block expressions.
+
+Specifically, the following expressions are stripped by this function:
+- `:block` expressions with a single non-line-number argument.
+- Pairs of `:var"hygienic-scope"` / `:escape` expressions.
+"""
+function unblock(@nospecialize ex)
+    while isexpr(ex, :var"hygienic-scope")
+        isexpr(ex.args[1], :escape) || break
+        ex = ex.args[1].args[1]
+    end
+    isexpr(ex, :block) || return ex
+    exs = filter(ex -> !(isa(ex, LineNumberNode) || isexpr(ex, :line)), ex.args)
+    length(exs) == 1 || return ex
+    return unblock(exs[1])
+end
+
+"""
+    Meta.unescape(expr)
+
+Peel away `:escape` expressions and redundant block expressions (see
+[`unblock`](@ref)).
+"""
+function unescape(@nospecialize ex)
+    ex = unblock(ex)
+    while isexpr(ex, :escape) || isexpr(ex, :var"hygienic-scope")
+       ex = unblock(ex.args[1])
+    end
+    return ex
+end
+
+"""
+    Meta.uncurly(expr)
+
+Turn `T{P...}` into just `T`.
+"""
+uncurly(@nospecialize ex) = isexpr(ex, :curly) ? ex.args[1] : ex
+
 end # module
diff --git a/base/util.jl b/base/util.jl
index 38e27520a39cc..199546bd2dea4 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -563,24 +563,31 @@ Stacktrace:
 macro kwdef(expr)
     expr = macroexpand(__module__, expr) # to expand @static
     isexpr(expr, :struct) || error("Invalid usage of @kwdef")
-    T = expr.args[2]
+    _, T, fieldsblock = expr.args
     if T isa Expr && T.head === :<:
         T = T.args[1]
     end
 
-    params_ex = Expr(:parameters)
-    call_args = Any[]
+    fieldnames = Any[]
+    defvals = Any[]
+    extract_names_and_defvals_from_kwdef_fieldblock!(fieldsblock, fieldnames, defvals)
+    parameters = map(fieldnames, defvals) do fieldname, defval
+        if isnothing(defval)
+            return fieldname
+        else
+            return Expr(:kw, fieldname, esc(defval))
+        end
+    end
 
-    _kwdef!(expr.args[3], params_ex.args, call_args)
     # Only define a constructor if the type has fields, otherwise we'll get a stack
     # overflow on construction
-    if !isempty(params_ex.args)
-        if T isa Symbol
-            sig = :(($(esc(T)))($params_ex))
-            call = :(($(esc(T)))($(call_args...)))
-            body = Expr(:block, __source__, call)
+    if !isempty(parameters)
+        T_no_esc = Meta.unescape(T)
+        if T_no_esc isa Symbol
+            sig = Expr(:call, esc(T), Expr(:parameters, parameters...))
+            body = Expr(:block, __source__, Expr(:call, esc(T), fieldnames...))
             kwdefs = Expr(:function, sig, body)
-        elseif isexpr(T, :curly)
+        elseif isexpr(T_no_esc, :curly)
             # if T == S{A<:AA,B<:BB}, define two methods
             #   S(...) = ...
             #   S{A,B}(...) where {A<:AA,B<:BB} = ...
@@ -588,11 +595,11 @@ macro kwdef(expr)
             P = T.args[2:end]
             Q = Any[isexpr(U, :<:) ? U.args[1] : U for U in P]
             SQ = :($S{$(Q...)})
-            body1 = Expr(:block, __source__, :(($(esc(S)))($(call_args...))))
-            sig1 = :(($(esc(S)))($params_ex))
+            body1 = Expr(:block, __source__, Expr(:call, esc(S), fieldnames...))
+            sig1 = Expr(:call, esc(S), Expr(:parameters, parameters...))
             def1 = Expr(:function, sig1, body1)
-            body2 = Expr(:block, __source__, :(($(esc(SQ)))($(call_args...))))
-            sig2 = :(($(esc(SQ)))($params_ex) where {$(esc.(P)...)})
+            body2 = Expr(:block, __source__, Expr(:call, esc(SQ), fieldnames...))
+            sig2 = :($(Expr(:call, esc(SQ), Expr(:parameters, parameters...))) where {$(esc.(P)...)})
             def2 = Expr(:function, sig2, body2)
             kwdefs = Expr(:block, def1, def2)
         else
@@ -609,54 +616,44 @@ end
 
 # @kwdef helper function
 # mutates arguments inplace
-function _kwdef!(blk, params_args, call_args)
-    for i in eachindex(blk.args)
-        ei = blk.args[i]
-        if ei isa Symbol
-            #  var
-            push!(params_args, ei)
-            push!(call_args, ei)
-        elseif ei isa Expr
-            is_atomic = ei.head === :atomic
-            ei = is_atomic ? first(ei.args) : ei # strip "@atomic" and add it back later
-            is_const = ei.head === :const
-            ei = is_const ? first(ei.args) : ei # strip "const" and add it back later
-            # Note: `@atomic const ..` isn't valid, but reconstruct it anyway to serve a nice error
-            if ei isa Symbol
-                # const var
-                push!(params_args, ei)
-                push!(call_args, ei)
-            elseif ei.head === :(=)
-                lhs = ei.args[1]
-                if lhs isa Symbol
-                    #  var = defexpr
-                    var = lhs
-                elseif lhs isa Expr && lhs.head === :(::) && lhs.args[1] isa Symbol
-                    #  var::T = defexpr
-                    var = lhs.args[1]
-                else
-                    # something else, e.g. inline inner constructor
-                    #   F(...) = ...
-                    continue
+function extract_names_and_defvals_from_kwdef_fieldblock!(block, names, defvals)
+    for (i, item) in pairs(block.args)
+        if isexpr(item, :block)
+            extract_names_and_defvals_from_kwdef_fieldblock!(item, names, defvals)
+        elseif item isa Expr && item.head in (:escape, :var"hygienic-scope")
+            n = length(names)
+            extract_names_and_defvals_from_kwdef_fieldblock!(item, names, defvals)
+            for j in n+1:length(defvals)
+                if !isnothing(defvals[j])
+                    defvals[j] = Expr(item.head, defvals[j])
                 end
-                defexpr = ei.args[2]  # defexpr
-                push!(params_args, Expr(:kw, var, esc(defexpr)))
-                push!(call_args, var)
-                lhs = is_const ? Expr(:const, lhs) : lhs
-                lhs = is_atomic ? Expr(:atomic, lhs) : lhs
-                blk.args[i] = lhs # overrides arg
-            elseif ei.head === :(::) && ei.args[1] isa Symbol
-                # var::Typ
-                var = ei.args[1]
-                push!(params_args, var)
-                push!(call_args, var)
-            elseif ei.head === :block
-                # can arise with use of @static inside type decl
-                _kwdef!(ei, params_args, call_args)
             end
+        else
+            def, name, defval = @something(def_name_defval_from_kwdef_fielddef(item), continue)
+            block.args[i] = def
+            push!(names, name)
+            push!(defvals, defval)
         end
     end
-    blk
+end
+
+function def_name_defval_from_kwdef_fielddef(kwdef)
+    if kwdef isa Symbol
+        return kwdef, kwdef, nothing
+    elseif isexpr(kwdef, :(::))
+        name, _ = kwdef.args
+        return kwdef, Meta.unescape(name), nothing
+    elseif isexpr(kwdef, :(=))
+        lhs, rhs = kwdef.args
+        def, name, _ = @something(def_name_defval_from_kwdef_fielddef(lhs), return nothing)
+        return def, name, rhs
+    elseif kwdef isa Expr && kwdef.head in (:const, :atomic)
+        def, name, defval = @something(def_name_defval_from_kwdef_fielddef(kwdef.args[1]), return nothing)
+        return Expr(kwdef.head, def), name, defval
+    elseif kwdef isa Expr && kwdef.head in (:escape, :var"hygienic-scope")
+        def, name, defval = @something(def_name_defval_from_kwdef_fielddef(kwdef.args[1]), return nothing)
+        return Expr(kwdef.head, def), name, isnothing(defval) ? defval : Expr(kwdef.head, defval)
+    end
 end
 
 # testing
diff --git a/test/misc.jl b/test/misc.jl
index e0961c538921a..d2a8fabd119c5 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1287,6 +1287,51 @@ end
     end
 end
 
+module KwdefWithEsc
+    const Int1 = Int
+    const val1 = 42
+    macro define_struct()
+        quote
+            @kwdef struct $(esc(:Struct))
+                a
+                b = val1
+                c::Int1
+                d::Int1 = val1
+
+                $(esc(quote
+                    e
+                    f = val2
+                    g::Int2
+                    h::Int2 = val2
+                end))
+
+                $(esc(:(i = val2)))
+                $(esc(:(j::Int2)))
+                $(esc(:(k::Int2 = val2)))
+
+                l::$(esc(:Int2))
+                m::$(esc(:Int2)) = val1
+
+                n = $(esc(:val2))
+                o::Int1 = $(esc(:val2))
+
+                $(esc(:p))
+                $(esc(:q)) = val1
+                $(esc(:s))::Int1
+                $(esc(:t))::Int1 = val1
+            end
+        end
+    end
+end
+
+module KwdefWithEsc_TestModule
+    using ..KwdefWithEsc
+    const Int2 = Int
+    const val2 = 42
+    KwdefWithEsc.@define_struct()
+end
+@test isdefined(KwdefWithEsc_TestModule, :Struct)
+
 @testset "exports of modules" begin
     for (_, mod) in Base.loaded_modules
         mod === Main && continue # Main exports everything

From 63e95d47e692352fac5541b6ee835b573f4c4898 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 9 Feb 2024 02:34:34 -0500
Subject: [PATCH 0855/1315] Add nested precomp highlight debug (#53111)

---
 base/loading.jl | 13 +++++++++++++
 pkgimage.mk     |  3 +++
 2 files changed, 16 insertions(+)

diff --git a/base/loading.jl b/base/loading.jl
index 34d1e848ecb98..d18d4e72ae809 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2508,6 +2508,7 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     # write data over stdin to avoid the (unlikely) case of exceeding max command line size
     write(io.in, """
         empty!(Base.EXT_DORMITORY) # If we have a custom sysimage with `EXT_DORMITORY` prepopulated
+        Base.track_nested_precomp($(vcat(Base.precompilation_stack, pkg)))
         Base.precompiling_extension = $(loading_extension)
         Base.include_package_for_output($(pkg_str(pkg)), $(repr(abspath(input))), $(repr(depot_path)), $(repr(dl_load_path)),
             $(repr(load_path)), $deps, $(repr(source_path(nothing))))
@@ -2516,6 +2517,18 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     return io
 end
 
+const precompilation_stack = Vector{PkgId}()
+# Helpful for debugging when precompilation is unexpectedly nested.
+# Enable with `JULIA_DEBUG=nested_precomp`. Note that it expected to be nested in classical code-load precompilation
+# TODO: Add detection if extension precompilation is nested and error / return early?
+function track_nested_precomp(pkgs::Vector{PkgId})
+    append!(precompilation_stack, pkgs)
+    if length(precompilation_stack) > 1
+        list() = join(map(p->p.name, precompilation_stack), " > ")
+        @debug "Nested precompilation: $(list())" _group=:nested_precomp
+    end
+end
+
 function compilecache_dir(pkg::PkgId)
     entrypath, entryfile = cache_file_entry(pkg)
     return joinpath(DEPOT_PATH[1], entrypath)
diff --git a/pkgimage.mk b/pkgimage.mk
index 9a46a8d581bf8..b45b4ab89560b 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -69,6 +69,9 @@ cache-debug-$1: $$(BUILDDIR)/stdlib/$1.debug.image
 .SECONDARY: $$(BUILDDIR)/stdlib/$1.release.image $$(BUILDDIR)/stdlib/$1.debug.image
 endef
 
+# Note: you can check for the correctness of this tree by running `JULIA_DEBUG=nested_precomp make` and looking
+# out for `Debug: Nested precompilation` logs.
+
 # no dependencies
 $(eval $(call stdlib_builder,MozillaCACerts_jll,))
 $(eval $(call stdlib_builder,ArgTools,))

From 27b31d188dd4f8bc690be7400a3442ea6246ac63 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 9 Feb 2024 16:26:32 +0530
Subject: [PATCH 0856/1315] Reroute algebraic functions for
 `Symmetric`/`Hermitian` through triangular (#52942)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This ensures that only the triangular indices are accessed for strided
parent matrices. Fix #52895

```julia
julia> M = Matrix{Complex{BigFloat}}(undef, 2, 2);

julia> M[1,1] = M[2,2] = M[1,2] = 2;

julia> H = Hermitian(M)
2×2 Hermitian{Complex{BigFloat}, Matrix{Complex{BigFloat}}}:
 2.0+0.0im  2.0+0.0im
 2.0-0.0im  2.0+0.0im

julia> H + H # works after this
2×2 Hermitian{Complex{BigFloat}, Matrix{Complex{BigFloat}}}:
 4.0+0.0im  4.0+0.0im
 4.0-0.0im  4.0+0.0im
```
This also provides a speed-up in several common cases (allocations
mentioned only when they differ):
```julia
julia> H = Hermitian(rand(ComplexF64,1000,1000));

julia> H2 = Hermitian(rand(ComplexF64,1000,1000),:L);
```
| Operation | master | PR |
| ---- | ---- | ---- |
|`-H` |2.247 ms | 1.384 ms |
| `real(H)` |1.544 ms |1.175 ms |
|`H + H` |2.288 ms |1.978 ms |
|`H + H2` |5.139 ms |3.287 ms |
| `isdiag(H)` |23.042 ns (1 allocation: 16 bytes) |16.778 ns (0
allocations: 0 bytes) |

I'm not entirely certain why `isdiag(H)` allocates on master, as union
splitting should handle this automatically, but manually splitting the
union appears to help.
---
 stdlib/LinearAlgebra/src/symmetric.jl  | 72 ++++++++++++++++----------
 stdlib/LinearAlgebra/test/symmetric.jl | 43 +++++++++++++++
 2 files changed, 88 insertions(+), 27 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index d0066ddecbfe0..21047dad8fcd9 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -269,10 +269,34 @@ end
     end
 end
 
+_conjugation(::Symmetric) = transpose
+_conjugation(::Hermitian) = adjoint
+
 diag(A::Symmetric) = symmetric.(diag(parent(A)), sym_uplo(A.uplo))
 diag(A::Hermitian) = hermitian.(diag(parent(A)), sym_uplo(A.uplo))
 
-isdiag(A::HermOrSym) = isdiag(A.uplo == 'U' ? UpperTriangular(A.data) : LowerTriangular(A.data))
+function applytri(f, A::HermOrSym)
+    if A.uplo == 'U'
+        f(UpperTriangular(A.data))
+    else
+        f(LowerTriangular(A.data))
+    end
+end
+
+function applytri(f, A::HermOrSym, B::HermOrSym)
+    if A.uplo == B.uplo == 'U'
+        f(UpperTriangular(A.data), UpperTriangular(B.data))
+    elseif A.uplo == B.uplo == 'L'
+        f(LowerTriangular(A.data), LowerTriangular(B.data))
+    elseif A.uplo == 'U'
+        f(UpperTriangular(A.data), UpperTriangular(_conjugation(B)(B.data)))
+    else # A.uplo == 'L'
+        f(UpperTriangular(_conjugation(A)(A.data)), UpperTriangular(B.data))
+    end
+end
+parentof_applytri(f, args...) = applytri(parent ∘ f, args...)
+
+isdiag(A::HermOrSym) = applytri(isdiag, A)
 
 # For A<:Union{Symmetric,Hermitian}, similar(A[, neweltype]) should yield a matrix with the same
 # symmetry type, uplo flag, and underlying storage type as A. The following methods cover these cases.
@@ -314,8 +338,8 @@ Hermitian{T,S}(A::Hermitian) where {T,S<:AbstractMatrix{T}} = Hermitian{T,S}(con
 AbstractMatrix{T}(A::Hermitian) where {T} = Hermitian(convert(AbstractMatrix{T}, A.data), sym_uplo(A.uplo))
 AbstractMatrix{T}(A::Hermitian{T}) where {T} = copy(A)
 
-copy(A::Symmetric{T,S}) where {T,S} = (B = copy(A.data); Symmetric{T,typeof(B)}(B,A.uplo))
-copy(A::Hermitian{T,S}) where {T,S} = (B = copy(A.data); Hermitian{T,typeof(B)}(B,A.uplo))
+copy(A::Symmetric) = (Symmetric(parentof_applytri(copy, A), sym_uplo(A.uplo)))
+copy(A::Hermitian) = (Hermitian(parentof_applytri(copy, A), sym_uplo(A.uplo)))
 
 function copyto!(dest::Symmetric, src::Symmetric)
     if src.uplo == dest.uplo
@@ -389,9 +413,9 @@ transpose(A::Hermitian) = Transpose(A)
 
 real(A::Symmetric{<:Real}) = A
 real(A::Hermitian{<:Real}) = A
-real(A::Symmetric) = Symmetric(real(A.data), sym_uplo(A.uplo))
-real(A::Hermitian) = Hermitian(real(A.data), sym_uplo(A.uplo))
-imag(A::Symmetric) = Symmetric(imag(A.data), sym_uplo(A.uplo))
+real(A::Symmetric) = Symmetric(parentof_applytri(real, A), sym_uplo(A.uplo))
+real(A::Hermitian) = Hermitian(parentof_applytri(real, A), sym_uplo(A.uplo))
+imag(A::Symmetric) = Symmetric(parentof_applytri(imag, A), sym_uplo(A.uplo))
 
 Base.copy(A::Adjoint{<:Any,<:Symmetric}) =
     Symmetric(copy(adjoint(A.parent.data)), ifelse(A.parent.uplo == 'U', :L, :U))
@@ -401,8 +425,9 @@ Base.copy(A::Transpose{<:Any,<:Hermitian}) =
 tr(A::Symmetric) = tr(A.data) # to avoid AbstractMatrix fallback (incl. allocations)
 tr(A::Hermitian) = real(tr(A.data))
 
-Base.conj(A::HermOrSym) = typeof(A)(conj(A.data), A.uplo)
-Base.conj!(A::HermOrSym) = typeof(A)(conj!(A.data), A.uplo)
+Base.conj(A::Symmetric) = Symmetric(parentof_applytri(conj, A), sym_uplo(A.uplo))
+Base.conj(A::Hermitian) = Hermitian(parentof_applytri(conj, A), sym_uplo(A.uplo))
+Base.conj!(A::HermOrSym) = typeof(A)(parentof_applytri(conj!, A), A.uplo)
 
 # tril/triu
 function tril(A::Hermitian, k::Integer=0)
@@ -496,21 +521,14 @@ for (T, trans, real) in [(:Symmetric, :transpose, :identity), (:(Hermitian{<:Uni
     end
 end
 
-(-)(A::Symmetric) = Symmetric(-A.data, sym_uplo(A.uplo))
-(-)(A::Hermitian) = Hermitian(-A.data, sym_uplo(A.uplo))
+(-)(A::Symmetric) = Symmetric(parentof_applytri(-, A), sym_uplo(A.uplo))
+(-)(A::Hermitian) = Hermitian(parentof_applytri(-, A), sym_uplo(A.uplo))
 
 ## Addition/subtraction
-for f ∈ (:+, :-), (Wrapper, conjugation) ∈ ((:Hermitian, :adjoint), (:Symmetric, :transpose))
-    @eval begin
-        function $f(A::$Wrapper, B::$Wrapper)
-            if A.uplo == B.uplo
-                return $Wrapper($f(parent(A), parent(B)), sym_uplo(A.uplo))
-            elseif A.uplo == 'U'
-                return $Wrapper($f(parent(A), $conjugation(parent(B))), :U)
-            else
-                return $Wrapper($f($conjugation(parent(A)), parent(B)), :U)
-            end
-        end
+for f ∈ (:+, :-), Wrapper ∈ (:Hermitian, :Symmetric)
+    @eval function $f(A::$Wrapper, B::$Wrapper)
+        uplo = A.uplo == B.uplo ? sym_uplo(A.uplo) : (:U)
+        $Wrapper(parentof_applytri($f, A, B), uplo)
     end
 end
 
@@ -555,12 +573,12 @@ function dot(x::AbstractVector, A::RealHermSymComplexHerm, y::AbstractVector)
 end
 
 # Scaling with Number
-*(A::Symmetric, x::Number) = Symmetric(A.data*x, sym_uplo(A.uplo))
-*(x::Number, A::Symmetric) = Symmetric(x*A.data, sym_uplo(A.uplo))
-*(A::Hermitian, x::Real) = Hermitian(A.data*x, sym_uplo(A.uplo))
-*(x::Real, A::Hermitian) = Hermitian(x*A.data, sym_uplo(A.uplo))
-/(A::Symmetric, x::Number) = Symmetric(A.data/x, sym_uplo(A.uplo))
-/(A::Hermitian, x::Real) = Hermitian(A.data/x, sym_uplo(A.uplo))
+*(A::Symmetric, x::Number) = Symmetric(parentof_applytri(y -> y * x, A), sym_uplo(A.uplo))
+*(x::Number, A::Symmetric) = Symmetric(parentof_applytri(y -> x * y, A), sym_uplo(A.uplo))
+*(A::Hermitian, x::Real) = Hermitian(parentof_applytri(y -> y * x, A), sym_uplo(A.uplo))
+*(x::Real, A::Hermitian) = Hermitian(parentof_applytri(y -> x * y, A), sym_uplo(A.uplo))
+/(A::Symmetric, x::Number) = Symmetric(parentof_applytri(y -> y/x, A), sym_uplo(A.uplo))
+/(A::Hermitian, x::Real) = Hermitian(parentof_applytri(y -> y/x, A), sym_uplo(A.uplo))
 
 factorize(A::HermOrSym) = _factorize(A)
 function _factorize(A::HermOrSym{T}; check::Bool=true) where T
diff --git a/stdlib/LinearAlgebra/test/symmetric.jl b/stdlib/LinearAlgebra/test/symmetric.jl
index b3e0b7b560e7a..d3b24ccf78b0b 100644
--- a/stdlib/LinearAlgebra/test/symmetric.jl
+++ b/stdlib/LinearAlgebra/test/symmetric.jl
@@ -470,6 +470,42 @@ end
     end
 end
 
+@testset "non-isbits algebra" begin
+    for ST in (Symmetric, Hermitian), uplo in (:L, :U)
+        M = Matrix{Complex{BigFloat}}(undef,2,2)
+        M[1,1] = rand()
+        M[2,2] = rand()
+        M[1+(uplo==:L), 1+(uplo==:U)] = rand(ComplexF64)
+        S = ST(M, uplo)
+        MS = Matrix(S)
+        @test real(S) == real(MS)
+        @test imag(S) == imag(MS)
+        @test conj(S) == conj(MS)
+        @test conj!(copy(S)) == conj(MS)
+        @test -S == -MS
+        @test S + S == MS + MS
+        @test S - S == MS - MS
+        @test S*2 == 2*S == 2*MS
+        @test S/2 == MS/2
+    end
+    @testset "mixed uplo" begin
+        Mu = Matrix{Complex{BigFloat}}(undef,2,2)
+        Mu[1,1] = Mu[2,2] = 3
+        Mu[1,2] = 2 + 3im
+        Ml = Matrix{Complex{BigFloat}}(undef,2,2)
+        Ml[1,1] = Ml[2,2] = 4
+        Ml[2,1] = 4 + 5im
+        for ST in (Symmetric, Hermitian)
+            Su = ST(Mu, :U)
+            MSu = Matrix(Su)
+            Sl = ST(Ml, :L)
+            MSl = Matrix(Sl)
+            @test Su + Sl == Sl + Su == MSu + MSl
+            @test Su - Sl == -(Sl - Su) == MSu - MSl
+        end
+    end
+end
+
 # bug identified in PR #52318: dot products of quaternionic Hermitian matrices,
 # or any number type where conj(a)*conj(b) ≠ conj(a*b):
 @testset "dot Hermitian quaternion #52318" begin
@@ -932,4 +968,11 @@ end
     end
 end
 
+@testset "conj for immutable" begin
+    S = Symmetric(reshape((1:16)*im, 4, 4))
+    @test conj(S) == conj(Array(S))
+    H = Hermitian(reshape((1:16)*im, 4, 4))
+    @test conj(H) == conj(Array(H))
+end
+
 end # module TestSymmetric

From 36b7d3bed73a6e9419b5ebbb073e41252e2de028 Mon Sep 17 00:00:00 2001
From: Harmen Stoppels <me@harmenstoppels.nl>
Date: Fri, 9 Feb 2024 15:37:01 +0100
Subject: [PATCH 0857/1315] Add PGO+LTO Makefile (#45641)

Adds a convenient way to enable PGO+LTO on Julia and LLVM together:

1. `cd contrib/pgo-lto`
2. `make -j$(nproc) stage1`
3. `make clean-profiles`
4. `./stage1.build/julia -O3 -e 'using Pkg;
Pkg.add("LoopVectorization"); Pkg.test("LoopVectorization")'`
5. `make -j$(nproc) stage2`

<details>
<summary>* Output looks roughly like as follows</summary>

```c++
$ make -C contrib/pgo-lto top
make: Entering directory '/dev/shm/julia/contrib/pgo-lto'
llvm-profdata show --topn=50 /dev/shm/julia/contrib/pgo-lto/profiles/merged.prof | c++filt
Instrumentation level: IR  entry_first = 0
Total functions: 85943
Maximum function count: 7867557260
Maximum internal block count: 3468437590
Top 50 functions with the largest internal block counts:
  llvm::BitVector::operator|=(llvm::BitVector const&), max count = 7867557260
  LateLowerGCFrame::ComputeLiveness(State&), max count = 3468437590
  llvm::hashing::detail::hash_combine_recursive_helper::hash_combine_recursive_helper(), max count = 1742259834
  llvm::SUnit::addPred(llvm::SDep const&, bool), max count = 511396575
  llvm::LiveRange::overlaps(llvm::LiveRange const&, llvm::CoalescerPair const&, llvm::SlotIndexes const&) const, max count = 508061762
  llvm::StringMapImpl::LookupBucketFor(llvm::StringRef), max count = 505682177
  std::map<llvm::BasicBlock*, BBState, std::less<llvm::BasicBlock*>, std::allocator<std::pair<llvm::BasicBlock* const, BBState> > >::operator[](llvm::BasicBlock* const&), max count = 395628888
  llvm::LiveRange::advanceTo(llvm::LiveRange::Segment const*, llvm::SlotIndex) const, max count = 384642728
  llvm::LiveRange::isLiveAtIndexes(llvm::ArrayRef<llvm::SlotIndex>) const, max count = 380291040
  llvm::PassRegistry::enumerateWith(llvm::PassRegistrationListener*), max count = 352313953
  ijl_method_instance_add_backedge, max count = 349608221
  llvm::SUnit::ComputeHeight(), max count = 336604330
  llvm::LiveRange::advanceTo(llvm::LiveRange::Segment*, llvm::SlotIndex), max count = 331030109
  llvm::SmallPtrSetImplBase::insert_imp(void const*), max count = 272966545
  llvm::LiveIntervals::checkRegMaskInterference(llvm::LiveInterval&, llvm::BitVector&), max count = 257449540
  LateLowerGCFrame::ComputeLiveSets(State&), max count = 252096274
  /dev/shm/julia/src/jltypes.c:has_free_typevars, max count = 230879464
  ijl_get_pgcstack, max count = 216953592
  LateLowerGCFrame::RefineLiveSet(llvm::BitVector&, State&, std::vector<int, std::allocator<int> > const&), max count = 188013152
  /dev/shm/julia/src/flisp/flisp.c:apply_cl, max count = 174863813
  /dev/shm/julia/src/flisp/builtins.c:fl_memq, max count = 168621603
```
</details>


This results quite often in spectacular speedups for time to first X as
it reduces the time spent in LLVM optimization passes by 25 or even 30%.

Example 1:

```julia
using LoopVectorization
function f!(a, b)
    @turbo for i in eachindex(a)
        a[i] *= b[i]
    end
    return a
end
f!(rand(1), rand(1))
```

```console
$ time ./julia -O3 lv.jl
```

Without PGO+LTO: 14.801s
With PGO+LTO: 11.978s (-19%)

Example 2:

```console
$ time ./julia -e 'using Pkg; Pkg.test("Unitful");'
```

Without PGO+LTO: 1m47.688s
With PGO+LTO: 1m35.704s (-11%)

Example 3 (taken from issue #45395, which is almost only LLVM):

```console
$ JULIA_LLVM_ARGS=-time-passes ./julia script-45395.jl
```

Without PGO+LTO:

```
===-------------------------------------------------------------------------===
                      ... Pass execution timing report ...
===-------------------------------------------------------------------------===
  Total Execution Time: 101.0130 seconds (98.6253 wall clock)

   ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
  53.6961 ( 54.7%)   0.1050 (  3.8%)  53.8012 ( 53.3%)  53.8045 ( 54.6%)  Unroll loops
  25.5423 ( 26.0%)   0.0072 (  0.3%)  25.5495 ( 25.3%)  25.5444 ( 25.9%)  Global Value Numbering
   7.1995 (  7.3%)   0.0526 (  1.9%)   7.2521 (  7.2%)   7.2517 (  7.4%)  Induction Variable Simplification
   6.0541 (  5.1%)   0.0098 (  0.3%)   5.0639 (  5.0%)   5.0561 (  5.1%)  Combine redundant instructions #2
```

With PGO+LTO:

```
===-------------------------------------------------------------------------===
                      ... Pass execution timing report ...
===-------------------------------------------------------------------------===
  Total Execution Time: 72.6507 seconds (70.1337 wall clock)

   ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
  36.0894 ( 51.7%)   0.0825 (  2.9%)  36.1719 ( 49.8%)  36.1738 ( 51.6%)  Unroll loops
  16.5713 ( 23.7%)   0.0129 (  0.5%)  16.5843 ( 22.8%)  16.5794 ( 23.6%)  Global Value Numbering
   5.9047 (  8.5%)   0.0395 (  1.4%)   5.9442 (  8.2%)   5.9438 (  8.5%)  Induction Variable Simplification
   4.7566 (  6.8%)   0.0078 (  0.3%)   4.7645 (  6.6%)   4.7575 (  6.8%)  Combine redundant instructions #2
```

Or -28% time spent in LLVM.

`perf` reports show this is mostly fewer instructions and reduction in
icache misses.

---

Finally there's a significant reduction in binary sizes. For libLLVM.so:

```
79M	usr/lib/libLLVM-13jl.so (before)
67M	usr/lib/libLLVM-13jl.so (after)
```

And it can be reduced by another 2MB with `--icf=safe` when using LLD as
a linker anyways.

- [x] Two out-of-source builds would be better than a single in-source
build, so that it's easier to find good profile data

---------

Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 contrib/pgo-lto/.gitignore |  4 ++
 contrib/pgo-lto/Makefile   | 80 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+)
 create mode 100644 contrib/pgo-lto/.gitignore
 create mode 100644 contrib/pgo-lto/Makefile

diff --git a/contrib/pgo-lto/.gitignore b/contrib/pgo-lto/.gitignore
new file mode 100644
index 0000000000000..978d8f2ca86dd
--- /dev/null
+++ b/contrib/pgo-lto/.gitignore
@@ -0,0 +1,4 @@
+profiles
+stage0*
+stage1*
+stage2*
diff --git a/contrib/pgo-lto/Makefile b/contrib/pgo-lto/Makefile
new file mode 100644
index 0000000000000..a73825e182561
--- /dev/null
+++ b/contrib/pgo-lto/Makefile
@@ -0,0 +1,80 @@
+.PHONY: top clean clean-profiles
+
+STAGE0_BUILD:=$(CURDIR)/stage0.build
+STAGE1_BUILD:=$(CURDIR)/stage1.build
+STAGE2_BUILD:=$(CURDIR)/stage2.build
+
+STAGE0_TOOLS:=$(STAGE0_BUILD)/usr/tools/
+
+PROFILE_DIR:=$(CURDIR)/profiles
+PROFILE_FILE:=$(PROFILE_DIR)/merged.prof
+PROFRAW_FILES:=$(wildcard $(PROFILE_DIR)/*.profraw)
+JULIA_ROOT:=$(CURDIR)/../..
+
+LLVM_CXXFILT:=$(STAGE0_TOOLS)llvm-cxxfilt
+LLVM_PROFDATA:=$(STAGE0_TOOLS)llvm-profdata
+LLVM_OBJCOPY:=$(STAGE0_TOOLS)llvm-objcopy
+
+# When building a single libLLVM.so we need to increase -vp-counters-per-site
+# significantly
+COUNTERS_PER_SITE:=6
+
+AFTER_STAGE1_MESSAGE:='Run `make clean-profiles` to start with a clean slate. $\
+    Then run Julia to collect realistic profile data, for example: `$(STAGE1_BUILD)/julia -O3 -e $\
+    '\''using Pkg; Pkg.add("LoopVectorization"); Pkg.test("LoopVectorization")'\''`. This $\
+	should produce about 15MB of data in $(PROFILE_DIR). Note that running extensive $\
+	scripts may result in counter overflows, which can be detected by running $\
+	`make top`. Afterwards run `make stage2`.'
+
+TOOLCHAIN_FLAGS = $\
+	"CC=$(STAGE0_TOOLS)clang" $\
+	"CXX=$(STAGE0_TOOLS)clang++" $\
+	"LD=$(STAGE0_TOOLS)ld.lld" $\
+	"AR=$(STAGE0_TOOLS)llvm-ar" $\
+	"RANLIB=$(STAGE0_TOOLS)llvm-ranlib" $\
+	"CFLAGS+=$(PGO_CFLAGS)" $\
+	"CXXFLAGS+=$(PGO_CXXFLAGS)" $\
+	"LDFLAGS+=$(PGO_LDFLAGS)"
+
+$(STAGE0_BUILD) $(STAGE1_BUILD) $(STAGE2_BUILD):
+	$(MAKE) -C $(JULIA_ROOT) O=$@ configure
+
+stage0: export USE_BINARYBUILDER_LLVM=1
+stage0: | $(STAGE0_BUILD)
+	# Turn [cd]tors into init/fini_array sections in libclang_rt, since lld
+	# doesn't do that, and otherwise the profile constructor is not executed
+	$(MAKE) -C $(STAGE0_BUILD)/deps install-clang install-llvm install-lld install-llvm-tools && \
+	find $< -name 'libclang_rt.profile-*.a' -exec $(LLVM_OBJCOPY) --rename-section .ctors=.init_array --rename-section .dtors=.fini_array {} + && \
+	touch $@
+
+$(STAGE1_BUILD): stage0
+stage1: PGO_CFLAGS:=-fprofile-generate=$(PROFILE_DIR) -Xclang -mllvm -Xclang -vp-counters-per-site=$(COUNTERS_PER_SITE)
+stage1: PGO_CXXFLAGS:=-fprofile-generate=$(PROFILE_DIR) -Xclang -mllvm -Xclang -vp-counters-per-site=$(COUNTERS_PER_SITE)
+stage1: PGO_LDFLAGS:=-fuse-ld=lld -flto=thin -fprofile-generate=$(PROFILE_DIR)
+stage1: export USE_BINARYBUILDER_LLVM=0
+stage1: | $(STAGE1_BUILD)
+	$(MAKE) -C $(STAGE1_BUILD) $(TOOLCHAIN_FLAGS) && touch $@
+	@echo $(AFTER_STAGE1_MESSAGE)
+
+stage2: PGO_CFLAGS:=-fprofile-use=$(PROFILE_FILE)
+stage2: PGO_CXXFLAGS:=-fprofile-use=$(PROFILE_FILE)
+stage2: PGO_LDFLAGS:=-fuse-ld=lld -flto=thin -fprofile-use=$(PROFILE_FILE) -Wl,--icf=safe
+stage2: export USE_BINARYBUILDER_LLVM=0
+stage2: $(PROFILE_FILE) | $(STAGE2_BUILD)
+	$(MAKE) -C $(STAGE2_BUILD) $(TOOLCHAIN_FLAGS) && touch $@
+
+install: stage2
+	$(MAKE) -C $(STAGE2_BUILD) USE_BINARYBUILDER_LLVM=0 install
+
+$(PROFILE_FILE): stage1 $(PROFRAW_FILES)
+	$(LLVM_PROFDATA) merge -output=$@ $(PROFRAW_FILES)
+
+# show top 50 functions
+top: $(PROFILE_FILE)
+	$(LLVM_PROFDATA) show --topn=50 $< | $(LLVM_CXXFILT)
+
+clean-profiles:
+	rm -rf $(PROFILE_DIR)
+
+clean:
+	rm -f stage0 stage1 stage2 $(PROFILE_FILE)

From daac6a68ca77b5a3ccdfafc992d87d7e2221fd50 Mon Sep 17 00:00:00 2001
From: Simon May <simon.may@protonmail.ch>
Date: Fri, 9 Feb 2024 15:13:33 +0000
Subject: [PATCH 0858/1315] doc: Rephrase some text referring to `DArray`
 (#53244)

Some parts of `distributed-computing.md` were somewhat unclear/confusing
after `DArray` was moved to `DistributedArrays.jl`.
---
 doc/src/manual/distributed-computing.md | 29 +++++++++++++++----------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/doc/src/manual/distributed-computing.md b/doc/src/manual/distributed-computing.md
index dd372ccbc53d4..e8a2146bdcf3e 100644
--- a/doc/src/manual/distributed-computing.md
+++ b/doc/src/manual/distributed-computing.md
@@ -813,16 +813,18 @@ will always operate on copies of arguments.
 
 ## [Shared Arrays](@id man-shared-arrays)
 
-Shared Arrays use system shared memory to map the same array across many processes. While there
-are some similarities to a [`DArray`](https://github.com/JuliaParallel/DistributedArrays.jl), the
-behavior of a [`SharedArray`](@ref) is quite different. In a [`DArray`](https://github.com/JuliaParallel/DistributedArrays.jl),
-each process has local access to just a chunk of the data, and no two processes share the same
-chunk; in contrast, in a [`SharedArray`](@ref) each "participating" process has access to the
-entire array.  A [`SharedArray`](@ref) is a good choice when you want to have a large amount of
-data jointly accessible to two or more processes on the same machine.
-
-Shared Array support is available via module `SharedArrays` which must be explicitly loaded on
-all participating workers.
+Shared Arrays use system shared memory to map the same array across many processes. A
+[`SharedArray`](@ref) is a good choice when you want to have a large amount of data jointly
+accessible to two or more processes on the same machine. Shared Array support is available via the
+module `SharedArrays`, which must be explicitly loaded on all participating workers.
+
+A complementary data structure is provided by the external package
+[`DistributedArrays.jl`](https://github.com/JuliaParallel/DistributedArrays.jl) in the form of a
+`DArray`. While there are some similarities to a [`SharedArray`](@ref), the behavior of a
+[`DArray`](https://github.com/JuliaParallel/DistributedArrays.jl) is quite different. In a
+[`SharedArray`](@ref), each "participating" process has access to the entire array; in contrast, in
+a [`DArray`](https://github.com/JuliaParallel/DistributedArrays.jl), each process has local access
+to just a chunk of the data, and no two processes share the same chunk.
 
 [`SharedArray`](@ref) indexing (assignment and accessing values) works just as with regular arrays,
 and is efficient because the underlying memory is available to the local process. Therefore,
@@ -1326,8 +1328,11 @@ in future releases.
 ## Noteworthy external packages
 
 Outside of Julia parallelism there are plenty of external packages that should be mentioned.
-For example [MPI.jl](https://github.com/JuliaParallel/MPI.jl) is a Julia wrapper for the `MPI` protocol, [Dagger.jl](https://github.com/JuliaParallel/Dagger.jl) provides functionality similar to Python's [Dask](https://dask.org/), and
-[DistributedArrays.jl](https://github.com/JuliaParallel/Distributedarrays.jl) provides array operations distributed across workers, as presented in [Shared Arrays](@ref).
+For example, [`MPI.jl`](https://github.com/JuliaParallel/MPI.jl) is a Julia wrapper for the `MPI`
+protocol, [`Dagger.jl`](https://github.com/JuliaParallel/Dagger.jl) provides functionality similar to
+Python's [Dask](https://dask.org/), and
+[`DistributedArrays.jl`](https://github.com/JuliaParallel/Distributedarrays.jl) provides array
+operations distributed across workers, as [outlined above](@ref man-shared-arrays).
 
 A mention must be made of Julia's GPU programming ecosystem, which includes:
 

From 65d4ce238badd337af91e6aebcba4e4a617e5743 Mon Sep 17 00:00:00 2001
From: Ben Baumgold <4933671+baumgold@users.noreply.github.com>
Date: Fri, 9 Feb 2024 10:14:44 -0500
Subject: [PATCH 0859/1315] implement convert from NamedTuple to Tuple (#49879)

See the discussion from Discourse:


https://discourse.julialang.org/t/construct-tuple-containing-namedtuple-from-tuple
---
 base/namedtuple.jl | 1 +
 test/namedtuple.jl | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/base/namedtuple.jl b/base/namedtuple.jl
index cc82edf3d3e3a..cbcade94f1c0d 100644
--- a/base/namedtuple.jl
+++ b/base/namedtuple.jl
@@ -182,6 +182,7 @@ nextind(@nospecialize(t::NamedTuple), i::Integer) = Int(i)+1
 
 convert(::Type{NT}, nt::NT) where {names, NT<:NamedTuple{names}} = nt
 convert(::Type{NT}, nt::NT) where {names, T<:Tuple, NT<:NamedTuple{names,T}} = nt
+convert(::Type{NT}, t::Tuple) where {NT<:NamedTuple} = NT(t)
 
 function convert(::Type{NamedTuple{names,T}}, nt::NamedTuple{names}) where {names,T<:Tuple}
     NamedTuple{names,T}(T(nt))::NamedTuple{names,T}
diff --git a/test/namedtuple.jl b/test/namedtuple.jl
index 0d9c6f420ced1..9c16d24b0c575 100644
--- a/test/namedtuple.jl
+++ b/test/namedtuple.jl
@@ -94,6 +94,9 @@ end
 
     conv_res = @test_throws MethodError convert(NamedTuple{(:a,),Tuple{I}} where I<:AbstractString, (;a=1))
     @test conv_res.value.f === convert && conv_res.value.args === (AbstractString, 1)
+
+    conv6 = convert(NamedTuple{(:a,),Tuple{NamedTuple{(:b,), Tuple{Int}}}}, ((1,),))
+    @test conv6 === (a = (b = 1,),)
 end
 
 @test NamedTuple{(:a,:c)}((b=1,z=2,c=3,aa=4,a=5)) === (a=5, c=3)

From 95233619745ef84c96af82299b162aa008a7debd Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Fri, 9 Feb 2024 16:18:03 +0100
Subject: [PATCH 0860/1315] Document & expose printing of custom
 `AbstractTestSet` (#53215)

This was previously alluded to in the docs as being possible ("just
record if we're not the top-level parent"), but trying to do that didn't
actually do anything because the printing in the `DefaultTestSet`
ignored anything that wasn't a `Test.Result` or `Test.DefaultTestSet`.
This is particularly problematic if any of the child-testsets had
failures, because those failures would never be shown to a user.

Co-authored-by: Sukera <Seelengrab@users.noreply.github.com>
Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
---
 stdlib/Test/docs/src/index.md |  45 ++++++-
 stdlib/Test/src/Test.jl       | 236 ++++++++++++++++++++++++----------
 stdlib/Test/test/runtests.jl  | 116 ++++++++++++++++-
 test/testdefs.jl              |   6 +-
 4 files changed, 328 insertions(+), 75 deletions(-)

diff --git a/stdlib/Test/docs/src/index.md b/stdlib/Test/docs/src/index.md
index 3241ff13ca029..e68efdfb6ebf5 100644
--- a/stdlib/Test/docs/src/index.md
+++ b/stdlib/Test/docs/src/index.md
@@ -322,8 +322,12 @@ function finish(ts::CustomTestSet)
     # just record if we're not the top-level parent
     if get_testset_depth() > 0
         record(get_testset(), ts)
+        return ts
     end
-    ts
+
+    # so the results are printed if we are at the top level
+    Test.print_test_results(ts)
+    return ts
 end
 ```
 
@@ -338,6 +342,45 @@ And using that testset looks like:
 end
 ```
 
+In order to use a custom testset and have the recorded results printed as part of any outer default testset,
+also define `Test.get_test_counts`. This might look like so:
+
+```julia
+using Test: AbstractTestSet, Pass, Fail, Error, Broken, get_test_counts, TestCounts, format_duration
+
+function Test.get_test_counts(ts::CustomTestSet)
+    passes, fails, errors, broken = 0, 0, 0, 0
+    # cumulative results
+    c_passes, c_fails, c_errors, c_broken = 0, 0, 0, 0
+
+    for t in ts.results
+        # count up results
+        isa(t, Pass)   && (passes += 1)
+        isa(t, Fail)   && (fails  += 1)
+        isa(t, Error)  && (errors += 1)
+        isa(t, Broken) && (broken += 1)
+        # handle children
+        if isa(t, AbstractTestSet)
+            tc = get_test_counts(t)::TestCounts
+            c_passes += tc.passes + tc.cumulative_passes
+            c_fails  += tc.fails + tc.cumulative_fails
+            c_errors += tc.errors + tc.cumulative_errors
+            c_broken += tc.broken + tc.cumulative_broken
+        end
+    end
+    # get a duration, if we have one
+    duration = format_duration(ts)
+    return TestCounts(true, passes, fails, errors, broken, c_passes, c_fails, c_errors, c_broken, duration)
+end
+```
+
+```@docs
+Test.TestCounts
+Test.get_test_counts
+Test.format_duration
+Test.print_test_results
+```
+
 ## Test utilities
 
 ```@docs
diff --git a/stdlib/Test/src/Test.jl b/stdlib/Test/src/Test.jl
index 25d7b0c3127ab..ddd62ca9a10f8 100644
--- a/stdlib/Test/src/Test.jl
+++ b/stdlib/Test/src/Test.jl
@@ -1114,6 +1114,27 @@ function record(ts::DefaultTestSet, t::Union{Fail, Error}; print_result::Bool=TE
     return t
 end
 
+"""
+    print_verbose(::AbstractTestSet) -> Bool
+
+Whether printing involving this `AbstractTestSet` should be verbose or not.
+
+Defaults to `false`.
+"""
+function print_verbose end
+
+"""
+    results(::AbstractTestSet)
+
+Return an iterator of results aggregated by this `AbstractTestSet`, if any were recorded.
+
+Defaults to the empty tuple.
+"""
+function results end
+
+print_verbose(ts::DefaultTestSet) = ts.verbose
+results(ts::DefaultTestSet) = ts.results
+
 # When a DefaultTestSet finishes, it records itself to its parent
 # testset, if there is one. This allows for recursive printing of
 # the results at the end of the tests
@@ -1121,26 +1142,42 @@ record(ts::DefaultTestSet, t::AbstractTestSet) = push!(ts.results, t)
 
 @specialize
 
-function print_test_errors(ts::DefaultTestSet)
-    for t in ts.results
+"""
+    print_test_errors(::AbstractTestSet)
+
+Prints the errors that were recorded by this `AbstractTestSet` after it
+was `finish`ed.
+"""
+function print_test_errors(ts::AbstractTestSet)
+    for t in results(ts)
         if isa(t, Error) || isa(t, Fail)
             println("Error in testset $(ts.description):")
             show(t)
             println()
-        elseif isa(t, DefaultTestSet)
+        elseif isa(t, AbstractTestSet)
             print_test_errors(t)
         end
     end
 end
 
-function print_test_results(ts::DefaultTestSet, depth_pad=0)
+"""
+    print_test_results(ts::AbstractTestSet, depth_pad=0)
+
+Print the results of an `AbstractTestSet` as a formatted table.
+
+`depth_pad` refers to how much padding should be added in front of all output.
+
+Called inside of `Test.finish`, if the `finish`ed testset is the topmost
+testset.
+"""
+function print_test_results(ts::AbstractTestSet, depth_pad=0)
     # Calculate the overall number for each type so each of
     # the test result types are aligned
-    passes, fails, errors, broken, c_passes, c_fails, c_errors, c_broken, duration = get_test_counts(ts)
-    total_pass   = passes + c_passes
-    total_fail   = fails  + c_fails
-    total_error  = errors + c_errors
-    total_broken = broken + c_broken
+    tc = get_test_counts(ts)
+    total_pass   = tc.passes + tc.cumulative_passes
+    total_fail   = tc.fails  + tc.cumulative_fails
+    total_error  = tc.errors + tc.cumulative_errors
+    total_broken = tc.broken + tc.cumulative_broken
     dig_pass   = total_pass   > 0 ? ndigits(total_pass)   : 0
     dig_fail   = total_fail   > 0 ? ndigits(total_fail)   : 0
     dig_error  = total_error  > 0 ? ndigits(total_error)  : 0
@@ -1153,14 +1190,13 @@ function print_test_results(ts::DefaultTestSet, depth_pad=0)
     fail_width   = dig_fail   > 0 ? max(length("Fail"),   dig_fail)   : 0
     error_width  = dig_error  > 0 ? max(length("Error"),  dig_error)  : 0
     broken_width = dig_broken > 0 ? max(length("Broken"), dig_broken) : 0
-    total_width  = dig_total  > 0 ? max(length("Total"),  dig_total)  : 0
-    duration_width = max(length("Time"), length(duration))
+    total_width  = max(textwidth("Total"),  dig_total)
+    duration_width = max(textwidth("Time"), textwidth(tc.duration))
     # Calculate the alignment of the test result counts by
     # recursively walking the tree of test sets
-    align = max(get_alignment(ts, 0), length("Test Summary:"))
+    align = max(get_alignment(ts, 0), textwidth("Test Summary:"))
     # Print the outer test set header once
-    pad = total == 0 ? "" : " "
-    printstyled(rpad("Test Summary:", align, " "), " |", pad; bold=true)
+    printstyled(rpad("Test Summary:", align, " "), " |", " "; bold=true)
     if pass_width > 0
         printstyled(lpad("Pass", pass_width, " "), "  "; bold=true, color=:green)
     end
@@ -1173,15 +1209,16 @@ function print_test_results(ts::DefaultTestSet, depth_pad=0)
     if broken_width > 0
         printstyled(lpad("Broken", broken_width, " "), "  "; bold=true, color=Base.warn_color())
     end
-    if total_width > 0
+    if total_width > 0 || total == 0
         printstyled(lpad("Total", total_width, " "), "  "; bold=true, color=Base.info_color())
     end
-    if ts.showtiming
+    timing = isdefined(ts, :showtiming) ? ts.showtiming : false
+    if timing
         printstyled(lpad("Time", duration_width, " "); bold=true)
     end
     println()
     # Recursively print a summary at every level
-    print_counts(ts, depth_pad, align, pass_width, fail_width, error_width, broken_width, total_width, duration_width, ts.showtiming)
+    print_counts(ts, depth_pad, align, pass_width, fail_width, error_width, broken_width, total_width, duration_width, timing)
 end
 
 
@@ -1199,11 +1236,11 @@ function finish(ts::DefaultTestSet; print_results::Bool=TESTSET_PRINT_ENABLE[])
         record(parent_ts, ts)
         return ts
     end
-    passes, fails, errors, broken, c_passes, c_fails, c_errors, c_broken, duration = get_test_counts(ts)
-    total_pass   = passes + c_passes
-    total_fail   = fails  + c_fails
-    total_error  = errors + c_errors
-    total_broken = broken + c_broken
+    tc = get_test_counts(ts)
+    total_pass   = tc.passes + tc.cumulative_passes
+    total_fail   = tc.fails  + tc.cumulative_fails
+    total_error  = tc.errors + tc.cumulative_errors
+    total_broken = tc.broken + tc.cumulative_broken
     total = total_pass + total_fail + total_error + total_broken
 
     if print_results
@@ -1253,100 +1290,165 @@ function filter_errors(ts::DefaultTestSet)
     efs
 end
 
-# Recursive function that counts the number of test results of each
-# type directly in the testset, and totals across the child testsets
+"""
+    TestCounts
+
+Holds the state for recursively gathering the results of a test set for display purposes.
+
+Fields:
+
+ * `customized`: Whether the function `get_test_counts` was customized for the `AbstractTestSet`
+                 this counts object is for. If a custom method was defined, always pass `true`
+                 to the constructor.
+ * `passes`: The number of passing `@test` invocations.
+ * `fails`: The number of failing `@test` invocations.
+ * `errors`: The number of erroring `@test` invocations.
+ * `broken`: The number of broken `@test` invocations.
+ * `passes`: The cumulative number of passing `@test` invocations.
+ * `fails`: The cumulative number of failing `@test` invocations.
+ * `errors`: The cumulative number of erroring `@test` invocations.
+ * `broken`: The cumulative number of broken `@test` invocations.
+ * `duration`: The total duration the `AbstractTestSet` in question ran for, as a formatted `String`.
+"""
+struct TestCounts
+    customized::Bool
+    passes::Int
+    fails::Int
+    errors::Int
+    broken::Int
+    cumulative_passes::Int
+    cumulative_fails::Int
+    cumulative_errors::Int
+    cumulative_broken::Int
+    duration::String
+end
+
+""""
+    get_test_counts(::AbstractTestSet) -> TestCounts
+
+Recursive function that counts the number of test results of each
+type directly in the testset, and totals across the child testsets.
+
+Custom `AbstractTestSet` should implement this function to get their totals
+counted & displayed with `DefaultTestSet` as well.
+
+If this is not implemented for a custom `TestSet`, the printing falls back to
+reporting `x` for failures and `?s` for the duration.
+"""
+function get_test_counts end
+
+get_test_counts(ts::AbstractTestSet) = TestCounts(false, 0,0,0,0,0,0,0,0, format_duration(ts))
+
 function get_test_counts(ts::DefaultTestSet)
     passes, fails, errors, broken = ts.n_passed, 0, 0, 0
+    # cumulative results
     c_passes, c_fails, c_errors, c_broken = 0, 0, 0, 0
     for t in ts.results
         isa(t, Fail)   && (fails  += 1)
         isa(t, Error)  && (errors += 1)
         isa(t, Broken) && (broken += 1)
-        if isa(t, DefaultTestSet)
-            np, nf, ne, nb, ncp, ncf, nce , ncb, duration = get_test_counts(t)
-            c_passes += np + ncp
-            c_fails  += nf + ncf
-            c_errors += ne + nce
-            c_broken += nb + ncb
+        if isa(t, AbstractTestSet)
+            tc = get_test_counts(t)::TestCounts
+            c_passes += tc.passes + tc.cumulative_passes
+            c_fails  += tc.fails + tc.cumulative_fails
+            c_errors += tc.errors + tc.cumulative_errors
+            c_broken += tc.broken + tc.cumulative_broken
         end
     end
+    duration = format_duration(ts)
     ts.anynonpass = (fails + errors + c_fails + c_errors > 0)
+    return TestCounts(true, passes, fails, errors, broken, c_passes, c_fails, c_errors, c_broken, duration)
+end
+
+"""
+    format_duration(::AbstractTestSet)
+
+Return a formatted string for printing the duration the testset ran for.
+
+If not defined, falls back to `"?s"`.
+"""
+format_duration(::AbstractTestSet) = "?s"
+
+function format_duration(ts::DefaultTestSet)
     (; time_start, time_end) = ts
-    duration = if isnothing(time_end)
-        ""
+    isnothing(time_end) && return ""
+
+    dur_s = time_end - time_start
+    if dur_s < 60
+        string(round(dur_s, digits = 1), "s")
     else
-        dur_s = time_end - time_start
-        if dur_s < 60
-            string(round(dur_s, digits = 1), "s")
-        else
-            m, s = divrem(dur_s, 60)
-            s = lpad(string(round(s, digits = 1)), 4, "0")
-            string(round(Int, m), "m", s, "s")
-        end
+        m, s = divrem(dur_s, 60)
+        s = lpad(string(round(s, digits = 1)), 4, "0")
+        string(round(Int, m), "m", s, "s")
     end
-    return passes, fails, errors, broken, c_passes, c_fails, c_errors, c_broken, duration
 end
 
+print_verbose(::AbstractTestSet) = false
+results(::AbstractTestSet) = ()
+
 # Recursive function that prints out the results at each level of
 # the tree of test sets
-function print_counts(ts::DefaultTestSet, depth, align,
+function print_counts(ts::AbstractTestSet, depth, align,
                       pass_width, fail_width, error_width, broken_width, total_width, duration_width, showtiming)
     # Count results by each type at this level, and recursively
     # through any child test sets
-    passes, fails, errors, broken, c_passes, c_fails, c_errors, c_broken, duration = get_test_counts(ts)
-    subtotal = passes + fails + errors + broken + c_passes + c_fails + c_errors + c_broken
+    tc = get_test_counts(ts)
+    fallbackstr = tc.customized ? " " : "x"
+    subtotal = tc.passes + tc.fails + tc.errors + tc.broken +
+               tc.cumulative_passes + tc.cumulative_fails + tc.cumulative_errors + tc.cumulative_broken
     # Print test set header, with an alignment that ensures all
     # the test results appear above each other
     print(rpad(string("  "^depth, ts.description), align, " "), " | ")
 
-    np = passes + c_passes
-    if np > 0
-        printstyled(lpad(string(np), pass_width, " "), "  ", color=:green)
+    n_passes = tc.passes + tc.cumulative_passes
+    if n_passes > 0
+        printstyled(lpad(string(n_passes), pass_width, " "), "  ", color=:green)
     elseif pass_width > 0
         # No passes at this level, but some at another level
-        print(lpad(" ", pass_width), "  ")
+        printstyled(lpad(fallbackstr, pass_width, " "), "  ", color=:green)
     end
 
-    nf = fails + c_fails
-    if nf > 0
-        printstyled(lpad(string(nf), fail_width, " "), "  ", color=Base.error_color())
+    n_fails = tc.fails + tc.cumulative_fails
+    if n_fails > 0
+        printstyled(lpad(string(n_fails), fail_width, " "), "  ", color=Base.error_color())
     elseif fail_width > 0
         # No fails at this level, but some at another level
-        print(lpad(" ", fail_width), "  ")
+        printstyled(lpad(fallbackstr, fail_width, " "), "  ", color=Base.error_color())
     end
 
-    ne = errors + c_errors
-    if ne > 0
-        printstyled(lpad(string(ne), error_width, " "), "  ", color=Base.error_color())
+    n_errors = tc.errors + tc.cumulative_errors
+    if n_errors > 0
+        printstyled(lpad(string(n_errors), error_width, " "), "  ", color=Base.error_color())
     elseif error_width > 0
         # No errors at this level, but some at another level
-        print(lpad(" ", error_width), "  ")
+        printstyled(lpad(fallbackstr, error_width, " "), "  ", color=Base.error_color())
     end
 
-    nb = broken + c_broken
-    if nb > 0
-        printstyled(lpad(string(nb), broken_width, " "), "  ", color=Base.warn_color())
+    n_broken = tc.broken + tc.cumulative_broken
+    if n_broken > 0
+        printstyled(lpad(string(n_broken), broken_width, " "), "  ", color=Base.warn_color())
     elseif broken_width > 0
         # None broken at this level, but some at another level
-        print(lpad(" ", broken_width), "  ")
+        printstyled(lpad(fallbackstr, broken_width, " "), "  ", color=Base.warn_color())
     end
 
-    if np == 0 && nf == 0 && ne == 0 && nb == 0
-        printstyled(lpad("None", total_width, " "), "  ", color=Base.info_color())
+    if n_passes == 0 && n_fails == 0 && n_errors == 0 && n_broken == 0
+        total_str = tc.customized ? string(subtotal) : "?"
+        printstyled(lpad(total_str, total_width, " "), "  ", color=Base.info_color())
     else
         printstyled(lpad(string(subtotal), total_width, " "), "  ", color=Base.info_color())
     end
 
     if showtiming
-        printstyled(lpad(string(duration), duration_width, " "))
+        printstyled(lpad(tc.duration, duration_width, " "))
     end
     println()
 
     # Only print results at lower levels if we had failures or if the user
-    # wants.
-    if (np + nb != subtotal) || (ts.verbose)
-        for t in ts.results
-            if isa(t, DefaultTestSet)
+    # wants. Requires the given `AbstractTestSet` to have a vector of results
+    if ((n_passes + n_broken != subtotal) || print_verbose(ts))
+        for t in results(ts)
+            if isa(t, AbstractTestSet)
                 print_counts(t, depth + 1, align,
                     pass_width, fail_width, error_width, broken_width, total_width, duration_width, ts.showtiming)
             end
diff --git a/stdlib/Test/test/runtests.jl b/stdlib/Test/test/runtests.jl
index ecabe85250906..460e2eadf42b7 100644
--- a/stdlib/Test/test/runtests.jl
+++ b/stdlib/Test/test/runtests.jl
@@ -468,11 +468,11 @@ end
     end
     @testset "ts results" begin
         @test isa(ts, Test.DefaultTestSet)
-        passes, fails, errors, broken, c_passes, c_fails, c_errors, c_broken = Test.get_test_counts(ts)
-        total_pass   = passes + c_passes
-        total_fail   = fails  + c_fails
-        total_error  = errors + c_errors
-        total_broken = broken + c_broken
+        tc = Test.get_test_counts(ts)
+        total_pass   = tc.passes + tc.cumulative_passes
+        total_fail   = tc.fails  + tc.cumulative_fails
+        total_error  = tc.errors + tc.cumulative_errors
+        total_broken = tc.broken + tc.cumulative_broken
         @test total_pass   == 24
         @test total_fail   == 6
         @test total_error  == 6
@@ -1604,3 +1604,109 @@ end
         @test res isa CustomTestSetModule.CustomTestSet
     end
 end
+
+struct CustomPrintingTestSet <: AbstractTestSet
+    description::String
+    passes::Int
+    errors::Int
+    fails::Int
+    broken::Int
+end
+
+function Test.finish(cpts::CustomPrintingTestSet)
+    if Test.get_testset_depth() != 0
+        push!(Test.get_current_testset(), cpts)
+        # printing is handled by the parent
+        return cpts
+    end
+
+    Test.print_testset_results(cpts)
+    cpts
+end
+
+@testset "Custom testsets participate in printing" begin
+    mktemp() do f, _
+        write(f,
+        """
+        using Test
+
+        mutable struct CustomPrintingTestSet <: Test.AbstractTestSet
+            description::String
+            passes::Int
+            fails::Int
+            errors::Int
+            broken::Int
+        end
+        CustomPrintingTestSet(desc::String) = CustomPrintingTestSet(desc, 0,0,0,0)
+
+        Test.record(cpts::CustomPrintingTestSet, ::Test.Pass) = cpts.passes += 1
+        Test.record(cpts::CustomPrintingTestSet, ::Test.Error) = cpts.errors += 1
+        Test.record(cpts::CustomPrintingTestSet, ::Test.Fail) = cpts.fails += 1
+        Test.record(cpts::CustomPrintingTestSet, ::Test.Broken) = cpts.broken += 1
+        Test.get_test_counts(ts::CustomPrintingTestSet) = Test.TestCounts(
+                                                                true,
+                                                                ts.passes,
+                                                                ts.fails,
+                                                                ts.errors,
+                                                                ts.broken,
+                                                                0,
+                                                                0,
+                                                                0,
+                                                                0,
+                                                                Test.format_duration(ts))
+
+        function Test.finish(cpts::CustomPrintingTestSet)
+            if Test.get_testset_depth() != 0
+                Test.record(Test.get_testset(), cpts)
+                # printing is handled by the parent
+                return cpts
+            end
+
+            Test.print_test_results(cpts)
+            cpts
+        end
+
+        struct NonRecordingTestSet <: Test.AbstractTestSet
+            description::String
+        end
+        Test.record(nrts::NonRecordingTestSet, ::Test.Result) = nrts
+        Test.finish(nrts::NonRecordingTestSet) = Test.record(Test.get_testset(), nrts)
+
+         @testset "outer" begin
+            @testset "a" begin
+                @test true
+            end
+            @testset CustomPrintingTestSet "custom" begin
+                @test false
+                @test true
+                @test_broken false
+                @test error()
+            end
+            @testset NonRecordingTestSet "no-record" begin
+                @test false
+                @test true
+                @test_broken false
+                @test error()
+            end
+            @testset "b" begin
+                @test true
+            end
+        end
+        """)
+
+        # this tests both the `TestCounts` parts as well as the fallback `x`s
+        expected = r"""
+                    Test Summary: | Pass  Fail  Error  Broken  Total  Time
+                    outer         |    3     1      1       1      6  \s*\d*.\ds
+                      a           |    1                           1  \s*\d*.\ds
+                      custom      |    1     1      1       1      4  \s*?s
+                      no-record   |    x     x      x       x      ?  \s*?s
+                      b           |    1                           1  \s*\d*.\ds
+                    ERROR: Some tests did not pass: 3 passed, 1 failed, 1 errored, 1 broken.
+                    """
+
+        cmd    = `$(Base.julia_cmd()) --startup-file=no --color=no $f`
+        result = read(pipeline(ignorestatus(cmd), stderr=devnull), String)
+        @test occursin(expected, result)
+    end
+end
diff --git a/test/testdefs.jl b/test/testdefs.jl
index e8f62858d1cbb..b96c95045f2bd 100644
--- a/test/testdefs.jl
+++ b/test/testdefs.jl
@@ -82,9 +82,11 @@ function runtests(name, path, isolate=true; seed=nothing)
         rss = Sys.maxrss()
         #res_and_time_data[1] is the testset
         ts = res_and_time_data[1]
-        passes, fails, errors, broken, c_passes, c_fails, c_errors, c_broken = Test.get_test_counts(ts)
+        tc = Test.get_test_counts(ts)
         # simplify our stored data to just contain the counts
-        res_and_time_data = (TestSetException(passes+c_passes, fails+c_fails, errors+c_errors, broken+c_broken, Test.filter_errors(ts)),
+        res_and_time_data = (TestSetException(tc.passes+tc.cumulative_passes, tc.fails+tc.cumulative_fails,
+                             tc.errors+tc.cumulative_errors, tc.broken+tc.cumulative_broken,
+                             Test.filter_errors(ts)),
                              res_and_time_data[2],
                              res_and_time_data[3],
                              res_and_time_data[4],

From f3d6904052118c628f0293602808729e41b2f158 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 9 Feb 2024 22:01:05 -0500
Subject: [PATCH 0861/1315] less jl_get_global reflection (#53250)

---
 base/filesystem.jl                    |   8 +-
 src/jl_exported_funcs.inc             |   5 -
 src/jl_uv.c                           |  19 ----
 src/jlapi.c                           |  49 ---------
 src/jsvm-emscripten/asyncify_setup.js | 144 --------------------------
 src/jsvm-emscripten/task.js           |  15 ---
 src/julia.h                           |   7 --
 src/julia_threads.h                   |  19 +---
 src/rtutils.c                         |  16 ---
 src/stackwalk.c                       |   2 -
 src/staticdata_utils.c                |  26 +++++
 src/task.c                            |  62 ++---------
 12 files changed, 40 insertions(+), 332 deletions(-)
 delete mode 100644 src/jsvm-emscripten/asyncify_setup.js
 delete mode 100644 src/jsvm-emscripten/task.js

diff --git a/base/filesystem.jl b/base/filesystem.jl
index d9760ec08a8a9..bb804392c49af 100644
--- a/base/filesystem.jl
+++ b/base/filesystem.jl
@@ -195,9 +195,13 @@ end
 
 function read(f::File, ::Type{UInt8})
     check_open(f)
-    ret = ccall(:jl_fs_read_byte, Int32, (OS_HANDLE,), f.handle)
+    p = Ref{UInt8}()
+    ret = ccall(:jl_fs_read, Int32, (OS_HANDLE, Ptr{Cvoid}, Csize_t),
+                f.handle, p, 1)
     uv_error("read", ret)
-    return ret % UInt8
+    @assert ret <= sizeof(p) == 1
+    ret < 1 && throw(EOFError())
+    return p[] % UInt8
 end
 
 function read(f::File, ::Type{Char})
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 138bde4a0830a..a72058f10f42d 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -112,7 +112,6 @@
     XX(jl_enter_handler) \
     XX(jl_enter_threaded_region) \
     XX(jl_environ) \
-    XX(jl_eof_error) \
     XX(jl_eqtable_get) \
     XX(jl_eqtable_pop) \
     XX(jl_eqtable_put) \
@@ -239,8 +238,6 @@
     XX(jl_method_lookup_by_tt) \
     XX(jl_method_lookup) \
     XX(jl_gf_invoke_lookup_worlds) \
-    XX(jl_git_branch) \
-    XX(jl_git_commit) \
     XX(jl_global_event_loop) \
     XX(jl_has_empty_intersection) \
     XX(jl_has_free_typevars) \
@@ -436,7 +433,6 @@
     XX(jl_stderr_obj) \
     XX(jl_stderr_stream) \
     XX(jl_stdin_stream) \
-    XX(jl_stdout_obj) \
     XX(jl_stdout_stream) \
     XX(jl_stored_inline) \
     XX(jl_string_ptr) \
@@ -516,7 +512,6 @@
     XX(jl_vprintf) \
     XX(jl_wakeup_thread) \
     XX(jl_write_compiler_output) \
-    XX(jl_yield) \
 
 #define JL_RUNTIME_EXPORTED_FUNCS_WIN(XX) \
     XX(jl_setjmp) \
diff --git a/src/jl_uv.c b/src/jl_uv.c
index dca08f5ddd91d..582484f78e181 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -662,25 +662,6 @@ JL_DLLEXPORT int jl_fs_read(uv_os_fd_t handle, char *data, size_t len)
     return ret;
 }
 
-JL_DLLEXPORT int jl_fs_read_byte(uv_os_fd_t handle)
-{
-    uv_fs_t req;
-    unsigned char c;
-    uv_buf_t buf[1];
-    buf[0].base = (char*)&c;
-    buf[0].len = 1;
-    int ret = uv_fs_read(unused_uv_loop_arg, &req, handle, buf, 1, -1, NULL);
-    uv_fs_req_cleanup(&req);
-    switch (ret) {
-    case -1: return ret;
-    case  0: jl_eof_error();
-    case  1: return (int)c;
-    default:
-        assert(0 && "jl_fs_read_byte: Invalid return value from uv_fs_read");
-        return -1;
-    }
-}
-
 JL_DLLEXPORT int jl_fs_close(uv_os_fd_t handle)
 {
     uv_fs_t req;
diff --git a/src/jlapi.c b/src/jlapi.c
index bde8b4f9f1245..276a792b2cd66 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -437,20 +437,6 @@ JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
     return v;
 }
 
-/**
- * @brief Yield to the Julia scheduler.
- *
- * Yields control to the Julia scheduler, allowing other Julia tasks to run.
- */
-JL_DLLEXPORT void jl_yield(void)
-{
-    static jl_function_t *yieldfunc = NULL;
-    if (yieldfunc == NULL)
-        yieldfunc = (jl_function_t*)jl_get_global(jl_base_module, jl_symbol("yield"));
-    if (yieldfunc != NULL)
-        jl_call0(yieldfunc);
-}
-
 /**
  * @brief Get a field from a Julia object.
  *
@@ -619,41 +605,6 @@ JL_DLLEXPORT const char *jl_ver_string(void)
    return JULIA_VERSION_STRING;
 }
 
-// return char* from String field in Base.GIT_VERSION_INFO
-static const char *git_info_string(const char *fld)
-{
-    static jl_value_t *GIT_VERSION_INFO = NULL;
-    if (!GIT_VERSION_INFO)
-        GIT_VERSION_INFO = jl_get_global(jl_base_module, jl_symbol("GIT_VERSION_INFO"));
-    jl_value_t *f = jl_get_field(GIT_VERSION_INFO, fld);
-    assert(jl_is_string(f));
-    return jl_string_data(f);
-}
-
-/**
- * @brief Get the name of the Git branch for the Julia build.
- *
- * @return A C string containing the name of the Git branch.
- */
-JL_DLLEXPORT const char *jl_git_branch(void)
-{
-    static const char *branch = NULL;
-    if (!branch) branch = git_info_string("branch");
-    return branch;
-}
-
-/**
- * @brief Get the Git commit hash for the Julia build.
- *
- * @return A C string containing the Git commit hash.
- */
-JL_DLLEXPORT const char *jl_git_commit(void)
-{
-    static const char *commit = NULL;
-    if (!commit) commit = git_info_string("commit");
-    return commit;
-}
-
 /**
  * @brief Convert a Julia value to a tagged value.
  *
diff --git a/src/jsvm-emscripten/asyncify_setup.js b/src/jsvm-emscripten/asyncify_setup.js
deleted file mode 100644
index 6783206602fd0..0000000000000
--- a/src/jsvm-emscripten/asyncify_setup.js
+++ /dev/null
@@ -1,144 +0,0 @@
-Module.preRun.push(function() {
-    if (typeof Asyncify !== "undefined") {
-        Asyncify.instrumentWasmExports = function (exports) { return exports; };
-        Asyncify.handleSleep = function (startAsync) {
-            if (ABORT) return;
-            Module['noExitRuntime'] = true;
-            if (Asyncify.state === Asyncify.State.Normal) {
-                // Prepare to sleep. Call startAsync, and see what happens:
-                // if the code decided to call our callback synchronously,
-                // then no async operation was in fact begun, and we don't
-                // need to do anything.
-                var reachedCallback = false;
-                var reachedAfterCallback = false;
-                var task = get_current_task();
-                startAsync(function(returnValue) {
-                assert(!returnValue || typeof returnValue === 'number'); // old emterpretify API supported other stuff
-                if (ABORT) return;
-                Asyncify.returnValue = returnValue || 0;
-                reachedCallback = true;
-                if (!reachedAfterCallback) {
-                    // We are happening synchronously, so no need for async.
-                    return;
-                }
-                schedule_and_wait(task);
-                });
-                reachedAfterCallback = true;
-                if (!reachedCallback) {
-                    Module['_jl_task_wait']();
-                }
-            } else if (Asyncify.state === Asyncify.State.Rewinding) {
-                // Stop a resume.
-                finish_schedule_task();
-            } else {
-                abort('invalid state: ' + Asyncify.state);
-            }
-            return Asyncify.returnValue;
-        };
-    }
-});
-
-function get_current_task() {
-    return Module['_jl_get_current_task']();
-}
-
-function get_root_task() {
-    return Module['_jl_get_root_task']();
-}
-
-function task_ctx_ptr(task) {
-    return Module["_task_ctx_ptr"](task);
-}
-
-function ctx_save(ctx) {
-    var stackPtr = stackSave();
-
-    // Save the bottom of the C stack in the task context. It simultaneously
-    // serves as the top of the asyncify stack.
-    HEAP32[ctx + 4 >> 2] = stackPtr;
-
-    Asyncify.state = Asyncify.State.Unwinding;
-    Module['_asyncify_start_unwind'](ctx);
-    if (Browser.mainLoop.func) {
-        Browser.mainLoop.pause();
-    }
-}
-
-function do_start_task(old_stack)
-{
-    try {
-        // start_task is always the entry point for any task
-        Module['_start_task']();
-    } catch(e) {
-        stackRestore(old_stack)
-        if (e !== e+0 && e !== 'killed') throw e;
-        maybe_schedule_next();
-        return;
-    }
-    // Either unwind or normal exit. In either case, we're back at the main task
-    if (Asyncify.state === Asyncify.State.Unwinding) {
-        // We just finished unwinding for a sleep.
-        Asyncify.state = Asyncify.State.Normal;
-        Module['_asyncify_stop_unwind']();
-    }
-    stackRestore(old_stack);
-    maybe_schedule_next();
-}
-
-function schedule_and_wait(task) {
-    Module['_jl_schedule_task'](task);
-    Module['_jl_task_wait']();
-}
-
-function finish_schedule_task() {
-    Asyncify.state = Asyncify.State.Normal;
-    Module['_asyncify_stop_rewind']();
-}
-
-next_ctx = 0;
-next_need_start = true;
-function set_next_ctx(ctx, needs_start) {
-    next_ctx = ctx;
-    next_need_start = needs_start;
-}
-
-function root_ctx() {
-    return task_ctx_ptr(get_root_task())
-}
-
-function ctx_switch(lastt_ctx) {
-    if (lastt_ctx == root_ctx()) {
-        // If we're in the root context, switch to
-        // the new ctx now, else we'll get there after
-        // unwinding.
-        return schedule_next()
-    } else if (lastt_ctx == 0) {
-        throw 'killed';
-    } else {
-        return ctx_save(lastt_ctx);
-    }
-}
-
-function schedule_next()
-{
-    old_stack = stackSave();
-    var next_task_stack = HEAP32[next_ctx + 4 >> 2];
-    if (!next_need_start) {
-        Asyncify.state = Asyncify.State.Rewinding;
-        Module['_asyncify_start_rewind'](next_ctx);
-        if (Browser.mainLoop.func) {
-            Browser.mainLoop.resume();
-        }
-    }
-    next_ctx = -1;
-    stackRestore(next_task_stack);
-    do_start_task(old_stack)
-}
-
-function maybe_schedule_next() {
-    assert(next_ctx != -1);
-    if (next_ctx == root_ctx() || next_ctx == 0) {
-        return;
-    }
-    schedule_next()
-}
diff --git a/src/jsvm-emscripten/task.js b/src/jsvm-emscripten/task.js
deleted file mode 100644
index ba695a5a40052..0000000000000
--- a/src/jsvm-emscripten/task.js
+++ /dev/null
@@ -1,15 +0,0 @@
-mergeInto(LibraryManager.library, {
-  jl_set_fiber: function(ctx) {
-    set_next_ctx(ctx, false);
-    return ctx_switch(0)
-  },
-  jl_swap_fiber: function(lastt_ctx, ctx) {
-    set_next_ctx(ctx, false);
-    return ctx_switch(lastt_ctx)
-  },
-  jl_start_fiber: function(lastt_ctx, ctx) {
-    set_next_ctx(ctx, true);
-    return ctx_switch(lastt_ctx)
-  }
-});
-
diff --git a/src/julia.h b/src/julia.h
index 7d143a3daa3fc..ee20641d17805 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -2003,7 +2003,6 @@ JL_DLLEXPORT void JL_NORETURN jl_bounds_error_tuple_int(jl_value_t **v,
 JL_DLLEXPORT void JL_NORETURN jl_bounds_error_unboxed_int(void *v, jl_value_t *vt, size_t i);
 JL_DLLEXPORT void JL_NORETURN jl_bounds_error_ints(jl_value_t *v JL_MAYBE_UNROOTED,
                                                    size_t *idxs, size_t nidxs);
-JL_DLLEXPORT void JL_NORETURN jl_eof_error(void);
 
 // Return the exception currently being handled, or `jl_nothing`.
 //
@@ -2173,9 +2172,6 @@ JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f JL_MAYBE_UNROOTED, jl_value_t
 JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f JL_MAYBE_UNROOTED, jl_value_t *a JL_MAYBE_UNROOTED,
                                   jl_value_t *b JL_MAYBE_UNROOTED, jl_value_t *c JL_MAYBE_UNROOTED);
 
-// interfacing with Task runtime
-JL_DLLEXPORT void jl_yield(void);
-
 // async signal handling ------------------------------------------------------
 
 JL_DLLEXPORT void jl_install_sigint_handler(void);
@@ -2409,7 +2405,6 @@ JL_DLLEXPORT int jl_termios_size(void);
 
 // showing and std streams
 JL_DLLEXPORT void jl_flush_cstdio(void) JL_NOTSAFEPOINT;
-JL_DLLEXPORT jl_value_t *jl_stdout_obj(void) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_stderr_obj(void) JL_NOTSAFEPOINT;
 JL_DLLEXPORT size_t jl_static_show(JL_STREAM *out, jl_value_t *v) JL_NOTSAFEPOINT;
 JL_DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type) JL_NOTSAFEPOINT;
@@ -2510,8 +2505,6 @@ JL_DLLEXPORT extern int jl_ver_minor(void);
 JL_DLLEXPORT extern int jl_ver_patch(void);
 JL_DLLEXPORT extern int jl_ver_is_release(void);
 JL_DLLEXPORT extern const char *jl_ver_string(void);
-JL_DLLEXPORT const char *jl_git_branch(void);
-JL_DLLEXPORT const char *jl_git_commit(void);
 
 // nullable struct representations
 typedef struct {
diff --git a/src/julia_threads.h b/src/julia_threads.h
index 292c11f61d60d..1c64a722850f2 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -30,7 +30,6 @@ JL_DLLEXPORT int8_t jl_threadpoolid(int16_t tid) JL_NOTSAFEPOINT;
 // JL_HAVE_ASM -- mostly setjmp
 // JL_HAVE_ASM && JL_HAVE_UNW_CONTEXT -- libunwind-based
 // JL_HAVE_UNW_CONTEXT -- libunwind-based
-// JL_HAVE_ASYNCIFY -- task switching based on the binary asyncify transform
 // JL_HAVE_UCONTEXT -- posix standard API, requires syscall for resume
 // JL_HAVE_SIGALTSTACK -- requires several syscall for start, setjmp for resume
 
@@ -45,8 +44,7 @@ typedef struct {
 #if !defined(JL_HAVE_UCONTEXT) && \
     !defined(JL_HAVE_ASM) && \
     !defined(JL_HAVE_UNW_CONTEXT) && \
-    !defined(JL_HAVE_SIGALTSTACK) && \
-    !defined(JL_HAVE_ASYNCIFY)
+    !defined(JL_HAVE_SIGALTSTACK)
 #if (defined(_CPU_X86_64_) || defined(_CPU_X86_) || defined(_CPU_AARCH64_) ||  \
      defined(_CPU_ARM_) || defined(_CPU_PPC64_))
 #define JL_HAVE_ASM
@@ -57,8 +55,6 @@ typedef struct {
 //#define JL_HAVE_UNW_CONTEXT
 //#elif defined(_OS_LINUX_)
 //#define JL_HAVE_UNW_CONTEXT
-#elif defined(_OS_EMSCRIPTEN_)
-#define JL_HAVE_ASYNCIFY
 #elif !defined(JL_HAVE_ASM)
 #define JL_HAVE_UNW_CONTEXT // optimistically?
 #endif
@@ -67,19 +63,6 @@ typedef struct {
 #if (!defined(JL_HAVE_UNW_CONTEXT) && defined(JL_HAVE_ASM)) || defined(JL_HAVE_SIGALTSTACK)
 typedef jl_stack_context_t _jl_ucontext_t;
 #endif
-#if defined(JL_HAVE_ASYNCIFY)
-#if defined(_COMPILER_TSAN_ENABLED_)
-#error TSAN not currently supported with asyncify
-#endif
-typedef struct {
-    // This is the extent of the asyncify stack, but because the top of the
-    // asyncify stack (stacktop) is also the bottom of the C stack, we can
-    // reuse stacktop for both. N.B.: This matches the layout of the
-    // __asyncify_data struct.
-    void *stackbottom;
-    void *stacktop;
-} _jl_ucontext_t;
-#endif
 #pragma GCC visibility push(default)
 #if defined(JL_HAVE_UNW_CONTEXT)
 #define UNW_LOCAL_ONLY
diff --git a/src/rtutils.c b/src/rtutils.c
index a4cfa28039805..1ab881e613564 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -219,14 +219,6 @@ JL_DLLEXPORT void JL_NORETURN jl_bounds_error_ints(jl_value_t *v JL_MAYBE_UNROOT
     jl_throw(jl_new_struct((jl_datatype_t*)jl_boundserror_type, v, t));
 }
 
-JL_DLLEXPORT void JL_NORETURN jl_eof_error(void)
-{
-    jl_datatype_t *eof_error =
-        (jl_datatype_t*)jl_get_global(jl_base_module, jl_symbol("EOFError"));
-    assert(eof_error != NULL);
-    jl_throw(jl_new_struct(eof_error));
-}
-
 JL_DLLEXPORT void jl_typeassert(jl_value_t *x, jl_value_t *t)
 {
     if (!jl_isa(x,t))
@@ -546,14 +538,6 @@ JL_DLLEXPORT void jl_flush_cstdio(void) JL_NOTSAFEPOINT
     fflush(stderr);
 }
 
-JL_DLLEXPORT jl_value_t *jl_stdout_obj(void) JL_NOTSAFEPOINT
-{
-    if (jl_base_module == NULL)
-        return NULL;
-    jl_binding_t *stdout_obj = jl_get_module_binding(jl_base_module, jl_symbol("stdout"), 0);
-    return stdout_obj ? jl_atomic_load_relaxed(&stdout_obj->value) : NULL;
-}
-
 JL_DLLEXPORT jl_value_t *jl_stderr_obj(void) JL_NOTSAFEPOINT
 {
     if (jl_base_module == NULL)
diff --git a/src/stackwalk.c b/src/stackwalk.c
index 6efb177927637..37f239609504e 100644
--- a/src/stackwalk.c
+++ b/src/stackwalk.c
@@ -1087,8 +1087,6 @@ static void jl_rec_backtrace(jl_task_t *t) JL_NOTSAFEPOINT
       #pragma message("jl_rec_backtrace not defined for ASM/SETJMP on unknown system")
       (void)c;
      #endif
-#elif defined(JL_HAVE_ASYNCIFY)
-     #pragma message("jl_rec_backtrace not defined for ASYNCIFY")
 #elif defined(JL_HAVE_SIGALTSTACK)
      #pragma message("jl_rec_backtrace not defined for SIGALTSTACK")
 #else
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index 199724e54ae00..aa39c53844a56 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -634,6 +634,32 @@ JL_DLLEXPORT uint8_t jl_match_cache_flags(uint8_t flags)
     return flags >= current_flags;
 }
 
+// return char* from String field in Base.GIT_VERSION_INFO
+static const char *git_info_string(const char *fld)
+{
+    static jl_value_t *GIT_VERSION_INFO = NULL;
+    if (!GIT_VERSION_INFO)
+        GIT_VERSION_INFO = jl_get_global(jl_base_module, jl_symbol("GIT_VERSION_INFO"));
+    jl_value_t *f = jl_get_field(GIT_VERSION_INFO, fld);
+    assert(jl_is_string(f));
+    return jl_string_data(f);
+}
+
+static const char *jl_git_branch(void)
+{
+    static const char *branch = NULL;
+    if (!branch) branch = git_info_string("branch");
+    return branch;
+}
+
+static const char *jl_git_commit(void)
+{
+    static const char *commit = NULL;
+    if (!commit) commit = git_info_string("commit");
+    return commit;
+}
+
+
 // "magic" string and version header of .ji file
 static const int JI_FORMAT_VERSION = 12;
 static const char JI_MAGIC[] = "\373jli\r\n\032\n"; // based on PNG signature
diff --git a/src/task.c b/src/task.c
index 8905b49e87f8e..4bf12250b7d2c 100644
--- a/src/task.c
+++ b/src/task.c
@@ -134,18 +134,11 @@ static inline void sanitizer_finish_switch_fiber(jl_task_t *last, jl_task_t *cur
 #define ROOT_TASK_STACK_ADJUSTMENT 3000000
 #endif
 
-#ifdef JL_HAVE_ASYNCIFY
-// Switching logic is implemented in JavaScript
-#define STATIC_OR_JS JL_DLLEXPORT
-#else
-#define STATIC_OR_JS static
-#endif
-
 static char *jl_alloc_fiber(_jl_ucontext_t *t, size_t *ssize, jl_task_t *owner) JL_NOTSAFEPOINT;
-STATIC_OR_JS void jl_set_fiber(jl_ucontext_t *t);
-STATIC_OR_JS void jl_swap_fiber(jl_ucontext_t *lastt, jl_ucontext_t *t);
-STATIC_OR_JS void jl_start_fiber_swap(jl_ucontext_t *savet, jl_ucontext_t *t);
-STATIC_OR_JS void jl_start_fiber_set(jl_ucontext_t *t);
+static void jl_set_fiber(jl_ucontext_t *t);
+static void jl_swap_fiber(jl_ucontext_t *lastt, jl_ucontext_t *t);
+static void jl_start_fiber_swap(jl_ucontext_t *savet, jl_ucontext_t *t);
+static void jl_start_fiber_set(jl_ucontext_t *t);
 
 #ifdef ALWAYS_COPY_STACKS
 # ifndef COPY_STACKS
@@ -1172,47 +1165,6 @@ JL_DLLEXPORT jl_task_t *jl_get_current_task(void)
     return pgcstack == NULL ? NULL : container_of(pgcstack, jl_task_t, gcstack);
 }
 
-
-#ifdef JL_HAVE_ASYNCIFY
-JL_DLLEXPORT jl_ucontext_t *task_ctx_ptr(jl_task_t *t)
-{
-    return &t->ctx.ctx;
-}
-
-JL_DLLEXPORT jl_value_t *jl_get_root_task(void)
-{
-    jl_task_t *ct = jl_current_task;
-    return (jl_value_t*)ct->ptls->root_task;
-}
-
-JL_DLLEXPORT void jl_task_wait()
-{
-    static jl_function_t *wait_func = NULL;
-    if (!wait_func) {
-        wait_func = (jl_function_t*)jl_get_global(jl_base_module, jl_symbol("wait"));
-    }
-    jl_task_t *ct = jl_current_task;
-    size_t last_age = ct->world_age;
-    ct->world_age = jl_get_world_counter();
-    jl_apply(&wait_func, 1);
-    ct->world_age = last_age;
-}
-
-JL_DLLEXPORT void jl_schedule_task(jl_task_t *task)
-{
-    static jl_function_t *sched_func = NULL;
-    if (!sched_func) {
-        sched_func = (jl_function_t*)jl_get_global(jl_base_module, jl_symbol("schedule"));
-    }
-    jl_task_t *ct = jl_current_task;
-    size_t last_age = ct->world_age;
-    ct->world_age = jl_get_world_counter();
-    jl_value_t *args[] = {(jl_value_t*)sched_func, (jl_value_t*)task};
-    jl_apply(args, 2);
-    ct->world_age = last_age;
-}
-#endif
-
 // Do one-time initializations for task system
 void jl_init_tasks(void) JL_GC_DISABLED
 {
@@ -1247,10 +1199,10 @@ void jl_init_tasks(void) JL_GC_DISABLED
 }
 
 #if defined(_COMPILER_ASAN_ENABLED_)
-STATIC_OR_JS void NOINLINE JL_NORETURN _start_task(void);
+static void NOINLINE JL_NORETURN _start_task(void);
 #endif
 
-STATIC_OR_JS void NOINLINE JL_NORETURN JL_NO_ASAN start_task(void)
+static void NOINLINE JL_NORETURN JL_NO_ASAN start_task(void)
 {
 CFI_NORETURN
 #if defined(_COMPILER_ASAN_ENABLED_)
@@ -1266,7 +1218,7 @@ CFI_NORETURN
     _start_task();
 }
 
-STATIC_OR_JS void NOINLINE JL_NORETURN _start_task(void)
+static void NOINLINE JL_NORETURN _start_task(void)
 {
 CFI_NORETURN
 #endif

From b43edb77a3d10d091faff221bd4248a52b25e008 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 9 Feb 2024 22:02:29 -0500
Subject: [PATCH 0862/1315] Updated MethodError to show closest candidates more
 reliably (#53165)

Updated version of #33793. Always show up to 3 methods, even if no
arguments types match on some of them, but rank ones with fewer
arguments before those with more arguments.

Closes #33793
Fixes #33793
Fixes #46236
Co-authored-by: Eric Wright <efwright@udel.edu>
(this diff best viewed with whitespace ignored)
---
 base/errorshow.jl              | 130 ++++++++++++++++-----------------
 doc/src/manual/constructors.md |   2 +
 doc/src/manual/methods.md      |   2 +
 test/errorshow.jl              |   9 ++-
 4 files changed, 76 insertions(+), 67 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index 74afc191fcc4d..f63c150336689 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -421,7 +421,8 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs=[])
     # functions methods and counting the number of matching arguments.
     f = ex.f
     ft = typeof(f)
-    lines = []
+    lines = String[]
+    line_score = Int[]
     # These functions are special cased to only show if first argument is matched.
     special = f === convert || f === getindex || f === setindex!
     funcs = Tuple{Any,Vector{Any}}[(f, arg_types_param)]
@@ -512,85 +513,82 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs=[])
                 end
             end
 
-            if right_matches > 0 || length(arg_types_param) < 2
-                if length(t_i) < length(sig)
-                    # If the methods args is longer than input then the method
-                    # arguments is printed as not a match
-                    for (k, sigtype) in enumerate(sig[length(t_i)+1:end])
-                        sigtype = isvarargtype(sigtype) ? unwrap_unionall(sigtype) : sigtype
-                        if Base.isvarargtype(sigtype)
-                            sigstr = (unwrapva(sigtype::Core.TypeofVararg), "...")
-                        else
-                            sigstr = (sigtype,)
-                        end
-                        if !((min(length(t_i), length(sig)) == 0) && k==1)
-                            print(iob, ", ")
-                        end
-                        if k == 1 && Base.isvarargtype(sigtype)
-                            # There wasn't actually a mismatch - the method match failed for
-                            # some other reason, e.g. world age. Just print the sigstr.
-                            print(iob, sigstr...)
-                        elseif get(io, :color, false)::Bool
-                            let sigstr=sigstr
-                                Base.with_output_color(Base.error_color(), iob) do iob
-                                    print(iob, "::", sigstr...)
-                                end
-                            end
-                        else
-                            print(iob, "!Matched::", sigstr...)
-                        end
+            if length(t_i) < length(sig)
+                # If the methods args is longer than input then the method
+                # arguments is printed as not a match
+                for (k, sigtype) in enumerate(sig[length(t_i)+1:end])
+                    sigtype = isvarargtype(sigtype) ? unwrap_unionall(sigtype) : sigtype
+                    if Base.isvarargtype(sigtype)
+                        sigstr = (unwrapva(sigtype::Core.TypeofVararg), "...")
+                    else
+                        sigstr = (sigtype,)
                     end
-                end
-                kwords = kwarg_decl(method)
-                if !isempty(kwords)
-                    print(iob, "; ")
-                    join(iob, kwords, ", ")
-                end
-                print(iob, ")")
-                show_method_params(iob0, tv)
-                file, line = updated_methodloc(method)
-                if file === nothing
-                    file = string(method.file)
-                end
-                stacktrace_contract_userdir() && (file = contractuser(file))
-
-                if !isempty(kwargs)::Bool
-                    unexpected = Symbol[]
-                    if isempty(kwords) || !(any(endswith(string(kword), "...") for kword in kwords))
-                        for (k, v) in kwargs
-                            if !(k::Symbol in kwords)
-                                push!(unexpected, k::Symbol)
+                    if !((min(length(t_i), length(sig)) == 0) && k==1)
+                        print(iob, ", ")
+                    end
+                    if k == 1 && Base.isvarargtype(sigtype)
+                        # There wasn't actually a mismatch - the method match failed for
+                        # some other reason, e.g. world age. Just print the sigstr.
+                        print(iob, sigstr...)
+                    elseif get(io, :color, false)::Bool
+                        let sigstr=sigstr
+                            Base.with_output_color(Base.error_color(), iob) do iob
+                                print(iob, "::", sigstr...)
                             end
                         end
+                    else
+                        print(iob, "!Matched::", sigstr...)
                     end
-                    if !isempty(unexpected)
-                        Base.with_output_color(Base.error_color(), iob) do iob
-                            plur = length(unexpected) > 1 ? "s" : ""
-                            print(iob, " got unsupported keyword argument$plur \"", join(unexpected, "\", \""), "\"")
+                end
+            end
+            kwords = kwarg_decl(method)
+            if !isempty(kwords)
+                print(iob, "; ")
+                join(iob, kwords, ", ")
+            end
+            print(iob, ")")
+            show_method_params(iob0, tv)
+            file, line = updated_methodloc(method)
+            if file === nothing
+                file = string(method.file)
+            end
+            stacktrace_contract_userdir() && (file = contractuser(file))
+
+            if !isempty(kwargs)::Bool
+                unexpected = Symbol[]
+                if isempty(kwords) || !(any(endswith(string(kword), "...") for kword in kwords))
+                    for (k, v) in kwargs
+                        if !(k::Symbol in kwords)
+                            push!(unexpected, k::Symbol)
                         end
                     end
                 end
-                if ex.world < reinterpret(UInt, method.primary_world)
-                    print(iob, " (method too new to be called from this world context.)")
-                elseif ex.world > reinterpret(UInt, method.deleted_world)
-                    print(iob, " (method deleted before this world age.)")
+                if !isempty(unexpected)
+                    Base.with_output_color(Base.error_color(), iob) do iob
+                        plur = length(unexpected) > 1 ? "s" : ""
+                        print(iob, " got unsupported keyword argument$plur \"", join(unexpected, "\", \""), "\"")
+                    end
                 end
-                println(iob)
-
-                m = parentmodule_before_main(method)
-                modulecolor = get!(() -> popfirst!(STACKTRACE_MODULECOLORS), STACKTRACE_FIXEDCOLORS, m)
-                print_module_path_file(iob, m, string(file), line; modulecolor, digit_align_width = 3)
-
-                # TODO: indicate if it's in the wrong world
-                push!(lines, (buf, right_matches))
             end
+            if ex.world < reinterpret(UInt, method.primary_world)
+                print(iob, " (method too new to be called from this world context.)")
+            elseif ex.world > reinterpret(UInt, method.deleted_world)
+                print(iob, " (method deleted before this world age.)")
+            end
+            println(iob)
+
+            m = parentmodule_before_main(method)
+            modulecolor = get!(() -> popfirst!(STACKTRACE_MODULECOLORS), STACKTRACE_FIXEDCOLORS, m)
+            print_module_path_file(iob, m, string(file), line; modulecolor, digit_align_width = 3)
+            push!(lines, String(take!(buf)))
+            push!(line_score, -(right_matches * 2 + (length(arg_types_param) < 2 ? 1 : 0)))
         end
     end
 
     if !isempty(lines) # Display up to three closest candidates
         Base.with_output_color(:normal, io) do io
             print(io, "\n\nClosest candidates are:")
-            sort!(lines, by = x -> -x[2])
+            permute!(lines, sortperm(line_score))
             i = 0
             for line in lines
                 println(io)
@@ -599,7 +597,7 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs=[])
                     break
                 end
                 i += 1
-                print(io, String(take!(line[1])))
+                print(io, line)
             end
             println(io) # extra newline for spacing to stacktrace
         end
diff --git a/doc/src/manual/constructors.md b/doc/src/manual/constructors.md
index 2cfa6e25503d2..f8b9dd9673082 100644
--- a/doc/src/manual/constructors.md
+++ b/doc/src/manual/constructors.md
@@ -379,6 +379,8 @@ The type `Point` exists, but no method is defined for this combination of argume
 Closest candidates are:
   Point(::T, !Matched::T) where T<:Real
    @ Main none:1
+  Point(!Matched::Int64, !Matched::Float64)
+   @ Main none:1
 
 Stacktrace:
 [...]
diff --git a/doc/src/manual/methods.md b/doc/src/manual/methods.md
index 4745ae886e8d0..6b90990a6dd7c 100644
--- a/doc/src/manual/methods.md
+++ b/doc/src/manual/methods.md
@@ -173,6 +173,8 @@ The function `f` exists, but no method is defined for this combination of argume
 Closest candidates are:
   f(!Matched::Number, ::Number)
    @ Main none:1
+  f(!Matched::Float64, !Matched::Float64)
+   @ Main none:1
 
 Stacktrace:
 [...]
diff --git a/test/errorshow.jl b/test/errorshow.jl
index a12224554fd11..932122682983e 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -78,8 +78,12 @@ Base.show_method_candidates(buf, Base.MethodError(method_c1,(1, "", "")))
 Base.show_method_candidates(buf, Base.MethodError(method_c1,(1., "", "")))
 @test occursin("\n\nClosest candidates are:\n  method_c1(::Float64, ::AbstractString...)$cmod$cfile$c1line\n", String(take!(buf)))
 
-# Have no matches so should return empty
+# Have no matches, but still print up to 3
 Base.show_method_candidates(buf, Base.MethodError(method_c1,(1, 1, 1)))
+@test occursin("\n\nClosest candidates are:\n  method_c1(!Matched::Float64, !Matched::AbstractString...)$cmod$cfile$c1line\n", String(take!(buf)))
+
+function nomethodsfunc end
+Base.show_method_candidates(buf, Base.MethodError(nomethodsfunc,(1, 1, 1)))
 @test isempty(String(take!(buf)))
 
 # matches the implicit constructor -> convert method
@@ -1161,3 +1165,6 @@ end
 # issue #47559"
 @test_throws("MethodError: no method matching invoke Returns(::Any, ::Val{N}) where N",
              invoke(Returns, Tuple{Any,Val{N}} where N, 1, Val(1)))
+
+f33793(x::Float32, y::Float32) = 1
+@test_throws "\nClosest candidates are:\n  f33793(!Matched::Float32, !Matched::Float32)\n" f33793(Float64(0.0), Float64(0.0))

From 5547305a7d571a9abc6119589689a64cc7c98da6 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 9 Feb 2024 22:03:26 -0500
Subject: [PATCH 0863/1315] Fix duplicate error when using generator in Dict
 (#53151)

Fixes: #33147
Replaces/Closes: #40445

The difference here, compared to past implementations, is that we use
the zero-cost `isiterable` check on every intermediate step, instead of
wrapping the call in a try/catch and then trying to re-approximate the
`isiterable` afterwards. Some samples:

```julia
julia> Dict(i for i in 1:3)
ERROR: ArgumentError: AbstractDict(kv): kv needs to be an iterator of 2-tuples or pairs
Stacktrace:
 [1] _throw_dict_kv_error()
   @ Base ./dict.jl:118
 [2] grow_to!
   @ ./dict.jl:132 [inlined]
 [3] dict_with_eltype
   @ ./abstractdict.jl:592 [inlined]
 [4] Dict(kv::Base.Generator{UnitRange{Int64}, typeof(identity)})
   @ Base ./dict.jl:120
 [5] top-level scope
   @ REPL[1]:1

julia> Dict(i => error("$i") for i in 1:3)
ERROR: 1
Stacktrace:
 [1] error(s::String)
   @ Base ./error.jl:35
 [2] (::var"#3#4")(i::Int64)
   @ Main ./none:0
 [3] iterate
   @ ./generator.jl:48 [inlined]
 [4] grow_to!
   @ ./dict.jl:124 [inlined]
 [5] dict_with_eltype
   @ ./abstractdict.jl:592 [inlined]
 [6] Dict(kv::Base.Generator{UnitRange{Int64}, var"#3#4"})
   @ Base ./dict.jl:120
 [7] top-level scope
   @ REPL[2]:1
```

The other unrelated change here is that `dest = empty(dest, typeof(k),
typeof(v))` is made conditional, so we do not unconditionally construct
an empty Dict in order to discard it and allocate an exact duplicate of
it, but only do so if inference wasn't precise originally.

Co-authored-by: Curtis Vogt <curtis.vogt@gmail.com>
---
 base/abstractdict.jl | 49 ++++++++++++++++++++++++++++++++++++++++++++
 base/dict.jl         | 40 +-----------------------------------
 base/iddict.jl       | 13 +-----------
 base/weakkeydict.jl  | 12 +----------
 test/dict.jl         | 24 ++++++++++++++++++++++
 5 files changed, 76 insertions(+), 62 deletions(-)

diff --git a/base/abstractdict.jl b/base/abstractdict.jl
index 5ca485610f053..f73b518930a07 100644
--- a/base/abstractdict.jl
+++ b/base/abstractdict.jl
@@ -579,6 +579,55 @@ _tablesz(x::T) where T <: Integer = x < 16 ? T(16) : one(T)<<(top_set_bit(x-one(
 
 TP{K,V} = Union{Type{Tuple{K,V}},Type{Pair{K,V}}}
 
+# This error is thrown if `grow_to!` cannot validate the contents of the iterator argument to it, which it does by testing the iteration protocol (isiterable) on it each time it is about to start iteration on it
+_throw_dict_kv_error() = throw(ArgumentError("AbstractDict(kv): kv needs to be an iterator of 2-tuples or pairs"))
+
+function grow_to!(dest::AbstractDict, itr)
+    applicable(iterate, itr) || _throw_dict_kv_error()
+    y = iterate(itr)
+    y === nothing && return dest
+    kv, st = y
+    applicable(iterate, kv) || _throw_dict_kv_error()
+    k = iterate(kv)
+    k === nothing && _throw_dict_kv_error()
+    k, kvst = k
+    v = iterate(kv, kvst)
+    v === nothing && _throw_dict_kv_error()
+    v, kvst = v
+    iterate(kv, kvst) === nothing || _throw_dict_kv_error()
+    if !(dest isa AbstractDict{typeof(k), typeof(v)})
+        dest = empty(dest, typeof(k), typeof(v))
+    end
+    dest[k] = v
+    return grow_to!(dest, itr, st)
+end
+
+function grow_to!(dest::AbstractDict{K,V}, itr, st) where {K, V}
+    y = iterate(itr, st)
+    while y !== nothing
+        kv, st = y
+        applicable(iterate, kv) || _throw_dict_kv_error()
+        kst = iterate(kv)
+        kst === nothing && _throw_dict_kv_error()
+        k, kvst = kst
+        vst = iterate(kv, kvst)
+        vst === nothing && _throw_dict_kv_error()
+        v, kvst = vst
+        iterate(kv, kvst) === nothing || _throw_dict_kv_error()
+        if isa(k, K) && isa(v, V)
+            dest[k] = v
+        else
+            new = empty(dest, promote_typejoin(K, typeof(k)), promote_typejoin(V, typeof(v)))
+            merge!(new, dest)
+            new[k] = v
+            return grow_to!(new, itr, st)
+        end
+        y = iterate(itr, st)
+    end
+    return dest
+end
+
+
 dict_with_eltype(DT_apply, kv, ::TP{K,V}) where {K,V} = DT_apply(K, V)(kv)
 dict_with_eltype(DT_apply, kv::Generator, ::TP{K,V}) where {K,V} = DT_apply(K, V)(kv)
 dict_with_eltype(DT_apply, ::Type{Pair{K,V}}) where {K,V} = DT_apply(K, V)()
diff --git a/base/dict.jl b/base/dict.jl
index 2b6fd41d8d075..c924e10ab4d6e 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -114,45 +114,7 @@ const AnyDict = Dict{Any,Any}
 Dict(ps::Pair{K,V}...) where {K,V} = Dict{K,V}(ps)
 Dict(ps::Pair...)                  = Dict(ps)
 
-function Dict(kv)
-    try
-        dict_with_eltype((K, V) -> Dict{K, V}, kv, eltype(kv))
-    catch
-        if !isiterable(typeof(kv)) || !all(x->isa(x,Union{Tuple,Pair}),kv)
-            throw(ArgumentError("Dict(kv): kv needs to be an iterator of tuples or pairs"))
-        else
-            rethrow()
-        end
-    end
-end
-
-function grow_to!(dest::AbstractDict{K, V}, itr) where V where K
-    y = iterate(itr)
-    y === nothing && return dest
-    ((k,v), st) = y
-    dest2 = empty(dest, typeof(k), typeof(v))
-    dest2[k] = v
-    grow_to!(dest2, itr, st)
-end
-
-# this is a special case due to (1) allowing both Pairs and Tuples as elements,
-# and (2) Pair being invariant. a bit annoying.
-function grow_to!(dest::AbstractDict{K,V}, itr, st) where V where K
-    y = iterate(itr, st)
-    while y !== nothing
-        (k,v), st = y
-        if isa(k,K) && isa(v,V)
-            dest[k] = v
-        else
-            new = empty(dest, promote_typejoin(K,typeof(k)), promote_typejoin(V,typeof(v)))
-            merge!(new, dest)
-            new[k] = v
-            return grow_to!(new, itr, st)
-        end
-        y = iterate(itr, st)
-    end
-    return dest
-end
+Dict(kv) = dict_with_eltype((K, V) -> Dict{K, V}, kv, eltype(kv))
 
 empty(a::AbstractDict, ::Type{K}, ::Type{V}) where {K, V} = Dict{K, V}()
 
diff --git a/base/iddict.jl b/base/iddict.jl
index 73f532af9bba6..0b12ae86b2c6a 100644
--- a/base/iddict.jl
+++ b/base/iddict.jl
@@ -53,18 +53,7 @@ IdDict(ps::Pair{K}...)             where {K}   = IdDict{K,Any}(ps)
 IdDict(ps::(Pair{K,V} where K)...) where {V}   = IdDict{Any,V}(ps)
 IdDict(ps::Pair...)                            = IdDict{Any,Any}(ps)
 
-function IdDict(kv)
-    try
-        dict_with_eltype((K, V) -> IdDict{K, V}, kv, eltype(kv))
-    catch
-        if !applicable(iterate, kv) || !all(x->isa(x,Union{Tuple,Pair}),kv)
-            throw(ArgumentError(
-                "IdDict(kv): kv needs to be an iterator of tuples or pairs"))
-        else
-            rethrow()
-        end
-    end
-end
+IdDict(kv) = dict_with_eltype((K, V) -> IdDict{K, V}, kv, eltype(kv))
 
 empty(d::IdDict, ::Type{K}, ::Type{V}) where {K, V} = IdDict{K,V}()
 
diff --git a/base/weakkeydict.jl b/base/weakkeydict.jl
index b827f0d1495da..1a98bf1ee4333 100644
--- a/base/weakkeydict.jl
+++ b/base/weakkeydict.jl
@@ -54,17 +54,7 @@ WeakKeyDict(ps::Pair{K}...)             where {K}   = WeakKeyDict{K,Any}(ps)
 WeakKeyDict(ps::(Pair{K,V} where K)...) where {V}   = WeakKeyDict{Any,V}(ps)
 WeakKeyDict(ps::Pair...)                            = WeakKeyDict{Any,Any}(ps)
 
-function WeakKeyDict(kv)
-    try
-        Base.dict_with_eltype((K, V) -> WeakKeyDict{K, V}, kv, eltype(kv))
-    catch
-        if !isiterable(typeof(kv)) || !all(x->isa(x,Union{Tuple,Pair}),kv)
-            throw(ArgumentError("WeakKeyDict(kv): kv needs to be an iterator of tuples or pairs"))
-        else
-            rethrow()
-        end
-    end
-end
+WeakKeyDict(kv) = Base.dict_with_eltype((K, V) -> WeakKeyDict{K, V}, kv, eltype(kv))
 
 function _cleanup_locked(h::WeakKeyDict)
     if h.dirty
diff --git a/test/dict.jl b/test/dict.jl
index f44c6d696bc74..ca8a598de0b81 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -162,6 +162,30 @@ end
 
     # issue #39117
     @test Dict(t[1]=>t[2] for t in zip((1,"2"), (2,"2"))) == Dict{Any,Any}(1=>2, "2"=>"2")
+
+    @testset "issue #33147" begin
+        expected = try; Base._throw_dict_kv_error(); catch e; e; end
+        @test_throws expected Dict(i for i in 1:2)
+        @test_throws expected Dict(nothing for i in 1:2)
+        @test_throws expected Dict(() for i in 1:2)
+        @test_throws expected Dict((i, i, i) for i in 1:2)
+        @test_throws expected Dict(nothing)
+        @test_throws expected Dict((1,))
+        @test_throws expected Dict(1:2)
+        @test_throws expected Dict(((),))
+        @test_throws expected IdDict(((),))
+        @test_throws expected WeakKeyDict(((),))
+        @test_throws expected IdDict(nothing)
+        @test_throws expected WeakKeyDict(nothing)
+        @test Dict(1:0) isa Dict
+        @test Dict(()) isa Dict
+        try
+            Dict(i => error("$i") for i in 1:3)
+        catch ex
+            @test ex isa ErrorException
+            @test length(Base.current_exceptions()) == 1
+        end
+    end
 end
 
 @testset "empty tuple ctor" begin

From 9284e572eb0a9f18ec7276de2f6456dcc0b99ed4 Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Fri, 9 Feb 2024 22:08:04 -0500
Subject: [PATCH 0864/1315] Add `Vector{<:AbstractString}` method for `Cmd()`
 (#49531)

Was annoyed that `Cmd` wouldn't take a vector containing SubStrings. So
I here add a constructor that converts an `AbstractString` vector to
`String`s.
---
 base/cmd.jl   | 2 +-
 test/spawn.jl | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/base/cmd.jl b/base/cmd.jl
index da29c732c7f26..0e4ec119109f1 100644
--- a/base/cmd.jl
+++ b/base/cmd.jl
@@ -14,7 +14,7 @@ struct Cmd <: AbstractCmd
     env::Union{Vector{String},Nothing}
     dir::String
     cpus::Union{Nothing,Vector{UInt16}}
-    Cmd(exec::Vector{String}) =
+    Cmd(exec::Vector{<:AbstractString}) =
         new(exec, false, 0x00, nothing, "", nothing)
     Cmd(cmd::Cmd, ignorestatus, flags, env, dir, cpus = nothing) =
         new(cmd.exec, ignorestatus, flags, env,
diff --git a/test/spawn.jl b/test/spawn.jl
index 4ae4b3368bef6..9d58b32976357 100644
--- a/test/spawn.jl
+++ b/test/spawn.jl
@@ -1032,3 +1032,10 @@ let effects = Base.infer_effects(x -> `a $x`, (Any,))
     @test !Core.Compiler.is_noub(effects)
     @test !Core.Compiler.is_consistent(effects)
 end
+
+# Test that Cmd accepts various AbstractStrings
+@testset "AbstractStrings" begin
+    args = split("-l /tmp")
+    @assert eltype(args) != String
+    @test Cmd(["ls", args...]) == `ls -l /tmp`
+end

From 250916f3a4e515e6edcfcf831e381c38828c4ccc Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Sat, 10 Feb 2024 11:09:31 +0800
Subject: [PATCH 0865/1315] Use StyledStrings for Logging (#51829)

Transition from printstyled to the new approach to styling provided by
StyledStrings.

This both makes it possible for the styling used to be customised, and
allows for other styled content to inherit/re-use the logging styles.
---
 doc/Manifest.toml                   |  1 +
 pkgimage.mk                         |  2 +-
 stdlib/Logging/Project.toml         |  3 +++
 stdlib/Logging/src/ConsoleLogger.jl | 33 ++++++++++++++++-------------
 stdlib/Logging/src/Logging.jl       | 12 +++++------
 stdlib/Logging/test/runtests.jl     | 24 ++++++++++-----------
 test/precompile.jl                  |  1 +
 7 files changed, 42 insertions(+), 34 deletions(-)

diff --git a/doc/Manifest.toml b/doc/Manifest.toml
index f3e4b08306bd2..b34942bbddd3a 100644
--- a/doc/Manifest.toml
+++ b/doc/Manifest.toml
@@ -134,6 +134,7 @@ uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531"
 version = "1.17.0+0"
 
 [[deps.Logging]]
+deps = ["StyledStrings"]
 uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
 version = "1.11.0"
 
diff --git a/pkgimage.mk b/pkgimage.mk
index b45b4ab89560b..c9de49d2f8421 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -80,7 +80,6 @@ $(eval $(call stdlib_builder,Base64,))
 $(eval $(call stdlib_builder,CRC32c,))
 $(eval $(call stdlib_builder,FileWatching,))
 $(eval $(call stdlib_builder,Libdl,))
-$(eval $(call stdlib_builder,Logging,))
 $(eval $(call stdlib_builder,Mmap,))
 $(eval $(call stdlib_builder,NetworkOptions,))
 $(eval $(call stdlib_builder,SHA,))
@@ -109,6 +108,7 @@ $(eval $(call stdlib_builder,OpenBLAS_jll,Artifacts Libdl))
 $(eval $(call stdlib_builder,Markdown,Base64))
 $(eval $(call stdlib_builder,Printf,Unicode))
 $(eval $(call stdlib_builder,Random,SHA))
+$(eval $(call stdlib_builder,Logging,StyledStrings))
 $(eval $(call stdlib_builder,Tar,ArgTools,SHA))
 $(eval $(call stdlib_builder,DelimitedFiles,Mmap))
 $(eval $(call stdlib_builder,JuliaSyntaxHighlighting,StyledStrings))
diff --git a/stdlib/Logging/Project.toml b/stdlib/Logging/Project.toml
index ce69112733d5e..3fc288e25f0b7 100644
--- a/stdlib/Logging/Project.toml
+++ b/stdlib/Logging/Project.toml
@@ -2,6 +2,9 @@ name = "Logging"
 uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
 version = "1.11.0"
 
+[deps]
+StyledStrings = "f489334b-da3d-4c2e-b8f0-e476e12c162b"
+
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
diff --git a/stdlib/Logging/src/ConsoleLogger.jl b/stdlib/Logging/src/ConsoleLogger.jl
index 1d45296c907d1..0922e9fcc66c9 100644
--- a/stdlib/Logging/src/ConsoleLogger.jl
+++ b/stdlib/Logging/src/ConsoleLogger.jl
@@ -12,10 +12,10 @@ Log levels less than `min_level` are filtered out.
 Message formatting can be controlled by setting keyword arguments:
 
 * `meta_formatter` is a function which takes the log event metadata
-  `(level, _module, group, id, file, line)` and returns a color (as would be
-  passed to printstyled), prefix and suffix for the log message.  The
-  default is to prefix with the log level and a suffix containing the module,
-  file and line location.
+  `(level, _module, group, id, file, line)` and returns a face name (used in
+  the constructed [`AnnotatedString`](@ref Base.AnnotatedString)), prefix and
+  suffix for the log message.  The default is to prefix with the log level and
+  a suffix containing the module, file and line location.
 * `show_limited` limits the printing of large data structures to something
   which can fit on the screen by setting the `:limit` `IOContext` key during
   formatting.
@@ -59,10 +59,10 @@ showvalue(io, ex::Exception) = showerror(io, ex)
 
 function default_logcolor(level::LogLevel)
     level in keys(custom_log_levels) ? custom_log_levels[level][2] :
-    level < Info  ? Base.debug_color() :
-    level < Warn  ? Base.info_color()  :
-    level < Error ? Base.warn_color()  :
-                    Base.error_color()
+    level < Info  ? :log_debug :
+    level < Warn  ? :log_info  :
+    level < Error ? :log_warn  :
+                    :log_error
 end
 
 function default_metafmt(level::LogLevel, _module, group, id, file, line)
@@ -104,6 +104,8 @@ function termlength(str)
     return N
 end
 
+termlength(str::Base.AnnotatedString) = textwidth(str)
+
 function handle_message(logger::ConsoleLogger, level::LogLevel, message, _module, group, id,
                         filepath, line; kwargs...)
     @nospecialize
@@ -146,6 +148,7 @@ function handle_message(logger::ConsoleLogger, level::LogLevel, message, _module
     # Format lines as text with appropriate indentation and with a box
     # decoration on the left.
     color, prefix, suffix = logger.meta_formatter(level, _module, group, id, filepath, line)::Tuple{Union{Symbol,Int},String,String}
+    color = StyledStrings.Face(foreground=StyledStrings.Legacy.legacy_color(color))
     minsuffixpad = 2
     buf = IOBuffer()
     iob = IOContext(buf, stream)
@@ -159,19 +162,19 @@ function handle_message(logger::ConsoleLogger, level::LogLevel, message, _module
         nonpadwidth = 2 + length(suffix)
     end
     for (i, (indent, msg)) in enumerate(msglines)
-        boxstr = length(msglines) == 1 ? "[ " :
-                 i == 1                ? "┌ " :
-                 i < length(msglines)  ? "│ " :
-                                         "└ "
-        printstyled(iob, boxstr, bold=true, color=color)
+        boxstr = length(msglines) == 1 ? "[" :
+                 i == 1                ? "┌" :
+                 i < length(msglines)  ? "│" :
+                                         "└"
+        print(iob, styled"{$color,bold:$boxstr} ")
         if i == 1 && !isempty(prefix)
-            printstyled(iob, prefix, " ", bold=true, color=color)
+            print(iob, styled"{$color,bold:$prefix} ")
         end
         print(iob, " "^indent, msg)
         if i == length(msglines) && !isempty(suffix)
             npad = max(0, justify_width - nonpadwidth) + minsuffixpad
             print(iob, " "^npad)
-            printstyled(iob, suffix, color=:light_black)
+            print(iob, styled"{shadow:$suffix}")
         end
         println(iob)
     end
diff --git a/stdlib/Logging/src/Logging.jl b/stdlib/Logging/src/Logging.jl
index 83e93ee396361..1cb1bca774c27 100644
--- a/stdlib/Logging/src/Logging.jl
+++ b/stdlib/Logging/src/Logging.jl
@@ -8,6 +8,8 @@ and available by default.
 """
 module Logging
 
+using StyledStrings
+
 # Import the CoreLogging implementation into Logging as new const bindings.
 # Doing it this way (rather than with import) makes these symbols accessible to
 # tab completion.
@@ -31,13 +33,11 @@ for sym in [
 end
 
 """
-    @create_log_macro(name::Symbol, level::Int, color::Union{Int,Symbol})
-
-Creates a custom log macro like `@info`, `@warn` etc. with a given `name`, `level` and
-`color`. The macro created is named with the lowercase form of `name` but the given form
-is used for the printing.
+    @create_log_macro(name::Symbol, level::Int, face::Union{Symbol, StyledStrings.Face})
 
-The available color keys can be seen by typing `Base.text_colors` in the help mode of the REPL
+Creates a custom log macro like `@info`, `@warn` etc. with a given `name`,
+`level` to be displayed with `face`. The macro created is named with the
+lowercase form of `name` but the given form is used for the printing.
 
 ```julia-repl
 julia> @create_log_macro(:MyLog, 200, :magenta)
diff --git a/stdlib/Logging/test/runtests.jl b/stdlib/Logging/test/runtests.jl
index e0fc6a0bc3770..15371ac5d442c 100644
--- a/stdlib/Logging/test/runtests.jl
+++ b/stdlib/Logging/test/runtests.jl
@@ -54,24 +54,24 @@ end
 
     @testset "Default metadata formatting" begin
         @test Logging.default_metafmt(Logging.Debug, Base, :g, :i, expanduser("~/somefile.jl"), 42) ==
-            (:blue,      "Debug:",   "@ Base ~/somefile.jl:42")
+            (:log_debug, "Debug:",   "@ Base ~/somefile.jl:42")
         @test Logging.default_metafmt(Logging.Info,  Main, :g, :i, "a.jl", 1) ==
-            (:cyan,      "Info:",    "")
+            (:log_info,  "Info:",    "")
         @test Logging.default_metafmt(Logging.Warn,  Main, :g, :i, "b.jl", 2) ==
-            (:yellow,    "Warning:", "@ Main b.jl:2")
+            (:log_warn,  "Warning:", "@ Main b.jl:2")
         @test Logging.default_metafmt(Logging.Error, Main, :g, :i, "", 0) ==
-            (:light_red, "Error:",   "@ Main :0")
+            (:log_error, "Error:",   "@ Main :0")
         # formatting of nothing
         @test Logging.default_metafmt(Logging.Warn,  nothing, :g, :i, "b.jl", 2) ==
-            (:yellow,    "Warning:", "@ b.jl:2")
+            (:log_warn,  "Warning:", "@ b.jl:2")
         @test Logging.default_metafmt(Logging.Warn,  Main, :g, :i, nothing, 2) ==
-            (:yellow,    "Warning:", "@ Main")
+            (:log_warn,  "Warning:", "@ Main")
         @test Logging.default_metafmt(Logging.Warn,  Main, :g, :i, "b.jl", nothing) ==
-            (:yellow,    "Warning:", "@ Main b.jl")
+            (:log_warn,  "Warning:", "@ Main b.jl")
         @test Logging.default_metafmt(Logging.Warn,  nothing, :g, :i, nothing, 2) ==
-            (:yellow,    "Warning:", "")
+            (:log_warn,  "Warning:", "")
         @test Logging.default_metafmt(Logging.Warn,  Main, :g, :i, "b.jl", 2:5) ==
-            (:yellow,    "Warning:", "@ Main b.jl:2-5")
+            (:log_warn,  "Warning:", "@ Main b.jl:2-5")
     end
 
     function dummy_metafmt(level, _module, group, id, file, line)
@@ -256,9 +256,9 @@ end
     # Basic colorization test
     @test genmsg("line1\nline2", color=true) ==
     """
-    \e[36m\e[1m┌ \e[22m\e[39m\e[36m\e[1mPREFIX \e[22m\e[39mline1
-    \e[36m\e[1m│ \e[22m\e[39mline2
-    \e[36m\e[1m└ \e[22m\e[39m\e[90mSUFFIX\e[39m
+    \e[36m\e[1m┌\e[39m\e[22m \e[36m\e[1mPREFIX\e[39m\e[22m line1
+    \e[36m\e[1m│\e[39m\e[22m line2
+    \e[36m\e[1m└\e[39m\e[22m \e[90mSUFFIX\e[39m
     """
 
 end
diff --git a/test/precompile.jl b/test/precompile.jl
index 1eed9b1418a63..d1360d1a06357 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -469,6 +469,7 @@ precompile_test_harness(false) do dir
             # and their dependencies
             Dict(Base.PkgId(Base.root_module(Base, :SHA)) => Base.module_build_id(Base.root_module(Base, :SHA))),
             Dict(Base.PkgId(Base.root_module(Base, :Markdown)) => Base.module_build_id(Base.root_module(Base, :Markdown))),
+            Dict(Base.PkgId(Base.root_module(Base, :StyledStrings)) => Base.module_build_id(Base.root_module(Base, :StyledStrings))),
             # and their dependencies
             Dict(Base.PkgId(Base.root_module(Base, :Base64)) => Base.module_build_id(Base.root_module(Base, :Base64))),
         )

From 3952e78cfeaa3f4a8bc9463f93d5d9effc5ac3cf Mon Sep 17 00:00:00 2001
From: Jeremie Knuesel <knuesel@gmail.com>
Date: Sat, 10 Feb 2024 04:12:10 +0100
Subject: [PATCH 0866/1315] LU factorization: add allowsingular keyword
 argument (#52957)

Currently the `check` argument of `lu` conflates failed factorization
(invalid factors) and valid factorizations that have a rank-deficient
factor, and the `show` value for the factorization is misleading in the
latter case.

This PR adds an `allowsingular` keyword argument to `lu` and the
corresponding `issuccess` method to treat valid but rank-deficient
factors as success. It also changes `show` to show the factors as usual
in such cases, but with a "rank-deficient" note.

The invalid vs rank-defficient factors are distinguished using negative
`info` values in the rank-deficient case, as proposed in #27657.

Fixes #27657
Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
Co-authored-by: Jishnu Bhattacharya <jishnub.github@gmail.com>
---
 NEWS.md                                   |   1 +
 stdlib/LinearAlgebra/src/factorization.jl |  14 +--
 stdlib/LinearAlgebra/src/lu.jl            | 121 +++++++++++++++++-----
 stdlib/LinearAlgebra/src/tridiag.jl       |   4 +-
 stdlib/LinearAlgebra/test/lu.jl           |   6 +-
 5 files changed, 108 insertions(+), 38 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 6db22fa1f8be7..ca4fb51b37fa0 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -139,6 +139,7 @@ Standard library changes
 * Structured matrices now retain either the axes of the parent (for `Symmetric`/`Hermitian`/`AbstractTriangular`/`UpperHessenberg`), or that of the principal diagonal (for banded matrices) ([#52480]).
 * `bunchkaufman` and `bunchkaufman!` now work for any `AbstractFloat`, `Rational` and their complex variants. `bunchkaufman` now supports `Integer` types, by making an internal conversion to `Rational{BigInt}`. Added new function `inertia` that computes the inertia of the diagonal factor given by the `BunchKaufman` factorization object of a real symmetric or Hermitian matrix. For complex symmetric matrices, `inertia` only computes the number of zero eigenvalues of the diagonal factor ([#51487]).
 * Packages that specialize matrix-matrix `mul!` with a method signature of the form `mul!(::AbstractMatrix, ::MyMatrix, ::AbstractMatrix, ::Number, ::Number)` no longer encounter method ambiguities when interacting with `LinearAlgebra`. Previously, ambiguities used to arise when multiplying a `MyMatrix` with a structured matrix type provided by LinearAlgebra, such as `AbstractTriangular`, which used to necessitate additional methods to resolve such ambiguities. Similar sources of ambiguities have also been removed for matrix-vector `mul!` operations ([#52837]).
+* `lu` and `issuccess(::LU)` now accept an `allowsingular` keyword argument. When set to `true`, a valid factorization with rank-deficient U factor will be treated as success instead of throwing an error. Such factorizations are now shown by printing the factors together with a "rank-deficient" note rather than printing a "Failed Factorization" message ([#52957]).
 
 #### Logging
 * New `@create_log_macro` macro for creating new log macros like `@info`, `@warn` etc. For instance
diff --git a/stdlib/LinearAlgebra/src/factorization.jl b/stdlib/LinearAlgebra/src/factorization.jl
index 6f5a631cf9164..4cefc661741be 100644
--- a/stdlib/LinearAlgebra/src/factorization.jl
+++ b/stdlib/LinearAlgebra/src/factorization.jl
@@ -64,11 +64,10 @@ transpose(F::AdjointFactorization{<:Real}) = F.parent
 conj(A::TransposeFactorization) = adjoint(A.parent)
 conj(A::AdjointFactorization) = transpose(A.parent)
 
+# These functions expect a non-zero info to be positive, indicating the position where a problem was detected
 checkpositivedefinite(info) = info == 0 || throw(PosDefException(info))
-checknonsingular(info, ::RowMaximum) = info == 0 || throw(SingularException(info))
-checknonsingular(info, ::RowNonZero) = info == 0 || throw(SingularException(info))
-checknonsingular(info, ::NoPivot) = info == 0 || throw(ZeroPivotException(info))
-checknonsingular(info) = checknonsingular(info, RowMaximum())
+checknonsingular(info) = info == 0 || throw(SingularException(info))
+checknozeropivot(info) = info == 0 || throw(ZeroPivotException(info))
 
 """
     issuccess(F::Factorization)
@@ -78,16 +77,13 @@ Test that a factorization of a matrix succeeded.
 !!! compat "Julia 1.6"
     `issuccess(::CholeskyPivoted)` requires Julia 1.6 or later.
 
+# Examples
+
 ```jldoctest
 julia> F = cholesky([1 0; 0 1]);
 
 julia> issuccess(F)
 true
-
-julia> F = lu([1 0; 0 0]; check = false);
-
-julia> issuccess(F)
-false
 ```
 """
 issuccess(F::Factorization)
diff --git a/stdlib/LinearAlgebra/src/lu.jl b/stdlib/LinearAlgebra/src/lu.jl
index 25e32a8ab0828..be32f1e863ff1 100644
--- a/stdlib/LinearAlgebra/src/lu.jl
+++ b/stdlib/LinearAlgebra/src/lu.jl
@@ -21,6 +21,7 @@ The individual components of the factorization `F::LU` can be accessed via [`get
 Iterating the factorization produces the components `F.L`, `F.U`, and `F.p`.
 
 # Examples
+
 ```jldoctest
 julia> A = [4 3; 6 3]
 2×2 Matrix{Int64}:
@@ -50,7 +51,7 @@ true
 struct LU{T,S<:AbstractMatrix{T},P<:AbstractVector{<:Integer}} <: Factorization{T}
     factors::S
     ipiv::P
-    info::BlasInt
+    info::BlasInt # Can be negative to indicate failed unpivoted factorization
 
     function LU{T,S,P}(factors, ipiv, info) where {T, S<:AbstractMatrix{T}, P<:AbstractVector{<:Integer}}
         require_one_based_indexing(factors)
@@ -76,16 +77,25 @@ Base.iterate(S::LU, ::Val{:done}) = nothing
 adjoint(F::LU{<:Real}) = TransposeFactorization(F)
 transpose(F::LU{<:Real}) = TransposeFactorization(F)
 
+function _check_lu_success(info, allowsingular)
+    if info < 0 # zero pivot error from unpivoted LU
+        checknozeropivot(-info)
+    else
+        allowsingular || checknonsingular(info)
+    end
+end
+
 # the following method is meant to catch calls to lu!(A::LAPACKArray) without a pivoting strategy
-lu!(A::StridedMatrix{<:BlasFloat}; check::Bool = true) = lu!(A, RowMaximum(); check=check)
-function lu!(A::StridedMatrix{T}, ::RowMaximum; check::Bool = true) where {T<:BlasFloat}
+lu!(A::StridedMatrix{<:BlasFloat}; check::Bool = true, allowsingular::Bool = false) = lu!(A, RowMaximum(); check, allowsingular)
+function lu!(A::StridedMatrix{T}, ::RowMaximum; check::Bool = true, allowsingular::Bool = false) where {T<:BlasFloat}
     lpt = LAPACK.getrf!(A; check)
-    check && checknonsingular(lpt[3])
+    check && _check_lu_success(lpt[3], allowsingular)
     return LU{T,typeof(lpt[1]),typeof(lpt[2])}(lpt[1], lpt[2], lpt[3])
 end
-function lu!(A::HermOrSym{T}, pivot::Union{RowMaximum,NoPivot,RowNonZero} = lupivottype(T); check::Bool = true) where {T}
+function lu!(A::HermOrSym{T}, pivot::Union{RowMaximum,NoPivot,RowNonZero} = lupivottype(T);
+        check::Bool = true, allowsingular::Bool = false) where {T}
     copytri!(A.data, A.uplo, isa(A, Hermitian))
-    lu!(A.data, pivot; check = check)
+    lu!(A.data, pivot; check, allowsingular)
 end
 # for backward compatibility
 # TODO: remove towards Julia v2
@@ -93,13 +103,16 @@ end
 @deprecate lu!(A::Union{StridedMatrix,HermOrSym,Tridiagonal}, ::Val{false}; check::Bool = true) lu!(A, NoPivot(); check=check)
 
 """
-    lu!(A, pivot = RowMaximum(); check = true) -> LU
+    lu!(A, pivot = RowMaximum(); check = true, allowsingular = false) -> LU
 
 `lu!` is the same as [`lu`](@ref), but saves space by overwriting the
 input `A`, instead of creating a copy. An [`InexactError`](@ref)
 exception is thrown if the factorization produces a number not representable by the
 element type of `A`, e.g. for integer types.
 
+!!! compat "Julia 1.11"
+    The `allowsingular` keyword argument was added in Julia 1.11.
+
 # Examples
 ```jldoctest
 julia> A = [4. 3.; 6. 3.]
@@ -129,10 +142,10 @@ Stacktrace:
 [...]
 ```
 """
-lu!(A::AbstractMatrix, pivot::Union{RowMaximum,NoPivot,RowNonZero} = lupivottype(eltype(A)); check::Bool = true) =
-    generic_lufact!(A, pivot; check = check)
+lu!(A::AbstractMatrix, pivot::Union{RowMaximum,NoPivot,RowNonZero} = lupivottype(eltype(A));
+    check::Bool = true, allowsingular::Bool = false) = generic_lufact!(A, pivot; check, allowsingular)
 function generic_lufact!(A::AbstractMatrix{T}, pivot::Union{RowMaximum,NoPivot,RowNonZero} = lupivottype(T);
-                         check::Bool = true) where {T}
+                         check::Bool = true, allowsingular::Bool = false) where {T}
     check && LAPACK.chkfinite(A)
     # Extract values
     m, n = size(A)
@@ -188,7 +201,12 @@ function generic_lufact!(A::AbstractMatrix{T}, pivot::Union{RowMaximum,NoPivot,R
             end
         end
     end
-    check && checknonsingular(info, pivot)
+    if pivot === NoPivot()
+        # Use a negative value to distinguish a failed factorization (zero in pivot
+        # position during unpivoted LU) from a valid but rank-deficient factorization
+        info = -info
+    end
+    check && _check_lu_success(info, allowsingular)
     return LU{T,typeof(A),typeof(ipiv)}(A, ipiv, convert(BlasInt, info))
 end
 
@@ -215,7 +233,7 @@ lupivottype(::Type{T}) where {T} = RowMaximum()
 
 # for all other types we must promote to a type which is stable under division
 """
-    lu(A, pivot = RowMaximum(); check = true) -> F::LU
+    lu(A, pivot = RowMaximum(); check = true, allowsingular = false) -> F::LU
 
 Compute the LU factorization of `A`.
 
@@ -223,6 +241,10 @@ When `check = true`, an error is thrown if the decomposition fails.
 When `check = false`, responsibility for checking the decomposition's
 validity (via [`issuccess`](@ref)) lies with the user.
 
+By default, with `check = true`, an error is also thrown when the decomposition
+produces valid factors, but the upper-triangular factor `U` is rank-deficient. This may be changed by
+passing `allowsingular = true`.
+
 In most cases, if `A` is a subtype `S` of `AbstractMatrix{T}` with an element
 type `T` supporting `+`, `-`, `*` and `/`, the return type is `LU{T,S{T}}`.
 
@@ -240,7 +262,8 @@ One of the following pivoting strategies can be selected via the optional `pivot
   to be factorized rows.  (This corresponds to the typical choice in hand calculations, and
   is also useful for more general algebraic number types that support [`iszero`](@ref) but
   not `abs` or `<`.)
-* `NoPivot()`: pivoting turned off (may fail if a zero entry is encountered).
+* `NoPivot()`: pivoting turned off (will fail if a zero entry is encountered in
+  a pivot position, even when `allowsingular = true`).
 
 The individual components of the factorization `F` can be accessed via [`getproperty`](@ref):
 
@@ -269,6 +292,9 @@ The relationship between `F` and `A` is
 | [`logabsdet`](@ref)              | ✓    | ✓                      |
 | [`size`](@ref)                   | ✓    | ✓                      |
 
+!!! compat "Julia 1.11"
+    The `allowsingular` keyword argument was added in Julia 1.11.
+
 # Examples
 ```jldoctest
 julia> A = [4 3; 6 3]
@@ -294,6 +320,17 @@ julia> l, u, p = lu(A); # destructuring via iteration
 
 julia> l == F.L && u == F.U && p == F.p
 true
+
+julia> lu([1 2; 1 2], allowsingular = true)
+LU{Float64, Matrix{Float64}, Vector{Int64}}
+L factor:
+2×2 Matrix{Float64}:
+ 1.0  0.0
+ 1.0  1.0
+U factor (rank-deficient):
+2×2 Matrix{Float64}:
+ 1.0  2.0
+ 0.0  0.0
 ```
 """
 lu(A::AbstractMatrix{T}, args...; kwargs...) where {T} =
@@ -309,9 +346,9 @@ _lucopy(A::HermOrSym, T)      = copymutable_oftype(A, T)
 _lucopy(A::Tridiagonal, T)    = copymutable_oftype(A, T)
 
 lu(S::LU) = S
-function lu(x::Number; check::Bool=true)
+function lu(x::Number; check::Bool=true, allowsingular::Bool=false)
     info = x == 0 ? one(BlasInt) : zero(BlasInt)
-    check && checknonsingular(info)
+    check && _check_lu_success(info, allowsingular)
     return LU(fill(x, 1, 1), BlasInt[1], info)
 end
 
@@ -357,17 +394,47 @@ end
 Base.propertynames(F::LU, private::Bool=false) =
     (:L, :U, :p, :P, (private ? fieldnames(typeof(F)) : ())...)
 
-issuccess(F::LU) = F.info == 0
+
+"""
+    issuccess(F::LU; allowsingular = false)
+
+Test that the LU factorization of a matrix succeeded. By default a
+factorization that produces a valid but rank-deficient U factor is considered a
+failure. This can be changed by passing `allowsingular = true`.
+
+!!! compat "Julia 1.11"
+    The `allowsingular` keyword argument was added in Julia 1.11.
+
+# Examples
+
+```jldoctest
+julia> F = lu([1 2; 1 2], check = false);
+
+julia> issuccess(F)
+false
+
+julia> issuccess(F, allowsingular = true)
+true
+```
+"""
+function issuccess(F::LU; allowsingular::Bool=false)
+    # A negative info is always a failure, a positive info indicates a valid but rank-deficient U factor
+    F.info == 0 || (allowsingular && F.info > 0)
+end
 
 function show(io::IO, mime::MIME{Symbol("text/plain")}, F::LU)
-    if issuccess(F)
+    if F.info < 0
+        print(io, "Failed factorization of type $(typeof(F))")
+    else
         summary(io, F); println(io)
         println(io, "L factor:")
         show(io, mime, F.L)
-        println(io, "\nU factor:")
+        if F.info > 0
+            println(io, "\nU factor (rank-deficient):")
+        else
+            println(io, "\nU factor:")
+        end
         show(io, mime, F.U)
-    else
-        print(io, "Failed factorization of type $(typeof(F))")
     end
 end
 
@@ -494,7 +561,8 @@ inv!(A::LU{T,<:StridedMatrix}) where {T} =
 inv(A::LU{<:BlasFloat,<:StridedMatrix}) = inv!(copy(A))
 
 # Tridiagonal
-function lu!(A::Tridiagonal{T,V}, pivot::Union{RowMaximum,NoPivot} = RowMaximum(); check::Bool = true) where {T,V}
+function lu!(A::Tridiagonal{T,V}, pivot::Union{RowMaximum,NoPivot} = RowMaximum();
+        check::Bool = true, allowsingular::Bool = false) where {T,V}
     n = size(A, 1)
     has_du2_defined = isdefined(A, :du2) && length(A.du2) == max(0, n-2)
     if has_du2_defined
@@ -502,16 +570,17 @@ function lu!(A::Tridiagonal{T,V}, pivot::Union{RowMaximum,NoPivot} = RowMaximum(
     else
         du2 = similar(A.d, max(0, n-2))::V
     end
-    _lu_tridiag!(A.dl, A.d, A.du, du2, Vector{BlasInt}(undef, n), pivot, check)
+    _lu_tridiag!(A.dl, A.d, A.du, du2, Vector{BlasInt}(undef, n), pivot, check, allowsingular)
 end
-function lu!(F::LU{<:Any,<:Tridiagonal}, A::Tridiagonal, pivot::Union{RowMaximum,NoPivot} = RowMaximum(); check::Bool = true)
+function lu!(F::LU{<:Any,<:Tridiagonal}, A::Tridiagonal, pivot::Union{RowMaximum,NoPivot} = RowMaximum();
+        check::Bool = true, allowsingular::Bool = false)
     B = F.factors
     size(B) == size(A) || throw(DimensionMismatch())
     copyto!(B, A)
-    _lu_tridiag!(B.dl, B.d, B.du, B.du2, F.ipiv, pivot, check)
+    _lu_tridiag!(B.dl, B.d, B.du, B.du2, F.ipiv, pivot, check, allowsingular)
 end
 # See dgttrf.f
-@inline function _lu_tridiag!(dl, d, du, du2, ipiv, pivot, check)
+@inline function _lu_tridiag!(dl, d, du, du2, ipiv, pivot, check, allowsingular)
     T = eltype(d)
     V = typeof(d)
 
@@ -575,7 +644,7 @@ end
             end
         end
     end
-    check && checknonsingular(info, pivot)
+    check && _check_lu_success(info, allowsingular)
     return LU{T,Tridiagonal{T,V},typeof(ipiv)}(Tridiagonal{T,V}(dl, d, du, du2), ipiv, convert(BlasInt, info))
 end
 
diff --git a/stdlib/LinearAlgebra/src/tridiag.jl b/stdlib/LinearAlgebra/src/tridiag.jl
index ae7373ee79bca..07c2fe410769d 100644
--- a/stdlib/LinearAlgebra/src/tridiag.jl
+++ b/stdlib/LinearAlgebra/src/tridiag.jl
@@ -946,7 +946,7 @@ function ldiv!(A::Tridiagonal, B::AbstractVecOrMat)
                         B[i+1,j] -= fact*B[i,j]
                     end
                 else
-                    checknonsingular(i, RowMaximum())
+                    checknonsingular(i)
                 end
                 i < n-1 && (dl[i] = 0)
             else
@@ -967,7 +967,7 @@ function ldiv!(A::Tridiagonal, B::AbstractVecOrMat)
                 end
             end
         end
-        iszero(d[n]) && checknonsingular(n, RowMaximum())
+        iszero(d[n]) && checknonsingular(n)
         # backward substitution
         for j in 1:nrhs
             B[n,j] /= d[n]
diff --git a/stdlib/LinearAlgebra/test/lu.jl b/stdlib/LinearAlgebra/test/lu.jl
index d96510549caa5..a4cbdbe3eb9b9 100644
--- a/stdlib/LinearAlgebra/test/lu.jl
+++ b/stdlib/LinearAlgebra/test/lu.jl
@@ -245,9 +245,13 @@ end
     @test_throws ZeroPivotException lu!(copy(A), NoPivot(); check = true)
     @test !issuccess(lu(A, NoPivot(); check = false))
     @test !issuccess(lu!(copy(A), NoPivot(); check = false))
-    F = lu(A; check = false)
+    F = lu(A, NoPivot(); check = false)
     @test sprint((io, x) -> show(io, "text/plain", x), F) ==
         "Failed factorization of type $(typeof(F))"
+    F2 = lu(A; allowsingular = true)
+    @test !issuccess(F2)
+    @test issuccess(F2, allowsingular = true)
+    @test occursin("U factor (rank-deficient)", sprint((io, x) -> show(io, "text/plain", x), F2))
 end
 
 @testset "conversion" begin

From 7baaafeea35d3d9ebc2d1bff8045898774dda93f Mon Sep 17 00:00:00 2001
From: Jaakko Ruohio <jaakkor2@users.noreply.github.com>
Date: Sat, 10 Feb 2024 05:45:25 +0200
Subject: [PATCH 0867/1315] Truecolor terminal capability detection for Windows
 (#53257)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

```
for i in 0:255
    print("\x1b[38;2;$i;0;0m█")
end
```
shows on Windows Terminal

![image](https://github.com/JuliaLang/julia/assets/7318249/d742b739-9645-4daa-8572-d4c28803013e)
so it does have true-color support.
With this PR, `Base.ttyhastruecolor()` returns `true` on Windows
Terminal and Cygwin64 Terminal, those are the ones I tried out.

Notes:

https://devblogs.microsoft.com/commandline/24-bit-color-in-the-windows-console/
says
> in Windows 10 Insiders Build # 14931, we’ve updated the Windows
Console to support full, glorious 24-bit RGB true color!
---
 base/terminfo.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/base/terminfo.jl b/base/terminfo.jl
index 958fe459fb3d8..3792e35e0fd8d 100644
--- a/base/terminfo.jl
+++ b/base/terminfo.jl
@@ -337,6 +337,7 @@ function ttyhastruecolor()
         get(current_terminfo, :RGB, false) || get(current_terminfo, :Tc, false) ||
         (haskey(current_terminfo, :setrgbf) && haskey(current_terminfo, :setrgbb)) ||
         @static if Sys.isunix() get(current_terminfo, :colors, 0) > 256 else false end ||
+        (Sys.iswindows() && Sys.windows_version() ≥ v"10.0.14931") || # See <https://devblogs.microsoft.com/commandline/24-bit-color-in-the-windows-console/>
         something(tryparse(Int, get(ENV, "VTE_VERSION", "")), 0) >= 3600 || # Per GNOME bug #685759 <https://bugzilla.gnome.org/show_bug.cgi?id=685759>
         haskey(ENV, "XTERM_VERSION") ||
         get(ENV, "TERMINAL_PROGRAM", "") == "iTerm.app" || # Why does Apple need to be special?

From bdf9830b31e67b91ce11100547f6266a835448fb Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sat, 10 Feb 2024 09:16:32 +0530
Subject: [PATCH 0868/1315] Tests for isassigned for a SubArray (#53267)

---
 test/subarray.jl | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/test/subarray.jl b/test/subarray.jl
index a556260c4717e..0606ed00e6a7a 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -1031,3 +1031,28 @@ end
     av2 = view(av, 2:2, 2:2, 1:1)
     @test parentindices(av2) === (view(inds[1], 2:2, 2:2, 1:1),)
 end
+
+@testset "isassigned" begin
+    a = Vector{BigFloat}(undef, 5)
+    a[2] = 0
+    for v in (view(a, 2:3), # FastContiguousSubArray
+               view(a, 2:2:4), # FastSubArray
+               view(a, [2:2:4;]), # SlowSubArray
+            )
+        @test !isassigned(v, 0) # out-of-bounds
+        @test isassigned(v, 1) # inbounds and assigned
+        @test !isassigned(v, 2) # inbounds but not assigned
+        @test !isassigned(v, 4) # out-of-bounds
+    end
+
+    a = Array{BigFloat}(undef,3,3,3)
+    a[1,1,1] = 0
+    for v in (view(a, :, 1:3, 1), # FastContiguousSubArray
+               view(a, 1, :, 1:2), # FastSubArray
+            )
+        @test !isassigned(v, 0, 0) # out-of-bounds
+        @test isassigned(v, 1, 1) # inbounds and assigned
+        @test !isassigned(v, 1, 2) # inbounds but not assigned
+        @test !isassigned(v, 3, 3) # out-of-bounds
+    end
+end

From 8922eaa5517536eb51eb542f4543a8c6b82fda34 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Fri, 9 Feb 2024 19:48:27 -0800
Subject: [PATCH 0869/1315] Allow overriding default value of `JL_STACK_SIZE`
 (#53254)

Occasionally, users may want to be able to customize the default
per-task stack size. While this is a somewhat unusual thing to do, this
plumbs through support for this to be set at the `Make.user` level,
rather than having to modify `CFLAGS` or `src/options.h` directly.
---
 Make.inc      | 6 ++++++
 src/options.h | 2 ++
 2 files changed, 8 insertions(+)

diff --git a/Make.inc b/Make.inc
index a6de773b88dcd..51186cfefe8eb 100644
--- a/Make.inc
+++ b/Make.inc
@@ -759,6 +759,12 @@ JCXXFLAGS += -DGC_VERIFY
 JCFLAGS += -DGC_VERIFY
 endif
 
+ifneq ($(JL_STACK_SIZE),)
+JCXXFLAGS += -DJL_STACK_SIZE=$(JL_STACK_SIZE)
+JCFLAGS += -DJL_STACK_SIZE=$(JL_STACK_SIZE)
+endif
+
+
 ifeq ($(WITH_GC_DEBUG_ENV), 1)
 JCXXFLAGS += -DGC_DEBUG_ENV
 JCFLAGS += -DGC_DEBUG_ENV
diff --git a/src/options.h b/src/options.h
index da8d38e1b6a38..69b31ea918008 100644
--- a/src/options.h
+++ b/src/options.h
@@ -109,6 +109,7 @@
 
 // When not using COPY_STACKS the task-system is less memory efficient so
 // you probably want to choose a smaller default stack size (factor of 8-10)
+#if !defined(JL_STACK_SIZE)
 #if defined(_COMPILER_ASAN_ENABLED_) || defined(_COMPILER_MSAN_ENABLED_)
 #define JL_STACK_SIZE (64*1024*1024)
 #elif defined(_P64)
@@ -116,6 +117,7 @@
 #else
 #define JL_STACK_SIZE (2*1024*1024)
 #endif
+#endif
 
 // allow a suspended Task to restart on a different thread
 #define MIGRATE_TASKS

From e177fc3ad75769e426b0e102d2fef316495aae60 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sat, 10 Feb 2024 00:37:32 -0600
Subject: [PATCH 0870/1315] Fix sortperm(::OffsetRange) (#53208)

---
 base/range.jl  |  4 ++--
 test/ranges.jl | 10 ++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/base/range.jl b/base/range.jl
index e7d57fa3c7e85..9480b46d8fcf1 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -1393,8 +1393,8 @@ sort!(r::AbstractUnitRange) = r
 
 sort(r::AbstractRange) = issorted(r) ? r : reverse(r)
 
-sortperm(r::AbstractUnitRange) = 1:length(r)
-sortperm(r::AbstractRange) = issorted(r) ? (1:1:length(r)) : (length(r):-1:1)
+sortperm(r::AbstractUnitRange) = eachindex(r)
+sortperm(r::AbstractRange) = issorted(r) ? (firstindex(r):1:lastindex(r)) : (lastindex(r):-1:firstindex(r))
 
 function sum(r::AbstractRange{<:Real})
     l = length(r)
diff --git a/test/ranges.jl b/test/ranges.jl
index 8933ab0047c86..82593b53ff503 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -3,6 +3,9 @@
 using Base.Checked: checked_length
 using InteractiveUtils: code_llvm
 
+isdefined(Main, :OffsetArrays) || @eval Main include("testhelpers/OffsetArrays.jl")
+using .Main.OffsetArrays
+
 @testset "range construction" begin
     @test_throws ArgumentError range(start=1, step=1, stop=2, length=10)
     @test_throws ArgumentError range(start=1, step=1, stop=10, length=11)
@@ -545,6 +548,13 @@ end
         @test sort(1:10, rev=true) == 10:-1:1
         @test sort(-3:3, by=abs) == [0,-1,1,-2,2,-3,3]
         @test partialsort(1:10, 4) == 4
+
+        @testset "offset ranges" begin
+            x = OffsetArrays.IdOffsetRange(values=4:13, indices=4:13)
+            @test sort(x) === x === sort!(x)
+            @test sortperm(x) == eachindex(x)
+            @test issorted(x[sortperm(x)])
+        end
     end
     @testset "in" begin
         @test 0 in UInt(0):100:typemax(UInt)

From 5d9a472ce0dd58ef4cb3140ca8f420fa2a10b3ac Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Sat, 10 Feb 2024 04:06:15 -0500
Subject: [PATCH 0871/1315] additional clarification on cfunction embedding
 (#52315)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Additional clarification to #45208 — in addition to some punctuation
tweaks, I added a sentence noting that using `@cfunction` to construct
and C function pointers, unlike `jl_call`, eliminates the overhead of
dynamic dispatch.

See also [this discourse
thread](https://discourse.julialang.org/t/jl-call-function-call-latency/106791).
---
 doc/src/manual/embedding.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/embedding.md b/doc/src/manual/embedding.md
index f59dee225e1a7..9df9a6c198003 100644
--- a/doc/src/manual/embedding.md
+++ b/doc/src/manual/embedding.md
@@ -247,7 +247,7 @@ Its second argument `args` is an array of `jl_value_t*` arguments and `nargs` is
 arguments.
 
 There is also an alternative, possibly simpler, way of calling Julia functions and that is via [`@cfunction`](@ref).
-Using `@cfunction` allows you to do the type conversions on the Julia side which typically is easier than doing it on
+Using `@cfunction` allows you to do the type conversions on the Julia side, which is typically easier than doing it on
 the C side. The `sqrt` example above would with `@cfunction` be written as:
 
 ```c
@@ -255,7 +255,10 @@ double (*sqrt_jl)(double) = jl_unbox_voidpointer(jl_eval_string("@cfunction(sqrt
 double ret = sqrt_jl(2.0);
 ```
 
-where we first define a C callable function in Julia, extract the function pointer from it and finally call it.
+where we first define a C callable function in Julia, extract the function pointer from it, and finally call it.
+In addition to simplifying type conversions by doing them in the higher-level language, calling Julia functions
+via `@cfunction` pointers eliminates the dynamic-dispatch overhead required by `jl_call` (for which all of the
+arguments are "boxed"), and should have performance equivalent to native C function pointers.
 
 ## Memory Management
 

From a333f1c83aaf5d2485edf0e42cb6cd3fb5d01e44 Mon Sep 17 00:00:00 2001
From: Yuto Horikawa <hyrodium@gmail.com>
Date: Sat, 10 Feb 2024 18:44:38 +0900
Subject: [PATCH 0872/1315] Update `unique` and `unique!` docstrings to mention
 `hash` function (#52159)

---
 base/set.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/set.jl b/base/set.jl
index 76502ee9d22ef..6b0c933f79faa 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -201,7 +201,7 @@ end
     unique(itr)
 
 Return an array containing only the unique elements of collection `itr`,
-as determined by [`isequal`](@ref), in the order that the first of each
+as determined by [`isequal`](@ref) and [`hash`](@ref), in the order that the first of each
 set of equivalent elements originally appears. The element type of the
 input is preserved.
 
@@ -436,7 +436,7 @@ end
 """
     unique!(A::AbstractVector)
 
-Remove duplicate items as determined by [`isequal`](@ref), then return the modified `A`.
+Remove duplicate items as determined by [`isequal`](@ref) and [`hash`](@ref), then return the modified `A`.
 `unique!` will return the elements of `A` in the order that they occur. If you do not care
 about the order of the returned data, then calling `(sort!(A); unique!(A))` will be much
 more efficient as long as the elements of `A` can be sorted.

From baa36e41eb095cec8077b02cb9b45e56c09e481c Mon Sep 17 00:00:00 2001
From: Simon Byrne <simonbyrne@gmail.com>
Date: Sat, 10 Feb 2024 06:47:20 -0800
Subject: [PATCH 0873/1315] add --compiled-modules=strict option (#52174)

This is useful for ensuring that all modules were precompiled
successfully.
---
 base/loading.jl                          | 4 ++++
 base/util.jl                             | 1 +
 doc/man/julia.1                          | 4 +++-
 doc/src/manual/command-line-interface.md | 2 +-
 src/jloptions.c                          | 6 ++++--
 src/julia.h                              | 1 +
 6 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index d18d4e72ae809..1e6af4592b6a1 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2121,6 +2121,10 @@ function _require(pkg::PkgId, env=nothing)
             end
         end
 
+        if JLOptions().use_compiled_modules == 3
+            error("Precompiled image $pkg not available with flags $(CacheFlags())")
+        end
+
         # if the module being required was supposed to have a particular version
         # but it was not handled by the precompile loader, complain
         for (concrete_pkg, concrete_build_id) in _concrete_dependencies
diff --git a/base/util.jl b/base/util.jl
index 199546bd2dea4..41eaf528d6925 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -207,6 +207,7 @@ function julia_cmd(julia=joinpath(Sys.BINDIR, julia_exename()); cpu_target::Unio
     opts.can_inline == 0 && push!(addflags, "--inline=no")
     opts.use_compiled_modules == 0 && push!(addflags, "--compiled-modules=no")
     opts.use_compiled_modules == 2 && push!(addflags, "--compiled-modules=existing")
+    opts.use_compiled_modules == 3 && push!(addflags, "--compiled-modules=strict")
     opts.use_pkgimages == 0 && push!(addflags, "--pkgimages=no")
     opts.use_pkgimages == 2 && push!(addflags, "--pkgimages=existing")
     opts.opt_level == 2 || push!(addflags, "-O$(opts.opt_level)")
diff --git a/doc/man/julia.1 b/doc/man/julia.1
index ee0f973c259fd..a060c6dffb6b8 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -93,8 +93,10 @@ Enable or disable Julia's default signal handlers
 Use native code from system image if available
 
 .TP
---compiled-modules={yes*|no|existing}
+--compiled-modules={yes*|no|existing|strict}
 Enable or disable incremental precompilation of modules.
+The "existing" option allows use of existing compiled modules that were previously precompiled, but disallows creation of new precompile files.
+The "strict" option is similar, but will error if no precompile file is found.
 
 .TP
 --pkgimages={yes*|no|existing}
diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index b27c6bee1be38..d56b27622532c 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -172,7 +172,7 @@ The following is a complete list of command-line switches available when launchi
 |`--startup-file={yes*\|no}`            |Load `JULIA_DEPOT_PATH/config/startup.jl`; if [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH) environment variable is unset, load `~/.julia/config/startup.jl`|
 |`--handle-signals={yes*\|no}`          |Enable or disable Julia's default signal handlers|
 |`--sysimage-native-code={yes*\|no}`    |Use native code from system image if available|
-|`--compiled-modules={yes*\|no\|existing}` |Enable or disable incremental precompilation of modules. The `existing` option allows use of existing compiled modules that were previously precompiled, but disallows creation of new precompile files.|
+|`--compiled-modules={yes*\|no\|existing|strict}` |Enable or disable incremental precompilation of modules. The `existing` option allows use of existing compiled modules that were previously precompiled, but disallows creation of new precompile files. The `strict` option is similar, but will error if no precompile file is found. |
 |`--pkgimages={yes*\|no}`               |Enable or disable usage of native code caching in the form of pkgimages|
 |`-e`, `--eval <expr>`                  |Evaluate `<expr>`|
 |`-E`, `--print <expr>`                 |Evaluate `<expr>` and display the result|
diff --git a/src/jloptions.c b/src/jloptions.c
index 5d627687a38be..fa5d4ff43ee04 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -110,7 +110,7 @@ static const char opts[]  =
     " --handle-signals={yes*|no} Enable or disable Julia's default signal handlers\n"
     " --sysimage-native-code={yes*|no}\n"
     "                            Use native code from system image if available\n"
-    " --compiled-modules={yes*|no|existing}\n"
+    " --compiled-modules={yes*|no|existing|strict}\n"
     "                            Enable or disable incremental precompilation of modules\n"
     " --pkgimages={yes*|no|existing}\n"
     "                            Enable or disable usage of native code caching in the form of pkgimages ($)\n\n"
@@ -464,8 +464,10 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                 jl_options.use_compiled_modules = JL_OPTIONS_USE_COMPILED_MODULES_NO;
             else if (!strcmp(optarg,"existing"))
                 jl_options.use_compiled_modules = JL_OPTIONS_USE_COMPILED_MODULES_EXISTING;
+            else if (!strcmp(optarg,"strict"))
+                jl_options.use_compiled_modules = JL_OPTIONS_USE_COMPILED_MODULES_STRICT;
             else
-                jl_errorf("julia: invalid argument to --compiled-modules={yes|no|existing} (%s)", optarg);
+                jl_errorf("julia: invalid argument to --compiled-modules={yes|no|existing|strict} (%s)", optarg);
             break;
         case opt_pkgimages:
             if (!strcmp(optarg,"yes"))
diff --git a/src/julia.h b/src/julia.h
index ee20641d17805..1ad7967528786 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -2489,6 +2489,7 @@ JL_DLLEXPORT int jl_generating_output(void) JL_NOTSAFEPOINT;
 #define JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES 1
 #define JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_NO 0
 
+#define JL_OPTIONS_USE_COMPILED_MODULES_STRICT 3
 #define JL_OPTIONS_USE_COMPILED_MODULES_EXISTING 2
 #define JL_OPTIONS_USE_COMPILED_MODULES_YES 1
 #define JL_OPTIONS_USE_COMPILED_MODULES_NO 0

From 3a283d95d45d585a8727a6c7be6dc7c2966fe0de Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Sat, 10 Feb 2024 09:55:04 -0500
Subject: [PATCH 0874/1315] document Base.Chars arguments of
 startswith/endswith (#52741)

Since Julia 0.3 (#6779), the `startswith` and `endswith` functions have
accepted not only a string as the prefix/suffix, but also a character or
a tuple/vector/set of characters. However, this wasn't fully documented.

(The docstring actually mentioned vectors and sets of characters, but
this was inconsistent with the given signature.)

Also updates `Base.Chars` to allow `AbstractSet` types, not just `Set`,
which seems to have been an oversight.
---
 base/strings/util.jl | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/base/strings/util.jl b/base/strings/util.jl
index b5eb9185c3766..219b329d7924d 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -1,13 +1,23 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-const Chars = Union{AbstractChar,Tuple{Vararg{AbstractChar}},AbstractVector{<:AbstractChar},Set{<:AbstractChar}}
+"""
+    Base.Chars = Union{AbstractChar,Tuple{Vararg{AbstractChar}},AbstractVector{<:AbstractChar},AbstractSet{<:AbstractChar}}
+
+An alias type for a either single character or a tuple/vector/set of characters, used to describe arguments
+of several string-matching functions such as [`startswith`](@ref) and [`strip`](@ref).
+
+!!! compat "Julia 1.11"
+    Julia versions prior to 1.11 only included `Set`, not `AbstractSet`, in `Base.Chars` types.
+"""
+const Chars = Union{AbstractChar,Tuple{Vararg{AbstractChar}},AbstractVector{<:AbstractChar},AbstractSet{<:AbstractChar}}
 
 # starts with and ends with predicates
 
 """
-    startswith(s::AbstractString, prefix::AbstractString)
+    startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})
 
-Return `true` if `s` starts with `prefix`. If `prefix` is a vector or set
+Return `true` if `s` starts with `prefix`, which can be a string, a character,
+or a tuple/vector/set of characters. If `prefix` is a tuple/vector/set
 of characters, test whether the first character of `s` belongs to that set.
 
 See also [`endswith`](@ref), [`contains`](@ref).
@@ -30,10 +40,11 @@ end
 startswith(str::AbstractString, chars::Chars) = !isempty(str) && first(str)::AbstractChar in chars
 
 """
-    endswith(s::AbstractString, suffix::AbstractString)
+    endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})
 
-Return `true` if `s` ends with `suffix`. If `suffix` is a vector or set of
-characters, test whether the last character of `s` belongs to that set.
+Return `true` if `s` ends with `suffix`, which can be a string, a character,
+or a tuple/vector/set of characters. If `suffix` is a tuple/vector/set
+of characters, test whether the last character of `s` belongs to that set.
 
 See also [`startswith`](@ref), [`contains`](@ref).
 
@@ -70,7 +81,8 @@ end
 """
     startswith(io::IO, prefix::Union{AbstractString,Base.Chars})
 
-Check if an `IO` object starts with a prefix.  See also [`peek`](@ref).
+Check if an `IO` object starts with a prefix, which can be either a string, a
+character, or a tuple/vector/set of characters.  See also [`peek`](@ref).
 """
 function Base.startswith(io::IO, prefix::Base.Chars)
     mark(io)

From 35768c2c93dd3dae0c75905b5b955cd252d9f2e7 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 10 Feb 2024 12:41:57 -0500
Subject: [PATCH 0875/1315] Fix interpreter_exec.jl test (#53218)

This test was supposed to check that we correctly handled PhiNodes in
uninferred code in both the interpreter and the compiler. However, the
compiler path wasn't actually exercised, because the `inferred=true`
part of this forced it to be skipped. Drop that and fix the exposed
issues in the compiler where we didn't handle PhiNodes properly.

---------

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 base/compiler/abstractinterpretation.jl |  4 +++
 base/compiler/optimize.jl               |  2 +-
 base/compiler/utilities.jl              | 15 +++++----
 test/compiler/interpreter_exec.jl       | 42 +++++++++++++------------
 test/compiler/irpasses.jl               | 14 +++++++++
 test/compiler/ssair.jl                  | 14 ++++++---
 6 files changed, 59 insertions(+), 32 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 2b736dbeff9d8..9244ee5f3f8ec 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -3304,6 +3304,10 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             end
             if rt === Bottom
                 ssavaluetypes[currpc] = Bottom
+                # Special case: Bottom-typed PhiNodes do not error (but must also be unused)
+                if isa(stmt, PhiNode)
+                    continue
+                end
                 @goto find_next_bb
             end
             if changes !== nothing
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index f634fc0bcb7e4..cbe80a65fc607 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -1086,7 +1086,7 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
             idx += 1
             prevloc = codeloc
         end
-        if ssavaluetypes[idx] === Union{} && !(oldidx in sv.unreachable)
+        if ssavaluetypes[idx] === Union{} && !(oldidx in sv.unreachable) && !isa(code[idx], PhiNode)
             # We should have converted any must-throw terminators to an equivalent w/o control-flow edges
             @assert !isterminator(code[idx])
 
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 368395e714054..00c7ea40e3db9 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -415,15 +415,15 @@ function find_ssavalue_uses(body::Vector{Any}, nvals::Int)
         if isa(e, SSAValue)
             push!(uses[e.id], line)
         elseif isa(e, Expr)
-            find_ssavalue_uses(e, uses, line)
+            find_ssavalue_uses!(uses, e, line)
         elseif isa(e, PhiNode)
-            find_ssavalue_uses(e, uses, line)
+            find_ssavalue_uses!(uses, e, line)
         end
     end
     return uses
 end
 
-function find_ssavalue_uses(e::Expr, uses::Vector{BitSet}, line::Int)
+function find_ssavalue_uses!(uses::Vector{BitSet}, e::Expr, line::Int)
     head = e.head
     is_meta_expr_head(head) && return
     skiparg = (head === :(=))
@@ -433,13 +433,16 @@ function find_ssavalue_uses(e::Expr, uses::Vector{BitSet}, line::Int)
         elseif isa(a, SSAValue)
             push!(uses[a.id], line)
         elseif isa(a, Expr)
-            find_ssavalue_uses(a, uses, line)
+            find_ssavalue_uses!(uses, a, line)
         end
     end
 end
 
-function find_ssavalue_uses(e::PhiNode, uses::Vector{BitSet}, line::Int)
-    for val in e.values
+function find_ssavalue_uses!(uses::Vector{BitSet}, e::PhiNode, line::Int)
+    values = e.values
+    for i = 1:length(values)
+        isassigned(values, i) || continue
+        val = values[i]
         if isa(val, SSAValue)
             push!(uses[val.id], line)
         end
diff --git a/test/compiler/interpreter_exec.jl b/test/compiler/interpreter_exec.jl
index ce0704be15178..31f3f510cf4a2 100644
--- a/test/compiler/interpreter_exec.jl
+++ b/test/compiler/interpreter_exec.jl
@@ -20,13 +20,18 @@ let m = Meta.@lower 1 + 1
         ReturnNode(SSAValue(6)),
     ]
     nstmts = length(src.code)
-    src.ssavaluetypes = Any[ Any for _ = 1:nstmts ]
+    src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
     src.codelocs = fill(Int32(1), nstmts)
-    src.inferred = true
+    @test !src.inferred
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
     @test :a === @eval $m
+    compile_mode = @ccall jl_get_module_compile(@__MODULE__()::Module)::Cint
+    if compile_mode == 3
+        # implies `Base.Experimental.@compiler_options compile=min`
+        @test !src.inferred
+    end
     global test29262 = false
     @test :b === @eval $m
 end
@@ -61,13 +66,19 @@ let m = Meta.@lower 1 + 1
         ReturnNode(SSAValue(18)),
     ]
     nstmts = length(src.code)
-    src.ssavaluetypes = Any[ Any for _ = 1:nstmts ]
+    src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
     src.codelocs = fill(Int32(1), nstmts)
-    src.inferred = true
+    @test !src.inferred
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
     @test (:b, :a, :c, :c) === @eval $m
+    compile_mode = @ccall jl_get_module_compile(@__MODULE__()::Module)::Cint
+    if compile_mode == 3
+        # implies `Base.Experimental.@compiler_options compile=min`
+        @test !src.inferred
+    end
+    src.ssavaluetypes = nstmts
     global test29262 = false
     @test (:b, :a, :c, :b) === @eval $m
 end
@@ -98,27 +109,18 @@ let m = Meta.@lower 1 + 1
         ReturnNode(SSAValue(11)),
     ]
     nstmts = length(src.code)
-    src.ssavaluetypes = Any[ Any for _ = 1:nstmts ]
+    src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
     src.codelocs = fill(Int32(1), nstmts)
-    src.inferred = true
+    @test !src.inferred
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
     @test :a === @eval $m
+    compile_mode = @ccall jl_get_module_compile(@__MODULE__()::Module)::Cint
+    if compile_mode == 3
+        # implies `Base.Experimental.@compiler_options compile=min`
+        @test !src.inferred
+    end
     global test29262 = false
     @test :b === @eval $m
 end
-
-# https://github.com/JuliaLang/julia/issues/47065
-# `Core.Compiler.sort!` should be able to handle a big list
-let n = 1000
-    ex = :(return 1)
-    for _ in 1:n
-        ex = :(rand() < .1 && $(ex))
-    end
-    @eval global function f_1000_blocks()
-        $ex
-        return 0
-    end
-end
-@test f_1000_blocks() == 0
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 2e14fdb8d3013..9345c2e26db33 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1787,3 +1787,17 @@ let code = Any[
     @test !any(iscall((ir, getfield)), ir.stmts.stmt)
     @test length(ir.cfg.blocks[end].stmts) == 1
 end
+
+# https://github.com/JuliaLang/julia/issues/47065
+# `Core.Compiler.sort!` should be able to handle a big list
+let n = 1000
+    ex = :(return 1)
+    for _ in 1:n
+        ex = :(rand() < .1 && $(ex))
+    end
+    @eval global function f_1000_blocks()
+        $ex
+        return 0
+    end
+end
+@test f_1000_blocks() == 0
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index bab11d3ead522..3a90ee6308d53 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -92,11 +92,15 @@ let cfg = CFG(BasicBlock[
     end
 end
 
-for compile in ("min", "yes")
-    cmd = `$(Base.julia_cmd()) --compile=$compile interpreter_exec.jl`
-    if !success(pipeline(Cmd(cmd, dir=@__DIR__); stdout=stdout, stderr=stderr))
-        error("Interpreter test failed, cmd : $cmd")
-    end
+# test code execution with the default compile-mode
+module CompilerExecTest
+include("interpreter_exec.jl")
+end
+
+# test code execution with the interpreter mode (compile=min)
+module InterpreterExecTest
+Base.Experimental.@compiler_options compile=min
+include("interpreter_exec.jl")
 end
 
 # PR #32145

From 65ffa7978b230b159be5014de928740ed9b07567 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Sat, 10 Feb 2024 13:11:40 -0500
Subject: [PATCH 0876/1315] `names` docstring: qualify non-exported cross-refs
 (#52745)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It seems like cross-references to non-exported symbols, like `ispublic`,
should be qualified — otherwise it is confusing since looking them up
fails.

Co-authored-by: Max Horn <max@quendi.de>
---
 base/reflection.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index 8c3ec226d6e22..f1a385068757c 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -89,7 +89,7 @@ since it is not idiomatic to explicitly mark names from `Main` as public.
     `names` will return symbols marked with `public` or `export`, even if
     they are not defined in the module.
 
-See also: [`isexported`](@ref), [`ispublic`](@ref), [`@locals`](@ref Base.@locals), [`@__MODULE__`](@ref).
+See also: [`Base.isexported`](@ref), [`Base.ispublic`](@ref), [`Base.@locals`](@ref), [`@__MODULE__`](@ref).
 """
 names(m::Module; all::Bool = false, imported::Bool = false) =
     sort!(unsorted_names(m; all, imported))

From 8e70bf1a02436d7669e60c596777734ae97576f7 Mon Sep 17 00:00:00 2001
From: Neal Gafter <neal@gafter.com>
Date: Sat, 10 Feb 2024 10:23:09 -0800
Subject: [PATCH 0877/1315] Add documentation for some documentation forms.
 (#50679)

There are a couple of documentation forms that are used in the wild but
not covered by the documentation. Here I describe them.
---
 doc/src/manual/documentation.md | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/documentation.md b/doc/src/manual/documentation.md
index 41eb4e4d6dde5..47b8b84dda1b6 100644
--- a/doc/src/manual/documentation.md
+++ b/doc/src/manual/documentation.md
@@ -434,10 +434,13 @@ Adds docstring `"..."` to the `@m(::Any)` macro definition.
 
 ```julia
 "..."
-:(@m)
+:(@m1)
+
+"..."
+macro m2 end
 ```
 
-Adds docstring `"..."` to the macro named `@m`.
+Adds docstring `"..."` to the macros named `@m1` and `@m2`.
 
 ### Types
 
@@ -458,6 +461,20 @@ end
 
 Adds the docstring `"..."` to types `T1`, `T2`, and `T3`.
 
+```
+"..."
+T1
+
+"..."
+T2
+
+"..."
+T3
+```
+
+Adds the docstring `"..."` to types `T1`, `T2`, and `T3`.
+The previous version is the preferred syntax, however both are equivalent.
+
 ```julia
 "..."
 struct T

From a59f2192accf0e14c4fbb45f90219fb6d648e12c Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Sat, 10 Feb 2024 12:26:28 -0600
Subject: [PATCH 0878/1315] doc: float: add note for NaN compare with egal
 (#53194)

Current documentation seems to imply that one should use `===` for NaN
comparisons.
But non-normalized NaNs will give unexpected results: `NaN32p1 !==
NaN32`.
---
 base/float.jl | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/base/float.jl b/base/float.jl
index 5e40652490835..64dcb8b807550 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -14,6 +14,8 @@ const Inf16 = bitcast(Float16, 0x7c00)
     NaN16
 
 A not-a-number value of type [`Float16`](@ref).
+
+See also: [`NaN`](@ref).
 """
 const NaN16 = bitcast(Float16, 0x7e00)
 """
@@ -26,6 +28,8 @@ const Inf32 = bitcast(Float32, 0x7f800000)
     NaN32
 
 A not-a-number value of type [`Float32`](@ref).
+
+See also: [`NaN`](@ref).
 """
 const NaN32 = bitcast(Float32, 0x7fc00000)
 const Inf64 = bitcast(Float64, 0x7ff0000000000000)
@@ -69,9 +73,23 @@ NaN
 julia> Inf - Inf
 NaN
 
-julia> NaN == NaN, isequal(NaN, NaN), NaN === NaN
+julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
 (false, true, true)
 ```
+
+!!! note
+    Always use [`isnan`](@ref) or [`isequal`](@ref) for checking for `NaN`.
+    Using `x === NaN` may give unexpected results:
+    ```julia-repl
+    julia> reinterpret(UInt32, NaN32)
+    0x7fc00000
+
+    julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
+    NaN32
+
+    julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
+    (false, true, true)
+    ```
 """
 NaN, NaN64
 

From 51144415de6376d2b42d49ac08514cda15c1f298 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 10 Feb 2024 19:10:09 +0000
Subject: [PATCH 0879/1315] [GMP_jll] Upgrade to v6.3.0 (#53270)

---
 deps/checksums/gmp                            | 120 ++--
 deps/gmp.mk                                   |  25 +-
 deps/gmp.version                              |   3 +-
 deps/patches/gmp-CVE-2021-43618.patch         |  24 -
 deps/patches/gmp-HG-changeset.patch           | 520 ------------------
 ...ow_func.patch => gmp-alloc_overflow.patch} | 149 ++---
 deps/patches/gmp-more_alloc_overflow.patch    |  37 --
 stdlib/GMP_jll/Project.toml                   |   2 +-
 stdlib/GMP_jll/test/runtests.jl               |   2 +-
 9 files changed, 149 insertions(+), 733 deletions(-)
 delete mode 100644 deps/patches/gmp-CVE-2021-43618.patch
 delete mode 100644 deps/patches/gmp-HG-changeset.patch
 rename deps/patches/{gmp_alloc_overflow_func.patch => gmp-alloc_overflow.patch} (54%)
 delete mode 100644 deps/patches/gmp-more_alloc_overflow.patch

diff --git a/deps/checksums/gmp b/deps/checksums/gmp
index c9f6deac6e19b..0c7dd415e6f16 100644
--- a/deps/checksums/gmp
+++ b/deps/checksums/gmp
@@ -1,60 +1,60 @@
-GMP.v6.2.1+6.aarch64-apple-darwin.tar.gz/md5/8123f7925ae9aa60b6998313b21a9db9
-GMP.v6.2.1+6.aarch64-apple-darwin.tar.gz/sha512/5c7927ecfd47409dd4116cd4209768294ba229b51472ed220da498823dc1e7f9100292ec4b3a990491acd27f16ce3a3dce7a7c6e20dcd515982a9c8e364d91bc
-GMP.v6.2.1+6.aarch64-linux-gnu-cxx03.tar.gz/md5/0d0d2ee67cff251941e3474341280b34
-GMP.v6.2.1+6.aarch64-linux-gnu-cxx03.tar.gz/sha512/69fb2f1476e0bb73f89ad2f73b58ec4da1b99e099124666e6da93b7705fde23913daa59f2ad479f99fcb4f0df152603bb0ba4875420b583f01fded0fec280a15
-GMP.v6.2.1+6.aarch64-linux-gnu-cxx11.tar.gz/md5/86ba1313c8ab4ca1ae8313cbf96e1e7d
-GMP.v6.2.1+6.aarch64-linux-gnu-cxx11.tar.gz/sha512/05c306c01d1b0e9e4dc7ce937075eeaede4e5e0791826a8892fae2eb73cdb7f22c4873cf31cea3cfe3db996ac77387346f4f8a851ce52c29883146678f3851fd
-GMP.v6.2.1+6.aarch64-linux-musl-cxx03.tar.gz/md5/2fbbb9adee7db794f5888442b7b7688c
-GMP.v6.2.1+6.aarch64-linux-musl-cxx03.tar.gz/sha512/d8a1719e529374d00ba6372013d0c7ddc9f44f9f6ee0f966b4ed16d731ce74c26b6e6a807403b3396bed67dd3e775e18c1e70c247a371d622a6e7013eb6b8905
-GMP.v6.2.1+6.aarch64-linux-musl-cxx11.tar.gz/md5/b6a8c494d4c90decb6eacbca3ce3f22a
-GMP.v6.2.1+6.aarch64-linux-musl-cxx11.tar.gz/sha512/6798406e20cc4d58647c266a2b1b8d0670e62f19bf4bff991c39eef13cf92c043f00717e7289bcc00007d7e248e943b37ba2eef89c9e68c42e30f0e2be9dd589
-GMP.v6.2.1+6.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/a6866ee9784e9359e32dc18f417b2be7
-GMP.v6.2.1+6.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/548953ccc8444886316d4dfd7081783e397ec180e88a1d17a464e4b1d0a27f51ee7f6a1936ddab499db192d3cdfdc87d572731c5ab2f87d528609dabfccad2d3
-GMP.v6.2.1+6.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/6b78c826a4aedc8107c1bbfccbe5c097
-GMP.v6.2.1+6.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/e8c075c29e4d8a916f087faeb2db50168e1a5546fcb02fc841477cf82a39188c3b9e7703b5354d4842880b5ac7215a32d022abe08aacc5e23238b63c6b994af4
-GMP.v6.2.1+6.armv6l-linux-musleabihf-cxx03.tar.gz/md5/57e1a6c71b3c5b4047bf08bfc4d4f22d
-GMP.v6.2.1+6.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/0f72c675ab3005ea183393bc4e5b4a157c13042367fd1bb3b03b3f7742e09604bddffb89f1478dc0dab4d992939519578549d05f9885b89319b0b51678b8a619
-GMP.v6.2.1+6.armv6l-linux-musleabihf-cxx11.tar.gz/md5/65a13f49cbdaa9d3a8e20d0b84bbc701
-GMP.v6.2.1+6.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/0487b18d1c9c59d990e6c4ec435b8dff91ae02d5d56c665b12aaaea105f7d2ab5beae9dfcbb133c990f70774b0d32e55df7f2e91e2d0a85c391a4090dcadf080
-GMP.v6.2.1+6.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/30e20c183153f8ce60e564b35e4b54bd
-GMP.v6.2.1+6.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/41bdabc2610b46b215043e98eaddb2e2ad0695ae15f3088c9beef24a97864dce4088ae68993de928d952baaf123f279d74705664fffbf96be9b7436f1ba7692b
-GMP.v6.2.1+6.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/5f2cba31677e6681666c0b6ebd33c3ad
-GMP.v6.2.1+6.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/a89399bf84bebf4b8432e48aae6dce5547bb6f1c048364697c577541c4f1a555b976370634624e9cf039fcbcb70e449a2f55563f0a4f48e60ee4653a185cf7dd
-GMP.v6.2.1+6.armv7l-linux-musleabihf-cxx03.tar.gz/md5/4a682d832109d7ab5743832f73ca33d2
-GMP.v6.2.1+6.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/d5062bd8eee926eb1177e70e5d9e8d6ed7a00a17c25d2b165b974c01aa79d45ca97e219b26ded752b5f323546192d595b838b474c61bdd87e641549db9e9ef5d
-GMP.v6.2.1+6.armv7l-linux-musleabihf-cxx11.tar.gz/md5/caa51529cb1b6dc8db765e202e1b7737
-GMP.v6.2.1+6.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/d11ae870e68ca8d28bbcdf799a04769c3df2fbd169f6f2b16d88a556c40866b39636820ac3497e869086e638ba31dc1c87ec780add2d1aafe5e4ca178641678e
-GMP.v6.2.1+6.i686-linux-gnu-cxx03.tar.gz/md5/dfcb024b9cfba37f80da5b7cc0c5b1ad
-GMP.v6.2.1+6.i686-linux-gnu-cxx03.tar.gz/sha512/10eb086228b4250ecce11ad5bbec15e2bfff2429530cfd700602ead7f108163bc48fc83d9714443cbf5a93e7dd5f9046bdc15ef324486475f6b4be1cf34bad4b
-GMP.v6.2.1+6.i686-linux-gnu-cxx11.tar.gz/md5/e889c1d65c9ca710c859129ae99ef322
-GMP.v6.2.1+6.i686-linux-gnu-cxx11.tar.gz/sha512/4d97ebdd6a12d39907ccc9bad00266e286c949b3f99a306c1c4a4380a292694d944f275c351d9ddf465d020c8197b3b19dfccb5080249c75e3f5ffb9aa77a1c4
-GMP.v6.2.1+6.i686-linux-musl-cxx03.tar.gz/md5/d57b3948e7a120bafeae67c28fe40869
-GMP.v6.2.1+6.i686-linux-musl-cxx03.tar.gz/sha512/88165c809a73007d2b5e750d23c619fbb088f6de200aae1dee34b5e3783949150d91b94774cd1881d2a621d092c0e7e7332707ed4737ff8426686dfce7e0313a
-GMP.v6.2.1+6.i686-linux-musl-cxx11.tar.gz/md5/e3c53fc468a9f48f9d06fdf51eafae62
-GMP.v6.2.1+6.i686-linux-musl-cxx11.tar.gz/sha512/3c6a99acd84c226d7a48177c8e18624a677ea2a3df15fb2d54002eb5a6d55144b6f51f82ff491373366f32e92252fd14747503166621c2d2359029bdb1b20741
-GMP.v6.2.1+6.i686-w64-mingw32-cxx03.tar.gz/md5/64b9bed188f9a300200659efdb9facef
-GMP.v6.2.1+6.i686-w64-mingw32-cxx03.tar.gz/sha512/f7ed47cc29be31f99e612abd1db0d806ece84c117677cd639e04e2f6b08bbbfa4056ed9504bb073ec5f722de6955db668934f3d3ca05ddde0f22b096afcea2e3
-GMP.v6.2.1+6.i686-w64-mingw32-cxx11.tar.gz/md5/a8f38cefb46dc9c3faddfd597d0e1a4c
-GMP.v6.2.1+6.i686-w64-mingw32-cxx11.tar.gz/sha512/f02c3458c05869fab493d9be5ea98390baf6eed136fe2916cd6214c4f24a6f22d0716d59f352454fd4c799df71a8fd90e3a169644e1c6ffe89f3620f2a52f158
-GMP.v6.2.1+6.powerpc64le-linux-gnu-cxx03.tar.gz/md5/7f8da2b7e16ef4cb593fea4bdb2e43eb
-GMP.v6.2.1+6.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/d0105fe7dfcc1daf7024d2f58b53240bab473c3ae44a904833d009beeb8e41f5487430f68e79bd79fc5c74b55f1111eb7479fedc84bcb45fe4dff3d8c3ac3e4f
-GMP.v6.2.1+6.powerpc64le-linux-gnu-cxx11.tar.gz/md5/31fb7b6e37c650f0b8c3a2d475cb2b5b
-GMP.v6.2.1+6.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/d03f3f1303996008ff267682de5b9d6e3be78ca1b0d6aa7cadbf4a612b331fe70460b689125f4ededa1c6078092ad3dafaad32c68a98d31713764a7a7461cf98
-GMP.v6.2.1+6.x86_64-apple-darwin.tar.gz/md5/9276d90b4f850f167f673f731c7d3781
-GMP.v6.2.1+6.x86_64-apple-darwin.tar.gz/sha512/f914452a49988b0694915483547c2f878c0ba71be2079fd1228b3e583cb08e92d8c958a052f29025054ded74cacb699893a5a6ef27749c851e83607ad3f1fe8f
-GMP.v6.2.1+6.x86_64-linux-gnu-cxx03.tar.gz/md5/cded149fcef93ab1ba89c51d7cc58b73
-GMP.v6.2.1+6.x86_64-linux-gnu-cxx03.tar.gz/sha512/8f97582d6323df6f86e3079b9a2534425bd4e64bb4cec337c21059605d50c1220fd006e55bdb34e8aa7195cd79ef518f1541c1b1a92187ed928f7939b3128dd6
-GMP.v6.2.1+6.x86_64-linux-gnu-cxx11.tar.gz/md5/0529bb60dcf584222cd91e9e11510f24
-GMP.v6.2.1+6.x86_64-linux-gnu-cxx11.tar.gz/sha512/0532821e81a4e51363570f87ec59c37dea24cab59a94e43127837ce4b388d1951853d50e52d4c9f30b4a21cfe222e368207239ce8ac0f1ee1e9375f51fb10127
-GMP.v6.2.1+6.x86_64-linux-musl-cxx03.tar.gz/md5/2d332d096da5515581ee92128aff88ab
-GMP.v6.2.1+6.x86_64-linux-musl-cxx03.tar.gz/sha512/b17f7b762bd4d61fa4c4be8124275c2b337383da167bdeaca34e44d71f20716b182b46bc5a6714a798a0951d73b335ab9c87f451cf4c5456edbe76cf3ad36ba4
-GMP.v6.2.1+6.x86_64-linux-musl-cxx11.tar.gz/md5/a9dae953f9d59589162a3ea149c46d1e
-GMP.v6.2.1+6.x86_64-linux-musl-cxx11.tar.gz/sha512/31e568aba38a29ec6713dda9eb1c7d7b50c2a736e8883ae8ff2eaf16840b15c93e6dc53025e7750d3ac3e4ffc7d2c91787bda5b799ecfdeea3d928657176b1b3
-GMP.v6.2.1+6.x86_64-unknown-freebsd.tar.gz/md5/6f42d7486fa85ce1bf0cac409d1dd5ae
-GMP.v6.2.1+6.x86_64-unknown-freebsd.tar.gz/sha512/5111751619388e51d1b3c0e32548a6de0aa02b7967994a4b4b78cdc9e0e852dae9d78bf48a503a6fb67e3b08343ddcf5a9f0b7a64a803c4d5067d69e4cb2edee
-GMP.v6.2.1+6.x86_64-w64-mingw32-cxx03.tar.gz/md5/39cca70db2d23bc73a47870a0ee5156c
-GMP.v6.2.1+6.x86_64-w64-mingw32-cxx03.tar.gz/sha512/a2877a6641e4cccd39e7ef093dd9ba7501c6e312f160b2924880d129195aadb74badfbf198fd6ee11035a6a7c99d64c0965c44526104a43569ca0d97fa565b5a
-GMP.v6.2.1+6.x86_64-w64-mingw32-cxx11.tar.gz/md5/e2e03ed150558405ca1993ca14488662
-GMP.v6.2.1+6.x86_64-w64-mingw32-cxx11.tar.gz/sha512/50995f6382ed2a4c425097e7abf762b847872734c104847f6a042090be132c68e864d34bb24baf64832d3636810cb631464767949eb2df2fedaa7ccd9824f78b
-gmp-6.2.1.tar.bz2/md5/28971fc21cf028042d4897f02fd355ea
-gmp-6.2.1.tar.bz2/sha512/8904334a3bcc5c896ececabc75cda9dec642e401fb5397c4992c4fabea5e962c9ce8bd44e8e4233c34e55c8010cc28db0545f5f750cbdbb5f00af538dc763be9
+GMP.v6.3.0+0.aarch64-apple-darwin.tar.gz/md5/70a730ecf64eefb5a13f4524e29a6388
+GMP.v6.3.0+0.aarch64-apple-darwin.tar.gz/sha512/51791b4ae0ede1db4c6e7759072d125ca56f6a3a3e43fd5970981a3b2d651f28fe0abefce4b3ad0589d3a46c143054d20fee801bbd423bd2a4c12ba97314c39c
+GMP.v6.3.0+0.aarch64-linux-gnu-cxx03.tar.gz/md5/e2b0bf1317259972cdc4f0e6fc3c2bc8
+GMP.v6.3.0+0.aarch64-linux-gnu-cxx03.tar.gz/sha512/8de1dd5d6971c76693c67222725c9eb0a1d276a55a28cd49d94115123100bfe45144652421d4cde468dce67a5630736f4174c9491c8a6e2543aadcb44f1f2d12
+GMP.v6.3.0+0.aarch64-linux-gnu-cxx11.tar.gz/md5/2017b6215ed99c3aed8b04abe75cb3e9
+GMP.v6.3.0+0.aarch64-linux-gnu-cxx11.tar.gz/sha512/78b22106f96348f0d9222279fdf8d1e3f5bd400f771fb0c54dd4045985ee05b896e3097f788739eefab9a9ab09a885aad65c4adb31ae5ba59b7ab22ca10bb574
+GMP.v6.3.0+0.aarch64-linux-musl-cxx03.tar.gz/md5/6477f35f92203db871f56f047b99a1fe
+GMP.v6.3.0+0.aarch64-linux-musl-cxx03.tar.gz/sha512/66a6d18979c1ee9a5d06323a717d0a5dd73efc196087349408e739d7aa0444e8ee1af4bd634f85dfd4cfa4c97c24dda4ba472b490f50409581aff967c81b0750
+GMP.v6.3.0+0.aarch64-linux-musl-cxx11.tar.gz/md5/4648558f1e42b8e679f5be494a910402
+GMP.v6.3.0+0.aarch64-linux-musl-cxx11.tar.gz/sha512/9b7ff68a412bccd423b3cffefbc6350db6db8f3f7657713767187c2c2ea3b09d835e1c80d34ab4407f79fccbec82594e024787def27b9ad2ee7ea01ef1607b53
+GMP.v6.3.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/6cabb238d148b3e2e76e8527e65893cd
+GMP.v6.3.0+0.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/07b5673b4680781b7d42399213ecd491ede8883bbf1825689ad6678986a76581f6c4e53f17353f63bec8db8df5ed3fbddc228694eecc54ae7fc949f106bb8f14
+GMP.v6.3.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/0257216ad4e96b404d456f07fcc30b09
+GMP.v6.3.0+0.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/ae8bbbbe3992f78186fe7535e450330e94e6630540eefbdfb51bb5014afd90feac0b1583e3fd2bbf226e61523647b3ec6324188bd6267c353a2a98594566c02b
+GMP.v6.3.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/md5/48b949c062ea27dc0dbcc07ea5387821
+GMP.v6.3.0+0.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/03699c20b5c50dbd44f45a0f5f115c6b10b4e8de68d747bceba605c3090469c819b82ad7e57fe7702c1700c25aae6ab9394a22ded319bc58c80e9d20692b610e
+GMP.v6.3.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/md5/847ba3116072a523e1ff4ce83e5a18a8
+GMP.v6.3.0+0.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/402548acd57f4112bf2435803f35ea93fd8d07f3df0e2f053b0bec6b08aa3dff4052990a724e2547ce35a29ee376b17d34b7e7e2ab45ecb4981ffc99c56f1a9f
+GMP.v6.3.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/5cc75b66059c3b8b5fbf9b8fcb781b10
+GMP.v6.3.0+0.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/1ef583d014c825e1d4e6d5f7e2d84c3ba183ba9490410f5d424760e275b7032e98f8377d87ed349d4969c6ef8f9b961a1e8df6f40efb406d41983446a9510303
+GMP.v6.3.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/c0295c143bcb6b53d6184e2852ce35c5
+GMP.v6.3.0+0.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/3c74edb123a6f4147b416e5f7f25903bc859ac5f58f141bd463d3dff8cc2928fedf176f20869a1018a2731c1d7170444b3b3405c8f89c3fc22dc2edf9c036c24
+GMP.v6.3.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/md5/a67696b02a7f67405dd84252c908e071
+GMP.v6.3.0+0.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/73ba1809cfc68199401974f73e7a37b1fe00d4c0cf3e58ed85d161a8fbac4390aeb28591c3108fc503ef8fb5b131d027cb76dcf5d7731698997c2f377d929dce
+GMP.v6.3.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/md5/484f00cd5b0beec20f63cd6734d02611
+GMP.v6.3.0+0.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/46fc56f945647f5c8577ad45f540a034f747604e5a89230d9d419b10d5f0571c7580e18e1138ea920efc08b25798c0c7110e15359de17dce3b6db7f07b8ceb3a
+GMP.v6.3.0+0.i686-linux-gnu-cxx03.tar.gz/md5/d36d84638e2e5f927d15f07c55919f5f
+GMP.v6.3.0+0.i686-linux-gnu-cxx03.tar.gz/sha512/61c62084ab90d25f7168281c7fb672f5bcafdf909afbf66847cfaa1077dd5474b2c27464eb76cac45f5e319aca0c4f7367fc238b83d2dde46ba90a7c1f396dfb
+GMP.v6.3.0+0.i686-linux-gnu-cxx11.tar.gz/md5/d87627470bdcac981f7b004c27ac9a89
+GMP.v6.3.0+0.i686-linux-gnu-cxx11.tar.gz/sha512/2a34028687f75422b43f5365b0a8c9530b29473d41bfec4fb9822f074f813b8c6c1fc9efbfbb17a7e4d3d66f2549b5589b3fdbd08711a365330deb72be4958d0
+GMP.v6.3.0+0.i686-linux-musl-cxx03.tar.gz/md5/a2f2fc663bcacfc3e7d6aff29a52de23
+GMP.v6.3.0+0.i686-linux-musl-cxx03.tar.gz/sha512/a30a5d0ee78e747f074b3a5f0a26b9ba99b7553b3c83411a3cb9298814e605509194e9f0d8934caaa1cb7b78eef521805bbc86a297aebd06473ba80a20ffc443
+GMP.v6.3.0+0.i686-linux-musl-cxx11.tar.gz/md5/246b24935442815ff75a13b3dcf24756
+GMP.v6.3.0+0.i686-linux-musl-cxx11.tar.gz/sha512/ca351c4b93adf3f3e40f93c7b0cd61b33ec10049d39e8d33975f46d509efcded67600e6b19d8018a29ee893027d7a28edef0b19c1d70451d072a7a0989e9317d
+GMP.v6.3.0+0.i686-w64-mingw32-cxx03.tar.gz/md5/c3b321ae48db0cb8dac4e09e2722e56c
+GMP.v6.3.0+0.i686-w64-mingw32-cxx03.tar.gz/sha512/6a6feeb8baf6d499409a9010295b474a8c6de461fa0e34562d53e58190b66c50e278fae7560495cd85ea6f5b41f9e8c6e950ff4f451d26d0757e1d1696e8bca5
+GMP.v6.3.0+0.i686-w64-mingw32-cxx11.tar.gz/md5/3f633b0ff74c2a44350855fc6ce310b8
+GMP.v6.3.0+0.i686-w64-mingw32-cxx11.tar.gz/sha512/eecb17dec70fe84d90f47e1958672d273c865da9607ba3056c9c923a6ff9a3cab5b30414389d8f0c7f5ae5d87c05999964ed0900c80ae5afb525eaec00f401e2
+GMP.v6.3.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/md5/8b5f113ad7fd4a312229cfe8c2d1abca
+GMP.v6.3.0+0.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/36525ffc0ac5c363810c47945c34c81daabf88cf1f9c60d236447249d06332d3f5a130b431ab2d1c0148eb5413a4fa66bdd50671f2e7fcb77858d9fcdf83a94c
+GMP.v6.3.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/md5/7f1237e9668136b00dd719a5cad3b6aa
+GMP.v6.3.0+0.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/46a6efe23173a12299da371121847d16d7950ffe5c87d1221b54c5e95dafbf723c4a327b1c2e832d4742a91254aa40fd5d8152d6d0801769b2efd4f83a042afd
+GMP.v6.3.0+0.x86_64-apple-darwin.tar.gz/md5/cd2d1b309aea2c781a9c28470fd2f0eb
+GMP.v6.3.0+0.x86_64-apple-darwin.tar.gz/sha512/d7f94d80f1ba170c9553601d1af323bef7bbb98575b80b58b3d7b37d69d81cdee0e132fb4fa20393a0e8719984c785d0c7e5c8ae2c29c62ffbd82b00375993d4
+GMP.v6.3.0+0.x86_64-linux-gnu-cxx03.tar.gz/md5/5be8efef65dafe52e5726ef24238ae36
+GMP.v6.3.0+0.x86_64-linux-gnu-cxx03.tar.gz/sha512/f4c303fe915c89fecdb5a333a30412e0cfb04e07b4f1bc2f726179243dbc61d60ae5b0773a6bd5da8a10cb8764e448bc88035a639ea88d2e06f04e55074d8551
+GMP.v6.3.0+0.x86_64-linux-gnu-cxx11.tar.gz/md5/66f9a3858d07591227f2bc057c3c988b
+GMP.v6.3.0+0.x86_64-linux-gnu-cxx11.tar.gz/sha512/5611b9bfd24efac0a189bbd85533e1cd2bee7f833f5ae0a06343f2c1d92925e0d0f0758b99c43520293348ad61f98e1b470829514c35d208697988d8b469fc41
+GMP.v6.3.0+0.x86_64-linux-musl-cxx03.tar.gz/md5/edaa83f6432ff7e75e106d8bfd03d509
+GMP.v6.3.0+0.x86_64-linux-musl-cxx03.tar.gz/sha512/1587e7b91e387da9c23559826c161fa4d447250bd7b6565f0b9fedc36e7502dc2b59caa8157abcb7e7862d24d696470289bd650511b07e8711ecf5a462330b6d
+GMP.v6.3.0+0.x86_64-linux-musl-cxx11.tar.gz/md5/e668c4f0c1246aa1510c36f246b1b483
+GMP.v6.3.0+0.x86_64-linux-musl-cxx11.tar.gz/sha512/cf4bd47a5ddb067a57e852855fbd637a93f3652c3327af256f74e9e265c9e0de7c5be78b3e7bcbf08a03916876ecdc05cc294149e2c3d472a30fedc2e6dded47
+GMP.v6.3.0+0.x86_64-unknown-freebsd.tar.gz/md5/4cbf56d2884aa357291321b182d07cb8
+GMP.v6.3.0+0.x86_64-unknown-freebsd.tar.gz/sha512/0c723b8e0f5fabf9e43945d3fb355c3d7b036662a8d6542629aaff27164f12d13b2a19f5c4964f165466705b231884b7f7193d7a01a0e9d3644da1d79af79631
+GMP.v6.3.0+0.x86_64-w64-mingw32-cxx03.tar.gz/md5/02e8f5d66c15731117cf805e0a4c4976
+GMP.v6.3.0+0.x86_64-w64-mingw32-cxx03.tar.gz/sha512/1f94805fe9f34f4e77c54e92625615d91ade617468483409037d0693c3bf106187916d9d21e92681673faae158b376133c0ede643f31bfc9f73ac29c9fd13bcc
+GMP.v6.3.0+0.x86_64-w64-mingw32-cxx11.tar.gz/md5/10752137fccc73175872db07749d6f49
+GMP.v6.3.0+0.x86_64-w64-mingw32-cxx11.tar.gz/sha512/3a5d7e8125f3b538a2e59e9c6919db36c974575e6b1950451cb60307da68dc092c4ce21b8f49c40871aadf3bd07681b43eea9c7bf37ba383da9a0e80c30b176e
+gmp-6.3.0.tar.bz2/md5/c1cd6ef33085e9cb818b9b08371f9000
+gmp-6.3.0.tar.bz2/sha512/3b684c9bcb9ede2b7e54d0ba4c9764bfa17c20d4f3000017c553b6f1e135b536949580ff37341680c25dc236cfe0ba1db8cfdfe619ce013656189ef0871b89f8
diff --git a/deps/gmp.mk b/deps/gmp.mk
index 491d649e9202f..23075c861cd35 100644
--- a/deps/gmp.mk
+++ b/deps/gmp.mk
@@ -35,34 +35,17 @@ $(SRCCACHE)/gmp-$(GMP_VER)/source-extracted: $(SRCCACHE)/gmp-$(GMP_VER).tar.bz2
 checksum-gmp: $(SRCCACHE)/gmp-$(GMP_VER).tar.bz2
 	$(JLCHECKSUM) $<
 
-# Apply fix to avoid using Apple ARM reserved register X18
-# Necessary for version 6.2.1, remove after next gmp release
-$(SRCCACHE)/gmp-$(GMP_VER)/gmp-HG-changeset.patch-applied: $(SRCCACHE)/gmp-$(GMP_VER)/source-extracted
-	cd $(dir $@) && \
-		patch -p1 -f < $(SRCDIR)/patches/gmp-HG-changeset.patch
-	echo 1 > $@
-
-$(SRCCACHE)/gmp-$(GMP_VER)/gmp-exception.patch-applied: $(SRCCACHE)/gmp-$(GMP_VER)/gmp-HG-changeset.patch-applied
+$(SRCCACHE)/gmp-$(GMP_VER)/gmp-exception.patch-applied: $(SRCCACHE)/gmp-$(GMP_VER)/source-extracted
 	cd $(dir $@) && \
 		patch -p1 -f < $(SRCDIR)/patches/gmp-exception.patch
 	echo 1 > $@
 
-$(SRCCACHE)/gmp-$(GMP_VER)/gmp_alloc_overflow_func.patch-applied: $(SRCCACHE)/gmp-$(GMP_VER)/gmp-exception.patch-applied
-	cd $(dir $@) && \
-		patch -p1 -f < $(SRCDIR)/patches/gmp_alloc_overflow_func.patch
-	echo 1 > $@
-
-$(SRCCACHE)/gmp-$(GMP_VER)/gmp-CVE-2021-43618.patch-applied: $(SRCCACHE)/gmp-$(GMP_VER)/gmp_alloc_overflow_func.patch-applied
-	cd $(dir $@) && \
-		patch -p1 -f < $(SRCDIR)/patches/gmp-CVE-2021-43618.patch
-	echo 1 > $@
-
-$(SRCCACHE)/gmp-$(GMP_VER)/gmp-more_alloc_overflow.patch-applied: $(SRCCACHE)/gmp-$(GMP_VER)/gmp-CVE-2021-43618.patch-applied
+$(SRCCACHE)/gmp-$(GMP_VER)/gmp-alloc_overflow.patch-applied: $(SRCCACHE)/gmp-$(GMP_VER)/gmp-exception.patch-applied
 	cd $(dir $@) && \
-		patch -p1 -f < $(SRCDIR)/patches/gmp-more_alloc_overflow.patch
+		patch -p1 -f < $(SRCDIR)/patches/gmp-alloc_overflow.patch
 	echo 1 > $@
 
-$(SRCCACHE)/gmp-$(GMP_VER)/source-patched: $(SRCCACHE)/gmp-$(GMP_VER)/gmp-more_alloc_overflow.patch-applied
+$(SRCCACHE)/gmp-$(GMP_VER)/source-patched: $(SRCCACHE)/gmp-$(GMP_VER)/gmp-alloc_overflow.patch-applied
 	echo 1 > $@
 
 $(BUILDDIR)/gmp-$(GMP_VER)/build-configured: $(SRCCACHE)/gmp-$(GMP_VER)/source-patched
diff --git a/deps/gmp.version b/deps/gmp.version
index f77cac5906cea..3b6659faea7b7 100644
--- a/deps/gmp.version
+++ b/deps/gmp.version
@@ -1,5 +1,6 @@
+# -*- makefile -*-
 ## jll artifact
 GMP_JLL_NAME := GMP
 
 ## source build
-GMP_VER := 6.2.1
+GMP_VER := 6.3.0
diff --git a/deps/patches/gmp-CVE-2021-43618.patch b/deps/patches/gmp-CVE-2021-43618.patch
deleted file mode 100644
index a4e420e9219da..0000000000000
--- a/deps/patches/gmp-CVE-2021-43618.patch
+++ /dev/null
@@ -1,24 +0,0 @@
-# Origin: https://gmplib.org/repo/gmp-6.2/rev/561a9c25298e
-# HG changeset patch
-# User Marco Bodrato <bodrato@mail.dm.unipi.it>
-# Date 1634836009 -7200
-# Node ID 561a9c25298e17bb01896801ff353546c6923dbd
-# Parent  e1fd9db13b475209a864577237ea4b9105b3e96e
-mpz/inp_raw.c: Avoid bit size overflows
-
-diff -r e1fd9db13b47 -r 561a9c25298e mpz/inp_raw.c
---- a/mpz/inp_raw.c	Tue Dec 22 23:49:51 2020 +0100
-+++ b/mpz/inp_raw.c	Thu Oct 21 19:06:49 2021 +0200
-@@ -88,8 +88,11 @@
- 
-   abs_csize = ABS (csize);
- 
-+  if (UNLIKELY (abs_csize > ~(mp_bitcnt_t) 0 / 8))
-+    return 0; /* Bit size overflows */
-+
-   /* round up to a multiple of limbs */
--  abs_xsize = BITS_TO_LIMBS (abs_csize*8);
-+  abs_xsize = BITS_TO_LIMBS ((mp_bitcnt_t) abs_csize * 8);
- 
-   if (abs_xsize != 0)
-     {
diff --git a/deps/patches/gmp-HG-changeset.patch b/deps/patches/gmp-HG-changeset.patch
deleted file mode 100644
index 7437fb6f2f748..0000000000000
--- a/deps/patches/gmp-HG-changeset.patch
+++ /dev/null
@@ -1,520 +0,0 @@
-
-# HG changeset patch
-# User Torbjorn Granlund <tg@gmplib.org>
-# Date 1606685500 -3600
-# Node ID 5f32dbc41afc1f8cd77af1614f0caeb24deb7d7b
-# Parent  94c84d919f83ba963ed1809f8e80c7bef32db55c
-Avoid the x18 register since it is reserved on Darwin.
-
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/aors_n.asm
---- a/mpn/arm64/aors_n.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/aors_n.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -68,7 +68,7 @@
- EPILOGUE()
- PROLOGUE(func_n)
- 	CLRCY
--L(ent):	lsr	x18, n, #2
-+L(ent):	lsr	x17, n, #2
- 	tbz	n, #0, L(bx0)
- 
- L(bx1):	ldr	x7, [up]
-@@ -77,7 +77,7 @@
- 	str	x13, [rp],#8
- 	tbnz	n, #1, L(b11)
- 
--L(b01):	cbz	x18, L(ret)
-+L(b01):	cbz	x17, L(ret)
- 	ldp	x4, x5, [up,#8]
- 	ldp	x8, x9, [vp,#8]
- 	sub	up, up, #8
-@@ -88,7 +88,7 @@
- 	ldp	x10, x11, [vp,#8]
- 	add	up, up, #8
- 	add	vp, vp, #8
--	cbz	x18, L(end)
-+	cbz	x17, L(end)
- 	b	L(top)
- 
- L(bx0):	tbnz	n, #1, L(b10)
-@@ -101,7 +101,7 @@
- 
- L(b10):	ldp	x6, x7, [up]
- 	ldp	x10, x11, [vp]
--	cbz	x18, L(end)
-+	cbz	x17, L(end)
- 
- 	ALIGN(16)
- L(top):	ldp	x4, x5, [up,#16]
-@@ -114,8 +114,8 @@
- 	ADDSUBC	x12, x4, x8
- 	ADDSUBC	x13, x5, x9
- 	stp	x12, x13, [rp],#16
--	sub	x18, x18, #1
--	cbnz	x18, L(top)
-+	sub	x17, x17, #1
-+	cbnz	x17, L(top)
- 
- L(end):	ADDSUBC	x12, x6, x10
- 	ADDSUBC	x13, x7, x11
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/aorsmul_1.asm
---- a/mpn/arm64/aorsmul_1.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/aorsmul_1.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -32,10 +32,15 @@
- 
- include(`../config.m4')
- 
--C	     cycles/limb
--C Cortex-A53	9.3-9.8
--C Cortex-A57	 7.0
--C X-Gene	 5.0
-+C	       addmul_1        submul_1
-+C	     cycles/limb     cycles/limb
-+C Cortex-A53	9.3-9.8		9.3-9.8
-+C Cortex-A55    9.0-9.5		9.3-9.8
-+C Cortex-A57	 7		 7
-+C Cortex-A72
-+C Cortex-A73	 6		 6
-+C X-Gene	 5		 5
-+C Apple M1	 1.75		 1.75
- 
- C NOTES
- C  * It is possible to keep the carry chain alive between the addition blocks
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/aorsorrlshC_n.asm
---- a/mpn/arm64/aorsorrlshC_n.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/aorsorrlshC_n.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -65,14 +65,14 @@
- 
- ASM_START()
- PROLOGUE(func_n)
--	lsr	x18, n, #2
-+	lsr	x6, n, #2
- 	tbz	n, #0, L(bx0)
- 
- L(bx1):	ldr	x5, [up]
- 	tbnz	n, #1, L(b11)
- 
- L(b01):	ldr	x11, [vp]
--	cbz	x18, L(1)
-+	cbz	x6, L(1)
- 	ldp	x8, x9, [vp,#8]
- 	lsl	x13, x11, #LSH
- 	ADDSUB(	x15, x13, x5)
-@@ -94,7 +94,7 @@
- 	ADDSUB(	x17, x13, x5)
- 	str	x17, [rp],#8
- 	sub	up, up, #8
--	cbz	x18, L(end)
-+	cbz	x6, L(end)
- 	b	L(top)
- 
- L(bx0):	tbnz	n, #1, L(b10)
-@@ -107,7 +107,7 @@
- L(b10):	CLRRCY(	x9)
- 	ldp	x10, x11, [vp]
- 	sub	up, up, #16
--	cbz	x18, L(end)
-+	cbz	x6, L(end)
- 
- 	ALIGN(16)
- L(top):	ldp	x4, x5, [up,#16]
-@@ -124,8 +124,8 @@
- 	ADDSUBC(x16, x12, x4)
- 	ADDSUBC(x17, x13, x5)
- 	stp	x16, x17, [rp],#16
--	sub	x18, x18, #1
--	cbnz	x18, L(top)
-+	sub	x6, x6, #1
-+	cbnz	x6, L(top)
- 
- L(end):	ldp	x4, x5, [up,#16]
- 	extr	x12, x10, x9, #RSH
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/cnd_aors_n.asm
---- a/mpn/arm64/cnd_aors_n.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/cnd_aors_n.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -65,7 +65,7 @@
- 
- 	CLRCY
- 
--	lsr	x18, n, #2
-+	lsr	x17, n, #2
- 	tbz	n, #0, L(bx0)
- 
- L(bx1):	ldr	x13, [vp]
-@@ -75,7 +75,7 @@
- 	str	x9, [rp]
- 	tbnz	n, #1, L(b11)
- 
--L(b01):	cbz	x18, L(rt)
-+L(b01):	cbz	x17, L(rt)
- 	ldp	x12, x13, [vp,#8]
- 	ldp	x10, x11, [up,#8]
- 	sub	up, up, #8
-@@ -86,7 +86,7 @@
- L(b11):	ldp	x12, x13, [vp,#8]!
- 	ldp	x10, x11, [up,#8]!
- 	sub	rp, rp, #8
--	cbz	x18, L(end)
-+	cbz	x17, L(end)
- 	b	L(top)
- 
- L(bx0):	ldp	x12, x13, [vp]
-@@ -99,7 +99,7 @@
- 	b	L(mid)
- 
- L(b10):	sub	rp, rp, #16
--	cbz	x18, L(end)
-+	cbz	x17, L(end)
- 
- 	ALIGN(16)
- L(top):	bic	x6, x12, cnd
-@@ -116,8 +116,8 @@
- 	ADDSUBC	x9, x11, x7
- 	ldp	x10, x11, [up,#32]!
- 	stp	x8, x9, [rp,#32]!
--	sub	x18, x18, #1
--	cbnz	x18, L(top)
-+	sub	x17, x17, #1
-+	cbnz	x17, L(top)
- 
- L(end):	bic	x6, x12, cnd
- 	bic	x7, x13, cnd
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/logops_n.asm
---- a/mpn/arm64/logops_n.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/logops_n.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -78,7 +78,7 @@
- 
- ASM_START()
- PROLOGUE(func)
--	lsr	x18, n, #2
-+	lsr	x17, n, #2
- 	tbz	n, #0, L(bx0)
- 
- L(bx1):	ldr	x7, [up]
-@@ -88,7 +88,7 @@
- 	str	x15, [rp],#8
- 	tbnz	n, #1, L(b11)
- 
--L(b01):	cbz	x18, L(ret)
-+L(b01):	cbz	x17, L(ret)
- 	ldp	x4, x5, [up,#8]
- 	ldp	x8, x9, [vp,#8]
- 	sub	up, up, #8
-@@ -99,7 +99,7 @@
- 	ldp	x10, x11, [vp,#8]
- 	add	up, up, #8
- 	add	vp, vp, #8
--	cbz	x18, L(end)
-+	cbz	x17, L(end)
- 	b	L(top)
- 
- L(bx0):	tbnz	n, #1, L(b10)
-@@ -110,7 +110,7 @@
- 
- L(b10):	ldp	x6, x7, [up]
- 	ldp	x10, x11, [vp]
--	cbz	x18, L(end)
-+	cbz	x17, L(end)
- 
- 	ALIGN(16)
- L(top):	ldp	x4, x5, [up,#16]
-@@ -127,8 +127,8 @@
- 	POSTOP(	x12)
- 	POSTOP(	x13)
- 	stp	x12, x13, [rp],#16
--	sub	x18, x18, #1
--	cbnz	x18, L(top)
-+	sub	x17, x17, #1
-+	cbnz	x17, L(top)
- 
- L(end):	LOGOP(	x12, x6, x10)
- 	LOGOP(	x13, x7, x11)
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/lshift.asm
---- a/mpn/arm64/lshift.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/lshift.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -61,7 +61,7 @@
- 	add	rp, rp_arg, n, lsl #3
- 	add	up, up, n, lsl #3
- 	sub	tnc, xzr, cnt
--	lsr	x18, n, #2
-+	lsr	x17, n, #2
- 	tbz	n, #0, L(bx0)
- 
- L(bx1):	ldr	x4, [up,#-8]
-@@ -69,7 +69,7 @@
- 
- L(b01):	NSHIFT	x0, x4, tnc
- 	PSHIFT	x2, x4, cnt
--	cbnz	x18, L(gt1)
-+	cbnz	x17, L(gt1)
- 	str	x2, [rp,#-8]
- 	ret
- L(gt1):	ldp	x4, x5, [up,#-24]
-@@ -89,7 +89,7 @@
- 	PSHIFT	x13, x5, cnt
- 	NSHIFT	x10, x4, tnc
- 	PSHIFT	x2, x4, cnt
--	cbnz	x18, L(gt2)
-+	cbnz	x17, L(gt2)
- 	orr	x10, x10, x13
- 	stp	x2, x10, [rp,#-16]
- 	ret
-@@ -123,11 +123,11 @@
- 	orr	x11, x12, x2
- 	stp	x10, x11, [rp,#-32]!
- 	PSHIFT	x2, x4, cnt
--L(lo0):	sub	x18, x18, #1
-+L(lo0):	sub	x17, x17, #1
- L(lo3):	NSHIFT	x10, x6, tnc
- 	PSHIFT	x13, x7, cnt
- 	NSHIFT	x12, x7, tnc
--	cbnz	x18, L(top)
-+	cbnz	x17, L(top)
- 
- L(end):	orr	x10, x10, x13
- 	orr	x11, x12, x2
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/lshiftc.asm
---- a/mpn/arm64/lshiftc.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/lshiftc.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -61,7 +61,7 @@
- 	add	rp, rp_arg, n, lsl #3
- 	add	up, up, n, lsl #3
- 	sub	tnc, xzr, cnt
--	lsr	x18, n, #2
-+	lsr	x17, n, #2
- 	tbz	n, #0, L(bx0)
- 
- L(bx1):	ldr	x4, [up,#-8]
-@@ -69,7 +69,7 @@
- 
- L(b01):	NSHIFT	x0, x4, tnc
- 	PSHIFT	x2, x4, cnt
--	cbnz	x18, L(gt1)
-+	cbnz	x17, L(gt1)
- 	mvn	x2, x2
- 	str	x2, [rp,#-8]
- 	ret
-@@ -90,7 +90,7 @@
- 	PSHIFT	x13, x5, cnt
- 	NSHIFT	x10, x4, tnc
- 	PSHIFT	x2, x4, cnt
--	cbnz	x18, L(gt2)
-+	cbnz	x17, L(gt2)
- 	eon	x10, x10, x13
- 	mvn	x2, x2
- 	stp	x2, x10, [rp,#-16]
-@@ -125,11 +125,11 @@
- 	eon	x11, x12, x2
- 	stp	x10, x11, [rp,#-32]!
- 	PSHIFT	x2, x4, cnt
--L(lo0):	sub	x18, x18, #1
-+L(lo0):	sub	x17, x17, #1
- L(lo3):	NSHIFT	x10, x6, tnc
- 	PSHIFT	x13, x7, cnt
- 	NSHIFT	x12, x7, tnc
--	cbnz	x18, L(top)
-+	cbnz	x17, L(top)
- 
- L(end):	eon	x10, x10, x13
- 	eon	x11, x12, x2
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/mul_1.asm
---- a/mpn/arm64/mul_1.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/mul_1.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -56,7 +56,7 @@
- 
- PROLOGUE(mpn_mul_1)
- 	adds	x4, xzr, xzr		C clear register and cy flag
--L(com):	lsr	x18, n, #2
-+L(com):	lsr	x17, n, #2
- 	tbnz	n, #0, L(bx1)
- 
- L(bx0):	mov	x11, x4
-@@ -65,7 +65,7 @@
- L(b10):	ldp	x4, x5, [up]
- 	mul	x8, x4, v0
- 	umulh	x10, x4, v0
--	cbz	x18, L(2)
-+	cbz	x17, L(2)
- 	ldp	x6, x7, [up,#16]!
- 	mul	x9, x5, v0
- 	b	L(mid)-8
-@@ -80,7 +80,7 @@
- 	str	x9, [rp],#8
- 	tbnz	n, #1, L(b10)
- 
--L(b01):	cbz	x18, L(1)
-+L(b01):	cbz	x17, L(1)
- 
- L(b00):	ldp	x6, x7, [up]
- 	mul	x8, x6, v0
-@@ -90,8 +90,8 @@
- 	adcs	x12, x8, x11
- 	umulh	x11, x7, v0
- 	add	rp, rp, #16
--	sub	x18, x18, #1
--	cbz	x18, L(end)
-+	sub	x17, x17, #1
-+	cbz	x17, L(end)
- 
- 	ALIGN(16)
- L(top):	mul	x8, x4, v0
-@@ -110,8 +110,8 @@
- 	stp	x12, x13, [rp],#32
- 	adcs	x12, x8, x11
- 	umulh	x11, x7, v0
--	sub	x18, x18, #1
--	cbnz	x18, L(top)
-+	sub	x17, x17, #1
-+	cbnz	x17, L(top)
- 
- L(end):	mul	x8, x4, v0
- 	adcs	x13, x9, x10
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/rsh1aors_n.asm
---- a/mpn/arm64/rsh1aors_n.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/rsh1aors_n.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -59,7 +59,7 @@
- 
- ASM_START()
- PROLOGUE(func_n)
--	lsr	x18, n, #2
-+	lsr	x6, n, #2
- 
- 	tbz	n, #0, L(bx0)
- 
-@@ -69,7 +69,7 @@
- 
- L(b01):	ADDSUB	x13, x5, x9
- 	and	x10, x13, #1
--	cbz	x18, L(1)
-+	cbz	x6, L(1)
- 	ldp	x4, x5, [up],#48
- 	ldp	x8, x9, [vp],#48
- 	ADDSUBC	x14, x4, x8
-@@ -80,8 +80,8 @@
- 	ADDSUBC	x12, x4, x8
- 	ADDSUBC	x13, x5, x9
- 	str	x17, [rp], #24
--	sub	x18, x18, #1
--	cbz	x18, L(end)
-+	sub	x6, x6, #1
-+	cbz	x6, L(end)
- 	b	L(top)
- 
- L(1):	cset	x14, COND
-@@ -97,7 +97,7 @@
- 	ldp	x8, x9, [vp],#32
- 	ADDSUBC	x12, x4, x8
- 	ADDSUBC	x13, x5, x9
--	cbz	x18, L(3)
-+	cbz	x6, L(3)
- 	ldp	x4, x5, [up,#-16]
- 	ldp	x8, x9, [vp,#-16]
- 	extr	x17, x12, x15, #1
-@@ -117,7 +117,7 @@
- 	ADDSUB	x12, x4, x8
- 	ADDSUBC	x13, x5, x9
- 	and	x10, x12, #1
--	cbz	x18, L(2)
-+	cbz	x6, L(2)
- 	ldp	x4, x5, [up,#-16]
- 	ldp	x8, x9, [vp,#-16]
- 	ADDSUBC	x14, x4, x8
-@@ -134,8 +134,8 @@
- 	ADDSUBC	x12, x4, x8
- 	ADDSUBC	x13, x5, x9
- 	add	rp, rp, #16
--	sub	x18, x18, #1
--	cbz	x18, L(end)
-+	sub	x6, x6, #1
-+	cbz	x6, L(end)
- 
- 	ALIGN(16)
- L(top):	ldp	x4, x5, [up,#-16]
-@@ -152,8 +152,8 @@
- 	ADDSUBC	x12, x4, x8
- 	ADDSUBC	x13, x5, x9
- 	stp	x16, x17, [rp],#32
--	sub	x18, x18, #1
--	cbnz	x18, L(top)
-+	sub	x6, x6, #1
-+	cbnz	x6, L(top)
- 
- L(end):	extr	x16, x15, x14, #1
- 	extr	x17, x12, x15, #1
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/rshift.asm
---- a/mpn/arm64/rshift.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/rshift.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -60,7 +60,7 @@
- PROLOGUE(mpn_rshift)
- 	mov	rp, rp_arg
- 	sub	tnc, xzr, cnt
--	lsr	x18, n, #2
-+	lsr	x17, n, #2
- 	tbz	n, #0, L(bx0)
- 
- L(bx1):	ldr	x5, [up]
-@@ -68,7 +68,7 @@
- 
- L(b01):	NSHIFT	x0, x5, tnc
- 	PSHIFT	x2, x5, cnt
--	cbnz	x18, L(gt1)
-+	cbnz	x17, L(gt1)
- 	str	x2, [rp]
- 	ret
- L(gt1):	ldp	x4, x5, [up,#8]
-@@ -89,7 +89,7 @@
- 	PSHIFT	x13, x4, cnt
- 	NSHIFT	x10, x5, tnc
- 	PSHIFT	x2, x5, cnt
--	cbnz	x18, L(gt2)
-+	cbnz	x17, L(gt2)
- 	orr	x10, x10, x13
- 	stp	x10, x2, [rp]
- 	ret
-@@ -121,11 +121,11 @@
- 	orr	x11, x12, x2
- 	stp	x11, x10, [rp,#32]!
- 	PSHIFT	x2, x5, cnt
--L(lo0):	sub	x18, x18, #1
-+L(lo0):	sub	x17, x17, #1
- L(lo3):	NSHIFT	x10, x7, tnc
- 	NSHIFT	x12, x6, tnc
- 	PSHIFT	x13, x6, cnt
--	cbnz	x18, L(top)
-+	cbnz	x17, L(top)
- 
- L(end):	orr	x10, x10, x13
- 	orr	x11, x12, x2
-diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/sqr_diag_addlsh1.asm
---- a/mpn/arm64/sqr_diag_addlsh1.asm	Sat Nov 28 23:38:32 2020 +0100
-+++ b/mpn/arm64/sqr_diag_addlsh1.asm	Sun Nov 29 22:31:40 2020 +0100
-@@ -47,7 +47,7 @@
- ASM_START()
- PROLOGUE(mpn_sqr_diag_addlsh1)
- 	ldr	x15, [up],#8
--	lsr	x18, n, #1
-+	lsr	x14, n, #1
- 	tbz	n, #0, L(bx0)
- 
- L(bx1):	adds	x7, xzr, xzr
-@@ -62,8 +62,8 @@
- 	ldr	x17, [up],#16
- 	ldp	x6, x7, [tp],#32
- 	umulh	x11, x15, x15
--	sub	x18, x18, #1
--	cbz	x18, L(end)
-+	sub	x14, x14, #1
-+	cbz	x14, L(end)
- 
- 	ALIGN(16)
- L(top):	extr	x9, x6, x5, #63
-@@ -84,8 +84,8 @@
- 	extr	x8, x5, x4, #63
- 	stp	x12, x13, [rp],#16
- 	adcs	x12, x8, x10
--	sub	x18, x18, #1
--	cbnz	x18, L(top)
-+	sub	x14, x14, #1
-+	cbnz	x14, L(top)
- 
- L(end):	extr	x9, x6, x5, #63
- 	mul	x10, x17, x17
diff --git a/deps/patches/gmp_alloc_overflow_func.patch b/deps/patches/gmp-alloc_overflow.patch
similarity index 54%
rename from deps/patches/gmp_alloc_overflow_func.patch
rename to deps/patches/gmp-alloc_overflow.patch
index 51506d70d46fb..6a0f02c66e3f4 100644
--- a/deps/patches/gmp_alloc_overflow_func.patch
+++ b/deps/patches/gmp-alloc_overflow.patch
@@ -1,7 +1,7 @@
-diff --git a/gmp-h.in b/gmp-h.in
---- a/gmp-h.in
-+++ b/gmp-h.in
-@@ -479,6 +479,13 @@ using std::FILE;
+diff -ru gmp-6.3.0/gmp-h.in gmp-6.3.0.new/gmp-h.in
+--- gmp-6.3.0/gmp-h.in	2023-07-29 09:42:16
++++ gmp-6.3.0.new/gmp-h.in	2023-12-29 15:33:34
+@@ -487,6 +487,12 @@
  				      void *(**) (void *, size_t, size_t),
  				      void (**) (void *, size_t)) __GMP_NOTHROW;
  
@@ -10,15 +10,23 @@ diff --git a/gmp-h.in b/gmp-h.in
 +
 +#define mp_get_alloc_overflow_function __gmp_get_alloc_overflow_function
 +__GMP_DECLSPEC void mp_get_alloc_overflow_function (void (**) (void)) __GMP_NOTHROW;
-+
 +
  #define mp_bits_per_limb __gmp_bits_per_limb
  __GMP_DECLSPEC extern const int mp_bits_per_limb;
  
-diff --git a/gmp-impl.h b/gmp-impl.h
---- a/gmp-impl.h
-+++ b/gmp-impl.h
-@@ -696,10 +696,12 @@ struct tmp_debug_entry_t {
+diff -ru gmp-6.3.0/gmp-impl.h gmp-6.3.0.new/gmp-impl.h
+--- gmp-6.3.0/gmp-impl.h	2023-07-29 09:42:16
++++ gmp-6.3.0.new/gmp-impl.h	2023-12-30 16:02:36
+@@ -58,6 +58,8 @@
+    short can be 24, 32, 46 or 64 bits, and different for ushort.  */
+ 
+ #include <limits.h>
++#include <stdio.h>
++#include <stdlib.h>
+ 
+ /* For fat.h and other fat binary stuff.
+    No need for __GMP_ATTRIBUTE_PURE or __GMP_NOTHROW, since functions
+@@ -699,14 +701,22 @@
  __GMP_DECLSPEC extern void * (*__gmp_allocate_func) (size_t);
  __GMP_DECLSPEC extern void * (*__gmp_reallocate_func) (void *, size_t, size_t);
  __GMP_DECLSPEC extern void   (*__gmp_free_func) (void *, size_t);
@@ -31,10 +39,7 @@ diff --git a/gmp-impl.h b/gmp-impl.h
  
  #define __GMP_ALLOCATE_FUNC_TYPE(n,type) \
    ((type *) (*__gmp_allocate_func) ((n) * sizeof (type)))
-@@ -727,6 +729,12 @@ struct tmp_debug_entry_t {
- 	(ptr, (oldsize) * sizeof (type), (newsize) * sizeof (type));	\
-   } while (0)
- 
+ #define __GMP_ALLOCATE_FUNC_LIMBS(n)   __GMP_ALLOCATE_FUNC_TYPE (n, mp_limb_t)
 +#define __GMP_ALLOC_OVERFLOW_FUNC()                              \
 +  do {                                                           \
 +    (*__gmp_alloc_overflow_func) ();                             \
@@ -42,12 +47,12 @@ diff --git a/gmp-impl.h b/gmp-impl.h
 +    abort ();                                                    \
 +  } while (0)
  
- /* Dummy for non-gcc, code involving it will go dead. */
- #if ! defined (__GNUC__) || __GNUC__ < 2
-diff --git a/memory.c b/memory.c
---- a/memory.c
-+++ b/memory.c
-@@ -38,6 +38,7 @@ see https://www.gnu.org/licenses/.  */
+ #define __GMP_REALLOCATE_FUNC_TYPE(p, old_size, new_size, type)		\
+   ((type *) (*__gmp_reallocate_func)					\
+diff -ru gmp-6.3.0/memory.c gmp-6.3.0.new/memory.c
+--- gmp-6.3.0/memory.c	2023-07-29 09:42:16
++++ gmp-6.3.0.new/memory.c	2023-12-29 15:43:27
+@@ -37,6 +37,7 @@
  void * (*__gmp_allocate_func) (size_t) = __gmp_default_allocate;
  void * (*__gmp_reallocate_func) (void *, size_t, size_t) = __gmp_default_reallocate;
  void   (*__gmp_free_func) (void *, size_t) = __gmp_default_free;
@@ -55,21 +60,22 @@ diff --git a/memory.c b/memory.c
  
  
  /* Default allocation functions.  In case of failure to allocate/reallocate
-@@ -144,3 +145,10 @@ void
+@@ -142,4 +143,11 @@
+   }
  #endif
    free (blk_ptr);
- }
++}
 +
 +void
 +__gmp_default_alloc_overflow(void)
 +{
 +    fprintf (stderr, "gmp: overflow in mpz type\n");
 +    abort();
-+}
-diff --git a/mp_get_fns.c b/mp_get_fns.c
---- a/mp_get_fns.c
-+++ b/mp_get_fns.c
-@@ -46,3 +46,11 @@ mp_get_memory_functions (void *(**alloc_
+ }
+diff -ru gmp-6.3.0/mp_get_fns.c gmp-6.3.0.new/mp_get_fns.c
+--- gmp-6.3.0/mp_get_fns.c	2023-07-29 09:42:16
++++ gmp-6.3.0.new/mp_get_fns.c	2023-12-29 15:43:27
+@@ -45,3 +45,11 @@
    if (free_func != NULL)
      *free_func = __gmp_free_func;
  }
@@ -81,10 +87,10 @@ diff --git a/mp_get_fns.c b/mp_get_fns.c
 +  if (alloc_overflow_func != NULL)
 +    *alloc_overflow_func = __gmp_alloc_overflow_func;
 +}
-diff --git a/mp_set_fns.c b/mp_set_fns.c
---- a/mp_set_fns.c
-+++ b/mp_set_fns.c
-@@ -48,3 +48,12 @@ mp_set_memory_functions (void *(*alloc_f
+diff -ru gmp-6.3.0/mp_set_fns.c gmp-6.3.0.new/mp_set_fns.c
+--- gmp-6.3.0/mp_set_fns.c	2023-07-29 09:42:16
++++ gmp-6.3.0.new/mp_set_fns.c	2023-12-29 15:43:27
+@@ -47,3 +47,12 @@
    __gmp_reallocate_func = realloc_func;
    __gmp_free_func = free_func;
  }
@@ -97,58 +103,66 @@ diff --git a/mp_set_fns.c b/mp_set_fns.c
 +    alloc_overflow_func = __gmp_default_alloc_overflow;
 +  __gmp_alloc_overflow_func = alloc_overflow_func;
 +}
-diff --git a/mpz/init2.c b/mpz/init2.c
---- a/mpz/init2.c
-+++ b/mpz/init2.c
-@@ -45,8 +45,7 @@ mpz_init2 (mpz_ptr x, mp_bitcnt_t bits)
+diff -ru gmp-6.3.0/mpz/init2.c gmp-6.3.0.new/mpz/init2.c
+--- gmp-6.3.0/mpz/init2.c	2023-07-29 09:42:17
++++ gmp-6.3.0.new/mpz/init2.c	2023-12-30 12:22:34
+@@ -41,7 +41,7 @@
+   if (sizeof (unsigned long) > sizeof (int)) /* param vs _mp_size field */
      {
        if (UNLIKELY (new_alloc > INT_MAX))
- 	{
--	  fprintf (stderr, "gmp: overflow in mpz type\n");
--	  abort ();
-+	  __GMP_ALLOC_OVERFLOW_FUNC ();
- 	}
+-	MPZ_OVERFLOW;
++	__GMP_ALLOC_OVERFLOW_FUNC ();
      }
  
-diff --git a/mpz/realloc.c b/mpz/realloc.c
---- a/mpz/realloc.c
-+++ b/mpz/realloc.c
-@@ -45,16 +45,14 @@ void *
+   PTR(x) = __GMP_ALLOCATE_FUNC_LIMBS (new_alloc);
+diff -ru gmp-6.3.0/mpz/realloc.c gmp-6.3.0.new/mpz/realloc.c
+--- gmp-6.3.0/mpz/realloc.c	2023-07-29 09:42:17
++++ gmp-6.3.0.new/mpz/realloc.c	2023-12-30 12:22:47
+@@ -42,12 +42,12 @@
+   if (sizeof (mp_size_t) == sizeof (int))
      {
        if (UNLIKELY (new_alloc > ULONG_MAX / GMP_NUMB_BITS))
- 	{
--	  fprintf (stderr, "gmp: overflow in mpz type\n");
--	  abort ();
-+	  __GMP_ALLOC_OVERFLOW_FUNC ();
- 	}
+-	MPZ_OVERFLOW;
++	__GMP_ALLOC_OVERFLOW_FUNC ();
      }
    else
      {
        if (UNLIKELY (new_alloc > INT_MAX))
- 	{
--	  fprintf (stderr, "gmp: overflow in mpz type\n");
--	  abort ();
-+	  __GMP_ALLOC_OVERFLOW_FUNC ();
- 	}
+-	MPZ_OVERFLOW;
++	__GMP_ALLOC_OVERFLOW_FUNC ();
      }
  
-diff --git a/mpz/realloc2.c b/mpz/realloc2.c
---- a/mpz/realloc2.c
-+++ b/mpz/realloc2.c
-@@ -45,8 +45,7 @@ mpz_realloc2 (mpz_ptr m, mp_bitcnt_t bit
+   if (ALLOC (m) == 0)
+diff -ru gmp-6.3.0/mpz/realloc2.c gmp-6.3.0.new/mpz/realloc2.c
+--- gmp-6.3.0/mpz/realloc2.c	2023-07-29 09:42:17
++++ gmp-6.3.0.new/mpz/realloc2.c	2023-12-30 12:22:59
+@@ -42,7 +42,7 @@
+   if (sizeof (unsigned long) > sizeof (int)) /* param vs _mp_size field */
      {
        if (UNLIKELY (new_alloc > INT_MAX))
- 	{
--	  fprintf (stderr, "gmp: overflow in mpz type\n");
--	  abort ();
-+	  __GMP_ALLOC_OVERFLOW_FUNC ();
- 	}
+-	MPZ_OVERFLOW;
++	__GMP_ALLOC_OVERFLOW_FUNC ();
      }
  
-diff --git a/tests/mpz/t-pow.c b/tests/mpz/t-pow.c
---- a/tests/mpz/t-pow.c
-+++ b/tests/mpz/t-pow.c
-@@ -195,6 +195,34 @@ check_random (int reps)
+   if (ALLOC (m) == 0)
+diff -ru gmp-6.3.0/tal-reent.c gmp-6.3.0.new/tal-reent.c
+--- gmp-6.3.0/tal-reent.c	2023-07-29 09:42:17
++++ gmp-6.3.0.new/tal-reent.c	2023-12-30 12:19:40
+@@ -61,6 +61,10 @@
+ 
+   total_size = size + HSIZ;
+   p = __GMP_ALLOCATE_FUNC_TYPE (total_size, char);
++  if (!p)
++    {
++      __GMP_ALLOC_OVERFLOW_FUNC ();
++    }
+   P->size = total_size;
+   P->next = *markp;
+   *markp = P;
+diff -ru gmp-6.3.0/tests/mpz/t-pow.c gmp-6.3.0.new/tests/mpz/t-pow.c
+--- gmp-6.3.0/tests/mpz/t-pow.c	2023-07-29 09:42:17
++++ gmp-6.3.0.new/tests/mpz/t-pow.c	2023-12-30 15:57:58
+@@ -194,6 +194,33 @@
    mpz_clear (want);
  }
  
@@ -178,12 +192,11 @@ diff --git a/tests/mpz/t-pow.c b/tests/mpz/t-pow.c
 +  }
 +  mpz_clear (x);
 +}
-+
 +
  int
  main (int argc, char **argv)
  {
-@@ -212,6 +240,7 @@ main (int argc, char **argv)
+@@ -211,6 +238,7 @@
  
    check_various ();
    check_random (reps);
diff --git a/deps/patches/gmp-more_alloc_overflow.patch b/deps/patches/gmp-more_alloc_overflow.patch
deleted file mode 100644
index 597f0d52d73e7..0000000000000
--- a/deps/patches/gmp-more_alloc_overflow.patch
+++ /dev/null
@@ -1,37 +0,0 @@
-diff -ur a/mpz/n_pow_ui.c b/mpz/n_pow_ui.c
---- a/mpz/n_pow_ui.c
-+++ b/mpz/n_pow_ui.c
-@@ -220,8 +220,7 @@
-   umul_ppmm (ovfl, rtwos_bits, e, btwos);
-   if (ovfl)
-     {
--      fprintf (stderr, "gmp: overflow in mpz type\n");
--      abort ();
-+      __GMP_ALLOC_OVERFLOW_FUNC ();
-     }
-
-   rtwos_limbs += rtwos_bits / GMP_NUMB_BITS;
-@@ -382,8 +381,7 @@
-   umul_ppmm (ovfl, ralloc, (bsize*GMP_NUMB_BITS - cnt + GMP_NAIL_BITS), e);
-   if (ovfl)
-     {
--      fprintf (stderr, "gmp: overflow in mpz type\n");
--      abort ();
-+      __GMP_ALLOC_OVERFLOW_FUNC ();
-     }
-   ralloc = ralloc / GMP_NUMB_BITS + 5;
-
-diff -ur a/tal-reent.c b/tal-reent.c
---- a/tal-reent.c
-+++ b/tal-reent.c
-@@ -61,6 +61,10 @@
-
-   total_size = size + HSIZ;
-   p = __GMP_ALLOCATE_FUNC_TYPE (total_size, char);
-+  if (!p)
-+    {
-+      __GMP_ALLOC_OVERFLOW_FUNC ();
-+    }
-   P->size = total_size;
-   P->next = *markp;
-   *markp = P;
diff --git a/stdlib/GMP_jll/Project.toml b/stdlib/GMP_jll/Project.toml
index 9f3b917257bfa..c8fcfe4f2b845 100644
--- a/stdlib/GMP_jll/Project.toml
+++ b/stdlib/GMP_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "GMP_jll"
 uuid = "781609d7-10c4-51f6-84f2-b8444358ff6d"
-version = "6.2.1+6"
+version = "6.3.0+0"
 
 [deps]
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
diff --git a/stdlib/GMP_jll/test/runtests.jl b/stdlib/GMP_jll/test/runtests.jl
index 7c0d877945231..b2b35b98cbe17 100644
--- a/stdlib/GMP_jll/test/runtests.jl
+++ b/stdlib/GMP_jll/test/runtests.jl
@@ -4,5 +4,5 @@ using Test, Libdl, GMP_jll
 
 @testset "GMP_jll" begin
     vn = VersionNumber(unsafe_string(unsafe_load(cglobal((:__gmp_version, libgmp), Ptr{Cchar}))))
-    @test vn == v"6.2.1"
+    @test vn == v"6.3.0"
 end

From a78b8e3d97303391df301ddfe310f75f3d407f2c Mon Sep 17 00:00:00 2001
From: Antoine Levitt <antoine.levitt@gmail.com>
Date: Sat, 10 Feb 2024 20:17:53 +0100
Subject: [PATCH 0880/1315] bypass assignments in edit, code_warntype and
 friends (#52046)

It was suggested in the original issue that the binding should still
occur, but for consistency with `@edit f(2)` which doesn't actually
call `f`, this does not.

Fixes #20270
---
 stdlib/InteractiveUtils/src/macros.jl    | 4 ++++
 stdlib/InteractiveUtils/test/runtests.jl | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/stdlib/InteractiveUtils/src/macros.jl b/stdlib/InteractiveUtils/src/macros.jl
index a840dd7ea43bb..939098464e148 100644
--- a/stdlib/InteractiveUtils/src/macros.jl
+++ b/stdlib/InteractiveUtils/src/macros.jl
@@ -36,6 +36,10 @@ function gen_call_with_extracted_types(__module__, fcn, ex0, kws=Expr[])
     if Meta.isexpr(ex0, :ref)
         ex0 = replace_ref_begin_end!(ex0)
     end
+    # assignments get bypassed: @edit a = f(x) <=> @edit f(x)
+    if isa(ex0, Expr) && ex0.head == :(=) && isa(ex0.args[1], Symbol) && isempty(kws)
+        return gen_call_with_extracted_types(__module__, fcn, ex0.args[2])
+    end
     if isa(ex0, Expr)
         if ex0.head === :do && Meta.isexpr(get(ex0.args, 1, nothing), :call)
             if length(ex0.args) != 2
diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index 94c0c42e2d2da..346b111c785f7 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -284,7 +284,7 @@ try
     @which x = 1
     error("unexpected")
 catch err13464
-    @test startswith(err13464.msg, "expression is not a function call, or is too complex")
+    @test startswith(err13464.msg, "expression is not a function call")
 end
 
 module MacroTest

From 604609a3fc1bf76470f4bca2333628cb08419f81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= <lars.goettgens@rwth-aachen.de>
Date: Sat, 10 Feb 2024 20:26:18 +0100
Subject: [PATCH 0881/1315] Add docstring to constants in `Base.Filesystem`
 (#53247)

A first step towards https://github.com/JuliaLang/julia/issues/52725 for
`Base.Filesystem`.
---
 base/filesystem.jl | 70 +++++++++++++++++++++++++++++++++++++++++++++-
 test/filesystem.jl |  2 +-
 2 files changed, 70 insertions(+), 2 deletions(-)

diff --git a/base/filesystem.jl b/base/filesystem.jl
index bb804392c49af..ee6fde982caab 100644
--- a/base/filesystem.jl
+++ b/base/filesystem.jl
@@ -4,6 +4,45 @@
 
 module Filesystem
 
+"""
+    JL_O_APPEND
+    JL_O_ASYNC
+    JL_O_CLOEXEC
+    JL_O_CREAT
+    JL_O_DIRECT
+    JL_O_DIRECTORY
+    JL_O_DSYNC
+    JL_O_EXCL
+    JL_O_FSYNC
+    JL_O_LARGEFILE
+    JL_O_NDELAY
+    JL_O_NOATIME
+    JL_O_NOCTTY
+    JL_O_NOFOLLOW
+    JL_O_NONBLOCK
+    JL_O_PATH
+    JL_O_RANDOM
+    JL_O_RDONLY
+    JL_O_RDWR
+    JL_O_RSYNC
+    JL_O_SEQUENTIAL
+    JL_O_SHORT_LIVED
+    JL_O_SYNC
+    JL_O_TEMPORARY
+    JL_O_TMPFILE
+    JL_O_TRUNC
+    JL_O_WRONLY
+
+Enum constant for the `open` syscall, where `JL_O_*` corresponds to the `O_*` constant.
+See [the libuv docs](https://docs.libuv.org/en/v1.x/fs.html#file-open-constants) for more details.
+"""
+(:JL_O_APPEND, :JL_O_ASYNC, :JL_O_CLOEXEC, :JL_O_CREAT, :JL_O_DIRECT,
+ :JL_O_DIRECTORY, :JL_O_DSYNC, :JL_O_EXCL, :JL_O_FSYNC, :JL_O_LARGEFILE,
+ :JL_O_NOATIME, :JL_O_NOCTTY, :JL_O_NDELAY, :JL_O_NOFOLLOW, :JL_O_NONBLOCK,
+ :JL_O_PATH, :JL_O_RANDOM, :JL_O_RDONLY, :JL_O_RDWR, :JL_O_RSYNC,
+ :JL_O_SEQUENTIAL, :JL_O_SHORT_LIVED, :JL_O_SYNC, :JL_O_TEMPORARY,
+ :JL_O_TMPFILE, :JL_O_TRUNC, :JL_O_WRONLY)
+
 const S_IFDIR  = 0o040000  # directory
 const S_IFCHR  = 0o020000  # character device
 const S_IFBLK  = 0o060000  # block device
@@ -31,6 +70,36 @@ const S_IWOTH = 0o0002  # write by other
 const S_IXOTH = 0o0001  # execute by other
 const S_IRWXO = 0o0007  # mask for other permissions
 
+"""
+    S_IRUSR
+    S_IWUSR
+    S_IXUSR
+    S_IRGRP
+    S_IWGRP
+    S_IXGRP
+    S_IROTH
+    S_IWOTH
+    S_IXOTH
+
+Constants for file access permission bits.
+The general structure is `S_I[permission][class]`
+where `permission` is `R` for read, `W` for write, and `X` for execute,
+and `class` is `USR` for user/owner, `GRP` for group, and `OTH` for other.
+"""
+(:S_IRUSR, :S_IWUSR, :S_IXUSR, :S_IRGRP, :S_IWGRP, :S_IXGRP, :S_IROTH, :S_IWOTH, :S_IXOTH)
+
+"""
+    S_IRWXU
+    S_IRWXG
+    S_IRWXO
+
+Constants for file access permission masks, i.e. the combination of read, write,
+and execute permissions for a class.
+The general structure is `S_IRWX[class]`
+where `class` is `U` for user/owner, `G` for group, and `O` for other.
+"""
+(:S_IRWXU, :S_IRWXG, :S_IRWXO)
+
 export File,
        StatStruct,
        # open,
@@ -48,7 +117,6 @@ export File,
        JL_O_SEQUENTIAL,
        JL_O_RANDOM,
        JL_O_NOCTTY,
-       JL_O_NOCTTY,
        JL_O_NONBLOCK,
        JL_O_NDELAY,
        JL_O_SYNC,
diff --git a/test/filesystem.jl b/test/filesystem.jl
index c9bab69c586b3..566ca08ec910e 100644
--- a/test/filesystem.jl
+++ b/test/filesystem.jl
@@ -44,5 +44,5 @@ end
 @testset "Base.Filesystem docstrings" begin
   undoc = Docs.undocumented_names(Base.Filesystem)
   @test_broken isempty(undoc)
-  @test undoc == [:File, :Filesystem, :JL_O_APPEND, :JL_O_ASYNC, :JL_O_CLOEXEC, :JL_O_CREAT, :JL_O_DIRECT, :JL_O_DIRECTORY, :JL_O_DSYNC, :JL_O_EXCL, :JL_O_FSYNC, :JL_O_LARGEFILE, :JL_O_NDELAY, :JL_O_NOATIME, :JL_O_NOCTTY, :JL_O_NOFOLLOW, :JL_O_NONBLOCK, :JL_O_PATH, :JL_O_RANDOM, :JL_O_RDONLY, :JL_O_RDWR, :JL_O_RSYNC, :JL_O_SEQUENTIAL, :JL_O_SHORT_LIVED, :JL_O_SYNC, :JL_O_TEMPORARY, :JL_O_TMPFILE, :JL_O_TRUNC, :JL_O_WRONLY, :S_IRGRP, :S_IROTH, :S_IRUSR, :S_IRWXG, :S_IRWXO, :S_IRWXU, :S_IWGRP, :S_IWOTH, :S_IWUSR, :S_IXGRP, :S_IXOTH, :S_IXUSR, :cptree, :futime, :rename, :sendfile, :unlink]
+  @test undoc == [:File, :Filesystem, :cptree, :futime, :rename, :sendfile, :unlink]
 end

From e5496e0d1700797ab721e9158bd39093542e3118 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 10 Feb 2024 15:26:47 -0500
Subject: [PATCH 0882/1315] update libuv to v2-1.48.0 (#49937)

Notable additions:
 - Linux now uses io_uring for many fs calls
 - Windows now supports WTF-8
 - new cross-platform uv_clock_gettime API
 - Windows now emits a coredump when sending SIGQUIT, if configured
 - Windows now can execute file given by an exact path name that do not contain a `.` (unlike cmd.exe, which cannot)

Closes #47611
Fixes #33486
---
 Make.inc                             |  2 +-
 NEWS.md                              |  1 +
 base/cmd.jl                          |  7 +--
 base/process.jl                      |  1 +
 deps/checksums/libuv                 | 68 ++++++++++++++--------------
 deps/libuv.version                   |  4 +-
 src/jl_uv.c                          | 41 +++++++++++------
 stdlib/FileWatching/test/runtests.jl |  2 +-
 stdlib/LibUV_jll/Project.toml        |  2 +-
 stdlib/REPL/src/precompile.jl        | 12 +++--
 test/spawn.jl                        |  2 +-
 11 files changed, 81 insertions(+), 61 deletions(-)

diff --git a/Make.inc b/Make.inc
index 51186cfefe8eb..5d58454c80333 100644
--- a/Make.inc
+++ b/Make.inc
@@ -1392,7 +1392,7 @@ endif
 ifeq ($(OS), WINNT)
 HAVE_SSP := 1
 OSLIBS += -Wl,--export-all-symbols -Wl,--version-script=$(BUILDROOT)/src/julia.expmap \
-	$(NO_WHOLE_ARCHIVE) -lpsapi -lkernel32 -lws2_32 -liphlpapi -lwinmm -ldbghelp -luserenv -lsecur32 -latomic
+	$(NO_WHOLE_ARCHIVE) -lpsapi -lkernel32 -lws2_32 -liphlpapi -lwinmm -ldbghelp -luserenv -lsecur32 -latomic -lole32
 JLDFLAGS += -Wl,--stack,8388608
 ifeq ($(ARCH),i686)
 JLDFLAGS += -Wl,--large-address-aware
diff --git a/NEWS.md b/NEWS.md
index ca4fb51b37fa0..d71e14dff6fe1 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -54,6 +54,7 @@ Compiler/Runtime improvements
 * A new `LazyLibrary` type is exported from `Libdl` for use in building chained lazy library
   loads, primarily to be used within JLLs ([#50074]).
 * Added support for annotating `Base.@assume_effects` on code blocks ([#52400]).
+* The libuv library has been updated from a base of v1.44.2 to v1.48.0 ([#49937]).
 
 Command-line option changes
 ---------------------------
diff --git a/base/cmd.jl b/base/cmd.jl
index 0e4ec119109f1..202527abdf644 100644
--- a/base/cmd.jl
+++ b/base/cmd.jl
@@ -3,9 +3,10 @@
 abstract type AbstractCmd end
 
 # libuv process option flags
-const UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = UInt8(1 << 2)
-const UV_PROCESS_DETACHED = UInt8(1 << 3)
-const UV_PROCESS_WINDOWS_HIDE = UInt8(1 << 4)
+const UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = UInt32(1 << 2)
+const UV_PROCESS_DETACHED = UInt32(1 << 3)
+const UV_PROCESS_WINDOWS_HIDE = UInt32(1 << 4)
+const UV_PROCESS_WINDOWS_DISABLE_EXACT_NAME = UInt32(1 << 7)
 
 struct Cmd <: AbstractCmd
     exec::Vector{String}
diff --git a/base/process.jl b/base/process.jl
index 24e676138bfae..fbc4acfd83e80 100644
--- a/base/process.jl
+++ b/base/process.jl
@@ -114,6 +114,7 @@ end
         handle = Libc.malloc(_sizeof_uv_process)
         disassociate_julia_struct(handle)
         (; exec, flags, env, dir) = cmd
+        flags ⊻= UV_PROCESS_WINDOWS_DISABLE_EXACT_NAME # libuv inverts the default for this, so flip this bit now
         iolock_begin()
         err = ccall(:jl_spawn, Int32,
                   (Cstring, Ptr{Cstring}, Ptr{Cvoid}, Ptr{Cvoid},
diff --git a/deps/checksums/libuv b/deps/checksums/libuv
index 6ad61210bc0cc..7ac93952b8b34 100644
--- a/deps/checksums/libuv
+++ b/deps/checksums/libuv
@@ -1,34 +1,34 @@
-LibUV.v2.0.1+14.aarch64-apple-darwin.tar.gz/md5/1a58ce9dc88984c3b5f7df97af6cbf83
-LibUV.v2.0.1+14.aarch64-apple-darwin.tar.gz/sha512/2bfd482ac759ac88d885371854affa8e358a10fea6c7756e0d1b366bc82ecbea56bdf24ca634525fb2a6fc2b3a5c77b07a4c6dec2923d8bffe2bc962bd3e7f84
-LibUV.v2.0.1+14.aarch64-linux-gnu.tar.gz/md5/7f270dd1e3046c8db432e350dd5cf114
-LibUV.v2.0.1+14.aarch64-linux-gnu.tar.gz/sha512/c0debcf17b54ba9f1588d4b267d610751f739d8ff96936c9d5fb6d8742039f8736c63fa70037322705569e221d73fb83c03b6ba9fb4454442fffd3a9f1a1a2da
-LibUV.v2.0.1+14.aarch64-linux-musl.tar.gz/md5/07f56c32d5a2c12e6c351cf9f705631c
-LibUV.v2.0.1+14.aarch64-linux-musl.tar.gz/sha512/8037d7aa0cb06850f055fd19cebdcfcf3146dde0d12768a9669bf05dcab91fdf3708798203258cb3f452158bdec7faae41e6afbb0e60b21403e683db3e23a1c9
-LibUV.v2.0.1+14.armv6l-linux-gnueabihf.tar.gz/md5/5558a7f68c7c375f40bc64da59fef0ad
-LibUV.v2.0.1+14.armv6l-linux-gnueabihf.tar.gz/sha512/92ed6601cb5aa9a3ea2478a1485849543c9e847c8e85542e72f372a2d37c4c8b90f5ecb1bee1e462db31e1e8dba460f584b3cca9c833989c2b9ee404e355654e
-LibUV.v2.0.1+14.armv6l-linux-musleabihf.tar.gz/md5/de6bfb7f0c0468b79e8895f166fb6340
-LibUV.v2.0.1+14.armv6l-linux-musleabihf.tar.gz/sha512/7948d007171bf57b827b489f3627ac74df447f4d696e8226e54e95ef0c8eed5a5ddbf758fbad841bc367f78cd61e6a5899eb478003dca3a79cb494b38cab830b
-LibUV.v2.0.1+14.armv7l-linux-gnueabihf.tar.gz/md5/5be35de1d881f80981647c369b9b4ec8
-LibUV.v2.0.1+14.armv7l-linux-gnueabihf.tar.gz/sha512/458e5058ea4e794e0dc790da4c98569676056bac336df69762e8ccfec8f2955dcc55e8d090daa1b191c0ffa41392a04530c9bc28aa27cf411c1df2f1ba14bb97
-LibUV.v2.0.1+14.armv7l-linux-musleabihf.tar.gz/md5/8d034490da1ec2ef3dd3c69336177654
-LibUV.v2.0.1+14.armv7l-linux-musleabihf.tar.gz/sha512/7f595a8ab8b664d229cf6144e9ed1b5936ba8aaa70b92611ddb85bbe9046bb1b94d8417355a5abf058fb00023d4d56be0b2ddfd5dba896cd7b64e84e32dbfc5a
-LibUV.v2.0.1+14.i686-linux-gnu.tar.gz/md5/ccb9aba78456c99b8473e8ddd328f90e
-LibUV.v2.0.1+14.i686-linux-gnu.tar.gz/sha512/d382d90137db308933257a75e51d90988d6d07663b3b2915478547127d32f73ae6cdb4575d5ee20758f8850c7e85908fe4710c053cb361826621f22bc5b6502d
-LibUV.v2.0.1+14.i686-linux-musl.tar.gz/md5/5ade48f16aa26bb68dc046d285c73043
-LibUV.v2.0.1+14.i686-linux-musl.tar.gz/sha512/f5728a5dc567268e59aa2697deb793ae427e11dcb6796c577e3da3ac24225ece5d4a6c4f903d4a7b184d3c3a3c8c1586c34b97e4a75de0a4e23ace720020fa8c
-LibUV.v2.0.1+14.i686-w64-mingw32.tar.gz/md5/541210fef837c2ef7cffa508d282f9bb
-LibUV.v2.0.1+14.i686-w64-mingw32.tar.gz/sha512/4541a02c59b66f97099b5264dce0cad90fcdf9a4d7ccd8e950cc1f3a530616a0fb2aa43db21b5b1f52819efef22cd0b68595d419e2e5b05924e344b0333f8bf8
-LibUV.v2.0.1+14.powerpc64le-linux-gnu.tar.gz/md5/26656d4eaae8739099c55054bad54f57
-LibUV.v2.0.1+14.powerpc64le-linux-gnu.tar.gz/sha512/f85f8cfd91e7b1b02b073931ef9a3bb05620641d18ada039744a92b8c40e5a3de8d7c5efa7189b88baf1eb11fbcf9e6d16031b86e40f99f1b7cfebb0f5c5adf1
-LibUV.v2.0.1+14.x86_64-apple-darwin.tar.gz/md5/c7da6b91394a20c43acdf6f680cb62e2
-LibUV.v2.0.1+14.x86_64-apple-darwin.tar.gz/sha512/238d22bd299ae3b0dfd24a5b38d6d0d07b751fb301487a2d1d2f5313ae3596f33492388ea9fbff549293787505fc527e174ebcd4068f1bda43b40bc19e016d89
-LibUV.v2.0.1+14.x86_64-linux-gnu.tar.gz/md5/8c8913068263257cce5042b725918e0e
-LibUV.v2.0.1+14.x86_64-linux-gnu.tar.gz/sha512/a848381012d5a20a0c881f5835e479cfff811928ce508cc57041d69668782f2135c14c7e5388e7dbf693ae57aa1825d911f6f450b9e909cce45487b03a581a23
-LibUV.v2.0.1+14.x86_64-linux-musl.tar.gz/md5/16747c066b6d7fe56850c77f66ea7478
-LibUV.v2.0.1+14.x86_64-linux-musl.tar.gz/sha512/833a02f9191edf3b56f1e02f5671f22de6cb27ec3c9f770530ec95d8da7ba0b9c05bcdf6b094224ea8e43ba70918e1599f3237bd98900763daef80c327d3d2de
-LibUV.v2.0.1+14.x86_64-unknown-freebsd.tar.gz/md5/e828eb79728e75766a72d7b304c9f989
-LibUV.v2.0.1+14.x86_64-unknown-freebsd.tar.gz/sha512/37df5b966f70b3d1e0eae603d4a6b00c84dffdfc3632ca581669a99a0cd894a81aff4361de3beed53ec032273f62cf397cf52085c6c387d0bbb2c57b59ae84fe
-LibUV.v2.0.1+14.x86_64-w64-mingw32.tar.gz/md5/bded9d94435a70fd0dfff3f0fc605736
-LibUV.v2.0.1+14.x86_64-w64-mingw32.tar.gz/sha512/48793a386f6231d12f01b4718d87aaab409f0b807b03a3577e2401f7493caef36a5072fdc33f3cd3ce9733ba50ab344cb2e2fa6a21ba5adb56d6cca642afad0c
-libuv-2723e256e952be0b015b3c0086f717c3d365d97e.tar.gz/md5/d2284d7f6fa75d6a35673d22e1be058b
-libuv-2723e256e952be0b015b3c0086f717c3d365d97e.tar.gz/sha512/68d6ab740945b9ce3475118ce3d186fb67d7e8125784cc0c827df23d63f50c40c0261ef37365d8c11ab9462a8dd4e2e6b19e91e3c84b64d8fb84fd3894afc4ac
+LibUV.v2.0.1+15.aarch64-apple-darwin.tar.gz/md5/f12ee08b8d5721bd88b651ac573c59ed
+LibUV.v2.0.1+15.aarch64-apple-darwin.tar.gz/sha512/b3c53e04624d9c60e664db2eaaf3add696f95c52e55db0c577547f7bf7e045ce30cffa0e38c3451f483dcdb7ddcac1b7f43b694dfadb37282773ce416af1030a
+LibUV.v2.0.1+15.aarch64-linux-gnu.tar.gz/md5/8cb9f4d6c6a4013fa9ed9ae120058275
+LibUV.v2.0.1+15.aarch64-linux-gnu.tar.gz/sha512/d4213ee47ebdcab4cc4719478608ffa461a5543a16656c2881587364c8ed1b39a2f418d5c3c6a04d7e6dd3df349f0afa72cd1df0e06db6146512356b37637024
+LibUV.v2.0.1+15.aarch64-linux-musl.tar.gz/md5/e23a0d7162fc3f09f0ea92d24cba3f4d
+LibUV.v2.0.1+15.aarch64-linux-musl.tar.gz/sha512/f4a13eee72575092ab673777a53d43ce999a7a8bf847daa0a86b39bbfd3f6c1575f105a0bb629766268921ff94f10d354a0e53d32623f6ad35fca44e7bac25f8
+LibUV.v2.0.1+15.armv6l-linux-gnueabihf.tar.gz/md5/70ed0616cd3737a357b7571ab648d239
+LibUV.v2.0.1+15.armv6l-linux-gnueabihf.tar.gz/sha512/25a4b8a90b7bb62e31c1c2bb1d7e137050de26f311daa9f77be932ab3d9a2b92c82ce82ed37cc74a2b1cd5a60bd0dc412e92d31013d36ad35af2d4f376fbc0b0
+LibUV.v2.0.1+15.armv6l-linux-musleabihf.tar.gz/md5/e4320c51c8904a59c105f7b63d086c79
+LibUV.v2.0.1+15.armv6l-linux-musleabihf.tar.gz/sha512/bbc39d800277a66298c56849c1131a6f1958a2c8b2465b59527965a1bd3f36a4c87c1d7ad4be59ec0f4ca8f94ec1804a619eb963d956b77e645e0e00effc6613
+LibUV.v2.0.1+15.armv7l-linux-gnueabihf.tar.gz/md5/d5436552dc177fc3fd0cf4f575cc03b4
+LibUV.v2.0.1+15.armv7l-linux-gnueabihf.tar.gz/sha512/8d3722290151ecf65f4e3fe3440828492a7b115810b87c8711c5592f4dea69727e516228a5a1bdac430c74b288f12de390daf0a9408274aa27cdd69efc81cfee
+LibUV.v2.0.1+15.armv7l-linux-musleabihf.tar.gz/md5/67e1ba03ddf2d2bdd79fef25a5976350
+LibUV.v2.0.1+15.armv7l-linux-musleabihf.tar.gz/sha512/535565657b5714da0db5c622b65b261a77f21f407b1166eee99f35ba3bb9c6fab4c7d1f3db70528767cef7c66c856c5101b01423be05efb9219ec4c76df0be6a
+LibUV.v2.0.1+15.i686-linux-gnu.tar.gz/md5/ba1432ecd75e6a43ff197d51ba76446c
+LibUV.v2.0.1+15.i686-linux-gnu.tar.gz/sha512/dc8940284d4ba05098037fcf4b3bada199878794ef34ad09d8992ef58e4c829b00a3fcca29c4f65b49edcab4274092232ff5d7619b3535333125043f89503cfc
+LibUV.v2.0.1+15.i686-linux-musl.tar.gz/md5/237080cf5d1286a3d2f35d134a285d28
+LibUV.v2.0.1+15.i686-linux-musl.tar.gz/sha512/834f16a16cf6b765dfd094037c8a45ccdedc2eb9e45f527c6721eb0f60f4e56dc4f9b90a2a35e3ed10da4a937d8555e97034e0a29d733cac5352061ebe286799
+LibUV.v2.0.1+15.i686-w64-mingw32.tar.gz/md5/8a5261a6ce4200d272b5eda4fe9ecb31
+LibUV.v2.0.1+15.i686-w64-mingw32.tar.gz/sha512/b372b9368a9ac92775a8d6ee39b492905dc5f58f16d7edf792e0c2ffbd4507ede79139a24fe852dfa26068d0f076a4abf3c3b868a8a057b23fdbad80999d315f
+LibUV.v2.0.1+15.powerpc64le-linux-gnu.tar.gz/md5/53db7b763af204477ce8f0bfae0ce15c
+LibUV.v2.0.1+15.powerpc64le-linux-gnu.tar.gz/sha512/bbfe2518d4dc84fe73b7d3f3bcaf5aeef0db0d284c0e205e3e3670b8ce6f3ea593a0e52d125fd9a79cd098dba0d35f151cb46469fa25dfeef62ebcc966f94d4f
+LibUV.v2.0.1+15.x86_64-apple-darwin.tar.gz/md5/b4699192c098564edc5589e90c47324e
+LibUV.v2.0.1+15.x86_64-apple-darwin.tar.gz/sha512/2505e4060712143d3213747d4276c0b99dec78579d2ab0b71c5d7edf15ae80e0178138a11470c976d97de14e44b153dcb00c08c864523d7ee0ead8e48cf15d14
+LibUV.v2.0.1+15.x86_64-linux-gnu.tar.gz/md5/f5515c50106a0748b9a1986c912a00f3
+LibUV.v2.0.1+15.x86_64-linux-gnu.tar.gz/sha512/5822396039e14a5d919f2612559a8d62a925c4319e66eb05ed20faed754318762f5653851684701cd4ddb1edf10bfe25d252c3d9cd84228e498e825ba61146b1
+LibUV.v2.0.1+15.x86_64-linux-musl.tar.gz/md5/1962e6f21080e874d2ca0275c5b569b2
+LibUV.v2.0.1+15.x86_64-linux-musl.tar.gz/sha512/4702e13633d77a6c0aeb1e7cd252471a779177e20c68485130f420cc4878c8f7de7f0f51730008ba9dc0f275875a5947629d39aff200691e26f31d42e388d53d
+LibUV.v2.0.1+15.x86_64-unknown-freebsd.tar.gz/md5/928a789c3cd3b4cefcc1cf13f5f179ac
+LibUV.v2.0.1+15.x86_64-unknown-freebsd.tar.gz/sha512/ee58667b19fdf7ec0218b4645b3f5bed2e9fc01cc29eab8473ee02aaa044f94a48eb220c6427200aaf56eacf52d0f72156712d17017cfecbc25d3c1b71a4bd2f
+LibUV.v2.0.1+15.x86_64-w64-mingw32.tar.gz/md5/d3b84729ee9d5a6e6a1e29357e25cced
+LibUV.v2.0.1+15.x86_64-w64-mingw32.tar.gz/sha512/43ca5999d8e8ff820722b1a548bd4e277e95c739c3363ed6159d080dd06842316f5370e8e4f4a886bf76010f4aed2bbf01f6091845b0e84b75f709277c561649
+libuv-afa1c67fa496eb49ade1e520f76fd018a1409eaa.tar.gz/md5/3863ccd5a51f85cf76679070c99be6cd
+libuv-afa1c67fa496eb49ade1e520f76fd018a1409eaa.tar.gz/sha512/bf4c705e05e730139b62de799331653eea2767898d654b8890ca2623db3adb9a1efcfcfab38af22e8ac44c67a9c5c018f1f7847a3703bee5f05657169a67d817
diff --git a/deps/libuv.version b/deps/libuv.version
index 01bf4fecc6dc6..9ae54aa7be91a 100644
--- a/deps/libuv.version
+++ b/deps/libuv.version
@@ -3,5 +3,5 @@ LIBUV_JLL_NAME := LibUV
 
 ## source build
 LIBUV_VER := 2
-LIBUV_BRANCH=julia-uv2-1.44.2
-LIBUV_SHA1=2723e256e952be0b015b3c0086f717c3d365d97e
+LIBUV_BRANCH=julia-uv2-1.48.0
+LIBUV_SHA1=afa1c67fa496eb49ade1e520f76fd018a1409eaa
diff --git a/src/jl_uv.c b/src/jl_uv.c
index 582484f78e181..e447faf8fa9c2 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -39,21 +39,24 @@ static void walk_print_cb(uv_handle_t *h, void *arg)
     const char *type = uv_handle_type_name(h->type);
     if (!type)
         type = "<unknown>";
+    size_t resource_id; // fits an int or pid_t on Unix, HANDLE or PID on Windows
     uv_os_fd_t fd;
     if (h->type == UV_PROCESS)
-        fd = uv_process_get_pid((uv_process_t*)h);
-    else if (uv_fileno(h, &fd))
-        fd = (uv_os_fd_t)-1;
+        resource_id = (size_t)uv_process_get_pid((uv_process_t*)h);
+    else if (uv_fileno(h, &fd) == 0)
+        resource_id = (size_t)fd;
+    else
+        resource_id = -1;
     const char *pad = "                "; // 16 spaces
-    int npad = fd == -1 ? 0 : snprintf(NULL, 0, "%zd", (size_t)fd);
+    int npad = resource_id == -1 ? 0 : snprintf(NULL, 0, "%zd", resource_id);
     if (npad < 0)
         npad = 0;
     npad += strlen(type);
     pad += npad < strlen(pad) ? npad : strlen(pad);
-    if (fd == -1)
+    if (resource_id == -1)
         jl_safe_printf(" %s   %s%p->%p\n", type,             pad, (void*)h, (void*)h->data);
     else
-        jl_safe_printf(" %s[%zd] %s%p->%p\n", type, (size_t)fd, pad, (void*)h, (void*)h->data);
+        jl_safe_printf(" %s[%zd] %s%p->%p\n", type, resource_id, pad, (void*)h, (void*)h->data);
 }
 
 static void wait_empty_func(uv_timer_t *t)
@@ -1110,31 +1113,39 @@ static inline int ishexchar(char c)
 
 JL_DLLEXPORT int jl_ispty(uv_pipe_t *pipe)
 {
-    if (pipe->type != UV_NAMED_PIPE) return 0;
+    char namebuf[0];
     size_t len = 0;
-    if (uv_pipe_getpeername(pipe, NULL, &len) != UV_ENOBUFS) return 0;
+    if (pipe->type != UV_NAMED_PIPE)
+        return 0;
+    if (uv_pipe_getpeername(pipe, namebuf, &len) != UV_ENOBUFS)
+        return 0;
     char *name = (char*)alloca(len + 1);
-    if (uv_pipe_getpeername(pipe, name, &len)) return 0;
+    if (uv_pipe_getpeername(pipe, name, &len))
+        return 0;
     name[len] = '\0';
     // return true if name matches regex:
     // ^\\\\?\\pipe\\(msys|cygwin)-[0-9a-z]{16}-[pt]ty[1-9][0-9]*-
     //jl_printf(JL_STDERR,"pipe_name: %s\n", name);
     int n = 0;
-    if (!strncmp(name,"\\\\?\\pipe\\msys-",14))
+    if (!strncmp(name, "\\\\?\\pipe\\msys-", 14))
         n = 14;
-    else if (!strncmp(name,"\\\\?\\pipe\\cygwin-",16))
+    else if (!strncmp(name, "\\\\?\\pipe\\cygwin-", 16))
         n = 16;
     else
         return 0;
     //jl_printf(JL_STDERR,"prefix pass\n");
     name += n;
     for (int n = 0; n < 16; n++)
-        if (!ishexchar(*name++)) return 0;
+        if (!ishexchar(*name++))
+            return 0;
     //jl_printf(JL_STDERR,"hex pass\n");
-    if ((*name++)!='-') return 0;
-    if (*name != 'p' && *name != 't') return 0;
+    if ((*name++)!='-')
+        return 0;
+    if (*name != 'p' && *name != 't')
+        return 0;
     name++;
-    if (*name++ != 't' || *name++ != 'y') return 0;
+    if (*name++ != 't' || *name++ != 'y')
+        return 0;
     //jl_printf(JL_STDERR,"tty pass\n");
     return 1;
 }
diff --git a/stdlib/FileWatching/test/runtests.jl b/stdlib/FileWatching/test/runtests.jl
index 9ba6456d20a98..b9ad8d9bc7777 100644
--- a/stdlib/FileWatching/test/runtests.jl
+++ b/stdlib/FileWatching/test/runtests.jl
@@ -161,7 +161,7 @@ test2_12992()
 #######################################################################
 # This section tests file watchers.                                   #
 #######################################################################
-F_GETPATH = Sys.islinux() || Sys.iswindows() || Sys.isapple()  # platforms where F_GETPATH is available
+F_GETPATH = Sys.islinux() || Sys.iswindows() || Sys.isapple() || Sys.isfreebsd() # platforms where F_GETPATH is available
 F_PATH = F_GETPATH ? "afile.txt" : ""
 dir = mktempdir()
 file = joinpath(dir, "afile.txt")
diff --git a/stdlib/LibUV_jll/Project.toml b/stdlib/LibUV_jll/Project.toml
index 605c1115b3d34..8089516c1df14 100644
--- a/stdlib/LibUV_jll/Project.toml
+++ b/stdlib/LibUV_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LibUV_jll"
 uuid = "183b4373-6708-53ba-ad28-60e28bb38547"
-version = "2.0.1+14"
+version = "2.0.1+15"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/stdlib/REPL/src/precompile.jl b/stdlib/REPL/src/precompile.jl
index 0eea4c140e39b..7299742eaef1c 100644
--- a/stdlib/REPL/src/precompile.jl
+++ b/stdlib/REPL/src/precompile.jl
@@ -4,8 +4,14 @@ module Precompile
 # Can't use this during incremental: `@eval Module() begin``
 
 import ..REPL
+# Prepare this staging area with all the loaded packages available
+for (_pkgid, _mod) in Base.loaded_modules
+    if !(_pkgid.name in ("Main", "Core", "Base", "REPL"))
+        eval(:(const $(Symbol(_mod)) = $_mod))
+    end
+end
 
-# Ugly hack for our cache file to not have a dependency edge on FakePTYs.
+# Ugly hack for our cache file to not have a dependency edge on the FakePTYs file.
 Base._track_dependencies[] = false
 try
     Base.include(@__MODULE__, joinpath(Sys.BINDIR, "..", "share", "julia", "test", "testhelpers", "FakePTYs.jl"))
@@ -172,10 +178,10 @@ generate_precompile_statements() = try
         end
         close(precompile_copy)
         wait(buffer_reader)
-        close(statements_step)
         return :ok
     end
     !PARALLEL_PRECOMPILATION && wait(step)
+    bind(statements_step, step)
 
     # Make statements unique
     statements = Set{String}()
@@ -205,7 +211,7 @@ generate_precompile_statements() = try
         end
     end
 
-    fetch(step) == :ok || throw("Collecting precompiles failed.")
+    fetch(step) == :ok || throw("Collecting precompiles failed: $(c.excp)")
     return nothing
 finally
     GC.gc(true); GC.gc(false); # reduce memory footprint
diff --git a/test/spawn.jl b/test/spawn.jl
index 9d58b32976357..831eac493d4aa 100644
--- a/test/spawn.jl
+++ b/test/spawn.jl
@@ -23,7 +23,7 @@ havebb = false
 
 function _tryonce_download_from_cache(desired_url::AbstractString)
     cache_url = "https://cache.julialang.org/$(desired_url)"
-    cache_output_filename = joinpath(mktempdir(), "myfile")
+    cache_output_filename = joinpath(mktempdir(), "busybox")
     cache_response = Downloads.request(
         cache_url;
         output = cache_output_filename,

From a3e0b62ed2ca13c23a6b40b7789c6001dfe2842e Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Sat, 10 Feb 2024 17:35:36 -0500
Subject: [PATCH 0883/1315] Use tagged CodeInstances for AbstractInterpreter
 caching (#52233)

Currently external AbstractInterpreters all follow the pattern
that `CACHE = IdDict{MethodInstance,CodeInstance}`. The
NativeInterpreter
has the benefit that each `MethodInstance` carries an inline cache of
`CodeInstances`.

`CodeInstances` pull triple duty, they contain validity information
(`min_world`, `max_world`),
the inference state cache and the compilation state cache.

When we currently create a CodeInstance we don't record the owner and we
thus construct detached CodeInstances.

In this PR I introduce the notion of tagging the code instances with the
owner (nothing meaning native),
thus allowing foreign code instances to be stored in the inline cache.

GPUCompiler/CUDA would change it's caching strategy from
`IdDict{MethodInstance, CodeInstance}` to `IdDict{CodeInstance,
LLVM.Module}`
or similar. Ideally we would allow polymorphism for the compilation
state part of the code instance, but that seems to invasive for now.

This has the benefit that CodeInstances are handled by caching and it
would allow us to cache inference results
from foreign abstract interpreters across sessions.

The downside is that the cache walk now is a bit slower since we need to
filter on owner. If this turns out to be
a large bottleneck we could bifurcate the cache on owner.

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
---
 base/boot.jl                            |   6 +-
 base/compiler/cicache.jl                |  17 ++-
 base/compiler/typeinfer.jl              |   2 +-
 base/compiler/types.jl                  |   4 +-
 base/compiler/utilities.jl              |  19 ---
 base/reflection.jl                      |   9 ++
 doc/src/devdocs/ast.md                  |   4 +
 doc/src/devdocs/locks.md                |   1 +
 src/builtins.c                          |   1 +
 src/gf.c                                |  96 +++++-------
 src/jltypes.c                           |  28 ++--
 src/julia.h                             |   4 +-
 src/julia_internal.h                    |   7 +-
 src/method.c                            |   1 -
 src/opaque_closure.c                    |   2 +-
 src/staticdata.c                        |   7 +-
 src/staticdata_utils.c                  |  50 +++---
 stdlib/REPL/src/REPLCompletions.jl      |  37 +----
 test/compiler/AbstractInterpreter.jl    |   5 +-
 test/compiler/EscapeAnalysis/EAUtils.jl |  37 +----
 test/compiler/invalidation.jl           | 193 ++++++++++++++++--------
 test/compiler/newinterp.jl              |  18 +--
 test/core.jl                            |   2 +-
 test/precompile.jl                      |  66 +++++++-
 test/reflection.jl                      |   3 +-
 25 files changed, 340 insertions(+), 279 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index ed26536b961ff..8ca6d392ead67 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -483,13 +483,13 @@ eval(Core, quote
 end)
 
 function CodeInstance(
-    mi::MethodInstance, @nospecialize(rettype), @nospecialize(exctype), @nospecialize(inferred_const),
+    mi::MethodInstance, owner, @nospecialize(rettype), @nospecialize(exctype), @nospecialize(inferred_const),
     @nospecialize(inferred), const_flags::Int32, min_world::UInt, max_world::UInt,
     ipo_effects::UInt32, effects::UInt32, @nospecialize(analysis_results),
     relocatability::UInt8)
     return ccall(:jl_new_codeinst, Ref{CodeInstance},
-        (Any, Any, Any, Any, Any, Int32, UInt, UInt, UInt32, UInt32, Any, UInt8),
-        mi, rettype, exctype, inferred_const, inferred, const_flags, min_world, max_world,
+        (Any, Any, Any, Any, Any, Any, Int32, UInt, UInt, UInt32, UInt32, Any, UInt8),
+        mi, owner, rettype, exctype, inferred_const, inferred, const_flags, min_world, max_world,
         ipo_effects, effects, analysis_results,
         relocatability)
 end
diff --git a/base/compiler/cicache.jl b/base/compiler/cicache.jl
index 8332777e6d5bc..a6ed18fe5105f 100644
--- a/base/compiler/cicache.jl
+++ b/base/compiler/cicache.jl
@@ -7,15 +7,16 @@ Internally, each `MethodInstance` keep a unique global cache of code instances
 that have been created for the given method instance, stratified by world age
 ranges. This struct abstracts over access to this cache.
 """
-struct InternalCodeCache end
+struct InternalCodeCache
+    owner::Any # `jl_egal` is used for comparison
+end
 
 function setindex!(cache::InternalCodeCache, ci::CodeInstance, mi::MethodInstance)
+    @assert ci.owner === cache.owner
     ccall(:jl_mi_cache_insert, Cvoid, (Any, Any), mi, ci)
     return cache
 end
 
-const GLOBAL_CI_CACHE = InternalCodeCache()
-
 struct WorldRange
     min_world::UInt
     max_world::UInt
@@ -49,11 +50,11 @@ WorldView(wvc::WorldView, wr::WorldRange) = WorldView(wvc.cache, wr)
 WorldView(wvc::WorldView, args...) = WorldView(wvc.cache, args...)
 
 function haskey(wvc::WorldView{InternalCodeCache}, mi::MethodInstance)
-    return ccall(:jl_rettype_inferred, Any, (Any, UInt, UInt), mi, first(wvc.worlds), last(wvc.worlds)) !== nothing
+    return ccall(:jl_rettype_inferred, Any, (Any, Any, UInt, UInt), wvc.cache.owner, mi, first(wvc.worlds), last(wvc.worlds)) !== nothing
 end
 
 function get(wvc::WorldView{InternalCodeCache}, mi::MethodInstance, default)
-    r = ccall(:jl_rettype_inferred, Any, (Any, UInt, UInt), mi, first(wvc.worlds), last(wvc.worlds))
+    r = ccall(:jl_rettype_inferred, Any, (Any, Any, UInt, UInt), wvc.cache.owner, mi, first(wvc.worlds), last(wvc.worlds))
     if r === nothing
         return default
     end
@@ -70,3 +71,9 @@ function setindex!(wvc::WorldView{InternalCodeCache}, ci::CodeInstance, mi::Meth
     setindex!(wvc.cache, ci, mi)
     return wvc
 end
+
+function code_cache(interp::AbstractInterpreter)
+    cache = InternalCodeCache(cache_owner(interp))
+    worlds = WorldRange(get_inference_world(interp))
+    return WorldView(cache, worlds)
+end
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index e9edd04e59d40..e30c6e5f96fcb 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -326,7 +326,7 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult,
         end
     end
     # relocatability = isa(inferred_result, String) ? inferred_result[end] : UInt8(0)
-    return CodeInstance(result.linfo,
+    return CodeInstance(result.linfo, cache_owner(interp),
         widenconst(result_type), widenconst(result.exc_result), rettype_const, inferred_result,
         const_flags, first(valid_worlds), last(valid_worlds),
         # TODO: Actually do something with non-IPO effects
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index cdf90a3a6e78c..642a7ac551662 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -14,7 +14,7 @@ the following methods to satisfy the `AbstractInterpreter` API requirement:
 - `OptimizationParams(interp::NewInterpreter)` - return an `OptimizationParams` instance
 - `get_inference_world(interp::NewInterpreter)` - return the world age for this interpreter
 - `get_inference_cache(interp::NewInterpreter)` - return the local inference cache
-- `code_cache(interp::NewInterpreter)` - return the global inference cache
+- `cache_owner(interp::NewInterpreter)` - return the owner of any new cache entries
 """
 :(AbstractInterpreter)
 
@@ -404,7 +404,7 @@ InferenceParams(interp::NativeInterpreter) = interp.inf_params
 OptimizationParams(interp::NativeInterpreter) = interp.opt_params
 get_inference_world(interp::NativeInterpreter) = interp.world
 get_inference_cache(interp::NativeInterpreter) = interp.inf_cache
-code_cache(interp::NativeInterpreter) = WorldView(GLOBAL_CI_CACHE, get_inference_world(interp))
+cache_owner(interp::NativeInterpreter) = nothing
 
 """
     already_inferred_quick_test(::AbstractInterpreter, ::MethodInstance)
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 00c7ea40e3db9..7d554e46a1744 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -321,25 +321,6 @@ function iterate(iter::BackedgeIterator, i::Int=1)
     return BackedgePair(item, backedges[i+1]::MethodInstance), i+2            # `invoke` calls
 end
 
-"""
-    add_invalidation_callback!(callback, mi::MethodInstance)
-
-Register `callback` to be triggered upon the invalidation of `mi`.
-`callback` should a function taking two arguments, `callback(replaced::MethodInstance, max_world::UInt32)`,
-and it will be recursively invoked on `MethodInstance`s within the invalidation graph.
-"""
-function add_invalidation_callback!(@nospecialize(callback), mi::MethodInstance)
-    if !isdefined(mi, :callbacks)
-        callbacks = mi.callbacks = Any[callback]
-    else
-        callbacks = mi.callbacks::Vector{Any}
-        if !any(@nospecialize(cb)->cb===callback, callbacks)
-            push!(callbacks, callback)
-        end
-    end
-    return callbacks
-end
-
 #########
 # types #
 #########
diff --git a/base/reflection.jl b/base/reflection.jl
index f1a385068757c..6c1d785bef81d 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1332,6 +1332,15 @@ function method_instances(@nospecialize(f), @nospecialize(t), world::UInt)
     return results
 end
 
+function method_instance(@nospecialize(f), @nospecialize(t);
+                         world=Base.get_world_counter(), method_table=nothing)
+    tt = signature_type(f, t)
+    mi = ccall(:jl_method_lookup_by_tt, Any,
+                (Any, Csize_t, Any),
+                tt, world, method_table)
+    return mi::Union{Nothing, MethodInstance}
+end
+
 default_debug_info_kind() = unsafe_load(cglobal(:jl_default_debug_info_kind, Cint))
 
 # this type mirrors jl_cgparams_t (documented in julia.h)
diff --git a/doc/src/devdocs/ast.md b/doc/src/devdocs/ast.md
index f829b27663e62..c2cd0e92d58d2 100644
--- a/doc/src/devdocs/ast.md
+++ b/doc/src/devdocs/ast.md
@@ -627,6 +627,10 @@ for important details on how to modify these fields safely.
 
     The `MethodInstance` that this cache entry is derived from.
 
+  * `owner`
+
+    A token that represents the owner of this `CodeInstance`. Will use `jl_egal` to match.
+
 
   * `rettype`/`rettype_const`
 
diff --git a/doc/src/devdocs/locks.md b/doc/src/devdocs/locks.md
index f79f4f2b1e3e3..50cdd738e3b34 100644
--- a/doc/src/devdocs/locks.md
+++ b/doc/src/devdocs/locks.md
@@ -155,6 +155,7 @@ MethodInstance/CodeInstance updates : Method->writelock, codegen lock
 >       * specTypes
 >       * sparam_vals
 >       * def
+>       * owner
 
 >   * These are set by `jl_type_infer` (while holding codegen lock):
 >       * cache
diff --git a/src/builtins.c b/src/builtins.c
index 412ccaf8bab04..29aec53ae5a40 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -2378,6 +2378,7 @@ jl_fptr_args_t jl_get_builtin_fptr(jl_datatype_t *dt)
     jl_typemap_entry_t *entry = (jl_typemap_entry_t*)jl_atomic_load_relaxed(&dt->name->mt->defs);
     jl_method_instance_t *mi = jl_atomic_load_relaxed(&entry->func.method->unspecialized);
     jl_code_instance_t *ci = jl_atomic_load_relaxed(&mi->cache);
+    assert(ci->owner == jl_nothing);
     return jl_atomic_load_relaxed(&ci->specptr.fptr1);
 }
 
diff --git a/src/gf.c b/src/gf.c
index e8a5f7450b724..00613cf9da486 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -316,7 +316,7 @@ jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_a
     jl_atomic_store_relaxed(&m->unspecialized, mi);
     jl_gc_wb(m, mi);
 
-    jl_code_instance_t *codeinst = jl_new_codeinst(mi,
+    jl_code_instance_t *codeinst = jl_new_codeinst(mi, jl_nothing,
         (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, jl_nothing, jl_nothing,
         0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
     jl_mi_cache_insert(mi, codeinst);
@@ -437,11 +437,13 @@ JL_DLLEXPORT jl_value_t *jl_call_in_typeinf_world(jl_value_t **args, int nargs)
     return ret;
 }
 
-JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
+STATIC_INLINE jl_value_t *_jl_rettype_inferred(jl_value_t *owner, jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
 {
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
     while (codeinst) {
-        if (jl_atomic_load_relaxed(&codeinst->min_world) <= min_world && max_world <= jl_atomic_load_relaxed(&codeinst->max_world)) {
+        if (jl_atomic_load_relaxed(&codeinst->min_world) <= min_world &&
+            max_world <= jl_atomic_load_relaxed(&codeinst->max_world) &&
+            jl_egal(codeinst->owner, owner)) {
             jl_value_t *code = jl_atomic_load_relaxed(&codeinst->inferred);
             if (code && (code == jl_nothing || jl_ir_flag_inferred(code)))
                 return (jl_value_t*)codeinst;
@@ -450,24 +452,37 @@ JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_method_instance_t *mi, size_t mi
     }
     return (jl_value_t*)jl_nothing;
 }
-JL_DLLEXPORT jl_value_t *(*const jl_rettype_inferred_addr)(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT = jl_rettype_inferred;
+
+JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_value_t *owner, jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
+{
+    return (jl_value_t*)_jl_rettype_inferred(owner, mi, min_world, max_world);
+}
+
+JL_DLLEXPORT jl_value_t *jl_rettype_inferred_native(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
+{
+    return (jl_value_t*)_jl_rettype_inferred(jl_nothing, mi, min_world, max_world);
+}
+
+JL_DLLEXPORT jl_value_t *(*const jl_rettype_inferred_addr)(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT = jl_rettype_inferred_native;
 
 
 JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
         jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_value_t *rettype,
         size_t min_world, size_t max_world)
 {
+    jl_value_t *owner = jl_nothing; // TODO: owner should be arg
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
     while (codeinst) {
         if (jl_atomic_load_relaxed(&codeinst->min_world) == min_world &&
             jl_atomic_load_relaxed(&codeinst->max_world) == max_world &&
+            jl_egal(codeinst->owner, owner) &&
             jl_egal(codeinst->rettype, rettype)) {
             return codeinst;
         }
         codeinst = jl_atomic_load_relaxed(&codeinst->next);
     }
     codeinst = jl_new_codeinst(
-        mi, rettype, (jl_value_t*)jl_any_type, NULL, NULL,
+        mi, owner, rettype, (jl_value_t*)jl_any_type, NULL, NULL,
         0, min_world, max_world, 0, 0, jl_nothing, 0);
     jl_mi_cache_insert(mi, codeinst);
     return codeinst;
@@ -484,7 +499,8 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
 }
 
 JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
-        jl_method_instance_t *mi, jl_value_t *rettype, jl_value_t *exctype,
+        jl_method_instance_t *mi, jl_value_t *owner,
+        jl_value_t *rettype, jl_value_t *exctype,
         jl_value_t *inferred_const, jl_value_t *inferred,
         int32_t const_flags, size_t min_world, size_t max_world,
         uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
@@ -496,6 +512,7 @@ JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
     jl_code_instance_t *codeinst = (jl_code_instance_t*)jl_gc_alloc(ct->ptls, sizeof(jl_code_instance_t),
             jl_code_instance_type);
     codeinst->def = mi;
+    codeinst->owner = owner;
     jl_atomic_store_relaxed(&codeinst->min_world, min_world);
     jl_atomic_store_relaxed(&codeinst->max_world, max_world);
     codeinst->rettype = rettype;
@@ -548,7 +565,7 @@ static int get_method_unspec_list(jl_typemap_entry_t *def, void *closure)
     if (!jl_is_svec(specializations)) {
         jl_method_instance_t *mi = (jl_method_instance_t*)specializations;
         assert(jl_is_method_instance(mi));
-        if (jl_rettype_inferred(mi, world, world) == jl_nothing)
+        if (jl_rettype_inferred_native(mi, world, world) == jl_nothing)
             jl_array_ptr_1d_push((jl_array_t*)closure, (jl_value_t*)mi);
         return 1;
     }
@@ -558,7 +575,7 @@ static int get_method_unspec_list(jl_typemap_entry_t *def, void *closure)
         jl_method_instance_t *mi = (jl_method_instance_t*)jl_svecref(specializations, i);
         if ((jl_value_t*)mi != jl_nothing) {
             assert(jl_is_method_instance(mi));
-            if (jl_rettype_inferred(mi, world, world) == jl_nothing)
+            if (jl_rettype_inferred_native(mi, world, world) == jl_nothing)
                 jl_array_ptr_1d_push((jl_array_t*)closure, (jl_value_t*)mi);
         }
     }
@@ -678,7 +695,7 @@ JL_DLLEXPORT void jl_set_typeinf_func(jl_value_t *f)
         size_t i, l;
         for (i = 0, l = jl_array_nrows(unspec); i < l; i++) {
             jl_method_instance_t *mi = (jl_method_instance_t*)jl_array_ptr_ref(unspec, i);
-            if (jl_rettype_inferred(mi, world, world) == jl_nothing)
+            if (jl_rettype_inferred_native(mi, world, world) == jl_nothing)
                 jl_type_infer(mi, world, 1);
         }
         JL_GC_POP();
@@ -1627,41 +1644,6 @@ JL_DLLEXPORT jl_value_t *jl_debug_method_invalidation(int state)
     return jl_nothing;
 }
 
-// call external callbacks registered with this method_instance
-static void invalidate_external(jl_method_instance_t *mi, size_t max_world) {
-    jl_array_t *callbacks = mi->callbacks;
-    if (callbacks) {
-        // AbstractInterpreter allows for MethodInstances to be present in non-local caches
-        // inform those caches about the invalidation.
-        JL_TRY {
-            size_t i, l = jl_array_nrows(callbacks);
-            jl_value_t **args;
-            JL_GC_PUSHARGS(args, 3);
-            // these arguments are constant per call
-            args[1] = (jl_value_t*)mi;
-            args[2] = jl_box_uint32(max_world);
-
-            jl_task_t *ct = jl_current_task;
-            size_t last_age = ct->world_age;
-            ct->world_age = jl_get_world_counter();
-
-            jl_value_t **cbs = (jl_value_t**)jl_array_ptr_data(callbacks);
-            for (i = 0; i < l; i++) {
-                args[0] = cbs[i];
-                jl_apply(args, 3);
-            }
-            ct->world_age = last_age;
-            JL_GC_POP();
-        }
-        JL_CATCH {
-            jl_printf((JL_STREAM*)STDERR_FILENO, "error in invalidation callback: ");
-            jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
-            jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
-            jlbacktrace(); // written to STDERR_FILENO
-        }
-    }
-}
-
 static void _invalidate_backedges(jl_method_instance_t *replaced_mi, size_t max_world, int depth);
 
 // recursively invalidate cached methods that had an edge to a replaced method
@@ -1690,7 +1672,6 @@ static void invalidate_method_instance(jl_method_instance_t *replaced, size_t ma
         codeinst = jl_atomic_load_relaxed(&codeinst->next);
     }
     JL_GC_PUSH1(&replaced);
-    invalidate_external(replaced, max_world);
     // recurse to all backedges to update their valid range also
     _invalidate_backedges(replaced, max_world, depth + 1);
     JL_GC_POP();
@@ -1839,7 +1820,6 @@ static int invalidate_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
             }
         }
         if (intersects) {
-            // TODO call invalidate_external here?
             if (_jl_debug_method_invalidation) {
                 jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)mi);
                 jl_value_t *loctag = jl_cstr_to_string("invalidate_mt_cache");
@@ -1924,7 +1904,6 @@ static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *m
         jl_method_instance_t *mi = (jl_method_instance_t*)jl_svecref(specializations, i);
         if ((jl_value_t*)mi != jl_nothing) {
             invalidated = 1;
-            invalidate_external(mi, max_world);
             invalidate_backedges(mi, max_world, "jl_method_table_disable");
         }
     }
@@ -2202,7 +2181,6 @@ void jl_method_table_activate(jl_methtable_t *mt, jl_typemap_entry_t *newentry)
                             jl_array_del_end(backedges, nb - insb);
                         }
                         jl_array_ptr_1d_push(oldmi, (jl_value_t*)mi);
-                        invalidate_external(mi, max_world);
                         if (_jl_debug_method_invalidation && invalidated) {
                             jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)mi);
                             loctag = jl_cstr_to_string("jl_method_table_insert");
@@ -2302,7 +2280,7 @@ static jl_tupletype_t *lookup_arg_type_tuple(jl_value_t *arg1 JL_PROPAGATES_ROOT
     return jl_lookup_arg_tuple_type(arg1, args, nargs, 1);
 }
 
-JL_DLLEXPORT jl_method_instance_t *jl_method_lookup_by_tt(jl_tupletype_t *tt, size_t world, jl_value_t *_mt)
+JL_DLLEXPORT jl_value_t *jl_method_lookup_by_tt(jl_tupletype_t *tt, size_t world, jl_value_t *_mt)
 {
     jl_methtable_t *mt = NULL;
     if (_mt == jl_nothing)
@@ -2311,7 +2289,10 @@ JL_DLLEXPORT jl_method_instance_t *jl_method_lookup_by_tt(jl_tupletype_t *tt, si
         assert(jl_isa(_mt, (jl_value_t*)jl_methtable_type));
         mt = (jl_methtable_t*) _mt;
     }
-    return jl_mt_assoc_by_type(mt, tt, world);
+    jl_method_instance_t* mi = jl_mt_assoc_by_type(mt, tt, world);
+    if (!mi)
+        return jl_nothing;
+    return (jl_value_t*) mi;
 }
 
 JL_DLLEXPORT jl_method_instance_t *jl_method_lookup(jl_value_t **args, size_t nargs, size_t world)
@@ -2503,7 +2484,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
                 jl_code_instance_t *unspec = jl_atomic_load_relaxed(&unspecmi->cache);
                 jl_callptr_t unspec_invoke = NULL;
                 if (unspec && (unspec_invoke = jl_atomic_load_acquire(&unspec->invoke))) {
-                    jl_code_instance_t *codeinst = jl_new_codeinst(mi,
+                    jl_code_instance_t *codeinst = jl_new_codeinst(mi, jl_nothing,
                         (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
                         0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
                     void *unspec_fptr = jl_atomic_load_relaxed(&unspec->specptr.fptr);
@@ -2530,7 +2511,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         compile_option == JL_OPTIONS_COMPILE_MIN) {
         jl_code_info_t *src = jl_code_for_interpreter(mi, world);
         if (!jl_code_requires_compiler(src, 0)) {
-            jl_code_instance_t *codeinst = jl_new_codeinst(mi,
+            jl_code_instance_t *codeinst = jl_new_codeinst(mi, jl_nothing,
                 (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
                 0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
             jl_atomic_store_release(&codeinst->invoke, jl_fptr_interpret_call);
@@ -2565,7 +2546,8 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
             // only these care about the exact specTypes, otherwise we can use it directly
             return ucache;
         }
-        codeinst = jl_new_codeinst(mi, (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
+        codeinst = jl_new_codeinst(mi, jl_nothing,
+            (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
             0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
         void *unspec_fptr = jl_atomic_load_relaxed(&ucache->specptr.fptr);
         if (unspec_fptr) {
@@ -2815,10 +2797,10 @@ static jl_method_instance_t *jl_get_compile_hint_specialization(jl_tupletype_t *
 
 static void _generate_from_hint(jl_method_instance_t *mi, size_t world)
 {
-    jl_value_t *codeinst = jl_rettype_inferred(mi, world, world);
+    jl_value_t *codeinst = jl_rettype_inferred_native(mi, world, world);
     if (codeinst == jl_nothing) {
         (void)jl_type_infer(mi, world, 1);
-        codeinst = jl_rettype_inferred(mi, world, world);
+        codeinst = jl_rettype_inferred_native(mi, world, world);
     }
     if (codeinst != jl_nothing) {
         if (jl_atomic_load_relaxed(&((jl_code_instance_t*)codeinst)->invoke) == jl_fptr_const_return)
@@ -2857,10 +2839,10 @@ JL_DLLEXPORT void jl_compile_method_instance(jl_method_instance_t *mi, jl_tuplet
             jl_method_instance_t *mi2 = jl_specializations_get_linfo(mi->def.method, (jl_value_t*)types2, tpenv2);
             JL_GC_POP();
             jl_atomic_store_relaxed(&mi2->precompiled, 1);
-            if (jl_rettype_inferred(mi2, world, world) == jl_nothing)
+            if (jl_rettype_inferred_native(mi2, world, world) == jl_nothing)
                 (void)jl_type_infer(mi2, world, 1);
             if (jl_typeinf_func && jl_atomic_load_relaxed(&mi->def.method->primary_world) <= tworld) {
-                if (jl_rettype_inferred(mi2, tworld, tworld) == jl_nothing)
+                if (jl_rettype_inferred_native(mi2, tworld, tworld) == jl_nothing)
                     (void)jl_type_infer(mi2, tworld, 1);
             }
         }
diff --git a/src/jltypes.c b/src/jltypes.c
index 84e90303affaa..6f9347c8fadd4 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3265,25 +3265,23 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_method_instance_type =
         jl_new_datatype(jl_symbol("MethodInstance"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(10,
+                        jl_perm_symsvec(9,
                             "def",
                             "specTypes",
                             "sparam_vals",
                             "uninferred",
                             "backedges",
-                            "callbacks",
                             "cache",
                             "inInference",
                             "cache_with_orig",
                             "precompiled"),
-                        jl_svec(10,
+                        jl_svec(9,
                             jl_new_struct(jl_uniontype_type, jl_method_type, jl_module_type),
                             jl_any_type,
                             jl_simplevector_type,
                             jl_any_type,
                             jl_array_any_type,
                             jl_any_type,
-                            jl_any_type,
                             jl_bool_type,
                             jl_bool_type,
                             jl_bool_type),
@@ -3291,7 +3289,7 @@ void jl_init_types(void) JL_GC_DISABLED
                         0, 1, 3);
     // These fields should be constant, but Serialization wants to mutate them in initialization
     //const static uint32_t method_instance_constfields[1] = { 0x00000007 }; // (1<<0)|(1<<1)|(1<<2);
-    const static uint32_t method_instance_atomicfields[1] = { 0x00000248 }; // (1<<3)|(1<<6)|(1<<9);
+    const static uint32_t method_instance_atomicfields[1] = { 0x00000128 }; // (1<<3)|(1<<5)|(1<<8);
     //Fields 4 and 5 must be protected by method->write_lock, and thus all operations on jl_method_instance_t are threadsafe. TODO: except inInference
     //jl_method_instance_type->name->constfields = method_instance_constfields;
     jl_method_instance_type->name->atomicfields = method_instance_atomicfields;
@@ -3299,8 +3297,9 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_code_instance_type =
         jl_new_datatype(jl_symbol("CodeInstance"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(16,
+                        jl_perm_symsvec(17,
                             "def",
+                            "owner",
                             "next",
                             "min_world",
                             "max_world",
@@ -3314,9 +3313,10 @@ void jl_init_types(void) JL_GC_DISABLED
                             "analysis_results",
                             "isspecsig", "precompile", "relocatability",
                             "invoke", "specptr"), // function object decls
-                        jl_svec(16,
+                        jl_svec(17,
                             jl_method_instance_type,
                             jl_any_type,
+                            jl_any_type,
                             jl_ulong_type,
                             jl_ulong_type,
                             jl_any_type,
@@ -3333,11 +3333,11 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_any_type, jl_any_type), // fptrs
                         jl_emptysvec,
                         0, 1, 1);
-    jl_svecset(jl_code_instance_type->types, 1, jl_code_instance_type);
-    const static uint32_t code_instance_constfields[1]  = { 0b0000010101110001 }; // Set fields 1, 5-7, 9, 11 as const
-    const static uint32_t code_instance_atomicfields[1] = { 0b1101001010001110 }; // Set fields 2-4, 8, 10, 13, 15-16 as atomic
-    //Fields 3-4 are only operated on by construction and deserialization, so are const at runtime
-    //Fields 11 and 15 must be protected by locks, and thus all operations on jl_code_instance_t are threadsafe
+    jl_svecset(jl_code_instance_type->types, 2, jl_code_instance_type);
+    const static uint32_t code_instance_constfields[1]  = { 0b00000101011100011 }; // Set fields 1, 2, 6-8, 10, 12 as const
+    const static uint32_t code_instance_atomicfields[1] = { 0b11010010100011100 }; // Set fields 3-5, 9, 11, 14, 16-17 as atomic
+    //Fields 4-5 are only operated on by construction and deserialization, so are const at runtime
+    //Fields 12 and 16 must be protected by locks, and thus all operations on jl_code_instance_t are threadsafe
     jl_code_instance_type->name->constfields = code_instance_constfields;
     jl_code_instance_type->name->atomicfields = code_instance_atomicfields;
 
@@ -3476,9 +3476,9 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_svecset(jl_methtable_type->types, 9, jl_uint8_type);
     jl_svecset(jl_methtable_type->types, 10, jl_uint8_type);
     jl_svecset(jl_method_type->types, 12, jl_method_instance_type);
-    jl_svecset(jl_method_instance_type->types, 6, jl_code_instance_type);
-    jl_svecset(jl_code_instance_type->types, 14, jl_voidpointer_type);
+    jl_svecset(jl_method_instance_type->types, 5, jl_code_instance_type);
     jl_svecset(jl_code_instance_type->types, 15, jl_voidpointer_type);
+    jl_svecset(jl_code_instance_type->types, 16, jl_voidpointer_type);
     jl_svecset(jl_binding_type->types, 1, jl_globalref_type);
     jl_svecset(jl_binding_type->types, 2, jl_binding_type);
 
diff --git a/src/julia.h b/src/julia.h
index 1ad7967528786..852b671f744f6 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -391,7 +391,6 @@ struct _jl_method_instance_t {
     jl_svec_t *sparam_vals; // static parameter values, indexed by def.method->sig
     _Atomic(jl_value_t*) uninferred; // cached uncompressed code, for generated functions, top-level thunks, or the interpreter
     jl_array_t *backedges; // list of method-instances which call this method-instance; `invoke` records (invokesig, caller) pairs
-    jl_array_t *callbacks; // list of callback functions to inform external caches about invalidations
     _Atomic(struct _jl_code_instance_t*) cache;
     uint8_t inInference; // flags to tell if inference is running on this object
     uint8_t cache_with_orig; // !cache_with_specTypes
@@ -412,6 +411,7 @@ typedef struct _jl_opaque_closure_t {
 typedef struct _jl_code_instance_t {
     JL_DATA_TYPE
     jl_method_instance_t *def; // method this is specialized from
+    jl_value_t *owner; // Compiler token this belongs to, `jl_nothing` is reserved for native
     _Atomic(struct _jl_code_instance_t*) next; // pointer to the next cache entry
 
     // world range for which this object is valid to use
@@ -2545,7 +2545,7 @@ typedef struct {
     int gcstack_arg; // Pass the ptls value as an argument with swiftself
 
     int use_jlplt; // Whether to use the Julia PLT mechanism or emit symbols directly
-    // Cache access. Default: jl_rettype_inferred.
+    // Cache access. Default: jl_rettype_inferred_native.
     jl_codeinstance_lookup_t lookup;
 } jl_cgparams_t;
 extern JL_DLLEXPORT int jl_default_debug_info_kind;
diff --git a/src/julia_internal.h b/src/julia_internal.h
index e140dfa205d8e..14b8b4f43ee92 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -669,7 +669,8 @@ jl_method_instance_t *jl_get_unspecialized_from_mi(jl_method_instance_t *method
 jl_method_instance_t *jl_get_unspecialized(jl_method_t *def JL_PROPAGATES_ROOT);
 
 JL_DLLEXPORT jl_code_instance_t* jl_new_codeinst(
-        jl_method_instance_t *mi, jl_value_t *rettype, jl_value_t *exctype,
+        jl_method_instance_t *mi, jl_value_t *owner,
+        jl_value_t *rettype, jl_value_t *exctype,
         jl_value_t *inferred_const, jl_value_t *inferred,
         int32_t const_flags, size_t min_world, size_t max_world,
         uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
@@ -809,7 +810,7 @@ JL_DLLEXPORT int jl_is_toplevel_only_expr(jl_value_t *e) JL_NOTSAFEPOINT;
 jl_value_t *jl_call_scm_on_ast_and_loc(const char *funcname, jl_value_t *expr,
                                        jl_module_t *inmodule, const char *file, int line);
 
-JL_DLLEXPORT jl_method_instance_t *jl_method_lookup_by_tt(jl_tupletype_t *tt, size_t world, jl_value_t *_mt);
+JL_DLLEXPORT jl_value_t *jl_method_lookup_by_tt(jl_tupletype_t *tt, size_t world, jl_value_t *_mt);
 JL_DLLEXPORT jl_method_instance_t *jl_method_lookup(jl_value_t **args, size_t nargs, size_t world);
 
 jl_value_t *jl_gf_invoke_by_method(jl_method_t *method, jl_value_t *gf, jl_value_t **args, size_t nargs);
@@ -1021,7 +1022,7 @@ JL_DLLEXPORT jl_method_t *jl_new_method_uninit(jl_module_t*);
 JL_DLLEXPORT jl_methtable_t *jl_new_method_table(jl_sym_t *name, jl_module_t *module);
 JL_DLLEXPORT jl_method_instance_t *jl_get_specialization1(jl_tupletype_t *types, size_t world, size_t *min_valid, size_t *max_valid, int mt_cache);
 jl_method_instance_t *jl_get_specialized(jl_method_t *m, jl_value_t *types, jl_svec_t *sp);
-JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_method_instance_t *li JL_PROPAGATES_ROOT, size_t min_world, size_t max_world);
+JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_value_t *owner, jl_method_instance_t *li JL_PROPAGATES_ROOT, size_t min_world, size_t max_world);
 JL_DLLEXPORT jl_code_instance_t *jl_method_compiled(jl_method_instance_t *mi JL_PROPAGATES_ROOT, size_t world) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_methtable_lookup(jl_methtable_t *mt JL_PROPAGATES_ROOT, jl_value_t *type, size_t world);
 JL_DLLEXPORT jl_method_instance_t *jl_specializations_get_linfo(
diff --git a/src/method.c b/src/method.c
index 3d3cc4cb7ea4e..88d43fb4b22ee 100644
--- a/src/method.c
+++ b/src/method.c
@@ -488,7 +488,6 @@ JL_DLLEXPORT jl_method_instance_t *jl_new_method_instance_uninit(void)
     mi->sparam_vals = jl_emptysvec;
     jl_atomic_store_relaxed(&mi->uninferred, NULL);
     mi->backedges = NULL;
-    mi->callbacks = NULL;
     jl_atomic_store_relaxed(&mi->cache, NULL);
     mi->inInference = 0;
     mi->cache_with_orig = 0;
diff --git a/src/opaque_closure.c b/src/opaque_closure.c
index 0b0d1052bd449..45b08fee668db 100644
--- a/src/opaque_closure.c
+++ b/src/opaque_closure.c
@@ -153,7 +153,7 @@ JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tuplet
 
     sigtype = jl_argtype_with_function(env, (jl_value_t*)argt);
     jl_method_instance_t *mi = jl_specializations_get_linfo((jl_method_t*)root, sigtype, jl_emptysvec);
-    inst = jl_new_codeinst(mi, rt_ub, (jl_value_t*)jl_any_type, NULL, (jl_value_t*)ci,
+    inst = jl_new_codeinst(mi, jl_nothing, rt_ub, (jl_value_t*)jl_any_type, NULL, (jl_value_t*)ci,
         0, world, world, 0, 0, jl_nothing, 0);
     jl_mi_cache_insert(mi, inst);
 
diff --git a/src/staticdata.c b/src/staticdata.c
index 8489fa116688e..0d38dddb79aaf 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -803,7 +803,6 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
             // so must not be present here
             record_field_change((jl_value_t**)&mi->uninferred, NULL);
             record_field_change((jl_value_t**)&mi->backedges, NULL);
-            record_field_change((jl_value_t**)&mi->callbacks, NULL);
             record_field_change((jl_value_t**)&mi->cache, NULL);
         }
         else {
@@ -835,6 +834,11 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_
     if (s->incremental && jl_is_code_instance(v)) {
         jl_code_instance_t *ci = (jl_code_instance_t*)v;
         // make sure we don't serialize other reachable cache entries of foreign methods
+        // Should this now be:
+        // if (ci !in ci->defs->cache)
+        //     record_field_change((jl_value_t**)&ci->next, NULL);
+        // Why are we checking that the method/module this originates from is in_image?
+        // and then disconnect this CI?
         if (jl_object_in_image((jl_value_t*)ci->def->def.value)) {
             // TODO: if (ci in ci->defs->cache)
             record_field_change((jl_value_t**)&ci->next, NULL);
@@ -2392,7 +2396,6 @@ static void strip_specializations_(jl_method_instance_t *mi)
     if (jl_options.strip_ir) {
         record_field_change((jl_value_t**)&mi->uninferred, NULL);
         record_field_change((jl_value_t**)&mi->backedges, NULL);
-        record_field_change((jl_value_t**)&mi->callbacks, NULL);
     }
 }
 
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index aa39c53844a56..fc7a59d9d0bf9 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -239,11 +239,7 @@ static jl_array_t *queue_external_cis(jl_array_t *list)
             assert(found == 0 || found == 1 || found == 2);
             assert(stack.len == 0);
             if (found == 1 && jl_atomic_load_relaxed(&ci->max_world) == ~(size_t)0) {
-                void **bp = ptrhash_bp(&visited, mi);
-                if (*bp != (void*)((char*)HT_NOTFOUND + 3)) {
-                    *bp = (void*)((char*)HT_NOTFOUND + 3);
-                    jl_array_ptr_1d_push(new_ext_cis, (jl_value_t*)ci);
-                }
+                jl_array_ptr_1d_push(new_ext_cis, (jl_value_t*)ci);
             }
         }
     }
@@ -1188,13 +1184,23 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
         jl_code_instance_t *ci = (jl_code_instance_t*)jl_array_ptr_ref(ext_ci_list, i);
         if (jl_atomic_load_relaxed(&ci->max_world) == WORLD_AGE_REVALIDATION_SENTINEL) {
             assert(jl_atomic_load_relaxed(&ci->min_world) == minworld);
-            ptrhash_put(&cis_pending_validation, (void*)ci->def, (void*)ci);
+            void **bp = ptrhash_bp(&cis_pending_validation, (void*)ci->def);
+            assert(!jl_atomic_load_relaxed(&ci->next));
+            if (*bp == HT_NOTFOUND)
+                *bp = (void*)ci;
+            else {
+                // Do ci->owner bifurcates the cache, we temporarily
+                // form a linked list of all the CI that need to be connected later
+                jl_code_instance_t *prev_ci = (jl_code_instance_t *)*bp;
+                jl_atomic_store_relaxed(&ci->next, prev_ci);
+                *bp = (void*)ci;
+            }
         }
         else {
             assert(jl_atomic_load_relaxed(&ci->min_world) == 1);
             assert(jl_atomic_load_relaxed(&ci->max_world) == ~(size_t)0);
             jl_method_instance_t *caller = ci->def;
-            if (jl_atomic_load_relaxed(&ci->inferred) && jl_rettype_inferred(caller, minworld, ~(size_t)0) == jl_nothing) {
+            if (jl_atomic_load_relaxed(&ci->inferred) && jl_rettype_inferred(ci->owner, caller, minworld, ~(size_t)0) == jl_nothing) {
                 jl_mi_cache_insert(caller, ci);
             }
             //jl_static_show((JL_STREAM*)ios_stderr, (jl_value_t*)caller);
@@ -1237,18 +1243,26 @@ static void jl_insert_backedges(jl_array_t *edges, jl_array_t *ext_targets, jl_a
             // Update any external CIs and add them to the cache.
             assert(jl_is_code_instance(ci));
             jl_code_instance_t *codeinst = (jl_code_instance_t*)ci;
-            assert(jl_atomic_load_relaxed(&codeinst->min_world) == minworld);
-            assert(jl_atomic_load_relaxed(&codeinst->max_world) == WORLD_AGE_REVALIDATION_SENTINEL);
-            assert(jl_atomic_load_relaxed(&codeinst->inferred));
-            jl_atomic_store_relaxed(&codeinst->max_world, maxvalid);
-
-            if (jl_rettype_inferred(caller, minworld, maxvalid) != jl_nothing) {
-                // We already got a code instance for this world age range from somewhere else - we don't need
-                // this one.
-                continue;
+            while (codeinst) {
+                jl_code_instance_t *next_ci = jl_atomic_load_relaxed(&codeinst->next);
+                jl_atomic_store_relaxed(&codeinst->next, NULL);
+
+                jl_value_t *owner = codeinst->owner;
+                JL_GC_PROMISE_ROOTED(owner);
+
+                assert(jl_atomic_load_relaxed(&codeinst->min_world) == minworld);
+                assert(jl_atomic_load_relaxed(&codeinst->max_world) == WORLD_AGE_REVALIDATION_SENTINEL);
+                assert(jl_atomic_load_relaxed(&codeinst->inferred));
+                jl_atomic_store_relaxed(&codeinst->max_world, maxvalid);
+
+                if (jl_rettype_inferred(owner, caller, minworld, maxvalid) != jl_nothing) {
+                    // We already got a code instance for this world age range from somewhere else - we don't need
+                    // this one.
+                } else {
+                    jl_mi_cache_insert(caller, codeinst);
+                }
+                codeinst = next_ci;
             }
-
-            jl_mi_cache_insert(caller, codeinst);
         }
         else {
             // Likely internal. Find the CI already in the cache hierarchy.
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index cd779b8868a37..215814dc8cada 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -527,25 +527,7 @@ function find_start_brace(s::AbstractString; c_start='(', c_end=')')
     return (startind:lastindex(s), method_name_end)
 end
 
-struct REPLInterpreterCache
-    dict::IdDict{MethodInstance,CodeInstance}
-end
-REPLInterpreterCache() = REPLInterpreterCache(IdDict{MethodInstance,CodeInstance}())
-const REPL_INTERPRETER_CACHE = REPLInterpreterCache()
-
-function get_code_cache()
-    # XXX Avoid storing analysis results into the cache that persists across precompilation,
-    #     as [sys|pkg]image currently doesn't support serializing externally created `CodeInstance`.
-    #     Otherwise, `CodeInstance`s created by `REPLInterpreter`, that are much less optimized
-    #     that those produced by `NativeInterpreter`, will leak into the native code cache,
-    #     potentially causing runtime slowdown.
-    #     (see https://github.com/JuliaLang/julia/issues/48453).
-    if Base.generating_output()
-        return REPLInterpreterCache()
-    else
-        return REPL_INTERPRETER_CACHE
-    end
-end
+struct REPLCacheToken end
 
 struct REPLInterpreter <: CC.AbstractInterpreter
     limit_aggressive_inference::Bool
@@ -553,32 +535,21 @@ struct REPLInterpreter <: CC.AbstractInterpreter
     inf_params::CC.InferenceParams
     opt_params::CC.OptimizationParams
     inf_cache::Vector{CC.InferenceResult}
-    code_cache::REPLInterpreterCache
     function REPLInterpreter(limit_aggressive_inference::Bool=false;
                              world::UInt = Base.get_world_counter(),
                              inf_params::CC.InferenceParams = CC.InferenceParams(;
                                  aggressive_constant_propagation=true,
                                  unoptimize_throw_blocks=false),
                              opt_params::CC.OptimizationParams = CC.OptimizationParams(),
-                             inf_cache::Vector{CC.InferenceResult} = CC.InferenceResult[],
-                             code_cache::REPLInterpreterCache = get_code_cache())
-        return new(limit_aggressive_inference, world, inf_params, opt_params, inf_cache, code_cache)
+                             inf_cache::Vector{CC.InferenceResult} = CC.InferenceResult[])
+        return new(limit_aggressive_inference, world, inf_params, opt_params, inf_cache)
     end
 end
 CC.InferenceParams(interp::REPLInterpreter) = interp.inf_params
 CC.OptimizationParams(interp::REPLInterpreter) = interp.opt_params
 CC.get_inference_world(interp::REPLInterpreter) = interp.world
 CC.get_inference_cache(interp::REPLInterpreter) = interp.inf_cache
-CC.code_cache(interp::REPLInterpreter) = CC.WorldView(interp.code_cache, CC.WorldRange(interp.world))
-CC.get(wvc::CC.WorldView{REPLInterpreterCache}, mi::MethodInstance, default) = get(wvc.cache.dict, mi, default)
-CC.getindex(wvc::CC.WorldView{REPLInterpreterCache}, mi::MethodInstance) = getindex(wvc.cache.dict, mi)
-CC.haskey(wvc::CC.WorldView{REPLInterpreterCache}, mi::MethodInstance) = haskey(wvc.cache.dict, mi)
-function CC.setindex!(wvc::CC.WorldView{REPLInterpreterCache}, ci::CodeInstance, mi::MethodInstance)
-    CC.add_invalidation_callback!(mi) do replaced::MethodInstance, max_world::UInt32
-        delete!(wvc.cache.dict, replaced)
-    end
-    return setindex!(wvc.cache.dict, ci, mi)
-end
+CC.cache_owner(::REPLInterpreter) = REPLCacheToken()
 
 # REPLInterpreter is only used for type analysis, so it should disable optimization entirely
 CC.may_optimize(::REPLInterpreter) = false
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 77636bfba9a17..c0b320009b8ec 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -368,7 +368,7 @@ let NoinlineModule = Module()
     # it should work for cached results
     method = only(methods(inlined_usually, (Float64,Float64,Float64,)))
     mi = CC.specialize_method(method, Tuple{typeof(inlined_usually),Float64,Float64,Float64}, Core.svec())
-    @test haskey(interp.code_cache.dict, mi)
+    @test CC.haskey(CC.code_cache(interp), mi)
     let src = code_typed1((Float64,Float64,Float64); interp) do x, y, z
             inlined_usually(x, y, z)
         end
@@ -442,7 +442,8 @@ function custom_lookup(mi::MethodInstance, min_world::UInt, max_world::UInt)
             end
         end
     end
-    return CONST_INVOKE_INTERP.code_cache.dict[mi]
+    # XXX: This seems buggy, custom_lookup should probably construct the absint on demand.
+    return CC.getindex(CC.code_cache(CONST_INVOKE_INTERP), mi)
 end
 
 let # generate cache
diff --git a/test/compiler/EscapeAnalysis/EAUtils.jl b/test/compiler/EscapeAnalysis/EAUtils.jl
index 2a4f04f8f79ea..87228aaf2858a 100644
--- a/test/compiler/EscapeAnalysis/EAUtils.jl
+++ b/test/compiler/EscapeAnalysis/EAUtils.jl
@@ -62,7 +62,7 @@ __clear_cache!() = empty!(GLOBAL_EA_CODE_CACHE)
 # imports
 import .CC:
     AbstractInterpreter, NativeInterpreter, WorldView, WorldRange,
-    InferenceParams, OptimizationParams, get_world_counter, get_inference_cache, code_cache,
+    InferenceParams, OptimizationParams, get_world_counter, get_inference_cache,
     ipo_dataflow_analysis!, cache_result!
 # usings
 using Core:
@@ -71,11 +71,7 @@ using .CC:
     InferenceResult, OptimizationState, IRCode
 using .EA: analyze_escapes, ArgEscapeCache, EscapeInfo, EscapeState
 
-struct CodeCache
-    cache::IdDict{MethodInstance,CodeInstance}
-end
-CodeCache() = CodeCache(IdDict{MethodInstance,CodeInstance}())
-const GLOBAL_CODE_CACHE = CodeCache()
+struct EAToken end
 
 # when working outside of Core.Compiler,
 # cache entire escape state for later inspection and debugging
@@ -86,7 +82,7 @@ struct EscapeCacheInfo
 end
 
 struct EscapeCache
-    cache::IdDict{MethodInstance,EscapeCacheInfo}
+    cache::IdDict{MethodInstance,EscapeCacheInfo} # TODO(aviatesk) Should this be CodeInstance to EscapeCacheInfo?
 end
 EscapeCache() = EscapeCache(IdDict{MethodInstance,EscapeCacheInfo}())
 const GLOBAL_ESCAPE_CACHE = EscapeCache()
@@ -102,17 +98,15 @@ mutable struct EscapeAnalyzer <: AbstractInterpreter
     const inf_params::InferenceParams
     const opt_params::OptimizationParams
     const inf_cache::Vector{InferenceResult}
-    const code_cache::CodeCache
     const escape_cache::EscapeCache
     const entry_mi::MethodInstance
     result::EscapeResultForEntry
     function EscapeAnalyzer(world::UInt, entry_mi::MethodInstance,
-                            code_cache::CodeCache=GLOBAL_CODE_CACHE,
                             escape_cache::EscapeCache=GLOBAL_ESCAPE_CACHE)
         inf_params = InferenceParams()
         opt_params = OptimizationParams()
         inf_cache = InferenceResult[]
-        return new(world, inf_params, opt_params, inf_cache, code_cache, escape_cache, entry_mi)
+        return new(world, inf_params, opt_params, inf_cache, escape_cache, entry_mi)
     end
 end
 
@@ -120,28 +114,7 @@ CC.InferenceParams(interp::EscapeAnalyzer) = interp.inf_params
 CC.OptimizationParams(interp::EscapeAnalyzer) = interp.opt_params
 CC.get_inference_world(interp::EscapeAnalyzer) = interp.world
 CC.get_inference_cache(interp::EscapeAnalyzer) = interp.inf_cache
-
-struct EscapeAnalyzerCacheView
-    code_cache::CodeCache
-    escape_cache::EscapeCache
-end
-
-function CC.code_cache(interp::EscapeAnalyzer)
-    worlds = WorldRange(CC.get_inference_world(interp))
-    return WorldView(EscapeAnalyzerCacheView(interp.code_cache, interp.escape_cache), worlds)
-end
-CC.haskey(wvc::WorldView{EscapeAnalyzerCacheView}, mi::MethodInstance) = haskey(wvc.cache.code_cache.cache, mi)
-CC.get(wvc::WorldView{EscapeAnalyzerCacheView}, mi::MethodInstance, default) = get(wvc.cache.code_cache.cache, mi, default)
-CC.getindex(wvc::WorldView{EscapeAnalyzerCacheView}, mi::MethodInstance) = getindex(wvc.cache.code_cache.cache, mi)
-function CC.setindex!(wvc::WorldView{EscapeAnalyzerCacheView}, ci::CodeInstance, mi::MethodInstance)
-    wvc.cache.code_cache.cache[mi] = ci
-    # register the callback on invalidation
-    CC.add_invalidation_callback!(mi) do replaced::MethodInstance, max_world::UInt32
-        delete!(wvc.cache.code_cache.cache, replaced)
-        delete!(wvc.cache.escape_cache.cache, replaced)
-    end
-    return wvc
-end
+CC.cache_owner(::EscapeAnalyzer) = EAToken()
 
 function CC.ipo_dataflow_analysis!(interp::EscapeAnalyzer, ir::IRCode, caller::InferenceResult)
     # run EA on all frames that have been optimized
diff --git a/test/compiler/invalidation.jl b/test/compiler/invalidation.jl
index e3263156499c8..d5e86ca533f05 100644
--- a/test/compiler/invalidation.jl
+++ b/test/compiler/invalidation.jl
@@ -7,51 +7,28 @@ include("irutils.jl")
 
 using Test
 const CC = Core.Compiler
-import Core: MethodInstance, CodeInstance
-import .CC: WorldRange, WorldView
 
-struct InvalidationTesterCache
-    dict::IdDict{MethodInstance,CodeInstance}
-end
-InvalidationTesterCache() = InvalidationTesterCache(IdDict{MethodInstance,CodeInstance}())
-
-const INVALIDATION_TESTER_CACHE = InvalidationTesterCache()
+struct InvalidationTesterToken end
 
 struct InvalidationTester <: CC.AbstractInterpreter
     world::UInt
     inf_params::CC.InferenceParams
     opt_params::CC.OptimizationParams
     inf_cache::Vector{CC.InferenceResult}
-    code_cache::InvalidationTesterCache
     function InvalidationTester(;
                                 world::UInt = Base.get_world_counter(),
                                 inf_params::CC.InferenceParams = CC.InferenceParams(),
                                 opt_params::CC.OptimizationParams = CC.OptimizationParams(),
-                                inf_cache::Vector{CC.InferenceResult} = CC.InferenceResult[],
-                                code_cache::InvalidationTesterCache = INVALIDATION_TESTER_CACHE)
-        return new(world, inf_params, opt_params, inf_cache, code_cache)
+                                inf_cache::Vector{CC.InferenceResult} = CC.InferenceResult[])
+        return new(world, inf_params, opt_params, inf_cache)
     end
 end
 
-struct InvalidationTesterCacheView
-    dict::IdDict{MethodInstance,CodeInstance}
-end
-
 CC.InferenceParams(interp::InvalidationTester) = interp.inf_params
 CC.OptimizationParams(interp::InvalidationTester) = interp.opt_params
 CC.get_inference_world(interp::InvalidationTester) = interp.world
 CC.get_inference_cache(interp::InvalidationTester) = interp.inf_cache
-CC.code_cache(interp::InvalidationTester) = WorldView(InvalidationTesterCacheView(interp.code_cache.dict), WorldRange(interp.world))
-CC.get(wvc::WorldView{InvalidationTesterCacheView}, mi::MethodInstance, default) = get(wvc.cache.dict, mi, default)
-CC.getindex(wvc::WorldView{InvalidationTesterCacheView}, mi::MethodInstance) = getindex(wvc.cache.dict, mi)
-CC.haskey(wvc::WorldView{InvalidationTesterCacheView}, mi::MethodInstance) = haskey(wvc.cache.dict, mi)
-function CC.setindex!(wvc::WorldView{InvalidationTesterCacheView}, ci::CodeInstance, mi::MethodInstance)
-    CC.add_invalidation_callback!(mi) do replaced::MethodInstance, max_world::UInt32
-        delete!(wvc.cache.dict, replaced)
-        # Core.println("[InvalidationTester] ", replaced) # debug
-    end
-    setindex!(wvc.cache.dict, ci, mi)
-end
+CC.cache_owner(::InvalidationTester) = InvalidationTesterToken()
 
 # basic functionality test
 # ------------------------
@@ -63,33 +40,55 @@ basic_caller(x) = basic_callee(x)
 @test Base.return_types((Float64,); interp=InvalidationTester()) do x
     basic_caller(x)
 end |> only === Float64
-@test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-    mi.def.name === :basic_callee
+
+let mi = Base.method_instance(basic_callee, (Float64,))
+    ci = mi.cache
+    @test !isdefined(ci, :next)
+    @test ci.owner === InvalidationTesterToken()
+    @test ci.max_world == typemax(UInt)
 end
-@test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-    mi.def.name === :basic_caller
+
+let mi = Base.method_instance(basic_caller, (Float64,))
+    ci = mi.cache
+    @test !isdefined(ci, :next)
+    @test ci.owner === InvalidationTesterToken()
+    @test ci.max_world == typemax(UInt)
 end
 
 # this redefinition below should invalidate the cache
+const BASIC_CALLER_WORLD = Base.get_world_counter()
 basic_callee(x) = x, x
-@test !any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-    mi.def.name === :basic_callee
-end
-@test !any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-    mi.def.name === :basic_caller
+@test !isdefined(Base.method_instance(basic_callee, (Float64,)), :cache)
+let mi = Base.method_instance(basic_caller, (Float64,))
+    ci = mi.cache
+    @test !isdefined(ci, :next)
+    @test ci.owner === InvalidationTesterToken()
+    @test ci.max_world == BASIC_CALLER_WORLD
 end
 
 # re-run inference and check the result is updated (and new cache exists)
 @test Base.return_types((Float64,); interp=InvalidationTester()) do x
     basic_caller(x)
 end |> only === Tuple{Float64,Float64}
-@test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-    mi.def.name === :basic_callee
+let mi = Base.method_instance(basic_callee, (Float64,))
+    ci = mi.cache
+    @test !isdefined(ci, :next)
+    @test ci.owner === InvalidationTesterToken()
+    @test ci.max_world == typemax(UInt)
 end
-@test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-    mi.def.name === :basic_caller
+
+let mi = Base.method_instance(basic_caller, (Float64,))
+    ci = mi.cache
+    @test isdefined(ci, :next)
+    @test ci.owner === InvalidationTesterToken()
+    @test ci.max_world == typemax(UInt)
+    ci = ci.next
+    @test !isdefined(ci, :next)
+    @test ci.owner === InvalidationTesterToken()
+    @test ci.max_world != typemax(UInt)
 end
 
+
 # backedge optimization
 # ---------------------
 
@@ -115,24 +114,47 @@ begin take!(GLOBAL_BUFFER)
         @test rt === Any
         @test any(iscall((src, pr48932_callee)), src.code)
     end
-    @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_callee
+
+    let mi = only(Base.specializations(Base.only(Base.methods(pr48932_callee))))
+        # Base.method_instance(pr48932_callee, (Any,))
+        ci = mi.cache
+        @test isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world == typemax(UInt)
+
+        # In cache due to Base.return_types(pr48932_callee, (Any,))
+        ci = ci.next
+        @test !isdefined(ci, :next)
+        @test ci.owner === nothing
+        @test ci.max_world == typemax(UInt)
     end
-    @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_caller
+    let mi = Base.method_instance(pr48932_caller, (Int,))
+        ci = mi.cache
+        @test !isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world == typemax(UInt)
     end
+
     @test 42 == pr48932_caller(42)
     @test "42" == String(take!(GLOBAL_BUFFER))
 
     # test that we didn't add the backedge from `pr48932_callee` to `pr48932_caller`:
     # this redefinition below should invalidate the cache of `pr48932_callee` but not that of `pr48932_caller`
     pr48932_callee(x) = (print(GLOBAL_BUFFER, x); nothing)
-    @test !any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_callee
-    end
-    @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_caller
+
+    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee))))
+    let mi = only(Base.specializations(Base.only(Base.methods(pr48932_caller))))
+        # Base.method_instance(pr48932_callee, (Any,))
+        ci = mi.cache
+        @test isdefined(ci, :next)
+        @test ci.owner === nothing
+        @test ci.max_world == typemax(UInt)
+        ci = ci.next
+        @test !isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world == typemax(UInt)
     end
+
     @test isnothing(pr48932_caller(42))
     @test "42" == String(take!(GLOBAL_BUFFER))
 end
@@ -159,23 +181,41 @@ begin take!(GLOBAL_BUFFER)
         @test rt === Nothing
         @test any(iscall((src, pr48932_callee_inferable)), src.code)
     end
-    @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_callee_inferable
+
+    let mi = only(Base.specializations(Base.only(Base.methods(pr48932_callee_inferable))))
+        ci = mi.cache
+        @test isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world == typemax(UInt)
+        ci = ci.next
+        @test !isdefined(ci, :next)
+        @test ci.owner === nothing
+        @test ci.max_world == typemax(UInt)
     end
-    @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_caller_unuse
+    let mi = Base.method_instance(pr48932_caller_unuse, (Int,))
+        ci = mi.cache
+        @test !isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world == typemax(UInt)
     end
+
     @test isnothing(pr48932_caller_unuse(42))
     @test "42" == String(take!(GLOBAL_BUFFER))
 
     # test that we didn't add the backedge from `pr48932_callee_inferable` to `pr48932_caller_unuse`:
     # this redefinition below should invalidate the cache of `pr48932_callee_inferable` but not that of `pr48932_caller_unuse`
     pr48932_callee_inferable(x) = (print(GLOBAL_BUFFER, "foo"); x)
-    @test !any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_callee_inferable
-    end
-    @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_caller_unuse
+
+    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee_inferable))))
+    let mi = Base.method_instance(pr48932_caller_unuse, (Int,))
+        ci = mi.cache
+        @test isdefined(ci, :next)
+        @test ci.owner === nothing
+        @test ci.max_world == typemax(UInt)
+        ci = ci.next
+        @test !isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world == typemax(UInt)
     end
     @test isnothing(pr48932_caller_unuse(42))
     @test "foo" == String(take!(GLOBAL_BUFFER))
@@ -201,24 +241,43 @@ begin take!(GLOBAL_BUFFER)
         @test rt === Any
         @test any(isinvoke(:pr48932_callee_inlined), src.code)
     end
-    @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_callee_inlined
+
+    let mi = Base.method_instance(pr48932_callee_inlined, (Int,))
+        ci = mi.cache
+        @test isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world == typemax(UInt)
+        ci = ci.next
+        @test !isdefined(ci, :next)
+        @test ci.owner === nothing
+        @test ci.max_world == typemax(UInt)
     end
-    @test any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_caller_inlined
+    let mi = Base.method_instance(pr48932_caller_inlined, (Int,))
+        ci = mi.cache
+        @test !isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world == typemax(UInt)
     end
+
     @test 42 == pr48932_caller_inlined(42)
     @test "42" == String(take!(GLOBAL_BUFFER))
 
     # test that we added the backedge from `pr48932_callee_inlined` to `pr48932_caller_inlined`:
     # this redefinition below should invalidate the cache of `pr48932_callee_inlined` but not that of `pr48932_caller_inlined`
     @noinline pr48932_callee_inlined(@nospecialize x) = (print(GLOBAL_BUFFER, x); nothing)
-    @test !any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_callee_inlined
-    end
-    @test !any(INVALIDATION_TESTER_CACHE.dict) do (mi, ci)
-        mi.def.name === :pr48932_caller_inlined
+
+    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee_inlined))))
+    let mi = Base.method_instance(pr48932_caller_inlined, (Int,))
+        ci = mi.cache
+        @test isdefined(ci, :next)
+        @test ci.owner === nothing
+        @test ci.max_world != typemax(UInt)
+        ci = ci.next
+        @test !isdefined(ci, :next)
+        @test ci.owner === InvalidationTesterToken()
+        @test ci.max_world != typemax(UInt)
     end
+
     @test isnothing(pr48932_caller_inlined(42))
     @test "42" == String(take!(GLOBAL_BUFFER))
 end
diff --git a/test/compiler/newinterp.jl b/test/compiler/newinterp.jl
index 4b2cabcf33c3b..1157a52ebbcbe 100644
--- a/test/compiler/newinterp.jl
+++ b/test/compiler/newinterp.jl
@@ -9,39 +9,29 @@ Defines new `NewInterpreter <: AbstractInterpreter` whose cache is separated
 from the native code cache, satisfying the minimum interface requirements.
 """
 macro newinterp(InterpName)
-    InterpCacheName = esc(Symbol(string(InterpName, "Cache")))
+    InterpCacheName = QuoteNode(Symbol(string(InterpName, "Cache")))
     InterpName = esc(InterpName)
     C = Core
     CC = Core.Compiler
     quote
-        struct $InterpCacheName
-            dict::IdDict{$C.MethodInstance,$C.CodeInstance}
-        end
-        $InterpCacheName() = $InterpCacheName(IdDict{$C.MethodInstance,$C.CodeInstance}())
         struct $InterpName <: $CC.AbstractInterpreter
             meta # additional information
             world::UInt
             inf_params::$CC.InferenceParams
             opt_params::$CC.OptimizationParams
             inf_cache::Vector{$CC.InferenceResult}
-            code_cache::$InterpCacheName
             function $InterpName(meta = nothing;
                                  world::UInt = Base.get_world_counter(),
                                  inf_params::$CC.InferenceParams = $CC.InferenceParams(),
                                  opt_params::$CC.OptimizationParams = $CC.OptimizationParams(),
-                                 inf_cache::Vector{$CC.InferenceResult} = $CC.InferenceResult[],
-                                 code_cache::$InterpCacheName = $InterpCacheName())
-                return new(meta, world, inf_params, opt_params, inf_cache, code_cache)
+                                 inf_cache::Vector{$CC.InferenceResult} = $CC.InferenceResult[])
+                return new(meta, world, inf_params, opt_params, inf_cache)
             end
         end
         $CC.InferenceParams(interp::$InterpName) = interp.inf_params
         $CC.OptimizationParams(interp::$InterpName) = interp.opt_params
         $CC.get_inference_world(interp::$InterpName) = interp.world
         $CC.get_inference_cache(interp::$InterpName) = interp.inf_cache
-        $CC.code_cache(interp::$InterpName) = $CC.WorldView(interp.code_cache, $CC.WorldRange(interp.world))
-        $CC.get(wvc::$CC.WorldView{$InterpCacheName}, mi::$C.MethodInstance, default) = get(wvc.cache.dict, mi, default)
-        $CC.getindex(wvc::$CC.WorldView{$InterpCacheName}, mi::$C.MethodInstance) = getindex(wvc.cache.dict, mi)
-        $CC.haskey(wvc::$CC.WorldView{$InterpCacheName}, mi::$C.MethodInstance) = haskey(wvc.cache.dict, mi)
-        $CC.setindex!(wvc::$CC.WorldView{$InterpCacheName}, ci::$C.CodeInstance, mi::$C.MethodInstance) = setindex!(wvc.cache.dict, ci, mi)
+        $CC.cache_owner(::$InterpName) = $InterpCacheName
     end
 end
diff --git a/test/core.jl b/test/core.jl
index a2c3b3cff9e6b..504cfe99ba68c 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -14,7 +14,7 @@ include("testenv.jl")
 # sanity tests that our built-in types are marked correctly for const fields
 for (T, c) in (
         (Core.CodeInfo, []),
-        (Core.CodeInstance, [:def, :rettype, :exctype, :rettype_const, :ipo_purity_bits, :analysis_results]),
+        (Core.CodeInstance, [:def, :owner, :rettype, :exctype, :rettype_const, :ipo_purity_bits, :analysis_results]),
         (Core.Method, [#=:name, :module, :file, :line, :primary_world, :sig, :slot_syms, :external_mt, :nargs, :called, :nospecialize, :nkw, :isva, :is_for_opaque_closure, :constprop=#]),
         (Core.MethodInstance, [#=:def, :specTypes, :sparam_vals=#]),
         (Core.MethodTable, [:module]),
diff --git a/test/precompile.jl b/test/precompile.jl
index d1360d1a06357..90086ff7b7385 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1694,13 +1694,14 @@ precompile_test_harness("Issue #46558") do load_path
     @test (@eval $Foo.foo(1)) == 2
 end
 
+# TODO: Decide if we need to keep supporting this.
 precompile_test_harness("issue #46296") do load_path
     write(joinpath(load_path, "CodeInstancePrecompile.jl"),
         """
         module CodeInstancePrecompile
 
         mi = first(Base.specializations(first(methods(identity))))
-        ci = Core.CodeInstance(mi, Any, Any, nothing, nothing, zero(Int32), typemin(UInt),
+        ci = Core.CodeInstance(mi, nothing, Any, Any, nothing, nothing, zero(Int32), typemin(UInt),
                                typemax(UInt), zero(UInt32), zero(UInt32), nothing, 0x00)
 
         __init__() = @assert ci isa Core.CodeInstance
@@ -1711,6 +1712,69 @@ precompile_test_harness("issue #46296") do load_path
     (@eval (using CodeInstancePrecompile))
 end
 
+precompile_test_harness("AbstractInterpreter caching") do load_path
+    write(joinpath(load_path, "SimpleModule.jl"),
+        """
+        module SimpleModule
+            basic_callee(x) = x
+            basic_caller(x) = basic_callee(x)
+        end
+        """)
+    write(joinpath(load_path, "CustomAbstractInterpreterCaching.jl"),
+        """
+        module CustomAbstractInterpreterCaching
+            import SimpleModule: basic_caller, basic_callee
+            module Custom
+                const CC = Core.Compiler
+
+                struct InvalidationTesterToken end
+
+                struct InvalidationTester <: CC.AbstractInterpreter
+                    world::UInt
+                    inf_params::CC.InferenceParams
+                    opt_params::CC.OptimizationParams
+                    inf_cache::Vector{CC.InferenceResult}
+                    function InvalidationTester(;
+                                                world::UInt = Base.get_world_counter(),
+                                                inf_params::CC.InferenceParams = CC.InferenceParams(),
+                                                opt_params::CC.OptimizationParams = CC.OptimizationParams(),
+                                                inf_cache::Vector{CC.InferenceResult} = CC.InferenceResult[])
+                        return new(world, inf_params, opt_params, inf_cache)
+                    end
+                end
+
+                CC.InferenceParams(interp::InvalidationTester) = interp.inf_params
+                CC.OptimizationParams(interp::InvalidationTester) = interp.opt_params
+                CC.get_inference_world(interp::InvalidationTester) = interp.world
+                CC.get_inference_cache(interp::InvalidationTester) = interp.inf_cache
+                CC.cache_owner(::InvalidationTester) = InvalidationTesterToken()
+            end
+
+            Base.return_types((Float64,)) do x
+                basic_caller(x)
+            end
+            Base.return_types((Float64,); interp=Custom.InvalidationTester()) do x
+                basic_caller(x)
+            end
+        end
+        """)
+    Base.compilecache(Base.PkgId("CustomAbstractInterpreterCaching"))
+    (@eval begin
+        using CustomAbstractInterpreterCaching
+        let m = only(methods(CustomAbstractInterpreterCaching.basic_callee))
+            mi = only(Base.specializations(m))
+            ci = mi.cache
+            @test isdefined(ci, :next)
+            @test ci.owner === nothing
+            @test ci.max_world == typemax(UInt)
+            ci = ci.next
+            @test !isdefined(ci, :next)
+            @test ci.owner === CustomAbstractInterpreterCaching.Custom.InvalidationTesterToken()
+            @test ci.max_world == typemax(UInt)
+        end
+    end)
+end
+
 precompile_test_harness("Recursive types") do load_path
     write(joinpath(load_path, "RecursiveTypeDef.jl"),
         """
diff --git a/test/reflection.jl b/test/reflection.jl
index f81605622a806..c4e941fa7bb1a 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1006,8 +1006,9 @@ end
 
 @testset "lookup mi" begin
     @test 1+1 == 2
-    mi1 = @ccall jl_method_lookup_by_tt(Tuple{typeof(+), Int, Int}::Any, Base.get_world_counter()::Csize_t, nothing::Any)::Ref{Core.MethodInstance}
+    mi1 = Base.method_instance(+, (Int, Int))
     @test mi1.def.name == :+
+    # Note `jl_method_lookup` doesn't returns CNull if not found
     mi2 = @ccall jl_method_lookup(Any[+, 1, 1]::Ptr{Any}, 3::Csize_t, Base.get_world_counter()::Csize_t)::Ref{Core.MethodInstance}
     @test mi1 == mi2
 end

From 4be67e4e3e43825461365dbca74432d6cd12f257 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Sun, 11 Feb 2024 02:34:59 +0100
Subject: [PATCH 0884/1315] export `IdSet` and document it (#53262)

It feels kind of odd to have `IdDict` exported and documented and not
`IdSet`.
---
 NEWS.md                     |  1 +
 base/exports.jl             |  1 +
 base/iddict.jl              |  9 +++++----
 base/idset.jl               | 23 +++++++++++++++++++++++
 doc/src/base/collections.md | 10 +++++++---
 stdlib/TOML/src/TOML.jl     |  2 +-
 stdlib/TOML/src/print.jl    | 10 +++++-----
 stdlib/TOML/test/print.jl   |  6 +++---
 test/sets.jl                |  8 ++++----
 9 files changed, 50 insertions(+), 20 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index d71e14dff6fe1..2da8a7bad8b23 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -87,6 +87,7 @@ New library functions
 * `Sys.username()` can be used to return the current user's username ([#51897]).
 * `wrap(Array, m::Union{MemoryRef{T}, Memory{T}}, dims)` is the safe counterpart to `unsafe_wrap` ([#52049]).
 * `GC.logging_enabled()` can be used to test whether GC logging has been enabled via `GC.enable_logging` ([#51647]).
+* `IdSet` is now exported from Base and considered public ([#53262]).
 
 New library features
 --------------------
diff --git a/base/exports.jl b/base/exports.jl
index b1b84539c07a3..fbb5b449719d6 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -65,6 +65,7 @@ export
     Missing,
     NTuple,
     IdDict,
+    IdSet,
     OrdinalRange,
     Pair,
     PartialQuickSort,
diff --git a/base/iddict.jl b/base/iddict.jl
index 0b12ae86b2c6a..9c133d5ba23c6 100644
--- a/base/iddict.jl
+++ b/base/iddict.jl
@@ -4,11 +4,12 @@
     IdDict([itr])
 
 `IdDict{K,V}()` constructs a hash table using [`objectid`](@ref) as hash and
-`===` as equality with keys of type `K` and values of type `V`.
+`===` as equality with keys of type `K` and values of type `V`. See [`Dict`](@ref)
+for further help and [`IdSet`](@ref) for the set version of this.
 
-See [`Dict`](@ref) for further help. In the example below, The `Dict`
-keys are all `isequal` and therefore get hashed the same, so they get overwritten.
-The `IdDict` hashes by object-id, and thus preserves the 3 different keys.
+In the example below, the `Dict` keys are all `isequal` and therefore get hashed
+the same, so they get overwritten. The `IdDict` hashes by object-id, and thus
+preserves the 3 different keys.
 
 # Examples
 ```julia-repl
diff --git a/base/idset.jl b/base/idset.jl
index 6e0b7a85a5b23..23f9ca009af0c 100644
--- a/base/idset.jl
+++ b/base/idset.jl
@@ -1,5 +1,28 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    IdSet{T}([itr])
+    IdSet()
+
+IdSet{T}() constructs a set (see [`Set`](@ref)) using
+`===` as equality with values of type `V`.
+
+In the example below, the values are all `isequal` so they get overwritten.
+The `IdSet` compares by `===` so preserves the 3 different keys.
+
+Examples
+≡≡≡≡≡≡≡≡
+
+julia> Set(Any[true, 1, 1.0])
+Set{Any} with 1 element:
+  1.0
+
+julia> IdSet{Any}(Any[true, 1, 1.0])
+IdSet{Any} with 3 elements:
+  1.0
+  1
+  true
+"""
 mutable struct IdSet{K} <: AbstractSet{K}
     list::Memory{Any}
     idxs::Union{Memory{UInt8}, Memory{UInt16}, Memory{UInt32}}
diff --git a/doc/src/base/collections.md b/doc/src/base/collections.md
index 909f968b30baf..9d68d55be3459 100644
--- a/doc/src/base/collections.md
+++ b/doc/src/base/collections.md
@@ -225,14 +225,15 @@ Base.valtype
 
 Fully implemented by:
 
-  * [`IdDict`](@ref)
   * [`Dict`](@ref)
+  * [`IdDict`](@ref)
   * [`WeakKeyDict`](@ref)
 
 Partially implemented by:
 
-  * [`BitSet`](@ref)
   * [`Set`](@ref)
+  * [`BitSet`](@ref)
+  * [`IdSet`](@ref)
   * [`EnvDict`](@ref Base.EnvDict)
   * [`Array`](@ref)
   * [`BitArray`](@ref)
@@ -246,6 +247,7 @@ Partially implemented by:
 Base.AbstractSet
 Base.Set
 Base.BitSet
+Base.IdSet
 Base.union
 Base.union!
 Base.intersect
@@ -264,8 +266,10 @@ Base.isdisjoint
 
 Fully implemented by:
 
-  * [`BitSet`](@ref)
   * [`Set`](@ref)
+  * [`BitSet`](@ref)
+  * [`IdSet`](@ref)
+
 
 Partially implemented by:
 
diff --git a/stdlib/TOML/src/TOML.jl b/stdlib/TOML/src/TOML.jl
index 64d715ceef832..858b75a2e0eff 100644
--- a/stdlib/TOML/src/TOML.jl
+++ b/stdlib/TOML/src/TOML.jl
@@ -110,7 +110,7 @@ const ParserError = Internals.ParserError
 
 
 """
-    print([to_toml::Function], io::IO [=stdout], data::AbstractDict; sorted=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict})
+    print([to_toml::Function], io::IO [=stdout], data::AbstractDict; sorted=false, by=identity, inline_tables::IdSet{<:AbstractDict})
 
 Write `data` as TOML syntax to the stream `io`. If the keyword argument `sorted` is set to `true`,
 sort tables according to the function given by the keyword argument `by`. If the keyword argument
diff --git a/stdlib/TOML/src/print.jl b/stdlib/TOML/src/print.jl
index 06e4f08f35c46..91ea4fd392e4b 100644
--- a/stdlib/TOML/src/print.jl
+++ b/stdlib/TOML/src/print.jl
@@ -146,7 +146,7 @@ function print_table(f::MbyFunc, io::IO, a::AbstractDict,
     indent::Int = 0,
     first_block::Bool = true,
     sorted::Bool = false,
-    inline_tables::Base.IdSet,
+    inline_tables::IdSet,
     by::Function = identity,
 )
 
@@ -223,7 +223,7 @@ end
 # API #
 #######
 
-print(f::MbyFunc, io::IO, a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict}=Base.IdSet{Dict{String}}()) = print_table(f, io, a; sorted, by, inline_tables)
-print(f::MbyFunc,         a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict}=Base.IdSet{Dict{String}}()) = print(f, stdout, a; sorted, by, inline_tables)
-print(io::IO, a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict}=Base.IdSet{Dict{String}}()) = print_table(nothing, io, a; sorted, by, inline_tables)
-print(        a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::Base.IdSet{<:AbstractDict}=Base.IdSet{Dict{String}}()) = print(nothing, stdout, a; sorted, by, inline_tables)
+print(f::MbyFunc, io::IO, a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::IdSet{<:AbstractDict}=IdSet{Dict{String}}()) = print_table(f, io, a; sorted, by, inline_tables)
+print(f::MbyFunc,         a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::IdSet{<:AbstractDict}=IdSet{Dict{String}}()) = print(f, stdout, a; sorted, by, inline_tables)
+print(io::IO, a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::IdSet{<:AbstractDict}=IdSet{Dict{String}}()) = print_table(nothing, io, a; sorted, by, inline_tables)
+print(        a::AbstractDict; sorted::Bool=false, by=identity, inline_tables::IdSet{<:AbstractDict}=IdSet{Dict{String}}()) = print(nothing, stdout, a; sorted, by, inline_tables)
diff --git a/stdlib/TOML/test/print.jl b/stdlib/TOML/test/print.jl
index 9698a2871ae27..79a87b9f0f13f 100644
--- a/stdlib/TOML/test/print.jl
+++ b/stdlib/TOML/test/print.jl
@@ -148,7 +148,7 @@ d = Dict(
     "y" => inline_dict,
     "z" => [1,2,3],
 )
-inline_tables = Base.IdSet{Dict}()
+inline_tables = IdSet{Dict}()
 push!(inline_tables, inline_dict)
 @test toml_str(d; sorted=true, inline_tables) ==
 """
@@ -165,7 +165,7 @@ d = Dict("deps" => Dict(
         "LocalPkg" => Dict("path" => "LocalPkg"),
         "Example" => Dict("url" => "https://github.com/JuliaLang/Example.jl")))
 
-inline_tables = Base.IdSet{Dict}()
+inline_tables = IdSet{Dict}()
 push!(inline_tables, d["sources"]["LocalPkg"])
 push!(inline_tables, d["sources"]["Example"])
 
@@ -180,7 +180,7 @@ Example = {url = "https://github.com/JuliaLang/Example.jl"}
 LocalPkg = {path = "LocalPkg"}
 """
 
-inline_tables = Base.IdSet{Dict}()
+inline_tables = IdSet{Dict}()
 push!(inline_tables, d["sources"]["LocalPkg"])
 s = """
 [deps]
diff --git a/test/sets.jl b/test/sets.jl
index 2e7e19c5c1cdf..c490e66793cb4 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -899,8 +899,8 @@ end
     b = [2, 3, 1, 3]
     ua = unique(a)
     ub = unique(b)
-    for TA in (Tuple, identity, Set, BitSet, Base.IdSet{Int}),
-        TB in (Tuple, identity, Set, BitSet, Base.IdSet{Int}),
+    for TA in (Tuple, identity, Set, BitSet, IdSet{Int}),
+        TB in (Tuple, identity, Set, BitSet, IdSet{Int}),
         uA = false:true,
         uB = false:true
         A = TA(uA ? ua : a)
@@ -921,7 +921,7 @@ end
         @test !issetequal(B, A)
         @test !issetequal(B)(A)
         @test !issetequal(A)(B)
-        for T = (Tuple, identity, Set, BitSet, Base.IdSet{Int})
+        for T = (Tuple, identity, Set, BitSet, IdSet{Int})
             @test issetequal(A, T(A))
             @test issetequal(B, T(B))
         end
@@ -982,7 +982,7 @@ end
     c = [3]
     d = [4]
     e = [5]
-    A = Base.IdSet{Vector{Int}}([a, b, c, d])
+    A = IdSet{Vector{Int}}([a, b, c, d])
     @test !isempty(A)
     B = copy(A)
     @test A ⊆ B

From b8540d1766e1cec98ddc636febf84cdc60e3d4af Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 10 Feb 2024 22:53:23 -0500
Subject: [PATCH 0885/1315] [REPL] Fix typo in using/import completion (#53273)

Co-authored-by: Keno Fischer <keno@juliahub.com>
---
 stdlib/REPL/src/REPLCompletions.jl  | 2 +-
 stdlib/REPL/test/replcompletions.jl | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 215814dc8cada..621cd6f9021fb 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -1136,7 +1136,7 @@ function complete_identifiers!(suggestions::Vector{Completion}, @nospecialize(ff
                         if ex === nothing
                             ex = arg
                         else
-                            ex = Expr(:., out, QuoteNode(arg))
+                            ex = Expr(:., ex, QuoteNode(arg))
                         end
                     else # invalid expression
                         ex = nothing
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 7fd36e3d147e6..0a73a944ec8ea 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -2232,6 +2232,11 @@ let s = "using .Issue52922.Inn"
     @test res
     @test "Inner1" in c
 end
+let s = "using .Issue52922.Inner1."
+    c, r, res = test_complete_context(s)
+    @test res
+    @test "Inner12" in c
+end
 let s = "using .Inner1.Inn"
     c, r, res = test_complete_context(s, Issue52922)
     @test res

From af90dac17a2f59e68f6f6f69f48a7d21270909a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=89ric=20Thi=C3=A9baut?= <eric.thiebaut@univ-lyon1.fr>
Date: Sun, 11 Feb 2024 04:56:08 +0100
Subject: [PATCH 0886/1315] Add unary negation in table of operator precedence
 and associativity (#49438)

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 doc/src/manual/mathematical-operations.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/manual/mathematical-operations.md b/doc/src/manual/mathematical-operations.md
index 59af063ce8487..c333aeb56c5d9 100644
--- a/doc/src/manual/mathematical-operations.md
+++ b/doc/src/manual/mathematical-operations.md
@@ -394,7 +394,7 @@ Julia applies the following order and associativity of operations, from highest
 |:-------------- |:------------------------------------------------------------------------------------------------- |:-------------------------- |
 | Syntax         | `.` followed by `::`                                                                              | Left                       |
 | Exponentiation | `^`                                                                                               | Right                      |
-| Unary          | `+ - √`                                                                                           | Right[^1]                  |
+| Unary          | `+ - ! ~ ¬ √ ∛ ∜ ⋆ ± ∓ <: >:`                                                                     | Right[^1]                  |
 | Bitshifts      | `<< >> >>>`                                                                                       | Left                       |
 | Fractions      | `//`                                                                                              | Left                       |
 | Multiplication | `* / % & \ ÷`                                                                                     | Left[^2]                   |

From 37ed82b2898b93c86fe120bd6599ba6ddc8b5467 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Sun, 11 Feb 2024 09:08:13 -0500
Subject: [PATCH 0887/1315] Mark codeinstance.specsigflags as atomic (#53275)

A correctness fix from #53255

This shouldn't matter much as that field is
only accessed from the runtime, but this
synchronizes the C-header definition, with
the Julia native definition.
---
 src/jltypes.c | 4 ++--
 test/core.jl  | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/jltypes.c b/src/jltypes.c
index 6f9347c8fadd4..bf7561fc29e1b 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3311,7 +3311,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             //"absolute_max",
                             "ipo_purity_bits", "purity_bits",
                             "analysis_results",
-                            "isspecsig", "precompile", "relocatability",
+                            "specsigflags", "precompile", "relocatability",
                             "invoke", "specptr"), // function object decls
                         jl_svec(17,
                             jl_method_instance_type,
@@ -3335,7 +3335,7 @@ void jl_init_types(void) JL_GC_DISABLED
                         0, 1, 1);
     jl_svecset(jl_code_instance_type->types, 2, jl_code_instance_type);
     const static uint32_t code_instance_constfields[1]  = { 0b00000101011100011 }; // Set fields 1, 2, 6-8, 10, 12 as const
-    const static uint32_t code_instance_atomicfields[1] = { 0b11010010100011100 }; // Set fields 3-5, 9, 11, 14, 16-17 as atomic
+    const static uint32_t code_instance_atomicfields[1] = { 0b11011010100011100 }; // Set fields 3-5, 9, 11, 13-14, 16-17 as atomic
     //Fields 4-5 are only operated on by construction and deserialization, so are const at runtime
     //Fields 12 and 16 must be protected by locks, and thus all operations on jl_code_instance_t are threadsafe
     jl_code_instance_type->name->constfields = code_instance_constfields;
diff --git a/test/core.jl b/test/core.jl
index 504cfe99ba68c..aa16380c8a866 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -32,7 +32,7 @@ end
 # sanity tests that our built-in types are marked correctly for atomic fields
 for (T, c) in (
         (Core.CodeInfo, []),
-        (Core.CodeInstance, [:next, :min_world, :max_world, :inferred, :purity_bits, :invoke, :specptr, :precompile]),
+        (Core.CodeInstance, [:next, :min_world, :max_world, :inferred, :purity_bits, :invoke, :specptr, :specsigflags, :precompile]),
         (Core.Method, [:primary_world, :deleted_world]),
         (Core.MethodInstance, [:uninferred, :cache, :precompiled]),
         (Core.MethodTable, [:defs, :leafcache, :cache, :max_args]),

From a37d626565930a58a9968965e52c113043fe06bb Mon Sep 17 00:00:00 2001
From: Maarten Pronk <8655030+evetion@users.noreply.github.com>
Date: Sun, 11 Feb 2024 16:52:54 +0100
Subject: [PATCH 0888/1315] Clarify that command-line switches need to be
 manually set in `addprocs` (#50843)

Co-authored-by: Max Horn <max@quendi.de>
---
 doc/src/manual/arrays.md                | 2 +-
 doc/src/manual/distributed-computing.md | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/doc/src/manual/arrays.md b/doc/src/manual/arrays.md
index 13b289becf6e0..6aa3a7a724e0e 100644
--- a/doc/src/manual/arrays.md
+++ b/doc/src/manual/arrays.md
@@ -889,7 +889,7 @@ in their implementations, other arrays — like [`Diagonal`](@ref) — need the
 full set of cartesian indices to do their lookup (see [`IndexStyle`](@ref) to
 introspect which is which).
 
-!!! warnings
+!!! warning
 
     When iterating over all the indices for an array, it is
     better to iterate over [`eachindex(A)`](@ref) instead of `1:length(A)`.
diff --git a/doc/src/manual/distributed-computing.md b/doc/src/manual/distributed-computing.md
index e8a2146bdcf3e..020181dd0a08c 100644
--- a/doc/src/manual/distributed-computing.md
+++ b/doc/src/manual/distributed-computing.md
@@ -270,10 +270,11 @@ julia> addprocs(2)
 Module [`Distributed`](@ref man-distributed) must be explicitly loaded on the master process before invoking [`addprocs`](@ref).
 It is automatically made available on the worker processes.
 
-Note that workers do not run a `~/.julia/config/startup.jl` startup script, nor do they synchronize
-their global state (such as global variables, new method definitions, and loaded modules) with any
-of the other running processes. You may use `addprocs(exeflags="--project")` to initialize a worker with
-a particular environment, and then `@everywhere using <modulename>` or `@everywhere include("file.jl")`.
+!!! note
+    Note that workers do not run a `~/.julia/config/startup.jl` startup script, nor do they synchronize
+    their global state (such as command-line switches, global variables, new method definitions, and loaded modules) with any
+    of the other running processes. You may use `addprocs(exeflags="--project")` to initialize a worker with
+    a particular environment, and then `@everywhere using <modulename>` or `@everywhere include("file.jl")`.
 
 Other types of clusters can be supported by writing your own custom `ClusterManager`, as described
 below in the [ClusterManagers](@ref) section.

From 790a4eb7f25a3de5eae7e4b0d950e8a22aa271a6 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Sun, 11 Feb 2024 19:16:25 +0100
Subject: [PATCH 0889/1315] document exactness for `typeintersect(T, S)` when
 `T <: S` (#53283)

As per the discussion in #53265.
---
 base/reflection.jl | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/base/reflection.jl b/base/reflection.jl
index 6c1d785bef81d..4f15881c2c0d3 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -880,6 +880,9 @@ issingletontype(@nospecialize(t)) = (@_total_meta; isa(t, DataType) && isdefined
 
 Compute a type that contains the intersection of `T` and `S`. Usually this will be the
 smallest such type or one close to it.
+
+A special case where exact behavior is guaranteed: when `T <: S`,
+`typeintersect(S, T) == T == typeintersect(T, S)`.
 """
 typeintersect(@nospecialize(a), @nospecialize(b)) = (@_total_meta; ccall(:jl_type_intersection, Any, (Any, Any), a::Type, b::Type))
 

From 1f1436df8bc52a2117cc10e13851cd73a9bb22b1 Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Sun, 11 Feb 2024 19:16:40 +0100
Subject: [PATCH 0890/1315] Prefer `# Examples` in docstrings (#53276)

... as suggested by the Julia manual and by `CONTRIBUTING.md`

In one case `# Example` was dropped (instead of appending an `s`)
because it was redundant.
---
 base/abstractdict.jl                    |  2 +-
 base/cartesian.jl                       |  2 +-
 base/complex.jl                         |  2 +-
 base/essentials.jl                      |  2 +-
 base/experimental.jl                    |  2 +-
 base/expr.jl                            |  2 +-
 base/gcutils.jl                         |  1 -
 base/indices.jl                         |  2 +-
 base/libdl.jl                           |  4 ++--
 base/loading.jl                         |  4 ++--
 base/logging.jl                         |  2 +-
 base/math.jl                            |  2 +-
 base/operators.jl                       |  2 +-
 base/path.jl                            |  4 ++--
 base/reflection.jl                      | 16 ++++++++--------
 base/secretbuffer.jl                    |  2 +-
 base/shell.jl                           |  2 +-
 base/show.jl                            |  2 +-
 base/slicearray.jl                      |  6 +++---
 base/strings/annotated.jl               |  2 +-
 base/threadingconstructs.jl             |  2 +-
 base/util.jl                            |  2 +-
 stdlib/Dates/src/conversions.jl         |  2 +-
 stdlib/Dates/src/io.jl                  | 14 +++++++-------
 stdlib/InteractiveUtils/src/editless.jl |  2 +-
 stdlib/LinearAlgebra/src/eigen.jl       |  2 +-
 stdlib/Markdown/src/render/html.jl      |  2 +-
 stdlib/Markdown/src/render/latex.jl     |  2 +-
 stdlib/Sockets/src/addrinfo.jl          |  4 ++--
 stdlib/Test/src/logging.jl              |  2 +-
 30 files changed, 48 insertions(+), 49 deletions(-)

diff --git a/base/abstractdict.jl b/base/abstractdict.jl
index f73b518930a07..62a5b3ee9e1b0 100644
--- a/base/abstractdict.jl
+++ b/base/abstractdict.jl
@@ -416,7 +416,7 @@ end
 Update `d`, removing elements for which `f` is `false`.
 The function `f` is passed `key=>value` pairs.
 
-# Example
+# Examples
 ```jldoctest
 julia> d = Dict(1=>"a", 2=>"b", 3=>"c")
 Dict{Int64, String} with 3 entries:
diff --git a/base/cartesian.jl b/base/cartesian.jl
index decc01cbc3e5f..ca0fc0aac0cfc 100644
--- a/base/cartesian.jl
+++ b/base/cartesian.jl
@@ -115,7 +115,7 @@ Generate a function call expression with keyword arguments `kw...`. As
 in the case of [`@ncall`](@ref), `sym` represents any number of function arguments, the
 last of which may be an anonymous-function expression and is expanded into `N` arguments.
 
-# Example
+# Examples
 ```jldoctest
 julia> using Base.Cartesian
 
diff --git a/base/complex.jl b/base/complex.jl
index f14b7f2f5336f..8ac126d2c6532 100644
--- a/base/complex.jl
+++ b/base/complex.jl
@@ -1097,7 +1097,7 @@ second is used for rounding the imaginary components.
 which rounds to the nearest integer, with ties (fractional values of 0.5)
 being rounded to the nearest even integer.
 
-# Example
+# Examples
 ```jldoctest
 julia> round(3.14 + 4.5im)
 3.0 + 4.0im
diff --git a/base/essentials.jl b/base/essentials.jl
index 8e329c4f7c4d9..9c156fb1b8f6d 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -90,7 +90,7 @@ f(y) = [x for x in y]
     standard ones) on type-inference. Use [`Base.@nospecializeinfer`](@ref) together with
     `@nospecialize` to additionally suppress inference.
 
-# Example
+# Examples
 
 ```julia
 julia> f(A::AbstractArray) = g(A)
diff --git a/base/experimental.jl b/base/experimental.jl
index c599d973b0a76..8dbdcacd65376 100644
--- a/base/experimental.jl
+++ b/base/experimental.jl
@@ -254,7 +254,7 @@ When issuing a hint, the output should typically start with `\\n`.
 If you define custom exception types, your `showerror` method can
 support hints by calling [`Experimental.show_error_hints`](@ref).
 
-# Example
+# Examples
 
 ```
 julia> module Hinter
diff --git a/base/expr.jl b/base/expr.jl
index 39da1408a77b3..b90f75e75a76f 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -831,7 +831,7 @@ end
 Tells the compiler to infer `f` using the declared types of `@nospecialize`d arguments.
 This can be used to limit the number of compiler-generated specializations during inference.
 
-# Example
+# Examples
 
 ```julia
 julia> f(A::AbstractArray) = g(A)
diff --git a/base/gcutils.jl b/base/gcutils.jl
index 25f098e407223..3b8c4cf4ede10 100644
--- a/base/gcutils.jl
+++ b/base/gcutils.jl
@@ -70,7 +70,6 @@ end
 A finalizer may be registered at object construction. In the following example note that
 we implicitly rely on the finalizer returning the newly created mutable struct `x`.
 
-# Example
 ```julia
 mutable struct MyMutableStruct
     bar
diff --git a/base/indices.jl b/base/indices.jl
index 9f2115e692564..0bd46f9787dab 100644
--- a/base/indices.jl
+++ b/base/indices.jl
@@ -464,7 +464,7 @@ julia> extrema(b)
 
 Return a `LinearIndices` array with the specified shape or [`axes`](@ref).
 
-# Example
+# Examples
 
 The main purpose of this constructor is intuitive conversion
 from cartesian to linear indexing:
diff --git a/base/libdl.jl b/base/libdl.jl
index bd909bb7b90eb..199d847572ca4 100644
--- a/base/libdl.jl
+++ b/base/libdl.jl
@@ -130,7 +130,7 @@ end
 Wrapper for usage with `do` blocks to automatically close the dynamic library once
 control flow leaves the `do` block scope.
 
-# Example
+# Examples
 ```julia
 vendor = dlopen("libblas") do lib
     if Libdl.dlsym(lib, :openblas_set_num_threads; throw_error=false) !== nothing
@@ -234,7 +234,7 @@ end
 
 Get the full path of the library `libname`.
 
-# Example
+# Examples
 ```julia-repl
 julia> dlpath("libjulia")
 ```
diff --git a/base/loading.jl b/base/loading.jl
index 1e6af4592b6a1..5f0ea1859bc0f 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2335,7 +2335,7 @@ and return the value of the last expression.
 The optional `args` argument can be used to set the input arguments of the script (i.e. the global `ARGS` variable).
 Note that definitions (e.g. methods, globals) are evaluated in the anonymous module and do not affect the current module.
 
-# Example
+# Examples
 
 ```jldoctest
 julia> write("testfile.jl", \"\"\"
@@ -3558,7 +3558,7 @@ Macro to obtain the absolute path of the current directory as a string.
 If in a script, returns the directory of the script containing the `@__DIR__` macrocall. If run from a
 REPL or if evaluated by `julia -e <expr>`, returns the current working directory.
 
-# Example
+# Examples
 
 The example illustrates the difference in the behaviors of `@__DIR__` and `pwd()`, by creating
 a simple script in a different directory than the current working one and executing both commands:
diff --git a/base/logging.jl b/base/logging.jl
index 1853caa16148c..436d00335acf3 100644
--- a/base/logging.jl
+++ b/base/logging.jl
@@ -608,7 +608,7 @@ end
 
 Execute `function`, directing all log messages to `logger`.
 
-# Example
+# Examples
 
 ```julia
 function test(x)
diff --git a/base/math.jl b/base/math.jl
index b0870c60016f7..0071d427fbbac 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -177,7 +177,7 @@ a Goertzel-like [^DK62] algorithm if `x` is complex.
 !!! compat "Julia 1.4"
     This function requires Julia 1.4 or later.
 
-# Example
+# Examples
 ```jldoctest
 julia> evalpoly(2, (1, 2, 3))
 17
diff --git a/base/operators.jl b/base/operators.jl
index 2138888c82d9f..3d5ad705ed99a 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -1242,7 +1242,7 @@ it into the original function. This is useful as an adaptor to pass a
 multi-argument function in a context that expects a single argument, but passes
 a tuple as that single argument.
 
-# Example usage:
+# Examples
 ```jldoctest
 julia> map(splat(+), zip(1:3,4:6))
 3-element Vector{Int64}:
diff --git a/base/path.jl b/base/path.jl
index 6d2fe933e4ec6..3b8124f34f174 100644
--- a/base/path.jl
+++ b/base/path.jl
@@ -435,11 +435,11 @@ normpath(a::AbstractString, b::AbstractString...) = normpath(joinpath(a,b...))
 Convert a path to an absolute path by adding the current directory if necessary.
 Also normalizes the path as in [`normpath`](@ref).
 
-# Example
+# Examples
 
 If you are in a directory called `JuliaExample` and the data you are using is two levels up relative to the `JuliaExample` directory, you could write:
 
-abspath("../../data")
+    abspath("../../data")
 
 Which gives a path like `"/home/JuliaUser/data/"`.
 
diff --git a/base/reflection.jl b/base/reflection.jl
index 4f15881c2c0d3..65a46242c389d 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1064,7 +1064,7 @@ fieldtypes(T::Type) = (@_foldable_meta; ntupleany(i -> fieldtype(T, i), fieldcou
 Return a collection of all instances of the given type, if applicable. Mostly used for
 enumerated types (see `@enum`).
 
-# Example
+# Examples
 ```jldoctest
 julia> @enum Color red blue green
 
@@ -1558,7 +1558,7 @@ internals.
 - `interp::Core.Compiler.AbstractInterpreter = Core.Compiler.NativeInterpreter(world)`:
   optional, controls the abstract interpreter to use, use the native interpreter if not specified.
 
-# Example
+# Examples
 
 One can put the argument types in a tuple to get the corresponding `code_typed`.
 
@@ -1666,7 +1666,7 @@ internals.
   If it is an integer, it specifies the number of passes to run.
   If it is `nothing` (default), all passes are run.
 
-# Example
+# Examples
 
 One can put the argument types in a tuple to get the corresponding `code_ircode`.
 
@@ -1764,7 +1764,7 @@ candidates for `f` and `types` (see also [`methods(f, types)`](@ref methods).
   methods matching with the given `f` and `types`. The list's order matches the order
   returned by `methods(f, types)`.
 
-# Example
+# Examples
 
 ```julia
 julia> Base.return_types(sum, Tuple{Vector{Int}})
@@ -1833,7 +1833,7 @@ Returns an inferred return type of the function call specified by `f` and `types
     It returns a single return type, taking into account all potential outcomes of
     any function call entailed by the given signature type.
 
-# Example
+# Examples
 
 ```julia
 julia> checksym(::Symbol) = :symbol;
@@ -1904,7 +1904,7 @@ It works like [`Base.return_types`](@ref), but it infers the exception types ins
   methods matching with the given `f` and `types`. The list's order matches the order
   returned by `methods(f, types)`.
 
-# Example
+# Examples
 
 ```julia
 julia> throw_if_number(::Number) = error("number is given");
@@ -1987,7 +1987,7 @@ Returns the type of exception potentially thrown by the function call specified
     It returns a single exception type, taking into account all potential outcomes of
     any function call entailed by the given signature type.
 
-# Example
+# Examples
 
 ```julia
 julia> f1(x) = x * 2;
@@ -2071,7 +2071,7 @@ Returns the possible computation effects of the function call specified by `f` a
     It returns a single effect, taking into account all potential outcomes of any function
     call entailed by the given signature type.
 
-# Example
+# Examples
 
 ```julia
 julia> f1(x) = x * 2;
diff --git a/base/secretbuffer.jl b/base/secretbuffer.jl
index 61eeffdb4f18d..bf37c3caa6c23 100644
--- a/base/secretbuffer.jl
+++ b/base/secretbuffer.jl
@@ -200,7 +200,7 @@ resetting its pointer and size.
 This function is used to securely erase the sensitive data held in the buffer,
 reducing the potential for information leaks.
 
-# Example
+# Examples
 ```julia
 s = SecretBuffer()
 write(s, 's', 'e', 'c', 'r', 'e', 't')
diff --git a/base/shell.jl b/base/shell.jl
index dd4533c182534..9f15550a1aa59 100644
--- a/base/shell.jl
+++ b/base/shell.jl
@@ -416,7 +416,7 @@ rather than returned as a string.
 
 See also [`escape_microsoft_c_args`](@ref), [`shell_escape_posixly`](@ref).
 
-# Example
+# Examples
 ```jldoctest
 julia> Base.shell_escape_wincmd("a^\\"^o\\"^u\\"")
 "a^^\\"^o\\"^^u^\\""
diff --git a/base/show.jl b/base/show.jl
index 8c59bb3bd9f6d..a5bf5f73ba0ed 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -3174,7 +3174,7 @@ representing argument `x` in terms of its type. (The double-colon is
 omitted if `toplevel=true`.) However, you can
 specialize this function for specific types to customize printing.
 
-# Example
+# Examples
 
 A SubArray created as `view(a, :, 3, 2:5)`, where `a` is a
 3-dimensional Float64 array, has type
diff --git a/base/slicearray.jl b/base/slicearray.jl
index de4272550bdb0..215cf13f9651e 100644
--- a/base/slicearray.jl
+++ b/base/slicearray.jl
@@ -96,7 +96,7 @@ See also [`eachrow`](@ref), [`eachcol`](@ref), [`mapslices`](@ref) and [`selectd
 !!! compat "Julia 1.9"
      Prior to Julia 1.9, this returned an iterator, and only a single dimension `dims` was supported.
 
-# Example
+# Examples
 
 ```jldoctest
 julia> m = [1 2 3; 4 5 6; 7 8 9]
@@ -144,7 +144,7 @@ See also [`eachcol`](@ref), [`eachslice`](@ref) and [`mapslices`](@ref).
 !!! compat "Julia 1.9"
      Prior to Julia 1.9, this returned an iterator.
 
-# Example
+# Examples
 
 ```jldoctest
 julia> a = [1 2; 3 4]
@@ -182,7 +182,7 @@ See also [`eachrow`](@ref), [`eachslice`](@ref) and [`mapslices`](@ref).
 !!! compat "Julia 1.9"
      Prior to Julia 1.9, this returned an iterator.
 
-# Example
+# Examples
 
 ```jldoctest
 julia> a = [1 2; 3 4]
diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index f84a85eaf62ab..d67ac70d8c684 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -45,7 +45,7 @@ AnnotatedString(s::S<:AbstractString, annotations::Vector{Tuple{UnitRange{Int},
 A AnnotatedString can also be created with [`annotatedstring`](@ref), which acts much
 like [`string`](@ref) but preserves any annotations present in the arguments.
 
-# Example
+# Examples
 
 ```julia-repl
 julia> AnnotatedString("this is an example annotated string",
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index eef75916880da..56d596958bc7e 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -345,7 +345,7 @@ thread other than 1.
     In newly written library functions, `:static` scheduling is discouraged because the
     functions using this option cannot be called from arbitrary worker threads.
 
-## Example
+## Examples
 
 To illustrate of the different scheduling strategies, consider the following function
 `busywait` containing a non-yielding timed loop that runs for a given number of seconds.
diff --git a/base/util.jl b/base/util.jl
index 41eaf528d6925..a26a874c7a461 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -375,7 +375,7 @@ then the user can enter just a newline character to select the `default`.
 
 See also `Base.winprompt` (for Windows) and `Base.getpass` for secure entry of passwords.
 
-# Example
+# Examples
 
 ```julia-repl
 julia> your_name = Base.prompt("Enter your name");
diff --git a/stdlib/Dates/src/conversions.jl b/stdlib/Dates/src/conversions.jl
index 30f1f2581d1fa..0d413d2cf53a1 100644
--- a/stdlib/Dates/src/conversions.jl
+++ b/stdlib/Dates/src/conversions.jl
@@ -84,7 +84,7 @@ today() = Date(now())
 Return a `DateTime` corresponding to the user's system time as UTC/GMT.
 For other time zones, see the TimeZones.jl package.
 
-# Example
+# Examples
 ```julia
 julia> now(UTC)
 2023-01-04T10:52:24.864
diff --git a/stdlib/Dates/src/io.jl b/stdlib/Dates/src/io.jl
index 257e86064c2fb..3980ad3a7245f 100644
--- a/stdlib/Dates/src/io.jl
+++ b/stdlib/Dates/src/io.jl
@@ -472,7 +472,7 @@ end
 Describes the ISO8601 formatting for a date and time. This is the default value for `Dates.format`
 of a `DateTime`.
 
-# Example
+# Examples
 ```jldoctest
 julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), ISODateTimeFormat)
 "2018-08-08T12:00:43.001"
@@ -486,7 +486,7 @@ default_format(::Type{DateTime}) = ISODateTimeFormat
 
 Describes the ISO8601 formatting for a date. This is the default value for `Dates.format` of a `Date`.
 
-# Example
+# Examples
 ```jldoctest
 julia> Dates.format(Date(2018, 8, 8), ISODateFormat)
 "2018-08-08"
@@ -500,7 +500,7 @@ default_format(::Type{Date}) = ISODateFormat
 
 Describes the ISO8601 formatting for a time. This is the default value for `Dates.format` of a `Time`.
 
-# Example
+# Examples
 ```jldoctest
 julia> Dates.format(Time(12, 0, 43, 1), ISOTimeFormat)
 "12:00:43.001"
@@ -514,7 +514,7 @@ default_format(::Type{Time}) = ISOTimeFormat
 
 Describes the RFC1123 formatting for a date and time.
 
-# Example
+# Examples
 ```jldoctest
 julia> Dates.format(DateTime(2018, 8, 8, 12, 0, 43, 1), RFC1123Format)
 "Wed, 08 Aug 2018 12:00:43"
@@ -538,7 +538,7 @@ pattern given in the `format` string (see [`DateFormat`](@ref)  for syntax).
     that you create a [`DateFormat`](@ref) object instead and use that as the second
     argument to avoid performance loss when using the same format repeatedly.
 
-# Example
+# Examples
 ```jldoctest
 julia> DateTime("2020-01-01", "yyyy-mm-dd")
 2020-01-01T00:00:00
@@ -578,7 +578,7 @@ in the `format` string (see [`DateFormat`](@ref) for syntax).
     that you create a [`DateFormat`](@ref) object instead and use that as the second
     argument to avoid performance loss when using the same format repeatedly.
 
-# Example
+# Examples
 ```jldoctest
 julia> Date("2020-01-01", "yyyy-mm-dd")
 2020-01-01
@@ -618,7 +618,7 @@ in the `format` string (see [`DateFormat`](@ref) for syntax).
     that you create a [`DateFormat`](@ref) object instead and use that as the second
     argument to avoid performance loss when using the same format repeatedly.
 
-# Example
+# Examples
 ```jldoctest
 julia> Time("12:34pm", "HH:MMp")
 12:34:00
diff --git a/stdlib/InteractiveUtils/src/editless.jl b/stdlib/InteractiveUtils/src/editless.jl
index 74fc5c6becfbd..5b87dc0c57d40 100644
--- a/stdlib/InteractiveUtils/src/editless.jl
+++ b/stdlib/InteractiveUtils/src/editless.jl
@@ -77,7 +77,7 @@ already work:
 - pycharm
 - bbedit
 
-# Example:
+# Examples
 
 The following defines the usage of terminal-based `emacs`:
 
diff --git a/stdlib/LinearAlgebra/src/eigen.jl b/stdlib/LinearAlgebra/src/eigen.jl
index 4ba540d42b261..d1d2a156b1ed4 100644
--- a/stdlib/LinearAlgebra/src/eigen.jl
+++ b/stdlib/LinearAlgebra/src/eigen.jl
@@ -346,7 +346,7 @@ eigvals(A::AbstractMatrix{T}; kws...) where T =
 """
 For a scalar input, `eigvals` will return a scalar.
 
-# Example
+# Examples
 ```jldoctest
 julia> eigvals(-2)
 -2
diff --git a/stdlib/Markdown/src/render/html.jl b/stdlib/Markdown/src/render/html.jl
index 3831e6acc7bb9..e7d436f2ccbda 100644
--- a/stdlib/Markdown/src/render/html.jl
+++ b/stdlib/Markdown/src/render/html.jl
@@ -191,7 +191,7 @@ writing to an (optional) `io` stream or returning a string.
 One can alternatively use `show(io, "text/html", md)` or `repr("text/html", md)`, which
 differ in that they wrap the output in a `<div class="markdown"> ... </div>` element.
 
-# Example
+# Examples
 ```jldoctest
 julia> html(md"hello _world_")
 "<p>hello <em>world</em></p>\\n"
diff --git a/stdlib/Markdown/src/render/latex.jl b/stdlib/Markdown/src/render/latex.jl
index 03bb78ba3efec..df52b2849f2b0 100644
--- a/stdlib/Markdown/src/render/latex.jl
+++ b/stdlib/Markdown/src/render/latex.jl
@@ -175,7 +175,7 @@ writing to an (optional) `io` stream or returning a string.
 
 One can alternatively use `show(io, "text/latex", md)` or `repr("text/latex", md)`.
 
-# Example
+# Examples
 ```jldoctest
 julia> latex(md"hello _world_")
 "hello \\\\emph{world}\\n\\n"
diff --git a/stdlib/Sockets/src/addrinfo.jl b/stdlib/Sockets/src/addrinfo.jl
index bf5819f6388c6..4ee9e07a58430 100644
--- a/stdlib/Sockets/src/addrinfo.jl
+++ b/stdlib/Sockets/src/addrinfo.jl
@@ -55,7 +55,7 @@ end
 Gets all of the IP addresses of the `host`.
 Uses the operating system's underlying `getaddrinfo` implementation, which may do a DNS lookup.
 
-# Example
+# Examples
 ```julia-repl
 julia> getalladdrinfo("google.com")
 2-element Array{IPAddr,1}:
@@ -362,7 +362,7 @@ are not guaranteed to be unique beyond their network segment,
 therefore routers do not forward them. Link-local addresses are from
 the address blocks `169.254.0.0/16` or `fe80::/10`.
 
-# Example
+# Examples
 ```julia
 filter(!islinklocaladdr, getipaddrs())
 ```
diff --git a/stdlib/Test/src/logging.jl b/stdlib/Test/src/logging.jl
index 7b3838903ce10..42d3eaf8eaa48 100644
--- a/stdlib/Test/src/logging.jl
+++ b/stdlib/Test/src/logging.jl
@@ -55,7 +55,7 @@ most `n` times.
 
 See also: [`LogRecord`](@ref).
 
-## Example
+## Examples
 
 ```jldoctest
 julia> using Test, Logging

From 3560036711033693a4c6942d711d2c6ed7f2a235 Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Sun, 11 Feb 2024 13:43:47 -0500
Subject: [PATCH 0891/1315] Docs: add `Logging.BelowMinLevel` and
 `Logging.AboveMaxLevel` to the manual page for the Logging stdlib (#52232)

According to the source code file, `Logging.BelowMinLevel` and
`Logging.AboveMaxLevel` are already part of the public API of the
Logging stdlib:


https://github.com/JuliaLang/julia/blob/c8ca350832030992fca113ed56d979b6a8ff7fd3/stdlib/Logging/src/Logging.jl#L85-L91

Additionally, Logging currently exports `BelowMinLevel` and
`AboveMaxLevel`:


https://github.com/JuliaLang/julia/blob/c8ca350832030992fca113ed56d979b6a8ff7fd3/stdlib/Logging/src/Logging.jl#L61-L81

However, `Logging.BelowMinLevel` and `Logging.AboveMaxLevel` are not
currently in the manual.

This PR adds them to the manual.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 stdlib/Logging/docs/src/index.md |  2 ++
 stdlib/Logging/src/Logging.jl    | 14 +++++++++++++-
 stdlib/Logging/test/runtests.jl  |  3 +--
 3 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/stdlib/Logging/docs/src/index.md b/stdlib/Logging/docs/src/index.md
index ed17c23efdba6..6d0af3ac21321 100644
--- a/stdlib/Logging/docs/src/index.md
+++ b/stdlib/Logging/docs/src/index.md
@@ -313,6 +313,8 @@ Logging.Debug
 Logging.Info
 Logging.Warn
 Logging.Error
+Logging.BelowMinLevel
+Logging.AboveMaxLevel
 Logging.@create_log_macro
 ```
 
diff --git a/stdlib/Logging/src/Logging.jl b/stdlib/Logging/src/Logging.jl
index 1cb1bca774c27..c05d3b7227c34 100644
--- a/stdlib/Logging/src/Logging.jl
+++ b/stdlib/Logging/src/Logging.jl
@@ -14,7 +14,7 @@ using StyledStrings
 # Doing it this way (rather than with import) makes these symbols accessible to
 # tab completion.
 for sym in [
-    :LogLevel, :BelowMinLevel, :AboveMaxLevel,
+    :LogLevel,
     :AbstractLogger,
     :NullLogger,
     :handle_message, :shouldlog, :min_enabled_level, :catch_exceptions,
@@ -90,6 +90,18 @@ const Warn = Base.CoreLogging.Warn
 Alias for [`LogLevel(2000)`](@ref LogLevel).
 """
 const Error = Base.CoreLogging.Error
+"""
+    BelowMinLevel
+
+Alias for [`LogLevel(-1_000_001)`](@ref LogLevel).
+"""
+const BelowMinLevel = Base.CoreLogging.BelowMinLevel
+"""
+    AboveMaxLevel
+
+Alias for [`LogLevel(1_000_001)`](@ref LogLevel).
+"""
+const AboveMaxLevel = Base.CoreLogging.AboveMaxLevel
 
 using Base.CoreLogging:
     closed_stream
diff --git a/stdlib/Logging/test/runtests.jl b/stdlib/Logging/test/runtests.jl
index 15371ac5d442c..1a86c884295b4 100644
--- a/stdlib/Logging/test/runtests.jl
+++ b/stdlib/Logging/test/runtests.jl
@@ -302,8 +302,7 @@ end
 
 @testset "Docstrings" begin
     undoc = Docs.undocumented_names(Logging)
-    @test_broken isempty(undoc)
-    @test undoc == [:AboveMaxLevel, :BelowMinLevel]
+    @test isempty(undoc)
 end
 
 end

From c4bec9ac7b767ab96dba956865fe79aa3b4a81a6 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <kshyatt@users.noreply.github.com>
Date: Sun, 11 Feb 2024 13:44:25 -0500
Subject: [PATCH 0892/1315] Missing tests for TwicePrecision (#34938)

Co-authored-by: Tim Holy <tim.holy@gmail.com>
---
 test/ranges.jl | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/ranges.jl b/test/ranges.jl
index 82593b53ff503..549078bab45fe 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -235,9 +235,23 @@ end
             @test cmp_sn2(Tw(xw/yw), astuple(x/y)..., slopbits)
         end
     end
+    @testset "high precision of varying types" begin
+        x = Float32(π)
+        y = Float64(Base.MathConstants.γ)
+        @test Base.mul12(x, y)[1] ≈ Base.mul12(Float64(π), y)[1] rtol=1e-6
+        @test Base.mul12(x, y)[2] ≈ Base.mul12(Float64(π), y)[2] atol=1e-15
+        @test Base.div12(x, y)[1] ≈ Base.div12(Float64(π), y)[1] rtol=1e-6
+        @test Base.div12(x, y)[2] ≈ Base.div12(Float64(π), y)[2] atol=1e-15
+        xtp = Base.TwicePrecision{Float32}(π)
+        ytp = Base.TwicePrecision{Float64}(Base.MathConstants.γ)
+        @test Float32(xtp + ytp) ≈ Float32(Base.TwicePrecision{Float64}(π) + ytp)
+    end
 
     x1 = Base.TwicePrecision{Float64}(1)
     x0 = Base.TwicePrecision{Float64}(0)
+    @test eltype(x1) == Float64
+    @test eltype(typeof(x1)) == Float64
+    @test zero(typeof(x1)) === x0
     xinf = Base.TwicePrecision{Float64}(Inf)
     @test Float64(x1+x0)  == 1
     @test Float64(x1+0)   == 1

From efa77cc6812201d97a24ea418fbee1383d1e8f49 Mon Sep 17 00:00:00 2001
From: Michael Abbott <32575566+mcabbott@users.noreply.github.com>
Date: Sun, 11 Feb 2024 17:33:43 -0500
Subject: [PATCH 0893/1315] Predicate versions of `allequal` & `allunique`
 (#47679)

First, use `Iterators.peel` to improve `allequal(itr)` as suggested by
jlapeyre in here:
https://github.com/JuliaLang/julia/issues/47005#issuecomment-1276477572

After that, `allequal(f, xs) = allequal(f(x) for x in xs)` should never
call `f` twice on the same `x`, nor more times than necessary.

For `allunique`, at present this has a path which collects short
iterators (<32) as this is faster than making a `Set`. Thus calling
`allunique(f(x) for x in xs)` will sometimes call `f` more times than it
has to. This PR doesn't change that, just adds a method
`allunique(f, xs)`.

Since generators tend to have eltype `Any`, it pays to use
`Set{@default_eltype(C)}()` now. I think this ought to be safe.

Finally, methods `allequal(f, xs::Tuple)` and `allunique(f, xs::Tuple)`
seem to be worthwhile. [This
gist](https://gist.github.com/mcabbott/69c0b85cdf0a37d97eecba3edb18bdc0)
times a few variants.

Closes #47005, and does the same for `allunique`
---
 NEWS.md      |  1 +
 base/set.jl  | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 test/sets.jl | 37 ++++++++++++++++++++++++++++++++++++
 3 files changed, 89 insertions(+), 2 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 2da8a7bad8b23..3c83e995c4de2 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -96,6 +96,7 @@ New library features
 * `invmod(n)` is an abbreviation for `invmod(n, typeof(n))` for native integer types ([#52180]).
 * `replace(string, pattern...)` now supports an optional `IO` argument to
   write the output to a stream rather than returning a string ([#48625]).
+* New methods `allequal(f, itr)` and `allunique(f, itr)` taking a predicate function ([#47679]).
 * `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
 * New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
 * New function `Docs.undocumented_names(module)` returns a module's undocumented public names ([#52413]).
diff --git a/base/set.jl b/base/set.jl
index 6b0c933f79faa..2f96cef626b6f 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -479,13 +479,21 @@ end
 
 """
     allunique(itr) -> Bool
+    allunique(f, itr) -> Bool
 
 Return `true` if all values from `itr` are distinct when compared with [`isequal`](@ref).
+Or if all of `[f(x) for x in itr]` are distinct, for the second method.
+
+Note that `allunique(f, itr)` may call `f` fewer than `length(itr)` times.
+The precise number of calls is regarded as an implementation detail.
 
 `allunique` may use a specialized implementation when the input is sorted.
 
 See also: [`unique`](@ref), [`issorted`](@ref), [`allequal`](@ref).
 
+!!! compat "Julia 1.11"
+    The method `allunique(f, itr)` requires at least Julia 1.11.
+
 # Examples
 ```jldoctest
 julia> allunique([1, 2, 3])
@@ -499,6 +507,9 @@ false
 
 julia> allunique([NaN, 2.0, NaN, 4.0])
 false
+
+julia> allunique(abs, [1, -1, 2])
+false
 ```
 """
 function allunique(C)
@@ -509,8 +520,10 @@ function allunique(C)
     return _hashed_allunique(C)
 end
 
+allunique(f, xs) = allunique(Generator(f, xs))
+
 function _hashed_allunique(C)
-    seen = Set{eltype(C)}()
+    seen = Set{@default_eltype(C)}()
     x = iterate(C)
     if haslength(C) && length(C) > 1000
         for i in OneTo(1000)
@@ -582,16 +595,30 @@ function allunique(t::Tuple)
 end
 allunique(t::Tuple{}) = true
 
+function allunique(f::F, t::Tuple) where {F}
+    length(t) < 2 && return true
+    length(t) < 32 || return _hashed_allunique(Generator(f, t))
+    return allunique(map(f, t))
+end
+
 """
     allequal(itr) -> Bool
+    allequal(f, itr) -> Bool
 
 Return `true` if all values from `itr` are equal when compared with [`isequal`](@ref).
+Or if all of `[f(x) for x in itr]` are equal, for the second method.
+
+Note that `allequal(f, itr)` may call `f` fewer than `length(itr)` times.
+The precise number of calls is regarded as an implementation detail.
 
 See also: [`unique`](@ref), [`allunique`](@ref).
 
 !!! compat "Julia 1.8"
     The `allequal` function requires at least Julia 1.8.
 
+!!! compat "Julia 1.11"
+    The method `allequal(f, itr)` requires at least Julia 1.11.
+
 # Examples
 ```jldoctest
 julia> allequal([])
@@ -608,14 +635,36 @@ false
 
 julia> allequal(Dict(:a => 1, :b => 1))
 false
+
+julia> allequal(abs2, [1, -1])
+true
 ```
 """
-allequal(itr) = isempty(itr) ? true : all(isequal(first(itr)), itr)
+function allequal(itr)
+    if haslength(itr)
+        length(itr) <= 1 && return true
+    end
+    pl = Iterators.peel(itr)
+    isnothing(pl) && return true
+    a, rest = pl
+    return all(isequal(a), rest)
+end
 
 allequal(c::Union{AbstractSet,AbstractDict}) = length(c) <= 1
 
 allequal(r::AbstractRange) = iszero(step(r)) || length(r) <= 1
 
+allequal(f, xs) = allequal(Generator(f, xs))
+
+function allequal(f, xs::Tuple)
+    length(xs) <= 1 && return true
+    f1 = f(xs[1])
+    for x in tail(xs)
+        isequal(f1, f(x)) || return false
+    end
+    return true
+end
+
 filter!(f, s::Set) = unsafe_filter!(f, s)
 
 const hashs_seed = UInt === UInt64 ? 0x852ada37cfe8e0ce : 0xcfe8e0ce
diff --git a/test/sets.jl b/test/sets.jl
index c490e66793cb4..4ab360c9fedd4 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -642,21 +642,38 @@ end
     @test !allunique((1,2,3,4,3))
     @test allunique((0.0, -0.0))
     @test !allunique((NaN, NaN))
+    # Known length 1, need not evaluate:
+    @test allunique(error(x) for x in [1])
+end
+
+@testset "allunique(f, xs)" begin
+    @test allunique(sin, 1:3)
+    @test !allunique(sin, [1,2,3,1])
+    @test allunique(sin, (1, 2, pi, im))  # eltype Any
+    @test allunique(abs2, 1:100)
+    @test !allunique(abs, -10:10)
+    @test allunique(abs2, Vector{Any}(1:100))
+    # These cases don't call the function at all:
+    @test allunique(error, [])
+    @test allunique(error, [1])
 end
 
 @testset "allequal" begin
+    # sets & dictionaries
     @test allequal(Set())
     @test allequal(Set(1))
     @test !allequal(Set([1, 2]))
     @test allequal(Dict())
     @test allequal(Dict(:a => 1))
     @test !allequal(Dict(:a => 1, :b => 2))
+    # vectors
     @test allequal([])
     @test allequal([1])
     @test allequal([1, 1])
     @test !allequal([1, 1, 2])
     @test allequal([:a, :a])
     @test !allequal([:a, :b])
+    # ranges
     @test !allequal(1:2)
     @test allequal(1:1)
     @test !allequal(4.0:0.3:7.0)
@@ -670,6 +687,26 @@ end
     @test allequal(LinRange(1, 1, 1))
     @test allequal(LinRange(1, 1, 2))
     @test !allequal(LinRange(1, 2, 2))
+    # Known length 1, need not evaluate:
+    @test allequal(error(x) for x in [1])
+    # Empty, but !haslength:
+    @test allequal(error(x) for x in 1:3 if false)
+end
+
+@testset "allequal(f, xs)" begin
+    @test allequal(abs2, [3, -3])
+    @test allequal(x -> 1, rand(3))
+    @test !allequal(x -> rand(), [1,1,1])
+    # tuples
+    @test allequal(abs2, (3, -3))
+    @test allequal(x -> 1, Tuple(rand(3)))
+    @test !allequal(x -> rand(), (1,1,1))
+    # These cases don't call the function at all:
+    @test allequal(error, [])
+    @test allequal(error, ())
+    @test allequal(error, (x for x in 1:3 if false))
+    @test allequal(error, [1])
+    @test allequal(error, (1,))
 end
 
 @testset "filter(f, ::$S)" for S = (Set, BitSet)

From 002f07a5b4ec7d2ab477f4e894d062c3c112d034 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Mon, 12 Feb 2024 06:42:31 +0800
Subject: [PATCH 0894/1315] Improve the annotated join method and dispatch
 (#51914)

With the initial implementation, join could work for AnnotatedStrings,
however only when the eltype of the iterator or delim was itself a
Annotated{String,Char}. This was better than nothing, but seems
inconsistent in the face of mixed iterators.

Furthermore, the implementation of an annotated join was far from
optimised, relying on zipping and then calling annotatedstring(xs...).
By contrast, the non-annotated implementation relies on printing to IO
and even has manually defined alternative methods for optional arguments
to minimise code generation.

With the advent of AnnotatedIOBuffer and _isannotated, we can improve on
both those aspects. The new AnnotatedIOBuffer type allows us to re-use
the optimised join(::IO, ...) methods, and we can more reliably dispatch
to them with _isannotated. Since this is a type-based decision, the
Julia compiler is kind enough to work out which branch is taken at
compile-time, making this zero-overhead in the unannotated case.
---
 base/strings/io.jl        | 27 +++++++++------------------
 test/strings/annotated.jl |  2 +-
 2 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/base/strings/io.jl b/base/strings/io.jl
index 6db737532637d..94b5a1e4e4614 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -353,28 +353,19 @@ function join(io::IO, iterator, delim="")
     end
 end
 
-# TODO: If/when we have `AnnotatedIO`, we can revisit this and
-# implement it more nicely.
-function join_annotated(iterator, delim="", last=delim)
-    xs = zip(iterator, Iterators.repeated(delim)) |> Iterators.flatten |> collect
-    xs = xs[1:end-1]
-    if length(xs) > 1
-        xs[end-1] = last
-    end
-    annotatedstring(xs...)::AnnotatedString{String}
-end
-
-function _join_maybe_annotated(args...)
-    if any(_isannotated ∘ eltype, args)
-        join_annotated(args...)
+function _join_preserve_annotations(iterator, args...)
+    if _isannotated(eltype(iterator)) || any(_isannotated, args)
+        io = AnnotatedIOBuffer()
+        join(io, iterator, args...)
+        read(seekstart(io), AnnotatedString{String})
     else
-        sprint(join, args...)
+        sprint(join, iterator, args...)
     end
 end
 
-join(iterator) = _join_maybe_annotated(iterator)
-join(iterator, delim) = _join_maybe_annotated(iterator, delim)
-join(iterator, delim, last) = _join_maybe_annotated(iterator, delim, last)
+join(iterator) = _join_preserve_annotations(iterator)
+join(iterator, delim) = _join_preserve_annotations(iterator, delim)
+join(iterator, delim, last) = _join_preserve_annotations(iterator, delim, last)
 
 ## string escaping & unescaping ##
 
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index 74898e09eb008..04933c0cb8473 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -91,7 +91,7 @@ end
                                       (6:11, :other => 0x02)])
     str1 = Base.AnnotatedString("test", [(1:4, :label => 5)])
     str2 = Base.AnnotatedString("case", [(2:3, :label => "oomph")])
-    @test join([str1, str1], Base.AnnotatedString(" ")) ==
+    @test join([str1, str1], ' ') ==
         Base.AnnotatedString("test test",
                      [(1:4, :label => 5),
                       (6:9, :label => 5)])

From 86c0191b498ecfd35e871a63198d55320d34f92f Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Mon, 12 Feb 2024 00:25:48 +0100
Subject: [PATCH 0895/1315] Tests: rename Foo test pkg (#53289)

Encountered another instance of a flaky `Foo.jl` test pkg which caused
me trouble locally.

Xref:
https://github.com/JuliaLang/julia/issues/53103#issuecomment-1915458694
---
 test/loading.jl | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/test/loading.jl b/test/loading.jl
index 3740babcd17ed..2dc895a8fbd8b 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1329,11 +1329,11 @@ end
         mkpath(project_path)
 
         # Create fake `Foo.jl` package with two files:
-        foo_path = joinpath(depot, "dev", "Foo")
+        foo_path = joinpath(depot, "dev", "Foo51989")
         mkpath(joinpath(foo_path, "src"))
-        open(joinpath(foo_path, "src", "Foo.jl"); write=true) do io
+        open(joinpath(foo_path, "src", "Foo51989.jl"); write=true) do io
             println(io, """
-            module Foo
+            module Foo51989
             include("internal.jl")
             end
             """)
@@ -1343,7 +1343,7 @@ end
         end
         open(joinpath(foo_path, "Project.toml"); write=true) do io
             println(io, """
-            name = "Foo"
+            name = "Foo51989"
             uuid = "00000000-0000-0000-0000-000000000001"
             version = "1.0.0"
             """)
@@ -1351,27 +1351,27 @@ end
 
         # In our depot, `dev` and then `precompile` this `Foo` package.
         @test success(addenv(
-            `$(Base.julia_cmd()) --project=$project_path --startup-file=no -e 'import Pkg; Pkg.develop("Foo"); Pkg.precompile(); exit(0)'`,
+            `$(Base.julia_cmd()) --project=$project_path --startup-file=no -e 'import Pkg; Pkg.develop("Foo51989"); Pkg.precompile(); exit(0)'`,
             "JULIA_DEPOT_PATH" => depot))
 
         # Get the size of the generated `.ji` file so that we can ensure that it gets altered
-        foo_compiled_path = joinpath(depot, "compiled", "v$(VERSION.major).$(VERSION.minor)", "Foo")
+        foo_compiled_path = joinpath(depot, "compiled", "v$(VERSION.major).$(VERSION.minor)", "Foo51989")
         cache_path = joinpath(foo_compiled_path, only(filter(endswith(".ji"), readdir(foo_compiled_path))))
         cache_size = filesize(cache_path)
 
         # Next, remove the dependence on `internal.jl` and delete it:
         rm(joinpath(foo_path, "src", "internal.jl"))
-        open(joinpath(foo_path, "src", "Foo.jl"); write=true) do io
+        open(joinpath(foo_path, "src", "Foo51989.jl"); write=true) do io
             truncate(io, 0)
             println(io, """
-            module Foo
+            module Foo51989
             end
             """)
         end
 
         # Try to load `Foo`; this should trigger recompilation, not an error!
         @test success(addenv(
-            `$(Base.julia_cmd()) --project=$project_path --startup-file=no -e 'using Foo; exit(0)'`,
+            `$(Base.julia_cmd()) --project=$project_path --startup-file=no -e 'using Foo51989; exit(0)'`,
             "JULIA_DEPOT_PATH" => depot,
         ))
 

From e1a76bb40668d80ea84a0c2fc458010bf2a4501e Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Mon, 12 Feb 2024 08:56:30 +0800
Subject: [PATCH 0896/1315] More consistent return value for `annotations`
 (#53281)

This is a generally nice simplification, that tweaks the `annotations`
API.

It also requires the adjustment in
https://github.com/JuliaLang/StyledStrings.jl/pull/38 to be made, hence
the bump.
---
 base/strings/annotated.jl                     | 20 +++++++++++--------
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 stdlib/StyledStrings.version                  |  2 +-
 6 files changed, 15 insertions(+), 11 deletions(-)
 delete mode 100644 deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
 create mode 100644 deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index d67ac70d8c684..43d105999315f 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -153,7 +153,7 @@ lastindex(s::AnnotatedString) = lastindex(s.string)
 function getindex(s::AnnotatedString, i::Integer)
     @boundscheck checkbounds(s, i)
     @inbounds if isvalid(s, i)
-        AnnotatedChar(s.string[i], annotations(s, i))
+        AnnotatedChar(s.string[i], map(last, annotations(s, i)))
     else
         string_index_err(s, i)
     end
@@ -354,12 +354,16 @@ annotate!(c::AnnotatedChar, @nospecialize(labelval::Pair{Symbol, <:Any})) =
     (push!(c.annotations, labelval); c)
 
 """
-    annotations(str::AnnotatedString, [position::Union{Integer, UnitRange}])
-    annotations(str::SubString{AnnotatedString}, [position::Union{Integer, UnitRange}])
+    annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
+                [position::Union{Integer, UnitRange}]) ->
+        Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
 
 Get all annotations that apply to `str`. Should `position` be provided, only
 annotations that overlap with `position` will be returned.
 
+Annotations are provided together with the regions they apply to, in the form of
+a vector of region–annotation tuples.
+
 See also: `annotate!`.
 """
 annotations(s::AnnotatedString) = s.annotations
@@ -369,22 +373,22 @@ annotations(s::SubString{<:AnnotatedString}) =
 
 function annotations(s::AnnotatedString, pos::UnitRange{<:Integer})
     # TODO optimise
-    annots = filter(label -> !isempty(intersect(pos, first(label))),
-                    s.annotations)
-    last.(annots)
+    filter(label -> !isempty(intersect(pos, first(label))),
+           s.annotations)
 end
 
 annotations(s::AnnotatedString, pos::Integer) = annotations(s, pos:pos)
 
 annotations(s::SubString{<:AnnotatedString}, pos::Integer) =
     annotations(s.string, s.offset + pos)
+
 annotations(s::SubString{<:AnnotatedString}, pos::UnitRange{<:Integer}) =
     annotations(s.string, first(pos)+s.offset:last(pos)+s.offset)
 
 """
-    annotations(chr::AnnotatedChar)
+    annotations(chr::AnnotatedChar) -> Vector{Pair{Symbol, Any}}
 
-Get all annotations of `chr`.
+Get all annotations of `chr`, in the form of a vector of annotation pairs.
 """
 annotations(c::AnnotatedChar) = c.annotations
 
diff --git a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5 b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
deleted file mode 100644
index fc675ee83125a..0000000000000
--- a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-c1fd1bb7e3f9ab00afe0758a8a101374
diff --git a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512 b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
deleted file mode 100644
index 09d5a8a619295..0000000000000
--- a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-373302f1d32a5b5ad0efacf14fa82a16fd877c11ca589fc1f1492eb1d4bcd0f49a2a5a3f471f8577649309c8a03634e7467e31b403cfd6ab8a8e4a775d7f4e53
diff --git a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5 b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
new file mode 100644
index 0000000000000..2ab79799cca0e
--- /dev/null
+++ b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
@@ -0,0 +1 @@
+fc3a846400107c432d20da6cfdd19ccf
diff --git a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512 b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512
new file mode 100644
index 0000000000000..70b0ef6f5cb3a
--- /dev/null
+++ b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512
@@ -0,0 +1 @@
+22da8964cc4c09f7c7a3da44be14c953f520ce6d395cf0f9ccf9c17777d6d968b0a874b35c072801ef7a1f4eee40f96ea0e2fc5ed5b3a63ad0b6b776a9c14ebb
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index 8180223575f05..19a5a24514f2f 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = a1b2ae2434cd7d8199fa8647339422fe0e1d0324
+STYLEDSTRINGS_SHA1 = e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1

From 3412c86e956482a7ef6a12b0274686b9c64a48e4 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Mon, 12 Feb 2024 09:08:47 +0800
Subject: [PATCH 0897/1315] Fix seekend method of AnnotatedIOBuffer (#53282)

A minor oversight had it returning the underlying IOBuffer originally.
---
 base/strings/annotated.jl | 2 +-
 test/strings/annotated.jl | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 43d105999315f..f458c641f3b7f 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -414,7 +414,7 @@ pipe_writer(io::AnnotatedIOBuffer) = io.io
 # Useful `IOBuffer` methods that we don't get from `AbstractPipe`
 position(io::AnnotatedIOBuffer) = position(io.io)
 seek(io::AnnotatedIOBuffer, n::Integer) = (seek(io.io, n); io)
-seekend(io::AnnotatedIOBuffer) = seekend(io.io)
+seekend(io::AnnotatedIOBuffer) = (seekend(io.io); io)
 skip(io::AnnotatedIOBuffer, n::Integer) = (skip(io.io, n); io)
 copy(io::AnnotatedIOBuffer) = AnnotatedIOBuffer(copy(io.io), copy(io.annotations))
 
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index 04933c0cb8473..9d812deea51f8 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -122,7 +122,7 @@ end
     @test read(seek(aio, 1), Base.AnnotatedString) == Base.AnnotatedString("ello world", [(1:4, :tag => 1), (6:10, :tag => 2)])
     @test read(seek(aio, 4), Base.AnnotatedString) == Base.AnnotatedString("o world", [(1:1, :tag => 1), (3:7, :tag => 2)])
     @test read(seek(aio, 5), Base.AnnotatedString) == Base.AnnotatedString(" world", [(2:6, :tag => 2)])
-    @test read(aio, Base.AnnotatedString) == Base.AnnotatedString("")
+    @test read(seekend(aio), Base.AnnotatedString) == Base.AnnotatedString("")
     @test read(seekstart(truncate(deepcopy(aio), 5)), Base.AnnotatedString) == Base.AnnotatedString("hello", [(1:5, :tag => 1)])
     @test read(seekstart(truncate(deepcopy(aio), 6)), Base.AnnotatedString) == Base.AnnotatedString("hello ", [(1:5, :tag => 1)])
     @test read(seekstart(truncate(deepcopy(aio), 7)), Base.AnnotatedString) == Base.AnnotatedString("hello w", [(1:5, :tag => 1), (7:7, :tag => 2)])

From a86edf132cb75faebaab27d56cc520f842fa6bb1 Mon Sep 17 00:00:00 2001
From: Michael Abbott <32575566+mcabbott@users.noreply.github.com>
Date: Sun, 11 Feb 2024 20:24:59 -0500
Subject: [PATCH 0898/1315] Add existing 3-arg `*` docstring to the manual
 (#53288)

PR #37898 added methods to `*` for chained matrix multiplication. They
have a descriptive docstring but I don't think this is mentioned in the
manual.
---
 stdlib/LinearAlgebra/docs/src/index.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stdlib/LinearAlgebra/docs/src/index.md b/stdlib/LinearAlgebra/docs/src/index.md
index 138e505c79a46..1d4c1f360feb6 100644
--- a/stdlib/LinearAlgebra/docs/src/index.md
+++ b/stdlib/LinearAlgebra/docs/src/index.md
@@ -412,6 +412,7 @@ Other sparse solvers are available as Julia packages.
 
 ```@docs
 Base.:*(::AbstractMatrix, ::AbstractMatrix)
+Base.:*(::AbstractMatrix, ::AbstractMatrix, ::AbstractVector)
 Base.:\(::AbstractMatrix, ::AbstractVecOrMat)
 Base.:/(::AbstractVecOrMat, ::AbstractVecOrMat)
 LinearAlgebra.SingularException

From 57f02bfaeb5dca0d7774ccabdf92ac57baccff0c Mon Sep 17 00:00:00 2001
From: Eric Hanson <5846501+ericphanson@users.noreply.github.com>
Date: Mon, 12 Feb 2024 02:33:29 +0100
Subject: [PATCH 0899/1315] Add `Lockable` to Base, to bundle a lock with its
 resource (#52898)

I am not sure about a `lock(f, ::Lockable)` method: it is nice because
it unpacks the value for you, but it is weird because it unpacks the
value for you. For a `Lockable`, `f` must accept one argument, whereas
for a `Lock`, `f` must be 0-arg. A `Lockable` is not `<:AbstractLock`
here, so maybe this is allowed, but if we deleted this `lock` method, we
could inherit from `AbstractLock` and just use the generic one
(requiring folks to unpack the value within the locked region
themselves, as is the case for `@lock`). I think it is preferred these
days to use `@lock` anyway, so having the `lock(f, ::Lockable)` method
may be of limited value anyway.

I searched Base and came up with two places that could currently use
this internally, `TEMP_CLEANUP` and `env_dict`. We didn't add them both
as usages yet, to avoid external breakage from delaying this PR.

Similarly, this is not exported yet, to avoid breakage with older
releases of ConcurrentUtilities.jl.

redo of https://github.com/JuliaLang/julia/pull/34400
First commit copied from
https://github.com/JuliaServices/ConcurrentUtilities.jl/blob/main/src/lockable.jl,
Closes #52897

Co-authored-by: Jacob Quinn <quinn.jacobd@gmail.com>
Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 NEWS.md                  |  1 +
 base/env.jl              |  9 +++----
 base/lock.jl             | 57 ++++++++++++++++++++++++++++++++++++++++
 doc/src/base/parallel.md |  1 +
 test/misc.jl             | 30 +++++++++++++++++++++
 5 files changed, 93 insertions(+), 5 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 3c83e995c4de2..bf4e72afc95d0 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -73,6 +73,7 @@ Multi-threading changes
 -----------------------
 
 * `Threads.@threads` now supports the `:greedy` scheduler, intended for non-uniform workloads ([#52096]).
+* A new exported struct `Lockable{T, L<:AbstractLock}` makes it easy to bundle a resource and its lock together ([#52898]).
 
 Build system changes
 --------------------
diff --git a/base/env.jl b/base/env.jl
index 3092efbe372e0..2928a8bdfede2 100644
--- a/base/env.jl
+++ b/base/env.jl
@@ -3,19 +3,18 @@
 if Sys.iswindows()
     const ERROR_ENVVAR_NOT_FOUND = UInt32(203)
 
-    const env_dict = Dict{String, Vector{Cwchar_t}}()
-    const env_lock = ReentrantLock()
+    const env_dict = Lockable(Dict{String, Vector{Cwchar_t}}())
 
     function memoized_env_lookup(str::AbstractString)
         # Windows environment variables have a different format from Linux / MacOS, and previously
         # incurred allocations because we had to convert a String to a Vector{Cwchar_t} each time
         # an environment variable was looked up. This function memoizes that lookup process, storing
         # the String => Vector{Cwchar_t} pairs in env_dict
-        @lock env_lock begin
-            var = get(env_dict, str, nothing)
+        @lock env_dict begin
+            var = get(env_dict[], str, nothing)
             if isnothing(var)
                 var = cwstring(str)
-                env_dict[str] = var
+                env_dict[][str] = var
             end
             return var
         end
diff --git a/base/lock.jl b/base/lock.jl
index eb76a3b30e6a4..7cbb023a78ee4 100644
--- a/base/lock.jl
+++ b/base/lock.jl
@@ -294,6 +294,63 @@ macro lock_nofail(l, expr)
     end
 end
 
+"""
+  Lockable(value, lock = ReentrantLock())
+
+Creates a `Lockable` object that wraps `value` and
+associates it with the provided `lock`. This object
+supports [`@lock`](@ref), [`lock`](@ref), [`trylock`](@ref),
+[`unlock`](@ref). To access the value, index the lockable object while
+holding the lock.
+
+!!! compat "Julia 1.11"
+    Requires at least Julia 1.11.
+
+## Example
+
+```jldoctest
+julia> locked_list = Base.Lockable(Int[]);
+
+julia> @lock(locked_list, push!(locked_list[], 1)) # must hold the lock to access the value
+1-element Vector{Int64}:
+ 1
+
+julia> lock(summary, locked_list)
+"1-element Vector{Int64}"
+```
+"""
+struct Lockable{T, L <: AbstractLock}
+    value::T
+    lock::L
+end
+
+Lockable(value) = Lockable(value, ReentrantLock())
+getindex(l::Lockable) = (assert_havelock(l.lock); l.value)
+
+"""
+  lock(f::Function, l::Lockable)
+
+Acquire the lock associated with `l`, execute `f` with the lock held,
+and release the lock when `f` returns. `f` will receive one positional
+argument: the value wrapped by `l`. If the lock is already locked by a
+different task/thread, wait for it to become available.
+When this function returns, the `lock` has been released, so the caller should
+not attempt to `unlock` it.
+
+!!! compat "Julia 1.11"
+    Requires at least Julia 1.11.
+"""
+function lock(f, l::Lockable)
+    lock(l.lock) do
+        f(l.value)
+    end
+end
+
+# implement the rest of the Lock interface on Lockable
+lock(l::Lockable) = lock(l.lock)
+trylock(l::Lockable) = trylock(l.lock)
+unlock(l::Lockable) = unlock(l.lock)
+
 @eval Threads begin
     """
         Threads.Condition([lock])
diff --git a/doc/src/base/parallel.md b/doc/src/base/parallel.md
index c3106b8caf8c7..5798da54a5cde 100644
--- a/doc/src/base/parallel.md
+++ b/doc/src/base/parallel.md
@@ -51,6 +51,7 @@ Base.trylock
 Base.islocked
 Base.ReentrantLock
 Base.@lock
+Base.Lockable
 ```
 
 ## Channels
diff --git a/test/misc.jl b/test/misc.jl
index d2a8fabd119c5..6597ecf8a8428 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -129,6 +129,36 @@ let l = ReentrantLock()
     @test_throws ErrorException unlock(l)
 end
 
+# Lockable{T, L<:AbstractLock}
+using Base: Lockable
+let
+    @test_broken Base.isexported(Base, :Lockable)
+    lockable = Lockable(Dict("foo" => "hello"), ReentrantLock())
+    # note field access is non-public
+    @test lockable.value["foo"] == "hello"
+    @test @lock(lockable, lockable[]["foo"]) == "hello"
+    lock(lockable) do d
+        @test d["foo"] == "hello"
+    end
+    lock(lockable) do d
+        d["foo"] = "goodbye"
+    end
+    @test lockable.value["foo"] == "goodbye"
+    @lock lockable begin
+        @test lockable[]["foo"] == "goodbye"
+    end
+    l = trylock(lockable)
+    try
+        @test l
+    finally
+        unlock(lockable)
+    end
+    # Test 1-arg constructor
+    lockable2 = Lockable(Dict("foo" => "hello"))
+    @test lockable2.lock isa ReentrantLock
+    @test @lock(lockable2, lockable2[]["foo"]) == "hello"
+end
+
 for l in (Threads.SpinLock(), ReentrantLock())
     @test get_finalizers_inhibited() == 0
     @test lock(get_finalizers_inhibited, l) == 1

From a459926fbf245c5a3fe0015ae0d665d84066e278 Mon Sep 17 00:00:00 2001
From: Frames White <oxinabox@ucc.asn.au>
Date: Mon, 12 Feb 2024 09:41:01 +0800
Subject: [PATCH 0900/1315] Make zero on array of arrays etc apply recursively
 (#51458)

I wonder if this breaks things, in practice. It shouldn't. Since old
code behavior errored for the cases I am aware of.
As discussed in #38064, this definition is needed to be consistent with
our other linear algebra operations,
and with us considering a vector of vectors etc as a vector space.

Closes #38064
---
 NEWS.md               |  1 +
 base/abstractarray.jl |  3 ++-
 test/abstractarray.jl | 11 +++++++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/NEWS.md b/NEWS.md
index bf4e72afc95d0..4ad8a9b761dda 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -111,6 +111,7 @@ New library features
   automatically.
 * `@timed` now additionally returns the elapsed compilation and recompilation time ([#52889])
 * `filter` can now act on a `NamedTuple` ([#50795]).
+* `zero(::AbstractArray)` now applies recursively, so `zero([[1,2],[3,4,5]])` now produces the additive identity `[[0,0],[0,0,0]]` rather than erroring ([#38064]).
 
 Standard library changes
 ------------------------
diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 1af8e07584d0d..6c6f38dd2f339 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1217,7 +1217,8 @@ function copymutable(a::AbstractArray)
 end
 copymutable(itr) = collect(itr)
 
-zero(x::AbstractArray{T}) where {T} = fill!(similar(x, typeof(zero(T))), zero(T))
+zero(x::AbstractArray{T}) where {T<:Number} = fill!(similar(x, typeof(zero(T))), zero(T))
+zero(x::AbstractArray) = map(zero, x)
 
 ## iteration support for arrays by iterating over `eachindex` in the array ##
 # Allows fast iteration by default for both IndexLinear and IndexCartesian arrays
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 099ffc653e8d6..c3409a4a059fb 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1950,3 +1950,14 @@ end
     @test repeat(f, 2, 3, 4) === FillArrays.Fill(3, (8, 6, 4))
     @test repeat(f, inner=(1,2), outer=(3,1)) === FillArrays.Fill(3, (12, 4))
 end
+
+@testset "zero" begin
+    @test zero([1 2; 3 4]) isa Matrix{Int}
+    @test zero([1 2; 3 4]) == [0 0; 0 0]
+
+    @test zero([1.0]) isa Vector{Float64}
+    @test zero([1.0]) == [0.0]
+
+    @test zero([[2,2], [3,3,3]]) isa Vector{Vector{Int}}
+    @test zero([[2,2], [3,3,3]]) == [[0,0], [0, 0, 0]]
+end

From 850035611655b426f48166a81d315cad4d853b17 Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Sun, 11 Feb 2024 19:41:41 -0600
Subject: [PATCH 0901/1315] Add more doc examples for `cat` (#47409)

- `cat` 2 2D arrays
- `cat` 2 3D arrays
- `cat` 2 strings
---
 base/abstractarray.jl | 67 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 6c6f38dd2f339..cb2519bdbeca5 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1990,24 +1990,91 @@ The keyword also accepts `Val(dims)`.
     For multiple dimensions `dims = Val(::Tuple)` was added in Julia 1.8.
 
 # Examples
+
+Concatenate two arrays in different dimensions:
+```jldoctest
+julia> a = [1 2 3]
+1×3 Matrix{Int64}:
+ 1  2  3
+
+julia> b = [4 5 6]
+1×3 Matrix{Int64}:
+ 4  5  6
+
+julia> cat(a, b; dims=1)
+2×3 Matrix{Int64}:
+ 1  2  3
+ 4  5  6
+
+julia> cat(a, b; dims=2)
+1×6 Matrix{Int64}:
+ 1  2  3  4  5  6
+
+julia> cat(a, b; dims=(1, 2))
+2×6 Matrix{Int64}:
+ 1  2  3  0  0  0
+ 0  0  0  4  5  6
+```
+
+# Extended Help
+
+Concatenate 3D arrays:
+```jldoctest
+julia> a = ones(2, 2, 3);
+
+julia> b = ones(2, 2, 4);
+
+julia> c = cat(a, b; dims=3);
+
+julia> size(c) == (2, 2, 7)
+true
+```
+
+Concatenate arrays of different sizes:
 ```jldoctest
 julia> cat([1 2; 3 4], [pi, pi], fill(10, 2,3,1); dims=2)  # same as hcat
 2×6×1 Array{Float64, 3}:
 [:, :, 1] =
  1.0  2.0  3.14159  10.0  10.0  10.0
  3.0  4.0  3.14159  10.0  10.0  10.0
+```
 
+Construct a block diagonal matrix:
+```
 julia> cat(true, trues(2,2), trues(4)', dims=(1,2))  # block-diagonal
 4×7 Matrix{Bool}:
  1  0  0  0  0  0  0
  0  1  1  0  0  0  0
  0  1  1  0  0  0  0
  0  0  0  1  1  1  1
+```
 
+```
 julia> cat(1, [2], [3;;]; dims=Val(2))
 1×3 Matrix{Int64}:
  1  2  3
 ```
+
+!!! note
+    `cat` does not join two strings, you may want to use `*`.
+
+```jldoctest
+julia> a = "aaa";
+
+julia> b = "bbb";
+
+julia> cat(a, b; dims=1)
+2-element Vector{String}:
+ "aaa"
+ "bbb"
+
+julia> cat(a, b; dims=2)
+1×2 Matrix{String}:
+ "aaa"  "bbb"
+
+julia> a * b
+"aaabbb"
+```
 """
 @inline cat(A...; dims) = _cat(dims, A...)
 # `@constprop :aggressive` allows `catdims` to be propagated as constant improving return type inference

From 987d6f323bc066c9606abb435b3b2a4318e5ff4b Mon Sep 17 00:00:00 2001
From: Zentrik <Zentrik@users.noreply.github.com>
Date: Mon, 12 Feb 2024 01:43:52 +0000
Subject: [PATCH 0902/1315] Update probes.md to remove workaround mention
 (#53160)

Given #41616 merged, remove reference to it in doc example
---
 doc/src/devdocs/probes.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/src/devdocs/probes.md b/doc/src/devdocs/probes.md
index d15723e945462..e75e7f6bb0156 100644
--- a/doc/src/devdocs/probes.md
+++ b/doc/src/devdocs/probes.md
@@ -137,8 +137,8 @@ fib(x) = x <= 1 ? 1 : fib(x-1) + fib(x-2)
 beaver = @spawn begin
     while true
         fib(30)
-        # This safepoint is necessary until #41616, since otherwise this
-        # loop will never yield to GC.
+        # A manual safepoint is necessary since otherwise this loop
+        # may never yield to GC.
         GC.safepoint()
     end
 end

From d6396f1c62e4734b3e55babed0b9321e94a96ae3 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Mon, 12 Feb 2024 03:11:28 +0100
Subject: [PATCH 0903/1315] doc: in constructors, note the correspondence with
 callable objects (#53051)

---
 doc/src/manual/constructors.md | 50 ++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/doc/src/manual/constructors.md b/doc/src/manual/constructors.md
index f8b9dd9673082..9f9afca3e076c 100644
--- a/doc/src/manual/constructors.md
+++ b/doc/src/manual/constructors.md
@@ -575,3 +575,53 @@ This constructor will be invoked by the syntax `SummedArray(a)`. The syntax `new
 specifying parameters for the type to be constructed, i.e. this call will return a `SummedArray{T,S}`.
 `new{T,S}` can be used in any constructor definition, but for convenience the parameters
 to `new{}` are automatically derived from the type being constructed when possible.
+
+## Constructors are just callable objects
+
+An object of any type may be [made callable](@ref "Function-like objects") by defining a
+method. This includes types, i.e., objects of type [`Type`](@ref); and constructors may,
+in fact, be viewed as just callable type objects. For example, there are many methods
+defined on `Bool` and various supertypes of it:
+
+```julia-repl
+julia> methods(Bool)
+# 10 methods for type constructor:
+  [1] Bool(x::BigFloat)
+     @ Base.MPFR mpfr.jl:393
+  [2] Bool(x::Float16)
+     @ Base float.jl:338
+  [3] Bool(x::Rational)
+     @ Base rational.jl:138
+  [4] Bool(x::Real)
+     @ Base float.jl:233
+  [5] (dt::Type{<:Integer})(ip::Sockets.IPAddr)
+     @ Sockets ~/tmp/jl/jl/julia-nightly-assert/share/julia/stdlib/v1.11/Sockets/src/IPAddr.jl:11
+  [6] (::Type{T})(x::Enum{T2}) where {T<:Integer, T2<:Integer}
+     @ Base.Enums Enums.jl:19
+  [7] (::Type{T})(z::Complex) where T<:Real
+     @ Base complex.jl:44
+  [8] (::Type{T})(x::Base.TwicePrecision) where T<:Number
+     @ Base twiceprecision.jl:265
+  [9] (::Type{T})(x::T) where T<:Number
+     @ boot.jl:894
+ [10] (::Type{T})(x::AbstractChar) where T<:Union{AbstractChar, Number}
+     @ char.jl:50
+```
+
+The usual constructor syntax is exactly equivalent to the function-like object
+syntax, so trying to define a method with each syntax will cause the first method
+to be overwritten by the next one:
+
+```jldoctest
+julia> struct S
+           f::Int
+       end
+
+julia> S() = S(7)
+S
+
+julia> (::Type{S})() = S(8)  # overwrites the previous constructor method
+
+julia> S()
+S(8)
+```

From 0a8916446b782eae1a09681b2b47c1be26fab7f3 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 12 Feb 2024 07:44:23 +0530
Subject: [PATCH 0904/1315] Restrict vector indexing of views to 1-based ranges
 (#53249)

This will be an offset array in general, so we need to restrict the
method to 1-based ranges. This restores the behavior on `v"1.10"`.

The method was added in #45371
---
 base/subarray.jl    | 4 +++-
 test/offsetarray.jl | 5 +++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index 6f1e20af2b966..7b7e913332aaf 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -338,7 +338,9 @@ function getindex(V::FastContiguousSubArray, i::Int)
 end
 # parents of FastContiguousSubArrays may support fast indexing with AbstractUnitRanges,
 # so we may just forward the indexing to the parent
-function getindex(V::FastContiguousSubArray, i::AbstractUnitRange{Int})
+# This may only be done for non-offset ranges, as the result would otherwise have offset axes
+const OneBasedRanges = Union{OneTo{Int}, UnitRange{Int}, Slice{OneTo{Int}}, IdentityUnitRange{OneTo{Int}}}
+function getindex(V::FastContiguousSubArray, i::OneBasedRanges)
     @inline
     @boundscheck checkbounds(V, i)
     @inbounds r = V.parent[V.offset1 .+ i]
diff --git a/test/offsetarray.jl b/test/offsetarray.jl
index e2924ac0a8ca4..9d6a8b08c0b1f 100644
--- a/test/offsetarray.jl
+++ b/test/offsetarray.jl
@@ -864,3 +864,8 @@ end
     # this is fixed in #40038, so the evaluation of its CartesianIndices should work
     @test CartesianIndices(A) == CartesianIndices(B)
 end
+
+@testset "indexing views (#53249)" begin
+    v = view([1,2,3,4], :)
+    @test v[Base.IdentityUnitRange(2:3)] == OffsetArray(2:3, 2:3)
+end

From 61bf2089c3786e9740f59d09a2c413f167cb8cf4 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 12 Feb 2024 19:56:26 +0900
Subject: [PATCH 0905/1315] follow up #52868 and fix up doc/src/base/base.md
 (#53294)

---
 doc/src/base/base.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 64c635ed3043b..3fd2bbb12bb1f 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -1,4 +1,4 @@
-#replacefield Essentials
+# Essentials
 
 ## Introduction
 
@@ -469,7 +469,6 @@ Core.setglobalonce!
 Core.replaceglobal!
 ```
 
-
 ## Documentation
 (See also the [documentation](@ref man-documentation) chapter.)
 ```@docs

From 29a58d5c4a5943774984ba83b2a84f98ff377a73 Mon Sep 17 00:00:00 2001
From: Michael Abbott <32575566+mcabbott@users.noreply.github.com>
Date: Mon, 12 Feb 2024 09:03:37 -0500
Subject: [PATCH 0906/1315] Improve docstrings for `Int`, `Float64`, `^`, and
 friends (#45221)

This extends the docs for `Int`, `Float64` etc, to
* Note that Int is the default, mention that it can overflow
* Explain what `1f0` means, and that Float64 is the default

Similarly extends docs for `^`, `+`, `*` aiming to
* Point out that `1.2 * 10^3` is a bad habit, warn about overflow
* Give an example for what `literal_pow` is doing since the explanation
is quite technical
* Also point out overflow in `+`, as [suggested
here](https://github.com/JuliaLang/julia/pull/45141#discussion_r862808888)
* While there, mention that you can add vectors, and that vararg
`+(1,2,3,4)` has a default binary behaviour
* Similarly mention that vararg `*(1,2,3,4)` has a default order, from
the left
* While there, mention `1/2pi` and `v'v` as examples of `*`.

---------

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/docs/basedocs.jl   | 215 +++++++++++++++++++++++++++++++++++-----
 base/math.jl            |  30 +++++-
 base/promotion.jl       |  33 ++++--
 doc/src/base/numbers.md |   2 +
 4 files changed, 240 insertions(+), 40 deletions(-)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 383ae2c683182..d4785df98ec21 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -2028,7 +2028,21 @@ AbstractFloat
 """
     Integer <: Real
 
-Abstract supertype for all integers.
+Abstract supertype for all integers (e.g. [`Signed`](@ref), [`Unsigned`](@ref), and [`Bool`](@ref)).
+
+See also [`isinteger`](@ref), [`trunc`](@ref), [`div`](@ref).
+
+# Examples
+```
+julia> 42 isa Integer
+true
+
+julia> 1.0 isa Integer
+false
+
+julia> isinteger(1.0)
+true
+```
 """
 Integer
 
@@ -2043,6 +2057,21 @@ Signed
     Unsigned <: Integer
 
 Abstract supertype for all unsigned integers.
+
+Built-in unsigned integers are printed in hexadecimal, with prefix `0x`,
+and can be entered in the same way.
+
+# Examples
+```
+julia> typemax(UInt8)
+0xff
+
+julia> Int(0x00d)
+13
+
+julia> unsigned(true)
+0x0000000000000001
+```
 """
 Unsigned
 
@@ -2053,57 +2082,147 @@ Boolean type, containing the values `true` and `false`.
 
 `Bool` is a kind of number: `false` is numerically
 equal to `0` and `true` is numerically equal to `1`.
-Moreover, `false` acts as a multiplicative "strong zero":
+Moreover, `false` acts as a multiplicative "strong zero"
+against [`NaN`](@ref) and [`Inf`](@ref):
 
 ```jldoctest
-julia> false == 0
+julia> [true, false] == [1, 0]
 true
 
-julia> true == 1
-true
+julia> 42.0 + true
+43.0
 
-julia> 0 * NaN
-NaN
+julia> 0 .* (NaN, Inf, -Inf)
+(NaN, NaN, NaN)
 
-julia> false * NaN
-0.0
+julia> false .* (NaN, Inf, -Inf)
+(0.0, 0.0, -0.0)
 ```
 
-See also: [`digits`](@ref), [`iszero`](@ref), [`NaN`](@ref).
+Branches via [`if`](@ref) and other conditionals only accept `Bool`.
+There are no "truthy" values in Julia.
+
+Comparisons typically return `Bool`, and broadcasted comparisons may
+return [`BitArray`](@ref) instead of an `Array{Bool}`.
+
+```jldoctest
+julia> [1 2 3 4 5] .< pi
+1×5 BitMatrix:
+ 1  1  1  0  0
+
+julia> map(>(pi), [1 2 3 4 5])
+1×5 Matrix{Bool}:
+ 0  0  0  1  1
+```
+
+See also [`trues`](@ref), [`falses`](@ref), [`ifelse`](@ref).
 """
 Bool
 
-for (bit, sign, exp, frac) in ((16, 1, 5, 10), (32, 1, 8, 23), (64, 1, 11, 52))
-    @eval begin
-        """
-            Float$($bit) <: AbstractFloat
+"""
+    Float64 <: AbstractFloat <: Real
 
-        $($bit)-bit floating point number type (IEEE 754 standard).
+64-bit floating point number type (IEEE 754 standard).
+Binary format is 1 sign, 11 exponent, 52 fraction bits.
+See [`bitstring`](@ref), [`signbit`](@ref), [`exponent`](@ref), [`frexp`](@ref),
+and [`significand`](@ref) to access various bits.
 
-        Binary format: $($sign) sign, $($exp) exponent, $($frac) fraction bits.
-        """
-        $(Symbol("Float", bit))
-    end
-end
+This is the default for floating point literals, `1.0 isa Float64`,
+and for many operations such as `1/2, 2pi, log(2), range(0,90,length=4)`.
+Unlike integers, this default does not change with `Sys.WORD_SIZE`.
+
+The exponent for scientific notation can be entered as `e` or `E`,
+thus `2e3 === 2.0E3 === 2.0 * 10^3`. Doing so is strongly preferred over
+`10^n` because integers overflow, thus `2.0 * 10^19 < 0` but `2e19 > 0`.
+
+See also [`Inf`](@ref), [`NaN`](@ref), [`floatmax`](@ref), [`Float32`](@ref), [`Complex`](@ref).
+"""
+Float64
+
+"""
+    Float32 <: AbstractFloat <: Real
+
+32-bit floating point number type (IEEE 754 standard).
+Binary format is 1 sign, 8 exponent, 23 fraction bits.
+
+The exponent for scientific notation should be entered as lower-case `f`,
+thus `2f3 === 2.0f0 * 10^3 === Float32(2_000)`.
+For array literals and comprehensions, the element type can be specified before
+the square brackets: `Float32[1,4,9] == Float32[i^2 for i in 1:3]`.
+
+See also [`Inf32`](@ref), [`NaN32`](@ref), [`Float16`](@ref), [`exponent`](@ref), [`frexp`](@ref).
+"""
+Float32
+
+"""
+    Float16 <: AbstractFloat <: Real
+
+16-bit floating point number type (IEEE 754 standard).
+Binary format is 1 sign, 5 exponent, 10 fraction bits.
+"""
+Float16
 
 for bit in (8, 16, 32, 64, 128)
+    type = Symbol(:Int, bit)
+    srange = bit > 31 ? "" : "Represents numbers `n ∈ " * repr(eval(:(typemin($type):typemax($type)))) * "`.\n"
+    unshow = repr(eval(Symbol(:UInt, bit))(bit-1))
+
     @eval begin
         """
-            Int$($bit) <: Signed
+            Int$($bit) <: Signed <: Integer
 
         $($bit)-bit signed integer type.
+
+        $($(srange))Note that such integers overflow without warning,
+        thus `typemax($($type)) + $($type)(1) < 0`.
+
+        See also [`Int`](@ref $Int), [`widen`](@ref), [`BigInt`](@ref).
         """
         $(Symbol("Int", bit))
 
         """
-            UInt$($bit) <: Unsigned
+            UInt$($bit) <: Unsigned <: Integer
 
         $($bit)-bit unsigned integer type.
+
+        Printed in hexadecimal, thus $($(unshow)) == $($(bit-1)).
         """
         $(Symbol("UInt", bit))
     end
 end
 
+"""
+    Int
+
+Sys.WORD_SIZE-bit signed integer type, `Int <: Signed <: Integer <: Real`.
+
+This is the default type of most integer literals and is an alias for either `Int32`
+or `Int64`, depending on `Sys.WORD_SIZE`. It is the type returned by functions such as
+[`length`](@ref), and the standard type for indexing arrays.
+
+Note that integers overflow without warning, thus `typemax(Int) + 1 < 0` and `10^19 < 0`.
+Overflow can be avoided by using [`BigInt`](@ref).
+Very large integer literals will use a wider type, for instance `10_000_000_000_000_000_000 isa Int128`.
+
+Integer division is [`div`](@ref) alias `÷`,
+whereas [`/`](@ref) acting on integers returns [`Float64`](@ref).
+
+See also [`$(Symbol("Int", Sys.WORD_SIZE))`](@ref), [`widen`](@ref), [`typemax`](@ref), [`bitstring`](@ref).
+"""
+Int
+
+"""
+    UInt
+
+Sys.WORD_SIZE-bit unsigned integer type, `UInt <: Unsigned <: Integer`.
+
+Like [`Int`](@ref Int), the alias `UInt` may point to either `UInt32` or `UInt64`,
+according to the value of `Sys.WORD_SIZE` on a given computer.
+
+Printed and parsed in hexadecimal: `UInt(15) === $(repr(UInt(15)))`.
+"""
+UInt
+
 """
     Symbol
 
@@ -2796,7 +2915,13 @@ Ptr{T}()
 """
     +(x, y...)
 
-Addition operator. `x+y+z+...` calls this function with all arguments, i.e. `+(x, y, z, ...)`.
+Addition operator.
+
+Infix `x+y+z+...` calls this function with all arguments, i.e. `+(x, y, z, ...)`,
+which by default then calls `(x+y) + z + ...` starting from the left.
+
+Note that overflow is possible for most integer types, including the
+default `Int`, when adding large numbers.
 
 # Examples
 ```jldoctest
@@ -2805,6 +2930,14 @@ julia> 1 + 20 + 4
 
 julia> +(1, 20, 4)
 25
+
+julia> [1,2] + [3,4]
+2-element Vector{Int64}:
+ 4
+ 6
+
+julia> typemax(Int) + 1 < 0
+true
 ```
 """
 (+)(x, y...)
@@ -2828,6 +2961,12 @@ julia> -[1 2; 3 4]
 2×2 Matrix{Int64}:
  -1  -2
  -3  -4
+
+julia> -(true)  # promotes to Int
+-1
+
+julia> -(0x003)
+0xfffd
 ```
 """
 -(x)
@@ -2851,7 +2990,18 @@ julia> -(2, 4.5)
 """
     *(x, y...)
 
-Multiplication operator. `x*y*z*...` calls this function with all arguments, i.e. `*(x, y, z, ...)`.
+Multiplication operator.
+
+Infix `x*y*z*...` calls this function with all arguments, i.e. `*(x, y, z, ...)`,
+which by default then calls `(x*y) * z * ...` starting from the left.
+
+Juxtaposition such as `2pi` also calls `*(2, pi)`. Note that this operation
+has higher precedence than a literal `*`. Note also that juxtaposition "0x..."
+(integer zero times a variable whose name starts with `x`) is forbidden as
+it clashes with unsigned integer literals: `0x01 isa UInt8`.
+
+Note that overflow is possible for most integer types, including the default `Int`,
+when multiplying large numbers.
 
 # Examples
 ```jldoctest
@@ -2860,6 +3010,17 @@ julia> 2 * 7 * 8
 
 julia> *(2, 7, 8)
 112
+
+julia> [2 0; 0 3] * [1, 10]  # matrix * vector
+2-element Vector{Int64}:
+  2
+ 30
+
+julia> 1/2pi, 1/2*pi  # juxtaposition has higher precedence
+(0.15915494309189535, 1.5707963267948966)
+
+julia> x = [1, 2]; x'x  # adjoint vector * vector
+5
 ```
 """
 (*)(x, y...)
@@ -2867,8 +3028,10 @@ julia> *(2, 7, 8)
 """
     /(x, y)
 
-Right division operator: multiplication of `x` by the inverse of `y` on the right. Gives
-floating-point results for integer arguments.
+Right division operator: multiplication of `x` by the inverse of `y` on the right.
+
+Gives floating-point results for integer arguments.
+See [`÷`](@ref div) for integer division, or [`//`](@ref) for [`Rational`](@ref) results.
 
 # Examples
 ```jldoctest
diff --git a/base/math.jl b/base/math.jl
index 0071d427fbbac..6ed69188371dd 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -949,9 +949,11 @@ end
 
 Compute ``x \\times 2^n``.
 
+See also [`frexp`](@ref), [`exponent`](@ref).
+
 # Examples
 ```jldoctest
-julia> ldexp(5., 2)
+julia> ldexp(5.0, 2)
 20.0
 ```
 """
@@ -1008,8 +1010,7 @@ Returns the largest integer `y` such that `2^y ≤ abs(x)`.
 Throws a `DomainError` when `x` is zero, infinite, or [`NaN`](@ref).
 For any other non-subnormal floating-point number `x`, this corresponds to the exponent bits of `x`.
 
-See also [`signbit`](@ref), [`significand`](@ref), [`frexp`](@ref), [`issubnormal`](@ref), [`log2`](@ref).
-
+See also [`signbit`](@ref), [`significand`](@ref), [`frexp`](@ref), [`issubnormal`](@ref), [`log2`](@ref), [`ldexp`](@ref).
 # Examples
 ```jldoctest
 julia> exponent(8)
@@ -1021,8 +1022,16 @@ julia> exponent(6.5)
 julia> exponent(-1//4)
 -2
 
+julia> exponent(3.142e-4)
+-12
+
 julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
 (-126, -149)
+
+julia> exponent(0.0)
+ERROR: DomainError with 0.0:
+Cannot be ±0.0.
+[...]
 ```
 """
 function exponent(x::T) where T<:IEEEFloat
@@ -1062,6 +1071,8 @@ a non-zero finite number, then the result will be a number of the same type and
 sign as `x`, and whose absolute value is on the interval ``[1,2)``. Otherwise
 `x` is returned.
 
+See also [`frexp`](@ref), [`exponent`](@ref).
+
 # Examples
 ```jldoctest
 julia> significand(15.2)
@@ -1096,10 +1107,19 @@ end
 
 Return `(x,exp)` such that `x` has a magnitude in the interval ``[1/2, 1)`` or 0,
 and `val` is equal to ``x \\times 2^{exp}``.
+
+See also [`significand`](@ref), [`exponent`](@ref), [`ldexp`](@ref).
+
 # Examples
 ```jldoctest
-julia> frexp(12.8)
-(0.8, 4)
+julia> frexp(6.0)
+(0.75, 3)
+
+julia> significand(6.0), exponent(6.0)  # interval [1, 2) instead
+(1.5, 2)
+
+julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # exponent would give an error
+((0.0, 0), (NaN, 0), (-Inf, 0))
 ```
 """
 function frexp(x::T) where T<:IEEEFloat
diff --git a/base/promotion.jl b/base/promotion.jl
index 16769f8566b92..1d4fea8c404eb 100644
--- a/base/promotion.jl
+++ b/base/promotion.jl
@@ -430,7 +430,11 @@ end
 """
     ^(x, y)
 
-Exponentiation operator. If `x` is a matrix, computes matrix exponentiation.
+Exponentiation operator.
+
+If `x` and `y` are integers, the result may overflow.
+To enter numbers in scientific notation, use [`Float64`](@ref) literals
+such as `1.2e3` rather than `1.2 * 10^3`.
 
 If `y` is an `Int` literal (e.g. `2` in `x^2` or `-3` in `x^-3`), the Julia code
 `x^y` is transformed by the compiler to `Base.literal_pow(^, x, Val(y))`, to
@@ -440,20 +444,31 @@ where usually `^ == Base.^` unless `^` has been defined in the calling
 namespace.) If `y` is a negative integer literal, then `Base.literal_pow`
 transforms the operation to `inv(x)^-y` by default, where `-y` is positive.
 
+See also [`exp2`](@ref), [`<<`](@ref).
+
 # Examples
 ```jldoctest
 julia> 3^5
 243
 
-julia> A = [1 2; 3 4]
-2×2 Matrix{Int64}:
- 1  2
- 3  4
+julia> 3^-1  # uses Base.literal_pow
+0.3333333333333333
+
+julia> p = -1;
+
+julia> 3^p
+ERROR: DomainError with -1:
+Cannot raise an integer x to a negative power -1.
+[...]
+
+julia> 3.0^p
+0.3333333333333333
+
+julia> 10^19 > 0  # integer overflow
+false
 
-julia> A^3
-2×2 Matrix{Int64}:
- 37   54
- 81  118
+julia> big(10)^19 == 1e19
+true
 ```
 """
 ^(x::Number, y::Number) = ^(promote(x,y)...)
diff --git a/doc/src/base/numbers.md b/doc/src/base/numbers.md
index 8167650ac17d1..aad4e94901054 100644
--- a/doc/src/base/numbers.md
+++ b/doc/src/base/numbers.md
@@ -63,6 +63,8 @@ Core.Int64
 Core.UInt64
 Core.Int128
 Core.UInt128
+Base.Int
+Base.UInt
 Base.BigInt
 Base.Complex
 Base.Rational

From f8d59471e15f89cd0bdaedc76eb194d2175aa93e Mon Sep 17 00:00:00 2001
From: Aravindh Krishnamoorthy <aravindh.k@gmail.com>
Date: Mon, 12 Feb 2024 18:21:15 +0100
Subject: [PATCH 0907/1315] Documentation update for LinearAlgebra functions
 (#52934)

Documentation update for LinearAlgebra functions, see #52725

- [X] Pivoting strategies
    - [X] `NoPivot`
    - [X] `RowNonZero`
    - [X] `ColumnNorm`
    - [X] `RowMaximum`

 - [X] Matrix multiplication functions
    - [X] `copy_transpose!`
    - [X] `copyto!`

Note: `copyto!` is not mentioned in the original issue. However, it is
felt that `copy_transpose!` without the complementing `copyto!` will be
confusing for a reader.

- [X] Exceptions
    - [X] `LAPACKException`
    - [X] `RankDeficientException`

Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
Co-authored-by: Daniel Karrasch <daniel.karrasch@posteo.de>
---
 stdlib/LinearAlgebra/docs/src/index.md    | 35 +++++++++++++++-
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 45 ++++++++++++++++++++
 stdlib/LinearAlgebra/src/exceptions.jl    | 14 +++++++
 stdlib/LinearAlgebra/src/matmul.jl        | 47 +++++++++++++++++++--
 stdlib/LinearAlgebra/src/transpose.jl     | 50 ++++++++++++++++++-----
 stdlib/LinearAlgebra/test/matmul.jl       | 10 +++++
 stdlib/LinearAlgebra/test/runtests.jl     |  4 +-
 7 files changed, 188 insertions(+), 17 deletions(-)

diff --git a/stdlib/LinearAlgebra/docs/src/index.md b/stdlib/LinearAlgebra/docs/src/index.md
index 1d4c1f360feb6..da756f56e12b8 100644
--- a/stdlib/LinearAlgebra/docs/src/index.md
+++ b/stdlib/LinearAlgebra/docs/src/index.md
@@ -404,6 +404,35 @@ generally broadcasting over elements in the matrix representation fail because t
 be highly inefficient. For such use cases, consider computing the matrix representation
 up front and cache it for future reuse.
 
+## [Pivoting Strategies](@id man-linalg-pivoting-strategies)
+
+Several of Julia's [matrix factorizations](@ref man-linalg-factorizations) support
+[pivoting](https://en.wikipedia.org/wiki/Pivot_element), which can be used to improve their
+numerical stability. In fact, some matrix factorizations, such as the LU
+factorization, may fail without pivoting.
+
+In pivoting, first, a [pivot element](https://en.wikipedia.org/wiki/Pivot_element)
+with good numerical properties is chosen based on a pivoting strategy. Next, the rows and
+columns of the original matrix are permuted to bring the chosen element in place for
+subsequent computation. Furthermore, the process is repeated for each stage of the factorization.
+
+Consequently, besides the conventional matrix factors, the outputs of
+pivoted factorization schemes also include permutation matrices.
+
+In the following, the pivoting strategies implemented in Julia are briefly described. Note
+that not all matrix factorizations may support them. Consult the documentation of the
+respective [matrix factorization](@ref man-linalg-factorizations) for details on the
+supported pivoting strategies.
+
+See also [`LinearAlgebra.ZeroPivotException`](@ref).
+
+```@docs
+LinearAlgebra.NoPivot
+LinearAlgebra.RowNonZero
+LinearAlgebra.RowMaximum
+LinearAlgebra.ColumnNorm
+```
+
 ## Standard functions
 
 Linear algebra functions in Julia are largely implemented by calling functions from [LAPACK](https://www.netlib.org/lapack/).
@@ -418,6 +447,8 @@ Base.:/(::AbstractVecOrMat, ::AbstractVecOrMat)
 LinearAlgebra.SingularException
 LinearAlgebra.PosDefException
 LinearAlgebra.ZeroPivotException
+LinearAlgebra.RankDeficientException
+LinearAlgebra.LAPACKException
 LinearAlgebra.dot
 LinearAlgebra.dot(::Any, ::Any, ::Any)
 LinearAlgebra.cross
@@ -571,6 +602,8 @@ LinearAlgebra.checksquare
 LinearAlgebra.peakflops
 LinearAlgebra.hermitianpart
 LinearAlgebra.hermitianpart!
+LinearAlgebra.copy_adjoint!
+LinearAlgebra.copy_transpose!
 ```
 
 ## Low-level matrix operations
@@ -762,7 +795,7 @@ LinearAlgebra.BLAS.trsm!
 LinearAlgebra.BLAS.trsm
 ```
 
-## LAPACK functions
+## [LAPACK functions](@id man-linalg-lapack-functions)
 
 `LinearAlgebra.LAPACK` provides wrappers for some of the LAPACK functions for linear algebra.
  Those functions that overwrite one of the input arrays have names ending in `'!'`.
diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index be46a700ab44c..793775992fdea 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -78,6 +78,7 @@ export
     cholesky,
     cond,
     condskeel,
+    copy_adjoint!,
     copy_transpose!,
     copyto!,
     copytrito!,
@@ -190,10 +191,54 @@ abstract type Algorithm end
 struct DivideAndConquer <: Algorithm end
 struct QRIteration <: Algorithm end
 
+# Pivoting strategies for matrix factorization algorithms.
 abstract type PivotingStrategy end
+
+"""
+    NoPivot
+
+Pivoting is not performed. Matrix factorizations such as the LU factorization
+may fail without pivoting, and may also be numerically unstable for floating-point matrices in the face of roundoff error.
+This pivot strategy is mainly useful for pedagogical purposes.
+"""
 struct NoPivot <: PivotingStrategy end
+
+"""
+    RowNonZero
+
+First non-zero element in the remaining rows is chosen as the pivot element.
+
+Beware that for floating-point matrices, the resulting LU algorithm is numerically unstable — this strategy
+is mainly useful for comparison to hand calculations (which typically use this strategy) or for other
+algebraic types (e.g. rational numbers) not susceptible to roundoff errors.   Otherwise, the default
+`RowMaximum` pivoting strategy should be generally preferred in Gaussian elimination.
+
+Note that the [element type](@ref eltype) of the matrix must admit an [`iszero`](@ref)
+method.
+"""
 struct RowNonZero <: PivotingStrategy end
+
+"""
+    RowMaximum
+
+The maximum-magnitude element in the remaining rows is chosen as the pivot element.
+This is the default strategy for LU factorization of floating-point matrices, and is sometimes
+referred to as the "partial pivoting" algorithm.
+
+Note that the [element type](@ref eltype) of the matrix must admit an [`abs`](@ref) method,
+whose result type must admit a [`<`](@ref) method.
+"""
 struct RowMaximum <: PivotingStrategy end
+
+"""
+    ColumnNorm
+
+The column with the maximum norm is used for subsequent computation.  This
+is used for pivoted QR factorization.
+
+Note that the [element type](@ref eltype) of the matrix must admit [`norm`](@ref) and
+[`abs`](@ref) methods, whose respective result types must admit a [`<`](@ref) method.
+"""
 struct ColumnNorm <: PivotingStrategy end
 
 # Check that stride of matrix/vector is 1
diff --git a/stdlib/LinearAlgebra/src/exceptions.jl b/stdlib/LinearAlgebra/src/exceptions.jl
index 574decf79fc07..7791b1ddef416 100644
--- a/stdlib/LinearAlgebra/src/exceptions.jl
+++ b/stdlib/LinearAlgebra/src/exceptions.jl
@@ -6,6 +6,13 @@ export LAPACKException,
        RankDeficientException,
        ZeroPivotException
 
+"""
+    LAPACKException
+
+Generic LAPACK exception thrown either during direct calls to the [LAPACK functions](@ref man-linalg-lapack-functions)
+or during calls to other functions that use the LAPACK functions internally but lack specialized error handling. The `info` field
+contains additional information on the underlying error and depends on the LAPACK function that was invoked.
+"""
 struct LAPACKException <: Exception
     info::BlasInt
 end
@@ -41,6 +48,13 @@ function Base.showerror(io::IO, ex::PosDefException)
     print(io, "; Factorization failed.")
 end
 
+"""
+    RankDeficientException
+
+Exception thrown when the input matrix is [rank deficient](https://en.wikipedia.org/wiki/Rank_(linear_algebra)). Some
+linear algebra functions, such as the Cholesky decomposition, are only applicable to matrices that are not rank
+deficient. The `info` field indicates the computed rank of the matrix.
+"""
 struct RankDeficientException <: Exception
     info::BlasInt
 end
diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index c84a85ebc7c81..95a24b0d798ea 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -682,19 +682,60 @@ end
 
 lapack_size(t::AbstractChar, M::AbstractVecOrMat) = (size(M, t=='N' ? 1 : 2), size(M, t=='N' ? 2 : 1))
 
+"""
+    copyto!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
+            tM::AbstractChar,
+            M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B
+
+Efficiently copy elements of matrix `M` to `B` conditioned on the character
+parameter `tM` as follows:
+
+| `tM` | Destination | Source |
+| --- | :--- | :--- |
+| `'N'` | `B[ir_dest, jr_dest]` | `M[ir_src, jr_src]` |
+| `'T'` | `B[ir_dest, jr_dest]` | `transpose(M)[ir_src, jr_src]` |
+| `'C'` | `B[ir_dest, jr_dest]` | `adjoint(M)[ir_src, jr_src]` |
+
+The elements `B[ir_dest, jr_dest]` are overwritten. Furthermore, the index range
+parameters must satisfy `length(ir_dest) == length(ir_src)` and
+`length(jr_dest) == length(jr_src)`.
+
+See also [`copy_transpose!`](@ref) and [`copy_adjoint!`](@ref).
+"""
 function copyto!(B::AbstractVecOrMat, ir_dest::AbstractUnitRange{Int}, jr_dest::AbstractUnitRange{Int}, tM::AbstractChar, M::AbstractVecOrMat, ir_src::AbstractUnitRange{Int}, jr_src::AbstractUnitRange{Int})
     if tM == 'N'
         copyto!(B, ir_dest, jr_dest, M, ir_src, jr_src)
+    elseif tM == 'T'
+        copy_transpose!(B, ir_dest, jr_dest, M, jr_src, ir_src)
     else
-        LinearAlgebra.copy_transpose!(B, ir_dest, jr_dest, M, jr_src, ir_src)
-        tM == 'C' && conj!(@view B[ir_dest, jr_dest])
+        copy_adjoint!(B, ir_dest, jr_dest, M, jr_src, ir_src)
     end
     B
 end
 
+"""
+    copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
+                    tM::AbstractChar,
+                    M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B
+
+Efficiently copy elements of matrix `M` to `B` conditioned on the character
+parameter `tM` as follows:
+
+| `tM` | Destination | Source |
+| --- | :--- | :--- |
+| `'N'` | `B[ir_dest, jr_dest]` | `transpose(M)[jr_src, ir_src]` |
+| `'T'` | `B[ir_dest, jr_dest]` | `M[jr_src, ir_src]` |
+| `'C'` | `B[ir_dest, jr_dest]` | `conj(M)[jr_src, ir_src]` |
+
+The elements `B[ir_dest, jr_dest]` are overwritten. Furthermore, the index
+range parameters must satisfy `length(ir_dest) == length(jr_src)` and
+`length(jr_dest) == length(ir_src)`.
+
+See also [`copyto!`](@ref) and [`copy_adjoint!`](@ref).
+"""
 function copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange{Int}, jr_dest::AbstractUnitRange{Int}, tM::AbstractChar, M::AbstractVecOrMat, ir_src::AbstractUnitRange{Int}, jr_src::AbstractUnitRange{Int})
     if tM == 'N'
-        LinearAlgebra.copy_transpose!(B, ir_dest, jr_dest, M, ir_src, jr_src)
+        copy_transpose!(B, ir_dest, jr_dest, M, ir_src, jr_src)
     else
         copyto!(B, ir_dest, jr_dest, M, jr_src, ir_src)
         tM == 'C' && conj!(@view B[ir_dest, jr_dest])
diff --git a/stdlib/LinearAlgebra/src/transpose.jl b/stdlib/LinearAlgebra/src/transpose.jl
index afc3494fc9726..8aa04f7d34b48 100644
--- a/stdlib/LinearAlgebra/src/transpose.jl
+++ b/stdlib/LinearAlgebra/src/transpose.jl
@@ -178,8 +178,41 @@ copy(::Union{Transpose,Adjoint})
 Base.copy(A::TransposeAbsMat) = transpose!(similar(A.parent, reverse(axes(A.parent))), A.parent)
 Base.copy(A::AdjointAbsMat) = adjoint!(similar(A.parent, reverse(axes(A.parent))), A.parent)
 
-function copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
-                         A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int})
+"""
+    copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
+                    A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B
+
+Efficiently copy elements of matrix `A` to `B` with transposition as follows:
+
+    B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]
+
+The elements `B[ir_dest, jr_dest]` are overwritten. Furthermore,
+the index range parameters must satisfy `length(ir_dest) == length(jr_src)` and
+`length(jr_dest) == length(ir_src)`.
+"""
+copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
+                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) =
+    _copy_adjtrans!(B, ir_dest, jr_dest, A, ir_src, jr_src, transpose)
+
+"""
+    copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
+                    A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B
+
+Efficiently copy elements of matrix `A` to `B` with adjunction as follows:
+
+    B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]
+
+The elements `B[ir_dest, jr_dest]` are overwritten. Furthermore,
+the index range parameters must satisfy `length(ir_dest) == length(jr_src)` and
+`length(jr_dest) == length(ir_src)`.
+"""
+copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
+              A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) =
+    _copy_adjtrans!(B, ir_dest, jr_dest, A, ir_src, jr_src, adjoint)
+
+function _copy_adjtrans!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
+                         A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int},
+                         tfun::T) where {T}
     if length(ir_dest) != length(jr_src)
         throw(ArgumentError(LazyString("source and destination must have same size (got ",
                                    length(jr_src)," and ",length(ir_dest),")")))
@@ -194,7 +227,7 @@ function copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_de
     for jsrc in jr_src
         jdest = first(jr_dest)
         for isrc in ir_src
-            B[idest,jdest] = transpose(A[isrc,jsrc])
+            B[idest,jdest] = tfun(A[isrc,jsrc])
             jdest += step(jr_dest)
         end
         idest += step(ir_dest)
@@ -202,13 +235,10 @@ function copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_de
     return B
 end
 
-function copy_similar(A::AdjointAbsMat, ::Type{T}) where {T}
-    C = similar(A, T, size(A))
-    adjoint!(C, parent(A))
-end
-function copy_similar(A::TransposeAbsMat, ::Type{T}) where {T}
-    C = similar(A, T, size(A))
-    transpose!(C, parent(A))
+function copy_similar(A::AdjOrTransAbsMat, ::Type{T}) where {T}
+    Ap = parent(A)
+    f! = inplace_adj_or_trans(A)
+    return f!(similar(Ap, T, reverse(axes(Ap))), Ap)
 end
 
 function Base.copyto_unaliased!(deststyle::IndexStyle, dest::AbstractMatrix, srcstyle::IndexCartesian, src::AdjOrTransAbsMat)
diff --git a/stdlib/LinearAlgebra/test/matmul.jl b/stdlib/LinearAlgebra/test/matmul.jl
index 4b0181f079a6f..5bcbb99a314fd 100644
--- a/stdlib/LinearAlgebra/test/matmul.jl
+++ b/stdlib/LinearAlgebra/test/matmul.jl
@@ -873,6 +873,16 @@ end
     @test Xv1' * Xv3' ≈ XcXc
 end
 
+@testset "copyto! for matrices of matrices" begin
+    A = [randn(ComplexF64, 2,3) for _ in 1:2, _ in 1:3]
+    for (tfun, tM) in ((identity, 'N'), (transpose, 'T'), (adjoint, 'C'))
+        At = copy(tfun(A))
+        B = zero.(At)
+        copyto!(B, axes(B, 1), axes(B, 2), tM, A, axes(A, tM == 'N' ? 1 : 2), axes(A, tM == 'N' ? 2 : 1))
+        @test B == At
+    end
+end
+
 @testset "method ambiguity" begin
     # Ambiguity test is run inside a clean process.
     # https://github.com/JuliaLang/julia/issues/28804
diff --git a/stdlib/LinearAlgebra/test/runtests.jl b/stdlib/LinearAlgebra/test/runtests.jl
index 55bc119756ce8..d64da9899ca86 100644
--- a/stdlib/LinearAlgebra/test/runtests.jl
+++ b/stdlib/LinearAlgebra/test/runtests.jl
@@ -6,7 +6,5 @@ for file in readlines(joinpath(@__DIR__, "testgroups"))
 end
 
 @testset "Docstrings" begin
-    undoc = Docs.undocumented_names(LinearAlgebra)
-    @test_broken isempty(undoc)
-    @test undoc == [:ColumnNorm, :LAPACKException, :NoPivot, :RankDeficientException, :RowMaximum, :RowNonZero, :copy_transpose!]
+    @test isempty(Docs.undocumented_names(LinearAlgebra))
 end

From 81c652640ecfa5215781bf398bbf57b67ec3d616 Mon Sep 17 00:00:00 2001
From: Christian Guinard <28689358+christiangnrd@users.noreply.github.com>
Date: Mon, 12 Feb 2024 14:44:06 -0400
Subject: [PATCH 0908/1315] Fix typo in `Sys.total_memory` docstring. (#53301)

Fixes #53298.
---
 base/sysinfo.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 69ee93864aadc..97e5e2a71bcbc 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -358,7 +358,7 @@ free_memory() = ccall(:uv_get_available_memory, UInt64, ())
 
 Get the total memory in RAM (including that which is currently used) in bytes.
 This amount may be constrained, e.g., by Linux control groups. For the unconstrained
-amount, see `Sys.physical_memory()`.
+amount, see `Sys.total_physical_memory()`.
 """
 function total_memory()
     constrained = ccall(:uv_get_constrained_memory, UInt64, ())

From 56e193ea84f6d90d23b4231e56312af8eafcb6d4 Mon Sep 17 00:00:00 2001
From: Stefan Karpinski <stefan@karpinski.org>
Date: Mon, 12 Feb 2024 19:12:46 -0500
Subject: [PATCH 0909/1315] tempdir: error on non-directory result (#33593)

Potential more graceful handling of
https://github.com/JuliaLang/julia/issues/33382. I thought about
creating the directory if it doesn't exist, but that seems aa bit
questionable. Probably better to let the user know about the situation
in a clear way so they can mitigate it. An even better improvement would
be if we could tell them which environment variable to look at. I tried
setting `TEMP` in the environment on macOS but it didn't seem to have
any effect on the result.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 base/file.jl | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/base/file.jl b/base/file.jl
index e63ed67ae249b..6347f042e3422 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -480,13 +480,26 @@ function tempdir()
         rc = ccall(:uv_os_tmpdir, Cint, (Ptr{UInt8}, Ptr{Csize_t}), buf, sz)
         if rc == 0
             resize!(buf, sz[])
-            return String(buf)
+            break
         elseif rc == Base.UV_ENOBUFS
             resize!(buf, sz[] - 1)  # space for null-terminator implied by StringVector
         else
             uv_error("tempdir()", rc)
         end
     end
+    tempdir = String(buf)
+    try
+        s = stat(tempdir)
+        if !ispath(s)
+            @warn "tempdir path does not exist" tempdir
+        elseif !isdir(s)
+            @warn "tempdir path is not a directory" tempdir
+        end
+    catch ex
+        ex isa IOError || ex isa SystemError || rethrow()
+        @warn "accessing tempdir path failed" _exception=ex
+    end
+    return tempdir
 end
 
 """
@@ -504,13 +517,19 @@ function prepare_for_deletion(path::AbstractString)
         return
     end
 
-    try chmod(path, filemode(path) | 0o333)
-    catch; end
+    try
+        chmod(path, filemode(path) | 0o333)
+    catch ex
+        ex isa IOError || ex isa SystemError || rethrow()
+    end
     for (root, dirs, files) in walkdir(path; onerror=x->())
         for dir in dirs
             dpath = joinpath(root, dir)
-            try chmod(dpath, filemode(dpath) | 0o333)
-            catch; end
+            try
+                chmod(dpath, filemode(dpath) | 0o333)
+            catch ex
+                ex isa IOError || ex isa SystemError || rethrow()
+            end
         end
     end
 end

From e6992f74b003eead40d928a31e1c5baaba79f377 Mon Sep 17 00:00:00 2001
From: Michael Abbott <32575566+mcabbott@users.noreply.github.com>
Date: Mon, 12 Feb 2024 20:50:05 -0500
Subject: [PATCH 0910/1315] Add `Iterators.cycle(iter, n)` (#47354)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

At present `Iterators.repeated(iter, n)` is the lazy cousin of
`fill(iter, n)`, but there is no iterator for `repeat(iter, n)`. This PR
proposes that `Iterators.cycle(iter, n)` should fill that role.

This relates to the one-argument form in the same way as
`Iterators.repeated`. That is, `cycle(iter)` means `cycle(iter, Inf)` in
the same way that `repeated(iter)` means `repeated(iter, Inf)`... or
would be if Inf were an integer.

The implementation uses `flatten(repeated(xs, n))`. It could instead use
`take(cycle(xs), n * length(xs))` but that only works when the contents
has known length. `take(cycle...)` tends to be faster, perhaps it should
be used when possible? Some timing below. But perhaps this detail is a
secondary question.

<details>

```julia
julia> takecycle(x, n::Int) = Iterators.take(Iterators.cycle(x), n * length(x));

julia> flatrep(x, n::Int) = Iterators.flatten(Iterators.repeated(x, n));  # as in PR, first commit

julia> takecycle(1:10, 100) |> length
1000

julia> flatrep(1:10, 100) |> Base.haslength  # and won't be helped by 47353
false

julia> @btime collect(takecycle(1:10, 100));
  min 1.642 μs, mean 2.554 μs (1 allocation, 7.94 KiB)

julia> @btime collect(flatrep(1:10, 100));
  min 6.617 μs, mean 9.107 μs (6 allocations, 21.86 KiB)

julia> flatrep(Tuple(1:10), 100) |> Base.haslength  # behaves better with tuples, but not faster:
true

julia> @btime collect(takecycle($(Tuple(rand(10))), 100));
  min 1.100 μs, mean 1.977 μs (1 allocation, 7.94 KiB)

julia> @btime collect(flatrep($(Tuple(rand(10))), 100));
  min 10.458 μs, mean 11.220 μs (1 allocation, 7.94 KiB)
```

</details>
---
 NEWS.md           |  1 +
 base/iterators.jl | 29 +++++++++++++++++++++++++----
 test/iterators.jl | 16 ++++++++++++++++
 3 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 4ad8a9b761dda..fc3a2304ea72a 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -111,6 +111,7 @@ New library features
   automatically.
 * `@timed` now additionally returns the elapsed compilation and recompilation time ([#52889])
 * `filter` can now act on a `NamedTuple` ([#50795]).
+* `Iterators.cycle(iter, n)` runs over `iter` a fixed number of times, instead of forever ([#47354])
 * `zero(::AbstractArray)` now applies recursively, so `zero([[1,2],[3,4,5]])` now produces the additive identity `[[0,0],[0,0,0]]` rather than erroring ([#38064]).
 
 Standard library changes
diff --git a/base/iterators.jl b/base/iterators.jl
index b51920cdddb68..a0b3a6cd4672d 100644
--- a/base/iterators.jl
+++ b/base/iterators.jl
@@ -953,12 +953,17 @@ struct Cycle{I}
 end
 
 """
-    cycle(iter)
+    cycle(iter[, n::Int])
 
 An iterator that cycles through `iter` forever.
-If `iter` is empty, so is `cycle(iter)`.
+If `n` is specified, then it cycles through `iter` that many times.
+When `iter` is empty, so are `cycle(iter)` and `cycle(iter, n)`.
 
-See also: [`Iterators.repeated`](@ref), [`Base.repeat`](@ref).
+`Iterators.cycle(iter, n)` is the lazy equivalent of [`Base.repeat`](@ref)`(vector, n)`,
+while [`Iterators.repeated`](@ref)`(iter, n)` is the lazy [`Base.fill`](@ref)`(item, n)`.
+
+!!! compat "Julia 1.11"
+    The method `cycle(iter, n)` was added in Julia 1.11.
 
 # Examples
 ```jldoctest
@@ -967,9 +972,19 @@ julia> for (i, v) in enumerate(Iterators.cycle("hello"))
            i > 10 && break
        end
 hellohelloh
+
+julia> foreach(print, Iterators.cycle(['j', 'u', 'l', 'i', 'a'], 3))
+juliajuliajulia
+
+julia> repeat([1,2,3], 4) == collect(Iterators.cycle([1,2,3], 4))
+true
+
+julia> fill([1,2,3], 4) == collect(Iterators.repeated([1,2,3], 4))
+true
 ```
 """
 cycle(xs) = Cycle(xs)
+cycle(xs, n::Integer) = flatten(repeated(xs, n))
 
 eltype(::Type{Cycle{I}}) where {I} = eltype(I)
 IteratorEltype(::Type{Cycle{I}}) where {I} = IteratorEltype(I)
@@ -1000,7 +1015,7 @@ repeated(x) = Repeated(x)
 An iterator that generates the value `x` forever. If `n` is specified, generates `x` that
 many times (equivalent to `take(repeated(x), n)`).
 
-See also: [`Iterators.cycle`](@ref), [`Base.repeat`](@ref).
+See also [`fill`](@ref Base.fill), and compare [`Iterators.cycle`](@ref).
 
 # Examples
 ```jldoctest
@@ -1012,6 +1027,12 @@ julia> collect(a)
  [1 2]
  [1 2]
  [1 2]
+
+julia> ans == fill([1 2], 4)
+true
+
+julia> Iterators.cycle([1 2], 4) |> collect |> println
+[1, 2, 1, 2, 1, 2, 1, 2]
 ```
 """
 repeated(x, n::Integer) = take(repeated(x), Int(n))
diff --git a/test/iterators.jl b/test/iterators.jl
index 6fd308a31d746..3616a17b31d31 100644
--- a/test/iterators.jl
+++ b/test/iterators.jl
@@ -254,6 +254,22 @@ let i = 0
     @test !Base.isdone(cycle(0:3), 1)
 end
 
+@testset "cycle(iter, n)"  begin
+    @test collect(cycle(0:3, 2)) == [0, 1, 2, 3, 0, 1, 2, 3]
+    @test collect(cycle(Iterators.filter(iseven, 1:4), 2)) == [2, 4, 2, 4]
+    @test collect(take(cycle(countfrom(11), 3), 4)) == 11:14
+
+    @test isempty(cycle(1:0)) == isempty(cycle(1:0, 3)) == true
+    @test isempty(cycle(1:5, 0))
+    @test isempty(cycle(Iterators.filter(iseven, 1:4), 0))
+
+    @test eltype(cycle(0:3, 2)) === Int
+    @test Base.IteratorEltype(cycle(0:3, 2)) == Base.HasEltype()
+
+    Base.haslength(cycle(0:3, 2)) == false  # but not sure we should test these
+    Base.IteratorSize(cycle(0:3, 2)) == Base.SizeUnknown()
+end
+
 # repeated
 # --------
 let i = 0

From dba215f5be2515f1ed99c8cdc69637c2ff90ca91 Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Mon, 12 Feb 2024 21:11:58 -0500
Subject: [PATCH 0911/1315] Strengthen docs for `reinterpret` (#52157)

As suggested in #52135, I've added some to the `reinterpret` docs.
---
 base/essentials.jl       |  7 ++++++-
 base/reinterpretarray.jl | 17 +++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/base/essentials.jl b/base/essentials.jl
index 9c156fb1b8f6d..fdc66e94d1a00 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -673,7 +673,7 @@ Change the type-interpretation of the binary data in the isbits value `x`
 to that of the isbits type `Out`.
 The size (ignoring padding) of `Out` has to be the same as that of the type of `x`.
 For example, `reinterpret(Float32, UInt32(7))` interprets the 4 bytes corresponding to `UInt32(7)` as a
-[`Float32`](@ref).
+[`Float32`](@ref). Note that `reinterpret(In, reinterpret(Out, x)) === x`
 
 ```jldoctest
 julia> reinterpret(Float32, UInt32(7))
@@ -689,11 +689,16 @@ julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
 (0x0301, 0x02)
 ```
 
+!!! note
+
+    The treatment of padding differs from reinterpret(::DataType, ::AbstractArray).
+
 !!! warning
 
     Use caution if some combinations of bits in `Out` are not considered valid and would
     otherwise be prevented by the type's constructors and methods. Unexpected behavior
     may result without additional validation.
+
 """
 function reinterpret(::Type{Out}, x) where {Out}
     if isprimitivetype(Out) && isprimitivetype(typeof(x))
diff --git a/base/reinterpretarray.jl b/base/reinterpretarray.jl
index 23bfb38a28654..ff674690a5c66 100644
--- a/base/reinterpretarray.jl
+++ b/base/reinterpretarray.jl
@@ -46,6 +46,23 @@ struct ReinterpretArray{T,N,S,A<:AbstractArray{S},IsReshaped} <: AbstractArray{T
      3 + 4im
      5 + 6im
     ```
+
+    If the location of padding bits does not line up between `T` and `eltype(A)`, the resulting array will be
+    read-only or write-only, to prevent invalid bits from being written to or read from, respectively.
+
+    ```jldoctest
+    julia> a = reinterpret(Tuple{UInt8, UInt32}, UInt32[1, 2])
+    1-element reinterpret(Tuple{UInt8, UInt32}, ::Vector{UInt32}):
+     (0x01, 0x00000002)
+
+    julia> a[1] = 3
+    ERROR: Padding of type Tuple{UInt8, UInt32} is not compatible with type UInt32.
+
+    julia> b = reinterpret(UInt32, Tuple{UInt8, UInt32}[(0x01, 0x00000002)]); # showing will error
+
+    julia> b[1]
+    ERROR: Padding of type UInt32 is not compatible with type Tuple{UInt8, UInt32}.
+    ```
     """
     function reinterpret(::Type{T}, a::A) where {T,N,S,A<:AbstractArray{S, N}}
         function thrownonint(S::Type, T::Type, dim)

From e8bf9bc3e0dcbc92c29aa3cf9cf641c36359772a Mon Sep 17 00:00:00 2001
From: Philip Tellis <philip.tellis@gmail.com>
Date: Mon, 12 Feb 2024 21:12:56 -0500
Subject: [PATCH 0912/1315] Add more @showarg examples (#52410)

Adds a few more examples to show how `@showarg` works with literals and
interpolated string expressions.
---
 doc/src/manual/metaprogramming.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/doc/src/manual/metaprogramming.md b/doc/src/manual/metaprogramming.md
index b1623ff8591b0..b619021fcef92 100644
--- a/doc/src/manual/metaprogramming.md
+++ b/doc/src/manual/metaprogramming.md
@@ -629,6 +629,15 @@ julia> @showarg(1+1)
 
 julia> @showarg(println("Yo!"))
 :(println("Yo!"))
+
+julia> @showarg(1)        # Numeric literal
+1
+
+julia> @showarg("Yo!")    # String literal
+"Yo!"
+
+julia> @showarg("Yo! $("hello")")    # String with interpolation is an Expr rather than a String
+:("Yo! $("hello")")
 ```
 
 In addition to the given argument list, every macro is passed extra arguments named `__source__` and `__module__`.

From 75cb2a51ec3e6c6819ed9ae4c9c432ffe39c28e4 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Tue, 13 Feb 2024 10:16:16 +0800
Subject: [PATCH 0913/1315] eliminate the dead `iterate` branch in
 `_unsafe_(get)setindex!`. (#52809)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It's sad that compiler can't do this automatically.
Some benchmark with `setindex!`:
```julia
julia> a = zeros(Int, 100, 100);
julia> @btime $a[:,:] = $(1:10000);
  1.340 μs (0 allocations: 0 bytes) #master: 3.350 μs (0 allocations: 0 bytes)

julia> @btime $a[:,:] = $(view(LinearIndices(a), 1:100, 1:100));
  10.000 μs (0 allocations: 0 bytes) #master: 11.000 μs (0 allocations: 0 bytes)
```

BTW optimization for `FastSubArray` introduced in #45371 still work
after this change as the parent array might have their own `copyto!`
optimization.
---
 base/multidimensional.jl | 43 ++++++++++++++++++++++++++++------------
 test/abstractarray.jl    | 18 +++++++++++++++++
 2 files changed, 48 insertions(+), 13 deletions(-)

diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 4b462c8e2079b..ed0a48b4f23cf 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -879,6 +879,28 @@ _maybe_linear_logical_index(::IndexLinear, A, i) = LogicalIndex{Int}(i)
 uncolon(::Tuple{}) = Slice(OneTo(1))
 uncolon(inds::Tuple) = Slice(inds[1])
 
+"""
+    _prechecked_iterate(iter[, state])
+
+Internal function used to eliminate the dead branch in `iterate`.
+Fallback to `iterate` by default, but optimized for indices type in `Base`.
+"""
+@propagate_inbounds _prechecked_iterate(iter) = iterate(iter)
+@propagate_inbounds _prechecked_iterate(iter, state) = iterate(iter, state)
+
+_prechecked_iterate(iter::AbstractUnitRange, i = first(iter)) = i, convert(eltype(iter), i + step(iter))
+_prechecked_iterate(iter::LinearIndices, i = first(iter)) = i, i + 1
+_prechecked_iterate(iter::CartesianIndices) = first(iter), first(iter)
+function _prechecked_iterate(iter::CartesianIndices, i)
+    i′ = IteratorsMD.inc(i.I, iter.indices)
+    return i′, i′
+end
+_prechecked_iterate(iter::SCartesianIndices2) = first(iter), first(iter)
+function _prechecked_iterate(iter::SCartesianIndices2{K}, (;i, j)) where {K}
+    I = i < K ? SCartesianIndex2{K}(i + 1, j) : SCartesianIndex2{K}(1, j + 1)
+    return I, I
+end
+
 ### From abstractarray.jl: Internal multidimensional indexing definitions ###
 getindex(x::Union{Number,AbstractChar}, ::CartesianIndex{0}) = x
 getindex(t::Tuple,  i::CartesianIndex{1}) = getindex(t, i.I[1])
@@ -910,14 +932,11 @@ function _generate_unsafe_getindex!_body(N::Int)
     quote
         @inline
         D = eachindex(dest)
-        Dy = iterate(D)
+        Dy = _prechecked_iterate(D)
         @inbounds @nloops $N j d->I[d] begin
-            # This condition is never hit, but at the moment
-            # the optimizer is not clever enough to split the union without it
-            Dy === nothing && return dest
-            (idx, state) = Dy
+            (idx, state) = Dy::NTuple{2,Any}
             dest[idx] = @ncall $N getindex src j
-            Dy = iterate(D, state)
+            Dy = _prechecked_iterate(D, state)
         end
         return dest
     end
@@ -953,14 +972,12 @@ function _generate_unsafe_setindex!_body(N::Int)
         @nexprs $N d->(I_d = unalias(A, I[d]))
         idxlens = @ncall $N index_lengths I
         @ncall $N setindex_shape_check x′ (d->idxlens[d])
-        Xy = iterate(x′)
+        X = eachindex(x′)
+        Xy = _prechecked_iterate(X)
         @inbounds @nloops $N i d->I_d begin
-            # This is never reached, but serves as an assumption for
-            # the optimizer that it does not need to emit error paths
-            Xy === nothing && break
-            (val, state) = Xy
-            @ncall $N setindex! A val i
-            Xy = iterate(x′, state)
+            (idx, state) = Xy::NTuple{2,Any}
+            @ncall $N setindex! A x′[idx] i
+            Xy = _prechecked_iterate(X, state)
         end
         A
     end
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index c3409a4a059fb..a327c011e8fb7 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1961,3 +1961,21 @@ end
     @test zero([[2,2], [3,3,3]]) isa Vector{Vector{Int}}
     @test zero([[2,2], [3,3,3]]) == [[0,0], [0, 0, 0]]
 end
+
+@testset "`_prechecked_iterate` optimization" begin
+    function test_prechecked_iterate(iter)
+        Js = Base._prechecked_iterate(iter)
+        for I in iter
+            J, s = Js::NTuple{2,Any}
+            @test J === I
+            Js = Base._prechecked_iterate(iter, s)
+        end
+    end
+    test_prechecked_iterate(1:10)
+    test_prechecked_iterate(Base.OneTo(10))
+    test_prechecked_iterate(CartesianIndices((3, 3)))
+    test_prechecked_iterate(CartesianIndices(()))
+    test_prechecked_iterate(LinearIndices((3, 3)))
+    test_prechecked_iterate(LinearIndices(()))
+    test_prechecked_iterate(Base.SCartesianIndices2{3}(1:3))
+end

From 1fd09817690582728d246130ce7748a4a4b75ab2 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Mon, 12 Feb 2024 21:17:37 -0500
Subject: [PATCH 0914/1315] Trim hash map size when pruning type caches
 (#53296)

This doesn't make much of a difference for the smaller type caches (many
of which have exactly 1 element actually), but it does offer up to ~75%
savings (8192 -> 2048, 4096 -> 512) for some of the larger type caches
in our sysimage.
---
 src/jltypes.c    | 1 +
 src/staticdata.c | 8 +++++++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/jltypes.c b/src/jltypes.c
index bf7561fc29e1b..9dac534259f73 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -1154,6 +1154,7 @@ static void cache_insert_type_set(jl_datatype_t *val, uint_t hv)
 
 jl_svec_t *cache_rehash_set(jl_svec_t *a, size_t newsz)
 {
+    newsz = newsz ? next_power_of_two(newsz) : 0;
     jl_value_t **ol = jl_svec_data(a);
     size_t sz = jl_svec_len(a);
     while (1) {
diff --git a/src/staticdata.c b/src/staticdata.c
index 0d38dddb79aaf..62c0b27cb8eab 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -2305,6 +2305,7 @@ static void jl_reinit_ccallable(arraylist_t *ccallable_list, char *base, void *s
 static jl_svec_t *jl_prune_type_cache_hash(jl_svec_t *cache) JL_GC_DISABLED
 {
     size_t l = jl_svec_len(cache), i;
+    size_t sz = 0;
     if (l == 0)
         return cache;
     for (i = 0; i < l; i++) {
@@ -2313,11 +2314,16 @@ static jl_svec_t *jl_prune_type_cache_hash(jl_svec_t *cache) JL_GC_DISABLED
             continue;
         if (ptrhash_get(&serialization_order, ti) == HT_NOTFOUND)
             jl_svecset(cache, i, jl_nothing);
+        else
+            sz += 1;
     }
+    if (sz < HT_N_INLINE)
+        sz = HT_N_INLINE;
+
     void *idx = ptrhash_get(&serialization_order, cache);
     assert(idx != HT_NOTFOUND && idx != (void*)(uintptr_t)-1);
     assert(serialization_queue.items[(char*)idx - 1 - (char*)HT_NOTFOUND] == cache);
-    cache = cache_rehash_set(cache, l);
+    cache = cache_rehash_set(cache, sz);
     // redirect all references to the old cache to relocate to the new cache object
     ptrhash_put(&serialization_order, cache, idx);
     serialization_queue.items[(char*)idx - 1 - (char*)HT_NOTFOUND] = cache;

From 54e97283976c1b25337bded69ce42483872fb42b Mon Sep 17 00:00:00 2001
From: Sebastien Marie <8948701+semarie@users.noreply.github.com>
Date: Tue, 13 Feb 2024 03:18:25 +0100
Subject: [PATCH 0915/1315] llvmunwind: use LLVM_PATH instead of
 LLVM_CONFIG_PATH variable (#53304)

with llvm-16, the `--src-root` argument of llvm-config has been removed.
see
https://github.com/llvm/llvm-project/commit/c061892fcdbdfe46884c54a7a7bfe6df54d1df12

but `llvmunwind` was using it for configuration.
so prefer to use `LLVM_PATH` and explicitly pass the llvm source
directory.
---
 deps/unwind.mk | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/deps/unwind.mk b/deps/unwind.mk
index 66607845428c4..f8e8260b431fa 100644
--- a/deps/unwind.mk
+++ b/deps/unwind.mk
@@ -73,7 +73,10 @@ check-unwind: $(BUILDDIR)/libunwind-$(UNWIND_VER)/build-checked
 
 ## LLVM libunwind ##
 
-LLVMUNWIND_OPTS := $(CMAKE_COMMON) -DCMAKE_BUILD_TYPE=MinSizeRel -DLIBUNWIND_ENABLE_PEDANTIC=OFF -DLLVM_CONFIG_PATH=$(build_depsbindir)/llvm-config
+LLVMUNWIND_OPTS := $(CMAKE_COMMON) \
+	-DCMAKE_BUILD_TYPE=MinSizeRel \
+	-DLIBUNWIND_ENABLE_PEDANTIC=OFF \
+	-DLLVM_PATH=$(SRCCACHE)/$(LLVM_SRC_DIR)/llvm
 
 $(SRCCACHE)/llvmunwind-$(LLVMUNWIND_VER).tar.xz: | $(SRCCACHE)
 	$(JLDOWNLOAD) $@ https://github.com/llvm/llvm-project/releases/download/llvmorg-$(LLVMUNWIND_VER)/libunwind-$(LLVMUNWIND_VER).src.tar.xz

From 69f16a2316407e41fd726633a9197da7fd121ea5 Mon Sep 17 00:00:00 2001
From: AllHailTheSheep <58122014+AllHailTheSheep@users.noreply.github.com>
Date: Mon, 12 Feb 2024 21:19:55 -0500
Subject: [PATCH 0916/1315] Update logging.jl to add docstrings for exported
 symbols (#53299)

This is a part of issue #52725.
---
 base/logging.jl | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/base/logging.jl b/base/logging.jl
index 436d00335acf3..d0f612c31eeae 100644
--- a/base/logging.jl
+++ b/base/logging.jl
@@ -132,6 +132,11 @@ isless(a::LogLevel, b::LogLevel) = isless(a.level, b.level)
 -(level::LogLevel, inc::Integer) = LogLevel(level.level-inc)
 convert(::Type{LogLevel}, level::Integer) = LogLevel(level)
 
+"""
+    BelowMinLevel
+
+Alias for [`LogLevel(-1_000_001)`](@ref LogLevel).
+"""
 const BelowMinLevel = LogLevel(-1000001)
 """
     Debug
@@ -157,6 +162,11 @@ const Warn          = LogLevel(    1000)
 Alias for [`LogLevel(2000)`](@ref LogLevel).
 """
 const Error         = LogLevel(    2000)
+"""
+    AboveMaxLevel
+
+Alias for [`LogLevel(1_000_001)`](@ref LogLevel).
+"""
 const AboveMaxLevel = LogLevel( 1000001)
 
 # Global log limiting mechanism for super fast but inflexible global log limiting.

From eabdd9c6bac55cc156bc0929944702cc0db6f72d Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 8 Feb 2024 01:24:27 +0800
Subject: [PATCH 0917/1315] Turn terminfo_data.jl into a self-updating quine

Is it brilliant or cursed? That's up for debate, but I think it's neat.

This change also revealed some minor discrepancies between the NCurses
source (which we use nwo) and the processed source I originally
used (from some python package? I can't quite recall).

All of the minor discrepancies are cosmetic, with the exception of:
- memory_below moving down by one, and
- backspace_with_bs changing to backspace_if_not_bs

Since we are now using NCurses's source directly, I'm inclined to trust
these changes.
---
 base/terminfo_data.jl | 88 +++++++++++++++++++++++++++++++++++++++----
 1 file changed, 80 insertions(+), 8 deletions(-)

diff --git a/base/terminfo_data.jl b/base/terminfo_data.jl
index 38c058f414f07..5f803710642c3 100644
--- a/base/terminfo_data.jl
+++ b/base/terminfo_data.jl
@@ -1,5 +1,20 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+# Updating this listing is fairly easy, assuming existence of a unix system,
+# posix shell, and `awk`. Just update the version string in the commented out
+# `NCURSES_VERSION` variable, and run this file. This works because this file is
+# a bit of a quine.
+
+#=
+awk '/^#=run/{flag=1;next}/=#/{flag=0}flag{gsub(/__FILE__/,"\"'"$0"'\"");print}' "$0" | \
+  julia --startup-file=no -E 'readchomp("/dev/fd/0") |> Meta.parse |> eval' && echo "Done"; exit
+=#
+
+#=run
+begin
+const NCURSES_VERSION = "6.3"
+=#
+
 """
     struct TermCapability
 
@@ -22,6 +37,63 @@ struct TermCapability
     description::String
 end
 
+#=run
+using Downloads
+
+standard_caps = IOBuffer()
+
+Downloads.download("https://raw.githubusercontent.com/mirror/ncurses/v$NCURSES_VERSION/include/Caps", standard_caps)
+
+const TERM_FLAGS = Tuple{String, String, String}[]
+const TERM_NUMBERS = Tuple{String, String, String}[]
+const TERM_STRINGS = Tuple{String, String, String}[]
+
+for line in eachline(seekstart(standard_caps))
+    startswith(line, '#') && continue
+    components = split(line, '\t', keepempty=false)
+    if length(components) ∉ 8:9
+        @warn "Malformed line: $(sprint(show, line))"
+        continue
+    end
+    name, shortcode, type, _, _, _, _, description, _... = components
+    caplist = if type == "bool" TERM_FLAGS
+    elseif type == "num" TERM_NUMBERS
+    elseif type == "str" TERM_STRINGS
+    else
+        @warn "Unrecognised capability type: $type"
+        continue
+    end
+    push!(caplist, (name, shortcode, description))
+end
+
+const SENTINEL = "\n## GENERATED CODE BEYOND THIS POINT ##"
+const PREAMBLE = readuntil(__FILE__, SENTINEL, keep=true)
+
+out = IOBuffer()
+write(out, PREAMBLE, "\n\n# Terminfo Capabilities as of NCurses $NCURSES_VERSION\n")
+
+for (ftype, list) in [("flag", TERM_FLAGS), ("number", TERM_NUMBERS), ("string", TERM_STRINGS)]
+    print(out, "\n\"\"\"\n\
+          Ordered list of known terminal capability $ftype fields, as of NCurses $NCURSES_VERSION.\n\
+          \"\"\"\n\
+          const TERM_$(uppercase(ftype))S = [")
+    namepad = maximum(textwidth, getindex.(list, 1)) + 1
+    codepad = maximum(textwidth, getindex.(list, 2)) + 1
+    for (name, shortcode, description) in list
+        print(out, "\n    TermCapability(:", shortcode, ',', ' '^(codepad - textwidth(shortcode)),
+              ':', name, ',', ' '^(namepad - textwidth(name)),
+              '"', escape_string(description), "\"),")
+    end
+    println(out, "\n]")
+end
+
+open(io -> write(io, seekstart(out)), __FILE__, "w")
+
+end
+=#
+
+## GENERATED CODE BEYOND THIS POINT ##
+
 # Terminfo Capabilities as of NCurses 6.3
 
 """
@@ -39,8 +111,8 @@ const TERM_FLAGS = [
     TermCapability(:km,    :has_meta_key,             "Has a meta key (i.e., sets 8th-bit)"),
     TermCapability(:hs,    :has_status_line,          "has extra status line"),
     TermCapability(:in,    :insert_null_glitch,       "insert mode distinguishes nulls"),
-    TermCapability(:db,    :memory_below,             "display may be retained below the screen"),
     TermCapability(:da,    :memory_above,             "display may be retained above the screen"),
+    TermCapability(:db,    :memory_below,             "display may be retained below the screen"),
     TermCapability(:mir,   :move_insert_mode,         "safe to move while in insert mode"),
     TermCapability(:msgr,  :move_standout_mode,       "safe to move while in standout mode"),
     TermCapability(:os,    :over_strike,              "terminal can overstrike"),
@@ -69,7 +141,7 @@ const TERM_FLAGS = [
     TermCapability(:OTns,  :crt_no_scrolling,         "crt cannot scroll"),
     TermCapability(:OTnc,  :no_correctly_working_cr,  "no way to go to start of line"),
     TermCapability(:OTMT,  :gnu_has_meta_key,         "has meta key"),
-    TermCapability(:OTNL,  :linefeed_is_newline,      "move down with \n"),
+    TermCapability(:OTNL,  :linefeed_is_newline,      "move down with \\n"),
     TermCapability(:OTpt,  :has_hardware_tabs,        "has 8-char tabs invoked with ^I"),
     TermCapability(:OTxr,  :return_does_clr_eol,      "return clears the line"),
 ]
@@ -394,13 +466,13 @@ const TERM_STRINGS = [
     TermCapability(:kf63,     :key_f63,                   "F63 function key"),
     TermCapability(:el1,      :clr_bol,                   "Clear to beginning of line"),
     TermCapability(:mgc,      :clear_margins,             "clear right and left soft margins"),
-    TermCapability(:smgl,     :set_left_margin,           "set left soft margin at current column. (ML is not in BSD termcap)."),
+    TermCapability(:smgl,     :set_left_margin,           "set left soft margin at current column."),
     TermCapability(:smgr,     :set_right_margin,          "set right soft margin at current column"),
     TermCapability(:fln,      :label_format,              "label format"),
     TermCapability(:sclk,     :set_clock,                 "set clock, #1 hrs #2 mins #3 secs"),
     TermCapability(:dclk,     :display_clock,             "display clock"),
     TermCapability(:rmclk,    :remove_clock,              "remove clock"),
-    TermCapability(:cwin,     :create_window,             "define a window #1 from #2, #3 to #4, #5"),
+    TermCapability(:cwin,     :create_window,             "define a window #1 from #2,#3 to #4,#5"),
     TermCapability(:wingo,    :goto_window,               "go to window #1"),
     TermCapability(:hup,      :hangup,                    "hang-up phone"),
     TermCapability(:dial,     :dial_phone,                "dial number #1"),
@@ -422,8 +494,8 @@ const TERM_STRINGS = [
     TermCapability(:u9,       :user9,                     "User string #9"),
     TermCapability(:op,       :orig_pair,                 "Set default pair to its original value"),
     TermCapability(:oc,       :orig_colors,               "Set all color pairs to the original ones"),
-    TermCapability(:initc,    :initialize_color,          "Initialize color #1 to (#2, #3, #4)"),
-    TermCapability(:initp,    :initialize_pair,           "Initialize color pair #1 to fg=(#2, #3, #4), bg=(#5,#6,#7)"),
+    TermCapability(:initc,    :initialize_color,          "initialize color #1 to (#2,#3,#4)"),
+    TermCapability(:initp,    :initialize_pair,           "Initialize color pair #1 to fg=(#2,#3,#4), bg=(#5,#6,#7)"),
     TermCapability(:scp,      :set_color_pair,            "Set current color pair to #1"),
     TermCapability(:setf,     :set_foreground,            "Set foreground color #1"),
     TermCapability(:setb,     :set_background,            "Set background color #1"),
@@ -491,7 +563,7 @@ const TERM_STRINGS = [
     TermCapability(:s1ds,     :set1_des_seq,              "Shift to codeset 1"),
     TermCapability(:s2ds,     :set2_des_seq,              "Shift to codeset 2"),
     TermCapability(:s3ds,     :set3_des_seq,              "Shift to codeset 3"),
-    TermCapability(:smglr,    :set_lr_margin,             "Set both left and right margins to #1, #2. (ML is not in BSD termcap)."),
+    TermCapability(:smglr,    :set_lr_margin,             "Set both left and right margins to #1, #2.  (ML is not in BSD termcap)."),
     TermCapability(:smgtb,    :set_tb_margin,             "Sets both top and bottom margins to #1, #2"),
     TermCapability(:birep,    :bit_image_repeat,          "Repeat bit image cell #1 #2 times"),
     TermCapability(:binel,    :bit_image_newline,         "Move to next row of the bit image"),
@@ -520,7 +592,7 @@ const TERM_STRINGS = [
     TermCapability(:OTi2,     :termcap_init2,             "secondary initialization string"),
     TermCapability(:OTrs,     :termcap_reset,             "terminal reset string"),
     TermCapability(:OTnl,     :linefeed_if_not_lf,        "use to move down"),
-    TermCapability(:OTbs,     :backspaces_with_bs,        "uses ^H to move left"),
+    TermCapability(:OTbc,     :backspace_if_not_bs,       "move left, if not ^H"),
     TermCapability(:OTko,     :other_non_function_keys,   "list of self-mapped keycaps"),
     TermCapability(:OTma,     :arrow_key_map,             "map motion-keys for vi version 2"),
     TermCapability(:OTG2,     :acs_ulcorner,              "single upper left"),

From f49c193acdd2e98687e1a10f381893ba0853821a Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 8 Feb 2024 02:20:47 +0800
Subject: [PATCH 0918/1315] Switch the field ordering of TermCapability

The preferred code to use is the "long" symbol, for readability when
used. I think it makes sense to have it as the first field to reflect
that. While we're at it, we may as well update the field names to better
indicate that "short" is the actual capname, and just call "long"
"name".
---
 base/terminfo.jl      |   12 +-
 base/terminfo_data.jl | 1006 ++++++++++++++++++++---------------------
 2 files changed, 509 insertions(+), 509 deletions(-)

diff --git a/base/terminfo.jl b/base/terminfo.jl
index 3792e35e0fd8d..ffbfe8acac976 100644
--- a/base/terminfo.jl
+++ b/base/terminfo.jl
@@ -177,17 +177,17 @@ function TermInfo(raw::TermInfoRaw)
     strings = Dict{Symbol, String}()
     extensions = nothing
     for (flag, value) in zip(TERM_FLAGS, raw.flags)
-        flags[flag.short] = value
-        flags[flag.long] = value
+        flags[flag.capname] = value
+        flags[flag.name] = value
     end
     for (num, value) in zip(TERM_NUMBERS, raw.numbers)
-        numbers[num.short] = Int(value)
-        numbers[num.long] = Int(value)
+        numbers[num.capname] = Int(value)
+        numbers[num.name] = Int(value)
     end
     for (str, value) in zip(TERM_STRINGS, raw.strings)
         if !isnothing(value)
-            strings[str.short] = value
-            strings[str.long] = value
+            strings[str.capname] = value
+            strings[str.name] = value
         end
     end
     if !isnothing(raw.extended)
diff --git a/base/terminfo_data.jl b/base/terminfo_data.jl
index 5f803710642c3..39d1ef1d4d86e 100644
--- a/base/terminfo_data.jl
+++ b/base/terminfo_data.jl
@@ -25,15 +25,15 @@ Specification of a single terminal capability.
 
 # Fields
 
-- `short::Symbol`: The *Cap-name* of the capability
-- `long::Symbol`: The name of the terminfo capability variable
+- `name::Symbol`: The name of the terminfo capability variable
+- `capname::Symbol`: The *Cap-name* of the capability
 - `description::String`: A description of the purpose of the capability
 
 See also: `TermInfo`, `TERM_FLAGS`, `TERM_NUMBERS`, and `TERM_STRINGS`.
 """
 struct TermCapability
-    short::Symbol
-    long::Symbol
+    name::Symbol
+    capname::Symbol
     description::String
 end
 
@@ -80,8 +80,8 @@ for (ftype, list) in [("flag", TERM_FLAGS), ("number", TERM_NUMBERS), ("string",
     namepad = maximum(textwidth, getindex.(list, 1)) + 1
     codepad = maximum(textwidth, getindex.(list, 2)) + 1
     for (name, shortcode, description) in list
-        print(out, "\n    TermCapability(:", shortcode, ',', ' '^(codepad - textwidth(shortcode)),
-              ':', name, ',', ' '^(namepad - textwidth(name)),
+        print(out, "\n    TermCapability(:", name, ',', ' '^(namepad - textwidth(name)),
+              ':', shortcode, ',', ' '^(codepad - textwidth(shortcode)),
               '"', escape_string(description), "\"),")
     end
     println(out, "\n]")
@@ -100,513 +100,513 @@ end
 Ordered list of known terminal capability flag fields, as of NCurses 6.3.
 """
 const TERM_FLAGS = [
-    TermCapability(:bw,    :auto_left_margin,         "cub1 wraps from column 0 to last column"),
-    TermCapability(:am,    :auto_right_margin,        "terminal has automatic margins"),
-    TermCapability(:xsb,   :no_esc_ctlc,              "beehive (f1=escape, f2=ctrl C)"),
-    TermCapability(:xhp,   :ceol_standout_glitch,     "standout not erased by overwriting (hp)"),
-    TermCapability(:xenl,  :eat_newline_glitch,       "newline ignored after 80 cols (concept)"),
-    TermCapability(:eo,    :erase_overstrike,         "can erase overstrikes with a blank"),
-    TermCapability(:gn,    :generic_type,             "generic line type"),
-    TermCapability(:hc,    :hard_copy,                "hardcopy terminal"),
-    TermCapability(:km,    :has_meta_key,             "Has a meta key (i.e., sets 8th-bit)"),
-    TermCapability(:hs,    :has_status_line,          "has extra status line"),
-    TermCapability(:in,    :insert_null_glitch,       "insert mode distinguishes nulls"),
-    TermCapability(:da,    :memory_above,             "display may be retained above the screen"),
-    TermCapability(:db,    :memory_below,             "display may be retained below the screen"),
-    TermCapability(:mir,   :move_insert_mode,         "safe to move while in insert mode"),
-    TermCapability(:msgr,  :move_standout_mode,       "safe to move while in standout mode"),
-    TermCapability(:os,    :over_strike,              "terminal can overstrike"),
-    TermCapability(:eslok, :status_line_esc_ok,       "escape can be used on the status line"),
-    TermCapability(:xt,    :dest_tabs_magic_smso,     "tabs destructive, magic so char (t1061)"),
-    TermCapability(:hz,    :tilde_glitch,             "cannot print ~'s (Hazeltine)"),
-    TermCapability(:ul,    :transparent_underline,    "underline character overstrikes"),
-    TermCapability(:xon,   :xon_xoff,                 "terminal uses xon/xoff handshaking"),
-    TermCapability(:nxon,  :needs_xon_xoff,           "padding will not work, xon/xoff required"),
-    TermCapability(:mc5i,  :prtr_silent,              "printer will not echo on screen"),
-    TermCapability(:chts,  :hard_cursor,              "cursor is hard to see"),
-    TermCapability(:nrrmc, :non_rev_rmcup,            "smcup does not reverse rmcup"),
-    TermCapability(:npc,   :no_pad_char,              "pad character does not exist"),
-    TermCapability(:ndscr, :non_dest_scroll_region,   "scrolling region is non-destructive"),
-    TermCapability(:ccc,   :can_change,               "terminal can re-define existing colors"),
-    TermCapability(:bce,   :back_color_erase,         "screen erased with background color"),
-    TermCapability(:hls,   :hue_lightness_saturation, "terminal uses only HLS color notation (Tektronix)"),
-    TermCapability(:xhpa,  :col_addr_glitch,          "only positive motion for hpa/mhpa caps"),
-    TermCapability(:crxm,  :cr_cancels_micro_mode,    "using cr turns off micro mode"),
-    TermCapability(:daisy, :has_print_wheel,          "printer needs operator to change character set"),
-    TermCapability(:xvpa,  :row_addr_glitch,          "only positive motion for vpa/mvpa caps"),
-    TermCapability(:sam,   :semi_auto_right_margin,   "printing in last column causes cr"),
-    TermCapability(:cpix,  :cpi_changes_res,          "changing character pitch changes resolution"),
-    TermCapability(:lpix,  :lpi_changes_res,          "changing line pitch changes resolution"),
-    TermCapability(:OTbs,  :backspaces_with_bs,       "uses ^H to move left"),
-    TermCapability(:OTns,  :crt_no_scrolling,         "crt cannot scroll"),
-    TermCapability(:OTnc,  :no_correctly_working_cr,  "no way to go to start of line"),
-    TermCapability(:OTMT,  :gnu_has_meta_key,         "has meta key"),
-    TermCapability(:OTNL,  :linefeed_is_newline,      "move down with \\n"),
-    TermCapability(:OTpt,  :has_hardware_tabs,        "has 8-char tabs invoked with ^I"),
-    TermCapability(:OTxr,  :return_does_clr_eol,      "return clears the line"),
+    TermCapability(:auto_left_margin,         :bw,    "cub1 wraps from column 0 to last column"),
+    TermCapability(:auto_right_margin,        :am,    "terminal has automatic margins"),
+    TermCapability(:no_esc_ctlc,              :xsb,   "beehive (f1=escape, f2=ctrl C)"),
+    TermCapability(:ceol_standout_glitch,     :xhp,   "standout not erased by overwriting (hp)"),
+    TermCapability(:eat_newline_glitch,       :xenl,  "newline ignored after 80 cols (concept)"),
+    TermCapability(:erase_overstrike,         :eo,    "can erase overstrikes with a blank"),
+    TermCapability(:generic_type,             :gn,    "generic line type"),
+    TermCapability(:hard_copy,                :hc,    "hardcopy terminal"),
+    TermCapability(:has_meta_key,             :km,    "Has a meta key (i.e., sets 8th-bit)"),
+    TermCapability(:has_status_line,          :hs,    "has extra status line"),
+    TermCapability(:insert_null_glitch,       :in,    "insert mode distinguishes nulls"),
+    TermCapability(:memory_above,             :da,    "display may be retained above the screen"),
+    TermCapability(:memory_below,             :db,    "display may be retained below the screen"),
+    TermCapability(:move_insert_mode,         :mir,   "safe to move while in insert mode"),
+    TermCapability(:move_standout_mode,       :msgr,  "safe to move while in standout mode"),
+    TermCapability(:over_strike,              :os,    "terminal can overstrike"),
+    TermCapability(:status_line_esc_ok,       :eslok, "escape can be used on the status line"),
+    TermCapability(:dest_tabs_magic_smso,     :xt,    "tabs destructive, magic so char (t1061)"),
+    TermCapability(:tilde_glitch,             :hz,    "cannot print ~'s (Hazeltine)"),
+    TermCapability(:transparent_underline,    :ul,    "underline character overstrikes"),
+    TermCapability(:xon_xoff,                 :xon,   "terminal uses xon/xoff handshaking"),
+    TermCapability(:needs_xon_xoff,           :nxon,  "padding will not work, xon/xoff required"),
+    TermCapability(:prtr_silent,              :mc5i,  "printer will not echo on screen"),
+    TermCapability(:hard_cursor,              :chts,  "cursor is hard to see"),
+    TermCapability(:non_rev_rmcup,            :nrrmc, "smcup does not reverse rmcup"),
+    TermCapability(:no_pad_char,              :npc,   "pad character does not exist"),
+    TermCapability(:non_dest_scroll_region,   :ndscr, "scrolling region is non-destructive"),
+    TermCapability(:can_change,               :ccc,   "terminal can re-define existing colors"),
+    TermCapability(:back_color_erase,         :bce,   "screen erased with background color"),
+    TermCapability(:hue_lightness_saturation, :hls,   "terminal uses only HLS color notation (Tektronix)"),
+    TermCapability(:col_addr_glitch,          :xhpa,  "only positive motion for hpa/mhpa caps"),
+    TermCapability(:cr_cancels_micro_mode,    :crxm,  "using cr turns off micro mode"),
+    TermCapability(:has_print_wheel,          :daisy, "printer needs operator to change character set"),
+    TermCapability(:row_addr_glitch,          :xvpa,  "only positive motion for vpa/mvpa caps"),
+    TermCapability(:semi_auto_right_margin,   :sam,   "printing in last column causes cr"),
+    TermCapability(:cpi_changes_res,          :cpix,  "changing character pitch changes resolution"),
+    TermCapability(:lpi_changes_res,          :lpix,  "changing line pitch changes resolution"),
+    TermCapability(:backspaces_with_bs,       :OTbs,  "uses ^H to move left"),
+    TermCapability(:crt_no_scrolling,         :OTns,  "crt cannot scroll"),
+    TermCapability(:no_correctly_working_cr,  :OTnc,  "no way to go to start of line"),
+    TermCapability(:gnu_has_meta_key,         :OTMT,  "has meta key"),
+    TermCapability(:linefeed_is_newline,      :OTNL,  "move down with \\n"),
+    TermCapability(:has_hardware_tabs,        :OTpt,  "has 8-char tabs invoked with ^I"),
+    TermCapability(:return_does_clr_eol,      :OTxr,  "return clears the line"),
 ]
 
 """
 Ordered list of known terminal capability number fields, as of NCurses 6.3.
 """
 const TERM_NUMBERS = [
-    TermCapability(:cols,   :columns,                 "number of columns in a line"),
-    TermCapability(:it,     :init_tabs,               "tabs initially every # spaces"),
-    TermCapability(:lines,  :lines,                   "number of lines on screen or page"),
-    TermCapability(:lm,     :lines_of_memory,         "lines of memory if > line. 0 means varies"),
-    TermCapability(:xmc,    :magic_cookie_glitch,     "number of blank characters left by smso or rmso"),
-    TermCapability(:pb,     :padding_baud_rate,       "lowest baud rate where padding needed"),
-    TermCapability(:vt,     :virtual_terminal,        "virtual terminal number (CB/unix)"),
-    TermCapability(:wsl,    :width_status_line,       "number of columns in status line"),
-    TermCapability(:nlab,   :num_labels,              "number of labels on screen"),
-    TermCapability(:lh,     :label_height,            "rows in each label"),
-    TermCapability(:lw,     :label_width,             "columns in each label"),
-    TermCapability(:ma,     :max_attributes,          "maximum combined attributes terminal can handle"),
-    TermCapability(:wnum,   :maximum_windows,         "maximum number of definable windows"),
-    TermCapability(:colors, :max_colors,              "maximum number of colors on screen"),
-    TermCapability(:pairs,  :max_pairs,               "maximum number of color-pairs on the screen"),
-    TermCapability(:ncv,    :no_color_video,          "video attributes that cannot be used with colors"),
-    TermCapability(:bufsz,  :buffer_capacity,         "numbers of bytes buffered before printing"),
-    TermCapability(:spinv,  :dot_vert_spacing,        "spacing of pins vertically in pins per inch"),
-    TermCapability(:spinh,  :dot_horz_spacing,        "spacing of dots horizontally in dots per inch"),
-    TermCapability(:maddr,  :max_micro_address,       "maximum value in micro_..._address"),
-    TermCapability(:mjump,  :max_micro_jump,          "maximum value in parm_..._micro"),
-    TermCapability(:mcs,    :micro_col_size,          "character step size when in micro mode"),
-    TermCapability(:mls,    :micro_line_size,         "line step size when in micro mode"),
-    TermCapability(:npins,  :number_of_pins,          "numbers of pins in print-head"),
-    TermCapability(:orc,    :output_res_char,         "horizontal resolution in units per line"),
-    TermCapability(:orl,    :output_res_line,         "vertical resolution in units per line"),
-    TermCapability(:orhi,   :output_res_horz_inch,    "horizontal resolution in units per inch"),
-    TermCapability(:orvi,   :output_res_vert_inch,    "vertical resolution in units per inch"),
-    TermCapability(:cps,    :print_rate,              "print rate in characters per second"),
-    TermCapability(:widcs,  :wide_char_size,          "character step size when in double wide mode"),
-    TermCapability(:btns,   :buttons,                 "number of buttons on mouse"),
-    TermCapability(:bitwin, :bit_image_entwining,     "number of passes for each bit-image row"),
-    TermCapability(:bitype, :bit_image_type,          "type of bit-image device"),
-    TermCapability(:OTug,   :magic_cookie_glitch_ul,  "number of blanks left by ul"),
-    TermCapability(:OTdC,   :carriage_return_delay,   "pad needed for CR"),
-    TermCapability(:OTdN,   :new_line_delay,          "pad needed for LF"),
-    TermCapability(:OTdB,   :backspace_delay,         "padding required for ^H"),
-    TermCapability(:OTdT,   :horizontal_tab_delay,    "padding required for ^I"),
-    TermCapability(:OTkn,   :number_of_function_keys, "count of function keys"),
+    TermCapability(:columns,                 :cols,   "number of columns in a line"),
+    TermCapability(:init_tabs,               :it,     "tabs initially every # spaces"),
+    TermCapability(:lines,                   :lines,  "number of lines on screen or page"),
+    TermCapability(:lines_of_memory,         :lm,     "lines of memory if > line. 0 means varies"),
+    TermCapability(:magic_cookie_glitch,     :xmc,    "number of blank characters left by smso or rmso"),
+    TermCapability(:padding_baud_rate,       :pb,     "lowest baud rate where padding needed"),
+    TermCapability(:virtual_terminal,        :vt,     "virtual terminal number (CB/unix)"),
+    TermCapability(:width_status_line,       :wsl,    "number of columns in status line"),
+    TermCapability(:num_labels,              :nlab,   "number of labels on screen"),
+    TermCapability(:label_height,            :lh,     "rows in each label"),
+    TermCapability(:label_width,             :lw,     "columns in each label"),
+    TermCapability(:max_attributes,          :ma,     "maximum combined attributes terminal can handle"),
+    TermCapability(:maximum_windows,         :wnum,   "maximum number of definable windows"),
+    TermCapability(:max_colors,              :colors, "maximum number of colors on screen"),
+    TermCapability(:max_pairs,               :pairs,  "maximum number of color-pairs on the screen"),
+    TermCapability(:no_color_video,          :ncv,    "video attributes that cannot be used with colors"),
+    TermCapability(:buffer_capacity,         :bufsz,  "numbers of bytes buffered before printing"),
+    TermCapability(:dot_vert_spacing,        :spinv,  "spacing of pins vertically in pins per inch"),
+    TermCapability(:dot_horz_spacing,        :spinh,  "spacing of dots horizontally in dots per inch"),
+    TermCapability(:max_micro_address,       :maddr,  "maximum value in micro_..._address"),
+    TermCapability(:max_micro_jump,          :mjump,  "maximum value in parm_..._micro"),
+    TermCapability(:micro_col_size,          :mcs,    "character step size when in micro mode"),
+    TermCapability(:micro_line_size,         :mls,    "line step size when in micro mode"),
+    TermCapability(:number_of_pins,          :npins,  "numbers of pins in print-head"),
+    TermCapability(:output_res_char,         :orc,    "horizontal resolution in units per line"),
+    TermCapability(:output_res_line,         :orl,    "vertical resolution in units per line"),
+    TermCapability(:output_res_horz_inch,    :orhi,   "horizontal resolution in units per inch"),
+    TermCapability(:output_res_vert_inch,    :orvi,   "vertical resolution in units per inch"),
+    TermCapability(:print_rate,              :cps,    "print rate in characters per second"),
+    TermCapability(:wide_char_size,          :widcs,  "character step size when in double wide mode"),
+    TermCapability(:buttons,                 :btns,   "number of buttons on mouse"),
+    TermCapability(:bit_image_entwining,     :bitwin, "number of passes for each bit-image row"),
+    TermCapability(:bit_image_type,          :bitype, "type of bit-image device"),
+    TermCapability(:magic_cookie_glitch_ul,  :OTug,   "number of blanks left by ul"),
+    TermCapability(:carriage_return_delay,   :OTdC,   "pad needed for CR"),
+    TermCapability(:new_line_delay,          :OTdN,   "pad needed for LF"),
+    TermCapability(:backspace_delay,         :OTdB,   "padding required for ^H"),
+    TermCapability(:horizontal_tab_delay,    :OTdT,   "padding required for ^I"),
+    TermCapability(:number_of_function_keys, :OTkn,   "count of function keys"),
 ]
 
 """
 Ordered list of known terminal capability string fields, as of NCurses 6.3.
 """
 const TERM_STRINGS = [
-    TermCapability(:cbt,      :back_tab,                  "back tab (P)"),
-    TermCapability(:bel,      :bell,                      "audible signal (bell) (P)"),
-    TermCapability(:cr,       :carriage_return,           "carriage return (P*) (P*)"),
-    TermCapability(:csr,      :change_scroll_region,      "change region to line #1 to line #2 (P)"),
-    TermCapability(:tbc,      :clear_all_tabs,            "clear all tab stops (P)"),
-    TermCapability(:clear,    :clear_screen,              "clear screen and home cursor (P*)"),
-    TermCapability(:el,       :clr_eol,                   "clear to end of line (P)"),
-    TermCapability(:ed,       :clr_eos,                   "clear to end of screen (P*)"),
-    TermCapability(:hpa,      :column_address,            "horizontal position #1, absolute (P)"),
-    TermCapability(:cmdch,    :command_character,         "terminal settable cmd character in prototype !?"),
-    TermCapability(:cup,      :cursor_address,            "move to row #1 columns #2"),
-    TermCapability(:cud1,     :cursor_down,               "down one line"),
-    TermCapability(:home,     :cursor_home,               "home cursor (if no cup)"),
-    TermCapability(:civis,    :cursor_invisible,          "make cursor invisible"),
-    TermCapability(:cub1,     :cursor_left,               "move left one space"),
-    TermCapability(:mrcup,    :cursor_mem_address,        "memory relative cursor addressing, move to row #1 columns #2"),
-    TermCapability(:cnorm,    :cursor_normal,             "make cursor appear normal (undo civis/cvvis)"),
-    TermCapability(:cuf1,     :cursor_right,              "non-destructive space (move right one space)"),
-    TermCapability(:ll,       :cursor_to_ll,              "last line, first column (if no cup)"),
-    TermCapability(:cuu1,     :cursor_up,                 "up one line"),
-    TermCapability(:cvvis,    :cursor_visible,            "make cursor very visible"),
-    TermCapability(:dch1,     :delete_character,          "delete character (P*)"),
-    TermCapability(:dl1,      :delete_line,               "delete line (P*)"),
-    TermCapability(:dsl,      :dis_status_line,           "disable status line"),
-    TermCapability(:hd,       :down_half_line,            "half a line down"),
-    TermCapability(:smacs,    :enter_alt_charset_mode,    "start alternate character set (P)"),
-    TermCapability(:blink,    :enter_blink_mode,          "turn on blinking"),
-    TermCapability(:bold,     :enter_bold_mode,           "turn on bold (extra bright) mode"),
-    TermCapability(:smcup,    :enter_ca_mode,             "string to start programs using cup"),
-    TermCapability(:smdc,     :enter_delete_mode,         "enter delete mode"),
-    TermCapability(:dim,      :enter_dim_mode,            "turn on half-bright mode"),
-    TermCapability(:smir,     :enter_insert_mode,         "enter insert mode"),
-    TermCapability(:invis,    :enter_secure_mode,         "turn on blank mode (characters invisible)"),
-    TermCapability(:prot,     :enter_protected_mode,      "turn on protected mode"),
-    TermCapability(:rev,      :enter_reverse_mode,        "turn on reverse video mode"),
-    TermCapability(:smso,     :enter_standout_mode,       "begin standout mode"),
-    TermCapability(:smul,     :enter_underline_mode,      "begin underline mode"),
-    TermCapability(:ech,      :erase_chars,               "erase #1 characters (P)"),
-    TermCapability(:rmacs,    :exit_alt_charset_mode,     "end alternate character set (P)"),
-    TermCapability(:sgr0,     :exit_attribute_mode,       "turn off all attributes"),
-    TermCapability(:rmcup,    :exit_ca_mode,              "strings to end programs using cup"),
-    TermCapability(:rmdc,     :exit_delete_mode,          "end delete mode"),
-    TermCapability(:rmir,     :exit_insert_mode,          "exit insert mode"),
-    TermCapability(:rmso,     :exit_standout_mode,        "exit standout mode"),
-    TermCapability(:rmul,     :exit_underline_mode,       "exit underline mode"),
-    TermCapability(:flash,    :flash_screen,              "visible bell (may not move cursor)"),
-    TermCapability(:ff,       :form_feed,                 "hardcopy terminal page eject (P*)"),
-    TermCapability(:fsl,      :from_status_line,          "return from status line"),
-    TermCapability(:is1,      :init_1string,              "initialization string"),
-    TermCapability(:is2,      :init_2string,              "initialization string"),
-    TermCapability(:is3,      :init_3string,              "initialization string"),
-    TermCapability(:if,       :init_file,                 "name of initialization file"),
-    TermCapability(:ich1,     :insert_character,          "insert character (P)"),
-    TermCapability(:il1,      :insert_line,               "insert line (P*)"),
-    TermCapability(:ip,       :insert_padding,            "insert padding after inserted character"),
-    TermCapability(:kbs,      :key_backspace,             "backspace key"),
-    TermCapability(:ktbc,     :key_catab,                 "clear-all-tabs key"),
-    TermCapability(:kclr,     :key_clear,                 "clear-screen or erase key"),
-    TermCapability(:kctab,    :key_ctab,                  "clear-tab key"),
-    TermCapability(:kdch1,    :key_dc,                    "delete-character key"),
-    TermCapability(:kdl1,     :key_dl,                    "delete-line key"),
-    TermCapability(:kcud1,    :key_down,                  "down-arrow key"),
-    TermCapability(:krmir,    :key_eic,                   "sent by rmir or smir in insert mode"),
-    TermCapability(:kel,      :key_eol,                   "clear-to-end-of-line key"),
-    TermCapability(:ked,      :key_eos,                   "clear-to-end-of-screen key"),
-    TermCapability(:kf0,      :key_f0,                    "F0 function key"),
-    TermCapability(:kf1,      :key_f1,                    "F1 function key"),
-    TermCapability(:kf10,     :key_f10,                   "F10 function key"),
-    TermCapability(:kf2,      :key_f2,                    "F2 function key"),
-    TermCapability(:kf3,      :key_f3,                    "F3 function key"),
-    TermCapability(:kf4,      :key_f4,                    "F4 function key"),
-    TermCapability(:kf5,      :key_f5,                    "F5 function key"),
-    TermCapability(:kf6,      :key_f6,                    "F6 function key"),
-    TermCapability(:kf7,      :key_f7,                    "F7 function key"),
-    TermCapability(:kf8,      :key_f8,                    "F8 function key"),
-    TermCapability(:kf9,      :key_f9,                    "F9 function key"),
-    TermCapability(:khome,    :key_home,                  "home key"),
-    TermCapability(:kich1,    :key_ic,                    "insert-character key"),
-    TermCapability(:kil1,     :key_il,                    "insert-line key"),
-    TermCapability(:kcub1,    :key_left,                  "left-arrow key"),
-    TermCapability(:kll,      :key_ll,                    "lower-left key (home down)"),
-    TermCapability(:knp,      :key_npage,                 "next-page key"),
-    TermCapability(:kpp,      :key_ppage,                 "previous-page key"),
-    TermCapability(:kcuf1,    :key_right,                 "right-arrow key"),
-    TermCapability(:kind,     :key_sf,                    "scroll-forward key"),
-    TermCapability(:kri,      :key_sr,                    "scroll-backward key"),
-    TermCapability(:khts,     :key_stab,                  "set-tab key"),
-    TermCapability(:kcuu1,    :key_up,                    "up-arrow key"),
-    TermCapability(:rmkx,     :keypad_local,              "leave 'keyboard_transmit' mode"),
-    TermCapability(:smkx,     :keypad_xmit,               "enter 'keyboard_transmit' mode"),
-    TermCapability(:lf0,      :lab_f0,                    "label on function key f0 if not f0"),
-    TermCapability(:lf1,      :lab_f1,                    "label on function key f1 if not f1"),
-    TermCapability(:lf10,     :lab_f10,                   "label on function key f10 if not f10"),
-    TermCapability(:lf2,      :lab_f2,                    "label on function key f2 if not f2"),
-    TermCapability(:lf3,      :lab_f3,                    "label on function key f3 if not f3"),
-    TermCapability(:lf4,      :lab_f4,                    "label on function key f4 if not f4"),
-    TermCapability(:lf5,      :lab_f5,                    "label on function key f5 if not f5"),
-    TermCapability(:lf6,      :lab_f6,                    "label on function key f6 if not f6"),
-    TermCapability(:lf7,      :lab_f7,                    "label on function key f7 if not f7"),
-    TermCapability(:lf8,      :lab_f8,                    "label on function key f8 if not f8"),
-    TermCapability(:lf9,      :lab_f9,                    "label on function key f9 if not f9"),
-    TermCapability(:rmm,      :meta_off,                  "turn off meta mode"),
-    TermCapability(:smm,      :meta_on,                   "turn on meta mode (8th-bit on)"),
-    TermCapability(:nel,      :newline,                   "newline (behave like cr followed by lf)"),
-    TermCapability(:pad,      :pad_char,                  "padding char (instead of null)"),
-    TermCapability(:dch,      :parm_dch,                  "delete #1 characters (P*)"),
-    TermCapability(:dl,       :parm_delete_line,          "delete #1 lines (P*)"),
-    TermCapability(:cud,      :parm_down_cursor,          "down #1 lines (P*)"),
-    TermCapability(:ich,      :parm_ich,                  "insert #1 characters (P*)"),
-    TermCapability(:indn,     :parm_index,                "scroll forward #1 lines (P)"),
-    TermCapability(:il,       :parm_insert_line,          "insert #1 lines (P*)"),
-    TermCapability(:cub,      :parm_left_cursor,          "move #1 characters to the left (P)"),
-    TermCapability(:cuf,      :parm_right_cursor,         "move #1 characters to the right (P*)"),
-    TermCapability(:rin,      :parm_rindex,               "scroll back #1 lines (P)"),
-    TermCapability(:cuu,      :parm_up_cursor,            "up #1 lines (P*)"),
-    TermCapability(:pfkey,    :pkey_key,                  "program function key #1 to type string #2"),
-    TermCapability(:pfloc,    :pkey_local,                "program function key #1 to execute string #2"),
-    TermCapability(:pfx,      :pkey_xmit,                 "program function key #1 to transmit string #2"),
-    TermCapability(:mc0,      :print_screen,              "print contents of screen"),
-    TermCapability(:mc4,      :prtr_off,                  "turn off printer"),
-    TermCapability(:mc5,      :prtr_on,                   "turn on printer"),
-    TermCapability(:rep,      :repeat_char,               "repeat char #1 #2 times (P*)"),
-    TermCapability(:rs1,      :reset_1string,             "reset string"),
-    TermCapability(:rs2,      :reset_2string,             "reset string"),
-    TermCapability(:rs3,      :reset_3string,             "reset string"),
-    TermCapability(:rf,       :reset_file,                "name of reset file"),
-    TermCapability(:rc,       :restore_cursor,            "restore cursor to position of last save_cursor"),
-    TermCapability(:vpa,      :row_address,               "vertical position #1 absolute (P)"),
-    TermCapability(:sc,       :save_cursor,               "save current cursor position (P)"),
-    TermCapability(:ind,      :scroll_forward,            "scroll text up (P)"),
-    TermCapability(:ri,       :scroll_reverse,            "scroll text down (P)"),
-    TermCapability(:sgr,      :set_attributes,            "define video attributes #1-#9 (PG9)"),
-    TermCapability(:hts,      :set_tab,                   "set a tab in every row, current columns"),
-    TermCapability(:wind,     :set_window,                "current window is lines #1-#2 cols #3-#4"),
-    TermCapability(:ht,       :tab,                       "tab to next 8-space hardware tab stop"),
-    TermCapability(:tsl,      :to_status_line,            "move to status line, column #1"),
-    TermCapability(:uc,       :underline_char,            "underline char and move past it"),
-    TermCapability(:hu,       :up_half_line,              "half a line up"),
-    TermCapability(:iprog,    :init_prog,                 "path name of program for initialization"),
-    TermCapability(:ka1,      :key_a1,                    "upper left of keypad"),
-    TermCapability(:ka3,      :key_a3,                    "upper right of keypad"),
-    TermCapability(:kb2,      :key_b2,                    "center of keypad"),
-    TermCapability(:kc1,      :key_c1,                    "lower left of keypad"),
-    TermCapability(:kc3,      :key_c3,                    "lower right of keypad"),
-    TermCapability(:mc5p,     :prtr_non,                  "turn on printer for #1 bytes"),
-    TermCapability(:rmp,      :char_padding,              "like ip but when in insert mode"),
-    TermCapability(:acsc,     :acs_chars,                 "graphics charset pairs, based on vt100"),
-    TermCapability(:pln,      :plab_norm,                 "program label #1 to show string #2"),
-    TermCapability(:kcbt,     :key_btab,                  "back-tab key"),
-    TermCapability(:smxon,    :enter_xon_mode,            "turn on xon/xoff handshaking"),
-    TermCapability(:rmxon,    :exit_xon_mode,             "turn off xon/xoff handshaking"),
-    TermCapability(:smam,     :enter_am_mode,             "turn on automatic margins"),
-    TermCapability(:rmam,     :exit_am_mode,              "turn off automatic margins"),
-    TermCapability(:xonc,     :xon_character,             "XON character"),
-    TermCapability(:xoffc,    :xoff_character,            "XOFF character"),
-    TermCapability(:enacs,    :ena_acs,                   "enable alternate char set"),
-    TermCapability(:smln,     :label_on,                  "turn on soft labels"),
-    TermCapability(:rmln,     :label_off,                 "turn off soft labels"),
-    TermCapability(:kbeg,     :key_beg,                   "begin key"),
-    TermCapability(:kcan,     :key_cancel,                "cancel key"),
-    TermCapability(:kclo,     :key_close,                 "close key"),
-    TermCapability(:kcmd,     :key_command,               "command key"),
-    TermCapability(:kcpy,     :key_copy,                  "copy key"),
-    TermCapability(:kcrt,     :key_create,                "create key"),
-    TermCapability(:kend,     :key_end,                   "end key"),
-    TermCapability(:kent,     :key_enter,                 "enter/send key"),
-    TermCapability(:kext,     :key_exit,                  "exit key"),
-    TermCapability(:kfnd,     :key_find,                  "find key"),
-    TermCapability(:khlp,     :key_help,                  "help key"),
-    TermCapability(:kmrk,     :key_mark,                  "mark key"),
-    TermCapability(:kmsg,     :key_message,               "message key"),
-    TermCapability(:kmov,     :key_move,                  "move key"),
-    TermCapability(:knxt,     :key_next,                  "next key"),
-    TermCapability(:kopn,     :key_open,                  "open key"),
-    TermCapability(:kopt,     :key_options,               "options key"),
-    TermCapability(:kprv,     :key_previous,              "previous key"),
-    TermCapability(:kprt,     :key_print,                 "print key"),
-    TermCapability(:krdo,     :key_redo,                  "redo key"),
-    TermCapability(:kref,     :key_reference,             "reference key"),
-    TermCapability(:krfr,     :key_refresh,               "refresh key"),
-    TermCapability(:krpl,     :key_replace,               "replace key"),
-    TermCapability(:krst,     :key_restart,               "restart key"),
-    TermCapability(:kres,     :key_resume,                "resume key"),
-    TermCapability(:ksav,     :key_save,                  "save key"),
-    TermCapability(:kspd,     :key_suspend,               "suspend key"),
-    TermCapability(:kund,     :key_undo,                  "undo key"),
-    TermCapability(:kBEG,     :key_sbeg,                  "shifted begin key"),
-    TermCapability(:kCAN,     :key_scancel,               "shifted cancel key"),
-    TermCapability(:kCMD,     :key_scommand,              "shifted command key"),
-    TermCapability(:kCPY,     :key_scopy,                 "shifted copy key"),
-    TermCapability(:kCRT,     :key_screate,               "shifted create key"),
-    TermCapability(:kDC,      :key_sdc,                   "shifted delete-character key"),
-    TermCapability(:kDL,      :key_sdl,                   "shifted delete-line key"),
-    TermCapability(:kslt,     :key_select,                "select key"),
-    TermCapability(:kEND,     :key_send,                  "shifted end key"),
-    TermCapability(:kEOL,     :key_seol,                  "shifted clear-to-end-of-line key"),
-    TermCapability(:kEXT,     :key_sexit,                 "shifted exit key"),
-    TermCapability(:kFND,     :key_sfind,                 "shifted find key"),
-    TermCapability(:kHLP,     :key_shelp,                 "shifted help key"),
-    TermCapability(:kHOM,     :key_shome,                 "shifted home key"),
-    TermCapability(:kIC,      :key_sic,                   "shifted insert-character key"),
-    TermCapability(:kLFT,     :key_sleft,                 "shifted left-arrow key"),
-    TermCapability(:kMSG,     :key_smessage,              "shifted message key"),
-    TermCapability(:kMOV,     :key_smove,                 "shifted move key"),
-    TermCapability(:kNXT,     :key_snext,                 "shifted next key"),
-    TermCapability(:kOPT,     :key_soptions,              "shifted options key"),
-    TermCapability(:kPRV,     :key_sprevious,             "shifted previous key"),
-    TermCapability(:kPRT,     :key_sprint,                "shifted print key"),
-    TermCapability(:kRDO,     :key_sredo,                 "shifted redo key"),
-    TermCapability(:kRPL,     :key_sreplace,              "shifted replace key"),
-    TermCapability(:kRIT,     :key_sright,                "shifted right-arrow key"),
-    TermCapability(:kRES,     :key_srsume,                "shifted resume key"),
-    TermCapability(:kSAV,     :key_ssave,                 "shifted save key"),
-    TermCapability(:kSPD,     :key_ssuspend,              "shifted suspend key"),
-    TermCapability(:kUND,     :key_sundo,                 "shifted undo key"),
-    TermCapability(:rfi,      :req_for_input,             "send next input char (for ptys)"),
-    TermCapability(:kf11,     :key_f11,                   "F11 function key"),
-    TermCapability(:kf12,     :key_f12,                   "F12 function key"),
-    TermCapability(:kf13,     :key_f13,                   "F13 function key"),
-    TermCapability(:kf14,     :key_f14,                   "F14 function key"),
-    TermCapability(:kf15,     :key_f15,                   "F15 function key"),
-    TermCapability(:kf16,     :key_f16,                   "F16 function key"),
-    TermCapability(:kf17,     :key_f17,                   "F17 function key"),
-    TermCapability(:kf18,     :key_f18,                   "F18 function key"),
-    TermCapability(:kf19,     :key_f19,                   "F19 function key"),
-    TermCapability(:kf20,     :key_f20,                   "F20 function key"),
-    TermCapability(:kf21,     :key_f21,                   "F21 function key"),
-    TermCapability(:kf22,     :key_f22,                   "F22 function key"),
-    TermCapability(:kf23,     :key_f23,                   "F23 function key"),
-    TermCapability(:kf24,     :key_f24,                   "F24 function key"),
-    TermCapability(:kf25,     :key_f25,                   "F25 function key"),
-    TermCapability(:kf26,     :key_f26,                   "F26 function key"),
-    TermCapability(:kf27,     :key_f27,                   "F27 function key"),
-    TermCapability(:kf28,     :key_f28,                   "F28 function key"),
-    TermCapability(:kf29,     :key_f29,                   "F29 function key"),
-    TermCapability(:kf30,     :key_f30,                   "F30 function key"),
-    TermCapability(:kf31,     :key_f31,                   "F31 function key"),
-    TermCapability(:kf32,     :key_f32,                   "F32 function key"),
-    TermCapability(:kf33,     :key_f33,                   "F33 function key"),
-    TermCapability(:kf34,     :key_f34,                   "F34 function key"),
-    TermCapability(:kf35,     :key_f35,                   "F35 function key"),
-    TermCapability(:kf36,     :key_f36,                   "F36 function key"),
-    TermCapability(:kf37,     :key_f37,                   "F37 function key"),
-    TermCapability(:kf38,     :key_f38,                   "F38 function key"),
-    TermCapability(:kf39,     :key_f39,                   "F39 function key"),
-    TermCapability(:kf40,     :key_f40,                   "F40 function key"),
-    TermCapability(:kf41,     :key_f41,                   "F41 function key"),
-    TermCapability(:kf42,     :key_f42,                   "F42 function key"),
-    TermCapability(:kf43,     :key_f43,                   "F43 function key"),
-    TermCapability(:kf44,     :key_f44,                   "F44 function key"),
-    TermCapability(:kf45,     :key_f45,                   "F45 function key"),
-    TermCapability(:kf46,     :key_f46,                   "F46 function key"),
-    TermCapability(:kf47,     :key_f47,                   "F47 function key"),
-    TermCapability(:kf48,     :key_f48,                   "F48 function key"),
-    TermCapability(:kf49,     :key_f49,                   "F49 function key"),
-    TermCapability(:kf50,     :key_f50,                   "F50 function key"),
-    TermCapability(:kf51,     :key_f51,                   "F51 function key"),
-    TermCapability(:kf52,     :key_f52,                   "F52 function key"),
-    TermCapability(:kf53,     :key_f53,                   "F53 function key"),
-    TermCapability(:kf54,     :key_f54,                   "F54 function key"),
-    TermCapability(:kf55,     :key_f55,                   "F55 function key"),
-    TermCapability(:kf56,     :key_f56,                   "F56 function key"),
-    TermCapability(:kf57,     :key_f57,                   "F57 function key"),
-    TermCapability(:kf58,     :key_f58,                   "F58 function key"),
-    TermCapability(:kf59,     :key_f59,                   "F59 function key"),
-    TermCapability(:kf60,     :key_f60,                   "F60 function key"),
-    TermCapability(:kf61,     :key_f61,                   "F61 function key"),
-    TermCapability(:kf62,     :key_f62,                   "F62 function key"),
-    TermCapability(:kf63,     :key_f63,                   "F63 function key"),
-    TermCapability(:el1,      :clr_bol,                   "Clear to beginning of line"),
-    TermCapability(:mgc,      :clear_margins,             "clear right and left soft margins"),
-    TermCapability(:smgl,     :set_left_margin,           "set left soft margin at current column."),
-    TermCapability(:smgr,     :set_right_margin,          "set right soft margin at current column"),
-    TermCapability(:fln,      :label_format,              "label format"),
-    TermCapability(:sclk,     :set_clock,                 "set clock, #1 hrs #2 mins #3 secs"),
-    TermCapability(:dclk,     :display_clock,             "display clock"),
-    TermCapability(:rmclk,    :remove_clock,              "remove clock"),
-    TermCapability(:cwin,     :create_window,             "define a window #1 from #2,#3 to #4,#5"),
-    TermCapability(:wingo,    :goto_window,               "go to window #1"),
-    TermCapability(:hup,      :hangup,                    "hang-up phone"),
-    TermCapability(:dial,     :dial_phone,                "dial number #1"),
-    TermCapability(:qdial,    :quick_dial,                "dial number #1 without checking"),
-    TermCapability(:tone,     :tone,                      "select touch tone dialing"),
-    TermCapability(:pulse,    :pulse,                     "select pulse dialing"),
-    TermCapability(:hook,     :flash_hook,                "flash switch hook"),
-    TermCapability(:pause,    :fixed_pause,               "pause for 2-3 seconds"),
-    TermCapability(:wait,     :wait_tone,                 "wait for dial-tone"),
-    TermCapability(:u0,       :user0,                     "User string #0"),
-    TermCapability(:u1,       :user1,                     "User string #1"),
-    TermCapability(:u2,       :user2,                     "User string #2"),
-    TermCapability(:u3,       :user3,                     "User string #3"),
-    TermCapability(:u4,       :user4,                     "User string #4"),
-    TermCapability(:u5,       :user5,                     "User string #5"),
-    TermCapability(:u6,       :user6,                     "User string #6"),
-    TermCapability(:u7,       :user7,                     "User string #7"),
-    TermCapability(:u8,       :user8,                     "User string #8"),
-    TermCapability(:u9,       :user9,                     "User string #9"),
-    TermCapability(:op,       :orig_pair,                 "Set default pair to its original value"),
-    TermCapability(:oc,       :orig_colors,               "Set all color pairs to the original ones"),
-    TermCapability(:initc,    :initialize_color,          "initialize color #1 to (#2,#3,#4)"),
-    TermCapability(:initp,    :initialize_pair,           "Initialize color pair #1 to fg=(#2,#3,#4), bg=(#5,#6,#7)"),
-    TermCapability(:scp,      :set_color_pair,            "Set current color pair to #1"),
-    TermCapability(:setf,     :set_foreground,            "Set foreground color #1"),
-    TermCapability(:setb,     :set_background,            "Set background color #1"),
-    TermCapability(:cpi,      :change_char_pitch,         "Change number of characters per inch to #1"),
-    TermCapability(:lpi,      :change_line_pitch,         "Change number of lines per inch to #1"),
-    TermCapability(:chr,      :change_res_horz,           "Change horizontal resolution to #1"),
-    TermCapability(:cvr,      :change_res_vert,           "Change vertical resolution to #1"),
-    TermCapability(:defc,     :define_char,               "Define a character #1, #2 dots wide, descender #3"),
-    TermCapability(:swidm,    :enter_doublewide_mode,     "Enter double-wide mode"),
-    TermCapability(:sdrfq,    :enter_draft_quality,       "Enter draft-quality mode"),
-    TermCapability(:sitm,     :enter_italics_mode,        "Enter italic mode"),
-    TermCapability(:slm,      :enter_leftward_mode,       "Start leftward carriage motion"),
-    TermCapability(:smicm,    :enter_micro_mode,          "Start micro-motion mode"),
-    TermCapability(:snlq,     :enter_near_letter_quality, "Enter NLQ mode"),
-    TermCapability(:snrmq,    :enter_normal_quality,      "Enter normal-quality mode"),
-    TermCapability(:sshm,     :enter_shadow_mode,         "Enter shadow-print mode"),
-    TermCapability(:ssubm,    :enter_subscript_mode,      "Enter subscript mode"),
-    TermCapability(:ssupm,    :enter_superscript_mode,    "Enter superscript mode"),
-    TermCapability(:sum,      :enter_upward_mode,         "Start upward carriage motion"),
-    TermCapability(:rwidm,    :exit_doublewide_mode,      "End double-wide mode"),
-    TermCapability(:ritm,     :exit_italics_mode,         "End italic mode"),
-    TermCapability(:rlm,      :exit_leftward_mode,        "End left-motion mode"),
-    TermCapability(:rmicm,    :exit_micro_mode,           "End micro-motion mode"),
-    TermCapability(:rshm,     :exit_shadow_mode,          "End shadow-print mode"),
-    TermCapability(:rsubm,    :exit_subscript_mode,       "End subscript mode"),
-    TermCapability(:rsupm,    :exit_superscript_mode,     "End superscript mode"),
-    TermCapability(:rum,      :exit_upward_mode,          "End reverse character motion"),
-    TermCapability(:mhpa,     :micro_column_address,      "Like column_address in micro mode"),
-    TermCapability(:mcud1,    :micro_down,                "Like cursor_down in micro mode"),
-    TermCapability(:mcub1,    :micro_left,                "Like cursor_left in micro mode"),
-    TermCapability(:mcuf1,    :micro_right,               "Like cursor_right in micro mode"),
-    TermCapability(:mvpa,     :micro_row_address,         "Like row_address #1 in micro mode"),
-    TermCapability(:mcuu1,    :micro_up,                  "Like cursor_up in micro mode"),
-    TermCapability(:porder,   :order_of_pins,             "Match software bits to print-head pins"),
-    TermCapability(:mcud,     :parm_down_micro,           "Like parm_down_cursor in micro mode"),
-    TermCapability(:mcub,     :parm_left_micro,           "Like parm_left_cursor in micro mode"),
-    TermCapability(:mcuf,     :parm_right_micro,          "Like parm_right_cursor in micro mode"),
-    TermCapability(:mcuu,     :parm_up_micro,             "Like parm_up_cursor in micro mode"),
-    TermCapability(:scs,      :select_char_set,           "Select character set, #1"),
-    TermCapability(:smgb,     :set_bottom_margin,         "Set bottom margin at current line"),
-    TermCapability(:smgbp,    :set_bottom_margin_parm,    "Set bottom margin at line #1 or (if smgtp is not given) #2 lines from bottom"),
-    TermCapability(:smglp,    :set_left_margin_parm,      "Set left (right) margin at column #1"),
-    TermCapability(:smgrp,    :set_right_margin_parm,     "Set right margin at column #1"),
-    TermCapability(:smgt,     :set_top_margin,            "Set top margin at current line"),
-    TermCapability(:smgtp,    :set_top_margin_parm,       "Set top (bottom) margin at row #1"),
-    TermCapability(:sbim,     :start_bit_image,           "Start printing bit image graphics"),
-    TermCapability(:scsd,     :start_char_set_def,        "Start character set definition #1, with #2 characters in the set"),
-    TermCapability(:rbim,     :stop_bit_image,            "Stop printing bit image graphics"),
-    TermCapability(:rcsd,     :stop_char_set_def,         "End definition of character set #1"),
-    TermCapability(:subcs,    :subscript_characters,      "List of subscriptable characters"),
-    TermCapability(:supcs,    :superscript_characters,    "List of superscriptable characters"),
-    TermCapability(:docr,     :these_cause_cr,            "Printing any of these characters causes CR"),
-    TermCapability(:zerom,    :zero_motion,               "No motion for subsequent character"),
-    TermCapability(:csnm,     :char_set_names,            "Produce #1'th item from list of character set names"),
-    TermCapability(:kmous,    :key_mouse,                 "Mouse event has occurred"),
-    TermCapability(:minfo,    :mouse_info,                "Mouse status information"),
-    TermCapability(:reqmp,    :req_mouse_pos,             "Request mouse position"),
-    TermCapability(:getm,     :get_mouse,                 "Curses should get button events, parameter #1 not documented."),
-    TermCapability(:setaf,    :set_a_foreground,          "Set foreground color to #1, using ANSI escape"),
-    TermCapability(:setab,    :set_a_background,          "Set background color to #1, using ANSI escape"),
-    TermCapability(:pfxl,     :pkey_plab,                 "Program function key #1 to type string #2 and show string #3"),
-    TermCapability(:devt,     :device_type,               "Indicate language/codeset support"),
-    TermCapability(:csin,     :code_set_init,             "Init sequence for multiple codesets"),
-    TermCapability(:s0ds,     :set0_des_seq,              "Shift to codeset 0 (EUC set 0, ASCII)"),
-    TermCapability(:s1ds,     :set1_des_seq,              "Shift to codeset 1"),
-    TermCapability(:s2ds,     :set2_des_seq,              "Shift to codeset 2"),
-    TermCapability(:s3ds,     :set3_des_seq,              "Shift to codeset 3"),
-    TermCapability(:smglr,    :set_lr_margin,             "Set both left and right margins to #1, #2.  (ML is not in BSD termcap)."),
-    TermCapability(:smgtb,    :set_tb_margin,             "Sets both top and bottom margins to #1, #2"),
-    TermCapability(:birep,    :bit_image_repeat,          "Repeat bit image cell #1 #2 times"),
-    TermCapability(:binel,    :bit_image_newline,         "Move to next row of the bit image"),
-    TermCapability(:bicr,     :bit_image_carriage_return, "Move to beginning of same row"),
-    TermCapability(:colornm,  :color_names,               "Give name for color #1"),
-    TermCapability(:defbi,    :define_bit_image_region,   "Define rectangular bit image region"),
-    TermCapability(:endbi,    :end_bit_image_region,      "End a bit-image region"),
-    TermCapability(:setcolor, :set_color_band,            "Change to ribbon color #1"),
-    TermCapability(:slines,   :set_page_length,           "Set page length to #1 lines"),
-    TermCapability(:dispc,    :display_pc_char,           "Display PC character #1"),
-    TermCapability(:smpch,    :enter_pc_charset_mode,     "Enter PC character display mode"),
-    TermCapability(:rmpch,    :exit_pc_charset_mode,      "Exit PC character display mode"),
-    TermCapability(:smsc,     :enter_scancode_mode,       "Enter PC scancode mode"),
-    TermCapability(:rmsc,     :exit_scancode_mode,        "Exit PC scancode mode"),
-    TermCapability(:pctrm,    :pc_term_options,           "PC terminal options"),
-    TermCapability(:scesc,    :scancode_escape,           "Escape for scancode emulation"),
-    TermCapability(:scesa,    :alt_scancode_esc,          "Alternate escape for scancode emulation"),
-    TermCapability(:ehhlm,    :enter_horizontal_hl_mode,  "Enter horizontal highlight mode"),
-    TermCapability(:elhlm,    :enter_left_hl_mode,        "Enter left highlight mode"),
-    TermCapability(:elohlm,   :enter_low_hl_mode,         "Enter low highlight mode"),
-    TermCapability(:erhlm,    :enter_right_hl_mode,       "Enter right highlight mode"),
-    TermCapability(:ethlm,    :enter_top_hl_mode,         "Enter top highlight mode"),
-    TermCapability(:evhlm,    :enter_vertical_hl_mode,    "Enter vertical highlight mode"),
-    TermCapability(:sgr1,     :set_a_attributes,          "Define second set of video attributes #1-#6"),
-    TermCapability(:slength,  :set_pglen_inch,            "Set page length to #1 hundredth of an inch (some implementations use sL for termcap)."),
-    TermCapability(:OTi2,     :termcap_init2,             "secondary initialization string"),
-    TermCapability(:OTrs,     :termcap_reset,             "terminal reset string"),
-    TermCapability(:OTnl,     :linefeed_if_not_lf,        "use to move down"),
-    TermCapability(:OTbc,     :backspace_if_not_bs,       "move left, if not ^H"),
-    TermCapability(:OTko,     :other_non_function_keys,   "list of self-mapped keycaps"),
-    TermCapability(:OTma,     :arrow_key_map,             "map motion-keys for vi version 2"),
-    TermCapability(:OTG2,     :acs_ulcorner,              "single upper left"),
-    TermCapability(:OTG3,     :acs_llcorner,              "single lower left"),
-    TermCapability(:OTG1,     :acs_urcorner,              "single upper right"),
-    TermCapability(:OTG4,     :acs_lrcorner,              "single lower right"),
-    TermCapability(:OTGR,     :acs_ltee,                  "tee pointing right"),
-    TermCapability(:OTGL,     :acs_rtee,                  "tee pointing left"),
-    TermCapability(:OTGU,     :acs_btee,                  "tee pointing up"),
-    TermCapability(:OTGD,     :acs_ttee,                  "tee pointing down"),
-    TermCapability(:OTGH,     :acs_hline,                 "single horizontal line"),
-    TermCapability(:OTGV,     :acs_vline,                 "single vertical line"),
-    TermCapability(:OTGC,     :acs_plus,                  "single intersection"),
-    TermCapability(:meml,     :memory_lock,               "lock memory above cursor"),
-    TermCapability(:memu,     :memory_unlock,             "unlock memory"),
-    TermCapability(:box1,     :box_chars_1,               "box characters primary set"),
+    TermCapability(:back_tab,                  :cbt,      "back tab (P)"),
+    TermCapability(:bell,                      :bel,      "audible signal (bell) (P)"),
+    TermCapability(:carriage_return,           :cr,       "carriage return (P*) (P*)"),
+    TermCapability(:change_scroll_region,      :csr,      "change region to line #1 to line #2 (P)"),
+    TermCapability(:clear_all_tabs,            :tbc,      "clear all tab stops (P)"),
+    TermCapability(:clear_screen,              :clear,    "clear screen and home cursor (P*)"),
+    TermCapability(:clr_eol,                   :el,       "clear to end of line (P)"),
+    TermCapability(:clr_eos,                   :ed,       "clear to end of screen (P*)"),
+    TermCapability(:column_address,            :hpa,      "horizontal position #1, absolute (P)"),
+    TermCapability(:command_character,         :cmdch,    "terminal settable cmd character in prototype !?"),
+    TermCapability(:cursor_address,            :cup,      "move to row #1 columns #2"),
+    TermCapability(:cursor_down,               :cud1,     "down one line"),
+    TermCapability(:cursor_home,               :home,     "home cursor (if no cup)"),
+    TermCapability(:cursor_invisible,          :civis,    "make cursor invisible"),
+    TermCapability(:cursor_left,               :cub1,     "move left one space"),
+    TermCapability(:cursor_mem_address,        :mrcup,    "memory relative cursor addressing, move to row #1 columns #2"),
+    TermCapability(:cursor_normal,             :cnorm,    "make cursor appear normal (undo civis/cvvis)"),
+    TermCapability(:cursor_right,              :cuf1,     "non-destructive space (move right one space)"),
+    TermCapability(:cursor_to_ll,              :ll,       "last line, first column (if no cup)"),
+    TermCapability(:cursor_up,                 :cuu1,     "up one line"),
+    TermCapability(:cursor_visible,            :cvvis,    "make cursor very visible"),
+    TermCapability(:delete_character,          :dch1,     "delete character (P*)"),
+    TermCapability(:delete_line,               :dl1,      "delete line (P*)"),
+    TermCapability(:dis_status_line,           :dsl,      "disable status line"),
+    TermCapability(:down_half_line,            :hd,       "half a line down"),
+    TermCapability(:enter_alt_charset_mode,    :smacs,    "start alternate character set (P)"),
+    TermCapability(:enter_blink_mode,          :blink,    "turn on blinking"),
+    TermCapability(:enter_bold_mode,           :bold,     "turn on bold (extra bright) mode"),
+    TermCapability(:enter_ca_mode,             :smcup,    "string to start programs using cup"),
+    TermCapability(:enter_delete_mode,         :smdc,     "enter delete mode"),
+    TermCapability(:enter_dim_mode,            :dim,      "turn on half-bright mode"),
+    TermCapability(:enter_insert_mode,         :smir,     "enter insert mode"),
+    TermCapability(:enter_secure_mode,         :invis,    "turn on blank mode (characters invisible)"),
+    TermCapability(:enter_protected_mode,      :prot,     "turn on protected mode"),
+    TermCapability(:enter_reverse_mode,        :rev,      "turn on reverse video mode"),
+    TermCapability(:enter_standout_mode,       :smso,     "begin standout mode"),
+    TermCapability(:enter_underline_mode,      :smul,     "begin underline mode"),
+    TermCapability(:erase_chars,               :ech,      "erase #1 characters (P)"),
+    TermCapability(:exit_alt_charset_mode,     :rmacs,    "end alternate character set (P)"),
+    TermCapability(:exit_attribute_mode,       :sgr0,     "turn off all attributes"),
+    TermCapability(:exit_ca_mode,              :rmcup,    "strings to end programs using cup"),
+    TermCapability(:exit_delete_mode,          :rmdc,     "end delete mode"),
+    TermCapability(:exit_insert_mode,          :rmir,     "exit insert mode"),
+    TermCapability(:exit_standout_mode,        :rmso,     "exit standout mode"),
+    TermCapability(:exit_underline_mode,       :rmul,     "exit underline mode"),
+    TermCapability(:flash_screen,              :flash,    "visible bell (may not move cursor)"),
+    TermCapability(:form_feed,                 :ff,       "hardcopy terminal page eject (P*)"),
+    TermCapability(:from_status_line,          :fsl,      "return from status line"),
+    TermCapability(:init_1string,              :is1,      "initialization string"),
+    TermCapability(:init_2string,              :is2,      "initialization string"),
+    TermCapability(:init_3string,              :is3,      "initialization string"),
+    TermCapability(:init_file,                 :if,       "name of initialization file"),
+    TermCapability(:insert_character,          :ich1,     "insert character (P)"),
+    TermCapability(:insert_line,               :il1,      "insert line (P*)"),
+    TermCapability(:insert_padding,            :ip,       "insert padding after inserted character"),
+    TermCapability(:key_backspace,             :kbs,      "backspace key"),
+    TermCapability(:key_catab,                 :ktbc,     "clear-all-tabs key"),
+    TermCapability(:key_clear,                 :kclr,     "clear-screen or erase key"),
+    TermCapability(:key_ctab,                  :kctab,    "clear-tab key"),
+    TermCapability(:key_dc,                    :kdch1,    "delete-character key"),
+    TermCapability(:key_dl,                    :kdl1,     "delete-line key"),
+    TermCapability(:key_down,                  :kcud1,    "down-arrow key"),
+    TermCapability(:key_eic,                   :krmir,    "sent by rmir or smir in insert mode"),
+    TermCapability(:key_eol,                   :kel,      "clear-to-end-of-line key"),
+    TermCapability(:key_eos,                   :ked,      "clear-to-end-of-screen key"),
+    TermCapability(:key_f0,                    :kf0,      "F0 function key"),
+    TermCapability(:key_f1,                    :kf1,      "F1 function key"),
+    TermCapability(:key_f10,                   :kf10,     "F10 function key"),
+    TermCapability(:key_f2,                    :kf2,      "F2 function key"),
+    TermCapability(:key_f3,                    :kf3,      "F3 function key"),
+    TermCapability(:key_f4,                    :kf4,      "F4 function key"),
+    TermCapability(:key_f5,                    :kf5,      "F5 function key"),
+    TermCapability(:key_f6,                    :kf6,      "F6 function key"),
+    TermCapability(:key_f7,                    :kf7,      "F7 function key"),
+    TermCapability(:key_f8,                    :kf8,      "F8 function key"),
+    TermCapability(:key_f9,                    :kf9,      "F9 function key"),
+    TermCapability(:key_home,                  :khome,    "home key"),
+    TermCapability(:key_ic,                    :kich1,    "insert-character key"),
+    TermCapability(:key_il,                    :kil1,     "insert-line key"),
+    TermCapability(:key_left,                  :kcub1,    "left-arrow key"),
+    TermCapability(:key_ll,                    :kll,      "lower-left key (home down)"),
+    TermCapability(:key_npage,                 :knp,      "next-page key"),
+    TermCapability(:key_ppage,                 :kpp,      "previous-page key"),
+    TermCapability(:key_right,                 :kcuf1,    "right-arrow key"),
+    TermCapability(:key_sf,                    :kind,     "scroll-forward key"),
+    TermCapability(:key_sr,                    :kri,      "scroll-backward key"),
+    TermCapability(:key_stab,                  :khts,     "set-tab key"),
+    TermCapability(:key_up,                    :kcuu1,    "up-arrow key"),
+    TermCapability(:keypad_local,              :rmkx,     "leave 'keyboard_transmit' mode"),
+    TermCapability(:keypad_xmit,               :smkx,     "enter 'keyboard_transmit' mode"),
+    TermCapability(:lab_f0,                    :lf0,      "label on function key f0 if not f0"),
+    TermCapability(:lab_f1,                    :lf1,      "label on function key f1 if not f1"),
+    TermCapability(:lab_f10,                   :lf10,     "label on function key f10 if not f10"),
+    TermCapability(:lab_f2,                    :lf2,      "label on function key f2 if not f2"),
+    TermCapability(:lab_f3,                    :lf3,      "label on function key f3 if not f3"),
+    TermCapability(:lab_f4,                    :lf4,      "label on function key f4 if not f4"),
+    TermCapability(:lab_f5,                    :lf5,      "label on function key f5 if not f5"),
+    TermCapability(:lab_f6,                    :lf6,      "label on function key f6 if not f6"),
+    TermCapability(:lab_f7,                    :lf7,      "label on function key f7 if not f7"),
+    TermCapability(:lab_f8,                    :lf8,      "label on function key f8 if not f8"),
+    TermCapability(:lab_f9,                    :lf9,      "label on function key f9 if not f9"),
+    TermCapability(:meta_off,                  :rmm,      "turn off meta mode"),
+    TermCapability(:meta_on,                   :smm,      "turn on meta mode (8th-bit on)"),
+    TermCapability(:newline,                   :nel,      "newline (behave like cr followed by lf)"),
+    TermCapability(:pad_char,                  :pad,      "padding char (instead of null)"),
+    TermCapability(:parm_dch,                  :dch,      "delete #1 characters (P*)"),
+    TermCapability(:parm_delete_line,          :dl,       "delete #1 lines (P*)"),
+    TermCapability(:parm_down_cursor,          :cud,      "down #1 lines (P*)"),
+    TermCapability(:parm_ich,                  :ich,      "insert #1 characters (P*)"),
+    TermCapability(:parm_index,                :indn,     "scroll forward #1 lines (P)"),
+    TermCapability(:parm_insert_line,          :il,       "insert #1 lines (P*)"),
+    TermCapability(:parm_left_cursor,          :cub,      "move #1 characters to the left (P)"),
+    TermCapability(:parm_right_cursor,         :cuf,      "move #1 characters to the right (P*)"),
+    TermCapability(:parm_rindex,               :rin,      "scroll back #1 lines (P)"),
+    TermCapability(:parm_up_cursor,            :cuu,      "up #1 lines (P*)"),
+    TermCapability(:pkey_key,                  :pfkey,    "program function key #1 to type string #2"),
+    TermCapability(:pkey_local,                :pfloc,    "program function key #1 to execute string #2"),
+    TermCapability(:pkey_xmit,                 :pfx,      "program function key #1 to transmit string #2"),
+    TermCapability(:print_screen,              :mc0,      "print contents of screen"),
+    TermCapability(:prtr_off,                  :mc4,      "turn off printer"),
+    TermCapability(:prtr_on,                   :mc5,      "turn on printer"),
+    TermCapability(:repeat_char,               :rep,      "repeat char #1 #2 times (P*)"),
+    TermCapability(:reset_1string,             :rs1,      "reset string"),
+    TermCapability(:reset_2string,             :rs2,      "reset string"),
+    TermCapability(:reset_3string,             :rs3,      "reset string"),
+    TermCapability(:reset_file,                :rf,       "name of reset file"),
+    TermCapability(:restore_cursor,            :rc,       "restore cursor to position of last save_cursor"),
+    TermCapability(:row_address,               :vpa,      "vertical position #1 absolute (P)"),
+    TermCapability(:save_cursor,               :sc,       "save current cursor position (P)"),
+    TermCapability(:scroll_forward,            :ind,      "scroll text up (P)"),
+    TermCapability(:scroll_reverse,            :ri,       "scroll text down (P)"),
+    TermCapability(:set_attributes,            :sgr,      "define video attributes #1-#9 (PG9)"),
+    TermCapability(:set_tab,                   :hts,      "set a tab in every row, current columns"),
+    TermCapability(:set_window,                :wind,     "current window is lines #1-#2 cols #3-#4"),
+    TermCapability(:tab,                       :ht,       "tab to next 8-space hardware tab stop"),
+    TermCapability(:to_status_line,            :tsl,      "move to status line, column #1"),
+    TermCapability(:underline_char,            :uc,       "underline char and move past it"),
+    TermCapability(:up_half_line,              :hu,       "half a line up"),
+    TermCapability(:init_prog,                 :iprog,    "path name of program for initialization"),
+    TermCapability(:key_a1,                    :ka1,      "upper left of keypad"),
+    TermCapability(:key_a3,                    :ka3,      "upper right of keypad"),
+    TermCapability(:key_b2,                    :kb2,      "center of keypad"),
+    TermCapability(:key_c1,                    :kc1,      "lower left of keypad"),
+    TermCapability(:key_c3,                    :kc3,      "lower right of keypad"),
+    TermCapability(:prtr_non,                  :mc5p,     "turn on printer for #1 bytes"),
+    TermCapability(:char_padding,              :rmp,      "like ip but when in insert mode"),
+    TermCapability(:acs_chars,                 :acsc,     "graphics charset pairs, based on vt100"),
+    TermCapability(:plab_norm,                 :pln,      "program label #1 to show string #2"),
+    TermCapability(:key_btab,                  :kcbt,     "back-tab key"),
+    TermCapability(:enter_xon_mode,            :smxon,    "turn on xon/xoff handshaking"),
+    TermCapability(:exit_xon_mode,             :rmxon,    "turn off xon/xoff handshaking"),
+    TermCapability(:enter_am_mode,             :smam,     "turn on automatic margins"),
+    TermCapability(:exit_am_mode,              :rmam,     "turn off automatic margins"),
+    TermCapability(:xon_character,             :xonc,     "XON character"),
+    TermCapability(:xoff_character,            :xoffc,    "XOFF character"),
+    TermCapability(:ena_acs,                   :enacs,    "enable alternate char set"),
+    TermCapability(:label_on,                  :smln,     "turn on soft labels"),
+    TermCapability(:label_off,                 :rmln,     "turn off soft labels"),
+    TermCapability(:key_beg,                   :kbeg,     "begin key"),
+    TermCapability(:key_cancel,                :kcan,     "cancel key"),
+    TermCapability(:key_close,                 :kclo,     "close key"),
+    TermCapability(:key_command,               :kcmd,     "command key"),
+    TermCapability(:key_copy,                  :kcpy,     "copy key"),
+    TermCapability(:key_create,                :kcrt,     "create key"),
+    TermCapability(:key_end,                   :kend,     "end key"),
+    TermCapability(:key_enter,                 :kent,     "enter/send key"),
+    TermCapability(:key_exit,                  :kext,     "exit key"),
+    TermCapability(:key_find,                  :kfnd,     "find key"),
+    TermCapability(:key_help,                  :khlp,     "help key"),
+    TermCapability(:key_mark,                  :kmrk,     "mark key"),
+    TermCapability(:key_message,               :kmsg,     "message key"),
+    TermCapability(:key_move,                  :kmov,     "move key"),
+    TermCapability(:key_next,                  :knxt,     "next key"),
+    TermCapability(:key_open,                  :kopn,     "open key"),
+    TermCapability(:key_options,               :kopt,     "options key"),
+    TermCapability(:key_previous,              :kprv,     "previous key"),
+    TermCapability(:key_print,                 :kprt,     "print key"),
+    TermCapability(:key_redo,                  :krdo,     "redo key"),
+    TermCapability(:key_reference,             :kref,     "reference key"),
+    TermCapability(:key_refresh,               :krfr,     "refresh key"),
+    TermCapability(:key_replace,               :krpl,     "replace key"),
+    TermCapability(:key_restart,               :krst,     "restart key"),
+    TermCapability(:key_resume,                :kres,     "resume key"),
+    TermCapability(:key_save,                  :ksav,     "save key"),
+    TermCapability(:key_suspend,               :kspd,     "suspend key"),
+    TermCapability(:key_undo,                  :kund,     "undo key"),
+    TermCapability(:key_sbeg,                  :kBEG,     "shifted begin key"),
+    TermCapability(:key_scancel,               :kCAN,     "shifted cancel key"),
+    TermCapability(:key_scommand,              :kCMD,     "shifted command key"),
+    TermCapability(:key_scopy,                 :kCPY,     "shifted copy key"),
+    TermCapability(:key_screate,               :kCRT,     "shifted create key"),
+    TermCapability(:key_sdc,                   :kDC,      "shifted delete-character key"),
+    TermCapability(:key_sdl,                   :kDL,      "shifted delete-line key"),
+    TermCapability(:key_select,                :kslt,     "select key"),
+    TermCapability(:key_send,                  :kEND,     "shifted end key"),
+    TermCapability(:key_seol,                  :kEOL,     "shifted clear-to-end-of-line key"),
+    TermCapability(:key_sexit,                 :kEXT,     "shifted exit key"),
+    TermCapability(:key_sfind,                 :kFND,     "shifted find key"),
+    TermCapability(:key_shelp,                 :kHLP,     "shifted help key"),
+    TermCapability(:key_shome,                 :kHOM,     "shifted home key"),
+    TermCapability(:key_sic,                   :kIC,      "shifted insert-character key"),
+    TermCapability(:key_sleft,                 :kLFT,     "shifted left-arrow key"),
+    TermCapability(:key_smessage,              :kMSG,     "shifted message key"),
+    TermCapability(:key_smove,                 :kMOV,     "shifted move key"),
+    TermCapability(:key_snext,                 :kNXT,     "shifted next key"),
+    TermCapability(:key_soptions,              :kOPT,     "shifted options key"),
+    TermCapability(:key_sprevious,             :kPRV,     "shifted previous key"),
+    TermCapability(:key_sprint,                :kPRT,     "shifted print key"),
+    TermCapability(:key_sredo,                 :kRDO,     "shifted redo key"),
+    TermCapability(:key_sreplace,              :kRPL,     "shifted replace key"),
+    TermCapability(:key_sright,                :kRIT,     "shifted right-arrow key"),
+    TermCapability(:key_srsume,                :kRES,     "shifted resume key"),
+    TermCapability(:key_ssave,                 :kSAV,     "shifted save key"),
+    TermCapability(:key_ssuspend,              :kSPD,     "shifted suspend key"),
+    TermCapability(:key_sundo,                 :kUND,     "shifted undo key"),
+    TermCapability(:req_for_input,             :rfi,      "send next input char (for ptys)"),
+    TermCapability(:key_f11,                   :kf11,     "F11 function key"),
+    TermCapability(:key_f12,                   :kf12,     "F12 function key"),
+    TermCapability(:key_f13,                   :kf13,     "F13 function key"),
+    TermCapability(:key_f14,                   :kf14,     "F14 function key"),
+    TermCapability(:key_f15,                   :kf15,     "F15 function key"),
+    TermCapability(:key_f16,                   :kf16,     "F16 function key"),
+    TermCapability(:key_f17,                   :kf17,     "F17 function key"),
+    TermCapability(:key_f18,                   :kf18,     "F18 function key"),
+    TermCapability(:key_f19,                   :kf19,     "F19 function key"),
+    TermCapability(:key_f20,                   :kf20,     "F20 function key"),
+    TermCapability(:key_f21,                   :kf21,     "F21 function key"),
+    TermCapability(:key_f22,                   :kf22,     "F22 function key"),
+    TermCapability(:key_f23,                   :kf23,     "F23 function key"),
+    TermCapability(:key_f24,                   :kf24,     "F24 function key"),
+    TermCapability(:key_f25,                   :kf25,     "F25 function key"),
+    TermCapability(:key_f26,                   :kf26,     "F26 function key"),
+    TermCapability(:key_f27,                   :kf27,     "F27 function key"),
+    TermCapability(:key_f28,                   :kf28,     "F28 function key"),
+    TermCapability(:key_f29,                   :kf29,     "F29 function key"),
+    TermCapability(:key_f30,                   :kf30,     "F30 function key"),
+    TermCapability(:key_f31,                   :kf31,     "F31 function key"),
+    TermCapability(:key_f32,                   :kf32,     "F32 function key"),
+    TermCapability(:key_f33,                   :kf33,     "F33 function key"),
+    TermCapability(:key_f34,                   :kf34,     "F34 function key"),
+    TermCapability(:key_f35,                   :kf35,     "F35 function key"),
+    TermCapability(:key_f36,                   :kf36,     "F36 function key"),
+    TermCapability(:key_f37,                   :kf37,     "F37 function key"),
+    TermCapability(:key_f38,                   :kf38,     "F38 function key"),
+    TermCapability(:key_f39,                   :kf39,     "F39 function key"),
+    TermCapability(:key_f40,                   :kf40,     "F40 function key"),
+    TermCapability(:key_f41,                   :kf41,     "F41 function key"),
+    TermCapability(:key_f42,                   :kf42,     "F42 function key"),
+    TermCapability(:key_f43,                   :kf43,     "F43 function key"),
+    TermCapability(:key_f44,                   :kf44,     "F44 function key"),
+    TermCapability(:key_f45,                   :kf45,     "F45 function key"),
+    TermCapability(:key_f46,                   :kf46,     "F46 function key"),
+    TermCapability(:key_f47,                   :kf47,     "F47 function key"),
+    TermCapability(:key_f48,                   :kf48,     "F48 function key"),
+    TermCapability(:key_f49,                   :kf49,     "F49 function key"),
+    TermCapability(:key_f50,                   :kf50,     "F50 function key"),
+    TermCapability(:key_f51,                   :kf51,     "F51 function key"),
+    TermCapability(:key_f52,                   :kf52,     "F52 function key"),
+    TermCapability(:key_f53,                   :kf53,     "F53 function key"),
+    TermCapability(:key_f54,                   :kf54,     "F54 function key"),
+    TermCapability(:key_f55,                   :kf55,     "F55 function key"),
+    TermCapability(:key_f56,                   :kf56,     "F56 function key"),
+    TermCapability(:key_f57,                   :kf57,     "F57 function key"),
+    TermCapability(:key_f58,                   :kf58,     "F58 function key"),
+    TermCapability(:key_f59,                   :kf59,     "F59 function key"),
+    TermCapability(:key_f60,                   :kf60,     "F60 function key"),
+    TermCapability(:key_f61,                   :kf61,     "F61 function key"),
+    TermCapability(:key_f62,                   :kf62,     "F62 function key"),
+    TermCapability(:key_f63,                   :kf63,     "F63 function key"),
+    TermCapability(:clr_bol,                   :el1,      "Clear to beginning of line"),
+    TermCapability(:clear_margins,             :mgc,      "clear right and left soft margins"),
+    TermCapability(:set_left_margin,           :smgl,     "set left soft margin at current column."),
+    TermCapability(:set_right_margin,          :smgr,     "set right soft margin at current column"),
+    TermCapability(:label_format,              :fln,      "label format"),
+    TermCapability(:set_clock,                 :sclk,     "set clock, #1 hrs #2 mins #3 secs"),
+    TermCapability(:display_clock,             :dclk,     "display clock"),
+    TermCapability(:remove_clock,              :rmclk,    "remove clock"),
+    TermCapability(:create_window,             :cwin,     "define a window #1 from #2,#3 to #4,#5"),
+    TermCapability(:goto_window,               :wingo,    "go to window #1"),
+    TermCapability(:hangup,                    :hup,      "hang-up phone"),
+    TermCapability(:dial_phone,                :dial,     "dial number #1"),
+    TermCapability(:quick_dial,                :qdial,    "dial number #1 without checking"),
+    TermCapability(:tone,                      :tone,     "select touch tone dialing"),
+    TermCapability(:pulse,                     :pulse,    "select pulse dialing"),
+    TermCapability(:flash_hook,                :hook,     "flash switch hook"),
+    TermCapability(:fixed_pause,               :pause,    "pause for 2-3 seconds"),
+    TermCapability(:wait_tone,                 :wait,     "wait for dial-tone"),
+    TermCapability(:user0,                     :u0,       "User string #0"),
+    TermCapability(:user1,                     :u1,       "User string #1"),
+    TermCapability(:user2,                     :u2,       "User string #2"),
+    TermCapability(:user3,                     :u3,       "User string #3"),
+    TermCapability(:user4,                     :u4,       "User string #4"),
+    TermCapability(:user5,                     :u5,       "User string #5"),
+    TermCapability(:user6,                     :u6,       "User string #6"),
+    TermCapability(:user7,                     :u7,       "User string #7"),
+    TermCapability(:user8,                     :u8,       "User string #8"),
+    TermCapability(:user9,                     :u9,       "User string #9"),
+    TermCapability(:orig_pair,                 :op,       "Set default pair to its original value"),
+    TermCapability(:orig_colors,               :oc,       "Set all color pairs to the original ones"),
+    TermCapability(:initialize_color,          :initc,    "initialize color #1 to (#2,#3,#4)"),
+    TermCapability(:initialize_pair,           :initp,    "Initialize color pair #1 to fg=(#2,#3,#4), bg=(#5,#6,#7)"),
+    TermCapability(:set_color_pair,            :scp,      "Set current color pair to #1"),
+    TermCapability(:set_foreground,            :setf,     "Set foreground color #1"),
+    TermCapability(:set_background,            :setb,     "Set background color #1"),
+    TermCapability(:change_char_pitch,         :cpi,      "Change number of characters per inch to #1"),
+    TermCapability(:change_line_pitch,         :lpi,      "Change number of lines per inch to #1"),
+    TermCapability(:change_res_horz,           :chr,      "Change horizontal resolution to #1"),
+    TermCapability(:change_res_vert,           :cvr,      "Change vertical resolution to #1"),
+    TermCapability(:define_char,               :defc,     "Define a character #1, #2 dots wide, descender #3"),
+    TermCapability(:enter_doublewide_mode,     :swidm,    "Enter double-wide mode"),
+    TermCapability(:enter_draft_quality,       :sdrfq,    "Enter draft-quality mode"),
+    TermCapability(:enter_italics_mode,        :sitm,     "Enter italic mode"),
+    TermCapability(:enter_leftward_mode,       :slm,      "Start leftward carriage motion"),
+    TermCapability(:enter_micro_mode,          :smicm,    "Start micro-motion mode"),
+    TermCapability(:enter_near_letter_quality, :snlq,     "Enter NLQ mode"),
+    TermCapability(:enter_normal_quality,      :snrmq,    "Enter normal-quality mode"),
+    TermCapability(:enter_shadow_mode,         :sshm,     "Enter shadow-print mode"),
+    TermCapability(:enter_subscript_mode,      :ssubm,    "Enter subscript mode"),
+    TermCapability(:enter_superscript_mode,    :ssupm,    "Enter superscript mode"),
+    TermCapability(:enter_upward_mode,         :sum,      "Start upward carriage motion"),
+    TermCapability(:exit_doublewide_mode,      :rwidm,    "End double-wide mode"),
+    TermCapability(:exit_italics_mode,         :ritm,     "End italic mode"),
+    TermCapability(:exit_leftward_mode,        :rlm,      "End left-motion mode"),
+    TermCapability(:exit_micro_mode,           :rmicm,    "End micro-motion mode"),
+    TermCapability(:exit_shadow_mode,          :rshm,     "End shadow-print mode"),
+    TermCapability(:exit_subscript_mode,       :rsubm,    "End subscript mode"),
+    TermCapability(:exit_superscript_mode,     :rsupm,    "End superscript mode"),
+    TermCapability(:exit_upward_mode,          :rum,      "End reverse character motion"),
+    TermCapability(:micro_column_address,      :mhpa,     "Like column_address in micro mode"),
+    TermCapability(:micro_down,                :mcud1,    "Like cursor_down in micro mode"),
+    TermCapability(:micro_left,                :mcub1,    "Like cursor_left in micro mode"),
+    TermCapability(:micro_right,               :mcuf1,    "Like cursor_right in micro mode"),
+    TermCapability(:micro_row_address,         :mvpa,     "Like row_address #1 in micro mode"),
+    TermCapability(:micro_up,                  :mcuu1,    "Like cursor_up in micro mode"),
+    TermCapability(:order_of_pins,             :porder,   "Match software bits to print-head pins"),
+    TermCapability(:parm_down_micro,           :mcud,     "Like parm_down_cursor in micro mode"),
+    TermCapability(:parm_left_micro,           :mcub,     "Like parm_left_cursor in micro mode"),
+    TermCapability(:parm_right_micro,          :mcuf,     "Like parm_right_cursor in micro mode"),
+    TermCapability(:parm_up_micro,             :mcuu,     "Like parm_up_cursor in micro mode"),
+    TermCapability(:select_char_set,           :scs,      "Select character set, #1"),
+    TermCapability(:set_bottom_margin,         :smgb,     "Set bottom margin at current line"),
+    TermCapability(:set_bottom_margin_parm,    :smgbp,    "Set bottom margin at line #1 or (if smgtp is not given) #2 lines from bottom"),
+    TermCapability(:set_left_margin_parm,      :smglp,    "Set left (right) margin at column #1"),
+    TermCapability(:set_right_margin_parm,     :smgrp,    "Set right margin at column #1"),
+    TermCapability(:set_top_margin,            :smgt,     "Set top margin at current line"),
+    TermCapability(:set_top_margin_parm,       :smgtp,    "Set top (bottom) margin at row #1"),
+    TermCapability(:start_bit_image,           :sbim,     "Start printing bit image graphics"),
+    TermCapability(:start_char_set_def,        :scsd,     "Start character set definition #1, with #2 characters in the set"),
+    TermCapability(:stop_bit_image,            :rbim,     "Stop printing bit image graphics"),
+    TermCapability(:stop_char_set_def,         :rcsd,     "End definition of character set #1"),
+    TermCapability(:subscript_characters,      :subcs,    "List of subscriptable characters"),
+    TermCapability(:superscript_characters,    :supcs,    "List of superscriptable characters"),
+    TermCapability(:these_cause_cr,            :docr,     "Printing any of these characters causes CR"),
+    TermCapability(:zero_motion,               :zerom,    "No motion for subsequent character"),
+    TermCapability(:char_set_names,            :csnm,     "Produce #1'th item from list of character set names"),
+    TermCapability(:key_mouse,                 :kmous,    "Mouse event has occurred"),
+    TermCapability(:mouse_info,                :minfo,    "Mouse status information"),
+    TermCapability(:req_mouse_pos,             :reqmp,    "Request mouse position"),
+    TermCapability(:get_mouse,                 :getm,     "Curses should get button events, parameter #1 not documented."),
+    TermCapability(:set_a_foreground,          :setaf,    "Set foreground color to #1, using ANSI escape"),
+    TermCapability(:set_a_background,          :setab,    "Set background color to #1, using ANSI escape"),
+    TermCapability(:pkey_plab,                 :pfxl,     "Program function key #1 to type string #2 and show string #3"),
+    TermCapability(:device_type,               :devt,     "Indicate language/codeset support"),
+    TermCapability(:code_set_init,             :csin,     "Init sequence for multiple codesets"),
+    TermCapability(:set0_des_seq,              :s0ds,     "Shift to codeset 0 (EUC set 0, ASCII)"),
+    TermCapability(:set1_des_seq,              :s1ds,     "Shift to codeset 1"),
+    TermCapability(:set2_des_seq,              :s2ds,     "Shift to codeset 2"),
+    TermCapability(:set3_des_seq,              :s3ds,     "Shift to codeset 3"),
+    TermCapability(:set_lr_margin,             :smglr,    "Set both left and right margins to #1, #2.  (ML is not in BSD termcap)."),
+    TermCapability(:set_tb_margin,             :smgtb,    "Sets both top and bottom margins to #1, #2"),
+    TermCapability(:bit_image_repeat,          :birep,    "Repeat bit image cell #1 #2 times"),
+    TermCapability(:bit_image_newline,         :binel,    "Move to next row of the bit image"),
+    TermCapability(:bit_image_carriage_return, :bicr,     "Move to beginning of same row"),
+    TermCapability(:color_names,               :colornm,  "Give name for color #1"),
+    TermCapability(:define_bit_image_region,   :defbi,    "Define rectangular bit image region"),
+    TermCapability(:end_bit_image_region,      :endbi,    "End a bit-image region"),
+    TermCapability(:set_color_band,            :setcolor, "Change to ribbon color #1"),
+    TermCapability(:set_page_length,           :slines,   "Set page length to #1 lines"),
+    TermCapability(:display_pc_char,           :dispc,    "Display PC character #1"),
+    TermCapability(:enter_pc_charset_mode,     :smpch,    "Enter PC character display mode"),
+    TermCapability(:exit_pc_charset_mode,      :rmpch,    "Exit PC character display mode"),
+    TermCapability(:enter_scancode_mode,       :smsc,     "Enter PC scancode mode"),
+    TermCapability(:exit_scancode_mode,        :rmsc,     "Exit PC scancode mode"),
+    TermCapability(:pc_term_options,           :pctrm,    "PC terminal options"),
+    TermCapability(:scancode_escape,           :scesc,    "Escape for scancode emulation"),
+    TermCapability(:alt_scancode_esc,          :scesa,    "Alternate escape for scancode emulation"),
+    TermCapability(:enter_horizontal_hl_mode,  :ehhlm,    "Enter horizontal highlight mode"),
+    TermCapability(:enter_left_hl_mode,        :elhlm,    "Enter left highlight mode"),
+    TermCapability(:enter_low_hl_mode,         :elohlm,   "Enter low highlight mode"),
+    TermCapability(:enter_right_hl_mode,       :erhlm,    "Enter right highlight mode"),
+    TermCapability(:enter_top_hl_mode,         :ethlm,    "Enter top highlight mode"),
+    TermCapability(:enter_vertical_hl_mode,    :evhlm,    "Enter vertical highlight mode"),
+    TermCapability(:set_a_attributes,          :sgr1,     "Define second set of video attributes #1-#6"),
+    TermCapability(:set_pglen_inch,            :slength,  "Set page length to #1 hundredth of an inch (some implementations use sL for termcap)."),
+    TermCapability(:termcap_init2,             :OTi2,     "secondary initialization string"),
+    TermCapability(:termcap_reset,             :OTrs,     "terminal reset string"),
+    TermCapability(:linefeed_if_not_lf,        :OTnl,     "use to move down"),
+    TermCapability(:backspace_if_not_bs,       :OTbc,     "move left, if not ^H"),
+    TermCapability(:other_non_function_keys,   :OTko,     "list of self-mapped keycaps"),
+    TermCapability(:arrow_key_map,             :OTma,     "map motion-keys for vi version 2"),
+    TermCapability(:acs_ulcorner,              :OTG2,     "single upper left"),
+    TermCapability(:acs_llcorner,              :OTG3,     "single lower left"),
+    TermCapability(:acs_urcorner,              :OTG1,     "single upper right"),
+    TermCapability(:acs_lrcorner,              :OTG4,     "single lower right"),
+    TermCapability(:acs_ltee,                  :OTGR,     "tee pointing right"),
+    TermCapability(:acs_rtee,                  :OTGL,     "tee pointing left"),
+    TermCapability(:acs_btee,                  :OTGU,     "tee pointing up"),
+    TermCapability(:acs_ttee,                  :OTGD,     "tee pointing down"),
+    TermCapability(:acs_hline,                 :OTGH,     "single horizontal line"),
+    TermCapability(:acs_vline,                 :OTGV,     "single vertical line"),
+    TermCapability(:acs_plus,                  :OTGC,     "single intersection"),
+    TermCapability(:memory_lock,               :meml,     "lock memory above cursor"),
+    TermCapability(:memory_unlock,             :memu,     "unlock memory"),
+    TermCapability(:box_chars_1,               :box1,     "box characters primary set"),
 ]

From 7782823126157762cd7547bd8244f56d40ce4d71 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 8 Feb 2024 03:56:20 +0800
Subject: [PATCH 0919/1315] Make aliases structurally distinct in TermInfo

---
 base/terminfo.jl | 26 ++++++++++++++++----------
 test/terminfo.jl | 12 ++++++------
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/base/terminfo.jl b/base/terminfo.jl
index ffbfe8acac976..f63b36d1bd3cd 100644
--- a/base/terminfo.jl
+++ b/base/terminfo.jl
@@ -66,9 +66,10 @@ struct TermInfo
     numbers::Dict{Symbol, Int}
     strings::Dict{Symbol, String}
     extensions::Union{Nothing, Set{Symbol}}
+    aliases::Dict{Symbol, Symbol}
 end
 
-TermInfo() = TermInfo([], Dict(), Dict(), Dict(), nothing)
+TermInfo() = TermInfo([], Dict(), Dict(), Dict(), nothing, Dict())
 
 function read(data::IO, ::Type{TermInfoRaw})
     # Parse according to `term(5)`
@@ -175,19 +176,20 @@ function TermInfo(raw::TermInfoRaw)
     flags = Dict{Symbol, Bool}()
     numbers = Dict{Symbol, Int}()
     strings = Dict{Symbol, String}()
+    aliases = Dict{Symbol, Symbol}()
     extensions = nothing
     for (flag, value) in zip(TERM_FLAGS, raw.flags)
-        flags[flag.capname] = value
         flags[flag.name] = value
+        aliases[flag.capname] = flag.name
     end
     for (num, value) in zip(TERM_NUMBERS, raw.numbers)
-        numbers[num.capname] = Int(value)
         numbers[num.name] = Int(value)
+        aliases[num.capname] = num.name
     end
     for (str, value) in zip(TERM_STRINGS, raw.strings)
         if !isnothing(value)
-            strings[str.capname] = value
             strings[str.name] = value
+            aliases[str.capname] = str.name
         end
     end
     if !isnothing(raw.extended)
@@ -201,26 +203,30 @@ function TermInfo(raw::TermInfoRaw)
             elseif value isa String
                 strings[key] = value
             end
+            if !isnothing(long)
+                aliases[short] = long
+            end
         end
     end
-    TermInfo(raw.names, flags, numbers, strings, extensions)
+    TermInfo(raw.names, flags, numbers, strings, extensions, aliases)
 end
 
-get(ti::TermInfo, key::Symbol, default::Bool) = get(ti.flags, key, default)
-get(ti::TermInfo, key::Symbol, default::Int) = get(ti.numbers, key, default)
-get(ti::TermInfo, key::Symbol, default::String) = get(ti.strings, key, default)
+get(ti::TermInfo, key::Symbol, default::Bool)   = get(ti.flags,   get(ti.aliases, key, key), default)
+get(ti::TermInfo, key::Symbol, default::Int)    = get(ti.numbers, get(ti.aliases, key, key), default)
+get(ti::TermInfo, key::Symbol, default::String) = get(ti.strings, get(ti.aliases, key, key), default)
 
 haskey(ti::TermInfo, key::Symbol) =
-    haskey(ti.flags, key) || haskey(ti.numbers, key) || haskey(ti.strings, key)
+    haskey(ti.flags, key) || haskey(ti.numbers, key) || haskey(ti.strings, key) || haskey(ti.aliases, key)
 
 function getindex(ti::TermInfo, key::Symbol)
     haskey(ti.flags, key) && return ti.flags[key]
     haskey(ti.numbers, key) && return ti.numbers[key]
     haskey(ti.strings, key) && return ti.strings[key]
+    haskey(ti.aliases, key) && return getindex(ti, ti.aliases[key])
     throw(KeyError(key))
 end
 
-keys(ti::TermInfo) = keys(ti.flags) ∪ keys(ti.numbers) ∪ keys(ti.strings)
+keys(ti::TermInfo) = keys(ti.flags) ∪ keys(ti.numbers) ∪ keys(ti.strings) ∪ keys(ti.aliases)
 
 function show(io::IO, ::MIME"text/plain", ti::TermInfo)
     print(io, "TermInfo(", ti.names, "; ", length(ti.flags), " flags, ",
diff --git a/test/terminfo.jl b/test/terminfo.jl
index 809b0374ad3e1..a598b0802254f 100644
--- a/test/terminfo.jl
+++ b/test/terminfo.jl
@@ -889,9 +889,9 @@ let
 @testset "terminfo" begin
     dumb = Base.TermInfo(read(IOBuffer(dumb_terminfo), Base.TermInfoRaw))
     @test dumb.names == ["dumb", "80-column dumb tty"]
-    @test length(dumb.flags) == 4
-    @test length(dumb.numbers) == 2
-    @test length(dumb.strings) == 8
+    @test length(dumb.flags) == 2
+    @test length(dumb.numbers) == 1
+    @test length(dumb.strings) == 4
     @test isnothing(dumb.extensions)
     for (key, value) in dumb_capabilities
         @test dumb[key] == value
@@ -899,9 +899,9 @@ let
 
     xterm = Base.TermInfo(read(IOBuffer(xterm_terminfo), Base.TermInfoRaw))
     @test xterm.names == ["xterm", "xterm terminal emulator (X Window System)"]
-    @test length(xterm.flags) == 78
-    @test length(xterm.numbers) == 29
-    @test length(xterm.strings) == 432
+    @test length(xterm.flags) == 40
+    @test length(xterm.numbers) == 15
+    @test length(xterm.strings) == 253
     @test sort(xterm.extensions |> collect) == sort(xterm_extensions)
     for (key, value) in xterm_capabilities
         @test xterm[key] == value

From 38065a409942eb486e66db999f28531fa912c4cc Mon Sep 17 00:00:00 2001
From: Aiden Grossman <agrossman154@yahoo.com>
Date: Mon, 12 Feb 2024 20:26:46 -0800
Subject: [PATCH 0920/1315] Set LLVM issue tracker URL to Julia's issue tracker
 (#53128)

This patch sets the default issue tracker URL for LLVM to Julia's issue
tracker. LLVM issues coming from Julia should probably go through
Julia's issue tracker first and then can be reported upstream if there
is an issue with something in upstream LLVM. Having this set to the
default is moderately confusing for users as it refers to the LLVM issue
tracker, which probably isn't wanted.
---
 deps/llvm.mk | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/deps/llvm.mk b/deps/llvm.mk
index 18dab5dbceb30..3e3ea4e79c24e 100644
--- a/deps/llvm.mk
+++ b/deps/llvm.mk
@@ -210,6 +210,9 @@ LLVM_CMAKE += -DCMAKE_EXE_LINKER_FLAGS="$(LLVM_LDFLAGS)" \
 LLVM_CMAKE += -DLLVM_VERSION_SUFFIX:STRING="jl"
 LLVM_CMAKE += -DLLVM_SHLIB_SYMBOL_VERSION:STRING="JL_LLVM_$(LLVM_VER_SHORT)"
 
+# Change the default bug report URL to Julia's issue tracker
+LLVM_CMAKE += -DBUG_REPORT_URL="https://github.com/julialang/julia"
+
 # Apply version-specific LLVM patches sequentially
 LLVM_PATCH_PREV :=
 define LLVM_PATCH

From 003172d63afb5ea3fcf532eac7a5caabe3fad0ae Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Thu, 8 Feb 2024 03:56:53 +0800
Subject: [PATCH 0921/1315] Add user-aliases to TermInfo

---
 base/terminfo.jl      |   5 +-
 base/terminfo_data.jl | 174 +++++++++++++++++++++++++++++++++++++++++-
 test/terminfo.jl      |  36 +++++++--
 3 files changed, 203 insertions(+), 12 deletions(-)

diff --git a/base/terminfo.jl b/base/terminfo.jl
index f63b36d1bd3cd..6f1d1ca8015f0 100644
--- a/base/terminfo.jl
+++ b/base/terminfo.jl
@@ -194,7 +194,10 @@ function TermInfo(raw::TermInfoRaw)
     end
     if !isnothing(raw.extended)
         extensions = Set{Symbol}()
-        for (key, value) in raw.extended
+        longalias(key, value) = first(get(TERM_USER, (typeof(value), key), (nothing, "")))
+        for (short, value) in raw.extended
+            long = longalias(short, value)
+            key = something(long, short)
             push!(extensions, key)
             if value isa Bool
                 flags[key] = value
diff --git a/base/terminfo_data.jl b/base/terminfo_data.jl
index 39d1ef1d4d86e..54d6e988aa2bb 100644
--- a/base/terminfo_data.jl
+++ b/base/terminfo_data.jl
@@ -41,12 +41,15 @@ end
 using Downloads
 
 standard_caps = IOBuffer()
+user_caps = IOBuffer()
 
 Downloads.download("https://raw.githubusercontent.com/mirror/ncurses/v$NCURSES_VERSION/include/Caps", standard_caps)
+Downloads.download("https://raw.githubusercontent.com/mirror/ncurses/v$NCURSES_VERSION/include/Caps-ncurses", user_caps)
 
-const TERM_FLAGS = Tuple{String, String, String}[]
-const TERM_NUMBERS = Tuple{String, String, String}[]
-const TERM_STRINGS = Tuple{String, String, String}[]
+const TERM_FLAGS   = NTuple{3, String}[]
+const TERM_NUMBERS = NTuple{3, String}[]
+const TERM_STRINGS = NTuple{3, String}[]
+const TERM_USER    = NTuple{3, String}[]
 
 for line in eachline(seekstart(standard_caps))
     startswith(line, '#') && continue
@@ -66,6 +69,31 @@ for line in eachline(seekstart(standard_caps))
     push!(caplist, (name, shortcode, description))
 end
 
+for line in eachline(seekstart(user_caps))
+    startswith(line, '#') && continue
+    !startswith(line, "userdef") && continue
+    line = line[1+ncodeunits("userdef "):end]
+    components = split(line, '\t', keepempty=false)
+    if length(components) ∉ 4:5
+        @warn "Malformed line: $(sprint(show, line))"
+        continue
+    end
+    code, type, _, description, _... = components
+    if code == "xm"
+        components[3] == "-" || continue
+        description = "mouse response"
+    end
+    dtype = get(Dict("bool" => "Bool", "num" => "Int", "str" => "String"), type, nothing)
+    if isnothing(dtype)
+        @warn "Unrecognised data type: $type"
+        continue
+    end
+    push!(TERM_USER, (dtype, code, description))
+end
+
+push!(TERM_USER, ("Bool", "Tc", "tmux extension to indicate 24-bit truecolor support"))
+push!(TERM_USER, ("Bool", "Su", "kitty extension to indicate styled underline support"))
+
 const SENTINEL = "\n## GENERATED CODE BEYOND THIS POINT ##"
 const PREAMBLE = readuntil(__FILE__, SENTINEL, keep=true)
 
@@ -87,6 +115,37 @@ for (ftype, list) in [("flag", TERM_FLAGS), ("number", TERM_NUMBERS), ("string",
     println(out, "\n]")
 end
 
+function getcustomalias(allterms::Vector{NTuple{3, String}}, type, short, description)
+    specific_aliases = Dict{String, String}(
+        "smxx"  => ":enter_strikeout_mode",
+        "rmxx"  => ":exit_strikeout_mode",
+        "Smol"  => ":enter_overline_mode",
+        "Rmol"  => ":exit_overline_mode",
+        "Cs"    => ":set_cursor_color",
+        "Cr"    => ":reset_cursor_color",
+        "Ss"    => ":set_cursor_style",
+        "Se"    => ":reset_cursor_style",
+        "Smulx" => ":set_underline_style",
+        "Su"    => ":can_style_underline",
+        "csl"   => ":clear_status_line",
+        "Ms"    => ":set_host_clipboard",
+        "Tc"    => ":truecolor")
+    if startswith(short, 'k') && !occursin("keypad", description)
+        return ":key_" * replace(lowercase(description), r"[^a-z]" => '_')
+    end
+    return get(specific_aliases, short, "nothing")
+end
+
+print(out, "\n\"\"\"\nTerminfo extensions that NCurses $NCURSES_VERSION is aware of.\n\"\"\"",
+           "\nconst TERM_USER = Dict{Tuple{DataType, Symbol}, Union{Tuple{Nothing, String}, Tuple{Symbol, String}}}(")
+shortpad = maximum(textwidth, getindex.(TERM_USER, 2)) + 1
+for (type, short, description) in TERM_USER
+    print(out, "\n    ($(rpad(type * ',', 7)) :$short)", ' '^(shortpad - textwidth(short)),
+          "=> (", getcustomalias(TERM_USER, type, short, description), ", \"",
+          escape_string(description), "\"),")
+end
+println(out, "\n)")
+
 open(io -> write(io, seekstart(out)), __FILE__, "w")
 
 end
@@ -610,3 +669,112 @@ const TERM_STRINGS = [
     TermCapability(:memory_unlock,             :memu,     "unlock memory"),
     TermCapability(:box_chars_1,               :box1,     "box characters primary set"),
 ]
+
+"""
+Terminfo extensions that NCurses 6.3 is aware of.
+"""
+const TERM_USER = Dict{Tuple{DataType, Symbol}, Union{Tuple{Nothing, String}, Tuple{Symbol, String}}}(
+    (Int,    :CO )    => (nothing, "number of indexed colors overlaying RGB space"),
+    (String, :E3)     => (nothing, "clears the terminal's scrollback buffer."),
+    (Bool,   :NQ)     => (nothing, "terminal does not support query/response"),
+    (Bool,   :RGB)    => (nothing, "use direct colors with 1/3 of color-pair bits per color."),
+    (Int,    :RGB)    => (nothing, "use direct colors with given number of bits per color."),
+    (String, :RGB)    => (nothing, "use direct colors with given bit-layout."),
+    (String, :TS)     => (nothing, "like \"tsl\", but uses no parameter."),
+    (Int,    :U8)     => (nothing, "terminal does/does not support VT100 SI/SO when processing UTF-8 encoding."),
+    (String, :XM)     => (nothing, "initialize alternate xterm mouse mode"),
+    (String, :grbom)  => (nothing, "disable real bold (not intensity bright) mode."),
+    (String, :gsbom)  => (nothing, "enable real bold (not intensity bright) mode."),
+    (String, :xm)     => (nothing, "mouse response"),
+    (String, :Rmol)   => (:exit_overline_mode, "remove overline-mode"),
+    (String, :Smol)   => (:enter_overline_mode, "set overline-mode"),
+    (String, :blink2) => (nothing, "turn on rapid blinking"),
+    (String, :norm)   => (nothing, "turn off bold and half-bright mode"),
+    (String, :opaq)   => (nothing, "turn off blank mode"),
+    (String, :setal)  => (nothing, "set underline-color"),
+    (String, :smul2)  => (nothing, "begin double underline mode"),
+    (Bool,   :AN)     => (nothing, "turn on autonuke."),
+    (Bool,   :AX)     => (nothing, "understands ANSI set default fg/bg color (\\E[39m / \\E[49m)."),
+    (String, :C0)     => (nothing, "use the string as a conversion table for font '0', like acsc."),
+    (Bool,   :C8)     => (nothing, "terminal shows bold as high-intensity colors."),
+    (String, :CE)     => (nothing, "switch cursor-keys back to normal mode."),
+    (String, :CS)     => (nothing, "switch cursor-keys to application mode."),
+    (String, :E0)     => (nothing, "switch charset 'G0' back to standard charset. Default is '\\E(B'."),
+    (Bool,   :G0)     => (nothing, "terminal can deal with ISO 2022 font selection sequences."),
+    (String, :KJ)     => (nothing, "set the encoding of the terminal."),
+    (Int,    :OL)     => (nothing, "set the screen program's output buffer limit."),
+    (String, :S0)     => (nothing, "switch charset 'G0' to the specified charset. Default is '\\E(%.'."),
+    (Bool,   :TF)     => (nothing, "add missing capabilities to screen's termcap/info entry. (Set by default)."),
+    (String, :WS)     => (nothing, "resize display. This capability has the desired width and height as arguments. SunView(tm) example: '\\E[8;%d;%dt'."),
+    (String, :XC)     => (nothing, "describe a translation of characters to strings depending on the current font."),
+    (Bool,   :XT)     => (nothing, "terminal understands special xterm sequences (OSC, mouse tracking)."),
+    (String, :Z0)     => (nothing, "change width to 132 columns."),
+    (String, :Z1)     => (nothing, "change width to 80 columns."),
+    (String, :Cr)     => (:reset_cursor_color, "restore the default cursor color."),
+    (String, :Cs)     => (:set_cursor_color, "set the cursor color."),
+    (String, :Csr)    => (nothing, "change the cursor style, overriding Ss."),
+    (String, :Ms)     => (:set_host_clipboard, "store the current buffer in the host terminal's selection (clipboard)."),
+    (String, :Se)     => (:reset_cursor_style, "reset the cursor style to the terminal initial state."),
+    (String, :Smulx)  => (:set_underline_style, "modify the appearance of underlines in VTE."),
+    (String, :Ss)     => (:set_cursor_style, "change the cursor style."),
+    (String, :rmxx)   => (:exit_strikeout_mode, "reset ECMA-48 strikeout/crossed-out attributes."),
+    (String, :smxx)   => (:enter_strikeout_mode, "set ECMA-48 strikeout/crossed-out attributes."),
+    (String, :csl)    => (:clear_status_line, "clear status line"),
+    (String, :kDC3)   => (:key_alt_delete_character, "alt delete-character"),
+    (String, :kDC4)   => (:key_shift_alt_delete_character, "shift+alt delete-character"),
+    (String, :kDC5)   => (:key_control_delete_character, "control delete-character"),
+    (String, :kDC6)   => (:key_shift_control_delete_character, "shift+control delete-character"),
+    (String, :kDC7)   => (:key_alt_control_delete_character, "alt+control delete-character"),
+    (String, :kDN)    => (:key_shift_down_cursor, "shift down-cursor"),
+    (String, :kDN3)   => (:key_alt_down_cursor, "alt down-cursor"),
+    (String, :kDN4)   => (:key_shift_alt_down_cursor, "shift+alt down-cursor"),
+    (String, :kDN5)   => (:key_control_down_cursor, "control down-cursor"),
+    (String, :kDN6)   => (:key_shift_control_down_cursor, "shift+control down-cursor"),
+    (String, :kDN7)   => (:key_alt_control_down_cursor, "alt+control down-cursor"),
+    (String, :kEND3)  => (:key_alt_end, "alt end"),
+    (String, :kEND4)  => (:key_shift_alt_end, "shift+alt end"),
+    (String, :kEND5)  => (:key_control_end, "control end"),
+    (String, :kEND6)  => (:key_shift_control_end, "shift+control end"),
+    (String, :kEND7)  => (:key_alt_control_end, "alt+control end"),
+    (String, :kHOM3)  => (:key_alt_home, "alt home"),
+    (String, :kHOM4)  => (:key_shift_alt_home, "shift+alt home"),
+    (String, :kHOM5)  => (:key_control_home, "control home"),
+    (String, :kHOM6)  => (:key_shift_control_home, "shift+control home"),
+    (String, :kHOM7)  => (:key_alt_control_home, "alt+control home"),
+    (String, :kIC3)   => (:key_alt_insert_character, "alt insert-character"),
+    (String, :kIC4)   => (:key_shift_alt_insert_character, "shift+alt insert-character"),
+    (String, :kIC5)   => (:key_control_insert_character, "control insert-character"),
+    (String, :kIC6)   => (:key_shift_control_insert_character, "shift+control insert-character"),
+    (String, :kIC7)   => (:key_alt_control_insert_character, "alt+control insert-character"),
+    (String, :kLFT3)  => (:key_alt_left_cursor, "alt left-cursor"),
+    (String, :kLFT4)  => (:key_shift_alt_left_cursor, "shift+alt left-cursor"),
+    (String, :kLFT5)  => (:key_control_left_cursor, "control left-cursor"),
+    (String, :kLFT6)  => (:key_shift_control_left_cursor, "shift+control left-cursor"),
+    (String, :kLFT7)  => (:key_alt_control_left_cursor, "alt+control left-cursor"),
+    (String, :kNXT3)  => (:key_alt_next, "alt next"),
+    (String, :kNXT4)  => (:key_shift_alt_next, "shift+alt next"),
+    (String, :kNXT5)  => (:key_control_next, "control next"),
+    (String, :kNXT6)  => (:key_shift_control_next, "shift+control next"),
+    (String, :kNXT7)  => (:key_alt_control_next, "alt+control next"),
+    (String, :kPRV3)  => (:key_alt_previous, "alt previous"),
+    (String, :kPRV4)  => (:key_shift_alt_previous, "shift+alt previous"),
+    (String, :kPRV5)  => (:key_control_previous, "control previous"),
+    (String, :kPRV6)  => (:key_shift_control_previous, "shift+control previous"),
+    (String, :kPRV7)  => (:key_alt_control_previous, "alt+control previous"),
+    (String, :kRIT3)  => (:key_alt_right_cursor, "alt right-cursor"),
+    (String, :kRIT4)  => (:key_shift_alt_right_cursor, "shift+alt right-cursor"),
+    (String, :kRIT5)  => (:key_control_right_cursor, "control right-cursor"),
+    (String, :kRIT6)  => (:key_shift_control_right_cursor, "shift+control right-cursor"),
+    (String, :kRIT7)  => (:key_alt_control_right_cursor, "alt+control right-cursor"),
+    (String, :kUP)    => (:key_shift_up_cursor, "shift up-cursor"),
+    (String, :kUP3)   => (:key_alt_up_cursor, "alt up-cursor"),
+    (String, :kUP4)   => (:key_shift_alt_up_cursor, "shift+alt up-cursor"),
+    (String, :kUP5)   => (:key_control_up_cursor, "control up-cursor"),
+    (String, :kUP6)   => (:key_shift_control_up_cursor, "shift+control up-cursor"),
+    (String, :kUP7)   => (:key_alt_control_up_cursor, "alt+control up-cursor"),
+    (String, :ka2)    => (nothing, "vt220-keypad extensions"),
+    (String, :kb1)    => (nothing, "vt220-keypad extensions"),
+    (String, :kb3)    => (nothing, "vt220-keypad extensions"),
+    (String, :kc2)    => (nothing, "vt220-keypad extensions"),
+    (Bool,   :Tc)     => (:truecolor, "tmux extension to indicate 24-bit truecolor support"),
+)
diff --git a/test/terminfo.jl b/test/terminfo.jl
index a598b0802254f..07aa21704fef5 100644
--- a/test/terminfo.jl
+++ b/test/terminfo.jl
@@ -356,14 +356,34 @@ let
         0x73, 0x6d, 0x78, 0x78, 0x00, 0x78, 0x6d, 0x00]
 
     xterm_extensions =
-        [:kEND5, :Cs, :kDN5, :Cr, :kDC6, :kPRV6, :kDN7, :kb1, :kpZRO, :kNXT6,
-        :kLFT5, :kPRV3, :kRIT4, :kDC4, :kc2, :kp5, :kLFT6, :kIC6, :kEND6, :kIC4,
-        :kRIT7, :rmxx, :kpADD, :xm, :kNXT3, :XT, :kIC7, :kHOM4, :kDC7, :kPRV7,
-        :ka2, :kUP7, :kDN6, :kIC5, :kNXT4, :kUP5, :AX, :kpSUB, :kb3, :kDN4,
-        :kHOM5, :kHOM6, :kDN3, :kLFT4, :kRIT5, :kIC3, :kPRV4, :kUP, :kRIT6, :E3,
-        :kEND3, :kHOM7, :kDC3, :kLFT7, :kNXT5, :Se, :Ss, :kHOM3, :kRIT3, :kNXT7,
-        :smxx, :kEND4, :kDN, :kUP6, :XM, :kPRV5, :kUP4, :kpDOT, :kpMUL, :kEND7,
-        :Ms, :kpCMA, :kDC5, :kLFT3, :kpDIV, :kUP3]
+        [:AX, :E3, :XM, :XT, :enter_strikeout_mode, :exit_strikeout_mode, :ka2,
+         :kb1, :kb3, :kc2, :key_alt_control_delete_character,
+         :key_alt_control_down_cursor, :key_alt_control_end,
+         :key_alt_control_home, :key_alt_control_insert_character,
+         :key_alt_control_left_cursor, :key_alt_control_next,
+         :key_alt_control_previous, :key_alt_control_right_cursor,
+         :key_alt_control_up_cursor, :key_alt_delete_character,
+         :key_alt_down_cursor, :key_alt_end, :key_alt_home,
+         :key_alt_insert_character, :key_alt_left_cursor, :key_alt_next,
+         :key_alt_previous, :key_alt_right_cursor, :key_alt_up_cursor,
+         :key_control_delete_character, :key_control_down_cursor,
+         :key_control_end, :key_control_home, :key_control_insert_character,
+         :key_control_left_cursor, :key_control_next, :key_control_previous,
+         :key_control_right_cursor, :key_control_up_cursor,
+         :key_shift_alt_delete_character, :key_shift_alt_down_cursor,
+         :key_shift_alt_end, :key_shift_alt_home,
+         :key_shift_alt_insert_character, :key_shift_alt_left_cursor,
+         :key_shift_alt_next, :key_shift_alt_previous,
+         :key_shift_alt_right_cursor, :key_shift_alt_up_cursor,
+         :key_shift_control_delete_character, :key_shift_control_down_cursor,
+         :key_shift_control_end, :key_shift_control_home,
+         :key_shift_control_insert_character, :key_shift_control_left_cursor,
+         :key_shift_control_next, :key_shift_control_previous,
+         :key_shift_control_right_cursor, :key_shift_control_up_cursor,
+         :key_shift_down_cursor, :key_shift_up_cursor, :kp5, :kpADD, :kpCMA,
+         :kpDIV, :kpDOT, :kpMUL, :kpSUB, :kpZRO, :reset_cursor_color,
+         :reset_cursor_style, :set_cursor_color, :set_cursor_style,
+         :set_host_clipboard, :xm]
 
     xterm_capabilities = Dict{Symbol, Union{Bool, Int, String}}(
         :AX => true,

From 1a76ed4d95a293676df3fc7957bcdbb0e0b38b70 Mon Sep 17 00:00:00 2001
From: TEC <git@tecosaur.net>
Date: Tue, 13 Feb 2024 12:24:55 +0800
Subject: [PATCH 0922/1315] Change terminfo update logic, and update

Using the tagged releases in the ncurses repository isn't actually a
good idea, since it fails to capture the patch releases made
subsequently.

Instead, we switch to grabbing the latest version and recording which
patch release it is. Normally, there would be a danger of grabbing
un-released changes, however this doesn't seem like an actual risk in
this case given how the ncurses repo seems to operate.
---
 base/terminfo_data.jl | 48 ++++++++++++++++++++++++++++---------------
 1 file changed, 32 insertions(+), 16 deletions(-)

diff --git a/base/terminfo_data.jl b/base/terminfo_data.jl
index 54d6e988aa2bb..caf2ff528d3e1 100644
--- a/base/terminfo_data.jl
+++ b/base/terminfo_data.jl
@@ -10,11 +10,6 @@ awk '/^#=run/{flag=1;next}/=#/{flag=0}flag{gsub(/__FILE__/,"\"'"$0"'\"");print}'
   julia --startup-file=no -E 'readchomp("/dev/fd/0") |> Meta.parse |> eval' && echo "Done"; exit
 =#
 
-#=run
-begin
-const NCURSES_VERSION = "6.3"
-=#
-
 """
     struct TermCapability
 
@@ -38,19 +33,25 @@ struct TermCapability
 end
 
 #=run
+begin
+
 using Downloads
 
+version_info = IOBuffer()
 standard_caps = IOBuffer()
 user_caps = IOBuffer()
 
-Downloads.download("https://raw.githubusercontent.com/mirror/ncurses/v$NCURSES_VERSION/include/Caps", standard_caps)
-Downloads.download("https://raw.githubusercontent.com/mirror/ncurses/v$NCURSES_VERSION/include/Caps-ncurses", user_caps)
+Downloads.download("https://raw.githubusercontent.com/mirror/ncurses/master/VERSION", version_info)
+Downloads.download("https://raw.githubusercontent.com/mirror/ncurses/master/include/Caps", standard_caps)
+Downloads.download("https://raw.githubusercontent.com/mirror/ncurses/master/include/Caps-ncurses", user_caps)
 
 const TERM_FLAGS   = NTuple{3, String}[]
 const TERM_NUMBERS = NTuple{3, String}[]
 const TERM_STRINGS = NTuple{3, String}[]
 const TERM_USER    = NTuple{3, String}[]
 
+_, ncurses_version, ncurses_date = split(read(seekstart(version_info), String))
+
 for line in eachline(seekstart(standard_caps))
     startswith(line, '#') && continue
     components = split(line, '\t', keepempty=false)
@@ -98,11 +99,12 @@ const SENTINEL = "\n## GENERATED CODE BEYOND THIS POINT ##"
 const PREAMBLE = readuntil(__FILE__, SENTINEL, keep=true)
 
 out = IOBuffer()
-write(out, PREAMBLE, "\n\n# Terminfo Capabilities as of NCurses $NCURSES_VERSION\n")
+write(out, PREAMBLE, "\n\n# Terminfo Capabilities as of NCurses $ncurses_version-$ncurses_date\n",
+      "const NCURSES_VERSION = v\"$ncurses_version.$ncurses_date\"\n")
 
 for (ftype, list) in [("flag", TERM_FLAGS), ("number", TERM_NUMBERS), ("string", TERM_STRINGS)]
     print(out, "\n\"\"\"\n\
-          Ordered list of known terminal capability $ftype fields, as of NCurses $NCURSES_VERSION.\n\
+          Ordered list of known terminal capability $ftype fields, as of NCurses $ncurses_version-$ncurses_date.\n\
           \"\"\"\n\
           const TERM_$(uppercase(ftype))S = [")
     namepad = maximum(textwidth, getindex.(list, 1)) + 1
@@ -129,14 +131,15 @@ function getcustomalias(allterms::Vector{NTuple{3, String}}, type, short, descri
         "Su"    => ":can_style_underline",
         "csl"   => ":clear_status_line",
         "Ms"    => ":set_host_clipboard",
-        "Tc"    => ":truecolor")
+        "Tc"    => ":truecolor",
+        "XF"    => ":xterm_focus")
     if startswith(short, 'k') && !occursin("keypad", description)
         return ":key_" * replace(lowercase(description), r"[^a-z]" => '_')
     end
     return get(specific_aliases, short, "nothing")
 end
 
-print(out, "\n\"\"\"\nTerminfo extensions that NCurses $NCURSES_VERSION is aware of.\n\"\"\"",
+print(out, "\n\"\"\"\nTerminfo extensions that NCurses $ncurses_version-$ncurses_date is aware of.\n\"\"\"",
            "\nconst TERM_USER = Dict{Tuple{DataType, Symbol}, Union{Tuple{Nothing, String}, Tuple{Symbol, String}}}(")
 shortpad = maximum(textwidth, getindex.(TERM_USER, 2)) + 1
 for (type, short, description) in TERM_USER
@@ -153,10 +156,11 @@ end
 
 ## GENERATED CODE BEYOND THIS POINT ##
 
-# Terminfo Capabilities as of NCurses 6.3
+# Terminfo Capabilities as of NCurses 6.4-20230311
+const NCURSES_VERSION = v"6.4.20230311"
 
 """
-Ordered list of known terminal capability flag fields, as of NCurses 6.3.
+Ordered list of known terminal capability flag fields, as of NCurses 6.4-20230311.
 """
 const TERM_FLAGS = [
     TermCapability(:auto_left_margin,         :bw,    "cub1 wraps from column 0 to last column"),
@@ -206,7 +210,7 @@ const TERM_FLAGS = [
 ]
 
 """
-Ordered list of known terminal capability number fields, as of NCurses 6.3.
+Ordered list of known terminal capability number fields, as of NCurses 6.4-20230311.
 """
 const TERM_NUMBERS = [
     TermCapability(:columns,                 :cols,   "number of columns in a line"),
@@ -251,7 +255,7 @@ const TERM_NUMBERS = [
 ]
 
 """
-Ordered list of known terminal capability string fields, as of NCurses 6.3.
+Ordered list of known terminal capability string fields, as of NCurses 6.4-20230311.
 """
 const TERM_STRINGS = [
     TermCapability(:back_tab,                  :cbt,      "back tab (P)"),
@@ -671,7 +675,7 @@ const TERM_STRINGS = [
 ]
 
 """
-Terminfo extensions that NCurses 6.3 is aware of.
+Terminfo extensions that NCurses 6.4-20230311 is aware of.
 """
 const TERM_USER = Dict{Tuple{DataType, Symbol}, Union{Tuple{Nothing, String}, Tuple{Symbol, String}}}(
     (Int,    :CO )    => (nothing, "number of indexed colors overlaying RGB space"),
@@ -719,6 +723,15 @@ const TERM_USER = Dict{Tuple{DataType, Symbol}, Union{Tuple{Nothing, String}, Tu
     (String, :Ss)     => (:set_cursor_style, "change the cursor style."),
     (String, :rmxx)   => (:exit_strikeout_mode, "reset ECMA-48 strikeout/crossed-out attributes."),
     (String, :smxx)   => (:enter_strikeout_mode, "set ECMA-48 strikeout/crossed-out attributes."),
+    (String, :BD)     => (nothing, "disables bracketed paste"),
+    (String, :BE)     => (nothing, "enables bracketed paste"),
+    (String, :PE)     => (nothing, "is sent after pasted text"),
+    (String, :PS)     => (nothing, "is sent before pasted text"),
+    (String, :RV)     => (nothing, "report terminal secondary device attributes"),
+    (String, :XR)     => (nothing, "report terminal version as a free-format string."),
+    (Bool,   :XF)     => (:xterm_focus, "terminal supports xterm focus in/out"),
+    (String, :rv)     => (nothing, "response to RV, regular expression"),
+    (String, :xr)     => (nothing, "response to XR, regular expression"),
     (String, :csl)    => (:clear_status_line, "clear status line"),
     (String, :kDC3)   => (:key_alt_delete_character, "alt delete-character"),
     (String, :kDC4)   => (:key_shift_alt_delete_character, "shift+alt delete-character"),
@@ -776,5 +789,8 @@ const TERM_USER = Dict{Tuple{DataType, Symbol}, Union{Tuple{Nothing, String}, Tu
     (String, :kb1)    => (nothing, "vt220-keypad extensions"),
     (String, :kb3)    => (nothing, "vt220-keypad extensions"),
     (String, :kc2)    => (nothing, "vt220-keypad extensions"),
+    (String, :kxIN)   => (:key_mouse_response_on_focus_in, "mouse response on focus-in"),
+    (String, :kxOUT)  => (:key_mouse_response_on_focus_out, "mouse response on focus-out"),
     (Bool,   :Tc)     => (:truecolor, "tmux extension to indicate 24-bit truecolor support"),
+    (Bool,   :Su)     => (:can_style_underline, "kitty extension to indicate styled underline support"),
 )

From d211398479aaf94e5f9bc2ab6a965feb2c90b0fd Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Tue, 13 Feb 2024 04:43:21 -0800
Subject: [PATCH 0923/1315] Fix FileWatching tests on FreeBSD (#53307)

#49937 optimistically enabled some file watcher tests on FreeBSD due to
changes made in libuv that suggested it should work, but unfortunately
it does not.
---
 stdlib/FileWatching/test/runtests.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stdlib/FileWatching/test/runtests.jl b/stdlib/FileWatching/test/runtests.jl
index b9ad8d9bc7777..2592aea024386 100644
--- a/stdlib/FileWatching/test/runtests.jl
+++ b/stdlib/FileWatching/test/runtests.jl
@@ -161,7 +161,7 @@ test2_12992()
 #######################################################################
 # This section tests file watchers.                                   #
 #######################################################################
-F_GETPATH = Sys.islinux() || Sys.iswindows() || Sys.isapple() || Sys.isfreebsd() # platforms where F_GETPATH is available
+F_GETPATH = Sys.islinux() || Sys.iswindows() || Sys.isapple() # platforms where F_GETPATH is available
 F_PATH = F_GETPATH ? "afile.txt" : ""
 dir = mktempdir()
 file = joinpath(dir, "afile.txt")
@@ -276,7 +276,7 @@ function test_dirmonitor_wait(tval)
             end
         end
         fname, events = wait(fm)::Pair
-        @test fname == F_PATH
+        @test fname == basename(file)
         @test events.changed && !events.timedout && !events.renamed
         close(fm)
     end

From 81c34742ee428174a2659a131304c4c5f592921a Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 13 Feb 2024 09:45:02 -0500
Subject: [PATCH 0924/1315] Revert "More consistent return value for
 annotations" (#53309)

Reverts JuliaLang/julia#53281 as it appears to have broken CI on all
subsequent commits:
https://github.com/JuliaLang/julia/pull/53281#issuecomment-1938071915

According to the CI logs, it is this test that aborts early on in the
rr-trace log:
```
Pkg.test(TEST_PKG.name; coverage = coverage_path)
```
---
 base/strings/annotated.jl                     | 20 ++++++++-----------
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 stdlib/StyledStrings.version                  |  2 +-
 6 files changed, 11 insertions(+), 15 deletions(-)
 create mode 100644 deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
 delete mode 100644 deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index f458c641f3b7f..86790d169420e 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -153,7 +153,7 @@ lastindex(s::AnnotatedString) = lastindex(s.string)
 function getindex(s::AnnotatedString, i::Integer)
     @boundscheck checkbounds(s, i)
     @inbounds if isvalid(s, i)
-        AnnotatedChar(s.string[i], map(last, annotations(s, i)))
+        AnnotatedChar(s.string[i], annotations(s, i))
     else
         string_index_err(s, i)
     end
@@ -354,16 +354,12 @@ annotate!(c::AnnotatedChar, @nospecialize(labelval::Pair{Symbol, <:Any})) =
     (push!(c.annotations, labelval); c)
 
 """
-    annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
-                [position::Union{Integer, UnitRange}]) ->
-        Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
+    annotations(str::AnnotatedString, [position::Union{Integer, UnitRange}])
+    annotations(str::SubString{AnnotatedString}, [position::Union{Integer, UnitRange}])
 
 Get all annotations that apply to `str`. Should `position` be provided, only
 annotations that overlap with `position` will be returned.
 
-Annotations are provided together with the regions they apply to, in the form of
-a vector of region–annotation tuples.
-
 See also: `annotate!`.
 """
 annotations(s::AnnotatedString) = s.annotations
@@ -373,22 +369,22 @@ annotations(s::SubString{<:AnnotatedString}) =
 
 function annotations(s::AnnotatedString, pos::UnitRange{<:Integer})
     # TODO optimise
-    filter(label -> !isempty(intersect(pos, first(label))),
-           s.annotations)
+    annots = filter(label -> !isempty(intersect(pos, first(label))),
+                    s.annotations)
+    last.(annots)
 end
 
 annotations(s::AnnotatedString, pos::Integer) = annotations(s, pos:pos)
 
 annotations(s::SubString{<:AnnotatedString}, pos::Integer) =
     annotations(s.string, s.offset + pos)
-
 annotations(s::SubString{<:AnnotatedString}, pos::UnitRange{<:Integer}) =
     annotations(s.string, first(pos)+s.offset:last(pos)+s.offset)
 
 """
-    annotations(chr::AnnotatedChar) -> Vector{Pair{Symbol, Any}}
+    annotations(chr::AnnotatedChar)
 
-Get all annotations of `chr`, in the form of a vector of annotation pairs.
+Get all annotations of `chr`.
 """
 annotations(c::AnnotatedChar) = c.annotations
 
diff --git a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5 b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
new file mode 100644
index 0000000000000..fc675ee83125a
--- /dev/null
+++ b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
@@ -0,0 +1 @@
+c1fd1bb7e3f9ab00afe0758a8a101374
diff --git a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512 b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
new file mode 100644
index 0000000000000..09d5a8a619295
--- /dev/null
+++ b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
@@ -0,0 +1 @@
+373302f1d32a5b5ad0efacf14fa82a16fd877c11ca589fc1f1492eb1d4bcd0f49a2a5a3f471f8577649309c8a03634e7467e31b403cfd6ab8a8e4a775d7f4e53
diff --git a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5 b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
deleted file mode 100644
index 2ab79799cca0e..0000000000000
--- a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-fc3a846400107c432d20da6cfdd19ccf
diff --git a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512 b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512
deleted file mode 100644
index 70b0ef6f5cb3a..0000000000000
--- a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-22da8964cc4c09f7c7a3da44be14c953f520ce6d395cf0f9ccf9c17777d6d968b0a874b35c072801ef7a1f4eee40f96ea0e2fc5ed5b3a63ad0b6b776a9c14ebb
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index 19a5a24514f2f..8180223575f05 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2
+STYLEDSTRINGS_SHA1 = a1b2ae2434cd7d8199fa8647339422fe0e1d0324
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1

From d7b9ac8281cd988ffb5da9b0e7deed23b8d5cb28 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 13 Feb 2024 10:32:15 -0500
Subject: [PATCH 0925/1315] change IOBuffer to use Memory internally (#53192)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An Array is often still allocated on output, but this gives the compiler
a chance to potentially elide that in certain cases.

For measurement, it seems about 10% faster as a string builder:
```
julia> @btime repr("hello\nworld"^10);
  1.096 μs (10 allocations: 640 bytes) # master
  973.000 ns (9 allocations: 608 bytes) # PR
  994.000 ns (8 allocations: 576 bytes) # also PR, after Revise-ing Base.wrap
```
---
 base/array.jl                      |  34 +++--
 base/iobuffer.jl                   | 194 ++++++++++++++++++-----------
 base/iostream.jl                   |  22 ++--
 base/stream.jl                     |   6 +-
 base/strings/annotated.jl          |  17 +--
 base/strings/string.jl             |  27 +++-
 base/subarray.jl                   |   3 +
 src/array.c                        |  15 ---
 src/genericmemory.c                |   2 +
 src/jl_exported_funcs.inc          |   1 -
 stdlib/REPL/src/LineEdit.jl        |  39 +++---
 stdlib/REPL/test/precompilation.jl |   2 +-
 test/iobuffer.jl                   |   1 +
 test/show.jl                       |   4 +-
 14 files changed, 230 insertions(+), 137 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index 600ae73d2338e..e1a1ee0ecf450 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -3067,7 +3067,8 @@ of [`unsafe_wrap`](@ref) utilizing `Memory` or `MemoryRef` instead of raw pointe
 """
 function wrap end
 
-@eval @propagate_inbounds function wrap(::Type{Array}, ref::MemoryRef{T}, dims::NTuple{N, Integer}) where {T, N}
+# validity checking for _wrap calls, separate from allocation of Array so that it can be more likely to inline into the caller
+function _wrap(ref::MemoryRef{T}, dims::NTuple{N, Int}) where {T, N}
     mem = ref.mem
     mem_len = length(mem) + 1 - memoryrefoffset(ref)
     len = Core.checked_dims(dims...)
@@ -3076,18 +3077,35 @@ function wrap end
         mem = ccall(:jl_genericmemory_slice, Memory{T}, (Any, Ptr{Cvoid}, Int), mem, ref.ptr_or_offset, len)
         ref = MemoryRef(mem)
     end
-    $(Expr(:new, :(Array{T, N}), :ref, :dims))
+    return ref
 end
 
 @noinline invalid_wrap_err(len, dims, proddims) = throw(DimensionMismatch(
     "Attempted to wrap a MemoryRef of length $len with an Array of size dims=$dims, which is invalid because prod(dims) = $proddims > $len, so that the array would have more elements than the underlying memory can store."))
 
-function wrap(::Type{Array}, m::Memory{T}, dims::NTuple{N, Integer}) where {T, N}
-    wrap(Array, MemoryRef(m), dims)
+@eval @propagate_inbounds function wrap(::Type{Array}, m::MemoryRef{T}, dims::NTuple{N, Integer}) where {T, N}
+    dims = convert(Dims, dims)
+    ref = _wrap(m, dims)
+    $(Expr(:new, :(Array{T, N}), :ref, :dims))
+end
+
+@eval @propagate_inbounds function wrap(::Type{Array}, m::Memory{T}, dims::NTuple{N, Integer}) where {T, N}
+    dims = convert(Dims, dims)
+    ref = _wrap(MemoryRef(m), dims)
+    $(Expr(:new, :(Array{T, N}), :ref, :dims))
+end
+@eval @propagate_inbounds function wrap(::Type{Array}, m::MemoryRef{T}, l::Integer) where {T}
+    dims = (Int(l),)
+    ref = _wrap(m, dims)
+    $(Expr(:new, :(Array{T, 1}), :ref, :dims))
 end
-function wrap(::Type{Array}, m::MemoryRef{T}, l::Integer) where {T}
-    wrap(Array, m, (l,))
+@eval @propagate_inbounds function wrap(::Type{Array}, m::Memory{T}, l::Integer) where {T}
+    dims = (Int(l),)
+    ref = _wrap(MemoryRef(m), (l,))
+    $(Expr(:new, :(Array{T, 1}), :ref, :dims))
 end
-function wrap(::Type{Array}, m::Memory{T}, l::Integer) where {T}
-    wrap(Array, MemoryRef(m), (l,))
+@eval @propagate_inbounds function wrap(::Type{Array}, m::Memory{T}) where {T}
+    ref = MemoryRef(m)
+    dims = (length(m),)
+    $(Expr(:new, :(Array{T, 1}), :ref, :dims))
 end
diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index 895205549bc7e..dadb13e1f1e6a 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -4,32 +4,45 @@
 
 # Stateful string
 mutable struct GenericIOBuffer{T<:AbstractVector{UInt8}} <: IO
-    data::T # T should support: getindex, setindex!, length, copyto!, and resize!
+    data::T # T should support: getindex, setindex!, length, copyto!, similar, and (optionally) resize!
     reinit::Bool # if true, data needs to be re-allocated (after take!)
     readable::Bool
     writable::Bool
     seekable::Bool # if not seekable, implementation is free to destroy (compact) past read data
     append::Bool # add data at end instead of at pointer
-    size::Int # end pointer (and write pointer if append == true)
+    size::Int # end pointer (and write pointer if append == true) + offset
     maxsize::Int # fixed array size (typically pre-allocated)
-    ptr::Int # read (and maybe write) pointer
+    ptr::Int # read (and maybe write) pointer + offset
+    offset::Int # offset of ptr and size from actual start of data and actual size
     mark::Int # reset mark location for ptr (or <0 for no mark)
 
     function GenericIOBuffer{T}(data::T, readable::Bool, writable::Bool, seekable::Bool, append::Bool,
                                 maxsize::Integer) where T<:AbstractVector{UInt8}
         require_one_based_indexing(data)
-        new(data,false,readable,writable,seekable,append,length(data),maxsize,1,-1)
+        return new(data, false, readable, writable, seekable, append, length(data), maxsize, 1, 0, -1)
     end
 end
-const IOBuffer = GenericIOBuffer{Vector{UInt8}}
+
+const IOBuffer = GenericIOBuffer{Memory{UInt8}}
 
 function GenericIOBuffer(data::T, readable::Bool, writable::Bool, seekable::Bool, append::Bool,
                          maxsize::Integer) where T<:AbstractVector{UInt8}
     GenericIOBuffer{T}(data, readable, writable, seekable, append, maxsize)
 end
+function GenericIOBuffer(data::Vector{UInt8}, readable::Bool, writable::Bool, seekable::Bool, append::Bool,
+                         maxsize::Integer)
+    ref = data.ref
+    buf = GenericIOBuffer(ref.mem, readable, writable, seekable, append, maxsize)
+    offset = memoryrefoffset(ref) - 1
+    buf.ptr += offset
+    buf.size = length(data) + offset
+    buf.offset = offset
+    return buf
+end
 
 # allocate Vector{UInt8}s for IOBuffer storage that can efficiently become Strings
-StringVector(n::Integer) = unsafe_wrap(Vector{UInt8}, _string_n(n))
+StringMemory(n::Integer) = unsafe_wrap(Memory{UInt8}, _string_n(n))
+StringVector(n::Integer) = wrap(Array, StringMemory(n))
 
 # IOBuffers behave like Files. They are typically readable and writable. They are seekable. (They can be appendable).
 
@@ -98,7 +111,7 @@ function IOBuffer(
     flags = open_flags(read=read, write=write, append=append, truncate=truncate)
     buf = GenericIOBuffer(data, flags.read, flags.write, true, flags.append, Int(maxsize))
     if flags.truncate
-        buf.size = 0
+        buf.size = buf.offset
     end
     return buf
 end
@@ -113,7 +126,7 @@ function IOBuffer(;
     size = sizehint !== nothing ? Int(sizehint) : maxsize != typemax(Int) ? Int(maxsize) : 32
     flags = open_flags(read=read, write=write, append=append, truncate=truncate)
     buf = IOBuffer(
-        StringVector(size),
+        StringMemory(size),
         read=flags.read,
         write=flags.write,
         append=flags.append,
@@ -135,12 +148,12 @@ See [`IOBuffer`](@ref) for the available constructors.
 If `data` is given, creates a `PipeBuffer` to operate on a data vector,
 optionally specifying a size beyond which the underlying `Array` may not be grown.
 """
-PipeBuffer(data::AbstractVector{UInt8}=UInt8[]; maxsize::Int = typemax(Int)) =
+PipeBuffer(data::AbstractVector{UInt8}=Memory{UInt8}(); maxsize::Int = typemax(Int)) =
     GenericIOBuffer(data, true, true, false, true, maxsize)
-PipeBuffer(maxsize::Integer) = (x = PipeBuffer(StringVector(maxsize), maxsize = maxsize); x.size=0; x)
+PipeBuffer(maxsize::Integer) = (x = PipeBuffer(StringMemory(maxsize), maxsize = maxsize); x.size = 0; x)
 
 _similar_data(b::GenericIOBuffer, len::Int) = similar(b.data, len)
-_similar_data(b::IOBuffer, len::Int) = StringVector(len)
+_similar_data(b::IOBuffer, len::Int) = StringMemory(len)
 
 function copy(b::GenericIOBuffer)
     ret = typeof(b)(b.reinit ? _similar_data(b, 0) : b.writable ?
@@ -148,6 +161,8 @@ function copy(b::GenericIOBuffer)
                     b.readable, b.writable, b.seekable, b.append, b.maxsize)
     ret.size = b.size
     ret.ptr  = b.ptr
+    ret.mark = b.mark
+    ret.offset = b.offset
     return ret
 end
 
@@ -156,9 +171,9 @@ show(io::IO, b::GenericIOBuffer) = print(io, "IOBuffer(data=UInt8[...], ",
                                       "writable=", b.writable, ", ",
                                       "seekable=", b.seekable, ", ",
                                       "append=",   b.append, ", ",
-                                      "size=",     b.size, ", ",
+                                      "size=",     b.size - b.offset, ", ",
                                       "maxsize=",  b.maxsize == typemax(Int) ? "Inf" : b.maxsize, ", ",
-                                      "ptr=",      b.ptr, ", ",
+                                      "ptr=",      b.ptr - b.offset, ", ",
                                       "mark=",     b.mark, ")")
 
 @noinline function _throw_not_readable()
@@ -240,11 +255,9 @@ read(from::GenericIOBuffer, ::Type{Ptr{T}}) where {T} = convert(Ptr{T}, read(fro
 isreadable(io::GenericIOBuffer) = io.readable
 iswritable(io::GenericIOBuffer) = io.writable
 
-# TODO: GenericIOBuffer is not iterable, so doesn't really have a length.
-# This should maybe be sizeof() instead.
-#length(io::GenericIOBuffer) = (io.seekable ? io.size : bytesavailable(io))
+filesize(io::GenericIOBuffer) = (io.seekable ? io.size - io.offset : bytesavailable(io))
 bytesavailable(io::GenericIOBuffer) = io.size - io.ptr + 1
-position(io::GenericIOBuffer) = io.ptr-1
+position(io::GenericIOBuffer) = io.ptr - io.offset - 1
 
 function skip(io::GenericIOBuffer, n::Integer)
     seekto = io.ptr + n
@@ -262,7 +275,7 @@ function seek(io::GenericIOBuffer, n::Integer)
     #       of an GenericIOBuffer), so that would need to be fixed in order to throw an error here
     #(n < 0 || n > io.size) && throw(ArgumentError("Attempted to seek outside IOBuffer boundaries."))
     #io.ptr = n+1
-    io.ptr = max(min(n+1, io.size+1), 1)
+    io.ptr = min(max(0, n)+io.offset, io.size)+1
     return io
 end
 
@@ -271,32 +284,66 @@ function seekend(io::GenericIOBuffer)
     return io
 end
 
+# choose a resize strategy based on whether `resize!` is defined:
+# for a Vector, we use `resize!`, but for most other types,
+# this calls `similar`+copy
+function _resize!(io::GenericIOBuffer, sz::Int)
+    a = io.data
+    offset = io.offset
+    if applicable(resize!, a, sz)
+        if offset != 0
+            size = io.size
+            size > offset && copyto!(a, 1, a, offset + 1, min(sz, size - offset))
+            io.ptr -= offset
+            io.size -= offset
+            io.offset = 0
+        end
+        resize!(a, sz)
+    else
+        size = io.size
+        if size >= sz && sz != 0
+            b = a
+        else
+            b = _similar_data(io, sz == 0 ? 0 : max(overallocation(size - io.offset), sz))
+        end
+        size > offset && copyto!(b, 1, a, offset + 1, min(sz, size - offset))
+        io.data = b
+        io.ptr -= offset
+        io.size -= offset
+        io.offset = 0
+    end
+    return io
+end
+
 function truncate(io::GenericIOBuffer, n::Integer)
     io.writable || throw(ArgumentError("truncate failed, IOBuffer is not writeable"))
     io.seekable || throw(ArgumentError("truncate failed, IOBuffer is not seekable"))
     n < 0 && throw(ArgumentError("truncate failed, n bytes must be ≥ 0, got $n"))
     n > io.maxsize && throw(ArgumentError("truncate failed, $(n) bytes is exceeds IOBuffer maxsize $(io.maxsize)"))
+    n = Int(n)
     if io.reinit
         io.data = _similar_data(io, n)
         io.reinit = false
-    elseif n > length(io.data)
-        resize!(io.data, n)
+    elseif n > length(io.data) + io.offset
+        _resize!(io, n)
     end
+    ismarked(io) && io.mark > n && unmark(io)
+    n += io.offset
     io.data[io.size+1:n] .= 0
     io.size = n
     io.ptr = min(io.ptr, n+1)
-    ismarked(io) && io.mark > n && unmark(io)
     return io
 end
 
 function compact(io::GenericIOBuffer)
     io.writable || throw(ArgumentError("compact failed, IOBuffer is not writeable"))
     io.seekable && throw(ArgumentError("compact failed, IOBuffer is seekable"))
+    io.reinit && return
     local ptr::Int, bytes_to_move::Int
-    if ismarked(io) && io.mark < io.ptr
-        if io.mark == 0 return end
-        ptr = io.mark
-        bytes_to_move = bytesavailable(io) + (io.ptr-io.mark)
+    if ismarked(io) && io.mark < position(io)
+        io.mark == 0 && return
+        ptr = io.mark + io.offset
+        bytes_to_move = bytesavailable(io) + (io.ptr - ptr)
     else
         ptr = io.ptr
         bytes_to_move = bytesavailable(io)
@@ -304,19 +351,24 @@ function compact(io::GenericIOBuffer)
     copyto!(io.data, 1, io.data, ptr, bytes_to_move)
     io.size -= ptr - 1
     io.ptr -= ptr - 1
-    io.mark -= ptr - 1
-    return io
+    io.offset = 0
+    return
 end
 
 @noinline function ensureroom_slowpath(io::GenericIOBuffer, nshort::UInt)
     io.writable || throw(ArgumentError("ensureroom failed, IOBuffer is not writeable"))
+    if io.reinit
+        io.data = _similar_data(io, nshort % Int)
+        io.reinit = false
+    end
     if !io.seekable
-        if !ismarked(io) && io.ptr > 1 && io.size <= io.ptr - 1
+        if !ismarked(io) && io.ptr > io.offset+1 && io.size <= io.ptr - 1
             io.ptr = 1
             io.size = 0
+            io.offset = 0
         else
-            datastart = ismarked(io) ? io.mark : io.ptr
-            if (io.size+nshort > io.maxsize) ||
+            datastart = (ismarked(io) ? io.mark : io.ptr - io.offset)
+            if (io.size-io.offset+nshort > io.maxsize) ||
                 (datastart > 4096 && datastart > io.size - io.ptr) ||
                 (datastart > 262144)
                 # apply somewhat arbitrary heuristics to decide when to destroy
@@ -330,23 +382,18 @@ end
 
 @inline ensureroom(io::GenericIOBuffer, nshort::Int) = ensureroom(io, UInt(nshort))
 @inline function ensureroom(io::GenericIOBuffer, nshort::UInt)
-    if !io.writable || (!io.seekable && io.ptr > 1)
+    if !io.writable || (!io.seekable && io.ptr > io.offset+1) || io.reinit
         ensureroom_slowpath(io, nshort)
     end
-    n = min((nshort % Int) + (io.append ? io.size : io.ptr-1), io.maxsize)
-    if io.reinit
-        io.data = _similar_data(io, n)
-        io.reinit = false
-    else
-        l = length(io.data)
-        if n > l
-            _growend!(io.data, (n - l) % UInt)
-        end
+    n = min((nshort % Int) + (io.append ? io.size : io.ptr-1) - io.offset, io.maxsize)
+    l = length(io.data) + io.offset
+    if n > l
+        _resize!(io, Int(n))
     end
     return io
 end
 
-eof(io::GenericIOBuffer) = (io.ptr-1 == io.size)
+eof(io::GenericIOBuffer) = (io.ptr - 1 >= io.size)
 
 function closewrite(io::GenericIOBuffer)
     io.writable = false
@@ -358,11 +405,12 @@ end
     io.writable = false
     io.seekable = false
     io.size = 0
+    io.offset = 0
     io.maxsize = 0
     io.ptr = 1
     io.mark = -1
-    if io.writable
-        resize!(io.data, 0)
+    if io.writable && !io.reinit
+        io.data = _resize!(io, 0)
     end
     nothing
 end
@@ -388,45 +436,45 @@ julia> String(take!(io))
 function take!(io::GenericIOBuffer)
     ismarked(io) && unmark(io)
     if io.seekable
-        nbytes = io.size
-        data = copyto!(StringVector(nbytes), 1, io.data, 1, nbytes)
+        nbytes = io.size - io.offset
+        data = copyto!(StringVector(nbytes), 1, io.data, io.offset + 1, nbytes)
     else
         nbytes = bytesavailable(io)
-        data = read!(io,StringVector(nbytes))
+        data = read!(io, StringVector(nbytes))
     end
     if io.writable
         io.ptr = 1
         io.size = 0
+        io.offset = 0
     end
     return data
 end
 function take!(io::IOBuffer)
     ismarked(io) && unmark(io)
     if io.seekable
-        if io.writable
-            if io.reinit
-                data = StringVector(0)
-            else
-                data = resize!(io.data, io.size)
-                io.reinit = true
-            end
+        nbytes = filesize(io)
+        if nbytes == 0 || io.reinit
+            data = StringVector(0)
+        elseif io.writable
+            data = wrap(Array, MemoryRef(io.data, io.offset + 1), nbytes)
         else
-            data = copyto!(StringVector(io.size), 1, io.data, 1, io.size)
+            data = copyto!(StringVector(io.size), 1, io.data, io.offset + 1, nbytes)
         end
     else
         nbytes = bytesavailable(io)
-        if io.writable
-            data = io.data
-            io.reinit = true
-            _deletebeg!(data, io.ptr-1)
-            resize!(data, nbytes)
+        if nbytes == 0
+            data = StringVector(0)
+        elseif io.writable
+            data = wrap(Array, MemoryRef(io.data, io.ptr), nbytes)
         else
-            data = read!(io, StringVector(nbytes))
+            data = read!(io, data)
         end
     end
     if io.writable
+        io.reinit = true
         io.ptr = 1
         io.size = 0
+        io.offset = 0
     end
     return data
 end
@@ -440,17 +488,23 @@ state.  This should only be used internally for performance-critical
 `String` routines that immediately discard `io` afterwards, and it
 *assumes* that `io` is writable and seekable.
 
-It saves no allocations compared to `take!`, it just omits some checks.
+It might save an allocation compared to `take!` (if the compiler elides the
+Array allocation), as well as omits some checks.
 """
-_unsafe_take!(io::IOBuffer) = resize!(io.data, io.size)
+_unsafe_take!(io::IOBuffer) =
+    wrap(Array, io.size == io.offset ?
+        MemoryRef(Memory{UInt8}()) :
+        MemoryRef(io.data, io.offset + 1),
+        io.size - io.offset)
 
 function write(to::IO, from::GenericIOBuffer)
+    written::Int = bytesavailable(from)
     if to === from
         from.ptr = from.size + 1
-        return 0
+    else
+        written = GC.@preserve from unsafe_write(to, pointer(from.data, from.ptr), UInt(written))
+        from.ptr += written
     end
-    written::Int = GC.@preserve from unsafe_write(to, pointer(from.data, from.ptr), UInt(bytesavailable(from)))
-    from.ptr += written
     return written
 end
 
@@ -497,13 +551,13 @@ function readbytes!(io::GenericIOBuffer, b::Array{UInt8}, nb::Int)
     read_sub(io, b, 1, nr)
     return nr
 end
-read(io::GenericIOBuffer) = read!(io,StringVector(bytesavailable(io)))
+read(io::GenericIOBuffer) = read!(io, StringVector(bytesavailable(io)))
 readavailable(io::GenericIOBuffer) = read(io)
-read(io::GenericIOBuffer, nb::Integer) = read!(io,StringVector(min(nb, bytesavailable(io))))
+read(io::GenericIOBuffer, nb::Integer) = read!(io, StringVector(min(nb, bytesavailable(io))))
 
 function occursin(delim::UInt8, buf::IOBuffer)
     p = pointer(buf.data, buf.ptr)
-    q = GC.@preserve buf ccall(:memchr,Ptr{UInt8},(Ptr{UInt8},Int32,Csize_t),p,delim,bytesavailable(buf))
+    q = GC.@preserve buf ccall(:memchr, Ptr{UInt8}, (Ptr{UInt8}, Int32, Csize_t), p, delim, bytesavailable(buf))
     return q != C_NULL
 end
 
@@ -532,8 +586,8 @@ end
 function copyline(out::GenericIOBuffer, s::IO; keep::Bool=false)
     copyuntil(out, s, 0x0a, keep=true)
     line = out.data
-    i = out.size
-    if keep || i == 0 || line[i] != 0x0a
+    i = out.size # XXX: this is only correct for appended data. if the data was inserted, only ptr should change
+    if keep || i == out.offset || line[i] != 0x0a
         return out
     elseif i < 2 || line[i-1] != 0x0d
         i -= 1
diff --git a/base/iostream.jl b/base/iostream.jl
index ba422cd692fcd..5d972945e00e0 100644
--- a/base/iostream.jl
+++ b/base/iostream.jl
@@ -455,26 +455,24 @@ end
 
 function copyuntil(out::IOBuffer, s::IOStream, delim::UInt8; keep::Bool=false)
     ensureroom(out, 1) # make sure we can read at least 1 byte, for iszero(n) check below
-    ptr = (out.append ? out.size+1 : out.ptr)
-    d = out.data
-    len = length(d)
     while true
+        d = out.data
+        len = length(d)
+        ptr = (out.append ? out.size+1 : out.ptr)
         GC.@preserve d @_lock_ios s n=
             Int(ccall(:jl_readuntil_buf, Csize_t, (Ptr{Cvoid}, UInt8, Ptr{UInt8}, Csize_t),
                 s.ios, delim, pointer(d, ptr), (len - ptr + 1) % Csize_t))
         iszero(n) && break
         ptr += n
-        if d[ptr-1] == delim
-            keep || (ptr -= 1)
-            break
-        end
+        found = (d[ptr - 1] == delim)
+        found && !keep && (ptr -= 1)
+        out.size = max(out.size, ptr - 1)
+        out.append || (out.ptr = ptr)
+        found && break
         (eof(s) || len == out.maxsize) && break
         len = min(2len + 64, out.maxsize)
-        resize!(d, len)
-    end
-    out.size = max(out.size, ptr - 1)
-    if !out.append
-        out.ptr = ptr
+        ensureroom(out, len)
+        @assert length(out.data) >= len
     end
     return out
 end
diff --git a/base/stream.jl b/base/stream.jl
index 14621c464ce1b..3de61181e978d 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -608,7 +608,7 @@ end
 function alloc_request(buffer::IOBuffer, recommended_size::UInt)
     ensureroom(buffer, Int(recommended_size))
     ptr = buffer.append ? buffer.size + 1 : buffer.ptr
-    nb = min(length(buffer.data), buffer.maxsize) - ptr + 1
+    nb = min(length(buffer.data)-buffer.offset, buffer.maxsize) + buffer.offset - ptr + 1
     return (Ptr{Cvoid}(pointer(buffer.data, ptr)), nb)
 end
 
@@ -932,7 +932,7 @@ function readbytes!(s::LibuvStream, a::Vector{UInt8}, nb::Int)
         nread = readbytes!(sbuf, a, nb)
     else
         newbuf = PipeBuffer(a, maxsize=nb)
-        newbuf.size = 0 # reset the write pointer to the beginning
+        newbuf.size = newbuf.offset # reset the write pointer to the beginning
         nread = try
             s.buffer = newbuf
             write(newbuf, sbuf)
@@ -979,7 +979,7 @@ function unsafe_read(s::LibuvStream, p::Ptr{UInt8}, nb::UInt)
         unsafe_read(sbuf, p, nb)
     else
         newbuf = PipeBuffer(unsafe_wrap(Array, p, nb), maxsize=Int(nb))
-        newbuf.size = 0 # reset the write pointer to the beginning
+        newbuf.size = newbuf.offset # reset the write pointer to the beginning
         try
             s.buffer = newbuf
             write(newbuf, sbuf)
diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 86790d169420e..1eeaaa668d9ee 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -200,34 +200,36 @@ julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label => 1)]), ", an
 function annotatedstring(xs...)
     isempty(xs) && return AnnotatedString("")
     size = mapreduce(_str_sizehint, +, xs)
-    s = IOContext(IOBuffer(sizehint=size), :color => true)
+    buf = IOBuffer(sizehint=size)
+    s = IOContext(buf, :color => true)
     annotations = Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}()
     for x in xs
+        size = filesize(s.io)
         if x isa AnnotatedString
             for (region, annot) in x.annotations
-                push!(annotations, (s.io.size .+ (region), annot))
+                push!(annotations, (size .+ (region), annot))
             end
             print(s, x.string)
         elseif x isa SubString{<:AnnotatedString}
             for (region, annot) in x.string.annotations
                 start, stop = first(region), last(region)
                 if start <= x.offset + x.ncodeunits && stop > x.offset
-                    rstart = s.io.size + max(0, start - x.offset - 1) + 1
-                    rstop = s.io.size + min(stop, x.offset + x.ncodeunits) - x.offset
+                    rstart = size + max(0, start - x.offset - 1) + 1
+                    rstop = size + min(stop, x.offset + x.ncodeunits) - x.offset
                     push!(annotations, (rstart:rstop, annot))
                 end
             end
             print(s, SubString(x.string.string, x.offset, x.ncodeunits, Val(:noshift)))
         elseif x isa AnnotatedChar
             for annot in x.annotations
-                push!(annotations, (1+s.io.size:1+s.io.size, annot))
+                push!(annotations, (1+size:1+size, annot))
             end
             print(s, x.char)
         else
             print(s, x)
         end
     end
-    str = String(resize!(s.io.data, s.io.size))
+    str = String(take!(buf))
     AnnotatedString(str, annotations)
 end
 
@@ -400,7 +402,8 @@ AnnotatedIOBuffer() = AnnotatedIOBuffer(IOBuffer())
 
 function show(io::IO, aio::AnnotatedIOBuffer)
     show(io, AnnotatedIOBuffer)
-    print(io, '(', aio.io.size, " byte", ifelse(aio.io.size == 1, "", "s"), ", ",
+    size = filesize(aio.io)
+    print(io, '(', size, " byte", ifelse(size == 1, "", "s"), ", ",
           length(aio.annotations), " annotation", ifelse(length(aio.annotations) == 1, "", "s"), ")")
 end
 
diff --git a/base/strings/string.jl b/base/strings/string.jl
index 29216ae97aa37..b2afce897a937 100644
--- a/base/strings/string.jl
+++ b/base/strings/string.jl
@@ -63,8 +63,27 @@ by [`take!`](@ref) on a writable [`IOBuffer`](@ref) and by calls to
 In other cases, `Vector{UInt8}` data may be copied, but `v` is truncated anyway
 to guarantee consistent behavior.
 """
-String(v::AbstractVector{UInt8}) = String(copyto!(StringVector(length(v)), v))
-String(v::Vector{UInt8}) = ccall(:jl_array_to_string, Ref{String}, (Any,), v)
+String(v::AbstractVector{UInt8}) = String(copyto!(StringMemory(length(v)), v))
+function String(v::Memory{UInt8})
+    len = length(v)
+    len == 0 && return ""
+    return ccall(:jl_genericmemory_to_string, Ref{String}, (Any, Int), v, len)
+end
+function String(v::Vector{UInt8})
+    #return ccall(:jl_array_to_string, Ref{String}, (Any,), v)
+    len = length(v)
+    len == 0 && return ""
+    ref = v.ref
+    if ref.ptr_or_offset == ref.mem.ptr
+        str = ccall(:jl_genericmemory_to_string, Ref{String}, (Any, Int), ref.mem, len)
+    else
+        str = ccall(:jl_pchar_to_string, Ref{String}, (Ptr{UInt8}, Int), ref, len)
+    end
+    # optimized empty!(v); sizehint!(v, 0) calls
+    setfield!(v, :size, (0,))
+    setfield!(v, :ref, MemoryRef(Memory{UInt8}()))
+    return str
+end
 
 """
     unsafe_string(p::Ptr{UInt8}, [length::Integer])
@@ -97,8 +116,8 @@ Create a new `String` from an existing `AbstractString`.
 String(s::AbstractString) = print_to_string(s)
 @assume_effects :total String(s::Symbol) = unsafe_string(unsafe_convert(Ptr{UInt8}, s))
 
-unsafe_wrap(::Type{Vector{UInt8}}, s::String) = ccall(:jl_string_to_array, Ref{Vector{UInt8}}, (Any,), s)
-unsafe_wrap(::Type{Vector{UInt8}}, s::FastContiguousSubArray{UInt8,1,Vector{UInt8}}) = unsafe_wrap(Vector{UInt8}, pointer(s), size(s))
+unsafe_wrap(::Type{Memory{UInt8}}, s::String) = ccall(:jl_string_to_genericmemory, Ref{Memory{UInt8}}, (Any,), s)
+unsafe_wrap(::Type{Vector{UInt8}}, s::String) = wrap(Array, unsafe_wrap(Memory{UInt8}, s))
 
 Vector{UInt8}(s::CodeUnits{UInt8,String}) = copyto!(Vector{UInt8}(undef, length(s)), s)
 Vector{UInt8}(s::String) = Vector{UInt8}(codeunits(s))
diff --git a/base/subarray.jl b/base/subarray.jl
index 7b7e913332aaf..eca06fa3eacff 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -543,3 +543,6 @@ end
 function replace_in_print_matrix(S::SubArray{<:Any,1,<:AbstractVector}, i::Integer, j::Integer, s::AbstractString)
     replace_in_print_matrix(S.parent, to_indices(S.parent, reindex(S.indices, (i,)))..., j, s)
 end
+
+# XXX: this is considerably more unsafe than the other similarly named methods
+unsafe_wrap(::Type{Vector{UInt8}}, s::FastContiguousSubArray{UInt8,1,Vector{UInt8}}) = unsafe_wrap(Vector{UInt8}, pointer(s), size(s))
diff --git a/src/array.c b/src/array.c
index 198215831497d..979772e649727 100644
--- a/src/array.c
+++ b/src/array.c
@@ -99,21 +99,6 @@ jl_genericmemory_t *_new_genericmemory_(jl_value_t *mtype, size_t nel, int8_t is
 
 JL_DLLEXPORT jl_genericmemory_t *jl_string_to_genericmemory(jl_value_t *str);
 
-JL_DLLEXPORT jl_array_t *jl_string_to_array(jl_value_t *str)
-{
-    jl_task_t *ct = jl_current_task;
-    jl_genericmemory_t *mem = jl_string_to_genericmemory(str);
-    JL_GC_PUSH1(&mem);
-    int ndimwords = 1;
-    int tsz = sizeof(jl_array_t) + ndimwords*sizeof(size_t);
-    jl_array_t *a = (jl_array_t*)jl_gc_alloc(ct->ptls, tsz, jl_array_uint8_type);
-    a->ref.mem = mem;
-    a->ref.ptr_or_offset = mem->ptr;
-    a->dimsize[0] = mem->length;
-    JL_GC_POP();
-    return a;
-}
-
 JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
                                             size_t nel, int own_buffer)
 {
diff --git a/src/genericmemory.c b/src/genericmemory.c
index 0bd4db30fd690..f0e7b695f1122 100644
--- a/src/genericmemory.c
+++ b/src/genericmemory.c
@@ -101,6 +101,8 @@ JL_DLLEXPORT jl_genericmemory_t *jl_alloc_genericmemory(jl_value_t *mtype, size_
 
 JL_DLLEXPORT jl_genericmemory_t *jl_string_to_genericmemory(jl_value_t *str)
 {
+    if (jl_string_len(str) == 0)
+        return (jl_genericmemory_t*)((jl_datatype_t*)jl_memory_uint8_type)->instance;
     jl_task_t *ct = jl_current_task;
     int tsz = sizeof(jl_genericmemory_t) + sizeof(void*);
     jl_genericmemory_t *m = (jl_genericmemory_t*)jl_gc_alloc(ct->ptls, tsz, jl_memory_uint8_type);
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index a72058f10f42d..91f989f611b22 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -436,7 +436,6 @@
     XX(jl_stdout_stream) \
     XX(jl_stored_inline) \
     XX(jl_string_ptr) \
-    XX(jl_string_to_array) \
     XX(jl_subtype) \
     XX(jl_subtype_env) \
     XX(jl_subtype_env_size) \
diff --git a/stdlib/REPL/src/LineEdit.jl b/stdlib/REPL/src/LineEdit.jl
index 01daef9d66899..9f1dd76b168af 100644
--- a/stdlib/REPL/src/LineEdit.jl
+++ b/stdlib/REPL/src/LineEdit.jl
@@ -813,9 +813,9 @@ end
 # returns the removed portion as a String
 function edit_splice!(s::BufferLike, r::Region=region(s), ins::String = ""; rigid_mark::Bool=true)
     A, B = first(r), last(r)
-    A >= B && isempty(ins) && return String(ins)
+    A >= B && isempty(ins) && return ins
     buf = buffer(s)
-    pos = position(buf)
+    pos = position(buf) # n.b. position(), etc, are 0-indexed
     adjust_pos = true
     if A <= pos < B
         seek(buf, A)
@@ -824,18 +824,29 @@ function edit_splice!(s::BufferLike, r::Region=region(s), ins::String = ""; rigi
     else
         adjust_pos = false
     end
-    if A < buf.mark  < B || A == buf.mark == B
-        # rigid_mark is used only if the mark is strictly "inside"
-        # the region, or the region is empty and the mark is at the boundary
-        buf.mark = rigid_mark ? A : A + sizeof(ins)
-    elseif buf.mark >= B
-        buf.mark += sizeof(ins) - B + A
-    end
-    ensureroom(buf, B) # handle !buf.reinit from take!
-    ret = splice!(buf.data, A+1:B, codeunits(String(ins))) # position(), etc, are 0-indexed
-    buf.size = buf.size + sizeof(ins) - B + A
-    adjust_pos && seek(buf, position(buf) + sizeof(ins))
-    return String(copy(ret))
+    mark = buf.mark
+    if mark != -1
+        if A < mark < B || A == mark == B
+            # rigid_mark is used only if the mark is strictly "inside"
+            # the region, or the region is empty and the mark is at the boundary
+            mark = rigid_mark ? A : A + sizeof(ins)
+        elseif mark >= B
+            mark += sizeof(ins) - B + A
+        end
+        buf.mark = -1
+    end
+    # Implement ret = splice!(buf.data, A+1:B, codeunits(ins)) for a stream
+    pos = position(buf)
+    seek(buf, A)
+    ret = read(buf, A >= B ? 0 : B - A)
+    trail = read(buf)
+    seek(buf, A)
+    write(buf, ins)
+    write(buf, trail)
+    truncate(buf, position(buf))
+    seek(buf, pos + (adjust_pos ? sizeof(ins) : 0))
+    buf.mark = mark
+    return String(ret)
 end
 
 edit_splice!(s::MIState, ins::AbstractString) = edit_splice!(s, region(s), ins)
diff --git a/stdlib/REPL/test/precompilation.jl b/stdlib/REPL/test/precompilation.jl
index bf0c4e924a3c0..2dcf78c114d9a 100644
--- a/stdlib/REPL/test/precompilation.jl
+++ b/stdlib/REPL/test/precompilation.jl
@@ -27,7 +27,7 @@ if !Sys.iswindows()
         tracecompile_out = read(f, String)
         close(ptm) # close after reading so we don't get precompiles from error shutdown
 
-        expected_precompiles = 0
+        expected_precompiles = 1
 
         n_precompiles = count(r"precompile\(", tracecompile_out)
 
diff --git a/test/iobuffer.jl b/test/iobuffer.jl
index ec77903b4a5b8..6151f90f297ee 100644
--- a/test/iobuffer.jl
+++ b/test/iobuffer.jl
@@ -120,6 +120,7 @@ end
     Base.compact(io)
     @test position(io) == 0
     @test ioslength(io) == 0
+    Base._resize!(io,0)
     Base.ensureroom(io,50)
     @test position(io) == 0
     @test ioslength(io) == 0
diff --git a/test/show.jl b/test/show.jl
index 3e67155d0acb7..d6a691029d60a 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1250,12 +1250,12 @@ end
 @testset "PR 17117: print_array" begin
     s = IOBuffer(Vector{UInt8}(), read=true, write=true)
     Base.print_array(s, [1, 2, 3])
-    @test String(resize!(s.data, s.size)) == " 1\n 2\n 3"
+    @test String(take!(s)) == " 1\n 2\n 3"
     close(s)
     s2 = IOBuffer(Vector{UInt8}(), read=true, write=true)
     z = zeros(0,0,0,0,0,0,0,0)
     Base.print_array(s2, z)
-    @test String(resize!(s2.data, s2.size)) == ""
+    @test String(take!(s2)) == ""
     close(s2)
 end
 

From ba34d899edcbed48bddfdcf59c09057f3c97b663 Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Tue, 13 Feb 2024 16:33:06 +0100
Subject: [PATCH 0926/1315] Add `conj!`  for arrays of arrays (#53303)

Apparently, `broadcast!(conj!, A, A)` is not allocation-free, so I
spelled it out, but perhaps there's a more elegant solution.
---
 base/abstractarraymath.jl | 1 +
 test/arrayops.jl          | 7 ++++++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/base/abstractarraymath.jl b/base/abstractarraymath.jl
index 6ed3fff14928f..0c339fbc54e57 100644
--- a/base/abstractarraymath.jl
+++ b/base/abstractarraymath.jl
@@ -119,6 +119,7 @@ julia> A
 """
 conj!(A::AbstractArray{<:Number}) = (@inbounds broadcast!(conj, A, A); A)
 conj!(x::AbstractArray{<:Real}) = x
+conj!(A::AbstractArray) = (foreach(conj!, A); A)
 
 """
     conj(A::AbstractArray)
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 62df7550e90e5..a07e631e639f9 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -2612,7 +2612,7 @@ end
 end
 
 @testset "sign, conj[!], ~" begin
-    local A, B, C
+    local A, B, C, D, E
     A = [-10,0,3]
     B = [-10.0,0.0,3.0]
     C = [1,im,0]
@@ -2629,6 +2629,11 @@ end
     @test typeof(conj(A)) == Vector{Int}
     @test typeof(conj(B)) == Vector{Float64}
     @test typeof(conj(C)) == Vector{Complex{Int}}
+    D = [C copy(C); copy(C) copy(C)]
+    @test conj(D) == conj!(copy(D))
+    E = [D, copy(D)]
+    @test conj(E) == conj!(copy(E))
+    @test (@allocations conj!(E)) == 0
 
     @test .~A == [9,-1,-4]
     @test typeof(.~A) == Vector{Int}

From 288912a62d80844a1b7ef75cf09c29cd3f2a39da Mon Sep 17 00:00:00 2001
From: David Anthoff <anthoff@berkeley.edu>
Date: Tue, 13 Feb 2024 15:16:48 -0800
Subject: [PATCH 0927/1315] Add Juliaup docs (#50477)

---
 doc/make.jl                    |   1 +
 doc/src/manual/installation.md | 126 +++++++++++++++++++++++++++++++++
 2 files changed, 127 insertions(+)
 create mode 100644 doc/src/manual/installation.md

diff --git a/doc/make.jl b/doc/make.jl
index cf266370acb01..1f654649d9237 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -126,6 +126,7 @@ generate_markdown("NEWS")
 
 Manual = [
     "manual/getting-started.md",
+    "manual/installation.md",
     "manual/variables.md",
     "manual/integers-and-floating-point-numbers.md",
     "manual/mathematical-operations.md",
diff --git a/doc/src/manual/installation.md b/doc/src/manual/installation.md
new file mode 100644
index 0000000000000..07acfd1c62681
--- /dev/null
+++ b/doc/src/manual/installation.md
@@ -0,0 +1,126 @@
+# [Installation](@id man-installation)
+
+There are many ways to install Julia. The following sections highlight the
+recommended method for each of the main supported platforms, and then present
+alternative ways that might be useful in specialized situations.
+
+The current installation recommendation is a solution based on Juliaup. If you
+installed Julia previously with a method that is _not_ based on Juliaup and want
+to switch your system to an installation that is based on Juliaup, we recommend
+that you uninstall all previous Julia versions, ensure that you remove anything
+Julia related from your `PATH` variable and then install Julia with one of the
+methods described below.
+
+## Windows
+
+On Windows Julia can be installed directly from the Windows store
+[here](https://www.microsoft.com/store/apps/9NJNWW8PVKMN). One can also install
+exactly the same version by executing
+
+```
+winget install julia -s msstore
+```
+
+in any shell.
+
+## Mac and Linux
+
+Julia can be installed on Linux or Mac by executing
+
+```
+curl -fsSL https://install.julialang.org | sh
+```
+
+in a shell.
+
+### Command line arguments
+
+One can pass various command line arguments to the Julia installer. The syntax
+for installer arguments is
+
+```bash
+curl -fsSL https://install.julialang.org | sh -s -- <ARGS>
+```
+
+Here `<ARGS>` should be replaced with one or more of the following arguments:
+- `--yes` (or `-y`): Run the installer in a non-interactive mode. All
+configuration values use their default or a value supplied as a command line
+argument.
+- `--default-channel=<NAME>`: Configure the default Juliaup channel. For
+example `--default-channel lts` would install the `lts` channel and configure it
+as the default.
+- `--add-to-path=<yes|no>`: Configure whether Julia should be added to the `PATH`
+environment variable. Valid values are `yes` (default) and `no`.
+- `--background-selfupdate=<SECONDS>`: Configure an optional CRON job that
+auto-updates Juliaup if `<SECONDS>` has a value larger than 0. The actual value
+controls how often the CRON job will run to check for a new Juliaup version in
+seconds. The default value is 0, i.e. no CRON job will be created.
+- `--startup-selfupdate=<MINUTES>`: Configure how often Julia will check for new
+versions of Juliaup when Julia is started. The default is every 1440 minutes.
+- `-p=<PATH>` (or `--path`): Configure where the Julia and Juliaup binaries are
+installed. The default is `~/.juliaup`.
+
+## Alternative installation methods
+
+Note that we recommend the following methods _only_ if none of the installation
+methods described above work for your system.
+
+Some of the installation methods described below recommend installing a package
+called `juliaup`. Note that this nevertheless installs a fully functional
+Julia system, not just Juliaup.
+
+### App Installer (Windows)
+
+If the Windows Store is blocked on a system, we have an alternative
+[MSIX App Installer](https://learn.microsoft.com/en-us/windows/msix/app-installer/app-installer-file-overview)
+based setup. To use the App Installer version, download
+[this](https://install.julialang.org/Julia.appinstaller) file and open it by
+double clicking on it.
+
+### MSI Installer (Windows)
+
+If neither the Windows Store nor the App Installer version work on your Windows
+system, you can also use a MSI based installer. Note that this installation
+methods comes with serious limitations and is generally not recommended unless
+no other method works. For example, there is no automatic update mechanism for
+Juliaup with this installation method. The 64 bit version of the MSI installer
+can be downloaded from [here](https://install.julialang.org/Julia-x64.msi) and
+the 32 bit version from [here](https://install.julialang.org/Julia-x86.msi).
+
+ By default the install will be a per-user install that does not require
+ elevation. You can also do a system install by running the following command
+ from a shell:
+
+```
+msiexec /i <PATH_TO_JULIA_MSI> ALLUSERS=1
+```
+
+### [Homebrew](https://brew.sh) (Mac and Linux)
+
+On systems with brew, you can install Julia by running
+```
+brew install juliaup
+```
+in a shell. Note that you will have to update Juliaup with standard brew
+commands.
+
+### [Arch Linux - AUR](https://aur.archlinux.org/packages/juliaup/) (Linux)
+
+On Arch Linux, Juliaup is available [in the Arch User Repository (AUR)](https://aur.archlinux.org/packages/juliaup/).
+
+### [openSUSE Tumbleweed](https://get.opensuse.org/tumbleweed/) (Linux)
+
+On openSUSE Tumbleweed, you can install Julia by running
+
+```sh
+zypper install juliaup
+```
+in a shell with root privileges.
+
+### [cargo](https://crates.io/crates/juliaup/) (Windows, Mac and Linux)
+
+To install Julia via Rust's cargo, run:
+
+```sh
+cargo install juliaup
+```

From 90afb7c672b79192f665789964c71f2aeb31622c Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 13 Feb 2024 19:14:44 -0500
Subject: [PATCH 0928/1315] split results.json into 5000 result partitions
 (#53323)

Re.
https://github.com/JuliaCI/julia-buildkite/pull/338#issuecomment-1942542712
---
 test/buildkitetestjson.jl | 13 ++++++++++---
 test/runtests.jl          |  5 ++---
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/test/buildkitetestjson.jl b/test/buildkitetestjson.jl
index 15bd8b8194a93..2751122e1a5fe 100644
--- a/test/buildkitetestjson.jl
+++ b/test/buildkitetestjson.jl
@@ -8,7 +8,7 @@ module BuildKiteTestJSON
 using Test
 using Dates
 
-export write_testset_json
+export write_testset_json_files
 
 # Bootleg JSON writer
 
@@ -133,10 +133,17 @@ function collect_results!(results::Vector{Dict{String, Any}}, testset::Test.Defa
     results
 end
 
-function write_testset_json(io::IO, testset::Test.DefaultTestSet)
+function write_testset_json_files(dir::String, testset::Test.DefaultTestSet)
     data = Dict{String, Any}[]
     collect_results!(data, testset)
-    json_repr(io, data)
+    files = String[]
+    # Buildkite is limited to 5000 results per file https://buildkite.com/docs/test-analytics/importing-json
+    for (i, chunk) in enumerate(Iterators.partition(data, 5000))
+        res_file = joinpath(dir, "results_$i.json")
+        open(io -> json_repr(io, chunk), res_file, "w")
+        push!(files, res_file)
+    end
+    return files
 end
 
 end
diff --git a/test/runtests.jl b/test/runtests.jl
index 0f7a08446e014..7c6fa8480d98e 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -429,9 +429,8 @@ cd(@__DIR__) do
     end
 
     if Base.get_bool_env("CI", false)
-        testresults = joinpath(@__DIR__, "results.json")
-        @info "Writing test result data to $testresults"
-        open(io -> write_testset_json(io, o_ts), testresults, "w")
+        @info "Writing test result data to $(@__DIR__)"
+        write_testset_json_files(@__DIR__, o_ts)
     end
 
     Test.TESTSET_PRINT_ENABLE[] = true

From aaed1ccd0a16b114e65788eebaf6724b36b93c27 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Wed, 14 Feb 2024 07:43:02 +0100
Subject: [PATCH 0929/1315] allow passing command line flags to `compilecache`.
 (#53316)

Pkg right now has to start a separate process to run precompilation for
the test environment which is annoying for multiple reasons

Corresponding Pkg PR: https://github.com/JuliaLang/Pkg.jl/pull/3792
---
 base/loading.jl    | 15 ++++++++-------
 test/precompile.jl | 17 +++++++++++++++++
 2 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 5f0ea1859bc0f..3fbf0d20dfe89 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2447,7 +2447,7 @@ end
 
 const PRECOMPILE_TRACE_COMPILE = Ref{String}()
 function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::Union{Nothing, String},
-                           concrete_deps::typeof(_concrete_dependencies), internal_stderr::IO = stderr, internal_stdout::IO = stdout)
+                           concrete_deps::typeof(_concrete_dependencies), flags::Cmd=``, internal_stderr::IO = stderr, internal_stdout::IO = stdout)
     @nospecialize internal_stderr internal_stdout
     rm(output, force=true)   # Remove file if it exists
     output_o === nothing || rm(output_o, force=true)
@@ -2503,6 +2503,7 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     io = open(pipeline(addenv(`$(julia_cmd(;cpu_target)::Cmd) $(opts)
                               --startup-file=no --history-file=no --warn-overwrite=yes
                               --color=$(have_color === nothing ? "auto" : have_color ? "yes" : "no")
+                              $flags
                               $trace
                               -`,
                               "OPENBLAS_NUM_THREADS" => 1,
@@ -2570,17 +2571,17 @@ This can be used to reduce package load times. Cache files are stored in
 `DEPOT_PATH[1]/compiled`. See [Module initialization and precompilation](@ref)
 for important notes.
 """
-function compilecache(pkg::PkgId, internal_stderr::IO = stderr, internal_stdout::IO = stdout; reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
+function compilecache(pkg::PkgId, internal_stderr::IO = stderr, internal_stdout::IO = stdout; flags::Cmd=``, reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
     @nospecialize internal_stderr internal_stdout
     path = locate_package(pkg)
     path === nothing && throw(ArgumentError("$(repr("text/plain", pkg)) not found during precompilation"))
-    return compilecache(pkg, path, internal_stderr, internal_stdout; reasons)
+    return compilecache(pkg, path, internal_stderr, internal_stdout; flags, reasons)
 end
 
 const MAX_NUM_PRECOMPILE_FILES = Ref(10)
 
 function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, internal_stdout::IO = stdout,
-                      keep_loaded_modules::Bool = true; reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
+                      keep_loaded_modules::Bool = true; flags::Cmd=``, reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
 
     @nospecialize internal_stderr internal_stdout
     # decide where to put the resulting cache file
@@ -2618,7 +2619,7 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
             close(tmpio_o)
             close(tmpio_so)
         end
-        p = create_expr_cache(pkg, path, tmppath, tmppath_o, concrete_deps, internal_stderr, internal_stdout)
+        p = create_expr_cache(pkg, path, tmppath, tmppath_o, concrete_deps, flags, internal_stderr, internal_stdout)
 
         if success(p)
             if cache_objects
@@ -3627,5 +3628,5 @@ end
 
 precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), Nothing))
 precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), String))
-precompile(create_expr_cache, (PkgId, String, String, String, typeof(_concrete_dependencies), IO, IO))
-precompile(create_expr_cache, (PkgId, String, String, Nothing, typeof(_concrete_dependencies), IO, IO))
+precompile(create_expr_cache, (PkgId, String, String, String, typeof(_concrete_dependencies), IO, IO, Cmd))
+precompile(create_expr_cache, (PkgId, String, String, Nothing, typeof(_concrete_dependencies), IO, IO, Cmd))
diff --git a/test/precompile.jl b/test/precompile.jl
index 90086ff7b7385..129f909dcf6e2 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1986,6 +1986,23 @@ precompile_test_harness("Issue #50538") do load_path
     @test !isdefined(I50538, :undefglobal)
 end
 
+precompile_test_harness("Test flags") do load_path
+    write(joinpath(load_path, "TestFlags.jl"),
+          """
+          module TestFlags
+          end
+          """)
+    ji, ofile = Base.compilecache(Base.PkgId("TestFlags"); flags=`--check-bounds=no -O3`)
+    @show ji, ofile
+    open(ji, "r") do io
+        Base.isvalid_cache_header(io)
+        _, _, _, _, _, _, _, flags = Base.parse_cache_header(io, ji)
+        cacheflags = Base.CacheFlags(flags)
+        @test cacheflags.check_bounds == 2
+        @test cacheflags.opt_level == 3
+    end
+end
+
 empty!(Base.DEPOT_PATH)
 append!(Base.DEPOT_PATH, original_depot_path)
 empty!(Base.LOAD_PATH)

From 4a13e9eb035dca4107636ba016fac7fb93705154 Mon Sep 17 00:00:00 2001
From: Pierre Haessig <pierre-haessig@users.noreply.github.com>
Date: Wed, 14 Feb 2024 11:11:53 +0100
Subject: [PATCH 0930/1315] Clarify the difference between collect and bracket
 notation for generators (#50619)

As a follow-up to my question on the forum [Unclear documentation of
`collect`? (similarity and difference with
brackets)](https://discourse.julialang.org/t/unclear-documentation-of-collect-similarity-and-difference-with-brackets/),
here is a tentative expansion of the docstring of `Base.collect` to
clarify both the similarities and differences with the bracket notation
for generators.

I'm pretty sure it needs so edits, but here are the motivating factors
behind the changes, by decreasing order of importance:
1. avoid the presence of bracket notation in the example without
explanation (in the present docstring, I find it highly *implicit*)
2. simplification of examples to focus on the topic (and not on range
syntax or filtering in comprehensions)
3. avoid wasting vertical space by using longer than needed
iterators/generators

Feedback on my formulation is welcome!

---------

Co-authored-by: Max Horn <max@quendi.de>
Co-authored-by: Jishnu Bhattacharya <jishnub.github@gmail.com>
---
 base/array.jl            | 40 ++++++++++++++++++++++------------------
 doc/src/manual/arrays.md |  2 +-
 2 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index e1a1ee0ecf450..4b2cd34b2f0db 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -672,30 +672,34 @@ _array_for(::Type{T}, itr, isz) where {T} = _array_for(T, isz, _similar_shape(it
     collect(collection)
 
 Return an `Array` of all items in a collection or iterator. For dictionaries, returns
-`Vector{Pair{KeyType, ValType}}`. If the argument is array-like or is an iterator with the
-[`HasShape`](@ref IteratorSize) trait, the result will have the same shape
+a `Vector` of `key=>value` [Pair](@ref Pair)s. If the argument is array-like or is an iterator
+with the [`HasShape`](@ref IteratorSize) trait, the result will have the same shape
 and number of dimensions as the argument.
 
-Used by comprehensions to turn a generator into an `Array`.
+Used by [comprehensions](@ref man-comprehensions) to turn a [generator expression](@ref man-generators)
+into an `Array`. Thus, *on generators*, the square-brackets notation may be used instead of calling `collect`,
+see second example.
 
 # Examples
+
+Collect items from a `UnitRange{Int64}` collection:
+
 ```jldoctest
-julia> collect(1:2:13)
-7-element Vector{Int64}:
-  1
-  3
-  5
-  7
-  9
- 11
- 13
+julia> collect(1:3)
+3-element Vector{Int64}:
+ 1
+ 2
+ 3
+```
 
-julia> [x^2 for x in 1:8 if isodd(x)]
-4-element Vector{Int64}:
-  1
-  9
- 25
- 49
+Collect items from a generator (same output as `[x^2 for x in 1:3]`):
+
+```jldoctest
+julia> collect(x^2 for x in 1:3)
+3-element Vector{Int64}:
+ 1
+ 4
+ 9
 ```
 """
 collect(itr) = _collect(1:1 #= Array =#, itr, IteratorEltype(itr), IteratorSize(itr))
diff --git a/doc/src/manual/arrays.md b/doc/src/manual/arrays.md
index 6aa3a7a724e0e..34e5a231d22de 100644
--- a/doc/src/manual/arrays.md
+++ b/doc/src/manual/arrays.md
@@ -398,7 +398,7 @@ the result in single precision by writing:
 Float32[ 0.25*x[i-1] + 0.5*x[i] + 0.25*x[i+1] for i=2:length(x)-1 ]
 ```
 
-## Generator Expressions
+## [Generator Expressions](@id man-generators)
 
 Comprehensions can also be written without the enclosing square brackets, producing an object
 known as a generator. This object can be iterated to produce values on demand, instead of allocating

From 09a27b3fe405ea19344881a07d1e1e60cc11553d Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 14 Feb 2024 19:17:39 +0900
Subject: [PATCH 0931/1315] AbsInt: add interfaces to customize cases when
 cached results are used (#53318)

For external abstract interpreters like JET, which propagate custom data
interprocedurally, it is essential to inject custom behaviors into where
cached regular/constant inference results are used. Previously, this was
accomplished by overloading both `abstract_call_method` and
`get(::WorldView{CustomView}, ...)` (and `const_prop_call` and
`cached_lookup`), that method was admittedly hacky and should probably
better to be avoided. Moreover, after #52233, doing so has become
infeasible when the external abstract interpreter uses
`InternalCodeCache`.

To address this issue, this commit provides an interface named
`return_cached_result`. This allows external abstract interpreters to
inject custom interprocedural data propagation during abstract
interpretation even when they use `InternalCodeCache`.
---
 base/compiler/abstractinterpretation.jl | 62 ++++++++++++++-----------
 base/compiler/typeinfer.jl              | 20 +++++---
 2 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 9244ee5f3f8ec..21303f527e3f2 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1221,45 +1221,53 @@ function semi_concrete_eval_call(interp::AbstractInterpreter,
     return nothing
 end
 
+const_prop_result(inf_result::InferenceResult) =
+    ConstCallResults(inf_result.result, inf_result.exc_result, ConstPropResult(inf_result),
+                     inf_result.ipo_effects, inf_result.linfo)
+
+# return cached constant analysis result
+return_cached_result(::AbstractInterpreter, inf_result::InferenceResult, ::AbsIntState) =
+    const_prop_result(inf_result)
+
 function const_prop_call(interp::AbstractInterpreter,
     mi::MethodInstance, result::MethodCallResult, arginfo::ArgInfo, sv::AbsIntState,
     concrete_eval_result::Union{Nothing, ConstCallResults}=nothing)
     inf_cache = get_inference_cache(interp)
     𝕃ᵢ = typeinf_lattice(interp)
     inf_result = cache_lookup(𝕃ᵢ, mi, arginfo.argtypes, inf_cache)
-    if inf_result === nothing
-        # fresh constant prop'
-        argtypes = has_conditional(𝕃ᵢ, sv) ? ConditionalArgtypes(arginfo, sv) : SimpleArgtypes(arginfo.argtypes)
-        inf_result = InferenceResult(mi, argtypes, typeinf_lattice(interp))
-        if !any(inf_result.overridden_by_const)
-            add_remark!(interp, sv, "[constprop] Could not handle constant info in matching_cache_argtypes")
-            return nothing
-        end
-        frame = InferenceState(inf_result, #=cache_mode=#:local, interp)
-        if frame === nothing
-            add_remark!(interp, sv, "[constprop] Could not retrieve the source")
-            return nothing # this is probably a bad generated function (unsound), but just ignore it
-        end
-        frame.parent = sv
-        if !typeinf(interp, frame)
-            add_remark!(interp, sv, "[constprop] Fresh constant inference hit a cycle")
-            return nothing
-        end
-        @assert inf_result.result !== nothing
-        if concrete_eval_result !== nothing
-            # override return type and effects with concrete evaluation result if available
-            inf_result.result = concrete_eval_result.rt
-            inf_result.ipo_effects = concrete_eval_result.effects
-        end
-    else
+    if inf_result !== nothing
         # found the cache for this constant prop'
         if inf_result.result === nothing
             add_remark!(interp, sv, "[constprop] Found cached constant inference in a cycle")
             return nothing
         end
+        @assert inf_result.linfo === mi "MethodInstance for cached inference result does not match"
+        return return_cached_result(interp, inf_result, sv)
+    end
+    # perform fresh constant prop'
+    argtypes = has_conditional(𝕃ᵢ, sv) ? ConditionalArgtypes(arginfo, sv) : SimpleArgtypes(arginfo.argtypes)
+    inf_result = InferenceResult(mi, argtypes, typeinf_lattice(interp))
+    if !any(inf_result.overridden_by_const)
+        add_remark!(interp, sv, "[constprop] Could not handle constant info in matching_cache_argtypes")
+        return nothing
+    end
+    frame = InferenceState(inf_result, #=cache_mode=#:local, interp)
+    if frame === nothing
+        add_remark!(interp, sv, "[constprop] Could not retrieve the source")
+        return nothing # this is probably a bad generated function (unsound), but just ignore it
+    end
+    frame.parent = sv
+    if !typeinf(interp, frame)
+        add_remark!(interp, sv, "[constprop] Fresh constant inference hit a cycle")
+        return nothing
+    end
+    @assert inf_result.result !== nothing
+    if concrete_eval_result !== nothing
+        # override return type and effects with concrete evaluation result if available
+        inf_result.result = concrete_eval_result.rt
+        inf_result.ipo_effects = concrete_eval_result.effects
     end
-    return ConstCallResults(inf_result.result, inf_result.exc_result,
-        ConstPropResult(inf_result), inf_result.ipo_effects, mi)
+    return const_prop_result(inf_result)
 end
 
 # TODO implement MustAlias forwarding
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index e30c6e5f96fcb..747fd6e3ef705 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -818,23 +818,29 @@ struct EdgeCallResult
     end
 end
 
+# return cached regular inference result
+function return_cached_result(::AbstractInterpreter, codeinst::CodeInstance, caller::AbsIntState)
+    rt = cached_return_type(codeinst)
+    effects = ipo_effects(codeinst)
+    update_valid_age!(caller, WorldRange(min_world(codeinst), max_world(codeinst)))
+    return EdgeCallResult(rt, codeinst.exctype, codeinst.def, effects)
+end
+
 # compute (and cache) an inferred AST and return the current best estimate of the result type
 function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize(atype), sparams::SimpleVector, caller::AbsIntState)
     mi = specialize_method(method, atype, sparams)::MethodInstance
-    code = get(code_cache(interp), mi, nothing)
+    codeinst = get(code_cache(interp), mi, nothing)
     force_inline = is_stmt_inline(get_curr_ssaflag(caller))
-    if code isa CodeInstance # return existing rettype if the code is already inferred
-        inferred = @atomic :monotonic code.inferred
+    if codeinst isa CodeInstance # return existing rettype if the code is already inferred
+        inferred = @atomic :monotonic codeinst.inferred
         if inferred === nothing && force_inline
             # we already inferred this edge before and decided to discard the inferred code,
             # nevertheless we re-infer it here again in order to propagate the re-inferred
             # source to the inliner as a volatile result
             cache_mode = CACHE_MODE_VOLATILE
         else
-            rt = cached_return_type(code)
-            effects = ipo_effects(code)
-            update_valid_age!(caller, WorldRange(min_world(code), max_world(code)))
-            return EdgeCallResult(rt, code.exctype, mi, effects)
+            @assert codeinst.def === mi "MethodInstance for cached edge does not match"
+            return return_cached_result(interp, codeinst, caller)
         end
     else
         cache_mode = CACHE_MODE_GLOBAL # cache edge targets globally by default

From 52006aee4ebd158aa2d998730fe581a191e98ff9 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 14 Feb 2024 17:43:56 +0530
Subject: [PATCH 0932/1315] Move isassigned within inbounds in copyto_unaliased
 (#53311)

This matches the other branches where the `isassigned` and `
_unsetindex!` are within `@inbounds` blocks, and this might help with
performance after https://github.com/JuliaLang/julia/pull/53305
---
 base/abstractarray.jl |  4 ++--
 test/abstractarray.jl | 28 ++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index cb2519bdbeca5..90398d98465df 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1100,9 +1100,9 @@ function copyto_unaliased!(deststyle::IndexStyle, dest::AbstractArray, srcstyle:
         iterdest, itersrc = eachindex(dest), eachindex(src)
         if iterdest == itersrc
             # Shared-iterator implementation
-            for I in iterdest
+            @inbounds for I in iterdest
                 if isassigned(src, I)
-                    @inbounds dest[I] = src[I]
+                    dest[I] = src[I]
                 else
                     _unsetindex!(dest, I)
                 end
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index a327c011e8fb7..12b6b88d3f6f1 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1979,3 +1979,31 @@ end
     test_prechecked_iterate(LinearIndices(()))
     test_prechecked_iterate(Base.SCartesianIndices2{3}(1:3))
 end
+
+@testset "IndexStyles in copyto!" begin
+    A = rand(3,2)
+    B = zeros(size(A))
+    colons = ntuple(_->:, ndims(B))
+    # Ensure that the AbstractArray methods are hit
+    # by using views instead of Arrays
+    @testset "IndexLinear - IndexLinear" begin
+        B .= 0
+        copyto!(view(B, colons...), A)
+        @test B == A
+    end
+    @testset "IndexLinear - IndexCartesian" begin
+        B .= 0
+        copyto!(view(B, colons...), view(A, axes(A)...))
+        @test B == A
+    end
+    @testset "IndexCartesian - IndexLinear" begin
+        B .= 0
+        copyto!(view(B, axes(B)...), A)
+        @test B == A
+    end
+    @testset "IndexCartesian - IndexCartesian" begin
+        B .= 0
+        copyto!(view(B, axes(B)...), view(A, axes(A)...))
+        @test B == A
+    end
+end

From a19fbacca4123f7b24e199524eaf5fe864f99134 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Wed, 14 Feb 2024 13:47:41 +0100
Subject: [PATCH 0933/1315] make dependencies of extensions be found in
 implicit environments (#53314)

Alternative to https://github.com/JuliaLang/julia/pull/53293

This does kind of the same thing but it does not rely on `EXT_PRIMED` to
identify extensions which I think is a better idea since we don't really
want code lookup to depend on the state of Julia itself imo.

Fixes https://github.com/JuliaLang/julia/issues/53264

-----------------------

Co-authored by: Mark Kittisopikul <`markkitti@fosstodon.org`>
---
 base/loading.jl                               | 64 ++++++++++++++++---
 test/loading.jl                               | 12 ++++
 .../Extensions/ImplicitEnv/A/Project.toml     |  9 +++
 .../Extensions/ImplicitEnv/A/ext/BExt.jl      |  3 +
 .../project/Extensions/ImplicitEnv/A/src/A.jl |  5 ++
 .../Extensions/ImplicitEnv/B/Project.toml     |  3 +
 .../project/Extensions/ImplicitEnv/B/src/B.jl |  5 ++
 7 files changed, 92 insertions(+), 9 deletions(-)
 create mode 100644 test/project/Extensions/ImplicitEnv/A/Project.toml
 create mode 100644 test/project/Extensions/ImplicitEnv/A/ext/BExt.jl
 create mode 100644 test/project/Extensions/ImplicitEnv/A/src/A.jl
 create mode 100644 test/project/Extensions/ImplicitEnv/B/Project.toml
 create mode 100644 test/project/Extensions/ImplicitEnv/B/src/B.jl

diff --git a/base/loading.jl b/base/loading.jl
index 3fbf0d20dfe89..8bcaa4b2ab5b3 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -776,15 +776,30 @@ end
 function entry_point_and_project_file(dir::String, name::String)::Union{Tuple{Nothing,Nothing},Tuple{String,Nothing},Tuple{String,String}}
     path = normpath(joinpath(dir, "$name.jl"))
     isfile_casesensitive(path) && return path, nothing
-    dir = joinpath(dir, name)
-    path, project_file = entry_point_and_project_file_inside(dir, name)
+    dir_name = joinpath(dir, name)
+    path, project_file = entry_point_and_project_file_inside(dir_name, name)
     path === nothing || return path, project_file
-    dir = dir * ".jl"
-    path, project_file = entry_point_and_project_file_inside(dir, name)
+    dir_jl = dir_name * ".jl"
+    path, project_file = entry_point_and_project_file_inside(dir_jl, name)
     path === nothing || return path, project_file
     return nothing, nothing
 end
 
+# Find the project file for the extension `ext` in the implicit env `dir``
+function implicit_env_project_file_extension(dir::String, ext::PkgId)
+    for pkg in readdir(dir; join=true)
+        project_file = env_project_file(pkg)
+        project_file isa String || continue
+        proj = project_file_name_uuid(project_file, "")
+        uuid5(proj.uuid, ext.name) == ext.uuid || continue
+        path = project_file_ext_path(project_file, ext.name)
+        if path !== nothing
+            return path, project_file
+        end
+    end
+    return nothing, nothing
+end
+
 # given a path and a name, return the entry point
 function entry_path(path::String, name::String)::Union{Nothing,String}
     isfile_casesensitive(path) && return normpath(path)
@@ -796,11 +811,12 @@ end
 ## explicit project & manifest API ##
 
 # find project file root or deps `name => uuid` mapping
+# `ext` is the name of the extension if `name` is loaded from one
 # return `nothing` if `name` is not found
-function explicit_project_deps_get(project_file::String, name::String)::Union{Nothing,UUID}
+function explicit_project_deps_get(project_file::String, name::String, ext::Union{String,Nothing}=nothing)::Union{Nothing,UUID}
     d = parsed_toml(project_file)
-    root_uuid = dummy_uuid(project_file)
     if get(d, "name", nothing)::Union{String, Nothing} === name
+        root_uuid = dummy_uuid(project_file)
         uuid = get(d, "uuid", nothing)::Union{String, Nothing}
         return uuid === nothing ? root_uuid : UUID(uuid)
     end
@@ -809,6 +825,19 @@ function explicit_project_deps_get(project_file::String, name::String)::Union{No
         uuid = get(deps, name, nothing)::Union{String, Nothing}
         uuid === nothing || return UUID(uuid)
     end
+    if ext !== nothing
+        extensions = get(d, "extensions", nothing)
+        extensions === nothing && return nothing
+        ext_data = get(extensions, ext, nothing)
+        ext_data === nothing && return nothing
+        if (ext_data isa String && name == ext_data) || (ext_data isa Vector{String} && name in ext_data)
+            weakdeps = get(d, "weakdeps", nothing)::Union{Dict{String, Any}, Nothing}
+            weakdeps === nothing && return nothing
+            wuuid = get(weakdeps, name, nothing)::Union{String, Nothing}
+            wuuid === nothing && return nothing
+            return UUID(wuuid)
+        end
+    end
     return nothing
 end
 
@@ -996,11 +1025,28 @@ end
 function implicit_manifest_deps_get(dir::String, where::PkgId, name::String)::Union{Nothing,PkgId}
     @assert where.uuid !== nothing
     project_file = entry_point_and_project_file(dir, where.name)[2]
-    project_file === nothing && return nothing # a project file is mandatory for a package with a uuid
+    if project_file === nothing
+        # `where` could be an extension
+        project_file = implicit_env_project_file_extension(dir, where)[2]
+        project_file === nothing && return nothing
+    end
     proj = project_file_name_uuid(project_file, where.name)
-    proj == where || return nothing # verify that this is the correct project file
+    ext = nothing
+    if proj !== where
+        # `where` could be an extension in `proj`
+        d = parsed_toml(project_file)
+        exts = get(d, "extensions", nothing)::Union{Dict{String, Any}, Nothing}
+        if exts !== nothing && where.name in keys(exts)
+            if where.uuid !== uuid5(proj.uuid, where.name)
+                return nothing
+            end
+            ext = where.name
+        else
+            return nothing
+        end
+    end
     # this is the correct project, so stop searching here
-    pkg_uuid = explicit_project_deps_get(project_file, name)
+    pkg_uuid = explicit_project_deps_get(project_file, name, ext)
     return PkgId(pkg_uuid, name)
 end
 
diff --git a/test/loading.jl b/test/loading.jl
index 2dc895a8fbd8b..53e05a4a76bbc 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1131,6 +1131,18 @@ end
         cmd =  `$(Base.julia_cmd()) --startup-file=no -e $sysimg_ext_test_code`
         cmd = addenv(cmd, "JULIA_LOAD_PATH" => join([proj, "@stdlib"], sep))
         run(cmd)
+
+
+        # Extensions in implicit environments
+        old_load_path = copy(LOAD_PATH)
+        try
+            empty!(LOAD_PATH)
+            push!(LOAD_PATH, joinpath(@__DIR__, "project", "Extensions", "ImplicitEnv"))
+            pkgid_B = Base.PkgId(Base.uuid5(Base.identify_package("A").uuid, "BExt"), "BExt")
+            @test Base.identify_package(pkgid_B, "B") isa Base.PkgId
+        finally
+            copy!(LOAD_PATH, old_load_path)
+        end
     finally
         try
             rm(depot_path, force=true, recursive=true)
diff --git a/test/project/Extensions/ImplicitEnv/A/Project.toml b/test/project/Extensions/ImplicitEnv/A/Project.toml
new file mode 100644
index 0000000000000..043272d4bd015
--- /dev/null
+++ b/test/project/Extensions/ImplicitEnv/A/Project.toml
@@ -0,0 +1,9 @@
+name = "A"
+uuid = "299a509a-2181-4868-8714-15151945d902"
+version = "0.1.0"
+
+[weakdeps]
+B = "c2c18cb0-3543-497c-ac2a-523c527589e5"
+
+[extensions]
+BExt = "B"
diff --git a/test/project/Extensions/ImplicitEnv/A/ext/BExt.jl b/test/project/Extensions/ImplicitEnv/A/ext/BExt.jl
new file mode 100644
index 0000000000000..70be6435bcbe8
--- /dev/null
+++ b/test/project/Extensions/ImplicitEnv/A/ext/BExt.jl
@@ -0,0 +1,3 @@
+module BExt
+
+end
diff --git a/test/project/Extensions/ImplicitEnv/A/src/A.jl b/test/project/Extensions/ImplicitEnv/A/src/A.jl
new file mode 100644
index 0000000000000..ab16fa1de96af
--- /dev/null
+++ b/test/project/Extensions/ImplicitEnv/A/src/A.jl
@@ -0,0 +1,5 @@
+module A
+
+greet() = print("Hello World!")
+
+end # module A
diff --git a/test/project/Extensions/ImplicitEnv/B/Project.toml b/test/project/Extensions/ImplicitEnv/B/Project.toml
new file mode 100644
index 0000000000000..d919c27be0467
--- /dev/null
+++ b/test/project/Extensions/ImplicitEnv/B/Project.toml
@@ -0,0 +1,3 @@
+name = "B"
+uuid = "c2c18cb0-3543-497c-ac2a-523c527589e5"
+version = "0.1.0"
diff --git a/test/project/Extensions/ImplicitEnv/B/src/B.jl b/test/project/Extensions/ImplicitEnv/B/src/B.jl
new file mode 100644
index 0000000000000..79b5a1204765f
--- /dev/null
+++ b/test/project/Extensions/ImplicitEnv/B/src/B.jl
@@ -0,0 +1,5 @@
+module B
+
+greet() = print("Hello World!")
+
+end # module B

From 8eaf83c036f0962fca5e2d6a1bbc8eb48e6e5444 Mon Sep 17 00:00:00 2001
From: mbeltagy <mohammed.elbeltagy@gmail.com>
Date: Wed, 14 Feb 2024 20:14:07 +0200
Subject: [PATCH 0934/1315] doc: clean up some example regex expressions
 (#26931)

Remove some unnecessary parts of regex expressions used as examples in
the docs.
---
 doc/src/manual/strings.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md
index ec146125024b8..f4acffb2ae91b 100644
--- a/doc/src/manual/strings.md
+++ b/doc/src/manual/strings.md
@@ -832,7 +832,7 @@ of the substring that matches, but perhaps we want to capture any non-blank text
 character. We could do the following:
 
 ```jldoctest
-julia> m = match(r"^\s*(?:#\s*(.*?)\s*$|$)", "# a comment ")
+julia> m = match(r"^\s*(?:#\s*(.*?)\s*$)", "# a comment ")
 RegexMatch("# a comment ", 1="a comment")
 ```
 
@@ -981,10 +981,10 @@ x   Tells the regular expression parser to ignore most whitespace
 For example, the following regex has all three flags turned on:
 
 ```jldoctest
-julia> r"a+.*b+.*?d$"ism
-r"a+.*b+.*?d$"ims
+julia> r"a+.*b+.*d$"ism
+r"a+.*b+.*d$"ims
 
-julia> match(r"a+.*b+.*?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
+julia> match(r"a+.*b+.*d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
 RegexMatch("angry,\nBad world")
 ```
 

From 3e6ff3d37161932f52c2461b3046be729ae1ca7f Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Wed, 14 Feb 2024 14:24:25 -0500
Subject: [PATCH 0935/1315] add ability to specify heap size hint as a percent
 (#52979)

also fix overflowed subtraction with size hints < 250mb --- we should
pick some minimum soft heap limit; I chose 1mb here but it could be
anything.
---
 doc/man/julia.1     |  4 ++--
 src/gc.c            | 18 +++++++++++++-----
 src/jloptions.c     | 14 ++++++++++++--
 test/cmdlineargs.jl | 22 ++++++++++++++++++++--
 4 files changed, 47 insertions(+), 11 deletions(-)

diff --git a/doc/man/julia.1 b/doc/man/julia.1
index a060c6dffb6b8..c58b00120b7ec 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -229,8 +229,8 @@ fallbacks to the latest compatible BugReporting.jl if not. For more information,
 
 .TP
 --heap-size-hint=<size>
-Forces garbage collection if memory usage is higher than that value. The memory hint might be
-specified in megabytes (500M) or gigabytes (1.5G)
+Forces garbage collection if memory usage is higher than that value. The value can be
+specified in units of K, M, G, T, or % of physical memory.
 
 .TP
 --compile={yes*|no|all|min}
diff --git a/src/gc.c b/src/gc.c
index 044dcf8113e9f..a920958307c48 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -4037,14 +4037,22 @@ void jl_gc_init(void)
     gc_num.max_pause = 0;
     gc_num.max_memory = 0;
 
+    uint64_t mem_reserve = 250*1024*1024; // LLVM + other libraries need some amount of memory
+    uint64_t min_heap_size_hint = mem_reserve + 1*1024*1024;
+    uint64_t hint = jl_options.heap_size_hint;
 #ifdef _P64
     total_mem = uv_get_total_memory();
-    uint64_t constrained_mem = uv_get_constrained_memory();
-    if (constrained_mem > 0 && constrained_mem < total_mem)
-        jl_gc_set_max_memory(constrained_mem - 250*1024*1024); // LLVM + other libraries need some amount of memory
+    if (hint == 0) {
+        uint64_t constrained_mem = uv_get_constrained_memory();
+        if (constrained_mem > 0 && constrained_mem < total_mem)
+            hint = constrained_mem;
+    }
 #endif
-    if (jl_options.heap_size_hint)
-        jl_gc_set_max_memory(jl_options.heap_size_hint - 250*1024*1024);
+    if (hint) {
+        if (hint < min_heap_size_hint)
+            hint = min_heap_size_hint;
+        jl_gc_set_max_memory(hint - mem_reserve);
+    }
 
     t_start = jl_hrtime();
 }
diff --git a/src/jloptions.c b/src/jloptions.c
index fa5d4ff43ee04..4b3f7209dc56d 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -189,7 +189,7 @@ static const char opts[]  =
     "                            --bug-report=help.\n\n"
 
     " --heap-size-hint=<size>    Forces garbage collection if memory usage is higher than that value.\n"
-    "                            The memory hint might be specified in megabytes(500M) or gigabytes(1G)\n\n"
+    "                            The value can be specified in units of K, M, G, T, or % of physical memory.\n\n"
 ;
 
 static const char opts_hidden[]  =
@@ -823,14 +823,24 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                         case 'T':
                             multiplier <<= 40;
                             break;
+                        case '%':
+                            if (value > 100)
+                                jl_errorf("julia: invalid percentage specified in --heap-size-hint");
+                            uint64_t mem = uv_get_total_memory();
+                            uint64_t cmem = uv_get_constrained_memory();
+                            if (cmem > 0 && cmem < mem)
+                                mem = cmem;
+                            multiplier = mem/100;
+                            break;
                         default:
+                            jl_errorf("julia: invalid unit specified in --heap-size-hint");
                             break;
                     }
                     jl_options.heap_size_hint = (uint64_t)(value * multiplier);
                 }
             }
             if (jl_options.heap_size_hint == 0)
-                jl_errorf("julia: invalid argument to --heap-size-hint without memory size specified");
+                jl_errorf("julia: invalid memory size specified in --heap-size-hint");
 
             break;
         case opt_gc_threads:
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 92bada23cb258..434f6be0d8b05 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -1043,8 +1043,26 @@ end
         @test lines[3] == "foo"
         @test lines[4] == "bar"
     end
-#heap-size-hint, we reserve 250 MB for non GC memory (llvm, etc.)
-@test readchomp(`$(Base.julia_cmd()) --startup-file=no --heap-size-hint=500M -e "println(@ccall jl_gc_get_max_memory()::UInt64)"`) == "$((500-250)*1024*1024)"
+end
+
+@testset "heap size hint" begin
+    #heap-size-hint, we reserve 250 MB for non GC memory (llvm, etc.)
+    @test readchomp(`$(Base.julia_cmd()) --startup-file=no --heap-size-hint=500M -e "println(@ccall jl_gc_get_max_memory()::UInt64)"`) == "$((500-250)*1024*1024)"
+
+    mem = ccall(:uv_get_total_memory, UInt64, ())
+    cmem = ccall(:uv_get_constrained_memory, UInt64, ())
+    if cmem > 0 && cmem < mem
+        mem = cmem
+    end
+    maxmem = parse(UInt64, readchomp(`$(Base.julia_cmd()) --startup-file=no --heap-size-hint=25% -e "println(@ccall jl_gc_get_max_memory()::UInt64)"`))
+    hint = max(mem÷4, 251*1024*1024) - 250*1024*1024
+    MAX32HEAP = 1536 * 1024 * 1024
+    if Int === Int32 && hint > MAX32HEAP
+        hint = MAX32HEAP
+    end
+    @test abs(Float64(maxmem) - hint)/maxmem < 0.05
+
+    @test readchomp(`$(Base.julia_cmd()) --startup-file=no --heap-size-hint=10M -e "println(@ccall jl_gc_get_max_memory()::UInt64)"`) == "$(1*1024*1024)"
 end
 
 ## `Main.main` entrypoint

From c23be9a0f7c0791b781b1c6bf74f3aa30127d223 Mon Sep 17 00:00:00 2001
From: Yuto Horikawa <hyrodium@gmail.com>
Date: Thu, 15 Feb 2024 10:53:14 +0900
Subject: [PATCH 0936/1315] Update style-guide with invalid constructor example
 (#53328)

---
 doc/src/manual/style-guide.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/doc/src/manual/style-guide.md b/doc/src/manual/style-guide.md
index 19b4908927187..92516623724b1 100644
--- a/doc/src/manual/style-guide.md
+++ b/doc/src/manual/style-guide.md
@@ -262,6 +262,29 @@ Splicing function arguments can be addictive. Instead of `[a..., b...]`, use sim
 which already concatenates arrays. [`collect(a)`](@ref) is better than `[a...]`, but since `a`
 is already iterable it is often even better to leave it alone, and not convert it to an array.
 
+## Ensure constructors return an instance of their own type
+
+When a method `T(x)` is called on a type `T`, it is generally expected to return a value of type T.
+Defining a [constructor](@ref man-constructors) that returns an unexpected type can lead to confusing and unpredictable behavior:
+
+```jldoctest
+julia> struct Foo{T}
+           x::T
+       end
+
+julia> Base.Float64(foo::Foo) = Foo(Float64(foo.x))  # Do not define methods like this
+
+julia> Float64(Foo(3))  # Should return `Float64`
+Foo{Float64}(3.0)
+
+julia> Foo{Int}(x) = Foo{Float64}(x)  # Do not define methods like this
+
+julia> Foo{Int}(3)  # Should return `Foo{Int}`
+Foo{Float64}(3.0)
+```
+
+To maintain code clarity and ensure type consistency, always design constructors to return an instance of the type they are supposed to construct.
+
 ## Don't use unnecessary static parameters
 
 A function signature:

From 254f2341239c64ede2384d7706aa0cdab4db2404 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Thu, 15 Feb 2024 10:16:03 +0800
Subject: [PATCH 0937/1315] Merge duplicate entries in results.json (#53334)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Should resolve #53198 🙂
---
 test/buildkitetestjson.jl | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/test/buildkitetestjson.jl b/test/buildkitetestjson.jl
index 2751122e1a5fe..336f9cb4ee181 100644
--- a/test/buildkitetestjson.jl
+++ b/test/buildkitetestjson.jl
@@ -123,13 +123,31 @@ end
 
 function collect_results!(results::Vector{Dict{String, Any}}, testset::Test.DefaultTestSet, prefix::String="")
     common_data = result_dict(testset, prefix)
+    result_offset = length(results) + 1
+    result_counts = Dict{Tuple{String, String}, Int}()
     for (i, result) in enumerate(testset.results)
         if result isa Test.Result
-            push!(results, merge(common_data, result_dict(result)))
+            rdata = result_dict(result)
+            rid = (rdata["location"], rdata["result"])
+            if haskey(result_counts, rid)
+                result_counts[rid] += 1
+            else
+                result_counts[rid] = 1
+                push!(results, merge(common_data, rdata))
+            end
         elseif result isa Test.DefaultTestSet
             collect_results!(results, result, common_data["scope"])
         end
     end
+    # Modify names to hold `result_counts`
+    for i in result_offset:length(results)
+        result = results[i]
+        rid = (result["location"], result["result"])
+        if get(result_counts, rid, 0) > 1
+            result["name"] = replace(result["name"], r"^([^:]):" =>
+                SubstitutionString("\\1 (x$(result_counts[rid])):"))
+        end
+    end
     results
 end
 

From 4c2633c55a968b3d3a7085f021f33d5109f0a233 Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Thu, 15 Feb 2024 10:16:43 +0800
Subject: [PATCH 0938/1315] Fix results.json generation after chunk-splitting
 (#53335)

Should fix the problem raised in
https://github.com/JuliaLang/julia/pull/53323#issuecomment-1943007134.
---
 test/buildkitetestjson.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/buildkitetestjson.jl b/test/buildkitetestjson.jl
index 336f9cb4ee181..8410913e48ef2 100644
--- a/test/buildkitetestjson.jl
+++ b/test/buildkitetestjson.jl
@@ -29,7 +29,7 @@ function json_repr(io::IO, val::String; indent::Int=0)
 end
 json_repr(io::IO, val::Integer; indent::Int=0) = print(io, val)
 json_repr(io::IO, val::Float64; indent::Int=0) = print(io, val)
-function json_repr(io::IO, val::Vector; indent::Int=0)
+function json_repr(io::IO, val::AbstractVector; indent::Int=0)
     print(io, '[')
     for elt in val
         print(io, '\n', ' '^(indent + 2))

From 2c0098e8cb26423c74aaa514f0f6a3b8d395ad1e Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Wed, 14 Feb 2024 21:22:21 -0500
Subject: [PATCH 0939/1315] Cleanups for tagged code instance (#53336)

Two small cleanups to #52233
- Don't use foreign code-instances for native code caching decision
making
- don't return a non-native codeinst for jl_method_compiled

---------

Co-authored-by: Keno Fischer <keno@juliahub.com>
---
 src/gf.c               | 5 +++--
 src/precompile_utils.c | 5 ++++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/gf.c b/src/gf.c
index 00613cf9da486..20179157ff836 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -2368,12 +2368,13 @@ jl_method_instance_t *jl_get_unspecialized(jl_method_t *def JL_PROPAGATES_ROOT)
 jl_code_instance_t *jl_method_compiled(jl_method_instance_t *mi, size_t world)
 {
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
-    while (codeinst) {
+    for (; codeinst; codeinst = jl_atomic_load_relaxed(&codeinst->next)) {
+        if (codeinst->owner != jl_nothing)
+            continue;
         if (jl_atomic_load_relaxed(&codeinst->min_world) <= world && world <= jl_atomic_load_relaxed(&codeinst->max_world)) {
             if (jl_atomic_load_relaxed(&codeinst->invoke) != NULL)
                 return codeinst;
         }
-        codeinst = jl_atomic_load_relaxed(&codeinst->next);
     }
     return NULL;
 }
diff --git a/src/precompile_utils.c b/src/precompile_utils.c
index 338c62b7e2d72..35dc0e2f59493 100644
--- a/src/precompile_utils.c
+++ b/src/precompile_utils.c
@@ -182,7 +182,10 @@ static int precompile_enq_specialization_(jl_method_instance_t *mi, void *closur
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
     while (codeinst) {
         int do_compile = 0;
-        if (jl_atomic_load_relaxed(&codeinst->invoke) != jl_fptr_const_return) {
+        if (codeinst->owner != jl_nothing) {
+            // TODO(vchuravy) native code caching for foreign interpreters
+        }
+        else if (jl_atomic_load_relaxed(&codeinst->invoke) != jl_fptr_const_return) {
             jl_value_t *inferred = jl_atomic_load_relaxed(&codeinst->inferred);
             if (inferred &&
                 inferred != jl_nothing &&

From 7fcf9c88185ba53ef1dcb685ce55adec56b27efc Mon Sep 17 00:00:00 2001
From: Rafael Fourquet <fourquet.rafael@gmail.com>
Date: Thu, 15 Feb 2024 03:38:27 +0100
Subject: [PATCH 0940/1315] Random: make statistical uniform tests fail less
 often (#52165)

We have a very basic test to check that a distribution might be uniform:
all the sampled elements should be unique, under certain conditions. But
these conditions allowed the tests to fail too often. So allow one
collision if the probability of such an event is too high.

Fix #52156.

---------

Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
---
 stdlib/Random/test/runtests.jl | 25 ++++++++++++++++++++-----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/stdlib/Random/test/runtests.jl b/stdlib/Random/test/runtests.jl
index 16a2f89753f3b..9b46951f63ff5 100644
--- a/stdlib/Random/test/runtests.jl
+++ b/stdlib/Random/test/runtests.jl
@@ -16,15 +16,30 @@ using Random: jump_128, jump_192, jump_128!, jump_192!
 import Future # randjump
 
 function test_uniform(xs::AbstractArray{T}) where {T<:AbstractFloat}
-    if precision(T) >= precision(Float32) # TODO: refine
-        @test allunique(xs)
+    # TODO: refine
+    prec = isempty(xs) ? precision(T) : precision(first(xs))
+    proba_nocollision = prod((1.0 - i/2.0^prec for i=1:length(xs)-1), init=1.0) # rough estimate
+    xsu = Set(xs)
+    if (1.0 - proba_nocollision) < 2.0^-64
+        @test length(xsu) == length(xs)
+    elseif prec > 52 && length(xs) < 3000
+        # if proba of collisions is high enough, allow at most one collision;
+        # with the constraints on precision and length, more than one collision would happen
+        # with proba less than 2.0^-62
+        @test length(xsu) >= length(xs)-1
     end
     @test all(x -> zero(x) <= x < one(x), xs)
 end
 
-function test_uniform(xs::AbstractArray{T}) where {T<:Integer}
-    if !Base.hastypemax(T) || widen(typemax(T)) - widen(typemin(T)) >= 2^30 # TODO: refine
-        @test allunique(xs)
+function test_uniform(xs::AbstractArray{T}) where {T<:Base.BitInteger}
+    # TODO: refine
+    prec = 8*sizeof(T)
+    proba_nocollision = prod((1.0 - i/2.0^prec for i=1:length(xs)-1), init=1.0)
+    xsu = Set(xs)
+    if (1.0 - proba_nocollision) < 2.0^-64
+        @test length(xsu) == length(xs)
+    elseif prec > 52 && length(xs) < 3000
+        @test length(xsu) >= length(xs)-1
     end
 end
 

From 2197b5c9ed926c20ca03c6bf6fa903edd96ab6b1 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Thu, 15 Feb 2024 10:04:28 +0100
Subject: [PATCH 0941/1315] add Base.wrap to docs

---
 doc/src/base/arrays.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/src/base/arrays.md b/doc/src/base/arrays.md
index 20e8e81614b9e..f7ea23ad3b556 100644
--- a/doc/src/base/arrays.md
+++ b/doc/src/base/arrays.md
@@ -139,6 +139,7 @@ Base.reshape
 Base.dropdims
 Base.vec
 Base.SubArray
+Base.wrap
 ```
 
 ## Concatenation and permutation

From 61c3521613767b2af21dfa5cc5a7b8195c5bdcaf Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Thu, 15 Feb 2024 18:26:34 +0800
Subject: [PATCH 0942/1315] More cautious legacy_color conversion in Logging
 (#53280)

Can be seen as a follow-on from #51829, also wants
https://github.com/JuliaLang/StyledStrings.jl/pull/37
 to behave as expected.
---
 stdlib/Logging/src/ConsoleLogger.jl | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/stdlib/Logging/src/ConsoleLogger.jl b/stdlib/Logging/src/ConsoleLogger.jl
index 0922e9fcc66c9..ef901ebbbbc5d 100644
--- a/stdlib/Logging/src/ConsoleLogger.jl
+++ b/stdlib/Logging/src/ConsoleLogger.jl
@@ -148,7 +148,10 @@ function handle_message(logger::ConsoleLogger, level::LogLevel, message, _module
     # Format lines as text with appropriate indentation and with a box
     # decoration on the left.
     color, prefix, suffix = logger.meta_formatter(level, _module, group, id, filepath, line)::Tuple{Union{Symbol,Int},String,String}
-    color = StyledStrings.Face(foreground=StyledStrings.Legacy.legacy_color(color))
+    lcolor = StyledStrings.Legacy.legacy_color(color)
+    if !isnothing(lcolor)
+        color = StyledStrings.Face(foreground=lcolor)
+    end
     minsuffixpad = 2
     buf = IOBuffer()
     iob = IOContext(buf, stream)

From c7eb7666b7f404a78d572332c3f9606a1e2e36e4 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 15 Feb 2024 23:06:58 +0900
Subject: [PATCH 0943/1315] minor refactoring on the
 `CustomAbstractInterpreterCaching` test case (#53329)

By using `@newinterp`. Also ensures `cache_owner` for external abstract
interpreter defined by `@newinterp` is unique always.
---
 test/compiler/newinterp.jl |   4 +-
 test/precompile.jl         | 100 +++++++++++++++++++------------------
 2 files changed, 54 insertions(+), 50 deletions(-)

diff --git a/test/compiler/newinterp.jl b/test/compiler/newinterp.jl
index 1157a52ebbcbe..74a2b29cabc28 100644
--- a/test/compiler/newinterp.jl
+++ b/test/compiler/newinterp.jl
@@ -9,7 +9,7 @@ Defines new `NewInterpreter <: AbstractInterpreter` whose cache is separated
 from the native code cache, satisfying the minimum interface requirements.
 """
 macro newinterp(InterpName)
-    InterpCacheName = QuoteNode(Symbol(string(InterpName, "Cache")))
+    cache_token = QuoteNode(gensym(string(InterpName, "Cache")))
     InterpName = esc(InterpName)
     C = Core
     CC = Core.Compiler
@@ -32,6 +32,6 @@ macro newinterp(InterpName)
         $CC.OptimizationParams(interp::$InterpName) = interp.opt_params
         $CC.get_inference_world(interp::$InterpName) = interp.world
         $CC.get_inference_cache(interp::$InterpName) = interp.inf_cache
-        $CC.cache_owner(::$InterpName) = $InterpCacheName
+        $CC.cache_owner(::$InterpName) = $cache_token
     end
 end
diff --git a/test/precompile.jl b/test/precompile.jl
index 129f909dcf6e2..c4cceced8235b 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1712,67 +1712,71 @@ precompile_test_harness("issue #46296") do load_path
     (@eval (using CodeInstancePrecompile))
 end
 
-precompile_test_harness("AbstractInterpreter caching") do load_path
-    write(joinpath(load_path, "SimpleModule.jl"),
-        """
-        module SimpleModule
+let newinterp_path = abspath("compiler/newinterp.jl")
+    precompile_test_harness("AbstractInterpreter caching") do load_path
+        write(joinpath(load_path, "SimpleModule.jl"), :(module SimpleModule
             basic_callee(x) = x
             basic_caller(x) = basic_callee(x)
-        end
-        """)
-    write(joinpath(load_path, "CustomAbstractInterpreterCaching.jl"),
-        """
-        module CustomAbstractInterpreterCaching
+        end) |> string)
+
+        write(joinpath(load_path, "CustomAbstractInterpreterCaching.jl"), :(module CustomAbstractInterpreterCaching
             import SimpleModule: basic_caller, basic_callee
+
             module Custom
                 const CC = Core.Compiler
-
-                struct InvalidationTesterToken end
-
-                struct InvalidationTester <: CC.AbstractInterpreter
-                    world::UInt
-                    inf_params::CC.InferenceParams
-                    opt_params::CC.OptimizationParams
-                    inf_cache::Vector{CC.InferenceResult}
-                    function InvalidationTester(;
-                                                world::UInt = Base.get_world_counter(),
-                                                inf_params::CC.InferenceParams = CC.InferenceParams(),
-                                                opt_params::CC.OptimizationParams = CC.OptimizationParams(),
-                                                inf_cache::Vector{CC.InferenceResult} = CC.InferenceResult[])
-                        return new(world, inf_params, opt_params, inf_cache)
-                    end
-                end
-
-                CC.InferenceParams(interp::InvalidationTester) = interp.inf_params
-                CC.OptimizationParams(interp::InvalidationTester) = interp.opt_params
-                CC.get_inference_world(interp::InvalidationTester) = interp.world
-                CC.get_inference_cache(interp::InvalidationTester) = interp.inf_cache
-                CC.cache_owner(::InvalidationTester) = InvalidationTesterToken()
+                include("$($newinterp_path)")
+                @newinterp PrecompileInterpreter
             end
 
             Base.return_types((Float64,)) do x
                 basic_caller(x)
             end
-            Base.return_types((Float64,); interp=Custom.InvalidationTester()) do x
+            Base.return_types((Float64,); interp=Custom.PrecompileInterpreter()) do x
                 basic_caller(x)
             end
+            Base.return_types((Vector{Float64},)) do x
+                sum(x)
+            end
+            Base.return_types((Vector{Float64},); interp=Custom.PrecompileInterpreter()) do x
+                sum(x)
+            end
+        end) |> string)
+        Base.compilecache(Base.PkgId("CustomAbstractInterpreterCaching"))
+        @eval let
+            using CustomAbstractInterpreterCaching
+            cache_owner = Core.Compiler.cache_owner(
+                CustomAbstractInterpreterCaching.Custom.PrecompileInterpreter())
+            let m = only(methods(CustomAbstractInterpreterCaching.basic_callee))
+                mi = only(Base.specializations(m))
+                ci = mi.cache
+                @test isdefined(ci, :next)
+                @test ci.owner === nothing
+                @test ci.max_world == typemax(UInt)
+                ci = ci.next
+                @test !isdefined(ci, :next)
+                @test ci.owner === cache_owner
+                @test ci.max_world == typemax(UInt)
+            end
+            let m = only(methods(sum, (Vector{Float64},)))
+                found = false
+                for mi in Base.specializations(m)
+                    if mi isa Core.MethodInstance && mi.specTypes == Tuple{typeof(sum),Vector{Float64}}
+                        ci = mi.cache
+                        @test isdefined(ci, :next)
+                        @test ci.owner === cache_owner
+                        @test ci.max_world == typemax(UInt)
+                        ci = ci.next
+                        @test !isdefined(ci, :next)
+                        @test ci.owner === nothing
+                        @test ci.max_world == typemax(UInt)
+                        found = true
+                        break
+                    end
+                end
+                @test found
+            end
         end
-        """)
-    Base.compilecache(Base.PkgId("CustomAbstractInterpreterCaching"))
-    (@eval begin
-        using CustomAbstractInterpreterCaching
-        let m = only(methods(CustomAbstractInterpreterCaching.basic_callee))
-            mi = only(Base.specializations(m))
-            ci = mi.cache
-            @test isdefined(ci, :next)
-            @test ci.owner === nothing
-            @test ci.max_world == typemax(UInt)
-            ci = ci.next
-            @test !isdefined(ci, :next)
-            @test ci.owner === CustomAbstractInterpreterCaching.Custom.InvalidationTesterToken()
-            @test ci.max_world == typemax(UInt)
-        end
-    end)
+    end
 end
 
 precompile_test_harness("Recursive types") do load_path

From 1b25d1e1e461dbd4b13d73dcc9ec8b38741fe5c8 Mon Sep 17 00:00:00 2001
From: Nathan Boyer <65452054+nathanrboyer@users.noreply.github.com>
Date: Thu, 15 Feb 2024 10:25:31 -0500
Subject: [PATCH 0944/1315] Add CartesianIndex to getindex docstring (#51567)

Co-authored-by: Matt Bauman <mbauman@gmail.com>
Co-authored-by: Denis Barucic <barucic.d@gmail.com>
Co-authored-by: Jishnu Bhattacharya <jishnub.github@gmail.com>
Co-authored-by: Max Horn <max@quendi.de>
---
 base/abstractarray.jl | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 90398d98465df..59ba7ad82c7f0 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1274,8 +1274,11 @@ end
 """
     getindex(A, inds...)
 
-Return a subset of array `A` as specified by `inds`, where each `ind` may be,
-for example, an `Int`, an [`AbstractRange`](@ref), or a [`Vector`](@ref).
+Return a subset of array `A` as selected by the indices `inds`.
+
+Each index may be any [supported index type](@ref man-supported-index-types), such
+as an [`Integer`](@ref), [`CartesianIndex`](@ref), [range](@ref Base.AbstractRange), or [array](@ref man-multi-dim-arrays) of supported indices.
+A [:](@ref Base.Colon) may be used to select all elements along a specific dimension, and a boolean array (e.g. an `Array{Bool}` or a [`BitArray`](@ref)) may be used to filter for elements where the corresponding index is `true`.
 
 When `inds` selects multiple elements, this function returns a newly
 allocated array. To index multiple elements without making a copy,
@@ -1303,6 +1306,27 @@ julia> getindex(A, 2:4)
  3
  2
  4
+
+julia> getindex(A, 2, 1)
+3
+
+julia> getindex(A, CartesianIndex(2, 1))
+3
+
+julia> getindex(A, :, 2)
+2-element Vector{Int64}:
+ 2
+ 4
+
+julia> getindex(A, 2, :)
+2-element Vector{Int64}:
+ 3
+ 4
+
+julia> getindex(A, A .> 2)
+2-element Vector{Int64}:
+ 3
+ 4
 ```
 """
 function getindex(A::AbstractArray, I...)

From e460d357d48d121f55e8007d35f6848e9983cfac Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 15 Feb 2024 21:25:51 +0530
Subject: [PATCH 0945/1315] Support `signbit(::Dates.Period)` (#51073)

---
 stdlib/Dates/src/periods.jl  | 1 +
 stdlib/Dates/test/periods.jl | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/stdlib/Dates/src/periods.jl b/stdlib/Dates/src/periods.jl
index c1d94d3d62321..c88a1bed4bba9 100644
--- a/stdlib/Dates/src/periods.jl
+++ b/stdlib/Dates/src/periods.jl
@@ -102,6 +102,7 @@ div(x::Period, y::Period, r::RoundingMode) = div(promote(x, y)..., r)
 Base.gcdx(a::T, b::T) where {T<:Period} = ((g, x, y) = gcdx(value(a), value(b)); return T(g), x, y)
 Base.abs(a::T) where {T<:Period} = T(abs(value(a)))
 Base.sign(x::Period) = sign(value(x))
+Base.signbit(x::Period) = signbit(value(x))
 
 # return (next coarser period, conversion factor):
 coarserperiod(::Type{P}) where {P<:Period} = (P, 1)
diff --git a/stdlib/Dates/test/periods.jl b/stdlib/Dates/test/periods.jl
index 7cebfc55e7735..9c7d0deef8a11 100644
--- a/stdlib/Dates/test/periods.jl
+++ b/stdlib/Dates/test/periods.jl
@@ -30,6 +30,9 @@ using Test
     @test sign(t) == sign(t2) == 1
     @test sign(-t) == sign(-t2) == -1
     @test sign(Dates.Year(0)) == 0
+    @test signbit(t) == signbit(t2) == false
+    @test signbit(-t) == signbit(-t2) == true
+    @test signbit(Dates.Year(0)) == false
 end
 @testset "div/mod/gcd/lcm/rem" begin
     @test Dates.Year(10) % Dates.Year(4) == Dates.Year(2)

From 4118db8d6d294a26ae819f7c4c97f829bd307dbe Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 16 Feb 2024 03:40:26 +0100
Subject: [PATCH 0946/1315] update `--pkgimages=existing` option in CLI section
 of manual (#53343)

---
 doc/src/manual/command-line-interface.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index d56b27622532c..4faa3e8d3fc05 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -173,7 +173,7 @@ The following is a complete list of command-line switches available when launchi
 |`--handle-signals={yes*\|no}`          |Enable or disable Julia's default signal handlers|
 |`--sysimage-native-code={yes*\|no}`    |Use native code from system image if available|
 |`--compiled-modules={yes*\|no\|existing|strict}` |Enable or disable incremental precompilation of modules. The `existing` option allows use of existing compiled modules that were previously precompiled, but disallows creation of new precompile files. The `strict` option is similar, but will error if no precompile file is found. |
-|`--pkgimages={yes*\|no}`               |Enable or disable usage of native code caching in the form of pkgimages|
+|`--pkgimages={yes*\|no|existing}`               |Enable or disable usage of native code caching in the form of pkgimages. The `existing` option allows use of existing pkgimages but disallows creation of new ones|
 |`-e`, `--eval <expr>`                  |Evaluate `<expr>`|
 |`-E`, `--print <expr>`                 |Evaluate `<expr>` and display the result|
 |`-L`, `--load <file>`                  |Load `<file>` immediately on all processors|

From aecd8fd379a53afa780bc8a8404728b6aa22d6bc Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 16 Feb 2024 08:10:57 +0530
Subject: [PATCH 0947/1315] Propagate inbounds in isassigned with
 CartesianIndex indices (#53305)

Close #53302

---------

Co-authored-by: Matt Bauman <mbauman@juliahub.com>
---
 base/multidimensional.jl | 20 ++++++++++++--------
 test/abstractarray.jl    | 14 +++++++++++++-
 2 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index ed0a48b4f23cf..146f8c160e8e9 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -1582,19 +1582,23 @@ end
     end
 end
 
-isassigned(a::AbstractArray, i::CartesianIndex) = isassigned(a, Tuple(i)...)
-function isassigned(A::AbstractArray, i::Union{Integer, CartesianIndex}...)
-    isa(i, Tuple{Vararg{Int}}) || return isassigned(A, CartesianIndex(to_indices(A, i)))
-    @boundscheck checkbounds(Bool, A, i...) || return false
+@propagate_inbounds isassigned(A::AbstractArray, i::CartesianIndex) = isassigned(A, Tuple(i)...)
+@propagate_inbounds function isassigned(A::AbstractArray, i::Union{Integer, CartesianIndex}...)
+    return isassigned(A, CartesianIndex(to_indices(A, i)))
+end
+@inline function isassigned(A::AbstractArray, i::Integer...)
+    # convert to valid indices, checking for Bool
+    inds = to_indices(A, i)
+    @boundscheck checkbounds(Bool, A, inds...) || return false
     S = IndexStyle(A)
-    ninds = length(i)
+    ninds = length(inds)
     if (isa(S, IndexLinear) && ninds != 1)
-        return @inbounds isassigned(A, _to_linear_index(A, i...))
+        return @inbounds isassigned(A, _to_linear_index(A, inds...))
     elseif (!isa(S, IndexLinear) && ninds != ndims(A))
-        return @inbounds isassigned(A, _to_subscript_indices(A, i...)...)
+        return @inbounds isassigned(A, _to_subscript_indices(A, inds...)...)
     else
        try
-            A[i...]
+            A[inds...]
             true
         catch e
             if isa(e, BoundsError) || isa(e, UndefRefError)
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 12b6b88d3f6f1..8392d533261b3 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -548,12 +548,24 @@ function test_primitives(::Type{T}, shape, ::Type{TestAbstractArray}) where T
     @test firstindex(B, 1) == firstindex(A, 1) == first(axes(B, 1))
     @test firstindex(B, 2) == firstindex(A, 2) == first(axes(B, 2))
 
-    # isassigned(a::AbstractArray, i::Int...)
+    @test !isassigned(B)
+    # isassigned(a::AbstractArray, i::Integer...)
     j = rand(1:length(B))
     @test isassigned(B, j)
     if T == T24Linear
         @test !isassigned(B, length(B) + 1)
     end
+    # isassigned(a::AbstractArray, i::CartesianIndex)
+    @test isassigned(B, first(CartesianIndices(B)))
+    ind = last(CartesianIndices(B))
+    @test !isassigned(B, ind + oneunit(ind))
+    # isassigned(a::AbstractArray, i::Union{Integer,CartesianIndex}...)
+    @test isassigned(B, Int16.(first.(axes(B)))..., CartesianIndex(1,1))
+    # Bool isn't a valid index
+    @test_throws ArgumentError isassigned(B, Bool.(first.(axes(B)))..., CartesianIndex(1,1))
+    @test_throws ArgumentError isassigned(B, Bool.(first.(axes(B)))...)
+    @test_throws ArgumentError isassigned(B, true)
+    @test_throws ArgumentError isassigned(B, false)
 
     # reshape(a::AbstractArray, dims::Dims)
     @test_throws DimensionMismatch reshape(B, (0, 1))

From 7053e4c26422ca821551a2b76ad08c16d81f999e Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 16 Feb 2024 09:58:28 +0100
Subject: [PATCH 0948/1315] set VERSION to 1.12.0-DEV (#53346)

---
 VERSION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/VERSION b/VERSION
index 0bc25cfcab2c1..f6c25a3020b69 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.11.0-DEV
+1.12.0-DEV

From b4266e897d0a74d828906b4b2b7f4999786a8b66 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 16 Feb 2024 10:09:10 +0100
Subject: [PATCH 0949/1315] use a separate depot for `--pkgimages` loading test
 (#53344)

Otherwise this will write compile files to your home directory (and you
get confused in the debug output next time you run the tests due to old
precompile files being there)
---
 test/loading.jl | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/loading.jl b/test/loading.jl
index 53e05a4a76bbc..4a72a0f8060ad 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1439,7 +1439,7 @@ end
 end
 
 @testset "command-line flags" begin
-    mktempdir() do dir
+    mktempdir() do depot_path mktempdir() do dir
         # generate a Parent.jl and Child.jl package, with Parent depending on Child
         open(joinpath(dir, "Child.jl"), "w") do io
             println(io, """
@@ -1458,6 +1458,7 @@ end
             code = "using $name"
             cmd = addenv(`$(Base.julia_cmd()) -e $code $args`,
                         "JULIA_LOAD_PATH" => dir,
+                        "JULIA_DEPOT_PATH" => depot_path,
                         "JULIA_DEBUG" => "loading")
 
             out = Pipe()
@@ -1514,7 +1515,7 @@ end
         @test occursin(r"Loading object cache file .+ for Child", log)
         @test occursin(r"Generating object cache file for Parent", log)
         @test occursin(r"Loading object cache file .+ for Parent", log)
-    end
+    end end
 end
 
 @testset "including non-existent file throws proper error #52462" begin

From 3ed2b497910e091c80035339598e4c28d98b7188 Mon Sep 17 00:00:00 2001
From: Michael Abbott <32575566+mcabbott@users.noreply.github.com>
Date: Fri, 16 Feb 2024 09:00:02 -0500
Subject: [PATCH 0950/1315] Add a lazy `logrange` function and `LogRange` type
 (#39071)

---
 NEWS.md                |   1 +
 base/exports.jl        |   2 +
 base/range.jl          | 190 ++++++++++++++++++++++++++++++++++++++++-
 base/show.jl           |   7 ++
 base/twiceprecision.jl |  16 ++++
 doc/src/base/math.md   |   2 +
 test/ranges.jl         |  83 ++++++++++++++++++
 7 files changed, 297 insertions(+), 4 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index fc3a2304ea72a..42d36b606e839 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -83,6 +83,7 @@ New library functions
 
 * `in!(x, s::AbstractSet)` will return whether `x` is in `s`, and insert `x` in `s` if not.
 * The new `Libc.mkfifo` function wraps the `mkfifo` C function on Unix platforms ([#34587]).
+* `logrange(start, stop; length)` makes a range of constant ratio, instead of constant step ([#39071])
 * `copyuntil(out, io, delim)` and `copyline(out, io)` copy data into an `out::IO` stream ([#48273]).
 * `eachrsplit(string, pattern)` iterates split substrings right to left.
 * `Sys.username()` can be used to return the current user's username ([#51897]).
diff --git a/base/exports.jl b/base/exports.jl
index fbb5b449719d6..a31ea1b0fa842 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -412,6 +412,7 @@ export
     isperm,
     issorted,
     last,
+    logrange,
     mapslices,
     max,
     maximum!,
@@ -1095,6 +1096,7 @@ public
     Generator,
     ImmutableDict,
     OneTo,
+    LogRange,
     AnnotatedString,
     AnnotatedChar,
     UUID,
diff --git a/base/range.jl b/base/range.jl
index 9480b46d8fcf1..4f92b305564cd 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -70,6 +70,7 @@ Valid invocations of range are:
 * Call `range` with one of `stop` or `length`. `start` and `step` will be assumed to be one.
 
 See Extended Help for additional details on the returned type.
+See also [`logrange`](@ref) for logarithmically spaced points.
 
 # Examples
 ```jldoctest
@@ -252,10 +253,13 @@ end
 ## 1-dimensional ranges ##
 
 """
-    AbstractRange{T}
+    AbstractRange{T} <: AbstractVector{T}
 
-Supertype for ranges with elements of type `T`.
-[`UnitRange`](@ref) and other types are subtypes of this.
+Supertype for linear ranges with elements of type `T`.
+[`UnitRange`](@ref), [`LinRange`](@ref) and other types are subtypes of this.
+
+All subtypes must define [`step`](@ref).
+Thus [`LogRange`](@ref Base.LogRange) is not a subtype of `AbstractRange`.
 """
 abstract type AbstractRange{T} <: AbstractArray{T,1} end
 
@@ -550,6 +554,8 @@ julia> collect(LinRange(-0.1, 0.3, 5))
   0.19999999999999998
   0.3
 ```
+
+See also [`Logrange`](@ref Base.LogRange) for logarithmically spaced points.
 """
 struct LinRange{T,L<:Integer} <: AbstractRange{T}
     start::T
@@ -620,7 +626,7 @@ parameters `pre` and `post` characters for each printed row,
 `sep` separator string between printed elements,
 `hdots` string for the horizontal ellipsis.
 """
-function print_range(io::IO, r::AbstractRange,
+function print_range(io::IO, r::AbstractArray,
                      pre::AbstractString = " ",
                      sep::AbstractString = ", ",
                      post::AbstractString = "",
@@ -1488,3 +1494,179 @@ julia> mod(3, 0:2)  # mod(3, 3)
 """
 mod(i::Integer, r::OneTo) = mod1(i, last(r))
 mod(i::Integer, r::AbstractUnitRange{<:Integer}) = mod(i-first(r), length(r)) + first(r)
+
+
+"""
+    logrange(start, stop, length)
+    logrange(start, stop; length)
+
+Construct a specialized array whose elements are spaced logarithmically
+between the given endpoints. That is, the ratio of successive elements is
+a constant, calculated from the length.
+
+This is similar to `geomspace` in Python. Unlike `PowerRange` in Mathematica,
+you specify the number of elements not the ratio.
+Unlike `logspace` in Python and Matlab, the `start` and `stop` arguments are
+always the first and last elements of the result, not powers applied to some base.
+
+# Examples
+```jldoctest
+julia> logrange(10, 4000, length=3)
+3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
+ 10.0, 200.0, 4000.0
+
+julia> ans[2] ≈ sqrt(10 * 4000)  # middle element is the geometric mean
+true
+
+julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # arithmetic mean
+true
+
+julia> logrange(1f0, 32f0, 11)
+11-element Base.LogRange{Float32, Float64}:
+ 1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0
+
+julia> logrange(1, 1000, length=4) ≈ 10 .^ (0:3)
+true
+```
+
+See the [`LogRange`](@ref Base.LogRange) type for further details.
+
+See also [`range`](@ref) for linearly spaced points.
+
+!!! compat "Julia 1.11"
+    This function requires at least Julia 1.11.
+"""
+logrange(start::Real, stop::Real, length::Integer) = LogRange(start, stop, Int(length))
+logrange(start::Real, stop::Real; length::Integer) = logrange(start, stop, length)
+
+
+"""
+    LogRange{T}(start, stop, len) <: AbstractVector{T}
+
+A range whose elements are spaced logarithmically between `start` and `stop`,
+with spacing controlled by `len`. Returned by [`logrange`](@ref).
+
+Like [`LinRange`](@ref), the first and last elements will be exactly those
+provided, but intermediate values may have small floating-point errors.
+These are calculated using the logs of the endpoints, which are
+stored on construction, often in higher precision than `T`.
+
+# Examples
+```jldoctest
+julia> logrange(1, 4, length=5)
+5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
+ 1.0, 1.41421, 2.0, 2.82843, 4.0
+
+julia> Base.LogRange{Float16}(1, 4, 5)
+5-element Base.LogRange{Float16, Float64}:
+ 1.0, 1.414, 2.0, 2.828, 4.0
+
+julia> logrange(1e-310, 1e-300, 11)[1:2:end]
+6-element Vector{Float64}:
+ 1.0e-310
+ 9.999999999999974e-309
+ 9.999999999999981e-307
+ 9.999999999999988e-305
+ 9.999999999999994e-303
+ 1.0e-300
+
+julia> prevfloat(1e-308, 5) == ans[2]
+true
+```
+
+Note that integer eltype `T` is not allowed.
+Use for instance `round.(Int, xs)`, or explicit powers of some integer base:
+
+```jldoctest
+julia> xs = logrange(1, 512, 4)
+4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
+ 1.0, 8.0, 64.0, 512.0
+
+julia> 2 .^ (0:3:9) |> println
+[1, 8, 64, 512]
+```
+
+!!! compat "Julia 1.11"
+    This type requires at least Julia 1.11.
+"""
+struct LogRange{T<:Real,X} <: AbstractArray{T,1}
+    start::T
+    stop::T
+    len::Int
+    extra::Tuple{X,X}
+    function LogRange{T}(start::T, stop::T, len::Int) where {T<:Real}
+        if T <: Integer
+            # LogRange{Int}(1, 512, 4) produces InexactError: Int64(7.999999999999998)
+            throw(ArgumentError("LogRange{T} does not support integer types"))
+        end
+        if iszero(start) || iszero(stop)
+            throw(DomainError((start, stop),
+                "LogRange cannot start or stop at zero"))
+        elseif start < 0 || stop < 0
+            # log would throw, but _log_twice64_unchecked does not
+            throw(DomainError((start, stop),
+                "LogRange does not accept negative numbers"))
+        elseif !isfinite(start) || !isfinite(stop)
+            throw(DomainError((start, stop),
+                "LogRange is only defined for finite start & stop"))
+        elseif len < 0
+            throw(ArgumentError(LazyString(
+                "LogRange(", start, ", ", stop, ", ", len, "): can't have negative length")))
+        elseif len == 1 && start != stop
+            throw(ArgumentError(LazyString(
+                "LogRange(", start, ", ", stop, ", ", len, "): endpoints differ, while length is 1")))
+        end
+        ex = _logrange_extra(start, stop, len)
+        new{T,typeof(ex[1])}(start, stop, len, ex)
+    end
+end
+
+function LogRange{T}(start::Real, stop::Real, len::Integer) where {T}
+    LogRange{T}(convert(T, start), convert(T, stop), convert(Int, len))
+end
+function LogRange(start::Real, stop::Real, len::Integer)
+    T = float(promote_type(typeof(start), typeof(stop)))
+    LogRange{T}(convert(T, start), convert(T, stop), convert(Int, len))
+end
+
+size(r::LogRange) = (r.len,)
+length(r::LogRange) = r.len
+
+first(r::LogRange) = r.start
+last(r::LogRange) = r.stop
+
+function _logrange_extra(a::Real, b::Real, len::Int)
+    loga = log(1.0 * a)  # widen to at least Float64
+    logb = log(1.0 * b)
+    (loga/(len-1), logb/(len-1))
+end
+function _logrange_extra(a::Float64, b::Float64, len::Int)
+    loga = _log_twice64_unchecked(a)
+    logb = _log_twice64_unchecked(b)
+    # The reason not to do linear interpolation on log(a)..log(b) in `getindex` is
+    # that division of TwicePrecision is quite slow, so do it once on construction:
+    (loga/(len-1), logb/(len-1))
+end
+
+function getindex(r::LogRange{T}, i::Int) where {T}
+    @inline
+    @boundscheck checkbounds(r, i)
+    i == 1 && return r.start
+    i == r.len && return r.stop
+    # Main path uses Math.exp_impl for TwicePrecision, but is not perfectly
+    # accurate, hence the special cases for endpoints above.
+    logx = (r.len-i) * r.extra[1] + (i-1) * r.extra[2]
+    x = _exp_allowing_twice64(logx)
+    return T(x)
+end
+
+function show(io::IO, r::LogRange{T}) where {T}
+    print(io, "LogRange{", T, "}(")
+    ioc = IOContext(io, :typeinfo => T)
+    show(ioc, first(r))
+    print(io, ", ")
+    show(ioc, last(r))
+    print(io, ", ")
+    show(io, length(r))
+    print(io, ')')
+end
diff --git a/base/show.jl b/base/show.jl
index a5bf5f73ba0ed..217b22ab39ef8 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -23,6 +23,13 @@ function show(io::IO, ::MIME"text/plain", r::LinRange)
     print_range(io, r)
 end
 
+function show(io::IO, ::MIME"text/plain", r::LogRange)  # display LogRange like LinRange
+    isempty(r) && return show(io, r)
+    summary(io, r)
+    println(io, ":")
+    print_range(io, r, " ", ", ", "", " \u2026 ")
+end
+
 function _isself(ft::DataType)
     ftname = ft.name
     isdefined(ftname, :mt) || return false
diff --git a/base/twiceprecision.jl b/base/twiceprecision.jl
index 955bfc97b16ff..0de6270cafb2d 100644
--- a/base/twiceprecision.jl
+++ b/base/twiceprecision.jl
@@ -785,3 +785,19 @@ _tp_prod(t::TwicePrecision) = t
     x.hi < y.hi || ((x.hi == y.hi) & (x.lo < y.lo))
 
 isbetween(a, x, b) = a <= x <= b || b <= x <= a
+
+# These functions exist for use in LogRange:
+
+_exp_allowing_twice64(x::Number) = exp(x)
+_exp_allowing_twice64(x::TwicePrecision{Float64}) = Math.exp_impl(x.hi, x.lo, Val(:ℯ))
+
+# No error on negative x, and for NaN/Inf this returns junk:
+function _log_twice64_unchecked(x::Float64)
+    xu = reinterpret(UInt64, x)
+    if xu < (UInt64(1)<<52) # x is subnormal
+        xu = reinterpret(UInt64, x * 0x1p52) # normalize x
+        xu &= ~sign_mask(Float64)
+        xu -= UInt64(52) << 52 # mess with the exponent
+    end
+    TwicePrecision(Math._log_ext(xu)...)
+end
diff --git a/doc/src/base/math.md b/doc/src/base/math.md
index 86a7e4d8d3173..c1b18c0b66d86 100644
--- a/doc/src/base/math.md
+++ b/doc/src/base/math.md
@@ -39,6 +39,8 @@ Base.:(:)
 Base.range
 Base.OneTo
 Base.StepRangeLen
+Base.logrange
+Base.LogRange
 Base.:(==)
 Base.:(!=)
 Base.:(!==)
diff --git a/test/ranges.jl b/test/ranges.jl
index 549078bab45fe..4660a96dfc16a 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -2603,3 +2603,86 @@ end
     errmsg = ("deliberately unsupported for CartesianIndex", "StepRangeLen")
     @test_throws errmsg range(CartesianIndex(1), step=CartesianIndex(1), length=3)
 end
+
+@testset "logrange" begin
+    # basic idea
+    @test logrange(2, 16, 4) ≈ [2, 4, 8, 16]
+    @test logrange(1/8, 8.0, 7) ≈ [0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0]
+    @test logrange(1000, 1, 4) ≈ [1000, 100, 10, 1]
+    @test logrange(1, 10^9, 19)[1:2:end] ≈ 10 .^ (0:9)
+
+    # endpoints
+    @test logrange(0.1f0, 100, 33)[1] === 0.1f0
+    @test logrange(0.789, 123_456, 135_790)[[begin, end]] == [0.789, 123_456]
+    @test logrange(nextfloat(0f0), floatmax(Float32), typemax(Int))[end] === floatmax(Float32)
+    @test logrange(nextfloat(Float16(0)), floatmax(Float16), 66_000)[end] === floatmax(Float16)
+    @test first(logrange(pi, 2pi, 3000)) === logrange(pi, 2pi, 3000)[1] === Float64(pi)
+    if Int == Int64
+        @test logrange(0.1, 1000, 2^54)[end] === 1000.0
+    end
+
+    # empty, only, constant
+    @test first(logrange(1, 2, 0)) === 1.0
+    @test last(logrange(1, 2, 0)) === 2.0
+    @test collect(logrange(1, 2, 0)) == Float64[]
+    @test only(logrange(2pi, 2pi, 1)) === logrange(2pi, 2pi, 1)[1] === 2pi
+    @test logrange(1, 1, 3) == fill(1.0, 3)
+
+    # subnormal Float64
+    x = logrange(1e-320, 1e-300, 21) .* 1e300
+    @test x ≈ logrange(1e-20, 1, 21) rtol=1e-6
+
+    # types
+    @test eltype(logrange(1, 10, 3)) == Float64
+    @test eltype(logrange(1, 10, Int32(3))) == Float64
+    @test eltype(logrange(1, 10f0, 3)) == Float32
+    @test eltype(logrange(1f0, 10, 3)) == Float32
+    @test eltype(logrange(1, big(10), 3)) == BigFloat
+    @test logrange(big"0.3", big(pi), 50)[1] == big"0.3"
+    @test logrange(big"0.3", big(pi), 50)[end] == big(pi)
+
+    # more constructors
+    @test logrange(1,2,length=3) === Base.LogRange(1,2,3) == Base.LogRange{Float64}(1,2,3)
+    @test logrange(1f0, 2f0, length=3) == Base.LogRange{Float32}(1,2,3)
+
+    # errors
+    @test_throws UndefKeywordError logrange(1, 10)  # no default length
+    @test_throws ArgumentError logrange(1, 10, -1)  # negative length
+    @test_throws ArgumentError logrange(1, 10, 1) # endpoints must not differ
+    @test_throws DomainError logrange(1, -1, 3)   # needs complex numbers
+    @test_throws DomainError logrange(-1, -2, 3)  # not supported, for now
+    @test_throws MethodError logrange(1, 2+3im, length=4)  # not supported, for now
+    @test_throws ArgumentError logrange(1, 10, 2)[true]  # bad index
+    @test_throws BoundsError logrange(1, 10, 2)[3]
+    @test_throws ArgumentError Base.LogRange{Int}(1,4,5)  # no integer ranges
+    @test_throws MethodError Base.LogRange(1,4, length=5)  # type does not take keyword
+    # (not sure if these should ideally be DomainError or ArgumentError)
+    @test_throws DomainError logrange(1, Inf, 3)
+    @test_throws DomainError logrange(0, 2, 3)
+    @test_throws DomainError logrange(1, NaN, 3)
+    @test_throws DomainError logrange(NaN, 2, 3)
+
+    # printing
+    @test repr(Base.LogRange(1,2,3)) == "LogRange{Float64}(1.0, 2.0, 3)"  # like 2-arg show
+    @test repr("text/plain", Base.LogRange(1,2,3)) == "3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:\n 1.0, 1.41421, 2.0"
+    @test repr("text/plain", Base.LogRange(1,2,0)) == "LogRange{Float64}(1.0, 2.0, 0)"  # empty case
+end
+
+@testset "_log_twice64_unchecked" begin
+    # it roughly works
+    @test big(Base._log_twice64_unchecked(exp(1))) ≈ 1.0
+    @test big(Base._log_twice64_unchecked(exp(123))) ≈ 123.0
+
+    # it gets high accuracy
+    @test abs(big(log(4.0)) - log(big(4.0))) < 1e-16
+    @test abs(big(Base._log_twice64_unchecked(4.0)) - log(big(4.0))) < 1e-30
+
+    # it handles subnormals
+    @test abs(big(Base._log_twice64_unchecked(1e-310)) - log(big(1e-310))) < 1e-20
+
+    # it accepts negative, NaN, etc without complaint:
+    @test Base._log_twice64_unchecked(-0.0).lo isa Float64
+    @test Base._log_twice64_unchecked(-1.23).lo isa Float64
+    @test Base._log_twice64_unchecked(NaN).lo isa Float64
+    @test Base._log_twice64_unchecked(Inf).lo isa Float64
+end

From ddd7afb95165b15f87b2c83e7862437d0a68272d Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Fri, 16 Feb 2024 11:36:53 -0500
Subject: [PATCH 0951/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20SparseArrays=20stdlib=20from=20c9f7293=20to=20cb602d7=20(#53?=
 =?UTF-8?q?361)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: SparseArrays
URL: https://github.com/JuliaSparse/SparseArrays.jl.git
Stdlib branch: main
Julia branch: master
Old commit: c9f7293
New commit: cb602d7
Julia version: 1.12.0-DEV
SparseArrays version: 1.11.0(Does not match)
Bump invoked by: @dkarrasch
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaSparse/SparseArrays.jl/compare/c9f7293c10e6bea775feceabd4554ab55c34e3a8...cb602d7b7cf46057ddc87d23cda2bdd168a548ac

```
$ git log --oneline c9f7293..cb602d7
cb602d7 Add generic matmatmul for inplace sparse x sparse (#486)
95575c0 Speedup for `findmin()/findmax()` on sparse arrays (#510) (#511)
4cc31f2 Fix error message in getcommon() in cholmod (#509)
1748989 Move `fkeep!` docstring to the right function (#503)
1aa6431 Update ci.yml timeout (#507)
1f88ae1 Update ci.yml  - add codecov token (#504)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/SparseArrays.version                                     | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/sha512
 create mode 100644 deps/checksums/SparseArrays-cb602d7b7cf46057ddc87d23cda2bdd168a548ac.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-cb602d7b7cf46057ddc87d23cda2bdd168a548ac.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/md5 b/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/md5
deleted file mode 100644
index 190ea5ea307d8..0000000000000
--- a/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-b765873c42674134d74758200885e454
diff --git a/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/sha512 b/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/sha512
deleted file mode 100644
index aaf4f293d7d8b..0000000000000
--- a/deps/checksums/SparseArrays-c9f7293c10e6bea775feceabd4554ab55c34e3a8.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-37f5bca4d94bc74528079c039792017b7c363c53baf97671f458059f65134944e4c0ca87d474761ae082c8cf22090477559a40a84af53316aa117234d3145fa2
diff --git a/deps/checksums/SparseArrays-cb602d7b7cf46057ddc87d23cda2bdd168a548ac.tar.gz/md5 b/deps/checksums/SparseArrays-cb602d7b7cf46057ddc87d23cda2bdd168a548ac.tar.gz/md5
new file mode 100644
index 0000000000000..5234c20cb4ff7
--- /dev/null
+++ b/deps/checksums/SparseArrays-cb602d7b7cf46057ddc87d23cda2bdd168a548ac.tar.gz/md5
@@ -0,0 +1 @@
+47cb7d9dd6f3d8ae3cb497c202ae6411
diff --git a/deps/checksums/SparseArrays-cb602d7b7cf46057ddc87d23cda2bdd168a548ac.tar.gz/sha512 b/deps/checksums/SparseArrays-cb602d7b7cf46057ddc87d23cda2bdd168a548ac.tar.gz/sha512
new file mode 100644
index 0000000000000..1aa2d8146d78e
--- /dev/null
+++ b/deps/checksums/SparseArrays-cb602d7b7cf46057ddc87d23cda2bdd168a548ac.tar.gz/sha512
@@ -0,0 +1 @@
+5ff47ea50564375e5e926c3f592a9708b1d9862e4090a53c6b02fc09bc1872578e016a4231564a10dd17be174beed54fd0b8821430828e7148f09556f8034ed9
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index ec090d653f616..5eca7be5ec9b7 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = c9f7293c10e6bea775feceabd4554ab55c34e3a8
+SPARSEARRAYS_SHA1 = cb602d7b7cf46057ddc87d23cda2bdd168a548ac
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From fc53171a0aa75f5c52718808d3b60c74be040663 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Mon, 12 Feb 2024 21:14:29 +0100
Subject: [PATCH 0952/1315] implement Sys.isreadable, Sys.iswriteable,
 Sys.exists

---
 base/sysinfo.jl | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 97e5e2a71bcbc..a989431a4651a 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -33,6 +33,9 @@ export BINDIR,
        iswindows,
        isjsvm,
        isexecutable,
+       isreadable,
+       iswriteable,
+       exists,
        username,
        which
 
@@ -570,6 +573,45 @@ function isexecutable(path::String)
 end
 isexecutable(path::AbstractString) = isexecutable(String(path))
 
+"""
+    Sys.isreadable(path::String)
+
+Return `true` if the given `path` has readable permissions.
+"""
+function isreadable(path::String)
+    # We use `access()` and `R_OK` to determine if a given path is
+    # executable by the current user.  `R_OK` comes from `unistd.h`.
+    R_OK = 0x04
+    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, R_OK) == 0
+end
+isreadable(path::AbstractString) = isreadable(String(path))
+
+"""
+    Sys.iswriteable(path::String)
+
+Return `true` if the given `path` has writeable permissions.
+"""
+function iswriteable(path::String)
+    # We use `access()` and `W_OK` to determine if a given path is
+    # executable by the current user.  `W_OK` comes from `unistd.h`.
+    W_OK = 0x02
+    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, W_OK) == 0
+end
+iswriteable(path::AbstractString) = iswriteable(String(path))
+
+"""
+    Sys.exists(path::String)
+
+Return `true` if the given `path` exists.
+"""
+function exists(path::String)
+    # We use `access()` and `F_OK` to determine if a given path is
+    # executable by the current user.  `F_OK` comes from `unistd.h`.
+    F_OK = 0x00
+    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, F_OK) == 0
+end
+exists(path::AbstractString) = exists(String(path))
+
 """
     Sys.which(program_name::String)
 

From 17ee3ece7bfdefa5898d98550bda716179476ee6 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Mon, 12 Feb 2024 21:48:08 +0100
Subject: [PATCH 0953/1315] add to docs

---
 doc/src/base/base.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 3fd2bbb12bb1f..924196028bb1d 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -374,6 +374,9 @@ Base.Sys.uptime
 Base.Sys.isjsvm
 Base.Sys.loadavg
 Base.Sys.isexecutable
+Base.Sys.isreadable
+Base.Sys.iswriteable
+Base.Sys.exists
 Base.Sys.username
 Base.@static
 ```

From 790a5f9f1b63d61f8b328d9aab1749784d4b885e Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Mon, 12 Feb 2024 21:48:15 +0100
Subject: [PATCH 0954/1315] add tests

---
 test/file.jl | 27 ++++++++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

diff --git a/test/file.jl b/test/file.jl
index 2dfd881b8a487..43f8256532024 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -1658,23 +1658,44 @@ else
     )
 end
 
-@testset "chmod/isexecutable" begin
+@testset "chmod/isexecutable/isreadable/iswriteable/exists" begin
     mktempdir() do dir
-        mkdir(joinpath(dir, "subdir"))
+        subdir = joinpath(dir, "subdir")
         fpath = joinpath(dir, "subdir", "foo")
 
-        # Test that we can actually set the executable bit on all platforms.
+        @test !Sys.exists(subdir)
+        mkdir(joinpath(dir, "subdir"))
+        @test Sys.exists(subdir)
+
+        @test !Sys.exists(fpath)
         touch(fpath)
+        @test Sys.exists(fpath)
+
+        # Test that we can actually set the executable/readable/writeable bit on all platforms.
         chmod(fpath, 0o644)
         @test !Sys.isexecutable(fpath)
+        @test Sys.isreadable(fpath)
+        @test Sys.iswriteable(fpath)
         chmod(fpath, 0o755)
         @test Sys.isexecutable(fpath)
+        @test Sys.isreadable(fpath)
+        @test Sys.iswriteable(fpath)
+        chmod(fpath, 0o444)
+        @test !Sys.isexecutable(fpath)
+        @test Sys.isreadable(fpath)
+        @test !Sys.iswriteable(fpath)
+        chmod(fpath, 0o244)
+        @test !Sys.isexecutable(fpath)
+        @test !Sys.isreadable(fpath)
+        @test Sys.iswriteable(fpath)
 
         # Ensure that, on Windows, where inheritance is default,
         # chmod still behaves as we expect.
         if Sys.iswindows()
             chmod(joinpath(dir, "subdir"), 0o666)
             @test Sys.isexecutable(fpath)
+            @test Sys.isreadable(fpath)
+            @test Sys.iswriteable(fpath)
         end
 
         # Reset permissions to all at the end, so it can be deleted properly.

From d856dc0f29e955b968e0d0d0bbbd699337e7f3ee Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Tue, 13 Feb 2024 20:24:58 +0100
Subject: [PATCH 0955/1315] update comments

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/sysinfo.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index a989431a4651a..1d2026648b731 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -580,7 +580,7 @@ Return `true` if the given `path` has readable permissions.
 """
 function isreadable(path::String)
     # We use `access()` and `R_OK` to determine if a given path is
-    # executable by the current user.  `R_OK` comes from `unistd.h`.
+    # readable by the current user.  `R_OK` comes from `unistd.h`.
     R_OK = 0x04
     return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, R_OK) == 0
 end
@@ -593,7 +593,7 @@ Return `true` if the given `path` has writeable permissions.
 """
 function iswriteable(path::String)
     # We use `access()` and `W_OK` to determine if a given path is
-    # executable by the current user.  `W_OK` comes from `unistd.h`.
+    # writeable by the current user.  `W_OK` comes from `unistd.h`.
     W_OK = 0x02
     return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, W_OK) == 0
 end

From 6491148e2000c3c04c0d01f22b22f3a897288baf Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Tue, 13 Feb 2024 20:49:15 +0100
Subject: [PATCH 0956/1315] Sys.exists becomes ispath

---
 base/stat.jl    |  7 +++++++
 base/sysinfo.jl | 14 --------------
 2 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/base/stat.jl b/base/stat.jl
index 56b960c4f74ea..f527664f228ad 100644
--- a/base/stat.jl
+++ b/base/stat.jl
@@ -326,6 +326,13 @@ otherwise returns `false`.
 This is the generalization of [`isfile`](@ref), [`isdir`](@ref) etc.
 """
 ispath(st::StatStruct) = filemode(st) & 0xf000 != 0x0000
+function ispath(path::String)
+    # We use `access()` and `F_OK` to determine if a given path exists.
+    # `F_OK` comes from `unistd.h`.
+    F_OK = 0x00
+    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, F_OK) == 0
+end
+ispath(path::AbstractString) = ispath(String(path))
 
 """
     isfifo(path) -> Bool
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 1d2026648b731..2f83afcbc4cfa 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -35,7 +35,6 @@ export BINDIR,
        isexecutable,
        isreadable,
        iswriteable,
-       exists,
        username,
        which
 
@@ -599,19 +598,6 @@ function iswriteable(path::String)
 end
 iswriteable(path::AbstractString) = iswriteable(String(path))
 
-"""
-    Sys.exists(path::String)
-
-Return `true` if the given `path` exists.
-"""
-function exists(path::String)
-    # We use `access()` and `F_OK` to determine if a given path is
-    # executable by the current user.  `F_OK` comes from `unistd.h`.
-    F_OK = 0x00
-    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, F_OK) == 0
-end
-exists(path::AbstractString) = exists(String(path))
-
 """
     Sys.which(program_name::String)
 

From 32cccefc3a4de542a7d7d780cec2d6c5b438ea10 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Tue, 13 Feb 2024 20:49:53 +0100
Subject: [PATCH 0957/1315] update docs

---
 doc/src/base/base.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 924196028bb1d..556d51d3af0c1 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -376,7 +376,6 @@ Base.Sys.loadavg
 Base.Sys.isexecutable
 Base.Sys.isreadable
 Base.Sys.iswriteable
-Base.Sys.exists
 Base.Sys.username
 Base.@static
 ```

From b53d69a47f873b19deefbda60cfe021f7120bd54 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Tue, 13 Feb 2024 20:50:01 +0100
Subject: [PATCH 0958/1315] update test

---
 test/file.jl | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/file.jl b/test/file.jl
index 43f8256532024..ae05c47c47647 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -1658,18 +1658,18 @@ else
     )
 end
 
-@testset "chmod/isexecutable/isreadable/iswriteable/exists" begin
+@testset "chmod/isexecutable/isreadable/iswriteable" begin
     mktempdir() do dir
         subdir = joinpath(dir, "subdir")
         fpath = joinpath(dir, "subdir", "foo")
 
-        @test !Sys.exists(subdir)
+        @test !ispath(subdir)
         mkdir(joinpath(dir, "subdir"))
-        @test Sys.exists(subdir)
+        @test ispath(subdir)
 
-        @test !Sys.exists(fpath)
+        @test !ispath(fpath)
         touch(fpath)
-        @test Sys.exists(fpath)
+        @test ispath(fpath)
 
         # Test that we can actually set the executable/readable/writeable bit on all platforms.
         chmod(fpath, 0o644)

From 88587abf021e43748a74efdb15e055691baced28 Mon Sep 17 00:00:00 2001
From: omahs <73983677+omahs@users.noreply.github.com>
Date: Sat, 17 Feb 2024 17:10:59 +0100
Subject: [PATCH 0959/1315] Fix some typos in docstrings and comments (#53368)

---
 base/binaryplatforms.jl | 2 +-
 base/docs/Docs.jl       | 4 ++--
 base/env.jl             | 2 +-
 base/regex.jl           | 2 +-
 base/toml_parser.jl     | 2 +-
 base/version.jl         | 2 +-
 src/task.c              | 4 ++--
 test/compiler/inline.jl | 2 +-
 8 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/base/binaryplatforms.jl b/base/binaryplatforms.jl
index e0ee107c4ec73..9e45275f02636 100644
--- a/base/binaryplatforms.jl
+++ b/base/binaryplatforms.jl
@@ -306,7 +306,7 @@ function compare_version_cap(a::String, b::String, a_requested::Bool, b_requeste
         return a == b
     end
 
-    # Otherwise, do the comparison between the the single version cap and the single version:
+    # Otherwise, do the comparison between the single version cap and the single version:
     if a_requested
         return b <= a
     else
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 637a8e1a50bd9..0c83376ecfc76 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -194,7 +194,7 @@ docexpr(__source__, __module__, args...) = Expr(:call, docstr, args...)
 Stores a collection of docstrings for related objects, ie. a `Function`/`DataType` and
 associated `Method` objects.
 
-Each documented object in a `MultiDoc` is referred to by it's signature which is represented
+Each documented object in a `MultiDoc` is referred to by its signature which is represented
 by a `Union` of `Tuple` types. For example, the following `Method` definition
 
     f(x, y) = ...
@@ -243,7 +243,7 @@ function doc!(__module__::Module, b::Binding, str::DocStr, @nospecialize sig = U
             @warn "Replacing docs for `$b :: $sig` in module `$(__module__)`"
     else
         # The ordering of docstrings for each Binding is defined by the order in which they
-        # are initially added. Replacing a specific docstring does not change it's ordering.
+        # are initially added. Replacing a specific docstring does not change its ordering.
         push!(m.order, sig)
     end
     m.docs[sig] = str
diff --git a/base/env.jl b/base/env.jl
index 2928a8bdfede2..6248f1933d1ec 100644
--- a/base/env.jl
+++ b/base/env.jl
@@ -131,7 +131,7 @@ const get_bool_env_falsy = (
     Base.get_bool_env(name::String, default::Bool; throw=false)::Union{Bool,Nothing}
     Base.get_bool_env(f_default::Callable, name::String; throw=false)::Union{Bool,Nothing}
 
-Evaluate whether the value of environnment variable `name` is a truthy or falsy string,
+Evaluate whether the value of environment variable `name` is a truthy or falsy string,
 and return `nothing` (or throw if `throw=true`) if it is not recognized as either. If
 the variable is not set, or is set to "", return `default` or the result of executing `f_default()`.
 
diff --git a/base/regex.jl b/base/regex.jl
index 78eefa1741b0c..5018c9623f7e3 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -185,7 +185,7 @@ If a group was not captured, `nothing` will be yielded instead of a substring.
 
 Methods that accept a `RegexMatch` object are defined for [`iterate`](@ref),
 [`length`](@ref), [`eltype`](@ref), [`keys`](@ref keys(::RegexMatch)), [`haskey`](@ref), and
-[`getindex`](@ref), where keys are the the names or numbers of a capture group.
+[`getindex`](@ref), where keys are the names or numbers of a capture group.
 See [`keys`](@ref keys(::RegexMatch)) for more information.
 
 # Examples
diff --git a/base/toml_parser.jl b/base/toml_parser.jl
index eb7ffda2f5940..23fc14a894c06 100644
--- a/base/toml_parser.jl
+++ b/base/toml_parser.jl
@@ -2,7 +2,7 @@
 
 """
 `Base.TOML` is an undocumented internal part of Julia's TOML parser
-implementation.  Users should call the the documented interface in the
+implementation.  Users should call the documented interface in the
 TOML.jl standard library instead (by `import TOML` or `using TOML`).
 """
 module TOML
diff --git a/base/version.jl b/base/version.jl
index e078b5f9d4ac9..90c34b78c868f 100644
--- a/base/version.jl
+++ b/base/version.jl
@@ -16,7 +16,7 @@ alphanumeric annotations.
 `VersionNumber` objects can be compared with all of the standard comparison
 operators (`==`, `<`, `<=`, etc.), with the result following semver rules.
 
-`VersionNumber` has the the following public fields:
+`VersionNumber` has the following public fields:
 - `v.major::Integer`
 - `v.minor::Integer`
 - `v.patch::Integer`
diff --git a/src/task.c b/src/task.c
index 4bf12250b7d2c..a1e8dabb89f9d 100644
--- a/src/task.c
+++ b/src/task.c
@@ -197,7 +197,7 @@ static void JL_NO_ASAN JL_NO_MSAN memcpy_stack_a16(uint64_t *to, uint64_t *from,
     memcpy_noasan((char*)to_addr, (char*)from_addr, shadow_nb);
     memcpy_a16_noasan(jl_assume_aligned(to, 16), jl_assume_aligned(from, 16), nb);
 #elif defined(_COMPILER_MSAN_ENABLED_)
-# warning This function is imcompletely implemented for MSAN (TODO).
+# warning This function is incompletely implemented for MSAN (TODO).
     memcpy((char*)jl_assume_aligned(to, 16), (char*)jl_assume_aligned(from, 16), nb);
 #else
     memcpy((char*)jl_assume_aligned(to, 16), (char*)jl_assume_aligned(from, 16), nb);
@@ -884,7 +884,7 @@ then reduced to a single value by computing a dot product with a shared vector
 of random weights. The weights are common but each pedigree of each task is
 distinct, so the dot product of each task is unlikely to be the same. The DotMix
 paper provides a proof that this dot product hash value (referred to as a
-"compression function") is collision resistant in the sense the the pairwise
+"compression function") is collision resistant in the sense that the pairwise
 collision probability of two distinct tasks is 1/N where N is the number of
 possible weight values. Both DotMix and SplitMix use a prime value of N because
 the proof requires that the difference between two distinct pedigree coordinates
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index d4c6659593fe6..99918a1c91c64 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -761,7 +761,7 @@ end
 let f(x) = (x...,)
     # Test splatting with a Union of non-{Tuple, SimpleVector} types that require creating new `iterate` calls
     # in inlining. For this particular case, we're relying on `iterate(::CaretesianIndex)` throwing an error, such
-    # the the original apply call is not union-split, but the inserted `iterate` call is.
+    # that the original apply call is not union-split, but the inserted `iterate` call is.
     @test code_typed(f, Tuple{Union{Int64, CartesianIndex{1}, CartesianIndex{3}}})[1][2] == Tuple{Int64}
 end
 

From 93876c92ed725272d8853d73dc0c3256095f1617 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Sun, 18 Feb 2024 02:41:58 +0900
Subject: [PATCH 0960/1315] allow external absint to hold custom data in
 `codeinst.inferred` (#53300)

It has been possible for external abstract interpreters to keep custom
data in `codeinst.inferred` (together /w overloading `inlining_policy`).
After JuliaLang/julia#52233, when such external absint uses
`InternalCodeCache`, this data is passed to `jl_ir_flag_inferred`,
leading to segfaults in assertion builds.

This commit resolves the issue by omitting `jl_ir_flag_inferred` checks
when the `cache_owner` is external. Nonetheless, a better resolution
might be necessary. It suggests that the current design of `code_owner`
and `InternalCodeCache` for the external cache system is somewhat
flawed. A conceivable approach could involve:
- Adding a layer similar to `inlining_policy` in
`CC.get(::WorldView{InternalCodeCache})` to enable safe redirection of
custom data to the native interpreter's implementation.
- Prohibiting custom data in the `inferred` field and directing such
data to be kept in `analysis_results`.
---
 base/compiler/types.jl               |  9 ++--
 src/gf.c                             |  7 ++-
 test/compiler/AbstractInterpreter.jl | 33 +++++++++++-
 test/precompile.jl                   | 76 ++++++++++++++++++++++++++++
 4 files changed, 116 insertions(+), 9 deletions(-)

diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index 642a7ac551662..53a363a2280e4 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -373,20 +373,17 @@ end
 function NativeInterpreter(world::UInt = get_world_counter();
                            inf_params::InferenceParams = InferenceParams(),
                            opt_params::OptimizationParams = OptimizationParams())
+    curr_max_world = get_world_counter()
     # Sometimes the caller is lazy and passes typemax(UInt).
     # we cap it to the current world age for correctness
     if world == typemax(UInt)
-        world = get_world_counter()
+        world = curr_max_world
     end
-
     # If they didn't pass typemax(UInt) but passed something more subtly
     # incorrect, fail out loudly.
-    @assert world <= get_world_counter()
-
+    @assert world <= curr_max_world
     method_table = CachedMethodTable(InternalMethodTable(world))
-
     inf_cache = Vector{InferenceResult}() # Initially empty cache
-
     return NativeInterpreter(world, method_table, inf_cache, inf_params, opt_params)
 end
 
diff --git a/src/gf.c b/src/gf.c
index 20179157ff836..fdf61f440908b 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -444,8 +444,11 @@ STATIC_INLINE jl_value_t *_jl_rettype_inferred(jl_value_t *owner, jl_method_inst
         if (jl_atomic_load_relaxed(&codeinst->min_world) <= min_world &&
             max_world <= jl_atomic_load_relaxed(&codeinst->max_world) &&
             jl_egal(codeinst->owner, owner)) {
-            jl_value_t *code = jl_atomic_load_relaxed(&codeinst->inferred);
-            if (code && (code == jl_nothing || jl_ir_flag_inferred(code)))
+            jl_value_t *inferred = jl_atomic_load_relaxed(&codeinst->inferred);
+            if (inferred && ((inferred == jl_nothing) || (
+                // allow whatever code instance external abstract interpreter produced
+                // since `jl_ir_flag_inferred` is specific to the native interpreter
+                codeinst->owner != jl_nothing || jl_ir_flag_inferred(inferred))))
                 return (jl_value_t*)codeinst;
         }
         codeinst = jl_atomic_load_relaxed(&codeinst->next);
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index c0b320009b8ec..2068997c77c82 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -399,7 +399,6 @@ end
 Core.eval(Core.Compiler, quote f(;a=1) = a end)
 @test_throws MethodError Core.Compiler.f(;b=2)
 
-
 # Custom lookup function
 # ======================
 
@@ -469,3 +468,35 @@ let # generate cache
     @test  occursin("j_sin_", s)
     @test !occursin("j_cos_", s)
 end
+
+# custom inferred data
+# ====================
+
+@newinterp CustomDataInterp
+struct CustomDataInterpToken end
+CC.cache_owner(::CustomDataInterp) = CustomDataInterpToken()
+struct CustomData
+    inferred
+    CustomData(@nospecialize inferred) = new(inferred)
+end
+function CC.transform_result_for_cache(interp::CustomDataInterp,
+    mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
+    inferred_result = @invoke CC.transform_result_for_cache(interp::CC.AbstractInterpreter,
+        mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
+    return CustomData(inferred_result)
+end
+function CC.inlining_policy(interp::CustomDataInterp, @nospecialize(src),
+                            @nospecialize(info::CC.CallInfo), stmt_flag::UInt32)
+    if src isa CustomData
+        src = src.inferred
+    end
+    return @invoke CC.inlining_policy(interp::CC.AbstractInterpreter, src::Any,
+                                      info::CC.CallInfo, stmt_flag::UInt32)
+end
+let src = code_typed((Int,); interp=CustomDataInterp()) do x
+        return sin(x) + cos(x)
+    end |> only |> first
+    @test count(isinvoke(:sin), src.code) == 1
+    @test count(isinvoke(:cos), src.code) == 1
+    @test count(isinvoke(:+), src.code) == 0
+end
diff --git a/test/precompile.jl b/test/precompile.jl
index c4cceced8235b..015cf49f228ac 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1776,6 +1776,82 @@ let newinterp_path = abspath("compiler/newinterp.jl")
                 @test found
             end
         end
+
+        write(joinpath(load_path, "CustomAbstractInterpreterCaching2.jl"), :(module CustomAbstractInterpreterCaching2
+            import SimpleModule: basic_caller, basic_callee
+
+            module Custom
+                const CC = Core.Compiler
+                include("$($newinterp_path)")
+                @newinterp PrecompileInterpreter
+                struct CustomData
+                    inferred
+                    CustomData(@nospecialize inferred) = new(inferred)
+                end
+                function CC.transform_result_for_cache(interp::PrecompileInterpreter,
+                        mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
+                    inferred_result = @invoke CC.transform_result_for_cache(interp::CC.AbstractInterpreter,
+                        mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
+                    return CustomData(inferred_result)
+                end
+                function CC.inlining_policy(interp::PrecompileInterpreter, @nospecialize(src),
+                                            @nospecialize(info::CC.CallInfo), stmt_flag::UInt32)
+                    if src isa CustomData
+                        src = src.inferred
+                    end
+                    return @invoke CC.inlining_policy(interp::CC.AbstractInterpreter, src::Any,
+                                                    info::CC.CallInfo, stmt_flag::UInt32)
+                end
+            end
+
+            Base.return_types((Float64,)) do x
+                basic_caller(x)
+            end
+            Base.return_types((Float64,); interp=Custom.PrecompileInterpreter()) do x
+                basic_caller(x)
+            end
+            Base.return_types((Vector{Float64},)) do x
+                sum(x)
+            end
+            Base.return_types((Vector{Float64},); interp=Custom.PrecompileInterpreter()) do x
+                sum(x)
+            end
+        end) |> string)
+        Base.compilecache(Base.PkgId("CustomAbstractInterpreterCaching2"))
+        @eval let
+            using CustomAbstractInterpreterCaching2
+            cache_owner = Core.Compiler.cache_owner(
+                CustomAbstractInterpreterCaching2.Custom.PrecompileInterpreter())
+            let m = only(methods(CustomAbstractInterpreterCaching.basic_callee))
+                mi = only(Base.specializations(m))
+                ci = mi.cache
+                @test isdefined(ci, :next)
+                @test ci.owner === nothing
+                @test ci.max_world == typemax(UInt)
+                ci = ci.next
+                @test !isdefined(ci, :next)
+                @test ci.owner === cache_owner
+                @test ci.max_world == typemax(UInt)
+            end
+            let m = only(methods(sum, (Vector{Float64},)))
+                found = false
+                for mi = Base.specializations(m)
+                    if mi isa Core.MethodInstance && mi.specTypes == Tuple{typeof(sum),Vector{Float64}}
+                        ci = mi.cache
+                        @test isdefined(ci, :next)
+                        @test ci.owner === cache_owner
+                        @test ci.max_world == typemax(UInt)
+                        ci = ci.next
+                        @test !isdefined(ci, :next)
+                        @test ci.owner === nothing
+                        @test ci.max_world == typemax(UInt)
+                        found = true
+                        break
+                    end
+                end
+                @test found
+            end
+        end
     end
 end
 

From d3b477329661ef0c2b7fb0f5298ec0e3c67f29f4 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Wed, 14 Feb 2024 20:41:48 +0100
Subject: [PATCH 0961/1315] update doc strings

---
 base/sysinfo.jl | 29 +++++++++++++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 2f83afcbc4cfa..d4d9b77c420c0 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -558,6 +558,11 @@ const WINDOWS_VISTA_VER = v"6.0"
 
 Return `true` if the given `path` has executable permissions.
 
+!!! note
+    This permission may change before the user executes `path`,
+    so it is recommended to execute the file and handle the error if that fails,
+    rather than calling `isexecutable` first.
+
 !!! note
     Prior to Julia 1.6, this did not correctly interrogate filesystem
     ACLs on Windows, therefore it would return `true` for any
@@ -575,7 +580,17 @@ isexecutable(path::AbstractString) = isexecutable(String(path))
 """
     Sys.isreadable(path::String)
 
-Return `true` if the given `path` has readable permissions.
+Return `true` if the access permissions for the given `path` permitted reading by the current user.
+
+!!! note
+    This permission may change before the user calls `open`,
+    so it is recommended to just call `open` alone and handle the error if that fails,
+    rather than calling `isreadable` first.
+
+!!! compat "Julia 1.11"
+    This function requires at least Julia 1.11.
+
+See also [`ispath`](@ref).
 """
 function isreadable(path::String)
     # We use `access()` and `R_OK` to determine if a given path is
@@ -588,7 +603,17 @@ isreadable(path::AbstractString) = isreadable(String(path))
 """
     Sys.iswriteable(path::String)
 
-Return `true` if the given `path` has writeable permissions.
+Return `true` if the access permissions for the given `path` permitted writing by the current user.
+
+!!! note
+    This permission may change before the user calls `open`,
+    so it is recommended to just call `open` alone and handle the error if that fails,
+    rather than calling `iswriteable` first.
+
+!!! compat "Julia 1.11"
+    This function requires at least Julia 1.11.
+
+See also [`ispath`](@ref).
 """
 function iswriteable(path::String)
     # We use `access()` and `W_OK` to determine if a given path is

From 7d03316ea9fd0eb252ecb26a961471532c32f958 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Thu, 15 Feb 2024 23:28:53 +0100
Subject: [PATCH 0962/1315] fixup ispath edge cases

---
 base/stat.jl | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/base/stat.jl b/base/stat.jl
index f527664f228ad..fefae68463d9c 100644
--- a/base/stat.jl
+++ b/base/stat.jl
@@ -327,10 +327,16 @@ This is the generalization of [`isfile`](@ref), [`isdir`](@ref) etc.
 """
 ispath(st::StatStruct) = filemode(st) & 0xf000 != 0x0000
 function ispath(path::String)
-    # We use `access()` and `F_OK` to determine if a given path exists.
-    # `F_OK` comes from `unistd.h`.
+    if contains(path, '\0')
+        throw(ArgumentError(string("embedded NULs are not allowed in C strings: ", repr(path), ")")))
+    end
+    # We use `access()` and `F_OK` to determine if a given path exists. `F_OK` comes from `unistd.h`.
     F_OK = 0x00
-    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, F_OK) == 0
+    r = ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, F_OK)
+    if !(r in (0, Base.UV_ENOENT, Base.UV_ENOTDIR, Base.UV_EINVAL))
+        uv_error(string("ispath(", repr(path), ")"), r)
+    end
+    return r == 0
 end
 ispath(path::AbstractString) = ispath(String(path))
 

From ac978cc540ebee898db4ca7e584d91ea86754c7a Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Sat, 17 Feb 2024 18:48:54 +0100
Subject: [PATCH 0963/1315] fixup ccall signature

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/stat.jl    | 5 +----
 base/sysinfo.jl | 6 +++---
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/base/stat.jl b/base/stat.jl
index fefae68463d9c..3931b9d1f3583 100644
--- a/base/stat.jl
+++ b/base/stat.jl
@@ -327,12 +327,9 @@ This is the generalization of [`isfile`](@ref), [`isdir`](@ref) etc.
 """
 ispath(st::StatStruct) = filemode(st) & 0xf000 != 0x0000
 function ispath(path::String)
-    if contains(path, '\0')
-        throw(ArgumentError(string("embedded NULs are not allowed in C strings: ", repr(path), ")")))
-    end
     # We use `access()` and `F_OK` to determine if a given path exists. `F_OK` comes from `unistd.h`.
     F_OK = 0x00
-    r = ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, F_OK)
+    r = ccall(:jl_fs_access, Cint, (Cstring, Cint), path, F_OK)
     if !(r in (0, Base.UV_ENOENT, Base.UV_ENOTDIR, Base.UV_EINVAL))
         uv_error(string("ispath(", repr(path), ")"), r)
     end
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index d4d9b77c420c0..aa33d1db8db43 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -573,7 +573,7 @@ function isexecutable(path::String)
     # We use `access()` and `X_OK` to determine if a given path is
     # executable by the current user.  `X_OK` comes from `unistd.h`.
     X_OK = 0x01
-    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, X_OK) == 0
+    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, X_OK) == 0
 end
 isexecutable(path::AbstractString) = isexecutable(String(path))
 
@@ -596,7 +596,7 @@ function isreadable(path::String)
     # We use `access()` and `R_OK` to determine if a given path is
     # readable by the current user.  `R_OK` comes from `unistd.h`.
     R_OK = 0x04
-    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, R_OK) == 0
+    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, R_OK) == 0
 end
 isreadable(path::AbstractString) = isreadable(String(path))
 
@@ -619,7 +619,7 @@ function iswriteable(path::String)
     # We use `access()` and `W_OK` to determine if a given path is
     # writeable by the current user.  `W_OK` comes from `unistd.h`.
     W_OK = 0x02
-    return ccall(:jl_fs_access, Cint, (Ptr{UInt8}, Cint), path, W_OK) == 0
+    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, W_OK) == 0
 end
 iswriteable(path::AbstractString) = iswriteable(String(path))
 

From 4990429a1f038ebeda573181609745bf30c4a7d6 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Sat, 17 Feb 2024 19:01:54 +0100
Subject: [PATCH 0964/1315] silence warnings in tests introduced in #33593

---
 test/file.jl | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/test/file.jl b/test/file.jl
index 2dfd881b8a487..8f62b533083c6 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -637,9 +637,11 @@ end
     MAX_PATH = (Sys.iswindows() ? 260 - length(PATH_PREFIX) : 255)  - 9
     for i = 0:9
         local tmp = joinpath(PATH_PREFIX, "x"^MAX_PATH * "123456789"[1:i])
-        @test withenv(var => tmp) do
-            tempdir()
-        end == tmp
+        no_error_logging() do
+            @test withenv(var => tmp) do
+                tempdir()
+            end == tmp
+        end
     end
 end
 

From 199851801fa183c1bfac9b3ba2282655e2629b7f Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Sun, 18 Feb 2024 03:01:55 +0800
Subject: [PATCH 0965/1315] Allow AnnotatedStrings in log messages (#51802)

Permitting annotated strings allows for styling information to be
preserved through to log printing.
---
 stdlib/Logging/src/ConsoleLogger.jl | 13 +++++++++++--
 stdlib/Logging/test/runtests.jl     |  9 +++++++++
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/stdlib/Logging/src/ConsoleLogger.jl b/stdlib/Logging/src/ConsoleLogger.jl
index ef901ebbbbc5d..2950ad1b8cf95 100644
--- a/stdlib/Logging/src/ConsoleLogger.jl
+++ b/stdlib/Logging/src/ConsoleLogger.jl
@@ -118,8 +118,17 @@ function handle_message(logger::ConsoleLogger, level::LogLevel, message, _module
     end
 
     # Generate a text representation of the message and all key value pairs,
-    # split into lines.
-    msglines = [(indent=0, msg=l) for l in split(chomp(convert(String, string(message))::String), '\n')]
+    # split into lines.  This is specialised to improve type inference,
+    # and reduce the risk of resulting method invalidations.
+    message = string(message)
+    msglines = if Base._isannotated(message) && !isempty(Base.annotations(message))
+        message = Base.AnnotatedString(String(message), Base.annotations(message))
+        @NamedTuple{indent::Int, msg::Union{SubString{Base.AnnotatedString{String}}, SubString{String}}}[
+            (indent=0, msg=l) for l in split(chomp(message), '\n')]
+    else
+        [(indent=0, msg=l) for l in split(
+             chomp(convert(String, message)::String), '\n')]
+    end
     stream::IO = logger.stream
     if !(isopen(stream)::Bool)
         stream = stderr
diff --git a/stdlib/Logging/test/runtests.jl b/stdlib/Logging/test/runtests.jl
index 1a86c884295b4..57866ff0a18d2 100644
--- a/stdlib/Logging/test/runtests.jl
+++ b/stdlib/Logging/test/runtests.jl
@@ -52,6 +52,15 @@ end
     end
     @test String(take!(buf)) == ""
 
+    # Check that the AnnotatedString path works too
+    with_logger(logger) do
+        @info Base.AnnotatedString("test")
+    end
+    @test String(take!(buf)) ==
+    """
+    [ Info: test
+    """
+
     @testset "Default metadata formatting" begin
         @test Logging.default_metafmt(Logging.Debug, Base, :g, :i, expanduser("~/somefile.jl"), 42) ==
             (:log_debug, "Debug:",   "@ Base ~/somefile.jl:42")

From 16871e73f813345b2790c2879ececde55a4a2d65 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 18 Feb 2024 14:10:51 +0530
Subject: [PATCH 0966/1315] Orthogonalize re-indexing for FastSubArrays
 (#53369)

By separating out the re-indexing step for `FastSubArray`s and
specializing this for `FastContiguousSubArray`s, we don't need to define
specialized `getindex`, `setindex!` and `isassigned` for
`FastContiguousSubArray`s anymore. The fallback method for
`FastSubArray`s will correctly handle the special case.
---
 base/subarray.jl | 86 ++++++++++++++++--------------------------------
 1 file changed, 28 insertions(+), 58 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index eca06fa3eacff..396f7c52bd77a 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -320,22 +320,35 @@ end
 
 # But SubArrays with fast linear indexing pre-compute a stride and offset
 FastSubArray{T,N,P,I} = SubArray{T,N,P,I,true}
+# We define a convenience functions to compute the shifted parent index
+# This differs from reindex as this accepts the view directly, instead of its indices
+@inline _reindexlinear(V::FastSubArray, i::Int) = V.offset1 + V.stride1*i
+@inline _reindexlinear(V::FastSubArray, i::AbstractUnitRange{Int}) = V.offset1 .+ V.stride1 .* i
+
 function getindex(V::FastSubArray, i::Int)
     @inline
     @boundscheck checkbounds(V, i)
-    @inbounds r = V.parent[V.offset1 + V.stride1*i]
+    @inbounds r = V.parent[_reindexlinear(V, i)]
     r
 end
-# We can avoid a multiplication if the first parent index is a Colon or AbstractUnitRange,
-# or if all the indices are scalars, i.e. the view is for a single value only
-FastContiguousSubArray{T,N,P,I<:Union{Tuple{Union{Slice, AbstractUnitRange}, Vararg{Any}},
-                                      Tuple{Vararg{ScalarIndex}}}} = SubArray{T,N,P,I,true}
-function getindex(V::FastContiguousSubArray, i::Int)
+
+# For vector views with linear indexing, we disambiguate to favor the stride/offset
+# computation as that'll generally be faster than (or just as fast as) re-indexing into a range.
+function getindex(V::FastSubArray{<:Any, 1}, i::Int)
     @inline
     @boundscheck checkbounds(V, i)
-    @inbounds r = V.parent[V.offset1 + i]
+    @inbounds r = V.parent[_reindexlinear(V, i)]
     r
 end
+
+# We can avoid a multiplication if the first parent index is a Colon or AbstractUnitRange,
+# or if all the indices are scalars, i.e. the view is for a single value only
+FastContiguousSubArray{T,N,P,I<:Union{Tuple{Union{Slice, AbstractUnitRange}, Vararg{Any}},
+                                      Tuple{Vararg{ScalarIndex}}}} = SubArray{T,N,P,I,true}
+
+@inline _reindexlinear(V::FastContiguousSubArray, i::Int) = V.offset1 + i
+@inline _reindexlinear(V::FastContiguousSubArray, i::AbstractUnitRange{Int}) = V.offset1 .+ i
+
 # parents of FastContiguousSubArrays may support fast indexing with AbstractUnitRanges,
 # so we may just forward the indexing to the parent
 # This may only be done for non-offset ranges, as the result would otherwise have offset axes
@@ -343,24 +356,10 @@ const OneBasedRanges = Union{OneTo{Int}, UnitRange{Int}, Slice{OneTo{Int}}, Iden
 function getindex(V::FastContiguousSubArray, i::OneBasedRanges)
     @inline
     @boundscheck checkbounds(V, i)
-    @inbounds r = V.parent[V.offset1 .+ i]
+    @inbounds r = V.parent[_reindexlinear(V, i)]
     r
 end
 
-# For vector views with linear indexing, we disambiguate to favor the stride/offset
-# computation as that'll generally be faster than (or just as fast as) re-indexing into a range.
-function getindex(V::FastSubArray{<:Any, 1}, i::Int)
-    @inline
-    @boundscheck checkbounds(V, i)
-    @inbounds r = V.parent[V.offset1 + V.stride1*i]
-    r
-end
-function getindex(V::FastContiguousSubArray{<:Any, 1}, i::Int)
-    @inline
-    @boundscheck checkbounds(V, i)
-    @inbounds r = V.parent[V.offset1 + i]
-    r
-end
 @inline getindex(V::FastContiguousSubArray, i::Colon) = getindex(V, to_indices(V, (:,))...)
 
 # Indexed assignment follows the same pattern as `getindex` above
@@ -373,40 +372,23 @@ end
 function setindex!(V::FastSubArray, x, i::Int)
     @inline
     @boundscheck checkbounds(V, i)
-    @inbounds V.parent[V.offset1 + V.stride1*i] = x
+    @inbounds V.parent[_reindexlinear(V, i)] = x
     V
 end
-function setindex!(V::FastContiguousSubArray, x, i::Int)
+function setindex!(V::FastSubArray{<:Any, 1}, x, i::Int)
     @inline
     @boundscheck checkbounds(V, i)
-    @inbounds V.parent[V.offset1 + i] = x
+    @inbounds V.parent[_reindexlinear(V, i)] = x
     V
 end
+
 function setindex!(V::FastSubArray, x, i::AbstractUnitRange{Int})
     @inline
     @boundscheck checkbounds(V, i)
-    @inbounds V.parent[V.offset1 .+ V.stride1 .* i] = x
-    V
-end
-function setindex!(V::FastContiguousSubArray, x, i::AbstractUnitRange{Int})
-    @inline
-    @boundscheck checkbounds(V, i)
-    @inbounds V.parent[V.offset1 .+ i] = x
+    @inbounds V.parent[_reindexlinear(V, i)] = x
     V
 end
 
-function setindex!(V::FastSubArray{<:Any, 1}, x, i::Int)
-    @inline
-    @boundscheck checkbounds(V, i)
-    @inbounds V.parent[V.offset1 + V.stride1*i] = x
-    V
-end
-function setindex!(V::FastContiguousSubArray{<:Any, 1}, x, i::Int)
-    @inline
-    @boundscheck checkbounds(V, i)
-    @inbounds V.parent[V.offset1 + i] = x
-    V
-end
 @inline setindex!(V::FastSubArray, x, i::Colon) = setindex!(V, x, to_indices(V, (i,))...)
 
 function isassigned(V::SubArray{T,N}, I::Vararg{Int,N}) where {T,N}
@@ -418,25 +400,13 @@ end
 function isassigned(V::FastSubArray, i::Int)
     @inline
     @boundscheck checkbounds(Bool, V, i) || return false
-    @inbounds r = isassigned(V.parent, V.offset1 + V.stride1*i)
-    r
-end
-function isassigned(V::FastContiguousSubArray, i::Int)
-    @inline
-    @boundscheck checkbounds(Bool, V, i) || return false
-    @inbounds r = isassigned(V.parent, V.offset1 + i)
+    @inbounds r = isassigned(V.parent, _reindexlinear(V, i))
     r
 end
 function isassigned(V::FastSubArray{<:Any, 1}, i::Int)
     @inline
     @boundscheck checkbounds(Bool, V, i) || return false
-    @inbounds r = isassigned(V.parent, V.offset1 + V.stride1*i)
-    r
-end
-function isassigned(V::FastContiguousSubArray{<:Any, 1}, i::Int)
-    @inline
-    @boundscheck checkbounds(Bool, V, i) || return false
-    @inbounds r = isassigned(V.parent, V.offset1 + i)
+    @inbounds r = isassigned(V.parent, _reindexlinear(V, i))
     r
 end
 

From 2a9c95a80313e8eb8e510c537473a8c6280dec02 Mon Sep 17 00:00:00 2001
From: Aravindh Krishnamoorthy <aravindh.k@gmail.com>
Date: Sun, 18 Feb 2024 14:10:42 +0100
Subject: [PATCH 0967/1315] Implement `circshift(::Tuple, ::Integer)` (#52438)

---
 base/abstractarraymath.jl | 17 ++++++++++++++++-
 base/tuple.jl             |  6 ++++++
 test/tuple.jl             | 12 ++++++++++++
 3 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/base/abstractarraymath.jl b/base/abstractarraymath.jl
index 0c339fbc54e57..a9efc2b87bee4 100644
--- a/base/abstractarraymath.jl
+++ b/base/abstractarraymath.jl
@@ -265,10 +265,13 @@ circshift(a::AbstractArray, shiftamt::DimsInteger) = circshift!(similar(a), a, s
 """
     circshift(A, shifts)
 
-Circularly shift, i.e. rotate, the data in an array. The second argument is a tuple or
+Circularly shift, i.e. rotate, the data in `A`. The second argument is a tuple or
 vector giving the amount to shift in each dimension, or an integer to shift only in the
 first dimension.
 
+The generated code is most efficient when the shift amounts are known at compile-time, i.e.,
+compile-time constants.
+
 See also: [`circshift!`](@ref), [`circcopy!`](@ref), [`bitrotate`](@ref), [`<<`](@ref).
 
 # Examples
@@ -317,6 +320,18 @@ julia> circshift(a, -1)
  0
  1
  1
+
+julia> x = (1, 2, 3, 4, 5)
+(1, 2, 3, 4, 5)
+
+julia> circshift(x, 4)
+(2, 3, 4, 5, 1)
+
+julia> z = (1, 'a', -7.0, 3)
+(1, 'a', -7.0, 3)
+
+julia> circshift(z, -1)
+('a', -7.0, 3, 1)
 ```
 """
 function circshift(a::AbstractArray, shiftamt)
diff --git a/base/tuple.jl b/base/tuple.jl
index 3e39e8d63cb86..a3fadb5c86e78 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -691,3 +691,9 @@ empty(@nospecialize x::Tuple) = ()
 
 foreach(f, itr::Tuple) = foldl((_, x) -> (f(x); nothing), itr, init=nothing)
 foreach(f, itr::Tuple, itrs::Tuple...) = foldl((_, xs) -> (f(xs...); nothing), zip(itr, itrs...), init=nothing)
+
+function circshift(x::Tuple, shift::Integer)
+    @inline
+    j = mod1(shift, length(x))
+    ntuple(k -> getindex(x, k-j+ifelse(k>j,0,length(x))), Val(length(x)))
+end
diff --git a/test/tuple.jl b/test/tuple.jl
index ee9f3e9ac7a2c..4b0bfbbb3b055 100644
--- a/test/tuple.jl
+++ b/test/tuple.jl
@@ -818,3 +818,15 @@ namedtup = (;a=1, b=2, c=3)
     @test (1, "2") == @inferred Tuple(pair)
     @test (1, "2") == @inferred Tuple{Int,String}(pair)
 end
+
+@testset "circshift" begin
+    t1 = (1, 2, 3, 4, 5)
+    t2 = (1, 'a', -7.0, 3)
+    t3 = ('a', 'b', 'c', 'd')
+    @test @inferred(Base.circshift(t1, 2)) == (4, 5, 1, 2, 3)
+    # The return type of mixed tuples with runtime shift cannot be inferred.
+    @test Base.circshift(t2, 3) == ('a', -7.0, 3, 1)
+    @test @inferred(Base.circshift(t3, 7)) == ('b', 'c', 'd', 'a')
+    @test @inferred(Base.circshift(t3, -1)) == ('b', 'c', 'd', 'a')
+    @test_throws MethodError circshift(t1, 'a')
+end

From 45058550792539a286a54868ca677fe6085a0a64 Mon Sep 17 00:00:00 2001
From: Zhuoqian Zhou <ben02060846@gmail.com>
Date: Sun, 18 Feb 2024 23:44:13 +0800
Subject: [PATCH 0968/1315] fix typos in docs (#53378)

fix typos in docs
---
 doc/src/devdocs/build/build.md  | 2 +-
 stdlib/Random/docs/src/index.md | 4 ++--
 stdlib/Random/src/generation.jl | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/src/devdocs/build/build.md b/doc/src/devdocs/build/build.md
index 52d9482805b9a..e8092df493df7 100644
--- a/doc/src/devdocs/build/build.md
+++ b/doc/src/devdocs/build/build.md
@@ -269,7 +269,7 @@ DEPS_GIT = llvm
 #  LLVM_GIT_URL = ...
 #Name of the alternate branch to clone from git
 #  LLVM_BRANCH = julia-16.0.6-0
-#SHA hash of the alterate commit to check out automatically
+#SHA hash of the alternate commit to check out automatically
 #  LLVM_SHA1 = $(LLVM_BRANCH)
 #List of LLVM targets to build.  It is strongly recommended to keep at least all the
 #default targets listed in `deps/llvm.mk`, even if you don't necessarily need all of them.
diff --git a/stdlib/Random/docs/src/index.md b/stdlib/Random/docs/src/index.md
index c8451a3fe21fa..96320ee216198 100644
--- a/stdlib/Random/docs/src/index.md
+++ b/stdlib/Random/docs/src/index.md
@@ -94,7 +94,7 @@ There are two mostly orthogonal ways to extend `Random` functionalities:
 The API for 1) is quite functional, but is relatively recent so it may still have to evolve in subsequent releases of the `Random` module.
 For example, it's typically sufficient to implement one `rand` method in order to have all other usual methods work automatically.
 
-The API for 2) is still rudimentary, and may require more work than strictly necessary from the implementor,
+The API for 2) is still rudimentary, and may require more work than strictly necessary from the implementer,
 in order to support usual types of generated values.
 
 ### Generating random values of custom types
@@ -103,7 +103,7 @@ Generating random values for some distributions may involve various trade-offs.
 
 The `Random` module defines a customizable framework for obtaining random values that can address these issues. Each invocation of `rand` generates a *sampler* which can be customized with the above trade-offs in mind, by adding methods to `Sampler`, which in turn can dispatch on the random number generator, the object that characterizes the distribution, and a suggestion for the number of repetitions. Currently, for the latter, `Val{1}` (for a single sample) and `Val{Inf}` (for an arbitrary number) are used, with `Random.Repetition` an alias for both.
 
-The object returned by `Sampler` is then used to generate the random values. When implementing the random generation interface for a value `X` that can be sampled from, the implementor should define the method
+The object returned by `Sampler` is then used to generate the random values. When implementing the random generation interface for a value `X` that can be sampled from, the implementer should define the method
 
 ```julia
 rand(rng, sampler)
diff --git a/stdlib/Random/src/generation.jl b/stdlib/Random/src/generation.jl
index 23d53799a40ee..d8bb48d2764d2 100644
--- a/stdlib/Random/src/generation.jl
+++ b/stdlib/Random/src/generation.jl
@@ -19,7 +19,7 @@
 Sampler(::Type{RNG}, ::Type{T}, n::Repetition) where {RNG<:AbstractRNG,T<:AbstractFloat} =
     Sampler(RNG, CloseOpen01(T), n)
 
-# generic random generation function which can be used by RNG implementors
+# generic random generation function which can be used by RNG implementers
 # it is not defined as a fallback rand method as this could create ambiguities
 
 rand(r::AbstractRNG, ::SamplerTrivial{CloseOpen01{Float16}}) =
@@ -130,7 +130,7 @@ rand(r::AbstractRNG, sp::SamplerTrivial{<:UniformBits{T}}) where {T} =
 
 #### BitInteger
 
-# rand_generic methods are intended to help RNG implementors with common operations
+# rand_generic methods are intended to help RNG implementers with common operations
 # we don't call them simply `rand` as this can easily contribute to create
 # ambiguities with user-side methods (forcing the user to resort to @eval)
 

From c0a93f8c3ef20fe9f892e1a728409c60599657cc Mon Sep 17 00:00:00 2001
From: Collin Wittenstein <126870995+cwittens@users.noreply.github.com>
Date: Sun, 18 Feb 2024 17:01:59 +0100
Subject: [PATCH 0969/1315] fixed typo in performance-tips.md (#53379)

I have ESL, but I'm quite certain in should be "repeatedly accessing it"
and not "repeated access it"
---
 doc/src/manual/performance-tips.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/manual/performance-tips.md b/doc/src/manual/performance-tips.md
index bdceb5a0c2493..a3e9ab1b8739e 100644
--- a/doc/src/manual/performance-tips.md
+++ b/doc/src/manual/performance-tips.md
@@ -1166,7 +1166,7 @@ and fewer memory accesses due to caching. These are the same reasons that it is
 to access arrays in column-major order (see above). Irregular access patterns and non-contiguous
 views can drastically slow down computations on arrays because of non-sequential memory access.
 
-Copying irregularly-accessed data into a contiguous array before repeated access it can result
+Copying irregularly-accessed data into a contiguous array before repeatedly accessing it can result
 in a large speedup, such as in the example below. Here, a matrix is being accessed at
 randomly-shuffled indices before being multiplied. Copying into plain arrays speeds up the
 multiplication even with the added cost of copying and allocation.

From 1c25d93ca8ab3f5b0cad627d76705fb7025429a3 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 18 Feb 2024 20:35:56 -0500
Subject: [PATCH 0970/1315] Refactor CodeInfo/CodeInstance separation and
 interfaces (#53219)

The `CodeInfo` type is one of the oldest types in the system and has
grown a bit of cruft. In particular, the `rettype`, `inferred`,
`parent`, `edges`, `min_world`, `max_world` fields are not used for the
original purpose of representing code, but for one or more of (in
decreasing order of badness):

1. Smuggling extra results from inference into the compiler
2. Sumggling extra arguments into OpaqueClosure constructors
3. Passing extra information from generated functions to inference

The first of these points in particular causes a fair bit of mixup
between caching concerns and compiler concerns and results in external
abstract interpreters maintainging their own dummy CodeInfos, just to
comply with the interface. Originally, I just wanted to clean up that
bit, but it didn't really make sense as a standalone piece, so this PR
is more comprehensive.

In particular, this PR:

1. Removes the `parent`, `inferred` and `rettype` fields of `CodeInfo`.
They are largely vestigal and code accessing these is probably doing the
wrong thing. They should instead be looking at either the CodeInstance
or remembering the query that was asked of the cache in the first place.

2. Makes `edges`, `min_world` and `max_world` used for generated
functions only. All other uses were replaced by appropriate queries on
the CodeInstance. In particular, inference no longer sets these. In the
future we may want to consider removing these also and having generated
functions return some other object, but that is a topic to revisit once
the broader compiler plugins landscape is more clear.

3. Makes the external type inference interface return `CodeInstance`
rather than `CodeInfo`. This results in a lot of cleanup, because many
functions had multiple code paths, some for CodeInstance and others for
fallback to inference/CodeInfo. This is all cleaned up now. If you don't
have a CodeInstance, you can ask inference for one. This CodeInstance
may or may not be in the cache, but you can look at its types, compile
it, etc.

4. Moves the main inference entrypoint out of the codegen library. There
is still a little bit of entangelement, but this makes codegen much more
of an independent system that you give a CodeInstance and it just fills
in the invoke pointer for.

With these changes, only the third use of the above mentioned fields
remains.

The overall theme here is decoupling. Over time, various parties have
wanted to use the julia compiler with custom IR datastructure, backend
code generators, caches, etc. This doesn't quite get us all the way
there, but makes inference and codegen much more independent with a
clear IR-format-independent interface (CodeInstance).

---------

Co-authored-by: Valentin Churavy <v.churavy@gmail.com>
---
 base/compiler/inferencestate.jl           |  14 +-
 base/compiler/optimize.jl                 |   9 +-
 base/compiler/ssair/legacy.jl             |   2 -
 base/compiler/typeinfer.jl                | 252 ++++++++++++++--------
 base/compiler/types.jl                    |   1 +
 base/compiler/utilities.jl                |  14 +-
 base/opaque_closure.jl                    |  16 +-
 base/reflection.jl                        |  19 +-
 src/aotcompile.cpp                        |  81 +++----
 src/ast.c                                 |   5 -
 src/cgutils.cpp                           |  16 ++
 src/codegen-stubs.c                       |  11 +-
 src/codegen.cpp                           | 161 +++++++-------
 src/gf.c                                  | 163 ++++++++------
 src/interpreter.c                         |   4 +-
 src/ircode.c                              |  33 +--
 src/jitlayers.cpp                         | 148 +++----------
 src/jitlayers.h                           |   4 +-
 src/jl_exported_funcs.inc                 |   4 +-
 src/jltypes.c                             |  14 +-
 src/julia.h                               |  21 +-
 src/julia_internal.h                      |  21 +-
 src/method.c                              |  15 +-
 src/opaque_closure.c                      |  23 +-
 src/precompile_utils.c                    |   1 -
 src/staticdata.c                          |   2 +-
 src/toplevel.c                            |   8 +-
 stdlib/InteractiveUtils/src/codeview.jl   | 164 +++++++-------
 stdlib/InteractiveUtils/test/runtests.jl  |  28 +--
 stdlib/Serialization/src/Serialization.jl |  31 ++-
 test/compiler/AbstractInterpreter.jl      |   2 +-
 test/compiler/inference.jl                |   2 -
 test/compiler/inline.jl                   |   8 +-
 test/compiler/interpreter_exec.jl         |  21 +-
 test/copy.jl                              |  10 +-
 test/opaque_closure.jl                    |  10 +-
 test/worlds.jl                            |   3 +-
 37 files changed, 673 insertions(+), 668 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 5c1fea2e78e9f..0cc79cb92df6b 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -318,7 +318,7 @@ mutable struct InferenceState
         dont_work_on_me = false
         parent = nothing
 
-        valid_worlds = WorldRange(src.min_world, src.max_world == typemax(UInt) ? get_world_counter() : src.max_world)
+        valid_worlds = WorldRange(1, get_world_counter())
         bestguess = Bottom
         exc_bestguess = Bottom
         ipo_effects = EFFECTS_TOTAL
@@ -338,13 +338,21 @@ mutable struct InferenceState
         InferenceParams(interp).unoptimize_throw_blocks && mark_throw_blocks!(src, handler_at)
         !iszero(cache_mode & CACHE_MODE_LOCAL) && push!(get_inference_cache(interp), result)
 
-        return new(
+        this = new(
             linfo, world, mod, sptypes, slottypes, src, cfg, method_info,
             currbb, currpc, ip, handlers, handler_at, ssavalue_uses, bb_vartables, ssavaluetypes, stmt_edges, stmt_info,
             pclimitations, limitations, cycle_backedges, callers_in_cycle, dont_work_on_me, parent,
             result, unreachable, valid_worlds, bestguess, exc_bestguess, ipo_effects,
             restrict_abstract_call_sites, cache_mode, insert_coverage,
             interp)
+
+        # Apply generated function restrictions
+        if src.min_world != 1 || src.max_world != typemax(UInt)
+            # From generated functions
+            this.valid_worlds = WorldRange(src.min_world, src.max_world)
+        end
+
+        return this
     end
 end
 
@@ -799,7 +807,7 @@ function IRInterpretationState(interp::AbstractInterpreter,
     method_info = MethodInfo(src)
     ir = inflate_ir(src, mi)
     return IRInterpretationState(interp, method_info, ir, mi, argtypes, world,
-                                 src.min_world, src.max_world)
+                                 code.min_world, code.max_world)
 end
 
 # AbsIntState
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index cbe80a65fc607..3172c44c81158 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -107,19 +107,17 @@ is_declared_noinline(@nospecialize src::MaybeCompressed) =
 # OptimizationState #
 #####################
 
-is_source_inferred(@nospecialize src::MaybeCompressed) =
-    ccall(:jl_ir_flag_inferred, Bool, (Any,), src)
-
 function inlining_policy(interp::AbstractInterpreter,
     @nospecialize(src), @nospecialize(info::CallInfo), stmt_flag::UInt32)
     if isa(src, MaybeCompressed)
-        is_source_inferred(src) || return nothing
         src_inlineable = is_stmt_inline(stmt_flag) || is_inlineable(src)
         return src_inlineable ? src : nothing
     elseif isa(src, IRCode)
         return src
     elseif isa(src, SemiConcreteResult)
         return src
+    elseif isa(src, CodeInstance)
+        return inlining_policy(interp, src.inferred, info, stmt_flag)
     end
     return nothing
 end
@@ -222,7 +220,6 @@ end
 function ir_to_codeinf!(src::CodeInfo, ir::IRCode)
     replace_code_newstyle!(src, ir)
     widen_all_consts!(src)
-    src.inferred = true
     return src
 end
 
@@ -240,8 +237,6 @@ function widen_all_consts!(src::CodeInfo)
         end
     end
 
-    src.rettype = widenconst(src.rettype)
-
     return src
 end
 
diff --git a/base/compiler/ssair/legacy.jl b/base/compiler/ssair/legacy.jl
index 3e9a4e2a746dc..b1ce14f28cf14 100644
--- a/base/compiler/ssair/legacy.jl
+++ b/base/compiler/ssair/legacy.jl
@@ -55,8 +55,6 @@ Mainly used for testing or interactive use.
 inflate_ir(ci::CodeInfo, linfo::MethodInstance) = inflate_ir!(copy(ci), linfo)
 inflate_ir(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{Any}) = inflate_ir!(copy(ci), sptypes, argtypes)
 function inflate_ir(ci::CodeInfo)
-    parent = ci.parent
-    isa(parent, MethodInstance) && return inflate_ir(ci, parent)
     # XXX the length of `ci.slotflags` may be different from the actual number of call
     # arguments, but we really don't know that information in this case
     argtypes = Any[ Any for i = 1:length(ci.slotflags) ]
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 747fd6e3ef705..783bea60e3575 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -231,8 +231,6 @@ function finish!(interp::AbstractInterpreter, caller::InferenceState)
         result.src = opt = ir_to_codeinf!(opt)
     end
     if opt isa CodeInfo
-        opt.min_world = first(valid_worlds)
-        opt.max_world = last(valid_worlds)
         caller.src = opt
     else
         # In this case `caller.src` is invalid for clients (such as `typeinf_ext`) to use
@@ -278,8 +276,8 @@ function is_result_constabi_eligible(result::InferenceResult)
     result_type = result.result
     return isa(result_type, Const) && is_foldable_nothrow(result.ipo_effects) && is_inlineable_constant(result_type.val)
 end
-function CodeInstance(interp::AbstractInterpreter, result::InferenceResult,
-                      valid_worlds::WorldRange)
+function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
+        can_discard_trees::Bool=may_discard_trees(interp))
     local const_flags::Int32
     result_type = result.result
     @assert !(result_type === nothing || result_type isa LimitedAccuracy)
@@ -312,11 +310,11 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult,
         end
     end
     relocatability = 0x0
-    if const_flags == 0x3 && may_discard_trees(interp)
+    if const_flags == 0x3 && can_discard_trees
         inferred_result = nothing
         relocatability = 0x1
     else
-        inferred_result = transform_result_for_cache(interp, result.linfo, valid_worlds, result)
+        inferred_result = transform_result_for_cache(interp, result.linfo, result.valid_worlds, result, can_discard_trees)
         if isa(inferred_result, String)
             t = @_gc_preserve_begin inferred_result
             relocatability = unsafe_load(unsafe_convert(Ptr{UInt8}, inferred_result), Core.sizeof(inferred_result))
@@ -328,19 +326,19 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult,
     # relocatability = isa(inferred_result, String) ? inferred_result[end] : UInt8(0)
     return CodeInstance(result.linfo, cache_owner(interp),
         widenconst(result_type), widenconst(result.exc_result), rettype_const, inferred_result,
-        const_flags, first(valid_worlds), last(valid_worlds),
+        const_flags, first(result.valid_worlds), last(result.valid_worlds),
         # TODO: Actually do something with non-IPO effects
         encode_effects(result.ipo_effects), encode_effects(result.ipo_effects), result.analysis_results,
         relocatability)
 end
 
-function maybe_compress_codeinfo(interp::AbstractInterpreter, linfo::MethodInstance, ci::CodeInfo)
+function maybe_compress_codeinfo(interp::AbstractInterpreter, linfo::MethodInstance, ci::CodeInfo,
+        can_discard_trees::Bool=may_discard_trees(interp))
     def = linfo.def
     isa(def, Method) || return ci # don't compress toplevel code
-    if may_discard_trees(interp)
-        cache_the_tree = ci.inferred && (is_inlineable(ci) || isa_compileable_sig(linfo.specTypes, linfo.sparam_vals, def))
-    else
-        cache_the_tree = true
+    cache_the_tree = true
+    if can_discard_trees
+        cache_the_tree = is_inlineable(ci) || isa_compileable_sig(linfo.specTypes, linfo.sparam_vals, def)
     end
     if cache_the_tree
         if may_compress(interp)
@@ -357,11 +355,12 @@ function maybe_compress_codeinfo(interp::AbstractInterpreter, linfo::MethodInsta
 end
 
 function transform_result_for_cache(interp::AbstractInterpreter,
-    linfo::MethodInstance, valid_worlds::WorldRange, result::InferenceResult)
+        linfo::MethodInstance, valid_worlds::WorldRange, result::InferenceResult,
+        can_discard_trees::Bool=may_discard_trees(interp))
     inferred_result = result.src
     if inferred_result isa CodeInfo
         uncompressed = inferred_result
-        inferred_result = maybe_compress_codeinfo(interp, linfo, inferred_result)
+        inferred_result = maybe_compress_codeinfo(interp, linfo, inferred_result, can_discard_trees)
         result.is_src_volatile |= uncompressed !== inferred_result
     end
     # The global cache can only handle objects that codegen understands
@@ -372,23 +371,30 @@ function transform_result_for_cache(interp::AbstractInterpreter,
 end
 
 function cache_result!(interp::AbstractInterpreter, result::InferenceResult)
-    valid_worlds = result.valid_worlds
-    if last(valid_worlds) == get_world_counter()
+    if last(result.valid_worlds) == get_world_counter()
         # if we've successfully recorded all of the backedges in the global reverse-cache,
         # we can now widen our applicability in the global cache too
-        valid_worlds = WorldRange(first(valid_worlds), typemax(UInt))
+        result.valid_worlds = WorldRange(first(result.valid_worlds), typemax(UInt))
     end
     # check if the existing linfo metadata is also sufficient to describe the current inference result
     # to decide if it is worth caching this
     mi = result.linfo
     already_inferred = already_inferred_quick_test(interp, mi)
-    if !already_inferred && haskey(WorldView(code_cache(interp), valid_worlds), mi)
-        already_inferred = true
+    cache = WorldView(code_cache(interp), result.valid_worlds)
+    if !already_inferred && haskey(cache, mi)
+        ci = cache[mi]
+        # Even if we already have a CI for this, it's possible that the new CI has more
+        # information (E.g. because the source was limited before, but is no longer - this
+        # happens during bootstrap). In that case, allow the result to be recached.
+        if result.src === nothing || (ci.inferred !== nothing || ci.invoke != C_NULL)
+            already_inferred = true
+        end
     end
 
     # TODO: also don't store inferred code if we've previously decided to interpret this function
     if !already_inferred
-        code_cache(interp)[mi] = ci = CodeInstance(interp, result, valid_worlds)
+        code_cache(interp)[mi] = ci = CodeInstance(interp, result)
+        result.ci = ci
         if track_newly_inferred[]
             m = mi.def
             if isa(m, Method) && m.module != Core
@@ -529,7 +535,6 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
     end
     if me.src.edges !== nothing
         append!(s_edges, me.src.edges::Vector)
-        me.src.edges = nothing
     end
     # inspect whether our inference had a limited result accuracy,
     # else it may be suitable to cache
@@ -635,13 +640,6 @@ function record_slot_assign!(sv::InferenceState)
     return nothing
 end
 
-function record_bestguess!(sv::InferenceState)
-    bestguess = sv.bestguess
-    @assert !(bestguess isa LimitedAccuracy)
-    sv.src.rettype = bestguess
-    return nothing
-end
-
 # find the dominating assignment to the slot `id` in the block containing statement `idx`,
 # returns `nothing` otherwise
 function find_dominating_assignment(id::Int, idx::Int, sv::InferenceState)
@@ -670,8 +668,6 @@ function type_annotate!(interp::AbstractInterpreter, sv::InferenceState)
     # to hold all of the items assigned into it
     record_slot_assign!(sv)
 
-    record_bestguess!(sv)
-
     # annotate variables load types
     src = sv.src
     stmts = src.code
@@ -878,9 +874,8 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         exc_bestguess = refine_exception_type(frame.exc_bestguess, effects)
         # propagate newly inferred source to the inliner, allowing efficient inlining w/o deserialization:
         # note that this result is cached globally exclusively, we can use this local result destructively
-        volatile_inf_result = isinferred && let inferred_src = result.src
-                isa(inferred_src, CodeInfo) && (is_inlineable(inferred_src) || force_inline)
-            end ? VolatileInferenceResult(result) : nothing
+        volatile_inf_result = isinferred && (force_inline || inlining_policy(interp, result.src, NoCallInfo(), IR_FLAG_NULL) !== nothing) ?
+            VolatileInferenceResult(result) : nothing
         return EdgeCallResult(frame.bestguess, exc_bestguess, edge, effects, volatile_inf_result)
     elseif frame === true
         # unresolvable cycle
@@ -915,7 +910,15 @@ end
 
 #### entry points for inferring a MethodInstance given a type signature ####
 
-function codeinfo_for_const(interp::AbstractInterpreter, mi::MethodInstance, worlds::WorldRange, @nospecialize(val))
+"""
+    codeinfo_for_const(interp::AbstractInterpreter, mi::MethodInstance, worlds::WorldRange, @nospecialize(val))
+
+Return a fake CodeInfo that just contains `return \$val`. This function is used in various reflection APIs when asking
+for the code of a function that inference has found to just return a constant. For such functions, no code is actually
+stored - the constant is used directly. However, because this is an ABI implementation detail, it is nice to maintain
+consistency and just synthesize a CodeInfo when the reflection APIs ask for them - this function does that.
+"""
+function codeinfo_for_const(interp::AbstractInterpreter, mi::MethodInstance, @nospecialize(val))
     method = mi.def::Method
     tree = ccall(:jl_new_code_info_uninit, Ref{CodeInfo}, ())
     tree.code = Any[ ReturnNode(quoted(val)) ]
@@ -927,14 +930,24 @@ function codeinfo_for_const(interp::AbstractInterpreter, mi::MethodInstance, wor
     tree.linetable = LineInfoNode[LineInfoNode(method.module, method.name, method.file, method.line, Int32(0))]
     tree.ssaflags = UInt32[0]
     set_inlineable!(tree, true)
-    tree.parent = mi
-    tree.rettype = Core.Typeof(val)
-    tree.min_world = worlds.min_world
-    tree.max_world = worlds.max_world
-    tree.inferred = true
     return tree
 end
 
+"""
+    codeinstance_for_const_with_code(interp::AbstractInterpreter, code::CodeInstance)
+
+Given a constabi `CodeInstance`, create another (uncached) CodeInstance that contains the dummy code created
+by [`codeinfo_for_const`](@ref) for use in reflection functions that require this. See [`codeinfo_for_const`](@ref) for
+more details.
+"""
+function codeinstance_for_const_with_code(interp::AbstractInterpreter, code::CodeInstance)
+    src = codeinfo_for_const(interp, code.def, code.rettype_const)
+    return CodeInstance(code.def, cache_owner(interp), code.rettype, code.exctype, code.rettype_const, src,
+        Int32(0x3), code.min_world, code.max_world,
+        code.ipo_purity_bits, code.purity_bits, code.analysis_results,
+        code.relocatability)
+end
+
 result_is_constabi(interp::AbstractInterpreter, run_optimizer::Bool, result::InferenceResult) =
     run_optimizer && may_discard_trees(interp) && is_result_constabi_eligible(result)
 
@@ -950,7 +963,7 @@ function typeinf_code(interp::AbstractInterpreter, mi::MethodInstance, run_optim
     is_inferred(frame) || return nothing, Any
     if result_is_constabi(interp, run_optimizer, frame.result)
         rt = frame.result.result::Const
-        return codeinfo_for_const(interp, frame.linfo, frame.result.valid_worlds, rt.val), widenconst(rt)
+        return codeinfo_for_const(interp, frame.linfo, rt.val), widenconst(rt)
     end
     code = frame.src
     rt = widenconst(ignorelimited(frame.result.result))
@@ -1007,48 +1020,131 @@ function typeinf_frame(interp::AbstractInterpreter, mi::MethodInstance, run_opti
     return frame
 end
 
+# N.B.: These need to be aligned with the C side headers
+"""
+    SOURCE_MODE_NOT_REQUIRED
+
+Indicates to inference that the source is not required and the only fields
+of the resulting `CodeInstance` that the caller is interested in are types
+and effects. Inference is still free to create a CodeInstance with source,
+but is not required to do so.
+"""
+const SOURCE_MODE_NOT_REQUIRED = 0x0
+
+"""
+    SOURCE_MODE_ABI
+
+Indicates to inference that it should return a CodeInstance that can
+either be `->invoke`'d (because it has already been compiled or because
+it has constabi) or one that can be made so by compiling its `->inferred`
+field.
+
+N.B.: The `->inferred` field is volatile and the compiler may delete it.
+In such a case, it will first set the `invoke` field to a method that
+will block the thread until compilation is completed.
+"""
+const SOURCE_MODE_ABI = 0x1
+
+"""
+    SOURCE_MODE_FORCE_SOURCE
+
+Indicates that inference must always produce source in the `->inferred` field.
+This may mean that inference will need to re-do inference (if the `->inferred`
+field was previously deleted by the JIT) or may need to synthesize source for
+other kinds of CodeInstances.
+
+N.B.: The same caching considerations as SOURCE_MODE_ABI apply.
+"""
+const SOURCE_MODE_FORCE_SOURCE = 0x2
+
+"""
+    SOURCE_MODE_FORCE_SOURCE_UNCACHED
+
+Like `SOURCE_MODE_FORCE_SOURCE`, but ensures that the resulting code instance is
+not part of the cache hierarchy, so the `->inferred` field may be safely used
+without the possibility of deletion by the compiler.
+"""
+const SOURCE_MODE_FORCE_SOURCE_UNCACHED = 0x3
+
+function ci_has_source(code::CodeInstance)
+    inf = @atomic :monotonic code.inferred
+    return isa(inf, CodeInfo) || isa(inf, String)
+end
+
+"""
+    ci_has_abi(code::CodeInstance)
+
+Determine whether this CodeInstance is something that could be invoked if we gave it
+to the runtime system (either because it already has an ->invoke ptr, or because it
+has source that could be compiled).
+"""
+function ci_has_abi(code::CodeInstance)
+    ci_has_source(code) && return true
+    return code.invoke !== C_NULL
+end
+
+function ci_meets_requirement(code::CodeInstance, source_mode::UInt8, ci_is_cached::Bool)
+    source_mode == SOURCE_MODE_NOT_REQUIRED && return true
+    source_mode == SOURCE_MODE_ABI && return ci_has_abi(code)
+    source_mode == SOURCE_MODE_FORCE_SOURCE && return ci_has_source(code)
+    source_mode == SOURCE_MODE_FORCE_SOURCE_UNCACHED && return (!ci_is_cached && ci_has_source(code))
+    return false
+end
+
 # compute (and cache) an inferred AST and return type
-function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance)
-    method = mi.def::Method
+function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance, source_mode::UInt8)
     start_time = ccall(:jl_typeinf_timing_begin, UInt64, ())
     code = get(code_cache(interp), mi, nothing)
     if code isa CodeInstance
         # see if this code already exists in the cache
-        inf = @atomic :monotonic code.inferred
-        if use_const_api(code)
+        if source_mode in (SOURCE_MODE_FORCE_SOURCE, SOURCE_MODE_FORCE_SOURCE_UNCACHED) && use_const_api(code)
+            code = codeinstance_for_const_with_code(interp, code)
             ccall(:jl_typeinf_timing_end, Cvoid, (UInt64,), start_time)
-            return codeinfo_for_const(interp, mi, WorldRange(code.min_world, code.max_world), code.rettype_const)
-        elseif isa(inf, CodeInfo)
-            ccall(:jl_typeinf_timing_end, Cvoid, (UInt64,), start_time)
-            if !(inf.min_world == code.min_world &&
-                    inf.max_world == code.max_world &&
-                    inf.rettype === code.rettype)
-                inf = copy(inf)
-                inf.min_world = code.min_world
-                inf.max_world = code.max_world
-                inf.rettype = code.rettype
-            end
-            return inf
-        elseif isa(inf, String)
+            return code
+        end
+        if ci_meets_requirement(code, source_mode, true)
             ccall(:jl_typeinf_timing_end, Cvoid, (UInt64,), start_time)
-            inf = _uncompressed_ir(code, inf)
-            return inf
+            return code
         end
     end
-    if ccall(:jl_get_module_infer, Cint, (Any,), method.module) == 0 && !generating_output(#=incremental=#false)
-        return retrieve_code_info(mi, get_inference_world(interp))
+    def = mi.def
+    if isa(def, Method)
+        if ccall(:jl_get_module_infer, Cint, (Any,), def.module) == 0 && !generating_output(#=incremental=#false)
+            src = retrieve_code_info(mi, get_inference_world(interp))
+            return CodeInstance(mi, cache_owner(interp), Any, Any, nothing, src, Int32(0),
+                get_inference_world(interp), get_inference_world(interp),
+                UInt32(0), UInt32(0), nothing, UInt8(0))
+        end
     end
     lock_mi_inference(interp, mi)
     result = InferenceResult(mi, typeinf_lattice(interp))
-    frame = InferenceState(result, #=cache_mode=#:global, interp)
+    frame = InferenceState(result, #=cache_mode=#source_mode == SOURCE_MODE_FORCE_SOURCE_UNCACHED ? :volatile : :global, interp)
     frame === nothing && return nothing
     typeinf(interp, frame)
     ccall(:jl_typeinf_timing_end, Cvoid, (UInt64,), start_time)
-    if result_is_constabi(interp, true, frame.result)
-        return codeinfo_for_const(interp, frame.linfo, frame.result.valid_worlds, frame.result.result.val)
+    if isdefined(result, :ci)
+        if ci_meets_requirement(result.ci, source_mode, true)
+            # Inference result was cacheable and is in global cache. Return it.
+            return result.ci
+        elseif use_const_api(result.ci)
+            code = codeinstance_for_const_with_code(interp, result.ci)
+            @assert ci_meets_requirement(code, source_mode, false)
+            return code
+        end
     end
-    frame.src.inferred || return nothing
-    return frame.src
+    # Inference result is not cacheable or is was cacheable, but we do not want to
+    # store the source in the cache, but the caller wanted it anyway (e.g. for reflection).
+    # We construct a new CodeInstance for it that is not part of the cache hierarchy.
+    code = CodeInstance(interp, result, can_discard_trees=(
+        source_mode != SOURCE_MODE_FORCE_SOURCE && source_mode != SOURCE_MODE_FORCE_SOURCE_UNCACHED))
+
+    # If the caller cares about the code and this is constabi, still use our synthesis function
+    # anyway, because we will have not finished inferring the code inside the CodeInstance once
+    # we realized it was constabi, but we want reflection to pretend that we did.
+    if use_const_api(code) && source_mode in (SOURCE_MODE_FORCE_SOURCE, SOURCE_MODE_FORCE_SOURCE_UNCACHED)
+        return codeinstance_for_const_with_code(interp, code)
+    end
+    return code
 end
 
 # compute (and cache) an inferred AST and return the inferred return type
@@ -1076,27 +1172,9 @@ function typeinf_type(interp::AbstractInterpreter, mi::MethodInstance)
 end
 
 # This is a bridge for the C code calling `jl_typeinf_func()`
-typeinf_ext_toplevel(mi::MethodInstance, world::UInt) = typeinf_ext_toplevel(NativeInterpreter(world), mi)
-function typeinf_ext_toplevel(interp::AbstractInterpreter, mi::MethodInstance)
-    if isa(mi.def, Method)
-        # method lambda - infer this specialization via the method cache
-        src = typeinf_ext(interp, mi)
-    else
-        src = mi.uninferred::CodeInfo
-        if !src.inferred
-            # toplevel lambda - infer directly
-            start_time = ccall(:jl_typeinf_timing_begin, UInt64, ())
-            if !src.inferred
-                result = InferenceResult(mi, typeinf_lattice(interp))
-                frame = InferenceState(result, src, #=cache_mode=#:global, interp)
-                typeinf(interp, frame)
-                @assert is_inferred(frame) # TODO: deal with this better
-                src = frame.src
-            end
-            ccall(:jl_typeinf_timing_end, Cvoid, (UInt64,), start_time)
-        end
-    end
-    return src
+typeinf_ext_toplevel(mi::MethodInstance, world::UInt, source_mode::UInt8) = typeinf_ext_toplevel(NativeInterpreter(world), mi, source_mode)
+function typeinf_ext_toplevel(interp::AbstractInterpreter, mi::MethodInstance, source_mode::UInt8)
+    return typeinf_ext(interp, mi, source_mode)
 end
 
 function return_type(@nospecialize(f), t::DataType) # this method has a special tfunc
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index 53a363a2280e4..64410d231adda 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -88,6 +88,7 @@ mutable struct InferenceResult
     effects::Effects         # if optimization is finished
     analysis_results::AnalysisResults # AnalysisResults with e.g. result::ArgEscapeCache if optimized, otherwise NULL_ANALYSIS_RESULTS
     is_src_volatile::Bool    # `src` has been cached globally as the compressed format already, allowing `src` to be used destructively
+    ci::CodeInstance         # CodeInstance if this result has been added to the cache
     function InferenceResult(linfo::MethodInstance, cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
         # def = linfo.def
         # nargs = def isa Method ? Int(def.nargs) : 0
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 7d554e46a1744..66b5d3d15624b 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -128,25 +128,27 @@ function get_staged(mi::MethodInstance, world::UInt)
 end
 
 function retrieve_code_info(linfo::MethodInstance, world::UInt)
-    m = linfo.def::Method
+    def = linfo.def
+    if !isa(def, Method)
+        return linfo.uninferred
+    end
     c = nothing
-    if isdefined(m, :generator)
+    if isdefined(def, :generator)
         # user code might throw errors – ignore them
         c = get_staged(linfo, world)
     end
-    if c === nothing && isdefined(m, :source)
-        src = m.source
+    if c === nothing && isdefined(def, :source)
+        src = def.source
         if src === nothing
             # can happen in images built with --strip-ir
             return nothing
         elseif isa(src, String)
-            c = _uncompressed_ir(m, src)
+            c = _uncompressed_ir(def, src)
         else
             c = copy(src::CodeInfo)
         end
     end
     if c isa CodeInfo
-        c.parent = linfo
         return c
     end
     return nothing
diff --git a/base/opaque_closure.jl b/base/opaque_closure.jl
index cb3c00b128dcb..9891db20249fb 100644
--- a/base/opaque_closure.jl
+++ b/base/opaque_closure.jl
@@ -68,19 +68,12 @@ function Core.OpaqueClosure(ir::IRCode, @nospecialize env...;
     src.slotnames = fill(:none, nargs+1)
     src.slotflags = fill(zero(UInt8), length(ir.argtypes))
     src.slottypes = copy(ir.argtypes)
-    src.rettype = rt
     src = Core.Compiler.ir_to_codeinf!(src, ir)
     return generate_opaque_closure(sig, Union{}, rt, src, nargs, isva, env...; do_compile)
 end
 
-function Core.OpaqueClosure(src::CodeInfo, @nospecialize env...)
-    src.inferred || throw(ArgumentError("Expected inferred src::CodeInfo"))
-    mi = src.parent::Core.MethodInstance
-    sig = Base.tuple_type_tail(mi.specTypes)
-    method = mi.def::Method
-    nargs = method.nargs-1
-    isva = method.isva
-    return generate_opaque_closure(sig, Union{}, src.rettype, src, nargs, isva, env...)
+function Core.OpaqueClosure(src::CodeInfo, @nospecialize env...; rettype, sig, nargs, isva=false)
+    return generate_opaque_closure(sig, Union{}, rettype, src, nargs, isva, env...)
 end
 
 function generate_opaque_closure(@nospecialize(sig), @nospecialize(rt_lb), @nospecialize(rt_ub),
@@ -88,7 +81,8 @@ function generate_opaque_closure(@nospecialize(sig), @nospecialize(rt_lb), @nosp
                                  mod::Module=@__MODULE__,
                                  lineno::Int=0,
                                  file::Union{Nothing,Symbol}=nothing,
+                                 isinferred::Bool=true,
                                  do_compile::Bool=true)
-    return ccall(:jl_new_opaque_closure_from_code_info, Any, (Any, Any, Any, Any, Any, Cint, Any, Cint, Cint, Any, Cint),
-        sig, rt_lb, rt_ub, mod, src, lineno, file, nargs, isva, env, do_compile)
+    return ccall(:jl_new_opaque_closure_from_code_info, Any, (Any, Any, Any, Any, Any, Cint, Any, Cint, Cint, Any, Cint, Cint),
+        sig, rt_lb, rt_ub, mod, src, lineno, file, nargs, isva, env, do_compile, isinferred)
 end
diff --git a/base/reflection.jl b/base/reflection.jl
index 65a46242c389d..7f7d3ccf0a144 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1317,8 +1317,8 @@ uncompressed_ir(m::Method) = isdefined(m, :source) ? _uncompressed_ir(m, m.sourc
                              isdefined(m, :generator) ? error("Method is @generated; try `code_lowered` instead.") :
                              error("Code for this Method is not available.")
 _uncompressed_ir(m::Method, s::CodeInfo) = copy(s)
-_uncompressed_ir(m::Method, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), m, C_NULL, s)::CodeInfo
-_uncompressed_ir(ci::Core.CodeInstance, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any, Any), ci.def.def::Method, ci, s)::CodeInfo
+_uncompressed_ir(m::Method, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any), m, s)::CodeInfo
+_uncompressed_ir(ci::Core.CodeInstance, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any), ci.def.def::Method, s)::CodeInfo
 # for backwards compat
 const uncompressed_ast = uncompressed_ir
 const _uncompressed_ast = _uncompressed_ir
@@ -1628,21 +1628,24 @@ function code_typed_by_type(@nospecialize(tt::Type);
     return asts
 end
 
-function code_typed_opaque_closure(@nospecialize(oc::Core.OpaqueClosure);
-                                   debuginfo::Symbol=:default, _...)
+function get_oc_code_rt(@nospecialize(oc::Core.OpaqueClosure))
     ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
     m = oc.source
     if isa(m, Method)
         code = _uncompressed_ir(m, m.source)
-        debuginfo === :none && remove_linenums!(code)
-        # intersect the declared return type and the inferred return type (if available)
-        rt = typeintersect(code.rettype, typeof(oc).parameters[2])
-        return Any[code => rt]
+        return Pair{CodeInfo,Any}(code, typeof(oc).parameters[2])
     else
         error("encountered invalid Core.OpaqueClosure object")
     end
 end
 
+function code_typed_opaque_closure(@nospecialize(oc::Core.OpaqueClosure);
+                                   debuginfo::Symbol=:default, _...)
+    (code, rt) = get_oc_code_rt(oc)
+    debuginfo === :none && remove_linenums!(code)
+    return Any[Pair{CodeInfo,Any}(code, rt)]
+end
+
 """
     code_ircode(f, [types])
 
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 7b51579ce430f..54c92fb688d30 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -301,21 +301,14 @@ static void jl_ci_cache_lookup(const jl_cgparams_t &cgparams, jl_method_instance
         if ((jl_value_t*)*src_out == jl_nothing)
             *src_out = NULL;
         if (*src_out && jl_is_method(def))
-            *src_out = jl_uncompress_ir(def, codeinst, (jl_value_t*)*src_out);
+            *src_out = jl_uncompress_ir(def, (jl_value_t*)*src_out);
     }
     if (*src_out == NULL || !jl_is_code_info(*src_out)) {
         if (cgparams.lookup != jl_rettype_inferred_addr) {
             jl_error("Refusing to automatically run type inference with custom cache lookup.");
         }
         else {
-            *src_out = jl_type_infer(mi, world, 0);
-            if (*src_out) {
-                codeinst = jl_get_codeinst_for_src(mi, *src_out);
-                if ((*src_out)->inferred) {
-                    jl_value_t *null = nullptr;
-                    jl_atomic_cmpswap_relaxed(&codeinst->inferred, &null, jl_nothing);
-                }
-            }
+            *ci_out = jl_type_infer(mi, world, 0, SOURCE_MODE_ABI);
         }
     }
     *ci_out = codeinst;
@@ -374,11 +367,11 @@ void *jl_create_native_impl(jl_array_t *methods, LLVMOrcThreadSafeModuleRef llvm
     size_t compile_for[] = { jl_typeinf_world, _world };
     for (int worlds = 0; worlds < 2; worlds++) {
         JL_TIMING(NATIVE_AOT, NATIVE_Codegen);
-        params.world = compile_for[worlds];
-        if (!params.world)
+        size_t this_world = compile_for[worlds];
+        if (!this_world)
             continue;
         // Don't emit methods for the typeinf_world with extern policy
-        if (policy != CompilationPolicy::Default && params.world == jl_typeinf_world)
+        if (policy != CompilationPolicy::Default && this_world == jl_typeinf_world)
             continue;
         size_t i, l;
         for (i = 0, l = jl_array_nrows(methods); i < l; i++) {
@@ -395,17 +388,18 @@ void *jl_create_native_impl(jl_array_t *methods, LLVMOrcThreadSafeModuleRef llvm
             // if this method is generally visible to the current compilation world,
             // and this is either the primary world, or not applicable in the primary world
             // then we want to compile and emit this
-            if (jl_atomic_load_relaxed(&mi->def.method->primary_world) <= params.world && params.world <= jl_atomic_load_relaxed(&mi->def.method->deleted_world)) {
+            if (jl_atomic_load_relaxed(&mi->def.method->primary_world) <= this_world && this_world <= jl_atomic_load_relaxed(&mi->def.method->deleted_world)) {
                 // find and prepare the source code to compile
                 jl_code_instance_t *codeinst = NULL;
-                jl_ci_cache_lookup(*cgparams, mi, params.world, &codeinst, &src);
+                jl_ci_cache_lookup(*cgparams, mi, this_world, &codeinst, &src);
                 if (src && !params.compiled_functions.count(codeinst)) {
                     // now add it to our compilation results
                     JL_GC_PROMISE_ROOTED(codeinst->rettype);
                     orc::ThreadSafeModule result_m = jl_create_ts_module(name_from_method_instance(codeinst->def),
                             params.tsctx, clone.getModuleUnlocked()->getDataLayout(),
                             Triple(clone.getModuleUnlocked()->getTargetTriple()));
-                    jl_llvm_functions_t decls = jl_emit_code(result_m, mi, src, codeinst->rettype, params);
+                    jl_llvm_functions_t decls = jl_emit_code(result_m, mi, src, codeinst->rettype, params, jl_atomic_load_relaxed(&codeinst->min_world),
+                        jl_atomic_load_relaxed(&codeinst->max_world));
                     if (result_m)
                         params.compiled_functions[codeinst] = {std::move(result_m), std::move(decls)};
                 }
@@ -1946,18 +1940,20 @@ extern "C" JL_DLLEXPORT_CODEGEN jl_code_info_t *jl_gdbdumpcode(jl_method_instanc
 
     jl_code_info_t *src = NULL;
     jl_value_t *ci = jl_default_cgparams.lookup(mi, world, world);
-    if (ci != jl_nothing) {
+    if (ci == jl_nothing) {
+        ci = (jl_value_t*)jl_type_infer(mi, world, 0, SOURCE_MODE_FORCE_SOURCE_UNCACHED);
+    } else {
+        ci = NULL;
+    }
+    if (ci) {
         jl_code_instance_t *codeinst = (jl_code_instance_t*)ci;
         src = (jl_code_info_t*)jl_atomic_load_relaxed(&codeinst->inferred);
         if ((jl_value_t*)src != jl_nothing && !jl_is_code_info(src) && jl_is_method(mi->def.method)) {
             JL_GC_PUSH2(&codeinst, &src);
-            src = jl_uncompress_ir(mi->def.method, codeinst, (jl_value_t*)src);
+            src = jl_uncompress_ir(mi->def.method, (jl_value_t*)src);
             JL_GC_POP();
         }
     }
-    if (!src || (jl_value_t*)src == jl_nothing) {
-        src = jl_type_infer(mi, world, 0);
-    }
     return src;
 }
 
@@ -1970,48 +1966,34 @@ extern "C" JL_DLLEXPORT_CODEGEN
 void jl_get_llvmf_defn_impl(jl_llvmf_dump_t* dump, jl_method_instance_t *mi, size_t world, char getwrapper, char optimize, const jl_cgparams_t params)
 {
     if (jl_is_method(mi->def.method) && mi->def.method->source == NULL &&
-            mi->def.method->generator == NULL) {
+            mi->def.method->generator == NULL && !mi->def.method->is_for_opaque_closure) {
         // not a generic function
         dump->F = NULL;
         return;
     }
 
     // get the source code for this function
-    jl_value_t *jlrettype = (jl_value_t*)jl_any_type;
     jl_code_info_t *src = NULL;
     jl_code_instance_t *codeinst = NULL;
-    JL_GC_PUSH3(&src, &jlrettype, &codeinst);
-    if (jl_is_method(mi->def.method) && mi->def.method->source != NULL && mi->def.method->source != jl_nothing && jl_ir_flag_inferred(mi->def.method->source)) {
-        // uninferred opaque closure
-        src = (jl_code_info_t*)mi->def.method->source;
-        if (src && !jl_is_code_info(src))
-            src = jl_uncompress_ir(mi->def.method, NULL, (jl_value_t*)src);
+    JL_GC_PUSH2(&src, &codeinst);
+    jl_value_t *ci = params.lookup(mi, world, world);
+    if (ci && ci != jl_nothing) {
+        codeinst = (jl_code_instance_t*)ci;
+        src = (jl_code_info_t*)jl_atomic_load_relaxed(&codeinst->inferred);
     }
-    else {
-        jl_value_t *ci = params.lookup(mi, world, world);
-        if (ci != jl_nothing) {
-            codeinst = (jl_code_instance_t*)ci;
+    if (!src || (jl_value_t*)src == jl_nothing) {
+        codeinst = jl_type_infer(mi, world, 0, SOURCE_MODE_FORCE_SOURCE_UNCACHED);
+        if (codeinst) {
             src = (jl_code_info_t*)jl_atomic_load_relaxed(&codeinst->inferred);
-            if ((jl_value_t*)src != jl_nothing && !jl_is_code_info(src) && jl_is_method(mi->def.method))
-                src = jl_uncompress_ir(mi->def.method, codeinst, (jl_value_t*)src);
-            jlrettype = codeinst->rettype;
-            codeinst = NULL; // not needed outside of this branch
-        }
-        if (!src || (jl_value_t*)src == jl_nothing) {
-            src = jl_type_infer(mi, world, 0);
-            if (src)
-                jlrettype = src->rettype;
-            else if (jl_is_method(mi->def.method)) {
-                src = mi->def.method->generator ? jl_code_for_staged(mi, world) : (jl_code_info_t*)mi->def.method->source;
-                if (src && (jl_value_t*)src != jl_nothing && !jl_is_code_info(src) && jl_is_method(mi->def.method))
-                    src = jl_uncompress_ir(mi->def.method, NULL, (jl_value_t*)src);
-            }
-            // TODO: use mi->uninferred
         }
     }
+    if (src) {
+        if ((jl_value_t*)src != jl_nothing && !jl_is_code_info(src) && jl_is_method(mi->def.method))
+            src = jl_uncompress_ir(mi->def.method, (jl_value_t*)src);
+    }
 
     // emit this function into a new llvm module
-    if (src && jl_is_code_info(src)) {
+    if (codeinst && src && jl_is_code_info(src)) {
         auto ctx = jl_ExecutionEngine->getContext();
         orc::ThreadSafeModule m = jl_create_ts_module(name_from_method_instance(mi), *ctx);
         uint64_t compiler_start_time = 0;
@@ -2023,7 +2005,6 @@ void jl_get_llvmf_defn_impl(jl_llvmf_dump_t* dump, jl_method_instance_t *mi, siz
             return std::make_pair(M.getDataLayout(), Triple(M.getTargetTriple()));
         });
         jl_codegen_params_t output(*ctx, std::move(target_info.first), std::move(target_info.second));
-        output.world = world;
         output.params = &params;
         output.imaging_mode = imaging_default();
         // This would be nice, but currently it causes some assembly regressions that make printed output
@@ -2033,7 +2014,7 @@ void jl_get_llvmf_defn_impl(jl_llvmf_dump_t* dump, jl_method_instance_t *mi, siz
         // This would also be nice, but it seems to cause OOMs on the windows32 builder
         // To get correct names in the IR this needs to be at least 2
         output.debug_level = params.debug_info_level;
-        auto decls = jl_emit_code(m, mi, src, jlrettype, output);
+        auto decls = jl_emit_code(m, mi, src, codeinst->rettype, output, jl_atomic_load_relaxed(&codeinst->min_world),  jl_atomic_load_relaxed(&codeinst->max_world));
         JL_UNLOCK(&jl_codegen_lock); // Might GC
 
         Function *F = NULL;
diff --git a/src/ast.c b/src/ast.c
index 8816c905ee101..bd3460cbe7fd2 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -945,11 +945,6 @@ JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
         new_ci->ssaflags = jl_array_copy(new_ci->ssaflags);
         jl_gc_wb(new_ci, new_ci->ssaflags);
 
-        if (new_ci->edges != jl_nothing) {
-            new_ci->edges = (jl_value_t*)jl_array_copy((jl_array_t*)new_ci->edges);
-            jl_gc_wb(new_ci, new_ci->edges);
-        }
-
         if (jl_is_array(new_ci->ssavaluetypes)) {
             new_ci->ssavaluetypes = (jl_value_t*)jl_array_copy((jl_array_t*)new_ci->ssavaluetypes);
             jl_gc_wb(new_ci, new_ci->ssavaluetypes);
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 007e4c5936a4f..55dc18b8cfa04 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -4257,6 +4257,22 @@ static Value *emit_memoryref_ptr(jl_codectx_t &ctx, const jl_cgval_t &ref, const
     return data;
 }
 
+jl_value_t *jl_fptr_wait_for_compiled(jl_value_t *f, jl_value_t **args, uint32_t nargs, jl_code_instance_t *m)
+{
+    // This relies on the invariant that the JIT will have set the invoke ptr
+    // by the time it releases the codegen lock. If the code is refactored to make the
+    // codegen lock more fine-grained, this will have to be replaced by a per-codeinstance futex.
+    size_t nthreads = jl_atomic_load_acquire(&jl_n_threads);
+    // This should only be possible if there's more than one thread. If not, either there's a bug somewhere
+    // that resulted in this not getting cleared, or we're about to deadlock. Either way, that's bad.
+    if (nthreads == 1) {
+        jl_error("Internal error: Reached jl_fptr_wait_for_compiled in single-threaded execution.");
+    }
+    JL_LOCK(&jl_codegen_lock);
+    JL_UNLOCK(&jl_codegen_lock);
+    return jl_atomic_load_acquire(&m->invoke)(f, args, nargs, m);
+}
+
 // Reset us back to codegen debug type
 #undef DEBUG_TYPE
 #define DEBUG_TYPE "julia_irgen_codegen"
diff --git a/src/codegen-stubs.c b/src/codegen-stubs.c
index 26b8226b6e4be..dda9bbee184a0 100644
--- a/src/codegen-stubs.c
+++ b/src/codegen-stubs.c
@@ -38,17 +38,16 @@ JL_DLLEXPORT void jl_register_fptrs_fallback(uint64_t image_base, const struct _
     (void)image_base; (void)fptrs; (void)linfos; (void)n;
 }
 
-JL_DLLEXPORT jl_code_instance_t *jl_generate_fptr_fallback(jl_method_instance_t *mi JL_PROPAGATES_ROOT, size_t world)
-{
-    return NULL;
-}
-
 JL_DLLEXPORT void jl_generate_fptr_for_unspecialized_fallback(jl_code_instance_t *unspec)
 {
     jl_atomic_store_release(&unspec->invoke, &jl_fptr_interpret_call);
 }
 
-JL_DLLEXPORT void jl_generate_fptr_for_oc_wrapper_fallback(jl_code_instance_t *unspec) UNAVAILABLE
+JL_DLLEXPORT void jl_compile_codeinst_fallback(jl_code_instance_t *unspec)
+{
+    // Do nothing. The caller will notice that we failed to provide a an ->invoke and trigger
+    // appropriate fallbacks.
+}
 
 JL_DLLEXPORT uint32_t jl_get_LLVM_VERSION_fallback(void)
 {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 6de2669ac0f7d..93fc1b9a680e2 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1915,7 +1915,8 @@ class jl_codectx_t {
     jl_value_t *rettype = NULL;
     jl_code_info_t *source = NULL;
     jl_array_t *code = NULL;
-    size_t world = 0;
+    size_t min_world = 0;
+    size_t max_world = -1;
     const char *name = NULL;
     StringRef file{};
     ssize_t *line = NULL;
@@ -1938,14 +1939,19 @@ class jl_codectx_t {
 
     SmallVector<std::unique_ptr<Module>, 0> llvmcall_modules;
 
-    jl_codectx_t(LLVMContext &llvmctx, jl_codegen_params_t &params)
+    jl_codectx_t(LLVMContext &llvmctx, jl_codegen_params_t &params, size_t min_world, size_t max_world)
       : builder(llvmctx),
         emission_context(params),
         call_targets(),
-        world(params.world),
+        min_world(min_world),
+        max_world(max_world),
         use_cache(params.cache),
         external_linkage(params.external_linkage),
-        params(params.params) { }
+        params(params.params) {
+    }
+
+    jl_codectx_t(LLVMContext &llvmctx, jl_codegen_params_t &params, jl_code_instance_t *ci) :
+        jl_codectx_t(llvmctx, params, jl_atomic_load_relaxed(&ci->min_world), jl_atomic_load_relaxed(&ci->max_world)) {}
 
     jl_typecache_t &types() {
         type_cache.initialize(builder.getContext(), emission_context.DL);
@@ -3892,7 +3898,8 @@ static jl_llvm_functions_t
         jl_method_instance_t *lam,
         jl_code_info_t *src,
         jl_value_t *jlrettype,
-        jl_codegen_params_t &params);
+        jl_codegen_params_t &params,
+        size_t min_world, size_t max_world);
 
 static void emit_hasnofield_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *type, jl_cgval_t name);
 
@@ -4988,7 +4995,7 @@ static jl_cgval_t emit_invoke(jl_codectx_t &ctx, const jl_cgval_t &lival, ArrayR
             }
         }
         else {
-            jl_value_t *ci = ctx.params->lookup(mi, ctx.world, ctx.world); // TODO: need to use the right pair world here
+            jl_value_t *ci = ctx.params->lookup(mi, ctx.min_world, ctx.max_world);
             if (ci != jl_nothing) {
                 jl_code_instance_t *codeinst = (jl_code_instance_t*)ci;
                 auto invoke = jl_atomic_load_acquire(&codeinst->invoke);
@@ -5992,7 +5999,7 @@ static std::pair<Function*, Function*> get_oc_function(jl_codectx_t &ctx, jl_met
     sigtype = jl_apply_tuple_type_v(jl_svec_data(sig_args), nsig);
 
     jl_method_instance_t *mi = jl_specializations_get_linfo(closure_method, sigtype, jl_emptysvec);
-    jl_code_instance_t *ci = (jl_code_instance_t*)jl_rettype_inferred_addr(mi, ctx.world, ctx.world);
+    jl_code_instance_t *ci = (jl_code_instance_t*)jl_rettype_inferred_addr(mi, ctx.min_world, ctx.max_world);
 
     if (ci == NULL || (jl_value_t*)ci == jl_nothing) {
         JL_GC_POP();
@@ -6008,13 +6015,13 @@ static std::pair<Function*, Function*> get_oc_function(jl_codectx_t &ctx, jl_met
 
     if (it == ctx.emission_context.compiled_functions.end()) {
         ++EmittedOpaqueClosureFunctions;
-        jl_code_info_t *ir = jl_uncompress_ir(closure_method, ci, (jl_value_t*)inferred);
+        jl_code_info_t *ir = jl_uncompress_ir(closure_method, (jl_value_t*)inferred);
         JL_GC_PUSH1(&ir);
         // TODO: Emit this inline and outline it late using LLVM's coroutine support.
         orc::ThreadSafeModule closure_m = jl_create_ts_module(
                 name_from_method_instance(mi), ctx.emission_context.tsctx,
                 jl_Module->getDataLayout(), Triple(jl_Module->getTargetTriple()));
-        jl_llvm_functions_t closure_decls = emit_function(closure_m, mi, ir, rettype, ctx.emission_context);
+        jl_llvm_functions_t closure_decls = emit_function(closure_m, mi, ir, rettype, ctx.emission_context, ctx.min_world, ctx.max_world);
         JL_GC_POP();
         it = ctx.emission_context.compiled_functions.insert(std::make_pair(ci, std::make_pair(std::move(closure_m), std::move(closure_decls)))).first;
     }
@@ -6514,7 +6521,7 @@ static Value *get_scope_field(jl_codectx_t &ctx)
 static Function *emit_tojlinvoke(jl_code_instance_t *codeinst, Module *M, jl_codegen_params_t &params)
 {
     ++EmittedToJLInvokes;
-    jl_codectx_t ctx(M->getContext(), params);
+    jl_codectx_t ctx(M->getContext(), params, codeinst);
     std::string name;
     raw_string_ostream(name) << "tojlinvoke" << jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1);
     Function *f = Function::Create(ctx.types().T_jlfunc,
@@ -6531,7 +6538,7 @@ static Function *emit_tojlinvoke(jl_code_instance_t *codeinst, Module *M, jl_cod
     auto invoke = jl_atomic_load_relaxed(&codeinst->invoke);
     bool cache_valid = params.cache;
 
-    if (cache_valid && invoke != NULL) {
+    if (cache_valid && invoke != NULL && invoke != &jl_fptr_wait_for_compiled) {
         StringRef theFptrName = jl_ExecutionEngine->getFunctionAtAddress((uintptr_t)invoke, codeinst);
         theFunc = cast<Function>(
             M->getOrInsertFunction(theFptrName, jlinvoke_func->_type(ctx.builder.getContext())).getCallee());
@@ -6562,10 +6569,11 @@ static void emit_cfunc_invalidate(
         jl_value_t *calltype, jl_value_t *rettype, bool is_for_opaque_closure,
         size_t nargs,
         jl_codegen_params_t &params,
-        Function *target)
+        Function *target,
+        size_t min_world, size_t max_world)
 {
     ++EmittedCFuncInvalidates;
-    jl_codectx_t ctx(gf_thunk->getParent()->getContext(), params);
+    jl_codectx_t ctx(gf_thunk->getParent()->getContext(), params, min_world, max_world);
     ctx.f = gf_thunk;
 
     BasicBlock *b0 = BasicBlock::Create(ctx.builder.getContext(), "top", gf_thunk);
@@ -6673,18 +6681,19 @@ static void emit_cfunc_invalidate(
 static void emit_cfunc_invalidate(
         Function *gf_thunk, jl_returninfo_t::CallingConv cc, unsigned return_roots,
         jl_value_t *calltype, jl_value_t *rettype, bool is_for_opaque_closure,
-        size_t nargs,
-        jl_codegen_params_t &params)
+        size_t nargs, jl_codegen_params_t &params,
+        size_t min_world, size_t max_world)
 {
     emit_cfunc_invalidate(gf_thunk, cc, return_roots, calltype, rettype, is_for_opaque_closure, nargs, params,
-        prepare_call_in(gf_thunk->getParent(), jlapplygeneric_func));
+        prepare_call_in(gf_thunk->getParent(), jlapplygeneric_func), min_world, max_world);
 }
 
 static Function* gen_cfun_wrapper(
     Module *into, jl_codegen_params_t &params,
     const function_sig_t &sig, jl_value_t *ff, const char *aliasname,
     jl_value_t *declrt, jl_method_instance_t *lam,
-    jl_unionall_t *unionall_env, jl_svec_t *sparam_vals, jl_array_t **closure_types)
+    jl_unionall_t *unionall_env, jl_svec_t *sparam_vals, jl_array_t **closure_types,
+    size_t min_world, size_t max_world)
 {
     ++GeneratedCFuncWrappers;
     // Generate a c-callable wrapper
@@ -6802,9 +6811,8 @@ static Function* gen_cfun_wrapper(
     jl_init_function(cw, params.TargetTriple);
     cw->setAttributes(AttributeList::get(M->getContext(), {attributes, cw->getAttributes()}));
 
-    jl_codectx_t ctx(M->getContext(), params);
+    jl_codectx_t ctx(M->getContext(), params, min_world, max_world);
     ctx.f = cw;
-    ctx.world = world;
     ctx.name = name;
     ctx.funcName = name;
 
@@ -7125,7 +7133,8 @@ static Function* gen_cfun_wrapper(
             // build a  specsig -> jl_apply_generic converter thunk
             // this builds a method that calls jl_apply_generic (as a closure over a singleton function pointer),
             // but which has the signature of a specsig
-            emit_cfunc_invalidate(gf_thunk, returninfo.cc, returninfo.return_roots, lam->specTypes, codeinst->rettype, is_opaque_closure, nargs + 1, ctx.emission_context);
+            emit_cfunc_invalidate(gf_thunk, returninfo.cc, returninfo.return_roots, lam->specTypes, codeinst->rettype, is_opaque_closure, nargs + 1, ctx.emission_context,
+                min_world, max_world);
             theFptr = ctx.builder.CreateSelect(age_ok, theFptr, gf_thunk);
         }
 
@@ -7345,7 +7354,7 @@ static jl_cgval_t emit_cfunction(jl_codectx_t &ctx, jl_value_t *output_type, con
             jl_Module, ctx.emission_context,
             sig, fexpr_rt.constant, NULL,
             declrt, lam,
-            unionall_env, sparam_vals, &closure_types);
+            unionall_env, sparam_vals, &closure_types, min_valid, max_valid);
     bool outboxed;
     if (nest) {
         // F is actually an init_trampoline function that returns the real address
@@ -7450,7 +7459,7 @@ const char *jl_generate_ccallable(LLVMOrcThreadSafeModuleRef llvmmod, void *sysi
             else {
                 jl_method_instance_t *lam = jl_get_specialization1((jl_tupletype_t*)sigt, world, &min_valid, &max_valid, 0);
                 //Safe b/c params holds context lock
-                gen_cfun_wrapper(unwrap(llvmmod)->getModuleUnlocked(), params, sig, ff, name, declrt, lam, NULL, NULL, NULL);
+                gen_cfun_wrapper(unwrap(llvmmod)->getModuleUnlocked(), params, sig, ff, name, declrt, lam, NULL, NULL, NULL, min_valid, max_valid);
             }
             JL_GC_POP();
             return name;
@@ -7478,11 +7487,10 @@ static Function *gen_invoke_wrapper(jl_method_instance_t *lam, jl_value_t *jlret
     //Value *mfunc = &*AI++; (void)mfunc; // unused
     assert(AI == w->arg_end());
 
-    jl_codectx_t ctx(M->getContext(), params);
+    jl_codectx_t ctx(M->getContext(), params, 0, 0);
     ctx.f = w;
     ctx.linfo = lam;
     ctx.rettype = jlretty;
-    ctx.world = 0;
 
     BasicBlock *b0 = BasicBlock::Create(ctx.builder.getContext(), "top", w);
     ctx.builder.SetInsertPoint(b0);
@@ -7864,12 +7872,13 @@ static jl_llvm_functions_t
         jl_method_instance_t *lam,
         jl_code_info_t *src,
         jl_value_t *jlrettype,
-        jl_codegen_params_t &params)
+        jl_codegen_params_t &params,
+        size_t min_world, size_t max_world)
 {
     ++EmittedFunctions;
     // step 1. unpack AST and allocate codegen context for this function
     jl_llvm_functions_t declarations;
-    jl_codectx_t ctx(*params.tsctx.getContext(), params);
+    jl_codectx_t ctx(*params.tsctx.getContext(), params, min_world, max_world);
     jl_datatype_t *vatyp = NULL;
     JL_GC_PUSH2(&ctx.code, &vatyp);
     ctx.code = src->code;
@@ -7949,8 +7958,6 @@ static jl_llvm_functions_t
 
     bool specsig, needsparams;
     std::tie(specsig, needsparams) = uses_specsig(lam, jlrettype, params.params->prefer_specsig);
-    if (!src->inferred)
-        specsig = false;
 
     // step 3. some variable analysis
     size_t i;
@@ -7985,7 +7992,7 @@ static jl_llvm_functions_t
         jl_varinfo_t &varinfo = ctx.slots[i];
         uint8_t flags = jl_array_uint8_ref(src->slotflags, i);
         varinfo.isSA = (jl_vinfo_sa(flags) != 0) || varinfo.isArgument;
-        varinfo.usedUndef = (jl_vinfo_usedundef(flags) != 0) || (!varinfo.isArgument && !src->inferred);
+        varinfo.usedUndef = (jl_vinfo_usedundef(flags) != 0) || !varinfo.isArgument;
         if (!varinfo.isArgument) {
             varinfo.value = mark_julia_type(ctx, (Value*)NULL, false, (jl_value_t*)jl_any_type);
         }
@@ -9473,7 +9480,8 @@ jl_llvm_functions_t jl_emit_code(
         jl_method_instance_t *li,
         jl_code_info_t *src,
         jl_value_t *jlrettype,
-        jl_codegen_params_t &params)
+        jl_codegen_params_t &params,
+        size_t min_world, size_t max_world)
 {
     JL_TIMING(CODEGEN, CODEGEN_LLVM);
     jl_timing_show_func_sig((jl_value_t *)li->specTypes, JL_TIMING_DEFAULT_BLOCK);
@@ -9483,7 +9491,7 @@ jl_llvm_functions_t jl_emit_code(
         compare_cgparams(params.params, &jl_default_cgparams)) &&
         "functions compiled with custom codegen params must not be cached");
     JL_TRY {
-        decls = emit_function(m, li, src, jlrettype, params);
+        decls = emit_function(m, li, src, jlrettype, params, min_world, max_world);
         auto stream = *jl_ExecutionEngine->get_dump_emitted_mi_name_stream();
         if (stream) {
             jl_printf(stream, "%s\t", decls.specFunctionObject.c_str());
@@ -9518,7 +9526,7 @@ jl_llvm_functions_t jl_emit_code(
 static jl_llvm_functions_t jl_emit_oc_wrapper(orc::ThreadSafeModule &m, jl_codegen_params_t &params, jl_method_instance_t *mi, jl_value_t *rettype)
 {
     Module *M = m.getModuleUnlocked();
-    jl_codectx_t ctx(M->getContext(), params);
+    jl_codectx_t ctx(M->getContext(), params, 0, 0);
     ctx.name = M->getModuleIdentifier().data();
     std::string funcName = get_function_name(true, false, ctx.name, ctx.emission_context.TargetTriple);
     jl_llvm_functions_t declarations;
@@ -9528,7 +9536,7 @@ static jl_llvm_functions_t jl_emit_oc_wrapper(orc::ThreadSafeModule &m, jl_codeg
         Function *gf_thunk = cast<Function>(returninfo.decl.getCallee());
         jl_init_function(gf_thunk, ctx.emission_context.TargetTriple);
         size_t nrealargs = jl_nparams(mi->specTypes);
-        emit_cfunc_invalidate(gf_thunk, returninfo.cc, returninfo.return_roots, mi->specTypes, rettype, true, nrealargs, ctx.emission_context);
+        emit_cfunc_invalidate(gf_thunk, returninfo.cc, returninfo.return_roots, mi->specTypes, rettype, true, nrealargs, ctx.emission_context, ctx.min_world, ctx.max_world);
         declarations.specFunctionObject = funcName;
     }
     return declarations;
@@ -9562,14 +9570,15 @@ jl_llvm_functions_t jl_emit_codeinst(
             return jl_emit_oc_wrapper(m, params, codeinst->def, codeinst->rettype);
         }
         if (src && (jl_value_t*)src != jl_nothing && jl_is_method(def))
-            src = jl_uncompress_ir(def, codeinst, (jl_value_t*)src);
+            src = jl_uncompress_ir(def, (jl_value_t*)src);
         if (!src || !jl_is_code_info(src)) {
             JL_GC_POP();
             m = orc::ThreadSafeModule();
             return jl_llvm_functions_t(); // failed
         }
     }
-    jl_llvm_functions_t decls = jl_emit_code(m, codeinst->def, src, codeinst->rettype, params);
+    jl_llvm_functions_t decls = jl_emit_code(m, codeinst->def, src, codeinst->rettype, params,
+        jl_atomic_load_relaxed(&codeinst->min_world), jl_atomic_load_relaxed(&codeinst->max_world));
 
     const std::string &specf = decls.specFunctionObject;
     const std::string &f = decls.functionObject;
@@ -9590,38 +9599,40 @@ jl_llvm_functions_t jl_emit_codeinst(
                 jl_add_code_in_flight(f, codeinst, DL);
         }
 
-        if (params.world) {// don't alter `inferred` when the code is not directly being used
-            jl_value_t *inferred = jl_atomic_load_relaxed(&codeinst->inferred);
-            // don't change inferred state
-            if (inferred) {
-                jl_method_t *def = codeinst->def->def.method;
-                if (// keep code when keeping everything
-                    !(JL_DELETE_NON_INLINEABLE) ||
-                    // aggressively keep code when debugging level >= 2
-                    // note that this uses the global jl_options.debug_level, not the local emission_ctx.debug_level
-                    jl_options.debug_level > 1) {
-                    // update the stored code
-                    if (inferred != (jl_value_t*)src) {
-                        if (jl_is_method(def)) {
-                            src = (jl_code_info_t*)jl_compress_ir(def, src);
-                            assert(jl_is_string(src));
-                            codeinst->relocatability = jl_string_data(src)[jl_string_len(src)-1];
-                        }
-                        jl_atomic_store_release(&codeinst->inferred, (jl_value_t*)src);
-                        jl_gc_wb(codeinst, src);
+        jl_value_t *inferred = jl_atomic_load_relaxed(&codeinst->inferred);
+        // don't change inferred state
+        if (inferred) {
+            jl_method_t *def = codeinst->def->def.method;
+            if (// keep code when keeping everything
+                !(JL_DELETE_NON_INLINEABLE) ||
+                // aggressively keep code when debugging level >= 2
+                // note that this uses the global jl_options.debug_level, not the local emission_ctx.debug_level
+                jl_options.debug_level > 1) {
+                // update the stored code
+                if (inferred != (jl_value_t*)src) {
+                    if (jl_is_method(def)) {
+                        src = (jl_code_info_t*)jl_compress_ir(def, src);
+                        assert(jl_is_string(src));
+                        codeinst->relocatability = jl_string_data(src)[jl_string_len(src)-1];
                     }
+                    jl_atomic_store_release(&codeinst->inferred, (jl_value_t*)src);
+                    jl_gc_wb(codeinst, src);
                 }
-                // delete non-inlineable code, since it won't be needed again
-                // because we already emitted LLVM code from it and the native
-                // Julia-level optimization will never need to see it
-                else if (jl_is_method(def) && // don't delete toplevel code
-                         inferred != jl_nothing && // and there is something to delete (test this before calling jl_ir_inlining_cost)
-                         !effects_foldable(codeinst->ipo_purity_bits) && // don't delete code we may want for irinterp
-                         ((jl_ir_inlining_cost(inferred) == UINT16_MAX) || // don't delete inlineable code
-                          jl_atomic_load_relaxed(&codeinst->invoke) == jl_fptr_const_return_addr) && // unless it is constant
-                         !(params.imaging_mode || jl_options.incremental)) { // don't delete code when generating a precompile file
-                    jl_atomic_store_release(&codeinst->inferred, jl_nothing);
-                }
+            }
+            // delete non-inlineable code, since it won't be needed again
+            // because we already emitted LLVM code from it and the native
+            // Julia-level optimization will never need to see it
+            else if (jl_is_method(def) && // don't delete toplevel code
+                        def->source != NULL && // don't delete code from optimized opaque closures that can't be reconstructed
+                        inferred != jl_nothing && // and there is something to delete (test this before calling jl_ir_inlining_cost)
+                        !effects_foldable(codeinst->ipo_purity_bits) && // don't delete code we may want for irinterp
+                        ((jl_ir_inlining_cost(inferred) == UINT16_MAX) || // don't delete inlineable code
+                        jl_atomic_load_relaxed(&codeinst->invoke) == jl_fptr_const_return_addr) && // unless it is constant
+                        !(params.imaging_mode || jl_options.incremental)) { // don't delete code when generating a precompile file
+                // Never end up in a situation where the codeinst has no invoke, but also no source, so we never fall
+                // through the cracks of SOURCE_MODE_ABI.
+                jl_atomic_store_release(&codeinst->invoke, &jl_fptr_wait_for_compiled);
+                jl_atomic_store_release(&codeinst->inferred, jl_nothing);
             }
         }
     }
@@ -9644,15 +9655,12 @@ void jl_compile_workqueue(
         auto proto = it.second;
         params.workqueue.pop_back();
         // try to emit code for this item from the workqueue
-        assert(jl_atomic_load_relaxed(&codeinst->min_world) <= params.world &&
-               jl_atomic_load_relaxed(&codeinst->max_world) >= params.world &&
-               "invalid world for code-instance");
         StringRef preal_decl = "";
         bool preal_specsig = false;
         auto invoke = jl_atomic_load_acquire(&codeinst->invoke);
         bool cache_valid = params.cache;
         // WARNING: isspecsig is protected by the codegen-lock. If that lock is removed, then the isspecsig load needs to be properly atomically sequenced with this.
-        if (cache_valid && invoke != NULL) {
+        if (cache_valid && invoke != NULL && invoke != &jl_fptr_wait_for_compiled) {
             auto fptr = jl_atomic_load_relaxed(&codeinst->specptr.fptr);
             if (fptr) {
                 while (!(jl_atomic_load_acquire(&codeinst->specsigflags) & 0b10)) {
@@ -9676,17 +9684,10 @@ void jl_compile_workqueue(
                 // method body. See #34993
                 if (policy != CompilationPolicy::Default &&
                     jl_atomic_load_relaxed(&codeinst->inferred) == jl_nothing) {
-                    src = jl_type_infer(codeinst->def, jl_atomic_load_acquire(&jl_world_counter), 0);
-                    if (src) {
-                        orc::ThreadSafeModule result_m =
-                        jl_create_ts_module(name_from_method_instance(codeinst->def),
-                            params.tsctx, params.DL, params.TargetTriple);
-                        auto decls = jl_emit_code(result_m, codeinst->def, src, src->rettype, params);
-                        if (result_m)
-                            it = params.compiled_functions.insert(std::make_pair(codeinst, std::make_pair(std::move(result_m), std::move(decls)))).first;
-                    }
+                    // Codegen lock is held, so SOURCE_MODE_FORCE_SOURCE_UNCACHED is not required
+                    codeinst = jl_type_infer(codeinst->def, jl_atomic_load_relaxed(&codeinst->max_world), 0, SOURCE_MODE_FORCE_SOURCE);
                 }
-                else {
+                if (codeinst) {
                     orc::ThreadSafeModule result_m =
                         jl_create_ts_module(name_from_method_instance(codeinst->def),
                             params.tsctx, params.DL, params.TargetTriple);
@@ -9719,7 +9720,7 @@ void jl_compile_workqueue(
                 jl_init_function(proto.decl, params.TargetTriple);
                 size_t nrealargs = jl_nparams(codeinst->def->specTypes); // number of actual arguments being passed
                 // TODO: maybe this can be cached in codeinst->specfptr?
-                emit_cfunc_invalidate(proto.decl, proto.cc, proto.return_roots, codeinst->def->specTypes, codeinst->rettype, false, nrealargs, params, preal);
+                emit_cfunc_invalidate(proto.decl, proto.cc, proto.return_roots, codeinst->def->specTypes, codeinst->rettype, false, nrealargs, params, preal, 0, 0);
                 preal_decl = ""; // no need to fixup the name
             }
             else {
diff --git a/src/gf.c b/src/gf.c
index fdf61f440908b..f6a9d82a4625d 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -135,7 +135,7 @@ static int speccache_eq(size_t idx, const void *ty, jl_value_t *data, uint_t hv)
 // get or create the MethodInstance for a specialization
 static jl_method_instance_t *jl_specializations_get_linfo_(jl_method_t *m JL_PROPAGATES_ROOT, jl_value_t *type, jl_svec_t *sparams, jl_method_instance_t *mi_insert)
 {
-    if (m->sig == (jl_value_t*)jl_anytuple_type && jl_atomic_load_relaxed(&m->unspecialized) != NULL && m != jl_opaque_closure_method)
+    if (m->sig == (jl_value_t*)jl_anytuple_type && jl_atomic_load_relaxed(&m->unspecialized) != NULL && m != jl_opaque_closure_method && !m->is_for_opaque_closure)
         return jl_atomic_load_relaxed(&m->unspecialized); // handle builtin methods
     jl_value_t *ut = jl_is_unionall(type) ? jl_unwrap_unionall(type) : type;
     JL_TYPECHK(specializations, datatype, ut);
@@ -336,7 +336,7 @@ jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_a
 // returns the inferred source, and may cache the result in mi
 // if successful, also updates the mi argument to describe the validity of this src
 // if inference doesn't occur (or can't finish), returns NULL instead
-jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
+jl_code_instance_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force, uint8_t source_mode)
 {
     if (jl_typeinf_func == NULL)
         return NULL;
@@ -350,16 +350,17 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
     if ((ct->reentrant_timing & 0b1111) >= 0b110)
         return NULL;
 
-    jl_code_info_t *src = NULL;
+    jl_code_instance_t *ci = NULL;
 #ifdef ENABLE_INFERENCE
     if (mi->inInference && !force)
         return NULL;
     JL_TIMING(INFERENCE, INFERENCE);
     jl_value_t **fargs;
-    JL_GC_PUSHARGS(fargs, 3);
+    JL_GC_PUSHARGS(fargs, 4);
     fargs[0] = (jl_value_t*)jl_typeinf_func;
     fargs[1] = (jl_value_t*)mi;
     fargs[2] = jl_box_ulong(world);
+    fargs[3] = jl_box_uint8(source_mode);
 
     jl_timing_show_method_instance(mi, JL_TIMING_DEFAULT_BLOCK);
 #ifdef TRACE_INFERENCE
@@ -387,7 +388,7 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
     // allocate another bit for the counter.
     ct->reentrant_timing += 0b10;
     JL_TRY {
-        src = (jl_code_info_t*)jl_apply(fargs, 3);
+        ci = (jl_code_instance_t*)jl_apply(fargs, 4);
     }
     JL_CATCH {
         jl_value_t *e = jl_current_exception();
@@ -404,7 +405,7 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
             jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
             jlbacktrace(); // written to STDERR_FILENO
         }
-        src = NULL;
+        ci = NULL;
 #ifndef JL_NDEBUG
         abort();
 #endif
@@ -418,13 +419,13 @@ jl_code_info_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int force)
 #endif
     errno = last_errno;
 
-    if (src && !jl_is_code_info(src)) {
-        src = NULL;
+    if (ci && !jl_is_code_instance(ci)) {
+        ci = NULL;
     }
     JL_GC_POP();
 #endif
 
-    return src;
+    return ci;
 }
 
 JL_DLLEXPORT jl_value_t *jl_call_in_typeinf_world(jl_value_t **args, int nargs)
@@ -437,38 +438,6 @@ JL_DLLEXPORT jl_value_t *jl_call_in_typeinf_world(jl_value_t **args, int nargs)
     return ret;
 }
 
-STATIC_INLINE jl_value_t *_jl_rettype_inferred(jl_value_t *owner, jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
-{
-    jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
-    while (codeinst) {
-        if (jl_atomic_load_relaxed(&codeinst->min_world) <= min_world &&
-            max_world <= jl_atomic_load_relaxed(&codeinst->max_world) &&
-            jl_egal(codeinst->owner, owner)) {
-            jl_value_t *inferred = jl_atomic_load_relaxed(&codeinst->inferred);
-            if (inferred && ((inferred == jl_nothing) || (
-                // allow whatever code instance external abstract interpreter produced
-                // since `jl_ir_flag_inferred` is specific to the native interpreter
-                codeinst->owner != jl_nothing || jl_ir_flag_inferred(inferred))))
-                return (jl_value_t*)codeinst;
-        }
-        codeinst = jl_atomic_load_relaxed(&codeinst->next);
-    }
-    return (jl_value_t*)jl_nothing;
-}
-
-JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_value_t *owner, jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
-{
-    return (jl_value_t*)_jl_rettype_inferred(owner, mi, min_world, max_world);
-}
-
-JL_DLLEXPORT jl_value_t *jl_rettype_inferred_native(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
-{
-    return (jl_value_t*)_jl_rettype_inferred(jl_nothing, mi, min_world, max_world);
-}
-
-JL_DLLEXPORT jl_value_t *(*const jl_rettype_inferred_addr)(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT = jl_rettype_inferred_native;
-
-
 JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
         jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_value_t *rettype,
         size_t min_world, size_t max_world)
@@ -491,16 +460,6 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
     return codeinst;
 }
 
-JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
-        jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_code_info_t *src)
-{
-    // TODO: copy backedges from src to mi
-    size_t max_world = src->max_world;
-    if (max_world >= jl_atomic_load_acquire(&jl_world_counter))
-        max_world = ~(size_t)0;
-    return jl_get_method_inferred(mi, src->rettype, src->min_world, max_world);
-}
-
 JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
         jl_method_instance_t *mi, jl_value_t *owner,
         jl_value_t *rettype, jl_value_t *exctype,
@@ -699,7 +658,7 @@ JL_DLLEXPORT void jl_set_typeinf_func(jl_value_t *f)
         for (i = 0, l = jl_array_nrows(unspec); i < l; i++) {
             jl_method_instance_t *mi = (jl_method_instance_t*)jl_array_ptr_ref(unspec, i);
             if (jl_rettype_inferred_native(mi, world, world) == jl_nothing)
-                jl_type_infer(mi, world, 1);
+                jl_type_infer(mi, world, 1, SOURCE_MODE_NOT_REQUIRED);
         }
         JL_GC_POP();
     }
@@ -2367,6 +2326,34 @@ jl_method_instance_t *jl_get_unspecialized(jl_method_t *def JL_PROPAGATES_ROOT)
     return unspec;
 }
 
+STATIC_INLINE jl_value_t *_jl_rettype_inferred(jl_value_t *owner, jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
+{
+    jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
+    while (codeinst) {
+        if (jl_atomic_load_relaxed(&codeinst->min_world) <= min_world &&
+            max_world <= jl_atomic_load_relaxed(&codeinst->max_world) &&
+            jl_egal(codeinst->owner, owner)) {
+
+            jl_value_t *code = jl_atomic_load_relaxed(&codeinst->inferred);
+            if (code)
+                return (jl_value_t*)codeinst;
+        }
+        codeinst = jl_atomic_load_relaxed(&codeinst->next);
+    }
+    return (jl_value_t*)jl_nothing;
+}
+
+JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_value_t *owner, jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
+{
+    return (jl_value_t*)_jl_rettype_inferred(owner, mi, min_world, max_world);
+}
+
+JL_DLLEXPORT jl_value_t *jl_rettype_inferred_native(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT
+{
+    return (jl_value_t*)_jl_rettype_inferred(jl_nothing, mi, min_world, max_world);
+}
+
+JL_DLLEXPORT jl_value_t *(*const jl_rettype_inferred_addr)(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT = jl_rettype_inferred_native;
 
 jl_code_instance_t *jl_method_compiled(jl_method_instance_t *mi, size_t world)
 {
@@ -2382,6 +2369,23 @@ jl_code_instance_t *jl_method_compiled(jl_method_instance_t *mi, size_t world)
     return NULL;
 }
 
+// Opportunistic SOURCE_MODE_ABI cache lookup.
+jl_code_instance_t *jl_method_inferred_with_abi(jl_method_instance_t *mi JL_PROPAGATES_ROOT, size_t world)
+{
+    jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
+    for (; codeinst; codeinst = jl_atomic_load_relaxed(&codeinst->next)) {
+        if (codeinst->owner != jl_nothing)
+            continue;
+
+        if (jl_atomic_load_relaxed(&codeinst->min_world) <= world && world <= jl_atomic_load_relaxed(&codeinst->max_world)) {
+            jl_value_t *code = jl_atomic_load_relaxed(&codeinst->inferred);
+            if (code && (code != jl_nothing || (jl_atomic_load_relaxed(&codeinst->invoke) != NULL)))
+                return codeinst;
+        }
+    }
+    return NULL;
+}
+
 jl_mutex_t precomp_statement_out_lock;
 
 static void record_precompile_statement(jl_method_instance_t *mi)
@@ -2530,7 +2534,44 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         }
     }
 
-    codeinst = jl_generate_fptr(mi, world);
+    // Ok, compilation is enabled. We'll need to try to compile something (probably).
+    // Try to find a codeinst we have already inferred (e.g. while we were compiling
+    // something else).
+    codeinst = jl_method_inferred_with_abi(mi, world);
+
+    // Everything from here on is considered (user facing) compile time
+    uint64_t start = jl_typeinf_timing_begin();
+    int is_recompile = jl_atomic_load_relaxed(&mi->cache) != NULL;
+
+    // This codeinst hasn't been previously inferred do that now
+    if (!codeinst) {
+        // Don't bother inferring toplevel thunks or macros - the performance cost of inference is likely
+        // to significantly exceed the actual runtime.
+        int should_skip_inference = !jl_is_method(mi->def.method) || jl_symbol_name(mi->def.method->name)[0] == '@';
+
+        if (!should_skip_inference) {
+            codeinst = jl_type_infer(mi, world, 0, SOURCE_MODE_ABI);
+        }
+    }
+
+    if (codeinst) {
+        if (jl_atomic_load_acquire(&codeinst->invoke) != NULL) {
+            jl_typeinf_timing_end(start, is_recompile);
+            // Already compiled - e.g. constabi, or compiled by a different thread while we were waiting.
+            return codeinst;
+        }
+
+        JL_GC_PUSH1(&codeinst);
+        jl_compile_codeinst(codeinst);
+
+        if (jl_atomic_load_relaxed(&codeinst->invoke) == NULL) {
+            // Something went wrong. Bail to the fallback path.
+            codeinst = NULL;
+        } else {
+            record_precompile_statement(mi);
+        }
+        JL_GC_POP();
+    }
     if (!codeinst) {
         jl_method_instance_t *unspec = jl_get_unspecialized_from_mi(mi);
         jl_code_instance_t *ucache = jl_get_method_inferred(unspec, (jl_value_t*)jl_any_type, 1, ~(size_t)0);
@@ -2548,6 +2589,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         if (ucache_invoke != jl_fptr_sparam &&
             ucache_invoke != jl_fptr_interpret_call) {
             // only these care about the exact specTypes, otherwise we can use it directly
+            jl_typeinf_timing_end(start, is_recompile);
             return ucache;
         }
         codeinst = jl_new_codeinst(mi, jl_nothing,
@@ -2568,10 +2610,8 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         jl_atomic_store_release(&codeinst->invoke, ucache_invoke);
         jl_mi_cache_insert(mi, codeinst);
     }
-    else {
-        record_precompile_statement(mi);
-    }
     jl_atomic_store_relaxed(&codeinst->precompile, 1);
+    jl_typeinf_timing_end(start, is_recompile);
     return codeinst;
 }
 
@@ -2803,7 +2843,7 @@ static void _generate_from_hint(jl_method_instance_t *mi, size_t world)
 {
     jl_value_t *codeinst = jl_rettype_inferred_native(mi, world, world);
     if (codeinst == jl_nothing) {
-        (void)jl_type_infer(mi, world, 1);
+        (void)jl_type_infer(mi, world, 1, SOURCE_MODE_NOT_REQUIRED);
         codeinst = jl_rettype_inferred_native(mi, world, world);
     }
     if (codeinst != jl_nothing) {
@@ -2844,10 +2884,10 @@ JL_DLLEXPORT void jl_compile_method_instance(jl_method_instance_t *mi, jl_tuplet
             JL_GC_POP();
             jl_atomic_store_relaxed(&mi2->precompiled, 1);
             if (jl_rettype_inferred_native(mi2, world, world) == jl_nothing)
-                (void)jl_type_infer(mi2, world, 1);
+                (void)jl_type_infer(mi2, world, 1, SOURCE_MODE_NOT_REQUIRED);
             if (jl_typeinf_func && jl_atomic_load_relaxed(&mi->def.method->primary_world) <= tworld) {
                 if (jl_rettype_inferred_native(mi2, tworld, tworld) == jl_nothing)
-                    (void)jl_type_infer(mi2, tworld, 1);
+                    (void)jl_type_infer(mi2, tworld, 1, SOURCE_MODE_NOT_REQUIRED);
             }
         }
     }
@@ -4010,7 +4050,7 @@ JL_DLLEXPORT uint64_t jl_typeinf_timing_begin(void)
     return jl_hrtime();
 }
 
-JL_DLLEXPORT void jl_typeinf_timing_end(uint64_t start)
+JL_DLLEXPORT void jl_typeinf_timing_end(uint64_t start, int is_recompile)
 {
     if (!start)
         return;
@@ -4019,6 +4059,9 @@ JL_DLLEXPORT void jl_typeinf_timing_end(uint64_t start)
     if (jl_atomic_load_relaxed(&jl_measure_compile_time_enabled)) {
         uint64_t inftime = jl_hrtime() - start;
         jl_atomic_fetch_add_relaxed(&jl_cumulative_compile_time, inftime);
+        if (is_recompile) {
+            jl_atomic_fetch_add_relaxed(&jl_cumulative_recompile_time, inftime);
+        }
     }
 }
 
diff --git a/src/interpreter.c b/src/interpreter.c
index 5102d1417c939..ffc8c6d8c12ea 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -696,7 +696,7 @@ jl_code_info_t *jl_code_for_interpreter(jl_method_instance_t *mi, size_t world)
         }
         if (src && (jl_value_t*)src != jl_nothing) {
             JL_GC_PUSH1(&src);
-            src = jl_uncompress_ir(mi->def.method, NULL, (jl_value_t*)src);
+            src = jl_uncompress_ir(mi->def.method, (jl_value_t*)src);
             jl_atomic_store_release(&mi->uninferred, (jl_value_t*)src);
             jl_gc_wb(mi, src);
             JL_GC_POP();
@@ -758,7 +758,7 @@ JL_DLLEXPORT const jl_callptr_t jl_fptr_interpret_call_addr = &jl_fptr_interpret
 jl_value_t *jl_interpret_opaque_closure(jl_opaque_closure_t *oc, jl_value_t **args, size_t nargs)
 {
     jl_method_t *source = oc->source;
-    jl_code_info_t *code = jl_uncompress_ir(source, NULL, (jl_value_t*)source->source);
+    jl_code_info_t *code = jl_uncompress_ir(source, (jl_value_t*)source->source);
     interpreter_state *s;
     unsigned nroots = jl_source_nslots(code) + jl_source_nssavalues(code) + 2;
     jl_task_t *ct = jl_current_task;
diff --git a/src/ircode.c b/src/ircode.c
index 09f039db76424..46d2fd82253de 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -457,11 +457,10 @@ static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal)
     }
 }
 
-static jl_code_info_flags_t code_info_flags(uint8_t inferred, uint8_t propagate_inbounds, uint8_t has_fcall,
+static jl_code_info_flags_t code_info_flags(uint8_t propagate_inbounds, uint8_t has_fcall,
                                             uint8_t nospecializeinfer, uint8_t inlining, uint8_t constprop)
 {
     jl_code_info_flags_t flags;
-    flags.bits.inferred = inferred;
     flags.bits.propagate_inbounds = propagate_inbounds;
     flags.bits.has_fcall = has_fcall;
     flags.bits.nospecializeinfer = nospecializeinfer;
@@ -824,7 +823,7 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
         1
     };
 
-    jl_code_info_flags_t flags = code_info_flags(code->inferred, code->propagate_inbounds, code->has_fcall,
+    jl_code_info_flags_t flags = code_info_flags(code->propagate_inbounds, code->has_fcall,
                                                  code->nospecializeinfer, code->inlining, code->constprop);
     write_uint8(s.s, flags.packed);
     static_assert(sizeof(flags.packed) == IR_DATASIZE_FLAGS, "ir_datasize_flags is mismatched with the actual size");
@@ -843,16 +842,12 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
     // by the various jl_ir_ accessors. Make sure to adjust those if you change
     // the data layout.
 
-    for (i = 0; i < 6; i++) {
+    for (i = 0; i < 5; i++) {
         int copy = 1;
         if (i == 1) { // skip codelocs
             assert(jl_field_offset(jl_code_info_type, i) == offsetof(jl_code_info_t, codelocs));
             continue;
         }
-        if (i == 4) { // don't copy contents of method_for_inference_limit_heuristics field
-            assert(jl_field_offset(jl_code_info_type, i) == offsetof(jl_code_info_t, method_for_inference_limit_heuristics));
-            copy = 0;
-        }
         jl_encode_value_(&s, jl_get_nth_field((jl_value_t*)code, i), copy);
     }
 
@@ -899,7 +894,7 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
     return v;
 }
 
-JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t *metadata, jl_string_t *data)
+JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_string_t *data)
 {
     if (jl_is_code_info(data))
         return (jl_code_info_t*)data;
@@ -925,7 +920,6 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
     flags.packed = read_uint8(s.s);
     code->inlining = flags.bits.inlining;
     code->constprop = flags.bits.constprop;
-    code->inferred = flags.bits.inferred;
     code->propagate_inbounds = flags.bits.propagate_inbounds;
     code->has_fcall = flags.bits.has_fcall;
     code->nospecializeinfer = flags.bits.nospecializeinfer;
@@ -936,7 +930,7 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
     code->slotflags = jl_alloc_array_1d(jl_array_uint8_type, nslots);
     ios_readall(s.s, jl_array_data(code->slotflags, char), nslots);
 
-    for (i = 0; i < 6; i++) {
+    for (i = 0; i < 5; i++) {
         if (i == 1)  // skip codelocs
             continue;
         assert(jl_field_isptr(jl_code_info_type, i));
@@ -975,27 +969,10 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
     jl_gc_enable(en);
     JL_UNLOCK(&m->writelock); // Might GC
     JL_GC_POP();
-    if (metadata) {
-        code->min_world = jl_atomic_load_relaxed(&metadata->min_world);
-        // n.b. this should perhaps be capped to jl_world_counter max here, since we don't have backedges on it after return
-        code->max_world = jl_atomic_load_relaxed(&metadata->max_world);
-        code->rettype = metadata->rettype;
-        code->parent = metadata->def;
-    }
 
     return code;
 }
 
-JL_DLLEXPORT uint8_t jl_ir_flag_inferred(jl_string_t *data)
-{
-    if (jl_is_code_info(data))
-        return ((jl_code_info_t*)data)->inferred;
-    assert(jl_is_string(data));
-    jl_code_info_flags_t flags;
-    flags.packed = jl_string_data(data)[ir_offset_flags];
-    return flags.bits.inferred;
-}
-
 JL_DLLEXPORT uint8_t jl_ir_flag_inlining(jl_string_t *data)
 {
     if (jl_is_code_info(data))
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index cb6267866eac1..3c2a6dd285af4 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -177,6 +177,8 @@ static orc::ThreadSafeModule jl_get_globals_module(orc::ThreadSafeContext &ctx,
     return GTSM;
 }
 
+extern jl_value_t *jl_fptr_wait_for_compiled(jl_value_t *f, jl_value_t **args, uint32_t nargs, jl_code_instance_t *m);
+
 // this generates llvm code for the lambda info
 // and adds the result to the jitlayers
 // (and the shadow module),
@@ -184,9 +186,7 @@ static orc::ThreadSafeModule jl_get_globals_module(orc::ThreadSafeContext &ctx,
 static jl_callptr_t _jl_compile_codeinst(
         jl_code_instance_t *codeinst,
         jl_code_info_t *src,
-        size_t world,
-        orc::ThreadSafeContext context,
-        bool is_recompile)
+        orc::ThreadSafeContext context)
 {
     // caller must hold codegen_lock
     // and have disabled finalizers
@@ -196,23 +196,12 @@ static jl_callptr_t _jl_compile_codeinst(
         start_time = jl_hrtime();
 
     assert(jl_is_code_instance(codeinst));
-#ifndef NDEBUG
-    size_t max_world = jl_atomic_load_relaxed(&codeinst->max_world);
-    assert(jl_atomic_load_relaxed(&codeinst->min_world) <= world && (max_world >= world || max_world == 0) &&
-        "invalid world for method-instance");
-#endif
 
     JL_TIMING(CODEINST_COMPILE, CODEINST_COMPILE);
-#ifdef USE_TRACY
-    if (is_recompile) {
-        TracyCZoneColor(JL_TIMING_DEFAULT_BLOCK->tracy_ctx, 0xFFA500);
-    }
-#endif
     jl_callptr_t fptr = NULL;
     // emit the code in LLVM IR form
     jl_codegen_params_t params(std::move(context), jl_ExecutionEngine->getDataLayout(), jl_ExecutionEngine->getTargetTriple()); // Locks the context
     params.cache = true;
-    params.world = world;
     params.imaging_mode = imaging_default();
     params.debug_level = jl_options.debug_level;
     {
@@ -324,10 +313,13 @@ static jl_callptr_t _jl_compile_codeinst(
             }
         } else {
             jl_callptr_t prev_invoke = NULL;
+            // Allow replacing addr if it is either NULL or our special waiting placeholder.
             if (!jl_atomic_cmpswap_acqrel(&this_code->invoke, &prev_invoke, addr)) {
-                addr = prev_invoke;
-                //TODO do we want to potentially promote invoke anyways? (e.g. invoke is jl_interpret_call or some other
-                //known lesser function)
+                if (prev_invoke == &jl_fptr_wait_for_compiled && !jl_atomic_cmpswap_acqrel(&this_code->invoke, &prev_invoke, addr)) {
+                    addr = prev_invoke;
+                    //TODO do we want to potentially promote invoke anyways? (e.g. invoke is jl_interpret_call or some other
+                    //known lesser function)
+                }
             }
         }
         if (this_code == codeinst)
@@ -468,92 +460,18 @@ void jl_extern_c_impl(jl_value_t *declrt, jl_tupletype_t *sigt)
         jl_error("@ccallable was already defined for this method name");
 }
 
-// this compiles li and emits fptr
-extern "C" JL_DLLEXPORT_CODEGEN
-jl_code_instance_t *jl_generate_fptr_impl(jl_method_instance_t *mi JL_PROPAGATES_ROOT, size_t world)
-{
-    auto ct = jl_current_task;
-    bool timed = (ct->reentrant_timing & 1) == 0;
-    if (timed)
-        ct->reentrant_timing |= 1;
-    uint64_t compiler_start_time = 0;
-    uint8_t measure_compile_time_enabled = jl_atomic_load_relaxed(&jl_measure_compile_time_enabled);
-    bool is_recompile = false;
-    if (measure_compile_time_enabled)
-        compiler_start_time = jl_hrtime();
-    // if we don't have any decls already, try to generate it now
-    jl_code_info_t *src = NULL;
-    jl_code_instance_t *codeinst = NULL;
-    JL_GC_PUSH2(&src, &codeinst);
-    JL_LOCK(&jl_codegen_lock); // also disables finalizers, to prevent any unexpected recursion
-    jl_value_t *ci = jl_rettype_inferred_addr(mi, world, world);
-    if (ci != jl_nothing)
-        codeinst = (jl_code_instance_t*)ci;
-    if (codeinst) {
-        src = (jl_code_info_t*)jl_atomic_load_relaxed(&codeinst->inferred);
-        if ((jl_value_t*)src == jl_nothing)
-            src = NULL;
-        else if (jl_is_method(mi->def.method))
-            src = jl_uncompress_ir(mi->def.method, codeinst, (jl_value_t*)src);
-    }
-    else {
-        // identify whether this is an invalidated method that is being recompiled
-        is_recompile = jl_atomic_load_relaxed(&mi->cache) != NULL;
-    }
-    if (src == NULL && jl_is_method(mi->def.method) &&
-             jl_symbol_name(mi->def.method->name)[0] != '@') {
-        if (mi->def.method->source != jl_nothing) {
-            // If the caller didn't provide the source and IR is available,
-            // see if it is inferred, or try to infer it for ourself.
-            // (but don't bother with typeinf on macros or toplevel thunks)
-            src = jl_type_infer(mi, world, 0);
-            codeinst = nullptr;
-        }
-    }
-    jl_code_instance_t *compiled = jl_method_compiled(mi, world);
-    if (compiled) {
-        codeinst = compiled;
-    }
-    else if (src && jl_is_code_info(src)) {
-        if (!codeinst) {
-            codeinst = jl_get_codeinst_for_src(mi, src);
-            if (src->inferred) {
-                jl_value_t *null = nullptr;
-                jl_atomic_cmpswap_relaxed(&codeinst->inferred, &null, jl_nothing);
-            }
-        }
-        ++SpecFPtrCount;
-        _jl_compile_codeinst(codeinst, src, world, *jl_ExecutionEngine->getContext(), is_recompile);
-        if (jl_atomic_load_relaxed(&codeinst->invoke) == NULL)
-            codeinst = NULL;
-    }
-    else {
-        codeinst = NULL;
-    }
-    JL_UNLOCK(&jl_codegen_lock);
-    if (timed) {
-        if (measure_compile_time_enabled) {
-            uint64_t t_comp = jl_hrtime() - compiler_start_time;
-            if (is_recompile) {
-                jl_atomic_fetch_add_relaxed(&jl_cumulative_recompile_time, t_comp);
-            }
-            jl_atomic_fetch_add_relaxed(&jl_cumulative_compile_time, t_comp);
-        }
-        ct->reentrant_timing &= ~1ull;
-    }
-    JL_GC_POP();
-    return codeinst;
-}
-
 extern "C" JL_DLLEXPORT_CODEGEN
-void jl_generate_fptr_for_oc_wrapper_impl(jl_code_instance_t *oc_wrap)
+void jl_compile_codeinst_impl(jl_code_instance_t *ci)
 {
-    if (jl_atomic_load_relaxed(&oc_wrap->invoke) != NULL) {
+    if (jl_atomic_load_relaxed(&ci->invoke) != NULL) {
         return;
     }
     JL_LOCK(&jl_codegen_lock);
-    if (jl_atomic_load_relaxed(&oc_wrap->invoke) == NULL) {
-        _jl_compile_codeinst(oc_wrap, NULL, 1, *jl_ExecutionEngine->getContext(), 0);
+    if (jl_atomic_load_relaxed(&ci->invoke) == NULL) {
+        ++SpecFPtrCount;
+        uint64_t start = jl_typeinf_timing_begin();
+        _jl_compile_codeinst(ci, NULL, *jl_ExecutionEngine->getContext());
+        jl_typeinf_timing_end(start, 0);
     }
     JL_UNLOCK(&jl_codegen_lock); // Might GC
 }
@@ -580,7 +498,7 @@ void jl_generate_fptr_for_unspecialized_impl(jl_code_instance_t *unspec)
         if (jl_is_method(def)) {
             src = (jl_code_info_t*)def->source;
             if (src && (jl_value_t*)src != jl_nothing)
-                src = jl_uncompress_ir(def, NULL, (jl_value_t*)src);
+                src = jl_uncompress_ir(def, (jl_value_t*)src);
         }
         else {
             src = (jl_code_info_t*)jl_atomic_load_relaxed(&unspec->def->uninferred);
@@ -589,7 +507,7 @@ void jl_generate_fptr_for_unspecialized_impl(jl_code_instance_t *unspec)
         if (src) {
             assert(jl_is_code_info(src));
             ++UnspecFPtrCount;
-            _jl_compile_codeinst(unspec, src, jl_atomic_load_relaxed(&unspec->min_world), *jl_ExecutionEngine->getContext(), 0);
+            _jl_compile_codeinst(unspec, src, *jl_ExecutionEngine->getContext());
         }
         jl_callptr_t null = nullptr;
         // if we hit a codegen bug (or ran into a broken generated function or llvmcall), fall back to the interpreter as a last resort
@@ -613,7 +531,7 @@ jl_value_t *jl_dump_method_asm_impl(jl_method_instance_t *mi, size_t world,
         char emit_mc, char getwrapper, const char* asm_variant, const char *debuginfo, char binary)
 {
     // printing via disassembly
-    jl_code_instance_t *codeinst = jl_generate_fptr(mi, world);
+    jl_code_instance_t *codeinst = jl_compile_method_internal(mi, world);
     if (codeinst) {
         uintptr_t fptr = (uintptr_t)jl_atomic_load_acquire(&codeinst->invoke);
         if (getwrapper)
@@ -634,25 +552,14 @@ jl_value_t *jl_dump_method_asm_impl(jl_method_instance_t *mi, size_t world,
             JL_LOCK(&jl_codegen_lock); // also disables finalizers, to prevent any unexpected recursion
             specfptr = (uintptr_t)jl_atomic_load_relaxed(&codeinst->specptr.fptr);
             if (specfptr == 0) {
-                jl_code_info_t *src = jl_type_infer(mi, world, 0);
-                JL_GC_PUSH1(&src);
-                jl_method_t *def = mi->def.method;
-                if (jl_is_method(def)) {
-                    if (!src) {
-                        // TODO: jl_code_for_staged can throw
-                        src = def->generator ? jl_code_for_staged(mi, world) : (jl_code_info_t*)def->source;
-                    }
-                    if (src && (jl_value_t*)src != jl_nothing)
-                        src = jl_uncompress_ir(mi->def.method, codeinst, (jl_value_t*)src);
-                }
-                fptr = (uintptr_t)jl_atomic_load_acquire(&codeinst->invoke);
-                specfptr = (uintptr_t)jl_atomic_load_relaxed(&codeinst->specptr.fptr);
-                if (src && jl_is_code_info(src)) {
-                    if (fptr == (uintptr_t)jl_fptr_const_return_addr && specfptr == 0) {
-                        fptr = (uintptr_t)_jl_compile_codeinst(codeinst, src, world, *jl_ExecutionEngine->getContext(), 0);
-                        (void)fptr; // silence unused variable warning
-                        specfptr = (uintptr_t)jl_atomic_load_relaxed(&codeinst->specptr.fptr);
-                    }
+                // Doesn't need SOURCE_MODE_FORCE_SOURCE_UNCACHED, because the codegen lock is held,
+                // so there's no concern that the ->inferred field will be deleted.
+                jl_code_instance_t *forced_ci = jl_type_infer(mi, world, 0, SOURCE_MODE_FORCE_SOURCE);
+                JL_GC_PUSH1(&forced_ci);
+                if (forced_ci) {
+                    // Force compile of this codeinst even though it already has an ->invoke
+                    _jl_compile_codeinst(forced_ci, NULL, *jl_ExecutionEngine->getContext());
+                    specfptr = (uintptr_t)jl_atomic_load_relaxed(&forced_ci->specptr.fptr);
                 }
                 JL_GC_POP();
             }
@@ -1978,6 +1885,7 @@ uint64_t JuliaOJIT::getFunctionAddress(StringRef Name)
 StringRef JuliaOJIT::getFunctionAtAddress(uint64_t Addr, jl_code_instance_t *codeinst)
 {
     std::lock_guard<std::mutex> lock(RLST_mutex);
+    assert(Addr != (uint64_t)&jl_fptr_wait_for_compiled);
     std::string *fname = &ReverseLocalSymbolTable[(void*)(uintptr_t)Addr];
     if (fname->empty()) {
         std::string string_fname;
diff --git a/src/jitlayers.h b/src/jitlayers.h
index 3da4c28af6601..931f0070042ac 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -247,7 +247,6 @@ struct jl_codegen_params_t {
     std::unique_ptr<Module> _shared_module;
     inline Module &shared_module();
     // inputs
-    size_t world = 0;
     const jl_cgparams_t *params = &jl_default_cgparams;
     bool cache = false;
     bool external_linkage = false;
@@ -263,7 +262,8 @@ jl_llvm_functions_t jl_emit_code(
         jl_method_instance_t *mi,
         jl_code_info_t *src,
         jl_value_t *jlrettype,
-        jl_codegen_params_t &params);
+        jl_codegen_params_t &params,
+        size_t min_world, size_t max_world);
 
 jl_llvm_functions_t jl_emit_codeinst(
         orc::ThreadSafeModule &M,
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 91f989f611b22..6463d30cbeae9 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -266,7 +266,6 @@
     XX(jl_ios_buffer_n) \
     XX(jl_ios_fd) \
     XX(jl_ios_get_nbyte_int) \
-    XX(jl_ir_flag_inferred) \
     XX(jl_ir_flag_has_fcall) \
     XX(jl_ir_flag_inlining) \
     XX(jl_ir_inlining_cost) \
@@ -533,9 +532,8 @@
     YY(jl_init_codegen) \
     YY(jl_getFunctionInfo) \
     YY(jl_register_fptrs) \
-    YY(jl_generate_fptr) \
     YY(jl_generate_fptr_for_unspecialized) \
-    YY(jl_generate_fptr_for_oc_wrapper) \
+    YY(jl_compile_codeinst) \
     YY(jl_compile_extern_c) \
     YY(jl_teardown_codegen) \
     YY(jl_jit_total_bytes) \
diff --git a/src/jltypes.c b/src/jltypes.c
index 9dac534259f73..0ecf00651438a 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3142,22 +3142,19 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_code_info_type =
         jl_new_datatype(jl_symbol("CodeInfo"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(22,
+                        jl_perm_symsvec(19,
                             "code",
                             "codelocs",
                             "ssavaluetypes",
                             "ssaflags",
-                            "method_for_inference_limit_heuristics",
                             "linetable",
                             "slotnames",
                             "slotflags",
                             "slottypes",
-                            "rettype",
-                            "parent",
+                            "method_for_inference_limit_heuristics",
                             "edges",
                             "min_world",
                             "max_world",
-                            "inferred",
                             "propagate_inbounds",
                             "has_fcall",
                             "nospecializeinfer",
@@ -3165,31 +3162,28 @@ void jl_init_types(void) JL_GC_DISABLED
                             "constprop",
                             "purity",
                             "inlining_cost"),
-                        jl_svec(22,
+                        jl_svec(19,
                             jl_array_any_type,
                             jl_array_int32_type,
                             jl_any_type,
                             jl_array_uint32_type,
                             jl_any_type,
-                            jl_any_type,
                             jl_array_symbol_type,
                             jl_array_uint8_type,
                             jl_any_type,
                             jl_any_type,
                             jl_any_type,
-                            jl_any_type,
                             jl_ulong_type,
                             jl_ulong_type,
                             jl_bool_type,
                             jl_bool_type,
                             jl_bool_type,
-                            jl_bool_type,
                             jl_uint8_type,
                             jl_uint8_type,
                             jl_uint16_type,
                             jl_uint16_type),
                         jl_emptysvec,
-                        0, 1, 22);
+                        0, 1, 19);
 
     jl_method_type =
         jl_new_datatype(jl_symbol("Method"), core,
diff --git a/src/julia.h b/src/julia.h
index 852b671f744f6..de5146aed7065 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -289,19 +289,21 @@ typedef struct _jl_code_info_t {
         // 1 << 11 = :inaccessiblemem_or_argmemonly
         // 1 << 12-19 = callsite effects overrides
     // miscellaneous data:
-    jl_value_t *method_for_inference_limit_heuristics; // optional method used during inference
     jl_value_t *linetable; // Table of locations [TODO: make this volatile like slotnames]
     jl_array_t *slotnames; // names of local variables
     jl_array_t *slotflags;  // local var bit flags
     // the following are optional transient properties (not preserved by compression--as they typically get stored elsewhere):
     jl_value_t *slottypes; // inferred types of slots
-    jl_value_t *rettype;
-    jl_method_instance_t *parent; // context (optionally, if available, otherwise nothing)
+
+    // These may be used by generated functions to further constrain the resulting inputs.
+    // They are not used by any other part of the system and may be moved elsewhere in the
+    // future.
+    jl_value_t *method_for_inference_limit_heuristics; // optional method used during inference
     jl_value_t *edges; // forward edges to method instances that must be invalidated
     size_t min_world;
     size_t max_world;
+
     // various boolean properties:
-    uint8_t inferred;
     uint8_t propagate_inbounds;
     uint8_t has_fcall;
     uint8_t nospecializeinfer;
@@ -422,7 +424,13 @@ typedef struct _jl_code_instance_t {
     jl_value_t *rettype; // return type for fptr
     jl_value_t *exctype; // thrown type for fptr
     jl_value_t *rettype_const; // inferred constant return value, or null
-    _Atomic(jl_value_t *) inferred; // inferred jl_code_info_t (may be compressed), or jl_nothing, or null
+
+    // Inferred result. When part of the runtime cache, either
+    // - A jl_code_info_t (may be compressed) containing the inferred IR
+    // - jl_nothing, indicating that inference was completed, but the result was
+    //               deleted to save space.
+    // - null, indicating that inference was not yet completed or did not succeed
+    _Atomic(jl_value_t *) inferred;
     //TODO: jl_array_t *edges; // stored information about edges from this object
     //TODO: uint8_t absolute_max; // whether true max world is unknown
 
@@ -2126,8 +2134,7 @@ JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr JL_MAYBE_UNROOTED);
 
 // IR representation
 JL_DLLEXPORT jl_value_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code);
-JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t *metadata, jl_value_t *data);
-JL_DLLEXPORT uint8_t jl_ir_flag_inferred(jl_value_t *data) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_value_t *data);
 JL_DLLEXPORT uint8_t jl_ir_flag_inlining(jl_value_t *data) JL_NOTSAFEPOINT;
 JL_DLLEXPORT uint8_t jl_ir_flag_has_fcall(jl_value_t *data) JL_NOTSAFEPOINT;
 JL_DLLEXPORT uint16_t jl_ir_inlining_cost(jl_value_t *data) JL_NOTSAFEPOINT;
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 14b8b4f43ee92..bb2e664d2fdcc 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -269,6 +269,9 @@ static inline uint64_t cycleclock(void) JL_NOTSAFEPOINT
 
 #include "timing.h"
 
+extern JL_DLLEXPORT uint64_t jl_typeinf_timing_begin(void) JL_NOTSAFEPOINT;
+extern JL_DLLEXPORT void jl_typeinf_timing_end(uint64_t start, int is_recompile) JL_NOTSAFEPOINT;
+
 // Global *atomic* integers controlling *process-wide* measurement of compilation time.
 extern JL_DLLEXPORT _Atomic(uint8_t) jl_measure_compile_time_enabled;
 extern JL_DLLEXPORT _Atomic(uint64_t) jl_cumulative_compile_time;
@@ -643,7 +646,6 @@ STATIC_INLINE jl_value_t *undefref_check(jl_datatype_t *dt, jl_value_t *v) JL_NO
 // -- helper types -- //
 
 typedef struct {
-    uint8_t inferred:1;
     uint8_t propagate_inbounds:1;
     uint8_t has_fcall:1;
     uint8_t nospecializeinfer:1;
@@ -658,13 +660,17 @@ typedef union {
 
 // -- functions -- //
 
-JL_DLLEXPORT jl_code_info_t *jl_type_infer(jl_method_instance_t *li, size_t world, int force);
+// Also defined in typeinfer.jl - See documentation there.
+#define SOURCE_MODE_NOT_REQUIRED            0x0
+#define SOURCE_MODE_ABI                     0x1
+#define SOURCE_MODE_FORCE_SOURCE            0x2
+#define SOURCE_MODE_FORCE_SOURCE_UNCACHED   0x3
+
+JL_DLLEXPORT jl_code_instance_t *jl_type_infer(jl_method_instance_t *li, size_t world, int force, uint8_t source_mode);
 JL_DLLEXPORT jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *meth JL_PROPAGATES_ROOT, size_t world);
 JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
         jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_value_t *rettype,
         size_t min_world, size_t max_world);
-JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
-        jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_code_info_t *src);
 jl_method_instance_t *jl_get_unspecialized_from_mi(jl_method_instance_t *method JL_PROPAGATES_ROOT);
 jl_method_instance_t *jl_get_unspecialized(jl_method_t *def JL_PROPAGATES_ROOT);
 
@@ -846,6 +852,8 @@ JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val, int insert) JL_GLOBA
 
 jl_opaque_closure_t *jl_new_opaque_closure(jl_tupletype_t *argt, jl_value_t *rt_lb, jl_value_t *rt_ub,
     jl_value_t *source,  jl_value_t **env, size_t nenv, int do_compile);
+jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name,
+    int nargs, jl_value_t *functionloc, jl_value_t *uninferred_source, int isva);
 JL_DLLEXPORT int jl_is_valid_oc_argtype(jl_tupletype_t *argt, jl_method_t *source);
 
 // Each tuple can exist in one of 4 Vararg states:
@@ -1023,7 +1031,9 @@ JL_DLLEXPORT jl_methtable_t *jl_new_method_table(jl_sym_t *name, jl_module_t *mo
 JL_DLLEXPORT jl_method_instance_t *jl_get_specialization1(jl_tupletype_t *types, size_t world, size_t *min_valid, size_t *max_valid, int mt_cache);
 jl_method_instance_t *jl_get_specialized(jl_method_t *m, jl_value_t *types, jl_svec_t *sp);
 JL_DLLEXPORT jl_value_t *jl_rettype_inferred(jl_value_t *owner, jl_method_instance_t *li JL_PROPAGATES_ROOT, size_t min_world, size_t max_world);
+JL_DLLEXPORT jl_value_t *jl_rettype_inferred_native(jl_method_instance_t *mi, size_t min_world, size_t max_world) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_code_instance_t *jl_method_compiled(jl_method_instance_t *mi JL_PROPAGATES_ROOT, size_t world) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_code_instance_t *jl_method_inferred_with_abi(jl_method_instance_t *mi JL_PROPAGATES_ROOT, size_t world) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_methtable_lookup(jl_methtable_t *mt JL_PROPAGATES_ROOT, jl_value_t *type, size_t world);
 JL_DLLEXPORT jl_method_instance_t *jl_specializations_get_linfo(
     jl_method_t *m JL_PROPAGATES_ROOT, jl_value_t *type, jl_svec_t *sparams);
@@ -1724,9 +1734,8 @@ JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len);
 
 #define IR_FLAG_INBOUNDS 0x01
 
-JL_DLLIMPORT jl_code_instance_t *jl_generate_fptr(jl_method_instance_t *mi JL_PROPAGATES_ROOT, size_t world);
 JL_DLLIMPORT void jl_generate_fptr_for_unspecialized(jl_code_instance_t *unspec);
-JL_DLLIMPORT void jl_generate_fptr_for_oc_wrapper(jl_code_instance_t *unspec);
+JL_DLLIMPORT void jl_compile_codeinst(jl_code_instance_t *unspec);
 JL_DLLIMPORT int jl_compile_extern_c(LLVMOrcThreadSafeModuleRef llvmmod, void *params, void *sysimg, jl_value_t *declrt, jl_value_t *sigt);
 
 typedef struct {
diff --git a/src/method.c b/src/method.c
index 88d43fb4b22ee..15d2fd673e047 100644
--- a/src/method.c
+++ b/src/method.c
@@ -20,9 +20,6 @@ extern jl_value_t *jl_builtin_tuple;
 jl_methtable_t *jl_kwcall_mt;
 jl_method_t *jl_opaque_closure_method;
 
-jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name,
-    int nargs, jl_value_t *functionloc, jl_code_info_t *ci, int isva);
-
 static void check_c_types(const char *where, jl_value_t *rt, jl_value_t *at)
 {
     if (jl_is_svec(rt))
@@ -124,7 +121,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                 } else if (!jl_is_long(oc_nargs)) {
                     jl_type_error("opaque_closure_method", (jl_value_t*)jl_long_type, oc_nargs);
                 }
-                jl_method_t *m = jl_make_opaque_closure_method(module, name, jl_unbox_long(oc_nargs), functionloc, (jl_code_info_t*)ci, isva);
+                jl_method_t *m = jl_make_opaque_closure_method(module, name, jl_unbox_long(oc_nargs), functionloc, ci, isva);
                 return (jl_value_t*)m;
             }
             if (e->head == jl_cfunction_sym) {
@@ -510,15 +507,12 @@ JL_DLLEXPORT jl_code_info_t *jl_new_code_info_uninit(void)
     src->slotflags = NULL;
     src->slotnames = NULL;
     src->slottypes = jl_nothing;
-    src->parent = (jl_method_instance_t*)jl_nothing;
-    src->rettype = (jl_value_t*)jl_any_type;
     src->min_world = 1;
     src->max_world = ~(size_t)0;
-    src->inferred = 0;
+    src->edges = jl_nothing;
     src->propagate_inbounds = 0;
     src->has_fcall = 0;
     src->nospecializeinfer = 0;
-    src->edges = jl_nothing;
     src->constprop = 0;
     src->inlining = 0;
     src->purity.bits = 0;
@@ -909,7 +903,7 @@ void push_edge(jl_array_t *list, jl_value_t *invokesig, jl_method_instance_t *ca
 // method definition ----------------------------------------------------------
 
 jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name,
-    int nargs, jl_value_t *functionloc, jl_code_info_t *ci, int isva)
+    int nargs, jl_value_t *functionloc, jl_value_t *uninferred_source, int isva)
 {
     jl_method_t *m = jl_new_method_uninit(module);
     JL_GC_PUSH1(&m);
@@ -928,7 +922,8 @@ jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name
     jl_value_t *file = jl_linenode_file(functionloc);
     m->file = jl_is_symbol(file) ? (jl_sym_t*)file : jl_empty_sym;
     m->line = jl_linenode_line(functionloc);
-    jl_method_set_source(m, ci);
+    if (jl_is_code_info(uninferred_source))
+        jl_method_set_source(m, (jl_code_info_t*)uninferred_source);
     JL_GC_POP();
     return m;
 }
diff --git a/src/opaque_closure.c b/src/opaque_closure.c
index 45b08fee668db..2c70a053eb970 100644
--- a/src/opaque_closure.c
+++ b/src/opaque_closure.c
@@ -107,7 +107,7 @@ static jl_opaque_closure_t *new_opaque_closure(jl_tupletype_t *argt, jl_value_t
         // OC wrapper methods are not world dependent
         ci = jl_get_method_inferred(mi_generic, selected_rt, 1, ~(size_t)0);
         if (!jl_atomic_load_acquire(&ci->invoke))
-            jl_generate_fptr_for_oc_wrapper(ci);
+            jl_compile_codeinst(ci);
         specptr = jl_atomic_load_relaxed(&ci->specptr.fptr);
     }
     jl_opaque_closure_t *oc = (jl_opaque_closure_t*)jl_gc_alloc(ct->ptls, sizeof(jl_opaque_closure_t), oc_type);
@@ -131,31 +131,28 @@ jl_opaque_closure_t *jl_new_opaque_closure(jl_tupletype_t *argt, jl_value_t *rt_
     return oc;
 }
 
-jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name,
-    int nargs, jl_value_t *functionloc, jl_code_info_t *ci, int isva);
-
 JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tupletype_t *argt, jl_value_t *rt_lb, jl_value_t *rt_ub,
-    jl_module_t *mod, jl_code_info_t *ci, int lineno, jl_value_t *file, int nargs, int isva, jl_value_t *env, int do_compile)
+    jl_module_t *mod, jl_code_info_t *ci, int lineno, jl_value_t *file, int nargs, int isva, jl_value_t *env, int do_compile, int isinferred)
 {
-    if (!ci->inferred)
-        jl_error("CodeInfo must already be inferred");
     jl_value_t *root = NULL, *sigtype = NULL;
     jl_code_instance_t *inst = NULL;
     JL_GC_PUSH3(&root, &sigtype, &inst);
     root = jl_box_long(lineno);
     root = jl_new_struct(jl_linenumbernode_type, root, file);
-    jl_method_t *meth = jl_make_opaque_closure_method(mod, jl_nothing, nargs, root, ci, isva);
+    jl_method_t *meth = jl_make_opaque_closure_method(mod, jl_nothing, nargs, root, isinferred ? jl_nothing : (jl_value_t*)ci, isva);
     root = (jl_value_t*)meth;
     size_t world = jl_current_task->world_age;
     // these are only legal in the current world since they are not in any tables
     jl_atomic_store_release(&meth->primary_world, world);
     jl_atomic_store_release(&meth->deleted_world, world);
 
-    sigtype = jl_argtype_with_function(env, (jl_value_t*)argt);
-    jl_method_instance_t *mi = jl_specializations_get_linfo((jl_method_t*)root, sigtype, jl_emptysvec);
-    inst = jl_new_codeinst(mi, jl_nothing, rt_ub, (jl_value_t*)jl_any_type, NULL, (jl_value_t*)ci,
-        0, world, world, 0, 0, jl_nothing, 0);
-    jl_mi_cache_insert(mi, inst);
+    if (isinferred) {
+        sigtype = jl_argtype_with_function(env, (jl_value_t*)argt);
+        jl_method_instance_t *mi = jl_specializations_get_linfo((jl_method_t*)root, sigtype, jl_emptysvec);
+        inst = jl_new_codeinst(mi, jl_nothing, rt_ub, (jl_value_t*)jl_any_type, NULL, (jl_value_t*)ci,
+            0, world, world, 0, 0, jl_nothing, 0);
+        jl_mi_cache_insert(mi, inst);
+    }
 
     jl_opaque_closure_t *oc = new_opaque_closure(argt, rt_lb, rt_ub, root, env, do_compile);
     JL_GC_POP();
diff --git a/src/precompile_utils.c b/src/precompile_utils.c
index 35dc0e2f59493..af9d93d612249 100644
--- a/src/precompile_utils.c
+++ b/src/precompile_utils.c
@@ -189,7 +189,6 @@ static int precompile_enq_specialization_(jl_method_instance_t *mi, void *closur
             jl_value_t *inferred = jl_atomic_load_relaxed(&codeinst->inferred);
             if (inferred &&
                 inferred != jl_nothing &&
-                jl_ir_flag_inferred(inferred) &&
                 (jl_ir_inlining_cost(inferred) == UINT16_MAX)) {
                 do_compile = 1;
             }
diff --git a/src/staticdata.c b/src/staticdata.c
index 62c0b27cb8eab..5172eb80c8b4a 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -2351,7 +2351,7 @@ static jl_value_t *strip_codeinfo_meta(jl_method_t *m, jl_value_t *ci_, int orig
     int compressed = 0;
     if (!jl_is_code_info(ci_)) {
         compressed = 1;
-        ci = jl_uncompress_ir(m, NULL, (jl_value_t*)ci_);
+        ci = jl_uncompress_ir(m, (jl_value_t*)ci_);
     }
     else {
         ci = (jl_code_info_t*)ci_;
diff --git a/src/toplevel.c b/src/toplevel.c
index e4438da991e1e..8f67a0e1aa3e7 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -929,7 +929,7 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
         size_t world = jl_atomic_load_acquire(&jl_world_counter);
         ct->world_age = world;
         if (!has_defs && jl_get_module_infer(m) != 0) {
-            (void)jl_type_infer(mfunc, world, 0);
+            (void)jl_type_infer(mfunc, world, 0, SOURCE_MODE_NOT_REQUIRED);
         }
         result = jl_invoke(/*func*/NULL, /*args*/NULL, /*nargs*/0, mfunc);
         ct->world_age = last_age;
@@ -1010,10 +1010,10 @@ JL_DLLEXPORT jl_value_t *jl_infer_thunk(jl_code_info_t *thk, jl_module_t *m)
     JL_GC_PUSH1(&li);
     jl_resolve_globals_in_ir((jl_array_t*)thk->code, m, NULL, 0);
     jl_task_t *ct = jl_current_task;
-    jl_code_info_t *src = jl_type_infer(li, ct->world_age, 0);
+    jl_code_instance_t *ci = jl_type_infer(li, ct->world_age, 0, SOURCE_MODE_NOT_REQUIRED);
     JL_GC_POP();
-    if (src)
-        return src->rettype;
+    if (ci)
+        return ci->rettype;
     return (jl_value_t*)jl_any_type;
 }
 
diff --git a/stdlib/InteractiveUtils/src/codeview.jl b/stdlib/InteractiveUtils/src/codeview.jl
index 877e023bc28ed..d03e2b27a2286 100644
--- a/stdlib/InteractiveUtils/src/codeview.jl
+++ b/stdlib/InteractiveUtils/src/codeview.jl
@@ -54,6 +54,75 @@ function is_expected_union(u::Union)
     return true
 end
 
+function print_warntype_codeinfo(io::IO, src::Core.CodeInfo, @nospecialize(rettype), nargs::Int; lineprinter)
+    if src.slotnames !== nothing
+        slotnames = Base.sourceinfo_slotnames(src)
+        io = IOContext(io, :SOURCE_SLOTNAMES => slotnames)
+        slottypes = src.slottypes
+        nargs > 0 && println(io, "Arguments")
+        for i = 1:length(slotnames)
+            if i == nargs + 1
+                println(io, "Locals")
+            end
+            print(io, "  ", slotnames[i])
+            if isa(slottypes, Vector{Any})
+                warntype_type_printer(io; type=slottypes[i], used=true)
+            end
+            println(io)
+        end
+    end
+    print(io, "Body")
+    warntype_type_printer(io; type=rettype, used=true)
+    println(io)
+    irshow_config = Base.IRShow.IRShowConfig(lineprinter(src), warntype_type_printer)
+    Base.IRShow.show_ir(io, src, irshow_config)
+    println(io)
+end
+
+function print_warntype_mi(io::IO, mi::Core.MethodInstance)
+    println(io, mi)
+    print(io, "  from ")
+    println(io, mi.def)
+    if !isempty(mi.sparam_vals)
+        println(io, "Static Parameters")
+        sig = mi.def.sig
+        warn_color = Base.warn_color() # more mild user notification
+        for i = 1:length(mi.sparam_vals)
+            sig = sig::UnionAll
+            name = sig.var.name
+            val = mi.sparam_vals[i]
+            print_highlighted(io::IO, v::String, color::Symbol) =
+                if highlighting[:warntype]
+                    Base.printstyled(io, v; color)
+                else
+                    Base.print(io, v)
+                end
+            if val isa TypeVar
+                if val.lb === Union{}
+                    print(io, "  ", name, " <: ")
+                    print_highlighted(io, "$(val.ub)", warn_color)
+                elseif val.ub === Any
+                    print(io, "  ", sig.var.name, " >: ")
+                    print_highlighted(io, "$(val.lb)", warn_color)
+                else
+                    print(io, "  ")
+                    print_highlighted(io, "$(val.lb)", warn_color)
+                    print(io, " <: ", sig.var.name, " <: ")
+                    print_highlighted(io, "$(val.ub)", warn_color)
+                end
+            elseif val isa typeof(Vararg)
+                print(io, "  ", name, "::")
+                print_highlighted(io, "Int", warn_color)
+            else
+                print(io, "  ", sig.var.name, " = ")
+                print_highlighted(io, "$(val)", :cyan) # show the "good" type
+            end
+            println(io)
+            sig = sig.body
+        end
+    end
+end
+
 """
     code_warntype([io::IO], f, types; debuginfo=:default)
 
@@ -75,84 +144,27 @@ See the [`@code_warntype`](@ref man-code-warntype) section in the Performance Ti
 See also: [`@code_warntype`](@ref), [`code_typed`](@ref), [`code_lowered`](@ref), [`code_llvm`](@ref), [`code_native`](@ref).
 """
 function code_warntype(io::IO, @nospecialize(f), @nospecialize(t=Base.default_tt(f));
+                       world=Base.get_world_counter(),
+                       interp::Core.Compiler.AbstractInterpreter=Core.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")
     debuginfo = Base.IRShow.debuginfo(debuginfo)
     lineprinter = Base.IRShow.__debuginfo[debuginfo]
-    for (src, rettype) in code_typed(f, t; optimize, kwargs...)
-        if !(src isa Core.CodeInfo)
-            println(io, src)
-            println(io, "  failed to infer")
-            continue
-        end
-        lambda_io::IOContext = io
-        p = src.parent
-        nargs::Int = 0
-        if p isa Core.MethodInstance
-            println(io, p)
-            print(io, "  from ")
-            println(io, p.def)
-            p.def isa Method && (nargs = p.def.nargs)
-            if !isempty(p.sparam_vals)
-                println(io, "Static Parameters")
-                sig = p.def.sig
-                warn_color = Base.warn_color() # more mild user notification
-                for i = 1:length(p.sparam_vals)
-                    sig = sig::UnionAll
-                    name = sig.var.name
-                    val = p.sparam_vals[i]
-                    print_highlighted(io::IO, v::String, color::Symbol) =
-                        if highlighting[:warntype]
-                            Base.printstyled(io, v; color)
-                        else
-                            Base.print(io, v)
-                        end
-                    if val isa TypeVar
-                        if val.lb === Union{}
-                            print(io, "  ", name, " <: ")
-                            print_highlighted(io, "$(val.ub)", warn_color)
-                        elseif val.ub === Any
-                            print(io, "  ", sig.var.name, " >: ")
-                            print_highlighted(io, "$(val.lb)", warn_color)
-                        else
-                            print(io, "  ")
-                            print_highlighted(io, "$(val.lb)", warn_color)
-                            print(io, " <: ", sig.var.name, " <: ")
-                            print_highlighted(io, "$(val.ub)", warn_color)
-                        end
-                    elseif val isa typeof(Vararg)
-                        print(io, "  ", name, "::")
-                        print_highlighted(io, "Int", warn_color)
-                    else
-                        print(io, "  ", sig.var.name, " = ")
-                        print_highlighted(io, "$(val)", :cyan) # show the "good" type
-                    end
-                    println(io)
-                    sig = sig.body
-                end
-            end
-        end
-        if src.slotnames !== nothing
-            slotnames = Base.sourceinfo_slotnames(src)
-            lambda_io = IOContext(lambda_io, :SOURCE_SLOTNAMES => slotnames)
-            slottypes = src.slottypes
-            nargs > 0 && println(io, "Arguments")
-            for i = 1:length(slotnames)
-                if i == nargs + 1
-                    println(io, "Locals")
-                end
-                print(io, "  ", slotnames[i])
-                if isa(slottypes, Vector{Any})
-                    warntype_type_printer(io; type=slottypes[i], used=true)
-                end
-                println(io)
-            end
-        end
-        print(io, "Body")
-        warntype_type_printer(io; type=rettype, used=true)
-        println(io)
-        irshow_config = Base.IRShow.IRShowConfig(lineprinter(src), warntype_type_printer)
-        Base.IRShow.show_ir(lambda_io, src, irshow_config)
-        println(io)
+    nargs::Int = 0
+    if isa(f, Core.OpaqueClosure)
+        isa(f.source, Method) && (nargs = f.nargs)
+        print_warntype_codeinfo(io, Base.code_typed_opaque_closure(f)[1]..., nargs; lineprinter)
+        return nothing
+    end
+    matches = Base._methods_by_ftype(Base.signature_type(f, t), #=lim=#-1, world)::Vector
+    for match in matches
+        match = match::Core.MethodMatch
+        (src, rettype) = Core.Compiler.typeinf_code(interp, match, optimize)
+        mi = Core.Compiler.specialize_method(match)
+        mi.def isa Method && (nargs = (mi.def::Method).nargs)
+        print_warntype_mi(io, mi)
+        print_warntype_codeinfo(io, src, rettype, nargs; lineprinter)
     end
     nothing
 end
@@ -188,7 +200,7 @@ function _dump_function(@nospecialize(f), @nospecialize(t), native::Bool, wrappe
     else
         world = UInt64(f.world)
         tt = Base.to_tuple_type(t)
-        if Core.Compiler.is_source_inferred(f.source.source)
+        if !isdefined(f.source, :source)
             # OC was constructed from inferred source. There's only one
             # specialization and we can't infer anything more precise either.
             world = f.source.primary_world
diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index 346b111c785f7..4b69e4c1f615d 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -347,9 +347,9 @@ _true = true
 # and show that we can still work around it
 @noinline g_broken_code() = _true ? 0 : h_broken_code()
 @noinline h_broken_code() = (g_broken_code(); f_broken_code())
-let err = tempname(),
+let errf = tempname(),
     old_stderr = stderr,
-    new_stderr = open(err, "w")
+    new_stderr = open(errf, "w")
     try
         redirect_stderr(new_stderr)
         println(new_stderr, "start")
@@ -362,7 +362,7 @@ let err = tempname(),
     finally
         redirect_stderr(old_stderr)
         close(new_stderr)
-        let errstr = read(err, String)
+        let errstr = read(errf, String)
             @test startswith(errstr, """start
                 end
                 Internal error: encountered unexpected error during compilation of f_broken_code:
@@ -370,7 +370,7 @@ let err = tempname(),
                 """) || errstr
             @test !endswith(errstr, "\nend\n") || errstr
         end
-        rm(err)
+        rm(errf)
     end
 end
 end
@@ -378,9 +378,11 @@ end
 # Issue #33163
 A33163(x; y) = x + y
 B33163(x) = x
-@test (@code_typed A33163(1, y=2))[1].inferred
-@test !(@code_typed optimize=false A33163(1, y=2))[1].inferred
-@test !(@code_typed optimize=false B33163(1))[1].inferred
+let
+    (@code_typed A33163(1, y=2))[1]
+    (@code_typed optimize=false A33163(1, y=2))[1]
+    (@code_typed optimize=false B33163(1))[1]
+end
 
 @test_throws MethodError (@code_lowered wrongkeyword=true 3 + 4)
 
@@ -414,10 +416,11 @@ a14637 = A14637(0)
 @test (@code_typed max.(1 .+ 3, 5 - 7))[2] == Int
 f36261(x,y) = 3x + 4y
 A36261 = Float64[1.0, 2.0, 3.0]
-@test (@code_typed f36261.(A36261, pi))[1].inferred
-@test (@code_typed f36261.(A36261, 1 .+ pi))[1].inferred
-@test (@code_typed f36261.(A36261, 1 + pi))[1].inferred
-
+let
+    @code_typed f36261.(A36261, pi)[1]
+    @code_typed f36261.(A36261, 1 .+ pi)[1]
+    @code_typed f36261.(A36261, 1 + pi)[1]
+end
 
 module ReflectionTest
 using Test, Random, InteractiveUtils
@@ -643,7 +646,8 @@ end
 # macro options should accept both literals and variables
 let
     opt = false
-    @test !(first(@code_typed optimize=opt sum(1:10)).inferred)
+    @test length(first(@code_typed optimize=opt sum(1:10)).code) ==
+        length((@code_lowered sum(1:10)).code)
 end
 
 @testset "@time_imports" begin
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index b03936afd5c03..9e83fbe38f490 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -80,7 +80,7 @@ const TAGS = Any[
 const NTAGS = length(TAGS)
 @assert NTAGS == 255
 
-const ser_version = 26 # do not make changes without bumping the version #!
+const ser_version = 27 # do not make changes without bumping the version #!
 
 format_version(::AbstractSerializer) = ser_version
 format_version(s::Serializer) = s.version
@@ -1201,26 +1201,37 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
     if pre_12
         ci.slotflags = deserialize(s)
     else
-        ci.method_for_inference_limit_heuristics = deserialize(s)
+        if format_version(s) <= 26
+            ci.method_for_inference_limit_heuristics = deserialize(s)
+        end
         ci.linetable = deserialize(s)
     end
     ci.slotnames = deserialize(s)
     if !pre_12
         ci.slotflags = deserialize(s)
         ci.slottypes = deserialize(s)
-        ci.rettype = deserialize(s)
-        ci.parent = deserialize(s)
-        world_or_edges = deserialize(s)
-        pre_13 = isa(world_or_edges, Integer)
-        if pre_13
-            ci.min_world = world_or_edges
+        if format_version(s) <= 26
+            deserialize(s) # rettype
+            deserialize(s) # parent
+            world_or_edges = deserialize(s)
+            pre_13 = isa(world_or_edges, Integer)
+            if pre_13
+                ci.min_world = world_or_edges
+            else
+                ci.edges = world_or_edges
+                ci.min_world = reinterpret(UInt, deserialize(s))
+                ci.max_world = reinterpret(UInt, deserialize(s))
+            end
         else
-            ci.edges = world_or_edges
+            ci.method_for_inference_limit_heuristics = deserialize(s)
+            ci.edges = deserialize(s)
             ci.min_world = reinterpret(UInt, deserialize(s))
             ci.max_world = reinterpret(UInt, deserialize(s))
         end
     end
-    ci.inferred = deserialize(s)
+    if format_version(s) <= 26
+        deserialize(s) # inferred
+    end
     if format_version(s) < 22
         inlining_cost = deserialize(s)
         if isa(inlining_cost, Bool)
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 2068997c77c82..6518d7fbe3d30 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -437,7 +437,7 @@ function custom_lookup(mi::MethodInstance, min_world::UInt, max_world::UInt)
     for inf_result in CONST_INVOKE_INTERP.inf_cache
         if inf_result.linfo === mi
             if CC.any(inf_result.overridden_by_const)
-                return CodeInstance(CONST_INVOKE_INTERP, inf_result, inf_result.valid_worlds)
+                return CodeInstance(CONST_INVOKE_INTERP, inf_result)
             end
         end
     end
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 65729ab01cb9f..d6d65faaaf7bb 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -680,7 +680,6 @@ end
 function test_inferred_static(arrow::Pair, all_ssa)
     code, rt = arrow
     @test isdispatchelem(rt)
-    @test code.inferred
     for i = 1:length(code.code)
         e = code.code[i]
         test_inferred_static(e)
@@ -1703,7 +1702,6 @@ let linfo = get_linfo(Base.convert, Tuple{Type{Int64}, Int32}),
     @test opt.src !== linfo.def.source
     @test length(opt.src.slotflags) == linfo.def.nargs <= length(opt.src.slotnames)
     @test opt.src.ssavaluetypes isa Vector{Any}
-    @test !opt.src.inferred
     @test opt.mod === Base
 end
 
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 99918a1c91c64..3e48d91ba880d 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -630,8 +630,8 @@ g41299(f::Tf, args::Vararg{Any,N}) where {Tf,N} = f(args...)
 # idempotency of callsite inlining
 function getcache(mi::Core.MethodInstance)
     cache = Core.Compiler.code_cache(Core.Compiler.NativeInterpreter())
-    codeinf = Core.Compiler.get(cache, mi, nothing)
-    return isnothing(codeinf) ? nothing : codeinf
+    codeinst = Core.Compiler.get(cache, mi, nothing)
+    return isnothing(codeinst) ? nothing : codeinst
 end
 @noinline f42078(a) = sum(sincos(a))
 let
@@ -649,8 +649,8 @@ let
     end
     let # make sure to discard the inferred source
         mi = only(methods(f42078)).specializations::Core.MethodInstance
-        codeinf = getcache(mi)::Core.CodeInstance
-        @atomic codeinf.inferred = nothing
+        codeinst = getcache(mi)::Core.CodeInstance
+        @atomic codeinst.inferred = nothing
     end
 
     let # inference should re-infer `f42078(::Int)` and we should get the same code
diff --git a/test/compiler/interpreter_exec.jl b/test/compiler/interpreter_exec.jl
index 31f3f510cf4a2..b3aca0cfe2903 100644
--- a/test/compiler/interpreter_exec.jl
+++ b/test/compiler/interpreter_exec.jl
@@ -23,15 +23,9 @@ let m = Meta.@lower 1 + 1
     src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
     src.codelocs = fill(Int32(1), nstmts)
-    @test !src.inferred
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
     @test :a === @eval $m
-    compile_mode = @ccall jl_get_module_compile(@__MODULE__()::Module)::Cint
-    if compile_mode == 3
-        # implies `Base.Experimental.@compiler_options compile=min`
-        @test !src.inferred
-    end
     global test29262 = false
     @test :b === @eval $m
 end
@@ -69,16 +63,11 @@ let m = Meta.@lower 1 + 1
     src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
     src.codelocs = fill(Int32(1), nstmts)
-    @test !src.inferred
+    m.args[1] = copy(src)
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
     @test (:b, :a, :c, :c) === @eval $m
-    compile_mode = @ccall jl_get_module_compile(@__MODULE__()::Module)::Cint
-    if compile_mode == 3
-        # implies `Base.Experimental.@compiler_options compile=min`
-        @test !src.inferred
-    end
-    src.ssavaluetypes = nstmts
+    m.args[1] = copy(src)
     global test29262 = false
     @test (:b, :a, :c, :b) === @eval $m
 end
@@ -112,15 +101,9 @@ let m = Meta.@lower 1 + 1
     src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
     src.codelocs = fill(Int32(1), nstmts)
-    @test !src.inferred
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
     @test :a === @eval $m
-    compile_mode = @ccall jl_get_module_compile(@__MODULE__()::Module)::Cint
-    if compile_mode == 3
-        # implies `Base.Experimental.@compiler_options compile=min`
-        @test !src.inferred
-    end
     global test29262 = false
     @test :b === @eval $m
 end
diff --git a/test/copy.jl b/test/copy.jl
index 633beee5f2af3..11cfbb9f14d76 100644
--- a/test/copy.jl
+++ b/test/copy.jl
@@ -213,11 +213,13 @@ end
 @testset "copying CodeInfo" begin
     _testfunc() = nothing
     ci,_ = code_typed(_testfunc, ())[1]
-    ci.edges = [_testfunc]
+    if isdefined(ci, :edges)
+        ci.edges = [_testfunc]
 
-    ci2 = copy(ci)
-    # Test that edges are not shared
-    @test ci2.edges !== ci.edges
+        ci2 = copy(ci)
+        # Test that edges are not shared
+        @test ci2.edges !== ci.edges
+    end
 end
 
 @testset "issue #34025" begin
diff --git a/test/opaque_closure.jl b/test/opaque_closure.jl
index 856253ecd5a8d..e9f1601019a59 100644
--- a/test/opaque_closure.jl
+++ b/test/opaque_closure.jl
@@ -189,8 +189,6 @@ let ci = @code_lowered const_int()
         cig.slotnames = Symbol[Symbol("#self#")]
         cig.slottypes = Any[Any]
         cig.slotflags = UInt8[0x00]
-        @assert cig.min_world == UInt(1)
-        @assert cig.max_world == typemax(UInt)
         return cig
     end
 end
@@ -246,8 +244,8 @@ end
 
 # constructing an opaque closure from IRCode
 let src = first(only(code_typed(+, (Int, Int))))
-    ir = Core.Compiler.inflate_ir(src)
-    @test OpaqueClosure(src)(40, 2) == 42
+    ir = Core.Compiler.inflate_ir(src, Core.Compiler.VarState[], src.slottypes)
+    @test OpaqueClosure(src; sig=Tuple{Int, Int}, rettype=Int, nargs=2)(40, 2) == 42
     oc = OpaqueClosure(ir)
     @test oc(40, 2) == 42
     @test isa(oc, OpaqueClosure{Tuple{Int,Int}, Int})
@@ -266,11 +264,11 @@ end
 let src = code_typed((Int,Int)) do x, y...
         return (x, y)
     end |> only |> first
-    let oc = OpaqueClosure(src)
+    let oc = OpaqueClosure(src; rettype=Tuple{Int, Tuple{Int}}, sig=Tuple{Int, Int}, nargs=2, isva=true)
         @test oc(1,2) === (1,(2,))
         @test_throws MethodError oc(1,2,3)
     end
-    ir = Core.Compiler.inflate_ir(src)
+    ir = Core.Compiler.inflate_ir(src, Core.Compiler.VarState[], src.slottypes)
     let oc = OpaqueClosure(ir; isva=true)
         @test oc(1,2) === (1,(2,))
         @test_throws MethodError oc(1,2,3)
diff --git a/test/worlds.jl b/test/worlds.jl
index ecd76549e9e29..292628b8cbed3 100644
--- a/test/worlds.jl
+++ b/test/worlds.jl
@@ -264,8 +264,7 @@ function equal(ci1::Core.CodeInfo, ci2::Core.CodeInfo)
            ci1.linetable == ci2.linetable &&
            ci1.slotnames == ci2.slotnames &&
            ci1.slotflags == ci2.slotflags &&
-           ci1.slottypes == ci2.slottypes &&
-           ci1.rettype == ci2.rettype
+           ci1.slottypes == ci2.slottypes
 end
 equal(p1::Pair, p2::Pair) = p1.second == p2.second && equal(p1.first, p2.first)
 

From 59102aa21e1b37cd116f12553876937dd080dcb1 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Sun, 18 Feb 2024 21:07:49 -0500
Subject: [PATCH 0971/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=206dd0e7c9e=20to=2076070d295=20(#53357)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 6dd0e7c9e
New commit: 76070d295
Julia version: 1.12.0-DEV
Pkg version: 1.11.0(Does not match)
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/6dd0e7c9e99d578aa5477e2c78c91a161ce4c357...76070d295fc4a1f27f852e05400bbc956962e084

```
$ git log --oneline 6dd0e7c9e..76070d295
76070d295 Prevent repl crash on invalid command (#3800)
d267986c2 RFC: stop testing non-ARM on mac on CI (#3794)
2571be6d1 CI: Add Apple Silicon (macOS aarch64) to the CI matrix (#3793)
3075fb78c Simplify Pkg.Registry APIs. (#3785)
e6f1e0902 Explain about Manifest.toml per julia version (#3791)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5     | 1 -
 .../Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512  | 1 -
 .../Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5     | 1 +
 .../Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512

diff --git a/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5 b/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5
deleted file mode 100644
index 0bd59e0f13bab..0000000000000
--- a/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-fcf25a83bfb9c68eb34ecf50612ef2e5
diff --git a/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512 b/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512
deleted file mode 100644
index 03fc867f28070..0000000000000
--- a/deps/checksums/Pkg-6dd0e7c9e99d578aa5477e2c78c91a161ce4c357.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-25fa3274513292c5e28502a8d9ffbf193ba44e32550e10dfcb880b7544780270ad155ef64d4346f9d10b8068fb8feb271c16a76aa93a99ede7f16ad5caafca38
diff --git a/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5 b/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5
new file mode 100644
index 0000000000000..279472ca7aa3d
--- /dev/null
+++ b/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5
@@ -0,0 +1 @@
+777fe3e3dd5b6c7c1b436d3077d91c13
diff --git a/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512 b/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512
new file mode 100644
index 0000000000000..5e26fbd8577fa
--- /dev/null
+++ b/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512
@@ -0,0 +1 @@
+b832093b4e387460a1d96526169e12c6ee2ff5a8bd1961c362dbcf4f4839790f3a0bdcf1d0e1524b77eea662cc7590483fc7e4e674f94f5e7f291970778ab128
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 52524cb88083c..048b652a0a272 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 6dd0e7c9e99d578aa5477e2c78c91a161ce4c357
+PKG_SHA1 = 76070d295fc4a1f27f852e05400bbc956962e084
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 9c0f1dc1e426008250415d5dd7aa155e9df1a75e Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Mon, 19 Feb 2024 13:11:08 +0100
Subject: [PATCH 0972/1315] add being able to pass a `CacheFlags()` to
 `isprecompiled` to verify a precompile file against a set of custom flags
 (#53332)

---
 base/loading.jl           | 268 ++++++++++++++++++++------------------
 src/jl_exported_funcs.inc |   1 +
 src/staticdata.c          |   2 +-
 src/staticdata_utils.c    |  26 ++--
 test/precompile.jl        |  13 +-
 5 files changed, 168 insertions(+), 142 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 8bcaa4b2ab5b3..f4db43d80640b 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1495,6 +1495,126 @@ end
 
 # End extensions
 
+
+struct CacheFlags
+    # OOICCDDP - see jl_cache_flags
+    use_pkgimages::Bool
+    debug_level::Int
+    check_bounds::Int
+    inline::Bool
+    opt_level::Int
+end
+function CacheFlags(f::UInt8)
+    use_pkgimages = Bool(f & 1)
+    debug_level = Int((f >> 1) & 3)
+    check_bounds = Int((f >> 3) & 3)
+    inline = Bool((f >> 5) & 1)
+    opt_level = Int((f >> 6) & 3) # define OPT_LEVEL in statiddata_utils
+    CacheFlags(use_pkgimages, debug_level, check_bounds, inline, opt_level)
+end
+CacheFlags(f::Int) = CacheFlags(UInt8(f))
+CacheFlags() = CacheFlags(ccall(:jl_cache_flags, UInt8, ()))
+
+function _cacheflag_to_uint8(cf::CacheFlags)::UInt8
+    f = UInt8(0)
+    f |= cf.use_pkgimages << 0
+    f |= cf.debug_level << 1
+    f |= cf.check_bounds << 3
+    f |= cf.inline << 5
+    f |= cf.opt_level << 6
+    return f
+end
+
+function show(io::IO, cf::CacheFlags)
+    print(io, "use_pkgimages = ", cf.use_pkgimages)
+    print(io, ", debug_level = ", cf.debug_level)
+    print(io, ", check_bounds = ", cf.check_bounds)
+    print(io, ", inline = ", cf.inline)
+    print(io, ", opt_level = ", cf.opt_level)
+end
+
+struct ImageTarget
+    name::String
+    flags::Int32
+    ext_features::String
+    features_en::Vector{UInt8}
+    features_dis::Vector{UInt8}
+end
+
+function parse_image_target(io::IO)
+    flags = read(io, Int32)
+    nfeature = read(io, Int32)
+    feature_en = read(io, 4*nfeature)
+    feature_dis = read(io, 4*nfeature)
+    name_len = read(io, Int32)
+    name = String(read(io, name_len))
+    ext_features_len = read(io, Int32)
+    ext_features = String(read(io, ext_features_len))
+    ImageTarget(name, flags, ext_features, feature_en, feature_dis)
+end
+
+function parse_image_targets(targets::Vector{UInt8})
+    io = IOBuffer(targets)
+    ntargets = read(io, Int32)
+    targets = Vector{ImageTarget}(undef, ntargets)
+    for i in 1:ntargets
+        targets[i] = parse_image_target(io)
+    end
+    return targets
+end
+
+function current_image_targets()
+    targets = @ccall jl_reflect_clone_targets()::Vector{UInt8}
+    return parse_image_targets(targets)
+end
+
+struct FeatureName
+    name::Cstring
+    bit::UInt32 # bit index into a `uint32_t` array;
+    llvmver::UInt32 # 0 if it is available on the oldest LLVM version we support
+end
+
+function feature_names()
+    fnames = Ref{Ptr{FeatureName}}()
+    nf = Ref{Csize_t}()
+    @ccall jl_reflect_feature_names(fnames::Ptr{Ptr{FeatureName}}, nf::Ptr{Csize_t})::Cvoid
+    if fnames[] == C_NULL
+        @assert nf[] == 0
+        return Vector{FeatureName}(undef, 0)
+    end
+    Base.unsafe_wrap(Array, fnames[], nf[], own=false)
+end
+
+function test_feature(features::Vector{UInt8}, feat::FeatureName)
+    bitidx = feat.bit
+    u8idx = div(bitidx, 8) + 1
+    bit = bitidx % 8
+    return (features[u8idx] & (1 << bit)) != 0
+end
+
+function show(io::IO, it::ImageTarget)
+    print(io, it.name)
+    if !isempty(it.ext_features)
+        print(io, ",", it.ext_features)
+    end
+    print(io, "; flags=", it.flags)
+    print(io, "; features_en=(")
+    first = true
+    for feat in feature_names()
+        if test_feature(it.features_en, feat)
+            name = Base.unsafe_string(feat.name)
+            if first
+                first = false
+                print(io, name)
+            else
+                print(io, ", ", name)
+            end
+        end
+    end
+    print(io, ")")
+    # Is feature_dis useful?
+end
+
 # should sync with the types of arguments of `stale_cachefile`
 const StaleCacheKey = Tuple{Base.PkgId, UInt128, String, String}
 
@@ -1515,11 +1635,11 @@ function isprecompiled(pkg::PkgId;
         ignore_loaded::Bool=false,
         stale_cache::Dict{StaleCacheKey,Bool}=Dict{StaleCacheKey, Bool}(),
         cachepaths::Vector{String}=Base.find_all_in_cache_path(pkg),
-        sourcepath::Union{String,Nothing}=Base.locate_package(pkg)
-    )
+        sourcepath::Union{String,Nothing}=Base.locate_package(pkg),
+        flags::CacheFlags=CacheFlags())
     isnothing(sourcepath) && error("Cannot locate source for $(repr(pkg))")
     for path_to_try in cachepaths
-        staledeps = stale_cachefile(sourcepath, path_to_try, ignore_loaded = true)
+        staledeps = stale_cachefile(sourcepath, path_to_try, ignore_loaded = true, requested_flags=flags)
         if staledeps === true
             continue
         end
@@ -1532,7 +1652,7 @@ function isprecompiled(pkg::PkgId;
             modpaths = find_all_in_cache_path(modkey)
             for modpath_to_try in modpaths::Vector{String}
                 stale_cache_key = (modkey, modbuild_id, modpath, modpath_to_try)::StaleCacheKey
-                if get!(() -> stale_cachefile(stale_cache_key...; ignore_loaded) === true,
+                if get!(() -> stale_cachefile(stale_cache_key...; ignore_loaded, requested_flags=flags) === true,
                         stale_cache, stale_cache_key)
                     continue
                 end
@@ -2535,8 +2655,7 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     if output_o !== nothing
         @debug "Generating object cache file for $(repr("text/plain", pkg))"
         cpu_target = get(ENV, "JULIA_CPU_TARGET", nothing)
-        opt_level = Base.JLOptions().opt_level
-        opts = `-O$(opt_level) --output-o $(output_o) --output-ji $(output) --output-incremental=yes`
+        opts = `--output-o $(output_o) --output-ji $(output) --output-incremental=yes`
     else
         @debug "Generating cache file for $(repr("text/plain", pkg))"
         cpu_target = nothing
@@ -2546,10 +2665,11 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     deps_eltype = sprint(show, eltype(concrete_deps); context = :module=>nothing)
     deps = deps_eltype * "[" * join(deps_strs, ",") * "]"
     trace = isassigned(PRECOMPILE_TRACE_COMPILE) ? `--trace-compile=$(PRECOMPILE_TRACE_COMPILE[])` : ``
-    io = open(pipeline(addenv(`$(julia_cmd(;cpu_target)::Cmd) $(opts)
+    io = open(pipeline(addenv(`$(julia_cmd(;cpu_target)::Cmd)
+                             $(flags)
+                             $(opts)
                               --startup-file=no --history-file=no --warn-overwrite=yes
                               --color=$(have_color === nothing ? "auto" : have_color ? "yes" : "no")
-                              $flags
                               $trace
                               -`,
                               "OPENBLAS_NUM_THREADS" => 1,
@@ -3212,116 +3332,6 @@ function check_clone_targets(clone_targets)
     end
 end
 
-struct CacheFlags
-    # OOICCDDP - see jl_cache_flags
-    use_pkgimages::Bool
-    debug_level::Int
-    check_bounds::Int
-    inline::Bool
-    opt_level::Int
-
-    function CacheFlags(f::UInt8)
-        use_pkgimages = Bool(f & 1)
-        debug_level = Int((f >> 1) & 3)
-        check_bounds = Int((f >> 3) & 3)
-        inline = Bool((f >> 5) & 1)
-        opt_level = Int((f >> 6) & 3) # define OPT_LEVEL in statiddata_utils
-        new(use_pkgimages, debug_level, check_bounds, inline, opt_level)
-    end
-end
-CacheFlags(f::Int) = CacheFlags(UInt8(f))
-CacheFlags() = CacheFlags(ccall(:jl_cache_flags, UInt8, ()))
-
-function show(io::IO, cf::CacheFlags)
-    print(io, "use_pkgimages = ", cf.use_pkgimages)
-    print(io, ", debug_level = ", cf.debug_level)
-    print(io, ", check_bounds = ", cf.check_bounds)
-    print(io, ", inline = ", cf.inline)
-    print(io, ", opt_level = ", cf.opt_level)
-end
-
-struct ImageTarget
-    name::String
-    flags::Int32
-    ext_features::String
-    features_en::Vector{UInt8}
-    features_dis::Vector{UInt8}
-end
-
-function parse_image_target(io::IO)
-    flags = read(io, Int32)
-    nfeature = read(io, Int32)
-    feature_en = read(io, 4*nfeature)
-    feature_dis = read(io, 4*nfeature)
-    name_len = read(io, Int32)
-    name = String(read(io, name_len))
-    ext_features_len = read(io, Int32)
-    ext_features = String(read(io, ext_features_len))
-    ImageTarget(name, flags, ext_features, feature_en, feature_dis)
-end
-
-function parse_image_targets(targets::Vector{UInt8})
-    io = IOBuffer(targets)
-    ntargets = read(io, Int32)
-    targets = Vector{ImageTarget}(undef, ntargets)
-    for i in 1:ntargets
-        targets[i] = parse_image_target(io)
-    end
-    return targets
-end
-
-function current_image_targets()
-    targets = @ccall jl_reflect_clone_targets()::Vector{UInt8}
-    return parse_image_targets(targets)
-end
-
-struct FeatureName
-    name::Cstring
-    bit::UInt32 # bit index into a `uint32_t` array;
-    llvmver::UInt32 # 0 if it is available on the oldest LLVM version we support
-end
-
-function feature_names()
-    fnames = Ref{Ptr{FeatureName}}()
-    nf = Ref{Csize_t}()
-    @ccall jl_reflect_feature_names(fnames::Ptr{Ptr{FeatureName}}, nf::Ptr{Csize_t})::Cvoid
-    if fnames[] == C_NULL
-        @assert nf[] == 0
-        return Vector{FeatureName}(undef, 0)
-    end
-    Base.unsafe_wrap(Array, fnames[], nf[], own=false)
-end
-
-function test_feature(features::Vector{UInt8}, feat::FeatureName)
-    bitidx = feat.bit
-    u8idx = div(bitidx, 8) + 1
-    bit = bitidx % 8
-    return (features[u8idx] & (1 << bit)) != 0
-end
-
-function show(io::IO, it::ImageTarget)
-    print(io, it.name)
-    if !isempty(it.ext_features)
-        print(io, ",", it.ext_features)
-    end
-    print(io, "; flags=", it.flags)
-    print(io, "; features_en=(")
-    first = true
-    for feat in feature_names()
-        if test_feature(it.features_en, feat)
-            name = Base.unsafe_string(feat.name)
-            if first
-                first = false
-                print(io, name)
-            else
-                print(io, ", ", name)
-            end
-        end
-    end
-    print(io, ")")
-    # Is feature_dis useful?
-end
-
 # Set by FileWatching.__init__()
 global mkpidlock_hook
 global trymkpidlock_hook
@@ -3377,11 +3387,11 @@ list_reasons(::Nothing) = ""
 
 # returns true if it "cachefile.ji" is stale relative to "modpath.jl" and build_id for modkey
 # otherwise returns the list of dependencies to also check
-@constprop :none function stale_cachefile(modpath::String, cachefile::String; ignore_loaded::Bool = false, reasons=nothing)
-    return stale_cachefile(PkgId(""), UInt128(0), modpath, cachefile; ignore_loaded, reasons)
+@constprop :none function stale_cachefile(modpath::String, cachefile::String; ignore_loaded::Bool = false, requested_flags::CacheFlags=CacheFlags(), reasons=nothing)
+    return stale_cachefile(PkgId(""), UInt128(0), modpath, cachefile; ignore_loaded, requested_flags, reasons)
 end
 @constprop :none function stale_cachefile(modkey::PkgId, build_id::UInt128, modpath::String, cachefile::String;
-                                            ignore_loaded::Bool = false, reasons::Union{Dict{String,Int},Nothing}=nothing)
+                                            ignore_loaded::Bool = false, requested_flags::CacheFlags=CacheFlags(), reasons::Union{Dict{String,Int},Nothing}=nothing)
     io = open(cachefile, "r")
     try
         checksum = isvalid_cache_header(io)
@@ -3390,15 +3400,15 @@ end
             record_reason(reasons, "invalid header")
             return true # invalid cache file
         end
-        modules, (includes, _, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags = parse_cache_header(io, cachefile)
+        modules, (includes, _, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, actual_flags = parse_cache_header(io, cachefile)
         if isempty(modules)
             return true # ignore empty file
         end
-        if ccall(:jl_match_cache_flags, UInt8, (UInt8,), flags) == 0
+        if @ccall(jl_match_cache_flags(_cacheflag_to_uint8(requested_flags)::UInt8, actual_flags::UInt8)::UInt8) == 0
             @debug """
             Rejecting cache file $cachefile for $modkey since the flags are mismatched
-              current session: $(CacheFlags())
-              cache file:      $(CacheFlags(flags))
+              requested flags: $(requested_flags) [$(_cacheflag_to_uint8(requested_flags))]
+              cache file:      $(CacheFlags(actual_flags)) [$actual_flags]
             """
             record_reason(reasons, "mismatched flags")
             return true
@@ -3672,7 +3682,7 @@ function precompile(@nospecialize(argt::Type), m::Method)
     return precompile(mi)
 end
 
-precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), Nothing))
-precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), String))
-precompile(create_expr_cache, (PkgId, String, String, String, typeof(_concrete_dependencies), IO, IO, Cmd))
-precompile(create_expr_cache, (PkgId, String, String, Nothing, typeof(_concrete_dependencies), IO, IO, Cmd))
+@assert precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), Nothing))
+@assert precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), String))
+@assert precompile(create_expr_cache, (PkgId, String, String, String, typeof(_concrete_dependencies), Cmd, IO, IO))
+@assert precompile(create_expr_cache, (PkgId, String, String, Nothing, typeof(_concrete_dependencies), Cmd, IO, IO))
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 6463d30cbeae9..4498f3132d1bc 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -386,6 +386,7 @@
     XX(jl_raise_debugger) \
     XX(jl_readuntil) \
     XX(jl_cache_flags) \
+    XX(jl_match_cache_flags_current) \
     XX(jl_match_cache_flags) \
     XX(jl_read_verify_header) \
     XX(jl_realloc) \
diff --git a/src/staticdata.c b/src/staticdata.c
index 5172eb80c8b4a..67f5620f7fcef 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -3566,7 +3566,7 @@ static jl_value_t *jl_validate_cache_file(ios_t *f, jl_array_t *depmods, uint64_
                 "Precompile file header verification checks failed.");
     }
     uint8_t flags = read_uint8(f);
-    if (pkgimage && !jl_match_cache_flags(flags)) {
+    if (pkgimage && !jl_match_cache_flags_current(flags)) {
         return jl_get_exceptionf(jl_errorexception_type, "Pkgimage flags mismatch");
     }
     if (!pkgimage) {
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index fc7a59d9d0bf9..9542e54182644 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -603,31 +603,35 @@ JL_DLLEXPORT uint8_t jl_cache_flags(void)
     return flags;
 }
 
-JL_DLLEXPORT uint8_t jl_match_cache_flags(uint8_t flags)
+
+JL_DLLEXPORT uint8_t jl_match_cache_flags(uint8_t requested_flags, uint8_t actual_flags)
 {
-    // 1. Check which flags are relevant
-    uint8_t current_flags = jl_cache_flags();
-    uint8_t supports_pkgimage = (current_flags & 1);
-    uint8_t is_pkgimage = (flags & 1);
+    uint8_t supports_pkgimage = (requested_flags & 1);
+    uint8_t is_pkgimage = (actual_flags & 1);
 
     // For .ji packages ignore other flags
     if (!supports_pkgimage && !is_pkgimage) {
         return 1;
     }
 
-    // If package images are optional, ignore that bit (it will be unset in current_flags)
+    // If package images are optional, ignore that bit (it will be unset in requested_flags)
     if (jl_options.use_pkgimages == JL_OPTIONS_USE_PKGIMAGES_EXISTING) {
-        flags &= ~1;
+        actual_flags &= ~1;
     }
 
     // 2. Check all flags, execept opt level must be exact
     uint8_t mask = (1 << OPT_LEVEL)-1;
-    if ((flags & mask) != (current_flags & mask))
+    if ((actual_flags & mask) != (requested_flags & mask))
         return 0;
     // 3. allow for higher optimization flags in cache
-    flags >>= OPT_LEVEL;
-    current_flags >>= OPT_LEVEL;
-    return flags >= current_flags;
+    actual_flags >>= OPT_LEVEL;
+    requested_flags >>= OPT_LEVEL;
+    return actual_flags >= requested_flags;
+}
+
+JL_DLLEXPORT uint8_t jl_match_cache_flags_current(uint8_t flags)
+{
+    return jl_match_cache_flags(jl_cache_flags(), flags);
 }
 
 // return char* from String field in Base.GIT_VERSION_INFO
diff --git a/test/precompile.jl b/test/precompile.jl
index 015cf49f228ac..a68d8936d1ed1 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -2072,8 +2072,16 @@ precompile_test_harness("Test flags") do load_path
           module TestFlags
           end
           """)
+
+    current_flags = Base.CacheFlags()
+    modified_flags = Base.CacheFlags(
+        current_flags.use_pkgimages,
+        current_flags.debug_level,
+        2,
+        current_flags.inline,
+        3
+    )
     ji, ofile = Base.compilecache(Base.PkgId("TestFlags"); flags=`--check-bounds=no -O3`)
-    @show ji, ofile
     open(ji, "r") do io
         Base.isvalid_cache_header(io)
         _, _, _, _, _, _, _, flags = Base.parse_cache_header(io, ji)
@@ -2081,6 +2089,9 @@ precompile_test_harness("Test flags") do load_path
         @test cacheflags.check_bounds == 2
         @test cacheflags.opt_level == 3
     end
+    id = Base.identify_package("TestFlags")
+    @test Base.isprecompiled(id, ;flags=modified_flags)
+    @test !Base.isprecompiled(id, ;flags=current_flags)
 end
 
 empty!(Base.DEPOT_PATH)

From 02699bb6cd83d16b1e51e2fb127241e18df7c56b Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 19 Feb 2024 07:52:29 -0500
Subject: [PATCH 0973/1315] fix sysimage-native-code=no option with pkgimages
 (#53373)

Loading pkgimages would try to access the sysimage native code, which
will fail. Ensure that no code tries to load if the sysimage native code
is not available, as it may try to link against it.

Fixes #53147
---
 src/staticdata.c | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/staticdata.c b/src/staticdata.c
index 67f5620f7fcef..abcdd76dac507 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -607,15 +607,8 @@ extern void * JL_WEAK_SYMBOL_OR_ALIAS_DEFAULT(system_image_data_unavailable) jl_
 extern void * JL_WEAK_SYMBOL_OR_ALIAS_DEFAULT(system_image_data_unavailable) jl_system_image_size;
 static void jl_load_sysimg_so(void)
 {
-    int imaging_mode = jl_generating_output() && !jl_options.incremental;
-    // in --build mode only use sysimg data, not precompiled native code
-    if (!imaging_mode && jl_options.use_sysimage_native_code==JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES) {
-        assert(sysimage.fptrs.ptrs);
-    }
-    else {
-        memset(&sysimage.fptrs, 0, sizeof(sysimage.fptrs));
-    }
     const char *sysimg_data;
+    assert(sysimage.fptrs.ptrs); // jl_init_processor_sysimg should already be run
     if (jl_sysimg_handle == jl_exe_handle &&
             &jl_system_image_data != JL_WEAK_SYMBOL_DEFAULT(system_image_data_unavailable))
         sysimg_data = (const char*)&jl_system_image_data;
@@ -3097,6 +3090,17 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     htable_new(&new_dt_objs, 0);
     arraylist_new(&deser_sym, 0);
 
+    // in --build mode only use sysimg data, not precompiled native code
+    int imaging_mode = jl_generating_output() && !jl_options.incremental;
+    if (!imaging_mode && jl_options.use_sysimage_native_code == JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES) {
+        if (image->gvars_base)
+            assert(image->fptrs.ptrs);
+    }
+    else {
+        memset(&image->fptrs, 0, sizeof(image->fptrs));
+        image->gvars_base = NULL;
+    }
+
     // step 1: read section map
     assert(ios_pos(f) == 0 && f->bm == bm_mem);
     size_t sizeof_sysdata = read_uint(f);

From 4f20a42e10f5a440d5db5a9cf1b40e26d22195e3 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Sat, 17 Feb 2024 20:47:19 +0100
Subject: [PATCH 0974/1315] skip some tests on windows

---
 test/file.jl | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/test/file.jl b/test/file.jl
index ae05c47c47647..d44c3772e03e4 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -1664,7 +1664,7 @@ end
         fpath = joinpath(dir, "subdir", "foo")
 
         @test !ispath(subdir)
-        mkdir(joinpath(dir, "subdir"))
+        mkdir(subdir)
         @test ispath(subdir)
 
         @test !ispath(fpath)
@@ -1675,27 +1675,27 @@ end
         chmod(fpath, 0o644)
         @test !Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
-        @test Sys.iswriteable(fpath)
+        Sys.iswindows() ? @test_skip(Sys.iswriteable(fpath)) : @test(Sys.iswriteable(fpath))
         chmod(fpath, 0o755)
         @test Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
-        @test Sys.iswriteable(fpath)
+        Sys.iswindows() ? @test_skip(Sys.iswriteable(fpath)) : @test(Sys.iswriteable(fpath))
         chmod(fpath, 0o444)
         @test !Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
         @test !Sys.iswriteable(fpath)
         chmod(fpath, 0o244)
         @test !Sys.isexecutable(fpath)
-        @test !Sys.isreadable(fpath)
-        @test Sys.iswriteable(fpath)
+        Sys.iswindows() ? @test_skip(!Sys.isreadable(fpath)) : @test(!Sys.isreadable(fpath))
+        Sys.iswindows() ? @test_skip(Sys.iswriteable(fpath)) : @test(Sys.iswriteable(fpath))
 
         # Ensure that, on Windows, where inheritance is default,
         # chmod still behaves as we expect.
         if Sys.iswindows()
-            chmod(joinpath(dir, "subdir"), 0o666)
-            @test Sys.isexecutable(fpath)
+            chmod(subdir, 0o666)
+            @test !Sys.isexecutable(fpath)
             @test Sys.isreadable(fpath)
-            @test Sys.iswriteable(fpath)
+            @test_skip Sys.iswriteable(fpath)
         end
 
         # Reset permissions to all at the end, so it can be deleted properly.

From c31f1eea1a6f791f933b65be76cc7ae2f2efd9f3 Mon Sep 17 00:00:00 2001
From: Florian Atteneder <florian.atteneder@gmail.com>
Date: Mon, 19 Feb 2024 22:45:01 +0100
Subject: [PATCH 0975/1315] add note on windows ACL problems

---
 base/sysinfo.jl | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index aa33d1db8db43..c5744873312d6 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -568,6 +568,8 @@ Return `true` if the given `path` has executable permissions.
     ACLs on Windows, therefore it would return `true` for any
     file.  From Julia 1.6 on, it correctly determines whether the
     file is marked as executable or not.
+
+See also [`ispath`](@ref), [`isreadable`](@ref), [`iswriteable`](@ref).
 """
 function isexecutable(path::String)
     # We use `access()` and `X_OK` to determine if a given path is
@@ -587,10 +589,14 @@ Return `true` if the access permissions for the given `path` permitted reading b
     so it is recommended to just call `open` alone and handle the error if that fails,
     rather than calling `isreadable` first.
 
+!!! note
+    Currently this function does not correctly interrogate filesystem
+    ACLs on Windows, therefore it can return wrong results.
+
 !!! compat "Julia 1.11"
     This function requires at least Julia 1.11.
 
-See also [`ispath`](@ref).
+See also [`ispath`](@ref), [`isexecutable`](@ref), [`iswriteable`](@ref).
 """
 function isreadable(path::String)
     # We use `access()` and `R_OK` to determine if a given path is
@@ -610,10 +616,14 @@ Return `true` if the access permissions for the given `path` permitted writing b
     so it is recommended to just call `open` alone and handle the error if that fails,
     rather than calling `iswriteable` first.
 
+!!! note
+    Currently this function does not correctly interrogate filesystem
+    ACLs on Windows, therefore it can return wrong results.
+
 !!! compat "Julia 1.11"
     This function requires at least Julia 1.11.
 
-See also [`ispath`](@ref).
+See also [`ispath`](@ref), [`isexecutable`](@ref), [`isreadable`](@ref).
 """
 function iswriteable(path::String)
     # We use `access()` and `W_OK` to determine if a given path is

From 1ef36933f7aaaf97325d1fcdcc464dcd6a121f78 Mon Sep 17 00:00:00 2001
From: Kristoffer <kcarlsson89@gmail.com>
Date: Fri, 16 Feb 2024 11:18:06 +0100
Subject: [PATCH 0976/1315] update links in NEWS

---
 NEWS.md | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index 42d36b606e839..0b416b3527b38 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -223,3 +223,58 @@ Tooling Improvements
   runs on PRs that edit those same files ([#51704]).
 
 <!--- generated by NEWS-update.jl: -->
+[#28705]: https://github.com/JuliaLang/julia/issues/28705
+[#33892]: https://github.com/JuliaLang/julia/issues/33892
+[#34587]: https://github.com/JuliaLang/julia/issues/34587
+[#35856]: https://github.com/JuliaLang/julia/issues/35856
+[#38064]: https://github.com/JuliaLang/julia/issues/38064
+[#43845]: https://github.com/JuliaLang/julia/issues/43845
+[#46501]: https://github.com/JuliaLang/julia/issues/46501
+[#47354]: https://github.com/JuliaLang/julia/issues/47354
+[#47679]: https://github.com/JuliaLang/julia/issues/47679
+[#48273]: https://github.com/JuliaLang/julia/issues/48273
+[#48625]: https://github.com/JuliaLang/julia/issues/48625
+[#49546]: https://github.com/JuliaLang/julia/issues/49546
+[#49586]: https://github.com/JuliaLang/julia/issues/49586
+[#49937]: https://github.com/JuliaLang/julia/issues/49937
+[#50074]: https://github.com/JuliaLang/julia/issues/50074
+[#50105]: https://github.com/JuliaLang/julia/issues/50105
+[#50144]: https://github.com/JuliaLang/julia/issues/50144
+[#50251]: https://github.com/JuliaLang/julia/issues/50251
+[#50471]: https://github.com/JuliaLang/julia/issues/50471
+[#50586]: https://github.com/JuliaLang/julia/issues/50586
+[#50661]: https://github.com/JuliaLang/julia/issues/50661
+[#50795]: https://github.com/JuliaLang/julia/issues/50795
+[#50797]: https://github.com/JuliaLang/julia/issues/50797
+[#50958]: https://github.com/JuliaLang/julia/issues/50958
+[#51229]: https://github.com/JuliaLang/julia/issues/51229
+[#51416]: https://github.com/JuliaLang/julia/issues/51416
+[#51448]: https://github.com/JuliaLang/julia/issues/51448
+[#51487]: https://github.com/JuliaLang/julia/issues/51487
+[#51501]: https://github.com/JuliaLang/julia/issues/51501
+[#51527]: https://github.com/JuliaLang/julia/issues/51527
+[#51616]: https://github.com/JuliaLang/julia/issues/51616
+[#51647]: https://github.com/JuliaLang/julia/issues/51647
+[#51704]: https://github.com/JuliaLang/julia/issues/51704
+[#51799]: https://github.com/JuliaLang/julia/issues/51799
+[#51897]: https://github.com/JuliaLang/julia/issues/51897
+[#51929]: https://github.com/JuliaLang/julia/issues/51929
+[#52049]: https://github.com/JuliaLang/julia/issues/52049
+[#52096]: https://github.com/JuliaLang/julia/issues/52096
+[#52123]: https://github.com/JuliaLang/julia/issues/52123
+[#52139]: https://github.com/JuliaLang/julia/issues/52139
+[#52180]: https://github.com/JuliaLang/julia/issues/52180
+[#52196]: https://github.com/JuliaLang/julia/issues/52196
+[#52400]: https://github.com/JuliaLang/julia/issues/52400
+[#52413]: https://github.com/JuliaLang/julia/issues/52413
+[#52461]: https://github.com/JuliaLang/julia/issues/52461
+[#52480]: https://github.com/JuliaLang/julia/issues/52480
+[#52573]: https://github.com/JuliaLang/julia/issues/52573
+[#52631]: https://github.com/JuliaLang/julia/issues/52631
+[#52670]: https://github.com/JuliaLang/julia/issues/52670
+[#52837]: https://github.com/JuliaLang/julia/issues/52837
+[#52883]: https://github.com/JuliaLang/julia/issues/52883
+[#52889]: https://github.com/JuliaLang/julia/issues/52889
+[#52898]: https://github.com/JuliaLang/julia/issues/52898
+[#52957]: https://github.com/JuliaLang/julia/issues/52957
+[#53262]: https://github.com/JuliaLang/julia/issues/53262

From 262dc3bfdb4bde51afcd29feae58379c9b708c62 Mon Sep 17 00:00:00 2001
From: Kristoffer <kcarlsson89@gmail.com>
Date: Fri, 16 Feb 2024 11:21:16 +0100
Subject: [PATCH 0977/1315] move the 1.11 NEWS to HISTORY

---
 HISTORY.md | 281 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 NEWS.md    | 206 +--------------------------------------
 2 files changed, 282 insertions(+), 205 deletions(-)

diff --git a/HISTORY.md b/HISTORY.md
index d9486c361b934..cdcbe01481ba6 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,3 +1,284 @@
+Julia v1.11 Release Notes
+========================
+
+New language features
+---------------------
+* `public` is a new keyword. Symbols marked with `public` are considered public
+  API. Symbols marked with `export` are now also treated as public API. The
+  difference between `public` and `export` is that `public` names do not become
+  available when `using` a package/module ([#50105]).
+* `ScopedValue` implements dynamic scope with inheritance across tasks ([#50958]).
+* The new macro `Base.Cartesian.@ncallkw` is analogous to `Base.Cartesian.@ncall`,
+  but allows to add keyword arguments to the function call ([#51501]).
+* Support for Unicode 15.1 ([#51799]).
+* Three new types around the idea of text with "annotations" (`Pair{Symbol, Any}`
+  entries, e.g. `:lang => "en"` or `:face => :magenta`). These annotations
+  are preserved across operations (e.g. string concatenation with `*`) when
+  possible.
+  * `AnnotatedString` is a new `AbstractString` type. It wraps an underlying
+    string and allows for annotations to be attached to regions of the string.
+    This type is used extensively in the new `StyledStrings` standard library to
+    hold styling information.
+  * `AnnotatedChar` is a new `AbstractChar` type. It wraps another char and
+    holds a list of annotations that apply to it.
+  * `AnnotatedIOBuffer` is a new `IO` type that mimics an `IOBuffer`, but has
+    specialised `read`/`write` methods for annotated content. This can be
+    thought of both as a "string builder" of sorts and also as glue between
+    annotated and unannotated content.
+* `Manifest.toml` files can now be renamed in the format `Manifest-v{major}.{minor}.toml`
+  to be preferentially picked up by the given julia version. i.e. in the same folder,
+  a `Manifest-v1.11.toml` would be used by v1.11 and `Manifest.toml` by every other julia
+  version. This makes managing environments for multiple julia versions at the same time
+  easier ([#43845]).
+* `@time` now reports a count of any lock conflicts where a `ReentrantLock` had to wait, plus a new macro
+  `@lock_conflicts` which returns that count ([#52883]).
+
+Language changes
+----------------
+* During precompilation, the `atexit` hooks now run before saving the output file. This
+  allows users to safely tear down background state (such as closing Timers and sending
+  disconnect notifications to heartbeat tasks) and cleanup other resources when the program
+  wants to begin exiting.
+* Code coverage and malloc tracking is no longer generated during the package precompilation stage.
+  Further, during these modes pkgimage caches are now used for packages that are not being tracked.
+  This means that coverage testing (the default for `julia-actions/julia-runtest`) will by default use
+  pkgimage caches for all other packages than the package being tested, likely meaning faster test
+  execution. ([#52123])
+
+* Specifying a path in `JULIA_DEPOT_PATH` now results in the expansion of empty strings to
+  omit the default user depot ([#51448]).
+
+Compiler/Runtime improvements
+-----------------------------
+* Updated GC heuristics to count allocated pages instead of individual objects ([#50144]).
+* A new `LazyLibrary` type is exported from `Libdl` for use in building chained lazy library
+  loads, primarily to be used within JLLs ([#50074]).
+* Added support for annotating `Base.@assume_effects` on code blocks ([#52400]).
+* The libuv library has been updated from a base of v1.44.2 to v1.48.0 ([#49937]).
+
+Command-line option changes
+---------------------------
+
+* The entry point for Julia has been standardized to `Main.main(ARGS)`. This must be explicitly opted into using the `@main` macro
+(see the docstring for further details). When opted-in, and julia is invoked to run a script or expression
+(i.e. using `julia script.jl` or `julia -e expr`), julia will subsequently run the `Main.main` function automatically.
+This is intended to unify script and compilation workflows, where code loading may happen
+in the compiler and execution of `Main.main` may happen in the resulting executable. For interactive use, there is no semantic
+difference between defining a `main` function and executing the code directly at the end of the script ([50974]).
+* The `--compiled-modules` and `--pkgimages` flags can now be set to `existing`, which will
+  cause Julia to consider loading existing cache files, but not to create new ones ([#50586]
+  and [#52573]).
+
+Multi-threading changes
+-----------------------
+
+* `Threads.@threads` now supports the `:greedy` scheduler, intended for non-uniform workloads ([#52096]).
+* A new exported struct `Lockable{T, L<:AbstractLock}` makes it easy to bundle a resource and its lock together ([#52898]).
+
+Build system changes
+--------------------
+
+New library functions
+---------------------
+
+* `in!(x, s::AbstractSet)` will return whether `x` is in `s`, and insert `x` in `s` if not.
+* The new `Libc.mkfifo` function wraps the `mkfifo` C function on Unix platforms ([#34587]).
+* `copyuntil(out, io, delim)` and `copyline(out, io)` copy data into an `out::IO` stream ([#48273]).
+* `eachrsplit(string, pattern)` iterates split substrings right to left.
+* `Sys.username()` can be used to return the current user's username ([#51897]).
+* `wrap(Array, m::Union{MemoryRef{T}, Memory{T}}, dims)` is the safe counterpart to `unsafe_wrap` ([#52049]).
+* `GC.logging_enabled()` can be used to test whether GC logging has been enabled via `GC.enable_logging` ([#51647]).
+* `IdSet` is now exported from Base and considered public ([#53262]).
+
+New library features
+--------------------
+
+* `invmod(n, T)` where `T` is a native integer type now computes the modular inverse of `n` in the modular integer ring that `T` defines ([#52180]).
+* `invmod(n)` is an abbreviation for `invmod(n, typeof(n))` for native integer types ([#52180]).
+* `replace(string, pattern...)` now supports an optional `IO` argument to
+  write the output to a stream rather than returning a string ([#48625]).
+* New methods `allequal(f, itr)` and `allunique(f, itr)` taking a predicate function ([#47679]).
+* `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
+* New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
+* New function `Docs.undocumented_names(module)` returns a module's undocumented public names ([#52413]).
+* Passing an `IOBuffer` as a stdout argument for `Process` spawn now works as
+  expected, synchronized with `wait` or `success`, so a `Base.BufferStream` is
+  no longer required there for correctness to avoid data races ([#52461]).
+* After a process exits, `closewrite` will no longer be automatically called on
+  the stream passed to it. Call `wait` on the process instead to ensure the
+  content is fully written, then call `closewrite` manually to avoid
+  data-races. Or use the callback form of `open` to have all that handled
+  automatically.
+* `@timed` now additionally returns the elapsed compilation and recompilation time ([#52889])
+* `filter` can now act on a `NamedTuple` ([#50795]).
+* `Iterators.cycle(iter, n)` runs over `iter` a fixed number of times, instead of forever ([#47354])
+* `zero(::AbstractArray)` now applies recursively, so `zero([[1,2],[3,4,5]])` now produces the additive identity `[[0,0],[0,0,0]]` rather than erroring ([#38064]).
+
+Standard library changes
+------------------------
+
+#### StyledStrings
+
+* A new standard library for handling styling in a more comprehensive and structured way ([#49586]).
+* The new `Faces` struct serves as a container for text styling information
+  (think typeface, as well as color and decoration), and comes with a framework
+  to provide a convenient, extensible (via `addface!`), and customisable (with a
+  user's `Faces.toml` and `loadfaces!`) approach to
+  styled content ([#49586]).
+* The new `@styled_str` string macro provides a convenient way of creating a
+  `AnnotatedString` with various faces or other attributes applied ([#49586]).
+
+#### JuliaSyntaxHighlighting
+
+* A new standard library for applying syntax highlighting to Julia code, this
+  uses `JuliaSyntax` and `StyledStrings` to implement a `highlight` function
+  that creates an `AnnotatedString` with syntax highlighting applied.
+
+#### Package Manager
+
+#### LinearAlgebra
+* `cbrt(::AbstractMatrix{<:Real})` is now defined and returns real-valued matrix cube roots of real-valued matrices ([#50661]).
+* `eigvals/eigen(A, bunchkaufman(B))` and `eigvals/eigen(A, lu(B))`, which utilize the Bunchkaufman (LDL) and LU decomposition of `B`,
+   respectively, now efficiently compute the generalized eigenvalues (`eigen`: and eigenvectors) of `A` and `B`. Note: The second
+   argument is the output of `bunchkaufman` or `lu` ([#50471]).
+* There is now a specialized dispatch for `eigvals/eigen(::Hermitian{<:Tridiagonal})` which performs a similarity transformation to create a real symmetrix triagonal matrix, and solve that using the LAPACK routines ([#49546]).
+* Structured matrices now retain either the axes of the parent (for `Symmetric`/`Hermitian`/`AbstractTriangular`/`UpperHessenberg`), or that of the principal diagonal (for banded matrices) ([#52480]).
+* `bunchkaufman` and `bunchkaufman!` now work for any `AbstractFloat`, `Rational` and their complex variants. `bunchkaufman` now supports `Integer` types, by making an internal conversion to `Rational{BigInt}`. Added new function `inertia` that computes the inertia of the diagonal factor given by the `BunchKaufman` factorization object of a real symmetric or Hermitian matrix. For complex symmetric matrices, `inertia` only computes the number of zero eigenvalues of the diagonal factor ([#51487]).
+* Packages that specialize matrix-matrix `mul!` with a method signature of the form `mul!(::AbstractMatrix, ::MyMatrix, ::AbstractMatrix, ::Number, ::Number)` no longer encounter method ambiguities when interacting with `LinearAlgebra`. Previously, ambiguities used to arise when multiplying a `MyMatrix` with a structured matrix type provided by LinearAlgebra, such as `AbstractTriangular`, which used to necessitate additional methods to resolve such ambiguities. Similar sources of ambiguities have also been removed for matrix-vector `mul!` operations ([#52837]).
+* `lu` and `issuccess(::LU)` now accept an `allowsingular` keyword argument. When set to `true`, a valid factorization with rank-deficient U factor will be treated as success instead of throwing an error. Such factorizations are now shown by printing the factors together with a "rank-deficient" note rather than printing a "Failed Factorization" message ([#52957]).
+
+#### Logging
+* New `@create_log_macro` macro for creating new log macros like `@info`, `@warn` etc. For instance
+  `@create_log_macro MyLog 1500 :magenta` will create `@mylog` to be used like `@mylog "hello"` which
+  will show as `┌ MyLog: hello` etc. ([#52196])
+
+#### Printf
+
+#### Profile
+
+#### Random
+* `rand` now supports sampling over `Tuple` types ([#35856], [#50251]).
+* `rand` now supports sampling over `Pair` types ([#28705]).
+* When seeding RNGs provided by `Random`, negative integer seeds can now be used ([#51416]).
+* Seedable random number generators from `Random` can now be seeded by a string, e.g.
+  `seed!(rng, "a random seed")` ([#51527]).
+
+#### REPL
+
+* Tab complete hints now show in lighter text while typing in the repl. To disable
+  set `Base.active_repl.options.hint_tab_completes = false` interactively, or in startup.jl:
+  ```
+  if VERSION >= v"1.11.0-0"
+    atreplinit() do repl
+        repl.options.hint_tab_completes = false
+    end
+  end
+  ``` ([#51229]).
+* Meta-M with an empty prompt now toggles the contextual module between the previous non-Main
+  contextual module and Main so that switching back and forth is simple. ([#51616], [#52670])
+
+#### SuiteSparse
+
+
+#### SparseArrays
+
+#### Test
+
+#### Dates
+
+The undocumented function `adjust` is no longer exported but is now documented
+
+#### Statistics
+
+* Statistics is now an upgradeable standard library ([#46501]).
+
+#### Distributed
+
+* `pmap` now defaults to using a `CachingPool` ([#33892]).
+
+#### Unicode
+
+
+#### DelimitedFiles
+
+
+#### InteractiveUtils
+
+Deprecated or removed
+---------------------
+
+* `Base.map`, `Iterators.map`, and `foreach` lost their single-argument methods ([#52631]).
+
+
+External dependencies
+---------------------
+* `tput` is no longer called to check terminal capabilities, it has been replaced with a pure-Julia terminfo parser ([#50797]).
+
+Tooling Improvements
+--------------------
+
+* CI now performs limited automatic typo detection on all PRs. If you merge a PR with a
+  failing typo CI check, then the reported typos will be automatically ignored in future CI
+  runs on PRs that edit those same files ([#51704]).
+
+<!--- generated by NEWS-update.jl: -->
+[#28705]: https://github.com/JuliaLang/julia/issues/28705
+[#33892]: https://github.com/JuliaLang/julia/issues/33892
+[#34587]: https://github.com/JuliaLang/julia/issues/34587
+[#35856]: https://github.com/JuliaLang/julia/issues/35856
+[#38064]: https://github.com/JuliaLang/julia/issues/38064
+[#43845]: https://github.com/JuliaLang/julia/issues/43845
+[#46501]: https://github.com/JuliaLang/julia/issues/46501
+[#47354]: https://github.com/JuliaLang/julia/issues/47354
+[#47679]: https://github.com/JuliaLang/julia/issues/47679
+[#48273]: https://github.com/JuliaLang/julia/issues/48273
+[#48625]: https://github.com/JuliaLang/julia/issues/48625
+[#49546]: https://github.com/JuliaLang/julia/issues/49546
+[#49586]: https://github.com/JuliaLang/julia/issues/49586
+[#49937]: https://github.com/JuliaLang/julia/issues/49937
+[#50074]: https://github.com/JuliaLang/julia/issues/50074
+[#50105]: https://github.com/JuliaLang/julia/issues/50105
+[#50144]: https://github.com/JuliaLang/julia/issues/50144
+[#50251]: https://github.com/JuliaLang/julia/issues/50251
+[#50471]: https://github.com/JuliaLang/julia/issues/50471
+[#50586]: https://github.com/JuliaLang/julia/issues/50586
+[#50661]: https://github.com/JuliaLang/julia/issues/50661
+[#50795]: https://github.com/JuliaLang/julia/issues/50795
+[#50797]: https://github.com/JuliaLang/julia/issues/50797
+[#50958]: https://github.com/JuliaLang/julia/issues/50958
+[#51229]: https://github.com/JuliaLang/julia/issues/51229
+[#51416]: https://github.com/JuliaLang/julia/issues/51416
+[#51448]: https://github.com/JuliaLang/julia/issues/51448
+[#51487]: https://github.com/JuliaLang/julia/issues/51487
+[#51501]: https://github.com/JuliaLang/julia/issues/51501
+[#51527]: https://github.com/JuliaLang/julia/issues/51527
+[#51616]: https://github.com/JuliaLang/julia/issues/51616
+[#51647]: https://github.com/JuliaLang/julia/issues/51647
+[#51704]: https://github.com/JuliaLang/julia/issues/51704
+[#51799]: https://github.com/JuliaLang/julia/issues/51799
+[#51897]: https://github.com/JuliaLang/julia/issues/51897
+[#51929]: https://github.com/JuliaLang/julia/issues/51929
+[#52049]: https://github.com/JuliaLang/julia/issues/52049
+[#52096]: https://github.com/JuliaLang/julia/issues/52096
+[#52123]: https://github.com/JuliaLang/julia/issues/52123
+[#52139]: https://github.com/JuliaLang/julia/issues/52139
+[#52180]: https://github.com/JuliaLang/julia/issues/52180
+[#52196]: https://github.com/JuliaLang/julia/issues/52196
+[#52400]: https://github.com/JuliaLang/julia/issues/52400
+[#52413]: https://github.com/JuliaLang/julia/issues/52413
+[#52461]: https://github.com/JuliaLang/julia/issues/52461
+[#52480]: https://github.com/JuliaLang/julia/issues/52480
+[#52573]: https://github.com/JuliaLang/julia/issues/52573
+[#52631]: https://github.com/JuliaLang/julia/issues/52631
+[#52670]: https://github.com/JuliaLang/julia/issues/52670
+[#52837]: https://github.com/JuliaLang/julia/issues/52837
+[#52883]: https://github.com/JuliaLang/julia/issues/52883
+[#52889]: https://github.com/JuliaLang/julia/issues/52889
+[#52898]: https://github.com/JuliaLang/julia/issues/52898
+[#52957]: https://github.com/JuliaLang/julia/issues/52957
+[#53262]: https://github.com/JuliaLang/julia/issues/53262
+
+
 Julia v1.10 Release Notes
 =========================
 
diff --git a/NEWS.md b/NEWS.md
index 0b416b3527b38..15821f2744e0a 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,280 +1,76 @@
-Julia v1.11 Release Notes
+Julia v1.12 Release Notes
 ========================
 
 New language features
 ---------------------
-* `public` is a new keyword. Symbols marked with `public` are considered public
-  API. Symbols marked with `export` are now also treated as public API. The
-  difference between `public` and `export` is that `public` names do not become
-  available when `using` a package/module ([#50105]).
-* `ScopedValue` implements dynamic scope with inheritance across tasks ([#50958]).
-* The new macro `Base.Cartesian.@ncallkw` is analogous to `Base.Cartesian.@ncall`,
-  but allows to add keyword arguments to the function call ([#51501]).
-* Support for Unicode 15.1 ([#51799]).
-* Three new types around the idea of text with "annotations" (`Pair{Symbol, Any}`
-  entries, e.g. `:lang => "en"` or `:face => :magenta`). These annotations
-  are preserved across operations (e.g. string concatenation with `*`) when
-  possible.
-  * `AnnotatedString` is a new `AbstractString` type. It wraps an underlying
-    string and allows for annotations to be attached to regions of the string.
-    This type is used extensively in the new `StyledStrings` standard library to
-    hold styling information.
-  * `AnnotatedChar` is a new `AbstractChar` type. It wraps another char and
-    holds a list of annotations that apply to it.
-  * `AnnotatedIOBuffer` is a new `IO` type that mimics an `IOBuffer`, but has
-    specialised `read`/`write` methods for annotated content. This can be
-    thought of both as a "string builder" of sorts and also as glue between
-    annotated and unannotated content.
-* `Manifest.toml` files can now be renamed in the format `Manifest-v{major}.{minor}.toml`
-  to be preferentially picked up by the given julia version. i.e. in the same folder,
-  a `Manifest-v1.11.toml` would be used by v1.11 and `Manifest.toml` by every other julia
-  version. This makes managing environments for multiple julia versions at the same time
-  easier ([#43845]).
-* `@time` now reports a count of any lock conflicts where a `ReentrantLock` had to wait, plus a new macro
-  `@lock_conflicts` which returns that count ([#52883]).
 
 Language changes
 ----------------
-* During precompilation, the `atexit` hooks now run before saving the output file. This
-  allows users to safely tear down background state (such as closing Timers and sending
-  disconnect notifications to heartbeat tasks) and cleanup other resources when the program
-  wants to begin exiting.
-* Code coverage and malloc tracking is no longer generated during the package precompilation stage.
-  Further, during these modes pkgimage caches are now used for packages that are not being tracked.
-  This means that coverage testing (the default for `julia-actions/julia-runtest`) will by default use
-  pkgimage caches for all other packages than the package being tested, likely meaning faster test
-  execution. ([#52123])
-
-* Specifying a path in `JULIA_DEPOT_PATH` now results in the expansion of empty strings to
-  omit the default user depot ([#51448]).
 
 Compiler/Runtime improvements
 -----------------------------
-* Updated GC heuristics to count allocated pages instead of individual objects ([#50144]).
-* A new `LazyLibrary` type is exported from `Libdl` for use in building chained lazy library
-  loads, primarily to be used within JLLs ([#50074]).
-* Added support for annotating `Base.@assume_effects` on code blocks ([#52400]).
-* The libuv library has been updated from a base of v1.44.2 to v1.48.0 ([#49937]).
 
 Command-line option changes
 ---------------------------
 
-* The entry point for Julia has been standardized to `Main.main(ARGS)`. This must be explicitly opted into using the `@main` macro
-(see the docstring for further details). When opted-in, and julia is invoked to run a script or expression
-(i.e. using `julia script.jl` or `julia -e expr`), julia will subsequently run the `Main.main` function automatically.
-This is intended to unify script and compilation workflows, where code loading may happen
-in the compiler and execution of `Main.main` may happen in the resulting executable. For interactive use, there is no semantic
-difference between defining a `main` function and executing the code directly at the end of the script ([50974]).
-* The `--compiled-modules` and `--pkgimages` flags can now be set to `existing`, which will
-  cause Julia to consider loading existing cache files, but not to create new ones ([#50586]
-  and [#52573]).
-
 Multi-threading changes
 -----------------------
 
-* `Threads.@threads` now supports the `:greedy` scheduler, intended for non-uniform workloads ([#52096]).
-* A new exported struct `Lockable{T, L<:AbstractLock}` makes it easy to bundle a resource and its lock together ([#52898]).
-
 Build system changes
 --------------------
 
 New library functions
 ---------------------
 
-* `in!(x, s::AbstractSet)` will return whether `x` is in `s`, and insert `x` in `s` if not.
-* The new `Libc.mkfifo` function wraps the `mkfifo` C function on Unix platforms ([#34587]).
 * `logrange(start, stop; length)` makes a range of constant ratio, instead of constant step ([#39071])
-* `copyuntil(out, io, delim)` and `copyline(out, io)` copy data into an `out::IO` stream ([#48273]).
-* `eachrsplit(string, pattern)` iterates split substrings right to left.
-* `Sys.username()` can be used to return the current user's username ([#51897]).
-* `wrap(Array, m::Union{MemoryRef{T}, Memory{T}}, dims)` is the safe counterpart to `unsafe_wrap` ([#52049]).
-* `GC.logging_enabled()` can be used to test whether GC logging has been enabled via `GC.enable_logging` ([#51647]).
-* `IdSet` is now exported from Base and considered public ([#53262]).
 
 New library features
 --------------------
 
-* `invmod(n, T)` where `T` is a native integer type now computes the modular inverse of `n` in the modular integer ring that `T` defines ([#52180]).
-* `invmod(n)` is an abbreviation for `invmod(n, typeof(n))` for native integer types ([#52180]).
-* `replace(string, pattern...)` now supports an optional `IO` argument to
-  write the output to a stream rather than returning a string ([#48625]).
-* New methods `allequal(f, itr)` and `allunique(f, itr)` taking a predicate function ([#47679]).
-* `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
-* New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
-* New function `Docs.undocumented_names(module)` returns a module's undocumented public names ([#52413]).
-* Passing an `IOBuffer` as a stdout argument for `Process` spawn now works as
-  expected, synchronized with `wait` or `success`, so a `Base.BufferStream` is
-  no longer required there for correctness to avoid data races ([#52461]).
-* After a process exits, `closewrite` will no longer be automatically called on
-  the stream passed to it. Call `wait` on the process instead to ensure the
-  content is fully written, then call `closewrite` manually to avoid
-  data-races. Or use the callback form of `open` to have all that handled
-  automatically.
-* `@timed` now additionally returns the elapsed compilation and recompilation time ([#52889])
-* `filter` can now act on a `NamedTuple` ([#50795]).
-* `Iterators.cycle(iter, n)` runs over `iter` a fixed number of times, instead of forever ([#47354])
-* `zero(::AbstractArray)` now applies recursively, so `zero([[1,2],[3,4,5]])` now produces the additive identity `[[0,0],[0,0,0]]` rather than erroring ([#38064]).
-
 Standard library changes
 ------------------------
 
 #### StyledStrings
 
-* A new standard library for handling styling in a more comprehensive and structured way ([#49586]).
-* The new `Faces` struct serves as a container for text styling information
-  (think typeface, as well as color and decoration), and comes with a framework
-  to provide a convenient, extensible (via `addface!`), and customisable (with a
-  user's `Faces.toml` and `loadfaces!`) approach to
-  styled content ([#49586]).
-* The new `@styled_str` string macro provides a convenient way of creating a
-  `AnnotatedString` with various faces or other attributes applied ([#49586]).
-
 #### JuliaSyntaxHighlighting
 
-* A new standard library for applying syntax highlighting to Julia code, this
-  uses `JuliaSyntax` and `StyledStrings` to implement a `highlight` function
-  that creates an `AnnotatedString` with syntax highlighting applied.
-
 #### Package Manager
 
 #### LinearAlgebra
-* `cbrt(::AbstractMatrix{<:Real})` is now defined and returns real-valued matrix cube roots of real-valued matrices ([#50661]).
-* `eigvals/eigen(A, bunchkaufman(B))` and `eigvals/eigen(A, lu(B))`, which utilize the Bunchkaufman (LDL) and LU decomposition of `B`,
-   respectively, now efficiently compute the generalized eigenvalues (`eigen`: and eigenvectors) of `A` and `B`. Note: The second
-   argument is the output of `bunchkaufman` or `lu` ([#50471]).
-* There is now a specialized dispatch for `eigvals/eigen(::Hermitian{<:Tridiagonal})` which performs a similarity transformation to create a real symmetrix triagonal matrix, and solve that using the LAPACK routines ([#49546]).
-* Structured matrices now retain either the axes of the parent (for `Symmetric`/`Hermitian`/`AbstractTriangular`/`UpperHessenberg`), or that of the principal diagonal (for banded matrices) ([#52480]).
-* `bunchkaufman` and `bunchkaufman!` now work for any `AbstractFloat`, `Rational` and their complex variants. `bunchkaufman` now supports `Integer` types, by making an internal conversion to `Rational{BigInt}`. Added new function `inertia` that computes the inertia of the diagonal factor given by the `BunchKaufman` factorization object of a real symmetric or Hermitian matrix. For complex symmetric matrices, `inertia` only computes the number of zero eigenvalues of the diagonal factor ([#51487]).
-* Packages that specialize matrix-matrix `mul!` with a method signature of the form `mul!(::AbstractMatrix, ::MyMatrix, ::AbstractMatrix, ::Number, ::Number)` no longer encounter method ambiguities when interacting with `LinearAlgebra`. Previously, ambiguities used to arise when multiplying a `MyMatrix` with a structured matrix type provided by LinearAlgebra, such as `AbstractTriangular`, which used to necessitate additional methods to resolve such ambiguities. Similar sources of ambiguities have also been removed for matrix-vector `mul!` operations ([#52837]).
-* `lu` and `issuccess(::LU)` now accept an `allowsingular` keyword argument. When set to `true`, a valid factorization with rank-deficient U factor will be treated as success instead of throwing an error. Such factorizations are now shown by printing the factors together with a "rank-deficient" note rather than printing a "Failed Factorization" message ([#52957]).
 
 #### Logging
-* New `@create_log_macro` macro for creating new log macros like `@info`, `@warn` etc. For instance
-  `@create_log_macro MyLog 1500 :magenta` will create `@mylog` to be used like `@mylog "hello"` which
-  will show as `┌ MyLog: hello` etc. ([#52196])
 
 #### Printf
 
 #### Profile
 
 #### Random
-* `rand` now supports sampling over `Tuple` types ([#35856], [#50251]).
-* `rand` now supports sampling over `Pair` types ([#28705]).
-* When seeding RNGs provided by `Random`, negative integer seeds can now be used ([#51416]).
-* Seedable random number generators from `Random` can now be seeded by a string, e.g.
-  `seed!(rng, "a random seed")` ([#51527]).
 
 #### REPL
 
-* Tab complete hints now show in lighter text while typing in the repl. To disable
-  set `Base.active_repl.options.hint_tab_completes = false` interactively, or in startup.jl:
-  ```
-  if VERSION >= v"1.11.0-0"
-    atreplinit() do repl
-        repl.options.hint_tab_completes = false
-    end
-  end
-  ``` ([#51229]).
-* Meta-M with an empty prompt now toggles the contextual module between the previous non-Main
-  contextual module and Main so that switching back and forth is simple. ([#51616], [#52670])
-
 #### SuiteSparse
 
-
 #### SparseArrays
 
 #### Test
 
 #### Dates
 
-The undocumented function `adjust` is no longer exported but is now documented
-
 #### Statistics
 
-* Statistics is now an upgradeable standard library ([#46501]).
-
 #### Distributed
 
-* `pmap` now defaults to using a `CachingPool` ([#33892]).
-
 #### Unicode
 
-
 #### DelimitedFiles
 
-
 #### InteractiveUtils
 
 Deprecated or removed
 ---------------------
 
-* `Base.map`, `Iterators.map`, and `foreach` lost their single-argument methods ([#52631]).
-
-
 External dependencies
 ---------------------
-* `tput` is no longer called to check terminal capabilities, it has been replaced with a pure-Julia terminfo parser ([#50797]).
 
 Tooling Improvements
 --------------------
-
-* CI now performs limited automatic typo detection on all PRs. If you merge a PR with a
-  failing typo CI check, then the reported typos will be automatically ignored in future CI
-  runs on PRs that edit those same files ([#51704]).
-
-<!--- generated by NEWS-update.jl: -->
-[#28705]: https://github.com/JuliaLang/julia/issues/28705
-[#33892]: https://github.com/JuliaLang/julia/issues/33892
-[#34587]: https://github.com/JuliaLang/julia/issues/34587
-[#35856]: https://github.com/JuliaLang/julia/issues/35856
-[#38064]: https://github.com/JuliaLang/julia/issues/38064
-[#43845]: https://github.com/JuliaLang/julia/issues/43845
-[#46501]: https://github.com/JuliaLang/julia/issues/46501
-[#47354]: https://github.com/JuliaLang/julia/issues/47354
-[#47679]: https://github.com/JuliaLang/julia/issues/47679
-[#48273]: https://github.com/JuliaLang/julia/issues/48273
-[#48625]: https://github.com/JuliaLang/julia/issues/48625
-[#49546]: https://github.com/JuliaLang/julia/issues/49546
-[#49586]: https://github.com/JuliaLang/julia/issues/49586
-[#49937]: https://github.com/JuliaLang/julia/issues/49937
-[#50074]: https://github.com/JuliaLang/julia/issues/50074
-[#50105]: https://github.com/JuliaLang/julia/issues/50105
-[#50144]: https://github.com/JuliaLang/julia/issues/50144
-[#50251]: https://github.com/JuliaLang/julia/issues/50251
-[#50471]: https://github.com/JuliaLang/julia/issues/50471
-[#50586]: https://github.com/JuliaLang/julia/issues/50586
-[#50661]: https://github.com/JuliaLang/julia/issues/50661
-[#50795]: https://github.com/JuliaLang/julia/issues/50795
-[#50797]: https://github.com/JuliaLang/julia/issues/50797
-[#50958]: https://github.com/JuliaLang/julia/issues/50958
-[#51229]: https://github.com/JuliaLang/julia/issues/51229
-[#51416]: https://github.com/JuliaLang/julia/issues/51416
-[#51448]: https://github.com/JuliaLang/julia/issues/51448
-[#51487]: https://github.com/JuliaLang/julia/issues/51487
-[#51501]: https://github.com/JuliaLang/julia/issues/51501
-[#51527]: https://github.com/JuliaLang/julia/issues/51527
-[#51616]: https://github.com/JuliaLang/julia/issues/51616
-[#51647]: https://github.com/JuliaLang/julia/issues/51647
-[#51704]: https://github.com/JuliaLang/julia/issues/51704
-[#51799]: https://github.com/JuliaLang/julia/issues/51799
-[#51897]: https://github.com/JuliaLang/julia/issues/51897
-[#51929]: https://github.com/JuliaLang/julia/issues/51929
-[#52049]: https://github.com/JuliaLang/julia/issues/52049
-[#52096]: https://github.com/JuliaLang/julia/issues/52096
-[#52123]: https://github.com/JuliaLang/julia/issues/52123
-[#52139]: https://github.com/JuliaLang/julia/issues/52139
-[#52180]: https://github.com/JuliaLang/julia/issues/52180
-[#52196]: https://github.com/JuliaLang/julia/issues/52196
-[#52400]: https://github.com/JuliaLang/julia/issues/52400
-[#52413]: https://github.com/JuliaLang/julia/issues/52413
-[#52461]: https://github.com/JuliaLang/julia/issues/52461
-[#52480]: https://github.com/JuliaLang/julia/issues/52480
-[#52573]: https://github.com/JuliaLang/julia/issues/52573
-[#52631]: https://github.com/JuliaLang/julia/issues/52631
-[#52670]: https://github.com/JuliaLang/julia/issues/52670
-[#52837]: https://github.com/JuliaLang/julia/issues/52837
-[#52883]: https://github.com/JuliaLang/julia/issues/52883
-[#52889]: https://github.com/JuliaLang/julia/issues/52889
-[#52898]: https://github.com/JuliaLang/julia/issues/52898
-[#52957]: https://github.com/JuliaLang/julia/issues/52957
-[#53262]: https://github.com/JuliaLang/julia/issues/53262

From 1a9040908b9bb89927b2d318da3f9fe1e457abea Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 20 Feb 2024 22:35:02 +0530
Subject: [PATCH 0978/1315] Add `_unsetindex!` methods for `SubArray`s and
 `CartesianIndex`es (#53383)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

With this, the following (and equivalent calls) work:
```julia
julia> copyto!(view(zeros(BigInt, 2), 1:2), Vector{BigInt}(undef,2))
2-element view(::Vector{BigInt}, 1:2) with eltype BigInt:
 #undef
 #undef

julia> copyto!(view(zeros(BigInt, 2), 1:2), view(Vector{BigInt}(undef,2), 1:2))
2-element view(::Vector{BigInt}, 1:2) with eltype BigInt:
 #undef
 #undef
```

Close https://github.com/JuliaLang/julia/issues/53098. With this, all
the `_unsetindex!` branches in `copyto_unaliased!` work for
`Array`-views, and this makes certain indexing operations vectorize and
speed-up:
```julia
julia> using BenchmarkTools

julia> a = view(rand(100,100), 1:100, 1:100); b = view(similar(a), axes(a)...);

julia> @btime copyto!($b, $a);
  16.427 μs (0 allocations: 0 bytes) # master
  2.308 μs (0 allocations: 0 bytes) # PR
```

Improves (but doesn't resolve)
https://github.com/JuliaLang/julia/issues/40962 and
https://github.com/JuliaLang/julia/issues/53158

```julia
julia> a = rand(40,40); b = rand(40,40);

julia> @btime $a[1:end,1:end] .= $b;
  5.383 μs (0 allocations: 0 bytes) # v"1.12.0-DEV.16"
  3.194 μs (0 allocations: 0 bytes) # PR
```
ƒ
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/abstractarray.jl    | 15 +++++++++++++-
 base/array.jl            |  7 ++++++-
 base/multidimensional.jl |  6 ++++++
 base/subarray.jl         | 19 ++++++++++++++++++
 test/abstractarray.jl    | 31 +++++++++++++++++++++++++++++
 test/subarray.jl         | 42 ++++++++++++++++++++++++++++++++++++++++
 6 files changed, 118 insertions(+), 2 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 59ba7ad82c7f0..bdbcbe4d081a4 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1472,7 +1472,20 @@ function _setindex!(::IndexCartesian, A::AbstractArray, v, I::Vararg{Int,M}) whe
     r
 end
 
-_unsetindex!(A::AbstractArray, i::Integer) = _unsetindex!(A, to_index(i))
+function _unsetindex!(A::AbstractArray, i::Integer...)
+    @_propagate_inbounds_meta
+    _unsetindex!(A, map(to_index, i)...)
+end
+
+function _unsetindex!(A::AbstractArray{T}, i::Int...) where T
+    # this provides a fallback method which is a no-op if the element is already unassigned
+    # such that copying into an uninitialized object generally always will work,
+    # even if the specific custom array type has not implemented `_unsetindex!`
+    @inline
+    @boundscheck checkbounds(A, i...)
+    allocatedinline(T) || @inbounds(!isassigned(A, i...)) || throw(MethodError(_unsetindex!, (A, i...)))
+    return A
+end
 
 """
     parent(A)
diff --git a/base/array.jl b/base/array.jl
index 4b2cd34b2f0db..4fcf29af69b4b 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -219,7 +219,12 @@ function _unsetindex!(A::Array, i::Int)
     @inbounds _unsetindex!(GenericMemoryRef(A.ref, i))
     return A
 end
-
+function _unsetindex!(A::Array, i::Int...)
+    @inline
+    @boundscheck checkbounds(A, i...)
+    @inbounds _unsetindex!(A, _to_linear_index(A, i...))
+    return A
+end
 
 # TODO: deprecate this (aligned_sizeof and/or elsize and/or sizeof(Some{T}) are more correct)
 elsize(::Type{A}) where {T,A<:Array{T}} = aligned_sizeof(T)
diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 146f8c160e8e9..fe29e5c1d8e5f 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -1610,6 +1610,12 @@ end
     end
 end
 
+# _unsetindex
+@propagate_inbounds function Base._unsetindex!(A::AbstractArray, i::CartesianIndex)
+    Base._unsetindex!(A, to_indices(A, (i,))...)
+    return A
+end
+
 ## permutedims
 
 ## Permute array dims ##
diff --git a/base/subarray.jl b/base/subarray.jl
index 396f7c52bd77a..c15a4d48868fa 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -410,6 +410,25 @@ function isassigned(V::FastSubArray{<:Any, 1}, i::Int)
     r
 end
 
+function _unsetindex!(V::FastSubArray, i::Int)
+    @inline
+    @boundscheck checkbounds(Bool, V, i)
+    @inbounds _unsetindex!(V.parent, _reindexlinear(V, i))
+    return V
+end
+function _unsetindex!(V::FastSubArray{<:Any,1}, i::Int)
+    @inline
+    @boundscheck checkbounds(Bool, V, i)
+    @inbounds _unsetindex!(V.parent, _reindexlinear(V, i))
+    return V
+end
+function _unsetindex!(V::SubArray{T,N}, i::Vararg{Int,N}) where {T,N}
+    @inline
+    @boundscheck checkbounds(Bool, V, i...)
+    @inbounds _unsetindex!(V.parent, reindex(V.indices, i)...)
+    return V
+end
+
 IndexStyle(::Type{<:FastSubArray}) = IndexLinear()
 IndexStyle(::Type{<:SubArray}) = IndexCartesian()
 
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 8392d533261b3..9d9c9b9c87776 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -2019,3 +2019,34 @@ end
         @test B == A
     end
 end
+
+@testset "_unsetindex!" begin
+    struct MyMatrixUnsetIndexCartInds{T,A<:AbstractMatrix{T}} <: AbstractMatrix{T}
+        data :: A
+    end
+    Base.size(A::MyMatrixUnsetIndexCartInds) = size(A.data)
+    Base.getindex(M::MyMatrixUnsetIndexCartInds, i::Int, j::Int) = M.data[i,j]
+    Base.setindex!(M::MyMatrixUnsetIndexCartInds, v, i::Int, j::Int) = setindex!(M.data, v, i, j)
+    struct MyMatrixUnsetIndexLinInds{T,A<:AbstractMatrix{T}} <: AbstractMatrix{T}
+        data :: A
+    end
+    Base.size(A::MyMatrixUnsetIndexLinInds) = size(A.data)
+    Base.getindex(M::MyMatrixUnsetIndexLinInds, i::Int) = M.data[i]
+    Base.setindex!(M::MyMatrixUnsetIndexLinInds, v, i::Int) = setindex!(M.data, v, i)
+    Base.IndexStyle(::Type{<:MyMatrixUnsetIndexLinInds}) = IndexLinear()
+
+    function test_unsetindex(MT)
+        M = MT(ones(2,2))
+        M2 = MT(Matrix{BigFloat}(undef, 2,2))
+        copyto!(M, M2)
+        @test all(==(1), M)
+        M3 = MT(Matrix{BigFloat}(undef, 2,2))
+        for i in eachindex(M3)
+            @test !isassigned(M3, i)
+        end
+        M3 .= 1
+        @test_throws MethodError copyto!(M3, M2)
+    end
+    test_unsetindex(MyMatrixUnsetIndexCartInds)
+    test_unsetindex(MyMatrixUnsetIndexLinInds)
+end
diff --git a/test/subarray.jl b/test/subarray.jl
index 0606ed00e6a7a..ada53d7d91ee3 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -1055,4 +1055,46 @@ end
         @test !isassigned(v, 1, 2) # inbounds but not assigned
         @test !isassigned(v, 3, 3) # out-of-bounds
     end
+
+    @testset "_unsetindex!" begin
+        function test_unsetindex(A, B)
+            copyto!(A, B)
+            for i in eachindex(A)
+                @test !isassigned(A, i)
+            end
+        end
+        @testset "dest IndexLinear, src IndexLinear" begin
+            for p in (fill(BigInt(2)), BigInt[1, 2], BigInt[1 2; 3 4])
+                A = view(copy(p), ntuple(_->:, ndims(p))...)
+                B = view(similar(A), ntuple(_->:, ndims(p))...)
+                test_unsetindex(A, B)
+                test_unsetindex(p, B)
+            end
+        end
+
+        @testset "dest IndexLinear, src IndexCartesian" begin
+            for p in (fill(BigInt(2)), BigInt[1, 2], BigInt[1 2; 3 4])
+                A = view(copy(p), ntuple(_->:, ndims(p))...)
+                B = view(similar(A), axes(A)...)
+                test_unsetindex(A, B)
+                test_unsetindex(p, B)
+            end
+        end
+
+        @testset "dest IndexCartesian, src IndexLinear" begin
+            for p in (fill(BigInt(2)), BigInt[1, 2], BigInt[1 2; 3 4])
+                A = view(p, axes(p)...)
+                B = similar(A)
+                test_unsetindex(A, B)
+            end
+        end
+
+        @testset "dest IndexCartesian, src IndexCartesian" begin
+            for p in (fill(BigInt(2)), BigInt[1, 2], BigInt[1 2; 3 4])
+                A = view(p, axes(p)...)
+                B = view(similar(A), axes(A)...)
+                test_unsetindex(A, B)
+            end
+        end
+    end
 end

From 5c14d338e58be46bc6cd79e97bacb868adfbc355 Mon Sep 17 00:00:00 2001
From: Sebastien Marie <8948701+semarie@users.noreply.github.com>
Date: Tue, 20 Feb 2024 18:06:23 +0100
Subject: [PATCH 0979/1315] posix compatibility: avoid using ln -v (#53396)

the PR removes `-v` argument from `ln` invocation. it permits to stick
to POSIX `ln` version without using extension.

it is part of on-going work to port julia to OpenBSD.
---
 base/Makefile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/Makefile b/base/Makefile
index 6abf9b285ce34..9a6c0d0d03833 100644
--- a/base/Makefile
+++ b/base/Makefile
@@ -203,7 +203,7 @@ endif
 $(build_bindir)/7z$(EXE):
 	[ -e "$(7Z_PATH)" ] && \
 	rm -f "$@" && \
-	ln -svf "$(7Z_PATH)" "$@"
+	ln -sf "$(7Z_PATH)" "$@"
 
 symlink_llvm_utils: $(build_depsbindir)/lld$(EXE) $(build_depsbindir)/dsymutil$(EXE)
 
@@ -216,12 +216,12 @@ endif
 $(build_depsbindir)/lld$(EXE):
 	[ -e "$(LLD_PATH)" ] && \
 	rm -f "$@" && \
-	ln -svf "$(LLD_PATH)" "$@"
+	ln -sf "$(LLD_PATH)" "$@"
 
 $(build_depsbindir)/dsymutil$(EXE):
 	[ -e "$(DSYMUTIL_PATH)" ] && \
 	rm -f "$@" && \
-	ln -svf "$(DSYMUTIL_PATH)" "$@"
+	ln -sf "$(DSYMUTIL_PATH)" "$@"
 
 # the following excludes: libuv.a, libutf8proc.a
 

From fbc766aa9869e914e9540f5ad5b7ec03ccfcd47d Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Wed, 21 Feb 2024 01:21:58 +0800
Subject: [PATCH 0980/1315] More consistent return value for annotations, take
 2 (#53333)

Relands #53281 with some fixes noticed, though not the original causes
of the failure.
---
 base/strings/annotated.jl                     | 27 ++++++++++++-------
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 stdlib/StyledStrings.version                  |  2 +-
 6 files changed, 20 insertions(+), 13 deletions(-)
 delete mode 100644 deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
 create mode 100644 deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 1eeaaa668d9ee..1b1130335f013 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -153,7 +153,7 @@ lastindex(s::AnnotatedString) = lastindex(s.string)
 function getindex(s::AnnotatedString, i::Integer)
     @boundscheck checkbounds(s, i)
     @inbounds if isvalid(s, i)
-        AnnotatedChar(s.string[i], annotations(s, i))
+        AnnotatedChar(s.string[i], map(last, annotations(s, i)))
     else
         string_index_err(s, i)
     end
@@ -356,37 +356,44 @@ annotate!(c::AnnotatedChar, @nospecialize(labelval::Pair{Symbol, <:Any})) =
     (push!(c.annotations, labelval); c)
 
 """
-    annotations(str::AnnotatedString, [position::Union{Integer, UnitRange}])
-    annotations(str::SubString{AnnotatedString}, [position::Union{Integer, UnitRange}])
+    annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
+                [position::Union{Integer, UnitRange}]) ->
+        Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}
 
 Get all annotations that apply to `str`. Should `position` be provided, only
 annotations that overlap with `position` will be returned.
 
+Annotations are provided together with the regions they apply to, in the form of
+a vector of region–annotation tuples.
+
 See also: `annotate!`.
 """
 annotations(s::AnnotatedString) = s.annotations
 
-annotations(s::SubString{<:AnnotatedString}) =
-    annotations(s, s.offset+1:s.offset+s.ncodeunits)
+function annotations(s::SubString{<:AnnotatedString})
+    map(((region, annot),) -> (first(region)-s.offset:last(region)-s.offset, annot),
+        annotations(s.string, s.offset+1:s.offset+s.ncodeunits))
+end
 
 function annotations(s::AnnotatedString, pos::UnitRange{<:Integer})
     # TODO optimise
-    annots = filter(label -> !isempty(intersect(pos, first(label))),
-                    s.annotations)
-    last.(annots)
+    Tuple{UnitRange{Int64}, Pair{Symbol, Any}}[
+        (max(first(pos), first(region)):min(last(pos), last(region)), annot)
+        for (region, annot) in s.annotations if !isempty(intersect(pos, region))]
 end
 
 annotations(s::AnnotatedString, pos::Integer) = annotations(s, pos:pos)
 
 annotations(s::SubString{<:AnnotatedString}, pos::Integer) =
     annotations(s.string, s.offset + pos)
+
 annotations(s::SubString{<:AnnotatedString}, pos::UnitRange{<:Integer}) =
     annotations(s.string, first(pos)+s.offset:last(pos)+s.offset)
 
 """
-    annotations(chr::AnnotatedChar)
+    annotations(chr::AnnotatedChar) -> Vector{Pair{Symbol, Any}}
 
-Get all annotations of `chr`.
+Get all annotations of `chr`, in the form of a vector of annotation pairs.
 """
 annotations(c::AnnotatedChar) = c.annotations
 
diff --git a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5 b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
deleted file mode 100644
index fc675ee83125a..0000000000000
--- a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-c1fd1bb7e3f9ab00afe0758a8a101374
diff --git a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512 b/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
deleted file mode 100644
index 09d5a8a619295..0000000000000
--- a/deps/checksums/StyledStrings-a1b2ae2434cd7d8199fa8647339422fe0e1d0324.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-373302f1d32a5b5ad0efacf14fa82a16fd877c11ca589fc1f1492eb1d4bcd0f49a2a5a3f471f8577649309c8a03634e7467e31b403cfd6ab8a8e4a775d7f4e53
diff --git a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5 b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
new file mode 100644
index 0000000000000..2ab79799cca0e
--- /dev/null
+++ b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
@@ -0,0 +1 @@
+fc3a846400107c432d20da6cfdd19ccf
diff --git a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512 b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512
new file mode 100644
index 0000000000000..70b0ef6f5cb3a
--- /dev/null
+++ b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512
@@ -0,0 +1 @@
+22da8964cc4c09f7c7a3da44be14c953f520ce6d395cf0f9ccf9c17777d6d968b0a874b35c072801ef7a1f4eee40f96ea0e2fc5ed5b3a63ad0b6b776a9c14ebb
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index 8180223575f05..19a5a24514f2f 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = a1b2ae2434cd7d8199fa8647339422fe0e1d0324
+STYLEDSTRINGS_SHA1 = e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1

From 3351e574e386b44ff361daa4ade8eb23270d951e Mon Sep 17 00:00:00 2001
From: Sebastien Marie <8948701+semarie@users.noreply.github.com>
Date: Tue, 20 Feb 2024 19:32:36 +0100
Subject: [PATCH 0981/1315] jlchecksum: use sha512 if present (#53397)

Add the BSD `sha512` binary for checking sha512 checksum (note that
this is completely unrelated to the debian binary of the same name from
`hashalot`).

While here, silence `which` error message about unavailable binaries.
---
 deps/tools/jlchecksum | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/deps/tools/jlchecksum b/deps/tools/jlchecksum
index 87db805dbfab3..329d3a2a845d4 100755
--- a/deps/tools/jlchecksum
+++ b/deps/tools/jlchecksum
@@ -87,15 +87,17 @@ SHA512_PROG=""
 MD5_PROG=""
 find_checksum_progs()
 {
-    if [ ! -z $(which sha512sum) ]; then
+    if [ ! -z $(which sha512sum 2>/dev/null) ]; then
         SHA512_PROG="sha512sum $ARG1 | awk '{ print \$1; }'"
-    elif [ ! -z $(which shasum) ]; then
+    elif [ ! -z $(which shasum 2>/dev/null) ]; then
         SHA512_PROG="shasum -a 512 $ARG1 | awk '{ print \$1; }'"
+    elif [ ! -z $(which sha512 2>/dev/null) ]; then
+        SHA512_PROG="sha512 -q $ARG1"
     fi
 
-    if [ ! -z $(which md5sum) ]; then
+    if [ ! -z $(which md5sum 2>/dev/null) ]; then
         MD5_PROG="md5sum $ARG1 | awk '{ print \$1; }'"
-    elif [ ! -z $(which md5) ]; then
+    elif [ ! -z $(which md5 2>/dev/null) ]; then
         MD5_PROG="md5 -q $ARG1"
     fi
 }

From d12a620463ed78b26635ac8f0b6526a391c5c6fe Mon Sep 17 00:00:00 2001
From: Christian Guinard <28689358+christiangnrd@users.noreply.github.com>
Date: Tue, 20 Feb 2024 17:00:02 -0400
Subject: [PATCH 0982/1315] Fix NEWS.md (#53411)

Closes #53409
Closes #53410
---
 NEWS.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index 15821f2744e0a..6b5fd28082b9b 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -74,3 +74,5 @@ External dependencies
 
 Tooling Improvements
 --------------------
+
+<!--- generated by NEWS-update.jl: -->

From 61fc907a225eb642fd180257a02e5951336dabe4 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 20 Feb 2024 16:42:30 -0500
Subject: [PATCH 0983/1315] fix code coverage bug in tail position and `else`
 (#53354)

This was due to lowering keeping the same location info for the inserted
`return` or `goto` statement, even though the last seen location might
not have executed.

Also fixes inliner handling of the sentinel `0` value for code
locations.
---
 base/compiler/ssair/inlining.jl |  4 +-
 base/compiler/ssair/passes.jl   |  6 ++-
 src/julia-syntax.scm            | 83 +++++++++++++++++++--------------
 test/cmdlineargs.jl             | 63 +++++++++++++++++++++++++
 test/show.jl                    |  2 +-
 test/syntax.jl                  |  2 +-
 6 files changed, 121 insertions(+), 39 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 74d3987ee0257..d4228cf3c4454 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1818,7 +1818,9 @@ end
 
 function ssa_substitute!(insert_node!::Inserter, subst_inst::Instruction, @nospecialize(val),
                          ssa_substitute::SSASubstitute)
-    subst_inst[:line] += ssa_substitute.linetable_offset
+    if subst_inst[:line] != 0
+        subst_inst[:line] += ssa_substitute.linetable_offset
+    end
     return ssa_substitute_op!(insert_node!, subst_inst, val, ssa_substitute)
 end
 
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index fe587f82a9def..5ea21c85427be 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1519,8 +1519,12 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
             ssa_rename[ssa.id]
         end
         stmt′ = ssa_substitute_op!(InsertBefore(ir, SSAValue(idx)), inst, stmt′, ssa_substitute)
+        newline = inst[:line]
+        if newline != 0
+            newline += ssa_substitute.linetable_offset
+        end
         ssa_rename[idx′] = insert_node!(ir, idx,
-            NewInstruction(inst; stmt=stmt′, line=inst[:line]+ssa_substitute.linetable_offset),
+            NewInstruction(inst; stmt=stmt′, line=newline),
             attach_after)
     end
 
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 674a04cb1e563..7d9f8711ec714 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -4371,7 +4371,7 @@ f(x) = yt(x)
             (if (eq? (cdr s) dest-tokens)
                 (cons (car s) l)
                 (loop (cdr s) (cons (car s) l))))))
-    (define (emit-return x)
+    (define (emit-return tail x)
       (define (emit- x)
         (let* ((tmp (if ((if (null? catch-token-stack) valid-ir-return? simple-atom?) x)
                         #f
@@ -4380,8 +4380,12 @@ f(x) = yt(x)
               (begin (emit `(= ,tmp ,x)) tmp)
               x)))
       (define (actually-return x)
-        (let* ((x (if rett
-                      (compile (convert-for-type-decl (emit- x) rett #t lam) '() #t #f)
+        (let* ((x (begin0 (emit- x)
+                          ;; if we are adding an implicit return then mark it as having no location
+                          (if (not (eq? tail 'explicit))
+                              (emit '(line #f)))))
+               (x (if rett
+                      (compile (convert-for-type-decl x rett #t lam) '() #t #f)
                       x))
                (x (emit- x)))
           (let ((pexc (pop-exc-expr catch-token-stack '())))
@@ -4531,7 +4535,7 @@ f(x) = yt(x)
                                                   (eq? (car e) 'globalref))
                                     (underscore-symbol? (cadr e)))))
                 (error (string "all-underscore identifiers are write-only and their values cannot be used in expressions" (format-loc current-loc))))
-            (cond (tail  (emit-return e1))
+            (cond (tail  (emit-return tail e1))
                   (value e1)
                   ((symbol? e1) (emit e1) #f)  ;; keep symbols for undefined-var checking
                   ((and (pair? e1) (eq? (car e1) 'outerref)) (emit e1) #f)  ;; keep globals for undefined-var checking
@@ -4577,7 +4581,7 @@ f(x) = yt(x)
                            (else
                             (compile-args (cdr e) break-labels))))
                     (callex (cons (car e) args)))
-               (cond (tail (emit-return callex))
+               (cond (tail (emit-return tail callex))
                      (value callex)
                      (else (emit callex)))))
             ((=)
@@ -4594,7 +4598,7 @@ f(x) = yt(x)
                            (if (not (eq? rr rhs))
                                (emit `(= ,rr ,rhs)))
                            (emit `(= ,lhs ,rr))
-                           (if tail (emit-return rr))
+                           (if tail (emit-return tail rr))
                            rr)
                          (emit-assignment lhs rhs))))))
             ((block)
@@ -4647,7 +4651,7 @@ f(x) = yt(x)
                   (if file-diff (set! filename last-fname))
                   v)))
             ((return)
-             (compile (cadr e) break-labels #t #t)
+             (compile (cadr e) break-labels #t 'explicit)
              #f)
             ((unnecessary)
              ;; `unnecessary` marks expressions generated by lowering that
@@ -4662,7 +4666,8 @@ f(x) = yt(x)
                (let ((v1 (compile (caddr e) break-labels value tail)))
                  (if val (emit-assignment val v1))
                  (if (and (not tail) (or (length> e 3) val))
-                     (emit end-jump))
+                     (begin (emit `(line #f))
+                            (emit end-jump)))
                  (let ((elselabel (make&mark-label)))
                    (for-each (lambda (test)
                                (set-car! (cddr test) elselabel))
@@ -4674,7 +4679,7 @@ f(x) = yt(x)
                    (if (not tail)
                        (set-car! (cdr end-jump) (make&mark-label))
                        (if (length= e 3)
-                           (emit-return v2)))
+                           (emit-return tail v2)))
                    val))))
             ((_while)
              (let* ((endl (make-label))
@@ -4716,7 +4721,7 @@ f(x) = yt(x)
                    (emit `(label ,m))
                    (put! label-map (cadr e) (make&mark-label)))
                (if tail
-                   (emit-return '(null))
+                   (emit-return tail '(null))
                    (if value (error "misplaced label")))))
             ((symbolicgoto)
              (let* ((m (get label-map (cadr e) #f))
@@ -4762,7 +4767,7 @@ f(x) = yt(x)
                      (begin (if els
                                 (begin (if (and (not val) v1) (emit v1))
                                        (emit `(leave ,handler-token)))
-                                (if v1 (emit-return v1)))
+                                (if v1 (emit-return tail v1)))
                             (if (not finally) (set! endl #f)))
                      (begin (emit `(leave ,handler-token))
                             (emit `(goto ,(or els endl)))))
@@ -4794,7 +4799,7 @@ f(x) = yt(x)
                                           (emit `(= ,tmp (call (core ===) ,finally ,(caar actions))))
                                           (emit `(gotoifnot ,tmp ,skip))))
                                     (let ((ac (cdar actions)))
-                                      (cond ((eq? (car ac) 'return) (emit-return (cadr ac)))
+                                      (cond ((eq? (car ac) 'return) (emit-return tail (cadr ac)))
                                             ((eq? (car ac) 'break)  (emit-break (cadr ac)))
                                             (else ;; assumed to be a rethrow
                                              (emit ac))))
@@ -4833,8 +4838,8 @@ f(x) = yt(x)
                          (set! global-const-error current-loc))
                      (emit e))))
             ((atomic) (error "misplaced atomic declaration"))
-            ((isdefined) (if tail (emit-return e) e))
-            ((boundscheck) (if tail (emit-return e) e))
+            ((isdefined) (if tail (emit-return tail e) e))
+            ((boundscheck) (if tail (emit-return tail e) e))
 
             ((method)
              (if (not (null? (cadr lam)))
@@ -4855,12 +4860,12 @@ f(x) = yt(x)
                                    l))))
                    (emit `(method ,(or (cadr e) '(false)) ,sig ,lam))
                    (if value (compile '(null) break-labels value tail)))
-                 (cond (tail  (emit-return e))
+                 (cond (tail  (emit-return tail e))
                        (value e)
                        (else  (emit e)))))
             ((lambda)
              (let ((temp (linearize e)))
-               (cond (tail  (emit-return temp))
+               (cond (tail  (emit-return tail temp))
                      (value temp)
                      (else  (emit temp)))))
 
@@ -4868,7 +4873,7 @@ f(x) = yt(x)
             ((thunk module)
              (check-top-level e)
              (emit e)
-             (if tail (emit-return '(null)))
+             (if tail (emit-return tail '(null)))
              '(null))
             ((toplevel-only)
              (check-top-level (cdr e))
@@ -4878,7 +4883,7 @@ f(x) = yt(x)
              (check-top-level e)
              (let ((val (make-ssavalue)))
                (emit `(= ,val ,e))
-               (if tail (emit-return val))
+               (if tail (emit-return tail val))
                val))
 
             ;; other top level expressions
@@ -4887,7 +4892,7 @@ f(x) = yt(x)
              (emit e)
              (let ((have-ret? (and (pair? code) (pair? (car code)) (eq? (caar code) 'return))))
                (if (and tail (not have-ret?))
-                   (emit-return '(null))))
+                   (emit-return tail '(null))))
              '(null))
 
             ((gc_preserve_begin)
@@ -4911,7 +4916,7 @@ f(x) = yt(x)
                      (else
                       (emit e)))
                (if (and tail (not have-ret?))
-                   (emit-return '(null)))
+                   (emit-return tail '(null)))
                '(null)))
 
             ;; unsupported assignment operators
@@ -5027,6 +5032,7 @@ f(x) = yt(x)
         (labltable    (table))
         (ssavtable    (table))
         (current-loc  0)
+        (nowhere      #f)
         (current-file file)
         (current-line line)
         (locstack     '())
@@ -5040,26 +5046,33 @@ f(x) = yt(x)
                  (set! current-loc 1)))
       (set! code (cons e code))
       (set! i (+ i 1))
-      (set! locs (cons current-loc locs)))
+      (set! locs (cons (if nowhere 0 current-loc) locs))
+      (set! nowhere #f))
     (let loop ((stmts (cdr body)))
       (if (pair? stmts)
           (let ((e (car stmts)))
             (cond ((atom? e) (emit e))
                   ((eq? (car e) 'line)
-                   (if (and (= current-line 0) (length= e 2) (pair? linetable))
-                       ;; (line n) after push_loc just updates the line for the new file
-                       (begin (set-lineno! (car linetable) (cadr e))
-                              (set! current-line (cadr e)))
-                       (begin
-                         (set! current-line (cadr e))
-                         (if (pair? (cddr e))
-                             (set! current-file (caddr e)))
-                         (set! linetable (cons (if (null? locstack)
-                                                   (make-lineinfo name current-file current-line)
-                                                   (make-lineinfo name current-file current-line (caar locstack)))
-                                               linetable))
-                         (set! linetablelen (+ linetablelen 1))
-                         (set! current-loc linetablelen))))
+                   (cond ((and (length= e 2) (not (cadr e)))
+                          ;; (line #f) marks that we are entering a generated statement
+                          ;; that should not be counted as belonging to the previous marked location,
+                          ;; for example `return` after a not-executed `if` arm in tail position.
+                          (set! nowhere #t))
+                         ((and (= current-line 0) (length= e 2) (pair? linetable))
+                          ;; (line n) after push_loc just updates the line for the new file
+                          (begin (set-lineno! (car linetable) (cadr e))
+                                 (set! current-line (cadr e))))
+                         (else
+                          (begin
+                            (set! current-line (cadr e))
+                            (if (pair? (cddr e))
+                                (set! current-file (caddr e)))
+                            (set! linetable (cons (if (null? locstack)
+                                                      (make-lineinfo name current-file current-line)
+                                                      (make-lineinfo name current-file current-line (caar locstack)))
+                                                  linetable))
+                            (set! linetablelen (+ linetablelen 1))
+                            (set! current-loc linetablelen)))))
                   ((and (length> e 2) (eq? (car e) 'meta) (eq? (cadr e) 'push_loc))
                    (set! locstack (cons (list current-loc current-line current-file) locstack))
                    (set! current-file (caddr e))
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 434f6be0d8b05..3af31965e63fc 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -545,6 +545,69 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         got = read(covfile, String)
         @test isempty(got)
         rm(covfile)
+
+        function coverage_info_for(src::String)
+            mktemp(dir) do srcfile, io
+                write(io, src); close(io)
+                outfile = tempname(dir, cleanup=false)*".info"
+                run(`$exename --code-coverage=$outfile $srcfile`)
+                result = read(outfile, String)
+                rm(outfile, force=true)
+                result
+            end
+        end
+        @test contains(coverage_info_for("""
+            function cov_bug(x, p)
+                if p > 2
+                    print("")  # runs
+                end
+                if Base.compilerbarrier(:const, false)
+                    println("Does not run")
+                end
+            end
+            function do_test()
+                cov_bug(5, 3)
+            end
+            do_test()
+            """), """
+            DA:1,1
+            DA:2,1
+            DA:3,1
+            DA:5,1
+            DA:6,0
+            DA:9,1
+            DA:10,1
+            LH:6
+            LF:7
+            """)
+        @test contains(coverage_info_for("""
+            function cov_bug()
+                if Base.compilerbarrier(:const, true)
+                    if Base.compilerbarrier(:const, true)
+                        if Base.compilerbarrier(:const, false)
+                            println("Does not run")
+                        end
+                    else
+                        print("Does not run either")
+                    end
+                else
+                    print("")
+                end
+                return nothing
+            end
+            cov_bug()
+            """), """
+            DA:1,1
+            DA:2,1
+            DA:3,1
+            DA:4,1
+            DA:5,0
+            DA:8,0
+            DA:11,0
+            DA:13,1
+            LH:5
+            LF:8
+            """)
     end
 
     # --track-allocation
diff --git a/test/show.jl b/test/show.jl
index d6a691029d60a..66286f4df12ba 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2106,7 +2106,7 @@ let src = code_typed(my_fun28173, (Int,), debuginfo=:source)[1][1]
     io = IOBuffer()
     Base.IRShow.show_ir(io, ir, Base.IRShow.default_config(ir; verbose_linetable=true))
     seekstart(io)
-    @test count(contains(r"@ a{80}:\d+ within `my_fun28173"), eachline(io)) == 11
+    @test count(contains(r"@ a{80}:\d+ within `my_fun28173"), eachline(io)) == 10
 
     # Test that a bad :invoke doesn't cause an error during printing
     Core.Compiler.insert_node!(ir, 1, Core.Compiler.NewInstruction(Expr(:invoke, nothing, sin), Any), false)
diff --git a/test/syntax.jl b/test/syntax.jl
index a0021864da0e0..25d3e7282818a 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -713,7 +713,7 @@ m1_exprs = get_expr_list(Meta.lower(@__MODULE__, quote @m1 end))
 let low3 = Meta.lower(@__MODULE__, quote @m3 end)
     m3_exprs = get_expr_list(low3)
     ci = low3.args[1]::Core.CodeInfo
-    @test ci.codelocs in ([4, 4, 2], [4, 2])
+    @test ci.codelocs in ([4, 4, 0], [4, 0])
     @test is_return_ssavalue(m3_exprs[end])
 end
 

From 3742d33ecc9048bb925ad89020751702c45f18a2 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 20 Feb 2024 23:07:24 -0500
Subject: [PATCH 0984/1315] fix sysimage-native-code=yes option (#53407)

Follow up to #53373, it seems this assert was broken for empty packages,
causing CI issues. It is not necessary.

Observed in CI here: https://github.com/JuliaLang/julia/pull/53395

https://buildkite.com/julialang/julia-master/builds/33860#018dc4dc-a603-4ad1-90cf-574540a41720
---
 src/staticdata.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/staticdata.c b/src/staticdata.c
index abcdd76dac507..eab19607d9eba 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -3092,11 +3092,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
 
     // in --build mode only use sysimg data, not precompiled native code
     int imaging_mode = jl_generating_output() && !jl_options.incremental;
-    if (!imaging_mode && jl_options.use_sysimage_native_code == JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES) {
-        if (image->gvars_base)
-            assert(image->fptrs.ptrs);
-    }
-    else {
+    if (imaging_mode || jl_options.use_sysimage_native_code != JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES) {
         memset(&image->fptrs, 0, sizeof(image->fptrs));
         image->gvars_base = NULL;
     }

From 9d896dc9f1f105b33aa50ad07bb41d4061e2d439 Mon Sep 17 00:00:00 2001
From: Nathan Zimmerberg <39104088+nhz2@users.noreply.github.com>
Date: Tue, 20 Feb 2024 23:07:45 -0500
Subject: [PATCH 0985/1315] Throw OverflowError on `copysign(typemin(Int)//1,
 1)` (#53395)

The default `copysign(x::Real, y::Real)` in `number.jl` works, so the
incorrect method in `rational.jl` isn't needed.

Here is a benchmark of the new version.
```julia
using BenchmarkTools
function foo!(c,a,b)
    c .= copysign.(a, b)
    nothing
end
N = 1000
@btime foo!(c,a,b) setup=(c=zeros(Rational{Int},N); a=rand(Int,N).//rand(Int,N); b=fill(-1,N))
```
On master: 406.215 ns (0 allocations: 0 bytes)
On this PR: 869.327 ns (0 allocations: 0 bytes)
---
 base/rational.jl | 2 --
 test/numbers.jl  | 3 +++
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/base/rational.jl b/base/rational.jl
index b27baf5973d3b..bd1633bd3dd28 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -315,8 +315,6 @@ denominator(x::Rational) = x.den
 
 sign(x::Rational) = oftype(x, sign(x.num))
 signbit(x::Rational) = signbit(x.num)
-copysign(x::Rational, y::Real) = unsafe_rational(copysign(x.num, y), x.den)
-copysign(x::Rational, y::Rational) = unsafe_rational(copysign(x.num, y.num), x.den)
 
 abs(x::Rational) = unsafe_rational(checked_abs(x.num), x.den)
 
diff --git a/test/numbers.jl b/test/numbers.jl
index 922fa0da3337e..47d7e87753b11 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -679,6 +679,9 @@ end
     @test copysign(big(-1), 0x02) == 1
     @test copysign(big(-1.0), 0x02) == 1.0
     @test copysign(-1//2, 0x01) == 1//2
+
+    # Verify overflow is checked with rational
+    @test_throws OverflowError copysign(typemin(Int)//1, 1)
 end
 
 @testset "isnan/isinf/isfinite" begin

From 4e7294423f4462244617af6f9eea425bd06a78a6 Mon Sep 17 00:00:00 2001
From: Sebastien Marie <semarie@kapouay.eu.org>
Date: Wed, 21 Feb 2024 09:49:58 +0100
Subject: [PATCH 0986/1315] posix compatibility: avoid grep GNU extension
 (#53400)

the `.\+` meta-character is a GNU extension. prefer to use the POSIX
equivalent `..*` to work with `grep` on wider platforms.

it is part of on-going work to port julia to OpenBSD.
---
 src/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Makefile b/src/Makefile
index 5f58c7fa57627..ce81ff03cdd70 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -230,7 +230,7 @@ $(BUILDDIR)/jl_internal_funcs.inc: $(SRCDIR)/jl_exported_funcs.inc
 	# to have a `ijl_` prefix instead of `jl_`, to denote that they are coming from `libjulia-internal`.  This avoids
 	# potential confusion with debugging tools, when inspecting a process that has both `libjulia` and `libjulia-internal`
 	# loaded at the same time.
-	grep 'XX(.\+)' $< | sed -E 's/.*XX\((.+)\).*/#define \1 i\1/g' >$@
+	grep 'XX(..*)' $< | sed -E 's/.*XX\((.+)\).*/#define \1 i\1/g' >$@
 
 # source file rules
 $(BUILDDIR)/%.o: $(SRCDIR)/%.c $(HEADERS) | $(BUILDDIR)

From f2c6334193a63aad46897477e147b08212a56485 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 19 Feb 2024 21:04:33 +0000
Subject: [PATCH 0987/1315] undo breaking change of removing parent from
 CodeInfo

The loss provided no value, as it is easy to provide this info, and has
downstream users as well as being documented for use.
---
 base/compiler/ssair/legacy.jl             | 2 ++
 base/compiler/typeinfer.jl                | 1 +
 base/compiler/utilities.jl                | 1 +
 base/reflection.jl                        | 4 ++--
 src/aotcompile.cpp                        | 6 +++---
 src/codegen.cpp                           | 4 ++--
 src/interpreter.c                         | 4 ++--
 src/ircode.c                              | 5 ++++-
 src/jitlayers.cpp                         | 2 +-
 src/jltypes.c                             | 8 +++++---
 src/julia.h                               | 3 ++-
 src/method.c                              | 1 +
 src/staticdata.c                          | 2 +-
 stdlib/Serialization/src/Serialization.jl | 3 ++-
 14 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/base/compiler/ssair/legacy.jl b/base/compiler/ssair/legacy.jl
index b1ce14f28cf14..3e9a4e2a746dc 100644
--- a/base/compiler/ssair/legacy.jl
+++ b/base/compiler/ssair/legacy.jl
@@ -55,6 +55,8 @@ Mainly used for testing or interactive use.
 inflate_ir(ci::CodeInfo, linfo::MethodInstance) = inflate_ir!(copy(ci), linfo)
 inflate_ir(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{Any}) = inflate_ir!(copy(ci), sptypes, argtypes)
 function inflate_ir(ci::CodeInfo)
+    parent = ci.parent
+    isa(parent, MethodInstance) && return inflate_ir(ci, parent)
     # XXX the length of `ci.slotflags` may be different from the actual number of call
     # arguments, but we really don't know that information in this case
     argtypes = Any[ Any for i = 1:length(ci.slotflags) ]
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 783bea60e3575..7ea157699e202 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -930,6 +930,7 @@ function codeinfo_for_const(interp::AbstractInterpreter, mi::MethodInstance, @no
     tree.linetable = LineInfoNode[LineInfoNode(method.module, method.name, method.file, method.line, Int32(0))]
     tree.ssaflags = UInt32[0]
     set_inlineable!(tree, true)
+    tree.parent = mi
     return tree
 end
 
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 66b5d3d15624b..a810f92c8f87c 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -149,6 +149,7 @@ function retrieve_code_info(linfo::MethodInstance, world::UInt)
         end
     end
     if c isa CodeInfo
+        c.parent = linfo
         return c
     end
     return nothing
diff --git a/base/reflection.jl b/base/reflection.jl
index 7f7d3ccf0a144..de9cf6951ec87 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1317,8 +1317,8 @@ uncompressed_ir(m::Method) = isdefined(m, :source) ? _uncompressed_ir(m, m.sourc
                              isdefined(m, :generator) ? error("Method is @generated; try `code_lowered` instead.") :
                              error("Code for this Method is not available.")
 _uncompressed_ir(m::Method, s::CodeInfo) = copy(s)
-_uncompressed_ir(m::Method, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any), m, s)::CodeInfo
-_uncompressed_ir(ci::Core.CodeInstance, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any), ci.def.def::Method, s)::CodeInfo
+_uncompressed_ir(m::Method, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), m, C_NULL, s)::CodeInfo
+_uncompressed_ir(ci::Core.CodeInstance, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any, Any), ci.def.def::Method, ci, s)::CodeInfo
 # for backwards compat
 const uncompressed_ast = uncompressed_ir
 const _uncompressed_ast = _uncompressed_ir
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 54c92fb688d30..c07f7bf32780a 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -301,7 +301,7 @@ static void jl_ci_cache_lookup(const jl_cgparams_t &cgparams, jl_method_instance
         if ((jl_value_t*)*src_out == jl_nothing)
             *src_out = NULL;
         if (*src_out && jl_is_method(def))
-            *src_out = jl_uncompress_ir(def, (jl_value_t*)*src_out);
+            *src_out = jl_uncompress_ir(def, codeinst, (jl_value_t*)*src_out);
     }
     if (*src_out == NULL || !jl_is_code_info(*src_out)) {
         if (cgparams.lookup != jl_rettype_inferred_addr) {
@@ -1950,7 +1950,7 @@ extern "C" JL_DLLEXPORT_CODEGEN jl_code_info_t *jl_gdbdumpcode(jl_method_instanc
         src = (jl_code_info_t*)jl_atomic_load_relaxed(&codeinst->inferred);
         if ((jl_value_t*)src != jl_nothing && !jl_is_code_info(src) && jl_is_method(mi->def.method)) {
             JL_GC_PUSH2(&codeinst, &src);
-            src = jl_uncompress_ir(mi->def.method, (jl_value_t*)src);
+            src = jl_uncompress_ir(mi->def.method, codeinst, (jl_value_t*)src);
             JL_GC_POP();
         }
     }
@@ -1989,7 +1989,7 @@ void jl_get_llvmf_defn_impl(jl_llvmf_dump_t* dump, jl_method_instance_t *mi, siz
     }
     if (src) {
         if ((jl_value_t*)src != jl_nothing && !jl_is_code_info(src) && jl_is_method(mi->def.method))
-            src = jl_uncompress_ir(mi->def.method, (jl_value_t*)src);
+            src = jl_uncompress_ir(mi->def.method, codeinst, (jl_value_t*)src);
     }
 
     // emit this function into a new llvm module
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 93fc1b9a680e2..c8e1ba9d4bdc7 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -6015,7 +6015,7 @@ static std::pair<Function*, Function*> get_oc_function(jl_codectx_t &ctx, jl_met
 
     if (it == ctx.emission_context.compiled_functions.end()) {
         ++EmittedOpaqueClosureFunctions;
-        jl_code_info_t *ir = jl_uncompress_ir(closure_method, (jl_value_t*)inferred);
+        jl_code_info_t *ir = jl_uncompress_ir(closure_method, ci, (jl_value_t*)inferred);
         JL_GC_PUSH1(&ir);
         // TODO: Emit this inline and outline it late using LLVM's coroutine support.
         orc::ThreadSafeModule closure_m = jl_create_ts_module(
@@ -9570,7 +9570,7 @@ jl_llvm_functions_t jl_emit_codeinst(
             return jl_emit_oc_wrapper(m, params, codeinst->def, codeinst->rettype);
         }
         if (src && (jl_value_t*)src != jl_nothing && jl_is_method(def))
-            src = jl_uncompress_ir(def, (jl_value_t*)src);
+            src = jl_uncompress_ir(def, codeinst, (jl_value_t*)src);
         if (!src || !jl_is_code_info(src)) {
             JL_GC_POP();
             m = orc::ThreadSafeModule();
diff --git a/src/interpreter.c b/src/interpreter.c
index ffc8c6d8c12ea..5102d1417c939 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -696,7 +696,7 @@ jl_code_info_t *jl_code_for_interpreter(jl_method_instance_t *mi, size_t world)
         }
         if (src && (jl_value_t*)src != jl_nothing) {
             JL_GC_PUSH1(&src);
-            src = jl_uncompress_ir(mi->def.method, (jl_value_t*)src);
+            src = jl_uncompress_ir(mi->def.method, NULL, (jl_value_t*)src);
             jl_atomic_store_release(&mi->uninferred, (jl_value_t*)src);
             jl_gc_wb(mi, src);
             JL_GC_POP();
@@ -758,7 +758,7 @@ JL_DLLEXPORT const jl_callptr_t jl_fptr_interpret_call_addr = &jl_fptr_interpret
 jl_value_t *jl_interpret_opaque_closure(jl_opaque_closure_t *oc, jl_value_t **args, size_t nargs)
 {
     jl_method_t *source = oc->source;
-    jl_code_info_t *code = jl_uncompress_ir(source, (jl_value_t*)source->source);
+    jl_code_info_t *code = jl_uncompress_ir(source, NULL, (jl_value_t*)source->source);
     interpreter_state *s;
     unsigned nroots = jl_source_nslots(code) + jl_source_nssavalues(code) + 2;
     jl_task_t *ct = jl_current_task;
diff --git a/src/ircode.c b/src/ircode.c
index 46d2fd82253de..90dab5f63d494 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -894,7 +894,7 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
     return v;
 }
 
-JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_string_t *data)
+JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t *metadata, jl_string_t *data)
 {
     if (jl_is_code_info(data))
         return (jl_code_info_t*)data;
@@ -969,6 +969,9 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_string_t *data)
     jl_gc_enable(en);
     JL_UNLOCK(&m->writelock); // Might GC
     JL_GC_POP();
+    if (metadata) {
+        code->parent = metadata->def;
+    }
 
     return code;
 }
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 3c2a6dd285af4..c3ccb5746e37a 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -498,7 +498,7 @@ void jl_generate_fptr_for_unspecialized_impl(jl_code_instance_t *unspec)
         if (jl_is_method(def)) {
             src = (jl_code_info_t*)def->source;
             if (src && (jl_value_t*)src != jl_nothing)
-                src = jl_uncompress_ir(def, (jl_value_t*)src);
+                src = jl_uncompress_ir(def, NULL, (jl_value_t*)src);
         }
         else {
             src = (jl_code_info_t*)jl_atomic_load_relaxed(&unspec->def->uninferred);
diff --git a/src/jltypes.c b/src/jltypes.c
index 0ecf00651438a..1d743e175cec9 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3142,7 +3142,7 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_code_info_type =
         jl_new_datatype(jl_symbol("CodeInfo"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(19,
+                        jl_perm_symsvec(20,
                             "code",
                             "codelocs",
                             "ssavaluetypes",
@@ -3151,6 +3151,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             "slotnames",
                             "slotflags",
                             "slottypes",
+                            "parent",
                             "method_for_inference_limit_heuristics",
                             "edges",
                             "min_world",
@@ -3162,7 +3163,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             "constprop",
                             "purity",
                             "inlining_cost"),
-                        jl_svec(19,
+                        jl_svec(20,
                             jl_array_any_type,
                             jl_array_int32_type,
                             jl_any_type,
@@ -3173,6 +3174,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_any_type,
                             jl_any_type,
                             jl_any_type,
+                            jl_any_type,
                             jl_ulong_type,
                             jl_ulong_type,
                             jl_bool_type,
@@ -3183,7 +3185,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_uint16_type,
                             jl_uint16_type),
                         jl_emptysvec,
-                        0, 1, 19);
+                        0, 1, 20);
 
     jl_method_type =
         jl_new_datatype(jl_symbol("Method"), core,
diff --git a/src/julia.h b/src/julia.h
index de5146aed7065..0505b1e88d4bb 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -294,6 +294,7 @@ typedef struct _jl_code_info_t {
     jl_array_t *slotflags;  // local var bit flags
     // the following are optional transient properties (not preserved by compression--as they typically get stored elsewhere):
     jl_value_t *slottypes; // inferred types of slots
+    jl_method_instance_t *parent; // context (after inference, otherwise nothing)
 
     // These may be used by generated functions to further constrain the resulting inputs.
     // They are not used by any other part of the system and may be moved elsewhere in the
@@ -2134,7 +2135,7 @@ JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr JL_MAYBE_UNROOTED);
 
 // IR representation
 JL_DLLEXPORT jl_value_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code);
-JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_value_t *data);
+JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t *metadata, jl_value_t *data);
 JL_DLLEXPORT uint8_t jl_ir_flag_inlining(jl_value_t *data) JL_NOTSAFEPOINT;
 JL_DLLEXPORT uint8_t jl_ir_flag_has_fcall(jl_value_t *data) JL_NOTSAFEPOINT;
 JL_DLLEXPORT uint16_t jl_ir_inlining_cost(jl_value_t *data) JL_NOTSAFEPOINT;
diff --git a/src/method.c b/src/method.c
index 15d2fd673e047..ab9487bbecad4 100644
--- a/src/method.c
+++ b/src/method.c
@@ -507,6 +507,7 @@ JL_DLLEXPORT jl_code_info_t *jl_new_code_info_uninit(void)
     src->slotflags = NULL;
     src->slotnames = NULL;
     src->slottypes = jl_nothing;
+    src->parent = (jl_method_instance_t*)jl_nothing;
     src->min_world = 1;
     src->max_world = ~(size_t)0;
     src->edges = jl_nothing;
diff --git a/src/staticdata.c b/src/staticdata.c
index eab19607d9eba..f899899aff242 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -2344,7 +2344,7 @@ static jl_value_t *strip_codeinfo_meta(jl_method_t *m, jl_value_t *ci_, int orig
     int compressed = 0;
     if (!jl_is_code_info(ci_)) {
         compressed = 1;
-        ci = jl_uncompress_ir(m, (jl_value_t*)ci_);
+        ci = jl_uncompress_ir(m, NULL, (jl_value_t*)ci_);
     }
     else {
         ci = (jl_code_info_t*)ci_;
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index 9e83fbe38f490..ebbbc85f11cba 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -1212,7 +1212,7 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
         ci.slottypes = deserialize(s)
         if format_version(s) <= 26
             deserialize(s) # rettype
-            deserialize(s) # parent
+            ci.parent = deserialize(s)
             world_or_edges = deserialize(s)
             pre_13 = isa(world_or_edges, Integer)
             if pre_13
@@ -1223,6 +1223,7 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
                 ci.max_world = reinterpret(UInt, deserialize(s))
             end
         else
+            ci.parent = deserialize(s)
             ci.method_for_inference_limit_heuristics = deserialize(s)
             ci.edges = deserialize(s)
             ci.min_world = reinterpret(UInt, deserialize(s))

From 70577632d8431895ba5abaa9b514dee0159b2c56 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 19 Feb 2024 21:35:58 +0000
Subject: [PATCH 0988/1315] fix cases where metadata was not being set
 correctly

---
 base/compiler/abstractinterpretation.jl   |  2 +-
 base/compiler/inferencestate.jl           |  2 +-
 base/compiler/optimize.jl                 | 16 +++---
 base/compiler/ssair/inlining.jl           | 65 ++++++++++++++---------
 base/compiler/ssair/passes.jl             |  7 ++-
 base/compiler/typeinfer.jl                | 39 +++++++-------
 base/compiler/utilities.jl                |  2 +-
 base/reflection.jl                        | 12 +++--
 stdlib/Serialization/src/Serialization.jl |  4 +-
 test/compiler/AbstractInterpreter.jl      | 16 +++---
 test/precompile.jl                        | 10 ++--
 11 files changed, 101 insertions(+), 74 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 21303f527e3f2..12eb9a03e323b 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1181,7 +1181,7 @@ function const_prop_methodinstance_heuristic(interp::AbstractInterpreter,
         if isa(code, CodeInstance)
             inferred = @atomic :monotonic code.inferred
             # TODO propagate a specific `CallInfo` that conveys information about this call
-            if inlining_policy(interp, inferred, NoCallInfo(), IR_FLAG_NULL) !== nothing
+            if src_inlining_policy(interp, inferred, NoCallInfo(), IR_FLAG_NULL)
                 return true
             end
         end
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 0cc79cb92df6b..663fd78c90dba 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -800,7 +800,7 @@ function IRInterpretationState(interp::AbstractInterpreter,
     @assert code.def === mi
     src = @atomic :monotonic code.inferred
     if isa(src, String)
-        src = _uncompressed_ir(mi.def, src)
+        src = _uncompressed_ir(code, src)
     else
         isa(src, CodeInfo) || return nothing
     end
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 3172c44c81158..d3c680f9308d3 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -107,21 +107,23 @@ is_declared_noinline(@nospecialize src::MaybeCompressed) =
 # OptimizationState #
 #####################
 
-function inlining_policy(interp::AbstractInterpreter,
+# return whether this src should be inlined. If so, retrieve_ir_for_inlining must return an IRCode from it
+function src_inlining_policy(interp::AbstractInterpreter,
     @nospecialize(src), @nospecialize(info::CallInfo), stmt_flag::UInt32)
     if isa(src, MaybeCompressed)
         src_inlineable = is_stmt_inline(stmt_flag) || is_inlineable(src)
-        return src_inlineable ? src : nothing
+        return src_inlineable
     elseif isa(src, IRCode)
-        return src
+        return true
     elseif isa(src, SemiConcreteResult)
-        return src
-    elseif isa(src, CodeInstance)
-        return inlining_policy(interp, src.inferred, info, stmt_flag)
+        return true
     end
-    return nothing
+    @assert !isa(src, CodeInstance) # handled by caller
+    return false
 end
 
+function inlining_policy end # deprecated legacy name used by Cthulhu
+
 struct InliningState{Interp<:AbstractInterpreter}
     edges::Vector{Any}
     world::UInt
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index d4228cf3c4454..a89583494ee13 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -838,7 +838,7 @@ function compileable_specialization(match::MethodMatch, effects::Effects,
 end
 
 struct InferredResult
-    src::Any
+    src::Any # CodeInfo or IRCode
     effects::Effects
     InferredResult(@nospecialize(src), effects::Effects) = new(src, effects)
 end
@@ -849,11 +849,9 @@ end
             # in this case function can be inlined to a constant
             return ConstantCase(quoted(code.rettype_const))
         end
-        src = @atomic :monotonic code.inferred
-        effects = decode_effects(code.ipo_purity_bits)
-        return InferredResult(src, effects)
+        return code
     end
-    return InferredResult(nothing, Effects())
+    return nothing
 end
 @inline function get_local_result(inf_result::InferenceResult)
     effects = inf_result.ipo_effects
@@ -887,7 +885,15 @@ function resolve_todo(mi::MethodInstance, result::Union{Nothing,InferenceResult,
         add_inlining_backedge!(et, mi)
         return inferred_result
     end
-    (; src, effects) = inferred_result
+    if inferred_result isa InferredResult
+        (; src, effects) = inferred_result
+    elseif inferred_result isa CodeInstance
+        src = @atomic :monotonic inferred_result.inferred
+        effects = decode_effects(inferred_result.ipo_purity_bits)
+    else
+        src = nothing
+        effects = Effects()
+    end
 
     # the duplicated check might have been done already within `analyze_method!`, but still
     # we need it here too since we may come here directly using a constant-prop' result
@@ -896,12 +902,13 @@ function resolve_todo(mi::MethodInstance, result::Union{Nothing,InferenceResult,
             compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
     end
 
-    src = inlining_policy(state.interp, src, info, flag)
-    src === nothing && return compileable_specialization(mi, effects, et, info;
-        compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
+    src_inlining_policy(state.interp, src, info, flag) ||
+        return compileable_specialization(mi, effects, et, info;
+            compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
 
     add_inlining_backedge!(et, mi)
-    ir = retrieve_ir_for_inlining(mi, src, preserve_local_sources)
+    ir = inferred_result isa CodeInstance  ? retrieve_ir_for_inlining(inferred_result, src) :
+                                             retrieve_ir_for_inlining(mi, src, preserve_local_sources)
     return InliningTodo(mi, ir, effects)
 end
 
@@ -919,14 +926,22 @@ function resolve_todo(mi::MethodInstance, @nospecialize(info::CallInfo), flag::U
         add_inlining_backedge!(et, mi)
         return cached_result
     end
-    (; src, effects) = cached_result
-
-    src = inlining_policy(state.interp, src, info, flag)
-
-    src === nothing && return nothing
+    if cached_result isa InferredResult
+        (; src, effects) = cached_result
+    elseif cached_result isa CodeInstance
+        src = @atomic :monotonic cached_result.inferred
+        effects = decode_effects(cached_result.ipo_purity_bits)
+    else
+        src = nothing
+        effects = Effects()
+    end
 
+    preserve_local_sources = true
+    src_inlining_policy(state.interp, src, info, flag) || return nothing
+    ir = cached_result isa CodeInstance  ? retrieve_ir_for_inlining(cached_result, src) :
+                                           retrieve_ir_for_inlining(mi, src, preserve_local_sources)
     add_inlining_backedge!(et, mi)
-    return InliningTodo(mi, retrieve_ir_for_inlining(mi, src), effects)
+    return InliningTodo(mi, ir, effects)
 end
 
 function validate_sparams(sparams::SimpleVector)
@@ -979,17 +994,17 @@ function analyze_method!(match::MethodMatch, argtypes::Vector{Any},
     return resolve_todo(mi, volatile_inf_result, info, flag, state; invokesig)
 end
 
-function retrieve_ir_for_inlining(mi::MethodInstance, src::String, ::Bool=true)
-    src = _uncompressed_ir(mi.def, src)
-    return inflate_ir!(src, mi)
+function retrieve_ir_for_inlining(cached_result::CodeInstance, src::MaybeCompressed)
+    src = _uncompressed_ir(cached_result, src)::CodeInfo
+    return inflate_ir!(src, cached_result.def)
 end
-function retrieve_ir_for_inlining(mi::MethodInstance, src::CodeInfo, preserve_local_sources::Bool=true)
+function retrieve_ir_for_inlining(mi::MethodInstance, src::CodeInfo, preserve_local_sources::Bool)
     if preserve_local_sources
         src = copy(src)
     end
     return inflate_ir!(src, mi)
 end
-function retrieve_ir_for_inlining(::MethodInstance, ir::IRCode, preserve_local_sources::Bool=true)
+function retrieve_ir_for_inlining(mi::MethodInstance, ir::IRCode, preserve_local_sources::Bool)
     if preserve_local_sources
         ir = copy(ir)
     end
@@ -1494,13 +1509,13 @@ function semiconcrete_result_item(result::SemiConcreteResult,
         return compileable_specialization(mi, result.effects, et, info;
             compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
     end
-    ir = inlining_policy(state.interp, result.ir, info, flag)
-    ir === nothing && return compileable_specialization(mi, result.effects, et, info;
-        compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
+    src_inlining_policy(state.interp, result.ir, info, flag) ||
+        return compileable_specialization(mi, result.effects, et, info;
+            compilesig_invokes=OptimizationParams(state.interp).compilesig_invokes)
 
     add_inlining_backedge!(et, mi)
     preserve_local_sources = OptimizationParams(state.interp).preserve_local_sources
-    ir = retrieve_ir_for_inlining(mi, ir, preserve_local_sources)
+    ir = retrieve_ir_for_inlining(mi, result.ir, preserve_local_sources)
     return InliningTodo(mi, ir, result.effects)
 end
 
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 5ea21c85427be..0d855f38cd286 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1492,12 +1492,11 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
         end
         src = @atomic :monotonic code.inferred
     else
-        src = nothing
+        return false
     end
 
-    src = inlining_policy(inlining.interp, src, info, IR_FLAG_NULL)
-    src === nothing && return false
-    src = retrieve_ir_for_inlining(mi, src)
+    src_inlining_policy(inlining.interp, src, info, IR_FLAG_NULL) || return false
+    src = retrieve_ir_for_inlining(code, src)
 
     # For now: Require finalizer to only have one basic block
     length(src.cfg.blocks) == 1 || return false
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 7ea157699e202..5af074498ca7e 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -310,11 +310,20 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
         end
     end
     relocatability = 0x0
+    owner = cache_owner(interp)
     if const_flags == 0x3 && can_discard_trees
         inferred_result = nothing
         relocatability = 0x1
     else
         inferred_result = transform_result_for_cache(interp, result.linfo, result.valid_worlds, result, can_discard_trees)
+        if inferred_result isa CodeInfo
+            uncompressed = inferred_result
+            inferred_result = maybe_compress_codeinfo(interp, result.linfo, inferred_result, can_discard_trees)
+            result.is_src_volatile |= uncompressed !== inferred_result
+        elseif owner === nothing
+            # The global cache can only handle objects that codegen understands
+            inferred_result = nothing
+        end
         if isa(inferred_result, String)
             t = @_gc_preserve_begin inferred_result
             relocatability = unsafe_load(unsafe_convert(Ptr{UInt8}, inferred_result), Core.sizeof(inferred_result))
@@ -323,8 +332,8 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
             relocatability = 0x1
         end
     end
-    # relocatability = isa(inferred_result, String) ? inferred_result[end] : UInt8(0)
-    return CodeInstance(result.linfo, cache_owner(interp),
+    # n.b. relocatability = (isa(inferred_result, String) && inferred_result[end]) || inferred_result === nothing
+    return CodeInstance(result.linfo, owner,
         widenconst(result_type), widenconst(result.exc_result), rettype_const, inferred_result,
         const_flags, first(result.valid_worlds), last(result.valid_worlds),
         # TODO: Actually do something with non-IPO effects
@@ -332,6 +341,12 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
         relocatability)
 end
 
+function transform_result_for_cache(interp::AbstractInterpreter,
+        linfo::MethodInstance, valid_worlds::WorldRange, result::InferenceResult,
+        can_discard_trees::Bool=may_discard_trees(interp))
+    return result.src
+end
+
 function maybe_compress_codeinfo(interp::AbstractInterpreter, linfo::MethodInstance, ci::CodeInfo,
         can_discard_trees::Bool=may_discard_trees(interp))
     def = linfo.def
@@ -354,22 +369,6 @@ function maybe_compress_codeinfo(interp::AbstractInterpreter, linfo::MethodInsta
     end
 end
 
-function transform_result_for_cache(interp::AbstractInterpreter,
-        linfo::MethodInstance, valid_worlds::WorldRange, result::InferenceResult,
-        can_discard_trees::Bool=may_discard_trees(interp))
-    inferred_result = result.src
-    if inferred_result isa CodeInfo
-        uncompressed = inferred_result
-        inferred_result = maybe_compress_codeinfo(interp, linfo, inferred_result, can_discard_trees)
-        result.is_src_volatile |= uncompressed !== inferred_result
-    end
-    # The global cache can only handle objects that codegen understands
-    if !isa(inferred_result, MaybeCompressed)
-        inferred_result = nothing
-    end
-    return inferred_result
-end
-
 function cache_result!(interp::AbstractInterpreter, result::InferenceResult)
     if last(result.valid_worlds) == get_world_counter()
         # if we've successfully recorded all of the backedges in the global reverse-cache,
@@ -874,7 +873,7 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         exc_bestguess = refine_exception_type(frame.exc_bestguess, effects)
         # propagate newly inferred source to the inliner, allowing efficient inlining w/o deserialization:
         # note that this result is cached globally exclusively, we can use this local result destructively
-        volatile_inf_result = isinferred && (force_inline || inlining_policy(interp, result.src, NoCallInfo(), IR_FLAG_NULL) !== nothing) ?
+        volatile_inf_result = isinferred && (force_inline || src_inlining_policy(interp, result.src, NoCallInfo(), IR_FLAG_NULL) !== nothing) ?
             VolatileInferenceResult(result) : nothing
         return EdgeCallResult(frame.bestguess, exc_bestguess, edge, effects, volatile_inf_result)
     elseif frame === true
@@ -1092,6 +1091,8 @@ function ci_meets_requirement(code::CodeInstance, source_mode::UInt8, ci_is_cach
     return false
 end
 
+_uncompressed_ir(ci::Core.CodeInstance, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any, Any), ci.def.def::Method, ci, s)::CodeInfo
+
 # compute (and cache) an inferred AST and return type
 function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance, source_mode::UInt8)
     start_time = ccall(:jl_typeinf_timing_begin, UInt64, ())
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index a810f92c8f87c..c2c36920bd574 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -143,7 +143,7 @@ function retrieve_code_info(linfo::MethodInstance, world::UInt)
             # can happen in images built with --strip-ir
             return nothing
         elseif isa(src, String)
-            c = _uncompressed_ir(def, src)
+            c = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), def, C_NULL, src)
         else
             c = copy(src::CodeInfo)
         end
diff --git a/base/reflection.jl b/base/reflection.jl
index de9cf6951ec87..7a7d60ba25f1e 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1313,12 +1313,14 @@ function length(mt::Core.MethodTable)
 end
 isempty(mt::Core.MethodTable) = (mt.defs === nothing)
 
-uncompressed_ir(m::Method) = isdefined(m, :source) ? _uncompressed_ir(m, m.source) :
+uncompressed_ir(m::Method) = isdefined(m, :source) ? _uncompressed_ir(m) :
                              isdefined(m, :generator) ? error("Method is @generated; try `code_lowered` instead.") :
                              error("Code for this Method is not available.")
-_uncompressed_ir(m::Method, s::CodeInfo) = copy(s)
-_uncompressed_ir(m::Method, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), m, C_NULL, s)::CodeInfo
-_uncompressed_ir(ci::Core.CodeInstance, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any, Any), ci.def.def::Method, ci, s)::CodeInfo
+function _uncompressed_ir(m::Method)
+    s = m.source
+    s isa String && (s = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), m, C_NULL, s))
+    return s::CodeInfo
+end
 # for backwards compat
 const uncompressed_ast = uncompressed_ir
 const _uncompressed_ast = _uncompressed_ir
@@ -1632,7 +1634,7 @@ function get_oc_code_rt(@nospecialize(oc::Core.OpaqueClosure))
     ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
     m = oc.source
     if isa(m, Method)
-        code = _uncompressed_ir(m, m.source)
+        code = _uncompressed_ir(m)
         return Pair{CodeInfo,Any}(code, typeof(oc).parameters[2])
     else
         error("encountered invalid Core.OpaqueClosure object")
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index ebbbc85f11cba..4fa6274554be0 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -7,7 +7,7 @@ Provide serialization of Julia objects via the functions
 """
 module Serialization
 
-import Base: GMP, Bottom, unsafe_convert, uncompressed_ast
+import Base: GMP, Bottom, unsafe_convert
 import Core: svec, SimpleVector
 using Base: unaliascopy, unwrap_unionall, require_one_based_indexing, ntupleany
 using Core.IR
@@ -447,7 +447,7 @@ function serialize(s::AbstractSerializer, meth::Method)
     serialize(s, meth.constprop)
     serialize(s, meth.purity)
     if isdefined(meth, :source)
-        serialize(s, Base._uncompressed_ast(meth, meth.source))
+        serialize(s, Base._uncompressed_ast(meth))
     else
         serialize(s, nothing)
     end
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 6518d7fbe3d30..80288bac486ff 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -334,12 +334,12 @@ function CC.abstract_call(interp::NoinlineInterpreter,
     end
     return ret
 end
-function CC.inlining_policy(interp::NoinlineInterpreter,
+function CC.src_inlining_policy(interp::NoinlineInterpreter,
     @nospecialize(src), @nospecialize(info::CallInfo), stmt_flag::UInt32)
     if isa(info, NoinlineCallInfo)
-        return nothing
+        return false
     end
-    return @invoke CC.inlining_policy(interp::CC.AbstractInterpreter,
+    return @invoke CC.src_inlining_policy(interp::CC.AbstractInterpreter,
         src::Any, info::CallInfo, stmt_flag::UInt32)
 end
 
@@ -485,14 +485,18 @@ function CC.transform_result_for_cache(interp::CustomDataInterp,
         mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
     return CustomData(inferred_result)
 end
-function CC.inlining_policy(interp::CustomDataInterp, @nospecialize(src),
+function CC.src_inlining_policy(interp::CustomDataInterp, @nospecialize(src),
                             @nospecialize(info::CC.CallInfo), stmt_flag::UInt32)
     if src isa CustomData
         src = src.inferred
     end
-    return @invoke CC.inlining_policy(interp::CC.AbstractInterpreter, src::Any,
-                                      info::CC.CallInfo, stmt_flag::UInt32)
+    return @invoke CC.src_inlining_policy(interp::CC.AbstractInterpreter, src::Any,
+                                          info::CC.CallInfo, stmt_flag::UInt32)
 end
+CC.retrieve_ir_for_inlining(cached_result::CodeInstance, src::CustomData) =
+    CC.retrieve_ir_for_inlining(cached_result, src.inferred)
+CC.retrieve_ir_for_inlining(mi::MethodInstance, src::CustomData, preserve_local_sources::Bool) =
+    CC.retrieve_ir_for_inlining(mi, src.inferred, preserve_local_sources)
 let src = code_typed((Int,); interp=CustomDataInterp()) do x
         return sin(x) + cos(x)
     end |> only |> first
diff --git a/test/precompile.jl b/test/precompile.jl
index a68d8936d1ed1..9a035997ce9f0 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1794,14 +1794,18 @@ let newinterp_path = abspath("compiler/newinterp.jl")
                         mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
                     return CustomData(inferred_result)
                 end
-                function CC.inlining_policy(interp::PrecompileInterpreter, @nospecialize(src),
+                function CC.src_inlining_policy(interp::PrecompileInterpreter, @nospecialize(src),
                                             @nospecialize(info::CC.CallInfo), stmt_flag::UInt32)
                     if src isa CustomData
                         src = src.inferred
                     end
-                    return @invoke CC.inlining_policy(interp::CC.AbstractInterpreter, src::Any,
-                                                    info::CC.CallInfo, stmt_flag::UInt32)
+                    return @invoke CC.src_inlining_policy(interp::CC.AbstractInterpreter, src::Any,
+                                                          info::CC.CallInfo, stmt_flag::UInt32)
                 end
+                CC.retrieve_ir_for_inlining(cached_result::Core.CodeInstance, src::CustomData) =
+                    CC.retrieve_ir_for_inlining(cached_result, src.inferred)
+                CC.retrieve_ir_for_inlining(mi::Core.MethodInstance, src::CustomData, preserve_local_sources::Bool) =
+                    CC.retrieve_ir_for_inlining(mi, src.inferred, preserve_local_sources)
             end
 
             Base.return_types((Float64,)) do x

From 2126b6716357ceae0177bd857560ad0634d56449 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 19 Feb 2024 22:23:59 +0000
Subject: [PATCH 0989/1315] [Serialization] fix format bug for pre_13 code

pre_13 would fail to read the max_world field, resulting in the stream
getting desynchronized and corrupted. Add some type-asserts to help
detect that error earlier.
---
 stdlib/Serialization/src/Serialization.jl | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index 4fa6274554be0..7f122142c1fff 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -1214,24 +1214,25 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
             deserialize(s) # rettype
             ci.parent = deserialize(s)
             world_or_edges = deserialize(s)
-            pre_13 = isa(world_or_edges, Integer)
+            pre_13 = isa(world_or_edges, Union{UInt, Int})
             if pre_13
-                ci.min_world = world_or_edges
+                ci.min_world = reinterpret(UInt, world_or_edges)
+                ci.max_world = reinterpret(UInt, deserialize(s))
             else
                 ci.edges = world_or_edges
-                ci.min_world = reinterpret(UInt, deserialize(s))
-                ci.max_world = reinterpret(UInt, deserialize(s))
+                ci.min_world = deserialize(s)::UInt
+                ci.max_world = deserialize(s)::UInt
             end
         else
             ci.parent = deserialize(s)
             ci.method_for_inference_limit_heuristics = deserialize(s)
             ci.edges = deserialize(s)
-            ci.min_world = reinterpret(UInt, deserialize(s))
-            ci.max_world = reinterpret(UInt, deserialize(s))
+            ci.min_world = deserialize(s)::UInt
+            ci.max_world = deserialize(s)::UInt
         end
     end
     if format_version(s) <= 26
-        deserialize(s) # inferred
+        deserialize(s)::Bool # inferred
     end
     if format_version(s) < 22
         inlining_cost = deserialize(s)

From ef8fab0eb0b896b29820c01748047e24ccbb560c Mon Sep 17 00:00:00 2001
From: Sebastien Marie <semarie@kapouay.eu.org>
Date: Wed, 21 Feb 2024 15:44:57 +0100
Subject: [PATCH 0990/1315] update libwhich to latest commit (#53398)

It supports more platforms.

it is part of on-going work to port julia to OpenBSD.
---
 deps/checksums/libwhich | 4 ++--
 deps/libwhich.version   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/deps/checksums/libwhich b/deps/checksums/libwhich
index d4a0119625663..cd34ac7cc0b8b 100644
--- a/deps/checksums/libwhich
+++ b/deps/checksums/libwhich
@@ -1,2 +1,2 @@
-libwhich-81e9723c0273d78493dc8c8ed570f68d9ce7e89e.tar.gz/md5/22fd8368c7b40209dada50e3205c1294
-libwhich-81e9723c0273d78493dc8c8ed570f68d9ce7e89e.tar.gz/sha512/6fb77b715d70d9bc95a8546c3bf97bd3677c7ea344b88bb5bc3bbfac9dceabe8a8cde7a0f64dec884cde802e4a3000e30837d3f824b5a9242348c4fe061526a3
+libwhich-99a0ea12689e41164456dba03e93bc40924de880.tar.gz/md5/213f0ad813de677d25787cae05901a9a
+libwhich-99a0ea12689e41164456dba03e93bc40924de880.tar.gz/sha512/7c42c3b6c480763b85f8c5eb927e776b48cb8a2be1e1c143e799628ee9265adea6a56b33c17583c8e6fc040a3889a4010ac674918bc6947899983a4942353526
diff --git a/deps/libwhich.version b/deps/libwhich.version
index 0fa713024ef99..09ea0197d10c1 100644
--- a/deps/libwhich.version
+++ b/deps/libwhich.version
@@ -1,2 +1,2 @@
 LIBWHICH_BRANCH=master
-LIBWHICH_SHA1=81e9723c0273d78493dc8c8ed570f68d9ce7e89e
+LIBWHICH_SHA1=99a0ea12689e41164456dba03e93bc40924de880

From 65f24dac1b34dfd3ff3149538b5e6dffcbf1dc7d Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Wed, 21 Feb 2024 15:54:33 +0100
Subject: [PATCH 0991/1315] doc: expand the `<:` doc string (#53001)

Clear up some things, state some expected properties and limitations,
add cross-references, add more examples.

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/operators.jl | 44 ++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 40 insertions(+), 4 deletions(-)

diff --git a/base/operators.jl b/base/operators.jl
index 3d5ad705ed99a..9fc8068ddf20e 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -3,10 +3,25 @@
 ## types ##
 
 """
-    <:(T1, T2)
+    <:(T1, T2)::Bool
 
-Subtype operator: returns `true` if and only if all values of type `T1` are
-also of type `T2`.
+Subtyping relation, defined between two types. In Julia, a type `S` is said to be a
+*subtype* of a type `T` if and only if we have `S <: T`.
+
+For any type `L` and any type `R`, `L <: R` implies that any value `v` of type `L`
+is also of type `R`. I.e., `(L <: R) && (v isa L)` implies `v isa R`.
+
+The subtyping relation is a *partial order*. I.e., `<:` is:
+
+* *reflexive*: for any type `T`, `T <: T` holds
+
+* *antisymmetric*: for any type `A` and any type `B`, `(A <: B) && (B <: A)`
+  implies `A == B`
+
+* *transitive*: for any type `A`, any type `B` and any type `C`;
+  `(A <: B) && (B <: C)` implies `A <: C`
+
+See also info on [Types](@ref man-types), [`Union{}`](@ref), [`Any`](@ref), [`isa`](@ref).
 
 # Examples
 ```jldoctest
@@ -16,9 +31,30 @@ true
 julia> Vector{Int} <: AbstractArray
 true
 
-julia> Matrix{Float64} <: Matrix{AbstractFloat}
+julia> Matrix{Float64} <: Matrix{AbstractFloat}  # `Matrix` is invariant
 false
+
+julia> Tuple{Float64} <: Tuple{AbstractFloat}    # `Tuple` is covariant
+true
+
+julia> Union{} <: Int  # The bottom type, `Union{}`, subtypes each type.
+true
+
+julia> Union{} <: Float32 <: AbstractFloat <: Real <: Number <: Any  # Operator chaining
+true
 ```
+
+The `<:` keyword also has several syntactic uses which represent the same subtyping relation,
+but which do not execute the operator or return a Bool:
+
+* To specify the lower bound and the upper bound on a parameter of a
+  [`UnionAll`](@ref) type in a [`where`](@ref) statement.
+
+* To specify the lower bound and the upper bound on a (static) parameter of a
+  method, see [Parametric Methods](@ref).
+
+* To define a subtyping relation while declaring a new type, see [`struct`](@ref)
+  and [`abstract type`](@ref).
 """
 (<:)
 

From 8425b0ea03a4cbf4cfb677fb554b19d6a5a0eb03 Mon Sep 17 00:00:00 2001
From: Carsten Bauer <crstnbr@gmail.com>
Date: Wed, 21 Feb 2024 21:33:54 +0100
Subject: [PATCH 0992/1315] Fix documentation: thread pool of main thread
 (#53388)

See
https://github.com/JuliaLang/julia/issues/53217#issuecomment-1930891907
---
 doc/src/manual/multi-threading.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/multi-threading.md b/doc/src/manual/multi-threading.md
index 085c6b835c87c..dd02da8798f06 100644
--- a/doc/src/manual/multi-threading.md
+++ b/doc/src/manual/multi-threading.md
@@ -116,8 +116,8 @@ julia> using Base.Threads
 julia> nthreadpools()
 2
 
-julia> threadpool()
-:default
+julia> threadpool() # the main thread is in the interactive thread pool
+:interactive
 
 julia> nthreads(:default)
 3
@@ -133,6 +133,10 @@ julia> nthreads()
     The zero-argument version of `nthreads` returns the number of threads
     in the default pool.
 
+!!! note
+    Depending on whether Julia has been started with interactive threads,
+    the main thread is either in the default or interactive thread pool.
+
 Either or both numbers can be replaced with the word `auto`, which causes
 Julia to choose a reasonable default.
 

From a1db8daafd6c1a1179de77955167a6958a4c23b0 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 22 Feb 2024 04:30:07 -0500
Subject: [PATCH 0993/1315] protect against PkgId and UUID being imported and
 losing Base prefix in create_expr_cache (#53387)

Fixes https://github.com/JuliaLang/julia/issues/53381
---
 base/loading.jl | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index f4db43d80640b..3c7bb28cfdd17 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2641,6 +2641,7 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
         error("LOAD_PATH entries cannot contain $(repr(path_sep))")
 
     deps_strs = String[]
+    # protects against PkgId and UUID being imported and losing Base prefix
     function pkg_str(_pkg::PkgId)
         if _pkg.uuid === nothing
             "Base.PkgId($(repr(_pkg.name)))"
@@ -2651,6 +2652,9 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     for (pkg, build_id) in concrete_deps
         push!(deps_strs, "$(pkg_str(pkg)) => $(repr(build_id))")
     end
+    deps_eltype = sprint(show, eltype(concrete_deps); context = :module=>nothing)
+    deps = deps_eltype * "[" * join(deps_strs, ",") * "]"
+    precomp_stack = "Base.PkgId[$(join(map(pkg_str, vcat(Base.precompilation_stack, pkg)), ", "))]"
 
     if output_o !== nothing
         @debug "Generating object cache file for $(repr("text/plain", pkg))"
@@ -2662,8 +2666,6 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
         opts = `-O0 --output-ji $(output) --output-incremental=yes`
     end
 
-    deps_eltype = sprint(show, eltype(concrete_deps); context = :module=>nothing)
-    deps = deps_eltype * "[" * join(deps_strs, ",") * "]"
     trace = isassigned(PRECOMPILE_TRACE_COMPILE) ? `--trace-compile=$(PRECOMPILE_TRACE_COMPILE[])` : ``
     io = open(pipeline(addenv(`$(julia_cmd(;cpu_target)::Cmd)
                              $(flags)
@@ -2679,7 +2681,7 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
     # write data over stdin to avoid the (unlikely) case of exceeding max command line size
     write(io.in, """
         empty!(Base.EXT_DORMITORY) # If we have a custom sysimage with `EXT_DORMITORY` prepopulated
-        Base.track_nested_precomp($(vcat(Base.precompilation_stack, pkg)))
+        Base.track_nested_precomp($precomp_stack)
         Base.precompiling_extension = $(loading_extension)
         Base.include_package_for_output($(pkg_str(pkg)), $(repr(abspath(input))), $(repr(depot_path)), $(repr(dl_load_path)),
             $(repr(load_path)), $deps, $(repr(source_path(nothing))))

From ccba6c91e24ebc0940acc2f8c390e6391ce0e292 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 22 Feb 2024 20:41:07 +0900
Subject: [PATCH 0994/1315] make `code_lowered` type stable (#53416)

---
 base/expr.jl       |  4 ++--
 base/reflection.jl | 20 +++++++++++---------
 test/reflection.jl |  3 +++
 3 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/base/expr.jl b/base/expr.jl
index b90f75e75a76f..94abe5b2eab67 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -79,7 +79,7 @@ function copy(c::CodeInfo)
     cnew.slotnames = copy(cnew.slotnames)
     cnew.slotflags = copy(cnew.slotflags)
     if cnew.slottypes !== nothing
-        cnew.slottypes = copy(cnew.slottypes)
+        cnew.slottypes = copy(cnew.slottypes::Vector{Any})
     end
     cnew.codelocs  = copy(cnew.codelocs)
     cnew.linetable = copy(cnew.linetable::Union{Vector{Any},Vector{Core.LineInfoNode}})
@@ -1019,7 +1019,7 @@ function remove_linenums!(@nospecialize ex)
         return ex
     elseif ex isa CodeInfo
         ex.codelocs .= 0
-        length(ex.linetable) > 1 && resize!(ex.linetable, 1)
+        length(ex.linetable::Vector) > 1 && resize!(ex.linetable::Vector, 1)
         return ex
     else
         return ex
diff --git a/base/reflection.jl b/base/reflection.jl
index 7a7d60ba25f1e..202573b02f1bf 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1127,20 +1127,23 @@ function code_lowered(@nospecialize(f), @nospecialize(t=Tuple); generated::Bool=
     end
     world = get_world_counter()
     world == typemax(UInt) && error("code reflection cannot be used from generated functions")
-    return map(method_instances(f, t, world)) do m
+    ret = CodeInfo[]
+    for m in method_instances(f, t, world)
         if generated && hasgenerator(m)
             if may_invoke_generator(m)
-                return ccall(:jl_code_for_staged, Any, (Any, UInt), m, world)::CodeInfo
+                code = ccall(:jl_code_for_staged, Any, (Any, UInt), m, world)::CodeInfo
             else
                 error("Could not expand generator for `@generated` method ", m, ". ",
                       "This can happen if the provided argument types (", t, ") are ",
                       "not leaf types, but the `generated` argument is `true`.")
             end
+        else
+            code = uncompressed_ir(m.def::Method)
+            debuginfo === :none && remove_linenums!(code)
         end
-        code = uncompressed_ir(m.def::Method)
-        debuginfo === :none && remove_linenums!(code)
-        return code
+        push!(ret, code)
     end
+    return ret
 end
 
 hasgenerator(m::Method) = isdefined(m, :generator)
@@ -1331,7 +1334,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)
+        instance = Core.Compiler.specialize_method(match::Core.MethodMatch)
         push!(results, instance)
     end
     return results
@@ -1497,7 +1500,7 @@ function may_invoke_generator(method::Method, @nospecialize(atype), sparams::Sim
     gen_mthds isa Vector || return false
     length(gen_mthds) == 1 || return false
 
-    generator_method = first(gen_mthds).method
+    generator_method = (first(gen_mthds)::Core.MethodMatch).method
     nsparams = length(sparams)
     isdefined(generator_method, :source) || return false
     code = generator_method.source
@@ -2459,7 +2462,7 @@ function isambiguous(m1::Method, m2::Method; ambiguous_bottom::Bool=false)
         min = Ref{UInt}(typemin(UInt))
         max = Ref{UInt}(typemax(UInt))
         has_ambig = Ref{Int32}(0)
-        ms = _methods_by_ftype(ti, nothing, -1, world, true, min, max, has_ambig)::Vector
+        ms = collect(Core.MethodMatch, _methods_by_ftype(ti, nothing, -1, world, true, min, max, has_ambig)::Vector)
         has_ambig[] == 0 && return false
         if !ambiguous_bottom
             filter!(ms) do m::Core.MethodMatch
@@ -2472,7 +2475,6 @@ function isambiguous(m1::Method, m2::Method; ambiguous_bottom::Bool=false)
         # report the other ambiguous pair)
         have_m1 = have_m2 = false
         for match in ms
-            match = match::Core.MethodMatch
             m = match.method
             m === m1 && (have_m1 = true)
             m === m2 && (have_m2 = true)
diff --git a/test/reflection.jl b/test/reflection.jl
index c4e941fa7bb1a..f2444a1cb8658 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1193,3 +1193,6 @@ end
 @test Base.isexported(Mod52812, :b)
 @test Base.ispublic(Mod52812, :a)
 @test Base.ispublic(Mod52812, :b)
+
+@test Base.infer_return_type(code_lowered, (Any,)) == Vector{Core.CodeInfo}
+@test Base.infer_return_type(code_lowered, (Any,Any)) == Vector{Core.CodeInfo}

From a96726b84d9dfcaec304c5643956a2e9d2176079 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 22 Feb 2024 14:24:54 -0300
Subject: [PATCH 0995/1315] Fix synchronization issue on the GC scheduler
 (#53355)

This aims to slightly simplify the synchronization by making
`n_threads_marking` the sole memory location of relevance for it, it
also removes the fast path, because being protected by the lock is
quite important so that the observed gc state arrays are valid.

Fixes: #53350
Fixes: #52757
Maybe fixes: #53026
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 src/gc.c                  | 63 ++++++++++++++-------------------------
 src/julia_threads.h       | 11 +++----
 src/llvm-codegen-shared.h |  2 +-
 src/safepoint.c           |  4 +--
 src/scheduler.c           | 10 +++----
 src/signal-handling.c     |  2 +-
 src/threading.c           |  2 +-
 7 files changed, 37 insertions(+), 57 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index a920958307c48..c2d194b8a28bb 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -3,6 +3,7 @@
 #include "gc.h"
 #include "gc-page-profiler.h"
 #include "julia.h"
+#include "julia_atomics.h"
 #include "julia_gcext.h"
 #include "julia_assert.h"
 #ifdef __GLIBC__
@@ -540,7 +541,7 @@ void jl_gc_run_all_finalizers(jl_task_t *ct)
 
 void jl_gc_add_finalizer_(jl_ptls_t ptls, void *v, void *f) JL_NOTSAFEPOINT
 {
-    assert(jl_atomic_load_relaxed(&ptls->gc_state) == 0);
+    assert(jl_atomic_load_relaxed(&ptls->gc_state) == JL_GC_STATE_UNSAFE);
     arraylist_t *a = &ptls->finalizers;
     // This acquire load and the release store at the end are used to
     // synchronize with `finalize_object` on another thread. Apart from the GC,
@@ -1676,7 +1677,7 @@ void gc_sweep_wake_all(jl_ptls_t ptls, jl_gc_padded_page_stack_t *new_gc_allocd_
 void gc_sweep_wait_for_all(void)
 {
     jl_atomic_store(&gc_allocd_scratch, NULL);
-    while (jl_atomic_load_relaxed(&gc_n_threads_sweeping) != 0) {
+    while (jl_atomic_load_acquire(&gc_n_threads_sweeping) != 0) {
         jl_cpu_pause();
     }
 }
@@ -2966,9 +2967,7 @@ void gc_mark_and_steal(jl_ptls_t ptls)
     jl_gc_markqueue_t *mq = &ptls->mark_queue;
     jl_gc_markqueue_t *mq_master = NULL;
     int master_tid = jl_atomic_load(&gc_master_tid);
-    if (master_tid == -1) {
-        return;
-    }
+    assert(master_tid != -1);
     mq_master = &gc_all_tls_states[master_tid]->mark_queue;
     void *new_obj;
     jl_gc_chunk_t c;
@@ -3060,54 +3059,37 @@ size_t gc_count_work_in_queue(jl_ptls_t ptls) JL_NOTSAFEPOINT
  * Correctness argument for the mark-loop termination protocol.
  *
  * Safety properties:
- * - No work items shall be in any thread's queues when `gc_mark_loop_barrier` observes
+ * - No work items shall be in any thread's queues when `gc_should_mark` observes
  * that `gc_n_threads_marking` is zero.
  *
  * - No work item shall be stolen from the master thread (i.e. mutator thread which started
  * GC and which helped the `jl_n_markthreads` - 1 threads to mark) after
- * `gc_mark_loop_barrier` observes that `gc_n_threads_marking` is zero. This property is
+ * `gc_should_mark` observes that `gc_n_threads_marking` is zero. This property is
  * necessary because we call `gc_mark_loop_serial` after marking the finalizer list in
  * `_jl_gc_collect`, and want to ensure that we have the serial mark-loop semantics there,
  * and that no work is stolen from us at that point.
  *
  * Proof:
- * - Suppose the master thread observes that `gc_n_threads_marking` is zero in
- * `gc_mark_loop_barrier` and there is a work item left in one thread's queue at that point.
- * Since threads try to steal from all threads' queues, this implies that all threads must
- * have tried to steal from the queue which still has a work item left, but failed to do so,
- * which violates the semantics of Chase-Lev's work-stealing queue.
- *
- * - Let E1 be the event "master thread writes -1 to gc_master_tid" and E2 be the event
- * "master thread observes that `gc_n_threads_marking` is zero". Since we're using
- * sequentially consistent atomics, E1 => E2. Now suppose one thread which is spinning in
- * `gc_should_mark` tries to enter the mark-loop after E2. In order to do so, it must
- * increment `gc_n_threads_marking` to 1 in an event E3, and then read `gc_master_tid` in an
- * event E4. Since we're using sequentially consistent atomics, E3 => E4. Since we observed
- * `gc_n_threads_marking` as zero in E2, then E2 => E3, and we conclude E1 => E4, so that
- * the thread which is spinning in `gc_should_mark` must observe that `gc_master_tid` is -1
- * and therefore won't enter the mark-loop.
+ * - If a thread observes that `gc_n_threads_marking` is zero inside `gc_should_mark`, that
+ * means that no thread has work on their queue, this is guaranteed because a thread may only exit
+ * `gc_mark_and_steal` when its own queue is empty, this information is synchronized by the
+ * seq-cst fetch_add to a thread that is in `gc_should_mark`. `gc_queue_observer_lock`
+ * guarantees that once `gc_n_threads_marking` reaches zero, no thread will increment it again,
+ * because incrementing is only legal from inside the lock. Therefore, no thread will reenter
+ * the mark-loop after `gc_n_threads_marking` reaches zero.
  */
 
 int gc_should_mark(void)
 {
     int should_mark = 0;
-    int n_threads_marking = jl_atomic_load(&gc_n_threads_marking);
-    // fast path
-    if (n_threads_marking == 0) {
-        return 0;
-    }
     uv_mutex_lock(&gc_queue_observer_lock);
     while (1) {
-        int tid = jl_atomic_load(&gc_master_tid);
-        // fast path
-        if (tid == -1) {
-            break;
-        }
-        n_threads_marking = jl_atomic_load(&gc_n_threads_marking);
-        // fast path
+        int n_threads_marking = jl_atomic_load(&gc_n_threads_marking);
         if (n_threads_marking == 0) {
             break;
         }
+        int tid = jl_atomic_load_relaxed(&gc_master_tid);
+        assert(tid != -1);
         size_t work = gc_count_work_in_queue(gc_all_tls_states[tid]);
         for (tid = gc_first_tid; tid < gc_first_tid + jl_n_markthreads; tid++) {
             jl_ptls_t ptls2 = gc_all_tls_states[tid];
@@ -3118,7 +3100,8 @@ int gc_should_mark(void)
         }
         // if there is a lot of work left, enter the mark loop
         if (work >= 16 * n_threads_marking) {
-            jl_atomic_fetch_add(&gc_n_threads_marking, 1);
+            jl_atomic_fetch_add(&gc_n_threads_marking, 1); // A possibility would be to allow a thread that found lots
+                                                           // of work to increment this
             should_mark = 1;
             break;
         }
@@ -3130,9 +3113,7 @@ int gc_should_mark(void)
 
 void gc_wake_all_for_marking(jl_ptls_t ptls)
 {
-    jl_atomic_store(&gc_master_tid, ptls->tid);
     uv_mutex_lock(&gc_threads_lock);
-    jl_atomic_fetch_add(&gc_n_threads_marking, 1);
     uv_cond_broadcast(&gc_threads_cond);
     uv_mutex_unlock(&gc_threads_lock);
 }
@@ -3140,6 +3121,8 @@ void gc_wake_all_for_marking(jl_ptls_t ptls)
 void gc_mark_loop_parallel(jl_ptls_t ptls, int master)
 {
     if (master) {
+        jl_atomic_store(&gc_master_tid, ptls->tid);
+        jl_atomic_fetch_add(&gc_n_threads_marking, 1);
         gc_wake_all_for_marking(ptls);
         gc_mark_and_steal(ptls);
         jl_atomic_fetch_add(&gc_n_threads_marking, -1);
@@ -3166,10 +3149,8 @@ void gc_mark_loop(jl_ptls_t ptls)
 
 void gc_mark_loop_barrier(void)
 {
-    jl_atomic_store(&gc_master_tid, -1);
-    while (jl_atomic_load(&gc_n_threads_marking) != 0) {
-        jl_cpu_pause();
-    }
+    assert(jl_atomic_load_relaxed(&gc_n_threads_marking) == 0);
+    jl_atomic_store_relaxed(&gc_master_tid, -1);
 }
 
 void gc_mark_clean_reclaim_sets(void)
diff --git a/src/julia_threads.h b/src/julia_threads.h
index 1c64a722850f2..3f8f5391919b4 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -192,6 +192,9 @@ typedef struct _jl_tls_states_t {
     _Atomic(volatile size_t *) safepoint; // may be changed to the suspend page by any thread
     _Atomic(int8_t) sleep_check_state; // read/write from foreign threads
     // Whether it is safe to execute GC at the same time.
+#define JL_GC_STATE_UNSAFE 0
+    // gc_state = 0 means the thread is running Julia code and is not
+    //              safe to run concurrently to the GC
 #define JL_GC_STATE_WAITING 1
     // gc_state = 1 means the thread is doing GC or is waiting for the GC to
     //              finish.
@@ -330,9 +333,7 @@ STATIC_INLINE int8_t jl_gc_state_set(jl_ptls_t ptls, int8_t state,
                                      int8_t old_state)
 {
     jl_atomic_store_release(&ptls->gc_state, state);
-    if (state == JL_GC_STATE_SAFE && old_state == 0)
-        jl_gc_safepoint_(ptls);
-    if (state == 0 && old_state == JL_GC_STATE_SAFE)
+    if (state == JL_GC_STATE_UNSAFE || old_state == JL_GC_STATE_UNSAFE)
         jl_gc_safepoint_(ptls);
     return old_state;
 }
@@ -347,8 +348,8 @@ void jl_gc_unsafe_leave(jl_ptls_t ptls, int8_t state) JL_NOTSAFEPOINT JL_NOTSAFE
 int8_t jl_gc_safe_enter(jl_ptls_t ptls) JL_NOTSAFEPOINT JL_NOTSAFEPOINT_ENTER;
 void jl_gc_safe_leave(jl_ptls_t ptls, int8_t state) JL_NOTSAFEPOINT_LEAVE; // this might not be a safepoint, but we have to assume it could be (statically)
 #else
-#define jl_gc_unsafe_enter(ptls) jl_gc_state_save_and_set(ptls, 0)
-#define jl_gc_unsafe_leave(ptls, state) ((void)jl_gc_state_set(ptls, (state), 0))
+#define jl_gc_unsafe_enter(ptls) jl_gc_state_save_and_set(ptls, JL_GC_STATE_UNSAFE)
+#define jl_gc_unsafe_leave(ptls, state) ((void)jl_gc_state_set(ptls, (state), JL_GC_STATE_UNSAFE))
 #define jl_gc_safe_enter(ptls) jl_gc_state_save_and_set(ptls, JL_GC_STATE_SAFE)
 #define jl_gc_safe_leave(ptls, state) ((void)jl_gc_state_set(ptls, (state), JL_GC_STATE_SAFE))
 #endif
diff --git a/src/llvm-codegen-shared.h b/src/llvm-codegen-shared.h
index a4f77bc1b3b38..2c60907ca086c 100644
--- a/src/llvm-codegen-shared.h
+++ b/src/llvm-codegen-shared.h
@@ -325,7 +325,7 @@ static inline llvm::Value *emit_gc_unsafe_enter(llvm::IRBuilder<> &builder, llvm
 static inline llvm::Value *emit_gc_unsafe_leave(llvm::IRBuilder<> &builder, llvm::Type *T_size, llvm::Value *ptls, llvm::Value *state, bool final)
 {
     using namespace llvm;
-    Value *old_state = builder.getInt8(0);
+    Value *old_state = builder.getInt8(JL_GC_STATE_UNSAFE);
     return emit_gc_state_set(builder, T_size, ptls, state, old_state, final);
 }
 
diff --git a/src/safepoint.c b/src/safepoint.c
index a05d37e492813..22cda0a89444d 100644
--- a/src/safepoint.c
+++ b/src/safepoint.c
@@ -234,7 +234,7 @@ void jl_safepoint_wait_gc(void) JL_NOTSAFEPOINT
     jl_task_t *ct = jl_current_task; (void)ct;
     JL_TIMING_SUSPEND_TASK(GC_SAFEPOINT, ct);
     // The thread should have set this is already
-    assert(jl_atomic_load_relaxed(&ct->ptls->gc_state) != 0);
+    assert(jl_atomic_load_relaxed(&ct->ptls->gc_state) != JL_GC_STATE_UNSAFE);
     // Use normal volatile load in the loop for speed until GC finishes.
     // Then use an acquire load to make sure the GC result is visible on this thread.
     while (jl_atomic_load_relaxed(&jl_gc_running) || jl_atomic_load_acquire(&jl_gc_running)) {
@@ -309,7 +309,7 @@ int jl_safepoint_suspend_thread(int tid, int waitstate)
         }
         while (jl_atomic_load_acquire(&ptls2->suspend_count) != 0) {
             int8_t state2 = jl_atomic_load_acquire(&ptls2->gc_state);
-            if (waitstate <= 2 && state2 != 0)
+            if (waitstate <= 2 && state2 != JL_GC_STATE_UNSAFE)
                 break;
             if (waitstate == 3 && state2 == JL_GC_STATE_WAITING)
                 break;
diff --git a/src/scheduler.c b/src/scheduler.c
index 2af88db89ca14..dbc913353ce4c 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -131,7 +131,7 @@ void jl_parallel_gc_threadfun(void *arg)
     jl_ptls_t ptls = jl_init_threadtls(targ->tid);
 
     // wait for all threads
-    jl_gc_state_set(ptls, JL_GC_STATE_WAITING, 0);
+    jl_gc_state_set(ptls, JL_GC_STATE_WAITING, JL_GC_STATE_UNSAFE);
     uv_barrier_wait(targ->barrier);
 
     // free the thread argument here
@@ -143,9 +143,7 @@ void jl_parallel_gc_threadfun(void *arg)
             uv_cond_wait(&gc_threads_cond, &gc_threads_lock);
         }
         uv_mutex_unlock(&gc_threads_lock);
-        if (may_mark()) {
-            gc_mark_loop_parallel(ptls, 0);
-        }
+        gc_mark_loop_parallel(ptls, 0);
         if (may_sweep(ptls)) { // not an else!
             gc_sweep_pool_parallel(ptls);
             jl_atomic_fetch_add(&ptls->gc_sweeps_requested, -1);
@@ -162,7 +160,7 @@ void jl_concurrent_gc_threadfun(void *arg)
     jl_ptls_t ptls = jl_init_threadtls(targ->tid);
 
     // wait for all threads
-    jl_gc_state_set(ptls, JL_GC_STATE_WAITING, 0);
+    jl_gc_state_set(ptls, JL_GC_STATE_WAITING, JL_GC_STATE_UNSAFE);
     uv_barrier_wait(targ->barrier);
 
     // free the thread argument here
@@ -190,7 +188,7 @@ void jl_threadfun(void *arg)
     JL_GC_PROMISE_ROOTED(ct);
 
     // wait for all threads
-    jl_gc_state_set(ptls, JL_GC_STATE_SAFE, 0);
+    jl_gc_state_set(ptls, JL_GC_STATE_SAFE, JL_GC_STATE_UNSAFE);
     uv_barrier_wait(targ->barrier);
 
     // free the thread argument here
diff --git a/src/signal-handling.c b/src/signal-handling.c
index abe63ba6d2d7f..2ddbf2ad1cc8e 100644
--- a/src/signal-handling.c
+++ b/src/signal-handling.c
@@ -440,7 +440,7 @@ void jl_task_frame_noreturn(jl_task_t *ct) JL_NOTSAFEPOINT
         ct->ptls->in_finalizer = 0;
         ct->ptls->defer_signal = 0;
         // forcibly exit GC (if we were in it) or safe into unsafe, without the mandatory safepoint
-        jl_atomic_store_release(&ct->ptls->gc_state, 0);
+        jl_atomic_store_release(&ct->ptls->gc_state, JL_GC_STATE_UNSAFE);
         // allow continuing to use a Task that should have already died--unsafe necromancy!
         jl_atomic_store_relaxed(&ct->_state, JL_TASK_STATE_RUNNABLE);
     }
diff --git a/src/threading.c b/src/threading.c
index 648f7d935bac2..dcfc6ac7e93bb 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -364,7 +364,7 @@ jl_ptls_t jl_init_threadtls(int16_t tid)
         }
     }
 #endif
-    jl_atomic_store_relaxed(&ptls->gc_state, 0); // GC unsafe
+    jl_atomic_store_relaxed(&ptls->gc_state, JL_GC_STATE_UNSAFE); // GC unsafe
     // Conditionally initialize the safepoint address. See comment in
     // `safepoint.c`
     if (tid == 0) {

From 848ae2c6491c909ec0bb93cb1b347927349cb6a6 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Thu, 16 Nov 2023 17:24:01 -0500
Subject: [PATCH 0996/1315] free more thread state in jl_delete_thread and GC

---
 src/gc-stacks.c           |  3 +++
 src/gc.c                  | 28 ++++++++++++++++++++++++++++
 src/threading.c           |  5 +++++
 src/work-stealing-queue.h |  6 ++++++
 4 files changed, 42 insertions(+)

diff --git a/src/gc-stacks.c b/src/gc-stacks.c
index 0318162289f11..7af1017cb55d9 100644
--- a/src/gc-stacks.c
+++ b/src/gc-stacks.c
@@ -223,6 +223,9 @@ void sweep_stack_pools(void)
                 void *stk = small_arraylist_pop(al);
                 free_stack(stk, pool_sizes[p]);
             }
+            if (jl_atomic_load_relaxed(&ptls2->current_task) == NULL) {
+                small_arraylist_free(al);
+            }
         }
 
         small_arraylist_t *live_tasks = &ptls2->heap.live_tasks;
diff --git a/src/gc.c b/src/gc.c
index c2d194b8a28bb..2b237ca95fe49 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -3775,6 +3775,22 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
         else {
             ptls2->heap.remset->len = 0;
         }
+        // free empty GC state for threads that have exited
+        if (ptls2->current_task == NULL) {
+            jl_thread_heap_t *heap = &ptls2->heap;
+            if (heap->weak_refs.len == 0)
+                small_arraylist_free(&heap->weak_refs);
+            if (heap->live_tasks.len == 0)
+                small_arraylist_free(&heap->live_tasks);
+            if (heap->remset->len == 0)
+                arraylist_free(heap->remset);
+            if (heap->last_remset->len == 0)
+                arraylist_free(heap->last_remset);
+            if (ptls2->finalizers.len == 0)
+                arraylist_free(&ptls->finalizers);
+            if (ptls2->sweep_objs.len == 0)
+                arraylist_free(&ptls->sweep_objs);
+        }
     }
 
 #ifdef __GLIBC__
@@ -3993,6 +4009,18 @@ void jl_init_thread_heap(jl_ptls_t ptls)
     jl_atomic_store_relaxed(&ptls->gc_num.allocd, -(int64_t)gc_num.interval);
 }
 
+void jl_free_thread_gc_state(jl_ptls_t ptls)
+{
+    jl_gc_markqueue_t *mq = &ptls->mark_queue;
+    ws_queue_t *cq = &mq->chunk_queue;
+    free_ws_array(jl_atomic_load_relaxed(&cq->array));
+    jl_atomic_store_relaxed(&cq->array, NULL);
+    ws_queue_t *q = &mq->ptr_queue;
+    free_ws_array(jl_atomic_load_relaxed(&q->array));
+    jl_atomic_store_relaxed(&q->array, NULL);
+    arraylist_free(&mq->reclaim_set);
+}
+
 // System-wide initializations
 void jl_gc_init(void)
 {
diff --git a/src/threading.c b/src/threading.c
index dcfc6ac7e93bb..97b2a247cd202 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -508,6 +508,11 @@ static void jl_delete_thread(void *value) JL_NOTSAFEPOINT_ENTER
 #else
     pthread_mutex_unlock(&in_signal_lock);
 #endif
+    free(ptls->bt_data);
+    // allow the page root_task is on to be freed
+    ptls->root_task = NULL;
+    void jl_free_thread_gc_state(jl_ptls_t ptls);
+    jl_free_thread_gc_state(ptls);
     // then park in safe-region
     (void)jl_gc_safe_enter(ptls);
 }
diff --git a/src/work-stealing-queue.h b/src/work-stealing-queue.h
index 5902c2ac6af9f..73c6e34e36de8 100644
--- a/src/work-stealing-queue.h
+++ b/src/work-stealing-queue.h
@@ -34,6 +34,12 @@ static inline ws_array_t *create_ws_array(size_t capacity, int32_t eltsz) JL_NOT
     return a;
 }
 
+static inline void free_ws_array(ws_array_t *a)
+{
+    free(a->buffer);
+    free(a);
+}
+
 typedef struct {
     _Atomic(int64_t) top;
     char _padding[JL_CACHE_BYTE_ALIGNMENT - sizeof(_Atomic(int64_t))];

From a125bc22c7ec2885dbc424631d597e9b322d2673 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 21 Nov 2023 17:55:51 -0500
Subject: [PATCH 0997/1315] free even more state for exited threads

---
 src/gc-stacks.c |  5 +++++
 src/gc.c        | 21 ++++++++++++++++++---
 src/threading.c |  5 ++++-
 3 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/src/gc-stacks.c b/src/gc-stacks.c
index 7af1017cb55d9..eb627ec39d409 100644
--- a/src/gc-stacks.c
+++ b/src/gc-stacks.c
@@ -203,6 +203,8 @@ void sweep_stack_pools(void)
     assert(gc_n_threads);
     for (int i = 0; i < gc_n_threads; i++) {
         jl_ptls_t ptls2 = gc_all_tls_states[i];
+        if (ptls2 == NULL)
+            continue;
 
         // free half of stacks that remain unused since last sweep
         for (int p = 0; p < JL_N_STACK_POOLS; p++) {
@@ -227,6 +229,9 @@ void sweep_stack_pools(void)
                 small_arraylist_free(al);
             }
         }
+        if (jl_atomic_load_relaxed(&ptls2->current_task) == NULL) {
+            small_arraylist_free(ptls2->heap.free_stacks);
+        }
 
         small_arraylist_t *live_tasks = &ptls2->heap.live_tasks;
         size_t n = 0;
diff --git a/src/gc.c b/src/gc.c
index 2b237ca95fe49..9edf863e28216 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1746,6 +1746,19 @@ void gc_free_pages(void)
     }
 }
 
+void gc_move_to_global_page_pool(jl_gc_page_stack_t *pgstack)
+{
+    while (1) {
+        jl_gc_pagemeta_t *pg = pop_lf_back(pgstack);
+        if (pg == NULL) {
+            break;
+        }
+        jl_gc_free_page(pg);
+        jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, -GC_PAGE_SZ);
+        push_lf_back(&global_page_pool_freed, pg);
+    }
+}
+
 // setup the data-structures for a sweep over all memory pools
 static void gc_sweep_pool(void)
 {
@@ -3776,7 +3789,8 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
             ptls2->heap.remset->len = 0;
         }
         // free empty GC state for threads that have exited
-        if (ptls2->current_task == NULL) {
+        if (jl_atomic_load_relaxed(&ptls2->current_task) == NULL &&
+            (ptls->tid < gc_first_tid || ptls2->tid >= gc_first_tid + jl_n_gcthreads)) {
             jl_thread_heap_t *heap = &ptls2->heap;
             if (heap->weak_refs.len == 0)
                 small_arraylist_free(&heap->weak_refs);
@@ -3787,9 +3801,10 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
             if (heap->last_remset->len == 0)
                 arraylist_free(heap->last_remset);
             if (ptls2->finalizers.len == 0)
-                arraylist_free(&ptls->finalizers);
+                arraylist_free(&ptls2->finalizers);
             if (ptls2->sweep_objs.len == 0)
-                arraylist_free(&ptls->sweep_objs);
+                arraylist_free(&ptls2->sweep_objs);
+            gc_move_to_global_page_pool(&ptls2->page_metadata_buffered);
         }
     }
 
diff --git a/src/threading.c b/src/threading.c
index 97b2a247cd202..2eecb59db1f17 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -435,6 +435,8 @@ JL_DLLEXPORT jl_gcframe_t **jl_adopt_thread(void)
 void jl_task_frame_noreturn(jl_task_t *ct) JL_NOTSAFEPOINT;
 void scheduler_delete_thread(jl_ptls_t ptls) JL_NOTSAFEPOINT;
 
+void jl_free_thread_gc_state(jl_ptls_t ptls);
+
 static void jl_delete_thread(void *value) JL_NOTSAFEPOINT_ENTER
 {
 #ifndef _OS_WINDOWS_
@@ -509,9 +511,10 @@ static void jl_delete_thread(void *value) JL_NOTSAFEPOINT_ENTER
     pthread_mutex_unlock(&in_signal_lock);
 #endif
     free(ptls->bt_data);
+    small_arraylist_free(&ptls->locks);
+    ptls->previous_exception = NULL;
     // allow the page root_task is on to be freed
     ptls->root_task = NULL;
-    void jl_free_thread_gc_state(jl_ptls_t ptls);
     jl_free_thread_gc_state(ptls);
     // then park in safe-region
     (void)jl_gc_safe_enter(ptls);

From 37c48e8b11d4742818571405019d80b59fceab49 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Fri, 23 Feb 2024 07:06:06 +0800
Subject: [PATCH 0998/1315] =?UTF-8?q?Subtype:=20skip=20slow-path=20in=20`l?=
 =?UTF-8?q?ocal=5F=E2=88=80=5F=E2=88=83=5Fsubtype`=20if=20inputs=20contain?=
 =?UTF-8?q?=20no=20=E2=88=83=20typevar.=20(#53429)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This should be safe as ∀ vars' bounds are frozen in env.
If there's no ∃ var, then the current env won't change after
`local_∀_∃_subtype`.
Thus, the slow path should be equivalent to the fast path if the latter
returns 1.
Close #53371.
---
 src/jltypes.c        |  2 +-
 src/julia_internal.h |  1 +
 src/subtype.c        | 31 +++++++++++++++++++++++++++----
 test/subtype.jl      |  9 +++++++++
 4 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/src/jltypes.c b/src/jltypes.c
index 1d743e175cec9..896e8f7b676c8 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -217,7 +217,7 @@ JL_DLLEXPORT jl_array_t *jl_find_free_typevars(jl_value_t *v)
 }
 
 // test whether a type has vars bound by the given environment
-static int jl_has_bound_typevars(jl_value_t *v, jl_typeenv_t *env) JL_NOTSAFEPOINT
+int jl_has_bound_typevars(jl_value_t *v, jl_typeenv_t *env) JL_NOTSAFEPOINT
 {
     while (1) {
         if (jl_is_typevar(v)) {
diff --git a/src/julia_internal.h b/src/julia_internal.h
index bb2e664d2fdcc..bb98001fcb6e3 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -750,6 +750,7 @@ void jl_method_table_activate(jl_methtable_t *mt, jl_typemap_entry_t *newentry);
 jl_typemap_entry_t *jl_method_table_add(jl_methtable_t *mt, jl_method_t *method, jl_tupletype_t *simpletype);
 jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_args_t fptr) JL_GC_DISABLED;
 int jl_obviously_unequal(jl_value_t *a, jl_value_t *b);
+int jl_has_bound_typevars(jl_value_t *v, jl_typeenv_t *env) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_array_t *jl_find_free_typevars(jl_value_t *v);
 int jl_has_fixed_layout(jl_datatype_t *t);
 JL_DLLEXPORT int jl_struct_try_layout(jl_datatype_t *dt);
diff --git a/src/subtype.c b/src/subtype.c
index 600df9da8757e..4a797aab9831d 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -1512,6 +1512,23 @@ static int may_contain_union_decision(jl_value_t *x, jl_stenv_t *e, jl_typeenv_t
            may_contain_union_decision(xb ? xb->ub : ((jl_tvar_t *)x)->ub, e, &newlog);
 }
 
+static int has_exists_typevar(jl_value_t *x, jl_stenv_t *e) JL_NOTSAFEPOINT
+{
+    jl_typeenv_t *env = NULL;
+    jl_varbinding_t *v = e->vars;
+    while (v != NULL) {
+        if (v->right) {
+            jl_typeenv_t *newenv = (jl_typeenv_t*)alloca(sizeof(jl_typeenv_t));
+            newenv->var = v->var;
+            newenv->val = NULL;
+            newenv->prev = env;
+            env = newenv;
+        }
+        v = v->prev;
+    }
+    return env != NULL && jl_has_bound_typevars(x, env);
+}
+
 static int local_forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param, int limit_slow)
 {
     int16_t oldRmore = e->Runions.more;
@@ -1531,13 +1548,19 @@ static int local_forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t
         int count = 0, noRmore = 0;
         sub = _forall_exists_subtype(x, y, e, param, &count, &noRmore);
         pop_unionstate(&e->Runions, &oldRunions);
-        // we should not try the slow path if `forall_exists_subtype` has tested all cases;
-        // Once limit_slow == 1, also skip it if
-        // 1) `forall_exists_subtype` return false
+        // We could skip the slow path safely if
+        // 1) `_∀_∃_subtype` has tested all cases
+        // 2) `_∀_∃_subtype` returns 1 &&  `x` and `y` contain no ∃ typevar
+        // Once `limit_slow == 1`, also skip it if
+        // 1) `_∀_∃_subtype` returns 0
         // 2) the left `Union` looks big
+        // TODO: `limit_slow` ignores complexity from inner `local_∀_exists_subtype`.
         if (limit_slow == -1)
             limit_slow = kindx || kindy;
-        if (noRmore || (limit_slow && (count > 3  || !sub)))
+        int skip = noRmore || (limit_slow && (count > 3 || !sub)) ||
+                   (sub && (kindx || !has_exists_typevar(x, e)) &&
+                           (kindy || !has_exists_typevar(y, e)));
+        if (skip)
             e->Runions.more = oldRmore;
     }
     else {
diff --git a/test/subtype.jl b/test/subtype.jl
index c8197dbddbf6d..27e8fa604a5e9 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -2571,3 +2571,12 @@ let a = Tuple{Union{Nothing, Type{Pair{T1}} where T1}}
     b = Tuple{Type{X2} where X2<:(Pair{T2, Y2} where {Src, Z2<:Src, Y2<:Union{Val{Z2}, Z2}})} where T2
     @test !Base.has_free_typevars(typeintersect(a, b))
 end
+
+#issue 53371
+struct T53371{A,B,C,D,E} end
+S53371{A} = Union{Int, <:A}
+R53371{A} = Val{V} where V<:(T53371{B,C,D,E,F} where {B<:Val{A}, C<:S53371{B}, D<:S53371{B}, E<:S53371{B}, F<:S53371{B}})
+let S = Type{T53371{A, B, C, D, E}} where {A, B<:R53371{A}, C<:R53371{A}, D<:R53371{A}, E<:R53371{A}},
+    T = Type{T53371{A, B, C, D, E} where {A, B<:R53371{A}, C<:R53371{A}, D<:R53371{A}, E<:R53371{A}}}
+    @test !(S <: T)
+end

From bf965f31bd60dde77cefb71901dd2c521a070497 Mon Sep 17 00:00:00 2001
From: Peter Simon <simonp0420@users.noreply.github.com>
Date: Thu, 22 Feb 2024 19:31:51 -0800
Subject: [PATCH 0999/1315] =?UTF-8?q?Fix=20typos=20in=20docstrings=20for?=
 =?UTF-8?q?=20`in`=20and=20`=E2=88=89`=20(#53443)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 base/operators.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/operators.jl b/base/operators.jl
index 9fc8068ddf20e..26274307ba05c 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -1397,7 +1397,7 @@ or `k in keys(dict)`. For the collections mentioned above,
 the result is always a `Bool`.
 
 When broadcasting with `in.(items, collection)` or `items .∈ collection`, both
-`item` and `collection` are broadcasted over, which is often not what is intended.
+`items` and `collection` are broadcasted over, which is often not what is intended.
 For example, if both arguments are vectors (and the dimensions match), the result is
 a vector indicating whether each value in collection `items` is `in` the value at the
 corresponding position in `collection`. To get a vector indicating whether each value
@@ -1451,7 +1451,7 @@ in
 
 Negation of `∈` and `∋`, i.e. checks that `item` is not in `collection`.
 
-When broadcasting with `items .∉ collection`, both `item` and `collection` are
+When broadcasting with `items .∉ collection`, both `items` and `collection` are
 broadcasted over, which is often not what is intended. For example, if both arguments
 are vectors (and the dimensions match), the result is a vector indicating whether
 each value in collection `items` is not in the value at the corresponding position

From fee198beaba675772158ddc5faeeaf76beea612d Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Fri, 23 Feb 2024 08:46:36 +0100
Subject: [PATCH 1000/1315] Add debug variant of loader_trampolines.o (#53437)

This prevents a race condition when building 'julia-cli-debug
julia-cli-release' simultaneously (as we do for libjulia_jll, and also
generally seems appropriate given what is done for all other source
files.

Motivated by https://github.com/JuliaPackaging/Yggdrasil/pull/8151 so
I'll first see if it works there.

Closes #45002.
---
 cli/Makefile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/cli/Makefile b/cli/Makefile
index c72ebff2b9bfd..4e32c53b9a6f0 100644
--- a/cli/Makefile
+++ b/cli/Makefile
@@ -48,7 +48,7 @@ LIB_DOBJS := $(BUILDDIR)/loader_lib.dbg.obj
 # If this is an architecture that supports dynamic linking, link in a trampoline definition
 ifneq (,$(wildcard $(SRCDIR)/trampolines/trampolines_$(ARCH).S))
 LIB_OBJS += $(BUILDDIR)/loader_trampolines.o
-LIB_DOBJS += $(BUILDDIR)/loader_trampolines.o
+LIB_DOBJS += $(BUILDDIR)/loader_trampolines.dbg.obj
 endif
 
 default: release
@@ -65,6 +65,8 @@ $(BUILDDIR)/loader_exe.dbg.obj : $(SRCDIR)/loader_exe.c $(HEADERS) $(JULIAHOME)/
 	@$(call PRINT_CC, $(CC) $(DEBUGFLAGS) $(LOADER_CFLAGS) -c $< -o $@)
 $(BUILDDIR)/loader_trampolines.o : $(SRCDIR)/trampolines/trampolines_$(ARCH).S $(HEADERS) $(SRCDIR)/trampolines/common.h
 	@$(call PRINT_CC, $(CC) $(SHIPFLAGS) $(LOADER_CFLAGS) $< -c -o $@)
+$(BUILDDIR)/loader_trampolines.dbg.obj : $(SRCDIR)/trampolines/trampolines_$(ARCH).S $(HEADERS) $(SRCDIR)/trampolines/common.h
+	@$(call PRINT_CC, $(CC) $(DEBUGFLAGS) $(LOADER_CFLAGS) $< -c -o $@)
 
 # Debugging target to help us see what kind of code is being generated for our trampolines
 dump-trampolines: $(SRCDIR)/trampolines/trampolines_$(ARCH).S

From 6e1d062bccf0147b849461c7c09ddd03d94f71dc Mon Sep 17 00:00:00 2001
From: tecosaur <git@tecosaur.net>
Date: Fri, 23 Feb 2024 16:16:42 +0800
Subject: [PATCH 1001/1315] Add annotate! method for AnnotatedIOBuffer (#53284)

The annotate! function provides a convenient way of adding annotations
to an AnnotatedString/AnnotatedChar without accessing any of the
implementation details of the Annotated* types.

When AnnotatedIOBuffer was introduced, an appropriate annotations method
was added, but annotate! was missed. To correct that, we refactor the
current annotate! method for AnnotatedString to a more general helper
function _annotate! that operates on the annotation vector itself, and
use this new helper method to easily provide an annotate! method for
AnnotatedIOBuffer.
---
 base/strings/annotated.jl | 33 +++++++++++++++++++--------------
 test/strings/annotated.jl |  6 ++++++
 2 files changed, 25 insertions(+), 14 deletions(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 1b1130335f013..a85cdf1b08bbb 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -316,28 +316,30 @@ reverse(s::SubString{<:AnnotatedString}) = reverse(AnnotatedString(s))
 
 ## End AbstractString interface ##
 
-"""
-    annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol => value)
-    annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol => value)
-
-Annotate a `range` of `str` (or the entire string) with a labeled value (`label` => `value`).
-To remove existing `label` annotations, use a value of `nothing`.
-"""
-function annotate!(s::AnnotatedString, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any}))
+function _annotate!(annlist::Vector{Tuple{UnitRange{Int}, Pair{Symbol, Any}}}, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any}))
     label, val = labelval
     if val === nothing
-        indices = searchsorted(s.annotations, (range,), by=first)
-        labelindex = filter(i -> first(s.annotations[i][2]) === label, indices)
+        indices = searchsorted(annlist, (range,), by=first)
+        labelindex = filter(i -> first(annlist[i][2]) === label, indices)
         for index in Iterators.reverse(labelindex)
-            deleteat!(s.annotations, index)
+            deleteat!(annlist, index)
         end
     else
-        sortedindex = searchsortedlast(s.annotations, (range,), by=first) + 1
-        insert!(s.annotations, sortedindex, (range, Pair{Symbol, Any}(label, val)))
+        sortedindex = searchsortedlast(annlist, (range,), by=first) + 1
+        insert!(annlist, sortedindex, (range, Pair{Symbol, Any}(label, val)))
     end
-    s
 end
 
+"""
+    annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol => value)
+    annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol => value)
+
+Annotate a `range` of `str` (or the entire string) with a labeled value (`label` => `value`).
+To remove existing `label` annotations, use a value of `nothing`.
+"""
+annotate!(s::AnnotatedString, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any})) =
+    (_annotate!(s.annotations, range, labelval); s)
+
 annotate!(ss::AnnotatedString, @nospecialize(labelval::Pair{Symbol, <:Any})) =
     annotate!(ss, firstindex(ss):lastindex(ss), labelval)
 
@@ -426,6 +428,9 @@ copy(io::AnnotatedIOBuffer) = AnnotatedIOBuffer(copy(io.io), copy(io.annotations
 
 annotations(io::AnnotatedIOBuffer) = io.annotations
 
+annotate!(io::AnnotatedIOBuffer, range::UnitRange{Int}, @nospecialize(labelval::Pair{Symbol, <:Any})) =
+    (_annotate!(io.annotations, range, labelval); io)
+
 function write(io::AnnotatedIOBuffer, astr::Union{AnnotatedString, SubString{<:AnnotatedString}})
     astr = AnnotatedString(astr)
     offset = position(io.io)
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index 9d812deea51f8..fda583bf7f778 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -115,6 +115,12 @@ end
     @test write(aio, ' ') == 1
     @test write(aio, Base.AnnotatedString("world", [(1:5, :tag => 2)])) == 5
     @test Base.annotations(aio) == [(1:5, :tag => 1), (7:11, :tag => 2)]
+    # Check `annotate!`, including region sorting
+    @test truncate(aio, 0).io.size == 0
+    @test write(aio, "hello world") == ncodeunits("hello world")
+    @test Base.annotate!(aio, 7:11, :tag => 2) === aio
+    @test Base.annotate!(aio, 1:5, :tag => 1) === aio
+    @test Base.annotations(aio) == [(1:5, :tag => 1), (7:11, :tag => 2)]
     # Reading
     @test read(seekstart(deepcopy(aio.io)), String) == "hello world"
     @test read(seekstart(deepcopy(aio)), String) == "hello world"

From 6cbed3198554381a6ed57b2d81f6c2ae0adfc4e5 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 23 Feb 2024 11:16:17 -0500
Subject: [PATCH 1002/1315] staticdata: fix assert from partially disabled
 native code (#53439)

This should fix the assertion failure that has been plaguing the Pkg
tests, as discussed in https://github.com/JuliaLang/julia/pull/52123#issuecomment-1959965395
---
 src/staticdata.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/staticdata.c b/src/staticdata.c
index f899899aff242..c8fd4053aaf73 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -3768,8 +3768,11 @@ JL_DLLEXPORT jl_value_t *jl_restore_package_image_from_file(const char *fname, j
 
     jl_image_t pkgimage = jl_init_processor_pkgimg(pkgimg_handle);
 
-    if (ignore_native){
-        memset(&pkgimage.fptrs, 0, sizeof(pkgimage.fptrs));
+    if (ignore_native) {
+        // Must disable using native code in possible downstream users of this code:
+        // https://github.com/JuliaLang/julia/pull/52123#issuecomment-1959965395.
+        // The easiest way to do that is to disable it in all of them.
+        jl_options.use_sysimage_native_code = JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_NO;
     }
 
     jl_value_t* mod = jl_restore_incremental_from_buf(pkgimg_handle, pkgimg_data, &pkgimage, *plen, depmods, completeinfo, pkgname, 0);

From 2ebb896f45ecd9ff385f37cb83c8b65fbccbd090 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Fri, 23 Feb 2024 16:40:57 -0300
Subject: [PATCH 1003/1315] Audit sequential consistent atomic usage in the
 codebase (#53440)

---
 src/ccall.cpp   | 10 +++++-----
 src/cgutils.cpp |  2 +-
 src/codegen.cpp | 10 +++++-----
 src/gc-stacks.c |  8 ++++----
 src/gc.c        | 10 +++++-----
 src/module.c    |  2 +-
 src/symbol.c    |  4 ++--
 7 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/ccall.cpp b/src/ccall.cpp
index b71d86623065f..5dd23d083186a 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -80,7 +80,7 @@ static bool runtime_sym_gvs(jl_codectx_t &ctx, const char *f_lib, const char *f_
     else {
         std::string name = "ccalllib_";
         name += llvm::sys::path::filename(f_lib);
-        name += std::to_string(jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1));
+        name += std::to_string(jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1));
         runtime_lib = true;
         auto &libgv = ctx.emission_context.libMapGV[f_lib];
         if (libgv.first == NULL) {
@@ -100,7 +100,7 @@ static bool runtime_sym_gvs(jl_codectx_t &ctx, const char *f_lib, const char *f_
         std::string name = "ccall_";
         name += f_name;
         name += "_";
-        name += std::to_string(jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1));
+        name += std::to_string(jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1));
         auto T_pvoidfunc = JuliaType::get_pvoidfunc_ty(M->getContext());
         llvmgv = new GlobalVariable(*M, T_pvoidfunc, false,
                                     GlobalVariable::ExternalLinkage,
@@ -205,7 +205,7 @@ static Value *runtime_sym_lookup(
         std::string gvname = "libname_";
         gvname += f_name;
         gvname += "_";
-        gvname += std::to_string(jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1));
+        gvname += std::to_string(jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1));
         llvmgv = new GlobalVariable(*jl_Module, T_pvoidfunc, false,
                                     GlobalVariable::ExternalLinkage,
                                     Constant::getNullValue(T_pvoidfunc), gvname);
@@ -233,7 +233,7 @@ static GlobalVariable *emit_plt_thunk(
     libptrgv = prepare_global_in(M, libptrgv);
     llvmgv = prepare_global_in(M, llvmgv);
     std::string fname;
-    raw_string_ostream(fname) << "jlplt_" << f_name << "_" << jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1);
+    raw_string_ostream(fname) << "jlplt_" << f_name << "_" << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
     Function *plt = Function::Create(functype,
                                      GlobalVariable::PrivateLinkage,
                                      fname, M);
@@ -852,7 +852,7 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
     // Make sure to find a unique name
     std::string ir_name;
     while (true) {
-        raw_string_ostream(ir_name) << (ctx.f->getName().str()) << "u" << jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1);
+        raw_string_ostream(ir_name) << (ctx.f->getName().str()) << "u" << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
         if (jl_Module->getFunction(ir_name) == NULL)
             break;
     }
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 55dc18b8cfa04..695090f767546 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -355,7 +355,7 @@ static Constant *julia_pgv(jl_codectx_t &ctx, const char *cname, void *addr)
     StringRef localname;
     std::string gvname;
     if (!gv) {
-        uint64_t id = jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1); // TODO: use ctx.emission_context.global_targets.size()
+        uint64_t id = jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1); // TODO: use ctx.emission_context.global_targets.size()
         raw_string_ostream(gvname) << cname << id;
         localname = StringRef(gvname);
     }
diff --git a/src/codegen.cpp b/src/codegen.cpp
index c8e1ba9d4bdc7..bb9622c8e75c8 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -5048,7 +5048,7 @@ static jl_cgval_t emit_invoke(jl_codectx_t &ctx, const jl_cgval_t &lival, ArrayR
                         }
                     }
                     if (need_to_emit) {
-                        raw_string_ostream(name) << (specsig ? "j_" : "j1_") << name_from_method_instance(mi) << "_" << jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1);
+                        raw_string_ostream(name) << (specsig ? "j_" : "j1_") << name_from_method_instance(mi) << "_" << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
                         protoname = StringRef(name);
                     }
                     jl_returninfo_t::CallingConv cc = jl_returninfo_t::CallingConv::Boxed;
@@ -6523,7 +6523,7 @@ static Function *emit_tojlinvoke(jl_code_instance_t *codeinst, Module *M, jl_cod
     ++EmittedToJLInvokes;
     jl_codectx_t ctx(M->getContext(), params, codeinst);
     std::string name;
-    raw_string_ostream(name) << "tojlinvoke" << jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1);
+    raw_string_ostream(name) << "tojlinvoke" << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
     Function *f = Function::Create(ctx.types().T_jlfunc,
             GlobalVariable::InternalLinkage,
             name, M);
@@ -6747,7 +6747,7 @@ static Function* gen_cfun_wrapper(
     }
 
     std::string funcName;
-    raw_string_ostream(funcName) << "jlcapi_" << name << "_" << jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1);
+    raw_string_ostream(funcName) << "jlcapi_" << name << "_" << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
 
     Module *M = into; // Safe because ctx lock is held by params
     AttributeList attributes = sig.attributes;
@@ -7861,7 +7861,7 @@ static std::string get_function_name(bool specsig, bool needsparams, const char
         if (unadorned_name[0] == '@')
             unadorned_name++;
     }
-    funcName << unadorned_name << "_" << jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1);
+    funcName << unadorned_name << "_" << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
     return funcName.str();
 }
 
@@ -8091,7 +8091,7 @@ static jl_llvm_functions_t
         }();
 
         std::string wrapName;
-        raw_string_ostream(wrapName) << "jfptr_" << ctx.name << "_" << jl_atomic_fetch_add(&globalUniqueGeneratedNames, 1);
+        raw_string_ostream(wrapName) << "jfptr_" << ctx.name << "_" << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
         declarations.functionObject = wrapName;
         (void)gen_invoke_wrapper(lam, jlrettype, returninfo, retarg, declarations.functionObject, M, ctx.emission_context);
         // TODO: add attributes: maybe_mark_argument_dereferenceable(Arg, argType)
diff --git a/src/gc-stacks.c b/src/gc-stacks.c
index 0318162289f11..07c585c54372c 100644
--- a/src/gc-stacks.c
+++ b/src/gc-stacks.c
@@ -37,7 +37,7 @@ static void *malloc_stack(size_t bufsz) JL_NOTSAFEPOINT
         VirtualFree(stk, 0, MEM_RELEASE);
         return MAP_FAILED;
     }
-    jl_atomic_fetch_add(&num_stack_mappings, 1);
+    jl_atomic_fetch_add_relaxed(&num_stack_mappings, 1);
     return stk;
 }
 
@@ -45,7 +45,7 @@ static void *malloc_stack(size_t bufsz) JL_NOTSAFEPOINT
 static void free_stack(void *stkbuf, size_t bufsz)
 {
     VirtualFree(stkbuf, 0, MEM_RELEASE);
-    jl_atomic_fetch_add(&num_stack_mappings, -1);
+    jl_atomic_fetch_add_relaxed(&num_stack_mappings, -1);
 }
 
 #else
@@ -62,14 +62,14 @@ static void *malloc_stack(size_t bufsz) JL_NOTSAFEPOINT
         return MAP_FAILED;
     }
 #endif
-    jl_atomic_fetch_add(&num_stack_mappings, 1);
+    jl_atomic_fetch_add_relaxed(&num_stack_mappings, 1);
     return stk;
 }
 
 static void free_stack(void *stkbuf, size_t bufsz)
 {
     munmap(stkbuf, bufsz);
-    jl_atomic_fetch_add(&num_stack_mappings, -1);
+    jl_atomic_fetch_add_relaxed(&num_stack_mappings, -1);
 }
 #endif
 
diff --git a/src/gc.c b/src/gc.c
index c2d194b8a28bb..fed3ca5022c0c 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1404,8 +1404,8 @@ JL_DLLEXPORT double jl_gc_page_utilization_stats[JL_GC_N_MAX_POOLS];
 STATIC_INLINE void gc_update_page_fragmentation_data(jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT
 {
     gc_fragmentation_stat_t *stats = &gc_page_fragmentation_stats[pg->pool_n];
-    jl_atomic_fetch_add(&stats->n_freed_objs, pg->nfree);
-    jl_atomic_fetch_add(&stats->n_pages_allocd, 1);
+    jl_atomic_fetch_add_relaxed(&stats->n_freed_objs, pg->nfree);
+    jl_atomic_fetch_add_relaxed(&stats->n_pages_allocd, 1);
 }
 
 STATIC_INLINE void gc_dump_page_utilization_data(void) JL_NOTSAFEPOINT
@@ -1558,8 +1558,8 @@ static void gc_sweep_page(gc_page_profiler_serializer_t *s, jl_gc_pool_t *p, jl_
     gc_update_page_fragmentation_data(pg);
     gc_time_count_page(freedall, pg_skpd);
     jl_ptls_t ptls = gc_all_tls_states[pg->thread_n];
-    jl_atomic_fetch_add(&ptls->gc_num.pool_live_bytes, GC_PAGE_SZ - GC_PAGE_OFFSET - nfree * osize);
-    jl_atomic_fetch_add((_Atomic(int64_t) *)&gc_num.freed, (nfree - old_nfree) * osize);
+    jl_atomic_fetch_add_relaxed(&ptls->gc_num.pool_live_bytes, GC_PAGE_SZ - GC_PAGE_OFFSET - nfree * osize); //TODO: Could we avoid doing a fetch_add here?
+    jl_atomic_fetch_add_relaxed((_Atomic(int64_t) *)&gc_num.freed, (nfree - old_nfree) * osize);
 }
 
 // the actual sweeping over all allocated pages in a memory pool
@@ -3839,7 +3839,7 @@ JL_DLLEXPORT void jl_gc_collect(jl_gc_collection_t collection)
         size_t localbytes = jl_atomic_load_relaxed(&ptls->gc_num.allocd) + gc_num.interval;
         jl_atomic_store_relaxed(&ptls->gc_num.allocd, -(int64_t)gc_num.interval);
         static_assert(sizeof(_Atomic(uint64_t)) == sizeof(gc_num.deferred_alloc), "");
-        jl_atomic_fetch_add((_Atomic(uint64_t)*)&gc_num.deferred_alloc, localbytes);
+        jl_atomic_fetch_add_relaxed((_Atomic(uint64_t)*)&gc_num.deferred_alloc, localbytes);
         return;
     }
     jl_gc_debug_print();
diff --git a/src/module.c b/src/module.c
index 44b89bc236afc..7a12552415b11 100644
--- a/src/module.c
+++ b/src/module.c
@@ -59,7 +59,7 @@ JL_DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name, jl_module_t *parent)
 
 uint32_t jl_module_next_counter(jl_module_t *m)
 {
-    return jl_atomic_fetch_add(&m->counter, 1);
+    return jl_atomic_fetch_add_relaxed(&m->counter, 1);
 }
 
 JL_DLLEXPORT jl_value_t *jl_f_new_module(jl_sym_t *name, uint8_t std_imports, uint8_t default_names)
diff --git a/src/symbol.c b/src/symbol.c
index c9c0c0e533924..b488a0cc77065 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -129,7 +129,7 @@ JL_DLLEXPORT jl_sym_t *jl_gensym(void)
 {
     char name[16];
     char *n;
-    uint32_t ctr = jl_atomic_fetch_add(&gs_ctr, 1);
+    uint32_t ctr = jl_atomic_fetch_add_relaxed(&gs_ctr, 1);
     n = uint2str(&name[2], sizeof(name)-2, ctr, 10);
     *(--n) = '#'; *(--n) = '#';
     return jl_symbol(n);
@@ -153,7 +153,7 @@ JL_DLLEXPORT jl_sym_t *jl_tagged_gensym(const char *str, size_t len)
     name[1] = '#';
     name[2 + len] = '#';
     memcpy(name + 2, str, len);
-    uint32_t ctr = jl_atomic_fetch_add(&gs_ctr, 1);
+    uint32_t ctr = jl_atomic_fetch_add_relaxed(&gs_ctr, 1);
     n = uint2str(gs_name, sizeof(gs_name), ctr, 10);
     memcpy(name + 3 + len, n, sizeof(gs_name) - (n - gs_name));
     jl_sym_t *sym = _jl_symbol(name, alloc_len - (n - gs_name)- 1);

From ea1a0d2512be72a4568348e6b5fdfbbe687436c3 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Fri, 23 Feb 2024 14:59:20 -0500
Subject: [PATCH 1004/1315] when loading code for internal purposes, load
 stdlib files directly(#53326)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This bypasses DEPOT_PATH, LOAD_PATH, and stale checks when loading
known stdlib code for known purposes from known locations, specifically
to avoid the problem that I cannot fix my tools because I have used my
tools to break my tools.

This helps avoid the situation that the user can break important Pkg,
REPL, Socket or similar features simply because they chose to remove
`@stdlib` from their environment. For example, if you make an edit to
REPL, then this will trigger recompilation and load the edited version:
```
$ ./julia -e 'using REPL' -iq
┌ Info: Precompiling REPL [3fa0cd96-eef1-5676-8a61-b3b8758bbffb] (cache misses: include_dependency fsize change (2), invalid header (10), mismatched flags (1))
└ @ Base loading.jl:2643
julia>
```
But this will load the version that shipped with Julia, regardless of
the state of the cache or the source code (unless you delete the cache
files):
```
$ ./julia -iq
julia>
```

Fixes #53365
---
 base/Base.jl                                  |   3 +-
 base/client.jl                                |   7 +-
 base/loading.jl                               | 311 +++++++++++-------
 base/stream.jl                                |   4 +-
 base/util.jl                                  |   2 +-
 .../InteractiveUtils/src/InteractiveUtils.jl  |   4 +-
 stdlib/LinearAlgebra/src/LinearAlgebra.jl     |   2 +-
 stdlib/REPL/src/REPL.jl                       |  22 +-
 test/precompile.jl                            |   6 +-
 9 files changed, 210 insertions(+), 151 deletions(-)

diff --git a/base/Base.jl b/base/Base.jl
index c729ab9ca707e..e02b132aae6e4 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -629,8 +629,7 @@ function profile_printing_listener(cond::Base.AsyncCondition)
     profile = nothing
     try
         while _trywait(cond)
-            # this call to require is mostly legal, only because Profile has no dependencies and is usually in LOAD_PATH
-            profile = @something(profile, require(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))::Module
+            profile = @something(profile, require_stdlib(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))::Module
             invokelatest(profile.peek_report[])
             if Base.get_bool_env("JULIA_PROFILE_PEEK_HEAP_SNAPSHOT", false) === true
                 println(stderr, "Saving heap snapshot...")
diff --git a/base/client.jl b/base/client.jl
index 201792c786b51..31a3016489dcd 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -260,7 +260,7 @@ function exec_options(opts)
     # Load Distributed module only if any of the Distributed options have been specified.
     distributed_mode = (opts.worker == 1) || (opts.nprocs > 0) || (opts.machine_file != C_NULL)
     if distributed_mode
-        let Distributed = require(PkgId(UUID((0x8ba89e20_285c_5b6f, 0x9357_94700520ee1b)), "Distributed"))
+        let Distributed = require_stdlib(PkgId(UUID((0x8ba89e20_285c_5b6f, 0x9357_94700520ee1b)), "Distributed"))
             Core.eval(MainInclude, :(const Distributed = $Distributed))
             Core.eval(Main, :(using Base.MainInclude.Distributed))
         end
@@ -386,7 +386,8 @@ function load_InteractiveUtils(mod::Module=Main)
     # load interactive-only libraries
     if !isdefined(MainInclude, :InteractiveUtils)
         try
-            let InteractiveUtils = require(PkgId(UUID(0xb77e0a4c_d291_57a0_90e8_8db25a27a240), "InteractiveUtils"))
+            # TODO: we have to use require_stdlib here because it is a dependency of REPL, but we would sort of prefer not to
+            let InteractiveUtils = require_stdlib(PkgId(UUID(0xb77e0a4c_d291_57a0_90e8_8db25a27a240), "InteractiveUtils"))
                 Core.eval(MainInclude, :(const InteractiveUtils = $InteractiveUtils))
             end
         catch ex
@@ -401,7 +402,7 @@ end
 function load_REPL()
     # load interactive-only libraries
     try
-        return Base.require(PkgId(UUID(0x3fa0cd96_eef1_5676_8a61_b3b8758bbffb), "REPL"))
+        return Base.require_stdlib(PkgId(UUID(0x3fa0cd96_eef1_5676_8a61_b3b8758bbffb), "REPL"))
     catch ex
         @warn "Failed to import REPL" exception=(ex, catch_backtrace())
     end
diff --git a/base/loading.jl b/base/loading.jl
index 3c7bb28cfdd17..2be97237238dd 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -256,9 +256,9 @@ struct LoadingCache
     env_project_file::Dict{String, Union{Bool, String}}
     project_file_manifest_path::Dict{String, Union{Nothing, String}}
     require_parsed::Set{String}
-    identified_where::Dict{Tuple{PkgId, String}, Union{Nothing, Tuple{PkgId, Union{Nothing, String}}}}
-    identified::Dict{String, Union{Nothing, Tuple{PkgId, Union{Nothing, String}}}}
-    located::Dict{Tuple{PkgId, Union{String, Nothing}}, Union{Tuple{Union{String, Nothing}, Union{String, Nothing}}, Nothing}}
+    identified_where::Dict{Tuple{PkgId, String}, Union{Nothing, Tuple{PkgId, String}}}
+    identified::Dict{String, Union{Nothing, Tuple{PkgId, String}}}
+    located::Dict{Tuple{PkgId, Union{String, Nothing}}, Union{Tuple{String, String}, Nothing}}
 end
 const LOADING_CACHE = Ref{Union{LoadingCache, Nothing}}(nothing)
 LoadingCache() = LoadingCache(load_path(), Dict(), Dict(), Dict(), Set(), Dict(), Dict(), Dict())
@@ -298,7 +298,7 @@ end
 ## package identification: determine unique identity of package to be loaded ##
 
 # Used by Pkg but not used in loading itself
-function find_package(arg)
+function find_package(arg) # ::Union{Nothing,String}
     pkgenv = identify_package_env(arg)
     pkgenv === nothing && return nothing
     pkg, env = pkgenv
@@ -307,21 +307,21 @@ end
 
 """
     Base.identify_package_env(name::String)::Union{Tuple{PkgId, String}, Nothing}
-    Base.identify_package_env(where::Union{Module,PkgId}, name::String)::Union{Tuple{PkgId, String} Nothing}
+    Base.identify_package_env(where::Union{Module,PkgId}, name::String)::Union{Tuple{PkgId, Union{String, Nothing}}, Nothing}
 
 Same as [`Base.identify_package`](@ref) except that the path to the environment where the package is identified
-is also returned.
+is also returned, except when the identity is not identified.
 """
 identify_package_env(where::Module, name::String) = identify_package_env(PkgId(where), name)
 function identify_package_env(where::PkgId, name::String)
     cache = LOADING_CACHE[]
     if cache !== nothing
-        pkg_env = get(cache.identified_where, (where, name), nothing)
-        pkg_env === nothing || return pkg_env
+        pkg_env = get(cache.identified_where, (where, name), missing)
+        pkg_env === missing || return pkg_env
     end
     pkg_env = nothing
     if where.name === name
-        pkg_env = where, nothing
+        return (where, nothing)
     elseif where.uuid === nothing
         pkg_env = identify_package_env(name) # ignore `where`
     else
@@ -342,8 +342,8 @@ end
 function identify_package_env(name::String)
     cache = LOADING_CACHE[]
     if cache !== nothing
-        pkg_env = get(cache.identified, name, nothing)
-        pkg_env === nothing || return pkg_env
+        pkg_env = get(cache.identified, name, missing)
+        pkg_env === missing || return pkg_env
     end
     pkg_env = nothing
     for env in load_path()
@@ -390,17 +390,16 @@ identify_package(where::Module, name::String) = _nothing_or_first(identify_packa
 identify_package(where::PkgId, name::String)  = _nothing_or_first(identify_package_env(where, name))
 identify_package(name::String)                = _nothing_or_first(identify_package_env(name))
 
-function locate_package_env(pkg::PkgId, stopenv::Union{String, Nothing}=nothing)
+function locate_package_env(pkg::PkgId, stopenv::Union{String, Nothing}=nothing)::Union{Nothing,Tuple{String,String}}
     cache = LOADING_CACHE[]
     if cache !== nothing
-        pathenv = get(cache.located, (pkg, stopenv), nothing)
-        pathenv === nothing || return pathenv
+        pathenv = get(cache.located, (pkg, stopenv), missing)
+        pathenv === missing || return pathenv
     end
     path = nothing
     env′ = nothing
     if pkg.uuid === nothing
         for env in load_path()
-            env′ = env
             # look for the toplevel pkg `pkg.name` in this entry
             found = project_deps_get(env, pkg.name)
             if found !== nothing
@@ -410,6 +409,7 @@ function locate_package_env(pkg::PkgId, stopenv::Union{String, Nothing}=nothing)
                     # return the path the entry point for the code, if it could be found
                     # otherwise, signal failure
                     path = implicit_manifest_uuid_path(env, pkg)
+                    env′ = env
                     @goto done
                 end
             end
@@ -419,7 +419,6 @@ function locate_package_env(pkg::PkgId, stopenv::Union{String, Nothing}=nothing)
         end
     else
         for env in load_path()
-            env′ = env
             path = manifest_uuid_path(env, pkg)
             # missing is used as a sentinel to stop looking further down in envs
             if path === missing
@@ -428,6 +427,7 @@ function locate_package_env(pkg::PkgId, stopenv::Union{String, Nothing}=nothing)
             end
             if path !== nothing
                 path = entry_path(path, pkg.name)
+                env′ = env
                 @goto done
             end
             if !(loading_extension || precompiling_extension)
@@ -439,14 +439,16 @@ function locate_package_env(pkg::PkgId, stopenv::Union{String, Nothing}=nothing)
         mbypath = manifest_uuid_path(Sys.STDLIB, pkg)
         if mbypath isa String
             path = entry_path(mbypath, pkg.name)
+            env′ = Sys.STDLIB
             @goto done
         end
     end
     @label done
     if cache !== nothing
-        cache.located[(pkg, stopenv)] = path, env′
+        cache.located[(pkg, stopenv)] = path === nothing ? nothing : (path, something(env′))
     end
-    return path, env′
+    path === nothing && return nothing
+    return path, something(env′)
 end
 
 """
@@ -1083,11 +1085,12 @@ end
 # want it to pick up caches that already exist for other optimization levels
 const ignore_compiled_cache = PkgId[]
 
-function find_all_in_cache_path(pkg::PkgId)
+function find_all_in_cache_path(pkg::PkgId, DEPOT_PATH::typeof(DEPOT_PATH)=DEPOT_PATH)
     paths = String[]
     pkg in ignore_compiled_cache && return paths
     entrypath, entryfile = cache_file_entry(pkg)
-    for path in joinpath.(DEPOT_PATH, entrypath)
+    for path in DEPOT_PATH
+        path = joinpath(path, entrypath)
         isdir(path) || continue
         for file in readdir(path, sort = false) # no sort given we sort later
             if !((pkg.uuid === nothing && file == entryfile * ".ji") ||
@@ -1142,6 +1145,8 @@ cachefile_from_ocachefile(cachefile) = string(chopsuffix(cachefile, ".$(Libc.Lib
 # use an Int counter so that nested @time_imports calls all remain open
 const TIMING_IMPORTS = Threads.Atomic{Int}(0)
 
+# loads a precompile cache file, ignoring stale_cachefile tests
+# assuming all depmods are already loaded and everything is valid
 # these return either the array of modules loaded from the path / content given
 # or an Exception that describes why it couldn't be loaded
 # and it reconnects the Base.Docs.META
@@ -1169,6 +1174,15 @@ function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{No
         t_comp_before = cumulative_compile_time_ns()
     end
 
+    for i in 1:length(depmods)
+        dep = depmods[i]
+        dep isa Module && continue
+        _, depkey, depbuild_id = dep::Tuple{String, PkgId, UInt128}
+        @assert root_module_exists(depkey)
+        dep = root_module(depkey)
+        depmods[i] = dep
+    end
+
     if ocachepath !== nothing
         @debug "Loading object cache file $ocachepath for $(repr("text/plain", pkg))"
         sv = ccall(:jl_restore_package_image_from_file, Any, (Cstring, Any, Cint, Cstring, Cint), ocachepath, depmods, false, pkg.name, ignore_native)
@@ -1314,9 +1328,6 @@ function insert_extension_triggers(pkg::PkgId)
     path_env_loc = locate_package_env(pkg)
     path_env_loc === nothing && return
     path, env_loc = path_env_loc
-    if path === nothing || env_loc === nothing
-        return
-    end
     insert_extension_triggers(env_loc, pkg)
 end
 
@@ -1637,7 +1648,7 @@ function isprecompiled(pkg::PkgId;
         cachepaths::Vector{String}=Base.find_all_in_cache_path(pkg),
         sourcepath::Union{String,Nothing}=Base.locate_package(pkg),
         flags::CacheFlags=CacheFlags())
-    isnothing(sourcepath) && error("Cannot locate source for $(repr(pkg))")
+    isnothing(sourcepath) && error("Cannot locate source for $(repr("text/plain", pkg))")
     for path_to_try in cachepaths
         staledeps = stale_cachefile(sourcepath, path_to_try, ignore_loaded = true, requested_flags=flags)
         if staledeps === true
@@ -1674,10 +1685,9 @@ function isprecompiled(pkg::PkgId;
     return false
 end
 
-# loads a precompile cache file, after checking stale_cachefile tests
+# search for a precompile cache file to load, after some various checks
 function _tryrequire_from_serialized(modkey::PkgId, build_id::UInt128)
     assert_havelock(require_lock)
-    loaded = nothing
     if root_module_exists(modkey)
         loaded = root_module(modkey)
     else
@@ -1687,7 +1697,7 @@ function _tryrequire_from_serialized(modkey::PkgId, build_id::UInt128)
                 modpath = locate_package(modkey)
                 modpath === nothing && return nothing
                 set_pkgorigin_version_path(modkey, String(modpath))
-                loaded = _require_search_from_serialized(modkey, String(modpath), build_id)
+                loaded = _require_search_from_serialized(modkey, String(modpath), build_id, true)
             finally
                 end_loading(modkey, loaded)
             end
@@ -1697,46 +1707,10 @@ function _tryrequire_from_serialized(modkey::PkgId, build_id::UInt128)
             end
         end
     end
-    if !(loaded isa Module) || PkgId(loaded) != modkey
-        return ErrorException("Required dependency $modkey failed to load from a cache file.")
+    if loaded isa Module && PkgId(loaded) == modkey && module_build_id(loaded) === build_id
+        return loaded
     end
-    return loaded
-end
-
-# loads a precompile cache file, ignoring stale_cachefile tests
-# assuming all depmods are already loaded and everything is valid
-function _tryrequire_from_serialized(modkey::PkgId, path::String, ocachepath::Union{Nothing, String}, sourcepath::String, depmods::Vector{Any})
-    assert_havelock(require_lock)
-    loaded = nothing
-    if root_module_exists(modkey)
-        loaded = root_module(modkey)
-    else
-        loaded = start_loading(modkey)
-        if loaded === nothing
-            try
-                for i in 1:length(depmods)
-                    dep = depmods[i]
-                    dep isa Module && continue
-                    _, depkey, depbuild_id = dep::Tuple{String, PkgId, UInt128}
-                    @assert root_module_exists(depkey)
-                    dep = root_module(depkey)
-                    depmods[i] = dep
-                end
-                set_pkgorigin_version_path(modkey, sourcepath)
-                loaded = _include_from_serialized(modkey, path, ocachepath, depmods)
-            finally
-                end_loading(modkey, loaded)
-            end
-            if loaded isa Module
-                insert_extension_triggers(modkey)
-                run_package_callbacks(modkey)
-            end
-        end
-    end
-    if !(loaded isa Module) || PkgId(loaded) != modkey
-        return ErrorException("Required dependency $modkey failed to load from a cache file.")
-    end
-    return loaded
+    return ErrorException("Required dependency $modkey failed to load from a cache file.")
 end
 
 # returns whether the package is tracked in coverage or malloc tracking based on
@@ -1766,7 +1740,7 @@ function pkg_tracked(includes)
 end
 
 # loads a precompile cache file, ignoring stale_cachefile tests
-# load the best available (non-stale) version of all dependent modules first
+# load all dependent modules first
 function _tryrequire_from_serialized(pkg::PkgId, path::String, ocachepath::Union{Nothing, String})
     assert_havelock(require_lock)
     local depmodnames
@@ -1808,56 +1782,92 @@ end
 
 # returns `nothing` if require found a precompile cache for this sourcepath, but couldn't load it
 # returns the set of modules restored if the cache load succeeded
-@constprop :none function _require_search_from_serialized(pkg::PkgId, sourcepath::String, build_id::UInt128; reasons=nothing)
+@constprop :none function _require_search_from_serialized(pkg::PkgId, sourcepath::String, build_id::UInt128, stalecheck::Bool; reasons=nothing, DEPOT_PATH::typeof(DEPOT_PATH)=DEPOT_PATH)
     assert_havelock(require_lock)
-    paths = find_all_in_cache_path(pkg)
+    paths = find_all_in_cache_path(pkg, DEPOT_PATH)
+    newdeps = PkgId[]
     for path_to_try in paths::Vector{String}
-        staledeps = stale_cachefile(pkg, build_id, sourcepath, path_to_try; reasons)
+        staledeps = stale_cachefile(pkg, build_id, sourcepath, path_to_try; reasons, stalecheck)
         if staledeps === true
             continue
         end
-        staledeps, ocachefile = staledeps::Tuple{Vector{Any}, Union{Nothing, String}}
-        # finish checking staledeps module graph
-        for i in 1:length(staledeps)
-            dep = staledeps[i]
-            dep isa Module && continue
-            modpath, modkey, modbuild_id = dep::Tuple{String, PkgId, UInt128}
-            modpaths = find_all_in_cache_path(modkey)
-            for modpath_to_try in modpaths
-                modstaledeps = stale_cachefile(modkey, modbuild_id, modpath, modpath_to_try)
-                if modstaledeps === true
-                    continue
-                end
-                modstaledeps, modocachepath = modstaledeps::Tuple{Vector{Any}, Union{Nothing, String}}
-                staledeps[i] = (modpath, modkey, modpath_to_try, modstaledeps, modocachepath)
-                @goto check_next_dep
-            end
-            @debug "Rejecting cache file $path_to_try because required dependency $modkey with build ID $(UUID(modbuild_id)) is missing from the cache."
-            @goto check_next_path
-            @label check_next_dep
-        end
         try
-            touch(path_to_try) # update timestamp of precompilation file
-        catch ex # file might be read-only and then we fail to update timestamp, which is fine
-            ex isa IOError || rethrow()
-        end
-        # finish loading module graph into staledeps
-        for i in 1:length(staledeps)
-            dep = staledeps[i]
-            dep isa Module && continue
-            modpath, modkey, modcachepath, modstaledeps, modocachepath = dep::Tuple{String, PkgId, String, Vector{Any}, Union{Nothing, String}}
-            dep = _tryrequire_from_serialized(modkey, modcachepath, modocachepath, modpath, modstaledeps)
-            if !isa(dep, Module)
-                @debug "Rejecting cache file $path_to_try because required dependency $modkey failed to load from cache file for $modcachepath." exception=dep
+            staledeps, ocachefile = staledeps::Tuple{Vector{Any}, Union{Nothing, String}}
+            # finish checking staledeps module graph
+            for i in 1:length(staledeps)
+                dep = staledeps[i]
+                dep isa Module && continue
+                modpath, modkey, modbuild_id = dep::Tuple{String, PkgId, UInt128}
+                modpaths = find_all_in_cache_path(modkey, DEPOT_PATH)
+                for modpath_to_try in modpaths
+                    modstaledeps = stale_cachefile(modkey, modbuild_id, modpath, modpath_to_try; stalecheck)
+                    if modstaledeps === true
+                        continue
+                    end
+                    modstaledeps, modocachepath = modstaledeps::Tuple{Vector{Any}, Union{Nothing, String}}
+                    staledeps[i] = (modpath, modkey, modbuild_id, modpath_to_try, modstaledeps, modocachepath)
+                    @goto check_next_dep
+                end
+                @debug "Rejecting cache file $path_to_try because required dependency $modkey with build ID $(UUID(modbuild_id)) is missing from the cache."
                 @goto check_next_path
+                @label check_next_dep
+            end
+            if stalecheck
+                try
+                    touch(path_to_try) # update timestamp of precompilation file
+                catch ex # file might be read-only and then we fail to update timestamp, which is fine
+                    ex isa IOError || rethrow()
+                end
             end
-            staledeps[i] = dep
+            # finish loading module graph into staledeps
+            for i in 1:length(staledeps)
+                dep = staledeps[i]
+                dep isa Module && continue
+                modpath, modkey, modbuild_id, modcachepath, modstaledeps, modocachepath = dep::Tuple{String, PkgId, UInt128, String, Vector{Any}, Union{Nothing, String}}
+                dep = nothing
+                if root_module_exists(modkey)
+                    dep = root_module(modkey)
+                end
+                while true
+                    if dep isa Module
+                        if PkgId(dep) == modkey && module_build_id(dep) === modbuild_id
+                            break
+                        else
+                            if stalecheck
+                                @debug "Rejecting cache file $path_to_try because module $modkey is already loaded and incompatible."
+                                @goto check_next_path
+                            end
+                        end
+                    end
+                    dep = start_loading(modkey)
+                    if dep === nothing
+                        try
+                            set_pkgorigin_version_path(modkey, modpath)
+                            dep = _include_from_serialized(modkey, modcachepath, modocachepath, modstaledeps)
+                        finally
+                            end_loading(modkey, dep)
+                        end
+                        if !isa(dep, Module)
+                            @debug "Rejecting cache file $path_to_try because required dependency $modkey failed to load from cache file for $modcachepath." exception=dep
+                            @goto check_next_path
+                        else
+                            push!(newdeps, modkey)
+                        end
+                    end
+                end
+                staledeps[i] = dep
+            end
+            restored = _include_from_serialized(pkg, path_to_try, ocachefile, staledeps)
+            isa(restored, Module) && return restored
+            @debug "Deserialization checks failed while attempting to load cache from $path_to_try" exception=restored
+            @label check_next_path
+        finally
+            for modkey in newdeps
+                insert_extension_triggers(modkey)
+                run_package_callbacks(modkey)
+            end
+            empty!(newdeps)
         end
-        restored = _include_from_serialized(pkg, path_to_try, ocachefile, staledeps)
-        isa(restored, Module) && return restored
-        @debug "Deserialization checks failed while attempting to load cache from $path_to_try" exception=restored
-        continue
-        @label check_next_path
     end
     return nothing
 end
@@ -2241,14 +2251,12 @@ function unreference_module(key::PkgId)
 end
 
 # whoever takes the package_locks[pkg] must call this function immediately
-function set_pkgorigin_version_path(pkg::PkgId, path::Union{String,Nothing})
+function set_pkgorigin_version_path(pkg::PkgId, path::String)
     assert_havelock(require_lock)
     pkgorigin = get!(PkgOrigin, pkgorigins, pkg)
-    if path !== nothing
-        # Pkg needs access to the version of packages in the sysimage.
-        if generating_output(#=incremental=#false)
-            pkgorigin.version = get_pkgversion_from_path(joinpath(dirname(path), ".."))
-        end
+    # Pkg needs access to the version of packages in the sysimage.
+    if generating_output(#=incremental=#false)
+        pkgorigin.version = get_pkgversion_from_path(joinpath(dirname(path), ".."))
     end
     pkgorigin.path = path
     nothing
@@ -2281,7 +2289,7 @@ function _require(pkg::PkgId, env=nothing)
         # attempt to load the module file via the precompile cache locations
         if JLOptions().use_compiled_modules != 0
             @label load_from_cache
-            m = _require_search_from_serialized(pkg, path, UInt128(0); reasons)
+            m = _require_search_from_serialized(pkg, path, UInt128(0), true; reasons)
             if m isa Module
                 return m
             end
@@ -2319,7 +2327,7 @@ function _require(pkg::PkgId, env=nothing)
                 # spawn off a new incremental pre-compile task for recursive `require` calls
                 cachefile_or_module = maybe_cachefile_lock(pkg, path) do
                     # double-check now that we have lock
-                    m = _require_search_from_serialized(pkg, path, UInt128(0))
+                    m = _require_search_from_serialized(pkg, path, UInt128(0), true)
                     m isa Module && return m
                     compilecache(pkg, path; reasons)
                 end
@@ -2376,10 +2384,10 @@ function _require(pkg::PkgId, env=nothing)
     return loaded
 end
 
-# Only used from test/precompile.jl
-function _require_from_serialized(uuidkey::PkgId, path::String, ocachepath::Union{String, Nothing})
+# load a serialized file directly
+function _require_from_serialized(uuidkey::PkgId, path::String, ocachepath::Union{String, Nothing}, sourcepath::String)
     @lock require_lock begin
-    set_pkgorigin_version_path(uuidkey, nothing)
+    set_pkgorigin_version_path(uuidkey, sourcepath)
     newm = _tryrequire_from_serialized(uuidkey, path, ocachepath)
     newm isa Module || throw(newm)
     insert_extension_triggers(uuidkey)
@@ -2389,6 +2397,58 @@ function _require_from_serialized(uuidkey::PkgId, path::String, ocachepath::Unio
     end
 end
 
+# load a serialized file directly from append_bundled_depot_path for uuidkey without stalechecks
+function require_stdlib(uuidkey::PkgId, ext::Union{Nothing, String}=nothing)
+    @lock require_lock begin
+    if root_module_exists(uuidkey)
+        return loaded_modules[uuidkey]
+    end
+    # first since this is a stdlib, try to look there directly first
+    env = Sys.STDLIB
+    #sourcepath = ""
+    if ext === nothing
+        sourcepath = normpath(env, uuidkey.name, "src", uuidkey.name * ".jl")
+    else
+        sourcepath = find_ext_path(normpath(joinpath(env, uuidkey.name)), ext)
+        uuidkey = PkgId(uuid5(uuidkey.uuid, ext), ext)
+    end
+    #mbypath = manifest_uuid_path(env, uuidkey)
+    #if mbypath isa String
+    #    sourcepath = entry_path(mbypath, uuidkey.name)
+    #else
+    #    # if the user deleted the stdlib folder, we next try using their environment
+    #    sourcepath = locate_package_env(uuidkey)
+    #    if sourcepath !== nothing
+    #        sourcepath, env = sourcepath
+    #    end
+    #end
+    #if sourcepath === nothing
+    #    throw(ArgumentError("""
+    #        Package $(repr("text/plain", uuidkey)) is required but does not seem to be installed.
+    #        """))
+    #end
+    set_pkgorigin_version_path(uuidkey, sourcepath)
+    depot_path = append_bundled_depot_path!(empty(DEPOT_PATH))
+    newm = start_loading(uuidkey)
+    newm === nothing || return newm
+    try
+        newm = _require_search_from_serialized(uuidkey, sourcepath, UInt128(0), false; DEPOT_PATH=depot_path)
+    finally
+        end_loading(uuidkey, newm)
+    end
+    if newm isa Module
+        # After successfully loading, notify downstream consumers
+        insert_extension_triggers(env, uuidkey)
+        run_package_callbacks(uuidkey)
+    else
+        # if the user deleted their bundled depot, next try to load it completely normally
+        newm = _require(uuidkey)
+    end
+    return newm
+    end
+end
+
+
 
 
 # relative-path load
@@ -3393,7 +3453,9 @@ list_reasons(::Nothing) = ""
     return stale_cachefile(PkgId(""), UInt128(0), modpath, cachefile; ignore_loaded, requested_flags, reasons)
 end
 @constprop :none function stale_cachefile(modkey::PkgId, build_id::UInt128, modpath::String, cachefile::String;
-                                            ignore_loaded::Bool = false, requested_flags::CacheFlags=CacheFlags(), reasons::Union{Dict{String,Int},Nothing}=nothing)
+                                          ignore_loaded::Bool=false, requested_flags::CacheFlags=CacheFlags(),
+                                          reasons::Union{Dict{String,Int},Nothing}=nothing, stalecheck::Bool=true)
+    # XXX: this function appears to dl all of the file validation, not just those checks related to stale
     io = open(cachefile, "r")
     try
         checksum = isvalid_cache_header(io)
@@ -3468,7 +3530,7 @@ end
                 M = root_module(req_key)
                 if PkgId(M) == req_key && module_build_id(M) === req_build_id
                     depmods[i] = M
-                elseif ignore_loaded
+                elseif ignore_loaded || !stalecheck
                     # Used by Pkg.precompile given that there it's ok to precompile different versions of loaded packages
                     @goto locate_branch
                 else
@@ -3478,7 +3540,7 @@ end
                 end
             else
                 @label locate_branch
-                path = locate_package(req_key)
+                path = locate_package(req_key) # TODO: add env and/or skip this when stalecheck is false
                 if path === nothing
                     @debug "Rejecting cache file $cachefile because dependency $req_key not found."
                     record_reason(reasons, "dep missing source")
@@ -3491,13 +3553,12 @@ end
         # check if this file is going to provide one of our concrete dependencies
         # or if it provides a version that conflicts with our concrete dependencies
         # or neither
-        skip_check = false
         for (req_key, req_build_id) in _concrete_dependencies
             build_id = get(modules, req_key, UInt64(0))
             if build_id !== UInt64(0)
                 build_id |= UInt128(checksum) << 64
                 if build_id === req_build_id
-                    skip_check = true
+                    stalecheck = false
                     break
                 end
                 @debug "Rejecting cache file $cachefile because it provides the wrong build_id (got $((UUID(build_id)))) for $req_key (want $(UUID(req_build_id)))"
@@ -3507,7 +3568,7 @@ end
         end
 
         # now check if this file's content hash has changed relative to its source files
-        if !skip_check
+        if stalecheck
             if !samefile(includes[1].filename, modpath) && !samefile(fixup_stdlib_path(includes[1].filename), modpath)
                 @debug "Rejecting cache file $cachefile because it is for file $(includes[1].filename) not file $modpath"
                 record_reason(reasons, "wrong source")
diff --git a/base/stream.jl b/base/stream.jl
index 3de61181e978d..3264b8f153677 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -304,7 +304,7 @@ function init_stdio(handle::Ptr{Cvoid})
     elseif t == UV_TTY
         io = TTY(handle, StatusOpen)
     elseif t == UV_TCP
-        Sockets = require(PkgId(UUID((0x6462fe0b_24de_5631, 0x8697_dd941f90decc)), "Sockets"))
+        Sockets = require_stdlib(PkgId(UUID((0x6462fe0b_24de_5631, 0x8697_dd941f90decc)), "Sockets"))
         io = Sockets.TCPSocket(handle, StatusOpen)
     elseif t == UV_NAMED_PIPE
         io = PipeEndpoint(handle, StatusOpen)
@@ -341,7 +341,7 @@ function open(h::OS_HANDLE)
     elseif t == UV_TTY
         io = TTY(h)
     elseif t == UV_TCP
-        Sockets = require(PkgId(UUID((0x6462fe0b_24de_5631, 0x8697_dd941f90decc)), "Sockets"))
+        Sockets = require_stdlib(PkgId(UUID((0x6462fe0b_24de_5631, 0x8697_dd941f90decc)), "Sockets"))
         io = Sockets.TCPSocket(h)
     elseif t == UV_NAMED_PIPE
         io = PipeEndpoint(h)
diff --git a/base/util.jl b/base/util.jl
index a26a874c7a461..847d89e895af4 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -695,7 +695,7 @@ function runtests(tests = ["all"]; ncores::Int = ceil(Int, Sys.CPU_THREADS / 2),
     catch
         buf = PipeBuffer()
         original_load_path = copy(Base.LOAD_PATH); empty!(Base.LOAD_PATH); pushfirst!(Base.LOAD_PATH, "@stdlib")
-        let InteractiveUtils = Base.require(Base, :InteractiveUtils)
+        let InteractiveUtils = Base.require_stdlib(Base, :InteractiveUtils)
             @invokelatest InteractiveUtils.versioninfo(buf)
         end
         empty!(Base.LOAD_PATH); append!(Base.LOAD_PATH, original_load_path)
diff --git a/stdlib/InteractiveUtils/src/InteractiveUtils.jl b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
index 7391a0d6b2f00..519acfc8a2f33 100644
--- a/stdlib/InteractiveUtils/src/InteractiveUtils.jl
+++ b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
@@ -338,7 +338,7 @@ export peakflops
 function peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)
     # Base.depwarn("`peakflops` has moved to the LinearAlgebra module, " *
     #              "add `using LinearAlgebra` to your imports.", :peakflops)
-    let LinearAlgebra = Base.require(Base.PkgId(
+    let LinearAlgebra = Base.require_stdlib(Base.PkgId(
             Base.UUID((0x37e2e46d_f89d_539d,0xb4ee_838fcccc9c8e)), "LinearAlgebra"))
         return LinearAlgebra.peakflops(n, eltype=eltype, ntrials=ntrials, parallel=parallel)
     end
@@ -353,7 +353,7 @@ function report_bug(kind)
     if Base.locate_package(BugReportingId) === nothing
         @info "Package `BugReporting` not found - attempting temporary installation"
         # Create a temporary environment and add BugReporting
-        let Pkg = Base.require(Base.PkgId(
+        let Pkg = Base.require_stdlib(Base.PkgId(
             Base.UUID((0x44cfe95a_1eb2_52ea,0xb672_e2afdf69b78f)), "Pkg"))
             mktempdir() do tmp
                 old_load_path = copy(LOAD_PATH)
diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index 793775992fdea..acacf4b20cfc7 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -691,7 +691,7 @@ function peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3
     end
 
     if parallel
-        let Distributed = Base.require(Base.PkgId(
+        let Distributed = Base.require_stdlib(Base.PkgId(
                 Base.UUID((0x8ba89e20_285c_5b6f, 0x9357_94700520ee1b)), "Distributed"))
             nworkers = @invokelatest Distributed.nworkers()
             results = @invokelatest Distributed.pmap(peakflops, fill(n, nworkers))
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index f39aed51cebaf..840e6daaf1909 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -1188,25 +1188,23 @@ function setup_interface(
         ']' => function (s::MIState,o...)
             if isempty(s) || position(LineEdit.buffer(s)) == 0
                 pkgid = Base.PkgId(Base.UUID("44cfe95a-1eb2-52ea-b672-e2afdf69b78f"), "Pkg")
-                if Base.locate_package(pkgid) !== nothing # Only try load Pkg if we can find it
-                    Pkg = Base.require(pkgid)
-                    REPLExt = Base.get_extension(Pkg, :REPLExt)
-                    # Pkg should have loaded its REPL mode by now, let's find it so we can transition to it.
-                    pkg_mode = nothing
+                REPLExt = Base.require_stdlib(pkgid, "REPLExt")
+                pkg_mode = nothing
+                if REPLExt isa Module && isdefined(REPLExt, :PkgCompletionProvider)
                     for mode in repl.interface.modes
                         if mode isa LineEdit.Prompt && mode.complete isa REPLExt.PkgCompletionProvider
                             pkg_mode = mode
                             break
                         end
                     end
-                    # TODO: Cache the `pkg_mode`?
-                    if pkg_mode !== nothing
-                        buf = copy(LineEdit.buffer(s))
-                        transition(s, pkg_mode) do
-                            LineEdit.state(s, pkg_mode).input_buffer = buf
-                        end
-                        return
+                end
+                # TODO: Cache the `pkg_mode`?
+                if pkg_mode !== nothing
+                    buf = copy(LineEdit.buffer(s))
+                    transition(s, pkg_mode) do
+                        LineEdit.state(s, pkg_mode).input_buffer = buf
                     end
+                    return
                 end
             end
             edit_insert(s, ']')
diff --git a/test/precompile.jl b/test/precompile.jl
index 9a035997ce9f0..ce7e9e77217b0 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -407,11 +407,11 @@ precompile_test_harness(false) do dir
         else
             ocachefile = nothing
         end
-            # use _require_from_serialized to ensure that the test fails if
-            # the module doesn't reload from the image:
+        # use _require_from_serialized to ensure that the test fails if
+        # the module doesn't reload from the image:
         @test_warn "@ccallable was already defined for this method name" begin
             @test_logs (:warn, "Replacing module `$Foo_module`") begin
-                m = Base._require_from_serialized(Base.PkgId(Foo), cachefile, ocachefile)
+                m = Base._require_from_serialized(Base.PkgId(Foo), cachefile, ocachefile, Foo_file)
                 @test isa(m, Module)
             end
         end

From 936c8a699010257b87e8f63a755f90ba54568475 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 23 Feb 2024 21:04:41 +0100
Subject: [PATCH 1005/1315] make debug messages for relocatable srcfiles into a
 separate group (#53446)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These create a lot of noisy output that is typically not interesting. As
an example of the output :

```
┌ Debug: include() files from /Users/kristoffercarlsson/.julia/compiled/v1.12/Pkg/tUTdb_NNLzf.ji are not relocatable
│   srcfiles =
│    Set{String} with 27 elements:
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/BinaryPlatforms_compat.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/MiniProgressBars.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/registry_instance.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/Registry.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/maxsum.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Types.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/REPLMode/command_declarations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/versionweights.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Artifacts.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Operations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/API.jl"
│      ⋮
└ @ Base loading.jl:3051
┌ Debug: include() files from /Users/kristoffercarlsson/.julia/compiled/v1.12/Pkg/tUTdb_Qo7WJ.ji are not relocatable
│   srcfiles =
│    Set{String} with 27 elements:
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/BinaryPlatforms_compat.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/MiniProgressBars.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/registry_instance.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/Registry.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/maxsum.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Types.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/REPLMode/command_declarations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/versionweights.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Artifacts.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Operations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/API.jl"
│      ⋮
└ @ Base loading.jl:3051
┌ Debug: include() files from /Users/kristoffercarlsson/.julia/compiled/v1.12/Pkg/tUTdb_bHWms.ji are not relocatable
│   srcfiles =
│    Set{String} with 27 elements:
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/BinaryPlatforms_compat.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/MiniProgressBars.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/registry_instance.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/Registry.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/maxsum.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Types.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/REPLMode/command_declarations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/versionweights.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Artifacts.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Operations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/API.jl"
│      ⋮
└ @ Base loading.jl:3051
┌ Debug: include() files from /Users/kristoffercarlsson/.julia/compiled/v1.12/Pkg/tUTdb_ePY5e.ji are not relocatable
│   srcfiles =
│    Set{String} with 27 elements:
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/BinaryPlatforms_compat.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/MiniProgressBars.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/registry_instance.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/Registry.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/maxsum.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Types.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/REPLMode/command_declarations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/versionweights.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Artifacts.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Operations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/API.jl"
│      ⋮
└ @ Base loading.jl:3051
┌ Debug: include() files from /Users/kristoffercarlsson/.julia/compiled/v1.12/Pkg/tUTdb_s9CWW.ji are not relocatable
│   srcfiles =
│    Set{String} with 27 elements:
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/BinaryPlatforms_compat.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/MiniProgressBars.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/registry_instance.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Registry/Registry.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/maxsum.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Types.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/REPLMode/command_declarations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Resolve/versionweights.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Artifacts.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/Operations.jl"
│      "/Users/kristoffercarlsson/JuliaPkgs/Pkg.jl/src/API.jl"
│      ⋮
```
---
 base/loading.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 2be97237238dd..1cff14203b291 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -3106,9 +3106,9 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
     # determine depot for @depot replacement for include() files and include_dependency() files separately
     srcfiles_depot = resolve_depot(first(srcfiles))
     if srcfiles_depot === :no_depot_found
-        @debug("Unable to resolve @depot tag include() files from cache file $cachefile", srcfiles)
+        @debug("Unable to resolve @depot tag include() files from cache file $cachefile", srcfiles, _group=:relocatable)
     elseif srcfiles_depot === :not_relocatable
-        @debug("include() files from $cachefile are not relocatable", srcfiles)
+        @debug("include() files from $cachefile are not relocatable", srcfiles, _group=:relocatable)
     else
         for inc in includes_srcfiles
             inc.filename = restore_depot_path(inc.filename, srcfiles_depot)
@@ -3117,9 +3117,9 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
     for inc in includes_depfiles
         depot = resolve_depot(inc.filename)
         if depot === :no_depot_found
-            @debug("Unable to resolve @depot tag for include_dependency() file $(inc.filename) from cache file $cachefile", srcfiles)
+            @debug("Unable to resolve @depot tag for include_dependency() file $(inc.filename) from cache file $cachefile", srcfiles, _group=:relocatable)
         elseif depot === :not_relocatable
-            @debug("include_dependency() file $(inc.filename) from $cachefile is not relocatable", srcfiles)
+            @debug("include_dependency() file $(inc.filename) from $cachefile is not relocatable", srcfiles, _group=:relocatable)
         else
             inc.filename = restore_depot_path(inc.filename, depot)
         end

From 138aba7320c4c37b1ad6330ec46531077f8ee516 Mon Sep 17 00:00:00 2001
From: Matt Bauman <mbauman@juliahub.com>
Date: Fri, 23 Feb 2024 17:04:29 -0500
Subject: [PATCH 1006/1315] improve `--heap-size-hint` arg handling (#48050)

Previously, `--heap-size-hint` would silently ignore many flavors of
"bad" input, parsing things like "3PB" as 3 bytes. This change makes it
significantly less permissive, erroring unless it can parse a number
(still relying on the C `sscanf` `%Lf` format specifier there) with an
optional unit (case-insensitive, either with or without the trailing
`b`). Also test it.
---
 doc/man/julia.1                          |  7 +-
 doc/src/manual/command-line-interface.md |  2 +-
 src/jloptions.c                          | 90 ++++++++++++++----------
 test/cmdlineargs.jl                      | 16 +++++
 4 files changed, 73 insertions(+), 42 deletions(-)

diff --git a/doc/man/julia.1 b/doc/man/julia.1
index c58b00120b7ec..afde0326e4952 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -228,9 +228,10 @@ fallbacks to the latest compatible BugReporting.jl if not. For more information,
 --bug-report=help.
 
 .TP
---heap-size-hint=<size>
-Forces garbage collection if memory usage is higher than that value. The value can be
-specified in units of K, M, G, T, or % of physical memory.
+--heap-size-hint=<value>
+Forces garbage collection if memory usage is higher than the given value.
+The value may be specified as a number of bytes, optionally in units of
+KB, MB, GB, or TB, or as a percentage of physical memory with %.
 
 .TP
 --compile={yes*|no|all|min}
diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index 4faa3e8d3fc05..448964bf1ef8a 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -213,7 +213,7 @@ The following is a complete list of command-line switches available when launchi
 |`--output-incremental={yes\|no*}`      |Generate an incremental output file (rather than complete)|
 |`--trace-compile={stderr,name}`        |Print precompile statements for methods compiled during execution or save to a path|
 |`--image-codegen`                      |Force generate code in imaging mode|
-|`--heap-size-hint=<size>`              |Forces garbage collection if memory usage is higher than that value. The memory hint might be specified in megabytes (e.g., 500M) or gigabytes (e.g., 1G)|
+|`--heap-size-hint=<size>`              |Forces garbage collection if memory usage is higher than the given value. The value may be specified as a number of bytes, optionally in units of KB, MB, GB, or TB, or as a percentage of physical memory with %.|
 
 
 !!! compat "Julia 1.1"
diff --git a/src/jloptions.c b/src/jloptions.c
index 4b3f7209dc56d..570d021351104 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -8,6 +8,7 @@
 
 #include <unistd.h>
 #include <getopt.h>
+
 #include "julia_assert.h"
 
 #ifdef _OS_WINDOWS_
@@ -18,6 +19,15 @@ char *shlib_ext = ".dylib";
 char *shlib_ext = ".so";
 #endif
 
+/* This simple hand-crafted tolower exists to avoid locale-dependent effects in
+ * behaviors (and utf8proc_tolower wasn't linking properly on all platforms) */
+static char ascii_tolower(char c)
+{
+    if ('A' <= c && c <= 'Z')
+        return c - 'A' + 'a';
+    return c;
+}
+
 static const char system_image_path[256] = "\0" JL_SYSTEM_IMAGE_PATH;
 JL_DLLEXPORT const char *jl_get_default_sysimg_path(void)
 {
@@ -187,9 +197,9 @@ static const char opts[]  =
     "                            expressions. It first tries to use BugReporting.jl installed in current environment and\n"
     "                            fallbacks to the latest compatible BugReporting.jl if not. For more information, see\n"
     "                            --bug-report=help.\n\n"
-
-    " --heap-size-hint=<size>    Forces garbage collection if memory usage is higher than that value.\n"
-    "                            The value can be specified in units of K, M, G, T, or % of physical memory.\n\n"
+    " --heap-size-hint=<size>    Forces garbage collection if memory usage is higher than the given value.\n"
+    "                            The value may be specified as a number of bytes, optionally in units of\n"
+    "                            KB, MB, GB, or TB, or as a percentage of physical memory with %.\n\n"
 ;
 
 static const char opts_hidden[]  =
@@ -801,43 +811,47 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
             break;
         case opt_heap_size_hint:
             if (optarg != NULL) {
-                size_t endof = strlen(optarg);
                 long double value = 0.0;
-                if (sscanf(optarg, "%Lf", &value) == 1 && value > 1e-7) {
-                    char unit = optarg[endof - 1];
-                    uint64_t multiplier = 1ull;
-                    switch (unit) {
-                        case 'k':
-                        case 'K':
-                            multiplier <<= 10;
-                            break;
-                        case 'm':
-                        case 'M':
-                            multiplier <<= 20;
-                            break;
-                        case 'g':
-                        case 'G':
-                            multiplier <<= 30;
-                            break;
-                        case 't':
-                        case 'T':
-                            multiplier <<= 40;
-                            break;
-                        case '%':
-                            if (value > 100)
-                                jl_errorf("julia: invalid percentage specified in --heap-size-hint");
-                            uint64_t mem = uv_get_total_memory();
-                            uint64_t cmem = uv_get_constrained_memory();
-                            if (cmem > 0 && cmem < mem)
-                                mem = cmem;
-                            multiplier = mem/100;
-                            break;
-                        default:
-                            jl_errorf("julia: invalid unit specified in --heap-size-hint");
-                            break;
-                    }
-                    jl_options.heap_size_hint = (uint64_t)(value * multiplier);
+                char unit[4] = {0};
+                int nparsed = sscanf(optarg, "%Lf%3s", &value, unit);
+                if (nparsed == 0 || strlen(unit) > 2 || (strlen(unit) == 2 && ascii_tolower(unit[1]) != 'b')) {
+                    jl_errorf("julia: invalid argument to --heap-size-hint (%s)", optarg);
+                }
+                uint64_t multiplier = 1ull;
+                switch (ascii_tolower(unit[0])) {
+                    case '\0':
+                    case 'b':
+                        break;
+                    case 'k':
+                        multiplier <<= 10;
+                        break;
+                    case 'm':
+                        multiplier <<= 20;
+                        break;
+                    case 'g':
+                        multiplier <<= 30;
+                        break;
+                    case 't':
+                        multiplier <<= 40;
+                        break;
+                    case '%':
+                        if (value > 100)
+                            jl_errorf("julia: invalid percentage specified in --heap-size-hint");
+                        uint64_t mem = uv_get_total_memory();
+                        uint64_t cmem = uv_get_constrained_memory();
+                        if (cmem > 0 && cmem < mem)
+                            mem = cmem;
+                        multiplier = mem/100;
+                        break;
+                    default:
+                        jl_errorf("julia: invalid argument to --heap-size-hint (%s)", optarg);
+                        break;
+                }
+                long double sz = value * multiplier;
+                if (isnan(sz) || sz < 0) {
+                    jl_errorf("julia: invalid argument to --heap-size-hint (%s)", optarg);
                 }
+                jl_options.heap_size_hint = sz < UINT64_MAX ? (uint64_t)sz : UINT64_MAX;
             }
             if (jl_options.heap_size_hint == 0)
                 jl_errorf("julia: invalid memory size specified in --heap-size-hint");
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 3af31965e63fc..498254bb26ce0 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -1148,3 +1148,19 @@ if Sys.islinux() && Sys.ARCH in (:i686, :x86_64) # rr is only available on these
                                       "_RR_TRACE_DIR" => temp_trace_dir); #=stderr, stdout=#))
     end
 end
+
+@testset "--heap-size-hint" begin
+    exename = `$(Base.julia_cmd())`
+    @test errors_not_signals(`$exename --heap-size-hint -e "exit(0)"`)
+    @testset "--heap-size-hint=$str" for str in ["asdf","","0","1.2vb","b","GB","2.5GB̂","1.2gb2","42gigabytes","5gig","2GiB","NaNt"]
+        @test errors_not_signals(`$exename --heap-size-hint=$str -e "exit(0)"`)
+    end
+    k = 1024
+    m = 1024k
+    g = 1024m
+    t = 1024g
+    @testset "--heap-size-hint=$str" for (str, val) in [("1", 1), ("1e7", 1e7), ("2.5e7", 2.5e7), ("1MB", 1m), ("2.5g", 2.5g), ("1e4kB", 1e4k),
+        ("1e100", typemax(UInt64)), ("1e500g", typemax(UInt64)), ("1e-12t", 1), ("500000000b", 500000000)]
+        @test parse(UInt64,read(`$exename --heap-size-hint=$str -E "Base.JLOptions().heap_size_hint"`, String)) == val
+    end
+end

From 714c6d02f8adf970a0451fffb39d6be1d8b5b564 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Sat, 24 Feb 2024 20:26:49 -0500
Subject: [PATCH 1007/1315] clarify keyword arg method error message (#53460)

This is a nice explanatory message, so I think we should make the
wording less obscure.
---
 base/errorshow.jl | 2 +-
 test/errorshow.jl | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index f63c150336689..9236e7da5baa6 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -330,7 +330,7 @@ function showerror(io::IO, ex::MethodError)
         if ex.world == typemax(UInt) || isempty(kwargs)
             print(io, "\nThis error has been manually thrown, explicitly, so the method may exist but be intentionally marked as unimplemented.")
         else
-            print(io, "\nThis method may not support any kwargs.")
+            print(io, "\nThis method may not support any keyword arguments.")
         end
     elseif hasmethod(f, arg_types) && !hasmethod(f, arg_types, world=ex.world)
         curworld = get_world_counter()
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 932122682983e..2b497ed3f5f1b 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -669,7 +669,7 @@ end
 
     str = sprint(Base.showerror, MethodError(Core.kwcall, ((; a=3.0), +, 1.0, 2.0), Base.get_world_counter()))
     @test startswith(str, "MethodError: no method matching +(::Float64, ::Float64; a::Float64)")
-    @test occursin("This method may not support any kwargs", str)
+    @test occursin("This method may not support any keyword arguments", str)
 
     @test_throws "MethodError: no method matching kwcall()" Core.kwcall()
 end

From b8a0a3978ccf163ce8fc371a4882547dc1271d53 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Sat, 24 Feb 2024 21:48:37 -0500
Subject: [PATCH 1008/1315] Prevent tainting native code loading from
 propagating (#53457)

When we use options like code coverage, we can't use the native code
present in the cache file since it is not instrumented.

PR #52123 introduced the capability of skipping the native
code during loading, but created the issue that subsequent packages
could have an explicit or implicit dependency on the native code.

PR #53439 tainted the current process by setting
`use_sysimage_native_code`, but this flag is propagated to subprocesses
and lead to a regression in test time.

Move this to a process local flag to avoid the regression.
In the future we might be able to change the calling convention for
cross-image calls to `invoke(ci::CodeInstance, args...)` instead of
`ci.fptr(args...)` to handle native code not being present.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 src/staticdata.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/staticdata.c b/src/staticdata.c
index c8fd4053aaf73..261042b775c14 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -3066,6 +3066,11 @@ JL_DLLEXPORT void jl_set_sysimg_so(void *handle)
 extern void rebuild_image_blob_tree(void);
 extern void export_jl_small_typeof(void);
 
+// When an image is loaded with ignore_native, all subsequent image loads must ignore
+// native code in the cache-file since we can't gurantuee that there are no call edges
+// into the native code of the image. See https://github.com/JuliaLang/julia/pull/52123#issuecomment-1959965395.
+int IMAGE_NATIVE_CODE_TAINTED = 0;
+
 static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl_array_t *depmods, uint64_t checksum,
                                 /* outputs */    jl_array_t **restored,         jl_array_t **init_order,
                                                  jl_array_t **extext_methods, jl_array_t **internal_methods,
@@ -3092,9 +3097,10 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
 
     // in --build mode only use sysimg data, not precompiled native code
     int imaging_mode = jl_generating_output() && !jl_options.incremental;
-    if (imaging_mode || jl_options.use_sysimage_native_code != JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES) {
+    if (imaging_mode || jl_options.use_sysimage_native_code != JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_YES || IMAGE_NATIVE_CODE_TAINTED) {
         memset(&image->fptrs, 0, sizeof(image->fptrs));
         image->gvars_base = NULL;
+        IMAGE_NATIVE_CODE_TAINTED = 1;
     }
 
     // step 1: read section map
@@ -3772,7 +3778,7 @@ JL_DLLEXPORT jl_value_t *jl_restore_package_image_from_file(const char *fname, j
         // Must disable using native code in possible downstream users of this code:
         // https://github.com/JuliaLang/julia/pull/52123#issuecomment-1959965395.
         // The easiest way to do that is to disable it in all of them.
-        jl_options.use_sysimage_native_code = JL_OPTIONS_USE_SYSIMAGE_NATIVE_CODE_NO;
+        IMAGE_NATIVE_CODE_TAINTED = 1;
     }
 
     jl_value_t* mod = jl_restore_incremental_from_buf(pkgimg_handle, pkgimg_data, &pkgimage, *plen, depmods, completeinfo, pkgname, 0);

From 669cbdce4e40e3d06b168323b97c003d75483ca9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sun, 25 Feb 2024 22:55:35 +0000
Subject: [PATCH 1009/1315] [MozillaCACerts_jll] Update to v2023-12-12 (#53466)

Memo to self:

* update the version in `stdlib/MozillaCACerts_jll/Project.toml`
* update `MOZILLA_CACERT_VERSION` in `deps/libgit2.version`
* generate new checksums with `make -f contrib/refresh_checksums.mk
mozillacert`
* manually delete old checksums in
`deps/checksums/cacert-<OLD-VERSIONS>`
---
 deps/checksums/cacert-2023-01-10.pem/md5    | 1 -
 deps/checksums/cacert-2023-01-10.pem/sha512 | 1 -
 deps/checksums/cacert-2023-12-12.pem/md5    | 1 +
 deps/checksums/cacert-2023-12-12.pem/sha512 | 1 +
 deps/libgit2.version                        | 3 ++-
 stdlib/MozillaCACerts_jll/Project.toml      | 3 ++-
 6 files changed, 6 insertions(+), 4 deletions(-)
 delete mode 100644 deps/checksums/cacert-2023-01-10.pem/md5
 delete mode 100644 deps/checksums/cacert-2023-01-10.pem/sha512
 create mode 100644 deps/checksums/cacert-2023-12-12.pem/md5
 create mode 100644 deps/checksums/cacert-2023-12-12.pem/sha512

diff --git a/deps/checksums/cacert-2023-01-10.pem/md5 b/deps/checksums/cacert-2023-01-10.pem/md5
deleted file mode 100644
index 92063050b50f3..0000000000000
--- a/deps/checksums/cacert-2023-01-10.pem/md5
+++ /dev/null
@@ -1 +0,0 @@
-e7cf471ba7c88f4e313f492a76e624b3
diff --git a/deps/checksums/cacert-2023-01-10.pem/sha512 b/deps/checksums/cacert-2023-01-10.pem/sha512
deleted file mode 100644
index d3322e5890f81..0000000000000
--- a/deps/checksums/cacert-2023-01-10.pem/sha512
+++ /dev/null
@@ -1 +0,0 @@
-08cd35277bf2260cb3232d7a7ca3cce6b2bd58af9221922d2c6e9838a19c2f96d1ca6d77f3cc2a3ab611692f9fec939e9b21f67442282e867a487b0203ee0279
diff --git a/deps/checksums/cacert-2023-12-12.pem/md5 b/deps/checksums/cacert-2023-12-12.pem/md5
new file mode 100644
index 0000000000000..fa4b90b0b2ddd
--- /dev/null
+++ b/deps/checksums/cacert-2023-12-12.pem/md5
@@ -0,0 +1 @@
+1e305b4e910d204ab7b4c18ec0cf0f27
diff --git a/deps/checksums/cacert-2023-12-12.pem/sha512 b/deps/checksums/cacert-2023-12-12.pem/sha512
new file mode 100644
index 0000000000000..8ce26f24dffd9
--- /dev/null
+++ b/deps/checksums/cacert-2023-12-12.pem/sha512
@@ -0,0 +1 @@
+dcbfe08d39efdd8de555b31e1050757900d08448c61f8a67c055f14514e5d47e734f6874b5ae628021c35ebc8dabdfdac5808df0b3a073d4f9246cca4b725fe8
diff --git a/deps/libgit2.version b/deps/libgit2.version
index 9bd56f1bd0001..064c95094adb3 100644
--- a/deps/libgit2.version
+++ b/deps/libgit2.version
@@ -10,4 +10,5 @@ LIBGIT2_SHA1=a2bde63741977ca0f4ef7db2f609df320be67a08
 # Specify the version of the Mozilla CA Certificate Store to obtain.
 # The versions of cacert.pem are identified by the date (YYYY-MM-DD) of their changes.
 # See https://curl.haxx.se/docs/caextract.html for more details.
-MOZILLA_CACERT_VERSION := 2023-01-10
+# Keep in sync with `stdlib/MozillaCACerts_jll/Project.toml`.
+MOZILLA_CACERT_VERSION := 2023-12-12
diff --git a/stdlib/MozillaCACerts_jll/Project.toml b/stdlib/MozillaCACerts_jll/Project.toml
index cef860fda4acd..b4f667b974736 100644
--- a/stdlib/MozillaCACerts_jll/Project.toml
+++ b/stdlib/MozillaCACerts_jll/Project.toml
@@ -1,6 +1,7 @@
 name = "MozillaCACerts_jll"
 uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
-version = "2023.01.10"
+# Keep in sync with `deps/libgit2.version`.
+version = "2023.12.12"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

From 90d03b2bbec84488af7792258bf99fa2606b77a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Mon, 26 Feb 2024 00:37:13 +0000
Subject: [PATCH 1010/1315] [LibGit2_jll] Update to v1.7.2 (#53467)

Memo to self:

* update version number in `stdlib/LibGit2_jll/Project.toml`
* update test result in `stdlib/LibGit2_jll/test/runtests.jl`
* update version number and commit sha in `deps/libgit2.version`
* refresh checksums with `make -f contrib/refresh_checksums.mk -j libgit2`
---
 deps/checksums/libgit2              | 68 ++++++++++++++---------------
 deps/libgit2.version                |  4 +-
 stdlib/LibGit2_jll/Project.toml     |  2 +-
 stdlib/LibGit2_jll/test/runtests.jl |  2 +-
 4 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/deps/checksums/libgit2 b/deps/checksums/libgit2
index 63d67671b12a4..78b82572f3898 100644
--- a/deps/checksums/libgit2
+++ b/deps/checksums/libgit2
@@ -1,34 +1,34 @@
-LibGit2.v1.7.1+0.aarch64-apple-darwin.tar.gz/md5/80102fd8cd633a4875a1257bd61d4e17
-LibGit2.v1.7.1+0.aarch64-apple-darwin.tar.gz/sha512/3cc3679923c36e0020e692e79112a8fa71b53c1b83c9bea8d6defda124722a67c2859089d36fddef7be4547539575483db32de8137b43f7fc97843e579a02696
-LibGit2.v1.7.1+0.aarch64-linux-gnu.tar.gz/md5/74be95a3f7886a9804964f024df5311f
-LibGit2.v1.7.1+0.aarch64-linux-gnu.tar.gz/sha512/3ad8a3c9ced9be2ab5fefe651f445a26900beae743127dcd1f887d01a7672d5d6c523641ba7d402620f3c44a1cc9557e43e11ad1692726c8cfabecca59a030e9
-LibGit2.v1.7.1+0.aarch64-linux-musl.tar.gz/md5/e63f4351250b4f4ac60d66b0bed2ddf5
-LibGit2.v1.7.1+0.aarch64-linux-musl.tar.gz/sha512/8f2dd17fe55b7cf7cf60504e5b630b22ce27e4e89d75f7e93dba3b112f662470612987e09abd82c2e3df48fc3c0fe1dbf98c690d972edb50c10a5571741cd9e8
-LibGit2.v1.7.1+0.armv6l-linux-gnueabihf.tar.gz/md5/f06611068a36fa575ec8eb219c068723
-LibGit2.v1.7.1+0.armv6l-linux-gnueabihf.tar.gz/sha512/04c554b9617300cea7750d18590e1a5629e70274ef1e1e8fdabbb4347e46fd8a68e82ba21714d7cd3809c3b6de2e254baca35ff60a4be87485643c460b10ac73
-LibGit2.v1.7.1+0.armv6l-linux-musleabihf.tar.gz/md5/7135ca6e52bf63855c5b6aa45d59ad80
-LibGit2.v1.7.1+0.armv6l-linux-musleabihf.tar.gz/sha512/e542180d2d8a0896ec586edac03b91d48d2ece3d22220d09b6e717b1b95a38bc1de2ae0faeed39dd3e99150684441bfb0504b55b3e18e543e00561f91147d405
-LibGit2.v1.7.1+0.armv7l-linux-gnueabihf.tar.gz/md5/7ffc92c821ec99bd76865ece43f5face
-LibGit2.v1.7.1+0.armv7l-linux-gnueabihf.tar.gz/sha512/c945a0895be07479fd94c3c127060e58866bc9b9c93e80dc923ecdda6689e43d566896ecf4bfc7d85ca710b9ee51e6d85dec423edc48a3a2066db0fbb118d073
-LibGit2.v1.7.1+0.armv7l-linux-musleabihf.tar.gz/md5/3d00a6223612c23ac6b3c1f44bff8119
-LibGit2.v1.7.1+0.armv7l-linux-musleabihf.tar.gz/sha512/c3ef7783f140b28ad2d10e1c16f5be683d3332a4f9db5d26fdf3f2ac2b750aa0ceaec928740a9bdf7f4d9e83f666aa6e5fdd9c019630bf46f6797000943e1510
-LibGit2.v1.7.1+0.i686-linux-gnu.tar.gz/md5/6ea4e6777f5a8630f9fa98fb6a4a4ac7
-LibGit2.v1.7.1+0.i686-linux-gnu.tar.gz/sha512/d62a46b54dfc491a88fa35d06f3ed9c76ce676473b33acd5382e72ce07e6a313505755476c4732b7a22cd774ddcdf4ea5e8a5b62b93eb48b67363911655ac177
-LibGit2.v1.7.1+0.i686-linux-musl.tar.gz/md5/9f74dc4e93886f011412a4f61dfb487f
-LibGit2.v1.7.1+0.i686-linux-musl.tar.gz/sha512/1370cab2ef917aa759dd4986f247a6b4878f12c4b17399fa75c9a2878f86c136e6f2f998a396df0757bf36ac09d5d194e4b7688705d115f09c176f4a5ab22347
-LibGit2.v1.7.1+0.i686-w64-mingw32.tar.gz/md5/ce866e600b2ad8c0fd54ff8c57dc015c
-LibGit2.v1.7.1+0.i686-w64-mingw32.tar.gz/sha512/c7848b39f3515452e13fb156ee645f9a8d3917374ba874b10437b417b3c8e9a108e014b3baf30c7ced5fd0034d4f37de7e7d76fb105358d8e953dca30c873dc6
-LibGit2.v1.7.1+0.powerpc64le-linux-gnu.tar.gz/md5/b7c2f120e33f499860cb1e096923e7fe
-LibGit2.v1.7.1+0.powerpc64le-linux-gnu.tar.gz/sha512/3df8e54d2086fbedb55b5dc31a2010f2ecd277089293473607e780340882bda5b2f9a2cc1c53c88bd7fcca0791cc2530645ceda17de3f37bb1ff98a19ccb85cf
-LibGit2.v1.7.1+0.x86_64-apple-darwin.tar.gz/md5/b5334bd7e44c2c28705bb816fe03b9b7
-LibGit2.v1.7.1+0.x86_64-apple-darwin.tar.gz/sha512/d91cfde393499687cc699d55184c58ee5f543108902bf1f08fde2270dec0f38e0d70cbc7af04ffe46952afad12ce008e745f4aae9084f23df58982c14b48117c
-LibGit2.v1.7.1+0.x86_64-linux-gnu.tar.gz/md5/9e2e2fe324a40bb0a5364d218c5ce45e
-LibGit2.v1.7.1+0.x86_64-linux-gnu.tar.gz/sha512/da7e28c20c09c5c0731fd5cdff6fa6c319b2c4757d5c4228fc287238cd649f98c689814480119f21cbb938a29f52c895021b44c74eccc2f93ae51766555d9b6a
-LibGit2.v1.7.1+0.x86_64-linux-musl.tar.gz/md5/7147480b9520116eb63ee3c30fa60a21
-LibGit2.v1.7.1+0.x86_64-linux-musl.tar.gz/sha512/f3dfb2a416cb786f229fe9eb3ef653a30ba5ebf3b978475f0a10fa79fa68b7bce9b6d99aed19f8dfb5599d988e3c6d4ede9ef1a6ccdbb3c2ea61f76b97d7fb29
-LibGit2.v1.7.1+0.x86_64-unknown-freebsd.tar.gz/md5/39e1a6d463e52ca0b2a1a8e6c3c4a286
-LibGit2.v1.7.1+0.x86_64-unknown-freebsd.tar.gz/sha512/3978ba9923cc8a188aca36d7320d46b2788de27142d11920976c47ad43574ad7056539812cebab62550e656b263c2d277754c341bd83d013de608a91e6a0aad3
-LibGit2.v1.7.1+0.x86_64-w64-mingw32.tar.gz/md5/7d92c546023f460741a8187999b76bbe
-LibGit2.v1.7.1+0.x86_64-w64-mingw32.tar.gz/sha512/da00d54f969ce3b70cc95dda281ddfafee72073164c31d7999053ed704a59401d64894ad702306d6e19eb1a60e5e98e5960c9c7e9a0e1645a0f3048422e62eb9
-libgit2-e6325351ceee58cf56f58bdce61b38907805544f.tar.gz/md5/08777cc257825f218ceac1a24abafdc9
-libgit2-e6325351ceee58cf56f58bdce61b38907805544f.tar.gz/sha512/ebeaf3bb12ce7d58cd6d36e0123168de3af8f083f707dc20df9781537e38188a176667ac51daf8d9006d54f2beed13fbfff6c26fbb48e3228988578ef8fbc9b7
+LibGit2.v1.7.2+0.aarch64-apple-darwin.tar.gz/md5/069fa8cbd69e98a6196bd24bb427ff47
+LibGit2.v1.7.2+0.aarch64-apple-darwin.tar.gz/sha512/bacaf03e8aa28a55af2ae031f09a22f0a9cecb20257ee9778f37d87eb4ed21ff25dbb33ac342b134edc2a9584c0c57e6eabf7dbe78b031e9e45c2448bd8a317c
+LibGit2.v1.7.2+0.aarch64-linux-gnu.tar.gz/md5/3bc5dfb163045c335aec05097702ddd4
+LibGit2.v1.7.2+0.aarch64-linux-gnu.tar.gz/sha512/c8055e51713f6fe6f064c7e4626db7a70d07af6e5c8cb031e88ef8ea728accdb92a449f738fb248c0afbc9698d30d0670fa5cf640df564886887c7ce4dbc7124
+LibGit2.v1.7.2+0.aarch64-linux-musl.tar.gz/md5/23440824a3ec0a0d82fa8adccac63534
+LibGit2.v1.7.2+0.aarch64-linux-musl.tar.gz/sha512/040874d092d7a11c5bfa284e95b86335792ffa6b868e8c7165ca304647d82ffbc7a72b65bb92038abd1bfa545e831d5b2a658b3f5891377735f85d3e4ddff7b2
+LibGit2.v1.7.2+0.armv6l-linux-gnueabihf.tar.gz/md5/3ffc0954875a20f610f6852c522311f2
+LibGit2.v1.7.2+0.armv6l-linux-gnueabihf.tar.gz/sha512/35767e10a36a0025539a354ef5be2ec4031457c0c1121a07f4616c774e48bb85425732935a12718d23627b4bdf1fb5c7fe6b220cb4e2bcb94b9d26c743af0004
+LibGit2.v1.7.2+0.armv6l-linux-musleabihf.tar.gz/md5/73acea595fc31967d7fe1e808f4cc47c
+LibGit2.v1.7.2+0.armv6l-linux-musleabihf.tar.gz/sha512/e124681a7b7b1ff64a1ca073ee6fcc75fc2b11ab0a3404b0a2bc9944854c4048e576697254cd8efed1d6c7103ac2e1bd574a75c6c3d8a383775d48170ef6d474
+LibGit2.v1.7.2+0.armv7l-linux-gnueabihf.tar.gz/md5/b710035b0be0c7e4810b9282912369a0
+LibGit2.v1.7.2+0.armv7l-linux-gnueabihf.tar.gz/sha512/e34b2956a869303a5b6bed059f326989e4e95f039fa3d1b75fc6f80c6d1170df96e2ea809df05aad59685751eb4666a0a05e0c3b456bcace2b0570b174b2b541
+LibGit2.v1.7.2+0.armv7l-linux-musleabihf.tar.gz/md5/aa4c7374dda73266cd387596fa31c258
+LibGit2.v1.7.2+0.armv7l-linux-musleabihf.tar.gz/sha512/54f6c9bd7dd1ee0438b817b1b18a94ce6f18838613524f146cf37f7d01319dd7c05d19d352376454ed2658e9dd839fede32db05748d9c352b56c3f0fe01edebc
+LibGit2.v1.7.2+0.i686-linux-gnu.tar.gz/md5/2cf407e8cf5f7c7c984b48704935afaa
+LibGit2.v1.7.2+0.i686-linux-gnu.tar.gz/sha512/44224ccf773b9f77979c1130cbb893d80c934918940ab9357bff7d92b97bdf1671d4263d121a603a6c12e60375bafc38b4bcac9a12cb0abb4665b5848d12946a
+LibGit2.v1.7.2+0.i686-linux-musl.tar.gz/md5/742b947992f9f003a49c480165df1c87
+LibGit2.v1.7.2+0.i686-linux-musl.tar.gz/sha512/4d1a0c5c119f391be76d93ee7e82c6e38c8cda5c172c3d431bed6c6923776d4ad194c88509203332bed23f4c42581255a319a2ca45b6433b3fb68b3dc0aa1f02
+LibGit2.v1.7.2+0.i686-w64-mingw32.tar.gz/md5/476c290758970376ddfdcad25ba74c7c
+LibGit2.v1.7.2+0.i686-w64-mingw32.tar.gz/sha512/dc76e0563b45aead1187fd7abfe411e3fbc21ff45983b693c11db4265d39fc3f51d167fe447f6a7efb1f3ec1e35a9d0edb1c3444ed50be62770dfea545fbddae
+LibGit2.v1.7.2+0.powerpc64le-linux-gnu.tar.gz/md5/3ce536ea1ad7facca14c19c84106e8e5
+LibGit2.v1.7.2+0.powerpc64le-linux-gnu.tar.gz/sha512/d52d400249c7ed16084b13fde81f784cbf3b13b7081944872986b216b7faf186b7c8ff28626504d461c6059c7b4962acde0b15dc2e36007492210568a0f425f7
+LibGit2.v1.7.2+0.x86_64-apple-darwin.tar.gz/md5/c59af177b7ebdcfd52312a40d7832ee8
+LibGit2.v1.7.2+0.x86_64-apple-darwin.tar.gz/sha512/5bae0efc71421f28e4a3b2aca70ef1810b5810ed3df3d3577b8a7e956ea895f4b9efdabf17a32130e1f71fede4ceae7246d099b71147686e5722abdf56d50778
+LibGit2.v1.7.2+0.x86_64-linux-gnu.tar.gz/md5/1a55eb14294730b0ba7a23df3aac27ee
+LibGit2.v1.7.2+0.x86_64-linux-gnu.tar.gz/sha512/21f7aea927bed22da1b974eab4d6f3413cc41e47b5a5e5bbfff6690474d6f374952b81549345a68c9227d1f3ef9e76578c81776cd1c41e75330c9f2dd1437c7b
+LibGit2.v1.7.2+0.x86_64-linux-musl.tar.gz/md5/33a9bfb5a805ca6ca695196c2e94183e
+LibGit2.v1.7.2+0.x86_64-linux-musl.tar.gz/sha512/924c2c2cd9baad369b21c17364164dbff7ecda153cb1ed89a4a7539407f3bdc54e87304ed2b7e26ba8046077cb0b3645e9263d53eb4b220436a2e150a77109c3
+LibGit2.v1.7.2+0.x86_64-unknown-freebsd.tar.gz/md5/8d27555b9a1bc086c4c3056cda876bd2
+LibGit2.v1.7.2+0.x86_64-unknown-freebsd.tar.gz/sha512/8ca7a589a328908ee10490230c963ae1292f9cb7c2c427c26ca5d6e4985d56ef76d02f98e05e4fc655cc5e92e2e405d63896a180bc33ebd4b852d2ff355c0339
+LibGit2.v1.7.2+0.x86_64-w64-mingw32.tar.gz/md5/3d7ac5a2af376a2ba0b335cb84710874
+LibGit2.v1.7.2+0.x86_64-w64-mingw32.tar.gz/sha512/5bdbb1110fa7c5bfaac0ba63002f9b1f480abab1cf3e284146352c30027381c23919745a0c490e202e8d856503f5c2bb2390a6bc32af533def7d31f8d6f7be31
+libgit2-a418d9d4ab87bae16b87d8f37143a4687ae0e4b2.tar.gz/md5/c67e5a2358f01d26b78269639ba20148
+libgit2-a418d9d4ab87bae16b87d8f37143a4687ae0e4b2.tar.gz/sha512/c82dc18bacb45f82c72f09e5525fd47191c8673a553df9faa05290c33dfdadfff9784341e68790130a14b12267c795f4ca166481fdf9674d2b70e8228bbeb11d
diff --git a/deps/libgit2.version b/deps/libgit2.version
index 064c95094adb3..65f3e7670e4af 100644
--- a/deps/libgit2.version
+++ b/deps/libgit2.version
@@ -3,8 +3,8 @@
 LIBGIT2_JLL_NAME := LibGit2
 
 ## source build
-LIBGIT2_BRANCH=v1.7.1
-LIBGIT2_SHA1=a2bde63741977ca0f4ef7db2f609df320be67a08
+LIBGIT2_BRANCH=v1.7.2
+LIBGIT2_SHA1=a418d9d4ab87bae16b87d8f37143a4687ae0e4b2
 
 ## Other deps
 # Specify the version of the Mozilla CA Certificate Store to obtain.
diff --git a/stdlib/LibGit2_jll/Project.toml b/stdlib/LibGit2_jll/Project.toml
index e64d86dc6c9b7..1e13d0228488f 100644
--- a/stdlib/LibGit2_jll/Project.toml
+++ b/stdlib/LibGit2_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LibGit2_jll"
 uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"
-version = "1.7.1+0"
+version = "1.7.2+0"
 
 [deps]
 MbedTLS_jll = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
diff --git a/stdlib/LibGit2_jll/test/runtests.jl b/stdlib/LibGit2_jll/test/runtests.jl
index 86dcf659e7ab2..6d83f6e447453 100644
--- a/stdlib/LibGit2_jll/test/runtests.jl
+++ b/stdlib/LibGit2_jll/test/runtests.jl
@@ -7,5 +7,5 @@ using Test, Libdl, LibGit2_jll
     minor = Ref{Cint}(0)
     patch = Ref{Cint}(0)
     @test ccall((:git_libgit2_version, libgit2), Cint, (Ref{Cint}, Ref{Cint}, Ref{Cint}), major, minor, patch) == 0
-    @test VersionNumber(major[], minor[], patch[]) == v"1.7.1"
+    @test VersionNumber(major[], minor[], patch[]) == v"1.7.2"
 end

From 849d551d27950f3c7e7a314773e9261a9d83ffea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <mose@gnu.org>
Date: Mon, 9 May 2022 00:48:39 +0100
Subject: [PATCH 1011/1315] Use `@test ... broken=...` instead of
 `@test_broken`

---
 stdlib/LinearAlgebra/test/triangular.jl | 18 ++++--------------
 stdlib/TOML/test/toml_test.jl           | 12 ++----------
 test/compiler/inference.jl              |  6 +-----
 test/stacktraces.jl                     | 12 +++---------
 4 files changed, 10 insertions(+), 38 deletions(-)

diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index 97bf756044c66..7b222234c5fcb 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -1013,13 +1013,8 @@ end
             @test 2\L == 2\B
             @test real(L) == real(B)
             @test imag(L) == imag(B)
-            if A isa Matrix
-                @test transpose!(MT(copy(A))) == transpose(L)
-                @test adjoint!(MT(copy(A))) == adjoint(L)
-            else
-                @test_broken transpose!(MT(copy(A))) == transpose(L)
-                @test_broken adjoint!(MT(copy(A))) == adjoint(L)
-            end
+            @test transpose!(MT(copy(A))) == transpose(L) broken=!(A isa Matrix)
+            @test adjoint!(MT(copy(A))) == adjoint(L) broken=!(A isa Matrix)
         end
     end
 
@@ -1039,13 +1034,8 @@ end
             @test 2\U == 2\B
             @test real(U) == real(B)
             @test imag(U) == imag(B)
-            if A isa Matrix
-                @test transpose!(MT(copy(A))) == transpose(U)
-                @test adjoint!(MT(copy(A))) == adjoint(U)
-            else
-                @test_broken transpose!(MT(copy(A))) == transpose(U)
-                @test_broken adjoint!(MT(copy(A))) == adjoint(U)
-            end
+            @test transpose!(MT(copy(A))) == transpose(U) broken=!(A isa Matrix)
+            @test adjoint!(MT(copy(A))) == adjoint(U) broken=!(A isa Matrix)
         end
     end
 end
diff --git a/stdlib/TOML/test/toml_test.jl b/stdlib/TOML/test/toml_test.jl
index c22c01acf1870..cdd8950677c75 100644
--- a/stdlib/TOML/test/toml_test.jl
+++ b/stdlib/TOML/test/toml_test.jl
@@ -72,11 +72,7 @@ for (root, dirs, files) in walkdir(valid_test_folder)
                 rel = replace(rel, '\\' => '/')
             end
             v = check_valid(splitext(file)[1])
-            if rel in failures
-                @test_broken v
-            else
-                @test v
-            end
+            @test v broken=rel in failures
         end
     end
 end
@@ -145,11 +141,7 @@ for (root, dirs, files) in walkdir(invalid_test_folder)
                 rel = replace(rel, '\\' => '/')
             end
             v = check_invalid(file)
-            if rel in failures
-                @test_broken v
-            else
-                @test v
-            end
+            @test v broken=rel in failures
         end
     end
 end
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index d6d65faaaf7bb..a9b1d89d40e9d 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -184,11 +184,7 @@ Base.ndims(g::e43296) = ndims(typeof(g))
 # PR 22120
 function tuplemerge_test(a, b, r, commutative=true)
     @test r == Core.Compiler.tuplemerge(a, b)
-    if commutative
-        @test r == Core.Compiler.tuplemerge(b, a)
-    else
-        @test_broken r == Core.Compiler.tuplemerge(b, a)
-    end
+    @test r == Core.Compiler.tuplemerge(b, a) broken=!commutative
 end
 tuplemerge_test(Tuple{Int}, Tuple{String}, Tuple{Union{Int, String}})
 tuplemerge_test(Tuple{Int}, Tuple{String, String}, Tuple)
diff --git a/test/stacktraces.jl b/test/stacktraces.jl
index caea8158315ff..69b3b71d03167 100644
--- a/test/stacktraces.jl
+++ b/test/stacktraces.jl
@@ -92,15 +92,9 @@ can_inline = Bool(Base.JLOptions().can_inline)
 for (frame, func, inlined) in zip(trace, [g,h,f], (can_inline, can_inline, false))
     @test frame.func === typeof(func).name.mt.name
     # broken until #50082 can be addressed
-    if inlined
-        @test frame.linfo.def.module === which(func, (Any,)).module broken=true
-        @test frame.linfo.def === which(func, (Any,)) broken=true
-        @test frame.linfo.specTypes === Tuple{typeof(func), Int} broken=true
-    else
-        @test frame.linfo.def.module === which(func, (Any,)).module
-        @test frame.linfo.def === which(func, (Any,))
-        @test frame.linfo.specTypes === Tuple{typeof(func), Int}
-    end
+    @test frame.linfo.def.module === which(func, (Any,)).module broken=inlined
+    @test frame.linfo.def === which(func, (Any,)) broken=inlined
+    @test frame.linfo.specTypes === Tuple{typeof(func), Int} broken=inlined
     # line
     @test frame.file === Symbol(@__FILE__)
     @test !frame.from_c

From 34a515189a653080776e9d24295a0cfee393fe90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <mose@gnu.org>
Date: Mon, 26 Feb 2024 01:49:17 +0000
Subject: [PATCH 1012/1315] Use `@test ... skip=...` instead of `@test_skip`

---
 test/file.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/file.jl b/test/file.jl
index c32f655eb677e..e0241c5ef38df 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -1677,19 +1677,19 @@ end
         chmod(fpath, 0o644)
         @test !Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
-        Sys.iswindows() ? @test_skip(Sys.iswriteable(fpath)) : @test(Sys.iswriteable(fpath))
+        @test Sys.iswriteable(fpath) skip=Sys.iswindows()
         chmod(fpath, 0o755)
         @test Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
-        Sys.iswindows() ? @test_skip(Sys.iswriteable(fpath)) : @test(Sys.iswriteable(fpath))
+        @test Sys.iswriteable(fpath) skip=Sys.iswindows()
         chmod(fpath, 0o444)
         @test !Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
         @test !Sys.iswriteable(fpath)
         chmod(fpath, 0o244)
         @test !Sys.isexecutable(fpath)
-        Sys.iswindows() ? @test_skip(!Sys.isreadable(fpath)) : @test(!Sys.isreadable(fpath))
-        Sys.iswindows() ? @test_skip(Sys.iswriteable(fpath)) : @test(Sys.iswriteable(fpath))
+        @test !Sys.isreadable(fpath) skip=Sys.iswindows()
+        @test Sys.iswriteable(fpath) skip=Sys.iswindows()
 
         # Ensure that, on Windows, where inheritance is default,
         # chmod still behaves as we expect.

From 4b47cc48302281a705abf550748408eb78ec39d3 Mon Sep 17 00:00:00 2001
From: Eric Hanson <5846501+ericphanson@users.noreply.github.com>
Date: Mon, 26 Feb 2024 08:36:47 +0100
Subject: [PATCH 1013/1315] Remove stale explicit imports from many stdlibs
 (#53464)

Found via my new https://github.com/ericphanson/ExplicitImports.jl

```julia
using ExplicitImports

ExplicitImports.inspect_session(; inner=print_stale_explicit_imports)
```

These are not being used in the modules they are being imported into (or
in some cases they are being used, but only in a qualified way where the
explicit import is unnecessary). It can happen that someone imports a
name into a module in order to have it available in that namespace, to
then access it from another module (e.g. `TOML.Internals` seems to work
like this). I've tried to notice those situations and not remove the
imports in cases where I suspect the import is playing such a role, but
hopefully CI will figure out if I got it right in all cases.

I only looked at stdlibs that happened to be loaded in my Julia session
and whose code is in this repo, so there are probably more stale
explicit imports out there.
---
 stdlib/Dates/src/Dates.jl                       | 2 +-
 stdlib/FileWatching/src/pidfile.jl              | 2 --
 stdlib/InteractiveUtils/src/InteractiveUtils.jl | 2 +-
 stdlib/LibGit2/Project.toml                     | 1 -
 stdlib/LibGit2/src/LibGit2.jl                   | 3 +--
 stdlib/LibGit2/src/consts.jl                    | 2 +-
 stdlib/LinearAlgebra/src/LinearAlgebra.jl       | 2 +-
 stdlib/LinearAlgebra/src/blas.jl                | 3 +--
 stdlib/LinearAlgebra/src/structuredbroadcast.jl | 2 +-
 stdlib/REPL/src/LineEdit.jl                     | 3 +--
 stdlib/REPL/src/REPL.jl                         | 2 --
 stdlib/REPL/src/REPLCompletions.jl              | 2 +-
 stdlib/REPL/src/Terminals.jl                    | 4 +---
 stdlib/Serialization/src/Serialization.jl       | 2 +-
 stdlib/Sockets/src/Sockets.jl                   | 2 +-
 15 files changed, 12 insertions(+), 22 deletions(-)

diff --git a/stdlib/Dates/src/Dates.jl b/stdlib/Dates/src/Dates.jl
index bbfcdbee3f3d1..a4600a5f82043 100644
--- a/stdlib/Dates/src/Dates.jl
+++ b/stdlib/Dates/src/Dates.jl
@@ -32,7 +32,7 @@ for more information.
 """
 module Dates
 
-import Base: ==, isless, div, fld, mod, rem, gcd, lcm, +, -, *, /, %, broadcast
+import Base: ==, isless, div, fld, mod, rem, gcd, lcm, +, -, *, /, %
 using Printf: @sprintf
 
 using Base.Iterators
diff --git a/stdlib/FileWatching/src/pidfile.jl b/stdlib/FileWatching/src/pidfile.jl
index 71b596ba35f12..0ee86e70f8465 100644
--- a/stdlib/FileWatching/src/pidfile.jl
+++ b/stdlib/FileWatching/src/pidfile.jl
@@ -7,8 +7,6 @@ using Base:
     IOError, UV_EEXIST, UV_ESRCH,
     Process
 
-using Base.Libc: rand
-
 using Base.Filesystem:
     File, open, JL_O_CREAT, JL_O_RDWR, JL_O_RDONLY, JL_O_EXCL,
     rename, samefile, path_separator
diff --git a/stdlib/InteractiveUtils/src/InteractiveUtils.jl b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
index 519acfc8a2f33..a0020090e451d 100644
--- a/stdlib/InteractiveUtils/src/InteractiveUtils.jl
+++ b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
@@ -15,7 +15,7 @@ export apropos, edit, less, code_warntype, code_llvm, code_native, methodswith,
 
 import Base.Docs.apropos
 
-using Base: unwrap_unionall, rewrap_unionall, isdeprecated, Bottom, show_unquoted, summarysize,
+using Base: unwrap_unionall, rewrap_unionall, isdeprecated, Bottom, summarysize,
     signature_type, format_bytes
 using Base.Libc
 using Markdown
diff --git a/stdlib/LibGit2/Project.toml b/stdlib/LibGit2/Project.toml
index 83d359d6a4f1a..8432a32cd240b 100644
--- a/stdlib/LibGit2/Project.toml
+++ b/stdlib/LibGit2/Project.toml
@@ -3,7 +3,6 @@ uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
 version = "1.11.0"
 
 [deps]
-Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 LibGit2_jll = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"
 NetworkOptions = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
diff --git a/stdlib/LibGit2/src/LibGit2.jl b/stdlib/LibGit2/src/LibGit2.jl
index 43b960e8d509d..04435dd577c19 100644
--- a/stdlib/LibGit2/src/LibGit2.jl
+++ b/stdlib/LibGit2/src/LibGit2.jl
@@ -6,8 +6,7 @@ Interface to [libgit2](https://libgit2.org/).
 module LibGit2
 
 import Base: ==
-using Base: something, notnothing
-using Base64: base64decode
+using Base: something
 using NetworkOptions
 using Printf: @printf
 using SHA: sha1, sha256
diff --git a/stdlib/LibGit2/src/consts.jl b/stdlib/LibGit2/src/consts.jl
index 1f28a3bdbe887..5a5b8b74e7127 100644
--- a/stdlib/LibGit2/src/consts.jl
+++ b/stdlib/LibGit2/src/consts.jl
@@ -2,7 +2,7 @@
 
 module Consts
 
-import ..LibGit2: version, ensure_initialized
+import ..LibGit2: version
 
 const HEAD_FILE  = "HEAD"
 const FETCH_HEAD  = "FETCH_HEAD"
diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index acacf4b20cfc7..9b9aaf0d9581d 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -16,7 +16,7 @@ import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, as
     permutedims, permuterows!, power_by_squaring, promote_rule, real, sec, sech, setindex!,
     show, similar, sin, sincos, sinh, size, sqrt, strides, stride, tan, tanh, transpose, trunc,
     typed_hcat, vec, view, zero
-using Base: IndexLinear, promote_eltype, promote_op, promote_typeof, print_matrix,
+using Base: IndexLinear, promote_eltype, promote_op, print_matrix,
     @propagate_inbounds, reduce, typed_hvcat, typed_vcat, require_one_based_indexing,
     splat
 using Base.Broadcast: Broadcasted, broadcasted
diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 5d8821cd6e009..7bf7f8bf95100 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -5,7 +5,6 @@ Interface to BLAS subroutines.
 """
 module BLAS
 
-import Base: copyto!
 using Base: require_one_based_indexing, USE_BLAS64
 
 export
@@ -85,7 +84,7 @@ export
     trsm!,
     trsm
 
-using ..LinearAlgebra: libblastrampoline, BlasReal, BlasComplex, BlasFloat, BlasInt, DimensionMismatch, checksquare, stride1, chkstride1
+using ..LinearAlgebra: libblastrampoline, BlasReal, BlasComplex, BlasFloat, BlasInt, DimensionMismatch, checksquare, chkstride1
 
 include("lbt.jl")
 
diff --git a/stdlib/LinearAlgebra/src/structuredbroadcast.jl b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
index a227b678c9934..e5393bfc719f1 100644
--- a/stdlib/LinearAlgebra/src/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
@@ -2,7 +2,7 @@
 
 ## Broadcast styles
 import Base.Broadcast
-using Base.Broadcast: DefaultArrayStyle, Broadcasted, tail
+using Base.Broadcast: DefaultArrayStyle, Broadcasted
 
 struct StructuredMatrixStyle{T} <: Broadcast.AbstractArrayStyle{2} end
 StructuredMatrixStyle{T}(::Val{2}) where {T} = StructuredMatrixStyle{T}()
diff --git a/stdlib/REPL/src/LineEdit.jl b/stdlib/REPL/src/LineEdit.jl
index 9f1dd76b168af..3b63a256dafe2 100644
--- a/stdlib/REPL/src/LineEdit.jl
+++ b/stdlib/REPL/src/LineEdit.jl
@@ -6,8 +6,7 @@ import ..REPL
 using REPL: AbstractREPL, Options
 
 using ..Terminals
-import ..Terminals: raw!, width, height, cmove, getX,
-                       getY, clear_line, beep
+import ..Terminals: raw!, width, height, clear_line, beep
 
 import Base: ensureroom, show, AnyDict, position
 using Base: something
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index 840e6daaf1909..c5c45dee34a01 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -130,12 +130,10 @@ import ..LineEdit:
     history_first,
     history_last,
     history_search,
-    accept_result,
     setmodifiers!,
     terminal,
     MIState,
     PromptState,
-    TextInterface,
     mode_idx
 
 include("REPLCompletions.jl")
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 621cd6f9021fb..609825b772d47 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -4,7 +4,7 @@ module REPLCompletions
 
 export completions, shell_completions, bslash_completions, completion_text
 
-using Core: CodeInfo, MethodInstance, CodeInstance, Const
+using Core: Const
 const CC = Core.Compiler
 using Base.Meta
 using Base: propertynames, something, IdSet
diff --git a/stdlib/REPL/src/Terminals.jl b/stdlib/REPL/src/Terminals.jl
index dac19406b3fc1..821ed224f1829 100644
--- a/stdlib/REPL/src/Terminals.jl
+++ b/stdlib/REPL/src/Terminals.jl
@@ -30,9 +30,7 @@ import Base:
     displaysize,
     flush,
     pipe_reader,
-    pipe_writer,
-    read,
-    readuntil
+    pipe_writer
 
 ## AbstractTerminal: abstract supertype of all terminals ##
 
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index 7f122142c1fff..2e1d4cd801fd9 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -7,7 +7,7 @@ Provide serialization of Julia objects via the functions
 """
 module Serialization
 
-import Base: GMP, Bottom, unsafe_convert
+import Base: Bottom, unsafe_convert
 import Core: svec, SimpleVector
 using Base: unaliascopy, unwrap_unionall, require_one_based_indexing, ntupleany
 using Core.IR
diff --git a/stdlib/Sockets/src/Sockets.jl b/stdlib/Sockets/src/Sockets.jl
index 85f3e7639b6ae..5baf8826cc883 100644
--- a/stdlib/Sockets/src/Sockets.jl
+++ b/stdlib/Sockets/src/Sockets.jl
@@ -31,7 +31,7 @@ export
     IPv4,
     IPv6
 
-import Base: isless, show, print, parse, bind, convert, isreadable, iswritable, alloc_buf_hook, _uv_hook_close
+import Base: isless, show, print, parse, bind, alloc_buf_hook, _uv_hook_close
 
 using Base: LibuvStream, LibuvServer, PipeEndpoint, @handle_as, uv_error, associate_julia_struct, uvfinalize,
     notify_error, uv_req_data, uv_req_set_data, preserve_handle, unpreserve_handle, _UVError, IOError,

From b18824a9282b216a5e2b2e8d0cbb941a013154cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Mon, 26 Feb 2024 08:18:52 +0000
Subject: [PATCH 1014/1315] Wrap `contrib/check-whitespace.jl` in a function
 (#53468)

---
 contrib/check-whitespace.jl | 62 ++++++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 29 deletions(-)

diff --git a/contrib/check-whitespace.jl b/contrib/check-whitespace.jl
index b92f0c88a53a6..e178ec8a02a38 100755
--- a/contrib/check-whitespace.jl
+++ b/contrib/check-whitespace.jl
@@ -32,39 +32,43 @@ allow_tabs(path) =
 
 const errors = Set{Tuple{String,Int,String}}()
 
-for path in eachline(`git ls-files -- $patterns`)
-    lineno = 0
-    non_blank = 0
+function check_whitespace()
+    for path in eachline(`git ls-files -- $patterns`)
+        lineno = 0
+        non_blank = 0
 
-    file_err(msg) = push!(errors, (path, 0, msg))
-    line_err(msg) = push!(errors, (path, lineno, msg))
+        file_err(msg) = push!(errors, (path, 0, msg))
+        line_err(msg) = push!(errors, (path, lineno, msg))
 
-    isfile(path) || continue
-    for line in eachline(path, keep=true)
-        lineno += 1
-        contains(line, '\r')   && file_err("non-UNIX line endings")
-        contains(line, '\ua0') && line_err("non-breaking space")
-        allow_tabs(path) ||
-        contains(line, '\t')   && line_err("tab")
-        endswith(line, '\n')   || line_err("no trailing newline")
-        line = chomp(line)
-        endswith(line, r"\s")  && line_err("trailing whitespace")
-        contains(line, r"\S")  && (non_blank = lineno)
+        isfile(path) || continue
+        for line in eachline(path, keep=true)
+            lineno += 1
+            contains(line, '\r')   && file_err("non-UNIX line endings")
+            contains(line, '\ua0') && line_err("non-breaking space")
+            allow_tabs(path) ||
+                contains(line, '\t')   && line_err("tab")
+            endswith(line, '\n')   || line_err("no trailing newline")
+            line = chomp(line)
+            endswith(line, r"\s")  && line_err("trailing whitespace")
+            contains(line, r"\S")  && (non_blank = lineno)
+        end
+        non_blank < lineno         && line_err("trailing blank lines")
     end
-    non_blank < lineno         && line_err("trailing blank lines")
-end
 
-if isempty(errors)
-    println(stderr, "Whitespace check found no issues.")
-    exit(0)
-else
-    println(stderr, "Whitespace check found $(length(errors)) issues:")
-    for (path, lineno, msg) in sort!(collect(errors))
-        if lineno == 0
-            println(stderr, "$path -- $msg")
-        else
-            println(stderr, "$path:$lineno -- $msg")
+    if isempty(errors)
+        println(stderr, "Whitespace check found no issues.")
+        exit(0)
+    else
+        println(stderr, "Whitespace check found $(length(errors)) issues:")
+        for (path, lineno, msg) in sort!(collect(errors))
+            if lineno == 0
+                println(stderr, "$path -- $msg")
+            else
+                println(stderr, "$path:$lineno -- $msg")
+            end
         end
+        exit(1)
     end
-    exit(1)
 end
+
+check_whitespace()

From 3ebba8f6d152970045a9d5b03519855ae633b725 Mon Sep 17 00:00:00 2001
From: Simon Byrne <simonbyrne@gmail.com>
Date: Mon, 26 Feb 2024 06:06:32 -0800
Subject: [PATCH 1015/1315] use ScopedValues for MPFR precision and rounding
 (#51362)

Should fix thread safety issues.

Actually fixes #27139
---
 base/mpfr.jl | 174 ++++++++++++++++++++++++++-------------------------
 1 file changed, 90 insertions(+), 84 deletions(-)

diff --git a/base/mpfr.jl b/base/mpfr.jl
index c12154fa517c3..d3045371829f6 100644
--- a/base/mpfr.jl
+++ b/base/mpfr.jl
@@ -109,8 +109,9 @@ end
 tie_breaker_is_to_even(::MPFRRoundingMode) = true
 
 const ROUNDING_MODE = Ref{MPFRRoundingMode}(MPFRRoundNearest)
+const CURRENT_ROUNDING_MODE = ScopedValue{MPFRRoundingMode}()
 const DEFAULT_PRECISION = Ref{Clong}(256)
-
+const CURRENT_PRECISION = ScopedValue{Clong}()
 # Basic type and initialization definitions
 
 # Warning: the constants are MPFR implementation details from
@@ -144,7 +145,7 @@ mutable struct BigFloat <: AbstractFloat
         return new(prec, sign, exp, pointer(d), d)
     end
 
-    function BigFloat(; precision::Integer=DEFAULT_PRECISION[])
+    function BigFloat(; precision::Integer=_precision_with_base_2(BigFloat))
         precision < 1 && throw(DomainError(precision, "`precision` cannot be less than 1."))
         nb = ccall((:mpfr_custom_get_size,libmpfr), Csize_t, (Clong,), precision)
         nb = (nb + Core.sizeof(Limb) - 1) ÷ Core.sizeof(Limb) # align to number of Limb allocations required for this
@@ -158,11 +159,17 @@ end
 # The rounding mode here shouldn't matter.
 significand_limb_count(x::BigFloat) = div(sizeof(x._d), sizeof(Limb), RoundToZero)
 
-rounding_raw(::Type{BigFloat}) = ROUNDING_MODE[]
+rounding_raw(::Type{BigFloat}) = something(Base.ScopedValues.get(CURRENT_ROUNDING_MODE), ROUNDING_MODE[])
 setrounding_raw(::Type{BigFloat}, r::MPFRRoundingMode) = ROUNDING_MODE[]=r
+function setrounding_raw(f::Function, ::Type{BigFloat}, r::MPFRRoundingMode)
+    @with(CURRENT_ROUNDING_MODE => r, f())
+end
+
 
 rounding(::Type{BigFloat}) = convert(RoundingMode, rounding_raw(BigFloat))
 setrounding(::Type{BigFloat}, r::RoundingMode) = setrounding_raw(BigFloat, convert(MPFRRoundingMode, r))
+setrounding(f::Function, ::Type{BigFloat}, r::RoundingMode) =
+    setrounding_raw(f, BigFloat, convert(MPFRRoundingMode, r))
 
 
 # overload the definition of unsafe_convert to ensure that `x.d` is assigned
@@ -220,7 +227,7 @@ BigFloat(x, r::RoundingMode)
 widen(::Type{Float64}) = BigFloat
 widen(::Type{BigFloat}) = BigFloat
 
-function BigFloat(x::BigFloat, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[])
+function BigFloat(x::BigFloat, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat))
     if precision == _precision_with_base_2(x)
         return x
     else
@@ -240,7 +247,7 @@ end
 # convert to BigFloat
 for (fJ, fC) in ((:si,:Clong), (:ui,:Culong))
     @eval begin
-        function BigFloat(x::($fC), r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[])
+        function BigFloat(x::($fC), r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat))
             z = BigFloat(;precision=precision)
             ccall(($(string(:mpfr_set_,fJ)), libmpfr), Int32, (Ref{BigFloat}, $fC, MPFRRoundingMode), z, x, r)
             return z
@@ -248,7 +255,7 @@ for (fJ, fC) in ((:si,:Clong), (:ui,:Culong))
     end
 end
 
-function BigFloat(x::Float64, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[])
+function BigFloat(x::Float64, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat))
     z = BigFloat(;precision)
     # punt on the hard case where we might have to deal with rounding
     # we could use this path in all cases, but mpfr_set_d has a lot of overhead.
@@ -291,26 +298,26 @@ function BigFloat(x::Float64, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::In
     z
 end
 
-function BigFloat(x::BigInt, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[])
+function BigFloat(x::BigInt, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat))
     z = BigFloat(;precision=precision)
     ccall((:mpfr_set_z, libmpfr), Int32, (Ref{BigFloat}, Ref{BigInt}, MPFRRoundingMode), z, x, r)
     return z
 end
 
-BigFloat(x::Integer; precision::Integer=DEFAULT_PRECISION[]) =
-    BigFloat(BigInt(x)::BigInt, ROUNDING_MODE[]; precision=precision)
-BigFloat(x::Integer, r::MPFRRoundingMode; precision::Integer=DEFAULT_PRECISION[]) =
+BigFloat(x::Integer; precision::Integer=_precision_with_base_2(BigFloat)) =
+    BigFloat(BigInt(x)::BigInt, rounding_raw(BigFloat); precision=precision)
+BigFloat(x::Integer, r::MPFRRoundingMode; precision::Integer=_precision_with_base_2(BigFloat)) =
     BigFloat(BigInt(x)::BigInt, r; precision=precision)
 
-BigFloat(x::Union{Bool,Int8,Int16,Int32}, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[]) =
+BigFloat(x::Union{Bool,Int8,Int16,Int32}, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat)) =
     BigFloat(convert(Clong, x), r; precision=precision)
-BigFloat(x::Union{UInt8,UInt16,UInt32}, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[]) =
+BigFloat(x::Union{UInt8,UInt16,UInt32}, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat)) =
     BigFloat(convert(Culong, x), r; precision=precision)
 
-BigFloat(x::Union{Float16,Float32}, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[]) =
+BigFloat(x::Union{Float16,Float32}, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat)) =
     BigFloat(Float64(x), r; precision=precision)
 
-function BigFloat(x::Rational, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[])
+function BigFloat(x::Rational, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat))
     setprecision(BigFloat, precision) do
         setrounding_raw(BigFloat, r) do
             BigFloat(numerator(x))::BigFloat / BigFloat(denominator(x))::BigFloat
@@ -318,14 +325,14 @@ function BigFloat(x::Rational, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::I
     end
 end
 
-function tryparse(::Type{BigFloat}, s::AbstractString; base::Integer=0, precision::Integer=DEFAULT_PRECISION[], rounding::MPFRRoundingMode=ROUNDING_MODE[])
+function tryparse(::Type{BigFloat}, s::AbstractString; base::Integer=0, precision::Integer=_precision_with_base_2(BigFloat), rounding::MPFRRoundingMode=rounding_raw(BigFloat))
     !isempty(s) && isspace(s[end]) && return tryparse(BigFloat, rstrip(s), base = base)
     z = BigFloat(precision=precision)
     err = ccall((:mpfr_set_str, libmpfr), Int32, (Ref{BigFloat}, Cstring, Int32, MPFRRoundingMode), z, s, base, rounding)
     err == 0 ? z : nothing
 end
 
-BigFloat(x::AbstractString, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::Integer=DEFAULT_PRECISION[]) =
+BigFloat(x::AbstractString, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat)) =
     parse(BigFloat, x; precision=precision, rounding=r)
 
 Rational(x::BigFloat) = convert(Rational{BigInt}, x)
@@ -333,9 +340,9 @@ AbstractFloat(x::BigInt) = BigFloat(x)
 
 float(::Type{BigInt}) = BigFloat
 
-BigFloat(x::Real, r::RoundingMode; precision::Integer=DEFAULT_PRECISION[]) =
+BigFloat(x::Real, r::RoundingMode; precision::Integer=_precision_with_base_2(BigFloat)) =
     BigFloat(x, convert(MPFRRoundingMode, r); precision=precision)::BigFloat
-BigFloat(x::AbstractString, r::RoundingMode; precision::Integer=DEFAULT_PRECISION[]) =
+BigFloat(x::AbstractString, r::RoundingMode; precision::Integer=_precision_with_base_2(BigFloat)) =
     BigFloat(x, convert(MPFRRoundingMode, r); precision=precision)
 
 ## BigFloat -> Integer
@@ -385,7 +392,7 @@ round(::Type{BigInt}, x::BigFloat, r::RoundingMode) =
 unsafe_trunc(::Type{T}, x::BigFloat) where {T<:Integer} = unsafe_trunc(T, _unchecked_cast(T, x, RoundToZero))
 unsafe_trunc(::Type{BigInt}, x::BigFloat) = _unchecked_cast(BigInt, x, RoundToZero)
 
-round(::Type{T}, x::BigFloat) where T<:Integer = round(T, x, ROUNDING_MODE[])
+round(::Type{T}, x::BigFloat) where T<:Integer = round(T, x, rounding_raw(BigFloat))
 # these two methods are split to increase their precedence in disambiguation:
 round(::Type{Integer}, x::BigFloat, r::RoundingMode) = round(BigInt, x, r)
 round(::Type{Integer}, x::BigFloat, r::MPFRRoundingMode) = round(BigInt, x, r)
@@ -461,9 +468,9 @@ function to_ieee754(::Type{T}, x::BigFloat, rm) where {T<:AbstractFloat}
     reinterpret(T, ret_u)
 end
 
-Float16(x::BigFloat, r::MPFRRoundingMode=ROUNDING_MODE[]) = to_ieee754(Float16, x, r)
-Float32(x::BigFloat, r::MPFRRoundingMode=ROUNDING_MODE[]) = to_ieee754(Float32, x, r)
-Float64(x::BigFloat, r::MPFRRoundingMode=ROUNDING_MODE[]) = to_ieee754(Float64, x, r)
+Float16(x::BigFloat, r::MPFRRoundingMode=rounding_raw(BigFloat)) = to_ieee754(Float16, x, r)
+Float32(x::BigFloat, r::MPFRRoundingMode=rounding_raw(BigFloat)) = to_ieee754(Float32, x, r)
+Float64(x::BigFloat, r::MPFRRoundingMode=rounding_raw(BigFloat)) = to_ieee754(Float64, x, r)
 Float16(x::BigFloat, r::RoundingMode) = to_ieee754(Float16, x, r)
 Float32(x::BigFloat, r::RoundingMode) = to_ieee754(Float32, x, r)
 Float64(x::BigFloat, r::RoundingMode) = to_ieee754(Float64, x, r)
@@ -490,14 +497,14 @@ for (fJ, fC) in ((:+,:add), (:*,:mul))
         # BigFloat
         function ($fJ)(x::BigFloat, y::BigFloat)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC)),libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC)),libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
             return z
         end
 
         # Unsigned Integer
         function ($fJ)(x::BigFloat, c::CulongMax)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC,:_ui)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC,:_ui)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, c, rounding_raw(BigFloat))
             return z
         end
         ($fJ)(c::CulongMax, x::BigFloat) = ($fJ)(x,c)
@@ -505,7 +512,7 @@ for (fJ, fC) in ((:+,:add), (:*,:mul))
         # Signed Integer
         function ($fJ)(x::BigFloat, c::ClongMax)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC,:_si)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, x, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC,:_si)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, x, c, rounding_raw(BigFloat))
             return z
         end
         ($fJ)(c::ClongMax, x::BigFloat) = ($fJ)(x,c)
@@ -513,7 +520,7 @@ for (fJ, fC) in ((:+,:add), (:*,:mul))
         # Float32/Float64
         function ($fJ)(x::BigFloat, c::CdoubleMax)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC,:_d)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Cdouble, MPFRRoundingMode), z, x, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC,:_d)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Cdouble, MPFRRoundingMode), z, x, c, rounding_raw(BigFloat))
             return z
         end
         ($fJ)(c::CdoubleMax, x::BigFloat) = ($fJ)(x,c)
@@ -521,7 +528,7 @@ for (fJ, fC) in ((:+,:add), (:*,:mul))
         # BigInt
         function ($fJ)(x::BigFloat, c::BigInt)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC,:_z)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigInt}, MPFRRoundingMode), z, x, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC,:_z)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigInt}, MPFRRoundingMode), z, x, c, rounding_raw(BigFloat))
             return z
         end
         ($fJ)(c::BigInt, x::BigFloat) = ($fJ)(x,c)
@@ -533,50 +540,50 @@ for (fJ, fC) in ((:-,:sub), (:/,:div))
         # BigFloat
         function ($fJ)(x::BigFloat, y::BigFloat)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC)),libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC)),libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
             return z
         end
 
         # Unsigned Int
         function ($fJ)(x::BigFloat, c::CulongMax)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC,:_ui)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC,:_ui)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, c, rounding_raw(BigFloat))
             return z
         end
         function ($fJ)(c::CulongMax, x::BigFloat)
             z = BigFloat()
-            ccall(($(string(:mpfr_,:ui_,fC)), libmpfr), Int32, (Ref{BigFloat}, Culong, Ref{BigFloat}, MPFRRoundingMode), z, c, x, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,:ui_,fC)), libmpfr), Int32, (Ref{BigFloat}, Culong, Ref{BigFloat}, MPFRRoundingMode), z, c, x, rounding_raw(BigFloat))
             return z
         end
 
         # Signed Integer
         function ($fJ)(x::BigFloat, c::ClongMax)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC,:_si)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, x, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC,:_si)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, x, c, rounding_raw(BigFloat))
             return z
         end
         function ($fJ)(c::ClongMax, x::BigFloat)
             z = BigFloat()
-            ccall(($(string(:mpfr_,:si_,fC)), libmpfr), Int32, (Ref{BigFloat}, Clong, Ref{BigFloat}, MPFRRoundingMode), z, c, x, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,:si_,fC)), libmpfr), Int32, (Ref{BigFloat}, Clong, Ref{BigFloat}, MPFRRoundingMode), z, c, x, rounding_raw(BigFloat))
             return z
         end
 
         # Float32/Float64
         function ($fJ)(x::BigFloat, c::CdoubleMax)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC,:_d)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Cdouble, MPFRRoundingMode), z, x, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC,:_d)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Cdouble, MPFRRoundingMode), z, x, c, rounding_raw(BigFloat))
             return z
         end
         function ($fJ)(c::CdoubleMax, x::BigFloat)
             z = BigFloat()
-            ccall(($(string(:mpfr_,:d_,fC)), libmpfr), Int32, (Ref{BigFloat}, Cdouble, Ref{BigFloat}, MPFRRoundingMode), z, c, x, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,:d_,fC)), libmpfr), Int32, (Ref{BigFloat}, Cdouble, Ref{BigFloat}, MPFRRoundingMode), z, c, x, rounding_raw(BigFloat))
             return z
         end
 
         # BigInt
         function ($fJ)(x::BigFloat, c::BigInt)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC,:_z)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigInt}, MPFRRoundingMode), z, x, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC,:_z)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigInt}, MPFRRoundingMode), z, x, c, rounding_raw(BigFloat))
             return z
         end
         # no :mpfr_z_div function
@@ -585,7 +592,7 @@ end
 
 function -(c::BigInt, x::BigFloat)
     z = BigFloat()
-    ccall((:mpfr_z_sub, libmpfr), Int32, (Ref{BigFloat}, Ref{BigInt}, Ref{BigFloat}, MPFRRoundingMode), z, c, x, ROUNDING_MODE[])
+    ccall((:mpfr_z_sub, libmpfr), Int32, (Ref{BigFloat}, Ref{BigInt}, Ref{BigFloat}, MPFRRoundingMode), z, c, x, rounding_raw(BigFloat))
     return z
 end
 
@@ -593,7 +600,7 @@ inv(x::BigFloat) = one(Clong) / x # faster than fallback one(x)/x
 
 function fma(x::BigFloat, y::BigFloat, z::BigFloat)
     r = BigFloat()
-    ccall(("mpfr_fma",libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), r, x, y, z, ROUNDING_MODE[])
+    ccall(("mpfr_fma",libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), r, x, y, z, rounding_raw(BigFloat))
     return r
 end
 
@@ -664,23 +671,23 @@ for (fJ, fC, fI) in ((:+, :add, 0), (:*, :mul, 1))
     @eval begin
         function ($fJ)(a::BigFloat, b::BigFloat, c::BigFloat)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, a, b, ROUNDING_MODE[])
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, c, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, a, b, rounding_raw(BigFloat))
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, c, rounding_raw(BigFloat))
             return z
         end
         function ($fJ)(a::BigFloat, b::BigFloat, c::BigFloat, d::BigFloat)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, a, b, ROUNDING_MODE[])
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, c, ROUNDING_MODE[])
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, d, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, a, b, rounding_raw(BigFloat))
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, c, rounding_raw(BigFloat))
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, d, rounding_raw(BigFloat))
             return z
         end
         function ($fJ)(a::BigFloat, b::BigFloat, c::BigFloat, d::BigFloat, e::BigFloat)
             z = BigFloat()
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, a, b, ROUNDING_MODE[])
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, c, ROUNDING_MODE[])
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, d, ROUNDING_MODE[])
-            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, e, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, a, b, rounding_raw(BigFloat))
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, c, rounding_raw(BigFloat))
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, d, rounding_raw(BigFloat))
+            ccall(($(string(:mpfr_,fC)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, e, rounding_raw(BigFloat))
             return z
         end
     end
@@ -688,14 +695,14 @@ end
 
 function -(x::BigFloat)
     z = BigFloat()
-    ccall((:mpfr_neg, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, ROUNDING_MODE[])
+    ccall((:mpfr_neg, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, rounding_raw(BigFloat))
     return z
 end
 
 function sqrt(x::BigFloat)
     isnan(x) && return x
     z = BigFloat()
-    ccall((:mpfr_sqrt, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, ROUNDING_MODE[])
+    ccall((:mpfr_sqrt, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, rounding_raw(BigFloat))
     isnan(z) && throw(DomainError(x, "NaN result for non-NaN input."))
     return z
 end
@@ -704,25 +711,25 @@ sqrt(x::BigInt) = sqrt(BigFloat(x))
 
 function ^(x::BigFloat, y::BigFloat)
     z = BigFloat()
-    ccall((:mpfr_pow, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+    ccall((:mpfr_pow, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
     return z
 end
 
 function ^(x::BigFloat, y::CulongMax)
     z = BigFloat()
-    ccall((:mpfr_pow_ui, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+    ccall((:mpfr_pow_ui, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
     return z
 end
 
 function ^(x::BigFloat, y::ClongMax)
     z = BigFloat()
-    ccall((:mpfr_pow_si, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+    ccall((:mpfr_pow_si, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
     return z
 end
 
 function ^(x::BigFloat, y::BigInt)
     z = BigFloat()
-    ccall((:mpfr_pow_z, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigInt}, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+    ccall((:mpfr_pow_z, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigInt}, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
     return z
 end
 
@@ -732,7 +739,7 @@ end
 for f in (:exp, :exp2, :exp10, :expm1, :cosh, :sinh, :tanh, :sech, :csch, :coth, :cbrt)
     @eval function $f(x::BigFloat)
         z = BigFloat()
-        ccall(($(string(:mpfr_,f)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, ROUNDING_MODE[])
+        ccall(($(string(:mpfr_,f)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, rounding_raw(BigFloat))
         return z
     end
 end
@@ -740,7 +747,7 @@ end
 function sincos_fast(v::BigFloat)
     s = BigFloat()
     c = BigFloat()
-    ccall((:mpfr_sin_cos, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), s, c, v, ROUNDING_MODE[])
+    ccall((:mpfr_sin_cos, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), s, c, v, rounding_raw(BigFloat))
     return (s, c)
 end
 sincos(v::BigFloat) = sincos_fast(v)
@@ -748,18 +755,18 @@ sincos(v::BigFloat) = sincos_fast(v)
 # return log(2)
 function big_ln2()
     c = BigFloat()
-    ccall((:mpfr_const_log2, libmpfr), Cint, (Ref{BigFloat}, MPFRRoundingMode), c, MPFR.ROUNDING_MODE[])
+    ccall((:mpfr_const_log2, libmpfr), Cint, (Ref{BigFloat}, MPFRRoundingMode), c, MPFR.rounding_raw(BigFloat))
     return c
 end
 
 function ldexp(x::BigFloat, n::Clong)
     z = BigFloat()
-    ccall((:mpfr_mul_2si, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, x, n, ROUNDING_MODE[])
+    ccall((:mpfr_mul_2si, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, x, n, rounding_raw(BigFloat))
     return z
 end
 function ldexp(x::BigFloat, n::Culong)
     z = BigFloat()
-    ccall((:mpfr_mul_2ui, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, n, ROUNDING_MODE[])
+    ccall((:mpfr_mul_2ui, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, n, rounding_raw(BigFloat))
     return z
 end
 ldexp(x::BigFloat, n::ClongMax) = ldexp(x, convert(Clong, n))
@@ -772,13 +779,13 @@ function factorial(x::BigFloat)
     end
     ui = convert(Culong, x)
     z = BigFloat()
-    ccall((:mpfr_fac_ui, libmpfr), Int32, (Ref{BigFloat}, Culong, MPFRRoundingMode), z, ui, ROUNDING_MODE[])
+    ccall((:mpfr_fac_ui, libmpfr), Int32, (Ref{BigFloat}, Culong, MPFRRoundingMode), z, ui, rounding_raw(BigFloat))
     return z
 end
 
 function hypot(x::BigFloat, y::BigFloat)
     z = BigFloat()
-    ccall((:mpfr_hypot, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+    ccall((:mpfr_hypot, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
     return z
 end
 
@@ -790,7 +797,7 @@ for f in (:log, :log2, :log10)
                               "with a complex argument. Try ", $f, "(complex(x)).")))
         end
         z = BigFloat()
-        ccall(($(string(:mpfr_,f)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, ROUNDING_MODE[])
+        ccall(($(string(:mpfr_,f)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, rounding_raw(BigFloat))
         return z
     end
 end
@@ -802,7 +809,7 @@ function log1p(x::BigFloat)
                           "with a complex argument. Try log1p(complex(x)).")))
     end
     z = BigFloat()
-    ccall((:mpfr_log1p, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, ROUNDING_MODE[])
+    ccall((:mpfr_log1p, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, rounding_raw(BigFloat))
     return z
 end
 
@@ -826,19 +833,19 @@ end
 function modf(x::BigFloat)
     zint = BigFloat()
     zfloat = BigFloat()
-    ccall((:mpfr_modf, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), zint, zfloat, x, ROUNDING_MODE[])
+    ccall((:mpfr_modf, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), zint, zfloat, x, rounding_raw(BigFloat))
     return (zfloat, zint)
 end
 
 function rem(x::BigFloat, y::BigFloat)
     z = BigFloat()
-    ccall((:mpfr_fmod, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+    ccall((:mpfr_fmod, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
     return z
 end
 
 function rem(x::BigFloat, y::BigFloat, ::RoundingMode{:Nearest})
     z = BigFloat()
-    ccall((:mpfr_remainder, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+    ccall((:mpfr_remainder, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
     return z
 end
 
@@ -849,7 +856,7 @@ function sum(arr::AbstractArray{BigFloat})
     z = BigFloat(0)
     for i in arr
         ccall((:mpfr_add, libmpfr), Int32,
-            (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, i, ROUNDING_MODE[])
+            (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, z, i, rounding_raw(BigFloat))
     end
     return z
 end
@@ -860,7 +867,7 @@ for f in (:sin, :cos, :tan, :sec, :csc, :acos, :asin, :atan, :acosh, :asinh, :at
         function ($f)(x::BigFloat)
             isnan(x) && return x
             z = BigFloat()
-            ccall(($(string(:mpfr_,f)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,f)), libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, rounding_raw(BigFloat))
             isnan(z) && throw(DomainError(x, "NaN result for non-NaN input."))
             return z
         end
@@ -870,7 +877,7 @@ sincospi(x::BigFloat) = (sinpi(x), cospi(x))
 
 function atan(y::BigFloat, x::BigFloat)
     z = BigFloat()
-    ccall((:mpfr_atan2, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, y, x, ROUNDING_MODE[])
+    ccall((:mpfr_atan2, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, y, x, rounding_raw(BigFloat))
     return z
 end
 
@@ -880,14 +887,14 @@ for f in (:sin, :cos, :tan)
         function ($(Symbol(f,:d)))(x::BigFloat)
             isnan(x) && return x
             z = BigFloat()
-            ccall(($(string(:mpfr_,f,:u)), :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, 360, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_,f,:u)), :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, 360, rounding_raw(BigFloat))
             isnan(z) && throw(DomainError(x, "NaN result for non-NaN input."))
             return z
         end
         function ($(Symbol(:a,f,:d)))(x::BigFloat)
             isnan(x) && return x
             z = BigFloat()
-            ccall(($(string(:mpfr_a,f,:u)), :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, 360, ROUNDING_MODE[])
+            ccall(($(string(:mpfr_a,f,:u)), :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, x, 360, rounding_raw(BigFloat))
             isnan(z) && throw(DomainError(x, "NaN result for non-NaN input."))
             return z
         end
@@ -895,7 +902,7 @@ for f in (:sin, :cos, :tan)
 end
 function atand(y::BigFloat, x::BigFloat)
     z = BigFloat()
-    ccall((:mpfr_atan2u, :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, y, x, 360, ROUNDING_MODE[])
+    ccall((:mpfr_atan2u, :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, Culong, MPFRRoundingMode), z, y, x, 360, rounding_raw(BigFloat))
     return z
 end
 
@@ -959,7 +966,12 @@ function _precision_with_base_2(x::BigFloat)  # precision of an object of type B
 end
 precision(x::BigFloat; base::Integer=2) = _precision(x, base)
 
-_precision_with_base_2(::Type{BigFloat}) = Int(DEFAULT_PRECISION[]) # default precision of the type BigFloat itself
+
+_convert_precision_from_base(precision::Integer, base::Integer) =
+    base == 2 ? precision : ceil(Int, precision * log2(base))
+
+_precision_with_base_2(::Type{BigFloat}) =
+    Int(something(Base.ScopedValues.get(CURRENT_PRECISION), DEFAULT_PRECISION[])) # default precision of the type BigFloat itself
 
 """
     setprecision([T=BigFloat,] precision::Int; base=2)
@@ -980,7 +992,7 @@ at least `precision` digits in the given `base`.
 function setprecision(::Type{BigFloat}, precision::Integer; base::Integer=2)
     base > 1 || throw(DomainError(base, "`base` cannot be less than 2."))
     precision > 0 || throw(DomainError(precision, "`precision` cannot be less than 1."))
-    DEFAULT_PRECISION[] = base == 2 ? precision : ceil(Int, precision * log2(base))
+    DEFAULT_PRECISION[] = _convert_precision_from_base(precision, base)
     return precision
 end
 
@@ -991,7 +1003,7 @@ maxintfloat(::Type{BigFloat}) = BigFloat(2)^precision(BigFloat)
 
 function copysign(x::BigFloat, y::BigFloat)
     z = BigFloat()
-    ccall((:mpfr_copysign, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, ROUNDING_MODE[])
+    ccall((:mpfr_copysign, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, y, rounding_raw(BigFloat))
     return z
 end
 
@@ -1006,16 +1018,16 @@ end
 function frexp(x::BigFloat)
     z = BigFloat()
     c = Ref{Clong}()
-    ccall((:mpfr_frexp, libmpfr), Int32, (Ptr{Clong}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), c, z, x, ROUNDING_MODE[])
+    ccall((:mpfr_frexp, libmpfr), Int32, (Ptr{Clong}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), c, z, x, rounding_raw(BigFloat))
     return (z, c[])
 end
 
 function significand(x::BigFloat)
     z = BigFloat()
     c = Ref{Clong}()
-    ccall((:mpfr_frexp, libmpfr), Int32, (Ptr{Clong}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), c, z, x, ROUNDING_MODE[])
+    ccall((:mpfr_frexp, libmpfr), Int32, (Ptr{Clong}, Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), c, z, x, rounding_raw(BigFloat))
     # Double the significand to make it work as Base.significand
-    ccall((:mpfr_mul_si, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, z, 2, ROUNDING_MODE[])
+    ccall((:mpfr_mul_si, libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Clong, MPFRRoundingMode), z, z, 2, rounding_raw(BigFloat))
     return z
 end
 
@@ -1096,14 +1108,8 @@ Note: `nextfloat()`, `prevfloat()` do not use the precision mentioned by
 !!! compat "Julia 1.8"
     The `base` keyword requires at least Julia 1.8.
 """
-function setprecision(f::Function, ::Type{T}, prec::Integer; kws...) where T
-    old_prec = precision(T)
-    setprecision(T, prec; kws...)
-    try
-        return f()
-    finally
-        setprecision(T, old_prec)
-    end
+function setprecision(f::Function, ::Type{BigFloat}, prec::Integer; base::Integer=2)
+    @with(CURRENT_PRECISION => _convert_precision_from_base(prec, base), f())
 end
 
 setprecision(f::Function, prec::Integer; base::Integer=2) = setprecision(f, BigFloat, prec; base)

From 4634c743d20603873c2b0c9f3d6d5b71a6fd1853 Mon Sep 17 00:00:00 2001
From: Alexander Plavin <alexander@plav.in>
Date: Mon, 26 Feb 2024 14:17:38 -0500
Subject: [PATCH 1016/1315] add array `typeinfo` support for NamedTuples
 (#53465)

Closes https://github.com/JuliaLang/julia/issues/53455
---
 base/arrayshow.jl | 2 +-
 test/show.jl      | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/arrayshow.jl b/base/arrayshow.jl
index db639a88876e8..164a9257d8412 100644
--- a/base/arrayshow.jl
+++ b/base/arrayshow.jl
@@ -554,7 +554,7 @@ function typeinfo_implicit(@nospecialize(T))
     end
     return isconcretetype(T) &&
         ((T <: Array && typeinfo_implicit(eltype(T))) ||
-         ((T <: Tuple || T <: Pair) && all(typeinfo_implicit, fieldtypes(T))) ||
+         ((T <: Tuple || T <: NamedTuple || T <: Pair) && all(typeinfo_implicit, fieldtypes(T))) ||
          (T <: AbstractDict && typeinfo_implicit(keytype(T)) && typeinfo_implicit(valtype(T))))
 end
 
diff --git a/test/show.jl b/test/show.jl
index 66286f4df12ba..064ae76b6fe1f 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1892,6 +1892,7 @@ end
 
     @test showstr(Pair{Integer,Integer}(1, 2), :typeinfo => Pair{Integer,Integer}) == "1 => 2"
     @test showstr([Pair{Integer,Integer}(1, 2)]) == "Pair{Integer, Integer}[1 => 2]"
+    @test showstr([(a=1,)]) == "[(a = 1,)]"
     @test showstr(Dict{Integer,Integer}(1 => 2)) == "Dict{Integer, Integer}(1 => 2)"
     @test showstr(Dict(true=>false)) == "Dict{Bool, Bool}(1 => 0)"
     @test showstr(Dict((1 => 2) => (3 => 4))) == "Dict((1 => 2) => (3 => 4))"

From a796a41766c19e3daf004e0a6d7828cf09841d27 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 26 Feb 2024 14:52:42 -0500
Subject: [PATCH 1017/1315] add suffix kwarg to `tempname` (#53474)

`tempname` checks that the name its returning is not already a file,
however if you want that filename to contain other information, like a
file extension, that can mean the uniquing isn't complete.

This adds `tempname(suffix = "_foo.txt")` to include a suffix in the
name and uniquing check.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 NEWS.md      |  3 +++
 base/file.jl | 12 ++++++++----
 test/file.jl |  3 +++
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 6b5fd28082b9b..c37cb9efdd9b8 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -27,6 +27,9 @@ New library functions
 New library features
 --------------------
 
+* `tempname` can now take a suffix string to allow the file name to include a suffix and include that suffix in
+  the uniquing checking ([#53474])
+
 Standard library changes
 ------------------------
 
diff --git a/base/file.jl b/base/file.jl
index 6347f042e3422..6156bafacdc47 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -620,13 +620,13 @@ end
 
 
 # Obtain a temporary filename.
-function tempname(parent::AbstractString=tempdir(); max_tries::Int = 100, cleanup::Bool=true)
+function tempname(parent::AbstractString=tempdir(); max_tries::Int = 100, cleanup::Bool=true, suffix::AbstractString="")
     isdir(parent) || throw(ArgumentError("$(repr(parent)) is not a directory"))
 
     prefix = joinpath(parent, temp_prefix)
     filename = nothing
     for i in 1:max_tries
-        filename = string(prefix, _rand_filename())
+        filename = string(prefix, _rand_filename(), suffix)
         if ispath(filename)
             filename = nothing
         else
@@ -682,7 +682,7 @@ end # os-test
 
 
 """
-    tempname(parent=tempdir(); cleanup=true) -> String
+    tempname(parent=tempdir(); cleanup=true, suffix="") -> String
 
 Generate a temporary file path. This function only returns a path; no file is
 created. The path is likely to be unique, but this cannot be guaranteed due to
@@ -693,7 +693,8 @@ existing at the time of the call to `tempname`.
 When called with no arguments, the temporary name will be an absolute path to a
 temporary name in the system temporary directory as given by `tempdir()`. If a
 `parent` directory argument is given, the temporary path will be in that
-directory instead.
+directory instead. If a suffix is given the tempname will end with that suffix
+and be tested for uniqueness with that suffix.
 
 The `cleanup` option controls whether the process attempts to delete the
 returned path automatically when the process exits. Note that the `tempname`
@@ -705,6 +706,9 @@ you do and `cleanup` is `true` it will be deleted upon process termination.
     The `parent` and `cleanup` arguments were added in 1.4. Prior to Julia 1.4
     the path `tempname` would never be cleaned up at process termination.
 
+!!! compat "Julia 1.12"
+    The `suffix` keyword argument was added in Julia 1.12.
+
 !!! warning
 
     This can lead to security holes if another process obtains the same
diff --git a/test/file.jl b/test/file.jl
index e0241c5ef38df..1ce7a5cdb440b 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -124,6 +124,9 @@ end
     end
     @test_throws ArgumentError tempname(randstring())
 end
+@testset "tempname with suffix" begin
+    @test !isfile(tempname(suffix = "_foo.txt"))
+end
 
 child_eval(code::String) = eval(Meta.parse(readchomp(`$(Base.julia_cmd()) -E $code`)))
 

From 189a255ecfc98ddd1f16ee9d0cea5c98b6c19432 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Mon, 26 Feb 2024 15:18:44 -0500
Subject: [PATCH 1018/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Distributed=20stdlib=20from=2041c0106=20to=206a07d98=20(#534?=
 =?UTF-8?q?77)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Distributed
URL: https://github.com/JuliaLang/Distributed.jl
Stdlib branch: master
Julia branch: master
Old commit: 41c0106
New commit: 6a07d98
Julia version: 1.12.0-DEV
Distributed version: 1.11.0(Does not match)
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Distributed.jl/compare/41c01069533e22a6ce6b794746e4b3aa9f5a25cd...6a07d9853ab7686df7440a47d1b585c6c9f3be35

```
$ git log --oneline 41c0106..6a07d98
6a07d98 Merge pull request #93 from JuliaLang/ib/guard_rmprocs
41cd14f suppress interrupt trace from SIGTERM test
2b23ae4 guard rmprocs in tests
8c03305 do not call worker_from_id with pid<1 (#92)
25ee836 Add warning about new workers not sharing prior global state (#14)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/Distributed.version                                      | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/md5
 delete mode 100644 deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/sha512
 create mode 100644 deps/checksums/Distributed-6a07d9853ab7686df7440a47d1b585c6c9f3be35.tar.gz/md5
 create mode 100644 deps/checksums/Distributed-6a07d9853ab7686df7440a47d1b585c6c9f3be35.tar.gz/sha512

diff --git a/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/md5 b/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/md5
deleted file mode 100644
index 91dfaf6968e2b..0000000000000
--- a/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-5c6463034c358a254074e86ab81720b1
diff --git a/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/sha512 b/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/sha512
deleted file mode 100644
index 0ad09e2e6bf50..0000000000000
--- a/deps/checksums/Distributed-41c01069533e22a6ce6b794746e4b3aa9f5a25cd.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-bebc472ed89afc8f48eabe0ec0673cf416c5fc3b2f3c51599b388f47e47e6c9905a8a033a3f4b5c38a29be515c43fd70ef44750e7d6f8c6ecd8dc491b3012ac0
diff --git a/deps/checksums/Distributed-6a07d9853ab7686df7440a47d1b585c6c9f3be35.tar.gz/md5 b/deps/checksums/Distributed-6a07d9853ab7686df7440a47d1b585c6c9f3be35.tar.gz/md5
new file mode 100644
index 0000000000000..f6ae9d2d77aeb
--- /dev/null
+++ b/deps/checksums/Distributed-6a07d9853ab7686df7440a47d1b585c6c9f3be35.tar.gz/md5
@@ -0,0 +1 @@
+316bc519c49cd54685cfceb76a4dab5d
diff --git a/deps/checksums/Distributed-6a07d9853ab7686df7440a47d1b585c6c9f3be35.tar.gz/sha512 b/deps/checksums/Distributed-6a07d9853ab7686df7440a47d1b585c6c9f3be35.tar.gz/sha512
new file mode 100644
index 0000000000000..275997e84e6d5
--- /dev/null
+++ b/deps/checksums/Distributed-6a07d9853ab7686df7440a47d1b585c6c9f3be35.tar.gz/sha512
@@ -0,0 +1 @@
+e71c269c5ca92f4b5b709b871dd1bb06f9e23c5b1444a30f780ccb37f4aa19b50668a5f81c85269f7cea5ebe740b453c1b3fe1569629f441d01d8964cd185e54
diff --git a/stdlib/Distributed.version b/stdlib/Distributed.version
index ca528066e9403..b0acacf2367de 100644
--- a/stdlib/Distributed.version
+++ b/stdlib/Distributed.version
@@ -1,4 +1,4 @@
 DISTRIBUTED_BRANCH = master
-DISTRIBUTED_SHA1 = 41c01069533e22a6ce6b794746e4b3aa9f5a25cd
+DISTRIBUTED_SHA1 = 6a07d9853ab7686df7440a47d1b585c6c9f3be35
 DISTRIBUTED_GIT_URL := https://github.com/JuliaLang/Distributed.jl
 DISTRIBUTED_TAR_URL = https://api.github.com/repos/JuliaLang/Distributed.jl/tarball/$1

From 7f9288098b0140e4738e770e9de7dcb51d5dce3d Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 26 Feb 2024 16:06:35 -0500
Subject: [PATCH 1019/1315] add dedicated IO thread (capability only) (#53422)

It has been oft-requested that we have a dedicated IO thread. That
actually turns out to already be the case of something that exists,
except that we hard-code the identity of that thread as being thread 0.
This PR replaces all of the places where we hard code that assumption
with a variable so that they are more easily searched for in the code.
It also adds an internal function (`jl_set_io_loop_tid`) that can be
used to transfer ownership of the loop to any (valid) tid. In
conjunction with the prior foreign-threads work and foreign-thread pool,
this lets us spawn a dedicate IO-management thread with this bit of
code:

```julia
function make_io_thread()
    tid = UInt[0]
    threadwork = @cfunction function(arg::Ptr{Cvoid})
            Base.errormonitor(current_task()) # this may not go particularly well if the IO loop is dead, but try anyways
            @ccall jl_set_io_loop_tid((Threads.threadid() - 1)::Int16)::Cvoid
            wait() # spin uv_run as long as needed
            nothing
        end Cvoid (Ptr{Cvoid},)
    err = @ccall uv_thread_create(tid::Ptr{UInt}, threadwork::Ptr{Cvoid}, C_NULL::Ptr{Cvoid})::Cint
    err == 0 || Base.uv_error("uv_thread_create", err)
    @ccall uv_thread_detach(tid::Ptr{UInt})::Cint
    err == 0 || Base.uv_error("uv_thread_detach", err)
    # n.b. this does not wait for the thread to start or to take ownership of the event loop
    nothing
end
```
---
 base/stream.jl       |  1 +
 src/jl_uv.c          |  8 +++-----
 src/julia_internal.h | 23 ++---------------------
 src/scheduler.c      | 14 ++++++--------
 src/threading.c      | 25 +++++++++++++++++++++++--
 5 files changed, 35 insertions(+), 36 deletions(-)

diff --git a/base/stream.jl b/base/stream.jl
index 3264b8f153677..feb5ad777fc11 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -619,6 +619,7 @@ function notify_filled(buffer::IOBuffer, nread::Int)
         buffer.size += nread
     else
         buffer.ptr += nread
+        buffer.size = max(buffer.size, buffer.ptr - 1)
     end
     nothing
 end
diff --git a/src/jl_uv.c b/src/jl_uv.c
index e447faf8fa9c2..4da23a5937770 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -373,8 +373,6 @@ JL_DLLEXPORT void *jl_uv_handle_data(uv_handle_t *handle) { return handle->data;
  */
 JL_DLLEXPORT void *jl_uv_write_handle(uv_write_t *req) { return req->handle; }
 
-extern _Atomic(unsigned) _threadedregion;
-
 /**
  * @brief Process pending UV events.
  *
@@ -387,7 +385,7 @@ JL_DLLEXPORT int jl_process_events(void)
     jl_task_t *ct = jl_current_task;
     uv_loop_t *loop = jl_io_loop;
     jl_gc_safepoint_(ct->ptls);
-    if (loop && (jl_atomic_load_relaxed(&_threadedregion) || jl_atomic_load_relaxed(&ct->tid) == 0)) {
+    if (loop && (jl_atomic_load_relaxed(&_threadedregion) || jl_atomic_load_relaxed(&ct->tid) == jl_atomic_load_relaxed(&io_loop_tid))) {
         if (jl_atomic_load_relaxed(&jl_uv_n_waiters) == 0 && jl_mutex_trylock(&jl_uv_mutex)) {
             JL_PROBE_RT_START_PROCESS_EVENTS(ct);
             loop->stop_flag = 0;
@@ -637,7 +635,7 @@ JL_DLLEXPORT int jl_fs_write(uv_os_fd_t handle, const char *data, size_t len,
 {
     jl_task_t *ct = jl_get_current_task();
     // TODO: fix this cheating
-    if (jl_get_safe_restore() || ct == NULL || jl_atomic_load_relaxed(&ct->tid) != 0)
+    if (jl_get_safe_restore() || ct == NULL || jl_atomic_load_relaxed(&ct->tid) != jl_atomic_load_relaxed(&io_loop_tid))
 #ifdef _OS_WINDOWS_
         return WriteFile(handle, data, len, NULL, NULL);
 #else
@@ -718,7 +716,7 @@ JL_DLLEXPORT void jl_uv_puts(uv_stream_t *stream, const char *str, size_t n)
 
     // TODO: Hack to make CoreIO thread-safer
     jl_task_t *ct = jl_get_current_task();
-    if (ct == NULL || jl_atomic_load_relaxed(&ct->tid) != 0) {
+    if (ct == NULL || jl_atomic_load_relaxed(&ct->tid) != jl_atomic_load_relaxed(&io_loop_tid)) {
         if (stream == JL_STDOUT) {
             fd = UV_STDOUT_FD;
         }
diff --git a/src/julia_internal.h b/src/julia_internal.h
index bb98001fcb6e3..b9f4268f77d3f 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -97,23 +97,6 @@ JL_DLLIMPORT void *__tsan_get_current_fiber(void);
 JL_DLLIMPORT void __tsan_destroy_fiber(void *fiber);
 JL_DLLIMPORT void __tsan_switch_to_fiber(void *fiber, unsigned flags);
 #endif
-#ifdef __cplusplus
-}
-#endif
-
-// Remove when C11 is required for C code.
-#ifndef static_assert
-#  ifndef __cplusplus
-// C11 should already have `static_assert` from `<assert.h>` so there's no need
-// to check C version.
-#    ifdef __GNUC__
-#      define static_assert _Static_assert
-#    else
-#      define static_assert(...)
-#    endif
-#  endif
-// For C++, C++11 or MSVC is required. Both provide `static_assert`.
-#endif
 
 #ifndef alignof
 #  ifndef __cplusplus
@@ -182,10 +165,8 @@ extern jl_mutex_t jl_uv_mutex;
 extern _Atomic(int) jl_uv_n_waiters;
 void JL_UV_LOCK(void);
 #define JL_UV_UNLOCK() JL_UNLOCK(&jl_uv_mutex)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+extern _Atomic(unsigned) _threadedregion;
+extern _Atomic(uint16_t) io_loop_tid;
 
 int jl_running_under_rr(int recheck) JL_NOTSAFEPOINT;
 
diff --git a/src/scheduler.c b/src/scheduler.c
index dbc913353ce4c..81cf03bc38c5b 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -417,8 +417,6 @@ static int may_sleep(jl_ptls_t ptls) JL_NOTSAFEPOINT
 }
 
 
-extern _Atomic(unsigned) _threadedregion;
-
 JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q, jl_value_t *checkempty)
 {
     jl_task_t *ct = jl_current_task;
@@ -438,7 +436,7 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
 
         jl_cpu_pause();
         jl_ptls_t ptls = ct->ptls;
-        if (sleep_check_after_threshold(&start_cycles) || (ptls->tid == 0 && (!jl_atomic_load_relaxed(&_threadedregion) || wait_empty))) {
+        if (sleep_check_after_threshold(&start_cycles) || (ptls->tid == jl_atomic_load_relaxed(&io_loop_tid) && (!jl_atomic_load_relaxed(&_threadedregion) || wait_empty))) {
             // acquire sleep-check lock
             jl_atomic_store_relaxed(&ptls->sleep_check_state, sleeping);
             jl_fence(); // [^store_buffering_1]
@@ -485,7 +483,7 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
             if (jl_atomic_load_relaxed(&_threadedregion)) {
                 uvlock = jl_mutex_trylock(&jl_uv_mutex);
             }
-            else if (ptls->tid == 0) {
+            else if (ptls->tid == jl_atomic_load_relaxed(&io_loop_tid)) {
                 uvlock = 1;
                 JL_UV_LOCK();
             }
@@ -526,7 +524,7 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
                     start_cycles = 0;
                     continue;
                 }
-                if (!enter_eventloop && !jl_atomic_load_relaxed(&_threadedregion) && ptls->tid == 0) {
+                if (!enter_eventloop && !jl_atomic_load_relaxed(&_threadedregion) && ptls->tid == jl_atomic_load_relaxed(&io_loop_tid)) {
                     // thread 0 is the only thread permitted to run the event loop
                     // so it needs to stay alive, just spin-looping if necessary
                     if (set_not_sleeping(ptls)) {
@@ -543,10 +541,10 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
             assert(wasrunning);
             if (wasrunning == 1) {
                 // This was the last running thread, and there is no thread with !may_sleep
-                // so make sure tid 0 is notified to check wait_empty
+                // so make sure io_loop_tid is notified to check wait_empty
                 // TODO: this also might be a good time to check again that
                 // libuv's queue is truly empty, instead of during delete_thread
-                if (ptls->tid != 0) {
+                if (ptls->tid != jl_atomic_load_relaxed(&io_loop_tid)) {
                     uv_mutex_lock(&ptls->sleep_lock);
                     uv_cond_wait(&ptls->wake_signal, &ptls->sleep_lock);
                     uv_mutex_unlock(&ptls->sleep_lock);
@@ -597,7 +595,7 @@ void scheduler_delete_thread(jl_ptls_t ptls) JL_NOTSAFEPOINT
     jl_fence();
     if (notsleeping) {
         if (jl_atomic_load_relaxed(&nrunning) == 1) {
-            jl_ptls_t ptls2 = jl_atomic_load_relaxed(&jl_all_tls_states)[0];
+            jl_ptls_t ptls2 = jl_atomic_load_relaxed(&jl_all_tls_states)[jl_atomic_load_relaxed(&io_loop_tid)];
             // This was the last running thread, and there is no thread with !may_sleep
             // so make sure tid 0 is notified to check wait_empty
             uv_mutex_lock(&ptls2->sleep_lock);
diff --git a/src/threading.c b/src/threading.c
index 2eecb59db1f17..8879a34d6b701 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -808,7 +808,8 @@ void jl_start_threads(void)
     uv_barrier_wait(&thread_init_done);
 }
 
-_Atomic(unsigned) _threadedregion; // HACK: keep track of whether to prioritize IO or threading
+_Atomic(unsigned) _threadedregion; // keep track of whether to prioritize IO or threading
+_Atomic(uint16_t) io_loop_tid; // mark which thread is assigned to run the uv_loop
 
 JL_DLLEXPORT int jl_in_threaded_region(void)
 {
@@ -829,7 +830,27 @@ JL_DLLEXPORT void jl_exit_threaded_region(void)
         JL_UV_UNLOCK();
         // make sure thread 0 is not using the sleep_lock
         // so that it may enter the libuv event loop instead
-        jl_wakeup_thread(0);
+        jl_fence();
+        jl_wakeup_thread(jl_atomic_load_relaxed(&io_loop_tid));
+    }
+}
+
+JL_DLLEXPORT void jl_set_io_loop_tid(int16_t tid)
+{
+    if (tid < 0 || tid >= jl_atomic_load_relaxed(&jl_n_threads)) {
+        // TODO: do we care if this thread has exited or not started yet,
+        // since ptls2 might not be defined yet and visible on all threads yet
+        return;
+    }
+    jl_atomic_store_relaxed(&io_loop_tid, tid);
+    jl_fence();
+    if (jl_atomic_load_relaxed(&_threadedregion) == 0) {
+        // make sure the previous io_loop_tid leaves the libuv event loop
+        JL_UV_LOCK();
+        JL_UV_UNLOCK();
+        // make sure thread io_loop_tid is not using the sleep_lock
+        // so that it may enter the libuv event loop instead
+        jl_wakeup_thread(tid);
     }
 }
 

From a2be715dde75cfdc5cc0e5debcf1ce37b693cd8b Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 26 Feb 2024 16:08:57 -0500
Subject: [PATCH 1020/1315] gf: allow method shadowing with exact signatures
 without deletion (#53415)

We already allowed method shadowing for an inexact signature and
implicit method deletion by exact signatures, so it was fairly arbitrary
to implement it as a deletion for a replacement by an exact signature
rather than use the morespecific definition for this.

This change should be useful to Mocking libraries, such as Pluto, which
previously had a buggier version of this which tried to re-activate or
re-define the old methods.

There is a bit of code cleanup in here, either of unused features, or of
aspects that were broken, or of world_valid computations that were not
actually impacting the final result (e.g. when there is a more specific
result matches, it does not need to limit the result valid world range
because of a less specific result that does not get returned).
---
 NEWS.md                                   |  10 ++
 base/deprecated.jl                        |   8 +-
 base/reflection.jl                        |   7 +-
 doc/src/devdocs/types.md                  |  10 +-
 doc/src/manual/modules.md                 |   8 +-
 src/gf.c                                  | 137 +++++++++++++---------
 src/jl_exported_funcs.inc                 |   2 +-
 src/julia.h                               |   1 +
 src/julia_internal.h                      |   2 -
 src/subtype.c                             |  20 ++++
 src/typemap.c                             |  25 +---
 stdlib/Serialization/src/Serialization.jl |   2 +-
 test/compiler/invalidation.jl             |   8 +-
 test/reflection.jl                        |   2 +-
 test/specificity.jl                       |   4 +-
 test/worlds.jl                            |  24 ++++
 16 files changed, 161 insertions(+), 109 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index c37cb9efdd9b8..56a2ffb8d539d 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -7,6 +7,16 @@ New language features
 Language changes
 ----------------
 
+ - When methods are replaced with exactly equivalent ones, the old method is no
+   longer deleted implicitly simultaneously, although the new method does take
+   priority and become more specific than the old method. Thus if the new
+   method is deleted later, the old method will resume operating. This can be
+   useful to mocking frameworks (such as in SparseArrays, Pluto, and Mocking,
+   among others), as they do not need to explicitly restore the old method.
+   While inference and compilation still must be repeated with this, it also
+   may pave the way for inference to be able to intelligently re-use the old
+   results, once the new method is deleted. ([#53415])
+
 Compiler/Runtime improvements
 -----------------------------
 
diff --git a/base/deprecated.jl b/base/deprecated.jl
index 7e7fa5596ca25..5cb054f426344 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -29,11 +29,11 @@ To prevent `old` from being exported, set `export_old` to `false`.
 
 # Examples
 ```jldoctest
-julia> @deprecate old(x) new(x)
-old (generic function with 1 method)
+julia> @deprecate old_export(x) new(x)
+old_export (generic function with 1 method)
 
-julia> @deprecate old(x) new(x) false
-old (generic function with 1 method)
+julia> @deprecate old_public(x) new(x) false
+old_public (generic function with 1 method)
 ```
 
 Calls to `@deprecate` without explicit type-annotations will define
diff --git a/base/reflection.jl b/base/reflection.jl
index 202573b02f1bf..446e5825a16cc 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -887,6 +887,7 @@ A special case where exact behavior is guaranteed: when `T <: S`,
 typeintersect(@nospecialize(a), @nospecialize(b)) = (@_total_meta; ccall(:jl_type_intersection, Any, (Any, Any), a::Type, b::Type))
 
 morespecific(@nospecialize(a), @nospecialize(b)) = (@_total_meta; ccall(:jl_type_morespecific, Cint, (Any, Any), a::Type, b::Type) != 0)
+morespecific(a::Method, b::Method) = ccall(:jl_method_morespecific, Cint, (Any, Any), a, b) != 0
 
 """
     fieldoffset(type, i)
@@ -2492,7 +2493,7 @@ function isambiguous(m1::Method, m2::Method; ambiguous_bottom::Bool=false)
             for match in ms
                 m = match.method
                 match.fully_covers || continue
-                if minmax === nothing || morespecific(m.sig, minmax.sig)
+                if minmax === nothing || morespecific(m, minmax)
                     minmax = m
                 end
             end
@@ -2502,8 +2503,8 @@ function isambiguous(m1::Method, m2::Method; ambiguous_bottom::Bool=false)
             for match in ms
                 m = match.method
                 m === minmax && continue
-                if !morespecific(minmax.sig, m.sig)
-                    if match.fully_covers || !morespecific(m.sig, minmax.sig)
+                if !morespecific(minmax, m)
+                    if match.fully_covers || !morespecific(m, minmax)
                         return true
                     end
                 end
diff --git a/doc/src/devdocs/types.md b/doc/src/devdocs/types.md
index 42bdf251ac82f..120c948c6cadc 100644
--- a/doc/src/devdocs/types.md
+++ b/doc/src/devdocs/types.md
@@ -521,10 +521,6 @@ than the other.)  Likewise, `Tuple{Int,Vararg{Int}}` is not a subtype of `Tuple{
 considered more specific. However, `morespecific` does get a bonus for length: in particular,
 `Tuple{Int,Int}` is more specific than `Tuple{Int,Vararg{Int}}`.
 
-If you're debugging how methods get sorted, it can be convenient to define the function:
-
-```julia
-type_morespecific(a, b) = ccall(:jl_type_morespecific, Cint, (Any,Any), a, b)
-```
-
-which allows you to test whether tuple type `a` is more specific than tuple type `b`.
+Additionally, if 2 methods are defined with identical signatures, per type-equal, then they
+will instead by compared by order of addition, such that the later method is more specific
+than the earlier one.
diff --git a/doc/src/manual/modules.md b/doc/src/manual/modules.md
index 8c366616bac49..64befb03c1ad5 100644
--- a/doc/src/manual/modules.md
+++ b/doc/src/manual/modules.md
@@ -184,7 +184,6 @@ Stacktrace:
    @ none:0
  [2] top-level scope
    @ none:1
-
 ```
 
 This error prevents accidentally adding methods to functions in other modules that you only intended to use.
@@ -196,17 +195,16 @@ julia> using .NiceStuff
 julia> struct Cat end
 
 julia> NiceStuff.nice(::Cat) = "nice 😸"
-
 ```
 
 Alternatively, you can `import` the specific function name:
 ```jldoctest module_manual
 julia> import .NiceStuff: nice
 
-julia> struct Cat end
+julia> struct Mouse end
 
-julia> nice(::Cat) = "nice 😸"
-nice (generic function with 2 methods)
+julia> nice(::Mouse) = "nice 🐭"
+nice (generic function with 3 methods)
 ```
 
 Which one you choose is a matter of style. The first form makes it clear that you are adding a
diff --git a/src/gf.c b/src/gf.c
index f6a9d82a4625d..88890b7e5f203 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -276,7 +276,7 @@ JL_DLLEXPORT jl_value_t *jl_methtable_lookup(jl_methtable_t *mt, jl_value_t *typ
     // TODO: this is sort of an odd lookup strategy (and the only user of
     // jl_typemap_assoc_by_type with subtype=0), while normally jl_gf_invoke_lookup would be
     // expected to be used instead
-    struct jl_typemap_assoc search = {type, world, NULL, 0, ~(size_t)0};
+    struct jl_typemap_assoc search = {type, world, NULL};
     jl_typemap_entry_t *sf = jl_typemap_assoc_by_type(jl_atomic_load_relaxed(&mt->defs), &search, jl_cachearg_offset(mt), /*subtype*/0);
     if (!sf)
         return jl_nothing;
@@ -299,6 +299,8 @@ jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_a
     m->module = jl_core_module;
     m->isva = 1;
     m->nargs = 2;
+    jl_atomic_store_relaxed(&m->primary_world, 1);
+    jl_atomic_store_relaxed(&m->deleted_world, ~(size_t)0);
     m->sig = (jl_value_t*)jl_anytuple_type;
     m->slot_syms = jl_an_empty_string;
     m->nospecialize = 0;
@@ -309,7 +311,7 @@ jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_a
     JL_GC_PUSH2(&m, &newentry);
 
     newentry = jl_typemap_alloc(jl_anytuple_type, NULL, jl_emptysvec,
-            (jl_value_t*)m, 1, ~(size_t)0);
+            (jl_value_t*)m, jl_atomic_load_relaxed(&m->primary_world), jl_atomic_load_relaxed(&m->deleted_world));
     jl_typemap_insert(&mt->defs, (jl_value_t*)mt, newentry, jl_cachearg_offset(mt));
 
     jl_method_instance_t *mi = jl_get_specialized(m, (jl_value_t*)jl_anytuple_type, jl_emptysvec);
@@ -1236,7 +1238,7 @@ static jl_method_instance_t *cache_method(
             if (entry)
                 return entry->func.linfo;
         }
-        struct jl_typemap_assoc search = {(jl_value_t*)tt, world, NULL, 0, ~(size_t)0};
+        struct jl_typemap_assoc search = {(jl_value_t*)tt, world, NULL};
         jl_typemap_entry_t *entry = jl_typemap_assoc_by_type(jl_atomic_load_relaxed(cache), &search, offs, /*subtype*/1);
         if (entry && entry->func.value)
             return entry->func.linfo;
@@ -1387,7 +1389,7 @@ static jl_method_instance_t *cache_method(
     // short-circuit if an existing entry is already present
     // that satisfies our requirements
     if (cachett != tt) {
-        struct jl_typemap_assoc search = {(jl_value_t*)cachett, world, NULL, 0, ~(size_t)0};
+        struct jl_typemap_assoc search = {(jl_value_t*)cachett, world, NULL};
         jl_typemap_entry_t *entry = jl_typemap_assoc_by_type(jl_atomic_load_relaxed(cache), &search, offs, /*subtype*/1);
         if (entry && jl_egal((jl_value_t*)entry->simplesig, simplett ? (jl_value_t*)simplett : jl_nothing) &&
                 jl_egal((jl_value_t*)guardsigs, (jl_value_t*)entry->guardsigs)) {
@@ -1451,7 +1453,7 @@ static jl_method_instance_t *jl_mt_assoc_by_type(jl_methtable_t *mt JL_PROPAGATE
     }
 
     if (!mi) {
-        struct jl_typemap_assoc search = {(jl_value_t*)tt, world, NULL, 0, ~(size_t)0};
+        struct jl_typemap_assoc search = {(jl_value_t*)tt, world, NULL};
         jl_typemap_entry_t *entry = jl_typemap_assoc_by_type(jl_atomic_load_relaxed(&mt->cache), &search, jl_cachearg_offset(mt), /*subtype*/1);
         if (entry)
             mi = entry->func.linfo;
@@ -1491,7 +1493,8 @@ static int get_intersect_visitor(jl_typemap_entry_t *oldentry, struct typemap_in
     jl_method_t *oldmethod = oldentry->func.method;
     if (closure->match.issubty // e.g. jl_subtype(closure->newentry.sig, oldentry->sig)
         && jl_subtype(oldmethod->sig, (jl_value_t*)closure->newentry->sig)) { // e.g. jl_type_equal(closure->newentry->sig, oldentry->sig)
-        closure->replaced = oldentry;
+        if (closure->replaced == NULL || jl_atomic_load_relaxed(&closure->replaced->min_world) < jl_atomic_load_relaxed(&oldentry->min_world))
+            closure->replaced = oldentry; // must pick the newest insertion (both are still valid)
     }
     if (closure->shadowed == NULL)
         closure->shadowed = (jl_value_t*)jl_alloc_vec_any(0);
@@ -1795,13 +1798,18 @@ static int invalidate_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
     }
     return 1;
 }
+
+struct disable_mt_env {
+    jl_method_t *replaced;
+    size_t max_world;
+};
 static int disable_mt_cache(jl_typemap_entry_t *oldentry, void *closure0)
 {
-    struct invalidate_mt_env *env = (struct invalidate_mt_env*)closure0;
+    struct disable_mt_env *env = (struct disable_mt_env*)closure0;
     if (jl_atomic_load_relaxed(&oldentry->max_world) < ~(size_t)0)
         return 1;
     jl_method_t *m = oldentry->func.linfo->def.method;
-    if (m == env->newentry->func.method)
+    if (m == env->replaced)
         jl_atomic_store_relaxed(&oldentry->max_world, env->max_world);
     return 1;
 }
@@ -1815,33 +1823,23 @@ static int typemap_search(jl_typemap_entry_t *entry, void *closure)
     return 1;
 }
 
-static jl_typemap_entry_t *do_typemap_search(jl_methtable_t *mt JL_PROPAGATES_ROOT, jl_method_t *method) JL_NOTSAFEPOINT;
-
-#ifndef __clang_gcanalyzer__ /* in general, jl_typemap_visitor could be a safepoint, but not for typemap_search */
-static jl_typemap_entry_t *do_typemap_search(jl_methtable_t *mt JL_PROPAGATES_ROOT, jl_method_t *method) JL_NOTSAFEPOINT {
+static jl_typemap_entry_t *do_typemap_search(jl_methtable_t *mt JL_PROPAGATES_ROOT, jl_method_t *method) {
     jl_value_t *closure = (jl_value_t*)(method);
     if (jl_typemap_visitor(jl_atomic_load_relaxed(&mt->defs), typemap_search, &closure))
         jl_error("method not in method table");
     return (jl_typemap_entry_t *)closure;
 }
-#endif
 
-static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *methodentry, size_t max_world)
+static void jl_method_table_invalidate(jl_methtable_t *mt, jl_method_t *replaced, size_t max_world)
 {
     if (jl_options.incremental && jl_generating_output())
         jl_error("Method deletion is not possible during Module precompile.");
-    jl_method_t *method = methodentry->func.method;
-    assert(!method->is_for_opaque_closure);
+    assert(!replaced->is_for_opaque_closure);
     assert(jl_atomic_load_relaxed(&jl_world_counter) == max_world);
-    assert(jl_atomic_load_relaxed(&method->deleted_world) == ~(size_t)0);
-    jl_atomic_store_relaxed(&method->deleted_world, max_world);
-    jl_atomic_store_relaxed(&methodentry->max_world, max_world);
     // drop this method from mt->cache
-    struct invalidate_mt_env mt_cache_env;
+    struct disable_mt_env mt_cache_env;
     mt_cache_env.max_world = max_world;
-    mt_cache_env.newentry = methodentry;
-    mt_cache_env.shadowed = NULL;
-    mt_cache_env.invalidated = 0;
+    mt_cache_env.replaced = replaced;
     jl_typemap_visitor(jl_atomic_load_relaxed(&mt->cache), disable_mt_cache, (void*)&mt_cache_env);
     jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
     size_t i, l = leafcache->length;
@@ -1849,15 +1847,14 @@ static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *m
         jl_typemap_entry_t *oldentry = (jl_typemap_entry_t*)jl_genericmemory_ptr_ref(leafcache, i);
         if (oldentry) {
             while ((jl_value_t*)oldentry != jl_nothing) {
-                if (jl_atomic_load_relaxed(&oldentry->max_world) == ~(size_t)0)
-                    jl_atomic_store_relaxed(&oldentry->max_world, mt_cache_env.max_world);
+                disable_mt_cache(oldentry, (void*)&mt_cache_env);
                 oldentry = jl_atomic_load_relaxed(&oldentry->next);
             }
         }
     }
     // Invalidate the backedges
     int invalidated = 0;
-    jl_value_t *specializations = jl_atomic_load_relaxed(&method->specializations);
+    jl_value_t *specializations = jl_atomic_load_relaxed(&replaced->specializations);
     JL_GC_PUSH1(&specializations);
     if (!jl_is_svec(specializations))
         specializations = (jl_value_t*)jl_svec1(specializations);
@@ -1873,7 +1870,7 @@ static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *m
     // XXX: this might have resolved an ambiguity, for which we have not tracked the edge here,
     // and thus now introduce a mistake into inference
     if (invalidated && _jl_debug_method_invalidation) {
-        jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)method);
+        jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)replaced);
         jl_value_t *loctag = jl_cstr_to_string("jl_method_table_disable");
         JL_GC_PUSH1(&loctag);
         jl_array_ptr_1d_push(_jl_debug_method_invalidation, loctag);
@@ -1888,7 +1885,11 @@ JL_DLLEXPORT void jl_method_table_disable(jl_methtable_t *mt, jl_method_t *metho
     JL_LOCK(&mt->writelock);
     // Narrow the world age on the method to make it uncallable
     size_t world = jl_atomic_load_relaxed(&jl_world_counter);
-    jl_method_table_invalidate(mt, methodentry, world);
+    assert(method == methodentry->func.method);
+    assert(jl_atomic_load_relaxed(&method->deleted_world) == ~(size_t)0);
+    jl_atomic_store_relaxed(&method->deleted_world, world);
+    jl_atomic_store_relaxed(&methodentry->max_world, world);
+    jl_method_table_invalidate(mt, method, world);
     jl_atomic_store_release(&jl_world_counter, world + 1);
     JL_UNLOCK(&mt->writelock);
     JL_UNLOCK(&world_counter_lock);
@@ -2006,7 +2007,8 @@ void jl_method_table_activate(jl_methtable_t *mt, jl_typemap_entry_t *newentry)
         oldvalue = (jl_value_t*)replaced;
         invalidated = 1;
         method_overwrite(newentry, replaced->func.method);
-        jl_method_table_invalidate(mt, replaced, max_world);
+        // this is an optimized version of below, given we know the type-intersection is exact
+        jl_method_table_invalidate(mt, replaced->func.method, max_world);
     }
     else {
         jl_method_t *const *d;
@@ -2817,7 +2819,7 @@ static jl_method_instance_t *jl_get_compile_hint_specialization(jl_tupletype_t *
             exclude = 0;
             for (size_t j = n-1; j > i; j--) {  // more general methods maybe more likely to be at end
                 jl_method_match_t *match2 = (jl_method_match_t*)jl_array_ptr_ref(matches, j);
-                if (jl_type_morespecific(match1->method->sig, match2->method->sig)) {
+                if (jl_method_morespecific(match1->method, match2->method)) {
                     exclude = 1;
                     break;
                 }
@@ -3348,18 +3350,23 @@ static int ml_matches_visitor(jl_typemap_entry_t *ml, struct typemap_intersectio
             closure->match.min_valid = max_world + 1;
         return 1;
     }
-    else {
-        // intersect the env valid range with method's inclusive valid range
-        if (closure->match.min_valid < min_world)
-            closure->match.min_valid = min_world;
-        if (closure->match.max_valid > max_world)
-            closure->match.max_valid = max_world;
-    }
     jl_method_t *meth = ml->func.method;
     if (closure->lim >= 0 && jl_is_dispatch_tupletype(meth->sig)) {
-        if (closure->lim == 0)
-            return 0;
-        closure->lim--;
+        int replaced = 0;
+        // check if this is replaced, in which case we need to avoid double-counting it against the limit
+        // (although it will figure out later which one to keep and return)
+        size_t len = jl_array_nrows(closure->t);
+        for (int i = 0; i < len; i++) {
+            if (jl_types_equal(((jl_method_match_t*)jl_array_ptr_ref(closure->t, i))->method->sig, meth->sig)) {
+                replaced = 1;
+                break;
+            }
+        }
+        if (!replaced) {
+            if (closure->lim == 0)
+                return 0;
+            closure->lim--;
+        }
     }
     // don't need to consider other similar methods if this ml will always fully intersect with them and dominates all of them
     if (!closure->include_ambiguous || closure->lim != -1)
@@ -3384,7 +3391,6 @@ static int ml_mtable_visitor(jl_methtable_t *mt, void *closure0)
     return jl_typemap_intersection_visitor(jl_atomic_load_relaxed(&mt->defs), jl_cachearg_offset(mt), env);
 }
 
-
 // Visit the candidate methods, starting from t[idx], to determine a possible valid sort ordering,
 // where every morespecific method appears before any method which it has a common
 // intersection with but is not partly ambiguous with (ambiguity is transitive, particularly
@@ -3435,7 +3441,7 @@ static int sort_mlmatches(jl_array_t *t, size_t idx, arraylist_t *visited, array
             jl_method_t *m2 = matc2->method;
             if (jl_subtype(ti, m2->sig)) {
                 if (include_ambiguous) {
-                    if (!jl_type_morespecific((jl_value_t*)m2->sig, (jl_value_t*)m->sig))
+                    if (!jl_method_morespecific(m2, m))
                         continue;
                 }
                 visited->items[idx] = (void*)1;
@@ -3469,8 +3475,8 @@ static int sort_mlmatches(jl_array_t *t, size_t idx, arraylist_t *visited, array
         // since we only care about sorting of the intersections the user asked us about
         if (!subt2 && jl_has_empty_intersection(m2->sig, m->sig))
             continue;
-        int msp = jl_type_morespecific((jl_value_t*)m->sig, (jl_value_t*)m2->sig);
-        int msp2 = !msp && jl_type_morespecific((jl_value_t*)m2->sig, (jl_value_t*)m->sig);
+        int msp = jl_method_morespecific(m, m2);
+        int msp2 = !msp && jl_method_morespecific(m2, m);
         if (!msp) {
             if (subt || !include_ambiguous || (lim != -1 && msp2)) {
                 if (subt2 || jl_subtype((jl_value_t*)ti, m2->sig)) {
@@ -3510,7 +3516,7 @@ static int sort_mlmatches(jl_array_t *t, size_t idx, arraylist_t *visited, array
                     jl_method_t *m2 = matc2->method;
                     if (jl_subtype(ti, m2->sig)) {
                         if (include_ambiguous) {
-                            if (!jl_type_morespecific((jl_value_t*)m2->sig, (jl_value_t*)m->sig))
+                            if (!jl_method_morespecific(m2, m))
                                 continue;
                         }
                         visited->items[idx] = (void*)1;
@@ -3586,7 +3592,7 @@ static int sort_mlmatches(jl_array_t *t, size_t idx, arraylist_t *visited, array
                     jl_method_t *m2 = matc2->method;
                     if (jl_subtype(ti, m2->sig)) {
                         if (include_ambiguous) {
-                            if (!jl_type_morespecific((jl_value_t*)m2->sig, (jl_value_t*)m->sig))
+                            if (!jl_method_morespecific(m2, m))
                                 continue;
                         }
                         visited->items[childidx] = (void*)1;
@@ -3617,8 +3623,7 @@ static int sort_mlmatches(jl_array_t *t, size_t idx, arraylist_t *visited, array
                         // we don't consider that a third method might be
                         // disrupting that ordering and just consider them
                         // pairwise to keep this simple).
-                        if (!jl_type_morespecific((jl_value_t*)m->sig, (jl_value_t*)m2->sig) &&
-                            !jl_type_morespecific((jl_value_t*)m2->sig, (jl_value_t*)m->sig)) {
+                        if (!jl_method_morespecific(m, m2) && !jl_method_morespecific(m2, m)) {
                             visited->items[childidx] = (void*)-1;
                             break;
                         }
@@ -3656,7 +3661,6 @@ static int sort_mlmatches(jl_array_t *t, size_t idx, arraylist_t *visited, array
 }
 
 
-
 // This is the collect form of calling jl_typemap_intersection_visitor
 // with optimizations to skip fully shadowed methods.
 //
@@ -3692,7 +3696,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
             /* .ti = */ NULL, /* .env = */ jl_emptysvec, /* .issubty = */ 0},
         intersections, world, lim, include_ambiguous, /* .t = */ jl_an_empty_vec_any,
         /* .matc = */ NULL};
-    struct jl_typemap_assoc search = {(jl_value_t*)type, world, jl_emptysvec, 1, ~(size_t)0};
+    struct jl_typemap_assoc search = {(jl_value_t*)type, world, jl_emptysvec};
     jl_value_t *isect2 = NULL;
     JL_GC_PUSH6(&env.t, &env.matc, &env.match.env, &search.env, &env.match.ti, &isect2);
 
@@ -3760,6 +3764,9 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
         }
         if (!ml_mtable_visitor(mt, &env.match)) {
             JL_GC_POP();
+            // if we return early, set only the min/max valid collected from matching
+            *min_valid = env.match.min_valid;
+            *max_valid = env.match.max_valid;
             return jl_nothing;
         }
     }
@@ -3767,9 +3774,13 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
         // else: scan everything
         if (!jl_foreach_reachable_mtable(ml_mtable_visitor, &env.match)) {
             JL_GC_POP();
+            // if we return early, set only the min/max valid collected from matching
+            *min_valid = env.match.min_valid;
+            *max_valid = env.match.max_valid;
             return jl_nothing;
         }
     }
+    // if we return early, set only the min/max valid collected from matching
     *min_valid = env.match.min_valid;
     *max_valid = env.match.max_valid;
     // done with many of these values now
@@ -3789,7 +3800,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
                 jl_method_t *m = matc->method;
                 if (minmax != NULL) {
                     jl_method_t *minmaxm = minmax->method;
-                    if (jl_type_morespecific((jl_value_t*)minmaxm->sig, (jl_value_t*)m->sig))
+                    if (jl_method_morespecific(minmaxm, m))
                         continue;
                 }
                 minmax = matc;
@@ -3807,7 +3818,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
                 if (matc->fully_covers == FULLY_COVERS) {
                     jl_method_t *m = matc->method;
                     jl_method_t *minmaxm = minmax->method;
-                    if (!jl_type_morespecific((jl_value_t*)minmaxm->sig, (jl_value_t*)m->sig)) {
+                    if (!jl_method_morespecific(minmaxm, m)) {
                         minmax_ambig = 1;
                         minmax = NULL;
                         has_ambiguity = 1;
@@ -3832,7 +3843,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
                 jl_method_match_t *matc = (jl_method_match_t*)jl_array_ptr_ref(env.t, i);
                 if (matc->fully_covers != FULLY_COVERS) {
                     jl_method_t *m = matc->method;
-                    if (jl_type_morespecific((jl_value_t*)minmaxm->sig, (jl_value_t*)m->sig))
+                    if (jl_method_morespecific(minmaxm, m))
                         matc->fully_covers = SENTINEL; // put a sentinel value here for sorting
                     else
                         all_subtypes = 0;
@@ -3951,8 +3962,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
                         if (ti == jl_bottom_type)
                             continue;
                         // and they aren't themselves simply ordered
-                        if (jl_type_morespecific((jl_value_t*)m->sig, (jl_value_t*)m2->sig) ||
-                            jl_type_morespecific((jl_value_t*)m2->sig, (jl_value_t*)m->sig))
+                        if (jl_method_morespecific(m, m2) || jl_method_morespecific(m2, m))
                             continue;
                         // now look for a third method m3 that dominated these and that fully covered this intersection already
                         size_t k;
@@ -3965,8 +3975,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
                             jl_method_match_t *matc3 = (jl_method_match_t*)jl_array_ptr_ref(env.t, idx3);
                             jl_method_t *m3 = matc3->method;
                             if ((jl_subtype(ti, m3->sig) || (isect2 && jl_subtype(isect2, m3->sig)))
-                                    && jl_type_morespecific((jl_value_t*)m3->sig, (jl_value_t*)m->sig)
-                                    && jl_type_morespecific((jl_value_t*)m3->sig, (jl_value_t*)m2->sig)) {
+                                    && jl_method_morespecific(m3, m) && jl_method_morespecific(m3, m2)) {
                                 //if (jl_subtype(matc->spec_types, ti) || jl_subtype(matc->spec_types, matc3->m3->sig))
                                 //    // check if it covered not only this intersection, but all intersections with matc
                                 //    // if so, we do not need to check all of them separately
@@ -4008,6 +4017,18 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
             jl_array_del_end((jl_array_t*)env.t, len - j);
         len = j;
     }
+    for (j = 0; j < len; j++) {
+        jl_method_match_t *matc = (jl_method_match_t*)jl_array_ptr_ref(env.t, j);
+        jl_method_t *m = matc->method;
+        // method applicability is the same as typemapentry applicability
+        size_t min_world = jl_atomic_load_relaxed(&m->primary_world);
+        size_t max_world = jl_atomic_load_relaxed(&m->deleted_world);
+        // intersect the env valid range with method lookup's inclusive valid range
+        if (env.match.min_valid < min_world)
+            env.match.min_valid = min_world;
+        if (env.match.max_valid > max_world)
+            env.match.max_valid = max_world;
+    }
     if (mt && cache_result && ((jl_datatype_t*)unw)->isdispatchtuple) { // cache_result parameter keeps this from being recursive
         if (len == 1 && !has_ambiguity) {
             env.matc = (jl_method_match_t*)jl_array_ptr_ref(env.t, 0);
@@ -4018,6 +4039,8 @@ static jl_value_t *ml_matches(jl_methtable_t *mt,
             JL_UNLOCK(&mt->writelock);
         }
     }
+    *min_valid = env.match.min_valid;
+    *max_valid = env.match.max_valid;
     if (ambig != NULL)
         *ambig = has_ambiguity;
     JL_GC_POP();
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 4498f3132d1bc..48bbec09688b7 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -479,7 +479,7 @@
     XX(jl_type_intersection) \
     XX(jl_type_intersection_with_env) \
     XX(jl_type_morespecific) \
-    XX(jl_type_morespecific_no_subtype) \
+    XX(jl_method_morespecific) \
     XX(jl_type_union) \
     XX(jl_type_unionall) \
     XX(jl_unbox_bool) \
diff --git a/src/julia.h b/src/julia.h
index 0505b1e88d4bb..a7e0c1b2db17b 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1711,6 +1711,7 @@ JL_DLLEXPORT jl_value_t *jl_type_unionall(jl_tvar_t *v, jl_value_t *body);
 JL_DLLEXPORT const char *jl_typename_str(jl_value_t *v) JL_NOTSAFEPOINT;
 JL_DLLEXPORT const char *jl_typeof_str(jl_value_t *v) JL_NOTSAFEPOINT;
 JL_DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT int jl_method_morespecific(jl_method_t *ma, jl_method_t *mb);
 
 STATIC_INLINE int jl_is_dispatch_tupletype(jl_value_t *v) JL_NOTSAFEPOINT
 {
diff --git a/src/julia_internal.h b/src/julia_internal.h
index b9f4268f77d3f..76556e288f387 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1465,8 +1465,6 @@ struct jl_typemap_assoc {
     size_t const world;
     // outputs
     jl_svec_t *env; // subtype env (initialize to null to perform intersection without an environment)
-    size_t min_valid;
-    size_t max_valid;
 };
 
 jl_typemap_entry_t *jl_typemap_assoc_by_type(
diff --git a/src/subtype.c b/src/subtype.c
index 4a797aab9831d..c6b51ec872e75 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -5150,6 +5150,26 @@ JL_DLLEXPORT int jl_type_morespecific_no_subtype(jl_value_t *a, jl_value_t *b)
     return type_morespecific_(a, b, a, b, 0, NULL);
 }
 
+// Equivalent to `jl_type_morespecific` of the signatures, except that more recent
+// methods are more specific, iff the methods signatures are type-equal
+JL_DLLEXPORT int jl_method_morespecific(jl_method_t *ma, jl_method_t *mb)
+{
+    jl_value_t *a = (jl_value_t*)ma->sig;
+    jl_value_t *b = (jl_value_t*)mb->sig;
+    if (obviously_disjoint(a, b, 1))
+        return 0;
+    if (jl_has_free_typevars(a) || jl_has_free_typevars(b))
+        return 0;
+    if (jl_subtype(b, a)) {
+        if (jl_types_equal(a, b))
+            return jl_atomic_load_relaxed(&ma->primary_world) > jl_atomic_load_relaxed(&mb->primary_world);
+        return 0;
+    }
+    if (jl_subtype(a, b))
+        return 1;
+    return type_morespecific_(a, b, a, b, 0, NULL);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/typemap.c b/src/typemap.c
index 1f69d5da8af6e..b8b699e101fe5 100644
--- a/src/typemap.c
+++ b/src/typemap.c
@@ -836,9 +836,7 @@ static jl_typemap_entry_t *jl_typemap_entry_assoc_by_type(
     size_t n = jl_nparams(unw);
     int typesisva = n == 0 ? 0 : jl_is_vararg(jl_tparam(unw, n-1));
     for (; ml != (void*)jl_nothing; ml = jl_atomic_load_relaxed(&ml->next)) {
-        if (search->max_valid < jl_atomic_load_relaxed(&ml->min_world))
-            continue;
-        if (search->min_valid > jl_atomic_load_relaxed(&ml->max_world))
+        if (search->world < jl_atomic_load_relaxed(&ml->min_world) || search->world > jl_atomic_load_relaxed(&ml->max_world))
             continue;
         size_t lensig = jl_nparams(jl_unwrap_unionall((jl_value_t*)ml->sig));
         if (lensig == n || (ml->va && lensig <= n+1)) {
@@ -877,26 +875,7 @@ static jl_typemap_entry_t *jl_typemap_entry_assoc_by_type(
                     }
                 }
                 if (ismatch) {
-                    size_t min_world = jl_atomic_load_relaxed(&ml->min_world);
-                    size_t max_world = jl_atomic_load_relaxed(&ml->max_world);
-                    if (search->world < min_world) {
-                        // ignore method table entries that are part of a later world
-                        if (search->max_valid >= min_world)
-                            search->max_valid = min_world - 1;
-                    }
-                    else if (search->world > max_world) {
-                        // ignore method table entries that have been replaced in the current world
-                        if (search->min_valid <= max_world)
-                            search->min_valid = max_world + 1;
-                    }
-                    else {
-                        // intersect the env valid range with method's valid range
-                        if (search->min_valid < min_world)
-                            search->min_valid = min_world;
-                        if (search->max_valid > max_world)
-                            search->max_valid = max_world;
-                        return ml;
-                    }
+                    return ml;
                 }
             }
             if (resetenv)
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index 2e1d4cd801fd9..29010a52eed91 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -1111,7 +1111,7 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
         end
         if !is_for_opaque_closure
             mt = ccall(:jl_method_table_for, Any, (Any,), sig)
-            if mt !== nothing && nothing === ccall(:jl_methtable_lookup, Any, (Any, Any, UInt), mt, sig, typemax(UInt))
+            if mt !== nothing && nothing === ccall(:jl_methtable_lookup, Any, (Any, Any, UInt), mt, sig, Base.get_world_counter())
                 ccall(:jl_method_table_insert, Cvoid, (Any, Any, Ptr{Cvoid}), mt, meth, C_NULL)
             end
         end
diff --git a/test/compiler/invalidation.jl b/test/compiler/invalidation.jl
index d5e86ca533f05..76cf3cbdc0796 100644
--- a/test/compiler/invalidation.jl
+++ b/test/compiler/invalidation.jl
@@ -142,7 +142,9 @@ begin take!(GLOBAL_BUFFER)
     # this redefinition below should invalidate the cache of `pr48932_callee` but not that of `pr48932_caller`
     pr48932_callee(x) = (print(GLOBAL_BUFFER, x); nothing)
 
-    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee))))
+    @test length(Base.methods(pr48932_callee)) == 2
+    @test Base.only(Base.methods(pr48932_callee, Tuple{Any})) === first(Base.methods(pr48932_callee))
+    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee, Tuple{Any}))))
     let mi = only(Base.specializations(Base.only(Base.methods(pr48932_caller))))
         # Base.method_instance(pr48932_callee, (Any,))
         ci = mi.cache
@@ -206,7 +208,7 @@ begin take!(GLOBAL_BUFFER)
     # this redefinition below should invalidate the cache of `pr48932_callee_inferable` but not that of `pr48932_caller_unuse`
     pr48932_callee_inferable(x) = (print(GLOBAL_BUFFER, "foo"); x)
 
-    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee_inferable))))
+    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee_inferable, Tuple{Any}))))
     let mi = Base.method_instance(pr48932_caller_unuse, (Int,))
         ci = mi.cache
         @test isdefined(ci, :next)
@@ -266,7 +268,7 @@ begin take!(GLOBAL_BUFFER)
     # this redefinition below should invalidate the cache of `pr48932_callee_inlined` but not that of `pr48932_caller_inlined`
     @noinline pr48932_callee_inlined(@nospecialize x) = (print(GLOBAL_BUFFER, x); nothing)
 
-    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee_inlined))))
+    @test isempty(Base.specializations(Base.only(Base.methods(pr48932_callee_inlined, Tuple{Any}))))
     let mi = Base.method_instance(pr48932_caller_inlined, (Int,))
         ci = mi.cache
         @test isdefined(ci, :next)
diff --git a/test/reflection.jl b/test/reflection.jl
index f2444a1cb8658..4a738dd3e58ee 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -474,7 +474,7 @@ fLargeTable() = 4
 fLargeTable(::Union, ::Union) = "a"
 @test fLargeTable(Union{Int, Missing}, Union{Int, Missing}) == "a"
 fLargeTable(::Union, ::Union) = "b"
-@test length(methods(fLargeTable)) == 205
+@test length(methods(fLargeTable)) == 206
 @test fLargeTable(Union{Int, Missing}, Union{Int, Missing}) == "b"
 
 # issue #15280
diff --git a/test/specificity.jl b/test/specificity.jl
index 9b605444bad42..816a59f63e193 100644
--- a/test/specificity.jl
+++ b/test/specificity.jl
@@ -1,9 +1,9 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function args_morespecific(a, b)
-    sp = (ccall(:jl_type_morespecific, Cint, (Any,Any), a, b) != 0)
+    sp = Base.morespecific(a, b)
     if sp  # make sure morespecific(a,b) implies !morespecific(b,a)
-        @test ccall(:jl_type_morespecific, Cint, (Any,Any), b, a) == 0
+        @test !Base.morespecific(b, a)
     end
     return sp
 end
diff --git a/test/worlds.jl b/test/worlds.jl
index 292628b8cbed3..e9d8895fc90d4 100644
--- a/test/worlds.jl
+++ b/test/worlds.jl
@@ -454,3 +454,27 @@ let e = ExceptionUnwrapping.X(nothing)
     @test ExceptionUnwrapping.result == [false, true]
     empty!(ExceptionUnwrapping.result)
 end
+
+fshadow() = 1
+gshadow() = fshadow()
+@test fshadow() === 1
+@test gshadow() === 1
+fshadow_m1 = which(fshadow, ())
+fshadow() = 2
+fshadow() = 3
+@test fshadow() === 3
+@test gshadow() === 3
+fshadow_m3 = which(fshadow, ())
+Base.delete_method(fshadow_m1)
+@test fshadow() === 3
+@test gshadow() === 3
+Base.delete_method(fshadow_m3)
+fshadow_m2 = which(fshadow, ())
+@test fshadow() === 2
+@test gshadow() === 2
+Base.delete_method(fshadow_m2)
+@test_throws MethodError(fshadow, (), Base.tls_world_age()) gshadow()
+@test Base.morespecific(fshadow_m3, fshadow_m2)
+@test Base.morespecific(fshadow_m2, fshadow_m1)
+@test Base.morespecific(fshadow_m3, fshadow_m1)
+@test !Base.morespecific(fshadow_m2, fshadow_m3)

From 98b3f721275082cbf3c1ece9d3ae394ec305e12f Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 27 Feb 2024 06:46:22 +0530
Subject: [PATCH 1021/1315] Fix boundscheck in unsetindex for SubArrays
 (#53475)

These had been copy-pasted incorrectly, and should throw an error if the
indices are out of bounds.
---
 base/subarray.jl | 6 +++---
 test/subarray.jl | 2 ++
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index c15a4d48868fa..2b8545c2cc226 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -412,19 +412,19 @@ end
 
 function _unsetindex!(V::FastSubArray, i::Int)
     @inline
-    @boundscheck checkbounds(Bool, V, i)
+    @boundscheck checkbounds(V, i)
     @inbounds _unsetindex!(V.parent, _reindexlinear(V, i))
     return V
 end
 function _unsetindex!(V::FastSubArray{<:Any,1}, i::Int)
     @inline
-    @boundscheck checkbounds(Bool, V, i)
+    @boundscheck checkbounds(V, i)
     @inbounds _unsetindex!(V.parent, _reindexlinear(V, i))
     return V
 end
 function _unsetindex!(V::SubArray{T,N}, i::Vararg{Int,N}) where {T,N}
     @inline
-    @boundscheck checkbounds(Bool, V, i...)
+    @boundscheck checkbounds(V, i...)
     @inbounds _unsetindex!(V.parent, reindex(V.indices, i)...)
     return V
 end
diff --git a/test/subarray.jl b/test/subarray.jl
index ada53d7d91ee3..31bd69cccb5ae 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -1062,6 +1062,8 @@ end
             for i in eachindex(A)
                 @test !isassigned(A, i)
             end
+            inds = eachindex(A)
+            @test_throws BoundsError Base._unsetindex!(A, last(inds) + oneunit(eltype(inds)))
         end
         @testset "dest IndexLinear, src IndexLinear" begin
             for p in (fill(BigInt(2)), BigInt[1, 2], BigInt[1 2; 3 4])

From 2e9b0bbf4e8301cd186d945117d78f1bbdbc458d Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 26 Feb 2024 21:42:36 -0500
Subject: [PATCH 1022/1315] `rm`: move open DLLs to temp dir to allow dir to be
 deleted (#53456)

---
 base/file.jl    | 40 ++++++++++++++++++++++++++--------------
 base/loading.jl | 45 +++++++++++++++++++++++++--------------------
 2 files changed, 51 insertions(+), 34 deletions(-)

diff --git a/base/file.jl b/base/file.jl
index 6156bafacdc47..157951c6bc5bf 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -249,6 +249,10 @@ function mkpath(path::AbstractString; mode::Integer = 0o777)
     path
 end
 
+# Files that were requested to be deleted but can't be by the current process
+# i.e. loaded DLLs on Windows
+delayed_delete_dir() = joinpath(tempdir(), "julia_delayed_deletes")
+
 """
     rm(path::AbstractString; force::Bool=false, recursive::Bool=false)
 
@@ -270,20 +274,26 @@ Stacktrace:
 [...]
 ```
 """
-function rm(path::AbstractString; force::Bool=false, recursive::Bool=false)
+function rm(path::AbstractString; force::Bool=false, recursive::Bool=false, allow_delayed_delete::Bool=true)
+    # allow_delayed_delete is used by Pkg.gc() but is otherwise not part of the public API
     if islink(path) || !isdir(path)
         try
-            @static if Sys.iswindows()
-                # is writable on windows actually means "is deletable"
-                st = lstat(path)
-                if ispath(st) && (filemode(st) & 0o222) == 0
-                    chmod(path, 0o777)
-                end
-            end
             unlink(path)
         catch err
-            if force && isa(err, IOError) && err.code==Base.UV_ENOENT
-                return
+            if isa(err, IOError)
+                force && err.code==Base.UV_ENOENT && return
+                @static if Sys.iswindows()
+                    if allow_delayed_delete && err.code==Base.UV_EACCES && endswith(path, ".dll")
+                        # Loaded DLLs cannot be deleted on Windows, even with posix delete mode
+                        # but they can be moved. So move out to allow the dir to be deleted
+                        # TODO: Add a mechanism to delete these moved files after dlclose or process exit
+                        dir = mkpath(delayed_delete_dir())
+                        temp_path = tempname(dir, cleanup = false, suffix = string("_", basename(path)))
+                        @debug "Could not delete DLL most likely because it is loaded, moving to tempdir" path temp_path
+                        mv(path, temp_path)
+                        return
+                    end
+                end
             end
             rethrow()
         end
@@ -291,12 +301,14 @@ function rm(path::AbstractString; force::Bool=false, recursive::Bool=false)
         if recursive
             try
                 for p in readdir(path)
-                    rm(joinpath(path, p), force=force, recursive=true)
+                    try
+                        rm(joinpath(path, p), force=force, recursive=true)
+                    catch err
+                        (isa(err, IOError) && err.code==Base.UV_EACCES) || rethrow()
+                    end
                 end
             catch err
-                if !(isa(err, IOError) && err.code==Base.UV_EACCES)
-                    rethrow(err)
-                end
+                (isa(err, IOError) && err.code==Base.UV_EACCES) || rethrow()
             end
         end
         req = Libc.malloc(_sizeof_uv_fs)
diff --git a/base/loading.jl b/base/loading.jl
index 1cff14203b291..e055eb3003c9e 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2902,26 +2902,10 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
             end
 
             if cache_objects
-                try
-                    rename(tmppath_so, ocachefile::String; force=true)
-                catch e
-                    e isa IOError || rethrow()
-                    isfile(ocachefile::String) || rethrow()
-                    # Windows prevents renaming a file that is in use so if there is a Julia session started
-                    # with a package image loaded, we cannot rename that file.
-                    # The code belows append a `_i` to the name of the cache file where `i` is the smallest number such that
-                    # that cache file does not exist.
-                    ocachename, ocacheext = splitext(ocachefile::String)
-                    old_cachefiles = Set(readdir(cachepath))
-                    num = 1
-                    while true
-                        ocachefile = ocachename * "_$num" * ocacheext
-                        in(basename(ocachefile), old_cachefiles) || break
-                        num += 1
-                    end
-                    # TODO: Risk for a race here if some other process grabs this name before us
-                    cachefile = cachefile_from_ocachefile(ocachefile)
-                    rename(tmppath_so, ocachefile::String; force=true)
+                ocachefile_new = rename_unique_ocachefile(tmppath_so, ocachefile)
+                if ocachefile_new != ocachefile
+                    cachefile = cachefile_from_ocachefile(ocachefile_new)
+                    ocachefile = ocachefile_new
                 end
                 @static if Sys.isapple()
                     run(`$(Linking.dsymutil()) $ocachefile`, Base.DevNull(), Base.DevNull(), Base.DevNull())
@@ -2945,6 +2929,27 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
     end
 end
 
+function rename_unique_ocachefile(tmppath_so::String, ocachefile_orig::String, ocachefile::String = ocachefile_orig, num = 0)
+    try
+        rename(tmppath_so, ocachefile; force=true)
+    catch e
+        e isa IOError || rethrow()
+        # If `rm` was called on a dir containing a loaded DLL, we moved it to temp for cleanup
+        # on restart. However the old path cannot be used (UV_EACCES) while the DLL is loaded
+        if !isfile(ocachefile) && e.code != Base.UV_EACCES
+            rethrow()
+        end
+        # Windows prevents renaming a file that is in use so if there is a Julia session started
+        # with a package image loaded, we cannot rename that file.
+        # The code belows append a `_i` to the name of the cache file where `i` is the smallest number such that
+        # that cache file does not exist.
+        ocachename, ocacheext = splitext(ocachefile_orig)
+        ocachefile_unique = ocachename * "_$num" * ocacheext
+        ocachefile = rename_unique_ocachefile(tmppath_so, ocachefile_orig, ocachefile_unique, num + 1)
+    end
+    return ocachefile
+end
+
 function module_build_id(m::Module)
     hi, lo = ccall(:jl_module_build_id, NTuple{2,UInt64}, (Any,), m)
     return (UInt128(hi) << 64) | lo

From 35cb8a556b1efd12b7052e48412590fe67bef3bf Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 27 Feb 2024 15:12:46 +0900
Subject: [PATCH 1023/1315] minor fixes on test/precompile.jl (#53476)

These changes are driven-by fixes I found during investigating into a
more complex issue related to precompilation with external abs int.
---
 test/precompile.jl | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/precompile.jl b/test/precompile.jl
index ce7e9e77217b0..c06145cba8416 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1723,7 +1723,6 @@ let newinterp_path = abspath("compiler/newinterp.jl")
             import SimpleModule: basic_caller, basic_callee
 
             module Custom
-                const CC = Core.Compiler
                 include("$($newinterp_path)")
                 @newinterp PrecompileInterpreter
             end
@@ -1826,7 +1825,7 @@ let newinterp_path = abspath("compiler/newinterp.jl")
             using CustomAbstractInterpreterCaching2
             cache_owner = Core.Compiler.cache_owner(
                 CustomAbstractInterpreterCaching2.Custom.PrecompileInterpreter())
-            let m = only(methods(CustomAbstractInterpreterCaching.basic_callee))
+            let m = only(methods(CustomAbstractInterpreterCaching2.basic_callee))
                 mi = only(Base.specializations(m))
                 ci = mi.cache
                 @test isdefined(ci, :next)

From b3b27360672f87af78e90f43737e32988d9b8be1 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 27 Feb 2024 08:57:49 -0500
Subject: [PATCH 1024/1315] add IR encoding for EnterNode (#53482)

fixes #53248
---
 src/ircode.c    | 10 ++++++++++
 src/serialize.h |  3 ++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/ircode.c b/src/ircode.c
index 90dab5f63d494..a89d0140e0d88 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -322,6 +322,11 @@ static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal)
         jl_encode_value(s, jl_get_nth_field(v, 0));
         jl_encode_value(s, jl_get_nth_field(v, 1));
     }
+    else if (jl_is_enternode(v)) {
+        write_uint8(s->s, TAG_ENTERNODE);
+        jl_encode_value(s, jl_get_nth_field(v, 0));
+        jl_encode_value(s, jl_get_nth_field(v, 1));
+    }
     else if (jl_is_argument(v)) {
         write_uint8(s->s, TAG_ARGUMENT);
         jl_encode_value(s, jl_get_nth_field(v, 0));
@@ -721,6 +726,11 @@ static jl_value_t *jl_decode_value(jl_ircode_state *s) JL_GC_DISABLED
         set_nth_field(jl_gotoifnot_type, v, 0, jl_decode_value(s), 0);
         set_nth_field(jl_gotoifnot_type, v, 1, jl_decode_value(s), 0);
         return v;
+    case TAG_ENTERNODE:
+        v = jl_new_struct_uninit(jl_enternode_type);
+        set_nth_field(jl_enternode_type, v, 0, jl_decode_value(s), 0);
+        set_nth_field(jl_enternode_type, v, 1, jl_decode_value(s), 0);
+        return v;
     case TAG_ARGUMENT:
         v = jl_new_struct_uninit(jl_argument_type);
         set_nth_field(jl_argument_type, v, 0, jl_decode_value(s), 0);
diff --git a/src/serialize.h b/src/serialize.h
index 1bd29e9cc5911..2a91189dce739 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -65,8 +65,9 @@ extern "C" {
 #define TAG_RELOC_METHODROOT   57
 #define TAG_BINDING            58
 #define TAG_MEMORYT            59
+#define TAG_ENTERNODE          60
 
-#define LAST_TAG 59
+#define LAST_TAG 60
 
 #define write_uint8(s, n) ios_putc((n), (s))
 #define read_uint8(s) ((uint8_t)ios_getc((s)))

From c19c68e83ac372ebbe53d21c3c19d61f0dbc7e0a Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Tue, 27 Feb 2024 11:17:15 -0500
Subject: [PATCH 1025/1315] Add error hint for incorrect stacked indexing
 (#40934)

A common entry level mistake is to try to index a matrix with two sets
of brackets, e.g. `a = [1 2; 3 4]; a[1][2] = 5`

This will lead to an error that `setindex!()` on the element type of `a`
is missing.

This PR adds an error hint for the case where a MethodError is raised
when `setindex!` is called with a `Number` as the first argument.

I considered going broader than numbers, but it seems more likely that
this kind of mistake would happen when working with simple number arrays
vs. something more advanced.

Could also consider if it is possible to do the same for when
`getindex()` is called on a `Number`, which emits a BoundsError.

Co-authored-by: Michael Abbott <32575566+mcabbott@users.noreply.github.com>
---
 base/errorshow.jl | 27 +++++++++++++++++++++++++--
 test/errorshow.jl | 18 ++++++++++++++++++
 2 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/base/errorshow.jl b/base/errorshow.jl
index 9236e7da5baa6..1e6a6faaae5df 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -1022,6 +1022,31 @@ end
 
 Experimental.register_error_hint(noncallable_number_hint_handler, MethodError)
 
+# handler for displaying a hint in case the user tries to call setindex! on
+# something that doesn't support it:
+#  - a number (probably attempting to use wrong indexing)
+#    eg: a = [1 2; 3 4]; a[1][2] = 5
+#  - a type (probably tried to initialize without parentheses)
+#    eg: d = Dict; d["key"] = 2
+function nonsetable_type_hint_handler(io, ex, arg_types, kwargs)
+    @nospecialize
+    if ex.f == setindex!
+        T = arg_types[1]
+        if T <: Number
+            print(io, "\nAre you trying to index into an array? For multi-dimensional arrays, separate the indices with commas: ")
+            printstyled(io, "a[1, 2]", color=:cyan)
+            print(io, " rather than a[1][2]")
+        else isType(T)
+            Tx = T.parameters[1]
+            print(io, "\nYou attempted to index the type $Tx, rather than an instance of the type. Make sure you create the type using its constructor: ")
+            printstyled(io, "d = $Tx([...])", color=:cyan)
+            print(io, " rather than d = $Tx")
+        end
+    end
+end
+
+Experimental.register_error_hint(nonsetable_type_hint_handler, MethodError)
+
 # Display a hint in case the user tries to use the + operator on strings
 # (probably attempting concatenation)
 function string_concatenation_hint_handler(io, ex, arg_types, kwargs)
@@ -1035,7 +1060,6 @@ end
 
 Experimental.register_error_hint(string_concatenation_hint_handler, MethodError)
 
-
 # Display a hint in case the user tries to use the min or max function on an iterable
 # or tries to use something like `collect` on an iterator without defining either IteratorSize or length
 function methods_on_iterable(io, ex, arg_types, kwargs)
@@ -1061,7 +1085,6 @@ end
 
 Experimental.register_error_hint(methods_on_iterable, MethodError)
 
-
 # ExceptionStack implementation
 size(s::ExceptionStack) = size(s.stack)
 getindex(s::ExceptionStack, i::Int) = s.stack[i]
diff --git a/test/errorshow.jl b/test/errorshow.jl
index 2b497ed3f5f1b..d03de54aab496 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -9,6 +9,8 @@ include("testenv.jl")
 Base.Experimental.register_error_hint(Base.noncallable_number_hint_handler, MethodError)
 Base.Experimental.register_error_hint(Base.string_concatenation_hint_handler, MethodError)
 Base.Experimental.register_error_hint(Base.methods_on_iterable, MethodError)
+Base.Experimental.register_error_hint(Base.nonsetable_type_hint_handler, MethodError)
+
 
 @testset "SystemError" begin
     err = try; systemerror("reason", Cint(0)); false; catch ex; ex; end::SystemError
@@ -745,6 +747,22 @@ let err_str
     @test count(==("Maybe you forgot to use an operator such as *, ^, %, / etc. ?"), split(err_str, '\n')) == 1
 end
 
+let err_str
+    a = [1 2; 3 4];
+    err_str = @except_str (a[1][2] = 5) MethodError
+    @test occursin("\nAre you trying to index into an array? For multi-dimensional arrays, separate the indices with commas: ", err_str)
+    @test occursin("a[1, 2]", err_str)
+    @test occursin("rather than a[1][2]", err_str)
+end
+
+let err_str
+    d = Dict
+    err_str = @except_str (d[1] = 5) MethodError
+    @test occursin("\nYou attempted to index the type Dict, rather than an instance of the type. Make sure you create the type using its constructor: ", err_str)
+    @test occursin("d = Dict([...])", err_str)
+    @test occursin(" rather than d = Dict", err_str)
+end
+
 # Execute backtrace once before checking formatting, see #38858
 backtrace()
 

From 2b79326037ac4092733b8eb091d94f0c41bc92a2 Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Tue, 27 Feb 2024 12:22:16 -0500
Subject: [PATCH 1026/1315] Move the list of Base's `public` names from
 `base/exports.jl` to `base/public.jl` (#53487)

---
 base/Base.jl    |   1 +
 base/exports.jl | 100 -----------------------------------------------
 base/public.jl  | 101 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 102 insertions(+), 100 deletions(-)
 create mode 100644 base/public.jl

diff --git a/base/Base.jl b/base/Base.jl
index e02b132aae6e4..30bc0b91411b8 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -137,6 +137,7 @@ if isdefined(Core, :Compiler)
 end
 
 include("exports.jl")
+include("public.jl")
 
 if false
     # simple print definitions for debugging. enable these if something
diff --git a/base/exports.jl b/base/exports.jl
index a31ea1b0fa842..7f3ad451bcc83 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -1078,103 +1078,3 @@ export
     @static,
 
     @main
-
-public
-# Modules
-    Checked,
-    Filesystem,
-    Order,
-    Sort,
-
-# Types
-    AbstractLock,
-    AsyncCondition,
-    CodeUnits,
-    Event,
-    Fix1,
-    Fix2,
-    Generator,
-    ImmutableDict,
-    OneTo,
-    LogRange,
-    AnnotatedString,
-    AnnotatedChar,
-    UUID,
-
-# Annotated strings
-    annotatedstring,
-    annotate!,
-    annotations,
-
-# Semaphores
-    Semaphore,
-    acquire,
-    release,
-
-# collections
-    IteratorEltype,
-    IteratorSize,
-    to_index,
-    vect,
-    isdone,
-    front,
-    rest,
-    split_rest,
-    tail,
-    checked_length,
-
-# Loading
-    DL_LOAD_PATH,
-    load_path,
-    active_project,
-
-# Reflection and introspection
-    isambiguous,
-    isexpr,
-    isidentifier,
-    issingletontype,
-    identify_package,
-    locate_package,
-    moduleroot,
-    jit_total_bytes,
-    summarysize,
-    isexported,
-    ispublic,
-    remove_linenums!,
-
-# Opperators
-    operator_associativity,
-    operator_precedence,
-    isbinaryoperator,
-    isoperator,
-    isunaryoperator,
-
-# C interface
-    cconvert,
-    unsafe_convert,
-
-# Error handling
-    exit_on_sigint,
-    windowserror,
-
-# Macros
-    @assume_effects,
-    @constprop,
-    @locals,
-    @propagate_inbounds,
-
-# IO
-    # types
-    BufferStream,
-    IOServer,
-    OS_HANDLE,
-    PipeEndpoint,
-    TTY,
-    # functions
-    reseteof,
-    link_pipe!,
-
-# misc
-    notnothing,
-    runtests,
-    text_colors
diff --git a/base/public.jl b/base/public.jl
new file mode 100644
index 0000000000000..912953795c801
--- /dev/null
+++ b/base/public.jl
@@ -0,0 +1,101 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+public
+# Modules
+    Checked,
+    Filesystem,
+    Order,
+    Sort,
+
+# Types
+    AbstractLock,
+    AsyncCondition,
+    CodeUnits,
+    Event,
+    Fix1,
+    Fix2,
+    Generator,
+    ImmutableDict,
+    OneTo,
+    LogRange,
+    AnnotatedString,
+    AnnotatedChar,
+    UUID,
+
+# Annotated strings
+    annotatedstring,
+    annotate!,
+    annotations,
+
+# Semaphores
+    Semaphore,
+    acquire,
+    release,
+
+# collections
+    IteratorEltype,
+    IteratorSize,
+    to_index,
+    vect,
+    isdone,
+    front,
+    rest,
+    split_rest,
+    tail,
+    checked_length,
+
+# Loading
+    DL_LOAD_PATH,
+    load_path,
+    active_project,
+
+# Reflection and introspection
+    isambiguous,
+    isexpr,
+    isidentifier,
+    issingletontype,
+    identify_package,
+    locate_package,
+    moduleroot,
+    jit_total_bytes,
+    summarysize,
+    isexported,
+    ispublic,
+    remove_linenums!,
+
+# Opperators
+    operator_associativity,
+    operator_precedence,
+    isbinaryoperator,
+    isoperator,
+    isunaryoperator,
+
+# C interface
+    cconvert,
+    unsafe_convert,
+
+# Error handling
+    exit_on_sigint,
+    windowserror,
+
+# Macros
+    @assume_effects,
+    @constprop,
+    @locals,
+    @propagate_inbounds,
+
+# IO
+    # types
+    BufferStream,
+    IOServer,
+    OS_HANDLE,
+    PipeEndpoint,
+    TTY,
+    # functions
+    reseteof,
+    link_pipe!,
+
+# misc
+    notnothing,
+    runtests,
+    text_colors

From b18a62d624d4be2f0b30f6d7245a01bdc7c13d09 Mon Sep 17 00:00:00 2001
From: pyfagorass <Pyfagorass@users.noreply.github.com>
Date: Tue, 27 Feb 2024 21:54:46 +0200
Subject: [PATCH 1027/1315] Fix formatting & typo in methods.md (#53486)

* Fixed what I suspect is a typo: commonly -> common
* Added code quotes to eltype: eltype -> `eltype`

Sentence now reads:
Instead, common code will dispatch first on the container type, then
recurse down to a more specific method based on `eltype`.
---
 doc/src/manual/methods.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/methods.md b/doc/src/manual/methods.md
index 6b90990a6dd7c..810f81f3e9c8f 100644
--- a/doc/src/manual/methods.md
+++ b/doc/src/manual/methods.md
@@ -745,8 +745,8 @@ often it is best to separate each level of dispatch into distinct functions.
 This may sound similar in approach to single-dispatch, but as we shall see below, it is still more flexible.
 
 For example, trying to dispatch on the element-type of an array will often run into ambiguous situations.
-Instead, commonly code will dispatch first on the container type,
-then recurse down to a more specific method based on eltype.
+Instead, common code will dispatch first on the container type,
+then recurse down to a more specific method based on `eltype`.
 In most cases, the algorithms lend themselves conveniently to this hierarchical approach,
 while in other cases, this rigor must be resolved manually.
 This dispatching branching can be observed, for example, in the logic to sum two matrices:

From c379db77135e55b71707704f58d901e78924804d Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Tue, 27 Feb 2024 17:33:57 -0500
Subject: [PATCH 1028/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=2076070d295=20to=201f16df404=20(#53495)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 base/file.jl                                                  | 4 ++--
 .../Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5   | 1 +
 .../sha512                                                    | 1 +
 .../Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5   | 1 -
 .../sha512                                                    | 1 -
 stdlib/Pkg.version                                            | 2 +-
 6 files changed, 5 insertions(+), 5 deletions(-)
 create mode 100644 deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512

diff --git a/base/file.jl b/base/file.jl
index 157951c6bc5bf..6c4f7bc5fb8f3 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -285,8 +285,8 @@ function rm(path::AbstractString; force::Bool=false, recursive::Bool=false, allo
                 @static if Sys.iswindows()
                     if allow_delayed_delete && err.code==Base.UV_EACCES && endswith(path, ".dll")
                         # Loaded DLLs cannot be deleted on Windows, even with posix delete mode
-                        # but they can be moved. So move out to allow the dir to be deleted
-                        # TODO: Add a mechanism to delete these moved files after dlclose or process exit
+                        # but they can be moved. So move out to allow the dir to be deleted.
+                        # Pkg.gc() cleans up this dir when possible
                         dir = mkpath(delayed_delete_dir())
                         temp_path = tempname(dir, cleanup = false, suffix = string("_", basename(path)))
                         @debug "Could not delete DLL most likely because it is loaded, moving to tempdir" path temp_path
diff --git a/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5 b/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5
new file mode 100644
index 0000000000000..6313b4844bd73
--- /dev/null
+++ b/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5
@@ -0,0 +1 @@
+c8077b74f0e37e3939f74367d9ab55cd
diff --git a/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512 b/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512
new file mode 100644
index 0000000000000..42b796b4264db
--- /dev/null
+++ b/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512
@@ -0,0 +1 @@
+d52830b86bb89d5831768214a4b1b0cc272a810d82f8fdcbf0ccad85085c999c626e75483f443f3d3db6cc29f6fe1bba17c33ef3fffceb5fbcc1e2909b0517cc
diff --git a/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5 b/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5
deleted file mode 100644
index 279472ca7aa3d..0000000000000
--- a/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-777fe3e3dd5b6c7c1b436d3077d91c13
diff --git a/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512 b/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512
deleted file mode 100644
index 5e26fbd8577fa..0000000000000
--- a/deps/checksums/Pkg-76070d295fc4a1f27f852e05400bbc956962e084.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-b832093b4e387460a1d96526169e12c6ee2ff5a8bd1961c362dbcf4f4839790f3a0bdcf1d0e1524b77eea662cc7590483fc7e4e674f94f5e7f291970778ab128
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 048b652a0a272..532edda44cd99 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 76070d295fc4a1f27f852e05400bbc956962e084
+PKG_SHA1 = 1f16df404a2fbe8642ea3eecc9f4d7064c400a73
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 71f68b4ce9189e64f320631f3f74ffb3dd10e875 Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Wed, 28 Feb 2024 06:46:20 +0100
Subject: [PATCH 1029/1315] Avoid compiler warning about redefining
 jl_globalref_t (#53499)

---
 src/julia.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/julia.h b/src/julia.h
index a7e0c1b2db17b..5c3a983367470 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -645,11 +645,11 @@ typedef struct _jl_module_t {
     intptr_t hash;
 } jl_module_t;
 
-typedef struct _jl_globalref_t {
+struct _jl_globalref_t {
     jl_module_t *mod;
     jl_sym_t *name;
     jl_binding_t *binding;
-} jl_globalref_t;
+};
 
 // one Type-to-Value entry
 typedef struct _jl_typemap_entry_t {

From c80a9647166d59782eff6be8c75a5052e17483d7 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 29 Feb 2024 07:34:54 +0900
Subject: [PATCH 1030/1315] update staled `Core.Compiler.Effects` documentation
 (#53507)

---
 base/compiler/effects.jl | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/base/compiler/effects.jl b/base/compiler/effects.jl
index a864925b23eb1..a3d30baef9efa 100644
--- a/base/compiler/effects.jl
+++ b/base/compiler/effects.jl
@@ -43,15 +43,16 @@ following meanings:
     except that it may access or modify mutable memory pointed to by its call arguments.
     This may later be refined to `ALWAYS_TRUE` in a case when call arguments are known to be immutable.
     This state corresponds to LLVM's `inaccessiblemem_or_argmemonly` function attribute.
-- `noub::Bool`: indicates that the method will not execute any undefined behavior (for any input).
+- `noub::UInt8`: indicates that the method will not execute any undefined behavior (for any input).
   Note that undefined behavior may technically cause the method to violate any other effect
   assertions (such as `:consistent` or `:effect_free`) as well, but we do not model this,
   and they assume the absence of undefined behavior.
+  * `ALWAYS_TRUE`: this method is guaranteed to not execute any undefined behavior.
+  * `ALWAYS_FALSE`: this method may execute undefined behavior.
+  * `NOUB_IF_NOINBOUNDS`: this method is guaranteed to not execute any undefined behavior
+    if the caller does not set nor propagate the `@inbounds` context.
 - `nonoverlayed::Bool`: indicates that any methods that may be called within this method
   are not defined in an [overlayed method table](@ref OverlayMethodTable).
-- `noinbounds::Bool`: If set, indicates that this method does not read the parent's `:inbounds`
-  state. In particular, it does not have any reached `:boundscheck` exprs, not propagates inbounds
-  to any children that do.
 
 Note that the representations above are just internal implementation details and thus likely
 to change in the future. See [`Base.@assume_effects`](@ref) for more detailed explanation
@@ -92,9 +93,7 @@ The output represents the state of different effect properties in the following
 7. `noub` (`u`):
     - `+u` (green): `true`
     - `-u` (red): `false`
-8. `noinbounds` (`i`):
-    - `+i` (green): `true`
-    - `-i` (red): `false`
+    - `?u` (yellow): `NOUB_IF_NOINBOUNDS`
 
 Additionally, if the `nonoverlayed` property is false, a red prime symbol (′) is displayed after the tuple.
 """

From 77c06727559c3dbb87e5fde46cec87ce59ba61c8 Mon Sep 17 00:00:00 2001
From: Stefan Karpinski <stefan@karpinski.org>
Date: Wed, 28 Feb 2024 18:06:12 -0500
Subject: [PATCH 1031/1315] task splitting: change additive accumulation to
 multiplicative (#53408)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Issue raised
[here](https://discourse.julialang.org/t/linear-relationship-between-xoshiro-tasks/110454).
Given this definition, look at output values:
```jl
using .Threads

macro fetch(ex) :(fetch(@spawn($(esc(ex))))) end

function taskCorrelatedXoshiros(+ = +)
    r11, r10 = @fetch (@fetch(rand(UInt64)), rand(UInt64))
    r01, r00 = (@fetch(rand(UInt64)), rand(UInt64))
    r01 + r10 - (r00 + r11)
end
```
Before:
```jl
julia> sort!(unique(taskCorrelatedXoshiros() for _ = 1:1000))
9-element Vector{UInt64}:
 0x0000000000000000
 0x0000000000000001
 0x00000000007fffff
 0x0000000000800000
 0x0000000000800001
 0xffffffffff7fffff
 0xffffffffff800000
 0xffffffffff800001
 0xffffffffffffffff
```
After:
```jl
julia> sort!(unique(taskCorrelatedXoshiros() for _ = 1:1000))
1000-element Vector{UInt64}:
 0x000420647a085960
 0x0038c5b889b585c6
 0x007b29fae8107ff7
 0x00e73b9e883ac1c8
                  ⋮
 0xfe68be9c0dde1e88
 0xfeca042354218c35
 0xfeeb8203e470c96b
 0xfff5dbb8771307b9

julia> sort!(unique(taskCorrelatedXoshiros(*) for _ = 1:1000))
1000-element Vector{UInt64}:
 0x00126f951c1e56dc
 0x0025a82477ffac08
 0x002dd82c9986457a
 0x00a713c4d56a3dbc
                  ⋮
 0xfe2e40a5b345095e
 0xfe77b90881967436
 0xfea2559be63f1701
 0xff88b5b28cefac5f
```
---
 src/task.c | 341 ++++++++++++++++++++++-------------------------------
 1 file changed, 143 insertions(+), 198 deletions(-)

diff --git a/src/task.c b/src/task.c
index a1e8dabb89f9d..7c8770530c326 100644
--- a/src/task.c
+++ b/src/task.c
@@ -856,202 +856,143 @@ guaranteed to avoid collisions between the RNG streams of all tasks. The main
 RNG is the xoshiro256++ RNG whose state is stored in rngState[0..3]. There is
 also a small internal RNG used for task forking stored in rngState[4]. This
 state is used to iterate a linear congruential generator (LCG), which is then
-put through four different variations of the strongest PCG output function,
-referred to as PCG-RXS-M-XS-64 [1]. This output function is invertible: it maps
-a 64-bit state to 64-bit output. This is one of the reasons it's not recommended
-for general purpose RNGs unless space is at an absolute premium, but in our
-usage invertibility is actually a benefit (as is explained below) and adding as
-little additional memory overhead to each task object as possible is preferred.
+combined with xoshiro256's state and put through four different variations of
+the strongest PCG output function, referred to as PCG-RXS-M-XS-64 [1].
 
 The goal of jl_rng_split is to perturb the state of each child task's RNG in
-such a way each that for an entire tree of tasks spawned starting with a given
-state in a root task, no two tasks have the same RNG state. Moreover, we want to
-do this in a way that is deterministic and repeatable based on (1) the root
-task's seed, (2) how many random numbers are generated, and (3) the task tree
-structure. The RNG state of a parent task is allowed to affect the initial RNG
-state of a child task, but the mere fact that a child was spawned should not
-alter the RNG output of the parent. This second requirement rules out using the
-main RNG to seed children: if we use the main RNG, we either advance it, which
-affects the parent's RNG stream or, if we don't advance it, then every child
-would have an identical RNG stream. Therefore some separate state must be
-maintained and changed upon forking a child task while leaving the main RNG
-state unchanged.
-
-The basic approach is that used by the DotMix [2] and SplitMix [3] RNG systems:
-each task is uniquely identified by a sequence of "pedigree" numbers, indicating
-where in the task tree it was spawned. This vector of pedigree coordinates is
-then reduced to a single value by computing a dot product with a shared vector
-of random weights. The weights are common but each pedigree of each task is
-distinct, so the dot product of each task is unlikely to be the same. The DotMix
-paper provides a proof that this dot product hash value (referred to as a
-"compression function") is collision resistant in the sense that the pairwise
-collision probability of two distinct tasks is 1/N where N is the number of
-possible weight values. Both DotMix and SplitMix use a prime value of N because
-the proof requires that the difference between two distinct pedigree coordinates
-have a multiplicative inverse, which is guaranteed by N being prime since all
-values are invertible then. We take a somewhat different approach: instead of
-assigning n-ary pedigree coordinates, we assign binary tree coordinates to
-tasks, which means that our pedigree vectors have only 0/1 and differences
-between them can only be -1, 0 or 1. Since the only possible non-zero coordinate
-differences are ±1 which are invertible regardless of the modulus, we can use a
-modulus of 2^64, which is far easier and more efficient then using a prime
-modulus. It also means that when accumulating the dot product incrementally, as
-described in SplitMix, we don't need to multiply weights by anything, we simply
-add the random weight for the current task tree depth to the parent's dot
-product to derive the child's dot product.
-
-we instead limit pedigree coordinates to being binary, guaranteeing
-invertibility regardless of modulus. When a task spawns a child, the parent and
-child share the parent's previous pedigree prefix and the parent appends a zero
-to its coordinates, which doesn't affect the task's dot product value, while the
-child appends a one, which does produce a new dot product. In this manner a
-binary pedigree vector uniquely identifies each task and since the coordinates
-are binary, the difference between coordinates is always invertible: 1 and -1
-are their own multiplicative inverses regardless of the modulus.
-
-How does our assignment of pedigree coordinates to tasks differ from DotMix and
-SplitMix? In DotMix and SplitMix, each task has a fixed pedigree vector that
-never changes. The root tasks's pedigree is `()`, its first child's pedigree is
-`(0,)`, its second child's pedigree is `(2,)` and so on. The length of a task's
-pedigree tuple corresponds to how many ancestors tasks it has. Our approach
-instead appends 0 to the parent's pedigree when it forks a child and appends 1
-to the child's pedigree at the same time. The root task starts with a pedigree
-of `()` as before, but when it spawns a child, we update its pedigree to `(0,)`
-and give its child a pedigree of `(1,)`. When the root task then spawns a second
-child, we update its pedigree to `(0,0)` and give it's second child a pedigree
-of `(0,1)`. If the first child spawns a grandchild, the child's pedigree is
-changed from `(1,)` to `(1,0)` and the grandchild is assigned a pedigree of
-`(1,1)`. In other words, DotMix and SplitMix build an n-ary tree where every
-node is a task: parent nodes are higher up the tree and child tasks are children
-in the pedigree tree. Our approach is to build a binary tree where only leaves
-are tasks and each task spawn replaces a leaf in the tree with two leaves: the
-parent moves to the left/zero leaf while the child is the right/one leaf. Since
-the tree is binary, the pedigree coordinates are binary.
-
-It may seem odd for a task's pedigree coordinates to change, but note that we
-only ever append zeros to a task's pedigree, which does not change its dot
-product. So while the pedigree changes, the dot product is fixed. What purpose
-does appending zeros like this serve if the task's dot product doesn't change?
-Changing the pedigree length (which is also the binary tree depth) ensures that
-the next child spawned by that task will have new and different dot product from
-the previous child since it will have a different pseudo-random weight added to
-the parent's dot product value. Whereas the pedigree length in DotMix and
-SplitMix is unchanging and corresponds to how many ancestors a task has, in our
-scheme the pedigree length corresponds to the number of ancestors *plus*
-children a task has, which increases every time it spawns another child.
-
-We use the LCG in rngState[4] to generate pseudorandom weights for the dot
-product. Each time a child is forked, we update the LCG in both parent and child
-tasks. In the parent, that's all we have to do -- the main RNG state remains
-unchanged. (Recall that spawning a child should *not* affect subsequent RNG
-draws in the parent). The next time the parent forks a child, the dot product
-weight used will be different, corresponding to being a level deeper in the
-pedigree tree. In the child, we use the LCG state to generate four pseudorandom
-64-bit weights (more below) and add each weight to one of the xoshiro256 state
-registers, rngState[0..3]. If we assume the main RNG remains unused in all
-tasks, then each register rngState[0..3] accumulates a different dot product
-hash as additional child tasks are spawned. Each one is collision resistant with
-a pairwise collision chance of only 1/2^64. Assuming that the four pseudorandom
-64-bit weight streams are sufficiently independent, the pairwise collision
-probability for distinct tasks is 1/2^256. If we somehow managed to spawn a
-trillion tasks, the probability of a collision would be on the order of 1/10^54.
-In other words, practically impossible. Put another way, this is the same as the
-probability of two SHA256 hash values accidentally colliding, which we generally
-consider so unlikely as not to be worth worrying about.
-
-What about the random "junk" that's in the xoshiro256 state registers from
-normal use of the RNG? For a tree of tasks spawned with no intervening samples
-taken from the main RNG, all tasks start with the same junk which doesn't affect
-the chance of collision. The Dot/SplitMix papers even suggest adding a random
-base value to the dot product, so we can consider whatever happens to be in the
-xoshiro256 registers to be that. What if the main RNG gets used between task
-forks? In that case, the initial state registers will be different. The DotMix
-collision resistance proof doesn't apply without modification, but we can
-generalize the setup by adding a different base constant to each compression
-function and observe that we still have a 1/N chance of the weight value
-matching that exact difference. This proves collision resistance even between
-tasks whose dot product hashes are computed with arbitrary offsets. We can
-conclude that this scheme provides collision resistance even in the face of
-different starting states of the main RNG. Does this seem too good to be true?
-Perhaps another way of thinking about it will help. Suppose we seeded each task
-completely randomly. Then there would also be a 1/2^256 chance of collision,
-just as the DotMix proof gives. Essentially what the proof is telling us is that
-if the weights are chosen uniformly and uncorrelated with the rest of the
-compression function, then the dot product construction is a good enough way to
-pseudorandomly seed each task based on its parent's RNG state and where in the
-task tree it lives. From that perspective, all we need to believe is that the
-dot product construction is random enough (assuming the weights are), and it
-becomes easier to believe that adding an arbitrary constant to each dot product
-value doesn't make its randomness any worse.
-
-This leaves us with the question of how to generate four pseudorandom weights to
-add to the rngState[0..3] registers at each depth of the task tree. The scheme
-used here is that a single 64-bit LCG state is iterated in both parent and child
-at each task fork, and four different variations of the PCG-RXS-M-XS-64 output
-function are applied to that state to generate four different pseudorandom
-weights. Another obvious way to generate four weights would be to iterate the
-LCG four times per task split. There are two main reasons we've chosen to use
-four output variants instead:
-
-1. Advancing four times per fork reduces the set of possible weights that each
-   register can be perturbed by from 2^64 to 2^60. Since collision resistance is
-   proportional to the number of possible weight values, that would reduce
-   collision resistance. While it would still be strong engough, why reduce it?
-
-2. It's easier to compute four PCG output variants in parallel. Iterating the
-   LCG is inherently sequential. PCG variants can be computed independently. All
-   four can even be computed at once with SIMD vector instructions. The C
-   compiler doesn't currently choose to do that transformation, but it could.
-
-A key question is whether the approach of using four variations of PCG-RXS-M-XS
-is sufficiently random both within and between streams to provide the collision
-resistance we expect. We obviously can't test that with 256 bits, but we have
-tested it with a reduced state analogue using four PCG-RXS-M-XS-8 output
-variations applied to a common 8-bit LCG. Test results do indicate sufficient
-independence: a single register has collisions at 2^5 while four registers only
-start having collisions at 2^20. This is actually better scaling of collision
-resistance than we theoretically expect. In theory, with one byte of resistance
-we have a 50% chance of some collision at 20 tasks, which matches what we see,
-but four bytes should give a 50% chance of collision at 2^17 tasks and our
-reduced size analogue construction remains collision free at 2^19 tasks. This
-may be due to the next observation, which is that the way we generate
-pseudorandom weights actually guarantees collision avoidance in many common
-situations rather than merely providing collision resistance and thus is better
-than true randomness.
-
-In the specific case where a parent task spawns a sequence of child tasks with
-no intervening usage of its main RNG, the parent and child tasks are actually
-_guaranteed_ to have different RNG states. This is true because the four PCG
-streams each produce every possible 2^64 bit output exactly once in the full
-2^64 period of the LCG generator. This is considered a weakness of PCG-RXS-M-XS
-when used as a general purpose RNG, but is quite beneficial in this application.
-Since each of up to 2^64 children will be perturbed by different weights, they
-cannot have hash collisions. What about parent colliding with child? That can
-only happen if all four main RNG registers are perturbed by exactly zero. This
-seems unlikely, but could it occur? Consider the core of the output function:
-
-    p ^= p >> ((p >> 59) + 5);
-    p *= m[i];
-    p ^= p >> 43
-
-It's easy to check that this maps zero to zero. An unchanged parent RNG can only
-happen if all four `p` values are zero at the end of this, which implies that
-they were all zero at the beginning. However, that is impossible since the four
-`p` values differ from `x` by different additive constants, so they cannot all
-be zero. Stated more generally, this non-collision property: assuming the main
-RNG isn't used between task forks, sibling and parent tasks cannot have RNG
-collisions. If the task tree structure is more deeply nested or if there are
-intervening uses of the main RNG, we're back to relying on "merely" 256 bits of
-collision resistance, but it's nice to know that in what is likely the most
-common case, RNG collisions are actually impossible. This fact may also explain
-better-than-theoretical collision resistance observed in our experiment with a
-reduced size analogue of our hashing system.
+such a way that for an entire tree of tasks spawned starting with a given root
+task state, no two tasks have the same RNG state. Moreover, we want to do this
+in a way that is deterministic and repeatable based on (1) the root task's seed,
+(2) how many random numbers are generated, and (3) the task tree structure. The
+RNG state of a parent task is allowed to affect the initial RNG state of a child
+task, but the mere fact that a child was spawned should not alter the RNG output
+of the parent. This second requirement rules out using the main RNG to seed
+children: if we use the main RNG, we either advance it, which affects the
+parent's RNG stream or, if we don't advance it, then every child would have an
+identical RNG stream. Therefore some separate state must be maintained and
+changed upon forking a child task while leaving the main RNG state unchanged.
+
+The basic approach is a generalization and simplification of that used in the
+DotMix [2] and SplitMix [3] RNG systems: each task is uniquely identified by a
+sequence of "pedigree" numbers, indicating where in the task tree it was
+spawned. This vector of pedigree coordinates is then reduced to a single value
+by computing a "dot product" with a shared vector of random weights. I write
+"dot product" in quotes because what we use is not an actual dot product. The
+linear dot product construction used in both DotMix and SplitMix was found by
+@foobar_iv2 [4] to allow easy construction of linear relationships between the
+main RNG states of tasks, which was in turn reflected in observable linear
+relationships between the outputs of their RNGs. This relationship was between a
+minimum of four tasks, so doesn't constitute a collision, per se, but is clearly
+undesirable and highlights a hazard of the plain dot product construction.
+
+As in DotMix and SplitMix, each task is assigned unique task "pedigree"
+coordinates. Our pedigree construction is a bit different and uses only binary
+coordinates rather than arbitrary integers. Each pedigree is an infinite
+sequence of ones and zeros with only finitely many ones. Each task has a "fork
+index": the root task has index 0; the fork index of a task the jth child task
+of a parent task with fork index i is i+j. The root task's coordinates are all
+zeros; each child task's coordinates are the same as its parents except at its
+fork index, where the parent has a zero while the child has a one. A task's
+coordinates after its fork index are all zeros. The coordinates of a tasks
+ancestors are all prefixes of its own coordinates, padded with zeros.
+
+Also as in DotMix and SplitMix, we generate a sequence of pseudorandom weights
+to combine with the coordinates of each task. This sequence is common across all
+tasks, and different mix values for each task derive from their coordinates
+being different. In DotMix and SplitMix, this is a literal dot product: the
+pseudorandom weights are multiplied by corresponding task coordinate and added
+up. While this does provably make collisions as unlikely as randomly assigned
+task seeds, this linear construction can be used to create linearly correlated
+states between tasks. However, it turns out that the compression construction
+need not be linear, commutative, associative, etc. which allows us to avoid any
+linear or other obvious correlations between related sets of tasks.
+
+To generalize SplitMix's optimized dot product construction, we similarly
+compute each task's compression function value incrementally by combining the
+parent's compression value with pseudorandom weight corresponding with the
+child's fork index. Formally, if the parent's compression value is c then we can
+compute the child's compression value as c′ = f(c, wᵢ) where w is the vector of
+pseudorandom weights. What is f? It can be any function that is bijective in
+each argument for all values of the other argument:
+
+    * For all c: w ↦ f(c, w) is bijective
+    * For all w: c ↦ f(c, w) is bijective
+
+The proof that these requirements are sufficient to ensure collision resistance
+is in the linked discussion [4]. DotMix/SplitMix are a special case where f is
+just addition. Instead we use a much less simple mixing function:
+
+    1. We use (2c+1)(2w+1)÷2 % 2^64 to mix the bits of c and w
+    2. We then apply the PCG-RXS-M-XS-64 output function
+
+The first step thoroughly mixes the bits of the previous compression value and
+the pseudorandom weight value using multiplication, which is non-commutative
+with xoshiro's operations (xor, shift, rotate). This mixing function is a
+bijection on each argument witnessed by these inverses:
+
+    * c′ ↦ (2c′+1)(2w+1)⁻¹÷2 % 2^64
+    * w′ ↦ (2c+1)⁻¹(2w′+1)÷2 % 2^64
+
+The second PCG output step is a bijection and designed to be significantly
+non-linear -- non-linear enough to mask the linearity of the LCG that drives the
+PCG-RXS-M-XS-64 RNG and allows it to pass statistical RNG test suites despite
+having the same size state and output. In particular, since this mixing function
+is highly non-associative and non-linear, we (hopefully) don't have any
+discernible relationship between these values:
+
+    * c₀₀ = c
+    * c₁₀ = f(c, wᵢ)
+    * c₀₁ = f(c, wⱼ)
+    * c₁₁ = f(f(c, wᵢ), wⱼ)
+
+When f is simply `+` then these have a very obvious relationship:
+
+    c₀₀ + c₁₁ == c₁₀ + c₀₁
+
+This relationship holds regardless of what wᵢ and wⱼ are and is precisely what
+allows easy creation of correlated tasks with the DotMix/SplitMix construction
+that we previously used. Expressing any relationship between these values with
+our mixing function would require inverting the PCG output function (doable but
+non-trivial), knowing the weights wᵢ and wⱼ, and then applying the inversion
+functions for those weights appropriately. Since the weights are pseudo-randomly
+generated and not directly observable, this is infeasible.
+
+We maintain an LCG in rngState[4] to generate pseudorandom weights. An LCG by
+itself is a very bad RNG, but we combine this one with xoshiro256 state
+registers in a non-trivial way and then apply the PCG-RXS-M-XS-64 output
+function to that. Even if the xoshiro256 states are all zeros, which they should
+never be, the output would be the same as PCG-RXS-M-XS-64, which is a solid
+statistical RNG.
+
+Each time a child is forked, we update the LCG in both parent and child tasks,
+corresponding to increasing the fork index. In the parent, that's all we have to
+do -- the main RNG state remains unchanged. Recall that spawning a child should
+*not* affect subsequent RNG draws in the parent. The next time the parent forks
+a child, the mixing weight used will be different. In the child, we use the LCG
+state to perturb the child's main RNG state registers, rngState[0..3].
+
+Since we want these registers to behave independently, we use four different
+variations on f to mix the LCG state with each of the four main RNG registers.
+Each variation first xors the LCG state with a different random constant before
+combining that value above with the old register state via multiplication; the
+PCG-RXS-M-XS-64 output function is then applied to that mixed state, with a
+different multiplier constant for each variation / register index. Xor is used
+in the first step since we multiply the result with the state immediately after
+and multiplication distributes over `+` and commutes with `*`, which makes both
+options suspect; multiplication doesn't distribute over or commute with xor. We
+also use a different odd multiplier in PCG-RXS-M-XS-64 for each RNG register.
+These three sources of variation (different xor constants, different xoshiro256
+state, different PCG multipliers) are sufficient for each of the four outputs to
+behave statistically independently.
 
 [1]: https://www.pcg-random.org/pdf/hmc-cs-2014-0905.pdf
 
 [2]: http://supertech.csail.mit.edu/papers/dprng.pdf
 
 [3]: https://gee.cs.oswego.edu/dl/papers/oopsla14.pdf
+
+[4]:
+https://discourse.julialang.org/t/linear-relationship-between-xoshiro-tasks/110454
 */
 void jl_rng_split(uint64_t dst[JL_RNG_SIZE], uint64_t src[JL_RNG_SIZE]) JL_NOTSAFEPOINT
 {
@@ -1060,26 +1001,30 @@ void jl_rng_split(uint64_t dst[JL_RNG_SIZE], uint64_t src[JL_RNG_SIZE]) JL_NOTSA
     src[4] = dst[4] = x * 0xd1342543de82ef95 + 1;
     // high spectrum multiplier from https://arxiv.org/abs/2001.05304
 
+    // random xor constants
     static const uint64_t a[4] = {
-        0xe5f8fa077b92a8a8, // random additive offsets...
-        0x7a0cd918958c124d,
-        0x86222f7d388588d4,
-        0xd30cbd35f2b64f52
+        0x214c146c88e47cb7,
+        0xa66d8cc21285aafa,
+        0x68c7ef2d7b1a54d4,
+        0xb053a7d7aa238c61
     };
+    // random odd multipliers
     static const uint64_t m[4] = {
         0xaef17502108ef2d9, // standard PCG multiplier
-        0xf34026eeb86766af, // random odd multipliers...
+        0xf34026eeb86766af,
         0x38fd70ad58dd9fbb,
         0x6677f9b93ab0c04d
     };
 
     // PCG-RXS-M-XS-64 output with four variants
     for (int i = 0; i < 4; i++) {
-        uint64_t p = x + a[i];
-        p ^= p >> ((p >> 59) + 5);
-        p *= m[i];
-        p ^= p >> 43;
-        dst[i] = src[i] + p; // SplitMix dot product
+        uint64_t c = src[i];
+        uint64_t w = x ^ a[i];
+        c += w*(2*c + 1); // c = (2c+1)(2w+1)÷2 % 2^64 (double bijection)
+        c ^= c >> ((c >> 59) + 5);
+        c *= m[i];
+        c ^= c >> 43;
+        dst[i] = c;
     }
 }
 

From 84ae35190ed265899c7a46df7f3b6305cd614405 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Thu, 29 Feb 2024 05:15:12 -0500
Subject: [PATCH 1032/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=201f16df404=20to=2048eea8dbd=20(#53517)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 1f16df404
New commit: 48eea8dbd
Julia version: 1.12.0-DEV
Pkg version: 1.11.0(Does not match)
Bump invoked by: @KristofferC
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/1f16df404a2fbe8642ea3eecc9f4d7064c400a73...48eea8dbd7b651cdc932b909c1b718bb9c3f94f4

```
$ git log --oneline 1f16df404..48eea8dbd
48eea8dbd setenv -> addenv (#3819)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5     | 1 -
 .../Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512  | 1 -
 .../Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5     | 1 +
 .../Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512

diff --git a/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5 b/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5
deleted file mode 100644
index 6313b4844bd73..0000000000000
--- a/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-c8077b74f0e37e3939f74367d9ab55cd
diff --git a/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512 b/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512
deleted file mode 100644
index 42b796b4264db..0000000000000
--- a/deps/checksums/Pkg-1f16df404a2fbe8642ea3eecc9f4d7064c400a73.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-d52830b86bb89d5831768214a4b1b0cc272a810d82f8fdcbf0ccad85085c999c626e75483f443f3d3db6cc29f6fe1bba17c33ef3fffceb5fbcc1e2909b0517cc
diff --git a/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5 b/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5
new file mode 100644
index 0000000000000..341ea80c32a7e
--- /dev/null
+++ b/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5
@@ -0,0 +1 @@
+fea1786e8202d07744c17457a114e911
diff --git a/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512 b/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512
new file mode 100644
index 0000000000000..8f6d09bbb6001
--- /dev/null
+++ b/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512
@@ -0,0 +1 @@
+e79913b68643ec4c448a861f446d0358484b01d16794c9dfe700b1f539d4c01ea259014d37df263b4d7dd3f3c2e1df3966c584b428041dbdf03d4e4794b52a64
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 532edda44cd99..ca45bee7ee736 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 1f16df404a2fbe8642ea3eecc9f4d7064c400a73
+PKG_SHA1 = 48eea8dbd7b651cdc932b909c1b718bb9c3f94f4
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 24aaf00819e49ba5c377b9e9deed287e54333129 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Thu, 29 Feb 2024 15:22:15 +0100
Subject: [PATCH 1033/1315] add back an alias for `check_top_bit` (#53523)

Used in some packages (e.g. rfourquet/BitIntegers.jl)
Renamed in https://github.com/JuliaLang/julia/pull/53166
---
 base/boot.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/base/boot.jl b/base/boot.jl
index 8ca6d392ead67..f8ed86b0fb6b7 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -969,6 +969,7 @@ arrayset(inbounds::Bool, A::Array{T}, x::Any, i::Int...) where {T} = Main.Base.s
 arraysize(a::Array) = a.size
 arraysize(a::Array, i::Int) = sle_int(i, nfields(a.size)) ? getfield(a.size, i) : 1
 export arrayref, arrayset, arraysize, const_arrayref
+const check_top_bit = check_sign_bit
 
 # For convenience
 EnterNode(old::EnterNode, new_dest::Int) = isdefined(old, :scope) ?

From 715c50d82af8d2856281e99bbed68014c3ddefd9 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 29 Feb 2024 09:32:17 -0500
Subject: [PATCH 1034/1315] codegen: make gcroots for argument-derived values
 (#53501)

This function might previously refuse to make gc roots for any of the
function's arguments (i.e. it potentially assumed everything was in an
alloca), which was only valid if we could guarantee that no IPO passes
run. This commit aims to make that safe, but deferring such decisions
about their source until llvm-late-gc-lowering can make them valid.

This should make inlining-safe gc annotations for

code_llvm(raw=true, optimize=false, (Some{Int},)) do x; GC.@preserve x
GC.safepoint(); end

and also better annotations even without inlining for

code_llvm(raw=true, optimize=false, (Some{Any},)) do x; GC.@preserve x
GC.safepoint(); end
---
 src/ccall.cpp                 |  10 ++--
 src/cgutils.cpp               | 104 +++++++++++++++++-----------------
 src/codegen.cpp               |  17 ++----
 src/llvm-late-gc-lowering.cpp |  20 ++++---
 4 files changed, 72 insertions(+), 79 deletions(-)

diff --git a/src/ccall.cpp b/src/ccall.cpp
index 5dd23d083186a..0fcc838905004 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1065,7 +1065,7 @@ class function_sig_t {
             jl_codectx_t &ctx,
             const native_sym_arg_t &symarg,
             jl_cgval_t *argv,
-            SmallVector<Value*, 16> &gc_uses,
+            SmallVectorImpl<Value*> &gc_uses,
             bool static_rt) const;
 
 private:
@@ -1389,16 +1389,14 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
     }
 
     // emit roots
-    SmallVector<Value*, 16> gc_uses;
+    SmallVector<Value*> gc_uses;
     for (size_t i = nccallargs + fc_args_start; i <= nargs; i++) {
         // Julia (expression) value of current parameter gcroot
         jl_value_t *argi_root = args[i];
         if (jl_is_long(argi_root))
             continue;
         jl_cgval_t arg_root = emit_expr(ctx, argi_root);
-        Value *gc_root = get_gc_root_for(ctx, arg_root);
-        if (gc_root)
-            gc_uses.push_back(gc_root);
+        gc_uses.append(get_gc_roots_for(ctx, arg_root));
     }
 
     jl_unionall_t *unionall = (jl_is_method(ctx.linfo->def.method) && jl_is_unionall(ctx.linfo->def.method->sig))
@@ -1855,7 +1853,7 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         jl_codectx_t &ctx,
         const native_sym_arg_t &symarg,
         jl_cgval_t *argv,
-        SmallVector<Value*, 16> &gc_uses,
+        SmallVectorImpl<Value*> &gc_uses,
         bool static_rt) const
 {
     ++EmittedCCalls;
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 695090f767546..7bbf7a84a0385 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -312,32 +312,64 @@ static Value *emit_pointer_from_objref(jl_codectx_t &ctx, Value *V)
 static Value *emit_unbox(jl_codectx_t &ctx, Type *to, const jl_cgval_t &x, jl_value_t *jt);
 static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value* dest, MDNode *tbaa_dest, unsigned alignment, bool isVolatile=false);
 
-static Value *get_gc_root_for(jl_codectx_t &ctx, const jl_cgval_t &x)
+static bool type_is_permalloc(jl_value_t *typ)
+{
+    // Singleton should almost always be handled by the later optimization passes.
+    // Also do it here since it is cheap and save some effort in LLVM passes.
+    if (jl_is_datatype(typ) && jl_is_datatype_singleton((jl_datatype_t*)typ))
+        return true;
+    return typ == (jl_value_t*)jl_symbol_type ||
+        typ == (jl_value_t*)jl_int8_type ||
+        typ == (jl_value_t*)jl_uint8_type;
+}
+
+
+static void find_perm_offsets(jl_datatype_t *typ, SmallVectorImpl<unsigned> &res, unsigned offset)
+{
+    // This is a inlined field at `offset`.
+    if (!typ->layout || typ->layout->npointers == 0)
+        return;
+    jl_svec_t *types = jl_get_fieldtypes(typ);
+    size_t nf = jl_svec_len(types);
+    for (size_t i = 0; i < nf; i++) {
+        jl_value_t *_fld = jl_svecref(types, i);
+        if (!jl_is_datatype(_fld))
+            continue;
+        jl_datatype_t *fld = (jl_datatype_t*)_fld;
+        if (jl_field_isptr(typ, i)) {
+            // pointer field, check if field is perm-alloc
+            if (type_is_permalloc((jl_value_t*)fld))
+                res.push_back(offset + jl_field_offset(typ, i));
+            continue;
+        }
+        // inline field
+        find_perm_offsets(fld, res, offset + jl_field_offset(typ, i));
+    }
+}
+
+static llvm::SmallVector<llvm::Value*, 0> get_gc_roots_for(jl_codectx_t &ctx, const jl_cgval_t &x)
 {
     if (x.constant || x.typ == jl_bottom_type)
-        return nullptr;
+        return {};
     if (x.Vboxed) // superset of x.isboxed
-        return x.Vboxed;
+        return {x.Vboxed};
     assert(!x.isboxed);
-#ifndef NDEBUG
     if (x.ispointer()) {
         assert(x.V);
-        if (PointerType *T = dyn_cast<PointerType>(x.V->getType())) {
-            assert(T->getAddressSpace() != AddressSpace::Tracked);
-            if (T->getAddressSpace() == AddressSpace::Derived) {
-                // n.b. this IR would not be valid after LLVM-level inlining,
-                // since codegen does not have a way to determine the whether
-                // this argument value needs to be re-rooted
-            }
-        }
-    }
-#endif
-    if (jl_is_concrete_immutable(x.typ) && !jl_is_pointerfree(x.typ)) {
-        Type *T = julia_type_to_llvm(ctx, x.typ);
-        return emit_unbox(ctx, T, x, x.typ);
+        assert(x.V->getType()->getPointerAddressSpace() != AddressSpace::Tracked);
+        return {x.V};
+    }
+    else if (jl_is_concrete_immutable(x.typ) && !jl_is_pointerfree(x.typ)) {
+        jl_value_t *jltype = x.typ;
+        Type *T = julia_type_to_llvm(ctx, jltype);
+        Value *agg = emit_unbox(ctx, T, x, jltype);
+        SmallVector<unsigned,4> perm_offsets;
+        if (jltype && jl_is_datatype(jltype) && ((jl_datatype_t*)jltype)->layout)
+            find_perm_offsets((jl_datatype_t*)jltype, perm_offsets, 0);
+        return ExtractTrackedValues(agg, agg->getType(), false, ctx.builder, perm_offsets);
     }
     // nothing here to root, move along
-    return nullptr;
+    return {};
 }
 
 // --- emitting pointers directly into code ---
@@ -590,17 +622,6 @@ static Value *julia_binding_gv(jl_codectx_t &ctx, jl_binding_t *b)
 
 // --- mapping between julia and llvm types ---
 
-static bool type_is_permalloc(jl_value_t *typ)
-{
-    // Singleton should almost always be handled by the later optimization passes.
-    // Also do it here since it is cheap and save some effort in LLVM passes.
-    if (jl_is_datatype(typ) && jl_is_datatype_singleton((jl_datatype_t*)typ))
-        return true;
-    return typ == (jl_value_t*)jl_symbol_type ||
-        typ == (jl_value_t*)jl_int8_type ||
-        typ == (jl_value_t*)jl_uint8_type;
-}
-
 static unsigned convert_struct_offset(const llvm::DataLayout &DL, Type *lty, unsigned byte_offset)
 {
     const StructLayout *SL = DL.getStructLayout(cast<StructType>(lty));
@@ -1905,7 +1926,7 @@ Value *extract_first_ptr(jl_codectx_t &ctx, Value *V)
     if (path.empty())
         return NULL;
     std::reverse(std::begin(path), std::end(path));
-    return ctx.builder.CreateExtractValue(V, path);
+    return CreateSimplifiedExtractValue(ctx, V, path);
 }
 
 
@@ -3590,29 +3611,6 @@ static void emit_write_barrier(jl_codectx_t &ctx, Value *parent, ArrayRef<Value*
     ctx.builder.CreateCall(prepare_call(jl_write_barrier_func), decay_ptrs);
 }
 
-static void find_perm_offsets(jl_datatype_t *typ, SmallVectorImpl<unsigned> &res, unsigned offset)
-{
-    // This is a inlined field at `offset`.
-    if (!typ->layout || typ->layout->npointers == 0)
-        return;
-    jl_svec_t *types = jl_get_fieldtypes(typ);
-    size_t nf = jl_svec_len(types);
-    for (size_t i = 0; i < nf; i++) {
-        jl_value_t *_fld = jl_svecref(types, i);
-        if (!jl_is_datatype(_fld))
-            continue;
-        jl_datatype_t *fld = (jl_datatype_t*)_fld;
-        if (jl_field_isptr(typ, i)) {
-            // pointer field, check if field is perm-alloc
-            if (type_is_permalloc((jl_value_t*)fld))
-                res.push_back(offset + jl_field_offset(typ, i));
-            continue;
-        }
-        // inline field
-        find_perm_offsets(fld, res, offset + jl_field_offset(typ, i));
-    }
-}
-
 static void emit_write_multibarrier(jl_codectx_t &ctx, Value *parent, Value *agg,
                                     jl_value_t *jltype)
 {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index bb9622c8e75c8..59c7763350fff 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -3365,21 +3365,18 @@ static Value *emit_bits_compare(jl_codectx_t &ctx, jl_cgval_t arg1, jl_cgval_t a
                 value_to_pointer(ctx, arg2).V;
             varg1 = emit_pointer_from_objref(ctx, varg1);
             varg2 = emit_pointer_from_objref(ctx, varg2);
-            Value *gc_uses[2];
-            int nroots = 0;
+            SmallVector<Value*, 0> gc_uses;
             // these roots may seem a bit overkill, but we want to make sure
             // that a!=b implies (a,)!=(b,) even if a and b are unused and
             // therefore could be freed and then the memory for a reused for b
-            if ((gc_uses[nroots] = get_gc_root_for(ctx, arg1)))
-                nroots++;
-            if ((gc_uses[nroots] = get_gc_root_for(ctx, arg2)))
-                nroots++;
-            OperandBundleDef OpBundle("jl_roots", ArrayRef<Value*>(gc_uses, nroots));
+            gc_uses.append(get_gc_roots_for(ctx, arg1));
+            gc_uses.append(get_gc_roots_for(ctx, arg2));
+            OperandBundleDef OpBundle("jl_roots", gc_uses);
             auto answer = ctx.builder.CreateCall(prepare_call(memcmp_func), {
                         ctx.builder.CreateBitCast(varg1, getInt8PtrTy(ctx.builder.getContext())),
                         ctx.builder.CreateBitCast(varg2, getInt8PtrTy(ctx.builder.getContext())),
                         ConstantInt::get(ctx.types().T_size, sz) },
-                    ArrayRef<OperandBundleDef>(&OpBundle, nroots ? 1 : 0));
+                    ArrayRef<OperandBundleDef>(&OpBundle, gc_uses.empty() ? 0 : 1));
 
             if (arg1.tbaa || arg2.tbaa) {
                 jl_aliasinfo_t ai;
@@ -6432,9 +6429,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
         }
         SmallVector<Value*, 0> vals;
         for (size_t i = 0; i < nargs; ++i) {
-            Value *gc_root = get_gc_root_for(ctx, argv[i]);
-            if (gc_root)
-                vals.push_back(gc_root);
+            vals.append(get_gc_roots_for(ctx, argv[i]));
         }
         Value *token = vals.empty()
             ? (Value*)ConstantTokenNone::get(ctx.builder.getContext())
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index e081c6f067245..b35f64be813d7 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -12,7 +12,8 @@
 #include <llvm/ADT/SetVector.h>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/ADT/SmallSet.h>
-#include "llvm/Analysis/CFG.h"
+#include <llvm/Analysis/CFG.h>
+#include <llvm/Analysis/InstSimplifyFolder.h>
 #include <llvm/IR/Value.h>
 #include <llvm/IR/Constants.h>
 #include <llvm/IR/Dominators.h>
@@ -455,7 +456,6 @@ SmallVector<SmallVector<unsigned, 0>, 0> TrackCompositeType(Type *T) {
 }
 
 
-
 // Walk through simple expressions to until we hit something that requires root numbering
 // If the input value is a scalar (pointer), we may return a composite value as base
 // in which case the second member of the pair is the index of the value in the vector.
@@ -616,12 +616,12 @@ Value *LateLowerGCFrame::MaybeExtractScalar(State &S, std::pair<Value*,int> ValE
                 V = ConstantPointerNull::get(cast<PointerType>(T_prjlvalue));
             return V;
         }
+        IRBuilder<InstSimplifyFolder> foldbuilder(InsertBefore->getContext(), InstSimplifyFolder(InsertBefore->getModule()->getDataLayout()));
+        foldbuilder.SetInsertPoint(InsertBefore);
         if (Idxs.size() > IsVector)
-            V = ExtractValueInst::Create(V, IsVector ? IdxsNotVec : Idxs, "", InsertBefore);
+            V = foldbuilder.CreateExtractValue(V, IsVector ? IdxsNotVec : Idxs);
         if (IsVector)
-            V = ExtractElementInst::Create(V,
-                    ConstantInt::get(Type::getInt32Ty(V->getContext()), Idxs.back()),
-                    "", InsertBefore);
+            V = foldbuilder.CreateExtractElement(V, ConstantInt::get(Type::getInt32Ty(V->getContext()), Idxs.back()));
     }
     return V;
 }
@@ -1817,11 +1817,13 @@ static Value *ExtractScalar(Value *V, Type *VTy, bool isptr, ArrayRef<unsigned>
         auto IdxsNotVec = Idxs.slice(0, Idxs.size() - 1);
         Type *FinalT = ExtractValueInst::getIndexedType(V->getType(), IdxsNotVec);
         bool IsVector = isa<VectorType>(FinalT);
+        IRBuilder<InstSimplifyFolder> foldbuilder(irbuilder.getContext(), InstSimplifyFolder(irbuilder.GetInsertBlock()->getModule()->getDataLayout()));
+        foldbuilder.restoreIP(irbuilder.saveIP());
+        foldbuilder.SetCurrentDebugLocation(irbuilder.getCurrentDebugLocation());
         if (Idxs.size() > IsVector)
-            V = irbuilder.Insert(ExtractValueInst::Create(V, IsVector ? IdxsNotVec : Idxs));
+            V = foldbuilder.CreateExtractValue(V, IsVector ? IdxsNotVec : Idxs);
         if (IsVector)
-            V = irbuilder.Insert(ExtractElementInst::Create(V,
-                    ConstantInt::get(Type::getInt32Ty(V->getContext()), Idxs.back())));
+            V = foldbuilder.CreateExtractElement(V, ConstantInt::get(Type::getInt32Ty(V->getContext()), Idxs.back()));
     }
     return V;
 }

From e50ca99ae75752c6314e394c1c1e923a7d8844a0 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Thu, 29 Feb 2024 10:40:01 -0500
Subject: [PATCH 1035/1315] fix potential double-free in flisp table
 implementation (#53519)

In this case we would add two finalizers, leading to a double free.
Introduced by 5fc4ba91931526a08fc1bf8d3937aac731ee2cc6. However, I
believe we never hit this in the julia front end, since it requires
making a large pre-initialized table (i.e. with many arguments to
`table`) which is later freed. That tends not to happen since
initialized tables tend to be global constants.
---
 src/flisp/table.c      |  2 +-
 src/flisp/unittest.lsp | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/flisp/table.c b/src/flisp/table.c
index 1d8aed358e88d..8836c93f81513 100644
--- a/src/flisp/table.c
+++ b/src/flisp/table.c
@@ -102,7 +102,7 @@ value_t fl_table(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
         else
             k = arg;
     }
-    if (h->table != &h->_space[0]) {
+    if (cnt <= HT_N_INLINE && h->table != &h->_space[0]) {
         // We expected to use the inline table, but we ended up outgrowing it.
         // Make sure to register the finalizer.
         add_finalizer(fl_ctx, (cvalue_t*)ptr(nt));
diff --git a/src/flisp/unittest.lsp b/src/flisp/unittest.lsp
index 584d5c81225e8..16774a97e3233 100644
--- a/src/flisp/unittest.lsp
+++ b/src/flisp/unittest.lsp
@@ -267,4 +267,23 @@
 (assert (equal? `(a `(b c)) '(a (quasiquote (b c)))))
 (assert (equal? ````x '```x))
 
+;; make many initialized tables large enough not to be stored in-line
+(for 1 100
+     (lambda (i)
+       (table eq?      2      eqv?     2
+              equal?   2      atom?    1
+              not      1      null?    1
+              boolean? 1      symbol?  1
+              number?  1      bound?   1
+              pair?    1      builtin? 1
+              vector?  1      fixnum?  1
+              cons     2      car      1
+              cdr      1      set-car! 2
+              set-cdr! 2      =        2
+              <        2      compare  2
+              aref     2      aset!    3
+              div0     2)))
+;; now allocate enough to trigger GC
+(for 1 8000000 (lambda (i) (cons 1 2)))
+
 #t

From 962bbf75e8e4a5cc5181fbccf895b0a5b20b6e34 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Thu, 29 Feb 2024 19:01:22 +0100
Subject: [PATCH 1036/1315] Introduce -m/--module flag to execute a `main`
 function in a package (#52103)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This aims to bring similar functionality to Julia as the `-m` flag for
Python which exists to directly run some function in a package and being
able to pass arguments to that function.

While in Python, `python -m package args` runs the file
`<package>.__main__.py`, the equivalent Julia command (`julia -m Package
args`) instead runs `<Package>.main(args)`. The package is assumed to be
installed in the environment `julia` is run in.

An example usage could be:

Add the package:
```julia
(@v1.11) pkg> add https://github.com/KristofferC/Rot13.jl
     Cloning git-repo `https://github.com/KristofferC/Rot13.jl`
    Updating git-repo `https://github.com/KristofferC/Rot13.jl`
   Resolving package versions...
    Updating `~/.julia/environments/v1.11/Project.toml`
  [43ef800a] + Rot13 v0.1.0 `https://github.com/KristofferC/Rot13.jl#master`
    Updating `~/.julia/environments/v1.11/Manifest.toml`
  [43ef800a] + Rot13 v0.1.0 `https://github.com/KristofferC/Rot13.jl#master`
```

And then it can be run (since it has a `main` function) via:

```
❯ ./julia/julia -m Rot13 "encrypt this for me" "and this as well"
rapelcg guvf sbe zr
naq guvf nf jryy
```

I'm not sure if `-m/--module` is the best choice but perhaps the
association to Python makes it worth it.
---
 NEWS.md                         |  3 +++
 base/client.jl                  |  9 ++++++++-
 doc/man/julia.1                 |  5 +++++
 src/jloptions.c                 | 11 ++++++++++-
 test/loading.jl                 |  5 +++++
 test/project/Rot13/Project.toml |  3 +++
 test/project/Rot13/src/Rot13.jl | 15 +++++++++++++++
 7 files changed, 49 insertions(+), 2 deletions(-)
 create mode 100644 test/project/Rot13/Project.toml
 create mode 100644 test/project/Rot13/src/Rot13.jl

diff --git a/NEWS.md b/NEWS.md
index 56a2ffb8d539d..432211ba003f4 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -23,6 +23,9 @@ Compiler/Runtime improvements
 Command-line option changes
 ---------------------------
 
+* The `-m/--module` flag can be passed to run the `main` function inside a package with a set of arguments.
+  This `main` function should be declared using `@main` to indicate that it is an entry point.
+
 Multi-threading changes
 -----------------------
 
diff --git a/base/client.jl b/base/client.jl
index 31a3016489dcd..087efe3d3b99c 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -240,7 +240,7 @@ function exec_options(opts)
         if cmd_suppresses_program(cmd)
             arg_is_program = false
             repl = false
-        elseif cmd == 'L'
+        elseif cmd == 'L' || cmd == 'm'
             # nothing
         elseif cmd == 'B' # --bug-report
             # If we're doing a bug report, don't load anything else. We will
@@ -292,6 +292,13 @@ function exec_options(opts)
         elseif cmd == 'E'
             invokelatest(show, Core.eval(Main, parse_input_line(arg)))
             println()
+        elseif cmd == 'm'
+            @eval Main import $(Symbol(arg)).main
+            if !should_use_main_entrypoint()
+                error("`main` in `$arg` not declared as entry point (use `@main` to do so)")
+            end
+            return false
+
         elseif cmd == 'L'
             # load file immediately on all processors
             if !distributed_mode
diff --git a/doc/man/julia.1 b/doc/man/julia.1
index afde0326e4952..a7d16abe3f85c 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -106,6 +106,11 @@ Enable or disable usage of native code caching in the form of pkgimages
 -e, --eval <expr>
 Evaluate <expr>
 
+.TP
+-m, --module <Package> [args]
+Run entry point of `Package` (`@main` function) with `args'.
+
+
 .TP
 -E, --print <expr>
 Evaluate <expr> and display the result
diff --git a/src/jloptions.c b/src/jloptions.c
index 570d021351104..2ba5174e5c730 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -128,6 +128,8 @@ static const char opts[]  =
     // actions
     " -e, --eval <expr>          Evaluate <expr>\n"
     " -E, --print <expr>         Evaluate <expr> and display the result\n"
+    " -m, --module <Package> [args]\n"
+    "                            Run entry point of `Package` (`@main` function) with `args'.\n"
     " -L, --load <file>          Load <file> immediately on all processors\n\n"
 
     // parallel options
@@ -271,7 +273,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
            opt_gc_threads,
            opt_permalloc_pkgimg
     };
-    static const char* const shortopts = "+vhqH:e:E:L:J:C:it:p:O:g:";
+    static const char* const shortopts = "+vhqH:e:E:L:J:C:it:p:O:g:m:";
     static const struct option longopts[] = {
         // exposed command line options
         // NOTE: This set of required arguments need to be kept in sync
@@ -284,6 +286,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
         { "banner",          required_argument, 0, opt_banner },
         { "home",            required_argument, 0, 'H' },
         { "eval",            required_argument, 0, 'e' },
+        { "module",          required_argument, 0, 'm' },
         { "print",           required_argument, 0, 'E' },
         { "load",            required_argument, 0, 'L' },
         { "bug-report",      required_argument, 0, opt_bug_report },
@@ -421,6 +424,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
         case 'e': // eval
         case 'E': // print
         case 'L': // load
+        case 'm': // module
         case opt_bug_report: // bug
         {
             size_t sz = strlen(optarg) + 1;
@@ -434,6 +438,10 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
             ncmds++;
             cmds[ncmds] = 0;
             jl_options.cmds = cmds;
+            if (c == 'm') {
+                optind -= 1;
+                goto parsing_args_done;
+            }
             break;
         }
         case 'J': // sysimage
@@ -886,6 +894,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                       "This is a bug, please report it.", c);
         }
     }
+    parsing_args_done:
     jl_options.code_coverage = codecov;
     jl_options.malloc_log = malloclog;
     int proc_args = *argcp < optind ? *argcp : optind;
diff --git a/test/loading.jl b/test/loading.jl
index 4a72a0f8060ad..8ba2cf3026120 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1545,3 +1545,8 @@ end
         @test_throws SystemError("opening file $(repr(file))") include(file)
     end
 end
+
+@testset "-m" begin
+    rot13proj = joinpath(@__DIR__, "project", "Rot13")
+    @test readchomp(`$(Base.julia_cmd()) --startup-file=no --project=$rot13proj -m Rot13 --project nowhere ABJURER`) == "--cebwrpg abjurer NOWHERE "
+end
diff --git a/test/project/Rot13/Project.toml b/test/project/Rot13/Project.toml
new file mode 100644
index 0000000000000..eb03cb84d588e
--- /dev/null
+++ b/test/project/Rot13/Project.toml
@@ -0,0 +1,3 @@
+name = "Rot13"
+uuid = "43ef800a-eac4-47f4-949b-25107b932e8f"
+version = "0.1.0"
diff --git a/test/project/Rot13/src/Rot13.jl b/test/project/Rot13/src/Rot13.jl
new file mode 100644
index 0000000000000..0672799d61f24
--- /dev/null
+++ b/test/project/Rot13/src/Rot13.jl
@@ -0,0 +1,15 @@
+module Rot13
+
+function rot13(c::Char)
+    shft = islowercase(c) ? 'a' : 'A'
+    isletter(c) ? c = shft + (c - shft + 13) % 26 : c
+end
+
+rot13(str::AbstractString) = map(rot13, str)
+
+function (@main)(ARGS)
+    foreach(arg -> print(rot13(arg), " "), ARGS)
+    return 0
+end
+
+end # module Rot13

From c06662a4f8d3fb277a30df82f2a012739f3c84d6 Mon Sep 17 00:00:00 2001
From: KronosTheLate <61620837+KronosTheLate@users.noreply.github.com>
Date: Thu, 29 Feb 2024 19:01:47 +0100
Subject: [PATCH 1037/1315] Implement and export `isfull` (#53159)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR implements `isfull(c::Channel)`.

It calls `n_avail(c) ≥ c.sz_max` in all cases. The original
implementation was inspired by [this
comment](https://discourse.julialang.org/t/function-to-check-if-channel-is-full/44795/3?u=thelatekronos),
and therefore had a special case for unbuffered channels, which fell
back to `isready`. I opted against this behaviour, because it fails to
respect that an unbuffered channel is always full, in two important
senses:
1) The number of elements available is greater than or equal the
capacity
    2) A call to `put!` will block

With the current implementation, the behaviour is simply understood and
summarized in all cases by the start of the docstring:
> Determines whether a `Channel` is full, in the
sense that calling `put!(c, some_value)` will block.

Shoutout to @SamuraiAku for their work in
https://github.com/JuliaLang/julia/pull/40720, which helped me a lot on
thinking this through, and remembering to change all relevant files. In
particular, the detail around how `c.cond_take.waitq` may result in
immediate unblocking, which is a really important caveat on a function
that may be used to check if `put!`ing will block. However, for buffered
channels, `isfull` is extremely close to `putwillblock` from #40720
(just a little better, with >= instead of ==), and for unbuffered
channels it does not make much sense to see if `put!`ing will block.

This PR is created based on
[this](https://github.com/JuliaLang/julia/issues/22863#issuecomment-1921498544)
"call to action".

Checklist:
- [x] Entry in news
- [x] Docstring with example
- [x] Export function
- [x] Mention in manual
- [x] Entry in
[docs-reference](https://docs.julialang.org/en/v1/base/parallel/)

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 NEWS.md                                    |  1 +
 base/channels.jl                           | 43 +++++++++++++++++++++-
 base/exports.jl                            |  1 +
 doc/src/base/parallel.md                   |  1 +
 doc/src/manual/asynchronous-programming.md |  5 ++-
 test/channels.jl                           |  7 ++++
 6 files changed, 55 insertions(+), 3 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 432211ba003f4..4d312c28ce34e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -36,6 +36,7 @@ New library functions
 ---------------------
 
 * `logrange(start, stop; length)` makes a range of constant ratio, instead of constant step ([#39071])
+* The new `isfull(c::Channel)` function can be used to check if `put!(c, some_value)` will block. ([#53159])
 
 New library features
 --------------------
diff --git a/base/channels.jl b/base/channels.jl
index 3ddf9cff7634c..3acbf37246a58 100644
--- a/base/channels.jl
+++ b/base/channels.jl
@@ -519,7 +519,7 @@ end
 Determines whether a [`Channel`](@ref) has a value stored in it.
 Returns immediately, does not block.
 
-For unbuffered channels returns `true` if there are tasks waiting on a [`put!`](@ref).
+For unbuffered channels, return `true` if there are tasks waiting on a [`put!`](@ref).
 
 # Examples
 
@@ -559,6 +559,47 @@ function n_avail(c::Channel)
     @atomic :monotonic c.n_avail_items
 end
 
+"""
+    isfull(c::Channel)
+
+Determines if a [`Channel`](@ref) is full, in the sense
+that calling `put!(c, some_value)` would have blocked.
+Returns immediately, does not block.
+
+Note that it may frequently be the case that `put!` will
+not block after this returns `true`. Users must take
+precautions not to accidentally create live-lock bugs
+in their code by calling this method, as these are
+generally harder to debug than deadlocks. It is also
+possible that `put!` will block after this call
+returns `false`, if there are multiple producer
+tasks calling `put!` in parallel.
+
+# Examples
+
+Buffered channel:
+```jldoctest
+julia> c = Channel(1); # capacity = 1
+
+julia> isfull(c)
+false
+
+julia> put!(c, 1);
+
+julia> isfull(c)
+true
+```
+
+Unbuffered channel:
+```jldoctest
+julia> c = Channel(); # capacity = 0
+
+julia> isfull(c) # unbuffered channel is always full
+true
+```
+"""
+isfull(c::Channel) = n_avail(c) ≥ c.sz_max
+
 lock(c::Channel) = lock(c.cond_take)
 lock(f, c::Channel) = lock(f, c.cond_take)
 unlock(c::Channel) = unlock(c.cond_take)
diff --git a/base/exports.jl b/base/exports.jl
index 7f3ad451bcc83..cb4acce27c66d 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -719,6 +719,7 @@ export
 # channels
     take!,
     put!,
+    isfull,
     isready,
     fetch,
     bind,
diff --git a/doc/src/base/parallel.md b/doc/src/base/parallel.md
index 5798da54a5cde..7605d4e6c9e7e 100644
--- a/doc/src/base/parallel.md
+++ b/doc/src/base/parallel.md
@@ -62,6 +62,7 @@ Base.Channel
 Base.Channel(::Function)
 Base.put!(::Channel, ::Any)
 Base.take!(::Channel)
+Base.isfull(::Channel)
 Base.isready(::Channel)
 Base.fetch(::Channel)
 Base.close(::Channel)
diff --git a/doc/src/manual/asynchronous-programming.md b/doc/src/manual/asynchronous-programming.md
index 5b43ba971ee1c..15db6eda5f807 100644
--- a/doc/src/manual/asynchronous-programming.md
+++ b/doc/src/manual/asynchronous-programming.md
@@ -194,10 +194,11 @@ A channel can be visualized as a pipe, i.e., it has a write end and a read end :
     to the maximum number of elements that can be held in the channel at any time. For example, `Channel(32)`
     creates a channel that can hold a maximum of 32 objects of any type. A `Channel{MyType}(64)` can
     hold up to 64 objects of `MyType` at any time.
-  * If a [`Channel`](@ref) is empty, readers (on a [`take!`](@ref) call) will block until data is available.
-  * If a [`Channel`](@ref) is full, writers (on a [`put!`](@ref) call) will block until space becomes available.
+  * If a [`Channel`](@ref) is empty, readers (on a [`take!`](@ref) call) will block until data is available (see [`isempty`](@ref)).
+  * If a [`Channel`](@ref) is full, writers (on a [`put!`](@ref) call) will block until space becomes available (see [`isfull`](@ref)).
   * [`isready`](@ref) tests for the presence of any object in the channel, while [`wait`](@ref)
     waits for an object to become available.
+  * Note that if another task is currently waiting to `put!` an object into a channel, a channel can have more items available than its capacity.
   * A [`Channel`](@ref) is in an open state initially. This means that it can be read from and written to
     freely via [`take!`](@ref) and [`put!`](@ref) calls. [`close`](@ref) closes a [`Channel`](@ref).
     On a closed [`Channel`](@ref), [`put!`](@ref) will fail. For example:
diff --git a/test/channels.jl b/test/channels.jl
index 5633d9480d0b8..25b5185c1a336 100644
--- a/test/channels.jl
+++ b/test/channels.jl
@@ -40,6 +40,8 @@ end
     c = Channel()
     @test eltype(c) == Any
     @test c.sz_max == 0
+    @test isempty(c) == true  # Nothing in it
+    @test isfull(c) == true   # But no more room
 
     c = Channel(1)
     @test eltype(c) == Any
@@ -49,6 +51,11 @@ end
     @test isready(c) == false
     @test eltype(Channel(1.0)) == Any
 
+    c = Channel(1)
+    @test isfull(c) == false
+    put!(c, 1)
+    @test isfull(c) == true
+
     c = Channel{Int}(1)
     @test eltype(c) == Int
     @test_throws MethodError put!(c, "Hello")

From fbcc99a60a3130ad1e28adc841e793d66c7e1367 Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Fri, 1 Mar 2024 00:04:08 +0100
Subject: [PATCH 1038/1315] Add documentation about failure cases of trig
 functions & return types (#50855)

---
 base/math.jl         | 59 +++++++++++++++++++++----------
 base/special/trig.jl | 82 +++++++++++++++++++++++++++++++-------------
 2 files changed, 99 insertions(+), 42 deletions(-)

diff --git a/base/math.jl b/base/math.jl
index 6ed69188371dd..71a4ef9f34882 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -359,7 +359,7 @@ log(b::T, x::T) where {T<:Number} = log(x)/log(b)
 """
     log(b,x)
 
-Compute the base `b` logarithm of `x`. Throws [`DomainError`](@ref) for negative
+Compute the base `b` logarithm of `x`. Throw a [`DomainError`](@ref) for negative
 [`Real`](@ref) arguments.
 
 # Examples
@@ -408,6 +408,8 @@ const libm = Base.libm_name
     sinh(x)
 
 Compute hyperbolic sine of `x`.
+
+See also [`sin`](@ref).
 """
 sinh(x::Number)
 
@@ -415,6 +417,8 @@ sinh(x::Number)
     cosh(x)
 
 Compute hyperbolic cosine of `x`.
+
+See also [`cos`](@ref).
 """
 cosh(x::Number)
 
@@ -493,10 +497,12 @@ asinh(x::Number)
 
 # functions that return NaN on non-NaN argument for domain error
 """
-    sin(x)
+    sin(x::T) where {T <: Number} -> float(T)
 
 Compute sine of `x`, where `x` is in radians.
 
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
+
 See also [`sind`](@ref), [`sinpi`](@ref), [`sincos`](@ref), [`cis`](@ref), [`asin`](@ref).
 
 # Examples
@@ -524,26 +530,34 @@ julia> round(exp(im*pi/6), digits=3)
 sin(x::Number)
 
 """
-    cos(x)
+    cos(x::T) where {T <: Number} -> float(T)
 
 Compute cosine of `x`, where `x` is in radians.
 
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
+
 See also [`cosd`](@ref), [`cospi`](@ref), [`sincos`](@ref), [`cis`](@ref).
 """
 cos(x::Number)
 
 """
-    tan(x)
+    tan(x::T) where {T <: Number} -> float(T)
 
 Compute tangent of `x`, where `x` is in radians.
+
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
+
+See also [`tanh`](@ref).
 """
 tan(x::Number)
 
 """
-    asin(x)
+    asin(x::T) where {T <: Number} -> float(T)
 
 Compute the inverse sine of `x`, where the output is in radians.
 
+Return a `T(NaN)` if `isnan(x)`.
+
 See also [`asind`](@ref) for output in degrees.
 
 # Examples
@@ -558,9 +572,11 @@ julia> asind.((0, 1/2, 1))
 asin(x::Number)
 
 """
-    acos(x)
+    acos(x::T) where {T <: Number} -> float(T)
 
 Compute the inverse cosine of `x`, where the output is in radians
+
+Return a `T(NaN)` if `isnan(x)`.
 """
 acos(x::Number)
 
@@ -583,9 +599,12 @@ atanh(x::Number)
 
 Compute the natural logarithm of `x`.
 
-Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
-Use complex arguments to obtain complex results.
-Has a branch cut along the negative real axis, for which `-0.0im` is taken to be below the axis.
+Throw a [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
+Use [`Complex`](@ref) arguments to obtain [`Complex`](@ref) results.
+
+!!! note "Branch cut"
+    `log` has a branch cut along the negative real axis; `-0.0im` is taken
+    to be below the axis.
 
 See also [`ℯ`](@ref), [`log1p`](@ref), [`log2`](@ref), [`log10`](@ref).
 
@@ -619,7 +638,7 @@ log(x::Number)
 """
     log2(x)
 
-Compute the logarithm of `x` to base 2. Throws [`DomainError`](@ref) for negative
+Compute the logarithm of `x` to base 2. Throw a [`DomainError`](@ref) for negative
 [`Real`](@ref) arguments.
 
 See also: [`exp2`](@ref), [`ldexp`](@ref), [`ispow2`](@ref).
@@ -652,7 +671,7 @@ log2(x)
     log10(x)
 
 Compute the logarithm of `x` to base 10.
-Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
+Throw a [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
 
 # Examples
 ```jldoctest; filter = r"Stacktrace:(\\n \\[[0-9]+\\].*)*"
@@ -675,7 +694,7 @@ log10(x)
 """
     log1p(x)
 
-Accurate natural logarithm of `1+x`. Throws [`DomainError`](@ref) for [`Real`](@ref)
+Accurate natural logarithm of `1+x`. Throw a [`DomainError`](@ref) for [`Real`](@ref)
 arguments less than -1.
 
 # Examples
@@ -706,12 +725,15 @@ end
 
 Return ``\\sqrt{x}``.
 
-Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
-Use complex negative arguments instead. Note that `sqrt` has a branch cut
-along the negative real axis.
+Throw a [`DomainError`](@ref) for negative [`Real`](@ref) arguments.
+Use [`Complex`](@ref) negative arguments instead to obtain a [`Complex`](@ref) result.
 
 The prefix operator `√` is equivalent to `sqrt`.
 
+!!! note "Branch cut"
+    `sqrt` has a branch cut along the negative real axis; `-0.0im` is taken
+    to be below the axis.
+
 See also: [`hypot`](@ref).
 
 # Examples
@@ -1005,7 +1027,8 @@ ldexp(x::Float16, q::Integer) = Float16(ldexp(Float32(x), q))
 """
     exponent(x::Real) -> Int
 
-Returns the largest integer `y` such that `2^y ≤ abs(x)`.
+Return the largest integer `y` such that `2^y ≤ abs(x)`.
+For a normalized floating-point number `x`, this corresponds to the exponent of `x`.
 
 Throws a `DomainError` when `x` is zero, infinite, or [`NaN`](@ref).
 For any other non-subnormal floating-point number `x`, this corresponds to the exponent bits of `x`.
@@ -1330,8 +1353,8 @@ end
 
 function add22condh(xh::Float64, xl::Float64, yh::Float64, yl::Float64)
     # This algorithm, due to Dekker, computes the sum of two
-    # double-double numbers and returns the high double. References:
-    # [1] https://www.digizeitschriften.de/en/dms/img/?PID=GDZPPN001170007
+    # double-double numbers and return the high double. References:
+    # [1] http://www.digizeitschriften.de/en/dms/img/?PID=GDZPPN001170007
     # [2] https://doi.org/10.1007/BF01397083
     r = xh+yh
     s = (abs(xh) > abs(yh)) ? (xh-r+yh+yl+xl) : (yh-r+xh+xl+yl)
diff --git a/base/special/trig.jl b/base/special/trig.jl
index 99b4ca91608f2..15ecb0ca0492f 100644
--- a/base/special/trig.jl
+++ b/base/special/trig.jl
@@ -165,11 +165,13 @@ end
 @noinline sincos_domain_error(x) = throw(DomainError(x, "sincos(x) is only defined for finite x."))
 
 """
-    sincos(x)
+    sincos(x::T) where T -> float(T)
 
 Simultaneously compute the sine and cosine of `x`, where `x` is in radians, returning
 a tuple `(sine, cosine)`.
 
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `(T(NaN), T(NaN))` if `isnan(x)`.
+
 See also [`cis`](@ref), [`sincospi`](@ref), [`sincosd`](@ref).
 """
 function sincos(x::T) where T<:Union{Float32, Float64}
@@ -783,17 +785,19 @@ end
 end
 
 """
-    sinpi(x)
+    sinpi(x::T) where T -> float(T)
 
 Compute ``\\sin(\\pi x)`` more accurately than `sin(pi*x)`, especially for large `x`.
 
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
+
 See also [`sind`](@ref), [`cospi`](@ref), [`sincospi`](@ref).
 """
 function sinpi(_x::T) where T<:IEEEFloat
     x = abs(_x)
     if !isfinite(x)
         isnan(x) && return x
-        throw(DomainError(x, "`x` cannot be infinite."))
+        throw(DomainError(x, "`sinpi(x)` is only defined for finite `x`."))
     end
     # For large x, answers are all 1 or zero.
     x >= maxintfloat(T) && return copysign(zero(T), _x)
@@ -814,15 +818,19 @@ function sinpi(_x::T) where T<:IEEEFloat
     return ifelse(signbit(_x), -res, res)
 end
 """
-    cospi(x)
+    cospi(x::T) where T -> float(T)
 
 Compute ``\\cos(\\pi x)`` more accurately than `cos(pi*x)`, especially for large `x`.
+
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
+
+See also: [`cispi`](@ref), [`sincosd`](@ref), [`cospi`](@ref).
 """
 function cospi(x::T) where T<:IEEEFloat
     x = abs(x)
     if !isfinite(x)
         isnan(x) && return x
-        throw(DomainError(x, "`x` cannot be infinite."))
+        throw(DomainError(x, "`cospi(x)` is only defined for finite `x`."))
     end
     # For large x, answers are all 1 or zero.
     x >= maxintfloat(T) && return one(T)
@@ -842,11 +850,13 @@ function cospi(x::T) where T<:IEEEFloat
     end
 end
 """
-    sincospi(x)
+    sincospi(x::T) where T -> float(T)
 
 Simultaneously compute [`sinpi(x)`](@ref) and [`cospi(x)`](@ref) (the sine and cosine of `π*x`,
 where `x` is in radians), returning a tuple `(sine, cosine)`.
 
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `(T(NaN), T(NaN))` tuple if `isnan(x)`.
+
 !!! compat "Julia 1.6"
     This function requires Julia 1.6 or later.
 
@@ -856,7 +866,7 @@ function sincospi(_x::T) where T<:IEEEFloat
     x = abs(_x)
     if !isfinite(x)
         isnan(x) && return x, x
-        throw(DomainError(x, "`x` cannot be infinite."))
+        throw(DomainError(x, "`sincospi(x)` is only defined for finite `x`."))
     end
     # For large x, answers are all 1 or zero.
     x >= maxintfloat(T) && return (copysign(zero(T), _x), one(T))
@@ -880,10 +890,12 @@ function sincospi(_x::T) where T<:IEEEFloat
 end
 
 """
-    tanpi(x)
+    tanpi(x::T) where T -> float(T)
 
 Compute ``\\tan(\\pi x)`` more accurately than `tan(pi*x)`, especially for large `x`.
 
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
+
 !!! compat "Julia 1.10"
     This function requires at least Julia 1.10.
 
@@ -895,7 +907,7 @@ function tanpi(_x::T) where T<:IEEEFloat
     x = abs(_x)
     if !isfinite(x)
         isnan(x) && return x
-        throw(DomainError(x, "`x` cannot be infinite."))
+        throw(DomainError(x, "`tanpi(x)` is only defined for finite `x`."))
     end
     # For large x, answers are all zero.
     # All integer values for floats larger than maxintfloat are even.
@@ -1063,10 +1075,12 @@ isinf_real(x::Complex) = isinf(real(x)) && isfinite(imag(x))
 isinf_real(x::Number) = false
 
 """
-    sinc(x)
+    sinc(x::T) where {T <: Number} -> float(T)
 
 Compute normalized sinc function ``\\operatorname{sinc}(x) = \\sin(\\pi x) / (\\pi x)`` if ``x \\neq 0``, and ``1`` if ``x = 0``.
 
+Return a `T(NaN)` if `isnan(x)`.
+
 See also [`cosc`](@ref), its derivative.
 """
 sinc(x::Number) = _sinc(float(x))
@@ -1080,11 +1094,13 @@ _sinc(x::Float16) = Float16(_sinc(Float32(x)))
 _sinc(x::ComplexF16) = ComplexF16(_sinc(ComplexF32(x)))
 
 """
-    cosc(x)
+    cosc(x::T) where {T <: Number} -> float(T)
 
 Compute ``\\cos(\\pi x) / x - \\sin(\\pi x) / (\\pi x^2)`` if ``x \\neq 0``, and ``0`` if
 ``x = 0``. This is the derivative of `sinc(x)`.
 
+Return a `T(NaN)` if `isnan(x)`.
+
 See also [`sinc`](@ref).
 """
 cosc(x::Number) = _cosc(float(x))
@@ -1129,19 +1145,25 @@ for (finv, f, finvh, fh, finvd, fd, fn) in ((:sec, :cos, :sech, :cosh, :secd, :c
     dname = string(finvd)
     @eval begin
         @doc """
-            $($name)(x)
+            $($name)(x::T) where {T <: Number} -> float(T)
 
         Compute the $($fn) of `x`, where `x` is in radians.
+
+        Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
         """ ($finv)(z::Number) = inv(($f)(z))
         @doc """
-            $($hname)(x)
+            $($hname)(x::T) where {T <: Number} -> float(T)
 
         Compute the hyperbolic $($fn) of `x`.
+
+        Return a `T(NaN)` if `isnan(x)`.
         """ ($finvh)(z::Number) = inv(($fh)(z))
         @doc """
-            $($dname)(x)
+            $($dname)(x::T) where {T <: Number} -> float(T)
 
         Compute the $($fn) of `x`, where `x` is in degrees.
+
+        Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
         """ ($finvd)(z::Number) = inv(($fd)(z))
     end
 end
@@ -1153,11 +1175,15 @@ for (tfa, tfainv, hfa, hfainv, fn) in ((:asec, :acos, :asech, :acosh, "secant"),
     hname = string(hfa)
     @eval begin
         @doc """
-            $($tname)(x)
-        Compute the inverse $($fn) of `x`, where the output is in radians. """ ($tfa)(y::Number) = ($tfainv)(inv(y))
+            $($tname)(x::T) where {T <: Number} -> float(T)
+
+        Compute the inverse $($fn) of `x`, where the output is in radians.
+        """ ($tfa)(y::Number) = ($tfainv)(inv(y))
         @doc """
-            $($hname)(x)
-        Compute the inverse hyperbolic $($fn) of `x`. """ ($hfa)(y::Number) = ($hfainv)(inv(y))
+            $($hname)(x::T) where {T <: Number} -> float(T)
+
+        Compute the inverse hyperbolic $($fn) of `x`.
+        """ ($hfa)(y::Number) = ($hfainv)(inv(y))
     end
 end
 
@@ -1182,7 +1208,7 @@ deg2rad_ext(x::Real) = deg2rad(x) # Fallback
 
 function sind(x::Real)
     if isinf(x)
-        return throw(DomainError(x, "`x` cannot be infinite."))
+        return throw(DomainError(x, "`sind(x)` is only defined for finite `x`."))
     elseif isnan(x)
         return x
     end
@@ -1213,7 +1239,7 @@ end
 
 function cosd(x::Real)
     if isinf(x)
-        return throw(DomainError(x, "`x` cannot be infinite."))
+        return throw(DomainError(x, "`cosd(x)` is only defined for finite `x`."))
     elseif isnan(x)
         return x
     end
@@ -1240,10 +1266,12 @@ end
 tand(x::Real) = sind(x) / cosd(x)
 
 """
-    sincosd(x)
+    sincosd(x::T) where T -> float(T)
 
 Simultaneously compute the sine and cosine of `x`, where `x` is in degrees.
 
+Throw a [`DomainError`](@ref) if `isinf(x)`, return a `(T(NaN), T(NaN))` tuple if `isnan(x)`.
+
 !!! compat "Julia 1.3"
     This function requires at least Julia 1.3.
 """
@@ -1258,11 +1286,13 @@ for (fd, f, fn) in ((:sind, :sin, "sine"), (:cosd, :cos, "cosine"), (:tand, :tan
         name = string(fd)
         @eval begin
             @doc """
-                $($name)(x)
+                $($name)(x::T) where T -> float(T)
 
             Compute $($fn) of `x`, where `x` is in $($un).
             If `x` is a matrix, `x` needs to be a square matrix.
 
+            Throw a [`DomainError`](@ref) if `isinf(x)`, return a `T(NaN)` if `isnan(x)`.
+
             !!! compat "Julia 1.7"
                 Matrix arguments require Julia 1.7 or later.
             """ ($fd)(x) = ($f)(($fu).(x))
@@ -1290,11 +1320,15 @@ for (fd, f, fn) in ((:asind, :asin, "sine"), (:acosd, :acos, "cosine"),
 end
 
 """
-    atand(y)
-    atand(y,x)
+    atand(y::T) where T -> float(T)
+    atand(y::T, x::S) where {T,S} -> promote_type(T,S)
+    atand(y::AbstractMatrix{T}) where T -> AbstractMatrix{Complex{float(T)}}
 
 Compute the inverse tangent of `y` or `y/x`, respectively, where the output is in degrees.
 
+Return a `NaN` if `isnan(y)` or `isnan(x)`. The returned `NaN` is either a `T` in the single
+argument version, or a `promote_type(T,S)` in the two argument version.
+
 !!! compat "Julia 1.7"
     The one-argument method supports square matrix arguments as of Julia 1.7.
 """

From 989c4db50e0ca59b890af2f1800004ecf91c0faf Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 29 Feb 2024 18:04:39 -0500
Subject: [PATCH 1039/1315] add _readdirx for returning more object info
 gathered during dir scan (#53377)

---
 base/file.jl | 85 ++++++++++++++++++++++++++++++++++++++++++++++++----
 test/file.jl |  8 +++++
 test/misc.jl |  5 ++--
 3 files changed, 91 insertions(+), 7 deletions(-)

diff --git a/base/file.jl b/base/file.jl
index 6c4f7bc5fb8f3..659c39d7415f8 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -929,7 +929,79 @@ julia> readdir(abspath("base"), join=true)
  "/home/JuliaUser/dev/julia/base/weakkeydict.jl"
 ```
 """
-function readdir(dir::AbstractString; join::Bool=false, sort::Bool=true)
+readdir(; join::Bool=false, kwargs...) = readdir(join ? pwd() : "."; join, kwargs...)::Vector{String}
+readdir(dir::AbstractString; kwargs...) = _readdir(dir; return_objects=false, kwargs...)::Vector{String}
+
+# this might be better as an Enum but they're not available here
+# UV_DIRENT_T
+const UV_DIRENT_UNKNOWN = Cint(0)
+const UV_DIRENT_FILE = Cint(1)
+const UV_DIRENT_DIR = Cint(2)
+const UV_DIRENT_LINK = Cint(3)
+const UV_DIRENT_FIFO = Cint(4)
+const UV_DIRENT_SOCKET = Cint(5)
+const UV_DIRENT_CHAR = Cint(6)
+const UV_DIRENT_BLOCK = Cint(7)
+
+"""
+    DirEntry
+
+A type representing a filesystem entry that contains the name of the entry, the directory, and
+the raw type of the entry. The full path of the entry can be obtained lazily by accessing the
+`path` field. The type of the entry can be checked for by calling [`isfile`](@ref), [`isdir`](@ref),
+[`islink`](@ref), [`isfifo`](@ref), [`issocket`](@ref), [`ischardev`](@ref), and [`isblockdev`](@ref)
+"""
+struct DirEntry
+    dir::String
+    name::String
+    rawtype::Cint
+end
+function Base.getproperty(obj::DirEntry, p::Symbol)
+    if p === :path
+        return joinpath(obj.dir, obj.name)
+    else
+        return getfield(obj, p)
+    end
+end
+Base.propertynames(::DirEntry) = (:dir, :name, :path, :rawtype)
+Base.isless(a::DirEntry, b::DirEntry) = a.dir == b.dir ? isless(a.name, b.name) : isless(a.dir, b.dir)
+Base.hash(o::DirEntry, h::UInt) = hash(o.dir, hash(o.name, hash(o.rawtype, h)))
+Base.:(==)(a::DirEntry, b::DirEntry) = a.name == b.name && a.dir == b.dir && a.rawtype == b.rawtype
+joinpath(obj::DirEntry, args...) = joinpath(obj.path, args...)
+isunknown(obj::DirEntry) =  obj.rawtype == UV_DIRENT_UNKNOWN
+islink(obj::DirEntry) =     isunknown(obj) ? islink(obj.path) : obj.rawtype == UV_DIRENT_LINK
+isfile(obj::DirEntry) =     (isunknown(obj) || islink(obj)) ? isfile(obj.path)      : obj.rawtype == UV_DIRENT_FILE
+isdir(obj::DirEntry) =      (isunknown(obj) || islink(obj)) ? isdir(obj.path)       : obj.rawtype == UV_DIRENT_DIR
+isfifo(obj::DirEntry) =     (isunknown(obj) || islink(obj)) ? isfifo(obj.path)      : obj.rawtype == UV_DIRENT_FIFO
+issocket(obj::DirEntry) =   (isunknown(obj) || islink(obj)) ? issocket(obj.path)    : obj.rawtype == UV_DIRENT_SOCKET
+ischardev(obj::DirEntry) =  (isunknown(obj) || islink(obj)) ? ischardev(obj.path)   : obj.rawtype == UV_DIRENT_CHAR
+isblockdev(obj::DirEntry) = (isunknown(obj) || islink(obj)) ? isblockdev(obj.path)  : obj.rawtype == UV_DIRENT_BLOCK
+realpath(obj::DirEntry) = realpath(obj.path)
+
+"""
+    _readdirx(dir::AbstractString=pwd(); sort::Bool = true) -> Vector{DirEntry}
+
+Return a vector of [`DirEntry`](@ref) objects representing the contents of the directory `dir`,
+or the current working directory if not given. If `sort` is true, the returned vector is
+sorted by name.
+
+Unlike [`readdir`](@ref), `_readdirx` returns [`DirEntry`](@ref) objects, which contain the name of the
+file, the directory it is in, and the type of the file which is determined during the
+directory scan. This means that calls to [`isfile`](@ref), [`isdir`](@ref), [`islink`](@ref), [`isfifo`](@ref),
+[`issocket`](@ref), [`ischardev`](@ref), and [`isblockdev`](@ref) can be made on the
+returned objects without further stat calls. However, for some filesystems, the type of the file
+cannot be determined without a stat call. In these cases the `rawtype` field of the [`DirEntry`](@ref))
+object will be 0 (`UV_DIRENT_UNKNOWN`) and [`isfile`](@ref) etc. will fall back to a `stat` call.
+
+```julia
+for obj in _readdirx()
+    isfile(obj) && println("\$(obj.name) is a file with path \$(obj.path)")
+end
+```
+"""
+_readdirx(dir::AbstractString=pwd(); sort::Bool=true) = _readdir(dir; return_objects=true, sort)::Vector{DirEntry}
+
+function _readdir(dir::AbstractString; return_objects::Bool=false, join::Bool=false, sort::Bool=true)
     # Allocate space for uv_fs_t struct
     req = Libc.malloc(_sizeof_uv_fs)
     try
@@ -939,11 +1011,16 @@ function readdir(dir::AbstractString; join::Bool=false, sort::Bool=true)
         err < 0 && uv_error("readdir($(repr(dir)))", err)
 
         # iterate the listing into entries
-        entries = String[]
+        entries = return_objects ? DirEntry[] : String[]
         ent = Ref{uv_dirent_t}()
         while Base.UV_EOF != ccall(:uv_fs_scandir_next, Cint, (Ptr{Cvoid}, Ptr{uv_dirent_t}), req, ent)
             name = unsafe_string(ent[].name)
-            push!(entries, join ? joinpath(dir, name) : name)
+            if return_objects
+                rawtype = ent[].typ
+                push!(entries, DirEntry(dir, name, rawtype))
+            else
+                push!(entries, join ? joinpath(dir, name) : name)
+            end
         end
 
         # Clean up the request string
@@ -957,8 +1034,6 @@ function readdir(dir::AbstractString; join::Bool=false, sort::Bool=true)
         Libc.free(req)
     end
 end
-readdir(; join::Bool=false, sort::Bool=true) =
-    readdir(join ? pwd() : ".", join=join, sort=sort)
 
 """
     walkdir(dir; topdown=true, follow_symlinks=false, onerror=throw)
diff --git a/test/file.jl b/test/file.jl
index 1ce7a5cdb440b..a5ab29a3bf8bc 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -31,6 +31,8 @@ if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     symlink(subdir, dirlink)
     @test stat(dirlink) == stat(subdir)
     @test readdir(dirlink) == readdir(subdir)
+    @test map(o->o.names, Base.Filesystem._readdirx(dirlink)) == map(o->o.names, Base.Filesystem._readdirx(subdir))
+    @test realpath.(Base.Filesystem._readdirx(dirlink)) == realpath.(Base.Filesystem._readdirx(subdir))
 
     # relative link
     relsubdirlink = joinpath(subdir, "rel_subdirlink")
@@ -38,6 +40,7 @@ if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     symlink(reldir, relsubdirlink)
     @test stat(relsubdirlink) == stat(subdir2)
     @test readdir(relsubdirlink) == readdir(subdir2)
+    @test Base.Filesystem._readdirx(relsubdirlink) == Base.Filesystem._readdirx(subdir2)
 
     # creation of symlink to directory that does not yet exist
     new_dir = joinpath(subdir, "new_dir")
@@ -56,6 +59,7 @@ if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     mkdir(new_dir)
     touch(foo_file)
     @test readdir(new_dir) == readdir(nedlink)
+    @test realpath.(Base.Filesystem._readdirx(new_dir)) == realpath.(Base.Filesystem._readdirx(nedlink))
 
     rm(foo_file)
     rm(new_dir)
@@ -1441,6 +1445,10 @@ rm(dirwalk, recursive=true)
                 touch(randstring())
             end
             @test issorted(readdir())
+            @test issorted(Base.Filesystem._readdirx())
+            @test map(o->o.name, Base.Filesystem._readdirx()) == readdir()
+            @test map(o->o.path, Base.Filesystem._readdirx()) == readdir(join=true)
+            @test count(isfile, readdir(join=true)) == count(isfile, Base.Filesystem._readdirx())
         end
     end
 end
diff --git a/test/misc.jl b/test/misc.jl
index 6597ecf8a8428..e870c7f491c13 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -1363,9 +1363,10 @@ end
 @test isdefined(KwdefWithEsc_TestModule, :Struct)
 
 @testset "exports of modules" begin
-    for (_, mod) in Base.loaded_modules
+    @testset "$mod" for (_, mod) in Base.loaded_modules
         mod === Main && continue # Main exports everything
-        for v in names(mod)
+        @testset "$v" for v in names(mod)
+            isdefined(mod, v) || @error "missing $v in $mod"
             @test isdefined(mod, v)
         end
     end

From 2501e37e31a763ba64fc95c1e48b2bd35cb8ebb1 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 1 Mar 2024 09:43:00 +0900
Subject: [PATCH 1040/1315] post-opt analysis: fix conditional successor
 visitation logic (#53518)

Previously `conditional_successors_may_throw` performed post-domination
analysis not on the initially specified `bb` (which was given as the
argument), but on those BBs being analyzed that were popped from the
work-queue at the time. As a result, there were cases where not all
conditional successors were visited.

fixes #53508
---
 base/compiler/optimize.jl | 21 ++++++++++++++-------
 test/compiler/effects.jl  |  5 +++++
 test/compiler/ssair.jl    | 29 +++++++++++++++++++++++++++++
 3 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index d3c680f9308d3..1615781727669 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -531,17 +531,22 @@ function any_stmt_may_throw(ir::IRCode, bb::Int)
     return false
 end
 
-function conditional_successors_may_throw(lazypostdomtree::LazyPostDomtree, ir::IRCode, bb::Int)
+function visit_conditional_successors(callback, lazypostdomtree::LazyPostDomtree, ir::IRCode, bb::Int)
     visited = BitSet((bb,))
     worklist = Int[bb]
     while !isempty(worklist)
-        thisbb = pop!(worklist)
+        thisbb = popfirst!(worklist)
         for succ in ir.cfg.blocks[thisbb].succs
             succ in visited && continue
             push!(visited, succ)
-            postdominates(get!(lazypostdomtree), succ, thisbb) && continue
-            any_stmt_may_throw(ir, succ) && return true
-            push!(worklist, succ)
+            if postdominates(get!(lazypostdomtree), succ, bb)
+                # this successor is not conditional, so no need to visit it further
+                continue
+            elseif callback(succ)
+                return true
+            else
+                push!(worklist, succ)
+            end
         end
     end
     return false
@@ -833,8 +838,10 @@ function ((; sv)::ScanStmt)(inst::Instruction, lstmt::Int, bb::Int)
             # inconsistent region.
             if !sv.result.ipo_effects.terminates
                 sv.all_retpaths_consistent = false
-            elseif conditional_successors_may_throw(sv.lazypostdomtree, sv.ir, bb)
-                # Check if there are potential throws that require
+            elseif visit_conditional_successors(sv.lazypostdomtree, sv.ir, bb) do succ::Int
+                       return any_stmt_may_throw(sv.ir, succ)
+                   end
+                # check if this `GotoIfNot` leads to conditional throws, which taints consistency
                 sv.all_retpaths_consistent = false
             else
                 (; cfg, domtree) = get!(sv.lazyagdomtree)
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index f5ecb8a0d347c..fa70c8de9d853 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1382,3 +1382,8 @@ let; Base.Experimental.@force_compile; func52843(); end
 # pointerref nothrow for invalid pointer
 @test !Core.Compiler.intrinsic_nothrow(Core.Intrinsics.pointerref, Any[Type{Ptr{Vector{Int64}}}, Int, Int])
 @test !Core.Compiler.intrinsic_nothrow(Core.Intrinsics.pointerref, Any[Type{Ptr{T}} where T, Int, Int])
+
+# post-opt :consistent-cy analysis correctness
+# https://github.com/JuliaLang/julia/issues/53508
+@test !Core.Compiler.is_consistent(Base.infer_effects(getindex, (UnitRange{Int},Int)))
+@test !Core.Compiler.is_consistent(Base.infer_effects(getindex, (Base.OneTo{Int},Int)))
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 3a90ee6308d53..0a53dec80f732 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -238,6 +238,35 @@ let ci = code_lowered(()->@isdefined(_not_def_37919_), ())[1]
     @test Core.Compiler.verify_ir(ir) === nothing
 end
 
+let code = Any[
+        # block 1
+        GotoIfNot(Argument(2), 4),
+        # block 2
+        GotoNode(3),
+        # block 3
+        Expr(:call, throw, "potential throw"),
+        # block 4
+        Expr(:call, Core.Intrinsics.add_int, Argument(3), Argument(4)),
+        GotoNode(6),
+        # block 5
+        ReturnNode(SSAValue(4))
+    ]
+    ir = make_ircode(code; slottypes=Any[Any,Bool,Int,Int])
+    lazypostdomtree = Core.Compiler.LazyPostDomtree(ir)
+    visited = BitSet()
+    @test !Core.Compiler.visit_conditional_successors(lazypostdomtree, ir, #=bb=#1) do succ::Int
+        push!(visited, succ)
+        return false
+    end
+    @test 2 ∈ visited
+    @test 3 ∈ visited
+    @test 4 ∉ visited
+    @test 5 ∉ visited
+    oc = Core.OpaqueClosure(ir)
+    @test oc(false, 1, 1) == 2
+    @test_throws "potential throw" oc(true, 1, 1)
+end
+
 # Test dynamic update of domtree with edge insertions and deletions in the
 # following CFG:
 #

From 95f54c4dcb58e4f15f53f8a13a930db8e035ea89 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 29 Feb 2024 21:38:38 -0500
Subject: [PATCH 1041/1315] fix InteractiveUtils call in Base.runtests on
 failure (#53525)

Noticed in CI that `Base.runtests(["fail"])` fails here instead of
throwing the correct error later, since #53326.
---
 base/util.jl | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/base/util.jl b/base/util.jl
index 847d89e895af4..c91f04e8baf96 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -694,11 +694,9 @@ function runtests(tests = ["all"]; ncores::Int = ceil(Int, Sys.CPU_THREADS / 2),
         nothing
     catch
         buf = PipeBuffer()
-        original_load_path = copy(Base.LOAD_PATH); empty!(Base.LOAD_PATH); pushfirst!(Base.LOAD_PATH, "@stdlib")
-        let InteractiveUtils = Base.require_stdlib(Base, :InteractiveUtils)
+        let InteractiveUtils = Base.require_stdlib(PkgId(UUID(0xb77e0a4c_d291_57a0_90e8_8db25a27a240), "InteractiveUtils"))
             @invokelatest InteractiveUtils.versioninfo(buf)
         end
-        empty!(Base.LOAD_PATH); append!(Base.LOAD_PATH, original_load_path)
         error("A test has failed. Please submit a bug report (https://github.com/JuliaLang/julia/issues)\n" *
               "including error messages above and the output of versioninfo():\n$(read(buf, String))")
     end

From 136f018e7473e48ebb90ed5bc8dc6ad3dd109d6f Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 1 Mar 2024 00:32:36 -0600
Subject: [PATCH 1042/1315] Allow GlobalRef and module qualified names in macro
 definitions (#53535)

The following is currently an error:
```
julia> module MyMacroModule
           macro mymacro end
       end
Main.MyMacroModule

julia> macro MyMacroModule.mymacro()
           1
       end
ERROR: syntax: invalid macro definition around REPL[2]:1
Stacktrace:
 [1] top-level scope
   @ REPL[2]:1
```

Discussing with Jeff, we didn't think there was any good reason not to
allow this, just a missing case in lowering. It's probably not
particularly useful (unlike the corresponding case for functions that is
used all the time), but it came up in writing a test case for #53515.
---
 src/julia-parser.scm | 12 ++++++++++--
 src/julia-syntax.scm | 11 +++++++----
 test/syntax.jl       | 13 +++++++++++++
 3 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index fb20717add65d..891a26bb0ea49 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -2610,15 +2610,23 @@
 
 (define (valid-modref? e)
   (and (length= e 3) (eq? (car e) '|.|) (pair? (caddr e))
-       (eq? (car (caddr e)) 'quote) (symbol? (cadr (caddr e)))
+       (or (eq? (car (caddr e)) 'quote)
+           (eq? (car (caddr e)) 'inert))
+       (symbol? (cadr (caddr e)))
        (or (symbol? (cadr e))
            (valid-modref? (cadr e)))))
 
 (define (macroify-name e . suffixes)
   (cond ((symbol? e) (symbol (apply string #\@ e suffixes)))
+        ((and (pair? e) (eq? (car e) 'quote))
+         `(quote ,(apply macroify-name (cadr e) suffixes)))
+        ((and (pair? e) (eq? (car e) 'inert))
+         `(inert ,(apply macroify-name (cadr e) suffixes)))
+        ((globalref? e)
+         `(globalref ,(cadr e) ,(apply macroify-name (caddr e) suffixes)))
         ((valid-modref? e)
          `(|.| ,(cadr e)
-               (quote ,(apply macroify-name (cadr (caddr e)) suffixes))))
+               ,(apply macroify-name (caddr e) suffixes)))
         (else (error (string "invalid macro usage \"@(" (deparse e) ")\"" )))))
 
 (define (macroify-call s call startloc)
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 7d9f8711ec714..d3d4f7dfe3a56 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1347,15 +1347,18 @@
                (else (error "invalid let syntax"))))
              (else (error "invalid let syntax")))))))))
 
+(define (valid-macro-def-name? e)
+  (or (symbol? e) (valid-modref? e) (globalref? e)))
+
 (define (expand-macro-def e)
   (cond ((and (pair? (cadr e))
               (eq? (car (cadr e)) 'call)
-              (symbol? (cadr (cadr e))))
+              (valid-macro-def-name? (cadr (cadr e))))
          (let ((anames (remove-empty-parameters (cddr (cadr e)))))
            (if (has-parameters? anames)
                (error "macros cannot accept keyword arguments"))
            (expand-forms
-            `(function (call ,(symbol (string #\@ (cadr (cadr e))))
+            `(function (call ,(macroify-name (cadr (cadr e)))
                              (|::| __source__ (core LineNumberNode))
                              (|::| __module__ (core Module))
                              ,@(map (lambda (v)
@@ -1364,8 +1367,8 @@
                                           v))
                                     anames))
                        ,@(cddr e)))))
-        ((and (length= e 2) (symbol? (cadr e)))
-         (expand-forms `(function ,(symbol (string #\@ (cadr e))))))
+        ((and (length= e 2) (valid-macro-def-name? (cadr e)))
+         (expand-forms `(function ,(macroify-name (cadr e)))))
         (else
          (error "invalid macro definition"))))
 
diff --git a/test/syntax.jl b/test/syntax.jl
index 25d3e7282818a..423d1e3d04bfb 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -3637,3 +3637,16 @@ end
     @test array == [7]
     @test execs == 4
 end
+
+# Allow GlobalRefs in macro definition
+module MyMacroModule
+    macro mymacro end
+end
+macro MyMacroModule.mymacro()
+    1
+end
+@eval macro $(GlobalRef(MyMacroModule, :mymacro))(x)
+    2
+end
+@test (@MyMacroModule.mymacro) == 1
+@test (@MyMacroModule.mymacro(a)) == 2

From 0918cf12d549a53da02265ec1005aec7fce87e5f Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 1 Mar 2024 00:34:00 -0600
Subject: [PATCH 1043/1315] Allow sysimage build without the doc system
 (#53533)

The earliest bootstrapping code has a definition of `atdoc` that is just
supposed to ignore the doc string and pass the defining code through.
This function is then replaced by the actual docsystem once that is
available. For testing, I wanted to build the whole system image without
the doc system using this boostrap definition. However, this turns out
not to be possible, because there's a few doc syntax semantics that do
not actually just ignore the doc string.

In particular:
```
"""
I am a doc for a particular signature
"""
foo(x::Int, y::Float64)
```

Does not acutally result in a call to `foo`.

And similarly

```
"""
I am a doc for a global binding
"""
MyModule.foo
```

Does not require `MyModule.foo` to actually have a value, since it only
documents the binding.

This PR allows both of those cases in the boostrap version of `atdoc` so
that we can bootstrap without the doc system if we wanted to.
---
 base/boot.jl  | 13 +++++++++++--
 base/shell.jl |  6 +++---
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index f8ed86b0fb6b7..e041488cdb74c 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -648,8 +648,17 @@ end
 macro __doc__(x)
     return Expr(:escape, Expr(:block, Expr(:meta, :doc), x))
 end
-atdoc     = (source, mod, str, expr) -> Expr(:escape, expr)
-atdoc!(λ) = global atdoc = λ
+
+isbasicdoc(@nospecialize x) = (isa(x, Expr) && x.head === :.) || isa(x, Union{QuoteNode, Symbol})
+iscallexpr(ex::Expr) = (isa(ex, Expr) && ex.head === :where) ? iscallexpr(ex.args[1]) : (isa(ex, Expr) && ex.head === :call)
+iscallexpr(ex) = false
+function ignoredoc(source, mod, str, expr)
+    (isbasicdoc(expr) || iscallexpr(expr)) && return Expr(:escape, nothing)
+    Expr(:escape, expr)
+end
+
+global atdoc = ignoredoc
+atdoc!(λ)    = global atdoc = λ
 
 # macros for big integer syntax
 macro int128_str end
diff --git a/base/shell.jl b/base/shell.jl
index 9f15550a1aa59..137150b585d86 100644
--- a/base/shell.jl
+++ b/base/shell.jl
@@ -4,7 +4,7 @@
 
 const shell_special = "#{}()[]<>|&*?~;"
 
-@doc raw"""
+(@doc raw"""
     rstrip_shell(s::AbstractString)
 
 Strip trailing whitespace from a shell command string, while respecting a trailing backslash followed by a space ("\\ ").
@@ -16,7 +16,7 @@ julia> Base.rstrip_shell("echo 'Hello World' \\ ")
 julia> Base.rstrip_shell("echo 'Hello World'    ")
 "echo 'Hello World'"
 ```
-""" ->
+"""
 function rstrip_shell(s::AbstractString)
     c_old = nothing
     for (i, c) in Iterators.reverse(pairs(s))
@@ -26,7 +26,7 @@ function rstrip_shell(s::AbstractString)
         c_old = c
     end
     SubString(s, 1, 0)
-end
+end)
 
 function shell_parse(str::AbstractString, interpolate::Bool=true;
                      special::AbstractString="", filename="none")

From ac41e2a0d446de8249733d902bb774695c9d61f7 Mon Sep 17 00:00:00 2001
From: Daniel Wennberg <daniel.wennberg@gmail.com>
Date: Fri, 1 Mar 2024 16:24:30 +0100
Subject: [PATCH 1044/1315] Fix `hypot` promotion bug (#53541)

Fixes #53505
---
 base/math.jl |  4 ++--
 test/math.jl | 10 ++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/base/math.jl b/base/math.jl
index 71a4ef9f34882..c3c15505c5f8f 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -817,8 +817,8 @@ true
 ```
 """
 hypot(x::Number) = abs(float(x))
-hypot(x::Number, y::Number) = _hypot(promote(float(x), y)...)
-hypot(x::Number, y::Number, xs::Number...) = _hypot(promote(float(x), y, xs...))
+hypot(x::Number, y::Number) = _hypot(float.(promote(x, y))...)
+hypot(x::Number, y::Number, xs::Number...) = _hypot(float.(promote(x, y, xs...)))
 function _hypot(x, y)
     # preserves unit
     axu = abs(x)
diff --git a/test/math.jl b/test/math.jl
index f3c6dc5bb103f..f551bb3a5d4b7 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -1355,6 +1355,16 @@ end
     # hypot on Complex returns Real
     @test (@inferred hypot(3, 4im)) === 5.0
     @test (@inferred hypot(3, 4im, 12)) === 13.0
+    @testset "promotion, issue #53505" begin
+        @testset "Int,$T" for T in (Float16, Float32, Float64, BigFloat)
+            for args in ((3, 4), (3, 4, 12))
+                for i in eachindex(args)
+                    targs = ntuple(j -> (j == i) ? T(args[j]) : args[j], length(args))
+                    @test (@inferred hypot(targs...)) isa float(eltype(promote(targs...)))
+                end
+            end
+        end
+    end
 end
 
 struct BadFloatWrapper <: AbstractFloat

From c703a1781543e7e82db981a1e49df8c7c6fe5dbb Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Fri, 1 Mar 2024 11:58:09 -0600
Subject: [PATCH 1045/1315] Update package naming guidelines to encourage
 consideration of the global namespace (#53514)

Co-authored-by: Daniel Wennberg <daniel.wennberg@gmail.com>
Co-authored-by: Matt Bauman <mbauman@juliahub.com>
---
 doc/src/tutorials/creating-packages.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/doc/src/tutorials/creating-packages.md b/doc/src/tutorials/creating-packages.md
index d1f79e8c88a9d..bd5c9b32d34b3 100644
--- a/doc/src/tutorials/creating-packages.md
+++ b/doc/src/tutorials/creating-packages.md
@@ -605,9 +605,22 @@ may fit your package better.
 
      * `CPLEX.jl` wraps the `CPLEX` library, which can be identified easily in a web search.
      * `MATLAB.jl` provides an interface to call the MATLAB engine from within Julia.
+
 7. Avoid naming a package closely to an existing package
      * `Websocket` is too close to `WebSockets` and can be confusing to users. Rather use a new name such as `SimpleWebsockets`.
 
+8. Avoid using a distinctive name that is already in use in a well known, unrelated project.
+     * Don't use the names `Tkinter.jl`, `TkinterGUI.jl`, etc. for a package that is unrelated
+       to the popular `tkinter` python package, even if it provides bindings to Tcl/Tk.
+       A package name of `Tkinter.jl` would only be appropriate if the package used Python's
+       library to accomplish its work or was spearheaded by the same community of developers.
+     * It's okay to name a package `HTTP.jl` even though it is unrelated to the popular rust
+       crate `http` because in most usages the name "http" refers to the hypertext transfer
+       protocol, not to the `http` rust crate.
+     * It's okay to name a package `OpenSSL.jl` if it provides an interface to the OpenSSL
+       library, even without explicit affiliation with the creators of the OpenSSL (provided
+       there's no copyright or trademark infringement etc.)
+
 ## Registering packages
 
 Once a package is ready it can be registered with the [General Registry](https://github.com/JuliaRegistries/General#registering-a-package-in-general) (see also the [FAQ](https://github.com/JuliaRegistries/General#faq)).

From 188e386e090fb83e89fb527d68fd23afee94c3b2 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 1 Mar 2024 18:03:41 -0500
Subject: [PATCH 1046/1315] use more efficient `_readdirx` for tab completion
 (#53540)

Fixes https://github.com/JuliaLang/julia/issues/53153
---
 stdlib/REPL/src/REPLCompletions.jl | 35 +++++++++++++++---------------
 stdlib/REPL/src/docview.jl         |  8 ++++---
 2 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index 609825b772d47..5ffa718f38604 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -8,6 +8,7 @@ using Core: Const
 const CC = Core.Compiler
 using Base.Meta
 using Base: propertynames, something, IdSet
+using Base.Filesystem: _readdirx
 
 abstract type Completion end
 
@@ -317,8 +318,8 @@ function cache_PATH()
             continue
         end
 
-        filesinpath = try
-            readdir(pathdir)
+        path_entries = try
+            _readdirx(pathdir)
         catch e
             # Bash allows dirs in PATH that can't be read, so we should as well.
             if isa(e, Base.IOError) || isa(e, Base.ArgumentError)
@@ -328,13 +329,13 @@ function cache_PATH()
                 rethrow()
             end
         end
-        for file in filesinpath
+        for entry in path_entries
             # In a perfect world, we would filter on whether the file is executable
             # here, or even on whether the current user can execute the file in question.
             try
-                if isfile(joinpath(pathdir, file))
-                    @lock PATH_cache_lock push!(PATH_cache, file)
-                    push!(this_PATH_cache, file)
+                if isfile(entry)
+                    @lock PATH_cache_lock push!(PATH_cache, entry.name)
+                    push!(this_PATH_cache, entry.name)
                 end
             catch e
                 # `isfile()` can throw in rare cases such as when probing a
@@ -378,11 +379,11 @@ function complete_path(path::AbstractString;
     else
         dir, prefix = splitdir(path)
     end
-    files = try
+    entries = try
         if isempty(dir)
-            readdir()
+            _readdirx()
         elseif isdir(dir)
-            readdir(dir)
+            _readdirx(dir)
         else
             return Completion[], dir, false
         end
@@ -392,11 +393,10 @@ function complete_path(path::AbstractString;
     end
 
     matches = Set{String}()
-    for file in files
-        if startswith(file, prefix)
-            p = joinpath(dir, file)
-            is_dir = try isdir(p) catch ex; ex isa Base.IOError ? false : rethrow() end
-            push!(matches, is_dir ? file * "/" : file)
+    for entry in entries
+        if startswith(entry.name, prefix)
+            is_dir = try isdir(entry) catch ex; ex isa Base.IOError ? false : rethrow() end
+            push!(matches, is_dir ? entry.name * "/" : entry.name)
         end
     end
 
@@ -1349,14 +1349,15 @@ function completions(string::String, pos::Int, context_module::Module=Main, shif
                     append!(suggestions, project_deps_get_completion_candidates(s, dir))
                 end
                 isdir(dir) || continue
-                for pname in readdir(dir)
+                for entry in _readdirx(dir)
+                    pname = entry.name
                     if pname[1] != '.' && pname != "METADATA" &&
                         pname != "REQUIRE" && startswith(pname, s)
                         # Valid file paths are
                         #   <Mod>.jl
                         #   <Mod>/src/<Mod>.jl
                         #   <Mod>.jl/src/<Mod>.jl
-                        if isfile(joinpath(dir, pname))
+                        if isfile(entry)
                             endswith(pname, ".jl") && push!(suggestions,
                                                             PackageCompletion(pname[1:prevind(pname, end-2)]))
                         else
@@ -1365,7 +1366,7 @@ function completions(string::String, pos::Int, context_module::Module=Main, shif
                             else
                                 pname
                             end
-                            if isfile(joinpath(dir, pname, "src",
+                            if isfile(joinpath(entry, "src",
                                                "$mod_name.jl"))
                                 push!(suggestions, PackageCompletion(mod_name))
                             end
diff --git a/stdlib/REPL/src/docview.jl b/stdlib/REPL/src/docview.jl
index 79cc6b48d2f4d..feeeecbd97165 100644
--- a/stdlib/REPL/src/docview.jl
+++ b/stdlib/REPL/src/docview.jl
@@ -11,6 +11,8 @@ import Base.Docs: doc, formatdoc, parsedoc, apropos
 
 using Base: with_output_color, mapany, isdeprecated, isexported
 
+using Base.Filesystem: _readdirx
+
 import REPL
 
 using InteractiveUtils: subtypes
@@ -379,9 +381,9 @@ function find_readme(m::Module)::Union{String, Nothing}
     path = dirname(mpath)
     top_path = pkgdir(m)
     while true
-        for file in readdir(path; join=true, sort=true)
-            isfile(file) && (basename(lowercase(file)) in ["readme.md", "readme"]) || continue
-            return file
+        for entry in _readdirx(path; sort=true)
+            isfile(entry) && (lowercase(entry.name) in ["readme.md", "readme"]) || continue
+            return entry.path
         end
         path == top_path && break # go no further than pkgdir
         path = dirname(path) # work up through nested modules

From 2b9595601e6e81b0c81376d7942497af22e222dd Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 1 Mar 2024 18:04:35 -0500
Subject: [PATCH 1047/1315] use `_readdirx` for `walkdir` (#53545)

On a M2 Mac there is some benefit, but assumed to be much greater on
slower filesystems.
```
# master
julia> @btime collect(walkdir(expanduser("~/Downloads")));
  380.086 ms (310696 allocations: 25.29 MiB)

# This PR
julia> @btime collect(walkdir(expanduser("~/Downloads")));
  289.747 ms (103300 allocations: 7.50 MiB)
```

The implementations appear to produce the same result
```
julia> collect(walkdir(expanduser("~/Downloads"))) == collect(walkdirx(expanduser("~/Downloads")))
true
```
---
 base/file.jl | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/base/file.jl b/base/file.jl
index 659c39d7415f8..b7adb8e1a3fbd 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -1089,18 +1089,16 @@ function walkdir(root; topdown=true, follow_symlinks=false, onerror=throw)
                 end
                 return
             end
-        content = tryf(readdir, root)
-        content === nothing && return
-        dirs = Vector{eltype(content)}()
-        files = Vector{eltype(content)}()
-        for name in content
-            path = joinpath(root, name)
-
+        entries = tryf(_readdirx, root)
+        entries === nothing && return
+        dirs = Vector{String}()
+        files = Vector{String}()
+        for entry in entries
             # If we're not following symlinks, then treat all symlinks as files
-            if (!follow_symlinks && something(tryf(islink, path), true)) || !something(tryf(isdir, path), false)
-                push!(files, name)
+            if (!follow_symlinks && something(tryf(islink, entry), true)) || !something(tryf(isdir, entry), false)
+                push!(files, entry.name)
             else
-                push!(dirs, name)
+                push!(dirs, entry.name)
             end
         end
 

From 8bf6a073a2bec5c015a8da3a8d5bb22d129d15ca Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sat, 2 Mar 2024 11:49:08 -0500
Subject: [PATCH 1048/1315] revert "Add @create_log_macro for making custom
 styled logging macros (#52196)" (#53551)

---
 HISTORY.md                          |  3 ---
 base/logging.jl                     | 18 ++++++---------
 stdlib/Logging/docs/src/index.md    | 14 +-----------
 stdlib/Logging/src/ConsoleLogger.jl |  1 -
 stdlib/Logging/src/Logging.jl       | 35 -----------------------------
 stdlib/Logging/test/runtests.jl     | 20 +++++------------
 6 files changed, 14 insertions(+), 77 deletions(-)

diff --git a/HISTORY.md b/HISTORY.md
index cdcbe01481ba6..3eaec3c6d0774 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -148,9 +148,6 @@ Standard library changes
 * `lu` and `issuccess(::LU)` now accept an `allowsingular` keyword argument. When set to `true`, a valid factorization with rank-deficient U factor will be treated as success instead of throwing an error. Such factorizations are now shown by printing the factors together with a "rank-deficient" note rather than printing a "Failed Factorization" message ([#52957]).
 
 #### Logging
-* New `@create_log_macro` macro for creating new log macros like `@info`, `@warn` etc. For instance
-  `@create_log_macro MyLog 1500 :magenta` will create `@mylog` to be used like `@mylog "hello"` which
-  will show as `┌ MyLog: hello` etc. ([#52196])
 
 #### Printf
 
diff --git a/base/logging.jl b/base/logging.jl
index d0f612c31eeae..bef8a89118371 100644
--- a/base/logging.jl
+++ b/base/logging.jl
@@ -172,18 +172,14 @@ const AboveMaxLevel = LogLevel( 1000001)
 # Global log limiting mechanism for super fast but inflexible global log limiting.
 const _min_enabled_level = Ref{LogLevel}(Debug)
 
-# stored as LogLevel => (name, color)
-const custom_log_levels = Dict{LogLevel,Tuple{Symbol,Union{Symbol,Int}}}()
-
 function show(io::IO, level::LogLevel)
-    if     haskey(custom_log_levels, level) print(io, custom_log_levels[level][1])
-    elseif level == BelowMinLevel           print(io, "BelowMinLevel")
-    elseif level == Debug                   print(io, "Debug")
-    elseif level == Info                    print(io, "Info")
-    elseif level == Warn                    print(io, "Warn")
-    elseif level == Error                   print(io, "Error")
-    elseif level == AboveMaxLevel           print(io, "AboveMaxLevel")
-    else                                    print(io, "LogLevel($(level.level))")
+    if     level == BelowMinLevel  print(io, "BelowMinLevel")
+    elseif level == Debug          print(io, "Debug")
+    elseif level == Info           print(io, "Info")
+    elseif level == Warn           print(io, "Warn")
+    elseif level == Error          print(io, "Error")
+    elseif level == AboveMaxLevel  print(io, "AboveMaxLevel")
+    else                           print(io, "LogLevel($(level.level))")
     end
 end
 
diff --git a/stdlib/Logging/docs/src/index.md b/stdlib/Logging/docs/src/index.md
index 6d0af3ac21321..c2bde11720f4c 100644
--- a/stdlib/Logging/docs/src/index.md
+++ b/stdlib/Logging/docs/src/index.md
@@ -62,7 +62,7 @@ automatically extracted. Let's examine the user-defined data first:
 * The *log level* is a broad category for the message that is used for early
   filtering. There are several standard levels of type [`LogLevel`](@ref);
   user-defined levels are also possible.
-  Each built-in log level is distinct in purpose:
+  Each is distinct in purpose:
   - [`Logging.Debug`](@ref) (log level -1000) is information intended for the developer of
     the program. These events are disabled by default.
   - [`Logging.Info`](@ref) (log level 0) is for general information to the user.
@@ -74,17 +74,6 @@ automatically extracted. Let's examine the user-defined data first:
     Often this log-level is unneeded as throwing an exception can convey
     all the required information.
 
-    You can create logging macros for custom log levels. For instance:
-    ```julia-repl
-    julia> using Logging
-
-    julia> @create_log_macro MyLog 200 :magenta
-    @mylog (macro with 1 method)
-
-    julia> @mylog "hello"
-    [ MyLog: hello
-    ```
-
 * The *message*  is an object describing the event. By convention
   `AbstractString`s passed as messages are assumed to be in markdown format.
   Other types will be displayed using `print(io, obj)` or `string(obj)` for
@@ -315,7 +304,6 @@ Logging.Warn
 Logging.Error
 Logging.BelowMinLevel
 Logging.AboveMaxLevel
-Logging.@create_log_macro
 ```
 
 ### [Processing events with AbstractLogger](@id AbstractLogger-interface)
diff --git a/stdlib/Logging/src/ConsoleLogger.jl b/stdlib/Logging/src/ConsoleLogger.jl
index 2950ad1b8cf95..08e4a8c6b2efe 100644
--- a/stdlib/Logging/src/ConsoleLogger.jl
+++ b/stdlib/Logging/src/ConsoleLogger.jl
@@ -58,7 +58,6 @@ end
 showvalue(io, ex::Exception) = showerror(io, ex)
 
 function default_logcolor(level::LogLevel)
-    level in keys(custom_log_levels) ? custom_log_levels[level][2] :
     level < Info  ? :log_debug :
     level < Warn  ? :log_info  :
     level < Error ? :log_warn  :
diff --git a/stdlib/Logging/src/Logging.jl b/stdlib/Logging/src/Logging.jl
index c05d3b7227c34..3822bde2e630b 100644
--- a/stdlib/Logging/src/Logging.jl
+++ b/stdlib/Logging/src/Logging.jl
@@ -23,7 +23,6 @@ for sym in [
     Symbol("@warn"),
     Symbol("@error"),
     Symbol("@logmsg"),
-    :custom_log_levels,
     :with_logger,
     :current_logger,
     :global_logger,
@@ -32,39 +31,6 @@ for sym in [
     @eval const $sym = Base.CoreLogging.$sym
 end
 
-"""
-    @create_log_macro(name::Symbol, level::Int, face::Union{Symbol, StyledStrings.Face})
-
-Creates a custom log macro like `@info`, `@warn` etc. with a given `name`,
-`level` to be displayed with `face`. The macro created is named with the
-lowercase form of `name` but the given form is used for the printing.
-
-```julia-repl
-julia> @create_log_macro(:MyLog, 200, :magenta)
-@mylog (macro with 1 method)
-
-julia> @mylog "hello"
-[ MyLog: hello
-```
-"""
-macro create_log_macro(name, level, color)
-    macro_name = Symbol(lowercase(string(name)))
-    macro_string = QuoteNode(name)
-    loglevel = LogLevel(level)
-    if loglevel in (BelowMinLevel, Debug, Info, Warn, Error, AboveMaxLevel)
-        throw(ArgumentError("Cannot use the same log level as a built in log macro"))
-    end
-    if haskey(custom_log_levels, loglevel)
-        throw(ArgumentError("Custom log macro already exists for given log level"))
-    end
-    quote
-        $(custom_log_levels)[$(esc(loglevel))] = ($(macro_string), $(esc(color)))
-        macro $(esc(macro_name))(exs...)
-            $(Base.CoreLogging.logmsg_code)(($(Base.CoreLogging.@_sourceinfo))..., $(esc(loglevel)), exs...)
-        end
-    end
-end
-
 # LogLevel aliases (re-)documented here (JuliaLang/julia#40978)
 """
     Debug
@@ -115,7 +81,6 @@ export
     @warn,
     @error,
     @logmsg,
-    @create_log_macro,
     with_logger,
     current_logger,
     global_logger,
diff --git a/stdlib/Logging/test/runtests.jl b/stdlib/Logging/test/runtests.jl
index 57866ff0a18d2..a244facee3468 100644
--- a/stdlib/Logging/test/runtests.jl
+++ b/stdlib/Logging/test/runtests.jl
@@ -7,8 +7,8 @@ import Logging: min_enabled_level, shouldlog, handle_message
 @noinline func1() = backtrace()
 
 # see "custom log macro" testset
-@create_log_macro CustomLog1 -500 :magenta
-@create_log_macro CustomLog2 1500 1
+CustomLog = LogLevel(-500)
+macro customlog(exs...) Base.CoreLogging.logmsg_code((Base.CoreLogging.@_sourceinfo)..., esc(CustomLog), exs...) end
 
 @testset "Logging" begin
 
@@ -289,24 +289,16 @@ end
 end
 
 @testset "custom log macro" begin
-    llevel = LogLevel(-500)
-
-    @test_logs (llevel, "foo") min_level=llevel @customlog1 "foo"
+    @test_logs (CustomLog, "a") min_level=CustomLog @customlog "a"
 
     buf = IOBuffer()
     io = IOContext(buf, :displaysize=>(30,80), :color=>false)
-    logger = ConsoleLogger(io, llevel)
-
-    with_logger(logger) do
-        @customlog1 "foo"
-    end
-    @test occursin("CustomLog1: foo", String(take!(buf)))
-
+    logger = ConsoleLogger(io, CustomLog)
 
     with_logger(logger) do
-        @customlog2 "hello"
+        @customlog "a"
     end
-    @test occursin("CustomLog2: hello", String(take!(buf)))
+    @test occursin("LogLevel(-500): a", String(take!(buf)))
 end
 
 @testset "Docstrings" begin

From e3b2462ec925a8d445db0386a47429e8410de36e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateus=20Ara=C3=BAjo?= <maltusan@gmail.com>
Date: Sat, 2 Mar 2024 20:02:45 +0100
Subject: [PATCH 1049/1315] fix number of chunks (#53413)

The manual claims that `a` is split into `nthreads()` chunks, but this
is not true in general. As it was you could get an error, if `length(a)
< nthreads()`, or a number of chunks larger than `nthreads()`, if
`nthreads()` is smaller than `length(a)` but does not divide it. With
`cld`, on the other hand, you always get at most `nthreads()` chunks.
---
 doc/src/manual/multi-threading.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/src/manual/multi-threading.md b/doc/src/manual/multi-threading.md
index dd02da8798f06..d16407efc3dcf 100644
--- a/doc/src/manual/multi-threading.md
+++ b/doc/src/manual/multi-threading.md
@@ -227,11 +227,11 @@ julia> sum_multi_bad(1:1_000_000)
 Note that the result is not `500000500000` as it should be, and will most likely change each evaluation.
 
 To fix this, buffers that are specific to the task may be used to segment the sum into chunks that are race-free.
-Here `sum_single` is reused, with its own internal buffer `s`. The input vector `a` is split into `nthreads()`
+Here `sum_single` is reused, with its own internal buffer `s`. The input vector `a` is split into at most `nthreads()`
 chunks for parallel work. We then use `Threads.@spawn` to create tasks that individually sum each chunk. Finally, we sum the results from each task using `sum_single` again:
 ```julia-repl
 julia> function sum_multi_good(a)
-           chunks = Iterators.partition(a, length(a) ÷ Threads.nthreads())
+           chunks = Iterators.partition(a, cld(length(a), Threads.nthreads()))
            tasks = map(chunks) do chunk
                Threads.@spawn sum_single(chunk)
            end

From 86f5b218ca8c99e9eea6b23208e6bd5569f8b504 Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Sun, 3 Mar 2024 02:16:23 +0100
Subject: [PATCH 1050/1315] Make dump print `const` before const fields
 (#53492)

This provides more information to the user when dumping types, and also
makes the output of dump slightly more similar to the type definition
syntax.

EDIT: This has been changed to print:
* The kind of type before the type name `abstract type`, `mutable
struct`, etc.
* `const` only for `const` fields of `mutable struct`

New behaviour
```
julia> dump(Float32)
primitive type Float32 <: AbstractFloat

julia> dump(Signed)
abstract type Signed <: Integer

julia> dump(Pair{Int, String})
struct Pair{Int64, String} <: Any
  first::Int64
  second::String

julia> dump(BitSet)
mutable struct BitSet <: AbstractSet{Int64}
  const bits::Vector{UInt64}
  offset::Int64

julia> dump(Set)
UnionAll
  var: TypeVar
    name: Symbol T
    lb: Union{}
    ub: abstract type Any
  body: struct Set{T} <: AbstractSet{T}
    dict::Dict{T, Nothing}
```

---------

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
---
 base/show.jl             |  11 +++-
 doc/src/devdocs/types.md |  12 ++---
 test/show.jl             | 108 +++++++++++++++++++--------------------
 3 files changed, 70 insertions(+), 61 deletions(-)

diff --git a/base/show.jl b/base/show.jl
index 217b22ab39ef8..df429830b16fd 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -2986,6 +2986,13 @@ end
 
 # Types
 function dump(io::IOContext, x::DataType, n::Int, indent)
+    # For some reason, tuples are structs
+    is_struct = isstructtype(x) && !(x <: Tuple)
+    is_mut = is_struct && ismutabletype(x)
+    is_mut && print(io, "mutable ")
+    is_struct && print(io, "struct ")
+    isprimitivetype(x) && print(io, "primitive type ")
+    isabstracttype(x) && print(io, "abstract type ")
     print(io, x)
     if x !== Any
         print(io, " <: ", supertype(x))
@@ -3007,7 +3014,9 @@ function dump(io::IOContext, x::DataType, n::Int, indent)
         fieldtypes = datatype_fieldtypes(x)
         for idx in 1:length(fields)
             println(io)
-            print(io, indent, "  ", fields[idx])
+            print(io, indent, "  ")
+            is_mut && isconst(x, idx) && print(io, "const ")
+            print(io, fields[idx])
             if isassigned(fieldtypes, idx)
                 print(io, "::")
                 print(tvar_io, fieldtypes[idx])
diff --git a/doc/src/devdocs/types.md b/doc/src/devdocs/types.md
index 120c948c6cadc..7a5ede63b1989 100644
--- a/doc/src/devdocs/types.md
+++ b/doc/src/devdocs/types.md
@@ -93,13 +93,13 @@ UnionAll
   var: TypeVar
     name: Symbol T
     lb: Union{}
-    ub: Any
+    ub: abstract type Any
   body: UnionAll
     var: TypeVar
       name: Symbol N
       lb: Union{}
-      ub: Any
-    body: Array{T, N} <: DenseArray{T, N}
+      ub: abstract type Any
+    body: mutable struct Array{T, N} <: DenseArray{T, N}
       ref::MemoryRef{T}
       size::NTuple{N, Int64}
 ```
@@ -181,13 +181,13 @@ TypeName
     var: TypeVar
       name: Symbol T
       lb: Union{}
-      ub: Any
+      ub: abstract type Any
     body: UnionAll
       var: TypeVar
         name: Symbol N
         lb: Union{}
-        ub: Any
-      body: Array{T, N} <: DenseArray{T, N}
+        ub: abstract type Any
+      body: mutable struct Array{T, N} <: DenseArray{T, N}
   cache: SimpleVector
     ...
 
diff --git a/test/show.jl b/test/show.jl
index 064ae76b6fe1f..8d6b32a3fd663 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -703,7 +703,7 @@ let oldout = stdout, olderr = stderr
         redirect_stderr(olderr)
         close(wrout)
         close(wrerr)
-        @test fetch(out) == "Int64 <: Signed\nTESTA\nTESTB\nΑ1Β2\"A\"\nA\n123\"C\"\n"
+        @test fetch(out) == "primitive type Int64 <: Signed\nTESTA\nTESTB\nΑ1Β2\"A\"\nA\n123\"C\"\n"
         @test fetch(err) == "TESTA\nTESTB\nΑ1Β2\"A\"\n"
     finally
         redirect_stdout(oldout)
@@ -1259,64 +1259,64 @@ end
     close(s2)
 end
 
-let repr = sprint(dump, :(x = 1))
-    @test repr == "Expr\n  head: Symbol =\n  args: Array{Any}((2,))\n    1: Symbol x\n    2: $Int 1\n"
-end
-let repr = sprint(dump, Pair{String,Int64})
-    @test repr == "Pair{String, Int64} <: Any\n  first::String\n  second::Int64\n"
-end
-let repr = sprint(dump, Tuple)
-    @test repr == "Tuple <: Any\n"
-end
-let repr = sprint(dump, Int64)
-    @test repr == "Int64 <: Signed\n"
-end
-let repr = sprint(dump, Any)
-    @test length(repr) == 4
-    @test occursin(r"^Any\n", repr)
-    @test endswith(repr, '\n')
-end
-let repr = sprint(dump, Integer)
-    @test occursin("Integer <: Real", repr)
-    @test !occursin("Any", repr)
-end
-let repr = sprint(dump, Union{Integer, Float32})
-    @test repr == "Union{Integer, Float32}\n" || repr == "Union{Float32, Integer}\n"
-end
 module M30442
     struct T end
 end
-let repr = sprint(show, Union{String, M30442.T})
-    @test repr == "Union{$(curmod_prefix)M30442.T, String}" ||
-          repr == "Union{String, $(curmod_prefix)M30442.T}"
-end
-let repr = sprint(dump, Ptr{UInt8}(UInt(1)))
-    @test repr == "Ptr{UInt8} @$(Base.repr(UInt(1)))\n"
-end
-let repr = sprint(dump, Core.svec())
-    @test repr == "empty SimpleVector\n"
-end
-let repr = sprint(dump, sin)
-    @test repr == "sin (function of type typeof(sin))\n"
-end
-let repr = sprint(dump, Test)
-    @test repr == "Module Test\n"
-end
-let repr = sprint(dump, nothing)
-    @test repr == "Nothing nothing\n"
-end
-let a = Vector{Any}(undef, 10000)
-    a[2] = "elemA"
-    a[4] = "elemB"
-    a[11] = "elemC"
-    repr = sprint(dump, a; context=(:limit => true), sizehint=0)
-    @test repr == "Array{Any}((10000,))\n  1: #undef\n  2: String \"elemA\"\n  3: #undef\n  4: String \"elemB\"\n  5: #undef\n  ...\n  9996: #undef\n  9997: #undef\n  9998: #undef\n  9999: #undef\n  10000: #undef\n"
-end
-@test occursin("NamedTuple", sprint(dump, NamedTuple))
+@testset "Dump types" begin
+    let repr = sprint(dump, :(x = 1))
+        @test repr == "Expr\n  head: Symbol =\n  args: Array{Any}((2,))\n    1: Symbol x\n    2: $Int 1\n"
+    end
+    let repr = sprint(dump, Pair{String,Int64})
+        @test repr == "struct Pair{String, Int64} <: Any\n  first::String\n  second::Int64\n"
+    end
+    let repr = sprint(dump, Tuple)
+        @test repr == "Tuple <: Any\n"
+    end
+    let repr = sprint(dump, Int64)
+        @test repr == "primitive type Int64 <: Signed\n"
+    end
+    let repr = sprint(dump, Any)
+        @test repr == "abstract type Any\n"
+    end
+    let repr = sprint(dump, Integer)
+        @test occursin("abstract type Integer <: Real", repr)
+        @test !occursin("Any", repr)
+    end
+    let repr = sprint(dump, Union{Integer, Float32})
+        @test repr == "Union{Integer, Float32}\n" || repr == "Union{Float32, Integer}\n"
+    end
 
-# issue 36495, dumping a partial NamedTupled shouldn't error
-@test occursin("NamedTuple", sprint(dump, NamedTuple{(:foo,:bar)}))
+    let repr = sprint(show, Union{String, M30442.T})
+        @test repr == "Union{$(curmod_prefix)M30442.T, String}" ||
+              repr == "Union{String, $(curmod_prefix)M30442.T}"
+    end
+    let repr = sprint(dump, Ptr{UInt8}(UInt(1)))
+        @test repr == "Ptr{UInt8} @$(Base.repr(UInt(1)))\n"
+    end
+    let repr = sprint(dump, Core.svec())
+        @test repr == "empty SimpleVector\n"
+    end
+    let repr = sprint(dump, sin)
+        @test repr == "sin (function of type typeof(sin))\n"
+    end
+    let repr = sprint(dump, Test)
+        @test repr == "Module Test\n"
+    end
+    let repr = sprint(dump, nothing)
+        @test repr == "Nothing nothing\n"
+    end
+    let a = Vector{Any}(undef, 10000)
+        a[2] = "elemA"
+        a[4] = "elemB"
+        a[11] = "elemC"
+        repr = sprint(dump, a; context=(:limit => true), sizehint=0)
+        @test repr == "Array{Any}((10000,))\n  1: #undef\n  2: String \"elemA\"\n  3: #undef\n  4: String \"elemB\"\n  5: #undef\n  ...\n  9996: #undef\n  9997: #undef\n  9998: #undef\n  9999: #undef\n  10000: #undef\n"
+    end
+    @test occursin("NamedTuple", sprint(dump, NamedTuple))
 
+    # issue 36495, dumping a partial NamedTupled shouldn't error
+    @test occursin("NamedTuple", sprint(dump, NamedTuple{(:foo,:bar)}))
+end
 # issue #17338
 @test repr(Core.svec(1, 2)) == "svec(1, 2)"
 

From a586d3cc6b02c7ae72e2161c8674aa3800d8da1f Mon Sep 17 00:00:00 2001
From: Mason Protter <mason.protter@icloud.com>
Date: Sun, 3 Mar 2024 02:16:51 +0100
Subject: [PATCH 1051/1315] Clarify docstring for `zero`, `one`, and `oneunit`.
 (#52107)

spurred by a conversation on Slack where someone was thrown off
wondering why `zero(Vector{Int})` errors, but `zero(Int)` is fine.

---------

Co-authored-by: Sukera <11753998+Seelengrab@users.noreply.github.com>
Co-authored-by: Max Horn <max@quendi.de>
Co-authored-by: Simon Byrne <simonbyrne@gmail.com>
---
 base/number.jl | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/base/number.jl b/base/number.jl
index 923fc907d4038..39908222027c1 100644
--- a/base/number.jl
+++ b/base/number.jl
@@ -287,7 +287,12 @@ map(f, x::Number, ys::Number...) = f(x, ys...)
     zero(x)
     zero(::Type)
 
-Get the additive identity element for the type of `x` (`x` can also specify the type itself).
+Get the additive identity element for `x`. If the additive identity can be deduced
+from the type alone, then a type may be given as an argument to `zero`.
+
+For example, `zero(Int)` will work because the additive identity is the same for all
+instances of `Int`, but `zero(Vector{Int})` is not defined because vectors of different
+lengths have different additive identities.
 
 See also [`iszero`](@ref), [`one`](@ref), [`oneunit`](@ref), [`oftype`](@ref).
 
@@ -314,9 +319,12 @@ zero(::Type{Union{}}, slurp...) = Union{}(0)
     one(T::type)
 
 Return a multiplicative identity for `x`: a value such that
-`one(x)*x == x*one(x) == x`.  Alternatively `one(T)` can
-take a type `T`, in which case `one` returns a multiplicative
-identity for any `x` of type `T`.
+`one(x)*x == x*one(x) == x`. If the multiplicative identity can
+be deduced from the type alone, then a type may be given as
+an argument to `one` (e.g. `one(Int)` will work because the
+multiplicative identity is the same for all instances of `Int`,
+but `one(Matrix{Int})` is not defined because matrices of
+different shapes have different multiplicative identities.)
 
 If possible, `one(x)` returns a value of the same type as `x`,
 and `one(T)` returns a value of type `T`.  However, this may
@@ -354,9 +362,10 @@ one(::Type{Union{}}, slurp...) = Union{}(1)
     oneunit(x::T)
     oneunit(T::Type)
 
-Return `T(one(x))`, where `T` is either the type of the argument or
-(if a type is passed) the argument.  This differs from [`one`](@ref) for
-dimensionful quantities: `one` is dimensionless (a multiplicative identity)
+Return `T(one(x))`, where `T` is either the type of the argument, or
+the argument itself in cases where the `oneunit` can be deduced from
+the type alone. This differs from [`one`](@ref) for dimensionful
+quantities: `one` is dimensionless (a multiplicative identity)
 while `oneunit` is dimensionful (of the same type as `x`, or of type `T`).
 
 # Examples

From e7734ea0889c940c7dc57ba4e4401c93747fb428 Mon Sep 17 00:00:00 2001
From: Abel Soares Siqueira <nepper271@gmail.com>
Date: Sun, 3 Mar 2024 02:23:18 +0100
Subject: [PATCH 1052/1315] Add a GitHub Actions workflow for automatic
 validation of the citation metadata file (`CITATION.CFF`) (#44062)

Hello!

We noticed that your `CITATION.cff` had a small issue and fixed it.

In addition to the fix, this Pull Request automates validation of that
file using the [cffconvert GitHub
Action](https://github.com/marketplace/actions/cffconvert). That way,
it's a little bit easier to be robust against future changes to the
`CITATION.cff` file.

BTW it's perfectly fine if you don't feel like accepting this Pull
Request for whatever reason -- we just thought it might be helpful is
all.

We found your repository using a partially automated workflow; if you
have any questions about that, feel free to create an issue over at
https://github.com/cffbots/filtering/issues/

On behalf of the cffbots team,
@abelsiqueira / @fdiblen / @jspaaks

---------

Co-authored-by: Max Horn <max@quendi.de>
---
 .github/workflows/cffconvert.yml | 33 ++++++++++++++++++++++++++++++++
 CITATION.cff                     |  1 +
 2 files changed, 34 insertions(+)
 create mode 100644 .github/workflows/cffconvert.yml

diff --git a/.github/workflows/cffconvert.yml b/.github/workflows/cffconvert.yml
new file mode 100644
index 0000000000000..751476865ae4c
--- /dev/null
+++ b/.github/workflows/cffconvert.yml
@@ -0,0 +1,33 @@
+name: cffconvert
+
+on:
+  push:
+    branches:
+      - 'master'
+      - 'release-*'
+    paths:
+      - CITATION.cff
+  pull_request:
+    branches:
+      - 'master'
+      - 'release-*'
+    paths:
+      - CITATION.cff
+
+permissions:
+  contents: read
+
+jobs:
+  validate:
+    name: "validate"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out a copy of the repository
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Check whether the citation metadata from CITATION.cff is valid
+        uses: citation-file-format/cffconvert-github-action@2.0.0
+        with:
+          args: "--validate"
diff --git a/CITATION.cff b/CITATION.cff
index c88727bcfa311..878ab94a4d86a 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -1,3 +1,4 @@
+# Official format description at https://citation-file-format.github.io
 cff-version: 1.2.0
 message: "Cite this paper whenever you use Julia"
 authors:

From 0f902bf2f7ea6dcf0955b5dc37f00a2c1447af28 Mon Sep 17 00:00:00 2001
From: Eric Hanson <5846501+ericphanson@users.noreply.github.com>
Date: Sun, 3 Mar 2024 04:14:06 +0100
Subject: [PATCH 1053/1315] Provide better error hint when `UndefVarError`
 results from name clashes (#53469)

We can detect this since we set the `usingfailed` bit when the clash
occurs (to avoid printing the `WARNING` multiple times). In this case,
typos or missing imports (the current message) isn't quite as clear as
it could be, because in fact the name is probably spelled totally right,
it's just that there is a missing explicit import or the name should be
qualified.

This code will stop working if we change the flags in `Core.Binding`,
but the test I added should catch that. However if REPL is supposed to
be independent of Base and not depend on internals there, there could be
an issue. In that case we should probably add an API to Base to inspect
this `usingfailed` bit so we can use it in the REPL.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Alex Arslan <ararslan@comcast.net>
---
 stdlib/REPL/src/REPL.jl  | 11 ++++++++++-
 stdlib/REPL/test/repl.jl | 29 +++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index c5c45dee34a01..bb5915c192b6e 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -44,7 +44,16 @@ function UndefVarError_hint(io::IO, ex::UndefVarError)
                 if C_NULL == owner
                     # No global of this name exists in this module.
                     # This is the common case, so do not print that information.
-                    print(io, "\nSuggestion: check for spelling errors or missing imports.")
+                    # It could be the binding was exported by two modules, which we can detect
+                    # by the `usingfailed` flag in the binding:
+                    if isdefined(bnd, :flags) && Bool(bnd.flags >> 4 & 1) # magic location of the `usingfailed` flag
+                        print(io, "\nHint: It looks like two or more modules export different ",
+                              "bindings with this name, resulting in ambiguity. Try explicitly ",
+                              "importing it from a particular module, or qualifying the name ",
+                              "with the module it should come from.")
+                    else
+                        print(io, "\nSuggestion: check for spelling errors or missing imports.")
+                    end
                     owner = bnd
                 else
                     owner = unsafe_pointer_to_objref(owner)::Core.Binding
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 83df34a056578..12f3f8956122e 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -1696,6 +1696,35 @@ finally
     empty!(Base.Experimental._hint_handlers)
 end
 
+try # test the functionality of `UndefVarError_hint` against import clashes
+    @assert isempty(Base.Experimental._hint_handlers)
+    Base.Experimental.register_error_hint(REPL.UndefVarError_hint, UndefVarError)
+
+    @eval module X
+
+    module A
+    export x
+    x = 1
+    end # A
+
+    module B
+    export x
+    x = 2
+    end # B
+
+    using .A, .B
+
+    end # X
+
+    expected_message = string("\nHint: It looks like two or more modules export different ",
+                              "bindings with this name, resulting in ambiguity. Try explicitly ",
+                              "importing it from a particular module, or qualifying the name ",
+                              "with the module it should come from.")
+    @test_throws expected_message X.x
+finally
+    empty!(Base.Experimental._hint_handlers)
+end
+
 # Hints for tab completes
 
 fake_repl() do stdin_write, stdout_read, repl

From 7179050c81cfcaca75419f4948bf59a025b50469 Mon Sep 17 00:00:00 2001
From: erich-9 <erich-9@gmx.de>
Date: Sun, 3 Mar 2024 04:14:28 +0100
Subject: [PATCH 1054/1315] Always return a value in 1-d circshift! of
 abstractarray.jl (#53554)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Sukera <11753998+Seelengrab@users.noreply.github.com>
Co-authored-by: Mosè Giordano <giordano@users.noreply.github.com>
---
 base/abstractarray.jl | 4 ++--
 test/arrayops.jl      | 8 ++++++++
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index bdbcbe4d081a4..a9431197932dd 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -3656,9 +3656,9 @@ end
 ## 1-d circshift ##
 function circshift!(a::AbstractVector, shift::Integer)
     n = length(a)
-    n == 0 && return
+    n == 0 && return a
     shift = mod(shift, n)
-    shift == 0 && return
+    shift == 0 && return a
     l = lastindex(a)
     reverse!(a, firstindex(a), l-shift)
     reverse!(a, l-shift+1, lastindex(a))
diff --git a/test/arrayops.jl b/test/arrayops.jl
index a07e631e639f9..566dd44b8dcd9 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -797,6 +797,14 @@ end
     oa = OffsetVector(copy(a), -1)
     @test circshift!(oa, 1) === oa
     @test oa == circshift(OffsetVector(a, -1), 1)
+
+    # 1d circshift! (#53554)
+    a = []
+    @test circshift!(a, 1) === a
+    @test circshift!(a, 1) == []
+    a = [1:5;]
+    @test circshift!(a, 10) === a
+    @test circshift!(a, 10) == 1:5
 end
 
 @testset "circcopy" begin

From bc2212cc0e9fd499a4916820c95791273b93fadd Mon Sep 17 00:00:00 2001
From: Alexander Plavin <alexander@plav.in>
Date: Sun, 3 Mar 2024 20:20:49 -0500
Subject: [PATCH 1055/1315] allow convert from RegexMatch to Dict/NamedTuple
 (#50988)

Added implementation + tests, will add to docs if ok

---------

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
Co-authored-by: Jeff Bezanson <jeff.bezanson@gmail.com>
---
 NEWS.md       | 18 ++++++++++++++++++
 base/regex.jl | 24 +++++++++++++++++++++---
 test/regex.jl | 19 +++++++++++++++++++
 3 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 4d312c28ce34e..5684d00875942 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -41,8 +41,26 @@ New library functions
 New library features
 --------------------
 
+* `invmod(n, T)` where `T` is a native integer type now computes the modular inverse of `n` in the modular integer ring that `T` defines ([#52180]).
+* `invmod(n)` is an abbreviation for `invmod(n, typeof(n))` for native integer types ([#52180]).
+* `replace(string, pattern...)` now supports an optional `IO` argument to
+  write the output to a stream rather than returning a string ([#48625]).
+* `sizehint!(s, n)` now supports an optional `shrink` argument to disable shrinking ([#51929]).
+* New function `Docs.hasdoc(module, symbol)` tells whether a name has a docstring ([#52139]).
+* New function `Docs.undocumented_names(module)` returns a module's undocumented public names ([#52413]).
+* Passing an `IOBuffer` as a stdout argument for `Process` spawn now works as
+  expected, synchronized with `wait` or `success`, so a `Base.BufferStream` is
+  no longer required there for correctness to avoid data races ([#52461]).
+* After a process exits, `closewrite` will no longer be automatically called on
+  the stream passed to it. Call `wait` on the process instead to ensure the
+  content is fully written, then call `closewrite` manually to avoid
+  data-races. Or use the callback form of `open` to have all that handled
+  automatically.
+* `@timed` now additionally returns the elapsed compilation and recompilation time ([#52889])
+* `filter` can now act on a `NamedTuple` ([#50795]).
 * `tempname` can now take a suffix string to allow the file name to include a suffix and include that suffix in
   the uniquing checking ([#53474])
+* `RegexMatch` objects can now be used to construct `NamedTuple`s and `Dict`s ([#50988])
 
 Standard library changes
 ------------------------
diff --git a/base/regex.jl b/base/regex.jl
index 5018c9623f7e3..38eb4cc512552 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -188,6 +188,11 @@ Methods that accept a `RegexMatch` object are defined for [`iterate`](@ref),
 [`getindex`](@ref), where keys are the names or numbers of a capture group.
 See [`keys`](@ref keys(::RegexMatch)) for more information.
 
+`Tuple(m)`, `NamedTuple(m)`, and `Dict(m)` can be used to construct more flexible collection types from `RegexMatch` objects.
+
+!!! compat "Julia 1.11"
+    Constructing NamedTuples and Dicts from RegexMatches requires Julia 1.11
+
 # Examples
 ```jldoctest
 julia> m = match(r"(?<hour>\\d+):(?<minute>\\d+)(am|pm)?", "11:30 in the morning")
@@ -210,6 +215,12 @@ julia> hr, min, ampm = m; # destructure capture groups by iteration
 
 julia> hr
 "11"
+
+julia> Dict(m)
+Dict{Any, Union{Nothing, SubString{String}}} with 3 entries:
+  "hour"   => "11"
+  3        => nothing
+  "minute" => "30"
 ```
 """
 struct RegexMatch{S<:AbstractString} <: AbstractMatch
@@ -289,6 +300,9 @@ iterate(m::RegexMatch, args...) = iterate(m.captures, args...)
 length(m::RegexMatch) = length(m.captures)
 eltype(m::RegexMatch) = eltype(m.captures)
 
+NamedTuple(m::RegexMatch) = NamedTuple{Symbol.(Tuple(keys(m)))}(values(m))
+Dict(m::RegexMatch) = Dict(pairs(m))
+
 function occursin(r::Regex, s::AbstractString; offset::Integer=0)
     compile(r)
     return PCRE.exec_r(r.regex, String(s), offset, r.match_options)
@@ -381,9 +395,13 @@ end
     match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])
 
 Search for the first match of the regular expression `r` in `s` and return a [`RegexMatch`](@ref)
-object containing the match, or nothing if the match failed. The matching substring can be
-retrieved by accessing `m.match` and the captured sequences can be retrieved by accessing
-`m.captures` The optional `idx` argument specifies an index at which to start the search.
+object containing the match, or nothing if the match failed.
+The optional `idx` argument specifies an index at which to start the search.
+The matching substring can be retrieved by accessing `m.match`, the captured sequences can be retrieved by accessing `m.captures`.
+The resulting [`RegexMatch`](@ref) object can be used to construct other collections: e.g. `Tuple(m)`, `NamedTuple(m)`.
+
+!!! compat "Julia 1.11"
+    Constructing NamedTuples and Dicts requires Julia 1.11
 
 # Examples
 ```jldoctest
diff --git a/test/regex.jl b/test/regex.jl
index e5f1428527512..a1d0b1b0ed69a 100644
--- a/test/regex.jl
+++ b/test/regex.jl
@@ -101,15 +101,34 @@
         @test haskey(m, 3)
         @test !haskey(m, 44)
         @test (m[1], m[2], m[3]) == ("x", "y", "z")
+        @test Tuple(m) == ("x", "y", "z")
+        @test NamedTuple(m) == (var"1"="x", var"2"="y", var"3"="z")
+        @test Dict(m) == Dict([1=>"x", 2=>"y", 3=>"z"])
         @test sprint(show, m) == "RegexMatch(\"xyz\", 1=\"x\", 2=\"y\", 3=\"z\")"
     end
 
     # Named subpatterns
+    let m = match(r"(?<a>.)(?<c>.)(?<b>.)", "xyz")
+        @test haskey(m, :a)
+        @test haskey(m, "b")
+        @test !haskey(m, "foo")
+        @test (m[:a], m[:c], m["b"]) == ("x", "y", "z")
+        @test Tuple(m) == ("x", "y", "z")
+        @test NamedTuple(m) == (a="x", c="y", b="z")
+        @test Dict(m) == Dict(["a"=>"x", "c"=>"y", "b"=>"z"])
+        @test sprint(show, m) == "RegexMatch(\"xyz\", a=\"x\", c=\"y\", b=\"z\")"
+        @test keys(m) == ["a", "c", "b"]
+    end
+
+    # Named and unnamed subpatterns
     let m = match(r"(?<a>.)(.)(?<b>.)", "xyz")
         @test haskey(m, :a)
         @test haskey(m, "b")
         @test !haskey(m, "foo")
         @test (m[:a], m[2], m["b"]) == ("x", "y", "z")
+        @test Tuple(m) == ("x", "y", "z")
+        @test NamedTuple(m) == (a="x", var"2"="y", b="z")
+        @test Dict(m) == Dict(["a"=>"x", 2=>"y", "b"=>"z"])
         @test sprint(show, m) == "RegexMatch(\"xyz\", a=\"x\", 2=\"y\", b=\"z\")"
         @test keys(m) == ["a", 2, "b"]
     end

From 4d5a20d39f9d142652c6c4ebbfbe1ed09ea1d066 Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Mon, 4 Mar 2024 06:36:24 -0500
Subject: [PATCH 1056/1315] Docs: Change "Packages that wrap external libraries
 or programs should be named after those libraries or programs" to "Packages
 that wrap external libraries or programs can be named after those libraries
 or programs" (#53567)

Before this PR:

> Packages that wrap external libraries or programs should be named
after those libraries or programs.

I think that "should" is a little too strong.

After this PR:

> Packages that wrap external libraries or programs can be named after
those libraries or programs.

## Motivation

This might make it a bit easier to convince package authors that they
can use a longer more descriptive name for their package, instead of
needing to exactly match the name of the underlying software that they
are wrapping.

Suppose for example that someone is making a Julia package to wrap a
piece of software named `HW`. Under the "should be named..." guideline,
this would lead the package author to register a Julia package named
HW.jl. Personally I'd like to encourage longer and more descriptive
names. So, under the "can be named..." guideline, the author won't feel
like the Julia package needs to be named HW.jl, and thus they might be
more amenable to a longer name such as HelloWorld.jl.
---
 doc/src/tutorials/creating-packages.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/tutorials/creating-packages.md b/doc/src/tutorials/creating-packages.md
index bd5c9b32d34b3..52288e5a8924f 100644
--- a/doc/src/tutorials/creating-packages.md
+++ b/doc/src/tutorials/creating-packages.md
@@ -601,7 +601,7 @@ may fit your package better.
        and other packages each implement a unique approach based on a particular design philosophy.
      * In contrast, `SortingAlgorithms` provides a consistent interface to use many well-established
        sorting algorithms.
-6. Packages that wrap external libraries or programs should be named after those libraries or programs.
+6. Packages that wrap external libraries or programs can be named after those libraries or programs.
 
      * `CPLEX.jl` wraps the `CPLEX` library, which can be identified easily in a web search.
      * `MATLAB.jl` provides an interface to call the MATLAB engine from within Julia.

From 973b4ff9abb6e12cada196a9c97a96b358275e16 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Mon, 4 Mar 2024 13:16:28 -0300
Subject: [PATCH 1057/1315] yet more atomics & cache-line fixes on
 work-stealing queue (#53424)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This regression at a large number of GC threads still shows up on a
large aarch64 machine (80-core ARM Neoverse N1).

```
bench = "many_refs.jl"
(gcthreads, threads) = (1, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       3807 │    2826 │      2633 │        193 │          960 │                13 │      892 │         74 │
│  median │       3810 │    2826 │      2633 │        193 │          961 │                15 │      892 │         74 │
│ maximum │       3810 │    2831 │      2638 │        193 │          962 │                27 │      892 │         74 │
│   stdev │          2 │       3 │         3 │          0 │            1 │                 7 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (2, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2455 │    1476 │      1350 │        126 │          488 │                20 │      892 │         60 │
│  median │       2459 │    1478 │      1352 │        126 │          489 │                23 │      892 │         60 │
│ maximum │       2465 │    1479 │      1352 │        126 │          489 │                23 │      893 │         60 │
│   stdev │          5 │       1 │         1 │          0 │            1 │                 2 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (4, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2173 │    1194 │      1115 │         77 │          463 │                18 │      892 │         54 │
│  median │       2187 │    1194 │      1116 │         78 │          463 │                19 │      893 │         55 │
│ maximum │       2217 │    1208 │      1130 │         78 │          463 │                19 │      893 │         55 │
│   stdev │         22 │       8 │         8 │          1 │            0 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (8, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2191 │    1212 │      1149 │         63 │          539 │                19 │      901 │         55 │
│  median │       2199 │    1219 │      1156 │         63 │          540 │                20 │      901 │         55 │
│ maximum │       2201 │    1222 │      1157 │         65 │          540 │                20 │      901 │         56 │
│   stdev │          5 │       5 │         4 │          1 │            1 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (16, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       3897 │    2916 │      2854 │         60 │         1423 │                20 │      902 │         75 │
│  median │       4012 │    3032 │      2972 │         62 │         1491 │                21 │      904 │         75 │
│ maximum │       4026 │    3106 │      3044 │         62 │         1511 │                22 │      904 │         77 │
│   stdev │         70 │      96 │        96 │          1 │           46 │                 1 │        1 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```

This patch seems to improve performance at 16 GC threads though we still
have some negative scaling for this benchmark beyond 8 GC threads
(others seem fine). I didn't test whether this is indeed the optimal
struct layout for the queue in this benchmark.

```
bench = "many_refs.jl"
(gcthreads, threads) = (1, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       3807 │    2822 │      2630 │        193 │          959 │                15 │      892 │         74 │
│  median │       3824 │    2823 │      2630 │        193 │          959 │                15 │      892 │         74 │
│ maximum │       4307 │    3194 │      2974 │        220 │         1086 │                19 │      892 │         74 │
│   stdev │        284 │     215 │       199 │         16 │           74 │                 2 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (2, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2459 │    1476 │      1349 │        126 │          488 │                19 │      892 │         60 │
│  median │       2460 │    1479 │      1352 │        127 │          488 │                21 │      893 │         60 │
│ maximum │       2770 │    1661 │      1526 │        135 │          570 │                22 │      893 │         60 │
│   stdev │        179 │     106 │       101 │          5 │           47 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (4, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2215 │    1233 │      1155 │         77 │          485 │                20 │      892 │         53 │
│  median │       2320 │    1248 │      1171 │         78 │          492 │                21 │      893 │         54 │
│ maximum │       2372 │    1259 │      1176 │         83 │          493 │                22 │      893 │         56 │
│   stdev │         80 │      13 │        11 │          3 │            5 │                 1 │        1 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (8, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2204 │    1220 │      1156 │         64 │          544 │                23 │      901 │         53 │
│  median │       2362 │    1249 │      1181 │         64 │          553 │                23 │      901 │         53 │
│ maximum │       2374 │    1261 │      1196 │         68 │          558 │                25 │      901 │         55 │
│   stdev │         95 │      21 │        20 │          2 │            7 │                 1 │        0 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (16, 1)
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
[ Info: Setting GC memory pressure callback
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2502 │    1519 │      1458 │         62 │          721 │                22 │      902 │         58 │
│  median │       2511 │    1524 │      1461 │         63 │          728 │                23 │      903 │         61 │
│ maximum │       2664 │    1554 │      1486 │         68 │          741 │                25 │      905 │         61 │
│   stdev │         91 │      19 │        16 │          3 │           10 │                 1 │        2 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```
---
 src/work-stealing-queue.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/work-stealing-queue.h b/src/work-stealing-queue.h
index 73c6e34e36de8..9ec283b610e62 100644
--- a/src/work-stealing-queue.h
+++ b/src/work-stealing-queue.h
@@ -3,6 +3,8 @@
 #ifndef WORK_STEALING_QUEUE_H
 #define WORK_STEALING_QUEUE_H
 
+#include <stdalign.h>
+
 #include "julia_atomics.h"
 #include "assert.h"
 
@@ -41,10 +43,10 @@ static inline void free_ws_array(ws_array_t *a)
 }
 
 typedef struct {
-    _Atomic(int64_t) top;
-    char _padding[JL_CACHE_BYTE_ALIGNMENT - sizeof(_Atomic(int64_t))];
-    _Atomic(int64_t) bottom; // put on a separate cache line. conservatively estimate cache line size as 128 bytes
-    _Atomic(ws_array_t *) array;
+    // align to JL_CACHE_BYTE_ALIGNMENT
+    alignas(JL_CACHE_BYTE_ALIGNMENT) _Atomic(int64_t) top;
+    alignas(JL_CACHE_BYTE_ALIGNMENT) _Atomic(int64_t) bottom;
+    alignas(JL_CACHE_BYTE_ALIGNMENT) _Atomic(ws_array_t *) array;
 } ws_queue_t;
 
 static inline ws_array_t *ws_queue_push(ws_queue_t *q, void *elt, int32_t eltsz) JL_NOTSAFEPOINT

From 0311aa4caf461d05fb408de67dafc582e2ada9a0 Mon Sep 17 00:00:00 2001
From: Michael Goerz <mail@michaelgoerz.net>
Date: Mon, 4 Mar 2024 11:34:27 -0500
Subject: [PATCH 1058/1315] Update Documenter to v1.3 for inventory writing
 (#53571)

With the newest Documenter release, the Julia documentation will
automatically have an `objects.inv` file. This file allows any other
project using Documenter with the
[`DocumenterInterLinks`](https://github.com/JuliaDocs/DocumenterInterLinks.jl)
plugin (or any project using
[Sphinx](https://www.sphinx-doc.org/en/master/)) to link directly into
the Julia documentation, e.g., with ```[`Base.sort!`](@extref Julia)```.

See also
https://github.com/JuliaDocs/Documenter.jl/pull/2424#issuecomment-1960025462
and the following comments
---
 doc/Manifest.toml | 39 +++++++++++++++++++++++++++++----------
 doc/make.jl       |  1 +
 2 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/doc/Manifest.toml b/doc/Manifest.toml
index b34942bbddd3a..c55c983402830 100644
--- a/doc/Manifest.toml
+++ b/doc/Manifest.toml
@@ -16,7 +16,7 @@ version = "0.4.4"
 
 [[deps.ArgTools]]
 uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"
-version = "1.1.1"
+version = "1.1.2"
 
 [[deps.Artifacts]]
 uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
@@ -26,6 +26,12 @@ version = "1.11.0"
 uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 version = "1.11.0"
 
+[[deps.CodecZlib]]
+deps = ["TranscodingStreams", "Zlib_jll"]
+git-tree-sha1 = "59939d8a997469ee05c4b4944560a820f9ba0d73"
+uuid = "944b1d66-785c-5afd-91f1-9de20f533193"
+version = "0.7.4"
+
 [[deps.Dates]]
 deps = ["Printf"]
 uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
@@ -38,10 +44,10 @@ uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 version = "0.9.3"
 
 [[deps.Documenter]]
-deps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "LibGit2", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "Test", "Unicode"]
-git-tree-sha1 = "2613dbec8f4748273bbe30ba71fd5cb369966bac"
+deps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "CodecZlib", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "LibGit2", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "TOML", "Test", "Unicode"]
+git-tree-sha1 = "4a40af50e8b24333b9ec6892546d9ca5724228eb"
 uuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
-version = "1.2.1"
+version = "1.3.0"
 
 [[deps.Downloads]]
 deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"]
@@ -106,7 +112,7 @@ version = "0.6.4"
 [[deps.LibCURL_jll]]
 deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
 uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
-version = "8.4.0+0"
+version = "8.6.0+0"
 
 [[deps.LibGit2]]
 deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"]
@@ -116,7 +122,7 @@ version = "1.11.0"
 [[deps.LibGit2_jll]]
 deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"]
 uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"
-version = "1.7.1+0"
+version = "1.7.2+0"
 
 [[deps.LibSSH2_jll]]
 deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
@@ -152,7 +158,7 @@ version = "0.1.2"
 [[deps.MbedTLS_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
-version = "2.28.2+1"
+version = "2.28.6+0"
 
 [[deps.Mmap]]
 uuid = "a63ad114-7e13-5084-954f-fe012c677804"
@@ -160,7 +166,7 @@ version = "1.11.0"
 
 [[deps.MozillaCACerts_jll]]
 uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
-version = "2023.1.10"
+version = "2023.12.12"
 
 [[deps.NetworkOptions]]
 uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
@@ -184,9 +190,13 @@ uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
 version = "2.8.0"
 
 [[deps.Pkg]]
-deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
+deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
 uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 version = "1.11.0"
+weakdeps = ["REPL"]
+
+    [deps.Pkg.extensions]
+    REPLExt = "REPL"
 
 [[deps.PrecompileTools]]
 deps = ["Preferences"]
@@ -251,6 +261,15 @@ deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
 uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 version = "1.11.0"
 
+[[deps.TranscodingStreams]]
+git-tree-sha1 = "54194d92959d8ebaa8e26227dbe3cdefcdcd594f"
+uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
+version = "0.10.3"
+weakdeps = ["Random", "Test"]
+
+    [deps.TranscodingStreams.extensions]
+    TestExt = ["Test", "Random"]
+
 [[deps.UUIDs]]
 deps = ["Random", "SHA"]
 uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
@@ -268,7 +287,7 @@ version = "1.2.13+1"
 [[deps.nghttp2_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
-version = "1.58.0+0"
+version = "1.59.0+0"
 
 [[deps.p7zip_jll]]
 deps = ["Artifacts", "Libdl"]
diff --git a/doc/make.jl b/doc/make.jl
index 1f654649d9237..8dee832bf27b7 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -365,6 +365,7 @@ else
         ansicolor = true,
         size_threshold = 800 * 2^10, # 800 KiB
         size_threshold_warn = 200 * 2^10, # the manual has quite a few large pages, so we warn at 200+ KiB only
+        inventory_version = VERSION,
     )
 end
 

From 144f58b4133ce9f304fc54852ae67366f5fd86b5 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 5 Mar 2024 02:58:28 +0900
Subject: [PATCH 1059/1315] disable irinterp for interpreters with
 `may_optimize(...)=false` (#53580)

As discussed at
<https://github.com/JuliaLang/julia/commit/b8a0a3978ccf163ce8fc371a4882547dc1271d53#commitcomment-139076159>,
currently external abstract interpreter that configures `may_optimize`
to return `false` may end up with the internal error from irinterp since
it fundamentally required optimized IR but it currently assumes that all
sources from cached `CodeInstance`s are optimized.

This commit addresses the issue by incorporating a `may_optimize` check
in `concrete_eval_eligible`, which in turn automatically disables
irinterp for such interpreters. Although there were earlier discussions
suggesting the revival of `codeinfo.inferred::Bool`, this commit does
not need it, and I think this approach maintains the current state more
cleanly.

This should fix the error of `"inference"` benchmarks from
BaseBenchmarks.jl.
---
 base/compiler/abstractinterpretation.jl |  7 ++++++-
 test/compiler/AbstractInterpreter.jl    | 11 +++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 12eb9a03e323b..45f4dea1e46e1 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -897,7 +897,12 @@ function concrete_eval_eligible(interp::AbstractInterpreter,
             add_remark!(interp, sv, "[constprop] Concrete eval disabled for overlayed methods")
         end
         if !any_conditional(arginfo)
-            return :semi_concrete_eval
+            if may_optimize(interp)
+                return :semi_concrete_eval
+            else
+                # disable irinterp if optimization is disabled, since it requires optimized IR
+                add_remark!(interp, sv, "[constprop] Semi-concrete interpretation disabled for non-optimizing interpreter")
+            end
         end
     end
     return :none
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 80288bac486ff..0b78d54803f7f 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -6,6 +6,17 @@ const CC = Core.Compiler
 include("irutils.jl")
 include("newinterp.jl")
 
+# interpreter that performs abstract interpretation only
+# (semi-concrete interpretation should be disabled automatically)
+@newinterp AbsIntOnlyInterp1
+CC.may_optimize(::AbsIntOnlyInterp1) = false
+@test Base.infer_return_type(Base.init_stdio, (Ptr{Cvoid},); interp=AbsIntOnlyInterp1()) >: IO
+
+# it should work even if the interpreter discards inferred source entirely
+@newinterp AbsIntOnlyInterp2
+CC.may_optimize(::AbsIntOnlyInterp2) = false
+CC.transform_result_for_cache(::AbsIntOnlyInterp2, ::Core.MethodInstance, ::CC.WorldRange, ::CC.InferenceResult) = nothing
+@test Base.infer_return_type(Base.init_stdio, (Ptr{Cvoid},); interp=AbsIntOnlyInterp2()) >: IO
 
 # OverlayMethodTable
 # ==================

From 688ae0a58361889feedcff9eeb5ff1e1b710906b Mon Sep 17 00:00:00 2001
From: cui fliter <imcusg@gmail.com>
Date: Tue, 5 Mar 2024 02:09:52 +0800
Subject: [PATCH 1060/1315] remove repetitive code (#53592)

---
 base/broadcast.jl            | 2 +-
 stdlib/Profile/src/Allocs.jl | 2 +-
 stdlib/REPL/src/REPL.jl      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index 90453ccf19aa3..d26613233a271 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -338,7 +338,7 @@ function flatten(bc::Broadcasted)
     # concatenate the nested arguments into {a, b, c, d}
     args = cat_nested(bc)
     # build a tuple of functions `makeargs`. Its elements take
-    # the whole "flat" argument list and and generate the appropriate
+    # the whole "flat" argument list and generate the appropriate
     # input arguments for the broadcasted function `f`, e.g.,
     #          makeargs[1] = ((w, x, y, z)) -> w
     #          makeargs[2] = ((w, x, y, z)) -> g(x, y)
diff --git a/stdlib/Profile/src/Allocs.jl b/stdlib/Profile/src/Allocs.jl
index 59399b1f21bb3..a1cee98871011 100644
--- a/stdlib/Profile/src/Allocs.jl
+++ b/stdlib/Profile/src/Allocs.jl
@@ -40,7 +40,7 @@ end
     Profile.Allocs.@profile [sample_rate=0.1] expr
 
 Profile allocations that happen during `expr`, returning
-both the result and and AllocResults struct.
+both the result and AllocResults struct.
 
 A sample rate of 1.0 will record everything; 0.0 will record nothing.
 
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index bb5915c192b6e..f78f318d268e1 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -962,7 +962,7 @@ end
 
 find_hist_file() = get(ENV, "JULIA_HISTORY",
                        !isempty(DEPOT_PATH) ? joinpath(DEPOT_PATH[1], "logs", "repl_history.jl") :
-                       error("DEPOT_PATH is empty and and ENV[\"JULIA_HISTORY\"] not set."))
+                       error("DEPOT_PATH is empty and ENV[\"JULIA_HISTORY\"] not set."))
 
 backend(r::AbstractREPL) = r.backendref
 

From f66fd47f2daa9a7139f72617d74bbd1efaafd766 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 4 Mar 2024 16:14:08 -0500
Subject: [PATCH 1061/1315] make MethodError for unhandled kwarg more accurate
 (#53500)

Previously it threw this error manually, so it did not have the world
info for this lookup and message to be fully accurate.
---
 base/error.jl     | 2 +-
 base/errorshow.jl | 5 +++--
 test/errorshow.jl | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/base/error.jl b/base/error.jl
index 37ceb39253e38..fc294b3cb3eb0 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -162,7 +162,7 @@ end
 ## keyword arg lowering generates calls to this ##
 function kwerr(kw, args::Vararg{Any,N}) where {N}
     @noinline
-    throw(MethodError(Core.kwcall, (kw, args...)))
+    throw(MethodError(Core.kwcall, (kw, args...), tls_world_age()))
 end
 
 ## system error handling ##
diff --git a/base/errorshow.jl b/base/errorshow.jl
index 1e6a6faaae5df..abc8083f38266 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -327,10 +327,11 @@ function showerror(io::IO, ex::MethodError)
         end
     end
     if ex.world == typemax(UInt) || hasmethod(f, arg_types, world=ex.world)
+        if !isempty(kwargs)
+            print(io, "\nThis method does not support all of the given keyword arguments (and may not support any).")
+        end
         if ex.world == typemax(UInt) || isempty(kwargs)
             print(io, "\nThis error has been manually thrown, explicitly, so the method may exist but be intentionally marked as unimplemented.")
-        else
-            print(io, "\nThis method may not support any keyword arguments.")
         end
     elseif hasmethod(f, arg_types) && !hasmethod(f, arg_types, world=ex.world)
         curworld = get_world_counter()
diff --git a/test/errorshow.jl b/test/errorshow.jl
index d03de54aab496..5d0640601b398 100644
--- a/test/errorshow.jl
+++ b/test/errorshow.jl
@@ -671,7 +671,7 @@ end
 
     str = sprint(Base.showerror, MethodError(Core.kwcall, ((; a=3.0), +, 1.0, 2.0), Base.get_world_counter()))
     @test startswith(str, "MethodError: no method matching +(::Float64, ::Float64; a::Float64)")
-    @test occursin("This method may not support any keyword arguments", str)
+    @test occursin("This method does not support all of the given keyword arguments", str)
 
     @test_throws "MethodError: no method matching kwcall()" Core.kwcall()
 end

From ece8814f7b637e66c0d472b213feb9eccd6a1aea Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 26 Feb 2024 15:06:31 -0500
Subject: [PATCH 1062/1315] codegen: optimize const fields of mutable objects
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

For example, we seek to eliminate the gc frame from this function, as
observed here:

```julia
julia> code_llvm((BitSet,), raw=true) do x; r = x.bits; GC.safepoint(); @inbounds r[1]; end
; Function Signature: var"#3"(Base.BitSet)
;  @ REPL[1]:1 within `#3`
define swiftcc i64 @"julia_#3_494"(ptr nonnull swiftself %pgcstack, ptr noundef nonnull align 8 dereferenceable(16) %"x::BitSet") #0 !dbg !5 {
top:
  call void @llvm.dbg.declare(metadata ptr %"x::BitSet", metadata !21, metadata !DIExpression()), !dbg !22
  %ptls_field = getelementptr inbounds ptr, ptr %pgcstack, i64 2
  %ptls_load = load ptr, ptr %ptls_field, align 8, !tbaa !23
  %0 = getelementptr inbounds ptr, ptr %ptls_load, i64 2
  %safepoint = load ptr, ptr %0, align 8, !tbaa !27
  fence syncscope("singlethread") seq_cst
  %1 = load volatile i64, ptr %safepoint, align 8, !dbg !22
  fence syncscope("singlethread") seq_cst
; ┌ @ Base.jl:49 within `getproperty`
   %"x::BitSet.bits" = load atomic ptr, ptr %"x::BitSet" unordered, align 8, !dbg !29, !tbaa !27, !alias.scope !33, !noalias !36, !nonnull !11, !dereferenceable !41, !align !42
; └
; ┌ @ gcutils.jl:253 within `safepoint`
   %ptls_load4 = load ptr, ptr %ptls_field, align 8, !dbg !43, !tbaa !23
   %2 = getelementptr inbounds ptr, ptr %ptls_load4, i64 2, !dbg !43
   %safepoint5 = load ptr, ptr %2, align 8, !dbg !43, !tbaa !27
   fence syncscope("singlethread") seq_cst, !dbg !43
   %3 = load volatile i64, ptr %safepoint5, align 8, !dbg !43
   fence syncscope("singlethread") seq_cst, !dbg !43
; └
; ┌ @ essentials.jl:892 within `getindex`
   %4 = load ptr, ptr %"x::BitSet.bits", align 8, !dbg !46, !tbaa !49, !alias.scope !52, !noalias !53
   %5 = load i64, ptr %4, align 8, !dbg !46, !tbaa !54, !alias.scope !57, !noalias !58
   ret i64 %5, !dbg !46
; └
}
```
---
 src/cgutils.cpp |  2 ++
 src/codegen.cpp | 72 +++++++++++++++++++++----------------------------
 2 files changed, 32 insertions(+), 42 deletions(-)

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 7bbf7a84a0385..11bf835e30020 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -2664,6 +2664,8 @@ static MDNode *best_field_tbaa(jl_codectx_t &ctx, const jl_cgval_t &strct, jl_da
                 return ctx.tbaa().tbaa_arraysize;
         }
     }
+    if (strct.V && jl_field_isconst(jt, idx) && isa<Argument>(strct.V->stripInBoundsOffsets())) // TODO: we use our isLoadFromConstGV helper here instead instead of just isa<Argument> (but without PhiNode handling)
+        return ctx.tbaa().tbaa_const;
     return tbaa;
 }
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 59c7763350fff..faa9de2762471 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -8267,7 +8267,7 @@ static jl_llvm_functions_t
 
     // step 7. allocate local variables slots
     // must be in the first basic block for the llvm mem2reg pass to work
-    auto allocate_local = [&](jl_varinfo_t &varinfo, jl_sym_t *s) {
+    auto allocate_local = [&ctx, &dbuilder, &debuginfo, topdebugloc, va, debug_enabled, M](jl_varinfo_t &varinfo, jl_sym_t *s, int i) {
         jl_value_t *jt = varinfo.value.typ;
         assert(!varinfo.boxroot); // variables shouldn't have memory locs already
         if (varinfo.value.constant) {
@@ -8275,10 +8275,10 @@ static jl_llvm_functions_t
             alloc_def_flag(ctx, varinfo);
             return;
         }
-        else if (varinfo.isArgument && !(specsig && i == (size_t)ctx.vaSlot)) {
-            // if we can unbox it, just use the input pointer
-            if (i != (size_t)ctx.vaSlot && jl_is_concrete_immutable(jt))
-                return;
+        else if (varinfo.isArgument && (!va || ctx.vaSlot == -1 || i != ctx.vaSlot)) {
+            // just use the input pointer, if we have it
+            // (we will need to attach debuginfo later to it)
+            return;
         }
         else if (jl_is_uniontype(jt)) {
             bool allunbox;
@@ -8289,6 +8289,7 @@ static jl_llvm_functions_t
                 varinfo.value = mark_julia_slot(lv, jt, NULL, ctx.tbaa().tbaa_stack);
                 varinfo.pTIndex = emit_static_alloca(ctx, getInt8Ty(ctx.builder.getContext()));
                 setName(ctx.emission_context, varinfo.pTIndex, "tindex");
+                // TODO: attach debug metadata to this variable
             }
             else if (allunbox) {
                 // all ghost values just need a selector allocated
@@ -8297,6 +8298,7 @@ static jl_llvm_functions_t
                 varinfo.pTIndex = lv;
                 varinfo.value.tbaa = NULL;
                 varinfo.value.isboxed = false;
+                // TODO: attach debug metadata to this variable
             }
             if (lv || allunbox)
                 alloc_def_flag(ctx, varinfo);
@@ -8323,29 +8325,21 @@ static jl_llvm_functions_t
             }
             return;
         }
-        if (!varinfo.isArgument || // always need a slot if the variable is assigned
-            specsig || // for arguments, give them stack slots if they aren't in `argArray` (otherwise, will use that pointer)
-            (va && (int)i == ctx.vaSlot) || // or it's the va arg tuple
-            i == 0) { // or it is the first argument (which isn't in `argArray`)
-            AllocaInst *av = new AllocaInst(ctx.types().T_prjlvalue, M->getDataLayout().getAllocaAddrSpace(),
-                nullptr, Align(sizeof(jl_value_t*)), jl_symbol_name(s), /*InsertBefore*/ctx.topalloca);
-            StoreInst *SI = new StoreInst(Constant::getNullValue(ctx.types().T_prjlvalue), av, false, Align(sizeof(void*)));
-            SI->insertAfter(ctx.topalloca);
-            varinfo.boxroot = av;
-            if (debug_enabled && varinfo.dinfo) {
-                DIExpression *expr;
-                if ((Metadata*)varinfo.dinfo->getType() == debuginfo.jl_pvalue_dillvmt) {
-                    expr = dbuilder.createExpression();
-                }
-                else {
-                    SmallVector<uint64_t, 8> addr;
-                    addr.push_back(llvm::dwarf::DW_OP_deref);
-                    expr = dbuilder.createExpression(addr);
-                }
-                dbuilder.insertDeclare(av, varinfo.dinfo, expr,
-                                            topdebugloc,
-                                ctx.builder.GetInsertBlock());
-            }
+        // otherwise give it a boxroot in this function
+        AllocaInst *av = new AllocaInst(ctx.types().T_prjlvalue, M->getDataLayout().getAllocaAddrSpace(),
+            nullptr, Align(sizeof(jl_value_t*)), jl_symbol_name(s), /*InsertBefore*/ctx.topalloca);
+        StoreInst *SI = new StoreInst(Constant::getNullValue(ctx.types().T_prjlvalue), av, false, Align(sizeof(void*)));
+        SI->insertAfter(ctx.topalloca);
+        varinfo.boxroot = av;
+        if (debug_enabled && varinfo.dinfo) {
+            SmallVector<uint64_t, 1> addr;
+            DIExpression *expr;
+            if ((Metadata*)varinfo.dinfo->getType() != debuginfo.jl_pvalue_dillvmt)
+                addr.push_back(llvm::dwarf::DW_OP_deref);
+            expr = dbuilder.createExpression(addr);
+            dbuilder.insertDeclare(av, varinfo.dinfo, expr,
+                                        topdebugloc,
+                            ctx.builder.GetInsertBlock());
         }
     };
 
@@ -8359,7 +8353,7 @@ static jl_llvm_functions_t
             varinfo.usedUndef = false;
             continue;
         }
-        allocate_local(varinfo, s);
+        allocate_local(varinfo, s, (int)i);
     }
 
     std::map<int, int> upsilon_to_phic;
@@ -8402,7 +8396,7 @@ static jl_llvm_functions_t
                 vi.used = true;
                 vi.isVolatile = true;
                 vi.value = mark_julia_type(ctx, (Value*)NULL, false, typ);
-                allocate_local(vi, jl_symbol("phic"));
+                allocate_local(vi, jl_symbol("phic"), -1);
             }
         }
     }
@@ -8542,7 +8536,7 @@ static jl_llvm_functions_t
                             ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, argPtr, Align(sizeof(void*))),
                             false, vi.value.typ));
                     theArg = mark_julia_type(ctx, load, true, vi.value.typ);
-                    if (debug_enabled && vi.dinfo && !vi.boxroot && !vi.value.V) {
+                    if (debug_enabled && vi.dinfo && !vi.boxroot) {
                         SmallVector<uint64_t, 8> addr;
                         addr.push_back(llvm::dwarf::DW_OP_deref);
                         addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
@@ -8561,21 +8555,15 @@ static jl_llvm_functions_t
                 assert(vi.value.V == NULL && "unexpected variable slot created for argument");
                 // keep track of original (possibly boxed) value to avoid re-boxing or moving
                 vi.value = theArg;
-                if (specsig && theArg.V && debug_enabled && vi.dinfo) {
-                    SmallVector<uint64_t, 8> addr;
-                    Value *parg;
+                if (debug_enabled && vi.dinfo && theArg.V) {
                     if (theArg.ispointer()) {
-                        parg = theArg.V;
-                        if ((Metadata*)vi.dinfo->getType() != debuginfo.jl_pvalue_dillvmt)
-                            addr.push_back(llvm::dwarf::DW_OP_deref);
+                        dbuilder.insertDeclare(theArg.V, vi.dinfo, dbuilder.createExpression(),
+                                               topdebugloc, ctx.builder.GetInsertBlock());
                     }
                     else {
-                        parg = ctx.builder.CreateAlloca(theArg.V->getType(), NULL, jl_symbol_name(s));
-                        ctx.builder.CreateStore(theArg.V, parg);
+                        dbuilder.insertDbgValueIntrinsic(theArg.V, vi.dinfo, dbuilder.createExpression(),
+                                                         topdebugloc, ctx.builder.GetInsertBlock());
                     }
-                    dbuilder.insertDeclare(parg, vi.dinfo, dbuilder.createExpression(addr),
-                                                topdebugloc,
-                                                ctx.builder.GetInsertBlock());
                 }
             }
             else {

From 50114d7a1fce1701cf53dafcfc6bafb193afb2e5 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 26 Feb 2024 15:49:39 -0500
Subject: [PATCH 1063/1315] codegen: optimize const fields of mutable objects
 even more

Make this analysis even stronger, using a function from
llvm-late-gc-lowering.cpp that implements it more aggressively
---
 src/cgutils.cpp | 100 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 99 insertions(+), 1 deletion(-)

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 11bf835e30020..b17b174dd8a8d 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -2644,6 +2644,104 @@ static jl_cgval_t emit_unionload(jl_codectx_t &ctx, Value *addr, Value *ptindex,
     return mark_julia_slot(fsz > 0 ? addr : nullptr, jfty, tindex, tbaa);
 }
 
+static bool isTBAA(MDNode *TBAA, std::initializer_list<const char*> const strset)
+{
+    if (!TBAA)
+        return false;
+    while (TBAA->getNumOperands() > 1) {
+        TBAA = cast<MDNode>(TBAA->getOperand(1).get());
+        auto str = cast<MDString>(TBAA->getOperand(0))->getString();
+        for (auto str2 : strset) {
+            if (str == str2) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+// Check if this is a load from an immutable value. The easiest
+// way to do so is to look at the tbaa and see if it derives from
+// jtbaa_immut.
+static bool isLoadFromImmut(LoadInst *LI)
+{
+    if (LI->getMetadata(LLVMContext::MD_invariant_load))
+        return true;
+    MDNode *TBAA = LI->getMetadata(LLVMContext::MD_tbaa);
+    if (isTBAA(TBAA, {"jtbaa_immut", "jtbaa_const", "jtbaa_datatype", "jtbaa_memoryptr", "jtbaa_memorylen", "jtbaa_memoryown"}))
+        return true;
+    return false;
+}
+
+static bool isConstGV(GlobalVariable *gv)
+{
+    return gv->isConstant() || gv->getMetadata("julia.constgv");
+}
+
+// Check if this is can be traced through constant loads to an constant global
+// or otherwise globally rooted value.
+// Almost all `tbaa_const` loads satisfies this with the exception of
+// task local constants which are constant as far as the code is concerned but aren't
+// global constants. For task local constant `task_local` will be true when this function
+// returns.
+// Unlike this function in llvm-late-gc-lowering, we do not examine PhiNode, as those are not emitted yet
+static bool isLoadFromConstGV(LoadInst *LI);
+static bool isLoadFromConstGV(Value *v)
+{
+    v = v->stripInBoundsOffsets();
+    if (auto LI = dyn_cast<LoadInst>(v))
+        return isLoadFromConstGV(LI);
+    if (auto gv = dyn_cast<GlobalVariable>(v))
+        return isConstGV(gv);
+    // null pointer
+    if (isa<ConstantData>(v))
+        return true;
+    // literal pointers
+    if (auto CE = dyn_cast<ConstantExpr>(v))
+        return (CE->getOpcode() == Instruction::IntToPtr &&
+                isa<ConstantData>(CE->getOperand(0)));
+    if (auto SL = dyn_cast<SelectInst>(v))
+        return (isLoadFromConstGV(SL->getTrueValue()) &&
+                isLoadFromConstGV(SL->getFalseValue()));
+    if (auto call = dyn_cast<CallInst>(v)) {
+        auto callee = call->getCalledFunction();
+        if (callee && callee->getName() == "julia.typeof") {
+            return true;
+        }
+        if (callee && callee->getName() == "julia.get_pgcstack") {
+            return true;
+        }
+        if (callee && callee->getName() == "julia.gc_loaded") {
+            return isLoadFromConstGV(call->getArgOperand(0)) &&
+                   isLoadFromConstGV(call->getArgOperand(1));
+        }
+    }
+    if (isa<Argument>(v)) {
+        return true;
+    }
+    return false;
+}
+
+// The white list implemented here and above in `isLoadFromConstGV(Value*)` should
+// cover all the cases we and LLVM generates.
+static bool isLoadFromConstGV(LoadInst *LI)
+{
+    // We only emit single slot GV in codegen
+    // but LLVM global merging can change the pointer operands to GEPs/bitcasts
+    auto load_base = LI->getPointerOperand()->stripInBoundsOffsets();
+    assert(load_base); // Static analyzer
+    auto gv = dyn_cast<GlobalVariable>(load_base);
+    if (isLoadFromImmut(LI)) {
+        if (gv)
+            return true;
+        return isLoadFromConstGV(load_base);
+    }
+    if (gv)
+        return isConstGV(gv);
+    return false;
+}
+
+
 static MDNode *best_field_tbaa(jl_codectx_t &ctx, const jl_cgval_t &strct, jl_datatype_t *jt, unsigned idx, size_t byte_offset)
 {
     auto tbaa = strct.tbaa;
@@ -2664,7 +2762,7 @@ static MDNode *best_field_tbaa(jl_codectx_t &ctx, const jl_cgval_t &strct, jl_da
                 return ctx.tbaa().tbaa_arraysize;
         }
     }
-    if (strct.V && jl_field_isconst(jt, idx) && isa<Argument>(strct.V->stripInBoundsOffsets())) // TODO: we use our isLoadFromConstGV helper here instead instead of just isa<Argument> (but without PhiNode handling)
+    if (strct.V && jl_field_isconst(jt, idx) && isLoadFromConstGV(strct.V))
         return ctx.tbaa().tbaa_const;
     return tbaa;
 }

From 67451604cf463c912c2325eb5990ad46262468c2 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 5 Mar 2024 02:07:34 +0100
Subject: [PATCH 1064/1315] Move parallel precompilation to Base (#53403)

Parallel precompilation is more or less now required in order to use
somewhat large packages unless you want to wait an obscene long time for
it to complete. Right now, we even start a parallel precompilation on a
package load if we notice that the package you are loading is not
precompiled.

This functionally has typically been implemented in Pkg but with Pkg not
being in the sysimage it becomes a bit awkward because we then need to
load Pkg from Base. The only real reason this functionality has been
implemented in Pkg is that Pkg has some useful features for parsing
environments. Moving precompilation to Base has typically been stalled
on such an environment parser not existing in Base.

However, in https://github.com/JuliaLang/julia/pull/46690 I started
implemented code loading on top of a more up front environment parser
(instead of the "incremental" one that currently exists in `loading.jl`)
and we can retro fit this to be used as the basis of parallel
precompilation. At some later point code loading could be implemented on
top of it but that is for now considered future work.

This PR thus adds the environment parser from the codeloading PR and
implementes the parallel precompilation feature from Pkg on top of it
(instead of on top of the `EnvCache` in Pkg).

Some points to bring up here:

- This copy pastes the progress bar implementation in Pkg into here. It
is probably a bit excessive to use so we can simplify that
significantly.
- Parallel precompilation uses the `FileWatching` module to avoid
different processes trying to precompile the same package concurrently.
Right now, I used grab this from `Base.loaded_modules` relying on it
being in the sysimage.
- This removes the "suspended" functionality from the Pkg precompilation
which does not try to precompile packages if they have "recently" failed
which is unclear how useful it is in practice. This also requires the
Serialization stdlib and uses data structures defined in Pkg so it is
hard to keep when moving this to Base.

---------

Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
---
 base/Base.jl           |   2 +
 base/loading.jl        |  15 +-
 base/precompilation.jl | 948 +++++++++++++++++++++++++++++++++++++++++
 doc/make.jl            |   3 +-
 4 files changed, 960 insertions(+), 8 deletions(-)
 create mode 100644 base/precompilation.jl

diff --git a/base/Base.jl b/base/Base.jl
index 30bc0b91411b8..5375729be55a3 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -543,6 +543,8 @@ if isdefined(Core, :Compiler) && is_primary_base_module
     Docs.loaddocs(Core.Compiler.CoreDocs.DOCS)
 end
 
+include("precompilation.jl")
+
 # finally, now make `include` point to the full version
 for m in methods(include)
     delete_method(m)
diff --git a/base/loading.jl b/base/loading.jl
index e055eb3003c9e..5d56819159e83 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2147,8 +2147,6 @@ end
 
 require(uuidkey::PkgId) = @lock require_lock _require_prelocked(uuidkey)
 
-const REPL_PKGID = PkgId(UUID("3fa0cd96-eef1-5676-8a61-b3b8758bbffb"), "REPL")
-
 function _require_prelocked(uuidkey::PkgId, env=nothing)
     if _require_world_age[] != typemax(UInt)
         Base.invoke_in_world(_require_world_age[], __require_prelocked, uuidkey, env)
@@ -2262,8 +2260,9 @@ function set_pkgorigin_version_path(pkg::PkgId, path::String)
     nothing
 end
 
-# A hook to allow code load to use Pkg.precompile
+# Unused
 const PKG_PRECOMPILE_HOOK = Ref{Function}()
+disable_parallel_precompile::Bool = false
 
 # Returns `nothing` or the new(ish) module
 function _require(pkg::PkgId, env=nothing)
@@ -2284,7 +2283,7 @@ function _require(pkg::PkgId, env=nothing)
         end
         set_pkgorigin_version_path(pkg, path)
 
-        pkg_precompile_attempted = false # being safe to avoid getting stuck in a Pkg.precompile loop
+        parallel_precompile_attempted = false # being safe to avoid getting stuck in a precompilepkgs loop
         reasons = Dict{String,Int}()
         # attempt to load the module file via the precompile cache locations
         if JLOptions().use_compiled_modules != 0
@@ -2314,11 +2313,13 @@ function _require(pkg::PkgId, env=nothing)
 
         if JLOptions().use_compiled_modules == 1
             if !generating_output(#=incremental=#false)
-                if !pkg_precompile_attempted && isinteractive() && isassigned(PKG_PRECOMPILE_HOOK)
-                    pkg_precompile_attempted = true
+                project = active_project()
+                if !generating_output() && !parallel_precompile_attempted && !disable_parallel_precompile && @isdefined(Precompilation) && project !== nothing &&
+                        isfile(project) && project_file_manifest_path(project) !== nothing
+                    parallel_precompile_attempted = true
                     unlock(require_lock)
                     try
-                        @invokelatest PKG_PRECOMPILE_HOOK[](pkg.name, _from_loading = true)
+                        Precompilation.precompilepkgs([pkg.name]; _from_loading=true)
                     finally
                         lock(require_lock)
                     end
diff --git a/base/precompilation.jl b/base/precompilation.jl
new file mode 100644
index 0000000000000..4efd35836a29d
--- /dev/null
+++ b/base/precompilation.jl
@@ -0,0 +1,948 @@
+module Precompilation
+
+using Base: PkgId, UUID, SHA1, parsed_toml, project_file_name_uuid, project_names,
+            project_file_manifest_path, get_deps, preferences_names, isaccessibledir, isfile_casesensitive
+
+# This is currently only used for pkgprecompile but the plan is to use this in code loading in the future
+# see the `kc/codeloading2.0` branch
+struct ExplicitEnv
+    path::String
+    project_deps::Dict{String, UUID} # [deps] in Project.toml
+    project_weakdeps::Dict{String, UUID} # [weakdeps] in Project.toml
+    project_extras::Dict{String, UUID} # [extras] in Project.toml
+    project_extensions::Dict{String, Vector{UUID}} # [exts] in Project.toml
+    deps::Dict{UUID, Vector{UUID}} # all dependencies in Manifest.toml
+    weakdeps::Dict{UUID, Vector{UUID}} # all weak dependencies in Manifest.toml
+    extensions::Dict{UUID, Dict{String, Vector{UUID}}}
+    # Lookup name for a UUID
+    names::Dict{UUID, String}
+    lookup_strategy::Dict{UUID, Union{
+                                      SHA1,     # `git-tree-sha1` entry
+                                      String,   # `path` entry
+                                      Nothing,  # stdlib (no `path` nor `git-tree-sha1`)
+                                      Missing}} # not present in the manifest
+    #prefs::Union{Nothing, Dict{String, Any}}
+    #local_prefs::Union{Nothing, Dict{String, Any}}
+end
+
+function ExplicitEnv(envpath::String=Base.active_project())
+    envpath = abspath(envpath)
+    project_d = parsed_toml(envpath)
+
+    # TODO: Perhaps verify that two packages with the same UUID do not have different names?
+    names = Dict{UUID, String}()
+    project_uuid_to_name = Dict{String, UUID}()
+
+    project_deps = Dict{String, UUID}()
+    project_weakdeps = Dict{String, UUID}()
+    project_extras = Dict{String, UUID}()
+
+    # Collect all direct dependencies of the project
+    for key in ["deps", "weakdeps", "extras"]
+        for (name, _uuid) in get(Dict{String, Any}, project_d, key)::Dict{String, Any}
+            v = key == "deps" ? project_deps :
+                key == "weakdeps" ? project_weakdeps :
+                key == "extras" ? project_extras :
+                error()
+            uuid = UUID(_uuid)
+            v[name] = uuid
+            names[UUID(uuid)] = name
+            project_uuid_to_name[name] = UUID(uuid)
+        end
+    end
+
+    project_extensions = Dict{String, Vector{UUID}}()
+    # Collect all extensions of the project
+    for (name, triggers::Union{String, Vector{String}}) in get(Dict{String, Any}, project_d, "extensions")::Dict{String, Any}
+        if triggers isa String
+            triggers = [triggers]
+        end
+        uuids = UUID[]
+        for trigger in triggers
+            uuid = get(project_uuid_to_name, trigger, nothing)
+            if uuid === nothing
+                error("Trigger $trigger for extension $name not found in project")
+            end
+            push!(uuids, uuid)
+        end
+        project_extensions[name] = uuids
+    end
+
+    # This project might be a package, in that case, that is also a "dependency"
+    # of the project.
+    proj_name = get(project_d, "name", nothing)::Union{String, Nothing}
+    _proj_uuid = get(project_d, "uuid", nothing)::Union{String, Nothing}
+    proj_uuid = _proj_uuid === nothing ? nothing : UUID(_proj_uuid)
+
+    if proj_name !== nothing && proj_uuid !== nothing
+        # TODO: Error on missing uuid?
+        project_deps[proj_name] = UUID(proj_uuid)
+        names[UUID(proj_uuid)] = proj_name
+    end
+
+    manifest = project_file_manifest_path(envpath)
+    manifest_d = manifest === nothing ? Dict{String, Any}() : parsed_toml(manifest)
+
+    # Dependencies in a manifest can either be stored compressed (when name is unique among all packages)
+    # in which case it is a `Vector{String}` or expanded where it is a `name => uuid` mapping.
+    deps = Dict{UUID, Union{Vector{String}, Vector{UUID}}}()
+    weakdeps = Dict{UUID, Union{Vector{String}, Vector{UUID}}}()
+    extensions = Dict{UUID, Dict{String, Vector{String}}}()
+    name_to_uuid = Dict{String, UUID}()
+    lookup_strategy = Dict{UUID, Union{SHA1, String, Nothing, Missing}}()
+
+    sizehint!(deps, length(manifest_d))
+    sizehint!(weakdeps, length(manifest_d))
+    sizehint!(extensions, length(manifest_d))
+    sizehint!(name_to_uuid, length(manifest_d))
+    sizehint!(lookup_strategy, length(manifest_d))
+
+    for (name, pkg_infos) in get_deps(manifest_d)
+        pkg_infos = pkg_infos::Vector{Any}
+        for pkg_info in pkg_infos
+            m_uuid = UUID(pkg_info["uuid"]::String)
+
+            # If we have multiple packages with the same name we will overwrite things here
+            # but that is fine since we will only use the information in here for packages
+            # with unique names
+            names[m_uuid] = name
+            name_to_uuid[name] = m_uuid
+
+            for key in ["deps", "weakdeps"]
+                deps_pkg = get(Vector{String}, pkg_info, key)::Union{Vector{String}, Dict{String, Any}}
+                d = key == "deps" ? deps :
+                    key == "weakdeps" ? weakdeps :
+                    error()
+
+                # Compressed format with unique names:
+                if deps_pkg isa Vector{String}
+                    d[m_uuid] = deps_pkg
+                # Expanded format:
+                else
+                    uuids = UUID[]
+                    for (name_dep, _dep_uuid::String) in deps_pkg
+                        dep_uuid = UUID(_dep_uuid)
+                        push!(uuids, dep_uuid)
+                        names[dep_uuid] = name_dep
+                    end
+                    d[m_uuid] = uuids
+                end
+            end
+
+            # Extensions
+            deps_pkg = get(Dict{String, Any}, pkg_info, "extensions")::Dict{String, Any}
+            for (ext, triggers) in deps_pkg
+                triggers = triggers::Union{String, Vector{String}}
+                if triggers isa String
+                    triggers = [triggers]
+                end
+                deps_pkg[ext] = triggers
+            end
+            extensions[m_uuid] = deps_pkg
+
+            # Determine strategy to find package
+            lookup_strat = begin
+                if (path = get(pkg_info, "path", nothing)::Union{String, Nothing}) !== nothing
+                    path
+                elseif (git_tree_sha_str = get(pkg_info, "git-tree-sha1", nothing)::Union{String, Nothing}) !== nothing
+                    SHA1(git_tree_sha_str)
+                else
+                    nothing
+                end
+            end
+            lookup_strategy[m_uuid] = lookup_strat
+        end
+    end
+
+    # No matter if the deps were stored compressed or not in the manifest,
+    # we internally store them expanded
+    deps_expanded = Dict{UUID, Vector{UUID}}()
+    weakdeps_expanded = Dict{UUID, Vector{UUID}}()
+    extensions_expanded = Dict{UUID, Dict{String, Vector{UUID}}}()
+    sizehint!(deps_expanded, length(deps))
+    sizehint!(weakdeps_expanded, length(deps))
+    sizehint!(extensions_expanded, length(deps))
+
+    if proj_name !== nothing
+        deps_expanded[proj_uuid] = filter!(!=(proj_uuid), collect(values(project_deps)))
+        extensions_expanded[proj_uuid] = project_extensions
+        path = get(project_d, "path", nothing)
+        entry_point = path !== nothing ? path : dirname(envpath)
+        lookup_strategy[proj_uuid] = entry_point
+    end
+
+    for key in ["deps", "weakdeps"]
+        d = key == "deps" ? deps :
+            key == "weakdeps" ? weakdeps :
+            error()
+        d_expanded = key == "deps" ? deps_expanded :
+                     key == "weakdeps" ? weakdeps_expanded :
+                     error()
+        for (pkg, deps) in d
+            # dependencies was already expanded so use it directly:
+            if deps isa Vector{UUID}
+                d_expanded[pkg] = deps
+                for dep in deps
+                    name_to_uuid[names[dep]] = dep
+                end
+            # find the (unique) UUID associated with the name
+            else
+                deps_pkg = UUID[]
+                sizehint!(deps_pkg, length(deps))
+                for dep in deps
+                    push!(deps_pkg, name_to_uuid[dep])
+                end
+                d_expanded[pkg] = deps_pkg
+            end
+        end
+    end
+
+    for (pkg, exts) in extensions
+        exts_expanded = Dict{String, Vector{UUID}}()
+        for (ext, triggers) in exts
+            triggers_expanded = UUID[]
+            sizehint!(triggers_expanded, length(triggers))
+            for trigger in triggers
+                push!(triggers_expanded, name_to_uuid[trigger])
+            end
+            exts_expanded[ext] = triggers_expanded
+        end
+        extensions_expanded[pkg] = exts_expanded
+    end
+
+    # Everything that does not yet have a lookup_strategy is missing from the manifest
+    for (_, uuid) in project_deps
+        get!(lookup_strategy, uuid, missing)
+    end
+
+    #=
+    # Preferences:
+    prefs = get(project_d, "preferences", nothing)
+
+    # `(Julia)LocalPreferences.toml`
+    project_dir = dirname(envpath)
+    local_prefs = nothing
+    for name in preferences_names
+        toml_path = joinpath(project_dir, name)
+        if isfile(toml_path)
+            local_prefs = parsed_toml(toml_path)
+            break
+        end
+    end
+    =#
+
+    return ExplicitEnv(envpath, project_deps, project_weakdeps, project_extras,
+                       project_extensions, deps_expanded, weakdeps_expanded, extensions_expanded,
+                       names, lookup_strategy, #=prefs, local_prefs=#)
+end
+
+## PROGRESS BAR
+
+# using Printf
+Base.@kwdef mutable struct MiniProgressBar
+    max::Int = 1.0
+    header::String = ""
+    color::Symbol = :nothing
+    width::Int = 40
+    current::Int = 0.0
+    prev::Int = 0.0
+    has_shown::Bool = false
+    time_shown::Float64 = 0.0
+    percentage::Bool = true
+    always_reprint::Bool = false
+    indent::Int = 4
+end
+
+const PROGRESS_BAR_TIME_GRANULARITY = Ref(1 / 30.0) # 30 fps
+const PROGRESS_BAR_PERCENTAGE_GRANULARITY = Ref(0.1)
+
+function start_progress(io::IO, _::MiniProgressBar)
+    ansi_disablecursor = "\e[?25l"
+    print(io, ansi_disablecursor)
+end
+
+function show_progress(io::IO, p::MiniProgressBar; termwidth=nothing, carriagereturn=true)
+    if p.max == 0
+        perc = 0.0
+        prev_perc = 0.0
+    else
+        perc = p.current / p.max * 100
+        prev_perc = p.prev / p.max * 100
+    end
+    # Bail early if we are not updating the progress bar,
+    # Saves printing to the terminal
+    if !p.always_reprint && p.has_shown && !((perc - prev_perc) > PROGRESS_BAR_PERCENTAGE_GRANULARITY[])
+        return
+    end
+    t = time()
+    if p.has_shown && (t - p.time_shown) < PROGRESS_BAR_TIME_GRANULARITY[]
+        return
+    end
+    p.time_shown = t
+    p.prev = p.current
+    p.has_shown = true
+
+    progress_text = if false # p.percentage
+        # @sprintf "%2.1f %%" perc
+    else
+        string(p.current, "/",  p.max)
+    end
+    termwidth = @something termwidth displaysize(io)[2]
+    max_progress_width = max(0, min(termwidth - textwidth(p.header) - textwidth(progress_text) - 10 , p.width))
+    n_filled = ceil(Int, max_progress_width * perc / 100)
+    n_left = max_progress_width - n_filled
+    to_print = sprint(; context=io) do io
+        print(io, " "^p.indent)
+        printstyled(io, p.header, color=p.color, bold=true)
+        print(io, " [")
+        print(io, "="^n_filled, ">")
+        print(io, " "^n_left, "]  ", )
+        print(io, progress_text)
+        carriagereturn && print(io, "\r")
+    end
+    # Print everything in one call
+    print(io, to_print)
+end
+
+function end_progress(io, p::MiniProgressBar)
+    ansi_enablecursor = "\e[?25h"
+    ansi_clearline = "\e[2K"
+    print(io, ansi_enablecursor * ansi_clearline)
+end
+
+function print_progress_bottom(io::IO)
+    ansi_clearline = "\e[2K"
+    ansi_movecol1 = "\e[1G"
+    ansi_moveup(n::Int) = string("\e[", n, "A")
+    print(io, "\e[S" * ansi_moveup(1) * ansi_clearline * ansi_movecol1)
+end
+
+
+############
+struct PkgPrecompileError <: Exception
+    msg::String
+end
+Base.showerror(io::IO, err::PkgPrecompileError) = print(io, err.msg)
+# This needs a show method to make `julia> err` show nicely
+Base.show(io::IO, err::PkgPrecompileError) = print(io, "PkgPrecompileError: ", err.msg)
+
+import Base: StaleCacheKey
+
+can_fancyprint(io::IO) = io isa Base.TTY && (get(ENV, "CI", nothing) != "true")
+
+function printpkgstyle(io, header, msg; color=:light_green)
+    printstyled(io, header; color, bold=true)
+    println(io, " ", msg)
+end
+
+
+function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false,
+                    strict::Bool=false, warn_loaded = true, timing::Bool = false,
+                    _from_loading::Bool=false, flags_cacheflags::Pair{Cmd, Base.CacheFlags}=(``=>Base.CacheFlags()), io::IO=stderr)
+    time_start = time_ns()
+
+    env = ExplicitEnv()
+
+    flags, cacheflags = flags_cacheflags
+
+    # Windows sometimes hits a ReadOnlyMemoryError, so we halve the default number of tasks. Issue #2323
+    # TODO: Investigate why this happens in windows and restore the full task limit
+    default_num_tasks = Sys.iswindows() ? div(Sys.CPU_THREADS::Int, 2) + 1 : Sys.CPU_THREADS::Int + 1
+    default_num_tasks = min(default_num_tasks, 16) # limit for better stability on shared resource systems
+
+    num_tasks = parse(Int, get(ENV, "JULIA_NUM_PRECOMPILE_TASKS", string(default_num_tasks)))
+    parallel_limiter = Base.Semaphore(num_tasks)
+
+    # asking for timing disables fancy mode, as timing is shown in non-fancy mode
+    fancyprint = can_fancyprint(io) && !timing
+
+    if _from_loading && !Sys.isinteractive()
+        io = devnull
+    end
+
+    hascolor = get(io, :color, false)::Bool
+    color_string(cstr::String, col::Union{Int64, Symbol}) = _color_string(cstr, col, hascolor)
+
+    direct_deps = [
+        Base.PkgId(uuid, name)
+        for (name, uuid) in env.project_deps if !Base.in_sysimage(Base.PkgId(uuid, name))
+    ]
+    stale_cache = Dict{StaleCacheKey, Bool}()
+    exts = Dict{Base.PkgId, String}() # ext -> parent
+    # make a flat map of each dep and its direct deps
+    depsmap = Dict{Base.PkgId, Vector{Base.PkgId}}()
+    pkg_exts_map = Dict{Base.PkgId, Vector{Base.PkgId}}()
+
+    for (dep, deps) in env.deps
+        pkg = Base.PkgId(dep, env.names[dep])
+        Base.in_sysimage(pkg) && continue
+        deps = [Base.PkgId(x, env.names[x]) for x in deps]
+        depsmap[pkg] = filter!(!Base.in_sysimage, deps)
+        # add any extensions
+        pkg_exts = Dict{Base.PkgId, Vector{Base.PkgId}}()
+        prev_ext = nothing
+        for (ext_name, extdep_uuids) in env.extensions[dep]
+            ext_deps = Base.PkgId[]
+            push!(ext_deps, pkg) # depends on parent package
+            all_extdeps_available = true
+            for extdep_uuid in extdep_uuids
+                extdep_name = env.names[extdep_uuid]
+                if extdep_uuid in keys(env.deps) || Base.in_sysimage(Base.PkgId(extdep_uuid, extdep_name))
+                    push!(ext_deps, Base.PkgId(extdep_uuid, extdep_name))
+                else
+                    all_extdeps_available = false
+                    break
+                end
+            end
+            all_extdeps_available || continue
+            if prev_ext isa Base.PkgId
+                # also make the exts depend on eachother sequentially to avoid race
+                push!(ext_deps, prev_ext)
+            end
+            ext_uuid = Base.uuid5(pkg.uuid, ext_name)
+            ext = Base.PkgId(ext_uuid, ext_name)
+            prev_ext = ext
+            filter!(!Base.in_sysimage, ext_deps)
+            depsmap[ext] = ext_deps
+            exts[ext] = pkg.name
+            pkg_exts[ext] = ext_deps
+        end
+        if !isempty(pkg_exts)
+            pkg_exts_map[pkg] = collect(keys(pkg_exts))
+        end
+    end
+
+    @debug "precompile: deps collected" _group=:precompile
+    # this loop must be run after the full depsmap has been populated
+    for (pkg, pkg_exts) in pkg_exts_map
+        # find any packages that depend on the extension(s)'s deps and replace those deps in their deps list with the extension(s),
+        # basically injecting the extension into the precompile order in the graph, to avoid race to precompile extensions
+        for (_pkg, deps) in depsmap # for each manifest dep
+            if !in(_pkg, keys(exts)) && pkg in deps # if not an extension and depends on pkg
+                append!(deps, pkg_exts) # add the package extensions to deps
+                filter!(!isequal(pkg), deps) # remove the pkg from deps
+            end
+        end
+    end
+    @debug "precompile: extensions collected" _group=:precompile
+
+    # return early if no deps
+    if isempty(depsmap)
+        if isempty(pkgs)
+            return
+        elseif _from_loading
+            # if called from loading precompilation it may be a package from another environment stack so
+            # don't error and allow serial precompilation to try
+            # TODO: actually handle packages from other envs in the stack
+            return
+        else
+            error("No direct dependencies outside of the sysimage found matching $(repr([p.name for p in pkgs]))")
+        end
+    end
+
+    # initialize signalling
+    started = Dict{Base.PkgId,Bool}()
+    was_processed = Dict{Base.PkgId,Base.Event}()
+    was_recompiled = Dict{Base.PkgId,Bool}()
+    for pkgid in keys(depsmap)
+        started[pkgid] = false
+        was_processed[pkgid] = Base.Event()
+        was_recompiled[pkgid] = false
+    end
+    @debug "precompile: signalling initialized"  _group=:precompile
+
+
+    # find and guard against circular deps
+    circular_deps = Base.PkgId[]
+    # Three states
+    # !haskey -> never visited
+    # true -> cannot be compiled due to a cycle (or not yet determined)
+    # false -> not depending on a cycle
+    could_be_cycle = Dict{Base.PkgId, Bool}()
+    function scan_pkg!(pkg, dmap)
+        did_visit_dep = true
+        inpath = get!(could_be_cycle, pkg) do
+            did_visit_dep = false
+            return true
+        end
+        if did_visit_dep ? inpath : scan_deps!(pkg, dmap)
+            # Found a cycle. Delete this and all parents
+            return true
+        end
+        return false
+    end
+    function scan_deps!(pkg, dmap)
+        for dep in dmap[pkg]
+            scan_pkg!(dep, dmap) && return true
+        end
+        could_be_cycle[pkg] = false
+        return false
+    end
+    for pkg in keys(depsmap)
+        if scan_pkg!(pkg, depsmap)
+            push!(circular_deps, pkg)
+            notify(was_processed[pkg])
+        end
+    end
+    if !isempty(circular_deps)
+        @warn """Circular dependency detected. Precompilation will be skipped for:\n  $(join(string.(circular_deps), "\n  "))"""
+    end
+    @debug "precompile: circular dep check done"  _group=:precompile
+
+    # if a list of packages is given, restrict to dependencies of given packages
+    if !isempty(pkgs)
+         function collect_all_deps(depsmap, dep, alldeps=Set{Base.PkgId}())
+            for _dep in depsmap[dep]
+                if !(_dep in alldeps)
+                    push!(alldeps, _dep)
+                    collect_all_deps(depsmap, _dep, alldeps)
+                end
+            end
+            return alldeps
+        end
+        keep = Set{Base.PkgId}()
+        for dep in depsmap
+            dep_pkgid = first(dep)
+            if dep_pkgid.name in pkgs
+                push!(keep, dep_pkgid)
+                collect_all_deps(depsmap, dep_pkgid, keep)
+            end
+        end
+        for ext in keys(exts)
+            if issubset(collect_all_deps(depsmap, ext), keep) # if all extension deps are kept
+                push!(keep, ext)
+            end
+        end
+        filter!(d->in(first(d), keep), depsmap)
+        if isempty(depsmap)
+            if _from_loading
+                # if called from loading precompilation it may be a package from another environment stack so
+                # don't error and allow serial precompilation to try
+                # TODO: actually handle packages from other envs in the stack
+                return
+            else
+                error("No direct dependencies outside of the sysimage found matching $(repr(pkgs))")
+            end
+        end
+        target = join(pkgs, ", ")
+    else
+        target = "project..."
+    end
+    @debug "precompile: packages filtered"  _group=:precompile
+
+    pkg_queue = Base.PkgId[]
+    failed_deps = Dict{Base.PkgId, String}()
+    skipped_deps = Base.PkgId[]
+    precomperr_deps = Base.PkgId[] # packages that may succeed after a restart (i.e. loaded packages with no cache file)
+
+    print_lock = io isa Base.LibuvStream ? io.lock::ReentrantLock : ReentrantLock()
+    first_started = Base.Event()
+    printloop_should_exit::Bool = !fancyprint # exit print loop immediately if not fancy printing
+    interrupted_or_done = Base.Event()
+
+    ansi_moveup(n::Int) = string("\e[", n, "A")
+    ansi_movecol1 = "\e[1G"
+    ansi_cleartoend = "\e[0J"
+    ansi_cleartoendofline = "\e[0K"
+    ansi_enablecursor = "\e[?25h"
+    ansi_disablecursor = "\e[?25l"
+    n_done::Int = 0
+    n_already_precomp::Int = 0
+    n_loaded::Int = 0
+    interrupted = false
+
+    function handle_interrupt(err, in_printloop = false)
+        notify(interrupted_or_done)
+        in_printloop || wait(t_print) # wait to let the print loop cease first
+        if err isa InterruptException
+            lock(print_lock) do
+                println(io, " Interrupted: Exiting precompilation...")
+            end
+            interrupted = true
+            return true
+        else
+            return false
+        end
+    end
+
+    std_outputs = Dict{Base.PkgId,String}()
+    taskwaiting = Set{Base.PkgId}()
+    pkgspidlocked = Dict{Base.PkgId,String}()
+    pkg_liveprinted = nothing
+
+    function monitor_std(pkg, pipe; single_requested_pkg=false)
+        try
+            liveprinting = false
+            while !eof(pipe)
+                str = readline(pipe, keep=true)
+                if single_requested_pkg && (liveprinting || !isempty(str))
+                    lock(print_lock) do
+                        if !liveprinting
+                            printpkgstyle(io, :Info, "Given $(pkg.name) was explicitly requested, output will be shown live $ansi_cleartoendofline",
+                                color = Base.info_color())
+                            liveprinting = true
+                            pkg_liveprinted = pkg
+                        end
+                        print(io, ansi_cleartoendofline, str)
+                    end
+                end
+                std_outputs[pkg] = string(get(std_outputs, pkg, ""), str)
+                if !in(pkg, taskwaiting) && occursin("waiting for IO to finish", str)
+                    !fancyprint && lock(print_lock) do
+                        println(io, pkg.name, color_string(" Waiting for background task / IO / timer.", Base.warn_color()))
+                    end
+                    push!(taskwaiting, pkg)
+                end
+                if !fancyprint && in(pkg, taskwaiting)
+                    lock(print_lock) do
+                        print(io, str)
+                    end
+                end
+            end
+        catch err
+            err isa InterruptException || rethrow()
+        end
+    end
+
+    ## fancy print loop
+    t_print = @async begin
+        try
+            wait(first_started)
+            (isempty(pkg_queue) || interrupted_or_done.set) && return
+            fancyprint && lock(print_lock) do
+                printpkgstyle(io, :Precompiling, target)
+                print(io, ansi_disablecursor)
+            end
+            t = Timer(0; interval=1/10)
+            anim_chars = ["◐","◓","◑","◒"]
+            i = 1
+            last_length = 0
+            bar = MiniProgressBar(; indent=2, header = "Progress", color = Base.info_color(), percentage=false, always_reprint=true)
+            n_total = length(depsmap)
+            bar.max = n_total - n_already_precomp
+            final_loop = false
+            n_print_rows = 0
+            while !printloop_should_exit
+                lock(print_lock) do
+                    term_size = Base.displaysize(io)::Tuple{Int,Int}
+                    num_deps_show = term_size[1] - 3
+                    pkg_queue_show = if !interrupted_or_done.set && length(pkg_queue) > num_deps_show
+                        last(pkg_queue, num_deps_show)
+                    else
+                        pkg_queue
+                    end
+                    str_ = sprint() do iostr
+                        if i > 1
+                            print(iostr, ansi_cleartoend)
+                        end
+                        bar.current = n_done - n_already_precomp
+                        bar.max = n_total - n_already_precomp
+                        # when sizing to the terminal width subtract a little to give some tolerance to resizing the
+                        # window between print cycles
+                        termwidth = displaysize(io)[2] - 4
+                        if !final_loop
+                            str = sprint(io -> show_progress(io, bar; termwidth, carriagereturn=false); context=io)
+                            print(iostr, Base._truncate_at_width_or_chars(true, str, termwidth), "\n")
+                        end
+                        for dep in pkg_queue_show
+                            loaded = warn_loaded && haskey(Base.loaded_modules, dep)
+                            _name = haskey(exts, dep) ? string(exts[dep], " → ", dep.name) : dep.name
+                            name = dep in direct_deps ? _name : string(color_string(_name, :light_black))
+                            line = if dep in precomperr_deps
+                                string(color_string("  ? ", Base.warn_color()), name)
+                            elseif haskey(failed_deps, dep)
+                                string(color_string("  ✗ ", Base.error_color()), name)
+                            elseif was_recompiled[dep]
+                                !loaded && interrupted_or_done.set && continue
+                                loaded || @async begin # keep successful deps visible for short period
+                                    sleep(1);
+                                    filter!(!isequal(dep), pkg_queue)
+                                end
+                                string(color_string("  ✓ ", loaded ? Base.warn_color() : :green), name)
+                            elseif started[dep]
+                                # Offset each spinner animation using the first character in the package name as the seed.
+                                # If not offset, on larger terminal fonts it looks odd that they all sync-up
+                                anim_char = anim_chars[(i + Int(dep.name[1])) % length(anim_chars) + 1]
+                                anim_char_colored = dep in direct_deps ? anim_char : color_string(anim_char, :light_black)
+                                waiting = if haskey(pkgspidlocked, dep)
+                                    who_has_lock = pkgspidlocked[dep]
+                                    color_string(" Being precompiled by $(who_has_lock)", Base.info_color())
+                                elseif dep in taskwaiting
+                                    color_string(" Waiting for background task / IO / timer. Interrupt to inspect", Base.warn_color())
+                                else
+                                    ""
+                                end
+                                string("  ", anim_char_colored, " ", name, waiting)
+                            else
+                                string("    ", name)
+                            end
+                            println(iostr, Base._truncate_at_width_or_chars(true, line, termwidth))
+                        end
+                    end
+                    last_length = length(pkg_queue_show)
+                    n_print_rows = count("\n", str_)
+                    print(io, str_)
+                    printloop_should_exit = interrupted_or_done.set && final_loop
+                    final_loop = interrupted_or_done.set # ensures one more loop to tidy last task after finish
+                    i += 1
+                    printloop_should_exit || print(io, ansi_moveup(n_print_rows), ansi_movecol1)
+                end
+                wait(t)
+            end
+        catch err
+            handle_interrupt(err, true) || rethrow()
+        finally
+            fancyprint && print(io, ansi_enablecursor)
+        end
+    end
+    tasks = Task[]
+    if !_from_loading
+        Base.LOADING_CACHE[] = Base.LoadingCache()
+    end
+    @debug "precompile: starting precompilation loop"  _group=:precompile
+    ## precompilation loop
+    for (pkg, deps) in depsmap
+        cachepaths = Base.find_all_in_cache_path(pkg)
+        sourcepath = Base.locate_package(pkg)
+        if sourcepath === nothing
+            failed_deps[pkg] = "Error: Missing source file for $(pkg)"
+            notify(was_processed[pkg])
+            continue
+        end
+        # Heuristic for when precompilation is disabled
+        if occursin(r"\b__precompile__\(\s*false\s*\)", read(sourcepath, String))
+            notify(was_processed[pkg])
+            continue
+        end
+
+        single_requested_pkg = length(pkgs) == 1 && only(pkgs) == pkg.name
+
+        task = @async begin
+            try
+                loaded = haskey(Base.loaded_modules, pkg)
+                for dep in deps # wait for deps to finish
+                    wait(was_processed[dep])
+                end
+
+                circular = pkg in circular_deps
+                is_stale = !Base.isprecompiled(pkg; ignore_loaded=true, stale_cache, cachepaths, sourcepath, flags=cacheflags)
+                if !circular && is_stale
+                    Base.acquire(parallel_limiter)
+                    is_direct_dep = pkg in direct_deps
+
+                    # std monitoring
+                    std_pipe = Base.link_pipe!(Pipe(); reader_supports_async=true, writer_supports_async=true)
+                    t_monitor = @async monitor_std(pkg, std_pipe; single_requested_pkg)
+
+                    _name = haskey(exts, pkg) ? string(exts[pkg], " → ", pkg.name) : pkg.name
+                    name = is_direct_dep ? _name : string(color_string(_name, :light_black))
+                    !fancyprint && lock(print_lock) do
+                        isempty(pkg_queue) && printpkgstyle(io, :Precompiling, target)
+                    end
+                    push!(pkg_queue, pkg)
+                    started[pkg] = true
+                    fancyprint && notify(first_started)
+                    if interrupted_or_done.set
+                        notify(was_processed[pkg])
+                        Base.release(parallel_limiter)
+                        return
+                    end
+                    try
+                        # allows processes to wait if another process is precompiling a given package to
+                        # a functionally identical package cache (except for preferences, which may differ)
+                        t = @elapsed ret = precompile_pkgs_maybe_cachefile_lock(io, print_lock, fancyprint, pkg, pkgspidlocked, hascolor, cacheflags) do
+                            Base.with_logger(Base.NullLogger()) do
+                                # The false here means we ignore loaded modules, so precompile for a fresh session
+                                Base.compilecache(pkg, sourcepath, std_pipe, std_pipe, false; flags)
+                            end
+                        end
+                        if ret isa Base.PrecompilableError
+                            push!(precomperr_deps, pkg)
+                            !fancyprint && lock(print_lock) do
+                                println(io, _timing_string(t), color_string("  ? ", Base.warn_color()), name)
+                            end
+                        else
+                            !fancyprint && lock(print_lock) do
+                                println(io, _timing_string(t), color_string("  ✓ ", loaded ? Base.warn_color() : :green), name)
+                            end
+                            was_recompiled[pkg] = true
+                        end
+                        loaded && (n_loaded += 1)
+                    catch err
+                        close(std_pipe.in) # close pipe to end the std output monitor
+                        wait(t_monitor)
+                        if err isa ErrorException || (err isa ArgumentError && startswith(err.msg, "Invalid header in cache file"))
+                            failed_deps[pkg] = (strict || is_direct_dep) ? string(sprint(showerror, err), "\n", strip(get(std_outputs, pkg, ""))) : ""
+                            delete!(std_outputs, pkg) # so it's not shown as warnings, given error report
+                            !fancyprint && lock(print_lock) do
+                                println(io, " "^9, color_string("  ✗ ", Base.error_color()), name)
+                            end
+                        else
+                            rethrow()
+                        end
+                    finally
+                        isopen(std_pipe.in) && close(std_pipe.in) # close pipe to end the std output monitor
+                        wait(t_monitor)
+                        Base.release(parallel_limiter)
+                    end
+                else
+                    is_stale || (n_already_precomp += 1)
+                end
+                n_done += 1
+                notify(was_processed[pkg])
+            catch err_outer
+                # For debugging:
+                # @error "Task failed" exception=(err_outer, catch_backtrace())
+                handle_interrupt(err_outer) || rethrow()
+                notify(was_processed[pkg])
+            finally
+                filter!(!istaskdone, tasks)
+                length(tasks) == 1 && notify(interrupted_or_done)
+            end
+        end
+        push!(tasks, task)
+    end
+    isempty(tasks) && notify(interrupted_or_done)
+    try
+        wait(interrupted_or_done)
+    catch err
+        handle_interrupt(err) || rethrow()
+    finally
+        Base.LOADING_CACHE[] = nothing
+    end
+    notify(first_started) # in cases of no-op or !fancyprint
+    fancyprint && wait(t_print)
+    quick_exit = !all(istaskdone, tasks) || interrupted # if some not finished internal error is likely
+    seconds_elapsed = round(Int, (time_ns() - time_start) / 1e9)
+    ndeps = count(values(was_recompiled))
+    if ndeps > 0 || !isempty(failed_deps) || (quick_exit && !isempty(std_outputs))
+        str = sprint() do iostr
+            if !quick_exit
+                plural = ndeps == 1 ? "y" : "ies"
+                print(iostr, "  $(ndeps) dependenc$(plural) successfully precompiled in $(seconds_elapsed) seconds")
+                if n_already_precomp > 0 || !isempty(circular_deps) || !isempty(skipped_deps)
+                    n_already_precomp > 0 && (print(iostr, ". $n_already_precomp already precompiled"))
+                    !isempty(circular_deps) && (print(iostr, ". $(length(circular_deps)) skipped due to circular dependency"))
+                    !isempty(skipped_deps) && (print(iostr, ". $(length(skipped_deps)) skipped during auto due to previous errors"))
+                    print(iostr, ".")
+                end
+                if n_loaded > 0
+                    plural1 = n_loaded == 1 ? "y" : "ies"
+                    plural2 = n_loaded == 1 ? "a different version is" : "different versions are"
+                    plural3 = n_loaded == 1 ? "" : "s"
+                    print(iostr, "\n  ",
+                        color_string(string(n_loaded), Base.warn_color()),
+                        " dependenc$(plural1) precompiled but $(plural2) currently loaded. Restart julia to access the new version$(plural3)"
+                    )
+                end
+                if !isempty(precomperr_deps)
+                    pluralpc = length(precomperr_deps) == 1 ? "y" : "ies"
+                    print(iostr, "\n  ",
+                        color_string(string(length(precomperr_deps)), Base.warn_color()),
+                        " dependenc$(pluralpc) failed but may be precompilable after restarting julia"
+                    )
+                end
+            end
+            # show any stderr output, even if Pkg.precompile has been interrupted (quick_exit=true), given user may be
+            # interrupting a hanging precompile job with stderr output. julia#48371
+            filter!(kv -> !isempty(strip(last(kv))), std_outputs) # remove empty output
+            if !isempty(std_outputs)
+                plural1 = length(std_outputs) == 1 ? "y" : "ies"
+                plural2 = length(std_outputs) == 1 ? "" : "s"
+                print(iostr, "\n  ", color_string("$(length(std_outputs))", Base.warn_color()), " dependenc$(plural1) had output during precompilation:")
+                for (pkgid, err) in std_outputs
+                    err = if pkgid == pkg_liveprinted
+                        "[Output was shown above]"
+                    else
+                        join(split(strip(err), "\n"), color_string("\n│  ", Base.warn_color()))
+                    end
+                    name = haskey(exts, pkgid) ? string(exts[pkgid], " → ", pkgid.name) : pkgid.name
+                    print(iostr, color_string("\n┌ ", Base.warn_color()), name, color_string("\n│  ", Base.warn_color()), err, color_string("\n└  ", Base.warn_color()))
+                end
+            end
+        end
+        let str=str
+            lock(print_lock) do
+                println(io, str)
+            end
+        end
+        quick_exit && return
+        err_str = ""
+        n_direct_errs = 0
+        for (dep, err) in failed_deps
+            if strict || (dep in direct_deps)
+                err_str = string(err_str, "\n$dep\n\n$err", (n_direct_errs > 0 ? "\n" : ""))
+                n_direct_errs += 1
+            end
+        end
+        if err_str != ""
+            pluralde = n_direct_errs == 1 ? "y" : "ies"
+            direct = strict ? "" : "direct "
+            err_msg = "The following $n_direct_errs $(direct)dependenc$(pluralde) failed to precompile:\n$(err_str[1:end-1])"
+            if internal_call # aka. auto-precompilation
+                if isinteractive() && !get(ENV, "CI", false)
+                    plural1 = length(failed_deps) == 1 ? "y" : "ies"
+                    println(io, "  ", color_string("$(length(failed_deps))", Base.error_color()), " dependenc$(plural1) errored.")
+                    println(io, "  For a report of the errors see `julia> err`. To retry use `pkg> precompile`")
+                    setglobal!(Base.MainInclude, :err, PkgPrecompileError(err_msg))
+                else
+                    # auto-precompilation shouldn't throw but if the user can't easily access the
+                    # error messages, just show them
+                    print(io, "\n", err_msg)
+                end
+            else
+                println(io)
+                error(err_msg)
+            end
+        end
+    end
+    nothing
+end
+
+_timing_string(t) = string(lpad(round(t * 1e3, digits = 1), 9), " ms")
+
+function _color_string(cstr::String, col::Union{Int64, Symbol}, hascolor)
+    if hascolor
+        enable_ansi  = get(Base.text_colors, col, Base.text_colors[:default])
+        disable_ansi = get(Base.disable_text_style, col, Base.text_colors[:default])
+        return string(enable_ansi, cstr, disable_ansi)
+    else
+        return cstr
+    end
+end
+
+# Can be merged with `maybe_cachefile_lock` in loading?
+function precompile_pkgs_maybe_cachefile_lock(f, io::IO, print_lock::ReentrantLock, fancyprint::Bool, pkg::Base.PkgId, pkgspidlocked::Dict{Base.PkgId,String}, hascolor, cacheflags)
+    FileWatching = Base.loaded_modules[Base.PkgId(Base.UUID("7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"), "FileWatching")]
+    stale_age = Base.compilecache_pidlock_stale_age
+    pidfile = Base.compilecache_pidfile_path(pkg)
+    cachefile = FileWatching.trymkpidlock(f, pidfile; stale_age)
+    if cachefile === false
+        pid, hostname, age = FileWatching.Pidfile.parse_pidfile(pidfile)
+        pkgspidlocked[pkg] = if isempty(hostname) || hostname == gethostname()
+            if pid == getpid()
+                "an async task in this process (pidfile: $pidfile)"
+            else
+                "another process (pid: $pid, pidfile: $pidfile)"
+            end
+        else
+            "another machine (hostname: $hostname, pid: $pid, pidfile: $pidfile)"
+        end
+        !fancyprint && lock(print_lock) do
+            println(io, "    ", pkg.name, _color_string(" Being precompiled by $(pkgspidlocked[pkg])", Base.info_color(), hascolor))
+        end
+        # wait until the lock is available
+        FileWatching.mkpidlock(pidfile; stale_age) do
+            # double-check in case the other process crashed or the lock expired
+            if Base.isprecompiled(pkg; ignore_loaded=true, flags=cacheflags) # don't use caches for this as the env state will have changed
+                return nothing # returning nothing indicates a process waited for another
+            else
+                delete!(pkgspidlocked, pkg)
+                return f() # precompile
+            end
+        end
+    end
+    return cachefile
+end
+
+end
diff --git a/doc/make.jl b/doc/make.jl
index 8dee832bf27b7..e06fa1deb8f42 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -3,7 +3,8 @@ Base.ACTIVE_PROJECT[] = nothing
 empty!(LOAD_PATH)
 push!(LOAD_PATH, @__DIR__, "@stdlib")
 empty!(DEPOT_PATH)
-pushfirst!(DEPOT_PATH, joinpath(@__DIR__, "deps"))
+push!(DEPOT_PATH, joinpath(@__DIR__, "deps"))
+push!(DEPOT_PATH, abspath(Sys.BINDIR, "..", "share", "julia"))
 using Pkg
 Pkg.instantiate()
 

From 892c49162a48e9646dc3f0f2b94ebb33ae2a76be Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Mon, 4 Mar 2024 23:00:26 -0500
Subject: [PATCH 1065/1315] Docs: change "Package naming guidelines" to
 "Package naming rules" (#53566)

I think that "guidelines" implies that these are just optional
suggestions.

But in practice, I think we usually insist that these are followed.

So I think it might be worth changing "guidelines" to "rules", to
clarify that we enforce these.
---
 doc/src/tutorials/creating-packages.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/src/tutorials/creating-packages.md b/doc/src/tutorials/creating-packages.md
index 52288e5a8924f..c5cd1f4f92f48 100644
--- a/doc/src/tutorials/creating-packages.md
+++ b/doc/src/tutorials/creating-packages.md
@@ -563,10 +563,10 @@ duplicated into `[extras]`. This is an unfortunate duplication, but without
 doing this the project verifier under older Julia versions will throw an error
 if it finds packages under `[compat]` that is not listed in `[extras]`.
 
-## Package naming guidelines
+## Package naming rules
 
 Package names should be sensible to most Julia users, *even to those who are not domain experts*.
-The following guidelines apply to the `General` registry but may be useful for other package
+The following rules apply to the `General` registry but may be useful for other package
 registries as well.
 
 Since the `General` registry belongs to the entire community, people may have opinions about

From d3ee213987986d5a5acf702061c60a46cb13cab4 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 5 Mar 2024 10:59:32 +0100
Subject: [PATCH 1066/1315] add back `unsafe_convert` to pointer for arrays
 (#53589)

This caused a pretty big breakage in the ecosystem (~50 packages) and is
according to Jameson "Too breaking for no necessary reason". So let's
add it back.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 base/pointer.jl | 1 +
 test/core.jl    | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/base/pointer.jl b/base/pointer.jl
index 86513c076ade6..2f67c8a6757cb 100644
--- a/base/pointer.jl
+++ b/base/pointer.jl
@@ -64,6 +64,7 @@ unsafe_convert(::Type{Ptr{Int8}}, s::String) = ccall(:jl_string_ptr, Ptr{Int8},
 
 cconvert(::Type{<:Ptr}, a::Array) = getfield(a, :ref)
 unsafe_convert(::Type{Ptr{S}}, a::AbstractArray{T}) where {S,T} = convert(Ptr{S}, unsafe_convert(Ptr{T}, a))
+unsafe_convert(::Type{Ptr{T}}, a::Array{T}) where {T} = unsafe_convert(Ptr{T}, a.ref)
 unsafe_convert(::Type{Ptr{T}}, a::AbstractArray{T}) where {T} = error("conversion to pointer not defined for $(typeof(a))")
 # TODO: add this deprecation to give a better error:
 # cconvert(::Type{<:Ptr}, a::AbstractArray) = error("conversion to pointer not defined for $(typeof(a))")
diff --git a/test/core.jl b/test/core.jl
index aa16380c8a866..0eca2251cd146 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8127,3 +8127,5 @@ let M = @__MODULE__
     @test Core.set_binding_type!(M, :a_typed_global) === nothing
     @test Core.get_binding_type(M, :a_typed_global) === Tuple{Union{Integer,Nothing}}
 end
+
+@test Base.unsafe_convert(Ptr{Int}, [1]) !== C_NULL

From b50344fa0a43bf1da7855a3dcd4dacaae65462bb Mon Sep 17 00:00:00 2001
From: inky <git@wo-class.cn>
Date: Tue, 5 Mar 2024 04:00:14 -0600
Subject: [PATCH 1067/1315] build: remove extra .a file (#53596)

fix #53569
---
 Makefile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Makefile b/Makefile
index 89fe35b470094..5ce3003dba231 100644
--- a/Makefile
+++ b/Makefile
@@ -289,6 +289,7 @@ else ifeq ($(JULIA_BUILD_MODE),debug)
 	-$(INSTALL_M) $(build_libdir)/libjulia-internal-debug.dll.a $(DESTDIR)$(libdir)/
 endif
 	-$(INSTALL_M) $(wildcard $(build_private_libdir)/*.a) $(DESTDIR)$(private_libdir)/
+	-rm -f $(DESTDIR)$(private_libdir)/sys-o.a
 
 	# We have a single exception; we want 7z.dll to live in private_libexecdir,
 	# not bindir, so that 7z.exe can find it.

From 3df016d8e1b20607dda786d9b5912f256aebb80c Mon Sep 17 00:00:00 2001
From: Eric Hanson <5846501+ericphanson@users.noreply.github.com>
Date: Tue, 5 Mar 2024 14:49:02 +0100
Subject: [PATCH 1068/1315] Semver: specify VersionNumber's follow v2-rc2
 specifically (#53538)

Since v2 has changed from v2-rc2 by saying build numbers MUST not be
taken into account in precedence.

I don't think changing VersionNumber's ordering in a minor release of
Julia is acceptable, but since the semver landing page is now v2 rather
than v2-rc2, we should update the link.

closes https://github.com/JuliaLang/julia/issues/53502
---
 base/version.jl           | 4 ++--
 doc/src/manual/strings.md | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/version.jl b/base/version.jl
index 90c34b78c868f..9fa4edb32e4dd 100644
--- a/base/version.jl
+++ b/base/version.jl
@@ -9,12 +9,12 @@ const VInt = UInt32
     VersionNumber
 
 Version number type which follows the specifications of
-[semantic versioning (semver)](https://semver.org/), composed of major, minor
+[semantic versioning (semver)](https://semver.org/spec/v2.0.0-rc.2.html), composed of major, minor
 and patch numeric values, followed by pre-release and build
 alphanumeric annotations.
 
 `VersionNumber` objects can be compared with all of the standard comparison
-operators (`==`, `<`, `<=`, etc.), with the result following semver rules.
+operators (`==`, `<`, `<=`, etc.), with the result following semver v2.0.0-rc.2 rules.
 
 `VersionNumber` has the following public fields:
 - `v.major::Integer`
diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md
index f4acffb2ae91b..1087c7f8b5ff1 100644
--- a/doc/src/manual/strings.md
+++ b/doc/src/manual/strings.md
@@ -1142,7 +1142,7 @@ some confusion regarding the matter.
 
 Version numbers can easily be expressed with non-standard string literals of the form [`v"..."`](@ref @v_str).
 Version number literals create [`VersionNumber`](@ref) objects which follow the
-specifications of [semantic versioning](https://semver.org/),
+specifications of [semantic versioning 2.0.0-rc2](https://semver.org/spec/v2.0.0-rc.2.html),
 and therefore are composed of major, minor and patch numeric values, followed by pre-release and
 build alphanumeric annotations. For example, `v"0.2.1-rc1+win64"` is broken into major version
 `0`, minor version `2`, patch version `1`, pre-release `rc1` and build `win64`. When entering

From 427da5c38ee08ab8477f2cd706c605d2d0bcb84c Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 5 Mar 2024 18:23:08 +0100
Subject: [PATCH 1069/1315] fix error path in `precompilepkgs` (#53606)

this was accidentally left when porting this from Pkg.jl
---
 base/precompilation.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index 4efd35836a29d..9eaa0539f522e 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -436,7 +436,7 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
             # TODO: actually handle packages from other envs in the stack
             return
         else
-            error("No direct dependencies outside of the sysimage found matching $(repr([p.name for p in pkgs]))")
+            error("No direct dependencies outside of the sysimage found matching $(pkgs)")
         end
     end
 

From fb71a5d2fb6ed8348e3b8ff7b54f18965b9d8d7b Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Tue, 5 Mar 2024 16:32:17 -0500
Subject: [PATCH 1070/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=2048eea8dbd=20to=20e7d740ac8=20(#53610)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 48eea8dbd
New commit: e7d740ac8
Julia version: 1.12.0-DEV
Pkg version: 1.11.0(Does not match)
Bump invoked by: @KristofferC
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/48eea8dbd7b651cdc932b909c1b718bb9c3f94f4...e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e

```
$ git log --oneline 48eea8dbd..e7d740ac8
e7d740ac8 move to using Base parallel precompile (#3820)
d1f91fd37 fix relative paths in test project for `[sources]` (#3825)
5c73d7f3c Support a `[sources]` section in Project.toml for specifying paths and repo locations for dependencies (#3783)
0d9aa51a9 do not use UnstableIO for subprocess (in e.g. Pkg.test) (#3823)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5     | 1 -
 .../Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512  | 1 -
 .../Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5     | 1 +
 .../Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512

diff --git a/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5 b/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5
deleted file mode 100644
index 341ea80c32a7e..0000000000000
--- a/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-fea1786e8202d07744c17457a114e911
diff --git a/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512 b/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512
deleted file mode 100644
index 8f6d09bbb6001..0000000000000
--- a/deps/checksums/Pkg-48eea8dbd7b651cdc932b909c1b718bb9c3f94f4.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-e79913b68643ec4c448a861f446d0358484b01d16794c9dfe700b1f539d4c01ea259014d37df263b4d7dd3f3c2e1df3966c584b428041dbdf03d4e4794b52a64
diff --git a/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5 b/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5
new file mode 100644
index 0000000000000..96ceb05a2c8d4
--- /dev/null
+++ b/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5
@@ -0,0 +1 @@
+0d226d1a3cf5c4cf207788fc3c5ba50c
diff --git a/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512 b/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512
new file mode 100644
index 0000000000000..304829ca32df0
--- /dev/null
+++ b/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512
@@ -0,0 +1 @@
+e9516466573c24d2bd90645edbdc9c2dbe3f4f4e1704d665525429ff6a463208ff849ebb7c4f9d2d2627d69d1b2cc56a9b305a89e30a0e16b666cbd91f34ced3
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index ca45bee7ee736..9ca239a2c6b5a 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 48eea8dbd7b651cdc932b909c1b718bb9c3f94f4
+PKG_SHA1 = e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 90d84d4ab00a34cd9c75b06b77925aaf8afbabfd Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 6 Mar 2024 09:32:31 +0900
Subject: [PATCH 1071/1315] cleanups on `src_inlining_policy` (#53599)

- fixed the check with `src_inlining_policy` in typeinfer.jl
- removed the `SemiConcreteResult` handling, which is no longer needed
---
 base/compiler/optimize.jl  | 4 ----
 base/compiler/typeinfer.jl | 3 ++-
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 1615781727669..6de08e64c14e7 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -115,15 +115,11 @@ function src_inlining_policy(interp::AbstractInterpreter,
         return src_inlineable
     elseif isa(src, IRCode)
         return true
-    elseif isa(src, SemiConcreteResult)
-        return true
     end
     @assert !isa(src, CodeInstance) # handled by caller
     return false
 end
 
-function inlining_policy end # deprecated legacy name used by Cthulhu
-
 struct InliningState{Interp<:AbstractInterpreter}
     edges::Vector{Any}
     world::UInt
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 5af074498ca7e..b659fc2a88e6c 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -873,7 +873,8 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         exc_bestguess = refine_exception_type(frame.exc_bestguess, effects)
         # propagate newly inferred source to the inliner, allowing efficient inlining w/o deserialization:
         # note that this result is cached globally exclusively, we can use this local result destructively
-        volatile_inf_result = isinferred && (force_inline || src_inlining_policy(interp, result.src, NoCallInfo(), IR_FLAG_NULL) !== nothing) ?
+        volatile_inf_result = (isinferred && (force_inline ||
+            src_inlining_policy(interp, result.src, NoCallInfo(), IR_FLAG_NULL))) ?
             VolatileInferenceResult(result) : nothing
         return EdgeCallResult(frame.bestguess, exc_bestguess, edge, effects, volatile_inf_result)
     elseif frame === true

From a556af2d8a8e448fca2067992e98ee7954c51656 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sat, 2 Mar 2024 13:27:21 +0800
Subject: [PATCH 1072/1315] typeintersect: fuse `unalias_unionall`

And ensures all innervar get checked.
---
 src/subtype.c   | 25 ++++++++++++++-----------
 test/subtype.jl | 29 ++++++++++++++++++++++++++++-
 2 files changed, 42 insertions(+), 12 deletions(-)

diff --git a/src/subtype.c b/src/subtype.c
index c6b51ec872e75..d024b3920e924 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -881,10 +881,20 @@ static jl_unionall_t *unalias_unionall(jl_unionall_t *u, jl_stenv_t *e)
     // in the environment, rename to get a fresh var.
     JL_GC_PUSH1(&u);
     while (btemp != NULL) {
-        if (btemp->var == u->var ||
-            // outer var can only refer to inner var if bounds changed
+        int aliased = btemp->var == u->var ||
+            // outer var can only refer to inner var if bounds changed (mainly for subtyping path)
             (btemp->lb != btemp->var->lb && jl_has_typevar(btemp->lb, u->var)) ||
-            (btemp->ub != btemp->var->ub && jl_has_typevar(btemp->ub, u->var))) {
+            (btemp->ub != btemp->var->ub && jl_has_typevar(btemp->ub, u->var));
+        if (!aliased && btemp->innervars != NULL) {
+            for (size_t i = 0; i < jl_array_len(btemp->innervars); i++) {
+                jl_tvar_t *ivar = (jl_tvar_t*)jl_array_ptr_ref(btemp->innervars, i);
+                if (ivar == u->var) {
+                    aliased = 1;
+                    break;
+                }
+            }
+        }
+        if (aliased) {
             u = jl_rename_unionall(u);
             break;
         }
@@ -3056,9 +3066,6 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
 static jl_value_t *intersect_unionall_(jl_value_t *t, jl_unionall_t *u, jl_stenv_t *e, int8_t R, int param, jl_varbinding_t *vb)
 {
     jl_varbinding_t *btemp = e->vars;
-    // if the var for this unionall (based on identity) already appears somewhere
-    // in the environment, rename to get a fresh var.
-    // TODO: might need to look inside types in btemp->lb and btemp->ub
     int envsize = 0;
     while (btemp != NULL) {
         envsize++;
@@ -3066,13 +3073,9 @@ static jl_value_t *intersect_unionall_(jl_value_t *t, jl_unionall_t *u, jl_stenv
             vb->limited = 1;
             return t;
         }
-        if (btemp->var == u->var || btemp->lb == (jl_value_t*)u->var ||
-            btemp->ub == (jl_value_t*)u->var) {
-            u = jl_rename_unionall(u);
-            break;
-        }
         btemp = btemp->prev;
     }
+    u = unalias_unionall(u, e);
     JL_GC_PUSH1(&u);
     vb->var = u->var;
     e->vars = vb;
diff --git a/test/subtype.jl b/test/subtype.jl
index 27e8fa604a5e9..94f254e5c0a0f 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -1216,7 +1216,8 @@ let a = Tuple{T1,T1} where T1,
 end
 let a = Val{Tuple{T1,T1}} where T1,
     b = Val{Tuple{Val{S2},S6}} where S2 where S6
-    @testintersect(a, b, Val{Tuple{Val{T},Val{T}}} where T)
+    # @testintersect(a, b, Val{Tuple{Val{T},Val{T}}} where T)
+    @test_broken !Base.has_free_typevars(typeintersect(b, a))
 end
 let a = Tuple{Float64,T3,T4} where T4 where T3,
     b = Tuple{S2,Tuple{S3},S3} where S2 where S3
@@ -2572,6 +2573,32 @@ let a = Tuple{Union{Nothing, Type{Pair{T1}} where T1}}
     @test !Base.has_free_typevars(typeintersect(a, b))
 end
 
+#issue 53366
+let Y = Tuple{Val{T}, Val{Val{T}}} where T
+    A = Val{Val{T}} where T
+    T = TypeVar(:T, UnionAll(A.var, Val{A.var}))
+    B = UnionAll(T, Val{T})
+    X = Tuple{A, B}
+    @testintersect(X, Y, !Union{})
+end
+
+#issue 53621 (requires assertions enabled)
+abstract type A53621{T, R, C, U} <: AbstractSet{Union{C, U}} end
+struct T53621{T, R<:Real, C, U} <: A53621{T, R, C, U} end
+let
+    U = TypeVar(:U)
+    C = TypeVar(:C)
+    T = TypeVar(:T)
+    R = TypeVar(:R)
+    CC = TypeVar(:CC, Union{C, U})
+    UU = TypeVar(:UU, Union{C, U})
+    S1 = UnionAll(T, UnionAll(R, Type{UnionAll(C, UnionAll(U, T53621{T, R, C, U}))}))
+    S2 = UnionAll(C, UnionAll(U, UnionAll(CC, UnionAll(UU, UnionAll(T, UnionAll(R, T53621{T, R, CC, UU}))))))
+    S = Tuple{S1, S2}
+    T = Tuple{Type{T53621{T, R}}, AbstractSet{T}} where {T, R}
+    @testintersect(S, T, !Union{})
+end
+
 #issue 53371
 struct T53371{A,B,C,D,E} end
 S53371{A} = Union{Int, <:A}

From 02f27c24929ab2561bcb21d3f58c1d313ae5d6e8 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sat, 2 Mar 2024 15:29:18 +0800
Subject: [PATCH 1073/1315] typeintersect: more organized innervar wrapping

---
 src/subtype.c   | 46 +++++++++++++++++++++++++++++++++++++++++-----
 test/subtype.jl |  3 +--
 2 files changed, 42 insertions(+), 7 deletions(-)

diff --git a/src/subtype.c b/src/subtype.c
index d024b3920e924..c8b6f9a346bd1 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -2849,7 +2849,7 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
 
     // I. Handle indirect innervars (make them behave like direct innervars).
     //   1) record if btemp->lb/ub has indirect innervars.
-    //   2) substitute `vb->var` with `varval`/`varval`
+    //   2) substitute `vb->var` with `varval`/`newvar`
     //   note: We only store the innervar in the outmost `varbinding`,
     //       thus we must check all inner env to ensure the recording/substitution
     //       is complete
@@ -2913,6 +2913,7 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
                     }
                     envind++;
                 }
+                // FIXME: innervar that depend on `ivar` should also be updated.
             }
         }
     }
@@ -3028,7 +3029,8 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
     }
 
     if (vb->innervars != NULL) {
-        for (size_t i = 0; i < jl_array_nrows(vb->innervars); i++) {
+        size_t len = jl_array_nrows(vb->innervars), count = 0;
+        for (size_t i = 0; i < len; i++) {
             jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
             // the `btemp->prev` walk is only giving a sort of post-order guarantee (since we are
             // iterating 2 trees at once), so once we set `wrap`, there might remain other branches
@@ -3042,11 +3044,45 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
             if (wrap) {
                 if (wrap->innervars == NULL)
                     wrap->innervars = jl_alloc_array_1d(jl_array_any_type, 0);
+                // FIXME: `var`'s dependence should also be pushed into `wrap->innervars`.
                 jl_array_ptr_1d_push(wrap->innervars, (jl_value_t*)var);
+                jl_array_ptr_set(vb->innervars, i, (jl_value_t*)NULL);
             }
-            else if (res != jl_bottom_type) {
-                if (jl_has_typevar(res, var))
-                    res = jl_type_unionall((jl_tvar_t*)var, res);
+        }
+        for (size_t i = 0; i < len; i++) {
+            jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
+            if (var) {
+                if (count < i)
+                    jl_array_ptr_set(vb->innervars, count, (jl_value_t*)var);
+                count++;
+            }
+        }
+        if (count != len)
+            jl_array_del_end(vb->innervars, len - count);
+        if (res != jl_bottom_type) {
+            while (count > 1) {
+                int changed = 0;
+                // Now need to re-sort the vb->innervars using the partial-ordering predicate `jl_has_typevar`.
+                // If this is slow, we could possibly switch to a simpler graph sort than this triple loop, such as Tarjan's SCC.
+                // But for now we use a variant on selection sort for partial-orders.
+                for (size_t i = 0; i < count - 1; i++) {
+                    jl_tvar_t *vari = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
+                    for (size_t j = i+1; j < count; j++) {
+                        jl_tvar_t *varj = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, j);
+                        if (jl_has_typevar(varj->lb, vari) || jl_has_typevar(varj->ub, vari)) {
+                            jl_array_ptr_set(vb->innervars, j, (jl_value_t*)vari);
+                            jl_array_ptr_set(vb->innervars, i, (jl_value_t*)varj);
+                            changed = 1;
+                            break;
+                        }
+                    }
+                    if (changed) break;
+                }
+                if (!changed) break;
+            }
+            for (size_t i = 0; i < count; i++) {
+                jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
+                res = jl_type_unionall(var, res);
             }
         }
     }
diff --git a/test/subtype.jl b/test/subtype.jl
index 94f254e5c0a0f..7805c232bd050 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -1216,8 +1216,7 @@ let a = Tuple{T1,T1} where T1,
 end
 let a = Val{Tuple{T1,T1}} where T1,
     b = Val{Tuple{Val{S2},S6}} where S2 where S6
-    # @testintersect(a, b, Val{Tuple{Val{T},Val{T}}} where T)
-    @test_broken !Base.has_free_typevars(typeintersect(b, a))
+    @testintersect(a, b, Val{Tuple{Val{T},Val{T}}} where T)
 end
 let a = Tuple{Float64,T3,T4} where T4 where T3,
     b = Tuple{S2,Tuple{S3},S3} where S2 where S3

From 6335386555ff5af3fa7844a8674473871c8427dd Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Wed, 6 Mar 2024 10:04:22 -0500
Subject: [PATCH 1074/1315] Unexport with, at_with, and ScopedValue from Base
 (#53004)

fixes #52535

---------

Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
---
 base/exports.jl              |  5 -----
 base/logging.jl              |  1 +
 base/mpfr.jl                 |  8 ++++----
 base/scopedvalues.jl         |  2 ++
 doc/src/base/scopedvalues.md | 25 ++++++++++++++++++++++---
 test/scopedvalues.jl         | 10 +++++-----
 6 files changed, 34 insertions(+), 17 deletions(-)

diff --git a/base/exports.jl b/base/exports.jl
index cb4acce27c66d..2e0cd9b46e846 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -653,11 +653,6 @@ export
     sprint,
     summary,
 
-# ScopedValue
-    with,
-    @with,
-    ScopedValue,
-
 # logging
     @debug,
     @info,
diff --git a/base/logging.jl b/base/logging.jl
index bef8a89118371..75b8eea5051d2 100644
--- a/base/logging.jl
+++ b/base/logging.jl
@@ -3,6 +3,7 @@
 module CoreLogging
 
 import Base: isless, +, -, convert, show
+import Base: ScopedValue, with, @with
 
 export
     AbstractLogger,
diff --git a/base/mpfr.jl b/base/mpfr.jl
index d3045371829f6..788ecf4f99790 100644
--- a/base/mpfr.jl
+++ b/base/mpfr.jl
@@ -109,9 +109,9 @@ end
 tie_breaker_is_to_even(::MPFRRoundingMode) = true
 
 const ROUNDING_MODE = Ref{MPFRRoundingMode}(MPFRRoundNearest)
-const CURRENT_ROUNDING_MODE = ScopedValue{MPFRRoundingMode}()
+const CURRENT_ROUNDING_MODE = Base.ScopedValue{MPFRRoundingMode}()
 const DEFAULT_PRECISION = Ref{Clong}(256)
-const CURRENT_PRECISION = ScopedValue{Clong}()
+const CURRENT_PRECISION = Base.ScopedValue{Clong}()
 # Basic type and initialization definitions
 
 # Warning: the constants are MPFR implementation details from
@@ -162,7 +162,7 @@ significand_limb_count(x::BigFloat) = div(sizeof(x._d), sizeof(Limb), RoundToZer
 rounding_raw(::Type{BigFloat}) = something(Base.ScopedValues.get(CURRENT_ROUNDING_MODE), ROUNDING_MODE[])
 setrounding_raw(::Type{BigFloat}, r::MPFRRoundingMode) = ROUNDING_MODE[]=r
 function setrounding_raw(f::Function, ::Type{BigFloat}, r::MPFRRoundingMode)
-    @with(CURRENT_ROUNDING_MODE => r, f())
+    Base.@with(CURRENT_ROUNDING_MODE => r, f())
 end
 
 
@@ -1109,7 +1109,7 @@ Note: `nextfloat()`, `prevfloat()` do not use the precision mentioned by
     The `base` keyword requires at least Julia 1.8.
 """
 function setprecision(f::Function, ::Type{BigFloat}, prec::Integer; base::Integer=2)
-    @with(CURRENT_PRECISION => _convert_precision_from_base(prec, base), f())
+    Base.@with(CURRENT_PRECISION => _convert_precision_from_base(prec, base), f())
 end
 
 setprecision(f::Function, prec::Integer; base::Integer=2) = setprecision(f, BigFloat, prec; base)
diff --git a/base/scopedvalues.jl b/base/scopedvalues.jl
index ee4571b8ae497..339ee717d5fd6 100644
--- a/base/scopedvalues.jl
+++ b/base/scopedvalues.jl
@@ -19,6 +19,8 @@ Dynamic scopes are propagated across tasks.
 # Examples
 
 ```jldoctest
+julia> using Base.ScopedValues;
+
 julia> const sval = ScopedValue(1);
 
 julia> sval[]
diff --git a/doc/src/base/scopedvalues.md b/doc/src/base/scopedvalues.md
index 0de29308c5df8..2991522900e1a 100644
--- a/doc/src/base/scopedvalues.md
+++ b/doc/src/base/scopedvalues.md
@@ -17,8 +17,8 @@ concurrently.
     Scoped values were introduced in Julia 1.11. In Julia 1.8+ a compatible
     implementation is available from the package ScopedValues.jl.
 
-In its simplest form you can create a [`ScopedValue`](@ref) with a
-default value and then use [`with`](@ref Base.with) or [`@with`](@ref) to
+In its simplest form you can create a [`Base.ScopedValue`](@ref) with a
+default value and then use [`Base.with`](@ref with) or [`Base.@with`](@ref) to
 enter a new dynamic scope.
 
 The new scope will inherit all values from the parent scope
@@ -54,6 +54,8 @@ f() # 1
 Now using a `ScopedValue` we can use **dynamic** scoping.
 
 ```julia
+using Base.ScopedValues
+
 x = ScopedValue(1)
 f() = @show x[]
 with(x=>5) do
@@ -70,6 +72,8 @@ and you can set the value of multiple `ScopedValue`s with one call to `with`.
 
 
 ```julia
+using Base.ScopedValues
+
 const scoped_val = ScopedValue(1)
 const scoped_val2 = ScopedValue(0)
 
@@ -94,6 +98,8 @@ Since `with` requires a closure or a function and creates another call-frame,
 it can sometimes be beneficial to use the macro form.
 
 ```julia
+using Base.ScopedValues
+
 const STATE = ScopedValue{State}()
 with_state(f, state::State) = @with(STATE => state, f())
 ```
@@ -106,7 +112,9 @@ The parent task and the two child tasks observe independent values of the
 same scoped value at the same time.
 
 ```julia
+using Base.ScopedValues
 import Base.Threads: @spawn
+
 const scoped_val = ScopedValue(1)
 @sync begin
     with(scoped_val => 2)
@@ -128,7 +136,9 @@ values. You might want to explicitly [unshare mutable state](@ref unshare_mutabl
 when entering a new dynamic scope.
 
 ```julia
+using Base.ScopedValues
 import Base.Threads: @spawn
+
 const sval_dict = ScopedValue(Dict())
 
 # Example of using a mutable value wrongly
@@ -161,6 +171,8 @@ are not well suited for this kind of propagation; our only alternative would hav
 been to thread a value through the entire call-chain.
 
 ```julia
+using Base.ScopedValues
+
 const LEVEL = ScopedValue(:GUEST)
 
 function serve(request, response)
@@ -189,7 +201,9 @@ end
 ### [Unshare mutable state](@id unshare_mutable_state)
 
 ```julia
+using Base.ScopedValues
 import Base.Threads: @spawn
+
 const sval_dict = ScopedValue(Dict())
 
 # If you want to add new values to the dict, instead of replacing
@@ -210,6 +224,7 @@ be in (lexical) scope. This means most often you likely want to use scoped value
 as constant globals.
 
 ```julia
+using Base.ScopedValues
 const sval = ScopedValue(1)
 ```
 
@@ -218,7 +233,9 @@ Indeed one can think of scoped values as hidden function arguments.
 This does not preclude their use as non-globals.
 
 ```julia
+using Base.ScopedValues
 import Base.Threads: @spawn
+
 function main()
     role = ScopedValue(:client)
 
@@ -241,6 +258,8 @@ If you find yourself creating many `ScopedValue`'s for one given module,
 it may be better to use a dedicated struct to hold them.
 
 ```julia
+using Base.ScopedValues
+
 Base.@kwdef struct Configuration
     color::Bool = false
     verbose::Bool = false
@@ -260,7 +279,7 @@ end
 Base.ScopedValues.ScopedValue
 Base.ScopedValues.with
 Base.ScopedValues.@with
-Base.isassigned(::ScopedValue)
+Base.isassigned(::Base.ScopedValues.ScopedValue)
 Base.ScopedValues.get
 ```
 
diff --git a/test/scopedvalues.jl b/test/scopedvalues.jl
index 39de22bc2bee5..ca700521b50cd 100644
--- a/test/scopedvalues.jl
+++ b/test/scopedvalues.jl
@@ -1,5 +1,5 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
-import Base: ScopedValues
+using Base.ScopedValues
 
 @testset "errors" begin
     @test ScopedValue{Float64}(1)[] == 1.0
@@ -67,13 +67,13 @@ import Base.Threads: @spawn
 end
 
 @testset "show" begin
-    @test sprint(show, ScopedValue{Int}()) == "ScopedValue{$Int}(undefined)"
-    @test sprint(show, sval) == "ScopedValue{$Int}(1)"
+    @test sprint(show, ScopedValue{Int}()) == "Base.ScopedValues.ScopedValue{$Int}(undefined)"
+    @test sprint(show, sval) == "Base.ScopedValues.ScopedValue{$Int}(1)"
     @test sprint(show, Core.current_scope()) == "nothing"
     with(sval => 2.0) do
-        @test sprint(show, sval) == "ScopedValue{$Int}(2)"
+        @test sprint(show, sval) == "Base.ScopedValues.ScopedValue{$Int}(2)"
         objid = sprint(show, Base.objectid(sval))
-        @test sprint(show, Core.current_scope()) == "Base.ScopedValues.Scope(ScopedValue{$Int}@$objid => 2)"
+        @test sprint(show, Core.current_scope()) == "Base.ScopedValues.Scope(Base.ScopedValues.ScopedValue{$Int}@$objid => 2)"
     end
 end
 

From cf5f1632933a146c82ae9b33e76d89241d976dbd Mon Sep 17 00:00:00 2001
From: Phillip Alday <palday@users.noreply.github.com>
Date: Thu, 7 Mar 2024 09:07:59 -0600
Subject: [PATCH 1075/1315] typo fix in scoped values docs (#53629)

---
 doc/src/base/scopedvalues.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/base/scopedvalues.md b/doc/src/base/scopedvalues.md
index 2991522900e1a..8c3340ab9cf11 100644
--- a/doc/src/base/scopedvalues.md
+++ b/doc/src/base/scopedvalues.md
@@ -295,6 +295,6 @@ version of Julia.
 ## Design inspiration
 
 This design was heavily inspired by [JEPS-429](https://openjdk.org/jeps/429),
-which in turn was inspired by dynamically scoped free variables in many Lisp dialects. In particular Interlisp-D and it's deep binding strategy.
+which in turn was inspired by dynamically scoped free variables in many Lisp dialects. In particular Interlisp-D and its deep binding strategy.
 
 A prior design discussed was context variables ala [PEPS-567](https://peps.python.org/pep-0567/) and implemented in Julia as [ContextVariablesX.jl](https://github.com/tkf/ContextVariablesX.jl).

From a1828802515e01fcf89c10decec85c37c4b5a531 Mon Sep 17 00:00:00 2001
From: Frames White <me@oxinabox.net>
Date: Thu, 7 Mar 2024 23:09:12 +0800
Subject: [PATCH 1076/1315] use isempty in tests (#53617)

This was not being used as it didn't have fancy printing when it failed.
But that was fixed in https://github.com/JuliaLang/julia/pull/30721
so we can do this now
---
 test/ambiguous.jl | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/test/ambiguous.jl b/test/ambiguous.jl
index ac5b524931046..748660cc9c981 100644
--- a/test/ambiguous.jl
+++ b/test/ambiguous.jl
@@ -332,23 +332,22 @@ end
 @test length(detect_unbound_args(M25341; recursive=true)) == 1
 
 # Test that Core and Base are free of UndefVarErrors
-# not using isempty so this prints more information when it fails
 @testset "detect_unbound_args in Base and Core" begin
     # 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 need_to_handle_undef_sparam == Set()
+        @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 need_to_handle_undef_sparam == Set()
+        @test isempty(need_to_handle_undef_sparam)
     end
     let need_to_handle_undef_sparam =
             Set{Method}(detect_unbound_args(Base; recursive=true, allowed_undefineds))
         pop!(need_to_handle_undef_sparam, which(Base._totuple, (Type{Tuple{Vararg{E}}} where E, Any, Any)))
         pop!(need_to_handle_undef_sparam, which(Base.eltype, Tuple{Type{Tuple{Any}}}))
         pop!(need_to_handle_undef_sparam, first(methods(Base.same_names)))
-        @test_broken need_to_handle_undef_sparam == Set()
+        @test_broken isempty(need_to_handle_undef_sparam)
         pop!(need_to_handle_undef_sparam, which(Base._cat, Tuple{Any, AbstractArray}))
         pop!(need_to_handle_undef_sparam, which(Base.byteenv, (Union{AbstractArray{Pair{T,V}, 1}, Tuple{Vararg{Pair{T,V}}}} where {T<:AbstractString,V},)))
         pop!(need_to_handle_undef_sparam, which(Base.float, Tuple{AbstractArray{Union{Missing, T},N} where {T, N}}))
@@ -357,7 +356,7 @@ end
         pop!(need_to_handle_undef_sparam, which(Base.zero, Tuple{Type{Union{Missing, T}} where T}))
         pop!(need_to_handle_undef_sparam, which(Base.one, Tuple{Type{Union{Missing, T}} where T}))
         pop!(need_to_handle_undef_sparam, which(Base.oneunit, Tuple{Type{Union{Missing, T}} where T}))
-        @test need_to_handle_undef_sparam == Set()
+        @test isempty(need_to_handle_undef_sparam)
     end
 end
 

From d45581c18d649ad19313300d6766587d2aed0155 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 8 Mar 2024 01:15:35 +0900
Subject: [PATCH 1077/1315] inlining: use method match signature for
 union-spliting (#53600)

In cases where the results of constant inference, like concrete-eval,
are used for union-split inlining, `isa`-blocks are generated using the
`result.edge.specTypes` stored within each `result`. However, it's been
found that the `edge` returned by abstract interpretation may have been
widened by the new `@nospecializeinfer`, which can result in invalid
union-splitting. To address this problem, this commit tweaks the
inlining algorithm so that it performs union-split inlining using the
original signatures that abstract interpretation used for union-split
inference, by using `match::MethodMatch`.

- fixes #53590
---
 base/compiler/ssair/inlining.jl | 23 ++++++++++++-----------
 test/compiler/inference.jl      | 12 ++++++++++++
 2 files changed, 24 insertions(+), 11 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index a89583494ee13..3e57bc8503e06 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1331,11 +1331,11 @@ function handle_any_const_result!(cases::Vector{InliningCase},
     @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
     allow_abstract::Bool, allow_typevars::Bool)
     if isa(result, ConcreteResult)
-        return handle_concrete_result!(cases, result, info, state)
+        return handle_concrete_result!(cases, result, match, info, state)
     elseif isa(result, SemiConcreteResult)
-        return handle_semi_concrete_result!(cases, result, info, flag, state; allow_abstract)
+        return handle_semi_concrete_result!(cases, result, match, info, flag, state; allow_abstract)
     elseif isa(result, ConstPropResult)
-        return handle_const_prop_result!(cases, result, info, flag, state; allow_abstract, allow_typevars)
+        return handle_const_prop_result!(cases, result, match, info, flag, state; allow_abstract, allow_typevars)
     else
         @assert result === nothing || result isa VolatileInferenceResult
         return handle_match!(cases, match, argtypes, info, flag, state; allow_abstract, allow_typevars, volatile_inf_result = result)
@@ -1481,11 +1481,11 @@ function handle_match!(cases::Vector{InliningCase},
     return true
 end
 
-function handle_const_prop_result!(cases::Vector{InliningCase},
-    result::ConstPropResult, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
+function handle_const_prop_result!(cases::Vector{InliningCase}, result::ConstPropResult,
+    match::MethodMatch, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
     allow_abstract::Bool, allow_typevars::Bool)
     mi = result.result.linfo
-    spec_types = mi.specTypes
+    spec_types = match.spec_types
     allow_abstract || isdispatchtuple(spec_types) || return false
     if !validate_sparams(mi.sparam_vals)
         (allow_typevars && !may_have_fcalls(mi.def::Method)) || return false
@@ -1520,10 +1520,10 @@ function semiconcrete_result_item(result::SemiConcreteResult,
 end
 
 function handle_semi_concrete_result!(cases::Vector{InliningCase}, result::SemiConcreteResult,
-        @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
-        allow_abstract::Bool)
+    match::MethodMatch, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
+    allow_abstract::Bool)
     mi = result.mi
-    spec_types = mi.specTypes
+    spec_types = match.spec_types
     allow_abstract || isdispatchtuple(spec_types) || return false
     validate_sparams(mi.sparam_vals) || return false
     item = semiconcrete_result_item(result, info, flag, state)
@@ -1532,10 +1532,11 @@ function handle_semi_concrete_result!(cases::Vector{InliningCase}, result::SemiC
     return true
 end
 
-function handle_concrete_result!(cases::Vector{InliningCase}, result::ConcreteResult, @nospecialize(info::CallInfo), state::InliningState)
+function handle_concrete_result!(cases::Vector{InliningCase}, result::ConcreteResult,
+    match::MethodMatch, @nospecialize(info::CallInfo), state::InliningState)
     case = concrete_result_item(result, info, state)
     case === nothing && return false
-    push!(cases, InliningCase(result.mi.specTypes, case))
+    push!(cases, InliningCase(match.spec_types, case))
     return true
 end
 
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index a9b1d89d40e9d..d6cd231dfdd58 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5627,3 +5627,15 @@ end
 
 # Issue #52613
 @test (code_typed((Any,)) do x; TypeVar(x...); end)[1][2] === TypeVar
+
+# https://github.com/JuliaLang/julia/issues/53590
+func53590(b) = b ? Int : Float64
+function issue53590(b1, b2)
+    T1 = func53590(b1)
+    T2 = func53590(b2)
+    return typejoin(T1, T2)
+end
+@test issue53590(true, true) == Int
+@test issue53590(true, false) == Real
+@test issue53590(false, false) == Float64
+@test issue53590(false, true) == Real

From f6504e4af93a3ce33391b2bd858c1a3e9fb9fe54 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 8 Mar 2024 09:42:49 +0900
Subject: [PATCH 1078/1315] add `construct_[post]domtree(::[IRCode|CFG])`
 interfaces (#53638)

We currently have `construct_[post]domtree(::Vector{BasicBlock})` only.
The higher level interfaces are often convenient.
---
 base/compiler/inferencestate.jl |  6 +++---
 base/compiler/optimize.jl       |  4 ++--
 base/compiler/ssair/ir.jl       |  6 ++++++
 test/compiler/irpasses.jl       |  4 ++--
 test/compiler/ssair.jl          | 14 +++++++-------
 test/compiler/tarjan.jl         |  2 +-
 6 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 663fd78c90dba..60e55b8ad2cf0 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -177,7 +177,7 @@ mutable struct LazyCFGReachability
 end
 function get!(x::LazyCFGReachability)
     isdefined(x, :reachability) && return x.reachability
-    domtree = construct_domtree(x.ir.cfg.blocks)
+    domtree = construct_domtree(x.ir)
     return x.reachability = CFGReachability(x.ir.cfg, domtree)
 end
 
@@ -189,8 +189,8 @@ end
 function get!(x::LazyGenericDomtree{IsPostDom}) where {IsPostDom}
     isdefined(x, :domtree) && return x.domtree
     return @timeit "domtree 2" x.domtree = IsPostDom ?
-        construct_postdomtree(x.ir.cfg.blocks) :
-        construct_domtree(x.ir.cfg.blocks)
+        construct_postdomtree(x.ir) :
+        construct_domtree(x.ir)
 end
 
 const LazyDomtree = LazyGenericDomtree{false}
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 6de08e64c14e7..c30f15864892d 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -571,7 +571,7 @@ function get!(lazyagdomtree::LazyAugmentedDomtree)
             cfg_insert_edge!(cfg, bb, length(cfg.blocks))
         end
     end
-    domtree = construct_domtree(cfg.blocks)
+    domtree = construct_domtree(cfg)
     return lazyagdomtree.agdomtree = AugmentedDomtree(cfg, domtree)
 end
 
@@ -1180,7 +1180,7 @@ function slot2reg(ir::IRCode, ci::CodeInfo, sv::OptimizationState)
     # need `ci` for the slot metadata, IR for the code
     svdef = sv.linfo.def
     nargs = isa(svdef, Method) ? Int(svdef.nargs) : 0
-    @timeit "domtree 1" domtree = construct_domtree(ir.cfg.blocks)
+    @timeit "domtree 1" domtree = construct_domtree(ir)
     defuse_insts = scan_slot_def_use(nargs, ci, ir.stmts.stmt)
     𝕃ₒ = optimizer_lattice(sv.inlining.interp)
     @timeit "construct_ssa" ir = construct_ssa!(ci, ir, sv, domtree, defuse_insts, 𝕃ₒ) # consumes `ir`
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 80d6d5fde556d..ca658ad101f7f 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -397,6 +397,12 @@ function IRCode()
     return ir
 end
 
+construct_domtree(ir::IRCode) = construct_domtree(ir.cfg)
+construct_domtree(cfg::CFG) = construct_domtree(cfg.blocks)
+
+construct_postdomtree(ir::IRCode) = construct_postdomtree(ir.cfg)
+construct_postdomtree(cfg::CFG) = construct_postdomtree(cfg.blocks)
+
 function block_for_inst(ir::IRCode, inst::Int)
     if inst > length(ir.stmts)
         inst = ir.new_nodes.info[inst - length(ir.stmts)].pos
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 9345c2e26db33..35aba9f647ea8 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -29,7 +29,7 @@ let code = Any[
         ReturnNode(Core.SSAValue(10)),
     ]
     ir = make_ircode(code)
-    domtree = Core.Compiler.construct_domtree(ir.cfg.blocks)
+    domtree = Core.Compiler.construct_domtree(ir)
     ir = Core.Compiler.domsort_ssa!(ir, domtree)
     Core.Compiler.verify_ir(ir)
     phi = ir.stmts.stmt[3]
@@ -47,7 +47,7 @@ let code = Any[]
     push!(code, Expr(:call, :opaque))
     push!(code, ReturnNode(nothing))
     ir = make_ircode(code)
-    domtree = Core.Compiler.construct_domtree(ir.cfg.blocks)
+    domtree = Core.Compiler.construct_domtree(ir)
     ir = Core.Compiler.domsort_ssa!(ir, domtree)
     Core.Compiler.verify_ir(ir)
 end
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 0a53dec80f732..e237ab732ef57 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -73,8 +73,8 @@ let cfg = CFG(BasicBlock[
     @test dfs.from_pre[dfs.to_parent_pre[dfs.to_pre[5]]] == 4
     let correct_idoms = Compiler.naive_idoms(cfg.blocks),
         correct_pidoms = Compiler.naive_idoms(cfg.blocks, true)
-        @test Compiler.construct_domtree(cfg.blocks).idoms_bb == correct_idoms
-        @test Compiler.construct_postdomtree(cfg.blocks).idoms_bb == correct_pidoms
+        @test Compiler.construct_domtree(cfg).idoms_bb == correct_idoms
+        @test Compiler.construct_postdomtree(cfg).idoms_bb == correct_pidoms
         # For completeness, reverse the order of pred/succ in the CFG and verify
         # the answer doesn't change (it does change the which node is chosen
         # as the semi-dominator, since it changes the DFS numbering).
@@ -85,8 +85,8 @@ let cfg = CFG(BasicBlock[
                 c && (blocks[4] = make_bb(reverse(blocks[4].preds), blocks[4].succs))
                 d && (blocks[5] = make_bb(reverse(blocks[5].preds), blocks[5].succs))
                 cfg′ = CFG(blocks, cfg.index)
-                @test Compiler.construct_domtree(cfg′.blocks).idoms_bb == correct_idoms
-                @test Compiler.construct_postdomtree(cfg′.blocks).idoms_bb == correct_pidoms
+                @test Compiler.construct_domtree(cfg′).idoms_bb == correct_idoms
+                @test Compiler.construct_postdomtree(cfg′).idoms_bb == correct_pidoms
             end
         end
     end
@@ -292,7 +292,7 @@ let cfg = CFG(BasicBlock[
         make_bb([2, 6], []),
         make_bb([4],    [5, 3]),
     ], Int[])
-    domtree = Compiler.construct_domtree(cfg.blocks)
+    domtree = Compiler.construct_domtree(cfg)
     @test domtree.dfs_tree.to_pre == [1, 2, 4, 5, 3, 6]
     @test domtree.idoms_bb == Compiler.naive_idoms(cfg.blocks) == [0, 1, 1, 3, 1, 4]
 
@@ -486,7 +486,7 @@ let ir = Base.code_ircode((Bool,Any)) do c, x
         end
     end
     # domination analysis
-    domtree = Core.Compiler.construct_domtree(ir.cfg.blocks)
+    domtree = Core.Compiler.construct_domtree(ir)
     @test Core.Compiler.dominates(domtree, 1, 2)
     @test Core.Compiler.dominates(domtree, 1, 3)
     @test Core.Compiler.dominates(domtree, 1, 4)
@@ -497,7 +497,7 @@ let ir = Base.code_ircode((Bool,Any)) do c, x
         end
     end
     # post domination analysis
-    post_domtree = Core.Compiler.construct_postdomtree(ir.cfg.blocks)
+    post_domtree = Core.Compiler.construct_postdomtree(ir)
     @test Core.Compiler.postdominates(post_domtree, 4, 1)
     @test Core.Compiler.postdominates(post_domtree, 4, 2)
     @test Core.Compiler.postdominates(post_domtree, 4, 3)
diff --git a/test/compiler/tarjan.jl b/test/compiler/tarjan.jl
index 44acafb2ca5f4..11c6b68e58b1b 100644
--- a/test/compiler/tarjan.jl
+++ b/test/compiler/tarjan.jl
@@ -102,7 +102,7 @@ function test_reachability(V, E; deletions = 2E ÷ 3, all_checks=false)
     end
 
     cfg = rand_cfg(V, E)
-    domtree = Core.Compiler.construct_domtree(cfg.blocks)
+    domtree = Core.Compiler.construct_domtree(cfg)
     reachability = CFGReachability(cfg, domtree)
     check_reachability(reachability, cfg, domtree, all_checks)
 

From fa90883d1e827387046d8046b8271da0f3bd525a Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Thu, 7 Mar 2024 22:31:27 -0500
Subject: [PATCH 1079/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20e7d740ac8=20to=2056c379045=20(#53637)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: e7d740ac8
New commit: 56c379045
Julia version: 1.12.0-DEV
Pkg version: 1.11.0(Does not match)
Bump invoked by: @KristofferC
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e...56c379045c8cf876b365c284a5b442f2dc9fc8af

```
$ git log --oneline e7d740ac8..56c379045
56c379045 make `delayed_delete_dir` usage a bit more backwards compatible (#3830)
5a68d7953 restore unwrap UnstableIO in precompile (#3831)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5     | 1 +
 .../Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512  | 1 +
 .../Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5     | 1 -
 .../Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512  | 1 -
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512

diff --git a/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5 b/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5
new file mode 100644
index 0000000000000..3fc997ee6d795
--- /dev/null
+++ b/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5
@@ -0,0 +1 @@
+de47c3414e7e3168f77b20676c3f7631
diff --git a/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512 b/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512
new file mode 100644
index 0000000000000..7d14fdc309cfe
--- /dev/null
+++ b/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512
@@ -0,0 +1 @@
+b4b7ebb7fe636bbb9d653cb826e1a74eadcbc936dbf1a76281a7cc2e439a17f48ea8d04b77d825deb94a0fe228490760df5836837cafbcbd7308251d0be6589f
diff --git a/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5 b/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5
deleted file mode 100644
index 96ceb05a2c8d4..0000000000000
--- a/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-0d226d1a3cf5c4cf207788fc3c5ba50c
diff --git a/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512 b/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512
deleted file mode 100644
index 304829ca32df0..0000000000000
--- a/deps/checksums/Pkg-e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-e9516466573c24d2bd90645edbdc9c2dbe3f4f4e1704d665525429ff6a463208ff849ebb7c4f9d2d2627d69d1b2cc56a9b305a89e30a0e16b666cbd91f34ced3
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 9ca239a2c6b5a..a68d4a1697eac 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = e7d740ac82fa4c289bb58f9acb6e60eebb6d8a8e
+PKG_SHA1 = 56c379045c8cf876b365c284a5b442f2dc9fc8af
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 321fb2ccda65aa122c3549ef4951c6890b440cf2 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 8 Mar 2024 01:26:10 -0500
Subject: [PATCH 1080/1315] sroa: Fix incorrect scope counting (#53630)

Sroa was incorrectly assuming that every :leave leaves exactly one
scope. In reality, it leaves as many scopes as the corresponding :leave
references. Fix that to fix #53521.
---
 base/compiler/ssair/passes.jl | 17 ++++++++++++++---
 test/compiler/irpasses.jl     | 19 +++++++++++++++++++
 2 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 0d855f38cd286..4c34a6d8fe9de 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1225,10 +1225,21 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
             bb = compact.active_result_bb - 1
             bbs = scope_mapping[bb]
             if isexpr(stmt, :leave) && bbs != SSAValue(0)
-                update_scope_mapping!(scope_mapping, bb+1, scope_mapping[block_for_inst(compact, bbs)])
-            else
-                update_scope_mapping!(scope_mapping, bb+1, bbs)
+                # Here we want to count the number of scopes that we're leaving,
+                # which is the same as the number of EnterNodes being referenced
+                # by `stmt.args`. Which have :scope set. In practice, the frontend
+                # does emit these in order, so we could simply go to the last one,
+                # but we want to avoid making that semantic assumption.
+                for i = 1:length(stmt.args)
+                    scope = stmt.args[i]
+                    scope === nothing && continue
+                    enter = compact[scope][:inst]
+                    @assert isa(enter, EnterNode)
+                    isdefined(enter, :scope) || continue
+                    bbs = scope_mapping[block_for_inst(compact, bbs)]
+                end
             end
+            update_scope_mapping!(scope_mapping, bb+1, bbs)
         end
         # check whether this statement is `getfield` / `setfield!` (or other "interesting" statement)
         is_setfield = is_isdefined = is_finalizer = is_keyvalue_get = false
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 35aba9f647ea8..c124832030cbd 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1801,3 +1801,22 @@ let n = 1000
     end
 end
 @test f_1000_blocks() == 0
+
+# https://github.com/JuliaLang/julia/issues/53521
+# Incorrect scope counting in :leave
+using Base.ScopedValues
+function f53521()
+    VALUE = ScopedValue(1)
+    @with VALUE => 2 begin
+        for i = 1
+            @with VALUE => 3 begin
+                try
+                    foo()
+                catch
+                    nothing
+                end
+            end
+        end
+    end
+end
+@test code_typed(f53521)[1][2] === Nothing

From 4dcf35786ec164832e1eb961c9cdacae7974a27a Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 8 Mar 2024 01:26:43 -0500
Subject: [PATCH 1081/1315] inference: Don't confuse frames in different
 interpreters (#53627)

Diffractor's abstract interpreter sometimes needs to do side queries
using the native interpreter. These are pushed onto the regular
inference callstack in anticipation of a future where compiler plugins
may want to recurse from the native interpreter back into the Diffractor
abstract interpreter. However, this introduced a subtle challenge: When
the native interpreter is looking at a frame that is currently on the
inference stack, it would treat them as the same, incorrectly merging
inference across the two abstract interpreters (which have different
semantics and may not be confused). The caches for the two abstract
interpreters were already different, so once things are inferred,
there's no problem (likely because things were already inferred on the
native interpreter), but if not, this could cause subtle and hard to
debug problems.
---
 base/compiler/abstractinterpretation.jl |  4 ++++
 base/compiler/inferencestate.jl         | 11 +++++++++++
 base/compiler/typeinfer.jl              |  2 +-
 base/show.jl                            |  6 ++++++
 4 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 45f4dea1e46e1..00bd8a9310de7 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -689,6 +689,10 @@ function edge_matches_sv(interp::AbstractInterpreter, frame::AbsIntState,
     if callee_method2 !== inf_method2
         return false
     end
+    if isa(frame, InferenceState) && cache_owner(frame.interp) !== cache_owner(interp)
+        # Don't assume that frames in different interpreters are the same
+        return false
+    end
     if !hardlimit || InferenceParams(interp).ignore_recursion_hardlimit
         # if this is a soft limit,
         # also inspect the parent of this edge,
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 60e55b8ad2cf0..d4c4d94b6db31 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -731,7 +731,16 @@ function empty_backedges!(frame::InferenceState, currpc::Int=frame.currpc)
 end
 
 function print_callstack(sv::InferenceState)
+    print("=================== Callstack: ==================\n")
+    idx = 0
     while sv !== nothing
+        print("[")
+        print(idx)
+        if !isa(sv.interp, NativeInterpreter)
+            print(", ")
+            print(typeof(sv.interp))
+        end
+        print("] ")
         print(sv.linfo)
         is_cached(sv) || print("  [uncached]")
         println()
@@ -740,7 +749,9 @@ function print_callstack(sv::InferenceState)
             println()
         end
         sv = sv.parent
+        idx += 1
     end
+    print("================= End callstack ==================\n")
 end
 
 function narguments(sv::InferenceState, include_va::Bool=true)
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index b659fc2a88e6c..3ec9c1a3811ed 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -746,7 +746,7 @@ function merge_call_chain!(interp::AbstractInterpreter, parent::InferenceState,
 end
 
 function is_same_frame(interp::AbstractInterpreter, mi::MethodInstance, frame::InferenceState)
-    return mi === frame_instance(frame)
+    return mi === frame_instance(frame) && cache_owner(interp) === cache_owner(frame.interp)
 end
 
 function poison_callstack!(infstate::InferenceState, topmost::InferenceState)
diff --git a/base/show.jl b/base/show.jl
index df429830b16fd..33832f898d240 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -2888,6 +2888,12 @@ show(io::IO, ::Core.Compiler.NativeInterpreter) =
 show(io::IO, cache::Core.Compiler.CachedMethodTable) =
     print(io, typeof(cache), "(", Core.Compiler.length(cache.cache), " entries)")
 
+function show(io::IO, limited::Core.Compiler.LimitedAccuracy)
+    print(io, "Core.Compiler.LimitedAccuracy(")
+    show(io, limited.typ)
+    print(io, ", #= ", Core.Compiler.length(limited.causes), " cause(s) =#)")
+end
+
 function dump(io::IOContext, x::SimpleVector, n::Int, indent)
     if isempty(x)
         print(io, "empty SimpleVector")

From a998082d9c78fad066f6ebfd250989f922976c5b Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Fri, 8 Mar 2024 10:11:22 -0500
Subject: [PATCH 1082/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=2056c379045=20to=20e0821116e=20(#53654)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 56c379045
New commit: e0821116e
Julia version: 1.12.0-DEV
Pkg version: 1.12.0
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/56c379045c8cf876b365c284a5b442f2dc9fc8af...e0821116e9f4364a2b37a77183e93d055a111f4d

```
$ git log --oneline 56c379045..e0821116e
e0821116e re-enable Pkg precompilation (#3835)
a2b8729ea Update version on master to 1.12 (#3832)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5     | 1 -
 .../Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512  | 1 -
 .../Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5     | 1 +
 .../Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512

diff --git a/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5 b/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5
deleted file mode 100644
index 3fc997ee6d795..0000000000000
--- a/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-de47c3414e7e3168f77b20676c3f7631
diff --git a/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512 b/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512
deleted file mode 100644
index 7d14fdc309cfe..0000000000000
--- a/deps/checksums/Pkg-56c379045c8cf876b365c284a5b442f2dc9fc8af.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-b4b7ebb7fe636bbb9d653cb826e1a74eadcbc936dbf1a76281a7cc2e439a17f48ea8d04b77d825deb94a0fe228490760df5836837cafbcbd7308251d0be6589f
diff --git a/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5 b/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5
new file mode 100644
index 0000000000000..406f660ee9deb
--- /dev/null
+++ b/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5
@@ -0,0 +1 @@
+8cfa30c7ed9af99573a0f935df20784e
diff --git a/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512 b/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512
new file mode 100644
index 0000000000000..64fa7141cb1b4
--- /dev/null
+++ b/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512
@@ -0,0 +1 @@
+c5f7f90ae0e40902cec3b9541543acfbdc6e3301bcd95b0deb187908eac8e1c9a4de4943e10f5f5988088462be5de424da13086686fbbd77224e2139bf2fcada
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index a68d4a1697eac..e44d020b39545 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 56c379045c8cf876b365c284a5b442f2dc9fc8af
+PKG_SHA1 = e0821116e9f4364a2b37a77183e93d055a111f4d
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 78351b5c478b65295dfa143d33ddc41f546baceb Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 8 Mar 2024 10:21:33 -0500
Subject: [PATCH 1083/1315] Use Base parallel precompilation to build stdlibs
 (#53598)

Follow-on from https://github.com/JuliaLang/julia/pull/53403

This extends `Base.Precompilation.precompilepkgs` to take a list of
configurations to precompile each package with, while parallelizing
across all packages and configurations, and uses it to build the stdlib
pkgimages.

It simplifies the stdlib pkgimage build process but is (currently)
dependent on having an accurately resolved Manifest.toml (Project.toml
included to make the manifest easier to make). Any new/removed stdlibs
or changes their dependencies will require updating the Manifest.toml.
It's a bit chicken and egg, but should be manageable with manual editing
of the Manifest.toml.

In terms of speed improvement:
MacOS aarch64 CI runner 6m19s before, 5m19 with this

Note that CI builds will show the basic print with timing of each
package, whereas local build will be the tidier fancy print without
timings.

Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com>
---
 Makefile               |   3 +-
 base/loading.jl        |  33 ++++-
 base/precompilation.jl | 318 +++++++++++++++++++++++------------------
 base/util.jl           |   1 +
 pkgimage.mk            | 141 ++----------------
 stdlib/Manifest.toml   | 300 ++++++++++++++++++++++++++++++++++++++
 stdlib/Project.toml    |  61 ++++++++
 stdlib/stdlib.mk       |  21 ++-
 sysimage.mk            |   2 +-
 9 files changed, 589 insertions(+), 291 deletions(-)
 create mode 100644 stdlib/Manifest.toml
 create mode 100644 stdlib/Project.toml

diff --git a/Makefile b/Makefile
index 5ce3003dba231..d7d25998688c5 100644
--- a/Makefile
+++ b/Makefile
@@ -112,7 +112,7 @@ julia-debug julia-release : julia-% : julia-sysimg-% julia-src-% julia-symlink j
                                       julia-libccalllazyfoo julia-libccalllazybar julia-libllvmcalltest julia-base-cache
 
 stdlibs-cache-release stdlibs-cache-debug : stdlibs-cache-% : julia-%
-	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT) -f pkgimage.mk all-$*
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT) -f pkgimage.mk $*
 
 debug release : % : julia-% stdlibs-cache-%
 
@@ -588,6 +588,7 @@ clean: | $(CLEAN_TARGETS)
 	@-$(MAKE) -C $(BUILDROOT)/cli clean
 	@-$(MAKE) -C $(BUILDROOT)/test clean
 	@-$(MAKE) -C $(BUILDROOT)/stdlib clean
+	@-$(MAKE) -C $(BUILDROOT) -f pkgimage.mk clean
 	-rm -f $(BUILDROOT)/julia
 	-rm -f $(BUILDROOT)/*.tar.gz
 	-rm -f $(build_depsbindir)/stringreplace \
diff --git a/base/loading.jl b/base/loading.jl
index 5d56819159e83..774aa22bdacbd 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1524,7 +1524,21 @@ function CacheFlags(f::UInt8)
     CacheFlags(use_pkgimages, debug_level, check_bounds, inline, opt_level)
 end
 CacheFlags(f::Int) = CacheFlags(UInt8(f))
-CacheFlags() = CacheFlags(ccall(:jl_cache_flags, UInt8, ()))
+function CacheFlags(cf::CacheFlags=CacheFlags(ccall(:jl_cache_flags, UInt8, ()));
+            use_pkgimages::Union{Nothing,Bool}=nothing,
+            debug_level::Union{Nothing,Int}=nothing,
+            check_bounds::Union{Nothing,Int}=nothing,
+            inline::Union{Nothing,Bool}=nothing,
+            opt_level::Union{Nothing,Int}=nothing
+        )
+    return CacheFlags(
+        use_pkgimages === nothing ? cf.use_pkgimages : use_pkgimages,
+        debug_level === nothing ? cf.debug_level : debug_level,
+        check_bounds === nothing ? cf.check_bounds : check_bounds,
+        inline === nothing ? cf.inline : inline,
+        opt_level === nothing ? cf.opt_level : opt_level
+    )
+end
 
 function _cacheflag_to_uint8(cf::CacheFlags)::UInt8
     f = UInt8(0)
@@ -2768,7 +2782,7 @@ function compilecache_dir(pkg::PkgId)
     return joinpath(DEPOT_PATH[1], entrypath)
 end
 
-function compilecache_path(pkg::PkgId, prefs_hash::UInt64; project::String=something(Base.active_project(), ""))::String
+function compilecache_path(pkg::PkgId, prefs_hash::UInt64; flags::CacheFlags=CacheFlags(), project::String=something(Base.active_project(), ""))::String
     entrypath, entryfile = cache_file_entry(pkg)
     cachepath = joinpath(DEPOT_PATH[1], entrypath)
     isdir(cachepath) || mkpath(cachepath)
@@ -2778,7 +2792,7 @@ function compilecache_path(pkg::PkgId, prefs_hash::UInt64; project::String=somet
         crc = _crc32c(project)
         crc = _crc32c(unsafe_string(JLOptions().image_file), crc)
         crc = _crc32c(unsafe_string(JLOptions().julia_bin), crc)
-        crc = _crc32c(ccall(:jl_cache_flags, UInt8, ()), crc)
+        crc = _crc32c(_cacheflag_to_uint8(flags), crc)
 
         cpu_target = get(ENV, "JULIA_CPU_TARGET", nothing)
         if cpu_target === nothing
@@ -2810,7 +2824,8 @@ end
 const MAX_NUM_PRECOMPILE_FILES = Ref(10)
 
 function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, internal_stdout::IO = stdout,
-                      keep_loaded_modules::Bool = true; flags::Cmd=``, reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
+                      keep_loaded_modules::Bool = true; flags::Cmd=``, cacheflags::CacheFlags=CacheFlags(),
+                      reasons::Union{Dict{String,Int},Nothing}=Dict{String,Int}())
 
     @nospecialize internal_stderr internal_stdout
     # decide where to put the resulting cache file
@@ -2859,7 +2874,7 @@ function compilecache(pkg::PkgId, path::String, internal_stderr::IO = stderr, in
             # Read preferences hash back from .ji file (we can't precompute because
             # we don't actually know what the list of compile-time preferences are without compiling)
             prefs_hash = preferences_hash(tmppath)
-            cachefile = compilecache_path(pkg, prefs_hash)
+            cachefile = compilecache_path(pkg, prefs_hash; flags=cacheflags)
             ocachefile = cache_objects ? ocachefile_from_cachefile(cachefile) : nothing
 
             # append checksum for so to the end of the .ji file:
@@ -3408,7 +3423,7 @@ global parse_pidfile_hook
 # The preferences hash is only known after precompilation so just assume no preferences.
 # Also ignore the active project, which means that if all other conditions are equal,
 # the same package cannot be precompiled from different projects and/or different preferences at the same time.
-compilecache_pidfile_path(pkg::PkgId) = compilecache_path(pkg, UInt64(0); project="") * ".pidfile"
+compilecache_pidfile_path(pkg::PkgId; flags::CacheFlags=CacheFlags()) = compilecache_path(pkg, UInt64(0); project="", flags) * ".pidfile"
 
 const compilecache_pidlock_stale_age = 10
 
@@ -3536,12 +3551,16 @@ end
                 M = root_module(req_key)
                 if PkgId(M) == req_key && module_build_id(M) === req_build_id
                     depmods[i] = M
+                elseif M == Core
+                    @debug "Rejecting cache file $cachefile because it was made with a different julia version"
+                    record_reason(reasons, "wrong julia version")
+                    return true # Won't be able to fulfill dependency
                 elseif ignore_loaded || !stalecheck
                     # Used by Pkg.precompile given that there it's ok to precompile different versions of loaded packages
                     @goto locate_branch
                 else
                     @debug "Rejecting cache file $cachefile because module $req_key is already loaded and incompatible."
-                    record_reason(reasons, req_key == PkgId(Core) ? "wrong julia version" : "wrong dep version loaded")
+                    record_reason(reasons, "wrong dep version loaded")
                     return true # Won't be able to fulfill dependency
                 end
             else
diff --git a/base/precompilation.jl b/base/precompilation.jl
index 9eaa0539f522e..3259b6a7e063b 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -335,16 +335,29 @@ function printpkgstyle(io, header, msg; color=:light_green)
     println(io, " ", msg)
 end
 
+const Config = Pair{Cmd, Base.CacheFlags}
+const PkgConfig = Tuple{Base.PkgId,Config}
+
+function precompilepkgs(pkgs::Vector{String}=String[];
+                        internal_call::Bool=false,
+                        strict::Bool = false,
+                        warn_loaded::Bool = true,
+                        timing::Bool = false,
+                        _from_loading::Bool=false,
+                        configs::Union{Config,Vector{Config}}=(``=>Base.CacheFlags()),
+                        io::IO=stderr,
+                        flags_cacheflags=nothing)
+
+    if flags_cacheflags !== nothing
+        # TODO: Remove `flags_cacheflags` once Pkg moves to the renamed kwarg `configs`
+        configs = flags_cacheflags
+    end
+    configs = configs isa Config ? [configs] : configs
 
-function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false,
-                    strict::Bool=false, warn_loaded = true, timing::Bool = false,
-                    _from_loading::Bool=false, flags_cacheflags::Pair{Cmd, Base.CacheFlags}=(``=>Base.CacheFlags()), io::IO=stderr)
     time_start = time_ns()
 
     env = ExplicitEnv()
 
-    flags, cacheflags = flags_cacheflags
-
     # Windows sometimes hits a ReadOnlyMemoryError, so we halve the default number of tasks. Issue #2323
     # TODO: Investigate why this happens in windows and restore the full task limit
     default_num_tasks = Sys.iswindows() ? div(Sys.CPU_THREADS::Int, 2) + 1 : Sys.CPU_THREADS::Int + 1
@@ -356,7 +369,8 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
     # asking for timing disables fancy mode, as timing is shown in non-fancy mode
     fancyprint = can_fancyprint(io) && !timing
 
-    if _from_loading && !Sys.isinteractive()
+    if _from_loading && !Sys.isinteractive() && Base.get_bool_env("JULIA_TESTS", false)
+        # suppress passive loading printing in julia test suite. `JULIA_TESTS` is set in Base.runtests
         io = devnull
     end
 
@@ -441,13 +455,16 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
     end
 
     # initialize signalling
-    started = Dict{Base.PkgId,Bool}()
-    was_processed = Dict{Base.PkgId,Base.Event}()
-    was_recompiled = Dict{Base.PkgId,Bool}()
-    for pkgid in keys(depsmap)
-        started[pkgid] = false
-        was_processed[pkgid] = Base.Event()
-        was_recompiled[pkgid] = false
+    started = Dict{PkgConfig,Bool}()
+    was_processed = Dict{PkgConfig,Base.Event}()
+    was_recompiled = Dict{PkgConfig,Bool}()
+    for config in configs
+        for pkgid in keys(depsmap)
+            dep_config = (pkgid, config)
+            started[dep_config] = false
+            was_processed[dep_config] = Base.Event()
+            was_recompiled[dep_config] = false
+        end
     end
     @debug "precompile: signalling initialized"  _group=:precompile
 
@@ -481,7 +498,10 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
     for pkg in keys(depsmap)
         if scan_pkg!(pkg, depsmap)
             push!(circular_deps, pkg)
-            notify(was_processed[pkg])
+            for dep_config in keys(was_processed)
+                # notify all to allow skipping
+                dep_config[1] == pkg && notify(was_processed[dep_config])
+            end
         end
     end
     if !isempty(circular_deps)
@@ -526,14 +546,18 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
         end
         target = join(pkgs, ", ")
     else
-        target = "project..."
+        target = "project"
+    end
+    if length(configs) > 1 || !isempty(only(configs)[1]) # if multiple configs or only one is not default
+        target *= " for $(length(configs)) compilation configurations..."
+    else
+        target *= "..."
     end
     @debug "precompile: packages filtered"  _group=:precompile
 
-    pkg_queue = Base.PkgId[]
-    failed_deps = Dict{Base.PkgId, String}()
-    skipped_deps = Base.PkgId[]
-    precomperr_deps = Base.PkgId[] # packages that may succeed after a restart (i.e. loaded packages with no cache file)
+    pkg_queue = PkgConfig[]
+    failed_deps = Dict{PkgConfig, String}()
+    precomperr_deps = PkgConfig[] # packages that may succeed after a restart (i.e. loaded packages with no cache file)
 
     print_lock = io isa Base.LibuvStream ? io.lock::ReentrantLock : ReentrantLock()
     first_started = Base.Event()
@@ -556,7 +580,7 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
         in_printloop || wait(t_print) # wait to let the print loop cease first
         if err isa InterruptException
             lock(print_lock) do
-                println(io, " Interrupted: Exiting precompilation...")
+                println(io, " Interrupted: Exiting precompilation...", ansi_cleartoendofline)
             end
             interrupted = true
             return true
@@ -564,13 +588,13 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
             return false
         end
     end
-
-    std_outputs = Dict{Base.PkgId,String}()
-    taskwaiting = Set{Base.PkgId}()
-    pkgspidlocked = Dict{Base.PkgId,String}()
+    std_outputs = Dict{PkgConfig,String}()
+    taskwaiting = Set{PkgConfig}()
+    pkgspidlocked = Dict{PkgConfig,String}()
     pkg_liveprinted = nothing
 
-    function monitor_std(pkg, pipe; single_requested_pkg=false)
+    function monitor_std(pkg_config, pipe; single_requested_pkg=false)
+        pkg, config = pkg_config
         try
             liveprinting = false
             while !eof(pipe)
@@ -586,14 +610,14 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
                         print(io, ansi_cleartoendofline, str)
                     end
                 end
-                std_outputs[pkg] = string(get(std_outputs, pkg, ""), str)
-                if !in(pkg, taskwaiting) && occursin("waiting for IO to finish", str)
+                std_outputs[pkg_config] = string(get(std_outputs, pkg_config, ""), str)
+                if !in(pkg_config, taskwaiting) && occursin("waiting for IO to finish", str)
                     !fancyprint && lock(print_lock) do
                         println(io, pkg.name, color_string(" Waiting for background task / IO / timer.", Base.warn_color()))
                     end
-                    push!(taskwaiting, pkg)
+                    push!(taskwaiting, pkg_config)
                 end
-                if !fancyprint && in(pkg, taskwaiting)
+                if !fancyprint && in(pkg_config, taskwaiting)
                     lock(print_lock) do
                         print(io, str)
                     end
@@ -618,7 +642,7 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
             i = 1
             last_length = 0
             bar = MiniProgressBar(; indent=2, header = "Progress", color = Base.info_color(), percentage=false, always_reprint=true)
-            n_total = length(depsmap)
+            n_total = length(depsmap) * length(configs)
             bar.max = n_total - n_already_precomp
             final_loop = false
             n_print_rows = 0
@@ -644,30 +668,35 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
                             str = sprint(io -> show_progress(io, bar; termwidth, carriagereturn=false); context=io)
                             print(iostr, Base._truncate_at_width_or_chars(true, str, termwidth), "\n")
                         end
-                        for dep in pkg_queue_show
+                        for dep_config in pkg_queue_show
+                            dep, config = dep_config
                             loaded = warn_loaded && haskey(Base.loaded_modules, dep)
                             _name = haskey(exts, dep) ? string(exts[dep], " → ", dep.name) : dep.name
                             name = dep in direct_deps ? _name : string(color_string(_name, :light_black))
-                            line = if dep in precomperr_deps
+                            if length(configs) > 1
+                                config_str = isempty(config[1]) ? "" : "$(join(config[1], " "))"
+                                name *= color_string(" $(config_str)", :light_black)
+                            end
+                            line = if dep_config in precomperr_deps
                                 string(color_string("  ? ", Base.warn_color()), name)
-                            elseif haskey(failed_deps, dep)
+                            elseif haskey(failed_deps, dep_config)
                                 string(color_string("  ✗ ", Base.error_color()), name)
-                            elseif was_recompiled[dep]
+                            elseif was_recompiled[dep_config]
                                 !loaded && interrupted_or_done.set && continue
                                 loaded || @async begin # keep successful deps visible for short period
                                     sleep(1);
-                                    filter!(!isequal(dep), pkg_queue)
+                                    filter!(!isequal(dep_config), pkg_queue)
                                 end
                                 string(color_string("  ✓ ", loaded ? Base.warn_color() : :green), name)
-                            elseif started[dep]
+                            elseif started[dep_config]
                                 # Offset each spinner animation using the first character in the package name as the seed.
                                 # If not offset, on larger terminal fonts it looks odd that they all sync-up
                                 anim_char = anim_chars[(i + Int(dep.name[1])) % length(anim_chars) + 1]
                                 anim_char_colored = dep in direct_deps ? anim_char : color_string(anim_char, :light_black)
-                                waiting = if haskey(pkgspidlocked, dep)
-                                    who_has_lock = pkgspidlocked[dep]
+                                waiting = if haskey(pkgspidlocked, dep_config)
+                                    who_has_lock = pkgspidlocked[dep_config]
                                     color_string(" Being precompiled by $(who_has_lock)", Base.info_color())
-                                elseif dep in taskwaiting
+                                elseif dep_config in taskwaiting
                                     color_string(" Waiting for background task / IO / timer. Interrupt to inspect", Base.warn_color())
                                 else
                                     ""
@@ -704,103 +733,108 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
     for (pkg, deps) in depsmap
         cachepaths = Base.find_all_in_cache_path(pkg)
         sourcepath = Base.locate_package(pkg)
-        if sourcepath === nothing
-            failed_deps[pkg] = "Error: Missing source file for $(pkg)"
-            notify(was_processed[pkg])
-            continue
-        end
-        # Heuristic for when precompilation is disabled
-        if occursin(r"\b__precompile__\(\s*false\s*\)", read(sourcepath, String))
-            notify(was_processed[pkg])
-            continue
-        end
-
         single_requested_pkg = length(pkgs) == 1 && only(pkgs) == pkg.name
-
-        task = @async begin
-            try
-                loaded = haskey(Base.loaded_modules, pkg)
-                for dep in deps # wait for deps to finish
-                    wait(was_processed[dep])
-                end
-
-                circular = pkg in circular_deps
-                is_stale = !Base.isprecompiled(pkg; ignore_loaded=true, stale_cache, cachepaths, sourcepath, flags=cacheflags)
-                if !circular && is_stale
-                    Base.acquire(parallel_limiter)
-                    is_direct_dep = pkg in direct_deps
-
-                    # std monitoring
-                    std_pipe = Base.link_pipe!(Pipe(); reader_supports_async=true, writer_supports_async=true)
-                    t_monitor = @async monitor_std(pkg, std_pipe; single_requested_pkg)
-
-                    _name = haskey(exts, pkg) ? string(exts[pkg], " → ", pkg.name) : pkg.name
-                    name = is_direct_dep ? _name : string(color_string(_name, :light_black))
-                    !fancyprint && lock(print_lock) do
-                        isempty(pkg_queue) && printpkgstyle(io, :Precompiling, target)
-                    end
-                    push!(pkg_queue, pkg)
-                    started[pkg] = true
-                    fancyprint && notify(first_started)
-                    if interrupted_or_done.set
-                        notify(was_processed[pkg])
-                        Base.release(parallel_limiter)
-                        return
+        for config in configs
+            pkg_config = (pkg, config)
+            if sourcepath === nothing
+                failed_deps[pkg_config] = "Error: Missing source file for $(pkg)"
+                notify(was_processed[pkg_config])
+                continue
+            end
+            # Heuristic for when precompilation is disabled
+            if occursin(r"\b__precompile__\(\s*false\s*\)", read(sourcepath, String))
+                notify(was_processed[pkg_config])
+                continue
+            end
+            flags, cacheflags = config
+            task = @async begin
+                try
+                    loaded = haskey(Base.loaded_modules, pkg)
+                    for dep in deps # wait for deps to finish
+                        wait(was_processed[(dep,config)])
                     end
-                    try
-                        # allows processes to wait if another process is precompiling a given package to
-                        # a functionally identical package cache (except for preferences, which may differ)
-                        t = @elapsed ret = precompile_pkgs_maybe_cachefile_lock(io, print_lock, fancyprint, pkg, pkgspidlocked, hascolor, cacheflags) do
-                            Base.with_logger(Base.NullLogger()) do
-                                # The false here means we ignore loaded modules, so precompile for a fresh session
-                                Base.compilecache(pkg, sourcepath, std_pipe, std_pipe, false; flags)
-                            end
+                    circular = pkg in circular_deps
+                    is_stale = !Base.isprecompiled(pkg; ignore_loaded=true, stale_cache, cachepaths, sourcepath, flags=cacheflags)
+                    if !circular && is_stale
+                        Base.acquire(parallel_limiter)
+                        is_direct_dep = pkg in direct_deps
+
+                        # std monitoring
+                        std_pipe = Base.link_pipe!(Pipe(); reader_supports_async=true, writer_supports_async=true)
+                        t_monitor = @async monitor_std(pkg_config, std_pipe; single_requested_pkg)
+
+                        _name = haskey(exts, pkg) ? string(exts[pkg], " → ", pkg.name) : pkg.name
+                        name = is_direct_dep ? _name : string(color_string(_name, :light_black))
+                        if length(configs) > 1
+                            config_str = isempty(config[1]) ? "" : "$(join(config[1], " "))"
+                            name *= color_string(" $(config_str)", :light_black)
+                        end
+                        !fancyprint && lock(print_lock) do
+                            isempty(pkg_queue) && printpkgstyle(io, :Precompiling, target)
                         end
-                        if ret isa Base.PrecompilableError
-                            push!(precomperr_deps, pkg)
-                            !fancyprint && lock(print_lock) do
-                                println(io, _timing_string(t), color_string("  ? ", Base.warn_color()), name)
+                        push!(pkg_queue, pkg_config)
+                        started[pkg_config] = true
+                        fancyprint && notify(first_started)
+                        if interrupted_or_done.set
+                            notify(was_processed[pkg_config])
+                            Base.release(parallel_limiter)
+                            return
+                        end
+                        try
+                            # allows processes to wait if another process is precompiling a given package to
+                            # a functionally identical package cache (except for preferences, which may differ)
+                            t = @elapsed ret = precompile_pkgs_maybe_cachefile_lock(io, print_lock, fancyprint, pkg_config, pkgspidlocked, hascolor) do
+                                Base.with_logger(Base.NullLogger()) do
+                                    # The false here means we ignore loaded modules, so precompile for a fresh session
+                                    Base.compilecache(pkg, sourcepath, std_pipe, std_pipe, false; flags, cacheflags)
+                                end
                             end
-                        else
-                            !fancyprint && lock(print_lock) do
-                                println(io, _timing_string(t), color_string("  ✓ ", loaded ? Base.warn_color() : :green), name)
+                            if ret isa Base.PrecompilableError
+                                push!(precomperr_deps, pkg_config)
+                                !fancyprint && lock(print_lock) do
+                                    println(io, _timing_string(t), color_string("  ? ", Base.warn_color()), name)
+                                end
+                            else
+                                !fancyprint && lock(print_lock) do
+                                    println(io, _timing_string(t), color_string("  ✓ ", loaded ? Base.warn_color() : :green), name)
+                                end
+                                was_recompiled[pkg_config] = true
                             end
-                            was_recompiled[pkg] = true
-                        end
-                        loaded && (n_loaded += 1)
-                    catch err
-                        close(std_pipe.in) # close pipe to end the std output monitor
-                        wait(t_monitor)
-                        if err isa ErrorException || (err isa ArgumentError && startswith(err.msg, "Invalid header in cache file"))
-                            failed_deps[pkg] = (strict || is_direct_dep) ? string(sprint(showerror, err), "\n", strip(get(std_outputs, pkg, ""))) : ""
-                            delete!(std_outputs, pkg) # so it's not shown as warnings, given error report
-                            !fancyprint && lock(print_lock) do
-                                println(io, " "^9, color_string("  ✗ ", Base.error_color()), name)
+                            loaded && (n_loaded += 1)
+                        catch err
+                            close(std_pipe.in) # close pipe to end the std output monitor
+                            wait(t_monitor)
+                            if err isa ErrorException || (err isa ArgumentError && startswith(err.msg, "Invalid header in cache file"))
+                                failed_deps[dep_config] = (strict || is_direct_dep) ? string(sprint(showerror, err), "\n", strip(get(std_outputs, pkg, ""))) : ""
+                                delete!(std_outputs, pkg_config) # so it's not shown as warnings, given error report
+                                !fancyprint && lock(print_lock) do
+                                    println(io, " "^9, color_string("  ✗ ", Base.error_color()), name)
+                                end
+                            else
+                                rethrow()
                             end
-                        else
-                            rethrow()
+                        finally
+                            isopen(std_pipe.in) && close(std_pipe.in) # close pipe to end the std output monitor
+                            wait(t_monitor)
+                            Base.release(parallel_limiter)
                         end
-                    finally
-                        isopen(std_pipe.in) && close(std_pipe.in) # close pipe to end the std output monitor
-                        wait(t_monitor)
-                        Base.release(parallel_limiter)
+                    else
+                        is_stale || (n_already_precomp += 1)
                     end
-                else
-                    is_stale || (n_already_precomp += 1)
+                    n_done += 1
+                    notify(was_processed[pkg_config])
+                catch err_outer
+                    # For debugging:
+                    # println("Task failed $err_outer") # logging doesn't show here
+                    handle_interrupt(err_outer) || rethrow()
+                    notify(was_processed[pkg_config])
+                finally
+                    filter!(!istaskdone, tasks)
+                    length(tasks) == 1 && notify(interrupted_or_done)
                 end
-                n_done += 1
-                notify(was_processed[pkg])
-            catch err_outer
-                # For debugging:
-                # @error "Task failed" exception=(err_outer, catch_backtrace())
-                handle_interrupt(err_outer) || rethrow()
-                notify(was_processed[pkg])
-            finally
-                filter!(!istaskdone, tasks)
-                length(tasks) == 1 && notify(interrupted_or_done)
             end
+            push!(tasks, task)
         end
-        push!(tasks, task)
     end
     isempty(tasks) && notify(interrupted_or_done)
     try
@@ -818,28 +852,27 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
     if ndeps > 0 || !isempty(failed_deps) || (quick_exit && !isempty(std_outputs))
         str = sprint() do iostr
             if !quick_exit
-                plural = ndeps == 1 ? "y" : "ies"
-                print(iostr, "  $(ndeps) dependenc$(plural) successfully precompiled in $(seconds_elapsed) seconds")
-                if n_already_precomp > 0 || !isempty(circular_deps) || !isempty(skipped_deps)
+                plural = length(configs) > 1 ? "dependency configurations" : ndeps == 1 ? "dependency" : "dependencies"
+                print(iostr, "  $(ndeps) $(plural) successfully precompiled in $(seconds_elapsed) seconds")
+                if n_already_precomp > 0 || !isempty(circular_deps)
                     n_already_precomp > 0 && (print(iostr, ". $n_already_precomp already precompiled"))
                     !isempty(circular_deps) && (print(iostr, ". $(length(circular_deps)) skipped due to circular dependency"))
-                    !isempty(skipped_deps) && (print(iostr, ". $(length(skipped_deps)) skipped during auto due to previous errors"))
                     print(iostr, ".")
                 end
                 if n_loaded > 0
-                    plural1 = n_loaded == 1 ? "y" : "ies"
+                    plural1 = length(configs) > 1 ? "dependency configurations" : n_loaded == 1 ? "dependency" : "dependencies"
                     plural2 = n_loaded == 1 ? "a different version is" : "different versions are"
                     plural3 = n_loaded == 1 ? "" : "s"
                     print(iostr, "\n  ",
                         color_string(string(n_loaded), Base.warn_color()),
-                        " dependenc$(plural1) precompiled but $(plural2) currently loaded. Restart julia to access the new version$(plural3)"
+                        " $(plural1) precompiled but $(plural2) currently loaded. Restart julia to access the new version$(plural3)"
                     )
                 end
                 if !isempty(precomperr_deps)
-                    pluralpc = length(precomperr_deps) == 1 ? "y" : "ies"
+                    pluralpc = length(configs) > 1 ? "dependency configurations" : precomperr_deps == 1 ? "dependency" : "dependencies"
                     print(iostr, "\n  ",
                         color_string(string(length(precomperr_deps)), Base.warn_color()),
-                        " dependenc$(pluralpc) failed but may be precompilable after restarting julia"
+                        " $(pluralpc) failed but may be precompilable after restarting julia"
                     )
                 end
             end
@@ -850,13 +883,14 @@ function precompilepkgs(pkgs::Vector{String}=String[]; internal_call::Bool=false
                 plural1 = length(std_outputs) == 1 ? "y" : "ies"
                 plural2 = length(std_outputs) == 1 ? "" : "s"
                 print(iostr, "\n  ", color_string("$(length(std_outputs))", Base.warn_color()), " dependenc$(plural1) had output during precompilation:")
-                for (pkgid, err) in std_outputs
-                    err = if pkgid == pkg_liveprinted
+                for (pkg_config, err) in std_outputs
+                    pkg, config = pkg_config
+                    err = if pkg == pkg_liveprinted
                         "[Output was shown above]"
                     else
                         join(split(strip(err), "\n"), color_string("\n│  ", Base.warn_color()))
                     end
-                    name = haskey(exts, pkgid) ? string(exts[pkgid], " → ", pkgid.name) : pkgid.name
+                    name = haskey(exts, pkg) ? string(exts[pkg], " → ", pkg.name) : pkg.name
                     print(iostr, color_string("\n┌ ", Base.warn_color()), name, color_string("\n│  ", Base.warn_color()), err, color_string("\n└  ", Base.warn_color()))
                 end
             end
@@ -912,14 +946,16 @@ function _color_string(cstr::String, col::Union{Int64, Symbol}, hascolor)
 end
 
 # Can be merged with `maybe_cachefile_lock` in loading?
-function precompile_pkgs_maybe_cachefile_lock(f, io::IO, print_lock::ReentrantLock, fancyprint::Bool, pkg::Base.PkgId, pkgspidlocked::Dict{Base.PkgId,String}, hascolor, cacheflags)
+function precompile_pkgs_maybe_cachefile_lock(f, io::IO, print_lock::ReentrantLock, fancyprint::Bool, pkg_config, pkgspidlocked, hascolor)
+    pkg, config = pkg_config
+    flags, cacheflags = config
     FileWatching = Base.loaded_modules[Base.PkgId(Base.UUID("7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"), "FileWatching")]
     stale_age = Base.compilecache_pidlock_stale_age
-    pidfile = Base.compilecache_pidfile_path(pkg)
+    pidfile = Base.compilecache_pidfile_path(pkg, flags=cacheflags)
     cachefile = FileWatching.trymkpidlock(f, pidfile; stale_age)
     if cachefile === false
         pid, hostname, age = FileWatching.Pidfile.parse_pidfile(pidfile)
-        pkgspidlocked[pkg] = if isempty(hostname) || hostname == gethostname()
+        pkgspidlocked[pkg_config] = if isempty(hostname) || hostname == gethostname()
             if pid == getpid()
                 "an async task in this process (pidfile: $pidfile)"
             else
@@ -929,7 +965,7 @@ function precompile_pkgs_maybe_cachefile_lock(f, io::IO, print_lock::ReentrantLo
             "another machine (hostname: $hostname, pid: $pid, pidfile: $pidfile)"
         end
         !fancyprint && lock(print_lock) do
-            println(io, "    ", pkg.name, _color_string(" Being precompiled by $(pkgspidlocked[pkg])", Base.info_color(), hascolor))
+            println(io, "    ", pkg.name, _color_string(" Being precompiled by $(pkgspidlocked[pkg_config])", Base.info_color(), hascolor))
         end
         # wait until the lock is available
         FileWatching.mkpidlock(pidfile; stale_age) do
@@ -937,7 +973,7 @@ function precompile_pkgs_maybe_cachefile_lock(f, io::IO, print_lock::ReentrantLo
             if Base.isprecompiled(pkg; ignore_loaded=true, flags=cacheflags) # don't use caches for this as the env state will have changed
                 return nothing # returning nothing indicates a process waited for another
             else
-                delete!(pkgspidlocked, pkg)
+                delete!(pkgspidlocked, pkg_config)
                 return f() # precompile
             end
         end
diff --git a/base/util.jl b/base/util.jl
index c91f04e8baf96..5e86f026f8f9a 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -687,6 +687,7 @@ function runtests(tests = ["all"]; ncores::Int = ceil(Int, Sys.CPU_THREADS / 2),
     pathsep = Sys.iswindows() ? ";" : ":"
     ENV2["JULIA_DEPOT_PATH"] = string(mktempdir(; cleanup = true), pathsep) # make sure the default depots can be loaded
     ENV2["JULIA_LOAD_PATH"] = string("@", pathsep, "@stdlib")
+    ENV2["JULIA_TESTS"] = "true"
     delete!(ENV2, "JULIA_PROJECT")
     try
         run(setenv(`$(julia_cmd()) $(joinpath(Sys.BINDIR,
diff --git a/pkgimage.mk b/pkgimage.mk
index c9de49d2f8421..485e27996bb44 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -7,146 +7,31 @@ include $(JULIAHOME)/stdlib/stdlib.mk
 
 # set some influential environment variables
 export JULIA_DEPOT_PATH := $(build_prefix)/share/julia
-export JULIA_LOAD_PATH := @stdlib
+export JULIA_LOAD_PATH := @stdlib:$(JULIAHOME)/stdlib
 unexport JULIA_PROJECT :=
 unexport JULIA_BINDIR :=
 
 export JULIA_FALLBACK_REPL := true
 
 default: release
-release: all-release
-debug: all-debug
+release: $(BUILDDIR)/stdlib/release.image
+debug: $(BUILDDIR)/stdlib/debug.image
 all: release debug
 
-$(JULIA_DEPOT_PATH):
+$(JULIA_DEPOT_PATH)/compiled:
 	mkdir -p $@
 
 print-depot-path:
 	@$(call PRINT_JULIA, $(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no -e '@show Base.DEPOT_PATH')
 
-all-release: $(addprefix cache-release-, $(STDLIBS))
-all-debug:   $(addprefix cache-debug-, $(STDLIBS))
+$(BUILDDIR)/stdlib/%.image: $(JULIAHOME)/stdlib/Project.toml $(JULIAHOME)/stdlib/Manifest.toml $(INDEPENDENT_STDLIBS_SRCS) $(JULIA_DEPOT_PATH)/compiled
+	export JULIA_CPU_TARGET="$(JULIA_CPU_TARGET)"
+	@$(call PRINT_JULIA, $(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.Precompilation.precompilepkgs(;configs=[``=>Base.CacheFlags(), `--check-bounds=yes`=>Base.CacheFlags(;check_bounds=1)])')
+	touch $@
 
-define stdlib_builder
-ifneq ($(filter $(1),$(INDEPENDENT_STDLIBS) $(PKG_EXTS)),)
-# Define target-specific export for `JULIA_CPU_TARGET`
-$$(BUILDDIR)/stdlib/$1.release.image: export JULIA_CPU_TARGET=$(JULIA_CPU_TARGET)
-$$(BUILDDIR)/stdlib/$1.debug.image: export JULIA_CPU_TARGET=$(JULIA_CPU_TARGET)
-ifneq ($(filter $(1),$(INDEPENDENT_STDLIBS)),)
-$$(BUILDDIR)/stdlib/$1.release.image: $$($1_SRCS) $$(addsuffix .release.image,$$(addprefix $$(BUILDDIR)/stdlib/,$2)) $(build_private_libdir)/sys.$(SHLIB_EXT)
-	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
-	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.compilecache(Base.identify_package("$1"))')
-	touch $$@
-$$(BUILDDIR)/stdlib/$1.debug.image: $$($1_SRCS) $$(addsuffix .debug.image,$$(addprefix $$(BUILDDIR)/stdlib/,$2)) $(build_private_libdir)/sys-debug.$(SHLIB_EXT)
-	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'Base.compilecache(Base.identify_package("$1"))')
-	@$$(call PRINT_JULIA, $$(call spawn,$$(JULIA_EXECUTABLE)) --startup-file=no -e 'Base.compilecache(Base.identify_package("$1"))')
-	touch $$@
-endif
-ifneq ($(filter $(1),$(PKG_EXTS)),)
-# This is weird. It set up for multiple Pkg exts because that suits the structure here better
-# but it hard codes the deps and `import REPL, Pkg`
-$$(BUILDDIR)/stdlib/REPLExt.release.image: $$(REPLExt_SRCS) $$(BUILDDIR)/stdlib/Pkg.release.image $$(BUILDDIR)/stdlib/REPL.release.image
-	@$$(call PRINT_JULIA, $$(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'using REPL; using Pkg')
-	@$$(call PRINT_JULIA, $$(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no -e 'using REPL; using Pkg')
-	touch $$@
-$$(BUILDDIR)/stdlib/REPLExt.debug.image: $$(REPLExt_SRCS) $(BUILDDIR)/stdlib/Pkg.debug.image $$(BUILDDIR)/stdlib/REPL.debug.image
-	@$$(call PRINT_JULIA, $$(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no --check-bounds=yes -e 'using REPL; using Pkg')
-	@$$(call PRINT_JULIA, $$(call spawn,$(JULIA_EXECUTABLE)) --startup-file=no -e 'using REPL; using Pkg')
-	touch $$@
-endif
-else
-ifneq ($(filter $(1),$(STDLIBS_WITHIN_SYSIMG)),)
-$$(BUILDDIR)/stdlib/$1.release.image:
-	touch $$@
-$$(BUILDDIR)/stdlib/$1.debug.image:
-	touch $$@
-else
-$$(error $(1) neither in STDLIBS_WITHIN_SYSIMG nor INDEPENDENT_STDLIBS)
-endif
-endif
-cache-release-$1: $$(BUILDDIR)/stdlib/$1.release.image
-cache-debug-$1: $$(BUILDDIR)/stdlib/$1.debug.image
-.SECONDARY: $$(BUILDDIR)/stdlib/$1.release.image $$(BUILDDIR)/stdlib/$1.debug.image
-endef
+$(BUILDDIR)/stdlib/release.image: $(build_private_libdir)/sys.$(SHLIB_EXT)
+$(BUILDDIR)/stdlib/debug.image: $(build_private_libdir)/sys-debug.$(SHLIB_EXT)
 
-# Note: you can check for the correctness of this tree by running `JULIA_DEBUG=nested_precomp make` and looking
-# out for `Debug: Nested precompilation` logs.
-
-# no dependencies
-$(eval $(call stdlib_builder,MozillaCACerts_jll,))
-$(eval $(call stdlib_builder,ArgTools,))
-$(eval $(call stdlib_builder,Artifacts,))
-$(eval $(call stdlib_builder,Base64,))
-$(eval $(call stdlib_builder,CRC32c,))
-$(eval $(call stdlib_builder,FileWatching,))
-$(eval $(call stdlib_builder,Libdl,))
-$(eval $(call stdlib_builder,Mmap,))
-$(eval $(call stdlib_builder,NetworkOptions,))
-$(eval $(call stdlib_builder,SHA,))
-$(eval $(call stdlib_builder,Serialization,))
-$(eval $(call stdlib_builder,Sockets,))
-$(eval $(call stdlib_builder,Unicode,))
-$(eval $(call stdlib_builder,Profile,))
-$(eval $(call stdlib_builder,StyledStrings,))
-$(eval $(call stdlib_builder,SuiteSparse_jll,))
-
-# 1-depth packages
-$(eval $(call stdlib_builder,GMP_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,LLVMLibUnwind_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,LibUV_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,LibUnwind_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,MbedTLS_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,nghttp2_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,OpenLibm_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,PCRE2_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,Zlib_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,dSFMT_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,libLLVM_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,libblastrampoline_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,p7zip_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,OpenBLAS_jll,Artifacts Libdl))
-$(eval $(call stdlib_builder,Markdown,Base64))
-$(eval $(call stdlib_builder,Printf,Unicode))
-$(eval $(call stdlib_builder,Random,SHA))
-$(eval $(call stdlib_builder,Logging,StyledStrings))
-$(eval $(call stdlib_builder,Tar,ArgTools,SHA))
-$(eval $(call stdlib_builder,DelimitedFiles,Mmap))
-$(eval $(call stdlib_builder,JuliaSyntaxHighlighting,StyledStrings))
-
-# 2-depth packages
-$(eval $(call stdlib_builder,LLD_jll,Zlib_jll libLLVM_jll Artifacts Libdl))
-$(eval $(call stdlib_builder,LibSSH2_jll,Artifacts Libdl MbedTLS_jll))
-$(eval $(call stdlib_builder,MPFR_jll,Artifacts Libdl GMP_jll))
-$(eval $(call stdlib_builder,LinearAlgebra,Libdl libblastrampoline_jll OpenBLAS_jll))
-$(eval $(call stdlib_builder,Dates,Printf))
-$(eval $(call stdlib_builder,Distributed,Random Serialization Sockets))
-$(eval $(call stdlib_builder,Future,Random))
-$(eval $(call stdlib_builder,UUIDs,Random SHA))
-$(eval $(call stdlib_builder,InteractiveUtils,Markdown))
-
- # 3-depth packages
-$(eval $(call stdlib_builder,LibGit2_jll,MbedTLS_jll LibSSH2_jll Artifacts Libdl))
-$(eval $(call stdlib_builder,LibCURL_jll,LibSSH2_jll nghttp2_jll MbedTLS_jll Zlib_jll Artifacts Libdl))
-$(eval $(call stdlib_builder,REPL,InteractiveUtils Markdown Sockets StyledStrings Unicode))
-$(eval $(call stdlib_builder,SharedArrays,Distributed Mmap Random Serialization))
-$(eval $(call stdlib_builder,TOML,Dates))
-$(eval $(call stdlib_builder,Test,Logging Random Serialization InteractiveUtils))
-
-# 4-depth packages
-$(eval $(call stdlib_builder,LibGit2,LibGit2_jll NetworkOptions Printf SHA Base64))
-$(eval $(call stdlib_builder,LibCURL,LibCURL_jll MozillaCACerts_jll))
-
-# 5-depth packages
-$(eval $(call stdlib_builder,Downloads,ArgTools FileWatching LibCURL NetworkOptions))
-
-# 6-depth packages
-$(eval $(call stdlib_builder,Pkg, Artifacts Dates Downloads FileWatching LibGit2 Libdl\
-								  Logging Markdown Printf REPL Random SHA Serialization\
-								  TOML Tar UUIDs p7zip_jll))
-
-# 7-depth packages
-$(eval $(call stdlib_builder,LazyArtifacts,Artifacts Pkg))
-$(eval $(call stdlib_builder,REPLExt,Pkg REPL))
-
-$(eval $(call stdlib_builder,SparseArrays,Libdl LinearAlgebra Random Serialization SuiteSparse_jll))
-$(eval $(call stdlib_builder,Statistics,LinearAlgebra SparseArrays))
+clean:
+	rm -rf $(JULIA_DEPOT_PATH)/compiled
+	rm -f $(BUILDDIR)/stdlib/*.image
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
new file mode 100644
index 0000000000000..f2ae43f231db5
--- /dev/null
+++ b/stdlib/Manifest.toml
@@ -0,0 +1,300 @@
+# This file is machine-generated - editing it directly is not advised
+
+julia_version = "1.12.0-DEV"
+manifest_format = "2.0"
+project_hash = "13f2dd600364a1e8b659dc5796bf185b37d1c95d"
+
+[[deps.ArgTools]]
+uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"
+version = "1.1.2"
+
+[[deps.Artifacts]]
+uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
+version = "1.11.0"
+
+[[deps.Base64]]
+uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+version = "1.11.0"
+
+[[deps.CRC32c]]
+uuid = "8bf52ea8-c179-5cab-976a-9e18b702a9bc"
+version = "1.11.0"
+
+[[deps.CompilerSupportLibraries_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"
+version = "1.1.0+0"
+
+[[deps.Dates]]
+deps = ["Printf"]
+uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
+version = "1.11.0"
+
+[[deps.DelimitedFiles]]
+deps = ["Mmap"]
+git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae"
+uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"
+version = "1.9.1"
+
+[[deps.Distributed]]
+deps = ["Random", "Serialization", "Sockets"]
+uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"
+version = "1.11.0"
+
+[[deps.Downloads]]
+deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"]
+uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
+version = "1.6.0"
+
+[[deps.FileWatching]]
+uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"
+version = "1.11.0"
+
+[[deps.Future]]
+deps = ["Random"]
+uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"
+version = "1.11.0"
+
+[[deps.GMP_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "781609d7-10c4-51f6-84f2-b8444358ff6d"
+version = "6.3.0+0"
+
+[[deps.InteractiveUtils]]
+deps = ["Markdown"]
+uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+version = "1.11.0"
+
+[[deps.JuliaSyntaxHighlighting]]
+deps = ["StyledStrings"]
+uuid = "dc6e5ff7-fb65-4e79-a425-ec3bc9c03011"
+version = "1.11.0"
+
+[[deps.LLD_jll]]
+deps = ["Artifacts", "Libdl", "Zlib_jll", "libLLVM_jll"]
+uuid = "d55e3150-da41-5e91-b323-ecfd1eec6109"
+version = "16.0.6+4"
+
+[[deps.LLVMLibUnwind_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "47c5dbc3-30ba-59ef-96a6-123e260183d9"
+version = "12.0.1+0"
+
+[[deps.LazyArtifacts]]
+deps = ["Artifacts", "Pkg"]
+uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3"
+version = "1.11.0"
+
+[[deps.LibCURL]]
+deps = ["LibCURL_jll", "MozillaCACerts_jll"]
+uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"
+version = "0.6.4"
+
+[[deps.LibCURL_jll]]
+deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
+uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
+version = "8.6.0+0"
+
+[[deps.LibGit2]]
+deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"]
+uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
+version = "1.11.0"
+
+[[deps.LibGit2_jll]]
+deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"]
+uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"
+version = "1.7.2+0"
+
+[[deps.LibSSH2_jll]]
+deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
+uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"
+version = "1.11.0+1"
+
+[[deps.LibUV_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "183b4373-6708-53ba-ad28-60e28bb38547"
+version = "2.0.1+15"
+
+[[deps.LibUnwind_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "745a5e78-f969-53e9-954f-d19f2f74f4e3"
+version = "1.7.2+2"
+
+[[deps.Libdl]]
+uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+version = "1.11.0"
+
+[[deps.LinearAlgebra]]
+deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"]
+uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+version = "1.11.0"
+
+[[deps.Logging]]
+deps = ["StyledStrings"]
+uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
+version = "1.11.0"
+
+[[deps.MPFR_jll]]
+deps = ["Artifacts", "GMP_jll", "Libdl"]
+uuid = "3a97d323-0669-5f0c-9066-3539efd106a3"
+version = "4.2.0+1"
+
+[[deps.Markdown]]
+deps = ["Base64"]
+uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
+version = "1.11.0"
+
+[[deps.MbedTLS_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
+version = "2.28.6+0"
+
+[[deps.Mmap]]
+uuid = "a63ad114-7e13-5084-954f-fe012c677804"
+version = "1.11.0"
+
+[[deps.MozillaCACerts_jll]]
+uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
+version = "2023.12.12"
+
+[[deps.NetworkOptions]]
+uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
+version = "1.2.0"
+
+[[deps.OpenBLAS_jll]]
+deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]
+uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
+version = "0.3.26+2"
+
+[[deps.OpenLibm_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "05823500-19ac-5b8b-9628-191a04bc5112"
+version = "0.8.1+2"
+
+[[deps.PCRE2_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15"
+version = "10.42.0+1"
+
+[[deps.Pkg]]
+deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
+uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+version = "1.11.0"
+weakdeps = ["REPL"]
+
+    [deps.Pkg.extensions]
+    REPLExt = "REPL"
+
+[[deps.Printf]]
+deps = ["Unicode"]
+uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+version = "1.11.0"
+
+[[deps.Profile]]
+uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
+version = "1.11.0"
+
+[[deps.REPL]]
+deps = ["InteractiveUtils", "Markdown", "Sockets", "StyledStrings", "Unicode"]
+uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+version = "1.11.0"
+
+[[deps.Random]]
+deps = ["SHA"]
+uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+version = "1.11.0"
+
+[[deps.SHA]]
+uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"
+version = "0.7.0"
+
+[[deps.Serialization]]
+uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+version = "1.11.0"
+
+[[deps.SharedArrays]]
+deps = ["Distributed", "Mmap", "Random", "Serialization"]
+uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
+version = "1.11.0"
+
+[[deps.Sockets]]
+uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
+version = "1.11.0"
+
+[[deps.SparseArrays]]
+deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"]
+uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+version = "1.11.0"
+
+[[deps.Statistics]]
+deps = ["LinearAlgebra"]
+git-tree-sha1 = "ae3bb1eb3bba077cd276bc5cfc337cc65c3075c0"
+uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+version = "1.11.1"
+weakdeps = ["SparseArrays"]
+
+    [deps.Statistics.extensions]
+    SparseArraysExt = ["SparseArrays"]
+
+[[deps.StyledStrings]]
+uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b"
+version = "1.11.0"
+
+[[deps.SuiteSparse_jll]]
+deps = ["Artifacts", "Libdl", "libblastrampoline_jll"]
+uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
+version = "7.6.0+0"
+
+[[deps.TOML]]
+deps = ["Dates"]
+uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
+version = "1.0.3"
+
+[[deps.Tar]]
+deps = ["ArgTools", "SHA"]
+uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"
+version = "1.10.0"
+
+[[deps.Test]]
+deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
+uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+version = "1.11.0"
+
+[[deps.UUIDs]]
+deps = ["Random", "SHA"]
+uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+version = "1.11.0"
+
+[[deps.Unicode]]
+uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
+version = "1.11.0"
+
+[[deps.Zlib_jll]]
+deps = ["Libdl"]
+uuid = "83775a58-1f1d-513f-b197-d71354ab007a"
+version = "1.2.13+1"
+
+[[deps.dSFMT_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "05ff407c-b0c1-5878-9df8-858cc2e60c36"
+version = "2.2.5+0"
+
+[[deps.libLLVM_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
+version = "16.0.6+4"
+
+[[deps.libblastrampoline_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "8e850b90-86db-534c-a0d3-1478176c7d93"
+version = "5.8.0+1"
+
+[[deps.nghttp2_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
+version = "1.59.0+0"
+
+[[deps.p7zip_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
+version = "17.4.0+2"
diff --git a/stdlib/Project.toml b/stdlib/Project.toml
new file mode 100644
index 0000000000000..cc7ba99dd4e4f
--- /dev/null
+++ b/stdlib/Project.toml
@@ -0,0 +1,61 @@
+[deps]
+ArgTools = "0dad84c5-d112-42e6-8d28-ef12dabb789f"
+Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
+Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+CRC32c = "8bf52ea8-c179-5cab-976a-9e18b702a9bc"
+CompilerSupportLibraries_jll = "e66e0078-7015-5450-92f7-15fbd957f2ae"
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+DelimitedFiles = "8bb1440f-4735-579b-a4ab-409b98df4dab"
+Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
+Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
+FileWatching = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"
+Future = "9fa8497b-333b-5362-9e8d-4d0656e87820"
+GMP_jll = "781609d7-10c4-51f6-84f2-b8444358ff6d"
+InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+JuliaSyntaxHighlighting = "dc6e5ff7-fb65-4e79-a425-ec3bc9c03011"
+LLD_jll = "d55e3150-da41-5e91-b323-ecfd1eec6109"
+LLVMLibUnwind_jll = "47c5dbc3-30ba-59ef-96a6-123e260183d9"
+LazyArtifacts = "4af54fe1-eca0-43a8-85a7-787d91b784e3"
+LibCURL = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"
+LibCURL_jll = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
+LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
+LibGit2_jll = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"
+LibSSH2_jll = "29816b5a-b9ab-546f-933c-edad1886dfa8"
+LibUV_jll = "183b4373-6708-53ba-ad28-60e28bb38547"
+LibUnwind_jll = "745a5e78-f969-53e9-954f-d19f2f74f4e3"
+Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
+MPFR_jll = "3a97d323-0669-5f0c-9066-3539efd106a3"
+Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
+MbedTLS_jll = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
+Mmap = "a63ad114-7e13-5084-954f-fe012c677804"
+MozillaCACerts_jll = "14a3606d-f60d-562e-9121-12d972cd8159"
+NetworkOptions = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
+OpenBLAS_jll = "4536629a-c528-5b80-bd46-f80d51c5b363"
+OpenLibm_jll = "05823500-19ac-5b8b-9628-191a04bc5112"
+PCRE2_jll = "efcefdf7-47ab-520b-bdef-62a2eaa19f15"
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+Profile = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
+REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce"
+Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+SharedArrays = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
+Sockets = "6462fe0b-24de-5631-8697-dd941f90decc"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+StyledStrings = "f489334b-da3d-4c2e-b8f0-e476e12c162b"
+SuiteSparse_jll = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
+TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
+Tar = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
+Zlib_jll = "83775a58-1f1d-513f-b197-d71354ab007a"
+dSFMT_jll = "05ff407c-b0c1-5878-9df8-858cc2e60c36"
+libLLVM_jll = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
+libblastrampoline_jll = "8e850b90-86db-534c-a0d3-1478176c7d93"
+nghttp2_jll = "8e850ede-7688-5339-a07c-302acd2aaf8d"
+p7zip_jll = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
diff --git a/stdlib/stdlib.mk b/stdlib/stdlib.mk
index b23754f3a3cac..b79059d3368b1 100644
--- a/stdlib/stdlib.mk
+++ b/stdlib/stdlib.mk
@@ -11,24 +11,19 @@ INDEPENDENT_STDLIBS := \
 	LibCURL_jll LibSSH2_jll LibGit2_jll nghttp2_jll  MozillaCACerts_jll MbedTLS_jll \
 	MPFR_jll OpenLibm_jll PCRE2_jll p7zip_jll Zlib_jll
 
-PKG_EXTS := \
-	REPLExt
-
-STDLIBS := $(STDLIBS_WITHIN_SYSIMG) $(INDEPENDENT_STDLIBS) $(PKG_EXTS)
+STDLIBS := $(STDLIBS_WITHIN_SYSIMG) $(INDEPENDENT_STDLIBS)
 VERSDIR := v$(shell cut -d. -f1-2 < $(JULIAHOME)/VERSION)
 
-SYSIMG_STDLIB_SRCS =
+SYSIMG_STDLIBS_SRCS =
+INDEPENDENT_STDLIBS_SRCS =
 define STDLIB_srcs
-ifneq ($(filter $(1),$(PKG_EXTS)),)
-	$1_SRCS := $$(shell find $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/Pkg/ext/$1 -name \*.jl) \
-	$$(wildcard $$(build_prefix)/manifest/$$(VERSDIR)/Pkg) $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/Pkg/Project.toml
-else
-	$1_SRCS := $$(shell find $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/$1/src -name \*.jl) \
-	$$(wildcard $$(build_prefix)/manifest/$$(VERSDIR)/$1) $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/$1/Project.toml
-endif
+$1_SRCS := $$(shell find $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/$1/src -name \*.jl) \
+$$(wildcard $$(build_prefix)/manifest/$$(VERSDIR)/$1) $$(build_datarootdir)/julia/stdlib/$$(VERSDIR)/$1/Project.toml
 
 ifneq ($(filter $(1),$(STDLIBS_WITHIN_SYSIMG)),)
-	SYSIMG_STDLIB_SRCS += $$($1_SRCS)
+	SYSIMG_STDLIBS_SRCS += $$($1_SRCS)
+else
+	INDEPENDENT_STDLIBS_SRCS += $$($1_SRCS)
 endif
 endef
 
diff --git a/sysimage.mk b/sysimage.mk
index e6fa54be5f186..b5f47be0160a4 100644
--- a/sysimage.mk
+++ b/sysimage.mk
@@ -57,7 +57,7 @@ COMPILER_SRCS += $(shell find $(JULIAHOME)/base/compiler -name \*.jl)
 # sort these to remove duplicates
 BASE_SRCS := $(sort $(shell find $(JULIAHOME)/base -name \*.jl -and -not -name sysimg.jl) \
                     $(shell find $(BUILDROOT)/base -name \*.jl  -and -not -name sysimg.jl))
-STDLIB_SRCS := $(JULIAHOME)/base/sysimg.jl $(SYSIMG_STDLIB_SRCS)
+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)

From e618369409609f905d2a65f1e68cc934931991fd Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 8 Mar 2024 17:02:54 +0100
Subject: [PATCH 1084/1315] precompilepkgs: package in boths deps and weakdeps
 are in fact only weak (#53649)

Missed when porting from Pkg. Fixes
https://github.com/JuliaLang/Pkg.jl/issues/3834.
---
 base/precompilation.jl | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index 3259b6a7e063b..9ecb190a1afb5 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -26,6 +26,9 @@ struct ExplicitEnv
 end
 
 function ExplicitEnv(envpath::String=Base.active_project())
+    if !isfile(envpath)
+        error("expected a project file at $(repr(envpath))")
+    end
     envpath = abspath(envpath)
     project_d = parsed_toml(envpath)
 
@@ -51,6 +54,11 @@ function ExplicitEnv(envpath::String=Base.active_project())
         end
     end
 
+    # A package in both deps and weakdeps is in fact only a weakdep
+    for (name, _) in project_weakdeps
+        delete!(project_deps, name)
+    end
+
     project_extensions = Dict{String, Vector{UUID}}()
     # Collect all extensions of the project
     for (name, triggers::Union{String, Vector{String}}) in get(Dict{String, Any}, project_d, "extensions")::Dict{String, Any}

From bb35dc9abd678903220cd230b26d8a0d85bc33dc Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 8 Mar 2024 18:44:48 -0300
Subject: [PATCH 1085/1315] optimize remset marking (#52476)

Tag the lowest bit of a pointer to indicate it's in the remset and
enqueue objects in the remset for later processing when GC threads have
woken up, instead of sequentially marking them all at once.

In principle, this should allow for more parallelism in the mark phase,
though I didn't benchmark it yet.
---
 src/gc.c | 21 ++++++++++-----------
 src/gc.h |  2 ++
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index baa9c26a076a6..35a8d31749233 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -2644,13 +2644,12 @@ JL_DLLEXPORT void jl_gc_mark_queue_objarray(jl_ptls_t ptls, jl_value_t *parent,
     gc_mark_objarray(ptls, parent, objs, objs + nobjs, 1, nptr);
 }
 
-// Enqueue and mark all outgoing references from `new_obj` which have not been marked
-// yet. `meta_updated` is mostly used to make sure we don't update metadata twice for
-// objects which have been enqueued into the `remset`
-FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_new_obj,
-                              int meta_updated)
+// Enqueue and mark all outgoing references from `new_obj` which have not been marked yet.
+// `_new_obj` has its lowest bit tagged if it's in the remset (in which case we shouldn't update page metadata)
+FORCE_INLINE void gc_mark_outrefs(jl_ptls_t ptls, jl_gc_markqueue_t *mq, void *_new_obj)
 {
-    jl_value_t *new_obj = (jl_value_t *)_new_obj;
+    int meta_updated = (uintptr_t)_new_obj & GC_REMSET_PTR_TAG;
+    jl_value_t *new_obj = (jl_value_t *)((uintptr_t)_new_obj & ~(uintptr_t)GC_REMSET_PTR_TAG);
     mark_obj: {
         jl_taggedvalue_t *o = jl_astaggedvalue(new_obj);
         uintptr_t vtag = o->header & ~(uintptr_t)0xf;
@@ -2948,7 +2947,7 @@ void gc_mark_loop_serial_(jl_ptls_t ptls, jl_gc_markqueue_t *mq)
         if (__unlikely(new_obj == NULL)) {
             return;
         }
-        gc_mark_outrefs(ptls, mq, new_obj, 0);
+        gc_mark_outrefs(ptls, mq, new_obj);
     }
 }
 
@@ -2997,7 +2996,7 @@ void gc_mark_and_steal(jl_ptls_t ptls)
         goto steal;
     }
     mark : {
-        gc_mark_outrefs(ptls, mq, new_obj, 0);
+        gc_mark_outrefs(ptls, mq, new_obj);
         goto pop;
     }
     // Note that for the stealing heuristics, we try to
@@ -3260,9 +3259,9 @@ static void gc_queue_remset(jl_ptls_t ptls, jl_ptls_t ptls2)
     size_t len = ptls2->heap.last_remset->len;
     void **items = ptls2->heap.last_remset->items;
     for (size_t i = 0; i < len; i++) {
-        // Objects in the `remset` are already marked,
-        // so a `gc_try_claim_and_push` wouldn't work here
-        gc_mark_outrefs(ptls, &ptls->mark_queue, (jl_value_t *)items[i], 1);
+        // Tag the pointer to indicate it's in the remset
+        jl_value_t *v = (jl_value_t *)((uintptr_t)items[i] | GC_REMSET_PTR_TAG);
+        gc_ptr_queue_push(&ptls->mark_queue, v);
     }
 }
 
diff --git a/src/gc.h b/src/gc.h
index 4bb8828910e6c..f27fa9954eae2 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -118,6 +118,8 @@ typedef struct _jl_gc_chunk_t {
 #define GC_PTR_QUEUE_INIT_SIZE (1 << 18)    // initial size of queue of `jl_value_t *`
 #define GC_CHUNK_QUEUE_INIT_SIZE (1 << 14)  // initial size of chunk-queue
 
+#define GC_REMSET_PTR_TAG (0x1)             // lowest bit of `jl_value_t *` is tagged if it's in the remset
+
 // layout for big (>2k) objects
 
 JL_EXTENSION typedef struct _bigval_t {

From ed1d6a03f9929c3c7942d5e90c7b48f9fde49c36 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 9 Mar 2024 04:23:38 +0000
Subject: [PATCH 1086/1315] some fixes for precompile with threads

Not sure what I was thinking before here.
---
 src/scheduler.c | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/src/scheduler.c b/src/scheduler.c
index 81cf03bc38c5b..40f82180dfc89 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -438,6 +438,7 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
         jl_ptls_t ptls = ct->ptls;
         if (sleep_check_after_threshold(&start_cycles) || (ptls->tid == jl_atomic_load_relaxed(&io_loop_tid) && (!jl_atomic_load_relaxed(&_threadedregion) || wait_empty))) {
             // acquire sleep-check lock
+            assert(jl_atomic_load_relaxed(&ptls->sleep_check_state) == not_sleeping);
             jl_atomic_store_relaxed(&ptls->sleep_check_state, sleeping);
             jl_fence(); // [^store_buffering_1]
             JL_PROBE_RT_SLEEP_CHECK_SLEEP(ptls);
@@ -544,10 +545,12 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
                 // so make sure io_loop_tid is notified to check wait_empty
                 // TODO: this also might be a good time to check again that
                 // libuv's queue is truly empty, instead of during delete_thread
-                if (ptls->tid != jl_atomic_load_relaxed(&io_loop_tid)) {
-                    uv_mutex_lock(&ptls->sleep_lock);
-                    uv_cond_wait(&ptls->wake_signal, &ptls->sleep_lock);
-                    uv_mutex_unlock(&ptls->sleep_lock);
+                int16_t tid2 = 0;
+                if (ptls->tid != tid2) {
+                    jl_ptls_t ptls2 = jl_atomic_load_relaxed(&jl_all_tls_states)[tid2];
+                    uv_mutex_lock(&ptls2->sleep_lock);
+                    uv_cond_signal(&ptls2->wake_signal);
+                    uv_mutex_unlock(&ptls2->sleep_lock);
                 }
             }
 
@@ -556,16 +559,19 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
             int8_t gc_state = jl_gc_safe_enter(ptls);
             uv_mutex_lock(&ptls->sleep_lock);
             while (may_sleep(ptls)) {
-                task = wait_empty;
-                if (ptls->tid == 0 && task && jl_atomic_load_relaxed(&nrunning) == 0) {
-                    wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, 1);
-                    assert(!wasrunning);
-                    wasrunning = !set_not_sleeping(ptls);
-                    assert(!wasrunning);
-                    JL_PROBE_RT_SLEEP_CHECK_TASK_WAKE(ptls);
-                    if (!ptls->finalizers_inhibited)
-                        ptls->finalizers_inhibited++; // this annoyingly is rather sticky (we should like to reset it at the end of jl_task_wait_empty)
-                    break;
+                if (ptls->tid == 0) {
+                    task = wait_empty;
+                    if (task && jl_atomic_load_relaxed(&nrunning) == 0) {
+                        wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, 1);
+                        assert(!wasrunning);
+                        wasrunning = !set_not_sleeping(ptls);
+                        assert(!wasrunning);
+                        JL_PROBE_RT_SLEEP_CHECK_TASK_WAKE(ptls);
+                        if (!ptls->finalizers_inhibited)
+                            ptls->finalizers_inhibited++; // this annoyingly is rather sticky (we should like to reset it at the end of jl_task_wait_empty)
+                        break;
+                    }
+                    task = NULL;
                 }
                 // else should we warn the user of certain deadlock here if tid == 0 && nrunning == 0?
                 uv_cond_wait(&ptls->wake_signal, &ptls->sleep_lock);

From 53048b2ab1eb8ce412ef884a2431ca57da4dc4e6 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sat, 9 Mar 2024 16:14:25 +0530
Subject: [PATCH 1087/1315] Linalg: Reduce allocations in triangular tests
 (#53634)

Reuses a pre-allocated matrix in tests to avoid allocating a fresh
matrix in every call.
---
 stdlib/LinearAlgebra/test/triangular.jl | 215 ++++++++++++------------
 1 file changed, 108 insertions(+), 107 deletions(-)

diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index 7b222234c5fcb..fba0c86c8a1eb 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -35,6 +35,7 @@ debug && println("Test basic type functionality")
 
         # Construct test matrix
         A1 = t1(elty1 == Int ? rand(1:7, n, n) : convert(Matrix{elty1}, (elty1 <: Complex ? complex.(randn(n, n), randn(n, n)) : randn(n, n)) |> t -> cholesky(t't).U |> t -> uplo1 === :U ? t : copy(t')))
+        M1 = Matrix(A1)
         @test t1(A1) === A1
         @test t1{elty1}(A1) === A1
         # test the ctor works for AbstractMatrix
@@ -68,7 +69,7 @@ debug && println("Test basic type functionality")
         @test simA1 == A1
 
         # getindex
-        let mA1 = Matrix(A1)
+        let mA1 = M1
             # linear indexing
             for i in 1:length(A1)
                 @test A1[i] == mA1[i]
@@ -141,8 +142,8 @@ debug && println("Test basic type functionality")
         #tril/triu
         if uplo1 === :L
             @test tril(A1,0)  == A1
-            @test tril(A1,-1) == LowerTriangular(tril(Matrix(A1), -1))
-            @test tril(A1,1)  == t1(tril(tril(Matrix(A1), 1)))
+            @test tril(A1,-1) == LowerTriangular(tril(M1, -1))
+            @test tril(A1,1)  == t1(tril(tril(M1, 1)))
             @test tril(A1, -n - 2) == zeros(size(A1))
             @test tril(A1, n) == A1
             @test triu(A1,0)  == t1(diagm(0 => diag(A1)))
@@ -152,8 +153,8 @@ debug && println("Test basic type functionality")
             @test triu(A1, n + 2) == zeros(size(A1))
         else
             @test triu(A1,0)  == A1
-            @test triu(A1,1)  == UpperTriangular(triu(Matrix(A1), 1))
-            @test triu(A1,-1) == t1(triu(triu(Matrix(A1), -1)))
+            @test triu(A1,1)  == UpperTriangular(triu(M1, 1))
+            @test triu(A1,-1) == t1(triu(triu(M1, -1)))
             @test triu(A1, -n) == A1
             @test triu(A1, n + 2) == zeros(size(A1))
             @test tril(A1,0)  == t1(diagm(0 => diag(A1)))
@@ -169,10 +170,10 @@ debug && println("Test basic type functionality")
         # [c]transpose[!] (test views as well, see issue #14317)
         let vrange = 1:n-1, viewA1 = t1(view(A1.data, vrange, vrange))
             # transpose
-            @test copy(transpose(A1)) == transpose(Matrix(A1))
+            @test copy(transpose(A1)) == transpose(M1)
             @test copy(transpose(viewA1)) == transpose(Matrix(viewA1))
             # adjoint
-            @test copy(A1') == Matrix(A1)'
+            @test copy(A1') == M1'
             @test copy(viewA1') == Matrix(viewA1)'
             # transpose!
             @test transpose!(copy(A1)) == transpose(A1)
@@ -185,15 +186,15 @@ debug && println("Test basic type functionality")
         end
 
         # diag
-        @test diag(A1) == diag(Matrix(A1))
+        @test diag(A1) == diag(M1)
 
         # tr
-        @test tr(A1)::elty1 == tr(Matrix(A1))
+        @test tr(A1)::elty1 == tr(M1)
 
         # real
-        @test real(A1) == real(Matrix(A1))
-        @test imag(A1) == imag(Matrix(A1))
-        @test abs.(A1) == abs.(Matrix(A1))
+        @test real(A1) == real(M1)
+        @test imag(A1) == imag(M1)
+        @test abs.(A1) == abs.(M1)
 
         # zero
         if A1 isa UpperTriangular || A1 isa LowerTriangular
@@ -201,12 +202,12 @@ debug && println("Test basic type functionality")
         end
 
         # Unary operations
-        @test -A1 == -Matrix(A1)
+        @test -A1 == -M1
 
         # copy and copyto! (test views as well, see issue #14317)
         let vrange = 1:n-1, viewA1 = t1(view(A1.data, vrange, vrange))
             # copy
-            @test copy(A1) == copy(Matrix(A1))
+            @test copy(A1) == copy(M1)
             @test copy(viewA1) == copy(Matrix(viewA1))
             # copyto!
             B = similar(A1)
@@ -283,25 +284,25 @@ debug && println("Test basic type functionality")
         end
 
         # Binary operations
-        @test A1*0.5 == Matrix(A1)*0.5
-        @test 0.5*A1 == 0.5*Matrix(A1)
-        @test A1/0.5 == Matrix(A1)/0.5
-        @test 0.5\A1 == 0.5\Matrix(A1)
+        @test A1*0.5 == M1*0.5
+        @test 0.5*A1 == 0.5*M1
+        @test A1/0.5 == M1/0.5
+        @test 0.5\A1 == 0.5\M1
 
         # inversion
-        @test inv(A1) ≈ inv(lu(Matrix(A1)))
-        inv(Matrix(A1)) # issue #11298
+        @test inv(A1) ≈ inv(lu(M1))
+        inv(M1) # issue #11298
         @test isa(inv(A1), t1)
         # make sure the call to LAPACK works right
         if elty1 <: BlasFloat
-            @test LinearAlgebra.inv!(copy(A1)) ≈ inv(lu(Matrix(A1)))
+            @test LinearAlgebra.inv!(copy(A1)) ≈ inv(lu(M1))
         end
 
         # Determinant
-        @test det(A1) ≈ det(lu(Matrix(A1))) atol=sqrt(eps(real(float(one(elty1)))))*n*n
-        @test logdet(A1) ≈ logdet(lu(Matrix(A1))) atol=sqrt(eps(real(float(one(elty1)))))*n*n
+        @test det(A1) ≈ det(lu(M1)) atol=sqrt(eps(real(float(one(elty1)))))*n*n
+        @test logdet(A1) ≈ logdet(lu(M1)) atol=sqrt(eps(real(float(one(elty1)))))*n*n
         lada, ladb = logabsdet(A1)
-        flada, fladb = logabsdet(lu(Matrix(A1)))
+        flada, fladb = logabsdet(lu(M1))
         @test lada ≈ flada atol=sqrt(eps(real(float(one(elty1)))))*n*n
         @test ladb ≈ fladb atol=sqrt(eps(real(float(one(elty1)))))*n*n
 
@@ -324,7 +325,7 @@ debug && println("Test basic type functionality")
             for p in (1.0, Inf)
                 @test cond(A1,p) ≈ cond(A1,p) atol=(cond(A1,p)+cond(A1,p))
             end
-            @test cond(A1,2) == cond(Matrix(A1),2)
+            @test cond(A1,2) == cond(M1,2)
         end
 
         if !(elty1 in (BigFloat, Complex{BigFloat})) # Not implemented yet
@@ -333,9 +334,9 @@ debug && println("Test basic type functionality")
             svdvals(A1)
         end
 
-        @test ((A1*A1)::t1) ≈ Matrix(A1) * Matrix(A1)
-        @test ((A1/A1)::t1) ≈ Matrix(A1) / Matrix(A1)
-        @test ((A1\A1)::t1) ≈ Matrix(A1) \ Matrix(A1)
+        @test ((A1*A1)::t1) ≈ M1 * M1
+        @test ((A1/A1)::t1) ≈ M1 / M1
+        @test ((A1\A1)::t1) ≈ M1 \ M1
 
         # Begin loop for second Triangular matrix
         for elty2 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFloat}, Int)
@@ -347,7 +348,7 @@ debug && println("Test basic type functionality")
                 debug && println("elty1: $elty1, A1: $t1, elty2: $elty2, A2: $t2")
 
                 A2 = t2(elty2 == Int ? rand(1:7, n, n) : convert(Matrix{elty2}, (elty2 <: Complex ? complex.(randn(n, n), randn(n, n)) : randn(n, n)) |> t -> cholesky(t't).U |> t -> uplo2 === :U ? t : copy(t')))
-
+                M2 = Matrix(A2)
                 # Convert
                 if elty1 <: Real && !(elty2 <: Integer)
                     @test convert(AbstractMatrix{elty2}, A1) == t1(convert(Matrix{elty2}, A1.data))
@@ -356,21 +357,21 @@ debug && println("Test basic type functionality")
                 end
 
                 # Binary operations
-                @test A1 + A2 == Matrix(A1) + Matrix(A2)
-                @test A1 - A2 == Matrix(A1) - Matrix(A2)
+                @test A1 + A2 == M1 + M2
+                @test A1 - A2 == M1 - M2
 
                 # Triangular-Triangular multiplication and division
-                @test A1*A2 ≈ Matrix(A1)*Matrix(A2)
-                @test transpose(A1)*A2 ≈ transpose(Matrix(A1))*Matrix(A2)
-                @test transpose(A1)*adjoint(A2) ≈ transpose(Matrix(A1))*adjoint(Matrix(A2))
-                @test adjoint(A1)*transpose(A2) ≈ adjoint(Matrix(A1))*transpose(Matrix(A2))
-                @test A1'A2 ≈ Matrix(A1)'Matrix(A2)
-                @test A1*transpose(A2) ≈ Matrix(A1)*transpose(Matrix(A2))
-                @test A1*A2' ≈ Matrix(A1)*Matrix(A2)'
-                @test transpose(A1)*transpose(A2) ≈ transpose(Matrix(A1))*transpose(Matrix(A2))
-                @test A1'A2' ≈ Matrix(A1)'Matrix(A2)'
-                @test A1/A2 ≈ Matrix(A1)/Matrix(A2)
-                @test A1\A2 ≈ Matrix(A1)\Matrix(A2)
+                @test A1*A2 ≈ M1*M2
+                @test transpose(A1)*A2 ≈ transpose(M1)*M2
+                @test transpose(A1)*adjoint(A2) ≈ transpose(M1)*adjoint(M2)
+                @test adjoint(A1)*transpose(A2) ≈ adjoint(M1)*transpose(M2)
+                @test A1'A2 ≈ M1'M2
+                @test A1*transpose(A2) ≈ M1*transpose(M2)
+                @test A1*A2' ≈ M1*M2'
+                @test transpose(A1)*transpose(A2) ≈ transpose(M1)*transpose(M2)
+                @test A1'A2' ≈ M1'M2'
+                @test A1/A2 ≈ M1/M2
+                @test A1\A2 ≈ M1\M2
                 if uplo1 === :U && uplo2 === :U
                     if t1 === UnitUpperTriangular && t2 === UnitUpperTriangular
                         @test A1*A2 isa UnitUpperTriangular
@@ -411,20 +412,20 @@ debug && println("Test basic type functionality")
                 @test_throws DimensionMismatch A2'  * offsizeA
                 @test_throws DimensionMismatch A2   * offsizeA
                 if (uplo1 == uplo2 && elty1 == elty2 != Int && t1 != UnitLowerTriangular && t1 != UnitUpperTriangular)
-                    @test rdiv!(copy(A1), A2)::t1 ≈ A1/A2 ≈ Matrix(A1)/Matrix(A2)
-                    @test ldiv!(A2, copy(A1))::t1 ≈ A2\A1 ≈ Matrix(A2)\Matrix(A1)
+                    @test rdiv!(copy(A1), A2)::t1 ≈ A1/A2 ≈ M1/M2
+                    @test ldiv!(A2, copy(A1))::t1 ≈ A2\A1 ≈ M2\M1
                 end
                 if (uplo1 != uplo2 && elty1 == elty2 != Int && t2 != UnitLowerTriangular && t2 != UnitUpperTriangular)
-                    @test lmul!(adjoint(A1), copy(A2)) ≈ A1'*A2 ≈ Matrix(A1)'*Matrix(A2)
-                    @test lmul!(transpose(A1), copy(A2)) ≈ transpose(A1)*A2 ≈ transpose(Matrix(A1))*Matrix(A2)
-                    @test ldiv!(adjoint(A1), copy(A2)) ≈ A1'\A2 ≈ Matrix(A1)'\Matrix(A2)
-                    @test ldiv!(transpose(A1), copy(A2)) ≈ transpose(A1)\A2 ≈ transpose(Matrix(A1))\Matrix(A2)
+                    @test lmul!(adjoint(A1), copy(A2)) ≈ A1'*A2 ≈ M1'*M2
+                    @test lmul!(transpose(A1), copy(A2)) ≈ transpose(A1)*A2 ≈ transpose(M1)*M2
+                    @test ldiv!(adjoint(A1), copy(A2)) ≈ A1'\A2 ≈ M1'\M2
+                    @test ldiv!(transpose(A1), copy(A2)) ≈ transpose(A1)\A2 ≈ transpose(M1)\M2
                 end
                 if (uplo1 != uplo2 && elty1 == elty2 != Int && t1 != UnitLowerTriangular && t1 != UnitUpperTriangular)
-                    @test rmul!(copy(A1), adjoint(A2)) ≈ A1*A2' ≈ Matrix(A1)*Matrix(A2)'
-                    @test rmul!(copy(A1), transpose(A2)) ≈ A1*transpose(A2) ≈ Matrix(A1)*transpose(Matrix(A2))
-                    @test rdiv!(copy(A1), adjoint(A2)) ≈ A1/A2' ≈ Matrix(A1)/Matrix(A2)'
-                    @test rdiv!(copy(A1), transpose(A2)) ≈ A1/transpose(A2) ≈ Matrix(A1)/transpose(Matrix(A2))
+                    @test rmul!(copy(A1), adjoint(A2)) ≈ A1*A2' ≈ M1*M2'
+                    @test rmul!(copy(A1), transpose(A2)) ≈ A1*transpose(A2) ≈ M1*transpose(M2)
+                    @test rdiv!(copy(A1), adjoint(A2)) ≈ A1/A2' ≈ M1/M2'
+                    @test rdiv!(copy(A1), transpose(A2)) ≈ A1/transpose(A2) ≈ M1/transpose(M2)
                 end
             end
         end
@@ -435,55 +436,55 @@ debug && println("Test basic type functionality")
             debug && println("elty1: $elty1, A1: $t1, B: $eltyB")
 
             Tri = Tridiagonal(rand(eltyB,n-1),rand(eltyB,n),rand(eltyB,n-1))
-            @test lmul!(Tri,copy(A1)) ≈ Tri*Matrix(A1)
+            @test lmul!(Tri,copy(A1)) ≈ Tri*M1
             Tri = Tridiagonal(rand(eltyB,n-1),rand(eltyB,n),rand(eltyB,n-1))
             C = Matrix{promote_type(elty1,eltyB)}(undef, n, n)
             mul!(C, Tri, A1)
-            @test C ≈ Tri*Matrix(A1)
+            @test C ≈ Tri*M1
             Tri = Tridiagonal(rand(eltyB,n-1),rand(eltyB,n),rand(eltyB,n-1))
             mul!(C, A1, Tri)
-            @test C ≈ Matrix(A1)*Tri
+            @test C ≈ M1*Tri
 
             # Triangular-dense Matrix/vector multiplication
-            @test A1*B[:,1] ≈ Matrix(A1)*B[:,1]
-            @test A1*B ≈ Matrix(A1)*B
-            @test transpose(A1)*B[:,1] ≈ transpose(Matrix(A1))*B[:,1]
-            @test A1'B[:,1] ≈ Matrix(A1)'B[:,1]
-            @test transpose(A1)*B ≈ transpose(Matrix(A1))*B
-            @test A1'B ≈ Matrix(A1)'B
-            @test A1*transpose(B) ≈ Matrix(A1)*transpose(B)
-            @test adjoint(A1)*transpose(B) ≈ Matrix(A1)'*transpose(B)
-            @test transpose(A1)*adjoint(B) ≈ transpose(Matrix(A1))*adjoint(B)
-            @test A1*B' ≈ Matrix(A1)*B'
-            @test B*A1 ≈ B*Matrix(A1)
-            @test transpose(B[:,1])*A1 ≈ transpose(B[:,1])*Matrix(A1)
-            @test B[:,1]'A1 ≈ B[:,1]'Matrix(A1)
-            @test transpose(B)*A1 ≈ transpose(B)*Matrix(A1)
-            @test transpose(B)*adjoint(A1) ≈ transpose(B)*Matrix(A1)'
-            @test adjoint(B)*transpose(A1) ≈ adjoint(B)*transpose(Matrix(A1))
-            @test B'A1 ≈ B'Matrix(A1)
-            @test B*transpose(A1) ≈ B*transpose(Matrix(A1))
-            @test B*A1' ≈ B*Matrix(A1)'
-            @test transpose(B[:,1])*transpose(A1) ≈ transpose(B[:,1])*transpose(Matrix(A1))
-            @test B[:,1]'A1' ≈ B[:,1]'Matrix(A1)'
-            @test transpose(B)*transpose(A1) ≈ transpose(B)*transpose(Matrix(A1))
-            @test B'A1' ≈ B'Matrix(A1)'
+            @test A1*B[:,1] ≈ M1*B[:,1]
+            @test A1*B ≈ M1*B
+            @test transpose(A1)*B[:,1] ≈ transpose(M1)*B[:,1]
+            @test A1'B[:,1] ≈ M1'B[:,1]
+            @test transpose(A1)*B ≈ transpose(M1)*B
+            @test A1'B ≈ M1'B
+            @test A1*transpose(B) ≈ M1*transpose(B)
+            @test adjoint(A1)*transpose(B) ≈ M1'*transpose(B)
+            @test transpose(A1)*adjoint(B) ≈ transpose(M1)*adjoint(B)
+            @test A1*B' ≈ M1*B'
+            @test B*A1 ≈ B*M1
+            @test transpose(B[:,1])*A1 ≈ transpose(B[:,1])*M1
+            @test B[:,1]'A1 ≈ B[:,1]'M1
+            @test transpose(B)*A1 ≈ transpose(B)*M1
+            @test transpose(B)*adjoint(A1) ≈ transpose(B)*M1'
+            @test adjoint(B)*transpose(A1) ≈ adjoint(B)*transpose(M1)
+            @test B'A1 ≈ B'M1
+            @test B*transpose(A1) ≈ B*transpose(M1)
+            @test B*A1' ≈ B*M1'
+            @test transpose(B[:,1])*transpose(A1) ≈ transpose(B[:,1])*transpose(M1)
+            @test B[:,1]'A1' ≈ B[:,1]'M1'
+            @test transpose(B)*transpose(A1) ≈ transpose(B)*transpose(M1)
+            @test B'A1' ≈ B'M1'
 
             if eltyB == elty1
-                @test mul!(similar(B), A1, B) ≈ Matrix(A1)*B
-                @test mul!(similar(B), A1, adjoint(B)) ≈ Matrix(A1)*B'
-                @test mul!(similar(B), A1, transpose(B)) ≈ Matrix(A1)*transpose(B)
-                @test mul!(similar(B), adjoint(A1), adjoint(B)) ≈ Matrix(A1)'*B'
-                @test mul!(similar(B), transpose(A1), transpose(B)) ≈ transpose(Matrix(A1))*transpose(B)
-                @test mul!(similar(B), transpose(A1), adjoint(B)) ≈ transpose(Matrix(A1))*B'
-                @test mul!(similar(B), adjoint(A1), transpose(B)) ≈ Matrix(A1)'*transpose(B)
-                @test mul!(similar(B), adjoint(A1), B) ≈ Matrix(A1)'*B
-                @test mul!(similar(B), transpose(A1), B) ≈ transpose(Matrix(A1))*B
+                @test mul!(similar(B), A1, B) ≈ M1*B
+                @test mul!(similar(B), A1, adjoint(B)) ≈ M1*B'
+                @test mul!(similar(B), A1, transpose(B)) ≈ M1*transpose(B)
+                @test mul!(similar(B), adjoint(A1), adjoint(B)) ≈ M1'*B'
+                @test mul!(similar(B), transpose(A1), transpose(B)) ≈ transpose(M1)*transpose(B)
+                @test mul!(similar(B), transpose(A1), adjoint(B)) ≈ transpose(M1)*B'
+                @test mul!(similar(B), adjoint(A1), transpose(B)) ≈ M1'*transpose(B)
+                @test mul!(similar(B), adjoint(A1), B) ≈ M1'*B
+                @test mul!(similar(B), transpose(A1), B) ≈ transpose(M1)*B
                 # test also vector methods
                 B1 = vec(B[1,:])
-                @test mul!(similar(B1), A1, B1)  ≈ Matrix(A1)*B1
-                @test mul!(similar(B1), adjoint(A1), B1) ≈ Matrix(A1)'*B1
-                @test mul!(similar(B1), transpose(A1), B1) ≈ transpose(Matrix(A1))*B1
+                @test mul!(similar(B1), A1, B1)  ≈ M1*B1
+                @test mul!(similar(B1), adjoint(A1), B1) ≈ M1'*B1
+                @test mul!(similar(B1), transpose(A1), B1) ≈ transpose(M1)*B1
             end
             #error handling
             Ann, Bmm, bm = A1, Matrix{eltyB}(undef, n+1, n+1), Vector{eltyB}(undef, n+1)
@@ -495,16 +496,16 @@ debug && println("Test basic type functionality")
             @test_throws DimensionMismatch rmul!(Bmm, transpose(Ann))
 
             # ... and division
-            @test A1\B[:,1] ≈ Matrix(A1)\B[:,1]
-            @test A1\B ≈ Matrix(A1)\B
-            @test transpose(A1)\B[:,1] ≈ transpose(Matrix(A1))\B[:,1]
-            @test A1'\B[:,1] ≈ Matrix(A1)'\B[:,1]
-            @test transpose(A1)\B ≈ transpose(Matrix(A1))\B
-            @test A1'\B ≈ Matrix(A1)'\B
-            @test A1\transpose(B) ≈ Matrix(A1)\transpose(B)
-            @test A1\B' ≈ Matrix(A1)\B'
-            @test transpose(A1)\transpose(B) ≈ transpose(Matrix(A1))\transpose(B)
-            @test A1'\B' ≈ Matrix(A1)'\B'
+            @test A1\B[:,1] ≈ M1\B[:,1]
+            @test A1\B ≈ M1\B
+            @test transpose(A1)\B[:,1] ≈ transpose(M1)\B[:,1]
+            @test A1'\B[:,1] ≈ M1'\B[:,1]
+            @test transpose(A1)\B ≈ transpose(M1)\B
+            @test A1'\B ≈ M1'\B
+            @test A1\transpose(B) ≈ M1\transpose(B)
+            @test A1\B' ≈ M1\B'
+            @test transpose(A1)\transpose(B) ≈ transpose(M1)\transpose(B)
+            @test A1'\B' ≈ M1'\B'
             Ann, bm = A1, Vector{elty1}(undef,n+1)
             @test_throws DimensionMismatch Ann\bm
             @test_throws DimensionMismatch Ann'\bm
@@ -512,13 +513,13 @@ debug && println("Test basic type functionality")
             if t1 == UpperTriangular || t1 == LowerTriangular
                 @test_throws SingularException ldiv!(t1(zeros(elty1, n, n)), fill(eltyB(1), n))
             end
-            @test B/A1 ≈ B/Matrix(A1)
-            @test B/transpose(A1) ≈ B/transpose(Matrix(A1))
-            @test B/A1' ≈ B/Matrix(A1)'
-            @test transpose(B)/A1 ≈ transpose(B)/Matrix(A1)
-            @test B'/A1 ≈ B'/Matrix(A1)
-            @test transpose(B)/transpose(A1) ≈ transpose(B)/transpose(Matrix(A1))
-            @test B'/A1' ≈ B'/Matrix(A1)'
+            @test B/A1 ≈ B/M1
+            @test B/transpose(A1) ≈ B/transpose(M1)
+            @test B/A1' ≈ B/M1'
+            @test transpose(B)/A1 ≈ transpose(B)/M1
+            @test B'/A1 ≈ B'/M1
+            @test transpose(B)/transpose(A1) ≈ transpose(B)/transpose(M1)
+            @test B'/A1' ≈ B'/M1'
 
             # Error bounds
             !(elty1 in (BigFloat, Complex{BigFloat})) && !(eltyB in (BigFloat, Complex{BigFloat})) && errorbounds(A1, A1\B, B)

From 18a2e70636b6cd69c67f9e83fd34ddb8fb0649ce Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 9 Mar 2024 08:28:55 -0500
Subject: [PATCH 1088/1315] Fix bootstrap Base precompile in cross compile
 configuration (#53671)

---
 pkgimage.mk | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pkgimage.mk b/pkgimage.mk
index 485e27996bb44..740b9760cab48 100644
--- a/pkgimage.mk
+++ b/pkgimage.mk
@@ -6,8 +6,8 @@ include $(JULIAHOME)/stdlib/stdlib.mk
 
 
 # set some influential environment variables
-export JULIA_DEPOT_PATH := $(build_prefix)/share/julia
-export JULIA_LOAD_PATH := @stdlib:$(JULIAHOME)/stdlib
+export JULIA_DEPOT_PATH := $(shell echo $(call cygpath_w,$(build_prefix)/share/julia))
+export JULIA_LOAD_PATH := @stdlib$(PATHSEP)$(shell echo $(call cygpath_w,$(JULIAHOME)/stdlib))
 unexport JULIA_PROJECT :=
 unexport JULIA_BINDIR :=
 

From 6f8ba49e157d4b0de3726be8613a6ae607c5ccd2 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sat, 9 Mar 2024 19:21:03 +0530
Subject: [PATCH 1089/1315] Add methods to index identityUnitRange/Slice with
 another IdentityUnitRange (#41224)

Adding these methods lets `OffsetArrays` define
`getindex(::AbstractUnitRange, ::IdentityUnitRange)` without
ambiguities. This is in the domain of sanctioned type-piracy, as the
result is an offset range in general and cannot be represented correctly
using `Base` types.

Re: https://github.com/JuliaArrays/OffsetArrays.jl/pull/244

cc: @johnnychen94

Edit: this also fixes an indexing bug in `IdentityUntiRange`:
master
```julia
julia> r = Base.IdentityUnitRange(-3:3)
Base.IdentityUnitRange(-3:3)

julia> r[2]
2

julia> r[big(2)]
-2
```

Co-authored-by: jishnub <jishnub@users.noreply.github.com>
---
 base/indices.jl | 50 +++++++++++++++++++++++++++++++++++++++++++++----
 test/ranges.jl  | 47 +++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 86 insertions(+), 11 deletions(-)

diff --git a/base/indices.jl b/base/indices.jl
index 0bd46f9787dab..9fadff1cdb5de 100644
--- a/base/indices.jl
+++ b/base/indices.jl
@@ -423,15 +423,57 @@ first(S::IdentityUnitRange) = first(S.indices)
 last(S::IdentityUnitRange) = last(S.indices)
 size(S::IdentityUnitRange) = (length(S.indices),)
 length(S::IdentityUnitRange) = length(S.indices)
-getindex(S::IdentityUnitRange, i::Int) = (@inline; @boundscheck checkbounds(S, i); i)
-getindex(S::IdentityUnitRange, i::AbstractUnitRange{<:Integer}) = (@inline; @boundscheck checkbounds(S, i); i)
-getindex(S::IdentityUnitRange, i::StepRange{<:Integer}) = (@inline; @boundscheck checkbounds(S, i); i)
+unsafe_length(S::IdentityUnitRange) = unsafe_length(S.indices)
+getindex(S::IdentityUnitRange, i::Integer) = (@inline; @boundscheck checkbounds(S, i); convert(eltype(S), i))
+getindex(S::IdentityUnitRange, i::Bool) = throw(ArgumentError("invalid index: $i of type Bool"))
+function getindex(S::IdentityUnitRange, i::AbstractUnitRange{<:Integer})
+    @inline
+    @boundscheck checkbounds(S, i)
+    return convert(AbstractUnitRange{eltype(S)}, i)
+end
+function getindex(S::IdentityUnitRange, i::AbstractUnitRange{Bool})
+    @inline
+    @boundscheck checkbounds(S, i)
+    range(first(i) ? first(S) : last(S), length = last(i))
+end
+function getindex(S::IdentityUnitRange, i::StepRange{<:Integer})
+    @inline
+    @boundscheck checkbounds(S, i)
+    return convert(AbstractRange{eltype(S)}, i)
+end
+function getindex(S::IdentityUnitRange, i::StepRange{Bool})
+    @inline
+    @boundscheck checkbounds(S, i)
+    range(first(i) ? first(S) : last(S), length = last(i), step = Int(step(i)))
+end
+# Indexing with offset ranges should preserve the axes of the indices
+# however, this is only really possible in general with OffsetArrays.
+# In some cases, though, we may obtain correct results using Base ranges
+# the following methods are added to allow OffsetArrays to dispatch on the first argument without ambiguities
+function getindex(S::IdentityUnitRange{<:AbstractUnitRange{<:Integer}},
+                    i::IdentityUnitRange{<:AbstractUnitRange{<:Integer}})
+    @inline
+    @boundscheck checkbounds(S, i)
+    return i
+end
+function getindex(S::Slice{<:AbstractUnitRange{<:Integer}},
+                    i::IdentityUnitRange{<:AbstractUnitRange{<:Integer}})
+    @inline
+    @boundscheck checkbounds(S, i)
+    return i
+end
 show(io::IO, r::IdentityUnitRange) = print(io, "Base.IdentityUnitRange(", r.indices, ")")
 iterate(S::IdentityUnitRange, s...) = iterate(S.indices, s...)
 
 # For OneTo, the values and indices of the values are identical, so this may be defined in Base.
 # In general such an indexing operation would produce offset ranges
-getindex(S::OneTo, I::IdentityUnitRange{<:AbstractUnitRange{<:Integer}}) = (@inline; @boundscheck checkbounds(S, I); I)
+# This should also ideally return an AbstractUnitRange{eltype(S)}, but currently
+# we're restricted to eltype(::IdentityUnitRange) == Int by definition
+function getindex(S::OneTo, I::IdentityUnitRange{<:AbstractUnitRange{<:Integer}})
+    @inline
+    @boundscheck checkbounds(S, I)
+    return I
+end
 
 """
     LinearIndices(A::AbstractArray)
diff --git a/test/ranges.jl b/test/ranges.jl
index 4660a96dfc16a..9284c898bcbfb 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -2376,13 +2376,46 @@ end
     @test 0.2 * (-2:2:2) == [-0.4, 0, 0.4]
 end
 
-@testset "Indexing OneTo with IdentityUnitRange" begin
-    for endpt in Any[10, big(10), UInt(10)]
-        r = Base.OneTo(endpt)
-        inds = Base.IdentityUnitRange(3:5)
-        rs = r[inds]
-        @test rs === inds
-        @test_throws BoundsError r[Base.IdentityUnitRange(-1:100)]
+@testset "IdentityUnitRange indexing" begin
+    @testset "Indexing into an IdentityUnitRange" begin
+        @testset for r in Any[-1:20, Base.OneTo(20)]
+            ri = Base.IdentityUnitRange(r)
+            @test_throws "invalid index" ri[true]
+            @testset for s in Any[Base.OneTo(6), Base.OneTo{BigInt}(6), 3:6, big(3):big(6), 3:2:7]
+                @test mapreduce(==, &, ri[s], ri[s[begin]]:step(s):ri[s[end]])
+                @test axes(ri[s]) == axes(s)
+                @test eltype(ri[s]) == eltype(ri)
+            end
+        end
+        @testset "Bool indices" begin
+            r = 1:1
+            @test Base.IdentityUnitRange(r)[true:true] == r[true:true]
+            @test Base.IdentityUnitRange(r)[true:true:true] == r[true:true:true]
+            @test_throws BoundsError Base.IdentityUnitRange(1:2)[true:true]
+            @test_throws BoundsError Base.IdentityUnitRange(1:2)[true:true:true]
+        end
+    end
+    @testset "Indexing with IdentityUnitRange" begin
+        @testset "OneTo" begin
+            @testset for endpt in Any[10, big(12), UInt(11)]
+                r = Base.OneTo(endpt)
+                inds = Base.IdentityUnitRange(3:5)
+                rs = r[inds]
+                @test rs == inds
+                @test axes(rs) == axes(inds)
+                @test_throws BoundsError r[Base.IdentityUnitRange(-1:100)]
+            end
+        end
+        @testset "IdentityUnitRange" begin
+            @testset for r in Any[Base.IdentityUnitRange(1:4), Base.IdentityUnitRange(Base.OneTo(4)), Base.Slice(1:4), Base.Slice(Base.OneTo(4))]
+                @testset for s in Any[Base.IdentityUnitRange(3:3), Base.IdentityUnitRange(Base.OneTo(2)), Base.Slice(3:3), Base.Slice(Base.OneTo(2))]
+                    rs = r[s]
+                    @test rs == s
+                    @test axes(rs) == axes(s)
+                end
+                @test_throws BoundsError r[Base.IdentityUnitRange(first(r):last(r) + 1)]
+            end
+        end
     end
 end
 

From 0d029eaf7ddc594a59cae90096419c4f66d45855 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sat, 9 Mar 2024 09:58:25 -0500
Subject: [PATCH 1090/1315] Load Pkg if not already to reinstate missing
 package add prompt (#52125)

---
 stdlib/REPL/src/REPL.jl | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index f78f318d268e1..0c88c84b3cbc2 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -222,9 +222,7 @@ function eval_user_input(@nospecialize(ast), backend::REPLBackend, mod::Module)
                 put!(backend.response_channel, Pair{Any, Bool}(lasterr, true))
             else
                 backend.in_eval = true
-                if !isempty(install_packages_hooks)
-                    check_for_missing_packages_and_run_hooks(ast)
-                end
+                check_for_missing_packages_and_run_hooks(ast)
                 for xf in backend.ast_transforms
                     ast = Base.invokelatest(xf, ast)
                 end
@@ -251,6 +249,7 @@ function check_for_missing_packages_and_run_hooks(ast)
     mods = modules_to_be_loaded(ast)
     filter!(mod -> isnothing(Base.identify_package(String(mod))), mods) # keep missing modules
     if !isempty(mods)
+        isempty(install_packages_hooks) && Base.require_stdlib(Base.PkgId(Base.UUID("44cfe95a-1eb2-52ea-b672-e2afdf69b78f"), "Pkg"))
         for f in install_packages_hooks
             Base.invokelatest(f, mods) && return
         end
@@ -1658,7 +1657,6 @@ function __current_ast_transforms(backend)
     end
 end
 
-
 function numbered_prompt!(repl::LineEditREPL=Base.active_repl, backend=nothing)
     n = Ref{Int}(0)
     set_prompt(repl, n)

From c705a25e22da9f061899b16fed2d4a08ee135bb6 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Sat, 9 Mar 2024 10:42:22 -0500
Subject: [PATCH 1091/1315] document exact BigInt determinants (#53579)

New users are commonly surprised that determinants of integer matrices
give an approximate floating-point answer (#40128), and are unaware that
an exact algorithm is implemented for `BigInt` matrices (#40868). This
PR comments on both of these facts in the `det` documentation.

(At some point, we may want to mark `LinearAlgebra.det_bareiss` as
`public`, and document it, but that can be done in a future PR.)
---
 stdlib/LinearAlgebra/src/generic.jl | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl
index d0a985f3b6e51..023f2a1147feb 100644
--- a/stdlib/LinearAlgebra/src/generic.jl
+++ b/stdlib/LinearAlgebra/src/generic.jl
@@ -1642,6 +1642,15 @@ julia> M = [1 0; 2 2]
 julia> det(M)
 2.0
 ```
+Note that, in general, `det` computes a floating-point approximation of the
+determinant, even for integer matrices, typically via Gaussian elimination.
+Julia includes an exact algorithm for integer determinants (the Bareiss algorithm),
+but only uses it by default for `BigInt` matrices (since determinants quickly
+overflow any fixed integer precision):
+```jldoctest
+julia> det(BigInt[1 0; 2 2]) # exact integer determinant
+2
+```
 """
 function det(A::AbstractMatrix{T}) where {T}
     if istriu(A) || istril(A)

From fc6c618c4e199330429c05836eeb779723e7c97b Mon Sep 17 00:00:00 2001
From: Frames White <me@oxinabox.net>
Date: Sun, 10 Mar 2024 02:36:14 +0800
Subject: [PATCH 1092/1315] Handle zero on arrays of unions of number types and
 missings (#53602)

---
 base/abstractarray.jl |  1 +
 test/abstractarray.jl | 10 ++++++++++
 2 files changed, 11 insertions(+)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index a9431197932dd..9042e5f81e462 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1218,6 +1218,7 @@ end
 copymutable(itr) = collect(itr)
 
 zero(x::AbstractArray{T}) where {T<:Number} = fill!(similar(x, typeof(zero(T))), zero(T))
+zero(x::AbstractArray{S}) where {S<:Union{Missing, Number}} = fill!(similar(x, typeof(zero(S))), zero(S))
 zero(x::AbstractArray) = map(zero, x)
 
 ## iteration support for arrays by iterating over `eachindex` in the array ##
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 9d9c9b9c87776..1411864acfa03 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -1972,6 +1972,16 @@ end
 
     @test zero([[2,2], [3,3,3]]) isa Vector{Vector{Int}}
     @test zero([[2,2], [3,3,3]]) == [[0,0], [0, 0, 0]]
+
+
+    @test zero(Union{Float64, Missing}[missing]) == [0.0]
+    struct CustomNumber <: Number
+        val::Float64
+    end
+    Base.zero(::Type{CustomNumber}) = CustomNumber(0.0)
+    @test zero([CustomNumber(5.0)]) == [CustomNumber(0.0)]
+    @test zero(Union{CustomNumber, Missing}[missing]) == [CustomNumber(0.0)]
+    @test zero(Vector{Union{CustomNumber, Missing}}(undef, 1)) == [CustomNumber(0.0)]
 end
 
 @testset "`_prechecked_iterate` optimization" begin

From e9c84c809f6369907f4087e8d823f13c92a93c35 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 9 Mar 2024 13:40:54 -0500
Subject: [PATCH 1093/1315] permit NamedTuple{<:Any, Union{}} to be created
 (#53516)

---
 base/boot.jl                            |  4 ++--
 base/compiler/abstractinterpretation.jl |  2 +-
 base/namedtuple.jl                      | 19 ++++++++-----------
 src/builtins.c                          |  2 ++
 src/jltypes.c                           | 17 +++++++++++------
 test/namedtuple.jl                      | 15 +++++++++++++++
 6 files changed, 39 insertions(+), 20 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index e041488cdb74c..b4c5cda67bd57 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -736,8 +736,8 @@ eval(Core, :(NamedTuple{names}(args::Tuple) where {names} =
 
 using .Intrinsics: sle_int, add_int
 
-eval(Core, :(NamedTuple{names,T}(args::T) where {names, T <: Tuple} =
-             $(Expr(:splatnew, :(NamedTuple{names,T}), :args))))
+eval(Core, :((NT::Type{NamedTuple{names,T}})(args::T) where {names, T <: Tuple} =
+             $(Expr(:splatnew, :NT, :args))))
 
 # constructors for built-in types
 
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 00bd8a9310de7..443b4beba315d 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2695,7 +2695,7 @@ function refine_partial_type(@nospecialize t)
         # if the first/second parameter of `NamedTuple` is known to be empty,
         # the second/first argument should also be empty tuple type,
         # so refine it here
-        return Const(NamedTuple())
+        return Const((;))
     end
     return t
 end
diff --git a/base/namedtuple.jl b/base/namedtuple.jl
index cbcade94f1c0d..98192480db9dd 100644
--- a/base/namedtuple.jl
+++ b/base/namedtuple.jl
@@ -112,24 +112,24 @@ Core.NamedTuple
 
 if nameof(@__MODULE__) === :Base
 
-@eval function NamedTuple{names,T}(args::Tuple) where {names, T <: Tuple}
+@eval function (NT::Type{NamedTuple{names,T}})(args::Tuple) where {names, T <: Tuple}
     if length(args) != length(names::Tuple)
         throw(ArgumentError("Wrong number of arguments to named tuple constructor."))
     end
     # Note T(args) might not return something of type T; e.g.
     # Tuple{Type{Float64}}((Float64,)) returns a Tuple{DataType}
-    $(Expr(:splatnew, :(NamedTuple{names,T}), :(T(args))))
+    $(Expr(:splatnew, :NT, :(T(args))))
 end
 
-function NamedTuple{names, T}(nt::NamedTuple) where {names, T <: Tuple}
+function (NT::Type{NamedTuple{names, T}})(nt::NamedTuple) where {names, T <: Tuple}
     if @generated
-        Expr(:new, :(NamedTuple{names, T}),
-             Any[ :(let Tn = fieldtype(T, $n),
+        Expr(:new, :NT,
+             Any[ :(let Tn = fieldtype(NT, $n),
                       ntn = getfield(nt, $(QuoteNode(names[n])))
                       ntn isa Tn ? ntn : convert(Tn, ntn)
                   end) for n in 1:length(names) ]...)
     else
-        NamedTuple{names, T}(map(Fix1(getfield, nt), names))
+        NT(map(Fix1(getfield, nt), names))
     end
 end
 
@@ -145,14 +145,11 @@ function NamedTuple{names}(nt::NamedTuple) where {names}
     end
 end
 
-NamedTuple{names, T}(itr) where {names, T <: Tuple} = NamedTuple{names, T}(T(itr))
-NamedTuple{names}(itr) where {names} = NamedTuple{names}(Tuple(itr))
+(NT::Type{NamedTuple{names, T}})(itr) where {names, T <: Tuple} = NT(T(itr))
+(NT::Type{NamedTuple{names}})(itr) where {names} = NT(Tuple(itr))
 
 NamedTuple(itr) = (; itr...)
 
-# avoids invalidating Union{}(...)
-NamedTuple{names, Union{}}(itr::Tuple) where {names} = throw(MethodError(NamedTuple{names, Union{}}, (itr,)))
-
 end # if Base
 
 # Like NamedTuple{names, T} as a constructor, but omits the additional
diff --git a/src/builtins.c b/src/builtins.c
index 29aec53ae5a40..c26d528cb3ee4 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1219,6 +1219,8 @@ static jl_value_t *get_fieldtype(jl_value_t *t, jl_value_t *f, int dothrow)
             tt = ((jl_tvar_t*)tt)->ub;
         if (tt == (jl_value_t*)jl_any_type)
             return (jl_value_t*)jl_any_type;
+        if (tt == (jl_value_t*)jl_bottom_type)
+            return (jl_value_t*)jl_bottom_type;
         JL_GC_PUSH1(&f);
         if (jl_is_symbol(f))
             f = jl_box_long(field_index+1);
diff --git a/src/jltypes.c b/src/jltypes.c
index 896e8f7b676c8..33d67b179fc8b 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -2141,15 +2141,20 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
                         jl_errorf("duplicate field name in NamedTuple: \"%s\" is not unique", jl_symbol_name((jl_sym_t*)ni));
                 }
             }
-            if (!jl_is_datatype(values_tt))
-                jl_error("NamedTuple field type must be a tuple type");
-            if (jl_is_va_tuple((jl_datatype_t*)values_tt) || jl_nparams(values_tt) != nf)
-                jl_error("NamedTuple names and field types must have matching lengths");
-            ndt->types = ((jl_datatype_t*)values_tt)->parameters;
+            if (values_tt == jl_bottom_type && nf > 0) {
+                ndt->types = jl_svec_fill(nf, jl_bottom_type);
+            }
+            else {
+                if (!jl_is_datatype(values_tt))
+                    jl_error("NamedTuple field type must be a tuple datatype");
+                if (jl_is_va_tuple((jl_datatype_t*)values_tt) || jl_nparams(values_tt) != nf)
+                    jl_error("NamedTuple names and field types must have matching lengths");
+                ndt->types = ((jl_datatype_t*)values_tt)->parameters;
+            }
             jl_gc_wb(ndt, ndt->types);
         }
         else {
-            ndt->types = jl_emptysvec; // XXX: this is essentially always false
+            ndt->types = jl_emptysvec; // XXX: this is essentially always incorrect
         }
     }
     else if (tn == jl_genericmemoryref_typename || tn == jl_genericmemory_typename) {
diff --git a/test/namedtuple.jl b/test/namedtuple.jl
index 9c16d24b0c575..48aa8ea4a2591 100644
--- a/test/namedtuple.jl
+++ b/test/namedtuple.jl
@@ -437,3 +437,18 @@ let c = (a=1, b=2),
     d = (b=3, c=(d=1,))
     @test @inferred(mergewith51009((x,y)->y, c, d)) === (a = 1, b = 3, c = (d = 1,))
 end
+
+@test_throws ErrorException NamedTuple{(), Union{}}
+for NT in (NamedTuple{(:a, :b), Union{}}, NamedTuple{(:a, :b), T} where T<:Union{})
+    @test fieldtype(NT, 1) == Union{}
+    @test fieldtype(NT, :b) == Union{}
+    @test_throws ErrorException fieldtype(NT, :c)
+    @test_throws BoundsError fieldtype(NT, 0)
+    @test_throws BoundsError fieldtype(NT, 3)
+    @test Base.return_types((Type{NT},)) do NT; fieldtype(NT, :a); end == Any[Type{Union{}}]
+    @test fieldtype(NamedTuple{<:Any, Union{}}, 1) == Union{}
+end
+let NT = NamedTuple{<:Any, Union{}}
+    @test fieldtype(NT, 100) == Union{}
+    @test only(Base.return_types((Type{NT},)) do NT; fieldtype(NT, 100); end) >: Type{Union{}}
+end

From 39f141df5ebf38599c20f1687551e45213463251 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sat, 9 Mar 2024 13:41:47 -0500
Subject: [PATCH 1094/1315] increase max atomic size to 16 on 64-bit platforms
 (#42268)

---
 src/Makefile       |  2 +-
 src/datatype.c     |  5 +++--
 src/julia.h        | 11 ++++++++---
 test/intrinsics.jl |  2 +-
 4 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/Makefile b/src/Makefile
index ce81ff03cdd70..72895e9a8080c 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -26,7 +26,7 @@ endif
 JCFLAGS += -Wold-style-definition -Wstrict-prototypes -Wc++-compat
 
 ifeq ($(USECLANG),1)
-FLAGS += -Wno-return-type-c-linkage
+FLAGS += -Wno-return-type-c-linkage -Wno-atomic-alignment
 endif
 
 FLAGS += -DJL_BUILD_ARCH='"$(ARCH)"'
diff --git a/src/datatype.c b/src/datatype.c
index f9f7dec3d1b13..80668063bb8ba 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
+#include <stdalign.h>
 #include "julia.h"
 #include "julia_internal.h"
 #include "julia_assert.h"
@@ -1012,7 +1013,7 @@ JL_DLLEXPORT int jl_is_foreign_type(jl_datatype_t *dt)
 
 #if MAX_POINTERATOMIC_SIZE >= 16
 typedef struct _jl_uint128_t {
-    uint64_t a;
+    alignas(16) uint64_t a;
     uint64_t b;
 } jl_uint128_t;
 #endif
@@ -1356,7 +1357,7 @@ JL_DLLEXPORT int jl_atomic_storeonce_bits(jl_datatype_t *dt, char *dst, const jl
 #endif
 #if MAX_POINTERATOMIC_SIZE >= 16
     else if (nb <= 16) {
-        jl_uint128_t y128 = 0;
+        jl_uint128_t y128 = {0};
         jl_uint128_t z128 = zext_read128(src, nb);
         while (1) {
             success = jl_atomic_cmpswap((_Atomic(jl_uint128_t)*)dst, &y128, z128);
diff --git a/src/julia.h b/src/julia.h
index 5c3a983367470..7d246d25cc767 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -46,11 +46,16 @@
 #endif
 
 // Define the largest size (bytes) of a properly aligned object that the
-// processor family and compiler typically supports without a lock
-// (assumed to be at least a pointer size). Since C is bad at handling 16-byte
-// types, we currently use 8 here as the default.
+// processor family (MAX_ATOMIC_SIZE) and compiler (MAX_POINTERATOMIC_SIZE)
+// typically supports without a lock (assumed to be at least a pointer size)
+// with MAX_POINTERATOMIC_SIZE >= MAX_ATOMIC_SIZE.
+#ifdef _P64
+#define MAX_ATOMIC_SIZE 16
+#define MAX_POINTERATOMIC_SIZE 16
+#else
 #define MAX_ATOMIC_SIZE 8
 #define MAX_POINTERATOMIC_SIZE 8
+#endif
 
 #ifdef _P64
 #define NWORDS(sz) (((sz)+7)>>3)
diff --git a/test/intrinsics.jl b/test/intrinsics.jl
index 8e4ab932f5eb6..6fbe4e5364354 100644
--- a/test/intrinsics.jl
+++ b/test/intrinsics.jl
@@ -220,7 +220,7 @@ for TT in (Int8, Int16, Int32, Int64, Int128, Int256, Int512, Complex{Int32}, Co
                 @test_throws TypeError Core.Intrinsics.atomic_pointerreplace(p, T(10), S(3), :sequentially_consistent, :sequentially_consistent)
             end
             @test Core.Intrinsics.pointerref(p, 1, 1) === T(10) === r[]
-            if sizeof(r) > 8
+            if sizeof(r) > 2*sizeof(Int)
                 @test_throws ErrorException("atomic_pointerref: invalid pointer for atomic operation") unsafe_load(p, :sequentially_consistent)
                 @test_throws ErrorException("atomic_pointerset: invalid pointer for atomic operation") unsafe_store!(p, T(1), :sequentially_consistent)
                 @test_throws ErrorException("atomic_pointerswap: invalid pointer for atomic operation") unsafe_swap!(p, T(100), :sequentially_consistent)

From 5c7d24493ebab184d4517ca556314524f4fcb47f Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Sat, 9 Mar 2024 17:22:20 -0500
Subject: [PATCH 1095/1315] Bump CSL to 1.1.1 to fix libgomp bug (#53643)

Resolves https://github.com/JuliaLang/julia/issues/53363
---
 deps/checksums/compilersupportlibraries       | 184 +++++++++---------
 .../CompilerSupportLibraries_jll/Project.toml |   2 +-
 2 files changed, 93 insertions(+), 93 deletions(-)

diff --git a/deps/checksums/compilersupportlibraries b/deps/checksums/compilersupportlibraries
index 2dcfecfb56b26..48843f21c0feb 100644
--- a/deps/checksums/compilersupportlibraries
+++ b/deps/checksums/compilersupportlibraries
@@ -1,92 +1,92 @@
-CompilerSupportLibraries.v1.1.0+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/20ebaad57850393b6ac9fa924e511fe4
-CompilerSupportLibraries.v1.1.0+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/020de4d8b0ff6bedbadaa305ff8445e6849f12053762ea4aa68412d1ec763dbd86f479587a2fbb862487f1feb04d976c38099ddf3887817a3d32b3f029cf85b1
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/e084a4374be45ba52279682c640449bc
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/d4aedf5c08e13fd9596476330f69e374af64373f7bca0e4df6cbb4d1710d695dce23f2655ee368c3df2049b7b0ca1848c9e01a437fadc0eb08937c6a7cdf2a27
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/6b3975f25be16ea1370ef0bf353ac752
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/d6298517be1ce350a61d1c1a1bf9b27a541382aa8ccf3e86eeadd7c47e2fe88facd17139a3878adb939df869a330264a942d280e3468d53b61325df7e31daaad
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/7134b79b71059d4da79224df1ca0853e
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/e66590a37e756ff33a84514a7ca2bbe2e1517f3e901bc66e40139e8a318d6cd8e329e0c2a7c557ea39e6db2f56802d485ab81b87be1373717b78474b1c7bf7d7
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/fd37789f5745a17cc9a85902cebf4698
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/9ff4e9be39f115af2e5bb6a5c88b3940f15a010952cebf39da22e7a5c6744be2f905bebccba092db0a89cf82e8c0e1a3e61b74d4204d2a6648b5469f3ccb0d12
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/e9286ae9299c57d5df7b795997b4adf5
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/ea64858481095e0374be330aa2ac84b394bc3e5351b9326137c9cd5d15e6bec47d6e5f672a216572dcb80c3aa6fcb08950cc10157c264f429a93c235028d79a4
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/b19c6cbc5b2a62ea76dea64b0f8ae488
-CompilerSupportLibraries.v1.1.0+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/090d659f7e4a7034117e2bb2dcad0ef544cdca898bf032222cdb81d32af6e6528be842d2cf55839fe397c2ace05dd4ce920cf98cc96324ae18832016516e6cc3
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/26fb41031e1b797373aea7a7c4d7be3c
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8fd0b6c990681789caec528067b4bcb9661f9c0a5e0268927d4e88565fa7005db3b592fb8e7830cf32b3fb4ce54d6db747dfde896f93bd38f65b7a1290a2399a
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/6ed3f3e94f662177c3cf3c3734a5c1ec
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b8165630cced0f7880cb6fd6263cf39bbbbda668eccc94219720078a85a641c3b1b20648960041aa3a51108ab6df087b909c572d0690aacf8b99dc5496ff7db6
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/86060cbbe966a59f18f92a9b2fab95d4
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/0aa0ca0ff3a4d541c7a9599ca1adae7391fdd3fa841f3055ecb8635096d0d95a0763758d7533c887b38a655af55174dfcb63f470147b28a256b75a85c8e47801
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/4acf6f8929fb8ec9fdb8a0f1af06260d
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/3b2e0a5f62bd93434d07848c3045479a1a05bd8589dc976a5680e13805db5adcd9abdcca82edee7b28b4c4a9413ce795784a8a0f0a8fb7346a439322c27c96d9
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/a75a927c3e14bee6dca29b4907def681
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/7853fd187f9289a8282d34112b5277bad13abe9dd9b6c796498db2f1a080b2c81faa6119df9ececd09725a019bf99706894765c9c20f618e359adc153c3181a2
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/ba8545cc20e6c602a0526a3b1fc1d2f1
-CompilerSupportLibraries.v1.1.0+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/7a7f3a7761deb068efc00ffc5d4bf4df365cb27674ce73abbe2305b678285161f1526f4facbe27fc11076d99b2079976507f78f5b463bd9057ed008e9d52f9cf
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/26fb41031e1b797373aea7a7c4d7be3c
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8fd0b6c990681789caec528067b4bcb9661f9c0a5e0268927d4e88565fa7005db3b592fb8e7830cf32b3fb4ce54d6db747dfde896f93bd38f65b7a1290a2399a
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/6ed3f3e94f662177c3cf3c3734a5c1ec
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/b8165630cced0f7880cb6fd6263cf39bbbbda668eccc94219720078a85a641c3b1b20648960041aa3a51108ab6df087b909c572d0690aacf8b99dc5496ff7db6
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/86060cbbe966a59f18f92a9b2fab95d4
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/0aa0ca0ff3a4d541c7a9599ca1adae7391fdd3fa841f3055ecb8635096d0d95a0763758d7533c887b38a655af55174dfcb63f470147b28a256b75a85c8e47801
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/4acf6f8929fb8ec9fdb8a0f1af06260d
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/3b2e0a5f62bd93434d07848c3045479a1a05bd8589dc976a5680e13805db5adcd9abdcca82edee7b28b4c4a9413ce795784a8a0f0a8fb7346a439322c27c96d9
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/a75a927c3e14bee6dca29b4907def681
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/7853fd187f9289a8282d34112b5277bad13abe9dd9b6c796498db2f1a080b2c81faa6119df9ececd09725a019bf99706894765c9c20f618e359adc153c3181a2
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/ba8545cc20e6c602a0526a3b1fc1d2f1
-CompilerSupportLibraries.v1.1.0+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/7a7f3a7761deb068efc00ffc5d4bf4df365cb27674ce73abbe2305b678285161f1526f4facbe27fc11076d99b2079976507f78f5b463bd9057ed008e9d52f9cf
-CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran3.tar.gz/md5/39dc387fd58ef02c461c7906ceb110e3
-CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/1296ac707fdad620c65256686523f2b027c8359f54d1f8354ef5d1ba514992c7269aad26b706575509b5e29d0ad3dec1c7d32fe3bcff0d723d6a4890819eca46
-CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran4.tar.gz/md5/21a76d54d875ef09db2cdce77d328c2e
-CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/9c6bf15338ffbc7113c536e145e53bfaa693007b971f83ee2db820d7d54018bd1cfdbedb6bbce000ee7aaadad1561e91f5ac0e0519bbfccbc3bc57fdfc0eb7e7
-CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran5.tar.gz/md5/f028f2c94f28201701ef6ba4fec9abc9
-CompilerSupportLibraries.v1.1.0+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/c231af1bb0fd4f733278f883837fddf574689bbd7c4dd46cfcd1478d784cbeae1fd785d7cf9f4b0f98cda08819b63a20d5026c6beb892a188fc979b7893697bc
-CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran3.tar.gz/md5/184436dc05207a653f13aae3d82a2e1b
-CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran3.tar.gz/sha512/b6e1f969528a168de087f472eebd23a4daf907aa48f7c5b42c35960b1cae3e6ca8f512982d69b757f39d6dc07b46f74c84e549cb22354a2f55d1265cba7b7013
-CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran4.tar.gz/md5/545bee22cb35d1c4c1381009e72eebca
-CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran4.tar.gz/sha512/78a65b9e7cda79cd648a1ae09daea970eba9d04fd5ea41bc1e37b065cf5c53974f759590292876f57c7f65139be66a6c381aa6756cdda7b36845cfed1bb7fddc
-CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran5.tar.gz/md5/3f1a08601a6a7bbd4ecfa36c8f6abbd9
-CompilerSupportLibraries.v1.1.0+0.i686-linux-musl-libgfortran5.tar.gz/sha512/0e225e0a7b651f6b3fbccf760d08d66f2d8af1e329d14ef67fd3968a46905e062edcf75f60d7540f0cd7dabcd3ac9130fa0f63e198869bdc6a9aabd391652805
-CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/9cfea65fa6c1b587d9b4b84ee64af166
-CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/b30e24982d4140c312759b8c26d4b72845fc1fa4d7fdf49ccfe9994f7bbf1815ed006a228f6a2185c5b8f9d596d0b04debd1d8392e705c530e5177a22c7c081d
-CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/af99905c4f054fe13842559f7201b3ad
-CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/96513ff22dc16cc259ad392862f1765218474bff24e561f14c1e0d349a6bc433952d9b7b73236b56722fd971e0b864b178d8a9f8d9499de4595bc9857ef17a95
-CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/1be078cd374d3b501b20d9ce679009ee
-CompilerSupportLibraries.v1.1.0+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/63097283c987dc439f02d72a6f70423acd962e4da25acc04185e654c7f16a617e34ad7efabd624fd2e70119e79e4d4806f76286d36d56c353f9e53814e75d3e4
-CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/156ae44ab4172903ad40932ca78a57ed
-CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/e800c20342dd9886c4c3f57e92278d6d41c544adba202ef3f5a6a4f8211fbbd8fab65f169adf7320b7be8a2ea02c0aa1afedbaf0b3f9afbfb691759aaaaccc4c
-CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/cb01c02fdcbd319784034744172e1eb9
-CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/0ba635d39958672a0a55069521e20ca6c0f9c81a9f55c360f6043acb415709edb72bfe8d0e83c25cdf9ace8a9e9ba10e39457e234e3905c988eb95e0e0ecff3d
-CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/f9592263c6e72228c492ed2ed216f29e
-CompilerSupportLibraries.v1.1.0+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/cbe29742959906e3fe9a356991ca1f09d4d8cc2a02a9af8624b3e02b4ab59e33bc05082826f7c67c73c6b91cc8e1e5c4a0c275c21c5f8eab8b58ed942cdcb55c
-CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/8f0db2ff4688c3f9e1337a28976d833a
-CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/98502e07499ad9e22147a977b1fe55320e75b6229c3993f1cd1b71e47a09ae6bf78e2341ce978ea72d33b111d09b813a332bfe8f4f6dfb669509c300fcec2561
-CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/980a1b8e6262c4a7b8f86b84f7234043
-CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/c0755d4fbb1b6fd7755d7508d7df929feabe7e5778661397ef0205e21aa3be565b39ccc2a08ed0d958e812c0c759be68ef52de09fe92ebab6da342b309a0810d
-CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/4b3cdb65e6114c77fd1e51da69e41afa
-CompilerSupportLibraries.v1.1.0+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/803cb771875d94eda554bade8197b31aab988ab0c957a2f8853d82d01418be9fee7d9d4b7ef6f5b7fc8d1825ab22083a71d467eb976d5076fc5d73a9a7a30440
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/36638a444b185954bf12169edace1914
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/33f657775258d0da1a57fc03c5e8ed203946944581ebf70af7b0205f9bff7fcd4f2bde5b6fa3b01659c51f106d0e6df5c7533ab8d3372c4895675854688e01dc
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/36ac52a361fd0f4be5c66572345af7a4
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/802bd8089bb2a3b5959a47dbade2199b46c247d0a793cbf6fcbc97b9a1dccd6d8585ac7694ae4bef1dc3ba21796ae5b53f995c8793ccd7316e8fde68ac121f83
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/5911da90a0fc86d665aa86cba12e9d61
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/c966936dfd272d9706aa51ed44abcb8cded899b0caa8b12ee787a0fb1569fa90a1cba89c9a9b83e05c0993facc615feb851399f4799c06956ae3064d172c964d
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/5f42a52e72f0e79530d71733a93811bf
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/51078ef0e447bb181003a50b899b39a9d1ee8ecc92fc293f5a358d836ddf21d03dc44433ae28aa21fdf756c2912b2d3f1e374a5ba108c8c34552fcf32f93fd0b
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/f3bbee1114cb85c266a45f64632c6911
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/102e638f49ff0f62644f15a931c71a16b96f02f4c90d1b8bd378e0d7c54f4e8a150cdb5ffdbc3dcbafb83131bef84f9071cb77e8debdd98d8929c7b65401fc54
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/ff2b0ebdc7ef83cf8b48bd2ae76c6430
-CompilerSupportLibraries.v1.1.0+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/0730ecf1b9476612cadc3f3e7c1b227a1967edc091c88cd0cc19477079d1739fd5e7b1022ff686c0c6a2404edaebfb02c810dcfc1aa4187e7ecddb54998ad96c
-CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/35642304a9a2f435cf5214b2715198fe
-CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/a67f41ba31c99a064f504f508711537f9e90089ca5352bfc2698c3fcd3e499ca716f07ffeac4fb1b88c2c934f7f380f262af8c863d3b16ac7e805d5c805ab358
-CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/01df0fbb265e5ff1a480a7a5e23b0835
-CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/57a79f2b8e846c1514dcb18420f26ae2889962040f410b746836cab4395749155fa9cd9d00d4c25954c0ffa72f9f3823b1b50688a20ddf675301f64e0d4b5c7e
-CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/1f1f6380ce8815cc9cedcea0b40860e7
-CompilerSupportLibraries.v1.1.0+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/a88ea8af8c8df792861812bfdf7f1bcaae31582ab78ce78b47a0dc6fd57b93441c0471f529ce23877131ac9701c6eed72ce89241746e18271f3686fbd718138c
-CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/5eab740e86bfa7656f6a08038fe2fa63
-CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/3dc6b7ec39ff7dcb71478376c86ce34a35a62f049f6203722c5414b7b635ff1b412e02d8d24c13c123d18b2e914780da4639538676694e342a1a6b507691ef25
-CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/9718c79244ed31c367e715f1f563b8cd
-CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/eec2380c4e182f4e923142736a2c4aaf11a525a5f966fed7e4ec4b431ee28f3842a4e73495df116604f74b419e6d398576ee3dd21d3c0c53b92167dcfd0f6b84
-CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/58d7b0b79a22f3aade7e4f39eec898e7
-CompilerSupportLibraries.v1.1.0+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/efecc0ca09ec6b7b8898c2ffd333c7e0a6a44706d72ac0e5010409aba92ee70a88b6fd77434bedafe0e013561f8d0c74b5a274808a6c9499f6a3005a7691785f
+CompilerSupportLibraries.v1.1.1+0.aarch64-apple-darwin-libgfortran5.tar.gz/md5/20ebaad57850393b6ac9fa924e511fe4
+CompilerSupportLibraries.v1.1.1+0.aarch64-apple-darwin-libgfortran5.tar.gz/sha512/020de4d8b0ff6bedbadaa305ff8445e6849f12053762ea4aa68412d1ec763dbd86f479587a2fbb862487f1feb04d976c38099ddf3887817a3d32b3f029cf85b1
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-gnu-libgfortran3.tar.gz/md5/d641904255ee412c45b089d92c53262b
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-gnu-libgfortran3.tar.gz/sha512/ace0383fe9bd64faeed1fb05a11bbec932bd56b8460d06d2b7c3e1b5f4f6e9a9b3345937088684e5cd1ca9a85ef1a5ff56a97a1f60449cd6e35247de1e123d81
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-gnu-libgfortran4.tar.gz/md5/2a71f320d8b9242ad26aabed74cbf404
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-gnu-libgfortran4.tar.gz/sha512/03e2a4482baaca2d6ce5cc207224d03bd7851486ebe8072c7317f5fcdd641395d945552d9462ab44a9f2e4b0ffaa3874a76f314d67bc0f75393a1151ab518611
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-gnu-libgfortran5.tar.gz/md5/1beec15ad689a5f572040ca2a7b6a880
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-gnu-libgfortran5.tar.gz/sha512/27bbe212a8d43e841cf8f3e9964b72bc220fea03cf5e65721b02d2f3aa5193acdce41e512578ed6be935b413cd0d2224a6bcd2e9624931f39092ba3cfc5cbcc0
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-musl-libgfortran3.tar.gz/md5/9e949c2efe48a7b2a62bff7e1ffdede0
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-musl-libgfortran3.tar.gz/sha512/2947acb250f8ff4936da5ed02ddbfa492fc38bc87baa588a36bb892ba68b6636a912cda976f8fff00cc7a710c3bfb185826b4cd4a726750ef5f161d5f1aa21a2
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-musl-libgfortran4.tar.gz/md5/7202764b1a89a748b07460d9c40a9279
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-musl-libgfortran4.tar.gz/sha512/63236225a9becdd166c4395ea5081c64f57bc51af89c2edb5abeb419d6eb8224a380a633afd861bb84a12435fd19c8554cbe5ffadf8324ff2c7f17021ed53e69
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-musl-libgfortran5.tar.gz/md5/f66c30d3cec8057ae47f05df022ead51
+CompilerSupportLibraries.v1.1.1+0.aarch64-linux-musl-libgfortran5.tar.gz/sha512/5329d9469bb0f47560e52b15eb21ab70e0e2da0275bdb2f8e6ed4feb132bc9989a6b44984329455104546c95d05a05f8fb4f1cf232856219ba005100f4b16dc3
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/md5/05ff63780f5b7c8c6c590c3626f32ac0
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8d3c4149531f3782f5efbb6a6fbbb7080ba005298ba962b5bc5f66250ea9fde91b34836ed909c16f306d21d2e358f985360962e9362a8e807ccd4254da3bb19b
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/md5/3ca2b6e8101d831e546c1b6ed2ca9a42
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-gnueabihf-libgfortran4.tar.gz/sha512/21a0b9c5acde96c0a91303f4f395e55f272d5585ad18f0365105188d129a3ca94ad66d4dd99b471abdf41a7a7262a3b258fd04b887110ad15255b284cd1612b0
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/md5/d4d560b8ecce0ff2cb4dbc88cb25942a
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-gnueabihf-libgfortran5.tar.gz/sha512/d405f61525af1b2fe85107a70ed67b8a1eb767923487fa71539e0f49d6e70358c8a24f4ef1c224256cf677af99b54a2f8243f1e207350fcb14d426a7a6bb3915
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/md5/8c6eddaa156fd0afee28ac5a154bc3f7
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-musleabihf-libgfortran3.tar.gz/sha512/b9fc86bb706ad98d61b63eb4cc8bfce6b2c67b58ba2cebecea7574f44790cce044bb1b4db1d20050b59538fa43b51cb352d752c77333a0f0621fde47c63a3596
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/md5/0a54c16fea86c6dadb39eff65c465528
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-musleabihf-libgfortran4.tar.gz/sha512/c635c636384d3af5b4b078be7398fbc665a185eae69dd223279affb4836fb5c575d6ab296ae940ccbe73777bdb5e355f4f28a2fa27606ac143ff424641c60c65
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/md5/892dfd91703f0f77d170a5371a1c25d4
+CompilerSupportLibraries.v1.1.1+0.armv6l-linux-musleabihf-libgfortran5.tar.gz/sha512/8ac59d00192c0e847168e61b3e93957f3909aab59ba8d05e47686a9f8b7226496f89b932151c42198ec966ccd47721cdf547a247ea4e5c61b22bfccce2ec591c
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/md5/05ff63780f5b7c8c6c590c3626f32ac0
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-gnueabihf-libgfortran3.tar.gz/sha512/8d3c4149531f3782f5efbb6a6fbbb7080ba005298ba962b5bc5f66250ea9fde91b34836ed909c16f306d21d2e358f985360962e9362a8e807ccd4254da3bb19b
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/md5/3ca2b6e8101d831e546c1b6ed2ca9a42
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-gnueabihf-libgfortran4.tar.gz/sha512/21a0b9c5acde96c0a91303f4f395e55f272d5585ad18f0365105188d129a3ca94ad66d4dd99b471abdf41a7a7262a3b258fd04b887110ad15255b284cd1612b0
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/md5/d4d560b8ecce0ff2cb4dbc88cb25942a
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-gnueabihf-libgfortran5.tar.gz/sha512/d405f61525af1b2fe85107a70ed67b8a1eb767923487fa71539e0f49d6e70358c8a24f4ef1c224256cf677af99b54a2f8243f1e207350fcb14d426a7a6bb3915
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/md5/8c6eddaa156fd0afee28ac5a154bc3f7
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-musleabihf-libgfortran3.tar.gz/sha512/b9fc86bb706ad98d61b63eb4cc8bfce6b2c67b58ba2cebecea7574f44790cce044bb1b4db1d20050b59538fa43b51cb352d752c77333a0f0621fde47c63a3596
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/md5/0a54c16fea86c6dadb39eff65c465528
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-musleabihf-libgfortran4.tar.gz/sha512/c635c636384d3af5b4b078be7398fbc665a185eae69dd223279affb4836fb5c575d6ab296ae940ccbe73777bdb5e355f4f28a2fa27606ac143ff424641c60c65
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/md5/892dfd91703f0f77d170a5371a1c25d4
+CompilerSupportLibraries.v1.1.1+0.armv7l-linux-musleabihf-libgfortran5.tar.gz/sha512/8ac59d00192c0e847168e61b3e93957f3909aab59ba8d05e47686a9f8b7226496f89b932151c42198ec966ccd47721cdf547a247ea4e5c61b22bfccce2ec591c
+CompilerSupportLibraries.v1.1.1+0.i686-linux-gnu-libgfortran3.tar.gz/md5/3094705222b6b61fd6a10422a73e1149
+CompilerSupportLibraries.v1.1.1+0.i686-linux-gnu-libgfortran3.tar.gz/sha512/27f874cde357ffa45aaa10f2e620ec0f8ab4e5a8bf4607fc023a2ec42040bcc9a724f959237c340d67451f8621402fa05133c1420086b87135f40326c30b97af
+CompilerSupportLibraries.v1.1.1+0.i686-linux-gnu-libgfortran4.tar.gz/md5/ba0acaff60648efa3915348a8a353df8
+CompilerSupportLibraries.v1.1.1+0.i686-linux-gnu-libgfortran4.tar.gz/sha512/0b6aaf75363cbe6133ca3aed351ab58ef1e441f61375f5baf702d8043813c459d48e8af17630f1a07dc22772ec9b02076af33726ed94e6314ae37d5a139d6dcc
+CompilerSupportLibraries.v1.1.1+0.i686-linux-gnu-libgfortran5.tar.gz/md5/95f1d57cfc43677e40bfc121bce79274
+CompilerSupportLibraries.v1.1.1+0.i686-linux-gnu-libgfortran5.tar.gz/sha512/edacd9960e9de1236c91752e103cddfc018d697e87fabb3cceadf36153b4e97842ef284bd1532290a5620007234882b4c4cd4f36525b61763d97b2f608358262
+CompilerSupportLibraries.v1.1.1+0.i686-linux-musl-libgfortran3.tar.gz/md5/f37fe1818e1634476c44afae478611c8
+CompilerSupportLibraries.v1.1.1+0.i686-linux-musl-libgfortran3.tar.gz/sha512/6e4e3eb5ac9570bfdf5280f59167eb6c4a74f3aa152afb4c5d180b9a6cdbdca557e7dd13f0b5b76943b45a65e848fe77c5b3bbc6ddb0fd846d03fbc9fbedf7ce
+CompilerSupportLibraries.v1.1.1+0.i686-linux-musl-libgfortran4.tar.gz/md5/b4ffd52179aa0006c56f279b87cb7556
+CompilerSupportLibraries.v1.1.1+0.i686-linux-musl-libgfortran4.tar.gz/sha512/a047ac7db204c31802f646351af51c55fe06498e851b2df58d7f93f75d9c0067f8736f247f108991ec01ac7f86f3026ecf58b5f2f3a76d7eab00130754e7f704
+CompilerSupportLibraries.v1.1.1+0.i686-linux-musl-libgfortran5.tar.gz/md5/2d38fc835f236f89f457fdf859ccb903
+CompilerSupportLibraries.v1.1.1+0.i686-linux-musl-libgfortran5.tar.gz/sha512/51fbe41efbce33b1cf3728df6fa59fd0e85a13308b3e868fe9f70f4d67857615f83542ba69be824a73e89959503dd7a11335d1c495704bd7d6cad6656d0c5d57
+CompilerSupportLibraries.v1.1.1+0.i686-w64-mingw32-libgfortran3.tar.gz/md5/9650002f6729c0964d33afcab334d77d
+CompilerSupportLibraries.v1.1.1+0.i686-w64-mingw32-libgfortran3.tar.gz/sha512/0b7907811a13d09b7b33203c7e46888308c7d6fcf5d69790babafc39f640541551f784264247f159a552f15df1ddd061c421a93b983d838d3bd7f85ba6427f70
+CompilerSupportLibraries.v1.1.1+0.i686-w64-mingw32-libgfortran4.tar.gz/md5/47e9fb99906b9647e26e4126a913074e
+CompilerSupportLibraries.v1.1.1+0.i686-w64-mingw32-libgfortran4.tar.gz/sha512/d7285691fbe1318e48e061d678e54890762cc16996652a34b190924cc1462d24ab0b08729945eb25f4bef60e60d50f3e78db57d4cda0302b8ba579db8a1311e1
+CompilerSupportLibraries.v1.1.1+0.i686-w64-mingw32-libgfortran5.tar.gz/md5/b588b2710f2b83d2c70c6104e585a3bd
+CompilerSupportLibraries.v1.1.1+0.i686-w64-mingw32-libgfortran5.tar.gz/sha512/b62a63b0c8750f85fc265db88456307b794e912352a68997c7cce06444391307c03edbe5b901833f53c5bd55f5a1e61a586538b08487cc139a2d71fccdce1d31
+CompilerSupportLibraries.v1.1.1+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/md5/7cce4f3dc057ebebaa677bf6f0d51e9e
+CompilerSupportLibraries.v1.1.1+0.powerpc64le-linux-gnu-libgfortran3.tar.gz/sha512/a0dd93905f0ede4da5e2fbacf2579154db8ac8e9963c77fb62284489686f2aa372925b3341742d86430a839267421af55f6e1e413473d17f13a1a199e6a904a0
+CompilerSupportLibraries.v1.1.1+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/md5/06ee6aaeca78b3e9005f53f1fa32731f
+CompilerSupportLibraries.v1.1.1+0.powerpc64le-linux-gnu-libgfortran4.tar.gz/sha512/ff0e33ce9f93b3a867cf409b95e763efbc8f4dde65ed19107eb14d29460d084f253e03ebd6375f1da996182b3d96e1fda4abff06507258da9a89ece36663db84
+CompilerSupportLibraries.v1.1.1+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/md5/483251d28076ee959dff131d13d7e53b
+CompilerSupportLibraries.v1.1.1+0.powerpc64le-linux-gnu-libgfortran5.tar.gz/sha512/a7c9053a8c1b784cb6459762f26e0c2106a9758cbe2aefe8975a14aaaf61b8a08e51c465e733e44d01537beb59d467c57e536ebd8b27b7b68f46945174c469c7
+CompilerSupportLibraries.v1.1.1+0.x86_64-apple-darwin-libgfortran3.tar.gz/md5/a147bf3a6d6550c177b8a784b9b02e21
+CompilerSupportLibraries.v1.1.1+0.x86_64-apple-darwin-libgfortran3.tar.gz/sha512/c6f7a13f0195eae8f7ad980a4b24de9b155be69c4437522723411f9866a4aee3c5b350ee2f0c95f41f19aba43acaca78309881157e8498df0664c902d0c05a5d
+CompilerSupportLibraries.v1.1.1+0.x86_64-apple-darwin-libgfortran4.tar.gz/md5/3f19c9d0e723a8d5591357ac3a9452a0
+CompilerSupportLibraries.v1.1.1+0.x86_64-apple-darwin-libgfortran4.tar.gz/sha512/5752bac310d80ed2dc1fc3d6580300d185787b9b933e31c8e0f572099abd0727d9483da8f9af858f706e96a183d2b10702c44381a080438cbb17d6459321ccfb
+CompilerSupportLibraries.v1.1.1+0.x86_64-apple-darwin-libgfortran5.tar.gz/md5/ad0f0e2fe3e7d147a0a27271a2aba0fc
+CompilerSupportLibraries.v1.1.1+0.x86_64-apple-darwin-libgfortran5.tar.gz/sha512/f42231adea3d0b6133c3b5bc5fbf765bc6a7ba8ef0f407fa1b8def36dd8a71d20ef39fb6e57b43208489c2795a96562cdbf15f3d20b3f3a09edb29b99d19a33a
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-gnu-libgfortran3.tar.gz/md5/4c78d56dbbbff682c0a78d11fb9d1e70
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-gnu-libgfortran3.tar.gz/sha512/0e9d6dcc4b8fddaaa94a26a46e915d33fb474f8a8ee14edd4d1c7e774846c44c5c5d852649a4f70409c99ac0e1d458077b7f0eb7dc0b0326ee8b625644d7074d
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-gnu-libgfortran4.tar.gz/md5/039d37f813b183c75feebadd21011eb6
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-gnu-libgfortran4.tar.gz/sha512/05e7291de1fd2520247402f0db9d348fdd7a02d8dd9133ac65701f88d237110a3cc6c6e2c5717364ab786b6e6063038ec10c9605e77bc4dbe1064a0e77617f5d
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-gnu-libgfortran5.tar.gz/md5/a985f13a85eb14d1b6339ba4983dc372
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-gnu-libgfortran5.tar.gz/sha512/27468ccd5642e6e11bd5972684518a0fb883bf4835ac18f5279c3fce97b1779131c7d9e39d8de26a15c293c832946334e964919f51d7679cd0569ce82b938579
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-musl-libgfortran3.tar.gz/md5/9d86ce2fe481ea97a1fd098bd47d524c
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-musl-libgfortran3.tar.gz/sha512/a865a4127bacaedd81b6c81279f6a44bc3497ab29a0401f66da1abfc0738ea459be9f158d06969c161a65925739665084bec5f8650a8cd1e8f0d08f1f44d729f
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-musl-libgfortran4.tar.gz/md5/86d9db869a7af6c96dea39f5d9d90505
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-musl-libgfortran4.tar.gz/sha512/01e0c69b04138989200ded92eddae6ff1873d3a440d17273d08bee40d53b2929e35bfd14be051074fe78671cac34ac2dd7360c1571790ee52f94a5921de42a65
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-musl-libgfortran5.tar.gz/md5/e72d28df4bcb60ab2f3389046e7c83a8
+CompilerSupportLibraries.v1.1.1+0.x86_64-linux-musl-libgfortran5.tar.gz/sha512/cac193a26328ddeff5f7bcc3d7207101c574f9bdb1bff5c2b925315c5c2404a2fdb6591d1968f30931373fbfcae9bda784c72e65580ad3acc398448cd193f65d
+CompilerSupportLibraries.v1.1.1+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/md5/35642304a9a2f435cf5214b2715198fe
+CompilerSupportLibraries.v1.1.1+0.x86_64-unknown-freebsd-libgfortran3.tar.gz/sha512/a67f41ba31c99a064f504f508711537f9e90089ca5352bfc2698c3fcd3e499ca716f07ffeac4fb1b88c2c934f7f380f262af8c863d3b16ac7e805d5c805ab358
+CompilerSupportLibraries.v1.1.1+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/md5/01df0fbb265e5ff1a480a7a5e23b0835
+CompilerSupportLibraries.v1.1.1+0.x86_64-unknown-freebsd-libgfortran4.tar.gz/sha512/57a79f2b8e846c1514dcb18420f26ae2889962040f410b746836cab4395749155fa9cd9d00d4c25954c0ffa72f9f3823b1b50688a20ddf675301f64e0d4b5c7e
+CompilerSupportLibraries.v1.1.1+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/md5/1f1f6380ce8815cc9cedcea0b40860e7
+CompilerSupportLibraries.v1.1.1+0.x86_64-unknown-freebsd-libgfortran5.tar.gz/sha512/a88ea8af8c8df792861812bfdf7f1bcaae31582ab78ce78b47a0dc6fd57b93441c0471f529ce23877131ac9701c6eed72ce89241746e18271f3686fbd718138c
+CompilerSupportLibraries.v1.1.1+0.x86_64-w64-mingw32-libgfortran3.tar.gz/md5/38fc8c445a1a610db40a7609155e22d6
+CompilerSupportLibraries.v1.1.1+0.x86_64-w64-mingw32-libgfortran3.tar.gz/sha512/085652c7ca583c3623611ca9262b70765c9936c9feb5f9034b2c6b6d6677a7a1d7d201b83d82d0d268f3190bd1a62eab0124e8fae3625407dee7f1df89d4106c
+CompilerSupportLibraries.v1.1.1+0.x86_64-w64-mingw32-libgfortran4.tar.gz/md5/f3f89eb3c2e441fde6e6b9c1c1a61183
+CompilerSupportLibraries.v1.1.1+0.x86_64-w64-mingw32-libgfortran4.tar.gz/sha512/c53f79e20ad043ab099873f38ece98c6bed22950610ba88b9c178a4bd943039cc426473828d509deb8c65c93309da1de87bdf36fb3954b8f8047277c418fe2e0
+CompilerSupportLibraries.v1.1.1+0.x86_64-w64-mingw32-libgfortran5.tar.gz/md5/024f7133425db23e215dc55589bb9171
+CompilerSupportLibraries.v1.1.1+0.x86_64-w64-mingw32-libgfortran5.tar.gz/sha512/819945496ea48dd44d8c0f12a11a358b7d1ebf198d60fbad576d74ddee68cdea98070cdd11ca96567d0c772ec007c03cbc83ff5c7d2ad737cbd486fe0c9afcd5
diff --git a/stdlib/CompilerSupportLibraries_jll/Project.toml b/stdlib/CompilerSupportLibraries_jll/Project.toml
index 3e15ff6b87b71..5aab865b5f6fc 100644
--- a/stdlib/CompilerSupportLibraries_jll/Project.toml
+++ b/stdlib/CompilerSupportLibraries_jll/Project.toml
@@ -4,7 +4,7 @@ uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"
 # NOTE: When updating this, also make sure to update the value
 # `CSL_NEXT_GLIBCXX_VERSION` in `Make.inc`, to properly disable
 # automatic usage of BB-built CSLs on extremely up-to-date systems!
-version = "1.1.0+0"
+version = "1.1.1+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 30450c36164fcf711645a747ea42c365cb89ac71 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Sun, 10 Mar 2024 14:58:14 -0400
Subject: [PATCH 1096/1315] add error for inconsistent public/export
 declarations (#53664)

Co-authored-by: Ian Butterworth <i.r.butterworth@gmail.com>
Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/docs/basedocs.jl         | 9 ++++++---
 src/module.c                  | 9 +++++++++
 stdlib/Profile/src/Profile.jl | 6 ++----
 test/reflection.jl            | 8 +++++++-
 4 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index d4785df98ec21..447cbe000faa6 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -64,9 +64,12 @@ kw"export"
     public
 
 `public` is used within modules to tell Julia which names are part of the
-public API of the module . For example: `public foo` indicates that the name
-`foo` is public, without making it available when [`using`](@ref)
-the module. See the [manual section about modules](@ref modules) for details.
+public API of the module. For example: `public foo` indicates that the name
+`foo` is public, without making it available when [`using`](@ref) the module.
+
+As [`export`](@ref) already indicates that a name is public, it is
+unnecessary and an error to declare a name both as `public` and as `export`ed.
+See the [manual section about modules](@ref modules) for details.
 
 !!! compat "Julia 1.11"
     The public keyword was added in Julia 1.11. Prior to this the notion
diff --git a/src/module.c b/src/module.c
index 7a12552415b11..702c98f165782 100644
--- a/src/module.c
+++ b/src/module.c
@@ -665,6 +665,15 @@ JL_DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from)
 JL_DLLEXPORT void jl_module_public(jl_module_t *from, jl_sym_t *s, int exported)
 {
     jl_binding_t *b = jl_get_module_binding(from, s, 1);
+    if (b->publicp) {
+        // check for conflicting declarations
+        if (b->exportp && !exported)
+            jl_errorf("cannot declare %s.%s public; it is already declared exported",
+                      jl_symbol_name(from->name), jl_symbol_name(s));
+        if (!b->exportp && exported)
+            jl_errorf("cannot declare %s.%s exported; it is already declared public",
+                      jl_symbol_name(from->name), jl_symbol_name(s));
+    }
     b->publicp = 1;
     b->exportp |= exported;
 }
diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index e426884f058b9..17e903ed373b1 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -23,8 +23,8 @@ Profiling support.
 module Profile
 
 global print
-public @profile,
-    clear,
+export @profile
+public clear,
     print,
     fetch,
     retrieve,
@@ -44,8 +44,6 @@ const nmeta = 4 # number of metadata fields per block (threadid, taskid, cpu_cyc
 # deprecated functions: use `getdict` instead
 lookup(ip::UInt) = lookup(convert(Ptr{Cvoid}, ip))
 
-export @profile
-
 """
     @profile
 
diff --git a/test/reflection.jl b/test/reflection.jl
index 4a738dd3e58ee..4fd2b7cd52306 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -1185,14 +1185,20 @@ end
 # marking a symbol as public should not "unexport" it
 # https://github.com/JuliaLang/julia/issues/52812
 module Mod52812
+using Test
 export a, b
-public a
+@test_throws ErrorException eval(Expr(:public, :a))
+public c
+@test_throws ErrorException eval(Expr(:export, :c))
+export b
+public c
 end
 
 @test Base.isexported(Mod52812, :a)
 @test Base.isexported(Mod52812, :b)
 @test Base.ispublic(Mod52812, :a)
 @test Base.ispublic(Mod52812, :b)
+@test Base.ispublic(Mod52812, :c) && !Base.isexported(Mod52812, :c)
 
 @test Base.infer_return_type(code_lowered, (Any,)) == Vector{Core.CodeInfo}
 @test Base.infer_return_type(code_lowered, (Any,Any)) == Vector{Core.CodeInfo}

From ccdf89e1627fea476408ab5ac546f719f33b670f Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Sun, 10 Mar 2024 16:15:20 -0500
Subject: [PATCH 1097/1315] Noteworthy differences: `exp.(A)` vs `exp(A)`
 (#53686)

---
 doc/src/manual/noteworthy-differences.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/doc/src/manual/noteworthy-differences.md b/doc/src/manual/noteworthy-differences.md
index 16cf46e0dfc4a..7db1a201f39ca 100644
--- a/doc/src/manual/noteworthy-differences.md
+++ b/doc/src/manual/noteworthy-differences.md
@@ -56,6 +56,10 @@ may trip up Julia users accustomed to MATLAB:
   * In Julia, if `A` and `B` are arrays, logical comparison operations like `A == B` do not return
     an array of booleans. Instead, use `A .== B`, and similarly for the other boolean operators like
     [`<`](@ref), [`>`](@ref).
+  * In Julia, when you want to apply a scalar-valued function elementwise to an array, use broadcasting
+    syntax: `f.(A)` instead of `f(A)`. In some cases, both operations are defined but mean different things:
+    in MATLAB `exp(A)` applies elementwise and `expm(A)` is the [matrix exponential](https://en.wikipedia.org/wiki/Matrix_exponential),
+    but in Julia `exp.(A)` applies elementwise and `exp(A)` is the matrix exponential.
   * In Julia, the operators [`&`](@ref), [`|`](@ref), and [`⊻`](@ref xor) ([`xor`](@ref)) perform the
     bitwise operations equivalent to `and`, `or`, and `xor` respectively in MATLAB, and have precedence
     similar to Python's bitwise operators (unlike C). They can operate on scalars or element-wise
@@ -245,6 +249,10 @@ For users coming to Julia from R, these are some noteworthy differences:
   * In Julia, the exponentiation operator is `^`, not `**` as in Python.
   * Julia uses `nothing` of type `Nothing` to represent a null value, whereas Python uses `None` of type `NoneType`.
   * In Julia, the standard operators over a matrix type are matrix operations, whereas, in Python, the standard operators are element-wise operations. When both `A` and `B` are matrices, `A * B` in Julia performs matrix multiplication, not element-wise multiplication as in Python. `A * B` in Julia is equivalent with `A @ B` in Python, whereas `A * B` in Python is equivalent with `A .* B` in Julia.
+  * In Julia, when you want to apply a scalar-valued function elementwise to an array, use broadcasting
+    syntax: `f.(A)` instead of `f(A)`. In some cases, both operations are defined but mean different things:
+    `numpy.exp(A)` applies elementwise and `scipy.linalg.expm(A)` is the [matrix exponential](https://en.wikipedia.org/wiki/Matrix_exponential),
+    but in Julia `exp.(A)` applies elementwise and `exp(A)` is the matrix exponential.
   * The adjoint operator `'` in Julia returns an adjoint of a vector (a lazy representation of row vector), whereas the transpose operator `.T` over a vector in Python returns the original vector (non-op).
   * In Julia, a function may contain multiple concrete implementations (called *methods*), which are selected via multiple dispatch based on the types of all arguments to the call, as compared to functions in Python, which have a single implementation and no polymorphism (as opposed to Python method calls which use a different syntax and allows dispatch on the receiver of the method).
   * There are no classes in Julia. Instead there are structures (mutable or immutable), containing data but no methods.

From 26b3b5fb18d3b03e2e79be9e3bf817afeb55b711 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sun, 10 Mar 2024 18:34:55 -0400
Subject: [PATCH 1098/1315] move precompile workload back from Base (#53679)

---
 base/Base.jl                   | 55 ----------------------
 contrib/generate_precompile.jl | 84 +++++++++++++++++++++-------------
 2 files changed, 52 insertions(+), 87 deletions(-)

diff --git a/base/Base.jl b/base/Base.jl
index 5375729be55a3..1f0dfceb26492 100644
--- a/base/Base.jl
+++ b/base/Base.jl
@@ -568,61 +568,6 @@ end_base_include = time_ns()
 const _sysimage_modules = PkgId[]
 in_sysimage(pkgid::PkgId) = pkgid in _sysimage_modules
 
-# Precompiles for Revise and other packages
-# TODO: move these to contrib/generate_precompile.jl
-# The problem is they don't work there
-for match = _methods(+, (Int, Int), -1, get_world_counter())
-    m = match.method
-    delete!(push!(Set{Method}(), m), m)
-    copy(Core.Compiler.retrieve_code_info(Core.Compiler.specialize_method(match), typemax(UInt)))
-
-    empty!(Set())
-    push!(push!(Set{Union{GlobalRef,Symbol}}(), :two), GlobalRef(Base, :two))
-    (setindex!(Dict{String,Base.PkgId}(), Base.PkgId(Base), "file.jl"))["file.jl"]
-    (setindex!(Dict{Symbol,Vector{Int}}(), [1], :two))[:two]
-    (setindex!(Dict{Base.PkgId,String}(), "file.jl", Base.PkgId(Base)))[Base.PkgId(Base)]
-    (setindex!(Dict{Union{GlobalRef,Symbol}, Vector{Int}}(), [1], :two))[:two]
-    (setindex!(IdDict{Type, Union{Missing, Vector{Tuple{LineNumberNode, Expr}}}}(), missing, Int))[Int]
-    Dict{Symbol, Union{Nothing, Bool, Symbol}}(:one => false)[:one]
-    Dict(Base => [:(1+1)])[Base]
-    Dict(:one => [1])[:one]
-    Dict("abc" => Set())["abc"]
-    pushfirst!([], sum)
-    get(Base.pkgorigins, Base.PkgId(Base), nothing)
-    sort!([1,2,3])
-    unique!([1,2,3])
-    cumsum([1,2,3])
-    append!(Int[], BitSet())
-    isempty(BitSet())
-    delete!(BitSet([1,2]), 3)
-    deleteat!(Int32[1,2,3], [1,3])
-    deleteat!(Any[1,2,3], [1,3])
-    Core.svec(1, 2) == Core.svec(3, 4)
-    any(t->t[1].line > 1, [(LineNumberNode(2,:none), :(1+1))])
-
-    # Code loading uses this
-    sortperm(mtime.(readdir(".")), rev=true)
-    # JLLWrappers uses these
-    Dict{UUID,Set{String}}()[UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210")] = Set{String}()
-    get!(Set{String}, Dict{UUID,Set{String}}(), UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210"))
-    eachindex(IndexLinear(), Expr[])
-    push!(Expr[], Expr(:return, false))
-    vcat(String[], String[])
-    k, v = (:hello => nothing)
-    precompile(indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int))
-    precompile(indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int, Int))
-    # Preferences uses these
-    precompile(get_preferences, (UUID,))
-    precompile(record_compiletime_preference, (UUID, String))
-    get(Dict{String,Any}(), "missing", nothing)
-    delete!(Dict{String,Any}(), "missing")
-    for (k, v) in Dict{String,Any}()
-        println(k)
-    end
-
-    break   # only actually need to do this once
-end
-
 if is_primary_base_module
 
 # Profiling helper
diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index 57af6c1f32679..9e4e2d4485189 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -91,39 +91,59 @@ for T in (Float16, Float32, Float64), IO in (IOBuffer, IOContext{IOBuffer}, Base
     hardcoded_precompile_statements *= "precompile(Tuple{typeof(show), $IO, $T})\n"
 end
 
+# Precompiles for Revise and other packages
 precompile_script = """
-# NOTE: these were moved to the end of Base.jl. TODO: move back here.
-# # Used by Revise & its dependencies
-# while true  # force inference
-# delete!(push!(Set{Module}(), Base), Main)
-# m = first(methods(+))
-# delete!(push!(Set{Method}(), m), m)
-# empty!(Set())
-# push!(push!(Set{Union{GlobalRef,Symbol}}(), :two), GlobalRef(Base, :two))
-# (setindex!(Dict{String,Base.PkgId}(), Base.PkgId(Base), "file.jl"))["file.jl"]
-# (setindex!(Dict{Symbol,Vector{Int}}(), [1], :two))[:two]
-# (setindex!(Dict{Base.PkgId,String}(), "file.jl", Base.PkgId(Base)))[Base.PkgId(Base)]
-# (setindex!(Dict{Union{GlobalRef,Symbol}, Vector{Int}}(), [1], :two))[:two]
-# (setindex!(IdDict{Type, Union{Missing, Vector{Tuple{LineNumberNode, Expr}}}}(), missing, Int))[Int]
-# Dict{Symbol, Union{Nothing, Bool, Symbol}}(:one => false)[:one]
-# Dict(Base => [:(1+1)])[Base]
-# Dict(:one => [1])[:one]
-# Dict("abc" => Set())["abc"]
-# pushfirst!([], sum)
-# get(Base.pkgorigins, Base.PkgId(Base), nothing)
-# sort!([1,2,3])
-# unique!([1,2,3])
-# cumsum([1,2,3])
-# append!(Int[], BitSet())
-# isempty(BitSet())
-# delete!(BitSet([1,2]), 3)
-# deleteat!(Int32[1,2,3], [1,3])
-# deleteat!(Any[1,2,3], [1,3])
-# Core.svec(1, 2) == Core.svec(3, 4)
-# # copy(Core.Compiler.retrieve_code_info(Core.Compiler.specialize_method(which(+, (Int, Int)), [Int, Int], Core.svec())))
-# any(t->t[1].line > 1, [(LineNumberNode(2,:none),:(1+1))])
-# break   # end force inference
-# end
+for match = Base._methods(+, (Int, Int), -1, Base.get_world_counter())
+    m = match.method
+    delete!(push!(Set{Method}(), m), m)
+    copy(Core.Compiler.retrieve_code_info(Core.Compiler.specialize_method(match), typemax(UInt)))
+
+    empty!(Set())
+    push!(push!(Set{Union{GlobalRef,Symbol}}(), :two), GlobalRef(Base, :two))
+    (setindex!(Dict{String,Base.PkgId}(), Base.PkgId(Base), "file.jl"))["file.jl"]
+    (setindex!(Dict{Symbol,Vector{Int}}(), [1], :two))[:two]
+    (setindex!(Dict{Base.PkgId,String}(), "file.jl", Base.PkgId(Base)))[Base.PkgId(Base)]
+    (setindex!(Dict{Union{GlobalRef,Symbol}, Vector{Int}}(), [1], :two))[:two]
+    (setindex!(IdDict{Type, Union{Missing, Vector{Tuple{LineNumberNode, Expr}}}}(), missing, Int))[Int]
+    Dict{Symbol, Union{Nothing, Bool, Symbol}}(:one => false)[:one]
+    Dict(Base => [:(1+1)])[Base]
+    Dict(:one => [1])[:one]
+    Dict("abc" => Set())["abc"]
+    pushfirst!([], sum)
+    get(Base.pkgorigins, Base.PkgId(Base), nothing)
+    sort!([1,2,3])
+    unique!([1,2,3])
+    cumsum([1,2,3])
+    append!(Int[], BitSet())
+    isempty(BitSet())
+    delete!(BitSet([1,2]), 3)
+    deleteat!(Int32[1,2,3], [1,3])
+    deleteat!(Any[1,2,3], [1,3])
+    Core.svec(1, 2) == Core.svec(3, 4)
+    any(t->t[1].line > 1, [(LineNumberNode(2,:none), :(1+1))])
+
+    # Code loading uses this
+    sortperm(mtime.(readdir(".")), rev=true)
+    # JLLWrappers uses these
+    Dict{Base.UUID,Set{String}}()[Base.UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210")] = Set{String}()
+    get!(Set{String}, Dict{Base.UUID,Set{String}}(), Base.UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210"))
+    eachindex(IndexLinear(), Expr[])
+    push!(Expr[], Expr(:return, false))
+    vcat(String[], String[])
+    k, v = (:hello => nothing)
+    precompile(Base.indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int))
+    precompile(Base.indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int, Int))
+    # Preferences uses these
+    precompile(Base.get_preferences, (Base.UUID,))
+    precompile(Base.record_compiletime_preference, (Base.UUID, String))
+    get(Dict{String,Any}(), "missing", nothing)
+    delete!(Dict{String,Any}(), "missing")
+    for (k, v) in Dict{String,Any}()
+        println(k)
+    end
+
+    break   # only actually need to do this once
+end
 """
 
 julia_exepath() = joinpath(Sys.BINDIR, Base.julia_exename())

From 6e3044d46acc90b7ba948bef7bd0c276f5817870 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 11 Mar 2024 11:44:28 +0530
Subject: [PATCH 1099/1315] Fix linear indexing for ReshapedArray if the parent
 has offset axes  (#41232)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR fixes
```julia
julia> r = reshape(Base.IdentityUnitRange(3:4), 2, 1)
2×1 reshape(::Base.IdentityUnitRange{UnitRange{Int64}}, 2, 1) with eltype Int64:
 3
 4

julia> collect(r) == r
false

julia> collect(r)
2×1 Matrix{Int64}:
 3258125826116431922
 3688512103538242609
```

After this PR,
```julia
julia> collect(r)
2×1 Matrix{Int64}:
 3
 4
```
---
 base/reshapedarray.jl |  9 ++++++---
 test/abstractarray.jl | 30 ++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/base/reshapedarray.jl b/base/reshapedarray.jl
index 344858e76764a..63e508e8835de 100644
--- a/base/reshapedarray.jl
+++ b/base/reshapedarray.jl
@@ -238,7 +238,8 @@ offset_if_vec(i::Integer, axs::Tuple) = i
 
 @inline function isassigned(A::ReshapedArrayLF, index::Int)
     @boundscheck checkbounds(Bool, A, index) || return false
-    @inbounds ret = isassigned(parent(A), index)
+    indexparent = index - firstindex(A) + firstindex(parent(A))
+    @inbounds ret = isassigned(parent(A), indexparent)
     ret
 end
 @inline function isassigned(A::ReshapedArray{T,N}, indices::Vararg{Int, N}) where {T,N}
@@ -251,7 +252,8 @@ end
 
 @inline function getindex(A::ReshapedArrayLF, index::Int)
     @boundscheck checkbounds(A, index)
-    @inbounds ret = parent(A)[index]
+    indexparent = index - firstindex(A) + firstindex(parent(A))
+    @inbounds ret = parent(A)[indexparent]
     ret
 end
 @inline function getindex(A::ReshapedArray{T,N}, indices::Vararg{Int,N}) where {T,N}
@@ -275,7 +277,8 @@ end
 
 @inline function setindex!(A::ReshapedArrayLF, val, index::Int)
     @boundscheck checkbounds(A, index)
-    @inbounds parent(A)[index] = val
+    indexparent = index - firstindex(A) + firstindex(parent(A))
+    @inbounds parent(A)[indexparent] = val
     val
 end
 @inline function setindex!(A::ReshapedArray{T,N}, val, indices::Vararg{Int,N}) where {T,N}
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 1411864acfa03..48451d43d79c4 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -2060,3 +2060,33 @@ end
     test_unsetindex(MyMatrixUnsetIndexCartInds)
     test_unsetindex(MyMatrixUnsetIndexLinInds)
 end
+
+@testset "reshape for offset arrays" begin
+    p = Base.IdentityUnitRange(3:4)
+    r = reshape(p, :, 1)
+    @test r[eachindex(r)] == UnitRange(p)
+    @test collect(r) == r
+
+    struct ZeroBasedArray{T,N,A<:AbstractArray{T,N}} <: AbstractArray{T,N}
+        a :: A
+        function ZeroBasedArray(a::AbstractArray)
+            Base.require_one_based_indexing(a)
+            new{eltype(a), ndims(a), typeof(a)}(a)
+        end
+    end
+    Base.parent(z::ZeroBasedArray) = z.a
+    Base.size(z::ZeroBasedArray) = size(parent(z))
+    Base.axes(z::ZeroBasedArray) = map(x -> Base.IdentityUnitRange(0:x - 1), size(parent(z)))
+    Base.getindex(z::ZeroBasedArray{<:Any, N}, i::Vararg{Int,N}) where {N} = parent(z)[map(x -> x + 1, i)...]
+    Base.setindex!(z::ZeroBasedArray{<:Any, N}, val, i::Vararg{Int,N}) where {N} = parent(z)[map(x -> x + 1, i)...] = val
+
+    z = ZeroBasedArray(collect(1:4))
+    r2 = reshape(z, :, 1)
+    @test r2[CartesianIndices(r2)] == r2[LinearIndices(r2)]
+    r2[firstindex(r2)] = 34
+    @test z[0] == 34
+    r2[eachindex(r2)] = r2 .* 2
+    for (i, j) in zip(eachindex(r2), eachindex(z))
+        @test r2[i] == z[j]
+    end
+end

From 1ba83f021ecf09a431f7ecd7f35072e6849204eb Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 11 Mar 2024 12:20:16 +0530
Subject: [PATCH 1100/1315] LinAlg: fzeropreserving unit triangular broadcast
 preserves structure (#53648)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On master
```julia
julia> UU = UnitUpperTriangular(reshape([1:9;],3,3))
3×3 UnitUpperTriangular{Int64, Matrix{Int64}}:
 1  4  7
 ⋅  1  8
 ⋅  ⋅  1

julia> UU .* 2
3×3 Matrix{Int64}:
 2  8  14
 0  2  16
 0  0   2
```
This PR
```julia
julia> UU .* 2
3×3 UpperTriangular{Int64, Matrix{Int64}}:
 2  8  14
 ⋅  2  16
 ⋅  ⋅   2
```
This also improves performance, as the `materialize` skips the
structured zeros.
```julia
julia> UU = UnitUpperTriangular(rand(100, 100));

julia> @btime $UU .* 2;
  12.788 μs (3 allocations: 78.20 KiB) # master
  7.821 μs (3 allocations: 78.20 KiB) # PR
```
---
 .../LinearAlgebra/src/structuredbroadcast.jl  |  7 +++-
 .../LinearAlgebra/test/structuredbroadcast.jl | 37 +++++++++++++++++++
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/structuredbroadcast.jl b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
index e5393bfc719f1..dfc58aabc63ec 100644
--- a/stdlib/LinearAlgebra/src/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
@@ -152,8 +152,13 @@ end
 
 function Base.similar(bc::Broadcasted{StructuredMatrixStyle{T}}, ::Type{ElType}) where {T,ElType}
     inds = axes(bc)
-    if isstructurepreserving(bc) || (fzeropreserving(bc) && !(T <: Union{SymTridiagonal,UnitLowerTriangular,UnitUpperTriangular}))
+    fzerobc = fzeropreserving(bc)
+    if isstructurepreserving(bc) || (fzerobc && !(T <: Union{SymTridiagonal,UnitLowerTriangular,UnitUpperTriangular}))
         return structured_broadcast_alloc(bc, T, ElType, length(inds[1]))
+    elseif fzerobc && T <: UnitLowerTriangular
+        return similar(convert(Broadcasted{StructuredMatrixStyle{LowerTriangular}}, bc), ElType)
+    elseif fzerobc && T <: UnitUpperTriangular
+        return similar(convert(Broadcasted{StructuredMatrixStyle{UpperTriangular}}, bc), ElType)
     end
     return similar(convert(Broadcasted{DefaultArrayStyle{ndims(bc)}}, bc), ElType)
 end
diff --git a/stdlib/LinearAlgebra/test/structuredbroadcast.jl b/stdlib/LinearAlgebra/test/structuredbroadcast.jl
index fab6cd80141b2..02d7ead55af17 100644
--- a/stdlib/LinearAlgebra/test/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/test/structuredbroadcast.jl
@@ -59,6 +59,43 @@ using Test, LinearAlgebra
             @test broadcast!(*, Z, X, Y) == broadcast(*, fX, fY)
         end
     end
+    UU = UnitUpperTriangular(rand(N,N))
+    UL = UnitLowerTriangular(rand(N,N))
+    unittriangulars = (UU, UL)
+    Ttris = typeof.((UpperTriangular(parent(UU)), LowerTriangular(parent(UU))))
+    funittriangulars = map(Array, unittriangulars)
+    for (X, fX, Ttri) in zip(unittriangulars, funittriangulars, Ttris)
+        @test (Q = broadcast(sin, X); typeof(Q) == Ttri && Q == broadcast(sin, fX))
+        @test broadcast!(sin, Z, X) == broadcast(sin, fX)
+        @test (Q = broadcast(cos, X); Q isa Matrix && Q == broadcast(cos, fX))
+        @test broadcast!(cos, Z, X) == broadcast(cos, fX)
+        @test (Q = broadcast(*, s, X); typeof(Q) == Ttri && Q == broadcast(*, s, fX))
+        @test broadcast!(*, Z, s, X) == broadcast(*, s, fX)
+        @test (Q = broadcast(+, fV, fA, X); Q isa Matrix && Q == broadcast(+, fV, fA, fX))
+        @test broadcast!(+, Z, fV, fA, X) == broadcast(+, fV, fA, fX)
+        @test (Q = broadcast(*, s, fV, fA, X); Q isa Matrix && Q == broadcast(*, s, fV, fA, fX))
+        @test broadcast!(*, Z, s, fV, fA, X) == broadcast(*, s, fV, fA, fX)
+
+        @test X .* 2.0 == X .* (2.0,) == fX .* 2.0
+        @test X .* 2.0 isa Ttri
+        @test X .* (2.0,) isa Ttri
+        @test isequal(X .* Inf, fX .* Inf)
+
+        two = 2
+        @test X .^ 2 ==  X .^ (2,) == fX .^ 2 == X .^ two
+        @test X .^ 2 isa typeof(X) # special cased, as isstructurepreserving
+        @test X .^ (2,) isa Ttri
+        @test X .^ two isa Ttri
+        @test X .^ 0 == fX .^ 0
+        @test X .^ -1 == fX .^ -1
+
+        for (Y, fY) in zip(unittriangulars, funittriangulars)
+            @test broadcast(+, X, Y) == broadcast(+, fX, fY)
+            @test broadcast!(+, Z, X, Y) == broadcast(+, fX, fY)
+            @test broadcast(*, X, Y) == broadcast(*, fX, fY)
+            @test broadcast!(*, Z, X, Y) == broadcast(*, fX, fY)
+        end
+    end
 end
 
 @testset "broadcast! where the destination is a structured matrix" begin

From 57efee11663814e426f622b75efe19fbc70d6026 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Mon, 11 Mar 2024 06:56:59 -0400
Subject: [PATCH 1101/1315] Correct `@NamedTuple` printing for non-identitifer
 keys (#53689)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Before:
```
julia> typeof((;:var"#"=>1))
@NamedTuple{#::Int64}

julia> @NamedTuple{#::Int64}
ERROR: ParseError:
 # Error @ REPL[47]:2:2
 @NamedTuple{#::Int64}

 #└ ── Expected `}`
Stacktrace:
 [1] top-level scope
   @ none:1
```

After:
```
julia> typeof((;:var"#"=>1))
@NamedTuple{var"#"::Int64}

julia> @NamedTuple{var"#"::Int64}
@NamedTuple{var"#"::Int64}
```
---
 base/show.jl | 2 +-
 test/show.jl | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/show.jl b/base/show.jl
index 33832f898d240..d25853c295871 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1192,7 +1192,7 @@ function show_at_namedtuple(io::IO, syms::Tuple, types::DataType)
         if !first
             print(io, ", ")
         end
-        print(io, syms[i])
+        show_sym(io, syms[i])
         typ = types.parameters[i]
         if typ !== Any
             print(io, "::")
diff --git a/test/show.jl b/test/show.jl
index 8d6b32a3fd663..5e432fe0e31a3 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1381,6 +1381,7 @@ test_repr("(:).a")
 @test repr(@NamedTuple{kw::@NamedTuple{kw2::Int64}}) == "@NamedTuple{kw::@NamedTuple{kw2::Int64}}"
 @test repr(@NamedTuple{kw::NTuple{7, Int64}}) == "@NamedTuple{kw::NTuple{7, Int64}}"
 @test repr(@NamedTuple{a::Float64, b}) == "@NamedTuple{a::Float64, b}"
+@test repr(@NamedTuple{var"#"::Int64}) == "@NamedTuple{var\"#\"::Int64}"
 
 # Test general printing of `Base.Pairs` (it should not use the `@Kwargs` macro syntax)
 @test repr(@Kwargs{init::Int}) == "Base.Pairs{Symbol, $Int, Tuple{Symbol}, @NamedTuple{init::$Int}}"

From 60d4b7be63a477071a0640a3bc87d5db3ff73d93 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 11 Mar 2024 08:28:24 -0400
Subject: [PATCH 1102/1315] add isassigned methods for reinterpretarray
 (#53663)

Fixes #52925
Refs #51760
---
 base/reinterpretarray.jl |  4 ++++
 test/reinterpretarray.jl | 20 ++++++++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/base/reinterpretarray.jl b/base/reinterpretarray.jl
index ff674690a5c66..8b4025e6903cd 100644
--- a/base/reinterpretarray.jl
+++ b/base/reinterpretarray.jl
@@ -386,6 +386,10 @@ check_ptr_indexable(a::AbstractArray, sz) = false
 
 @propagate_inbounds getindex(a::ReinterpretArray) = a[firstindex(a)]
 
+@propagate_inbounds isassigned(a::ReinterpretArray, inds::Integer...) = checkbounds(Bool, a, inds...) && (check_ptr_indexable(a) || _isassigned_ra(a, inds...))
+@propagate_inbounds isassigned(a::ReinterpretArray, inds::SCartesianIndex2) = isassigned(a.parent, inds.j)
+@propagate_inbounds _isassigned_ra(a::ReinterpretArray, inds...) = true # that is not entirely true, but computing exactly which indexes will be accessed in the parent requires a lot of duplication from the _getindex_ra code
+
 @propagate_inbounds function getindex(a::ReinterpretArray{T,N,S}, inds::Vararg{Int, N}) where {T,N,S}
     check_readable(a)
     check_ptr_indexable(a) && return _getindex_ptr(a, inds...)
diff --git a/test/reinterpretarray.jl b/test/reinterpretarray.jl
index 05a40895b7934..46ecbf6d06723 100644
--- a/test/reinterpretarray.jl
+++ b/test/reinterpretarray.jl
@@ -588,3 +588,23 @@ end
 
     @test_throws ArgumentError reinterpret(Tuple{Int32, Int64}, (Int16(1), Int64(4)))
 end
+
+let R = reinterpret(Float32, ComplexF32[1.0f0+2.0f0*im, 4.0f0+3.0f0*im])
+    @test !isassigned(R, 0)
+    @test isassigned(R, 1)
+    @test isassigned(R, 4)
+    @test isassigned(R, Int8(2), Int16(1), Int32(1), Int64(1))
+    @test !isassigned(R, 1, 2)
+    @test !isassigned(R, 5)
+    @test Array(R)::Vector{Float32} == [1.0f0, 2.0f0, 4.0f0, 3.0f0]
+end
+
+let R = reinterpret(reshape, Float32, ComplexF32[1.0f0+2.0f0*im, 4.0f0+3.0f0*im])
+    @test !isassigned(R, 0)
+    @test isassigned(R, 1)
+    @test isassigned(R, 4)
+    @test isassigned(R, Int8(2), Int16(2), Int32(1), Int64(1))
+    @test !isassigned(R, 1, 1, 2)
+    @test !isassigned(R, 5)
+    @test Array(R)::Matrix{Float32} == [1.0f0 4.0f0; 2.0f0 3.0f0]
+end

From 2978a642b8d0a1912f80e84e7c2e769919aed376 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 11 Mar 2024 08:28:49 -0400
Subject: [PATCH 1103/1315] [REPL] fix incorrectly cleared line after
 completions accepted (#53662)

The hint must be cleared before the screen state is reset, otherwise the
state after reset may not be compatible with being able to clear it.

Fixes #52264
---
 stdlib/REPL/src/LineEdit.jl | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/stdlib/REPL/src/LineEdit.jl b/stdlib/REPL/src/LineEdit.jl
index 3b63a256dafe2..a910bfaebab06 100644
--- a/stdlib/REPL/src/LineEdit.jl
+++ b/stdlib/REPL/src/LineEdit.jl
@@ -479,14 +479,12 @@ prompt_string(f::Function) = Base.invokelatest(f)
 function maybe_show_hint(s::PromptState)
     isa(s.hint, String) || return nothing
     # The hint being "" then nothing is used to first clear a previous hint, then skip printing the hint
-    # the clear line cannot be printed each time because it breaks column movement
     if isempty(s.hint)
-        print(terminal(s), "\e[0K") # clear remainder of line which had a hint
         s.hint = nothing
     else
         Base.printstyled(terminal(s), s.hint, color=:light_black)
         cmove_left(terminal(s), textwidth(s.hint))
-        s.hint = "" # being "" signals to do one clear line remainder to clear the hint next time if still empty
+        s.hint = "" # being "" signals to do one clear line remainder to clear the hint next time the screen is refreshed
     end
     return nothing
 end
@@ -496,8 +494,13 @@ function refresh_multi_line(s::PromptState; kw...)
         close(s.refresh_wait)
         s.refresh_wait = nothing
     end
+    if s.hint isa String
+        # clear remainder of line which is unknown here if it had a hint before unbeknownst to refresh_multi_line
+        # the clear line cannot be printed each time because it would break column movement
+        print(terminal(s), "\e[0K")
+    end
     r = refresh_multi_line(terminal(s), s; kw...)
-    maybe_show_hint(s)
+    maybe_show_hint(s) # now maybe write the hint back to the screen
     return r
 end
 refresh_multi_line(s::ModeState; kw...) = refresh_multi_line(terminal(s), s; kw...)

From f882c00bdc5904cee7d1631740ba3824157bc656 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Mon, 11 Mar 2024 19:45:30 +0530
Subject: [PATCH 1104/1315] Linalg: matprod_dest for Diagonal and adjvec
 (#53611)

---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl |  2 ++
 stdlib/LinearAlgebra/test/diagonal.jl     | 11 +++++++++++
 2 files changed, 13 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index 9b9aaf0d9581d..a8c6792178aec 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -581,6 +581,8 @@ matprod_dest(A::Diagonal, B::StructuredMatrix, TS) = similar(B, TS)
 matprod_dest(A::Diagonal, B::Diagonal, TS) = similar(B, TS)
 matprod_dest(A::HermOrSym, B::Diagonal, TS) = similar(A, TS, size(A))
 matprod_dest(A::Diagonal, B::HermOrSym, TS) = similar(B, TS, size(B))
+# Special handling for adj/trans vec
+matprod_dest(A::Diagonal, B::AdjOrTransAbsVec, TS) = similar(B, TS)
 
 # TODO: remove once not used anymore in SparseArrays.jl
 # some trait like this would be cool
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 18abc6940eded..3087e87f63415 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -1277,4 +1277,15 @@ end
     @test c == Diagonal([2,2,2,2])
 end
 
+@testset "mul/div with an adjoint vector" begin
+    A = [1.0;;]
+    x = [1.0]
+    yadj = Diagonal(A) \ x'
+    @test typeof(yadj) == typeof(x')
+    @test yadj == x'
+    yadj = Diagonal(A) * x'
+    @test typeof(yadj) == typeof(x')
+    @test yadj == x'
+end
+
 end # module TestDiagonal

From 8413b97c8063662665b8e3588b8a7ea85f7f4c34 Mon Sep 17 00:00:00 2001
From: Kenta Murata <3959+mrkn@users.noreply.github.com>
Date: Tue, 12 Mar 2024 00:35:31 +0900
Subject: [PATCH 1105/1315] Add waitany and waitall functions to wait multiple
 tasks at once (#53341)

This adds two functions: `waitany` and `waitall`, as discussed in the
issue #53226. These functions wait for multiple tasks at once. The
`waitany` function blocks until one task finishes. The `waitall`
function blocks until all tasks finish.

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 NEWS.md                  |   1 +
 base/exports.jl          |   2 +
 base/task.jl             | 142 +++++++++++++++++++++++++++++++++++++++
 doc/src/base/parallel.md |   2 +
 test/threads_exec.jl     | 123 +++++++++++++++++++++++++++++++++
 5 files changed, 270 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index 5684d00875942..d3f29ef30987d 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -37,6 +37,7 @@ New library functions
 
 * `logrange(start, stop; length)` makes a range of constant ratio, instead of constant step ([#39071])
 * The new `isfull(c::Channel)` function can be used to check if `put!(c, some_value)` will block. ([#53159])
+* `waitany(tasks; throw=false)` and `waitall(tasks; failfast=false, throw=false)` which wait multiple tasks at once ([#53341]).
 
 New library features
 --------------------
diff --git a/base/exports.jl b/base/exports.jl
index 2e0cd9b46e846..368f336188486 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -706,6 +706,8 @@ export
     yield,
     yieldto,
     wait,
+    waitany,
+    waitall,
     timedwait,
     asyncmap,
     asyncmap!,
diff --git a/base/task.jl b/base/task.jl
index ba96d7bca5095..309ca43d632b1 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -365,6 +365,148 @@ function wait(t::Task)
     nothing
 end
 
+# Wait multiple tasks
+
+"""
+    waitany(tasks; throw=true) -> (done_tasks, remaining_tasks)
+
+Wait until at least one of the given tasks have been completed.
+
+If `throw` is `true`, throw `CompositeException` when one of the
+completed tasks completes with an exception.
+
+The return value consists of two task vectors. The first one consists of
+completed tasks, and the other consists of uncompleted tasks.
+
+!!! warning
+    This may scale poorly compared to writing code that uses multiple individual tasks that
+    each runs serially, since this needs to scan the list of `tasks` each time and
+    synchronize with each one every time this is called. Or consider using
+    [`waitall(tasks; failfast=true)`](@ref waitall) instead.
+"""
+waitany(tasks; throw=true) = _wait_multiple(tasks, throw)
+
+"""
+    waitall(tasks; failfast=true, throw=true) -> (done_tasks, remaining_tasks)
+
+Wait until all the given tasks have been completed.
+
+If `failfast` is `true`, the function will return when at least one of the
+given tasks is finished by exception. If `throw` is `true`, throw
+`CompositeException` when one of the completed tasks has failed.
+
+`failfast` and `throw` keyword arguments work independently; when only
+`throw=true` is specified, this function waits for all the tasks to complete.
+
+The return value consists of two task vectors. The first one consists of
+completed tasks, and the other consists of uncompleted tasks.
+"""
+waitall(tasks; failfast=true, throw=true) = _wait_multiple(tasks, throw, true, failfast)
+
+function _wait_multiple(waiting_tasks, throwexc=false, all=false, failfast=false)
+    tasks = Task[]
+
+    for t in waiting_tasks
+        t isa Task || error("Expected an iterator of `Task` object")
+        push!(tasks, t)
+    end
+
+    if (all && !failfast) || length(tasks) <= 1
+        exception = false
+        # Force everything to finish synchronously for the case of waitall
+        # with failfast=false
+        for t in tasks
+            _wait(t)
+            exception |= istaskfailed(t)
+        end
+        if exception && throwexc
+            exceptions = [TaskFailedException(t) for t in tasks if istaskfailed(t)]
+            throw(CompositeException(exceptions))
+        else
+            return tasks, Task[]
+        end
+    end
+
+    exception = false
+    nremaining::Int = length(tasks)
+    done_mask = falses(nremaining)
+    for (i, t) in enumerate(tasks)
+        if istaskdone(t)
+            done_mask[i] = true
+            exception |= istaskfailed(t)
+            nremaining -= 1
+        else
+            done_mask[i] = false
+        end
+    end
+
+    if nremaining == 0
+        return tasks, Task[]
+    elseif any(done_mask) && (!all || (failfast && exception))
+        if throwexc && (!all || failfast) && exception
+            exceptions = [TaskFailedException(t) for t in tasks[done_mask] if istaskfailed(t)]
+            throw(CompositeException(exceptions))
+        else
+            return tasks[done_mask], tasks[.~done_mask]
+        end
+    end
+
+    chan = Channel{Int}(Inf)
+    sentinel = current_task()
+    waiter_tasks = fill(sentinel, length(tasks))
+
+    for (i, done) in enumerate(done_mask)
+        done && continue
+        t = tasks[i]
+        if istaskdone(t)
+            done_mask[i] = true
+            exception |= istaskfailed(t)
+            nremaining -= 1
+            exception && failfast && break
+        else
+            waiter = @task put!(chan, i)
+            waiter.sticky = false
+            _wait2(t, waiter)
+            waiter_tasks[i] = waiter
+        end
+    end
+
+    while nremaining > 0
+        i = take!(chan)
+        t = tasks[i]
+        waiter_tasks[i] = sentinel
+        done_mask[i] = true
+        exception |= istaskfailed(t)
+        nremaining -= 1
+
+        # stop early if requested, unless there is something immediately
+        # ready to consume from the channel (using a race-y check)
+        if (!all || (failfast && exception)) && !isready(chan)
+            break
+        end
+    end
+
+    close(chan)
+
+    if nremaining == 0
+        return tasks, Task[]
+    else
+        remaining_mask = .~done_mask
+        for i in findall(remaining_mask)
+            waiter = waiter_tasks[i]
+            donenotify = tasks[i].donenotify::ThreadSynchronizer
+            @lock donenotify Base.list_deletefirst!(donenotify.waitq, waiter)
+        end
+        done_tasks = tasks[done_mask]
+        if throwexc && exception
+            exceptions = [TaskFailedException(t) for t in done_tasks if istaskfailed(t)]
+            throw(CompositeException(exceptions))
+        else
+            return done_tasks, tasks[remaining_mask]
+        end
+    end
+end
+
 """
     fetch(x::Any)
 
diff --git a/doc/src/base/parallel.md b/doc/src/base/parallel.md
index 7605d4e6c9e7e..c0f427cc00bb2 100644
--- a/doc/src/base/parallel.md
+++ b/doc/src/base/parallel.md
@@ -30,6 +30,8 @@ Base.schedule
 Base.errormonitor
 Base.@sync
 Base.wait
+Base.waitany
+Base.waitall
 Base.fetch(t::Task)
 Base.fetch(x::Any)
 Base.timedwait
diff --git a/test/threads_exec.jl b/test/threads_exec.jl
index e18e4ad8809fb..7f4775cae0055 100644
--- a/test/threads_exec.jl
+++ b/test/threads_exec.jl
@@ -1186,4 +1186,127 @@ end
 @testset "threadcall + threads" begin
     threadcall_threads() #Shouldn't crash!
 end
+
+@testset "Wait multiple tasks" begin
+    convert_tasks(t, x) = x
+    convert_tasks(::Set{Task}, x::Vector{Task}) = Set{Task}(x)
+    convert_tasks(::Tuple{Task}, x::Vector{Task}) = tuple(x...)
+
+    function create_tasks()
+        tasks = Task[]
+        event = Threads.Event()
+        push!(tasks,
+              Threads.@spawn begin
+                  sleep(0.01)
+              end)
+        push!(tasks,
+              Threads.@spawn begin
+                  sleep(0.02)
+              end)
+        push!(tasks,
+              Threads.@spawn begin
+                  wait(event)
+              end)
+        return tasks, event
+    end
+
+    function teardown(tasks, event)
+        notify(event)
+        waitall(resize!(tasks, 3), throw=true)
+    end
+
+    for tasks_type in (Vector{Task}, Set{Task}, Tuple{Task})
+        @testset "waitany" begin
+            @testset "throw=false" begin
+                tasks, event = create_tasks()
+                wait(tasks[1])
+                wait(tasks[2])
+                done,  pending = waitany(convert_tasks(tasks_type, tasks); throw=false)
+                @test length(done) == 2
+                @test tasks[1] ∈ done
+                @test tasks[2] ∈ done
+                @test length(pending) == 1
+                @test tasks[3] ∈ pending
+                teardown(tasks, event)
+            end
+
+            @testset "throw=true" begin
+                tasks, event = create_tasks()
+                push!(tasks, Threads.@spawn error("Error"))
+
+                @test_throws CompositeException begin
+                    waitany(convert_tasks(tasks_type, tasks); throw=true)
+                end
+
+                teardown(tasks, event)
+            end
+        end
+
+        @testset "waitall" begin
+            @testset "All tasks succeed" begin
+                tasks, event = create_tasks()
+
+                wait(tasks[1])
+                wait(tasks[2])
+                waiter = Threads.@spawn waitall(convert_tasks(tasks_type, tasks))
+                @test !istaskdone(waiter)
+
+                notify(event)
+                done, pending = fetch(waiter)
+                @test length(done) == 3
+                @test tasks[1] ∈ done
+                @test tasks[2] ∈ done
+                @test tasks[3] ∈ done
+                @test length(pending) == 0
+            end
+
+            @testset "failfast=true, throw=false" begin
+                tasks, event = create_tasks()
+                push!(tasks, Threads.@spawn error("Error"))
+
+                wait(tasks[1])
+                wait(tasks[2])
+                waiter = Threads.@spawn waitall(convert_tasks(tasks_type, tasks); failfast=true, throw=false)
+
+                done, pending = fetch(waiter)
+                @test length(done) == 3
+                @test tasks[1] ∈ done
+                @test tasks[2] ∈ done
+                @test tasks[4] ∈ done
+                @test length(pending) == 1
+                @test tasks[3] ∈ pending
+
+                teardown(tasks, event)
+            end
+
+            @testset "failfast=false, throw=true" begin
+                tasks, event = create_tasks()
+                push!(tasks, Threads.@spawn error("Error"))
+
+                notify(event)
+
+                @test_throws CompositeException begin
+                    waitall(convert_tasks(tasks_type, tasks); failfast=false, throw=true)
+                end
+
+                @test all(istaskdone.(tasks))
+
+                teardown(tasks, event)
+            end
+
+            @testset "failfast=true, throw=true" begin
+                tasks, event = create_tasks()
+                push!(tasks, Threads.@spawn error("Error"))
+
+                @test_throws CompositeException begin
+                    waitall(convert_tasks(tasks_type, tasks); failfast=true, throw=true)
+                end
+
+                @test !istaskdone(tasks[3])
+
+                teardown(tasks, event)
+            end
+        end
+    end
+end
 end # main testset

From 6f143eaf241f2f514bce550bf40bba0ed60711f9 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 11 Mar 2024 12:54:11 -0400
Subject: [PATCH 1106/1315] invert linetable representation (#52415)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previously, our linetables (similar to LLVM) represented line
information as a linked list from callee via inlined_at up to the
original information. This requires many copies of this information to
be created. Instead we can take advantage of the necessary existence of
the line table from the child to flip this chain of information and
instead make each statement be a table describing (for each IR
instruction):
`(current line number, (index into edges, index into edges statements))`
plus a table of all edges, plus a table with the original line numbers
from the parser, plus the file name. This is all packed into the struct

    struct DebugInfo
        def::Union{Method,MethodInstance,Symbol}
        linetable::Union{Nothing,DebugInfo}
        edges::SimpleVector{DebugInfo}
        codelocs::String
    end

Which is described in doc/src/devdocs/ast.md for what each field means
and look at stacktraces.jl or compiler/ssair/show.jl to look at how to
decode and interpret this information.

For the sysimage, this saves several megabytes (about 113 MB -> 110 MB)
and about 5% of the stdlib pkgimages (294 MB -> 279 MB).

It also now happens to have the full type information for the inlined
functions. Now if you create an `IRShow.DILineInfoPrinter` with
`showtypes=true`, it can print that information when printing IR.

```
julia> @eval Base.IRShow DILineInfoPrinter(debuginfo, def) = DILineInfoPrinter(debuginfo, def, true)
DILineInfoPrinter (generic function with 2 methods)

julia> (@code_typed 1 + 1.0)[1]
CodeInfo(
    @ promotion.jl:425 within `+`
   ┌ invoke MethodInstance for promote(::Int64, ::Float64)
   │ @ promotion.jl:396 within `promote`
   │┌ invoke MethodInstance for Base._promote(::Int64, ::Float64)
   ││ @ promotion.jl:373 within `_promote`
   ││┌ invoke MethodInstance for convert(::Type{Float64}, ::Int64)
   │││ @ number.jl:7 within `convert`
   │││┌ invoke MethodInstance for Float64(::Int64)
   ││││ @ float.jl:221 within `Float64`
1 ─││││ %1 = Base.sitofp(Float64, x)::Float64
│  └└└└
│  ┌ invoke MethodInstance for +(::Float64, ::Float64)
│  │ @ float.jl:460 within `+`
│  │ %2 = Base.add_float(%1, y)::Float64
│  └
└──      return %2
)
```
---
 base/boot.jl                              |  45 ++-
 base/compiler/inferencestate.jl           |  30 +-
 base/compiler/optimize.jl                 |  92 ++++--
 base/compiler/ssair/inlining.jl           | 124 +++-----
 base/compiler/ssair/ir.jl                 | 119 ++++++--
 base/compiler/ssair/irinterp.jl           |   1 +
 base/compiler/ssair/legacy.jl             |  17 +-
 base/compiler/ssair/passes.jl             |  12 +-
 base/compiler/ssair/show.jl               | 259 +++++++++--------
 base/compiler/ssair/slot2ssa.jl           |  39 +--
 base/compiler/ssair/verify.jl             |  30 +-
 base/compiler/typeinfer.jl                |  14 +-
 base/expr.jl                              |  13 +-
 base/opaque_closure.jl                    |   2 +
 base/show.jl                              |  37 ++-
 base/stacktraces.jl                       |  42 ++-
 doc/src/base/reflection.md                |   1 -
 doc/src/devdocs/ast.md                    |  77 +++++
 src/ast.c                                 |  16 +-
 src/builtins.c                            |   3 +-
 src/clangsa/GCChecker.cpp                 |   1 +
 src/codegen.cpp                           | 307 +++++++++++---------
 src/gf.c                                  |  66 +++--
 src/ircode.c                              | 338 ++++++++++++++++++----
 src/jitlayers.cpp                         |   3 +
 src/jl_exported_data.inc                  |   1 +
 src/jltypes.c                             |  69 +++--
 src/julia-syntax.scm                      |  17 +-
 src/julia.h                               |  26 +-
 src/julia_internal.h                      |  12 +-
 src/method.c                              | 195 +++++++++----
 src/opaque_closure.c                      |   4 +-
 src/rtutils.c                             |  42 +--
 src/serialize.h                           |  31 +-
 src/stackwalk.c                           |  97 +++++--
 src/staticdata.c                          |  16 +-
 stdlib/InteractiveUtils/test/runtests.jl  |   2 +
 stdlib/REPL/test/precompilation.jl        |   2 +-
 stdlib/Serialization/src/Serialization.jl |  33 ++-
 test/cmdlineargs.jl                       |  17 +-
 test/compiler/AbstractInterpreter.jl      |   1 -
 test/compiler/contextual.jl               |   8 +-
 test/compiler/interpreter_exec.jl         |  13 +-
 test/compiler/irpasses.jl                 |   2 +-
 test/compiler/irutils.jl                  |   2 +-
 test/compiler/ssair.jl                    |   6 +-
 test/core.jl                              |   6 +-
 test/opaque_closure.jl                    |   4 +
 test/precompile.jl                        |   3 +-
 test/show.jl                              |   2 +-
 test/staged.jl                            |   8 +-
 test/syntax.jl                            |  28 +-
 test/testhelpers/coverage_file.info       |   7 +-
 test/testhelpers/coverage_file.info.bad   |  20 --
 test/testhelpers/coverage_file.info.bad2  |  20 --
 test/testhelpers/coverage_file.jl         |   2 +-
 test/worlds.jl                            |   3 +-
 57 files changed, 1488 insertions(+), 899 deletions(-)
 delete mode 100644 test/testhelpers/coverage_file.info.bad
 delete mode 100644 test/testhelpers/coverage_file.info.bad2

diff --git a/base/boot.jl b/base/boot.jl
index b4c5cda67bd57..fc00f571171c9 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -64,7 +64,7 @@
 #   }
 #end
 
-# struct GenericMemoryRef{kind::Symbol, T, AS::AddrSpace}
+#struct GenericMemoryRef{kind::Symbol, T, AS::AddrSpace}
 #    mem::GenericMemory{kind, T, AS}
 #    data::Ptr{Cvoid} # make this GenericPtr{addrspace, Cvoid}
 #end
@@ -125,12 +125,13 @@
 #    file::Union{Symbol,Nothing}
 #end
 
-#struct LineInfoNode
-#    module::Module
-#    method::Any (Union{Symbol, Method, MethodInstance})
-#    file::Symbol
-#    line::Int32
-#    inlined_at::Int32
+#struct LegacyLineInfoNode end # only used internally during lowering
+
+#struct DebugInfo
+#    def::Any # (Union{Symbol, Method, MethodInstance})
+#    linetable::Any # (Union{Nothing,DebugInfo})
+#    edges::SimpleVector # Vector{DebugInfo}
+#    codelocs::String # compressed Vector{UInt8}
 #end
 
 #struct GotoNode
@@ -296,6 +297,9 @@ TypeVar(@nospecialize(n), @nospecialize(ub)) = _typevar(n::Symbol, Union{}, ub)
 TypeVar(@nospecialize(n), @nospecialize(lb), @nospecialize(ub)) = _typevar(n::Symbol, lb, ub)
 UnionAll(@nospecialize(v), @nospecialize(t)) = ccall(:jl_type_unionall, Any, (Any, Any), v::TypeVar, t)
 
+const Memory{T} = GenericMemory{:not_atomic, T, CPU}
+const MemoryRef{T} = GenericMemoryRef{:not_atomic, T, CPU}
+
 # simple convert for use by constructors of types in Core
 # note that there is no actual conversion defined here,
 # so the methods and ccall's in Core aren't permitted to use convert
@@ -466,8 +470,10 @@ eval(Core, quote
         isa(f, String) && (f = Symbol(f))
         return $(Expr(:new, :LineNumberNode, :l, :f))
     end
-    LineInfoNode(mod::Module, @nospecialize(method), file::Symbol, line::Int32, inlined_at::Int32) =
-        $(Expr(:new, :LineInfoNode, :mod, :method, :file, :line, :inlined_at))
+    DebugInfo(def::Union{Method,MethodInstance,Symbol}, linetable::Union{Nothing,DebugInfo}, edges::SimpleVector, codelocs::String) =
+        $(Expr(:new, :DebugInfo, :def, :linetable, :edges, :codelocs))
+    DebugInfo(def::Union{Method,MethodInstance,Symbol}) =
+        $(Expr(:new, :DebugInfo, :def, nothing, Core.svec(), ""))
     SlotNumber(n::Int) = $(Expr(:new, :SlotNumber, :n))
     PhiNode(edges::Array{Int32, 1}, values::Array{Any, 1}) = $(Expr(:new, :PhiNode, :edges, :values))
     PiNode(@nospecialize(val), @nospecialize(typ)) = $(Expr(:new, :PiNode, :val, :typ))
@@ -482,16 +488,25 @@ eval(Core, quote
     MethodMatch(@nospecialize(spec_types), sparams::SimpleVector, method::Method, fully_covers::Bool) = $(Expr(:new, :MethodMatch, :spec_types, :sparams, :method, :fully_covers))
 end)
 
+struct LineInfoNode # legacy support for aiding Serializer.deserialize of old IR
+    mod::Module
+    method
+    file::Symbol
+    line::Int32
+    inlined_at::Int32
+    LineInfoNode(mod::Module, @nospecialize(method), file::Symbol, line::Int32, inlined_at::Int32) = new(mod, method, file, line, inlined_at)
+end
+
+
 function CodeInstance(
     mi::MethodInstance, owner, @nospecialize(rettype), @nospecialize(exctype), @nospecialize(inferred_const),
     @nospecialize(inferred), const_flags::Int32, min_world::UInt, max_world::UInt,
     ipo_effects::UInt32, effects::UInt32, @nospecialize(analysis_results),
-    relocatability::UInt8)
+    relocatability::UInt8, edges::DebugInfo)
     return ccall(:jl_new_codeinst, Ref{CodeInstance},
-        (Any, Any, Any, Any, Any, Any, Int32, UInt, UInt, UInt32, UInt32, Any, UInt8),
+        (Any, Any, Any, Any, Any, Any, Int32, UInt, UInt, UInt32, UInt32, Any, UInt8, Any),
         mi, owner, rettype, exctype, inferred_const, inferred, const_flags, min_world, max_world,
-        ipo_effects, effects, analysis_results,
-        relocatability)
+        ipo_effects, effects, analysis_results, relocatability, edges)
 end
 GlobalRef(m::Module, s::Symbol) = ccall(:jl_module_globalref, Ref{GlobalRef}, (Any, Any), m, s)
 Module(name::Symbol=:anonymous, std_imports::Bool=true, default_names::Bool=true) = ccall(:jl_f_new_module, Ref{Module}, (Any, Bool, Bool), name, std_imports, default_names)
@@ -629,12 +644,12 @@ module IR
 
 export CodeInfo, MethodInstance, CodeInstance, GotoNode, GotoIfNot, ReturnNode,
     NewvarNode, SSAValue, SlotNumber, Argument,
-    PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode,
+    PiNode, PhiNode, PhiCNode, UpsilonNode, DebugInfo,
     Const, PartialStruct, InterConditional, EnterNode
 
 using Core: CodeInfo, MethodInstance, CodeInstance, GotoNode, GotoIfNot, ReturnNode,
     NewvarNode, SSAValue, SlotNumber, Argument,
-    PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode,
+    PiNode, PhiNode, PhiCNode, UpsilonNode, DebugInfo,
     Const, PartialStruct, InterConditional, EnterNode
 
 end # module IR
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index d4c4d94b6db31..31bc8d4e20105 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -323,7 +323,7 @@ mutable struct InferenceState
         exc_bestguess = Bottom
         ipo_effects = EFFECTS_TOTAL
 
-        insert_coverage = should_insert_coverage(mod, src)
+        insert_coverage = should_insert_coverage(mod, src.debuginfo)
         if insert_coverage
             ipo_effects = Effects(ipo_effects; effect_free = ALWAYS_FALSE)
         end
@@ -474,25 +474,21 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
 end
 
 # check if coverage mode is enabled
-function should_insert_coverage(mod::Module, src::CodeInfo)
+function should_insert_coverage(mod::Module, debuginfo::DebugInfo)
     coverage_enabled(mod) && return true
     JLOptions().code_coverage == 3 || return false
     # path-specific coverage mode: if any line falls in a tracked file enable coverage for all
-    linetable = src.linetable
-    if isa(linetable, Vector{Any})
-        for line in linetable
-            line = line::LineInfoNode
-            if is_file_tracked(line.file)
-                return true
-            end
-        end
-    elseif isa(linetable, Vector{LineInfoNode})
-        for line in linetable
-            if is_file_tracked(line.file)
-                return true
-            end
-        end
-    end
+    return _should_insert_coverage(debuginfo)
+end
+
+_should_insert_coverage(mod::Symbol) = is_file_tracked(mod)
+_should_insert_coverage(mod::Method) = _should_insert_coverage(mod.file)
+_should_insert_coverage(mod::MethodInstance) = _should_insert_coverage(mod.def)
+_should_insert_coverage(mod::Module) = false
+function _should_insert_coverage(info::DebugInfo)
+    linetable = info.linetable
+    linetable === nothing || (_should_insert_coverage(linetable) && return true)
+    _should_insert_coverage(info.def) && return true
     return false
 end
 
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index c30f15864892d..81b025e588f7f 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -990,22 +990,79 @@ function run_passes_ipo_safe(
     if is_asserts()
         @timeit "verify 3" begin
             verify_ir(ir, true, false, optimizer_lattice(sv.inlining.interp))
-            verify_linetable(ir.linetable)
+            verify_linetable(ir.debuginfo, length(ir.stmts))
         end
     end
     @label __done__  # used by @pass
     return ir
 end
 
-function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
-    linetable = ci.linetable
-    if !isa(linetable, Vector{LineInfoNode})
-        linetable = collect(LineInfoNode, linetable::Vector{Any})::Vector{LineInfoNode}
+function strip_trailing_junk!(code::Vector{Any}, ssavaluetypes::Vector{Any}, ssaflags::Vector, debuginfo::DebugInfoStream, cfg::CFG, info::Vector{CallInfo})
+    # Remove `nothing`s at the end, we don't handle them well
+    # (we expect the last instruction to be a terminator)
+    codelocs = debuginfo.codelocs
+    for i = length(code):-1:1
+        if code[i] !== nothing
+            resize!(code, i)
+            resize!(ssavaluetypes, i)
+            resize!(codelocs, 3i)
+            resize!(info, i)
+            resize!(ssaflags, i)
+            break
+        end
+    end
+    # If the last instruction is not a terminator, add one. This can
+    # happen for implicit return on dead branches.
+    term = code[end]
+    if !isa(term, GotoIfNot) && !isa(term, GotoNode) && !isa(term, ReturnNode)
+        push!(code, ReturnNode())
+        push!(ssavaluetypes, Union{})
+        push!(codelocs, 0, 0, 0)
+        push!(info, NoCallInfo())
+        push!(ssaflags, IR_FLAG_NOTHROW)
+
+        # Update CFG to include appended terminator
+        old_range = cfg.blocks[end].stmts
+        new_range = StmtRange(first(old_range), last(old_range) + 1)
+        cfg.blocks[end] = BasicBlock(cfg.blocks[end], new_range)
+        (length(cfg.index) == length(cfg.blocks)) && (cfg.index[end] += 1)
+    end
+    nothing
+end
+
+function changed_lineinfo(di::DebugInfo, codeloc::Int, prevloc::Int)
+    while true
+        next = getdebugidx(di, codeloc)
+        next[1] < 0 && return false # invalid info
+        next[1] == 0 && next[2] == 0 && return false # no new info
+        prevloc <= 0 && return true # no old info
+        prev = getdebugidx(di, prevloc)
+        next === prev && return false # exactly identical
+        prev[1] < 0 && return true # previous invalid info, now valid
+        edge = next[2]
+        edge === prev[2] || return true # change to this edge
+        linetable = di.linetable
+        # check for change to line number here
+        if linetable === nothing || next[1] == 0
+            next[1] == prev[1] || return true
+        else
+            changed_lineinfo(linetable, next[1], prev[1]) && return true
+        end
+        # check for change to edge here
+        edge == 0 && return false # no edge here
+        di = di.edges[Int(edge)]::DebugInfo
+        codeloc = Int(next[3])
+        prevloc = Int(prev[3])
     end
+end
 
+function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
     # Update control-flow to reflect any unreachable branches.
     ssavaluetypes = ci.ssavaluetypes::Vector{Any}
-    code = copy_exprargs(ci.code)
+    ci.code = code = copy_exprargs(ci.code)
+    di = DebugInfoStream(sv.linfo, ci.debuginfo, length(code))
+    codelocs = di.codelocs
+    ssaflags = ci.ssaflags
     for i = 1:length(code)
         expr = code[i]
         if !(i in sv.unreachable)
@@ -1021,11 +1078,11 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                     ((block + 1) != destblock) && cfg_delete_edge!(sv.cfg, block, destblock)
                     expr = Expr(:call, Core.typeassert, expr.cond, Bool)
                 elseif i + 1 in sv.unreachable
-                    @assert has_flag(ci.ssaflags[i], IR_FLAG_NOTHROW)
+                    @assert has_flag(ssaflags[i], IR_FLAG_NOTHROW)
                     cfg_delete_edge!(sv.cfg, block, block + 1)
                     expr = GotoNode(expr.dest)
                 elseif expr.dest in sv.unreachable
-                    @assert has_flag(ci.ssaflags[i], IR_FLAG_NOTHROW)
+                    @assert has_flag(ssaflags[i], IR_FLAG_NOTHROW)
                     cfg_delete_edge!(sv.cfg, block, block_for_inst(sv.cfg, expr.dest))
                     expr = nothing
                 end
@@ -1052,20 +1109,17 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
     # Go through and add an unreachable node after every
     # Union{} call. Then reindex labels.
     stmtinfo = sv.stmt_info
-    codelocs = ci.codelocs
-    ssaflags = ci.ssaflags
     meta = Expr[]
     idx = 1
     oldidx = 1
     nstmts = length(code)
     ssachangemap = labelchangemap = blockchangemap = nothing
-    prevloc = zero(eltype(ci.codelocs))
+    prevloc = 0
     while idx <= length(code)
-        codeloc = codelocs[idx]
-        if sv.insert_coverage && codeloc != prevloc && codeloc != 0
+        if sv.insert_coverage && changed_lineinfo(ci.debuginfo, oldidx, prevloc)
             # insert a side-effect instruction before the current instruction in the same basic block
             insert!(code, idx, Expr(:code_coverage_effect))
-            insert!(codelocs, idx, codeloc)
+            splice!(codelocs, 3idx-2:3idx-3, (codelocs[3idx-2], codelocs[3idx-1], codelocs[3idx-0]))
             insert!(ssavaluetypes, idx, Nothing)
             insert!(stmtinfo, idx, NoCallInfo())
             insert!(ssaflags, idx, IR_FLAG_NULL)
@@ -1084,7 +1138,7 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
             end
             blockchangemap[block_for_inst(sv.cfg, oldidx)] += 1
             idx += 1
-            prevloc = codeloc
+            prevloc = oldidx
         end
         if ssavaluetypes[idx] === Union{} && !(oldidx in sv.unreachable) && !isa(code[idx], PhiNode)
             # We should have converted any must-throw terminators to an equivalent w/o control-flow edges
@@ -1106,7 +1160,7 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                 # terminator with an explicit `unreachable` marker.
                 if block_end > idx
                     code[block_end] = ReturnNode()
-                    codelocs[block_end] = codelocs[idx]
+                    codelocs[3block_end-2], codelocs[3block_end-1], codelocs[3block_end-0] = (codelocs[3idx-2], codelocs[3idx-1], codelocs[3idx-0])
                     ssavaluetypes[block_end] = Union{}
                     stmtinfo[block_end] = NoCallInfo()
                     ssaflags[block_end] = IR_FLAG_NOTHROW
@@ -1121,7 +1175,7 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                     idx += block_end - idx
                 else
                     insert!(code, idx + 1, ReturnNode())
-                    insert!(codelocs, idx + 1, codelocs[idx])
+                    splice!(codelocs, 3idx-2:3idx-3, (codelocs[3idx-2], codelocs[3idx-1], codelocs[3idx-0]))
                     insert!(ssavaluetypes, idx + 1, Union{})
                     insert!(stmtinfo, idx + 1, NoCallInfo())
                     insert!(ssaflags, idx + 1, IR_FLAG_NOTHROW)
@@ -1158,14 +1212,14 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
     for i = 1:length(code)
         code[i] = process_meta!(meta, code[i])
     end
-    strip_trailing_junk!(ci, sv.cfg, code, stmtinfo)
+    strip_trailing_junk!(code, ssavaluetypes, ssaflags, di, sv.cfg, stmtinfo)
     types = Any[]
     stmts = InstructionStream(code, types, stmtinfo, codelocs, ssaflags)
     # NOTE this `argtypes` contains types of slots yet: it will be modified to contain the
     # types of call arguments only once `slot2reg` converts this `IRCode` to the SSA form
     # and eliminates slots (see below)
     argtypes = sv.slottypes
-    return IRCode(stmts, sv.cfg, linetable, argtypes, meta, sv.sptypes)
+    return IRCode(stmts, sv.cfg, di, argtypes, meta, sv.sptypes)
 end
 
 function process_meta!(meta::Vector{Expr}, @nospecialize stmt)
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 3e57bc8503e06..c49bfe2239972 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -12,14 +12,16 @@ struct InliningTodo
     mi::MethodInstance
     # The IR of the inlinee
     ir::IRCode
+    # The DebugInfo table for the inlinee
+    di::DebugInfo
     # If the function being inlined is a single basic block we can use a
     # simpler inlining algorithm. This flag determines whether that's allowed
     linear_inline_eligible::Bool
     # Effects of the call statement
     effects::Effects
 end
-function InliningTodo(mi::MethodInstance, ir::IRCode, effects::Effects)
-    return InliningTodo(mi, ir, linear_inline_eligible(ir), effects)
+function InliningTodo(mi::MethodInstance, (ir, di)::Tuple{IRCode, DebugInfo}, effects::Effects)
+    return InliningTodo(mi, ir, di, linear_inline_eligible(ir), effects)
 end
 
 struct ConstantCase
@@ -298,69 +300,30 @@ function finish_cfg_inline!(state::CFGInliningState)
     end
 end
 
-# duplicated from IRShow
-function normalize_method_name(m)
-    if m isa Method
-        return m.name
-    elseif m isa MethodInstance
-        return (m.def::Method).name
-    elseif m isa Symbol
-        return m
-    else
-        return Symbol("")
-    end
-end
-@noinline method_name(m::LineInfoNode) = normalize_method_name(m.method)
-
-inline_node_is_duplicate(topline::LineInfoNode, line::LineInfoNode) =
-    topline.module === line.module &&
-    method_name(topline) === method_name(line) &&
-    topline.file === line.file &&
-    topline.line === line.line
-
-function ir_inline_linetable!(linetable::Vector{LineInfoNode}, inlinee_ir::IRCode,
-                              inlinee::MethodInstance, inlined_at::Int32)
-    inlinee_def = inlinee.def::Method
-    coverage = coverage_enabled(inlinee_def.module)
-    linetable_offset::Int32 = length(linetable)
-    # Append the linetable of the inlined function to our line table
-    topline::Int32 = linetable_offset + Int32(1)
-    coverage_by_path = JLOptions().code_coverage == 3
-    push!(linetable, LineInfoNode(inlinee_def.module, inlinee_def.name, inlinee_def.file, inlinee_def.line, inlined_at))
-    oldlinetable = inlinee_ir.linetable
-    extra_coverage_line = zero(Int32)
-    for oldline in eachindex(oldlinetable)
-        entry = oldlinetable[oldline]
-        if !coverage && coverage_by_path && is_file_tracked(entry.file)
-            # include topline coverage entry if in path-specific coverage mode, and any file falls under path
-            coverage = true
-        end
-        newentry = LineInfoNode(entry.module, entry.method, entry.file, entry.line,
-            (entry.inlined_at > 0 ? entry.inlined_at + linetable_offset + (oldline == 1) : inlined_at))
-        if oldline == 1
-            # check for a duplicate on the first iteration (likely true)
-            if inline_node_is_duplicate(linetable[topline], newentry)
-                continue
-            else
-                linetable_offset += 1
-            end
+function ir_inline_linetable!(debuginfo::DebugInfoStream, inlinee_debuginfo::DebugInfo, inlinee::MethodInstance)
+    # Append the linetable of the inlined function to our edges table
+    linetable_offset = 1
+    while true
+        if linetable_offset > length(debuginfo.edges)
+            push!(debuginfo.edges, inlinee_debuginfo)
+            break
+        elseif debuginfo.edges[linetable_offset] === inlinee_debuginfo
+            break
         end
-        push!(linetable, newentry)
-    end
-    if coverage && inlinee_ir.stmts[1][:line] + linetable_offset != topline
-        extra_coverage_line = topline
+        linetable_offset += 1
     end
-    return linetable_offset, extra_coverage_line
+    return Int32(linetable_offset)
 end
 
 function ir_prepare_inlining!(insert_node!::Inserter, inline_target::Union{IRCode, IncrementalCompact},
-                              ir::IRCode, mi::MethodInstance, inlined_at::Int32, argexprs::Vector{Any})
+                              ir::IRCode, di::DebugInfo, mi::MethodInstance, inlined_at::Int32, argexprs::Vector{Any})
     def = mi.def::Method
-    linetable = inline_target isa IRCode ? inline_target.linetable : inline_target.ir.linetable
-    topline::Int32 = length(linetable) + Int32(1)
-    linetable_offset, extra_coverage_line = ir_inline_linetable!(linetable, ir, mi, inlined_at)
-    if extra_coverage_line != 0
-        insert_node!(NewInstruction(Expr(:code_coverage_effect), Nothing, extra_coverage_line))
+    debuginfo = inline_target isa IRCode ? inline_target.debuginfo : inline_target.ir.debuginfo
+
+    linetable_offset = ir_inline_linetable!(debuginfo, di, mi)
+    topline = (inlined_at, linetable_offset, Int32(0))
+    if should_insert_coverage(def.module, di)
+        insert_node!(NewInstruction(Expr(:code_coverage_effect), Nothing, topline))
     end
     spvals_ssa = nothing
     if !validate_sparams(mi.sparam_vals)
@@ -380,7 +343,7 @@ function ir_prepare_inlining!(insert_node!::Inserter, inline_target::Union{IRCod
             NewInstruction(Expr(:call, GlobalRef(Core, :getfield), argexprs[1], QuoteNode(:captures)),
             ir.argtypes[1], topline))
     end
-    return SSASubstitute(mi, argexprs, spvals_ssa, linetable_offset)
+    return SSASubstitute(mi, argexprs, spvals_ssa, (inlined_at, linetable_offset))
 end
 
 function adjust_boundscheck!(inline_compact::IncrementalCompact, idx′::Int, stmt::Expr, boundscheck::Symbol)
@@ -396,13 +359,12 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
                          item::InliningTodo, boundscheck::Symbol, todo_bbs::Vector{Tuple{Int, Int}})
     # Ok, do the inlining here
     inlined_at = compact.result[idx][:line]
-
-    ssa_substitute = ir_prepare_inlining!(InsertHere(compact), compact, item.ir, item.mi, inlined_at, argexprs)
-
+    @assert inlined_at[2] == 0 "already inlined this instruction"
+    ssa_substitute = ir_prepare_inlining!(InsertHere(compact), compact, item.ir, item.di, item.mi, inlined_at[1], argexprs)
     boundscheck = has_flag(compact.result[idx], IR_FLAG_INBOUNDS) ? :off : boundscheck
 
     # If the iterator already moved on to the next basic block,
-    # temporarily re-open in again.
+    # temporarily re-open it again.
     local return_value
     # Special case inlining that maintains the current basic block if there's only one BB in the target
     new_new_offset = length(compact.new_new_nodes)
@@ -410,14 +372,16 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
     if item.linear_inline_eligible
         #compact[idx] = nothing
         inline_compact = IncrementalCompact(compact, item.ir, compact.result_idx)
-        for ((_, idx′), stmt′) in inline_compact
+        @assert isempty(inline_compact.perm) && isempty(inline_compact.pending_perm) "linetable not in canonical form (missing compact call)"
+        for ((lineidx, idx′), stmt′) in inline_compact
             # This dance is done to maintain accurate usage counts in the
             # face of rename_arguments! mutating in place - should figure out
             # something better eventually.
             inline_compact[idx′] = nothing
+            # alter the line number information for InsertBefore to point to the current instruction in the new linetable
+            inline_compact[SSAValue(idx′)][:line] = (ssa_substitute.inlined_at[1], ssa_substitute.inlined_at[2], Int32(lineidx))
             insert_node! = InsertBefore(inline_compact, SSAValue(idx′))
-            stmt′ = ssa_substitute!(insert_node!, inline_compact[SSAValue(idx′)], stmt′,
-                                    ssa_substitute)
+            stmt′ = ssa_substitute_op!(insert_node!, inline_compact[SSAValue(idx′)], stmt′, ssa_substitute)
             if isa(stmt′, ReturnNode)
                 val = stmt′.val
                 return_value = SSAValue(idx′)
@@ -444,11 +408,12 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
         pn = PhiNode()
         #compact[idx] = nothing
         inline_compact = IncrementalCompact(compact, item.ir, compact.result_idx)
-        for ((_, idx′), stmt′) in inline_compact
+        @assert isempty(inline_compact.perm) && isempty(inline_compact.pending_perm) "linetable not in canonical form (missing compact call)"
+        for ((lineidx, idx′), stmt′) in inline_compact
             inline_compact[idx′] = nothing
+            inline_compact[SSAValue(idx′)][:line] = (ssa_substitute.inlined_at[1], ssa_substitute.inlined_at[2], Int32(lineidx))
             insert_node! = InsertBefore(inline_compact, SSAValue(idx′))
-            stmt′ = ssa_substitute!(insert_node!, inline_compact[SSAValue(idx′)], stmt′,
-                                    ssa_substitute)
+            stmt′ = ssa_substitute_op!(insert_node!, inline_compact[SSAValue(idx′)], stmt′, ssa_substitute)
             if isa(stmt′, ReturnNode)
                 if isdefined(stmt′, :val)
                     val = stmt′.val
@@ -484,7 +449,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
 end
 
 function fix_va_argexprs!(insert_node!::Inserter, inline_target::Union{IRCode, IncrementalCompact},
-    argexprs::Vector{Any}, nargs_def::Int, line_idx::Int32)
+    argexprs::Vector{Any}, nargs_def::Int, line_idx::NTuple{3,Int32})
     newargexprs = argexprs[1:(nargs_def-1)]
     tuple_call = Expr(:call, TOP_TUPLE)
     tuple_typs = Any[]
@@ -996,19 +961,20 @@ end
 
 function retrieve_ir_for_inlining(cached_result::CodeInstance, src::MaybeCompressed)
     src = _uncompressed_ir(cached_result, src)::CodeInfo
-    return inflate_ir!(src, cached_result.def)
+    return inflate_ir!(src, cached_result.def), src.debuginfo
 end
 function retrieve_ir_for_inlining(mi::MethodInstance, src::CodeInfo, preserve_local_sources::Bool)
     if preserve_local_sources
         src = copy(src)
     end
-    return inflate_ir!(src, mi)
+    return inflate_ir!(src, mi), src.debuginfo
 end
 function retrieve_ir_for_inlining(mi::MethodInstance, ir::IRCode, preserve_local_sources::Bool)
     if preserve_local_sources
         ir = copy(ir)
     end
-    return ir
+    ir.debuginfo.def = mi
+    return ir, DebugInfo(ir.debuginfo, length(ir.stmts))
 end
 
 function handle_single_case!(todo::Vector{Pair{Int,Any}},
@@ -1829,15 +1795,7 @@ struct SSASubstitute
     mi::MethodInstance
     arg_replacements::Vector{Any}
     spvals_ssa::Union{Nothing,SSAValue}
-    linetable_offset::Int32
-end
-
-function ssa_substitute!(insert_node!::Inserter, subst_inst::Instruction, @nospecialize(val),
-                         ssa_substitute::SSASubstitute)
-    if subst_inst[:line] != 0
-        subst_inst[:line] += ssa_substitute.linetable_offset
-    end
-    return ssa_substitute_op!(insert_node!, subst_inst, val, ssa_substitute)
+    inlined_at::NTuple{2,Int32} # TODO: add a map also, so that ssaidx doesn't need to equal inlined_idx?
 end
 
 function insert_spval!(insert_node!::Inserter, spvals_ssa::SSAValue, spidx::Int, do_isdefined::Bool)
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index ca658ad101f7f..c23f89e01f664 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -174,6 +174,51 @@ function first_insert_for_bb(code::Vector{Any}, cfg::CFG, block::Int)
     return lastnonphiidx
 end
 
+# mutable version of the compressed DebugInfo
+mutable struct DebugInfoStream
+    def::Union{MethodInstance,Symbol,Nothing}
+    linetable::Union{Nothing,Core.DebugInfo}
+    edges::Vector{Any} # Vector{Core.DebugInfo}
+    firstline::Int32 # the starting line for this block (specified by having an index of 0)
+    codelocs::Vector{Int32} # for each statement:
+        # index into linetable (if defined), else a line number (in the file represented by def)
+        # then index into edges
+        # then index into edges[linetable]
+    function DebugInfoStream(codelocs::Vector{Int32})
+        return new(nothing, nothing, [], 0, codelocs)
+    end
+    #DebugInfoStream(def::Union{MethodInstance,Nothing}, di::DebugInfo, nstmts::Int) =
+    #    if debuginfo_file1(di.def) === debuginfo_file1(di.def)
+    #        new(def, di.linetable, Core.svec(di.edges...), getdebugidx(di, 0),
+    #            ccall(:jl_uncompress_codelocs, Any, (Any, Int), di.codelocs, nstmts)::Vector{Int32})
+    #    else
+    function DebugInfoStream(def::Union{MethodInstance,Nothing}, di::DebugInfo, nstmts::Int)
+        codelocs = zeros(Int32, nstmts * 3)
+        for i = 1:nstmts
+            codelocs[3i - 2] = i
+        end
+        return new(def, di, Vector{Any}(), 0, codelocs)
+    end
+    global copy(di::DebugInfoStream) = new(di.def, di.linetable, di.edges, di.firstline, di.codelocs)
+end
+
+Core.DebugInfo(di::DebugInfoStream, nstmts::Int) =
+    Core.DebugInfo(something(di.def), di.linetable, Core.svec(di.edges...),
+        ccall(:jl_compress_codelocs, Any, (Int32, Any, Int), di.firstline, di.codelocs, nstmts)::String)
+
+getdebugidx(debuginfo::Core.DebugInfo, pc::Int) = ccall(:jl_uncompress1_codeloc, NTuple{3,Int32}, (Any, Int), debuginfo.codelocs, pc)
+
+function getdebugidx(debuginfo::DebugInfoStream, pc::Int)
+    if 3 <= 3pc <= length(debuginfo.codelocs)
+        return (debuginfo.codelocs[3pc - 2], debuginfo.codelocs[3pc - 1], debuginfo.codelocs[3pc - 0])
+    elseif pc == 0
+        return (Int32(debuginfo.firstline), Int32(0), Int32(0))
+    else
+        return (Int32(-1), Int32(0), Int32(0))
+    end
+end
+
+
 # SSA values that need renaming
 struct OldSSAValue
     id::Int
@@ -203,7 +248,6 @@ end
 
 const AnySSAValue = Union{SSAValue, OldSSAValue, NewSSAValue}
 
-
 # SSA-indexed nodes
 struct InstructionStream
     stmt::Vector{Any}
@@ -211,13 +255,16 @@ struct InstructionStream
     info::Vector{CallInfo}
     line::Vector{Int32}
     flag::Vector{UInt32}
+    function InstructionStream(stmts::Vector{Any}, type::Vector{Any}, info::Vector{CallInfo}, line::Vector{Int32}, flag::Vector{UInt32})
+        return new(stmts, type, info, line, flag)
+    end
 end
 function InstructionStream(len::Int)
     stmts = Vector{Any}(undef, len)
     types = Vector{Any}(undef, len)
     info = Vector{CallInfo}(undef, len)
     fill!(info, NoCallInfo())
-    lines = fill(Int32(0), len)
+    lines = fill(Int32(0), 3len)
     flags = fill(IR_FLAG_NULL, len)
     return InstructionStream(stmts, types, info, lines, flags)
 end
@@ -242,10 +289,10 @@ function resize!(stmts::InstructionStream, len)
     resize!(stmts.stmt, len)
     resize!(stmts.type, len)
     resize!(stmts.info, len)
-    resize!(stmts.line, len)
+    resize!(stmts.line, 3len)
     resize!(stmts.flag, len)
     for i in (old_length + 1):len
-        stmts.line[i] = 0
+        stmts.line[3i-2], stmts.line[3i-1], stmts.line[3i] = NoLineUpdate
         stmts.flag[i] = IR_FLAG_NULL
         stmts.info[i] = NoCallInfo()
     end
@@ -261,11 +308,20 @@ Instruction(is::InstructionStream) = Instruction(is, add_new_idx!(is))
 @inline function getindex(node::Instruction, fld::Symbol)
     (fld === :inst) && (fld = :stmt) # deprecated
     isdefined(node, fld) && return getfield(node, fld)
-    return getfield(getfield(node, :data), fld)[getfield(node, :idx)]
+    fldarray = getfield(getfield(node, :data), fld)
+    fldidx = getfield(node, :idx)
+    (fld === :line) && return (fldarray[3fldidx-2], fldarray[3fldidx-1], fldarray[3fldidx-0])
+    return fldarray[fldidx]
 end
 @inline function setindex!(node::Instruction, @nospecialize(val), fld::Symbol)
     (fld === :inst) && (fld = :stmt) # deprecated
-    getfield(getfield(node, :data), fld)[getfield(node, :idx)] = val
+    fldarray = getfield(getfield(node, :data), fld)
+    fldidx = getfield(node, :idx)
+    if fld === :line
+        (fldarray[3fldidx-2], fldarray[3fldidx-1], fldarray[3fldidx-0]) = val::NTuple{3,Int32}
+    else
+        fldarray[fldidx] = val
+    end
     return node
 end
 
@@ -274,7 +330,7 @@ function setindex!(is::InstructionStream, newval::Instruction, idx::Int)
     is.stmt[idx] = newval[:stmt]
     is.type[idx] = newval[:type]
     is.info[idx] = newval[:info]
-    is.line[idx] = newval[:line]
+    (is.line[3idx-2], is.line[3idx-1], is.line[3idx-0]) = newval[:line]
     is.flag[idx] = newval[:flag]
     return is
 end
@@ -314,14 +370,15 @@ struct NewInstruction
     stmt::Any
     type::Any
     info::CallInfo
-    line::Union{Int32,Nothing} # if nothing, copy the line from previous statement in the insertion location
+    line::Union{NTuple{3,Int32},Nothing} # if nothing, copy the line from previous statement in the insertion location
     flag::Union{UInt32,Nothing} # if nothing, IR flags will be recomputed on insertion
     function NewInstruction(@nospecialize(stmt), @nospecialize(type), @nospecialize(info::CallInfo),
-                            line::Union{Int32,Nothing}, flag::Union{UInt32,Nothing})
+                            line::Union{NTuple{3,Int32},Int32,Nothing}, flag::Union{UInt32,Nothing})
+        line isa Int32 && (line = (line, zero(Int32), zero(Int32)))
         return new(stmt, type, info, line, flag)
     end
 end
-function NewInstruction(@nospecialize(stmt), @nospecialize(type), line::Union{Int32,Nothing}=nothing)
+function NewInstruction(@nospecialize(stmt), @nospecialize(type), line::Union{NTuple{3,Int32},Int32,Nothing}=nothing)
     return NewInstruction(stmt, type, NoCallInfo(), line, nothing)
 end
 @nospecialize
@@ -329,7 +386,7 @@ function NewInstruction(newinst::NewInstruction;
     stmt::Any=newinst.stmt,
     type::Any=newinst.type,
     info::CallInfo=newinst.info,
-    line::Union{Int32,Nothing}=newinst.line,
+    line::Union{NTuple{3,Int32},Int32,Nothing}=newinst.line,
     flag::Union{UInt32,Nothing}=newinst.flag)
     return NewInstruction(stmt, type, info, line, flag)
 end
@@ -337,7 +394,7 @@ function NewInstruction(inst::Instruction;
     stmt::Any=inst[:stmt],
     type::Any=inst[:type],
     info::CallInfo=inst[:info],
-    line::Union{Int32,Nothing}=inst[:line],
+    line::Union{NTuple{3,Int32},Int32,Nothing}=inst[:line],
     flag::Union{UInt32,Nothing}=inst[:flag])
     return NewInstruction(stmt, type, info, line, flag)
 end
@@ -366,19 +423,27 @@ struct IRCode
     stmts::InstructionStream
     argtypes::Vector{Any}
     sptypes::Vector{VarState}
-    linetable::Vector{LineInfoNode}
+    debuginfo::DebugInfoStream
     cfg::CFG
     new_nodes::NewNodeStream
     meta::Vector{Expr}
 
-    function IRCode(stmts::InstructionStream, cfg::CFG, linetable::Vector{LineInfoNode}, argtypes::Vector{Any}, meta::Vector{Expr}, sptypes::Vector{VarState})
-        return new(stmts, argtypes, sptypes, linetable, cfg, NewNodeStream(), meta)
+    function IRCode(stmts::InstructionStream, cfg::CFG, debuginfo::DebugInfoStream, argtypes::Vector{Any}, meta::Vector{Expr}, sptypes::Vector{VarState})
+        return new(stmts, argtypes, sptypes, debuginfo, cfg, NewNodeStream(), meta)
     end
     function IRCode(ir::IRCode, stmts::InstructionStream, cfg::CFG, new_nodes::NewNodeStream)
-        return new(stmts, ir.argtypes, ir.sptypes, ir.linetable, cfg, new_nodes, ir.meta)
+        di = ir.debuginfo
+        @assert di.codelocs === stmts.line
+        return new(stmts, ir.argtypes, ir.sptypes, di, cfg, new_nodes, ir.meta)
+    end
+    global function copy(ir::IRCode)
+        di = ir.debuginfo
+        stmts = copy(ir.stmts)
+        di = copy(di)
+        di.edges = copy(di.edges)
+        di.codelocs = stmts.line
+        return new(stmts, copy(ir.argtypes), copy(ir.sptypes), di, copy(ir.cfg), copy(ir.new_nodes), copy(ir.meta))
     end
-    global copy(ir::IRCode) = new(copy(ir.stmts), copy(ir.argtypes), copy(ir.sptypes),
-        copy(ir.linetable), copy(ir.cfg), copy(ir.new_nodes), copy(ir.meta))
 end
 
 """
@@ -389,11 +454,14 @@ for debugging and unit testing of IRCode APIs. The compiler itself should genera
 from the frontend or one of the caches.
 """
 function IRCode()
-    ir = IRCode(InstructionStream(1), CFG([BasicBlock(1:1, Int[], Int[])], Int[1]), LineInfoNode[], Any[], Expr[], VarState[])
+    stmts = InstructionStream(1)
+    debuginfo = DebugInfoStream(stmts.line)
+    stmts.line[1] = 1
+    ir = IRCode(stmts, CFG([BasicBlock(1:1, Int[], Int[])], Int[1]), debuginfo, Any[], Expr[], VarState[])
     ir[SSAValue(1)][:stmt] = ReturnNode(nothing)
     ir[SSAValue(1)][:type] = Nothing
     ir[SSAValue(1)][:flag] = 0x00
-    ir[SSAValue(1)][:line] = Int32(0)
+    ir[SSAValue(1)][:line] = NoLineUpdate
     return ir
 end
 
@@ -690,6 +758,7 @@ mutable struct IncrementalCompact
         perm = sort!(collect(eachindex(info)); by=i::Int->(2info[i].pos+info[i].attach_after, i))
         new_len = length(code.stmts) + length(info)
         result = InstructionStream(new_len)
+        code.debuginfo.codelocs = result.line
         used_ssas = fill(0, new_len)
         new_new_used_ssas = Vector{Int}()
         blocks = code.cfg.blocks
@@ -870,7 +939,7 @@ function add_pending!(compact::IncrementalCompact, pos::Int, attach_after::Bool)
 end
 
 function inst_from_newinst!(node::Instruction, newinst::NewInstruction,
-    newline::Int32=newinst.line::Int32, newflag::UInt32=newinst.flag::UInt32)
+    newline::NTuple{3,Int32}=newinst.line::NTuple{3,Int32}, newflag::UInt32=newinst.flag::UInt32)
     node[:stmt] = newinst.stmt
     node[:type] = newinst.type
     node[:info] = newinst.info
@@ -960,7 +1029,7 @@ function maybe_reopen_bb!(compact)
 end
 
 function insert_node_here!(compact::IncrementalCompact, newinst::NewInstruction, reverse_affinity::Bool=false)
-    newline = newinst.line::Int32
+    newline = newinst.line::NTuple{3,Int32}
     refinish = false
     result_idx = compact.result_idx
     result_bbs = compact.cfg_transform.result_bbs
@@ -1602,6 +1671,8 @@ function resize!(compact::IncrementalCompact, nnewnodes::Int)
     return compact
 end
 
+const NoLineUpdate = (Int32(0), Int32(0), Int32(0))
+
 function finish_current_bb!(compact::IncrementalCompact, active_bb::Int,
                             old_result_idx::Int=compact.result_idx, unreachable::Bool=false)
     (;result_bbs, cfg_transforms_enabled, bb_rename_succ) = compact.cfg_transform
@@ -1618,9 +1689,9 @@ function finish_current_bb!(compact::IncrementalCompact, active_bb::Int,
             length(compact.result) < old_result_idx && resize!(compact, old_result_idx)
             node = compact.result[old_result_idx]
             if unreachable
-                node[:stmt], node[:type], node[:line] = ReturnNode(), Union{}, 0
+                node[:stmt], node[:type], node[:line] = ReturnNode(), Union{}, NoLineUpdate
             else
-                node[:stmt], node[:type], node[:line], node[:flag] = nothing, Nothing, 0, IR_FLAGS_EFFECTS
+                node[:stmt], node[:type], node[:line], node[:flag] = nothing, Nothing, NoLineUpdate, IR_FLAGS_EFFECTS
             end
             compact.result_idx = old_result_idx + 1
         elseif cfg_transforms_enabled && compact.result_idx - 1 == first(bb.stmts)
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 3b6cfa9019d76..cda590b07d23c 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -163,6 +163,7 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
         elseif head === :leave
             return false
         else
+            Core.println(stmt)
             error("reprocess_instruction!: unhandled expression found")
         end
     elseif isa(stmt, PhiNode)
diff --git a/base/compiler/ssair/legacy.jl b/base/compiler/ssair/legacy.jl
index 3e9a4e2a746dc..6d1c44375a7dd 100644
--- a/base/compiler/ssair/legacy.jl
+++ b/base/compiler/ssair/legacy.jl
@@ -35,13 +35,10 @@ function inflate_ir!(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{A
         ssavaluetypes = Any[ Any for i = 1:ssavaluetypes::Int ]
     end
     info = CallInfo[NoCallInfo() for i = 1:nstmts]
-    stmts = InstructionStream(code, ssavaluetypes, info, ci.codelocs, ci.ssaflags)
-    linetable = ci.linetable
-    if !isa(linetable, Vector{LineInfoNode})
-        linetable = collect(LineInfoNode, linetable::Vector{Any})::Vector{LineInfoNode}
-    end
+    di = DebugInfoStream(nothing, ci.debuginfo, nstmts)
+    stmts = InstructionStream(code, ssavaluetypes, info, di.codelocs, ci.ssaflags)
     meta = Expr[]
-    return IRCode(stmts, cfg, linetable, argtypes, meta, sptypes)
+    return IRCode(stmts, cfg, di, argtypes, meta, sptypes)
 end
 
 """
@@ -73,15 +70,17 @@ function replace_code_newstyle!(ci::CodeInfo, ir::IRCode)
     stmts = ir.stmts
     code = ci.code = stmts.stmt
     ssavaluetypes = ci.ssavaluetypes = stmts.type
-    codelocs = ci.codelocs = stmts.line
+    codelocs = stmts.line
     ssaflags = ci.ssaflags = stmts.flag
-    linetable = ci.linetable = ir.linetable
+    debuginfo = ir.debuginfo
     for metanode in ir.meta
         push!(code, metanode)
-        push!(codelocs, 1)
+        push!(codelocs, 1, 0, 0)
         push!(ssavaluetypes, Any)
         push!(ssaflags, IR_FLAG_NULL)
     end
+    @assert debuginfo.codelocs === stmts.line "line table not from debuginfo"
+    ci.debuginfo = DebugInfo(debuginfo, length(code))
     # Translate BB Edges to statement edges
     # (and undo normalization for now)
     for i = 1:length(code)
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 4c34a6d8fe9de..946ba9633d366 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1507,7 +1507,7 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
     end
 
     src_inlining_policy(inlining.interp, src, info, IR_FLAG_NULL) || return false
-    src = retrieve_ir_for_inlining(code, src)
+    src, di = retrieve_ir_for_inlining(code, src)
 
     # For now: Require finalizer to only have one basic block
     length(src.cfg.blocks) == 1 || return false
@@ -1516,8 +1516,8 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
     add_inlining_backedge!(et, mi)
 
     # TODO: Should there be a special line number node for inlined finalizers?
-    inlined_at = ir[SSAValue(idx)][:line]
-    ssa_substitute = ir_prepare_inlining!(InsertBefore(ir, SSAValue(idx)), ir, src, mi, inlined_at, argexprs)
+    inline_at = ir[SSAValue(idx)][:line][1]
+    ssa_substitute = ir_prepare_inlining!(InsertBefore(ir, SSAValue(idx)), ir, src, di, mi, inline_at, argexprs)
 
     # TODO: Use the actual inliner here rather than open coding this special purpose inliner.
     ssa_rename = Vector{Any}(undef, length(src.stmts))
@@ -1529,12 +1529,8 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
             ssa_rename[ssa.id]
         end
         stmt′ = ssa_substitute_op!(InsertBefore(ir, SSAValue(idx)), inst, stmt′, ssa_substitute)
-        newline = inst[:line]
-        if newline != 0
-            newline += ssa_substitute.linetable_offset
-        end
         ssa_rename[idx′] = insert_node!(ir, idx,
-            NewInstruction(inst; stmt=stmt′, line=newline),
+            NewInstruction(inst; stmt=stmt′, line=(ssa_substitute.inlined_at[1], ssa_substitute.inlined_at[2], Int32(idx′))),
             attach_after)
     end
 
diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl
index 3936a82a6560e..2c0385a808801 100644
--- a/base/compiler/ssair/show.jl
+++ b/base/compiler/ssair/show.jl
@@ -145,17 +145,6 @@ function show_unquoted_gotoifnot(io::IO, stmt::GotoIfNot, indent::Int, prefix::S
     show_unquoted(io, stmt.cond, indent)
 end
 
-function compute_inlining_depth(linetable::Vector, iline::Int32)
-    iline == 0 && return 1
-    depth = -1
-    while iline != 0
-        depth += 1
-        lineinfo = linetable[iline]::LineInfoNode
-        iline = lineinfo.inlined_at
-    end
-    return depth
-end
-
 function should_print_ssa_type(@nospecialize node)
     if isa(node, Expr)
         return !(node.head in (:gc_preserve_begin, :gc_preserve_end, :meta, :leave))
@@ -171,32 +160,27 @@ function default_expr_type_printer(io::IO; @nospecialize(type), used::Bool, show
     return nothing
 end
 
-function normalize_method_name(m)
+function method_name(@nospecialize m)
+    if m isa LineInfoNode
+        m = m.method
+    end
+    if m isa MethodInstance
+        m = m.def
+    end
     if m isa Method
-        return m.name
-    elseif m isa MethodInstance
-        return (m.def::Method).name
-    elseif m isa Symbol
+        m = m.name
+    end
+    if m isa Module
+        return :var"top-level scope"
+    end
+    if m isa Symbol
         return m
-    else
-        return Symbol("")
     end
+    return :var""
 end
-@noinline method_name(m::LineInfoNode) = normalize_method_name(m.method)
-
-# converts the linetable for line numbers
-# into a list in the form:
-#   1 outer-most-frame
-#   2   inlined-frame
-#   3     innermost-frame
-function compute_loc_stack(linetable::Vector, line::Int32)
-    stack = Int[]
-    while line != 0
-        entry = linetable[line]::LineInfoNode
-        pushfirst!(stack, line)
-        line = entry.inlined_at
-    end
-    return stack
+@noinline function normalize_method_name(@nospecialize m)
+    name = method_name(m)
+    return name === :var"" ? :none : name
 end
 
 """
@@ -265,83 +249,72 @@ function compute_ir_line_annotations(code::IRCode)
     loc_lineno = String[]
     cur_group = 1
     last_lineno = 0
-    last_stack = Int[]
+    last_stack = LineInfoNode[] # nb. only file, line, and method are populated in this
     last_printed_depth = 0
-    linetable = code.linetable
-    lines = code.stmts.line
-    last_line = zero(eltype(lines))
-    for idx in 1:length(lines)
+    debuginfo = code.debuginfo
+    def = :var"unknown scope"
+    for idx in 1:length(code.stmts)
         buf = IOBuffer()
-        line = lines[idx]
         print(buf, "│")
-        depth = compute_inlining_depth(linetable, line)
-        iline = line
-        lineno = 0
+        stack = buildLineInfoNode(debuginfo, def, idx)
+        lineno::Int = 0
         loc_method = ""
-        if line != 0
-            stack = compute_loc_stack(linetable, line)
-            lineno = linetable[stack[1]].line
+        isempty(stack) && (stack = last_stack)
+        if !isempty(stack)
+            lineno = stack[1].line
             x = min(length(last_stack), length(stack))
-            if length(stack) != 0
-                # Compute the last depth that was in common
-                first_mismatch = let last_stack=last_stack
-                    findfirst(i->last_stack[i] != stack[i], 1:x)
-                end
-                # If the first mismatch is the last stack frame, that might just
-                # be a line number mismatch in inner most frame. Ignore those
-                if length(last_stack) == length(stack) && first_mismatch == length(stack)
-                    last_entry, entry = linetable[last_stack[end]], linetable[stack[end]]
-                    if method_name(last_entry) === method_name(entry) && last_entry.file === entry.file
-                        first_mismatch = nothing
-                    end
+            depth = length(stack) - 1
+            # Compute the last depth that was in common
+            first_mismatch = let last_stack=last_stack
+                findfirst(i->last_stack[i] != stack[i], 1:x)
+            end
+            # If the first mismatch is the last stack frame, that might just
+            # be a line number mismatch in inner most frame. Ignore those
+            if length(last_stack) == length(stack) && first_mismatch == length(stack)
+                last_entry, entry = last_stack[end], stack[end]
+                if method_name(last_entry) === method_name(entry) && last_entry.file === entry.file
+                    first_mismatch = nothing
                 end
-                last_depth = something(first_mismatch, x+1)-1
-                if min(depth, last_depth) > last_printed_depth
-                    printing_depth = min(depth, last_printed_depth + 1)
-                    last_printed_depth = printing_depth
-                elseif length(stack) > length(last_stack) || first_mismatch !== nothing
-                    printing_depth = min(depth, last_depth + 1)
-                    last_printed_depth = printing_depth
-                else
-                    printing_depth = 0
+            end
+            last_depth = something(first_mismatch, x+1)-1
+            if min(depth, last_depth) > last_printed_depth
+                printing_depth = min(depth, last_printed_depth + 1)
+                last_printed_depth = printing_depth
+            elseif length(stack) > length(last_stack) || first_mismatch !== nothing
+                printing_depth = min(depth, last_depth + 1)
+                last_printed_depth = printing_depth
+            else
+                printing_depth = 0
+            end
+            stole_one = false
+            if printing_depth != 0
+                for _ in 1:(printing_depth-1)
+                    print(buf, "│")
                 end
-                stole_one = false
-                if printing_depth != 0
-                    for _ in 1:(printing_depth-1)
+                if printing_depth <= last_depth-1 && first_mismatch === nothing
+                    print(buf, "┃")
+                    for _ in printing_depth+1:min(depth, last_depth)
                         print(buf, "│")
                     end
-                    if printing_depth <= last_depth-1 && first_mismatch === nothing
-                        print(buf, "┃")
-                        for _ in printing_depth+1:min(depth, last_depth)
-                            print(buf, "│")
-                        end
-                    else
-                        stole_one = true
-                        print(buf, "╻")
-                    end
                 else
-                    for _ in 1:min(depth, last_depth)
-                        print(buf, "│")
-                    end
+                    stole_one = true
+                    print(buf, "╻")
                 end
-                print(buf, "╷"^max(0, depth - last_depth - stole_one))
-                if printing_depth != 0
-                    if length(stack) == printing_depth
-                        loc_method = line
-                    else
-                        loc_method = stack[printing_depth + 1]
-                    end
-                    loc_method = method_name(linetable[loc_method])
+            else
+                for _ in 1:min(depth, last_depth)
+                    print(buf, "│")
                 end
-                loc_method = string(" "^printing_depth, loc_method)
             end
+            print(buf, "╷"^max(0, depth - last_depth - stole_one))
+            if printing_depth != 0
+                loc_method = normalize_method_name(stack[printing_depth + 1])
+            end
+            loc_method = string(" "^printing_depth, loc_method)
             last_stack = stack
-            entry = linetable[line]
         end
         push!(loc_annotations, String(take!(buf)))
         push!(loc_lineno, (lineno != 0 && lineno != last_lineno) ? string(lineno) : "")
         push!(loc_methods, loc_method)
-        last_line = line
         (lineno != 0) && (last_lineno = lineno)
         nothing
     end
@@ -350,19 +323,87 @@ end
 
 Base.show(io::IO, code::Union{IRCode, IncrementalCompact}) = show_ir(io, code)
 
+# A line_info_preprinter for disabling line info printing
 lineinfo_disabled(io::IO, linestart::String, idx::Int) = ""
 
-function DILineInfoPrinter(linetable::Vector, showtypes::Bool=false)
+# utility function to extract the file name from a DebugInfo object
+function debuginfo_file1(debuginfo::Union{Core.DebugInfo,DebugInfoStream})
+    def = debuginfo.def
+    if def isa MethodInstance
+        def = def.def
+    end
+    if def isa Method
+        def = def.file
+    end
+    if def isa Symbol
+        return def
+    end
+    return :var"<unknown>"
+end
+
+# utility function to extract the first line number and file of a block of code
+function debuginfo_firstline(debuginfo::Union{Core.DebugInfo,DebugInfoStream})
+    linetable = debuginfo.linetable
+    while linetable != nothing
+        debuginfo = linetable
+        linetable = debuginfo.linetable
+    end
+    codeloc = getdebugidx(debuginfo, 0)
+    return debuginfo_file1(debuginfo), codeloc[1]
+end
+
+struct LineInfoNode
+    method # ::Union{Method,MethodInstance,Symbol}
+    file::Symbol
+    line::Int32
+end
+
+# utility function for converting a debuginfo object a particular pc to list of LineInfoNodes representing the inlining info at that pc for function `def`
+# which is either `nothing` (macro-expand), a module (top-level), a Method (unspecialized code) or a MethodInstance (specialized code)
+# Returns `false` if the line info should not be updated with this info because this
+# statement has no effect on the line numbers. The `scopes` will still be populated however
+# with as much information as was available about the inlining at that statement.
+function append_scopes!(scopes::Vector{LineInfoNode}, pc::Int, debuginfo, @nospecialize(def))
+    doupdate = true
+    while true
+        debuginfo.def isa Symbol || (def = debuginfo.def)
+        codeloc = getdebugidx(debuginfo, pc)
+        line::Int = codeloc[1]
+        inl_to::Int = codeloc[2]
+        doupdate &= line != 0 || inl_to != 0 # disabled debug info--no update
+        if debuginfo.linetable === nothing || pc <= 0 || line < 0
+            line < 0 && (doupdate = false; line = 0) # broken debug info
+            push!(scopes, LineInfoNode(def, debuginfo_file1(debuginfo), Int32(line)))
+        else
+            doupdate = append_scopes!(scopes, line, debuginfo.linetable::Core.DebugInfo, def) && doupdate
+        end
+        inl_to == 0 && return doupdate
+        def = :var"macro expansion"
+        debuginfo = debuginfo.edges[inl_to]
+        pc::Int = codeloc[3]
+    end
+end
+
+# utility wrapper around `append_scopes!` that returns an empty list instead of false
+# when there is no applicable line update
+function buildLineInfoNode(debuginfo, @nospecialize(def), pc::Int)
+    DI = LineInfoNode[]
+    append_scopes!(DI, pc, debuginfo, def) || empty!(DI)
+    return DI
+end
+
+# A default line_info_preprinter for printing accurate line number information
+function DILineInfoPrinter(debuginfo, def, showtypes::Bool=false)
     context = LineInfoNode[]
     context_depth = Ref(0)
     indent(s::String) = s^(max(context_depth[], 1) - 1)
-    function emit_lineinfo_update(io::IO, linestart::String, lineidx::Int32)
+    function emit_lineinfo_update(io::IO, linestart::String, pc::Int)
         # internal configuration options:
         linecolor = :yellow
         collapse = showtypes ? false : true
         indent_all = true
-        # convert lineidx to a vector
-        if lineidx == typemin(Int32)
+        # convert pc to a vector
+        if pc == 0
             # sentinel value: reset internal (and external) state
             pops = indent("└")
             if !isempty(pops)
@@ -372,13 +413,10 @@ function DILineInfoPrinter(linetable::Vector, showtypes::Bool=false)
             end
             empty!(context)
             context_depth[] = 0
-        elseif lineidx > 0 # just skip over lines with no debug info at all
-            DI = LineInfoNode[]
-            while lineidx != 0
-                entry = linetable[lineidx]::LineInfoNode
-                push!(DI, entry)
-                lineidx = entry.inlined_at
-            end
+            return ""
+        end
+        DI = reverse!(buildLineInfoNode(debuginfo, def, pc))
+        if !isempty(DI)
             # FOR DEBUGGING, or if you just like very excessive output:
             # this prints out the context in full for every statement
             #empty!(context)
@@ -508,6 +546,7 @@ function DILineInfoPrinter(linetable::Vector, showtypes::Bool=false)
             #end
         end
         indent_all || return ""
+        context_depth[] <= 1 && return ""
         return sprint(io -> printstyled(io, indent("│"), color=linecolor), context=io)
     end
     return emit_lineinfo_update
@@ -803,18 +842,8 @@ end
 
 _strip_color(s::String) = replace(s, r"\e\[\d+m"a => "")
 
-function statementidx_lineinfo_printer(f, code::IRCode)
-    printer = f(code.linetable)
-    function (io::IO, indent::String, idx::Int)
-        printer(io, indent, idx > 0 ? code.stmts[idx][:line] : typemin(Int32))
-    end
-end
-function statementidx_lineinfo_printer(f, code::CodeInfo)
-    printer = f(code.linetable)
-    function (io::IO, indent::String, idx::Int)
-        printer(io, indent, idx > 0 ? code.codelocs[idx] : typemin(Int32))
-    end
-end
+statementidx_lineinfo_printer(f, code::IRCode) = f(code.debuginfo, :var"unknown scope")
+statementidx_lineinfo_printer(f, code::CodeInfo) = f(code.debuginfo, :var"unknown scope")
 statementidx_lineinfo_printer(code) = statementidx_lineinfo_printer(DILineInfoPrinter, code)
 
 function stmts_used(io::IO, code::IRCode, warn_unset_entry=true)
diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl
index 7ee07585fae9b..f2bfa0e4c5476 100644
--- a/base/compiler/ssair/slot2ssa.jl
+++ b/base/compiler/ssair/slot2ssa.jl
@@ -161,40 +161,6 @@ function rename_uses!(ir::IRCode, ci::CodeInfo, idx::Int, @nospecialize(stmt), r
     return fixemup!(stmt::SlotNumber->true, stmt::SlotNumber->renames[slot_id(stmt)], ir, ci, idx, stmt)
 end
 
-function strip_trailing_junk!(ci::CodeInfo, cfg::CFG, code::Vector{Any}, info::Vector{CallInfo})
-    # Remove `nothing`s at the end, we don't handle them well
-    # (we expect the last instruction to be a terminator)
-    ssavaluetypes = ci.ssavaluetypes::Vector{Any}
-    (; codelocs, ssaflags) = ci
-    for i = length(code):-1:1
-        if code[i] !== nothing
-            resize!(code, i)
-            resize!(ssavaluetypes, i)
-            resize!(codelocs, i)
-            resize!(info, i)
-            resize!(ssaflags, i)
-            break
-        end
-    end
-    # If the last instruction is not a terminator, add one. This can
-    # happen for implicit return on dead branches.
-    term = code[end]
-    if !isa(term, GotoIfNot) && !isa(term, GotoNode) && !isa(term, ReturnNode)
-        push!(code, ReturnNode())
-        push!(ssavaluetypes, Union{})
-        push!(codelocs, 0)
-        push!(info, NoCallInfo())
-        push!(ssaflags, IR_FLAG_NOTHROW)
-
-        # Update CFG to include appended terminator
-        old_range = cfg.blocks[end].stmts
-        new_range = StmtRange(first(old_range), last(old_range) + 1)
-        cfg.blocks[end] = BasicBlock(cfg.blocks[end], new_range)
-        (length(cfg.index) == length(cfg.blocks)) && (cfg.index[end] += 1)
-    end
-    nothing
-end
-
 # maybe use expr_type?
 function typ_for_val(@nospecialize(x), ci::CodeInfo, ir::IRCode, idx::Int, slottypes::Vector{Any})
     if isa(x, Expr)
@@ -464,7 +430,7 @@ function domsort_ssa!(ir::IRCode, domtree::DomTree)
                 # Add an explicit goto node in the next basic block (we accounted for this above)
                 nidx = inst_range[end] + 1
                 node = result[nidx]
-                node[:stmt], node[:type], node[:line] = GotoNode(bb_rename[bb + 1]), Any, 0
+                node[:stmt], node[:type], node[:line] = GotoNode(bb_rename[bb + 1]), Any, NoLineUpdate
             end
             result[inst_range[end]][:stmt] = GotoIfNot(terminator.cond, bb_rename[terminator.dest])
         elseif !isa(terminator, ReturnNode)
@@ -475,7 +441,7 @@ function domsort_ssa!(ir::IRCode, domtree::DomTree)
                 # Add an explicit goto node
                 nidx = inst_range[end] + 1
                 node = result[nidx]
-                node[:stmt], node[:type], node[:line] = GotoNode(bb_rename[bb + 1]), Any, 0
+                node[:stmt], node[:type], node[:line] = GotoNode(bb_rename[bb + 1]), Any, NoLineUpdate
                 inst_range = first(inst_range):(last(inst_range) + 1)
             end
         end
@@ -504,6 +470,7 @@ function domsort_ssa!(ir::IRCode, domtree::DomTree)
         end
         new_node[:stmt] = renumber_ssa!(new_node_inst, inst_rename, true)
     end
+    ir.debuginfo.codelocs = result.line
     new_ir = IRCode(ir, result, cfg, new_new_nodes)
     return new_ir
 end
diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index ae294990b40d0..95ee544530810 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -111,8 +111,8 @@ function verify_ir(ir::IRCode, print::Bool=true,
         @verify_error "IR info length is invalid $(length(ir.stmts.info)) / $(length(ir.stmts))"
         error("")
     end
-    if length(ir.stmts.line) != length(ir.stmts)
-        @verify_error "IR line length is invalid $(length(ir.stmts.line)) / $(length(ir.stmts))"
+    if length(ir.stmts.line) != length(ir.stmts) * 3
+        @verify_error "IR line length is invalid $(length(ir.stmts.line)) / $(length(ir.stmts) * 3)"
         error("")
     end
     if length(ir.stmts.flag) != length(ir.stmts)
@@ -329,20 +329,6 @@ function verify_ir(ir::IRCode, print::Bool=true,
             @verify_error "Terminator $idx in bb $bb is not the last statement in the block"
             error("")
         else
-            if isa(stmt, Expr) || isa(stmt, ReturnNode) # TODO: make sure everything has line info
-                if (stmt isa ReturnNode)
-                    if isdefined(stmt, :val)
-                        # TODO: Disallow unreachable returns?
-                        # bb_unreachable(domtree, Int64(edge))
-                    else
-                        #@verify_error "Missing line number information for statement $idx of $ir"
-                    end
-                end
-                if !(stmt isa ReturnNode && !isdefined(stmt, :val)) # not actually a return node, but an unreachable marker
-                    if ir.stmts[idx][:line] <= 0
-                    end
-                end
-            end
             isforeigncall = false
             if isa(stmt, Expr)
                 if stmt.head === :(=)
@@ -397,12 +383,12 @@ function verify_ir(ir::IRCode, print::Bool=true,
     end
 end
 
-function verify_linetable(linetable::Vector{LineInfoNode}, print::Bool=true)
-    for i in 1:length(linetable)
-        line = linetable[i]
-        if i <= line.inlined_at
-            @verify_error "Misordered linetable"
-            error("")
+function verify_linetable(di::DebugInfoStream, nstmts::Int, print::Bool=true)
+    @assert 3nstmts == length(di.codelocs)
+    for i in 1:nstmts
+        edge = di.codelocs[3i-1]
+        if !(edge == 0 || get(di.edges, edge, nothing) isa DebugInfo)
+            @verify_error "Malformed debuginfo index into edges"
         end
     end
 end
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 3ec9c1a3811ed..7113d3d6697a1 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -317,6 +317,7 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
     else
         inferred_result = transform_result_for_cache(interp, result.linfo, result.valid_worlds, result, can_discard_trees)
         if inferred_result isa CodeInfo
+            edges = inferred_result.debuginfo
             uncompressed = inferred_result
             inferred_result = maybe_compress_codeinfo(interp, result.linfo, inferred_result, can_discard_trees)
             result.is_src_volatile |= uncompressed !== inferred_result
@@ -333,12 +334,15 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
         end
     end
     # n.b. relocatability = (isa(inferred_result, String) && inferred_result[end]) || inferred_result === nothing
+    if !@isdefined edges
+        edges = Core.DebugInfo(result.linfo)
+    end
     return CodeInstance(result.linfo, owner,
         widenconst(result_type), widenconst(result.exc_result), rettype_const, inferred_result,
         const_flags, first(result.valid_worlds), last(result.valid_worlds),
         # TODO: Actually do something with non-IPO effects
         encode_effects(result.ipo_effects), encode_effects(result.ipo_effects), result.analysis_results,
-        relocatability)
+        relocatability, edges)
 end
 
 function transform_result_for_cache(interp::AbstractInterpreter,
@@ -926,8 +930,7 @@ function codeinfo_for_const(interp::AbstractInterpreter, mi::MethodInstance, @no
     tree.slotnames = ccall(:jl_uncompress_argnames, Vector{Symbol}, (Any,), method.slot_syms)
     tree.slotflags = fill(0x00, nargs)
     tree.ssavaluetypes = 1
-    tree.codelocs = Int32[1]
-    tree.linetable = LineInfoNode[LineInfoNode(method.module, method.name, method.file, method.line, Int32(0))]
+    tree.debuginfo = Core.DebugInfo(mi)
     tree.ssaflags = UInt32[0]
     set_inlineable!(tree, true)
     tree.parent = mi
@@ -946,7 +949,7 @@ function codeinstance_for_const_with_code(interp::AbstractInterpreter, code::Cod
     return CodeInstance(code.def, cache_owner(interp), code.rettype, code.exctype, code.rettype_const, src,
         Int32(0x3), code.min_world, code.max_world,
         code.ipo_purity_bits, code.purity_bits, code.analysis_results,
-        code.relocatability)
+        code.relocatability, src.debuginfo)
 end
 
 result_is_constabi(interp::AbstractInterpreter, run_optimizer::Bool, result::InferenceResult) =
@@ -1114,9 +1117,10 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance, source_mod
     if isa(def, Method)
         if ccall(:jl_get_module_infer, Cint, (Any,), def.module) == 0 && !generating_output(#=incremental=#false)
             src = retrieve_code_info(mi, get_inference_world(interp))
+            src isa CodeInfo || return nothing
             return CodeInstance(mi, cache_owner(interp), Any, Any, nothing, src, Int32(0),
                 get_inference_world(interp), get_inference_world(interp),
-                UInt32(0), UInt32(0), nothing, UInt8(0))
+                UInt32(0), UInt32(0), nothing, UInt8(0), src.debuginfo)
         end
     end
     lock_mi_inference(interp, mi)
diff --git a/base/expr.jl b/base/expr.jl
index 94abe5b2eab67..cbeb16dd8d79b 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -33,9 +33,6 @@ macro gensym(names...)
     return blk
 end
 
-## line numbers ##
-convert(::Type{LineNumberNode}, lin::Core.LineInfoNode) = LineNumberNode(Int(lin.line), lin.file)
-
 ## expressions ##
 
 isexpr(@nospecialize(ex), head::Symbol) = isa(ex, Expr) && ex.head === head
@@ -81,8 +78,6 @@ function copy(c::CodeInfo)
     if cnew.slottypes !== nothing
         cnew.slottypes = copy(cnew.slottypes::Vector{Any})
     end
-    cnew.codelocs  = copy(cnew.codelocs)
-    cnew.linetable = copy(cnew.linetable::Union{Vector{Any},Vector{Core.LineInfoNode}})
     cnew.ssaflags  = copy(cnew.ssaflags)
     cnew.edges     = cnew.edges === nothing ? nothing : copy(cnew.edges::Vector)
     ssavaluetypes  = cnew.ssavaluetypes
@@ -1016,14 +1011,10 @@ function remove_linenums!(@nospecialize ex)
         for subex in ex.args
             subex isa Expr && remove_linenums!(subex)
         end
-        return ex
     elseif ex isa CodeInfo
-        ex.codelocs .= 0
-        length(ex.linetable::Vector) > 1 && resize!(ex.linetable::Vector, 1)
-        return ex
-    else
-        return ex
+        ex.debuginfo = Core.DebugInfo(ex.debuginfo.def) # TODO: filter partially, but keep edges
     end
+    return ex
 end
 
 replace_linenums!(ex, ln::LineNumberNode) = ex
diff --git a/base/opaque_closure.jl b/base/opaque_closure.jl
index 9891db20249fb..0a265e87afb68 100644
--- a/base/opaque_closure.jl
+++ b/base/opaque_closure.jl
@@ -61,6 +61,8 @@ function Core.OpaqueClosure(ir::IRCode, @nospecialize env...;
                             do_compile::Bool = true)
     # NOTE: we need ir.argtypes[1] == typeof(env)
     ir = Core.Compiler.copy(ir)
+    # if the user didn't specify a definition MethodInstance or filename Symbol to use for the debuginfo, set a filename now
+    ir.debuginfo.def === nothing && (ir.debuginfo.def = :var"generated IR for OpaqueClosure")
     nargs = length(ir.argtypes)-1
     sig = compute_oc_signature(ir, nargs, isva)
     rt = compute_ir_rettype(ir)
diff --git a/base/show.jl b/base/show.jl
index d25853c295871..ea6fd2b820207 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1353,8 +1353,10 @@ function show_mi(io::IO, l::Core.MethodInstance, from_stackframe::Bool=false)
         # added by other means.  But if it isn't, then we should try
         # to print a little more identifying information.
         if !from_stackframe
-            linetable = l.uninferred.linetable
-            line = isempty(linetable) ? "unknown" : (lt = linetable[1]::Union{LineNumberNode,Core.LineInfoNode}; string(lt.file, ':', lt.line))
+            di = mi.uninferred.debuginfo
+            file, line = IRShow.debuginfo_firstline(di)
+            file = string(file)
+            line = isempty(file) || line < 0 ? "<unknown>" : "$file:$line"
             print(io, " from ", def, " starting at ", line)
         end
     end
@@ -1377,8 +1379,10 @@ function show(io::IO, mi_info::Core.Compiler.Timings.InferenceFrameInfo)
             show_tuple_as_call(io, def.name, mi.specTypes; argnames, qualified=true)
         end
     else
-        linetable = mi.uninferred.linetable
-        line = isempty(linetable) ? "" : (lt = linetable[1]; string(lt.file, ':', lt.line))
+        di = mi.uninferred.debuginfo
+        file, line = IRShow.debuginfo_firstline(di)
+        file = string(file)
+        line = isempty(file) || line < 0 ? "<unknown>" : "$file:$line"
         print(io, "Toplevel InferenceFrameInfo thunk from ", def, " starting at ", line)
     end
 end
@@ -2820,7 +2824,7 @@ module IRShow
     import ..Base
     import .Compiler: IRCode, CFG, scan_ssa_use!,
         isexpr, compute_basic_blocks, block_for_inst, IncrementalCompact,
-        Effects, ALWAYS_TRUE, ALWAYS_FALSE
+        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)
@@ -2833,9 +2837,9 @@ module IRShow
     include("compiler/ssair/show.jl")
 
     const __debuginfo = Dict{Symbol, Any}(
-        # :full => src -> Base.IRShow.statementidx_lineinfo_printer(src), # and add variable slot information
-        :source => src -> Base.IRShow.statementidx_lineinfo_printer(src),
-        # :oneliner => src -> Base.IRShow.statementidx_lineinfo_printer(Base.IRShow.PartialLineInfoPrinter, src),
+        # :full => src -> statementidx_lineinfo_printer(src), # and add variable slot information
+        :source => src -> statementidx_lineinfo_printer(src),
+        # :oneliner => src -> statementidx_lineinfo_printer(PartialLineInfoPrinter, src),
         :none => src -> Base.IRShow.lineinfo_disabled,
         )
     const default_debuginfo = Ref{Symbol}(:none)
@@ -2849,18 +2853,11 @@ function show(io::IO, src::CodeInfo; debuginfo::Symbol=:source)
     if src.slotnames !== nothing
         lambda_io = IOContext(lambda_io, :SOURCE_SLOTNAMES => sourceinfo_slotnames(src))
     end
-    if isempty(src.linetable) || src.linetable[1] isa LineInfoNode
-        println(io)
-        # TODO: static parameter values?
-        # only accepts :source or :none, we can't have a fallback for default since
-        # that would break code_typed(, debuginfo=:source) iff IRShow.default_debuginfo[] = :none
-        IRShow.show_ir(lambda_io, src, IRShow.IRShowConfig(IRShow.__debuginfo[debuginfo](src)))
-    else
-        # this is a CodeInfo that has not been used as a method yet, so its locations are still LineNumberNodes
-        body = Expr(:block)
-        body.args = src.code
-        show(lambda_io, body)
-    end
+    println(io)
+    # TODO: static parameter values?
+    # only accepts :source or :none, we can't have a fallback for default since
+    # that would break code_typed(, debuginfo=:source) iff IRShow.default_debuginfo[] = :none
+    IRShow.show_ir(lambda_io, src, IRShow.IRShowConfig(IRShow.__debuginfo[debuginfo](src)))
     print(io, ")")
 end
 
diff --git a/base/stacktraces.jl b/base/stacktraces.jl
index e82fd8118b2d7..84d280973c28a 100644
--- a/base/stacktraces.jl
+++ b/base/stacktraces.jl
@@ -8,6 +8,7 @@ module StackTraces
 
 import Base: hash, ==, show
 import Core: CodeInfo, MethodInstance
+using Base.IRShow: normalize_method_name, append_scopes!, LineInfoNode
 
 export StackTrace, StackFrame, stacktrace
 
@@ -20,10 +21,10 @@ Stack information representing execution context, with the following fields:
 
   The name of the function containing the execution context.
 
-- `linfo::Union{Core.MethodInstance, Method, Module, Core.CodeInfo, Nothing}`
+- `linfo::Union{Method, Core.MethodInstance, Core.CodeInfo, Nothing}`
 
-  The MethodInstance or CodeInfo containing the execution context (if it could be found), \
-     or Module (for macro expansions)"
+  The Method, MethodInstance, or CodeInfo containing the execution context (if it could be found), \
+     or nothing (for example, if the inlining was a result of macro expansion).
 
 - `file::Symbol`
 
@@ -54,8 +55,8 @@ struct StackFrame # this type should be kept platform-agnostic so that profiles
     "the line number in the file containing the execution context"
     line::Int
     "the MethodInstance or CodeInfo containing the execution context (if it could be found), \
-     or Module (for macro expansions)"
-    linfo::Union{MethodInstance, Method, Module, CodeInfo, Nothing}
+     or nothing (for example, if the inlining was a result of macro expansion)."
+    linfo::Union{MethodInstance, Method, CodeInfo, Nothing}
     "true if the code is from C"
     from_c::Bool
     "true if the code is from an inlined frame"
@@ -112,7 +113,11 @@ Base.@constprop :none function lookup(pointer::Ptr{Cvoid})
     for i in 1:length(infos)
         info = infos[i]::Core.SimpleVector
         @assert(length(info) == 6)
-        res[i] = StackFrame(info[1]::Symbol, info[2]::Symbol, info[3]::Int, info[4], info[5]::Bool, info[6]::Bool, pointer)
+        func = info[1]::Symbol
+        file = info[2]::Symbol
+        linenum = info[3]::Int
+        linfo = info[4]
+        res[i] = StackFrame(func, file, linenum, linfo, info[5]::Bool, info[6]::Bool, pointer)
     end
     return res
 end
@@ -136,17 +141,24 @@ function lookup(ip::Union{Base.InterpreterIP,Core.Compiler.InterpreterIP})
         file = empty_sym
         line = Int32(0)
     end
-    i = max(ip.stmt+1, 1)  # ip.stmt is 0-indexed
-    if i > length(codeinfo.codelocs) || codeinfo.codelocs[i] == 0
+    def = (code isa MethodInstance ? code : StackTraces) # Module just used as a token for top-level code
+    pc::Int = max(ip.stmt + 1, 0) # n.b. ip.stmt is 0-indexed
+    scopes = LineInfoNode[]
+    append_scopes!(scopes, pc, codeinfo.debuginfo, def)
+    if isempty(scopes)
         return [StackFrame(func, file, line, code, false, false, 0)]
     end
-    lineinfo = codeinfo.linetable[codeinfo.codelocs[i]]::Core.LineInfoNode
-    scopes = StackFrame[]
-    while true
-        inlined = lineinfo.inlined_at != 0
-        push!(scopes, StackFrame(Base.IRShow.method_name(lineinfo)::Symbol, lineinfo.file, lineinfo.line, inlined ? nothing : code, false, inlined, 0))
-        inlined || break
-        lineinfo = codeinfo.linetable[lineinfo.inlined_at]::Core.LineInfoNode
+    inlined = false
+    scopes = map(scopes) do lno
+        if inlined
+            def = lno.method
+            def isa Union{Method,MethodInstance} || (def = nothing)
+        else
+            def = codeinfo
+        end
+        sf = StackFrame(normalize_method_name(lno.method), lno.file, lno.line, def, false, inlined, 0)
+        inlined = true
+        return sf
     end
     return scopes
 end
diff --git a/doc/src/base/reflection.md b/doc/src/base/reflection.md
index d44bc474abbd2..0f0af140b605f 100644
--- a/doc/src/base/reflection.md
+++ b/doc/src/base/reflection.md
@@ -100,7 +100,6 @@ as assignments, branches, and calls:
 ```jldoctest; setup = (using Base: +, sin)
 julia> Meta.lower(@__MODULE__, :( [1+2, sin(0.5)] ))
 :($(Expr(:thunk, CodeInfo(
-    @ none within `top-level scope`
 1 ─ %1 = 1 + 2
 │   %2 = sin(0.5)
 │   %3 = Base.vect(%1, %2)
diff --git a/doc/src/devdocs/ast.md b/doc/src/devdocs/ast.md
index c2cd0e92d58d2..9efcd7974091f 100644
--- a/doc/src/devdocs/ast.md
+++ b/doc/src/devdocs/ast.md
@@ -767,3 +767,80 @@ Boolean properties:
     * 0x01 << 4 = the syntactic control flow within this method is guaranteed to terminate (`:terminates_locally`)
 
     See the documentation of `Base.@assume_effects` for more details.
+
+
+How to interpret line numbers in a `CodeInfo` object:
+
+There are 2 common forms for this data: one used internally that compresses the data somewhat and one used in the compiler.
+They contain the same basic info, but the compiler version is all mutable while the version used internally is not.
+
+Many consumers may be able to call `Base.IRShow.buildLineInfoNode`,
+`Base.IRShow.append_scopes!`, or `Stacktraces.lookup(::InterpreterIP)` to avoid needing to
+(re-)implement these details specifically.
+
+The definitions of each of these are:
+
+```
+struct Core.DebugInfo
+    @noinline
+    def::Union{Method,MethodInstance,Symbol}
+    linetable::Union{Nothing,DebugInfo}
+    edges::SimpleVector{DebugInfo}
+    codelocs::String # compressed data
+end
+mutable struct Core.Compiler.DebugInfoStream
+    def::Union{Method,MethodInstance,Symbol}
+    linetable::Union{Nothing,DebugInfo}
+    edges::Vector{DebugInfo}
+    firstline::Int32 # the starting line for this block (specified by an index of 0)
+    codelocs::Vector{Int32} # for each statement:
+        # index into linetable (if defined), else a line number (in the file represented by def)
+        # then index into edges
+        # then index into edges[linetable]
+end
+```
+
+
+  * `def` : where this DebugInfo was defined (the Method, MethodInstance, or file scope, for example)
+
+  * `linetable`
+
+    Another debuginfo that this was derived from, which contains the actual line numbers,
+    such that this DebugInfo contains only the indexes into it. This avoids making copies,
+    as well as makes it possible to track how each individual statement transformed from
+    source to optimized, not just the separate line numbers. If `def` is not a Symbol, then
+    that object replaces the current function object for the metadata on what function is
+    conceptually being executed (e.g. think Cassette transforms here). The `codelocs` values
+    described below also are interpreted as an index into the `codelocs` in this object,
+    instead of being a line number itself.
+
+  * `edges` : Vector of the unique DebugInfo for every function inlined into this (which
+    recursively have the edges for everything inlined into them).
+
+  * `firstline` (when uncompressed to DebugInfoStream)
+
+    The line number associated with the `begin` statement (or other keyword such as
+    `function` or `quote`) that delinated where this code definition "starts".
+
+  * `codelocs` (when uncompressed to DebugInfoStream)
+
+    A vector of indices, with 3 values for each statement in the IR plus one for the
+    starting point of the block, that describe the stacktrace from that point:
+     1. the integer index into the `linetable.codelocs` field, giving the
+        original location associated with each statement (including its syntactic edges),
+        or zero indicating no change to the line number from the previously
+        executed statement (which is not necessarily syntactic or lexical prior).
+       or
+       the line number itself if the `linetable` field is `nothing`
+     2. the integer index into edges, giving the DebugInfo inlined there (or zero if there
+        are no edges).
+     3. (if entry 2 is non-zero) the integer index into edges[].codelocs, to interpret
+        recursively for each function in the inlining stack, or zero indicating to use
+        `edges[].firstline` as the line number.
+
+   Special codes include:
+     - (zero, zero, *) : no change to the line number or edges from the previous statement
+       (you may choose to interpret this either syntactically or lexically). The inlining
+       depth also might have changed, though most callers should ignore that.
+     - (zero, non-zero, *) : no line number, just edges (usually because of macro-expansion into
+       top-level code)
diff --git a/src/ast.c b/src/ast.c
index bd3460cbe7fd2..a7c6ae3bc218c 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -576,20 +576,16 @@ static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, jl_module_t *m
             JL_GC_POP();
             return temp;
         }
-        else if (sym == jl_lineinfo_sym && n == 5) {
-            jl_value_t *modu=NULL, *name=NULL, *file=NULL, *linenum=NULL, *inlinedat=NULL;
-            JL_GC_PUSH5(&modu, &name, &file, &linenum, &inlinedat);
+        else if (sym == jl_lineinfo_sym && n == 3) {
+            jl_value_t *file=NULL, *linenum=NULL, *inlinedat=NULL;
+            JL_GC_PUSH3(&file, &linenum, &inlinedat);
             value_t lst = e;
-            modu = scm_to_julia_(fl_ctx, car_(lst), mod);
-            lst = cdr_(lst);
-            name = scm_to_julia_(fl_ctx, car_(lst), mod);
-            lst = cdr_(lst);
             file = scm_to_julia_(fl_ctx, car_(lst), mod);
             lst = cdr_(lst);
             linenum = scm_to_julia_(fl_ctx, car_(lst), mod);
             lst = cdr_(lst);
             inlinedat = scm_to_julia_(fl_ctx, car_(lst), mod);
-            temp = jl_new_struct(jl_lineinfonode_type, modu, name, file, linenum, inlinedat);
+            temp = jl_new_struct(jl_lineinfonode_type, file, linenum, inlinedat);
             JL_GC_POP();
             return temp;
         }
@@ -938,10 +934,6 @@ JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
         jl_gc_wb(new_ci, new_ci->slotnames);
         new_ci->slotflags = jl_array_copy(new_ci->slotflags);
         jl_gc_wb(new_ci, new_ci->slotflags);
-        new_ci->codelocs = (jl_value_t*)jl_array_copy((jl_array_t*)new_ci->codelocs);
-        jl_gc_wb(new_ci, new_ci->codelocs);
-        new_ci->linetable = (jl_value_t*)jl_array_copy((jl_array_t*)new_ci->linetable);
-        jl_gc_wb(new_ci, new_ci->linetable);
         new_ci->ssaflags = jl_array_copy(new_ci->ssaflags);
         jl_gc_wb(new_ci, new_ci->ssaflags);
 
diff --git a/src/builtins.c b/src/builtins.c
index c26d528cb3ee4..eb9839bcc20f3 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -2512,7 +2512,8 @@ void jl_init_primitives(void) JL_GC_DISABLED
 
     add_builtin("Expr", (jl_value_t*)jl_expr_type);
     add_builtin("LineNumberNode", (jl_value_t*)jl_linenumbernode_type);
-    add_builtin("LineInfoNode", (jl_value_t*)jl_lineinfonode_type);
+    add_builtin("LegacyLineInfoNode", (jl_value_t*)jl_lineinfonode_type);
+    add_builtin("DebugInfo", (jl_value_t*)jl_debuginfo_type);
     add_builtin("GotoNode", (jl_value_t*)jl_gotonode_type);
     add_builtin("GotoIfNot", (jl_value_t*)jl_gotoifnot_type);
     add_builtin("EnterNode", (jl_value_t*)jl_enternode_type);
diff --git a/src/clangsa/GCChecker.cpp b/src/clangsa/GCChecker.cpp
index 97def0fac59f2..60471f1909f02 100644
--- a/src/clangsa/GCChecker.cpp
+++ b/src/clangsa/GCChecker.cpp
@@ -812,6 +812,7 @@ bool GCChecker::isGCTrackedType(QualType QT) {
                    //Name.endswith_lower("jl_genericmemoryref_t") ||
                    Name.endswith_lower("jl_method_t") ||
                    Name.endswith_lower("jl_method_instance_t") ||
+                   Name.endswith_lower("jl_debuginfo_t") ||
                    Name.endswith_lower("jl_tupletype_t") ||
                    Name.endswith_lower("jl_datatype_t") ||
                    Name.endswith_lower("jl_typemap_entry_t") ||
diff --git a/src/codegen.cpp b/src/codegen.cpp
index faa9de2762471..eaa9335659fb1 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -7925,10 +7925,14 @@ static jl_llvm_functions_t
         toplineno = lam->def.method->line;
         ctx.file = jl_symbol_name(lam->def.method->file);
     }
-    else if (jl_array_nrows(src->linetable) > 0) {
-        jl_value_t *locinfo = jl_array_ptr_ref(src->linetable, 0);
-        ctx.file = jl_symbol_name((jl_sym_t*)jl_fieldref_noalloc(locinfo, 2));
-        toplineno = jl_unbox_int32(jl_fieldref(locinfo, 3));
+    else if ((jl_value_t*)src->debuginfo != jl_nothing) {
+        // look for the file and line info of the original start of this block, as reported by lowering
+        jl_debuginfo_t *debuginfo = src->debuginfo;
+        while ((jl_value_t*)debuginfo->linetable != jl_nothing)
+            debuginfo = debuginfo->linetable;
+        ctx.file = jl_debuginfo_file(debuginfo);
+        struct jl_codeloc_t lineidx = jl_uncompress1_codeloc(debuginfo->codelocs, 0);
+        toplineno = std::max((int32_t)0, lineidx.line);
     }
     if (ctx.file.empty())
         ctx.file = "<missing>";
@@ -8011,8 +8015,8 @@ static jl_llvm_functions_t
     //Safe because params holds ctx lock
     Module *M = TSM.getModuleUnlocked();
     M->addModuleFlag(Module::Warning, "julia.debug_level", ctx.emission_context.debug_level);
-    jl_debugcache_t debuginfo;
-    debuginfo.initialize(M);
+    jl_debugcache_t debugcache;
+    debugcache.initialize(M);
     jl_returninfo_t returninfo = {};
     Function *f = NULL;
     bool has_sret = false;
@@ -8164,11 +8168,11 @@ static jl_llvm_functions_t
         topfile = dbuilder.createFile(ctx.file, ".");
         DISubroutineType *subrty;
         if (ctx.emission_context.debug_level <= 1)
-            subrty = debuginfo.jl_di_func_null_sig;
+            subrty = debugcache.jl_di_func_null_sig;
         else if (!specsig)
-            subrty = debuginfo.jl_di_func_sig;
+            subrty = debugcache.jl_di_func_sig;
         else
-            subrty = get_specsig_di(ctx, debuginfo, jlrettype, lam->specTypes, dbuilder);
+            subrty = get_specsig_di(ctx, debugcache, jlrettype, lam->specTypes, dbuilder);
         SP = dbuilder.createFunction(nullptr
                                      ,dbgFuncName      // Name
                                      ,f->getName()     // LinkageName
@@ -8199,7 +8203,7 @@ static jl_llvm_functions_t
                     topfile,                            // File
                     toplineno == -1 ? 0 : toplineno,    // Line
                     // Variable type
-                    julia_type_to_di(ctx, debuginfo, varinfo.value.typ, &dbuilder, false),
+                    julia_type_to_di(ctx, debugcache, varinfo.value.typ, &dbuilder, false),
                     AlwaysPreserve,                     // May be deleted if optimized out
                     DINode::FlagZero);                  // Flags (TODO: Do we need any)
             }
@@ -8210,7 +8214,7 @@ static jl_llvm_functions_t
                     has_sret + nreq + 1,                // Argument number (1-based)
                     topfile,                            // File
                     toplineno == -1 ? 0 : toplineno,    // Line (for now, use lineno of the function)
-                    julia_type_to_di(ctx, debuginfo, ctx.slots[ctx.vaSlot].value.typ, &dbuilder, false),
+                    julia_type_to_di(ctx, debugcache, ctx.slots[ctx.vaSlot].value.typ, &dbuilder, false),
                     AlwaysPreserve,                     // May be deleted if optimized out
                     DINode::FlagZero);                  // Flags (TODO: Do we need any)
             }
@@ -8225,7 +8229,7 @@ static jl_llvm_functions_t
                     jl_symbol_name(s),       // Variable name
                     topfile,                 // File
                     toplineno == -1 ? 0 : toplineno, // Line (for now, use lineno of the function)
-                    julia_type_to_di(ctx, debuginfo, varinfo.value.typ, &dbuilder, false), // Variable type
+                    julia_type_to_di(ctx, debugcache, varinfo.value.typ, &dbuilder, false), // Variable type
                     AlwaysPreserve,          // May be deleted if optimized out
                     DINode::FlagZero         // Flags (TODO: Do we need any)
                     );
@@ -8267,7 +8271,7 @@ static jl_llvm_functions_t
 
     // step 7. allocate local variables slots
     // must be in the first basic block for the llvm mem2reg pass to work
-    auto allocate_local = [&ctx, &dbuilder, &debuginfo, topdebugloc, va, debug_enabled, M](jl_varinfo_t &varinfo, jl_sym_t *s, int i) {
+    auto allocate_local = [&ctx, &dbuilder, &debugcache, topdebugloc, va, debug_enabled, M](jl_varinfo_t &varinfo, jl_sym_t *s, int i) {
         jl_value_t *jt = varinfo.value.typ;
         assert(!varinfo.boxroot); // variables shouldn't have memory locs already
         if (varinfo.value.constant) {
@@ -8318,7 +8322,7 @@ static jl_llvm_functions_t
             varinfo.value = mark_julia_slot(lv, jt, NULL, ctx.tbaa().tbaa_stack);
             alloc_def_flag(ctx, varinfo);
             if (debug_enabled && varinfo.dinfo) {
-                assert((Metadata*)varinfo.dinfo->getType() != debuginfo.jl_pvalue_dillvmt);
+                assert((Metadata*)varinfo.dinfo->getType() != debugcache.jl_pvalue_dillvmt);
                 dbuilder.insertDeclare(lv, varinfo.dinfo, dbuilder.createExpression(),
                                        topdebugloc,
                                        ctx.builder.GetInsertBlock());
@@ -8334,7 +8338,7 @@ static jl_llvm_functions_t
         if (debug_enabled && varinfo.dinfo) {
             SmallVector<uint64_t, 1> addr;
             DIExpression *expr;
-            if ((Metadata*)varinfo.dinfo->getType() != debuginfo.jl_pvalue_dillvmt)
+            if ((Metadata*)varinfo.dinfo->getType() != debugcache.jl_pvalue_dillvmt)
                 addr.push_back(llvm::dwarf::DW_OP_deref);
             expr = dbuilder.createExpression(addr);
             dbuilder.insertDeclare(av, varinfo.dinfo, expr,
@@ -8541,7 +8545,7 @@ static jl_llvm_functions_t
                         addr.push_back(llvm::dwarf::DW_OP_deref);
                         addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
                         addr.push_back((i - 1) * sizeof(void*));
-                        if ((Metadata*)vi.dinfo->getType() != debuginfo.jl_pvalue_dillvmt)
+                        if ((Metadata*)vi.dinfo->getType() != debugcache.jl_pvalue_dillvmt)
                             addr.push_back(llvm::dwarf::DW_OP_deref);
                         dbuilder.insertDeclare(pargArray, vi.dinfo, dbuilder.createExpression(addr),
                                         topdebugloc,
@@ -8627,7 +8631,7 @@ static jl_llvm_functions_t
         return (!jl_is_submodule(mod, jl_base_module) &&
                 !jl_is_submodule(mod, jl_core_module));
     };
-    auto in_tracked_path = [] (StringRef file) {
+    auto in_tracked_path = [] (StringRef file) { // falls within an explicitly set file or directory
         return jl_options.tracked_path != NULL && file.startswith(jl_options.tracked_path);
     };
     bool mod_is_user_mod = in_user_mod(ctx.module);
@@ -8636,82 +8640,108 @@ static jl_llvm_functions_t
         DebugLoc loc;
         StringRef file;
         ssize_t line;
+        ssize_t line0; // if this represents pc=1, then also cover the entry to the function (pc=0)
         bool is_user_code;
-        bool is_tracked; // falls within an explicitly set file or directory
-        unsigned inlined_at;
-        bool operator ==(const DebugLineTable &other) const {
-            return other.loc == loc && other.file == file && other.line == line && other.is_user_code == is_user_code && other.is_tracked == is_tracked && other.inlined_at == inlined_at;
-        }
+        int32_t edgeid;
+        bool sameframe(const DebugLineTable &other) const {
+            // detect if the line info for this frame is unchanged (equivalent to loc == other.loc ignoring the inlined_at field)
+            return other.edgeid == edgeid && other.line == line;
+        };
     };
-    SmallVector<DebugLineTable, 0> linetable;
-    { // populate the linetable data format
-        assert(jl_is_array(src->linetable));
-        size_t nlocs = jl_array_nrows(src->linetable);
-        std::map<std::tuple<StringRef, StringRef>, DISubprogram*> subprograms;
-        linetable.resize(nlocs + 1);
-        DebugLineTable &topinfo = linetable[0];
-        topinfo.file = ctx.file;
-        topinfo.line = toplineno;
-        topinfo.is_user_code = mod_is_user_mod;
-        topinfo.is_tracked = mod_is_tracked;
-        topinfo.inlined_at = 0;
-        topinfo.loc = topdebugloc;
-        for (size_t i = 0; i < nlocs; i++) {
-            // LineInfoNode(mod::Module, method::Any, file::Symbol, line::Int32, inlined_at::Int32)
-            jl_value_t *locinfo = jl_array_ptr_ref(src->linetable, i);
-            DebugLineTable &info = linetable[i + 1];
-            assert(jl_typetagis(locinfo, jl_lineinfonode_type));
-            jl_module_t *module = (jl_module_t*)jl_fieldref_noalloc(locinfo, 0);
-            jl_value_t *method = jl_fieldref_noalloc(locinfo, 1);
-            jl_sym_t *filesym = (jl_sym_t*)jl_fieldref_noalloc(locinfo, 2);
-            info.line = jl_unbox_int32(jl_fieldref(locinfo, 3));
-            info.inlined_at = jl_unbox_int32(jl_fieldref(locinfo, 4));
-            assert(info.inlined_at <= i);
-            info.file = jl_symbol_name(filesym);
-            if (info.file.empty())
-                info.file = "<missing>";
-            if (module == ctx.module)
-                info.is_user_code = mod_is_user_mod;
-            else
-                info.is_user_code = in_user_mod(module);
-            info.is_tracked = in_tracked_path(info.file);
-            if (debug_enabled) {
-                StringRef fname;
-                if (jl_is_method_instance(method))
-                    method = ((jl_method_instance_t*)method)->def.value;
-                if (jl_is_method(method))
-                    method = (jl_value_t*)((jl_method_t*)method)->name;
-                if (jl_is_symbol(method))
-                    fname = jl_symbol_name((jl_sym_t*)method);
-                if (fname.empty())
-                    fname = "macro expansion";
-                if (info.inlined_at == 0 && info.file == ctx.file) { // if everything matches, emit a toplevel line number
-                    info.loc = DILocation::get(ctx.builder.getContext(), info.line, 0, SP, NULL);
+    DebugLineTable topinfo;
+    topinfo.file = ctx.file;
+    topinfo.line = toplineno;
+    topinfo.line0 = 0;
+    topinfo.is_user_code = mod_is_user_mod;
+    topinfo.loc = topdebugloc;
+    topinfo.edgeid = 0;
+    std::map<std::tuple<StringRef, StringRef>, DISubprogram*> subprograms;
+    SmallVector<DebugLineTable, 0> prev_lineinfo, new_lineinfo;
+    auto update_lineinfo = [&] (size_t pc) {
+        std::function<bool(jl_debuginfo_t*, jl_value_t*, size_t, size_t)> append_lineinfo =
+                [&] (jl_debuginfo_t *debuginfo, jl_value_t *func, size_t to, size_t pc) -> bool {
+            while (1) {
+                if (!jl_is_symbol(debuginfo->def)) // this is a path
+                    func = debuginfo->def; // this is inlined
+                struct jl_codeloc_t lineidx = jl_uncompress1_codeloc(debuginfo->codelocs, pc);
+                size_t i = lineidx.line;
+                if (i < 0) // pc out of range: broken debuginfo?
+                    return false;
+                if (i == 0 && lineidx.to == 0) // no update
+                    return false;
+                if (pc > 0 && (jl_value_t*)debuginfo->linetable != jl_nothing) {
+                    // indirection node
+                    if (!append_lineinfo(debuginfo->linetable, func, to, i))
+                        return false; // no update
                 }
-                else { // otherwise, describe this as an inlining frame
-                    DISubprogram *&inl_SP = subprograms[std::make_tuple(fname, info.file)];
-                    if (inl_SP == NULL) {
-                        DIFile *difile = dbuilder.createFile(info.file, ".");
-                        inl_SP = dbuilder.createFunction(difile
-                                                     ,std::string(fname) + ";" // Name
-                                                     ,fname            // LinkageName
-                                                     ,difile           // File
-                                                     ,0                // LineNo
-                                                     ,debuginfo.jl_di_func_null_sig // Ty
-                                                     ,0                // ScopeLine
-                                                     ,DINode::FlagZero // Flags
-                                                     ,DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized // SPFlags
-                                                     ,nullptr          // Template Parameters
-                                                     ,nullptr          // Template Declaration
-                                                     ,nullptr          // ThrownTypes
-                                                     );
+                else {
+                    // actual node
+                    DebugLineTable info;
+                    info.edgeid = to;
+                    jl_module_t *modu = func ? jl_debuginfo_module1(func) : NULL;
+                    if (modu == NULL)
+                        modu = ctx.module;
+                    info.file = jl_debuginfo_file1(debuginfo);
+                    info.line = i;
+                    info.line0 = 0;
+                    if (pc == 1) {
+                        struct jl_codeloc_t lineidx = jl_uncompress1_codeloc(debuginfo->codelocs, 0);
+                        assert(lineidx.to == 0 && lineidx.pc == 0);
+                        if (lineidx.line > 0 && info.line != lineidx.line)
+                            info.line0 = lineidx.line;
+                    }
+                    if (info.file.empty())
+                        info.file = "<missing>";
+                    if (modu == ctx.module)
+                        info.is_user_code = mod_is_user_mod;
+                    else
+                        info.is_user_code = in_user_mod(modu);
+                    if (debug_enabled) {
+                        StringRef fname = jl_debuginfo_name(func);
+                        if (new_lineinfo.empty() && info.file == ctx.file) { // if everything matches, emit a toplevel line number
+                            info.loc = DILocation::get(ctx.builder.getContext(), info.line, 0, SP, NULL);
+                        }
+                        else { // otherwise, describe this as an inlining frame
+                            DebugLoc inl_loc = new_lineinfo.empty() ? DebugLoc(DILocation::get(ctx.builder.getContext(), 0, 0, SP, NULL)) : new_lineinfo.back().loc;
+                            DISubprogram *&inl_SP = subprograms[std::make_tuple(fname, info.file)];
+                            if (inl_SP == NULL) {
+                                DIFile *difile = dbuilder.createFile(info.file, ".");
+                                inl_SP = dbuilder.createFunction(difile
+                                                             ,std::string(fname) + ";" // Name
+                                                             ,fname            // LinkageName
+                                                             ,difile           // File
+                                                             ,0                // LineNo
+                                                             ,debugcache.jl_di_func_null_sig // Ty
+                                                             ,0                // ScopeLine
+                                                             ,DINode::FlagZero // Flags
+                                                             ,DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized // SPFlags
+                                                             ,nullptr          // Template Parameters
+                                                             ,nullptr          // Template Declaration
+                                                             ,nullptr          // ThrownTypes
+                                                             );
+                            }
+                            info.loc = DILocation::get(ctx.builder.getContext(), info.line, 0, inl_SP, inl_loc);
+                        }
                     }
-                    DebugLoc inl_loc = (info.inlined_at == 0) ? DebugLoc(DILocation::get(ctx.builder.getContext(), 0, 0, SP, NULL)) : linetable[info.inlined_at].loc;
-                    info.loc = DILocation::get(ctx.builder.getContext(), info.line, 0, inl_SP, inl_loc);
+                    new_lineinfo.push_back(info);
                 }
+                to = lineidx.to;
+                if (to == 0)
+                    return true;
+                pc = lineidx.pc;
+                debuginfo = (jl_debuginfo_t*)jl_svecref(debuginfo->edges, to - 1);
+                func = NULL;
             }
-        }
-    }
+        };
+        prev_lineinfo.resize(0);
+        std::swap(prev_lineinfo, new_lineinfo);
+        bool updated = append_lineinfo(src->debuginfo, (jl_value_t*)lam, 0, pc + 1);
+        if (!updated)
+            std::swap(prev_lineinfo, new_lineinfo);
+        else
+            assert(new_lineinfo.size() > 0);
+        return updated;
+    };
 
     SmallVector<MDNode*, 0> aliasscopes;
     MDNode* current_aliasscope = nullptr;
@@ -8817,44 +8847,67 @@ static jl_llvm_functions_t
                 (in_user_code && malloc_log_mode == JL_LOG_USER) ||
                 (is_tracked && malloc_log_mode == JL_LOG_PATH)));
     };
-    SmallVector<unsigned, 0> current_lineinfo, new_lineinfo;
-    auto coverageVisitStmt = [&] (size_t dbg) {
-        if (dbg == 0 || dbg >= linetable.size())
-            return;
-        // Compute inlining stack for current line, inner frame first
-        while (dbg) {
-            new_lineinfo.push_back(dbg);
-            dbg = linetable[dbg].inlined_at;
-        }
+    auto coverageVisitStmt = [&] () {
         // Visit frames which differ from previous statement as tracked in
-        // current_lineinfo (tracked outer frame first).
-        current_lineinfo.resize(new_lineinfo.size(), 0);
+        // prev_lineinfo (tracked outer frame first).
+        size_t dbg;
         for (dbg = 0; dbg < new_lineinfo.size(); dbg++) {
-            unsigned newdbg = new_lineinfo[new_lineinfo.size() - dbg - 1];
-            if (newdbg != current_lineinfo[dbg]) {
-                current_lineinfo[dbg] = newdbg;
-                const auto &info = linetable[newdbg];
-                if (do_coverage(info.is_user_code, info.is_tracked))
-                    coverageVisitLine(ctx, info.file, info.line);
+            if (dbg >= prev_lineinfo.size() || !new_lineinfo[dbg].sameframe(prev_lineinfo[dbg]))
+                break;
+        }
+        for (; dbg < new_lineinfo.size(); dbg++) {
+            const auto &newdbg = new_lineinfo[dbg];
+            bool is_tracked = in_tracked_path(newdbg.file);
+            if (do_coverage(newdbg.is_user_code, is_tracked)) {
+                if (newdbg.line0 != 0 && (dbg >= prev_lineinfo.size() || newdbg.edgeid != prev_lineinfo[dbg].edgeid || newdbg.line0 != prev_lineinfo[dbg].line))
+                    coverageVisitLine(ctx, newdbg.file, newdbg.line0);
+                coverageVisitLine(ctx, newdbg.file, newdbg.line);
             }
         }
-        new_lineinfo.clear();
     };
-    auto mallocVisitStmt = [&] (unsigned dbg, Value *sync) {
-        if (!do_malloc_log(mod_is_user_mod, mod_is_tracked) || dbg == 0) {
+    auto mallocVisitStmt = [&] (Value *sync, bool have_dbg_update) {
+        if (!do_malloc_log(mod_is_user_mod, mod_is_tracked) || !have_dbg_update) {
+            // TODD: add || new_lineinfo[0].sameframe(prev_lineinfo[0])) above, but currently this breaks the test for it (by making an optimization better)
             if (do_malloc_log(true, mod_is_tracked) && sync)
                 ctx.builder.CreateCall(prepare_call(sync_gc_total_bytes_func), {sync});
             return;
         }
-        while (linetable[dbg].inlined_at)
-            dbg = linetable[dbg].inlined_at;
-        mallocVisitLine(ctx, ctx.file, linetable[dbg].line, sync);
+        mallocVisitLine(ctx, new_lineinfo[0].file, new_lineinfo[0].line, sync);
     };
     if (coverage_mode != JL_LOG_NONE) {
         // record all lines that could be covered
-        for (const auto &info : linetable)
-            if (do_coverage(info.is_user_code, info.is_tracked))
-                jl_coverage_alloc_line(info.file, info.line);
+        std::function<void(jl_debuginfo_t *debuginfo, jl_value_t *func)> record_line_exists = [&](jl_debuginfo_t *debuginfo, jl_value_t *func) {
+            if (!jl_is_symbol(debuginfo->def)) // this is a path
+                func = debuginfo->def; // this is inlined
+            for (size_t i = 0; i < jl_svec_len(debuginfo->edges); i++) {
+                jl_debuginfo_t *edge = (jl_debuginfo_t*)jl_svecref(debuginfo->edges, i);
+                record_line_exists(edge, NULL);
+            }
+            while ((jl_value_t*)debuginfo->linetable != jl_nothing)
+                debuginfo = debuginfo->linetable;
+            jl_module_t *modu = func ? jl_debuginfo_module1(func) : NULL;
+            if (modu == NULL)
+                modu = ctx.module;
+            StringRef file = jl_debuginfo_file1(debuginfo);
+            if (file.empty())
+                file = "<missing>";
+            bool is_user_code;
+            if (modu == ctx.module)
+                is_user_code = mod_is_user_mod;
+            else
+                is_user_code = in_user_mod(modu);
+            bool is_tracked = in_tracked_path(file);
+            if (do_coverage(is_user_code, is_tracked)) {
+                for (size_t pc = 0; 1; pc++) {
+                    struct jl_codeloc_t lineidx = jl_uncompress1_codeloc(debuginfo->codelocs, pc);
+                    if (lineidx.line == -1)
+                        break;
+                    if (lineidx.line > 0)
+                        jl_coverage_alloc_line(file, lineidx.line);
+                }
+            }
+        };
+        record_line_exists(src->debuginfo, (jl_value_t*)lam);
     }
 
     come_from_bb[0] = ctx.builder.GetInsertBlock();
@@ -8906,26 +8959,20 @@ static jl_llvm_functions_t
         BB[label] = bb;
     }
 
+    new_lineinfo.push_back(topinfo);
     Value *sync_bytes = nullptr;
     if (do_malloc_log(true, mod_is_tracked))
         sync_bytes = ctx.builder.CreateCall(prepare_call(diff_gc_total_bytes_func), {});
-    { // coverage for the function definition line number
-        const auto &topinfo = linetable[0];
-        if (linetable.size() > 1) {
-            if (topinfo == linetable[1])
-                current_lineinfo.push_back(1);
-        }
-        if (do_coverage(topinfo.is_user_code, topinfo.is_tracked))
-            coverageVisitLine(ctx, topinfo.file, topinfo.line);
-    }
+    // coverage for the function definition line number (topinfo)
+    coverageVisitStmt();
 
     find_next_stmt(0);
     while (cursor != -1) {
-        int32_t debuginfoloc = jl_array_data(src->codelocs, int32_t)[cursor];
-        if (debuginfoloc > 0) {
+        bool have_dbg_update = update_lineinfo(cursor);
+        if (have_dbg_update) {
             if (debug_enabled)
-                ctx.builder.SetCurrentDebugLocation(linetable[debuginfoloc].loc);
-            coverageVisitStmt(debuginfoloc);
+                ctx.builder.SetCurrentDebugLocation(new_lineinfo.back().loc);
+            coverageVisitStmt();
         }
         ctx.noalias().aliasscope.current = aliasscopes[cursor];
         jl_value_t *stmt = jl_array_ptr_ref(stmts, cursor);
@@ -9033,7 +9080,7 @@ static jl_llvm_functions_t
                 }
             }
 
-            mallocVisitStmt(debuginfoloc, sync_bytes);
+            mallocVisitStmt(sync_bytes, have_dbg_update);
             if (toplevel || ctx.is_opaque_closure)
                 ctx.builder.CreateStore(last_age, world_age_field);
             assert(type_is_ghost(retty) || returninfo.cc == jl_returninfo_t::SRet ||
@@ -9063,7 +9110,7 @@ static jl_llvm_functions_t
             jl_value_t *cond = jl_gotoifnot_cond(stmt);
             int lname = jl_gotoifnot_label(stmt);
             Value *isfalse = emit_condition(ctx, cond, "if");
-            mallocVisitStmt(debuginfoloc, nullptr);
+            mallocVisitStmt(nullptr, have_dbg_update);
             come_from_bb[cursor+1] = ctx.builder.GetInsertBlock();
             workstack.push_back(lname - 1);
             BasicBlock *ifnot = BB[lname];
@@ -9140,7 +9187,7 @@ static jl_llvm_functions_t
         }
         else {
             emit_stmtpos(ctx, stmt, cursor);
-            mallocVisitStmt(debuginfoloc, nullptr);
+            mallocVisitStmt(nullptr, have_dbg_update);
         }
         find_next_stmt(cursor + 1);
     }
@@ -9560,6 +9607,7 @@ jl_llvm_functions_t jl_emit_codeinst(
             return jl_llvm_functions_t(); // failed
         }
     }
+    assert(jl_egal((jl_value_t*)jl_atomic_load_relaxed(&codeinst->debuginfo), (jl_value_t*)src->debuginfo) && "trying to generate code for a codeinst for an incompatible src");
     jl_llvm_functions_t decls = jl_emit_code(m, codeinst->def, src, codeinst->rettype, params,
         jl_atomic_load_relaxed(&codeinst->min_world), jl_atomic_load_relaxed(&codeinst->max_world));
 
@@ -9593,6 +9641,7 @@ jl_llvm_functions_t jl_emit_codeinst(
                 jl_options.debug_level > 1) {
                 // update the stored code
                 if (inferred != (jl_value_t*)src) {
+                    // TODO: it is somewhat unclear what it means to be mutating this
                     if (jl_is_method(def)) {
                         src = (jl_code_info_t*)jl_compress_ir(def, src);
                         assert(jl_is_string(src));
diff --git a/src/gf.c b/src/gf.c
index 88890b7e5f203..db6b5a22d4cbb 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -320,7 +320,7 @@ jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_a
 
     jl_code_instance_t *codeinst = jl_new_codeinst(mi, jl_nothing,
         (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, jl_nothing, jl_nothing,
-        0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
+        0, 1, ~(size_t)0, 0, 0, jl_nothing, 0, NULL);
     jl_mi_cache_insert(mi, codeinst);
     jl_atomic_store_relaxed(&codeinst->specptr.fptr1, fptr);
     jl_atomic_store_relaxed(&codeinst->invoke, jl_fptr_args);
@@ -442,7 +442,7 @@ JL_DLLEXPORT jl_value_t *jl_call_in_typeinf_world(jl_value_t **args, int nargs)
 
 JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
         jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_value_t *rettype,
-        size_t min_world, size_t max_world)
+        size_t min_world, size_t max_world, jl_debuginfo_t *edges)
 {
     jl_value_t *owner = jl_nothing; // TODO: owner should be arg
     jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
@@ -451,25 +451,44 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
             jl_atomic_load_relaxed(&codeinst->max_world) == max_world &&
             jl_egal(codeinst->owner, owner) &&
             jl_egal(codeinst->rettype, rettype)) {
-            return codeinst;
+            if (edges == NULL)
+                return codeinst;
+            jl_debuginfo_t *debuginfo = jl_atomic_load_relaxed(&codeinst->debuginfo);
+            if (edges == debuginfo)
+                return codeinst;
+            if (debuginfo == NULL && jl_atomic_cmpswap_relaxed(&codeinst->debuginfo, &debuginfo, edges))
+                return codeinst;
+            if (debuginfo && jl_egal((jl_value_t*)debuginfo, (jl_value_t*)edges))
+                return codeinst;
         }
         codeinst = jl_atomic_load_relaxed(&codeinst->next);
     }
     codeinst = jl_new_codeinst(
         mi, owner, rettype, (jl_value_t*)jl_any_type, NULL, NULL,
-        0, min_world, max_world, 0, 0, jl_nothing, 0);
+        0, min_world, max_world, 0, 0, jl_nothing, 0, edges);
     jl_mi_cache_insert(mi, codeinst);
     return codeinst;
 }
 
+//JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
+//        jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_code_info_t *src)
+//{
+//    // TODO: copy backedges from src to mi
+//    size_t max_world = src->max_world;
+//    if (max_world >= jl_atomic_load_acquire(&jl_world_counter))
+//        max_world = ~(size_t)0;
+//    // TODO: this should clone all fields from src that it could to avoid poisoning the IPO cache
+//    return jl_get_method_inferred(mi, src->rettype, src->min_world, max_world, src->debuginfo);
+//}
+
 JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
         jl_method_instance_t *mi, jl_value_t *owner,
         jl_value_t *rettype, jl_value_t *exctype,
         jl_value_t *inferred_const, jl_value_t *inferred,
         int32_t const_flags, size_t min_world, size_t max_world,
         uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
-        uint8_t relocatability
-        /*, jl_array_t *edges, int absolute_max*/)
+        uint8_t relocatability,
+        jl_debuginfo_t *edges /* , int absolute_max*/)
 {
     jl_task_t *ct = jl_current_task;
     assert(min_world <= max_world && "attempting to set invalid world constraints");
@@ -482,10 +501,10 @@ JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
     codeinst->rettype = rettype;
     codeinst->exctype = exctype;
     jl_atomic_store_release(&codeinst->inferred, inferred);
-    //codeinst->edges = NULL;
     if ((const_flags & 2) == 0)
         inferred_const = NULL;
     codeinst->rettype_const = inferred_const;
+    jl_atomic_store_relaxed(&codeinst->debuginfo, edges);
     jl_atomic_store_relaxed(&codeinst->specptr.fptr, NULL);
     jl_atomic_store_relaxed(&codeinst->invoke, NULL);
     if ((const_flags & 1) != 0) {
@@ -2297,16 +2316,6 @@ JL_DLLEXPORT jl_value_t *jl_matching_methods(jl_tupletype_t *types, jl_value_t *
     return ml_matches((jl_methtable_t*)mt, types, lim, include_ambiguous, 1, world, 1, min_valid, max_valid, ambig);
 }
 
-jl_method_instance_t *jl_get_unspecialized_from_mi(jl_method_instance_t *method JL_PROPAGATES_ROOT)
-{
-    jl_method_t *def = method->def.method;
-    jl_method_instance_t *mi = jl_get_unspecialized(def);
-    if (mi == NULL) {
-        return method;
-    }
-    return mi;
-}
-
 jl_method_instance_t *jl_get_unspecialized(jl_method_t *def JL_PROPAGATES_ROOT)
 {
     // one unspecialized version of a function can be shared among all cached specializations
@@ -2438,9 +2447,11 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         jl_code_instance_t *codeinst2 = jl_compile_method_internal(mi2, world);
         jl_code_instance_t *codeinst = jl_get_method_inferred(
                 mi, codeinst2->rettype,
-                jl_atomic_load_relaxed(&codeinst2->min_world), jl_atomic_load_relaxed(&codeinst2->max_world));
+                jl_atomic_load_relaxed(&codeinst2->min_world), jl_atomic_load_relaxed(&codeinst2->max_world),
+                jl_atomic_load_relaxed(&codeinst2->debuginfo));
         if (jl_atomic_load_relaxed(&codeinst->invoke) == NULL) {
             codeinst->rettype_const = codeinst2->rettype_const;
+            jl_gc_wb(codeinst, codeinst->rettype_const);
             uint8_t specsigflags = jl_atomic_load_acquire(&codeinst2->specsigflags);
             jl_callptr_t invoke = jl_atomic_load_acquire(&codeinst2->invoke);
             void *fptr = jl_atomic_load_relaxed(&codeinst2->specptr.fptr);
@@ -2486,7 +2497,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
     // if compilation is disabled or source is unavailable, try calling unspecialized version
     if (compile_option == JL_OPTIONS_COMPILE_OFF ||
         compile_option == JL_OPTIONS_COMPILE_MIN ||
-        def->source == jl_nothing) {
+        (jl_is_method(def) && def->source == jl_nothing)) {
         // copy fptr from the template method definition
         if (jl_is_method(def)) {
             jl_method_instance_t *unspecmi = jl_atomic_load_relaxed(&def->unspecialized);
@@ -2496,7 +2507,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
                 if (unspec && (unspec_invoke = jl_atomic_load_acquire(&unspec->invoke))) {
                     jl_code_instance_t *codeinst = jl_new_codeinst(mi, jl_nothing,
                         (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
-                        0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
+                        0, 1, ~(size_t)0, 0, 0, jl_nothing, 0, NULL);
                     void *unspec_fptr = jl_atomic_load_relaxed(&unspec->specptr.fptr);
                     if (unspec_fptr) {
                         // wait until invoke and specsigflags are properly set
@@ -2523,7 +2534,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         if (!jl_code_requires_compiler(src, 0)) {
             jl_code_instance_t *codeinst = jl_new_codeinst(mi, jl_nothing,
                 (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
-                0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
+                0, 1, ~(size_t)0, 0, 0, jl_nothing, 0, NULL);
             jl_atomic_store_release(&codeinst->invoke, jl_fptr_interpret_call);
             jl_mi_cache_insert(mi, codeinst);
             record_precompile_statement(mi);
@@ -2575,13 +2586,16 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         JL_GC_POP();
     }
     if (!codeinst) {
-        jl_method_instance_t *unspec = jl_get_unspecialized_from_mi(mi);
-        jl_code_instance_t *ucache = jl_get_method_inferred(unspec, (jl_value_t*)jl_any_type, 1, ~(size_t)0);
+        jl_method_instance_t *unspec = jl_get_unspecialized(def);
+        if (unspec == NULL)
+            unspec = mi;
+        jl_code_instance_t *ucache = jl_get_method_inferred(unspec, (jl_value_t*)jl_any_type, 1, ~(size_t)0, NULL);
         // ask codegen to make the fptr for unspec
         jl_callptr_t ucache_invoke = jl_atomic_load_acquire(&ucache->invoke);
         if (ucache_invoke == NULL) {
-            if (def->source == jl_nothing && (jl_atomic_load_relaxed(&ucache->def->uninferred) == jl_nothing ||
-                                              jl_atomic_load_relaxed(&ucache->def->uninferred) == NULL)) {
+            if ((!jl_is_method(def) || def->source == jl_nothing) &&
+                (jl_atomic_load_relaxed(&ucache->def->uninferred) == jl_nothing ||
+                 jl_atomic_load_relaxed(&ucache->def->uninferred) == NULL)) {
                 jl_throw(jl_new_struct(jl_missingcodeerror_type, (jl_value_t*)mi));
             }
             jl_generate_fptr_for_unspecialized(ucache);
@@ -2596,7 +2610,7 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         }
         codeinst = jl_new_codeinst(mi, jl_nothing,
             (jl_value_t*)jl_any_type, (jl_value_t*)jl_any_type, NULL, NULL,
-            0, 1, ~(size_t)0, 0, 0, jl_nothing, 0);
+            0, 1, ~(size_t)0, 0, 0, jl_nothing, 0, NULL);
         void *unspec_fptr = jl_atomic_load_relaxed(&ucache->specptr.fptr);
         if (unspec_fptr) {
             // wait until invoke and specsigflags are properly set
diff --git a/src/ircode.c b/src/ircode.c
index a89d0140e0d88..196f9f7b413ad 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -367,11 +367,6 @@ static void jl_encode_value_(jl_ircode_state *s, jl_value_t *v, int as_literal)
         write_uint8(s->s, TAG_UINT8);
         write_int8(s->s, *(int8_t*)jl_data_ptr(v));
     }
-    else if (jl_typetagis(v, jl_lineinfonode_type)) {
-        write_uint8(s->s, TAG_LINEINFO);
-        for (i = 0; i < jl_datatype_nfields(jl_lineinfonode_type); i++)
-            jl_encode_value(s, jl_get_nth_field(v, i));
-    }
     else if (((jl_datatype_t*)jl_typeof(v))->instance == v) {
         write_uint8(s->s, TAG_SINGLETON);
         jl_encode_value(s, jl_typeof(v));
@@ -666,7 +661,7 @@ static jl_value_t *jl_decode_value(jl_ircode_state *s) JL_GC_DISABLED
 {
     assert(!ios_eof(s->s));
     jl_value_t *v;
-    size_t i, n;
+    size_t n;
     uint64_t key;
     uint8_t tag = read_uint8(s->s);
     if (tag > LAST_TAG)
@@ -782,13 +777,6 @@ static jl_value_t *jl_decode_value(jl_ircode_state *s) JL_GC_DISABLED
         v = jl_alloc_string(n);
         ios_readall(s->s, jl_string_data(v), n);
         return v;
-    case TAG_LINEINFO:
-        v = jl_new_struct_uninit(jl_lineinfonode_type);
-        for (i = 0; i < jl_datatype_nfields(jl_lineinfonode_type); i++) {
-            //size_t offs = jl_field_offset(jl_lineinfonode_type, i);
-            set_nth_field(jl_lineinfonode_type, v, i, jl_decode_value(s), 0);
-        }
-        return v;
     default:
         assert(tag == TAG_GENERAL || tag == TAG_SHORT_GENERAL);
         return jl_decode_value_any(s, tag);
@@ -799,6 +787,40 @@ static jl_value_t *jl_decode_value(jl_ircode_state *s) JL_GC_DISABLED
 
 typedef jl_value_t jl_string_t; // for local expressibility
 
+static size_t codelocs_parseheader(jl_string_t *cl, int *line_offset, int *line_bytes, int *to_bytes) JL_NOTSAFEPOINT
+{
+    if (jl_string_len(cl) == 0) {
+        *line_offset = *line_bytes = *to_bytes = 0;
+        return 0;
+    }
+    int32_t header[3];
+    memcpy(&header, (char*)jl_string_data(cl), sizeof(header));
+    *line_offset = header[0];
+    if (header[1] < 255)
+        *line_bytes = 1;
+    else if (header[1] < 65535)
+        *line_bytes = 2;
+    else
+        *line_bytes = 4;
+    if (header[2] == 0)
+        *to_bytes = 0;
+    else if (header[2] < 255)
+        *to_bytes = 1;
+    else if (header[2] < 65535)
+        *to_bytes = 2;
+    else
+        *to_bytes = 4;
+    assert(jl_string_len(cl) >= sizeof(header) + *line_bytes);
+    return (jl_string_len(cl) - sizeof(header) - *line_bytes) / (*line_bytes + *to_bytes * 2); // compute nstmts
+}
+#ifndef NDEBUG
+static int codelocs_nstmts(jl_string_t *cl) JL_NOTSAFEPOINT
+{
+    int line_offset, line_bytes, to_bytes;
+    return codelocs_parseheader(cl, &line_offset, &line_bytes, &to_bytes);
+}
+#endif
+
 #define IR_DATASIZE_FLAGS         sizeof(uint8_t)
 #define IR_DATASIZE_PURITY        sizeof(uint16_t)
 #define IR_DATASIZE_INLINING_COST sizeof(uint16_t)
@@ -815,8 +837,12 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
 {
     JL_TIMING(AST_COMPRESS, AST_COMPRESS);
     JL_LOCK(&m->writelock); // protect the roots array (Might GC)
+    int isdef = code == NULL;
+    if (isdef)
+        code = (jl_code_info_t*)m->source;
     assert(jl_is_method(m));
     assert(jl_is_code_info(code));
+    assert(jl_array_nrows(code->code) == codelocs_nstmts(code->debuginfo->codelocs) || jl_string_len(code->debuginfo->codelocs) == 0);
     ios_t dest;
     ios_mem(&dest, 0);
     int en = jl_gc_enable(0); // Might GC
@@ -854,8 +880,8 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
 
     for (i = 0; i < 5; i++) {
         int copy = 1;
-        if (i == 1) { // skip codelocs
-            assert(jl_field_offset(jl_code_info_type, i) == offsetof(jl_code_info_t, codelocs));
+        if (i == 1) { // skip debuginfo
+            assert(jl_field_offset(jl_code_info_type, i) == offsetof(jl_code_info_t, debuginfo));
             continue;
         }
         jl_encode_value_(&s, jl_get_nth_field((jl_value_t*)code, i), copy);
@@ -872,22 +898,6 @@ JL_DLLEXPORT jl_string_t *jl_compress_ir(jl_method_t *m, jl_code_info_t *code)
     else
         jl_encode_value(&s, jl_nothing);
 
-    size_t nstmt = jl_array_nrows(code->code);
-    assert(nstmt == jl_array_nrows(code->codelocs));
-    if (jl_array_nrows(code->linetable) < 256) {
-        for (i = 0; i < nstmt; i++) {
-            write_uint8(s.s, jl_array_data(code->codelocs, int32_t)[i]);
-        }
-    }
-    else if (jl_array_nrows(code->linetable) < 65536) {
-        for (i = 0; i < nstmt; i++) {
-            write_uint16(s.s, jl_array_data(code->codelocs, int32_t)[i]);
-        }
-    }
-    else {
-        ios_write(s.s, (char*)jl_array_data(code->codelocs, int32_t), nstmt * sizeof(int32_t));
-    }
-
     write_uint8(s.s, s.relocatability);
 
     ios_flush(s.s);
@@ -941,7 +951,7 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
     ios_readall(s.s, jl_array_data(code->slotflags, char), nslots);
 
     for (i = 0; i < 5; i++) {
-        if (i == 1)  // skip codelocs
+        if (i == 1)  // skip debuginfo
             continue;
         assert(jl_field_isptr(jl_code_info_type, i));
         jl_value_t **fld = (jl_value_t**)((char*)jl_data_ptr(code) + jl_field_offset(jl_code_info_type, i));
@@ -955,25 +965,17 @@ JL_DLLEXPORT jl_code_info_t *jl_uncompress_ir(jl_method_t *m, jl_code_instance_t
         slotnames = m->slot_syms;
     code->slotnames = jl_uncompress_argnames(slotnames);
 
-    size_t nstmt = jl_array_nrows(code->code);
-    code->codelocs = (jl_value_t*)jl_alloc_array_1d(jl_array_int32_type, nstmt);
-    if (jl_array_nrows(code->linetable) < 256) {
-        for (i = 0; i < nstmt; i++) {
-            jl_array_data(code->codelocs, int32_t)[i] = read_uint8(s.s);
-        }
-    }
-    else if (jl_array_nrows(code->linetable) < 65536) {
-        for (i = 0; i < nstmt; i++) {
-            jl_array_data(code->codelocs, int32_t)[i] = read_uint16(s.s);
-        }
-    }
-    else {
-        ios_readall(s.s, (char*)jl_array_data(code->codelocs, int32_t), nstmt * sizeof(int32_t));
-    }
+    if (metadata)
+        code->debuginfo = jl_atomic_load_relaxed(&metadata->debuginfo);
+    else
+        code->debuginfo = m->debuginfo;
+    assert(code->debuginfo);
+    assert(jl_array_nrows(code->code) == codelocs_nstmts(code->debuginfo->codelocs) || jl_string_len(code->debuginfo->codelocs) == 0);
 
     (void) read_uint8(s.s);   // relocatability
-
+    assert(!ios_eof(s.s));
     assert(ios_getc(s.s) == -1);
+
     ios_close(s.s);
     JL_GC_PUSH1(&code);
     jl_gc_enable(en);
@@ -1108,6 +1110,245 @@ JL_DLLEXPORT jl_value_t *jl_uncompress_argname_n(jl_value_t *syms, size_t i)
     return jl_nothing;
 }
 
+// codelocs are compressed as follows:
+// The input vector is a NTuple{3,UInt32} (struct jl_codeloc_t)
+// The vector is scanned for min and max of the values for each element
+// The output is then allocated to hold (min-line, max-line, max-at) first, then line - min (in the smallest space), then the remainder (in the smallest space)
+static inline struct jl_codeloc_t unpack_codeloc(jl_string_t *cl, size_t pc, int line_offset, int line_bytes, int to_bytes) JL_NOTSAFEPOINT
+{
+    const char *ptr = jl_string_data(cl) + sizeof(int32_t[3]);
+    if (pc == 0)
+        to_bytes = 0;
+    else
+        ptr += line_bytes + (pc - 1) * (line_bytes + to_bytes * 2);
+    uint8_t int8;
+    uint16_t int16;
+    uint32_t int32;
+    struct jl_codeloc_t codeloc;
+    switch (line_bytes) {
+    case 0:
+        codeloc.line = 0;
+        break;
+    case 1:
+        memcpy(&int8, ptr, 1);
+        codeloc.line = int8;
+        break;
+    case 2:
+        memcpy(&int16, ptr, 2);
+        codeloc.line = int16;
+        break;
+    case 4:
+        memcpy(&int32, ptr, 4);
+        codeloc.line = int32;
+        break;
+    }
+    if (codeloc.line > 0)
+        codeloc.line += line_offset - 1;
+    ptr += line_bytes;
+    switch (to_bytes) {
+    case 0:
+        codeloc.to = 0;
+        break;
+    case 1:
+        memcpy(&int8, ptr, 1);
+        codeloc.to = int8;
+        break;
+    case 2:
+        memcpy(&int16, ptr, 2);
+        codeloc.to = int16;
+        break;
+    case 4:
+        memcpy(&int32, ptr, 4);
+        codeloc.to = int32;
+        break;
+    }
+    ptr += to_bytes;
+    switch (to_bytes) {
+    case 0:
+        codeloc.pc = 0;
+        break;
+    case 1:
+        memcpy(&int8, ptr, 1);
+        codeloc.pc = int8;
+        break;
+    case 2:
+        memcpy(&int16, ptr, 2);
+        codeloc.pc = int16;
+        break;
+    case 3:
+        memcpy(&int32, ptr, 4);
+        codeloc.pc = int32;
+        break;
+    }
+    ptr += to_bytes;
+    return codeloc;
+}
+
+
+static const struct jl_codeloc_t badloc = {-1, 0, 0};
+
+JL_DLLEXPORT struct jl_codeloc_t jl_uncompress1_codeloc(jl_string_t *cl, size_t pc) JL_NOTSAFEPOINT
+{
+    assert(jl_is_string(cl));
+    int line_offset, line_bytes, to_bytes;
+    size_t nstmts = codelocs_parseheader(cl, &line_offset, &line_bytes, &to_bytes);
+    if (pc > nstmts)
+        return badloc;
+    return unpack_codeloc(cl, pc, line_offset, line_bytes, to_bytes);
+}
+
+static int allzero(jl_value_t *codelocs) JL_NOTSAFEPOINT
+{
+    int32_t *p = jl_array_data(codelocs,int32_t);
+    int32_t *pend = p + jl_array_nrows(codelocs);
+    do {
+        if (*p)
+            return 0;
+    } while (++p < pend);
+    return 1;
+}
+
+JL_DLLEXPORT jl_string_t *jl_compress_codelocs(int32_t firstline, jl_value_t *codelocs, size_t nstmts) // firstline+Vector{Int32} => Memory{UInt8}
+{
+    assert(jl_typeis(codelocs, jl_array_int32_type));
+    if (jl_array_nrows(codelocs) == 0)
+        nstmts = 0;
+    assert(nstmts * 3 == jl_array_nrows(codelocs));
+    if (allzero(codelocs))
+        return jl_an_empty_string;
+    struct jl_codeloc_t codeloc, min, max;
+    size_t i;
+    min.line = min.to = min.pc = firstline <= 0 ? INT32_MAX : firstline;
+    max.line = max.to = max.pc = 0;
+    for (i = 0; i < nstmts; i++) {
+        memcpy(&codeloc, jl_array_data(codelocs,int32_t) + 3 * i, sizeof(codeloc));
+#define SETMIN(x) if (codeloc.x < min.x) min.x = codeloc.x
+#define SETMAX(x) if (codeloc.x > max.x) max.x = codeloc.x
+        if (codeloc.line > 0)
+            SETMIN(line);
+        SETMAX(line);
+        SETMIN(to);
+        SETMAX(to);
+        SETMIN(pc);
+        SETMAX(pc);
+#undef SETMIN
+#undef SETMAX
+    }
+    min.line = min.to = min.pc = firstline <= 0 ? INT32_MAX : firstline;
+    int32_t header[3];
+    header[0] = min.line > max.line ? 0 : min.line;
+    header[1] = min.line > max.line ? 0 : max.line - min.line;
+    header[2] = max.to > max.pc ? max.to : max.pc;
+    size_t line_bytes;
+    if (header[1] < 255)
+        line_bytes = 1;
+    else if (header[1] < 65535)
+        line_bytes = 2;
+    else
+        line_bytes = 4;
+    size_t to_bytes;
+    if (header[2] == 0)
+        to_bytes = 0;
+    else if (header[2] < 255)
+        to_bytes = 1;
+    else if (header[2] < 65535)
+        to_bytes = 2;
+    else
+        to_bytes = 4;
+    jl_string_t *cl = jl_alloc_string(sizeof(header) + line_bytes + nstmts * (line_bytes + to_bytes * 2));
+    // store header structure
+    memcpy(jl_string_data(cl), &header, sizeof(header));
+    // pack bytes
+    char *ptr = jl_string_data(cl) + sizeof(header);
+    uint8_t int8;
+    uint16_t int16;
+    uint32_t int32;
+    { // store firstline value
+        int8 = int16 = int32 = firstline > 0 ? firstline - header[0] + 1 : 0;
+        switch (line_bytes) {
+        case 0:
+            break;
+        case 1:
+            memcpy(ptr, &int8, 1);
+            break;
+        case 2:
+            memcpy(ptr, &int16, 2);
+            break;
+        case 4:
+            memcpy(ptr, &int32, 4);
+            break;
+        }
+        ptr += line_bytes;
+    }
+    for (i = 0; i < nstmts; i++) {
+        memcpy(&codeloc, jl_array_data(codelocs,int32_t) + 3 * i, sizeof(codeloc));
+        int8 = int16 = int32 = codeloc.line > 0 ? codeloc.line - header[0] + 1 : 0;
+        switch (line_bytes) {
+        case 0:
+            break;
+        case 1:
+            memcpy(ptr, &int8, 1);
+            break;
+        case 2:
+            memcpy(ptr, &int16, 2);
+            break;
+        case 4:
+            memcpy(ptr, &int32, 4);
+            break;
+        }
+        ptr += line_bytes;
+        int8 = int16 = int32 = codeloc.to;
+        switch (to_bytes) {
+        case 0:
+            break;
+        case 1:
+            memcpy(ptr, &int8, 1);
+            break;
+        case 2:
+            memcpy(ptr, &int16, 2);
+            break;
+        case 4:
+            memcpy(ptr, &int32, 4);
+            break;
+        }
+        ptr += to_bytes;
+        int8 = int16 = int32 = codeloc.pc;
+        switch (to_bytes) {
+        case 0:
+            break;
+        case 1:
+            memcpy(ptr, &int8, 1);
+            break;
+        case 2:
+            memcpy(ptr, &int16, 2);
+            break;
+        case 4:
+            memcpy(ptr, &int32, 4);
+            break;
+        }
+        ptr += to_bytes;
+    }
+    return cl;
+}
+
+JL_DLLEXPORT jl_value_t *jl_uncompress_codelocs(jl_string_t *cl, size_t nstmts) // Memory{UInt8} => Vector{Int32}
+{
+    assert(jl_is_string(cl));
+    int line_offset, line_bytes, to_bytes;
+    size_t nlocs = codelocs_parseheader(cl, &line_offset, &line_bytes, &to_bytes);
+    assert(nlocs == 0 || nlocs == nstmts);
+    jl_value_t *codelocs = (jl_value_t*)jl_alloc_array_1d(jl_array_int32_type, nstmts * 3);
+    size_t i;
+    for (i = 0; i < nlocs; i++) {
+        struct jl_codeloc_t codeloc = unpack_codeloc(cl, i + 1, line_offset, line_bytes, to_bytes);;
+        memcpy(jl_array_data(codelocs,int32_t) + i * 3, &codeloc, sizeof(codeloc));
+    }
+    if (nlocs == 0) {
+        memset(jl_array_data(codelocs,int32_t), 0, nstmts * sizeof(struct jl_codeloc_t));
+    }
+    return codelocs;
+}
+
 void jl_init_serializer(void)
 {
     jl_task_t *ct = jl_current_task;
@@ -1186,7 +1427,6 @@ void jl_init_serializer(void)
     deser_tag[TAG_INT32] = (jl_value_t*)jl_int32_type;
     deser_tag[TAG_INT64] = (jl_value_t*)jl_int64_type;
     deser_tag[TAG_UINT8] = (jl_value_t*)jl_uint8_type;
-    deser_tag[TAG_LINEINFO] = (jl_value_t*)jl_lineinfonode_type;
     deser_tag[TAG_UNIONALL] = (jl_value_t*)jl_unionall_type;
     deser_tag[TAG_GOTONODE] = (jl_value_t*)jl_gotonode_type;
     deser_tag[TAG_QUOTENODE] = (jl_value_t*)jl_quotenode_type;
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index c3ccb5746e37a..b7fb975515eb4 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -507,6 +507,9 @@ void jl_generate_fptr_for_unspecialized_impl(jl_code_instance_t *unspec)
         if (src) {
             assert(jl_is_code_info(src));
             ++UnspecFPtrCount;
+            jl_debuginfo_t *debuginfo = src->debuginfo;
+            jl_atomic_store_release(&unspec->debuginfo, debuginfo); // n.b. this assumes the field was previously NULL, which is not entirely true
+            jl_gc_wb(unspec, debuginfo);
             _jl_compile_codeinst(unspec, src, *jl_ExecutionEngine->getContext());
         }
         jl_callptr_t null = nullptr;
diff --git a/src/jl_exported_data.inc b/src/jl_exported_data.inc
index f40b252180a65..79ff437841879 100644
--- a/src/jl_exported_data.inc
+++ b/src/jl_exported_data.inc
@@ -35,6 +35,7 @@
     XX(jl_const_type) \
     XX(jl_core_module) \
     XX(jl_datatype_type) \
+    XX(jl_debuginfo_type) \
     XX(jl_densearray_type) \
     XX(jl_diverror_exception) \
     XX(jl_emptysvec) \
diff --git a/src/jltypes.c b/src/jltypes.c
index 33d67b179fc8b..741d48978a555 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3079,10 +3079,10 @@ void jl_init_types(void) JL_GC_DISABLED
                         jl_emptysvec, 0, 0, 2);
 
     jl_lineinfonode_type =
-        jl_new_datatype(jl_symbol("LineInfoNode"), core, jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(5, "module", "method", "file", "line", "inlined_at"),
-                        jl_svec(5, jl_module_type, jl_any_type, jl_symbol_type, jl_int32_type, jl_int32_type),
-                        jl_emptysvec, 0, 0, 5);
+        jl_new_datatype(jl_symbol("LegacyLineInfoNode"), core, jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(3, "file", "line", "inlined_at"),
+                        jl_svec(3, jl_symbol_type, jl_int32_type, jl_int32_type),
+                        jl_emptysvec, 0, 0, 3);
 
     jl_gotonode_type =
         jl_new_datatype(jl_symbol("GotoNode"), core, jl_any_type, jl_emptysvec,
@@ -3144,15 +3144,30 @@ void jl_init_types(void) JL_GC_DISABLED
                         jl_svec(1, jl_slotnumber_type),
                         jl_emptysvec, 0, 0, 1);
 
+    jl_debuginfo_type =
+        jl_new_datatype(jl_symbol("DebugInfo"), core,
+                        jl_any_type, jl_emptysvec,
+                        jl_perm_symsvec(4,
+                            "def",
+                            "linetable",
+                            "edges",
+                            "codelocs"),
+                        jl_svec(4,
+                            jl_any_type, // union(jl_method_instance_type, jl_method_type, jl_symbol_type),
+                            jl_any_type, // union(jl_nothing, jl_debuginfo_type)
+                            jl_simplevector_type, // memory{debuginfo}
+                            jl_string_type),
+                        jl_emptysvec, 0, 0, 4);
+    jl_debuginfo_type->name->mayinlinealloc = 0;
+
     jl_code_info_type =
         jl_new_datatype(jl_symbol("CodeInfo"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(20,
+                        jl_perm_symsvec(19,
                             "code",
-                            "codelocs",
+                            "debuginfo",
                             "ssavaluetypes",
                             "ssaflags",
-                            "linetable",
                             "slotnames",
                             "slotflags",
                             "slottypes",
@@ -3168,12 +3183,11 @@ void jl_init_types(void) JL_GC_DISABLED
                             "constprop",
                             "purity",
                             "inlining_cost"),
-                        jl_svec(20,
+                        jl_svec(19,
                             jl_array_any_type,
-                            jl_array_int32_type,
+                            jl_debuginfo_type,
                             jl_any_type,
                             jl_array_uint32_type,
-                            jl_any_type,
                             jl_array_symbol_type,
                             jl_array_uint8_type,
                             jl_any_type,
@@ -3190,12 +3204,12 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_uint16_type,
                             jl_uint16_type),
                         jl_emptysvec,
-                        0, 1, 20);
+                        0, 1, 19);
 
     jl_method_type =
         jl_new_datatype(jl_symbol("Method"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(30,
+                        jl_perm_symsvec(31,
                             "name",
                             "module",
                             "file",
@@ -3208,6 +3222,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             "slot_syms",
                             "external_mt",
                             "source", // !const
+                            "debuginfo", // !const
                             "unspecialized", // !const
                             "generator", // !const
                             "roots", // !const
@@ -3226,7 +3241,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             "constprop",
                             "max_varargs",
                             "purity"),
-                        jl_svec(30,
+                        jl_svec(31,
                             jl_symbol_type,
                             jl_module_type,
                             jl_symbol_type,
@@ -3239,6 +3254,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_string_type,
                             jl_any_type,
                             jl_any_type,
+                            jl_debuginfo_type,
                             jl_any_type, // jl_method_instance_type
                             jl_any_type,
                             jl_array_any_type,
@@ -3259,7 +3275,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_uint16_type),
                         jl_emptysvec,
                         0, 1, 10);
-    //const static uint32_t method_constfields[1] = { 0x03fc065f }; // (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<6)|(1<<9)|(1<<10)|(1<<18)|(1<<19)|(1<<20)|(1<<21)|(1<<22)|(1<<23)|(1<<24)|(1<<25);
+    //const static uint32_t method_constfields[1] = { 0b0 }; // (1<<0)|(1<<1)|(1<<2)|(1<<3)|(1<<6)|(1<<9)|(1<<10)|(1<<17)|(1<<21)|(1<<22)|(1<<23)|(1<<24)|(1<<25)|(1<<26)|(1<<27)|(1<<28)|(1<<29)|(1<<30);
     //jl_method_type->name->constfields = method_constfields;
     const static uint32_t method_atomicfields[1] = { 0x00000030 }; // (1<<4)|(1<<5)
     jl_method_type->name->atomicfields = method_atomicfields;
@@ -3283,7 +3299,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_simplevector_type,
                             jl_any_type,
                             jl_array_any_type,
-                            jl_any_type,
+                            jl_any_type/*jl_code_instance_type*/,
                             jl_bool_type,
                             jl_bool_type,
                             jl_bool_type),
@@ -3299,7 +3315,7 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_code_instance_type =
         jl_new_datatype(jl_symbol("CodeInstance"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(17,
+                        jl_perm_symsvec(18,
                             "def",
                             "owner",
                             "next",
@@ -3309,13 +3325,13 @@ void jl_init_types(void) JL_GC_DISABLED
                             "exctype",
                             "rettype_const",
                             "inferred",
-                            //"edges",
+                            "debuginfo", // TODO: rename to edges?
                             //"absolute_max",
                             "ipo_purity_bits", "purity_bits",
                             "analysis_results",
                             "specsigflags", "precompile", "relocatability",
                             "invoke", "specptr"), // function object decls
-                        jl_svec(17,
+                        jl_svec(18,
                             jl_method_instance_type,
                             jl_any_type,
                             jl_any_type,
@@ -3325,7 +3341,7 @@ void jl_init_types(void) JL_GC_DISABLED
                             jl_any_type,
                             jl_any_type,
                             jl_any_type,
-                            //jl_any_type,
+                            jl_debuginfo_type,
                             //jl_bool_type,
                             jl_uint32_type, jl_uint32_type,
                             jl_any_type,
@@ -3336,10 +3352,11 @@ void jl_init_types(void) JL_GC_DISABLED
                         jl_emptysvec,
                         0, 1, 1);
     jl_svecset(jl_code_instance_type->types, 2, jl_code_instance_type);
-    const static uint32_t code_instance_constfields[1]  = { 0b00000101011100011 }; // Set fields 1, 2, 6-8, 10, 12 as const
-    const static uint32_t code_instance_atomicfields[1] = { 0b11011010100011100 }; // Set fields 3-5, 9, 11, 13-14, 16-17 as atomic
+    const static uint32_t code_instance_constfields[1]  = { 0b000001010011100011 }; // Set fields 1, 2, 6-8, 11, 13 as const
+    const static uint32_t code_instance_atomicfields[1] = { 0b110110101100011100 }; // Set fields 3-5, 9, 10, 12, 14-15, 17-18 as atomic
     //Fields 4-5 are only operated on by construction and deserialization, so are const at runtime
-    //Fields 12 and 16 must be protected by locks, and thus all operations on jl_code_instance_t are threadsafe
+    //Fields 13 and 17 must be protected by locks, and thus all operations on jl_code_instance_t are threadsafe
+    //Except for field 9 (inferred), which is volatile unless you know which other places are currently using it
     jl_code_instance_type->name->constfields = code_instance_constfields;
     jl_code_instance_type->name->atomicfields = code_instance_atomicfields;
 
@@ -3477,10 +3494,11 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_svecset(jl_methtable_type->types, 8, jl_long_type); // uint32_t plus alignment
     jl_svecset(jl_methtable_type->types, 9, jl_uint8_type);
     jl_svecset(jl_methtable_type->types, 10, jl_uint8_type);
-    jl_svecset(jl_method_type->types, 12, jl_method_instance_type);
+    jl_svecset(jl_method_type->types, 13, jl_method_instance_type);
+    //jl_svecset(jl_debuginfo_type->types, 0, jl_method_instance_type); // union(jl_method_instance_type, jl_method_type, jl_symbol_type)
     jl_svecset(jl_method_instance_type->types, 5, jl_code_instance_type);
-    jl_svecset(jl_code_instance_type->types, 15, jl_voidpointer_type);
     jl_svecset(jl_code_instance_type->types, 16, jl_voidpointer_type);
+    jl_svecset(jl_code_instance_type->types, 17, jl_voidpointer_type);
     jl_svecset(jl_binding_type->types, 1, jl_globalref_type);
     jl_svecset(jl_binding_type->types, 2, jl_binding_type);
 
@@ -3509,9 +3527,6 @@ void jl_init_types(void) JL_GC_DISABLED
     // Module object identity is determined by its name and parent name.
     jl_module_type->isidentityfree = 1;
 
-    // override the preferred layout for a couple types
-    jl_lineinfonode_type->name->mayinlinealloc = 0; // FIXME: assumed to be a pointer by codegen
-
     export_jl_small_typeof();
 }
 
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index d3d4f7dfe3a56..079d4155fa6d0 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -5021,13 +5021,13 @@ f(x) = yt(x)
              (list ,@(cadr vi)) ,(caddr vi) (list ,@(cadddr vi)))
        ,@(cdddr lam))))
 
-(define (make-lineinfo name file line (inlined-at #f))
-  `(lineinfo (thismodule) ,(if inlined-at '|macro expansion| name) ,file ,line ,(or inlined-at 0)))
+(define (make-lineinfo file line (inlined-at #f))
+  `(lineinfo ,file ,line ,(or inlined-at 0)))
 
 (define (set-lineno! lineinfo num)
-  (set-car! (cddddr lineinfo) num))
+  (set-car! (cddr lineinfo) num))
 
-(define (compact-ir body name file line)
+(define (compact-ir body file line)
   (let ((code         '(block))
         (locs         '(list))
         (linetable    '(list))
@@ -5044,7 +5044,7 @@ f(x) = yt(x)
       (or e (raise "missing value in IR"))
       (if (and (null? (cdr linetable))
                (not (and (pair? e) (eq? (car e) 'meta))))
-          (begin (set! linetable (cons (make-lineinfo name file line) linetable))
+          (begin (set! linetable (cons (make-lineinfo file line) linetable))
                  (set! linetablelen (+ linetablelen 1))
                  (set! current-loc 1)))
       (set! code (cons e code))
@@ -5071,8 +5071,8 @@ f(x) = yt(x)
                             (if (pair? (cddr e))
                                 (set! current-file (caddr e)))
                             (set! linetable (cons (if (null? locstack)
-                                                      (make-lineinfo name current-file current-line)
-                                                      (make-lineinfo name current-file current-line (caar locstack)))
+                                                      (make-lineinfo current-file current-line)
+                                                      (make-lineinfo current-file current-line (caar locstack)))
                                                   linetable))
                             (set! linetablelen (+ linetablelen 1))
                             (set! current-loc linetablelen)))))
@@ -5080,7 +5080,7 @@ f(x) = yt(x)
                    (set! locstack (cons (list current-loc current-line current-file) locstack))
                    (set! current-file (caddr e))
                    (set! current-line 0)
-                   (set! linetable (cons (make-lineinfo name current-file current-line current-loc) linetable))
+                   (set! linetable (cons (make-lineinfo current-file current-line current-loc) linetable))
                    (set! linetablelen (+ linetablelen 1))
                    (set! current-loc linetablelen))
                   ((and (length= e 2) (eq? (car e) 'meta) (eq? (cadr e) 'pop_loc))
@@ -5106,7 +5106,6 @@ f(x) = yt(x)
 
 (define (renumber-lambda lam file line)
   (let* ((stuff (compact-ir (lam:body lam)
-                            (if (null? (cadr lam)) '|top-level scope| 'none)
                             file line))
          (code (aref stuff 0))
          (locs (aref stuff 1))
diff --git a/src/julia.h b/src/julia.h
index 7d246d25cc767..cf0317b6ad9fd 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -250,6 +250,19 @@ typedef struct _jl_line_info_node_t {
     int32_t inlined_at;
 } jl_line_info_node_t;
 
+struct jl_codeloc_t {
+    int32_t line;
+    int32_t to;
+    int32_t pc;
+};
+
+typedef struct _jl_debuginfo_t {
+    jl_value_t *def;
+    struct _jl_debuginfo_t *linetable; // or nothing
+    jl_svec_t *edges; // Memory{DebugInfo}
+    jl_value_t *codelocs; // String // Memory{UInt8} // compressed info
+} jl_debuginfo_t;
+
 // the following mirrors `struct EffectsOverride` in `base/compiler/effects.jl`
 typedef union __jl_purity_overrides_t {
     struct {
@@ -277,7 +290,7 @@ typedef union __jl_purity_overrides_t {
 typedef struct _jl_code_info_t {
     // ssavalue-indexed arrays of properties:
     jl_array_t *code;  // Any array of statements
-    jl_value_t *codelocs; // Int32 array of indices into the line table
+    jl_debuginfo_t *debuginfo; // Table of edge data for each statement
     jl_value_t *ssavaluetypes; // types of ssa values (or count of them)
     jl_array_t *ssaflags; // 32 bits flags associated with each statement:
         // 1 << 0 = inbounds region
@@ -294,7 +307,6 @@ typedef struct _jl_code_info_t {
         // 1 << 11 = :inaccessiblemem_or_argmemonly
         // 1 << 12-19 = callsite effects overrides
     // miscellaneous data:
-    jl_value_t *linetable; // Table of locations [TODO: make this volatile like slotnames]
     jl_array_t *slotnames; // names of local variables
     jl_array_t *slotflags;  // local var bit flags
     // the following are optional transient properties (not preserved by compression--as they typically get stored elsewhere):
@@ -305,7 +317,7 @@ typedef struct _jl_code_info_t {
     // They are not used by any other part of the system and may be moved elsewhere in the
     // future.
     jl_value_t *method_for_inference_limit_heuristics; // optional method used during inference
-    jl_value_t *edges; // forward edges to method instances that must be invalidated
+    jl_value_t *edges; // forward edges to method instances that must be invalidated (for copying to debuginfo)
     size_t min_world;
     size_t max_world;
 
@@ -342,6 +354,7 @@ typedef struct _jl_method_t {
     jl_value_t *slot_syms; // compacted list of slot names (String)
     jl_value_t *external_mt; // reference to the method table this method is part of, null if part of the internal table
     jl_value_t *source;  // original code template (jl_code_info_t, but may be compressed), null for builtins
+    jl_debuginfo_t *debuginfo;  // fixed linetable from the source argument, null if not available
     _Atomic(jl_method_instance_t*) unspecialized;  // unspecialized executable method instance, or null
     jl_value_t *generator;  // executable code-generating function if available
     jl_array_t *roots;  // pointers in generated code (shared to reduce memory), or null
@@ -437,7 +450,7 @@ typedef struct _jl_code_instance_t {
     //               deleted to save space.
     // - null, indicating that inference was not yet completed or did not succeed
     _Atomic(jl_value_t *) inferred;
-    //TODO: jl_array_t *edges; // stored information about edges from this object
+    _Atomic(jl_debuginfo_t *) debuginfo; // stored information about edges from this object (set once, with a happens-before both source and invoke)
     //TODO: uint8_t absolute_max; // whether true max world is unknown
 
     // purity results
@@ -827,6 +840,7 @@ extern JL_DLLIMPORT jl_value_t *jl_bottom_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_method_instance_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_code_instance_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_code_info_type JL_GLOBALLY_ROOTED;
+extern JL_DLLIMPORT jl_datatype_t *jl_debuginfo_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_method_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_datatype_t *jl_module_type JL_GLOBALLY_ROOTED;
 extern JL_DLLIMPORT jl_unionall_t *jl_addrspace_type JL_GLOBALLY_ROOTED;
@@ -2150,7 +2164,9 @@ JL_DLLEXPORT uint8_t jl_ir_slotflag(jl_value_t *data, size_t i) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_compress_argnames(jl_array_t *syms);
 JL_DLLEXPORT jl_array_t *jl_uncompress_argnames(jl_value_t *syms);
 JL_DLLEXPORT jl_value_t *jl_uncompress_argname_n(jl_value_t *syms, size_t i);
-
+JL_DLLEXPORT struct jl_codeloc_t jl_uncompress1_codeloc(jl_value_t *cl, size_t pc) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_value_t *jl_compress_codelocs(int32_t firstline, jl_value_t *codelocs, size_t nstmts);
+JL_DLLEXPORT jl_value_t *jl_uncompress_codelocs(jl_value_t *cl, size_t nstmts);
 
 JL_DLLEXPORT int jl_is_operator(const char *sym);
 JL_DLLEXPORT int jl_is_unary_operator(const char *sym);
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 76556e288f387..6fdb65903636b 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -651,17 +651,21 @@ JL_DLLEXPORT jl_code_instance_t *jl_type_infer(jl_method_instance_t *li, size_t
 JL_DLLEXPORT jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *meth JL_PROPAGATES_ROOT, size_t world);
 JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
         jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_value_t *rettype,
-        size_t min_world, size_t max_world);
-jl_method_instance_t *jl_get_unspecialized_from_mi(jl_method_instance_t *method JL_PROPAGATES_ROOT);
+        size_t min_world, size_t max_world, jl_debuginfo_t *edges);
 jl_method_instance_t *jl_get_unspecialized(jl_method_t *def JL_PROPAGATES_ROOT);
 
-JL_DLLEXPORT jl_code_instance_t* jl_new_codeinst(
+JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
         jl_method_instance_t *mi, jl_value_t *owner,
         jl_value_t *rettype, jl_value_t *exctype,
         jl_value_t *inferred_const, jl_value_t *inferred,
         int32_t const_flags, size_t min_world, size_t max_world,
         uint32_t ipo_effects, uint32_t effects, jl_value_t *analysis_results,
-        uint8_t relocatability);
+        uint8_t relocatability, jl_debuginfo_t *edges /* , int absolute_max*/);
+
+JL_DLLEXPORT const char *jl_debuginfo_file(jl_debuginfo_t *debuginfo) JL_NOTSAFEPOINT;
+JL_DLLEXPORT const char *jl_debuginfo_file1(jl_debuginfo_t *debuginfo) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_module_t *jl_debuginfo_module1(jl_value_t *debuginfo_def) JL_NOTSAFEPOINT;
+JL_DLLEXPORT const char *jl_debuginfo_name(jl_value_t *func) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT void jl_compile_method_instance(jl_method_instance_t *mi, jl_tupletype_t *types, size_t world);
 JL_DLLEXPORT int jl_compile_hint(jl_tupletype_t *types);
diff --git a/src/method.c b/src/method.c
index ab9487bbecad4..ee0ac11c368cb 100644
--- a/src/method.c
+++ b/src/method.c
@@ -290,20 +290,140 @@ jl_value_t *expr_arg1(jl_value_t *expr) {
     return jl_array_ptr_ref(args, 0);
 }
 
+static jl_value_t *alloc_edges(arraylist_t *edges_list)
+{
+    jl_value_t *jledges = (jl_value_t*)jl_alloc_svec(edges_list->len);
+    jl_value_t *jledges2 = NULL;
+    jl_value_t *codelocs = NULL;
+    JL_GC_PUSH3(&jledges, &jledges2, &codelocs);
+    size_t i;
+    for (i = 0; i < edges_list->len; i++) {
+        arraylist_t *edge = (arraylist_t*)edges_list->items[i];
+        jl_value_t *file = (jl_value_t*)edge->items[0];
+        int32_t line = 0; // not preserved by lowering (and probably lost even before that)
+        arraylist_t *edges_list2 = (arraylist_t*)edge->items[1];
+        size_t j, nlocs = (edge->len - 2) / 3;
+        codelocs = (jl_value_t*)jl_alloc_array_1d(jl_array_int32_type, nlocs * 3);
+        for (j = 0; j < nlocs; j++) {
+            jl_array_data(codelocs,int32_t)[3 * j + 0] = (intptr_t)edge->items[3 * j + 0 + 2];
+            jl_array_data(codelocs,int32_t)[3 * j + 1] = (intptr_t)edge->items[3 * j + 1 + 2];
+            jl_array_data(codelocs,int32_t)[3 * j + 2] = (intptr_t)edge->items[3 * j + 2 + 2];
+        }
+        codelocs = (jl_value_t*)jl_compress_codelocs(line, codelocs, nlocs);
+        jledges2 = alloc_edges(edges_list2);
+        jl_value_t *debuginfo = jl_new_struct(jl_debuginfo_type, file, jl_nothing, jledges2, codelocs);
+        jledges2 = NULL;
+        jl_svecset(jledges, i, debuginfo);
+        free(edges_list2);
+        free(edge);
+    }
+    JL_GC_POP();
+    return jledges;
+}
+
+static void add_edge(arraylist_t *edges_list, arraylist_t *inlinestack, int32_t *p_to, int32_t *p_pc)
+{
+    jl_value_t *locinfo = (jl_value_t*)arraylist_pop(inlinestack);
+    jl_sym_t *filesym = (jl_sym_t*)jl_fieldref_noalloc(locinfo, 0);
+    int32_t line = jl_unbox_int32(jl_fieldref(locinfo, 1));
+    size_t i;
+    arraylist_t *edge = NULL;
+    for (i = 0; i < edges_list->len; i++) {
+        edge = (arraylist_t*)edges_list->items[i];
+        if (edge->items[0] == filesym)
+            break;
+    }
+    if (i == edges_list->len) {
+        edge = (arraylist_t*)malloc(sizeof(arraylist_t));
+        arraylist_t *edge_list2 = (arraylist_t*)malloc(sizeof(arraylist_t));
+        arraylist_new(edge, 0);
+        arraylist_new(edge_list2, 0);
+        arraylist_push(edge, (void*)filesym);
+        arraylist_push(edge, (void*)edge_list2);
+        arraylist_push(edges_list, (void*)edge);
+    }
+    *p_to = i + 1;
+    int32_t to = 0, pc = 0;
+    if (inlinestack->len) {
+        arraylist_t *edge_list2 = (arraylist_t*)edge->items[1];
+        add_edge(edge_list2, inlinestack, &to, &pc);
+    }
+    for (i = 2; i < edge->len; i += 3) {
+        if ((intptr_t)edge->items[i + 0] == line &&
+            (intptr_t)edge->items[i + 1] == to &&
+            (intptr_t)edge->items[i + 2] == pc) {
+            break;
+        }
+    }
+    if (i == edge->len) {
+        arraylist_push(edge, (void*)(intptr_t)line);
+        arraylist_push(edge, (void*)(intptr_t)to);
+        arraylist_push(edge, (void*)(intptr_t)pc);
+    }
+    *p_pc = (i - 2) / 3 + 1;
+}
+
+jl_debuginfo_t *jl_linetable_to_debuginfo(jl_array_t *codelocs_any, jl_array_t *linetable)
+{
+    size_t nlocs = jl_array_nrows(codelocs_any);
+    jl_value_t *toplocinfo = jl_array_ptr_ref(linetable, 0);
+    jl_sym_t *topfile = (jl_sym_t*)jl_fieldref_noalloc(toplocinfo, 0);
+    int32_t topline = jl_unbox_int32(jl_fieldref(toplocinfo, 1));
+    arraylist_t inlinestack;
+    arraylist_new(&inlinestack, 0);
+    arraylist_t edges_list;
+    arraylist_new(&edges_list, 0);
+    jl_value_t *jledges = NULL;
+    jl_value_t *codelocs = (jl_value_t*)jl_alloc_array_1d(jl_array_int32_type, nlocs * 3);
+    jl_debuginfo_t *debuginfo = NULL;
+    JL_GC_PUSH3(&jledges, &codelocs, &debuginfo);
+    int32_t *codelocs32 = jl_array_data(codelocs,int32_t);
+    size_t j;
+    for (j = 0; j < nlocs; j++) {
+        size_t lineidx = jl_unbox_long(jl_array_ptr_ref((jl_array_t*)codelocs_any, j)); // 1 indexed!
+        while (lineidx != 0) {
+            jl_value_t *locinfo = jl_array_ptr_ref(linetable, lineidx - 1);
+            lineidx = jl_unbox_int32(jl_fieldref(locinfo, 2));
+            arraylist_push(&inlinestack, locinfo);
+        }
+        int32_t line = 0, to = 0, pc = 0;
+        if (inlinestack.len) {
+            jl_value_t *locinfo = (jl_value_t*)arraylist_pop(&inlinestack);
+            jl_sym_t *filesym = (jl_sym_t*)jl_fieldref_noalloc(locinfo, 0);
+            if (filesym == topfile)
+                line = jl_unbox_int32(jl_fieldref(locinfo, 1));
+            else
+                arraylist_push(&inlinestack, locinfo);
+            if (inlinestack.len) {
+                add_edge(&edges_list, &inlinestack, &to, &pc);
+            }
+        }
+        codelocs32[j * 3 + 0] = line;
+        codelocs32[j * 3 + 1] = to;
+        codelocs32[j * 3 + 2] = pc;
+    }
+    codelocs = (jl_value_t*)jl_compress_codelocs(topline, codelocs, nlocs);
+    jledges = alloc_edges(&edges_list);
+    debuginfo = (jl_debuginfo_t*)jl_new_struct(jl_debuginfo_type, topfile, jl_nothing, jledges, codelocs);
+    JL_GC_POP();
+    return debuginfo;
+}
+
 // copy a :lambda Expr into its CodeInfo representation,
 // including popping of known meta nodes
-static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
+jl_code_info_t *jl_new_code_info_from_ir(jl_expr_t *ir)
 {
+    jl_code_info_t *li = NULL;
+    JL_GC_PUSH1(&li);
+    li = jl_new_code_info_uninit();
     assert(jl_is_expr(ir));
     jl_expr_t *bodyex = (jl_expr_t*)jl_exprarg(ir, 2);
-    jl_value_t *codelocs = jl_exprarg(ir, 3);
-    li->linetable = jl_exprarg(ir, 4);
-    size_t nlocs = jl_array_nrows(codelocs);
-    li->codelocs = (jl_value_t*)jl_alloc_array_1d(jl_array_int32_type, nlocs);
-    size_t j;
-    for (j = 0; j < nlocs; j++) {
-        jl_array_uint32_set((jl_array_t*)li->codelocs, j, jl_unbox_long(jl_array_ptr_ref((jl_array_t*)codelocs, j)));
-    }
+
+    jl_array_t *codelocs_any = (jl_array_t*)jl_exprarg(ir, 3);
+    jl_array_t *linetable = (jl_array_t*)jl_exprarg(ir, 4);
+    li->debuginfo = jl_linetable_to_debuginfo(codelocs_any, linetable);
+    jl_gc_wb(li, li->debuginfo);
+
     assert(jl_is_expr(bodyex));
     jl_array_t *body = bodyex->args;
     li->code = body;
@@ -318,6 +438,7 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
     // last(inline_flags) == 0: callsite noinline region
     arraylist_t *inline_flags = arraylist_new((arraylist_t*)malloc_s(sizeof(arraylist_t)), 0);
     arraylist_t *purity_exprs = arraylist_new((arraylist_t*)malloc_s(sizeof(arraylist_t)), 0);
+    size_t j;
     for (j = 0; j < n; j++) {
         jl_value_t *st = bd[j];
         int is_flag_stmt = 0;
@@ -472,6 +593,8 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir)
         jl_array_ptr_set(li->slotnames, i, name);
         jl_array_uint8_set(li->slotflags, i, vinfo_mask & jl_unbox_long(jl_array_ptr_ref(vi, 2)));
     }
+    JL_GC_POP();
+    return li;
 }
 
 JL_DLLEXPORT jl_method_instance_t *jl_new_method_instance_uninit(void)
@@ -499,11 +622,10 @@ JL_DLLEXPORT jl_code_info_t *jl_new_code_info_uninit(void)
         (jl_code_info_t*)jl_gc_alloc(ct->ptls, sizeof(jl_code_info_t),
                                        jl_code_info_type);
     src->code = NULL;
-    src->codelocs = NULL;
+    src->debuginfo = NULL;
     src->ssavaluetypes = NULL;
     src->ssaflags = NULL;
     src->method_for_inference_limit_heuristics = jl_nothing;
-    src->linetable = jl_nothing;
     src->slotflags = NULL;
     src->slotnames = NULL;
     src->slottypes = jl_nothing;
@@ -521,40 +643,6 @@ JL_DLLEXPORT jl_code_info_t *jl_new_code_info_uninit(void)
     return src;
 }
 
-jl_code_info_t *jl_new_code_info_from_ir(jl_expr_t *ir)
-{
-    jl_code_info_t *src = NULL;
-    JL_GC_PUSH1(&src);
-    src = jl_new_code_info_uninit();
-    jl_code_info_set_ir(src, ir);
-    JL_GC_POP();
-    return src;
-}
-
-void jl_add_function_to_lineinfo(jl_code_info_t *ci, jl_value_t *func)
-{
-    // func may contain jl_symbol (function name), jl_method_t, or jl_method_instance_t
-    jl_array_t *li = (jl_array_t*)ci->linetable;
-    size_t i, n = jl_array_nrows(li);
-    jl_value_t *rt = NULL, *lno = NULL, *inl = NULL;
-    JL_GC_PUSH3(&rt, &lno, &inl);
-    for (i = 0; i < n; i++) {
-        jl_value_t *ln = jl_array_ptr_ref(li, i);
-        assert(jl_typetagis(ln, jl_lineinfonode_type));
-        jl_value_t *mod = jl_fieldref_noalloc(ln, 0);
-        jl_value_t *file = jl_fieldref_noalloc(ln, 2);
-        lno = jl_fieldref(ln, 3);
-        inl = jl_fieldref(ln, 4);
-        // respect a given linetable if available
-        jl_value_t *ln_func = jl_fieldref_noalloc(ln, 1);
-        if (jl_is_symbol(ln_func) && (jl_sym_t*)ln_func == jl_symbol("none") && jl_is_int32(inl) && jl_unbox_int32(inl) == 0)
-            ln_func = func;
-        rt = jl_new_struct(jl_lineinfonode_type, mod, ln_func, file, lno, inl);
-        jl_array_ptr_set(li, i, rt);
-    }
-    JL_GC_POP();
-}
-
 // invoke (compiling if necessary) the jlcall function pointer for a method template
 static jl_value_t *jl_call_staged(jl_method_t *def, jl_value_t *generator,
         size_t world, jl_svec_t *sparam_vals, jl_value_t **args, uint32_t nargs)
@@ -644,7 +732,6 @@ JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo, siz
                 jl_error("The function body AST defined by this @generated function is not pure. This likely means it contains a closure, a comprehension or a generator.");
             }
         }
-        jl_add_function_to_lineinfo(func, (jl_value_t*)def->name);
 
         // If this generated function has an opaque closure, cache it for
         // correctness of method identity
@@ -723,7 +810,6 @@ JL_DLLEXPORT void jl_method_set_source(jl_method_t *m, jl_code_info_t *src)
     m->nospecializeinfer = src->nospecializeinfer;
     m->constprop = src->constprop;
     m->purity.bits = src->purity.bits;
-    jl_add_function_to_lineinfo(src, (jl_value_t*)m->name);
 
     jl_array_t *copy = NULL;
     jl_svec_t *sparam_vars = jl_outer_unionall_vars(m->sig);
@@ -811,11 +897,17 @@ JL_DLLEXPORT void jl_method_set_source(jl_method_t *m, jl_code_info_t *src)
     jl_gc_wb(src, copy);
     m->slot_syms = jl_compress_argnames(src->slotnames);
     jl_gc_wb(m, m->slot_syms);
-    if (gen_only)
+    if (gen_only) {
         m->source = NULL;
-    else
-        m->source = (jl_value_t*)jl_compress_ir(m, src);
-    jl_gc_wb(m, m->source);
+    }
+    else {
+        m->debuginfo = src->debuginfo;
+        jl_gc_wb(m, m->debuginfo);
+        m->source = (jl_value_t*)src;
+        jl_gc_wb(m, m->source);
+        m->source = (jl_value_t*)jl_compress_ir(m, NULL);
+        jl_gc_wb(m, m->source);
+    }
     JL_GC_POP();
 }
 
@@ -835,6 +927,7 @@ JL_DLLEXPORT jl_method_t *jl_new_method_uninit(jl_module_t *module)
     m->module = module;
     m->external_mt = NULL;
     m->source = NULL;
+    m->debuginfo = NULL;
     jl_atomic_store_relaxed(&m->unspecialized, NULL);
     m->generator = NULL;
     m->name = NULL;
diff --git a/src/opaque_closure.c b/src/opaque_closure.c
index 2c70a053eb970..656eb91a2f1f3 100644
--- a/src/opaque_closure.c
+++ b/src/opaque_closure.c
@@ -105,7 +105,7 @@ static jl_opaque_closure_t *new_opaque_closure(jl_tupletype_t *argt, jl_value_t
         jl_method_instance_t *mi_generic = jl_specializations_get_linfo(jl_opaque_closure_method, sigtype, jl_emptysvec);
 
         // OC wrapper methods are not world dependent
-        ci = jl_get_method_inferred(mi_generic, selected_rt, 1, ~(size_t)0);
+        ci = jl_get_method_inferred(mi_generic, selected_rt, 1, ~(size_t)0, NULL);
         if (!jl_atomic_load_acquire(&ci->invoke))
             jl_compile_codeinst(ci);
         specptr = jl_atomic_load_relaxed(&ci->specptr.fptr);
@@ -150,7 +150,7 @@ JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tuplet
         sigtype = jl_argtype_with_function(env, (jl_value_t*)argt);
         jl_method_instance_t *mi = jl_specializations_get_linfo((jl_method_t*)root, sigtype, jl_emptysvec);
         inst = jl_new_codeinst(mi, jl_nothing, rt_ub, (jl_value_t*)jl_any_type, NULL, (jl_value_t*)ci,
-            0, world, world, 0, 0, jl_nothing, 0);
+            0, world, world, 0, 0, jl_nothing, 0, ci->debuginfo);
         jl_mi_cache_insert(mi, inst);
     }
 
diff --git a/src/rtutils.c b/src/rtutils.c
index 1ab881e613564..9e76f513419c0 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -864,6 +864,17 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
             }
             return n;
         }
+        if (jl_genericmemory_type && dv->name == jl_genericmemory_typename) {
+            jl_value_t *isatomic = jl_tparam0(dv);
+            jl_value_t *el_type = jl_tparam1(dv);
+            jl_value_t *addrspace = jl_tparam2(dv);
+            if (isatomic == (jl_value_t*)jl_not_atomic_sym && addrspace && jl_is_addrspacecore(addrspace) && jl_unbox_uint8(addrspace) == 0) {
+                n += jl_printf(out, "Memory{");
+                n += jl_static_show_x(out, el_type, depth, ctx);
+                n += jl_printf(out, "}");
+                return n;
+            }
+        }
         if (ctx.quiet) {
             return jl_static_show_symbol(out, dv->name->name);
         }
@@ -1104,7 +1115,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     }
     else if (jl_genericmemoryref_type && jl_is_genericmemoryref_type(vt)) {
         jl_genericmemoryref_t *ref = (jl_genericmemoryref_t*)v;
-        n += jl_printf(out, "MemoryRef(offset=");
+        n += jl_printf(out, "GenericMemoryRef(offset=");
         size_t offset = (size_t)ref->ptr_or_offset;
         if (ref->mem) {
             const jl_datatype_layout_t *layout = ((jl_datatype_t*)jl_typeof(ref->mem))->layout;
@@ -1117,30 +1128,19 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
     }
     else if (jl_genericmemory_type && jl_is_genericmemory_type(vt)) {
         jl_genericmemory_t *m = (jl_genericmemory_t*)v;
-        jl_value_t *isatomic = jl_tparam0(vt);
-        jl_value_t *addrspace = jl_tparam2(vt);
-        if (isatomic == (jl_value_t*)jl_not_atomic_sym && jl_is_addrspacecore(addrspace) && jl_unbox_uint8(addrspace) == 0) {
-            n += jl_printf(out, "Memory{");
-        }
-        else {
-            n += jl_printf(out, "GenericMemory{");
-            n += jl_static_show_x(out, isatomic, depth, ctx);
-            n += jl_printf(out, ", ");
-            n += jl_static_show_x(out, addrspace, depth, ctx);
-            n += jl_printf(out, ", ");
-        }
+        //jl_value_t *isatomic = jl_tparam0(vt);
         jl_value_t *el_type = jl_tparam1(vt);
-        n += jl_static_show_x(out, el_type, depth, ctx);
+        jl_value_t *addrspace = jl_tparam2(vt);
+        n += jl_static_show_x(out, (jl_value_t*)vt, depth, ctx);
         size_t j, tlen = m->length;
-        n += jl_printf(out, "}(%" PRIdPTR ", %p)[", tlen, m->ptr);
-//#ifdef _P64
-//        n += jl_printf(out, "0x%016" PRIx64, tlen);
-//#else
-//        n += jl_printf(out, "0x%08" PRIx32, tlen);
-//#endif
+        n += jl_printf(out, "(%" PRIdPTR ", %p)[", tlen, m->ptr);
+        if (!(addrspace && jl_is_addrspacecore(addrspace) && jl_unbox_uint8(addrspace) == 0)) {
+            n += jl_printf(out, "...]");
+            return n;
+        }
+        const char *typetagdata = NULL;
         const jl_datatype_layout_t *layout = vt->layout;
         int nlsep = 0;
-        const char *typetagdata = NULL;
         if (layout->flags.arrayelem_isboxed) {
             // print arrays with newlines, unless the elements are probably small
             for (j = 0; j < tlen; j++) {
diff --git a/src/serialize.h b/src/serialize.h
index 2a91189dce739..3d3eb4df5e862 100644
--- a/src/serialize.h
+++ b/src/serialize.h
@@ -52,22 +52,21 @@ extern "C" {
 #define TAG_SHORT_INT32        44
 #define TAG_CALL1              45
 #define TAG_CALL2              46
-#define TAG_LINEINFO           47
-#define TAG_SHORT_BACKREF      48
-#define TAG_BACKREF            49
-#define TAG_UNIONALL           50
-#define TAG_GOTONODE           51
-#define TAG_QUOTENODE          52
-#define TAG_GENERAL            53
-#define TAG_GOTOIFNOT          54
-#define TAG_RETURNNODE         55
-#define TAG_ARGUMENT           56
-#define TAG_RELOC_METHODROOT   57
-#define TAG_BINDING            58
-#define TAG_MEMORYT            59
-#define TAG_ENTERNODE          60
-
-#define LAST_TAG 60
+#define TAG_SHORT_BACKREF      47
+#define TAG_BACKREF            48
+#define TAG_UNIONALL           49
+#define TAG_GOTONODE           50
+#define TAG_QUOTENODE          51
+#define TAG_GENERAL            52
+#define TAG_GOTOIFNOT          53
+#define TAG_RETURNNODE         54
+#define TAG_ARGUMENT           55
+#define TAG_RELOC_METHODROOT   56
+#define TAG_BINDING            57
+#define TAG_MEMORYT            58
+#define TAG_ENTERNODE          59
+
+#define LAST_TAG 59
 
 #define write_uint8(s, n) ios_putc((n), (s))
 #define read_uint8(s) ((uint8_t)ios_getc((s)))
diff --git a/src/stackwalk.c b/src/stackwalk.c
index 37f239609504e..e45af4bb6634e 100644
--- a/src/stackwalk.c
+++ b/src/stackwalk.c
@@ -652,6 +652,80 @@ void jl_print_native_codeloc(uintptr_t ip) JL_NOTSAFEPOINT
     free(frames);
 }
 
+const char *jl_debuginfo_file1(jl_debuginfo_t *debuginfo)
+{
+    jl_value_t *def = debuginfo->def;
+    if (jl_is_method_instance(def))
+        def = ((jl_method_instance_t*)def)->def.value;
+    if (jl_is_method(def))
+        def = (jl_value_t*)((jl_method_t*)def)->file;
+    if (jl_is_symbol(def))
+        return jl_symbol_name((jl_sym_t*)def);
+    return "<unknown>";
+}
+
+const char *jl_debuginfo_file(jl_debuginfo_t *debuginfo)
+{
+    jl_debuginfo_t *linetable = debuginfo->linetable;
+    while ((jl_value_t*)linetable != jl_nothing) {
+        debuginfo = linetable;
+        linetable = debuginfo->linetable;
+    }
+    return jl_debuginfo_file1(debuginfo);
+}
+
+jl_module_t *jl_debuginfo_module1(jl_value_t *debuginfo_def)
+{
+    if (jl_is_method_instance(debuginfo_def))
+        debuginfo_def = ((jl_method_instance_t*)debuginfo_def)->def.value;
+    if (jl_is_method(debuginfo_def))
+        debuginfo_def = (jl_value_t*)((jl_method_t*)debuginfo_def)->module;
+    if (jl_is_module(debuginfo_def))
+        return (jl_module_t*)debuginfo_def;
+    return NULL;
+}
+
+const char *jl_debuginfo_name(jl_value_t *func)
+{
+    if (func == NULL)
+        return "macro expansion";
+    if (jl_is_method_instance(func))
+        func = ((jl_method_instance_t*)func)->def.value;
+    if (jl_is_method(func))
+        func = (jl_value_t*)((jl_method_t*)func)->name;
+    if (jl_is_symbol(func))
+        return jl_symbol_name((jl_sym_t*)func);
+    if (jl_is_module(func))
+        return "top-level scope";
+    return "<unknown>";
+}
+
+// func == module : top-level
+// func == NULL : macro expansion
+static void jl_print_debugloc(jl_debuginfo_t *debuginfo, jl_value_t *func, size_t ip, int inlined) JL_NOTSAFEPOINT
+{
+    if (!jl_is_symbol(debuginfo->def)) // this is a path or
+        func = debuginfo->def; // this is inlined code
+    struct jl_codeloc_t stmt = jl_uncompress1_codeloc(debuginfo->codelocs, ip);
+    intptr_t edges_idx = stmt.to;
+    if (edges_idx) {
+        jl_debuginfo_t *edge = (jl_debuginfo_t*)jl_svecref(debuginfo->edges, edges_idx - 1);
+        assert(jl_typetagis(edge, jl_debuginfo_type));
+        jl_print_debugloc(edge, NULL, stmt.pc, 1);
+    }
+    intptr_t ip2 = stmt.line;
+    if (ip2 >= 0 && ip > 0 && (jl_value_t*)debuginfo->linetable != jl_nothing) {
+        jl_print_debugloc(debuginfo->linetable, func, ip2, 0);
+    }
+    else {
+        if (ip2 < 0) // set broken debug info to ignored
+            ip2 = 0;
+        const char *func_name = jl_debuginfo_name(func);
+        const char *file = jl_debuginfo_file(debuginfo);
+        jl_safe_print_codeloc(func_name, file, ip2, inlined);
+    }
+}
+
 // Print code location for backtrace buffer entry at *bt_entry
 void jl_print_bt_entry_codeloc(jl_bt_element_t *bt_entry) JL_NOTSAFEPOINT
 {
@@ -659,33 +733,18 @@ void jl_print_bt_entry_codeloc(jl_bt_element_t *bt_entry) JL_NOTSAFEPOINT
         jl_print_native_codeloc(bt_entry[0].uintptr);
     }
     else if (jl_bt_entry_tag(bt_entry) == JL_BT_INTERP_FRAME_TAG) {
-        size_t ip = jl_bt_entry_header(bt_entry);
+        size_t ip = jl_bt_entry_header(bt_entry); // zero-indexed
         jl_value_t *code = jl_bt_entry_jlvalue(bt_entry, 0);
+        jl_value_t *def = (jl_value_t*)jl_core_module; // just used as a token here that isa Module
         if (jl_is_method_instance(code)) {
+            def = code;
             // When interpreting a method instance, need to unwrap to find the code info
             code = jl_atomic_load_relaxed(&((jl_method_instance_t*)code)->uninferred);
         }
         if (jl_is_code_info(code)) {
             jl_code_info_t *src = (jl_code_info_t*)code;
             // See also the debug info handling in codegen.cpp.
-            // NB: debuginfoloc is 1-based!
-            intptr_t debuginfoloc = jl_array_data(src->codelocs, int32_t)[ip];
-            while (debuginfoloc != 0) {
-                jl_line_info_node_t *locinfo = (jl_line_info_node_t*)
-                    jl_array_ptr_ref(src->linetable, debuginfoloc - 1);
-                assert(jl_typetagis(locinfo, jl_lineinfonode_type));
-                const char *func_name = "Unknown";
-                jl_value_t *method = locinfo->method;
-                if (jl_is_method_instance(method))
-                    method = ((jl_method_instance_t*)method)->def.value;
-                if (jl_is_method(method))
-                    method = (jl_value_t*)((jl_method_t*)method)->name;
-                if (jl_is_symbol(method))
-                    func_name = jl_symbol_name((jl_sym_t*)method);
-                jl_safe_print_codeloc(func_name, jl_symbol_name(locinfo->file),
-                                      locinfo->line, locinfo->inlined_at);
-                debuginfoloc = locinfo->inlined_at;
-            }
+            jl_print_debugloc(src->debuginfo, def, ip + 1, 0);
         }
         else {
             // If we're using this function something bad has already happened;
diff --git a/src/staticdata.c b/src/staticdata.c
index 261042b775c14..3e2aaf44d8a0d 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -100,7 +100,7 @@ extern "C" {
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
-#define NUM_TAGS    188
+#define NUM_TAGS    189
 
 // An array of references that need to be restored from the sysimg
 // This is a manually constructed dual of the gvars array, which would be produced by codegen for Julia code, for C.
@@ -213,6 +213,7 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_addrspace_type);
         INSERT_TAG(jl_addrspace_typename);
         INSERT_TAG(jl_addrspacecore_type);
+        INSERT_TAG(jl_debuginfo_type);
 
         // special typenames
         INSERT_TAG(jl_tuple_typename);
@@ -2337,23 +2338,18 @@ static void jl_prune_type_cache_linear(jl_svec_t *cache)
         jl_svecset(cache, ins++, jl_nothing);
 }
 
-static jl_value_t *strip_codeinfo_meta(jl_method_t *m, jl_value_t *ci_, int orig)
+static jl_value_t *strip_codeinfo_meta(jl_method_t *m, jl_value_t *ci_, jl_code_instance_t *codeinst, int orig)
 {
     jl_code_info_t *ci = NULL;
     JL_GC_PUSH1(&ci);
     int compressed = 0;
     if (!jl_is_code_info(ci_)) {
         compressed = 1;
-        ci = jl_uncompress_ir(m, NULL, (jl_value_t*)ci_);
+        ci = jl_uncompress_ir(m, codeinst, (jl_value_t*)ci_);
     }
     else {
         ci = (jl_code_info_t*)ci_;
     }
-    // leave codelocs length the same so the compiler can assume that; just zero it
-    memset(jl_array_data(ci->codelocs, int32_t), 0, jl_array_len(ci->codelocs)*sizeof(int32_t));
-    // empty linetable
-    if (jl_is_array(ci->linetable))
-        jl_array_del_end((jl_array_t*)ci->linetable, jl_array_len(ci->linetable));
     // replace slot names with `?`, except unused_sym since the compiler looks at it
     jl_sym_t *questionsym = jl_symbol("?");
     int i, l = jl_array_len(ci->slotnames);
@@ -2384,7 +2380,7 @@ static void strip_specializations_(jl_method_instance_t *mi)
                 record_field_change((jl_value_t**)&codeinst->inferred, jl_nothing);
             }
             else if (jl_options.strip_metadata) {
-                jl_value_t *stripped = strip_codeinfo_meta(mi->def.method, inferred, 0);
+                jl_value_t *stripped = strip_codeinfo_meta(mi->def.method, inferred, codeinst, 0);
                 if (jl_atomic_cmpswap_relaxed(&codeinst->inferred, &inferred, stripped)) {
                     jl_gc_wb(codeinst, stripped);
                 }
@@ -2422,7 +2418,7 @@ static int strip_all_codeinfos__(jl_typemap_entry_t *def, void *_env)
             }
         }
         if (jl_options.strip_metadata && !stripped_ir) {
-            m->source = strip_codeinfo_meta(m, m->source, 1);
+            m->source = strip_codeinfo_meta(m, m->source, NULL, 1);
             jl_gc_wb(m, m->source);
         }
     }
diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index 4b69e4c1f615d..ef1cd6e230818 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -707,6 +707,8 @@ end
 @testset "code_llvm on opaque_closure" begin
     let ci = code_typed(+, (Int, Int))[1][1]
         ir = Core.Compiler.inflate_ir(ci)
+        @test ir.debuginfo.def === nothing
+        ir.debuginfo.def = Symbol(@__FILE__)
         oc = Core.OpaqueClosure(ir)
         @test (code_llvm(devnull, oc, Tuple{Int, Int}); true)
         let io = IOBuffer()
diff --git a/stdlib/REPL/test/precompilation.jl b/stdlib/REPL/test/precompilation.jl
index 2dcf78c114d9a..5021844a9d1a4 100644
--- a/stdlib/REPL/test/precompilation.jl
+++ b/stdlib/REPL/test/precompilation.jl
@@ -27,7 +27,7 @@ if !Sys.iswindows()
         tracecompile_out = read(f, String)
         close(ptm) # close after reading so we don't get precompiles from error shutdown
 
-        expected_precompiles = 1
+        expected_precompiles = 2
 
         n_precompiles = count(r"precompile\(", tracecompile_out)
 
diff --git a/stdlib/Serialization/src/Serialization.jl b/stdlib/Serialization/src/Serialization.jl
index 29010a52eed91..3f38708e8bb1e 100644
--- a/stdlib/Serialization/src/Serialization.jl
+++ b/stdlib/Serialization/src/Serialization.jl
@@ -1085,6 +1085,7 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
     end
     if makenew
         meth.module = mod
+        meth.debuginfo = NullDebugInfo
         meth.name = name
         meth.file = file
         meth.line = line
@@ -1097,7 +1098,9 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
         meth.purity = purity
         if template !== nothing
             # TODO: compress template
-            meth.source = template::CodeInfo
+            template = template::CodeInfo
+            meth.source = template
+            meth.debuginfo = template.debuginfo
             if !@isdefined(slot_syms)
                 slot_syms = ccall(:jl_compress_argnames, Ref{String}, (Any,), meth.source.slotnames)
             end
@@ -1151,6 +1154,7 @@ function deserialize(s::AbstractSerializer, ::Type{Core.LineInfoNode})
     return Core.LineInfoNode(mod, method, deserialize(s)::Symbol, Int32(deserialize(s)::Union{Int32, Int}), Int32(deserialize(s)::Union{Int32, Int}))
 end
 
+
 function deserialize(s::AbstractSerializer, ::Type{PhiNode})
     edges = deserialize(s)
     if edges isa Vector{Any}
@@ -1165,6 +1169,7 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
     deserialize_cycle(s, ci)
     code = deserialize(s)::Vector{Any}
     ci.code = code
+    ci.debuginfo = NullDebugInfo
     # allow older-style IR with return and gotoifnot Exprs
     for i in 1:length(code)
         stmt = code[i]
@@ -1177,17 +1182,27 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
             end
         end
     end
-    ci.codelocs = deserialize(s)::Vector{Int32}
+    _x = deserialize(s)
+    have_debuginfo = _x isa Core.DebugInfo
+    if have_debuginfo
+        ci.debuginfo = _x
+    else
+        codelocs = _x::Vector{Int32}
+        # TODO: convert codelocs to debuginfo format?
+    end
     _x = deserialize(s)
     if _x isa Array || _x isa Int
         pre_12 = false
-        ci.ssavaluetypes = _x
     else
         pre_12 = true
         # < v1.2
         ci.method_for_inference_limit_heuristics = _x
-        ci.ssavaluetypes = deserialize(s)
-        ci.linetable = deserialize(s)
+        _x = deserialize(s)
+    end
+    ci.ssavaluetypes = _x
+    if pre_12
+        linetable = deserialize(s)
+        # TODO: convert linetable to debuginfo format?
     end
     ssaflags = deserialize(s)
     if length(ssaflags) ≠ length(code)
@@ -1204,7 +1219,10 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
         if format_version(s) <= 26
             ci.method_for_inference_limit_heuristics = deserialize(s)
         end
-        ci.linetable = deserialize(s)
+        if !have_debuginfo # pre v1.11 format
+            linetable = deserialize(s)
+            # TODO: convert linetable to debuginfo format?
+        end
     end
     ci.slotnames = deserialize(s)
     if !pre_12
@@ -1266,9 +1284,12 @@ function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
     if format_version(s) >= 22
         ci.inlining_cost = deserialize(s)::UInt16
     end
+    ci.debuginfo = NullDebugInfo
     return ci
 end
 
+const NullDebugInfo = DebugInfo(:none)
+
 if Int === Int64
 const OtherInt = Int32
 else
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 498254bb26ce0..291b0b0fdad78 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -444,9 +444,7 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
     mktempdir() do dir
         helperdir = joinpath(@__DIR__, "testhelpers")
         inputfile = joinpath(helperdir, "coverage_file.jl")
-        expected = replace(read(joinpath(helperdir, "coverage_file.info.bad"), String),
-            "<FILENAME>" => realpath(inputfile))
-        expected_good = replace(read(joinpath(helperdir, "coverage_file.info"), String),
+        expected = replace(read(joinpath(helperdir, "coverage_file.info"), String),
             "<FILENAME>" => realpath(inputfile))
         covfile = replace(joinpath(dir, "coverage.info"), "%" => "%%")
         @test !isfile(covfile)
@@ -464,21 +462,18 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         got = read(covfile, String)
         rm(covfile)
         @test occursin(expected, got) || (expected, got)
-        @test_broken occursin(expected_good, got)
         @test readchomp(`$exename -E "Base.JLOptions().code_coverage" -L $inputfile
             --code-coverage=$covfile --code-coverage=user`) == "1"
         @test isfile(covfile)
         got = read(covfile, String)
         rm(covfile)
         @test occursin(expected, got) || (expected, got)
-        @test_broken occursin(expected_good, got)
         @test readchomp(`$exename -E "Base.JLOptions().code_coverage" -L $inputfile
             --code-coverage=$covfile --code-coverage=all`) == "2"
         @test isfile(covfile)
         got = read(covfile, String)
         rm(covfile)
         @test occursin(expected, got) || (expected, got)
-        @test_broken occursin(expected_good, got)
 
         # Ask for coverage in specific file
         tfile = realpath(inputfile)
@@ -488,7 +483,6 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         got = read(covfile, String)
         rm(covfile)
         @test occursin(expected, got) || (expected, got)
-        @test_broken occursin(expected_good, got)
 
         # Ask for coverage in directory
         tdir = dirname(realpath(inputfile))
@@ -498,7 +492,6 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         got = read(covfile, String)
         rm(covfile)
         @test occursin(expected, got) || (expected, got)
-        @test_broken occursin(expected_good, got)
 
         # Ask for coverage in current directory
         tdir = dirname(realpath(inputfile))
@@ -511,7 +504,6 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         got = read(covfile, String)
         rm(covfile)
         @test occursin(expected, got) || (expected, got)
-        @test_broken occursin(expected_good, got)
 
         # Ask for coverage in relative directory
         tdir = dirname(realpath(inputfile))
@@ -523,7 +515,6 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         got = read(covfile, String)
         rm(covfile)
         @test occursin(expected, got) || (expected, got)
-        @test_broken occursin(expected_good, got)
 
         # Ask for coverage in relative directory with dot-dot notation
         tdir = dirname(realpath(inputfile))
@@ -535,7 +526,6 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         got = read(covfile, String)
         rm(covfile)
         @test occursin(expected, got) || (expected, got)
-        @test_broken occursin(expected_good, got)
 
         # Ask for coverage in a different directory
         tdir = mktempdir() # a dir that contains no code
@@ -570,15 +560,14 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
             end
             do_test()
             """), """
-            DA:1,1
             DA:2,1
             DA:3,1
             DA:5,1
             DA:6,0
             DA:9,1
             DA:10,1
-            LH:6
-            LF:7
+            LH:5
+            LF:6
             """)
         @test contains(coverage_info_for("""
             function cov_bug()
diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index 0b78d54803f7f..e6691b3373259 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -463,7 +463,6 @@ let # generate cache
     target_mi = CC.specialize_method(only(methods(custom_lookup_target)), Tuple{typeof(custom_lookup_target),Bool,Int}, Core.svec())
     target_ci = custom_lookup(target_mi, CONST_INVOKE_INTERP_WORLD, CONST_INVOKE_INTERP_WORLD)
     @test target_ci.rettype == Tuple{Float64,Nothing} # constprop'ed source
-    # display(@ccall jl_uncompress_ir(target_ci.def.def::Any, C_NULL::Ptr{Cvoid}, target_ci.inferred::Any)::Any)
 
     raw = false
     lookup = @cfunction(custom_lookup, Any, (Any,Csize_t,Csize_t))
diff --git a/test/compiler/contextual.jl b/test/compiler/contextual.jl
index bbcf7b0dfb959..17919c6a9f6ad 100644
--- a/test/compiler/contextual.jl
+++ b/test/compiler/contextual.jl
@@ -43,14 +43,16 @@ module MiniCassette
         end
     end
 
-    function transform!(ci::CodeInfo, nargs::Int, sparams::Core.SimpleVector)
+    function transform!(mi::MethodInstance, ci::CodeInfo, nargs::Int, sparams::Core.SimpleVector)
         code = ci.code
+        di = Core.Compiler.DebugInfoStream(mi, ci.debuginfo, length(code))
         ci.slotnames = Symbol[Symbol("#self#"), :ctx, :f, :args, ci.slotnames[nargs+1:end]...]
         ci.slotflags = UInt8[(0x00 for i = 1:4)..., ci.slotflags[nargs+1:end]...]
         # Insert one SSAValue for every argument statement
         prepend!(code, Any[Expr(:call, getfield, SlotNumber(4), i) for i = 1:nargs])
-        prepend!(ci.codelocs, fill(0, nargs))
+        prepend!(di.codelocs, fill(Int32(0), 3nargs))
         prepend!(ci.ssaflags, fill(0x00, nargs))
+        ci.debuginfo = Core.DebugInfo(di, length(code))
         ci.ssavaluetypes += nargs
         function map_slot_number(slot::Int)
             if slot == 1
@@ -88,7 +90,7 @@ module MiniCassette
         code_info = copy(code_info)
         @assert code_info.edges === nothing
         code_info.edges = MethodInstance[mi]
-        transform!(code_info, length(args), match.sparams)
+        transform!(mi, code_info, length(args), match.sparams)
         # TODO: this is mandatory: code_info.min_world = max(code_info.min_world, min_world[])
         # TODO: this is mandatory: code_info.max_world = min(code_info.max_world, max_world[])
         return code_info
diff --git a/test/compiler/interpreter_exec.jl b/test/compiler/interpreter_exec.jl
index b3aca0cfe2903..f00bc92c7443d 100644
--- a/test/compiler/interpreter_exec.jl
+++ b/test/compiler/interpreter_exec.jl
@@ -22,7 +22,7 @@ let m = Meta.@lower 1 + 1
     nstmts = length(src.code)
     src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
-    src.codelocs = fill(Int32(1), nstmts)
+    src.debuginfo = Core.DebugInfo(:none)
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
     @test :a === @eval $m
@@ -62,7 +62,7 @@ let m = Meta.@lower 1 + 1
     nstmts = length(src.code)
     src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
-    src.codelocs = fill(Int32(1), nstmts)
+    src.debuginfo = Core.DebugInfo(:none)
     m.args[1] = copy(src)
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
@@ -81,7 +81,7 @@ let m = Meta.@lower 1 + 1
         QuoteNode(:b),
         GlobalRef(@__MODULE__, :test29262),
         # block 2
-        EnterNode(11),
+        EnterNode(12),
         # block 3
         UpsilonNode(),
         UpsilonNode(),
@@ -91,19 +91,22 @@ let m = Meta.@lower 1 + 1
         UpsilonNode(SSAValue(1)),
         # block 5
         Expr(:throw_undef_if_not, :expected, false),
+        ReturnNode(), # unreachable
         # block 6
         PhiCNode(Any[SSAValue(5), SSAValue(7), SSAValue(9)]), # NULL, :a, :b
         PhiCNode(Any[SSAValue(6)]), # NULL
+        Expr(:pop_exception, SSAValue(4)),
         # block 7
-        ReturnNode(SSAValue(11)),
+        ReturnNode(SSAValue(12)),
     ]
     nstmts = length(src.code)
     src.ssavaluetypes = nstmts
     src.ssaflags = fill(UInt8(0x00), nstmts)
-    src.codelocs = fill(Int32(1), nstmts)
+    src.debuginfo = Core.DebugInfo(:none)
     Core.Compiler.verify_ir(Core.Compiler.inflate_ir(src))
     global test29262 = true
     @test :a === @eval $m
     global test29262 = false
     @test :b === @eval $m
+    @test isempty(current_exceptions())
 end
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index c124832030cbd..4df4c699add09 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -804,7 +804,7 @@ function each_stmt_a_bb(stmts, preds, succs)
     append!(ir.stmts.stmt, stmts)
     empty!(ir.stmts.type); append!(ir.stmts.type, [Nothing for _ = 1:length(stmts)])
     empty!(ir.stmts.flag); append!(ir.stmts.flag, [0x0 for _ = 1:length(stmts)])
-    empty!(ir.stmts.line); append!(ir.stmts.line, [Int32(0) for _ = 1:length(stmts)])
+    empty!(ir.stmts.line); append!(ir.stmts.line, [Int32(0) for _ = 1:3length(stmts)])
     empty!(ir.stmts.info); append!(ir.stmts.info, [NoCallInfo() for _ = 1:length(stmts)])
     empty!(ir.cfg.blocks); append!(ir.cfg.blocks, [BasicBlock(StmtRange(i, i), preds[i], succs[i]) for i = 1:length(stmts)])
     empty!(ir.cfg.index);  append!(ir.cfg.index,  [i for i = 2:length(stmts)])
diff --git a/test/compiler/irutils.jl b/test/compiler/irutils.jl
index 788d7bbc721ee..6a4087fbea958 100644
--- a/test/compiler/irutils.jl
+++ b/test/compiler/irutils.jl
@@ -71,7 +71,7 @@ let m = Meta.@lower 1 + 1
         else
             src.ssavaluetypes = ssavaluetypes
         end
-        src.codelocs = fill(one(Int32), nstmts)
+        src.debuginfo = Core.DebugInfo(:none)
         src.ssaflags = fill(zero(UInt32), nstmts)
         if slottypes !== nothing
             src.slottypes = slottypes
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index e237ab732ef57..6e0c292c0bd45 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -38,7 +38,6 @@ end
 #        false, false, false, false
 #    ))
 #
-#    NullLineInfo = Core.LineInfoNode(Main, Symbol(""), Symbol(""), Int32(0), UInt32(0))
 #    Compiler.run_passes(ci, 1, [NullLineInfo])
 #    # XXX: missing @test
 #end
@@ -113,8 +112,9 @@ let cfg = CFG(BasicBlock[
     make_bb([0, 1, 2] , [5]   ), # 0 predecessor should be preserved
     make_bb([2, 3]    , []    ),
 ], Int[])
-    insts = Compiler.InstructionStream([], [], Any[], Int32[], UInt8[])
-    ir = Compiler.IRCode(insts, cfg, Core.LineInfoNode[], Any[], Expr[], Compiler.VarState[])
+    insts = Compiler.InstructionStream([], [], Core.Compiler.CallInfo[], Int32[], UInt32[])
+    di = Compiler.DebugInfoStream(insts.line)
+    ir = Compiler.IRCode(insts, cfg, di, Any[], Expr[], Compiler.VarState[])
     compact = Compiler.IncrementalCompact(ir, true)
     @test length(compact.cfg_transform.result_bbs) == 4 && 0 in compact.cfg_transform.result_bbs[3].preds
 end
diff --git a/test/core.jl b/test/core.jl
index 0eca2251cd146..3a9945f152f5f 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -32,7 +32,7 @@ end
 # sanity tests that our built-in types are marked correctly for atomic fields
 for (T, c) in (
         (Core.CodeInfo, []),
-        (Core.CodeInstance, [:next, :min_world, :max_world, :inferred, :purity_bits, :invoke, :specptr, :specsigflags, :precompile]),
+        (Core.CodeInstance, [:next, :min_world, :max_world, :inferred, :debuginfo, :purity_bits, :invoke, :specptr, :specsigflags, :precompile]),
         (Core.Method, [:primary_world, :deleted_world]),
         (Core.MethodInstance, [:uninferred, :cache, :precompiled]),
         (Core.MethodTable, [:defs, :leafcache, :cache, :max_args]),
@@ -8063,10 +8063,6 @@ end
 @test Core.Compiler.is_foldable(Base.infer_effects(length, (Core.SimpleVector,)))
 @test Core.Compiler.is_foldable(Base.infer_effects(getindex, (Core.SimpleVector,Int)))
 
-let lin = Core.LineInfoNode(Base, first(methods(convert)), :foo, Int32(5), Int32(0))
-    @test convert(LineNumberNode, lin) == LineNumberNode(5, :foo)
-end
-
 # Test that a nothrow-globalref doesn't get outlined during lowering
 module WellKnownGlobal
     global well_known = 1
diff --git a/test/opaque_closure.jl b/test/opaque_closure.jl
index e9f1601019a59..8b0d118d98f1b 100644
--- a/test/opaque_closure.jl
+++ b/test/opaque_closure.jl
@@ -245,6 +245,8 @@ end
 # constructing an opaque closure from IRCode
 let src = first(only(code_typed(+, (Int, Int))))
     ir = Core.Compiler.inflate_ir(src, Core.Compiler.VarState[], src.slottypes)
+    @test ir.debuginfo.def === nothing
+    ir.debuginfo.def = Symbol(@__FILE__)
     @test OpaqueClosure(src; sig=Tuple{Int, Int}, rettype=Int, nargs=2)(40, 2) == 42
     oc = OpaqueClosure(ir)
     @test oc(40, 2) == 42
@@ -269,6 +271,8 @@ let src = code_typed((Int,Int)) do x, y...
         @test_throws MethodError oc(1,2,3)
     end
     ir = Core.Compiler.inflate_ir(src, Core.Compiler.VarState[], src.slottypes)
+    @test ir.debuginfo.def === nothing
+    ir.debuginfo.def = Symbol(@__FILE__)
     let oc = OpaqueClosure(ir; isva=true)
         @test oc(1,2) === (1,(2,))
         @test_throws MethodError oc(1,2,3)
diff --git a/test/precompile.jl b/test/precompile.jl
index c06145cba8416..3aa48552b8f66 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1702,7 +1702,8 @@ precompile_test_harness("issue #46296") do load_path
 
         mi = first(Base.specializations(first(methods(identity))))
         ci = Core.CodeInstance(mi, nothing, Any, Any, nothing, nothing, zero(Int32), typemin(UInt),
-                               typemax(UInt), zero(UInt32), zero(UInt32), nothing, 0x00)
+                               typemax(UInt), zero(UInt32), zero(UInt32), nothing, 0x00,
+                               Core.DebugInfo(mi))
 
         __init__() = @assert ci isa Core.CodeInstance
 
diff --git a/test/show.jl b/test/show.jl
index 5e432fe0e31a3..2eabe6353f328 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2076,7 +2076,7 @@ eval(Meta._parse_string("""function my_fun28173(x)
 end""", "a"^80, 1, 1, :statement)[1]) # use parse to control the line numbers
 let src = code_typed(my_fun28173, (Int,), debuginfo=:source)[1][1]
     ir = Core.Compiler.inflate_ir(src)
-    fill!(src.codelocs, 0) # IRCode printing is only capable of printing partial line info
+    src.debuginfo = Core.DebugInfo(src.debuginfo.def) # IRCode printing defaults to incomplete line info printing, so turn it off completely for CodeInfo too
     let source_slotnames = String["my_fun28173", "x"],
         repr_ir = split(repr(ir, context = :SOURCE_SLOTNAMES=>source_slotnames), '\n'),
         repr_ir = "CodeInfo(\n" * join((l[4:end] for l in repr_ir), "\n") * ")" # remove line numbers
diff --git a/test/staged.jl b/test/staged.jl
index 76d02c1938e4d..6bc3ead35586d 100644
--- a/test/staged.jl
+++ b/test/staged.jl
@@ -337,13 +337,15 @@ let world = Base.get_world_counter()
     match = Base._which(Tuple{typeof(sin), Int}; world)
     mi = Core.Compiler.specialize_method(match)
     lwr = Core.Compiler.retrieve_code_info(mi, world)
-    @test all(lin->lin.method === :sin, lwr.linetable)
+    nstmts = length(lwr.code)
+    di = Core.DebugInfo(Core.Compiler.DebugInfoStream(mi, lwr.debuginfo, nstmts), nstmts)
+    lwr.debuginfo = di
     @eval function sin_generated(a)
         $(Expr(:meta, :generated, Returns(lwr)))
         $(Expr(:meta, :generated_only))
     end
     src = only(code_lowered(sin_generated, (Int,)))
-    @test all(lin->lin.method === :sin, src.linetable)
+    @test src.debuginfo === di
     @test sin_generated(42) == sin(42)
 end
 
@@ -362,7 +364,7 @@ let
     nstmts = length(src.code)
     nslots = 1
     src.ssavaluetypes = nstmts
-    src.codelocs = fill(Int32(1), nstmts)
+    src.debuginfo = Core.DebugInfo(:f_unreachable_generated)
     src.ssaflags = fill(Int32(0), nstmts)
     src.slotflags = fill(0, nslots)
     src.slottypes = Any[Any]
diff --git a/test/syntax.jl b/test/syntax.jl
index 423d1e3d04bfb..d5338d76adf59 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -713,36 +713,10 @@ m1_exprs = get_expr_list(Meta.lower(@__MODULE__, quote @m1 end))
 let low3 = Meta.lower(@__MODULE__, quote @m3 end)
     m3_exprs = get_expr_list(low3)
     ci = low3.args[1]::Core.CodeInfo
-    @test ci.codelocs in ([4, 4, 0], [4, 0])
+    #@test ci.codelocs in ([4, 4, 0], [4, 0])
     @test is_return_ssavalue(m3_exprs[end])
 end
 
-function f1(a)
-    b = a + 100
-    b
-end
-
-@generated function f2(a)
-    quote
-        b = a + 100
-        b
-    end
-end
-
-f1_ci = code_typed(f1, (Int,), debuginfo=:source)[1][1]
-f2_ci = code_typed(f2, (Int,), debuginfo=:source)[1][1]
-
-f1_exprs = get_expr_list(f1_ci)
-f2_exprs = get_expr_list(f2_ci)
-
-if Base.JLOptions().can_inline != 0
-    @test length(f1_ci.linetable) == 3
-    @test length(f2_ci.linetable) >= 3
-else
-    @test length(f1_ci.linetable) == 2
-    @test length(f2_ci.linetable) >= 3
-end
-
 # Check that string and command literals are parsed to the appropriate macros
 @test :(x"s") == :(@x_str "s")
 @test :(x"s"flag) == :(@x_str "s" "flag")
diff --git a/test/testhelpers/coverage_file.info b/test/testhelpers/coverage_file.info
index c83e75dee8060..b03b0e07e6977 100644
--- a/test/testhelpers/coverage_file.info
+++ b/test/testhelpers/coverage_file.info
@@ -10,9 +10,10 @@ DA:11,1
 DA:12,1
 DA:14,0
 DA:17,1
-DA:19,2
+DA:18,1
+DA:19,1
 DA:20,1
 DA:22,1
-LH:12
-LF:14
+LH:13
+LF:15
 end_of_record
diff --git a/test/testhelpers/coverage_file.info.bad b/test/testhelpers/coverage_file.info.bad
deleted file mode 100644
index 311f6379381ee..0000000000000
--- a/test/testhelpers/coverage_file.info.bad
+++ /dev/null
@@ -1,20 +0,0 @@
-SF:<FILENAME>
-DA:3,1
-DA:4,1
-DA:5,0
-DA:7,1
-DA:8,1
-DA:9,3
-DA:10,5
-DA:11,1
-DA:12,1
-DA:14,0
-DA:17,1
-DA:18,0
-DA:19,2
-DA:20,1
-DA:22,1
-DA:1234,0
-LH:12
-LF:16
-end_of_record
diff --git a/test/testhelpers/coverage_file.info.bad2 b/test/testhelpers/coverage_file.info.bad2
deleted file mode 100644
index a766597be4c17..0000000000000
--- a/test/testhelpers/coverage_file.info.bad2
+++ /dev/null
@@ -1,20 +0,0 @@
-SF:<FILENAME>
-DA:3,1
-DA:4,1
-DA:5,0
-DA:7,1
-DA:8,1
-DA:9,3
-DA:10,5
-DA:11,0
-DA:12,1
-DA:14,0
-DA:17,1
-DA:18,0
-DA:19,0
-DA:20,0
-DA:22,1
-DA:1234,0
-LH:9
-LF:16
-end_of_record
diff --git a/test/testhelpers/coverage_file.jl b/test/testhelpers/coverage_file.jl
index e8e0355952d80..577cc6bb5d2ca 100644
--- a/test/testhelpers/coverage_file.jl
+++ b/test/testhelpers/coverage_file.jl
@@ -24,6 +24,6 @@ end
 
 success = code_coverage_test() == [1, 2, 3] &&
           short_form_func_coverage_test(2) == 4
-exit(success ?  0 : 1)
+exit(success ? 0 : 1)
 
 # end of file
diff --git a/test/worlds.jl b/test/worlds.jl
index e9d8895fc90d4..945405cee26a4 100644
--- a/test/worlds.jl
+++ b/test/worlds.jl
@@ -257,11 +257,10 @@ end
 # avoid adding this to Base
 function equal(ci1::Core.CodeInfo, ci2::Core.CodeInfo)
     return ci1.code == ci2.code &&
-           ci1.codelocs == ci2.codelocs &&
+           ci1.debuginfo == ci2.debuginfo &&
            ci1.ssavaluetypes == ci2.ssavaluetypes &&
            ci1.ssaflags == ci2.ssaflags &&
            ci1.method_for_inference_limit_heuristics == ci2.method_for_inference_limit_heuristics &&
-           ci1.linetable == ci2.linetable &&
            ci1.slotnames == ci2.slotnames &&
            ci1.slotflags == ci2.slotflags &&
            ci1.slottypes == ci2.slottypes

From f9e08f7941efad238c13641cb72a0d383fd7eaba Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 11 Mar 2024 15:09:12 -0400
Subject: [PATCH 1107/1315] fix #52025, re-allow all implicit pointer casts in
 cconvert for Array (#53659)

fix #52025
---
 base/refpointer.jl | 4 ++--
 test/ccall.jl      | 3 +++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/base/refpointer.jl b/base/refpointer.jl
index ce2c6fc00560d..5027462eeb6b6 100644
--- a/base/refpointer.jl
+++ b/base/refpointer.jl
@@ -171,8 +171,8 @@ if is_primary_base_module
     Ref(x::AbstractArray, i::Integer) = RefArray(x, i)
 end
 
-cconvert(::Type{Ptr{P}}, a::Array{P}) where {P<:Union{Ptr,Cwstring,Cstring}} = getfield(a, :ref)
-cconvert(::Type{Ref{P}}, a::Array{P}) where {P<:Union{Ptr,Cwstring,Cstring}} = getfield(a, :ref)
+cconvert(::Type{Ptr{P}}, a::Array{<:Union{Ptr,Cwstring,Cstring}}) where {P<:Union{Ptr,Cwstring,Cstring}} = getfield(a, :ref)
+cconvert(::Type{Ref{P}}, a::Array{<:Union{Ptr,Cwstring,Cstring}}) where {P<:Union{Ptr,Cwstring,Cstring}} = getfield(a, :ref)
 cconvert(::Type{Ptr{P}}, a::Array) where {P<:Union{Ptr,Cwstring,Cstring}} = Ref{P}(a)
 cconvert(::Type{Ref{P}}, a::Array) where {P<:Union{Ptr,Cwstring,Cstring}} = Ref{P}(a)
 
diff --git a/test/ccall.jl b/test/ccall.jl
index 3647173eb9290..8b1fefdfc66e4 100644
--- a/test/ccall.jl
+++ b/test/ccall.jl
@@ -1934,3 +1934,6 @@ end
     end
     @test_throws "could not load symbol \"test\"" somefunction_not_found_libc()
 end
+
+# issue #52025
+@test Base.unsafe_convert(Ptr{Ptr{Cchar}}, Base.cconvert(Ptr{Ptr{Cchar}}, map(pointer, ["ab"]))) isa Ptr{Ptr{Cchar}}

From 5fc16621822398419a45631a1c0fc421a5cbd88c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Mon, 11 Mar 2024 20:54:46 +0000
Subject: [PATCH 1108/1315] Fix warning about comparison of integer expressions
 of different signedness (#53658)

---
 src/flisp/julia_extensions.c |  2 +-
 src/llvm-multiversioning.cpp |  2 +-
 src/processor.cpp            |  8 ++++----
 src/processor_arm.cpp        | 10 +++++-----
 src/processor_fallback.cpp   |  2 +-
 src/processor_x86.cpp        |  6 +++---
 src/smallintset.c            |  4 ++--
 src/support/utf8.h           |  2 +-
 8 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/flisp/julia_extensions.c b/src/flisp/julia_extensions.c
index f29e3972755c5..79a007df8bfde 100644
--- a/src/flisp/julia_extensions.c
+++ b/src/flisp/julia_extensions.c
@@ -405,7 +405,7 @@ value_t fl_string_only_julia_char(fl_context_t *fl_ctx, value_t *args, uint32_t
     uint8_t *s = (uint8_t*)cvalue_data(args[0]);
     size_t len = cv_len((cvalue_t*)ptr(args[0]));
     uint32_t u = _string_only_julia_char(s, len);
-    if (u == (uint32_t)-1)
+    if (u == UINT32_MAX)
         return fl_ctx->F;
     return fl_list2(fl_ctx, fl_ctx->jl_char_sym, mk_uint32(fl_ctx, u));
 }
diff --git a/src/llvm-multiversioning.cpp b/src/llvm-multiversioning.cpp
index d1c3f9bc464eb..0110fa8efc8b6 100644
--- a/src/llvm-multiversioning.cpp
+++ b/src/llvm-multiversioning.cpp
@@ -754,7 +754,7 @@ std::pair<uint32_t,GlobalVariable*> CloneCtx::get_reloc_slot(Function *F) const
     if (F->isDeclaration()) {
         auto extern_decl = extern_relocs.find(F);
         assert(extern_decl != extern_relocs.end() && "Missing extern relocation slot!");
-        return {(uint32_t)-1, extern_decl->second};
+        return {UINT32_MAX, extern_decl->second};
     }
     else {
         auto id = get_func_id(F);
diff --git a/src/processor.cpp b/src/processor.cpp
index fc56a93be9787..730e470f4153d 100644
--- a/src/processor.cpp
+++ b/src/processor.cpp
@@ -389,7 +389,7 @@ JL_UNUSED static uint32_t find_feature_bit(const FeatureName *features, size_t n
             return feature.bit;
         }
     }
-    return (uint32_t)-1;
+    return UINT32_MAX;
 }
 
 // This is how we save the target identification.
@@ -642,7 +642,7 @@ static inline jl_image_t parse_sysimg(void *hdl, F &&callback)
     jl_value_t* rejection_reason = nullptr;
     JL_GC_PUSH1(&rejection_reason);
     uint32_t target_idx = callback(ids, &rejection_reason);
-    if (target_idx == (uint32_t)-1) {
+    if (target_idx == UINT32_MAX) {
         jl_error(jl_string_ptr(rejection_reason));
     }
     JL_GC_POP();
@@ -856,7 +856,7 @@ static inline void check_cmdline(T &&cmdline, bool imaging)
 }
 
 struct SysimgMatch {
-    uint32_t best_idx{(uint32_t)-1};
+    uint32_t best_idx{UINT32_MAX};
     int vreg_size{0};
 };
 
@@ -911,7 +911,7 @@ static inline SysimgMatch match_sysimg_targets(S &&sysimg, T &&target, F &&max_v
         feature_size = new_feature_size;
         rejection_reasons.push_back("Updating best match to this target\n");
     }
-    if (match.best_idx == (uint32_t)-1) {
+    if (match.best_idx == UINT32_MAX) {
         // Construct a nice error message for debugging purposes
         std::string error_msg = "Unable to find compatible target in cached code image.\n";
         for (size_t i = 0; i < rejection_reasons.size(); i++) {
diff --git a/src/processor_arm.cpp b/src/processor_arm.cpp
index 0d069b085ac47..1852188c718a9 100644
--- a/src/processor_arm.cpp
+++ b/src/processor_arm.cpp
@@ -207,7 +207,7 @@ static constexpr auto feature_masks = get_feature_masks(
 #undef JL_FEATURE_DEF
     -1);
 static const auto real_feature_masks =
-    feature_masks & FeatureList<feature_sz>{{(uint32_t)-1, (uint32_t)-1, 0}};
+    feature_masks & FeatureList<feature_sz>{{UINT32_MAX, UINT32_MAX, 0}};
 
 namespace Feature {
 enum : uint32_t {
@@ -473,7 +473,7 @@ static constexpr auto feature_masks = get_feature_masks(
 #undef JL_FEATURE_DEF
     -1);
 static const auto real_feature_masks =
-    feature_masks & FeatureList<feature_sz>{{(uint32_t)-1, (uint32_t)-1, 0}};
+    feature_masks & FeatureList<feature_sz>{{UINT32_MAX, UINT32_MAX, 0}};
 
 namespace Feature {
 enum : uint32_t {
@@ -1522,7 +1522,7 @@ static const llvm::SmallVector<TargetData<feature_sz>, 0> &get_cmdline_targets(v
         }
 #endif
         auto fbit = find_feature_bit(feature_names, nfeature_names, str, len);
-        if (fbit == (uint32_t)-1)
+        if (fbit == UINT32_MAX)
             return false;
         set_bit(list, fbit, true);
         return true;
@@ -1603,7 +1603,7 @@ static uint32_t sysimg_init_cb(const void *id, jl_value_t **rejection_reason)
         }
     }
     auto match = match_sysimg_targets(sysimg, target, max_vector_size, rejection_reason);
-    if (match.best_idx == -1)
+    if (match.best_idx == UINT32_MAX)
         return match.best_idx;
     // Now we've decided on which sysimg version to use.
     // Make sure the JIT target is compatible with it and save the JIT target.
@@ -1865,7 +1865,7 @@ JL_DLLEXPORT jl_value_t* jl_check_pkgimage_clones(char *data)
     JL_GC_PUSH1(&rejection_reason);
     uint32_t match_idx = pkgimg_init_cb(data, &rejection_reason);
     JL_GC_POP();
-    if (match_idx == (uint32_t)-1)
+    if (match_idx == UINT32_MAX)
         return rejection_reason;
     return jl_nothing;
 }
diff --git a/src/processor_fallback.cpp b/src/processor_fallback.cpp
index 1c266e29e9dd7..87d72d5ba7958 100644
--- a/src/processor_fallback.cpp
+++ b/src/processor_fallback.cpp
@@ -179,7 +179,7 @@ JL_DLLEXPORT jl_value_t* jl_check_pkgimage_clones(char *data)
     JL_GC_PUSH1(&rejection_reason);
     uint32_t match_idx = pkgimg_init_cb(data, &rejection_reason);
     JL_GC_POP();
-    if (match_idx == (uint32_t)-1)
+    if (match_idx == UINT32_MAX)
         return rejection_reason;
     return jl_nothing;
 }
diff --git a/src/processor_x86.cpp b/src/processor_x86.cpp
index 24363d2d9d28f..7f173440c8b9b 100644
--- a/src/processor_x86.cpp
+++ b/src/processor_x86.cpp
@@ -786,7 +786,7 @@ static const llvm::SmallVector<TargetData<feature_sz>, 0> &get_cmdline_targets(v
 {
     auto feature_cb = [] (const char *str, size_t len, FeatureList<feature_sz> &list) {
         auto fbit = find_feature_bit(feature_names, nfeature_names, str, len);
-        if (fbit == (uint32_t)-1)
+        if (fbit == UINT32_MAX)
             return false;
         set_bit(list, fbit, true);
         return true;
@@ -880,7 +880,7 @@ static uint32_t sysimg_init_cb(const void *id, jl_value_t** rejection_reason)
                  "https://docs.julialang.org/en/v1/devdocs/sysimg/ for more.");
     }
     auto match = match_sysimg_targets(sysimg, target, max_vector_size, rejection_reason);
-    if (match.best_idx == (uint32_t)-1)
+    if (match.best_idx == UINT32_MAX)
         return match.best_idx;
     // Now we've decided on which sysimg version to use.
     // Make sure the JIT target is compatible with it and save the JIT target.
@@ -1058,7 +1058,7 @@ JL_DLLEXPORT jl_value_t* jl_check_pkgimage_clones(char *data)
     JL_GC_PUSH1(&rejection_reason);
     uint32_t match_idx = pkgimg_init_cb(data, &rejection_reason);
     JL_GC_POP();
-    if (match_idx == (uint32_t)-1)
+    if (match_idx == UINT32_MAX)
         return rejection_reason;
     return jl_nothing;
 }
diff --git a/src/smallintset.c b/src/smallintset.c
index df67239f79fb5..a80a18009c9db 100644
--- a/src/smallintset.c
+++ b/src/smallintset.c
@@ -36,7 +36,7 @@ static inline size_t jl_intref(const jl_genericmemory_t *arr, size_t idx) JL_NOT
     else if (el == jl_memory_uint16_type)
         return ignore_tombstone(jl_atomic_load_relaxed(&((_Atomic(uint16_t)*)arr->ptr)[idx]), (uint16_t)-1);
     else if (el == jl_memory_uint32_type)
-        return ignore_tombstone(jl_atomic_load_relaxed(&((_Atomic(uint32_t)*)arr->ptr)[idx]), (uint32_t)-1);
+        return ignore_tombstone(jl_atomic_load_relaxed(&((_Atomic(uint32_t)*)arr->ptr)[idx]), UINT32_MAX);
     else
         abort();
 }
@@ -53,7 +53,7 @@ static inline size_t jl_intref_acquire(const jl_genericmemory_t *arr, size_t idx
     else if (el == jl_memory_uint16_type)
         return acquire_tombstone(jl_atomic_load_acquire(&((_Atomic(uint16_t)*)arr->ptr)[idx]), (uint16_t)-1);
     else if (el == jl_memory_uint32_type)
-        return acquire_tombstone(jl_atomic_load_acquire(&((_Atomic(uint32_t)*)arr->ptr)[idx]), (uint32_t)-1);
+        return acquire_tombstone(jl_atomic_load_acquire(&((_Atomic(uint32_t)*)arr->ptr)[idx]), UINT32_MAX);
     else
         abort();
 }
diff --git a/src/support/utf8.h b/src/support/utf8.h
index f1c886e764064..eab86f602ee61 100644
--- a/src/support/utf8.h
+++ b/src/support/utf8.h
@@ -12,7 +12,7 @@ extern "C" {
 /* is c the start of a utf8 sequence? */
 #define isutf(c) (((c)&0xC0)!=0x80)
 
-#define UEOF ((uint32_t)-1)
+#define UEOF (UINT32_MAX)
 
 /* convert UTF-8 data to wide character */
 size_t u8_toucs(uint32_t *dest, size_t sz, const char *src, size_t srcsz);

From a0cee554ee1ca40dfcc9449ede733e0af5916b76 Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Mon, 11 Mar 2024 17:13:44 -0400
Subject: [PATCH 1109/1315] add check for invalid state in `_growend!`
 slow-path (#53513)

This only triggers in cases where the user has done something pretty bad
(e.g. modified the size incorrectly, or calling `push!` from multiple
threads on the same vector without a lock). I'm very unsure if
`ConcurrencyViolationError` is the right error to throw here, but I
think most of the time, that is going to be the cause. This check is in
the slow path because adding extra checks here is basically free (since
it will run rarely, and will be batched with O(n) work to copy
everything over).
---
 base/array.jl | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/base/array.jl b/base/array.jl
index 4fcf29af69b4b..76d5981ba8861 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -1068,6 +1068,9 @@ function _growbeg!(a::Vector, delta::Integer)
     else
         @noinline (function()
         memlen = length(mem)
+        if offset + len - 1 > memlen || offset < 1
+            throw(ConcurrencyViolationError("Vector has invalid state. Don't modify internal fields incorrectly, or resize without correct locks"))
+        end
         # since we will allocate the array in the middle of the memory we need at least 2*delta extra space
         # the +1 is because I didn't want to have an off by 1 error.
         newmemlen = max(overallocation(memlen), len + 2 * delta + 1)
@@ -1083,6 +1086,9 @@ function _growbeg!(a::Vector, delta::Integer)
             newmem = array_new_memory(mem, newmemlen)
         end
         unsafe_copyto!(newmem, newoffset + delta, mem, offset, len)
+        if ref !== a.ref
+            @noinline throw(ConcurrencyViolationError("Vector can not be resized concurrently"))
+        end
         setfield!(a, :ref, @inbounds GenericMemoryRef(newmem, newoffset))
         end)()
     end
@@ -1103,6 +1109,10 @@ function _growend!(a::Vector, delta::Integer)
     newmemlen = offset + newlen - 1
     if memlen < newmemlen
         @noinline (function()
+        if offset + len - 1 > memlen || offset < 1
+            throw(ConcurrencyViolationError("Vector has invalid state. Don't modify internal fields incorrectly, or resize without correct locks"))
+        end
+
         if offset - 1 > div(5 * newlen, 4)
             # If the offset is far enough that we can copy without resizing
             # while maintaining proportional spacing on both ends of the array
@@ -1120,6 +1130,9 @@ function _growend!(a::Vector, delta::Integer)
         end
         newref = @inbounds GenericMemoryRef(newmem, newoffset)
         unsafe_copyto!(newref, ref, len)
+        if ref !== a.ref
+            @noinline throw(ConcurrencyViolationError("Vector can not be resized concurrently"))
+        end
         setfield!(a, :ref, newref)
         end)()
     end

From 2d244019d375cf47ed34159fdef557a02ab82bad Mon Sep 17 00:00:00 2001
From: gbaraldi <baraldigabriel@gmail.com>
Date: Mon, 11 Mar 2024 17:51:26 -0400
Subject: [PATCH 1110/1315] Don't double increment nrunning when starting
 threads

---
 src/scheduler.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/scheduler.c b/src/scheduler.c
index 40f82180dfc89..54ccef1aa7c17 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -183,8 +183,6 @@ void jl_threadfun(void *arg)
     jl_init_stack_limits(0, &stack_lo, &stack_hi);
     // warning: this changes `jl_current_task`, so be careful not to call that from this function
     jl_task_t *ct = jl_init_root_task(ptls, stack_lo, stack_hi);
-    int wasrunning = jl_atomic_fetch_add_relaxed(&nrunning, 1);
-    assert(wasrunning); (void)wasrunning;
     JL_GC_PROMISE_ROOTED(ct);
 
     // wait for all threads

From a4783b0eefb6d0edbb08dc88497c64b316feed5e Mon Sep 17 00:00:00 2001
From: gbaraldi <baraldigabriel@gmail.com>
Date: Mon, 11 Mar 2024 18:25:27 -0400
Subject: [PATCH 1111/1315] Also don't increment it for gc threads

---
 src/scheduler.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/scheduler.c b/src/scheduler.c
index 54ccef1aa7c17..48a56cb00b8ad 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -129,7 +129,7 @@ void jl_parallel_gc_threadfun(void *arg)
 
     // initialize this thread (set tid and create heap)
     jl_ptls_t ptls = jl_init_threadtls(targ->tid);
-
+    (void)jl_atomic_fetch_add_relaxed(&nrunning, -1);
     // wait for all threads
     jl_gc_state_set(ptls, JL_GC_STATE_WAITING, JL_GC_STATE_UNSAFE);
     uv_barrier_wait(targ->barrier);
@@ -158,7 +158,7 @@ void jl_concurrent_gc_threadfun(void *arg)
 
     // initialize this thread (set tid and create heap)
     jl_ptls_t ptls = jl_init_threadtls(targ->tid);
-
+    (void)jl_atomic_fetch_add_relaxed(&nrunning, -1);
     // wait for all threads
     jl_gc_state_set(ptls, JL_GC_STATE_WAITING, JL_GC_STATE_UNSAFE);
     uv_barrier_wait(targ->barrier);

From dcfad21f3c72cf7460eef1912039c103fcbebd7a Mon Sep 17 00:00:00 2001
From: Kenta Murata <3959+mrkn@users.noreply.github.com>
Date: Tue, 12 Mar 2024 08:45:00 +0900
Subject: [PATCH 1112/1315] Add throw option in wait(::Task) (#53685)

As we discussed with @vtjnash in PR #53341, it might be useful to
introduce the `throw` option in the `wait` function for `Task`. If
`throw=false` is specified, `wait` behaves like `_wait`; it prevents
throwing a `TaskFailedException`.
---
 base/condition.jl |  4 +++-
 base/task.jl      |  6 +++---
 test/threads.jl   | 13 +++++++++++++
 3 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/base/condition.jl b/base/condition.jl
index 9f62593afaf77..a140903d52d41 100644
--- a/base/condition.jl
+++ b/base/condition.jl
@@ -113,7 +113,9 @@ Block the current task until some event occurs, depending on the type of the arg
 * `Process`: Wait for a process or process chain to exit. The `exitcode` field of a process
   can be used to determine success or failure.
 * [`Task`](@ref): Wait for a `Task` to finish. If the task fails with an exception, a
-  `TaskFailedException` (which wraps the failed task) is thrown.
+  `TaskFailedException` (which wraps the failed task) is thrown.  Waiting on a task
+  additionally allows passing `throw=false` which prevents throwing a `TaskFailedException`
+  when the task fails.
 * [`RawFD`](@ref): Wait for changes on a file descriptor (see the `FileWatching` package).
 
 If no argument is passed, the task blocks for an undefined period. A task can only be
diff --git a/base/task.jl b/base/task.jl
index 309ca43d632b1..2b758d342b169 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -356,11 +356,11 @@ function _wait2(t::Task, waiter::Task)
     nothing
 end
 
-function wait(t::Task)
+function wait(t::Task; throw=true)
     t === current_task() && error("deadlock detected: cannot wait on current task")
     _wait(t)
-    if istaskfailed(t)
-        throw(TaskFailedException(t))
+    if throw && istaskfailed(t)
+        Core.throw(TaskFailedException(t))
     end
     nothing
 end
diff --git a/test/threads.jl b/test/threads.jl
index 307742a4c292b..172385d1c130e 100644
--- a/test/threads.jl
+++ b/test/threads.jl
@@ -341,3 +341,16 @@ end
 @testset "Base.Threads docstrings" begin
     @test isempty(Docs.undocumented_names(Threads))
 end
+
+@testset "wait failed task" begin
+    @testset "wait without throw keyword" begin
+        t = Threads.@spawn error("Error")
+        @test_throws TaskFailedException wait(t)
+    end
+
+    @testset "wait with throw=false" begin
+        t = Threads.@spawn error("Error")
+        wait(t; throw=false)
+        @test istaskfailed(t)
+    end
+end

From dcd1fb2148dd7affee9449e304a9b42e7feba1ce Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 12 Mar 2024 07:34:25 +0530
Subject: [PATCH 1113/1315] LAPACK: validate input parameters to throw
 informative errors (#53631)

This PR validates the input parameters to the Julia LAPACK wrappers, so
that the error messages are more informative.
On nightly
```julia
julia> using LinearAlgebra

julia> LAPACK.geev!('X', 'X', rand(2,2))
 ** On entry to DGEEV  parameter number  1 had an illegal value
ERROR: ArgumentError: invalid argument #1 to LAPACK call
```
This PR
```julia
julia> using LinearAlgebra

julia> LAPACK.geev!('X', 'X', rand(2,2))
ERROR: ArgumentError: argument #1: jobvl must be one of ('N', 'V'), but 'X' was passed
```

Secondly, moved certain allocations (e.g. in `geevx`) below the
validation checks, so that these only happen for valid parameter values.

Thirdly, added `require_one_based_indexing` checks to functions where
these were missing.
---
 stdlib/LinearAlgebra/src/blas.jl    |   2 +-
 stdlib/LinearAlgebra/src/lapack.jl  | 240 ++++++++++++++++++++++------
 stdlib/LinearAlgebra/test/lapack.jl | 184 ++++++++++++++++-----
 3 files changed, 344 insertions(+), 82 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 7bf7f8bf95100..8903aaddcc11b 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -168,7 +168,7 @@ end
 "Check that upper/lower (for special matrices) is correctly specified"
 function chkuplo(uplo::AbstractChar)
     if !(uplo == 'U' || uplo == 'L')
-        throw(ArgumentError(lazy"uplo argument must be 'U' (upper) or 'L' (lower), got $uplo"))
+        throw(ArgumentError(lazy"uplo argument must be 'U' (upper) or 'L' (lower), got '$uplo'"))
     end
     uplo
 end
diff --git a/stdlib/LinearAlgebra/src/lapack.jl b/stdlib/LinearAlgebra/src/lapack.jl
index a85978435bf46..02dfa0079038b 100644
--- a/stdlib/LinearAlgebra/src/lapack.jl
+++ b/stdlib/LinearAlgebra/src/lapack.jl
@@ -55,10 +55,23 @@ function chkposdef(ret::BlasInt)
     end
 end
 
+# Generic fallback function to assert that parameters are valid
+# In specific cases, the following functions may be more useful
+macro chkvalidparam(position::Int, param, validvalues)
+    :(chkvalidparam($position, $(string(param)), $(esc(param)), $validvalues))
+end
+function chkvalidparam(position::Int, var::String, val, validvals)
+    if val ∉ validvals
+        throw(ArgumentError(
+            "argument #$position: $var must be one of $validvals, but $(repr(val)) was passed"))
+    end
+    return val
+end
+
 "Check that {c}transpose is correctly specified"
 function chktrans(trans::AbstractChar)
     if !(trans == 'N' || trans == 'C' || trans == 'T')
-        throw(ArgumentError("trans argument must be 'N' (no transpose), 'T' (transpose), or 'C' (conjugate transpose), got $trans"))
+        throw(ArgumentError("trans argument must be 'N' (no transpose), 'T' (transpose), or 'C' (conjugate transpose), got '$trans'"))
     end
     trans
 end
@@ -66,7 +79,7 @@ end
 "Check that left/right hand side multiply is correctly specified"
 function chkside(side::AbstractChar)
     if !(side == 'L' || side == 'R')
-        throw(ArgumentError("side argument must be 'L' (left hand multiply) or 'R' (right hand multiply), got $side"))
+        throw(ArgumentError("side argument must be 'L' (left hand multiply) or 'R' (right hand multiply), got '$side'"))
     end
     side
 end
@@ -74,7 +87,7 @@ end
 "Check that unit diagonal flag is correctly specified"
 function chkdiag(diag::AbstractChar)
     if !(diag == 'U' || diag =='N')
-        throw(ArgumentError("diag argument must be 'U' (unit diagonal) or 'N' (non-unit diagonal), got $diag"))
+        throw(ArgumentError("diag argument must be 'U' (unit diagonal) or 'N' (non-unit diagonal), got '$diag'"))
     end
     diag
 end
@@ -93,6 +106,7 @@ end
 
 function chkuplofinite(A::AbstractMatrix, uplo::AbstractChar)
     require_one_based_indexing(A)
+    chkuplo(uplo)
     m, n = size(A)
     if uplo == 'U'
         @inbounds for j in 1:n, i in 1:j
@@ -213,7 +227,9 @@ for (gebal, gebak, elty, relty) in
         #     .. Array Arguments ..
         #      DOUBLE PRECISION   A( LDA, * ), SCALE( * )
         function gebal!(job::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
+            @chkvalidparam 1 job ('N', 'P', 'S', 'B')
             n = checksquare(A)
             chkfinite(A) # balancing routines don't support NaNs and Infs
             ihi = Ref{BlasInt}()
@@ -238,6 +254,7 @@ for (gebal, gebak, elty, relty) in
                         ilo::BlasInt, ihi::BlasInt, scale::AbstractVector{$relty},
                         V::AbstractMatrix{$elty})
             require_one_based_indexing(scale, V)
+            @chkvalidparam 1 job ('N', 'P', 'S', 'B')
             chkstride1(scale, V)
             chkside(side)
             chkfinite(V) # balancing routines don't support NaNs and Infs
@@ -624,11 +641,13 @@ does not equal zero then the `j`th column of `A` is permuted to the front of
 geqp3!(A::AbstractMatrix, jpvt::AbstractVector{BlasInt}, tau::AbstractVector)
 
 function geqp3!(A::AbstractMatrix{<:BlasFloat}, jpvt::AbstractVector{BlasInt})
+    require_one_based_indexing(A, jpvt)
     m, n = size(A)
     geqp3!(A, jpvt, similar(A, min(m, n)))
 end
 
 function geqp3!(A::AbstractMatrix{<:BlasFloat})
+    require_one_based_indexing(A)
     m, n = size(A)
     geqp3!(A, zeros(BlasInt, n), similar(A, min(m, n)))
 end
@@ -777,6 +796,7 @@ for (larfg, elty) in
         #        .. Array Arguments ..
         #        DOUBLE PRECISION   x( * )
         function larfg!(x::AbstractVector{$elty})
+            require_one_based_indexing(x)
             N    = BlasInt(length(x))
             α    = Ref{$elty}(x[1])
             incx = BlasInt(1)
@@ -805,6 +825,7 @@ for (larf, elty) in
         #        DOUBLE PRECISION   c( ldc, * ), v( * ), work( * )
         function larf!(side::AbstractChar, v::AbstractVector{$elty},
                        τ::$elty, C::AbstractMatrix{$elty}, work::AbstractVector{$elty})
+            require_one_based_indexing(v, C, work)
             m, n = size(C)
             chkside(side)
             ldc = max(1, stride(C, 2))
@@ -820,6 +841,7 @@ for (larf, elty) in
 
         function larf!(side::AbstractChar, v::AbstractVector{$elty},
                        τ::$elty, C::AbstractMatrix{$elty})
+            require_one_based_indexing(v, C)
             m, n = size(C)
             chkside(side)
             lwork = side == 'L' ? n : m
@@ -1134,6 +1156,7 @@ for (gesvx, elty) in
                         AF::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt}, equed::AbstractChar,
                         R::AbstractVector{$elty}, C::AbstractVector{$elty}, B::AbstractVecOrMat{$elty})
             require_one_based_indexing(A, AF, ipiv, R, C, B)
+            @chkvalidparam 1 fact ('F', 'N', 'E')
             chktrans(trans)
             chkstride1(ipiv, R, C, B)
             n    = checksquare(A)
@@ -1168,6 +1191,7 @@ for (gesvx, elty) in
         end
 
         function gesvx!(A::AbstractMatrix{$elty}, B::AbstractVecOrMat{$elty})
+            require_one_based_indexing(A, B)
             n = size(A,1)
             X, equed, R, C, B, rcond, ferr, berr, rpgf =
                 gesvx!('N', 'N', A,
@@ -1204,6 +1228,7 @@ for (gesvx, elty, relty) in
                         AF::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt}, equed::AbstractChar,
                         R::AbstractVector{$relty}, C::AbstractVector{$relty}, B::AbstractVecOrMat{$elty})
             require_one_based_indexing(A, AF, ipiv, R, C, B)
+            @chkvalidparam 1 fact ('F', 'N', 'E')
             chktrans(trans)
             chkstride1(A, AF, ipiv, R, C, B)
             n   = checksquare(A)
@@ -1239,6 +1264,7 @@ for (gesvx, elty, relty) in
 
         #Wrapper for the no-equilibration, no-transpose calculation
         function gesvx!(A::AbstractMatrix{$elty}, B::AbstractVecOrMat{$elty})
+            require_one_based_indexing(A, B)
             n = size(A,1)
             X, equed, R, C, B, rcond, ferr, berr, rpgf =
                 gesvx!('N', 'N', A,
@@ -1577,8 +1603,11 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
         #       DOUBLE PRECISION   A( LDA, * ), VL( LDVL, * ), VR( LDVR, * ),
         #      $                   WI( * ), WORK( * ), WR( * )
         function geev!(jobvl::AbstractChar, jobvr::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
+            @chkvalidparam 1 jobvl ('N', 'V')
+            @chkvalidparam 2 jobvr ('N', 'V')
             chkfinite(A) # balancing routines don't support NaNs and Infs
             lvecs = jobvl == 'V'
             rvecs = jobvr == 'V'
@@ -1635,6 +1664,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
         function gesdd!(job::AbstractChar, A::AbstractMatrix{$elty})
             require_one_based_indexing(A)
             chkstride1(A)
+            @chkvalidparam 1 job ('A', 'S', 'O', 'N')
             m, n   = size(A)
             minmn  = min(m, n)
             if job == 'A'
@@ -1716,6 +1746,9 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
         function gesvd!(jobu::AbstractChar, jobvt::AbstractChar, A::AbstractMatrix{$elty})
             require_one_based_indexing(A)
             chkstride1(A)
+            @chkvalidparam 1 jobu ('A', 'S', 'O', 'N')
+            @chkvalidparam 2 jobvt ('A', 'S', 'O', 'N')
+            (jobu == jobvt == 'O') && throw(ArgumentError("jobu and jobvt cannot both be O"))
             m, n   = size(A)
             minmn  = min(m, n)
             S      = similar(A, $relty, minmn)
@@ -1785,6 +1818,9 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
         function ggsvd!(jobu::AbstractChar, jobv::AbstractChar, jobq::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
             require_one_based_indexing(A, B)
             chkstride1(A, B)
+            @chkvalidparam 1 jobu ('U', 'N')
+            @chkvalidparam 2 jobv ('V', 'N')
+            @chkvalidparam 3 jobq ('Q', 'N')
             m, n = size(A)
             if size(B, 2) != n
                 throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs $n"))
@@ -1912,6 +1948,9 @@ for (f, elty) in ((:dggsvd3_, :Float64),
         function ggsvd3!(jobu::AbstractChar, jobv::AbstractChar, jobq::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
             require_one_based_indexing(A, B)
             chkstride1(A, B)
+            @chkvalidparam 1 jobu ('U', 'N')
+            @chkvalidparam 2 jobv ('V', 'N')
+            @chkvalidparam 3 jobq ('Q', 'N')
             m, n = size(A)
             if size(B, 2) != n
                 throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs $n"))
@@ -1971,6 +2010,9 @@ for (f, elty, relty) in ((:zggsvd3_, :ComplexF64, :Float64),
         function ggsvd3!(jobu::AbstractChar, jobv::AbstractChar, jobq::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
             require_one_based_indexing(A, B)
             chkstride1(A, B)
+            @chkvalidparam 1 jobu ('U', 'N')
+            @chkvalidparam 2 jobv ('V', 'N')
+            @chkvalidparam 3 jobq ('Q', 'N')
             m, n = size(A)
             if size(B, 2) != n
                 throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs $n"))
@@ -2057,14 +2099,13 @@ for (geevx, ggev, ggev3, elty) in
         #      $                   SCALE( * ), VL( LDVL, * ), VR( LDVR, * ),
         #      $                   WI( * ), WORK( * ), WR( * )
         function geevx!(balanc::AbstractChar, jobvl::AbstractChar, jobvr::AbstractChar, sense::AbstractChar, A::AbstractMatrix{$elty})
-            n = checksquare(A)
-            chkfinite(A) # balancing routines don't support NaNs and Infs
-            lda = max(1,stride(A,2))
-            wr = similar(A, $elty, n)
-            wi = similar(A, $elty, n)
-            if balanc ∉ ['N', 'P', 'S', 'B']
-                throw(ArgumentError("balanc must be 'N', 'P', 'S', or 'B', but $balanc was passed"))
+            require_one_based_indexing(A)
+            @chkvalidparam 1 balanc ('N', 'P', 'S', 'B')
+            @chkvalidparam 4 sense ('N', 'E', 'V', 'B')
+            if sense ∈ ('E', 'B') && !(jobvl == jobvr == 'V')
+                throw(ArgumentError("sense = '$sense' requires jobvl = 'V' and jobvr = 'V'"))
             end
+            n = checksquare(A)
             ldvl = 0
             if jobvl == 'V'
                 ldvl = n
@@ -2073,7 +2114,6 @@ for (geevx, ggev, ggev3, elty) in
             else
                 throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
-            VL = similar(A, $elty, ldvl, n)
             ldvr = 0
             if jobvr == 'V'
                 ldvr = n
@@ -2082,6 +2122,11 @@ for (geevx, ggev, ggev3, elty) in
             else
                 throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
+            chkfinite(A) # balancing routines don't support NaNs and Infs
+            lda = max(1,stride(A,2))
+            wr = similar(A, $elty, n)
+            wi = similar(A, $elty, n)
+            VL = similar(A, $elty, ldvl, n)
             VR = similar(A, $elty, ldvr, n)
             ilo = Ref{BlasInt}()
             ihi = Ref{BlasInt}()
@@ -2143,11 +2188,6 @@ for (geevx, ggev, ggev3, elty) in
             if n != m
                 throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
-            lda = max(1, stride(A, 2))
-            ldb = max(1, stride(B, 2))
-            alphar = similar(A, $elty, n)
-            alphai = similar(A, $elty, n)
-            beta = similar(A, $elty, n)
             ldvl = 0
             if jobvl == 'V'
                 ldvl = n
@@ -2156,7 +2196,6 @@ for (geevx, ggev, ggev3, elty) in
             else
                 throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
-            vl = similar(A, $elty, ldvl, n)
             ldvr = 0
             if jobvr == 'V'
                 ldvr = n
@@ -2165,6 +2204,12 @@ for (geevx, ggev, ggev3, elty) in
             else
                 throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
+            lda = max(1, stride(A, 2))
+            ldb = max(1, stride(B, 2))
+            alphar = similar(A, $elty, n)
+            alphai = similar(A, $elty, n)
+            beta = similar(A, $elty, n)
+            vl = similar(A, $elty, ldvl, n)
             vr = similar(A, $elty, ldvr, n)
             work = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2207,11 +2252,6 @@ for (geevx, ggev, ggev3, elty) in
             if n != m
                 throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
-            lda = max(1, stride(A, 2))
-            ldb = max(1, stride(B, 2))
-            alphar = similar(A, $elty, n)
-            alphai = similar(A, $elty, n)
-            beta = similar(A, $elty, n)
             ldvl = 0
             if jobvl == 'V'
                 ldvl = n
@@ -2220,7 +2260,6 @@ for (geevx, ggev, ggev3, elty) in
             else
                 throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
-            vl = similar(A, $elty, ldvl, n)
             ldvr = 0
             if jobvr == 'V'
                 ldvr = n
@@ -2229,6 +2268,12 @@ for (geevx, ggev, ggev3, elty) in
             else
                 throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
+            lda = max(1, stride(A, 2))
+            ldb = max(1, stride(B, 2))
+            alphar = similar(A, $elty, n)
+            alphai = similar(A, $elty, n)
+            beta = similar(A, $elty, n)
+            vl = similar(A, $elty, ldvl, n)
             vr = similar(A, $elty, ldvr, n)
             work = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2275,13 +2320,17 @@ for (geevx, ggev, ggev3, elty, relty) in
         #       COMPLEX*16         A( LDA, * ), VL( LDVL, * ), VR( LDVR, * ),
         #      $                   W( * ), WORK( * )
         function geevx!(balanc::AbstractChar, jobvl::AbstractChar, jobvr::AbstractChar, sense::AbstractChar, A::AbstractMatrix{$elty})
-            n = checksquare(A)
-            chkfinite(A) # balancing routines don't support NaNs and Infs
-            lda = max(1,stride(A,2))
-            w = similar(A, $elty, n)
-            if balanc ∉ ['N', 'P', 'S', 'B']
+            require_one_based_indexing(A)
+            if balanc ∉ ('N', 'P', 'S', 'B')
                 throw(ArgumentError("balanc must be 'N', 'P', 'S', or 'B', but $balanc was passed"))
             end
+            if sense ∉ ('N','E','V','B')
+                throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
+            end
+            if sense ∈ ('E', 'B') && !(jobvl == jobvr == 'V')
+                throw(ArgumentError("sense = '$sense' requires jobvl = 'V' and jobvr = 'V'"))
+            end
+            n = checksquare(A)
             ldvl = 0
             if jobvl == 'V'
                 ldvl = n
@@ -2290,7 +2339,6 @@ for (geevx, ggev, ggev3, elty, relty) in
             else
                 throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
-            VL = similar(A, $elty, ldvl, n)
             ldvr = 0
             if jobvr == 'V'
                 ldvr = n
@@ -2299,9 +2347,10 @@ for (geevx, ggev, ggev3, elty, relty) in
             else
                 throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
-            if sense ∉ ['N','E','V','B']
-                throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
-            end
+            chkfinite(A) # balancing routines don't support NaNs and Infs
+            lda = max(1,stride(A,2))
+            w = similar(A, $elty, n)
+            VL = similar(A, $elty, ldvl, n)
             VR = similar(A, $elty, ldvr, n)
             ilo = Ref{BlasInt}()
             ihi = Ref{BlasInt}()
@@ -2354,10 +2403,6 @@ for (geevx, ggev, ggev3, elty, relty) in
             if n != m
                 throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
-            lda = max(1, stride(A, 2))
-            ldb = max(1, stride(B, 2))
-            alpha = similar(A, $elty, n)
-            beta = similar(A, $elty, n)
             ldvl = 0
             if jobvl == 'V'
                 ldvl = n
@@ -2366,7 +2411,6 @@ for (geevx, ggev, ggev3, elty, relty) in
             else
                 throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
-            vl = similar(A, $elty, ldvl, n)
             ldvr = 0
             if jobvr == 'V'
                 ldvr = n
@@ -2375,6 +2419,11 @@ for (geevx, ggev, ggev3, elty, relty) in
             else
                 throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
+            lda = max(1, stride(A, 2))
+            ldb = max(1, stride(B, 2))
+            alpha = similar(A, $elty, n)
+            beta = similar(A, $elty, n)
+            vl = similar(A, $elty, ldvl, n)
             vr = similar(A, $elty, ldvr, n)
             work = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2419,10 +2468,6 @@ for (geevx, ggev, ggev3, elty, relty) in
             if n != m
                 throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
-            lda = max(1, stride(A, 2))
-            ldb = max(1, stride(B, 2))
-            alpha = similar(A, $elty, n)
-            beta = similar(A, $elty, n)
             ldvl = 0
             if jobvl == 'V'
                 ldvl = n
@@ -2431,7 +2476,6 @@ for (geevx, ggev, ggev3, elty, relty) in
             else
                 throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
-            vl = similar(A, $elty, ldvl, n)
             ldvr = 0
             if jobvr == 'V'
                 ldvr = n
@@ -2440,6 +2484,11 @@ for (geevx, ggev, ggev3, elty, relty) in
             else
                 throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
+            lda = max(1, stride(A, 2))
+            ldb = max(1, stride(B, 2))
+            alpha = similar(A, $elty, n)
+            beta = similar(A, $elty, n)
+            vl = similar(A, $elty, ldvl, n)
             vr = similar(A, $elty, ldvr, n)
             work = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2524,6 +2573,7 @@ for (laic1, elty) in
         function laic1!(job::Integer, x::AbstractVector{$elty},
                         sest::$elty, w::AbstractVector{$elty}, gamma::$elty)
             require_one_based_indexing(x, w)
+            @chkvalidparam 1 job (1,2)
             j = length(x)
             if j != length(w)
                 throw(DimensionMismatch("vectors must have same length, but length of x is $j and length of w is $(length(w))"))
@@ -2558,6 +2608,7 @@ for (laic1, elty, relty) in
         function laic1!(job::Integer, x::AbstractVector{$elty},
                         sest::$relty, w::AbstractVector{$elty}, gamma::$elty)
             require_one_based_indexing(x, w)
+            @chkvalidparam 1 job (1,2)
             j = length(x)
             if j != length(w)
                 throw(DimensionMismatch("vectors must have same length, but length of x is $j and length of w is $(length(w))"))
@@ -3303,6 +3354,7 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
         #       DOUBLE PRECISION   A( LDA, * ), WORK( 2*N )
         #       INTEGER            PIV( N )
         function pstrf!(uplo::AbstractChar, A::AbstractMatrix{$elty}, tol::Real)
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -3534,6 +3586,7 @@ for (trtri, trtrs, elty) in
         #     .. Array Arguments ..
         #      DOUBLE PRECISION   A( LDA, * )
         function trtri!(uplo::AbstractChar, diag::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -3616,10 +3669,12 @@ for (trcon, trevc, trrfs, elty) in
         # INTEGER            IWORK( * )
         # DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function trcon!(norm::AbstractChar, uplo::AbstractChar, diag::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             chkdiag(diag)
             n = checksquare(A)
             chkuplo(uplo)
+            @chkvalidparam 1 norm ('O', '1', 'I')
             rcond = Ref{$elty}()
             work  = Vector{$elty}(undef, 3n)
             iwork = Vector{BlasInt}(undef, n)
@@ -3651,9 +3706,10 @@ for (trcon, trevc, trrfs, elty) in
                         VR::AbstractMatrix{$elty} = similar(T))
             require_one_based_indexing(select, T, VL, VR)
             # Extract
-            if side ∉ ['L','R','B']
+            if side ∉ ('L','R','B')
                 throw(ArgumentError("side argument must be 'L' (left eigenvectors), 'R' (right eigenvectors), or 'B' (both), got $side"))
             end
+            @chkvalidparam 2 howmny ('A', 'B', 'S')
             n, mm = checksquare(T), size(VL, 2)
             ldt, ldvl, ldvr = stride(T, 2), stride(VL, 2), stride(VR, 2)
 
@@ -3749,8 +3805,10 @@ for (trcon, trevc, trrfs, elty, relty) in
         # DOUBLE PRECISION   RWORK( * )
         # COMPLEX*16         A( LDA, * ), WORK( * )
         function trcon!(norm::AbstractChar, uplo::AbstractChar, diag::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
+            @chkvalidparam 1 norm ('O', '1', 'I')
             chkuplo(uplo)
             chkdiag(diag)
             rcond = Ref{$relty}(1)
@@ -3790,9 +3848,10 @@ for (trcon, trevc, trrfs, elty, relty) in
 
             # Check
             chkstride1(T, select, VL, VR)
-            if side ∉ ['L','R','B']
+            if side ∉ ('L','R','B')
                 throw(ArgumentError("side argument must be 'L' (left eigenvectors), 'R' (right eigenvectors), or 'B' (both), got $side"))
             end
+            @chkvalidparam 2 howmny ('A', 'B', 'S')
 
             # Allocate
             m = Ref{BlasInt}()
@@ -3919,6 +3978,7 @@ for (stev, stebz, stegr, stein, elty) in
     @eval begin
         function stev!(job::AbstractChar, dv::AbstractVector{$elty}, ev::AbstractVector{$elty})
             require_one_based_indexing(dv, ev)
+            @chkvalidparam 1 job ('N', 'V')
             chkstride1(dv, ev)
             n = length(dv)
             if length(ev) != n - 1 && length(ev) != n
@@ -3941,6 +4001,8 @@ for (stev, stebz, stegr, stein, elty) in
         #*  eigenvalues.
         function stebz!(range::AbstractChar, order::AbstractChar, vl::$elty, vu::$elty, il::Integer, iu::Integer, abstol::Real, dv::AbstractVector{$elty}, ev::AbstractVector{$elty})
             require_one_based_indexing(dv, ev)
+            @chkvalidparam 1 range ('A', 'V', 'I')
+            @chkvalidparam 2 order ('B', 'E')
             chkstride1(dv, ev)
             n = length(dv)
             if length(ev) != n - 1
@@ -3972,6 +4034,8 @@ for (stev, stebz, stegr, stein, elty) in
 
         function stegr!(jobz::AbstractChar, range::AbstractChar, dv::AbstractVector{$elty}, ev::AbstractVector{$elty}, vl::Real, vu::Real, il::Integer, iu::Integer)
             require_one_based_indexing(dv, ev)
+            @chkvalidparam 1 jobz ('N', 'V')
+            @chkvalidparam 2 range ('A', 'V', 'I')
             chkstride1(dv, ev)
             n = length(dv)
             ne = length(ev)
@@ -4144,6 +4208,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         #       INTEGER            IPIV( * )
         #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function syconv!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A, ipiv)
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4201,6 +4266,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         #       INTEGER            IPIV( * )
         #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function sytrf!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4225,6 +4291,8 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         end
 
         function sytrf!(uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
+            chkuplo(uplo)
             n = checksquare(A)
             ipiv = similar(A, BlasInt, n)
             sytrf!(uplo, A, ipiv)
@@ -4267,6 +4335,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         #      INTEGER            IPIV( * )
         #      DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function sytri!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A, ipiv)
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4358,6 +4427,7 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty) in
         #       INTEGER            IPIV( * )
         #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function sytrf_rook!(uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4390,6 +4460,7 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty) in
         #      INTEGER            IPIV( * )
         #      DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function sytri_rook!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A, ipiv)
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4492,6 +4563,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
        #        INTEGER            IPIV( * )
        #        COMPLEX*16         A( LDA, * ), WORK( * )
         function syconv!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A,ipiv)
             chkstride1(A,ipiv)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4549,6 +4621,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
         #       INTEGER            IPIV( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function hetrf!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4570,6 +4643,8 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
         end
 
         function hetrf!(uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
+            chkuplo(uplo)
             n = checksquare(A)
             ipiv = similar(A, BlasInt, n)
             hetrf!(uplo, A, ipiv)
@@ -4614,6 +4689,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
         #       INTEGER            IPIV( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function hetri!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A, ipiv)
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4638,6 +4714,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
         function hetrs!(uplo::AbstractChar, A::AbstractMatrix{$elty},
                        ipiv::AbstractVector{BlasInt}, B::AbstractVecOrMat{$elty})
             require_one_based_indexing(A, ipiv, B)
+            chkuplo(uplo)
             chkstride1(A,B,ipiv)
             n = checksquare(A)
             if n != size(B,1)
@@ -4702,6 +4779,7 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
         #       INTEGER            IPIV( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function hetrf_rook!(uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4732,6 +4810,7 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
         #       INTEGER            IPIV( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function hetri_rook!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A,ipiv)
             chkstride1(A,ipiv)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4757,6 +4836,7 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
                              ipiv::AbstractVector{BlasInt}, B::AbstractVecOrMat{$elty})
             require_one_based_indexing(A, ipiv, B)
             chkstride1(A,B,ipiv)
+            chkuplo(uplo)
             n = checksquare(A)
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
@@ -4822,6 +4902,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
         #       INTEGER            IPIV( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function sytrf!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4846,6 +4927,8 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
         end
 
         function sytrf!(uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
+            chkuplo(uplo)
             n = checksquare(A)
             ipiv = similar(A, BlasInt, n)
             sytrf!(uplo, A, ipiv)
@@ -4889,6 +4972,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
         #       INTEGER            IPIV( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function sytri!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A, ipiv)
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
@@ -4980,6 +5064,7 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty, relty) in
         #       INTEGER            IPIV( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function sytrf_rook!(uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -5013,6 +5098,7 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty, relty) in
         #       INTEGER            IPIV( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function sytri_rook!(uplo::AbstractChar, A::AbstractMatrix{$elty}, ipiv::AbstractVector{BlasInt})
+            require_one_based_indexing(A, ipiv)
             chkstride1(A, ipiv)
             n = checksquare(A)
             chkuplo(uplo)
@@ -5240,6 +5326,9 @@ for (syev, syevr, syevd, sygvd, elty) in
         # *     .. Array Arguments ..
         #       DOUBLE PRECISION   A( LDA, * ), W( * ), WORK( * )
         function syev!(jobz::AbstractChar, uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
+            @chkvalidparam 1 jobz ('N', 'V')
+            chkuplo(uplo)
             chkstride1(A)
             n = checksquare(A)
             W     = similar(A, $elty, n)
@@ -5273,15 +5362,18 @@ for (syev, syevr, syevd, sygvd, elty) in
         #       DOUBLE PRECISION   A( LDA, * ), W( * ), WORK( * ), Z( LDZ, * )
         function syevr!(jobz::AbstractChar, range::AbstractChar, uplo::AbstractChar, A::AbstractMatrix{$elty},
                         vl::AbstractFloat, vu::AbstractFloat, il::Integer, iu::Integer, abstol::AbstractFloat)
+            require_one_based_indexing(A)
+            @chkvalidparam 1 jobz ('N', 'V')
+            @chkvalidparam 2 range ('A', 'V', 'I')
             chkstride1(A)
             n = checksquare(A)
-            chkuplofinite(A, uplo)
             if range == 'I' && !(1 <= il <= iu <= n)
                 throw(ArgumentError("illegal choice of eigenvalue indices (il = $il, iu = $iu), which must be between 1 and n = $n"))
             end
             if range == 'V' && vl >= vu
                 throw(ArgumentError("lower boundary, $vl, must be less than upper boundary, $vu"))
             end
+            chkuplofinite(A, uplo)
             lda = stride(A,2)
             m = Ref{BlasInt}()
             W = similar(A, $elty, n)
@@ -5334,6 +5426,8 @@ for (syev, syevr, syevd, sygvd, elty) in
         #       INTEGER            IWORK( * )
         #       DOUBLE PRECISION   A( LDA, * ), W( * ), WORK( * )
         function syevd!(jobz::AbstractChar, uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
+            @chkvalidparam 1 jobz ('N', 'V')
             chkstride1(A)
             n = checksquare(A)
             chkuplofinite(A, uplo)
@@ -5375,6 +5469,10 @@ for (syev, syevr, syevd, sygvd, elty) in
         #       INTEGER            IWORK( * )
         #       DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), W( * ), WORK( * )
         function sygvd!(itype::Integer, jobz::AbstractChar, uplo::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
+            require_one_based_indexing(A, B)
+            @chkvalidparam 1 itype 1:3
+            @chkvalidparam 2 jobz ('N', 'V')
+            chkuplo(uplo)
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
@@ -5425,6 +5523,8 @@ for (syev, syevr, syevd, sygvd, elty, relty) in
         #       DOUBLE PRECISION   RWORK( * ), W( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function syev!(jobz::AbstractChar, uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
+            @chkvalidparam 1 jobz ('N', 'V')
             chkstride1(A)
             chkuplofinite(A, uplo)
             n = checksquare(A)
@@ -5464,6 +5564,9 @@ for (syev, syevr, syevd, sygvd, elty, relty) in
         #       COMPLEX*16         A( LDA, * ), WORK( * ), Z( LDZ, * )
         function syevr!(jobz::AbstractChar, range::AbstractChar, uplo::AbstractChar, A::AbstractMatrix{$elty},
                         vl::AbstractFloat, vu::AbstractFloat, il::Integer, iu::Integer, abstol::AbstractFloat)
+            require_one_based_indexing(A)
+            @chkvalidparam 1 jobz ('N', 'V')
+            @chkvalidparam 2 range ('A', 'V', 'I')
             chkstride1(A)
             chkuplofinite(A, uplo)
             n = checksquare(A)
@@ -5533,6 +5636,8 @@ for (syev, syevr, syevd, sygvd, elty, relty) in
         #       DOUBLE PRECISION   RWORK( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function syevd!(jobz::AbstractChar, uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
+            @chkvalidparam 1 jobz ('N', 'V')
             chkstride1(A)
             chkuplofinite(A, uplo)
             n = checksquare(A)
@@ -5578,6 +5683,9 @@ for (syev, syevr, syevd, sygvd, elty, relty) in
         #       DOUBLE PRECISION   RWORK( * ), W( * )
         #       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
         function sygvd!(itype::Integer, jobz::AbstractChar, uplo::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
+            require_one_based_indexing(A, B)
+            @chkvalidparam 1 itype 1:3
+            @chkvalidparam 2 jobz ('N', 'V')
             chkstride1(A, B)
             chkuplofinite(A, uplo)
             chkuplofinite(B, uplo)
@@ -5827,6 +5935,8 @@ for (gecon, elty) in
         #       INTEGER            IWORK( * )
         #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function gecon!(normtype::AbstractChar, A::AbstractMatrix{$elty}, anorm::$elty)
+            require_one_based_indexing(A)
+            @chkvalidparam 1 normtype ('0', '1', 'I')
             chkstride1(A)
             n = checksquare(A)
             lda = max(1, stride(A, 2))
@@ -5861,6 +5971,8 @@ for (gecon, elty, relty) in
         #       DOUBLE PRECISION   RWORK( * )
         #       COMPLEX*16         A( LDA, * ), WORK( * )
         function gecon!(normtype::AbstractChar, A::AbstractMatrix{$elty}, anorm::$relty)
+            require_one_based_indexing(A)
+            @chkvalidparam 1 normtype ('0', '1', 'I')
             chkstride1(A)
             n = checksquare(A)
             lda = max(1, stride(A, 2))
@@ -5903,6 +6015,7 @@ for (gehrd, elty) in
         # *     .. Array Arguments ..
         #       DOUBLE PRECISION  A( LDA, * ), TAU( * ), WORK( * )
         function gehrd!(ilo::Integer, ihi::Integer, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkfinite(A) # balancing routines don't support NaNs and Infs
@@ -6005,6 +6118,8 @@ for (ormhr, elty) in
 
             require_one_based_indexing(A, tau, C)
             chkstride1(A, tau, C)
+            chkside(side)
+            chktrans(trans)
             n = checksquare(A)
             mC, nC = size(C, 1), size(C, 2)
 
@@ -6052,6 +6167,8 @@ for (hseqr, elty) in
         function hseqr!(job::AbstractChar, compz::AbstractChar, ilo::Integer, ihi::Integer,
                         H::AbstractMatrix{$elty}, Z::AbstractMatrix{$elty})
             require_one_based_indexing(H, Z)
+            @chkvalidparam 1 job ('E', 'S')
+            @chkvalidparam 2 compz ('N', 'I', 'V')
             chkstride1(H)
             n = checksquare(H)
             checksquare(Z) == n || throw(DimensionMismatch())
@@ -6094,6 +6211,8 @@ for (hseqr, elty) in
         function hseqr!(job::AbstractChar, compz::AbstractChar, ilo::Integer, ihi::Integer,
                         H::AbstractMatrix{$elty}, Z::AbstractMatrix{$elty})
             require_one_based_indexing(H, Z)
+            @chkvalidparam 1 job ('E', 'S')
+            @chkvalidparam 2 compz ('N', 'I', 'V')
             chkstride1(H)
             n = checksquare(H)
             checksquare(Z) == n || throw(DimensionMismatch())
@@ -6152,6 +6271,7 @@ for (hetrd, elty) in
         # *     .. Array Arguments ..
         #       DOUBLE PRECISION  A( LDA, * ), D( * ), E( * ), TAU( * ), WORK( * )
         function hetrd!(uplo::AbstractChar, A::AbstractMatrix{$elty})
+            require_one_based_indexing(A)
             chkstride1(A)
             n = checksquare(A)
             chkuplo(uplo)
@@ -6257,7 +6377,9 @@ for (ormtr, elty) in
             require_one_based_indexing(A, tau, C)
             chkstride1(A, tau, C)
             n = checksquare(A)
+            chkside(side)
             chkuplo(uplo)
+            chktrans(trans)
             mC, nC = size(C, 1), size(C, 2)
 
             if n - length(tau) != 1
@@ -6305,6 +6427,7 @@ for (gees, gges, gges3, elty) in
         #    $                   WR( * )
         function gees!(jobvs::AbstractChar, A::AbstractMatrix{$elty})
             require_one_based_indexing(A)
+            @chkvalidparam 1 jobvs ('N', 'V')
             chkstride1(A)
             n     = checksquare(A)
             sdim  = Vector{BlasInt}(undef, 1)
@@ -6344,6 +6467,9 @@ for (gees, gges, gges3, elty) in
         #      $                   B( LDB, * ), BETA( * ), VSL( LDVSL, * ),
         #      $                   VSR( LDVSR, * ), WORK( * )
         function gges!(jobvsl::AbstractChar, jobvsr::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
+            require_one_based_indexing(A, B)
+            @chkvalidparam 1 jobvsl ('N', 'V')
+            @chkvalidparam 2 jobvsr ('N', 'V')
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
@@ -6393,6 +6519,9 @@ for (gees, gges, gges3, elty) in
         #      $                   B( LDB, * ), BETA( * ), VSL( LDVSL, * ),
         #      $                   VSR( LDVSR, * ), WORK( * )
         function gges3!(jobvsl::AbstractChar, jobvsr::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
+            require_one_based_indexing(A, B)
+            @chkvalidparam 1 jobvsl ('N', 'V')
+            @chkvalidparam 2 jobvsr ('N', 'V')
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
@@ -6448,6 +6577,7 @@ for (gees, gges, gges3, elty, relty) in
         #       COMPLEX*16         A( LDA, * ), VS( LDVS, * ), W( * ), WORK( * )
         function gees!(jobvs::AbstractChar, A::AbstractMatrix{$elty})
             require_one_based_indexing(A)
+            @chkvalidparam 1 jobvs ('N', 'V')
             chkstride1(A)
             n     = checksquare(A)
             sort  = 'N'
@@ -6489,6 +6619,9 @@ for (gees, gges, gges3, elty, relty) in
         #      $                   BETA( * ), VSL( LDVSL, * ), VSR( LDVSR, * ),
         #      $                   WORK( * )
         function gges!(jobvsl::AbstractChar, jobvsr::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
+            require_one_based_indexing(A, B)
+            @chkvalidparam 1 jobvsl ('N', 'V')
+            @chkvalidparam 2 jobvsr ('N', 'V')
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
@@ -6539,6 +6672,9 @@ for (gees, gges, gges3, elty, relty) in
         #      $                   BETA( * ), VSL( LDVSL, * ), VSR( LDVSR, * ),
         #      $                   WORK( * )
         function gges3!(jobvsl::AbstractChar, jobvsr::AbstractChar, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
+            require_one_based_indexing(A, B)
+            @chkvalidparam 1 jobvsl ('N', 'V')
+            @chkvalidparam 2 jobvsr ('N', 'V')
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
@@ -6627,6 +6763,8 @@ for (trexc, trsen, tgsen, elty) in
         # *     .. Array Arguments ..
         #       DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WORK( * )
         function trexc!(compq::AbstractChar, ifst::BlasInt, ilst::BlasInt, T::AbstractMatrix{$elty}, Q::AbstractMatrix{$elty})
+            require_one_based_indexing(T, Q)
+            @chkvalidparam 1 compq ('V', 'N')
             chkstride1(T, Q)
             n = checksquare(T)
             ldt = max(1, stride(T, 2))
@@ -6659,6 +6797,9 @@ for (trexc, trsen, tgsen, elty) in
         #       DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WI( * ), WORK( * ), WR( * )
         function trsen!(job::AbstractChar, compq::AbstractChar, select::AbstractVector{BlasInt},
                         T::AbstractMatrix{$elty}, Q::AbstractMatrix{$elty})
+            require_one_based_indexing(T, Q, select)
+            @chkvalidparam 1 job ('N', 'E', 'V', 'B')
+            @chkvalidparam 2 compq ('V', 'N')
             chkstride1(T, Q, select)
             n = checksquare(T)
             ldt = max(1, stride(T, 2))
@@ -6714,6 +6855,7 @@ for (trexc, trsen, tgsen, elty) in
         #        ..
         function tgsen!(select::AbstractVector{BlasInt}, S::AbstractMatrix{$elty}, T::AbstractMatrix{$elty},
                         Q::AbstractMatrix{$elty}, Z::AbstractMatrix{$elty})
+            require_one_based_indexing(select, S, T, Q, Z)
             chkstride1(select, S, T, Q, Z)
             n, nt, nq, nz = checksquare(S, T, Q, Z)
             if n != nt
@@ -6779,6 +6921,8 @@ for (trexc, trsen, tgsen, elty, relty) in
         #      .. Array Arguments ..
         #      DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WORK( * )
         function trexc!(compq::AbstractChar, ifst::BlasInt, ilst::BlasInt, T::AbstractMatrix{$elty}, Q::AbstractMatrix{$elty})
+            require_one_based_indexing(T, Q)
+            @chkvalidparam 1 compq ('V', 'N')
             chkstride1(T, Q)
             n = checksquare(T)
             ldt = max(1, stride(T, 2))
@@ -6809,6 +6953,9 @@ for (trexc, trsen, tgsen, elty, relty) in
         #      COMPLEX            Q( LDQ, * ), T( LDT, * ), W( * ), WORK( * )
         function trsen!(job::AbstractChar, compq::AbstractChar, select::AbstractVector{BlasInt},
                         T::AbstractMatrix{$elty}, Q::AbstractMatrix{$elty})
+            require_one_based_indexing(select, T, Q)
+            @chkvalidparam 1 job ('N', 'E', 'V', 'B')
+            @chkvalidparam 2 compq ('N', 'V')
             chkstride1(select, T, Q)
             n = checksquare(T)
             ldt = max(1, stride(T, 2))
@@ -6859,6 +7006,7 @@ for (trexc, trsen, tgsen, elty, relty) in
         #        ..
         function tgsen!(select::AbstractVector{BlasInt}, S::AbstractMatrix{$elty}, T::AbstractMatrix{$elty},
                         Q::AbstractMatrix{$elty}, Z::AbstractMatrix{$elty})
+            require_one_based_indexing(select, S, T, Q, Z)
             chkstride1(select, S, T, Q, Z)
             n, nt, nq, nz = checksquare(S, T, Q, Z)
             if n != nt
@@ -6959,6 +7107,8 @@ for (fn, elty, relty) in ((:dtrsyl_, :Float64, :Float64),
         function trsyl!(transa::AbstractChar, transb::AbstractChar, A::AbstractMatrix{$elty},
                         B::AbstractMatrix{$elty}, C::AbstractMatrix{$elty}, isgn::Int=1)
             require_one_based_indexing(A, B, C)
+            chktrans(transa)
+            chktrans(transb)
             chkstride1(A, B, C)
             m, n = checksquare(A), checksquare(B)
             lda = max(1, stride(A, 2))
diff --git a/stdlib/LinearAlgebra/test/lapack.jl b/stdlib/LinearAlgebra/test/lapack.jl
index 6e12c85204a78..652c6c2e27e6c 100644
--- a/stdlib/LinearAlgebra/test/lapack.jl
+++ b/stdlib/LinearAlgebra/test/lapack.jl
@@ -9,6 +9,7 @@ using LinearAlgebra: BlasInt
 @test_throws ArgumentError LinearAlgebra.LAPACK.chkside('Z')
 @test_throws ArgumentError LinearAlgebra.LAPACK.chkdiag('Z')
 @test_throws ArgumentError LinearAlgebra.LAPACK.chktrans('Z')
+@test_throws ArgumentError LinearAlgebra.LAPACK.chkvalidparam(1, "job", 2, (0,1))
 
 @testset "syevr" begin
     Random.seed!(123)
@@ -35,6 +36,12 @@ using LinearAlgebra: BlasInt
         @test vals_test ≈ vals
         @test Z_test*(Diagonal(vals)*Z_test') ≈ Asym
         @test_throws DimensionMismatch LAPACK.sygvd!(1, 'V', 'U', copy(Asym), zeros(elty, 6, 6))
+
+        @test_throws "jobz must be one of ('N', 'V'), but 'X' was passed" LAPACK.syevr!('X', Asym)
+        @test_throws "jobz must be one of ('N', 'V'), but 'X' was passed" LAPACK.syev!('X', 'U', Asym)
+        @test_throws "uplo argument must be 'U' (upper) or 'L' (lower), got 'M'" LAPACK.syev!('N', 'M', Asym)
+        @test_throws "jobz must be one of ('N', 'V'), but 'X' was passed" LAPACK.syevd!('X', 'U', Asym)
+        @test_throws "uplo argument must be 'U' (upper) or 'L' (lower), got 'M'" LAPACK.syevd!('N', 'M', Asym)
     end
 end
 
@@ -112,7 +119,9 @@ end
         D = LAPACK.gbtrs!('N',2,1,6,AB,ipiv,D)
         A = diagm(-2 => dl2, -1 => dl, 0 => d, 1 => du)
         @test A\C ≈ D
-        @test_throws DimensionMismatch LAPACK.gbtrs!('N',2,1,6,AB,ipiv,Matrix{elty}(undef,7,6))
+        M = Matrix{elty}(undef,7,6)
+        @test_throws DimensionMismatch LAPACK.gbtrs!('N',2,1,6,AB,ipiv,M)
+        @test_throws ArgumentError LAPACK.gbtrs!('M',2,1,6,AB,ipiv,M)
         @test_throws LinearAlgebra.LAPACKException LAPACK.gbtrf!(2,1,6,zeros(elty,6,6))
     end
 end
@@ -141,9 +150,11 @@ end
         x10, x11 = Vector{LinearAlgebra.BlasInt}.(undef, (10, 11))
         @test_throws DimensionMismatch LAPACK.gels!('N',A10x10,B11x11)
         @test_throws DimensionMismatch LAPACK.gels!('T',A10x10,B11x11)
+        @test_throws ArgumentError LAPACK.gels!('X',A10x10,B11x11)
         @test_throws DimensionMismatch LAPACK.gesv!(A10x10,B11x11)
         @test_throws DimensionMismatch LAPACK.getrs!('N',A10x10,x10,B11x11)
         @test_throws DimensionMismatch LAPACK.getrs!('T',A10x10,x10,B11x11)
+        @test_throws ArgumentError LAPACK.getrs!('X',A10x10,x10,B11x11)
         @test_throws DimensionMismatch LAPACK.getri!(A10x10,x11)
     end
 end
@@ -177,12 +188,20 @@ end
         @test U ≈ lU
         @test S ≈ lS
         @test V' ≈ lVt
+        @test_throws ArgumentError LAPACK.gesvd!('X','S',A)
+        @test_throws ArgumentError LAPACK.gesvd!('S','X',A)
         B = rand(elty,10,10)
         # xggsvd3 replaced xggsvd in LAPACK 3.6.0
         if LAPACK.version() < v"3.6.0"
-            @test_throws DimensionMismatch LAPACK.ggsvd!('S','S','S',A,B)
+            @test_throws DimensionMismatch LAPACK.ggsvd!('N','N','N',A,B)
+            @test_throws ArgumentError LAPACK.ggsvd!('X','N','N',A,B)
+            @test_throws ArgumentError LAPACK.ggsvd!('N','X','N',A,B)
+            @test_throws ArgumentError LAPACK.ggsvd!('N','N','X',A,B)
         else
-            @test_throws DimensionMismatch LAPACK.ggsvd3!('S','S','S',A,B)
+            @test_throws DimensionMismatch LAPACK.ggsvd3!('N','N','N',A,B)
+            @test_throws ArgumentError LAPACK.ggsvd3!('X','N','N',A,B)
+            @test_throws ArgumentError LAPACK.ggsvd3!('N','X','N',A,B)
+            @test_throws ArgumentError LAPACK.ggsvd3!('N','N','X',A,B)
         end
     end
 end
@@ -224,6 +243,7 @@ end
         X = rand(elty,10)
         B,Y,z = LAPACK.gels!('N',copy(A),copy(X))
         @test A\X ≈ Y
+        @test_throws ArgumentError LAPACK.gels!('X',A,X)
     end
 end
 
@@ -252,6 +272,9 @@ end
         fA = eigen(A, sortby=nothing)
         @test fA.values  ≈ Aw
         @test fA.vectors ≈ Avr
+
+        @test_throws ArgumentError LAPACK.geev!('X','V',A)
+        @test_throws ArgumentError LAPACK.geev!('N','X',A)
     end
 end
 
@@ -284,6 +307,7 @@ end
         @test_throws DimensionMismatch LAPACK.gttrs!('N', x11, d, du, x9, y10, b)
         @test_throws DimensionMismatch LAPACK.gttrs!('N', dl, d, x11, x9, y10, b)
         @test_throws DimensionMismatch LAPACK.gttrs!('N', dl, d, du, x9, y10, x11)
+        @test_throws ArgumentError LAPACK.gttrs!('X', dl, d, du, x9, y10, x11)
         A = lu(Tridiagonal(dl,d,du))
         b  = rand(elty,10,5)
         c = copy(b)
@@ -298,10 +322,17 @@ end
         A = rand(elty,10,10)
         A,tau = LAPACK.gelqf!(A)
         @test_throws DimensionMismatch LAPACK.orglq!(A,tau,11)
-        @test_throws DimensionMismatch LAPACK.ormlq!('R','N',A,tau,rand(elty,11,11))
-        @test_throws DimensionMismatch LAPACK.ormlq!('L','N',A,tau,rand(elty,11,11))
-        @test_throws DimensionMismatch LAPACK.ormlq!('R','N',A,zeros(elty,11),rand(elty,10,10))
-        @test_throws DimensionMismatch LAPACK.ormlq!('L','N',A,zeros(elty,11),rand(elty,10,10))
+        temp = rand(elty,11,11)
+        @test_throws DimensionMismatch LAPACK.ormlq!('R','N',A,tau,temp)
+        @test_throws DimensionMismatch LAPACK.ormlq!('L','N',A,tau,temp)
+        @test_throws ArgumentError LAPACK.ormlq!('X','N',A,tau,temp)
+        @test_throws ArgumentError LAPACK.ormlq!('R','X',A,tau,temp)
+        temp = zeros(elty,11)
+        B = copy(A)
+        @test_throws DimensionMismatch LAPACK.ormlq!('R','N',A,temp,B)
+        @test_throws DimensionMismatch LAPACK.ormlq!('L','N',A,temp,B)
+        @test_throws ArgumentError LAPACK.ormlq!('X','N',A,temp,B)
+        @test_throws ArgumentError LAPACK.ormlq!('L','X',A,temp,B)
 
         B = copy(A)
         C = LAPACK.orglq!(B,tau)
@@ -312,30 +343,51 @@ end
         @test_throws DimensionMismatch LAPACK.orgqr!(A,tau,11)
         B = copy(A)
         @test LAPACK.orgqr!(B,tau) ≈ LAPACK.ormqr!('R','N',A,tau,Matrix{elty}(I, 10, 10))
-        @test_throws DimensionMismatch LAPACK.ormqr!('R','N',A,tau,rand(elty,11,11))
-        @test_throws DimensionMismatch LAPACK.ormqr!('L','N',A,tau,rand(elty,11,11))
-        @test_throws DimensionMismatch LAPACK.ormqr!('R','N',A,zeros(elty,11),rand(elty,10,10))
-        @test_throws DimensionMismatch LAPACK.ormqr!('L','N',A,zeros(elty,11),rand(elty,10,10))
+        temp = rand(elty,11,11)
+        @test_throws DimensionMismatch LAPACK.ormqr!('R','N',A,tau,temp)
+        @test_throws DimensionMismatch LAPACK.ormqr!('L','N',A,tau,temp)
+        @test_throws ArgumentError LAPACK.ormqr!('X','N',A,tau,temp)
+        @test_throws ArgumentError LAPACK.ormqr!('L','X',A,tau,temp)
+        B = copy(A)
+        temp = zeros(elty,11)
+        @test_throws DimensionMismatch LAPACK.ormqr!('R','N',A,temp,B)
+        @test_throws DimensionMismatch LAPACK.ormqr!('L','N',A,temp,B)
+        @test_throws ArgumentError LAPACK.ormqr!('X','N',A,temp,B)
+        @test_throws ArgumentError LAPACK.ormqr!('L','X',A,temp,B)
 
         A = rand(elty,10,10)
         A,tau = LAPACK.geqlf!(A)
         @test_throws DimensionMismatch LAPACK.orgql!(A,tau,11)
         B = copy(A)
         @test LAPACK.orgql!(B,tau) ≈ LAPACK.ormql!('R','N',A,tau,Matrix{elty}(I, 10, 10))
-        @test_throws DimensionMismatch LAPACK.ormql!('R','N',A,tau,rand(elty,11,11))
-        @test_throws DimensionMismatch LAPACK.ormql!('L','N',A,tau,rand(elty,11,11))
-        @test_throws DimensionMismatch LAPACK.ormql!('R','N',A,zeros(elty,11),rand(elty,10,10))
-        @test_throws DimensionMismatch LAPACK.ormql!('L','N',A,zeros(elty,11),rand(elty,10,10))
+        temp = rand(elty,11,11)
+        @test_throws DimensionMismatch LAPACK.ormql!('R','N',A,tau,temp)
+        @test_throws DimensionMismatch LAPACK.ormql!('L','N',A,tau,temp)
+        @test_throws ArgumentError LAPACK.ormql!('X','N',A,tau,temp)
+        @test_throws ArgumentError LAPACK.ormql!('L','X',A,tau,temp)
+        temp = zeros(elty,11)
+        B = copy(A)
+        @test_throws DimensionMismatch LAPACK.ormql!('R','N',A,temp,B)
+        @test_throws DimensionMismatch LAPACK.ormql!('L','N',A,temp,B)
+        @test_throws ArgumentError LAPACK.ormql!('X','N',A,temp,B)
+        @test_throws ArgumentError LAPACK.ormql!('L','X',A,temp,B)
 
         A = rand(elty,10,10)
         A,tau = LAPACK.gerqf!(A)
         @test_throws DimensionMismatch LAPACK.orgrq!(A,tau,11)
         B = copy(A)
         @test LAPACK.orgrq!(B,tau) ≈ LAPACK.ormrq!('R','N',A,tau,Matrix{elty}(I, 10, 10))
-        @test_throws DimensionMismatch LAPACK.ormrq!('R','N',A,tau,rand(elty,11,11))
-        @test_throws DimensionMismatch LAPACK.ormrq!('L','N',A,tau,rand(elty,11,11))
-        @test_throws DimensionMismatch LAPACK.ormrq!('R','N',A,zeros(elty,11),rand(elty,10,10))
-        @test_throws DimensionMismatch LAPACK.ormrq!('L','N',A,zeros(elty,11),rand(elty,10,10))
+        temp = rand(elty,11,11)
+        @test_throws DimensionMismatch LAPACK.ormrq!('R','N',A,tau,temp)
+        @test_throws DimensionMismatch LAPACK.ormrq!('L','N',A,tau,temp)
+        @test_throws ArgumentError LAPACK.ormrq!('X','N',A,tau,temp)
+        @test_throws ArgumentError LAPACK.ormrq!('L','X',A,tau,temp)
+        B = copy(A)
+        temp = zeros(elty,11)
+        @test_throws DimensionMismatch LAPACK.ormrq!('R','N',A,temp,B)
+        @test_throws DimensionMismatch LAPACK.ormrq!('L','N',A,temp,B)
+        @test_throws ArgumentError LAPACK.ormrq!('X','N',A,temp,B)
+        @test_throws ArgumentError LAPACK.ormrq!('L','X',A,temp,B)
 
         A = rand(elty,10,11)
         Q = copy(A)
@@ -351,21 +403,29 @@ end
         T = zeros(elty,10,11)
         @test_throws DimensionMismatch LAPACK.gemqrt!('L','N',V,T,C)
         @test_throws DimensionMismatch LAPACK.gemqrt!('R','N',V,T,C)
+        @test_throws ArgumentError LAPACK.gemqrt!('X','N',V,T,C)
+        @test_throws ArgumentError LAPACK.gemqrt!('R','X',V,T,C)
 
         C = rand(elty,10,10)
         V = rand(elty,11,10)
         T = zeros(elty,10,10)
         @test_throws DimensionMismatch LAPACK.gemqrt!('R','N',V,T,C)
         @test_throws DimensionMismatch LAPACK.gemqrt!('L','N',V,T,C)
+        @test_throws ArgumentError LAPACK.gemqrt!('X','N',V,T,C)
+        @test_throws ArgumentError LAPACK.gemqrt!('L','X',V,T,C)
 
         # test size(T) = (nb,k) ensures 1 <= nb <= k
         T = zeros(elty,10,10)
         V = rand(elty,5,10)
         @test_throws DimensionMismatch LAPACK.gemqrt!('L','N',V,T,C)
+        @test_throws ArgumentError LAPACK.gemqrt!('X','N',V,T,C)
+        @test_throws ArgumentError LAPACK.gemqrt!('L','X',V,T,C)
         C = rand(elty,10,10)
         V = rand(elty,10,10)
         T = zeros(elty,11,10)
         @test_throws DimensionMismatch LAPACK.gemqrt!('R','N',V,T,C)
+        @test_throws ArgumentError LAPACK.gemqrt!('X','N',V,T,C)
+        @test_throws ArgumentError LAPACK.gemqrt!('R','X',V,T,C)
 
         @test_throws DimensionMismatch LAPACK.orghr!(1, 10, C, zeros(elty,11))
     end
@@ -377,8 +437,12 @@ end
         A = A + transpose(A) #symmetric!
         B = copy(A)
         B,ipiv = LAPACK.sytrf!('U',B)
+        @test_throws ArgumentError LAPACK.sytrf!('X',B)
         @test triu(inv(A)) ≈ triu(LAPACK.sytri!('U',B,ipiv)) rtol=eps(cond(A))
-        @test_throws DimensionMismatch LAPACK.sytrs!('U',B,ipiv,rand(elty,11,5))
+        @test_throws ArgumentError LAPACK.sytri!('X',B,ipiv)
+        temp = rand(elty,11,5)
+        @test_throws DimensionMismatch LAPACK.sytrs!('U',B,ipiv,temp)
+        @test_throws ArgumentError LAPACK.sytrs!('X',B,ipiv,temp)
         @test LAPACK.sytrf!('U',zeros(elty,0,0)) == (zeros(elty,0,0),zeros(BlasInt,0),zero(BlasInt))
     end
 
@@ -389,7 +453,10 @@ end
         B = copy(A)
         B,ipiv = LAPACK.sytrf_rook!('U', B)
         @test triu(inv(A)) ≈ triu(LAPACK.sytri_rook!('U', B, ipiv)) rtol=eps(cond(A))
-        @test_throws DimensionMismatch LAPACK.sytrs_rook!('U', B, ipiv, rand(elty, 11, 5))
+        @test_throws ArgumentError LAPACK.sytri_rook!('X', B, ipiv)
+        temp = rand(elty, 11, 5)
+        @test_throws DimensionMismatch LAPACK.sytrs_rook!('U', B, ipiv, temp)
+        @test_throws ArgumentError LAPACK.sytrs_rook!('X', B, ipiv, temp)
         @test LAPACK.sytrf_rook!('U',zeros(elty, 0, 0)) == (zeros(elty, 0, 0),zeros(BlasInt, 0),zero(BlasInt))
         A = rand(elty, 10, 10)
         A = A + transpose(A) #symmetric!
@@ -398,7 +465,9 @@ end
         cnd = cond(A)
         b,A = LAPACK.sysv_rook!('U', A, b)
         @test b ≈ c rtol=eps(cnd)
-        @test_throws DimensionMismatch LAPACK.sysv_rook!('U',A,rand(elty,11))
+        temp = rand(elty,11)
+        @test_throws DimensionMismatch LAPACK.sysv_rook!('U',A,temp)
+        @test_throws ArgumentError LAPACK.sysv_rook!('X',A,temp)
 
         # syconvf_rook error handling
         # way argument is wrong
@@ -416,8 +485,11 @@ end
         A = A + A' #hermitian!
         B = copy(A)
         B,ipiv = LAPACK.hetrf!('U',B)
-        @test_throws DimensionMismatch LAPACK.hetrs!('U',B,ipiv,rand(elty,11,5))
-        @test_throws DimensionMismatch LAPACK.hetrs_rook!('U',B,ipiv,rand(elty,11,5))
+        temp = rand(elty,11,5)
+        @test_throws DimensionMismatch LAPACK.hetrs!('U',B,ipiv,temp)
+        @test_throws ArgumentError LAPACK.hetrs!('X',B,ipiv,temp)
+        @test_throws DimensionMismatch LAPACK.hetrs_rook!('U',B,ipiv,temp)
+        @test_throws ArgumentError LAPACK.hetrs_rook!('X',B,ipiv,temp)
     end
 end
 
@@ -425,11 +497,21 @@ end
     @testset for elty in (Float32, Float64)
         d = rand(elty,10)
         e = rand(elty,9)
-        @test_throws DimensionMismatch LAPACK.stev!('U',d,rand(elty,11))
-        @test_throws DimensionMismatch LAPACK.stebz!('A','B',zero(elty),zero(elty),0,0,-1.,d,rand(elty,10))
-        @test_throws DimensionMismatch LAPACK.stegr!('N','A',d,rand(elty,11),zero(elty),zero(elty),0,0)
-        @test_throws DimensionMismatch LAPACK.stein!(d,zeros(elty,11),zeros(elty,10),zeros(BlasInt,10),zeros(BlasInt,10))
-        @test_throws DimensionMismatch LAPACK.stein!(d,e,zeros(elty,11),zeros(BlasInt,10),zeros(BlasInt,10))
+        temp = rand(elty,11)
+        @test_throws DimensionMismatch LAPACK.stev!('N',d,temp)
+        @test_throws ArgumentError LAPACK.stev!('X',d,temp)
+        temp = rand(elty,10)
+        @test_throws DimensionMismatch LAPACK.stebz!('A','B',zero(elty),zero(elty),0,0,-1.,d,temp)
+        @test_throws ArgumentError LAPACK.stebz!('X','B',zero(elty),zero(elty),0,0,-1.,d,temp)
+        @test_throws ArgumentError LAPACK.stebz!('A','X',zero(elty),zero(elty),0,0,-1.,d,temp)
+        temp11 = rand(elty,11)
+        @test_throws DimensionMismatch LAPACK.stegr!('N','A',d,temp11,zero(elty),zero(elty),0,0)
+        @test_throws ArgumentError LAPACK.stegr!('X','A',d,temp11,zero(elty),zero(elty),0,0)
+        @test_throws ArgumentError LAPACK.stegr!('N','X',d,temp11,zero(elty),zero(elty),0,0)
+        tempblasint10 = zeros(BlasInt,10)
+        tempblasint10_2 = zeros(BlasInt,10)
+        @test_throws DimensionMismatch LAPACK.stein!(d,temp11,temp,tempblasint10,tempblasint10_2)
+        @test_throws DimensionMismatch LAPACK.stein!(d,e,temp11,tempblasint10,tempblasint10_2)
     end
 end
 
@@ -439,7 +521,13 @@ end
         A = triu(A)
         B = copy(A)
         @test inv(A) ≈ LAPACK.trtri!('U','N',B)
-        @test_throws DimensionMismatch LAPACK.trtrs!('U','N','N',B,zeros(elty,11,10))
+        @test_throws ArgumentError LAPACK.trtri!('X','N',B)
+        @test_throws ArgumentError LAPACK.trtri!('U','X',B)
+        temp = zeros(elty,11,10)
+        @test_throws DimensionMismatch LAPACK.trtrs!('U','N','N',B,temp)
+        @test_throws ArgumentError LAPACK.trtrs!('X','N','N',B,temp)
+        @test_throws ArgumentError LAPACK.trtrs!('U','X','N',B,temp)
+        @test_throws ArgumentError LAPACK.trtrs!('U','N','X',B,temp)
     end
 end
 
@@ -479,6 +567,8 @@ end
         LinearAlgebra.LAPACK.larf!('L', v,      τ, C1)
         LinearAlgebra.LAPACK.larf!('R', v, conj(τ), C2)
         @test C ≈ C2*C1
+
+        @test_throws ArgumentError LAPACK.larf!('X', v,      τ, C1)
     end
 end
 
@@ -489,6 +579,8 @@ end
         @test_throws DimensionMismatch LAPACK.tgsen!(zeros(BlasInt,10),Z,Z,zeros(elty,11,11),Z)
         @test_throws DimensionMismatch LAPACK.tgsen!(zeros(BlasInt,10),Z,Z,Z,zeros(elty,11,11))
         @test_throws DimensionMismatch LAPACK.trsyl!('N','N',Z,Z,zeros(elty,11,11))
+        @test_throws ArgumentError LAPACK.trsyl!('X','N',Z,Z,zeros(elty,11,11))
+        @test_throws ArgumentError LAPACK.trsyl!('N','X',Z,Z,zeros(elty,11,11))
         @test_throws DimensionMismatch LAPACK.tzrzf!(zeros(elty,10,5))
 
         A = triu(rand(elty,4,4))
@@ -508,6 +600,7 @@ end
         b,A = LAPACK.sysv!('U',A,b)
         @test b ≈ c
         @test_throws DimensionMismatch LAPACK.sysv!('U',A,rand(elty,11))
+        @test_throws ArgumentError LAPACK.sysv!('X',A,rand(elty,11))
     end
 end
 
@@ -520,14 +613,17 @@ end
         c = A \ b
         b,A = LAPACK.hesv!('U',A,b)
         @test b ≈ c
-        @test_throws DimensionMismatch LAPACK.hesv!('U',A,rand(elty,11))
+        temp = rand(elty,11)
+        @test_throws DimensionMismatch LAPACK.hesv!('U',A,temp)
+        @test_throws ArgumentError LAPACK.hesv!('X',A,temp)
         A = rand(elty,10,10)
         A = A + A' #hermitian!
         b = rand(elty,10)
         c = A \ b
         b,A = LAPACK.hesv_rook!('U',A,b)
         @test b ≈ c
-        @test_throws DimensionMismatch LAPACK.hesv_rook!('U',A,rand(elty,11))
+        @test_throws DimensionMismatch LAPACK.hesv_rook!('U',A,temp)
+        @test_throws ArgumentError LAPACK.hesv_rook!('X',A,temp)
     end
 end
 
@@ -563,8 +659,12 @@ end
         C = copy(B)
         if elty <: Complex
             @test A\B ≈ LAPACK.pttrs!('U',rdv,ev,C)
-            @test_throws DimensionMismatch LAPACK.pttrs!('U',rdv,Vector{elty}(undef,10),C)
-            @test_throws DimensionMismatch LAPACK.pttrs!('U',rdv,ev,Matrix{elty}(undef,11,11))
+            tempvec = Vector{elty}(undef,10)
+            tempmat = Matrix{elty}(undef,11,11)
+            @test_throws DimensionMismatch LAPACK.pttrs!('U',rdv,tempvec,C)
+            @test_throws DimensionMismatch LAPACK.pttrs!('U',rdv,ev,tempmat)
+            @test_throws ArgumentError LAPACK.pttrs!('X',rdv,tempvec,C)
+            @test_throws ArgumentError LAPACK.pttrs!('X',rdv,ev,tempmat)
         else
             @test A\B ≈ LAPACK.pttrs!(rdv,ev,C)
             @test_throws DimensionMismatch LAPACK.pttrs!(rdv,Vector{elty}(undef,10),C)
@@ -591,6 +691,8 @@ end
         offsizemat = Matrix{elty}(undef, n+1, n+1)
         @test_throws DimensionMismatch LAPACK.posv!('U', D, offsizemat)
         @test_throws DimensionMismatch LAPACK.potrs!('U', D, offsizemat)
+        @test_throws ArgumentError LAPACK.posv!('X', D, offsizemat)
+        @test_throws ArgumentError LAPACK.potrs!('X', D, offsizemat)
 
         @test LAPACK.potrs!('U',Matrix{elty}(undef,0,0),elty[]) == elty[]
     end
@@ -613,6 +715,10 @@ end
         B = rand(elty,11,11)
         @test_throws DimensionMismatch LAPACK.gges!('V','V',A,B)
         @test_throws DimensionMismatch LAPACK.gges3!('V','V',A,B)
+        @test_throws ArgumentError LAPACK.gges!('X','V',A,B)
+        @test_throws ArgumentError LAPACK.gges3!('X','V',A,B)
+        @test_throws ArgumentError LAPACK.gges!('V','X',A,B)
+        @test_throws ArgumentError LAPACK.gges3!('V','X',A,B)
     end
 end
 
@@ -632,8 +738,14 @@ end
         select,Vln,Vrn = LAPACK.trevc!('B','S',select,copy(T))
         @test Vrn ≈ v
         @test Vln ≈ Vl
-        @test_throws ArgumentError LAPACK.trevc!('V','S',select,copy(T))
-        @test_throws DimensionMismatch LAPACK.trrfs!('U','N','N',T,rand(elty,10,10),rand(elty,10,11))
+        @test_throws ArgumentError LAPACK.trevc!('V','S',select,T)
+        @test_throws ArgumentError LAPACK.trevc!('R','X',select,T)
+        temp1010 = rand(elty,10,10)
+        temp1011 = rand(elty,10,11)
+        @test_throws DimensionMismatch LAPACK.trrfs!('U','N','N',T,temp1010,temp1011)
+        @test_throws ArgumentError LAPACK.trrfs!('X','N','N',T,temp1010,temp1011)
+        @test_throws ArgumentError LAPACK.trrfs!('U','X','N',T,temp1010,temp1011)
+        @test_throws ArgumentError LAPACK.trrfs!('U','N','X',T,temp1010,temp1011)
     end
 end
 

From 2c81e5d1033b38667b4f3b1a9af5d7e616385dd1 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 12 Mar 2024 07:35:27 +0530
Subject: [PATCH 1114/1315] Linalg: remove unnecessary matprod_dest
 specializations (#53620)

These methods are not necessary, as the fallback methods for
`StructuredArrays` on line 577 and 578 do the same.
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 5 +++--
 stdlib/LinearAlgebra/src/diagonal.jl      | 5 -----
 stdlib/LinearAlgebra/test/diagonal.jl     | 6 +++++-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index a8c6792178aec..d8dd730779c26 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -576,11 +576,12 @@ _droplast!(A) = deleteat!(A, lastindex(A))
 matprod_dest(A::StructuredMatrix, B::StructuredMatrix, TS) = similar(B, TS, size(B))
 matprod_dest(A, B::StructuredMatrix, TS) = similar(A, TS, size(A))
 matprod_dest(A::StructuredMatrix, B, TS) = similar(B, TS, size(B))
+# diagonal is special, as it does not change the structure of the other matrix
+# we call similar without a size to preserve the type of the matrix wherever possible
 matprod_dest(A::StructuredMatrix, B::Diagonal, TS) = similar(A, TS)
 matprod_dest(A::Diagonal, B::StructuredMatrix, TS) = similar(B, TS)
 matprod_dest(A::Diagonal, B::Diagonal, TS) = similar(B, TS)
-matprod_dest(A::HermOrSym, B::Diagonal, TS) = similar(A, TS, size(A))
-matprod_dest(A::Diagonal, B::HermOrSym, TS) = similar(B, TS, size(B))
+
 # Special handling for adj/trans vec
 matprod_dest(A::Diagonal, B::AdjOrTransAbsVec, TS) = similar(B, TS)
 
diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index 063dde619bd1a..cd93a771c30ad 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -423,7 +423,6 @@ function (*)(Da::Diagonal, Db::Diagonal, Dc::Diagonal)
 end
 
 /(A::AbstractVecOrMat, D::Diagonal) = _rdiv!(matprod_dest(A, D, promote_op(/, eltype(A), eltype(D))), A, D)
-/(A::HermOrSym, D::Diagonal) = _rdiv!(matprod_dest(A, D, promote_op(/, eltype(A), eltype(D))), A, D)
 
 rdiv!(A::AbstractVecOrMat, D::Diagonal) = @inline _rdiv!(A, A, D)
 # avoid copy when possible via internal 3-arg backend
@@ -450,7 +449,6 @@ function \(D::Diagonal, B::AbstractVector)
     return D.diag .\ B
 end
 \(D::Diagonal, B::AbstractMatrix) = ldiv!(matprod_dest(D, B, promote_op(\, eltype(D), eltype(B))), D, B)
-\(D::Diagonal, B::HermOrSym) = ldiv!(matprod_dest(D, B, promote_op(\, eltype(D), eltype(B))), D, B)
 
 ldiv!(D::Diagonal, B::AbstractVecOrMat) = @inline ldiv!(B, D, B)
 function ldiv!(B::AbstractVecOrMat, D::Diagonal, A::AbstractVecOrMat)
@@ -469,9 +467,6 @@ function ldiv!(B::AbstractVecOrMat, D::Diagonal, A::AbstractVecOrMat)
     B
 end
 
-# Optimizations for \, / between Diagonals
-\(D::Diagonal, B::Diagonal) = ldiv!(matprod_dest(D, B, promote_op(\, eltype(D), eltype(B))), D, B)
-/(A::Diagonal, D::Diagonal) = _rdiv!(matprod_dest(A, D, promote_op(/, eltype(A), eltype(D))), A, D)
 function _rdiv!(Dc::Diagonal, Db::Diagonal, Da::Diagonal)
     n, k = length(Db.diag), length(Da.diag)
     n == k || throw(DimensionMismatch("left hand side has $n columns but D is $k by $k"))
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 3087e87f63415..3f5cd34a543b6 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -826,7 +826,7 @@ end
     @test rdiv!(copy(B), D) ≈ B * Diagonal(inv.(D.diag))
 end
 
-@testset "multiplication with Symmetric/Hermitian" begin
+@testset "multiplication/division with Symmetric/Hermitian" begin
     for T in (Float64, ComplexF64)
         D = Diagonal(randn(T, n))
         A = randn(T, n, n); A = A'A
@@ -839,6 +839,10 @@ end
             @test *(transform1(D), transform2(H)) ≈ *(transform1(Matrix(D)), transform2(Matrix(H)))
             @test *(transform1(S), transform2(D)) ≈ *(transform1(Matrix(S)), transform2(Matrix(D)))
             @test *(transform1(S), transform2(H)) ≈ *(transform1(Matrix(S)), transform2(Matrix(H)))
+            @test (transform1(H)/D) * D ≈ transform1(H)
+            @test (transform1(S)/D) * D ≈ transform1(S)
+            @test D * (D\transform2(H)) ≈ transform2(H)
+            @test D * (D\transform2(S)) ≈ transform2(S)
         end
     end
 end

From 8e7751cf6101a458394732651260c44d589c542e Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 12 Mar 2024 14:18:04 +0530
Subject: [PATCH 1115/1315] propagate_inbounds to inline in indexing
 CartesianIndices{0} (#53701)

There's no indexing call in this method which an `@inbounds` may be
propagated to.
---
 base/multidimensional.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index fe29e5c1d8e5f..04274cd79c1aa 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -365,7 +365,7 @@ module IteratorsMD
     end
 
     # getindex for a 0D CartesianIndices is necessary for disambiguation
-    @propagate_inbounds function Base.getindex(iter::CartesianIndices{0,R}) where {R}
+    @inline function Base.getindex(iter::CartesianIndices{0,R}) where {R}
         CartesianIndex()
     end
     @inline function Base.getindex(iter::CartesianIndices{N,R}, I::Vararg{Int, N}) where {N,R}

From 0b95cafba21f738f34f6a598f455886d2fe6340a Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 12 Mar 2024 06:21:38 -0400
Subject: [PATCH 1116/1315] Fix `--compile=all` mode after CodeInstance
 refactor (#53421)

This codepath does not have tests, so it wasn't quite correct. Hopefully
this fixes it.
---
 base/compiler/typeinfer.jl |  5 ++++-
 src/aotcompile.cpp         | 33 +++++++++++++++++----------------
 src/gf.c                   | 21 +++++++++++----------
 src/julia_internal.h       |  1 +
 test/choosetests.jl        |  2 +-
 test/compileall.jl         | 13 +++++++++++++
 6 files changed, 47 insertions(+), 28 deletions(-)
 create mode 100644 test/compileall.jl

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 7113d3d6697a1..4b6525f886888 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -1139,11 +1139,13 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance, source_mod
             return code
         end
     end
+
     # Inference result is not cacheable or is was cacheable, but we do not want to
     # store the source in the cache, but the caller wanted it anyway (e.g. for reflection).
     # We construct a new CodeInstance for it that is not part of the cache hierarchy.
     code = CodeInstance(interp, result, can_discard_trees=(
-        source_mode != SOURCE_MODE_FORCE_SOURCE && source_mode != SOURCE_MODE_FORCE_SOURCE_UNCACHED))
+        source_mode != SOURCE_MODE_FORCE_SOURCE && source_mode != SOURCE_MODE_FORCE_SOURCE_UNCACHED &&
+        is_result_constabi_eligible(result)))
 
     # If the caller cares about the code and this is constabi, still use our synthesis function
     # anyway, because we will have not finished inferring the code inside the CodeInstance once
@@ -1151,6 +1153,7 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance, source_mod
     if use_const_api(code) && source_mode in (SOURCE_MODE_FORCE_SOURCE, SOURCE_MODE_FORCE_SOURCE_UNCACHED)
         return codeinstance_for_const_with_code(interp, code)
     end
+    @assert ci_meets_requirement(code, source_mode, false)
     return code
 end
 
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index c07f7bf32780a..11c2578f701f0 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -288,7 +288,7 @@ static void makeSafeName(GlobalObject &G)
         G.setName(StringRef(SafeName.data(), SafeName.size()));
 }
 
-static void jl_ci_cache_lookup(const jl_cgparams_t &cgparams, jl_method_instance_t *mi, size_t world, jl_code_instance_t **ci_out, jl_code_info_t **src_out)
+jl_code_instance_t *jl_ci_cache_lookup(const jl_cgparams_t &cgparams, jl_method_instance_t *mi, size_t world)
 {
     ++CICacheLookups;
     jl_value_t *ci = cgparams.lookup(mi, world, world);
@@ -296,22 +296,22 @@ static void jl_ci_cache_lookup(const jl_cgparams_t &cgparams, jl_method_instance
     jl_code_instance_t *codeinst = NULL;
     if (ci != jl_nothing) {
         codeinst = (jl_code_instance_t*)ci;
-        *src_out = (jl_code_info_t*)jl_atomic_load_relaxed(&codeinst->inferred);
-        jl_method_t *def = codeinst->def->def.method;
-        if ((jl_value_t*)*src_out == jl_nothing)
-            *src_out = NULL;
-        if (*src_out && jl_is_method(def))
-            *src_out = jl_uncompress_ir(def, codeinst, (jl_value_t*)*src_out);
-    }
-    if (*src_out == NULL || !jl_is_code_info(*src_out)) {
+    }
+    else {
         if (cgparams.lookup != jl_rettype_inferred_addr) {
             jl_error("Refusing to automatically run type inference with custom cache lookup.");
         }
         else {
-            *ci_out = jl_type_infer(mi, world, 0, SOURCE_MODE_ABI);
+            codeinst = jl_type_infer(mi, world, 0, SOURCE_MODE_ABI);
+            /* Even if this codeinst is ordinarily not cacheable, we need to force
+             * it into the cache here, since it was explicitly requested and is
+             * otherwise not reachable from anywhere in the system image.
+             */
+            if (!jl_mi_cache_has_ci(mi, codeinst))
+                jl_mi_cache_insert(mi, codeinst);
         }
     }
-    *ci_out = codeinst;
+    return codeinst;
 }
 
 // takes the running content that has collected in the shadow module and dump it to disk
@@ -390,16 +390,14 @@ void *jl_create_native_impl(jl_array_t *methods, LLVMOrcThreadSafeModuleRef llvm
             // then we want to compile and emit this
             if (jl_atomic_load_relaxed(&mi->def.method->primary_world) <= this_world && this_world <= jl_atomic_load_relaxed(&mi->def.method->deleted_world)) {
                 // find and prepare the source code to compile
-                jl_code_instance_t *codeinst = NULL;
-                jl_ci_cache_lookup(*cgparams, mi, this_world, &codeinst, &src);
-                if (src && !params.compiled_functions.count(codeinst)) {
+                jl_code_instance_t *codeinst = jl_ci_cache_lookup(*cgparams, mi, this_world);
+                if (codeinst && !params.compiled_functions.count(codeinst)) {
                     // now add it to our compilation results
                     JL_GC_PROMISE_ROOTED(codeinst->rettype);
                     orc::ThreadSafeModule result_m = jl_create_ts_module(name_from_method_instance(codeinst->def),
                             params.tsctx, clone.getModuleUnlocked()->getDataLayout(),
                             Triple(clone.getModuleUnlocked()->getTargetTriple()));
-                    jl_llvm_functions_t decls = jl_emit_code(result_m, mi, src, codeinst->rettype, params, jl_atomic_load_relaxed(&codeinst->min_world),
-                        jl_atomic_load_relaxed(&codeinst->max_world));
+                    jl_llvm_functions_t decls = jl_emit_codeinst(result_m, codeinst, NULL, params);
                     if (result_m)
                         params.compiled_functions[codeinst] = {std::move(result_m), std::move(decls)};
                 }
@@ -1790,6 +1788,9 @@ void jl_dump_native_impl(void *native_code,
         // reflect the address of the jl_RTLD_DEFAULT_handle variable
         // back to the caller, so that we can check for consistency issues
         GlobalValue *jlRTLD_DEFAULT_var = jl_emit_RTLD_DEFAULT_var(&metadataM);
+        if (TheTriple.isOSBinFormatCOFF()) {
+            jlRTLD_DEFAULT_var->setDLLStorageClass(GlobalValue::DLLImportStorageClass);
+        }
         addComdat(new GlobalVariable(metadataM,
                                     jlRTLD_DEFAULT_var->getType(),
                                     true,
diff --git a/src/gf.c b/src/gf.c
index db6b5a22d4cbb..cd67108adbc20 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -470,16 +470,17 @@ JL_DLLEXPORT jl_code_instance_t *jl_get_method_inferred(
     return codeinst;
 }
 
-//JL_DLLEXPORT jl_code_instance_t *jl_get_codeinst_for_src(
-//        jl_method_instance_t *mi JL_PROPAGATES_ROOT, jl_code_info_t *src)
-//{
-//    // TODO: copy backedges from src to mi
-//    size_t max_world = src->max_world;
-//    if (max_world >= jl_atomic_load_acquire(&jl_world_counter))
-//        max_world = ~(size_t)0;
-//    // TODO: this should clone all fields from src that it could to avoid poisoning the IPO cache
-//    return jl_get_method_inferred(mi, src->rettype, src->min_world, max_world, src->debuginfo);
-//}
+JL_DLLEXPORT int jl_mi_cache_has_ci(jl_method_instance_t *mi,
+                                     jl_code_instance_t *ci)
+{
+    jl_code_instance_t *codeinst = jl_atomic_load_relaxed(&mi->cache);
+    while (codeinst) {
+        if (codeinst == ci)
+            return 1;
+        codeinst = jl_atomic_load_relaxed(&codeinst->next);
+    }
+    return 0;
+}
 
 JL_DLLEXPORT jl_code_instance_t *jl_new_codeinst(
         jl_method_instance_t *mi, jl_value_t *owner,
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 6fdb65903636b..874be18444a94 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1028,6 +1028,7 @@ JL_DLLEXPORT void jl_method_instance_add_backedge(jl_method_instance_t *callee,
 JL_DLLEXPORT void jl_method_table_add_backedge(jl_methtable_t *mt, jl_value_t *typ, jl_value_t *caller);
 JL_DLLEXPORT void jl_mi_cache_insert(jl_method_instance_t *mi JL_ROOTING_ARGUMENT,
                                      jl_code_instance_t *ci JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED);
+JL_DLLEXPORT int jl_mi_cache_has_ci(jl_method_instance_t *mi, jl_code_instance_t *ci) JL_NOTSAFEPOINT;
 JL_DLLEXPORT extern jl_value_t *(*const jl_rettype_inferred_addr)(jl_method_instance_t *mi JL_PROPAGATES_ROOT, size_t min_world, size_t max_world) JL_NOTSAFEPOINT;
 
 uint32_t jl_module_next_counter(jl_module_t *m) JL_NOTSAFEPOINT;
diff --git a/test/choosetests.jl b/test/choosetests.jl
index 36da1ab39bc57..5f89233f892c8 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -29,7 +29,7 @@ const TESTNAMES = [
         "channels", "iostream", "secretbuffer", "specificity",
         "reinterpretarray", "syntax", "corelogging", "missing", "asyncmap",
         "smallarrayshrink", "opaque_closure", "filesystem", "download",
-        "scopedvalues",
+        "scopedvalues", "compileall"
 ]
 
 const INTERNET_REQUIRED_LIST = [
diff --git a/test/compileall.jl b/test/compileall.jl
new file mode 100644
index 0000000000000..464dea51e4497
--- /dev/null
+++ b/test/compileall.jl
@@ -0,0 +1,13 @@
+# This test builds a full system image, so it can take a little while.
+# We make it a separate test target here, so that it can run in parallel
+# with the rest of the tests.
+
+mktempdir() do dir
+    @test success(`$(Base.julia_cmd()) --compile=all --strip-ir --output-o $(dir)/sys.o.a -e 'exit()'`) broken=(Sys.iswindows() && Sys.WORD_SIZE == 32)
+    if isfile(joinpath(dir, "sys.o.a"))
+        Base.Linking.link_image(joinpath(dir, "sys.o.a"), joinpath(dir, "sys.so"))
+        # TODO: Broken on Windows due to
+        # https://github.com/llvm/llvm-project/issues/84424
+        @test success(`$(Base.julia_cmd()) -J $(dir)/sys.so -e 'Base.scrub_repl_backtrace(nothing); exit()'`) broken=Sys.iswindows()
+    end
+end

From 22602a2305cfb3ccead2a53000869554a8a2dbeb Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 12 Mar 2024 15:58:37 +0530
Subject: [PATCH 1117/1315] Slightly improve grammar in precompilation info
 text (#53700)

Uses the singular "configuration" if `length(configs) == 1`, instead of
the current "configurations"
---
 base/precompilation.jl | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index 9ecb190a1afb5..ce2be1f83f283 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -556,8 +556,9 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     else
         target = "project"
     end
-    if length(configs) > 1 || !isempty(only(configs)[1]) # if multiple configs or only one is not default
-        target *= " for $(length(configs)) compilation configurations..."
+    nconfig = length(configs)
+    if nconfig > 1 || !isempty(only(configs)[1]) # if multiple configs or only one is not default
+        target *= " for $nconfig compilation configuration$(nconfig > 1 ? "s" : "")..."
     else
         target *= "..."
     end

From 7eb5cb89fb938a1dc67efa3861b25562767a7bbe Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 12 Mar 2024 20:57:25 +0900
Subject: [PATCH 1118/1315] set `slot_syms` for methods of OCs constructed via
 `Core.OpaqueClosure` (#53650)

Previously `oc` constructed via `Core.OpaqueClosure` does not set
`oc.source.slot_syms` set, which caused segfaults either when trying to
`show` `oc.source` or if invocation of `oc(...)` threw an error. This
commit fixes that by making sure `oc.source.slot_syms` is set for `oc`
created with `jl_new_opaque_closure_from_code_info`.
---
 base/compiler/ssair/legacy.jl | 16 +++++++++-------
 base/opaque_closure.jl        | 13 ++++++++++---
 src/julia_internal.h          |  2 +-
 src/method.c                  | 13 +++++++++----
 src/opaque_closure.c          |  2 +-
 test/compiler/irutils.jl      | 18 +++++++++++++-----
 test/compiler/ssair.jl        | 11 +++++++++++
 test/opaque_closure.jl        |  5 +++++
 8 files changed, 59 insertions(+), 21 deletions(-)

diff --git a/base/compiler/ssair/legacy.jl b/base/compiler/ssair/legacy.jl
index 6d1c44375a7dd..f5181691cdf7b 100644
--- a/base/compiler/ssair/legacy.jl
+++ b/base/compiler/ssair/legacy.jl
@@ -1,16 +1,16 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
-    inflate_ir!(ci::CodeInfo, linfo::MethodInstance) -> ir::IRCode
+    inflate_ir!(ci::CodeInfo, mi::MethodInstance) -> ir::IRCode
     inflate_ir!(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{Any}) -> ir::IRCode
 
 Inflates `ci::CodeInfo`-IR to `ir::IRCode`-format.
 This should be used with caution as it is a in-place transformation where the fields of
 the original `ci::CodeInfo` are modified.
 """
-function inflate_ir!(ci::CodeInfo, linfo::MethodInstance)
-    sptypes = sptypes_from_meth_instance(linfo)
-    argtypes, _ = matching_cache_argtypes(fallback_lattice, linfo)
+function inflate_ir!(ci::CodeInfo, mi::MethodInstance)
+    sptypes = sptypes_from_meth_instance(mi)
+    argtypes, _ = matching_cache_argtypes(fallback_lattice, mi)
     return inflate_ir!(ci, sptypes, argtypes)
 end
 function inflate_ir!(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{Any})
@@ -42,14 +42,16 @@ function inflate_ir!(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{A
 end
 
 """
-    inflate_ir(ci::CodeInfo, linfo::MethodInstance) -> ir::IRCode
-    inflate_ir(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{Any}) -> ir::IRCode
     inflate_ir(ci::CodeInfo) -> ir::IRCode
+    inflate_ir(ci::CodeInfo, mi::MethodInstance) -> ir::IRCode
+    inflate_ir(ci::CodeInfo, argtypes::Vector{Any}) -> ir::IRCode
+    inflate_ir(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{Any}) -> ir::IRCode
 
 Non-destructive version of `inflate_ir!`.
 Mainly used for testing or interactive use.
 """
-inflate_ir(ci::CodeInfo, linfo::MethodInstance) = inflate_ir!(copy(ci), linfo)
+inflate_ir(ci::CodeInfo, mi::MethodInstance) = inflate_ir!(copy(ci), mi)
+inflate_ir(ci::CodeInfo, argtypes::Vector{Any}) = inflate_ir(ci, VarState[], argtypes)
 inflate_ir(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{Any}) = inflate_ir!(copy(ci), sptypes, argtypes)
 function inflate_ir(ci::CodeInfo)
     parent = ci.parent
diff --git a/base/opaque_closure.jl b/base/opaque_closure.jl
index 0a265e87afb68..83a364646ad39 100644
--- a/base/opaque_closure.jl
+++ b/base/opaque_closure.jl
@@ -58,17 +58,24 @@ end
 
 function Core.OpaqueClosure(ir::IRCode, @nospecialize env...;
                             isva::Bool = false,
+                            slotnames::Union{Nothing,Vector{Symbol}}=nothing,
                             do_compile::Bool = true)
     # NOTE: we need ir.argtypes[1] == typeof(env)
     ir = Core.Compiler.copy(ir)
     # if the user didn't specify a definition MethodInstance or filename Symbol to use for the debuginfo, set a filename now
     ir.debuginfo.def === nothing && (ir.debuginfo.def = :var"generated IR for OpaqueClosure")
-    nargs = length(ir.argtypes)-1
+    nargtypes = length(ir.argtypes)
+    nargs = nargtypes-1
     sig = compute_oc_signature(ir, nargs, isva)
     rt = compute_ir_rettype(ir)
     src = ccall(:jl_new_code_info_uninit, Ref{CodeInfo}, ())
-    src.slotnames = fill(:none, nargs+1)
-    src.slotflags = fill(zero(UInt8), length(ir.argtypes))
+    if slotnames === nothing
+        src.slotnames = fill(:none, nargtypes)
+    else
+        length(slotnames) == nargtypes || error("mismatched `argtypes` and `slotnames`")
+        src.slotnames = slotnames
+    end
+    src.slotflags = fill(zero(UInt8), nargtypes)
     src.slottypes = copy(ir.argtypes)
     src = Core.Compiler.ir_to_codeinf!(src, ir)
     return generate_opaque_closure(sig, Union{}, rt, src, nargs, isva, env...; do_compile)
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 874be18444a94..96637d8568844 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -839,7 +839,7 @@ JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val, int insert) JL_GLOBA
 jl_opaque_closure_t *jl_new_opaque_closure(jl_tupletype_t *argt, jl_value_t *rt_lb, jl_value_t *rt_ub,
     jl_value_t *source,  jl_value_t **env, size_t nenv, int do_compile);
 jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name,
-    int nargs, jl_value_t *functionloc, jl_value_t *uninferred_source, int isva);
+    int nargs, jl_value_t *functionloc, jl_code_info_t *ci, int isva, int isinferred);
 JL_DLLEXPORT int jl_is_valid_oc_argtype(jl_tupletype_t *argt, jl_method_t *source);
 
 // Each tuple can exist in one of 4 Vararg states:
diff --git a/src/method.c b/src/method.c
index ee0ac11c368cb..c75434b2bf17b 100644
--- a/src/method.c
+++ b/src/method.c
@@ -121,7 +121,8 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                 } else if (!jl_is_long(oc_nargs)) {
                     jl_type_error("opaque_closure_method", (jl_value_t*)jl_long_type, oc_nargs);
                 }
-                jl_method_t *m = jl_make_opaque_closure_method(module, name, jl_unbox_long(oc_nargs), functionloc, ci, isva);
+                jl_method_t *m = jl_make_opaque_closure_method(module, name,
+                    jl_unbox_long(oc_nargs), functionloc, (jl_code_info_t*)ci, isva, /*isinferred*/0);
                 return (jl_value_t*)m;
             }
             if (e->head == jl_cfunction_sym) {
@@ -997,7 +998,7 @@ void push_edge(jl_array_t *list, jl_value_t *invokesig, jl_method_instance_t *ca
 // method definition ----------------------------------------------------------
 
 jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name,
-    int nargs, jl_value_t *functionloc, jl_value_t *uninferred_source, int isva)
+    int nargs, jl_value_t *functionloc, jl_code_info_t *ci, int isva, int isinferred)
 {
     jl_method_t *m = jl_new_method_uninit(module);
     JL_GC_PUSH1(&m);
@@ -1016,8 +1017,12 @@ jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name
     jl_value_t *file = jl_linenode_file(functionloc);
     m->file = jl_is_symbol(file) ? (jl_sym_t*)file : jl_empty_sym;
     m->line = jl_linenode_line(functionloc);
-    if (jl_is_code_info(uninferred_source))
-        jl_method_set_source(m, (jl_code_info_t*)uninferred_source);
+    if (isinferred) {
+        m->slot_syms = jl_compress_argnames(ci->slotnames);
+        jl_gc_wb(m, m->slot_syms);
+    } else {
+        jl_method_set_source(m, ci);
+    }
     JL_GC_POP();
     return m;
 }
diff --git a/src/opaque_closure.c b/src/opaque_closure.c
index 656eb91a2f1f3..c9f94f6b15746 100644
--- a/src/opaque_closure.c
+++ b/src/opaque_closure.c
@@ -139,7 +139,7 @@ JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tuplet
     JL_GC_PUSH3(&root, &sigtype, &inst);
     root = jl_box_long(lineno);
     root = jl_new_struct(jl_linenumbernode_type, root, file);
-    jl_method_t *meth = jl_make_opaque_closure_method(mod, jl_nothing, nargs, root, isinferred ? jl_nothing : (jl_value_t*)ci, isva);
+    jl_method_t *meth = jl_make_opaque_closure_method(mod, jl_nothing, nargs, root, ci, isva, isinferred);
     root = (jl_value_t*)meth;
     size_t world = jl_current_task->world_age;
     // these are only legal in the current world since they are not in any tables
diff --git a/test/compiler/irutils.jl b/test/compiler/irutils.jl
index 6a4087fbea958..c11444d8daabc 100644
--- a/test/compiler/irutils.jl
+++ b/test/compiler/irutils.jl
@@ -62,7 +62,8 @@ let m = Meta.@lower 1 + 1
     orig_src = m.args[1]::CodeInfo
     global function make_codeinfo(code::Vector{Any};
                                   ssavaluetypes::Union{Nothing,Vector{Any}}=nothing,
-                                  slottypes::Union{Nothing,Vector{Any}}=nothing)
+                                  slottypes::Union{Nothing,Vector{Any}}=nothing,
+                                  slotnames::Union{Nothing,Vector{Symbol}}=nothing)
         src = copy(orig_src)
         src.code = code
         nstmts = length(src.code)
@@ -77,14 +78,21 @@ let m = Meta.@lower 1 + 1
             src.slottypes = slottypes
             src.slotflags = fill(zero(UInt8), length(slottypes))
         end
+        if slotnames !== nothing
+            src.slotnames = slotnames
+        end
         return src
     end
     global function make_ircode(code::Vector{Any};
-                                ssavaluetypes::Union{Nothing,Vector{Any}}=nothing,
                                 slottypes::Union{Nothing,Vector{Any}}=nothing,
-                                verify::Bool=true)
-        src = make_codeinfo(code; ssavaluetypes, slottypes)
-        ir = Core.Compiler.inflate_ir(src)
+                                verify::Bool=true,
+                                kwargs...)
+        src = make_codeinfo(code; slottypes, kwargs...)
+        if slottypes !== nothing
+            ir = Core.Compiler.inflate_ir(src, slottypes)
+        else
+            ir = Core.Compiler.inflate_ir(src)
+        end
         verify && Core.Compiler.verify_ir(ir)
         return ir
     end
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 6e0c292c0bd45..70a2ab4a3acd9 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -265,6 +265,17 @@ let code = Any[
     oc = Core.OpaqueClosure(ir)
     @test oc(false, 1, 1) == 2
     @test_throws "potential throw" oc(true, 1, 1)
+
+    let buf = IOBuffer()
+        oc = Core.OpaqueClosure(ir; slotnames=Symbol[:ocfunc, :x, :y, :z])
+        try
+            oc(true, 1, 1)
+        catch
+            Base.show_backtrace(buf, catch_backtrace())
+        end
+        s = String(take!(buf))
+        @test occursin("(x::Bool, y::$Int, z::$Int)", s)
+    end
 end
 
 # Test dynamic update of domtree with edge insertions and deletions in the
diff --git a/test/opaque_closure.jl b/test/opaque_closure.jl
index 8b0d118d98f1b..8378d8ae0d3dd 100644
--- a/test/opaque_closure.jl
+++ b/test/opaque_closure.jl
@@ -353,3 +353,8 @@ end
 foopaque() = Base.Experimental.@opaque(@noinline x::Int->println(x))(1)
 
 code_llvm(devnull,foopaque,()) #shouldn't crash
+
+let ir = first(only(Base.code_ircode(sin, (Int,))))
+    oc = Core.OpaqueClosure(ir)
+    @test (Base.show_method(IOBuffer(), oc.source::Method); true)
+end

From 2a72d65f2817c0ea7405feaa0c7e2b646f7afc0b Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Tue, 12 Mar 2024 09:47:06 -0400
Subject: [PATCH 1119/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20e0821116e=20to=206859d6857=20(#53703)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: e0821116e
New commit: 6859d6857
Julia version: 1.12.0-DEV
Pkg version: 1.12.0
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/e0821116e9f4364a2b37a77183e93d055a111f4d...6859d68579e7970daf00720901cf487563dca0da

```
$ git log --oneline e0821116e..6859d6857
6859d6857 precompile: update kwargs (#3838)
4d73d60aa move threads assignment after precompilation (#3840)
28bbbd46f remove line about changing UUID to dev in readme (#3837)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5     | 1 +
 .../Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512  | 1 +
 .../Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5     | 1 -
 .../Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512  | 1 -
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512

diff --git a/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5 b/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5
new file mode 100644
index 0000000000000..d8e436d51267c
--- /dev/null
+++ b/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5
@@ -0,0 +1 @@
+16cb4d2bcc0bc1c13aa5f1ee02f5f8ee
diff --git a/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512 b/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512
new file mode 100644
index 0000000000000..43b4ed2a68456
--- /dev/null
+++ b/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512
@@ -0,0 +1 @@
+e92cb66a66bcdb9c717c868912b0b53e25f4a04ce380714f619e5be36e07ff21f457c87c2a2af23460f6703fdfd9f931ad65a47c0ff96a39a3075f1ca54275ae
diff --git a/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5 b/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5
deleted file mode 100644
index 406f660ee9deb..0000000000000
--- a/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-8cfa30c7ed9af99573a0f935df20784e
diff --git a/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512 b/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512
deleted file mode 100644
index 64fa7141cb1b4..0000000000000
--- a/deps/checksums/Pkg-e0821116e9f4364a2b37a77183e93d055a111f4d.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-c5f7f90ae0e40902cec3b9541543acfbdc6e3301bcd95b0deb187908eac8e1c9a4de4943e10f5f5988088462be5de424da13086686fbbd77224e2139bf2fcada
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index e44d020b39545..2fcaa62d4d398 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = e0821116e9f4364a2b37a77183e93d055a111f4d
+PKG_SHA1 = 6859d68579e7970daf00720901cf487563dca0da
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From df28bf7c3df5e5f2e456e4cf6a39b62ffb3f2cbd Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 12 Mar 2024 14:30:20 -0400
Subject: [PATCH 1120/1315] use afoldl instead of tail recursion for tuples
 (#53665)

It is easy to accidentally call these functions (they are used by vcat,
which is syntax) with very long lists of values, causing inference to
crash and take a long time. The `afoldl` function can handle that very
well however, while naive recursion did not.

Fixes #53585
---
 base/abstractarray.jl      |  6 ++++--
 base/promotion.jl          | 10 +++++++---
 test/compiler/inference.jl |  6 ++++++
 3 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 9042e5f81e462..cef81d6925284 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1650,13 +1650,15 @@ eltypeof(x::AbstractArray) = eltype(x)
 
 promote_eltypeof() = error()
 promote_eltypeof(v1) = eltypeof(v1)
-promote_eltypeof(v1, vs...) = promote_type(eltypeof(v1), promote_eltypeof(vs...))
+promote_eltypeof(v1, v2) = promote_type(eltypeof(v1), eltypeof(v2))
+promote_eltypeof(v1, v2, vs...) = (@inline; afoldl(((::Type{T}, y) where {T}) -> promote_type(T, eltypeof(y)), promote_eltypeof(v1, v2), vs...))
 promote_eltypeof(v1::T, vs::T...) where {T} = eltypeof(v1)
 promote_eltypeof(v1::AbstractArray{T}, vs::AbstractArray{T}...) where {T} = T
 
 promote_eltype() = error()
 promote_eltype(v1) = eltype(v1)
-promote_eltype(v1, vs...) = promote_type(eltype(v1), promote_eltype(vs...))
+promote_eltype(v1, v2) = promote_type(eltype(v1), eltype(v2))
+promote_eltype(v1, v2, vs...) = (@inline; afoldl(((::Type{T}, y) where {T}) -> promote_type(T, eltype(y)), promote_eltype(v1, v2), vs...))
 promote_eltype(v1::T, vs::T...) where {T} = eltype(T)
 promote_eltype(v1::AbstractArray{T}, vs::AbstractArray{T}...) where {T} = T
 
diff --git a/base/promotion.jl b/base/promotion.jl
index 1d4fea8c404eb..689a4e4be8f39 100644
--- a/base/promotion.jl
+++ b/base/promotion.jl
@@ -19,7 +19,8 @@ Number
 """
 typejoin() = Bottom
 typejoin(@nospecialize(t)) = (@_nospecializeinfer_meta; t)
-typejoin(@nospecialize(t), ts...) = (@_foldable_meta; @_nospecializeinfer_meta; typejoin(t, typejoin(ts...)))
+typejoin(@nospecialize(t), @nospecialize(s), @nospecialize(u)) = (@_foldable_meta; @_nospecializeinfer_meta; typejoin(typejoin(t, s), u))
+typejoin(@nospecialize(t), @nospecialize(s), @nospecialize(u), ts...) = (@_foldable_meta; @_nospecializeinfer_meta; afoldl(typejoin, typejoin(t, s, u), ts...))
 function typejoin(@nospecialize(a), @nospecialize(b))
     @_foldable_meta
     @_nospecializeinfer_meta
@@ -299,7 +300,8 @@ function promote_type end
 
 promote_type()  = Bottom
 promote_type(T) = T
-promote_type(T, S, U, V...) = (@inline; promote_type(T, promote_type(S, U, V...)))
+promote_type(T, S, U) = (@inline; promote_type(promote_type(T, S), U))
+promote_type(T, S, U, V...) = (@inline; afoldl(promote_type, promote_type(T, S, U), V...))
 
 promote_type(::Type{Bottom}, ::Type{Bottom}) = Bottom
 promote_type(::Type{T}, ::Type{T}) where {T} = T
@@ -373,7 +375,9 @@ function _promote(x::T, y::S) where {T,S}
     return (convert(R, x), convert(R, y))
 end
 promote_typeof(x) = typeof(x)
-promote_typeof(x, xs...) = (@inline; promote_type(typeof(x), promote_typeof(xs...)))
+promote_typeof(x, y) = (@inline; promote_type(typeof(x), typeof(y)))
+promote_typeof(x, y, z) = (@inline; promote_type(typeof(x), typeof(y), typeof(z)))
+promote_typeof(x, y, z, a...) = (@inline; afoldl(((::Type{T}, y) where {T}) -> promote_type(T, typeof(y)), promote_typeof(x, y, z), a...))
 function _promote(x, y, z)
     @inline
     R = promote_typeof(x, y, z)
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index d6cd231dfdd58..30c5c306faa94 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5639,3 +5639,9 @@ end
 @test issue53590(true, false) == Real
 @test issue53590(false, false) == Float64
 @test issue53590(false, true) == Real
+
+# issue #53585
+let t = ntuple(i -> i % 8 == 1 ? Int64 : Float64, 4000)
+    @test only(Base.return_types(Base.promote_typeof, t)) == Type{Float64}
+    @test only(Base.return_types(vcat, t)) == Vector{Float64}
+end

From 7613c6954fd2d9168f1c805d9212f961a4765a67 Mon Sep 17 00:00:00 2001
From: Cameron Bieganek <8310743+CameronBieganek@users.noreply.github.com>
Date: Tue, 12 Mar 2024 15:24:51 -0500
Subject: [PATCH 1121/1315] Make some improvements to the Scoped Values
 documentation. (#53628)

Fixes #53471.

One thing to note, I changed the signature in the `with` docstring from
this:

```julia
with(f, (var::ScopedValue{T} => val::T)...)
```

to this:

```julia
with(f, (var::ScopedValue{T} => val)...)
```

...since the original signature in the docstring was too strict. I also
added this sentence to the docstring:

```julia
`val` will be converted to type `T`.
```

I added a couple tests that verify the conversion behavior.
---
 base/scopedvalues.jl         | 101 ++++++++++++++++++++++++++++++++---
 doc/src/base/scopedvalues.md |  93 +++++++++++++++++++-------------
 test/scopedvalues.jl         |  10 ++++
 3 files changed, 159 insertions(+), 45 deletions(-)

diff --git a/base/scopedvalues.jl b/base/scopedvalues.jl
index 339ee717d5fd6..6ccd4687c5c65 100644
--- a/base/scopedvalues.jl
+++ b/base/scopedvalues.jl
@@ -3,6 +3,7 @@
 module ScopedValues
 
 export ScopedValue, with, @with
+public get
 
 """
     ScopedValue(x)
@@ -54,7 +55,22 @@ Base.eltype(::ScopedValue{T}) where {T} = T
 """
     isassigned(val::ScopedValue)
 
-Test whether a ScopedValue has an assigned value.
+Test whether a `ScopedValue` has an assigned value.
+
+See also: [`ScopedValues.with`](@ref), [`ScopedValues.@with`](@ref), [`ScopedValues.get`](@ref).
+
+# Examples
+```jldoctest
+julia> using Base.ScopedValues
+
+julia> a = ScopedValue(1); b = ScopedValue{Int}();
+
+julia> isassigned(a)
+true
+
+julia> isassigned(b)
+false
+```
 """
 function Base.isassigned(val::ScopedValue)
     val.has_default && return true
@@ -114,6 +130,21 @@ const novalue = NoValue()
 If the scoped value isn't set and doesn't have a default value,
 return `nothing`. Otherwise returns `Some{T}` with the current
 value.
+
+See also: [`ScopedValues.with`](@ref), [`ScopedValues.@with`](@ref), [`ScopedValues.ScopedValue`](@ref).
+
+# Examples
+```jldoctest
+julia> using Base.ScopedValues
+
+julia> a = ScopedValue(42); b = ScopedValue{Int}();
+
+julia> ScopedValues.get(a)
+Some(42)
+
+julia> isnothing(ScopedValues.get(b))
+true
+```
 """
 function get(val::ScopedValue{T}) where {T}
     scope = Core.current_scope()::Union{Scope, Nothing}
@@ -151,11 +182,32 @@ function Base.show(io::IO, val::ScopedValue)
 end
 
 """
-    @with vars... expr
+    @with (var::ScopedValue{T} => val)... expr
+
+Macro version of `with`. The expression `@with var=>val expr` evaluates `expr` in a
+new dynamic scope with `var` set to `val`. `val` will be converted to type `T`.
+`@with var=>val expr` is equivalent to `with(var=>val) do expr end`, but `@with`
+avoids creating a closure.
+
+See also: [`ScopedValues.with`](@ref), [`ScopedValues.ScopedValue`](@ref), [`ScopedValues.get`](@ref).
+
+# Examples
+```jldoctest
+julia> using Base.ScopedValues
 
-Macro version of `with(f, vars...)` but with `expr` instead of `f` function.
-This is similar to using [`with`](@ref) with a `do` block, but avoids creating
-a closure.
+julia> const a = ScopedValue(1);
+
+julia> f(x) = a[] + x;
+
+julia> @with a=>2 f(10)
+12
+
+julia> @with a=>3 begin
+           x = 100
+           f(x)
+       end
+103
+```
 """
 macro with(exprs...)
     if length(exprs) > 1
@@ -172,9 +224,44 @@ macro with(exprs...)
 end
 
 """
-    with(f, (var::ScopedValue{T} => val::T)...)
+    with(f, (var::ScopedValue{T} => val)...)
+
+Execute `f` in a new dynamic scope with `var` set to `val`. `val` will be converted
+to type `T`.
+
+See also: [`ScopedValues.@with`](@ref), [`ScopedValues.ScopedValue`](@ref), [`ScopedValues.get`](@ref).
+
+# Examples
+```jldoctest
+julia> using Base.ScopedValues
+
+julia> a = ScopedValue(1);
 
-Execute `f` in a new scope with `var` set to `val`.
+julia> f(x) = a[] + x;
+
+julia> f(10)
+11
+
+julia> with(a=>2) do
+           f(10)
+       end
+12
+
+julia> f(10)
+11
+
+julia> b = ScopedValue(2);
+
+julia> g(x) = a[] + b[] + x;
+
+julia> with(a=>10, b=>20) do
+           g(30)
+       end
+60
+
+julia> with(() -> a[] * b[], a=>3, b=>4)
+12
+```
 """
 function with(f, pair::Pair{<:ScopedValue}, rest::Pair{<:ScopedValue}...)
     @with(pair, rest..., f())
diff --git a/doc/src/base/scopedvalues.md b/doc/src/base/scopedvalues.md
index 8c3340ab9cf11..6ad553429bb1f 100644
--- a/doc/src/base/scopedvalues.md
+++ b/doc/src/base/scopedvalues.md
@@ -17,18 +17,15 @@ concurrently.
     Scoped values were introduced in Julia 1.11. In Julia 1.8+ a compatible
     implementation is available from the package ScopedValues.jl.
 
-In its simplest form you can create a [`Base.ScopedValue`](@ref) with a
-default value and then use [`Base.with`](@ref with) or [`Base.@with`](@ref) to
-enter a new dynamic scope.
+In its simplest form you can create a [`ScopedValue`](@ref Base.ScopedValues.ScopedValue)
+with a default value and then use [`with`](@ref Base.ScopedValues.with) or
+[`@with`](@ref Base.ScopedValues.@with) to enter a new dynamic scope. The new scope will
+inherit all values from the parent scope (and recursively from all outer scopes) with the
+provided scoped value taking priority over previous definitions.
 
-The new scope will inherit all values from the parent scope
-(and recursively from all outer scopes) with the provided scoped
-value taking priority over previous definitions.
-
-Let's first look at an example of **lexical** scope:
-
-A `let` statements begins a new lexical scope within which the outer definition
-of `x` is shadowed by it's inner definition.
+Let's first look at an example of **lexical** scope. A `let` statement begins
+a new lexical scope within which the outer definition of `x` is shadowed by
+it's inner definition.
 
 ```julia
 x = 1
@@ -38,9 +35,9 @@ end
 @show x # 1
 ```
 
-Since Julia uses lexical scope the variable `x` is bound within the function `f`
-to the global scope and entering a `let` scope does not change the value `f`
-observes.
+In the following example, since Julia uses lexical scope, the variable `x` in the body
+of `f` refers to the `x` defined in the global scope, and entering a `let` scope does
+not change the value `f` observes.
 
 ```julia
 x = 1
@@ -64,7 +61,7 @@ end
 f() # 1
 ```
 
-Not that the observed value of the `ScopedValue` is dependent on the execution
+Note that the observed value of the `ScopedValue` is dependent on the execution
 path of the program.
 
 It often makes sense to use a `const` variable to point to a scoped value,
@@ -74,34 +71,54 @@ and you can set the value of multiple `ScopedValue`s with one call to `with`.
 ```julia
 using Base.ScopedValues
 
-const scoped_val = ScopedValue(1)
-const scoped_val2 = ScopedValue(0)
-
-# Enter a new dynamic scope and set value
-@show scoped_val[] # 1
-@show scoped_val2[] # 0
-with(scoped_val => 2) do
-    @show scoped_val[] # 2
-    @show scoped_val2[] # 0
-    with(scoped_val => 3, scoped_val2 => 5) do
-        @show scoped_val[] # 3
-        @show scoped_val2[] # 5
+f() = @show a[]
+g() = @show b[]
+
+const a = ScopedValue(1)
+const b = ScopedValue(2)
+
+f() # a[] = 1
+g() # b[] = 2
+
+# Enter a new dynamic scope and set value.
+with(a => 3) do
+    f() # a[] = 3
+    g() # b[] = 2
+    with(a => 4, b => 5) do
+        f() # a[] = 4
+        g() # b[] = 5
     end
-    @show scoped_val[] # 2
-    @show scoped_val2[] # 0
+    f() # a[] = 3
+    g() # b[] = 2
 end
-@show scoped_val[] # 1
-@show scoped_val2[] # 0
+
+f() # a[] = 1
+g() # b[] = 2
 ```
 
-Since `with` requires a closure or a function and creates another call-frame,
-it can sometimes be beneficial to use the macro form.
+`ScopedValues` provides a macro version of `with`. The expression `@with var=>val expr`
+evaluates `expr` in a new dynamic scope with `var` set to `val`. `@with var=>val expr`
+is equivalent to `with(var=>val) do expr end`. However, `with` requires a zero-argument
+closure or function, which results in an extra call-frame. As an example, consider the
+following function `f`:
 
 ```julia
 using Base.ScopedValues
+const a = ScopedValue(1)
+f(x) = a[] + x
+```
+
+If you wish to run `f` in a dynamic scope with `a` set to `2`, then you can use `with`:
 
-const STATE = ScopedValue{State}()
-with_state(f, state::State) = @with(STATE => state, f())
+```julia
+with(() -> f(10), a=>2)
+```
+
+However, this requires wrapping `f` in a zero-argument function. If you wish to avoid
+the extra call-frame, then you can use the `@with` macro:
+
+```julia
+@with a=>2 f(10)
 ```
 
 !!! note
@@ -265,11 +282,11 @@ Base.@kwdef struct Configuration
     verbose::Bool = false
 end
 
-const CONFIG = ScopedValue(Configuration())
+const CONFIG = ScopedValue(Configuration(color=true))
 
-@with CONFIG => Configuration(CONFIG[], color=true) begin
+@with CONFIG => Configuration(color=CONFIG[].color, verbose=true) begin
     @show CONFIG[].color # true
-    @show CONFIG[].verbose # false
+    @show CONFIG[].verbose # true
 end
 ```
 
diff --git a/test/scopedvalues.jl b/test/scopedvalues.jl
index ca700521b50cd..3af6a3f065c8b 100644
--- a/test/scopedvalues.jl
+++ b/test/scopedvalues.jl
@@ -52,6 +52,16 @@ emptyf() = nothing
 @testset "conversion" begin
     with(emptyf, sval_float=>2)
     @test_throws MethodError with(emptyf, sval_float=>"hello")
+    a = ScopedValue(1)
+    with(a => 2.0) do
+        @test a[] == 2
+        @test a[] isa Int
+    end
+    a = ScopedValue(1.0)
+    with(a => 2) do
+        @test a[] == 2.0
+        @test a[] isa Float64
+    end
 end
 
 import Base.Threads: @spawn

From b1dd26ae7c9630c69bb5c7289706a569b9e9964a Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Wed, 13 Mar 2024 02:09:25 -0300
Subject: [PATCH 1122/1315] remove duplicate definition of is_anonfn_typename
 (#53711)

They seem to be doing the same thing. Centralize the definition in a
single place.
---
 src/datatype.c       | 8 --------
 src/gf.c             | 8 --------
 src/julia_internal.h | 8 ++++++++
 3 files changed, 8 insertions(+), 16 deletions(-)

diff --git a/src/datatype.c b/src/datatype.c
index 80668063bb8ba..ee33e75869ee8 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -794,14 +794,6 @@ void jl_compute_field_offsets(jl_datatype_t *st)
     return;
 }
 
-static int is_anonfn_typename(char *name)
-{
-    if (name[0] != '#' || name[1] == '#')
-        return 0;
-    char *other = strrchr(name, '#');
-    return other > &name[1] && is10digit(other[1]);
-}
-
 JL_DLLEXPORT jl_datatype_t *jl_new_datatype(
         jl_sym_t *name,
         jl_module_t *module,
diff --git a/src/gf.c b/src/gf.c
index cd67108adbc20..1cc74672e4d0c 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1558,14 +1558,6 @@ void print_func_loc(JL_STREAM *s, jl_method_t *m)
     }
 }
 
-static int is_anonfn_typename(char *name)
-{
-    if (name[0] != '#' || name[1] == '#')
-        return 0;
-    char *other = strrchr(name, '#');
-    return other > &name[1] && other[1] > '0' && other[1] <= '9';
-}
-
 static void method_overwrite(jl_typemap_entry_t *newentry, jl_method_t *oldvalue)
 {
     // method overwritten
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 96637d8568844..66e824687bba0 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -842,6 +842,14 @@ jl_method_t *jl_make_opaque_closure_method(jl_module_t *module, jl_value_t *name
     int nargs, jl_value_t *functionloc, jl_code_info_t *ci, int isva, int isinferred);
 JL_DLLEXPORT int jl_is_valid_oc_argtype(jl_tupletype_t *argt, jl_method_t *source);
 
+STATIC_INLINE int is_anonfn_typename(char *name)
+{
+    if (name[0] != '#' || name[1] == '#')
+        return 0;
+    char *other = strrchr(name, '#');
+    return other > &name[1] && other[1] > '0' && other[1] <= '9';
+}
+
 // Each tuple can exist in one of 4 Vararg states:
 //   NONE: no vararg                            Tuple{Int,Float32}
 //   INT: vararg with integer length            Tuple{Int,Vararg{Float32,2}}

From 9ae7eab873199a529e3052fba8c69c5a7573302f Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 13 Mar 2024 03:31:51 -0400
Subject: [PATCH 1123/1315] Implement proper macro scope resolution for
 generator/for (#53674)

I'm not super familiar with this code, but it appears to me that these
need to be treated as equivalent to implicit let blocks for the purposes
of macro hygiene, so add appropriate logic to the macroexpander. Fixes
#53673.
---
 src/macroexpand.scm | 57 ++++++++++++++++++++++++++++++++++++++-------
 test/syntax.jl      | 45 +++++++++++++++++++++++++++++++++++
 2 files changed, 94 insertions(+), 8 deletions(-)

diff --git a/src/macroexpand.scm b/src/macroexpand.scm
index 424e921a35713..ee52b97669125 100644
--- a/src/macroexpand.scm
+++ b/src/macroexpand.scm
@@ -126,6 +126,16 @@
                                  (else '())))
                                (else '()))))))
 
+   ;; for/generator
+   (pattern-lambda (for assgn body)
+                   (if (eq? (car assgn) 'block)
+                    `(varlist ,@(map cadr (cdr assgn)))
+                     (cons 'varlist (cadr assgn))))
+   (pattern-lambda (generator body (filter filt . assgn))
+                    (cons 'varlist (map (lambda (x) (cadr x)) assgn)))
+   (pattern-lambda (generator body . assgn)
+                    (cons 'varlist (map (lambda (x) (cadr x)) assgn)))
+
    ;; macro definition
    (pattern-lambda (macro (call name . argl) body)
                    `(-> (tuple ,@argl) ,body))
@@ -357,6 +367,25 @@
         (else
          (resolve-expansion-vars-with-new-env x env m parent-scope inarg)))))
 
+(define (resolve-letlike-assign bind env newenv m parent-scope inarg)
+  (if (assignment? bind)
+    (make-assignment
+      ;; expand binds in newenv with dummy RHS
+      (cadr (resolve-expansion-vars- (make-assignment (cadr bind) 0)
+                                    newenv m parent-scope inarg))
+      ;; expand initial values in old env
+      (resolve-expansion-vars- (caddr bind) env m parent-scope inarg))
+    ;; Just expand everything else that's not an assignment. N.B.: This includes
+    ;; assignments inside escapes, which probably need special handling (TODO).
+    (resolve-expansion-vars- bind newenv m parent-scope inarg)))
+
+(define (for-ranges-list ranges)
+  (if (eq? (car ranges) 'escape)
+    (map (lambda (range) `(escape ,range)) (for-ranges-list (cadr ranges)))
+    (if (eq? (car ranges) 'block)
+      (cdr ranges)
+      (list ranges))))
+
 (define (resolve-expansion-vars- e env m parent-scope inarg)
   (cond ((or (eq? e 'begin) (eq? e 'end) (eq? e 'ccall) (eq? e 'cglobal) (underscore-symbol? e))
          e)
@@ -446,16 +475,28 @@
               `(let (block
                      ,@(map
                         (lambda (bind)
-                          (if (assignment? bind)
-                              (make-assignment
-                               ;; expand binds in old env with dummy RHS
-                               (cadr (resolve-expansion-vars- (make-assignment (cadr bind) 0)
-                                                              newenv m parent-scope inarg))
-                               ;; expand initial values in old env
-                               (resolve-expansion-vars- (caddr bind) env m parent-scope inarg))
-                              (resolve-expansion-vars- bind newenv m parent-scope inarg)))
+                          (resolve-letlike-assign bind env newenv m parent-scope inarg))
                         binds))
                  ,body)))
+           ((for)
+            (let* ((newenv (new-expansion-env-for e env))
+                   (body   (resolve-expansion-vars- (caddr e) newenv m parent-scope inarg))
+                   (expanded-ranges (map (lambda (range)
+                      (resolve-letlike-assign range env newenv m parent-scope inarg)) (for-ranges-list (cadr e)))))
+              (if (length= expanded-ranges 1)
+                `(for ,@expanded-ranges ,body))
+                `(for (block ,@expanded-ranges) ,body)))
+           ((generator)
+            (let* ((newenv (new-expansion-env-for e env))
+                   (body   (resolve-expansion-vars- (cadr e) newenv m parent-scope inarg))
+                   (filt? (eq? (car (caddr e)) 'filter))
+                   (range-exprs (if filt? (cddr (caddr e)) (cddr e)))
+                   (filt (if filt? (resolve-expansion-vars- (cadr (caddr e)) newenv m parent-scope inarg)))
+                   (expanded-ranges (map (lambda (range)
+                      (resolve-letlike-assign range env newenv m parent-scope inarg)) range-exprs)))
+              (if filt?
+                `(generator ,body (filter ,filt ,@expanded-ranges))
+                `(generator ,body ,@expanded-ranges))))
            ((hygienic-scope) ; TODO: move this lowering to resolve-scopes, instead of reimplementing it here badly
              (let ((parent-scope (cons (list env m) parent-scope))
                    (body (cadr e))
diff --git a/test/syntax.jl b/test/syntax.jl
index d5338d76adf59..fbbf7127f0c53 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -3624,3 +3624,48 @@ end
 end
 @test (@MyMacroModule.mymacro) == 1
 @test (@MyMacroModule.mymacro(a)) == 2
+
+# Issue #53673 - missing macro hygiene for for/generator
+baremodule MacroHygieneFor
+    import ..Base
+    using Base: esc, Expr, +
+    macro for1()
+        :(let a=(for i=10; end; 1); a; end)
+    end
+    macro for2()
+        :(let b=(for j=11, k=12; end; 2); b; end)
+    end
+    macro for3()
+        :(let c=($(Expr(:for, esc(Expr(:block, :(j=11), :(k=12))), :())); 3); c; end)
+    end
+    macro for4()
+        :(begin; local j; let a=(for outer j=10; end; 4); j+a; end; end)
+    end
+end
+let nnames = length(names(MacroHygieneFor; all=true))
+    @test (@MacroHygieneFor.for1) == 1
+    @test (@MacroHygieneFor.for2) == 2
+    @test (@MacroHygieneFor.for3) == 3
+    @test (@MacroHygieneFor.for4) == 14
+    @test length(names(MacroHygieneFor; all=true)) == nnames
+end
+
+baremodule MacroHygieneGenerator
+    using ..Base: Any, !
+    my!(x) = !x
+    macro gen1()
+        :(let a=Any[x for x in 1]; a; end)
+    end
+    macro gen2()
+        :(let a=Bool[x for x in (true, false) if my!(x)]; a; end)
+    end
+    macro gen3()
+        :(let a=Bool[x for x in (true, false), y in (true, false) if my!(x) && my!(y)]; a; end)
+    end
+end
+let nnames = length(names(MacroHygieneGenerator; all=true))
+    @test (MacroHygieneGenerator.@gen1) == Any[x for x in 1]
+    @test (MacroHygieneGenerator.@gen2) == Bool[false]
+    @test (MacroHygieneGenerator.@gen3) == Bool[false]
+    @test length(names(MacroHygieneGenerator; all=true)) == nnames
+end

From 8d31f334269c6553553cad4220215a03c6da7ab3 Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Wed, 13 Mar 2024 10:04:08 +0100
Subject: [PATCH 1124/1315] Move `isexecutable, isreadable, iswritable` to
 `filesystem.jl` (#53699)

This PR migrates the methods `isexecutable, isreadable, iswritable` from
`Sys` to `Base`, but also generates an alias in `Sys` for backwards
compatibility.

Furthermore, `iswriteable` is renamed to `iswritable` in order to match
the already existing `Base.iswritable` method.

Suggested in
https://github.com/JuliaLang/julia/pull/53320#issuecomment-1989217973.
---
 base/exports.jl            |  1 +
 base/filesystem.jl         | 83 ++++++++++++++++++++++++++++++++++++-
 base/io.jl                 |  2 +
 base/sysinfo.jl            | 84 ++------------------------------------
 doc/src/base/base.md       |  2 +-
 doc/src/base/io-network.md |  1 +
 test/file.jl               | 12 +++---
 7 files changed, 97 insertions(+), 88 deletions(-)

diff --git a/base/exports.jl b/base/exports.jl
index 368f336188486..3044f9d162d41 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -933,6 +933,7 @@ export
     isblockdev,
     ischardev,
     isdir,
+    isexecutable,
     isfifo,
     isfile,
     islink,
diff --git a/base/filesystem.jl b/base/filesystem.jl
index ee6fde982caab..36e4bb4596285 100644
--- a/base/filesystem.jl
+++ b/base/filesystem.jl
@@ -140,7 +140,8 @@ import .Base:
     IOError, _UVError, _sizeof_uv_fs, check_open, close, eof, eventloop, fd, isopen,
     bytesavailable, position, read, read!, readavailable, seek, seekend, show,
     skip, stat, unsafe_read, unsafe_write, write, transcode, uv_error,
-    setup_stdio, rawhandle, OS_HANDLE, INVALID_OS_HANDLE, windowserror, filesize
+    setup_stdio, rawhandle, OS_HANDLE, INVALID_OS_HANDLE, windowserror, filesize,
+    isexecutable, isreadable, iswritable
 
 import .Base.RefValue
 
@@ -365,5 +366,85 @@ function touch(f::File)
     f
 end
 
+"""
+    isexecutable(path::String)
+
+Return `true` if the given `path` has executable permissions.
+
+!!! note
+    This permission may change before the user executes `path`,
+    so it is recommended to execute the file and handle the error if that fails,
+    rather than calling `isexecutable` first.
+
+!!! note
+    Prior to Julia 1.6, this did not correctly interrogate filesystem
+    ACLs on Windows, therefore it would return `true` for any
+    file.  From Julia 1.6 on, it correctly determines whether the
+    file is marked as executable or not.
+
+See also [`ispath`](@ref), [`isreadable`](@ref), [`iswritable`](@ref).
+"""
+function isexecutable(path::String)
+    # We use `access()` and `X_OK` to determine if a given path is
+    # executable by the current user.  `X_OK` comes from `unistd.h`.
+    X_OK = 0x01
+    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, X_OK) == 0
+end
+isexecutable(path::AbstractString) = isexecutable(String(path))
+
+"""
+    isreadable(path::String)
+
+Return `true` if the access permissions for the given `path` permitted reading by the current user.
+
+!!! note
+    This permission may change before the user calls `open`,
+    so it is recommended to just call `open` alone and handle the error if that fails,
+    rather than calling `isreadable` first.
+
+!!! note
+    Currently this function does not correctly interrogate filesystem
+    ACLs on Windows, therefore it can return wrong results.
+
+!!! compat "Julia 1.11"
+    This function requires at least Julia 1.11.
+
+See also [`ispath`](@ref), [`isexecutable`](@ref), [`iswritable`](@ref).
+"""
+function isreadable(path::String)
+    # We use `access()` and `R_OK` to determine if a given path is
+    # readable by the current user.  `R_OK` comes from `unistd.h`.
+    R_OK = 0x04
+    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, R_OK) == 0
+end
+isreadable(path::AbstractString) = isreadable(String(path))
+
+"""
+    iswritable(path::String)
+
+Return `true` if the access permissions for the given `path` permitted writing by the current user.
+
+!!! note
+    This permission may change before the user calls `open`,
+    so it is recommended to just call `open` alone and handle the error if that fails,
+    rather than calling `iswritable` first.
+
+!!! note
+    Currently this function does not correctly interrogate filesystem
+    ACLs on Windows, therefore it can return wrong results.
+
+!!! compat "Julia 1.11"
+    This function requires at least Julia 1.11.
+
+See also [`ispath`](@ref), [`isexecutable`](@ref), [`isreadable`](@ref).
+"""
+function iswritable(path::String)
+    # We use `access()` and `W_OK` to determine if a given path is
+    # writeable by the current user.  `W_OK` comes from `unistd.h`.
+    W_OK = 0x02
+    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, W_OK) == 0
+end
+iswritable(path::AbstractString) = iswritable(String(path))
+
 
 end
diff --git a/base/io.jl b/base/io.jl
index 7d93bc3e6d9c8..fb883234be4df 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -131,6 +131,8 @@ data has already been buffered. The result is a `Vector{UInt8}`.
 """
 function readavailable end
 
+function isexecutable end
+
 """
     isreadable(io) -> Bool
 
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index c5744873312d6..9bdff3673477f 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -34,7 +34,7 @@ export BINDIR,
        isjsvm,
        isexecutable,
        isreadable,
-       iswriteable,
+       iswritable,
        username,
        which
 
@@ -553,85 +553,9 @@ windows_version
 
 const WINDOWS_VISTA_VER = v"6.0"
 
-"""
-    Sys.isexecutable(path::String)
-
-Return `true` if the given `path` has executable permissions.
-
-!!! note
-    This permission may change before the user executes `path`,
-    so it is recommended to execute the file and handle the error if that fails,
-    rather than calling `isexecutable` first.
-
-!!! note
-    Prior to Julia 1.6, this did not correctly interrogate filesystem
-    ACLs on Windows, therefore it would return `true` for any
-    file.  From Julia 1.6 on, it correctly determines whether the
-    file is marked as executable or not.
-
-See also [`ispath`](@ref), [`isreadable`](@ref), [`iswriteable`](@ref).
-"""
-function isexecutable(path::String)
-    # We use `access()` and `X_OK` to determine if a given path is
-    # executable by the current user.  `X_OK` comes from `unistd.h`.
-    X_OK = 0x01
-    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, X_OK) == 0
-end
-isexecutable(path::AbstractString) = isexecutable(String(path))
-
-"""
-    Sys.isreadable(path::String)
-
-Return `true` if the access permissions for the given `path` permitted reading by the current user.
-
-!!! note
-    This permission may change before the user calls `open`,
-    so it is recommended to just call `open` alone and handle the error if that fails,
-    rather than calling `isreadable` first.
-
-!!! note
-    Currently this function does not correctly interrogate filesystem
-    ACLs on Windows, therefore it can return wrong results.
-
-!!! compat "Julia 1.11"
-    This function requires at least Julia 1.11.
-
-See also [`ispath`](@ref), [`isexecutable`](@ref), [`iswriteable`](@ref).
-"""
-function isreadable(path::String)
-    # We use `access()` and `R_OK` to determine if a given path is
-    # readable by the current user.  `R_OK` comes from `unistd.h`.
-    R_OK = 0x04
-    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, R_OK) == 0
-end
-isreadable(path::AbstractString) = isreadable(String(path))
-
-"""
-    Sys.iswriteable(path::String)
-
-Return `true` if the access permissions for the given `path` permitted writing by the current user.
-
-!!! note
-    This permission may change before the user calls `open`,
-    so it is recommended to just call `open` alone and handle the error if that fails,
-    rather than calling `iswriteable` first.
-
-!!! note
-    Currently this function does not correctly interrogate filesystem
-    ACLs on Windows, therefore it can return wrong results.
-
-!!! compat "Julia 1.11"
-    This function requires at least Julia 1.11.
-
-See also [`ispath`](@ref), [`isexecutable`](@ref), [`isreadable`](@ref).
-"""
-function iswriteable(path::String)
-    # We use `access()` and `W_OK` to determine if a given path is
-    # writeable by the current user.  `W_OK` comes from `unistd.h`.
-    W_OK = 0x02
-    return ccall(:jl_fs_access, Cint, (Cstring, Cint), path, W_OK) == 0
-end
-iswriteable(path::AbstractString) = iswriteable(String(path))
+const isexecutable = Base.isexecutable
+const isreadable   = Base.isreadable
+const iswritable   = Base.iswritable
 
 """
     Sys.which(program_name::String)
diff --git a/doc/src/base/base.md b/doc/src/base/base.md
index 556d51d3af0c1..739ee97d1dd43 100644
--- a/doc/src/base/base.md
+++ b/doc/src/base/base.md
@@ -375,7 +375,7 @@ Base.Sys.isjsvm
 Base.Sys.loadavg
 Base.Sys.isexecutable
 Base.Sys.isreadable
-Base.Sys.iswriteable
+Base.Sys.iswritable
 Base.Sys.username
 Base.@static
 ```
diff --git a/doc/src/base/io-network.md b/doc/src/base/io-network.md
index f99f592e0fb5c..123d494c396a0 100644
--- a/doc/src/base/io-network.md
+++ b/doc/src/base/io-network.md
@@ -39,6 +39,7 @@ Base.eof
 Base.isreadonly
 Base.iswritable
 Base.isreadable
+Base.isexecutable
 Base.isopen
 Base.fd
 Base.redirect_stdio
diff --git a/test/file.jl b/test/file.jl
index a5ab29a3bf8bc..8c5c3ebc4b74b 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -1671,7 +1671,7 @@ else
     )
 end
 
-@testset "chmod/isexecutable/isreadable/iswriteable" begin
+@testset "chmod/isexecutable/isreadable/iswritable" begin
     mktempdir() do dir
         subdir = joinpath(dir, "subdir")
         fpath = joinpath(dir, "subdir", "foo")
@@ -1688,19 +1688,19 @@ end
         chmod(fpath, 0o644)
         @test !Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
-        @test Sys.iswriteable(fpath) skip=Sys.iswindows()
+        @test Sys.iswritable(fpath) skip=Sys.iswindows()
         chmod(fpath, 0o755)
         @test Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
-        @test Sys.iswriteable(fpath) skip=Sys.iswindows()
+        @test Sys.iswritable(fpath) skip=Sys.iswindows()
         chmod(fpath, 0o444)
         @test !Sys.isexecutable(fpath)
         @test Sys.isreadable(fpath)
-        @test !Sys.iswriteable(fpath)
+        @test !Sys.iswritable(fpath)
         chmod(fpath, 0o244)
         @test !Sys.isexecutable(fpath)
         @test !Sys.isreadable(fpath) skip=Sys.iswindows()
-        @test Sys.iswriteable(fpath) skip=Sys.iswindows()
+        @test Sys.iswritable(fpath) skip=Sys.iswindows()
 
         # Ensure that, on Windows, where inheritance is default,
         # chmod still behaves as we expect.
@@ -1708,7 +1708,7 @@ end
             chmod(subdir, 0o666)
             @test !Sys.isexecutable(fpath)
             @test Sys.isreadable(fpath)
-            @test_skip Sys.iswriteable(fpath)
+            @test_skip Sys.iswritable(fpath)
         end
 
         # Reset permissions to all at the end, so it can be deleted properly.

From 3d34f11d4ec843bf97e1cca29ca84f5166c6c6c5 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Wed, 13 Mar 2024 23:52:05 +0800
Subject: [PATCH 1125/1315] typeintersect: fix potential free `TypeVar` caused
 by chained inner var. (#53675)

Noticed when working on 02f27c24929ab2561bcb21d3f58c1d313ae5d6e8. The
substitution and re-sorting of inner vars are incomplete on master. This
commit re-organized the code by:
1. Flatten the inner vars into a reversed list and handling them just
like vars in norm bindings.
2. Then perform a global re-sorting on all vars.
3. After that, the inner vars get frozen and dependent bounds are
refreshed.
---
 src/subtype.c | 419 +++++++++++++++++++++++++++-----------------------
 1 file changed, 228 insertions(+), 191 deletions(-)

diff --git a/src/subtype.c b/src/subtype.c
index c8b6f9a346bd1..61946968beba6 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -87,6 +87,14 @@ typedef struct jl_varbinding_t {
     struct jl_varbinding_t *prev;
 } jl_varbinding_t;
 
+typedef struct jl_ivarbinding_t {
+    jl_tvar_t **var;
+    jl_value_t **lb;
+    jl_value_t **ub;
+    jl_varbinding_t *root;
+    struct jl_ivarbinding_t *next;
+} jl_ivarbinding_t;
+
 // subtype algorithm state
 typedef struct jl_stenv_t {
     // N.B.: varbindings are created on the stack and rooted there
@@ -2811,8 +2819,8 @@ static jl_value_t *omit_bad_union(jl_value_t *u, jl_tvar_t *t)
 static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbinding_t *vb, jl_unionall_t *u, jl_stenv_t *e)
 {
     jl_value_t *varval = NULL, *ilb = NULL, *iub = NULL, *nivar = NULL;
-    jl_tvar_t *newvar = vb->var;
-    JL_GC_PUSH5(&res, &newvar, &ilb, &iub, &nivar);
+    jl_tvar_t *newvar = vb->var, *ivar = NULL;
+    JL_GC_PUSH6(&res, &newvar, &ivar, &nivar, &ilb, &iub);
     // try to reduce var to a single value
     if (jl_is_long(vb->ub) && jl_is_typevar(vb->lb)) {
         varval = vb->ub;
@@ -2845,163 +2853,242 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
     if (!varval && (vb->lb != vb->var->lb || vb->ub != vb->var->ub))
         newvar = jl_new_typevar(vb->var->name, vb->lb, vb->ub);
 
-    // remove/replace/rewrap free occurrences of this var in the environment
-
-    // I. Handle indirect innervars (make them behave like direct innervars).
-    //   1) record if btemp->lb/ub has indirect innervars.
-    //   2) substitute `vb->var` with `varval`/`newvar`
-    //   note: We only store the innervar in the outmost `varbinding`,
-    //       thus we must check all inner env to ensure the recording/substitution
-    //       is complete
-    int len = current_env_length(e);
-    int8_t *blinding_has_innerdep = (int8_t *)alloca(len);
-    memset(blinding_has_innerdep, 0, len);
+    // flatten all innervar into a (revered) list
+    size_t icount = 0;
+    if (vb->innervars)
+        icount += jl_array_nrows(vb->innervars);
     for (jl_varbinding_t *btemp = e->vars; btemp != NULL; btemp = btemp->prev) {
-        if (btemp->innervars != NULL) {
-            for (size_t i = 0; i < jl_array_len(btemp->innervars); i++) {
-                jl_tvar_t *ivar = (jl_tvar_t*)jl_array_ptr_ref(btemp->innervars, i);
-                ilb = ivar->lb; iub = ivar->ub;
-                int has_innerdep = 0;
-                if (jl_has_typevar(ilb, vb->var)) {
-                    has_innerdep = 1;
-                    if (varval) {
-                        JL_TRY {
-                            ilb = jl_substitute_var(ilb, vb->var, varval);
-                        }
-                        JL_CATCH {
-                            res = jl_bottom_type;
-                        }
-                    }
-                    else if (newvar != vb->var) {
-                        ilb = jl_substitute_var(ilb, vb->var, (jl_value_t*)newvar);
-                    }
-                }
-                if (jl_has_typevar(iub, vb->var)) {
-                    has_innerdep = 1;
-                    if (varval) {
-                        JL_TRY {
-                            iub = jl_substitute_var(iub, vb->var, varval);
-                        }
-                        JL_CATCH {
-                            res = jl_bottom_type;
-                        }
-                    }
-                    else if (newvar != vb->var) {
-                        iub = jl_substitute_var(iub, vb->var, (jl_value_t*)newvar);
-                    }
-                }
-                if (!has_innerdep) continue;
-                int need_substitution = 0;
-                if (ilb != ivar->lb || iub != ivar->ub) {
-                    need_substitution = 1;
-                    nivar = (jl_value_t *)jl_new_typevar(ivar->name, ilb, iub);
-                    jl_array_ptr_set(btemp->innervars, i, nivar);
-                    if (jl_has_typevar(res, ivar))
-                        res = jl_substitute_var(res, ivar, nivar);
-                }
-                int envind = 0;
-                for (jl_varbinding_t *btemp2 = e->vars; btemp2 != btemp->prev; btemp2 = btemp2->prev) {
-                    if (jl_has_typevar(btemp2->lb, ivar)) {
-                        if (need_substitution)
-                            btemp2->lb = jl_substitute_var(btemp2->lb, ivar, nivar);
-                        blinding_has_innerdep[envind] |= 1;
-                    }
-                    if (jl_has_typevar(btemp2->ub, ivar)) {
-                        if (need_substitution)
-                            btemp2->ub = jl_substitute_var(btemp2->ub, ivar, nivar);
-                        blinding_has_innerdep[envind] |= 2;
-                    }
-                    envind++;
-                }
-                // FIXME: innervar that depend on `ivar` should also be updated.
-            }
+        if (btemp->innervars != NULL)
+            icount += jl_array_nrows(btemp->innervars);
+    }
+    jl_svec_t *p = NULL;
+    jl_value_t **iparams;
+    jl_value_t **roots;
+    JL_GC_PUSHARGS(roots, icount < 22 ? 3*icount : 1);
+    if (icount < 22) {
+        iparams = roots;
+    }
+    else {
+        p = jl_alloc_svec(3*icount);
+        roots[0] = (jl_value_t*)p;
+        iparams = jl_svec_data(p);
+    }
+    jl_ivarbinding_t *allvars = NULL;
+    size_t niparams = 0;
+    if (vb->innervars) {
+        for (size_t i = 0; i < jl_array_nrows(vb->innervars); i++) {
+            jl_tvar_t *ivar = (jl_tvar_t *)jl_array_ptr_ref(vb->innervars, i);
+            jl_ivarbinding_t *inew = (jl_ivarbinding_t *)alloca(sizeof(jl_ivarbinding_t));
+            inew->var = (jl_tvar_t **)&iparams[niparams++]; *inew->var = ivar;
+            inew->lb = &iparams[niparams++]; *inew->lb = ivar->lb;
+            inew->ub = &iparams[niparams++]; *inew->ub = ivar->ub;
+            inew->root = vb;
+            inew->next = allvars;
+            allvars = inew;
         }
     }
-    // II. Handle direct innervars.
-    jl_varbinding_t *wrap = NULL;
-    int envind = 0;
     for (jl_varbinding_t *btemp = e->vars; btemp != NULL; btemp = btemp->prev) {
-        int has_innerdep = blinding_has_innerdep[envind++];
-        int lb_has_innerdep = has_innerdep & 1;
-        int ub_has_innerdep = has_innerdep & 2;
-        assert(!has_innerdep || btemp->depth0 == vb->depth0);
-        int lb_has_dep = jl_has_typevar(btemp->lb, vb->var);
-        int ub_has_dep = jl_has_typevar(btemp->ub, vb->var);
-        if (lb_has_innerdep || lb_has_dep) {
-            if (vb->lb == (jl_value_t*)btemp->var) {
+        jl_ivarbinding_t *inew = (jl_ivarbinding_t *)alloca(sizeof(jl_ivarbinding_t));
+        inew->var = &btemp->var;
+        inew->lb = &btemp->lb;
+        inew->ub = &btemp->ub;
+        inew->root = btemp;
+        inew->next = allvars;
+        allvars = inew;
+        if (btemp->innervars) {
+            for (size_t i = 0; i < jl_array_nrows(btemp->innervars); i++) {
+                jl_tvar_t *ivar = (jl_tvar_t *)jl_array_ptr_ref(btemp->innervars, i);
+                jl_ivarbinding_t *inew = (jl_ivarbinding_t *)alloca(sizeof(jl_ivarbinding_t));
+                inew->var = (jl_tvar_t **)&iparams[niparams++]; *inew->var = ivar;
+                inew->lb = &iparams[niparams++]; *inew->lb = ivar->lb;
+                inew->ub = &iparams[niparams++]; *inew->ub = ivar->ub;
+                inew->root = btemp;
+                inew->next = allvars;
+                allvars = inew;
+            }
+        }
+    }
+
+    // remove/replace/rewrap free occurrences of this var in the environment
+    int wrapped = 0;
+    jl_ivarbinding_t *pwrap = NULL;
+    for (jl_ivarbinding_t *btemp = allvars, *pbtemp = NULL; btemp != NULL; btemp = btemp->next) {
+        int bdepth0 = btemp->root->depth0;
+        ivar = *btemp->var;
+        ilb = *btemp->lb;
+        iub = *btemp->ub;
+        if (jl_has_typevar(ilb, vb->var)) {
+            assert(btemp->root->var == ivar || bdepth0 == vb->depth0);
+            if (vb->lb == (jl_value_t*)ivar) {
+                JL_GC_POP();
                 JL_GC_POP();
                 return jl_bottom_type;
             }
             if (varval) {
-                if (lb_has_dep) { // inner substitution has been handled
-                    JL_TRY {
-                        btemp->lb = jl_substitute_var(btemp->lb, vb->var, varval);
-                    }
-                    JL_CATCH {
-                        res = jl_bottom_type;
-                    }
+                JL_TRY {
+                    *btemp->lb = jl_substitute_var(ilb, vb->var, varval);
+                }
+                JL_CATCH {
+                    res = jl_bottom_type;
                 }
             }
-            else if (btemp->lb == (jl_value_t*)vb->var) {
-                btemp->lb = vb->lb;
+            else if (ilb == (jl_value_t*)vb->var) {
+                *btemp->lb = vb->lb;
             }
-            else if (btemp->depth0 == vb->depth0 && !jl_has_typevar(vb->lb, btemp->var) && !jl_has_typevar(vb->ub, btemp->var)) {
+            else if (bdepth0 == vb->depth0 && !jl_has_typevar(vb->lb, ivar) && !jl_has_typevar(vb->ub, ivar)) {
                 // if our variable is T, and some outer variable has constraint S = Ref{T},
                 // move the `where T` outside `where S` instead of putting it here. issue #21243.
-                if (newvar != vb->var && lb_has_dep) // inner substitution has been handled
-                    btemp->lb = jl_substitute_var(btemp->lb, vb->var, (jl_value_t*)newvar);
-                wrap = btemp;
+                if (newvar != vb->var)
+                    *btemp->lb = jl_substitute_var(ilb, vb->var, (jl_value_t*)newvar);
+                if (!wrapped) pwrap = pbtemp;
+                wrapped = 1;
             }
             else {
-                btemp->lb = jl_new_struct(jl_unionall_type, vb->var, btemp->lb);
+                *btemp->lb = jl_new_struct(jl_unionall_type, vb->var, ilb);
             }
-            assert((jl_value_t*)btemp->var != btemp->lb);
+            assert((jl_value_t*)ivar != *btemp->lb);
         }
-        if (ub_has_innerdep || ub_has_dep) {
-            if (vb->ub == (jl_value_t*)btemp->var) {
-                // TODO: handle `omit_bad_union` correctly if `ub_has_innerdep`
-                btemp->ub = omit_bad_union(btemp->ub, vb->var);
-                if (btemp->ub == jl_bottom_type && btemp->ub != btemp->lb) {
+        if (jl_has_typevar(iub, vb->var)) {
+            assert(btemp->root->var == ivar || bdepth0 == vb->depth0);
+            if (vb->ub == (jl_value_t*)ivar) {
+                *btemp->ub = omit_bad_union(iub, vb->var);
+                if (*btemp->ub == jl_bottom_type && *btemp->ub != *btemp->lb) {
+                    JL_GC_POP();
                     JL_GC_POP();
                     return jl_bottom_type;
                 }
             }
             if (varval) {
-                if (ub_has_dep) { // inner substitution has been handled
-                    JL_TRY {
-                        btemp->ub = jl_substitute_var(btemp->ub, vb->var, varval);
-                    }
-                    JL_CATCH {
-                        res = jl_bottom_type;
-                    }
+                JL_TRY {
+                    *btemp->ub = jl_substitute_var(iub, vb->var, varval);
+                }
+                JL_CATCH {
+                    res = jl_bottom_type;
                 }
             }
-            else if (btemp->ub == (jl_value_t*)vb->var) {
+            else if (iub == (jl_value_t*)vb->var) {
                 // TODO: this loses some constraints, such as in this test, where we replace T4<:S3 (e.g. T4==S3 since T4 only appears covariantly once) with T4<:Any
                 // a = Tuple{Float64,T3,T4} where T4 where T3
                 // b = Tuple{S2,Tuple{S3},S3} where S2 where S3
                 // Tuple{Float64, T3, T4} where {S3, T3<:Tuple{S3}, T4<:S3}
-                btemp->ub = vb->ub;
+                *btemp->ub = vb->ub;
             }
-            else if (btemp->depth0 == vb->depth0 && !jl_has_typevar(vb->lb, btemp->var) && !jl_has_typevar(vb->ub, btemp->var)) {
-                if (newvar != vb->var && ub_has_dep) // inner substitution has been handled
-                    btemp->ub = jl_substitute_var(btemp->ub, vb->var, (jl_value_t*)newvar);
-                wrap = btemp;
+            else if (bdepth0 == vb->depth0 && !jl_has_typevar(vb->lb, ivar) && !jl_has_typevar(vb->ub, ivar)) {
+                if (newvar != vb->var)
+                    *btemp->ub = jl_substitute_var(iub, vb->var, (jl_value_t*)newvar);
+                if (!wrapped) pwrap = pbtemp;
+                wrapped = 1;
             }
             else
-                btemp->ub = jl_new_struct(jl_unionall_type, vb->var, btemp->ub);
-            assert((jl_value_t*)btemp->var != btemp->ub);
+                *btemp->ub = jl_new_struct(jl_unionall_type, vb->var, iub);
+            assert((jl_value_t*)ivar != *btemp->ub);
+        }
+        pbtemp = btemp;
+    }
+
+    // Insert the newvar into the (reversed) var list if needed.
+    if (wrapped) {
+        jl_ivarbinding_t *wrap = pwrap == NULL ? allvars : pwrap->next;
+        jl_ivarbinding_t *inew = (jl_ivarbinding_t *)alloca(sizeof(jl_ivarbinding_t));
+        inew->var = &newvar;
+        inew->lb = &newvar->lb;
+        inew->ub = &newvar->ub;;
+        inew->root = wrap->root;
+        inew->next = wrap;
+        if (pwrap != NULL)
+            pwrap->next = inew;
+        else
+            allvars = inew;
+    }
+
+    // Re-sort the innervar inside the (reversed) var list.
+    // `jl_has_typevar` is used as the partial-ordering predicate.
+    // If this is slow, we could possibly switch to a simpler graph sort, such as Tarjan's SCC.
+    if (icount > 0) {
+        jl_ivarbinding_t *pib1 = NULL;
+        while (1) {
+            jl_ivarbinding_t *ib1 = pib1 == NULL ? allvars : pib1->next;
+            if (ib1 == NULL) break;
+            if (jl_has_free_typevars(*ib1->lb) || jl_has_free_typevars(*ib1->ub)) {
+                int changed = 0;
+                jl_ivarbinding_t *pib2 = ib1, *ib2 = ib1->next;
+                while (ib2 != NULL) {
+                    int isinnervar = ib2->root->var != *ib2->var;
+                    if (isinnervar && ib1->root->depth0 == ib2->root->depth0 &&
+                        (jl_has_typevar(*ib1->lb, *ib2->var) ||
+                        jl_has_typevar(*ib1->ub, *ib2->var))) {
+                        pib2->next = ib2->next;
+                        ib2->next = ib1;
+                        ib2->root = ib1->root;
+                        if (pib1)
+                            pib1->next = ib2;
+                        else
+                            allvars = ib2;
+                        changed = 1;
+                        break;
+                    }
+                    pib2 = ib2;
+                    ib2 = ib2->next;
+                }
+                if (changed) continue;
+            }
+            pib1 = ib1;
+        }
+    }
+
+    // Freeze the innervars' lb/ub and perform substitution if needed.
+    for (jl_ivarbinding_t *btemp1 = allvars; btemp1 != NULL; btemp1 = btemp1->next) {
+        ivar = *btemp1->var;
+        ilb = *btemp1->lb;
+        iub = *btemp1->ub;
+        int isinnervar = btemp1->root->var != ivar;
+        if (isinnervar && (ivar->lb != ilb || ivar->ub != iub)) {
+            nivar = (jl_value_t *)jl_new_typevar(ivar->name, ilb, iub);
+            if (jl_has_typevar(res, ivar))
+                res = jl_substitute_var(res, ivar, nivar);
+            for (jl_ivarbinding_t *btemp2 = btemp1->next; btemp2 != NULL; btemp2 = btemp2->next) {
+                ilb = *btemp2->lb;
+                iub = *btemp2->ub;
+                if (jl_has_typevar(ilb, ivar))
+                    *btemp2->lb = jl_substitute_var(ilb, ivar, nivar);
+                if (jl_has_typevar(iub, ivar))
+                    *btemp2->ub = jl_substitute_var(iub, ivar, nivar);
+            }
+            *btemp1->var = (jl_tvar_t *)nivar;
         }
     }
 
-    if (wrap) {
-        // We only assign the newvar with the outmost var.
-        // This make sure we never create a UnionAll with 2 identical vars.
-        if (wrap->innervars == NULL)
-            wrap->innervars = jl_alloc_array_1d(jl_array_any_type, 0);
-        jl_array_ptr_1d_push(wrap->innervars, (jl_value_t*)newvar);
-        // TODO: should we move all the innervars here too?
+    // Switch back the innervars' storage.
+    while (1) {
+        jl_ivarbinding_t *btemp = allvars;
+        jl_varbinding_t *root = btemp ? btemp->root : vb;
+        size_t icount = 0;
+        while (btemp && btemp->root == root) {
+            btemp = btemp->next;
+            icount++;
+        }
+        if (root != vb) icount--;
+        if (root->innervars != NULL) {
+            size_t len = jl_array_nrows(root->innervars);
+            if (icount > len)
+                jl_array_grow_end(root->innervars, icount - len);
+            if (icount < len)
+                jl_array_del_end(root->innervars, len - icount);
+        }
+        else if (icount > 0) {
+            root->innervars = jl_alloc_array_1d(jl_array_any_type, icount);
+        }
+        btemp = allvars;
+        for (size_t i = icount; i > 0; i--) {
+            jl_array_ptr_set(root->innervars, i - 1, (jl_value_t*)*btemp->var);
+            btemp = btemp->next;
+        }
+        if (root == vb) break;
+        assert(*btemp->var == root->var);
+        allvars = btemp->next;
+        assert(allvars == NULL || allvars->root != root);
     }
+    JL_GC_POP();
 
     // if `v` still occurs, re-wrap body in `UnionAll v` or eliminate the UnionAll
     if (jl_has_typevar(res, vb->var)) {
@@ -3023,67 +3110,15 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
             if (newvar != vb->var)
                 res = jl_substitute_var(res, vb->var, (jl_value_t*)newvar);
             varval = (jl_value_t*)newvar;
-            if (!wrap)
+            if (!wrapped)
                 res = jl_type_unionall((jl_tvar_t*)newvar, res);
         }
     }
 
     if (vb->innervars != NULL) {
-        size_t len = jl_array_nrows(vb->innervars), count = 0;
-        for (size_t i = 0; i < len; i++) {
+        for (size_t i = 0; i < jl_array_nrows(vb->innervars); i++) {
             jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
-            // the `btemp->prev` walk is only giving a sort of post-order guarantee (since we are
-            // iterating 2 trees at once), so once we set `wrap`, there might remain other branches
-            // of the type walk that now still may have incomplete bounds: finish those now too
-            jl_varbinding_t *wrap = NULL;
-            for (jl_varbinding_t *btemp = e->vars; btemp != NULL; btemp = btemp->prev) {
-                if (btemp->depth0 == vb->depth0 && (jl_has_typevar(btemp->lb, var) || jl_has_typevar(btemp->ub, var))) {
-                    wrap = btemp;
-                }
-            }
-            if (wrap) {
-                if (wrap->innervars == NULL)
-                    wrap->innervars = jl_alloc_array_1d(jl_array_any_type, 0);
-                // FIXME: `var`'s dependence should also be pushed into `wrap->innervars`.
-                jl_array_ptr_1d_push(wrap->innervars, (jl_value_t*)var);
-                jl_array_ptr_set(vb->innervars, i, (jl_value_t*)NULL);
-            }
-        }
-        for (size_t i = 0; i < len; i++) {
-            jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
-            if (var) {
-                if (count < i)
-                    jl_array_ptr_set(vb->innervars, count, (jl_value_t*)var);
-                count++;
-            }
-        }
-        if (count != len)
-            jl_array_del_end(vb->innervars, len - count);
-        if (res != jl_bottom_type) {
-            while (count > 1) {
-                int changed = 0;
-                // Now need to re-sort the vb->innervars using the partial-ordering predicate `jl_has_typevar`.
-                // If this is slow, we could possibly switch to a simpler graph sort than this triple loop, such as Tarjan's SCC.
-                // But for now we use a variant on selection sort for partial-orders.
-                for (size_t i = 0; i < count - 1; i++) {
-                    jl_tvar_t *vari = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
-                    for (size_t j = i+1; j < count; j++) {
-                        jl_tvar_t *varj = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, j);
-                        if (jl_has_typevar(varj->lb, vari) || jl_has_typevar(varj->ub, vari)) {
-                            jl_array_ptr_set(vb->innervars, j, (jl_value_t*)vari);
-                            jl_array_ptr_set(vb->innervars, i, (jl_value_t*)varj);
-                            changed = 1;
-                            break;
-                        }
-                    }
-                    if (changed) break;
-                }
-                if (!changed) break;
-            }
-            for (size_t i = 0; i < count; i++) {
-                jl_tvar_t *var = (jl_tvar_t*)jl_array_ptr_ref(vb->innervars, i);
-                res = jl_type_unionall(var, res);
-            }
+            res = jl_type_unionall(var, res);
         }
     }
 
@@ -3958,9 +3993,9 @@ static int merge_env(jl_stenv_t *e, jl_savedenv_t *se, int count)
             se->buf[m+2] = 0;
             se->buf[m+3] = v->max_offset;
         }
+        jl_value_t *b1, *b2;
         if (v->occurs) {
-            // only merge lb/ub/innervars if this var occurs.
-            jl_value_t *b1, *b2;
+            // only merge lb/ub if this var occurs.
             b1 = roots[n];
             JL_GC_PROMISE_ROOTED(b1); // clang-sagc doesn't know this came from our GC frame
             b2 = v->lb;
@@ -3971,19 +4006,21 @@ static int merge_env(jl_stenv_t *e, jl_savedenv_t *se, int count)
             b2 = v->ub;
             JL_GC_PROMISE_ROOTED(b2); // clang-sagc doesn't know the fields of this are stack GC roots
             roots[n+1] = b1 ? simple_join(b1, b2) : b2;
-            b1 = roots[n+2];
-            JL_GC_PROMISE_ROOTED(b1); // clang-sagc doesn't know this came from our GC frame
-            b2 = (jl_value_t*)v->innervars;
-            JL_GC_PROMISE_ROOTED(b2); // clang-sagc doesn't know the fields of this are stack GC roots
-            if (b2 && b1 != b2) {
-                if (b1)
-                    jl_array_ptr_1d_append((jl_array_t*)b1, (jl_array_t*)b2);
-                else
-                    roots[n+2] = b2;
-            }
             // record the meeted vars.
             se->buf[m] = 1;
         }
+        // `innervars` might be re-sorted inside `finish_unionall`.
+        // We'd better always merge it.
+        b1 = roots[n+2];
+        JL_GC_PROMISE_ROOTED(b1); // clang-sagc doesn't know this came from our GC frame
+        b2 = (jl_value_t*)v->innervars;
+        JL_GC_PROMISE_ROOTED(b2); // clang-sagc doesn't know the fields of this are stack GC roots
+        if (b2 && b1 != b2) {
+            if (b1)
+                jl_array_ptr_1d_append((jl_array_t*)b1, (jl_array_t*)b2);
+            else
+                roots[n+2] = b2;
+        }
         // always merge occurs_inv/cov by max (never decrease)
         if (v->occurs_inv > se->buf[m+1])
             se->buf[m+1] = v->occurs_inv;

From 2e876fc7f665cd660aeb8f0c260523c1a1ca6d29 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 14 Mar 2024 01:23:57 +0900
Subject: [PATCH 1126/1315] inlining: remove ineffective handling for unmatched
 params (#52092)

The deleted branch was added in #45062, although it had not been tested.

I tried the following diff to find cases optimized by that, but I just
found the handling proved to be in vain in all cases I tried.
```diff
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 318b21b09b..7e42a65aa4 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1473,6 +1473,14 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
         handle_any_const_result!(cases,
             result, match, argtypes, info, flag, state; allow_abstract=true, allow_typevars=true)
         fully_covered = handled_all_cases = match.fully_covers
+        if length(cases) == 1 && fully_covered
+            println("first case: ", only_method)
+        elseif length(cases) == 1
+            atype = argtypes_to_type(sig.argtypes)
+            if atype isa DataType && cases[1].sig isa DataType
+                println("second case: ", only_method)
+            end
+        end
     elseif !handled_all_cases
         # if we've not seen all candidates, union split is valid only for dispatch tuples
         filter!(case::InliningCase->isdispatchtuple(case.sig), cases)
```
---
 base/compiler/ssair/inlining.jl | 56 +++++++++------------------------
 1 file changed, 14 insertions(+), 42 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index c49bfe2239972..4f48c30824155 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1333,12 +1333,10 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
     nunion === nothing && return nothing
     cases = InliningCase[]
     argtypes = sig.argtypes
-    local handled_all_cases::Bool = true
-    local revisit_idx = local only_method = nothing
-    local meth::MethodLookupResult
+    local handled_all_cases = local fully_covered = true
+    local revisit_idx = nothing
     local all_result_count = 0
-    local joint_effects::Effects = EFFECTS_TOTAL
-    local fully_covered::Bool = true
+    local joint_effects = EFFECTS_TOTAL
     for i = 1:nunion
         meth = getsplit(info, i)
         if meth.ambig
@@ -1349,18 +1347,8 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
             # No applicable methods; try next union split
             handled_all_cases = false
             continue
-        else
-            if length(meth) == 1 && only_method !== missing
-                if only_method === nothing
-                    only_method = meth[1].method
-                elseif only_method !== meth[1].method
-                    only_method = missing
-                end
-            else
-                only_method = missing
-            end
         end
-        local split_fully_covered::Bool = false
+        local split_fully_covered = false
         for (j, match) in enumerate(meth)
             all_result_count += 1
             result = getresult(info, all_result_count)
@@ -1387,33 +1375,17 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
 
     (handled_all_cases & fully_covered) || (joint_effects = Effects(joint_effects; nothrow=false))
 
-    if handled_all_cases && revisit_idx !== nothing
-        # we handled everything except one match with unmatched sparams,
-        # so try to handle it by bypassing validate_sparams
-        (i, j, k) = revisit_idx
-        match = getsplit(info, i)[j]
-        result = getresult(info, k)
-        handled_all_cases &= handle_any_const_result!(cases,
-            result, match, argtypes, info, flag, state; allow_abstract=true, allow_typevars=true)
-    elseif length(cases) == 0 && only_method isa Method
-        # if the signature is fully covered and there is only one applicable method,
-        # we can try to inline it even in the presence of unmatched sparams
-        # -- But don't try it if we already tried to handle the match in the revisit_idx
-        # case, because that'll (necessarily) be the same method.
-        if nsplit(info)::Int > 1
-            atype = argtypes_to_type(argtypes)
-            (metharg, methsp) = ccall(:jl_type_intersection_with_env, Any, (Any, Any), atype, only_method.sig)::SimpleVector
-            match = MethodMatch(metharg, methsp::SimpleVector, only_method, true)
-            result = nothing
-        else
-            @assert length(meth) == 1
-            match = meth[1]
-            result = getresult(info, 1)
+    if handled_all_cases
+        if revisit_idx !== nothing
+            # we handled everything except one match with unmatched sparams,
+            # so try to handle it by bypassing validate_sparams
+            (i, j, k) = revisit_idx
+            match = getsplit(info, i)[j]
+            result = getresult(info, k)
+            handled_all_cases &= handle_any_const_result!(cases,
+                result, match, argtypes, info, flag, state; allow_abstract=true, allow_typevars=true)
         end
-        handle_any_const_result!(cases,
-            result, match, argtypes, info, flag, state; allow_abstract=true, allow_typevars=true)
-        fully_covered = handled_all_cases = match.fully_covers
-    elseif !handled_all_cases
+    elseif !isempty(cases)
         # if we've not seen all candidates, union split is valid only for dispatch tuples
         filter!(case::InliningCase->isdispatchtuple(case.sig), cases)
     end

From 48e89db7689f66008456f6a876373c4cf5d1320a Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Wed, 13 Mar 2024 19:06:55 -0300
Subject: [PATCH 1127/1315] bump number of GC threads to the number of compute
 threads (as opposed to half of it) (#53608)

The GC scheduler seems to have matured enough for us to do this.
---
 src/threading.c     | 9 ++-------
 test/cmdlineargs.jl | 2 +-
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/threading.c b/src/threading.c
index 8879a34d6b701..eb76ac579b538 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -708,14 +708,9 @@ void jl_init_threading(void)
         }
         else {
             // if `--gcthreads` or ENV[NUM_GCTHREADS_NAME] was not specified,
-            // set the number of mark threads to half of compute threads
+            // set the number of mark threads to the number of compute threads
             // and number of sweep threads to 0
-            if (nthreads <= 1) {
-                jl_n_markthreads = 0;
-            }
-            else {
-                jl_n_markthreads = (nthreads / 2) - 1;
-            }
+            jl_n_markthreads = nthreads - 1; // -1 for the master (mutator) thread which may also do marking
             // if `--gcthreads` or ENV[NUM_GCTHREADS_NAME] was not specified,
             // cap the number of threads that may run the mark phase to
             // the number of CPU cores
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 291b0b0fdad78..2418296ef2292 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -388,7 +388,7 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
     # --gcthreads
     code = "print(Threads.ngcthreads())"
     cpu_threads = ccall(:jl_effective_threads, Int32, ())
-    @test (cpu_threads == 1 ? "1" : string(div(cpu_threads, 2))) ==
+    @test string(cpu_threads) ==
           read(`$exename --threads auto -e $code`, String) ==
           read(`$exename --threads=auto -e $code`, String) ==
           read(`$exename -tauto -e $code`, String) ==

From f24364a4821f85410a27a236173c4e6bbb08e568 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 14 Mar 2024 04:07:25 -0400
Subject: [PATCH 1128/1315] Don't recurse lowering symbol renaming through
 `Expr(:toplevel)` (#53730)

Fixes #53729.
---
 base/show.jl         |  5 +++++
 src/julia-syntax.scm |  2 +-
 test/show.jl         | 11 +++++++++++
 test/syntax.jl       |  4 ++++
 4 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/base/show.jl b/base/show.jl
index ea6fd2b820207..f7846e316c330 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -2504,6 +2504,11 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int, quote_level::In
     elseif head === :meta && nargs == 2 && args[1] === :pop_loc
         print(io, "# meta: pop locations ($(args[2]::Int))")
     # print anything else as "Expr(head, args...)"
+    elseif head === :toplevel
+        # Reset SOURCE_SLOTNAMES. Raw SlotNumbers are not valid in Expr(:toplevel), but
+        # we want to show bad ASTs reasonably to make errors understandable.
+        lambda_io = IOContext(io, :SOURCE_SLOTNAMES => false)
+        show_unquoted_expr_fallback(lambda_io, ex, indent, quote_level)
     else
         unhandled = true
     end
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 079d4155fa6d0..abe8165c42787 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -5131,7 +5131,7 @@ f(x) = yt(x)
             ((nospecialize-meta? e)
              ;; convert nospecialize vars to slot numbers
              `(meta ,(cadr e) ,@(map renumber-stuff (cddr e))))
-            ((or (atom? e) (quoted? e) (eq? (car e) 'global))
+            ((or (atom? e) (quoted? e) (eq? (car e) 'global) (eq? (car e) 'toplevel))
              e)
             ((ssavalue? e)
              (let ((idx (get ssavalue-table (cadr e) #f)))
diff --git a/test/show.jl b/test/show.jl
index 2eabe6353f328..4bc7540326923 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2683,3 +2683,14 @@ end
 using .Issue49382
 (::Type{Issue49382.Type49382})() = 1
 @test sprint(show, methods(Issue49382.Type49382)) isa String
+
+# Showing of bad SlotNumber in Expr(:toplevel)
+let lowered = Meta.lower(Main, Expr(:let, Expr(:block), Expr(:block, Expr(:toplevel, :(x = 1)), :(y = 1))))
+    ci = lowered.args[1]
+    @assert isa(ci, Core.CodeInfo)
+    @test !isempty(ci.slotnames)
+    @assert ci.code[1].head === :toplevel
+    ci.code[1].args[1] = :($(Core.SlotNumber(1)) = 1)
+    # Check that this gets printed as `_1 = 1` not `y = 1`
+    @test contains(sprint(show, ci), "_1 = 1")
+end
diff --git a/test/syntax.jl b/test/syntax.jl
index fbbf7127f0c53..9c26ea97594d0 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -3669,3 +3669,7 @@ let nnames = length(names(MacroHygieneGenerator; all=true))
     @test (MacroHygieneGenerator.@gen3) == Bool[false]
     @test length(names(MacroHygieneGenerator; all=true)) == nnames
 end
+
+# Issue #53729 - Lowering recursion into Expr(:toplevel)
+@test eval(Expr(:let, Expr(:block), Expr(:block, Expr(:toplevel, :(f53729(x) = x)), :(x=1)))) == 1
+@test f53729(2) == 2

From 612393c944a0a55410e41b6d253ee10ff2f4a84b Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Thu, 14 Mar 2024 07:01:22 -0400
Subject: [PATCH 1129/1315] Avoid macro-expand recursion into `Expr(:toplevel,
 ...)` (#53515)

Here's an example output from macroexpand:
```
Expr
  head: Symbol thunk
  args: Array{Any}((1,))
    1: Core.CodeInfo
      code: Array{Any}((2,))
        1: Expr
          head: Symbol toplevel
          args: Array{Any}((17,))
            1: Expr
              head: Symbol hygienic-scope
              args: Array{Any}((3,))
                1: LineNumberNode
                2: Module Base.Enums
                3: LineNumberNode
            2: Expr
              head: Symbol hygienic-scope
              args: Array{Any}((3,))
                1: Expr
                2: Module Base.Enums
                3: LineNumberNode
            3: Expr
              head: Symbol hygienic-scope
              args: Array{Any}((3,))
                1: LineNumberNode
                2: Module Base.Enums
                3: LineNumberNode
            4: Expr
              head: Symbol hygienic-scope
              args: Array{Any}((3,))
                1: Expr
                2: Module Base.Enums
                3: LineNumberNode
 ...
```

Currently fails during bootstrap with:
```
LoadError("sysimg.jl", 3, LoadError("Base.jl", 542, ErrorException("cannot document the following expression:\n\n#= mpfr.jl:65 =# @enum MPFRRoundingMode begin\n        #= mpfr.jl:66 =#\n        MPFRRoundNearest\n        #= mpfr.jl:67 =#\n        MPFRRoundToZero\n        #= mpfr.jl:68 =#\n        MPFRRoundUp\n        #= mpfr.jl:69 =#\n        MPFRRoundDown\n        #= mpfr.jl:70 =#\n        MPFRRoundFromZero\n        #= mpfr.jl:71 =#\n        MPFRRoundFaithful\n    end\n\n'@enum' not documentable. See 'Base.@__doc__' docs for details.\n")))
```


Perhaps we can do better than wrapping each `Expr(:toplevel, ...)` arg
individually, or I should be filtering out the LineNumberNodes?

---------

Co-authored-by: Keno Fischer <keno@juliacomputing.com>
Co-authored-by: Keno Fischer <keno@juliahub.com>
---
 NEWS.md             |   6 +++
 base/docs/Docs.jl   | 108 ++++++++++++++++++++++++++++++++++++-----
 src/ast.c           |   2 +-
 src/macroexpand.scm | 115 ++++++++++++++++++++++++--------------------
 test/core.jl        |   7 +++
 test/docs.jl        |  12 +++++
 6 files changed, 185 insertions(+), 65 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index d3f29ef30987d..695427d7eba8e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -17,6 +17,12 @@ Language changes
    may pave the way for inference to be able to intelligently re-use the old
    results, once the new method is deleted. ([#53415])
 
+ - Macro expansion will no longer eargerly recurse into into `Expr(:toplevel)`
+   expressions returned from macros. Instead, macro expansion of `:toplevel`
+   expressions will be delayed until evaluation time. This allows a later
+   expression within a given `:toplevel` expression to make use of macros
+   defined earlier in the same `:toplevel` expression. ([#53515])
+
 Compiler/Runtime improvements
 -----------------------------
 
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index 0c83376ecfc76..0206f867b3811 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -446,6 +446,52 @@ more than one expression is marked then the same docstring is applied to each ex
     end
 
 `@__doc__` has no effect when a macro that uses it is not documented.
+
+!!! compat "Julia 1.12"
+
+    This section documents a very subtle corner case that is only relevant to
+    macros which themselves both define other macros and then attempt to use them
+    within the same expansion. Such macros were impossible to write prior to
+    Julia 1.12 and are still quite rare. If you are not writing such a macro,
+    you may ignore this note.
+
+    In versions prior to Julia 1.12, macroexpansion would recursively expand through
+    `Expr(:toplevel)` blocks. This behavior was changed in Julia 1.12 to allow
+    macros to recursively define other macros and use them in the same returned
+    expression. However, to preserve backwards compatibility with existing uses of
+    `@__doc__`, the doc system will still expand through `Expr(:toplevel)` blocks
+    when looking for `@__doc__` markers. As a result, macro-defining-macros will
+    have an observable behavior difference when annotated with a docstring:
+
+    ```julia
+    julia> macro macroception()
+        Expr(:toplevel, :(macro foo() 1 end), :(@foo))
+    end
+
+    julia> @macroception
+    1
+
+    julia> "Docstring" @macroception
+    ERROR: LoadError: UndefVarError: `@foo` not defined in `Main`
+    ```
+
+    The supported workaround is to manually expand the `@__doc__` macro in the
+    defining macro, which the docsystem will recognize and suppress the recursive
+    expansion:
+
+    ```julia
+    julia> macro macroception()
+        Expr(:toplevel,
+            macroexpand(__module__, :(@__doc__ macro foo() 1 end); recursive=false),
+            :(@foo))
+    end
+
+    julia> @macroception
+    1
+
+    julia> "Docstring" @macroception
+    1
+    ```
 """
 :(Core.@__doc__)
 
@@ -453,17 +499,23 @@ function __doc__!(source, mod, meta, def, define::Bool)
     @nospecialize source mod meta def
     # Two cases must be handled here to avoid redefining all definitions contained in `def`:
     if define
-        # `def` has not been defined yet (this is the common case, i.e. when not generating
-        # the Base image). We just need to convert each `@__doc__` marker to an `@doc`.
-        finddoc(def) do each
+        function replace_meta_doc(each)
             each.head = :macrocall
             each.args = Any[Symbol("@doc"), source, mod, nothing, meta, each.args[end], define]
         end
+
+        # `def` has not been defined yet (this is the common case, i.e. when not generating
+        # the Base image). We just need to convert each `@__doc__` marker to an `@doc`.
+        found = finddoc(replace_meta_doc, mod, def; expand_toplevel = false)
+
+        if !found
+            found = finddoc(replace_meta_doc, mod, def; expand_toplevel = true)
+        end
     else
         # `def` has already been defined during Base image gen so we just need to find and
         # document any subexpressions marked with `@__doc__`.
         docs  = []
-        found = finddoc(def) do each
+        found = finddoc(mod, def; expand_toplevel = true) do each
             push!(docs, :(@doc($source, $mod, $meta, $(each.args[end]), $define)))
         end
         # If any subexpressions have been documented then replace the entire expression with
@@ -472,25 +524,30 @@ function __doc__!(source, mod, meta, def, define::Bool)
             def.head = :toplevel
             def.args = docs
         end
-        found
     end
+    return found
 end
 # Walk expression tree `def` and call `λ` when any `@__doc__` markers are found. Returns
 # `true` to signify that at least one `@__doc__` has been found, and `false` otherwise.
-function finddoc(λ, def::Expr)
+function finddoc(λ, mod::Module, def::Expr; expand_toplevel::Bool=false)
     if isexpr(def, :block, 2) && isexpr(def.args[1], :meta, 1) && (def.args[1]::Expr).args[1] === :doc
         # Found the macroexpansion of an `@__doc__` expression.
         λ(def)
         true
     else
+        if expand_toplevel && isexpr(def, :toplevel)
+            for i = 1:length(def.args)
+                def.args[i] = macroexpand(mod, def.args[i])
+            end
+        end
         found = false
         for each in def.args
-            found |= finddoc(λ, each)
+            found |= finddoc(λ, mod, each; expand_toplevel)
         end
         found
     end
 end
-finddoc(λ, @nospecialize def) = false
+finddoc(λ, mod::Module, @nospecialize def; expand_toplevel::Bool=false) = false
 
 # Predicates and helpers for `docm` expression selection:
 
@@ -528,8 +585,37 @@ iscallexpr(ex) = false
 function docm(source::LineNumberNode, mod::Module, meta, ex, define::Bool = true)
     @nospecialize meta ex
     # Some documented expressions may be decorated with macro calls which obscure the actual
-    # expression. Expand the macro calls and remove extra blocks.
-    x = unblock(macroexpand(mod, ex))
+    # expression. Expand the macro calls.
+    x = macroexpand(mod, ex)
+    return _docm(source, mod, meta, x, define)
+end
+
+function _docm(source::LineNumberNode, mod::Module, meta, x, define::Bool = true)
+    if isexpr(x, :var"hygienic-scope")
+        x.args[1] = _docm(source, mod, meta, x.args[1])
+        return x
+    elseif isexpr(x, :escape)
+        x.args[1] = _docm(source, mod, meta, x.args[1])
+        return x
+    elseif isexpr(x, :block)
+        docarg = 0
+        for i = 1:length(x.args)
+            isa(x.args[i], LineNumberNode) && continue
+            if docarg == 0
+                docarg = i
+                continue
+            end
+            # More than one documentable expression in the block, treat it as a whole
+            # expression, which will fall through and look for (Expr(:meta, doc))
+            docarg = 0
+            break
+        end
+        if docarg != 0
+            x.args[docarg] = _docm(source, mod, meta, x.args[docarg], define)
+            return x
+        end
+    end
+
     # Don't try to redefine expressions. This is only needed for `Base` img gen since
     # otherwise calling `loaddocs` would redefine all documented functions and types.
     def = define ? x : nothing
@@ -594,7 +680,7 @@ function docm(source::LineNumberNode, mod::Module, meta, ex, define::Bool = true
     # All other expressions are undocumentable and should be handled on a case-by-case basis
     # with `@__doc__`. Unbound string literals are also undocumentable since they cannot be
     # retrieved from the module's metadata `IdDict` without a reference to the string.
-    docerror(ex)
+    docerror(x)
 
     return doc
 end
diff --git a/src/ast.c b/src/ast.c
index a7c6ae3bc218c..d0ed4712c66f7 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -1154,7 +1154,7 @@ static jl_value_t *jl_expand_macros(jl_value_t *expr, jl_module_t *inmodule, str
     jl_expr_t *e = (jl_expr_t*)expr;
     if (e->head == jl_inert_sym ||
         e->head == jl_module_sym ||
-        //e->head == jl_toplevel_sym || // TODO: enable this once julia-expand-macroscope is fixed / removed
+        e->head == jl_toplevel_sym ||
         e->head == jl_meta_sym) {
         return expr;
     }
diff --git a/src/macroexpand.scm b/src/macroexpand.scm
index ee52b97669125..403df1f3d9ef0 100644
--- a/src/macroexpand.scm
+++ b/src/macroexpand.scm
@@ -194,18 +194,18 @@
       (unescape (cadr e))
       e))
 
-(define (unescape-global-lhs e env m parent-scope inarg)
+(define (unescape-global-lhs e env m lno parent-scope inarg)
   (cond ((not (pair? e)) e)
-        ((eq? (car e) 'escape) (unescape-global-lhs (cadr e) env m parent-scope inarg))
+        ((eq? (car e) 'escape) (unescape-global-lhs (cadr e) env m lno parent-scope inarg))
         ((memq (car e) '(parameters tuple))
          (list* (car e) (map (lambda (e)
-                          (unescape-global-lhs e env m parent-scope inarg))
+                          (unescape-global-lhs e env m lno parent-scope inarg))
                         (cdr e))))
         ((and (memq (car e) '(|::| kw)) (length= e 3))
-         (list (car e) (unescape-global-lhs (cadr e) env m parent-scope inarg)
-                       (resolve-expansion-vars-with-new-env (caddr e) env m parent-scope inarg)))
+         (list (car e) (unescape-global-lhs (cadr e) env m lno parent-scope inarg)
+                       (resolve-expansion-vars-with-new-env (caddr e) env m lno parent-scope inarg)))
         (else
-         (resolve-expansion-vars-with-new-env e env m parent-scope inarg))))
+         (resolve-expansion-vars-with-new-env e env m lno parent-scope inarg))))
 
 (define (typedef-expr-name e)
   (cond ((atom? e) e)
@@ -290,18 +290,18 @@
 ;; resolve-expansion-vars-with-new-env, but turn on `inarg` if we get inside
 ;; a formal argument list. `e` in general might be e.g. `(f{T}(x)::T) where T`,
 ;; and we want `inarg` to be true for the `(x)` part.
-(define (resolve-in-lhs e env m parent-scope inarg)
-  (define (recur x) (resolve-in-lhs x env m parent-scope inarg))
-  (define (other x) (resolve-expansion-vars-with-new-env x env m parent-scope inarg))
+(define (resolve-in-lhs e env m lno parent-scope inarg)
+  (define (recur x) (resolve-in-lhs x env m lno parent-scope inarg))
+  (define (other x) (resolve-expansion-vars-with-new-env x env m lno parent-scope inarg))
   (case (and (pair? e) (car e))
     ((where) `(where ,(recur (cadr e)) ,@(map other (cddr e))))
     ((|::|)  `(|::| ,(recur (cadr e)) ,(other (caddr e))))
     ((call)  `(call ,(other (cadr e))
                     ,@(map (lambda (x)
-                             (resolve-expansion-vars-with-new-env x env m parent-scope #t))
+                             (resolve-expansion-vars-with-new-env x env m lno parent-scope #t))
                            (cddr e))))
     ((tuple) `(tuple ,@(map (lambda (x)
-                              (resolve-expansion-vars-with-new-env x env m parent-scope #t))
+                              (resolve-expansion-vars-with-new-env x env m lno parent-scope #t))
                             (cdr e))))
     (else (other e))))
 
@@ -338,7 +338,7 @@
                    (keywords-introduced-by x))
               env)))))))
 
-(define (resolve-expansion-vars-with-new-env x env m parent-scope inarg (outermost #f))
+(define (resolve-expansion-vars-with-new-env x env m lno parent-scope inarg (outermost #f))
   (resolve-expansion-vars-
    x
    (if (and (pair? x) (eq? (car x) 'let))
@@ -346,7 +346,7 @@
        ;; the same expression
        env
        (new-expansion-env-for x env outermost))
-   m parent-scope inarg))
+   m lno parent-scope inarg))
 
 (define (reescape ux x)
   (if (and (pair? x) (eq? (car x) 'escape))
@@ -355,29 +355,29 @@
 
 ;; type has special behavior: identifiers inside are
 ;; field names, not expressions.
-(define (resolve-struct-field-expansion x env m parent-scope inarg)
+(define (resolve-struct-field-expansion x env m lno parent-scope inarg)
   (let ((ux (unescape x)))
     (cond
         ((atom? ux) ux)
         ((and (pair? ux) (eq? (car ux) '|::|))
          `(|::| ,(unescape (cadr ux))
-           ,(resolve-expansion-vars- (reescape (caddr ux) x) env m parent-scope inarg)))
+           ,(resolve-expansion-vars- (reescape (caddr ux) x) env m lno parent-scope inarg)))
         ((and (pair? ux) (memq (car ux) '(const atomic)))
-         `(,(car ux) ,(resolve-struct-field-expansion (reescape (cadr ux) x) env m parent-scope inarg)))
+         `(,(car ux) ,(resolve-struct-field-expansion (reescape (cadr ux) x) env m lno parent-scope inarg)))
         (else
-         (resolve-expansion-vars-with-new-env x env m parent-scope inarg)))))
+         (resolve-expansion-vars-with-new-env x env m lno parent-scope inarg)))))
 
-(define (resolve-letlike-assign bind env newenv m parent-scope inarg)
+(define (resolve-letlike-assign bind env newenv m lno parent-scope inarg)
   (if (assignment? bind)
     (make-assignment
       ;; expand binds in newenv with dummy RHS
       (cadr (resolve-expansion-vars- (make-assignment (cadr bind) 0)
-                                    newenv m parent-scope inarg))
+                                    newenv m lno parent-scope inarg))
       ;; expand initial values in old env
-      (resolve-expansion-vars- (caddr bind) env m parent-scope inarg))
+      (resolve-expansion-vars- (caddr bind) env m lno parent-scope inarg))
     ;; Just expand everything else that's not an assignment. N.B.: This includes
     ;; assignments inside escapes, which probably need special handling (TODO).
-    (resolve-expansion-vars- bind newenv m parent-scope inarg)))
+    (resolve-expansion-vars- bind newenv m lno parent-scope inarg)))
 
 (define (for-ranges-list ranges)
   (if (eq? (car ranges) 'escape)
@@ -386,7 +386,7 @@
       (cdr ranges)
       (list ranges))))
 
-(define (resolve-expansion-vars- e env m parent-scope inarg)
+(define (resolve-expansion-vars- e env m lno parent-scope inarg)
   (cond ((or (eq? e 'begin) (eq? e 'end) (eq? e 'ccall) (eq? e 'cglobal) (underscore-symbol? e))
          e)
         ((symbol? e)
@@ -405,23 +405,31 @@
                      (env (car scope))
                      (m (cadr scope))
                      (parent-scope (cdr parent-scope)))
-                (resolve-expansion-vars-with-new-env (cadr e) env m parent-scope inarg))))
+                (resolve-expansion-vars-with-new-env (cadr e) env m lno parent-scope inarg))))
            ((global)
             `(global
                ,@(map (lambda (arg)
                        (if (assignment? arg)
-                           `(= ,(unescape-global-lhs (cadr arg) env m parent-scope inarg)
-                               ,(resolve-expansion-vars-with-new-env (caddr arg) env m parent-scope inarg))
-                           (unescape-global-lhs arg env m parent-scope inarg)))
+                           `(= ,(unescape-global-lhs (cadr arg) env m lno parent-scope inarg)
+                               ,(resolve-expansion-vars-with-new-env (caddr arg) env m lno parent-scope inarg))
+                           (unescape-global-lhs arg env m lno parent-scope inarg)))
+                      (cdr e))))
+           ((toplevel) ; re-wrap Expr(:toplevel) in the current hygienic-scope(s)
+            `(toplevel
+               ,@(map (lambda (arg)
+                       (let loop ((parent-scope parent-scope) (m m) (lno lno) (arg arg))
+                        (let ((wrapped `(hygienic-scope ,arg ,m ,@lno)))
+                          (if (null? parent-scope) wrapped
+                            (loop (cdr parent-scope) (cadar parent-scope) (caddar parent-scope) wrapped)))))
                       (cdr e))))
            ((using import export meta line inbounds boundscheck loopinfo inline noinline purity) (map unescape e))
            ((macrocall) e) ; invalid syntax anyways, so just act like it's quoted.
            ((symboliclabel) e)
            ((symbolicgoto) e)
            ((struct)
-            `(struct ,(cadr e) ,(resolve-expansion-vars- (caddr e) env m parent-scope inarg)
+            `(struct ,(cadr e) ,(resolve-expansion-vars- (caddr e) env m lno parent-scope inarg)
                      ,(map (lambda (x)
-                            (resolve-struct-field-expansion x env m parent-scope inarg))
+                            (resolve-struct-field-expansion x env m lno parent-scope inarg))
                            (cadddr e))))
 
            ((parameters)
@@ -432,17 +440,17 @@
                                 (x (if (and (not inarg) (symbol? ux))
                                        `(kw ,ux ,x)
                                        x)))
-                           (resolve-expansion-vars- x env m parent-scope #f)))
+                           (resolve-expansion-vars- x env m lno parent-scope #f)))
                        (cdr e))))
 
            ((->)
-            `(-> ,(resolve-in-lhs (tuple-wrap-arrow-sig (cadr e)) env m parent-scope inarg)
-                 ,(resolve-expansion-vars-with-new-env (caddr e) env m parent-scope inarg)))
+            `(-> ,(resolve-in-lhs (tuple-wrap-arrow-sig (cadr e)) env m lno parent-scope inarg)
+                 ,(resolve-expansion-vars-with-new-env (caddr e) env m lno parent-scope inarg)))
 
            ((= function)
-             `(,(car e) ,(resolve-in-lhs (cadr e) env m parent-scope inarg)
+             `(,(car e) ,(resolve-in-lhs (cadr e) env m lno parent-scope inarg)
                         ,@(map (lambda (x)
-                                   (resolve-expansion-vars-with-new-env x env m parent-scope inarg))
+                                   (resolve-expansion-vars-with-new-env x env m lno parent-scope inarg))
                                  (cddr e))))
 
            ((kw)
@@ -456,67 +464,67 @@
                 `(kw (|::|
                       ,@(if argname
                             (list (if inarg
-                                      (resolve-expansion-vars- argname env m parent-scope inarg)
+                                      (resolve-expansion-vars- argname env m lno parent-scope inarg)
                                       ;; in keyword arg A=B, don't transform "A"
                                       (unescape argname)))
                             '())
-                      ,(resolve-expansion-vars- type env m parent-scope inarg))
-                     ,(resolve-expansion-vars-with-new-env (caddr e) env m parent-scope inarg))))
+                      ,(resolve-expansion-vars- type env m lno parent-scope inarg))
+                     ,(resolve-expansion-vars-with-new-env (caddr e) env m lno parent-scope inarg))))
              (else
               `(kw ,(if inarg
-                        (resolve-expansion-vars- (cadr e) env m parent-scope inarg)
+                        (resolve-expansion-vars- (cadr e) env m lno parent-scope inarg)
                         (unescape (cadr e)))
-                   ,(resolve-expansion-vars-with-new-env (caddr e) env m parent-scope inarg)))))
+                   ,(resolve-expansion-vars-with-new-env (caddr e) env m lno parent-scope inarg)))))
 
            ((let)
             (let* ((newenv (new-expansion-env-for e env))
-                   (body   (resolve-expansion-vars- (caddr e) newenv m parent-scope inarg))
+                   (body   (resolve-expansion-vars- (caddr e) newenv m lno parent-scope inarg))
                    (binds  (let-binds e)))
               `(let (block
                      ,@(map
                         (lambda (bind)
-                          (resolve-letlike-assign bind env newenv m parent-scope inarg))
+                          (resolve-letlike-assign bind env newenv m lno parent-scope inarg))
                         binds))
                  ,body)))
            ((for)
             (let* ((newenv (new-expansion-env-for e env))
-                   (body   (resolve-expansion-vars- (caddr e) newenv m parent-scope inarg))
+                   (body   (resolve-expansion-vars- (caddr e) newenv m lno parent-scope inarg))
                    (expanded-ranges (map (lambda (range)
-                      (resolve-letlike-assign range env newenv m parent-scope inarg)) (for-ranges-list (cadr e)))))
+                      (resolve-letlike-assign range env newenv m lno parent-scope inarg)) (for-ranges-list (cadr e)))))
               (if (length= expanded-ranges 1)
                 `(for ,@expanded-ranges ,body))
                 `(for (block ,@expanded-ranges) ,body)))
            ((generator)
             (let* ((newenv (new-expansion-env-for e env))
-                   (body   (resolve-expansion-vars- (cadr e) newenv m parent-scope inarg))
+                   (body   (resolve-expansion-vars- (cadr e) newenv m lno parent-scope inarg))
                    (filt? (eq? (car (caddr e)) 'filter))
                    (range-exprs (if filt? (cddr (caddr e)) (cddr e)))
-                   (filt (if filt? (resolve-expansion-vars- (cadr (caddr e)) newenv m parent-scope inarg)))
+                   (filt (if filt? (resolve-expansion-vars- (cadr (caddr e)) newenv m lno parent-scope inarg)))
                    (expanded-ranges (map (lambda (range)
-                      (resolve-letlike-assign range env newenv m parent-scope inarg)) range-exprs)))
+                      (resolve-letlike-assign range env newenv m lno parent-scope inarg)) range-exprs)))
               (if filt?
                 `(generator ,body (filter ,filt ,@expanded-ranges))
                 `(generator ,body ,@expanded-ranges))))
            ((hygienic-scope) ; TODO: move this lowering to resolve-scopes, instead of reimplementing it here badly
-             (let ((parent-scope (cons (list env m) parent-scope))
+             (let ((parent-scope (cons (list env m lno) parent-scope))
                    (body (cadr e))
                    (m (caddr e))
                    (lno  (cdddr e)))
-              (resolve-expansion-vars-with-new-env body env m parent-scope inarg #t)))
+              (resolve-expansion-vars-with-new-env body env m lno parent-scope inarg #t)))
            ((tuple)
             (cons (car e)
                   (map (lambda (x)
                          (if (assignment? x)
                              `(= ,(unescape (cadr x))
-                                 ,(resolve-expansion-vars-with-new-env (caddr x) env m parent-scope inarg))
-                             (resolve-expansion-vars-with-new-env x env m parent-scope inarg)))
+                                 ,(resolve-expansion-vars-with-new-env (caddr x) env m lno parent-scope inarg))
+                             (resolve-expansion-vars-with-new-env x env m lno parent-scope inarg)))
                        (cdr e))))
 
            ;; todo: trycatch
            (else
             (cons (car e)
                   (map (lambda (x)
-                         (resolve-expansion-vars-with-new-env x env m parent-scope inarg))
+                         (resolve-expansion-vars-with-new-env x env m lno parent-scope inarg))
                        (cdr e))))))))
 
 ;; decl-var that also identifies f in f()=...
@@ -617,11 +625,11 @@
         (cdr v)
         '())))
 
-(define (resolve-expansion-vars e m)
+(define (resolve-expansion-vars e m lno)
   ;; expand binding form patterns
   ;; keep track of environment, rename locals to gensyms
   ;; and wrap globals in (globalref module var) for macro's home module
-  (resolve-expansion-vars-with-new-env e '() m '() #f #t))
+  (resolve-expansion-vars-with-new-env e '() m lno '() #f #t))
 
 (define (julia-expand-quotes e)
   (cond ((not (pair? e)) e)
@@ -637,11 +645,12 @@
   (cond ((not (pair? e)) e)
         ((eq? (car e) 'inert) e)
         ((eq? (car e) 'module) e)
+        ((eq? (car e) 'toplevel) e)
         ((eq? (car e) 'hygienic-scope)
          (let ((form (cadr e)) ;; form is the expression returned from expand-macros
                (modu (caddr e)) ;; m is the macro's def module
                (lno  (cdddr e))) ;; lno is (optionally) the line number node
-           (resolve-expansion-vars form modu)))
+           (resolve-expansion-vars form modu lno)))
         (else
          (map julia-expand-macroscopes- e))))
 
diff --git a/test/core.jl b/test/core.jl
index 3a9945f152f5f..173526d3b2128 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8125,3 +8125,10 @@ let M = @__MODULE__
 end
 
 @test Base.unsafe_convert(Ptr{Int}, [1]) !== C_NULL
+
+# Test that new macros are allowed to be defined inside Expr(:toplevel) returned by macros
+macro macroception()
+    Expr(:toplevel, :(macro foo() 1 end), :(@foo))
+end
+
+@test (@macroception()) === 1
diff --git a/test/docs.jl b/test/docs.jl
index 36893b8614170..61d0271c25811 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -1562,3 +1562,15 @@ Base.@ccallable c51586_long()::Int = 3
     @test_broken isempty(undoc)
     @test undoc == [Symbol("@var")]
 end
+
+# Docing the macroception macro
+macro docmacroception()
+    Expr(:toplevel, macroexpand(__module__, :(@Base.__doc__ macro docmacrofoo() 1 end); recursive=false), :(@docmacrofoo))
+end
+
+"""
+This docmacroception has a docstring
+"""
+@docmacroception()
+
+@test Docs.hasdoc(@__MODULE__, :var"@docmacrofoo")

From 5023ee21d70b734edf206aab3cac7c202ee0235a Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 14 Mar 2024 20:15:40 +0900
Subject: [PATCH 1130/1315] replace `REPL.TerminalMenus.terminal` with type
 stable function (#53704)

---
 stdlib/REPL/src/TerminalMenus/AbstractMenu.jl  |  4 ++--
 stdlib/REPL/src/TerminalMenus/Pager.jl         |  2 +-
 stdlib/REPL/src/TerminalMenus/TerminalMenus.jl | 10 ++++------
 stdlib/REPL/test/TerminalMenus/runtests.jl     |  4 ++--
 4 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/stdlib/REPL/src/TerminalMenus/AbstractMenu.jl b/stdlib/REPL/src/TerminalMenus/AbstractMenu.jl
index a1f94852b38ec..ddcfc111cf962 100644
--- a/stdlib/REPL/src/TerminalMenus/AbstractMenu.jl
+++ b/stdlib/REPL/src/TerminalMenus/AbstractMenu.jl
@@ -176,7 +176,7 @@ Returns `selected(m)`.
 !!! compat "Julia 1.6"
     The `cursor` argument requires Julia 1.6 or later.
 """
-request(m::AbstractMenu; kwargs...) = request(terminal, m; kwargs...)
+request(m::AbstractMenu; kwargs...) = request(default_terminal(), m; kwargs...)
 
 function request(term::REPL.Terminals.TTYTerminal, m::AbstractMenu; cursor::Union{Int, Base.RefValue{Int}}=1, suppress_output=false)
     if cursor isa Int
@@ -252,7 +252,7 @@ end
 
 Shorthand for `println(msg); request(m)`.
 """
-request(msg::AbstractString, m::AbstractMenu; kwargs...) = request(terminal, msg, m; kwargs...)
+request(msg::AbstractString, m::AbstractMenu; kwargs...) = request(default_terminal(), msg, m; kwargs...)
 
 function request(term::REPL.Terminals.TTYTerminal, msg::AbstractString, m::AbstractMenu; kwargs...)
     println(term.out_stream, msg)
diff --git a/stdlib/REPL/src/TerminalMenus/Pager.jl b/stdlib/REPL/src/TerminalMenus/Pager.jl
index c823a5dedd1ba..091f87801e7a4 100644
--- a/stdlib/REPL/src/TerminalMenus/Pager.jl
+++ b/stdlib/REPL/src/TerminalMenus/Pager.jl
@@ -39,4 +39,4 @@ function pager(terminal, object)
     pager = Pager(String(take!(buffer)); pagesize = div(lines, 2))
     return request(terminal, pager)
 end
-pager(object) = pager(terminal, object)
+pager(object) = pager(default_terminal(), object)
diff --git a/stdlib/REPL/src/TerminalMenus/TerminalMenus.jl b/stdlib/REPL/src/TerminalMenus/TerminalMenus.jl
index 87869e84d9838..9fcddef2fd484 100644
--- a/stdlib/REPL/src/TerminalMenus/TerminalMenus.jl
+++ b/stdlib/REPL/src/TerminalMenus/TerminalMenus.jl
@@ -2,13 +2,11 @@
 
 module TerminalMenus
 
-terminal = nothing  # The user terminal
+using REPL: REPL
 
-import REPL
-
-function __init__()
-    global terminal
-    terminal = REPL.Terminals.TTYTerminal(get(ENV, "TERM", Sys.iswindows() ? "" : "dumb"), stdin, stdout, stderr)
+function default_terminal(; in::IO=stdin, out::IO=stdout, err::IO=stderr)
+    return REPL.Terminals.TTYTerminal(
+        get(ENV, "TERM", Sys.iswindows() ? "" : "dumb"), in, out, err)
 end
 
 include("util.jl")
diff --git a/stdlib/REPL/test/TerminalMenus/runtests.jl b/stdlib/REPL/test/TerminalMenus/runtests.jl
index c594958a36670..9455632d9f418 100644
--- a/stdlib/REPL/test/TerminalMenus/runtests.jl
+++ b/stdlib/REPL/test/TerminalMenus/runtests.jl
@@ -17,9 +17,9 @@ function simulate_input(menu::TerminalMenus.AbstractMenu, keys...; kwargs...)
             write(new_stdin, "$key")
         end
     end
-    TerminalMenus.terminal.in_stream = new_stdin
+    terminal = TerminalMenus.default_terminal(; in=new_stdin, out=devnull)
 
-    return request(menu; suppress_output=true, kwargs...)
+    return request(terminal, menu; suppress_output=true, kwargs...)
 end
 
 include("radio_menu.jl")

From 82879439db9926c88c364ab783cff0a1a093d6d7 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 14 Mar 2024 19:33:01 +0530
Subject: [PATCH 1131/1315] Remove specialized view method for `OneTo`
 arguments (#53725)

This seems unnecessary, as the fallback method on line 221 does the
same.
---
 base/subarray.jl | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index 2b8545c2cc226..cab1cb3a475e9 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -214,10 +214,6 @@ function view(A::AbstractArray, I::Vararg{Any,M}) where {M}
 end
 
 # Ranges implement getindex to return recomputed ranges; use that for views, too (when possible)
-function view(r1::OneTo, r2::OneTo)
-    @_propagate_inbounds_meta
-    getindex(r1, r2)
-end
 function view(r1::AbstractUnitRange, r2::AbstractUnitRange{<:Integer})
     @_propagate_inbounds_meta
     getindex(r1, r2)

From b507330e841287634d987e3378bcf667d41d4621 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 14 Mar 2024 19:34:50 +0530
Subject: [PATCH 1132/1315] Remove specialized IndexStyle method for SubArray
 (#53726)

The fallback method `IndexStyle(::Type{<:AbstractArray})` does the same,
so this is unnecessary.
---
 base/subarray.jl | 1 -
 test/subarray.jl | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index cab1cb3a475e9..e9660b9dee639 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -426,7 +426,6 @@ function _unsetindex!(V::SubArray{T,N}, i::Vararg{Int,N}) where {T,N}
 end
 
 IndexStyle(::Type{<:FastSubArray}) = IndexLinear()
-IndexStyle(::Type{<:SubArray}) = IndexCartesian()
 
 # Strides are the distance in memory between adjacent elements in a given dimension
 # which we determine from the strides of the parent
diff --git a/test/subarray.jl b/test/subarray.jl
index 31bd69cccb5ae..eedf28539d72b 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -339,6 +339,7 @@ end
     A = copy(reshape(1:120, 3, 5, 8))
     sA = view(A, 2:2, 1:5, :)
     @test @inferred(strides(sA)) == (1, 3, 15)
+    @test IndexStyle(sA) == IndexStyle(typeof(sA)) == IndexCartesian()
     @test parent(sA) == A
     @test parentindices(sA) == (2:2, 1:5, Base.Slice(1:8))
     @test size(sA) == (1, 5, 8)

From c4ab0d46a9c3a470794e5a441176bfdf8ff36e52 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 14 Mar 2024 10:23:58 -0400
Subject: [PATCH 1133/1315] Increase build precompilation (#53682)

- Bake precompilepkgs into the sysimage
- Enable compilation in stdlib JLLs @staticfloat I guess this is ok now
we have pkgimages?
- Add some hardcoded precompiles encountered locally
- Disable a problematic llvm test, with a note

With this there's no compilation loading Pkg in interactive mode
```
% ./julia --trace-compile=stderr --start=no -q
julia> ]
(@v1.12) pkg>
```

Before
```
% time julia +nightly --start=no --trace-compile=stderr -q -e "using Pkg"
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Symbol, Union{Nothing, Bool, Int64, String}}, Int64, Symbol})
precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Any}, String})
precompile(Tuple{typeof(MbedTLS_jll.__init__)})
precompile(Tuple{typeof(LibSSH2_jll.__init__)})
precompile(Tuple{typeof(LibGit2_jll.__init__)})
precompile(Tuple{typeof(nghttp2_jll.__init__)})
precompile(Tuple{typeof(LibCURL_jll.__init__)})
precompile(Tuple{typeof(MozillaCACerts_jll.__init__)})
precompile(Tuple{typeof(Base.Filesystem.normpath), String, String, Vararg{String}})
precompile(Tuple{typeof(p7zip_jll.__init__)})
precompile(Tuple{typeof(p7zip_jll.init_p7zip_path)})
precompile(Tuple{typeof(Base.append!), Array{String, 1}, Array{String, 1}})
precompile(Tuple{typeof(Base.join), Array{String, 1}, Char})
julia +nightly --start=no --trace-compile=stderr -q -e "using Pkg"  1.48s user 0.40s system 206% cpu 0.910 total
```
PR
```
% time ./julia --start=no --trace-compile=stderr -q -e "using Pkg"
./julia --start=no --trace-compile=stderr -q -e "using Pkg"  1.62s user 0.13s system 402% cpu 0.433 total
```
---
 base/precompilation.jl                        | 23 +++---
 contrib/generate_precompile.jl                | 77 ++++++++++++++-----
 .../src/CompilerSupportLibraries_jll.jl       |  1 -
 stdlib/GMP_jll/src/GMP_jll.jl                 |  1 -
 stdlib/LLD_jll/src/LLD_jll.jl                 |  1 -
 .../src/LLVMLibUnwind_jll.jl                  |  1 -
 stdlib/LibCURL_jll/src/LibCURL_jll.jl         |  1 -
 stdlib/LibGit2_jll/src/LibGit2_jll.jl         |  1 -
 stdlib/LibSSH2_jll/src/LibSSH2_jll.jl         |  1 -
 stdlib/LibUV_jll/src/LibUV_jll.jl             |  1 -
 stdlib/LibUnwind_jll/src/LibUnwind_jll.jl     |  1 -
 stdlib/MPFR_jll/src/MPFR_jll.jl               |  1 -
 stdlib/MbedTLS_jll/src/MbedTLS_jll.jl         |  1 -
 .../src/MozillaCACerts_jll.jl                 |  1 -
 stdlib/OpenBLAS_jll/src/OpenBLAS_jll.jl       |  1 -
 stdlib/OpenLibm_jll/src/OpenLibm_jll.jl       |  1 -
 stdlib/PCRE2_jll/src/PCRE2_jll.jl             |  1 -
 stdlib/REPL/test/precompilation.jl            |  5 +-
 stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl |  1 -
 stdlib/Zlib_jll/src/Zlib_jll.jl               |  1 -
 stdlib/dSFMT_jll/src/dSFMT_jll.jl             |  1 -
 stdlib/libLLVM_jll/src/libLLVM_jll.jl         |  1 -
 .../src/libblastrampoline_jll.jl              |  1 -
 stdlib/nghttp2_jll/src/nghttp2_jll.jl         |  1 -
 stdlib/p7zip_jll/src/p7zip_jll.jl             |  1 -
 test/cmdlineargs.jl                           |  8 +-
 26 files changed, 77 insertions(+), 58 deletions(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index ce2be1f83f283..211fd61c2be33 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -354,12 +354,10 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                         _from_loading::Bool=false,
                         configs::Union{Config,Vector{Config}}=(``=>Base.CacheFlags()),
                         io::IO=stderr,
-                        flags_cacheflags=nothing)
+                        # asking for timing disables fancy mode, as timing is shown in non-fancy mode
+                        fancyprint::Bool = can_fancyprint(io) && !timing
+                    )
 
-    if flags_cacheflags !== nothing
-        # TODO: Remove `flags_cacheflags` once Pkg moves to the renamed kwarg `configs`
-        configs = flags_cacheflags
-    end
     configs = configs isa Config ? [configs] : configs
 
     time_start = time_ns()
@@ -374,9 +372,6 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     num_tasks = parse(Int, get(ENV, "JULIA_NUM_PRECOMPILE_TASKS", string(default_num_tasks)))
     parallel_limiter = Base.Semaphore(num_tasks)
 
-    # asking for timing disables fancy mode, as timing is shown in non-fancy mode
-    fancyprint = can_fancyprint(io) && !timing
-
     if _from_loading && !Sys.isinteractive() && Base.get_bool_env("JULIA_TESTS", false)
         # suppress passive loading printing in julia test suite. `JULIA_TESTS` is set in Base.runtests
         io = devnull
@@ -434,7 +429,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
         end
     end
 
-    @debug "precompile: deps collected" _group=:precompile
+    @debug "precompile: deps collected"
     # this loop must be run after the full depsmap has been populated
     for (pkg, pkg_exts) in pkg_exts_map
         # find any packages that depend on the extension(s)'s deps and replace those deps in their deps list with the extension(s),
@@ -446,7 +441,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
             end
         end
     end
-    @debug "precompile: extensions collected" _group=:precompile
+    @debug "precompile: extensions collected"
 
     # return early if no deps
     if isempty(depsmap)
@@ -474,7 +469,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
             was_recompiled[dep_config] = false
         end
     end
-    @debug "precompile: signalling initialized"  _group=:precompile
+    @debug "precompile: signalling initialized"
 
 
     # find and guard against circular deps
@@ -515,7 +510,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     if !isempty(circular_deps)
         @warn """Circular dependency detected. Precompilation will be skipped for:\n  $(join(string.(circular_deps), "\n  "))"""
     end
-    @debug "precompile: circular dep check done"  _group=:precompile
+    @debug "precompile: circular dep check done"
 
     # if a list of packages is given, restrict to dependencies of given packages
     if !isempty(pkgs)
@@ -562,7 +557,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     else
         target *= "..."
     end
-    @debug "precompile: packages filtered"  _group=:precompile
+    @debug "precompile: packages filtered"
 
     pkg_queue = PkgConfig[]
     failed_deps = Dict{PkgConfig, String}()
@@ -737,7 +732,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     if !_from_loading
         Base.LOADING_CACHE[] = Base.LoadingCache()
     end
-    @debug "precompile: starting precompilation loop"  _group=:precompile
+    @debug "precompile: starting precompilation loop" depsmap direct_deps
     ## precompilation loop
     for (pkg, deps) in depsmap
         cachepaths = Base.find_all_in_cache_path(pkg)
diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index 9e4e2d4485189..92dde676244e4 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -39,6 +39,17 @@ precompile(Base.unsafe_string, (Ptr{Int8},))
 # loading.jl
 precompile(Base.__require_prelocked, (Base.PkgId, Nothing))
 precompile(Base._require, (Base.PkgId, Nothing))
+precompile(Base.indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int))
+precompile(Base.indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int, Int))
+
+# Pkg loading
+precompile(Tuple{typeof(Base.Filesystem.normpath), String, String, Vararg{String}})
+precompile(Tuple{typeof(Base.append!), Array{String, 1}, Array{String, 1}})
+precompile(Tuple{typeof(Base.join), Array{String, 1}, Char})
+precompile(Tuple{typeof(Base.getindex), Base.Dict{Any, Any}, Char})
+precompile(Tuple{typeof(Base.delete!), Base.Set{Any}, Char})
+precompile(Tuple{typeof(Base.convert), Type{Base.Dict{String, Base.Dict{String, String}}}, Base.Dict{String, Any}})
+precompile(Tuple{typeof(Base.convert), Type{Base.Dict{String, Array{String, 1}}}, Base.Dict{String, Any}})
 
 # REPL
 precompile(isequal, (String, String))
@@ -67,6 +78,10 @@ precompile(Tuple{typeof(haskey), Dict{Base.PkgId,Vector{Function}}, Base.PkgId})
 precompile(Tuple{typeof(delete!), Dict{Base.PkgId,Vector{Function}}, Base.PkgId})
 precompile(Tuple{typeof(push!), Vector{Function}, Function})
 
+# preferences
+precompile(Base.get_preferences, (Base.UUID,))
+precompile(Base.record_compiletime_preference, (Base.UUID, String))
+
 # miscellaneous
 precompile(Tuple{typeof(Base.exit)})
 precompile(Tuple{typeof(Base.require), Base.PkgId})
@@ -84,6 +99,23 @@ precompile(Base.CoreLogging.current_logger_for_env, (Base.CoreLogging.LogLevel,
 precompile(Base.CoreLogging.env_override_minlevel, (Symbol, Module))
 precompile(Base.StackTraces.lookup, (Ptr{Nothing},))
 precompile(Tuple{typeof(Base.run_module_init), Module, Int})
+
+# precompilepkgs
+precompile(Tuple{typeof(Base.get), Type{Array{String, 1}}, Base.Dict{String, Any}, String})
+precompile(Tuple{typeof(Base.get), Type{Base.Dict{String, Any}}, Base.Dict{String, Any}, String})
+precompile(Tuple{typeof(Base.haskey), Base.Dict{String, Any}, String})
+precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.TTY, Bool}, Int, Int})
+precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.TTY, Bool}, Int})
+precompile(Tuple{typeof(Base.open), Base.CmdRedirect, String, Base.TTY})
+precompile(Tuple{typeof(Base.Precompilation.precompilepkgs)})
+precompile(Tuple{typeof(Base.Precompilation.printpkgstyle), Base.TTY, Symbol, String})
+precompile(Tuple{typeof(Base.rawhandle), Base.TTY})
+precompile(Tuple{typeof(Base.setindex!), Base.Dict{String, Array{String, 1}}, Array{String, 1}, String})
+precompile(Tuple{typeof(Base.setindex!), GenericMemory{:not_atomic, Union{Base.Libc.RawFD, Base.SyncCloseFD, IO}, Core.AddrSpace{Core}(0x00)}, Base.TTY, Int})
+precompile(Tuple{typeof(Base.setup_stdio), Base.TTY, Bool})
+precompile(Tuple{typeof(Base.spawn_opts_inherit), Base.DevNull, Base.TTY, Base.TTY})
+precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:context,), Tuple{Base.TTY}}, typeof(Base.sprint), Function})
+precompile(Tuple{Type{Base.UUID}, Base.UUID})
 """
 
 for T in (Float16, Float32, Float64), IO in (IOBuffer, IOContext{IOBuffer}, Base.TTY, IOContext{Base.TTY})
@@ -131,17 +163,17 @@ for match = Base._methods(+, (Int, Int), -1, Base.get_world_counter())
     push!(Expr[], Expr(:return, false))
     vcat(String[], String[])
     k, v = (:hello => nothing)
-    precompile(Base.indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int))
-    precompile(Base.indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int, Int))
+
     # Preferences uses these
-    precompile(Base.get_preferences, (Base.UUID,))
-    precompile(Base.record_compiletime_preference, (Base.UUID, String))
     get(Dict{String,Any}(), "missing", nothing)
     delete!(Dict{String,Any}(), "missing")
     for (k, v) in Dict{String,Any}()
         println(k)
     end
 
+    # interactive statup uses this
+    write(IOBuffer(), "")
+
     break   # only actually need to do this once
 end
 """
@@ -223,10 +255,10 @@ ansi_disablecursor = "\e[?25l"
 blackhole = Sys.isunix() ? "/dev/null" : "nul"
 procenv = Dict{String,Any}(
         "JULIA_HISTORY" => blackhole,
-        "JULIA_PROJECT" => nothing, # remove from environment
-        "JULIA_LOAD_PATH" => "@stdlib",
+        "JULIA_LOAD_PATH" => "@$(Sys.iswindows() ? ";" : ":")@stdlib",
         "JULIA_DEPOT_PATH" => Sys.iswindows() ? ";" : ":",
         "TERM" => "",
+        # "JULIA_DEBUG" => "precompilation",
         "JULIA_FALLBACK_REPL" => "true")
 
 generate_precompile_statements() = try # Make sure `ansi_enablecursor` is printed
@@ -263,24 +295,32 @@ generate_precompile_statements() = try # Make sure `ansi_enablecursor` is printe
         print_state("step1" => "R")
         # Also precompile a package here
         pkgname = "__PackagePrecompilationStatementModule"
-        mkpath(joinpath(prec_path, pkgname, "src"))
-        path = joinpath(prec_path, pkgname, "src", "$pkgname.jl")
-        write(path,
-              """
-              module $pkgname
-              end
-              """)
+        pkguuid = "824efdaf-a0e9-431c-8ee7-3d356b2531c2"
+        pkgpath = joinpath(prec_path, pkgname)
+        mkpath(joinpath(pkgpath, "src"))
+        write(joinpath(pkgpath, "src", "$pkgname.jl"),
+            """
+            module $pkgname
+            println("Precompiling $pkgname")
+            end
+            """)
+        write(joinpath(pkgpath, "Project.toml"),
+            """
+            name = "$pkgname"
+            uuid = "$pkguuid"
+            """)
+        touch(joinpath(pkgpath, "Manifest.toml"))
         tmp_prec = tempname(prec_path)
         tmp_proc = tempname(prec_path)
         s = """
-            pushfirst!(DEPOT_PATH, $(repr(prec_path)));
+            pushfirst!(DEPOT_PATH, $(repr(joinpath(prec_path,"depot"))));
             Base.PRECOMPILE_TRACE_COMPILE[] = $(repr(tmp_prec));
-            Base.compilecache(Base.PkgId($(repr(pkgname))), $(repr(path)))
+            Base.Precompilation.precompilepkgs(;fancyprint=true);
             $precompile_script
             """
         p = run(pipeline(addenv(`$(julia_exepath()) -O0 --trace-compile=$tmp_proc --sysimage $sysimg
-                --cpu-target=native --startup-file=no --color=yes`, procenv),
-                 stdin=IOBuffer(s), stdout=debug_output))
+                --cpu-target=native --startup-file=no --color=yes --project=$(pkgpath)`, procenv),
+                 stdin=IOBuffer(s), stderr=debug_output, stdout=debug_output))
         n_step1 = 0
         for f in (tmp_prec, tmp_proc)
             isfile(f) || continue
@@ -334,9 +374,8 @@ generate_precompile_statements() = try # Make sure `ansi_enablecursor` is printe
             yield() # Make clock spinning
             print_state("step3" => string("R$n_succeeded", failed > 0 ? " ($failed failed)" : ""))
         catch ex
-            @show backtrace()
             # See #28808
-            @warn "Failed to precompile expression" form=statement exception=ex _module=nothing _file=nothing _line=0
+            @warn "Failed to precompile expression" form=statement exception=(ex,catch_backtrace()) _module=nothing _file=nothing _line=0
         end
     end
     wait(clock) # Stop asynchronous printing
diff --git a/stdlib/CompilerSupportLibraries_jll/src/CompilerSupportLibraries_jll.jl b/stdlib/CompilerSupportLibraries_jll/src/CompilerSupportLibraries_jll.jl
index bd7a0571f9d5a..a57b275b1862d 100644
--- a/stdlib/CompilerSupportLibraries_jll/src/CompilerSupportLibraries_jll.jl
+++ b/stdlib/CompilerSupportLibraries_jll/src/CompilerSupportLibraries_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule CompilerSupportLibraries_jll
 using Base, Libdl, Base.BinaryPlatforms
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/GMP_jll/src/GMP_jll.jl b/stdlib/GMP_jll/src/GMP_jll.jl
index fde2fc15acf90..ae8b3c0b3e7d5 100644
--- a/stdlib/GMP_jll/src/GMP_jll.jl
+++ b/stdlib/GMP_jll/src/GMP_jll.jl
@@ -3,7 +3,6 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/GMP_jll.jl
 baremodule GMP_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/LLD_jll/src/LLD_jll.jl b/stdlib/LLD_jll/src/LLD_jll.jl
index 55ccec9cc4005..9b8365dddcf0b 100644
--- a/stdlib/LLD_jll/src/LLD_jll.jl
+++ b/stdlib/LLD_jll/src/LLD_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule LLD_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/LLVMLibUnwind_jll/src/LLVMLibUnwind_jll.jl b/stdlib/LLVMLibUnwind_jll/src/LLVMLibUnwind_jll.jl
index 5c4026291a673..429e35b91d3f2 100644
--- a/stdlib/LLVMLibUnwind_jll/src/LLVMLibUnwind_jll.jl
+++ b/stdlib/LLVMLibUnwind_jll/src/LLVMLibUnwind_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule LLVMLibUnwind_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/LibCURL_jll/src/LibCURL_jll.jl b/stdlib/LibCURL_jll/src/LibCURL_jll.jl
index cd67bfac0006a..3291c97d811cb 100644
--- a/stdlib/LibCURL_jll/src/LibCURL_jll.jl
+++ b/stdlib/LibCURL_jll/src/LibCURL_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule LibCURL_jll
 using Base, Libdl, nghttp2_jll
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/LibGit2_jll/src/LibGit2_jll.jl b/stdlib/LibGit2_jll/src/LibGit2_jll.jl
index ff625a6494a26..c24d3c20f428e 100644
--- a/stdlib/LibGit2_jll/src/LibGit2_jll.jl
+++ b/stdlib/LibGit2_jll/src/LibGit2_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule LibGit2_jll
 using Base, Libdl, MbedTLS_jll, LibSSH2_jll
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/LibSSH2_jll/src/LibSSH2_jll.jl b/stdlib/LibSSH2_jll/src/LibSSH2_jll.jl
index a809f7a912d6b..351cbe0e3729b 100644
--- a/stdlib/LibSSH2_jll/src/LibSSH2_jll.jl
+++ b/stdlib/LibSSH2_jll/src/LibSSH2_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule LibSSH2_jll
 using Base, Libdl, MbedTLS_jll
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/LibUV_jll/src/LibUV_jll.jl b/stdlib/LibUV_jll/src/LibUV_jll.jl
index 767f055eb019f..febc47f168ab9 100644
--- a/stdlib/LibUV_jll/src/LibUV_jll.jl
+++ b/stdlib/LibUV_jll/src/LibUV_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule LibUV_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 # NOTE: This file is currently empty, as we link libuv statically for now.
 
diff --git a/stdlib/LibUnwind_jll/src/LibUnwind_jll.jl b/stdlib/LibUnwind_jll/src/LibUnwind_jll.jl
index 12abeaf598151..f97b18443b6fd 100644
--- a/stdlib/LibUnwind_jll/src/LibUnwind_jll.jl
+++ b/stdlib/LibUnwind_jll/src/LibUnwind_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule LibUnwind_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/MPFR_jll/src/MPFR_jll.jl b/stdlib/MPFR_jll/src/MPFR_jll.jl
index c184a9801102f..219ab0cad41be 100644
--- a/stdlib/MPFR_jll/src/MPFR_jll.jl
+++ b/stdlib/MPFR_jll/src/MPFR_jll.jl
@@ -3,7 +3,6 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/MPFR_jll.jl
 baremodule MPFR_jll
 using Base, Libdl, GMP_jll
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/MbedTLS_jll/src/MbedTLS_jll.jl b/stdlib/MbedTLS_jll/src/MbedTLS_jll.jl
index e46da42a9a638..6367213e2c4ab 100644
--- a/stdlib/MbedTLS_jll/src/MbedTLS_jll.jl
+++ b/stdlib/MbedTLS_jll/src/MbedTLS_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule MbedTLS_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/MozillaCACerts_jll/src/MozillaCACerts_jll.jl b/stdlib/MozillaCACerts_jll/src/MozillaCACerts_jll.jl
index 244c1204563d5..1d5df0236ae9e 100644
--- a/stdlib/MozillaCACerts_jll/src/MozillaCACerts_jll.jl
+++ b/stdlib/MozillaCACerts_jll/src/MozillaCACerts_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule MozillaCACerts_jll
 using Base
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/OpenBLAS_jll/src/OpenBLAS_jll.jl b/stdlib/OpenBLAS_jll/src/OpenBLAS_jll.jl
index a0c11ab047142..2f151f63f4413 100644
--- a/stdlib/OpenBLAS_jll/src/OpenBLAS_jll.jl
+++ b/stdlib/OpenBLAS_jll/src/OpenBLAS_jll.jl
@@ -13,7 +13,6 @@ using Base, Libdl, Base.BinaryPlatforms
 # using CompilerSupportLibraries_jll
 # Because of this however, we have to manually load the libraries we
 # _do_ care about, namely libgfortran
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/OpenLibm_jll/src/OpenLibm_jll.jl b/stdlib/OpenLibm_jll/src/OpenLibm_jll.jl
index f2dee45a279cd..297cd25512894 100644
--- a/stdlib/OpenLibm_jll/src/OpenLibm_jll.jl
+++ b/stdlib/OpenLibm_jll/src/OpenLibm_jll.jl
@@ -3,7 +3,6 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/OpenLibm_jll.jl
 baremodule OpenLibm_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/PCRE2_jll/src/PCRE2_jll.jl b/stdlib/PCRE2_jll/src/PCRE2_jll.jl
index e7f685820830b..d825ac74db5a8 100644
--- a/stdlib/PCRE2_jll/src/PCRE2_jll.jl
+++ b/stdlib/PCRE2_jll/src/PCRE2_jll.jl
@@ -3,7 +3,6 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/PCRE2_jll.jl
 baremodule PCRE2_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/REPL/test/precompilation.jl b/stdlib/REPL/test/precompilation.jl
index 5021844a9d1a4..228cbd212a2c1 100644
--- a/stdlib/REPL/test/precompilation.jl
+++ b/stdlib/REPL/test/precompilation.jl
@@ -27,7 +27,10 @@ if !Sys.iswindows()
         tracecompile_out = read(f, String)
         close(ptm) # close after reading so we don't get precompiles from error shutdown
 
-        expected_precompiles = 2
+        # given this test checks that startup is snappy, it's best to add workloads to
+        # contrib/generate_precompile.jl rather than increase this number. But if that's not
+        # possible, it'd be helpful to add a comment with the statement and a reason below
+        expected_precompiles = 0
 
         n_precompiles = count(r"precompile\(", tracecompile_out)
 
diff --git a/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl b/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl
index 08614880a934c..e5edfa76997e1 100644
--- a/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl
+++ b/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl
@@ -3,7 +3,6 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/SuiteSparse_jll.jl
 baremodule SuiteSparse_jll
 using Base, Libdl, libblastrampoline_jll
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/Zlib_jll/src/Zlib_jll.jl b/stdlib/Zlib_jll/src/Zlib_jll.jl
index ea381b8b0683c..fb043c7143789 100644
--- a/stdlib/Zlib_jll/src/Zlib_jll.jl
+++ b/stdlib/Zlib_jll/src/Zlib_jll.jl
@@ -3,7 +3,6 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/Zlib_jll.jl
 baremodule Zlib_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/dSFMT_jll/src/dSFMT_jll.jl b/stdlib/dSFMT_jll/src/dSFMT_jll.jl
index 35ada23778a94..b84bf0d8204ae 100644
--- a/stdlib/dSFMT_jll/src/dSFMT_jll.jl
+++ b/stdlib/dSFMT_jll/src/dSFMT_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule dSFMT_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/libLLVM_jll/src/libLLVM_jll.jl b/stdlib/libLLVM_jll/src/libLLVM_jll.jl
index 3140dc3989a72..be2acb34faa65 100644
--- a/stdlib/libLLVM_jll/src/libLLVM_jll.jl
+++ b/stdlib/libLLVM_jll/src/libLLVM_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule libLLVM_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/libblastrampoline_jll/src/libblastrampoline_jll.jl b/stdlib/libblastrampoline_jll/src/libblastrampoline_jll.jl
index 49e7932a6b701..bbdad252be14a 100644
--- a/stdlib/libblastrampoline_jll/src/libblastrampoline_jll.jl
+++ b/stdlib/libblastrampoline_jll/src/libblastrampoline_jll.jl
@@ -4,7 +4,6 @@
 
 baremodule libblastrampoline_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/nghttp2_jll/src/nghttp2_jll.jl b/stdlib/nghttp2_jll/src/nghttp2_jll.jl
index 76e8d3582c402..5057299614aa5 100644
--- a/stdlib/nghttp2_jll/src/nghttp2_jll.jl
+++ b/stdlib/nghttp2_jll/src/nghttp2_jll.jl
@@ -3,7 +3,6 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/nghttp2_jll.jl
 baremodule nghttp2_jll
 using Base, Libdl
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/stdlib/p7zip_jll/src/p7zip_jll.jl b/stdlib/p7zip_jll/src/p7zip_jll.jl
index 01f26de936e78..a2a90a2450ea6 100644
--- a/stdlib/p7zip_jll/src/p7zip_jll.jl
+++ b/stdlib/p7zip_jll/src/p7zip_jll.jl
@@ -3,7 +3,6 @@
 ## dummy stub for https://github.com/JuliaBinaryWrappers/p7zip_jll.jl
 baremodule p7zip_jll
 using Base
-Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
 const LIBPATH_list = String[]
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 2418296ef2292..3fbfdd9bc1257 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -666,7 +666,9 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
                 code = code[3]
                 @test occursin("llvm.module.flags", code)
                 @test occursin("llvm.dbg.cu", code)
-                @test occursin("int.jl", code)
+                # TODO: consider moving test to llvmpasses as this fails on some platforms
+                # without clear reason
+                @test_skip occursin("int.jl", code)
                 @test !occursin("name: \"Int64\"", code)
             end
             let code = readchomperrors(`$exename -g2 -E "@eval Int64(1)+Int64(1)"`)
@@ -674,7 +676,9 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
                 code = code[3]
                 @test occursin("llvm.module.flags", code)
                 @test occursin("llvm.dbg.cu", code)
-                @test occursin("int.jl", code)
+                # TODO: consider moving test to llvmpasses as this fails on some platforms
+                # without clear reason
+                @test_skip occursin("int.jl", code)
                 @test occursin("name: \"Int64\"", code)
             end
         end

From cb47b01d3eff8da054384bc0c293db8f9f8b2783 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 14 Mar 2024 10:51:10 -0400
Subject: [PATCH 1134/1315] codegen: change tbaa of ptr_phi to tbaa_value
 (#53655)

Fixes https://github.com/JuliaLang/julia/issues/53612
---
 src/codegen.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/codegen.cpp b/src/codegen.cpp
index eaa9335659fb1..d4ce52b4dc1d0 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -5634,7 +5634,7 @@ static void emit_phinode_assign(jl_codectx_t &ctx, ssize_t idx, jl_value_t *r)
             Value *ptr = ctx.builder.CreateSelect(isboxed,
                 maybe_bitcast(ctx, decay_derived(ctx, ptr_phi), getInt8PtrTy(ctx.builder.getContext())),
                 maybe_bitcast(ctx, decay_derived(ctx, phi), getInt8PtrTy(ctx.builder.getContext())));
-            jl_cgval_t val = mark_julia_slot(ptr, phiType, Tindex_phi, ctx.tbaa().tbaa_stack); // XXX: this TBAA is wrong for ptr_phi
+            jl_cgval_t val = mark_julia_slot(ptr, phiType, Tindex_phi, best_tbaa(ctx.tbaa(), phiType));
             val.Vboxed = ptr_phi;
             ctx.PhiNodes.push_back(std::make_tuple(val, BB, dest, ptr_phi, r));
             ctx.SAvalues[idx] = val;

From 0f04b33e01d3139ea103d9153dc442418c206b8a Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 14 Mar 2024 15:30:40 -0400
Subject: [PATCH 1135/1315] Default to the medium code model in x86 linux
 (#53391)

This shouldn't have any cost on smaller images because the only thing
that gets put into ldata is the system image data, which is only
reference via `dlsym`. This allows for images larger than 2gb (tested by
putting a 2gb array in the base image)

I did not test how this might be handled in other platforms (Windows
doesn't support it).
---
 src/aotcompile.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 11c2578f701f0..880d193ea157c 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -4,6 +4,7 @@
 #include "platform.h"
 
 // target support
+#include "llvm/Support/CodeGen.h"
 #include <llvm/ADT/Triple.h>
 #include <llvm/ADT/Statistic.h>
 #include <llvm/Analysis/TargetLibraryInfo.h>
@@ -1607,10 +1608,11 @@ void jl_dump_native_impl(void *native_code,
     if (TheTriple.isOSLinux() || TheTriple.isOSFreeBSD()) {
         RelocModel = Reloc::PIC_;
     }
+
     CodeModel::Model CMModel = CodeModel::Small;
-    if (TheTriple.isPPC()) {
-        // On PPC the small model is limited to 16bit offsets
-        CMModel = CodeModel::Medium;
+    if (TheTriple.isPPC() || (TheTriple.isX86() && TheTriple.isArch64Bit() && TheTriple.isOSLinux())) {
+        // On PPC the small model is limited to 16bit offsets. For very large images the small code model
+        CMModel = CodeModel::Medium; //  isn't good enough on x86 so use Medium, it has no cost because only the image goes in .ldata
     }
     std::unique_ptr<TargetMachine> SourceTM(
         jl_ExecutionEngine->getTarget().createTargetMachine(
@@ -1653,6 +1655,12 @@ void jl_dump_native_impl(void *native_code,
                                      GlobalVariable::ExternalLinkage,
                                      data, "jl_system_image_data");
         sysdata->setAlignment(Align(64));
+#if JL_LLVM_VERSION >= 180000
+        sysdata->setCodeModel(CodeModel::Large);
+#else
+        if (TheTriple.isX86() && TheTriple.isArch64Bit() && TheTriple.isOSLinux())
+            sysdata->setSection(".ldata");
+#endif
         addComdat(sysdata, TheTriple);
         Constant *len = ConstantInt::get(sysimgM.getDataLayout().getIntPtrType(Context), z->size);
         addComdat(new GlobalVariable(sysimgM, len->getType(), true,

From b730d33228faaa055de3c05b0bee5d8d2059d714 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 15 Mar 2024 09:39:56 +0900
Subject: [PATCH 1136/1315] inlining: bail out unless `match.spec_types <:
 match.method.sig` (#53720)

As Jameson pointed out in the link below, while the union-split handles
cases when there are uncovered matches, sometimes the expected condition
`spec_types <: method.sig` that the union-split algorithm relies on
isn't met in such cases, which caused issues like #52644. This commit
fixes the problem by adding explicit checks for such cases. Note that
this is based on #52092. The extra handling for single method match
unmatched static parameters based on `only_method` that was removed in
JuliaLang/#52092 has been ineffective and would otherwise cause
problematic inlining on this PR. We'll likely need to come back to this
later and figure out a safe and effective way to deal with such cases in
the future when the handling for either case turns out to be necessary.

- closes #52644
- xref:
<https://github.com/JuliaLang/julia/pull/53600#pullrequestreview-1917272781>
---
 base/compiler/ssair/inlining.jl | 44 ++++++++++++++++++---------------
 test/compiler/inline.jl         | 21 ++++++++++++++++
 2 files changed, 45 insertions(+), 20 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 4f48c30824155..164102758a88f 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -542,11 +542,11 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int, argexprs::
         @assert nparams == fieldcount(mtype)
         if !(i == ncases && fully_covered)
             for i = 1:nparams
-                a, m = fieldtype(atype, i), fieldtype(mtype, i)
+                aft, mft = fieldtype(atype, i), fieldtype(mtype, i)
                 # If this is always true, we don't need to check for it
-                a <: m && continue
+                aft <: mft && continue
                 # Generate isa check
-                isa_expr = Expr(:call, isa, argexprs[i], m)
+                isa_expr = Expr(:call, isa, argexprs[i], mft)
                 ssa = insert_node_here!(compact, NewInstruction(isa_expr, Bool, line))
                 if cond === true
                     cond = ssa
@@ -565,10 +565,10 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int, argexprs::
             for i = 1:nparams
                 argex = argexprs[i]
                 (isa(argex, SSAValue) || isa(argex, Argument)) || continue
-                a, m = fieldtype(atype, i), fieldtype(mtype, i)
-                if !(a <: m)
+                aft, mft = fieldtype(atype, i), fieldtype(mtype, i)
+                if !(aft <: mft)
                     argexprs′[i] = insert_node_here!(compact,
-                        NewInstruction(PiNode(argex, m), m, line))
+                        NewInstruction(PiNode(argex, mft), mft, line))
                 end
             end
         end
@@ -944,7 +944,8 @@ function analyze_method!(match::MethodMatch, argtypes::Vector{Any},
     if !match.fully_covers
         # type-intersection was not able to give us a simple list of types, so
         # ir_inline_unionsplit won't be able to deal with inlining this
-        if !(spec_types isa DataType && length(spec_types.parameters) == length(argtypes) && !isvarargtype(spec_types.parameters[end]))
+        if !(spec_types isa DataType && length(spec_types.parameters) == npassedargs &&
+             !isvarargtype(spec_types.parameters[end]))
             return nothing
         end
     end
@@ -1355,16 +1356,18 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
             joint_effects = merge_effects(joint_effects, info_effects(result, match, state))
             split_fully_covered |= match.fully_covers
             if !validate_sparams(match.sparams)
-                if !match.fully_covers
-                    handled_all_cases = false
-                    continue
-                end
-                if revisit_idx === nothing
-                    revisit_idx = (i, j, all_result_count)
+                if match.fully_covers
+                    if revisit_idx === nothing
+                        revisit_idx = (i, j, all_result_count)
+                    else
+                        handled_all_cases = false
+                        revisit_idx = nothing
+                    end
                 else
                     handled_all_cases = false
-                    revisit_idx = nothing
                 end
+            elseif !(match.spec_types <: match.method.sig) # the requirement for correct union-split
+                handled_all_cases = false
             else
                 handled_all_cases &= handle_any_const_result!(cases,
                     result, match, argtypes, info, flag, state; allow_abstract=true, allow_typevars=false)
@@ -1399,14 +1402,15 @@ function handle_call!(todo::Vector{Pair{Int,Any}},
     cases = compute_inlining_cases(info, flag, sig, state)
     cases === nothing && return nothing
     cases, all_covered, joint_effects = cases
-    handle_cases!(todo, ir, idx, stmt, argtypes_to_type(sig.argtypes), cases,
-        all_covered, joint_effects)
+    atype = argtypes_to_type(sig.argtypes)
+    handle_cases!(todo, ir, idx, stmt, atype, cases, all_covered, joint_effects)
 end
 
 function handle_match!(cases::Vector{InliningCase},
     match::MethodMatch, argtypes::Vector{Any}, @nospecialize(info::CallInfo), flag::UInt32,
     state::InliningState;
-    allow_abstract::Bool, allow_typevars::Bool, volatile_inf_result::Union{Nothing,VolatileInferenceResult})
+    allow_abstract::Bool, allow_typevars::Bool,
+    volatile_inf_result::Union{Nothing,VolatileInferenceResult})
     spec_types = match.spec_types
     allow_abstract || isdispatchtuple(spec_types) || return false
     # We may see duplicated dispatch signatures here when a signature gets widened
@@ -1493,19 +1497,19 @@ function concrete_result_item(result::ConcreteResult, @nospecialize(info::CallIn
 end
 
 function handle_cases!(todo::Vector{Pair{Int,Any}}, ir::IRCode, idx::Int, stmt::Expr,
-    @nospecialize(atype), cases::Vector{InliningCase}, fully_covered::Bool,
+    @nospecialize(atype), cases::Vector{InliningCase}, all_covered::Bool,
     joint_effects::Effects)
     # If we only have one case and that case is fully covered, we may either
     # be able to do the inlining now (for constant cases), or push it directly
     # onto the todo list
-    if fully_covered && length(cases) == 1
+    if all_covered && length(cases) == 1
         handle_single_case!(todo, ir, idx, stmt, cases[1].item)
     elseif length(cases) > 0
         isa(atype, DataType) || return nothing
         for case in cases
             isa(case.sig, DataType) || return nothing
         end
-        push!(todo, idx=>UnionSplit(fully_covered, atype, cases))
+        push!(todo, idx=>UnionSplit(all_covered, atype, cases))
     else
         add_flag!(ir[SSAValue(idx)], flags_for_effects(joint_effects))
     end
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 3e48d91ba880d..2f916c375218a 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -2159,3 +2159,24 @@ end
 @test !Core.Compiler.is_nothrow(Base.infer_effects(issue53062, (Bool,)))
 @test issue53062(false) == -1
 @test_throws MethodError issue53062(true)
+
+struct Issue52644
+    tuple::Type{<:Tuple}
+end
+issue52644(::DataType) = :DataType
+issue52644(::UnionAll) = :UnionAll
+let ir = Base.code_ircode((Issue52644,); optimize_until="Inlining") do t
+        issue52644(t.tuple)
+    end |> only |> first
+    irfunc = Core.OpaqueClosure(ir)
+    @test irfunc(Issue52644(Tuple{})) === :DataType
+    @test irfunc(Issue52644(Tuple{<:Integer})) === :UnionAll
+end
+issue52644_single(x::DataType) = :DataType
+let ir = Base.code_ircode((Issue52644,); optimize_until="Inlining") do t
+        issue52644_single(t.tuple)
+    end |> only |> first
+    irfunc = Core.OpaqueClosure(ir)
+    @test irfunc(Issue52644(Tuple{})) === :DataType
+    @test_throws MethodError irfunc(Issue52644(Tuple{<:Integer}))
+end

From 3c4af03cf2c69fbd695daab05f1ba595856100cb Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 15 Mar 2024 09:43:19 +0900
Subject: [PATCH 1137/1315] enhance the effectiveness of the test cases
 introduced in #53300 (#53478)

While experimenting with precompilation for external absints on builds
just after #53300 was merged, I found that the test case for
`CustomAbstractInterpreterCaching2.jl` fails if the test case for
`CustomAbstractInterpreterCaching1.jl` isn't run in the same session
beforehand. That is probably because of the previous lack of support for
proper `CodeInstance` caching. To address this, I've changed the tests
to run in separate processes in this commit. Note that it appears that a
recent refactor concerning `CodeInstance` might have resolved this
issue, so the new test cases runs successfully on master. However, I
suspect the fix hasn't been applied to v1.11 yet, we would need more
research.
---
 test/precompile.jl         | 189 ++-----------------------------------
 test/precompile_absint1.jl |  73 ++++++++++++++
 test/precompile_absint2.jl |  96 +++++++++++++++++++
 test/precompile_utils.jl   |  41 ++++++++
 4 files changed, 217 insertions(+), 182 deletions(-)
 create mode 100644 test/precompile_absint1.jl
 create mode 100644 test/precompile_absint2.jl
 create mode 100644 test/precompile_utils.jl

diff --git a/test/precompile.jl b/test/precompile.jl
index 3aa48552b8f66..5994ee44beb0c 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1,11 +1,10 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-original_depot_path = copy(Base.DEPOT_PATH)
-original_load_path = copy(Base.LOAD_PATH)
-
 using Test, Distributed, Random, Logging
 using REPL # doc lookup function
 
+include("precompile_utils.jl")
+
 Foo_module = :Foo4b3a94a1a081a8cb
 Foo2_module = :F2oo4b3a94a1a081a8cb
 FooBase_module = :FooBase4b3a94a1a081a8cb
@@ -16,37 +15,6 @@ FooBase_module = :FooBase4b3a94a1a081a8cb
 end
 using .ConflictingBindings
 
-function precompile_test_harness(@nospecialize(f), testset::String)
-    @testset "$testset" begin
-        precompile_test_harness(f, true)
-    end
-end
-function precompile_test_harness(@nospecialize(f), separate::Bool)
-    load_path = mktempdir()
-    load_cache_path = separate ? mktempdir() : load_path
-    try
-        pushfirst!(LOAD_PATH, load_path)
-        pushfirst!(DEPOT_PATH, load_cache_path)
-        f(load_path)
-    finally
-        try
-            rm(load_path, force=true, recursive=true)
-        catch err
-            @show err
-        end
-        if separate
-            try
-                rm(load_cache_path, force=true, recursive=true)
-            catch err
-                @show err
-            end
-        end
-        filter!((≠)(load_path), LOAD_PATH)
-        separate && filter!((≠)(load_cache_path), DEPOT_PATH)
-    end
-    nothing
-end
-
 # method root provenance
 
 rootid(m::Module) = Base.module_build_id(Base.parentmodule(m)) % UInt64
@@ -1713,150 +1681,10 @@ precompile_test_harness("issue #46296") do load_path
     (@eval (using CodeInstancePrecompile))
 end
 
-let newinterp_path = abspath("compiler/newinterp.jl")
-    precompile_test_harness("AbstractInterpreter caching") do load_path
-        write(joinpath(load_path, "SimpleModule.jl"), :(module SimpleModule
-            basic_callee(x) = x
-            basic_caller(x) = basic_callee(x)
-        end) |> string)
-
-        write(joinpath(load_path, "CustomAbstractInterpreterCaching.jl"), :(module CustomAbstractInterpreterCaching
-            import SimpleModule: basic_caller, basic_callee
-
-            module Custom
-                include("$($newinterp_path)")
-                @newinterp PrecompileInterpreter
-            end
-
-            Base.return_types((Float64,)) do x
-                basic_caller(x)
-            end
-            Base.return_types((Float64,); interp=Custom.PrecompileInterpreter()) do x
-                basic_caller(x)
-            end
-            Base.return_types((Vector{Float64},)) do x
-                sum(x)
-            end
-            Base.return_types((Vector{Float64},); interp=Custom.PrecompileInterpreter()) do x
-                sum(x)
-            end
-        end) |> string)
-        Base.compilecache(Base.PkgId("CustomAbstractInterpreterCaching"))
-        @eval let
-            using CustomAbstractInterpreterCaching
-            cache_owner = Core.Compiler.cache_owner(
-                CustomAbstractInterpreterCaching.Custom.PrecompileInterpreter())
-            let m = only(methods(CustomAbstractInterpreterCaching.basic_callee))
-                mi = only(Base.specializations(m))
-                ci = mi.cache
-                @test isdefined(ci, :next)
-                @test ci.owner === nothing
-                @test ci.max_world == typemax(UInt)
-                ci = ci.next
-                @test !isdefined(ci, :next)
-                @test ci.owner === cache_owner
-                @test ci.max_world == typemax(UInt)
-            end
-            let m = only(methods(sum, (Vector{Float64},)))
-                found = false
-                for mi in Base.specializations(m)
-                    if mi isa Core.MethodInstance && mi.specTypes == Tuple{typeof(sum),Vector{Float64}}
-                        ci = mi.cache
-                        @test isdefined(ci, :next)
-                        @test ci.owner === cache_owner
-                        @test ci.max_world == typemax(UInt)
-                        ci = ci.next
-                        @test !isdefined(ci, :next)
-                        @test ci.owner === nothing
-                        @test ci.max_world == typemax(UInt)
-                        found = true
-                        break
-                    end
-                end
-                @test found
-            end
-        end
-
-        write(joinpath(load_path, "CustomAbstractInterpreterCaching2.jl"), :(module CustomAbstractInterpreterCaching2
-            import SimpleModule: basic_caller, basic_callee
-
-            module Custom
-                const CC = Core.Compiler
-                include("$($newinterp_path)")
-                @newinterp PrecompileInterpreter
-                struct CustomData
-                    inferred
-                    CustomData(@nospecialize inferred) = new(inferred)
-                end
-                function CC.transform_result_for_cache(interp::PrecompileInterpreter,
-                        mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
-                    inferred_result = @invoke CC.transform_result_for_cache(interp::CC.AbstractInterpreter,
-                        mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
-                    return CustomData(inferred_result)
-                end
-                function CC.src_inlining_policy(interp::PrecompileInterpreter, @nospecialize(src),
-                                            @nospecialize(info::CC.CallInfo), stmt_flag::UInt32)
-                    if src isa CustomData
-                        src = src.inferred
-                    end
-                    return @invoke CC.src_inlining_policy(interp::CC.AbstractInterpreter, src::Any,
-                                                          info::CC.CallInfo, stmt_flag::UInt32)
-                end
-                CC.retrieve_ir_for_inlining(cached_result::Core.CodeInstance, src::CustomData) =
-                    CC.retrieve_ir_for_inlining(cached_result, src.inferred)
-                CC.retrieve_ir_for_inlining(mi::Core.MethodInstance, src::CustomData, preserve_local_sources::Bool) =
-                    CC.retrieve_ir_for_inlining(mi, src.inferred, preserve_local_sources)
-            end
-
-            Base.return_types((Float64,)) do x
-                basic_caller(x)
-            end
-            Base.return_types((Float64,); interp=Custom.PrecompileInterpreter()) do x
-                basic_caller(x)
-            end
-            Base.return_types((Vector{Float64},)) do x
-                sum(x)
-            end
-            Base.return_types((Vector{Float64},); interp=Custom.PrecompileInterpreter()) do x
-                sum(x)
-            end
-        end) |> string)
-        Base.compilecache(Base.PkgId("CustomAbstractInterpreterCaching2"))
-        @eval let
-            using CustomAbstractInterpreterCaching2
-            cache_owner = Core.Compiler.cache_owner(
-                CustomAbstractInterpreterCaching2.Custom.PrecompileInterpreter())
-            let m = only(methods(CustomAbstractInterpreterCaching2.basic_callee))
-                mi = only(Base.specializations(m))
-                ci = mi.cache
-                @test isdefined(ci, :next)
-                @test ci.owner === nothing
-                @test ci.max_world == typemax(UInt)
-                ci = ci.next
-                @test !isdefined(ci, :next)
-                @test ci.owner === cache_owner
-                @test ci.max_world == typemax(UInt)
-            end
-            let m = only(methods(sum, (Vector{Float64},)))
-                found = false
-                for mi = Base.specializations(m)
-                    if mi isa Core.MethodInstance && mi.specTypes == Tuple{typeof(sum),Vector{Float64}}
-                        ci = mi.cache
-                        @test isdefined(ci, :next)
-                        @test ci.owner === cache_owner
-                        @test ci.max_world == typemax(UInt)
-                        ci = ci.next
-                        @test !isdefined(ci, :next)
-                        @test ci.owner === nothing
-                        @test ci.max_world == typemax(UInt)
-                        found = true
-                        break
-                    end
-                end
-                @test found
-            end
-        end
-    end
+@testset "Precompile external abstract interpreter" begin
+    dir = @__DIR__
+    @test success(pipeline(Cmd(`$(Base.julia_cmd()) precompile_absint1.jl`; dir); stdout, stderr))
+    @test success(pipeline(Cmd(`$(Base.julia_cmd()) precompile_absint2.jl`; dir); stdout, stderr))
 end
 
 precompile_test_harness("Recursive types") do load_path
@@ -2098,7 +1926,4 @@ precompile_test_harness("Test flags") do load_path
     @test !Base.isprecompiled(id, ;flags=current_flags)
 end
 
-empty!(Base.DEPOT_PATH)
-append!(Base.DEPOT_PATH, original_depot_path)
-empty!(Base.LOAD_PATH)
-append!(Base.LOAD_PATH, original_load_path)
+finish_precompile_test!()
diff --git a/test/precompile_absint1.jl b/test/precompile_absint1.jl
new file mode 100644
index 0000000000000..f47b26bce9d94
--- /dev/null
+++ b/test/precompile_absint1.jl
@@ -0,0 +1,73 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+using Test
+
+include("precompile_utils.jl")
+
+precompile_test_harness() do load_path
+    write(joinpath(load_path, "SimpleModule.jl"), :(module SimpleModule
+        basic_callee(x) = x
+        basic_caller(x) = basic_callee(x)
+    end) |> string)
+
+    newinterp_path = abspath("compiler/newinterp.jl")
+    write(joinpath(load_path, "TestAbsIntPrecompile1.jl"), :(module TestAbsIntPrecompile1
+        import SimpleModule: basic_caller, basic_callee
+
+        module Custom
+            include("$($newinterp_path)")
+            @newinterp PrecompileInterpreter
+        end
+
+        Base.return_types((Float64,)) do x
+            basic_caller(x)
+        end
+        Base.return_types((Float64,); interp=Custom.PrecompileInterpreter()) do x
+            basic_caller(x)
+        end
+        Base.return_types((Vector{Float64},)) do x
+            sum(x)
+        end
+        Base.return_types((Vector{Float64},); interp=Custom.PrecompileInterpreter()) do x
+            sum(x)
+        end
+    end) |> string)
+    Base.compilecache(Base.PkgId("TestAbsIntPrecompile1"))
+
+    @eval let
+        using TestAbsIntPrecompile1
+        cache_owner = Core.Compiler.cache_owner(
+            TestAbsIntPrecompile1.Custom.PrecompileInterpreter())
+        let m = only(methods(TestAbsIntPrecompile1.basic_callee))
+            mi = only(Base.specializations(m))
+            ci = mi.cache
+            @test isdefined(ci, :next)
+            @test ci.owner === nothing
+            @test ci.max_world == typemax(UInt)
+            ci = ci.next
+            @test !isdefined(ci, :next)
+            @test ci.owner === cache_owner
+            @test ci.max_world == typemax(UInt)
+        end
+        let m = only(methods(sum, (Vector{Float64},)))
+            found = false
+            for mi in Base.specializations(m)
+                if mi isa Core.MethodInstance && mi.specTypes == Tuple{typeof(sum),Vector{Float64}}
+                    ci = mi.cache
+                    @test isdefined(ci, :next)
+                    @test ci.owner === cache_owner
+                    @test ci.max_world == typemax(UInt)
+                    ci = ci.next
+                    @test !isdefined(ci, :next)
+                    @test ci.owner === nothing
+                    @test ci.max_world == typemax(UInt)
+                    found = true
+                    break
+                end
+            end
+            @test found
+        end
+    end
+end
+
+finish_precompile_test!()
diff --git a/test/precompile_absint2.jl b/test/precompile_absint2.jl
new file mode 100644
index 0000000000000..a7bf01debe861
--- /dev/null
+++ b/test/precompile_absint2.jl
@@ -0,0 +1,96 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+using Test
+
+include("precompile_utils.jl")
+
+precompile_test_harness() do load_path
+    write(joinpath(load_path, "SimpleModule.jl"), :(module SimpleModule
+        basic_callee(x) = x
+        basic_caller(x) = basic_callee(x)
+    end) |> string)
+
+    newinterp_path = abspath("compiler/newinterp.jl")
+    write(joinpath(load_path, "TestAbsIntPrecompile2.jl"), :(module TestAbsIntPrecompile2
+        import SimpleModule: basic_caller, basic_callee
+
+        module Custom
+            const CC = Core.Compiler
+            include("$($newinterp_path)")
+            @newinterp PrecompileInterpreter
+            struct CustomData
+                inferred
+                CustomData(@nospecialize inferred) = new(inferred)
+            end
+            function CC.transform_result_for_cache(interp::PrecompileInterpreter,
+                    mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
+                inferred_result = @invoke CC.transform_result_for_cache(interp::CC.AbstractInterpreter,
+                    mi::Core.MethodInstance, valid_worlds::CC.WorldRange, result::CC.InferenceResult)
+                return CustomData(inferred_result)
+            end
+            function CC.src_inlining_policy(interp::PrecompileInterpreter, @nospecialize(src),
+                                            @nospecialize(info::CC.CallInfo), stmt_flag::UInt32)
+                if src isa CustomData
+                    src = src.inferred
+                end
+                return @invoke CC.src_inlining_policy(interp::CC.AbstractInterpreter, src::Any,
+                                                      info::CC.CallInfo, stmt_flag::UInt32)
+            end
+            CC.retrieve_ir_for_inlining(cached_result::Core.CodeInstance, src::CustomData) =
+                CC.retrieve_ir_for_inlining(cached_result, src.inferred)
+            CC.retrieve_ir_for_inlining(mi::Core.MethodInstance, src::CustomData, preserve_local_sources::Bool) =
+                CC.retrieve_ir_for_inlining(mi, src.inferred, preserve_local_sources)
+        end
+
+        Base.return_types((Float64,)) do x
+            basic_caller(x)
+        end
+        Base.return_types((Float64,); interp=Custom.PrecompileInterpreter()) do x
+            basic_caller(x)
+        end
+        Base.return_types((Vector{Float64},)) do x
+            sum(x)
+        end
+        Base.return_types((Vector{Float64},); interp=Custom.PrecompileInterpreter()) do x
+            sum(x)
+        end
+    end) |> string)
+    Base.compilecache(Base.PkgId("TestAbsIntPrecompile2"))
+
+    @eval let
+        using TestAbsIntPrecompile2
+        cache_owner = Core.Compiler.cache_owner(
+            TestAbsIntPrecompile2.Custom.PrecompileInterpreter())
+        let m = only(methods(TestAbsIntPrecompile2.basic_callee))
+            mi = only(Base.specializations(m))
+            ci = mi.cache
+            @test isdefined(ci, :next)
+            @test ci.owner === nothing
+            @test ci.max_world == typemax(UInt)
+            ci = ci.next
+            @test !isdefined(ci, :next)
+            @test ci.owner === cache_owner
+            @test ci.max_world == typemax(UInt)
+        end
+        let m = only(methods(sum, (Vector{Float64},)))
+            found = false
+            for mi = Base.specializations(m)
+                if mi isa Core.MethodInstance && mi.specTypes == Tuple{typeof(sum),Vector{Float64}}
+                    ci = mi.cache
+                    @test isdefined(ci, :next)
+                    @test ci.owner === cache_owner
+                    @test ci.max_world == typemax(UInt)
+                    ci = ci.next
+                    @test !isdefined(ci, :next)
+                    @test ci.owner === nothing
+                    @test ci.max_world == typemax(UInt)
+                    found = true
+                    break
+                end
+            end
+            @test found
+        end
+    end
+end
+
+finish_precompile_test!()
diff --git a/test/precompile_utils.jl b/test/precompile_utils.jl
new file mode 100644
index 0000000000000..55eba353f2ada
--- /dev/null
+++ b/test/precompile_utils.jl
@@ -0,0 +1,41 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+function precompile_test_harness(@nospecialize(f), testset::String)
+    @testset "$testset" precompile_test_harness(f, true)
+end
+function precompile_test_harness(@nospecialize(f), separate::Bool=true)
+    load_path = mktempdir()
+    load_cache_path = separate ? mktempdir() : load_path
+    try
+        pushfirst!(LOAD_PATH, load_path)
+        pushfirst!(DEPOT_PATH, load_cache_path)
+        f(load_path)
+    finally
+        try
+            rm(load_path, force=true, recursive=true)
+        catch err
+            @show err
+        end
+        if separate
+            try
+                rm(load_cache_path, force=true, recursive=true)
+            catch err
+                @show err
+            end
+        end
+        filter!((≠)(load_path), LOAD_PATH)
+        separate && filter!((≠)(load_cache_path), DEPOT_PATH)
+    end
+    return nothing
+end
+
+let original_depot_path = copy(Base.DEPOT_PATH)
+    original_load_path = copy(Base.LOAD_PATH)
+
+    global function finish_precompile_test!()
+        empty!(Base.DEPOT_PATH)
+        append!(Base.DEPOT_PATH, original_depot_path)
+        empty!(Base.LOAD_PATH)
+        append!(Base.LOAD_PATH, original_load_path)
+    end
+end

From 67cdb9bf70a39e62992276cb3923e928c2e8b637 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 14 Mar 2024 22:17:44 -0400
Subject: [PATCH 1138/1315] Enable analyzegc checks for try catch and fix found
 issues (#53527)

This PR also makes a successful `JL_TRY` not do so much work + fixes
clang not finding the sdk when running those tests in macos.

Fixes https://github.com/JuliaLang/julia/issues/
Co-authored-by: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 Make.inc                                     |  2 +-
 base/stream.jl                               | 12 ++-
 doc/src/devdocs/ast.md                       |  2 +-
 src/ast.c                                    |  4 +-
 src/ccall.cpp                                |  2 +-
 src/codegen.cpp                              | 94 ++++++++++++++------
 src/gc.c                                     |  2 +-
 src/gf.c                                     |  4 +-
 src/init.c                                   |  6 +-
 src/interpreter.c                            | 12 +--
 src/jl_exported_funcs.inc                    |  2 +
 src/jlapi.c                                  | 28 +++---
 src/jloptions.c                              |  3 +-
 src/jltypes.c                                |  2 +-
 src/julia.h                                  | 74 ++++++++-------
 src/julia_internal.h                         |  2 +-
 src/llvm-codegen-shared.h                    |  2 +-
 src/llvm-late-gc-lowering.cpp                |  2 +-
 src/llvm-lower-handlers.cpp                  | 34 +++----
 src/llvm-pass-helpers.cpp                    |  3 +-
 src/llvm-pass-helpers.h                      |  1 +
 src/method.c                                 | 11 ++-
 src/rtutils.c                                | 42 +++++----
 src/scheduler.c                              |  2 +-
 src/signals-mach.c                           |  6 +-
 src/task.c                                   | 27 +++---
 src/toplevel.c                               |  4 +-
 test/Makefile                                |  1 +
 test/llvmpasses/Makefile                     |  5 +-
 test/llvmpasses/lower-handlers-addrspaces.ll |  8 +-
 test/llvmpasses/lower-handlers.ll            |  8 +-
 31 files changed, 241 insertions(+), 166 deletions(-)

diff --git a/Make.inc b/Make.inc
index 5d58454c80333..2a23bd3d37b51 100644
--- a/Make.inc
+++ b/Make.inc
@@ -1487,7 +1487,7 @@ endif
 CLANGSA_FLAGS :=
 CLANGSA_CXXFLAGS :=
 ifeq ($(OS), Darwin) # on new XCode, the files are hidden
-CLANGSA_FLAGS += -isysroot $(shell xcode-select -p)/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk
+ CLANGSA_FLAGS += -isysroot $(shell xcrun --show-sdk-path -sdk macosx)
 endif
 ifeq ($(USEGCC),1)
 # try to help clang find the c++ files for CC by guessing the value for --prefix
diff --git a/base/stream.jl b/base/stream.jl
index feb5ad777fc11..e80d27c837802 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -453,9 +453,11 @@ function closewrite(s::LibuvStream)
     sigatomic_begin()
     uv_req_set_data(req, ct)
     iolock_end()
-    status = try
+    local status
+    try
         sigatomic_end()
-        wait()::Cint
+        status = wait()::Cint
+        sigatomic_begin()
     finally
         # try-finally unwinds the sigatomic level, so need to repeat sigatomic_end
         sigatomic_end()
@@ -1062,12 +1064,14 @@ function uv_write(s::LibuvStream, p::Ptr{UInt8}, n::UInt)
     sigatomic_begin()
     uv_req_set_data(uvw, ct)
     iolock_end()
-    status = try
+    local status
+    try
         sigatomic_end()
         # wait for the last chunk to complete (or error)
         # assume that any errors would be sticky,
         # (so we don't need to monitor the error status of the intermediate writes)
-        wait()::Cint
+        status = wait()::Cint
+        sigatomic_begin()
     finally
         # try-finally unwinds the sigatomic level, so need to repeat sigatomic_end
         sigatomic_end()
diff --git a/doc/src/devdocs/ast.md b/doc/src/devdocs/ast.md
index 9efcd7974091f..09361f3754184 100644
--- a/doc/src/devdocs/ast.md
+++ b/doc/src/devdocs/ast.md
@@ -431,7 +431,7 @@ These symbols appear in the `head` field of [`Expr`](@ref)s in lowered form.
 
   * `the_exception`
 
-    Yields the caught exception inside a `catch` block, as returned by `jl_current_exception()`.
+    Yields the caught exception inside a `catch` block, as returned by `jl_current_exception(ct)`.
 
   * `enter`
 
diff --git a/src/ast.c b/src/ast.c
index d0ed4712c66f7..8cd483748bc94 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -475,7 +475,7 @@ static jl_value_t *scm_to_julia(fl_context_t *fl_ctx, value_t e, jl_module_t *mo
     }
     JL_CATCH {
         // if expression cannot be converted, replace with error expr
-        //jl_(jl_current_exception());
+        //jl_(jl_current_exception(ct));
         //jlbacktrace();
         jl_expr_t *ex = jl_exprn(jl_error_sym, 1);
         v = (jl_value_t*)ex;
@@ -1138,7 +1138,7 @@ static jl_value_t *jl_invoke_julia_macro(jl_array_t *args, jl_module_t *inmodule
                 margs[0] = jl_cstr_to_string("<macrocall>");
             margs[1] = jl_fieldref(lno, 0); // extract and allocate line number
             jl_rethrow_other(jl_new_struct(jl_loaderror_type, margs[0], margs[1],
-                                           jl_current_exception()));
+                                           jl_current_exception(ct)));
         }
     }
     ct->world_age = last_age;
diff --git a/src/ccall.cpp b/src/ccall.cpp
index 0fcc838905004..53714cebcbe2a 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1611,7 +1611,7 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         assert(lrt == ctx.types().T_prjlvalue);
         assert(!isVa && !llvmcall && nccallargs == 0);
         JL_GC_POP();
-        auto ct = track_pjlvalue(ctx, emit_bitcast(ctx, get_current_task(ctx), ctx.types().T_pjlvalue));
+        auto ct = track_pjlvalue(ctx, get_current_task(ctx));
         return mark_or_box_ccall_result(ctx, ct, retboxed, rt, unionall, static_rt);
     }
     else if (is_libjulia_func(jl_set_next_task)) {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index d4ce52b4dc1d0..cf5122df295eb 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1048,30 +1048,64 @@ static const auto jlunlockfield_func = new JuliaFunction<>{
 };
 static const auto jlenter_func = new JuliaFunction<>{
     XSTR(jl_enter_handler),
-    [](LLVMContext &C) { return FunctionType::get(getVoidTy(C),
-            {getInt8PtrTy(C)}, false); },
+    [](LLVMContext &C) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        return FunctionType::get(getVoidTy(C),
+            {T_pjlvalue, getInt8PtrTy(C)}, false); },
     nullptr,
 };
 static const auto jl_current_exception_func = new JuliaFunction<>{
     XSTR(jl_current_exception),
-    [](LLVMContext &C) { return FunctionType::get(JuliaType::get_prjlvalue_ty(C), false); },
+    [](LLVMContext &C) { return FunctionType::get(JuliaType::get_prjlvalue_ty(C), {JuliaType::get_pjlvalue_ty(C)}, false); },
     nullptr,
 };
 static const auto jlleave_func = new JuliaFunction<>{
     XSTR(jl_pop_handler),
-    [](LLVMContext &C) { return FunctionType::get(getVoidTy(C),
-            {getInt32Ty(C)}, false); },
-    nullptr,
+    [](LLVMContext &C) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        return FunctionType::get(getVoidTy(C),
+            {T_pjlvalue, getInt32Ty(C)}, false); },
+    [](LLVMContext &C) {
+            auto FnAttrs = AttrBuilder(C);
+            FnAttrs.addAttribute(Attribute::WillReturn);
+            FnAttrs.addAttribute(Attribute::NoUnwind);
+            auto RetAttrs = AttrBuilder(C);
+            return AttributeList::get(C,
+                AttributeSet::get(C, FnAttrs),
+                AttributeSet(),
+                None);
+        },
+};
+static const auto jlleave_noexcept_func = new JuliaFunction<>{
+    XSTR(jl_pop_handler_noexcept),
+    [](LLVMContext &C) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        return FunctionType::get(getVoidTy(C),
+            {T_pjlvalue, getInt32Ty(C)}, false); },
+    [](LLVMContext &C) {
+            auto FnAttrs = AttrBuilder(C);
+            FnAttrs.addAttribute(Attribute::WillReturn);
+            FnAttrs.addAttribute(Attribute::NoUnwind);
+            auto RetAttrs = AttrBuilder(C);
+            return AttributeList::get(C,
+                AttributeSet::get(C, FnAttrs),
+                AttributeSet(),
+                None);
+        },
 };
 static const auto jl_restore_excstack_func = new JuliaFunction<TypeFnContextAndSizeT>{
     XSTR(jl_restore_excstack),
-    [](LLVMContext &C, Type *T_size) { return FunctionType::get(getVoidTy(C),
-            {T_size}, false); },
+    [](LLVMContext &C, Type *T_size) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        return FunctionType::get(getVoidTy(C),
+            {T_pjlvalue, T_size}, false); },
     nullptr,
 };
 static const auto jl_excstack_state_func = new JuliaFunction<TypeFnContextAndSizeT>{
     XSTR(jl_excstack_state),
-    [](LLVMContext &C, Type *T_size) { return FunctionType::get(T_size, false); },
+    [](LLVMContext &C, Type *T_size) {
+        auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+        return FunctionType::get(T_size, {T_pjlvalue}, false); },
     nullptr,
 };
 static const auto jlegalx_func = new JuliaFunction<TypeFnContextAndSizeT>{
@@ -1098,9 +1132,9 @@ static const auto jl_alloc_obj_func = new JuliaFunction<TypeFnContextAndSizeT>{
     [](LLVMContext &C, Type *T_size) {
         auto T_jlvalue = JuliaType::get_jlvalue_ty(C);
         auto T_prjlvalue = PointerType::get(T_jlvalue, AddressSpace::Tracked);
-        auto T_ppjlvalue = PointerType::get(PointerType::get(T_jlvalue, 0), 0);
+        auto T_pjlvalue = PointerType::get(T_jlvalue, 0);
         return FunctionType::get(T_prjlvalue,
-                {T_ppjlvalue, T_size, T_prjlvalue}, false);
+                {T_pjlvalue, T_size, T_prjlvalue}, false);
     },
     [](LLVMContext &C) {
         auto FnAttrs = AttrBuilder(C);
@@ -1442,7 +1476,9 @@ static const auto gc_preserve_end_func = new JuliaFunction<> {
 };
 static const auto except_enter_func = new JuliaFunction<>{
     "julia.except_enter",
-    [](LLVMContext &C) { return FunctionType::get(getInt32Ty(C), false); },
+    [](LLVMContext &C) {
+         auto T_pjlvalue = JuliaType::get_pjlvalue_ty(C);
+         return FunctionType::get(getInt32Ty(C), {T_pjlvalue}, false); },
     [](LLVMContext &C) { return AttributeList::get(C,
             Attributes(C, {Attribute::ReturnsTwice}),
             AttributeSet(),
@@ -5961,8 +5997,7 @@ static void emit_stmtpos(jl_codectx_t &ctx, jl_value_t *expr, int ssaval_result)
                 hand_n_leave += 1;
             }
         }
-        ctx.builder.CreateCall(prepare_call(jlleave_func),
-                           ConstantInt::get(getInt32Ty(ctx.builder.getContext()), hand_n_leave));
+        ctx.builder.CreateCall(prepare_call(jlleave_noexcept_func), {get_current_task(ctx), ConstantInt::get(getInt32Ty(ctx.builder.getContext()), hand_n_leave)});
         if (scope_to_restore) {
             jl_aliasinfo_t scope_ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_gcframe);
             scope_ai.decorateInst(
@@ -5972,7 +6007,7 @@ static void emit_stmtpos(jl_codectx_t &ctx, jl_value_t *expr, int ssaval_result)
     else if (head == jl_pop_exception_sym) {
         jl_cgval_t excstack_state = emit_expr(ctx, jl_exprarg(expr, 0));
         assert(excstack_state.V && excstack_state.V->getType() == ctx.types().T_size);
-        ctx.builder.CreateCall(prepare_call(jl_restore_excstack_func), excstack_state.V);
+        ctx.builder.CreateCall(prepare_call(jl_restore_excstack_func), {get_current_task(ctx), excstack_state.V});
         return;
     }
     else {
@@ -6203,7 +6238,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
                     bnd = jl_get_binding_for_method_def(mod, (jl_sym_t*)mn);
                 }
                 JL_CATCH {
-                    jl_value_t *e = jl_current_exception();
+                    jl_value_t *e = jl_current_exception(jl_current_task);
                     // errors. boo. :(
                     JL_GC_PUSH1(&e);
                     e = jl_as_global_root(e, 1);
@@ -6379,7 +6414,7 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
     else if (head == jl_exc_sym) {
         assert(nargs == 0);
         return mark_julia_type(ctx,
-                ctx.builder.CreateCall(prepare_call(jl_current_exception_func)),
+                ctx.builder.CreateCall(prepare_call(jl_current_exception_func), {get_current_task(ctx)}),
                 true, jl_any_type);
     }
     else if (head == jl_copyast_sym) {
@@ -6481,9 +6516,14 @@ static void allocate_gc_frame(jl_codectx_t &ctx, BasicBlock *b0, bool or_new=fal
     ctx.pgcstack->setName("pgcstack");
 }
 
+static Value *get_current_task(jl_codectx_t &ctx, Type *T)
+{
+    return emit_bitcast(ctx, get_current_task_from_pgcstack(ctx.builder, ctx.types().T_size, ctx.pgcstack), T);
+}
+
 static Value *get_current_task(jl_codectx_t &ctx)
 {
-    return get_current_task_from_pgcstack(ctx.builder, ctx.types().T_size, ctx.pgcstack);
+    return get_current_task(ctx, ctx.types().T_pjlvalue);
 }
 
 // Get PTLS through current task.
@@ -6495,20 +6535,20 @@ static Value *get_current_ptls(jl_codectx_t &ctx)
 // Get the address of the world age of the current task
 static Value *get_last_age_field(jl_codectx_t &ctx)
 {
-    Value *ct = get_current_task(ctx);
+    Value *ct = get_current_task(ctx, ctx.types().T_size->getPointerTo());
     return ctx.builder.CreateInBoundsGEP(
             ctx.types().T_size,
-            ctx.builder.CreateBitCast(ct, ctx.types().T_size->getPointerTo()),
+            ct,
             ConstantInt::get(ctx.types().T_size, offsetof(jl_task_t, world_age) / ctx.types().sizeof_ptr),
             "world_age");
 }
 
 static Value *get_scope_field(jl_codectx_t &ctx)
 {
-    Value *ct = get_current_task(ctx);
+    Value *ct = get_current_task(ctx, ctx.types().T_prjlvalue->getPointerTo());
     return ctx.builder.CreateInBoundsGEP(
             ctx.types().T_prjlvalue,
-            ctx.builder.CreateBitCast(ct, ctx.types().T_prjlvalue->getPointerTo()),
+            ct,
             ConstantInt::get(ctx.types().T_size, offsetof(jl_task_t, scope) / ctx.types().sizeof_ptr),
             "current_scope");
 }
@@ -9156,12 +9196,12 @@ static jl_llvm_functions_t
             if (lname) {
                 // Save exception stack depth at enter for use in pop_exception
                 Value *excstack_state =
-                    ctx.builder.CreateCall(prepare_call(jl_excstack_state_func));
+                    ctx.builder.CreateCall(prepare_call(jl_excstack_state_func), {get_current_task(ctx)});
                 assert(!ctx.ssavalue_assigned[cursor]);
                 ctx.SAvalues[cursor] = jl_cgval_t(excstack_state, (jl_value_t*)jl_ulong_type, NULL);
                 ctx.ssavalue_assigned[cursor] = true;
                 // Actually enter the exception frame
-                CallInst *sj = ctx.builder.CreateCall(prepare_call(except_enter_func));
+                CallInst *sj = ctx.builder.CreateCall(prepare_call(except_enter_func), {get_current_task(ctx)});
                 // We need to mark this on the call site as well. See issue #6757
                 sj->setCanReturnTwice();
                 Value *isz = ctx.builder.CreateICmpEQ(sj, ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 0));
@@ -9174,8 +9214,7 @@ static jl_llvm_functions_t
                 ctx.builder.CreateCondBr(isz, tryblk, catchpop);
                 ctx.builder.SetInsertPoint(catchpop);
                 {
-                    ctx.builder.CreateCall(prepare_call(jlleave_func),
-                                    ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 1));
+                    ctx.builder.CreateCall(prepare_call(jlleave_func), {get_current_task(ctx), ConstantInt::get(getInt32Ty(ctx.builder.getContext()), 1)});
                     if (old_scope) {
                         scope_ai.decorateInst(
                             ctx.builder.CreateAlignedStore(old_scope, scope_ptr, ctx.types().alignof_ptr));
@@ -9542,7 +9581,7 @@ jl_llvm_functions_t jl_emit_code(
         decls.functionObject = "";
         decls.specFunctionObject = "";
         jl_printf((JL_STREAM*)STDERR_FILENO, "Internal error: encountered unexpected error during compilation of %s:\n", mname.c_str());
-        jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
+        jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception(jl_current_task));
         jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
         jlbacktrace(); // written to STDERR_FILENO
 #ifndef JL_NDEBUG
@@ -9849,6 +9888,7 @@ static void init_jit_functions(void)
     add_named_global(jlgenericfunction_func, &jl_generic_function_def);
     add_named_global(jlenter_func, &jl_enter_handler);
     add_named_global(jl_current_exception_func, &jl_current_exception);
+    add_named_global(jlleave_noexcept_func, &jl_pop_handler_noexcept);
     add_named_global(jlleave_func, &jl_pop_handler);
     add_named_global(jl_restore_excstack_func, &jl_restore_excstack);
     add_named_global(jl_excstack_state_func, &jl_excstack_state);
diff --git a/src/gc.c b/src/gc.c
index 35a8d31749233..4aae5e22c6678 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -301,7 +301,7 @@ static void run_finalizer(jl_task_t *ct, void *o, void *ff)
     }
     JL_CATCH {
         jl_printf((JL_STREAM*)STDERR_FILENO, "error in running finalizer: ");
-        jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
+        jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception(ct));
         jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
         jlbacktrace(); // written to STDERR_FILENO
     }
diff --git a/src/gf.c b/src/gf.c
index 1cc74672e4d0c..53496c8feca58 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -95,7 +95,7 @@ void jl_call_tracer(tracer_cb callback, jl_value_t *tracee)
     JL_CATCH {
         ct->ptls->in_pure_callback = last_in;
         jl_printf((JL_STREAM*)STDERR_FILENO, "WARNING: tracer callback function threw an error:\n");
-        jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
+        jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception(ct));
         jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
         jlbacktrace(); // written to STDERR_FILENO
     }
@@ -393,7 +393,7 @@ jl_code_instance_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int fo
         ci = (jl_code_instance_t*)jl_apply(fargs, 4);
     }
     JL_CATCH {
-        jl_value_t *e = jl_current_exception();
+        jl_value_t *e = jl_current_exception(ct);
         jl_printf((JL_STREAM*)STDERR_FILENO, "Internal error: during type inference of\n");
         jl_static_show_func_sig((JL_STREAM*)STDERR_FILENO, (jl_value_t*)mi->specTypes);
         jl_printf((JL_STREAM*)STDERR_FILENO, "\nEncountered ");
diff --git a/src/init.c b/src/init.c
index 801f12ec53930..2c1ad618948f8 100644
--- a/src/init.c
+++ b/src/init.c
@@ -273,7 +273,7 @@ JL_DLLEXPORT void jl_atexit_hook(int exitcode) JL_NOTSAFEPOINT_ENTER
             }
             JL_CATCH {
                 jl_printf((JL_STREAM*)STDERR_FILENO, "\natexit hook threw an error: ");
-                jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
+                jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception(ct));
                 jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
                 jlbacktrace(); // written to STDERR_FILENO
             }
@@ -317,7 +317,7 @@ JL_DLLEXPORT void jl_atexit_hook(int exitcode) JL_NOTSAFEPOINT_ENTER
                     assert(item);
                     uv_unref(item->h);
                     jl_printf((JL_STREAM*)STDERR_FILENO, "error during exit cleanup: close: ");
-                    jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
+                    jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception(ct));
                     jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
                     jlbacktrace(); // written to STDERR_FILENO
                     item = next_shutdown_queue_item(item);
@@ -372,7 +372,7 @@ JL_DLLEXPORT void jl_postoutput_hook(void)
             }
             JL_CATCH {
                 jl_printf((JL_STREAM*)STDERR_FILENO, "\npostoutput hook threw an error: ");
-                jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
+                jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception(ct));
                 jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
                 jlbacktrace(); // written to STDERR_FILENO
             }
diff --git a/src/interpreter.c b/src/interpreter.c
index 5102d1417c939..2fb4b91927496 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -317,7 +317,7 @@ static jl_value_t *eval_value(jl_value_t *e, interpreter_state *s)
         return jl_copy_ast(eval_value(args[0], s));
     }
     else if (head == jl_exc_sym) {
-        return jl_current_exception();
+        return jl_current_exception(jl_current_task);
     }
     else if (head == jl_boundscheck_sym) {
         return jl_true;
@@ -490,7 +490,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
             s->locals[jl_source_nslots(s->src) + id] = val;
         }
         else if (jl_is_enternode(stmt)) {
-            jl_enter_handler(&__eh);
+            jl_enter_handler(ct, &__eh);
             // This is a bit tricky, but supports the implementation of PhiC nodes.
             // They are conceptually slots, but the slot to store to doesn't get explicitly
             // mentioned in the store (aka the "UpsilonNode") (this makes them integrate more
@@ -521,7 +521,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
                 }
                 // store current top of exception stack for restore in pop_exception.
             }
-            s->locals[jl_source_nslots(s->src) + ip] = jl_box_ulong(jl_excstack_state());
+            s->locals[jl_source_nslots(s->src) + ip] = jl_box_ulong(jl_excstack_state(ct));
             if (jl_enternode_scope(stmt)) {
                 jl_value_t *old_scope = ct->scope;
                 JL_GC_PUSH1(&old_scope);
@@ -540,13 +540,15 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
                     jl_unreachable();
                 }
             }
-            jl_eh_restore_state(&__eh);
+
             if (s->continue_at) { // means we reached a :leave expression
+                jl_eh_restore_state_noexcept(ct, &__eh);
                 ip = s->continue_at;
                 s->continue_at = 0;
                 continue;
             }
             else { // a real exception
+                jl_eh_restore_state(ct, &__eh);
                 ip = catch_ip;
                 assert(jl_enternode_catch_dest(stmt) != 0);
                 continue;
@@ -609,7 +611,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
             }
             else if (head == jl_pop_exception_sym) {
                 size_t prev_state = jl_unbox_ulong(eval_value(jl_exprarg(stmt, 0), s));
-                jl_restore_excstack(prev_state);
+                jl_restore_excstack(ct, prev_state);
             }
             else if (toplevel) {
                 if (head == jl_method_sym && jl_expr_nargs(stmt) > 1) {
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 48bbec09688b7..e2527e3d7aeab 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -109,6 +109,7 @@
     XX(jl_egal__bits) \
     XX(jl_egal__bitstag) \
     XX(jl_eh_restore_state) \
+    XX(jl_eh_restore_state_noexcept) \
     XX(jl_enter_handler) \
     XX(jl_enter_threaded_region) \
     XX(jl_environ) \
@@ -366,6 +367,7 @@
     XX(jl_pointerref) \
     XX(jl_pointerset) \
     XX(jl_pop_handler) \
+    XX(jl_pop_handler_noexcept) \
     XX(jl_preload_sysimg_so) \
     XX(jl_prepend_cwd) \
     XX(jl_printf) \
diff --git a/src/jlapi.c b/src/jlapi.c
index 276a792b2cd66..a3621385a437e 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -158,7 +158,7 @@ JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
         _jl_exception_clear(ct);
     }
     JL_CATCH {
-        ct->ptls->previous_exception = jl_current_exception();
+        ct->ptls->previous_exception = jl_current_exception(ct);
         r = NULL;
     }
     return r;
@@ -170,9 +170,9 @@ JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
  * @return A pointer to `jl_value_t` representing the current exception.
  *         Returns `NULL` if no exception is currently thrown.
  */
-JL_DLLEXPORT jl_value_t *jl_current_exception(void) JL_GLOBALLY_ROOTED JL_NOTSAFEPOINT
+JL_DLLEXPORT jl_value_t *jl_current_exception(jl_task_t *ct) JL_GLOBALLY_ROOTED JL_NOTSAFEPOINT
 {
-    jl_excstack_t *s = jl_current_task->excstack;
+    jl_excstack_t *s = ct->excstack;
     return s && s->top != 0 ? jl_excstack_exception(s, s->top) : jl_nothing;
 }
 
@@ -300,7 +300,7 @@ JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, uint32_t n
         _jl_exception_clear(ct);
     }
     JL_CATCH {
-        ct->ptls->previous_exception = jl_current_exception();
+        ct->ptls->previous_exception = jl_current_exception(ct);
         v = NULL;
     }
     return v;
@@ -328,7 +328,7 @@ JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
         _jl_exception_clear(ct);
     }
     JL_CATCH {
-        ct->ptls->previous_exception = jl_current_exception();
+        ct->ptls->previous_exception = jl_current_exception(ct);
         v = NULL;
     }
     return v;
@@ -360,7 +360,7 @@ JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
         _jl_exception_clear(ct);
     }
     JL_CATCH {
-        ct->ptls->previous_exception = jl_current_exception();
+        ct->ptls->previous_exception = jl_current_exception(ct);
         v = NULL;
     }
     return v;
@@ -394,7 +394,7 @@ JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b
         _jl_exception_clear(ct);
     }
     JL_CATCH {
-        ct->ptls->previous_exception = jl_current_exception();
+        ct->ptls->previous_exception = jl_current_exception(ct);
         v = NULL;
     }
     return v;
@@ -431,7 +431,7 @@ JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
         _jl_exception_clear(ct);
     }
     JL_CATCH {
-        ct->ptls->previous_exception = jl_current_exception();
+        ct->ptls->previous_exception = jl_current_exception(ct);
         v = NULL;
     }
     return v;
@@ -447,6 +447,7 @@ JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
 JL_DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
 {
     jl_value_t *v;
+    jl_task_t *ct = jl_current_task;
     JL_TRY {
         jl_value_t *s = (jl_value_t*)jl_symbol(fld);
         int i = jl_field_index((jl_datatype_t*)jl_typeof(o), (jl_sym_t*)s, 1);
@@ -454,7 +455,7 @@ JL_DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
         jl_exception_clear();
     }
     JL_CATCH {
-        jl_current_task->ptls->previous_exception = jl_current_exception();
+        ct->ptls->previous_exception = jl_current_exception(ct);
         v = NULL;
     }
     return v;
@@ -852,6 +853,7 @@ JL_DLLEXPORT int jl_set_fenv_rounding(int i)
 
 static int exec_program(char *program)
 {
+    jl_task_t *ct = jl_current_task;
     JL_TRY {
         jl_load(jl_main_module, program);
     }
@@ -860,7 +862,7 @@ static int exec_program(char *program)
         //       printing directly to STDERR_FILENO.
         int shown_err = 0;
         jl_printf(JL_STDERR, "error during bootstrap:\n");
-        jl_value_t *exc = jl_current_exception();
+        jl_value_t *exc = jl_current_exception(ct);
         jl_value_t *showf = jl_base_module ? jl_get_function(jl_base_module, "show") : NULL;
         if (showf) {
             jl_value_t *errs = jl_stderr_obj();
@@ -889,8 +891,8 @@ static NOINLINE int true_main(int argc, char *argv[])
     jl_function_t *start_client = jl_base_module ?
         (jl_function_t*)jl_get_global(jl_base_module, jl_symbol("_start")) : NULL;
 
+    jl_task_t *ct = jl_current_task;
     if (start_client) {
-        jl_task_t *ct = jl_current_task;
         int ret = 1;
         JL_TRY {
             size_t last_age = ct->world_age;
@@ -902,7 +904,7 @@ static NOINLINE int true_main(int argc, char *argv[])
             ct->world_age = last_age;
         }
         JL_CATCH {
-            jl_no_exc_handler(jl_current_exception(), ct);
+            jl_no_exc_handler(jl_current_exception(ct), ct);
         }
         return ret;
     }
@@ -946,7 +948,7 @@ static NOINLINE int true_main(int argc, char *argv[])
                 line = NULL;
             }
             jl_printf((JL_STREAM*)STDERR_FILENO, "\nparser error:\n");
-            jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
+            jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception(ct));
             jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
             jl_print_backtrace(); // written to STDERR_FILENO
         }
diff --git a/src/jloptions.c b/src/jloptions.c
index 2ba5174e5c730..085e5f365ac46 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -859,7 +859,8 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                 if (isnan(sz) || sz < 0) {
                     jl_errorf("julia: invalid argument to --heap-size-hint (%s)", optarg);
                 }
-                jl_options.heap_size_hint = sz < UINT64_MAX ? (uint64_t)sz : UINT64_MAX;
+                const long double limit = ldexpl(1.0, 64); // UINT64_MAX + 1
+                jl_options.heap_size_hint = sz < limit ? (uint64_t)sz : UINT64_MAX;
             }
             if (jl_options.heap_size_hint == 0)
                 jl_errorf("julia: invalid memory size specified in --heap-size-hint");
diff --git a/src/jltypes.c b/src/jltypes.c
index 741d48978a555..2ea432a7a5cc3 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -1846,7 +1846,7 @@ static jl_value_t *normalize_unionalls(jl_value_t *t)
     else if (jl_is_unionall(t)) {
         jl_unionall_t *u = (jl_unionall_t*)t;
         jl_value_t *body = normalize_unionalls(u->body);
-        JL_GC_PUSH1(&body);
+        JL_GC_PUSH2(&body, &t);
         if (body != u->body) {
             t = jl_new_struct(jl_unionall_type, u->var, body);
             u = (jl_unionall_t*)t;
diff --git a/src/julia.h b/src/julia.h
index cf0317b6ad9fd..8dc53b56785d3 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -2033,17 +2033,6 @@ JL_DLLEXPORT void JL_NORETURN jl_bounds_error_unboxed_int(void *v, jl_value_t *v
 JL_DLLEXPORT void JL_NORETURN jl_bounds_error_ints(jl_value_t *v JL_MAYBE_UNROOTED,
                                                    size_t *idxs, size_t nidxs);
 
-// Return the exception currently being handled, or `jl_nothing`.
-//
-// The catch scope is determined dynamically so this works in functions called
-// from a catch block.  The returned value is gc rooted until we exit the
-// enclosing JL_CATCH.
-// FIXME: Teach the static analyzer about this rather than using
-// JL_GLOBALLY_ROOTED which is far too optimistic.
-JL_DLLEXPORT jl_value_t *jl_current_exception(void) JL_GLOBALLY_ROOTED JL_NOTSAFEPOINT;
-JL_DLLEXPORT jl_value_t *jl_exception_occurred(void);
-JL_DLLEXPORT void jl_exception_clear(void) JL_NOTSAFEPOINT;
-
 #define JL_NARGS(fname, min, max)                               \
     if (nargs < min) jl_too_few_args(#fname, min);              \
     else if (nargs > max) jl_too_many_args(#fname, max);
@@ -2303,11 +2292,24 @@ extern JL_DLLIMPORT int jl_task_ptls_offset;
 
 #include "julia_locks.h"   // requires jl_task_t definition
 
-JL_DLLEXPORT void jl_enter_handler(jl_handler_t *eh);
-JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh);
-JL_DLLEXPORT void jl_pop_handler(int n);
-JL_DLLEXPORT size_t jl_excstack_state(void) JL_NOTSAFEPOINT;
-JL_DLLEXPORT void jl_restore_excstack(size_t state) JL_NOTSAFEPOINT;
+// Return the exception currently being handled, or `jl_nothing`.
+//
+// The catch scope is determined dynamically so this works in functions called
+// from a catch block.  The returned value is gc rooted until we exit the
+// enclosing JL_CATCH.
+// FIXME: Teach the static analyzer about this rather than using
+// JL_GLOBALLY_ROOTED which is far too optimistic.
+JL_DLLEXPORT jl_value_t *jl_current_exception(jl_task_t *ct) JL_GLOBALLY_ROOTED JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_value_t *jl_exception_occurred(void);
+JL_DLLEXPORT void jl_exception_clear(void) JL_NOTSAFEPOINT;
+
+JL_DLLEXPORT void jl_enter_handler(jl_task_t *ct, jl_handler_t *eh) JL_NOTSAFEPOINT ;
+JL_DLLEXPORT void jl_eh_restore_state(jl_task_t *ct, jl_handler_t *eh);
+JL_DLLEXPORT void jl_eh_restore_state_noexcept(jl_task_t *ct, jl_handler_t *eh) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_pop_handler(jl_task_t *ct, int n) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_pop_handler_noexcept(jl_task_t *ct, int n) JL_NOTSAFEPOINT;
+JL_DLLEXPORT size_t jl_excstack_state(jl_task_t *ct) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_restore_excstack(jl_task_t *ct, size_t state) JL_NOTSAFEPOINT;
 
 #if defined(_OS_WINDOWS_)
 #if defined(_COMPILER_GCC_)
@@ -2358,24 +2360,36 @@ extern void (*real_siglongjmp)(jmp_buf _Buf, int _Value);
 
 #ifdef __clang_gcanalyzer__
 
-// This is hard. Ideally we'd teach the static analyzer about the extra control
-// flow edges. But for now, just hide this as best we can
 extern int had_exception;
-#define JL_TRY if (1)
-#define JL_CATCH if (had_exception)
 
-#else
+// The analyzer assumes that the TRY block always executes to completion.
+// This can lead to both false positives and false negatives, since it doesn't model the fact that throwing always leaves the try block early.
+#define JL_TRY                                                      \
+    int i__try, i__catch; jl_handler_t __eh; jl_task_t *__eh_ct;    \
+    __eh_ct = jl_current_task;                                      \
+    size_t __excstack_state = jl_excstack_state(__eh_ct);           \
+    jl_enter_handler(__eh_ct, &__eh);                               \
+    if (1)
+    /* TRY BLOCK; */
+#define JL_CATCH                                                    \
+    if (!had_exception)                                             \
+        jl_eh_restore_state_noexcept(__eh_ct, &__eh);               \
+    else                                                            \
+        for (i__catch=1, jl_eh_restore_state(__eh_ct, &__eh); i__catch; i__catch=0, /* CATCH BLOCK; */ jl_restore_excstack(__eh_ct, __excstack_state))
 
-#define JL_TRY                                                    \
-    int i__tr, i__ca; jl_handler_t __eh;                          \
-    size_t __excstack_state = jl_excstack_state();                \
-    jl_enter_handler(&__eh);                                      \
-    if (!jl_setjmp(__eh.eh_ctx,0))                                \
-        for (i__tr=1; i__tr; i__tr=0, jl_eh_restore_state(&__eh))
+#else
 
-#define JL_CATCH                                                \
-    else                                                        \
-        for (i__ca=1, jl_eh_restore_state(&__eh); i__ca; i__ca=0, jl_restore_excstack(__excstack_state))
+#define JL_TRY                                                      \
+    int i__try, i__catch; jl_handler_t __eh; jl_task_t *__eh_ct;    \
+    __eh_ct = jl_current_task;                                      \
+    size_t __excstack_state = jl_excstack_state(__eh_ct);           \
+    jl_enter_handler(__eh_ct, &__eh);                               \
+    if (!jl_setjmp(__eh.eh_ctx, 0))                                 \
+        for (i__try=1; i__try; i__try=0, /* TRY BLOCK; */  jl_eh_restore_state_noexcept(__eh_ct, &__eh))
+
+#define JL_CATCH                                                    \
+    else                                                            \
+        for (i__catch=1, jl_eh_restore_state(__eh_ct, &__eh); i__catch; i__catch=0, /* CATCH BLOCK; */ jl_restore_excstack(__eh_ct, __excstack_state))
 
 #endif
 
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 66e824687bba0..1137e7a22d47b 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1272,7 +1272,7 @@ STATIC_INLINE size_t jl_excstack_next(jl_excstack_t *stack, size_t itr) JL_NOTSA
     return itr-2 - jl_excstack_bt_size(stack, itr);
 }
 // Exception stack manipulation
-void jl_push_excstack(jl_task_t* task, jl_excstack_t **stack JL_REQUIRE_ROOTED_SLOT JL_ROOTING_ARGUMENT,
+void jl_push_excstack(jl_task_t *ct, jl_excstack_t **stack JL_REQUIRE_ROOTED_SLOT JL_ROOTING_ARGUMENT,
                       jl_value_t *exception JL_ROOTED_ARGUMENT,
                       jl_bt_element_t *bt_data, size_t bt_size);
 
diff --git a/src/llvm-codegen-shared.h b/src/llvm-codegen-shared.h
index 2c60907ca086c..b355dd05436c1 100644
--- a/src/llvm-codegen-shared.h
+++ b/src/llvm-codegen-shared.h
@@ -222,7 +222,7 @@ static inline llvm::Value *get_current_ptls_from_task(llvm::IRBuilder<> &builder
     auto T_pjlvalue = JuliaType::get_pjlvalue_ty(builder.getContext());
     const int ptls_offset = offsetof(jl_task_t, ptls);
     llvm::Value *pptls = builder.CreateInBoundsGEP(
-            T_pjlvalue, current_task,
+            T_pjlvalue, emit_bitcast_with_builder(builder, current_task, T_ppjlvalue),
             ConstantInt::get(T_size, ptls_offset / sizeof(void *)),
             "ptls_field");
     LoadInst *ptls_load = builder.CreateAlignedLoad(T_pjlvalue,
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index b35f64be813d7..a6178d95d5476 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -1621,7 +1621,7 @@ State LateLowerGCFrame::LocalScan(Function &F) {
                         callee == pgcstack_getter || callee->getName() == XSTR(jl_egal__unboxed) ||
                         callee->getName() == XSTR(jl_lock_value) || callee->getName() == XSTR(jl_unlock_value) ||
                         callee->getName() == XSTR(jl_lock_field) || callee->getName() == XSTR(jl_unlock_field) ||
-                        callee == write_barrier_func || callee == gc_loaded_func ||
+                        callee == write_barrier_func || callee == gc_loaded_func || callee == pop_handler_noexcept_func ||
                         callee->getName() == "memcmp") {
                         continue;
                     }
diff --git a/src/llvm-lower-handlers.cpp b/src/llvm-lower-handlers.cpp
index 15866d0855fc1..d6d4793f3c1c0 100644
--- a/src/llvm-lower-handlers.cpp
+++ b/src/llvm-lower-handlers.cpp
@@ -37,13 +37,13 @@ using namespace llvm;
 /* Lowers Julia Exception Handlers and colors EH frames.
  *
  *  Our task is to lower:
- * call void @julia.except_enter()
+ * call void @julia.except_enter(ct)
  * <...>
  * call void jl_pop_handler(1)
  *
  * to
  *
- * call void @jl_enter_handler(jl_handler *%buff)
+ * call void @jl_enter_handler(ct, jl_handler *%buff)
  * <...>
  * call void jl_pop_handler(1)
  *
@@ -81,25 +81,19 @@ namespace {
  * If the module doesn't have declarations for the jl_enter_handler and setjmp
  * functions, insert them.
  */
-static void ensure_enter_function(Module &M, const Triple &TT)
+static void ensure_enter_function(Module &M, Type *T_pjlvalue, const Triple &TT)
 {
     auto T_int8  = Type::getInt8Ty(M.getContext());
     auto T_pint8 = PointerType::get(T_int8, 0);
     auto T_void = Type::getVoidTy(M.getContext());
     auto T_int32 = Type::getInt32Ty(M.getContext());
     if (!M.getNamedValue(XSTR(jl_enter_handler))) {
-        SmallVector<Type*, 0> ehargs(0);
-        ehargs.push_back(T_pint8);
-        Function::Create(FunctionType::get(T_void, ehargs, false),
+        Function::Create(FunctionType::get(T_void, {T_pjlvalue, T_pint8}, false),
                          Function::ExternalLinkage, XSTR(jl_enter_handler), &M);
     }
     if (!M.getNamedValue(jl_setjmp_name)) {
-        SmallVector<Type*, 0> args2(0);
-        args2.push_back(T_pint8);
-        if (!TT.isOSWindows()) {
-            args2.push_back(T_int32);
-        }
-        Function::Create(FunctionType::get(T_int32, args2, false),
+        Type *args2[] = {T_pint8, T_int32};
+        Function::Create(FunctionType::get(T_int32, ArrayRef(args2, TT.isOSWindows() ? 1 : 2), false),
                          Function::ExternalLinkage, jl_setjmp_name, &M)
             ->addFnAttr(Attribute::ReturnsTwice);
     }
@@ -111,8 +105,9 @@ static bool lowerExcHandlers(Function &F) {
     Function *except_enter_func = M.getFunction("julia.except_enter");
     if (!except_enter_func)
         return false; // No EH frames in this module
-    ensure_enter_function(M, TT);
+    ensure_enter_function(M, except_enter_func->getFunctionType()->getParamType(0), TT);
     Function *leave_func = M.getFunction(XSTR(jl_pop_handler));
+    Function *leave_noexcept_func = M.getFunction(XSTR(jl_pop_handler_noexcept));
     Function *jlenter_func = M.getFunction(XSTR(jl_enter_handler));
     Function *setjmp_func = M.getFunction(jl_setjmp_name);
 
@@ -150,9 +145,9 @@ static bool lowerExcHandlers(Function &F) {
                 continue;
             if (Callee == except_enter_func)
                 EnterDepth[CI] = Depth++;
-            else if (Callee == leave_func) {
+            else if (Callee == leave_func || Callee == leave_noexcept_func) {
                 LeaveDepth[CI] = Depth;
-                Depth -= cast<ConstantInt>(CI->getArgOperand(0))->getLimitedValue();
+                Depth -= cast<ConstantInt>(CI->getArgOperand(1))->getLimitedValue();
             }
             assert(Depth >= 0);
             if (Depth > MaxDepth)
@@ -192,7 +187,7 @@ static bool lowerExcHandlers(Function &F) {
         assert(it.second >= 0);
         Instruction *buff = buffs[it.second];
         CallInst *enter = it.first;
-        auto new_enter = CallInst::Create(jlenter_func, buff, "", enter);
+        auto new_enter = CallInst::Create(jlenter_func, {enter->getArgOperand(0), buff}, "", enter);
         Value *lifetime_args[] = {
             handler_sz64,
             buff
@@ -200,10 +195,7 @@ static bool lowerExcHandlers(Function &F) {
         CallInst::Create(lifetime_start, lifetime_args, "", new_enter);
         CallInst *sj;
         if (!TT.isOSWindows()) {
-            // For LLVM 3.3 compatibility
-            Value *args[] = {buff,
-                            ConstantInt::get(Type::getInt32Ty(F.getContext()), 0)};
-            sj = CallInst::Create(setjmp_func, args, "", enter);
+            sj = CallInst::Create(setjmp_func, {buff, ConstantInt::get(Type::getInt32Ty(F.getContext()), 0)}, "", enter);
         } else {
             sj = CallInst::Create(setjmp_func, buff, "", enter);
         }
@@ -219,7 +211,7 @@ static bool lowerExcHandlers(Function &F) {
     // Insert lifetime end intrinsics after every leave.
     for (auto it : LeaveDepth) {
         int StartDepth = it.second - 1;
-        int npops = cast<ConstantInt>(it.first->getArgOperand(0))->getLimitedValue();
+        int npops = cast<ConstantInt>(it.first->getArgOperand(1))->getLimitedValue();
         for (int i = 0; i < npops; ++i) {
             assert(StartDepth-i >= 0);
             Value *lifetime_args[] = {
diff --git a/src/llvm-pass-helpers.cpp b/src/llvm-pass-helpers.cpp
index 9c62a8a5711a5..f217d27035200 100644
--- a/src/llvm-pass-helpers.cpp
+++ b/src/llvm-pass-helpers.cpp
@@ -27,7 +27,7 @@ JuliaPassContext::JuliaPassContext()
         pgcstack_getter(nullptr), adoptthread_func(nullptr), gc_flush_func(nullptr),
         gc_preserve_begin_func(nullptr), gc_preserve_end_func(nullptr),
         pointer_from_objref_func(nullptr), gc_loaded_func(nullptr), alloc_obj_func(nullptr),
-        typeof_func(nullptr), write_barrier_func(nullptr),
+        typeof_func(nullptr), write_barrier_func(nullptr), pop_handler_noexcept_func(nullptr),
         call_func(nullptr), call2_func(nullptr), call3_func(nullptr), module(nullptr)
 {
 }
@@ -53,6 +53,7 @@ void JuliaPassContext::initFunctions(Module &M)
     typeof_func = M.getFunction("julia.typeof");
     write_barrier_func = M.getFunction("julia.write_barrier");
     alloc_obj_func = M.getFunction("julia.gc_alloc_obj");
+    pop_handler_noexcept_func = M.getFunction(XSTR(jl_pop_handler_noexcept));
     call_func = M.getFunction("julia.call");
     call2_func = M.getFunction("julia.call2");
     call3_func = M.getFunction("julia.call3");
diff --git a/src/llvm-pass-helpers.h b/src/llvm-pass-helpers.h
index 346500df51ca1..d0ac7faa01d2c 100644
--- a/src/llvm-pass-helpers.h
+++ b/src/llvm-pass-helpers.h
@@ -60,6 +60,7 @@ struct JuliaPassContext {
     llvm::Function *alloc_obj_func;
     llvm::Function *typeof_func;
     llvm::Function *write_barrier_func;
+    llvm::Function *pop_handler_noexcept_func;
     llvm::Function *call_func;
     llvm::Function *call2_func;
     llvm::Function *call3_func;
diff --git a/src/method.c b/src/method.c
index c75434b2bf17b..a97dccf53e1e2 100644
--- a/src/method.c
+++ b/src/method.c
@@ -127,6 +127,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
             }
             if (e->head == jl_cfunction_sym) {
                 JL_NARGS(cfunction method definition, 5, 5); // (type, func, rt, at, cc)
+                jl_task_t *ct = jl_current_task;
                 jl_value_t *typ = jl_exprarg(e, 0);
                 if (!jl_is_type(typ))
                     jl_error("first parameter to :cfunction must be a type");
@@ -143,7 +144,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                         rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);
                     }
                     JL_CATCH {
-                        if (jl_typetagis(jl_current_exception(), jl_errorexception_type))
+                        if (jl_typetagis(jl_current_exception(ct), jl_errorexception_type))
                             jl_error("could not evaluate cfunction return type (it might depend on a local variable)");
                         else
                             jl_rethrow();
@@ -155,7 +156,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                         at = jl_interpret_toplevel_expr_in(module, at, NULL, sparam_vals);
                     }
                     JL_CATCH {
-                        if (jl_typetagis(jl_current_exception(), jl_errorexception_type))
+                        if (jl_typetagis(jl_current_exception(ct), jl_errorexception_type))
                             jl_error("could not evaluate cfunction argument type (it might depend on a local variable)");
                         else
                             jl_rethrow();
@@ -169,6 +170,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
             }
             if (e->head == jl_foreigncall_sym) {
                 JL_NARGSV(ccall method definition, 5); // (fptr, rt, at, nreq, (cc, effects))
+                jl_task_t *ct = jl_current_task;
                 jl_value_t *rt = jl_exprarg(e, 1);
                 jl_value_t *at = jl_exprarg(e, 2);
                 if (!jl_is_type(rt)) {
@@ -176,7 +178,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                         rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);
                     }
                     JL_CATCH {
-                        if (jl_typetagis(jl_current_exception(), jl_errorexception_type))
+                        if (jl_typetagis(jl_current_exception(ct), jl_errorexception_type))
                             jl_error("could not evaluate ccall return type (it might depend on a local variable)");
                         else
                             jl_rethrow();
@@ -188,7 +190,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                         at = jl_interpret_toplevel_expr_in(module, at, NULL, sparam_vals);
                     }
                     JL_CATCH {
-                        if (jl_typetagis(jl_current_exception(), jl_errorexception_type))
+                        if (jl_typetagis(jl_current_exception(ct), jl_errorexception_type))
                             jl_error("could not evaluate ccall argument type (it might depend on a local variable)");
                         else
                             jl_rethrow();
@@ -264,6 +266,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                                 val = jl_interpret_toplevel_expr_in(module, (jl_value_t*)e, NULL, sparam_vals);
                             }
                             JL_CATCH {
+                                val = NULL; // To make the analyzer happy see #define JL_TRY
                             }
                             if (val)
                                 return val;
diff --git a/src/rtutils.c b/src/rtutils.c
index 9e76f513419c0..b7e7999320100 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -239,9 +239,8 @@ JL_DLLEXPORT void __stack_chk_fail(void)
 
 // exceptions -----------------------------------------------------------------
 
-JL_DLLEXPORT void jl_enter_handler(jl_handler_t *eh)
+JL_DLLEXPORT void jl_enter_handler(jl_task_t *ct, jl_handler_t *eh)
 {
-    jl_task_t *ct = jl_current_task;
     // Must have no safepoint
     eh->prev = ct->eh;
     eh->gcstack = ct->gcstack;
@@ -260,9 +259,8 @@ JL_DLLEXPORT void jl_enter_handler(jl_handler_t *eh)
 // * We leave a try block through normal control flow
 // * An exception causes a nonlocal jump to the catch block. In this case
 //   there's additional cleanup required, eg pushing the exception stack.
-JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh)
+JL_DLLEXPORT void jl_eh_restore_state(jl_task_t *ct, jl_handler_t *eh)
 {
-    jl_task_t *ct = jl_current_task;
 #ifdef _OS_WINDOWS_
     if (ct->ptls->needs_resetstkoflw) {
         _resetstkoflw();
@@ -297,27 +295,40 @@ JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh)
     }
 }
 
-JL_DLLEXPORT void jl_pop_handler(int n)
+JL_DLLEXPORT void jl_eh_restore_state_noexcept(jl_task_t *ct, jl_handler_t *eh)
+{
+    ct->eh = eh->prev;
+    ct->ptls->defer_signal = eh->defer_signal; // optional, but certain try-finally (in stream.jl) may be slightly harder to write without this
+}
+
+JL_DLLEXPORT void jl_pop_handler(jl_task_t *ct, int n)
+{
+    if (__unlikely(n <= 0))
+        return;
+    jl_handler_t *eh = ct->eh;
+    while (--n > 0)
+        eh = eh->prev;
+    jl_eh_restore_state(ct, eh);
+}
+
+JL_DLLEXPORT void jl_pop_handler_noexcept(jl_task_t *ct, int n)
 {
-    jl_task_t *ct = jl_current_task;
     if (__unlikely(n <= 0))
         return;
     jl_handler_t *eh = ct->eh;
     while (--n > 0)
         eh = eh->prev;
-    jl_eh_restore_state(eh);
+    jl_eh_restore_state_noexcept(ct, eh);
 }
 
-JL_DLLEXPORT size_t jl_excstack_state(void) JL_NOTSAFEPOINT
+JL_DLLEXPORT size_t jl_excstack_state(jl_task_t *ct) JL_NOTSAFEPOINT
 {
-    jl_task_t *ct = jl_current_task;
     jl_excstack_t *s = ct->excstack;
     return s ? s->top : 0;
 }
 
-JL_DLLEXPORT void jl_restore_excstack(size_t state) JL_NOTSAFEPOINT
+JL_DLLEXPORT void jl_restore_excstack(jl_task_t *ct, size_t state) JL_NOTSAFEPOINT
 {
-    jl_task_t *ct = jl_current_task;
     jl_excstack_t *s = ct->excstack;
     if (s) {
         assert(s->top >= state);
@@ -332,28 +343,27 @@ static void jl_copy_excstack(jl_excstack_t *dest, jl_excstack_t *src) JL_NOTSAFE
     dest->top = src->top;
 }
 
-static void jl_reserve_excstack(jl_task_t* task, jl_excstack_t **stack JL_REQUIRE_ROOTED_SLOT,
+static void jl_reserve_excstack(jl_task_t *ct, jl_excstack_t **stack JL_REQUIRE_ROOTED_SLOT,
                                 size_t reserved_size)
 {
     jl_excstack_t *s = *stack;
     if (s && s->reserved_size >= reserved_size)
         return;
     size_t bufsz = sizeof(jl_excstack_t) + sizeof(uintptr_t)*reserved_size;
-    jl_task_t *ct = jl_current_task;
     jl_excstack_t *new_s = (jl_excstack_t*)jl_gc_alloc_buf(ct->ptls, bufsz);
     new_s->top = 0;
     new_s->reserved_size = reserved_size;
     if (s)
         jl_copy_excstack(new_s, s);
     *stack = new_s;
-    jl_gc_wb(task, new_s);
+    jl_gc_wb(ct, new_s);
 }
 
-void jl_push_excstack(jl_task_t* task, jl_excstack_t **stack JL_REQUIRE_ROOTED_SLOT JL_ROOTING_ARGUMENT,
+void jl_push_excstack(jl_task_t *ct, jl_excstack_t **stack JL_REQUIRE_ROOTED_SLOT JL_ROOTING_ARGUMENT,
                       jl_value_t *exception JL_ROOTED_ARGUMENT,
                       jl_bt_element_t *bt_data, size_t bt_size)
 {
-    jl_reserve_excstack(task, stack, (*stack ? (*stack)->top : 0) + bt_size + 2);
+    jl_reserve_excstack(ct, stack, (*stack ? (*stack)->top : 0) + bt_size + 2);
     jl_excstack_t *s = *stack;
     jl_bt_element_t *rawstack = jl_excstack_raw(s);
     memcpy(rawstack + s->top, bt_data, sizeof(jl_bt_element_t)*bt_size);
diff --git a/src/scheduler.c b/src/scheduler.c
index 48a56cb00b8ad..1b6a20a36887a 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -110,7 +110,7 @@ void jl_init_threadinginfra(void)
 }
 
 
-void JL_NORETURN jl_finish_task(jl_task_t *t);
+void JL_NORETURN jl_finish_task(jl_task_t *ct);
 
 static inline int may_mark(void) JL_NOTSAFEPOINT
 {
diff --git a/src/signals-mach.c b/src/signals-mach.c
index 5063aa3e8e0d2..56f7c0d7505f4 100644
--- a/src/signals-mach.c
+++ b/src/signals-mach.c
@@ -115,7 +115,7 @@ static void jl_mach_gc_wait(jl_ptls_t ptls2, mach_port_t thread, int16_t tid)
         // Eventually, we should probably release this signal to the original
         // thread, (return KERN_FAILURE instead of KERN_SUCCESS) so that it
         // triggers a SIGSEGV and gets handled by the usual codepath for unix.
-        int8_t gc_state = ptls2->gc_state;
+        int8_t gc_state = jl_atomic_load_acquire(&ptls2->gc_state);
         jl_atomic_store_release(&ptls2->gc_state, JL_GC_STATE_WAITING);
         uintptr_t item = tid | (((uintptr_t)gc_state) << 16);
         arraylist_push(&suspended_threads, (void*)item);
@@ -338,7 +338,7 @@ kern_return_t catch_mach_exception_raise(
     //     jl_throw_in_thread(ptls2, thread, jl_stackovf_exception);
     //     return KERN_SUCCESS;
     // }
-    if (ptls2->gc_state == JL_GC_STATE_WAITING)
+    if (jl_atomic_load_acquire(&ptls2->gc_state) == JL_GC_STATE_WAITING)
         return KERN_FAILURE;
     if (exception == EXC_ARITHMETIC) {
         jl_throw_in_thread(ptls2, thread, jl_diverror_exception);
@@ -363,7 +363,7 @@ kern_return_t catch_mach_exception_raise(
         }
         return KERN_SUCCESS;
     }
-    if (ptls2->current_task->eh == NULL)
+    if (jl_atomic_load_relaxed(&ptls2->current_task)->eh == NULL)
         return KERN_FAILURE;
     jl_value_t *excpt;
     if (is_addr_on_stack(jl_atomic_load_relaxed(&ptls2->current_task), (void*)fault_addr)) {
diff --git a/src/task.c b/src/task.c
index 7c8770530c326..a7250c36832ea 100644
--- a/src/task.c
+++ b/src/task.c
@@ -290,18 +290,17 @@ JL_NO_ASAN static void restore_stack2(jl_task_t *t, jl_ptls_t ptls, jl_task_t *l
 /* Rooted by the base module */
 static _Atomic(jl_function_t*) task_done_hook_func JL_GLOBALLY_ROOTED = NULL;
 
-void JL_NORETURN jl_finish_task(jl_task_t *t)
+void JL_NORETURN jl_finish_task(jl_task_t *ct)
 {
-    jl_task_t *ct = jl_current_task;
     JL_PROBE_RT_FINISH_TASK(ct);
     JL_SIGATOMIC_BEGIN();
-    if (jl_atomic_load_relaxed(&t->_isexception))
-        jl_atomic_store_release(&t->_state, JL_TASK_STATE_FAILED);
+    if (jl_atomic_load_relaxed(&ct->_isexception))
+        jl_atomic_store_release(&ct->_state, JL_TASK_STATE_FAILED);
     else
-        jl_atomic_store_release(&t->_state, JL_TASK_STATE_DONE);
-    if (t->copy_stack) { // early free of stkbuf
-        asan_free_copy_stack(t->stkbuf, t->bufsz);
-        t->stkbuf = NULL;
+        jl_atomic_store_release(&ct->_state, JL_TASK_STATE_DONE);
+    if (ct->copy_stack) { // early free of stkbuf
+        asan_free_copy_stack(ct->stkbuf, ct->bufsz);
+        ct->stkbuf = NULL;
     }
     // ensure that state is cleared
     ct->ptls->in_finalizer = 0;
@@ -315,12 +314,12 @@ void JL_NORETURN jl_finish_task(jl_task_t *t)
             jl_atomic_store_release(&task_done_hook_func, done);
     }
     if (done != NULL) {
-        jl_value_t *args[2] = {done, (jl_value_t*)t};
+        jl_value_t *args[2] = {done, (jl_value_t*)ct};
         JL_TRY {
             jl_apply(args, 2);
         }
         JL_CATCH {
-            jl_no_exc_handler(jl_current_exception(), ct);
+            jl_no_exc_handler(jl_current_exception(ct), ct);
         }
     }
     jl_gc_debug_critical_error();
@@ -688,7 +687,7 @@ JL_DLLEXPORT JL_NORETURN void jl_no_exc_handler(jl_value_t *e, jl_task_t *ct)
     // NULL exception objects are used when rethrowing. we don't have a handler to process
     // the exception stack, so at least report the exception at the top of the stack.
     if (!e)
-        e = jl_current_exception();
+        e = jl_current_exception(ct);
 
     jl_printf((JL_STREAM*)STDERR_FILENO, "fatal: error thrown and no exception handler available.\n");
     jl_static_show((JL_STREAM*)STDERR_FILENO, e);
@@ -721,8 +720,8 @@ JL_DLLEXPORT JL_NORETURN void jl_no_exc_handler(jl_value_t *e, jl_task_t *ct)
         /* The temporary ptls->bt_data is rooted by special purpose code in the\
            GC. This exists only for the purpose of preserving bt_data until we \
            set ptls->bt_size=0 below. */                                       \
-        jl_push_excstack(ct, &ct->excstack, exception,                             \
-                          ptls->bt_data, ptls->bt_size);                       \
+        jl_push_excstack(ct, &ct->excstack, exception,                         \
+                         ptls->bt_data, ptls->bt_size);                        \
         ptls->bt_size = 0;                                                     \
     }                                                                          \
     assert(ct->excstack && ct->excstack->top);                                 \
@@ -1203,7 +1202,7 @@ CFI_NORETURN
             res = jl_apply(&ct->start, 1);
         }
         JL_CATCH {
-            res = jl_current_exception();
+            res = jl_current_exception(ct);
             jl_atomic_store_relaxed(&ct->_isexception, 1);
             goto skip_pop_exception;
         }
diff --git a/src/toplevel.c b/src/toplevel.c
index 8f67a0e1aa3e7..8715a955e7fb2 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -82,7 +82,7 @@ void jl_module_run_initializer(jl_module_t *m)
         }
         else {
             jl_rethrow_other(jl_new_struct(jl_initerror_type, m->name,
-                                           jl_current_exception()));
+                                           jl_current_exception(ct)));
         }
     }
 }
@@ -1081,7 +1081,7 @@ static jl_value_t *jl_parse_eval_all(jl_module_t *module, jl_value_t *text,
             jl_rethrow();
         else
             jl_rethrow_other(jl_new_struct(jl_loaderror_type, filename, result,
-                                           jl_current_exception()));
+                                           jl_current_exception(ct)));
     }
     JL_GC_POP();
     return result;
diff --git a/test/Makefile b/test/Makefile
index e522ec811b167..31f8f20615d7a 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -70,5 +70,6 @@ clangsa:
 clean:
 	@$(MAKE) -C embedding $@ $(EMBEDDING_ARGS)
 	@$(MAKE) -C gcext $@ $(GCEXT_ARGS)
+	@$(MAKE) -C llvmpasses $@
 
 .PHONY: $(TESTS) $(addprefix revise-, $(TESTS)) relocatedepot revise-relocatedepot embedding gcext clangsa clean
diff --git a/test/llvmpasses/Makefile b/test/llvmpasses/Makefile
index 7318d1b67da02..d9fdfa190f3cf 100644
--- a/test/llvmpasses/Makefile
+++ b/test/llvmpasses/Makefile
@@ -30,4 +30,7 @@ update-help:
 	$(JULIAHOME)/deps/srccache/llvm/llvm/utils/update_test_checks.py \
 	--help
 
-.PHONY: $(TESTS) $(addprefix update-,$(TESTS_ll)) check all .
+clean:
+	rm -rf .lit_test_times.txt Output
+
+.PHONY: $(TESTS) $(addprefix update-,$(TESTS_ll)) check all clean update-help .
diff --git a/test/llvmpasses/lower-handlers-addrspaces.ll b/test/llvmpasses/lower-handlers-addrspaces.ll
index 8b85a71705f60..779caf9aa6bdf 100644
--- a/test/llvmpasses/lower-handlers-addrspaces.ll
+++ b/test/llvmpasses/lower-handlers-addrspaces.ll
@@ -8,8 +8,8 @@ target triple = "amdgcn-amd-amdhsa"
 target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7-ni:10:11:12:13"
 
 attributes #1 = { returns_twice }
-declare i32 @julia.except_enter() #1
-declare void @ijl_pop_handler(i32)
+declare i32 @julia.except_enter({}*) #1
+declare void @ijl_pop_handler({}*, i32)
 declare i8**** @julia.ptls_states()
 declare i8**** @julia.get_pgcstack()
 
@@ -19,7 +19,7 @@ top:
 ; CHECK: call void @llvm.lifetime.start
 ; CHECK: call void @ijl_enter_handler
 ; CHECK: setjmp
-    %r = call i32 @julia.except_enter()
+    %r = call i32 @julia.except_enter({}* null)
     %cmp = icmp eq i32 %r, 0
     br i1 %cmp, label %try, label %catch
 try:
@@ -27,7 +27,7 @@ try:
 catch:
     br label %after
 after:
-    call void @ijl_pop_handler(i32 1)
+    call void @ijl_pop_handler({}* null, i32 1)
 ; CHECK: llvm.lifetime.end
     ret void
 }
diff --git a/test/llvmpasses/lower-handlers.ll b/test/llvmpasses/lower-handlers.ll
index a250edddcaa81..2361fb5b84ef6 100644
--- a/test/llvmpasses/lower-handlers.ll
+++ b/test/llvmpasses/lower-handlers.ll
@@ -5,8 +5,8 @@
 ; RUN: opt -enable-new-pm=1 --opaque-pointers=1 --load-pass-plugin=libjulia-codegen%shlibext -passes='function(LowerExcHandlers)' -S %s | FileCheck %s
 
 attributes #1 = { returns_twice }
-declare i32 @julia.except_enter() #1
-declare void @ijl_pop_handler(i32)
+declare i32 @julia.except_enter({}*) #1
+declare void @ijl_pop_handler({}*, i32)
 declare i8**** @julia.ptls_states()
 declare i8**** @julia.get_pgcstack()
 
@@ -16,7 +16,7 @@ top:
 ; CHECK: call void @llvm.lifetime.start
 ; CHECK: call void @ijl_enter_handler
 ; CHECK: setjmp
-    %r = call i32 @julia.except_enter()
+    %r = call i32 @julia.except_enter({}* null)
     %cmp = icmp eq i32 %r, 0
     br i1 %cmp, label %try, label %catch
 try:
@@ -24,7 +24,7 @@ try:
 catch:
     br label %after
 after:
-    call void @ijl_pop_handler(i32 1)
+    call void @ijl_pop_handler({}* null, i32 1)
 ; CHECK: llvm.lifetime.end
     ret void
 }

From 912460bb7418ac68139dde9fdd854314bd32c6cd Mon Sep 17 00:00:00 2001
From: Jeff Fessler <JeffFessler@users.noreply.github.com>
Date: Fri, 15 Mar 2024 00:46:03 -0400
Subject: [PATCH 1139/1315] =?UTF-8?q?Use=20Julian=20way=20`=E2=89=A5(0)`?=
 =?UTF-8?q?=20in=20`findall`=20docs=20(#53740)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I'm pretty sure the manual advises against `x -> x >= 0` :)
---
 base/array.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/array.jl b/base/array.jl
index 76d5981ba8861..ef91077dd6e96 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -2635,7 +2635,7 @@ Dict{Symbol, Int64} with 3 entries:
   :B => -1
   :C => 0
 
-julia> findall(x -> x >= 0, d)
+julia> findall(≥(0), d)
 2-element Vector{Symbol}:
  :A
  :C

From 0b1587c958583030bc3a61114858f04fc6802bfd Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 17 Mar 2024 18:31:25 +0530
Subject: [PATCH 1140/1315] Add an IndexStyle example to the diagind docstring
 (#53757)

Also, simplifies the docstring by splitting the usage into two lines.
---
 stdlib/LinearAlgebra/src/dense.jl | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 91c38e7f0b09b..72c3792d7867c 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -216,13 +216,16 @@ function diagind(::IndexCartesian, m::Integer, n::Integer, k::Integer=0)
 end
 
 """
-    diagind(M::AbstractMatrix, [k::Integer=0,] indstyle::IndexStyle = IndexLinear())
+    diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
+    diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())
 
 An `AbstractRange` giving the indices of the `k`th diagonal of the matrix `M`.
 Optionally, an index style may be specified which determines the type of the range returned.
 If `indstyle isa IndexLinear` (default), this returns an `AbstractRange{Integer}`.
 On the other hand, if `indstyle isa IndexCartesian`, this returns an `AbstractRange{CartesianIndex{2}}`.
 
+If `k` is not provided, it is assumed to be `0` (corresponding to the main diagonal).
+
 See also: [`diag`](@ref), [`diagm`](@ref), [`Diagonal`](@ref).
 
 # Examples
@@ -233,9 +236,15 @@ julia> A = [1 2 3; 4 5 6; 7 8 9]
  4  5  6
  7  8  9
 
-julia> diagind(A,-1)
+julia> diagind(A, -1)
 2:4:6
+
+julia> diagind(A, IndexCartesian())
+StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)
 ```
+
+!!! compat "Julia 1.11"
+     Specifying an `IndexStyle` requires at least Julia 1.11.
 """
 function diagind(A::AbstractMatrix, k::Integer=0, indexstyle::IndexStyle = IndexLinear())
     require_one_based_indexing(A)

From 1d532f4fc798ecaa5bcacfcedc4c36143ad0e68f Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Sun, 17 Mar 2024 16:05:53 +0100
Subject: [PATCH 1141/1315] remove dllexport `jl_arraylen` which no longer
 exists (#53765)

---
 src/julia_internal.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/julia_internal.h b/src/julia_internal.h
index 1137e7a22d47b..79f9e1fba0703 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1429,7 +1429,6 @@ JL_DLLEXPORT jl_value_t *jl_abs_float(jl_value_t *a);
 JL_DLLEXPORT jl_value_t *jl_copysign_float(jl_value_t *a, jl_value_t *b);
 JL_DLLEXPORT jl_value_t *jl_flipsign_int(jl_value_t *a, jl_value_t *b);
 
-JL_DLLEXPORT jl_value_t *jl_arraylen(jl_value_t *a);
 JL_DLLEXPORT jl_value_t *jl_have_fma(jl_value_t *a);
 JL_DLLEXPORT int jl_stored_inline(jl_value_t *el_type);
 JL_DLLEXPORT jl_value_t *(jl_array_data_owner)(jl_array_t *a);

From a9611ce6acde605c4f5ec5787514e181b6b4add6 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Mon, 18 Mar 2024 07:20:55 -0400
Subject: [PATCH 1142/1315] precompilepkgs: fix error path & adjust messaging
 (#53772)

Fixes issues with the handling of errored dependencies
---
 base/precompilation.jl | 52 ++++++++++++++++++++++--------------------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index 211fd61c2be33..80648299b13fd 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -463,10 +463,10 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     was_recompiled = Dict{PkgConfig,Bool}()
     for config in configs
         for pkgid in keys(depsmap)
-            dep_config = (pkgid, config)
-            started[dep_config] = false
-            was_processed[dep_config] = Base.Event()
-            was_recompiled[dep_config] = false
+            pkg_config = (pkgid, config)
+            started[pkg_config] = false
+            was_processed[pkg_config] = Base.Event()
+            was_recompiled[pkg_config] = false
         end
     end
     @debug "precompile: signalling initialized"
@@ -501,9 +501,9 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     for pkg in keys(depsmap)
         if scan_pkg!(pkg, depsmap)
             push!(circular_deps, pkg)
-            for dep_config in keys(was_processed)
+            for pkg_config in keys(was_processed)
                 # notify all to allow skipping
-                dep_config[1] == pkg && notify(was_processed[dep_config])
+                pkg_config[1] == pkg && notify(was_processed[pkg_config])
             end
         end
     end
@@ -552,8 +552,8 @@ function precompilepkgs(pkgs::Vector{String}=String[];
         target = "project"
     end
     nconfig = length(configs)
-    if nconfig > 1 || !isempty(only(configs)[1]) # if multiple configs or only one is not default
-        target *= " for $nconfig compilation configuration$(nconfig > 1 ? "s" : "")..."
+    if nconfig > 1
+        target *= " for $nconfig compilation configurations..."
     else
         target *= "..."
     end
@@ -672,35 +672,35 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                             str = sprint(io -> show_progress(io, bar; termwidth, carriagereturn=false); context=io)
                             print(iostr, Base._truncate_at_width_or_chars(true, str, termwidth), "\n")
                         end
-                        for dep_config in pkg_queue_show
-                            dep, config = dep_config
+                        for pkg_config in pkg_queue_show
+                            dep, config = pkg_config
                             loaded = warn_loaded && haskey(Base.loaded_modules, dep)
                             _name = haskey(exts, dep) ? string(exts[dep], " → ", dep.name) : dep.name
                             name = dep in direct_deps ? _name : string(color_string(_name, :light_black))
-                            if length(configs) > 1
-                                config_str = isempty(config[1]) ? "" : "$(join(config[1], " "))"
+                            if !isempty(config[1])
+                                config_str = "$(join(config[1], " "))"
                                 name *= color_string(" $(config_str)", :light_black)
                             end
-                            line = if dep_config in precomperr_deps
+                            line = if pkg_config in precomperr_deps
                                 string(color_string("  ? ", Base.warn_color()), name)
-                            elseif haskey(failed_deps, dep_config)
+                            elseif haskey(failed_deps, pkg_config)
                                 string(color_string("  ✗ ", Base.error_color()), name)
-                            elseif was_recompiled[dep_config]
+                            elseif was_recompiled[pkg_config]
                                 !loaded && interrupted_or_done.set && continue
                                 loaded || @async begin # keep successful deps visible for short period
                                     sleep(1);
-                                    filter!(!isequal(dep_config), pkg_queue)
+                                    filter!(!isequal(pkg_config), pkg_queue)
                                 end
                                 string(color_string("  ✓ ", loaded ? Base.warn_color() : :green), name)
-                            elseif started[dep_config]
+                            elseif started[pkg_config]
                                 # Offset each spinner animation using the first character in the package name as the seed.
                                 # If not offset, on larger terminal fonts it looks odd that they all sync-up
                                 anim_char = anim_chars[(i + Int(dep.name[1])) % length(anim_chars) + 1]
                                 anim_char_colored = dep in direct_deps ? anim_char : color_string(anim_char, :light_black)
-                                waiting = if haskey(pkgspidlocked, dep_config)
-                                    who_has_lock = pkgspidlocked[dep_config]
+                                waiting = if haskey(pkgspidlocked, pkg_config)
+                                    who_has_lock = pkgspidlocked[pkg_config]
                                     color_string(" Being precompiled by $(who_has_lock)", Base.info_color())
-                                elseif dep_config in taskwaiting
+                                elseif pkg_config in taskwaiting
                                     color_string(" Waiting for background task / IO / timer. Interrupt to inspect", Base.warn_color())
                                 else
                                     ""
@@ -769,8 +769,8 @@ function precompilepkgs(pkgs::Vector{String}=String[];
 
                         _name = haskey(exts, pkg) ? string(exts[pkg], " → ", pkg.name) : pkg.name
                         name = is_direct_dep ? _name : string(color_string(_name, :light_black))
-                        if length(configs) > 1
-                            config_str = isempty(config[1]) ? "" : "$(join(config[1], " "))"
+                        if !isempty(flags)
+                            config_str = "$(join(flags, " "))"
                             name *= color_string(" $(config_str)", :light_black)
                         end
                         !fancyprint && lock(print_lock) do
@@ -809,7 +809,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                             close(std_pipe.in) # close pipe to end the std output monitor
                             wait(t_monitor)
                             if err isa ErrorException || (err isa ArgumentError && startswith(err.msg, "Invalid header in cache file"))
-                                failed_deps[dep_config] = (strict || is_direct_dep) ? string(sprint(showerror, err), "\n", strip(get(std_outputs, pkg, ""))) : ""
+                                failed_deps[pkg_config] = (strict || is_direct_dep) ? string(sprint(showerror, err), "\n", strip(get(std_outputs, pkg, ""))) : ""
                                 delete!(std_outputs, pkg_config) # so it's not shown as warnings, given error report
                                 !fancyprint && lock(print_lock) do
                                     println(io, " "^9, color_string("  ✗ ", Base.error_color()), name)
@@ -907,9 +907,11 @@ function precompilepkgs(pkgs::Vector{String}=String[];
         quick_exit && return
         err_str = ""
         n_direct_errs = 0
-        for (dep, err) in failed_deps
+        for (pkg_config, err) in failed_deps
+            dep, config = pkg_config
             if strict || (dep in direct_deps)
-                err_str = string(err_str, "\n$dep\n\n$err", (n_direct_errs > 0 ? "\n" : ""))
+                config_str = isempty(config[1]) ? "" : "$(join(config[1], " ")) "
+                err_str = string(err_str, "\n$(dep.name) $config_str\n\n$err", (n_direct_errs > 0 ? "\n" : ""))
                 n_direct_errs += 1
             end
         end

From 8e67f99678a70b5d9eafe39430f12e296ceaf607 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 18 Mar 2024 17:08:32 -0400
Subject: [PATCH 1143/1315] fix functional assert statements (#53737)

We currently never remove asserts but I still think this is not a good
practice.
---
 base/loading.jl             | 8 ++++----
 base/pkgid.jl               | 3 ++-
 base/threadingconstructs.jl | 6 ++++--
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index 774aa22bdacbd..883e980b4000a 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -3770,7 +3770,7 @@ function precompile(@nospecialize(argt::Type), m::Method)
     return precompile(mi)
 end
 
-@assert precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), Nothing))
-@assert precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), String))
-@assert precompile(create_expr_cache, (PkgId, String, String, String, typeof(_concrete_dependencies), Cmd, IO, IO))
-@assert precompile(create_expr_cache, (PkgId, String, String, Nothing, typeof(_concrete_dependencies), Cmd, IO, IO))
+precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), Nothing)) || @assert false
+precompile(include_package_for_output, (PkgId, String, Vector{String}, Vector{String}, Vector{String}, typeof(_concrete_dependencies), String)) || @assert false
+precompile(create_expr_cache, (PkgId, String, String, String, typeof(_concrete_dependencies), Cmd, IO, IO)) || @assert false
+precompile(create_expr_cache, (PkgId, String, String, Nothing, typeof(_concrete_dependencies), Cmd, IO, IO)) || @assert false
diff --git a/base/pkgid.jl b/base/pkgid.jl
index a3d3ead184bb8..8c776d79a69cb 100644
--- a/base/pkgid.jl
+++ b/base/pkgid.jl
@@ -37,7 +37,8 @@ end
 
 function binunpack(s::String)
     io = IOBuffer(s)
-    @assert read(io, UInt8) === 0x00
+    z = read(io, UInt8)
+    @assert z === 0x00
     uuid = read(io, UInt128)
     name = read(io, String)
     return PkgId(UUID(uuid), name)
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index 56d596958bc7e..60aea04ddba64 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -158,7 +158,8 @@ function threading_run(fun, static)
         else
             # TODO: this should be the current pool (except interactive) if there
             # are ever more than two pools.
-            @assert ccall(:jl_set_task_threadpoolid, Cint, (Any, Int8), t, _sym_to_tpid(:default)) == 1
+            _result = ccall(:jl_set_task_threadpoolid, Cint, (Any, Int8), t, _sym_to_tpid(:default))
+            @assert _result == 1
         end
         tasks[i] = t
         schedule(t)
@@ -410,7 +411,8 @@ function _spawn_set_thrpool(t::Task, tp::Symbol)
     if tpid == -1 || _nthreads_in_pool(tpid) == 0
         tpid = _sym_to_tpid(:default)
     end
-    @assert ccall(:jl_set_task_threadpoolid, Cint, (Any, Int8), t, tpid) == 1
+    _result = ccall(:jl_set_task_threadpoolid, Cint, (Any, Int8), t, tpid)
+    @assert _result == 1
     nothing
 end
 

From 8f76c69cdc3f85c7d29265dfe749f900094a01a3 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 19 Mar 2024 14:42:23 +0900
Subject: [PATCH 1144/1315] minor refactoring on `find_method_matches` (#53741)

So that it can be tested in isolation easier.
---
 base/compiler/abstractinterpretation.jl | 135 ++++++++++++------------
 base/compiler/tfuncs.jl                 |   3 +-
 2 files changed, 71 insertions(+), 67 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 443b4beba315d..ba8f0b6709f8f 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -22,8 +22,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
     end
 
     argtypes = arginfo.argtypes
-    matches = find_matching_methods(𝕃ᵢ, argtypes, atype, method_table(interp),
-        InferenceParams(interp).max_union_splitting, max_methods)
+    matches = find_method_matches(interp, argtypes, atype; max_methods)
     if isa(matches, FailedMethodMatch)
         add_remark!(interp, sv, matches.reason)
         return CallMeta(Any, Any, Effects(), NoCallInfo())
@@ -255,73 +254,79 @@ struct UnionSplitMethodMatches
 end
 any_ambig(m::UnionSplitMethodMatches) = any(any_ambig, m.info.matches)
 
-function find_matching_methods(𝕃::AbstractLattice,
-                               argtypes::Vector{Any}, @nospecialize(atype), method_table::MethodTableView,
-                               max_union_splitting::Int, max_methods::Int)
-    # NOTE this is valid as far as any "constant" lattice element doesn't represent `Union` type
-    if 1 < unionsplitcost(𝕃, argtypes) <= max_union_splitting
-        split_argtypes = switchtupleunion(𝕃, argtypes)
-        infos = MethodMatchInfo[]
-        applicable = Any[]
-        applicable_argtypes = Vector{Any}[] # arrays like `argtypes`, including constants, for each match
-        valid_worlds = WorldRange()
-        mts = MethodTable[]
-        fullmatches = Bool[]
-        for i in 1:length(split_argtypes)
-            arg_n = split_argtypes[i]::Vector{Any}
-            sig_n = argtypes_to_type(arg_n)
-            mt = ccall(:jl_method_table_for, Any, (Any,), sig_n)
-            mt === nothing && return FailedMethodMatch("Could not identify method table for call")
-            mt = mt::MethodTable
-            matches = findall(sig_n, method_table; limit = max_methods)
-            if matches === nothing
-                return FailedMethodMatch("For one of the union split cases, too many methods matched")
-            end
-            push!(infos, MethodMatchInfo(matches))
-            for m in matches
-                push!(applicable, m)
-                push!(applicable_argtypes, arg_n)
-            end
-            valid_worlds = intersect(valid_worlds, matches.valid_worlds)
-            thisfullmatch = any(match::MethodMatch->match.fully_covers, matches)
-            found = false
-            for (i, mt′) in enumerate(mts)
-                if mt′ === mt
-                    fullmatches[i] &= thisfullmatch
-                    found = true
-                    break
-                end
-            end
-            if !found
-                push!(mts, mt)
-                push!(fullmatches, thisfullmatch)
-            end
-        end
-        return UnionSplitMethodMatches(applicable,
-                                       applicable_argtypes,
-                                       UnionSplitInfo(infos),
-                                       valid_worlds,
-                                       mts,
-                                       fullmatches)
-    else
-        mt = ccall(:jl_method_table_for, Any, (Any,), atype)
-        if mt === nothing
-            return FailedMethodMatch("Could not identify method table for call")
-        end
+function find_method_matches(interp::AbstractInterpreter, argtypes::Vector{Any}, @nospecialize(atype);
+                             max_union_splitting::Int = InferenceParams(interp).max_union_splitting,
+                             max_methods::Int = InferenceParams(interp).max_methods)
+    if is_union_split_eligible(typeinf_lattice(interp), argtypes, max_union_splitting)
+        return find_union_split_method_matches(interp, argtypes, atype, max_methods)
+    end
+    return find_simple_method_matches(interp, atype, max_methods)
+end
+
+# NOTE this is valid as far as any "constant" lattice element doesn't represent `Union` type
+is_union_split_eligible(𝕃::AbstractLattice, argtypes::Vector{Any}, max_union_splitting::Int) =
+    1 < unionsplitcost(𝕃, argtypes) <= max_union_splitting
+
+function find_union_split_method_matches(interp::AbstractInterpreter, argtypes::Vector{Any},
+                                         @nospecialize(atype), max_methods::Int)
+    split_argtypes = switchtupleunion(typeinf_lattice(interp), argtypes)
+    infos = MethodMatchInfo[]
+    applicable = Any[]
+    applicable_argtypes = Vector{Any}[] # arrays like `argtypes`, including constants, for each match
+    valid_worlds = WorldRange()
+    mts = MethodTable[]
+    fullmatches = Bool[]
+    for i in 1:length(split_argtypes)
+        arg_n = split_argtypes[i]::Vector{Any}
+        sig_n = argtypes_to_type(arg_n)
+        mt = ccall(:jl_method_table_for, Any, (Any,), sig_n)
+        mt === nothing && return FailedMethodMatch("Could not identify method table for call")
         mt = mt::MethodTable
-        matches = findall(atype, method_table; limit = max_methods)
+        matches = findall(sig_n, method_table(interp); limit = max_methods)
         if matches === nothing
-            # this means too many methods matched
-            # (assume this will always be true, so we don't compute / update valid age in this case)
-            return FailedMethodMatch("Too many methods matched")
+            return FailedMethodMatch("For one of the union split cases, too many methods matched")
+        end
+        push!(infos, MethodMatchInfo(matches))
+        for m in matches
+            push!(applicable, m)
+            push!(applicable_argtypes, arg_n)
+        end
+        valid_worlds = intersect(valid_worlds, matches.valid_worlds)
+        thisfullmatch = any(match::MethodMatch->match.fully_covers, matches)
+        found = false
+        for (i, mt′) in enumerate(mts)
+            if mt′ === mt
+                fullmatches[i] &= thisfullmatch
+                found = true
+                break
+            end
         end
-        fullmatch = any(match::MethodMatch->match.fully_covers, matches)
-        return MethodMatches(matches.matches,
-                             MethodMatchInfo(matches),
-                             matches.valid_worlds,
-                             mt,
-                             fullmatch)
+        if !found
+            push!(mts, mt)
+            push!(fullmatches, thisfullmatch)
+        end
+    end
+    info = UnionSplitInfo(infos)
+    return UnionSplitMethodMatches(
+        applicable, applicable_argtypes, info, valid_worlds, mts, fullmatches)
+end
+
+function find_simple_method_matches(interp::AbstractInterpreter, @nospecialize(atype), max_methods::Int)
+    mt = ccall(:jl_method_table_for, Any, (Any,), atype)
+    if mt === nothing
+        return FailedMethodMatch("Could not identify method table for call")
+    end
+    mt = mt::MethodTable
+    matches = findall(atype, method_table(interp); limit = max_methods)
+    if matches === nothing
+        # this means too many methods matched
+        # (assume this will always be true, so we don't compute / update valid age in this case)
+        return FailedMethodMatch("Too many methods matched")
     end
+    info = MethodMatchInfo(matches)
+    fullmatch = any(match::MethodMatch->match.fully_covers, matches)
+    return MethodMatches(
+        matches.matches, info, matches.valid_worlds, mt, fullmatch)
 end
 
 """
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index b817c2af9c49c..d697ec56bf55f 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -3019,8 +3019,7 @@ function abstract_applicable(interp::AbstractInterpreter, argtypes::Vector{Any},
     isvarargtype(argtypes[2]) && return CallMeta(Bool, Any, EFFECTS_UNKNOWN, NoCallInfo())
     argtypes = argtypes[2:end]
     atype = argtypes_to_type(argtypes)
-    matches = find_matching_methods(typeinf_lattice(interp), argtypes, atype, method_table(interp),
-        InferenceParams(interp).max_union_splitting, max_methods)
+    matches = find_method_matches(interp, argtypes, atype; max_methods)
     if isa(matches, FailedMethodMatch)
         rt = Bool # too many matches to analyze
     else

From 2775c9a0dc42436fb4c6013c3037eaad335a7bd3 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Tue, 19 Mar 2024 04:20:16 -0400
Subject: [PATCH 1145/1315] Fix handling of virtual exit node in `PostDomTree`
 (#53739)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is an alternative to https://github.com/JuliaLang/julia/pull/53642

The `dom_edges()` for an exit block in the CFG are empty when computing
the PostDomTree so the loop below this may not actually run. In that
case, the right semidominator is the ancestor from the DFSTree, which is
the "virtual" -1 block.

This resolves half of the issue in
https://github.com/JuliaLang/julia/issues/53613:
```julia
julia> let code = Any[
               # block 1
               GotoIfNot(Argument(2), 3),
               # block 2
               ReturnNode(Argument(3)),
               # block 3 (we should visit this block)
               Expr(:call, throw, "potential throw"),
               ReturnNode(), # unreachable
           ]
           ir = make_ircode(code; slottypes=Any[Any,Bool,Bool])
           visited = BitSet()
           @test !Core.Compiler.visit_conditional_successors(CC.LazyPostDomtree(ir), ir, #=bb=#1) do succ::Int
               push!(visited, succ)
               return false
           end
           @test 2 ∈ visited
           @test 3 ∈ visited
       end
Test Passed
```

This needs some tests (esp. since I don't think we have any DomTree
tests at all right now), but otherwise should be good to go.
---
 base/compiler/ssair/domtree.jl | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/base/compiler/ssair/domtree.jl b/base/compiler/ssair/domtree.jl
index dfe0550d7a06d..bbae3a4d8c0fc 100644
--- a/base/compiler/ssair/domtree.jl
+++ b/base/compiler/ssair/domtree.jl
@@ -345,10 +345,7 @@ function SNCA!(domtree::GenericDomTree{IsPostDom}, blocks::Vector{BasicBlock}, m
     ancestors = copy(D.to_parent_pre)
     relevant_blocks = IsPostDom ? (1:max_pre) : (2:max_pre)
     for w::PreNumber in reverse(relevant_blocks)
-        # LLVM initializes this to the parent, the paper initializes this to
-        # `w`, but it doesn't really matter (the parent is a predecessor, so at
-        # worst we'll discover it below). Save a memory reference here.
-        semi_w = typemax(PreNumber)
+        semi_w = ancestors[w]
         last_linked = PreNumber(w + 1)
         for v ∈ dom_edges(domtree, blocks, D.from_pre[w])
             # For the purpose of the domtree, ignore virtual predecessors into

From 9df47f238c44a92ca0962efbc4c42173d0c5ce54 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 19 Mar 2024 20:10:11 +0900
Subject: [PATCH 1146/1315] post-opt: add more test cases for
 `visit_conditional_successors` (#53642)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit fixes the first problem that was found while digging into
JuliaLang/julia#53613. It turns out that the post-domtree constructed
from regular `IRCode` doesn't work for visiting conditional successors
for post-opt analysis in cases like:
```julia
julia> let code = Any[
               # block 1
               GotoIfNot(Argument(2), 3),
               # block 2
               ReturnNode(Argument(3)),
               # block 3 (we should visit this block)
               Expr(:call, throw, "potential throw"),
               ReturnNode(), # unreachable
           ]
           ir = make_ircode(code; slottypes=Any[Any,Bool,Bool])
           visited = BitSet()
           @test !Core.Compiler.visit_conditional_successors(CC.LazyPostDomtree(ir), ir, #=bb=#1) do succ::Int
               push!(visited, succ)
               return false
           end
           @test 2 ∉ visited
           @test 3 ∈ visited
       end
Test Failed at REPL[14]:16
  Expression: 2 ∉ visited
   Evaluated: 2 ∉ BitSet([2])
```

This might mean that we need to fix on the `postdominates` end, but for
now, this commit tries to get around it by using the augmented post
domtree in `visit_conditional_successors`. Since the augmented post
domtree is enforced to have a single return, we can keep using the
current `postdominates` to fix the issue.

However, this commit isn't enough to fix the NeuralNetworkReachability
segfault as reported in #53613, and we need to tackle the second issue
reported there too
(https://github.com/JuliaLang/julia/issues/53613#issuecomment-1983243419).
---
 base/compiler/optimize.jl |  2 ++
 test/compiler/effects.jl  | 10 ++++++
 test/compiler/ssair.jl    | 66 ++++++++++++++++++++++++++++++++-------
 3 files changed, 67 insertions(+), 11 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 81b025e588f7f..325ba3eca0170 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -527,6 +527,8 @@ function any_stmt_may_throw(ir::IRCode, bb::Int)
     return false
 end
 
+visit_conditional_successors(callback, ir::IRCode, bb::Int) = # used for test
+    visit_conditional_successors(callback, LazyPostDomtree(ir), ir, bb)
 function visit_conditional_successors(callback, lazypostdomtree::LazyPostDomtree, ir::IRCode, bb::Int)
     visited = BitSet((bb,))
     worklist = Int[bb]
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index fa70c8de9d853..cdf797fb2a77b 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -1387,3 +1387,13 @@ let; Base.Experimental.@force_compile; func52843(); end
 # https://github.com/JuliaLang/julia/issues/53508
 @test !Core.Compiler.is_consistent(Base.infer_effects(getindex, (UnitRange{Int},Int)))
 @test !Core.Compiler.is_consistent(Base.infer_effects(getindex, (Base.OneTo{Int},Int)))
+
+@noinline f53613() = @assert isdefined(@__MODULE__, :v53613)
+g53613() = f53613()
+@test !Core.Compiler.is_consistent(Base.infer_effects(f53613))
+@test_broken !Core.Compiler.is_consistent(Base.infer_effects(g53613))
+@test_throws AssertionError f53613()
+@test_throws AssertionError g53613()
+global v53613 = nothing
+@test f53613() === nothing
+@test g53613() === nothing
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 70a2ab4a3acd9..9082d1640e3be 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -233,35 +233,79 @@ let code = Any[
 end
 
 # issue #37919
-let ci = code_lowered(()->@isdefined(_not_def_37919_), ())[1]
+let ci = only(code_lowered(()->@isdefined(_not_def_37919_), ()))
     ir = Core.Compiler.inflate_ir(ci)
     @test Core.Compiler.verify_ir(ir) === nothing
 end
 
 let code = Any[
         # block 1
-        GotoIfNot(Argument(2), 4),
+        GotoIfNot(Argument(2), 4)
         # block 2
-        GotoNode(3),
+        Expr(:call, throw, "potential throw")
+        ReturnNode() # unreachable
         # block 3
-        Expr(:call, throw, "potential throw"),
+        ReturnNode(Argument(3))
+    ]
+    ir = make_ircode(code; slottypes=Any[Any,Bool,Int])
+    visited = BitSet()
+    @test !Core.Compiler.visit_conditional_successors(ir, #=bb=#1) do succ::Int
+        push!(visited, succ)
+        return false
+    end
+    @test 2 ∈ visited
+    @test 3 ∈ visited
+    oc = Core.OpaqueClosure(ir)
+    @test oc(false, 1) == 1
+    @test_throws "potential throw" oc(true, 1)
+end
+
+let code = Any[
+        # block 1
+        GotoIfNot(Argument(2), 3)
+        # block 2
+        ReturnNode(Argument(3))
+        # block 3
+        Expr(:call, throw, "potential throw")
+        ReturnNode() # unreachable
+    ]
+    ir = make_ircode(code; slottypes=Any[Any,Bool,Int])
+    visited = BitSet()
+    @test !Core.Compiler.visit_conditional_successors(ir, #=bb=#1) do succ::Int
+        push!(visited, succ)
+        return false
+    end
+    @test 2 ∈ visited
+    @test 3 ∈ visited
+    oc = Core.OpaqueClosure(ir)
+    @test oc(true, 1) == 1
+    @test_throws "potential throw" oc(false, 1)
+end
+
+let code = Any[
+        # block 1
+        GotoIfNot(Argument(2), 5)
+        # block 2
+        GotoNode(3)
+        # block 3
+        Expr(:call, throw, "potential throw")
+        ReturnNode()
         # block 4
-        Expr(:call, Core.Intrinsics.add_int, Argument(3), Argument(4)),
-        GotoNode(6),
+        Expr(:call, Core.Intrinsics.add_int, Argument(3), Argument(4))
+        GotoNode(7)
         # block 5
-        ReturnNode(SSAValue(4))
+        ReturnNode(SSAValue(5))
     ]
     ir = make_ircode(code; slottypes=Any[Any,Bool,Int,Int])
-    lazypostdomtree = Core.Compiler.LazyPostDomtree(ir)
     visited = BitSet()
-    @test !Core.Compiler.visit_conditional_successors(lazypostdomtree, ir, #=bb=#1) do succ::Int
+    @test !Core.Compiler.visit_conditional_successors(ir, #=bb=#1) do succ::Int
         push!(visited, succ)
         return false
     end
     @test 2 ∈ visited
     @test 3 ∈ visited
-    @test 4 ∉ visited
-    @test 5 ∉ visited
+    @test 4 ∈ visited
+    @test 5 ∈ visited
     oc = Core.OpaqueClosure(ir)
     @test oc(false, 1, 1) == 2
     @test_throws "potential throw" oc(true, 1, 1)

From 5c891de4bc718c27a52bba306411bd10bc1bd71c Mon Sep 17 00:00:00 2001
From: Kiran Pamnany <kpamnany@users.noreply.github.com>
Date: Tue, 19 Mar 2024 10:39:25 -0400
Subject: [PATCH 1147/1315] Remove some duplicates from emitted compilation
 traces (#53774)

When multiple threads concurrently attempt to compile the same method,
`--trace-compile` could emit duplicate `precompile` statements. This
small tweak eliminates one source of these duplicates.
---
 src/codegen-stubs.c  | 3 ++-
 src/gf.c             | 4 ++--
 src/jitlayers.cpp    | 7 +++++--
 src/julia_internal.h | 2 +-
 4 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/codegen-stubs.c b/src/codegen-stubs.c
index dda9bbee184a0..e67ae3b75ea76 100644
--- a/src/codegen-stubs.c
+++ b/src/codegen-stubs.c
@@ -43,10 +43,11 @@ JL_DLLEXPORT void jl_generate_fptr_for_unspecialized_fallback(jl_code_instance_t
     jl_atomic_store_release(&unspec->invoke, &jl_fptr_interpret_call);
 }
 
-JL_DLLEXPORT void jl_compile_codeinst_fallback(jl_code_instance_t *unspec)
+JL_DLLEXPORT int jl_compile_codeinst_fallback(jl_code_instance_t *unspec)
 {
     // Do nothing. The caller will notice that we failed to provide a an ->invoke and trigger
     // appropriate fallbacks.
+    return 0;
 }
 
 JL_DLLEXPORT uint32_t jl_get_LLVM_VERSION_fallback(void)
diff --git a/src/gf.c b/src/gf.c
index 53496c8feca58..2bab2b2271e0b 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -2568,12 +2568,12 @@ jl_code_instance_t *jl_compile_method_internal(jl_method_instance_t *mi, size_t
         }
 
         JL_GC_PUSH1(&codeinst);
-        jl_compile_codeinst(codeinst);
+        int did_compile = jl_compile_codeinst(codeinst);
 
         if (jl_atomic_load_relaxed(&codeinst->invoke) == NULL) {
             // Something went wrong. Bail to the fallback path.
             codeinst = NULL;
-        } else {
+        } else if (did_compile) {
             record_precompile_statement(mi);
         }
         JL_GC_POP();
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index b7fb975515eb4..5f9d7f8a3c6cf 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -461,10 +461,11 @@ void jl_extern_c_impl(jl_value_t *declrt, jl_tupletype_t *sigt)
 }
 
 extern "C" JL_DLLEXPORT_CODEGEN
-void jl_compile_codeinst_impl(jl_code_instance_t *ci)
+int jl_compile_codeinst_impl(jl_code_instance_t *ci)
 {
+    int newly_compiled = 0;
     if (jl_atomic_load_relaxed(&ci->invoke) != NULL) {
-        return;
+        return newly_compiled;
     }
     JL_LOCK(&jl_codegen_lock);
     if (jl_atomic_load_relaxed(&ci->invoke) == NULL) {
@@ -472,8 +473,10 @@ void jl_compile_codeinst_impl(jl_code_instance_t *ci)
         uint64_t start = jl_typeinf_timing_begin();
         _jl_compile_codeinst(ci, NULL, *jl_ExecutionEngine->getContext());
         jl_typeinf_timing_end(start, 0);
+        newly_compiled = 1;
     }
     JL_UNLOCK(&jl_codegen_lock); // Might GC
+    return newly_compiled;
 }
 
 extern "C" JL_DLLEXPORT_CODEGEN
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 79f9e1fba0703..dc93e522b0c4d 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -1727,7 +1727,7 @@ JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len);
 #define IR_FLAG_INBOUNDS 0x01
 
 JL_DLLIMPORT void jl_generate_fptr_for_unspecialized(jl_code_instance_t *unspec);
-JL_DLLIMPORT void jl_compile_codeinst(jl_code_instance_t *unspec);
+JL_DLLIMPORT int jl_compile_codeinst(jl_code_instance_t *unspec);
 JL_DLLIMPORT int jl_compile_extern_c(LLVMOrcThreadSafeModuleRef llvmmod, void *params, void *sysimg, jl_value_t *declrt, jl_value_t *sigt);
 
 typedef struct {

From 1c2b9ad0049f8bd23b32ac5d4744898babab7e83 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 19 Mar 2024 17:09:27 -0700
Subject: [PATCH 1148/1315] compileall: Print error on failure (#53770)

This test appears to be failing intermittently on aarch64 darwin, so
stop suppressing any errors that might be happening.
---
 test/compileall.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/compileall.jl b/test/compileall.jl
index 464dea51e4497..914b0fc8a4d9e 100644
--- a/test/compileall.jl
+++ b/test/compileall.jl
@@ -3,7 +3,7 @@
 # with the rest of the tests.
 
 mktempdir() do dir
-    @test success(`$(Base.julia_cmd()) --compile=all --strip-ir --output-o $(dir)/sys.o.a -e 'exit()'`) broken=(Sys.iswindows() && Sys.WORD_SIZE == 32)
+    @test success(pipeline(`$(Base.julia_cmd()) --compile=all --strip-ir --output-o $(dir)/sys.o.a -e 'exit()'`, stderr=stderr)) broken=(Sys.iswindows() && Sys.WORD_SIZE == 32)
     if isfile(joinpath(dir, "sys.o.a"))
         Base.Linking.link_image(joinpath(dir, "sys.o.a"), joinpath(dir, "sys.so"))
         # TODO: Broken on Windows due to

From cc27a7b665c0d27a44b099e77ce291d63a47751d Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Wed, 20 Mar 2024 01:36:10 +0100
Subject: [PATCH 1149/1315] Add two missing whitespaces to error messages
 (#53782)

---
 base/intfuncs.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/intfuncs.jl b/base/intfuncs.jl
index 916cd28a32c6f..f5185b0a9fd17 100644
--- a/base/intfuncs.jl
+++ b/base/intfuncs.jl
@@ -302,12 +302,12 @@ to_power_type(x) = convert(Base._return_type(*, Tuple{typeof(x), typeof(x)}), x)
 @noinline throw_domerr_powbysq(::Integer, p) = throw(DomainError(p, LazyString(
     "Cannot raise an integer x to a negative power ", p, ".",
     "\nMake x or ", p, " a float by adding a zero decimal ",
-    "(e.g., 2.0^", p, " or 2^", float(p), " instead of 2^", p, ")",
+    "(e.g., 2.0^", p, " or 2^", float(p), " instead of 2^", p, ") ",
     "or write 1/x^", -p, ", float(x)^", p, ", x^float(", p, ") or (x//1)^", p, ".")))
 @noinline throw_domerr_powbysq(::AbstractMatrix, p) = throw(DomainError(p, LazyString(
     "Cannot raise an integer matrix x to a negative power ", p, ".",
     "\nMake x a float matrix by adding a zero decimal ",
-    "(e.g., [2.0 1.0;1.0 0.0]^", p, " instead of [2 1;1 0]^", p, ")",
+    "(e.g., [2.0 1.0;1.0 0.0]^", p, " instead of [2 1;1 0]^", p, ") ",
     "or write float(x)^", p, " or Rational.(x)^", p, ".")))
 # The * keyword supports `*=checked_mul` for `checked_pow`
 @assume_effects :terminates_locally function power_by_squaring(x_, p::Integer; mul=*)

From e0bb95aabdd9126cd5c1665e5cb49864c4c32c86 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 19 Mar 2024 20:38:51 -0400
Subject: [PATCH 1150/1315] small changes to make Base more statically
 compileable (#53778)

This makes it easier to fully-statically-type Base and init methods.
The changes are from gb/small-image2.
---
 base/boot.jl                            |  2 +-
 base/compiler/utilities.jl              |  2 --
 base/error.jl                           | 10 +++++-----
 base/errorshow.jl                       |  2 +-
 base/initdefs.jl                        |  4 ++--
 base/iostream.jl                        | 13 ++++++++-----
 base/libuv.jl                           |  6 +++---
 base/loading.jl                         |  7 +++----
 base/reflection.jl                      |  2 ++
 base/show.jl                            |  2 +-
 base/threadingconstructs.jl             |  2 +-
 stdlib/FileWatching/src/FileWatching.jl |  5 +++++
 stdlib/LinearAlgebra/src/blas.jl        |  5 ++---
 13 files changed, 34 insertions(+), 28 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index fc00f571171c9..a3c5c03bdf721 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -769,7 +769,7 @@ function is_top_bit_set(x::Union{Int8,UInt8})
 end
 
 # n.b. This function exists for CUDA to overload to configure error behavior (see #48097)
-throw_inexacterror(args...) = throw(InexactError(args...))
+throw_inexacterror(func::Symbol, to, val) = throw(InexactError(func, to, val))
 
 function check_sign_bit(::Type{To}, x) where {To}
     @inline
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index c2c36920bd574..1f74db620b7f7 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -504,8 +504,6 @@ end
 # options #
 ###########
 
-is_root_module(m::Module) = false
-
 inlining_enabled() = (JLOptions().can_inline == 1)
 
 function coverage_enabled(m::Module)
diff --git a/base/error.jl b/base/error.jl
index fc294b3cb3eb0..07782fce5f52e 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -228,15 +228,15 @@ macro assert(ex, msgs...)
         msg = Main.Base.string(msg)
     else
         # string() might not be defined during bootstrap
-        msg = quote
-            msg = $(Expr(:quote,msg))
-            isdefined(Main, :Base) ? Main.Base.string(msg) :
-                (Core.println(msg); "Error during bootstrap. See stdout.")
-        end
+        msg = :(_assert_tostring($(Expr(:quote,msg))))
     end
     return :($(esc(ex)) ? $(nothing) : throw(AssertionError($msg)))
 end
 
+# this may be overridden in contexts where `string(::Expr)` doesn't work
+_assert_tostring(msg) = isdefined(Main, :Base) ? Main.Base.string(msg) :
+    (Core.println(msg); "Error during bootstrap. See stdout.")
+
 struct ExponentialBackOff
     n::Int
     first_delay::Float64
diff --git a/base/errorshow.jl b/base/errorshow.jl
index abc8083f38266..b06052433ffc4 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -400,7 +400,7 @@ end
 
 #Show an error by directly calling jl_printf.
 #Useful in Base submodule __init__ functions where stderr isn't defined yet.
-function showerror_nostdio(err, msg::AbstractString)
+function showerror_nostdio(@nospecialize(err), msg::AbstractString)
     stderr_stream = ccall(:jl_stderr_stream, Ptr{Cvoid}, ())
     ccall(:jl_printf, Cint, (Ptr{Cvoid},Cstring), stderr_stream, msg)
     ccall(:jl_printf, Cint, (Ptr{Cvoid},Cstring), stderr_stream, ":\n")
diff --git a/base/initdefs.jl b/base/initdefs.jl
index 56c2c0c587272..2b2916fc804ad 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -9,7 +9,7 @@ A string containing the script name passed to Julia from the command line. Note
 script name remains unchanged from within included files. Alternatively see
 [`@__FILE__`](@ref).
 """
-global PROGRAM_FILE = ""
+global PROGRAM_FILE::String = ""
 
 """
     ARGS
@@ -480,7 +480,7 @@ end
 
 ## hook for disabling threaded libraries ##
 
-library_threading_enabled = true
+library_threading_enabled::Bool = true
 const disable_library_threading_hooks = []
 
 function at_disable_library_threading(f)
diff --git a/base/iostream.jl b/base/iostream.jl
index 5d972945e00e0..bea6612ebc220 100644
--- a/base/iostream.jl
+++ b/base/iostream.jl
@@ -292,12 +292,15 @@ function open(fname::String; lock = true,
     if !lock
         s._dolock = false
     end
-    systemerror("opening file $(repr(fname))",
-                ccall(:ios_file, Ptr{Cvoid},
-                      (Ptr{UInt8}, Cstring, Cint, Cint, Cint, Cint),
-                      s.ios, fname, flags.read, flags.write, flags.create, flags.truncate) == C_NULL)
+    if ccall(:ios_file, Ptr{Cvoid},
+             (Ptr{UInt8}, Cstring, Cint, Cint, Cint, Cint),
+             s.ios, fname, flags.read, flags.write, flags.create, flags.truncate) == C_NULL
+        systemerror("opening file \"$fname\"")
+    end
     if flags.append
-        systemerror("seeking to end of file $fname", ccall(:ios_seek_end, Int64, (Ptr{Cvoid},), s.ios) != 0)
+        if ccall(:ios_seek_end, Int64, (Ptr{Cvoid},), s.ios) != 0
+            systemerror("seeking to end of file \"$fname\"")
+        end
     end
     return s
 end
diff --git a/base/libuv.jl b/base/libuv.jl
index 66dfcfb3414ad..35424ad3eda3e 100644
--- a/base/libuv.jl
+++ b/base/libuv.jl
@@ -134,9 +134,9 @@ function uv_asynccb end
 function uv_timercb end
 
 function reinit_stdio()
-    global stdin = init_stdio(ccall(:jl_stdin_stream, Ptr{Cvoid}, ()))
-    global stdout = init_stdio(ccall(:jl_stdout_stream, Ptr{Cvoid}, ()))
-    global stderr = init_stdio(ccall(:jl_stderr_stream, Ptr{Cvoid}, ()))
+    global stdin = init_stdio(ccall(:jl_stdin_stream, Ptr{Cvoid}, ()))::IO
+    global stdout = init_stdio(ccall(:jl_stdout_stream, Ptr{Cvoid}, ()))::IO
+    global stderr = init_stdio(ccall(:jl_stderr_stream, Ptr{Cvoid}, ()))::IO
     opts = JLOptions()
     if opts.color != 0
         have_color = (opts.color == 1)
diff --git a/base/loading.jl b/base/loading.jl
index 883e980b4000a..986efc1e1e5fb 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2205,7 +2205,6 @@ const explicit_loaded_modules = Dict{PkgId,Module}()
 const loaded_modules_order = Vector{Module}()
 const module_keys = IdDict{Module,PkgId}() # the reverse
 
-is_root_module(m::Module) = @lock require_lock haskey(module_keys, m)
 root_module_key(m::Module) = @lock require_lock module_keys[m]
 
 @constprop :none function register_root_module(m::Module)
@@ -3416,9 +3415,9 @@ function check_clone_targets(clone_targets)
 end
 
 # Set by FileWatching.__init__()
-global mkpidlock_hook
-global trymkpidlock_hook
-global parse_pidfile_hook
+global mkpidlock_hook::Any
+global trymkpidlock_hook::Any
+global parse_pidfile_hook::Any
 
 # The preferences hash is only known after precompilation so just assume no preferences.
 # Also ignore the active project, which means that if all other conditions are equal,
diff --git a/base/reflection.jl b/base/reflection.jl
index 446e5825a16cc..39ad62fb1680b 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -20,6 +20,8 @@ Base
 """
 parentmodule(m::Module) = ccall(:jl_module_parent, Ref{Module}, (Any,), m)
 
+is_root_module(m::Module) = parentmodule(m) === m || (isdefined(Main, :Base) && m === Main.Base)
+
 """
     moduleroot(m::Module) -> Module
 
diff --git a/base/show.jl b/base/show.jl
index f7846e316c330..8f52fefdd7152 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1056,7 +1056,7 @@ function show_type_name(io::IO, tn::Core.TypeName)
         # IOContext If :module is not set, default to Main (or current active module).
         # nothing can be used to force printing prefix
         from = get(io, :module, active_module())
-        if isdefined(tn, :module) && (from === nothing || !isvisible(sym, tn.module, from))
+        if isdefined(tn, :module) && (from === nothing || !isvisible(sym, tn.module, from::Module))
             show(io, tn.module)
             print(io, ".")
             if globfunc && !is_id_start_char(first(string(sym)))
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index 60aea04ddba64..acab7cf7b8299 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -79,7 +79,7 @@ function _sym_to_tpid(tp::Symbol)
     elseif tp == :foreign
         return Int8(-1)
     else
-        throw(ArgumentError("Unrecognized threadpool name `$(repr(tp))`"))
+        throw(ArgumentError("Unrecognized threadpool name `$tp`"))
     end
 end
 
diff --git a/stdlib/FileWatching/src/FileWatching.jl b/stdlib/FileWatching/src/FileWatching.jl
index 0ee572ec47d92..0c987ad01c828 100644
--- a/stdlib/FileWatching/src/FileWatching.jl
+++ b/stdlib/FileWatching/src/FileWatching.jl
@@ -468,6 +468,11 @@ function uv_fspollcb(handle::Ptr{Cvoid}, status::Int32, prev::Ptr, curr::Ptr)
     nothing
 end
 
+global uv_jl_pollcb::Ptr{Cvoid}
+global uv_jl_fspollcb::Ptr{Cvoid}
+global uv_jl_fseventscb_file::Ptr{Cvoid}
+global uv_jl_fseventscb_folder::Ptr{Cvoid}
+
 function __init__()
     global uv_jl_pollcb = @cfunction(uv_pollcb, Cvoid, (Ptr{Cvoid}, Cint, Cint))
     global uv_jl_fspollcb = @cfunction(uv_fspollcb, Cvoid, (Ptr{Cvoid}, Cint, Ptr{Cvoid}, Ptr{Cvoid}))
diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 8903aaddcc11b..413b7866c5444 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -159,9 +159,8 @@ function check()
     interface = USE_BLAS64 ? :ilp64 : :lp64
     if !any(lib.interface == interface for lib in config.loaded_libs)
         interfacestr = uppercase(string(interface))
-        @error("No loaded BLAS libraries were built with $(interfacestr) support")
-        println("Quitting.")
-        exit()
+        @error("No loaded BLAS libraries were built with $interfacestr support.")
+        exit(1)
     end
 end
 

From bc7ba3d5c8b2dab1c0e19537739b67c2da902d11 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 19 Mar 2024 23:35:46 -0700
Subject: [PATCH 1151/1315] compiler: Refactor `concrete_eval_invoke` (#53771)

This passes slightly more information into this function (the full
`inst` rather than just the `stmt`) in order to allow external absint to
access additional fields (the flags and the info) if necessary to make
concrete evaluation decisions. It also splits out the actual concrete
evaluation from the part that just maps the `inst` to a CodeInstance.
---
 base/compiler/ssair/irinterp.jl | 43 ++++++++++++++++++---------------
 1 file changed, 24 insertions(+), 19 deletions(-)

diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index cda590b07d23c..f68006ed686b5 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -5,39 +5,44 @@ function collect_limitations!(@nospecialize(typ), ::IRInterpretationState)
     return typ
 end
 
-function concrete_eval_invoke(interp::AbstractInterpreter,
-    inst::Expr, mi::MethodInstance, irsv::IRInterpretationState)
-    world = frame_world(irsv)
-    mi_cache = WorldView(code_cache(interp), world)
-    code = get(mi_cache, mi, nothing)
-    code === nothing && return Pair{Any,Tuple{Bool,Bool}}(nothing, (false, false))
-    argtypes = collect_argtypes(interp, inst.args[2:end], nothing, irsv)
-    argtypes === nothing && return Pair{Any,Tuple{Bool,Bool}}(Bottom, (false, false))
-    effects = decode_effects(code.ipo_purity_bits)
+function concrete_eval_invoke(interp::AbstractInterpreter, ci::CodeInstance, argtypes::Vector{Any}, parent::IRInterpretationState)
+    world = frame_world(parent)
+    effects = decode_effects(ci.ipo_purity_bits)
     if (is_foldable(effects) && is_all_const_arg(argtypes, #=start=#1) &&
         (is_nonoverlayed(interp) || is_nonoverlayed(effects)))
         args = collect_const_args(argtypes, #=start=#1)
-        value = let world = get_inference_world(interp)
-            try
-                Core._call_in_world_total(world, args...)
-            catch
-                return Pair{Any,Tuple{Bool,Bool}}(Bottom, (false, is_noub(effects)))
-            end
+        value = try
+            Core._call_in_world_total(world, args...)
+        catch
+            return Pair{Any,Tuple{Bool,Bool}}(Bottom, (false, is_noub(effects)))
         end
         return Pair{Any,Tuple{Bool,Bool}}(Const(value), (true, true))
     else
-        if is_constprop_edge_recursed(mi, irsv)
+        mi = ci.def
+        if is_constprop_edge_recursed(mi, parent)
             return Pair{Any,Tuple{Bool,Bool}}(nothing, (is_nothrow(effects), is_noub(effects)))
         end
-        newirsv = IRInterpretationState(interp, code, mi, argtypes, world)
+        newirsv = IRInterpretationState(interp, ci, mi, argtypes, world)
         if newirsv !== nothing
-            newirsv.parent = irsv
+            newirsv.parent = parent
             return ir_abstract_constant_propagation(interp, newirsv)
         end
         return Pair{Any,Tuple{Bool,Bool}}(nothing, (is_nothrow(effects), is_noub(effects)))
     end
 end
 
+function abstract_eval_invoke_inst(interp::AbstractInterpreter, inst::Instruction, irsv::IRInterpretationState)
+    stmt = inst[:stmt]
+    mi = stmt.args[1]::MethodInstance
+    world = frame_world(irsv)
+    mi_cache = WorldView(code_cache(interp), world)
+    code = get(mi_cache, mi, nothing)
+    code === nothing && return Pair{Any,Tuple{Bool,Bool}}(nothing, (false, false))
+    argtypes = collect_argtypes(interp, stmt.args[2:end], nothing, irsv)
+    argtypes === nothing && return Pair{Any,Tuple{Bool,Bool}}(Bottom, (false, false))
+    return concrete_eval_invoke(interp, code, argtypes, irsv)
+end
+
 abstract_eval_ssavalue(s::SSAValue, sv::IRInterpretationState) = abstract_eval_ssavalue(s, sv.ir)
 
 function abstract_eval_phi_stmt(interp::AbstractInterpreter, phi::PhiNode, ::Int, irsv::IRInterpretationState)
@@ -141,7 +146,7 @@ function reprocess_instruction!(interp::AbstractInterpreter, inst::Instruction,
             (; rt, effects) = abstract_eval_statement_expr(interp, stmt, nothing, irsv)
             add_flag!(inst, flags_for_effects(effects))
         elseif head === :invoke
-            rt, (nothrow, noub) = concrete_eval_invoke(interp, stmt, stmt.args[1]::MethodInstance, irsv)
+            rt, (nothrow, noub) = abstract_eval_invoke_inst(interp, inst, irsv)
             if nothrow
                 add_flag!(inst, IR_FLAG_NOTHROW)
             end

From a30feec5094f040c3e19834acd8e4129b1433056 Mon Sep 17 00:00:00 2001
From: gitboy16 <82724369+gitboy16@users.noreply.github.com>
Date: Wed, 20 Mar 2024 22:07:33 +0000
Subject: [PATCH 1152/1315] Update LICENSE.md - update copyright years (#53758)

---
 LICENSE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LICENSE.md b/LICENSE.md
index d4125f4fba221..da8b6920491cc 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2009-2023: Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors: https://github.com/JuliaLang/julia/contributors
+Copyright (c) 2009-2024: Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors: https://github.com/JuliaLang/julia/contributors
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

From 55afecccffe5f981443ee8b1b139133b2a7c1f81 Mon Sep 17 00:00:00 2001
From: "John M. Kuhn" <jmkuhn@users.noreply.github.com>
Date: Wed, 20 Mar 2024 18:10:23 -0400
Subject: [PATCH 1153/1315] Printf: don't zero pad Inf or NaN (#53785)

We currently have
```
julia> @sprintf("%07f", -Inf)
"-000Inf"

julia> @sprintf("%07f", NaN)
"0000NaN"
```

With this PR
```
julia> @sprintf("%07f", -Inf)
"   -Inf"

julia> @sprintf("%07f", NaN)
"    NaN"
```
which is the same as Julia 1.5.4 and agrees with the C standard.
---
 stdlib/Printf/src/Printf.jl    | 2 +-
 stdlib/Printf/test/runtests.jl | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/stdlib/Printf/src/Printf.jl b/stdlib/Printf/src/Printf.jl
index 860ef3610f728..9b636d1180598 100644
--- a/stdlib/Printf/src/Printf.jl
+++ b/stdlib/Printf/src/Printf.jl
@@ -654,7 +654,7 @@ const __BIG_FLOAT_MAX__ = 8192
         else
             # right aligned
             n = width - (newpos - pos)
-            if zero
+            if zero && isfinite(x)
                 ex = (arg < 0 || (plus | space)) + (T <: Union{Val{'a'}, Val{'A'}} ? 2 : 0)
                 so = pos + ex
                 len = (newpos - pos) - ex
diff --git a/stdlib/Printf/test/runtests.jl b/stdlib/Printf/test/runtests.jl
index f00d7abe362c5..abe547c00ed0d 100644
--- a/stdlib/Printf/test/runtests.jl
+++ b/stdlib/Printf/test/runtests.jl
@@ -116,12 +116,15 @@ end
     @test (Printf.@sprintf "%+f" Inf) == "+Inf"
     @test (Printf.@sprintf "% f" Inf) == " Inf"
     @test (Printf.@sprintf "% #f" Inf) == " Inf"
+    @test (Printf.@sprintf "%07f" Inf) == "    Inf"
     @test (Printf.@sprintf "%f" -Inf) == "-Inf"
     @test (Printf.@sprintf "%+f" -Inf) == "-Inf"
+    @test (Printf.@sprintf "%07f" -Inf) == "   -Inf"
     @test (Printf.@sprintf "%f" NaN) == "NaN"
     @test (Printf.@sprintf "%+f" NaN) == "+NaN"
     @test (Printf.@sprintf "% f" NaN) == " NaN"
     @test (Printf.@sprintf "% #f" NaN) == " NaN"
+    @test (Printf.@sprintf "%07f" NaN) == "    NaN"
     @test (Printf.@sprintf "%e" big"Inf") == "Inf"
     @test (Printf.@sprintf "%e" big"NaN") == "NaN"
 
@@ -169,12 +172,15 @@ end
     @test (Printf.@sprintf "%+e" Inf) == "+Inf"
     @test (Printf.@sprintf "% e" Inf) == " Inf"
     @test (Printf.@sprintf "% #e" Inf) == " Inf"
+    @test (Printf.@sprintf "%07e" Inf) == "    Inf"
     @test (Printf.@sprintf "%e" -Inf) == "-Inf"
     @test (Printf.@sprintf "%+e" -Inf) == "-Inf"
+    @test (Printf.@sprintf "%07e" -Inf) == "   -Inf"
     @test (Printf.@sprintf "%e" NaN) == "NaN"
     @test (Printf.@sprintf "%+e" NaN) == "+NaN"
     @test (Printf.@sprintf "% e" NaN) == " NaN"
     @test (Printf.@sprintf "% #e" NaN) == " NaN"
+    @test (Printf.@sprintf "%07e" NaN) == "    NaN"
     @test (Printf.@sprintf "%e" big"Inf") == "Inf"
     @test (Printf.@sprintf "%e" big"NaN") == "NaN"
 

From 72b1c9e24101183a6bad20b71f8212a5342933f9 Mon Sep 17 00:00:00 2001
From: Lasse Peters <lasse.peters@mailbox.org>
Date: Thu, 21 Mar 2024 03:55:02 +0100
Subject: [PATCH 1154/1315] Document LazyString in performance tips (#53779)

Does what it says. Doc-changes only.

Recent motivating example: https://github.com/FluxML/Flux.jl/issues/2399
---
 doc/src/manual/performance-tips.md | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/doc/src/manual/performance-tips.md b/doc/src/manual/performance-tips.md
index a3e9ab1b8739e..1b7e2e76c722b 100644
--- a/doc/src/manual/performance-tips.md
+++ b/doc/src/manual/performance-tips.md
@@ -1239,6 +1239,34 @@ versus:
 println(file, f(a), f(b))
 ```
 
+## Avoid eager string materialization
+
+In settings where a string representation of an object is only needed
+conditionally (e.g. in error paths of functions or conditional warnings such as
+deprecations), it is advisable to avoid the overhead of eagerly materializing
+the string. Since Julia 1.8, this can be achieved via
+[`LazyString`](@ref) and the corresponding string macro [`@lazy_str`](@ref).
+
+For example, instead of:
+
+```julia
+Base.depwarn("`foo` is deprecated for type $(typeof(x))", :bar)
+```
+
+use:
+
+```julia
+Base.depwarn(lazy"`foo` is deprecated for type $(typeof(x))", :bar)
+```
+
+or the equivalent macro-free version:
+
+```julia
+Base.depwarn(LazyString("`foo` is deprecated for type ", typeof(x)), :bar)
+```
+
+Through this approach, the interpolated string will only be constructed when it is actually displayed.
+
 ## Optimize network I/O during parallel execution
 
 When executing a remote function in parallel:

From 8e8b533229e2554a83741ade6398e2ec02dff6e0 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 21 Mar 2024 12:14:52 +0900
Subject: [PATCH 1155/1315] minor followups on recent `CodeInstance` refactors
 (#53581)

- ~~simplifies the signature of `transform_result_for_cache`~~
- ~~make `jl_uncompress_ir` take `MethodInstance` instead of
`CodeInstance`
  and simplifies the inlining algorithm~~
- renames of `codeinst::CodeInstace` objects
- removal of dead code
---
 base/compiler/inferencestate.jl | 10 +++----
 base/compiler/typeinfer.jl      | 46 +++++++++++++++------------------
 base/compiler/utilities.jl      | 18 +++++--------
 base/reflection.jl              |  5 +++-
 4 files changed, 36 insertions(+), 43 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 31bc8d4e20105..0102f042ba2ba 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -803,18 +803,18 @@ mutable struct IRInterpretationState
 end
 
 function IRInterpretationState(interp::AbstractInterpreter,
-    code::CodeInstance, mi::MethodInstance, argtypes::Vector{Any}, world::UInt)
-    @assert code.def === mi
-    src = @atomic :monotonic code.inferred
+    codeinst::CodeInstance, mi::MethodInstance, argtypes::Vector{Any}, world::UInt)
+    @assert codeinst.def === mi "method instance is not synced with code instance"
+    src = @atomic :monotonic codeinst.inferred
     if isa(src, String)
-        src = _uncompressed_ir(code, src)
+        src = _uncompressed_ir(codeinst, src)
     else
         isa(src, CodeInfo) || return nothing
     end
     method_info = MethodInfo(src)
     ir = inflate_ir(src, mi)
     return IRInterpretationState(interp, method_info, ir, mi, argtypes, world,
-                                 code.min_world, code.max_world)
+                                 codeinst.min_world, codeinst.max_world)
 end
 
 # AbsIntState
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 4b6525f886888..b77d2e83d5780 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -230,13 +230,6 @@ function finish!(interp::AbstractInterpreter, caller::InferenceState)
     if opt isa OptimizationState
         result.src = opt = ir_to_codeinf!(opt)
     end
-    if opt isa CodeInfo
-        caller.src = opt
-    else
-        # In this case `caller.src` is invalid for clients (such as `typeinf_ext`) to use
-        # but that is what's permitted by `caller.cache_mode`.
-        # This is hopefully unreachable from such clients using `NativeInterpreter`.
-    end
     return nothing
 end
 
@@ -277,7 +270,7 @@ function is_result_constabi_eligible(result::InferenceResult)
     return isa(result_type, Const) && is_foldable_nothrow(result.ipo_effects) && is_inlineable_constant(result_type.val)
 end
 function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
-        can_discard_trees::Bool=may_discard_trees(interp))
+                      can_discard_trees::Bool=may_discard_trees(interp))
     local const_flags::Int32
     result_type = result.result
     @assert !(result_type === nothing || result_type isa LimitedAccuracy)
@@ -351,13 +344,13 @@ function transform_result_for_cache(interp::AbstractInterpreter,
     return result.src
 end
 
-function maybe_compress_codeinfo(interp::AbstractInterpreter, linfo::MethodInstance, ci::CodeInfo,
-        can_discard_trees::Bool=may_discard_trees(interp))
-    def = linfo.def
+function maybe_compress_codeinfo(interp::AbstractInterpreter, mi::MethodInstance, ci::CodeInfo,
+                                 can_discard_trees::Bool=may_discard_trees(interp))
+    def = mi.def
     isa(def, Method) || return ci # don't compress toplevel code
     cache_the_tree = true
     if can_discard_trees
-        cache_the_tree = is_inlineable(ci) || isa_compileable_sig(linfo.specTypes, linfo.sparam_vals, def)
+        cache_the_tree = is_inlineable(ci) || isa_compileable_sig(mi.specTypes, mi.sparam_vals, def)
     end
     if cache_the_tree
         if may_compress(interp)
@@ -576,13 +569,13 @@ function finish(me::InferenceState, interp::AbstractInterpreter)
         # annotate fulltree with type information,
         # either because we are the outermost code, or we might use this later
         type_annotate!(interp, me)
-        doopt = (me.cache_mode != CACHE_MODE_NULL || me.parent !== nothing)
-        # Disable the optimizer if we've already determined that there's nothing for
-        # it to do.
-        if may_discard_trees(interp) && is_result_constabi_eligible(me.result)
-            doopt = false
-        end
-        if doopt && may_optimize(interp)
+        mayopt = may_optimize(interp)
+        doopt = mayopt &&
+                # disable optimization if we don't use this later
+                (me.cache_mode != CACHE_MODE_NULL || me.parent !== nothing) &&
+                # disable optimization if we've already obtained very accurate result
+                !result_is_constabi(interp, me.result, mayopt)
+        if doopt
             me.result.src = OptimizationState(me, interp)
         else
             me.result.src = me.src # for reflection etc.
@@ -952,7 +945,8 @@ function codeinstance_for_const_with_code(interp::AbstractInterpreter, code::Cod
         code.relocatability, src.debuginfo)
 end
 
-result_is_constabi(interp::AbstractInterpreter, run_optimizer::Bool, result::InferenceResult) =
+result_is_constabi(interp::AbstractInterpreter, result::InferenceResult,
+                   run_optimizer::Bool=may_optimize(interp)) =
     run_optimizer && may_discard_trees(interp) && is_result_constabi_eligible(result)
 
 # compute an inferred AST and return type
@@ -965,7 +959,7 @@ function typeinf_code(interp::AbstractInterpreter, mi::MethodInstance, run_optim
     frame = typeinf_frame(interp, mi, run_optimizer)
     frame === nothing && return nothing, Any
     is_inferred(frame) || return nothing, Any
-    if result_is_constabi(interp, run_optimizer, frame.result)
+    if result_is_constabi(interp, frame.result, run_optimizer)
         rt = frame.result.result::Const
         return codeinfo_for_const(interp, frame.linfo, rt.val), widenconst(rt)
     end
@@ -1095,7 +1089,8 @@ function ci_meets_requirement(code::CodeInstance, source_mode::UInt8, ci_is_cach
     return false
 end
 
-_uncompressed_ir(ci::Core.CodeInstance, s::String) = ccall(:jl_uncompress_ir, Any, (Any, Any, Any), ci.def.def::Method, ci, s)::CodeInfo
+_uncompressed_ir(codeinst::CodeInstance, s::String) =
+    ccall(:jl_uncompress_ir, Ref{CodeInfo}, (Any, Any, Any), codeinst.def.def::Method, codeinst, s)
 
 # compute (and cache) an inferred AST and return type
 function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance, source_mode::UInt8)
@@ -1143,9 +1138,10 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance, source_mod
     # Inference result is not cacheable or is was cacheable, but we do not want to
     # store the source in the cache, but the caller wanted it anyway (e.g. for reflection).
     # We construct a new CodeInstance for it that is not part of the cache hierarchy.
-    code = CodeInstance(interp, result, can_discard_trees=(
-        source_mode != SOURCE_MODE_FORCE_SOURCE && source_mode != SOURCE_MODE_FORCE_SOURCE_UNCACHED &&
-        is_result_constabi_eligible(result)))
+    can_discard_trees = source_mode ≠ SOURCE_MODE_FORCE_SOURCE &&
+                        source_mode ≠ SOURCE_MODE_FORCE_SOURCE_UNCACHED &&
+                        is_result_constabi_eligible(result)
+    code = CodeInstance(interp, result; can_discard_trees)
 
     # If the caller cares about the code and this is constabi, still use our synthesis function
     # anyway, because we will have not finished inferring the code inside the CodeInstance once
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 1f74db620b7f7..1e002f8dad5a6 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -127,29 +127,23 @@ function get_staged(mi::MethodInstance, world::UInt)
     end
 end
 
-function retrieve_code_info(linfo::MethodInstance, world::UInt)
-    def = linfo.def
-    if !isa(def, Method)
-        return linfo.uninferred
-    end
-    c = nothing
-    if isdefined(def, :generator)
-        # user code might throw errors – ignore them
-        c = get_staged(linfo, world)
-    end
+function retrieve_code_info(mi::MethodInstance, world::UInt)
+    def = mi.def
+    isa(def, Method) || return mi.uninferred
+    c = isdefined(def, :generator) ? get_staged(mi, world) : nothing
     if c === nothing && isdefined(def, :source)
         src = def.source
         if src === nothing
             # can happen in images built with --strip-ir
             return nothing
         elseif isa(src, String)
-            c = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), def, C_NULL, src)
+            c = ccall(:jl_uncompress_ir, Ref{CodeInfo}, (Any, Ptr{Cvoid}, Any), def, C_NULL, src)
         else
             c = copy(src::CodeInfo)
         end
     end
     if c isa CodeInfo
-        c.parent = linfo
+        c.parent = mi
         return c
     end
     return nothing
diff --git a/base/reflection.jl b/base/reflection.jl
index 39ad62fb1680b..63909b4159877 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1324,9 +1324,12 @@ uncompressed_ir(m::Method) = isdefined(m, :source) ? _uncompressed_ir(m) :
                              error("Code for this Method is not available.")
 function _uncompressed_ir(m::Method)
     s = m.source
-    s isa String && (s = ccall(:jl_uncompress_ir, Any, (Any, Ptr{Cvoid}, Any), m, C_NULL, s))
+    if s isa String
+        s = ccall(:jl_uncompress_ir, Ref{CodeInfo}, (Any, Ptr{Cvoid}, Any), m, C_NULL, s)
+    end
     return s::CodeInfo
 end
+
 # for backwards compat
 const uncompressed_ast = uncompressed_ir
 const _uncompressed_ast = _uncompressed_ir

From 09400e4f5c3e31ba528c2dbcf8e1ccef2a66ce3d Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Thu, 21 Mar 2024 13:10:08 +0100
Subject: [PATCH 1156/1315] Switch LLVM codegen of Ptr{T} to an actual pointer
 type. (#53687)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR switches our code generation for `Ptr{T}` from `i64` to an
actual LLVM pointer type (`ptr` when using opaque pointers, an untyped
`i8*` otherwise). The main motivation is to simplify `llvmcall` usage
(doing away with the `inttoptr`/`ptrtoint` conversions), and also make
it possible to simply use `ccall` to call intrinsics with `Ptr`-valued
arguments (where we currently always need `llvmcall` for converting to
an actual pointer).

Changing codegen like this is a breaking change for `llvmcall` users,
but I've added backwards compatibility and a deprecation warning.

Before:

```llvm
julia> @code_llvm pointer([])
define i64 @julia_pointer_1542(ptr noundef nonnull align 8 dereferenceable(24) %"x::Array") #0 {
top:
; ┌ @ pointer.jl:65 within `cconvert`
   %0 = load ptr, ptr %"x::Array", align 8
; └
; ┌ @ pointer.jl:90 within `unsafe_convert`
; │┌ @ pointer.jl:30 within `convert`
    %bitcast_coercion = ptrtoint ptr %0 to i64
    ret i64 %bitcast_coercion
; └└
}
```

After:

```llvm
julia> @code_llvm pointer([])
define ptr @julia_pointer_3880(ptr noundef nonnull align 8 dereferenceable(24) %"x::Array") #0 {
top:
; ┌ @ pointer.jl:65 within `cconvert`
   %0 = load ptr, ptr %"x::Array", align 8
; └
; ┌ @ pointer.jl:90 within `unsafe_convert`
; │┌ @ pointer.jl:30 within `convert`
    ret ptr %0
; └└
}
```

This also simplifies "real code", e.g., when `ccall` converts an Array
to a pointer, resulting in some more optimization opportunities.
---
 NEWS.md                        |   5 +
 base/atomics.jl                |  12 +-
 base/compiler/tfuncs.jl        |   7 +-
 base/pointer.jl                |   4 +-
 base/task.jl                   |   3 +-
 src/ccall.cpp                  | 214 ++++++++++++++++++++++++---------
 src/cgutils.cpp                |   2 +
 src/codegen.cpp                |   4 +-
 src/intrinsics.cpp             |  67 +++++++----
 src/intrinsics.h               |   5 +-
 src/llvm-remove-addrspaces.cpp |   9 +-
 src/runtime_intrinsics.c       |  18 ++-
 12 files changed, 253 insertions(+), 97 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 695427d7eba8e..72b4629fe4174 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -26,6 +26,11 @@ Language changes
 Compiler/Runtime improvements
 -----------------------------
 
+- Generated LLVM IR now uses actual pointer types instead of passing pointers as integers.
+  This affects `llvmcall`: Inline LLVM IR should be updated to use `i8*` or `ptr` instead of
+  `i32` or `i64`, and remove unneeded `ptrtoint`/`inttoptr` conversions. For compatibility,
+  IR with integer pointers is still supported, but generates a deprecation warning. ([#53687])
+
 Command-line option changes
 ---------------------------
 
diff --git a/base/atomics.jl b/base/atomics.jl
index dde981b8c0e6a..e6f3a5654cbf7 100644
--- a/base/atomics.jl
+++ b/base/atomics.jl
@@ -364,13 +364,13 @@ for typ in atomictypes
     irt = "$ilt, $ilt*"
     @eval getindex(x::Atomic{$typ}) =
         GC.@preserve x llvmcall($"""
-                 %ptr = inttoptr i$WORD_SIZE %0 to $lt*
+                 %ptr = bitcast i8* %0 to $lt*
                  %rv = load atomic $rt %ptr acquire, align $(gc_alignment(typ))
                  ret $lt %rv
                  """, $typ, Tuple{Ptr{$typ}}, unsafe_convert(Ptr{$typ}, x))
     @eval setindex!(x::Atomic{$typ}, v::$typ) =
         GC.@preserve x llvmcall($"""
-                 %ptr = inttoptr i$WORD_SIZE %0 to $lt*
+                 %ptr = bitcast i8* %0 to $lt*
                  store atomic $lt %1, $lt* %ptr release, align $(gc_alignment(typ))
                  ret void
                  """, Cvoid, Tuple{Ptr{$typ}, $typ}, unsafe_convert(Ptr{$typ}, x), v)
@@ -379,7 +379,7 @@ for typ in atomictypes
     if typ <: Integer
         @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
             GC.@preserve x llvmcall($"""
-                     %ptr = inttoptr i$WORD_SIZE %0 to $lt*
+                     %ptr = bitcast i8* %0 to $lt*
                      %rs = cmpxchg $lt* %ptr, $lt %1, $lt %2 acq_rel acquire
                      %rv = extractvalue { $lt, i1 } %rs, 0
                      ret $lt %rv
@@ -388,7 +388,7 @@ for typ in atomictypes
     else
         @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
             GC.@preserve x llvmcall($"""
-                     %iptr = inttoptr i$WORD_SIZE %0 to $ilt*
+                     %iptr = bitcast i8* %0 to $ilt*
                      %icmp = bitcast $lt %1 to $ilt
                      %inew = bitcast $lt %2 to $ilt
                      %irs = cmpxchg $ilt* %iptr, $ilt %icmp, $ilt %inew acq_rel acquire
@@ -411,7 +411,7 @@ for typ in atomictypes
         if typ <: Integer
             @eval $fn(x::Atomic{$typ}, v::$typ) =
                 GC.@preserve x llvmcall($"""
-                         %ptr = inttoptr i$WORD_SIZE %0 to $lt*
+                         %ptr = bitcast i8* %0 to $lt*
                          %rv = atomicrmw $rmw $lt* %ptr, $lt %1 acq_rel
                          ret $lt %rv
                          """, $typ, Tuple{Ptr{$typ}, $typ}, unsafe_convert(Ptr{$typ}, x), v)
@@ -419,7 +419,7 @@ for typ in atomictypes
             rmwop === :xchg || continue
             @eval $fn(x::Atomic{$typ}, v::$typ) =
                 GC.@preserve x llvmcall($"""
-                         %iptr = inttoptr i$WORD_SIZE %0 to $ilt*
+                         %iptr = bitcast i8* %0 to $ilt*
                          %ival = bitcast $lt %1 to $ilt
                          %irv = atomicrmw $rmw $ilt* %iptr, $ilt %ival acq_rel
                          %rv = bitcast $ilt %irv to $lt
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index d697ec56bf55f..090be7e91fad9 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -184,8 +184,6 @@ add_tfunc(sdiv_int, 2, 2, math_tfunc, 20)
 add_tfunc(udiv_int, 2, 2, math_tfunc, 20)
 add_tfunc(srem_int, 2, 2, math_tfunc, 20)
 add_tfunc(urem_int, 2, 2, math_tfunc, 20)
-add_tfunc(add_ptr, 2, 2, math_tfunc, 1)
-add_tfunc(sub_ptr, 2, 2, math_tfunc, 1)
 add_tfunc(neg_float, 1, 1, math_tfunc, 1)
 add_tfunc(add_float, 2, 2, math_tfunc, 2)
 add_tfunc(sub_float, 2, 2, math_tfunc, 2)
@@ -662,6 +660,9 @@ function pointer_eltype(@nospecialize(ptr))
     return Any
 end
 
+@nospecs function pointerarith_tfunc(𝕃::AbstractLattice, ptr, offset)
+    return ptr
+end
 @nospecs function pointerref_tfunc(𝕃::AbstractLattice, a, i, align)
     return pointer_eltype(a)
 end
@@ -705,6 +706,8 @@ end
     end
     return ccall(:jl_apply_cmpswap_type, Any, (Any,), T) where T
 end
+add_tfunc(add_ptr, 2, 2, pointerarith_tfunc, 1)
+add_tfunc(sub_ptr, 2, 2, pointerarith_tfunc, 1)
 add_tfunc(pointerref, 3, 3, pointerref_tfunc, 4)
 add_tfunc(pointerset, 4, 4, pointerset_tfunc, 5)
 add_tfunc(atomic_fence, 1, 1, atomic_fence_tfunc, 4)
diff --git a/base/pointer.jl b/base/pointer.jl
index 2f67c8a6757cb..494e87996355c 100644
--- a/base/pointer.jl
+++ b/base/pointer.jl
@@ -313,8 +313,8 @@ isless(x::Ptr{T}, y::Ptr{T}) where {T} = x < y
 <(x::Ptr,  y::Ptr) = UInt(x) < UInt(y)
 -(x::Ptr,  y::Ptr) = UInt(x) - UInt(y)
 
-+(x::Ptr, y::Integer) = oftype(x, add_ptr(UInt(x), (y % UInt) % UInt))
--(x::Ptr, y::Integer) = oftype(x, sub_ptr(UInt(x), (y % UInt) % UInt))
++(x::Ptr, y::Integer) = add_ptr(x, (y % UInt) % UInt)
+-(x::Ptr, y::Integer) = sub_ptr(x, (y % UInt) % UInt)
 +(x::Integer, y::Ptr) = y + x
 
 unsigned(x::Ptr) = UInt(x)
diff --git a/base/task.jl b/base/task.jl
index 2b758d342b169..90f74441c7fbd 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -154,8 +154,7 @@ const _state_index = findfirst(==(:_state), fieldnames(Task))
 @eval function load_state_acquire(t)
     # TODO: Replace this by proper atomic operations when available
     @GC.preserve t llvmcall($("""
-        %ptr = inttoptr i$(Sys.WORD_SIZE) %0 to i8*
-        %rv = load atomic i8, i8* %ptr acquire, align 8
+        %rv = load atomic i8, i8* %0 acquire, align 8
         ret i8 %rv
         """), UInt8, Tuple{Ptr{UInt8}},
         Ptr{UInt8}(pointer_from_objref(t) + fieldoffset(Task, _state_index)))
diff --git a/src/ccall.cpp b/src/ccall.cpp
index 53714cebcbe2a..2d4343a00a2a5 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -616,7 +616,7 @@ static void interpret_symbol_arg(jl_codectx_t &ctx, native_sym_arg_t &out, jl_va
             emit_cpointercheck(ctx, arg1, errmsg);
         }
         arg1 = update_julia_type(ctx, arg1, (jl_value_t*)jl_voidpointer_type);
-        jl_ptr = emit_unbox(ctx, ctx.types().T_size, arg1, (jl_value_t*)jl_voidpointer_type);
+        jl_ptr = emit_unbox(ctx, ctx.types().T_ptr, arg1, (jl_value_t*)jl_voidpointer_type);
     }
     else {
         out.gcroot = ptr;
@@ -696,7 +696,7 @@ static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t narg
     else {
         rt = (jl_value_t*)jl_voidpointer_type;
     }
-    Type *lrt = ctx.types().T_size;
+    Type *lrt = ctx.types().T_ptr;
     assert(lrt == julia_type_to_llvm(ctx, rt));
 
     interpret_symbol_arg(ctx, sym, args[1], /*ccall=*/false, false);
@@ -723,7 +723,6 @@ static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t narg
         }
         else /*if (ctx.emission_context.imaging) */{
             res = runtime_sym_lookup(ctx, cast<PointerType>(getInt8PtrTy(ctx.builder.getContext())), sym.f_lib, NULL, sym.f_name, ctx.f);
-            res = ctx.builder.CreatePtrToInt(res, lrt);
         }
     }
 
@@ -814,18 +813,13 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
     JL_TYPECHK(llvmcall, type, rt);
     JL_TYPECHK(llvmcall, type, at);
 
-    // Generate arguments
-    std::string arguments;
-    raw_string_ostream argstream(arguments);
-    jl_svec_t *tt = ((jl_datatype_t*)at)->parameters;
-    jl_value_t *rtt = rt;
+    // Determine argument types
+    //
+    // Semantics for arguments are as follows:
+    // If the argument type is immutable (including bitstype), we pass the loaded llvm value
+    // type. Otherwise we pass a pointer to a jl_value_t.
+    jl_svec_t *tt = ((jl_datatype_t *)at)->parameters;
     size_t nargt = jl_svec_len(tt);
-
-    /*
-     * Semantics for arguments are as follows:
-     * If the argument type is immutable (including bitstype), we pass the loaded llvm value
-     * type. Otherwise we pass a pointer to a jl_value_t.
-     */
     SmallVector<llvm::Type*, 0> argtypes;
     SmallVector<Value *, 8> argvals(nargt);
     for (size_t i = 0; i < nargt; ++i) {
@@ -846,45 +840,87 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
         argvals[i] = llvm_type_rewrite(ctx, v, t, issigned);
     }
 
+    // Determine return type
+    jl_value_t *rtt = rt;
     bool retboxed;
     Type *rettype = julia_type_to_llvm(ctx, rtt, &retboxed);
 
     // Make sure to find a unique name
     std::string ir_name;
     while (true) {
-        raw_string_ostream(ir_name) << (ctx.f->getName().str()) << "u" << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
+        raw_string_ostream(ir_name)
+            << (ctx.f->getName().str()) << "u"
+            << jl_atomic_fetch_add_relaxed(&globalUniqueGeneratedNames, 1);
         if (jl_Module->getFunction(ir_name) == NULL)
             break;
     }
 
     // generate a temporary module that contains our IR
     std::unique_ptr<Module> Mod;
+    Function *f;
     if (entry == NULL) {
         // we only have function IR, which we should put in a function
 
-        bool first = true;
+        // stringify arguments
+        std::string arguments;
+        raw_string_ostream argstream(arguments);
         for (SmallVector<Type *, 0>::iterator it = argtypes.begin(); it != argtypes.end(); ++it) {
-            if (!first)
+            if (it != argtypes.begin())
                 argstream << ",";
-            else
-                first = false;
             (*it)->print(argstream);
             argstream << " ";
         }
 
+        // stringify return type
         std::string rstring;
         raw_string_ostream rtypename(rstring);
         rettype->print(rtypename);
-        std::map<uint64_t,std::string> localDecls;
 
+        // generate IR function definition
         std::string ir_string;
         raw_string_ostream ir_stream(ir_string);
-        ir_stream << "; Number of arguments: " << nargt << "\n"
-        << "define "<<rtypename.str()<<" @\"" << ir_name << "\"("<<argstream.str()<<") {\n"
-        << jl_string_data(ir) << "\n}";
+        ir_stream << "define " << rtypename.str() << " @\"" << ir_name << "\"("
+                  << argstream.str() << ") {\n"
+                  << jl_string_data(ir) << "\n}";
 
         SMDiagnostic Err = SMDiagnostic();
         Mod = parseAssemblyString(ir_stream.str(), Err, ctx.builder.getContext());
+
+        // backwards compatibility: support for IR with integer pointers
+        if (!Mod) {
+            std::string compat_arguments;
+            raw_string_ostream compat_argstream(compat_arguments);
+            for (size_t i = 0; i < nargt; ++i) {
+                if (i > 0)
+                    compat_argstream << ",";
+                jl_value_t *tti = jl_svecref(tt, i);
+                Type *t;
+                if (jl_is_cpointer_type(tti))
+                    t = ctx.types().T_size;
+                else
+                    t = argtypes[i];
+                t->print(compat_argstream);
+                compat_argstream << " ";
+            }
+
+            std::string compat_rstring;
+            raw_string_ostream compat_rtypename(compat_rstring);
+            if (jl_is_cpointer_type(rtt))
+                ctx.types().T_size->print(compat_rtypename);
+            else
+                rettype->print(compat_rtypename);
+
+            std::string compat_ir_string;
+            raw_string_ostream compat_ir_stream(compat_ir_string);
+            compat_ir_stream << "define " << compat_rtypename.str() << " @\"" << ir_name
+                             << "\"(" << compat_argstream.str() << ") {\n"
+                             << jl_string_data(ir) << "\n}";
+
+            SMDiagnostic Err = SMDiagnostic();
+            Mod =
+                parseAssemblyString(compat_ir_stream.str(), Err, ctx.builder.getContext());
+        }
+
         if (!Mod) {
             std::string message = "Failed to parse LLVM assembly: \n";
             raw_string_ostream stream(message);
@@ -894,7 +930,7 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
             return jl_cgval_t();
         }
 
-        Function *f = Mod->getFunction(ir_name);
+        f = Mod->getFunction(ir_name);
         f->addFnAttr(Attribute::AlwaysInline);
     }
     else {
@@ -932,21 +968,96 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
             Mod = std::move(ModuleOrErr.get());
         }
 
-        Function *f = Mod->getFunction(jl_string_data(entry));
+        f = Mod->getFunction(jl_string_data(entry));
         if (!f) {
             emit_error(ctx, "Module IR does not contain specified entry function");
             JL_GC_POP();
             return jl_cgval_t();
         }
+        assert(!f->isDeclaration());
         f->setName(ir_name);
+    }
 
-        // verify the function type
-        assert(!f->isDeclaration());
-        assert(f->getReturnType() == rettype);
-        int i = 0;
-        for (SmallVector<Type *, 0>::iterator it = argtypes.begin();
-            it != argtypes.end(); ++it, ++i)
-            assert(*it == f->getFunctionType()->getParamType(i));
+    // backwards compatibility: support for IR with integer pointers
+    bool mismatched_pointers = false;
+    for (size_t i = 0; i < nargt; ++i) {
+        jl_value_t *tti = jl_svecref(tt, i);
+        if (jl_is_cpointer_type(tti) &&
+            !f->getFunctionType()->getParamType(i)->isPointerTy()) {
+            mismatched_pointers = true;
+            break;
+        }
+    }
+    if (mismatched_pointers) {
+        if (jl_options.depwarn) {
+            if (jl_options.depwarn == JL_OPTIONS_DEPWARN_ERROR)
+                jl_error("llvmcall with integer pointers is deprecated, "
+                         "use an actual pointer type instead.");
+
+            // ensure we only depwarn once per method
+            // TODO: lift this into a reusable codegen-level depwarn utility
+            static std::set<jl_method_t*> llvmcall_depwarns;
+            jl_method_t *m = ctx.linfo->def.method;
+            if (llvmcall_depwarns.find(m) == llvmcall_depwarns.end()) {
+                llvmcall_depwarns.insert(m);
+                jl_printf(JL_STDERR,
+                        "WARNING: llvmcall with integer pointers is deprecated.\n"
+                        "Use actual pointers instead, replacing i32 or i64 with i8* or ptr\n"
+                        "in ");
+                jl_static_show(JL_STDERR, (jl_value_t*) ctx.linfo->def.method);
+                jl_printf(JL_STDERR, " at %s\n", ctx.file.str().c_str());
+            }
+        }
+
+        // wrap the function, performing the necessary pointer conversion
+
+        Function *inner = f;
+        inner->setName(ir_name + ".inner");
+
+        FunctionType *wrapper_ft = FunctionType::get(rettype, argtypes, false);
+        Function *wrapper =
+            Function::Create(wrapper_ft, inner->getLinkage(), ir_name, *Mod);
+
+        wrapper->copyAttributesFrom(inner);
+        inner->addFnAttr(Attribute::AlwaysInline);
+
+        BasicBlock *entry = BasicBlock::Create(ctx.builder.getContext(), "", wrapper);
+        IRBuilder<> irbuilder(entry);
+        SmallVector<Value *, 0> wrapper_args;
+        for (size_t i = 0; i < nargt; ++i) {
+            jl_value_t *tti = jl_svecref(tt, i);
+            Value *v = wrapper->getArg(i);
+            if (jl_is_cpointer_type(tti))
+                v = irbuilder.CreatePtrToInt(v, ctx.types().T_size);
+            wrapper_args.push_back(v);
+        }
+        Value *call = irbuilder.CreateCall(inner, wrapper_args);
+        // check if void
+        if (rettype->isVoidTy())
+            irbuilder.CreateRetVoid();
+        else {
+            if (jl_is_cpointer_type(rtt))
+                call = irbuilder.CreateIntToPtr(call, ctx.types().T_ptr);
+            irbuilder.CreateRet(call);
+        }
+
+        f = wrapper;
+    }
+
+    // verify the function type
+    assert(f->getReturnType() == rettype);
+    int i = 0;
+    for (SmallVector<Type *, 0>::iterator it = argtypes.begin(); it != argtypes.end();
+         ++it, ++i) {
+        if (*it != f->getFunctionType()->getParamType(i)) {
+            std::string message;
+            raw_string_ostream stream(message);
+            stream << "Malformed llvmcall: argument " << i + 1 << " type "
+                   << *f->getFunctionType()->getParamType(i)
+                   << " does not match expected argument type " << **it;
+            emit_error(ctx, stream.str());
+            return jl_cgval_t();
+        }
     }
 
     // copy module properties that should always match
@@ -984,7 +1095,7 @@ static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nar
     if (inst->getType() != rettype) {
         std::string message;
         raw_string_ostream stream(message);
-        stream << "llvmcall return type " << *inst->getType()
+        stream << "Malformed llvmcall: return type " << *inst->getType()
                << " does not match declared return type" << *rettype;
         emit_error(ctx, stream.str());
         return jl_cgval_t();
@@ -1462,14 +1573,14 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
     (void)isVa; // prevent compiler warning
     if (is_libjulia_func(jl_value_ptr)) {
         ++CCALL_STAT(jl_value_ptr);
-        assert(retboxed ? lrt == ctx.types().T_prjlvalue : lrt == ctx.types().T_size);
+        assert(retboxed ? lrt == ctx.types().T_prjlvalue : lrt == ctx.types().T_ptr);
         assert(!isVa && !llvmcall && nccallargs == 1);
         jl_value_t *tti = jl_svecref(at, 0);
         Type *largty;
         bool isboxed;
         if (jl_is_abstract_ref_type(tti)) {
             tti = (jl_value_t*)jl_voidpointer_type;
-            largty = ctx.types().T_size;
+            largty = ctx.types().T_ptr;
             isboxed = false;
         }
         else {
@@ -1482,7 +1593,6 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         }
         else {
             retval = emit_unbox(ctx, largty, argv[0], tti);
-            retval = emit_inttoptr(ctx, retval, ctx.types().T_pjlvalue);
         }
         // retval is now an untracked jl_value_t*
         if (retboxed)
@@ -1561,9 +1671,7 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         assert(lrt == ctx.types().T_size);
         assert(!isVa && !llvmcall && nccallargs == 0);
         JL_GC_POP();
-        return mark_or_box_ccall_result(ctx,
-            ctx.builder.CreatePtrToInt(get_current_ptls(ctx), lrt),
-            retboxed, rt, unionall, static_rt);
+        return mark_or_box_ccall_result(ctx, get_current_ptls(ctx), retboxed, rt, unionall, static_rt);
     }
     else if (is_libjulia_func(jl_threadid)) {
         ++CCALL_STAT(jl_threadid);
@@ -1683,21 +1791,20 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
     }
     else if (is_libjulia_func(jl_string_ptr)) {
         ++CCALL_STAT(jl_string_ptr);
-        assert(lrt == ctx.types().T_size);
+        assert(lrt == ctx.types().T_ptr);
         assert(!isVa && !llvmcall && nccallargs == 1);
         auto obj = emit_bitcast(ctx, emit_pointer_from_objref(ctx, boxed(ctx, argv[0])),
                                 ctx.types().T_pprjlvalue);
         // The inbounds gep makes it more clear to LLVM that the resulting value is not
         // a null pointer.
         auto strp = ctx.builder.CreateConstInBoundsGEP1_32(ctx.types().T_prjlvalue, obj, 1);
-        strp = ctx.builder.CreatePtrToInt(strp, ctx.types().T_size);
         setName(ctx.emission_context, strp, "string_ptr");
         JL_GC_POP();
         return mark_or_box_ccall_result(ctx, strp, retboxed, rt, unionall, static_rt);
     }
     else if (is_libjulia_func(jl_symbol_name)) {
         ++CCALL_STAT(jl_symbol_name);
-        assert(lrt == ctx.types().T_size);
+        assert(lrt == ctx.types().T_ptr);
         assert(!isVa && !llvmcall && nccallargs == 1);
         auto obj = emit_bitcast(ctx, emit_pointer_from_objref(ctx, boxed(ctx, argv[0])),
                                 ctx.types().T_pprjlvalue);
@@ -1705,7 +1812,6 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         // a null pointer.
         auto strp = ctx.builder.CreateConstInBoundsGEP1_32(
             ctx.types().T_prjlvalue, obj, (sizeof(jl_sym_t) + sizeof(void*) - 1) / sizeof(void*));
-        strp = ctx.builder.CreatePtrToInt(strp, ctx.types().T_size);
         setName(ctx.emission_context, strp, "symbol_name");
         JL_GC_POP();
         return mark_or_box_ccall_result(ctx, strp, retboxed, rt, unionall, static_rt);
@@ -1750,14 +1856,12 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         const jl_cgval_t &dst = argv[0];
         const jl_cgval_t &src = argv[1];
         const jl_cgval_t &n = argv[2];
-        Value *destp = emit_unbox(ctx, ctx.types().T_size, dst, (jl_value_t*)jl_voidpointer_type);
+        Value *destp = emit_unbox(ctx, ctx.types().T_ptr, dst, (jl_value_t*)jl_voidpointer_type);
 
         ctx.builder.CreateMemCpy(
-                emit_inttoptr(ctx, destp, getInt8PtrTy(ctx.builder.getContext())),
+                destp,
                 MaybeAlign(1),
-                emit_inttoptr(ctx,
-                    emit_unbox(ctx, ctx.types().T_size, src, (jl_value_t*)jl_voidpointer_type),
-                    getInt8PtrTy(ctx.builder.getContext())),
+                emit_unbox(ctx, ctx.types().T_ptr, src, (jl_value_t*)jl_voidpointer_type),
                 MaybeAlign(1),
                 emit_unbox(ctx, ctx.types().T_size, n, (jl_value_t*)jl_ulong_type),
                 false);
@@ -1770,11 +1874,11 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         const jl_cgval_t &dst = argv[0];
         const jl_cgval_t &val = argv[1];
         const jl_cgval_t &n = argv[2];
-        Value *destp = emit_unbox(ctx, ctx.types().T_size, dst, (jl_value_t*)jl_voidpointer_type);
+        Value *destp = emit_unbox(ctx, ctx.types().T_ptr, dst, (jl_value_t*)jl_voidpointer_type);
         Value *val32 = emit_unbox(ctx, getInt32Ty(ctx.builder.getContext()), val, (jl_value_t*)jl_uint32_type);
         Value *val8 = ctx.builder.CreateTrunc(val32, getInt8Ty(ctx.builder.getContext()), "memset_val");
         ctx.builder.CreateMemSet(
-            emit_inttoptr(ctx, destp, getInt8PtrTy(ctx.builder.getContext())),
+            destp,
             val8,
             emit_unbox(ctx, ctx.types().T_size, n, (jl_value_t*)jl_ulong_type),
             MaybeAlign(1)
@@ -1788,14 +1892,12 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
         const jl_cgval_t &dst = argv[0];
         const jl_cgval_t &src = argv[1];
         const jl_cgval_t &n = argv[2];
-        Value *destp = emit_unbox(ctx, ctx.types().T_size, dst, (jl_value_t*)jl_voidpointer_type);
+        Value *destp = emit_unbox(ctx, ctx.types().T_ptr, dst, (jl_value_t*)jl_voidpointer_type);
 
         ctx.builder.CreateMemMove(
-                emit_inttoptr(ctx, destp, getInt8PtrTy(ctx.builder.getContext())),
+                destp,
                 MaybeAlign(0),
-                emit_inttoptr(ctx,
-                    emit_unbox(ctx, ctx.types().T_size, src, (jl_value_t*)jl_voidpointer_type),
-                    getInt8PtrTy(ctx.builder.getContext())),
+                emit_unbox(ctx, ctx.types().T_ptr, src, (jl_value_t*)jl_voidpointer_type),
                 MaybeAlign(0),
                 emit_unbox(ctx, ctx.types().T_size, n, (jl_value_t*)jl_ulong_type),
                 false);
@@ -1999,7 +2101,7 @@ jl_cgval_t function_sig_t::emit_a_ccall(
         ++LiteralCCalls;
         null_pointer_check(ctx, symarg.jl_ptr, nullptr);
         Type *funcptype = PointerType::get(functype, 0);
-        llvmf = emit_inttoptr(ctx, symarg.jl_ptr, funcptype);
+        llvmf = ctx.builder.CreateBitCast(symarg.jl_ptr, funcptype);
     }
     else if (symarg.fptr != NULL) {
         ++LiteralCCalls;
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index b17b174dd8a8d..8385b5682a0bc 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -690,6 +690,8 @@ static Type *bitstype_to_llvm(jl_value_t *bt, LLVMContext &ctxt, bool llvmcall =
         return getDoubleTy(ctxt);
     if (bt == (jl_value_t*)jl_bfloat16_type)
         return getBFloatTy(ctxt);
+    if (jl_is_cpointer_type(bt))
+        return PointerType::get(getInt8Ty(ctxt), 0);
     if (jl_is_llvmpointer_type(bt)) {
         jl_value_t *as_param = jl_tparam1(bt);
         int as;
diff --git a/src/codegen.cpp b/src/codegen.cpp
index cf5122df295eb..2e2afc02080a1 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -283,6 +283,7 @@ extern void _chkstk(void);
 
 // types
 struct jl_typecache_t {
+    Type *T_ptr;
     Type *T_size;
     Type *T_jlvalue;
     Type *T_pjlvalue;
@@ -304,7 +305,7 @@ struct jl_typecache_t {
     bool initialized;
 
     jl_typecache_t() :
-        T_jlvalue(nullptr), T_pjlvalue(nullptr), T_prjlvalue(nullptr),
+        T_ptr(nullptr), T_jlvalue(nullptr), T_pjlvalue(nullptr), T_prjlvalue(nullptr),
         T_ppjlvalue(nullptr), T_pprjlvalue(nullptr),
         T_jlgenericmemory(nullptr), T_jlarray(nullptr), T_pjlarray(nullptr),
         T_jlfunc(nullptr), T_jlfuncparams(nullptr), T_sigatomic(nullptr), T_ppint8(nullptr),
@@ -315,6 +316,7 @@ struct jl_typecache_t {
             return;
         }
         initialized = true;
+        T_ptr = getInt8PtrTy(context);
         T_ppint8 = PointerType::get(getInt8PtrTy(context), 0);
         T_sigatomic = Type::getIntNTy(context, sizeof(sig_atomic_t) * 8);
         T_size = DL.getIntPtrType(context);
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index 3a98850ddca68..c2450d359be45 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -17,6 +17,7 @@ STATISTIC(EmittedRuntimeCalls, "Number of runtime intrinsic calls emitted");
 STATISTIC(EmittedIntrinsics, "Number of intrinsic calls emitted");
 STATISTIC(Emitted_pointerref, "Number of pointerref calls emitted");
 STATISTIC(Emitted_pointerset, "Number of pointerset calls emitted");
+STATISTIC(Emitted_pointerarith, "Number of pointer arithmetic calls emitted");
 STATISTIC(Emitted_atomic_fence, "Number of atomic_fence calls emitted");
 STATISTIC(Emitted_atomic_pointerref, "Number of atomic_pointerref calls emitted");
 STATISTIC(Emitted_atomic_pointerop, "Number of atomic_pointerop calls emitted");
@@ -625,10 +626,14 @@ static jl_cgval_t generic_bitcast(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
             vx = ctx.builder.CreateZExt(vx, llvmt);
         } else if (vxt->isPointerTy() && !llvmt->isPointerTy()) {
             vx = ctx.builder.CreatePtrToInt(vx, llvmt);
-            setName(ctx.emission_context, vx, "bitcast_coercion");
+            if (isa<Instruction>(vx) && !vx->hasName())
+                // CreatePtrToInt may undo an IntToPtr
+                setName(ctx.emission_context, vx, "bitcast_coercion");
         } else if (!vxt->isPointerTy() && llvmt->isPointerTy()) {
             vx = emit_inttoptr(ctx, vx, llvmt);
-            setName(ctx.emission_context, vx, "bitcast_coercion");
+            if (isa<Instruction>(vx) && !vx->hasName())
+                // emit_inttoptr may undo an PtrToInt
+                setName(ctx.emission_context, vx, "bitcast_coercion");
         } else {
             vx = emit_bitcast(ctx, vx, llvmt);
             setName(ctx.emission_context, vx, "bitcast_coercion");
@@ -741,7 +746,8 @@ static jl_cgval_t emit_pointerref(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 
     if (ety == (jl_value_t*)jl_any_type) {
         Value *thePtr = emit_unbox(ctx, ctx.types().T_pprjlvalue, e, e.typ);
-        setName(ctx.emission_context, thePtr, "unbox_any_ptr");
+        if (isa<Instruction>(thePtr) && !thePtr->hasName())
+            setName(ctx.emission_context, thePtr, "unbox_any_ptr");
         LoadInst *load = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, ctx.builder.CreateInBoundsGEP(ctx.types().T_prjlvalue, thePtr, im1), Align(align_nb));
         setName(ctx.emission_context, load, "any_unbox");
         jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_data);
@@ -853,6 +859,34 @@ static jl_cgval_t emit_pointerset(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
     return e;
 }
 
+// ptr + offset
+// ptr - offset
+static jl_cgval_t emit_pointerarith(jl_codectx_t &ctx, intrinsic f,
+                                    ArrayRef<jl_cgval_t> argv)
+{
+    jl_value_t *ptrtyp = argv[0].typ;
+    jl_value_t *offtyp = argv[1].typ;
+    if (!jl_is_cpointer_type(ptrtyp) || offtyp != (jl_value_t *)jl_ulong_type)
+        return emit_runtime_call(ctx, f, argv, argv.size());
+    assert(f == add_ptr || f == sub_ptr);
+
+    Value *ptr = emit_unbox(ctx, ctx.types().T_ptr, argv[0], ptrtyp);
+    Value *off = emit_unbox(ctx, ctx.types().T_size, argv[1], offtyp);
+    if (f == sub_ptr)
+        off = ctx.builder.CreateNeg(off);
+    Value *ans = ctx.builder.CreateGEP(getInt8Ty(ctx.builder.getContext()), ptr, off);
+
+    if (jl_is_concrete_type(ptrtyp)) {
+        return mark_julia_type(ctx, ans, false, ptrtyp);
+    }
+    else {
+        Value *box = emit_allocobj(ctx, (jl_datatype_t *)ptrtyp, true);
+        setName(ctx.emission_context, box, "ptr_box");
+        init_bits_value(ctx, box, ans, ctx.tbaa().tbaa_immut);
+        return mark_julia_type(ctx, box, true, (jl_datatype_t *)ptrtyp);
+    }
+}
+
 static jl_cgval_t emit_atomicfence(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> argv)
 {
     const jl_cgval_t &ord = argv[0];
@@ -1270,6 +1304,13 @@ static jl_cgval_t emit_intrinsic(jl_codectx_t &ctx, intrinsic f, jl_value_t **ar
         ++Emitted_pointerset;
         assert(nargs == 4);
         return emit_pointerset(ctx, argv);
+
+    case add_ptr:
+    case sub_ptr:
+        ++Emitted_pointerarith;
+        assert(nargs == 2);
+        return emit_pointerarith(ctx, f, argv);
+
     case atomic_fence:
         ++Emitted_atomic_fence;
         assert(nargs == 1);
@@ -1437,26 +1478,6 @@ static Value *emit_untyped_intrinsic(jl_codectx_t &ctx, intrinsic f, ArrayRef<Va
     case srem_int: return ctx.builder.CreateSRem(x, y);
     case urem_int: return ctx.builder.CreateURem(x, y);
 
-    // LLVM will not fold ptrtoint+arithmetic+inttoptr to GEP. The reason for this
-    // has to do with alias analysis. When adding two integers, either one of them
-    // could be the pointer base. With getelementptr, it is clear which of the
-    // operands is the pointer base. We also have this information at the julia
-    // level. Thus, to not lose information, we need to have a separate intrinsic
-    // for pointer arithmetic which lowers to getelementptr.
-    case add_ptr: {
-        return ctx.builder.CreatePtrToInt(
-            ctx.builder.CreateGEP(getInt8Ty(ctx.builder.getContext()),
-                emit_inttoptr(ctx, x, getInt8PtrTy(ctx.builder.getContext())), y), t);
-
-    }
-
-    case sub_ptr: {
-        return ctx.builder.CreatePtrToInt(
-            ctx.builder.CreateGEP(getInt8Ty(ctx.builder.getContext()),
-                emit_inttoptr(ctx, x, getInt8PtrTy(ctx.builder.getContext())), ctx.builder.CreateNeg(y)), t);
-
-    }
-
     case neg_float: return math_builder(ctx)().CreateFNeg(x);
     case neg_float_fast: return math_builder(ctx, true)().CreateFNeg(x);
     case add_float: return math_builder(ctx)().CreateFAdd(x, y);
diff --git a/src/intrinsics.h b/src/intrinsics.h
index 805aa914b5366..5b463e3bafe28 100644
--- a/src/intrinsics.h
+++ b/src/intrinsics.h
@@ -12,8 +12,6 @@
     ADD_I(udiv_int, 2) \
     ADD_I(srem_int, 2) \
     ADD_I(urem_int, 2) \
-    ADD_I(add_ptr, 2) \
-    ADD_I(sub_ptr, 2) \
     ADD_I(neg_float, 1) \
     ADD_I(add_float, 2) \
     ADD_I(sub_float, 2) \
@@ -86,6 +84,9 @@
     ADD_I(rint_llvm, 1) \
     ADD_I(sqrt_llvm, 1) \
     ADD_I(sqrt_llvm_fast, 1) \
+    /*  pointer arithmetic */ \
+    ADD_I(add_ptr, 2) \
+    ADD_I(sub_ptr, 2) \
     /*  pointer access */ \
     ADD_I(pointerref, 3) \
     ADD_I(pointerset, 4) \
diff --git a/src/llvm-remove-addrspaces.cpp b/src/llvm-remove-addrspaces.cpp
index e291e47b59b0e..3e3315cd43672 100644
--- a/src/llvm-remove-addrspaces.cpp
+++ b/src/llvm-remove-addrspaces.cpp
@@ -208,7 +208,14 @@ bool RemoveNoopAddrSpaceCasts(Function *F)
                 LLVM_DEBUG(
                         dbgs() << "Removing noop address space cast:\n"
                                << I << "\n");
-                ASC->replaceAllUsesWith(ASC->getOperand(0));
+                if (ASC->getType() == ASC->getOperand(0)->getType()) {
+                    ASC->replaceAllUsesWith(ASC->getOperand(0));
+                } else {
+                    // uncanonicalized addrspacecast; demote to bitcast
+                    llvm::IRBuilder<> builder(ASC);
+                    auto BC = builder.CreateBitCast(ASC->getOperand(0), ASC->getType());
+                    ASC->replaceAllUsesWith(BC);
+                }
                 NoopCasts.push_back(ASC);
             }
         }
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
index ff479a4d30959..9abe9828fb07f 100644
--- a/src/runtime_intrinsics.c
+++ b/src/runtime_intrinsics.c
@@ -1384,10 +1384,8 @@ JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b, jl_value_t *c)
 un_iintrinsic_fast(LLVMNeg, neg, neg_int, u)
 #define add(a,b) a + b
 bi_iintrinsic_fast(LLVMAdd, add, add_int, u)
-bi_iintrinsic_fast(LLVMAdd, add, add_ptr, u)
 #define sub(a,b) a - b
 bi_iintrinsic_fast(LLVMSub, sub, sub_int, u)
-bi_iintrinsic_fast(LLVMSub, sub, sub_ptr, u)
 #define mul(a,b) a * b
 bi_iintrinsic_fast(LLVMMul, mul, mul_int, u)
 #define div(a,b) a / b
@@ -1696,3 +1694,19 @@ JL_DLLEXPORT jl_value_t *jl_have_fma(jl_value_t *typ)
     else
         return jl_false;
 }
+
+JL_DLLEXPORT jl_value_t *jl_add_ptr(jl_value_t *ptr, jl_value_t *offset)
+{
+    JL_TYPECHK(add_ptr, pointer, ptr);
+    JL_TYPECHK(add_ptr, ulong, offset);
+    char *ptrval = (char*)jl_unbox_long(ptr) + jl_unbox_ulong(offset);
+    return jl_new_bits(jl_typeof(ptr), &ptrval);
+}
+
+JL_DLLEXPORT jl_value_t *jl_sub_ptr(jl_value_t *ptr, jl_value_t *offset)
+{
+    JL_TYPECHK(sub_ptr, pointer, ptr);
+    JL_TYPECHK(sub_ptr, ulong, offset);
+    char *ptrval = (char*)jl_unbox_long(ptr) - jl_unbox_ulong(offset);
+    return jl_new_bits(jl_typeof(ptr), &ptrval);
+}

From 52fc79696e0b08fe1793a001daaefd1d91d59f0c Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 21 Mar 2024 20:32:17 -0400
Subject: [PATCH 1157/1315] Add missing GC_POP() in emit_cfunction (#53809)

~~Apparently somewhere in codegen inside `emit_codeinst`some piece of
code is relying on the implicit try catch gcstack restoring. I haven't
got the analyzer working on that file yet (it has hundreds of issues and
it doesn't like C++ code that much + the file is tens of thousands of
lines after includes so it struggles).~~

This fixes the compileall segfault in apple-aarch64 ci.
https://github.com/JuliaLang/julia/issues/53811
---
 src/codegen.cpp | 1 +
 src/rtutils.c   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/codegen.cpp b/src/codegen.cpp
index 2e2afc02080a1..f1b0c570acc33 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -7379,6 +7379,7 @@ static jl_cgval_t emit_cfunction(jl_codectx_t &ctx, jl_value_t *output_type, con
     if (ctx.emission_context.TargetTriple.isAArch64() || ctx.emission_context.TargetTriple.isARM() || ctx.emission_context.TargetTriple.isPPC64()) {
         if (nest) {
             emit_error(ctx, "cfunction: closures are not supported on this platform");
+            JL_GC_POP();
             return jl_cgval_t();
         }
     }
diff --git a/src/rtutils.c b/src/rtutils.c
index b7e7999320100..88109374cf061 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -297,6 +297,7 @@ JL_DLLEXPORT void jl_eh_restore_state(jl_task_t *ct, jl_handler_t *eh)
 
 JL_DLLEXPORT void jl_eh_restore_state_noexcept(jl_task_t *ct, jl_handler_t *eh)
 {
+    assert(ct->gcstack == eh->gcstack && "Incorrect GC usage under try catch");
     ct->eh = eh->prev;
     ct->ptls->defer_signal = eh->defer_signal; // optional, but certain try-finally (in stream.jl) may be slightly harder to write without this
 }

From 6c22dfd3180b82566cc3fce2cea5782623d6e1e9 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 21 Mar 2024 21:04:28 -0400
Subject: [PATCH 1158/1315] Remove fl_julia_current_{file, line} (#53797)

These flisp accessor functions make use of the `jl_filename` and
`jl_lineno` globals. I was looking at removing these globals for
unrelated reasons, when I saw that one of the primary uses was in these
flisp accessor, which appear entirely unnecessary. They are only used to
provide a default for an error message, but the place that puts the
error message into a list to return to julia does actually already have
access to this information, so there's no need for these to look at the
globals.

While we're at it, also add a test for this code path, which was
otherwise unexercised in our test suite.
---
 src/ast.c            | 12 ------------
 src/jlfrontend.scm   |  7 ++++---
 src/julia-syntax.scm |  6 ++----
 test/syntax.jl       | 10 ++++++++++
 4 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/src/ast.c b/src/ast.c
index 8cd483748bc94..d39ee35e807ae 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -215,16 +215,6 @@ static value_t fl_current_module_counter(fl_context_t *fl_ctx, value_t *args, ui
     return fixnum(jl_module_next_counter(ctx->module));
 }
 
-static value_t fl_julia_current_file(fl_context_t *fl_ctx, value_t *args, uint32_t nargs) JL_NOTSAFEPOINT
-{
-    return symbol(fl_ctx, jl_filename);
-}
-
-static value_t fl_julia_current_line(fl_context_t *fl_ctx, value_t *args, uint32_t nargs) JL_NOTSAFEPOINT
-{
-    return fixnum(jl_lineno);
-}
-
 static int jl_is_number(jl_value_t *v)
 {
     jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v);
@@ -257,8 +247,6 @@ static const builtinspec_t julia_flisp_ast_ext[] = {
     { "nothrow-julia-global", fl_nothrow_julia_global },
     { "current-julia-module-counter", fl_current_module_counter },
     { "julia-scalar?", fl_julia_scalar },
-    { "julia-current-file", fl_julia_current_file },
-    { "julia-current-line", fl_julia_current_line },
     { NULL, NULL }
 };
 
diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index b46663c560346..2c5f42eda5ce8 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -32,8 +32,6 @@
 ;; this is overwritten when we run in actual julia
 (define (defined-julia-global v) #f)
 (define (nothrow-julia-global v) #f)
-(define (julia-current-file) 'none)
-(define (julia-current-line) 0)
 
 ;; parser entry points
 
@@ -182,7 +180,10 @@
      ;; Abuse scm_to_julia here to convert arguments to warn. This is meant for
      ;; `Expr`s but should be good enough provided we're only passing simple
      ;; numbers, symbols and strings.
-     ((lowering-warning (lambda lst (set! warnings (cons (cons 'warn lst) warnings)))))
+     ((lowering-warning (lambda (level group warn_file warn_line . lst)
+        (let ((line (if (= warn_line 0) line warn_line))
+              (file (if (eq? warn_file 'none) file warn_file)))
+          (set! warnings (cons (list* 'warn level group (symbol (string file line)) file line lst) warnings))))))
      (let ((thunk (if stmt
                       (expand-to-thunk-stmt- expr file line)
                       (expand-to-thunk- expr file line))))
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index abe8165c42787..f1ae6c90bda6a 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -3241,11 +3241,9 @@
                   (warn-var?! (cadr e) scope)
                   (= *scopewarn-opt* 1))
              (let* ((v    (cadr e))
-                    (loc  (extract-line-file loc))
-                    (line (if (= (car loc) 0) (julia-current-line) (car loc)))
-                    (file (if (eq? (cadr loc) 'none) (julia-current-file) (cadr loc))))
+                    (loc  (extract-line-file loc)))
                (lowering-warning
-                1000 'warn (symbol (string file line)) file line
+                1000 'warn (cadr loc) (car loc)
                 (string "Assignment to `" v "` in soft scope is ambiguous "
                         "because a global variable by the same name exists: "
                         "`" v "` will be treated as a new local. "
diff --git a/test/syntax.jl b/test/syntax.jl
index 9c26ea97594d0..985f5c9000fbe 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -2189,6 +2189,16 @@ end
 end
 @test z28789 == 42
 
+const warn28789 = "Assignment to `s28789` in soft scope is ambiguous because a global variable by the same name exists: "*
+    "`s28789` will be treated as a new local. Disambiguate by using `local s28789` to suppress this warning or "*
+    "`global s28789` to assign to the existing global variable."
+@test_logs (:warn, warn28789) @test_throws UndefVarError @eval begin
+    s28789 = 0
+    for i = 1:10
+        s28789 += i
+    end
+end
+
 # issue #38650, `struct` should always be a hard scope
 f38650() = 0
 @eval begin

From 91455710f38f226e45591203b0d4cd8e392131fd Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 22 Mar 2024 05:37:18 -0400
Subject: [PATCH 1159/1315] Use jl_filename/jl_lineno less (#53799)

I don't like `jl_filename`/`jl_lineno`. They are weird internal state,
and they are also not thread safe, so if different threads are evaling
different things at the same time, line numbers can get confused.

This PR changes the core function `jl_toplevel_eval_flex` to keep track
of its current file/line context on the stack, so at least there is no
confusion within one call to this function.

With this PR and #53797, the global `jl_filename`/`jl_lineno` are used
for three purposes:

1. To initialize the filename/lineno used by lowering from `Core.eval`.
2. To give binding deprecation warnings.
3. For `jl_critical_error`.
4. By humans in the debugger.

I think 3 and 4 are fine, they are exceptional cases. Case 2, I think
could be changed to plumb through locations explicitly,
 but it's a bit annoying, so I didn't tackle it here.
Case 1, I think can probably just be changed to consistently initialize,
and if you want a proper line number, you need to put it in there
explicitly.
However, I didn't change that in this PR, because I think it could be
slightly
 breaking, so should be pkgeval'd.
---
 src/julia_internal.h |  2 +-
 src/toplevel.c       | 73 ++++++++++++++++++++++++++------------------
 test/backtrace.jl    |  9 ++++++
 3 files changed, 53 insertions(+), 31 deletions(-)

diff --git a/src/julia_internal.h b/src/julia_internal.h
index dc93e522b0c4d..7df996d888909 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -790,7 +790,7 @@ JL_DLLEXPORT int jl_datatype_isinlinealloc(jl_datatype_t *ty, int pointerfree);
 int jl_type_equality_is_identity(jl_value_t *t1, jl_value_t *t2) JL_NOTSAFEPOINT;
 
 void jl_eval_global_expr(jl_module_t *m, jl_expr_t *ex, int set_type);
-jl_value_t *jl_toplevel_eval_flex(jl_module_t *m, jl_value_t *e, int fast, int expanded);
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval_flex(jl_module_t *m, jl_value_t *e, int fast, int expanded, const char **toplevel_filename, int *toplevel_lineno);
 
 jl_value_t *jl_eval_global_var(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *e);
 jl_value_t *jl_interpret_opaque_closure(jl_opaque_closure_t *clos, jl_value_t **args, size_t nargs);
diff --git a/src/toplevel.c b/src/toplevel.c
index 8715a955e7fb2..d7d4b04c3e67b 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -203,16 +203,16 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
         }
         // add `eval` function
         form = jl_call_scm_on_ast_and_loc("module-default-defs", (jl_value_t*)name, newm, filename, lineno);
-        jl_toplevel_eval_flex(newm, form, 0, 1);
+        jl_toplevel_eval_flex(newm, form, 0, 1, &filename, &lineno);
         form = NULL;
     }
 
     for (int i = 0; i < jl_array_nrows(exprs); i++) {
         // process toplevel form
         ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
-        form = jl_expand_stmt_with_loc(jl_array_ptr_ref(exprs, i), newm, jl_filename, jl_lineno);
+        form = jl_expand_stmt_with_loc(jl_array_ptr_ref(exprs, i), newm, filename, lineno);
         ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
-        (void)jl_toplevel_eval_flex(newm, form, 1, 1);
+        (void)jl_toplevel_eval_flex(newm, form, 1, 1, &filename, &lineno);
     }
     ct->world_age = last_age;
 
@@ -286,13 +286,13 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
     return (jl_value_t*)newm;
 }
 
-static jl_value_t *jl_eval_dot_expr(jl_module_t *m, jl_value_t *x, jl_value_t *f, int fast)
+static jl_value_t *jl_eval_dot_expr(jl_module_t *m, jl_value_t *x, jl_value_t *f, int fast, const char **toplevel_filename, int *toplevel_lineno)
 {
     jl_task_t *ct = jl_current_task;
     jl_value_t **args;
     JL_GC_PUSHARGS(args, 3);
-    args[1] = jl_toplevel_eval_flex(m, x, fast, 0);
-    args[2] = jl_toplevel_eval_flex(m, f, fast, 0);
+    args[1] = jl_toplevel_eval_flex(m, x, fast, 0, toplevel_filename, toplevel_lineno);
+    args[2] = jl_toplevel_eval_flex(m, f, fast, 0, toplevel_filename, toplevel_lineno);
     if (jl_is_module(args[1])) {
         JL_TYPECHK(getglobal, symbol, args[2]);
         args[0] = jl_eval_global_var((jl_module_t*)args[1], (jl_sym_t*)args[2]);
@@ -666,46 +666,49 @@ static void check_macro_rename(jl_sym_t *from, jl_sym_t *to, const char *keyword
 // Eval `throw(ErrorException(msg)))` in module `m`.
 // Used in `jl_toplevel_eval_flex` instead of `jl_throw` so that the error
 // location in julia code gets into the backtrace.
-static void jl_eval_throw(jl_module_t *m, jl_value_t *exc)
+static void jl_eval_throw(jl_module_t *m, jl_value_t *exc, const char *filename, int lineno)
 {
     jl_value_t *throw_ex = (jl_value_t*)jl_exprn(jl_call_sym, 2);
     JL_GC_PUSH1(&throw_ex);
     jl_exprargset(throw_ex, 0, jl_builtin_throw);
     jl_exprargset(throw_ex, 1, exc);
-    jl_toplevel_eval_flex(m, throw_ex, 0, 0);
+    jl_toplevel_eval_flex(m, throw_ex, 0, 0, &filename, &lineno);
     JL_GC_POP();
 }
 
 // Format error message and call jl_eval
-static void jl_eval_errorf(jl_module_t *m, const char* fmt, ...)
+static void jl_eval_errorf(jl_module_t *m, const char *filename, int lineno, const char* fmt, ...)
 {
     va_list args;
     va_start(args, fmt);
     jl_value_t *exc = jl_vexceptionf(jl_errorexception_type, fmt, args);
     va_end(args);
     JL_GC_PUSH1(&exc);
-    jl_eval_throw(m, exc);
+    jl_eval_throw(m, exc, filename, lineno);
     JL_GC_POP();
 }
 
-jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int fast, int expanded)
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int fast, int expanded, const char **toplevel_filename, int *toplevel_lineno)
 {
     jl_task_t *ct = jl_current_task;
     if (!jl_is_expr(e)) {
         if (jl_is_linenode(e)) {
-            jl_lineno = jl_linenode_line(e);
+            *toplevel_lineno = jl_linenode_line(e);
             jl_value_t *file = jl_linenode_file(e);
             if (file != jl_nothing) {
                 assert(jl_is_symbol(file));
-                jl_filename = jl_symbol_name((jl_sym_t*)file);
+                *toplevel_filename = jl_symbol_name((jl_sym_t*)file);
             }
+            // Not thread safe. For debugging and last resort error messages (jl_critical_error) only.
+            jl_filename = *toplevel_filename;
+            jl_lineno = *toplevel_lineno;
             return jl_nothing;
         }
         if (jl_is_symbol(e)) {
             char *n = jl_symbol_name((jl_sym_t*)e), *n0 = n;
             while (*n == '_') ++n;
             if (*n == 0 && n > n0)
-                jl_eval_errorf(m, "all-underscore identifiers are write-only and their values cannot be used in expressions");
+                jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno, "all-underscore identifiers are write-only and their values cannot be used in expressions");
         }
         return jl_interpret_toplevel_expr_in(m, e, NULL, NULL);
     }
@@ -714,12 +717,12 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
 
     if (ex->head == jl_dot_sym && jl_expr_nargs(ex) != 1) {
         if (jl_expr_nargs(ex) != 2)
-            jl_eval_errorf(m, "syntax: malformed \".\" expression");
+            jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno, "syntax: malformed \".\" expression");
         jl_value_t *lhs = jl_exprarg(ex, 0);
         jl_value_t *rhs = jl_exprarg(ex, 1);
         // only handle `a.b` syntax here, so qualified names can be eval'd in pure contexts
         if (jl_is_quotenode(rhs) && jl_is_symbol(jl_fieldref(rhs, 0))) {
-            return jl_eval_dot_expr(m, lhs, rhs, fast);
+            return jl_eval_dot_expr(m, lhs, rhs, fast, toplevel_filename, toplevel_lineno);
         }
     }
 
@@ -734,7 +737,7 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
     size_t last_age = ct->world_age;
     if (!expanded && jl_needs_lowering(e)) {
         ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
-        ex = (jl_expr_t*)jl_expand_with_loc_warn(e, m, jl_filename, jl_lineno);
+        ex = (jl_expr_t*)jl_expand_with_loc_warn(e, m, *toplevel_filename, *toplevel_lineno);
         ct->world_age = last_age;
     }
     jl_sym_t *head = jl_is_expr(ex) ? ex->head : NULL;
@@ -766,7 +769,8 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
                 }
                 else {
                     if (!jl_is_module(u))
-                        jl_eval_errorf(m, "invalid using path: \"%s\" does not name a module",
+                        jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
+                            "invalid using path: \"%s\" does not name a module",
                                        jl_symbol_name(name));
                     // `using A` and `using A.B` syntax
                     jl_module_using(m, u);
@@ -792,7 +796,8 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
                     continue;
                 }
             }
-            jl_eval_errorf(m, "syntax: malformed \"using\" statement");
+            jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
+                "syntax: malformed \"using\" statement");
         }
         JL_GC_POP();
         return jl_nothing;
@@ -839,7 +844,8 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
                     continue;
                 }
             }
-            jl_eval_errorf(m, "syntax: malformed \"import\" statement");
+            jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
+                "syntax: malformed \"import\" statement");
         }
         JL_GC_POP();
         return jl_nothing;
@@ -849,8 +855,9 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
         for (size_t i = 0; i < jl_array_nrows(ex->args); i++) {
             jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, i);
             if (!jl_is_symbol(name))
-                jl_eval_errorf(m, exp ? "syntax: malformed \"export\" statement" :
-                                        "syntax: malformed \"public\" statement");
+                jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
+                     exp ? "syntax: malformed \"export\" statement" :
+                           "syntax: malformed \"public\" statement");
             jl_module_public(m, name, exp);
         }
         JL_GC_POP();
@@ -883,17 +890,19 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
         jl_value_t *res = jl_nothing;
         int i;
         for (i = 0; i < jl_array_nrows(ex->args); i++) {
-            res = jl_toplevel_eval_flex(m, jl_array_ptr_ref(ex->args, i), fast, 0);
+            res = jl_toplevel_eval_flex(m, jl_array_ptr_ref(ex->args, i), fast, 0, toplevel_filename, toplevel_lineno);
         }
         JL_GC_POP();
         return res;
     }
     else if (head == jl_error_sym || head == jl_incomplete_sym) {
         if (jl_expr_nargs(ex) == 0)
-            jl_eval_errorf(m, "malformed \"%s\" expression", jl_symbol_name(head));
+            jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
+                "malformed \"%s\" expression", jl_symbol_name(head));
         if (jl_is_string(jl_exprarg(ex, 0)))
-            jl_eval_errorf(m, "syntax: %s", jl_string_data(jl_exprarg(ex, 0)));
-        jl_eval_throw(m, jl_exprarg(ex, 0));
+            jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
+                "syntax: %s", jl_string_data(jl_exprarg(ex, 0)));
+        jl_eval_throw(m, jl_exprarg(ex, 0), *toplevel_filename, *toplevel_lineno);
     }
     else if (jl_is_symbol(ex)) {
         JL_GC_POP();
@@ -908,7 +917,8 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
     assert(head == jl_thunk_sym);
     thk = (jl_code_info_t*)jl_exprarg(ex, 0);
     if (!jl_is_code_info(thk) || !jl_typetagis(thk->code, jl_array_any_type)) {
-        jl_eval_errorf(m, "malformed \"thunk\" statement");
+        jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
+            "malformed \"thunk\" statement");
     }
     body_attributes((jl_array_t*)thk->code, &has_ccall, &has_defs, &has_loops, &has_opaque, &forced_compile);
 
@@ -949,7 +959,9 @@ jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_value_t *e, int
 
 JL_DLLEXPORT jl_value_t *jl_toplevel_eval(jl_module_t *m, jl_value_t *v)
 {
-    return jl_toplevel_eval_flex(m, v, 1, 0);
+    const char *filename = jl_filename;
+    int lieno = jl_lineno;
+    return jl_toplevel_eval_flex(m, v, 1, 0, &filename, &lieno);
 }
 
 // Check module `m` is open for `eval/include`, or throw an error.
@@ -1049,7 +1061,8 @@ static jl_value_t *jl_parse_eval_all(jl_module_t *module, jl_value_t *text,
     size_t last_age = ct->world_age;
     int lineno = 0;
     jl_lineno = 0;
-    jl_filename = jl_string_data(filename);
+    const char *filename_str = jl_string_data(filename);
+    jl_filename = filename_str;
     int err = 0;
 
     JL_TRY {
@@ -1064,7 +1077,7 @@ static jl_value_t *jl_parse_eval_all(jl_module_t *module, jl_value_t *text,
             expression = jl_expand_with_loc_warn(expression, module,
                                                  jl_string_data(filename), lineno);
             ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
-            result = jl_toplevel_eval_flex(module, expression, 1, 1);
+            result = jl_toplevel_eval_flex(module, expression, 1, 1, &filename_str, &lineno);
         }
     }
     JL_CATCH {
diff --git a/test/backtrace.jl b/test/backtrace.jl
index 50a50100488c4..aa10720316a5d 100644
--- a/test/backtrace.jl
+++ b/test/backtrace.jl
@@ -202,6 +202,15 @@ let trace = try
     end
     @test trace[1].func === Symbol("top-level scope")
 end
+let trace = try
+        eval(Expr(:toplevel, LineNumberNode(3, :a_filename), Expr(:error, 1)))
+    catch
+        stacktrace(catch_backtrace())
+    end
+    @test trace[1].func === Symbol("top-level scope")
+    @test trace[1].file === :a_filename
+    @test trace[1].line == 3
+end
 let trace = try
         include_string(@__MODULE__,
             """

From 3e37e175d3c2c18de6927db7a4f5ae1d446f6b23 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 22 Mar 2024 14:39:21 +0100
Subject: [PATCH 1160/1315] also check that UUID of project is non-null when
 treating it as a package (#53789)

Fixes https://github.com/JuliaLang/julia/issues/53788
---
 base/precompilation.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index 80648299b13fd..4f9b53e1c1ae8 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -171,7 +171,7 @@ function ExplicitEnv(envpath::String=Base.active_project())
     sizehint!(weakdeps_expanded, length(deps))
     sizehint!(extensions_expanded, length(deps))
 
-    if proj_name !== nothing
+    if proj_name !== nothing && proj_uuid !== nothing
         deps_expanded[proj_uuid] = filter!(!=(proj_uuid), collect(values(project_deps)))
         extensions_expanded[proj_uuid] = project_extensions
         path = get(project_d, "path", nothing)

From 92918457e31e3696fff9fa3ea91aaa5e8159a23a Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 22 Mar 2024 09:40:53 -0400
Subject: [PATCH 1161/1315] precompilepkgs: simplify custom config printing if
 only one (#53805)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Currently it's a bit excessive in the `Pkg.test` precompile job

![Screenshot 2024-03-20 at 12 04
03 PM](https://github.com/JuliaLang/julia/assets/1694067/7600f0b8-6e4b-43b2-9c42-c8d5d16b8d57)


This PR
```
Precompiling project for configuration --code-coverage=none --color=yes --check-bounds=yes --warn-overwrite=yes --depwarn=yes --inline=yes --startup-file=no --track-allocation=none...
    354.9 ms  ✓ RFFT
  1 dependency successfully precompiled in 1 seconds. 38 already precompiled.
```

Pkg could also just set the non-default flags to minimize the list.
---
 base/precompilation.jl | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index 4f9b53e1c1ae8..50b84ad829d0a 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -551,11 +551,14 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     else
         target = "project"
     end
-    nconfig = length(configs)
-    if nconfig > 1
-        target *= " for $nconfig compilation configurations..."
-    else
+    nconfigs = length(configs)
+    if nconfigs == 1
+        if !isempty(only(configs)[1])
+            target *= " for configuration $(join(only(configs)[1], " "))"
+        end
         target *= "..."
+    else
+        target *= " for $nconfigs compilation configurations..."
     end
     @debug "precompile: packages filtered"
 
@@ -677,7 +680,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                             loaded = warn_loaded && haskey(Base.loaded_modules, dep)
                             _name = haskey(exts, dep) ? string(exts[dep], " → ", dep.name) : dep.name
                             name = dep in direct_deps ? _name : string(color_string(_name, :light_black))
-                            if !isempty(config[1])
+                            if nconfigs > 1 && !isempty(config[1])
                                 config_str = "$(join(config[1], " "))"
                                 name *= color_string(" $(config_str)", :light_black)
                             end
@@ -769,7 +772,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
 
                         _name = haskey(exts, pkg) ? string(exts[pkg], " → ", pkg.name) : pkg.name
                         name = is_direct_dep ? _name : string(color_string(_name, :light_black))
-                        if !isempty(flags)
+                        if nconfigs > 1 && !isempty(flags)
                             config_str = "$(join(flags, " "))"
                             name *= color_string(" $(config_str)", :light_black)
                         end

From d68a04ee9cc9f5479cf729b1bda17d950d4951ba Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 22 Mar 2024 12:10:24 -0400
Subject: [PATCH 1162/1315] Revert "small changes to make Base more statically
 compileable" (#53808)

Reverts JuliaLang/julia#53778 which appears to have introduced a windows
failure

See
https://github.com/JuliaLang/julia/pull/53778#issuecomment-2013100312
---
 base/boot.jl                            |  2 +-
 base/compiler/utilities.jl              |  2 ++
 base/error.jl                           | 10 +++++-----
 base/errorshow.jl                       |  2 +-
 base/initdefs.jl                        |  4 ++--
 base/iostream.jl                        | 13 +++++--------
 base/libuv.jl                           |  6 +++---
 base/loading.jl                         |  7 ++++---
 base/reflection.jl                      |  2 --
 base/show.jl                            |  2 +-
 base/threadingconstructs.jl             |  2 +-
 stdlib/FileWatching/src/FileWatching.jl |  5 -----
 stdlib/LinearAlgebra/src/blas.jl        |  5 +++--
 13 files changed, 28 insertions(+), 34 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index a3c5c03bdf721..fc00f571171c9 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -769,7 +769,7 @@ function is_top_bit_set(x::Union{Int8,UInt8})
 end
 
 # n.b. This function exists for CUDA to overload to configure error behavior (see #48097)
-throw_inexacterror(func::Symbol, to, val) = throw(InexactError(func, to, val))
+throw_inexacterror(args...) = throw(InexactError(args...))
 
 function check_sign_bit(::Type{To}, x) where {To}
     @inline
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 1e002f8dad5a6..00c4c9d4e3ec4 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -498,6 +498,8 @@ end
 # options #
 ###########
 
+is_root_module(m::Module) = false
+
 inlining_enabled() = (JLOptions().can_inline == 1)
 
 function coverage_enabled(m::Module)
diff --git a/base/error.jl b/base/error.jl
index 07782fce5f52e..fc294b3cb3eb0 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -228,15 +228,15 @@ macro assert(ex, msgs...)
         msg = Main.Base.string(msg)
     else
         # string() might not be defined during bootstrap
-        msg = :(_assert_tostring($(Expr(:quote,msg))))
+        msg = quote
+            msg = $(Expr(:quote,msg))
+            isdefined(Main, :Base) ? Main.Base.string(msg) :
+                (Core.println(msg); "Error during bootstrap. See stdout.")
+        end
     end
     return :($(esc(ex)) ? $(nothing) : throw(AssertionError($msg)))
 end
 
-# this may be overridden in contexts where `string(::Expr)` doesn't work
-_assert_tostring(msg) = isdefined(Main, :Base) ? Main.Base.string(msg) :
-    (Core.println(msg); "Error during bootstrap. See stdout.")
-
 struct ExponentialBackOff
     n::Int
     first_delay::Float64
diff --git a/base/errorshow.jl b/base/errorshow.jl
index b06052433ffc4..abc8083f38266 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -400,7 +400,7 @@ end
 
 #Show an error by directly calling jl_printf.
 #Useful in Base submodule __init__ functions where stderr isn't defined yet.
-function showerror_nostdio(@nospecialize(err), msg::AbstractString)
+function showerror_nostdio(err, msg::AbstractString)
     stderr_stream = ccall(:jl_stderr_stream, Ptr{Cvoid}, ())
     ccall(:jl_printf, Cint, (Ptr{Cvoid},Cstring), stderr_stream, msg)
     ccall(:jl_printf, Cint, (Ptr{Cvoid},Cstring), stderr_stream, ":\n")
diff --git a/base/initdefs.jl b/base/initdefs.jl
index 2b2916fc804ad..56c2c0c587272 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -9,7 +9,7 @@ A string containing the script name passed to Julia from the command line. Note
 script name remains unchanged from within included files. Alternatively see
 [`@__FILE__`](@ref).
 """
-global PROGRAM_FILE::String = ""
+global PROGRAM_FILE = ""
 
 """
     ARGS
@@ -480,7 +480,7 @@ end
 
 ## hook for disabling threaded libraries ##
 
-library_threading_enabled::Bool = true
+library_threading_enabled = true
 const disable_library_threading_hooks = []
 
 function at_disable_library_threading(f)
diff --git a/base/iostream.jl b/base/iostream.jl
index bea6612ebc220..5d972945e00e0 100644
--- a/base/iostream.jl
+++ b/base/iostream.jl
@@ -292,15 +292,12 @@ function open(fname::String; lock = true,
     if !lock
         s._dolock = false
     end
-    if ccall(:ios_file, Ptr{Cvoid},
-             (Ptr{UInt8}, Cstring, Cint, Cint, Cint, Cint),
-             s.ios, fname, flags.read, flags.write, flags.create, flags.truncate) == C_NULL
-        systemerror("opening file \"$fname\"")
-    end
+    systemerror("opening file $(repr(fname))",
+                ccall(:ios_file, Ptr{Cvoid},
+                      (Ptr{UInt8}, Cstring, Cint, Cint, Cint, Cint),
+                      s.ios, fname, flags.read, flags.write, flags.create, flags.truncate) == C_NULL)
     if flags.append
-        if ccall(:ios_seek_end, Int64, (Ptr{Cvoid},), s.ios) != 0
-            systemerror("seeking to end of file \"$fname\"")
-        end
+        systemerror("seeking to end of file $fname", ccall(:ios_seek_end, Int64, (Ptr{Cvoid},), s.ios) != 0)
     end
     return s
 end
diff --git a/base/libuv.jl b/base/libuv.jl
index 35424ad3eda3e..66dfcfb3414ad 100644
--- a/base/libuv.jl
+++ b/base/libuv.jl
@@ -134,9 +134,9 @@ function uv_asynccb end
 function uv_timercb end
 
 function reinit_stdio()
-    global stdin = init_stdio(ccall(:jl_stdin_stream, Ptr{Cvoid}, ()))::IO
-    global stdout = init_stdio(ccall(:jl_stdout_stream, Ptr{Cvoid}, ()))::IO
-    global stderr = init_stdio(ccall(:jl_stderr_stream, Ptr{Cvoid}, ()))::IO
+    global stdin = init_stdio(ccall(:jl_stdin_stream, Ptr{Cvoid}, ()))
+    global stdout = init_stdio(ccall(:jl_stdout_stream, Ptr{Cvoid}, ()))
+    global stderr = init_stdio(ccall(:jl_stderr_stream, Ptr{Cvoid}, ()))
     opts = JLOptions()
     if opts.color != 0
         have_color = (opts.color == 1)
diff --git a/base/loading.jl b/base/loading.jl
index 986efc1e1e5fb..883e980b4000a 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2205,6 +2205,7 @@ const explicit_loaded_modules = Dict{PkgId,Module}()
 const loaded_modules_order = Vector{Module}()
 const module_keys = IdDict{Module,PkgId}() # the reverse
 
+is_root_module(m::Module) = @lock require_lock haskey(module_keys, m)
 root_module_key(m::Module) = @lock require_lock module_keys[m]
 
 @constprop :none function register_root_module(m::Module)
@@ -3415,9 +3416,9 @@ function check_clone_targets(clone_targets)
 end
 
 # Set by FileWatching.__init__()
-global mkpidlock_hook::Any
-global trymkpidlock_hook::Any
-global parse_pidfile_hook::Any
+global mkpidlock_hook
+global trymkpidlock_hook
+global parse_pidfile_hook
 
 # The preferences hash is only known after precompilation so just assume no preferences.
 # Also ignore the active project, which means that if all other conditions are equal,
diff --git a/base/reflection.jl b/base/reflection.jl
index 63909b4159877..b1d41b4d68621 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -20,8 +20,6 @@ Base
 """
 parentmodule(m::Module) = ccall(:jl_module_parent, Ref{Module}, (Any,), m)
 
-is_root_module(m::Module) = parentmodule(m) === m || (isdefined(Main, :Base) && m === Main.Base)
-
 """
     moduleroot(m::Module) -> Module
 
diff --git a/base/show.jl b/base/show.jl
index 8f52fefdd7152..f7846e316c330 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1056,7 +1056,7 @@ function show_type_name(io::IO, tn::Core.TypeName)
         # IOContext If :module is not set, default to Main (or current active module).
         # nothing can be used to force printing prefix
         from = get(io, :module, active_module())
-        if isdefined(tn, :module) && (from === nothing || !isvisible(sym, tn.module, from::Module))
+        if isdefined(tn, :module) && (from === nothing || !isvisible(sym, tn.module, from))
             show(io, tn.module)
             print(io, ".")
             if globfunc && !is_id_start_char(first(string(sym)))
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index acab7cf7b8299..60aea04ddba64 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -79,7 +79,7 @@ function _sym_to_tpid(tp::Symbol)
     elseif tp == :foreign
         return Int8(-1)
     else
-        throw(ArgumentError("Unrecognized threadpool name `$tp`"))
+        throw(ArgumentError("Unrecognized threadpool name `$(repr(tp))`"))
     end
 end
 
diff --git a/stdlib/FileWatching/src/FileWatching.jl b/stdlib/FileWatching/src/FileWatching.jl
index 0c987ad01c828..0ee572ec47d92 100644
--- a/stdlib/FileWatching/src/FileWatching.jl
+++ b/stdlib/FileWatching/src/FileWatching.jl
@@ -468,11 +468,6 @@ function uv_fspollcb(handle::Ptr{Cvoid}, status::Int32, prev::Ptr, curr::Ptr)
     nothing
 end
 
-global uv_jl_pollcb::Ptr{Cvoid}
-global uv_jl_fspollcb::Ptr{Cvoid}
-global uv_jl_fseventscb_file::Ptr{Cvoid}
-global uv_jl_fseventscb_folder::Ptr{Cvoid}
-
 function __init__()
     global uv_jl_pollcb = @cfunction(uv_pollcb, Cvoid, (Ptr{Cvoid}, Cint, Cint))
     global uv_jl_fspollcb = @cfunction(uv_fspollcb, Cvoid, (Ptr{Cvoid}, Cint, Ptr{Cvoid}, Ptr{Cvoid}))
diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 413b7866c5444..8903aaddcc11b 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -159,8 +159,9 @@ function check()
     interface = USE_BLAS64 ? :ilp64 : :lp64
     if !any(lib.interface == interface for lib in config.loaded_libs)
         interfacestr = uppercase(string(interface))
-        @error("No loaded BLAS libraries were built with $interfacestr support.")
-        exit(1)
+        @error("No loaded BLAS libraries were built with $(interfacestr) support")
+        println("Quitting.")
+        exit()
     end
 end
 

From 5ed51d33c50f665200e562fe0cfb8ff70e566d59 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 22 Mar 2024 23:31:30 -0400
Subject: [PATCH 1163/1315] Bump libuv (#53822)

Fixes https://github.com/JuliaDebug/Cthulhu.jl/issues/541 by picking up
https://github.com/libuv/libuv/commit/3ecce914105590e6112cd0c6d4f6b30ac6a6c24f.
---
 deps/checksums/libuv          | 68 +++++++++++++++++------------------
 deps/libuv.version            |  2 +-
 stdlib/LibUV_jll/Project.toml |  2 +-
 3 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/deps/checksums/libuv b/deps/checksums/libuv
index 7ac93952b8b34..41a9a5bdf9722 100644
--- a/deps/checksums/libuv
+++ b/deps/checksums/libuv
@@ -1,34 +1,34 @@
-LibUV.v2.0.1+15.aarch64-apple-darwin.tar.gz/md5/f12ee08b8d5721bd88b651ac573c59ed
-LibUV.v2.0.1+15.aarch64-apple-darwin.tar.gz/sha512/b3c53e04624d9c60e664db2eaaf3add696f95c52e55db0c577547f7bf7e045ce30cffa0e38c3451f483dcdb7ddcac1b7f43b694dfadb37282773ce416af1030a
-LibUV.v2.0.1+15.aarch64-linux-gnu.tar.gz/md5/8cb9f4d6c6a4013fa9ed9ae120058275
-LibUV.v2.0.1+15.aarch64-linux-gnu.tar.gz/sha512/d4213ee47ebdcab4cc4719478608ffa461a5543a16656c2881587364c8ed1b39a2f418d5c3c6a04d7e6dd3df349f0afa72cd1df0e06db6146512356b37637024
-LibUV.v2.0.1+15.aarch64-linux-musl.tar.gz/md5/e23a0d7162fc3f09f0ea92d24cba3f4d
-LibUV.v2.0.1+15.aarch64-linux-musl.tar.gz/sha512/f4a13eee72575092ab673777a53d43ce999a7a8bf847daa0a86b39bbfd3f6c1575f105a0bb629766268921ff94f10d354a0e53d32623f6ad35fca44e7bac25f8
-LibUV.v2.0.1+15.armv6l-linux-gnueabihf.tar.gz/md5/70ed0616cd3737a357b7571ab648d239
-LibUV.v2.0.1+15.armv6l-linux-gnueabihf.tar.gz/sha512/25a4b8a90b7bb62e31c1c2bb1d7e137050de26f311daa9f77be932ab3d9a2b92c82ce82ed37cc74a2b1cd5a60bd0dc412e92d31013d36ad35af2d4f376fbc0b0
-LibUV.v2.0.1+15.armv6l-linux-musleabihf.tar.gz/md5/e4320c51c8904a59c105f7b63d086c79
-LibUV.v2.0.1+15.armv6l-linux-musleabihf.tar.gz/sha512/bbc39d800277a66298c56849c1131a6f1958a2c8b2465b59527965a1bd3f36a4c87c1d7ad4be59ec0f4ca8f94ec1804a619eb963d956b77e645e0e00effc6613
-LibUV.v2.0.1+15.armv7l-linux-gnueabihf.tar.gz/md5/d5436552dc177fc3fd0cf4f575cc03b4
-LibUV.v2.0.1+15.armv7l-linux-gnueabihf.tar.gz/sha512/8d3722290151ecf65f4e3fe3440828492a7b115810b87c8711c5592f4dea69727e516228a5a1bdac430c74b288f12de390daf0a9408274aa27cdd69efc81cfee
-LibUV.v2.0.1+15.armv7l-linux-musleabihf.tar.gz/md5/67e1ba03ddf2d2bdd79fef25a5976350
-LibUV.v2.0.1+15.armv7l-linux-musleabihf.tar.gz/sha512/535565657b5714da0db5c622b65b261a77f21f407b1166eee99f35ba3bb9c6fab4c7d1f3db70528767cef7c66c856c5101b01423be05efb9219ec4c76df0be6a
-LibUV.v2.0.1+15.i686-linux-gnu.tar.gz/md5/ba1432ecd75e6a43ff197d51ba76446c
-LibUV.v2.0.1+15.i686-linux-gnu.tar.gz/sha512/dc8940284d4ba05098037fcf4b3bada199878794ef34ad09d8992ef58e4c829b00a3fcca29c4f65b49edcab4274092232ff5d7619b3535333125043f89503cfc
-LibUV.v2.0.1+15.i686-linux-musl.tar.gz/md5/237080cf5d1286a3d2f35d134a285d28
-LibUV.v2.0.1+15.i686-linux-musl.tar.gz/sha512/834f16a16cf6b765dfd094037c8a45ccdedc2eb9e45f527c6721eb0f60f4e56dc4f9b90a2a35e3ed10da4a937d8555e97034e0a29d733cac5352061ebe286799
-LibUV.v2.0.1+15.i686-w64-mingw32.tar.gz/md5/8a5261a6ce4200d272b5eda4fe9ecb31
-LibUV.v2.0.1+15.i686-w64-mingw32.tar.gz/sha512/b372b9368a9ac92775a8d6ee39b492905dc5f58f16d7edf792e0c2ffbd4507ede79139a24fe852dfa26068d0f076a4abf3c3b868a8a057b23fdbad80999d315f
-LibUV.v2.0.1+15.powerpc64le-linux-gnu.tar.gz/md5/53db7b763af204477ce8f0bfae0ce15c
-LibUV.v2.0.1+15.powerpc64le-linux-gnu.tar.gz/sha512/bbfe2518d4dc84fe73b7d3f3bcaf5aeef0db0d284c0e205e3e3670b8ce6f3ea593a0e52d125fd9a79cd098dba0d35f151cb46469fa25dfeef62ebcc966f94d4f
-LibUV.v2.0.1+15.x86_64-apple-darwin.tar.gz/md5/b4699192c098564edc5589e90c47324e
-LibUV.v2.0.1+15.x86_64-apple-darwin.tar.gz/sha512/2505e4060712143d3213747d4276c0b99dec78579d2ab0b71c5d7edf15ae80e0178138a11470c976d97de14e44b153dcb00c08c864523d7ee0ead8e48cf15d14
-LibUV.v2.0.1+15.x86_64-linux-gnu.tar.gz/md5/f5515c50106a0748b9a1986c912a00f3
-LibUV.v2.0.1+15.x86_64-linux-gnu.tar.gz/sha512/5822396039e14a5d919f2612559a8d62a925c4319e66eb05ed20faed754318762f5653851684701cd4ddb1edf10bfe25d252c3d9cd84228e498e825ba61146b1
-LibUV.v2.0.1+15.x86_64-linux-musl.tar.gz/md5/1962e6f21080e874d2ca0275c5b569b2
-LibUV.v2.0.1+15.x86_64-linux-musl.tar.gz/sha512/4702e13633d77a6c0aeb1e7cd252471a779177e20c68485130f420cc4878c8f7de7f0f51730008ba9dc0f275875a5947629d39aff200691e26f31d42e388d53d
-LibUV.v2.0.1+15.x86_64-unknown-freebsd.tar.gz/md5/928a789c3cd3b4cefcc1cf13f5f179ac
-LibUV.v2.0.1+15.x86_64-unknown-freebsd.tar.gz/sha512/ee58667b19fdf7ec0218b4645b3f5bed2e9fc01cc29eab8473ee02aaa044f94a48eb220c6427200aaf56eacf52d0f72156712d17017cfecbc25d3c1b71a4bd2f
-LibUV.v2.0.1+15.x86_64-w64-mingw32.tar.gz/md5/d3b84729ee9d5a6e6a1e29357e25cced
-LibUV.v2.0.1+15.x86_64-w64-mingw32.tar.gz/sha512/43ca5999d8e8ff820722b1a548bd4e277e95c739c3363ed6159d080dd06842316f5370e8e4f4a886bf76010f4aed2bbf01f6091845b0e84b75f709277c561649
-libuv-afa1c67fa496eb49ade1e520f76fd018a1409eaa.tar.gz/md5/3863ccd5a51f85cf76679070c99be6cd
-libuv-afa1c67fa496eb49ade1e520f76fd018a1409eaa.tar.gz/sha512/bf4c705e05e730139b62de799331653eea2767898d654b8890ca2623db3adb9a1efcfcfab38af22e8ac44c67a9c5c018f1f7847a3703bee5f05657169a67d817
+LibUV.v2.0.1+16.aarch64-apple-darwin.tar.gz/md5/132266a501144f34eb9b8d5199db43c0
+LibUV.v2.0.1+16.aarch64-apple-darwin.tar.gz/sha512/e466ba8a2fe916f0e2dccb1d1075a6a20fcc5d5068d2375c940353a63522332fa8f665461adbb47ad4d30dabaea011b8e72a603601da29a071d98c7d7d130f46
+LibUV.v2.0.1+16.aarch64-linux-gnu.tar.gz/md5/1ae3018d9ab8bb293dbf6277c2c209cc
+LibUV.v2.0.1+16.aarch64-linux-gnu.tar.gz/sha512/6e56876cdf0fdad1aade6435edf980b286438ee9fa695fa4e262b47f7ada6ff69535c59d216daee3eb1d061a90c2c16fd70d21438776c54addda93cf275ef1be
+LibUV.v2.0.1+16.aarch64-linux-musl.tar.gz/md5/08243e727c7e957f5972a200b5d89113
+LibUV.v2.0.1+16.aarch64-linux-musl.tar.gz/sha512/4a684f248704b16b882d66ed7af60e2217a0b98f476bfdd1cb545d3e2adb17f6a410bf09e270c1e2623e550b36639c9282a562ab415850dfea98736ec03fd000
+LibUV.v2.0.1+16.armv6l-linux-gnueabihf.tar.gz/md5/c4dfccf5a899782715cbb0ca0197938c
+LibUV.v2.0.1+16.armv6l-linux-gnueabihf.tar.gz/sha512/ecdcd655865a532187e4e98cb21ca68e62303813cad585de83382aa226d965213f24fe7a684e1189fad11b0e5f2f4b318c122f557a6117f61bb2948b51e16a76
+LibUV.v2.0.1+16.armv6l-linux-musleabihf.tar.gz/md5/5382dae963f3003aefdb119377a45e82
+LibUV.v2.0.1+16.armv6l-linux-musleabihf.tar.gz/sha512/f901c2965e8f9ca52900180c32cdb70d8adc13f12f076c1b109d57b749cac1ecaac3c72e22531e6fcb79c8f2c7cf952ff563779d3764b015b73db079f2b171cb
+LibUV.v2.0.1+16.armv7l-linux-gnueabihf.tar.gz/md5/9c4cd82249c03ebeac670e2c7c8c1078
+LibUV.v2.0.1+16.armv7l-linux-gnueabihf.tar.gz/sha512/ee4b7f866e3f63df303d00d48d36680c490570979bb7174c12cfcf9efaf48ea7ae90aa05b41da8ab686de93c910c5a761f31da22845ad48fd980e9c16437cbfb
+LibUV.v2.0.1+16.armv7l-linux-musleabihf.tar.gz/md5/5255d7e320ef37eb63d0e85c4b86d20d
+LibUV.v2.0.1+16.armv7l-linux-musleabihf.tar.gz/sha512/5bcd3d22b1e2398879e654bb550fd093891775c64cb48bd179c4f9ff8dcbff23eda91a66ea14852ef5945d5c114732957075e3b3fded4cbd3cca559fead842db
+LibUV.v2.0.1+16.i686-linux-gnu.tar.gz/md5/7f0fc52beb13dad773c6ab54deee7a62
+LibUV.v2.0.1+16.i686-linux-gnu.tar.gz/sha512/cb1736eab4fa1be89018b3c77c3551a99d0fa761ad2f1947587c215d87d963d43198ce87574b6eb9d1fb8a93abf1ae89e74fb8a3f3fb9c4fd08a49e04b4335f4
+LibUV.v2.0.1+16.i686-linux-musl.tar.gz/md5/ed22ccd7eaa09ed9c71afc0c6affa423
+LibUV.v2.0.1+16.i686-linux-musl.tar.gz/sha512/7f3ff061c3d7d0c3c0c0be3e4052aeed39f35e1ba0b92f3ee3d9f266f26d064acc153c08054a22d090167f00fef3c27ec54e836de35f348e4849baab301f7fa4
+LibUV.v2.0.1+16.i686-w64-mingw32.tar.gz/md5/7f1fe93df0b741ca30c4fb64ff9ac9bd
+LibUV.v2.0.1+16.i686-w64-mingw32.tar.gz/sha512/9d71722c538d8232d8510fa2a43e7a52271b078401dfa838de9eedcfc34a2483aa3b1c221b17c41353b54554fe76d86b4973c5261b288228a91f0cc92820ad93
+LibUV.v2.0.1+16.powerpc64le-linux-gnu.tar.gz/md5/b796de6c75f18f318823e3e1cdd316c8
+LibUV.v2.0.1+16.powerpc64le-linux-gnu.tar.gz/sha512/f8dbb98cb49edfa06a0b48fbe1e658ca5a9bca13fe33d21872a012deaa1052a495faf74f90c0dfa48378b9f4f51f1045e01e563aec427d8c89d50e4eef0e4938
+LibUV.v2.0.1+16.x86_64-apple-darwin.tar.gz/md5/f2d55b315fa1f77b632a461530bb6b3b
+LibUV.v2.0.1+16.x86_64-apple-darwin.tar.gz/sha512/eb40a193c3bca5e822a417879e854877b353a2a04b03a721ef4125360f1189a3685d2751e2f975360a2ad4c37e6043485a54b5349b3da423b8aae73d4a095d04
+LibUV.v2.0.1+16.x86_64-linux-gnu.tar.gz/md5/a573ded4f78f8677ef73594be9629638
+LibUV.v2.0.1+16.x86_64-linux-gnu.tar.gz/sha512/c5809635be3ab5dc53c37a028e58695d89ea91eee850af22a0e8db10ea021640f1e618a553848332ee6df66eecd08d34605e335aad46ece82365a3525b69c42f
+LibUV.v2.0.1+16.x86_64-linux-musl.tar.gz/md5/5bdad561b5db7d19f198ef090ae3ec84
+LibUV.v2.0.1+16.x86_64-linux-musl.tar.gz/sha512/6662c8226f22f79f8c40857a5a531841f013031dd2e9536568498bfd536f133976ff71d0cc5f56f1e0c0b7f2403a35c2ccef9117d9e0d7819771bd492194f20d
+LibUV.v2.0.1+16.x86_64-unknown-freebsd.tar.gz/md5/f4ad9e445e4b14e2b59b2b77c9ed72ad
+LibUV.v2.0.1+16.x86_64-unknown-freebsd.tar.gz/sha512/a78deac6d8321f274a229961620da4d069ff2accf7d1ed9edfb01c21ad47eb33d364ba2f310ff4a93b2732dcd16f6d481843dbcb273770d731fd528f9c7a9ddc
+LibUV.v2.0.1+16.x86_64-w64-mingw32.tar.gz/md5/72caa067cf24e304955405dcb4de195a
+LibUV.v2.0.1+16.x86_64-w64-mingw32.tar.gz/sha512/de80ca98d199d3c5626ebc771325806ce3aae5927220201c2351207c10ff67791d2865f76e41519df88f0be3da534342965e7ba0d055d807c4b2b6c78bd2427d
+libuv-ca3a5a431a1c37859b6508e6b2a288092337029a.tar.gz/md5/d1fbca8bcc5819037b8b81ae4f61c357
+libuv-ca3a5a431a1c37859b6508e6b2a288092337029a.tar.gz/sha512/e735861923c0fc597b53eb2efb56b26acec29e3fcae7e76d349fc08f8b9d340df9ac60a1cd245e46a434aa357ed8e377734c1c97bf08bd044c9ba0c02b082a6a
diff --git a/deps/libuv.version b/deps/libuv.version
index 9ae54aa7be91a..bc8e2e57c9517 100644
--- a/deps/libuv.version
+++ b/deps/libuv.version
@@ -4,4 +4,4 @@ LIBUV_JLL_NAME := LibUV
 ## source build
 LIBUV_VER := 2
 LIBUV_BRANCH=julia-uv2-1.48.0
-LIBUV_SHA1=afa1c67fa496eb49ade1e520f76fd018a1409eaa
+LIBUV_SHA1=ca3a5a431a1c37859b6508e6b2a288092337029a
diff --git a/stdlib/LibUV_jll/Project.toml b/stdlib/LibUV_jll/Project.toml
index 8089516c1df14..7c61fdf89df70 100644
--- a/stdlib/LibUV_jll/Project.toml
+++ b/stdlib/LibUV_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LibUV_jll"
 uuid = "183b4373-6708-53ba-ad28-60e28bb38547"
-version = "2.0.1+15"
+version = "2.0.1+16"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 61720208c95daae5922f5d2e655651a4e614a239 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Sat, 23 Mar 2024 00:23:21 -0400
Subject: [PATCH 1164/1315] reland "small changes to make Base more statically
 compileable (#53778)" (#53820)

This makes it easier to fully-statically-type Base and init methods. The
changes are from gb/small-image2.
---
 base/boot.jl                            |  2 +-
 base/compiler/utilities.jl              |  2 --
 base/error.jl                           | 10 +++++-----
 base/errorshow.jl                       |  2 +-
 base/initdefs.jl                        |  4 ++--
 base/iostream.jl                        | 13 ++++++++-----
 base/libuv.jl                           |  6 +++---
 base/loading.jl                         |  7 +++----
 base/reflection.jl                      |  2 ++
 base/show.jl                            |  2 +-
 base/threadingconstructs.jl             |  2 +-
 stdlib/FileWatching/src/FileWatching.jl |  5 +++++
 stdlib/LinearAlgebra/src/blas.jl        |  5 ++---
 13 files changed, 34 insertions(+), 28 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index fc00f571171c9..a3c5c03bdf721 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -769,7 +769,7 @@ function is_top_bit_set(x::Union{Int8,UInt8})
 end
 
 # n.b. This function exists for CUDA to overload to configure error behavior (see #48097)
-throw_inexacterror(args...) = throw(InexactError(args...))
+throw_inexacterror(func::Symbol, to, val) = throw(InexactError(func, to, val))
 
 function check_sign_bit(::Type{To}, x) where {To}
     @inline
diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 00c4c9d4e3ec4..1e002f8dad5a6 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -498,8 +498,6 @@ end
 # options #
 ###########
 
-is_root_module(m::Module) = false
-
 inlining_enabled() = (JLOptions().can_inline == 1)
 
 function coverage_enabled(m::Module)
diff --git a/base/error.jl b/base/error.jl
index fc294b3cb3eb0..07782fce5f52e 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -228,15 +228,15 @@ macro assert(ex, msgs...)
         msg = Main.Base.string(msg)
     else
         # string() might not be defined during bootstrap
-        msg = quote
-            msg = $(Expr(:quote,msg))
-            isdefined(Main, :Base) ? Main.Base.string(msg) :
-                (Core.println(msg); "Error during bootstrap. See stdout.")
-        end
+        msg = :(_assert_tostring($(Expr(:quote,msg))))
     end
     return :($(esc(ex)) ? $(nothing) : throw(AssertionError($msg)))
 end
 
+# this may be overridden in contexts where `string(::Expr)` doesn't work
+_assert_tostring(msg) = isdefined(Main, :Base) ? Main.Base.string(msg) :
+    (Core.println(msg); "Error during bootstrap. See stdout.")
+
 struct ExponentialBackOff
     n::Int
     first_delay::Float64
diff --git a/base/errorshow.jl b/base/errorshow.jl
index abc8083f38266..b06052433ffc4 100644
--- a/base/errorshow.jl
+++ b/base/errorshow.jl
@@ -400,7 +400,7 @@ end
 
 #Show an error by directly calling jl_printf.
 #Useful in Base submodule __init__ functions where stderr isn't defined yet.
-function showerror_nostdio(err, msg::AbstractString)
+function showerror_nostdio(@nospecialize(err), msg::AbstractString)
     stderr_stream = ccall(:jl_stderr_stream, Ptr{Cvoid}, ())
     ccall(:jl_printf, Cint, (Ptr{Cvoid},Cstring), stderr_stream, msg)
     ccall(:jl_printf, Cint, (Ptr{Cvoid},Cstring), stderr_stream, ":\n")
diff --git a/base/initdefs.jl b/base/initdefs.jl
index 56c2c0c587272..2b2916fc804ad 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -9,7 +9,7 @@ A string containing the script name passed to Julia from the command line. Note
 script name remains unchanged from within included files. Alternatively see
 [`@__FILE__`](@ref).
 """
-global PROGRAM_FILE = ""
+global PROGRAM_FILE::String = ""
 
 """
     ARGS
@@ -480,7 +480,7 @@ end
 
 ## hook for disabling threaded libraries ##
 
-library_threading_enabled = true
+library_threading_enabled::Bool = true
 const disable_library_threading_hooks = []
 
 function at_disable_library_threading(f)
diff --git a/base/iostream.jl b/base/iostream.jl
index 5d972945e00e0..0ee51b9b98efd 100644
--- a/base/iostream.jl
+++ b/base/iostream.jl
@@ -292,12 +292,15 @@ function open(fname::String; lock = true,
     if !lock
         s._dolock = false
     end
-    systemerror("opening file $(repr(fname))",
-                ccall(:ios_file, Ptr{Cvoid},
-                      (Ptr{UInt8}, Cstring, Cint, Cint, Cint, Cint),
-                      s.ios, fname, flags.read, flags.write, flags.create, flags.truncate) == C_NULL)
+    if ccall(:ios_file, Ptr{Cvoid},
+             (Ptr{UInt8}, Cstring, Cint, Cint, Cint, Cint),
+             s.ios, fname, flags.read, flags.write, flags.create, flags.truncate) == C_NULL
+        systemerror("opening file $(repr(fname))")
+    end
     if flags.append
-        systemerror("seeking to end of file $fname", ccall(:ios_seek_end, Int64, (Ptr{Cvoid},), s.ios) != 0)
+        if ccall(:ios_seek_end, Int64, (Ptr{Cvoid},), s.ios) != 0
+            systemerror("seeking to end of file $fname")
+        end
     end
     return s
 end
diff --git a/base/libuv.jl b/base/libuv.jl
index 66dfcfb3414ad..35424ad3eda3e 100644
--- a/base/libuv.jl
+++ b/base/libuv.jl
@@ -134,9 +134,9 @@ function uv_asynccb end
 function uv_timercb end
 
 function reinit_stdio()
-    global stdin = init_stdio(ccall(:jl_stdin_stream, Ptr{Cvoid}, ()))
-    global stdout = init_stdio(ccall(:jl_stdout_stream, Ptr{Cvoid}, ()))
-    global stderr = init_stdio(ccall(:jl_stderr_stream, Ptr{Cvoid}, ()))
+    global stdin = init_stdio(ccall(:jl_stdin_stream, Ptr{Cvoid}, ()))::IO
+    global stdout = init_stdio(ccall(:jl_stdout_stream, Ptr{Cvoid}, ()))::IO
+    global stderr = init_stdio(ccall(:jl_stderr_stream, Ptr{Cvoid}, ()))::IO
     opts = JLOptions()
     if opts.color != 0
         have_color = (opts.color == 1)
diff --git a/base/loading.jl b/base/loading.jl
index 883e980b4000a..986efc1e1e5fb 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2205,7 +2205,6 @@ const explicit_loaded_modules = Dict{PkgId,Module}()
 const loaded_modules_order = Vector{Module}()
 const module_keys = IdDict{Module,PkgId}() # the reverse
 
-is_root_module(m::Module) = @lock require_lock haskey(module_keys, m)
 root_module_key(m::Module) = @lock require_lock module_keys[m]
 
 @constprop :none function register_root_module(m::Module)
@@ -3416,9 +3415,9 @@ function check_clone_targets(clone_targets)
 end
 
 # Set by FileWatching.__init__()
-global mkpidlock_hook
-global trymkpidlock_hook
-global parse_pidfile_hook
+global mkpidlock_hook::Any
+global trymkpidlock_hook::Any
+global parse_pidfile_hook::Any
 
 # The preferences hash is only known after precompilation so just assume no preferences.
 # Also ignore the active project, which means that if all other conditions are equal,
diff --git a/base/reflection.jl b/base/reflection.jl
index b1d41b4d68621..63909b4159877 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -20,6 +20,8 @@ Base
 """
 parentmodule(m::Module) = ccall(:jl_module_parent, Ref{Module}, (Any,), m)
 
+is_root_module(m::Module) = parentmodule(m) === m || (isdefined(Main, :Base) && m === Main.Base)
+
 """
     moduleroot(m::Module) -> Module
 
diff --git a/base/show.jl b/base/show.jl
index f7846e316c330..8f52fefdd7152 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1056,7 +1056,7 @@ function show_type_name(io::IO, tn::Core.TypeName)
         # IOContext If :module is not set, default to Main (or current active module).
         # nothing can be used to force printing prefix
         from = get(io, :module, active_module())
-        if isdefined(tn, :module) && (from === nothing || !isvisible(sym, tn.module, from))
+        if isdefined(tn, :module) && (from === nothing || !isvisible(sym, tn.module, from::Module))
             show(io, tn.module)
             print(io, ".")
             if globfunc && !is_id_start_char(first(string(sym)))
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index 60aea04ddba64..acab7cf7b8299 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -79,7 +79,7 @@ function _sym_to_tpid(tp::Symbol)
     elseif tp == :foreign
         return Int8(-1)
     else
-        throw(ArgumentError("Unrecognized threadpool name `$(repr(tp))`"))
+        throw(ArgumentError("Unrecognized threadpool name `$tp`"))
     end
 end
 
diff --git a/stdlib/FileWatching/src/FileWatching.jl b/stdlib/FileWatching/src/FileWatching.jl
index 0ee572ec47d92..0c987ad01c828 100644
--- a/stdlib/FileWatching/src/FileWatching.jl
+++ b/stdlib/FileWatching/src/FileWatching.jl
@@ -468,6 +468,11 @@ function uv_fspollcb(handle::Ptr{Cvoid}, status::Int32, prev::Ptr, curr::Ptr)
     nothing
 end
 
+global uv_jl_pollcb::Ptr{Cvoid}
+global uv_jl_fspollcb::Ptr{Cvoid}
+global uv_jl_fseventscb_file::Ptr{Cvoid}
+global uv_jl_fseventscb_folder::Ptr{Cvoid}
+
 function __init__()
     global uv_jl_pollcb = @cfunction(uv_pollcb, Cvoid, (Ptr{Cvoid}, Cint, Cint))
     global uv_jl_fspollcb = @cfunction(uv_fspollcb, Cvoid, (Ptr{Cvoid}, Cint, Ptr{Cvoid}, Ptr{Cvoid}))
diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 8903aaddcc11b..413b7866c5444 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -159,9 +159,8 @@ function check()
     interface = USE_BLAS64 ? :ilp64 : :lp64
     if !any(lib.interface == interface for lib in config.loaded_libs)
         interfacestr = uppercase(string(interface))
-        @error("No loaded BLAS libraries were built with $(interfacestr) support")
-        println("Quitting.")
-        exit()
+        @error("No loaded BLAS libraries were built with $interfacestr support.")
+        exit(1)
     end
 end
 

From 63e365feb8692b9d7cb5298954c26ab7af268171 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sat, 23 Mar 2024 01:18:55 -0400
Subject: [PATCH 1165/1315] REPL: Expand macros before looking for `using`
 statements (#53821)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Currently, in order to give the nice prompt for missing packages, we
look for any `using`/`import` statements in the AST before evaluation.
However, this misses any `using` statements introduced by macros:

```
julia> using Pkg

julia> using BenchmarkTools
 │ Package BenchmarkTools not found, but a package named BenchmarkTools is
 │ available from a registry.
 │ Install package?
 │   (@v1.11) pkg> add BenchmarkTools
 └ (y/n/o) [y]: n
ERROR: ArgumentError: Package BenchmarkTools not found in current path.
- Run `import Pkg; Pkg.add("BenchmarkTools")` to install the BenchmarkTools package.
Stacktrace:
 [1] macro expansion
   @ Base ./loading.jl:1781 [inlined]
 [2] macro expansion
   @ Base ./lock.jl:267 [inlined]
 [3] __require(into::Module, mod::Symbol)
   @ Base ./loading.jl:1762
 [4] #invoke_in_world#3
   @ Base ./essentials.jl:963 [inlined]
 [5] invoke_in_world
   @ Base ./essentials.jl:960 [inlined]
 [6] require(into::Module, mod::Symbol)
   @ Base ./loading.jl:1755

julia> macro foo()
       :(using BenchmarkTools)
       end
@foo (macro with 1 method)

julia> @foo
ERROR: ArgumentError: Package BenchmarkTools not found in current path.
- Run `import Pkg; Pkg.add("BenchmarkTools")` to install the BenchmarkTools package.
Stacktrace:
 [1] macro expansion
   @ Base ./loading.jl:1781 [inlined]
 [2] macro expansion
   @ Base ./lock.jl:267 [inlined]
 [3] __require(into::Module, mod::Symbol)
   @ Base ./loading.jl:1762
 [4] #invoke_in_world#3
   @ Base ./essentials.jl:963 [inlined]
 [5] invoke_in_world
   @ Base ./essentials.jl:960 [inlined]
 [6] require(into::Module, mod::Symbol)
   @ Base ./loading.jl:1755
 [7] top-level scope
   @ REPL[4]:1
```

Generally, it doesn't matter, but embedded DSLs may want to do this kind
of thing, so we might as well try to support it.
---
 base/client.jl           |  2 +-
 stdlib/REPL/src/REPL.jl  | 46 ++++++++++++++++++++++++++++++++++------
 stdlib/REPL/test/repl.jl | 29 +++++++++++++++++++++++++
 test/precompile.jl       |  2 +-
 4 files changed, 70 insertions(+), 9 deletions(-)

diff --git a/base/client.jl b/base/client.jl
index 087efe3d3b99c..3ca2d54745290 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -95,7 +95,7 @@ function scrub_repl_backtrace(bt)
     if bt !== nothing && !(bt isa Vector{Any}) # ignore our sentinel value types
         bt = bt isa Vector{StackFrame} ? copy(bt) : stacktrace(bt)
         # remove REPL-related frames from interactive printing
-        eval_ind = findlast(frame -> !frame.from_c && frame.func === :eval, bt)
+        eval_ind = findlast(frame -> !frame.from_c && startswith(String(frame.func), "__repl_entry"), bt)
         eval_ind === nothing || deleteat!(bt, eval_ind:length(bt))
     end
     return bt
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index 0c88c84b3cbc2..789def3d317bf 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -212,6 +212,27 @@ const repl_ast_transforms = Any[softscope] # defaults for new REPL backends
 # to e.g. install packages on demand
 const install_packages_hooks = Any[]
 
+# N.B.: Any functions starting with __repl_entry cut off backtraces when printing in the REPL.
+# We need to do this for both the actual eval and macroexpand, since the latter can cause custom macro
+# code to run (and error).
+__repl_entry_lower_with_loc(mod::Module, @nospecialize(ast), toplevel_file::Ref{Ptr{UInt8}}, toplevel_line::Ref{Cint}) =
+    ccall(:jl_expand_with_loc, Any, (Any, Any, Ptr{UInt8}, Cint), ast, mod, toplevel_file[], toplevel_line[])
+__repl_entry_eval_expanded_with_loc(mod::Module, @nospecialize(ast), toplevel_file::Ref{Ptr{UInt8}}, toplevel_line::Ref{Cint}) =
+    ccall(:jl_toplevel_eval_flex, Any, (Any, Any, Cint, Cint, Ptr{Ptr{UInt8}}, Ptr{Cint}), mod, ast, 1, 1, toplevel_file, toplevel_line)
+
+function toplevel_eval_with_hooks(mod::Module, @nospecialize(ast), toplevel_file=Ref{Ptr{UInt8}}(Base.unsafe_convert(Ptr{UInt8}, :REPL)), toplevel_line=Ref{Cint}(1))
+    if !isexpr(ast, :toplevel)
+        ast = __repl_entry_lower_with_loc(mod, ast, toplevel_file, toplevel_line)
+        check_for_missing_packages_and_run_hooks(ast)
+        return __repl_entry_eval_expanded_with_loc(mod, ast, toplevel_file, toplevel_line)
+    end
+    local value=nothing
+    for i = 1:length(ast.args)
+        value = toplevel_eval_with_hooks(mod, ast.args[i], toplevel_file, toplevel_line)
+    end
+    return value
+end
+
 function eval_user_input(@nospecialize(ast), backend::REPLBackend, mod::Module)
     lasterr = nothing
     Base.sigatomic_begin()
@@ -222,11 +243,10 @@ function eval_user_input(@nospecialize(ast), backend::REPLBackend, mod::Module)
                 put!(backend.response_channel, Pair{Any, Bool}(lasterr, true))
             else
                 backend.in_eval = true
-                check_for_missing_packages_and_run_hooks(ast)
                 for xf in backend.ast_transforms
                     ast = Base.invokelatest(xf, ast)
                 end
-                value = Core.eval(mod, ast)
+                value = toplevel_eval_with_hooks(mod, ast)
                 backend.in_eval = false
                 setglobal!(Base.MainInclude, :ans, value)
                 put!(backend.response_channel, Pair{Any, Bool}(value, false))
@@ -256,7 +276,7 @@ function check_for_missing_packages_and_run_hooks(ast)
     end
 end
 
-function modules_to_be_loaded(ast::Expr, mods::Vector{Symbol} = Symbol[])
+function _modules_to_be_loaded!(ast::Expr, mods::Vector{Symbol})
     ast.head === :quote && return mods # don't search if it's not going to be run during this eval
     if ast.head === :using || ast.head === :import
         for arg in ast.args
@@ -271,12 +291,24 @@ function modules_to_be_loaded(ast::Expr, mods::Vector{Symbol} = Symbol[])
             end
         end
     end
-    for arg in ast.args
-        if isexpr(arg, (:block, :if, :using, :import))
-            modules_to_be_loaded(arg, mods)
+    if ast.head !== :thunk
+        for arg in ast.args
+            if isexpr(arg, (:block, :if, :using, :import))
+                _modules_to_be_loaded!(arg, mods)
+            end
+        end
+    else
+        code = ast.args[1]
+        for arg in code.code
+            isa(arg, Expr) || continue
+            _modules_to_be_loaded!(arg, mods)
         end
     end
-    filter!(mod -> !in(String(mod), ["Base", "Main", "Core"]), mods) # Exclude special non-package modules
+end
+
+function modules_to_be_loaded(ast::Expr, mods::Vector{Symbol} = Symbol[])
+    _modules_to_be_loaded!(ast, mods)
+    filter!(mod::Symbol -> !in(mod, (:Base, :Main, :Core)), mods) # Exclude special non-package modules
     return unique(mods)
 end
 
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 12f3f8956122e..1d0caab7d0e57 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -1480,6 +1480,35 @@ end
     end
 end
 
+# Test that the REPL can find `using` statements inside macro expansions
+global packages_requested = Any[]
+old_hooks = copy(REPL.install_packages_hooks)
+empty!(REPL.install_packages_hooks)
+push!(REPL.install_packages_hooks, function(pkgs)
+    append!(packages_requested, pkgs)
+end)
+
+fake_repl() do stdin_write, stdout_read, repl
+    repltask = @async begin
+        REPL.run_repl(repl)
+    end
+
+    # Just consume all the output - we only test that the callback ran
+    read_resp_task = @async while !eof(stdout_read)
+        readavailable(stdout_read)
+    end
+
+    write(stdin_write, "macro usingfoo(); :(using FooNotFound); end\n")
+    write(stdin_write, "@usingfoo\n")
+    write(stdin_write, "\x4")
+    Base.wait(repltask)
+    close(stdin_write)
+    close(stdout_read)
+    Base.wait(read_resp_task)
+end
+@test packages_requested == Any[:FooNotFound]
+empty!(REPL.install_packages_hooks); append!(REPL.install_packages_hooks, old_hooks)
+
 # err should reprint error if deeper than top-level
 fake_repl() do stdin_write, stdout_read, repl
     repltask = @async begin
diff --git a/test/precompile.jl b/test/precompile.jl
index 5994ee44beb0c..a830a3af3ea7d 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -641,7 +641,7 @@ precompile_test_harness(false) do dir
           error("break me")
           end
           """)
-    @test_warn r"LoadError: break me\nStacktrace:\n \[1\] [\e01m\[]*error" try
+    @test_warn r"LoadError: break me\nStacktrace:\n[ ]*\[1\] [\e01m\[]*error" try
             Base.require(Main, :FooBar2)
             error("the \"break me\" test failed")
         catch exc

From 243f67db8f25a4601efe2a13727a3527ce6c90af Mon Sep 17 00:00:00 2001
From: danik292 <116908854+danik292@users.noreply.github.com>
Date: Sat, 23 Mar 2024 16:49:07 +0100
Subject: [PATCH 1166/1315] Add docstring for Base.Sort.SMALL_ALGORITHM
 (#53807)

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
Co-authored-by: Steven G. Johnson <stevenj@mit.edu>
---
 base/sort.jl    | 10 ++++++++++
 test/sorting.jl |  2 +-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/base/sort.jl b/base/sort.jl
index eb57da376f4ab..281a75cac309e 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -812,6 +812,16 @@ Characteristics:
 it is well-suited to small collections but should not be used for large ones.
 """
 const InsertionSort = InsertionSortAlg()
+
+"""
+    SMALL_ALGORITHM
+
+Default sorting algorithm for small arrays.
+
+This is an alias for a simple low-overhead algorithm that does not scale well
+to large arrays, unlike high-overhead recursive algorithms used for larger arrays.
+`SMALL_ALGORITHM` is a good choice for the base case of a recursive algorithm.
+"""
 const SMALL_ALGORITHM = InsertionSortAlg()
 
 function _sort!(v::AbstractVector, ::InsertionSortAlg, o::Ordering, kw)
diff --git a/test/sorting.jl b/test/sorting.jl
index d1875c9727a29..2714197f58823 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -12,7 +12,7 @@ using .Main.OffsetArrays
 @testset "Base.Sort docstrings" begin
     undoc = Docs.undocumented_names(Base.Sort)
     @test_broken isempty(undoc)
-    @test undoc == [:Algorithm, :SMALL_ALGORITHM, :SMALL_THRESHOLD, :Sort]
+    @test undoc == [:Algorithm, :SMALL_THRESHOLD, :Sort]
 end
 
 @testset "Order" begin

From 9bd7343fab5059fc00450d2e0f582f5c03f79cd5 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Sat, 23 Mar 2024 17:12:32 -0400
Subject: [PATCH 1167/1315] Retry downloads in toml tests (#53828)

---
 stdlib/TOML/test/utils/utils.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/TOML/test/utils/utils.jl b/stdlib/TOML/test/utils/utils.jl
index c484a61cee25a..b01acf04a72fe 100644
--- a/stdlib/TOML/test/utils/utils.jl
+++ b/stdlib/TOML/test/utils/utils.jl
@@ -33,7 +33,7 @@ end
 function get_data()
     tmp = mktempdir()
     path = joinpath(tmp, basename(url))
-    Downloads.download(url, path)
+    retry(Downloads.download, delays=fill(10,5))(url, path)
     Tar.extract(`$(exe7z()) x $path -so`, joinpath(tmp, "testfiles"))
     return joinpath(tmp, "testfiles", "toml-test-julia-$version", "testfiles")
 end

From 4a2c59333946c5450c73f4c5ba7d2d28529db8de Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Sat, 23 Mar 2024 22:32:02 +0100
Subject: [PATCH 1168/1315] add code loading + precompilation support for
 workspaces (#53653)

This is similar to workspaces in cargo where multiple projects share a
manifest https://doc.rust-lang.org/book/ch14-03-cargo-workspaces.html
and upon resolving the dependencies and compat of all projects in the
workspace is adhered to.

The idea is to use this for e.g. test, doc environments where you want
to "overlay" a dependency graph on top of a base one.

The code change in Base adds support for the code loading and precompilation part of this, those changes are:

- Finding the manifest from any active project in the workspace
- Merge preferences among projects in a workspace.
- Allowing one to pass `manifest=true` to `precompilepkgs` to compile every package in the manifest.
- The effect of giving no packages to `precompilepkgs` was changed from compiling all packages in the manifest to only those in the active project (which is equivalent in case of no workspace being used but different when it is used).
---
 base/loading.jl                               | 69 ++++++++++++++++---
 base/precompilation.jl                        | 50 ++++++++------
 doc/src/manual/code-loading.md                | 22 ++++++
 test/loading.jl                               | 58 ++++++++++++++++
 test/project/SubProject/Devved/Project.toml   |  3 +
 test/project/SubProject/Devved/src/Devved.jl  |  5 ++
 test/project/SubProject/Devved2/Project.toml  |  3 +
 .../project/SubProject/Devved2/src/Devved2.jl |  5 ++
 test/project/SubProject/Manifest.toml         | 68 ++++++++++++++++++
 .../SubProject/PackageThatIsSub/Project.toml  | 14 ++++
 .../PackageThatIsSub/src/PackageThatIsSub.jl  |  5 ++
 .../PackageThatIsSub/test/Project.toml        |  8 +++
 test/project/SubProject/Project.toml          | 13 ++++
 test/project/SubProject/src/MyPkg.jl          |  3 +
 test/project/SubProject/sub/Project.toml      |  3 +
 test/project/SubProject/test/Project.toml     |  4 ++
 16 files changed, 304 insertions(+), 29 deletions(-)
 create mode 100644 test/project/SubProject/Devved/Project.toml
 create mode 100644 test/project/SubProject/Devved/src/Devved.jl
 create mode 100644 test/project/SubProject/Devved2/Project.toml
 create mode 100644 test/project/SubProject/Devved2/src/Devved2.jl
 create mode 100644 test/project/SubProject/Manifest.toml
 create mode 100644 test/project/SubProject/PackageThatIsSub/Project.toml
 create mode 100644 test/project/SubProject/PackageThatIsSub/src/PackageThatIsSub.jl
 create mode 100644 test/project/SubProject/PackageThatIsSub/test/Project.toml
 create mode 100644 test/project/SubProject/Project.toml
 create mode 100644 test/project/SubProject/src/MyPkg.jl
 create mode 100644 test/project/SubProject/sub/Project.toml
 create mode 100644 test/project/SubProject/test/Project.toml

diff --git a/base/loading.jl b/base/loading.jl
index 986efc1e1e5fb..fd8eba6bed460 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -611,6 +611,23 @@ function env_project_file(env::String)::Union{Bool,String}
     end
 end
 
+function base_project(project_file)
+    base_dir = abspath(joinpath(dirname(project_file), ".."))
+    base_project_file = env_project_file(base_dir)
+    base_project_file isa String || return nothing
+    d = parsed_toml(base_project_file)
+    workspace = get(d, "workspace", nothing)::Union{Dict{String, Any}, Nothing}
+    if workspace === nothing
+        return nothing
+    end
+    projects = get(workspace, "projects", nothing)::Union{Vector{String}, Nothing, String}
+    projects === nothing && return nothing
+    if projects isa Vector && basename(dirname(project_file)) in projects
+        return base_project_file
+    end
+    return nothing
+end
+
 function project_deps_get(env::String, name::String)::Union{Nothing,PkgId}
     project_file = env_project_file(env)
     if project_file isa String
@@ -622,21 +639,27 @@ function project_deps_get(env::String, name::String)::Union{Nothing,PkgId}
     return nothing
 end
 
+function package_get(project_file, where::PkgId, name::String)
+    proj = project_file_name_uuid(project_file, where.name)
+    if proj == where
+        # if `where` matches the project, use [deps] section as manifest, and stop searching
+        pkg_uuid = explicit_project_deps_get(project_file, name)
+        return PkgId(pkg_uuid, name)
+    end
+    return nothing
+end
+
 function manifest_deps_get(env::String, where::PkgId, name::String)::Union{Nothing,PkgId}
     uuid = where.uuid
     @assert uuid !== nothing
     project_file = env_project_file(env)
     if project_file isa String
-        # first check if `where` names the Project itself
-        proj = project_file_name_uuid(project_file, where.name)
-        if proj == where
-            # if `where` matches the project, use [deps] section as manifest, and stop searching
-            pkg_uuid = explicit_project_deps_get(project_file, name)
-            return PkgId(pkg_uuid, name)
-        end
+        pkg = package_get(project_file, where, name)
+        pkg === nothing || return pkg
         d = parsed_toml(project_file)
         exts = get(d, "extensions", nothing)::Union{Dict{String, Any}, Nothing}
         if exts !== nothing
+            proj = project_file_name_uuid(project_file, where.name)
             # Check if `where` is an extension of the project
             if where.name in keys(exts) && where.uuid == uuid5(proj.uuid::UUID, where.name)
                 # Extensions can load weak deps...
@@ -726,6 +749,14 @@ function project_file_path(project_file::String)
     joinpath(dirname(project_file), get(d, "path", "")::String)
 end
 
+function workspace_manifest(project_file)
+    base = base_project(project_file)
+    if base !== nothing
+        return project_file_manifest_path(base)
+    end
+    return nothing
+end
+
 # find project file's corresponding manifest file
 function project_file_manifest_path(project_file::String)::Union{Nothing,String}
     @lock require_lock begin
@@ -736,6 +767,10 @@ function project_file_manifest_path(project_file::String)::Union{Nothing,String}
     end
     dir = abspath(dirname(project_file))
     d = parsed_toml(project_file)
+    base_manifest = workspace_manifest(project_file)
+    if base_manifest !== nothing
+        return base_manifest
+    end
     explicit_manifest = get(d, "manifest", nothing)::Union{String, Nothing}
     manifest_path = nothing
     if explicit_manifest !== nothing
@@ -3355,9 +3390,27 @@ function recursive_prefs_merge(base::Dict{String, Any}, overrides::Dict{String,
     return new_base
 end
 
+function get_projects_workspace_to_root(project_file)
+    projects = String[project_file]
+    while true
+        project_file = base_project(project_file)
+        if project_file === nothing
+            return projects
+        end
+        push!(projects, project_file)
+    end
+end
+
 function get_preferences(uuid::Union{UUID,Nothing} = nothing)
     merged_prefs = Dict{String,Any}()
-    for env in reverse(load_path())
+    loadpath = load_path()
+    projects_to_merge_prefs = String[]
+    append!(projects_to_merge_prefs, Iterators.drop(loadpath, 1))
+    if length(loadpath) >= 1
+        prepend!(projects_to_merge_prefs, get_projects_workspace_to_root(first(loadpath)))
+    end
+
+    for env in reverse(projects_to_merge_prefs)
         project_toml = env_project_file(env)
         if !isa(project_toml, String)
             continue
diff --git a/base/precompilation.jl b/base/precompilation.jl
index 50b84ad829d0a..a823b2b579852 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -1,7 +1,8 @@
 module Precompilation
 
 using Base: PkgId, UUID, SHA1, parsed_toml, project_file_name_uuid, project_names,
-            project_file_manifest_path, get_deps, preferences_names, isaccessibledir, isfile_casesensitive
+            project_file_manifest_path, get_deps, preferences_names, isaccessibledir, isfile_casesensitive,
+            base_project
 
 # This is currently only used for pkgprecompile but the plan is to use this in code loading in the future
 # see the `kc/codeloading2.0` branch
@@ -59,6 +60,19 @@ function ExplicitEnv(envpath::String=Base.active_project())
         delete!(project_deps, name)
     end
 
+    # This project might be a package, in that case, that is also a "dependency"
+    # of the project.
+    proj_name = get(project_d, "name", nothing)::Union{String, Nothing}
+    _proj_uuid = get(project_d, "uuid", nothing)::Union{String, Nothing}
+    proj_uuid = _proj_uuid === nothing ? nothing : UUID(_proj_uuid)
+
+    project_is_package = proj_name !== nothing && proj_uuid !== nothing
+    if project_is_package
+        # TODO: Error on missing uuid?
+        project_deps[proj_name] = UUID(proj_uuid)
+        names[UUID(proj_uuid)] = proj_name
+    end
+
     project_extensions = Dict{String, Vector{UUID}}()
     # Collect all extensions of the project
     for (name, triggers::Union{String, Vector{String}}) in get(Dict{String, Any}, project_d, "extensions")::Dict{String, Any}
@@ -76,18 +90,6 @@ function ExplicitEnv(envpath::String=Base.active_project())
         project_extensions[name] = uuids
     end
 
-    # This project might be a package, in that case, that is also a "dependency"
-    # of the project.
-    proj_name = get(project_d, "name", nothing)::Union{String, Nothing}
-    _proj_uuid = get(project_d, "uuid", nothing)::Union{String, Nothing}
-    proj_uuid = _proj_uuid === nothing ? nothing : UUID(_proj_uuid)
-
-    if proj_name !== nothing && proj_uuid !== nothing
-        # TODO: Error on missing uuid?
-        project_deps[proj_name] = UUID(proj_uuid)
-        names[UUID(proj_uuid)] = proj_name
-    end
-
     manifest = project_file_manifest_path(envpath)
     manifest_d = manifest === nothing ? Dict{String, Any}() : parsed_toml(manifest)
 
@@ -355,8 +357,8 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                         configs::Union{Config,Vector{Config}}=(``=>Base.CacheFlags()),
                         io::IO=stderr,
                         # asking for timing disables fancy mode, as timing is shown in non-fancy mode
-                        fancyprint::Bool = can_fancyprint(io) && !timing
-                    )
+                        fancyprint::Bool = can_fancyprint(io) && !timing,
+                        manifest::Bool=false,)
 
     configs = configs isa Config ? [configs] : configs
 
@@ -512,9 +514,15 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     end
     @debug "precompile: circular dep check done"
 
-    # if a list of packages is given, restrict to dependencies of given packages
-    if !isempty(pkgs)
-         function collect_all_deps(depsmap, dep, alldeps=Set{Base.PkgId}())
+    if !manifest
+        if isempty(pkgs)
+            pkgs = [pkg.name for pkg in direct_deps]
+            target = "all packages"
+        else
+            target = join(pkgs, ", ")
+        end
+        # restrict to dependencies of given packages
+        function collect_all_deps(depsmap, dep, alldeps=Set{Base.PkgId}())
             for _dep in depsmap[dep]
                 if !(_dep in alldeps)
                     push!(alldeps, _dep)
@@ -544,13 +552,13 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                 # TODO: actually handle packages from other envs in the stack
                 return
             else
-                error("No direct dependencies outside of the sysimage found matching $(repr(pkgs))")
+                return
             end
         end
-        target = join(pkgs, ", ")
     else
-        target = "project"
+        target = "manifest"
     end
+
     nconfigs = length(configs)
     if nconfigs == 1
         if !isempty(only(configs)[1])
diff --git a/doc/src/manual/code-loading.md b/doc/src/manual/code-loading.md
index 25ebf3475f34c..9e753d2a7de33 100644
--- a/doc/src/manual/code-loading.md
+++ b/doc/src/manual/code-loading.md
@@ -394,6 +394,28 @@ are stored in the manifest file in the section for that package. The dependency
 a package are the same as for its "parent" except that the listed extension dependencies are also considered as
 dependencies.
 
+### [Workspaces](@id workspaces)
+
+A project file can define a workspace by giving a set of projects that is part of that workspace:
+
+```toml
+[workspace]
+projects = ["test", "benchmarks", "docs", "SomePackage"]
+```
+
+Each subfolder contains its own `Project.toml` file, which may include additional dependencies and compatibility constraints. In such cases, the package manager gathers all dependency information from all the projects in the workspace generating a single manifest file that combines the versions of all dependencies.
+
+Furthermore, workspaces can be "nested", meaning a project defining a workspace can also be part of another workspace. In this scenario, a single manifest file is still utilized, stored alongside the "root project" (the project that doesn't have another workspace including it). An example file structure could look like this:
+
+```
+Project.toml # projects = ["MyPackage"]
+Manifest.toml
+MyPackage/
+    Project.toml # projects = ["test"]
+    test/
+        Project.toml
+```
+
 ### [Package/Environment Preferences](@id preferences)
 
 Preferences are dictionaries of metadata that influence package behavior within an environment.
diff --git a/test/loading.jl b/test/loading.jl
index 8ba2cf3026120..872ccd197f0f8 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1550,3 +1550,61 @@ end
     rot13proj = joinpath(@__DIR__, "project", "Rot13")
     @test readchomp(`$(Base.julia_cmd()) --startup-file=no --project=$rot13proj -m Rot13 --project nowhere ABJURER`) == "--cebwrpg abjurer NOWHERE "
 end
+
+@testset "workspace loading" begin
+   old_load_path = copy(LOAD_PATH)
+   try
+       empty!(LOAD_PATH)
+       push!(LOAD_PATH, joinpath(@__DIR__, "project", "SubProject"))
+       @test Base.get_preferences()["value"] == 1
+       @test Base.get_preferences()["x"] == 1
+
+       empty!(LOAD_PATH)
+       push!(LOAD_PATH, joinpath(@__DIR__, "project", "SubProject", "sub"))
+       id = Base.identify_package("Devved")
+       @test isfile(Base.locate_package(id))
+       @test Base.identify_package("Devved2") === nothing
+       id3 = Base.identify_package("MyPkg")
+       @test isfile(Base.locate_package(id3))
+
+       empty!(LOAD_PATH)
+       push!(LOAD_PATH, joinpath(@__DIR__, "project", "SubProject", "PackageThatIsSub"))
+       id_pkg = Base.identify_package("PackageThatIsSub")
+       @test Base.identify_package(id_pkg, "Devved") === nothing
+       id_dev2 = Base.identify_package(id_pkg, "Devved2")
+       @test isfile(Base.locate_package(id_dev2))
+       id_mypkg = Base.identify_package("MyPkg")
+       @test isfile(Base.locate_package(id_mypkg))
+       id_dev = Base.identify_package(id_mypkg, "Devved")
+       @test isfile(Base.locate_package(id_dev))
+       @test Base.get_preferences()["value"] == 2
+       @test Base.get_preferences()["x"] == 1
+       @test Base.get_preferences()["y"] == 2
+
+       empty!(LOAD_PATH)
+       push!(LOAD_PATH, joinpath(@__DIR__, "project", "SubProject", "PackageThatIsSub", "test"))
+       id_pkg = Base.identify_package("PackageThatIsSub")
+       @test isfile(Base.locate_package(id_pkg))
+       @test Base.identify_package(id_pkg, "Devved") === nothing
+       id_dev2 = Base.identify_package(id_pkg, "Devved2")
+       @test isfile(Base.locate_package(id_dev2))
+       id_mypkg = Base.identify_package("MyPkg")
+       @test isfile(Base.locate_package(id_mypkg))
+       id_dev = Base.identify_package(id_mypkg, "Devved")
+       @test isfile(Base.locate_package(id_dev))
+       @test Base.get_preferences()["value"] == 3
+       @test Base.get_preferences()["x"] == 1
+       @test Base.get_preferences()["y"] == 2
+       @test Base.get_preferences()["z"] == 3
+
+       empty!(LOAD_PATH)
+       push!(LOAD_PATH, joinpath(@__DIR__, "project", "SubProject", "test"))
+       id_mypkg = Base.identify_package("MyPkg")
+       id_dev = Base.identify_package(id_mypkg, "Devved")
+       @test isfile(Base.locate_package(id_dev))
+       @test Base.identify_package("Devved2") === nothing
+
+    finally
+       copy!(LOAD_PATH, old_load_path)
+   end
+end
diff --git a/test/project/SubProject/Devved/Project.toml b/test/project/SubProject/Devved/Project.toml
new file mode 100644
index 0000000000000..63088a132cb77
--- /dev/null
+++ b/test/project/SubProject/Devved/Project.toml
@@ -0,0 +1,3 @@
+name = "Devved"
+uuid = "cbce3a6e-7a3d-4e84-8e6d-b87208df7599"
+version = "0.1.0"
diff --git a/test/project/SubProject/Devved/src/Devved.jl b/test/project/SubProject/Devved/src/Devved.jl
new file mode 100644
index 0000000000000..f3eb267409ece
--- /dev/null
+++ b/test/project/SubProject/Devved/src/Devved.jl
@@ -0,0 +1,5 @@
+module Devved
+
+greet() = print("Hello World!")
+
+end # module Devved
diff --git a/test/project/SubProject/Devved2/Project.toml b/test/project/SubProject/Devved2/Project.toml
new file mode 100644
index 0000000000000..c761630566116
--- /dev/null
+++ b/test/project/SubProject/Devved2/Project.toml
@@ -0,0 +1,3 @@
+name = "Devved2"
+uuid = "08f74b90-50f5-462f-80b9-a72b1258a17b"
+version = "0.1.0"
diff --git a/test/project/SubProject/Devved2/src/Devved2.jl b/test/project/SubProject/Devved2/src/Devved2.jl
new file mode 100644
index 0000000000000..9bd5df2793671
--- /dev/null
+++ b/test/project/SubProject/Devved2/src/Devved2.jl
@@ -0,0 +1,5 @@
+module Devved2
+
+greet() = print("Hello World!")
+
+end # module Devved2
diff --git a/test/project/SubProject/Manifest.toml b/test/project/SubProject/Manifest.toml
new file mode 100644
index 0000000000000..5d791a74652d4
--- /dev/null
+++ b/test/project/SubProject/Manifest.toml
@@ -0,0 +1,68 @@
+# This file is machine-generated - editing it directly is not advised
+
+julia_version = "1.12.0-DEV"
+manifest_format = "2.0"
+project_hash = "620b9377bc807ff657e6618c8ccc24887eb40285"
+
+[[deps.Base64]]
+uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+version = "1.11.0"
+
+[[deps.Devved]]
+path = "Devved"
+uuid = "cbce3a6e-7a3d-4e84-8e6d-b87208df7599"
+version = "0.1.0"
+
+[[deps.Devved2]]
+path = "Devved2"
+uuid = "08f74b90-50f5-462f-80b9-a72b1258a17b"
+version = "0.1.0"
+
+[[deps.InteractiveUtils]]
+deps = ["Markdown"]
+uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+version = "1.11.0"
+
+[[deps.Logging]]
+deps = ["StyledStrings"]
+uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
+version = "1.11.0"
+
+[[deps.Markdown]]
+deps = ["Base64"]
+uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
+version = "1.11.0"
+
+[[deps.MyPkg]]
+deps = ["Devved", "Devved2"]
+path = "."
+uuid = "0cafdeb2-d7a2-40d0-8d22-4411fcc2c4ee"
+version = "0.0.0"
+
+[[deps.PackageThatIsSub]]
+deps = ["Devved2", "MyPkg"]
+path = "PackageThatIsSub"
+uuid = "1efb588c-9412-4e40-90a4-710420bd84aa"
+version = "0.1.0"
+
+[[deps.Random]]
+deps = ["SHA"]
+uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+version = "1.11.0"
+
+[[deps.SHA]]
+uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"
+version = "0.7.0"
+
+[[deps.Serialization]]
+uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+version = "1.11.0"
+
+[[deps.StyledStrings]]
+uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b"
+version = "1.11.0"
+
+[[deps.Test]]
+deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
+uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+version = "1.11.0"
diff --git a/test/project/SubProject/PackageThatIsSub/Project.toml b/test/project/SubProject/PackageThatIsSub/Project.toml
new file mode 100644
index 0000000000000..e41dd998c5a1c
--- /dev/null
+++ b/test/project/SubProject/PackageThatIsSub/Project.toml
@@ -0,0 +1,14 @@
+name = "PackageThatIsSub"
+uuid = "1efb588c-9412-4e40-90a4-710420bd84aa"
+version = "0.1.0"
+
+[workspace]
+projects = ["test"]
+
+[deps]
+Devved2 = "08f74b90-50f5-462f-80b9-a72b1258a17b"
+MyPkg = "0cafdeb2-d7a2-40d0-8d22-4411fcc2c4ee"
+
+[preferences]
+value = 2
+y = 2
diff --git a/test/project/SubProject/PackageThatIsSub/src/PackageThatIsSub.jl b/test/project/SubProject/PackageThatIsSub/src/PackageThatIsSub.jl
new file mode 100644
index 0000000000000..7f9ea94ccb156
--- /dev/null
+++ b/test/project/SubProject/PackageThatIsSub/src/PackageThatIsSub.jl
@@ -0,0 +1,5 @@
+module PackageThatIsSub
+
+greet() = print("Hello World!")
+
+end # module PackageThatIsSub
diff --git a/test/project/SubProject/PackageThatIsSub/test/Project.toml b/test/project/SubProject/PackageThatIsSub/test/Project.toml
new file mode 100644
index 0000000000000..dc8186e2b735e
--- /dev/null
+++ b/test/project/SubProject/PackageThatIsSub/test/Project.toml
@@ -0,0 +1,8 @@
+[deps]
+MyPkg = "0cafdeb2-d7a2-40d0-8d22-4411fcc2c4ee"
+PackageThatIsSub = "1efb588c-9412-4e40-90a4-710420bd84aa"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[preferences]
+value = 3
+z = 3
diff --git a/test/project/SubProject/Project.toml b/test/project/SubProject/Project.toml
new file mode 100644
index 0000000000000..dcb84d865ac85
--- /dev/null
+++ b/test/project/SubProject/Project.toml
@@ -0,0 +1,13 @@
+name = "MyPkg"
+uuid = "0cafdeb2-d7a2-40d0-8d22-4411fcc2c4ee"
+
+[workspace]
+projects = ["sub", "PackageThatIsSub", "test"]
+
+[deps]
+Devved = "cbce3a6e-7a3d-4e84-8e6d-b87208df7599"
+Devved2 = "08f74b90-50f5-462f-80b9-a72b1258a17b"
+
+[preferences]
+value = 1
+x = 1
diff --git a/test/project/SubProject/src/MyPkg.jl b/test/project/SubProject/src/MyPkg.jl
new file mode 100644
index 0000000000000..6d84954645d55
--- /dev/null
+++ b/test/project/SubProject/src/MyPkg.jl
@@ -0,0 +1,3 @@
+module MyPkg
+
+end
diff --git a/test/project/SubProject/sub/Project.toml b/test/project/SubProject/sub/Project.toml
new file mode 100644
index 0000000000000..50aa238e91d57
--- /dev/null
+++ b/test/project/SubProject/sub/Project.toml
@@ -0,0 +1,3 @@
+[deps]
+Devved = "cbce3a6e-7a3d-4e84-8e6d-b87208df7599"
+MyPkg = "0cafdeb2-d7a2-40d0-8d22-4411fcc2c4ee"
diff --git a/test/project/SubProject/test/Project.toml b/test/project/SubProject/test/Project.toml
new file mode 100644
index 0000000000000..b64312e4b1ee2
--- /dev/null
+++ b/test/project/SubProject/test/Project.toml
@@ -0,0 +1,4 @@
+[deps]
+MyPkg = "0cafdeb2-d7a2-40d0-8d22-4411fcc2c4ee"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+Devved = "cbce3a6e-7a3d-4e84-8e6d-b87208df7599"

From 9636ef72eebe0155710471fb79eb5c75cc26949b Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Mon, 25 Mar 2024 10:23:54 -0300
Subject: [PATCH 1169/1315] create phantom task for GC threads (#53815)

A common idiom used throughout the codebase is to get a pointer to
thread-local-state through `jl_current_task->ptls`.

Create a phantom task for GC threads so that we can make use of this
idiom when running in the GC threads as well.

Idea originally suggested by @vchuravy, bugs are mine.
---
 src/scheduler.c | 10 ++++++++++
 src/task.c      |  1 +
 2 files changed, 11 insertions(+)

diff --git a/src/scheduler.c b/src/scheduler.c
index 1b6a20a36887a..a04320beec00d 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -129,6 +129,11 @@ void jl_parallel_gc_threadfun(void *arg)
 
     // initialize this thread (set tid and create heap)
     jl_ptls_t ptls = jl_init_threadtls(targ->tid);
+    void *stack_lo, *stack_hi;
+    jl_init_stack_limits(0, &stack_lo, &stack_hi);
+    // warning: this changes `jl_current_task`, so be careful not to call that from this function
+    jl_task_t *ct = jl_init_root_task(ptls, stack_lo, stack_hi);
+    JL_GC_PROMISE_ROOTED(ct);
     (void)jl_atomic_fetch_add_relaxed(&nrunning, -1);
     // wait for all threads
     jl_gc_state_set(ptls, JL_GC_STATE_WAITING, JL_GC_STATE_UNSAFE);
@@ -158,6 +163,11 @@ void jl_concurrent_gc_threadfun(void *arg)
 
     // initialize this thread (set tid and create heap)
     jl_ptls_t ptls = jl_init_threadtls(targ->tid);
+    void *stack_lo, *stack_hi;
+    jl_init_stack_limits(0, &stack_lo, &stack_hi);
+    // warning: this changes `jl_current_task`, so be careful not to call that from this function
+    jl_task_t *ct = jl_init_root_task(ptls, stack_lo, stack_hi);
+    JL_GC_PROMISE_ROOTED(ct);
     (void)jl_atomic_fetch_add_relaxed(&nrunning, -1);
     // wait for all threads
     jl_gc_state_set(ptls, JL_GC_STATE_WAITING, JL_GC_STATE_UNSAFE);
diff --git a/src/task.c b/src/task.c
index a7250c36832ea..5f28c3c243bfe 100644
--- a/src/task.c
+++ b/src/task.c
@@ -1649,6 +1649,7 @@ jl_task_t *jl_init_root_task(jl_ptls_t ptls, void *stack_lo, void *stack_hi)
     JL_GC_PROMISE_ROOTED(ct);
     jl_set_pgcstack(&ct->gcstack);
     assert(jl_current_task == ct);
+    assert(jl_current_task->ptls == ptls);
 
 #ifdef _COMPILER_TSAN_ENABLED_
     ct->ctx.tsan_state = __tsan_get_current_fiber();

From 944f1809185455a1c57207983c1d0f8904343503 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogumi=C5=82=20Kami=C5=84ski?= <bkamins@sgh.waw.pl>
Date: Mon, 25 Mar 2024 16:18:44 +0100
Subject: [PATCH 1170/1315] Add Xoshiro reference to Random module docstring
 (#53784)

Since currently `Xoshiro` is a default random number generator I propose
to add it to the docstring of `Random` module.
---
 stdlib/Random/src/Random.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/Random/src/Random.jl b/stdlib/Random/src/Random.jl
index 432e32a4de691..9ce0896d0d125 100644
--- a/stdlib/Random/src/Random.jl
+++ b/stdlib/Random/src/Random.jl
@@ -4,7 +4,7 @@
     Random
 
 Support for generating random numbers. Provides [`rand`](@ref), [`randn`](@ref),
-[`AbstractRNG`](@ref), [`MersenneTwister`](@ref), and [`RandomDevice`](@ref).
+[`AbstractRNG`](@ref), [`Xoshiro`](@ref), [`MersenneTwister`](@ref), and [`RandomDevice`](@ref).
 """
 module Random
 

From 61caaa886afe18273e2f7b7d09a714298a62a9b3 Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Mon, 25 Mar 2024 18:54:09 +0100
Subject: [PATCH 1171/1315] update MPFR to 4.2.1 (#53837)

MPFR 4.2.1 was released on 22 August 2023.
It contains bugfixes.
---
 deps/checksums/mpfr              | 68 ++++++++++++++++----------------
 deps/mpfr.version                |  2 +-
 stdlib/MPFR_jll/Project.toml     |  2 +-
 stdlib/MPFR_jll/test/runtests.jl |  2 +-
 stdlib/Manifest.toml             |  2 +-
 5 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/deps/checksums/mpfr b/deps/checksums/mpfr
index 1bb4eca6bf4ad..050e9cbd8d5a8 100644
--- a/deps/checksums/mpfr
+++ b/deps/checksums/mpfr
@@ -1,34 +1,34 @@
-MPFR.v4.2.0+1.aarch64-apple-darwin.tar.gz/md5/f9393a636497b19c846343b456b2dd7e
-MPFR.v4.2.0+1.aarch64-apple-darwin.tar.gz/sha512/a77a0387e84f572ef5558977096e70da8eb7b3674a8198cc6ae35462971f76d684145ffae7c2ddca32e2bd1c8b2ccb33e4447eb8606d5d5cd5958298472b3ea9
-MPFR.v4.2.0+1.aarch64-linux-gnu.tar.gz/md5/ade253017d195de694780c32f9161dcf
-MPFR.v4.2.0+1.aarch64-linux-gnu.tar.gz/sha512/1b68de5f8e557b7434c8c1bc016227b58683b56c0977b763422ea85a673bec446fcfee3a4f69e1d4689abb9bb6bf47f2a50fbb56ecac6a9d40096e66bd0f2080
-MPFR.v4.2.0+1.aarch64-linux-musl.tar.gz/md5/7dbd121c7192ccaf7191de5ab8d91afb
-MPFR.v4.2.0+1.aarch64-linux-musl.tar.gz/sha512/8614e3cb28491b24a0ec5060b44abaf264b61c91ddd29d70105ff583bd3112cff1b9bd5ed45e39f186265333982d5eeb8bf35fedc3b51b2a009cc7a51046b50b
-MPFR.v4.2.0+1.armv6l-linux-gnueabihf.tar.gz/md5/adb2b7fdf111c8b19df1516cfb278bb1
-MPFR.v4.2.0+1.armv6l-linux-gnueabihf.tar.gz/sha512/0c47aeffd05a194802f6c4e0e2779d56fb46007e6c3e145ee6992854a21a317a9d51512c59a0ce4ddcd314c387945225c6557d6c2ab6961ae4848875e8983de8
-MPFR.v4.2.0+1.armv6l-linux-musleabihf.tar.gz/md5/c30358bdeffcff65ba9be906cd35889b
-MPFR.v4.2.0+1.armv6l-linux-musleabihf.tar.gz/sha512/2857ec27ae2d53a451d62dd241ce9b43f7ee182bee180ecd9ad92c907c66d0b0ab2d1ea3b20fe61cc176ae44ecbe6041305cc8a9343b396c9cb54dd77a1e2868
-MPFR.v4.2.0+1.armv7l-linux-gnueabihf.tar.gz/md5/a1e30436bade2150c9dc924177f0c321
-MPFR.v4.2.0+1.armv7l-linux-gnueabihf.tar.gz/sha512/d2f4662c494fefda66847e7a085edda3ce396383aafb4e17fc2e176191b0f530541726c261cac3467f13136e8ec728c8a7cf0e352f3e9ebf960d153cbfe766b8
-MPFR.v4.2.0+1.armv7l-linux-musleabihf.tar.gz/md5/857e3c82804e7c853d21603f18caa715
-MPFR.v4.2.0+1.armv7l-linux-musleabihf.tar.gz/sha512/86cf3e940fd66820b5269e9aa2a49c3fc3077857bec037a08e0d301b0bf3cc5c79ac331cc6370d852e20f4acf8f601c49d5dbe24e96652e4411b3f33a11e3f45
-MPFR.v4.2.0+1.i686-linux-gnu.tar.gz/md5/5a432be79a112e67e970980f4bde13a0
-MPFR.v4.2.0+1.i686-linux-gnu.tar.gz/sha512/94198b23ac94dcb9dca95938a46b9899c3ef329bafbb13b32076cd3415b89f11908632c7c07e90549c01bd9ed7fc9a002dae07a645f85b8509234c49be729621
-MPFR.v4.2.0+1.i686-linux-musl.tar.gz/md5/4ce71dc250c2469f844a02c6ee6571a1
-MPFR.v4.2.0+1.i686-linux-musl.tar.gz/sha512/134b67b23de75ab172594cd0fac55b5c265730bfea195978698e3e6fbc47d65617652bd72d90ba092ed1bac4c29d5b2c109df5d8dc60b5d8f91159fd58575b67
-MPFR.v4.2.0+1.i686-w64-mingw32.tar.gz/md5/be7239432e8a26c59e2d418d310bd6e3
-MPFR.v4.2.0+1.i686-w64-mingw32.tar.gz/sha512/3144d84d41996fc19bfc9ed4f36755838470e17dce79895b37d93e32ae1cb1da428f2136948f939b19548d7dd62830ae43c434f88efbe192ed3184bae2df5970
-MPFR.v4.2.0+1.powerpc64le-linux-gnu.tar.gz/md5/d818894054b38232ba02ee0e129f6fe0
-MPFR.v4.2.0+1.powerpc64le-linux-gnu.tar.gz/sha512/0e73ca926f3e06466d1899f0b3e9ae4abe15102804dce6716ce23154344a571773c40d276f0038a0ae4e626799867ee715428e1d961334a01ad3091745367e8e
-MPFR.v4.2.0+1.x86_64-apple-darwin.tar.gz/md5/9652148df4e771be39713c4f43d3ff61
-MPFR.v4.2.0+1.x86_64-apple-darwin.tar.gz/sha512/91a0219fd1880dfa90d196fa403f4e1df0347ced58a4772492196b94476f346d80696885a4f3520424494bc09679cca0c0ccf2f6e9247d60b52ebdf564485e72
-MPFR.v4.2.0+1.x86_64-linux-gnu.tar.gz/md5/4de39327a792be708119ac7b43957628
-MPFR.v4.2.0+1.x86_64-linux-gnu.tar.gz/sha512/447b59d5589a8517061627668e8baed4366408cacc9d8e063528b9b795de6d27e4005844578310185f03f568f4948bc4a794624235875fb61b6187264b6f483b
-MPFR.v4.2.0+1.x86_64-linux-musl.tar.gz/md5/f9b8c3c094b339341b19828cc5e1d47c
-MPFR.v4.2.0+1.x86_64-linux-musl.tar.gz/sha512/c661e7c5bded3bdf11b2bd5e5ef4ad8e446934d9b82dfe26f0be1b83cea98d7e56e0903bfc1075f91c8d23401cc6b3b722f2d60f46d73cab884e81fe518aba27
-MPFR.v4.2.0+1.x86_64-unknown-freebsd.tar.gz/md5/e402dceae753abbdd8b11f3c8d96e0dd
-MPFR.v4.2.0+1.x86_64-unknown-freebsd.tar.gz/sha512/235f001f3b0101a6bafaeb45fb49d2992549b6c2f42a4e7ba38e1fa8c59246fe7463598e7cfda5ead50c9805dda0b82a23b5ae2af4ec993bb771611163e58907
-MPFR.v4.2.0+1.x86_64-w64-mingw32.tar.gz/md5/c5bbd2217060491e2773bdd84b055e5c
-MPFR.v4.2.0+1.x86_64-w64-mingw32.tar.gz/sha512/74b059b22990ab79f243284687f571f47447457ac2c1cb4c4548ea1f3d8ea01b7466281f48429cb39e2d11394fb86650bfada7acab639c6537a143a95bd6e7ca
-mpfr-4.2.0.tar.bz2/md5/f8c66d737283fd35f9fe433fb419b05f
-mpfr-4.2.0.tar.bz2/sha512/cb2a9314b94e34a4ea49ce2619802e9420c982e55258a4bc423f802740632646a3d420e7fcf373b19618385b8b2b412abfa127e8f473053863424cac233893c0
+MPFR.v4.2.1+0.aarch64-apple-darwin.tar.gz/md5/816f9ff59070f21f1df2f310e2606c06
+MPFR.v4.2.1+0.aarch64-apple-darwin.tar.gz/sha512/dad9adba7a8867d1ce26d77efb5c33b602b920a2cdbec84ea58a054cfab3ab7df54d2bda101de72b71604e7844993f1e216b002ba092e69277d0764040216c81
+MPFR.v4.2.1+0.aarch64-linux-gnu.tar.gz/md5/c1e3c9619af6454d8adae9bcbd911dba
+MPFR.v4.2.1+0.aarch64-linux-gnu.tar.gz/sha512/5d916492aa73d11e022a7ca3f31940ceb8f8667bdf878ba29d6256736a380a2f6a11ac90cd8de3f1d3454a79165db240a1b971b9794fd21692ed64502ec34b9a
+MPFR.v4.2.1+0.aarch64-linux-musl.tar.gz/md5/8ada267e2d23eb0c65ab2d2df02362d5
+MPFR.v4.2.1+0.aarch64-linux-musl.tar.gz/sha512/0c7f18e6d0f3e2052541e3279dfa9a74eb34067ac4fea0b17ab805cd73010cc83f8d7cb4eda8f4a904da398268d1c0d638c35521a9f339f8c7c3b5f159f27277
+MPFR.v4.2.1+0.armv6l-linux-gnueabihf.tar.gz/md5/42bdb78eee83f496d7da699ad9603913
+MPFR.v4.2.1+0.armv6l-linux-gnueabihf.tar.gz/sha512/edaa9ece1404a606d6b635406ad5e721c8d094ffa1c73ce19222afc2b4ea7b3b9e23e7c5589ae10fd9f4c4aefa265773bcfce6c510efbca57782115d43daeb13
+MPFR.v4.2.1+0.armv6l-linux-musleabihf.tar.gz/md5/2213207772b8a50de4768816fdc20e2f
+MPFR.v4.2.1+0.armv6l-linux-musleabihf.tar.gz/sha512/d24debc38b8135ac5c10c4ea19de0c69126b6881940b4e182118e12cc2c7cf0aca2db065620f0cca636742da32eddec5bda3b4f449a035274f05120c977ed449
+MPFR.v4.2.1+0.armv7l-linux-gnueabihf.tar.gz/md5/a0d9fe20c9ff0027b6816ee0102b1f9a
+MPFR.v4.2.1+0.armv7l-linux-gnueabihf.tar.gz/sha512/97ce02898dc0d29a616048fd7ecee3100a710f7a30a21f2276c01675749034a5241be88bd46dff3dbf9ea0adca98a4357bd16e43fa9520e7a02477494c2d072e
+MPFR.v4.2.1+0.armv7l-linux-musleabihf.tar.gz/md5/7898b9047c914b290b5928af5df63030
+MPFR.v4.2.1+0.armv7l-linux-musleabihf.tar.gz/sha512/cbefa9588752c65751630832417c1c42e4819d49ff9a505f61c2567ef4271097e585542fa898efd61409a43e439d827bb79f693a0937d0a3a427b39535979588
+MPFR.v4.2.1+0.i686-linux-gnu.tar.gz/md5/15fa598e5c1c723ff6cd2ad3ea51e437
+MPFR.v4.2.1+0.i686-linux-gnu.tar.gz/sha512/2ec4cf0c88363bc9fb39522bbcd6a9c2311c38efb166f604aab118fed39712beea68367ff5c4cabb2b7b3f5a53469414b8552fd22a70a637cbbfc936f0c4851b
+MPFR.v4.2.1+0.i686-linux-musl.tar.gz/md5/6dc6a00d3ea22e2c60374d49926598d6
+MPFR.v4.2.1+0.i686-linux-musl.tar.gz/sha512/4a90356091b53d7238dda59f6e9c5c420614f16460dc67310e581611ad46a2dd3324d6164cfecf1bcd660b8f2e473f0afe137aac954c608b11be3acbda648e14
+MPFR.v4.2.1+0.i686-w64-mingw32.tar.gz/md5/bda99a916573607716c61473153a1927
+MPFR.v4.2.1+0.i686-w64-mingw32.tar.gz/sha512/ed3f45ff5ac8f4588584dd80036d9f3623651c87276a9b624955c831009dc33f8804c2845bd187ba750515725c29d65ac5d70c71db1b953c618cd771d2b066d0
+MPFR.v4.2.1+0.powerpc64le-linux-gnu.tar.gz/md5/ac70f716bddd5323b4add663b473b52d
+MPFR.v4.2.1+0.powerpc64le-linux-gnu.tar.gz/sha512/ebb0f5ea76c892b7a4e4636706e71f476aaea58bb88e1734a7966c44495fda8c81318e0e8629e208185f0fc8d0c73b6f3463034cd831dfb5fbbd493a0689bc06
+MPFR.v4.2.1+0.x86_64-apple-darwin.tar.gz/md5/ff13e865e3be717b0fffc16296cb2f56
+MPFR.v4.2.1+0.x86_64-apple-darwin.tar.gz/sha512/98479210910945714da0285a40803674242581894a731ba4709c70dc1341849e736a88aa4914df0ff536c15f8848c417e712ff6abeb25047d300f8b215fd131f
+MPFR.v4.2.1+0.x86_64-linux-gnu.tar.gz/md5/48194b9f92ad01b168e8b9612f4c9559
+MPFR.v4.2.1+0.x86_64-linux-gnu.tar.gz/sha512/638eb40d23fd492972809cdc3326ad4c2c99d3eae1ca5f7c0da6e0e335bb596de2899da5b3e65153225654b2cd9a805298e7241a21395e07d0b333eb1f101b5d
+MPFR.v4.2.1+0.x86_64-linux-musl.tar.gz/md5/0babbb823964ccebf63b42fd07f08936
+MPFR.v4.2.1+0.x86_64-linux-musl.tar.gz/sha512/880b685d9b456fa2bf78e707273783423f9ff00791b529eba00c5e1b94ff96f4ba01e680152a4d6b45b695e3c1169d07f793db42c5a4120861813d5458dfc828
+MPFR.v4.2.1+0.x86_64-unknown-freebsd.tar.gz/md5/f11d634e5a19177fe36b2b2f6f5727ca
+MPFR.v4.2.1+0.x86_64-unknown-freebsd.tar.gz/sha512/291245c06edf31b2e39b6774359ebd4f95b924f19d2a7e8581822a5bf908426d00f0452c061a027da0d7d4bb2fa1bb7ef8ab6d8e49bc848d6d7450a8d5c8a9c4
+MPFR.v4.2.1+0.x86_64-w64-mingw32.tar.gz/md5/e6d1347d5da312f7301d578ce9d7c4d9
+MPFR.v4.2.1+0.x86_64-w64-mingw32.tar.gz/sha512/3ea4b944172be250677ef271f1e10c2b95861755f203795a50b8d0f76f72498897059271e44e038625c3b73cccbd0165685d60afa994180d42e912bffbe86729
+mpfr-4.2.1.tar.bz2/md5/7765afa036e4ce7fb0e02bce0fef894b
+mpfr-4.2.1.tar.bz2/sha512/c81842532ecc663348deb7400d911ad71933d3b525a2f9e5adcd04265c9c0fdd1f22eca229f482703ac7f222ef209fc9e339dd1fa47d72ae57f7f70b2336a76f
diff --git a/deps/mpfr.version b/deps/mpfr.version
index e4f1c8a45aeb0..ec109e181ecdc 100644
--- a/deps/mpfr.version
+++ b/deps/mpfr.version
@@ -2,4 +2,4 @@
 MPFR_JLL_NAME := MPFR
 
 ## source build
-MPFR_VER := 4.2.0
+MPFR_VER := 4.2.1
diff --git a/stdlib/MPFR_jll/Project.toml b/stdlib/MPFR_jll/Project.toml
index e4b24d070db55..eaa8d0988b2ca 100644
--- a/stdlib/MPFR_jll/Project.toml
+++ b/stdlib/MPFR_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "MPFR_jll"
 uuid = "3a97d323-0669-5f0c-9066-3539efd106a3"
-version = "4.2.0+1"
+version = "4.2.1+0"
 
 [deps]
 GMP_jll = "781609d7-10c4-51f6-84f2-b8444358ff6d"
diff --git a/stdlib/MPFR_jll/test/runtests.jl b/stdlib/MPFR_jll/test/runtests.jl
index 81b6e06ed7b49..fc931b462fa9c 100644
--- a/stdlib/MPFR_jll/test/runtests.jl
+++ b/stdlib/MPFR_jll/test/runtests.jl
@@ -4,5 +4,5 @@ using Test, Libdl, MPFR_jll
 
 @testset "MPFR_jll" begin
     vn = VersionNumber(unsafe_string(ccall((:mpfr_get_version,libmpfr), Cstring, ())))
-    @test vn == v"4.2.0"
+    @test vn == v"4.2.1"
 end
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index f2ae43f231db5..456eee252e774 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -137,7 +137,7 @@ version = "1.11.0"
 [[deps.MPFR_jll]]
 deps = ["Artifacts", "GMP_jll", "Libdl"]
 uuid = "3a97d323-0669-5f0c-9066-3539efd106a3"
-version = "4.2.0+1"
+version = "4.2.1+0"
 
 [[deps.Markdown]]
 deps = ["Base64"]

From cd523fec76507b9c55a4b99072389f563043c041 Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Tue, 26 Mar 2024 02:21:39 +0100
Subject: [PATCH 1172/1315] Update nghttp2 to 1.60.0 (#53842)

Released 1st March 2024:
https://github.com/nghttp2/nghttp2/releases/tag/v1.60.0
---
 deps/checksums/nghttp2              | 68 ++++++++++++++---------------
 deps/nghttp2.version                |  2 +-
 stdlib/Manifest.toml                |  2 +-
 stdlib/nghttp2_jll/Project.toml     |  2 +-
 stdlib/nghttp2_jll/test/runtests.jl |  2 +-
 5 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/deps/checksums/nghttp2 b/deps/checksums/nghttp2
index cfe5dbbab17ee..f8226d4f68b3d 100644
--- a/deps/checksums/nghttp2
+++ b/deps/checksums/nghttp2
@@ -1,34 +1,34 @@
-nghttp2-1.59.0.tar.bz2/md5/ed847a9f718b0bed4491a51344e8e6c8
-nghttp2-1.59.0.tar.bz2/sha512/63c497afdebb98a3a38fe41ff9ef0027d670231fbd118cef22b6340829df5de91df3d4f503135d54e54f9ee056f71efbda640b78f4fbb9ff56ba085177bb41f8
-nghttp2.v1.59.0+0.aarch64-apple-darwin.tar.gz/md5/531f9c56fe3d2d4e4457cf4245fc8a81
-nghttp2.v1.59.0+0.aarch64-apple-darwin.tar.gz/sha512/497b26a66da86ad8d0a28323a18b4ee9cd9682b6ff8ef681d760cd17bc3e82ea98385e2d621e8060a706b50531afdf6f63fa3717005446c4159780f73d17f8da
-nghttp2.v1.59.0+0.aarch64-linux-gnu.tar.gz/md5/9e853f884f638534b5ce88112c7b1fbd
-nghttp2.v1.59.0+0.aarch64-linux-gnu.tar.gz/sha512/72da4843e3b2b01f568d61894a7c83ace1f175667e0b64663f8bcca9a7315509f5b91f96b21508aba6009d7d33ccdf75f4aed8a8dc45ed0934654512ef2200f0
-nghttp2.v1.59.0+0.aarch64-linux-musl.tar.gz/md5/25f1489b3cc3a5bef92af5bf136e62b5
-nghttp2.v1.59.0+0.aarch64-linux-musl.tar.gz/sha512/abe1f8c5faa2a1ae6308d1c13850cc6288b13f744576de574fa6e0871f372da9121059814b467b9d5763c2bdd54ef4a38ba842a394e23735a2cc5b9c7fec13fe
-nghttp2.v1.59.0+0.armv6l-linux-gnueabihf.tar.gz/md5/33448bd8e19b63811f07e7f8f6d84fbd
-nghttp2.v1.59.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/b327d63e3742528f2d3b17dc97923429acd71156e4b688118295f7e7257c6313869e742b2475ee2540436d5cd68ac9224298c9ca0be4ec7c8a8b9741b65d210e
-nghttp2.v1.59.0+0.armv6l-linux-musleabihf.tar.gz/md5/8e6836af6f1e7532b1ada585a31bc9ad
-nghttp2.v1.59.0+0.armv6l-linux-musleabihf.tar.gz/sha512/db17877b4bafd608fe844959e1640060161a6e36ba762053b9f7153d075c3c3eadea61d72dd9f9683cec3c4b0564f284eb0b443d1715a5af77afa6f8abfa2ed4
-nghttp2.v1.59.0+0.armv7l-linux-gnueabihf.tar.gz/md5/f537e4776bbb1d9e85f8eea76df99679
-nghttp2.v1.59.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/60bb3612a8021c194a0766775583b137f5f48ed3c7d4e1afbbeeef617a5a959494c35df34d2e9a68e53b8bb676b67de5b0b47f6e98543ecccd8fe10cee2ea3dd
-nghttp2.v1.59.0+0.armv7l-linux-musleabihf.tar.gz/md5/ffecbf49f667cd0a2c09919299ffa54e
-nghttp2.v1.59.0+0.armv7l-linux-musleabihf.tar.gz/sha512/c34cdbe0074012c6889dfb9c93c44a4b1b0ed86197428f97b1d7b1bcd829f384121b8fc60f2c608e4206dc203739df9382a0653e75362eef282616c65251de24
-nghttp2.v1.59.0+0.i686-linux-gnu.tar.gz/md5/bb8b7668b5de15e3cdab955f905b6681
-nghttp2.v1.59.0+0.i686-linux-gnu.tar.gz/sha512/42be179bbe6a9b4c9a7f086177a23bfa0d99ec3b8ff4741a7656bcd302de9613cdb1bf556e483d924a3362c150d3286de30531d226ac402ca4a464fad3271175
-nghttp2.v1.59.0+0.i686-linux-musl.tar.gz/md5/298fb89147eb458a5f948ac6298213c1
-nghttp2.v1.59.0+0.i686-linux-musl.tar.gz/sha512/693b41d8e764f1475b79aff74c036697779dc82ac5dc79cd4d25c15ef9627e398c50cc43ad4296b96c3b6fdbb4c7514a041396570b82b3d35ef27c6c2286e8e1
-nghttp2.v1.59.0+0.i686-w64-mingw32.tar.gz/md5/b69df3b2a034b0309b5ae97ecf6e803a
-nghttp2.v1.59.0+0.i686-w64-mingw32.tar.gz/sha512/1c349ccb0799942f117f56f0e2f83f898b5913071651e4bb8d1750d7ab6fdc9b6e3e894ee760623b27ae23ba7910a6674b5bbda7db3a8388fef68c0908e2ec7d
-nghttp2.v1.59.0+0.powerpc64le-linux-gnu.tar.gz/md5/fc101f34e22f8885ed4141514572f2ea
-nghttp2.v1.59.0+0.powerpc64le-linux-gnu.tar.gz/sha512/c7377429fcf47a0a7e9c2a1ca78d4eeba819f6f7f2fb1191fa46b7ce516db6a489994993abe50e2848cc7ab600a747cbc13e8e6484077cb8ca8fe37775bd0016
-nghttp2.v1.59.0+0.x86_64-apple-darwin.tar.gz/md5/9f81d5bd0aa9b1b4e1536020f59496ee
-nghttp2.v1.59.0+0.x86_64-apple-darwin.tar.gz/sha512/c8a0641b5255a70e305b4baf5689914fc4abf795ade4ddb636243d40828195bdf2d2df394e4f8680beb70f0e497d5ceae90f6453b32ebf5d77ed03239bbb64c4
-nghttp2.v1.59.0+0.x86_64-linux-gnu.tar.gz/md5/954ef507adf403630588734a5c1ec42e
-nghttp2.v1.59.0+0.x86_64-linux-gnu.tar.gz/sha512/e4de84a962e2a9a4b9b61fa69d0816db5daa271fa3440f01eb116856e5f8c9cdd0cf0aa63ff9fffd51073548ee81e94d83b4d3fd096efa6c38983047ac8a556a
-nghttp2.v1.59.0+0.x86_64-linux-musl.tar.gz/md5/d14e89c0473ccbfa0ccb6291069f605b
-nghttp2.v1.59.0+0.x86_64-linux-musl.tar.gz/sha512/5255c8e9b501b636fd78b90b46c7e46d583f1ec3328a512153f2460c3f5136ac024e9c9f05c44be8efb8eee687b95080154c6c086358755c167ff9defac37146
-nghttp2.v1.59.0+0.x86_64-unknown-freebsd.tar.gz/md5/3a396ec020b3e9f067ffbe36315f250a
-nghttp2.v1.59.0+0.x86_64-unknown-freebsd.tar.gz/sha512/bfc14de5851428548816f289032dce4adcfd17d3ffddd77785777f573df5950ae40df006164ef256eda19a9402101c05dcd994e8bf4f566ddb73a51b8cc1a641
-nghttp2.v1.59.0+0.x86_64-w64-mingw32.tar.gz/md5/300bf8563122e081a17a836fd0d62b6e
-nghttp2.v1.59.0+0.x86_64-w64-mingw32.tar.gz/sha512/7967faa9ff64897e4ea6cddff8e70c823472b9b0a814055b7032546cdada76904b28d4b3d0408377108e54b5aac67b83177c03afd71424bb2d4a5bd1d3f96827
+nghttp2-1.60.0.tar.bz2/md5/ec20d9a6df7cc006894f72f81f9f2b42
+nghttp2-1.60.0.tar.bz2/sha512/95b76dd492dad490640469c4b806dd1a446f11143bc990220ff106fe4bfb76cdc4dfb112e0297c543b2d828f2870aa09ba820d88e3e9dedb29c8f3d3c9741af8
+nghttp2.v1.60.0+0.aarch64-apple-darwin.tar.gz/md5/dbf9f8161a124dc88ba44b54094b96e4
+nghttp2.v1.60.0+0.aarch64-apple-darwin.tar.gz/sha512/1997f473ea802afb09d7e13feb4eec9c11ad1d161cf83659ef6059a7c81639e00f8a3461c3538c81ea025e359b0927c3a362cef4a57e6544ad27588683142203
+nghttp2.v1.60.0+0.aarch64-linux-gnu.tar.gz/md5/d2e821a693d7d0720f0158b3e19ef7fa
+nghttp2.v1.60.0+0.aarch64-linux-gnu.tar.gz/sha512/4165a1282d125b461d670d7d953c8a06b6508d1b97383a4126bc2fa9641454a9e0be749dbbaf772f2c2e6ea8cc3e64eb980cb0e09ac3d2fe5533eb3e6f7fa9e8
+nghttp2.v1.60.0+0.aarch64-linux-musl.tar.gz/md5/61ecc91336fcddb0f58af6af167e9a81
+nghttp2.v1.60.0+0.aarch64-linux-musl.tar.gz/sha512/802c7455e8f1ddfea74d3de3ceb937d1d10312f51594257cd406aedd67c181ada6ee5115bca00f8ee340a1471e2903bbe0159a0c08b80c556188647345e2c85b
+nghttp2.v1.60.0+0.armv6l-linux-gnueabihf.tar.gz/md5/2998ae8d24d1bd540a29e0c6054bfcc8
+nghttp2.v1.60.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/5b2235a0c8bded57adcbab11dbe97b85a7d6d8a083c155bd74b0ac5546aa861730e88b615f1cbfa1071fcc2eb252aae8508e926ad3d5a1ddf0374536c260217e
+nghttp2.v1.60.0+0.armv6l-linux-musleabihf.tar.gz/md5/7ebec92e3b340e25b952ccc4e714aa2e
+nghttp2.v1.60.0+0.armv6l-linux-musleabihf.tar.gz/sha512/eb0e5c584527182816203ce9bfc35688a969803104ffd17dd4ac3720c27a4fcde3b3b471bf66fda8ac83ec8a56aa82d6d40f492ce06cbf6af39fafc60f35574d
+nghttp2.v1.60.0+0.armv7l-linux-gnueabihf.tar.gz/md5/8c124c0daf59c622aedc7b9f1423d522
+nghttp2.v1.60.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/6e03246d1bfef7f184da68ac0eacc975dcb99172f2f352ce4ea5f5ae77536812163874d7ffc4fcb2df65dc51079880fdb83afc8988b73edb241cb641dc72f1fb
+nghttp2.v1.60.0+0.armv7l-linux-musleabihf.tar.gz/md5/79968e1cb68c3b0518db528933251b0e
+nghttp2.v1.60.0+0.armv7l-linux-musleabihf.tar.gz/sha512/f40790aa9a86fa2f44072c36a33416a7a8b4778881233989f8ed64ccb84f59ccdf3632b7a9d48d3e434e26cbd48c020e5d208da8fcb96e4e4ad41757e050213a
+nghttp2.v1.60.0+0.i686-linux-gnu.tar.gz/md5/1580bf21084fa62ec26020f5c89430a1
+nghttp2.v1.60.0+0.i686-linux-gnu.tar.gz/sha512/cf83afe1bb796c57e220c0ba32a6990830df50cd91f82c781f2722d7b0ca5e5fbd8b708a0204be65bb8838c85b548f867c97e85941d124b81c67e01738f1db1a
+nghttp2.v1.60.0+0.i686-linux-musl.tar.gz/md5/605eb6cd67b6fe3a1ba2d95413635831
+nghttp2.v1.60.0+0.i686-linux-musl.tar.gz/sha512/2c626b76898b4d782038661601fe34580c3cd560a519a46c4f6bc62d94ab987c7f2984350fc65933c00850cd2fe0b942fc64fcb23d2fb7db29bfed5866291b1a
+nghttp2.v1.60.0+0.i686-w64-mingw32.tar.gz/md5/5b5694f36addbc503bc1e78e57159e5a
+nghttp2.v1.60.0+0.i686-w64-mingw32.tar.gz/sha512/e70069b1dde2cf4dd041c4cc1c1ff40f67c20a8954b88d997fd7bf03d925b08148bc55293380dffce8c3b550a0e5768c94066e1a3b881ce4109ee94076c9a8b8
+nghttp2.v1.60.0+0.powerpc64le-linux-gnu.tar.gz/md5/1d073bba8e90c970bf1325a3d150d129
+nghttp2.v1.60.0+0.powerpc64le-linux-gnu.tar.gz/sha512/7e6f3895316d47a701944e8ee192b56f66aa05bf212c41164d25a0507f0e54c4c58c856e1c464fe3ec3eae78e0fe09ba8cf8b595c246faa3300a797750677180
+nghttp2.v1.60.0+0.x86_64-apple-darwin.tar.gz/md5/27d405bf53d4d438f74f91176d638741
+nghttp2.v1.60.0+0.x86_64-apple-darwin.tar.gz/sha512/59c4b4cca09e9a99e2e9ccc765068870824b907577c385313568ea29cd395caa3352bda230238888412b625e4a428a24c9ae0e59d122730cbd8025c6edbf0196
+nghttp2.v1.60.0+0.x86_64-linux-gnu.tar.gz/md5/ed1fe996e4c3e51d9ea8f724883dd3bc
+nghttp2.v1.60.0+0.x86_64-linux-gnu.tar.gz/sha512/0b20db04ef7b2cc470b9abaab05d0e1e7ea3d674c1ed47c63e1cda00b98a6f10ce19ceb77ebd5ece28f6e4a2cf46227f5858f767ff0f04feed867c57941793ee
+nghttp2.v1.60.0+0.x86_64-linux-musl.tar.gz/md5/cf3fcdb5720633700e4f9a9d8cd0cfc0
+nghttp2.v1.60.0+0.x86_64-linux-musl.tar.gz/sha512/d8f87b354de0f47be21b8e3aab6c2b05ee2af377e4bcc7df692fc4dd361ee5b731a190a0d9b4d4fdedf9c3a6a8a300f43338b38ac096da39ec13d4b79b544144
+nghttp2.v1.60.0+0.x86_64-unknown-freebsd.tar.gz/md5/b83aba7b3bd97ed7de770a597d6ec374
+nghttp2.v1.60.0+0.x86_64-unknown-freebsd.tar.gz/sha512/e40e47835bb0d5d548fbcfb28a64124323422bcdab411bcee7d4288cea765c6c82d7f4586980ee28b6ff310c6c7313aa4185ede192cd94839fbe708ab1ed14a7
+nghttp2.v1.60.0+0.x86_64-w64-mingw32.tar.gz/md5/37ba862c196b4d7c063cddc87722f7ff
+nghttp2.v1.60.0+0.x86_64-w64-mingw32.tar.gz/sha512/ce0b70b4ad5cb30b83e672c3875fac7bcc8fc039506f05fef552a9d9cb53f053187dd02da4550dd7e5ef9aaaf8d587cee331eace0335f663d4190bacbc4ff9a2
diff --git a/deps/nghttp2.version b/deps/nghttp2.version
index a893c5ee8085e..e9587297d0e32 100644
--- a/deps/nghttp2.version
+++ b/deps/nghttp2.version
@@ -3,4 +3,4 @@
 NGHTTP2_JLL_NAME := nghttp2
 
 ## source build
-NGHTTP2_VER := 1.59.0
+NGHTTP2_VER := 1.60.0
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index 456eee252e774..ac271b14c9048 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -292,7 +292,7 @@ version = "5.8.0+1"
 [[deps.nghttp2_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
-version = "1.59.0+0"
+version = "1.60.0+0"
 
 [[deps.p7zip_jll]]
 deps = ["Artifacts", "Libdl"]
diff --git a/stdlib/nghttp2_jll/Project.toml b/stdlib/nghttp2_jll/Project.toml
index ea7ca1615f050..88e60941f65ee 100644
--- a/stdlib/nghttp2_jll/Project.toml
+++ b/stdlib/nghttp2_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "nghttp2_jll"
 uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
-version = "1.59.0+0"
+version = "1.60.0+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/stdlib/nghttp2_jll/test/runtests.jl b/stdlib/nghttp2_jll/test/runtests.jl
index daa848d19f9b6..b6ddefb8222cd 100644
--- a/stdlib/nghttp2_jll/test/runtests.jl
+++ b/stdlib/nghttp2_jll/test/runtests.jl
@@ -11,5 +11,5 @@ end
 
 @testset "nghttp2_jll" begin
     info = unsafe_load(ccall((:nghttp2_version,libnghttp2), Ptr{nghttp2_info}, (Cint,), 0))
-    @test VersionNumber(unsafe_string(info.version_str)) == v"1.59.0"
+    @test VersionNumber(unsafe_string(info.version_str)) == v"1.60.0"
 end

From 324e353a07db80676622606ba4afc5bc9793004c Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Tue, 26 Mar 2024 02:23:27 +0100
Subject: [PATCH 1173/1315] Update patchelf to 0.18.0 (#53845)

Released Apr 23, 2023:
https://github.com/NixOS/patchelf/releases/tag/0.18.0
---
 deps/checksums/patchelf | 4 ++--
 deps/patchelf.version   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/deps/checksums/patchelf b/deps/checksums/patchelf
index a7122c400749a..e2029b83f14fc 100644
--- a/deps/checksums/patchelf
+++ b/deps/checksums/patchelf
@@ -1,2 +1,2 @@
-patchelf-0.13.tar.bz2/md5/d387eee9325414be0b1a80c8fbd2745f
-patchelf-0.13.tar.bz2/sha512/43c3f99fe922e2f34d860389165bcc2b0f3f3317e124eb8443017f71b1f223d96a7c815dc81f51b14958b7dc316f75c4ab367ccc287cd99c82abe890b09a478d
+patchelf-0.18.0.tar.bz2/md5/9b091a689583fdc7c3206679586322d5
+patchelf-0.18.0.tar.bz2/sha512/bf26194ca3435b141dd330890fcc0c9d805d0ad6a537901dabe6707a13cd28e7e6217462f3ebb3cb4861302dd8632342ec988fc18246c35332a94f2b349d4f4f
diff --git a/deps/patchelf.version b/deps/patchelf.version
index bbeaa87d25136..9038338d45faf 100644
--- a/deps/patchelf.version
+++ b/deps/patchelf.version
@@ -1,3 +1,3 @@
 ## source build
 # Patchelf (we don't ship this or even use a JLL, we just always build it)
-PATCHELF_VER := 0.13
+PATCHELF_VER := 0.18.0

From bf9079afb05829f51e60db888cb29a7c45296ee1 Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Tue, 26 Mar 2024 02:30:06 +0100
Subject: [PATCH 1174/1315] update PCRE2 to 10.43.0 (#53838)

Released on 16 February 2024. Among the changes is support for Unicode
15.0.0
---
 deps/checksums/pcre               | 68 +++++++++++++++----------------
 deps/pcre.version                 |  2 +-
 stdlib/Manifest.toml              |  2 +-
 stdlib/PCRE2_jll/Project.toml     |  2 +-
 stdlib/PCRE2_jll/test/runtests.jl |  2 +-
 5 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/deps/checksums/pcre b/deps/checksums/pcre
index 9b9717b61688b..744d16540d6c8 100644
--- a/deps/checksums/pcre
+++ b/deps/checksums/pcre
@@ -1,34 +1,34 @@
-PCRE2.v10.42.0+1.aarch64-apple-darwin.tar.gz/md5/667a570d341396c3213749ee1e5b5fda
-PCRE2.v10.42.0+1.aarch64-apple-darwin.tar.gz/sha512/c1bb99e8928efded9b0ea3f294ceb41daea7254204ca30c0ff88686110ccd58138d8ea8b20b9a9d6d16a6d8d3f34e27e74e7b57d3c8fe6b051c9d8fa6f86431a
-PCRE2.v10.42.0+1.aarch64-linux-gnu.tar.gz/md5/1a758f275ff3306fbad7698df7b9b7be
-PCRE2.v10.42.0+1.aarch64-linux-gnu.tar.gz/sha512/d09508c0b255366d01f1b4d1ae6748a8e47f18c451498d30715f5f968784990949dab7540cd086396abd912f61b5f7c44c8c72a27efaba0a7fc08b71a167c057
-PCRE2.v10.42.0+1.aarch64-linux-musl.tar.gz/md5/e61147579fdc9b57a61b814bdf9c84bb
-PCRE2.v10.42.0+1.aarch64-linux-musl.tar.gz/sha512/eecaf4c1937fc04210b910ac65318524c02d690e8c4894c38e74eaba36d26c87a1fd9e1cc36f4307a11ff3552a79f081fa8f05085435eb34872dc2fdecce2d18
-PCRE2.v10.42.0+1.armv6l-linux-gnueabihf.tar.gz/md5/b4c484a3b87923c0e2e4d9cc5f140eb7
-PCRE2.v10.42.0+1.armv6l-linux-gnueabihf.tar.gz/sha512/5931cf13d340971356a9b87f62c9efdb3656ba649e7b25f1722127a3fd70973d94c815a37b43cecab8eb0ed8d1ae02ef1a0c0a12051852c1b9242c3eaa01c496
-PCRE2.v10.42.0+1.armv6l-linux-musleabihf.tar.gz/md5/bc7b5bb1c5b0b99c121bad5a89299ca7
-PCRE2.v10.42.0+1.armv6l-linux-musleabihf.tar.gz/sha512/86b5ad4fa6f4b5bd1a76ad68ddff4b39916d0ed0acc03a3fee8eab5256aaed53abc0ff4ce9d9d9f8b9203c087211684da92fe6aa06ff5bc331ba1b3da2cba57e
-PCRE2.v10.42.0+1.armv7l-linux-gnueabihf.tar.gz/md5/3541eb26fa5a4d13e2c7d063dbd900d8
-PCRE2.v10.42.0+1.armv7l-linux-gnueabihf.tar.gz/sha512/872181f931662edaf653351486c5e2a700e94cfa0966ca90eca893fdc75dd46eb40d9d45737c198aa4b9ad8ebab33fd78697ef35906985e4e1c9748ddf58d363
-PCRE2.v10.42.0+1.armv7l-linux-musleabihf.tar.gz/md5/fe059feb18fcc9312f1033362070fe34
-PCRE2.v10.42.0+1.armv7l-linux-musleabihf.tar.gz/sha512/5a96acf3908c964ccb4f296c449499388ed447d9a094c2760c979e02ef656fa710ede3926b9626e89fb5b0545c111e6eedff21e48416e923c17fc9ff129d0519
-PCRE2.v10.42.0+1.i686-linux-gnu.tar.gz/md5/d6c804ae6cc661d039ee3edd2f1dbcb6
-PCRE2.v10.42.0+1.i686-linux-gnu.tar.gz/sha512/256ca677b169854686ca34cf30af5a6709758b41b65f2c66d497c552858770a69a49834fd16daa2f7d481964b21a2e3ec68ff1b1fbd08f4e2257ec46b85c0063
-PCRE2.v10.42.0+1.i686-linux-musl.tar.gz/md5/092af10d8182cb4240cdd975efce4d7c
-PCRE2.v10.42.0+1.i686-linux-musl.tar.gz/sha512/79a48f4fd50ffdf49c8d57581e01ace38c1b3d7edd86d44db44b8efd93074d16faf035131a0d60c6631b8bf22f0fd8296acedba45908da56e8096c296122f047
-PCRE2.v10.42.0+1.i686-w64-mingw32.tar.gz/md5/bafc5fc1621d0f4fb2b7b271e2f66db1
-PCRE2.v10.42.0+1.i686-w64-mingw32.tar.gz/sha512/a5ac2b788fb2e4baf129fb339f28da04e9a5c9b7dbba0a1f43da2a7193917d361d961ba48abd0aeec30d2352ebaa401d667c8eec81c5f40859ef8adf8487edca
-PCRE2.v10.42.0+1.powerpc64le-linux-gnu.tar.gz/md5/0de1215b2a1e9c0efd131355e9fbf2c1
-PCRE2.v10.42.0+1.powerpc64le-linux-gnu.tar.gz/sha512/69dae12627685ae665db8c91264a79aba7c60ae97eccdc79ef889f2a5f69b465fa333aba298fc90bbb95710cfc324e3630bc427a97577855e8fb6c8fe227cfec
-PCRE2.v10.42.0+1.x86_64-apple-darwin.tar.gz/md5/c5c52b399921c5ab81a5f598b350d2ca
-PCRE2.v10.42.0+1.x86_64-apple-darwin.tar.gz/sha512/e6c8ba3aa3fbf54b37079301ab317104c6852812b23835f52ca40f31f0831678172d32e077fbaa712a8a2cb16d62bb97d475827004353e7807922a2d6e049b28
-PCRE2.v10.42.0+1.x86_64-linux-gnu.tar.gz/md5/b074dd1f85e24e723349e566350e2c78
-PCRE2.v10.42.0+1.x86_64-linux-gnu.tar.gz/sha512/236017e02c9f32b913b772dbf22897c8460e5791f196c86f8a073e329ad8925f6859afe48f3bf18ca057c265f08fedbde255360d8f859e2303c6569ab1b0e1bb
-PCRE2.v10.42.0+1.x86_64-linux-musl.tar.gz/md5/9f32ca77e79843fc9c4b5fc8ed336d11
-PCRE2.v10.42.0+1.x86_64-linux-musl.tar.gz/sha512/334a31724e9d69c6517568d922717ce76d85cf87dbc863b7262b25ab43c79734b457833cd42674eb6a004864e5c74da3ae1d0a45794b4cd459eea24d9669fac5
-PCRE2.v10.42.0+1.x86_64-unknown-freebsd.tar.gz/md5/76cde3c509ed39ca67a18fe58e728821
-PCRE2.v10.42.0+1.x86_64-unknown-freebsd.tar.gz/sha512/219c82067a242554c523be5be2b5561cd955609eac1addc336004df64a2a12e815ea40ff94d3f610970f7d0215b410f098d4baaa2c722f5cf21dab175b288b7e
-PCRE2.v10.42.0+1.x86_64-w64-mingw32.tar.gz/md5/b0771d5b0132b554776e7cee0e1374e6
-PCRE2.v10.42.0+1.x86_64-w64-mingw32.tar.gz/sha512/d4435ff703e51c88df7764a732d6b67b1ee4d3b09b915ac822af05a33347642691837818d4c389226ef1d70cd69dbac792ebe1e7de1d8900443fe162051916ae
-pcre2-10.42.tar.bz2/md5/a8e9ab2935d428a4807461f183034abe
-pcre2-10.42.tar.bz2/sha512/72fbde87fecec3aa4b47225dd919ea1d55e97f2cbcf02aba26e5a0d3b1ffb58c25a80a9ef069eb99f9cf4e41ba9604ad06a7ec159870e1e875d86820e12256d3
+PCRE2.v10.43.0+0.aarch64-apple-darwin.tar.gz/md5/f1bee27b8d9465c14eaf9362701fb795
+PCRE2.v10.43.0+0.aarch64-apple-darwin.tar.gz/sha512/33b8f6e3703f0a52cd2d57897c28e35fb3c63af459296a2fef4e414dc99239617833b2ab176068d6aab690122a34a9ab9b6042dfff54b5a30ad60429a809818d
+PCRE2.v10.43.0+0.aarch64-linux-gnu.tar.gz/md5/c55a569260e302f315f4a1bd185346ab
+PCRE2.v10.43.0+0.aarch64-linux-gnu.tar.gz/sha512/be4d2883e69d562898a157424b2baa146fe79545a8c10935cf25b54e498ca2c14fae026fa0d958d175895fe2cb695d0f96ef7f09fecbf54e1cee4a55b81a382b
+PCRE2.v10.43.0+0.aarch64-linux-musl.tar.gz/md5/fb041ccace415ccc26263968c6435a47
+PCRE2.v10.43.0+0.aarch64-linux-musl.tar.gz/sha512/06672ebe18e0f6bfa1dd2d5c02e10d9fd67236a73fd38ee2e8f4496d98f297f7866760f0be3b9cebeca348a5d748a3719e416b84cec96a90c71eac55afbbd905
+PCRE2.v10.43.0+0.armv6l-linux-gnueabihf.tar.gz/md5/4f303a4cbf26abb7bf4ffb8bfe3d636d
+PCRE2.v10.43.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/dddb3b227ee48d8329f6c65c5d0fce9f460eccaec98594a05bf28d1d9af01397cf7ef86c96e88b0e96030a7f6d8406461f78dd5fa558db8fc8f7bfb3b522ed54
+PCRE2.v10.43.0+0.armv6l-linux-musleabihf.tar.gz/md5/eade1fff90404bf3584fd15b62be0cfa
+PCRE2.v10.43.0+0.armv6l-linux-musleabihf.tar.gz/sha512/351f6fa11c39b90fcc4086bd00b1b1126ed92272595f0b745757ca4e7e360c84d244446a871029245c3bcf838b23f42d908f858e44fae7deb9002a36cb76753c
+PCRE2.v10.43.0+0.armv7l-linux-gnueabihf.tar.gz/md5/daa0a34b2cf0b71a6f8e1f9456cd4b06
+PCRE2.v10.43.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/ae72956ae7a9a5f315bfc816fdbb500937a170dfea306a28289ec9eac57d883cf2fa5a467ce9406eea80546b632a272c63bbb48b89ebe6d9f69d30366fd84180
+PCRE2.v10.43.0+0.armv7l-linux-musleabihf.tar.gz/md5/90bfb9e4efd7c92a2bb6a1a48fd88ecb
+PCRE2.v10.43.0+0.armv7l-linux-musleabihf.tar.gz/sha512/147ac98d82fec4695de0c43c87d3d9242b9c024bc6df7ad7504d17ef6a12a029ed703c4deade0e2b24faf5283d66309f880d62f8c4834f27b2cc8889587d7abe
+PCRE2.v10.43.0+0.i686-linux-gnu.tar.gz/md5/6fde649bf449c4122438fff32c0706ab
+PCRE2.v10.43.0+0.i686-linux-gnu.tar.gz/sha512/edfaa15490497723c095eaa5df26194637b0606e9dce7b89b400024ef8ac42e21f010bb31c2cee5c735ce82fc8de0c42bf2b35b095a1e70a9a111d3bfba6da64
+PCRE2.v10.43.0+0.i686-linux-musl.tar.gz/md5/73aa8d13cc48338a5071e30b3a899109
+PCRE2.v10.43.0+0.i686-linux-musl.tar.gz/sha512/200e2d3ffd68f49b76c70a5be80cb0ae9703049214674485a2ab24abaaea7aefd6dec2042a14bd48cc52b04379f57322ec1e1788dc8c00896e1074921725d9cc
+PCRE2.v10.43.0+0.i686-w64-mingw32.tar.gz/md5/4ddf0f31c97463e5216ed71afc4fb014
+PCRE2.v10.43.0+0.i686-w64-mingw32.tar.gz/sha512/75903d81668a66a5c4d830e31657391d507883943d86245998f224655406dcc6a95ba4f5fad20dcf608a98d6ccf49abe50107993448669b03c42a878d8466611
+PCRE2.v10.43.0+0.powerpc64le-linux-gnu.tar.gz/md5/64cb71080da1c97eba3a440ff53d298c
+PCRE2.v10.43.0+0.powerpc64le-linux-gnu.tar.gz/sha512/16348b96a45c7a7d86775cb1d082b4d1c060e5a8acfb37554885d8da0db87430d8a40f834f008a90f4a7b1c07b8329df96836ba0430ecec506a143b7347bb101
+PCRE2.v10.43.0+0.x86_64-apple-darwin.tar.gz/md5/31bbb2485f5e06c3616fb061ffb2f022
+PCRE2.v10.43.0+0.x86_64-apple-darwin.tar.gz/sha512/3284ee63ed1e5631267efacb354a1d90bd1b7db0bc81d7233c9580eee4a9af06093c1c4f240786c34299df89a36a17ed92598fc302074f5a200c56cc96081bf1
+PCRE2.v10.43.0+0.x86_64-linux-gnu.tar.gz/md5/2fb7e0e9bbc32dddf543f4d395b50d3f
+PCRE2.v10.43.0+0.x86_64-linux-gnu.tar.gz/sha512/5a533a3a01f817689077377835dc88edf914459ed0df7323f8f4dba602a47fd6af700075feb1f448221366b1cf7e2d717c615a5c506eb4ca2db9c600fd290fb0
+PCRE2.v10.43.0+0.x86_64-linux-musl.tar.gz/md5/b432063c93aa477dd0883428191041f8
+PCRE2.v10.43.0+0.x86_64-linux-musl.tar.gz/sha512/36475e90e29d7324046fe1da669fb37f667245a680df23f3978394964e14eb9bda3fd56703ad62cd56e27a5af77d8b6b9612516457ae803cef0627bd919e4628
+PCRE2.v10.43.0+0.x86_64-unknown-freebsd.tar.gz/md5/6124870a991e70c2ed8a64d8f3258760
+PCRE2.v10.43.0+0.x86_64-unknown-freebsd.tar.gz/sha512/4645a2d05af149467f2e4ce5e48853b57c585d6a5950c70726d04bc71a5d82f50809af141ad98e99671e764ac74965651ecad1c49a849caa8fd077c7f4911c7c
+PCRE2.v10.43.0+0.x86_64-w64-mingw32.tar.gz/md5/cc4e9f45471f538c1fefa657ab99b878
+PCRE2.v10.43.0+0.x86_64-w64-mingw32.tar.gz/sha512/eed45e621263cb307b6e8ab42e2c12cf9e1d61ad523760fd721a85765c359b74d580752ca7c3d222e0cba26a74e872a6d43dbf2dbf08e4733a3e709417e48651
+pcre2-10.43.tar.bz2/md5/c8e2043cbc4abb80e76dba323f7c409f
+pcre2-10.43.tar.bz2/sha512/8ac1520c32e9e5672404aaf6104e23c9ee5c3c28ad28ff101435599d813cbb20e0491a3fd34e012b4411b3e0366a4c6dfa3f02d093acaa6ff0ab25478bb7ade9
diff --git a/deps/pcre.version b/deps/pcre.version
index ce27921435e1d..e3ea507376105 100644
--- a/deps/pcre.version
+++ b/deps/pcre.version
@@ -2,4 +2,4 @@
 PCRE_JLL_NAME := PCRE2
 
 ## source build
-PCRE_VER := 10.42
+PCRE_VER := 10.43
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index ac271b14c9048..88a91a8db0bd6 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -174,7 +174,7 @@ version = "0.8.1+2"
 [[deps.PCRE2_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15"
-version = "10.42.0+1"
+version = "10.43.0+0"
 
 [[deps.Pkg]]
 deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
diff --git a/stdlib/PCRE2_jll/Project.toml b/stdlib/PCRE2_jll/Project.toml
index 788d6b733234f..f9b3affb51b63 100644
--- a/stdlib/PCRE2_jll/Project.toml
+++ b/stdlib/PCRE2_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "PCRE2_jll"
 uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15"
-version = "10.42.0+1"
+version = "10.43.0+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/stdlib/PCRE2_jll/test/runtests.jl b/stdlib/PCRE2_jll/test/runtests.jl
index d593b07af31ce..af0ed9434d2b6 100644
--- a/stdlib/PCRE2_jll/test/runtests.jl
+++ b/stdlib/PCRE2_jll/test/runtests.jl
@@ -6,5 +6,5 @@ using Test, Libdl, PCRE2_jll
     vstr = zeros(UInt8, 32)
     @test ccall((:pcre2_config_8, libpcre2_8), Cint, (UInt32, Ref{UInt8}), 11, vstr) > 0
     vn = VersionNumber(split(unsafe_string(pointer(vstr)), " ")[1])
-    @test vn == v"10.42.0"
+    @test vn == v"10.43.0"
 end

From 018152fc21470362a4ddb14c649c0dd6964115dc Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Tue, 26 Mar 2024 04:46:12 +0100
Subject: [PATCH 1175/1315] Update zlib to 1.3.1 (#53841)

Released January 22, 2024
---
 deps/checksums/zlib              | 68 ++++++++++++++++----------------
 deps/zlib.version                |  6 +--
 stdlib/Manifest.toml             |  2 +-
 stdlib/Zlib_jll/Project.toml     |  2 +-
 stdlib/Zlib_jll/test/runtests.jl |  2 +-
 5 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/deps/checksums/zlib b/deps/checksums/zlib
index 72fd884183e47..b6fc106747c67 100644
--- a/deps/checksums/zlib
+++ b/deps/checksums/zlib
@@ -1,34 +1,34 @@
-Zlib.v1.2.13+1.aarch64-apple-darwin.tar.gz/md5/bc44b2016065fb20cbd639b3cd5dbb88
-Zlib.v1.2.13+1.aarch64-apple-darwin.tar.gz/sha512/9cfecc16a29b0a13282846ed7d4c17c420b3f62379777d3fac61a8c9c4eeaf4214b826cd9f7479f480e951617b22c96e6ca2976a709345e16fbe7f81e9bdd83f
-Zlib.v1.2.13+1.aarch64-linux-gnu.tar.gz/md5/a2d3265543017db03bc47b9d9778d99d
-Zlib.v1.2.13+1.aarch64-linux-gnu.tar.gz/sha512/c8143445222e151d7f522a98ee8f2742571542f4e71d515e88086c9d7f27b952662ced93f40c795e0de42e3a07c0cb5e1d9d8e792347f3c068cb07ccc144a640
-Zlib.v1.2.13+1.aarch64-linux-musl.tar.gz/md5/c1f2a1c562f72c7aa4b228f57c2346d4
-Zlib.v1.2.13+1.aarch64-linux-musl.tar.gz/sha512/7ed89bc7696690c03617c7413f5456ff5a1caa0dd600880ae67132f6c9190672ae451a06d23956a1969be00bf5c8f29bfa4f5bc4ab646b3b375c350f67c993e5
-Zlib.v1.2.13+1.armv6l-linux-gnueabihf.tar.gz/md5/7dff966f7bc5dd2902fa9ce20444235b
-Zlib.v1.2.13+1.armv6l-linux-gnueabihf.tar.gz/sha512/49e7b4a7c84996b697cf944b11ce06ce6064983a6a911c4539587385afa1e0119e3b1dbf816703a2c132acc90f7f114ec10631647638b59b14954382c1a82014
-Zlib.v1.2.13+1.armv6l-linux-musleabihf.tar.gz/md5/6982f19d2446559c0fd369afe84ebe4a
-Zlib.v1.2.13+1.armv6l-linux-musleabihf.tar.gz/sha512/8f69dfb7fb91cd6f7c934e1acddd83f77c2ebcc1732553f41ae1adcb7805a3304d16062133ce5094a8aea18ff5eca5f7a2df5724ae5a5cb9137caee732c1bf36
-Zlib.v1.2.13+1.armv7l-linux-gnueabihf.tar.gz/md5/30579a91f8f1c96752fe9a82bc053523
-Zlib.v1.2.13+1.armv7l-linux-gnueabihf.tar.gz/sha512/64f6a0e66ee13b086609e0d070c8742de20052e1ef43da201be0007e478c65b2f0a28a3c19ca5be6537b7c8bbeb6a4b2886c15a1e47bb2bd1cfe9d5e1590a620
-Zlib.v1.2.13+1.armv7l-linux-musleabihf.tar.gz/md5/b052ad151dbc3bad78762bc06164d667
-Zlib.v1.2.13+1.armv7l-linux-musleabihf.tar.gz/sha512/b5d2de09a4d65d898cf9ba0db34327c712f42a78cd1fd0f1d77fd8798910502049be63ccfed23de5fe3b499d9e0fe3d4cbb07c72765fd54db275e92f8f1e4dc4
-Zlib.v1.2.13+1.i686-linux-gnu.tar.gz/md5/3074702010889f586b43aa3dbbda4ceb
-Zlib.v1.2.13+1.i686-linux-gnu.tar.gz/sha512/92aa87c5aa3831155305276c2f0da091b5be4e8a396772e1a28650c2837ceb116dd2207329732b653a97c011abd7dd6ac1fc9574ac64cb3049ccd36fa6700748
-Zlib.v1.2.13+1.i686-linux-musl.tar.gz/md5/eff02476825ea7a53ab26b346d58f96e
-Zlib.v1.2.13+1.i686-linux-musl.tar.gz/sha512/14b72607d524948198e999e3919ee01046c049b3ec441bc581c77642cf37c3d28cc3c5500a3c073d62e9b8dc1efc9661b23bb925ed9c80b5e69abaddbcb59115
-Zlib.v1.2.13+1.i686-w64-mingw32.tar.gz/md5/138cb27334b8f6f9e818131ac394bf43
-Zlib.v1.2.13+1.i686-w64-mingw32.tar.gz/sha512/07fbf4a21f6cb5a6120be253e5769b8bbdf60658f9f3705222307fbe203d8710de59fd3dab7a35714ebe1a7385600d4e1b01eae0b1addca47f9d8d862173e667
-Zlib.v1.2.13+1.powerpc64le-linux-gnu.tar.gz/md5/bc69de101d9159b22b7a334e2700faa6
-Zlib.v1.2.13+1.powerpc64le-linux-gnu.tar.gz/sha512/174eb4f154594d268d970d23eb6144dd2f6be41ddcfb9bc756b2ff48f0781ad0ed6571e2ead64dab0967da91517a02cd8db2b0e33a0bde9400103b5204f78e85
-Zlib.v1.2.13+1.x86_64-apple-darwin.tar.gz/md5/60279d648bce4801cd0e311ea95a6481
-Zlib.v1.2.13+1.x86_64-apple-darwin.tar.gz/sha512/921fc557317f87012d76f5d2cb0a7bbed29cdfdb2274ed6d37577f8e99dda2afb2a8dd4725d720eb8fb0a93c0d3afe68dd54fdd3a6e7cb07c15607a8aed72f82
-Zlib.v1.2.13+1.x86_64-linux-gnu.tar.gz/md5/b192d547d56124262e2ae744f385efd6
-Zlib.v1.2.13+1.x86_64-linux-gnu.tar.gz/sha512/c6dca3c0a713ef2e2296bc9e9afa75e103a4cc4f00b5c905ebc5cff688904d6a454f83ab5ef3b6c66bdf425daa2fcd25825e50a3534c0ff109b13affbb686179
-Zlib.v1.2.13+1.x86_64-linux-musl.tar.gz/md5/f2a466b38b2ff1c895f630982147a950
-Zlib.v1.2.13+1.x86_64-linux-musl.tar.gz/sha512/191261d37fc501591005bf680d76bf518da261252456c4fef1c12bc572f9200a855fbd1b125bb8ad10d803eedbc53d4c9d7a2861e9a35d629fb40f87e5306f5f
-Zlib.v1.2.13+1.x86_64-unknown-freebsd.tar.gz/md5/36e53efdafdb8b8e1fb18817ea40c9ab
-Zlib.v1.2.13+1.x86_64-unknown-freebsd.tar.gz/sha512/3067eace2a46b45c071dd1d2c046ab21e3f4a34b87346905bf4c00ef4ea57f41c4c30e32cbd5d4b60a560fa45aeeba7b0ce95566c0889f06f00f7a25de771cb1
-Zlib.v1.2.13+1.x86_64-w64-mingw32.tar.gz/md5/4c14730c6e89a3b05dcf352007f9c1e5
-Zlib.v1.2.13+1.x86_64-w64-mingw32.tar.gz/sha512/b6fbfe93d0c4fc6ebb740dbe0aebaa31aa5ecf352589452f6baac3ee28514531a1d0de9795634f97774ebb492dd23dee9f7865c2b8ba3f70c7f03cdc5430e85a
-zlib-04f42ceca40f73e2978b50e93806c2a18c1281fc.tar.gz/md5/60a49c89b9409dd91c1b039266f7bd0c
-zlib-04f42ceca40f73e2978b50e93806c2a18c1281fc.tar.gz/sha512/83122539da9399ce5f51c2ecbc38a627405334a9a6d53a024341353c1263a1e3aef7498f30ee281a49b3022be70e992eae475691e33da7a9c6a59b83207bd688
+Zlib.v1.3.1+0.aarch64-apple-darwin.tar.gz/md5/50b48e14f0b3578e3f398d130749a25d
+Zlib.v1.3.1+0.aarch64-apple-darwin.tar.gz/sha512/d970e183035b3615b410f7b0da2c7a1d516234744491d65ed1ebc3800b55732f20bf00fcbb0cf91289b8b4660915282873fb23788896713cf8dfae2984a8fd85
+Zlib.v1.3.1+0.aarch64-linux-gnu.tar.gz/md5/ee42c0bae86fc39968c8cd6a77a801bf
+Zlib.v1.3.1+0.aarch64-linux-gnu.tar.gz/sha512/5d21cbeab03d44008c6cbad114d45c917ebee2fe98de6b19686f4f6ba1fc67eeedf968b94ed1c2d4efb89e93be9efa342bcc8a57cb8a505085d177abae14bc2d
+Zlib.v1.3.1+0.aarch64-linux-musl.tar.gz/md5/9091d1288736b218f7b016791dc1a9c8
+Zlib.v1.3.1+0.aarch64-linux-musl.tar.gz/sha512/b49cbfe734beb2af9ef8e847542d006765345cbb08aee0854779e35e03c98df25c93539b046547c6b66029987c49499ddf6cb207824b1e376900bfceaa79691a
+Zlib.v1.3.1+0.armv6l-linux-gnueabihf.tar.gz/md5/b686c85047b7dad2c2f08d1d16e7978a
+Zlib.v1.3.1+0.armv6l-linux-gnueabihf.tar.gz/sha512/511fda619519dccedb264988e3b59a0e0fbf8f73d3ae290f238346209ebc0202a22f945257cea19afef64246574285e0322901a46bb48d7b48364c1e2eacd801
+Zlib.v1.3.1+0.armv6l-linux-musleabihf.tar.gz/md5/374be5cb926876f3f0492cfe0e193220
+Zlib.v1.3.1+0.armv6l-linux-musleabihf.tar.gz/sha512/4d3a2cc0c7c48146e63ed098da5a5acad75517197adc965550c123f7f8bcee0811a27be76fa37b6b0515eee4b5ba1c1a85c854e7b23bea36b5e21671805bedce
+Zlib.v1.3.1+0.armv7l-linux-gnueabihf.tar.gz/md5/9febbc6a3d492e34c9ed53c95f3b799f
+Zlib.v1.3.1+0.armv7l-linux-gnueabihf.tar.gz/sha512/4cee0e2cf572eb91028a09ef356e1aa6360949e046ceec03bd37574295ddcc4a7cefca9276f7565f152697d55b35f62af2ab107cdbf402b42846818629fea9c7
+Zlib.v1.3.1+0.armv7l-linux-musleabihf.tar.gz/md5/5d0d59a6cbbd1e63193ba6f7dbb755f9
+Zlib.v1.3.1+0.armv7l-linux-musleabihf.tar.gz/sha512/ee3f48b354168342ef63509b19a26aca3301fb3e5f4f6898afe2d3b44ee3380515efd6ced5d4e06e69736d851d19352deb9595bad82c051caccaee8c55e629d8
+Zlib.v1.3.1+0.i686-linux-gnu.tar.gz/md5/834350a64b2302a9caf0250a8f6068e5
+Zlib.v1.3.1+0.i686-linux-gnu.tar.gz/sha512/63dc158c4dfc42db97875893fcdd9784d9487af855bd576dbe04d1b967ad64510222df74a4cfb1b7e67386329d2a5686d7931b81720883fc1924f0d706a0a711
+Zlib.v1.3.1+0.i686-linux-musl.tar.gz/md5/e4f96efdeafa3d74c7c348059a8dc46a
+Zlib.v1.3.1+0.i686-linux-musl.tar.gz/sha512/b47a571d94887ddcab8d7b50c6dce3afed3f56513a9d1859feaefebfad4a271d428b440df1d19ef3c2ed01ca4c8fd121ffc1572f5e252f27d0930f616cb47f18
+Zlib.v1.3.1+0.i686-w64-mingw32.tar.gz/md5/6bc27bd7dbbe17243dbbfaff225d3b23
+Zlib.v1.3.1+0.i686-w64-mingw32.tar.gz/sha512/5777661682831519875fffbb114c62596bf7bdb62011667c0f3dc5da9910e14de2285200a0a05187769b9c68c99b07024caafc16fef03c76e96e618f77149790
+Zlib.v1.3.1+0.powerpc64le-linux-gnu.tar.gz/md5/27dcad8557994cfd89d6fa7072bb843c
+Zlib.v1.3.1+0.powerpc64le-linux-gnu.tar.gz/sha512/3b388dd286b273881d4344cff61c7da316c2bd2bab93072bf47ce4cb1cf9662158351b8febb0d5b1f8dfd9bc73cd32f7cae37fdd19b0ca91531bd3375df104bb
+Zlib.v1.3.1+0.x86_64-apple-darwin.tar.gz/md5/9187319377191ae8b34162b375baa5db
+Zlib.v1.3.1+0.x86_64-apple-darwin.tar.gz/sha512/895203434f161926978be52a223dd49a99454651a79c1c5e0529fa064f3f7ac2d7a069fed47a577b32523df22afadd6eb97d564dbd59c5d67ed90083add13c00
+Zlib.v1.3.1+0.x86_64-linux-gnu.tar.gz/md5/55d4d982d60cb643aa8688eb031b07ee
+Zlib.v1.3.1+0.x86_64-linux-gnu.tar.gz/sha512/d8f94d22ffc37df027de23b2408c2000014c8b7b6c8539feca669ac1f2dbbe1679ca534c3be4d32c90fe38bbba27c795689226962fb067346b5ca213e64b9c4b
+Zlib.v1.3.1+0.x86_64-linux-musl.tar.gz/md5/95d735bba178da4b8bee23903419919c
+Zlib.v1.3.1+0.x86_64-linux-musl.tar.gz/sha512/370370f08133a720e3fbedcc434f102dc95225fda3ec8a399e782851bd4be57fb2b64a3ed62dc0559fb0c58d2e28db9b9e960efafd940982e4cb6652be0e81f1
+Zlib.v1.3.1+0.x86_64-unknown-freebsd.tar.gz/md5/df158f50fdb8ac1179fe6dad3bc62713
+Zlib.v1.3.1+0.x86_64-unknown-freebsd.tar.gz/sha512/f4ba4ccfeaf3fd2e172a2d5b3b1ae083ee9854022e71e062e29423e4179cb1fc49b2b99df49b3f5f231e2a0c5becc59b89644e9dcaf0fda9c97e83af7ea1c25d
+Zlib.v1.3.1+0.x86_64-w64-mingw32.tar.gz/md5/9cc735c54ddf5d1ea0db60e05d6631ea
+Zlib.v1.3.1+0.x86_64-w64-mingw32.tar.gz/sha512/8a2fd20944866cb7f717517ea0b80a134466e063f85bec87ffba56ca844f983f91060dfdc65f8faee1981d7329348c827b723aaad4fea36041e710b9e35c43de
+zlib-51b7f2abdade71cd9bb0e7a373ef2610ec6f9daf.tar.gz/md5/7ce1b2766499af7d948130113b649028
+zlib-51b7f2abdade71cd9bb0e7a373ef2610ec6f9daf.tar.gz/sha512/79d032b8c93260ce6b9806f2289cdccce67e9d80865b5bb39ac46dadffc8ee009da51c551eead59c56249c7adfa164c1d5ebcf2b10a8645e0b11b5650176cb24
diff --git a/deps/zlib.version b/deps/zlib.version
index 89a304c49b6dc..27d862a4cc35b 100644
--- a/deps/zlib.version
+++ b/deps/zlib.version
@@ -3,6 +3,6 @@
 ZLIB_JLL_NAME := Zlib
 
 ## source build
-ZLIB_VER := 1.2.13
-ZLIB_BRANCH=v1.2.13
-ZLIB_SHA1=04f42ceca40f73e2978b50e93806c2a18c1281fc
+ZLIB_VER := 1.3.1
+ZLIB_BRANCH=v1.3.1
+ZLIB_SHA1=51b7f2abdade71cd9bb0e7a373ef2610ec6f9daf
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index 88a91a8db0bd6..a9491702f62ad 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -272,7 +272,7 @@ version = "1.11.0"
 [[deps.Zlib_jll]]
 deps = ["Libdl"]
 uuid = "83775a58-1f1d-513f-b197-d71354ab007a"
-version = "1.2.13+1"
+version = "1.3.1+0"
 
 [[deps.dSFMT_jll]]
 deps = ["Artifacts", "Libdl"]
diff --git a/stdlib/Zlib_jll/Project.toml b/stdlib/Zlib_jll/Project.toml
index b1fa9576af3ec..bb5771654430b 100644
--- a/stdlib/Zlib_jll/Project.toml
+++ b/stdlib/Zlib_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "Zlib_jll"
 uuid = "83775a58-1f1d-513f-b197-d71354ab007a"
-version = "1.2.13+1"
+version = "1.3.1+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/stdlib/Zlib_jll/test/runtests.jl b/stdlib/Zlib_jll/test/runtests.jl
index f04f9c70a7054..81eb742a172fe 100644
--- a/stdlib/Zlib_jll/test/runtests.jl
+++ b/stdlib/Zlib_jll/test/runtests.jl
@@ -3,5 +3,5 @@
 using Test, Zlib_jll
 
 @testset "Zlib_jll" begin
-    @test VersionNumber(unsafe_string(ccall((:zlibVersion, libz), Cstring, ()))) == v"1.2.13"
+    @test VersionNumber(unsafe_string(ccall((:zlibVersion, libz), Cstring, ()))) == v"1.3.1"
 end

From 4607d53e5b3fd5ba067b98fda10dc0b7bb341548 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 26 Mar 2024 04:51:28 -0400
Subject: [PATCH 1176/1315] lowering: Don't bother rewrapping bare linenumbers
 in hygienic-scope (#53850)

JuliaInterpreter tries to do some very questionable pre-lowering
introspection to find line numbers, but doesn't properly handle hygienic
scope. That should be fixed, but as I was about to put in a hack there,
I figured we might as well not bother re-wrapping bare LineNumberNodes
in hygienic scopes. They just get discarded again immediately anyway. No
functional change in that this is semantically equivalent to what we had
before, just with a slightly more compact lowering result and additional
JuliaInterpreter test passing.
---
 src/macroexpand.scm | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/macroexpand.scm b/src/macroexpand.scm
index 403df1f3d9ef0..74d47aec45479 100644
--- a/src/macroexpand.scm
+++ b/src/macroexpand.scm
@@ -386,6 +386,9 @@
       (cdr ranges)
       (list ranges))))
 
+(define (just-line? ex)
+  (and (pair? ex) (eq? (car ex) 'line) (atom? (cadr ex)) (or (atom? (caddr ex)) (nothing? (caddr ex)))))
+
 (define (resolve-expansion-vars- e env m lno parent-scope inarg)
   (cond ((or (eq? e 'begin) (eq? e 'end) (eq? e 'ccall) (eq? e 'cglobal) (underscore-symbol? e))
          e)
@@ -417,11 +420,15 @@
            ((toplevel) ; re-wrap Expr(:toplevel) in the current hygienic-scope(s)
             `(toplevel
                ,@(map (lambda (arg)
-                       (let loop ((parent-scope parent-scope) (m m) (lno lno) (arg arg))
-                        (let ((wrapped `(hygienic-scope ,arg ,m ,@lno)))
-                          (if (null? parent-scope) wrapped
-                            (loop (cdr parent-scope) (cadar parent-scope) (caddar parent-scope) wrapped)))))
-                      (cdr e))))
+                       ;; Minor optimization: A lot of toplevel exprs have just bare line numbers in them.
+                       ;; don't bother with the full rewrapping in that case (even though
+                       ;; this would be semantically legal) - lowering won't touch them anyways.
+                       (if (just-line? arg) arg
+                        (let loop ((parent-scope parent-scope) (m m) (lno lno) (arg arg))
+                          (let ((wrapped `(hygienic-scope ,arg ,m ,@lno)))
+                            (if (null? parent-scope) wrapped
+                              (loop (cdr parent-scope) (cadar parent-scope) (caddar parent-scope) wrapped))))))
+                        (cdr e))))
            ((using import export meta line inbounds boundscheck loopinfo inline noinline purity) (map unescape e))
            ((macrocall) e) ; invalid syntax anyways, so just act like it's quoted.
            ((symboliclabel) e)

From 86a697c7fea4e1ed2c2a9487d883b84dd31e8899 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Tue, 26 Mar 2024 05:20:13 -0400
Subject: [PATCH 1177/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=206859d6857=20to=20162634c56=20(#53846)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 6859d6857
New commit: 162634c56
Julia version: 1.12.0-DEV
Pkg version: 1.12.0
Bump invoked by: @KristofferC
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/6859d68579e7970daf00720901cf487563dca0da...162634c5615d12b889e4b64f3cff95d1c377f189

```
$ git log --oneline 6859d6857..162634c56
162634c56 Add workspace feature (#3841)
a4ec712eb Remove outdated UUID instructions (#3855)
9c6356fa9 collect e.g. weak deps from project even if it is not a package (#3852)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5     | 1 +
 .../Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512  | 1 +
 .../Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5     | 1 -
 .../Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512  | 1 -
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512
 delete mode 100644 deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512

diff --git a/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5 b/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5
new file mode 100644
index 0000000000000..c27b9894015ce
--- /dev/null
+++ b/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5
@@ -0,0 +1 @@
+4bd123b9499b46a859d5bba5ae2228a5
diff --git a/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512 b/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512
new file mode 100644
index 0000000000000..d4c2d6b185137
--- /dev/null
+++ b/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512
@@ -0,0 +1 @@
+5f743255cee291185094bfa86e48f65160bc1ad170f052644b79d90d2f1d3c6c3e2be3c4da25925f3ec4b3f87179f946252cdab199ca510b78064afb0b0df039
diff --git a/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5 b/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5
deleted file mode 100644
index d8e436d51267c..0000000000000
--- a/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-16cb4d2bcc0bc1c13aa5f1ee02f5f8ee
diff --git a/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512 b/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512
deleted file mode 100644
index 43b4ed2a68456..0000000000000
--- a/deps/checksums/Pkg-6859d68579e7970daf00720901cf487563dca0da.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-e92cb66a66bcdb9c717c868912b0b53e25f4a04ce380714f619e5be36e07ff21f457c87c2a2af23460f6703fdfd9f931ad65a47c0ff96a39a3075f1ca54275ae
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 2fcaa62d4d398..0fcf00277a6f8 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 6859d68579e7970daf00720901cf487563dca0da
+PKG_SHA1 = 162634c5615d12b889e4b64f3cff95d1c377f189
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From 64de065a183ac70bb049f7f9e30d790f8845dd2b Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Tue, 26 Mar 2024 13:56:03 +0100
Subject: [PATCH 1178/1315] Update libgit2 to 1.8.0 (#53840)

According to the release notes, three breaking (ABI) changes are handled
here:

- `GIT_CONFIG_LEVEL_WORKTREE` constant (and modification to value of
`GIT_CONFIG_LEVEL_APP`)
- `git_config_entry` structure
- `git_push_options` structure

https://github.com/libgit2/libgit2/releases/tag/v1.8.0
---
 deps/checksums/cacert-2023-12-12.pem/md5    |  1 -
 deps/checksums/cacert-2023-12-12.pem/sha512 |  1 -
 deps/checksums/cacert-2024-03-11.pem/md5    |  1 +
 deps/checksums/cacert-2024-03-11.pem/sha512 |  1 +
 deps/checksums/libgit2                      | 68 ++++++++++-----------
 deps/libgit2.version                        |  6 +-
 stdlib/LibGit2/src/consts.jl                | 27 +++++++-
 stdlib/LibGit2/src/types.jl                 | 14 ++++-
 stdlib/LibGit2_jll/Project.toml             |  2 +-
 stdlib/LibGit2_jll/src/LibGit2_jll.jl       |  4 +-
 stdlib/LibGit2_jll/test/runtests.jl         |  2 +-
 stdlib/Manifest.toml                        |  2 +-
 stdlib/MozillaCACerts_jll/Project.toml      |  2 +-
 13 files changed, 84 insertions(+), 47 deletions(-)
 delete mode 100644 deps/checksums/cacert-2023-12-12.pem/md5
 delete mode 100644 deps/checksums/cacert-2023-12-12.pem/sha512
 create mode 100644 deps/checksums/cacert-2024-03-11.pem/md5
 create mode 100644 deps/checksums/cacert-2024-03-11.pem/sha512

diff --git a/deps/checksums/cacert-2023-12-12.pem/md5 b/deps/checksums/cacert-2023-12-12.pem/md5
deleted file mode 100644
index fa4b90b0b2ddd..0000000000000
--- a/deps/checksums/cacert-2023-12-12.pem/md5
+++ /dev/null
@@ -1 +0,0 @@
-1e305b4e910d204ab7b4c18ec0cf0f27
diff --git a/deps/checksums/cacert-2023-12-12.pem/sha512 b/deps/checksums/cacert-2023-12-12.pem/sha512
deleted file mode 100644
index 8ce26f24dffd9..0000000000000
--- a/deps/checksums/cacert-2023-12-12.pem/sha512
+++ /dev/null
@@ -1 +0,0 @@
-dcbfe08d39efdd8de555b31e1050757900d08448c61f8a67c055f14514e5d47e734f6874b5ae628021c35ebc8dabdfdac5808df0b3a073d4f9246cca4b725fe8
diff --git a/deps/checksums/cacert-2024-03-11.pem/md5 b/deps/checksums/cacert-2024-03-11.pem/md5
new file mode 100644
index 0000000000000..618b6c74efdd4
--- /dev/null
+++ b/deps/checksums/cacert-2024-03-11.pem/md5
@@ -0,0 +1 @@
+594084120d27f482b1dc48f558d12d48
diff --git a/deps/checksums/cacert-2024-03-11.pem/sha512 b/deps/checksums/cacert-2024-03-11.pem/sha512
new file mode 100644
index 0000000000000..441b8e84707b0
--- /dev/null
+++ b/deps/checksums/cacert-2024-03-11.pem/sha512
@@ -0,0 +1 @@
+31f03cc19566d007c4cffdad2ada71d99b4734ad7b13bc4f30d73d321f40cbe13b87a801aa61d9788207a851cc1f95a8af8ac732a372d45edb932f204bce3744
diff --git a/deps/checksums/libgit2 b/deps/checksums/libgit2
index 78b82572f3898..629a5f0601fcd 100644
--- a/deps/checksums/libgit2
+++ b/deps/checksums/libgit2
@@ -1,34 +1,34 @@
-LibGit2.v1.7.2+0.aarch64-apple-darwin.tar.gz/md5/069fa8cbd69e98a6196bd24bb427ff47
-LibGit2.v1.7.2+0.aarch64-apple-darwin.tar.gz/sha512/bacaf03e8aa28a55af2ae031f09a22f0a9cecb20257ee9778f37d87eb4ed21ff25dbb33ac342b134edc2a9584c0c57e6eabf7dbe78b031e9e45c2448bd8a317c
-LibGit2.v1.7.2+0.aarch64-linux-gnu.tar.gz/md5/3bc5dfb163045c335aec05097702ddd4
-LibGit2.v1.7.2+0.aarch64-linux-gnu.tar.gz/sha512/c8055e51713f6fe6f064c7e4626db7a70d07af6e5c8cb031e88ef8ea728accdb92a449f738fb248c0afbc9698d30d0670fa5cf640df564886887c7ce4dbc7124
-LibGit2.v1.7.2+0.aarch64-linux-musl.tar.gz/md5/23440824a3ec0a0d82fa8adccac63534
-LibGit2.v1.7.2+0.aarch64-linux-musl.tar.gz/sha512/040874d092d7a11c5bfa284e95b86335792ffa6b868e8c7165ca304647d82ffbc7a72b65bb92038abd1bfa545e831d5b2a658b3f5891377735f85d3e4ddff7b2
-LibGit2.v1.7.2+0.armv6l-linux-gnueabihf.tar.gz/md5/3ffc0954875a20f610f6852c522311f2
-LibGit2.v1.7.2+0.armv6l-linux-gnueabihf.tar.gz/sha512/35767e10a36a0025539a354ef5be2ec4031457c0c1121a07f4616c774e48bb85425732935a12718d23627b4bdf1fb5c7fe6b220cb4e2bcb94b9d26c743af0004
-LibGit2.v1.7.2+0.armv6l-linux-musleabihf.tar.gz/md5/73acea595fc31967d7fe1e808f4cc47c
-LibGit2.v1.7.2+0.armv6l-linux-musleabihf.tar.gz/sha512/e124681a7b7b1ff64a1ca073ee6fcc75fc2b11ab0a3404b0a2bc9944854c4048e576697254cd8efed1d6c7103ac2e1bd574a75c6c3d8a383775d48170ef6d474
-LibGit2.v1.7.2+0.armv7l-linux-gnueabihf.tar.gz/md5/b710035b0be0c7e4810b9282912369a0
-LibGit2.v1.7.2+0.armv7l-linux-gnueabihf.tar.gz/sha512/e34b2956a869303a5b6bed059f326989e4e95f039fa3d1b75fc6f80c6d1170df96e2ea809df05aad59685751eb4666a0a05e0c3b456bcace2b0570b174b2b541
-LibGit2.v1.7.2+0.armv7l-linux-musleabihf.tar.gz/md5/aa4c7374dda73266cd387596fa31c258
-LibGit2.v1.7.2+0.armv7l-linux-musleabihf.tar.gz/sha512/54f6c9bd7dd1ee0438b817b1b18a94ce6f18838613524f146cf37f7d01319dd7c05d19d352376454ed2658e9dd839fede32db05748d9c352b56c3f0fe01edebc
-LibGit2.v1.7.2+0.i686-linux-gnu.tar.gz/md5/2cf407e8cf5f7c7c984b48704935afaa
-LibGit2.v1.7.2+0.i686-linux-gnu.tar.gz/sha512/44224ccf773b9f77979c1130cbb893d80c934918940ab9357bff7d92b97bdf1671d4263d121a603a6c12e60375bafc38b4bcac9a12cb0abb4665b5848d12946a
-LibGit2.v1.7.2+0.i686-linux-musl.tar.gz/md5/742b947992f9f003a49c480165df1c87
-LibGit2.v1.7.2+0.i686-linux-musl.tar.gz/sha512/4d1a0c5c119f391be76d93ee7e82c6e38c8cda5c172c3d431bed6c6923776d4ad194c88509203332bed23f4c42581255a319a2ca45b6433b3fb68b3dc0aa1f02
-LibGit2.v1.7.2+0.i686-w64-mingw32.tar.gz/md5/476c290758970376ddfdcad25ba74c7c
-LibGit2.v1.7.2+0.i686-w64-mingw32.tar.gz/sha512/dc76e0563b45aead1187fd7abfe411e3fbc21ff45983b693c11db4265d39fc3f51d167fe447f6a7efb1f3ec1e35a9d0edb1c3444ed50be62770dfea545fbddae
-LibGit2.v1.7.2+0.powerpc64le-linux-gnu.tar.gz/md5/3ce536ea1ad7facca14c19c84106e8e5
-LibGit2.v1.7.2+0.powerpc64le-linux-gnu.tar.gz/sha512/d52d400249c7ed16084b13fde81f784cbf3b13b7081944872986b216b7faf186b7c8ff28626504d461c6059c7b4962acde0b15dc2e36007492210568a0f425f7
-LibGit2.v1.7.2+0.x86_64-apple-darwin.tar.gz/md5/c59af177b7ebdcfd52312a40d7832ee8
-LibGit2.v1.7.2+0.x86_64-apple-darwin.tar.gz/sha512/5bae0efc71421f28e4a3b2aca70ef1810b5810ed3df3d3577b8a7e956ea895f4b9efdabf17a32130e1f71fede4ceae7246d099b71147686e5722abdf56d50778
-LibGit2.v1.7.2+0.x86_64-linux-gnu.tar.gz/md5/1a55eb14294730b0ba7a23df3aac27ee
-LibGit2.v1.7.2+0.x86_64-linux-gnu.tar.gz/sha512/21f7aea927bed22da1b974eab4d6f3413cc41e47b5a5e5bbfff6690474d6f374952b81549345a68c9227d1f3ef9e76578c81776cd1c41e75330c9f2dd1437c7b
-LibGit2.v1.7.2+0.x86_64-linux-musl.tar.gz/md5/33a9bfb5a805ca6ca695196c2e94183e
-LibGit2.v1.7.2+0.x86_64-linux-musl.tar.gz/sha512/924c2c2cd9baad369b21c17364164dbff7ecda153cb1ed89a4a7539407f3bdc54e87304ed2b7e26ba8046077cb0b3645e9263d53eb4b220436a2e150a77109c3
-LibGit2.v1.7.2+0.x86_64-unknown-freebsd.tar.gz/md5/8d27555b9a1bc086c4c3056cda876bd2
-LibGit2.v1.7.2+0.x86_64-unknown-freebsd.tar.gz/sha512/8ca7a589a328908ee10490230c963ae1292f9cb7c2c427c26ca5d6e4985d56ef76d02f98e05e4fc655cc5e92e2e405d63896a180bc33ebd4b852d2ff355c0339
-LibGit2.v1.7.2+0.x86_64-w64-mingw32.tar.gz/md5/3d7ac5a2af376a2ba0b335cb84710874
-LibGit2.v1.7.2+0.x86_64-w64-mingw32.tar.gz/sha512/5bdbb1110fa7c5bfaac0ba63002f9b1f480abab1cf3e284146352c30027381c23919745a0c490e202e8d856503f5c2bb2390a6bc32af533def7d31f8d6f7be31
-libgit2-a418d9d4ab87bae16b87d8f37143a4687ae0e4b2.tar.gz/md5/c67e5a2358f01d26b78269639ba20148
-libgit2-a418d9d4ab87bae16b87d8f37143a4687ae0e4b2.tar.gz/sha512/c82dc18bacb45f82c72f09e5525fd47191c8673a553df9faa05290c33dfdadfff9784341e68790130a14b12267c795f4ca166481fdf9674d2b70e8228bbeb11d
+LibGit2.v1.8.0+0.aarch64-apple-darwin.tar.gz/md5/c19f3a4f6567b7504f607fc6f328312f
+LibGit2.v1.8.0+0.aarch64-apple-darwin.tar.gz/sha512/0a776ab3eb4593abe0f2198a7371cbcf653ac5cf71ab7af9d5520c2bbbbbc981cf07ba3afa70f1ef6ea56f81e2d4b33b1be1482f9e215e61178b3dd1149ecb80
+LibGit2.v1.8.0+0.aarch64-linux-gnu.tar.gz/md5/8137d530bea16d41a614983068c1909d
+LibGit2.v1.8.0+0.aarch64-linux-gnu.tar.gz/sha512/bdcb6249acd8df887a8af7c084d409132694a39f5e9f90bd70bba0f3eba2bad3eab6958cce9f060b2a4392d99352ccda8be92000f24ed4498c85ba55e0cbf13f
+LibGit2.v1.8.0+0.aarch64-linux-musl.tar.gz/md5/4b9508ea58d4b1bd99f8471bd7c9a839
+LibGit2.v1.8.0+0.aarch64-linux-musl.tar.gz/sha512/e0996627a3d3ab9b3b1d103bbdd3e1179ede5479816f6b1be54471f120f76fe0495d3c7587c382985173c0614b634903b58c67ac3badbead82b4d797cc5915d7
+LibGit2.v1.8.0+0.armv6l-linux-gnueabihf.tar.gz/md5/02d6fae1745562cf724190929383688e
+LibGit2.v1.8.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/11c14c5f395252143218a495c7dd2817c8f18f73320200a521f5ccd5f0c3c87403dee2c3b9e8166022fde1a67e83cbb83e6f222aac38b41efa43a6c0254548a9
+LibGit2.v1.8.0+0.armv6l-linux-musleabihf.tar.gz/md5/afa7b90751565b865f443b5a0a870d8b
+LibGit2.v1.8.0+0.armv6l-linux-musleabihf.tar.gz/sha512/3594c223883a7da3bc0c78ae656fb15e47cc9dd196cf08f0abc0a1fb5f799842261e125440c07e92ba82896ad7427814bb43b63ba64d9b72ba38e9149132c26b
+LibGit2.v1.8.0+0.armv7l-linux-gnueabihf.tar.gz/md5/ead27583a1cc5748c84d58a07fa6fc7e
+LibGit2.v1.8.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/c81c3582fda7b299aaed72de07e9d0bd06c0c231aed73bb980c12c89b2b7593b2fb7990421bc2e45173f3d107ab50660842289675efa31f24ff752f0ebc63875
+LibGit2.v1.8.0+0.armv7l-linux-musleabihf.tar.gz/md5/71e38f112e8629682cc383c510f1f13f
+LibGit2.v1.8.0+0.armv7l-linux-musleabihf.tar.gz/sha512/0b4b2677bdfc4f8e2a5ef3b9adf8fa2c0c1e76bd240b2173c268835b59cda29cbffc4241319fe36dcd63d1507ecf0e0e843f48fca80e3fbe4d3df53601ad7dec
+LibGit2.v1.8.0+0.i686-linux-gnu.tar.gz/md5/b54cdd02201c1481746ab81db6f39aac
+LibGit2.v1.8.0+0.i686-linux-gnu.tar.gz/sha512/0496a607b0d6841fc0c87477274b61eb95afa24d48d2624f8aaf230028a24d0248336902b01a326010fdbc45d8d73eecedb14c82313e1b1a94b3b6a4296e2607
+LibGit2.v1.8.0+0.i686-linux-musl.tar.gz/md5/b8946f9c1b83a7c22b2a8ca6da05b23b
+LibGit2.v1.8.0+0.i686-linux-musl.tar.gz/sha512/931ff27da4e35749a5c020af72b750dce0b1d672cd98c04ad5a340f4f33ddb61c4df6711c36c6601063262fb733d45a3bb24eb1141e9d2fd2e0ab7b9bfbf54c8
+LibGit2.v1.8.0+0.i686-w64-mingw32.tar.gz/md5/cb9db0b590efe0c60f6e2f9558de4e5b
+LibGit2.v1.8.0+0.i686-w64-mingw32.tar.gz/sha512/b9f637ec10cd751dfb2156e154a68809af400cdecbf0d25910792937c63ea56e60b703c7b78e3038ab34b1100bb20df79dce6346f40f1d24e5188fefe9517ccc
+LibGit2.v1.8.0+0.powerpc64le-linux-gnu.tar.gz/md5/4ac1fa6b1ca43d3f6e97d590d1d27127
+LibGit2.v1.8.0+0.powerpc64le-linux-gnu.tar.gz/sha512/5cc3b9b9d85068bb3c6711c63ccb2672be765888a114147f70cae0eebf96f5bde00a40f163202c20e18a4cf4af2488fd1c304060daa3dd35748b30ab5a1fdb1d
+LibGit2.v1.8.0+0.x86_64-apple-darwin.tar.gz/md5/26c2d1dcf68bc7b9919dfd24eb2fabc7
+LibGit2.v1.8.0+0.x86_64-apple-darwin.tar.gz/sha512/9c3ba94c438682f321cb2130f71028587a4a21b960f94f8c3f633dbe007210ff1b7b5e0b0bc4972e818458843a47a9e8d50d88f1bd3fb03a8fe129fa66332a38
+LibGit2.v1.8.0+0.x86_64-linux-gnu.tar.gz/md5/8d48ad388cca20d6338095cf8a36c3c9
+LibGit2.v1.8.0+0.x86_64-linux-gnu.tar.gz/sha512/9ddf4dc7420a9129ff8c34eb07ee94d9213c1a1c22700521199032a773353ab2413fd70d002b273a06dd951558128cd5577b7e917de6575d379911831d737bed
+LibGit2.v1.8.0+0.x86_64-linux-musl.tar.gz/md5/5d9fd50bdf38ec99311e9627f254b95d
+LibGit2.v1.8.0+0.x86_64-linux-musl.tar.gz/sha512/eae36cc70cb414e15924c22c9b03a98949b89fd8ca429fbe23fa215253266ed4cd11530adb2feccc9a19299ebf2048f1f5929c1faffba463b593b6c3e1808bee
+LibGit2.v1.8.0+0.x86_64-unknown-freebsd.tar.gz/md5/af9e9d4bbe0df291f07f41416809a6f2
+LibGit2.v1.8.0+0.x86_64-unknown-freebsd.tar.gz/sha512/859786f13ba1fb5cd448dd5f22ebdf3381f5290d4875d65840fb31567ccd012f283a1849a82f2b2f58c3d73eda4c748d3da07d84a99665e0f50aeb39c37a4fb2
+LibGit2.v1.8.0+0.x86_64-w64-mingw32.tar.gz/md5/b51e3e238d776d52e396dd749f895e4f
+LibGit2.v1.8.0+0.x86_64-w64-mingw32.tar.gz/sha512/2581d4b1d6fd4d0f15b406f050bd8a2a41e13dc2a1699a9b956e56426778beb994e6552988bf50ddad682349209a8694eace9450dab0570434cdfbed9c9f0b24
+libgit2-d74d491481831ddcd23575d376e56d2197e95910.tar.gz/md5/2420def04a290dd7ad0e67f93789f106
+libgit2-d74d491481831ddcd23575d376e56d2197e95910.tar.gz/sha512/496c6640d2453c58b66bc53c6e4e9e84f48d89eb8f240aefc1eea7e2d19b6c601614764590f2d2ca9e51e7e1de8fcdd5bf67f27f32bab628eae40d26ed382048
diff --git a/deps/libgit2.version b/deps/libgit2.version
index 65f3e7670e4af..d51beb34c27f5 100644
--- a/deps/libgit2.version
+++ b/deps/libgit2.version
@@ -3,12 +3,12 @@
 LIBGIT2_JLL_NAME := LibGit2
 
 ## source build
-LIBGIT2_BRANCH=v1.7.2
-LIBGIT2_SHA1=a418d9d4ab87bae16b87d8f37143a4687ae0e4b2
+LIBGIT2_BRANCH=v1.8.0
+LIBGIT2_SHA1=d74d491481831ddcd23575d376e56d2197e95910
 
 ## Other deps
 # Specify the version of the Mozilla CA Certificate Store to obtain.
 # The versions of cacert.pem are identified by the date (YYYY-MM-DD) of their changes.
 # See https://curl.haxx.se/docs/caextract.html for more details.
 # Keep in sync with `stdlib/MozillaCACerts_jll/Project.toml`.
-MOZILLA_CACERT_VERSION := 2023-12-12
+MOZILLA_CACERT_VERSION := 2024-03-11
diff --git a/stdlib/LibGit2/src/consts.jl b/stdlib/LibGit2/src/consts.jl
index 5a5b8b74e7127..8c140e8c2aa30 100644
--- a/stdlib/LibGit2/src/consts.jl
+++ b/stdlib/LibGit2/src/consts.jl
@@ -417,7 +417,32 @@ Option flags for `GitRepo`.
                    FEATURE_SSH     = Cuint(1 << 2),
                    FEATURE_NSEC    = Cuint(1 << 3))
 
-if version() >= v"0.24.0"
+if version() >= v"1.8.0"
+    @doc """
+    Priority level of a config file.
+
+    These priority levels correspond to the natural escalation logic (from higher to lower) when searching for config entries in git.
+
+    * `CONFIG_LEVEL_DEFAULT` - Open the global, XDG and system configuration files if any available.
+    * `CONFIG_LEVEL_PROGRAMDATA` - System-wide on Windows, for compatibility with portable git
+    * `CONFIG_LEVEL_SYSTEM` - System-wide configuration file; `/etc/gitconfig` on Linux systems
+    * `CONFIG_LEVEL_XDG` - XDG compatible configuration file; typically `~/.config/git/config`
+    * `CONFIG_LEVEL_GLOBAL` - User-specific configuration file (also called Global configuration file); typically `~/.gitconfig`
+    * `CONFIG_LEVEL_LOCAL` - Repository specific configuration file; `\$WORK_DIR/.git/config` on non-bare repos
+    * `CONFIG_LEVEL_WORKTREE` - Worktree specific configuration file; `\$GIT_DIR/config.worktree`
+    * `CONFIG_LEVEL_APP` - Application specific configuration file; freely defined by applications
+    * `CONFIG_HIGHEST_LEVEL` - Represents the highest level available config file (i.e. the most specific config file available that actually is loaded)
+    """
+    @enum(GIT_CONFIG, CONFIG_LEVEL_DEFAULT     = 0,
+                      CONFIG_LEVEL_PROGRAMDATA = 1,
+                      CONFIG_LEVEL_SYSTEM      = 2,
+                      CONFIG_LEVEL_XDG         = 3,
+                      CONFIG_LEVEL_GLOBAL      = 4,
+                      CONFIG_LEVEL_LOCAL       = 5,
+                      CONFIG_LEVEL_WORKTREE    = 6,
+                      CONFIG_LEVEL_APP         = 7,
+                      CONFIG_HIGHEST_LEVEL     =-1)
+elseif version() >= v"0.24.0"
     @doc """
     Priority level of a config file.
 
diff --git a/stdlib/LibGit2/src/types.jl b/stdlib/LibGit2/src/types.jl
index 96cea96d013e5..b0b463c69e2f1 100644
--- a/stdlib/LibGit2/src/types.jl
+++ b/stdlib/LibGit2/src/types.jl
@@ -678,6 +678,8 @@ The fields represent:
      for more information.
   * `custom_headers`: only relevant if the LibGit2 version is greater than or equal to `0.24.0`.
      Extra headers needed for the push operation.
+  * `remote_push_options`: only relevant if the LibGit2 version is greater than or equal to `1.8.0`.
+     "Push options" to deliver to the remote.
 """
 @kwdef struct PushOptions
     version::Cuint                     = Cuint(1)
@@ -692,6 +694,9 @@ The fields represent:
     @static if LibGit2.VERSION >= v"0.24.0"
         custom_headers::StrArrayStruct = StrArrayStruct()
     end
+    @static if LibGit2.VERSION >= v"1.8.0"
+        remote_push_options::StrArrayStruct = StrArrayStruct()
+    end
 end
 @assert Base.allocatedinline(PushOptions)
 
@@ -913,10 +918,17 @@ Matches the [`git_config_entry`](https://libgit2.org/libgit2/#HEAD/type/git_conf
 struct ConfigEntry
     name::Cstring
     value::Cstring
+    @static if LibGit2.VERSION >= v"1.8.0"
+        backend_type::Cstring
+        origin_path::Cstring
+    end
     include_depth::Cuint
     level::GIT_CONFIG
     free::Ptr{Cvoid}
-    payload::Ptr{Cvoid} # User is not permitted to read or write this field
+    @static if LibGit2.VERSION < v"1.8.0"
+        # In 1.8.0, the unused payload value has been removed
+        payload::Ptr{Cvoid}
+    end
 end
 @assert Base.allocatedinline(ConfigEntry)
 
diff --git a/stdlib/LibGit2_jll/Project.toml b/stdlib/LibGit2_jll/Project.toml
index 1e13d0228488f..ceeb394f26231 100644
--- a/stdlib/LibGit2_jll/Project.toml
+++ b/stdlib/LibGit2_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LibGit2_jll"
 uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"
-version = "1.7.2+0"
+version = "1.8.0+0"
 
 [deps]
 MbedTLS_jll = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
diff --git a/stdlib/LibGit2_jll/src/LibGit2_jll.jl b/stdlib/LibGit2_jll/src/LibGit2_jll.jl
index c24d3c20f428e..15d303dfea6ee 100644
--- a/stdlib/LibGit2_jll/src/LibGit2_jll.jl
+++ b/stdlib/LibGit2_jll/src/LibGit2_jll.jl
@@ -20,9 +20,9 @@ libgit2_path::String = ""
 if Sys.iswindows()
     const libgit2 = "libgit2.dll"
 elseif Sys.isapple()
-    const libgit2 = "@rpath/libgit2.1.7.dylib"
+    const libgit2 = "@rpath/libgit2.1.8.dylib"
 else
-    const libgit2 = "libgit2.so.1.7"
+    const libgit2 = "libgit2.so.1.8"
 end
 
 function __init__()
diff --git a/stdlib/LibGit2_jll/test/runtests.jl b/stdlib/LibGit2_jll/test/runtests.jl
index 6d83f6e447453..5bc74760b1603 100644
--- a/stdlib/LibGit2_jll/test/runtests.jl
+++ b/stdlib/LibGit2_jll/test/runtests.jl
@@ -7,5 +7,5 @@ using Test, Libdl, LibGit2_jll
     minor = Ref{Cint}(0)
     patch = Ref{Cint}(0)
     @test ccall((:git_libgit2_version, libgit2), Cint, (Ref{Cint}, Ref{Cint}, Ref{Cint}), major, minor, patch) == 0
-    @test VersionNumber(major[], minor[], patch[]) == v"1.7.2"
+    @test VersionNumber(major[], minor[], patch[]) == v"1.8.0"
 end
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index a9491702f62ad..a715cf141481b 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -103,7 +103,7 @@ version = "1.11.0"
 [[deps.LibGit2_jll]]
 deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"]
 uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"
-version = "1.7.2+0"
+version = "1.8.0+0"
 
 [[deps.LibSSH2_jll]]
 deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
diff --git a/stdlib/MozillaCACerts_jll/Project.toml b/stdlib/MozillaCACerts_jll/Project.toml
index b4f667b974736..181171a4c04c1 100644
--- a/stdlib/MozillaCACerts_jll/Project.toml
+++ b/stdlib/MozillaCACerts_jll/Project.toml
@@ -1,7 +1,7 @@
 name = "MozillaCACerts_jll"
 uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
 # Keep in sync with `deps/libgit2.version`.
-version = "2023.12.12"
+version = "2024.03.11"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

From 653c0ae986493a68f9fe4ad8a8981baacf9f9e92 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 26 Mar 2024 19:22:36 -0400
Subject: [PATCH 1179/1315] precompilepkgs: don't confuse single package in
 project with requesting single package (#53865)

Followup to https://github.com/JuliaLang/julia/pull/53653
Separate from #53862 because this one is just broken on master

Without this if you precompile a project with a single dep it thought
the user was calling `precompile Dep` or `using Dep` so went into live
print mode, which is confusing.
---
 base/precompilation.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index a823b2b579852..a835b6974d433 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -361,6 +361,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                         manifest::Bool=false,)
 
     configs = configs isa Config ? [configs] : configs
+    requested_pkgs = copy(pkgs) # for understanding user intent
 
     time_start = time_ns()
 
@@ -748,7 +749,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
     for (pkg, deps) in depsmap
         cachepaths = Base.find_all_in_cache_path(pkg)
         sourcepath = Base.locate_package(pkg)
-        single_requested_pkg = length(pkgs) == 1 && only(pkgs) == pkg.name
+        single_requested_pkg = length(requested_pkgs) == 1 && only(requested_pkgs) == pkg.name
         for config in configs
             pkg_config = (pkg, config)
             if sourcepath === nothing

From fc2d3af5bd8b6a0ba8d057c31129e9318b19f2c5 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 26 Mar 2024 20:37:46 -0400
Subject: [PATCH 1180/1315] precompilepkgs: fix error reporting (#53862)

---
 base/precompilation.jl | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index a835b6974d433..8185fe8e8230b 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -333,6 +333,8 @@ struct PkgPrecompileError <: Exception
     msg::String
 end
 Base.showerror(io::IO, err::PkgPrecompileError) = print(io, err.msg)
+Base.showerror(io::IO, err::PkgPrecompileError, bt; kw...) = Base.showerror(io, err) # hide stacktrace
+
 # This needs a show method to make `julia> err` show nicely
 Base.show(io::IO, err::PkgPrecompileError) = print(io, "PkgPrecompileError: ", err.msg)
 
@@ -821,7 +823,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                             close(std_pipe.in) # close pipe to end the std output monitor
                             wait(t_monitor)
                             if err isa ErrorException || (err isa ArgumentError && startswith(err.msg, "Invalid header in cache file"))
-                                failed_deps[pkg_config] = (strict || is_direct_dep) ? string(sprint(showerror, err), "\n", strip(get(std_outputs, pkg, ""))) : ""
+                                failed_deps[pkg_config] = (strict || is_direct_dep) ? string(sprint(showerror, err), "\n", strip(get(std_outputs, pkg_config, ""))) : ""
                                 delete!(std_outputs, pkg_config) # so it's not shown as warnings, given error report
                                 !fancyprint && lock(print_lock) do
                                     println(io, " "^9, color_string("  ✗ ", Base.error_color()), name)
@@ -944,7 +946,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
                 end
             else
                 println(io)
-                error(err_msg)
+                throw(PkgPrecompileError(err_msg))
             end
         end
     end

From d4d34b9639ba2fa66f52aff422c34c60c080ab19 Mon Sep 17 00:00:00 2001
From: crazeteam <164632007+crazeteam@users.noreply.github.com>
Date: Wed, 27 Mar 2024 08:44:31 +0800
Subject: [PATCH 1181/1315] chore: fix some comments (#53861)

Signed-off-by: crazeteam <lilujing@outlook.com>
---
 base/sort.jl                           | 2 +-
 stdlib/LinearAlgebra/src/triangular.jl | 2 +-
 stdlib/REPL/test/repl.jl               | 2 +-
 stdlib/Test/test/runtests.jl           | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/base/sort.jl b/base/sort.jl
index 281a75cac309e..38e89e3d3a0ce 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -528,7 +528,7 @@ no scratch space is present.
 
 A returned scratch space will be a `Vector{T}` where `T` is usually the eltype of `v`. There
 are some exceptions, for example if `eltype(v) == Union{Missing, T}` then the scratch space
-may be be a `Vector{T}` due to `MissingOptimization` changing the eltype of `v` to `T`.
+may be a `Vector{T}` due to `MissingOptimization` changing the eltype of `v` to `T`.
 
 `t` is an appropriate scratch space for the algorithm at hand, to be accessed as
 `t[i + offset]`. `t` is used for an algorithm to pass a scratch space back to itself in
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index aff87e3ae50ba..97ae07e12e979 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -2663,7 +2663,7 @@ end
             Bᵢⱼ⁽¹⁾ = M_Bᵢⱼ⁽¹⁾[1:s₁, 1:s₂]
             # Compute Bᵢⱼ⁽⁰⁾ and Bᵢⱼ⁽¹⁾
             mul!(Bᵢⱼ⁽⁰⁾, A[i₁:i₂,k₁:k₂], A[k₁:k₂,j₁:j₂])
-            # Retreive Rᵢ,ᵢ₊ₖ as A[i+k,i]'
+            # Retrieve Rᵢ,ᵢ₊ₖ as A[i+k,i]'
             mul!(Bᵢⱼ⁽¹⁾, A[i₁:i₂,k₁:k₂], A[j₁:j₂,k₁:k₂]')
             # Solve Uᵢ,ᵢ₊ₖ using Reference [1, (4.10)]
             kron!(L₀, Δ[1:s₂,1:s₂], S[1:s₁,i₁:i₂])
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 1d0caab7d0e57..09ff10e770e84 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -114,7 +114,7 @@ fake_repl() do stdin_write, stdout_read, repl
     Base.wait(repltask)
 end
 
-# These are integration tests. If you want to unit test test e.g. completion, or
+# These are integration tests. If you want to unit test e.g. completion, or
 # exact LineEdit behavior, put them in the appropriate test files.
 # Furthermore since we are emulating an entire terminal, there may be control characters
 # in the mix. If verification needs to be done, keep it to the bare minimum. Basically
diff --git a/stdlib/Test/test/runtests.jl b/stdlib/Test/test/runtests.jl
index 460e2eadf42b7..fc4838caf4ef4 100644
--- a/stdlib/Test/test/runtests.jl
+++ b/stdlib/Test/test/runtests.jl
@@ -162,7 +162,7 @@ let fails = @testset NoThrowTestSet begin
         @test_throws "A test" error("a test")
         @test_throws r"sqrt\([Cc]omplx" sqrt(-1)
         @test_throws str->occursin("a T", str) error("a test")
-        @test_throws ["BoundsError", "aquire", "1-element", "at index [2]"] [1][2]
+        @test_throws ["BoundsError", "acquire", "1-element", "at index [2]"] [1][2]
     end
     for fail in fails
         @test fail isa Test.Fail
@@ -294,7 +294,7 @@ let fails = @testset NoThrowTestSet begin
     end
 
     let str = sprint(show, fails[26])
-        @test occursin("Expected: [\"BoundsError\", \"aquire\", \"1-element\", \"at index [2]\"]", str)
+        @test occursin("Expected: [\"BoundsError\", \"acquire\", \"1-element\", \"at index [2]\"]", str)
         @test occursin(r"Message: \"BoundsError.* 1-element.*at index \[2\]", str)
     end
 

From 6737a1de25a835870641d8d1f3c507ee60e24cc0 Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Wed, 27 Mar 2024 01:45:27 +0100
Subject: [PATCH 1182/1315] Update SuiteSparse to 7.6.1 (#53864)

Following https://github.com/JuliaPackaging/Yggdrasil/pull/8355
---
 deps/checksums/suitesparse          | 68 ++++++++++++++---------------
 deps/libsuitesparse.version         |  4 +-
 stdlib/Manifest.toml                |  2 +-
 stdlib/SuiteSparse_jll/Project.toml |  2 +-
 4 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/deps/checksums/suitesparse b/deps/checksums/suitesparse
index 88f5195bb021a..537ec7dd6d3fa 100644
--- a/deps/checksums/suitesparse
+++ b/deps/checksums/suitesparse
@@ -1,34 +1,34 @@
-SuiteSparse-7.6.0.tar.gz/md5/79a68c2eca2d4b213a304bd08180c630
-SuiteSparse-7.6.0.tar.gz/sha512/6cffb283e7620afd31c6f7517ca9d28c2927515af582680d346e0e8a4ee1289daec0b4d83660f88f309e53e54a87403291fc4b0b45fe50dffd59781ec0129a8f
-SuiteSparse.v7.6.0+0.aarch64-apple-darwin.tar.gz/md5/dd7cb2ded54840648d9bb28099dfbc66
-SuiteSparse.v7.6.0+0.aarch64-apple-darwin.tar.gz/sha512/64edba78b463dffebf7a1dbcc21665a8229fc795f22ea669e648b03595bb2bc646d0e5d8d9326adca525f325523f50bb8aeb1f1d6da12ba2c465f16f87ed6726
-SuiteSparse.v7.6.0+0.aarch64-linux-gnu.tar.gz/md5/f7e30ff16e597cae91031dd84fcc790a
-SuiteSparse.v7.6.0+0.aarch64-linux-gnu.tar.gz/sha512/a3bfdaef6a2108d0179de3a3fa56c58af4a6cc36d12f987baa6ce15842bff2473c5ea92e5ce0e28d97744c5b8ffae5fb178c14a2e504f8d0291d5dc67370836d
-SuiteSparse.v7.6.0+0.aarch64-linux-musl.tar.gz/md5/763d9208eb9a8d134d8a0fcdf01745c2
-SuiteSparse.v7.6.0+0.aarch64-linux-musl.tar.gz/sha512/657d78d577dade8ddb6b863208c3baf9e15e4cae83853f3730dce49a5f227eb48164f60b39cfd4a22f1d4bcf6d9c6e4b3fcf340bdc6c36345c60fb235bc2cfd7
-SuiteSparse.v7.6.0+0.armv6l-linux-gnueabihf.tar.gz/md5/7c71369a2edfe3eca0061339b8a30e3a
-SuiteSparse.v7.6.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/bc197a50a1031e17721a63405438c2705da456c5ad97dcae0ccc538b0a5d46fa474b49e14a8d3db3d32402e7234e4d9523659a0ec2318901b5e6cd8a5fe7ea8f
-SuiteSparse.v7.6.0+0.armv6l-linux-musleabihf.tar.gz/md5/2933e936ec3cdbbbd015206124d2a98e
-SuiteSparse.v7.6.0+0.armv6l-linux-musleabihf.tar.gz/sha512/d3e3382b982198b5d37928ca0e2354bb110b327069b9dfeb72e9aef1d82e79e5a1536679112c0c82c20acf7e005269f0168c84d498b4ef87c5521bd18b133134
-SuiteSparse.v7.6.0+0.armv7l-linux-gnueabihf.tar.gz/md5/df109c03141c3c34dcbcee180c255539
-SuiteSparse.v7.6.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/cbffe6e5c023f3efbb60a78d6c403feb2b2ca0ff4cac4586c82ffba65d87a4bd1cff63370abfff91882d64e6cf2bb2e10e792ab21f4b7380f413c6a78b89f242
-SuiteSparse.v7.6.0+0.armv7l-linux-musleabihf.tar.gz/md5/5a82f651831d0e83214791156637c38b
-SuiteSparse.v7.6.0+0.armv7l-linux-musleabihf.tar.gz/sha512/0436c0a83d2fb40f21cdd49817182a12824b903050fb47a717a55040445393e5312596e27654a0dabe059059b8dabf82c37e4754a71f189ee1561ddeb11098dc
-SuiteSparse.v7.6.0+0.i686-linux-gnu.tar.gz/md5/b58d6186f54c4f10d1e37ac1b82ebd1c
-SuiteSparse.v7.6.0+0.i686-linux-gnu.tar.gz/sha512/7d3f1cdd2f9786fa072d8820e4ec424d282595051aa2355c84de0530c957459408f7a4d7eb213863fe91a78c03b96346f8c6f8c088ee6e2bad91c576a5e7e39c
-SuiteSparse.v7.6.0+0.i686-linux-musl.tar.gz/md5/c43f347674f1d983d76d453a1ce26c63
-SuiteSparse.v7.6.0+0.i686-linux-musl.tar.gz/sha512/467a4e3af813c7a550b097699ca45083fcdad4ad04689bf53c302b2cf769962c23b62bc39a7afa851c4a1226cd6fbb37e1e8590fd1dbca3c680f7138eb029a8b
-SuiteSparse.v7.6.0+0.i686-w64-mingw32.tar.gz/md5/cd92ad4bef9109ab60357b78ae3c444b
-SuiteSparse.v7.6.0+0.i686-w64-mingw32.tar.gz/sha512/41557b4e4254469bd1f264f0bea4335761ee18328e22d3626dd9ddb69ab8501c40d31c2848ac3c28b361454d80b8d97514478b8db96a335aa4b8580eba22de93
-SuiteSparse.v7.6.0+0.powerpc64le-linux-gnu.tar.gz/md5/8ba38d83ee767ef1a3108ad2fbdc9edf
-SuiteSparse.v7.6.0+0.powerpc64le-linux-gnu.tar.gz/sha512/37ae98d9557ae8d2ce6edbcf2b18f49690b98daa5a19fab2cda747d2f19c735430031414fc8f23bca35899cb21995170e6fe72623dc6dae25b207870b9396698
-SuiteSparse.v7.6.0+0.x86_64-apple-darwin.tar.gz/md5/21cedd18cf9f5aa83b1bdaaf2d4253af
-SuiteSparse.v7.6.0+0.x86_64-apple-darwin.tar.gz/sha512/e86ea34ac3d1d1123be7d6989893948d26a98ae28198740272c108c434650d1616f89c9176ea51c0dbc3550a1a4f0611935eec29b2aafd96d80717c99916a2b1
-SuiteSparse.v7.6.0+0.x86_64-linux-gnu.tar.gz/md5/10674b26e56d1cb4345012b965cac926
-SuiteSparse.v7.6.0+0.x86_64-linux-gnu.tar.gz/sha512/d1dba73e5449768ac728923edf665f1c11e6d54654ab14190fa3c7cd128642b2dac5b21f3c2d91313ab35e5054e6406542e074b6de2b8c0bce49269a9ab89dd4
-SuiteSparse.v7.6.0+0.x86_64-linux-musl.tar.gz/md5/9f2b78216d7474b064c710f6966b15d9
-SuiteSparse.v7.6.0+0.x86_64-linux-musl.tar.gz/sha512/32a3c124ca8041390b0e6d4ebcfe536d25c88fee28e178fb78279e52428613cb6e109ec99b3801331740985226dd40684bf20f75dd5c99c4c74335177d3a8307
-SuiteSparse.v7.6.0+0.x86_64-unknown-freebsd.tar.gz/md5/724ee53946f949618be56ded74c15d29
-SuiteSparse.v7.6.0+0.x86_64-unknown-freebsd.tar.gz/sha512/2fc9b2fdcabfe8e98a14f74ad1f94689cbde704e9f5635f6e5677af9090920627e46e903790231edb4de998eea3a732ad88b0c3ebc2ae5a158433b487e739340
-SuiteSparse.v7.6.0+0.x86_64-w64-mingw32.tar.gz/md5/57c4bd66dfd1bdf824017150d798f8aa
-SuiteSparse.v7.6.0+0.x86_64-w64-mingw32.tar.gz/sha512/26d9c15de1b5b68b9f01775a758f322b5a9f8600c66fa713b5de1009a90cec8e6db755305c19485406f9a9e88d752871b70fff5e336d09fca9bdf61bcb4de3ba
+SuiteSparse-7.6.1.tar.gz/md5/566fa42263477c0b4e2f9abc2e01173e
+SuiteSparse-7.6.1.tar.gz/sha512/cef8a8aa0624876dd8882eb3960dd22682eaae6c255e54d3c696d4b5760d04463a445560f956115eae06a04d9ae6b9227755ce0b375f8e55e979409b23fffd54
+SuiteSparse.v7.6.1+0.aarch64-apple-darwin.tar.gz/md5/ece087d641de1f41ba2deec6471c9b1c
+SuiteSparse.v7.6.1+0.aarch64-apple-darwin.tar.gz/sha512/31402f1906f7af17deac749930a997aac0b90436cdd80b30ff2c5b8148feaf5077fff8480f33cd7aa4fac41f098535f256de8e26599b39d88676f505518e8e3a
+SuiteSparse.v7.6.1+0.aarch64-linux-gnu.tar.gz/md5/94a615dac1459aa8f19e46e2954ae761
+SuiteSparse.v7.6.1+0.aarch64-linux-gnu.tar.gz/sha512/b02cc3b9c24af3e90ab9711b980c60faaa7fc7e01b7c076f3b2fb03189b87143ea91c29f8a816cf71370a6c42f58a794c7774da793157ba99dfbc0c3deb1d59f
+SuiteSparse.v7.6.1+0.aarch64-linux-musl.tar.gz/md5/35e2ce86179b26d3129a2c63a81fb033
+SuiteSparse.v7.6.1+0.aarch64-linux-musl.tar.gz/sha512/5d512986178b8140eb99be1e319ec787396d8806be158181fe97d99b788f895b596dcc0f70457d46167c9391dbfeb484411ddbca40f13b943c6c29956382ca45
+SuiteSparse.v7.6.1+0.armv6l-linux-gnueabihf.tar.gz/md5/3616cbe1e8badbbb2c3671d092821d2c
+SuiteSparse.v7.6.1+0.armv6l-linux-gnueabihf.tar.gz/sha512/aab2e86f2d25d305ae79595e02db4e04365e96d374915b390970f58272faa34eee0ce374ab3dc8fab7e6a89e1375e7ec1658bb5d485e3ab7ae3b7d3f03ae7461
+SuiteSparse.v7.6.1+0.armv6l-linux-musleabihf.tar.gz/md5/4db750ef1f63484a0e78e7e36bde5835
+SuiteSparse.v7.6.1+0.armv6l-linux-musleabihf.tar.gz/sha512/3ff7d45d98e5f99062d8ebead1ec26c72025d2623129da1999ea1e7efcae5cb4c5bc66bcb2e2fc7f7f31dc8b5824f4b8f6ea61147564056bb8daa45a5d53dee6
+SuiteSparse.v7.6.1+0.armv7l-linux-gnueabihf.tar.gz/md5/170612f9ebd79ea013bf13a884e7ef9f
+SuiteSparse.v7.6.1+0.armv7l-linux-gnueabihf.tar.gz/sha512/d53e9984f64b2dcbe76ea1b7d24703dbead785b987782b73881869b07cf3513149b576d2c537684cda48ad7c4447048c885413a2861e878c2026cb83875aa5d7
+SuiteSparse.v7.6.1+0.armv7l-linux-musleabihf.tar.gz/md5/d9f67600dcd77960a858a1e243009392
+SuiteSparse.v7.6.1+0.armv7l-linux-musleabihf.tar.gz/sha512/1222c095f4b1368d22e8b0bf00753714afc60062f9550414f59f71d26cf29b414ed91bb6ed8d2aa5152ea875280f620db7d6e7aaa459088c9bdd95f3c5afa237
+SuiteSparse.v7.6.1+0.i686-linux-gnu.tar.gz/md5/f0c81cd95e8b06541541f676c020bb01
+SuiteSparse.v7.6.1+0.i686-linux-gnu.tar.gz/sha512/da0dff1b38ae2d20cac3af6d43a3f2b9dfb6c7ee0d120ff2500cffafe9b851a2ccfeb8857a831a306cc8ae61108cdd2090cb66abcd8071a3503e514176f4b848
+SuiteSparse.v7.6.1+0.i686-linux-musl.tar.gz/md5/d9584256d6c8fe5631727c6947233dab
+SuiteSparse.v7.6.1+0.i686-linux-musl.tar.gz/sha512/a3e58f21dcae3e4eaa59cbc5846f4036be891753b1152423b5530ca2aba655c6283f982fe9d68e6304d6ef4629437e02f9850b142c8b7b62094a94125438cd80
+SuiteSparse.v7.6.1+0.i686-w64-mingw32.tar.gz/md5/92d639cf624c22db2f64f3cce94f1a9e
+SuiteSparse.v7.6.1+0.i686-w64-mingw32.tar.gz/sha512/e26188190fe2fa95535df220f8cc6da0f54dbcbffb8c3d5fe9cf9dac9865825a483ba2e6ed7a603f49b94ca3b4973adbabbf2b9d96f4837b5e27a716d98ed9bf
+SuiteSparse.v7.6.1+0.powerpc64le-linux-gnu.tar.gz/md5/8fb15955fb750dd38b18615855afd2f3
+SuiteSparse.v7.6.1+0.powerpc64le-linux-gnu.tar.gz/sha512/369e29a19f087982e74f083bc550b60e22705571ac29f0b92565c68c31068d32ee037c4af3114b1856558a4d35e338d575e2b8a382a14afbf8d37c5d8fa78117
+SuiteSparse.v7.6.1+0.x86_64-apple-darwin.tar.gz/md5/a52d9799e0c6a7fa704b4ef684f1151e
+SuiteSparse.v7.6.1+0.x86_64-apple-darwin.tar.gz/sha512/89ce162803afdd2626a202eb6c83fb2ec79c606d46343ecaf4e15cb5b3c191a5303cc5571384433f8e70b3c548de2d274d660acaa144f9357fd890172fb3f08d
+SuiteSparse.v7.6.1+0.x86_64-linux-gnu.tar.gz/md5/fb03e7f53715f17c07853151ccccc869
+SuiteSparse.v7.6.1+0.x86_64-linux-gnu.tar.gz/sha512/43490679d3c748850a9d052f92ef7ed7a002c18c014acc9c82e605576ae088c810a01bf05e7f0934dea9890a3cf6dcb45d76b1b2fc1249fc7f36d8b989a7f044
+SuiteSparse.v7.6.1+0.x86_64-linux-musl.tar.gz/md5/ee56d6cbf18b6e1da363d0ff3bdfd6a8
+SuiteSparse.v7.6.1+0.x86_64-linux-musl.tar.gz/sha512/31c33d29ad5cd153b37afed6560ba2903a77293ddb536f31effd217ec5953c1adc3217d1eb65a6bad78013e1da9fdb713c3d9537daae836cc560e648787a53ef
+SuiteSparse.v7.6.1+0.x86_64-unknown-freebsd.tar.gz/md5/78d819e5712b2ac9d254fdeb9e72e733
+SuiteSparse.v7.6.1+0.x86_64-unknown-freebsd.tar.gz/sha512/5effdb7f1808d82ed73b1ad380e82016c46965146098c503c90fef3834b919d50b7419e6d9b856f462786d4314b6e34194612fbbd83e4b76d04e5f1a19b7f774
+SuiteSparse.v7.6.1+0.x86_64-w64-mingw32.tar.gz/md5/72876b211640159db2a0e149ca9e4bae
+SuiteSparse.v7.6.1+0.x86_64-w64-mingw32.tar.gz/sha512/be80559f2fd19e1c0f8305e03dc7256202110e4e0c91757fc911e8c15e5e0706210d5323cd2c4fe759e35dc27d9469f40e5a49f0f562ca6fec03adad068962af
diff --git a/deps/libsuitesparse.version b/deps/libsuitesparse.version
index 2602a449e3a4e..98e27d9125700 100644
--- a/deps/libsuitesparse.version
+++ b/deps/libsuitesparse.version
@@ -4,5 +4,5 @@
 LIBSUITESPARSE_JLL_NAME := SuiteSparse
 
 ## source build
-LIBSUITESPARSE_VER := 7.6.0
-LIBSUITESPARSE_SHA1=1a4d4fb0c399b261f4ed11aa980c6bab754aefa6
+LIBSUITESPARSE_VER := 7.6.1
+LIBSUITESPARSE_SHA1=d4dad6c1d0b5cb3e7c5d7d01ef55653713567662
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index a715cf141481b..d95447c0a2580 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -243,7 +243,7 @@ version = "1.11.0"
 [[deps.SuiteSparse_jll]]
 deps = ["Artifacts", "Libdl", "libblastrampoline_jll"]
 uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
-version = "7.6.0+0"
+version = "7.6.1+0"
 
 [[deps.TOML]]
 deps = ["Dates"]
diff --git a/stdlib/SuiteSparse_jll/Project.toml b/stdlib/SuiteSparse_jll/Project.toml
index 24d2e42dbaea9..ee284bc3220f7 100644
--- a/stdlib/SuiteSparse_jll/Project.toml
+++ b/stdlib/SuiteSparse_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "SuiteSparse_jll"
 uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
-version = "7.6.0+0"
+version = "7.6.1+0"
 
 [deps]
 libblastrampoline_jll = "8e850b90-86db-534c-a0d3-1478176c7d93"

From f413b016c5486034ce1f83631129d6d7d2f01445 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Wed, 27 Mar 2024 08:18:58 -0500
Subject: [PATCH 1183/1315] Remove duplicate small integer union constants
 (#53866)

---
 base/reduce.jl    | 32 ++++++++++++--------------------
 test/reducedim.jl |  4 ++--
 2 files changed, 14 insertions(+), 22 deletions(-)

diff --git a/base/reduce.jl b/base/reduce.jl
index 6a0d46c61fcd9..d73aeeeee46ec 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -4,14 +4,6 @@
 
 ###### Generic (map)reduce functions ######
 
-if Int === Int32
-    const SmallSigned = Union{Int8,Int16}
-    const SmallUnsigned = Union{UInt8,UInt16}
-else
-    const SmallSigned = Union{Int8,Int16,Int32}
-    const SmallUnsigned = Union{UInt8,UInt16,UInt32}
-end
-
 abstract type AbstractBroadcasted end
 const AbstractArrayOrBroadcasted = Union{AbstractArray, AbstractBroadcasted}
 
@@ -22,8 +14,8 @@ The reduction operator used in `sum`. The main difference from [`+`](@ref) is th
 integers are promoted to `Int`/`UInt`.
 """
 add_sum(x, y) = x + y
-add_sum(x::SmallSigned, y::SmallSigned) = Int(x) + Int(y)
-add_sum(x::SmallUnsigned, y::SmallUnsigned) = UInt(x) + UInt(y)
+add_sum(x::BitSignedSmall, y::BitSignedSmall) = Int(x) + Int(y)
+add_sum(x::BitUnsignedSmall, y::BitUnsignedSmall) = UInt(x) + UInt(y)
 add_sum(x::Real, y::Real)::Real = x + y
 
 """
@@ -33,8 +25,8 @@ The reduction operator used in `prod`. The main difference from [`*`](@ref) is t
 integers are promoted to `Int`/`UInt`.
 """
 mul_prod(x, y) = x * y
-mul_prod(x::SmallSigned, y::SmallSigned) = Int(x) * Int(y)
-mul_prod(x::SmallUnsigned, y::SmallUnsigned) = UInt(x) * UInt(y)
+mul_prod(x::BitSignedSmall, y::BitSignedSmall) = Int(x) * Int(y)
+mul_prod(x::BitUnsignedSmall, y::BitUnsignedSmall) = UInt(x) * UInt(y)
 mul_prod(x::Real, y::Real)::Real = x * y
 
 ## foldl && mapfoldl
@@ -348,11 +340,11 @@ reduce_empty(::typeof(&), ::Type{Bool}) = true
 reduce_empty(::typeof(|), ::Type{Bool}) = false
 
 reduce_empty(::typeof(add_sum), ::Type{T}) where {T} = reduce_empty(+, T)
-reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallSigned}  = zero(Int)
-reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallUnsigned} = zero(UInt)
+reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:BitSignedSmall}  = zero(Int)
+reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:BitUnsignedSmall} = zero(UInt)
 reduce_empty(::typeof(mul_prod), ::Type{T}) where {T} = reduce_empty(*, T)
-reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:SmallSigned}  = one(Int)
-reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:SmallUnsigned} = one(UInt)
+reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:BitSignedSmall}  = one(Int)
+reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:BitUnsignedSmall} = one(UInt)
 
 reduce_empty(op::BottomRF, ::Type{T}) where {T} = reduce_empty(op.rf, T)
 reduce_empty(op::MappingRF, ::Type{T}) where {T} = mapreduce_empty(op.f, op.rf, T)
@@ -402,11 +394,11 @@ reduce_first(::typeof(+), x::Bool) = Int(x)
 reduce_first(::typeof(*), x::AbstractChar) = string(x)
 
 reduce_first(::typeof(add_sum), x) = reduce_first(+, x)
-reduce_first(::typeof(add_sum), x::SmallSigned)   = Int(x)
-reduce_first(::typeof(add_sum), x::SmallUnsigned) = UInt(x)
+reduce_first(::typeof(add_sum), x::BitSignedSmall)   = Int(x)
+reduce_first(::typeof(add_sum), x::BitUnsignedSmall) = UInt(x)
 reduce_first(::typeof(mul_prod), x) = reduce_first(*, x)
-reduce_first(::typeof(mul_prod), x::SmallSigned)   = Int(x)
-reduce_first(::typeof(mul_prod), x::SmallUnsigned) = UInt(x)
+reduce_first(::typeof(mul_prod), x::BitSignedSmall)   = Int(x)
+reduce_first(::typeof(mul_prod), x::BitUnsignedSmall) = UInt(x)
 
 """
     Base.mapreduce_first(f, op, x)
diff --git a/test/reducedim.jl b/test/reducedim.jl
index 77ed94664539f..8f629fa83f28d 100644
--- a/test/reducedim.jl
+++ b/test/reducedim.jl
@@ -576,8 +576,8 @@ end
 @testset "type of sum(::Array{$T}" for T in [UInt8, Int8, Int32, Int64, BigInt]
     result = sum(T[1 2 3; 4 5 6; 7 8 9], dims=2)
     @test result == hcat([6, 15, 24])
-    @test eltype(result) === (T <: Base.SmallSigned ? Int :
-                              T <: Base.SmallUnsigned ? UInt :
+    @test eltype(result) === (T <: Base.BitSignedSmall ? Int :
+                              T <: Base.BitUnsignedSmall ? UInt :
                               T)
 end
 

From 7a62dffe784a4ced9372d987e9b9b4a990a4d5d1 Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Wed, 27 Mar 2024 09:38:29 -0400
Subject: [PATCH 1184/1315] Harmonize and add docs for `--math-mode` (#53818)

The behavior was changed and the CLI doc was removed
in #41638, though we current still allow users to
selectively use the `@fastmath` macro.
This adds back the CLI docs and makes a minor
clarification about behavior.

Co-authored-by: Matt Bauman <mbauman@juliahub.com>
---
 doc/man/julia.1                          | 4 ++--
 doc/src/manual/command-line-interface.md | 2 +-
 src/jloptions.c                          | 3 ++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/doc/man/julia.1 b/doc/man/julia.1
index a7d16abe3f85c..2d7f41b2217bc 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -200,8 +200,8 @@ Control whether inlining is permitted, including overriding @inline declarations
 Emit bounds checks always, never, or respect @inbounds declarations
 
 .TP
---math-mode={ieee|user}
-Disallow or enable unsafe floating point optimizations (overrides @fastmath declaration)
+--math-mode={ieee|user*}
+Always follow `ieee` floating point semantics or respect `@fastmath` declarations
 
 .TP
 --code-coverage[={none*|user|all}]
diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index 448964bf1ef8a..1bb9507756aec 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -195,7 +195,7 @@ The following is a complete list of command-line switches available when launchi
 |`-g`, `--debug-info={0,1*,2}`          |Set the level of debug info generation (level is 2 if `-g` is used without a level) ($)|
 |`--inline={yes\|no}`                   |Control whether inlining is permitted, including overriding `@inline` declarations|
 |`--check-bounds={yes\|no\|auto*}`      |Emit bounds checks always, never, or respect `@inbounds` declarations ($)|
-|`--math-mode={ieee,fast}`              |Disallow or enable unsafe floating point optimizations (overrides `@fastmath` declaration)|
+|`--math-mode={ieee\|user*}`            |Always follow `ieee` floating point semantics or respect `@fastmath` declarations|
 |`--code-coverage[={none*\|user\|all}]` |Count executions of source lines (omitting setting is equivalent to `user`)|
 |`--code-coverage=@<path>`              |Count executions but only in files that fall under the given file path/directory. The `@` prefix is required to select this option. A `@` with no path will track the current directory.|
 |`--code-coverage=tracefile.info`       |Append coverage information to the LCOV tracefile (filename supports format tokens).|
diff --git a/src/jloptions.c b/src/jloptions.c
index 085e5f365ac46..9020404e70781 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -177,6 +177,7 @@ static const char opts[]  =
 #ifdef USE_POLLY
     " --polly={yes*|no}          Enable or disable the polyhedral optimizer Polly (overrides @polly declaration)\n"
 #endif
+    " --math-mode={ieee|user*}   Always follow `ieee` floating point semantics or respect `@fastmath` declarations\n\n"
 
     // instrumentation options
     " --code-coverage[={none*|user|all}]\n"
@@ -782,7 +783,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
             else if (!strcmp(optarg,"user"))
                 jl_options.fast_math = JL_OPTIONS_FAST_MATH_DEFAULT;
             else
-                jl_errorf("julia: invalid argument to --math-mode (%s)", optarg);
+                jl_errorf("julia: invalid argument to --math-mode={ieee|user} (%s)", optarg);
             break;
         case opt_worker:
             jl_options.worker = 1;

From a3616a8ff21aaee31b0b4353f3cdcb4e4a119e9e Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 27 Mar 2024 10:02:22 -0400
Subject: [PATCH 1185/1315] Print more info when backtrace test fails (#53874)

This test fails intermittently on win32. Let's try to print some more
info in that case to see if we can find out anything.
---
 test/backtrace.jl | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/test/backtrace.jl b/test/backtrace.jl
index aa10720316a5d..68873678df57b 100644
--- a/test/backtrace.jl
+++ b/test/backtrace.jl
@@ -262,10 +262,14 @@ let code = """
                   if ip isa Base.InterpreterIP && ip.code isa Core.MethodInstance]
     num_fs = sum(meth_names .== :f29695)
     num_gs = sum(meth_names .== :g29695)
-    print(num_fs, ' ', num_gs)
+    if num_fs != 1000 || num_gs != 1000
+        Base.show_backtrace(stderr, bt)
+        error("Expected 1000 frames each, got \$num_fs, \$num_fs")
+    end
+    exit()
     """
 
-    @test read(`$(Base.julia_cmd()) --startup-file=no --compile=min -e $code`, String) == "1000 1000"
+    @test success(pipeline(`$(Base.julia_cmd()) --startup-file=no --compile=min -e $code`; stderr))
 end
 
 # Test that modules make it into InterpreterIP for top-level code

From 0e2409aff821288ac078b1116fe9ae56ef93b7a5 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 27 Mar 2024 10:29:46 -0400
Subject: [PATCH 1186/1315] inference: Fix handling of :throw_undef_if_not
 (#53875)

This stmt type doesn't usually get introduced until IR conversion, but
we do allow it in inference (to allow it to be emitted by packages like
Diffractor). However, we didn't have a test for it, so the code path
grew a bug. Fix that and also allow this as a frontend form, so it can
be tested without resorting to generated functions.
---
 base/compiler/abstractinterpretation.jl | 2 +-
 src/julia-syntax.scm                    | 2 +-
 test/compiler/inference.jl              | 7 +++++++
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index ba8f0b6709f8f..836147d4e502b 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2625,7 +2625,7 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
             effects = EFFECTS_UNKNOWN
         end
     elseif ehead === :throw_undef_if_not
-        condt = argextype(stmt.args[2], ir)
+        condt = abstract_eval_value(interp, e.args[2], vtypes, sv)
         condval = maybe_extract_const_bool(condt)
         t = Nothing
         exct = UndefVarError
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index f1ae6c90bda6a..899476afc093a 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -4839,7 +4839,7 @@ f(x) = yt(x)
                          (set! global-const-error current-loc))
                      (emit e))))
             ((atomic) (error "misplaced atomic declaration"))
-            ((isdefined) (if tail (emit-return tail e) e))
+            ((isdefined throw_undef_if_not) (if tail (emit-return tail e) e))
             ((boundscheck) (if tail (emit-return tail e) e))
 
             ((method)
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 30c5c306faa94..07797d8b9f057 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5640,6 +5640,13 @@ end
 @test issue53590(false, false) == Float64
 @test issue53590(false, true) == Real
 
+# Expr(:throw_undef_if_not) handling
+@eval function has_tuin()
+    $(Expr(:throw_undef_if_not, :x, false))
+end
+@test Core.Compiler.return_type(has_tuin, Tuple{}) === Union{}
+@test_throws UndefVarError has_tuin()
+
 # issue #53585
 let t = ntuple(i -> i % 8 == 1 ? Int64 : Float64, 4000)
     @test only(Base.return_types(Base.promote_typeof, t)) == Type{Float64}

From bb3b09de50720d4b47c34fd53638e292c50c695e Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Wed, 27 Mar 2024 11:20:10 -0400
Subject: [PATCH 1187/1315] add invokelatest to on_done callback in bracketed
 paste (#53696)

fixes #52120
---
 stdlib/REPL/src/REPL.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index 789def3d317bf..f75e91da67be2 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -1379,7 +1379,7 @@ function setup_interface(
                     # execute the statement
                     terminal = LineEdit.terminal(s) # This is slightly ugly but ok for now
                     raw!(terminal, false) && disable_bracketed_paste(terminal)
-                    LineEdit.mode(s).on_done(s, LineEdit.buffer(s), true)
+                    @invokelatest LineEdit.mode(s).on_done(s, LineEdit.buffer(s), true)
                     raw!(terminal, true) && enable_bracketed_paste(terminal)
                     LineEdit.push_undo(s) # when the last line is incomplete
                 end

From f4866b7617a3d214e6e4437e13fd8b389c64b078 Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Wed, 27 Mar 2024 16:40:54 +0100
Subject: [PATCH 1188/1315] Update p7zip to 17.05 (#53863)

Following https://github.com/JuliaPackaging/Yggdrasil/pull/8352
---
 deps/checksums/p7zip          | 68 +++++++++++++++++------------------
 deps/p7zip.version            |  2 +-
 stdlib/Manifest.toml          |  2 +-
 stdlib/p7zip_jll/Project.toml |  2 +-
 4 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/deps/checksums/p7zip b/deps/checksums/p7zip
index 3a3986977e3cf..272f1d768161f 100644
--- a/deps/checksums/p7zip
+++ b/deps/checksums/p7zip
@@ -1,34 +1,34 @@
-p7zip-17.04.tar.gz/md5/00acfd6be87848231722d2d53f89e4a5
-p7zip-17.04.tar.gz/sha512/ad176db5b657b1c39584f6792c47978d94f2f1ccb1cf5bdb0f52ab31a7356b3822f4a922152c4253f4aa7e79166ba052b6592530b7a38f548cd555fe9c008be3
-p7zip.v17.4.0+2.aarch64-apple-darwin.tar.gz/md5/b418adbae6512a13e04407c120ba78e0
-p7zip.v17.4.0+2.aarch64-apple-darwin.tar.gz/sha512/818f7afb0d3ffbff8079f5f4b8e9745a847148ac9cb5a261b6ca2f2f3a1dd722fa93f798645129bc9bc4a48f756bf2e55605791abb394a32635dfaef31f21e70
-p7zip.v17.4.0+2.aarch64-linux-gnu.tar.gz/md5/3f976d6514e6327a9aee4a3f21a25a64
-p7zip.v17.4.0+2.aarch64-linux-gnu.tar.gz/sha512/a4dd8be97c53b864e81aae40e248759f97249fbd6d8c5b91f0ac115a84126cbfc4825ffa3876f5e8b66652b014a78ba04e3ffc1ba1d9c96786b914b1279682c0
-p7zip.v17.4.0+2.aarch64-linux-musl.tar.gz/md5/b31699d7ea671c689fa9194913fbe7ee
-p7zip.v17.4.0+2.aarch64-linux-musl.tar.gz/sha512/5c8d95df66055ab8027b047b23534743ac929befd37dc8a8e591deece22006209f94524f7951de580a5ded9530ead2ce7ec3370c482865554830b53d09f41bf1
-p7zip.v17.4.0+2.armv6l-linux-gnueabihf.tar.gz/md5/fbe2ebeeaa6e5b33dcb71662fb7040f1
-p7zip.v17.4.0+2.armv6l-linux-gnueabihf.tar.gz/sha512/6ca1d7eb1d3f6a7c4dc9860ac3d5a835abce92cddcda015a93086ecde44ed1b3d9f83a3c1e1eddc510af429ec269716dde6bc5fae4aa6bbbc3dcfc9a51326786
-p7zip.v17.4.0+2.armv6l-linux-musleabihf.tar.gz/md5/dae4b1e6060bf4431d3ead53e6b3e167
-p7zip.v17.4.0+2.armv6l-linux-musleabihf.tar.gz/sha512/856c2283c63728d8c542ce5a3d58e38c985f190774c407fc421dd30f05e0ae3467e2844cb7d535aa8a6b8fb24b21b29af75b736fbd9af67c24340609ad6b5841
-p7zip.v17.4.0+2.armv7l-linux-gnueabihf.tar.gz/md5/42b6b9b19158303c4399d651ee5b14cf
-p7zip.v17.4.0+2.armv7l-linux-gnueabihf.tar.gz/sha512/4f8792639db8599af026f592496a8c594c0fd6a62dc949965add55b1b85a95d4edc2f99960cf5b21e7beeb8e1bca1d9c1a1a34600103df04dc20d0509410c486
-p7zip.v17.4.0+2.armv7l-linux-musleabihf.tar.gz/md5/e34f5585a50c0cfce29c79e9ece60cf4
-p7zip.v17.4.0+2.armv7l-linux-musleabihf.tar.gz/sha512/87f72568f5a877008d3a8a032a85f69c29d3af4293d7b42d70419bb4c9ca7e99dc13c6b22621ca83886d07f765118451ee9f2a3aee63979d8070910887bf7cdd
-p7zip.v17.4.0+2.i686-linux-gnu.tar.gz/md5/d917247133b1c62663334b6a908e30e9
-p7zip.v17.4.0+2.i686-linux-gnu.tar.gz/sha512/4839bec129b7fbd68c61d35fd3b3af9863c757d9fec0220926d45f1f58174d88d0bbb4a472d259d1d77775b906e9c58ba707fc20e2a4a060ca9030722609182d
-p7zip.v17.4.0+2.i686-linux-musl.tar.gz/md5/951614fc7597de8c12e0109cbd81bfa9
-p7zip.v17.4.0+2.i686-linux-musl.tar.gz/sha512/f0420ddd6df82d2b3e1ece9cc5cf537cb0803d291d274a495bb9a575bb253a4241cdae38a88e43ddafaab7f6911b310a30c1b874b0a0a9bc447f8c42c5a24652
-p7zip.v17.4.0+2.i686-w64-mingw32.tar.gz/md5/cc81daf0e40990c48db178cb53a95d08
-p7zip.v17.4.0+2.i686-w64-mingw32.tar.gz/sha512/ae5bcbcf32dad20db95319c3c2f874fdbb0cd41054d6c192f2ab106e0aece1b4b0b591055b37c2c909b07b303204a75dec5c4b3c224243c2041da811f99cd7e5
-p7zip.v17.4.0+2.powerpc64le-linux-gnu.tar.gz/md5/e97d74ac4dacfaa215c3119e055a2df0
-p7zip.v17.4.0+2.powerpc64le-linux-gnu.tar.gz/sha512/8b0596ebd84fa9947e8f15f63c426339980e08c81eb4c1474b4a66af6329f0a2fe1bd31eef964d147bf9cf0213e85bdc143fab1a4f1dbfa09da5ebd9e73a3d8d
-p7zip.v17.4.0+2.x86_64-apple-darwin.tar.gz/md5/4d9a26dbfc0a02a812c8f7de20ea5440
-p7zip.v17.4.0+2.x86_64-apple-darwin.tar.gz/sha512/3cba51ba9742b616afec13a14e8e3bd3c73c835256af8f6a49d4abf32f5ddf3f86ac8ae08ffd9bc331caa8a711dd1b63f4cd082443a7863e3d512f6ca2152bcd
-p7zip.v17.4.0+2.x86_64-linux-gnu.tar.gz/md5/37b7570712ecb8677059f4280a346201
-p7zip.v17.4.0+2.x86_64-linux-gnu.tar.gz/sha512/9445add6a475bdfc2924dc52c07917c2746b07a41a2dbfdab8ad4b4e5b87b0192c13f4da5da64e5d3544bbf9c79fda3c633664eecb372e8475031789770c41ee
-p7zip.v17.4.0+2.x86_64-linux-musl.tar.gz/md5/04d6ae950d05c81c6b165721de2ba7e7
-p7zip.v17.4.0+2.x86_64-linux-musl.tar.gz/sha512/524d8ed80a1af903b572d5e32710b384702175cacc83ce2305d7f7a35d45aae7d08e2afc14a9e40c934ba4eb578787afa9bece4f820e96e4b624869cb2bcec26
-p7zip.v17.4.0+2.x86_64-unknown-freebsd.tar.gz/md5/e2a3361e91258e39db541c9dec5a73fe
-p7zip.v17.4.0+2.x86_64-unknown-freebsd.tar.gz/sha512/ecc1db9a1823ebdac290548f6e001688b5d111caede4cbfab4e2ef492dbb31844690e9b69360ed9c6ebb2affded7f352d57c0e5cfe67be951876d1fc5e87d92d
-p7zip.v17.4.0+2.x86_64-w64-mingw32.tar.gz/md5/2b5f77bb31526c469e0fd48399d0cf9a
-p7zip.v17.4.0+2.x86_64-w64-mingw32.tar.gz/sha512/a3a17af4db98b82b71c8d4d09e5315dc4fa77b38cc19f0593654b63744bc7489383d40032e48c2141d6b55e330d1538c527819378a2575a245de436bc6daf532
+p7zip-17.05.tar.gz/md5/de921a08f37242a8eed8e4a758fbcb58
+p7zip-17.05.tar.gz/sha512/97a7cfd15287998eb049c320548477be496c4ddf6b45c833c42adca4ab88719b07a442ae2e71cf2dc3b30a0777a3acab0a1a30f01fd85bacffa3fa9bd22c3f7d
+p7zip.v17.5.0+0.aarch64-apple-darwin.tar.gz/md5/2a254e251901b3d1ddfd7aff23a6e5eb
+p7zip.v17.5.0+0.aarch64-apple-darwin.tar.gz/sha512/8efb9a2c9bcab388e523adba3dc0b876e8ae34e2440c3eee01fd780eb87c8619c7a7bbdc46d703ccefff6aa6ad64c4e4b45b723136ab1f6fd6de4f52e75ebbbf
+p7zip.v17.5.0+0.aarch64-linux-gnu.tar.gz/md5/bb1f3773fd409dbb91a10f7d9d2e99b5
+p7zip.v17.5.0+0.aarch64-linux-gnu.tar.gz/sha512/e95ccc342be644570d218d25403b91a7db9ee983fbf8cce3deff453355d68d426f9301eaac865a98691025b596b8cd77ebebf6184c0eaf8b2f294bc6763b9a4b
+p7zip.v17.5.0+0.aarch64-linux-musl.tar.gz/md5/3fac518a6a70412294d71ca510958cf2
+p7zip.v17.5.0+0.aarch64-linux-musl.tar.gz/sha512/fc127790739bf8a8b918b2e83753d86f5e79ee8706bde4cc79d74d9f7d846aae99a109da4b2b3cc92ccedc1eef4d52a555a65a95f588e173e0fecc11f2ca21e6
+p7zip.v17.5.0+0.armv6l-linux-gnueabihf.tar.gz/md5/355410848192de3b02d12fd663867f4b
+p7zip.v17.5.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/8f103b41e755d157d70dacca89a0ef4610bea109686b4005e8edd5f79ed2e6419c00c2625d0ab90e6e33fa389e670490d8de263c0bdae952cc34cbbf440e275f
+p7zip.v17.5.0+0.armv6l-linux-musleabihf.tar.gz/md5/34363b227306fce34a728af54b71064f
+p7zip.v17.5.0+0.armv6l-linux-musleabihf.tar.gz/sha512/8dd7b37ce6223c9fedcaa999eb806eb6dec8c4a3133d3c07e2456cb8543b8e4f5b881c1bff2d2e25f19b1312b18673e9013aeff87d6a274eec6c451b1ba0d6b9
+p7zip.v17.5.0+0.armv7l-linux-gnueabihf.tar.gz/md5/dbb1fc0cf3bea674442ff8cc932a94cd
+p7zip.v17.5.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/c4d71d905fa420391417786ed206a0c334475dd0df8baa1fc3f6560ce548db11805003d0d0b35bb622fe818c761f2b0abe0796d1cbfce2a922da69e697f056a2
+p7zip.v17.5.0+0.armv7l-linux-musleabihf.tar.gz/md5/d188b5dd453faedb616ba9c48fdeab6b
+p7zip.v17.5.0+0.armv7l-linux-musleabihf.tar.gz/sha512/ea30a775370502ca9e271b87cbda528d0c51d63ce0df41883d4dbc1527a32f251d797f3692fcf9b883b5fbaaad80515b971a8f8fe09ba102978b19a0ecb58528
+p7zip.v17.5.0+0.i686-linux-gnu.tar.gz/md5/dc02bdde045a0b6b22cf14d6960e63ed
+p7zip.v17.5.0+0.i686-linux-gnu.tar.gz/sha512/d2d0dd14a5fc1163fea2276e0925bfa8d075d5dba1d8018e4e3160977d3b09642b2e521d8e57d049abaf0e2ea391a846f0b0136b3c59e8b476c8c52ac5210447
+p7zip.v17.5.0+0.i686-linux-musl.tar.gz/md5/0b8658147938a8ec109ee2b3b0a0665f
+p7zip.v17.5.0+0.i686-linux-musl.tar.gz/sha512/411b2950f5928c537b87ba0651c09c08e57afed765db9fee89eda8b12939ef0da94c8ba38c0a24ba46b4513a0e4cca798eb09f2b20a011099ed3cf14455dd19e
+p7zip.v17.5.0+0.i686-w64-mingw32.tar.gz/md5/98bdd8767c77a35f71303ff490a3d363
+p7zip.v17.5.0+0.i686-w64-mingw32.tar.gz/sha512/14f08071af74297df8bfe1d9f7efa3c0212e62ace573848f17b729e4c36dc3861110f3c5cc9315364c318e5b040736443a24492e86d76161993653a309996eb3
+p7zip.v17.5.0+0.powerpc64le-linux-gnu.tar.gz/md5/b18c917b9852898a9b9d6d24bcc6863e
+p7zip.v17.5.0+0.powerpc64le-linux-gnu.tar.gz/sha512/0148dc8a0bc9c95212d7f8e2f92ee24e968eb7290fe72c7ae02e286bf5c05dd6b1f10b32350a7ff37777ed5a8cc21f3303f464620f3394c7a4690ae98bf77299
+p7zip.v17.5.0+0.x86_64-apple-darwin.tar.gz/md5/da31752a2556644d39e48649bb0111de
+p7zip.v17.5.0+0.x86_64-apple-darwin.tar.gz/sha512/0695ad111263d2fadfdf9a46ce7ee80def0bf60db7d1c2585ed2af6fc945fb169311a9f1ffc6f95fb43b0b03694d2d1be9136d3d78ba2ef2b19228987883a385
+p7zip.v17.5.0+0.x86_64-linux-gnu.tar.gz/md5/2fb55d86e4eaccb0488bd637d088b996
+p7zip.v17.5.0+0.x86_64-linux-gnu.tar.gz/sha512/38ac355157d59c09f308fc29964d0e9c1466c9633efd8d3c6ff3c738abce2af45ebc6b92a29f56d5e7baa4871f9f39b14ecfcbedd4e2f4ca7c0fe6627c6b13e7
+p7zip.v17.5.0+0.x86_64-linux-musl.tar.gz/md5/f0bd567a851d2dd9d306552ffafbca3a
+p7zip.v17.5.0+0.x86_64-linux-musl.tar.gz/sha512/e60047a6e7e3496cb6658f87c8c88676f399cd9f3d0d7daa880b6be09cd5525f7f22776896f1375722b47555514ff8c018f02ce800ec3fd0ed922e16e8a6d657
+p7zip.v17.5.0+0.x86_64-unknown-freebsd.tar.gz/md5/d37bd26e39a3ec84f262636f70624341
+p7zip.v17.5.0+0.x86_64-unknown-freebsd.tar.gz/sha512/0604a880c19f9d72d5828edd75be641625c29f230b3a5e7d70ec3812c014c96b76ee7b45e0e80f49be63f109a48700e75d1e5be01b5ae7b46d42dafda9885e8c
+p7zip.v17.5.0+0.x86_64-w64-mingw32.tar.gz/md5/f02c7b2481dee880b096340a8735350f
+p7zip.v17.5.0+0.x86_64-w64-mingw32.tar.gz/sha512/08b717c1b072d1309f6af8973eb09b1a482abb7ae7d01fba79873d4310a7c11292e2e8779029f99cc60627ed0d064224bc87782e587c520f970b840b7b838052
diff --git a/deps/p7zip.version b/deps/p7zip.version
index d4a13155d9162..0fcde938eeb95 100644
--- a/deps/p7zip.version
+++ b/deps/p7zip.version
@@ -2,4 +2,4 @@
 P7ZIP_JLL_NAME := p7zip
 
 ## source build
-P7ZIP_VER := 17.04
+P7ZIP_VER := 17.05
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index d95447c0a2580..4df442c6833d1 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -297,4 +297,4 @@ version = "1.60.0+0"
 [[deps.p7zip_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
-version = "17.4.0+2"
+version = "17.5.0+0"
diff --git a/stdlib/p7zip_jll/Project.toml b/stdlib/p7zip_jll/Project.toml
index b1bd4bc9e0a1a..6bca9d1d0545b 100644
--- a/stdlib/p7zip_jll/Project.toml
+++ b/stdlib/p7zip_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "p7zip_jll"
 uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
-version = "17.4.0+2"
+version = "17.5.0+0"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From 4ee10228176c960fc3d0046390ab2ef4df7ab08a Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 27 Mar 2024 15:44:33 -0400
Subject: [PATCH 1189/1315] opaque_closure: Lookup optimized oc source inside
 code instance (#53878)

This is an alternative to #53852. I don't think it's semantically legal
to put optimized source into the :source field of a method, but it
should be fine to just look it up from the CodeInstance. That said, this
is a bit of an unusual configuration. In particular it wasn't even
reachable with the surface APIs, which assumed that inferred IR was
always supposed to be compiled.
---
 base/opaque_closure.jl | 12 ++++++------
 src/interpreter.c      | 14 +++++++++++++-
 test/opaque_closure.jl |  5 +++++
 3 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/base/opaque_closure.jl b/base/opaque_closure.jl
index 83a364646ad39..b00955e7a0ca0 100644
--- a/base/opaque_closure.jl
+++ b/base/opaque_closure.jl
@@ -59,7 +59,7 @@ end
 function Core.OpaqueClosure(ir::IRCode, @nospecialize env...;
                             isva::Bool = false,
                             slotnames::Union{Nothing,Vector{Symbol}}=nothing,
-                            do_compile::Bool = true)
+                            kwargs...)
     # NOTE: we need ir.argtypes[1] == typeof(env)
     ir = Core.Compiler.copy(ir)
     # if the user didn't specify a definition MethodInstance or filename Symbol to use for the debuginfo, set a filename now
@@ -78,11 +78,11 @@ function Core.OpaqueClosure(ir::IRCode, @nospecialize env...;
     src.slotflags = fill(zero(UInt8), nargtypes)
     src.slottypes = copy(ir.argtypes)
     src = Core.Compiler.ir_to_codeinf!(src, ir)
-    return generate_opaque_closure(sig, Union{}, rt, src, nargs, isva, env...; do_compile)
+    return generate_opaque_closure(sig, Union{}, rt, src, nargs, isva, env...; kwargs...)
 end
 
-function Core.OpaqueClosure(src::CodeInfo, @nospecialize env...; rettype, sig, nargs, isva=false)
-    return generate_opaque_closure(sig, Union{}, rettype, src, nargs, isva, env...)
+function Core.OpaqueClosure(src::CodeInfo, @nospecialize env...; rettype, sig, nargs, isva=false, kwargs...)
+    return generate_opaque_closure(sig, Union{}, rettype, src, nargs, isva, env...; kwargs...)
 end
 
 function generate_opaque_closure(@nospecialize(sig), @nospecialize(rt_lb), @nospecialize(rt_ub),
@@ -90,8 +90,8 @@ function generate_opaque_closure(@nospecialize(sig), @nospecialize(rt_lb), @nosp
                                  mod::Module=@__MODULE__,
                                  lineno::Int=0,
                                  file::Union{Nothing,Symbol}=nothing,
-                                 isinferred::Bool=true,
-                                 do_compile::Bool=true)
+                                 do_compile::Bool=true,
+                                 isinferred::Bool=true)
     return ccall(:jl_new_opaque_closure_from_code_info, Any, (Any, Any, Any, Any, Any, Cint, Any, Cint, Cint, Any, Cint, Cint),
         sig, rt_lb, rt_ub, mod, src, lineno, file, nargs, isva, env, do_compile, isinferred)
 end
diff --git a/src/interpreter.c b/src/interpreter.c
index 2fb4b91927496..c7d7fa88ea447 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -760,7 +760,19 @@ JL_DLLEXPORT const jl_callptr_t jl_fptr_interpret_call_addr = &jl_fptr_interpret
 jl_value_t *jl_interpret_opaque_closure(jl_opaque_closure_t *oc, jl_value_t **args, size_t nargs)
 {
     jl_method_t *source = oc->source;
-    jl_code_info_t *code = jl_uncompress_ir(source, NULL, (jl_value_t*)source->source);
+    jl_code_info_t *code = NULL;
+    if (source->source) {
+        code = jl_uncompress_ir(source, NULL, (jl_value_t*)source->source);
+    }
+    else {
+        // OC constructed from optimized IR. It'll have a single specialization with optimized code
+        // in it that we'll try to interpret.
+        jl_svec_t *specializations = (jl_svec_t*)jl_atomic_load_relaxed(&source->specializations);
+        assert(jl_is_method_instance(specializations));
+        jl_method_instance_t *mi = (jl_method_instance_t *)specializations;
+        jl_code_instance_t *ci = jl_atomic_load_relaxed(&mi->cache);
+        code = jl_uncompress_ir(source, ci, jl_atomic_load_relaxed(&ci->inferred));
+    }
     interpreter_state *s;
     unsigned nroots = jl_source_nslots(code) + jl_source_nssavalues(code) + 2;
     jl_task_t *ct = jl_current_task;
diff --git a/test/opaque_closure.jl b/test/opaque_closure.jl
index 8378d8ae0d3dd..cb7576ee656be 100644
--- a/test/opaque_closure.jl
+++ b/test/opaque_closure.jl
@@ -358,3 +358,8 @@ let ir = first(only(Base.code_ircode(sin, (Int,))))
     oc = Core.OpaqueClosure(ir)
     @test (Base.show_method(IOBuffer(), oc.source::Method); true)
 end
+
+let ir = first(only(Base.code_ircode(sin, (Int,))))
+    oc = Core.OpaqueClosure(ir; do_compile=false)
+    @test oc(1) == sin(1)
+end

From e07c0f1ddbfc89ad1ac4dda7246d8ed5d0d57c19 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 27 Mar 2024 23:09:07 -0400
Subject: [PATCH 1190/1315] inference: Fix correctness and ensure termination
 in the presence of PhiNodes (#53876)

There's two related, but distinct, issues here:
1. We were not using `tmerge` for merging SSA results inside loops,
which could cause infinite looping. In the absence of PhiNodes, things
usually have to go through a slot to be able to make the round trip,
which would usually put a PhiNode on the path, but it's possible there
may be other ways to smuggle things around (e.g. through exception
handling).

2. We were not properly accounting for the fact that PhiNode uses do not
need to be linearly ordered in the same BB, so we were getting the type
of the testcase here incorrect by failing to re-schedule the PhiNode.

The first of these shows up in the Diffractor test suite, the second was
found by writing the test case.
---
 base/compiler/abstractinterpretation.jl | 12 +++++++++--
 base/compiler/inferencestate.jl         |  5 +----
 test/compiler/inference.jl              | 28 +++++++++++++++++++++++++
 3 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 836147d4e502b..ce8494b1feff0 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2731,7 +2731,8 @@ function abstract_eval_phi(interp::AbstractInterpreter, phi::PhiNode, vtypes::Un
         val = phi.values[i]
         # N.B.: Phi arguments are restricted to not have effects, so we can drop
         # them here safely.
-        rt = tmerge(typeinf_lattice(interp), rt, abstract_eval_special_value(interp, val, vtypes, sv).rt)
+        thisval = abstract_eval_special_value(interp, val, vtypes, sv).rt
+        rt = tmerge(typeinf_lattice(interp), rt, thisval)
     end
     return rt
 end
@@ -2745,7 +2746,14 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
     if !isa(e, Expr)
         if isa(e, PhiNode)
             add_curr_ssaflag!(sv, IR_FLAGS_REMOVABLE)
-            return RTEffects(abstract_eval_phi(interp, e, vtypes, sv), Union{}, EFFECTS_TOTAL)
+            # Implement convergence for PhiNodes. In particular, PhiNodes need to tmerge over
+            # the incoming values from all iterations, but `abstract_eval_phi` will only tmerge
+            # over the first and last iterations. By tmerging in the current old_rt, we ensure that
+            # we will not lose an intermediate value.
+            rt = abstract_eval_phi(interp, e, vtypes, sv)
+            old_rt = sv.ssavaluetypes[sv.currpc]
+            rt = old_rt === NOT_FOUND ? rt : tmerge(typeinf_lattice(interp), old_rt, rt)
+            return RTEffects(rt, Union{}, EFFECTS_TOTAL)
         end
         (; rt, exct, effects) = abstract_eval_special_value(interp, e, vtypes, sv)
     else
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 0102f042ba2ba..38fb13495ad85 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -691,10 +691,7 @@ function record_ssa_assign!(𝕃ᵢ::AbstractLattice, ssa_id::Int, @nospecialize
         for r in frame.ssavalue_uses[ssa_id]
             if was_reached(frame, r)
                 usebb = block_for_inst(frame.cfg, r)
-                # We're guaranteed to visit the statement if it's in the current
-                # basic block, since SSA values can only ever appear after their
-                # def.
-                if usebb != frame.currbb
+                if usebb != frame.currbb || r < ssa_id
                     push!(W, usebb)
                 end
             end
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 07797d8b9f057..62c134e58c2a6 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5652,3 +5652,31 @@ let t = ntuple(i -> i % 8 == 1 ? Int64 : Float64, 4000)
     @test only(Base.return_types(Base.promote_typeof, t)) == Type{Float64}
     @test only(Base.return_types(vcat, t)) == Vector{Float64}
 end
+
+# Infinite loop in inference on SSA assignment
+const stop_infinite_loop::Base.Threads.Atomic{Bool} = Base.Threads.Atomic{Bool}(false)
+function gen_infinite_loop_ssa_generator(world::UInt, source, _)
+    ci = make_codeinfo(Any[
+        # Block 1
+        (),
+        # Block 2
+        PhiNode(Int32[1, 5], Any[SSAValue(1), SSAValue(3)]),
+        Expr(:call, tuple, SSAValue(2)),
+        Expr(:call, getindex, GlobalRef(@__MODULE__, :stop_infinite_loop)),
+        GotoIfNot(SSAValue(4), 2),
+        # Block 3
+        ReturnNode(SSAValue(2))
+    ]; slottypes=Any[Any])
+    ci.slotnames = Symbol[:var"#self#"]
+    ci
+end
+
+@eval function gen_infinite_loop_ssa()
+    $(Expr(:meta, :generated, gen_infinite_loop_ssa_generator))
+    $(Expr(:meta, :generated_only))
+    #= no body =#
+end
+
+# We want to make sure that both this returns `Tuple` and that
+# it doesn't infinite loop inside inference.
+@test Core.Compiler.return_type(gen_infinite_loop_ssa, Tuple{}) === Tuple

From 2a944fa336e4391a2f821e986675c5ac7e7a1fb6 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Thu, 28 Mar 2024 11:20:54 -0400
Subject: [PATCH 1191/1315] RNG reproducibility discussion - rm confusing ref
 to MenneTwister (#53879)

There was an odd phrase "in particular if `MersenneTwister` is used" in
the reproducibility discussion, which made it seem like the discussion
was specific to `MersenneTwister` (which we don't even use by default
anymore). I just deleted this clause.
---
 stdlib/Random/docs/src/index.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stdlib/Random/docs/src/index.md b/stdlib/Random/docs/src/index.md
index 96320ee216198..9ef86bb0d94f8 100644
--- a/stdlib/Random/docs/src/index.md
+++ b/stdlib/Random/docs/src/index.md
@@ -350,8 +350,8 @@ DocTestSetup = nothing
 
 By using an RNG parameter initialized with a given seed, you can reproduce the same pseudorandom
 number sequence when running your program multiple times. However, a minor release of Julia (e.g.
-1.3 to 1.4) *may change* the sequence of pseudorandom numbers generated from a specific seed, in
-particular if `MersenneTwister` is used. (Even if the sequence produced by a low-level function like
+1.3 to 1.4) *may change* the sequence of pseudorandom numbers generated from a specific seed.
+(Even if the sequence produced by a low-level function like
 [`rand`](@ref) does not change, the output of higher-level functions like [`randsubseq`](@ref) may
 change due to algorithm updates.) Rationale: guaranteeing that pseudorandom streams never change
 prohibits many algorithmic improvements.

From 6f51966bf76c8e6b05dd0cd6f84c01aa5bb087c4 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Thu, 28 Mar 2024 11:00:19 -0500
Subject: [PATCH 1192/1315] Improve error message when source length is wrong
 in reshape (#53883)

---
 base/bitarray.jl      | 2 +-
 base/reshapedarray.jl | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/bitarray.jl b/base/bitarray.jl
index 4411fc9323826..079dbefe03a94 100644
--- a/base/bitarray.jl
+++ b/base/bitarray.jl
@@ -482,7 +482,7 @@ end
 reshape(B::BitArray, dims::Tuple{Vararg{Int}}) = _bitreshape(B, dims)
 function _bitreshape(B::BitArray, dims::NTuple{N,Int}) where N
     prod(dims) == length(B) ||
-        throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $(length(B))"))
+        throw(DimensionMismatch("new dimensions $(dims) must be consistent with array length $(length(B))"))
     Br = BitArray{N}(undef, ntuple(i->0,Val(N))...)
     Br.chunks = B.chunks
     Br.len = prod(dims)
diff --git a/base/reshapedarray.jl b/base/reshapedarray.jl
index 63e508e8835de..f1bcc9fe303a7 100644
--- a/base/reshapedarray.jl
+++ b/base/reshapedarray.jl
@@ -39,7 +39,7 @@ eltype(::Type{<:ReshapedArrayIterator{I}}) where {I} = @isdefined(I) ? ReshapedI
 # reshaping to same # of dimensions
 @eval function reshape(a::Array{T,M}, dims::NTuple{N,Int}) where {T,N,M}
     throw_dmrsa(dims, len) =
-        throw(DimensionMismatch("new dimensions $(dims) must be consistent with array size $len"))
+        throw(DimensionMismatch("new dimensions $(dims) must be consistent with array length $len"))
     len = Core.checked_dims(dims...) # make sure prod(dims) doesn't overflow (and because of the comparison to length(a))
     if len != length(a)
         throw_dmrsa(dims, length(a))

From 89d59a91790b8fe6155c8cca16ac801e0bd4c863 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 28 Mar 2024 13:59:05 -0400
Subject: [PATCH 1193/1315] optimize: Delete incoming unreachable edges from
 PhiNode (#53877)

Incoming IR very rarely contains PhiNodes, but we do allow it to make
things easier on downstream packages like Diffractor that want to
generate the same code structures in both typed and untyped mode.
However, this does of course mean that once inference is finished, any
PhiNodes in the original source must be adjusted to maintain IRCode
invariants. One particular important invariant here is that the edges
list in a PhiNode must match the predecessor list, so in particular if a
predecessor becomes unreachable during inference, we must filter that
edge before passing it on to the optimizer.

---------

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
---
 base/compiler/optimize.jl | 14 +++++++
 test/compiler/ssair.jl    | 82 ++++++++++++++++++++++++++++++++++-----
 2 files changed, 86 insertions(+), 10 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 325ba3eca0170..fbdd726a81e9a 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -1104,6 +1104,20 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                         code[i] = nothing
                     end
                 end
+            elseif isa(expr, PhiNode)
+                new_edges = Int32[]
+                new_vals = Any[]
+                for j = 1:length(expr.edges)
+                    edge = expr.edges[j]
+                    (edge in sv.unreachable || (ssavaluetypes[edge] === Union{} && !isa(code[edge], PhiNode))) && continue
+                    push!(new_edges, edge)
+                    if isassigned(expr.values, j)
+                        push!(new_vals, expr.values[j])
+                    else
+                        resize!(new_vals, length(new_edges))
+                    end
+                end
+                code[i] = PhiNode(new_edges, new_vals)
             end
         end
     end
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 9082d1640e3be..9d5f7b617080d 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -9,16 +9,6 @@ include("irutils.jl")
 
 make_bb(preds, succs) = BasicBlock(Compiler.StmtRange(0, 0), preds, succs)
 
-function make_ci(code)
-    ci = (Meta.@lower 1 + 1).args[1]
-    ci.code = code
-    nstmts = length(ci.code)
-    ci.ssavaluetypes = nstmts
-    ci.codelocs = fill(Int32(1), nstmts)
-    ci.ssaflags = fill(Int32(0), nstmts)
-    return ci
-end
-
 # TODO: this test is broken
 #let code = Any[
 #        GotoIfNot(SlotNumber(2), 4),
@@ -763,3 +753,75 @@ end
         end
     end
 end
+
+# Test that things don't break if one branch of the frontend PhiNode becomes unreachable
+const global_error_switch_const1::Bool = false
+function gen_unreachable_phinode_edge1(world::UInt, source, args...)
+    ci = make_codeinfo(Any[
+        # block 1
+        GlobalRef(@__MODULE__, :global_error_switch_const1),
+        GotoIfNot(SSAValue(1), 4),
+        # block 2
+        Expr(:call, identity, Argument(3)),
+        # block 3
+        PhiNode(Int32[2, 3], Any[Argument(2), SSAValue(3)]),
+        ReturnNode(SSAValue(4))
+    ]; slottypes=Any[Any,Int,Int])
+    ci.slotnames = Symbol[:var"#self#", :x, :y]
+    return ci
+end
+@eval function f_unreachable_phinode_edge1(x, y)
+    $(Expr(:meta, :generated, gen_unreachable_phinode_edge1))
+    $(Expr(:meta, :generated_only))
+    #= no body =#
+end
+@test f_unreachable_phinode_edge1(1, 2) == 1
+
+const global_error_switch_const2::Bool = true
+function gen_unreachable_phinode_edge2(world::UInt, source, args...)
+    ci = make_codeinfo(Any[
+        # block 1
+        GlobalRef(@__MODULE__, :global_error_switch_const2),
+        GotoIfNot(SSAValue(1), 4),
+        # block 2
+        Expr(:call, identity, Argument(3)),
+        # block 3
+        PhiNode(Int32[2, 3], Any[Argument(2), SSAValue(3)]),
+        ReturnNode(SSAValue(4))
+    ]; slottypes=Any[Any,Int,Int])
+    ci.slotnames = Symbol[:var"#self#", :x, :y]
+    return ci
+end
+@eval function f_unreachable_phinode_edge2(x, y)
+    $(Expr(:meta, :generated, gen_unreachable_phinode_edge2))
+    $(Expr(:meta, :generated_only))
+    #= no body =#
+end
+@test f_unreachable_phinode_edge2(1, 2) == 2
+
+global global_error_switch::Bool = true
+function gen_must_throw_phinode_edge(world::UInt, source, _)
+    ci = make_codeinfo(Any[
+        # block 1
+        GlobalRef(@__MODULE__, :global_error_switch),
+        GotoIfNot(SSAValue(1), 4),
+        # block 2
+        Expr(:call, error, "This error is expected"),
+        # block 3
+        PhiNode(Int32[2, 3], Any[1, 2]),
+        ReturnNode(SSAValue(4))
+    ]; slottypes=Any[Any])
+    ci.slotnames = Symbol[:var"#self#"]
+    return ci
+end
+@eval function f_must_throw_phinode_edge()
+    $(Expr(:meta, :generated, gen_must_throw_phinode_edge))
+    $(Expr(:meta, :generated_only))
+    #= no body =#
+end
+let ir = first(only(Base.code_ircode(f_must_throw_phinode_edge)))
+    @test !any(@nospecialize(x)->isa(x,PhiNode), ir.stmts.stmt)
+end
+@test_throws ErrorException f_must_throw_phinode_edge()
+global global_error_switch = false
+@test f_must_throw_phinode_edge() == 1

From 3530c8f1774e41c51b88bed4d4a77f7ea7f871c0 Mon Sep 17 00:00:00 2001
From: Gabriele Bozzola <sbozzolator@gmail.com>
Date: Thu, 28 Mar 2024 11:35:45 -0700
Subject: [PATCH 1194/1315] Consistently format Julia in the docstring for
 Base.DEPOT_PATH (#53873)

It is unclear what `Julia` exactly means in this docstring, but the two
occurences of the word have different formatting. The guidelines say
> in docstrings refer to the language as "Julia" and the executable as
"`julia`".

Given that we are not talking about the executable here, I removed the
backticks.
---
 base/initdefs.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/initdefs.jl b/base/initdefs.jl
index 2b2916fc804ad..182984ae01d56 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -75,11 +75,11 @@ Here is an overview of some of the subdirectories that may exist in a depot:
 
 * `artifacts`: Contains content that packages use for which Pkg manages the installation of.
 * `clones`: Contains full clones of package repos. Maintained by `Pkg.jl` and used as a cache.
-* `config`: Contains julia-level configuration such as a `startup.jl`
+* `config`: Contains julia-level configuration such as a `startup.jl`.
 * `compiled`: Contains precompiled `*.ji` files for packages. Maintained by Julia.
 * `dev`: Default directory for `Pkg.develop`. Maintained by `Pkg.jl` and the user.
 * `environments`: Default package environments. For instance the global environment for a specific julia version. Maintained by `Pkg.jl`.
-* `logs`: Contains logs of `Pkg` and `REPL` operations. Maintained by `Pkg.jl` and `Julia`.
+* `logs`: Contains logs of `Pkg` and `REPL` operations. Maintained by `Pkg.jl` and Julia.
 * `packages`: Contains packages, some of which were explicitly installed and some which are implicit dependencies. Maintained by `Pkg.jl`.
 * `registries`: Contains package registries. By default only `General`. Maintained by `Pkg.jl`.
 * `scratchspaces`: Contains content that a package itself installs via the [`Scratch.jl`](https://github.com/JuliaPackaging/Scratch.jl) package. `Pkg.gc()` will delete content that is known to be unused.

From 1e50a99fd6cdce69ed819b587709151df9d227a2 Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Thu, 28 Mar 2024 15:27:52 -0400
Subject: [PATCH 1195/1315] Utilize bitshifts correctly in signals-mach.c when
 storing/reading the previous GC state (#53868)

I have not succeed in writing a test for this, but this was found on a
CI hang together with @keno and @vtjnash.

In essence if we hit a safepoint while GC_SAFE things can go wrong
<img width="748" alt="image"
src="https://github.com/JuliaLang/julia/assets/28694980/7d8170ee-11ab-43de-9bb1-9219aa5a2d80">
---
 src/signals-mach.c | 28 +++++++++++++++++++++++-----
 1 file changed, 23 insertions(+), 5 deletions(-)

diff --git a/src/signals-mach.c b/src/signals-mach.c
index 56f7c0d7505f4..2191dc3268721 100644
--- a/src/signals-mach.c
+++ b/src/signals-mach.c
@@ -9,6 +9,7 @@
 #include <mach/task.h>
 #include <mach/mig_errors.h>
 #include <AvailabilityMacros.h>
+#include <stdint.h>
 #include "mach_excServer.c"
 
 #ifdef MAC_OS_X_VERSION_10_9
@@ -47,14 +48,31 @@ static arraylist_t suspended_threads;
 extern uv_mutex_t safepoint_lock;
 extern uv_cond_t safepoint_cond_begin;
 
+#define GC_STATE_SHIFT 8*sizeof(int16_t)
+static inline int8_t decode_gc_state(uintptr_t item)
+{
+    return (int8_t)(item >> GC_STATE_SHIFT);
+}
+
+static inline int16_t decode_tid(uintptr_t item)
+{
+    return (int16_t)item;
+}
+
+static inline uintptr_t encode_item(int16_t tid, int8_t gc_state)
+{
+    return (uintptr_t)tid | ((uintptr_t)gc_state << GC_STATE_SHIFT);
+}
+
 // see jl_safepoint_wait_thread_resume
 void jl_safepoint_resume_thread_mach(jl_ptls_t ptls2, int16_t tid2)
 {
     // must be called with uv_mutex_lock(&safepoint_lock) and uv_mutex_lock(&ptls2->sleep_lock) held (in that order)
     for (size_t i = 0; i < suspended_threads.len; i++) {
         uintptr_t item = (uintptr_t)suspended_threads.items[i];
-        int16_t tid = (int16_t)item;
-        int8_t gc_state = (int8_t)(item >> 8);
+
+        int16_t tid = decode_tid(item);
+        int8_t gc_state = decode_gc_state(item);
         if (tid != tid2)
             continue;
         jl_atomic_store_release(&ptls2->gc_state, gc_state);
@@ -71,8 +89,8 @@ void jl_mach_gc_end(void)
     size_t j = 0;
     for (size_t i = 0; i < suspended_threads.len; i++) {
         uintptr_t item = (uintptr_t)suspended_threads.items[i];
-        int16_t tid = (int16_t)item;
-        int8_t gc_state = (int8_t)(item >> 8);
+        int16_t tid = decode_tid(item);
+        int8_t gc_state = decode_gc_state(item);
         jl_ptls_t ptls2 = jl_atomic_load_relaxed(&jl_all_tls_states)[tid];
         uv_mutex_lock(&ptls2->sleep_lock);
         if (jl_atomic_load_relaxed(&ptls2->suspend_count) == 0) {
@@ -117,7 +135,7 @@ static void jl_mach_gc_wait(jl_ptls_t ptls2, mach_port_t thread, int16_t tid)
         // triggers a SIGSEGV and gets handled by the usual codepath for unix.
         int8_t gc_state = jl_atomic_load_acquire(&ptls2->gc_state);
         jl_atomic_store_release(&ptls2->gc_state, JL_GC_STATE_WAITING);
-        uintptr_t item = tid | (((uintptr_t)gc_state) << 16);
+        uintptr_t item = encode_item(tid, gc_state);
         arraylist_push(&suspended_threads, (void*)item);
         thread_suspend(thread);
     }

From b18d2cc7046bee7b4a03842d709236ac1c081305 Mon Sep 17 00:00:00 2001
From: Matt Bauman <mbauman@juliahub.com>
Date: Thu, 28 Mar 2024 16:41:19 -0400
Subject: [PATCH 1196/1315] use flisp cprimitives for lowering large longs
 (#53860)

This addresses the previous limitation to `Base.literal_pow`, where it
would only apply to literals between $\pm2\^{61}$ (or 29).
---
 src/ast.c           | 16 ++++++++++++++--
 src/flisp/cvalues.c |  2 +-
 src/flisp/flisp.h   |  1 +
 test/numbers.jl     | 14 ++++++++++++++
 4 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/src/ast.c b/src/ast.c
index d39ee35e807ae..0971f4ab16e64 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -717,8 +717,20 @@ static int julia_to_scm_noalloc1(fl_context_t *fl_ctx, jl_value_t *v, value_t *r
 
 static value_t julia_to_scm_noalloc2(fl_context_t *fl_ctx, jl_value_t *v, int check_valid) JL_NOTSAFEPOINT
 {
-    if (jl_is_long(v) && fits_fixnum(jl_unbox_long(v)))
-        return fixnum(jl_unbox_long(v));
+    if (jl_is_long(v)) {
+        if (fits_fixnum(jl_unbox_long(v))) {
+            return fixnum(jl_unbox_long(v));
+        } else {
+#ifdef _P64
+            value_t prim = cprim(fl_ctx, fl_ctx->int64type, sizeof(int64_t));
+            *((int64_t*)cp_data((cprim_t*)ptr(prim))) = jl_unbox_long(v);
+#else
+            value_t prim = cprim(fl_ctx, fl_ctx->int32type, sizeof(int32_t));
+            *((int32_t*)cp_data((cprim_t*)ptr(prim))) = jl_unbox_long(v);
+#endif
+            return prim;
+        }
+    }
     if (check_valid) {
         if (jl_is_ssavalue(v))
             lerror(fl_ctx, symbol(fl_ctx, "error"), "SSAValue objects should not occur in an AST");
diff --git a/src/flisp/cvalues.c b/src/flisp/cvalues.c
index a5635c238ba3c..749b8802dfe82 100644
--- a/src/flisp/cvalues.c
+++ b/src/flisp/cvalues.c
@@ -101,7 +101,7 @@ void cv_autorelease(fl_context_t *fl_ctx, cvalue_t *cv)
     autorelease(fl_ctx, cv);
 }
 
-static value_t cprim(fl_context_t *fl_ctx, fltype_t *type, size_t sz)
+value_t cprim(fl_context_t *fl_ctx, fltype_t *type, size_t sz)
 {
     cprim_t *pcp = (cprim_t*)alloc_words(fl_ctx, CPRIM_NWORDS-1+NWORDS(sz));
     pcp->type = type;
diff --git a/src/flisp/flisp.h b/src/flisp/flisp.h
index b031e456cd3fe..669753a9f5302 100644
--- a/src/flisp/flisp.h
+++ b/src/flisp/flisp.h
@@ -328,6 +328,7 @@ typedef float    fl_float_t;
 typedef value_t (*builtin_t)(fl_context_t*, value_t*, uint32_t);
 
 value_t cvalue(fl_context_t *fl_ctx, fltype_t *type, size_t sz) JL_NOTSAFEPOINT;
+value_t cprim(fl_context_t *fl_ctx, fltype_t *type, size_t sz) JL_NOTSAFEPOINT;
 value_t cvalue_no_finalizer(fl_context_t *fl_ctx, fltype_t *type, size_t sz) JL_NOTSAFEPOINT;
 void add_finalizer(fl_context_t *fl_ctx, cvalue_t *cv);
 void cv_autorelease(fl_context_t *fl_ctx, cvalue_t *cv);
diff --git a/test/numbers.jl b/test/numbers.jl
index 47d7e87753b11..4f5893da0d091 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -2776,6 +2776,20 @@ Base.literal_pow(::typeof(^), ::PR20530, ::Val{p}) where {p} = 2
     @test [2,4,8].^-2 == [0.25, 0.0625, 0.015625]
     @test [2, 4, 8].^-2 .* 4 == [1.0, 0.25, 0.0625] # nested literal_pow
     @test ℯ^-2 == exp(-2) ≈ inv(ℯ^2) ≈ (ℯ^-1)^2 ≈ sqrt(ℯ^-4)
+
+    if Int === Int32
+        p = 2147483647
+        @test x^p == 1
+        @test x^2147483647 == 2
+        @test (@fastmath x^p) == 1
+        @test (@fastmath x^2147483647) == 2
+    elseif Int === Int64
+        p = 9223372036854775807
+        @test x^p == 1
+        @test x^9223372036854775807 == 2
+        @test (@fastmath x^p) == 1
+        @test (@fastmath x^9223372036854775807) == 2
+    end
 end
 module M20889 # do we get the expected behavior without importing Base.^?
     using Test

From a3438d0af710f1876a2a0eecc11782ab8fa20eab Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 29 Mar 2024 17:49:09 +0900
Subject: [PATCH 1197/1315] fix `NoMethodError` of `changed_lineinfo` (#53890)

I will add a test case for this later.

xref:
https://github.com/JuliaDiff/Diffractor.jl/actions/runs/8476871477/job/23226991456
---
 base/compiler/optimize.jl | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index fbdd726a81e9a..d8b307a1b7a7c 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -1035,20 +1035,22 @@ end
 function changed_lineinfo(di::DebugInfo, codeloc::Int, prevloc::Int)
     while true
         next = getdebugidx(di, codeloc)
-        next[1] < 0 && return false # invalid info
-        next[1] == 0 && next[2] == 0 && return false # no new info
+        line = next[1]
+        line < 0 && return false # invalid info
+        line == 0 && next[2] == 0 && return false # no new info
         prevloc <= 0 && return true # no old info
         prev = getdebugidx(di, prevloc)
         next === prev && return false # exactly identical
-        prev[1] < 0 && return true # previous invalid info, now valid
+        prevline = prev[1]
+        prevline < 0 && return true # previous invalid info, now valid
         edge = next[2]
         edge === prev[2] || return true # change to this edge
         linetable = di.linetable
         # check for change to line number here
-        if linetable === nothing || next[1] == 0
-            next[1] == prev[1] || return true
+        if linetable === nothing || line == 0
+            line == prevline || return true
         else
-            changed_lineinfo(linetable, next[1], prev[1]) && return true
+            changed_lineinfo(linetable::DebugInfo, Int(line), Int(prevline)) && return true
         end
         # check for change to edge here
         edge == 0 && return false # no edge here

From 11517f2df30cc55644dacdb054ffd981e3a76102 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 29 Mar 2024 19:42:09 +0900
Subject: [PATCH 1198/1315] fix typos in codegen.cpp (#53888)

Not sure why this typo didn't mess up the CI, but it looks like a clear
problem, let's correct it. I'd appreciate any idea on how to exercise
this change.

- fixes JuliaDebug/JuliaInterpreter.jl#621
---
 src/codegen.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/codegen.cpp b/src/codegen.cpp
index f1b0c570acc33..46e51785899a9 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -1617,9 +1617,9 @@ static const auto &builtin_func_map() {
           { jl_f_memoryref_addr,          new JuliaFunction<>{XSTR(jl_f_memoryref), get_func_sig, get_func_attrs} },
           { jl_f_memoryrefoffset_addr,    new JuliaFunction<>{XSTR(jl_f_memoryrefoffset), get_func_sig, get_func_attrs} },
           { jl_f_memoryrefset_addr,       new JuliaFunction<>{XSTR(jl_f_memoryrefset), get_func_sig, get_func_attrs} },
-          { jl_f_memoryrefswap_addr,      new JuliaFunction<>{XSTR(jl_f_memoryswapset), get_func_sig, get_func_attrs} },
-          { jl_f_memoryrefreplace_addr,   new JuliaFunction<>{XSTR(jl_f_memoryreplaceset), get_func_sig, get_func_attrs} },
-          { jl_f_memoryrefmodify_addr,    new JuliaFunction<>{XSTR(jl_f_memorymodifyset), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefswap_addr,      new JuliaFunction<>{XSTR(jl_f_memoryrefswap), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefreplace_addr,   new JuliaFunction<>{XSTR(jl_f_memoryrefreplace), get_func_sig, get_func_attrs} },
+          { jl_f_memoryrefmodify_addr,    new JuliaFunction<>{XSTR(jl_f_memoryrefmodify), get_func_sig, get_func_attrs} },
           { jl_f_memoryrefsetonce_addr,   new JuliaFunction<>{XSTR(jl_f_memoryrefsetonce), get_func_sig, get_func_attrs} },
           { jl_f_memoryref_isassigned_addr,new JuliaFunction<>{XSTR(jl_f_memoryref_isassigned), get_func_sig, get_func_attrs} },
           { jl_f_apply_type_addr,         new JuliaFunction<>{XSTR(jl_f_apply_type), get_func_sig, get_func_attrs} },

From b2e8eb2253c4641c058f61f3bd5cb3447484b7ed Mon Sep 17 00:00:00 2001
From: Zentrik <Zentrik@users.noreply.github.com>
Date: Fri, 29 Mar 2024 12:28:12 +0000
Subject: [PATCH 1199/1315] Revert change to checksum for llvm-julia (#53870)

Should fix #53399. I think this is the correct fix.
Makes it so you can build Julia with `USE_BINARYBUILDER=0`.
---
 deps/checksums/llvm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/deps/checksums/llvm b/deps/checksums/llvm
index 7effa4955a5f3..f54ddc7379b6e 100644
--- a/deps/checksums/llvm
+++ b/deps/checksums/llvm
@@ -246,7 +246,7 @@ libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/f6
 libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/45930e3ae3bf3922c8b3096474cbe22035432e80d2b0f4ccbd424c69e874a76acf4a724e055a5ef73ce40ae00ee6ede60b210b8847c30239a6ec242550a3e464
 libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/344f2a9d2b85a6c527fd6fa024d6763e
 libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/73909c58087568d8654d48ed5fc952289d8b3a4e26e956e9220cf254b8fb2c4b6630ebc9258502a6c3b67ed3cfe0cbe3a92ee3d346b228d842af03f0a42794c7
-llvm-julia-16.0.6-2.tar.gz/md5/71ca2225b042ec5ae666c99fa1bd19b1
-llvm-julia-16.0.6-2.tar.gz/sha512/6f2513adea1b939229c9be171e7ce41e488b3cfaa2e615912c4bc1ddaf0ab2e75df213a5d5db80105d6473a8017b0656016bbbb085ef00a38073519668885884
+llvm-julia-16.0.6-2.tar.gz/md5/f05607b71ac8d1e7c30430d2a9efa0a6
+llvm-julia-16.0.6-2.tar.gz/sha512/5f2f88b4673b13780fa819c78cb27fc5dab77c2976768ae4f7863b904c911e39fc18ee85d212e512a7c60081c74efd1fa2e7142b78002982533b7326ff808f24
 llvmunwind-12.0.1.tar.xz/md5/4ec327cee517fdb1f6a20e83748e2c7b
 llvmunwind-12.0.1.tar.xz/sha512/847b6ba03010a43f4fdbfdc49bf16d18fd18474d01584712e651b11191814bf7c1cf53475021d9ee447ed78413202b4ed97973d7bdd851d3e49f8d06f55a7af4

From 09b356f0eaf2e0570167b86fb674777cf435cb7e Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 29 Mar 2024 09:27:51 -0400
Subject: [PATCH 1200/1315] fix relocatable upgrades test (#53889)

Fixes https://github.com/JuliaLang/julia/issues/53885

Not the first time MacOS serving tempdir via a symlink has caused
obscure issues..
---
 test/loading.jl | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/loading.jl b/test/loading.jl
index 872ccd197f0f8..94f27ecf888bb 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1337,7 +1337,10 @@ end
 
 @testset "relocatable upgrades #51989" begin
     mktempdir() do depot
-        project_path = joinpath(depot, "project")
+        # realpath is needed because Pkg is used for one of the precompile paths below, and Pkg calls realpath on the
+        # project path so the cache file slug will be different if the tempdir is given as a symlink
+        # (which it often is on MacOS) which would break the test.
+        project_path = joinpath(realpath(depot), "project")
         mkpath(project_path)
 
         # Create fake `Foo.jl` package with two files:

From e26d14084cb11d1bf0f05096ef0887059ba0b52f Mon Sep 17 00:00:00 2001
From: Sebastien Marie <semarie@kapouay.eu.org>
Date: Fri, 29 Mar 2024 17:47:07 +0100
Subject: [PATCH 1201/1315] add initial support for OpenBSD (#53633)

These commits add initial support of OpenBSD in julia.

It isn't strictly enough to make julia runable on OpenBSD (see #53632),
but it covers the larger part.

---------

Co-authored-by: Max Horn <max@quendi.de>
Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
---
 Make.inc                     | 19 +++++++++++++---
 base/binaryplatforms.jl      | 18 +++++++++++----
 base/sysinfo.jl              |  2 +-
 cli/Makefile                 |  4 +++-
 cli/loader_lib.c             |  2 +-
 contrib/normalize_triplet.py |  2 ++
 deps/Makefile                |  4 +++-
 deps/libgit2.mk              |  6 ++++-
 deps/libssh2.mk              |  6 ++++-
 deps/libsuitesparse.mk       |  6 ++---
 deps/mbedtls.mk              |  2 +-
 deps/patchelf.mk             |  2 +-
 deps/pcre.mk                 |  3 +++
 src/Makefile                 |  2 ++
 src/aotcompile.cpp           |  2 +-
 src/cgmemmgr.cpp             |  3 +++
 src/codegen.cpp              |  2 +-
 src/gc-stacks.c              | 11 +++++++++
 src/jitlayers.cpp            | 22 +++++++++++++++++-
 src/julia.expmap.in          |  2 +-
 src/julia_threads.h          | 10 ++++++++
 src/signals-unix.c           | 39 ++++++++++++++++++++++++++++++--
 src/support/dtypes.h         |  2 +-
 src/support/platform.h       |  3 +++
 src/support/strtod.c         |  2 +-
 src/support/utf8.c           |  4 ++--
 src/sys.c                    | 44 ++++++++++++++++++++++++++++++++++--
 27 files changed, 194 insertions(+), 30 deletions(-)

diff --git a/Make.inc b/Make.inc
index 2a23bd3d37b51..56558e17bb2f4 100644
--- a/Make.inc
+++ b/Make.inc
@@ -670,7 +670,7 @@ JL_MAJOR_SHLIB_EXT := $(SHLIB_EXT).$(SOMAJOR)
 endif
 endif
 
-ifeq ($(OS), FreeBSD)
+ifneq ($(findstring $(OS),FreeBSD OpenBSD),)
 LOCALBASE ?= /usr/local
 else
 LOCALBASE ?= /usr
@@ -726,7 +726,7 @@ SANITIZE_LDFLAGS :=
 ifeq ($(SANITIZE_MEMORY),1)
 SANITIZE_OPTS += -fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer
 SANITIZE_LDFLAGS += $(SANITIZE_OPTS)
-ifneq ($(findstring $(OS),Linux FreeBSD),)
+ifneq ($(findstring $(OS),Linux FreeBSD OpenBSD),)
 SANITIZE_LDFLAGS += -Wl,--warn-unresolved-symbols
 endif # OS Linux or FreeBSD
 endif # SANITIZE_MEMORY=1
@@ -1069,7 +1069,7 @@ JCFLAGS+=-DSYSTEM_LIBUNWIND
 JCPPFLAGS+=-DSYSTEM_LIBUNWIND
 endif
 else
-ifeq ($(OS),Darwin)
+ifneq ($(findstring $(OS),Darwin OpenBSD),)
 LIBUNWIND:=-lunwind
 JCPPFLAGS+=-DLLVMLIBUNWIND
 else
@@ -1380,6 +1380,19 @@ OSLIBS += -Wl,--export-dynamic -Wl,--version-script=$(BUILDROOT)/src/julia.expma
 	$(NO_WHOLE_ARCHIVE)
 endif
 
+ifeq ($(OS), OpenBSD)
+JLDFLAGS += -Wl,--Bdynamic
+ifneq ($(SANITIZE),1)
+JLDFLAGS += -Wl,-no-undefined
+endif
+
+JLIBLDFLAGS += -Wl,-Bsymbolic-functions
+
+OSLIBS += -Wl,--no-as-needed -lpthread -lm -lc++abi -lc
+OSLIBS += -Wl,--whole-archive -lcompiler_rt -Wl,--no-whole-archive
+OSLIBS += -Wl,--export-dynamic,--as-needed,--version-script=$(BUILDROOT)/src/julia.expmap
+endif
+
 ifeq ($(OS), Darwin)
 SHLIB_EXT := dylib
 OSLIBS += -framework CoreFoundation
diff --git a/base/binaryplatforms.jl b/base/binaryplatforms.jl
index 9e45275f02636..8c6fa2a5f4a03 100644
--- a/base/binaryplatforms.jl
+++ b/base/binaryplatforms.jl
@@ -198,7 +198,7 @@ function validate_tags(tags::Dict)
         throw_invalid_key("arch")
     end
     # Validate `os`
-    if tags["os"] ∉ ("linux", "macos", "freebsd", "windows")
+    if tags["os"] ∉ ("linux", "macos", "freebsd", "openbsd", "windows")
         throw_invalid_key("os")
     end
     # Validate `os`/`arch` combination
@@ -375,8 +375,10 @@ function os()
         return "windows"
     elseif Sys.isapple()
         return "macos"
-    elseif Sys.isbsd()
+    elseif Sys.isfreebsd()
         return "freebsd"
+    elseif Sys.isopenbsd()
+        return "openbsd"
     else
         return "linux"
     end
@@ -422,6 +424,7 @@ const platform_names = Dict(
     "macos" => "macOS",
     "windows" => "Windows",
     "freebsd" => "FreeBSD",
+    "openbsd" => "OpenBSD",
     nothing => "Unknown",
 )
 
@@ -556,6 +559,8 @@ function os_str(p::AbstractPlatform)
         else
             return "-unknown-freebsd"
         end
+    elseif os(p) == "openbsd"
+        return "-unknown-openbsd"
     else
         return "-unknown"
     end
@@ -581,7 +586,8 @@ Sys.isapple(p::AbstractPlatform) = os(p) == "macos"
 Sys.islinux(p::AbstractPlatform) = os(p) == "linux"
 Sys.iswindows(p::AbstractPlatform) = os(p) == "windows"
 Sys.isfreebsd(p::AbstractPlatform) = os(p) == "freebsd"
-Sys.isbsd(p::AbstractPlatform) = os(p) ∈ ("freebsd", "macos")
+Sys.isopenbsd(p::AbstractPlatform) = os(p) == "openbsd"
+Sys.isbsd(p::AbstractPlatform) = os(p) ∈ ("freebsd", "openbsd", "macos")
 Sys.isunix(p::AbstractPlatform) = Sys.isbsd(p) || Sys.islinux(p)
 
 const arch_mapping = Dict(
@@ -632,6 +638,7 @@ end
 const os_mapping = Dict(
     "macos" => "-apple-darwin[\\d\\.]*",
     "freebsd" => "-(.*-)?freebsd[\\d\\.]*",
+    "openbsd" => "-(.*-)?openbsd[\\d\\.]*",
     "windows" => "-w64-mingw32",
     "linux" => "-(.*-)?linux",
 )
@@ -745,6 +752,9 @@ function Base.parse(::Type{Platform}, triplet::String; validate_strict::Bool = f
         if os == "freebsd"
             os_version = extract_os_version("freebsd", r".*freebsd([\d.]+)"sa)
         end
+        if os == "openbsd"
+            os_version = extract_os_version("openbsd", r".*openbsd([\d.]+)"sa)
+        end
         tags["os_version"] = os_version
 
         return Platform(arch, os, tags; validate_strict)
@@ -802,7 +812,7 @@ function parse_dl_name_version(path::String, os::String)
         # On OSX, libraries look like `libnettle.6.3.dylib`
         dlregex = r"^(.*?)((?:\.[\d]+)*)\.dylib$"sa
     else
-        # On Linux and FreeBSD, libraries look like `libnettle.so.6.3.0`
+        # On Linux and others BSD, libraries look like `libnettle.so.6.3.0`
         dlregex = r"^(.*?)\.so((?:\.[\d]+)*)$"sa
     end
 
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index 9bdff3673477f..484ac4d01d104 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -399,7 +399,7 @@ end
 
 Get the maximum resident set size utilized in bytes.
 See also:
-    - man page of `getrusage`(2) on Linux and FreeBSD.
+    - man page of `getrusage`(2) on Linux and BSD.
     - Windows API `GetProcessMemoryInfo`.
 """
 maxrss() = ccall(:jl_maxrss, Csize_t, ())
diff --git a/cli/Makefile b/cli/Makefile
index 4e32c53b9a6f0..017f713446e1a 100644
--- a/cli/Makefile
+++ b/cli/Makefile
@@ -24,6 +24,8 @@ else ifeq ($(OS),Linux)
 LOADER_LDFLAGS += -Wl,--no-as-needed -ldl -lpthread -rdynamic -lc -Wl,--as-needed -Wl,-z,notext
 else ifeq ($(OS),FreeBSD)
 LOADER_LDFLAGS += -Wl,--no-as-needed -ldl -lpthread -rdynamic -lc -Wl,--as-needed
+else ifeq ($(OS),OpenBSD)
+LOADER_LDFLAGS += -Wl,--no-as-needed -lpthread -rdynamic -lc -Wl,--as-needed
 else ifeq ($(OS),Darwin)
 LOADER_LDFLAGS += -lSystem
 endif
@@ -107,7 +109,7 @@ julia-debug: $(build_bindir)/julia-debug$(EXE)
 libjulia-release: $(build_shlibdir)/libjulia.$(SHLIB_EXT)
 libjulia-debug: $(build_shlibdir)/libjulia-debug.$(SHLIB_EXT)
 
-ifneq (,$(filter $(OS), Linux FreeBSD))
+ifneq (,$(filter $(OS), Linux FreeBSD OpenBSD))
 VERSIONSCRIPT := -Wl,--version-script=$(BUILDDIR)/julia.expmap
 endif
 
diff --git a/cli/loader_lib.c b/cli/loader_lib.c
index 02030cf2717a5..d09d21e10abd1 100644
--- a/cli/loader_lib.c
+++ b/cli/loader_lib.c
@@ -520,7 +520,7 @@ __attribute__((constructor)) void jl_load_libjulia_internal(void) {
         (*jl_codegen_exported_func_addrs[symbol_idx]) = addr;
     }
     // Next, if we're on Linux/FreeBSD, set up fast TLS.
-#if !defined(_OS_WINDOWS_) && !defined(_OS_DARWIN_)
+#if !defined(_OS_WINDOWS_) && !defined(_OS_DARWIN_) && !defined(_OS_OPENBSD_)
     void (*jl_pgcstack_setkey)(void*, void*(*)(void)) = lookup_symbol(libjulia_internal, "jl_pgcstack_setkey");
     if (jl_pgcstack_setkey == NULL) {
         jl_loader_print_stderr("ERROR: Cannot find jl_pgcstack_setkey() function within libjulia-internal!\n");
diff --git a/contrib/normalize_triplet.py b/contrib/normalize_triplet.py
index 77c047b360b76..b1bab29487b8f 100755
--- a/contrib/normalize_triplet.py
+++ b/contrib/normalize_triplet.py
@@ -19,6 +19,7 @@
 platform_mapping = {
     'darwin': "-apple-darwin[\\d\\.]*",
     'freebsd': "-(.*-)?freebsd[\\d\\.]*",
+    'openbsd': "-(.*-)?openbsd[\\d\\.]*",
     'windows': "-w64-mingw32",
     'linux': "-(.*-)?linux",
 }
@@ -96,6 +97,7 @@ def p(x):
         'darwin': 'apple-darwin',
         'windows': 'w64-mingw32',
         'freebsd': 'unknown-freebsd',
+        'openbsd': 'unknown-openbsd',
     }
     x = r(x)
     if x:
diff --git a/deps/Makefile b/deps/Makefile
index 27f5fdbb693d5..fd8f5267e9d7e 100644
--- a/deps/Makefile
+++ b/deps/Makefile
@@ -64,13 +64,15 @@ ifeq ($(OS), Linux)
 DEP_LIBS += unwind
 else ifeq ($(OS), FreeBSD)
 DEP_LIBS += unwind
+else ifeq ($(OS), OpenBSD)
+DEP_LIBS += llvmunwind
 else ifeq ($(OS), Darwin)
 DEP_LIBS += llvmunwind
 endif
 endif
 endif
 
-ifneq (,$(findstring $(OS),Linux FreeBSD))
+ifneq (,$(findstring $(OS),Linux FreeBSD OpenBSD))
 ifeq ($(USE_SYSTEM_PATCHELF), 0)
 DEP_LIBS += patchelf
 PATCHELF:=$(build_depsbindir)/patchelf
diff --git a/deps/libgit2.mk b/deps/libgit2.mk
index d68a7a80d6d5b..b65ac022885a3 100644
--- a/deps/libgit2.mk
+++ b/deps/libgit2.mk
@@ -33,8 +33,12 @@ LIBGIT2_OPTS += -DBUILD_TESTS=OFF -DDLLTOOL=`which $(CROSS_COMPILE)dlltool`
 LIBGIT2_OPTS += -DCMAKE_FIND_ROOT_PATH=/usr/$(XC_HOST) -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=ONLY
 endif
 endif
+ifeq ($(OS),OpenBSD)
+# iconv.h is third-party
+LIBGIT2_OPTS += -DCMAKE_C_FLAGS="-I/usr/local/include"
+endif
 
-ifneq (,$(findstring $(OS),Linux FreeBSD))
+ifneq (,$(findstring $(OS),Linux FreeBSD OpenBSD))
 LIBGIT2_OPTS += -DUSE_HTTPS="mbedTLS" -DUSE_SHA1="CollisionDetection" -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
 endif
 
diff --git a/deps/libssh2.mk b/deps/libssh2.mk
index 3f9738515e4a1..c293d8309d2bc 100644
--- a/deps/libssh2.mk
+++ b/deps/libssh2.mk
@@ -11,6 +11,10 @@ endif
 LIBSSH2_OPTS := $(CMAKE_COMMON) -DBUILD_SHARED_LIBS=ON -DBUILD_EXAMPLES=OFF \
 		-DCMAKE_BUILD_TYPE=Release
 
+ifneq ($(fPIC),)
+LIBSSH2_OPTS += -DCMAKE_C_FLAGS="-fPIC"
+endif
+
 ifeq ($(OS),WINNT)
 LIBSSH2_OPTS += -DCRYPTO_BACKEND=WinCNG -DENABLE_ZLIB_COMPRESSION=OFF
 ifeq ($(BUILD_OS),WINNT)
@@ -20,7 +24,7 @@ else
 LIBSSH2_OPTS += -DCRYPTO_BACKEND=mbedTLS -DENABLE_ZLIB_COMPRESSION=OFF
 endif
 
-ifneq (,$(findstring $(OS),Linux FreeBSD))
+ifneq (,$(findstring $(OS),Linux FreeBSD OpenBSD))
 LIBSSH2_OPTS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
 endif
 
diff --git a/deps/libsuitesparse.mk b/deps/libsuitesparse.mk
index 7e36bce8f4f9d..0207c5ef7c099 100644
--- a/deps/libsuitesparse.mk
+++ b/deps/libsuitesparse.mk
@@ -36,7 +36,7 @@ else
 LIBSUITESPARSE_CMAKE_FLAGS += -DSUITESPARSE_USE_64BIT_BLAS=NO
 endif
 
-ifneq (,$(findstring $(OS),Linux FreeBSD))
+ifneq (,$(findstring $(OS),Linux FreeBSD OpenBSD))
 LIBSUITESPARSE_CMAKE_FLAGS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
 endif
 
@@ -59,8 +59,8 @@ $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: | $(build_prefix)/
 
 $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-patched
 	cd $(dir $<) && $(CMAKE) . $(LIBSUITESPARSE_CMAKE_FLAGS)
-	make -C $(dir $<)
-	make -C $(dir $<) install
+	$(MAKE) -C $(dir $<)
+	$(MAKE) -C $(dir $<) install
 	echo 1 > $@
 
 ifeq ($(OS),WINNT)
diff --git a/deps/mbedtls.mk b/deps/mbedtls.mk
index b4147c2c2684e..39cf817d70658 100644
--- a/deps/mbedtls.mk
+++ b/deps/mbedtls.mk
@@ -13,7 +13,7 @@ ifeq ($(BUILD_OS),WINNT)
 MBEDTLS_OPTS += -G"MSYS Makefiles"
 endif
 
-ifneq (,$(findstring $(OS),Linux FreeBSD))
+ifneq (,$(findstring $(OS),Linux FreeBSD OpenBSD))
 MBEDTLS_OPTS += -DCMAKE_INSTALL_RPATH="\$$ORIGIN"
 endif
 
diff --git a/deps/patchelf.mk b/deps/patchelf.mk
index 9b4947f183117..c019892058d0e 100644
--- a/deps/patchelf.mk
+++ b/deps/patchelf.mk
@@ -20,7 +20,7 @@ $(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-configured: XC_HOST:=$(BUILD_MACHINE)
 $(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-configured: $(SRCCACHE)/patchelf-$(PATCHELF_VER)/source-extracted
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
-	$(dir $<)/configure $(CONFIGURE_COMMON) LDFLAGS="$(CXXLDFLAGS)" CPPFLAGS="$(CPPFLAGS)"
+	$(dir $<)/configure $(CONFIGURE_COMMON) LDFLAGS="$(CXXLDFLAGS)" CPPFLAGS="$(CPPFLAGS)" MAKE=$(MAKE)
 	echo 1 > $@
 
 $(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-compiled: $(BUILDDIR)/patchelf-$(PATCHELF_VER)/build-configured
diff --git a/deps/pcre.mk b/deps/pcre.mk
index cd1180d992885..3ff85d5569ad9 100644
--- a/deps/pcre.mk
+++ b/deps/pcre.mk
@@ -9,6 +9,9 @@ PCRE_LDFLAGS := $(RPATH_ESCAPED_ORIGIN)
 ifeq ($(OS),emscripten)
 PCRE_CFLAGS += -fPIC
 PCRE_JIT = --disable-jit
+else ifeq ($(OS),OpenBSD)
+# jit will need RWX memory
+PCRE_JIT = --disable-jit
 else
 PCRE_JIT = --enable-jit
 endif
diff --git a/src/Makefile b/src/Makefile
index 72895e9a8080c..323aaea61c47d 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -474,6 +474,8 @@ $(build_shlibdir)/lib%Plugin.$(SHLIB_EXT): $(SRCDIR)/clangsa/%.cpp $(LLVM_CONFIG
 ANALYSIS_DEPS := llvm clang llvm-tools libuv utf8proc
 ifeq ($(OS),Darwin)
 ANALYSIS_DEPS += llvmunwind
+else ifeq ($(OS),OpenBSD)
+ANALYSIS_DEPS += llvmunwind
 else ifneq ($(OS),WINNT)
 ANALYSIS_DEPS += unwind
 endif
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index 880d193ea157c..edef391af6708 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -1605,7 +1605,7 @@ void jl_dump_native_impl(void *native_code,
         TheTriple.setOSName(Str);
     }
     Optional<Reloc::Model> RelocModel;
-    if (TheTriple.isOSLinux() || TheTriple.isOSFreeBSD()) {
+    if (TheTriple.isOSLinux() || TheTriple.isOSFreeBSD() || TheTriple.isOSOpenBSD()) {
         RelocModel = Reloc::PIC_;
     }
 
diff --git a/src/cgmemmgr.cpp b/src/cgmemmgr.cpp
index b627224e027a9..c78e6092ca5db 100644
--- a/src/cgmemmgr.cpp
+++ b/src/cgmemmgr.cpp
@@ -25,6 +25,9 @@
 #  include <sys/types.h>
 #  include <sys/resource.h>
 #endif
+#ifdef _OS_OPENBSD_
+#  include <sys/resource.h>
+#endif
 #include "julia_assert.h"
 
 namespace {
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 46e51785899a9..5d1dda3e735dc 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -86,7 +86,7 @@ static bool jl_fpo_disabled(const Triple &TT) {
     // MSAN doesn't support FPO
     return true;
 #endif
-    if (TT.isOSLinux() || TT.isOSWindows() || TT.isOSFreeBSD()) {
+    if (TT.isOSLinux() || TT.isOSWindows() || TT.isOSFreeBSD() || TT.isOSOpenBSD()) {
         return true;
     }
     return false;
diff --git a/src/gc-stacks.c b/src/gc-stacks.c
index 2d0fc011802c9..e42b2fddaf8aa 100644
--- a/src/gc-stacks.c
+++ b/src/gc-stacks.c
@@ -50,6 +50,16 @@ static void free_stack(void *stkbuf, size_t bufsz)
 
 #else
 
+# ifdef _OS_OPENBSD_
+static void *malloc_stack(size_t bufsz) JL_NOTSAFEPOINT
+{
+    void* stk = mmap(0, bufsz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
+    if (stk == MAP_FAILED)
+        return MAP_FAILED;
+    jl_atomic_fetch_add(&num_stack_mappings, 1);
+    return stk;
+}
+# else
 static void *malloc_stack(size_t bufsz) JL_NOTSAFEPOINT
 {
     void* stk = mmap(0, bufsz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
@@ -65,6 +75,7 @@ static void *malloc_stack(size_t bufsz) JL_NOTSAFEPOINT
     jl_atomic_fetch_add_relaxed(&num_stack_mappings, 1);
     return stk;
 }
+# endif
 
 static void free_stack(void *stkbuf, size_t bufsz)
 {
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index 5f9d7f8a3c6cf..eee2879ef0ed7 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -113,6 +113,15 @@ static void *getTLSAddress(void *control)
 }
 #endif
 
+#ifdef _OS_OPENBSD_
+extern "C" {
+    __int128 __divti3(__int128, __int128);
+    __int128 __modti3(__int128, __int128);
+    unsigned __int128 __udivti3(unsigned __int128, unsigned __int128);
+    unsigned __int128 __umodti3(unsigned __int128, unsigned __int128);
+}
+#endif
+
 // Snooping on which functions are being compiled, and how long it takes
 extern "C" JL_DLLEXPORT_CODEGEN
 void jl_dump_compiles_impl(void *s)
@@ -1732,6 +1741,17 @@ JuliaOJIT::JuliaOJIT()
     };
     cantFail(GlobalJD.define(orc::symbolAliases(jl_crt)));
 
+#ifdef _OS_OPENBSD_
+    orc::SymbolMap i128_crt;
+
+    i128_crt[mangle("__divti3")] = JITEvaluatedSymbol::fromPointer(&__divti3, JITSymbolFlags::Exported);
+    i128_crt[mangle("__modti3")] = JITEvaluatedSymbol::fromPointer(&__modti3, JITSymbolFlags::Exported);
+    i128_crt[mangle("__udivti3")] = JITEvaluatedSymbol::fromPointer(&__udivti3, JITSymbolFlags::Exported);
+    i128_crt[mangle("__umodti3")] = JITEvaluatedSymbol::fromPointer(&__umodti3, JITSymbolFlags::Exported);
+
+    cantFail(GlobalJD.define(orc::absoluteSymbols(i128_crt)));
+#endif
+
 #ifdef MSAN_EMUTLS_WORKAROUND
     orc::SymbolMap msan_crt;
     msan_crt[mangle("__emutls_get_address")] = JITEvaluatedSymbol::fromPointer(msan_workaround::getTLSAddress, JITSymbolFlags::Exported);
@@ -1808,7 +1828,7 @@ void JuliaOJIT::addModule(orc::ThreadSafeModule TSM)
     auto Lookups = ES.lookup({{&JD, orc::JITDylibLookupFlags::MatchExportedSymbolsOnly}}, NewExports);
     if (!Lookups) {
         ES.reportError(Lookups.takeError());
-        errs() << "Failed to lookup symbols in module!";
+        errs() << "Failed to lookup symbols in module!\n";
         if (CurrentlyCompiling) {
             CurrentlyCompiling.withModuleDo([](Module &M) JL_NOTSAFEPOINT { errs() << "Dumping failing module\n" << M << "\n"; });
         } else {
diff --git a/src/julia.expmap.in b/src/julia.expmap.in
index 213d087fdc2ad..e5f9ee890205f 100644
--- a/src/julia.expmap.in
+++ b/src/julia.expmap.in
@@ -1,7 +1,7 @@
 @JULIA_SHLIB_SYMBOL_VERSION@ {
   global:
     pthread*;
-    __stack_chk_guard;
+    __stack_chk_*;
     asprintf;
     bitvector_*;
     ios_*;
diff --git a/src/julia_threads.h b/src/julia_threads.h
index 3f8f5391919b4..3a4e9a66cf5a7 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -37,6 +37,16 @@ JL_DLLEXPORT int8_t jl_threadpoolid(int16_t tid) JL_NOTSAFEPOINT;
 #define JL_HAVE_UCONTEXT
 typedef win32_ucontext_t jl_stack_context_t;
 typedef jl_stack_context_t _jl_ucontext_t;
+
+#elif defined(_OS_OPENBSD_)
+#define JL_HAVE_UNW_CONTEXT
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+typedef unw_context_t _jl_ucontext_t;
+typedef struct {
+    jl_jmp_buf uc_mcontext;
+} jl_stack_context_t;
+
 #else
 typedef struct {
     jl_jmp_buf uc_mcontext;
diff --git a/src/signals-unix.c b/src/signals-unix.c
index eb51a5fccfaba..91c47421669f2 100644
--- a/src/signals-unix.c
+++ b/src/signals-unix.c
@@ -24,10 +24,12 @@
 #endif
 
 // Figure out the best signals/timers to use for this platform
-#ifdef __APPLE__ // Darwin's mach ports allow signal-free thread management
+#if defined(__APPLE__) // Darwin's mach ports allow signal-free thread management
 #define HAVE_MACH
 #define HAVE_KEVENT
-#else // generic Linux or BSD
+#elif defined(__OpenBSD__)
+#define HAVE_KEVENT
+#else // generic Linux or FreeBSD
 #define HAVE_TIMER
 #endif
 
@@ -83,6 +85,9 @@ static inline __attribute__((unused)) uintptr_t jl_get_rsp_from_ctx(const void *
 #elif defined(_OS_FREEBSD_) && defined(_CPU_X86_64_)
     const ucontext_t *ctx = (const ucontext_t*)_ctx;
     return ctx->uc_mcontext.mc_rsp;
+#elif defined(_OS_OPENBSD_) && defined(_CPU_X86_64_)
+    const struct sigcontext *ctx = (const struct sigcontext *)_ctx;
+    return ctx->sc_rsp;
 #else
     // TODO Add support for PowerPC(64)?
     return 0;
@@ -145,6 +150,11 @@ JL_NO_ASAN static void jl_call_in_ctx(jl_ptls_t ptls, void (*fptr)(void), int si
     rsp -= sizeof(void*);
     ctx->uc_mcontext.mc_esp = rsp;
     ctx->uc_mcontext.mc_eip = (uintptr_t)fptr;
+#elif defined(_OS_OPENBSD_) && defined(_CPU_X86_64_)
+    struct sigcontext *ctx = (struct sigcontext *)_ctx;
+    rsp -= sizeof(void*);
+    ctx->sc_rsp = rsp;
+    ctx->sc_rip = fptr;
 #elif defined(_OS_LINUX_) && defined(_CPU_AARCH64_)
     ucontext_t *ctx = (ucontext_t*)_ctx;
     ctx->uc_mcontext.sp = rsp;
@@ -237,8 +247,12 @@ static void sigdie_handler(int sig, siginfo_t *info, void *context)
         info->si_code == SI_KERNEL ||
 #endif
         info->si_code == SI_QUEUE ||
+#ifdef SI_MESGQ
         info->si_code == SI_MESGQ ||
+#endif
+#ifdef SI_ASYNCIO
         info->si_code == SI_ASYNCIO ||
+#endif
 #ifdef SI_SIGIO
         info->si_code == SI_SIGIO ||
 #endif
@@ -336,6 +350,11 @@ int is_write_fault(void *context) {
     ucontext_t *ctx = (ucontext_t*)context;
     return exc_reg_is_write_fault(ctx->uc_mcontext.mc_err);
 }
+#elif defined(_OS_OPENBSD_) && defined(_CPU_X86_64_)
+int is_write_fault(void *context) {
+    struct sigcontext *ctx = (struct sigcontext *)context;
+    return exc_reg_is_write_fault(ctx->sc_err);
+}
 #else
 #pragma message("Implement this query for consistent PROT_NONE handling")
 int is_write_fault(void *context) {
@@ -615,6 +634,17 @@ JL_DLLEXPORT void jl_profile_stop_timer(void)
     }
 }
 
+#elif defined(__OpenBSD__)
+
+JL_DLLEXPORT int jl_profile_start_timer(void)
+{
+    return -1;
+}
+
+JL_DLLEXPORT void jl_profile_stop_timer(void)
+{
+}
+
 #else
 
 #error no profile tools available
@@ -653,6 +683,9 @@ void jl_install_thread_signal_handler(jl_ptls_t ptls)
     ss.ss_flags = 0;
     ss.ss_size = ssize;
     assert(ssize != 0);
+
+#ifndef _OS_OPENBSD_
+    /* fallback to malloc(), but it isn't possible on OpenBSD */
     if (signal_stack == NULL) {
         signal_stack = malloc(ssize);
         ssize = 0;
@@ -661,6 +694,8 @@ void jl_install_thread_signal_handler(jl_ptls_t ptls)
         else
             jl_safe_printf("\nwarning: julia signal stack allocated without guard page (launch foreign threads earlier to avoid this warning).\n");
     }
+#endif
+
     if (signal_stack != NULL) {
         ss.ss_sp = signal_stack;
         if (sigaltstack(&ss, NULL) < 0)
diff --git a/src/support/dtypes.h b/src/support/dtypes.h
index 4e9868ed45c23..57f4fa99f0016 100644
--- a/src/support/dtypes.h
+++ b/src/support/dtypes.h
@@ -99,7 +99,7 @@ typedef intptr_t ssize_t;
 #define BYTE_ORDER     __BYTE_ORDER
 #endif
 
-#if defined(__APPLE__) || defined(__FreeBSD__)
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 #include <machine/endian.h>
 #define __LITTLE_ENDIAN  LITTLE_ENDIAN
 #define __BIG_ENDIAN     BIG_ENDIAN
diff --git a/src/support/platform.h b/src/support/platform.h
index 9ab28ac1c70c3..a0dd84c9c20b6 100644
--- a/src/support/platform.h
+++ b/src/support/platform.h
@@ -16,6 +16,7 @@
  *          _COMPILER_GCC_
  *      OS:
  *          _OS_FREEBSD_
+ *          _OS_OPENBSD_
  *          _OS_LINUX_
  *          _OS_WINDOWS_
  *          _OS_DARWIN_
@@ -81,6 +82,8 @@
 
 #if defined(__FreeBSD__)
 #define _OS_FREEBSD_
+#elif defined(__OpenBSD__)
+#define _OS_OPENBSD_
 #elif defined(__linux__)
 #define _OS_LINUX_
 #elif defined(_WIN32) || defined(_WIN64)
diff --git a/src/support/strtod.c b/src/support/strtod.c
index 24f556d0c086b..e0ad1bf33435a 100644
--- a/src/support/strtod.c
+++ b/src/support/strtod.c
@@ -11,7 +11,7 @@
 extern "C" {
 #endif
 
-#if !defined(_OS_WINDOWS_)
+#if !defined(_OS_WINDOWS_) && !defined(__OpenBSD__)
 // This code path should be used for systems that support the strtod_l function
 
 // Cache locale object
diff --git a/src/support/utf8.c b/src/support/utf8.c
index 17dcf5f1efd51..02f541492b0f0 100644
--- a/src/support/utf8.c
+++ b/src/support/utf8.c
@@ -29,9 +29,9 @@
 #include <malloc.h>
 #define snprintf _snprintf
 #else
-#ifndef __FreeBSD__
+#if !defined(__FreeBSD__) && !defined(__OpenBSD__)
 #include <alloca.h>
-#endif /* __FreeBSD__ */
+#endif /* !__FreeBSD__ && !__OpenBSD__ */
 #endif
 #include <assert.h>
 
diff --git a/src/sys.c b/src/sys.c
index 0c0016ee07657..107a8f7637763 100644
--- a/src/sys.c
+++ b/src/sys.c
@@ -635,6 +635,38 @@ JL_DLLEXPORT long jl_SC_CLK_TCK(void)
 #endif
 }
 
+#ifdef _OS_OPENBSD_
+// Helper for jl_pathname_for_handle()
+struct dlinfo_data {
+    void       *searched;
+    const char *result;
+};
+
+static int dlinfo_helper(struct dl_phdr_info *info, size_t size, void *vdata)
+{
+    struct dlinfo_data *data = (struct dlinfo_data *)vdata;
+    void *handle;
+
+    /* ensure dl_phdr_info at compile-time to be compatible with the one at runtime */
+    if (sizeof(*info) < size)
+        return -1;
+
+    /* dlopen the name */
+    handle = dlopen(info->dlpi_name, RTLD_LAZY | RTLD_NOLOAD);
+    if (handle == NULL)
+        return 0;
+
+    /* check if the opened library is the same as the searched handle */
+    if (data->searched == handle)
+        data->result = info->dlpi_name;
+
+    dlclose(handle);
+
+    /* continue if still not found */
+    return (data->result != NULL);
+}
+#endif
+
 // Takes a handle (as returned from dlopen()) and returns the absolute path to the image loaded
 JL_DLLEXPORT const char *jl_pathname_for_handle(void *handle)
 {
@@ -677,6 +709,14 @@ JL_DLLEXPORT const char *jl_pathname_for_handle(void *handle)
     free(pth16);
     return filepath;
 
+#elif defined(_OS_OPENBSD_)
+    struct dlinfo_data data = {
+        .searched = handle,
+        .result = NULL,
+    };
+    dl_iterate_phdr(&dlinfo_helper, &data);
+    return data.result;
+
 #else // Linux, FreeBSD, ...
 
     struct link_map *map;
@@ -754,11 +794,11 @@ JL_DLLEXPORT size_t jl_maxrss(void)
 
 // FIXME: `rusage` is available on OpenBSD, DragonFlyBSD and NetBSD as well.
 //        All of them return `ru_maxrss` in kilobytes.
-#elif defined(_OS_LINUX_) || defined(_OS_DARWIN_) || defined (_OS_FREEBSD_)
+#elif defined(_OS_LINUX_) || defined(_OS_DARWIN_) || defined (_OS_FREEBSD_) || defined (_OS_OPENBSD_)
     struct rusage rusage;
     getrusage( RUSAGE_SELF, &rusage );
 
-#if defined(_OS_LINUX_) || defined(_OS_FREEBSD_)
+#if defined(_OS_LINUX_) || defined(_OS_FREEBSD_) || defined (_OS_OPENBSD_)
     return (size_t)(rusage.ru_maxrss * 1024);
 #else
     return (size_t)rusage.ru_maxrss;

From d10a0fbcfe7e339e5d9bab161ff64dd022b44418 Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Fri, 29 Mar 2024 17:51:02 +0100
Subject: [PATCH 1202/1315] curl: fix RPATH to find nghttp2 and libssh2
 (#53894)

Fixes https://github.com/JuliaLang/julia/issues/48820

I think this is the proper fix, and there might be a configure option to
curl or nghttp2 to set it, but I haven't been found it. So we'll do it
that way.
---
 deps/curl.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps/curl.mk b/deps/curl.mk
index 8454ec5f38b1e..4314bb89cc739 100644
--- a/deps/curl.mk
+++ b/deps/curl.mk
@@ -14,7 +14,7 @@ $(BUILDDIR)/curl-$(CURL_VER)/build-configured: | $(build_prefix)/manifest/nghttp
 endif
 
 ifneq ($(USE_BINARYBUILDER_CURL),1)
-CURL_LDFLAGS := $(RPATH_ESCAPED_ORIGIN)
+CURL_LDFLAGS := $(RPATH_ESCAPED_ORIGIN) -Wl,-rpath,$(build_shlibdir)
 
 # On older Linuces (those that use OpenSSL < 1.1) we include `libpthread` explicitly.
 # It doesn't hurt to include it explicitly elsewhere, so we do so.

From 24ff6f4c9596953245d311bfffb96a7108c8c9d0 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Sat, 30 Mar 2024 01:18:49 -0300
Subject: [PATCH 1203/1315] no need to check whether mq_master is nil in the GC
 work-stealing loop (#53899)

This is not needed after https://github.com/JuliaLang/julia/pull/53355.
---
 src/gc.c | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 4aae5e22c6678..06a41393953b9 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -2976,11 +2976,10 @@ JL_EXTENSION NOINLINE void gc_mark_loop_serial(jl_ptls_t ptls)
 
 void gc_mark_and_steal(jl_ptls_t ptls)
 {
-    jl_gc_markqueue_t *mq = &ptls->mark_queue;
-    jl_gc_markqueue_t *mq_master = NULL;
     int master_tid = jl_atomic_load(&gc_master_tid);
     assert(master_tid != -1);
-    mq_master = &gc_all_tls_states[master_tid]->mark_queue;
+    jl_gc_markqueue_t *mq = &ptls->mark_queue;
+    jl_gc_markqueue_t *mq_master = &gc_all_tls_states[master_tid]->mark_queue;
     void *new_obj;
     jl_gc_chunk_t c;
     pop : {
@@ -3024,12 +3023,10 @@ void gc_mark_and_steal(jl_ptls_t ptls)
             }
         }
         // Try to steal chunk from master thread
-        if (mq_master != NULL) {
-            c = gc_chunkqueue_steal_from(mq_master);
-            if (c.cid != GC_empty_chunk) {
-                gc_mark_chunk(ptls, mq, &c);
-                goto pop;
-            }
+        c = gc_chunkqueue_steal_from(mq_master);
+        if (c.cid != GC_empty_chunk) {
+            gc_mark_chunk(ptls, mq, &c);
+            goto pop;
         }
         // Try to steal pointer from random GC thread
         for (int i = 0; i < 4 * jl_n_markthreads; i++) {
@@ -3047,11 +3044,9 @@ void gc_mark_and_steal(jl_ptls_t ptls)
                 goto mark;
         }
         // Try to steal pointer from master thread
-        if (mq_master != NULL) {
-            new_obj = gc_ptr_queue_steal_from(mq_master);
-            if (new_obj != NULL)
-                goto mark;
-        }
+        new_obj = gc_ptr_queue_steal_from(mq_master);
+        if (new_obj != NULL)
+            goto mark;
     }
 }
 

From 313f933370aff4edf1eb8f972964b2e459451066 Mon Sep 17 00:00:00 2001
From: FX Coudert <fxcoudert@gmail.com>
Date: Sat, 30 Mar 2024 15:04:42 +0100
Subject: [PATCH 1204/1315] curl: remove patch (#53892)

This upstream patch needs to be removed because in latest curl, it's
already applied. This currently prevents a build from source. (And I am
wondering why that was not caught?)
---
 deps/curl.mk                   | 11 +----------
 deps/patches/curl-memdup.patch | 24 ------------------------
 2 files changed, 1 insertion(+), 34 deletions(-)
 delete mode 100644 deps/patches/curl-memdup.patch

diff --git a/deps/curl.mk b/deps/curl.mk
index 4314bb89cc739..444334b581fed 100644
--- a/deps/curl.mk
+++ b/deps/curl.mk
@@ -57,16 +57,7 @@ CURL_TLS_CONFIGURE_FLAGS := --with-mbedtls=$(build_prefix)
 endif
 CURL_CONFIGURE_FLAGS += $(CURL_TLS_CONFIGURE_FLAGS)
 
-$(BUILDDIR)/curl-$(CURL_VER)/source-extracted/curl-memdup.patch-applied: $(SRCCACHE)/curl-$(CURL_VER)/source-extracted
-	mkdir -p $(dir $@)
-	cd $(SRCCACHE)/curl-$(CURL_VER) && \
-		patch -p1 -f < $(SRCDIR)/patches/curl-memdup.patch
-	echo 1 > $@
-
-$(SRCCACHE)/curl-$(CURL_VER)/source-patched: $(BUILDDIR)/curl-$(CURL_VER)/source-extracted/curl-memdup.patch-applied
-	echo 1 > $@
-
-$(BUILDDIR)/curl-$(CURL_VER)/build-configured: $(SRCCACHE)/curl-$(CURL_VER)/source-patched
+$(BUILDDIR)/curl-$(CURL_VER)/build-configured: $(SRCCACHE)/curl-$(CURL_VER)/source-extracted
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CURL_CONFIGURE_FLAGS) \
diff --git a/deps/patches/curl-memdup.patch b/deps/patches/curl-memdup.patch
deleted file mode 100644
index 596606027c447..0000000000000
--- a/deps/patches/curl-memdup.patch
+++ /dev/null
@@ -1,24 +0,0 @@
-From 5cc2b016c36aaf5a08e2feb7c068fca5bb0a8052 Mon Sep 17 00:00:00 2001
-From: Daniel Stenberg <daniel@haxx.se>
-Date: Mon, 5 Feb 2024 15:22:08 +0100
-Subject: [PATCH] md4: include strdup.h for the memdup proto
-
-Reported-by: Erik Schnetter
-Fixes #12849
-Closes #12863
----
- lib/md4.c | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/lib/md4.c b/lib/md4.c
-index 067c211e420afd..58dd1166cf924f 100644
---- a/lib/md4.c
-+++ b/lib/md4.c
-@@ -28,6 +28,7 @@
- 
- #include <string.h>
- 
-+#include "strdup.h"
- #include "curl_md4.h"
- #include "warnless.h"
- 

From a3f710e2a35402bb7f7f96f874e6c696dfc911da Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 31 Mar 2024 07:26:46 +0530
Subject: [PATCH 1205/1315] Copy for `CartesianIndices`/`LinearIndices` need
 not materialize (#53901)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Currently,
```julia
julia> C = CartesianIndices((1:2, 1:2))
CartesianIndices((1:2, 1:2))

julia> copy(C)
2×2 Matrix{CartesianIndex{2}}:
 CartesianIndex(1, 1)  CartesianIndex(1, 2)
 CartesianIndex(2, 1)  CartesianIndex(2, 2)
```
However, seeing that a `CartesianIndices` is equivalent to an n-D range,
there doesn't seem to be a need to materialize the result. This PR also
ensures that `copy(C)` returns the same type as `C`.

After this PR:
```julia
julia> C = CartesianIndices((1:2, 1:2))
CartesianIndices((1:2, 1:2))

julia> copy(C)
CartesianIndices((1:2, 1:2))
```
Also, a similar change for `LinearIndices` is added.
---
 base/indices.jl          | 1 +
 base/multidimensional.jl | 4 +++-
 test/abstractarray.jl    | 7 +++++++
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/base/indices.jl b/base/indices.jl
index 9fadff1cdb5de..e629d2d6a03ff 100644
--- a/base/indices.jl
+++ b/base/indices.jl
@@ -565,6 +565,7 @@ function getindex(iter::LinearIndices, i::AbstractRange{<:Integer})
     @boundscheck checkbounds(iter, i)
     @inbounds isa(iter, LinearIndices{1}) ? iter.indices[1][i] : (first(iter):last(iter))[i]
 end
+copy(iter::LinearIndices) = iter
 # More efficient iteration — predominantly for non-vector LinearIndices
 # but one-dimensional LinearIndices must be special-cased to support OffsetArrays
 iterate(iter::LinearIndices{1}, s...) = iterate(axes1(iter.indices[1]), s...)
diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 04274cd79c1aa..5fb2bf8cad582 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -4,7 +4,7 @@
 module IteratorsMD
     import .Base: eltype, length, size, first, last, in, getindex, setindex!,
                   min, max, zero, oneunit, isless, eachindex,
-                  convert, show, iterate, promote_rule, to_indices
+                  convert, show, iterate, promote_rule, to_indices, copy
 
     import .Base: +, -, *, (:)
     import .Base: simd_outer_range, simd_inner_length, simd_index, setindex
@@ -476,6 +476,8 @@ module IteratorsMD
     @inline in(i::CartesianIndex, r::CartesianIndices) = false
     @inline in(i::CartesianIndex{N}, r::CartesianIndices{N}) where {N} = all(map(in, i.I, r.indices))
 
+    copy(iter::CartesianIndices) = iter
+
     simd_outer_range(iter::CartesianIndices{0}) = iter
     function simd_outer_range(iter::CartesianIndices)
         CartesianIndices(tail(iter.indices))
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 48451d43d79c4..a0a6ba6b2229a 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -332,6 +332,13 @@ end
     end
 end
 
+@testset "copy for LinearIndices/CartesianIndices" begin
+    C = CartesianIndices((1:2, 1:4))
+    @test copy(C) === C
+    L = LinearIndices((1:2, 1:4))
+    @test copy(L) === L
+end
+
 # token type on which to dispatch testing methods in order to avoid potential
 # name conflicts elsewhere in the base test suite
 mutable struct TestAbstractArray end

From e9d25ca09382b0f67a4c7770cba08bff3db3cb38 Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Mon, 1 Apr 2024 07:34:51 +0200
Subject: [PATCH 1206/1315] Add `Base.isrelocatable(pkg)` (#53906)

This PR adds a utility function `isrelocatable(pkg)` that can be used to
check if `pkg` is already precompiled and if the associated cachefile is
relocatable.

The reason to implicitly perform the `isprecompiled` check is that the
exact same computation needs to be done to find the right `.ji`.

A `pkg` is said to be relocatable if
1. all `include()` paths are relocatable (they start with `@depot`),
2. all `include_dependency()` paths are relocatable (they start with
`@depot` and `track_content=true` was used to include them).
---
 base/loading.jl       | 83 ++++++++++++++++++++++++++++++++++---------
 test/relocatedepot.jl | 13 +++++++
 2 files changed, 79 insertions(+), 17 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index fd8eba6bed460..a58d3e7502b74 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1678,25 +1678,13 @@ end
 # should sync with the types of arguments of `stale_cachefile`
 const StaleCacheKey = Tuple{Base.PkgId, UInt128, String, String}
 
-"""
-    Base.isprecompiled(pkg::PkgId; ignore_loaded::Bool=false)
-
-Returns whether a given PkgId within the active project is precompiled.
-
-By default this check observes the same approach that code loading takes
-with respect to when different versions of dependencies are currently loaded
-to that which is expected. To ignore loaded modules and answer as if in a
-fresh julia session specify `ignore_loaded=true`.
-
-!!! compat "Julia 1.10"
-    This function requires at least Julia 1.10.
-"""
-function isprecompiled(pkg::PkgId;
+function compilecache_path(pkg::PkgId;
         ignore_loaded::Bool=false,
         stale_cache::Dict{StaleCacheKey,Bool}=Dict{StaleCacheKey, Bool}(),
         cachepaths::Vector{String}=Base.find_all_in_cache_path(pkg),
         sourcepath::Union{String,Nothing}=Base.locate_package(pkg),
         flags::CacheFlags=CacheFlags())
+    path = nothing
     isnothing(sourcepath) && error("Cannot locate source for $(repr("text/plain", pkg))")
     for path_to_try in cachepaths
         staledeps = stale_cachefile(sourcepath, path_to_try, ignore_loaded = true, requested_flags=flags)
@@ -1728,10 +1716,64 @@ function isprecompiled(pkg::PkgId;
             # file might be read-only and then we fail to update timestamp, which is fine
             ex isa IOError || rethrow()
         end
-        return true
+        path = path_to_try
+        break
         @label check_next_path
     end
-    return false
+    return path
+end
+
+"""
+    Base.isprecompiled(pkg::PkgId; ignore_loaded::Bool=false)
+
+Returns whether a given PkgId within the active project is precompiled.
+
+By default this check observes the same approach that code loading takes
+with respect to when different versions of dependencies are currently loaded
+to that which is expected. To ignore loaded modules and answer as if in a
+fresh julia session specify `ignore_loaded=true`.
+
+!!! compat "Julia 1.10"
+    This function requires at least Julia 1.10.
+"""
+function isprecompiled(pkg::PkgId;
+        ignore_loaded::Bool=false,
+        stale_cache::Dict{StaleCacheKey,Bool}=Dict{StaleCacheKey, Bool}(),
+        cachepaths::Vector{String}=Base.find_all_in_cache_path(pkg),
+        sourcepath::Union{String,Nothing}=Base.locate_package(pkg),
+        flags::CacheFlags=CacheFlags())
+    path = compilecache_path(pkg; ignore_loaded, stale_cache, cachepaths, sourcepath, flags)
+    return !isnothing(path)
+end
+
+"""
+    Base.isrelocatable(pkg::PkgId)
+
+Returns whether a given PkgId within the active project is precompiled and the
+associated cache is relocatable.
+
+!!! compat "Julia 1.11"
+    This function requires at least Julia 1.11.
+"""
+function isrelocatable(pkg::PkgId)
+    path = compilecache_path(pkg)
+    isnothing(path) && return false
+    io = open(path, "r")
+    try
+        iszero(isvalid_cache_header(io)) && throw(ArgumentError("Invalid header in cache file $cachefile."))
+        _, (includes, includes_srcfiles, _), _... = _parse_cache_header(io, path)
+        for inc in includes
+            !startswith(inc.filename, "@depot") && return false
+            if inc ∉ includes_srcfiles
+                # its an include_dependency
+                track_content = inc.mtime == -1.0
+                track_content || return false
+            end
+        end
+    finally
+        close(io)
+    end
+    return true
 end
 
 # search for a precompile cache file to load, after some various checks
@@ -3064,7 +3106,7 @@ function resolve_depot(inc::AbstractString)
 end
 
 
-function parse_cache_header(f::IO, cachefile::AbstractString)
+function _parse_cache_header(f::IO, cachefile::AbstractString)
     flags = read(f, UInt8)
     modules = Vector{Pair{PkgId, UInt64}}()
     while true
@@ -3148,6 +3190,13 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
 
     srcfiles = srctext_files(f, srctextpos, includes)
 
+    return modules, (includes, srcfiles, requires), required_modules, srctextpos, prefs, prefs_hash, clone_targets, flags
+end
+
+function parse_cache_header(f::IO, cachefile::AbstractString)
+    modules, (includes, srcfiles, requires), required_modules,
+        srctextpos, prefs, prefs_hash, clone_targets, flags = _parse_cache_header(f, cachefile)
+
     includes_srcfiles = CacheHeaderIncludes[]
     includes_depfiles = CacheHeaderIncludes[]
     for (i, inc) in enumerate(includes)
diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
index b2a539ac330d3..c9c8bd38a245f 100644
--- a/test/relocatedepot.jl
+++ b/test/relocatedepot.jl
@@ -78,8 +78,10 @@ if !test_relocated_depot
             cachefiles = Base.find_all_in_cache_path(pkg)
             rm.(cachefiles, force=true)
             @test Base.isprecompiled(pkg) == false
+            @test Base.isrelocatable(pkg) == false # because not precompiled
             Base.require(pkg)
             @test Base.isprecompiled(pkg, ignore_loaded=true) == true
+            @test Base.isrelocatable(pkg) == true
         end
     end
 
@@ -93,10 +95,12 @@ if !test_relocated_depot
             rm.(cachefiles, force=true)
             rm(joinpath(@__DIR__, pkgname, "src", "foodir"), force=true, recursive=true)
             @test Base.isprecompiled(pkg) == false
+            @test Base.isrelocatable(pkg) == false # because not precompiled
             touch(joinpath(@__DIR__, pkgname, "src", "foo.txt"))
             mkdir(joinpath(@__DIR__, pkgname, "src", "foodir"))
             Base.require(pkg)
             @test Base.isprecompiled(pkg, ignore_loaded=true) == true
+            @test Base.isrelocatable(pkg) == false # because tracked by mtime
         end
     end
 
@@ -110,10 +114,12 @@ if !test_relocated_depot
             rm.(cachefiles, force=true)
             rm(joinpath(@__DIR__, pkgname, "src", "bardir"), force=true, recursive=true)
             @test Base.isprecompiled(pkg) == false
+            @test Base.isrelocatable(pkg) == false # because not precompiled
             touch(joinpath(@__DIR__, pkgname, "src", "bar.txt"))
             mkdir(joinpath(@__DIR__, pkgname, "src", "bardir"))
             Base.require(pkg)
             @test Base.isprecompiled(pkg, ignore_loaded=true) == true
+            @test Base.isrelocatable(pkg) == true
         end
     end
 
@@ -202,6 +208,7 @@ else
             # stdlib should be already precompiled
             pkg = Base.identify_package("DelimitedFiles")
             @test Base.isprecompiled(pkg) == true
+            @test Base.isrelocatable(pkg) == true
         end
     end
 
@@ -213,6 +220,7 @@ else
             push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
             pkg = Base.identify_package(pkgname)
             @test Base.isprecompiled(pkg) == true
+            @test Base.isrelocatable(pkg) == true
         end
     end
 
@@ -224,10 +232,13 @@ else
             push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
             pkg = Base.identify_package(pkgname)
             @test Base.isprecompiled(pkg) == false # moving depot changes mtime of include_dependency
+            @test Base.isrelocatable(pkg) == false # because not precompiled
             Base.require(pkg)
             @test Base.isprecompiled(pkg) == true
+            @test Base.isrelocatable(pkg) == false # because tracked by mtime
             touch(joinpath(@__DIR__, "relocatedepot", "RelocationTestPkg2", "src", "foodir", "foofoo"))
             @test Base.isprecompiled(pkg) == false
+            @test Base.isrelocatable(pkg) == false # because tracked by mtime
         end
     end
 
@@ -239,8 +250,10 @@ else
             push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
             pkg = Base.identify_package(pkgname)
             @test Base.isprecompiled(pkg) == true
+            @test Base.isrelocatable(pkg) == true
             touch(joinpath(@__DIR__, "relocatedepot", "RelocationTestPkg3", "src", "bardir", "barbar"))
             @test Base.isprecompiled(pkg) == false
+            @test Base.isrelocatable(pkg) == false # because not precompiled
         end
     end
 

From 657ce0482d54f9658c9cf4fd3560ca51aafdb03b Mon Sep 17 00:00:00 2001
From: Zentrik <Zentrik@users.noreply.github.com>
Date: Mon, 1 Apr 2024 19:13:18 +0100
Subject: [PATCH 1207/1315] Fix calling LLVM_SIZE on windows (#53902)

Per
https://github.com/JuliaCI/julia-buildkite/pull/224#issuecomment-1474914609,
the path needs to be updated so that `llvm-size` can find `libLLVM.dll`.
---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index d7d25998688c5..0c27216d2f9fb 100644
--- a/Makefile
+++ b/Makefile
@@ -653,7 +653,7 @@ win-extras:
 ifeq ($(USE_SYSTEM_LLVM), 1)
 LLVM_SIZE := llvm-size$(EXE)
 else
-LLVM_SIZE := $(build_depsbindir)/llvm-size$(EXE)
+LLVM_SIZE := PATH=$(build_bindir):$$PATH; $(build_depsbindir)/llvm-size$(EXE)
 endif
 build-stats:
 ifeq ($(USE_BINARYBUILDER_LLVM),1)

From 1fedcab78123f41d285e465632f37f5c85e7701b Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 2 Apr 2024 03:29:32 +0900
Subject: [PATCH 1208/1315] optimizer: allow multiple inlining again (#53911)

Before JuliaLang/julia#52415 we could do multiple rounds of inlining on
IR that had already been inlined, but this was no longer possible. By
removing the assertion that was introduced in JuliaLang/julia#52415,
this commit makes it possible to do multi-inlining once more. Note that
to fully solve this, though, we need to enhance `ir_inline_linetable!`
so it can add new linetables to an inner linetable that's already been
inlined. This commit notes that enhancement as something we need to do
later, leaving it with a TODO comment.
---
 base/compiler/ssair/inlining.jl | 18 +++++------
 base/compiler/ssair/passes.jl   |  2 +-
 test/compiler/inline.jl         | 54 ++++++++++++++++++++++++++-------
 3 files changed, 52 insertions(+), 22 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 164102758a88f..e54d3fd834a27 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -300,7 +300,8 @@ function finish_cfg_inline!(state::CFGInliningState)
     end
 end
 
-function ir_inline_linetable!(debuginfo::DebugInfoStream, inlinee_debuginfo::DebugInfo, inlinee::MethodInstance)
+# TODO append `inlinee_debuginfo` to inner linetable when `inlined_at[2] ≠ 0`
+function ir_inline_linetable!(debuginfo::DebugInfoStream, inlinee_debuginfo::DebugInfo, inlined_at::NTuple{3,Int32})
     # Append the linetable of the inlined function to our edges table
     linetable_offset = 1
     while true
@@ -312,16 +313,14 @@ function ir_inline_linetable!(debuginfo::DebugInfoStream, inlinee_debuginfo::Deb
         end
         linetable_offset += 1
     end
-    return Int32(linetable_offset)
+    return (inlined_at[1], Int32(linetable_offset), Int32(0))
 end
 
 function ir_prepare_inlining!(insert_node!::Inserter, inline_target::Union{IRCode, IncrementalCompact},
-                              ir::IRCode, di::DebugInfo, mi::MethodInstance, inlined_at::Int32, argexprs::Vector{Any})
+                              ir::IRCode, di::DebugInfo, mi::MethodInstance, inlined_at::NTuple{3,Int32}, argexprs::Vector{Any})
     def = mi.def::Method
     debuginfo = inline_target isa IRCode ? inline_target.debuginfo : inline_target.ir.debuginfo
-
-    linetable_offset = ir_inline_linetable!(debuginfo, di, mi)
-    topline = (inlined_at, linetable_offset, Int32(0))
+    topline = new_inlined_at = ir_inline_linetable!(debuginfo, di, inlined_at)
     if should_insert_coverage(def.module, di)
         insert_node!(NewInstruction(Expr(:code_coverage_effect), Nothing, topline))
     end
@@ -343,7 +342,7 @@ function ir_prepare_inlining!(insert_node!::Inserter, inline_target::Union{IRCod
             NewInstruction(Expr(:call, GlobalRef(Core, :getfield), argexprs[1], QuoteNode(:captures)),
             ir.argtypes[1], topline))
     end
-    return SSASubstitute(mi, argexprs, spvals_ssa, (inlined_at, linetable_offset))
+    return SSASubstitute(mi, argexprs, spvals_ssa, new_inlined_at)
 end
 
 function adjust_boundscheck!(inline_compact::IncrementalCompact, idx′::Int, stmt::Expr, boundscheck::Symbol)
@@ -359,8 +358,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
                          item::InliningTodo, boundscheck::Symbol, todo_bbs::Vector{Tuple{Int, Int}})
     # Ok, do the inlining here
     inlined_at = compact.result[idx][:line]
-    @assert inlined_at[2] == 0 "already inlined this instruction"
-    ssa_substitute = ir_prepare_inlining!(InsertHere(compact), compact, item.ir, item.di, item.mi, inlined_at[1], argexprs)
+    ssa_substitute = ir_prepare_inlining!(InsertHere(compact), compact, item.ir, item.di, item.mi, inlined_at, argexprs)
     boundscheck = has_flag(compact.result[idx], IR_FLAG_INBOUNDS) ? :off : boundscheck
 
     # If the iterator already moved on to the next basic block,
@@ -1771,7 +1769,7 @@ struct SSASubstitute
     mi::MethodInstance
     arg_replacements::Vector{Any}
     spvals_ssa::Union{Nothing,SSAValue}
-    inlined_at::NTuple{2,Int32} # TODO: add a map also, so that ssaidx doesn't need to equal inlined_idx?
+    inlined_at::NTuple{3,Int32} # TODO: add a map also, so that ssaidx doesn't need to equal inlined_idx?
 end
 
 function insert_spval!(insert_node!::Inserter, spvals_ssa::SSAValue, spidx::Int, do_isdefined::Bool)
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 946ba9633d366..328f7164a7b93 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -1516,7 +1516,7 @@ function try_inline_finalizer!(ir::IRCode, argexprs::Vector{Any}, idx::Int,
     add_inlining_backedge!(et, mi)
 
     # TODO: Should there be a special line number node for inlined finalizers?
-    inline_at = ir[SSAValue(idx)][:line][1]
+    inline_at = ir[SSAValue(idx)][:line]
     ssa_substitute = ir_prepare_inlining!(InsertBefore(ir, SSAValue(idx)), ir, src, di, mi, inline_at, argexprs)
 
     # TODO: Use the actual inliner here rather than open coding this special purpose inliner.
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 2f916c375218a..3c408b06a87ae 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -1818,23 +1818,55 @@ let src = code_typed1((AtomicMemoryRef{Int},)) do a
     @test count(isinvokemodify(:+), src.code) == 1
 end
 
-
-
 # apply `ssa_inlining_pass` multiple times
-let interp = Core.Compiler.NativeInterpreter()
+func_mul_int(a::Int, b::Int) = Core.Intrinsics.mul_int(a, b)
+multi_inlining1(a::Int, b::Int) = @noinline func_mul_int(a, b)
+let i::Int, continue_::Bool
+    interp = Core.Compiler.NativeInterpreter()
     # check if callsite `@noinline` annotation works
-    ir, = Base.code_ircode((Int,Int); optimize_until="inlining", interp) do a, b
-        @noinline a*b
-    end |> only
-    i = findfirst(isinvoke(:*), ir.stmts.stmt)
+    ir, = only(Base.code_ircode(multi_inlining1, (Int,Int); optimize_until="inlining", interp))
+    i = findfirst(isinvoke(:func_mul_int), ir.stmts.stmt)
     @test i !== nothing
-
-    # ok, now delete the callsite flag, and see the second inlining pass can inline the call
+    # now delete the callsite flag, and see the second inlining pass can inline the call
     @eval Core.Compiler $ir.stmts[$i][:flag] &= ~IR_FLAG_NOINLINE
     inlining = Core.Compiler.InliningState(interp)
     ir = Core.Compiler.ssa_inlining_pass!(ir, inlining, false)
-    @test count(isinvoke(:*), ir.stmts.stmt) == 0
-    @test count(iscall((ir, Core.Intrinsics.mul_int)), ir.stmts.stmt) == 1
+    @test findfirst(isinvoke(:func_mul_int), ir.stmts.stmt) === nothing
+    @test (i = findfirst(iscall((ir, Core.Intrinsics.mul_int)), ir.stmts.stmt)) !== nothing
+    lins = Base.IRShow.buildLineInfoNode(ir.debuginfo, nothing, i)
+    @test (continue_ = length(lins) == 2) # :multi_inlining1 -> :func_mul_int
+    if continue_
+        def1 = lins[1].method
+        @test def1 isa Core.MethodInstance && def1.def.name === :multi_inlining1
+        def2 = lins[2].method
+        @test def2 isa Core.MethodInstance && def2.def.name === :func_mul_int
+    end
+end
+
+call_func_mul_int(a::Int, b::Int) = @noinline func_mul_int(a, b)
+multi_inlining2(a::Int, b::Int) = call_func_mul_int(a, b)
+let i::Int, continue_::Bool
+    interp = Core.Compiler.NativeInterpreter()
+    # check if callsite `@noinline` annotation works
+    ir, = only(Base.code_ircode(multi_inlining2, (Int,Int); optimize_until="inlining", interp))
+    i = findfirst(isinvoke(:func_mul_int), ir.stmts.stmt)
+    @test i !== nothing
+    # now delete the callsite flag, and see the second inlining pass can inline the call
+    @eval Core.Compiler $ir.stmts[$i][:flag] &= ~IR_FLAG_NOINLINE
+    inlining = Core.Compiler.InliningState(interp)
+    ir = Core.Compiler.ssa_inlining_pass!(ir, inlining, false)
+    @test findfirst(isinvoke(:func_mul_int), ir.stmts.stmt) === nothing
+    @test (i = findfirst(iscall((ir, Core.Intrinsics.mul_int)), ir.stmts.stmt)) !== nothing
+    lins = Base.IRShow.buildLineInfoNode(ir.debuginfo, nothing, i)
+    @test_broken (continue_ = length(lins) == 3) # see TODO in `ir_inline_linetable!`
+    if continue_
+        def1 = lins[1].method
+        @test def1 isa Core.MethodInstance && def1.def.name === :multi_inlining2
+        def2 = lins[2].method
+        @test def2 isa Core.MethodInstance && def2.def.name === :call_func_mul_int
+        def3 = lins[3].method
+        @test def3 isa Core.MethodInstance && def3.def.name === :call_func_mul_int
+    end
 end
 
 # Test special purpose inliner for Core.ifelse

From 0ac60b736a26f4b92b67edad16f3e90e1eb32cd8 Mon Sep 17 00:00:00 2001
From: Fons van der Plas <fonsvdplas@gmail.com>
Date: Mon, 1 Apr 2024 23:06:16 +0200
Subject: [PATCH 1209/1315] =?UTF-8?q?More=20emoji=20completions!=20?=
 =?UTF-8?q?=F0=9F=AB=A0=20(#53913)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Happy April fools day! 🪿 Let's celebrate with a very important PR 🩵

This PR updates the REPL completion list with all the fun new emoji from
unicode 15.1! This makes Julia ready for the up-and-coming programmzers
who want the latest trends in emoji coding! 🫶🫶 Fresh new emoji for fresh
new ideas! 🫶🫶

Some of the new emoji include:
- `\:biting_lip:` 🫦 for when the IO code gets *spicy*
- `\:beans:` 🫘 beanssss
- `\:mirror_ball:` 🪩 for parties!
- `\:playground_slide:` 🛝 for really fun code :)

Thanks to @oxinabox for the future-proof script!

Enjoy!!
---
 stdlib/REPL/src/emoji_symbols.jl | 58 ++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/stdlib/REPL/src/emoji_symbols.jl b/stdlib/REPL/src/emoji_symbols.jl
index 49a55c97f6564..d6d4a03321d0a 100644
--- a/stdlib/REPL/src/emoji_symbols.jl
+++ b/stdlib/REPL/src/emoji_symbols.jl
@@ -27,6 +27,7 @@ result = mapfoldr(emoji_data, merge, [
     # overwrite the old with names that changed but still keep old ones that were removed
     "https://raw.githubusercontent.com/iamcal/emoji-data/0f0cf4ea8845eb52d26df2a48c3c31c3b8cad14e/emoji_pretty.json",
     "https://raw.githubusercontent.com/iamcal/emoji-data/e512953312c012f6bd00e3f2ef6bf152ca3710f8/emoji_pretty.json",
+    "https://raw.githubusercontent.com/iamcal/emoji-data/a8174c74675355c8c6a9564516b2e961fe7257ef/emoji_pretty.json",
     ];
     init=Dict()
 )
@@ -132,6 +133,7 @@ const emoji_symbols = Dict(
     "\\:bath:" => "🛀",
     "\\:bathtub:" => "🛁",
     "\\:battery:" => "🔋",
+    "\\:beans:" => "🫘",
     "\\:bear:" => "🐻",
     "\\:bearded_person:" => "🧔",
     "\\:beaver:" => "🦫",
@@ -151,6 +153,7 @@ const emoji_symbols = Dict(
     "\\:bird:" => "🐦",
     "\\:birthday:" => "🎂",
     "\\:bison:" => "🦬",
+    "\\:biting_lip:" => "🫦",
     "\\:black_circle:" => "⚫",
     "\\:black_heart:" => "🖤",
     "\\:black_joker:" => "🃏",
@@ -198,6 +201,7 @@ const emoji_symbols = Dict(
     "\\:broom:" => "🧹",
     "\\:brown_heart:" => "🤎",
     "\\:bubble_tea:" => "🧋",
+    "\\:bubbles:" => "🫧",
     "\\:bucket:" => "🪣",
     "\\:bug:" => "🐛",
     "\\:bulb:" => "💡",
@@ -309,6 +313,7 @@ const emoji_symbols = Dict(
     "\\:cool:" => "🆒",
     "\\:cop:" => "👮",
     "\\:copyright:" => "©",
+    "\\:coral:" => "🪸",
     "\\:corn:" => "🌽",
     "\\:couple:" => "👫",
     "\\:couple_with_heart:" => "💑",
@@ -325,6 +330,7 @@ const emoji_symbols = Dict(
     "\\:crossed_fingers:" => "🤞",
     "\\:crossed_flags:" => "🎌",
     "\\:crown:" => "👑",
+    "\\:crutch:" => "🩼",
     "\\:cry:" => "😢",
     "\\:crying_cat_face:" => "😿",
     "\\:crystal_ball:" => "🔮",
@@ -367,7 +373,9 @@ const emoji_symbols = Dict(
     "\\:dollar:" => "💵",
     "\\:dolls:" => "🎎",
     "\\:dolphin:" => "🐬",
+    "\\:donkey:" => "🫏",
     "\\:door:" => "🚪",
+    "\\:dotted_line_face:" => "🫥",
     "\\:doughnut:" => "🍩",
     "\\:dragon:" => "🐉",
     "\\:dragon_face:" => "🐲",
@@ -397,6 +405,7 @@ const emoji_symbols = Dict(
     "\\:elevator:" => "🛗",
     "\\:elf:" => "🧝",
     "\\:email:" => "✉",
+    "\\:empty_nest:" => "🪹",
     "\\:end:" => "🔚",
     "\\:envelope_with_arrow:" => "📩",
     "\\:euro:" => "💶",
@@ -408,12 +417,16 @@ const emoji_symbols = Dict(
     "\\:expressionless:" => "😑",
     "\\:eyeglasses:" => "👓",
     "\\:eyes:" => "👀",
+    "\\:face_holding_back_tears:" => "🥹",
     "\\:face_palm:" => "🤦",
     "\\:face_vomiting:" => "🤮",
     "\\:face_with_cowboy_hat:" => "🤠",
+    "\\:face_with_diagonal_mouth:" => "🫤",
     "\\:face_with_hand_over_mouth:" => "🤭",
     "\\:face_with_head_bandage:" => "🤕",
     "\\:face_with_monocle:" => "🧐",
+    "\\:face_with_open_eyes_and_hand_over_mouth:" => "🫢",
+    "\\:face_with_peeking_eye:" => "🫣",
     "\\:face_with_raised_eyebrow:" => "🤨",
     "\\:face_with_rolling_eyes:" => "🙄",
     "\\:face_with_symbols_on_mouth:" => "🤬",
@@ -452,10 +465,12 @@ const emoji_symbols = Dict(
     "\\:floppy_disk:" => "💾",
     "\\:flower_playing_cards:" => "🎴",
     "\\:flushed:" => "😳",
+    "\\:flute:" => "🪈",
     "\\:fly:" => "🪰",
     "\\:flying_disc:" => "🥏",
     "\\:flying_saucer:" => "🛸",
     "\\:foggy:" => "🌁",
+    "\\:folding_hand_fan:" => "🪭",
     "\\:fondue:" => "🫕",
     "\\:foot:" => "🦶",
     "\\:football:" => "🏈",
@@ -482,6 +497,7 @@ const emoji_symbols = Dict(
     "\\:ghost:" => "👻",
     "\\:gift:" => "🎁",
     "\\:gift_heart:" => "💝",
+    "\\:ginger_root:" => "🫚",
     "\\:giraffe_face:" => "🦒",
     "\\:girl:" => "👧",
     "\\:glass_of_milk:" => "🥛",
@@ -491,6 +507,7 @@ const emoji_symbols = Dict(
     "\\:goat:" => "🐐",
     "\\:goggles:" => "🥽",
     "\\:golf:" => "⛳",
+    "\\:goose:" => "🪿",
     "\\:gorilla:" => "🦍",
     "\\:grapes:" => "🍇",
     "\\:green_apple:" => "🍏",
@@ -498,6 +515,7 @@ const emoji_symbols = Dict(
     "\\:green_heart:" => "💚",
     "\\:green_salad:" => "🥗",
     "\\:grey_exclamation:" => "❕",
+    "\\:grey_heart:" => "🩶",
     "\\:grey_question:" => "❔",
     "\\:grimacing:" => "😬",
     "\\:grin:" => "😁",
@@ -506,11 +524,14 @@ const emoji_symbols = Dict(
     "\\:guide_dog:" => "🦮",
     "\\:guitar:" => "🎸",
     "\\:gun:" => "🔫",
+    "\\:hair_pick:" => "🪮",
     "\\:haircut:" => "💇",
     "\\:hamburger:" => "🍔",
     "\\:hammer:" => "🔨",
+    "\\:hamsa:" => "🪬",
     "\\:hamster:" => "🐹",
     "\\:hand:" => "✋",
+    "\\:hand_with_index_finger_and_thumb_crossed:" => "🫰",
     "\\:handbag:" => "👜",
     "\\:handball:" => "🤾",
     "\\:handshake:" => "🤝",
@@ -524,12 +545,14 @@ const emoji_symbols = Dict(
     "\\:heart_decoration:" => "💟",
     "\\:heart_eyes:" => "😍",
     "\\:heart_eyes_cat:" => "😻",
+    "\\:heart_hands:" => "🫶",
     "\\:heartbeat:" => "💓",
     "\\:heartpulse:" => "💗",
     "\\:hearts:" => "♥",
     "\\:heavy_check_mark:" => "✔",
     "\\:heavy_division_sign:" => "➗",
     "\\:heavy_dollar_sign:" => "💲",
+    "\\:heavy_equals_sign:" => "🟰",
     "\\:heavy_minus_sign:" => "➖",
     "\\:heavy_multiplication_x:" => "✖",
     "\\:heavy_plus_sign:" => "➕",
@@ -559,16 +582,19 @@ const emoji_symbols = Dict(
     "\\:hugging_face:" => "🤗",
     "\\:hushed:" => "😯",
     "\\:hut:" => "🛖",
+    "\\:hyacinth:" => "🪻",
     "\\:i_love_you_hand_sign:" => "🤟",
     "\\:ice_cream:" => "🍨",
     "\\:ice_cube:" => "🧊",
     "\\:ice_hockey_stick_and_puck:" => "🏒",
     "\\:icecream:" => "🍦",
     "\\:id:" => "🆔",
+    "\\:identification_card:" => "🪪",
     "\\:ideograph_advantage:" => "🉐",
     "\\:imp:" => "👿",
     "\\:inbox_tray:" => "📥",
     "\\:incoming_envelope:" => "📨",
+    "\\:index_pointing_at_the_viewer:" => "🫵",
     "\\:information_desk_person:" => "💁",
     "\\:information_source:" => "ℹ",
     "\\:innocent:" => "😇",
@@ -580,7 +606,9 @@ const emoji_symbols = Dict(
     "\\:japanese_castle:" => "🏯",
     "\\:japanese_goblin:" => "👺",
     "\\:japanese_ogre:" => "👹",
+    "\\:jar:" => "🫙",
     "\\:jeans:" => "👖",
+    "\\:jellyfish:" => "🪼",
     "\\:jigsaw:" => "🧩",
     "\\:joy:" => "😂",
     "\\:joy_cat:" => "😹",
@@ -589,6 +617,7 @@ const emoji_symbols = Dict(
     "\\:kangaroo:" => "🦘",
     "\\:key:" => "🔑",
     "\\:keycap_ten:" => "🔟",
+    "\\:khanda:" => "🪯",
     "\\:kimono:" => "👘",
     "\\:kiss:" => "💋",
     "\\:kissing:" => "😗",
@@ -631,11 +660,14 @@ const emoji_symbols = Dict(
     "\\:left_luggage:" => "🛅",
     "\\:left_right_arrow:" => "↔",
     "\\:leftwards_arrow_with_hook:" => "↩",
+    "\\:leftwards_hand:" => "🫲",
+    "\\:leftwards_pushing_hand:" => "🫷",
     "\\:leg:" => "🦵",
     "\\:lemon:" => "🍋",
     "\\:leo:" => "♌",
     "\\:leopard:" => "🐆",
     "\\:libra:" => "♎",
+    "\\:light_blue_heart:" => "🩵",
     "\\:light_rail:" => "🚈",
     "\\:link:" => "🔗",
     "\\:lion_face:" => "🦁",
@@ -650,10 +682,12 @@ const emoji_symbols = Dict(
     "\\:long_drum:" => "🪘",
     "\\:loop:" => "➿",
     "\\:lotion_bottle:" => "🧴",
+    "\\:lotus:" => "🪷",
     "\\:loud_sound:" => "🔊",
     "\\:loudspeaker:" => "📢",
     "\\:love_hotel:" => "🏩",
     "\\:love_letter:" => "💌",
+    "\\:low_battery:" => "🪫",
     "\\:low_brightness:" => "🔅",
     "\\:luggage:" => "🧳",
     "\\:lungs:" => "🫁",
@@ -679,6 +713,7 @@ const emoji_symbols = Dict(
     "\\:mans_shoe:" => "👞",
     "\\:manual_wheelchair:" => "🦽",
     "\\:maple_leaf:" => "🍁",
+    "\\:maracas:" => "🪇",
     "\\:martial_arts_uniform:" => "🥋",
     "\\:mask:" => "😷",
     "\\:massage:" => "💆",
@@ -688,6 +723,7 @@ const emoji_symbols = Dict(
     "\\:mechanical_leg:" => "🦿",
     "\\:mega:" => "📣",
     "\\:melon:" => "🍈",
+    "\\:melting_face:" => "🫠",
     "\\:memo:" => "📝",
     "\\:menorah_with_nine_branches:" => "🕎",
     "\\:mens:" => "🚹",
@@ -702,6 +738,7 @@ const emoji_symbols = Dict(
     "\\:minibus:" => "🚐",
     "\\:minidisc:" => "💽",
     "\\:mirror:" => "🪞",
+    "\\:mirror_ball:" => "🪩",
     "\\:mobile_phone_off:" => "📴",
     "\\:money_mouth_face:" => "🤑",
     "\\:money_with_wings:" => "💸",
@@ -711,6 +748,7 @@ const emoji_symbols = Dict(
     "\\:monorail:" => "🚝",
     "\\:moon:" => "🌔",
     "\\:moon_cake:" => "🥮",
+    "\\:moose:" => "🫎",
     "\\:mortar_board:" => "🎓",
     "\\:mosque:" => "🕌",
     "\\:mosquito:" => "🦟",
@@ -739,6 +777,7 @@ const emoji_symbols = Dict(
     "\\:necktie:" => "👔",
     "\\:negative_squared_cross_mark:" => "❎",
     "\\:nerd_face:" => "🤓",
+    "\\:nest_with_eggs:" => "🪺",
     "\\:nesting_dolls:" => "🪆",
     "\\:neutral_face:" => "😐",
     "\\:new:" => "🆕",
@@ -800,7 +839,9 @@ const emoji_symbols = Dict(
     "\\:page_facing_up:" => "📄",
     "\\:page_with_curl:" => "📃",
     "\\:pager:" => "📟",
+    "\\:palm_down_hand:" => "🫳",
     "\\:palm_tree:" => "🌴",
+    "\\:palm_up_hand:" => "🫴",
     "\\:palms_up_together:" => "🤲",
     "\\:pancakes:" => "🥞",
     "\\:panda_face:" => "🐼",
@@ -812,6 +853,7 @@ const emoji_symbols = Dict(
     "\\:partly_sunny:" => "⛅",
     "\\:partying_face:" => "🥳",
     "\\:passport_control:" => "🛂",
+    "\\:pea_pod:" => "🫛",
     "\\:peach:" => "🍑",
     "\\:peacock:" => "🦚",
     "\\:peanuts:" => "🥜",
@@ -829,6 +871,7 @@ const emoji_symbols = Dict(
     "\\:person_in_steamy_room:" => "🧖",
     "\\:person_in_tuxedo:" => "🤵",
     "\\:person_with_blond_hair:" => "👱",
+    "\\:person_with_crown:" => "🫅",
     "\\:person_with_headscarf:" => "🧕",
     "\\:person_with_pouting_face:" => "🙎",
     "\\:petri_dish:" => "🧫",
@@ -843,10 +886,12 @@ const emoji_symbols = Dict(
     "\\:pinched_fingers:" => "🤌",
     "\\:pinching_hand:" => "🤏",
     "\\:pineapple:" => "🍍",
+    "\\:pink_heart:" => "🩷",
     "\\:pisces:" => "♓",
     "\\:pizza:" => "🍕",
     "\\:placard:" => "🪧",
     "\\:place_of_worship:" => "🛐",
+    "\\:playground_slide:" => "🛝",
     "\\:pleading_face:" => "🥺",
     "\\:plunger:" => "🪠",
     "\\:point_down:" => "👇",
@@ -866,9 +911,12 @@ const emoji_symbols = Dict(
     "\\:pouch:" => "👝",
     "\\:poultry_leg:" => "🍗",
     "\\:pound:" => "💷",
+    "\\:pouring_liquid:" => "🫗",
     "\\:pouting_cat:" => "😾",
     "\\:pray:" => "🙏",
     "\\:prayer_beads:" => "📿",
+    "\\:pregnant_man:" => "🫃",
+    "\\:pregnant_person:" => "🫄",
     "\\:pregnant_woman:" => "🤰",
     "\\:pretzel:" => "🥨",
     "\\:prince:" => "🤴",
@@ -914,7 +962,10 @@ const emoji_symbols = Dict(
     "\\:rice_cracker:" => "🍘",
     "\\:rice_scene:" => "🎑",
     "\\:right-facing_fist:" => "🤜",
+    "\\:rightwards_hand:" => "🫱",
+    "\\:rightwards_pushing_hand:" => "🫸",
     "\\:ring:" => "💍",
+    "\\:ring_buoy:" => "🛟",
     "\\:ringed_planet:" => "🪐",
     "\\:robot_face:" => "🤖",
     "\\:rock:" => "🪨",
@@ -937,6 +988,7 @@ const emoji_symbols = Dict(
     "\\:sagittarius:" => "♐",
     "\\:sake:" => "🍶",
     "\\:salt:" => "🧂",
+    "\\:saluting_face:" => "🫡",
     "\\:sandal:" => "👡",
     "\\:sandwich:" => "🥪",
     "\\:santa:" => "🎅",
@@ -964,6 +1016,7 @@ const emoji_symbols = Dict(
     "\\:seedling:" => "🌱",
     "\\:selfie:" => "🤳",
     "\\:sewing_needle:" => "🪡",
+    "\\:shaking_face:" => "🫨",
     "\\:shallow_pan_of_food:" => "🥘",
     "\\:shark:" => "🦈",
     "\\:shaved_ice:" => "🍧",
@@ -1124,6 +1177,7 @@ const emoji_symbols = Dict(
     "\\:triangular_ruler:" => "📐",
     "\\:trident:" => "🔱",
     "\\:triumph:" => "😤",
+    "\\:troll:" => "🧌",
     "\\:trolleybus:" => "🚎",
     "\\:trophy:" => "🏆",
     "\\:tropical_drink:" => "🍹",
@@ -1188,6 +1242,7 @@ const emoji_symbols = Dict(
     "\\:wedding:" => "💒",
     "\\:whale2:" => "🐋",
     "\\:whale:" => "🐳",
+    "\\:wheel:" => "🛞",
     "\\:wheelchair:" => "♿",
     "\\:white_check_mark:" => "✅",
     "\\:white_circle:" => "⚪",
@@ -1202,7 +1257,9 @@ const emoji_symbols = Dict(
     "\\:wind_chime:" => "🎐",
     "\\:window:" => "🪟",
     "\\:wine_glass:" => "🍷",
+    "\\:wing:" => "🪽",
     "\\:wink:" => "😉",
+    "\\:wireless:" => "🛜",
     "\\:wolf:" => "🐺",
     "\\:woman:" => "👩",
     "\\:womans_clothes:" => "👚",
@@ -1215,6 +1272,7 @@ const emoji_symbols = Dict(
     "\\:worried:" => "😟",
     "\\:wrench:" => "🔧",
     "\\:wrestlers:" => "🤼",
+    "\\:x-ray:" => "🩻",
     "\\:x:" => "❌",
     "\\:yarn:" => "🧶",
     "\\:yawning_face:" => "🥱",

From 718b98843ffae71309456a03603376ce6bbe58a8 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 2 Apr 2024 11:31:42 +0900
Subject: [PATCH 1210/1315] documentation followup for "invert linetable
 representation (#52415)" (#53781)

- fix up added documents: eb05b4f2acec6ac0ecbc34547716cc77f6cff719
- ~~set up a specific type to capture the 3-set data of `codelocs`:
6afde4b740960f39f49afbd8a8d138e7df3a4fdf~~ (moved to a separate PR)
---
 doc/src/devdocs/ast.md | 47 +++++++++++++++++++-----------------------
 1 file changed, 21 insertions(+), 26 deletions(-)

diff --git a/doc/src/devdocs/ast.md b/doc/src/devdocs/ast.md
index 09361f3754184..a87929e6ff4d6 100644
--- a/doc/src/devdocs/ast.md
+++ b/doc/src/devdocs/ast.md
@@ -696,14 +696,10 @@ A (usually temporary) container for holding lowered source code.
     Statement-level 32 bits flags for each expression in the function.
     See the definition of `jl_code_info_t` in julia.h for more details.
 
-  * `linetable`
-
-    An array of source location objects
-
-  * `codelocs`
+  * `debuginfo`
 
-    An array of integer indices into the `linetable`, giving the location associated
-    with each statement.
+    An object to retrieve source information for each statements, see
+    [How to interpret line numbers in a `CodeInfo` object](@ref).
 
 Optional Fields:
 
@@ -769,7 +765,7 @@ Boolean properties:
     See the documentation of `Base.@assume_effects` for more details.
 
 
-How to interpret line numbers in a `CodeInfo` object:
+#### How to interpret line numbers in a `CodeInfo` object
 
 There are 2 common forms for this data: one used internally that compresses the data somewhat and one used in the compiler.
 They contain the same basic info, but the compiler version is all mutable while the version used internally is not.
@@ -780,7 +776,7 @@ Many consumers may be able to call `Base.IRShow.buildLineInfoNode`,
 
 The definitions of each of these are:
 
-```
+```julia
 struct Core.DebugInfo
     @noinline
     def::Union{Method,MethodInstance,Symbol}
@@ -801,11 +797,11 @@ end
 ```
 
 
-  * `def` : where this DebugInfo was defined (the Method, MethodInstance, or file scope, for example)
+  * `def` : where this `DebugInfo` was defined (the `Method`, `MethodInstance`, or `Symbol` of file scope, for example)
 
   * `linetable`
 
-    Another debuginfo that this was derived from, which contains the actual line numbers,
+    Another `DebugInfo` that this was derived from, which contains the actual line numbers,
     such that this DebugInfo contains only the indexes into it. This avoids making copies,
     as well as makes it possible to track how each individual statement transformed from
     source to optimized, not just the separate line numbers. If `def` is not a Symbol, then
@@ -820,27 +816,26 @@ end
   * `firstline` (when uncompressed to DebugInfoStream)
 
     The line number associated with the `begin` statement (or other keyword such as
-    `function` or `quote`) that delinated where this code definition "starts".
+    `function` or `quote`) that delineates where this code definition "starts".
 
-  * `codelocs` (when uncompressed to DebugInfoStream)
+  * `codelocs` (when uncompressed to `DebugInfoStream`)
 
     A vector of indices, with 3 values for each statement in the IR plus one for the
     starting point of the block, that describe the stacktrace from that point:
      1. the integer index into the `linetable.codelocs` field, giving the
         original location associated with each statement (including its syntactic edges),
         or zero indicating no change to the line number from the previously
-        executed statement (which is not necessarily syntactic or lexical prior).
-       or
-       the line number itself if the `linetable` field is `nothing`
-     2. the integer index into edges, giving the DebugInfo inlined there (or zero if there
-        are no edges).
-     3. (if entry 2 is non-zero) the integer index into edges[].codelocs, to interpret
-        recursively for each function in the inlining stack, or zero indicating to use
-        `edges[].firstline` as the line number.
-
-   Special codes include:
-     - (zero, zero, *) : no change to the line number or edges from the previous statement
+        executed statement (which is not necessarily syntactic or lexical prior),
+        or the line number itself if the `linetable` field is `nothing`.
+     2. the integer index into `edges`, giving the `DebugInfo` inlined there,
+        or zero if there are no edges.
+     3. (if entry 2 is non-zero) the integer index into `edges[].codelocs`,
+        to interpret recursively for each function in the inlining stack,
+        or zero indicating to use `edges[].firstline` as the line number.
+
+    Special codes include:
+     - `(zero, zero, *) `: no change to the line number or edges from the previous statement
        (you may choose to interpret this either syntactically or lexically). The inlining
        depth also might have changed, though most callers should ignore that.
-     - (zero, non-zero, *) : no line number, just edges (usually because of macro-expansion into
-       top-level code)
+     - `(zero, non-zero, *)` : no line number, just edges (usually because of
+       macro-expansion into top-level code).

From d8d384278d6a706e0dc4602bdae1ec1a08908394 Mon Sep 17 00:00:00 2001
From: Florian <florian.atteneder@gmail.com>
Date: Tue, 2 Apr 2024 12:25:09 +0200
Subject: [PATCH 1211/1315] Avoid repeated precompilation when loading from
 non-relocatable cachefiles (#53905)

Fixes
https://github.com/JuliaLang/julia/issues/53859#issuecomment-2027352004,
which was actually fixed before in
https://github.com/JuliaLang/julia/pull/52346, but
https://github.com/JuliaLang/julia/pull/52750 undid that fix.

This PR does not directly address #53859, because I can not reproduce it
atm.

---

The `@depot` resolution logic for `include()` files is adjusted as
follows:

1. (new behavior) If the cache is not relocatable because of an absolute
path, we ignore that path for the depot search. Recompilation will be
triggered by `stale_cachefile()` if that absolute path does not exist.
Previously this caused any `@depot` tags to be not resolved and so
trigger recompilation.
2. (new behavior) If we can't find a depot for a relocatable path, we
still replace it with the depot we found from other files. Recompilation
will be triggered by `stale_cachefile()` because the resolved path does
not exist.
3. (this behavior is kept) We require that relocatable paths all resolve
to the same depot.
4. (new behavior) We no longer use the first matching depot for
replacement, but instead we explicitly check that all resolve to the
same depot. This has two reasons:
- We want to scan all source files anyways in order to provide logs for
1. and 2. above, so the check is free.
- It is possible that a depot might be missing source files. Assume that
we have two depots on `DEPOT_PATH`, `depot_complete` and
`depot_incomplete`.
If `DEPOT_PATH=["depot_complete","depot_incomplete"]` then no
recompilation shall happen, because `depot_complete` will be picked.
If `DEPOT_PATH=["depot_incomplete","depot_complete"]` we trigger
recompilation and hopefully a meaningful error about missing files is
thrown. If we were to just select the first depot we find, then whether
recompilation happens would depend on whether the first relocatable file
resolves to `depot_complete` or `depot_incomplete`.
---
 base/loading.jl                               | 62 +++++++++++++++----
 test/.gitignore                               |  1 +
 test/Makefile                                 |  2 +
 test/RelocationTestPkg4/Project.toml          |  6 ++
 .../src/RelocationTestPkg4.jl                 |  5 ++
 test/relocatedepot.jl                         | 46 ++++++++++++--
 6 files changed, 106 insertions(+), 16 deletions(-)
 create mode 100644 test/RelocationTestPkg4/Project.toml
 create mode 100644 test/RelocationTestPkg4/src/RelocationTestPkg4.jl

diff --git a/base/loading.jl b/base/loading.jl
index a58d3e7502b74..882ae3a68a836 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -3199,7 +3199,7 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
 
     includes_srcfiles = CacheHeaderIncludes[]
     includes_depfiles = CacheHeaderIncludes[]
-    for (i, inc) in enumerate(includes)
+    for inc in includes
         if inc.filename ∈ srcfiles
             push!(includes_srcfiles, inc)
         else
@@ -3207,23 +3207,63 @@ function parse_cache_header(f::IO, cachefile::AbstractString)
         end
     end
 
-    # determine depot for @depot replacement for include() files and include_dependency() files separately
-    srcfiles_depot = resolve_depot(first(srcfiles))
-    if srcfiles_depot === :no_depot_found
-        @debug("Unable to resolve @depot tag include() files from cache file $cachefile", srcfiles, _group=:relocatable)
-    elseif srcfiles_depot === :not_relocatable
-        @debug("include() files from $cachefile are not relocatable", srcfiles, _group=:relocatable)
-    else
+
+    # The @depot resolution logic for include() files:
+    # 1. If the cache is not relocatable because of an absolute path,
+    #    we ignore that path for the depot search.
+    #    Recompilation will be triggered by stale_cachefile() if that absolute path does not exist.
+    # 2. If we can't find a depot for a relocatable path,
+    #    we still replace it with the depot we found from other files.
+    #    Recompilation will be triggered by stale_cachefile() because the resolved path does not exist.
+    # 3. We require that relocatable paths all resolve to the same depot.
+    # 4. We explicitly check that all relocatable paths resolve to the same depot. This has two reasons:
+    #    - We want to scan all source files in order to provide logs for 1. and 2. above.
+    #    - It is possible that a depot might be missing source files.
+    #      Assume that we have two depots on DEPOT_PATH, depot_complete and depot_incomplete.
+    #      If DEPOT_PATH=["depot_complete","depot_incomplete"] then no recompilation shall happen,
+    #      because depot_complete will be picked.
+    #      If DEPOT_PATH=["depot_incomplete","depot_complete"] we trigger recompilation and
+    #      hopefully a meaningful error about missing files is thrown.
+    #      If we were to just select the first depot we find, then whether recompilation happens would
+    #      depend on whether the first relocatable file resolves to depot_complete or depot_incomplete.
+    srcdepot = nothing
+    any_not_relocatable = false
+    any_no_depot_found = false
+    multiple_depots_found = false
+    for src in srcfiles
+        depot = resolve_depot(src)
+        if depot === :not_relocatable
+            any_not_relocatable = true
+        elseif depot === :no_depot_found
+            any_no_depot_found = true
+        elseif isnothing(srcdepot)
+            srcdepot = depot
+        elseif depot != srcdepot
+            multiple_depots_found = true
+        end
+    end
+    if any_no_depot_found
+        @debug("Unable to resolve @depot tag for at least one include() file from cache file $cachefile", srcfiles, _group=:relocatable)
+    end
+    if any_not_relocatable
+        @debug("At least one include() file from $cachefile is not relocatable", srcfiles, _group=:relocatable)
+    end
+    if multiple_depots_found
+        @debug("Some include() files from $cachefile are distributed over multiple depots", srcfiles, _group=:relocatable)
+    elseif !isnothing(srcdepot)
         for inc in includes_srcfiles
-            inc.filename = restore_depot_path(inc.filename, srcfiles_depot)
+            inc.filename = restore_depot_path(inc.filename, srcdepot)
         end
     end
+
+    # unlike include() files, we allow each relocatable include_dependency() file to resolve
+    # to a separate depot, #52161
     for inc in includes_depfiles
         depot = resolve_depot(inc.filename)
         if depot === :no_depot_found
-            @debug("Unable to resolve @depot tag for include_dependency() file $(inc.filename) from cache file $cachefile", srcfiles, _group=:relocatable)
+            @debug("Unable to resolve @depot tag for include_dependency() file $(inc.filename) from cache file $cachefile", _group=:relocatable)
         elseif depot === :not_relocatable
-            @debug("include_dependency() file $(inc.filename) from $cachefile is not relocatable", srcfiles, _group=:relocatable)
+            @debug("include_dependency() file $(inc.filename) from $cachefile is not relocatable", _group=:relocatable)
         else
             inc.filename = restore_depot_path(inc.filename, depot)
         end
diff --git a/test/.gitignore b/test/.gitignore
index fc55a0df3a173..20bf199b87c74 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -4,3 +4,4 @@
 /libccalltest.*
 /relocatedepot
 /RelocationTestPkg2/src/foo.txt
+/RelocationTestPkg*/Manifest.toml
diff --git a/test/Makefile b/test/Makefile
index 31f8f20615d7a..1b9cb377c943d 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -43,6 +43,7 @@ relocatedepot:
 	@cp -R $(SRCDIR)/RelocationTestPkg1 $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg2 $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg3 $(SRCDIR)/relocatedepot
+	@cp -R $(SRCDIR)/RelocationTestPkg4 $(SRCDIR)/relocatedepot
 	@cd $(SRCDIR) && \
 	$(call PRINT_JULIA, $(call spawn,RELOCATEDEPOT="" $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl $@)
 
@@ -55,6 +56,7 @@ revise-relocatedepot: revise-% :
 	@cp -R $(SRCDIR)/RelocationTestPkg1 $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg2 $(SRCDIR)/relocatedepot
 	@cp -R $(SRCDIR)/RelocationTestPkg3 $(SRCDIR)/relocatedepot
+	@cp -R $(SRCDIR)/RelocationTestPkg4 $(SRCDIR)/relocatedepot
 	@cd $(SRCDIR) && \
 	$(call PRINT_JULIA, $(call spawn,RELOCATEDEPOT="" $(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no --depwarn=error ./runtests.jl --revise $*)
 
diff --git a/test/RelocationTestPkg4/Project.toml b/test/RelocationTestPkg4/Project.toml
new file mode 100644
index 0000000000000..8334a684f064e
--- /dev/null
+++ b/test/RelocationTestPkg4/Project.toml
@@ -0,0 +1,6 @@
+name = "RelocationTestPkg4"
+uuid = "d423d817-d7e9-49ac-b245-9d9d6db0b429"
+version = "0.1.0"
+
+[deps]
+RelocationTestPkg1 = "854e1adb-5a97-46bf-a391-1cfe05ac726d"
diff --git a/test/RelocationTestPkg4/src/RelocationTestPkg4.jl b/test/RelocationTestPkg4/src/RelocationTestPkg4.jl
new file mode 100644
index 0000000000000..d24a51d19a918
--- /dev/null
+++ b/test/RelocationTestPkg4/src/RelocationTestPkg4.jl
@@ -0,0 +1,5 @@
+module RelocationTestPkg4
+
+greet() = print("Hello World!")
+
+end # module RelocationTestPkg4
diff --git a/test/relocatedepot.jl b/test/relocatedepot.jl
index c9c8bd38a245f..039d422c35e25 100644
--- a/test/relocatedepot.jl
+++ b/test/relocatedepot.jl
@@ -17,10 +17,12 @@ function test_harness(@nospecialize(fn); empty_load_path=true, empty_depot_path=
     end
 end
 
-# We test relocation with three dummy pkgs:
-# - RelocationTestPkg1 - no include_dependency
-# - RelocationTestPkg2 - with include_dependency tracked by `mtime`
-# - RelocationTestPkg3 - with include_dependency tracked by content
+# We test relocation with these dummy pkgs:
+# - RelocationTestPkg1 - pkg with no include_dependency
+# - RelocationTestPkg2 - pkg with include_dependency tracked by `mtime`
+# - RelocationTestPkg3 - pkg with include_dependency tracked by content
+# - RelocationTestPkg4 - pkg with no dependencies; will be compiled such that the pkgimage is
+#                        not relocatable, but no repeated recompilation happens upon loading
 
 if !test_relocated_depot
 
@@ -123,6 +125,27 @@ if !test_relocated_depot
         end
     end
 
+    @testset "precompile RelocationTestPkg4" begin
+        # test for #52346 and https://github.com/JuliaLang/julia/issues/53859#issuecomment-2027352004
+        # If a pkgimage is not relocatable, no repeated precompilation should occur.
+        pkgname = "RelocationTestPkg4"
+        test_harness(empty_depot_path=false) do
+            push!(LOAD_PATH, @__DIR__)
+            # skip this dir to make the pkgimage not relocatable
+            filter!(DEPOT_PATH) do depot
+                !startswith(@__DIR__, depot)
+            end
+            pkg = Base.identify_package(pkgname)
+            cachefiles = Base.find_all_in_cache_path(pkg)
+            rm.(cachefiles, force=true)
+            @test Base.isprecompiled(pkg) == false
+            @test Base.isrelocatable(pkg) == false # because not precompiled
+            Base.require(pkg)
+            @test Base.isprecompiled(pkg, ignore_loaded=true) == true
+            @test Base.isrelocatable(pkg) == false
+        end
+    end
+
     @testset "#52161" begin
         # Take the src files from two pkgs Example1 and Example2,
         # which are each located in depot1 and depot2, respectively, and
@@ -246,7 +269,7 @@ else
         pkgname = "RelocationTestPkg3"
         test_harness() do
             push!(LOAD_PATH, joinpath(@__DIR__, "relocatedepot"))
-            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot"))
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot")) # required to find src files
             push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
             pkg = Base.identify_package(pkgname)
             @test Base.isprecompiled(pkg) == true
@@ -257,4 +280,17 @@ else
         end
     end
 
+    @testset "load RelocationTestPkg4 from test/relocatedepot" begin
+        pkgname = "RelocationTestPkg4"
+        test_harness() do
+            push!(LOAD_PATH, @__DIR__, "relocatedepot")
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot")) # required to find src files
+            push!(DEPOT_PATH, joinpath(@__DIR__, "relocatedepot", "julia")) # contains cache file
+            pkg = Base.identify_package(pkgname)
+            # precompiled but not relocatable
+            @test Base.isprecompiled(pkg) == true
+            @test Base.isrelocatable(pkg) == false
+        end
+    end
+
 end

From e99627f0d13846de93bc7f11c50e4b5414b1b1e4 Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Tue, 2 Apr 2024 18:04:14 -0400
Subject: [PATCH 1212/1315] Explicitly call out reverse ranges in `:` and
 `range` docstring (#53626)

---
 base/range.jl | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/base/range.jl b/base/range.jl
index 4f92b305564cd..b987e5f50c7f7 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -32,7 +32,7 @@ _colon(::Any, ::Any, start::T, step, stop::T) where {T} =
     (:)(start, [step], stop)
 
 Range operator. `a:b` constructs a range from `a` to `b` with a step size
-equal to 1, which produces:
+equal to +1, which produces:
 
 * a [`UnitRange`](@ref) when `a` and `b` are integers, or
 * a [`StepRange`](@ref) when `a` and `b` are characters, or
@@ -41,6 +41,9 @@ equal to 1, which produces:
 `a:s:b` is similar but uses a step size of `s` (a [`StepRange`](@ref) or
 [`StepRangeLen`](@ref)). See also [`range`](@ref) for more control.
 
+To create a descending range, use `reverse(a:b)` or a negative step size, e.g. `b:-1:a`.
+Otherwise, when `b < a`, an empty range will be constructed and normalized to `a:a-1`.
+
 The operator `:` is also used in indexing to select whole dimensions, e.g. in `A[:, 1]`.
 
 `:` is also used to [`quote`](@ref) code, e.g. `:(x + y) isa Expr` and `:x isa Symbol`.
@@ -66,8 +69,12 @@ Mathematically a range is uniquely determined by any three of `start`, `step`, `
 Valid invocations of range are:
 * Call `range` with any three of `start`, `step`, `stop`, `length`.
 * Call `range` with two of `start`, `stop`, `length`. In this case `step` will be assumed
-  to be one. If both arguments are Integers, a [`UnitRange`](@ref) will be returned.
-* Call `range` with one of `stop` or `length`. `start` and `step` will be assumed to be one.
+  to be positive one. If both arguments are Integers, a [`UnitRange`](@ref) will be returned.
+* Call `range` with one of `stop` or `length`. `start` and `step` will be assumed to be positive one.
+
+To construct a descending range, specify a negative step size, e.g. `range(5, 1; step = -1)` => [5,4,3,2,1]. Otherwise,
+a `stop` value less than the `start` value, with the default `step` of `+1`, constructs an empty range. Empty ranges
+are normalized such that the `stop` is one less than the `start`, e.g. `range(5, 1) == 5:4`.
 
 See Extended Help for additional details on the returned type.
 See also [`logrange`](@ref) for logarithmically spaced points.

From b70e1aec6b10b9a1d678b24d41d83ada55a70941 Mon Sep 17 00:00:00 2001
From: Paul Annesley <paul@annesley.cc>
Date: Wed, 3 Apr 2024 10:15:04 +1030
Subject: [PATCH 1213/1315] Buildkite typos in tests/buildkitetestjson.jl etc
 fixed

---
 test/buildkitetestjson.jl | 4 ++--
 test/runtests.jl          | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/buildkitetestjson.jl b/test/buildkitetestjson.jl
index 8410913e48ef2..dc3b13ebf4e89 100644
--- a/test/buildkitetestjson.jl
+++ b/test/buildkitetestjson.jl
@@ -1,9 +1,9 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-# Convert test(set) results to a Buildkit-compatible JSON representation.
+# Convert test(set) results to a Buildkite-compatible JSON representation.
 # Based on <https://buildkite.com/docs/test-analytics/importing-json#json-test-results-data-reference>.
 
-module BuildKiteTestJSON
+module BuildkiteTestJSON
 
 using Test
 using Dates
diff --git a/test/runtests.jl b/test/runtests.jl
index 7c6fa8480d98e..c46472ac93fa8 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -11,7 +11,7 @@ include("choosetests.jl")
 include("testenv.jl")
 include("buildkitetestjson.jl")
 
-using .BuildKiteTestJSON
+using .BuildkiteTestJSON
 
 (; tests, net_on, exit_on_error, use_revise, seed) = choosetests(ARGS)
 tests = unique(tests)

From 1256e3eb4f497c21fd40aef44feb6f41f893896e Mon Sep 17 00:00:00 2001
From: Paul Annesley <paul@annesley.cc>
Date: Tue, 12 Mar 2024 22:45:02 +1030
Subject: [PATCH 1214/1315] Buildkite Test Analytics: fix failure_expanded

The `failure_expanded` attribute of a test result is an _array_ of
objects, not a single object.

I believe this is to support the possibility of multiple failure reasons
in a single test case, although I'm not sure if that's used anywhere.

https://buildkite.com/docs/test-analytics/importing-json#json-test-results-data-reference-test-result-objects
---
 test/buildkitetestjson.jl | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/buildkitetestjson.jl b/test/buildkitetestjson.jl
index dc3b13ebf4e89..49c47e0d8f151 100644
--- a/test/buildkitetestjson.jl
+++ b/test/buildkitetestjson.jl
@@ -105,9 +105,9 @@ function add_failure_info!(data::Dict{String, Any}, result::Test.Result)
         data["failure_reason"] = if result.test_type === :test_error
             if occursin("\nStacktrace:\n", result.backtrace)
                 err, trace = split(result.backtrace, "\nStacktrace:\n", limit=2)
-                data["failure_expanded"] = Dict{String, Any}(
-                    "expanded" => split(err, '\n'),
-                    "backtrace" => split(trace, '\n'))
+                data["failure_expanded"] =
+                    [Dict{String,Any}("expanded" => split(err, '\n'),
+                                      "backtrace" => split(trace, '\n'))]
             end
             "Exception (unexpectedly) thrown during test"
         elseif result.test_type === :test_nonbool

From 94f887bb5cdeb61a648b05bf8bfe5d37ecbe00a4 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Tue, 2 Apr 2024 21:00:42 -0500
Subject: [PATCH 1215/1315] note that REPL doesn't show "nothing" values
 (#53930)

It seemed worth documenting that display of `nothing` is suppressed by
the REPL (and similar environments, e.g. IJulia).
---
 base/docs/basedocs.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 447cbe000faa6..cc2d32f6b3deb 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -1521,6 +1521,8 @@ Nothing
 The singleton instance of type [`Nothing`](@ref), used by convention when there is no value to return
 (as in a C `void` function) or when a variable or field holds no value.
 
+A return value of `nothing` is not displayed by the REPL and similar interactive environments.
+
 See also: [`isnothing`](@ref), [`something`](@ref), [`missing`](@ref).
 """
 nothing

From 854170a092bc800090357e89d81fc2e672269551 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 3 Apr 2024 13:16:03 +0900
Subject: [PATCH 1216/1315] minor followups on the linetable changes (#53921)

- remove unnecessary `Core.` accessors to `DebugInfo` within
`Core.Compiler`
- improve the type of `DebugInfoStream`'s `edges` field
---
 base/compiler/ssair/ir.jl   | 25 +++++++++++++------------
 base/compiler/ssair/show.jl |  6 +++---
 base/compiler/typeinfer.jl  |  4 ++--
 3 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index c23f89e01f664..222ec91f7c01a 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -177,40 +177,41 @@ end
 # mutable version of the compressed DebugInfo
 mutable struct DebugInfoStream
     def::Union{MethodInstance,Symbol,Nothing}
-    linetable::Union{Nothing,Core.DebugInfo}
-    edges::Vector{Any} # Vector{Core.DebugInfo}
+    linetable::Union{Nothing,DebugInfo}
+    edges::Vector{DebugInfo}
     firstline::Int32 # the starting line for this block (specified by having an index of 0)
     codelocs::Vector{Int32} # for each statement:
         # index into linetable (if defined), else a line number (in the file represented by def)
         # then index into edges
         # then index into edges[linetable]
     function DebugInfoStream(codelocs::Vector{Int32})
-        return new(nothing, nothing, [], 0, codelocs)
+        return new(nothing, nothing, DebugInfo[], 0, codelocs)
     end
-    #DebugInfoStream(def::Union{MethodInstance,Nothing}, di::DebugInfo, nstmts::Int) =
-    #    if debuginfo_file1(di.def) === debuginfo_file1(di.def)
-    #        new(def, di.linetable, Core.svec(di.edges...), getdebugidx(di, 0),
-    #            ccall(:jl_uncompress_codelocs, Any, (Any, Int), di.codelocs, nstmts)::Vector{Int32})
-    #    else
+    # DebugInfoStream(def::Union{MethodInstance,Nothing}, di::DebugInfo, nstmts::Int) =
+    #     if debuginfo_file1(di.def) === debuginfo_file1(di.def)
+    #         new(def, di.linetable, Core.svec(di.edges...), getdebugidx(di, 0),
+    #             ccall(:jl_uncompress_codelocs, Any, (Any, Int), di.codelocs, nstmts)::Vector{Int32})
+    #     else
     function DebugInfoStream(def::Union{MethodInstance,Nothing}, di::DebugInfo, nstmts::Int)
         codelocs = zeros(Int32, nstmts * 3)
         for i = 1:nstmts
             codelocs[3i - 2] = i
         end
-        return new(def, di, Vector{Any}(), 0, codelocs)
+        return new(def, di, DebugInfo[], 0, codelocs)
     end
     global copy(di::DebugInfoStream) = new(di.def, di.linetable, di.edges, di.firstline, di.codelocs)
 end
 
 Core.DebugInfo(di::DebugInfoStream, nstmts::Int) =
-    Core.DebugInfo(something(di.def), di.linetable, Core.svec(di.edges...),
+    DebugInfo(something(di.def), di.linetable, Core.svec(di.edges...),
         ccall(:jl_compress_codelocs, Any, (Int32, Any, Int), di.firstline, di.codelocs, nstmts)::String)
 
-getdebugidx(debuginfo::Core.DebugInfo, pc::Int) = ccall(:jl_uncompress1_codeloc, NTuple{3,Int32}, (Any, Int), debuginfo.codelocs, pc)
+getdebugidx(debuginfo::DebugInfo, pc::Int) =
+    ccall(:jl_uncompress1_codeloc, NTuple{3,Int32}, (Any, Int), debuginfo.codelocs, pc)
 
 function getdebugidx(debuginfo::DebugInfoStream, pc::Int)
     if 3 <= 3pc <= length(debuginfo.codelocs)
-        return (debuginfo.codelocs[3pc - 2], debuginfo.codelocs[3pc - 1], debuginfo.codelocs[3pc - 0])
+        return (debuginfo.codelocs[3pc-2], debuginfo.codelocs[3pc-1], debuginfo.codelocs[3pc-0])
     elseif pc == 0
         return (Int32(debuginfo.firstline), Int32(0), Int32(0))
     else
diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl
index 2c0385a808801..cfcd2ce8f3d2b 100644
--- a/base/compiler/ssair/show.jl
+++ b/base/compiler/ssair/show.jl
@@ -327,7 +327,7 @@ Base.show(io::IO, code::Union{IRCode, IncrementalCompact}) = show_ir(io, code)
 lineinfo_disabled(io::IO, linestart::String, idx::Int) = ""
 
 # utility function to extract the file name from a DebugInfo object
-function debuginfo_file1(debuginfo::Union{Core.DebugInfo,DebugInfoStream})
+function debuginfo_file1(debuginfo::Union{DebugInfo,DebugInfoStream})
     def = debuginfo.def
     if def isa MethodInstance
         def = def.def
@@ -342,7 +342,7 @@ function debuginfo_file1(debuginfo::Union{Core.DebugInfo,DebugInfoStream})
 end
 
 # utility function to extract the first line number and file of a block of code
-function debuginfo_firstline(debuginfo::Union{Core.DebugInfo,DebugInfoStream})
+function debuginfo_firstline(debuginfo::Union{DebugInfo,DebugInfoStream})
     linetable = debuginfo.linetable
     while linetable != nothing
         debuginfo = linetable
@@ -375,7 +375,7 @@ function append_scopes!(scopes::Vector{LineInfoNode}, pc::Int, debuginfo, @nospe
             line < 0 && (doupdate = false; line = 0) # broken debug info
             push!(scopes, LineInfoNode(def, debuginfo_file1(debuginfo), Int32(line)))
         else
-            doupdate = append_scopes!(scopes, line, debuginfo.linetable::Core.DebugInfo, def) && doupdate
+            doupdate = append_scopes!(scopes, line, debuginfo.linetable::DebugInfo, def) && doupdate
         end
         inl_to == 0 && return doupdate
         def = :var"macro expansion"
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index b77d2e83d5780..02ec583316de0 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -328,7 +328,7 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
     end
     # n.b. relocatability = (isa(inferred_result, String) && inferred_result[end]) || inferred_result === nothing
     if !@isdefined edges
-        edges = Core.DebugInfo(result.linfo)
+        edges = DebugInfo(result.linfo)
     end
     return CodeInstance(result.linfo, owner,
         widenconst(result_type), widenconst(result.exc_result), rettype_const, inferred_result,
@@ -923,7 +923,7 @@ function codeinfo_for_const(interp::AbstractInterpreter, mi::MethodInstance, @no
     tree.slotnames = ccall(:jl_uncompress_argnames, Vector{Symbol}, (Any,), method.slot_syms)
     tree.slotflags = fill(0x00, nargs)
     tree.ssavaluetypes = 1
-    tree.debuginfo = Core.DebugInfo(mi)
+    tree.debuginfo = DebugInfo(mi)
     tree.ssaflags = UInt32[0]
     set_inlineable!(tree, true)
     tree.parent = mi

From a69aa30478ac9beda594235ff6f2e39549fdb752 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 3 Apr 2024 05:24:45 -0400
Subject: [PATCH 1217/1315] oc: code_typed support for optimized opaque
 closures (#53929)

Reflection version of #53878.

---------

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
---
 base/reflection.jl                      | 38 ++++++++++++++++++-------
 stdlib/InteractiveUtils/src/codeview.jl |  6 ++--
 test/opaque_closure.jl                  |  9 +++++-
 3 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/base/reflection.jl b/base/reflection.jl
index 63909b4159877..2df713a531fae 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -1584,7 +1584,7 @@ julia> code_typed(+, (Float64, Float64))
 """
 function code_typed(@nospecialize(f), @nospecialize(types=default_tt(f)); kwargs...)
     if isa(f, Core.OpaqueClosure)
-        return code_typed_opaque_closure(f; kwargs...)
+        return code_typed_opaque_closure(f, types; kwargs...)
     end
     tt = signature_type(f, types)
     return code_typed_by_type(tt; kwargs...)
@@ -1639,20 +1639,38 @@ function code_typed_by_type(@nospecialize(tt::Type);
     return asts
 end
 
-function get_oc_code_rt(@nospecialize(oc::Core.OpaqueClosure))
-    ccall(:jl_is_in_pure_context, Bool, ()) && error("code reflection cannot be used from generated functions")
+function get_oc_code_rt(oc::Core.OpaqueClosure, types, optimize::Bool)
+    @nospecialize oc types
+    ccall(:jl_is_in_pure_context, Bool, ()) &&
+        error("code reflection cannot be used from generated functions")
     m = oc.source
     if isa(m, Method)
-        code = _uncompressed_ir(m)
-        return Pair{CodeInfo,Any}(code, typeof(oc).parameters[2])
+        if isdefined(m, :source)
+            if optimize
+                tt = Tuple{typeof(oc.captures), to_tuple_type(types).parameters...}
+                mi = Core.Compiler.specialize_method(m, tt, Core.svec())
+                interp = Core.Compiler.NativeInterpreter(m.primary_world)
+                return Core.Compiler.typeinf_code(interp, mi, optimize)
+            else
+                code = _uncompressed_ir(m)
+                return Pair{CodeInfo,Any}(code, typeof(oc).parameters[2])
+            end
+        else
+            # OC constructed from optimized IR
+            codeinst = m.specializations.cache
+            return Pair{CodeInfo, Any}(codeinst.inferred, codeinst.rettype)
+        end
     else
         error("encountered invalid Core.OpaqueClosure object")
     end
 end
 
-function code_typed_opaque_closure(@nospecialize(oc::Core.OpaqueClosure);
-                                   debuginfo::Symbol=:default, _...)
-    (code, rt) = get_oc_code_rt(oc)
+function code_typed_opaque_closure(oc::Core.OpaqueClosure, types;
+                                   debuginfo::Symbol=:default,
+                                   optimize::Bool=true,
+                                   _...)
+    @nospecialize oc types
+    (code, rt) = get_oc_code_rt(oc, types, optimize)
     debuginfo === :none && remove_linenums!(code)
     return Any[Pair{CodeInfo,Any}(code, rt)]
 end
@@ -1807,7 +1825,7 @@ function return_types(@nospecialize(f), @nospecialize(types=default_tt(f));
                       interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
     check_generated_context(world)
     if isa(f, Core.OpaqueClosure)
-        _, rt = only(code_typed_opaque_closure(f))
+        _, rt = only(code_typed_opaque_closure(f, types))
         return Any[rt]
     end
     if isa(f, Core.Builtin)
@@ -1876,7 +1894,7 @@ function infer_return_type(@nospecialize(f), @nospecialize(types=default_tt(f));
                            interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world))
     check_generated_context(world)
     if isa(f, Core.OpaqueClosure)
-        return last(only(code_typed_opaque_closure(f)))
+        return last(only(code_typed_opaque_closure(f, types)))
     end
     if isa(f, Core.Builtin)
         return _builtin_return_type(interp, f, types)
diff --git a/stdlib/InteractiveUtils/src/codeview.jl b/stdlib/InteractiveUtils/src/codeview.jl
index d03e2b27a2286..b242dea8e006e 100644
--- a/stdlib/InteractiveUtils/src/codeview.jl
+++ b/stdlib/InteractiveUtils/src/codeview.jl
@@ -143,7 +143,7 @@ See the [`@code_warntype`](@ref man-code-warntype) section in the Performance Ti
 
 See also: [`@code_warntype`](@ref), [`code_typed`](@ref), [`code_lowered`](@ref), [`code_llvm`](@ref), [`code_native`](@ref).
 """
-function code_warntype(io::IO, @nospecialize(f), @nospecialize(t=Base.default_tt(f));
+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),
                        debuginfo::Symbol=:default, optimize::Bool=false, kwargs...)
@@ -154,10 +154,10 @@ function code_warntype(io::IO, @nospecialize(f), @nospecialize(t=Base.default_tt
     nargs::Int = 0
     if isa(f, Core.OpaqueClosure)
         isa(f.source, Method) && (nargs = f.nargs)
-        print_warntype_codeinfo(io, Base.code_typed_opaque_closure(f)[1]..., nargs; lineprinter)
+        print_warntype_codeinfo(io, Base.code_typed_opaque_closure(f, tt)[1]..., nargs; lineprinter)
         return nothing
     end
-    matches = Base._methods_by_ftype(Base.signature_type(f, t), #=lim=#-1, world)::Vector
+    matches = Base._methods_by_ftype(Base.signature_type(f, tt), #=lim=#-1, world)::Vector
     for match in matches
         match = match::Core.MethodMatch
         (src, rettype) = Core.Compiler.typeinf_code(interp, match, optimize)
diff --git a/test/opaque_closure.jl b/test/opaque_closure.jl
index cb7576ee656be..490ff282b7a53 100644
--- a/test/opaque_closure.jl
+++ b/test/opaque_closure.jl
@@ -239,7 +239,13 @@ let foo::Int = 42
 end
 
 let oc = @opaque a->sin(a)
-    @test length(code_typed(oc, (Int,))) == 1
+    let opt = code_typed(oc, (Int,))
+        @test length(opt) == 1
+        @test opt[1][2] === Float64
+    end
+    let unopt = code_typed(oc, (Int,); optimize=false)
+        @test length(unopt) == 1
+    end
 end
 
 # constructing an opaque closure from IRCode
@@ -257,6 +263,7 @@ end
 let ir = first(only(Base.code_ircode(sin, (Int,))))
     @test OpaqueClosure(ir)(42) == sin(42)
     @test OpaqueClosure(ir)(42) == sin(42) # the `OpaqueClosure(::IRCode)` constructor should be non-destructive
+    @test length(code_typed(OpaqueClosure(ir))) == 1
     ir = first(only(Base.code_ircode(sin, (Float64,))))
     @test OpaqueClosure(ir)(42.) == sin(42.)
     @test OpaqueClosure(ir)(42.) == sin(42.) # the `OpaqueClosure(::IRCode)` constructor should be non-destructive

From c74914776e8db17f129a858bd15b784aa765a4bf Mon Sep 17 00:00:00 2001
From: crazehang <165746307+crazehang@users.noreply.github.com>
Date: Wed, 3 Apr 2024 22:51:59 +0800
Subject: [PATCH 1218/1315] fix typo in comment (#53936)

Signed-off-by: crazehang <zhangrenzhong@outlook.com>
---
 src/subtype.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/subtype.c b/src/subtype.c
index 61946968beba6..f9bdf9d3982d8 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -2853,7 +2853,7 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
     if (!varval && (vb->lb != vb->var->lb || vb->ub != vb->var->ub))
         newvar = jl_new_typevar(vb->var->name, vb->lb, vb->ub);
 
-    // flatten all innervar into a (revered) list
+    // flatten all innervar into a (reversed) list
     size_t icount = 0;
     if (vb->innervars)
         icount += jl_array_nrows(vb->innervars);

From d7dc9a8cc8f2aebf04d5cecc8625be250169644b Mon Sep 17 00:00:00 2001
From: Klaus Crusius <KlausC@users.noreply.github.com>
Date: Wed, 3 Apr 2024 17:06:13 +0200
Subject: [PATCH 1219/1315] make @fastmath mirror how lowering applies
 literal_pow (#53819)

The expressions `a^x` and `@fastmath a^x` are now producing equivalent
results (apart from floating point accuracy) in the case of literal
integer `x`.
The logic in the `fastmath` macro, trying to mimic the behaviour of the
compiler is fixed.

Fixes #53817

---------

Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
---
 base/fastmath.jl | 13 ++++++++++---
 test/fastmath.jl | 16 ++++++++++++++++
 2 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/base/fastmath.jl b/base/fastmath.jl
index a34a4ca66e06b..28a7852640ba9 100644
--- a/base/fastmath.jl
+++ b/base/fastmath.jl
@@ -101,9 +101,12 @@ const rewrite_op =
 function make_fastmath(expr::Expr)
     if expr.head === :quote
         return expr
-    elseif expr.head === :call && expr.args[1] === :^ && expr.args[3] isa Integer
-        # mimic Julia's literal_pow lowering of literal integer powers
-        return Expr(:call, :(Base.FastMath.pow_fast), make_fastmath(expr.args[2]), Val{expr.args[3]}())
+    elseif expr.head === :call && expr.args[1] === :^
+        ea = expr.args
+        if length(ea) >= 3 && isa(ea[3], Int)
+            # mimic Julia's literal_pow lowering of literal integer powers
+            return Expr(:call, :(Base.FastMath.pow_fast), make_fastmath(ea[2]), Val(ea[3]))
+        end
     end
     op = get(rewrite_op, expr.head, :nothing)
     if op !== :nothing
@@ -364,6 +367,10 @@ for f in (:^, :atan, :hypot, :log)
         # fall-back implementation that applies after promotion
         $f_fast(x::T, y::T) where {T<:Number} = $f(x, y)
     end
+    # Issue 53886 - avoid promotion of Int128 etc to be consistent with non-fastmath
+    if f === :^
+        @eval $f_fast(x::Number, y::Integer) = $f(x, y)
+    end
 end
 
 # Reductions
diff --git a/test/fastmath.jl b/test/fastmath.jl
index 34744f325ad7f..120c0ece685bb 100644
--- a/test/fastmath.jl
+++ b/test/fastmath.jl
@@ -256,6 +256,22 @@ end
 
 @testset "literal powers" begin
     @test @fastmath(2^-2) == @fastmath(2.0^-2) == 0.25
+    # Issue #53817
+    # Note that exponent -2^63 fails testing because of issue #53881
+    # Therefore we test with -(2^63-1). For Int == Int32 there is an analogue restriction.
+    # See also PR #53860.
+    if Int == Int64
+        @test @fastmath(2^-9223372036854775807) === 0.0
+        @test_throws DomainError @fastmath(2^-9223372036854775809)
+        @test @fastmath(1^-9223372036854775807) isa Float64
+        @test @fastmath(1^-9223372036854775809) isa Int
+    elseif Int == Int32
+        @test @fastmath(2^-2147483647) === 0.0
+        @test_throws DomainError @fastmath(2^-2147483649)
+        @test @fastmath(1^-2147483647) isa Float64
+        @test @fastmath(1^-2147483649) isa Int
+    end
+    @test_throws MethodError @fastmath(^(2))
 end
 
 @testset "sincos fall-backs" begin

From 12c93910344d34d65222f7c52932b592d74299f2 Mon Sep 17 00:00:00 2001
From: Manuel <manuelbb@mail.uni-paderborn.de>
Date: Wed, 3 Apr 2024 21:51:04 +0200
Subject: [PATCH 1220/1315] =?UTF-8?q?=E2=80=9CFix=E2=80=9D=20#53451=20--?=
 =?UTF-8?q?=20allow=20zero-row=20QR=20factorization=20bypassing=20LAPACK?=
 =?UTF-8?q?=20(#53578)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 stdlib/LinearAlgebra/src/lapack.jl |  4 ++--
 stdlib/LinearAlgebra/test/qr.jl    | 24 ++++++++++++++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/lapack.jl b/stdlib/LinearAlgebra/src/lapack.jl
index 02dfa0079038b..875ed3ed4e3da 100644
--- a/stdlib/LinearAlgebra/src/lapack.jl
+++ b/stdlib/LinearAlgebra/src/lapack.jl
@@ -470,7 +470,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             end
             lda = max(1, stride(A,2))
             work = Vector{$elty}(undef, nb*n)
-            if n > 0
+            if minmn > 0
                 info = Ref{BlasInt}()
                 ccall((@blasfunc($geqrt), libblastrampoline), Cvoid,
                     (Ref{BlasInt}, Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty},
@@ -496,7 +496,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             if p != n || q != n
                 throw(DimensionMismatch("block reflector T has dimensions ($p,$q), but should have dimensions ($n,$n)"))
             end
-            if n > 0
+            if n > 0    # this implies `m > 0` because of `m >= n`
                 info = Ref{BlasInt}()
                 ccall((@blasfunc($geqrt3), libblastrampoline), Cvoid,
                     (Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt},
diff --git a/stdlib/LinearAlgebra/test/qr.jl b/stdlib/LinearAlgebra/test/qr.jl
index 184971da304f7..e339706598a8a 100644
--- a/stdlib/LinearAlgebra/test/qr.jl
+++ b/stdlib/LinearAlgebra/test/qr.jl
@@ -504,4 +504,28 @@ end
     @test x ≈ xf
 end
 
+@testset "issue #53451" begin
+    # in the issue it was noted that QR factorizations of zero-column matrices
+    # were possible, but zero row-matrices errored, because LAPACK does not
+    # accept these empty matrices. now, the `geqrt!` call should be forwarded only
+    # if both matrix dimensions are positive.
+
+    for dimA in (0, 1, 2, 4)
+        for F in (Float32, Float64, ComplexF32, ComplexF64, BigFloat)
+            # this should have worked before, Q is square, and R is 0 × 0:
+            A_zero_cols = rand(F, dimA, 0)
+            qr_zero_cols = qr(A_zero_cols)
+            @test size(qr_zero_cols.Q) == (dimA, dimA)
+            @test size(qr_zero_cols.R) == (0, 0)
+            @test qr_zero_cols.Q == LinearAlgebra.I(dimA)
+
+            # this should work now, Q is 0 × 0, and R has `dimA` columns:
+            A_zero_rows = rand(F, 0, dimA)
+            qr_zero_rows = qr(A_zero_rows)
+            @test size(qr_zero_rows.Q) == (0, 0)
+            @test size(qr_zero_rows.R) == (0, dimA)
+        end
+    end
+end
+
 end # module TestQR

From 286e3393fe5102f9f4f1578b3bae863e72f85cbd Mon Sep 17 00:00:00 2001
From: Klaus Crusius <KlausC@users.noreply.github.com>
Date: Wed, 3 Apr 2024 23:14:17 +0200
Subject: [PATCH 1221/1315] fix macros `@which`, `@edit`, `@functionloc`,
 `@less` for `literal_pow` case. (#53713)

The macros `@which`, `@edit`, `@functionloc`, `@less` from `InteractiveUtils`, if
applied to the case of literal powers, like `a^12` or `2^-1` used to direct the
user to function `^`, while the compiler generates code for `Base.literal_pow`.

Now the user is shown the code the compiler generates.

Fixes #53691
Fixes #43337
Fixes #21014

Co-authored-by: Matt Bauman <mbauman@juliahub.com>
---
 stdlib/InteractiveUtils/src/macros.jl    |  5 ++++
 stdlib/InteractiveUtils/test/runtests.jl | 38 +++++++++++++++++++++++-
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/stdlib/InteractiveUtils/src/macros.jl b/stdlib/InteractiveUtils/src/macros.jl
index 939098464e148..bb56c47b4f9ca 100644
--- a/stdlib/InteractiveUtils/src/macros.jl
+++ b/stdlib/InteractiveUtils/src/macros.jl
@@ -106,6 +106,11 @@ function gen_call_with_extracted_types(__module__, fcn, ex0, kws=Expr[])
                        $(kws...))
             end
         elseif ex0.head === :call
+            if ex0.args[1] === :^ && length(ex0.args) >= 3 && isa(ex0.args[3], Int)
+                return Expr(:call, fcn, :(Base.literal_pow),
+                            Expr(:call, typesof, esc(ex0.args[1]), esc(ex0.args[2]),
+                                 esc(Val(ex0.args[3]))))
+            end
             return Expr(:call, fcn, esc(ex0.args[1]),
                         Expr(:call, typesof, map(esc, ex0.args[2:end])...),
                         kws...)
diff --git a/stdlib/InteractiveUtils/test/runtests.jl b/stdlib/InteractiveUtils/test/runtests.jl
index ef1cd6e230818..22789be2c5495 100644
--- a/stdlib/InteractiveUtils/test/runtests.jl
+++ b/stdlib/InteractiveUtils/test/runtests.jl
@@ -279,6 +279,43 @@ let x..y = 0
     @test (@which 1..2).name === :..
 end
 
+# issue #53691
+let a = -1
+    @test (@which 2^a).name === :^
+    @test (@which 2^0x1).name === :^
+end
+
+let w = Vector{Any}(undef, 9)
+    @testset "@which x^literal" begin
+        w[1] = @which 2^0
+        w[2] = @which 2^1
+        w[3] = @which 2^2
+        w[4] = @which 2^3
+        w[5] = @which 2^-1
+        w[6] = @which 2^-2
+        w[7] = @which 2^10
+        w[8] = @which big(2.0)^1
+        w[9] = @which big(2.0)^-1
+        @test all(getproperty.(w, :name) .=== :literal_pow)
+        @test length(Set(w)) == length(w) # all methods distinct
+    end
+end
+
+# PR 53713
+if Int === Int64
+    # literal_pow only for exponents x: -2^63 <= x < 2^63 #53860 (all Int)
+    @test (@which 2^-9223372036854775809).name === :^
+    @test (@which 2^-9223372036854775808).name === :literal_pow
+    @test (@which 2^9223372036854775807).name === :literal_pow
+    @test (@which 2^9223372036854775808).name === :^
+elseif Int === Int32
+    # literal_pow only for exponents x: -2^31 <= x < 2^31 #53860 (all Int)
+    @test (@which 2^-2147483649).name === :^
+    @test (@which 2^-2147483648).name === :literal_pow
+    @test (@which 2^2147483647).name === :literal_pow
+    @test (@which 2^2147483648).name === :^
+end
+
 # issue #13464
 try
     @which x = 1
@@ -286,7 +323,6 @@ try
 catch err13464
     @test startswith(err13464.msg, "expression is not a function call")
 end
-
 module MacroTest
 export @macrotest
 macro macrotest(x::Int, y::Symbol) end

From 19919b70d342250c69b59e006d2b1e1dd704c06a Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 4 Apr 2024 08:26:24 +0530
Subject: [PATCH 1222/1315] Use `copyto!` in converting
 `Diagonal`/`Bidiagonal`/`Tridiagonal` to `Matrix` (#53912)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

With this, we may convert a structured matrix to `Matrix` even if its
`eltype` doesn't support `zero(T)`, as long as we may index into the
matrix and the elements have `zero` defined for themselves. This makes
the following work:
```julia
julia> D = Diagonal(fill(Diagonal([1,3]), 2))
2×2 Diagonal{Diagonal{Int64, Vector{Int64}}, Vector{Diagonal{Int64, Vector{Int64}}}}:
 [1 0; 0 3]      ⋅
     ⋅       [1 0; 0 3]

julia> Matrix{eltype(D)}(D)
2×2 Matrix{Diagonal{Int64, Vector{Int64}}}:
 [1 0; 0 3]  [0 0; 0 0]
 [0 0; 0 0]  [1 0; 0 3]
```
We also may materialize partly initialized matrices:
```julia
julia> D = Diagonal(Vector{BigInt}(undef, 2))
2×2 Diagonal{BigInt, Vector{BigInt}}:
 #undef    ⋅
   ⋅     #undef

julia> Matrix{eltype(D)}(D)
2×2 Matrix{BigInt}:
 #undef    0
   0     #undef
```

The performance seems identical for numeric matrices.
---
 stdlib/LinearAlgebra/src/bidiag.jl    | 19 ++++++---------
 stdlib/LinearAlgebra/src/diagonal.jl  | 11 +++++----
 stdlib/LinearAlgebra/src/tridiag.jl   | 33 +++++++++++++++------------
 stdlib/LinearAlgebra/test/bidiag.jl   | 13 +++++++++++
 stdlib/LinearAlgebra/test/diagonal.jl | 13 +++++++++++
 stdlib/LinearAlgebra/test/special.jl  |  2 ++
 stdlib/LinearAlgebra/test/tridiag.jl  |  8 +++++++
 7 files changed, 67 insertions(+), 32 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/bidiag.jl b/stdlib/LinearAlgebra/src/bidiag.jl
index 00c972f7f990b..b805d0ca309b9 100644
--- a/stdlib/LinearAlgebra/src/bidiag.jl
+++ b/stdlib/LinearAlgebra/src/bidiag.jl
@@ -195,19 +195,14 @@ end
 
 #Converting from Bidiagonal to dense Matrix
 function Matrix{T}(A::Bidiagonal) where T
-    n = size(A, 1)
-    B = Matrix{T}(undef, n, n)
-    n == 0 && return B
-    n > 1 && fill!(B, zero(T))
-    @inbounds for i = 1:n - 1
-        B[i,i] = A.dv[i]
-        if A.uplo == 'U'
-            B[i,i+1] = A.ev[i]
-        else
-            B[i+1,i] = A.ev[i]
-        end
+    B = Matrix{T}(undef, size(A))
+    if haszero(T) # optimized path for types with zero(T) defined
+        size(B,1) > 1 && fill!(B, zero(T))
+        copyto!(view(B, diagind(B)), A.dv)
+        copyto!(view(B, diagind(B, A.uplo == 'U' ? 1 : -1)), A.ev)
+    else
+        copyto!(B, A)
     end
-    B[n,n] = A.dv[n]
     return B
 end
 Matrix(A::Bidiagonal{T}) where {T} = Matrix{promote_type(T, typeof(zero(T)))}(A)
diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index cd93a771c30ad..8cee4a91d4696 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -116,11 +116,12 @@ AbstractMatrix{T}(D::Diagonal{T}) where {T} = copy(D)
 Matrix(D::Diagonal{T}) where {T} = Matrix{promote_type(T, typeof(zero(T)))}(D)
 Array(D::Diagonal{T}) where {T} = Matrix(D)
 function Matrix{T}(D::Diagonal) where {T}
-    n = size(D, 1)
-    B = Matrix{T}(undef, n, n)
-    n > 1 && fill!(B, zero(T))
-    @inbounds for i in 1:n
-        B[i,i] = D.diag[i]
+    B = Matrix{T}(undef, size(D))
+    if haszero(T) # optimized path for types with zero(T) defined
+        size(B,1) > 1 && fill!(B, zero(T))
+        copyto!(view(B, diagind(B)), D.diag)
+    else
+        copyto!(B, D)
     end
     return B
 end
diff --git a/stdlib/LinearAlgebra/src/tridiag.jl b/stdlib/LinearAlgebra/src/tridiag.jl
index 07c2fe410769d..90142dd941f28 100644
--- a/stdlib/LinearAlgebra/src/tridiag.jl
+++ b/stdlib/LinearAlgebra/src/tridiag.jl
@@ -135,13 +135,17 @@ function Matrix{T}(M::SymTridiagonal) where T
     n = size(M, 1)
     Mf = Matrix{T}(undef, n, n)
     n == 0 && return Mf
-    n > 2 && fill!(Mf, zero(T))
-    @inbounds for i = 1:n-1
-        Mf[i,i] = symmetric(M.dv[i], :U)
-        Mf[i+1,i] = transpose(M.ev[i])
-        Mf[i,i+1] = M.ev[i]
+    if haszero(T) # optimized path for types with zero(T) defined
+        n > 2 && fill!(Mf, zero(T))
+        @inbounds for i = 1:n-1
+            Mf[i,i] = symmetric(M.dv[i], :U)
+            Mf[i+1,i] = transpose(M.ev[i])
+            Mf[i,i+1] = M.ev[i]
+        end
+        Mf[n,n] = symmetric(M.dv[n], :U)
+    else
+        copyto!(Mf, M)
     end
-    Mf[n,n] = symmetric(M.dv[n], :U)
     return Mf
 end
 Matrix(M::SymTridiagonal{T}) where {T} = Matrix{promote_type(T, typeof(zero(T)))}(M)
@@ -586,15 +590,14 @@ axes(M::Tridiagonal) = (ax = axes(M.d,1); (ax, ax))
 
 function Matrix{T}(M::Tridiagonal) where {T}
     A = Matrix{T}(undef, size(M))
-    n = length(M.d)
-    n == 0 && return A
-    n > 2 && fill!(A, zero(T))
-    for i in 1:n-1
-        A[i,i] = M.d[i]
-        A[i+1,i] = M.dl[i]
-        A[i,i+1] = M.du[i]
-    end
-    A[n,n] = M.d[n]
+    if haszero(T) # optimized path for types with zero(T) defined
+        size(A,1) > 2 && fill!(A, zero(T))
+        copyto!(view(A, diagind(A)), M.d)
+        copyto!(view(A, diagind(A,1)), M.du)
+        copyto!(view(A, diagind(A,-1)), M.dl)
+    else
+        copyto!(A, M)
+    end
     A
 end
 Matrix(M::Tridiagonal{T}) where {T} = Matrix{promote_type(T, typeof(zero(T)))}(M)
diff --git a/stdlib/LinearAlgebra/test/bidiag.jl b/stdlib/LinearAlgebra/test/bidiag.jl
index 8d48c42a7f7ea..f9c4f09c474fe 100644
--- a/stdlib/LinearAlgebra/test/bidiag.jl
+++ b/stdlib/LinearAlgebra/test/bidiag.jl
@@ -884,4 +884,17 @@ end
     @test mul!(C1, B, sv, 1, 2) == mul!(C2, B, v, 1 ,2)
 end
 
+@testset "Matrix conversion for non-numeric and undef" begin
+    B = Bidiagonal(Vector{BigInt}(undef, 4), fill(big(3), 3), :U)
+    M = Matrix(B)
+    B[diagind(B)] .= 4
+    M[diagind(M)] .= 4
+    @test diag(B) == diag(M)
+
+    B = Bidiagonal(fill(Diagonal([1,3]), 3), fill(Diagonal([1,3]), 2), :U)
+    M = Matrix{eltype(B)}(B)
+    @test M isa Matrix{eltype(B)}
+    @test M == B
+end
+
 end # module TestBidiagonal
diff --git a/stdlib/LinearAlgebra/test/diagonal.jl b/stdlib/LinearAlgebra/test/diagonal.jl
index 3f5cd34a543b6..aa960aaa53193 100644
--- a/stdlib/LinearAlgebra/test/diagonal.jl
+++ b/stdlib/LinearAlgebra/test/diagonal.jl
@@ -1292,4 +1292,17 @@ end
     @test yadj == x'
 end
 
+@testset "Matrix conversion for non-numeric and undef" begin
+    D = Diagonal(Vector{BigInt}(undef, 4))
+    M = Matrix(D)
+    D[diagind(D)] .= 4
+    M[diagind(M)] .= 4
+    @test diag(D) == diag(M)
+
+    D = Diagonal(fill(Diagonal([1,3]), 2))
+    M = Matrix{eltype(D)}(D)
+    @test M isa Matrix{eltype(D)}
+    @test M == D
+end
+
 end # module TestDiagonal
diff --git a/stdlib/LinearAlgebra/test/special.jl b/stdlib/LinearAlgebra/test/special.jl
index 7e96af369e310..6465927db5235 100644
--- a/stdlib/LinearAlgebra/test/special.jl
+++ b/stdlib/LinearAlgebra/test/special.jl
@@ -113,6 +113,8 @@ Random.seed!(1)
         Base.convert(::Type{TypeWithZero}, ::TypeWithoutZero) = TypeWithZero()
         Base.zero(::Type{<:Union{TypeWithoutZero, TypeWithZero}}) = TypeWithZero()
         LinearAlgebra.symmetric(::TypeWithoutZero, ::Symbol) = TypeWithoutZero()
+        LinearAlgebra.symmetric_type(::Type{TypeWithoutZero}) = TypeWithoutZero
+        Base.copy(A::TypeWithoutZero) = A
         Base.transpose(::TypeWithoutZero) = TypeWithoutZero()
         d  = fill(TypeWithoutZero(), 3)
         du = fill(TypeWithoutZero(), 2)
diff --git a/stdlib/LinearAlgebra/test/tridiag.jl b/stdlib/LinearAlgebra/test/tridiag.jl
index 487f808076707..4878ab689985c 100644
--- a/stdlib/LinearAlgebra/test/tridiag.jl
+++ b/stdlib/LinearAlgebra/test/tridiag.jl
@@ -830,4 +830,12 @@ end
     @test axes(B) === (ax, ax)
 end
 
+@testset "Matrix conversion for non-numeric and undef" begin
+    T = Tridiagonal(fill(big(3), 3), Vector{BigInt}(undef, 4), fill(big(3), 3))
+    M = Matrix(T)
+    T[diagind(T)] .= 4
+    M[diagind(M)] .= 4
+    @test diag(T) == diag(M)
+end
+
 end # module TestTridiagonal

From cb4e107e37e11f65459d79ea6c3722970c22c562 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 4 Apr 2024 08:32:36 +0530
Subject: [PATCH 1223/1315] Add `zero` for `Base.TwicePrecision` (#53787)

Since `zero` exists for a `TwicePrecision` type, it makes sense for a
method to exist for an instance as well.
Fixes #52713, which was a regression from v1.9.1. After this, the
following may be displayed without errors:
```julia
julia> r = 1.0*(1:5) .+ im
1.0 + 1.0im:Base.TwicePrecision{Float64}(1.0, 0.0):5.0 + 1.0im
```
However, in this case, the step is a `Base.TwicePrecision`, which seems
to be an implementation detail that's leaking out, although addressing
this may be a separate PR.
---
 base/twiceprecision.jl | 1 +
 test/ranges.jl         | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/base/twiceprecision.jl b/base/twiceprecision.jl
index 0de6270cafb2d..6928d420a3860 100644
--- a/base/twiceprecision.jl
+++ b/base/twiceprecision.jl
@@ -278,6 +278,7 @@ big(x::TwicePrecision) = big(x.hi) + big(x.lo)
 
 -(x::TwicePrecision) = TwicePrecision(-x.hi, -x.lo)
 
+zero(x::TwicePrecision) = zero(typeof(x))
 function zero(::Type{TwicePrecision{T}}) where {T}
     z = zero(T)
     TwicePrecision{T}(z, z)
diff --git a/test/ranges.jl b/test/ranges.jl
index 9284c898bcbfb..9599128739488 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -314,6 +314,13 @@ end
             twiceprecision_is_normalized(Base.TwicePrecision{Float64}(rand_twiceprecision(Float32)))
         end
     end
+
+    @testset "displaying a complex range (#52713)" begin
+        r = 1.0*(1:5) .+ im
+        @test startswith(repr(r), repr(first(r)))
+        @test endswith(repr(r), repr(last(r)))
+        @test occursin(repr(step(r)), repr(r))
+    end
 end
 @testset "ranges" begin
     @test size(10:1:0) == (0,)

From 0cd3164862633649bb121933600803c9a54d533c Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Thu, 4 Apr 2024 09:10:57 +0530
Subject: [PATCH 1224/1315] Update stable version in README.md (#53947)

[skip ci]
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c5c4f3f2730ac..9ca71313f5483 100644
--- a/README.md
+++ b/README.md
@@ -94,7 +94,7 @@ and then use the command prompt to change into the resulting julia directory. By
 Julia. However, most users should use the [most recent stable version](https://github.com/JuliaLang/julia/releases)
 of Julia. You can get this version by running:
 
-    git checkout v1.10.0
+    git checkout v1.10.2
 
 To build the `julia` executable, run `make` from within the julia directory.
 

From 19fffe1976f900648431b268b8aeaef22ec09f9a Mon Sep 17 00:00:00 2001
From: Paul Berg <paul.berg@univ-ubs.fr>
Date: Thu, 4 Apr 2024 10:54:55 +0200
Subject: [PATCH 1225/1315] Fixes for allowing `:throw_undef_if_not` on the
 frontend (#53944)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

https://github.com/JuliaLang/julia/pull/53875 allowed
`:throw_undef_if_not` as a frontend form.

However, the `UndefVarError` being tested is thrown because the first
argument is resolved to a global ref:

```julia
julia> @eval function has_tuin()
           $(Expr(:throw_undef_if_not, :x, false))
       end
has_tuin (generic function with 1 method)

julia> @code_lowered has_tuin() # master
CodeInfo(
1 ─ %1 = $(Expr(:throw_undef_if_not, :(Main.x), false))
└──      return %1
)

julia> @code_lowered has_tuin() # this pr
CodeInfo(
1 ─ %1 = $(Expr(:throw_undef_if_not, :x, false))
└──      return %1
)
```

This change skips this global ref resolution for the first argument and
fixes a typo which would throw an error in case of non-const second
argument.
---
 base/compiler/abstractinterpretation.jl |  2 +-
 src/method.c                            |  2 +-
 test/compiler/inference.jl              | 16 ++++++++++++++++
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index ce8494b1feff0..51794e9e1eb7c 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2637,7 +2637,7 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
             else
                 t = Union{}
             end
-        elseif !hasintersect(windenconst(condt), Bool)
+        elseif !hasintersect(widenconst(condt), Bool)
             t = Union{}
         end
     elseif ehead === :boundscheck
diff --git a/src/method.c b/src/method.c
index a97dccf53e1e2..e3b19a5007b58 100644
--- a/src/method.c
+++ b/src/method.c
@@ -212,7 +212,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                 jl_exprargset(e, 0, resolve_globals(jl_exprarg(e, 0), module, sparam_vals, binding_effects, 1));
                 i++;
             }
-            if (e->head == jl_method_sym || e->head == jl_module_sym) {
+            if (e->head == jl_method_sym || e->head == jl_module_sym || e->head == jl_throw_undef_if_not_sym) {
                 i++;
             }
             for (; i < nargs; i++) {
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 62c134e58c2a6..01c4687a26caa 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5647,6 +5647,22 @@ end
 @test Core.Compiler.return_type(has_tuin, Tuple{}) === Union{}
 @test_throws UndefVarError has_tuin()
 
+function gen_tuin_from_arg(world::UInt, source, _, _)
+    ci = make_codeinfo(Any[
+        Expr(:throw_undef_if_not, :x, Core.Argument(2)),
+        ReturnNode(true),
+    ]; slottypes=Any[Any, Bool])
+    ci.slotnames = Symbol[:var"#self#", :def]
+    ci
+end
+
+@eval function has_tuin2(def)
+    $(Expr(:meta, :generated, gen_tuin_from_arg))
+    $(Expr(:meta, :generated_only))
+end
+@test_throws UndefVarError has_tuin2(false)
+@test has_tuin2(true)
+
 # issue #53585
 let t = ntuple(i -> i % 8 == 1 ? Int64 : Float64, 4000)
     @test only(Base.return_types(Base.promote_typeof, t)) == Type{Float64}

From c371e4cac4e571cbdda7576e3fc40e54344175f8 Mon Sep 17 00:00:00 2001
From: Matt Stinson <11094799+mestinso@users.noreply.github.com>
Date: Thu, 4 Apr 2024 07:21:31 -0700
Subject: [PATCH 1226/1315] Fix negative tolerance documentation issue in
 cholesky.jl (#53918)

---
 stdlib/LinearAlgebra/src/cholesky.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/cholesky.jl b/stdlib/LinearAlgebra/src/cholesky.jl
index 528eca5c3d8a3..c28613041e18a 100644
--- a/stdlib/LinearAlgebra/src/cholesky.jl
+++ b/stdlib/LinearAlgebra/src/cholesky.jl
@@ -427,7 +427,7 @@ The following functions are available for `CholeskyPivoted` objects:
 [`size`](@ref), [`\\`](@ref), [`inv`](@ref), [`det`](@ref), and [`rank`](@ref).
 
 The argument `tol` determines the tolerance for determining the rank.
-For negative values, the tolerance is the machine precision.
+For negative values, the tolerance is equal to `eps()*size(A,1)*maximum(diag(A))`.
 
 If you have a matrix `A` that is slightly non-Hermitian due to roundoff errors in its construction,
 wrap it in `Hermitian(A)` before passing it to `cholesky` in order to treat it as perfectly Hermitian.

From a931fbedc4f10776ba53eaaf1df7256eb55e3fba Mon Sep 17 00:00:00 2001
From: Hossein Pourbozorg <prbzrg@gmail.com>
Date: Thu, 4 Apr 2024 22:05:52 +0330
Subject: [PATCH 1227/1315] Make all command-line options documented in all
 related files (#53826)

I checked and updated the three related files to make sure command-line
documentations are the same in all of them.

Previously mentioned in
https://github.com/JuliaLang/julia/pull/52645#issuecomment-1870571454

---------

Co-authored-by: Matt Bauman <mbauman@gmail.com>
---
 doc/man/julia.1                          | 67 ++++++++++++++----------
 doc/src/manual/command-line-interface.md | 27 +++++-----
 src/jloptions.c                          | 30 ++++++-----
 3 files changed, 72 insertions(+), 52 deletions(-)

diff --git a/doc/man/julia.1 b/doc/man/julia.1
index 2d7f41b2217bc..6320536cbbc74 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -59,7 +59,7 @@ Display version information
 
 .TP
 -h, --help
-Print help message
+Print command-line options (this message)
 
 .TP
 --help-hidden
@@ -77,7 +77,7 @@ Start up with the given system image file
 
 .TP
 -H, --home <dir>
-Set location of julia executable
+Set location of `julia` executable
 
 .TP
 --startup-file={yes*|no}
@@ -95,39 +95,42 @@ Use native code from system image if available
 .TP
 --compiled-modules={yes*|no|existing|strict}
 Enable or disable incremental precompilation of modules.
-The "existing" option allows use of existing compiled modules that were previously precompiled, but disallows creation of new precompile files.
-The "strict" option is similar, but will error if no precompile file is found.
+The `existing` option allows use of existing compiled modules that were
+previously precompiled, but disallows creation of new precompile files.
+The `strict` option is similar, but will error if no precompile file is found.
 
 .TP
 --pkgimages={yes*|no|existing}
 Enable or disable usage of native code caching in the form of pkgimages
+The `existing` option allows use of existing pkgimages but disallows creation of new ones
 
 .TP
 -e, --eval <expr>
 Evaluate <expr>
 
-.TP
--m, --module <Package> [args]
-Run entry point of `Package` (`@main` function) with `args'.
-
-
 .TP
 -E, --print <expr>
 Evaluate <expr> and display the result
 
+.TP
+-m, --module <Package> [args]
+Run entry point of `Package` (`@main` function) with `args'
+
 .TP
 -L, --load <file>
 Load <file> immediately on all processors
 
 .TP
--t, --threads <n>
-Enable n threads; "auto" tries to infer a useful default number
-of threads to use but the exact behavior might change in the future.
-Currently, "auto" uses the number of CPUs assigned to this julia
-process based on the OS-specific affinity assignment interface, if
-supported (Linux and Windows). If this is not supported (macOS) or
-process affinity is not configured, it uses the number of CPU
-threads.
+-t, --threads {auto|N[,auto|M]}
+Enable N[+M] threads; N threads are assigned to the `default`
+threadpool, and if M is specified, M threads are assigned to the
+`interactive` threadpool; `auto` tries to infer a useful
+default number of threads to use but the exact behavior might change
+in the future. Currently sets N to the number of CPUs assigned to
+this Julia process based on the OS-specific affinity assignment
+interface if supported (Linux and Windows) or to the number of CPU
+threads if not supported (MacOS) or if process affinity is not
+configured, and sets M to 1.
 
 .TP
 --gcthreads=N[,M]
@@ -144,7 +147,7 @@ as the number of local CPU threads (logical cores)
 Run processes on hosts listed in <file>
 
 .TP
--i
+-i, --interactive
 Interactive mode; REPL runs and `isinteractive()` is true
 
 .TP
@@ -152,7 +155,7 @@ Interactive mode; REPL runs and `isinteractive()` is true
 Quiet startup: no banner, suppress REPL warnings
 
 .TP
---banner={yes|no|auto*}
+--banner={yes|no|short|auto*}
 Enable or disable startup banner
 
 .TP
@@ -180,15 +183,15 @@ Enable or disable warning for ambiguous top-level scope
 Limit usage of CPU features up to <target>; set to `help` to see the available options
 
 .TP
--O, --optimize={0,1,2*,3}
+-O, --optimize={0|1|2*|3}
 Set the optimization level (level 3 if `-O` is used without a level)
 
 .TP
---min-optlevel={0*,1,2,3}
+--min-optlevel={0*|1|2|3}
 Set a lower bound on the optimization level
 
 .TP
--g {0,1*,2}
+-g, --debug-info={0|1*|2}
 Set the level of debug info generation (level 2 if `-g` is used without a level)
 
 .TP
@@ -203,6 +206,10 @@ Emit bounds checks always, never, or respect @inbounds declarations
 --math-mode={ieee|user*}
 Always follow `ieee` floating point semantics or respect `@fastmath` declarations
 
+.TP
+--polly={yes*|no}
+Enable or disable the polyhedral optimizer Polly (overrides @polly declaration)
+
 .TP
 --code-coverage[={none*|user|all}]
 Count executions of source lines (omitting setting is equivalent to `user`)
@@ -213,8 +220,8 @@ Count executions of source lines in a file or files under a given directory. A `
 be placed before the path to indicate this option. A `@` with no path will track the current directory.
 
 .TP
- --code-coverage=tracefile.info
- Append coverage information to the LCOV tracefile (filename supports format tokens)
+--code-coverage=tracefile.info
+Append coverage information to the LCOV tracefile (filename supports format tokens)
 
 .TP
 --track-allocation[={none*|user|all}]
@@ -222,8 +229,8 @@ Count bytes allocated by each source line (omitting setting is equivalent to `us
 
 .TP
 --track-allocation=@<path>
-Count bytes allocated by each source line in a file or files under a given directory. A `@`
-must be placed before the path to indicate this option. A `@` with no path will track the current directory.
+Count bytes but only in files that fall under the given file path/directory.
+The `@` prefix is required to select this option. A `@` with no path will track the current directory.
 
 .TP
 --bug-report=KIND
@@ -233,7 +240,7 @@ fallbacks to the latest compatible BugReporting.jl if not. For more information,
 --bug-report=help.
 
 .TP
---heap-size-hint=<value>
+--heap-size-hint=<size>
 Forces garbage collection if memory usage is higher than the given value.
 The value may be specified as a number of bytes, optionally in units of
 KB, MB, GB, or TB, or as a percentage of physical memory with %.
@@ -275,13 +282,17 @@ Generate an assembly file (.s)
 Generate an incremental output file (rather than complete)
 
 .TP
---trace-compile={stderr,name}
+--trace-compile={stderr|name}
 Print precompile statements for methods compiled during execution or save to a path
 
 .TP
 -image-codegen
 Force generate code in imaging mode
 
+.TP
+--permalloc-pkgimg={yes|no*}
+Copy the data section of package images into memory
+
 .SH FILES AND ENVIRONMENT
 See https://docs.julialang.org/en/v1/manual/environment-variables/
 
diff --git a/doc/src/manual/command-line-interface.md b/doc/src/manual/command-line-interface.md
index 1bb9507756aec..50002801e06f8 100644
--- a/doc/src/manual/command-line-interface.md
+++ b/doc/src/manual/command-line-interface.md
@@ -164,44 +164,47 @@ The following is a complete list of command-line switches available when launchi
 |Switch                                 |Description|
 |:---                                   |:---|
 |`-v`, `--version`                      |Display version information|
-|`-h`, `--help`                         |Print command-line options (this message).|
-|`--help-hidden`                        |Uncommon options not shown by `-h`|
+|`-h`, `--help`                         |Print command-line options (this message)|
+|`--help-hidden`                        |Print uncommon options not shown by `-h`|
 |`--project[={<dir>\|@.}]`              |Set `<dir>` as the active project/environment. The default `@.` option will search through parent directories until a `Project.toml` or `JuliaProject.toml` file is found.|
 |`-J`, `--sysimage <file>`              |Start up with the given system image file|
 |`-H`, `--home <dir>`                   |Set location of `julia` executable|
 |`--startup-file={yes*\|no}`            |Load `JULIA_DEPOT_PATH/config/startup.jl`; if [`JULIA_DEPOT_PATH`](@ref JULIA_DEPOT_PATH) environment variable is unset, load `~/.julia/config/startup.jl`|
 |`--handle-signals={yes*\|no}`          |Enable or disable Julia's default signal handlers|
 |`--sysimage-native-code={yes*\|no}`    |Use native code from system image if available|
-|`--compiled-modules={yes*\|no\|existing|strict}` |Enable or disable incremental precompilation of modules. The `existing` option allows use of existing compiled modules that were previously precompiled, but disallows creation of new precompile files. The `strict` option is similar, but will error if no precompile file is found. |
-|`--pkgimages={yes*\|no|existing}`               |Enable or disable usage of native code caching in the form of pkgimages. The `existing` option allows use of existing pkgimages but disallows creation of new ones|
+|`--compiled-modules={yes*\|no\|existing\|strict}` |Enable or disable incremental precompilation of modules. The `existing` option allows use of existing compiled modules that were previously precompiled, but disallows creation of new precompile files. The `strict` option is similar, but will error if no precompile file is found. |
+|`--pkgimages={yes*\|no\|existing}`     |Enable or disable usage of native code caching in the form of pkgimages. The `existing` option allows use of existing pkgimages but disallows creation of new ones|
 |`-e`, `--eval <expr>`                  |Evaluate `<expr>`|
 |`-E`, `--print <expr>`                 |Evaluate `<expr>` and display the result|
+|`-m`, `--module <Package> [args]`      |Run entry point of `Package` (`@main` function) with `args'|
 |`-L`, `--load <file>`                  |Load `<file>` immediately on all processors|
-|`-t`, `--threads {N\|auto}`            |Enable N threads; `auto` tries to infer a useful default number of threads to use but the exact behavior might change in the future.  Currently, `auto` uses the number of CPUs assigned to this julia process based on the OS-specific affinity assignment interface, if supported (Linux and Windows). If this is not supported (macOS) or process affinity is not configured, it uses the number of CPU threads.|
+|`-t`, `--threads {auto\|N[,auto\|M]}`  |Enable N[+M] threads; N threads are assigned to the `default` threadpool, and if M is specified, M threads are assigned to the `interactive` threadpool; `auto` tries to infer a useful default number of threads to use but the exact behavior might change in the future. Currently sets N to the number of CPUs assigned to this Julia process based on the OS-specific affinity assignment interface if supported (Linux and Windows) or to the number of CPU threads if not supported (MacOS) or if process affinity is not configured, and sets M to 1.|
 | `--gcthreads=N[,M]`                   |Use N threads for the mark phase of GC and M (0 or 1) threads for the concurrent sweeping phase of GC. N is set to half of the number of compute threads and M is set to 0 if unspecified.|
 |`-p`, `--procs {N\|auto}`              |Integer value N launches N additional local worker processes; `auto` launches as many workers as the number of local CPU threads (logical cores)|
 |`--machine-file <file>`                |Run processes on hosts listed in `<file>`|
-|`-i`                                   |Interactive mode; REPL runs and `isinteractive()` is true|
+|`-i`, `--interactive`                  |Interactive mode; REPL runs and `isinteractive()` is true|
 |`-q`, `--quiet`                        |Quiet startup: no banner, suppress REPL warnings|
-|`--banner={yes\|no\|auto*}`            |Enable or disable startup banner|
+|`--banner={yes\|no\|short\|auto*}`     |Enable or disable startup banner|
 |`--color={yes\|no\|auto*}`             |Enable or disable color text|
 |`--history-file={yes*\|no}`            |Load or save history|
 |`--depwarn={yes\|no*\|error}`          |Enable or disable syntax and method deprecation warnings (`error` turns warnings into errors)|
 |`--warn-overwrite={yes\|no*}`          |Enable or disable method overwrite warnings|
 |`--warn-scope={yes*\|no}`              |Enable or disable warning for ambiguous top-level scope|
 |`-C`, `--cpu-target <target>`          |Limit usage of CPU features up to `<target>`; set to `help` to see the available options|
-|`-O`, `--optimize={0,1,2*,3}`          |Set the optimization level (level is 3 if `-O` is used without a level) ($)|
-|`--min-optlevel={0*,1,2,3}`            |Set the lower bound on per-module optimization|
-|`-g`, `--debug-info={0,1*,2}`          |Set the level of debug info generation (level is 2 if `-g` is used without a level) ($)|
+|`-O`, `--optimize={0\|1\|2*\|3}`       |Set the optimization level (level is 3 if `-O` is used without a level) ($)|
+|`--min-optlevel={0*\|1\|2\|3}`         |Set the lower bound on per-module optimization|
+|`-g`, `--debug-info={0\|1*\|2}`        |Set the level of debug info generation (level is 2 if `-g` is used without a level) ($)|
 |`--inline={yes\|no}`                   |Control whether inlining is permitted, including overriding `@inline` declarations|
 |`--check-bounds={yes\|no\|auto*}`      |Emit bounds checks always, never, or respect `@inbounds` declarations ($)|
 |`--math-mode={ieee\|user*}`            |Always follow `ieee` floating point semantics or respect `@fastmath` declarations|
+|`--polly={yes*\|no}`                   |Enable or disable the polyhedral optimizer Polly (overrides @polly declaration)|
 |`--code-coverage[={none*\|user\|all}]` |Count executions of source lines (omitting setting is equivalent to `user`)|
 |`--code-coverage=@<path>`              |Count executions but only in files that fall under the given file path/directory. The `@` prefix is required to select this option. A `@` with no path will track the current directory.|
 |`--code-coverage=tracefile.info`       |Append coverage information to the LCOV tracefile (filename supports format tokens).|
 |`--track-allocation[={none*\|user\|all}]` |Count bytes allocated by each source line (omitting setting is equivalent to "user")|
 |`--track-allocation=@<path>`           |Count bytes but only in files that fall under the given file path/directory. The `@` prefix is required to select this option. A `@` with no path will track the current directory.|
 |`--bug-report=KIND`                    |Launch a bug report session. It can be used to start a REPL, run a script, or evaluate expressions. It first tries to use BugReporting.jl installed in current environment and falls back to the latest compatible BugReporting.jl if not. For more information, see `--bug-report=help`.|
+|`--heap-size-hint=<size>`              |Forces garbage collection if memory usage is higher than the given value. The value may be specified as a number of bytes, optionally in units of KB, MB, GB, or TB, or as a percentage of physical memory with %.|
 |`--compile={yes*\|no\|all\|min}`       |Enable or disable JIT compiler, or request exhaustive or minimal compilation|
 |`--output-o <name>`                    |Generate an object file (including system image data)|
 |`--output-ji <name>`                   |Generate a system image data file (.ji)|
@@ -211,9 +214,9 @@ The following is a complete list of command-line switches available when launchi
 |`--output-bc <name>`                   |Generate LLVM bitcode (.bc)|
 |`--output-asm <name>`                  |Generate an assembly file (.s)|
 |`--output-incremental={yes\|no*}`      |Generate an incremental output file (rather than complete)|
-|`--trace-compile={stderr,name}`        |Print precompile statements for methods compiled during execution or save to a path|
+|`--trace-compile={stderr\|name}`       |Print precompile statements for methods compiled during execution or save to a path|
 |`--image-codegen`                      |Force generate code in imaging mode|
-|`--heap-size-hint=<size>`              |Forces garbage collection if memory usage is higher than the given value. The value may be specified as a number of bytes, optionally in units of KB, MB, GB, or TB, or as a percentage of physical memory with %.|
+|`--permalloc-pkgimg={yes\|no*}`        |Copy the data section of package images into memory|
 
 
 !!! compat "Julia 1.1"
diff --git a/src/jloptions.c b/src/jloptions.c
index 9020404e70781..6980d4b8b235c 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -108,11 +108,13 @@ static const char usage[] = "\n    julia [switches] -- [programfile] [args...]\n
 static const char opts[]  =
     "Switches (a '*' marks the default value, if applicable; settings marked '($)' may trigger package precompilation):\n\n"
     " -v, --version              Display version information\n"
-    " -h, --help                 Print this message (--help-hidden for more)\n"
-    " --help-hidden              Uncommon options not shown by `-h`\n\n"
+    " -h, --help                 Print command-line options (this message)\n"
+    " --help-hidden              Print uncommon options not shown by `-h`\n\n"
 
     // startup options
-    " --project[={<dir>|@.}]     Set <dir> as the active project/environment\n"
+    " --project[={<dir>|@.}]     Set <dir> as the active project/environment.\n"
+    "                            The default @. option will search through parent directories\n"
+    "                            until a Project.toml or JuliaProject.toml file is found.\n"
     " -J, --sysimage <file>      Start up with the given system image file\n"
     " -H, --home <dir>           Set location of `julia` executable\n"
     " --startup-file={yes*|no}   Load `JULIA_DEPOT_PATH/config/startup.jl`; if `JULIA_DEPOT_PATH`\n"
@@ -122,8 +124,12 @@ static const char opts[]  =
     "                            Use native code from system image if available\n"
     " --compiled-modules={yes*|no|existing|strict}\n"
     "                            Enable or disable incremental precompilation of modules\n"
+    "                            The `existing` option allows use of existing compiled modules that were\n"
+    "                            previously precompiled, but disallows creation of new precompile files.\n"
+    "                            The `strict` option is similar, but will error if no precompile file is found.\n"
     " --pkgimages={yes*|no|existing}\n"
-    "                            Enable or disable usage of native code caching in the form of pkgimages ($)\n\n"
+    "                            Enable or disable usage of native code caching in the form of pkgimages\n"
+    "                            The `existing` option allows use of existing pkgimages but disallows creation of new ones ($)\n\n"
 
     // actions
     " -e, --eval <expr>          Evaluate <expr>\n"
@@ -136,7 +142,7 @@ static const char opts[]  =
     " -t, --threads {auto|N[,auto|M]}\n"
     "                           Enable N[+M] threads; N threads are assigned to the `default`\n"
     "                           threadpool, and if M is specified, M threads are assigned to the\n"
-    "                           `interactive` threadpool; \"auto\" tries to infer a useful\n"
+    "                           `interactive` threadpool; `auto` tries to infer a useful\n"
     "                           default number of threads to use but the exact behavior might change\n"
     "                           in the future. Currently sets N to the number of CPUs assigned to\n"
     "                           this Julia process based on the OS-specific affinity assignment\n"
@@ -146,7 +152,7 @@ static const char opts[]  =
     " --gcthreads=N[,M]         Use N threads for the mark phase of GC and M (0 or 1) threads for the concurrent sweeping phase of GC.\n"
     "                           N is set to half of the number of compute threads and M is set to 0 if unspecified.\n"
     " -p, --procs {N|auto}      Integer value N launches N additional local worker processes\n"
-    "                           \"auto\" launches as many workers as the number of local CPU threads (logical cores)\n"
+    "                           `auto` launches as many workers as the number of local CPU threads (logical cores)\n"
     " --machine-file <file>     Run processes on hosts listed in <file>\n\n"
 
     // interactive options
@@ -164,20 +170,20 @@ static const char opts[]  =
 
     // code generation options
     " -C, --cpu-target <target>  Limit usage of CPU features up to <target>; set to `help` to see the available options\n"
-    " -O, --optimize={0,1,2*,3}  Set the optimization level (level 3 if `-O` is used without a level) ($)\n"
-    " --min-optlevel={0*,1,2,3}  Set a lower bound on the optimization level\n"
+    " -O, --optimize={0|1|2*|3}  Set the optimization level (level 3 if `-O` is used without a level) ($)\n"
+    " --min-optlevel={0*|1|2|3}  Set a lower bound on the optimization level\n"
 #ifdef JL_DEBUG_BUILD
-        " -g, --debug-info=[{0,1,2*}] Set the level of debug info generation in the julia-debug build ($)\n"
+        " -g, --debug-info=[{0|1|2*}] Set the level of debug info generation in the julia-debug build ($)\n"
 #else
-        " -g, --debug-info=[{0,1*,2}] Set the level of debug info generation (level 2 if `-g` is used without a level) ($)\n"
+        " -g, --debug-info=[{0|1*|2}] Set the level of debug info generation (level 2 if `-g` is used without a level) ($)\n"
 #endif
     " --inline={yes*|no}         Control whether inlining is permitted, including overriding @inline declarations\n"
     " --check-bounds={yes|no|auto*}\n"
     "                            Emit bounds checks always, never, or respect @inbounds declarations ($)\n"
+    " --math-mode={ieee|user*}   Always follow `ieee` floating point semantics or respect `@fastmath` declarations\n\n"
 #ifdef USE_POLLY
     " --polly={yes*|no}          Enable or disable the polyhedral optimizer Polly (overrides @polly declaration)\n"
 #endif
-    " --math-mode={ieee|user*}   Always follow `ieee` floating point semantics or respect `@fastmath` declarations\n\n"
 
     // instrumentation options
     " --code-coverage[={none*|user|all}]\n"
@@ -223,7 +229,7 @@ static const char opts_hidden[]  =
     " --output-asm <name>      Generate an assembly file (.s)\n"
     " --output-incremental={yes|no*}\n"
     "                          Generate an incremental output file (rather than complete)\n"
-    " --trace-compile={stderr,name}\n"
+    " --trace-compile={stderr|name}\n"
     "                          Print precompile statements for methods compiled during execution or save to a path\n"
     " --image-codegen          Force generate code in imaging mode\n"
     " --permalloc-pkgimg={yes|no*} Copy the data section of package images into memory\n"

From e64fa86a7f2c0347cfbf8abc3b5db32168fea2bf Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 5 Apr 2024 07:17:06 +0530
Subject: [PATCH 1228/1315] Add missing methods for UniformScaling (#53949)

The methods `float`, `cis`, `sincos` and `sincosd` are defined for
matrices, so it makes sense for these to be defined for a
`UniformScaling` as well.
E.g.:
```julia
julia> float(2I)
UniformScaling{Float64}
2.0*I

julia> sincos(2I)
(UniformScaling{Float64}(0.9092974268256817), UniformScaling{Float64}(-0.4161468365471424))
```
---
 stdlib/LinearAlgebra/src/uniformscaling.jl  | 9 +++++++--
 stdlib/LinearAlgebra/test/uniformscaling.jl | 7 ++++++-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/uniformscaling.jl b/stdlib/LinearAlgebra/src/uniformscaling.jl
index 5c052df1ff48e..b75886b8d99fb 100644
--- a/stdlib/LinearAlgebra/src/uniformscaling.jl
+++ b/stdlib/LinearAlgebra/src/uniformscaling.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-import Base: copy, adjoint, getindex, show, transpose, one, zero, inv,
+import Base: copy, adjoint, getindex, show, transpose, one, zero, inv, float,
              hcat, vcat, hvcat, ^
 
 """
@@ -124,6 +124,8 @@ conj(J::UniformScaling) = UniformScaling(conj(J.λ))
 real(J::UniformScaling) = UniformScaling(real(J.λ))
 imag(J::UniformScaling) = UniformScaling(imag(J.λ))
 
+float(J::UniformScaling) = UniformScaling(float(J.λ))
+
 transpose(J::UniformScaling) = J
 adjoint(J::UniformScaling) = UniformScaling(conj(J.λ))
 
@@ -159,7 +161,7 @@ isposdef(J::UniformScaling) = isposdef(J.λ)
 (-)(A::AbstractMatrix, J::UniformScaling)   = A + (-J)
 
 # matrix functions
-for f in ( :exp,   :log,
+for f in ( :exp,   :log, :cis,
            :expm1, :log1p,
            :sqrt,  :cbrt,
            :sin,   :cos,   :tan,
@@ -172,6 +174,9 @@ for f in ( :exp,   :log,
            :acsch, :asech, :acoth )
     @eval Base.$f(J::UniformScaling) = UniformScaling($f(J.λ))
 end
+for f in (:sincos, :sincosd)
+    @eval Base.$f(J::UniformScaling) = map(UniformScaling, $f(J.λ))
+end
 
 # Unit{Lower/Upper}Triangular matrices become {Lower/Upper}Triangular under
 # addition with a UniformScaling
diff --git a/stdlib/LinearAlgebra/test/uniformscaling.jl b/stdlib/LinearAlgebra/test/uniformscaling.jl
index 6719714049b1e..92547e8648d8a 100644
--- a/stdlib/LinearAlgebra/test/uniformscaling.jl
+++ b/stdlib/LinearAlgebra/test/uniformscaling.jl
@@ -24,6 +24,7 @@ Random.seed!(1234543)
     @test -one(UniformScaling(2)) == UniformScaling(-1)
     @test opnorm(UniformScaling(1+im)) ≈ sqrt(2)
     @test convert(UniformScaling{Float64}, 2I) === 2.0I
+    @test float(2I) === 2.0*I
 end
 
 @testset "getindex" begin
@@ -67,7 +68,7 @@ end
 
     # on complex plane
     J = UniformScaling(randn(ComplexF64))
-    for f in ( exp,   log,
+    for f in ( exp,   log, cis,
                sqrt,
                sin,   cos,   tan,
                asin,  acos,  atan,
@@ -80,6 +81,10 @@ end
         @test f(J) ≈ f(M(J))
     end
 
+    for f in (sincos, sincosd)
+        @test all(splat(≈), zip(f(J), f(M(J))))
+    end
+
     # on real axis
     for (λ, fs) in (
         # functions defined for x ∈ ℝ

From 57bbff63b8e74c78ffe185296eaba5fd781bc254 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 4 Apr 2024 22:00:13 -0400
Subject: [PATCH 1229/1315] Profile: make heap snapshots viewable in vscode
 viewer (#53833)

---
 src/gc-heap-snapshot.cpp                      | 24 ++++++++++++++---
 stdlib/Manifest.toml                          | 13 +++++-----
 stdlib/Profile/Project.toml                   |  6 +++++
 stdlib/Profile/src/Profile.jl                 |  1 +
 stdlib/Profile/src/heapsnapshot_reassemble.jl | 26 ++++++++++++++++---
 5 files changed, 57 insertions(+), 13 deletions(-)

diff --git a/src/gc-heap-snapshot.cpp b/src/gc-heap-snapshot.cpp
index 5007f88939701..77a6e70a127e6 100644
--- a/src/gc-heap-snapshot.cpp
+++ b/src/gc-heap-snapshot.cpp
@@ -606,7 +606,9 @@ void _record_gc_just_edge(const char *edge_type, size_t from_idx, size_t to_idx,
 void final_serialize_heap_snapshot(ios_t *json, ios_t *strings, HeapSnapshot &snapshot, char all_one)
 {
     // mimicking https://github.com/nodejs/node/blob/5fd7a72e1c4fbaf37d3723c4c81dce35c149dc84/deps/v8/src/profiler/heap-snapshot-generator.cc#L2567-L2567
+    // also https://github.com/microsoft/vscode-v8-heap-tools/blob/c5b34396392397925ecbb4ecb904a27a2754f2c1/v8-heap-parser/src/decoder.rs#L43-L51
     ios_printf(json, "{\"snapshot\":{");
+
     ios_printf(json, "\"meta\":{");
     ios_printf(json, "\"node_fields\":[\"type\",\"name\",\"id\",\"self_size\",\"edge_count\",\"trace_node_id\",\"detachedness\"],");
     ios_printf(json, "\"node_types\":[");
@@ -617,10 +619,26 @@ void final_serialize_heap_snapshot(ios_t *json, ios_t *strings, HeapSnapshot &sn
     ios_printf(json, "\"edge_types\":[");
     snapshot.edge_types.print_json_array(json, false);
     ios_printf(json, ",");
-    ios_printf(json, "\"string_or_number\",\"from_node\"]");
+    ios_printf(json, "\"string_or_number\",\"from_node\"],");
+    // not used. Required by microsoft/vscode-v8-heap-tools
+    ios_printf(json, "\"trace_function_info_fields\":[\"function_id\",\"name\",\"script_name\",\"script_id\",\"line\",\"column\"],");
+    ios_printf(json, "\"trace_node_fields\":[\"id\",\"function_info_index\",\"count\",\"size\",\"children\"],");
+    ios_printf(json, "\"sample_fields\":[\"timestamp_us\",\"last_assigned_id\"],");
+    ios_printf(json, "\"location_fields\":[\"object_index\",\"script_id\",\"line\",\"column\"]");
+    // end not used
     ios_printf(json, "},\n"); // end "meta"
+
     ios_printf(json, "\"node_count\":%zu,", snapshot.num_nodes);
-    ios_printf(json, "\"edge_count\":%zu", snapshot.num_edges);
-    ios_printf(json, "}\n"); // end "snapshot"
+    ios_printf(json, "\"edge_count\":%zu,", snapshot.num_edges);
+    ios_printf(json, "\"trace_function_count\":0"); // not used. Required by microsoft/vscode-v8-heap-tools
+    ios_printf(json, "},\n"); // end "snapshot"
+
+    // not used. Required by microsoft/vscode-v8-heap-tools
+    ios_printf(json, "\"trace_function_infos\":[],");
+    ios_printf(json, "\"trace_tree\":[],");
+    ios_printf(json, "\"samples\":[],");
+    ios_printf(json, "\"locations\":[]");
+    // end not used
+
     ios_printf(json, "}");
 }
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index 4df442c6833d1..858e5ea651339 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -2,7 +2,7 @@
 
 julia_version = "1.12.0-DEV"
 manifest_format = "2.0"
-project_hash = "13f2dd600364a1e8b659dc5796bf185b37d1c95d"
+project_hash = "d3a1f6b706609fe0c59521e1d770be6e2b8c489d"
 
 [[deps.ArgTools]]
 uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"
@@ -23,7 +23,7 @@ version = "1.11.0"
 [[deps.CompilerSupportLibraries_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"
-version = "1.1.0+0"
+version = "1.1.1+0"
 
 [[deps.Dates]]
 deps = ["Printf"]
@@ -113,7 +113,7 @@ version = "1.11.0+1"
 [[deps.LibUV_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "183b4373-6708-53ba-ad28-60e28bb38547"
-version = "2.0.1+15"
+version = "2.0.1+16"
 
 [[deps.LibUnwind_jll]]
 deps = ["Artifacts", "Libdl"]
@@ -155,7 +155,7 @@ version = "1.11.0"
 
 [[deps.MozillaCACerts_jll]]
 uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
-version = "2023.12.12"
+version = "2024.3.11"
 
 [[deps.NetworkOptions]]
 uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
@@ -177,9 +177,9 @@ uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15"
 version = "10.43.0+0"
 
 [[deps.Pkg]]
-deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
+deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"]
 uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
-version = "1.11.0"
+version = "1.12.0"
 weakdeps = ["REPL"]
 
     [deps.Pkg.extensions]
@@ -191,6 +191,7 @@ uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 version = "1.11.0"
 
 [[deps.Profile]]
+deps = ["Unicode"]
 uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
 version = "1.11.0"
 
diff --git a/stdlib/Profile/Project.toml b/stdlib/Profile/Project.toml
index ad0107ecf9404..ede7ccd66bc8e 100644
--- a/stdlib/Profile/Project.toml
+++ b/stdlib/Profile/Project.toml
@@ -2,6 +2,12 @@ name = "Profile"
 uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
 version = "1.11.0"
 
+[deps]
+Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
+
+[compat]
+Unicode = "1.11.0"
+
 [extras]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index 17e903ed373b1..062b608b25c59 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -1286,6 +1286,7 @@ function take_heap_snapshot(filepath::AbstractString, all_one::Bool=false; strea
         prefix = filepath
         _stream_heap_snapshot(prefix, all_one)
         Profile.HeapSnapshot.assemble_snapshot(prefix, filepath)
+        Profile.HeapSnapshot.cleanup_streamed_files(prefix)
     end
     return filepath
 end
diff --git a/stdlib/Profile/src/heapsnapshot_reassemble.jl b/stdlib/Profile/src/heapsnapshot_reassemble.jl
index b39f53a8bda03..27d7d12318ed1 100644
--- a/stdlib/Profile/src/heapsnapshot_reassemble.jl
+++ b/stdlib/Profile/src/heapsnapshot_reassemble.jl
@@ -2,6 +2,8 @@
 
 module HeapSnapshot
 
+using Unicode
+
 """
     assemble_snapshot(filepath::AbstractString, out_file::AbstractString)
 
@@ -92,7 +94,7 @@ function assemble_snapshot(in_prefix, io::IO)
     node_count = parse(Int, String(@view preamble[pos:endpos]))
 
     pos = last(findnext("edge_count\":", preamble, endpos)) + 1
-    endpos = findnext(==('}'), preamble, pos) - 1
+    endpos = findnext(==(','), preamble, pos) - 1
     edge_count = parse(Int, String(@view preamble[pos:endpos]))
 
     nodes = Nodes(node_count, edge_count)
@@ -137,7 +139,8 @@ function assemble_snapshot(in_prefix, io::IO)
     end
 
     _digits_buf = zeros(UInt8, ndigits(typemax(UInt)))
-    println(io, @view(preamble[1:end-2]), ",") # remove trailing "}\n", we don't end the snapshot here
+    println(io, @view(preamble[1:end-1]), ",") # remove trailing "}" to reopen the object
+
     println(io, "\"nodes\":[")
     for i in 1:length(nodes)
         i > 1 && println(io, ",")
@@ -182,12 +185,11 @@ function assemble_snapshot(in_prefix, io::IO)
             str_bytes = read(strings_io, str_size)
             str = String(str_bytes)
             if first
-                print_str_escape_json(io, str)
                 first = false
             else
                 print(io, ",\n")
-                print_str_escape_json(io, str)
             end
+            print_str_escape_json(io, str)
         end
     end
     print(io, "]}")
@@ -202,6 +204,19 @@ function assemble_snapshot(in_prefix, io::IO)
     return nothing
 end
 
+"""
+    cleanup_streamed_files(prefix::AbstractString)
+
+Remove files streamed during `take_heap_snapshot` in streaming mode.
+"""
+function cleanup_streamed_files(prefix::AbstractString)
+    rm(string(prefix, ".metadata.json"))
+    rm(string(prefix, ".nodes"))
+    rm(string(prefix, ".edges"))
+    rm(string(prefix, ".strings"))
+    return nothing
+end
+
 function print_str_escape_json(stream::IO, s::AbstractString)
     print(stream, '"')
     for c in s
@@ -221,6 +236,9 @@ function print_str_escape_json(stream::IO, s::AbstractString)
             print(stream, "\\t")
         elseif '\x00' <= c <= '\x1f'
             print(stream, "\\u", lpad(string(UInt16(c), base=16), 4, '0'))
+        elseif !Unicode.isassigned(c)
+            # we have to do this because vscode's viewer doesn't like the replace character
+            print(stream, "[invalid unicode character]")
         else
             print(stream, c)
         end

From 6ea67a944501d16d5939f60d63cdb1fc779fec40 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 5 Apr 2024 11:12:46 +0900
Subject: [PATCH 1230/1315] change the variable name `linfo::MethodInstance` to
 `mi::MethodInstance` (#53952)

---
 base/compiler/abstractinterpretation.jl | 22 ++++----
 base/compiler/inferenceresult.jl        | 68 +++++++++++++------------
 base/compiler/inferencestate.jl         | 28 +++++-----
 base/compiler/optimize.jl               | 14 ++---
 base/compiler/ssair/show.jl             |  4 +-
 base/compiler/tfuncs.jl                 |  4 +-
 base/compiler/typeinfer.jl              |  2 +-
 base/compiler/types.jl                  | 16 +++---
 base/compiler/validation.jl             | 10 ++--
 9 files changed, 85 insertions(+), 83 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 51794e9e1eb7c..75c8e841b7e10 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1292,20 +1292,20 @@ struct ConditionalArgtypes <: ForwardableArgtypes
 end
 
 """
-    matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance,
+    matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance,
                             conditional_argtypes::ConditionalArgtypes)
 
 The implementation is able to forward `Conditional` of `conditional_argtypes`,
 as well as the other general extended lattice information.
 """
-function matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance,
+function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance,
                                  conditional_argtypes::ConditionalArgtypes)
     (; arginfo, sv) = conditional_argtypes
     (; fargs, argtypes) = arginfo
     given_argtypes = Vector{Any}(undef, length(argtypes))
-    def = linfo.def::Method
+    def = mi.def::Method
     nargs = Int(def.nargs)
-    cache_argtypes, overridden_by_const = matching_cache_argtypes(𝕃, linfo)
+    cache_argtypes, overridden_by_const = matching_cache_argtypes(𝕃, mi)
     local condargs = nothing
     for i in 1:length(argtypes)
         argtype = argtypes[i]
@@ -1336,7 +1336,7 @@ function matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance,
     end
     if condargs !== nothing
         given_argtypes = let condargs=condargs
-            va_process_argtypes(𝕃, given_argtypes, linfo) do isva_given_argtypes::Vector{Any}, last::Int
+            va_process_argtypes(𝕃, given_argtypes, mi) do isva_given_argtypes::Vector{Any}, last::Int
                 # invalidate `Conditional` imposed on varargs
                 for (slotid, i) in condargs
                     if slotid ≥ last && (1 ≤ i ≤ length(isva_given_argtypes)) # `Conditional` is already widened to vararg-tuple otherwise
@@ -1346,7 +1346,7 @@ function matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance,
             end
         end
     else
-        given_argtypes = va_process_argtypes(𝕃, given_argtypes, linfo)
+        given_argtypes = va_process_argtypes(𝕃, given_argtypes, mi)
     end
     return pick_const_args!(𝕃, cache_argtypes, overridden_by_const, given_argtypes)
 end
@@ -2278,7 +2278,7 @@ function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo, si::StmtIn
     return abstract_call_known(interp, f, arginfo, si, sv, max_methods)
 end
 
-function sp_type_rewrap(@nospecialize(T), linfo::MethodInstance, isreturn::Bool)
+function sp_type_rewrap(@nospecialize(T), mi::MethodInstance, isreturn::Bool)
     isref = false
     if unwrapva(T) === Bottom
         return Bottom
@@ -2293,12 +2293,12 @@ function sp_type_rewrap(@nospecialize(T), linfo::MethodInstance, isreturn::Bool)
     else
         return Any
     end
-    if isa(linfo.def, Method)
-        spsig = linfo.def.sig
+    if isa(mi.def, Method)
+        spsig = mi.def.sig
         if isa(spsig, UnionAll)
-            if !isempty(linfo.sparam_vals)
+            if !isempty(mi.sparam_vals)
                 sparam_vals = Any[isvarargtype(v) ? TypeVar(:N, Union{}, Any) :
-                                  v for v in  linfo.sparam_vals]
+                                  v for v in  mi.sparam_vals]
                 T = ccall(:jl_instantiate_type_in_env, Any, (Any, Any, Ptr{Any}), T, spsig, sparam_vals)
                 isref && isreturn && T === Any && return Bottom # catch invalid return Ref{T} where T = Any
                 for v in sparam_vals
diff --git a/base/compiler/inferenceresult.jl b/base/compiler/inferenceresult.jl
index 86eed13686ae9..06fbffaa7aa04 100644
--- a/base/compiler/inferenceresult.jl
+++ b/base/compiler/inferenceresult.jl
@@ -1,31 +1,32 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
-    matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance) ->
+    matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance) ->
         (cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
 
-Returns argument types `cache_argtypes::Vector{Any}` for `linfo` that are in the native
+Returns argument types `cache_argtypes::Vector{Any}` for `mi` that are in the native
 Julia type domain. `overridden_by_const::BitVector` is all `false` meaning that
 there is no additional extended lattice information there.
 
-    matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance, argtypes::ForwardableArgtypes) ->
+    matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance, argtypes::ForwardableArgtypes) ->
         (cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
 
 Returns cache-correct extended lattice argument types `cache_argtypes::Vector{Any}`
-for `linfo` given some `argtypes` accompanied by `overridden_by_const::BitVector`
+for `mi` given some `argtypes` accompanied by `overridden_by_const::BitVector`
 that marks which argument contains additional extended lattice information.
 
 In theory, there could be a `cache` containing a matching `InferenceResult`
-for the provided `linfo` and `given_argtypes`. The purpose of this function is
-to return a valid value for `cache_lookup(𝕃, linfo, argtypes, cache).argtypes`,
+for the provided `mi` and `given_argtypes`. The purpose of this function is
+to return a valid value for `cache_lookup(𝕃, mi, argtypes, cache).argtypes`,
 so that we can construct cache-correct `InferenceResult`s in the first place.
 """
 function matching_cache_argtypes end
 
-function matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance)
-    mthd = isa(linfo.def, Method) ? linfo.def::Method : nothing
-    cache_argtypes = most_general_argtypes(mthd, linfo.specTypes)
-    return cache_argtypes, falses(length(cache_argtypes))
+function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance)
+    method = isa(mi.def, Method) ? mi.def::Method : nothing
+    cache_argtypes = most_general_argtypes(method, mi.specTypes)
+    overridden_by_const = falses(length(cache_argtypes))
+    return cache_argtypes, overridden_by_const
 end
 
 struct SimpleArgtypes <: ForwardableArgtypes
@@ -33,25 +34,25 @@ struct SimpleArgtypes <: ForwardableArgtypes
 end
 
 """
-    matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance, argtypes::SimpleArgtypes)
+    matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance, argtypes::SimpleArgtypes)
 
 The implementation for `argtypes` with general extended lattice information.
 This is supposed to be used for debugging and testing or external `AbstractInterpreter`
 usages and in general `matching_cache_argtypes(::MethodInstance, ::ConditionalArgtypes)`
 is more preferred it can forward `Conditional` information.
 """
-function matching_cache_argtypes(𝕃::AbstractLattice, linfo::MethodInstance, simple_argtypes::SimpleArgtypes)
+function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance, simple_argtypes::SimpleArgtypes)
     (; argtypes) = simple_argtypes
     given_argtypes = Vector{Any}(undef, length(argtypes))
     for i = 1:length(argtypes)
         given_argtypes[i] = widenslotwrapper(argtypes[i])
     end
-    given_argtypes = va_process_argtypes(𝕃, given_argtypes, linfo)
-    return pick_const_args(𝕃, linfo, given_argtypes)
+    given_argtypes = va_process_argtypes(𝕃, given_argtypes, mi)
+    return pick_const_args(𝕃, mi, given_argtypes)
 end
 
-function pick_const_args(𝕃::AbstractLattice, linfo::MethodInstance, given_argtypes::Vector{Any})
-    cache_argtypes, overridden_by_const = matching_cache_argtypes(𝕃, linfo)
+function pick_const_args(𝕃::AbstractLattice, mi::MethodInstance, given_argtypes::Vector{Any})
+    cache_argtypes, overridden_by_const = matching_cache_argtypes(𝕃, mi)
     return pick_const_args!(𝕃, cache_argtypes, overridden_by_const, given_argtypes)
 end
 
@@ -60,7 +61,7 @@ function pick_const_args!(𝕃::AbstractLattice, cache_argtypes::Vector{Any}, ov
         given_argtype = given_argtypes[i]
         cache_argtype = cache_argtypes[i]
         if !is_argtype_match(𝕃, given_argtype, cache_argtype, false)
-            # prefer the argtype we were given over the one computed from `linfo`
+            # prefer the argtype we were given over the one computed from `mi`
             if (isa(given_argtype, PartialStruct) && isa(cache_argtype, Type) &&
                 !⊏(𝕃, given_argtype, cache_argtype))
                 # if the type information of this `PartialStruct` is less strict than
@@ -80,8 +81,9 @@ function is_argtype_match(𝕃::AbstractLattice,
                           overridden_by_const::Bool)
     if is_forwardable_argtype(𝕃, given_argtype)
         return is_lattice_equal(𝕃, given_argtype, cache_argtype)
+    else
+        return !overridden_by_const
     end
-    return !overridden_by_const
 end
 
 va_process_argtypes(𝕃::AbstractLattice, given_argtypes::Vector{Any}, mi::MethodInstance) =
@@ -114,24 +116,24 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
     withfirst::Bool = true)
     toplevel = method === nothing
     isva = !toplevel && method.isva
-    linfo_argtypes = Any[(unwrap_unionall(specTypes)::DataType).parameters...]
+    mi_argtypes = Any[(unwrap_unionall(specTypes)::DataType).parameters...]
     nargs::Int = toplevel ? 0 : method.nargs
     # For opaque closure, the closure environment is processed elsewhere
     withfirst || (nargs -= 1)
     cache_argtypes = Vector{Any}(undef, nargs)
     # First, if we're dealing with a varargs method, then we set the last element of `args`
     # to the appropriate `Tuple` type or `PartialStruct` instance.
+    mi_argtypes_length = length(mi_argtypes)
     if !toplevel && isva
         if specTypes::Type == Tuple
-            linfo_argtypes = Any[Any for i = 1:nargs]
+            mi_argtypes = Any[Any for i = 1:nargs]
             if nargs > 1
-                linfo_argtypes[end] = Tuple
+                mi_argtypes[end] = Tuple
             end
             vargtype = Tuple
         else
-            linfo_argtypes_length = length(linfo_argtypes)
-            if nargs > linfo_argtypes_length
-                va = linfo_argtypes[linfo_argtypes_length]
+            if nargs > mi_argtypes_length
+                va = mi_argtypes[mi_argtypes_length]
                 if isvarargtype(va)
                     new_va = rewrap_unionall(unconstrain_vararg_length(va), specTypes)
                     vargtype = Tuple{new_va}
@@ -140,8 +142,8 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
                 end
             else
                 vargtype_elements = Any[]
-                for i in nargs:linfo_argtypes_length
-                    p = linfo_argtypes[i]
+                for i in nargs:mi_argtypes_length
+                    p = mi_argtypes[i]
                     p = unwraptv(isvarargtype(p) ? unconstrain_vararg_length(p) : p)
                     push!(vargtype_elements, elim_free_typevars(rewrap_unionall(p, specTypes)))
                 end
@@ -164,13 +166,12 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
     # type info as we go (where possible). Note that if we're dealing with a varargs method,
     # we already handled the last element of `cache_argtypes` (and decremented `nargs` so that
     # we don't overwrite the result of that work here).
-    linfo_argtypes_length = length(linfo_argtypes)
-    if linfo_argtypes_length > 0
-        n = linfo_argtypes_length > nargs ? nargs : linfo_argtypes_length
+    if mi_argtypes_length > 0
+        n = mi_argtypes_length > nargs ? nargs : mi_argtypes_length
         tail_index = n
         local lastatype
         for i = 1:n
-            atyp = linfo_argtypes[i]
+            atyp = mi_argtypes[i]
             if i == n && isvarargtype(atyp)
                 atyp = unwrapva(atyp)
                 tail_index -= 1
@@ -209,13 +210,14 @@ function elim_free_typevars(@nospecialize t)
     end
 end
 
-function cache_lookup(𝕃::AbstractLattice, linfo::MethodInstance, given_argtypes::Vector{Any}, cache::Vector{InferenceResult})
-    method = linfo.def::Method
+function cache_lookup(𝕃::AbstractLattice, mi::MethodInstance, given_argtypes::Vector{Any},
+                      cache::Vector{InferenceResult})
+    method = mi.def::Method
     nargs = Int(method.nargs)
     method.isva && (nargs -= 1)
     length(given_argtypes) ≥ nargs || return nothing
     for cached_result in cache
-        cached_result.linfo === linfo || continue
+        cached_result.linfo === mi || continue
         cache_argtypes = cached_result.argtypes
         cache_overridden_by_const = cached_result.overridden_by_const
         for i in 1:nargs
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 38fb13495ad85..3c71a88ab8a80 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -276,14 +276,14 @@ mutable struct InferenceState
     # src is assumed to be a newly-allocated CodeInfo, that can be modified in-place to contain intermediate results
     function InferenceState(result::InferenceResult, src::CodeInfo, cache_mode::UInt8,
                             interp::AbstractInterpreter)
-        linfo = result.linfo
+        mi = result.linfo
         world = get_inference_world(interp)
         if world == typemax(UInt)
             error("Entering inference from a generated function with an invalid world")
         end
-        def = linfo.def
+        def = mi.def
         mod = isa(def, Method) ? def.module : def
-        sptypes = sptypes_from_meth_instance(linfo)
+        sptypes = sptypes_from_meth_instance(mi)
         code = src.code::Vector{Any}
         cfg = compute_basic_blocks(code)
         method_info = MethodInfo(src)
@@ -339,7 +339,7 @@ mutable struct InferenceState
         !iszero(cache_mode & CACHE_MODE_LOCAL) && push!(get_inference_cache(interp), result)
 
         this = new(
-            linfo, world, mod, sptypes, slottypes, src, cfg, method_info,
+            mi, world, mod, sptypes, slottypes, src, cfg, method_info,
             currbb, currpc, ip, handlers, handler_at, ssavalue_uses, bb_vartables, ssavaluetypes, stmt_edges, stmt_info,
             pclimitations, limitations, cycle_backedges, callers_in_cycle, dont_work_on_me, parent,
             result, unreachable, valid_worlds, bestguess, exc_bestguess, ipo_effects,
@@ -582,13 +582,13 @@ end
 
 const EMPTY_SPTYPES = VarState[]
 
-function sptypes_from_meth_instance(linfo::MethodInstance)
-    def = linfo.def
+function sptypes_from_meth_instance(mi::MethodInstance)
+    def = mi.def
     isa(def, Method) || return EMPTY_SPTYPES # toplevel
     sig = def.sig
-    if isempty(linfo.sparam_vals)
+    if isempty(mi.sparam_vals)
         isa(sig, UnionAll) || return EMPTY_SPTYPES
-        # linfo is unspecialized
+        # mi is unspecialized
         spvals = Any[]
         sig′ = sig
         while isa(sig′, UnionAll)
@@ -596,7 +596,7 @@ function sptypes_from_meth_instance(linfo::MethodInstance)
             sig′ = sig′.body
         end
     else
-        spvals = linfo.sparam_vals
+        spvals = mi.sparam_vals
     end
     nvals = length(spvals)
     sptypes = Vector{VarState}(undef, nvals)
@@ -614,7 +614,7 @@ function sptypes_from_meth_instance(linfo::MethodInstance)
                 if isType(sⱼ) && sⱼ.parameters[1] === vᵢ
                     # if this parameter came from `arg::Type{T}`,
                     # then `arg` is more precise than `Type{T} where lb<:T<:ub`
-                    ty = fieldtype(linfo.specTypes, j)
+                    ty = fieldtype(mi.specTypes, j)
                     @goto ty_computed
                 elseif (va = va_from_vatuple(sⱼ)) !== nothing
                     # if this parameter came from `::Tuple{.., Vararg{T,vᵢ}}`,
@@ -645,8 +645,8 @@ function sptypes_from_meth_instance(linfo::MethodInstance)
                 # type variables, we can use it for a more accurate analysis of whether `v`
                 # is constrained or not, otherwise we should use `def.sig` which always
                 # doesn't contain any free type variables
-                if !has_free_typevars(linfo.specTypes)
-                    sig = linfo.specTypes
+                if !has_free_typevars(mi.specTypes)
+                    sig = mi.specTypes
                 end
                 @assert !has_free_typevars(sig)
                 constrains_param(v, sig, #=covariant=#true)
@@ -858,8 +858,8 @@ function is_effect_overridden(sv::AbsIntState, effect::Symbol)
     end
     return false
 end
-function is_effect_overridden(linfo::MethodInstance, effect::Symbol)
-    def = linfo.def
+function is_effect_overridden(mi::MethodInstance, effect::Symbol)
+    def = mi.def
     return isa(def, Method) && is_effect_overridden(def, effect)
 end
 is_effect_overridden(method::Method, effect::Symbol) = is_effect_overridden(decode_effects_override(method.purity), effect)
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index d8b307a1b7a7c..fa1bf2f1ee152 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -156,7 +156,7 @@ function OptimizationState(sv::InferenceState, interp::AbstractInterpreter)
                              sv.sptypes, sv.slottypes, inlining, sv.cfg,
                              sv.unreachable, sv.bb_vartables, sv.insert_coverage)
 end
-function OptimizationState(linfo::MethodInstance, src::CodeInfo, interp::AbstractInterpreter)
+function OptimizationState(mi::MethodInstance, src::CodeInfo, interp::AbstractInterpreter)
     # prepare src for running optimization passes if it isn't already
     nssavalues = src.ssavaluetypes
     if nssavalues isa Int
@@ -164,7 +164,7 @@ function OptimizationState(linfo::MethodInstance, src::CodeInfo, interp::Abstrac
     else
         nssavalues = length(src.ssavaluetypes::Vector{Any})
     end
-    sptypes = sptypes_from_meth_instance(linfo)
+    sptypes = sptypes_from_meth_instance(mi)
     nslots = length(src.slotflags)
     slottypes = src.slottypes
     if slottypes === nothing
@@ -172,7 +172,7 @@ function OptimizationState(linfo::MethodInstance, src::CodeInfo, interp::Abstrac
     end
     stmt_info = CallInfo[ NoCallInfo() for i = 1:nssavalues ]
     # cache some useful state computations
-    def = linfo.def
+    def = mi.def
     mod = isa(def, Method) ? def.module : def
     # Allow using the global MI cache, but don't track edges.
     # This method is mostly used for unit testing the optimizer
@@ -186,13 +186,13 @@ function OptimizationState(linfo::MethodInstance, src::CodeInfo, interp::Abstrac
             for slot = 1:nslots
         ])
     end
-    return OptimizationState(linfo, src, nothing, stmt_info, mod, sptypes, slottypes, inlining, cfg, unreachable, bb_vartables, false)
+    return OptimizationState(mi, src, nothing, stmt_info, mod, sptypes, slottypes, inlining, cfg, unreachable, bb_vartables, false)
 end
-function OptimizationState(linfo::MethodInstance, interp::AbstractInterpreter)
+function OptimizationState(mi::MethodInstance, interp::AbstractInterpreter)
     world = get_inference_world(interp)
-    src = retrieve_code_info(linfo, world)
+    src = retrieve_code_info(mi, world)
     src === nothing && return nothing
-    return OptimizationState(linfo, src, interp)
+    return OptimizationState(mi, src, interp)
 end
 
 function argextype end # imported by EscapeAnalysis
diff --git a/base/compiler/ssair/show.jl b/base/compiler/ssair/show.jl
index cfcd2ce8f3d2b..7f2854959ce5e 100644
--- a/base/compiler/ssair/show.jl
+++ b/base/compiler/ssair/show.jl
@@ -52,12 +52,12 @@ function print_stmt(io::IO, idx::Int, @nospecialize(stmt), used::BitSet, maxleng
         stmt = stmt::Expr
         # TODO: why is this here, and not in Base.show_unquoted
         print(io, "invoke ")
-        linfo = stmt.args[1]::Core.MethodInstance
+        mi = stmt.args[1]::Core.MethodInstance
         show_unquoted(io, stmt.args[2], indent)
         print(io, "(")
         # XXX: this is wrong if `sig` is not a concretetype method
         # more correct would be to use `fieldtype(sig, i)`, but that would obscure / discard Varargs information in show
-        sig = linfo.specTypes == Tuple ? Core.svec() : Base.unwrap_unionall(linfo.specTypes).parameters::Core.SimpleVector
+        sig = mi.specTypes == Tuple ? Core.svec() : Base.unwrap_unionall(mi.specTypes).parameters::Core.SimpleVector
         print_arg(i) = sprint(; context=io) do io
             show_unquoted(io, stmt.args[i], indent)
             if (i - 1) <= length(sig)
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 090be7e91fad9..07fb621554049 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -2137,7 +2137,7 @@ end
     return Type
 end
 
-@nospecs function opaque_closure_tfunc(𝕃::AbstractLattice, arg, lb, ub, source, env::Vector{Any}, linfo::MethodInstance)
+@nospecs function opaque_closure_tfunc(𝕃::AbstractLattice, arg, lb, ub, source, env::Vector{Any}, mi::MethodInstance)
     argt, argt_exact = instanceof_tfunc(arg)
     lbt, lb_exact = instanceof_tfunc(lb)
     if !lb_exact
@@ -2151,7 +2151,7 @@ end
 
     (isa(source, Const) && isa(source.val, Method)) || return t
 
-    return PartialOpaque(t, tuple_tfunc(𝕃, env), linfo, source.val)
+    return PartialOpaque(t, tuple_tfunc(𝕃, env), mi, source.val)
 end
 
 # whether getindex for the elements can potentially throw UndefRef
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 02ec583316de0..825045670e350 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -339,7 +339,7 @@ function CodeInstance(interp::AbstractInterpreter, result::InferenceResult;
 end
 
 function transform_result_for_cache(interp::AbstractInterpreter,
-        linfo::MethodInstance, valid_worlds::WorldRange, result::InferenceResult,
+        ::MethodInstance, valid_worlds::WorldRange, result::InferenceResult,
         can_discard_trees::Bool=may_discard_trees(interp))
     return result.src
 end
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index 64410d231adda..3017976b66949 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -70,7 +70,7 @@ end
 const NULL_ANALYSIS_RESULTS = AnalysisResults(nothing)
 
 """
-    InferenceResult(linfo::MethodInstance, [argtypes::ForwardableArgtypes, 𝕃::AbstractLattice])
+    InferenceResult(mi::MethodInstance, [argtypes::ForwardableArgtypes, 𝕃::AbstractLattice])
 
 A type that represents the result of running type inference on a chunk of code.
 
@@ -89,18 +89,18 @@ mutable struct InferenceResult
     analysis_results::AnalysisResults # AnalysisResults with e.g. result::ArgEscapeCache if optimized, otherwise NULL_ANALYSIS_RESULTS
     is_src_volatile::Bool    # `src` has been cached globally as the compressed format already, allowing `src` to be used destructively
     ci::CodeInstance         # CodeInstance if this result has been added to the cache
-    function InferenceResult(linfo::MethodInstance, cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
-        # def = linfo.def
+    function InferenceResult(mi::MethodInstance, cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
+        # def = mi.def
         # nargs = def isa Method ? Int(def.nargs) : 0
         # @assert length(cache_argtypes) == nargs
-        return new(linfo, cache_argtypes, overridden_by_const, nothing, nothing, nothing,
+        return new(mi, cache_argtypes, overridden_by_const, nothing, nothing, nothing,
             WorldRange(), Effects(), Effects(), NULL_ANALYSIS_RESULTS, false)
     end
 end
-InferenceResult(linfo::MethodInstance, 𝕃::AbstractLattice=fallback_lattice) =
-    InferenceResult(linfo, matching_cache_argtypes(𝕃, linfo)...)
-InferenceResult(linfo::MethodInstance, argtypes::ForwardableArgtypes, 𝕃::AbstractLattice=fallback_lattice) =
-    InferenceResult(linfo, matching_cache_argtypes(𝕃, linfo, argtypes)...)
+InferenceResult(mi::MethodInstance, 𝕃::AbstractLattice=fallback_lattice) =
+    InferenceResult(mi, matching_cache_argtypes(𝕃, mi)...)
+InferenceResult(mi::MethodInstance, argtypes::ForwardableArgtypes, 𝕃::AbstractLattice=fallback_lattice) =
+    InferenceResult(mi, matching_cache_argtypes(𝕃, mi, argtypes)...)
 
 function stack_analysis_result!(inf_result::InferenceResult, @nospecialize(result))
     return inf_result.analysis_results = AnalysisResults(result, inf_result.analysis_results)
diff --git a/base/compiler/validation.jl b/base/compiler/validation.jl
index fe3d002a43d6e..3d0db1a09afcc 100644
--- a/base/compiler/validation.jl
+++ b/base/compiler/validation.jl
@@ -64,17 +64,17 @@ struct InvalidCodeError <: Exception
 end
 InvalidCodeError(kind::AbstractString) = InvalidCodeError(kind, nothing)
 
-function maybe_validate_code(linfo::MethodInstance, src::CodeInfo, kind::String)
+function maybe_validate_code(mi::MethodInstance, src::CodeInfo, kind::String)
     if is_asserts()
-        errors = validate_code(linfo, src)
+        errors = validate_code(mi, src)
         if !isempty(errors)
             for e in errors
-                if linfo.def isa Method
+                if mi.def isa Method
                     println(stderr, "WARNING: Encountered invalid ", kind, " code for method ",
-                            linfo.def, ": ", e)
+                            mi.def, ": ", e)
                 else
                     println(stderr, "WARNING: Encountered invalid ", kind, " code for top level expression in ",
-                            linfo.def, ": ", e)
+                            mi.def, ": ", e)
                 end
             end
             error("")

From 5f4dec10a3564a8ba6e007cde5f719b015fe6e6c Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Fri, 5 Apr 2024 10:44:53 +0200
Subject: [PATCH 1231/1315] make loading work with a `entryfile` entry in the
 manifest file (#53939)

also soft deprecate the `path` entry in project file in favour of using
`entryfile` instead

Fixes the Julia Base part of #53937
---
 base/loading.jl                               | 41 +++++++++++--------
 doc/src/manual/code-loading.md                | 12 +++---
 test/loading.jl                               | 17 +++++++-
 test/project/ProjectPath/CustomPath.jl        |  5 +++
 test/project/ProjectPath/Manifest.toml        | 18 ++++++++
 test/project/ProjectPath/Project.toml         |  7 ++++
 .../ProjectPath/ProjectPathDep/CustomPath.jl  |  5 +++
 .../ProjectPath/ProjectPathDep/Project.toml   |  4 ++
 8 files changed, 85 insertions(+), 24 deletions(-)
 create mode 100644 test/project/ProjectPath/CustomPath.jl
 create mode 100644 test/project/ProjectPath/Manifest.toml
 create mode 100644 test/project/ProjectPath/Project.toml
 create mode 100644 test/project/ProjectPath/ProjectPathDep/CustomPath.jl
 create mode 100644 test/project/ProjectPath/ProjectPathDep/Project.toml

diff --git a/base/loading.jl b/base/loading.jl
index 882ae3a68a836..d49c8aa91e3b7 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -426,7 +426,6 @@ function locate_package_env(pkg::PkgId, stopenv::Union{String, Nothing}=nothing)
                 @goto done
             end
             if path !== nothing
-                path = entry_path(path, pkg.name)
                 env′ = env
                 @goto done
             end
@@ -438,12 +437,15 @@ function locate_package_env(pkg::PkgId, stopenv::Union{String, Nothing}=nothing)
         # e.g. if they have been explicitly added to the project/manifest
         mbypath = manifest_uuid_path(Sys.STDLIB, pkg)
         if mbypath isa String
-            path = entry_path(mbypath, pkg.name)
+            path = mbypath
             env′ = Sys.STDLIB
             @goto done
         end
     end
     @label done
+    if path !== nothing && !isfile_casesensitive(path)
+        path = nothing
+    end
     if cache !== nothing
         cache.located[(pkg, stopenv)] = path === nothing ? nothing : (path, something(env′))
     end
@@ -690,7 +692,7 @@ function manifest_uuid_path(env::String, pkg::PkgId)::Union{Nothing,String,Missi
         proj = project_file_name_uuid(project_file, pkg.name)
         if proj == pkg
             # if `pkg` matches the project, return the project itself
-            return project_file_path(project_file)
+            return project_file_path(project_file, pkg.name)
         end
         mby_ext = project_file_ext_path(project_file, pkg.name)
         mby_ext === nothing || return mby_ext
@@ -725,7 +727,7 @@ end
 
 function project_file_ext_path(project_file::String, name::String)
     d = parsed_toml(project_file)
-    p = project_file_path(project_file)
+    p = dirname(project_file)
     exts = get(d, "extensions", nothing)::Union{Dict{String, Any}, Nothing}
     if exts !== nothing
         if name in keys(exts)
@@ -744,9 +746,14 @@ function project_file_name_uuid(project_file::String, name::String)::PkgId
     return PkgId(uuid, name)
 end
 
-function project_file_path(project_file::String)
+function project_file_path(project_file::String, name::String)
     d = parsed_toml(project_file)
-    joinpath(dirname(project_file), get(d, "path", "")::String)
+    entryfile = get(d, "path", nothing)::Union{String, Nothing}
+    # "path" entry in project file is soft deprecated
+    if entryfile === nothing
+        entryfile = get(d, "entryfile", nothing)::Union{String, Nothing}
+    end
+    return entry_path(dirname(project_file), name, entryfile)
 end
 
 function workspace_manifest(project_file)
@@ -837,12 +844,11 @@ function implicit_env_project_file_extension(dir::String, ext::PkgId)
     return nothing, nothing
 end
 
-# given a path and a name, return the entry point
-function entry_path(path::String, name::String)::Union{Nothing,String}
+# given a path, name, and possibly an entryfile, return the entry point
+function entry_path(path::String, name::String, entryfile::Union{Nothing,String})::String
     isfile_casesensitive(path) && return normpath(path)
-    path = normpath(joinpath(path, "src", "$name.jl"))
-    isfile_casesensitive(path) && return path
-    return nothing # source not found
+    entrypoint = entryfile === nothing ? joinpath("src", "$name.jl") : entryfile
+    return normpath(joinpath(path, entrypoint))
 end
 
 ## explicit project & manifest API ##
@@ -1016,15 +1022,16 @@ end
 
 function explicit_manifest_entry_path(manifest_file::String, pkg::PkgId, entry::Dict{String,Any})
     path = get(entry, "path", nothing)::Union{Nothing, String}
+    entryfile = get(entry, "entryfile", nothing)::Union{Nothing, String}
     if path !== nothing
-        path = normpath(abspath(dirname(manifest_file), path))
+        path = entry_path(normpath(abspath(dirname(manifest_file), path)), pkg.name, entryfile)
         return path
     end
     hash = get(entry, "git-tree-sha1", nothing)::Union{Nothing, String}
     if hash === nothing
         mbypath = manifest_uuid_path(Sys.STDLIB, pkg)
-        if mbypath isa String
-            return entry_path(mbypath, pkg.name)
+        if mbypath isa String && isfile(mbypath)
+            return mbypath
         end
         return nothing
     end
@@ -1034,7 +1041,7 @@ function explicit_manifest_entry_path(manifest_file::String, pkg::PkgId, entry::
     for slug in (version_slug(uuid, hash), version_slug(uuid, hash, 4))
         for depot in DEPOT_PATH
             path = joinpath(depot, "packages", pkg.name, slug)
-            ispath(path) && return abspath(path)
+            ispath(path) && return entry_path(abspath(path), pkg.name, entryfile)
         end
     end
     # no depot contains the package, return missing to stop looking
@@ -2504,8 +2511,8 @@ function require_stdlib(uuidkey::PkgId, ext::Union{Nothing, String}=nothing)
         uuidkey = PkgId(uuid5(uuidkey.uuid, ext), ext)
     end
     #mbypath = manifest_uuid_path(env, uuidkey)
-    #if mbypath isa String
-    #    sourcepath = entry_path(mbypath, uuidkey.name)
+    #if mbypath isa String && isfile_casesensitive(mbypath)
+    #    sourcepath = mbypath
     #else
     #    # if the user deleted the stdlib folder, we next try using their environment
     #    sourcepath = locate_package_env(uuidkey)
diff --git a/doc/src/manual/code-loading.md b/doc/src/manual/code-loading.md
index 9e753d2a7de33..35d88ed13bc89 100644
--- a/doc/src/manual/code-loading.md
+++ b/doc/src/manual/code-loading.md
@@ -160,11 +160,12 @@ What happens if `import Zebra` is evaluated in the main `App` code base? Since `
 **The paths map** of a project environment is extracted from the manifest file. The path of a package `uuid` named `X` is determined by these rules (in order):
 
 1. If the project file in the directory matches `uuid` and name `X`, then either:
-   - It has a toplevel `path` entry, then `uuid` will be mapped to that path, interpreted relative to the directory containing the project file.
-   - Otherwise, `uuid` is mapped to  `src/X.jl` relative to the directory containing the project file.
-2. If the above is not the case and the project file has a corresponding manifest file and the manifest contains a stanza matching `uuid` then:
-   - If it has a `path` entry, use that path (relative to the directory containing the manifest file).
-   - If it has a `git-tree-sha1` entry, compute a deterministic hash function of `uuid` and `git-tree-sha1`—call it `slug`—and look for a directory named `packages/X/$slug` in each directory in the Julia `DEPOT_PATH` global array. Use the first such directory that exists.
+   - It has a toplevel `entryfile` entry, then `uuid` will be mapped to that path, interpreted relative to the directory containing the project file.
+   - Otherwise, `uuid` is mapped to `src/X.jl` relative to the directory containing the project file.
+2. 1. If the above is not the case and the project file has a corresponding manifest file and the manifest contains a stanza matching `uuid` then:
+      - If it has a `path` entry, use that path (relative to the directory containing the manifest file).
+      - If it has a `git-tree-sha1` entry, compute a deterministic hash function of `uuid` and `git-tree-sha1`—call it `slug`—and look for a directory named `packages/X/$slug` in each directory in the Julia `DEPOT_PATH` global array. Use the first such directory that exists.
+   2. If this is a directory then `uuid` is mapped to `src/X.jl` unless the matching manifest stanza has an `entryfile` entry in which case this is used. In both cases, these are relative to the directory in 2.1.
 
 If any of these result in success, the path to the source code entry point will be either that result, the relative path from that result plus `src/X.jl`; otherwise, there is no path mapping for `uuid`. When loading `X`, if no source code path is found, the lookup will fail, and the user may be prompted to install the appropriate package version or to take other corrective action (e.g. declaring `X` as a dependency).
 
@@ -208,7 +209,6 @@ This example map includes three different kinds of package locations (the first
 2. The public `Priv` and `Zebra` packages are in the system depot, where packages installed and managed by the system administrator live. These are available to all users on the system.
 3. The `Pub` package is in the user depot, where packages installed by the user live. These are only available to the user who installed them.
 
-
 ### Package directories
 
 Package directories provide a simpler kind of environment without the ability to handle name collisions. In a package directory, the set of top-level packages is the set of subdirectories that "look like" packages. A package `X` exists in a package directory if the directory contains one of the following "entry point" files:
diff --git a/test/loading.jl b/test/loading.jl
index 94f27ecf888bb..182db7c4a6d15 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1609,5 +1609,20 @@ end
 
     finally
        copy!(LOAD_PATH, old_load_path)
-   end
+    end
+end
+
+@testset "project path handling" begin
+    old_load_path = copy(LOAD_PATH)
+    try
+        push!(LOAD_PATH, joinpath(@__DIR__, "project", "ProjectPath"))
+        id_project = Base.identify_package("ProjectPath")
+        Base.locate_package(id_project)
+        @test Base.locate_package(id_project) == joinpath(@__DIR__, "project", "ProjectPath", "CustomPath.jl")
+
+        id_dep = Base.identify_package("ProjectPathDep")
+        @test Base.locate_package(id_dep) == joinpath(@__DIR__, "project", "ProjectPath", "ProjectPathDep", "CustomPath.jl")
+    finally
+        copy!(LOAD_PATH, old_load_path)
+    end
 end
diff --git a/test/project/ProjectPath/CustomPath.jl b/test/project/ProjectPath/CustomPath.jl
new file mode 100644
index 0000000000000..8fe764fa066dc
--- /dev/null
+++ b/test/project/ProjectPath/CustomPath.jl
@@ -0,0 +1,5 @@
+module ProjectPath
+
+greet() = print("Hello World!")
+
+end # module ProjectPath
diff --git a/test/project/ProjectPath/Manifest.toml b/test/project/ProjectPath/Manifest.toml
new file mode 100644
index 0000000000000..123e7f575062a
--- /dev/null
+++ b/test/project/ProjectPath/Manifest.toml
@@ -0,0 +1,18 @@
+# This file is machine-generated - editing it directly is not advised
+
+julia_version = "1.12.0-DEV"
+manifest_format = "2.0"
+project_hash = "51ade905d618e4aa369bc869841376219cc36cb1"
+
+[[deps.ProjectPath]]
+deps = ["ProjectPathDep"]
+path = "."
+entryfile = "CustomPath.jl"
+uuid = "32833bde-7fc1-4d28-8365-9d01e1bcbc1b"
+version = "0.1.0"
+
+[[deps.ProjectPathDep]]
+path = "ProjectPathDep"
+entryfile = "CustomPath.jl"
+uuid = "f18633fc-8799-43ff-aa06-99ed830dc572"
+version = "0.1.0"
diff --git a/test/project/ProjectPath/Project.toml b/test/project/ProjectPath/Project.toml
new file mode 100644
index 0000000000000..a434f78e9c211
--- /dev/null
+++ b/test/project/ProjectPath/Project.toml
@@ -0,0 +1,7 @@
+name = "ProjectPath"
+uuid = "32833bde-7fc1-4d28-8365-9d01e1bcbc1b"
+entryfile = "CustomPath.jl"
+version = "0.1.0"
+
+[deps]
+ProjectPathDep = "f18633fc-8799-43ff-aa06-99ed830dc572"
diff --git a/test/project/ProjectPath/ProjectPathDep/CustomPath.jl b/test/project/ProjectPath/ProjectPathDep/CustomPath.jl
new file mode 100644
index 0000000000000..adbe508f0c7f9
--- /dev/null
+++ b/test/project/ProjectPath/ProjectPathDep/CustomPath.jl
@@ -0,0 +1,5 @@
+module ProjectPathDep
+
+greet() = print("Hello World!")
+
+end # module ProjectPathDep
diff --git a/test/project/ProjectPath/ProjectPathDep/Project.toml b/test/project/ProjectPath/ProjectPathDep/Project.toml
new file mode 100644
index 0000000000000..c69e54e8c9390
--- /dev/null
+++ b/test/project/ProjectPath/ProjectPathDep/Project.toml
@@ -0,0 +1,4 @@
+name = "ProjectPathDep"
+uuid = "f18633fc-8799-43ff-aa06-99ed830dc572"
+version = "0.1.0"
+entryfile = "CustomPath.jl"

From d505c8cdafa79387139f6cf3bf3aa43f0118c087 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 5 Apr 2024 23:18:05 +0530
Subject: [PATCH 1232/1315] `LazyString` in `LinearAlgebra.checksquare` error
 message (#53961)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This reduces dynamic dispatch and makes JET happier.
Testing on v1.11:
```julia
julia> import LinearAlgebra: checksquare

julia> using JET

julia> @report_opt checksquare(rand(2,2), rand(2,2))
═════ 4 possible errors found ═════
┌ checksquare(::Matrix{Float64}, ::Matrix{Float64}) @ LinearAlgebra /cache/build/builder-amdci4-1/julialang/julia-release-1-dot-11/usr/share/julia/stdlib/v1.11/LinearAlgebra/src/LinearAlgebra.jl:307
│┌ string(::String, ::Tuple{Int64, Int64}) @ Base ./strings/io.jl:189
││┌ print_to_string(::String, ::Tuple{Int64, Int64}) @ Base ./strings/io.jl:150
│││┌ _unsafe_take!(io::IOBuffer) @ Base ./iobuffer.jl:494
││││┌ wrap(::Type{Array}, m::MemoryRef{UInt8}, l::Int64) @ Base ./array.jl:3101
│││││ failed to optimize due to recursion: wrap(::Type{Array}, ::MemoryRef{UInt8}, ::Int64)
││││└────────────────────
│││┌ print_to_string(::String, ::Vararg{Any}) @ Base ./strings/io.jl:143
││││ runtime dispatch detected: Base._str_sizehint(%17::Any)::Int64
│││└────────────────────
│││┌ print_to_string(::String, ::Vararg{Any}) @ Base ./strings/io.jl:148
││││ runtime dispatch detected: print(%59::IOBuffer, %97::Any)::Any
│││└────────────────────
│││┌ string(::String, ::Int64, ::String, ::Tuple{Int64}, ::String, ::Int64, ::String, ::Int64, ::String) @ Base ./strings/io.jl:189
││││ failed to optimize due to recursion: string(::String, ::Int64, ::String, ::Tuple{Int64}, ::String, ::Int64, ::String, ::Int64, ::String)
│││└────────────────────

julia> function checksquare(A...) # This PR
                  sizes = Int[]
                  for a in A
                      size(a,1)==size(a,2) || throw(DimensionMismatch(lazy"matrix is not square: dimensions are $(size(a))"))
                      push!(sizes, size(a,1))
                  end
                  return sizes
              end
checksquare (generic function with 2 methods)

julia> @report_opt checksquare(rand(2,2), rand(2,2))
No errors detected

```
---
 stdlib/LinearAlgebra/src/LinearAlgebra.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index d8dd730779c26..6ed272ab42f02 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -297,14 +297,14 @@ julia> LinearAlgebra.checksquare(A, B)
 """
 function checksquare(A)
     m,n = size(A)
-    m == n || throw(DimensionMismatch("matrix is not square: dimensions are $(size(A))"))
+    m == n || throw(DimensionMismatch(lazy"matrix is not square: dimensions are $(size(A))"))
     m
 end
 
 function checksquare(A...)
     sizes = Int[]
     for a in A
-        size(a,1)==size(a,2) || throw(DimensionMismatch("matrix is not square: dimensions are $(size(a))"))
+        size(a,1)==size(a,2) || throw(DimensionMismatch(lazy"matrix is not square: dimensions are $(size(a))"))
         push!(sizes, size(a,1))
     end
     return sizes

From 0e59c9eea225ed186671de1e5fd0c249b1495c1d Mon Sep 17 00:00:00 2001
From: Zentrik <Zentrik@users.noreply.github.com>
Date: Fri, 5 Apr 2024 19:12:48 +0100
Subject: [PATCH 1233/1315] Use StringMemory instead of StringVector where
 possible (#53962)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On `1.11.0-alpha2`
Old:
```julia
@benchmark Base.dec($0x1, $0, $false)
BenchmarkTools.Trial: 10000 samples with 994 evaluations.
 Range (min … max):  33.702 ns …   4.242 μs  ┊ GC (min … max):  0.00% … 97.61%
 Time  (median):     37.626 ns               ┊ GC (median):     0.00%
 Time  (mean ± σ):   45.787 ns ± 147.794 ns  ┊ GC (mean ± σ):  14.53% ±  4.47%

    ▄▅▆▇█▇▇▅▃▃▂▂▂▁    ▁▂▁▁▁             ▁▁   ▁                 ▂
  ▄▇███████████████▇▇██████▇█▆▆▄▄▃▄▅▄▆▇████████▆▅▅▇▆▅▆▄▄▅▄▄▄▁▅ █
  33.7 ns       Histogram: log(frequency) by time      67.5 ns <

 Memory estimate: 88 bytes, allocs estimate: 3.
```
New:
```julia
BenchmarkTools.Trial: 10000 samples with 995 evaluations.
 Range (min … max):  27.538 ns …   3.397 μs  ┊ GC (min … max):  0.00% … 97.86%
 Time  (median):     30.151 ns               ┊ GC (median):     0.00%
 Time  (mean ± σ):   34.547 ns ± 105.101 ns  ┊ GC (mean ± σ):  10.37% ±  3.39%

       ▁ █▆▃  ▁
  ▂▂▃▃▅█████▆████▆▄▄▃▃▃▃▃▃▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▂▂▂▂▂▁▂▂▂▂▂▂▂▂▂▂▂▂▂ ▃
  27.5 ns         Histogram: frequency by time         43.8 ns <

 Memory estimate: 56 bytes, allocs estimate: 2.
```


Fixes #53950, actually now even faster than `1.10.2`.

It doesn't look like the length is ever changed and we don't return
these `StringMemory`s so this change should be fine.
---
 base/gmp.jl                        |  2 +-
 base/intfuncs.jl                   | 12 ++++++------
 base/strings/util.jl               |  2 +-
 base/uuid.jl                       |  2 +-
 stdlib/FileWatching/src/pidfile.jl |  2 +-
 5 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/base/gmp.jl b/base/gmp.jl
index beeec879ed487..a7caa8dfcdafd 100644
--- a/base/gmp.jl
+++ b/base/gmp.jl
@@ -754,7 +754,7 @@ function string(n::BigInt; base::Integer = 10, pad::Integer = 1)
     iszero(n) && pad < 1 && return ""
     nd1 = ndigits(n, base=base)
     nd  = max(nd1, pad)
-    sv  = Base.StringVector(nd + isneg(n))
+    sv  = Base.StringMemory(nd + isneg(n))
     GC.@preserve sv MPZ.get_str!(pointer(sv) + nd - nd1, base, n)
     @inbounds for i = (1:nd-nd1) .+ isneg(n)
         sv[i] = '0' % UInt8
diff --git a/base/intfuncs.jl b/base/intfuncs.jl
index f5185b0a9fd17..a89d45eb55fc1 100644
--- a/base/intfuncs.jl
+++ b/base/intfuncs.jl
@@ -742,7 +742,7 @@ ndigits(x::Integer; base::Integer=10, pad::Integer=1) = max(pad, ndigits0z(x, ba
 function bin(x::Unsigned, pad::Int, neg::Bool)
     m = top_set_bit(x)
     n = neg + max(pad, m)
-    a = StringVector(n)
+    a = StringMemory(n)
     # for i in 0x0:UInt(n-1) # automatic vectorization produces redundant codes
     #     @inbounds a[n - i] = 0x30 + (((x >> i) % UInt8)::UInt8 & 0x1)
     # end
@@ -769,7 +769,7 @@ end
 function oct(x::Unsigned, pad::Int, neg::Bool)
     m = div(top_set_bit(x) + 2, 3)
     n = neg + max(pad, m)
-    a = StringVector(n)
+    a = StringMemory(n)
     i = n
     while i > neg
         @inbounds a[i] = 0x30 + ((x % UInt8)::UInt8 & 0x7)
@@ -844,7 +844,7 @@ end
 
 function dec(x::Unsigned, pad::Int, neg::Bool)
     n = neg + ndigits(x, pad=pad)
-    a = StringVector(n)
+    a = StringMemory(n)
     append_c_digits_fast(n, x, a, 1)
     neg && (@inbounds a[1] = 0x2d) # UInt8('-')
     String(a)
@@ -853,7 +853,7 @@ end
 function hex(x::Unsigned, pad::Int, neg::Bool)
     m = 2 * sizeof(x) - (leading_zeros(x) >> 2)
     n = neg + max(pad, m)
-    a = StringVector(n)
+    a = StringMemory(n)
     i = n
     while i >= 2
         b = (x % UInt8)::UInt8
@@ -880,7 +880,7 @@ function _base(base::Integer, x::Integer, pad::Int, neg::Bool)
     b = (base % Int)::Int
     digits = abs(b) <= 36 ? base36digits : base62digits
     n = neg + ndigits(x, base=b, pad=pad)
-    a = StringVector(n)
+    a = StringMemory(n)
     i = n
     @inbounds while i > neg
         if b > 0
@@ -956,7 +956,7 @@ julia> bitstring(2.2)
 function bitstring(x::T) where {T}
     isprimitivetype(T) || throw(ArgumentError("$T not a primitive type"))
     sz = sizeof(T) * 8
-    str = StringVector(sz)
+    str = StringMemory(sz)
     i = sz
     @inbounds while i >= 4
         b = UInt32(sizeof(T) == 1 ? bitcast(UInt8, x) : trunc_int(UInt8, x))
diff --git a/base/strings/util.jl b/base/strings/util.jl
index 219b329d7924d..4b701001a8676 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -1061,7 +1061,7 @@ function bytes2hex end
 
 function bytes2hex(itr)
     eltype(itr) === UInt8 || throw(ArgumentError("eltype of iterator not UInt8"))
-    b = Base.StringVector(2*length(itr))
+    b = Base.StringMemory(2*length(itr))
     @inbounds for (i, x) in enumerate(itr)
         b[2i - 1] = hex_chars[1 + x >> 4]
         b[2i    ] = hex_chars[1 + x & 0xf]
diff --git a/base/uuid.jl b/base/uuid.jl
index 1ed0b81b3f178..9b2da3c6409db 100644
--- a/base/uuid.jl
+++ b/base/uuid.jl
@@ -90,7 +90,7 @@ let groupings = [36:-1:25; 23:-1:20; 18:-1:15; 13:-1:10; 8:-1:1]
     global string
     function string(u::UUID)
         u = u.value
-        a = Base.StringVector(36)
+        a = Base.StringMemory(36)
         for i in groupings
             @inbounds a[i] = hex_chars[1 + u & 0xf]
             u >>= 4
diff --git a/stdlib/FileWatching/src/pidfile.jl b/stdlib/FileWatching/src/pidfile.jl
index 0ee86e70f8465..4c821a3d897e4 100644
--- a/stdlib/FileWatching/src/pidfile.jl
+++ b/stdlib/FileWatching/src/pidfile.jl
@@ -280,7 +280,7 @@ function open_exclusive(path::String;
 end
 
 function _rand_filename(len::Int=4) # modified from Base.Libc
-    slug = Base.StringVector(len)
+    slug = Base.StringMemory(len)
     chars = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     for i = 1:len
         slug[i] = chars[(Libc.rand() % length(chars)) + 1]

From 59c3c71c6e75e2ea6872d6feb75f830c5e5c0b4d Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Fri, 5 Apr 2024 14:50:20 -0400
Subject: [PATCH 1234/1315] TOML: Improve type-stability of BigInt/UInt support
 (#53955)

From a type-stability perspective, this restores a lot of our behavior
before #47903.

As it turns out, 10 of the 11 uses of `parse_int` (now called
`parse_integer`) introduced in that PR are unnecessary since the TOML
format already requires the parsed value to be within a very limited
range.

Note that this change does not actually revert any functionality (in
contrast to #49576)
---
 base/toml_parser.jl | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/base/toml_parser.jl b/base/toml_parser.jl
index 23fc14a894c06..b31e256517a1e 100644
--- a/base/toml_parser.jl
+++ b/base/toml_parser.jl
@@ -854,7 +854,7 @@ function parse_number_or_date_start(l::Parser)
     ate, contains_underscore = @try accept_batch_underscore(l, isdigit, readed_zero)
     read_underscore |= contains_underscore
     if (read_digit || ate) && ok_end_value(peek(l))
-        return parse_int(l, contains_underscore)
+        return parse_integer(l, contains_underscore)
     end
     # Done with integers here
 
@@ -904,7 +904,18 @@ function parse_float(l::Parser, contains_underscore)::Err{Float64}
     return v
 end
 
-for (name, T1, T2, n1, n2) in (("int", Int64,  Int128,  17,  33),
+function parse_int(l::Parser, contains_underscore, base=nothing)::Err{Int64}
+    s = take_string_or_substring(l, contains_underscore)
+    v = try
+        Base.parse(Int64, s; base=base)
+    catch e
+        e isa Base.OverflowError && return(ParserError(ErrOverflowError))
+        error("internal parser error: did not correctly discredit $(repr(s)) as an int")
+    end
+    return v
+end
+
+for (name, T1, T2, n1, n2) in (("integer", Int64,  Int128,  17,  33),
                                ("hex", UInt64, UInt128, 18,  34),
                                ("oct", UInt64, UInt128, 24,  45),
                                ("bin", UInt64, UInt128, 66, 130),
@@ -1103,7 +1114,7 @@ function _parse_local_time(l::Parser, skip_hour=false)::Err{NTuple{4, Int64}}
         end
         # DateTime in base only manages 3 significant digits in fractional
         # second
-        fractional_second = parse_int(l, false)
+        fractional_second = parse_int(l, false)::Int64
         # Truncate off the rest eventual digits
         accept_batch(l, isdigit)
     end

From d963a3469d742c633bc4d6f0279dd55f19e6c353 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Fri, 5 Apr 2024 21:02:33 +0200
Subject: [PATCH 1235/1315] profile: doc: update the `Allocs.@profile` doc
 string (#53825)

---
 stdlib/Profile/src/Allocs.jl | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/stdlib/Profile/src/Allocs.jl b/stdlib/Profile/src/Allocs.jl
index a1cee98871011..31d703a151ad8 100644
--- a/stdlib/Profile/src/Allocs.jl
+++ b/stdlib/Profile/src/Allocs.jl
@@ -54,18 +54,17 @@ julia> last(sort(results.allocs, by=x->x.size))
 Profile.Allocs.Alloc(Vector{Any}, Base.StackTraces.StackFrame[_new_array_ at array.c:127, ...], 5576)
 ```
 
-The best way to visualize these is currently with the
-[PProf.jl](https://github.com/JuliaPerf/PProf.jl) package,
-by invoking `PProf.Allocs.pprof`.
-
-!!! note
-    The current implementation of the Allocations Profiler does not
-    capture types for all allocations. Allocations for which the profiler
-    could not capture the type are represented as having type
-    `Profile.Allocs.UnknownType`.
-
-    You can read more about the missing types and the plan to improve this, here:
-    <https://github.com/JuliaLang/julia/issues/43688>.
+See the profiling tutorial in the Julia documentation for more information.
+
+!!! compat "Julia 1.11"
+
+    Older versions of Julia could not capture types in all cases. In older versions of
+    Julia, if you see an allocation of type `Profile.Allocs.UnknownType`, it means that
+    the profiler doesn't know what type of object was allocated. This mainly happened when
+    the allocation was coming from generated code produced by the compiler. See
+    [issue #43688](https://github.com/JuliaLang/julia/issues/43688) for more info.
+
+    Since Julia 1.11, all allocations should have a type reported.
 
 !!! compat "Julia 1.8"
     The allocation profiler was added in Julia 1.8.

From c707a53fe6bc6f9dec10f3a8b7ecceb61cc110fb Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sat, 6 Apr 2024 17:33:33 +0530
Subject: [PATCH 1236/1315] Explicit namespaces in sort-related docstrings
 (#53968)

This represents the unexported names by the fully qualified namespace,
which makes it simpler to interpret the keyword arguments. Otherwise,
for example, it's not obvious where `Forward` comes from in the `sort`
docstring.

Also, replaces some occurrences of `instance <: Algorithm` by `instance
isa Algorithm`, which is the correct relation. This is also closer to
English, which helps with readability.

---------

Co-authored-by: Lilith Orion Hafner <lilithhafner@gmail.com>
---
 base/sort.jl | 58 ++++++++++++++++++++++++++--------------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/base/sort.jl b/base/sort.jl
index 38e89e3d3a0ce..37b05d7c8397a 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -62,7 +62,7 @@ function issorted(itr, order::Ordering)
 end
 
 """
-    issorted(v, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)
+    issorted(v, lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)
 
 Test whether a collection is in sorted order. The keywords modify what
 order is considered sorted, as described in the [`sort!`](@ref) documentation.
@@ -514,7 +514,7 @@ end
 ## sorting algorithm components ##
 
 """
-    _sort!(v::AbstractVector, a::Algorithm, o::Ordering, kw; t, offset)
+    _sort!(v::AbstractVector, a::Base.Sort.Algorithm, o::Base.Order.Ordering, kw; t, offset)
 
 An internal function that sorts `v` using the algorithm `a` under the ordering `o`,
 subject to specifications provided in `kw` (such as `lo` and `hi` in which case it only
@@ -539,7 +539,7 @@ function _sort! end
 # TODO: delete this optimization when views have no overhead.
 const UnwrappableSubArray = SubArray{T, 1, <:AbstractArray{T}, <:Tuple{AbstractUnitRange, Vararg{Number}}, true} where T
 """
-    SubArrayOptimization(next) <: Algorithm
+    SubArrayOptimization(next) isa Base.Sort.Algorithm
 
 Unwrap certain known SubArrays because views have a performance overhead 😢
 
@@ -566,7 +566,7 @@ function _sort!(v::UnwrappableSubArray, a::SubArrayOptimization, o::Ordering, kw
 end
 
 """
-    MissingOptimization(next) <: Algorithm
+    MissingOptimization(next) isa Base.Sort.Algorithm
 
 Filter out missing values.
 
@@ -625,7 +625,7 @@ function send_to_end!(f::F, v::AbstractVector; lo=firstindex(v), hi=lastindex(v)
     i - 1
 end
 """
-    send_to_end!(f::Function, v::AbstractVector, o::DirectOrdering[, end_stable]; lo, hi)
+    send_to_end!(f::Function, v::AbstractVector, o::Base.Order.DirectOrdering[, end_stable]; lo, hi)
 
 Return `(a, b)` where `v[a:b]` are the elements that are not sent to the end.
 
@@ -679,7 +679,7 @@ end
 
 
 """
-    IEEEFloatOptimization(next) <: Algorithm
+    IEEEFloatOptimization(next) isa Base.Sort.Algorithm
 
 Move NaN values to the end, partition by sign, and reinterpret the rest as unsigned integers.
 
@@ -724,7 +724,7 @@ end
 
 
 """
-    BoolOptimization(next) <: Algorithm
+    BoolOptimization(next) isa Base.Sort.Algorithm
 
 Sort `AbstractVector{Bool}`s using a specialized version of counting sort.
 
@@ -751,7 +751,7 @@ end
 
 
 """
-    IsUIntMappable(yes, no) <: Algorithm
+    IsUIntMappable(yes, no) isa Base.Sort.Algorithm
 
 Determines if the elements of a vector can be mapped to unsigned integers while preserving
 their order under the specified ordering.
@@ -773,7 +773,7 @@ end
 
 
 """
-    Small{N}(small=SMALL_ALGORITHM, big) <: Algorithm
+    Small{N}(small=SMALL_ALGORITHM, big) isa Base.Sort.Algorithm
 
 Sort inputs with `length(lo:hi) <= N` using the `small` algorithm. Otherwise use the `big`
 algorithm.
@@ -845,7 +845,7 @@ end
 
 
 """
-    CheckSorted(next) <: Algorithm
+    CheckSorted(next) isa Base.Sort.Algorithm
 
 Check if the input is already sorted and for large inputs, also check if it is
 reverse-sorted. The reverse-sorted check is unstable.
@@ -872,7 +872,7 @@ end
 
 
 """
-    ComputeExtrema(next) <: Algorithm
+    ComputeExtrema(next) isa Base.Sort.Algorithm
 
 Compute the extrema of the input under the provided order.
 
@@ -898,7 +898,7 @@ end
 
 
 """
-    ConsiderCountingSort(counting=CountingSort(), next) <: Algorithm
+    ConsiderCountingSort(counting=CountingSort(), next) isa Base.Sort.Algorithm
 
 If the input's range is small enough, use the `counting` algorithm. Otherwise, dispatch to
 the `next` algorithm.
@@ -926,7 +926,7 @@ _sort!(v::AbstractVector, a::ConsiderCountingSort, o::Ordering, kw) = _sort!(v,
 
 
 """
-    CountingSort <: Algorithm
+    CountingSort() isa Base.Sort.Algorithm
 
 Use the counting sort algorithm.
 
@@ -962,7 +962,7 @@ end
 
 
 """
-    ConsiderRadixSort(radix=RadixSort(), next) <: Algorithm
+    ConsiderRadixSort(radix=RadixSort(), next) isa Base.Sort.Algorithm
 
 If the number of bits in the input's range is small enough and the input supports efficient
 bitshifts, use the `radix` algorithm. Otherwise, dispatch to the `next` algorithm.
@@ -985,7 +985,7 @@ end
 
 
 """
-    RadixSort <: Algorithm
+    RadixSort() isa Base.Sort.Algorithm
 
 Use the radix sort algorithm.
 
@@ -1040,8 +1040,8 @@ end
 
 
 """
-    ScratchQuickSort(next::Algorithm=SMALL_ALGORITHM) <: Algorithm
-    ScratchQuickSort(lo::Union{Integer, Missing}, hi::Union{Integer, Missing}=lo, next::Algorithm=SMALL_ALGORITHM) <: Algorithm
+    ScratchQuickSort(next::Base.Sort.Algorithm=Base.Sort.SMALL_ALGORITHM) isa Base.Sort.Algorithm
+    ScratchQuickSort(lo::Union{Integer, Missing}, hi::Union{Integer, Missing}=lo, next::Base.Sort.Algorithm=Base.Sort.SMALL_ALGORITHM) isa Base.Sort.Algorithm
 
 Use the `ScratchQuickSort` algorithm with the `next` algorithm as a base case.
 
@@ -1157,7 +1157,7 @@ end
 
 
 """
-    BracketedSort(target[, next::Algorithm]) <: Algorithm
+    BracketedSort(target[, next::Algorithm]) isa Base.Sort.Algorithm
 
 Perform a partialsort for the elements that fall into the indices specified by the `target`
 using BracketedSort with the `next` algorithm for subproblems.
@@ -1346,7 +1346,7 @@ end
 
 
 """
-    StableCheckSorted(next) <: Algorithm
+    StableCheckSorted(next) isa Base.Sort.Algorithm
 
 Check if an input is sorted and/or reverse-sorted.
 
@@ -1446,7 +1446,7 @@ end
 ## default sorting policy ##
 
 """
-    InitialOptimizations(next) <: Algorithm
+    InitialOptimizations(next) isa Base.Sort.Algorithm
 
 Attempt to apply a suite of low-cost optimizations to the input vector before sorting. These
 optimizations may be automatically applied by the `sort!` family of functions when
@@ -1593,7 +1593,7 @@ defalg(v::AbstractArray{Missing}) = DEFAULT_UNSTABLE # for method disambiguation
 defalg(v::AbstractArray{Union{}}) = DEFAULT_UNSTABLE # for method disambiguation
 
 """
-    sort!(v; alg::Algorithm=defalg(v), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)
+    sort!(v; alg::Base.Sort.Algorithm=Base.Sort.defalg(v), lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)
 
 Sort the vector `v` in place. A stable algorithm is used by default: the
 ordering of elements that compare equal is preserved. A specific algorithm can
@@ -1706,7 +1706,7 @@ function sort!(v::AbstractVector{T};
 end
 
 """
-    sort(v; alg::Algorithm=defalg(v), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)
+    sort(v; alg::Base.Sort.Algorithm=Base.Sort.defalg(v), lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)
 
 Variant of [`sort!`](@ref) that returns a sorted copy of `v` leaving `v` itself unmodified.
 
@@ -1829,7 +1829,7 @@ end
 ## sortperm: the permutation to sort an array ##
 
 """
-    sortperm(A; alg::Algorithm=DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward, [dims::Integer])
+    sortperm(A; alg::Base.Sort.Algorithm=Base.Sort.DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward, [dims::Integer])
 
 Return a permutation vector or array `I` that puts `A[I]` in sorted order along the given dimension.
 If `A` has more than one dimension, then the `dims` keyword argument must be specified. The order is specified
@@ -1907,7 +1907,7 @@ end
 
 
 """
-    sortperm!(ix, A; alg::Algorithm=DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward, [dims::Integer])
+    sortperm!(ix, A; alg::Base.Sort.Algorithm=Base.Sort.DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward, [dims::Integer])
 
 Like [`sortperm`](@ref), but accepts a preallocated index vector or array `ix` with the same `axes` as `A`.
 `ix` is initialized to contain the values `LinearIndices(A)`.
@@ -1995,7 +1995,7 @@ end
 ## sorting multi-dimensional arrays ##
 
 """
-    sort(A; dims::Integer, alg::Algorithm=defalg(A), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)
+    sort(A; dims::Integer, alg::Base.Sort.Algorithm=Base.Sort.defalg(A), lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)
 
 Sort a multidimensional array `A` along the given dimension.
 See [`sort!`](@ref) for a description of possible
@@ -2067,7 +2067,7 @@ end
 
 
 """
-    sort!(A; dims::Integer, alg::Algorithm=defalg(A), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)
+    sort!(A; dims::Integer, alg::Base.Sort.Algorithm=Base.Sort.defalg(A), lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)
 
 Sort the multidimensional array `A` along dimension `dims`.
 See the one-dimensional version of [`sort!`](@ref) for a description of
@@ -2139,7 +2139,7 @@ get_value(::Val{x}) where x = x
 ## uint mapping to allow radix sorting primitives other than UInts ##
 
 """
-    UIntMappable(T::Type, order::Ordering)
+    UIntMappable(T::Type, order::Base.Order.Ordering)
 
 Return `typeof(uint_map(x::T, order))` if [`uint_map`](@ref) and
 [`uint_unmap`](@ref) are implemented.
@@ -2149,7 +2149,7 @@ If either is not implemented, return `nothing`.
 UIntMappable(T::Type, order::Ordering) = nothing
 
 """
-    uint_map(x, order::Ordering)::Unsigned
+    uint_map(x, order::Base.Order.Ordering)::Unsigned
 
 Map `x` to an un unsigned integer, maintaining sort order.
 
@@ -2163,7 +2163,7 @@ See also: [`UIntMappable`](@ref) [`uint_unmap`](@ref)
 function uint_map end
 
 """
-    uint_unmap(T::Type, u::Unsigned, order::Ordering)
+    uint_unmap(T::Type, u::Unsigned, order::Base.Order.Ordering)
 
 Reconstruct the unique value `x::T` that uint_maps to `u`. Satisfies
 `x === uint_unmap(T, uint_map(x::T, order), order)` for all `x <: T`.

From 273d91e0dab8ff08d427eaebd58627b2bbd4d807 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sat, 6 Apr 2024 08:12:39 -0500
Subject: [PATCH 1237/1315] Make reshape and view on Memory produce Arrays and
 delete wrap (#53896)

- Make reshape and view with one based indexing on Memory produce Arrays
- delete wrap

Implements
https://github.com/JuliaLang/julia/issues/53552#issuecomment-2024288283

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
---
 HISTORY.md             |  1 -
 base/array.jl          | 51 ------------------------------------------
 base/exports.jl        |  1 -
 base/genericmemory.jl  | 24 ++++++++++++++++++++
 base/iobuffer.jl       | 12 ++++------
 base/strings/string.jl |  5 ++++-
 doc/src/base/arrays.md |  1 -
 test/arrayops.jl       | 48 +++++++++++++++++++++++++--------------
 8 files changed, 63 insertions(+), 80 deletions(-)

diff --git a/HISTORY.md b/HISTORY.md
index 3eaec3c6d0774..55bbfa1335a0e 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -86,7 +86,6 @@ New library functions
 * `copyuntil(out, io, delim)` and `copyline(out, io)` copy data into an `out::IO` stream ([#48273]).
 * `eachrsplit(string, pattern)` iterates split substrings right to left.
 * `Sys.username()` can be used to return the current user's username ([#51897]).
-* `wrap(Array, m::Union{MemoryRef{T}, Memory{T}}, dims)` is the safe counterpart to `unsafe_wrap` ([#52049]).
 * `GC.logging_enabled()` can be used to test whether GC logging has been enabled via `GC.enable_logging` ([#51647]).
 * `IdSet` is now exported from Base and considered public ([#53262]).
 
diff --git a/base/array.jl b/base/array.jl
index ef91077dd6e96..7676b380923ee 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -3080,54 +3080,3 @@ intersect(r::AbstractRange, v::AbstractVector) = intersect(v, r)
         _getindex(v, i)
     end
 end
-
-"""
-    wrap(Array, m::Union{Memory{T}, MemoryRef{T}}, dims)
-
-Create an array of size `dims` using `m` as the underlying memory. This can be thought of as a safe version
-of [`unsafe_wrap`](@ref) utilizing `Memory` or `MemoryRef` instead of raw pointers.
-"""
-function wrap end
-
-# validity checking for _wrap calls, separate from allocation of Array so that it can be more likely to inline into the caller
-function _wrap(ref::MemoryRef{T}, dims::NTuple{N, Int}) where {T, N}
-    mem = ref.mem
-    mem_len = length(mem) + 1 - memoryrefoffset(ref)
-    len = Core.checked_dims(dims...)
-    @boundscheck mem_len >= len || invalid_wrap_err(mem_len, dims, len)
-    if N != 1 && !(ref === GenericMemoryRef(mem) && len === mem_len)
-        mem = ccall(:jl_genericmemory_slice, Memory{T}, (Any, Ptr{Cvoid}, Int), mem, ref.ptr_or_offset, len)
-        ref = MemoryRef(mem)
-    end
-    return ref
-end
-
-@noinline invalid_wrap_err(len, dims, proddims) = throw(DimensionMismatch(
-    "Attempted to wrap a MemoryRef of length $len with an Array of size dims=$dims, which is invalid because prod(dims) = $proddims > $len, so that the array would have more elements than the underlying memory can store."))
-
-@eval @propagate_inbounds function wrap(::Type{Array}, m::MemoryRef{T}, dims::NTuple{N, Integer}) where {T, N}
-    dims = convert(Dims, dims)
-    ref = _wrap(m, dims)
-    $(Expr(:new, :(Array{T, N}), :ref, :dims))
-end
-
-@eval @propagate_inbounds function wrap(::Type{Array}, m::Memory{T}, dims::NTuple{N, Integer}) where {T, N}
-    dims = convert(Dims, dims)
-    ref = _wrap(MemoryRef(m), dims)
-    $(Expr(:new, :(Array{T, N}), :ref, :dims))
-end
-@eval @propagate_inbounds function wrap(::Type{Array}, m::MemoryRef{T}, l::Integer) where {T}
-    dims = (Int(l),)
-    ref = _wrap(m, dims)
-    $(Expr(:new, :(Array{T, 1}), :ref, :dims))
-end
-@eval @propagate_inbounds function wrap(::Type{Array}, m::Memory{T}, l::Integer) where {T}
-    dims = (Int(l),)
-    ref = _wrap(MemoryRef(m), (l,))
-    $(Expr(:new, :(Array{T, 1}), :ref, :dims))
-end
-@eval @propagate_inbounds function wrap(::Type{Array}, m::Memory{T}) where {T}
-    ref = MemoryRef(m)
-    dims = (length(m),)
-    $(Expr(:new, :(Array{T, 1}), :ref, :dims))
-end
diff --git a/base/exports.jl b/base/exports.jl
index 3044f9d162d41..fc2ee86a8d0d4 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -460,7 +460,6 @@ export
     vcat,
     vec,
     view,
-    wrap,
     zeros,
 
 # search, find, match and related functions
diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index b5f519a0f854d..a6f002b9c6175 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -288,3 +288,27 @@ function indcopy(sz::Dims, I::GenericMemory)
     src = eltype(I)[I[i][_findin(I[i], i < n ? (1:sz[i]) : (1:s))] for i = 1:n]
     dst, src
 end
+
+# Wrapping a memory region in an Array
+@eval begin # @eval for the Array construction. Block for the docstring.
+    function reshape(m::GenericMemory{M, T}, dims::Vararg{Int, N}) where {M, T, N}
+        len = Core.checked_dims(dims...)
+        length(m) == len || throw(DimensionMismatch("parent has $(length(m)) elements, which is incompatible with size $(dims)"))
+        ref = MemoryRef(m)
+        $(Expr(:new, :(Array{T, N}), :ref, :dims))
+    end
+
+    """
+        view(m::GenericMemory{M, T}, inds::Union{UnitRange, OneTo})
+
+    Create a vector `v::Vector{T}` backed by the specified indices of `m`. It is only safe to
+    resize `v` if `m` is subseqently not used.
+    """
+    function view(m::GenericMemory{M, T}, inds::Union{UnitRange, OneTo}) where {M, T}
+        isempty(inds) && return T[] # needed to allow view(Memory{T}(undef, 0), 2:1)
+        @boundscheck checkbounds(m, inds)
+        ref = MemoryRef(m, first(inds)) # @inbounds would be safe here but does not help performance.
+        dims = (length(inds),)
+        $(Expr(:new, :(Array{T, 1}), :ref, :dims))
+    end
+end
diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index dadb13e1f1e6a..109eaa96a3de4 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -42,7 +42,7 @@ end
 
 # allocate Vector{UInt8}s for IOBuffer storage that can efficiently become Strings
 StringMemory(n::Integer) = unsafe_wrap(Memory{UInt8}, _string_n(n))
-StringVector(n::Integer) = wrap(Array, StringMemory(n))
+StringVector(n::Integer) = view(StringMemory(n), 1:n)::Vector{UInt8}
 
 # IOBuffers behave like Files. They are typically readable and writable. They are seekable. (They can be appendable).
 
@@ -456,7 +456,7 @@ function take!(io::IOBuffer)
         if nbytes == 0 || io.reinit
             data = StringVector(0)
         elseif io.writable
-            data = wrap(Array, MemoryRef(io.data, io.offset + 1), nbytes)
+            data = view(io.data, io.offset+1:nbytes+io.offset)
         else
             data = copyto!(StringVector(io.size), 1, io.data, io.offset + 1, nbytes)
         end
@@ -465,7 +465,7 @@ function take!(io::IOBuffer)
         if nbytes == 0
             data = StringVector(0)
         elseif io.writable
-            data = wrap(Array, MemoryRef(io.data, io.ptr), nbytes)
+            data = view(io.data, io.ptr:io.ptr+nbytes-1)
         else
             data = read!(io, data)
         end
@@ -491,11 +491,7 @@ state.  This should only be used internally for performance-critical
 It might save an allocation compared to `take!` (if the compiler elides the
 Array allocation), as well as omits some checks.
 """
-_unsafe_take!(io::IOBuffer) =
-    wrap(Array, io.size == io.offset ?
-        MemoryRef(Memory{UInt8}()) :
-        MemoryRef(io.data, io.offset + 1),
-        io.size - io.offset)
+_unsafe_take!(io::IOBuffer) = view(io.data, io.offset+1:io.size)
 
 function write(to::IO, from::GenericIOBuffer)
     written::Int = bytesavailable(from)
diff --git a/base/strings/string.jl b/base/strings/string.jl
index b2afce897a937..d091baeb6c663 100644
--- a/base/strings/string.jl
+++ b/base/strings/string.jl
@@ -117,7 +117,10 @@ String(s::AbstractString) = print_to_string(s)
 @assume_effects :total String(s::Symbol) = unsafe_string(unsafe_convert(Ptr{UInt8}, s))
 
 unsafe_wrap(::Type{Memory{UInt8}}, s::String) = ccall(:jl_string_to_genericmemory, Ref{Memory{UInt8}}, (Any,), s)
-unsafe_wrap(::Type{Vector{UInt8}}, s::String) = wrap(Array, unsafe_wrap(Memory{UInt8}, s))
+function unsafe_wrap(::Type{Vector{UInt8}}, s::String)
+    mem = unsafe_wrap(Memory{UInt8}, s)
+    view(mem, eachindex(mem))
+end
 
 Vector{UInt8}(s::CodeUnits{UInt8,String}) = copyto!(Vector{UInt8}(undef, length(s)), s)
 Vector{UInt8}(s::String) = Vector{UInt8}(codeunits(s))
diff --git a/doc/src/base/arrays.md b/doc/src/base/arrays.md
index f7ea23ad3b556..20e8e81614b9e 100644
--- a/doc/src/base/arrays.md
+++ b/doc/src/base/arrays.md
@@ -139,7 +139,6 @@ Base.reshape
 Base.dropdims
 Base.vec
 Base.SubArray
-Base.wrap
 ```
 
 ## Concatenation and permutation
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 566dd44b8dcd9..65a9ecbd5e2a2 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -3187,23 +3187,37 @@ end
     end
 end
 
-@testset "Wrapping Memory into Arrays" begin
-    mem = Memory{Int}(undef, 10) .= 1
-    memref = MemoryRef(mem)
-    @test_throws DimensionMismatch wrap(Array, mem, (10, 10))
-    @test wrap(Array, mem, (5,)) == ones(Int, 5)
-    @test wrap(Array, mem, 2) == ones(Int, 2)
-    @test wrap(Array, memref, 10) == ones(Int, 10)
-    @test wrap(Array, memref, (2,2,2)) == ones(Int,2,2,2)
-    @test wrap(Array, mem, (5, 2)) == ones(Int, 5, 2)
-
-    memref2 = MemoryRef(mem, 3)
-    @test wrap(Array, memref2, (5,)) == ones(Int, 5)
-    @test wrap(Array, memref2, 2) == ones(Int, 2)
-    @test wrap(Array, memref2, (2,2,2)) == ones(Int,2,2,2)
-    @test wrap(Array, memref2, (3, 2)) == ones(Int, 3, 2)
-    @test_throws DimensionMismatch wrap(Array, memref2, 9)
-    @test_throws DimensionMismatch wrap(Array, memref2, 10)
+@testset "Wrapping Memory into Arrays with view and reshape" begin
+    mem::Memory{Int} = Memory{Int}(undef, 10) .= 11:20
+
+    @test_throws DimensionMismatch reshape(mem, 10, 10)
+    @test_throws DimensionMismatch reshape(mem, 5)
+    @test_throws BoundsError view(mem, 1:10, 1:10)
+    @test_throws BoundsError view(mem, 1:11)
+    @test_throws BoundsError view(mem, 3:11)
+    @test_throws BoundsError view(mem, 0:4)
+
+    @test @inferred(view(mem, 1:5))::Vector{Int} == 11:15
+    @test @inferred(view(mem, 1:2))::Vector{Int} == 11:12
+    @test @inferred(view(mem, 1:10))::Vector{Int} == 11:20
+    @test @inferred(view(mem, 3:8))::Vector{Int} == 13:18
+    @test @inferred(view(mem, 20:19))::Vector{Int} == []
+    @test @inferred(view(mem, -5:-7))::Vector{Int} == []
+    @test @inferred(reshape(mem, 5, 2))::Matrix{Int} == reshape(11:20, 5, 2)
+
+    empty_mem = Memory{Module}(undef, 0)
+    @test_throws BoundsError view(empty_mem, 0:1)
+    @test_throws BoundsError view(empty_mem, 1:2)
+    @test_throws DimensionMismatch reshape(empty_mem, 1)
+    @test_throws DimensionMismatch reshape(empty_mem, 1, 2, 3)
+    @test_throws ArgumentError reshape(empty_mem, 2^16, 2^16, 2^16, 2^16)
+
+    @test @inferred(view(empty_mem, 1:0))::Vector{Module} == []
+    @test @inferred(view(empty_mem, 10:3))::Vector{Module} == []
+    @test isempty(@inferred(reshape(empty_mem, 0, 7, 1))::Array{Module, 3})
+
+    offset_inds = OffsetArrays.IdOffsetRange(values=3:6, indices=53:56)
+    @test @inferred(view(collect(mem), offset_inds)) == view(mem, offset_inds)
 end
 
 @testset "Memory size" begin

From f7c7410b8f7d526dad499b87896f92fb39b4e56c Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sat, 6 Apr 2024 19:50:47 +0530
Subject: [PATCH 1238/1315] `LazyString` in `DimensionMismatch` error messages
 in broadcasting (#53975)

This reduces dynamic dispatch, and makes JET happier. Something similar
is already used in line 523.
---
 base/broadcast.jl | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index d26613233a271..30c982ae05117 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -517,8 +517,8 @@ function _bcs(shape::Tuple, newshape::Tuple)
     return (_bcs1(shape[1], newshape[1]), _bcs(tail(shape), tail(newshape))...)
 end
 # _bcs1 handles the logic for a single dimension
-_bcs1(a::Integer, b::Integer) = a == 1 ? b : (b == 1 ? a : (a == b ? a : throw(DimensionMismatch("arrays could not be broadcast to a common size; got a dimension with lengths $a and $b"))))
-_bcs1(a::Integer, b) = a == 1 ? b : (first(b) == 1 && last(b) == a ? b : throw(DimensionMismatch("arrays could not be broadcast to a common size; got a dimension with lengths $a and $(length(b))")))
+_bcs1(a::Integer, b::Integer) = a == 1 ? b : (b == 1 ? a : (a == b ? a : throw(DimensionMismatch(LazyString("arrays could not be broadcast to a common size; got a dimension with lengths ", a, " and ", b)))))
+_bcs1(a::Integer, b) = a == 1 ? b : (first(b) == 1 && last(b) == a ? b : throw(DimensionMismatch(LazyString("arrays could not be broadcast to a common size; got a dimension with lengths ", a, " and ", length(b)))))
 _bcs1(a, b::Integer) = _bcs1(b, a)
 _bcs1(a, b) = _bcsm(b, a) ? axistype(b, a) : _bcsm(a, b) ? axistype(a, b) : throw(DimensionMismatch(LazyString("arrays could not be broadcast to a common size: a has axes ", a, " and b has axes ", b)))
 # _bcsm tests whether the second index is consistent with the first
@@ -1057,7 +1057,7 @@ end
 
 
 @noinline throwdm(axdest, axsrc) =
-    throw(DimensionMismatch("destination axes $axdest are not compatible with source axes $axsrc"))
+    throw(DimensionMismatch(LazyString("destination axes ", axdest, " are not compatible with source axes ", axsrc)))
 
 function restart_copyto_nonleaf!(newdest, dest, bc, val, I, iter, state, count)
     # Function barrier that makes the copying to newdest type stable

From 4e5bd66ce6b6a4f4299d7be7762d6d7e11d33560 Mon Sep 17 00:00:00 2001
From: nathan musoke <nathan.musoke@gmail.com>
Date: Sat, 6 Apr 2024 13:20:21 -0400
Subject: [PATCH 1239/1315] fix minor typo in mktempdir docs (#53977)

This is a minor change, just adding a missing word to a docstring for
`Base.Filesystem.mktempdir`
---
 base/file.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/file.jl b/base/file.jl
index b7adb8e1a3fbd..727b97abd36f1 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -821,7 +821,7 @@ end
     mktempdir(f::Function, parent=tempdir(); prefix=$(repr(temp_prefix)))
 
 Apply the function `f` to the result of [`mktempdir(parent; prefix)`](@ref) and remove the
-temporary directory all of its contents upon completion.
+temporary directory and all of its contents upon completion.
 
 See also: [`mktemp`](@ref), [`mkdir`](@ref).
 

From 821c608ffeeb7bfc470270df2006c549b7672473 Mon Sep 17 00:00:00 2001
From: Viriato5 <120762182+Viriato5@users.noreply.github.com>
Date: Sat, 6 Apr 2024 18:24:11 +0100
Subject: [PATCH 1240/1315] Fix #52989: DateTime parser would return an error
 when parsing a year string (#53954)

Issue #52989.
Originally checked on version 1.10.0 but still relevant in the current
version in master

Bug: When executing the method DateTime to create a DateTime value with
a string input only containing a year (ex: "2000") the method returns an
'ArgumentError: Invalid DateTime string' when it should, from what I
understood, return a DateTime like 2000-01-01T00:00:00 seeing as if you
call the same method with a number indicating a year (ex: 2000) the
method returns correctly.

Fix: The fix was simple, on the first tryparsenext_base10 block (line
207-211) where a year is parsed from the string the exit condition i >
end_pos should jump into 'done' so it returns a correct value instead of
'error'
---
 stdlib/Dates/src/parse.jl | 2 +-
 stdlib/Dates/test/io.jl   | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/stdlib/Dates/src/parse.jl b/stdlib/Dates/src/parse.jl
index 62d44177de877..49c0234c7c9fa 100644
--- a/stdlib/Dates/src/parse.jl
+++ b/stdlib/Dates/src/parse.jl
@@ -207,7 +207,7 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF
     let val = tryparsenext_base10(s, i, end_pos, 1)
         val === nothing && @goto error
         dy, i = val
-        i > end_pos && @goto error
+        i > end_pos && @goto done
     end
 
     c, i = iterate(s, i)::Tuple{Char, Int}
diff --git a/stdlib/Dates/test/io.jl b/stdlib/Dates/test/io.jl
index 092a58d5d70d1..ee102288acd3e 100644
--- a/stdlib/Dates/test/io.jl
+++ b/stdlib/Dates/test/io.jl
@@ -470,6 +470,9 @@ end
 # Issue #44003
 @test tryparse(Dates.Date, "2017", Dates.DateFormat(".s")) === nothing
 
+# Issue #52989
+@test Dates.DateTime("2000") == Dates.DateTime(2000)
+
 @testset "parse milliseconds, Issue #22100" begin
     @test Dates.DateTime("2017-Mar-17 00:00:00.0000", "y-u-d H:M:S.s") == Dates.DateTime(2017, 3, 17)
     @test Dates.parse_components(".1", Dates.DateFormat(".s")) == [Dates.Millisecond(100)]

From 1febcd609fa2689a0578aa8a47a7bddc598b669a Mon Sep 17 00:00:00 2001
From: "Lance (Weiqing) Xu" <47257262+lanceXwq@users.noreply.github.com>
Date: Sun, 7 Apr 2024 00:37:27 -0700
Subject: [PATCH 1241/1315] Fix typos in docstrings (#53986)

---
 base/reduce.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/reduce.jl b/base/reduce.jl
index d73aeeeee46ec..c4020faf4c85f 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -1118,7 +1118,7 @@ If the input contains [`missing`](@ref) values, return `missing` if all non-miss
 values are `false` (or equivalently, if the input contains no `true` value), following
 [three-valued logic](https://en.wikipedia.org/wiki/Three-valued_logic).
 
-See also: [`all`](@ref), [`count`](@ref), [`sum`](@ref), [`|`](@ref), , [`||`](@ref).
+See also: [`all`](@ref), [`count`](@ref), [`sum`](@ref), [`|`](@ref), [`||`](@ref).
 
 # Examples
 ```jldoctest
@@ -1156,7 +1156,7 @@ If the input contains [`missing`](@ref) values, return `missing` if all non-miss
 values are `true` (or equivalently, if the input contains no `false` value), following
 [three-valued logic](https://en.wikipedia.org/wiki/Three-valued_logic).
 
-See also: [`all!`](@ref), [`any`](@ref), [`count`](@ref), [`&`](@ref), , [`&&`](@ref), [`allunique`](@ref).
+See also: [`all!`](@ref), [`any`](@ref), [`count`](@ref), [`&`](@ref), [`&&`](@ref), [`allunique`](@ref).
 
 # Examples
 ```jldoctest

From 243ebc389eec78f060a47c53375b3fd48c462d76 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 7 Apr 2024 19:52:09 +0530
Subject: [PATCH 1242/1315] Support broadcasting over structured block matrices
 (#53909)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix https://github.com/JuliaLang/julia/issues/48664

After this, broadcasting over structured block matrices with
matrix-valued elements works:
```julia
julia> D = Diagonal([[1 2; 3 4], [5 6; 7 8]])
2×2 Diagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
 [1 2; 3 4]      ⋅
     ⋅       [5 6; 7 8]

julia> D .+ D
2×2 Diagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
 [2 4; 6 8]      ⋅
     ⋅       [10 12; 14 16]

julia> cos.(D)
2×2 Matrix{Matrix{Float64}}:
 [0.855423 -0.110876; -0.166315 0.689109]  [1.0 0.0; 0.0 1.0]
 [1.0 0.0; 0.0 1.0]                        [0.928384 -0.069963; -0.0816235 0.893403]
```
Such operations show up when using `BlockArrays`.

The implementation is a bit hacky as it uses `0I` as the zero element in
`fzero`, which isn't really the correct zero if the blocks are
rectangular. Nonetheless, this works, as `fzero` is only used to
determine if the structure is preserved.
---
 .../LinearAlgebra/src/structuredbroadcast.jl  |  6 +-
 stdlib/LinearAlgebra/test/special.jl          |  1 +
 .../LinearAlgebra/test/structuredbroadcast.jl | 58 +++++++++++++++++++
 3 files changed, 63 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/structuredbroadcast.jl b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
index dfc58aabc63ec..6114c9a796390 100644
--- a/stdlib/LinearAlgebra/src/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
@@ -8,8 +8,8 @@ struct StructuredMatrixStyle{T} <: Broadcast.AbstractArrayStyle{2} end
 StructuredMatrixStyle{T}(::Val{2}) where {T} = StructuredMatrixStyle{T}()
 StructuredMatrixStyle{T}(::Val{N}) where {T,N} = Broadcast.DefaultArrayStyle{N}()
 
-const StructuredMatrix = Union{Diagonal,Bidiagonal,SymTridiagonal,Tridiagonal,LowerTriangular,UnitLowerTriangular,UpperTriangular,UnitUpperTriangular}
-for ST in Base.uniontypes(StructuredMatrix)
+const StructuredMatrix{T} = Union{Diagonal{T},Bidiagonal{T},SymTridiagonal{T},Tridiagonal{T},LowerTriangular{T},UnitLowerTriangular{T},UpperTriangular{T},UnitUpperTriangular{T}}
+for ST in (Diagonal,Bidiagonal,SymTridiagonal,Tridiagonal,LowerTriangular,UnitLowerTriangular,UpperTriangular,UnitUpperTriangular)
     @eval Broadcast.BroadcastStyle(::Type{<:$ST}) = $(StructuredMatrixStyle{ST}())
 end
 
@@ -133,6 +133,7 @@ fails as `zero(::Tuple{Int})` is not defined. However,
 iszerodefined(::Type) = false
 iszerodefined(::Type{<:Number}) = true
 iszerodefined(::Type{<:AbstractArray{T}}) where T = iszerodefined(T)
+iszerodefined(::Type{<:UniformScaling{T}}) where T = iszerodefined(T)
 
 fzeropreserving(bc) = (v = fzero(bc); !ismissing(v) && (iszerodefined(typeof(v)) ? iszero(v) : v == 0))
 # Like sparse matrices, we assume that the zero-preservation property of a broadcasted
@@ -144,6 +145,7 @@ fzero(::Type{T}) where T = T
 fzero(r::Ref) = r[]
 fzero(t::Tuple{Any}) = t[1]
 fzero(S::StructuredMatrix) = zero(eltype(S))
+fzero(::StructuredMatrix{<:AbstractMatrix{T}}) where {T<:Number} = haszero(T) ? zero(T)*I : missing
 fzero(x) = missing
 function fzero(bc::Broadcast.Broadcasted)
     args = map(fzero, bc.args)
diff --git a/stdlib/LinearAlgebra/test/special.jl b/stdlib/LinearAlgebra/test/special.jl
index 6465927db5235..a5198892ff995 100644
--- a/stdlib/LinearAlgebra/test/special.jl
+++ b/stdlib/LinearAlgebra/test/special.jl
@@ -111,6 +111,7 @@ Random.seed!(1)
         struct TypeWithZero end
         Base.promote_rule(::Type{TypeWithoutZero}, ::Type{TypeWithZero}) = TypeWithZero
         Base.convert(::Type{TypeWithZero}, ::TypeWithoutZero) = TypeWithZero()
+        Base.zero(x::Union{TypeWithoutZero, TypeWithZero}) = zero(typeof(x))
         Base.zero(::Type{<:Union{TypeWithoutZero, TypeWithZero}}) = TypeWithZero()
         LinearAlgebra.symmetric(::TypeWithoutZero, ::Symbol) = TypeWithoutZero()
         LinearAlgebra.symmetric_type(::Type{TypeWithoutZero}) = TypeWithoutZero
diff --git a/stdlib/LinearAlgebra/test/structuredbroadcast.jl b/stdlib/LinearAlgebra/test/structuredbroadcast.jl
index 02d7ead55af17..3767fc10055f2 100644
--- a/stdlib/LinearAlgebra/test/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/test/structuredbroadcast.jl
@@ -280,4 +280,62 @@ end
 # structured broadcast with function returning non-number type
 @test tuple.(Diagonal([1, 2])) == [(1,) (0,); (0,) (2,)]
 
+@testset "broadcast over structured matrices with matrix elements" begin
+    function standardbroadcastingtests(D, T)
+        M = [x for x in D]
+        Dsum = D .+ D
+        @test Dsum isa T
+        @test Dsum == M .+ M
+        Dcopy = copy.(D)
+        @test Dcopy isa T
+        @test Dcopy == D
+        Df = float.(D)
+        @test Df isa T
+        @test Df == D
+        @test eltype(eltype(Df)) <: AbstractFloat
+        @test (x -> (x,)).(D) == (x -> (x,)).(M)
+        @test (x -> 1).(D) == ones(Int,size(D))
+        @test all(==(2), ndims.(D))
+        @test_throws MethodError size.(D)
+    end
+    @testset "Diagonal" begin
+        @testset "square" begin
+            A = [1 3; 2 4]
+            D = Diagonal([A, A])
+            standardbroadcastingtests(D, Diagonal)
+            @test sincos.(D) == sincos.(Matrix{eltype(D)}(D))
+            M = [x for x in D]
+            @test cos.(D) == cos.(M)
+        end
+
+        @testset "different-sized square blocks" begin
+            D = Diagonal([ones(3,3), fill(3.0,2,2)])
+            standardbroadcastingtests(D, Diagonal)
+        end
+
+        @testset "rectangular blocks" begin
+            D = Diagonal([ones(Bool,3,4), ones(Bool,2,3)])
+            standardbroadcastingtests(D, Diagonal)
+        end
+
+        @testset "incompatible sizes" begin
+            A = reshape(1:12, 4, 3)
+            B = reshape(1:12, 3, 4)
+            D1 = Diagonal(fill(A, 2))
+            D2 = Diagonal(fill(B, 2))
+            @test_throws DimensionMismatch D1 .+ D2
+        end
+    end
+    @testset "Bidiagonal" begin
+        A = [1 3; 2 4]
+        B = Bidiagonal(fill(A,3), fill(A,2), :U)
+        standardbroadcastingtests(B, Bidiagonal)
+    end
+    @testset "UpperTriangular" begin
+        A = [1 3; 2 4]
+        U = UpperTriangular([(i+j)*A for i in 1:3, j in 1:3])
+        standardbroadcastingtests(U, UpperTriangular)
+    end
+end
+
 end

From c5a3b653353318607534fe9642c9e9476ff7d625 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sun, 7 Apr 2024 11:36:34 -0500
Subject: [PATCH 1243/1315] Remove trailing slash in "Official
 https://julialang.org/ release" (#53978)

---
 doc/src/devdocs/probes.md                       | 4 ++--
 stdlib/InteractiveUtils/src/InteractiveUtils.jl | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/src/devdocs/probes.md b/doc/src/devdocs/probes.md
index e75e7f6bb0156..5a1af0d897bc6 100644
--- a/doc/src/devdocs/probes.md
+++ b/doc/src/devdocs/probes.md
@@ -188,7 +188,7 @@ Julia session and get the PID and REPL's task address:
    _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
   | | | | | | |/ _` |  |
   | | |_| | | | (_| |  |  Version 1.6.2 (2021-07-14)
- _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
+ _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org release
 |__/                   |
 
 1> getpid()
@@ -264,7 +264,7 @@ We can see this problem illustrated with `bpftrace` quite easily. First, in one
    _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
   | | | | | | |/ _` |  |
   | | |_| | | | (_| |  |  Version 1.6.2 (2021-07-14)
- _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
+ _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org release
 |__/                   |
 
 1> getpid()
diff --git a/stdlib/InteractiveUtils/src/InteractiveUtils.jl b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
index a0020090e451d..835988ddf149f 100644
--- a/stdlib/InteractiveUtils/src/InteractiveUtils.jl
+++ b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
@@ -104,7 +104,7 @@ function versioninfo(io::IO=stdout; verbose::Bool=false)
     if !isempty(Base.GIT_VERSION_INFO.commit_short)
         println(io, "Commit $(Base.GIT_VERSION_INFO.commit_short) ($(Base.GIT_VERSION_INFO.date_string))")
     end
-    official_release = Base.TAGGED_RELEASE_BANNER == "Official https://julialang.org/ release"
+    official_release = Base.TAGGED_RELEASE_BANNER == "Official https://julialang.org release"
     if Base.isdebugbuild() || !isempty(Base.TAGGED_RELEASE_BANNER) || (Base.GIT_VERSION_INFO.tagged_commit && !official_release)
         println(io, "Build Info:")
         if Base.isdebugbuild()

From e4f2124e08a14fdfa2c0e569ceb4412b2f666868 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Sun, 7 Apr 2024 22:46:14 -0500
Subject: [PATCH 1244/1315] Test and fix non-int-length bug in `view(::Memory,
 ::Union{UnitRange, Base.OneTo})` (#53991)

We assumed, falsely, that `length(inds) isa Int`. The length must be
convertible to an `Int` or we throw, but that conversion may need to be
explicitly performed.

Fixes #53990

CC @oscardssmith @vtjnash @odow
---
 base/genericmemory.jl | 2 +-
 test/arrayops.jl      | 3 +++
 test/core.jl          | 3 +++
 3 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index a6f002b9c6175..3463be456ea59 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -308,7 +308,7 @@ end
         isempty(inds) && return T[] # needed to allow view(Memory{T}(undef, 0), 2:1)
         @boundscheck checkbounds(m, inds)
         ref = MemoryRef(m, first(inds)) # @inbounds would be safe here but does not help performance.
-        dims = (length(inds),)
+        dims = (Int(length(inds)),)
         $(Expr(:new, :(Array{T, 1}), :ref, :dims))
     end
 end
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 65a9ecbd5e2a2..a31d373a65a38 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -3205,6 +3205,9 @@ end
     @test @inferred(view(mem, -5:-7))::Vector{Int} == []
     @test @inferred(reshape(mem, 5, 2))::Matrix{Int} == reshape(11:20, 5, 2)
 
+    # 53990
+    @test @inferred(view(mem, unsigned(1):10))::Vector{Int} == 11:20
+
     empty_mem = Memory{Module}(undef, 0)
     @test_throws BoundsError view(empty_mem, 0:1)
     @test_throws BoundsError view(empty_mem, 1:2)
diff --git a/test/core.jl b/test/core.jl
index 173526d3b2128..ed1e1fc6757d2 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -5524,6 +5524,9 @@ let a = Base.StringVector(2^17)
     @test sizeof(c) == 0
 end
 
+# issue #53990 / https://github.com/JuliaLang/julia/pull/53896#discussion_r1555087951
+@test Base.StringVector(UInt64(2)) isa Vector{UInt8}
+
 @test_throws ArgumentError eltype(Bottom)
 
 # issue #16424, re-evaluating type definitions

From 62df400ddb3001bf4d6aaca06dd47c99c0b93969 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Thu, 4 Apr 2024 22:26:44 +0900
Subject: [PATCH 1245/1315] inference: fixes cache lookup with extended lattice
 elements

The previous local cache lookup system wasn't working well for caches
with extended lattice elements that are transformed from the caller
context to the callee context by `matching_cache_argtypes`. To address
this, the current commit moves the call to `matching_cache_argtypes`
right before `cache_lookup`, instead of within the `InferenceResult`
constructor.

Note that this adjustment leads to `given_argtypes` being allocated even
when there's a cache hit, potentially affecting performance negatively.
I'm looking to further optimize `matching_cache_argtypes` in an upcoming
commit.
---
 base/compiler/abstractinterpretation.jl |  7 ++++---
 base/compiler/types.jl                  |  2 --
 test/compiler/inference.jl              | 22 ++++++++++++++++++++++
 3 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 75c8e841b7e10..a113d028248db 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1248,7 +1248,9 @@ function const_prop_call(interp::AbstractInterpreter,
     concrete_eval_result::Union{Nothing, ConstCallResults}=nothing)
     inf_cache = get_inference_cache(interp)
     𝕃ᵢ = typeinf_lattice(interp)
-    inf_result = cache_lookup(𝕃ᵢ, mi, arginfo.argtypes, inf_cache)
+    argtypes = has_conditional(𝕃ᵢ, sv) ? ConditionalArgtypes(arginfo, sv) : SimpleArgtypes(arginfo.argtypes)
+    given_argtypes, overridden_by_const = matching_cache_argtypes(𝕃ᵢ, mi, argtypes)
+    inf_result = cache_lookup(𝕃ᵢ, mi, given_argtypes, inf_cache)
     if inf_result !== nothing
         # found the cache for this constant prop'
         if inf_result.result === nothing
@@ -1259,8 +1261,7 @@ function const_prop_call(interp::AbstractInterpreter,
         return return_cached_result(interp, inf_result, sv)
     end
     # perform fresh constant prop'
-    argtypes = has_conditional(𝕃ᵢ, sv) ? ConditionalArgtypes(arginfo, sv) : SimpleArgtypes(arginfo.argtypes)
-    inf_result = InferenceResult(mi, argtypes, typeinf_lattice(interp))
+    inf_result = InferenceResult(mi, given_argtypes, overridden_by_const)
     if !any(inf_result.overridden_by_const)
         add_remark!(interp, sv, "[constprop] Could not handle constant info in matching_cache_argtypes")
         return nothing
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index 3017976b66949..12c747d0c5707 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -99,8 +99,6 @@ mutable struct InferenceResult
 end
 InferenceResult(mi::MethodInstance, 𝕃::AbstractLattice=fallback_lattice) =
     InferenceResult(mi, matching_cache_argtypes(𝕃, mi)...)
-InferenceResult(mi::MethodInstance, argtypes::ForwardableArgtypes, 𝕃::AbstractLattice=fallback_lattice) =
-    InferenceResult(mi, matching_cache_argtypes(𝕃, mi, argtypes)...)
 
 function stack_analysis_result!(inf_result::InferenceResult, @nospecialize(result))
     return inf_result.analysis_results = AnalysisResults(result, inf_result.analysis_results)
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 01c4687a26caa..3accb1edf54e0 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5696,3 +5696,25 @@ end
 # We want to make sure that both this returns `Tuple` and that
 # it doesn't infinite loop inside inference.
 @test Core.Compiler.return_type(gen_infinite_loop_ssa, Tuple{}) === Tuple
+
+# inference local cache lookup with extended lattice elements that may be transformed
+# by `matching_cache_argtypes`
+@newinterp CachedConditionalInterp
+Base.@constprop :aggressive function func_cached_conditional(x, y)
+    if x
+        @noinline sin(y)
+    else
+        0.0
+    end
+end;
+function test_func_cached_conditional(y)
+    y₁ = func_cached_conditional(isa(y, Float64), y)
+    y₂ = func_cached_conditional(isa(y, Float64), y)
+    return y₁, y₂
+end;
+let interp = CachedConditionalInterp();
+    @test Base.infer_return_type(test_func_cached_conditional, (Any,); interp) == Tuple{Float64, Float64}
+    @test count(interp.inf_cache) do result
+        result.linfo.def.name === :func_cached_conditional
+    end == 1
+end

From 41347f58f2df934602d84244414596d7cd4b922c Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Mon, 8 Apr 2024 08:17:03 +0000
Subject: [PATCH 1246/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20StyledStrings=20stdlib=20from=20e0ca0f8=20to=20bfdb4c3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 stdlib/StyledStrings.version                                    | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/StyledStrings-bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b.tar.gz/sha512
 delete mode 100644 deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512

diff --git a/deps/checksums/StyledStrings-bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b.tar.gz/md5 b/deps/checksums/StyledStrings-bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b.tar.gz/md5
new file mode 100644
index 0000000000000..511b60c7e2217
--- /dev/null
+++ b/deps/checksums/StyledStrings-bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b.tar.gz/md5
@@ -0,0 +1 @@
+8fc4fd7e90d35e7d8d06a6b7c312ec03
diff --git a/deps/checksums/StyledStrings-bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b.tar.gz/sha512 b/deps/checksums/StyledStrings-bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b.tar.gz/sha512
new file mode 100644
index 0000000000000..d5e2302499a2c
--- /dev/null
+++ b/deps/checksums/StyledStrings-bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b.tar.gz/sha512
@@ -0,0 +1 @@
+137360872c9b75276426efa9e9096e442115a554b7e00dc98ce02904fa1a535f76e48ba1366fc517794490a494cccc3238d006ebb43dadb5594e5099a2c36f55
diff --git a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5 b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
deleted file mode 100644
index 2ab79799cca0e..0000000000000
--- a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-fc3a846400107c432d20da6cfdd19ccf
diff --git a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512 b/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512
deleted file mode 100644
index 70b0ef6f5cb3a..0000000000000
--- a/deps/checksums/StyledStrings-e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-22da8964cc4c09f7c7a3da44be14c953f520ce6d395cf0f9ccf9c17777d6d968b0a874b35c072801ef7a1f4eee40f96ea0e2fc5ed5b3a63ad0b6b776a9c14ebb
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index 19a5a24514f2f..8e489a5daf289 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = e0ca0f85412ea5cafabfeaaec4d62ca26c3959d2
+STYLEDSTRINGS_SHA1 = bfdb4c3f73a93a956ad48b0f06f89eb1cd40ff6b
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1

From a5356a4b4e6ab8b8cb4de452c1e044773aa405dc Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Fri, 5 Apr 2024 01:36:45 +0900
Subject: [PATCH 1247/1315] optimize construction of `InferenceResult` for
 constant inference

---
 base/compiler/abstractinterpretation.jl |  40 +++++----
 base/compiler/compiler.jl               |   2 +-
 base/compiler/inferenceresult.jl        | 110 +++++++-----------------
 base/compiler/inferencestate.jl         |   5 +-
 base/compiler/ssair/legacy.jl           |   2 +-
 base/compiler/typeinfer.jl              |   8 +-
 base/compiler/types.jl                  |  29 ++++---
 test/compiler/inference.jl              |   2 +-
 8 files changed, 82 insertions(+), 116 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index a113d028248db..a396e281c1bf7 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1239,7 +1239,7 @@ const_prop_result(inf_result::InferenceResult) =
     ConstCallResults(inf_result.result, inf_result.exc_result, ConstPropResult(inf_result),
                      inf_result.ipo_effects, inf_result.linfo)
 
-# return cached constant analysis result
+# return cached result of constant analysis
 return_cached_result(::AbstractInterpreter, inf_result::InferenceResult, ::AbsIntState) =
     const_prop_result(inf_result)
 
@@ -1249,8 +1249,15 @@ function const_prop_call(interp::AbstractInterpreter,
     inf_cache = get_inference_cache(interp)
     𝕃ᵢ = typeinf_lattice(interp)
     argtypes = has_conditional(𝕃ᵢ, sv) ? ConditionalArgtypes(arginfo, sv) : SimpleArgtypes(arginfo.argtypes)
-    given_argtypes, overridden_by_const = matching_cache_argtypes(𝕃ᵢ, mi, argtypes)
-    inf_result = cache_lookup(𝕃ᵢ, mi, given_argtypes, inf_cache)
+    # use `cache_argtypes` that has been constructed for fresh regular inference if available
+    volatile_inf_result = result.volatile_inf_result
+    if volatile_inf_result !== nothing
+        cache_argtypes = volatile_inf_result.inf_result.argtypes
+    else
+        cache_argtypes = matching_cache_argtypes(𝕃ᵢ, mi)
+    end
+    argtypes = matching_cache_argtypes(𝕃ᵢ, mi, argtypes, cache_argtypes)
+    inf_result = cache_lookup(𝕃ᵢ, mi, argtypes, inf_cache)
     if inf_result !== nothing
         # found the cache for this constant prop'
         if inf_result.result === nothing
@@ -1260,12 +1267,18 @@ function const_prop_call(interp::AbstractInterpreter,
         @assert inf_result.linfo === mi "MethodInstance for cached inference result does not match"
         return return_cached_result(interp, inf_result, sv)
     end
-    # perform fresh constant prop'
-    inf_result = InferenceResult(mi, given_argtypes, overridden_by_const)
-    if !any(inf_result.overridden_by_const)
+    overridden_by_const = falses(length(argtypes))
+    for i = 1:length(argtypes)
+        if argtypes[i] !== cache_argtypes[i]
+            overridden_by_const[i] = true
+        end
+    end
+    if !any(overridden_by_const)
         add_remark!(interp, sv, "[constprop] Could not handle constant info in matching_cache_argtypes")
         return nothing
     end
+    # perform fresh constant prop'
+    inf_result = InferenceResult(mi, argtypes, overridden_by_const)
     frame = InferenceState(inf_result, #=cache_mode=#:local, interp)
     if frame === nothing
         add_remark!(interp, sv, "[constprop] Could not retrieve the source")
@@ -1287,26 +1300,19 @@ end
 
 # TODO implement MustAlias forwarding
 
-struct ConditionalArgtypes <: ForwardableArgtypes
+struct ConditionalArgtypes
     arginfo::ArgInfo
     sv::InferenceState
 end
 
-"""
-    matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance,
-                            conditional_argtypes::ConditionalArgtypes)
-
-The implementation is able to forward `Conditional` of `conditional_argtypes`,
-as well as the other general extended lattice information.
-"""
 function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance,
-                                 conditional_argtypes::ConditionalArgtypes)
+                                 conditional_argtypes::ConditionalArgtypes,
+                                 cache_argtypes::Vector{Any})
     (; arginfo, sv) = conditional_argtypes
     (; fargs, argtypes) = arginfo
     given_argtypes = Vector{Any}(undef, length(argtypes))
     def = mi.def::Method
     nargs = Int(def.nargs)
-    cache_argtypes, overridden_by_const = matching_cache_argtypes(𝕃, mi)
     local condargs = nothing
     for i in 1:length(argtypes)
         argtype = argtypes[i]
@@ -1349,7 +1355,7 @@ function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance,
     else
         given_argtypes = va_process_argtypes(𝕃, given_argtypes, mi)
     end
-    return pick_const_args!(𝕃, cache_argtypes, overridden_by_const, given_argtypes)
+    return pick_const_args!(𝕃, given_argtypes, cache_argtypes)
 end
 
 # This is only for use with `Conditional`.
diff --git a/base/compiler/compiler.jl b/base/compiler/compiler.jl
index 8b9c26be2ec81..12d6d5eb38764 100644
--- a/base/compiler/compiler.jl
+++ b/base/compiler/compiler.jl
@@ -203,6 +203,7 @@ include("compiler/ssair/ir.jl")
 include("compiler/ssair/tarjan.jl")
 
 include("compiler/abstractlattice.jl")
+include("compiler/stmtinfo.jl")
 include("compiler/inferenceresult.jl")
 include("compiler/inferencestate.jl")
 
@@ -210,7 +211,6 @@ include("compiler/typeutils.jl")
 include("compiler/typelimits.jl")
 include("compiler/typelattice.jl")
 include("compiler/tfuncs.jl")
-include("compiler/stmtinfo.jl")
 
 include("compiler/abstractinterpretation.jl")
 include("compiler/typeinfer.jl")
diff --git a/base/compiler/inferenceresult.jl b/base/compiler/inferenceresult.jl
index 06fbffaa7aa04..574685c1e38d6 100644
--- a/base/compiler/inferenceresult.jl
+++ b/base/compiler/inferenceresult.jl
@@ -1,63 +1,30 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-"""
-    matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance) ->
-        (cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
-
-Returns argument types `cache_argtypes::Vector{Any}` for `mi` that are in the native
-Julia type domain. `overridden_by_const::BitVector` is all `false` meaning that
-there is no additional extended lattice information there.
-
-    matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance, argtypes::ForwardableArgtypes) ->
-        (cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
-
-Returns cache-correct extended lattice argument types `cache_argtypes::Vector{Any}`
-for `mi` given some `argtypes` accompanied by `overridden_by_const::BitVector`
-that marks which argument contains additional extended lattice information.
-
-In theory, there could be a `cache` containing a matching `InferenceResult`
-for the provided `mi` and `given_argtypes`. The purpose of this function is
-to return a valid value for `cache_lookup(𝕃, mi, argtypes, cache).argtypes`,
-so that we can construct cache-correct `InferenceResult`s in the first place.
-"""
-function matching_cache_argtypes end
-
 function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance)
-    method = isa(mi.def, Method) ? mi.def::Method : nothing
-    cache_argtypes = most_general_argtypes(method, mi.specTypes)
-    overridden_by_const = falses(length(cache_argtypes))
-    return cache_argtypes, overridden_by_const
+    (; def, specTypes) = mi
+    return most_general_argtypes(isa(def, Method) ? def : nothing, specTypes)
 end
 
-struct SimpleArgtypes <: ForwardableArgtypes
+struct SimpleArgtypes
     argtypes::Vector{Any}
 end
 
-"""
-    matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance, argtypes::SimpleArgtypes)
-
-The implementation for `argtypes` with general extended lattice information.
-This is supposed to be used for debugging and testing or external `AbstractInterpreter`
-usages and in general `matching_cache_argtypes(::MethodInstance, ::ConditionalArgtypes)`
-is more preferred it can forward `Conditional` information.
-"""
-function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance, simple_argtypes::SimpleArgtypes)
+function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance,
+                                 simple_argtypes::SimpleArgtypes,
+                                 cache_argtypes::Vector{Any})
     (; argtypes) = simple_argtypes
     given_argtypes = Vector{Any}(undef, length(argtypes))
     for i = 1:length(argtypes)
         given_argtypes[i] = widenslotwrapper(argtypes[i])
     end
     given_argtypes = va_process_argtypes(𝕃, given_argtypes, mi)
-    return pick_const_args(𝕃, mi, given_argtypes)
+    return pick_const_args!(𝕃, given_argtypes, cache_argtypes)
 end
 
-function pick_const_args(𝕃::AbstractLattice, mi::MethodInstance, given_argtypes::Vector{Any})
-    cache_argtypes, overridden_by_const = matching_cache_argtypes(𝕃, mi)
-    return pick_const_args!(𝕃, cache_argtypes, overridden_by_const, given_argtypes)
-end
-
-function pick_const_args!(𝕃::AbstractLattice, cache_argtypes::Vector{Any}, overridden_by_const::BitVector, given_argtypes::Vector{Any})
-    for i = 1:length(given_argtypes)
+function pick_const_args!(𝕃::AbstractLattice, given_argtypes::Vector{Any}, cache_argtypes::Vector{Any})
+    nargtypes = length(given_argtypes)
+    @assert nargtypes == length(cache_argtypes) #= == nargs =# "invalid `given_argtypes` for `mi`"
+    for i = 1:nargtypes
         given_argtype = given_argtypes[i]
         cache_argtype = cache_argtypes[i]
         if !is_argtype_match(𝕃, given_argtype, cache_argtype, false)
@@ -66,13 +33,13 @@ function pick_const_args!(𝕃::AbstractLattice, cache_argtypes::Vector{Any}, ov
                 !⊏(𝕃, given_argtype, cache_argtype))
                 # if the type information of this `PartialStruct` is less strict than
                 # declared method signature, narrow it down using `tmeet`
-                given_argtype = tmeet(𝕃, given_argtype, cache_argtype)
+                given_argtypes[i] = tmeet(𝕃, given_argtype, cache_argtype)
             end
-            cache_argtypes[i] = given_argtype
-            overridden_by_const[i] = true
+        else
+            given_argtypes[i] = cache_argtype
         end
     end
-    return cache_argtypes, overridden_by_const
+    return given_argtypes
 end
 
 function is_argtype_match(𝕃::AbstractLattice,
@@ -89,9 +56,9 @@ end
 va_process_argtypes(𝕃::AbstractLattice, given_argtypes::Vector{Any}, mi::MethodInstance) =
     va_process_argtypes(Returns(nothing), 𝕃, given_argtypes, mi)
 function va_process_argtypes(@specialize(va_handler!), 𝕃::AbstractLattice, given_argtypes::Vector{Any}, mi::MethodInstance)
-    def = mi.def
-    isva = isa(def, Method) ? def.isva : false
-    nargs = isa(def, Method) ? Int(def.nargs) : length(mi.specTypes.parameters)
+    def = mi.def::Method
+    isva = def.isva
+    nargs = Int(def.nargs)
     if isva || isvarargtype(given_argtypes[end])
         isva_given_argtypes = Vector{Any}(undef, nargs)
         for i = 1:(nargs-isva)
@@ -112,14 +79,11 @@ function va_process_argtypes(@specialize(va_handler!), 𝕃::AbstractLattice, gi
     return given_argtypes
 end
 
-function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(specTypes),
-    withfirst::Bool = true)
+function most_general_argtypes(method::Union{Method,Nothing}, @nospecialize(specTypes))
     toplevel = method === nothing
     isva = !toplevel && method.isva
     mi_argtypes = Any[(unwrap_unionall(specTypes)::DataType).parameters...]
     nargs::Int = toplevel ? 0 : method.nargs
-    # For opaque closure, the closure environment is processed elsewhere
-    withfirst || (nargs -= 1)
     cache_argtypes = Vector{Any}(undef, nargs)
     # First, if we're dealing with a varargs method, then we set the last element of `args`
     # to the appropriate `Tuple` type or `PartialStruct` instance.
@@ -162,17 +126,16 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
         cache_argtypes[nargs] = vargtype
         nargs -= 1
     end
-    # Now, we propagate type info from `linfo_argtypes` into `cache_argtypes`, improving some
+    # Now, we propagate type info from `mi_argtypes` into `cache_argtypes`, improving some
     # type info as we go (where possible). Note that if we're dealing with a varargs method,
     # we already handled the last element of `cache_argtypes` (and decremented `nargs` so that
     # we don't overwrite the result of that work here).
     if mi_argtypes_length > 0
-        n = mi_argtypes_length > nargs ? nargs : mi_argtypes_length
-        tail_index = n
+        tail_index = nargtypes = min(mi_argtypes_length, nargs)
         local lastatype
-        for i = 1:n
+        for i = 1:nargtypes
             atyp = mi_argtypes[i]
-            if i == n && isvarargtype(atyp)
+            if i == nargtypes && isvarargtype(atyp)
                 atyp = unwrapva(atyp)
                 tail_index -= 1
             end
@@ -185,16 +148,16 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
             else
                 atyp = elim_free_typevars(rewrap_unionall(atyp, specTypes))
             end
-            i == n && (lastatype = atyp)
+            i == nargtypes && (lastatype = atyp)
             cache_argtypes[i] = atyp
         end
-        for i = (tail_index + 1):nargs
+        for i = (tail_index+1):nargs
             cache_argtypes[i] = lastatype
         end
     else
         @assert nargs == 0 "invalid specialization of method" # wrong number of arguments
     end
-    cache_argtypes
+    return cache_argtypes
 end
 
 # eliminate free `TypeVar`s in order to make the life much easier down the road:
@@ -213,22 +176,15 @@ end
 function cache_lookup(𝕃::AbstractLattice, mi::MethodInstance, given_argtypes::Vector{Any},
                       cache::Vector{InferenceResult})
     method = mi.def::Method
-    nargs = Int(method.nargs)
-    method.isva && (nargs -= 1)
-    length(given_argtypes) ≥ nargs || return nothing
+    nargtypes = length(given_argtypes)
+    @assert nargtypes == Int(method.nargs) "invalid `given_argtypes` for `mi`"
     for cached_result in cache
-        cached_result.linfo === mi || continue
+        cached_result.linfo === mi || @goto next_cache
         cache_argtypes = cached_result.argtypes
-        cache_overridden_by_const = cached_result.overridden_by_const
-        for i in 1:nargs
-            if !is_argtype_match(𝕃, widenmustalias(given_argtypes[i]),
-                                 cache_argtypes[i], cache_overridden_by_const[i])
-                @goto next_cache
-            end
-        end
-        if method.isva
-            if !is_argtype_match(𝕃, tuple_tfunc(𝕃, given_argtypes[(nargs + 1):end]),
-                                 cache_argtypes[end], cache_overridden_by_const[end])
+        @assert length(cache_argtypes) == nargtypes "invalid `cache_argtypes` for `mi`"
+        cache_overridden_by_const = cached_result.overridden_by_const::BitVector
+        for i in 1:nargtypes
+            if !is_argtype_match(𝕃, given_argtypes[i], cache_argtypes[i], cache_overridden_by_const[i])
                 @goto next_cache
             end
         end
diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 3c71a88ab8a80..73c697d81b184 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -832,7 +832,10 @@ end
 frame_parent(sv::InferenceState) = sv.parent::Union{Nothing,AbsIntState}
 frame_parent(sv::IRInterpretationState) = sv.parent::Union{Nothing,AbsIntState}
 
-is_constproped(sv::InferenceState) = any(sv.result.overridden_by_const)
+function is_constproped(sv::InferenceState)
+    (;overridden_by_const) = sv.result
+    return overridden_by_const !== nothing
+end
 is_constproped(::IRInterpretationState) = true
 
 is_cached(sv::InferenceState) = !iszero(sv.cache_mode & CACHE_MODE_GLOBAL)
diff --git a/base/compiler/ssair/legacy.jl b/base/compiler/ssair/legacy.jl
index f5181691cdf7b..b45db03875801 100644
--- a/base/compiler/ssair/legacy.jl
+++ b/base/compiler/ssair/legacy.jl
@@ -10,7 +10,7 @@ the original `ci::CodeInfo` are modified.
 """
 function inflate_ir!(ci::CodeInfo, mi::MethodInstance)
     sptypes = sptypes_from_meth_instance(mi)
-    argtypes, _ = matching_cache_argtypes(fallback_lattice, mi)
+    argtypes = matching_cache_argtypes(fallback_lattice, mi)
     return inflate_ir!(ci, sptypes, argtypes)
 end
 function inflate_ir!(ci::CodeInfo, sptypes::Vector{VarState}, argtypes::Vector{Any})
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 825045670e350..22b0afc9b03c1 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -810,7 +810,7 @@ struct EdgeCallResult
     end
 end
 
-# return cached regular inference result
+# return cached result of regular inference
 function return_cached_result(::AbstractInterpreter, codeinst::CodeInstance, caller::AbsIntState)
     rt = cached_return_type(codeinst)
     effects = ipo_effects(codeinst)
@@ -869,10 +869,8 @@ function typeinf_edge(interp::AbstractInterpreter, method::Method, @nospecialize
         effects = isinferred ? frame.result.ipo_effects : adjust_effects(Effects(), method) # effects are adjusted already within `finish` for ipo_effects
         exc_bestguess = refine_exception_type(frame.exc_bestguess, effects)
         # propagate newly inferred source to the inliner, allowing efficient inlining w/o deserialization:
-        # note that this result is cached globally exclusively, we can use this local result destructively
-        volatile_inf_result = (isinferred && (force_inline ||
-            src_inlining_policy(interp, result.src, NoCallInfo(), IR_FLAG_NULL))) ?
-            VolatileInferenceResult(result) : nothing
+        # note that this result is cached globally exclusively, so we can use this local result destructively
+        volatile_inf_result = isinferred ? VolatileInferenceResult(result) : nothing
         return EdgeCallResult(frame.bestguess, exc_bestguess, edge, effects, volatile_inf_result)
     elseif frame === true
         # unresolvable cycle
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index 12c747d0c5707..30cb0fb0f39c5 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -57,8 +57,6 @@ struct VarState
     VarState(@nospecialize(typ), undef::Bool) = new(typ, undef)
 end
 
-abstract type ForwardableArgtypes end
-
 struct AnalysisResults
     result
     next::AnalysisResults
@@ -70,16 +68,19 @@ end
 const NULL_ANALYSIS_RESULTS = AnalysisResults(nothing)
 
 """
-    InferenceResult(mi::MethodInstance, [argtypes::ForwardableArgtypes, 𝕃::AbstractLattice])
+    result::InferenceResult
 
 A type that represents the result of running type inference on a chunk of code.
-
-See also [`matching_cache_argtypes`](@ref).
+There are two constructor available:
+- `InferenceResult(mi::MethodInstance, [𝕃::AbstractLattice])` for regular inference,
+  without extended lattice information included in `result.argtypes`.
+- `InferenceResult(mi::MethodInstance, argtypes::Vector{Any}, overridden_by_const::BitVector)`
+  for constant inference, with extended lattice information included in `result.argtypes`.
 """
 mutable struct InferenceResult
     const linfo::MethodInstance
     const argtypes::Vector{Any}
-    const overridden_by_const::BitVector
+    const overridden_by_const::Union{Nothing,BitVector}
     result                   # extended lattice element if inferred, nothing otherwise
     exc_result               # like `result`, but for the thrown value
     src                      # ::Union{CodeInfo, IRCode, OptimizationState} if inferred copy is available, nothing otherwise
@@ -89,16 +90,18 @@ mutable struct InferenceResult
     analysis_results::AnalysisResults # AnalysisResults with e.g. result::ArgEscapeCache if optimized, otherwise NULL_ANALYSIS_RESULTS
     is_src_volatile::Bool    # `src` has been cached globally as the compressed format already, allowing `src` to be used destructively
     ci::CodeInstance         # CodeInstance if this result has been added to the cache
-    function InferenceResult(mi::MethodInstance, cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
-        # def = mi.def
-        # nargs = def isa Method ? Int(def.nargs) : 0
-        # @assert length(cache_argtypes) == nargs
-        return new(mi, cache_argtypes, overridden_by_const, nothing, nothing, nothing,
+    function InferenceResult(mi::MethodInstance, argtypes::Vector{Any}, overridden_by_const::Union{Nothing,BitVector})
+        def = mi.def
+        nargs = def isa Method ? Int(def.nargs) : 0
+        @assert length(argtypes) == nargs "invalid `argtypes` for `mi`"
+        return new(mi, argtypes, overridden_by_const, nothing, nothing, nothing,
             WorldRange(), Effects(), Effects(), NULL_ANALYSIS_RESULTS, false)
     end
 end
-InferenceResult(mi::MethodInstance, 𝕃::AbstractLattice=fallback_lattice) =
-    InferenceResult(mi, matching_cache_argtypes(𝕃, mi)...)
+function InferenceResult(mi::MethodInstance, 𝕃::AbstractLattice=fallback_lattice)
+    argtypes = matching_cache_argtypes(𝕃, mi)
+    return InferenceResult(mi, argtypes, #=overridden_by_const=#nothing)
+end
 
 function stack_analysis_result!(inf_result::InferenceResult, @nospecialize(result))
     return inf_result.analysis_results = AnalysisResults(result, inf_result.analysis_results)
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 3accb1edf54e0..7bc1032828c80 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -4485,7 +4485,7 @@ let
                # Vararg
         #=va=# Bound, unbound,         # => Tuple{Integer,Integer} (invalid `TypeVar` widened beforehand)
         } where Bound<:Integer
-    argtypes = Core.Compiler.most_general_argtypes(method, specTypes, true)
+    argtypes = Core.Compiler.most_general_argtypes(method, specTypes)
     popfirst!(argtypes)
     @test argtypes[1] == Integer
     @test argtypes[2] == Integer

From 26070ca33417a16cb5e000e3e953793e0a87b937 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 9 Apr 2024 10:32:00 -0400
Subject: [PATCH 1248/1315] irinterp: Don't try to access mi.def if it's not a
 Method (#54003)

I don't believe this is reachable from the base compiler pipeline, since
we don't run irinterp on toplevel things, but I am seeing this in
downstream packages.
---
 base/compiler/inferencestate.jl | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 73c697d81b184..48784378ef7c1 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -783,9 +783,13 @@ mutable struct IRInterpretationState
         for i = 1:length(given_argtypes)
             given_argtypes[i] = widenslotwrapper(argtypes[i])
         end
-        given_argtypes = va_process_argtypes(optimizer_lattice(interp), given_argtypes, mi)
-        argtypes_refined = Bool[!⊑(optimizer_lattice(interp), ir.argtypes[i], given_argtypes[i])
-            for i = 1:length(given_argtypes)]
+        if isa(mi.def, Method)
+            given_argtypes = va_process_argtypes(optimizer_lattice(interp), given_argtypes, mi)
+            argtypes_refined = Bool[!⊑(optimizer_lattice(interp), ir.argtypes[i], given_argtypes[i])
+                for i = 1:length(given_argtypes)]
+        else
+            argtypes_refined = Bool[false for i = 1:length(given_argtypes)]
+        end
         empty!(ir.argtypes)
         append!(ir.argtypes, given_argtypes)
         tpdum = TwoPhaseDefUseMap(length(ir.stmts))

From 7099bddd5f0b430b5e2fe7e12e64384fbcf5b724 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 9 Apr 2024 21:25:26 +0530
Subject: [PATCH 1249/1315] LinearAlgebra: LazyString in interpolated error
 messages (#53976)

---
 stdlib/LinearAlgebra/src/abstractq.jl         |  22 +-
 stdlib/LinearAlgebra/src/adjtrans.jl          |   2 +-
 stdlib/LinearAlgebra/src/bidiag.jl            |  20 +-
 stdlib/LinearAlgebra/src/dense.jl             |   4 +-
 stdlib/LinearAlgebra/src/diagonal.jl          |  34 +-
 stdlib/LinearAlgebra/src/generic.jl           |  22 +-
 stdlib/LinearAlgebra/src/hessenberg.jl        |   6 +-
 stdlib/LinearAlgebra/src/lapack.jl            | 312 +++++++++---------
 stdlib/LinearAlgebra/src/lbt.jl               |   4 +-
 stdlib/LinearAlgebra/src/ldlt.jl              |   2 +-
 stdlib/LinearAlgebra/src/lu.jl                |   6 +-
 stdlib/LinearAlgebra/src/qr.jl                |   4 +-
 stdlib/LinearAlgebra/src/special.jl           |   2 +-
 .../LinearAlgebra/src/structuredbroadcast.jl  |   2 +-
 stdlib/LinearAlgebra/src/symmetric.jl         |   2 +-
 stdlib/LinearAlgebra/src/triangular.jl        |  58 ++--
 stdlib/LinearAlgebra/src/tridiag.jl           |  40 +--
 17 files changed, 271 insertions(+), 271 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/abstractq.jl b/stdlib/LinearAlgebra/src/abstractq.jl
index b0d53320f4aa3..d6e251e620309 100644
--- a/stdlib/LinearAlgebra/src/abstractq.jl
+++ b/stdlib/LinearAlgebra/src/abstractq.jl
@@ -149,13 +149,13 @@ end
 # generically, treat AbstractQ like a matrix with its definite size
 qsize_check(Q::AbstractQ, B::AbstractVecOrMat) =
     size(Q, 2) == size(B, 1) ||
-        throw(DimensionMismatch("second dimension of Q, $(size(Q,2)), must coincide with first dimension of B, $(size(B,1))"))
+        throw(DimensionMismatch(lazy"second dimension of Q, $(size(Q,2)), must coincide with first dimension of B, $(size(B,1))"))
 qsize_check(A::AbstractVecOrMat, Q::AbstractQ) =
     size(A, 2) == size(Q, 1) ||
-        throw(DimensionMismatch("second dimension of A, $(size(A,2)), must coincide with first dimension of Q, $(size(Q,1))"))
+        throw(DimensionMismatch(lazy"second dimension of A, $(size(A,2)), must coincide with first dimension of Q, $(size(Q,1))"))
 qsize_check(Q::AbstractQ, P::AbstractQ) =
     size(Q, 2) == size(P, 1) ||
-        throw(DimensionMismatch("second dimension of A, $(size(Q,2)), must coincide with first dimension of B, $(size(P,1))"))
+        throw(DimensionMismatch(lazy"second dimension of A, $(size(Q,2)), must coincide with first dimension of B, $(size(P,1))"))
 
 # mimic the AbstractArray fallback
 *(Q::AbstractQ{<:Number}) = Q
@@ -317,7 +317,7 @@ function lmul!(A::QRPackedQ, B::AbstractVecOrMat)
     mA, nA = size(A.factors)
     mB, nB = size(B,1), size(B,2)
     if mA != mB
-        throw(DimensionMismatch("matrix A has dimensions ($mA,$nA) but B has dimensions ($mB, $nB)"))
+        throw(DimensionMismatch(lazy"matrix A has dimensions ($mA,$nA) but B has dimensions ($mB, $nB)"))
     end
     Afactors = A.factors
     @inbounds begin
@@ -353,7 +353,7 @@ function lmul!(adjA::AdjointQ{<:Any,<:QRPackedQ}, B::AbstractVecOrMat)
     mA, nA = size(A.factors)
     mB, nB = size(B,1), size(B,2)
     if mA != mB
-        throw(DimensionMismatch("matrix A has dimensions ($mA,$nA) but B has dimensions ($mB, $nB)"))
+        throw(DimensionMismatch(lazy"matrix A has dimensions ($mA,$nA) but B has dimensions ($mB, $nB)"))
     end
     Afactors = A.factors
     @inbounds begin
@@ -384,7 +384,7 @@ function rmul!(A::AbstractVecOrMat, Q::QRPackedQ)
     mQ, nQ = size(Q.factors)
     mA, nA = size(A,1), size(A,2)
     if nA != mQ
-        throw(DimensionMismatch("matrix A has dimensions ($mA,$nA) but matrix Q has dimensions ($mQ, $nQ)"))
+        throw(DimensionMismatch(lazy"matrix A has dimensions ($mA,$nA) but matrix Q has dimensions ($mQ, $nQ)"))
     end
     Qfactors = Q.factors
     @inbounds begin
@@ -420,7 +420,7 @@ function rmul!(A::AbstractVecOrMat, adjQ::AdjointQ{<:Any,<:QRPackedQ})
     mQ, nQ = size(Q.factors)
     mA, nA = size(A,1), size(A,2)
     if nA != mQ
-        throw(DimensionMismatch("matrix A has dimensions ($mA,$nA) but matrix Q has dimensions ($mQ, $nQ)"))
+        throw(DimensionMismatch(lazy"matrix A has dimensions ($mA,$nA) but matrix Q has dimensions ($mQ, $nQ)"))
     end
     Qfactors = Q.factors
     @inbounds begin
@@ -521,10 +521,10 @@ rmul!(X::Adjoint{T,<:StridedVecOrMat{T}}, adjQ::AdjointQ{<:Any,<:HessenbergQ{T}}
 # flexible left-multiplication (and adjoint right-multiplication)
 qsize_check(Q::Union{QRPackedQ,QRCompactWYQ,HessenbergQ}, B::AbstractVecOrMat) =
     size(B, 1) in size(Q.factors) ||
-        throw(DimensionMismatch("first dimension of B, $(size(B,1)), must equal one of the dimensions of Q, $(size(Q.factors))"))
+        throw(DimensionMismatch(lazy"first dimension of B, $(size(B,1)), must equal one of the dimensions of Q, $(size(Q.factors))"))
 qsize_check(A::AbstractVecOrMat, adjQ::AdjointQ{<:Any,<:Union{QRPackedQ,QRCompactWYQ,HessenbergQ}}) =
     (Q = adjQ.Q; size(A, 2) in size(Q.factors) ||
-        throw(DimensionMismatch("second dimension of A, $(size(A,2)), must equal one of the dimensions of Q, $(size(Q.factors))")))
+        throw(DimensionMismatch(lazy"second dimension of A, $(size(A,2)), must equal one of the dimensions of Q, $(size(Q.factors))")))
 
 det(Q::HessenbergQ) = _det_tau(Q.τ)
 
@@ -560,10 +560,10 @@ size(Q::LQPackedQ) = (n = size(Q.factors, 2); return n, n)
 
 qsize_check(adjQ::AdjointQ{<:Any,<:LQPackedQ}, B::AbstractVecOrMat) =
     size(B, 1) in size(adjQ.Q.factors) ||
-        throw(DimensionMismatch("first dimension of B, $(size(B,1)), must equal one of the dimensions of Q, $(size(adjQ.Q.factors))"))
+        throw(DimensionMismatch(lazy"first dimension of B, $(size(B,1)), must equal one of the dimensions of Q, $(size(adjQ.Q.factors))"))
 qsize_check(A::AbstractVecOrMat, Q::LQPackedQ) =
     size(A, 2) in size(Q.factors) ||
-        throw(DimensionMismatch("second dimension of A, $(size(A,2)), must equal one of the dimensions of Q, $(size(Q.factors))"))
+        throw(DimensionMismatch(lazy"second dimension of A, $(size(A,2)), must equal one of the dimensions of Q, $(size(Q.factors))"))
 
 # in-place right-application of LQPackedQs
 # these methods require that the applied-to matrix's (A's) number of columns
diff --git a/stdlib/LinearAlgebra/src/adjtrans.jl b/stdlib/LinearAlgebra/src/adjtrans.jl
index 24ad7960f00b4..f52460a870ca0 100644
--- a/stdlib/LinearAlgebra/src/adjtrans.jl
+++ b/stdlib/LinearAlgebra/src/adjtrans.jl
@@ -465,7 +465,7 @@ tr(A::Transpose) = transpose(tr(parent(A)))
 function _dot_nonrecursive(u, v)
     lu = length(u)
     if lu != length(v)
-        throw(DimensionMismatch("first array has length $(lu) which does not match the length of the second, $(length(v))."))
+        throw(DimensionMismatch(lazy"first array has length $(lu) which does not match the length of the second, $(length(v))."))
     end
     if lu == 0
         zero(eltype(u)) * zero(eltype(v))
diff --git a/stdlib/LinearAlgebra/src/bidiag.jl b/stdlib/LinearAlgebra/src/bidiag.jl
index b805d0ca309b9..323edd5ad45c6 100644
--- a/stdlib/LinearAlgebra/src/bidiag.jl
+++ b/stdlib/LinearAlgebra/src/bidiag.jl
@@ -8,7 +8,7 @@ struct Bidiagonal{T,V<:AbstractVector{T}} <: AbstractMatrix{T}
     function Bidiagonal{T,V}(dv, ev, uplo::AbstractChar) where {T,V<:AbstractVector{T}}
         require_one_based_indexing(dv, ev)
         if length(ev) != max(length(dv)-1, 0)
-            throw(DimensionMismatch("length of diagonal vector is $(length(dv)), length of off-diagonal vector is $(length(ev))"))
+            throw(DimensionMismatch(lazy"length of diagonal vector is $(length(dv)), length of off-diagonal vector is $(length(ev))"))
         end
         (uplo != 'U' && uplo != 'L') && throw_uplo()
         new{T,V}(dv, ev, uplo)
@@ -438,11 +438,11 @@ function check_A_mul_B!_sizes(C, A, B)
     mB, nB = size(B)
     mC, nC = size(C)
     if mA != mC
-        throw(DimensionMismatch("first dimension of A, $mA, and first dimension of output C, $mC, must match"))
+        throw(DimensionMismatch(lazy"first dimension of A, $mA, and first dimension of output C, $mC, must match"))
     elseif nA != mB
-        throw(DimensionMismatch("second dimension of A, $nA, and first dimension of B, $mB, must match"))
+        throw(DimensionMismatch(lazy"second dimension of A, $nA, and first dimension of B, $mB, must match"))
     elseif nB != nC
-        throw(DimensionMismatch("second dimension of output C, $nC, and second dimension of B, $nB, must match"))
+        throw(DimensionMismatch(lazy"second dimension of output C, $nC, and second dimension of B, $nB, must match"))
     end
 end
 
@@ -562,10 +562,10 @@ function _mul!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat, _add::MulA
     nA = size(A,1)
     nB = size(B,2)
     if !(size(C,1) == size(B,1) == nA)
-        throw(DimensionMismatch("A has first dimension $nA, B has $(size(B,1)), C has $(size(C,1)) but all must match"))
+        throw(DimensionMismatch(lazy"A has first dimension $nA, B has $(size(B,1)), C has $(size(C,1)) but all must match"))
     end
     if size(C,2) != nB
-        throw(DimensionMismatch("A has second dimension $nA, B has $(size(B,2)), C has $(size(C,2)) but all must match"))
+        throw(DimensionMismatch(lazy"A has second dimension $nA, B has $(size(B,2)), C has $(size(C,2)) but all must match"))
     end
     iszero(nA) && return C
     iszero(_add.alpha) && return _rmul_or_fill!(C, _add.beta)
@@ -763,11 +763,11 @@ function ldiv!(c::AbstractVecOrMat, A::Bidiagonal, b::AbstractVecOrMat)
     N = size(A, 2)
     mb, nb = size(b, 1), size(b, 2)
     if N != mb
-        throw(DimensionMismatch("second dimension of A, $N, does not match first dimension of b, $mb"))
+        throw(DimensionMismatch(lazy"second dimension of A, $N, does not match first dimension of b, $mb"))
     end
     mc, nc = size(c, 1), size(c, 2)
     if mc != mb || nc != nb
-        throw(DimensionMismatch("size of result, ($mc, $nc), does not match the size of b, ($mb, $nb)"))
+        throw(DimensionMismatch(lazy"size of result, ($mc, $nc), does not match the size of b, ($mb, $nb)"))
     end
 
     if N == 0
@@ -833,11 +833,11 @@ function _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::Bidiagonal)
     require_one_based_indexing(C, A, B)
     m, n = size(A)
     if size(B, 1) != n
-        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+        throw(DimensionMismatch(lazy"right hand side B needs first dimension of size $n, has size $(size(B,1))"))
     end
     mc, nc = size(C)
     if mc != m || nc != n
-        throw(DimensionMismatch("expect output to have size ($m, $n), but got ($mc, $nc)"))
+        throw(DimensionMismatch(lazy"expect output to have size ($m, $n), but got ($mc, $nc)"))
     end
 
     zi = findfirst(iszero, B.dv)
diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 72c3792d7867c..97a64aee3e721 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -336,7 +336,7 @@ function diagm_size(size::Tuple{Int,Int}, kv::Pair{<:Integer,<:AbstractVector}..
     mmax = mapreduce(x -> length(x.second) - min(0,Int(x.first)), max, kv; init=0)
     nmax = mapreduce(x -> length(x.second) + max(0,Int(x.first)), max, kv; init=0)
     m, n = size
-    (m ≥ mmax && n ≥ nmax) || throw(DimensionMismatch("invalid size=$size"))
+    (m ≥ mmax && n ≥ nmax) || throw(DimensionMismatch(lazy"invalid size=$size"))
     return m, n
 end
 function diagm_container(size, kv::Pair{<:Integer,<:AbstractVector}...)
@@ -1645,7 +1645,7 @@ function cond(A::AbstractMatrix, p::Real=2)
             end
         end
     end
-    throw(ArgumentError("p-norm must be 1, 2 or Inf, got $p"))
+    throw(ArgumentError(lazy"p-norm must be 1, 2 or Inf, got $p"))
 end
 
 ## Lyapunov and Sylvester equation
diff --git a/stdlib/LinearAlgebra/src/diagonal.jl b/stdlib/LinearAlgebra/src/diagonal.jl
index 8cee4a91d4696..070edc39eab3a 100644
--- a/stdlib/LinearAlgebra/src/diagonal.jl
+++ b/stdlib/LinearAlgebra/src/diagonal.jl
@@ -191,7 +191,7 @@ function setindex!(D::Diagonal, v, i::Int, j::Int)
     if i == j
         @inbounds D.diag[i] = v
     elseif !iszero(v)
-        throw(ArgumentError("cannot set off-diagonal entry ($i, $j) to a nonzero value ($v)"))
+        throw(ArgumentError(lazy"cannot set off-diagonal entry ($i, $j) to a nonzero value ($v)"))
     end
     return v
 end
@@ -280,13 +280,13 @@ Base.literal_pow(::typeof(^), D::Diagonal, ::Val{-1}) = inv(D) # for disambiguat
 function _muldiag_size_check(A, B)
     nA = size(A, 2)
     mB = size(B, 1)
-    @noinline throw_dimerr(::AbstractMatrix, nA, mB) = throw(DimensionMismatch("second dimension of A, $nA, does not match first dimension of B, $mB"))
-    @noinline throw_dimerr(::AbstractVector, nA, mB) = throw(DimensionMismatch("second dimension of D, $nA, does not match length of V, $mB"))
+    @noinline throw_dimerr(::AbstractMatrix, nA, mB) = throw(DimensionMismatch(lazy"second dimension of A, $nA, does not match first dimension of B, $mB"))
+    @noinline throw_dimerr(::AbstractVector, nA, mB) = throw(DimensionMismatch(lazy"second dimension of D, $nA, does not match length of V, $mB"))
     nA == mB || throw_dimerr(B, nA, mB)
     return nothing
 end
 # the output matrix should have the same size as the non-diagonal input matrix or vector
-@noinline throw_dimerr(szC, szA) = throw(DimensionMismatch("output matrix has size: $szC, but should have size $szA"))
+@noinline throw_dimerr(szC, szA) = throw(DimensionMismatch(lazy"output matrix has size: $szC, but should have size $szA"))
 _size_check_out(C, ::Diagonal, A) = _size_check_out(C, A)
 _size_check_out(C, A, ::Diagonal) = _size_check_out(C, A)
 _size_check_out(C, A::Diagonal, ::Diagonal) = _size_check_out(C, A)
@@ -432,7 +432,7 @@ function _rdiv!(B::AbstractVecOrMat, A::AbstractVecOrMat, D::Diagonal)
     dd = D.diag
     m, n = size(A, 1), size(A, 2)
     if (k = length(dd)) != n
-        throw(DimensionMismatch("left hand side has $n columns but D is $k by $k"))
+        throw(DimensionMismatch(lazy"left hand side has $n columns but D is $k by $k"))
     end
     @inbounds for j in 1:n
         ddj = dd[j]
@@ -458,8 +458,8 @@ function ldiv!(B::AbstractVecOrMat, D::Diagonal, A::AbstractVecOrMat)
     d = length(dd)
     m, n = size(A, 1), size(A, 2)
     m′, n′ = size(B, 1), size(B, 2)
-    m == d || throw(DimensionMismatch("right hand side has $m rows but D is $d by $d"))
-    (m, n) == (m′, n′) || throw(DimensionMismatch("expect output to be $m by $n, but got $m′ by $n′"))
+    m == d || throw(DimensionMismatch(lazy"right hand side has $m rows but D is $d by $d"))
+    (m, n) == (m′, n′) || throw(DimensionMismatch(lazy"expect output to be $m by $n, but got $m′ by $n′"))
     j = findfirst(iszero, D.diag)
     isnothing(j) || throw(SingularException(j))
     @inbounds for j = 1:n, i = 1:m
@@ -470,7 +470,7 @@ end
 
 function _rdiv!(Dc::Diagonal, Db::Diagonal, Da::Diagonal)
     n, k = length(Db.diag), length(Da.diag)
-    n == k || throw(DimensionMismatch("left hand side has $n columns but D is $k by $k"))
+    n == k || throw(DimensionMismatch(lazy"left hand side has $n columns but D is $k by $k"))
     j = findfirst(iszero, Da.diag)
     isnothing(j) || throw(SingularException(j))
     Dc.diag .= Db.diag ./ Da.diag
@@ -498,10 +498,10 @@ function ldiv!(T::Tridiagonal, D::Diagonal, S::Union{SymTridiagonal,Tridiagonal}
     m = size(S, 1)
     dd = D.diag
     if (k = length(dd)) != m
-        throw(DimensionMismatch("diagonal matrix is $k by $k but right hand side has $m rows"))
+        throw(DimensionMismatch(lazy"diagonal matrix is $k by $k but right hand side has $m rows"))
     end
     if length(T.d) != m
-        throw(DimensionMismatch("target matrix size $(size(T)) does not match input matrix size $(size(S))"))
+        throw(DimensionMismatch(lazy"target matrix size $(size(T)) does not match input matrix size $(size(S))"))
     end
     m == 0 && return T
     j = findfirst(iszero, dd)
@@ -535,10 +535,10 @@ function _rdiv!(T::Tridiagonal, S::Union{SymTridiagonal,Tridiagonal}, D::Diagona
     n = size(S, 2)
     dd = D.diag
     if (k = length(dd)) != n
-        throw(DimensionMismatch("left hand side has $n columns but D is $k by $k"))
+        throw(DimensionMismatch(lazy"left hand side has $n columns but D is $k by $k"))
     end
     if length(T.d) != n
-        throw(DimensionMismatch("target matrix size $(size(T)) does not match input matrix size $(size(S))"))
+        throw(DimensionMismatch(lazy"target matrix size $(size(T)) does not match input matrix size $(size(S))"))
     end
     n == 0 && return T
     j = findfirst(iszero, dd)
@@ -608,7 +608,7 @@ end
     valB = B.diag; nB = length(valB)
     nC = checksquare(C)
     @boundscheck nC == nA*nB ||
-        throw(DimensionMismatch("expect C to be a $(nA*nB)x$(nA*nB) matrix, got size $(nC)x$(nC)"))
+        throw(DimensionMismatch(lazy"expect C to be a $(nA*nB)x$(nA*nB) matrix, got size $(nC)x$(nC)"))
     isempty(A) || isempty(B) || fill!(C, zero(A[1,1] * B[1,1]))
     @inbounds for i = 1:nA, j = 1:nB
         idx = (i-1)*nB+j
@@ -639,7 +639,7 @@ end
     (mB, nB) = size(B)
     (mC, nC) = size(C)
     @boundscheck (mC, nC) == (mA * mB, nA * nB) ||
-        throw(DimensionMismatch("expect C to be a $(mA * mB)x$(nA * nB) matrix, got size $(mC)x$(nC)"))
+        throw(DimensionMismatch(lazy"expect C to be a $(mA * mB)x$(nA * nB) matrix, got size $(mC)x$(nC)"))
     isempty(A) || isempty(B) || fill!(C, zero(A[1,1] * B[1,1]))
     m = 1
     @inbounds for j = 1:nA
@@ -662,7 +662,7 @@ end
     (mB, nB) = size(B)
     (mC, nC) = size(C)
     @boundscheck (mC, nC) == (mA * mB, nA * nB) ||
-        throw(DimensionMismatch("expect C to be a $(mA * mB)x$(nA * nB) matrix, got size $(mC)x$(nC)"))
+        throw(DimensionMismatch(lazy"expect C to be a $(mA * mB)x$(nA * nB) matrix, got size $(mC)x$(nC)"))
     isempty(A) || isempty(B) || fill!(C, zero(A[1,1] * B[1,1]))
     m = 1
     @inbounds for j = 1:nA
@@ -875,7 +875,7 @@ dot(x::AbstractVector, D::Diagonal, y::AbstractVector) = _mapreduce_prod(dot, x,
 
 dot(A::Diagonal, B::Diagonal) = dot(A.diag, B.diag)
 function dot(D::Diagonal, B::AbstractMatrix)
-    size(D) == size(B) || throw(DimensionMismatch("Matrix sizes $(size(D)) and $(size(B)) differ"))
+    size(D) == size(B) || throw(DimensionMismatch(lazy"Matrix sizes $(size(D)) and $(size(B)) differ"))
     return dot(D.diag, view(B, diagind(B, IndexStyle(B))))
 end
 
@@ -883,7 +883,7 @@ dot(A::AbstractMatrix, B::Diagonal) = conj(dot(B, A))
 
 function _mapreduce_prod(f, x, D::Diagonal, y)
     if !(length(x) == length(D.diag) == length(y))
-        throw(DimensionMismatch("x has length $(length(x)), D has size $(size(D)), and y has $(length(y))"))
+        throw(DimensionMismatch(lazy"x has length $(length(x)), D has size $(size(D)), and y has $(length(y))"))
     end
     if isempty(x) && isempty(D) && isempty(y)
         return zero(promote_op(f, eltype(x), eltype(D), eltype(y)))
diff --git a/stdlib/LinearAlgebra/src/generic.jl b/stdlib/LinearAlgebra/src/generic.jl
index 023f2a1147feb..35014cd520630 100644
--- a/stdlib/LinearAlgebra/src/generic.jl
+++ b/stdlib/LinearAlgebra/src/generic.jl
@@ -110,7 +110,7 @@ end
 
 function generic_mul!(C::AbstractArray, X::AbstractArray, s::Number, _add::MulAddMul)
     if length(C) != length(X)
-        throw(DimensionMismatch("first array has length $(length(C)) which does not match the length of the second, $(length(X))."))
+        throw(DimensionMismatch(lazy"first array has length $(length(C)) which does not match the length of the second, $(length(X))."))
     end
     for (IC, IX) in zip(eachindex(C), eachindex(X))
         @inbounds _modify!(_add, X[IX] * s, C, IC)
@@ -120,7 +120,7 @@ end
 
 function generic_mul!(C::AbstractArray, s::Number, X::AbstractArray, _add::MulAddMul)
     if length(C) != length(X)
-        throw(DimensionMismatch("first array has length $(length(C)) which does not
+        throw(DimensionMismatch(lazy"first array has length $(length(C)) which does not
 match the length of the second, $(length(X))."))
     end
     for (IC, IX) in zip(eachindex(C), eachindex(X))
@@ -748,7 +748,7 @@ function opnorm(A::AbstractMatrix, p::Real=2)
     elseif p == Inf
         return opnormInf(A)
     else
-        throw(ArgumentError("invalid p-norm p=$p. Valid: 1, 2, Inf"))
+        throw(ArgumentError(lazy"invalid p-norm p=$p. Valid: 1, 2, Inf"))
     end
 end
 
@@ -886,7 +886,7 @@ dot(x::Number, y::Number) = conj(x) * y
 function dot(x::AbstractArray, y::AbstractArray)
     lx = length(x)
     if lx != length(y)
-        throw(DimensionMismatch("first array has length $(lx) which does not match the length of the second, $(length(y))."))
+        throw(DimensionMismatch(lazy"first array has length $(lx) which does not match the length of the second, $(length(y))."))
     end
     if lx == 0
         return dot(zero(eltype(x)), zero(eltype(y)))
@@ -1464,7 +1464,7 @@ julia> axpy!(2, x, y)
 function axpy!(α, x::AbstractArray, y::AbstractArray)
     n = length(x)
     if n != length(y)
-        throw(DimensionMismatch("x has length $n, but y has length $(length(y))"))
+        throw(DimensionMismatch(lazy"x has length $n, but y has length $(length(y))"))
     end
     iszero(α) && return y
     for (IY, IX) in zip(eachindex(y), eachindex(x))
@@ -1475,7 +1475,7 @@ end
 
 function axpy!(α, x::AbstractArray, rx::AbstractArray{<:Integer}, y::AbstractArray, ry::AbstractArray{<:Integer})
     if length(rx) != length(ry)
-        throw(DimensionMismatch("rx has length $(length(rx)), but ry has length $(length(ry))"))
+        throw(DimensionMismatch(lazy"rx has length $(length(rx)), but ry has length $(length(ry))"))
     elseif !checkindex(Bool, eachindex(IndexLinear(), x), rx)
         throw(BoundsError(x, rx))
     elseif !checkindex(Bool, eachindex(IndexLinear(), y), ry)
@@ -1509,7 +1509,7 @@ julia> axpby!(2, x, 2, y)
 """
 function axpby!(α, x::AbstractArray, β, y::AbstractArray)
     if length(x) != length(y)
-        throw(DimensionMismatch("x has length $(length(x)), but y has length $(length(y))"))
+        throw(DimensionMismatch(lazy"x has length $(length(x)), but y has length $(length(y))"))
     end
     iszero(α) && isone(β) && return y
     for (IX, IY) in zip(eachindex(x), eachindex(y))
@@ -1549,7 +1549,7 @@ function rotate!(x::AbstractVector, y::AbstractVector, c, s)
     require_one_based_indexing(x, y)
     n = length(x)
     if n != length(y)
-        throw(DimensionMismatch("x has length $(length(x)), but y has length $(length(y))"))
+        throw(DimensionMismatch(lazy"x has length $(length(x)), but y has length $(length(y))"))
     end
     @inbounds for i = 1:n
         xi, yi = x[i], y[i]
@@ -1572,7 +1572,7 @@ function reflect!(x::AbstractVector, y::AbstractVector, c, s)
     require_one_based_indexing(x, y)
     n = length(x)
     if n != length(y)
-        throw(DimensionMismatch("x has length $(length(x)), but y has length $(length(y))"))
+        throw(DimensionMismatch(lazy"x has length $(length(x)), but y has length $(length(y))"))
     end
     @inbounds for i = 1:n
         xi, yi = x[i], y[i]
@@ -1613,7 +1613,7 @@ Multiplies `A` in-place by a Householder reflection on the left. It is equivalen
     require_one_based_indexing(x)
     m, n = size(A, 1), size(A, 2)
     if length(x) != m
-        throw(DimensionMismatch("reflector has length $(length(x)), which must match the first dimension of matrix A, $m"))
+        throw(DimensionMismatch(lazy"reflector has length $(length(x)), which must match the first dimension of matrix A, $m"))
     end
     m == 0 && return A
     @inbounds for j = 1:n
@@ -1943,7 +1943,7 @@ function copytrito!(B::AbstractMatrix, A::AbstractMatrix, uplo::AbstractChar)
     BLAS.chkuplo(uplo)
     m,n = size(A)
     m1,n1 = size(B)
-    (m1 < m || n1 < n) && throw(DimensionMismatch("B of size ($m1,$n1) should have at least the same number of rows and columns than A of size ($m,$n)"))
+    (m1 < m || n1 < n) && throw(DimensionMismatch(lazy"B of size ($m1,$n1) should have at least the same number of rows and columns than A of size ($m,$n)"))
     if uplo == 'U'
         for j=1:n
             for i=1:min(j,m)
diff --git a/stdlib/LinearAlgebra/src/hessenberg.jl b/stdlib/LinearAlgebra/src/hessenberg.jl
index 3be41baf24b24..f20d76e727b34 100644
--- a/stdlib/LinearAlgebra/src/hessenberg.jl
+++ b/stdlib/LinearAlgebra/src/hessenberg.jl
@@ -90,7 +90,7 @@ Base.@propagate_inbounds getindex(H::UpperHessenberg{T}, i::Integer, j::Integer)
 Base.@propagate_inbounds function setindex!(A::UpperHessenberg, x, i::Integer, j::Integer)
     if i > j+1
         x == 0 || throw(ArgumentError("cannot set index in the lower triangular part " *
-            "($i, $j) of an UpperHessenberg matrix to a nonzero value ($x)"))
+            lazy"($i, $j) of an UpperHessenberg matrix to a nonzero value ($x)"))
     else
         A.data[i,j] = x
     end
@@ -180,7 +180,7 @@ end
 function ldiv!(F::UpperHessenberg, B::AbstractVecOrMat; shift::Number=false)
     checksquare(F)
     m = size(F,1)
-    m != size(B,1) && throw(DimensionMismatch("wrong right-hand-side # rows != $m"))
+    m != size(B,1) && throw(DimensionMismatch(lazy"wrong right-hand-side # rows != $m"))
     require_one_based_indexing(B)
     n = size(B,2)
     H = F.data
@@ -230,7 +230,7 @@ end
 function rdiv!(B::AbstractMatrix, F::UpperHessenberg; shift::Number=false)
     checksquare(F)
     m = size(F,1)
-    m != size(B,2) && throw(DimensionMismatch("wrong right-hand-side # cols != $m"))
+    m != size(B,2) && throw(DimensionMismatch(lazy"wrong right-hand-side # cols != $m"))
     require_one_based_indexing(B)
     n = size(B,1)
     H = F.data
diff --git a/stdlib/LinearAlgebra/src/lapack.jl b/stdlib/LinearAlgebra/src/lapack.jl
index 875ed3ed4e3da..cf9a47073abd0 100644
--- a/stdlib/LinearAlgebra/src/lapack.jl
+++ b/stdlib/LinearAlgebra/src/lapack.jl
@@ -26,7 +26,7 @@ Handle only negative LAPACK error codes
 """
 function chkargsok(ret::BlasInt)
     if ret < 0
-        throw(ArgumentError("invalid argument #$(-ret) to LAPACK call"))
+        throw(ArgumentError(lazy"invalid argument #$(-ret) to LAPACK call"))
     end
 end
 
@@ -35,7 +35,7 @@ function chklapackerror(ret::BlasInt, f...)
     if ret == 0
         return
     elseif ret < 0
-        throw(ArgumentError("invalid argument #$(-ret) to LAPACK call"))
+        throw(ArgumentError(lazy"invalid argument #$(-ret) to LAPACK call"))
     else # ret > 0
         chklapackerror_positive(ret, f...)
     end
@@ -63,7 +63,7 @@ end
 function chkvalidparam(position::Int, var::String, val, validvals)
     if val ∉ validvals
         throw(ArgumentError(
-            "argument #$position: $var must be one of $validvals, but $(repr(val)) was passed"))
+            lazy"argument #$position: $var must be one of $validvals, but $(repr(val)) was passed"))
     end
     return val
 end
@@ -71,7 +71,7 @@ end
 "Check that {c}transpose is correctly specified"
 function chktrans(trans::AbstractChar)
     if !(trans == 'N' || trans == 'C' || trans == 'T')
-        throw(ArgumentError("trans argument must be 'N' (no transpose), 'T' (transpose), or 'C' (conjugate transpose), got '$trans'"))
+        throw(ArgumentError(lazy"trans argument must be 'N' (no transpose), 'T' (transpose), or 'C' (conjugate transpose), got '$trans'"))
     end
     trans
 end
@@ -79,7 +79,7 @@ end
 "Check that left/right hand side multiply is correctly specified"
 function chkside(side::AbstractChar)
     if !(side == 'L' || side == 'R')
-        throw(ArgumentError("side argument must be 'L' (left hand multiply) or 'R' (right hand multiply), got '$side'"))
+        throw(ArgumentError(lazy"side argument must be 'L' (left hand multiply) or 'R' (right hand multiply), got '$side'"))
     end
     side
 end
@@ -87,7 +87,7 @@ end
 "Check that unit diagonal flag is correctly specified"
 function chkdiag(diag::AbstractChar)
     if !(diag == 'U' || diag =='N')
-        throw(ArgumentError("diag argument must be 'U' (unit diagonal) or 'N' (non-unit diagonal), got '$diag'"))
+        throw(ArgumentError(lazy"diag argument must be 'U' (unit diagonal) or 'N' (non-unit diagonal), got '$diag'"))
     end
     diag
 end
@@ -178,7 +178,7 @@ for (gbtrf, gbtrs, elty) in
             info = Ref{BlasInt}()
             n    = size(AB,2)
             if m != n || m != size(B,1)
-                throw(DimensionMismatch("matrix AB has dimensions $(size(AB)), but right hand side matrix B has dimensions $(size(B))"))
+                throw(DimensionMismatch(lazy"matrix AB has dimensions $(size(AB)), but right hand side matrix B has dimensions $(size(B))"))
             end
             ccall((@blasfunc($gbtrs), libblastrampoline), Cvoid,
                   (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{BlasInt}, Ref{BlasInt},
@@ -355,7 +355,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             n     = BlasInt(size(A, 2))
             lda   = BlasInt(max(1,stride(A, 2)))
             if length(tau) != min(m,n)
-                throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             lwork = BlasInt(-1)
             work  = Vector{$elty}(undef, 1)
@@ -386,7 +386,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             n     = BlasInt(size(A, 2))
             lda   = BlasInt(max(1,stride(A, 2)))
             if length(tau) != min(m,n)
-                throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             lwork = BlasInt(-1)
             work  = Vector{$elty}(undef, 1)
@@ -416,10 +416,10 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             chkstride1(A,jpvt,tau)
             m,n = size(A)
             if length(tau) != min(m,n)
-                throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             if length(jpvt) != n
-                throw(DimensionMismatch("jpvt has length $(length(jpvt)), but needs length $n"))
+                throw(DimensionMismatch(lazy"jpvt has length $(length(jpvt)), but needs length $n"))
             end
             lda = stride(A,2)
             if lda == 0
@@ -466,7 +466,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             minmn = min(m, n)
             nb = size(T, 1)
             if nb > minmn
-                throw(ArgumentError("block size $nb > $minmn too large"))
+                throw(ArgumentError(lazy"block size $nb > $minmn too large"))
             end
             lda = max(1, stride(A,2))
             work = Vector{$elty}(undef, nb*n)
@@ -491,10 +491,10 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             m, n = size(A)
             p, q = size(T)
             if m < n
-                throw(DimensionMismatch("input matrix A has dimensions ($m,$n), but should have more rows than columns"))
+                throw(DimensionMismatch(lazy"input matrix A has dimensions ($m,$n), but should have more rows than columns"))
             end
             if p != n || q != n
-                throw(DimensionMismatch("block reflector T has dimensions ($p,$q), but should have dimensions ($n,$n)"))
+                throw(DimensionMismatch(lazy"block reflector T has dimensions ($p,$q), but should have dimensions ($n,$n)"))
             end
             if n > 0    # this implies `m > 0` because of `m >= n`
                 info = Ref{BlasInt}()
@@ -519,7 +519,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             chkstride1(A,tau)
             m, n  = size(A)
             if length(tau) != min(m,n)
-                throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -548,7 +548,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             chkstride1(A,tau)
             m, n  = size(A)
             if length(tau) != min(m,n)
-                throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             lwork = BlasInt(-1)
             work  = Vector{$elty}(undef, 1)
@@ -869,7 +869,7 @@ for (tzrzf, ormrz, elty) in
             chkstride1(A)
             m, n = size(A)
             if n < m
-                throw(DimensionMismatch("input matrix A has dimensions ($m,$n), but cannot have fewer columns than rows"))
+                throw(DimensionMismatch(lazy"input matrix A has dimensions ($m,$n), but cannot have fewer columns than rows"))
             end
             lda = max(1, stride(A,2))
             tau = similar(A, $elty, m)
@@ -974,7 +974,7 @@ for (gels, gesv, getrs, getri, elty) in
             btrn  = trans == 'T'
             m, n  = size(A)
             if size(B,1) != (btrn ? n : m)
-                throw(DimensionMismatch("matrix A has dimensions ($m,$n), transposed: $btrn, but leading dimension of B is $(size(B,1))"))
+                throw(DimensionMismatch(lazy"matrix A has dimensions ($m,$n), transposed: $btrn, but leading dimension of B is $(size(B,1))"))
             end
             info  = Ref{BlasInt}()
             work  = Vector{$elty}(undef, 1)
@@ -1017,7 +1017,7 @@ for (gels, gesv, getrs, getri, elty) in
             chkstride1(A, B)
             n = checksquare(A)
             if size(B,1) != n
-                throw(DimensionMismatch("B has leading dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has leading dimension $(size(B,1)), but needs $n"))
             end
             ipiv = similar(A, BlasInt, n)
             info = Ref{BlasInt}()
@@ -1042,10 +1042,10 @@ for (gels, gesv, getrs, getri, elty) in
             chkstride1(A, B, ipiv)
             n = checksquare(A)
             if n != size(B, 1)
-                throw(DimensionMismatch("B has leading dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has leading dimension $(size(B,1)), but needs $n"))
             end
             if n != length(ipiv)
-                throw(DimensionMismatch("ipiv has length $(length(ipiv)), but needs to be $n"))
+                throw(DimensionMismatch(lazy"ipiv has length $(length(ipiv)), but needs to be $n"))
             end
             nrhs = size(B, 2)
             info = Ref{BlasInt}()
@@ -1068,7 +1068,7 @@ for (gels, gesv, getrs, getri, elty) in
             chkstride1(A, ipiv)
             n = checksquare(A)
             if n != length(ipiv)
-                throw(DimensionMismatch("ipiv has length $(length(ipiv)), but needs $n"))
+                throw(DimensionMismatch(lazy"ipiv has length $(length(ipiv)), but needs $n"))
             end
             lda = max(1,stride(A, 2))
             lwork = BlasInt(-1)
@@ -1331,7 +1331,7 @@ for (gelsd, gelsy, elty) in
             chkstride1(A, B)
             m, n  = size(A)
             if size(B, 1) != m
-                throw(DimensionMismatch("B has leading dimension $(size(B,1)) but needs $m"))
+                throw(DimensionMismatch(lazy"B has leading dimension $(size(B,1)) but needs $m"))
             end
             newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
             s     = similar(A, $elty, min(m, n))
@@ -1376,7 +1376,7 @@ for (gelsd, gelsy, elty) in
             n = size(A, 2)
             nrhs = size(B, 2)
             if size(B, 1) != m
-                throw(DimensionMismatch("B has leading dimension $(size(B,1)) but needs $m"))
+                throw(DimensionMismatch(lazy"B has leading dimension $(size(B,1)) but needs $m"))
             end
             newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
             lda = max(1, stride(A,2))
@@ -1426,7 +1426,7 @@ for (gelsd, gelsy, elty, relty) in
             chkstride1(A, B)
             m, n  = size(A)
             if size(B, 1) != m
-                throw(DimensionMismatch("B has leading dimension $(size(B,1)) but needs $m"))
+                throw(DimensionMismatch(lazy"B has leading dimension $(size(B,1)) but needs $m"))
             end
             newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
             s     = similar(A, $relty, min(m, n))
@@ -1473,7 +1473,7 @@ for (gelsd, gelsy, elty, relty) in
             m, n = size(A)
             nrhs = size(B, 2)
             if size(B, 1) != m
-                throw(DimensionMismatch("B has leading dimension $(size(B,1)) but needs $m"))
+                throw(DimensionMismatch(lazy"B has leading dimension $(size(B,1)) but needs $m"))
             end
             newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
             lda = max(1, m)
@@ -1547,13 +1547,13 @@ for (gglse, elty) in ((:dgglse_, :Float64),
             m, n = size(A)
             p = size(B, 1)
             if size(B, 2) != n
-                throw(DimensionMismatch("B has second dimension $(size(B,2)), needs $n"))
+                throw(DimensionMismatch(lazy"B has second dimension $(size(B,2)), needs $n"))
             end
             if length(c) != m
-                throw(DimensionMismatch("c has length $(length(c)), needs $m"))
+                throw(DimensionMismatch(lazy"c has length $(length(c)), needs $m"))
             end
             if length(d) != p
-                throw(DimensionMismatch("d has length $(length(d)), needs $p"))
+                throw(DimensionMismatch(lazy"d has length $(length(d)), needs $p"))
             end
             X = zeros($elty, n)
             info  = Ref{BlasInt}()
@@ -1823,7 +1823,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
             @chkvalidparam 3 jobq ('Q', 'N')
             m, n = size(A)
             if size(B, 2) != n
-                throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs $n"))
+                throw(DimensionMismatch(lazy"B has second dimension $(size(B,2)) but needs $n"))
             end
             p = size(B, 1)
             k = Vector{BlasInt}(undef, 1)
@@ -1953,7 +1953,7 @@ for (f, elty) in ((:dggsvd3_, :Float64),
             @chkvalidparam 3 jobq ('Q', 'N')
             m, n = size(A)
             if size(B, 2) != n
-                throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs $n"))
+                throw(DimensionMismatch(lazy"B has second dimension $(size(B,2)) but needs $n"))
             end
             p = size(B, 1)
             k = Ref{BlasInt}()
@@ -2015,7 +2015,7 @@ for (f, elty, relty) in ((:zggsvd3_, :ComplexF64, :Float64),
             @chkvalidparam 3 jobq ('Q', 'N')
             m, n = size(A)
             if size(B, 2) != n
-                throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs $n"))
+                throw(DimensionMismatch(lazy"B has second dimension $(size(B,2)) but needs $n"))
             end
             p = size(B, 1)
             k = Vector{BlasInt}(undef, 1)
@@ -2103,7 +2103,7 @@ for (geevx, ggev, ggev3, elty) in
             @chkvalidparam 1 balanc ('N', 'P', 'S', 'B')
             @chkvalidparam 4 sense ('N', 'E', 'V', 'B')
             if sense ∈ ('E', 'B') && !(jobvl == jobvr == 'V')
-                throw(ArgumentError("sense = '$sense' requires jobvl = 'V' and jobvr = 'V'"))
+                throw(ArgumentError(lazy"sense = '$sense' requires jobvl = 'V' and jobvr = 'V'"))
             end
             n = checksquare(A)
             ldvl = 0
@@ -2112,7 +2112,7 @@ for (geevx, ggev, ggev3, elty) in
             elseif jobvl == 'N'
                 ldvl = 0
             else
-                throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
+                throw(ArgumentError(lazy"jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
             ldvr = 0
             if jobvr == 'V'
@@ -2120,7 +2120,7 @@ for (geevx, ggev, ggev3, elty) in
             elseif jobvr == 'N'
                 ldvr = 0
             else
-                throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
+                throw(ArgumentError(lazy"jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
             chkfinite(A) # balancing routines don't support NaNs and Infs
             lda = max(1,stride(A,2))
@@ -2142,7 +2142,7 @@ for (geevx, ggev, ggev3, elty) in
             elseif sense == 'V' || sense == 'B'
                 iworksize = 2*n - 2
             else
-                throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
+                throw(ArgumentError(lazy"sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
             end
             iwork = Vector{BlasInt}(undef, iworksize)
             info = Ref{BlasInt}()
@@ -2186,7 +2186,7 @@ for (geevx, ggev, ggev3, elty) in
             chkstride1(A,B)
             n, m = checksquare(A,B)
             if n != m
-                throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
+                throw(DimensionMismatch(lazy"A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
             ldvl = 0
             if jobvl == 'V'
@@ -2194,7 +2194,7 @@ for (geevx, ggev, ggev3, elty) in
             elseif jobvl == 'N'
                 ldvl = 1
             else
-                throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
+                throw(ArgumentError(lazy"jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
             ldvr = 0
             if jobvr == 'V'
@@ -2202,7 +2202,7 @@ for (geevx, ggev, ggev3, elty) in
             elseif jobvr == 'N'
                 ldvr = 1
             else
-                throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
+                throw(ArgumentError(lazy"jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
@@ -2250,7 +2250,7 @@ for (geevx, ggev, ggev3, elty) in
             chkstride1(A,B)
             n, m = checksquare(A,B)
             if n != m
-                throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
+                throw(DimensionMismatch(lazy"A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
             ldvl = 0
             if jobvl == 'V'
@@ -2258,7 +2258,7 @@ for (geevx, ggev, ggev3, elty) in
             elseif jobvl == 'N'
                 ldvl = 1
             else
-                throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
+                throw(ArgumentError(lazy"jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
             ldvr = 0
             if jobvr == 'V'
@@ -2266,7 +2266,7 @@ for (geevx, ggev, ggev3, elty) in
             elseif jobvr == 'N'
                 ldvr = 1
             else
-                throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
+                throw(ArgumentError(lazy"jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
@@ -2322,13 +2322,13 @@ for (geevx, ggev, ggev3, elty, relty) in
         function geevx!(balanc::AbstractChar, jobvl::AbstractChar, jobvr::AbstractChar, sense::AbstractChar, A::AbstractMatrix{$elty})
             require_one_based_indexing(A)
             if balanc ∉ ('N', 'P', 'S', 'B')
-                throw(ArgumentError("balanc must be 'N', 'P', 'S', or 'B', but $balanc was passed"))
+                throw(ArgumentError(lazy"balanc must be 'N', 'P', 'S', or 'B', but $balanc was passed"))
             end
             if sense ∉ ('N','E','V','B')
-                throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
+                throw(ArgumentError(lazy"sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
             end
             if sense ∈ ('E', 'B') && !(jobvl == jobvr == 'V')
-                throw(ArgumentError("sense = '$sense' requires jobvl = 'V' and jobvr = 'V'"))
+                throw(ArgumentError(lazy"sense = '$sense' requires jobvl = 'V' and jobvr = 'V'"))
             end
             n = checksquare(A)
             ldvl = 0
@@ -2337,7 +2337,7 @@ for (geevx, ggev, ggev3, elty, relty) in
             elseif jobvl == 'N'
                 ldvl = 0
             else
-                throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
+                throw(ArgumentError(lazy"jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
             ldvr = 0
             if jobvr == 'V'
@@ -2345,7 +2345,7 @@ for (geevx, ggev, ggev3, elty, relty) in
             elseif jobvr == 'N'
                 ldvr = 0
             else
-                throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
+                throw(ArgumentError(lazy"jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
             chkfinite(A) # balancing routines don't support NaNs and Infs
             lda = max(1,stride(A,2))
@@ -2401,7 +2401,7 @@ for (geevx, ggev, ggev3, elty, relty) in
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
-                throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
+                throw(DimensionMismatch(lazy"A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
             ldvl = 0
             if jobvl == 'V'
@@ -2409,7 +2409,7 @@ for (geevx, ggev, ggev3, elty, relty) in
             elseif jobvl == 'N'
                 ldvl = 1
             else
-                throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
+                throw(ArgumentError(lazy"jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
             ldvr = 0
             if jobvr == 'V'
@@ -2417,7 +2417,7 @@ for (geevx, ggev, ggev3, elty, relty) in
             elseif jobvr == 'N'
                 ldvr = 1
             else
-                throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
+                throw(ArgumentError(lazy"jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
@@ -2466,7 +2466,7 @@ for (geevx, ggev, ggev3, elty, relty) in
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
-                throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
+                throw(DimensionMismatch(lazy"A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
             ldvl = 0
             if jobvl == 'V'
@@ -2474,7 +2474,7 @@ for (geevx, ggev, ggev3, elty, relty) in
             elseif jobvl == 'N'
                 ldvl = 1
             else
-                throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
+                throw(ArgumentError(lazy"jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
             ldvr = 0
             if jobvr == 'V'
@@ -2482,7 +2482,7 @@ for (geevx, ggev, ggev3, elty, relty) in
             elseif jobvr == 'N'
                 ldvr = 1
             else
-                throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
+                throw(ArgumentError(lazy"jobvr must be 'V' or 'N', but $jobvr was passed"))
             end
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
@@ -2576,7 +2576,7 @@ for (laic1, elty) in
             @chkvalidparam 1 job (1,2)
             j = length(x)
             if j != length(w)
-                throw(DimensionMismatch("vectors must have same length, but length of x is $j and length of w is $(length(w))"))
+                throw(DimensionMismatch(lazy"vectors must have same length, but length of x is $j and length of w is $(length(w))"))
             end
             sestpr = Ref{$elty}()
             s = Ref{$elty}()
@@ -2611,7 +2611,7 @@ for (laic1, elty, relty) in
             @chkvalidparam 1 job (1,2)
             j = length(x)
             if j != length(w)
-                throw(DimensionMismatch("vectors must have same length, but length of x is $j and length of w is $(length(w))"))
+                throw(DimensionMismatch(lazy"vectors must have same length, but length of x is $j and length of w is $(length(w))"))
             end
             sestpr = Ref{$relty}()
             s = Ref{$elty}()
@@ -2646,13 +2646,13 @@ for (gtsv, gttrf, gttrs, elty) in
             chkstride1(B, dl, d, du)
             n = length(d)
             if !(n >= length(dl) >= n - 1)
-                throw(DimensionMismatch("subdiagonal has length $(length(dl)), but should be $n or $(n - 1)"))
+                throw(DimensionMismatch(lazy"subdiagonal has length $(length(dl)), but should be $n or $(n - 1)"))
             end
             if !(n >= length(du) >= n - 1)
-                throw(DimensionMismatch("superdiagonal has length $(length(du)), but should be $n or $(n - 1)"))
+                throw(DimensionMismatch(lazy"superdiagonal has length $(length(du)), but should be $n or $(n - 1)"))
             end
             if n != size(B,1)
-                throw(DimensionMismatch("B has leading dimension $(size(B,1)), but should have $n"))
+                throw(DimensionMismatch(lazy"B has leading dimension $(size(B,1)), but should have $n"))
             end
             if n == 0
                 return B # Early exit if possible
@@ -2677,10 +2677,10 @@ for (gtsv, gttrf, gttrs, elty) in
             chkstride1(dl,d,du)
             n    = length(d)
             if length(dl) != n - 1
-                throw(DimensionMismatch("subdiagonal has length $(length(dl)), but should be $(n - 1)"))
+                throw(DimensionMismatch(lazy"subdiagonal has length $(length(dl)), but should be $(n - 1)"))
             end
             if length(du) != n - 1
-                throw(DimensionMismatch("superdiagonal has length $(length(du)), but should be $(n - 1)"))
+                throw(DimensionMismatch(lazy"superdiagonal has length $(length(du)), but should be $(n - 1)"))
             end
             du2  = similar(d, $elty, n-2)
             ipiv = similar(d, BlasInt, n)
@@ -2708,13 +2708,13 @@ for (gtsv, gttrf, gttrs, elty) in
             chkstride1(B, ipiv, dl, d, du, du2)
             n = length(d)
             if length(dl) != n - 1
-                throw(DimensionMismatch("subdiagonal has length $(length(dl)), but should be $(n - 1)"))
+                throw(DimensionMismatch(lazy"subdiagonal has length $(length(dl)), but should be $(n - 1)"))
             end
             if length(du) != n - 1
-                throw(DimensionMismatch("superdiagonal has length $(length(du)), but should be $(n - 1)"))
+                throw(DimensionMismatch(lazy"superdiagonal has length $(length(du)), but should be $(n - 1)"))
             end
             if n != size(B,1)
-                throw(DimensionMismatch("B has leading dimension $(size(B,1)), but should have $n"))
+                throw(DimensionMismatch(lazy"B has leading dimension $(size(B,1)), but should have $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($gttrs), libblastrampoline), Cvoid,
@@ -2778,7 +2778,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             n = size(A, 2)
             m = min(n, size(A, 1))
             if k > m
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= m = $m"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= m = $m"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2812,7 +2812,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             m = size(A, 1)
             n = min(m, size(A, 2))
             if k > n
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= n = $n"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2848,7 +2848,7 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             m = size(A, 1)
             n = min(m, size(A, 2))
             if k > n
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= n = $n"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2883,10 +2883,10 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             chkstride1(A,tau)
             m, n = size(A)
             if n < m
-                throw(DimensionMismatch("input matrix A has dimensions ($m,$n), but cannot have fewer columns than rows"))
+                throw(DimensionMismatch(lazy"input matrix A has dimensions ($m,$n), but cannot have fewer columns than rows"))
             end
             if k > n
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= n = $n"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2924,16 +2924,16 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             nA = size(A, 2)
             k   = length(tau)
             if side == 'L' && m != nA
-                throw(DimensionMismatch("for a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $nA"))
+                throw(DimensionMismatch(lazy"for a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $nA"))
             end
             if side == 'R' && n != nA
-                throw(DimensionMismatch("for a right-sided multiplication, the second dimension of C, $n, must equal the second dimension of A, $nA"))
+                throw(DimensionMismatch(lazy"for a right-sided multiplication, the second dimension of C, $n, must equal the second dimension of A, $nA"))
             end
             if side == 'L' && k > m
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= m = $m"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= m = $m"))
             end
             if side == 'R' && k > n
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= n = $n"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -2971,16 +2971,16 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             mA  = size(A, 1)
             k   = length(tau)
             if side == 'L' && m != mA
-                throw(DimensionMismatch("for a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $mA"))
+                throw(DimensionMismatch(lazy"for a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $mA"))
             end
             if side == 'R' && n != mA
-                throw(DimensionMismatch("for a right-sided multiplication, the second dimension of C, $m, must equal the second dimension of A, $mA"))
+                throw(DimensionMismatch(lazy"for a right-sided multiplication, the second dimension of C, $m, must equal the second dimension of A, $mA"))
             end
             if side == 'L' && k > m
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= m = $m"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= m = $m"))
             end
             if side == 'R' && k > n
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= n = $n"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -3021,16 +3021,16 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             mA  = size(A, 1)
             k   = length(tau)
             if side == 'L' && m != mA
-                throw(DimensionMismatch("for a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $mA"))
+                throw(DimensionMismatch(lazy"for a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $mA"))
             end
             if side == 'R' && n != mA
-                throw(DimensionMismatch("for a right-sided multiplication, the second dimension of C, $m, must equal the second dimension of A, $mA"))
+                throw(DimensionMismatch(lazy"for a right-sided multiplication, the second dimension of C, $m, must equal the second dimension of A, $mA"))
             end
             if side == 'L' && k > m
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= m = $m"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= m = $m"))
             end
             if side == 'R' && k > n
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= n = $n"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -3071,16 +3071,16 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             nA  = size(A, 2)
             k   = length(tau)
             if side == 'L' && m != nA
-                throw(DimensionMismatch("for a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $nA"))
+                throw(DimensionMismatch(lazy"for a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $nA"))
             end
             if side == 'R' && n != nA
-                throw(DimensionMismatch("for a right-sided multiplication, the second dimension of C, $m, must equal the second dimension of A, $nA"))
+                throw(DimensionMismatch(lazy"for a right-sided multiplication, the second dimension of C, $m, must equal the second dimension of A, $nA"))
             end
             if side == 'L' && k > m
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= m = $m"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= m = $m"))
             end
             if side == 'R' && k > n
-                throw(DimensionMismatch("invalid number of reflectors: k = $k should be <= n = $n"))
+                throw(DimensionMismatch(lazy"invalid number of reflectors: k = $k should be <= n = $n"))
             end
             work  = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -3113,31 +3113,31 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             if side == 'L'
                 if !(0 <= k <= m)
-                    throw(DimensionMismatch("wrong value for k = $k: must be between 0 and $m"))
+                    throw(DimensionMismatch(lazy"wrong value for k = $k: must be between 0 and $m"))
                 end
                 if m != size(V,1)
-                    throw(DimensionMismatch("first dimensions of C, $m, and V, $(size(V,1)) must match"))
+                    throw(DimensionMismatch(lazy"first dimensions of C, $m, and V, $(size(V,1)) must match"))
                 end
                 ldv = stride(V,2)
                 if ldv < max(1, m)
-                    throw(DimensionMismatch("Q and C don't fit! The stride of V, $ldv, is too small"))
+                    throw(DimensionMismatch(lazy"Q and C don't fit! The stride of V, $ldv, is too small"))
                 end
                 wss = n*k
             elseif side == 'R'
                 if !(0 <= k <= n)
-                    throw(DimensionMismatch("wrong value for k = $k: must be between 0 and $n"))
+                    throw(DimensionMismatch(lazy"wrong value for k = $k: must be between 0 and $n"))
                 end
                 if n != size(V,1)
-                    throw(DimensionMismatch("second dimension of C, $n, and first dimension of V, $(size(V,1)) must match"))
+                    throw(DimensionMismatch(lazy"second dimension of C, $n, and first dimension of V, $(size(V,1)) must match"))
                 end
                 ldv = stride(V,2)
                 if ldv < max(1, n)
-                    throw(DimensionMismatch("Q and C don't fit! The stride of V, $ldv, is too small"))
+                    throw(DimensionMismatch(lazy"Q and C don't fit! The stride of V, $ldv, is too small"))
                 end
                 wss = m*k
             end
             if !(1 <= nb <= k)
-                throw(DimensionMismatch("wrong value for nb = $nb, which must be between 1 and $k"))
+                throw(DimensionMismatch(lazy"wrong value for nb = $nb, which must be between 1 and $k"))
             end
             ldc = stride(C, 2)
             work = Vector{$elty}(undef, wss)
@@ -3258,7 +3258,7 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
             n = checksquare(A)
             chkuplo(uplo)
             if size(B,1) != n
-                throw(DimensionMismatch("first dimension of B, $(size(B,1)), and size of A, ($n,$n), must match!"))
+                throw(DimensionMismatch(lazy"first dimension of B, $(size(B,1)), and size of A, ($n,$n), must match!"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($posv), libblastrampoline), Cvoid,
@@ -3328,7 +3328,7 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
             chkuplo(uplo)
             nrhs = size(B,2)
             if size(B,1) != n
-                throw(DimensionMismatch("first dimension of B, $(size(B,1)), and size of A, ($n,$n), must match!"))
+                throw(DimensionMismatch(lazy"first dimension of B, $(size(B,1)), and size of A, ($n,$n), must match!"))
             end
             lda = max(1,stride(A,2))
             if lda == 0 || nrhs == 0
@@ -3445,10 +3445,10 @@ for (ptsv, pttrf, elty, relty) in
             chkstride1(B, D, E)
             n = length(D)
             if length(E) != n - 1
-                throw(DimensionMismatch("E has length $(length(E)), but needs $(n - 1)"))
+                throw(DimensionMismatch(lazy"E has length $(length(E)), but needs $(n - 1)"))
             end
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)) but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)) but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($ptsv), libblastrampoline), Cvoid,
@@ -3469,7 +3469,7 @@ for (ptsv, pttrf, elty, relty) in
             chkstride1(D, E)
             n = length(D)
             if length(E) != n - 1
-                throw(DimensionMismatch("E has length $(length(E)), but needs $(n - 1)"))
+                throw(DimensionMismatch(lazy"E has length $(length(E)), but needs $(n - 1)"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($pttrf), libblastrampoline), Cvoid,
@@ -3513,10 +3513,10 @@ for (pttrs, elty, relty) in
             chkstride1(B, D, E)
             n = length(D)
             if length(E) != n - 1
-                throw(DimensionMismatch("E has length $(length(E)), but needs $(n - 1)"))
+                throw(DimensionMismatch(lazy"E has length $(length(E)), but needs $(n - 1)"))
             end
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)) but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)) but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($pttrs), libblastrampoline), Cvoid,
@@ -3547,10 +3547,10 @@ for (pttrs, elty, relty) in
             chkuplo(uplo)
             n = length(D)
             if length(E) != n - 1
-                throw(DimensionMismatch("E has length $(length(E)), but needs $(n - 1)"))
+                throw(DimensionMismatch(lazy"E has length $(length(E)), but needs $(n - 1)"))
             end
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)) but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)) but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($pttrs), libblastrampoline), Cvoid,
@@ -3616,7 +3616,7 @@ for (trtri, trtrs, elty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)) but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)) but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($trtrs), libblastrampoline), Cvoid,
@@ -3707,7 +3707,7 @@ for (trcon, trevc, trrfs, elty) in
             require_one_based_indexing(select, T, VL, VR)
             # Extract
             if side ∉ ('L','R','B')
-                throw(ArgumentError("side argument must be 'L' (left eigenvectors), 'R' (right eigenvectors), or 'B' (both), got $side"))
+                throw(ArgumentError(lazy"side argument must be 'L' (left eigenvectors), 'R' (right eigenvectors), or 'B' (both), got $side"))
             end
             @chkvalidparam 2 howmny ('A', 'B', 'S')
             n, mm = checksquare(T), size(VL, 2)
@@ -3773,7 +3773,7 @@ for (trcon, trevc, trrfs, elty) in
             n = size(A,2)
             nrhs = size(B,2)
             if nrhs != size(X,2)
-                throw(DimensionMismatch("second dimensions of B, $nrhs, and X, $(size(X,2)), must match"))
+                throw(DimensionMismatch(lazy"second dimensions of B, $nrhs, and X, $(size(X,2)), must match"))
             end
             work = Vector{$elty}(undef, 3n)
             iwork = Vector{BlasInt}(undef, n)
@@ -3849,7 +3849,7 @@ for (trcon, trevc, trrfs, elty, relty) in
             # Check
             chkstride1(T, select, VL, VR)
             if side ∉ ('L','R','B')
-                throw(ArgumentError("side argument must be 'L' (left eigenvectors), 'R' (right eigenvectors), or 'B' (both), got $side"))
+                throw(ArgumentError(lazy"side argument must be 'L' (left eigenvectors), 'R' (right eigenvectors), or 'B' (both), got $side"))
             end
             @chkvalidparam 2 howmny ('A', 'B', 'S')
 
@@ -3910,7 +3910,7 @@ for (trcon, trevc, trrfs, elty, relty) in
             n = size(A,2)
             nrhs = size(B,2)
             if nrhs != size(X,2)
-                throw(DimensionMismatch("second dimensions of B, $nrhs, and X, $(size(X,2)), must match"))
+                throw(DimensionMismatch(lazy"second dimensions of B, $nrhs, and X, $(size(X,2)), must match"))
             end
             work  = Vector{$elty}(undef, 2n)
             rwork = Vector{$relty}(undef, n)
@@ -3982,7 +3982,7 @@ for (stev, stebz, stegr, stein, elty) in
             chkstride1(dv, ev)
             n = length(dv)
             if length(ev) != n - 1 && length(ev) != n
-                throw(DimensionMismatch("ev has length $(length(ev)) but needs one less than or equal to dv's length, $n)"))
+                throw(DimensionMismatch(lazy"ev has length $(length(ev)) but needs one less than or equal to dv's length, $n)"))
             end
             Zmat = similar(dv, $elty, (n, job != 'N' ? n : 0))
             work = Vector{$elty}(undef, max(1, 2n-2))
@@ -4006,7 +4006,7 @@ for (stev, stebz, stegr, stein, elty) in
             chkstride1(dv, ev)
             n = length(dv)
             if length(ev) != n - 1
-                throw(DimensionMismatch("ev has length $(length(ev)) but needs one less than dv's length, $n)"))
+                throw(DimensionMismatch(lazy"ev has length $(length(ev)) but needs one less than dv's length, $n)"))
             end
             m = Ref{BlasInt}()
             nsplit = Vector{BlasInt}(undef, 1)
@@ -4045,7 +4045,7 @@ for (stev, stebz, stegr, stein, elty) in
                 eev = copy(ev)
                 eev[n] = zero($elty)
             else
-                throw(DimensionMismatch("ev has length $ne but needs one less than or equal to dv's length, $n)"))
+                throw(DimensionMismatch(lazy"ev has length $ne but needs one less than or equal to dv's length, $n)"))
             end
 
             abstol = Vector{$elty}(undef, 1)
@@ -4095,12 +4095,12 @@ for (stev, stebz, stegr, stein, elty) in
                 ev = copy(ev_in)
                 ev[n] = zero($elty)
             else
-                throw(DimensionMismatch("ev_in has length $ne but needs one less than or equal to dv's length, $n)"))
+                throw(DimensionMismatch(lazy"ev_in has length $ne but needs one less than or equal to dv's length, $n)"))
             end
             ldz = n #Leading dimension
             #Number of eigenvalues to find
             if !(1 <= length(w_in) <= n)
-                throw(DimensionMismatch("w_in has length $(length(w_in)), but needs to be between 1 and $n"))
+                throw(DimensionMismatch(lazy"w_in has length $(length(w_in)), but needs to be between 1 and $n"))
             end
             m = length(w_in)
             #If iblock and isplit are invalid input, assume worst-case block partitioning,
@@ -4236,7 +4236,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
             work  = Vector{$elty}(undef, 1)
@@ -4365,7 +4365,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($sytrs), libblastrampoline), Cvoid,
@@ -4397,7 +4397,7 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
             work  = Vector{$elty}(undef, 1)
@@ -4490,7 +4490,7 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($sytrs), libblastrampoline), Cvoid,
@@ -4524,10 +4524,10 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty) in
                 throw(ArgumentError("way must be C or R"))
             end
             if length(ipiv) != n
-                throw(ArgumentError("length of pivot vector was $(length(ipiv)) but should have been $n"))
+                throw(ArgumentError(lazy"length of pivot vector was $(length(ipiv)) but should have been $n"))
             end
             if length(e) != n
-                throw(ArgumentError("length of e vector was $(length(e)) but should have been $n"))
+                throw(ArgumentError(lazy"length of e vector was $(length(e)) but should have been $n"))
             end
 
             # allocate
@@ -4591,7 +4591,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
             work  = Vector{$elty}(undef, 1)
@@ -4718,7 +4718,7 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
             chkstride1(A,B,ipiv)
             n = checksquare(A)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($hetrs), libblastrampoline), Cvoid,
@@ -4749,7 +4749,7 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
             work  = Vector{$elty}(undef, 1)
@@ -4839,7 +4839,7 @@ for (hesv, hetrf, hetri, hetrs, elty, relty) in
             chkuplo(uplo)
             n = checksquare(A)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($hetrs), libblastrampoline), Cvoid,
@@ -4871,7 +4871,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
             work  = Vector{$elty}(undef, 1)
@@ -5001,7 +5001,7 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($sytrs), libblastrampoline), Cvoid,
@@ -5033,7 +5033,7 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             ipiv  = similar(A, BlasInt, n)
             work  = Vector{$elty}(undef, 1)
@@ -5127,7 +5127,7 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty, relty) in
             n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
-                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+                throw(DimensionMismatch(lazy"B has first dimension $(size(B,1)), but needs $n"))
             end
             info = Ref{BlasInt}()
             ccall((@blasfunc($sytrs), libblastrampoline), Cvoid,
@@ -5160,13 +5160,13 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty, relty) in
             # check
             chkuplo(uplo)
             if way != 'C' && way != 'R'
-                throw(ArgumentError("way must be 'C' or 'R'"))
+                throw(ArgumentError(lazy"way must be 'C' or 'R'"))
             end
             if length(ipiv) != n
-                throw(ArgumentError("length of pivot vector was $(length(ipiv)) but should have been $n"))
+                throw(ArgumentError(lazy"length of pivot vector was $(length(ipiv)) but should have been $n"))
             end
             if length(e) != n
-                throw(ArgumentError("length of e vector was $(length(e)) but should have been $n"))
+                throw(ArgumentError(lazy"length of e vector was $(length(e)) but should have been $n"))
             end
 
             # allocate
@@ -5368,10 +5368,10 @@ for (syev, syevr, syevd, sygvd, elty) in
             chkstride1(A)
             n = checksquare(A)
             if range == 'I' && !(1 <= il <= iu <= n)
-                throw(ArgumentError("illegal choice of eigenvalue indices (il = $il, iu = $iu), which must be between 1 and n = $n"))
+                throw(ArgumentError(lazy"illegal choice of eigenvalue indices (il = $il, iu = $iu), which must be between 1 and n = $n"))
             end
             if range == 'V' && vl >= vu
-                throw(ArgumentError("lower boundary, $vl, must be less than upper boundary, $vu"))
+                throw(ArgumentError(lazy"lower boundary, $vl, must be less than upper boundary, $vu"))
             end
             chkuplofinite(A, uplo)
             lda = stride(A,2)
@@ -5476,7 +5476,7 @@ for (syev, syevr, syevd, sygvd, elty) in
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
-                throw(DimensionMismatch("dimensions of A, ($n,$n), and B, ($m,$m), must match"))
+                throw(DimensionMismatch(lazy"dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
@@ -5571,10 +5571,10 @@ for (syev, syevr, syevd, sygvd, elty, relty) in
             chkuplofinite(A, uplo)
             n = checksquare(A)
             if range == 'I' && !(1 <= il <= iu <= n)
-                throw(ArgumentError("illegal choice of eigenvalue indices (il = $il, iu=$iu), which must be between 1 and n = $n"))
+                throw(ArgumentError(lazy"illegal choice of eigenvalue indices (il = $il, iu=$iu), which must be between 1 and n = $n"))
             end
             if range == 'V' && vl >= vu
-                throw(ArgumentError("lower boundary, $vl, must be less than upper boundary, $vu"))
+                throw(ArgumentError(lazy"lower boundary, $vl, must be less than upper boundary, $vu"))
             end
             lda = max(1,stride(A,2))
             m = Ref{BlasInt}()
@@ -5691,7 +5691,7 @@ for (syev, syevr, syevd, sygvd, elty, relty) in
             chkuplofinite(B, uplo)
             n, m = checksquare(A, B)
             if n != m
-                throw(DimensionMismatch("dimensions of A, ($n,$n), and B, ($m,$m), must match"))
+                throw(DimensionMismatch(lazy"dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
@@ -5802,19 +5802,19 @@ for (bdsqr, relty, elty) in
             # Do checks
             chkuplo(uplo)
             if length(e_) != n - 1
-                throw(DimensionMismatch("off-diagonal has length $(length(e_)) but should have length $(n - 1)"))
+                throw(DimensionMismatch(lazy"off-diagonal has length $(length(e_)) but should have length $(n - 1)"))
             end
             if ncvt > 0 && ldvt < n
-                throw(DimensionMismatch("leading dimension of Vt, $ldvt, must be at least $n"))
+                throw(DimensionMismatch(lazy"leading dimension of Vt, $ldvt, must be at least $n"))
             end
             if ldu < nru
-                throw(DimensionMismatch("leading dimension of U, $ldu, must be at least $nru"))
+                throw(DimensionMismatch(lazy"leading dimension of U, $ldu, must be at least $nru"))
             end
             if size(U, 2) != n
-                throw(DimensionMismatch("U must have $n columns but has $(size(U, 2))"))
+                throw(DimensionMismatch(lazy"U must have $n columns but has $(size(U, 2))"))
             end
             if ncc > 0 && ldc < n
-                throw(DimensionMismatch("leading dimension of C, $ldc, must be at least $n"))
+                throw(DimensionMismatch(lazy"leading dimension of C, $ldc, must be at least $n"))
             end
             # Allocate
             work = Vector{$relty}(undef, 4n)
@@ -5881,7 +5881,7 @@ for (bdsdc, elty) in
                 ldvt=ldu=max(1, n)
                 lwork=3*n^2 + 4*n
             else
-                throw(ArgumentError("COMPQ argument must be 'N', 'P' or 'I', got $(repr(compq))"))
+                throw(ArgumentError(lazy"COMPQ argument must be 'N', 'P' or 'I', got $(repr(compq))"))
             end
             u  = similar(d, $elty, (ldu,  n))
             vt = similar(d, $elty, (ldvt, n))
@@ -6069,7 +6069,7 @@ for (orghr, elty) in
             chkstride1(A, tau)
             n = checksquare(A)
             if n - length(tau) != 1
-                throw(DimensionMismatch("tau has length $(length(tau)), needs $(n - 1)"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), needs $(n - 1)"))
             end
             work = Vector{$elty}(undef, 1)
             lwork = BlasInt(-1)
@@ -6124,7 +6124,7 @@ for (ormhr, elty) in
             mC, nC = size(C, 1), size(C, 2)
 
             if n - length(tau) != 1
-                throw(DimensionMismatch("tau has length $(length(tau)), needs $(n - 1)"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), needs $(n - 1)"))
             end
             if (side == 'L' && mC != n) || (side == 'R' && nC != n)
                 throw(DimensionMismatch("A and C matrices are not conformable"))
@@ -6326,7 +6326,7 @@ for (orgtr, elty) in
             chkstride1(A, tau)
             n = checksquare(A)
             if n - length(tau) != 1
-                throw(DimensionMismatch("tau has length $(length(tau)), needs $(n - 1)"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), needs $(n - 1)"))
             end
             chkuplo(uplo)
             work = Vector{$elty}(undef, 1)
@@ -6383,10 +6383,10 @@ for (ormtr, elty) in
             mC, nC = size(C, 1), size(C, 2)
 
             if n - length(tau) != 1
-                throw(DimensionMismatch("tau has length $(length(tau)), needs $(n - 1)"))
+                throw(DimensionMismatch(lazy"tau has length $(length(tau)), needs $(n - 1)"))
             end
             if (side == 'L' && mC != n) || (side == 'R' && nC != n)
-                throw(DimensionMismatch("A and C matrices are not conformable"))
+                throw(DimensionMismatch(lazy"A and C matrices are not conformable"))
             end
 
             work = Vector{$elty}(undef, 1)
@@ -6473,7 +6473,7 @@ for (gees, gges, gges3, elty) in
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
-                throw(DimensionMismatch("dimensions of A, ($n,$n), and B, ($m,$m), must match"))
+                throw(DimensionMismatch(lazy"dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
             sdim = BlasInt(0)
             alphar = similar(A, $elty, n)
@@ -6525,7 +6525,7 @@ for (gees, gges, gges3, elty) in
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
-                throw(DimensionMismatch("dimensions of A, ($n,$n), and B, ($m,$m), must match"))
+                throw(DimensionMismatch(lazy"dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
             sdim = BlasInt(0)
             alphar = similar(A, $elty, n)
@@ -6625,7 +6625,7 @@ for (gees, gges, gges3, elty, relty) in
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
-                throw(DimensionMismatch("dimensions of A, ($n,$n), and B, ($m,$m), must match"))
+                throw(DimensionMismatch(lazy"dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
             sdim = BlasInt(0)
             alpha = similar(A, $elty, n)
@@ -6678,7 +6678,7 @@ for (gees, gges, gges3, elty, relty) in
             chkstride1(A, B)
             n, m = checksquare(A, B)
             if n != m
-                throw(DimensionMismatch("dimensions of A, ($n,$n), and B, ($m,$m), must match"))
+                throw(DimensionMismatch(lazy"dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
             sdim = BlasInt(0)
             alpha = similar(A, $elty, n)
@@ -6859,13 +6859,13 @@ for (trexc, trsen, tgsen, elty) in
             chkstride1(select, S, T, Q, Z)
             n, nt, nq, nz = checksquare(S, T, Q, Z)
             if n != nt
-                throw(DimensionMismatch("dimensions of S, ($n,$n), and T, ($nt,$nt), must match"))
+                throw(DimensionMismatch(lazy"dimensions of S, ($n,$n), and T, ($nt,$nt), must match"))
             end
             if n != nq
-                throw(DimensionMismatch("dimensions of S, ($n,$n), and Q, ($nq,$nq), must match"))
+                throw(DimensionMismatch(lazy"dimensions of S, ($n,$n), and Q, ($nq,$nq), must match"))
             end
             if n != nz
-                throw(DimensionMismatch("dimensions of S, ($n,$n), and Z, ($nz,$nz), must match"))
+                throw(DimensionMismatch(lazy"dimensions of S, ($n,$n), and Z, ($nz,$nz), must match"))
             end
             lds = max(1, stride(S, 2))
             ldt = max(1, stride(T, 2))
@@ -7010,13 +7010,13 @@ for (trexc, trsen, tgsen, elty, relty) in
             chkstride1(select, S, T, Q, Z)
             n, nt, nq, nz = checksquare(S, T, Q, Z)
             if n != nt
-                throw(DimensionMismatch("dimensions of S, ($n,$n), and T, ($nt,$nt), must match"))
+                throw(DimensionMismatch(lazy"dimensions of S, ($n,$n), and T, ($nt,$nt), must match"))
             end
             if n != nq
-                throw(DimensionMismatch("dimensions of S, ($n,$n), and Q, ($nq,$nq), must match"))
+                throw(DimensionMismatch(lazy"dimensions of S, ($n,$n), and Q, ($nq,$nq), must match"))
             end
             if n != nz
-                throw(DimensionMismatch("dimensions of S, ($n,$n), and Z, ($nz,$nz), must match"))
+                throw(DimensionMismatch(lazy"dimensions of S, ($n,$n), and Z, ($nz,$nz), must match"))
             end
             lds = max(1, stride(S, 2))
             ldt = max(1, stride(T, 2))
@@ -7115,7 +7115,7 @@ for (fn, elty, relty) in ((:dtrsyl_, :Float64, :Float64),
             ldb = max(1, stride(B, 2))
             m1, n1 = size(C)
             if m != m1 || n != n1
-                throw(DimensionMismatch("dimensions of A, ($m,$n), and C, ($m1,$n1), must match"))
+                throw(DimensionMismatch(lazy"dimensions of A, ($m,$n), and C, ($m1,$n1), must match"))
             end
             ldc = max(1, stride(C, 2))
             scale = Ref{$relty}()
@@ -7165,7 +7165,7 @@ for (fn, elty) in ((:dlacpy_, :Float64),
             chkstride1(A, B)
             m,n = size(A)
             m1,n1 = size(B)
-            (m1 < m || n1 < n) && throw(DimensionMismatch("B of size ($m1,$n1) should have at least the same number of rows and columns than A of size ($m,$n)"))
+            (m1 < m || n1 < n) && throw(DimensionMismatch(lazy"B of size ($m1,$n1) should have at least the same number of rows and columns than A of size ($m,$n)"))
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
             ccall((@blasfunc($fn), libblastrampoline), Cvoid,
diff --git a/stdlib/LinearAlgebra/src/lbt.jl b/stdlib/LinearAlgebra/src/lbt.jl
index b133741611adc..aadcb45d606a3 100644
--- a/stdlib/LinearAlgebra/src/lbt.jl
+++ b/stdlib/LinearAlgebra/src/lbt.jl
@@ -247,11 +247,11 @@ If the given `symbol_name` is not contained within the list of exported symbols,
 function lbt_find_backing_library(symbol_name, interface::Symbol;
                                   config::LBTConfig = lbt_get_config())
     if interface ∉ (:ilp64, :lp64)
-        throw(ArgumentError("Invalid interface specification: '$(interface)'"))
+        throw(ArgumentError(lazy"Invalid interface specification: '$(interface)'"))
     end
     symbol_idx = findfirst(s -> s == symbol_name, config.exported_symbols)
     if symbol_idx === nothing
-        throw(ArgumentError("Invalid exported symbol name '$(symbol_name)'"))
+        throw(ArgumentError(lazy"Invalid exported symbol name '$(symbol_name)'"))
     end
     # Convert to zero-indexed
     symbol_idx -= 1
diff --git a/stdlib/LinearAlgebra/src/ldlt.jl b/stdlib/LinearAlgebra/src/ldlt.jl
index d3d6234961c44..89e57d0dd27eb 100644
--- a/stdlib/LinearAlgebra/src/ldlt.jl
+++ b/stdlib/LinearAlgebra/src/ldlt.jl
@@ -175,7 +175,7 @@ function ldiv!(S::LDLt{<:Any,<:SymTridiagonal}, B::AbstractVecOrMat)
     require_one_based_indexing(B)
     n, nrhs = size(B, 1), size(B, 2)
     if size(S,1) != n
-        throw(DimensionMismatch("Matrix has dimensions $(size(S)) but right hand side has first dimension $n"))
+        throw(DimensionMismatch(lazy"Matrix has dimensions $(size(S)) but right hand side has first dimension $n"))
     end
     d = S.data.dv
     l = S.data.ev
diff --git a/stdlib/LinearAlgebra/src/lu.jl b/stdlib/LinearAlgebra/src/lu.jl
index be32f1e863ff1..72755e0eb6799 100644
--- a/stdlib/LinearAlgebra/src/lu.jl
+++ b/stdlib/LinearAlgebra/src/lu.jl
@@ -680,7 +680,7 @@ function ldiv!(A::LU{T,Tridiagonal{T,V}}, B::AbstractVecOrMat) where {T,V}
     require_one_based_indexing(B)
     n = size(A,1)
     if n != size(B,1)
-        throw(DimensionMismatch("matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
+        throw(DimensionMismatch(lazy"matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
     end
     nrhs = size(B,2)
     dl = A.factors.dl
@@ -713,7 +713,7 @@ function ldiv!(transA::TransposeFactorization{<:Any,<:LU{T,Tridiagonal{T,V}}}, B
     A = transA.parent
     n = size(A,1)
     if n != size(B,1)
-        throw(DimensionMismatch("matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
+        throw(DimensionMismatch(lazy"matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
     end
     nrhs = size(B,2)
     dl = A.factors.dl
@@ -750,7 +750,7 @@ function ldiv!(adjA::AdjointFactorization{<:Any,<:LU{T,Tridiagonal{T,V}}}, B::Ab
     A = adjA.parent
     n = size(A,1)
     if n != size(B,1)
-        throw(DimensionMismatch("matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
+        throw(DimensionMismatch(lazy"matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
     end
     nrhs = size(B,2)
     dl = A.factors.dl
diff --git a/stdlib/LinearAlgebra/src/qr.jl b/stdlib/LinearAlgebra/src/qr.jl
index 782e4778c56c9..06c2fba2932f5 100644
--- a/stdlib/LinearAlgebra/src/qr.jl
+++ b/stdlib/LinearAlgebra/src/qr.jl
@@ -541,7 +541,7 @@ function ldiv!(A::QRPivoted{T,<:StridedMatrix}, B::AbstractMatrix{T}, rcond::Rea
     m, n = size(A)
 
     if m > size(B, 1) || n > size(B, 1)
-        throw(DimensionMismatch("B has leading dimension $(size(B, 1)) but needs at least $(max(m, n))"))
+        throw(DimensionMismatch(lazy"B has leading dimension $(size(B, 1)) but needs at least $(max(m, n))"))
     end
 
     if length(A.factors) == 0 || length(B) == 0
@@ -734,7 +734,7 @@ _ret_size(A::Factorization, B::AbstractMatrix) = (max(size(A, 2), size(B, 1)), s
 function (\)(A::Union{QR{T},QRCompactWY{T},QRPivoted{T}}, BIn::VecOrMat{Complex{T}}) where T<:BlasReal
     require_one_based_indexing(BIn)
     m, n = size(A)
-    m == size(BIn, 1) || throw(DimensionMismatch("left hand side has $m rows, but right hand side has $(size(BIn,1)) rows"))
+    m == size(BIn, 1) || throw(DimensionMismatch(lazy"left hand side has $m rows, but right hand side has $(size(BIn,1)) rows"))
 
 # |z1|z3|  reinterpret  |x1|x2|x3|x4|  transpose  |x1|y1|  reshape  |x1|y1|x3|y3|
 # |z2|z4|      ->       |y1|y2|y3|y4|     ->      |x2|y2|     ->    |x2|y2|x4|y4|
diff --git a/stdlib/LinearAlgebra/src/special.jl b/stdlib/LinearAlgebra/src/special.jl
index 136f566f68447..1363708fb515f 100644
--- a/stdlib/LinearAlgebra/src/special.jl
+++ b/stdlib/LinearAlgebra/src/special.jl
@@ -287,7 +287,7 @@ _small_enough(A::SymTridiagonal) = size(A, 1) <= 2
 function fill!(A::Union{Diagonal,Bidiagonal,Tridiagonal,SymTridiagonal}, x)
     xT = convert(eltype(A), x)
     (iszero(xT) || _small_enough(A)) && return fillstored!(A, xT)
-    throw(ArgumentError("array of type $(typeof(A)) and size $(size(A)) can
+    throw(ArgumentError(lazy"array of type $(typeof(A)) and size $(size(A)) can
     not be filled with $x, since some of its entries are constrained."))
 end
 
diff --git a/stdlib/LinearAlgebra/src/structuredbroadcast.jl b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
index 6114c9a796390..476d9e3e5cd02 100644
--- a/stdlib/LinearAlgebra/src/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
@@ -211,7 +211,7 @@ function copyto!(dest::SymTridiagonal, bc::Broadcasted{<:StructuredMatrixStyle})
     end
     for i = 1:size(dest, 1)-1
         v = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i, i+1))
-        v == (@inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i+1, i))) || throw(ArgumentError("broadcasted assignment breaks symmetry between locations ($i, $(i+1)) and ($(i+1), $i)"))
+        v == (@inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i+1, i))) || throw(ArgumentError(lazy"broadcasted assignment breaks symmetry between locations ($i, $(i+1)) and ($(i+1), $i)"))
         dest.ev[i] = v
     end
     return dest
diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 21047dad8fcd9..07240fb9afb22 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -483,7 +483,7 @@ for (T, trans, real) in [(:Symmetric, :transpose, :identity), (:(Hermitian{<:Uni
         function dot(A::$T, B::$T)
             n = size(A, 2)
             if n != size(B, 2)
-                throw(DimensionMismatch("A has dimensions $(size(A)) but B has dimensions $(size(B))"))
+                throw(DimensionMismatch(lazy"A has dimensions $(size(A)) but B has dimensions $(size(B))"))
             end
 
             dotprod = $real(zero(dot(first(A), first(B))))
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 97ae07e12e979..9be82f8dab29a 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -272,7 +272,7 @@ Base.isstored(A::UpperTriangular, i::Int, j::Int) =
 @propagate_inbounds function setindex!(A::UpperTriangular, x, i::Integer, j::Integer)
     if i > j
         iszero(x) || throw(ArgumentError("cannot set index in the lower triangular part " *
-            "($i, $j) of an UpperTriangular matrix to a nonzero value ($x)"))
+            lazy"($i, $j) of an UpperTriangular matrix to a nonzero value ($x)"))
     else
         A.data[i,j] = x
     end
@@ -282,10 +282,10 @@ end
 @propagate_inbounds function setindex!(A::UnitUpperTriangular, x, i::Integer, j::Integer)
     if i > j
         iszero(x) || throw(ArgumentError("cannot set index in the lower triangular part " *
-            "($i, $j) of a UnitUpperTriangular matrix to a nonzero value ($x)"))
+            lazy"($i, $j) of a UnitUpperTriangular matrix to a nonzero value ($x)"))
     elseif i == j
-        x == oneunit(x) || throw(ArgumentError("cannot set index on the diagonal ($i, $j) " *
-            "of a UnitUpperTriangular matrix to a non-unit value ($x)"))
+        x == oneunit(x) || throw(ArgumentError(lazy"cannot set index on the diagonal ($i, $j) " *
+            lazy"of a UnitUpperTriangular matrix to a non-unit value ($x)"))
     else
         A.data[i,j] = x
     end
@@ -295,7 +295,7 @@ end
 @propagate_inbounds function setindex!(A::LowerTriangular, x, i::Integer, j::Integer)
     if i < j
         iszero(x) || throw(ArgumentError("cannot set index in the upper triangular part " *
-            "($i, $j) of a LowerTriangular matrix to a nonzero value ($x)"))
+            lazy"($i, $j) of a LowerTriangular matrix to a nonzero value ($x)"))
     else
         A.data[i,j] = x
     end
@@ -305,10 +305,10 @@ end
 @propagate_inbounds function setindex!(A::UnitLowerTriangular, x, i::Integer, j::Integer)
     if i < j
         iszero(x) || throw(ArgumentError("cannot set index in the upper triangular part " *
-            "($i, $j) of a UnitLowerTriangular matrix to a nonzero value ($x)"))
+            lazy"($i, $j) of a UnitLowerTriangular matrix to a nonzero value ($x)"))
     elseif i == j
-        x == oneunit(x) || throw(ArgumentError("cannot set index on the diagonal ($i, $j) " *
-            "of a UnitLowerTriangular matrix to a non-unit value ($x)"))
+        x == oneunit(x) || throw(ArgumentError(lazy"cannot set index on the diagonal ($i, $j) " *
+            lazy"of a UnitLowerTriangular matrix to a non-unit value ($x)"))
     else
         A.data[i,j] = x
     end
@@ -317,7 +317,7 @@ end
 
 @inline function fill!(A::UpperTriangular, x)
     iszero(x) || throw(ArgumentError("cannot set indices in the lower triangular part " *
-            "of an UpperTriangular matrix to a nonzero value ($x)"))
+            lazy"of an UpperTriangular matrix to a nonzero value ($x)"))
     for col in axes(A,2), row in firstindex(A,1):col
         @inbounds A.data[row, col] = x
     end
@@ -325,7 +325,7 @@ end
 end
 @inline function fill!(A::LowerTriangular, x)
     iszero(x) || throw(ArgumentError("cannot set indices in the upper triangular part " *
-            "of a LowerTriangular matrix to a nonzero value ($x)"))
+            lazy"of a LowerTriangular matrix to a nonzero value ($x)"))
     for col in axes(A,2), row in col:lastindex(A,1)
         @inbounds A.data[row, col] = x
     end
@@ -540,7 +540,7 @@ end
 
 function checksize1(A, B)
     szA, szB = size(A), size(B)
-    szA == szB || throw(DimensionMismatch("size of A, $szA, does not match size of B, $szB"))
+    szA == szB || throw(DimensionMismatch(lazy"size of A, $szA, does not match size of B, $szB"))
     checksquare(B)
 end
 
@@ -1003,11 +1003,11 @@ function generic_trimatmul!(C::AbstractVecOrMat, uploc, isunitc, tfun::Function,
     m, n = size(B, 1), size(B, 2)
     N = size(A, 1)
     if m != N
-        throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m"))
+        throw(DimensionMismatch(lazy"right hand side B needs first dimension of size $(size(A,1)), has size $m"))
     end
     mc, nc = size(C, 1), size(C, 2)
     if mc != N || nc != n
-        throw(DimensionMismatch("output has dimensions ($mc,$nc), should have ($N,$n)"))
+        throw(DimensionMismatch(lazy"output has dimensions ($mc,$nc), should have ($N,$n)"))
     end
     oA = oneunit(eltype(A))
     unit = isunitc == 'U'
@@ -1065,11 +1065,11 @@ function generic_trimatmul!(C::AbstractVecOrMat, uploc, isunitc, ::Function, xA:
     m, n = size(B, 1), size(B, 2)
     N = size(A, 1)
     if m != N
-        throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m"))
+        throw(DimensionMismatch(lazy"right hand side B needs first dimension of size $(size(A,1)), has size $m"))
     end
     mc, nc = size(C, 1), size(C, 2)
     if mc != N || nc != n
-        throw(DimensionMismatch("output has dimensions ($mc,$nc), should have ($N,$n)"))
+        throw(DimensionMismatch(lazy"output has dimensions ($mc,$nc), should have ($N,$n)"))
     end
     oA = oneunit(eltype(A))
     unit = isunitc == 'U'
@@ -1102,11 +1102,11 @@ function generic_mattrimul!(C::AbstractMatrix, uploc, isunitc, tfun::Function, A
     m, n = size(A, 1), size(A, 2)
     N = size(B, 1)
     if n != N
-        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $N"))
+        throw(DimensionMismatch(lazy"right hand side B needs first dimension of size $n, has size $N"))
     end
     mc, nc = size(C, 1), size(C, 2)
     if mc != m || nc != N
-        throw(DimensionMismatch("output has dimensions ($mc,$nc), should have ($m,$N)"))
+        throw(DimensionMismatch(lazy"output has dimensions ($mc,$nc), should have ($m,$N)"))
     end
     oB = oneunit(eltype(B))
     unit = isunitc == 'U'
@@ -1164,11 +1164,11 @@ function generic_mattrimul!(C::AbstractMatrix, uploc, isunitc, ::Function, A::Ab
     m, n = size(A, 1), size(A, 2)
     N = size(B, 1)
     if n != N
-        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $N"))
+        throw(DimensionMismatch(lazy"right hand side B needs first dimension of size $n, has size $N"))
     end
     mc, nc = size(C, 1), size(C, 2)
     if mc != m || nc != N
-        throw(DimensionMismatch("output has dimensions ($mc,$nc), should have ($m,$N)"))
+        throw(DimensionMismatch(lazy"output has dimensions ($mc,$nc), should have ($m,$N)"))
     end
     oB = oneunit(eltype(B))
     unit = isunitc == 'U'
@@ -1212,10 +1212,10 @@ function generic_trimatdiv!(C::AbstractVecOrMat, uploc, isunitc, tfun::Function,
     mA, nA = size(A)
     m, n = size(B, 1), size(B,2)
     if nA != m
-        throw(DimensionMismatch("second dimension of left hand side A, $nA, and first dimension of right hand side B, $m, must be equal"))
+        throw(DimensionMismatch(lazy"second dimension of left hand side A, $nA, and first dimension of right hand side B, $m, must be equal"))
     end
     if size(C) != size(B)
-        throw(DimensionMismatch("size of output, $(size(C)), does not match size of right hand side, $(size(B))"))
+        throw(DimensionMismatch(lazy"size of output, $(size(C)), does not match size of right hand side, $(size(B))"))
     end
     oA = oneunit(eltype(A))
     @inbounds if uploc == 'U'
@@ -1348,10 +1348,10 @@ function generic_trimatdiv!(C::AbstractVecOrMat, uploc, isunitc, ::Function, xA:
     mA, nA = size(A)
     m, n = size(B, 1), size(B,2)
     if nA != m
-        throw(DimensionMismatch("second dimension of left hand side A, $nA, and first dimension of right hand side B, $m, must be equal"))
+        throw(DimensionMismatch(lazy"second dimension of left hand side A, $nA, and first dimension of right hand side B, $m, must be equal"))
     end
     if size(C) != size(B)
-        throw(DimensionMismatch("size of output, $(size(C)), does not match size of right hand side, $(size(B))"))
+        throw(DimensionMismatch(lazy"size of output, $(size(C)), does not match size of right hand side, $(size(B))"))
     end
     oA = oneunit(eltype(A))
     @inbounds if uploc == 'U'
@@ -1430,10 +1430,10 @@ function generic_mattridiv!(C::AbstractMatrix, uploc, isunitc, tfun::Function, A
     require_one_based_indexing(C, A, B)
     m, n = size(A)
     if size(B, 1) != n
-        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+        throw(DimensionMismatch(lazy"right hand side B needs first dimension of size $n, has size $(size(B,1))"))
     end
     if size(C) != size(A)
-        throw(DimensionMismatch("size of output, $(size(C)), does not match size of left hand side, $(size(A))"))
+        throw(DimensionMismatch(lazy"size of output, $(size(C)), does not match size of left hand side, $(size(A))"))
     end
     oB = oneunit(eltype(B))
     unit = isunitc == 'U'
@@ -1493,10 +1493,10 @@ function generic_mattridiv!(C::AbstractMatrix, uploc, isunitc, ::Function, A::Ab
     require_one_based_indexing(C, A, B)
     m, n = size(A)
     if size(B, 1) != n
-        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+        throw(DimensionMismatch(lazy"right hand side B needs first dimension of size $n, has size $(size(B,1))"))
     end
     if size(C) != size(A)
-        throw(DimensionMismatch("size of output, $(size(C)), does not match size of left hand side, $(size(A))"))
+        throw(DimensionMismatch(lazy"size of output, $(size(C)), does not match size of left hand side, $(size(A))"))
     end
     oB = oneunit(eltype(B))
     unit = isunitc == 'U'
@@ -1618,7 +1618,7 @@ end
 #     34(3), (2013) 1341–1360.
 function powm!(A0::UpperTriangular, p::Real)
     if abs(p) >= 1
-        throw(ArgumentError("p must be a real number in (-1,1), got $p"))
+        throw(ArgumentError(lazy"p must be a real number in (-1,1), got $p"))
     end
 
     normA0 = opnorm(A0, 1)
@@ -2548,7 +2548,7 @@ function eigvecs(A::AbstractTriangular{T}) where T
     if TT <: BlasFloat
         return eigvecs(convert(AbstractMatrix{TT}, A))
     else
-        throw(ArgumentError("eigvecs type $(typeof(A)) not supported. Please submit a pull request."))
+        throw(ArgumentError(lazy"eigvecs type $(typeof(A)) not supported. Please submit a pull request."))
     end
 end
 det(A::UnitUpperTriangular{T}) where {T} = one(T)
diff --git a/stdlib/LinearAlgebra/src/tridiag.jl b/stdlib/LinearAlgebra/src/tridiag.jl
index 90142dd941f28..431e349d42da2 100644
--- a/stdlib/LinearAlgebra/src/tridiag.jl
+++ b/stdlib/LinearAlgebra/src/tridiag.jl
@@ -9,7 +9,7 @@ struct SymTridiagonal{T, V<:AbstractVector{T}} <: AbstractMatrix{T}
     function SymTridiagonal{T, V}(dv, ev) where {T, V<:AbstractVector{T}}
         require_one_based_indexing(dv, ev)
         if !(length(dv) - 1 <= length(ev) <= length(dv))
-            throw(DimensionMismatch("subdiagonal has wrong length. Has length $(length(ev)), but should be either $(length(dv) - 1) or $(length(dv))."))
+            throw(DimensionMismatch(lazy"subdiagonal has wrong length. Has length $(length(ev)), but should be either $(length(dv) - 1) or $(length(dv))."))
         end
         new{T, V}(dv, ev)
     end
@@ -191,8 +191,8 @@ function diag(M::SymTridiagonal{T}, n::Integer=0) where T<:Number
     elseif absn <= size(M,1)
         return fill!(similar(M.dv, size(M,1)-absn), zero(T))
     else
-        throw(ArgumentError(string("requested diagonal, $n, must be at least $(-size(M, 1)) ",
-            "and at most $(size(M, 2)) for an $(size(M, 1))-by-$(size(M, 2)) matrix")))
+        throw(ArgumentError(string(lazy"requested diagonal, $n, must be at least $(-size(M, 1)) ",
+            lazy"and at most $(size(M, 2)) for an $(size(M, 1))-by-$(size(M, 2)) matrix")))
     end
 end
 function diag(M::SymTridiagonal, n::Integer=0)
@@ -207,8 +207,8 @@ function diag(M::SymTridiagonal, n::Integer=0)
     elseif n <= size(M,1)
         throw(ArgumentError("requested diagonal contains undefined zeros of an array type"))
     else
-        throw(ArgumentError(string("requested diagonal, $n, must be at least $(-size(M, 1)) ",
-            "and at most $(size(M, 2)) for an $(size(M, 1))-by-$(size(M, 2)) matrix")))
+        throw(ArgumentError(string(lazy"requested diagonal, $n, must be at least $(-size(M, 1)) ",
+            lazy"and at most $(size(M, 2)) for an $(size(M, 1))-by-$(size(M, 2)) matrix")))
     end
 end
 
@@ -350,8 +350,8 @@ isdiag(M::SymTridiagonal) =  iszero(_evview(M))
 function tril!(M::SymTridiagonal{T}, k::Integer=0) where T
     n = length(M.dv)
     if !(-n - 1 <= k <= n - 1)
-        throw(ArgumentError(string("the requested diagonal, $k, must be at least ",
-            "$(-n - 1) and at most $(n - 1) in an $n-by-$n matrix")))
+        throw(ArgumentError(string(lazy"the requested diagonal, $k, must be at least ",
+            lazy"$(-n - 1) and at most $(n - 1) in an $n-by-$n matrix")))
     elseif k < -1
         fill!(M.ev, zero(T))
         fill!(M.dv, zero(T))
@@ -369,8 +369,8 @@ end
 function triu!(M::SymTridiagonal{T}, k::Integer=0) where T
     n = length(M.dv)
     if !(-n + 1 <= k <= n + 1)
-        throw(ArgumentError(string("the requested diagonal, $k, must be at least ",
-            "$(-n + 1) and at most $(n + 1) in an $n-by-$n matrix")))
+        throw(ArgumentError(string(lazy"the requested diagonal, $k, must be at least ",
+            lazy"$(-n + 1) and at most $(n + 1) in an $n-by-$n matrix")))
     elseif k > 1
         fill!(M.ev, zero(T))
         fill!(M.dv, zero(T))
@@ -463,7 +463,7 @@ end
     if i == j
         @inbounds A.dv[i] = x
     else
-        throw(ArgumentError("cannot set off-diagonal entry ($i, $j)"))
+        throw(ArgumentError(lazy"cannot set off-diagonal entry ($i, $j)"))
     end
     return x
 end
@@ -480,7 +480,7 @@ struct Tridiagonal{T,V<:AbstractVector{T}} <: AbstractMatrix{T}
         if (length(dl) != n-1 || length(du) != n-1) && !(length(d) == 0 && length(dl) == 0 && length(du) == 0)
             throw(ArgumentError(string("cannot construct Tridiagonal from incompatible ",
                 "lengths of subdiagonal, diagonal and superdiagonal: ",
-                "($(length(dl)), $(length(d)), $(length(du)))")))
+                lazy"($(length(dl)), $(length(d)), $(length(du)))")))
         end
         new{T,V}(dl, d, Base.unalias(dl, du))
     end
@@ -645,8 +645,8 @@ function diag(M::Tridiagonal{T}, n::Integer=0) where T
     elseif abs(n) <= size(M,1)
         return fill!(similar(M.d, size(M,1)-abs(n)), zero(T))
     else
-        throw(ArgumentError(string("requested diagonal, $n, must be at least $(-size(M, 1)) ",
-            "and at most $(size(M, 2)) for an $(size(M, 1))-by-$(size(M, 2)) matrix")))
+        throw(ArgumentError(string(lazy"requested diagonal, $n, must be at least $(-size(M, 1)) ",
+            lazy"and at most $(size(M, 2)) for an $(size(M, 1))-by-$(size(M, 2)) matrix")))
     end
 end
 
@@ -698,8 +698,8 @@ end
     elseif j - i == 1
         @inbounds A.du[i] = x
     elseif !iszero(x)
-        throw(ArgumentError(string("cannot set entry ($i, $j) off ",
-            "the tridiagonal band to a nonzero value ($x)")))
+        throw(ArgumentError(string(lazy"cannot set entry ($i, $j) off ",
+            lazy"the tridiagonal band to a nonzero value ($x)")))
     end
     return x
 end
@@ -741,8 +741,8 @@ isdiag(M::Tridiagonal) = iszero(M.dl) && iszero(M.du)
 function tril!(M::Tridiagonal{T}, k::Integer=0) where T
     n = length(M.d)
     if !(-n - 1 <= k <= n - 1)
-        throw(ArgumentError(string("the requested diagonal, $k, must be at least ",
-            "$(-n - 1) and at most $(n - 1) in an $n-by-$n matrix")))
+        throw(ArgumentError(string(lazy"the requested diagonal, $k, must be at least ",
+            lazy"$(-n - 1) and at most $(n - 1) in an $n-by-$n matrix")))
     elseif k < -1
         fill!(M.dl, zero(T))
         fill!(M.d, zero(T))
@@ -759,8 +759,8 @@ end
 function triu!(M::Tridiagonal{T}, k::Integer=0) where T
     n = length(M.d)
     if !(-n + 1 <= k <= n + 1)
-        throw(ArgumentError(string("the requested diagonal, $k, must be at least ",
-            "$(-n + 1) and at most $(n + 1) in an $n-by-$n matrix")))
+        throw(ArgumentError(string(lazy"the requested diagonal, $k, must be at least ",
+            lazy"$(-n + 1) and at most $(n + 1) in an $n-by-$n matrix")))
     elseif k > 1
         fill!(M.dl, zero(T))
         fill!(M.d, zero(T))
@@ -928,7 +928,7 @@ function ldiv!(A::Tridiagonal, B::AbstractVecOrMat)
     LinearAlgebra.require_one_based_indexing(B)
     n = size(A, 1)
     if n != size(B,1)
-        throw(DimensionMismatch("matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
+        throw(DimensionMismatch(lazy"matrix has dimensions ($n,$n) but right hand side has $(size(B,1)) rows"))
     end
     nrhs = size(B, 2)
 

From 97ac3ecc707888bd1c9344ed8386aea40d14c346 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Tue, 9 Apr 2024 11:44:50 -0500
Subject: [PATCH 1250/1315] make `view(::Memory, ::Colon)` produce a Vector
 (#54005)

---
 base/genericmemory.jl | 1 +
 test/arrayops.jl      | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/base/genericmemory.jl b/base/genericmemory.jl
index 3463be456ea59..c1dc215a68d33 100644
--- a/base/genericmemory.jl
+++ b/base/genericmemory.jl
@@ -312,3 +312,4 @@ end
         $(Expr(:new, :(Array{T, 1}), :ref, :dims))
     end
 end
+view(m::GenericMemory, inds::Colon) = view(m, eachindex(m))
diff --git a/test/arrayops.jl b/test/arrayops.jl
index a31d373a65a38..1c36453a6adae 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -3203,6 +3203,7 @@ end
     @test @inferred(view(mem, 3:8))::Vector{Int} == 13:18
     @test @inferred(view(mem, 20:19))::Vector{Int} == []
     @test @inferred(view(mem, -5:-7))::Vector{Int} == []
+    @test @inferred(view(mem, :))::Vector{Int} == mem
     @test @inferred(reshape(mem, 5, 2))::Matrix{Int} == reshape(11:20, 5, 2)
 
     # 53990
@@ -3217,6 +3218,7 @@ end
 
     @test @inferred(view(empty_mem, 1:0))::Vector{Module} == []
     @test @inferred(view(empty_mem, 10:3))::Vector{Module} == []
+    @test @inferred(view(empty_mem, :))::Vector{Module} == empty_mem
     @test isempty(@inferred(reshape(empty_mem, 0, 7, 1))::Array{Module, 3})
 
     offset_inds = OffsetArrays.IdOffsetRange(values=3:6, indices=53:56)

From f870ea0a1ef2351afb5ec025223172f9936e9a21 Mon Sep 17 00:00:00 2001
From: Mike Boyle <moble@users.noreply.github.com>
Date: Tue, 9 Apr 2024 16:09:41 -0400
Subject: [PATCH 1251/1315] Correct return types in docstrings of sincos*
 (#54006)

Just a tiny correction to the return types noted in the docstrings, and
include a phrase in `sincosd` that's present in the other two.
---
 base/special/trig.jl | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/base/special/trig.jl b/base/special/trig.jl
index 15ecb0ca0492f..66e4b46d7d489 100644
--- a/base/special/trig.jl
+++ b/base/special/trig.jl
@@ -165,7 +165,7 @@ end
 @noinline sincos_domain_error(x) = throw(DomainError(x, "sincos(x) is only defined for finite x."))
 
 """
-    sincos(x::T) where T -> float(T)
+    sincos(x::T) where T -> Tuple{float(T),float(T)}
 
 Simultaneously compute the sine and cosine of `x`, where `x` is in radians, returning
 a tuple `(sine, cosine)`.
@@ -850,7 +850,7 @@ function cospi(x::T) where T<:IEEEFloat
     end
 end
 """
-    sincospi(x::T) where T -> float(T)
+    sincospi(x::T) where T -> Tuple{float(T),float(T)}
 
 Simultaneously compute [`sinpi(x)`](@ref) and [`cospi(x)`](@ref) (the sine and cosine of `π*x`,
 where `x` is in radians), returning a tuple `(sine, cosine)`.
@@ -1266,9 +1266,10 @@ end
 tand(x::Real) = sind(x) / cosd(x)
 
 """
-    sincosd(x::T) where T -> float(T)
+    sincosd(x::T) where T -> Tuple{float(T),float(T)}
 
-Simultaneously compute the sine and cosine of `x`, where `x` is in degrees.
+Simultaneously compute the sine and cosine of `x`, where `x` is in degrees, returning
+a tuple `(sine, cosine)`.
 
 Throw a [`DomainError`](@ref) if `isinf(x)`, return a `(T(NaN), T(NaN))` tuple if `isnan(x)`.
 

From d183ee1bc0f65312bbc9406af7dafd0333aa5aa6 Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Tue, 9 Apr 2024 23:06:49 +0200
Subject: [PATCH 1252/1315] Improve performance of `ncodeunits(::Char)`
 (#54001)

This improves performance of `ncodeunits(::Char)` by simply counting the
number of non-zero bytes (except for `\0`, which is encoded as all zero
bytes). For a performance comparison, see [this gist](
https://gist.github.com/Seelengrab/ebb02d4b8d754700c2869de8daf88cad);
there's an up to 10x improvement here for collections of `Char`, with a
minor improvement for single `Char` (with much smaller spread). The
version in this PR is called `nbytesencoded` in the benchmarks.

Correctness has been verified with Supposition.jl, using the existing
implementation as an oracle:

```julia
julia> using Supposition

julia> const chars = Data.Characters()

julia> @check max_examples=1_000_000 function bytesenc(i=Data.Integers{UInt32}())
           c = reinterpret(Char, i)
           ncodeunits(c) == nbytesdiv(c)
       end;
Test Summary: | Pass  Total  Time
bytesenc      |    1      1  1.0s

julia> ncodeunits('\0') == nbytesencoded('\0')
true
```

Let's see if CI agrees!

Notably, neither the existing nor the new implementation check whether
the given `Char` is valid or not, since the only thing that matters is
how many bytes are written out.

---------

Co-authored-by: Sukera <Seelengrab@users.noreply.github.com>
---
 base/char.jl | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/base/char.jl b/base/char.jl
index 08d661c41de56..bc68a672ce0ca 100644
--- a/base/char.jl
+++ b/base/char.jl
@@ -62,7 +62,14 @@ to an output stream, or `ncodeunits(string(c))` but computed efficiently.
     This method requires at least Julia 1.1. In Julia 1.0 consider
     using `ncodeunits(string(c))`.
 """
-ncodeunits(c::Char) = write(devnull, c) # this is surprisingly efficient
+function ncodeunits(c::Char)
+    u = reinterpret(UInt32, c)
+    # We care about how many trailing bytes are all zero
+    # subtract that from the total number of bytes
+    n_nonzero_bytes = sizeof(UInt32) - div(trailing_zeros(u), 0x8)
+    # Take care of '\0', which has an all-zero bitpattern
+    n_nonzero_bytes + iszero(u)
+end
 
 """
     codepoint(c::AbstractChar) -> Integer

From e9a24d4cee4153023a7841a75fc4285229f26720 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Wed, 10 Apr 2024 09:11:43 -0400
Subject: [PATCH 1253/1315] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the?=
 =?UTF-8?q?=20Pkg=20stdlib=20from=20162634c56=20to=208f772ffa7=20(#54018)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: master
Julia branch: master
Old commit: 162634c56
New commit: 8f772ffa7
Julia version: 1.12.0-DEV
Pkg version: 1.12.0
Bump invoked by: @KristofferC
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/Pkg.jl/compare/162634c5615d12b889e4b64f3cff95d1c377f189...8f772ffa72d86c81f03cddce2e779d6b330414e3

```
$ git log --oneline 162634c56..8f772ffa7
8f772ffa7 prune manifest after the set of some deps have been "demoted" to weakdeps (#3864)
88c38b2cd make `add` and `dev` on a package remove it from the set of weak dependencies (#3865)
9210a1da5 fix how entry point to package is computed with `path` provided in project file (#3850)
77620a945 extensions: fixup entire manifest (#3720)
8cc835c7d Report failures to download artifacts as failures (#3860)
2f318cf66 remove unused PkgPrecompileError type (#3858)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
---
 .../Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5     | 1 -
 .../Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512  | 1 -
 .../Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/md5     | 1 +
 .../Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/sha512

diff --git a/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5 b/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5
deleted file mode 100644
index c27b9894015ce..0000000000000
--- a/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-4bd123b9499b46a859d5bba5ae2228a5
diff --git a/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512 b/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512
deleted file mode 100644
index d4c2d6b185137..0000000000000
--- a/deps/checksums/Pkg-162634c5615d12b889e4b64f3cff95d1c377f189.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-5f743255cee291185094bfa86e48f65160bc1ad170f052644b79d90d2f1d3c6c3e2be3c4da25925f3ec4b3f87179f946252cdab199ca510b78064afb0b0df039
diff --git a/deps/checksums/Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/md5 b/deps/checksums/Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/md5
new file mode 100644
index 0000000000000..89baf14afbcc2
--- /dev/null
+++ b/deps/checksums/Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/md5
@@ -0,0 +1 @@
+b1b74c19867026be19c77c3ab94b11e4
diff --git a/deps/checksums/Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/sha512 b/deps/checksums/Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/sha512
new file mode 100644
index 0000000000000..cb6d2098d0f10
--- /dev/null
+++ b/deps/checksums/Pkg-8f772ffa72d86c81f03cddce2e779d6b330414e3.tar.gz/sha512
@@ -0,0 +1 @@
+c1834ec2c41c201224d58928053d94fdb1972dbafa59b5d80bc43ac60f22eeb4287d57d519fe7d0e9f69c430e39e7eafc26aa0c2994ea417cab32725301cb39d
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 0fcf00277a6f8..499b6b9174c44 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,4 +1,4 @@
 PKG_BRANCH = master
-PKG_SHA1 = 162634c5615d12b889e4b64f3cff95d1c377f189
+PKG_SHA1 = 8f772ffa72d86c81f03cddce2e779d6b330414e3
 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git
 PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1

From f46cb4c67cd2ce7f88da778f5c0355c1100b5ccd Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Wed, 10 Apr 2024 20:08:10 +0200
Subject: [PATCH 1254/1315] allow extensions to trigger from packages in [deps]
 (#54009)

There is a use case where you have a weak dependency (for one of your
extensions) that is misbehaving and you quickly want to try debug that
issue. A workflow that feels reasonable for this could be:

```
pkg> dev WeakDependency

# do some fixes in this dependency

julia> using Package, WeakDependency
# this loads the extension of Package triggered by loading WeakDependency

# check that things work ok now
```

This doesn't work right now for two reasons:

1. Doing the `dev WeakDependency` will add the dependency to `[deps]`
but not remove it from `[weakdeps]` which means you all of a sudden are
in the scenario described in
https://pkgdocs.julialang.org/v1/creating-packages/#Transition-from-normal-dependency-to-extension
which is not what is desired.
2. The extension will not actually load because you can right now only
trigger extensions from weak deps getting loaded, not from deps getting
loaded.

Point 1. is fixed by https://github.com/JuliaLang/Pkg.jl/pull/3865
Point 2. is fixed by this PR.
---
 base/loading.jl                               | 53 +++++++++++--------
 base/precompilation.jl                        |  2 +-
 doc/src/manual/code-loading.md                | 12 ++---
 test/loading.jl                               |  6 ++-
 .../EnvWithHasExtensions/Manifest.toml        |  6 ++-
 .../Extensions/ExtDep3.jl/Project.toml        |  4 ++
 .../Extensions/ExtDep3.jl/src/ExtDep3.jl      |  5 ++
 .../HasDepWithExtensions.jl/Manifest.toml     | 11 +++-
 .../HasDepWithExtensions.jl/Project.toml      |  1 +
 .../Extensions/HasExtensions.jl/Manifest.toml |  9 ++--
 .../Extensions/HasExtensions.jl/Project.toml  |  4 ++
 .../HasExtensions.jl/ext/ExtensionDep.jl      |  9 ++++
 .../HasExtensions.jl/src/HasExtensions.jl     |  1 +
 13 files changed, 85 insertions(+), 38 deletions(-)
 create mode 100644 test/project/Extensions/ExtDep3.jl/Project.toml
 create mode 100644 test/project/Extensions/ExtDep3.jl/src/ExtDep3.jl
 create mode 100644 test/project/Extensions/HasExtensions.jl/ext/ExtensionDep.jl

diff --git a/base/loading.jl b/base/loading.jl
index d49c8aa91e3b7..ee6c47c7ce155 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1388,13 +1388,12 @@ function insert_extension_triggers(env::String, pkg::PkgId)::Union{Nothing,Missi
         proj_pkg = project_file_name_uuid(implicit_project_file, pkg.name)
         if pkg == proj_pkg
             d_proj = parsed_toml(implicit_project_file)
-            weakdeps = get(d_proj, "weakdeps", nothing)::Union{Nothing, Vector{String}, Dict{String,Any}}
             extensions = get(d_proj, "extensions", nothing)::Union{Nothing, Dict{String, Any}}
             extensions === nothing && return
-            weakdeps === nothing && return
-            if weakdeps isa Dict{String, Any}
-                return _insert_extension_triggers(pkg, extensions, weakdeps)
-            end
+            weakdeps = get(Dict{String, Any}, d_proj, "weakdeps")::Dict{String,Any}
+            deps = get(Dict{String, Any}, d_proj, "deps")::Dict{String,Any}
+            total_deps = merge(weakdeps, deps)
+            return _insert_extension_triggers(pkg, extensions, total_deps)
         end
 
         # Now look in manifest
@@ -1409,27 +1408,35 @@ function insert_extension_triggers(env::String, pkg::PkgId)::Union{Nothing,Missi
                 uuid = get(entry, "uuid", nothing)::Union{String, Nothing}
                 uuid === nothing && continue
                 if UUID(uuid) == pkg.uuid
-                    weakdeps = get(entry, "weakdeps", nothing)::Union{Nothing, Vector{String}, Dict{String,Any}}
                     extensions = get(entry, "extensions", nothing)::Union{Nothing, Dict{String, Any}}
                     extensions === nothing && return
-                    weakdeps === nothing && return
-                    if weakdeps isa Dict{String, Any}
-                        return _insert_extension_triggers(pkg, extensions, weakdeps)
+                    weakdeps = get(Dict{String, Any}, entry, "weakdeps")::Union{Vector{String}, Dict{String,Any}}
+                    deps = get(Dict{String, Any}, entry, "deps")::Union{Vector{String}, Dict{String,Any}}
+
+                    function expand_deps_list(deps′::Vector{String})
+                        deps′_expanded = Dict{String, Any}()
+                        for (dep_name, entries) in d
+                            dep_name in deps′ || continue
+                            entries::Vector{Any}
+                            if length(entries) != 1
+                                error("expected a single entry for $(repr(dep_name)) in $(repr(project_file))")
+                            end
+                            entry = first(entries)::Dict{String, Any}
+                            uuid = entry["uuid"]::String
+                            deps′_expanded[dep_name] = uuid
+                        end
+                        return deps′_expanded
                     end
 
-                    d_weakdeps = Dict{String, Any}()
-                    for (dep_name, entries) in d
-                        dep_name in weakdeps || continue
-                        entries::Vector{Any}
-                        if length(entries) != 1
-                            error("expected a single entry for $(repr(dep_name)) in $(repr(project_file))")
-                        end
-                        entry = first(entries)::Dict{String, Any}
-                        uuid = entry["uuid"]::String
-                        d_weakdeps[dep_name] = uuid
+                    if weakdeps isa Vector{String}
+                        weakdeps = expand_deps_list(weakdeps)
+                    end
+                    if deps isa Vector{String}
+                        deps = expand_deps_list(deps)
                     end
-                    @assert length(d_weakdeps) == length(weakdeps)
-                    return _insert_extension_triggers(pkg, extensions, d_weakdeps)
+
+                    total_deps = merge(weakdeps, deps)
+                    return _insert_extension_triggers(pkg, extensions, total_deps)
                 end
             end
         end
@@ -1437,7 +1444,7 @@ function insert_extension_triggers(env::String, pkg::PkgId)::Union{Nothing,Missi
     return nothing
 end
 
-function _insert_extension_triggers(parent::PkgId, extensions::Dict{String, Any}, weakdeps::Dict{String, Any})
+function _insert_extension_triggers(parent::PkgId, extensions::Dict{String, Any}, totaldeps::Dict{String, Any})
     for (ext, triggers) in extensions
         triggers = triggers::Union{String, Vector{String}}
         triggers isa String && (triggers = [triggers])
@@ -1451,7 +1458,7 @@ function _insert_extension_triggers(parent::PkgId, extensions::Dict{String, Any}
         push!(trigger1, gid)
         for trigger in triggers
             # TODO: Better error message if this lookup fails?
-            uuid_trigger = UUID(weakdeps[trigger]::String)
+            uuid_trigger = UUID(totaldeps[trigger]::String)
             trigger_id = PkgId(uuid_trigger, trigger)
             if !haskey(explicit_loaded_modules, trigger_id) || haskey(package_locks, trigger_id)
                 trigger1 = get!(Vector{ExtensionId}, EXT_DORMITORY, trigger_id)
diff --git a/base/precompilation.jl b/base/precompilation.jl
index 8185fe8e8230b..9acbd2a11f202 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -409,7 +409,7 @@ function precompilepkgs(pkgs::Vector{String}=String[];
             all_extdeps_available = true
             for extdep_uuid in extdep_uuids
                 extdep_name = env.names[extdep_uuid]
-                if extdep_uuid in keys(env.deps) || Base.in_sysimage(Base.PkgId(extdep_uuid, extdep_name))
+                if extdep_uuid in keys(env.deps)
                     push!(ext_deps, Base.PkgId(extdep_uuid, extdep_name))
                 else
                     all_extdeps_available = false
diff --git a/doc/src/manual/code-loading.md b/doc/src/manual/code-loading.md
index 35d88ed13bc89..5c8315693c71e 100644
--- a/doc/src/manual/code-loading.md
+++ b/doc/src/manual/code-loading.md
@@ -351,7 +351,7 @@ Since the primary environment is typically the environment of a project you're w
 
 ### [Package Extensions](@id man-extensions)
 
-A package "extension" is a module that is automatically loaded when a specified set of other packages (its "extension dependencies") are loaded in the current Julia session. Extensions are defined under the `[extensions]` section in the project file. The extension dependencies of an extension are a subset of those packages listed under the `[weakdeps]` section of the project file. Those packages can have compat entries like other packages.
+A package "extension" is a module that is automatically loaded when a specified set of other packages (its "triggers") are loaded in the current Julia session. Extensions are defined under the `[extensions]` section in the project file. The triggers of an extension are a subset of those packages listed under the `[weakdeps]` (and possibly, but uncommonly the `[deps]`) section of the project file. Those packages can have compat entries like other packages.
 
 ```toml
 name = "MyPackage"
@@ -371,8 +371,8 @@ FooExt = "ExtDep"
 ```
 
 The keys under `extensions` are the names of the extensions.
-They are loaded when all the packages on the right hand side (the extension dependencies) of that extension are loaded.
-If an extension only has one extension dependency the list of extension dependencies can be written as just a string for brevity.
+They are loaded when all the packages on the right hand side (the triggers) of that extension are loaded.
+If an extension only has one trigger the list of triggers can be written as just a string for brevity.
 The location for the entry point of the extension is either in `ext/FooExt.jl` or `ext/FooExt/FooExt.jl` for
 extension `FooExt`.
 The content of an extension is often structured as:
@@ -380,10 +380,10 @@ The content of an extension is often structured as:
 ```
 module FooExt
 
-# Load main package and extension dependencies
+# Load main package and triggers
 using MyPackage, ExtDep
 
-# Extend functionality in main package with types from the extension dependencies
+# Extend functionality in main package with types from the triggers
 MyPackage.func(x::ExtDep.SomeStruct) = ...
 
 end
@@ -391,7 +391,7 @@ end
 
 When a package with extensions is added to an environment, the `weakdeps` and `extensions` sections
 are stored in the manifest file in the section for that package. The dependency lookup rules for
-a package are the same as for its "parent" except that the listed extension dependencies are also considered as
+a package are the same as for its "parent" except that the listed triggers are also considered as
 dependencies.
 
 ### [Workspaces](@id workspaces)
diff --git a/test/loading.jl b/test/loading.jl
index 182db7c4a6d15..4cd0cb7dac823 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -1057,7 +1057,9 @@ end
                 $ew HasDepWithExtensions.do_something() || error("do_something errored")
                 using ExtDep2
                 $ew using ExtDep2
-                $ew HasExtensions.ext_folder_loaded || error("ext_folder_loaded not set")
+                using ExtDep3
+                $ew using ExtDep3
+                $ew HasExtensions.ext_dep_loaded || error("ext_dep_loaded not set")
             end
             """
             return `$(Base.julia_cmd()) $compile --startup-file=no -e $cmd`
@@ -1105,6 +1107,8 @@ end
             Base.get_extension(HasExtensions, :Extension) isa Module || error("expected extension to load")
             using ExtDep2
             Base.get_extension(HasExtensions, :ExtensionFolder) isa Module || error("expected extension to load")
+            using ExtDep3
+            Base.get_extension(HasExtensions, :ExtensionDep) isa Module || error("expected extension to load")
         end
         """
         for compile in (`--compiled-modules=no`, ``)
diff --git a/test/project/Extensions/EnvWithHasExtensions/Manifest.toml b/test/project/Extensions/EnvWithHasExtensions/Manifest.toml
index 8ac961fa1a9a9..004ef7892c173 100644
--- a/test/project/Extensions/EnvWithHasExtensions/Manifest.toml
+++ b/test/project/Extensions/EnvWithHasExtensions/Manifest.toml
@@ -1,8 +1,8 @@
 # This file is machine-generated - editing it directly is not advised
 
-julia_version = "1.9.0-beta4"
+julia_version = "1.12.0-DEV"
 manifest_format = "2.0"
-project_hash = "caa716752e6dff3d77c3de929ebbb5d2024d04ef"
+project_hash = "a4c480cfa7da9610333d5c42623bf746bd286c5f"
 
 [[deps.ExtDep]]
 deps = ["SomePackage"]
@@ -18,10 +18,12 @@ version = "0.1.0"
     [deps.HasExtensions.extensions]
     Extension = "ExtDep"
     ExtensionFolder = ["ExtDep", "ExtDep2"]
+    LinearAlgebraExt = "LinearAlgebra"
 
     [deps.HasExtensions.weakdeps]
     ExtDep = "fa069be4-f60b-4d4c-8b95-f8008775090c"
     ExtDep2 = "55982ee5-2ad5-4c40-8cfe-5e9e1b01500d"
+    LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [[deps.SomePackage]]
 path = "../SomePackage"
diff --git a/test/project/Extensions/ExtDep3.jl/Project.toml b/test/project/Extensions/ExtDep3.jl/Project.toml
new file mode 100644
index 0000000000000..690b2f1cffff4
--- /dev/null
+++ b/test/project/Extensions/ExtDep3.jl/Project.toml
@@ -0,0 +1,4 @@
+name = "ExtDep3"
+uuid = "a5541f1e-a556-4fdc-af15-097880d743a1"
+version = "0.1.0"
+authors = ["Kristoffer <kcarlsson89@gmail.com>"]
diff --git a/test/project/Extensions/ExtDep3.jl/src/ExtDep3.jl b/test/project/Extensions/ExtDep3.jl/src/ExtDep3.jl
new file mode 100644
index 0000000000000..96a0b472d06c5
--- /dev/null
+++ b/test/project/Extensions/ExtDep3.jl/src/ExtDep3.jl
@@ -0,0 +1,5 @@
+module ExtDep3
+
+greet() = print("Hello World!")
+
+end # module ExtDep3
diff --git a/test/project/Extensions/HasDepWithExtensions.jl/Manifest.toml b/test/project/Extensions/HasDepWithExtensions.jl/Manifest.toml
index 15f068f250ce3..5706aba59d1e0 100644
--- a/test/project/Extensions/HasDepWithExtensions.jl/Manifest.toml
+++ b/test/project/Extensions/HasDepWithExtensions.jl/Manifest.toml
@@ -1,8 +1,8 @@
 # This file is machine-generated - editing it directly is not advised
 
-julia_version = "1.10.0"
+julia_version = "1.12.0-DEV"
 manifest_format = "2.0"
-project_hash = "d523b3401f72a1ed34b7b43749fd2655c6b78542"
+project_hash = "4e196b07f2ee7adc48ac9d528d42b3cf3737c7a0"
 
 [[deps.ExtDep]]
 deps = ["SomePackage"]
@@ -15,13 +15,20 @@ path = "../ExtDep2"
 uuid = "55982ee5-2ad5-4c40-8cfe-5e9e1b01500d"
 version = "0.1.0"
 
+[[deps.ExtDep3]]
+path = "../ExtDep3.jl"
+uuid = "a5541f1e-a556-4fdc-af15-097880d743a1"
+version = "0.1.0"
+
 [[deps.HasExtensions]]
+deps = ["ExtDep3"]
 path = "../HasExtensions.jl"
 uuid = "4d3288b3-3afc-4bb6-85f3-489fffe514c8"
 version = "0.1.0"
 
     [deps.HasExtensions.extensions]
     Extension = "ExtDep"
+    ExtensionDep = "ExtDep3"
     ExtensionFolder = ["ExtDep", "ExtDep2"]
     LinearAlgebraExt = "LinearAlgebra"
 
diff --git a/test/project/Extensions/HasDepWithExtensions.jl/Project.toml b/test/project/Extensions/HasDepWithExtensions.jl/Project.toml
index 8f308a9fbee72..aa4956caada74 100644
--- a/test/project/Extensions/HasDepWithExtensions.jl/Project.toml
+++ b/test/project/Extensions/HasDepWithExtensions.jl/Project.toml
@@ -5,4 +5,5 @@ version = "0.1.0"
 [deps]
 ExtDep = "fa069be4-f60b-4d4c-8b95-f8008775090c"
 ExtDep2 = "55982ee5-2ad5-4c40-8cfe-5e9e1b01500d"
+ExtDep3 = "a5541f1e-a556-4fdc-af15-097880d743a1"
 HasExtensions = "4d3288b3-3afc-4bb6-85f3-489fffe514c8"
diff --git a/test/project/Extensions/HasExtensions.jl/Manifest.toml b/test/project/Extensions/HasExtensions.jl/Manifest.toml
index 55f7958701a75..429c6598fc4f4 100644
--- a/test/project/Extensions/HasExtensions.jl/Manifest.toml
+++ b/test/project/Extensions/HasExtensions.jl/Manifest.toml
@@ -1,7 +1,10 @@
 # This file is machine-generated - editing it directly is not advised
 
-julia_version = "1.10.0-DEV"
+julia_version = "1.12.0-DEV"
 manifest_format = "2.0"
-project_hash = "c87947f1f1f070eea848950c304d668a112dec3d"
+project_hash = "c0bb526b75939a74a6195ee4819e598918a22ad7"
 
-[deps]
+[[deps.ExtDep3]]
+path = "../ExtDep3.jl"
+uuid = "a5541f1e-a556-4fdc-af15-097880d743a1"
+version = "0.1.0"
diff --git a/test/project/Extensions/HasExtensions.jl/Project.toml b/test/project/Extensions/HasExtensions.jl/Project.toml
index a5f9bb1e42d29..fe21a1423f543 100644
--- a/test/project/Extensions/HasExtensions.jl/Project.toml
+++ b/test/project/Extensions/HasExtensions.jl/Project.toml
@@ -2,6 +2,9 @@ name = "HasExtensions"
 uuid = "4d3288b3-3afc-4bb6-85f3-489fffe514c8"
 version = "0.1.0"
 
+[deps]
+ExtDep3 = "a5541f1e-a556-4fdc-af15-097880d743a1"
+
 [weakdeps]
 ExtDep = "fa069be4-f60b-4d4c-8b95-f8008775090c"
 ExtDep2 = "55982ee5-2ad5-4c40-8cfe-5e9e1b01500d"
@@ -9,5 +12,6 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [extensions]
 Extension = "ExtDep"
+ExtensionDep = "ExtDep3"
 ExtensionFolder = ["ExtDep", "ExtDep2"]
 LinearAlgebraExt = "LinearAlgebra"
diff --git a/test/project/Extensions/HasExtensions.jl/ext/ExtensionDep.jl b/test/project/Extensions/HasExtensions.jl/ext/ExtensionDep.jl
new file mode 100644
index 0000000000000..e2710d4d89bbb
--- /dev/null
+++ b/test/project/Extensions/HasExtensions.jl/ext/ExtensionDep.jl
@@ -0,0 +1,9 @@
+module ExtensionDep
+
+using HasExtensions, ExtDep3
+
+function __init__()
+    HasExtensions.ext_dep_loaded = true
+end
+
+end
diff --git a/test/project/Extensions/HasExtensions.jl/src/HasExtensions.jl b/test/project/Extensions/HasExtensions.jl/src/HasExtensions.jl
index dbfaeec4f8812..9d9785f87f790 100644
--- a/test/project/Extensions/HasExtensions.jl/src/HasExtensions.jl
+++ b/test/project/Extensions/HasExtensions.jl/src/HasExtensions.jl
@@ -6,5 +6,6 @@ foo(::HasExtensionsStruct) = 1
 
 ext_loaded = false
 ext_folder_loaded = false
+ext_dep_loaded = false
 
 end # module

From 3357d1b52c9db4a71b192fb08d6c04657f03e95c Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Wed, 10 Apr 2024 23:02:45 +0200
Subject: [PATCH 1255/1315] revert moving "creating packages" from Pkg.jl
 (#53509)

As mentioned in
https://github.com/JuliaLang/julia/pull/52102#issuecomment-1845523326,
having this information be moved from Pkg to Base creates a quite
uncomfortable split between information about the package manager
between the Pkg docs and Base.

Pkg PR: https://github.com/JuliaLang/Pkg.jl/pull/3818
---
 doc/make.jl                            |   1 -
 doc/src/tutorials/creating-packages.md | 647 -------------------------
 stdlib/Test/docs/src/index.md          |   4 +-
 3 files changed, 2 insertions(+), 650 deletions(-)
 delete mode 100644 doc/src/tutorials/creating-packages.md

diff --git a/doc/make.jl b/doc/make.jl
index e06fa1deb8f42..15205d6c2f89d 100644
--- a/doc/make.jl
+++ b/doc/make.jl
@@ -193,7 +193,6 @@ BaseDocs = [
 StdlibDocs = [stdlib.targetfile for stdlib in STDLIB_DOCS]
 
 Tutorials = [
-    "tutorials/creating-packages.md",
     "tutorials/profile.md",
     "tutorials/external.md",
 ]
diff --git a/doc/src/tutorials/creating-packages.md b/doc/src/tutorials/creating-packages.md
deleted file mode 100644
index c5cd1f4f92f48..0000000000000
--- a/doc/src/tutorials/creating-packages.md
+++ /dev/null
@@ -1,647 +0,0 @@
-# [Creating Packages](@id creating-packages-tutorial)
-
-## Generating files for a package
-
-!!! note
-    The [PkgTemplates](https://github.com/invenia/PkgTemplates.jl) package offers an easy, repeatable, and
-    customizable way to generate the files for a new package. It can also generate files needed for Documentation, CI, etc.
-    We recommend that you use PkgTemplates for creating
-    new packages instead of using the minimal `pkg> generate` functionality described below.
-
-To generate the bare minimum files for a new package, use `pkg> generate`.
-
-```julia-repl
-(@v1.8) pkg> generate HelloWorld
-```
-
-This creates a new project `HelloWorld` in a subdirectory by the same name, with the following files (visualized with the external [`tree` command](https://linux.die.net/man/1/tree)):
-
-```julia-repl
-shell> tree HelloWorld/
-HelloWorld/
-├── Project.toml
-└── src
-    └── HelloWorld.jl
-
-2 directories, 2 files
-```
-
-The `Project.toml` file contains the name of the package, its unique UUID, its version, the authors and potential dependencies:
-
-```toml
-name = "HelloWorld"
-uuid = "b4cd1eb8-1e24-11e8-3319-93036a3eb9f3"
-version = "0.1.0"
-authors = ["Some One <someone@email.com>"]
-
-[deps]
-```
-
-The content of `src/HelloWorld.jl` is:
-
-```julia
-module HelloWorld
-
-greet() = print("Hello World!")
-
-end # module
-```
-
-We can now activate the project by using the path to the directory where it is installed, and load the package:
-
-```julia-repl
-pkg> activate ./HelloWorld
-
-julia> import HelloWorld
-
-julia> HelloWorld.greet()
-Hello World!
-```
-
-For the rest of the tutorial we enter inside the directory of the project, for convenience:
-
-```julia-repl
-julia> cd("HelloWorld")
-```
-
-## Adding dependencies to the project
-
-Let’s say we want to use the standard library package `Random` and the registered package `JSON` in our project.
-We simply `add` these packages (note how the prompt now shows the name of the newly generated project,
-since we `activate`d it):
-
-```julia-repl
-(HelloWorld) pkg> add Random JSON
-   Resolving package versions...
-    Updating `~/HelloWorld/Project.toml`
-  [682c06a0] + JSON v0.21.3
-  [9a3f8284] + Random
-    Updating `~/HelloWorld/Manifest.toml`
-  [682c06a0] + JSON v0.21.3
-  [69de0a69] + Parsers v2.4.0
-  [ade2ca70] + Dates
- ...
-```
-
-Both `Random` and `JSON` got added to the project’s `Project.toml` file, and the resulting dependencies got added to the `Manifest.toml` file.
-The resolver has installed each package with the highest possible version, while still respecting the compatibility that each package enforces on its dependencies.
-
-We can now use both `Random` and `JSON` in our project. Changing `src/HelloWorld.jl` to
-
-```julia
-module HelloWorld
-
-import Random
-import JSON
-
-greet() = print("Hello World!")
-greet_alien() = print("Hello ", Random.randstring(8))
-
-end # module
-```
-
-and reloading the package, the new `greet_alien` function that uses `Random` can be called:
-
-```julia-repl
-julia> HelloWorld.greet_alien()
-Hello aT157rHV
-```
-
-## Defining a public API
-
-If you want your package to be useful to other packages and you want folks to be able to
-easily update to newer version of your package when they come out, it is important to
-document what behavior will stay consistent across updates.
-
-Unless you note otherwise, the public API of your package is defined as all the behavior you
-describe about public symbols. A public symbol is a symbol that is exported from your
-package with the `export` keyword or marked as public with the `public` keyword. When you
-change the behavior of something that was previously public so that the new
-version no longer conforms to the specifications provided in the old version, you should
-adjust your package version number according to [Julia's variant on SemVer](#Version-specifier-format).
-If you would like to include a symbol in your public API without exporting it into the
-global namespace of folks who call `using YourPackage`, you should mark that symbol as
-public with `public that_symbol`. Symbols marked as public with the `public` keyword are
-just as public as those marked as public with the `export` keyword, but when folks call
-`using YourPackage`, they will still have to qualify access to those symbols with
-`YourPackage.that_symbol`.
-
-Let's say we would like our `greet` function to be part of the public API, but not the
-`greet_alien` function. We could the write the following and release it as version `1.0.0`.
-
-```julia
-module HelloWorld
-
-export greet
-
-import Random
-import JSON
-
-"Writes a friendly message."
-greet() = print("Hello World!")
-
-"Greet an alien by a randomly generated name."
-greet_alien() = print("Hello ", Random.randstring(8))
-
-end # module
-```
-
-Then, if we change `greet` to
-
-```julia
-"Writes a friendly message that is exactly three words long."
-greet() = print("Hello Lovely World!")
-```
-
-We would release the new version as `1.1.0`. This is not breaking
-because the new implementation conforms to the old documentation, but
-it does add a new feature, that the message must be three words long.
-
-Later, we may wish to change `greet_alien` to
-
-```julia
-"Greet an alien by the name of \"Zork\"."
-greet_alien() = print("Hello Zork")
-```
-
-And also export it by changing
-
-```julia
-export greet
-```
-
-to
-
-```julia
-export greet, greet_alien
-```
-
-We should release this new version as `1.2.0` because it adds a new feature
-`greet_alien` to the public API. Even though `greet_alien` was documented before
-and the new version does not conform to the old documentation, this is not breaking
-because the old documentation was not attached to a symbol that was exported
-at the time so that documentation does not apply across released versions.
-
-However, if we now wish to change `greet` to
-
-```julia
-"Writes a friendly message that is exactly four words long."
-greet() = print("Hello very lovely world")
-```
-
-we would need to release the new version as `2.0.0`. In version `1.1.0`, we specified that
-the greeting would be three words long, and because `greet` was exported, that description
-also applies to all future versions until the next breaking release. Because this new
-version does not conform to the old specification, it must be tagged as a breaking change.
-
-Please note that version numbers are free and unlimited. It is okay to use lots of them
-(e.g. version `6.62.8`).
-
-## Adding a build step to the package
-
-The build step is executed the first time a package is installed or when explicitly invoked with `build`.
-A package is built by executing the file `deps/build.jl`.
-
-```julia-repl
-julia> mkpath("deps");
-
-julia> write("deps/build.jl",
-             """
-             println("I am being built...")
-             """);
-
-(HelloWorld) pkg> build
-  Building HelloWorld → `deps/build.log`
- Resolving package versions...
-
-julia> print(readchomp("deps/build.log"))
-I am being built...
-```
-
-If the build step fails, the output of the build step is printed to the console
-
-```julia-repl
-julia> write("deps/build.jl",
-             """
-             error("Ooops")
-             """);
-
-(HelloWorld) pkg> build
-    Building HelloWorld → `~/HelloWorld/deps/build.log`
-ERROR: Error building `HelloWorld`:
-ERROR: LoadError: Ooops
-Stacktrace:
- [1] error(s::String)
-   @ Base ./error.jl:35
- [2] top-level scope
-   @ ~/HelloWorld/deps/build.jl:1
- [3] include(fname::String)
-   @ Base.MainInclude ./client.jl:476
- [4] top-level scope
-   @ none:5
-in expression starting at /home/kc/HelloWorld/deps/build.jl:1
-```
-
-!!! warning
-    A build step should generally not create or modify any files in the package directory. If you need to store some files
-    from the build step, use the [Scratch.jl](https://github.com/JuliaPackaging/Scratch.jl) package.
-
-## [Adding tests to the package](@id adding-tests-to-packages)
-
-When a package is tested the file `test/runtests.jl` is executed:
-
-```julia-repl
-julia> mkpath("test");
-
-julia> write("test/runtests.jl",
-             """
-             println("Testing...")
-             """);
-
-(HelloWorld) pkg> test
-   Testing HelloWorld
- Resolving package versions...
-Testing...
-   Testing HelloWorld tests passed
-```
-
-Tests are run in a new Julia process, where the package itself, and any
-test-specific dependencies, are available, see below.
-
-
-!!! warning
-    Tests should generally not create or modify any files in the package directory. If you need to store some files
-    from the build step, use the [Scratch.jl](https://github.com/JuliaPackaging/Scratch.jl) package.
-
-### Test-specific dependencies
-
-There are two ways of adding test-specific dependencies (dependencies that are not dependencies of the package but will still be available to
-load when the package is tested).
-
-#### `target` based test specific dependencies
-
-Using this method of adding test-specific dependencies, the packages are added under an `[extras]` section and to a test target,
-e.g. to add `Markdown` and `Test` as test dependencies, add the following to the `Project.toml` file:
-
-```toml
-[extras]
-Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-
-[targets]
-test = ["Markdown", "Test"]
-```
-
-Note that the only supported targets are `test` and `build`, the latter of which (not recommended) can be used
-for any `deps/build.jl` scripts.
-
-#### Alternative approach: `test/Project.toml` file test specific dependencies
-
-!!! note
-    The exact interaction between `Project.toml`, `test/Project.toml` and their corresponding
-    `Manifest.toml`s are not fully worked out and may be subject to change in future versions.
-    The older method of adding test-specific dependencies, described in the previous section,
-    will therefore be supported throughout all Julia 1.X releases.
-
-In Julia 1.2 and later test dependencies can be declared in `test/Project.toml`. When running
-tests, Pkg will automatically merge this and the package Projects to create the test environment.
-
-!!! note
-    If no `test/Project.toml` exists Pkg will use the `target` based test specific dependencies.
-
-To add a test-specific dependency, i.e. a dependency that is available only when testing,
-it is thus enough to add this dependency to the `test/Project.toml` project. This can be
-done from the Pkg REPL by activating this environment, and then use `add` as one normally
-does. Let's add the `Test` standard library as a test dependency:
-
-```julia-repl
-(HelloWorld) pkg> activate ./test
-[ Info: activating environment at `~/HelloWorld/test/Project.toml`.
-
-(test) pkg> add Test
- Resolving package versions...
-  Updating `~/HelloWorld/test/Project.toml`
-  [8dfed614] + Test
-  Updating `~/HelloWorld/test/Manifest.toml`
-  [...]
-```
-
-We can now use `Test` in the test script and we can see that it gets installed when testing:
-
-```julia-repl
-julia> write("test/runtests.jl",
-             """
-             using Test
-             @test 1 == 1
-             """);
-
-(test) pkg> activate .
-
-(HelloWorld) pkg> test
-   Testing HelloWorld
- Resolving package versions...
-  Updating `/var/folders/64/76tk_g152sg6c6t0b4nkn1vw0000gn/T/tmpPzUPPw/Project.toml`
-  [d8327f2a] + HelloWorld v0.1.0 [`~/.julia/dev/Pkg/HelloWorld`]
-  [8dfed614] + Test
-  Updating `/var/folders/64/76tk_g152sg6c6t0b4nkn1vw0000gn/T/tmpPzUPPw/Manifest.toml`
-  [d8327f2a] + HelloWorld v0.1.0 [`~/.julia/dev/Pkg/HelloWorld`]
-   Testing HelloWorld tests passed```
-```
-
-## Compatibility on dependencies
-
-Every dependency should in general have a compatibility constraint on it.
-This is an important topic so there is a chapter in the package docs about it:
-[Compatibility](https://pkgdocs.julialang.org/v1/compatibility).
-
-## Weak dependencies
-
-!!! note
-    This is a somewhat advanced usage of Pkg which can be skipped for people new to Julia and Julia packages.
-
-!!! compat
-    The described feature requires Julia 1.9+.
-
-A weak dependency is a dependency that will not automatically install when the package is installed but
-you can still control what versions of that package are allowed to be installed by setting compatibility on it.
-These are listed in the project file under the `[weakdeps]` section:
-
-```toml
-[weakdeps]
-SomePackage = "b3785f31-9d33-4cdf-bc73-f646780f1739"
-
-[compat]
-SomePackage = "1.2"
-```
-
-The current usage of this is almost solely limited to "extensions" which is described in the next section.
-
-## Conditional loading of code in packages (Extensions)
-
-!!! note
-    This is a somewhat advanced usage of Pkg which can be skipped for people new to Julia and Julia packages.
-
-!!! compat
-    The described feature requires Julia 1.9+.
-
-Sometimes one wants to make two or more packages work well together, but may be reluctant (perhaps due to increased load times) to make one an unconditional dependency of the other.
-A package *extension* is a module in a file (similar to a package) that is automatically loaded when *some other set of packages* are
-loaded into the Julia session. This is very similar to functionality that the external package
-[Requires.jl](https://github.com/JuliaPackaging/Requires.jl) provides, but which is now available directly through Julia,
-and provides added benefits such as being able to precompile the extension.
-
-### Code structure
-
-A useful application of extensions could be for a plotting package that should be able to plot
-objects from a wide variety of different Julia packages.
-Adding all those different Julia packages as dependencies of the plotting package
-could be expensive since they would end up getting loaded even if they were never used.
-Instead, the code required to plot objects for specific packages can be put into separate files
-(extensions) and these are loaded only when the packages that define the type(s) we want to plot
-are loaded.
-
-Below is an example of how the code can be structured for a use case in which a
-`Plotting` package wants to be able to display objects defined in the external package `Contour`.
-The file and folder structure shown below is found in the `Plotting` package.
-
- `Project.toml`:
- ```toml
-name = "Plotting"
-version = "0.1.0"
-uuid = "..."
-
-[weakdeps]
-Contour = "d38c429a-6771-53c6-b99e-75d170b6e991"
-
-[extensions]
-# name of extension to the left
-# extension dependencies required to load the extension to the right
-# use a list for multiple extension dependencies
-PlottingContourExt = "Contour"
-
-[compat]
-Contour = "0.6.2"
-```
-
-`src/Plotting.jl`:
-```julia
-module Plotting
-
-function plot(x::Vector)
-    # Some functionality for plotting a vector here
-end
-
-end # module
-```
-
-`ext/PlottingContourExt.jl` (can also be in `ext/PlottingContourExt/PlottingContourExt.jl`):
-```julia
-module PlottingContourExt # Should be same name as the file (just like a normal package)
-
-using Plotting, Contour
-
-function Plotting.plot(c::Contour.ContourCollection)
-    # Some functionality for plotting a contour here
-end
-
-end # module
-```
-
-Extensions can have any arbitrary name (here `PlottingContourExt`), but using something similar to the format of
-this example that makes the extended functionality and dependency of the extension clear is likely a good idea.
-
-!!! compat
-    Often you will put the extension dependencies into the `test` target so they are loaded when running e.g. `Pkg.test()`. On earlier Julia versions
-    this requires you to also put the package in the `[extras]` section. This is unfortunate but the project verifier on older Julia versions will
-    complain if this is not done.
-
-!!! note
-    If you use a manifest generated by a Julia version that does not know about extensions with a Julia version that does
-    know about them, the extensions will not load. This is because the manifest lacks some information that tells Julia
-    when it should load these packages. So make sure you use a manifest generated at least the Julia version you are using.
-
-### Behavior of extensions
-
-A user that depends only on `Plotting` will not pay the cost of the "extension" inside the `PlottingContourExt` module.
-It is only when the `Contour` package actually gets loaded that the `PlottingContourExt` extension is loaded too
-and provides the new functionality.
-
-In our example, the new functionality is an additional _method_, which we add to an existing _function_ from the parent package `Plotting`.
-Implementing such methods is among the most standard use cases of package extensions.
-Within the parent package, the function to extend can even be defined with zero methods, as follows:
-
-```julia
-function plot end
-```
-
-!!! note
-    If one considers `PlottingContourExt` as a completely separate package, it could be argued that defining `Plotting.plot(c::Contour.ContourCollection)` is
-    [type piracy](@ref avoid-type-piracy) since `PlottingContourExt` _owns_ neither the function `Plotting.plot` nor the type `Contour.ContourCollection`.
-    However, for extensions, it is ok to assume that the extension owns the functions in its parent package.
-
-In other situations, one may need to define new symbols in the extension (types, structs, functions, etc.) instead of reusing those from the parent package.
-Such symbols are created in a separate module corresponding to the extension, namely `PlottingContourExt`, and thus not in `Plotting` itself.
-If extension symbols are needed in the parent package, one must call `Base.get_extension` to retrieve them.
-Here is an example showing how a custom type defined in `PlottingContourExt` can be accessed in `Plotting`:
-
-```julia
-ext = Base.get_extension(@__MODULE__, :PlottingContourExt)
-if !isnothing(ext)
-    ContourPlotType = ext.ContourPlotType
-end
-```
-
-On the other hand, accessing extension symbols from a third-party package (i.e. not the parent) is not a recommended practice at the moment.
-
-### Backwards compatibility
-
-This section discusses various methods for using extensions on Julia versions that support them,
-while simultaneously providing similar functionality on older Julia versions.
-
-#### Requires.jl
-
-This section is relevant if you are currently using Requires.jl but want to transition to using extensions (while still having Requires be used on Julia versions that do not support extensions).
-This is done by making the following changes (using the example above):
-
-- Add the following to the package file. This makes it so that Requires.jl loads and inserts the
-  callback only when extensions are not supported
-  ```julia
-  # This symbol is only defined on Julia versions that support extensions
-  if !isdefined(Base, :get_extension)
-  using Requires
-  end
-
-  @static if !isdefined(Base, :get_extension)
-  function __init__()
-      @require Contour = "d38c429a-6771-53c6-b99e-75d170b6e991" include("../ext/PlottingContourExt.jl")
-  end
-  end
-  ```
-  or if you have other things in your `__init__()` function:
-  ```julia
-  if !isdefined(Base, :get_extension)
-  using Requires
-  end
-
-  function __init__()
-      # Other init functionality here
-
-      @static if !isdefined(Base, :get_extension)
-          @require Contour = "d38c429a-6771-53c6-b99e-75d170b6e991" include("../ext/PlottingContourExt.jl")
-      end
-  end
-  ```
-- Make the following change in the conditionally-loaded code:
-  ```julia
-  isdefined(Base, :get_extension) ? (using Contour) : (using ..Contour)
-  ```
-- Add `Requires` to `[weakdeps]` in your `Project.toml` file, so that it is listed in both `[deps]` and `[weakdeps]`.
-  Julia 1.9+ knows to not install it as a regular dependency, whereas earlier versions will consider it a dependency.
-
-The package should now work with Requires.jl on Julia versions before extensions were introduced
-and with extensions on more recent Julia versions.
-
-####  Transition from normal dependency to extension
-
-This section is relevant if you have a normal dependency that you want to transition be an extension (while still having the dependency be a normal dependency on Julia versions that do not support extensions).
-This is done by making the following changes (using the example above):
-
-- Make sure that the package is **both** in the `[deps]` and `[weakdeps]` section. Newer Julia versions will ignore dependencies in `[deps]` that are also in `[weakdeps]`.
-- Add the following to your main package file (typically at the bottom):
-  ```julia
-  if !isdefined(Base, :get_extension)
-    include("../ext/PlottingContourExt.jl")
-  end
-  ```
-
-#### Using an extension while supporting older Julia versions
-
-In the case where one wants to use an extension (without worrying about the
-feature of the extension being available on older Julia versions) while still
-supporting older Julia versions the packages under `[weakdeps]` should be
-duplicated into `[extras]`. This is an unfortunate duplication, but without
-doing this the project verifier under older Julia versions will throw an error
-if it finds packages under `[compat]` that is not listed in `[extras]`.
-
-## Package naming rules
-
-Package names should be sensible to most Julia users, *even to those who are not domain experts*.
-The following rules apply to the `General` registry but may be useful for other package
-registries as well.
-
-Since the `General` registry belongs to the entire community, people may have opinions about
-your package name when you publish it, especially if it's ambiguous or can be confused with
-something other than what it is. Usually, you will then get suggestions for a new name that
-may fit your package better.
-
-1. Avoid jargon. In particular, avoid acronyms unless there is minimal possibility of confusion.
-
-     * It's ok to say `USA` if you're talking about the USA.
-     * It's not ok to say `PMA`, even if you're talking about positive mental attitude.
-2. Avoid using `Julia` in your package name or prefixing it with `Ju`.
-
-     * It is usually clear from context and to your users that the package is a Julia package.
-     * Package names already have a `.jl` extension, which communicates to users that `Package.jl` is a Julia package.
-     * Having Julia in the name can imply that the package is connected to, or endorsed by, contributors
-       to the Julia language itself.
-3. Packages that provide most of their functionality in association with a new type should have pluralized
-   names.
-
-     * `DataFrames` provides the `DataFrame` type.
-     * `BloomFilters` provides the `BloomFilter` type.
-     * In contrast, `JuliaParser` provides no new type, but instead new functionality in the `JuliaParser.parse()`
-       function.
-4. Err on the side of clarity, even if clarity seems long-winded to you.
-
-     * `RandomMatrices` is a less ambiguous name than `RndMat` or `RMT`, even though the latter are shorter.
-5. A less systematic name may suit a package that implements one of several possible approaches to
-   its domain.
-
-     * Julia does not have a single comprehensive plotting package. Instead, `Gadfly`, `PyPlot`, `Winston`
-       and other packages each implement a unique approach based on a particular design philosophy.
-     * In contrast, `SortingAlgorithms` provides a consistent interface to use many well-established
-       sorting algorithms.
-6. Packages that wrap external libraries or programs can be named after those libraries or programs.
-
-     * `CPLEX.jl` wraps the `CPLEX` library, which can be identified easily in a web search.
-     * `MATLAB.jl` provides an interface to call the MATLAB engine from within Julia.
-
-7. Avoid naming a package closely to an existing package
-     * `Websocket` is too close to `WebSockets` and can be confusing to users. Rather use a new name such as `SimpleWebsockets`.
-
-8. Avoid using a distinctive name that is already in use in a well known, unrelated project.
-     * Don't use the names `Tkinter.jl`, `TkinterGUI.jl`, etc. for a package that is unrelated
-       to the popular `tkinter` python package, even if it provides bindings to Tcl/Tk.
-       A package name of `Tkinter.jl` would only be appropriate if the package used Python's
-       library to accomplish its work or was spearheaded by the same community of developers.
-     * It's okay to name a package `HTTP.jl` even though it is unrelated to the popular rust
-       crate `http` because in most usages the name "http" refers to the hypertext transfer
-       protocol, not to the `http` rust crate.
-     * It's okay to name a package `OpenSSL.jl` if it provides an interface to the OpenSSL
-       library, even without explicit affiliation with the creators of the OpenSSL (provided
-       there's no copyright or trademark infringement etc.)
-
-## Registering packages
-
-Once a package is ready it can be registered with the [General Registry](https://github.com/JuliaRegistries/General#registering-a-package-in-general) (see also the [FAQ](https://github.com/JuliaRegistries/General#faq)).
-Currently, packages are submitted via [`Registrator`](https://juliaregistrator.github.io/).
-In addition to `Registrator`, [`TagBot`](https://github.com/marketplace/actions/julia-tagbot) helps manage the process of tagging releases.
-
-## Best Practices
-
-Packages should avoid mutating their own state (writing to files within their package directory).
-Packages should, in general, not assume that they are located in a writable location (e.g. if installed as part of a system-wide depot) or even a stable one (e.g. if they are bundled into a system image by [PackageCompiler.jl](https://github.com/JuliaLang/PackageCompiler.jl)).
-To support the various use cases in the Julia package ecosystem, the Pkg developers have created a number of auxiliary packages and techniques to help package authors create self-contained, immutable, and relocatable packages:
-
-* [`Artifacts`](https://pkgdocs.julialang.org/v1/artifacts/) can be used to bundle chunks of data alongside your package, or even allow them to be downloaded on-demand.
-  Prefer artifacts over attempting to open a file via a path such as `joinpath(@__DIR__, "data", "my_dataset.csv")` as this is non-relocatable.
-  Once your package has been precompiled, the result of `@__DIR__` will have been baked into your precompiled package data, and if you attempt to distribute this package, it will attempt to load files at the wrong location.
-  Artifacts can be bundled and accessed easily using the `artifact"name"` string macro.
-
-* [`Scratch.jl`](https://github.com/JuliaPackaging/Scratch.jl) provides the notion of "scratch spaces", mutable containers of data for packages.
-  Scratch spaces are designed for data caches that are completely managed by a package and should be removed when the package itself is uninstalled.
-  For important user-generated data, packages should continue to write out to a user-specified path that is not managed by Julia or Pkg.
-
-* [`Preferences.jl`](https://github.com/JuliaPackaging/Preferences.jl) allows packages to read and write preferences to the top-level `Project.toml`.
-  These preferences can be read at runtime or compile-time, to enable or disable different aspects of package behavior.
-  Packages previously would write out files to their own package directories to record options set by the user or environment, but this is highly discouraged now that `Preferences` is available.
diff --git a/stdlib/Test/docs/src/index.md b/stdlib/Test/docs/src/index.md
index e68efdfb6ebf5..949c2591474a6 100644
--- a/stdlib/Test/docs/src/index.md
+++ b/stdlib/Test/docs/src/index.md
@@ -24,7 +24,7 @@ The `Test` module provides simple *unit testing* functionality. Unit testing is
 see if your code is correct by checking that the results are what you expect. It can be helpful
 to ensure your code still works after you make changes, and can be used when developing as a way
 of specifying the behaviors your code should have when complete. You may also want to look at the
-documentation for [adding tests to your Julia Package](@ref adding-tests-to-packages).
+documentation for [adding tests to your Julia Package](https://pkgdocs.julialang.org/dev/creating-packages/#Adding-tests-to-the-package).
 
 Simple unit testing can be performed with the `@test` and `@test_throws` macros:
 
@@ -469,7 +469,7 @@ end
 We will need to create those two included files, `math_tests.jl` and `greeting_tests.jl`, and add some tests to them.
 
 > **Note:** Notice how we did not have to specify add `Example` into the `test` environment's `Project.toml`.
-> This is a benefit of Julia's testing system that you could [read about more here](@ref adding-tests-to-packages).
+> This is a benefit of Julia's testing system that you could [read about more here](https://pkgdocs.julialang.org/dev/creating-packages/).
 
 #### Writing Tests for `math_tests.jl`
 

From 45fb084873b56dc555dd442cda3485c6175344b5 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Thu, 11 Apr 2024 08:55:08 +0900
Subject: [PATCH 1256/1315] inlining: remove unused `allow_abstract::Bool`
 keyword argument (#53601)

---
 base/compiler/ssair/inlining.jl | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index e54d3fd834a27..d6853d83b61bc 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1294,16 +1294,16 @@ end
 function handle_any_const_result!(cases::Vector{InliningCase},
     @nospecialize(result), match::MethodMatch, argtypes::Vector{Any},
     @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
-    allow_abstract::Bool, allow_typevars::Bool)
+    allow_typevars::Bool)
     if isa(result, ConcreteResult)
         return handle_concrete_result!(cases, result, match, info, state)
     elseif isa(result, SemiConcreteResult)
-        return handle_semi_concrete_result!(cases, result, match, info, flag, state; allow_abstract)
+        return handle_semi_concrete_result!(cases, result, match, info, flag, state)
     elseif isa(result, ConstPropResult)
-        return handle_const_prop_result!(cases, result, match, info, flag, state; allow_abstract, allow_typevars)
+        return handle_const_prop_result!(cases, result, match, info, flag, state; allow_typevars)
     else
         @assert result === nothing || result isa VolatileInferenceResult
-        return handle_match!(cases, match, argtypes, info, flag, state; allow_abstract, allow_typevars, volatile_inf_result = result)
+        return handle_match!(cases, match, argtypes, info, flag, state; allow_typevars, volatile_inf_result = result)
     end
 end
 
@@ -1368,7 +1368,7 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
                 handled_all_cases = false
             else
                 handled_all_cases &= handle_any_const_result!(cases,
-                    result, match, argtypes, info, flag, state; allow_abstract=true, allow_typevars=false)
+                    result, match, argtypes, info, flag, state; allow_typevars=false)
             end
         end
         fully_covered &= split_fully_covered
@@ -1384,7 +1384,7 @@ function compute_inlining_cases(@nospecialize(info::CallInfo), flag::UInt32, sig
             match = getsplit(info, i)[j]
             result = getresult(info, k)
             handled_all_cases &= handle_any_const_result!(cases,
-                result, match, argtypes, info, flag, state; allow_abstract=true, allow_typevars=true)
+                result, match, argtypes, info, flag, state; allow_typevars=true)
         end
     elseif !isempty(cases)
         # if we've not seen all candidates, union split is valid only for dispatch tuples
@@ -1407,10 +1407,8 @@ end
 function handle_match!(cases::Vector{InliningCase},
     match::MethodMatch, argtypes::Vector{Any}, @nospecialize(info::CallInfo), flag::UInt32,
     state::InliningState;
-    allow_abstract::Bool, allow_typevars::Bool,
-    volatile_inf_result::Union{Nothing,VolatileInferenceResult})
+    allow_typevars::Bool, volatile_inf_result::Union{Nothing,VolatileInferenceResult})
     spec_types = match.spec_types
-    allow_abstract || isdispatchtuple(spec_types) || return false
     # We may see duplicated dispatch signatures here when a signature gets widened
     # during abstract interpretation: for the purpose of inlining, we can just skip
     # processing this dispatch candidate (unless unmatched type parameters are present)
@@ -1423,10 +1421,9 @@ end
 
 function handle_const_prop_result!(cases::Vector{InliningCase}, result::ConstPropResult,
     match::MethodMatch, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
-    allow_abstract::Bool, allow_typevars::Bool)
+    allow_typevars::Bool)
     mi = result.result.linfo
     spec_types = match.spec_types
-    allow_abstract || isdispatchtuple(spec_types) || return false
     if !validate_sparams(mi.sparam_vals)
         (allow_typevars && !may_have_fcalls(mi.def::Method)) || return false
     end
@@ -1460,11 +1457,9 @@ function semiconcrete_result_item(result::SemiConcreteResult,
 end
 
 function handle_semi_concrete_result!(cases::Vector{InliningCase}, result::SemiConcreteResult,
-    match::MethodMatch, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState;
-    allow_abstract::Bool)
+    match::MethodMatch, @nospecialize(info::CallInfo), flag::UInt32, state::InliningState)
     mi = result.mi
     spec_types = match.spec_types
-    allow_abstract || isdispatchtuple(spec_types) || return false
     validate_sparams(mi.sparam_vals) || return false
     item = semiconcrete_result_item(result, info, flag, state)
     item === nothing && return false

From 630f7545a4a1a91caffc391ab463c437de721998 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 10 Apr 2024 23:54:41 -0400
Subject: [PATCH 1257/1315] Fix comparison base for line table compression
 (#54032)

I'm not entirely sure what the original intent of this statement was,
but the effect ends up being that some codeloc entries end up negative
in the compressed representation, but the code always assumes unsigned
integers, so things roundtripped badly, leading to badly corrupted stack
traces. I guess this might have been a rebase mistake,
since the same line exists (correctly) a few lines prior. Fixes #54031.
---
 src/ircode.c           | 1 -
 test/compiler/ssair.jl | 7 +++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/ircode.c b/src/ircode.c
index 196f9f7b413ad..2e16d1b5b2420 100644
--- a/src/ircode.c
+++ b/src/ircode.c
@@ -1234,7 +1234,6 @@ JL_DLLEXPORT jl_string_t *jl_compress_codelocs(int32_t firstline, jl_value_t *co
 #undef SETMIN
 #undef SETMAX
     }
-    min.line = min.to = min.pc = firstline <= 0 ? INT32_MAX : firstline;
     int32_t header[3];
     header[0] = min.line > max.line ? 0 : min.line;
     header[1] = min.line > max.line ? 0 : max.line - min.line;
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 9d5f7b617080d..9ff4d3d8a4220 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -825,3 +825,10 @@ end
 @test_throws ErrorException f_must_throw_phinode_edge()
 global global_error_switch = false
 @test f_must_throw_phinode_edge() == 1
+
+# Test roundtrip of debuginfo compression
+let cl = Int32[32, 1, 1, 1000, 240, 230]
+    str = ccall(:jl_compress_codelocs, Any, (Int32, Any, Int), 378, cl, 2)::String;
+    cl2 = ccall(:jl_uncompress_codelocs, Any, (Any, Int), str, 2)
+    @test cl == cl2
+end

From dc8857a86f0102b2e935057ac38eb5068833ac44 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 11 Apr 2024 08:05:30 -0400
Subject: [PATCH 1258/1315] ir: Add version of compute_trycatch for IRCode
 (#54035)

For ir transform passes that need to be aware of current_scope.
Currently no users in Base, but available for external absint.

---------

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 base/compiler/inferencestate.jl | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 48784378ef7c1..3f2ec4734cc21 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -368,7 +368,21 @@ is_inferred(result::InferenceResult) = result.result !== nothing
 
 was_reached(sv::InferenceState, pc::Int) = sv.ssavaluetypes[pc] !== NOT_FOUND
 
-function compute_trycatch(code::Vector{Any}, ip::BitSet)
+compute_trycatch(ir::IRCode, ip::BitSet) = compute_trycatch(ir.stmts.stmt, ip, ir.cfg.blocks)
+
+"""
+    compute_trycatch(code, ip [, bbs]) -> (handler_at, handlers)
+
+Given the code of a function, compute, at every statement, the current
+try/catch handler, and the current exception stack top. This function returns
+a tuple of:
+
+    1. `handler_at`: A statement length vector of tuples `(catch_handler, exception_stack)`,
+       which are indices into `handlers`
+
+    2. `handlers`: A `TryCatchFrame` vector of handlers
+"""
+function compute_trycatch(code::Vector{Any}, ip::BitSet, bbs::Union{Vector{BasicBlock}, Nothing}=nothing)
     # The goal initially is to record the frame like this for the state at exit:
     # 1: (enter 3) # == 0
     # 3: (expr)    # == 1
@@ -388,6 +402,7 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
         stmt = code[pc]
         if isa(stmt, EnterNode)
             l = stmt.catch_dest
+            (bbs !== nothing) && (l = first(bbs[l].stmts))
             push!(handlers, TryCatchFrame(Bottom, isdefined(stmt, :scope) ? Bottom : nothing, pc))
             handler_id = length(handlers)
             handler_at[pc + 1] = (handler_id, 0)
@@ -412,8 +427,10 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
             stmt = code[pc]
             if isa(stmt, GotoNode)
                 pc´ = stmt.label
+                (bbs !== nothing) && (pc´ = first(bbs[pc´].stmts))
             elseif isa(stmt, GotoIfNot)
                 l = stmt.dest::Int
+                (bbs !== nothing) && (l = first(bbs[l].stmts))
                 if handler_at[l] != cur_stacks
                     @assert handler_at[l][1] == 0 || handler_at[l][1] == cur_stacks[1] "unbalanced try/catch"
                     handler_at[l] = cur_stacks
@@ -424,6 +441,7 @@ function compute_trycatch(code::Vector{Any}, ip::BitSet)
                 break
             elseif isa(stmt, EnterNode)
                 l = stmt.catch_dest
+                (bbs !== nothing) && (l = first(bbs[l].stmts))
                 # We assigned a handler number above. Here we just merge that
                 # with out current handler information.
                 if l != 0

From a7fd6a76f43262c02e83d809500b98e649490dbc Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 11 Apr 2024 08:05:43 -0400
Subject: [PATCH 1259/1315] Allow mutable-for-identity-only types to be inlined
 into IR (#54034)

This extends the value-inability predicate to allow mutable structs that
do not have any mutable fields. The motivating example for this is
ScopedValue, which is mutable only for identity. By allowing it in this
predicate, more of the ScopedValue support code becomes concrete-eval
eligible, rather than attempting to constprop for every single
ScopedValue, saving compilation time.

---------

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>
---
 base/compiler/utilities.jl | 22 +++++++++++++++++++++-
 test/scopedvalues.jl       |  9 +++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/base/compiler/utilities.jl b/base/compiler/utilities.jl
index 1e002f8dad5a6..75e8f84dc4c33 100644
--- a/base/compiler/utilities.jl
+++ b/base/compiler/utilities.jl
@@ -83,7 +83,27 @@ const MAX_INLINE_CONST_SIZE = 256
 
 function count_const_size(@nospecialize(x), count_self::Bool = true)
     (x isa Type || x isa Core.TypeName || x isa Symbol) && return 0
-    ismutable(x) && return MAX_INLINE_CONST_SIZE + 1
+    if ismutable(x)
+        # No definite size
+        (isa(x, GenericMemory) || isa(x, String) || isa(x, SimpleVector)) &&
+            return MAX_INLINE_CONST_SIZE + 1
+        if isa(x, Module)
+            # We allow modules, because we already assume they are externally
+            # rooted, so we count their contents as 0 size.
+            return sizeof(Ptr{Cvoid})
+        end
+        # We allow mutable types with no mutable fields (i.e. those mutable
+        # types used for identity only). The intent of this function is to
+        # prevent the rooting of large amounts of data that may have been
+        # speculatively computed. If the struct can get mutated later, we
+        # cannot assess how much data we might end up rooting. However, if
+        # the struct is mutable only for identity, the query still works.
+        for i = 1:nfields(x)
+            if !isconst(typeof(x), i)
+                return MAX_INLINE_CONST_SIZE + 1
+            end
+        end
+    end
     isbits(x) && return Core.sizeof(x)
     dt = typeof(x)
     sz = count_self ? sizeof(dt) : 0
diff --git a/test/scopedvalues.jl b/test/scopedvalues.jl
index 3af6a3f065c8b..61b10c557c455 100644
--- a/test/scopedvalues.jl
+++ b/test/scopedvalues.jl
@@ -1,6 +1,9 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
+
 using Base.ScopedValues
 
+include("compiler/irutils.jl")
+
 @testset "errors" begin
     @test ScopedValue{Float64}(1)[] == 1.0
     @test_throws InexactError ScopedValue{Int}(1.5)
@@ -160,3 +163,9 @@ end
 let code = code_typed(with_macro_slot_cross)[1][1].code
     @test !any(x->isa(x, Core.PhiCNode), code)
 end
+
+# inline constant scoped values
+const inlineable_const_sv = ScopedValue(1)
+@test fully_eliminated(; retval=(inlineable_const_sv => 1)) do
+    inlineable_const_sv => 1
+end

From f085913ba188b825f7e669a80783244e852d20ad Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 11 Apr 2024 10:11:55 -0400
Subject: [PATCH 1260/1315] constprop: Add facility for widening arguments
 before constprop (#54036)

There are various situations where we may want to constprop with
something other than the most precise concrete arguments in order to
make the resulting cache more useful to other call sites. One particular
example of this might be a method where non-concrete inference already
discovered that one argument is unused:

```
function foo(a, b::DispatchOnly)
    expensive_to_compile(a)
end
```

Right now, we will generally perform constprop for every different value
of `b`, even though we already have the information that `b` is unused.

Another example is external absints that may want to treat certain types
fully symbolically. They may want to substitute concrete values for an
abstract domain.

This adds the facility to do both of these things by
1. Adding an appropriate interp hook in the constprop path
2. Adding a WidendedSimpleArgtypes wrapper that's like SimpleArgtypes
but works around an issue where we would override cache information
using values from concrete eval, which is not legal if the argtypes were
widened.
---
 base/compiler/abstractinterpretation.jl | 18 +++++++++++++-----
 base/compiler/inferenceresult.jl        |  9 ++++++++-
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index a396e281c1bf7..930439ad3500b 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1243,12 +1243,17 @@ const_prop_result(inf_result::InferenceResult) =
 return_cached_result(::AbstractInterpreter, inf_result::InferenceResult, ::AbsIntState) =
     const_prop_result(inf_result)
 
+function compute_forwarded_argtypes(interp::AbstractInterpreter, arginfo::ArgInfo, sv::AbsIntState)
+    𝕃ᵢ = typeinf_lattice(interp)
+    return has_conditional(𝕃ᵢ, sv) ? ConditionalSimpleArgtypes(arginfo, sv) : SimpleArgtypes(arginfo.argtypes)
+end
+
 function const_prop_call(interp::AbstractInterpreter,
     mi::MethodInstance, result::MethodCallResult, arginfo::ArgInfo, sv::AbsIntState,
     concrete_eval_result::Union{Nothing, ConstCallResults}=nothing)
     inf_cache = get_inference_cache(interp)
     𝕃ᵢ = typeinf_lattice(interp)
-    argtypes = has_conditional(𝕃ᵢ, sv) ? ConditionalArgtypes(arginfo, sv) : SimpleArgtypes(arginfo.argtypes)
+    forwarded_argtypes = compute_forwarded_argtypes(interp, arginfo, sv)
     # use `cache_argtypes` that has been constructed for fresh regular inference if available
     volatile_inf_result = result.volatile_inf_result
     if volatile_inf_result !== nothing
@@ -1256,7 +1261,7 @@ function const_prop_call(interp::AbstractInterpreter,
     else
         cache_argtypes = matching_cache_argtypes(𝕃ᵢ, mi)
     end
-    argtypes = matching_cache_argtypes(𝕃ᵢ, mi, argtypes, cache_argtypes)
+    argtypes = matching_cache_argtypes(𝕃ᵢ, mi, forwarded_argtypes, cache_argtypes)
     inf_result = cache_lookup(𝕃ᵢ, mi, argtypes, inf_cache)
     if inf_result !== nothing
         # found the cache for this constant prop'
@@ -1290,7 +1295,10 @@ function const_prop_call(interp::AbstractInterpreter,
         return nothing
     end
     @assert inf_result.result !== nothing
-    if concrete_eval_result !== nothing
+    # ConditionalSimpleArgtypes is allowed, because the only case in which it modifies
+    # the argtypes is when one of the argtypes is a `Conditional`, which case
+    # concrete_eval_result will not be available.
+    if concrete_eval_result !== nothing && isa(forwarded_argtypes, Union{SimpleArgtypes, ConditionalSimpleArgtypes})
         # override return type and effects with concrete evaluation result if available
         inf_result.result = concrete_eval_result.rt
         inf_result.ipo_effects = concrete_eval_result.effects
@@ -1300,13 +1308,13 @@ end
 
 # TODO implement MustAlias forwarding
 
-struct ConditionalArgtypes
+struct ConditionalSimpleArgtypes
     arginfo::ArgInfo
     sv::InferenceState
 end
 
 function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance,
-                                 conditional_argtypes::ConditionalArgtypes,
+                                 conditional_argtypes::ConditionalSimpleArgtypes,
                                  cache_argtypes::Vector{Any})
     (; arginfo, sv) = conditional_argtypes
     (; fargs, argtypes) = arginfo
diff --git a/base/compiler/inferenceresult.jl b/base/compiler/inferenceresult.jl
index 574685c1e38d6..2575429fbf924 100644
--- a/base/compiler/inferenceresult.jl
+++ b/base/compiler/inferenceresult.jl
@@ -9,8 +9,15 @@ struct SimpleArgtypes
     argtypes::Vector{Any}
 end
 
+# Like `SimpleArgtypes`, but allows the argtypes to be wider than the current call.
+# As a result, it is not legal to refine the cache result with information more
+# precise than was it deducible from the `WidenedSimpleArgtypes`.
+struct WidenedArgtypes
+    argtypes::Vector{Any}
+end
+
 function matching_cache_argtypes(𝕃::AbstractLattice, mi::MethodInstance,
-                                 simple_argtypes::SimpleArgtypes,
+                                 simple_argtypes::Union{SimpleArgtypes, WidenedArgtypes},
                                  cache_argtypes::Vector{Any})
     (; argtypes) = simple_argtypes
     given_argtypes = Vector{Any}(undef, length(argtypes))

From db247ce88fbd585c67b38be909d3a0411dc4865a Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Fri, 12 Apr 2024 00:52:45 +0530
Subject: [PATCH 1261/1315] LinearAlgebra: Remove unnecessary adjoint/transpose
 for bidiag/tridiag (#54024)

These should be unnecessary, as the fallback methods do the same.
---
 stdlib/LinearAlgebra/src/bidiag.jl  | 2 --
 stdlib/LinearAlgebra/src/tridiag.jl | 3 ---
 2 files changed, 5 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/bidiag.jl b/stdlib/LinearAlgebra/src/bidiag.jl
index 323edd5ad45c6..145cce562991f 100644
--- a/stdlib/LinearAlgebra/src/bidiag.jl
+++ b/stdlib/LinearAlgebra/src/bidiag.jl
@@ -275,8 +275,6 @@ for func in (:conj, :copy, :real, :imag)
     @eval ($func)(M::Bidiagonal) = Bidiagonal(($func)(M.dv), ($func)(M.ev), M.uplo)
 end
 
-adjoint(B::Bidiagonal) = Adjoint(B)
-transpose(B::Bidiagonal) = Transpose(B)
 adjoint(B::Bidiagonal{<:Number}) = Bidiagonal(conj(B.dv), conj(B.ev), B.uplo == 'U' ? :L : :U)
 transpose(B::Bidiagonal{<:Number}) = Bidiagonal(B.dv, B.ev, B.uplo == 'U' ? :L : :U)
 permutedims(B::Bidiagonal) = Bidiagonal(B.dv, B.ev, B.uplo == 'U' ? 'L' : 'U')
diff --git a/stdlib/LinearAlgebra/src/tridiag.jl b/stdlib/LinearAlgebra/src/tridiag.jl
index 431e349d42da2..9403b44538b11 100644
--- a/stdlib/LinearAlgebra/src/tridiag.jl
+++ b/stdlib/LinearAlgebra/src/tridiag.jl
@@ -167,7 +167,6 @@ end
 
 transpose(S::SymTridiagonal) = S
 adjoint(S::SymTridiagonal{<:Real}) = S
-adjoint(S::SymTridiagonal) = Adjoint(S)
 permutedims(S::SymTridiagonal) = S
 function permutedims(S::SymTridiagonal, perm)
     Base.checkdims_perm(S, S, perm)
@@ -616,8 +615,6 @@ for func in (:conj, :copy, :real, :imag)
     end
 end
 
-adjoint(S::Tridiagonal) = Adjoint(S)
-transpose(S::Tridiagonal) = Transpose(S)
 adjoint(S::Tridiagonal{<:Real}) = Tridiagonal(S.du, S.d, S.dl)
 transpose(S::Tridiagonal{<:Number}) = Tridiagonal(S.du, S.d, S.dl)
 permutedims(T::Tridiagonal) = Tridiagonal(T.du, T.d, T.dl)

From 1ae41a2c0a3ba49d4b39dc4933dddf952b5f7f3c Mon Sep 17 00:00:00 2001
From: "Lance (Weiqing) Xu" <47257262+lanceXwq@users.noreply.github.com>
Date: Thu, 11 Apr 2024 20:14:37 -0700
Subject: [PATCH 1262/1315] Fix typos in docs (#54059)

---
 base/compiler/ssair/domtree.jl     | 2 +-
 doc/src/manual/arrays.md           | 2 +-
 doc/src/manual/performance-tips.md | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/base/compiler/ssair/domtree.jl b/base/compiler/ssair/domtree.jl
index bbae3a4d8c0fc..81b46c7179d9a 100644
--- a/base/compiler/ssair/domtree.jl
+++ b/base/compiler/ssair/domtree.jl
@@ -202,7 +202,7 @@ DFS(blocks::Vector{BasicBlock}, is_post_dominator::Bool=false) = DFS!(DFSTree(0)
 """
 Keeps the per-BB state of the Semi NCA algorithm. In the original formulation,
 there are three separate length `n` arrays, `label`, `semi` and `ancestor`.
-Instead, for efficiency, we use one array in a array-of-structs style setup.
+Instead, for efficiency, we use one array in an array-of-structs style setup.
 """
 struct SNCAData
     semi::PreNumber
diff --git a/doc/src/manual/arrays.md b/doc/src/manual/arrays.md
index 34e5a231d22de..bda778594df96 100644
--- a/doc/src/manual/arrays.md
+++ b/doc/src/manual/arrays.md
@@ -793,7 +793,7 @@ Indexing by a boolean vector `B` is effectively the same as indexing by the
 vector of integers that is returned by [`findall(B)`](@ref). Similarly, indexing
 by a `N`-dimensional boolean array is effectively the same as indexing by the
 vector of `CartesianIndex{N}`s where its values are `true`. A logical index
-must be a array of the same shape as the dimension(s) it indexes into, or it
+must be an array of the same shape as the dimension(s) it indexes into, or it
 must be the only index provided and match the shape of the one-dimensional
 reshaped view of the array it indexes into. It is generally more efficient
 to use boolean arrays as indices directly instead of first calling [`findall`](@ref).
diff --git a/doc/src/manual/performance-tips.md b/doc/src/manual/performance-tips.md
index 1b7e2e76c722b..960ba51a16850 100644
--- a/doc/src/manual/performance-tips.md
+++ b/doc/src/manual/performance-tips.md
@@ -1675,7 +1675,7 @@ as opposed to the later phase when it is first invoked. The parser does not "kno
 The magic of type inference takes place in the later phase of compilation.
 
 Thus, the parser does not know that `r` has a fixed type (`Int`).
-nor that `r` does not change value once the inner function is created (so that
+Nor that `r` does not change value once the inner function is created (so that
 the box is unneeded).  Therefore, the parser emits code for
 box that holds an object with an abstract type such as `Any`, which
 requires run-time type dispatch for each occurrence of `r`.  This can be

From be3bc9af09deb28e51c06854278ce4de099f500d Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Fri, 12 Apr 2024 11:08:10 -0400
Subject: [PATCH 1263/1315] Only run Test.jl precompilation workload when
 outputting (#54045)

These types of workloads are usually only run when generating output.
---
 stdlib/Test/src/precompile.jl | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/stdlib/Test/src/precompile.jl b/stdlib/Test/src/precompile.jl
index 2cb2fb7f3f0c6..1e53033a09143 100644
--- a/stdlib/Test/src/precompile.jl
+++ b/stdlib/Test/src/precompile.jl
@@ -1,9 +1,11 @@
-redirect_stdout(devnull) do
-    @testset "example" begin
-        @test 1 == 1
-        @test_throws ErrorException error()
-        @test_logs (:info, "Doing foo with n=2") @info "Doing foo with n=2"
-        @test_broken 1 == 2
-        @test 1 ≈ 1.0000000000000001
+if Base.generating_output()
+    redirect_stdout(devnull) do
+        @testset "example" begin
+            @test 1 == 1
+            @test_throws ErrorException error()
+            @test_logs (:info, "Doing foo with n=2") @info "Doing foo with n=2"
+            @test_broken 1 == 2
+            @test 1 ≈ 1.0000000000000001
+        end
     end
 end

From d47cbf65c520142bd6926f28aee8ba2a22bf0140 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Fri, 12 Apr 2024 21:22:51 -0400
Subject: [PATCH 1264/1315] Allow for querying of build_id from objects
 (#53943)

For GPUCompiler we would like to support a native on disk cache of LLVM
IR.
One of the longstanding issues has been the cache invalidation of such
an on disk cache.

With #52233 we now have an integrated cache for the inference results
and we can rely
on `CodeInstance` to be stable across sessions. Due to #52119 we can
also rely on the
`objectid` to be stable.

My inital thought was to key the native disk cache in GPUCompiler on the
objectid of
the corresponding CodeInstance (+ some compilation parameters).

While discussing this with @rayegun yesterday we noted that having a
CodeInstance with
the same objectid might not be enough provenance. E.g we are not
gurantueed that the
CodeInstance is from the same build artifact and the same precise source
code.

For the package images we are tracking this during loading and validate
all contents
at once, and we keep explicitly track of the provenance chain.

This PR adds a lookup up table where we map from "external_blobs" e.g.
loaded images,
to the corresponding top module of each image, and uses this to
determine the
build_id of the package image.
---
 base/loading.jl            |  8 ++++++++
 src/init.c                 |  1 +
 src/julia.h                |  1 +
 src/julia_internal.h       |  4 +++-
 src/staticdata.c           | 25 ++++++++++++++++++++++++-
 test/precompile.jl         |  8 ++++++++
 test/precompile_absint1.jl |  8 ++++++++
 test/precompile_absint2.jl |  8 ++++++++
 8 files changed, 61 insertions(+), 2 deletions(-)

diff --git a/base/loading.jl b/base/loading.jl
index ee6c47c7ce155..86cad6f2ed94d 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -3061,6 +3061,14 @@ function module_build_id(m::Module)
     return (UInt128(hi) << 64) | lo
 end
 
+function object_build_id(obj)
+    mod = ccall(:jl_object_top_module, Any, (Any,), obj)
+    if mod === nothing
+        return nothing
+    end
+    return module_build_id(mod::Module)
+end
+
 function isvalid_cache_header(f::IOStream)
     pkgimage = Ref{UInt8}()
     checksum = ccall(:jl_read_verify_header, UInt64, (Ptr{Cvoid}, Ptr{UInt8}, Ptr{Int64}, Ptr{Int64}), f.ios, pkgimage, Ref{Int64}(), Ref{Int64}()) # returns checksum id or zero
diff --git a/src/init.c b/src/init.c
index 2c1ad618948f8..41ec4c78b195d 100644
--- a/src/init.c
+++ b/src/init.c
@@ -826,6 +826,7 @@ JL_DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel)
 
     arraylist_new(&jl_linkage_blobs, 0);
     arraylist_new(&jl_image_relocs, 0);
+    arraylist_new(&jl_top_mods, 0);
     arraylist_new(&eytzinger_image_tree, 0);
     arraylist_new(&eytzinger_idxs, 0);
     arraylist_push(&eytzinger_idxs, (void*)0);
diff --git a/src/julia.h b/src/julia.h
index 8dc53b56785d3..e90e9653d2c85 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -2078,6 +2078,7 @@ JL_DLLEXPORT void jl_create_system_image(void **, jl_array_t *worklist, bool_t e
 JL_DLLEXPORT void jl_restore_system_image(const char *fname);
 JL_DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len);
 JL_DLLEXPORT jl_value_t *jl_restore_incremental(const char *fname, jl_array_t *depmods, int complete, const char *pkgimage);
+JL_DLLEXPORT jl_value_t *jl_object_top_module(jl_value_t* v) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT void jl_set_newly_inferred(jl_value_t *newly_inferred);
 JL_DLLEXPORT void jl_push_newly_inferred(jl_value_t *ci);
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 7df996d888909..9840da6b17448 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -333,6 +333,7 @@ void print_func_loc(JL_STREAM *s, jl_method_t *m);
 extern jl_array_t *_jl_debug_method_invalidation JL_GLOBALLY_ROOTED;
 JL_DLLEXPORT extern arraylist_t jl_linkage_blobs; // external linkage: sysimg/pkgimages
 JL_DLLEXPORT extern arraylist_t jl_image_relocs;  // external linkage: sysimg/pkgimages
+JL_DLLEXPORT extern arraylist_t jl_top_mods;  // external linkage: sysimg/pkgimages
 extern arraylist_t eytzinger_image_tree;
 extern arraylist_t eytzinger_idxs;
 
@@ -1012,7 +1013,8 @@ STATIC_INLINE size_t n_linkage_blobs(void) JL_NOTSAFEPOINT
 
 size_t external_blob_index(jl_value_t *v) JL_NOTSAFEPOINT;
 
-uint8_t jl_object_in_image(jl_value_t* v) JL_NOTSAFEPOINT;
+// Query if this object is perm-allocated in an image.
+JL_DLLEXPORT uint8_t jl_object_in_image(jl_value_t* v) JL_NOTSAFEPOINT;
 
 // the first argument to jl_idtable_rehash is used to return a value
 // make sure it is rooted if it is used after the function returns
diff --git a/src/staticdata.c b/src/staticdata.c
index 3e2aaf44d8a0d..a41d6b76586eb 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -337,6 +337,8 @@ static arraylist_t object_worklist;  // used to mimic recursion by jl_serialize_
 // jl_linkage_blobs.items[2i:2i+1] correspond to build_ids[i]   (0-offset indexing)
 arraylist_t jl_linkage_blobs;
 arraylist_t jl_image_relocs;
+// Keep track of which image corresponds to which top module.
+arraylist_t jl_top_mods;
 
 // Eytzinger tree of images. Used for very fast jl_object_in_image queries
 // See https://algorithmica.org/en/eytzinger
@@ -451,11 +453,23 @@ size_t external_blob_index(jl_value_t *v) JL_NOTSAFEPOINT
     return idx;
 }
 
-uint8_t jl_object_in_image(jl_value_t *obj) JL_NOTSAFEPOINT
+JL_DLLEXPORT uint8_t jl_object_in_image(jl_value_t *obj) JL_NOTSAFEPOINT
 {
     return eyt_obj_in_img(obj);
 }
 
+// Map an object to it's "owning" top module
+JL_DLLEXPORT jl_value_t *jl_object_top_module(jl_value_t* v) JL_NOTSAFEPOINT
+{
+    size_t idx = external_blob_index(v);
+    size_t lbids = n_linkage_blobs();
+    if (idx < lbids) {
+        return (jl_value_t*)jl_top_mods.items[idx];
+    }
+    // The object is runtime allocated
+    return (jl_value_t*)jl_nothing;
+}
+
 // hash of definitions for predefined function pointers
 static htable_t fptr_to_id;
 void *native_functions;   // opaque jl_native_code_desc_t blob used for fetching data from LLVM
@@ -3550,6 +3564,15 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
     arraylist_push(&jl_linkage_blobs, (void*)image_base);
     arraylist_push(&jl_linkage_blobs, (void*)(image_base + sizeof_sysimg));
     arraylist_push(&jl_image_relocs, (void*)relocs_base);
+    if (restored == NULL) {
+        arraylist_push(&jl_top_mods, (void*)jl_top_module);
+    } else {
+        size_t len = jl_array_nrows(*restored);
+        assert(len > 0);
+        jl_module_t *topmod = (jl_module_t*)jl_array_ptr_ref(*restored, len-1);
+        assert(jl_is_module(topmod));
+        arraylist_push(&jl_top_mods, (void*)topmod);
+    }
     jl_timing_counter_inc(JL_TIMING_COUNTER_ImageSize, sizeof_sysimg + sizeof(uintptr_t));
     rebuild_image_blob_tree();
 
diff --git a/test/precompile.jl b/test/precompile.jl
index a830a3af3ea7d..ffd6e24789aba 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -15,6 +15,11 @@ FooBase_module = :FooBase4b3a94a1a081a8cb
 end
 using .ConflictingBindings
 
+@testset "object_build_id" begin
+    @test Base.object_build_id([1]) === nothing
+    @test Base.object_build_id(Base) == Base.module_build_id(Base)
+end
+
 # method root provenance
 
 rootid(m::Module) = Base.module_build_id(Base.parentmodule(m)) % UInt64
@@ -350,6 +355,9 @@ precompile_test_harness(false) do dir
         @test objectid(Foo.a_vec_int) === Foo.oid_vec_int
         @test objectid(Foo.a_mat_int) === Foo.oid_mat_int
         @test Foo.oid_vec_int !== Foo.oid_mat_int
+        @test Base.object_build_id(Foo.a_vec_int) == Base.object_build_id(Foo.a_mat_int)
+        @test Base.object_build_id(Foo) == Base.module_build_id(Foo)
+        @test Base.object_build_id(Foo.a_vec_int) == Base.module_build_id(Foo)
     end
 
     @eval begin function ccallable_test()
diff --git a/test/precompile_absint1.jl b/test/precompile_absint1.jl
index f47b26bce9d94..7bc0382ffda85 100644
--- a/test/precompile_absint1.jl
+++ b/test/precompile_absint1.jl
@@ -44,10 +44,14 @@ precompile_test_harness() do load_path
             @test isdefined(ci, :next)
             @test ci.owner === nothing
             @test ci.max_world == typemax(UInt)
+            @test Base.module_build_id(TestAbsIntPrecompile1) ==
+                Base.object_build_id(ci)
             ci = ci.next
             @test !isdefined(ci, :next)
             @test ci.owner === cache_owner
             @test ci.max_world == typemax(UInt)
+            @test Base.module_build_id(TestAbsIntPrecompile1) ==
+                Base.object_build_id(ci)
         end
         let m = only(methods(sum, (Vector{Float64},)))
             found = false
@@ -57,10 +61,14 @@ precompile_test_harness() do load_path
                     @test isdefined(ci, :next)
                     @test ci.owner === cache_owner
                     @test ci.max_world == typemax(UInt)
+                    @test Base.module_build_id(TestAbsIntPrecompile1) ==
+                        Base.object_build_id(ci)
                     ci = ci.next
                     @test !isdefined(ci, :next)
                     @test ci.owner === nothing
                     @test ci.max_world == typemax(UInt)
+                    @test Base.module_build_id(TestAbsIntPrecompile1) ==
+                        Base.object_build_id(ci)
                     found = true
                     break
                 end
diff --git a/test/precompile_absint2.jl b/test/precompile_absint2.jl
index a7bf01debe861..066dcbaece4c4 100644
--- a/test/precompile_absint2.jl
+++ b/test/precompile_absint2.jl
@@ -67,10 +67,14 @@ precompile_test_harness() do load_path
             @test isdefined(ci, :next)
             @test ci.owner === nothing
             @test ci.max_world == typemax(UInt)
+            @test Base.module_build_id(TestAbsIntPrecompile2) ==
+                Base.object_build_id(ci)
             ci = ci.next
             @test !isdefined(ci, :next)
             @test ci.owner === cache_owner
             @test ci.max_world == typemax(UInt)
+            @test Base.module_build_id(TestAbsIntPrecompile2) ==
+                Base.object_build_id(ci)
         end
         let m = only(methods(sum, (Vector{Float64},)))
             found = false
@@ -80,10 +84,14 @@ precompile_test_harness() do load_path
                     @test isdefined(ci, :next)
                     @test ci.owner === cache_owner
                     @test ci.max_world == typemax(UInt)
+                    @test Base.module_build_id(TestAbsIntPrecompile2) ==
+                        Base.object_build_id(ci)
                     ci = ci.next
                     @test !isdefined(ci, :next)
                     @test ci.owner === nothing
                     @test ci.max_world == typemax(UInt)
+                    @test Base.module_build_id(TestAbsIntPrecompile2) ==
+                        Base.object_build_id(ci)
                     found = true
                     break
                 end

From 396abe4fdc8615e162462910bfc16729be7c95ed Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 12 Apr 2024 23:16:52 -0400
Subject: [PATCH 1265/1315] ir: Set refined when narrowing PhiNode in
 IncrementalCompact (#54061)

This is a bit of a tricky one. What happens here is that
IncrementalCompact finds that one branch of an if/else is dead, so one
of the incoming values of the PhiNode goes away. This may have the
effect of narrowing the type of the PhiNode (if the branches have
different types). In the latest iteration of our compiler, such
situations need to be annotated with IR_FLAG_REFINED or `Refined()`,
otherwise irinterp will skip them on revisit.

In theory, the fix is quite simple: Check whether the type is being
refined and if so, set the flag. However, this code sits inside
IncrementalCompcat, which currently neither performs lattice operations
nor sets any Refined flags by itself. The three possible options here
are:

1. Thread lattice through IncrementalCompact.
2. Use an egal check inside IncrementalCompact rather than the proper
lattice query. This is legal, but may overapproximate the need for
`Refined`, thus causing unnecessary work later.
3. Move the phi node narrowing outside of IncrementalCompact.

This PR takes a hybrid approach of 2 and 3. Approach 1 is undesirable,
because we do not want to recompile all of IncrementalCompact for every
lattice, just for this one query. I almost took approach 2, but it is
unsatisfying, because of the imprecision, which could cuase a lot of
extra work in pathological cases.

The primary downside of approach 3 is that now every pass that performs
IncrementalCompact with CFG manipulation enabled will need to call the
`reprocess_phi_node!` helper. We have two of these in base (adce_pass!
and `compact!(..., true)` although only the former as access to a
lattice.

The compromise I came up with here is to do the egality check, except
leaving the PhiNode in place when it fails rather than setting `Refined`
internally. I think this is ok. There's a bit of an issue with duplicate
work, because the first thing that the lattice check will do is check
for equality, but that only happens in the case where a refinement
actually is required, which is both rarer and profitable.

Finally, I'm pretty sure I've found this issue before, but I cannot find
any writeup on it, so if somebody remembers me writing it up somewhere,
please let me know so I can add appropriate cross references.

---------

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
---
 base/compiler/ssair/ir.jl     | 52 +++++++++++++++++++++++++++--------
 base/compiler/ssair/passes.jl |  7 ++++-
 test/compiler/irpasses.jl     | 16 +++++++++++
 3 files changed, 63 insertions(+), 12 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 222ec91f7c01a..aa7b7e7464da7 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1601,17 +1601,15 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
         end
 
         values = process_phinode_values(values, late_fixup, already_inserted_phi_arg, result_idx, ssa_rename, used_ssas, new_new_used_ssas, do_rename_ssa, mark_refined!)
-        # Don't remove the phi node if it is before the definition of its value
-        # because doing so can create forward references. This should only
-        # happen with dead loops, but can cause problems when optimization
-        # passes look at all code, dead or not. This check should be
-        # unnecessary when DCE can remove those dead loops entirely, so this is
-        # just to be safe.
-        before_def = isassigned(values, 1) && (v = values[1]; isa(v, OldSSAValue)) && idx < v.id
-        if length(edges) == 1 && isassigned(values, 1) && !before_def &&
-                length(cfg_transforms_enabled ?
-                    result_bbs[bb_rename_succ[active_bb]].preds :
-                    compact.ir.cfg.blocks[active_bb].preds) == 1
+
+        # Quick egality check for PhiNode that may be replaced with its incoming
+        # value without needing to set the `Refined` flag. We can't do the actual
+        # refinement check, because we do not have access to the lattice here.
+        # Users may call `reprocess_phi_node!` inside the compaction loop to
+        # revisit PhiNodes with the proper lattice refinement check.
+        if may_replace_phi(values, cfg_transforms_enabled ?
+                result_bbs[bb_rename_succ[active_bb]] :
+                compact.ir.cfg.blocks[active_bb], idx) && argextype(values[1], compact) === inst[:type]
             # There's only one predecessor left - just replace it
             v = values[1]
             @assert !isa(v, NewSSAValue)
@@ -1662,6 +1660,38 @@ function process_node!(compact::IncrementalCompact, result_idx::Int, inst::Instr
     return result_idx
 end
 
+function may_replace_phi(values::Vector{Any}, phi_bb::BasicBlock, idx::Int)
+    length(values) == 1 || return false
+    isassigned(values, 1) || return false
+    length(phi_bb.preds) == 1 || return false
+
+    # Don't remove the phi node if it is before the definition of its value
+    # because doing so can create forward references. This should only
+    # happen with dead loops, but can cause problems when optimization
+    # passes look at all code, dead or not. This check should be
+    # unnecessary when DCE can remove those dead loops entirely, so this is
+    # just to be safe.
+    v = values[1]
+    before_def = isa(v, OldSSAValue) && idx < v.id
+    return !before_def
+end
+
+function reprocess_phi_node!(𝕃ₒ::AbstractLattice, compact::IncrementalCompact, phi::PhiNode, old_idx::Int)
+    phi_bb = compact.active_result_bb
+    did_just_finish_bb(compact) && (phi_bb -= 1)
+    may_replace_phi(phi.values, compact.cfg_transform.result_bbs[phi_bb], compact.idx) || return false
+
+    # There's only one predecessor left - just replace it
+    v = phi.values[1]
+    if !⊑(𝕃ₒ, compact[compact.ssa_rename[old_idx]][:type], argextype(v, compact))
+        v = Refined(v)
+    end
+    compact.ssa_rename[old_idx] = v
+
+    delete_inst_here!(compact)
+    return true
+end
+
 function resize!(compact::IncrementalCompact, nnewnodes::Int)
     old_length = length(compact.result)
     resize!(compact.result, nnewnodes)
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 328f7164a7b93..8ccc366176765 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -2009,8 +2009,13 @@ function adce_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
     unionphis = Pair{Int,Any}[] # sorted
     compact = IncrementalCompact(ir, true)
     made_changes = false
-    for ((_, idx), stmt) in compact
+    for ((old_idx, idx), stmt) in compact
         if isa(stmt, PhiNode)
+            if reprocess_phi_node!(𝕃ₒ, compact, stmt, old_idx)
+                # Phi node has a single predecessor and was deleted
+                made_changes = true
+                continue
+            end
             push!(all_phis, idx)
             if is_some_union(compact.result[idx][:type])
                 push!(unionphis, Pair{Int,Any}(idx, Union{}))
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 4df4c699add09..808a4b8c9f1b4 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1820,3 +1820,19 @@ function f53521()
     end
 end
 @test code_typed(f53521)[1][2] === Nothing
+
+# Test that adce_pass! sets Refined on PhiNode values
+let code = Any[
+    # Basic Block 1
+    GotoIfNot(false, 3)
+    # Basic Block 2
+    nothing
+    # Basic Block 3
+    PhiNode(Int32[1, 2], Any[1.0, 1])
+    ReturnNode(Core.SSAValue(3))
+]
+    ir = make_ircode(code; ssavaluetypes=Any[Any, Nothing, Union{Int64, Float64}, Any])
+    (ir, made_changes) = Core.Compiler.adce_pass!(ir)
+    @test made_changes
+    @test (ir[Core.SSAValue(length(ir.stmts))][:flag] & Core.Compiler.IR_FLAG_REFINED) != 0
+end

From a7216586d3dc169b44e0cd141f08e4d09fd98791 Mon Sep 17 00:00:00 2001
From: Denis Barucic <barucden@fel.cvut.cz>
Date: Sat, 13 Apr 2024 15:12:27 +0200
Subject: [PATCH 1266/1315] clamp: Turn `ifelse` into ternary (#54038)

Fixes #54022

Co-authored-by: Klaus Crusius <KlausC@users.noreply.github.com>
---
 base/math.jl | 18 ++++++++++++------
 test/math.jl | 11 +++++++++++
 2 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/base/math.jl b/base/math.jl
index c3c15505c5f8f..c9ee4b81caafa 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -95,11 +95,10 @@ julia> clamp.([11, 8, 5], 10, 6)  # an example where lo > hi
  10
 ```
 """
-clamp(x::X, lo::L, hi::H) where {X,L,H} =
-    ifelse(x > hi, convert(promote_type(X,L,H), hi),
-           ifelse(x < lo,
-                  convert(promote_type(X,L,H), lo),
-                  convert(promote_type(X,L,H), x)))
+function clamp(x::X, lo::L, hi::H) where {X,L,H}
+    T = promote_type(X, L, H)
+    return (x > hi) ? convert(T, hi) : (x < lo) ? convert(T, lo) : convert(T, x)
+end
 
 """
     clamp(x, T)::T
@@ -120,7 +119,14 @@ julia> trunc(Int, 4pi^2)
 39
 ```
 """
-clamp(x, ::Type{T}) where {T<:Integer} = clamp(x, typemin(T), typemax(T)) % T
+function clamp(x, ::Type{T}) where {T<:Integer}
+    # delegating to clamp(x, typemin(T), typemax(T)) would promote types
+    # this way, we avoid unnecessary conversions
+    # think of, e.g., clamp(big(2) ^ 200, Int16)
+    lo = typemin(T)
+    hi = typemax(T)
+    return (x > hi) ? hi : (x < lo) ? lo : convert(T, x)
+end
 
 
 """
diff --git a/test/math.jl b/test/math.jl
index f551bb3a5d4b7..8306345b3d45f 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -47,6 +47,17 @@ has_fma = Dict(
         clamp!(x, 1, 3)
         @test x == [1.0, 1.0, 2.0, 3.0, 3.0]
     end
+
+    @test clamp(typemax(UInt64), Int64) === typemax(Int64)
+    @test clamp(typemin(Int), UInt64) === typemin(UInt64)
+    @test clamp(Int16(-1), UInt16) === UInt16(0)
+    @test clamp(-1, 2, UInt(0)) === UInt(2)
+    @test clamp(typemax(UInt16), Int16) === Int16(32767)
+
+    # clamp should not allocate a BigInt for typemax(Int16)
+    x = big(2) ^ 100
+    @test (@allocated clamp(x, Int16)) == 0
+
 end
 
 @testset "constants" begin

From b9aeafa171e13609b3d47f8a1d75d83c0148a991 Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <daniel.karrasch@posteo.de>
Date: Sat, 13 Apr 2024 22:07:01 +0200
Subject: [PATCH 1267/1315] Overload `Base.literal_pow` for `AbstractQ`
 (#54010)

---
 stdlib/LinearAlgebra/src/abstractq.jl  | 4 ++++
 stdlib/LinearAlgebra/test/abstractq.jl | 6 ++++++
 2 files changed, 10 insertions(+)

diff --git a/stdlib/LinearAlgebra/src/abstractq.jl b/stdlib/LinearAlgebra/src/abstractq.jl
index d6e251e620309..bf4064c907a2d 100644
--- a/stdlib/LinearAlgebra/src/abstractq.jl
+++ b/stdlib/LinearAlgebra/src/abstractq.jl
@@ -18,6 +18,10 @@ transpose(Q::AbstractQ{<:Real}) = AdjointQ(Q)
 transpose(Q::AbstractQ) = error("transpose not implemented for $(typeof(Q)). Consider using adjoint instead of transpose.")
 adjoint(adjQ::AdjointQ) = adjQ.Q
 
+(^)(Q::AbstractQ, p::Integer) = p < 0 ? power_by_squaring(inv(Q), -p) : power_by_squaring(Q, p)
+@inline Base.literal_pow(::typeof(^), Q::AbstractQ, ::Val{1}) = Q
+@inline Base.literal_pow(::typeof(^), Q::AbstractQ, ::Val{-1}) = inv(Q)
+
 # promotion with AbstractMatrix, at least for equal eltypes
 promote_rule(::Type{<:AbstractMatrix{T}}, ::Type{<:AbstractQ{T}}) where {T} =
     (@inline; Union{AbstractMatrix{T},AbstractQ{T}})
diff --git a/stdlib/LinearAlgebra/test/abstractq.jl b/stdlib/LinearAlgebra/test/abstractq.jl
index 19b872d685668..0eb88324e8c20 100644
--- a/stdlib/LinearAlgebra/test/abstractq.jl
+++ b/stdlib/LinearAlgebra/test/abstractq.jl
@@ -39,6 +39,12 @@ n = 5
         @test Q'*I ≈ Q.Q'*I rtol=2eps(real(T))
         @test I*Q ≈ Q.Q*I rtol=2eps(real(T))
         @test I*Q' ≈ I*Q.Q' rtol=2eps(real(T))
+        @test Q^3 ≈ Q*Q*Q
+        @test Q^2 ≈ Q*Q
+        @test Q^1 == Q
+        @test Q^(-1) == Q'
+        @test (Q')^(-1) == Q
+        @test (Q')^2 ≈ Q'*Q'
         @test abs(det(Q)) ≈ 1
         @test logabsdet(Q)[1] ≈ 0 atol=2n*eps(real(T))
         y = rand(T, n)

From 8d577ab3f24212a9762ad6673e8a8fb0ecd5a140 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 14 Apr 2024 20:21:22 +0530
Subject: [PATCH 1268/1315] `zeros`/`ones`/`fill` may accept arbitrary axes
 that are supported by `similar` (#53965)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The idea is that functions like `zeros` are essentially constructing a
container and filling it with a value. `similar` seems perfectly placed
to construct such a container, so we may accept arbitrary axes in
`zeros` as long as there's a corresponding `similar` method that is
defined for the axes. Packages therefore would only need to define
`similar`, and would get `zeros`/`ones` and `fill` for free. For
example, the following will work after this:
```julia
julia> using StaticArrays

julia> zeros(SOneTo(2), 2)
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

julia> zeros(SOneTo(2), Base.OneTo(2))
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0
```
Neither of these work on the current master, as `StaticArrays` doesn't
define `zeros` for these combinations, even though it does define
`similar`. One may argue for these methods to be added to
`StaticArrays`, but this seems to be adding redundancy.

The flip side is that `OffsetArrays` defines exactly these methods, so
adding them to `Base` would break precompilation for the package.
However, `OffsetArrays` really shouldn't be defining these methods, as
this is type-piracy. The methods may be version-limited in
`OffsetArrays` if this PR is merged.

On the face of it, `trues` and `falses` should also work similarly, but
currently these seem to be bypassing `similar` and constructing a
`BitArray` explicitly. I have not added the corresponding methods for
these functions, but they may be added as well.
---
 base/array.jl                   |  6 ++++++
 base/bitarray.jl                |  2 ++
 test/abstractarray.jl           | 22 ++++++++++++++++++++++
 test/bitarray.jl                | 22 ++++++++++++++++++++++
 test/testhelpers/SizedArrays.jl | 15 +++++++++++++++
 5 files changed, 67 insertions(+)

diff --git a/base/array.jl b/base/array.jl
index 7676b380923ee..fb702725b389a 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -529,6 +529,7 @@ function fill end
 fill(v, dims::DimOrInd...) = fill(v, dims)
 fill(v, dims::NTuple{N, Union{Integer, OneTo}}) where {N} = fill(v, map(to_dim, dims))
 fill(v, dims::NTuple{N, Integer}) where {N} = (a=Array{typeof(v),N}(undef, dims); fill!(a, v); a)
+fill(v, dims::NTuple{N, DimOrInd}) where {N} = (a=similar(Array{typeof(v),N}, dims); fill!(a, v); a)
 fill(v, dims::Tuple{}) = (a=Array{typeof(v),0}(undef, dims); fill!(a, v); a)
 
 """
@@ -589,6 +590,11 @@ for (fname, felt) in ((:zeros, :zero), (:ones, :one))
             fill!(a, $felt(T))
             return a
         end
+        function $fname(::Type{T}, dims::NTuple{N, DimOrInd}) where {T,N}
+            a = similar(Array{T,N}, dims)
+            fill!(a, $felt(T))
+            return a
+        end
     end
 end
 
diff --git a/base/bitarray.jl b/base/bitarray.jl
index 079dbefe03a94..f7eeafbb62231 100644
--- a/base/bitarray.jl
+++ b/base/bitarray.jl
@@ -404,6 +404,7 @@ falses(dims::DimOrInd...) = falses(dims)
 falses(dims::NTuple{N, Union{Integer, OneTo}}) where {N} = falses(map(to_dim, dims))
 falses(dims::NTuple{N, Integer}) where {N} = fill!(BitArray(undef, dims), false)
 falses(dims::Tuple{}) = fill!(BitArray(undef, dims), false)
+falses(dims::NTuple{N, DimOrInd}) where {N} = fill!(similar(BitArray, dims), false)
 
 """
     trues(dims)
@@ -422,6 +423,7 @@ trues(dims::DimOrInd...) = trues(dims)
 trues(dims::NTuple{N, Union{Integer, OneTo}}) where {N} = trues(map(to_dim, dims))
 trues(dims::NTuple{N, Integer}) where {N} = fill!(BitArray(undef, dims), true)
 trues(dims::Tuple{}) = fill!(BitArray(undef, dims), true)
+trues(dims::NTuple{N, DimOrInd}) where {N} = fill!(similar(BitArray, dims), true)
 
 function one(x::BitMatrix)
     m, n = size(x)
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index a0a6ba6b2229a..feb6adaf39fdd 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -11,6 +11,9 @@ using .Main.StructArrays
 isdefined(Main, :FillArrays) || @eval Main include("testhelpers/FillArrays.jl")
 using .Main.FillArrays
 
+isdefined(Main, :SizedArrays) || @eval Main include("testhelpers/SizedArrays.jl")
+using .Main.SizedArrays
+
 A = rand(5,4,3)
 @testset "Bounds checking" begin
     @test checkbounds(Bool, A, 1, 1, 1) == true
@@ -2097,3 +2100,22 @@ end
         @test r2[i] == z[j]
     end
 end
+
+@testset "zero for arbitrary axes" begin
+    r = SizedArrays.SOneTo(2)
+    s = Base.OneTo(2)
+    _to_oneto(x::Integer) = Base.OneTo(2)
+    _to_oneto(x::Union{Base.OneTo, SizedArrays.SOneTo}) = x
+    for (f, v) in ((zeros, 0), (ones, 1), ((x...)->fill(3,x...),3))
+        for ax in ((r,r), (s, r), (2, r))
+            A = f(ax...)
+            @test axes(A) == map(_to_oneto, ax)
+            if all(x -> x isa SizedArrays.SOneTo, ax)
+                @test A isa SizedArrays.SizedArray && parent(A) isa Array
+            else
+                @test A isa Array
+            end
+            @test all(==(v), A)
+        end
+    end
+end
diff --git a/test/bitarray.jl b/test/bitarray.jl
index 056a201bd4f6f..2cf285370441e 100644
--- a/test/bitarray.jl
+++ b/test/bitarray.jl
@@ -3,6 +3,9 @@
 using Base: findprevnot, findnextnot
 using Random, LinearAlgebra, Test
 
+isdefined(Main, :SizedArrays) || @eval Main include("testhelpers/SizedArrays.jl")
+using .Main.SizedArrays
+
 tc(r1::NTuple{N,Any}, r2::NTuple{N,Any}) where {N} = all(x->tc(x...), [zip(r1,r2)...])
 tc(r1::BitArray{N}, r2::Union{BitArray{N},Array{Bool,N}}) where {N} = true
 tc(r1::SubArray{Bool,N1,BitArray{N2}}, r2::SubArray{Bool,N1,<:Union{BitArray{N2},Array{Bool,N2}}}) where {N1,N2} = true
@@ -82,6 +85,25 @@ allsizes = [((), BitArray{0}), ((v1,), BitVector),
     @test !isassigned(b, length(b) + 1)
 end
 
+@testset "trues and falses with custom axes" begin
+    for ax in ((SizedArrays.SOneTo(2),), (SizedArrays.SOneTo(2), Base.OneTo(2)))
+        t = trues(ax)
+        if all(x -> x isa SizedArrays.SOneTo, ax)
+            @test t isa SizedArrays.SizedArray && parent(t) isa BitArray
+        else
+            @test t isa BitArray
+        end
+        @test all(t)
+
+        f = falses(ax)
+        if all(x -> x isa SizedArrays.SOneTo, ax)
+            @test t isa SizedArrays.SizedArray && parent(t) isa BitArray
+        else
+            @test t isa BitArray
+        end
+        @test !any(f)
+    end
+end
 
 @testset "Conversions for size $sz" for (sz, T) in allsizes
     b1 = rand!(falses(sz...))
diff --git a/test/testhelpers/SizedArrays.jl b/test/testhelpers/SizedArrays.jl
index 43bc27e630479..2d37cead61a08 100644
--- a/test/testhelpers/SizedArrays.jl
+++ b/test/testhelpers/SizedArrays.jl
@@ -43,10 +43,25 @@ Base.size(a::SizedArray) = size(typeof(a))
 Base.size(::Type{<:SizedArray{SZ}}) where {SZ} = SZ
 Base.axes(a::SizedArray) = map(SOneTo, size(a))
 Base.getindex(A::SizedArray, i...) = getindex(A.data, i...)
+Base.setindex!(A::SizedArray, v, i...) = setindex!(A.data, v, i...)
 Base.zero(::Type{T}) where T <: SizedArray = SizedArray{size(T)}(zeros(eltype(T), size(T)))
+Base.parent(S::SizedArray) = S.data
 +(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = SizedArray{SZ}(S1.data + S2.data)
 ==(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = S1.data == S2.data
 
+homogenize_shape(t::Tuple) = (_homogenize_shape(first(t)), homogenize_shape(Base.tail(t))...)
+homogenize_shape(::Tuple{}) = ()
+_homogenize_shape(x::Integer) = x
+_homogenize_shape(x::AbstractUnitRange) = length(x)
+const Dims = Union{Integer, Base.OneTo, SOneTo}
+function Base.similar(::Type{A}, shape::Tuple{Dims, Vararg{Dims}}) where {A<:AbstractArray}
+    similar(A, homogenize_shape(shape))
+end
+function Base.similar(::Type{A}, shape::Tuple{SOneTo, Vararg{SOneTo}}) where {A<:AbstractArray}
+    R = similar(A, length.(shape))
+    SizedArray{length.(shape)}(R)
+end
+
 const SizedMatrixLike = Union{SizedMatrix, Transpose{<:Any, <:SizedMatrix}, Adjoint{<:Any, <:SizedMatrix}}
 
 _data(S::SizedArray) = S.data

From c91edf3641a919c16eee87dcd771135ecf5067c7 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 14 Apr 2024 15:40:16 -0400
Subject: [PATCH 1269/1315] irinterp: Move irinterp va processing (#54076)

Currently we perform the va transform inside the innermost construct of
IRInterpretationState. However, I think it makes more sense to lift this
processing one level, so that the `argtypes` for the constructor that
takes `ir` matches `ir.argtypes`, while the one for the constructor that
takes `mi` is the full expanded out argtypes. NFC for base, but the `ir`
constructor is used in downstream external absints. However, I think
this way around is better for them also, since it's not always clear
what format the argtypes they have are in and the va direction is easy
and well supported, so it's better to have the option.
---
 base/compiler/inferencestate.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/compiler/inferencestate.jl b/base/compiler/inferencestate.jl
index 3f2ec4734cc21..169d543f3249c 100644
--- a/base/compiler/inferencestate.jl
+++ b/base/compiler/inferencestate.jl
@@ -802,7 +802,6 @@ mutable struct IRInterpretationState
             given_argtypes[i] = widenslotwrapper(argtypes[i])
         end
         if isa(mi.def, Method)
-            given_argtypes = va_process_argtypes(optimizer_lattice(interp), given_argtypes, mi)
             argtypes_refined = Bool[!⊑(optimizer_lattice(interp), ir.argtypes[i], given_argtypes[i])
                 for i = 1:length(given_argtypes)]
         else
@@ -832,6 +831,7 @@ function IRInterpretationState(interp::AbstractInterpreter,
     end
     method_info = MethodInfo(src)
     ir = inflate_ir(src, mi)
+    argtypes = va_process_argtypes(optimizer_lattice(interp), argtypes, mi)
     return IRInterpretationState(interp, method_info, ir, mi, argtypes, world,
                                  codeinst.min_world, codeinst.max_world)
 end

From 7e7e280c91b9a1074e2482a964a51923d3359c09 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Sun, 14 Apr 2024 15:40:36 -0400
Subject: [PATCH 1270/1315] reachability: Ignore virtual catch predecessor
 (#54077)

For catch blocks, we add a virtual `0` predecessor in addition to the
predecessor from the enter block. However, for reachability purposes,
only real predecessors count, so ignore that here.
---
 base/compiler/ssair/tarjan.jl | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/base/compiler/ssair/tarjan.jl b/base/compiler/ssair/tarjan.jl
index bc0500901fb03..3727fe218dc1d 100644
--- a/base/compiler/ssair/tarjan.jl
+++ b/base/compiler/ssair/tarjan.jl
@@ -247,6 +247,9 @@ function enqueue_if_unreachable!(reach::CFGReachability, cfg::CFG, bb::Int)
         # target is a reducible CFG node
         # this node lives iff it still has an incoming forward edge
         for pred in cfg.blocks[bb].preds
+            # virtual edge does not count - if the enter is dead, that edge is
+            # not taken.
+            pred == 0 && continue
             !dominates(domtree, bb, pred) && return false # forward-edge
         end
         scc[bb] = 0

From 98f47474d8369a72366e60bd8e94ef7011be6f3e Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 15 Apr 2024 13:40:47 +0900
Subject: [PATCH 1271/1315] optimizer: do not delete statements that may not
 `:terminate` (#52999)

Fixes #52991.
Currently this commit marks the test case added in #52954 as `broken`
since it has relied on the behavior of #52991.
I'm planning to add followup changes in a separate commit.
---
 base/compiler/optimize.jl | 13 +++++++----
 base/dict.jl              | 33 +++++++++++-----------------
 test/compiler/irpasses.jl | 45 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 66 insertions(+), 25 deletions(-)

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index fa1bf2f1ee152..675fe87582b0d 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -48,9 +48,9 @@ const IR_FLAG_INACCESSIBLEMEM_OR_ARGMEM = one(UInt32) << 11
 const NUM_IR_FLAGS = 12 # sync with julia.h
 
 const IR_FLAGS_EFFECTS =
-    IR_FLAG_CONSISTENT | IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW | IR_FLAG_NOUB
+    IR_FLAG_CONSISTENT | IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW | IR_FLAG_TERMINATES | IR_FLAG_NOUB
 
-const IR_FLAGS_REMOVABLE = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW
+const IR_FLAGS_REMOVABLE = IR_FLAG_EFFECT_FREE | IR_FLAG_NOTHROW | IR_FLAG_TERMINATES
 
 const IR_FLAGS_NEEDS_EA = IR_FLAG_EFIIMO | IR_FLAG_INACCESSIBLEMEM_OR_ARGMEM
 
@@ -69,6 +69,9 @@ function flags_for_effects(effects::Effects)
     if is_nothrow(effects)
         flags |= IR_FLAG_NOTHROW
     end
+    if is_terminates(effects)
+        flags |= IR_FLAG_TERMINATES
+    end
     if is_inaccessiblemem_or_argmemonly(effects)
         flags |= IR_FLAG_INACCESSIBLEMEM_OR_ARGMEM
     end
@@ -331,7 +334,8 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
             consistent = is_consistent(effects)
             effect_free = is_effect_free(effects)
             nothrow = is_nothrow(effects)
-            removable = effect_free & nothrow
+            terminates = is_terminates(effects)
+            removable = effect_free & nothrow & terminates
             return (consistent, removable, nothrow)
         elseif head === :new
             return new_expr_effect_flags(𝕃ₒ, args, src)
@@ -342,7 +346,8 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
             consistent = is_consistent(effects)
             effect_free = is_effect_free(effects)
             nothrow = is_nothrow(effects)
-            removable = effect_free & nothrow
+            terminates = is_terminates(effects)
+            removable = effect_free & nothrow & terminates
             return (consistent, removable, nothrow)
         elseif head === :new_opaque_closure
             length(args) < 4 && return (false, false, false)
diff --git a/base/dict.jl b/base/dict.jl
index c924e10ab4d6e..4a63ed364b64d 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -868,34 +868,25 @@ struct PersistentDict{K,V} <: AbstractDict{K,V}
     @noinline function KeyValue.set(::Type{PersistentDict{K, V}}, ::Nothing, key, val) where {K, V}
         new{K, V}(HAMT.HAMT{K, V}(key => val))
     end
-    @noinline @Base.assume_effects :effect_free function KeyValue.set(dict::PersistentDict{K, V}, key, val) where {K, V}
+    @noinline Base.@assume_effects :effect_free :terminates_globally KeyValue.set(
+        dict::PersistentDict{K, V}, key, val) where {K, V} = @inline _keyvalueset(dict, key, val)
+    @noinline Base.@assume_effects :nothrow :effect_free :terminates_globally KeyValue.set(
+        dict::PersistentDict{K, V}, key::K, val::V) where {K, V} = @inline _keyvalueset(dict, key, val)
+    global function _keyvalueset(dict::PersistentDict{K, V}, key, val) where {K, V}
         trie = dict.trie
         h = HAMT.HashState(key)
-        found, present, trie, i, bi, top, hs = HAMT.path(trie, key, h, #=persistent=# true)
+        found, present, trie, i, bi, top, hs = HAMT.path(trie, key, h, #=persistent=#true)
         HAMT.insert!(found, present, trie, i, bi, hs, val)
         return new{K, V}(top)
     end
-    @noinline @Base.assume_effects :nothrow :effect_free function KeyValue.set(dict::PersistentDict{K, V}, key::K, val::V) where {K, V}
+    @noinline Base.@assume_effects :effect_free :terminates_globally KeyValue.set(
+        dict::PersistentDict{K, V}, key) where {K, V} = @inline _keyvalueset(dict, key)
+    @noinline Base.@assume_effects :nothrow :effect_free :terminates_globally KeyValue.set(
+        dict::PersistentDict{K, V}, key::K) where {K, V} = @inline _keyvalueset(dict, key)
+    global function _keyvalueset(dict::PersistentDict{K, V}, key) where {K, V}
         trie = dict.trie
         h = HAMT.HashState(key)
-        found, present, trie, i, bi, top, hs = HAMT.path(trie, key, h, #=persistent=# true)
-        HAMT.insert!(found, present, trie, i, bi, hs, val)
-        return new{K, V}(top)
-    end
-    @noinline @Base.assume_effects :effect_free function KeyValue.set(dict::PersistentDict{K, V}, key) where {K, V}
-        trie = dict.trie
-        h = HAMT.HashState(key)
-        found, present, trie, i, bi, top, _ = HAMT.path(trie, key, h, #=persistent=# true)
-        if found && present
-            deleteat!(trie.data, i)
-            HAMT.unset!(trie, bi)
-        end
-        return new{K, V}(top)
-    end
-    @noinline @Base.assume_effects :nothrow :effect_free function KeyValue.set(dict::PersistentDict{K, V}, key::K) where {K, V}
-        trie = dict.trie
-        h = HAMT.HashState(key)
-        found, present, trie, i, bi, top, _ = HAMT.path(trie, key, h, #=persistent=# true)
+        found, present, trie, i, bi, top, _ = HAMT.path(trie, key, h, #=persistent=#true)
         if found && present
             deleteat!(trie.data, i)
             HAMT.unset!(trie, bi)
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index 808a4b8c9f1b4..b41241bf6a9a7 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -1836,3 +1836,48 @@ let code = Any[
     @test made_changes
     @test (ir[Core.SSAValue(length(ir.stmts))][:flag] & Core.Compiler.IR_FLAG_REFINED) != 0
 end
+
+# JuliaLang/julia#52991: statements that may not :terminate should not be deleted
+@noinline Base.@assume_effects :effect_free :nothrow function issue52991(n)
+    local s = 0
+    try
+        while true
+            yield()
+            if n - rand(1:10) > 0
+                s += 1
+            else
+                break
+            end
+        end
+    catch
+    end
+    return s
+end
+@test !Core.Compiler.is_removable_if_unused(Base.infer_effects(issue52991, (Int,)))
+let src = code_typed1((Int,)) do x
+        issue52991(x)
+        nothing
+    end
+    @test count(isinvoke(:issue52991), src.code) == 1
+end
+let t = @async begin
+        issue52991(11) # this call never terminates
+        nothing
+    end
+    sleep(1)
+    if istaskdone(t)
+        ok = false
+    else
+        ok = true
+        schedule(t, InterruptException(); error=true)
+    end
+    @test ok
+end
+
+# JuliaLang/julia47664
+@test !fully_eliminated() do
+    any(isone, Iterators.repeated(0))
+end
+@test !fully_eliminated() do
+    all(iszero, Iterators.repeated(0))
+end

From 7ba1b332f87b2fc959aa751423f7d4f393eb7b65 Mon Sep 17 00:00:00 2001
From: Lasse Peters <lasse.peters@mailbox.org>
Date: Mon, 15 Apr 2024 09:40:47 +0200
Subject: [PATCH 1272/1315] Don't use `do` as variable name in doc strings.
 (#53924)

---
 base/array.jl | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index fb702725b389a..db20eaa5794f2 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -275,13 +275,13 @@ function unsafe_copyto!(dest::Ptr{T}, src::Ptr{T}, n) where T
 end
 
 """
-    unsafe_copyto!(dest::Array, do, src::Array, so, N)
+    unsafe_copyto!(dest::Array, doffs, src::Array, soffs, n)
 
-Copy `N` elements from a source array to a destination, starting at the linear index `so` in the
-source and `do` in the destination (1-indexed).
+Copy `n` elements from a source array to a destination, starting at the linear index `soffs` in the
+source and `doffs` in the destination (1-indexed).
 
 The `unsafe` prefix on this function indicates that no validation is performed to ensure
-that N is inbounds on either array. Incorrect usage may corrupt or segfault your program, in
+that n is inbounds on either array. Incorrect usage may corrupt or segfault your program, in
 the same manner as C.
 """
 function unsafe_copyto!(dest::Array, doffs, src::Array, soffs, n)
@@ -291,10 +291,10 @@ function unsafe_copyto!(dest::Array, doffs, src::Array, soffs, n)
 end
 
 """
-    copyto!(dest, do, src, so, N)
+    copyto!(dest, doffs, src, soffs, n)
 
-Copy `N` elements from collection `src` starting at the linear index `so`, to array `dest` starting at
-the index `do`. Return `dest`.
+Copy `n` elements from collection `src` starting at the linear index `soffs`, to array `dest` starting at
+the index `doffs`. Return `dest`.
 """
 copyto!(dest::Array, doffs::Integer, src::Array, soffs::Integer, n::Integer) = _copyto_impl!(dest, doffs, src, soffs, n)
 copyto!(dest::Array, doffs::Integer, src::Memory, soffs::Integer, n::Integer) = _copyto_impl!(dest, doffs, src, soffs, n)

From 3dd07fd356c6b26a880aac9d73bda08600e2ca4c Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Mon, 15 Apr 2024 09:21:32 -0400
Subject: [PATCH 1273/1315] document that print(x) and repr(x) call 2-arg show
 (#53927)

As mentioned
[here](https://discourse.julialang.org/t/improving-doc-for-display-print-show-repr/69124/4),
the `print(x)` and `repr(x)` docstrings say that they default to calling
`show`, but don't specifically say that they call the 2-argument `show`.
(Probably because they pre-date the 3-argument `show`).
---
 base/strings/io.jl | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/base/strings/io.jl b/base/strings/io.jl
index 94b5a1e4e4614..ba577b5e3eaaf 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -10,10 +10,10 @@ if `io` is not given) a canonical (un-decorated) text representation.
 The representation used by `print` includes minimal formatting and tries to
 avoid Julia-specific details.
 
-`print` falls back to calling `show`, so most types should just define
-`show`. Define `print` if your type has a separate "plain" representation.
-For example, `show` displays strings with quotes, and `print` displays strings
-without quotes.
+`print` falls back to calling the 2-argument `show(io, x)` for each argument `x` in `xs`,
+so most types should just define `show`. Define `print` if your type has a separate
+"plain" representation.  For example, `show` displays strings with quotes, and `print`
+displays strings without quotes.
 
 See also [`println`](@ref), [`string`](@ref), [`printstyled`](@ref).
 
@@ -252,8 +252,8 @@ print(io::IO, s::Union{String,SubString{String}}) = (write(io, s); nothing)
 """
     repr(x; context=nothing)
 
-Create a string from any value using the [`show`](@ref) function.
-You should not add methods to `repr`; define a `show` method instead.
+Create a string from any value using the 2-argument `show(io, x)` function.
+You should not add methods to `repr`; define a [`show`](@ref) method instead.
 
 The optional keyword argument `context` can be set to a `:key=>value` pair, a
 tuple of `:key=>value` pairs, or an `IO` or [`IOContext`](@ref) object whose
@@ -262,7 +262,7 @@ attributes are used for the I/O stream passed to `show`.
 Note that `repr(x)` is usually similar to how the value of `x` would
 be entered in Julia.  See also [`repr(MIME("text/plain"), x)`](@ref) to instead
 return a "pretty-printed" version of `x` designed more for human consumption,
-equivalent to the REPL display of `x`.
+equivalent to the REPL display of `x`, using the 3-argument `show(io, mime, x)`.
 
 !!! compat "Julia 1.7"
     Passing a tuple to keyword `context` requires Julia 1.7 or later.

From 9de150c3b3289d5608614f68fd743cb409a24824 Mon Sep 17 00:00:00 2001
From: Rory Finnegan <rory.finnegan@gmail.com>
Date: Mon, 15 Apr 2024 06:22:04 -0700
Subject: [PATCH 1274/1315] fix cumsum ignoring first element returned in call
 to promote_op (#53461)

Include an option to have `promote_op` throw an error rather than return
`Union{}`. We're not changing the default behaviour, but in some cases
returning `Union{}` will result in less clear error messages.

Closes #53438

@LilithHafner may have comments
---
 base/accumulate.jl | 54 +++++++++++++++++++++++++++++++++++++++-------
 test/arrayops.jl   | 27 +++++++++++++++++++++++
 2 files changed, 73 insertions(+), 8 deletions(-)

diff --git a/base/accumulate.jl b/base/accumulate.jl
index a2d8a1d368d86..2748a4da481fa 100644
--- a/base/accumulate.jl
+++ b/base/accumulate.jl
@@ -33,7 +33,7 @@ function accumulate_pairwise!(op::Op, result::AbstractVector, v::AbstractVector)
 end
 
 function accumulate_pairwise(op, v::AbstractVector{T}) where T
-    out = similar(v, promote_op(op, T, T))
+    out = similar(v, _accumulate_promote_op(op, v))
     return accumulate_pairwise!(op, out, v)
 end
 
@@ -111,8 +111,8 @@ julia> cumsum(a, dims=2)
     widening happens and integer overflow results in `Int8[100, -128]`.
 """
 function cumsum(A::AbstractArray{T}; dims::Integer) where T
-    out = similar(A, promote_op(add_sum, T, T))
-    cumsum!(out, A, dims=dims)
+    out = similar(A, _accumulate_promote_op(add_sum, A))
+    return cumsum!(out, A, dims=dims)
 end
 
 """
@@ -280,14 +280,13 @@ function accumulate(op, A; dims::Union{Nothing,Integer}=nothing, kw...)
         # This branch takes care of the cases not handled by `_accumulate!`.
         return collect(Iterators.accumulate(op, A; kw...))
     end
+
     nt = values(kw)
-    if isempty(kw)
-        out = similar(A, promote_op(op, eltype(A), eltype(A)))
-    elseif keys(nt) === (:init,)
-        out = similar(A, promote_op(op, typeof(nt.init), eltype(A)))
-    else
+    if !(isempty(kw) || keys(nt) === (:init,))
         throw(ArgumentError("accumulate does not support the keyword arguments $(setdiff(keys(nt), (:init,)))"))
     end
+
+    out = similar(A, _accumulate_promote_op(op, A; kw...))
     accumulate!(op, out, A; dims=dims, kw...)
 end
 
@@ -442,3 +441,42 @@ function _accumulate1!(op, B, v1, A::AbstractVector, dim::Integer)
     end
     return B
 end
+
+# Internal function used to identify the widest possible eltype required for accumulate results
+function _accumulate_promote_op(op, v; init=nothing)
+    # Nested mock functions used to infer the widest necessary eltype
+    # NOTE: We are just passing this to promote_op for inference and should never be run.
+
+    # Initialization function used to identify initial type of `r`
+    # NOTE: reduce_first may have a different return type than calling `op`
+    function f(op, v, init)
+        val = first(something(iterate(v)))
+        return isnothing(init) ? Base.reduce_first(op, val) : op(init, val)
+    end
+
+    # Infer iteration type independent of the initialization type
+    # If `op` fails then this will return `Union{}` as `k` will be undefined.
+    # Returning `Union{}` is desirable as it won't break the `promote_type` call in the
+    # outer scope below
+    function g(op, v, r)
+        local k
+        for val in v
+            k = op(r, val)
+        end
+        return k
+    end
+
+    # Finally loop again with the two types promoted together
+    # If the `op` fails and reduce_first was used then then this will still just
+    # return the initial type, allowing the `op` to error during execution.
+    function h(op, v, r)
+        for val in v
+            r = op(r, val)
+        end
+        return r
+    end
+
+    R = Base.promote_op(f, typeof(op), typeof(v), typeof(init))
+    K = Base.promote_op(g, typeof(op), typeof(v), R)
+    return Base.promote_op(h, typeof(op), typeof(v), Base.promote_type(R, K))
+end
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 1c36453a6adae..b64d08264e2d1 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -2859,6 +2859,33 @@ end
     @inferred accumulate(*, String[])
     @test accumulate(*, ['a' 'b'; 'c' 'd'], dims=1) == ["a" "b"; "ac" "bd"]
     @test accumulate(*, ['a' 'b'; 'c' 'd'], dims=2) == ["a" "ab"; "c" "cd"]
+
+    # #53438
+    v = [(1, 2), (3, 4)]
+    @test_throws MethodError accumulate(+, v)
+    @test_throws MethodError cumsum(v)
+    @test_throws MethodError cumprod(v)
+    @test_throws MethodError accumulate(+, v; init=(0, 0))
+    @test_throws MethodError accumulate(+, v; dims=1, init=(0, 0))
+
+    # Some checks to ensure we're identifying the widest needed eltype
+    # as identified in PR 53461
+    @testset "Base._accumulate_promote_op" begin
+        # A somewhat contrived example where each call to `foo`
+        # will return a different type
+        foo(x::Bool, y::Int)::Int = x + y
+        foo(x::Int, y::Int)::Float64 = x + y
+        foo(x::Float64, y::Int)::ComplexF64 = x + y * im
+        foo(x::ComplexF64, y::Int)::String = string(x, "+", y)
+
+        v = collect(1:5)
+        @test Base._accumulate_promote_op(foo, v; init=true) === Base._accumulate_promote_op(foo, v) == Union{Float64, String, ComplexF64}
+        @test Base._accumulate_promote_op(/, v) === Base._accumulate_promote_op(/, v; init=0) == Float64
+        @test Base._accumulate_promote_op(+, v) === Base._accumulate_promote_op(+, v; init=0) === Int
+        @test Base._accumulate_promote_op(+, v; init=0.0) === Float64
+        @test Base._accumulate_promote_op(+, Union{Int, Missing}[v...]) === Union{Int, Missing}
+        @test Base._accumulate_promote_op(+, Union{Int, Nothing}[v...]) === Union{Int, Nothing}
+    end
 end
 
 struct F21666{T <: Base.ArithmeticStyle}

From c0611e8c49c8e279fd83ed57a395a3217ba1dc0c Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Mon, 15 Apr 2024 13:22:32 -0400
Subject: [PATCH 1275/1315] Allow PrecompileTools to see MI's inferred by
 foreign abstract interpreters (#54069)

Partially reverts https://github.com/JuliaLang/julia/pull/49391

PrecompileTools uses the timing infrastructure to snoop on the inference
process.
The reason for #49391 was that this could lead to accidental pollution
of the caches
with foreign results
(https://github.com/timholy/SnoopCompile.jl/issues/338)

After #52233 and especially #53336 we now filter results by cache owner
and
don't try to cache foreign code using the native pipeline.

Motivated by https://github.com/JuliaGPU/GPUCompiler.jl/pull/567 which
demonstrated
that a foreign code instance would not be cached without
PrecompileTools.
---
 base/compiler/typeinfer.jl | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 22b0afc9b03c1..d091fb8d2f5f8 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -204,9 +204,8 @@ If set to `true`, record per-method-instance timings within type inference in th
 __set_measure_typeinf(onoff::Bool) = __measure_typeinf__[] = onoff
 const __measure_typeinf__ = fill(false)
 
-# Wrapper around `_typeinf` that optionally records the exclusive time for
-# each inference performed by `NativeInterpreter`.
-function typeinf(interp::NativeInterpreter, frame::InferenceState)
+# Wrapper around `_typeinf` that optionally records the exclusive time for each invocation.
+function typeinf(interp::AbstractInterpreter, frame::InferenceState)
     if __measure_typeinf__[]
         Timings.enter_new_timer(frame)
         v = _typeinf(interp, frame)
@@ -216,7 +215,6 @@ function typeinf(interp::NativeInterpreter, frame::InferenceState)
         return _typeinf(interp, frame)
     end
 end
-typeinf(interp::AbstractInterpreter, frame::InferenceState) = _typeinf(interp, frame)
 
 function finish!(interp::AbstractInterpreter, caller::InferenceState)
     result = caller.result

From d8b9810b8908560cc4aaa744c0e587f4dfd11bfb Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 16 Apr 2024 09:07:54 +0900
Subject: [PATCH 1276/1315] set `@max_methods 2` for `error` (#54086)

---
 base/error.jl |  9 +++++++++
 test/error.jl | 12 ++++++++++++
 2 files changed, 21 insertions(+)

diff --git a/base/error.jl b/base/error.jl
index 07782fce5f52e..10cf6baf6350d 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -27,6 +27,15 @@ throw
 
 ## native julia error handling ##
 
+# This is `Experimental.@max_methods 2 function error end`, which is not available at this point in bootstrap.
+# NOTE It is important to always be able to infer the return type of `error` as `Union{}`,
+# but there's a hitch when a package globally sets `@max_methods 1` and it causes inference
+# for `error(::Any)` to fail (JuliaLang/julia#54029).
+# This definition site `@max_methods 2` setting overrides any global `@max_methods 1` settings
+# on package side, guaranteeing that return type inference on `error` is successful always.
+function error end
+typeof(error).name.max_methods = UInt8(2)
+
 """
     error(message::AbstractString)
 
diff --git a/test/error.jl b/test/error.jl
index 8cd9a07f6655e..5d5000333fd30 100644
--- a/test/error.jl
+++ b/test/error.jl
@@ -127,3 +127,15 @@ end
     visited = test_exceptions(Base)
     test_exceptions(Core, visited)
 end
+
+# inference quality test for `error`
+@test Base.infer_return_type(error, (Any,)) === Union{}
+@test Base.infer_return_type(xs->error(xs...), (Vector{Any},)) === Union{}
+module Issue54029
+export raise54029
+Base.Experimental.@max_methods 1
+raise54029(x) = error(x)
+end
+using .Issue54029
+@test Base.infer_return_type(raise54029, (Any,)) === Union{}
+@test Base.infer_return_type(xs->raise54029(xs...), (Vector{Any},)) === Union{}

From 7ee15d13855c9705d732dd22a4257dea65c4a611 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 16 Apr 2024 18:26:59 +0530
Subject: [PATCH 1277/1315] LinearAlgebra: fix copyto! with aliased arrays
 (#54044)

Fixes https://github.com/JuliaLang/julia/issues/39460 by ensuring that
the matrices are `unalias`ed before copying. Also added `dataids` and
`unaliascopy` for some of the wrapper types, which makes more such
`copyto!` operations with aliased matrices return correct results.
---
 stdlib/LinearAlgebra/src/hessenberg.jl  |  3 +++
 stdlib/LinearAlgebra/src/symmetric.jl   |  8 ++++++--
 stdlib/LinearAlgebra/src/triangular.jl  | 13 +++++++++----
 stdlib/LinearAlgebra/test/hessenberg.jl |  9 +++++++++
 stdlib/LinearAlgebra/test/symmetric.jl  | 15 +++++++++++++++
 stdlib/LinearAlgebra/test/triangular.jl | 10 ++++++++++
 6 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/hessenberg.jl b/stdlib/LinearAlgebra/src/hessenberg.jl
index f20d76e727b34..28c23be520775 100644
--- a/stdlib/LinearAlgebra/src/hessenberg.jl
+++ b/stdlib/LinearAlgebra/src/hessenberg.jl
@@ -66,6 +66,9 @@ similar(H::UpperHessenberg, ::Type{T}, dims::Dims{N}) where {T,N} = similar(H.da
 AbstractMatrix{T}(H::UpperHessenberg) where {T} = UpperHessenberg{T}(H)
 AbstractMatrix{T}(H::UpperHessenberg{T}) where {T} = copy(H)
 
+Base.dataids(A::UpperHessenberg) = Base.dataids(parent(A))
+Base.unaliascopy(A::UpperHessenberg) = UpperHessenberg(Base.unaliascopy(parent(A)))
+
 copy(H::UpperHessenberg) = UpperHessenberg(copy(H.data))
 real(H::UpperHessenberg{<:Real}) = H
 real(H::UpperHessenberg{<:Complex}) = UpperHessenberg(triu!(real(H.data),-1))
diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 07240fb9afb22..10b996ca49e36 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -269,6 +269,10 @@ end
     end
 end
 
+Base.dataids(A::HermOrSym) = Base.dataids(parent(A))
+Base.unaliascopy(A::Hermitian) = Hermitian(Base.unaliascopy(parent(A)), sym_uplo(A.uplo))
+Base.unaliascopy(A::Symmetric) = Symmetric(Base.unaliascopy(parent(A)), sym_uplo(A.uplo))
+
 _conjugation(::Symmetric) = transpose
 _conjugation(::Hermitian) = adjoint
 
@@ -345,7 +349,7 @@ function copyto!(dest::Symmetric, src::Symmetric)
     if src.uplo == dest.uplo
         copyto!(dest.data, src.data)
     else
-        transpose!(dest.data, src.data)
+        transpose!(dest.data, Base.unalias(dest.data, src.data))
     end
     return dest
 end
@@ -354,7 +358,7 @@ function copyto!(dest::Hermitian, src::Hermitian)
     if src.uplo == dest.uplo
         copyto!(dest.data, src.data)
     else
-        adjoint!(dest.data, src.data)
+        adjoint!(dest.data, Base.unalias(dest.data, src.data))
     end
     return dest
 end
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 9be82f8dab29a..a78e838654f37 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -43,6 +43,7 @@ for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular, :UnitUpperTr
         similar(A::$t, ::Type{T}, dims::Dims{N}) where {T,N} = similar(parent(A), T, dims)
 
         copy(A::$t) = $t(copy(A.data))
+        Base.unaliascopy(A::$t) = $t(Base.unaliascopy(A.data))
 
         real(A::$t{<:Real}) = A
         real(A::$t{<:Complex}) = (B = real(A.data); $t(B))
@@ -153,6 +154,8 @@ const UpperOrUnitUpperTriangular{T,S} = Union{UpperTriangular{T,S}, UnitUpperTri
 const LowerOrUnitLowerTriangular{T,S} = Union{LowerTriangular{T,S}, UnitLowerTriangular{T,S}}
 const UpperOrLowerTriangular{T,S} = Union{UpperOrUnitUpperTriangular{T,S}, LowerOrUnitLowerTriangular{T,S}}
 
+Base.dataids(A::UpperOrLowerTriangular) = Base.dataids(A.data)
+
 imag(A::UpperTriangular) = UpperTriangular(imag(A.data))
 imag(A::LowerTriangular) = LowerTriangular(imag(A.data))
 imag(A::UpperTriangular{<:Any,<:StridedMaybeAdjOrTransMat}) = imag.(A)
@@ -513,21 +516,23 @@ tr(A::UnitUpperTriangular) = size(A, 1) * oneunit(eltype(A))
 
 # copy and scale
 function copyto!(A::T, B::T) where {T<:Union{UpperTriangular,UnitUpperTriangular}}
-    checkbounds(A, axes(B)...)
+    @boundscheck checkbounds(A, axes(B)...)
     n = size(B,1)
+    B2 = Base.unalias(A, B)
     for j = 1:n
         for i = 1:(isa(B, UnitUpperTriangular) ? j-1 : j)
-            @inbounds A[i,j] = B[i,j]
+            @inbounds A[i,j] = B2[i,j]
         end
     end
     return A
 end
 function copyto!(A::T, B::T) where {T<:Union{LowerTriangular,UnitLowerTriangular}}
-    checkbounds(A, axes(B)...)
+    @boundscheck checkbounds(A, axes(B)...)
     n = size(B,1)
+    B2 = Base.unalias(A, B)
     for j = 1:n
         for i = (isa(B, UnitLowerTriangular) ? j+1 : j):n
-            @inbounds A[i,j] = B[i,j]
+            @inbounds A[i,j] = B2[i,j]
         end
     end
     return A
diff --git a/stdlib/LinearAlgebra/test/hessenberg.jl b/stdlib/LinearAlgebra/test/hessenberg.jl
index 39ae7ec83a5c3..73786682480cb 100644
--- a/stdlib/LinearAlgebra/test/hessenberg.jl
+++ b/stdlib/LinearAlgebra/test/hessenberg.jl
@@ -250,4 +250,13 @@ end
     @test axes(S) === (r,r)
 end
 
+@testset "copyto! with aliasing (#39460)" begin
+    M = Matrix(reshape(1:36, 6, 6))
+    A = UpperHessenberg(view(M, 1:5, 1:5))
+    A2 = copy(A)
+    B = UpperHessenberg(view(M, 2:6, 2:6))
+    @test copyto!(B, A) == A2
+end
+
+
 end # module TestHessenberg
diff --git a/stdlib/LinearAlgebra/test/symmetric.jl b/stdlib/LinearAlgebra/test/symmetric.jl
index d3b24ccf78b0b..255e4e398b446 100644
--- a/stdlib/LinearAlgebra/test/symmetric.jl
+++ b/stdlib/LinearAlgebra/test/symmetric.jl
@@ -975,4 +975,19 @@ end
     @test conj(H) == conj(Array(H))
 end
 
+@testset "copyto! with aliasing (#39460)" begin
+    M = Matrix(reshape(1:36, 6, 6))
+    @testset for T in (Symmetric, Hermitian), uploA in (:U, :L), uploB in (:U, :L)
+        A = T(view(M, 1:5, 1:5), uploA)
+        A2 = copy(A)
+        B = T(view(M, 2:6, 2:6), uploB)
+        @test copyto!(B, A) == A2
+
+        A = view(M, 2:4, 2:4)
+        B = T(view(M, 1:3, 1:3), uploB)
+        B2 = copy(B)
+        @test copyto!(A, B) == B2
+    end
+end
+
 end # module TestSymmetric
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index fba0c86c8a1eb..daed1e9ebab3f 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -1041,4 +1041,14 @@ end
     end
 end
 
+@testset "copyto! with aliasing (#39460)" begin
+    M = Matrix(reshape(1:36, 6, 6))
+    @testset for T in (UpperTriangular, LowerTriangular)
+        A = T(view(M, 1:5, 1:5))
+        A2 = copy(A)
+        B = T(view(M, 2:6, 2:6))
+        @test copyto!(B, A) == A2
+    end
+end
+
 end # module TestTriangular

From e5821b3220bb66d18beb2fcae70d40779ba737c3 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Tue, 16 Apr 2024 18:27:45 +0530
Subject: [PATCH 1278/1315] LinearAlgebra: replace internal broadcast indexing
 method by getindex (#54071)

Within the `@inbounds` annotation, these two should be equivalent, so we
may call the public method instead of the internal one. Performance
remains unchanged by this.
---
 .../LinearAlgebra/src/structuredbroadcast.jl  | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/structuredbroadcast.jl b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
index 476d9e3e5cd02..f2c35c8edcce4 100644
--- a/stdlib/LinearAlgebra/src/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/src/structuredbroadcast.jl
@@ -178,7 +178,7 @@ function copyto!(dest::Diagonal, bc::Broadcasted{<:StructuredMatrixStyle})
     axs = axes(dest)
     axes(bc) == axs || Broadcast.throwdm(axes(bc), axs)
     for i in axs[1]
-        dest.diag[i] = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i, i))
+        dest.diag[i] = @inbounds bc[CartesianIndex(i, i)]
     end
     return dest
 end
@@ -188,15 +188,15 @@ function copyto!(dest::Bidiagonal, bc::Broadcasted{<:StructuredMatrixStyle})
     axs = axes(dest)
     axes(bc) == axs || Broadcast.throwdm(axes(bc), axs)
     for i in axs[1]
-        dest.dv[i] = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i, i))
+        dest.dv[i] = @inbounds bc[CartesianIndex(i, i)]
     end
     if dest.uplo == 'U'
         for i = 1:size(dest, 1)-1
-            dest.ev[i] = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i, i+1))
+            dest.ev[i] = @inbounds bc[CartesianIndex(i, i+1)]
         end
     else
         for i = 1:size(dest, 1)-1
-            dest.ev[i] = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i+1, i))
+            dest.ev[i] = @inbounds bc[CartesianIndex(i+1, i)]
         end
     end
     return dest
@@ -207,11 +207,11 @@ function copyto!(dest::SymTridiagonal, bc::Broadcasted{<:StructuredMatrixStyle})
     axs = axes(dest)
     axes(bc) == axs || Broadcast.throwdm(axes(bc), axs)
     for i in axs[1]
-        dest.dv[i] = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i, i))
+        dest.dv[i] = @inbounds bc[CartesianIndex(i, i)]
     end
     for i = 1:size(dest, 1)-1
-        v = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i, i+1))
-        v == (@inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i+1, i))) || throw(ArgumentError(lazy"broadcasted assignment breaks symmetry between locations ($i, $(i+1)) and ($(i+1), $i)"))
+        v = @inbounds bc[CartesianIndex(i, i+1)]
+        v == (@inbounds bc[CartesianIndex(i+1, i)]) || throw(ArgumentError(lazy"broadcasted assignment breaks symmetry between locations ($i, $(i+1)) and ($(i+1), $i)"))
         dest.ev[i] = v
     end
     return dest
@@ -222,11 +222,11 @@ function copyto!(dest::Tridiagonal, bc::Broadcasted{<:StructuredMatrixStyle})
     axs = axes(dest)
     axes(bc) == axs || Broadcast.throwdm(axes(bc), axs)
     for i in axs[1]
-        dest.d[i] = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i, i))
+        dest.d[i] = @inbounds bc[CartesianIndex(i, i)]
     end
     for i = 1:size(dest, 1)-1
-        dest.du[i] = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i, i+1))
-        dest.dl[i] = @inbounds Broadcast._broadcast_getindex(bc, CartesianIndex(i+1, i))
+        dest.du[i] = @inbounds bc[CartesianIndex(i, i+1)]
+        dest.dl[i] = @inbounds bc[CartesianIndex(i+1, i)]
     end
     return dest
 end
@@ -237,7 +237,7 @@ function copyto!(dest::LowerTriangular, bc::Broadcasted{<:StructuredMatrixStyle}
     axes(bc) == axs || Broadcast.throwdm(axes(bc), axs)
     for j in axs[2]
         for i in j:axs[1][end]
-            @inbounds dest.data[i,j] = Broadcast._broadcast_getindex(bc, CartesianIndex(i, j))
+            @inbounds dest.data[i,j] = bc[CartesianIndex(i, j)]
         end
     end
     return dest
@@ -249,7 +249,7 @@ function copyto!(dest::UpperTriangular, bc::Broadcasted{<:StructuredMatrixStyle}
     axes(bc) == axs || Broadcast.throwdm(axes(bc), axs)
     for j in axs[2]
         for i in 1:j
-            @inbounds dest.data[i,j] = Broadcast._broadcast_getindex(bc, CartesianIndex(i, j))
+            @inbounds dest.data[i,j] = bc[CartesianIndex(i, j)]
         end
     end
     return dest

From a82a28f6c3d0775f917cca25e86ccbd42b3daa77 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 16 Apr 2024 23:27:37 +0900
Subject: [PATCH 1279/1315] newinterp: add external cache mode (#54074)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When working on debugging inference behavior or performance tuning,
having direct access to inspect the global cache can be really handy.
Right now, `@newinterp` utilizes the `Core.Compiler.InternalCodeCache`
for its global caching, which doesn’t allow for such inspections. This
commit introduces the `@newinterp NewInterp cache_externally=true`
option. This enhancement allows `NewInterp` to store `CodeInstance` in
an external cache whose type is `IdDict{MethodInstance, CodeInstance}`.
---
 test/compiler/AbstractInterpreter.jl | 17 +++++++++++++
 test/compiler/newinterp.jl           | 37 ++++++++++++++++++++++++----
 2 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/test/compiler/AbstractInterpreter.jl b/test/compiler/AbstractInterpreter.jl
index e6691b3373259..bd7adc4be7639 100644
--- a/test/compiler/AbstractInterpreter.jl
+++ b/test/compiler/AbstractInterpreter.jl
@@ -514,3 +514,20 @@ let src = code_typed((Int,); interp=CustomDataInterp()) do x
     @test count(isinvoke(:cos), src.code) == 1
     @test count(isinvoke(:+), src.code) == 0
 end
+
+# ephemeral cache mode
+@newinterp DebugInterp #=ephemeral_cache=#true
+func_ext_cache1(a) = func_ext_cache2(a) * cos(a)
+func_ext_cache2(a) = sin(a)
+let interp = DebugInterp()
+    @test Base.infer_return_type(func_ext_cache1, (Float64,); interp) === Float64
+    @test isdefined(interp, :code_cache)
+    found = false
+    for (mi, codeinst) in interp.code_cache.dict
+        if mi.def.name === :func_ext_cache2
+            found = true
+            break
+        end
+    end
+    @test found
+end
diff --git a/test/compiler/newinterp.jl b/test/compiler/newinterp.jl
index 74a2b29cabc28..d86a1831def79 100644
--- a/test/compiler/newinterp.jl
+++ b/test/compiler/newinterp.jl
@@ -3,29 +3,49 @@
 # TODO set up a version who defines new interpreter with persistent cache?
 
 """
-    @newinterp NewInterpreter
+    @newinterp NewInterpreter [ephemeral_cache::Bool=false]
 
 Defines new `NewInterpreter <: AbstractInterpreter` whose cache is separated
 from the native code cache, satisfying the minimum interface requirements.
+
+When the `ephemeral_cache=true` option is specified, `NewInterpreter` will hold
+`CodeInstance` in an ephemeral non-integrated cache, rather than in the integrated
+`Core.Compiler.InternalCodeCache`.
+Keep in mind that ephemeral cache lacks support for invalidation and doesn't persist across
+sessions. However it is an usual Julia object of the type `code_cache::IdDict{MethodInstance,CodeInstance}`,
+making it easier for debugging and inspecting the compiler behavior.
 """
-macro newinterp(InterpName)
-    cache_token = QuoteNode(gensym(string(InterpName, "Cache")))
+macro newinterp(InterpName, ephemeral_cache::Bool=false)
+    cache_token = QuoteNode(gensym(string(InterpName, "CacheToken")))
+    InterpCacheName = esc(Symbol(string(InterpName, "Cache")))
     InterpName = esc(InterpName)
     C = Core
     CC = Core.Compiler
     quote
+        $(ephemeral_cache && quote
+        struct $InterpCacheName
+            dict::IdDict{$C.MethodInstance,$C.CodeInstance}
+        end
+        $InterpCacheName() = $InterpCacheName(IdDict{$C.MethodInstance,$C.CodeInstance}())
+        end)
         struct $InterpName <: $CC.AbstractInterpreter
             meta # additional information
             world::UInt
             inf_params::$CC.InferenceParams
             opt_params::$CC.OptimizationParams
             inf_cache::Vector{$CC.InferenceResult}
+            $(ephemeral_cache && :(code_cache::$InterpCacheName))
             function $InterpName(meta = nothing;
                                  world::UInt = Base.get_world_counter(),
                                  inf_params::$CC.InferenceParams = $CC.InferenceParams(),
                                  opt_params::$CC.OptimizationParams = $CC.OptimizationParams(),
-                                 inf_cache::Vector{$CC.InferenceResult} = $CC.InferenceResult[])
-                return new(meta, world, inf_params, opt_params, inf_cache)
+                                 inf_cache::Vector{$CC.InferenceResult} = $CC.InferenceResult[],
+                                 $(ephemeral_cache ?
+                                    Expr(:kw, :(code_cache::$InterpCacheName), :($InterpCacheName())) :
+                                    Expr(:kw, :_, :nothing)))
+                return $(ephemeral_cache ?
+                    :(new(meta, world, inf_params, opt_params, inf_cache, code_cache)) :
+                    :(new(meta, world, inf_params, opt_params, inf_cache)))
             end
         end
         $CC.InferenceParams(interp::$InterpName) = interp.inf_params
@@ -33,5 +53,12 @@ macro newinterp(InterpName)
         $CC.get_inference_world(interp::$InterpName) = interp.world
         $CC.get_inference_cache(interp::$InterpName) = interp.inf_cache
         $CC.cache_owner(::$InterpName) = $cache_token
+        $(ephemeral_cache && quote
+        $CC.code_cache(interp::$InterpName) = $CC.WorldView(interp.code_cache, $CC.WorldRange(interp.world))
+        $CC.get(wvc::$CC.WorldView{$InterpCacheName}, mi::$C.MethodInstance, default) = get(wvc.cache.dict, mi, default)
+        $CC.getindex(wvc::$CC.WorldView{$InterpCacheName}, mi::$C.MethodInstance) = getindex(wvc.cache.dict, mi)
+        $CC.haskey(wvc::$CC.WorldView{$InterpCacheName}, mi::$C.MethodInstance) = haskey(wvc.cache.dict, mi)
+        $CC.setindex!(wvc::$CC.WorldView{$InterpCacheName}, ci::$C.CodeInstance, mi::$C.MethodInstance) = setindex!(wvc.cache.dict, ci, mi)
+        end)
     end
 end

From 13d4f0e1caa950ee13c2cb1ad022c665e9d668d3 Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Tue, 16 Apr 2024 14:24:54 -0400
Subject: [PATCH 1280/1315] remove hand-coded methods for (U)Int128 on 32 bit
 systems (#53867)

I believe this code existed to work around bugs that LLVM used to have
with 128 bit numbers on 32 bit systems, but I'm not entirely sure.
---
 base/int.jl | 164 ++--------------------------------------------------
 1 file changed, 6 insertions(+), 158 deletions(-)

diff --git a/base/int.jl b/base/int.jl
index 61576d4360835..a25b17e2cc958 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -843,166 +843,14 @@ widemul(x::Bool,y::Number) = x * y
 widemul(x::Number,y::Bool) = x * y
 
 
-## wide multiplication, Int128 multiply and divide ##
-
-if Core.sizeof(Int) == 4
-    function widemul(u::Int64, v::Int64)
-        local u0::UInt64, v0::UInt64, w0::UInt64
-        local u1::Int64, v1::Int64, w1::UInt64, w2::Int64, t::UInt64
-
-        u0 = u & 0xffffffff; u1 = u >> 32
-        v0 = v & 0xffffffff; v1 = v >> 32
-        w0 = u0 * v0
-        t = reinterpret(UInt64, u1) * v0 + (w0 >>> 32)
-        w2 = reinterpret(Int64, t) >> 32
-        w1 = u0 * reinterpret(UInt64, v1) + (t & 0xffffffff)
-        hi = u1 * v1 + w2 + (reinterpret(Int64, w1) >> 32)
-        lo = w0 & 0xffffffff + (w1 << 32)
-        return Int128(hi) << 64 + Int128(lo)
-    end
-
-    function widemul(u::UInt64, v::UInt64)
-        local u0::UInt64, v0::UInt64, w0::UInt64
-        local u1::UInt64, v1::UInt64, w1::UInt64, w2::UInt64, t::UInt64
-
-        u0 = u & 0xffffffff; u1 = u >>> 32
-        v0 = v & 0xffffffff; v1 = v >>> 32
-        w0 = u0 * v0
-        t = u1 * v0 + (w0 >>> 32)
-        w2 = t >>> 32
-        w1 = u0 * v1 + (t & 0xffffffff)
-        hi = u1 * v1 + w2 + (w1 >>> 32)
-        lo = w0 & 0xffffffff + (w1 << 32)
-        return UInt128(hi) << 64 + UInt128(lo)
-    end
-
-    function *(u::Int128, v::Int128)
-        u0 = u % UInt64; u1 = Int64(u >> 64)
-        v0 = v % UInt64; v1 = Int64(v >> 64)
-        lolo = widemul(u0, v0)
-        lohi = widemul(reinterpret(Int64, u0), v1)
-        hilo = widemul(u1, reinterpret(Int64, v0))
-        t = reinterpret(UInt128, hilo) + (lolo >>> 64)
-        w1 = reinterpret(UInt128, lohi) + (t & 0xffffffffffffffff)
-        return Int128(lolo & 0xffffffffffffffff) + reinterpret(Int128, w1) << 64
-    end
-
-    function *(u::UInt128, v::UInt128)
-        u0 = u % UInt64; u1 = UInt64(u>>>64)
-        v0 = v % UInt64; v1 = UInt64(v>>>64)
-        lolo = widemul(u0, v0)
-        lohi = widemul(u0, v1)
-        hilo = widemul(u1, v0)
-        t = hilo + (lolo >>> 64)
-        w1 = lohi + (t & 0xffffffffffffffff)
-        return (lolo & 0xffffffffffffffff) + UInt128(w1) << 64
-    end
-
-    function _setbit(x::UInt128, i)
-        # faster version of `return x | (UInt128(1) << i)`
-        j = i >> 5
-        y = UInt128(one(UInt32) << (i & 0x1f))
-        if j == 0
-            return x | y
-        elseif j == 1
-            return x | (y << 32)
-        elseif j == 2
-            return x | (y << 64)
-        elseif j == 3
-            return x | (y << 96)
-        end
-        return x
-    end
+# Int128 multiply and divide
+*(x::T, y::T) where {T<:Union{Int128,UInt128}}  = mul_int(x, y)
 
-    function divrem(x::UInt128, y::UInt128)
-        iszero(y) && throw(DivideError())
-        if (x >> 64) % UInt64 == 0
-            if (y >> 64) % UInt64 == 0
-                # fast path: upper 64 bits are zero, so we can fallback to UInt64 division
-                q64, x64 = divrem(x % UInt64, y % UInt64)
-                return UInt128(q64), UInt128(x64)
-            else
-                # this implies y>x, so
-                return zero(UInt128), x
-            end
-        end
-        n = leading_zeros(y) - leading_zeros(x)
-        q = zero(UInt128)
-        ys = y << n
-        while n >= 0
-            # ys == y * 2^n
-            if ys <= x
-                x -= ys
-                q = _setbit(q, n)
-                if (x >> 64) % UInt64 == 0
-                    # exit early, similar to above fast path
-                    if (y >> 64) % UInt64 == 0
-                        q64, x64 = divrem(x % UInt64, y % UInt64)
-                        q |= q64
-                        x = UInt128(x64)
-                    end
-                    return q, x
-                end
-            end
-            ys >>>= 1
-            n -= 1
-        end
-        return q, x
-    end
+div(x::Int128,  y::Int128)  = checked_sdiv_int(x, y)
+div(x::UInt128, y::UInt128) = checked_udiv_int(x, y)
 
-    function div(x::Int128, y::Int128)
-        (x == typemin(Int128)) & (y == -1) && throw(DivideError())
-        return Int128(div(BigInt(x), BigInt(y)))::Int128
-    end
-    div(x::UInt128, y::UInt128) = divrem(x, y)[1]
-
-    function rem(x::Int128, y::Int128)
-        return Int128(rem(BigInt(x), BigInt(y)))::Int128
-    end
-
-    function rem(x::UInt128, y::UInt128)
-        iszero(y) && throw(DivideError())
-        if (x >> 64) % UInt64 == 0
-            if (y >> 64) % UInt64 == 0
-                # fast path: upper 64 bits are zero, so we can fallback to UInt64 division
-                return UInt128(rem(x % UInt64, y % UInt64))
-            else
-                # this implies y>x, so
-                return x
-            end
-        end
-        n = leading_zeros(y) - leading_zeros(x)
-        ys = y << n
-        while n >= 0
-            # ys == y * 2^n
-            if ys <= x
-                x -= ys
-                if (x >> 64) % UInt64 == 0
-                    # exit early, similar to above fast path
-                    if (y >> 64) % UInt64 == 0
-                        x = UInt128(rem(x % UInt64, y % UInt64))
-                    end
-                    return x
-                end
-            end
-            ys >>>= 1
-            n -= 1
-        end
-        return x
-    end
-
-    function mod(x::Int128, y::Int128)
-        return Int128(mod(BigInt(x), BigInt(y)))::Int128
-    end
-else
-    *(x::T, y::T) where {T<:Union{Int128,UInt128}}  = mul_int(x, y)
-
-    div(x::Int128,  y::Int128)  = checked_sdiv_int(x, y)
-    div(x::UInt128, y::UInt128) = checked_udiv_int(x, y)
-
-    rem(x::Int128,  y::Int128)  = checked_srem_int(x, y)
-    rem(x::UInt128, y::UInt128) = checked_urem_int(x, y)
-end
+rem(x::Int128,  y::Int128)  = checked_srem_int(x, y)
+rem(x::UInt128, y::UInt128) = checked_urem_int(x, y)
 
 # issue #15489: since integer ops are unchecked, they shouldn't check promotion
 for op in (:+, :-, :*, :&, :|, :xor)

From fb3ae0191d5c54336c58603cd74ee4003ef7f703 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 16 Apr 2024 15:23:19 -0400
Subject: [PATCH 1281/1315] inference correctness: fields and globals can
 revert to undef (#53750)

Particularly under precompilation, fields and globals can revert to
being undef, which is heavily relied upon by many `__init__` methods in
the ecosystem (because JLL emits this pattern, so we cannot simply
disallow it).

While here, also fix and improve several places where we compute or use
the isdefined check poorly.
---
 base/compiler/abstractinterpretation.jl | 28 ++++----
 base/compiler/optimize.jl               |  3 +-
 base/compiler/tfuncs.jl                 | 85 ++++++++++---------------
 src/codegen.cpp                         | 22 +++----
 test/compiler/effects.jl                | 64 +++++++++----------
 5 files changed, 86 insertions(+), 116 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 930439ad3500b..4ab512038b54e 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2603,6 +2603,7 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         t = Bool
         effects = EFFECTS_TOTAL
         exct = Union{}
+        isa(sym, Symbol) && (sym = GlobalRef(frame_module(sv), sym))
         if isa(sym, SlotNumber) && vtypes !== nothing
             vtyp = vtypes[slot_id(sym)]
             if vtyp.typ === Bottom
@@ -2610,19 +2611,11 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
             elseif !vtyp.undef
                 t = Const(true) # definitely assigned previously
             end
-        elseif isa(sym, Symbol)
-            if isdefined(frame_module(sv), sym)
-                t = Const(true)
-            elseif InferenceParams(interp).assume_bindings_static
-                t = Const(false)
-            else
-                effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE)
-            end
         elseif isa(sym, GlobalRef)
-            if isdefined(sym.mod, sym.name)
+            if InferenceParams(interp).assume_bindings_static
+                t = Const(isdefined_globalref(sym))
+            elseif isdefinedconst_globalref(sym)
                 t = Const(true)
-            elseif InferenceParams(interp).assume_bindings_static
-                t = Const(false)
             else
                 effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE)
             end
@@ -2819,9 +2812,10 @@ function override_effects(effects::Effects, override::EffectsOverride)
 end
 
 isdefined_globalref(g::GlobalRef) = !iszero(ccall(:jl_globalref_boundp, Cint, (Any,), g))
+isdefinedconst_globalref(g::GlobalRef) = isconst(g) && isdefined_globalref(g)
 
 function abstract_eval_globalref_type(g::GlobalRef)
-    if isdefined_globalref(g) && isconst(g)
+    if isdefinedconst_globalref(g)
         return Const(ccall(:jl_get_globalref_value, Any, (Any,), g))
     end
     ty = ccall(:jl_get_binding_type, Any, (Any, Any), g.mod, g.name)
@@ -2840,11 +2834,15 @@ function abstract_eval_globalref(interp::AbstractInterpreter, g::GlobalRef, sv::
         if is_mutation_free_argtype(rt)
             inaccessiblememonly = ALWAYS_TRUE
         end
-    elseif isdefined_globalref(g)
-        nothrow = true
     elseif InferenceParams(interp).assume_bindings_static
         consistent = inaccessiblememonly = ALWAYS_TRUE
-        rt = Union{}
+        if isdefined_globalref(g)
+            nothrow = true
+        else
+            rt = Union{}
+        end
+    elseif isdefinedconst_globalref(g)
+        nothrow = true
     end
     return RTEffects(rt, nothrow ? Union{} : UndefVarError, Effects(EFFECTS_TOTAL; consistent, nothrow, inaccessiblememonly))
 end
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 675fe87582b0d..1428d4b5ec34f 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -301,8 +301,7 @@ function stmt_effect_flags(𝕃ₒ::AbstractLattice, @nospecialize(stmt), @nospe
     isa(stmt, GotoNode) && return (true, false, true)
     isa(stmt, GotoIfNot) && return (true, false, ⊑(𝕃ₒ, argextype(stmt.cond, src), Bool))
     if isa(stmt, GlobalRef)
-        nothrow = isdefined(stmt.mod, stmt.name)
-        consistent = nothrow && isconst(stmt.mod, stmt.name)
+        nothrow = consistent = isdefinedconst_globalref(stmt)
         return (consistent, nothrow, nothrow)
     elseif isa(stmt, Expr)
         (; head, args) = stmt
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 07fb621554049..24450c4bd9952 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -392,20 +392,13 @@ end
     return isdefined_tfunc(𝕃, arg1, sym)
 end
 @nospecs function isdefined_tfunc(𝕃::AbstractLattice, arg1, sym)
-    if isa(arg1, Const)
-        arg1t = typeof(arg1.val)
-    else
-        arg1t = widenconst(arg1)
-    end
-    if isType(arg1t)
-        return Bool
-    end
+    arg1t = arg1 isa Const ? typeof(arg1.val) : isconstType(arg1) ? typeof(arg1.parameters[1]) : widenconst(arg1)
     a1 = unwrap_unionall(arg1t)
     if isa(a1, DataType) && !isabstracttype(a1)
         if a1 === Module
             hasintersect(widenconst(sym), Symbol) || return Bottom
             if isa(sym, Const) && isa(sym.val, Symbol) && isa(arg1, Const) &&
-               isdefined(arg1.val::Module, sym.val::Symbol)
+               isdefinedconst_globalref(GlobalRef(arg1.val::Module, sym.val::Symbol))
                 return Const(true)
             end
         elseif isa(sym, Const)
@@ -431,9 +424,8 @@ end
             elseif idx <= 0 || (!isvatuple(a1) && idx > fieldcount(a1))
                 return Const(false)
             elseif isa(arg1, Const)
-                arg1v = (arg1::Const).val
-                if !ismutable(arg1v) || isdefined(arg1v, idx) || isconst(typeof(arg1v), idx)
-                    return Const(isdefined(arg1v, idx))
+                if !ismutabletype(a1) || isconst(a1, idx)
+                    return Const(isdefined(arg1.val, idx))
                 end
             elseif !isvatuple(a1)
                 fieldT = fieldtype(a1, idx)
@@ -990,7 +982,7 @@ end
     # If we have s00 being a const, we can potentially refine our type-based analysis above
     if isa(s00, Const) || isconstType(s00)
         if !isa(s00, Const)
-            sv = s00.parameters[1]
+            sv = (s00::DataType).parameters[1]
         else
             sv = s00.val
         end
@@ -1000,15 +992,16 @@ end
                 isa(sv, Module) && return false
                 isa(nval, Int) || return false
             end
-            return isdefined(sv, nval)
+            return isdefined_tfunc(𝕃, s00, name) === Const(true)
         end
         boundscheck && return false
         # If bounds checking is disabled and all fields are assigned,
         # we may assume that we don't throw
         isa(sv, Module) && return false
         name ⊑ Int || name ⊑ Symbol || return false
-        for i = 1:fieldcount(typeof(sv))
-            isdefined(sv, i) || return false
+        typeof(sv).name.n_uninitialized == 0 && return true
+        for i = (datatype_min_ninitialized(typeof(sv)) + 1):nfields(sv)
+            isdefined_tfunc(𝕃, s00, Const(i)) === Const(true) || return false
         end
         return true
     end
@@ -1247,27 +1240,22 @@ end
     return rewrap_unionall(R, s00)
 end
 
-@nospecs function getfield_notundefined(typ0, name)
-    if isa(typ0, Const) && isa(name, Const)
-        typv = typ0.val
-        namev = name.val
-        isa(typv, Module) && return true
-        if isa(namev, Symbol) || isa(namev, Int)
-            # Fields are not allowed to transition from defined to undefined, so
-            # even if the field is not const, all we need to check here is that
-            # it is defined here.
-            return isdefined(typv, namev)
-        end
+@nospecs function getfield_notuninit(typ0, name)
+    if isa(typ0, Const)
+        # If the object is Const, then we know exactly the bit patterns that
+        # must be returned by getfield if not an error
+        return true
     end
     typ0 = widenconst(typ0)
     typ = unwrap_unionall(typ0)
     if isa(typ, Union)
-        return getfield_notundefined(rewrap_unionall(typ.a, typ0), name) &&
-               getfield_notundefined(rewrap_unionall(typ.b, typ0), name)
+        return getfield_notuninit(rewrap_unionall(typ.a, typ0), name) &&
+               getfield_notuninit(rewrap_unionall(typ.b, typ0), name)
     end
     isa(typ, DataType) || return false
-    if typ.name === Tuple.name || typ.name === _NAMEDTUPLE_NAME
-        # tuples and named tuples can't be instantiated with undefined fields,
+    isabstracttype(typ) && !isconstType(typ) && return false # cannot say anything about abstract types
+    if typ.name.n_uninitialized == 0
+        # Types such as tuples and named tuples that can't be instantiated with undefined fields,
         # so we don't need to be conservative here
         return true
     end
@@ -2439,25 +2427,16 @@ function isdefined_effects(𝕃::AbstractLattice, argtypes::Vector{Any})
     # consistent if the first arg is immutable
     na = length(argtypes)
     2 ≤ na ≤ 3 || return EFFECTS_THROWS
-    obj, sym = argtypes
-    wobj = unwrapva(obj)
+    wobj, sym = argtypes
+    wobj = unwrapva(wobj)
+    sym = unwrapva(sym)
     consistent = CONSISTENT_IF_INACCESSIBLEMEMONLY
     if is_immutable_argtype(wobj)
         consistent = ALWAYS_TRUE
-    else
-        # Bindings/fields are not allowed to transition from defined to undefined, so even
-        # if the object is not immutable, we can prove `:consistent`-cy if it is defined:
-        if isa(wobj, Const) && isa(sym, Const)
-            objval = wobj.val
-            symval = sym.val
-            if isa(objval, Module)
-                if isa(symval, Symbol) && isdefined(objval, symval)
-                    consistent = ALWAYS_TRUE
-                end
-            elseif (isa(symval, Symbol) || isa(symval, Int)) && isdefined(objval, symval)
-                consistent = ALWAYS_TRUE
-            end
-        end
+    elseif isdefined_tfunc(𝕃, wobj, sym) isa Const
+        # Some bindings/fields are not allowed to transition from defined to undefined or the reverse, so even
+        # if the object is not immutable, we can prove `:consistent`-cy of this:
+        consistent = ALWAYS_TRUE
     end
     nothrow = isdefined_nothrow(𝕃, argtypes)
     if hasintersect(widenconst(wobj), Module)
@@ -2486,11 +2465,11 @@ function getfield_effects(𝕃::AbstractLattice, argtypes::Vector{Any}, @nospeci
     # taint `:consistent` if accessing `isbitstype`-type object field that may be initialized
     # with undefined value: note that we don't need to taint `:consistent` if accessing
     # uninitialized non-`isbitstype` field since it will simply throw `UndefRefError`
-    # NOTE `getfield_notundefined` conservatively checks if this field is never initialized
+    # NOTE `getfield_notuninit` conservatively checks if this field is never initialized
     # with undefined value to avoid tainting `:consistent` too aggressively
     # TODO this should probably taint `:noub`, however, it would hinder concrete eval for
     # `REPLInterpreter` that can ignore `:consistent-cy`, causing worse completions
-    if !(length(argtypes) ≥ 2 && getfield_notundefined(obj, argtypes[2]))
+    if !(length(argtypes) ≥ 2 && getfield_notuninit(obj, argtypes[2]))
         consistent = ALWAYS_FALSE
     end
     noub = ALWAYS_TRUE
@@ -3125,7 +3104,7 @@ end
     if M isa Const && s isa Const
         M, s = M.val, s.val
         if M isa Module && s isa Symbol
-            return isdefined(M, s)
+            return isdefinedconst_globalref(GlobalRef(M, s))
         end
     end
     return false
@@ -3198,9 +3177,9 @@ end
 end
 
 function global_assignment_nothrow(M::Module, s::Symbol, @nospecialize(newty))
-    if isdefined(M, s) && !isconst(M, s)
+    if !isconst(M, s)
         ty = ccall(:jl_get_binding_type, Any, (Any, Any), M, s)
-        return ty === nothing || newty ⊑ ty
+        return ty isa Type && widenconst(newty) <: ty
     end
     return false
 end
@@ -3216,7 +3195,7 @@ end
 end
 @nospecs function get_binding_type_tfunc(𝕃::AbstractLattice, M, s)
     if get_binding_type_effect_free(M, s)
-        return Const(Core.get_binding_type((M::Const).val, (s::Const).val))
+        return Const(Core.get_binding_type((M::Const).val::Module, (s::Const).val::Symbol))
     end
     return Type
 end
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 5d1dda3e735dc..b6e948e9fcaff 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -3188,22 +3188,16 @@ static jl_cgval_t emit_globalref(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *
     if (bp == NULL)
         return jl_cgval_t();
     bp = julia_binding_pvalue(ctx, bp);
+    jl_value_t *ty = nullptr;
     if (bnd) {
         jl_value_t *v = jl_atomic_load_acquire(&bnd->value); // acquire value for ty
-        if (v != NULL) {
-            if (bnd->constp)
-                return mark_julia_const(ctx, v);
-            LoadInst *v = ctx.builder.CreateAlignedLoad(ctx.types().T_prjlvalue, bp, Align(sizeof(void*)));
-            setName(ctx.emission_context, v, jl_symbol_name(name));
-            v->setOrdering(order);
-            jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_binding);
-            ai.decorateInst(v);
-            jl_value_t *ty = jl_atomic_load_relaxed(&bnd->ty);
-            return mark_julia_type(ctx, v, true, ty);
-        }
+        if (v != NULL && bnd->constp)
+            return mark_julia_const(ctx, v);
+        ty = jl_atomic_load_relaxed(&bnd->ty);
     }
-    // todo: use type info to avoid undef check
-    return emit_checked_var(ctx, bp, name, (jl_value_t*)mod, false, ctx.tbaa().tbaa_binding);
+    if (ty == nullptr)
+        ty = (jl_value_t*)jl_any_type;
+    return update_julia_type(ctx, emit_checked_var(ctx, bp, name, (jl_value_t*)mod, false, ctx.tbaa().tbaa_binding), ty);
 }
 
 static jl_cgval_t emit_globalop(jl_codectx_t &ctx, jl_module_t *mod, jl_sym_t *sym, jl_cgval_t rval, const jl_cgval_t &cmp,
@@ -5461,7 +5455,7 @@ static jl_cgval_t emit_isdefined(jl_codectx_t &ctx, jl_value_t *sym)
         }
         jl_binding_t *bnd = jl_get_binding(modu, name);
         if (bnd) {
-            if (jl_atomic_load_relaxed(&bnd->value) != NULL)
+            if (jl_atomic_load_acquire(&bnd->value) != NULL && bnd->constp)
                 return mark_julia_const(ctx, jl_true);
             Value *bp = julia_binding_gv(ctx, bnd);
             bp = julia_binding_pvalue(ctx, bp);
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index cdf797fb2a77b..d3884bf2c73e2 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -249,52 +249,52 @@ struct SyntacticallyDefined{T}
     x::T
 end
 
-import Core.Compiler: Const, getfield_notundefined
+import Core.Compiler: Const, getfield_notuninit
 for T = (Base.RefValue, Maybe) # both mutable and immutable
     for name = (Const(1), Const(:x))
-        @test getfield_notundefined(T{String}, name)
-        @test getfield_notundefined(T{Integer}, name)
-        @test getfield_notundefined(T{Union{String,Integer}}, name)
-        @test getfield_notundefined(Union{T{String},T{Integer}}, name)
-        @test !getfield_notundefined(T{Int}, name)
-        @test !getfield_notundefined(T{<:Integer}, name)
-        @test !getfield_notundefined(T{Union{Int32,Int64}}, name)
-        @test !getfield_notundefined(T, name)
+        @test getfield_notuninit(T{String}, name)
+        @test getfield_notuninit(T{Integer}, name)
+        @test getfield_notuninit(T{Union{String,Integer}}, name)
+        @test getfield_notuninit(Union{T{String},T{Integer}}, name)
+        @test !getfield_notuninit(T{Int}, name)
+        @test !getfield_notuninit(T{<:Integer}, name)
+        @test !getfield_notuninit(T{Union{Int32,Int64}}, name)
+        @test !getfield_notuninit(T, name)
     end
     # throw doesn't account for undefined behavior
     for name = (Const(0), Const(2), Const(1.0), Const(:y), Const("x"),
                 Float64, String, Nothing)
-        @test getfield_notundefined(T{String}, name)
-        @test getfield_notundefined(T{Int}, name)
-        @test getfield_notundefined(T{Integer}, name)
-        @test getfield_notundefined(T{<:Integer}, name)
-        @test getfield_notundefined(T{Union{Int32,Int64}}, name)
-        @test getfield_notundefined(T, name)
+        @test getfield_notuninit(T{String}, name)
+        @test getfield_notuninit(T{Int}, name)
+        @test getfield_notuninit(T{Integer}, name)
+        @test getfield_notuninit(T{<:Integer}, name)
+        @test getfield_notuninit(T{Union{Int32,Int64}}, name)
+        @test getfield_notuninit(T, name)
     end
     # should not be too conservative when field isn't known very well but object information is accurate
-    @test getfield_notundefined(T{String}, Int)
-    @test getfield_notundefined(T{String}, Symbol)
-    @test getfield_notundefined(T{Integer}, Int)
-    @test getfield_notundefined(T{Integer}, Symbol)
-    @test !getfield_notundefined(T{Int}, Int)
-    @test !getfield_notundefined(T{Int}, Symbol)
-    @test !getfield_notundefined(T{<:Integer}, Int)
-    @test !getfield_notundefined(T{<:Integer}, Symbol)
+    @test getfield_notuninit(T{String}, Int)
+    @test getfield_notuninit(T{String}, Symbol)
+    @test getfield_notuninit(T{Integer}, Int)
+    @test getfield_notuninit(T{Integer}, Symbol)
+    @test !getfield_notuninit(T{Int}, Int)
+    @test !getfield_notuninit(T{Int}, Symbol)
+    @test !getfield_notuninit(T{<:Integer}, Int)
+    @test !getfield_notuninit(T{<:Integer}, Symbol)
 end
 # should be conservative when object information isn't accurate
-@test !getfield_notundefined(Any, Const(1))
-@test !getfield_notundefined(Any, Const(:x))
+@test !getfield_notuninit(Any, Const(1))
+@test !getfield_notuninit(Any, Const(:x))
 # tuples and namedtuples should be okay if not given accurate information
 for TupleType = Any[Tuple{Int,Int,Int}, Tuple{Int,Vararg{Int}}, Tuple{Any}, Tuple,
                     NamedTuple{(:a, :b), Tuple{Int,Int}}, NamedTuple{(:x,),Tuple{Any}}, NamedTuple],
     FieldType = Any[Int, Symbol, Any]
-    @test getfield_notundefined(TupleType, FieldType)
+    @test getfield_notuninit(TupleType, FieldType)
 end
 # skip analysis on fields that are known to be defined syntactically
-@test Core.Compiler.getfield_notundefined(SyntacticallyDefined{Float64}, Symbol)
-@test Core.Compiler.getfield_notundefined(Const(Main), Const(:var))
-@test Core.Compiler.getfield_notundefined(Const(Main), Const(42))
-# high-level tests for `getfield_notundefined`
+@test Core.Compiler.getfield_notuninit(SyntacticallyDefined{Float64}, Symbol)
+@test Core.Compiler.getfield_notuninit(Const(Main), Const(:var))
+@test Core.Compiler.getfield_notuninit(Const(Main), Const(42))
+# high-level tests for `getfield_notuninit`
 @test Base.infer_effects() do
     Maybe{Int}()
 end |> !Core.Compiler.is_consistent
@@ -904,7 +904,7 @@ end |> Core.Compiler.is_foldable_nothrow
 @test Base.infer_effects(Tuple{WrapperOneField{Float64}, Symbol}) do w, s
     getfield(w, s)
 end |> Core.Compiler.is_foldable
-@test Core.Compiler.getfield_notundefined(WrapperOneField{Float64}, Symbol)
+@test Core.Compiler.getfield_notuninit(WrapperOneField{Float64}, Symbol)
 @test Base.infer_effects(Tuple{WrapperOneField{Symbol}, Symbol}) do w, s
     getfield(w, s)
 end |> Core.Compiler.is_foldable
@@ -996,7 +996,7 @@ end
 let effects = Base.infer_effects() do
         isdefined(defined_ref, :x)
     end
-    @test Core.Compiler.is_consistent(effects)
+    @test !Core.Compiler.is_consistent(effects)
     @test Core.Compiler.is_nothrow(effects)
 end
 let effects = Base.infer_effects() do

From f259ebafcde875bcea7c5a285d41bc51b7e8b3b7 Mon Sep 17 00:00:00 2001
From: Steve Kelly <kd2cca@gmail.com>
Date: Tue, 16 Apr 2024 15:40:08 -0400
Subject: [PATCH 1282/1315] Ignore inlining costs for precompilation with
 `--compile=all` (#53798)

This helps to minimize the amount of missed precompiles
that occur by eliding the inlining cost check when julia is
run under `--compile=all`. This will lead to
slightly larger sysimage sizes. However, in practice it leads
to more extensive and successful precompilation, which can
minimize the number of JIT events in
call sites with dynamic dispatch.

This is an alternative to #53547, where removing the inlining
cost check was made universal. However, that lead to ~15% larger
sysimage sizes by default. This implements Jeff's  suggestion that
this mode be enabled under `--compile=all`.
---
 src/precompile_utils.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/precompile_utils.c b/src/precompile_utils.c
index af9d93d612249..5a4f599d1f0eb 100644
--- a/src/precompile_utils.c
+++ b/src/precompile_utils.c
@@ -189,7 +189,7 @@ static int precompile_enq_specialization_(jl_method_instance_t *mi, void *closur
             jl_value_t *inferred = jl_atomic_load_relaxed(&codeinst->inferred);
             if (inferred &&
                 inferred != jl_nothing &&
-                (jl_ir_inlining_cost(inferred) == UINT16_MAX)) {
+                (jl_options.compile_enabled != JL_OPTIONS_COMPILE_ALL && jl_ir_inlining_cost(inferred) == UINT16_MAX)) {
                 do_compile = 1;
             }
             else if (jl_atomic_load_relaxed(&codeinst->invoke) != NULL || jl_atomic_load_relaxed(&codeinst->precompile)) {

From 824ceefc081beae108b6616d19b8a1cb056d08e2 Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Tue, 16 Apr 2024 21:42:43 +0200
Subject: [PATCH 1283/1315] Clarify `wait(::Task)` documentation (#53722)

Small follow-up to https://github.com/JuliaLang/julia/pull/53685, since
having critical documentation for a specific method be only mentioned in
a catch-all docstring isn't quite as helpful as it could be (e.g. when
looking at inline documentation with LSP, where it happens to know that
the variable being passed is a `Task`). In addition, this also documents
that `wait` on a `Task` will throw if given `current_task`.

I've also split the function into a prototype and the actual
implementation, so that the same "more specific docs at the method
definition" transform can be applied for `GenericCondition` too.
---
 base/condition.jl | 23 +++++++++++++++--------
 base/task.jl      | 12 +++++++++++-
 test/misc.jl      |  2 +-
 3 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/base/condition.jl b/base/condition.jl
index a140903d52d41..52781f348eb0d 100644
--- a/base/condition.jl
+++ b/base/condition.jl
@@ -103,19 +103,16 @@ end
 """
     wait([x])
 
-Block the current task until some event occurs, depending on the type of the argument:
+Block the current task until some event occurs.
 
 * [`Channel`](@ref): Wait for a value to be appended to the channel.
 * [`Condition`](@ref): Wait for [`notify`](@ref) on a condition and return the `val`
-  parameter passed to `notify`. Waiting on a condition additionally allows passing
-  `first=true` which results in the waiter being put _first_ in line to wake up on `notify`
-  instead of the usual first-in-first-out behavior.
+  parameter passed to `notify`. See the `Condition`-specific docstring of `wait` for
+  the exact behavior.
 * `Process`: Wait for a process or process chain to exit. The `exitcode` field of a process
   can be used to determine success or failure.
-* [`Task`](@ref): Wait for a `Task` to finish. If the task fails with an exception, a
-  `TaskFailedException` (which wraps the failed task) is thrown.  Waiting on a task
-  additionally allows passing `throw=false` which prevents throwing a `TaskFailedException`
-  when the task fails.
+* [`Task`](@ref): Wait for a `Task` to finish. See the `Task`-specific docstring of `wait` for
+  the exact behavior.
 * [`RawFD`](@ref): Wait for changes on a file descriptor (see the `FileWatching` package).
 
 If no argument is passed, the task blocks for an undefined period. A task can only be
@@ -124,6 +121,16 @@ restarted by an explicit call to [`schedule`](@ref) or [`yieldto`](@ref).
 Often `wait` is called within a `while` loop to ensure a waited-for condition is met before
 proceeding.
 """
+function wait end
+
+"""
+    wait(c::GenericCondition; first::Bool=false)
+
+Wait for [`notify`](@ref) on `c` and return the `val` parameter passed to `notify`.
+
+If the keyword `first` is set to `true`, the waiter will be put _first_
+in line to wake up on `notify`. Otherwise, `wait` has first-in-first-out (FIFO) behavior.
+"""
 function wait(c::GenericCondition; first::Bool=false)
     ct = current_task()
     _wait2(c, ct, first)
diff --git a/base/task.jl b/base/task.jl
index 90f74441c7fbd..fcc18447ac5b2 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -355,8 +355,18 @@ function _wait2(t::Task, waiter::Task)
     nothing
 end
 
+"""
+    wait(t::Task; throw=true)
+
+Wait for a `Task` to finish.
+
+The keyword `throw` (defaults to `true`) controls whether a failed task results
+in an error, thrown as a [`TaskFailedException`](@ref) which wraps the failed task.
+
+Throws a `ConcurrencyViolationError` if `t` is the currently running task, to prevent deadlocks.
+"""
 function wait(t::Task; throw=true)
-    t === current_task() && error("deadlock detected: cannot wait on current task")
+    t === current_task() && Core.throw(ConcurrencyViolationError("deadlock detected: cannot wait on current task"))
     _wait(t)
     if throw && istaskfailed(t)
         Core.throw(TaskFailedException(t))
diff --git a/test/misc.jl b/test/misc.jl
index e870c7f491c13..2f27c76ed0077 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -251,7 +251,7 @@ let c = Ref(0),
     @test c[] == 100
 end
 
-@test_throws ErrorException("deadlock detected: cannot wait on current task") wait(current_task())
+@test_throws ConcurrencyViolationError("deadlock detected: cannot wait on current task") wait(current_task())
 
 # issue #41347
 let t = @async 1

From d7a354acada715ade36937fe841a07419ad62f29 Mon Sep 17 00:00:00 2001
From: Sukera <11753998+Seelengrab@users.noreply.github.com>
Date: Tue, 16 Apr 2024 21:56:42 +0200
Subject: [PATCH 1284/1315] Throw `ConcurrencyViolationError` on `yield` with
 `current_task` (#53974)

Previously, this errored with a nasty type assert *somewhere* in the
runtime. Throwing a proper `ConcurrencyViolationError` allows this to be
debugged, and makes the error condition better known.
---
 base/task.jl | 8 ++++++--
 test/misc.jl | 4 +++-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/base/task.jl b/base/task.jl
index fcc18447ac5b2..7b19fc5f2a3d1 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -1050,11 +1050,15 @@ end
 
 A fast, unfair-scheduling version of `schedule(t, arg); yield()` which
 immediately yields to `t` before calling the scheduler.
+
+Throws a `ConcurrencyViolationError` if `t` is the currently running task.
 """
 function yield(t::Task, @nospecialize(x=nothing))
-    (t._state === task_state_runnable && t.queue === nothing) || error("yield: Task not runnable")
+    current = current_task()
+    t === current && throw(ConcurrencyViolationError("Cannot yield to currently running task!"))
+    (t._state === task_state_runnable && t.queue === nothing) || throw(ConcurrencyViolationError("yield: Task not runnable"))
     t.result = x
-    enq_work(current_task())
+    enq_work(current)
     set_next_task(t)
     return try_yieldto(ensure_rescheduled)
 end
diff --git a/test/misc.jl b/test/misc.jl
index 2f27c76ed0077..6c2f0f89135fd 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -253,10 +253,12 @@ end
 
 @test_throws ConcurrencyViolationError("deadlock detected: cannot wait on current task") wait(current_task())
 
+@test_throws ConcurrencyViolationError("Cannot yield to currently running task!") yield(current_task())
+
 # issue #41347
 let t = @async 1
     wait(t)
-    @test_throws ErrorException yield(t)
+    @test_throws ConcurrencyViolationError yield(t)
 end
 
 let t = @async error(42)

From c5576361551f293e9154eb32dbfbfe94670ea4da Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 16 Apr 2024 16:00:23 -0400
Subject: [PATCH 1285/1315] Profile: fix heap snapshot is valid char check
 (#53984)

Followup to https://github.com/JuliaLang/julia/pull/53833
Fixes a failure seen in https://github.com/JuliaLang/julia/pull/53974
(below)

I believe this is the more correct check to make?

The heapsnapshot generated from this PR is viewable in vscode.

```
2024-04-06 09:33:58 EDT	      From worker 7:	ERROR: Base.InvalidCharError{Char}('\xc1\xae')
2024-04-06 09:33:58 EDT	      From worker 7:	Stacktrace:
2024-04-06 09:33:58 EDT	      From worker 7:	  [1] throw_invalid_char(c::Char)
2024-04-06 09:33:58 EDT	      From worker 7:	    @ Base ./char.jl:86
2024-04-06 09:33:58 EDT	      From worker 7:	  [2] UInt32
2024-04-06 09:33:58 EDT	      From worker 7:	    @ ./char.jl:133 [inlined]
2024-04-06 09:33:58 EDT	      From worker 7:	  [3] category_code
2024-04-06 09:33:58 EDT	      From worker 7:	    @ ./strings/unicode.jl:339 [inlined]
2024-04-06 09:33:58 EDT	      From worker 7:	  [4] isassigned
2024-04-06 09:33:58 EDT	      From worker 7:	    @ ./strings/unicode.jl:355 [inlined]
2024-04-06 09:33:58 EDT	      From worker 7:	  [5] isassigned
2024-04-06 09:33:58 EDT	      From worker 7:	    @ /cache/build/tester-amdci5-14/julialang/julia-master/julia-41d026beaf/share/julia/stdlib/v1.12/Unicode/src/Unicode.jl:138 [inlined]
2024-04-06 09:33:58 EDT	      From worker 7:	  [6] print_str_escape_json(stream::IOStream, s::String)
2024-04-06 09:33:58 EDT	      From worker 7:	    @ Profile.HeapSnapshot /cache/build/tester-amdci5-14/julialang/julia-master/julia-41d026beaf/share/julia/stdlib/v1.12/Profile/src/heapsnapshot_reassemble.jl:239
2024-04-06 09:33:59 EDT	      From worker 7:	  [7] (::Profile.HeapSnapshot.var"#5#6"{IOStream})(strings_io::IOStream)
2024-04-06 09:33:59 EDT	      From worker 7:	    @ Profile.HeapSnapshot /cache/build/tester-amdci5-14/julialang/julia-master/julia-41d026beaf/share/julia/stdlib/v1.12/Profile/src/heapsnapshot_reassemble.jl:192
```
---
 stdlib/Manifest.toml                          | 1 -
 stdlib/Profile/Project.toml                   | 6 ------
 stdlib/Profile/src/heapsnapshot_reassemble.jl | 4 +---
 3 files changed, 1 insertion(+), 10 deletions(-)

diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index 858e5ea651339..4e4f48b4e6af4 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -191,7 +191,6 @@ uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 version = "1.11.0"
 
 [[deps.Profile]]
-deps = ["Unicode"]
 uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
 version = "1.11.0"
 
diff --git a/stdlib/Profile/Project.toml b/stdlib/Profile/Project.toml
index ede7ccd66bc8e..ad0107ecf9404 100644
--- a/stdlib/Profile/Project.toml
+++ b/stdlib/Profile/Project.toml
@@ -2,12 +2,6 @@ name = "Profile"
 uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
 version = "1.11.0"
 
-[deps]
-Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
-
-[compat]
-Unicode = "1.11.0"
-
 [extras]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
diff --git a/stdlib/Profile/src/heapsnapshot_reassemble.jl b/stdlib/Profile/src/heapsnapshot_reassemble.jl
index 27d7d12318ed1..50da13e550d82 100644
--- a/stdlib/Profile/src/heapsnapshot_reassemble.jl
+++ b/stdlib/Profile/src/heapsnapshot_reassemble.jl
@@ -2,8 +2,6 @@
 
 module HeapSnapshot
 
-using Unicode
-
 """
     assemble_snapshot(filepath::AbstractString, out_file::AbstractString)
 
@@ -236,7 +234,7 @@ function print_str_escape_json(stream::IO, s::AbstractString)
             print(stream, "\\t")
         elseif '\x00' <= c <= '\x1f'
             print(stream, "\\u", lpad(string(UInt16(c), base=16), 4, '0'))
-        elseif !Unicode.isassigned(c)
+        elseif !isvalid(c)
             # we have to do this because vscode's viewer doesn't like the replace character
             print(stream, "[invalid unicode character]")
         else

From 159f4d74e63d20c89dcc6c93f7a7e8d01939c130 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 17 Apr 2024 05:05:27 +0530
Subject: [PATCH 1286/1315] Explicitly compute stride in unaliascopy for
 SubArray (#54102)

Fix https://github.com/JuliaLang/julia/issues/54100 by computing the
stride and offset explicitly. This is unlikely to be a performance
concern, so we don't need to hard-code this.
---
 base/subarray.jl |  7 +++++--
 test/subarray.jl | 19 +++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index e9660b9dee639..656628bb40382 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -115,11 +115,14 @@ function unaliascopy(V::SubArray{T,N,A,I,LD}) where {T,N,A<:Array,I<:Tuple{Varar
     trimmedpind = _trimmedpind(V.indices...)
     vdest = trimmedpind isa Tuple{Vararg{Union{Slice,Colon}}} ? dest : view(dest, trimmedpind...)
     copyto!(vdest, view(V, _trimmedvind(V.indices...)...))
-    SubArray{T,N,A,I,LD}(dest, map(_trimmedindex, V.indices), 0, Int(LD))
+    indices = map(_trimmedindex, V.indices)
+    stride1 = LD ? compute_stride1(dest, indices) : 0
+    offset1 = LD ? compute_offset1(dest, stride1, indices) : 0
+    SubArray{T,N,A,I,LD}(dest, indices, offset1, stride1)
 end
 # Get the proper trimmed shape
 _trimmedshape(::ScalarIndex, rest...) = (1, _trimmedshape(rest...)...)
-_trimmedshape(i::AbstractRange, rest...) = (maximum(i), _trimmedshape(rest...)...)
+_trimmedshape(i::AbstractRange, rest...) = (isempty(i) ? zero(eltype(i)) : maximum(i), _trimmedshape(rest...)...)
 _trimmedshape(i::Union{UnitRange,StepRange,OneTo}, rest...) = (length(i), _trimmedshape(rest...)...)
 _trimmedshape(i::AbstractArray{<:ScalarIndex}, rest...) = (length(i), _trimmedshape(rest...)...)
 _trimmedshape(i::AbstractArray{<:AbstractCartesianIndex{0}}, rest...) = _trimmedshape(rest...)
diff --git a/test/subarray.jl b/test/subarray.jl
index eedf28539d72b..0c29c6a784efd 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -827,6 +827,25 @@ end
     @test @inferred(Base.unaliascopy(V))::typeof(V) == V == A[i1, 1:5, i2, i3]
     V = view(A, i1, 1:5, i3, i2)
     @test @inferred(Base.unaliascopy(V))::typeof(V) == V == A[i1, 1:5, i3, i2]
+
+    @testset "custom ranges" begin
+        struct MyStepRange{T} <: OrdinalRange{T,T}
+            r::StepRange{T,T}
+        end
+
+        for f in (:first, :last, :step, :length, :size)
+            @eval Base.$f(r::MyStepRange) = $f(r.r)
+        end
+        Base.getindex(r::MyStepRange, i::Int) = r.r[i]
+
+        a = rand(6)
+        V = view(a, MyStepRange(2:2:4))
+        @test @inferred(Base.unaliascopy(V))::typeof(V) == V
+
+        # empty range
+        V = view(a, MyStepRange(2:2:1))
+        @test @inferred(Base.unaliascopy(V))::typeof(V) == V
+    end
 end
 
 @testset "issue #27632" begin

From 306124c0be088836bf962fd7aa6be6bef738ebd9 Mon Sep 17 00:00:00 2001
From: Nathan Zimmerberg <39104088+nhz2@users.noreply.github.com>
Date: Wed, 17 Apr 2024 05:03:58 -0400
Subject: [PATCH 1287/1315] Fix integer overflow in `skip(s::IOBuffer,
 typemax(Int64))` (#54070)

Fixes #53908  by clamping before doing addition.

This also fixes an issue with negative skips if `io.offset` isn't zero.

I am assuming that `io.size+1` cannot overflow.
---
 base/iobuffer.jl | 24 +++++++++++++++++-------
 test/iobuffer.jl | 25 +++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 7 deletions(-)

diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index 109eaa96a3de4..6b8d694ec03fb 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -260,22 +260,32 @@ bytesavailable(io::GenericIOBuffer) = io.size - io.ptr + 1
 position(io::GenericIOBuffer) = io.ptr - io.offset - 1
 
 function skip(io::GenericIOBuffer, n::Integer)
-    seekto = io.ptr + n
-    n < 0 && return seek(io, seekto-1) # Does error checking
-    io.ptr = min(seekto, io.size+1)
-    return io
+    skip(io, clamp(n, Int))
+end
+function skip(io::GenericIOBuffer, n::Int)
+    if signbit(n)
+        seekto = clamp(widen(position(io)) + widen(n), Int)
+        seek(io, seekto) # Does error checking
+    else
+        n_max = io.size + 1 - io.ptr
+        io.ptr += min(n, n_max)
+        io
+    end
 end
 
 function seek(io::GenericIOBuffer, n::Integer)
+    seek(io, clamp(n, Int))
+end
+function seek(io::GenericIOBuffer, n::Int)
     if !io.seekable
         ismarked(io) || throw(ArgumentError("seek failed, IOBuffer is not seekable and is not marked"))
         n == io.mark || throw(ArgumentError("seek failed, IOBuffer is not seekable and n != mark"))
     end
     # TODO: REPL.jl relies on the fact that this does not throw (by seeking past the beginning or end
     #       of an GenericIOBuffer), so that would need to be fixed in order to throw an error here
-    #(n < 0 || n > io.size) && throw(ArgumentError("Attempted to seek outside IOBuffer boundaries."))
-    #io.ptr = n+1
-    io.ptr = min(max(0, n)+io.offset, io.size)+1
+    #(n < 0 || n > io.size - io.offset) && throw(ArgumentError("Attempted to seek outside IOBuffer boundaries."))
+    #io.ptr = n + io.offset + 1
+    io.ptr = clamp(n, 0, io.size - io.offset) + io.offset + 1
     return io
 end
 
diff --git a/test/iobuffer.jl b/test/iobuffer.jl
index 6151f90f297ee..8c49b7ec83327 100644
--- a/test/iobuffer.jl
+++ b/test/iobuffer.jl
@@ -196,6 +196,31 @@ end
     @test position(skip(io, -3)) == 0
 end
 
+@testset "issue #53908" begin
+    @testset "offset $first" for first in (false, true)
+        b = collect(0x01:0x05)
+        sizehint!(b, 100; first) # make offset non zero
+        io = IOBuffer(b)
+        @test position(skip(io, 4)) == 4
+        @test position(skip(io, typemax(Int))) == 5
+        @test position(skip(io, typemax(Int128))) == 5
+        @test position(skip(io, typemax(Int32))) == 5
+        @test position(skip(io, typemin(Int))) == 0
+        @test position(skip(io, typemin(Int128))) == 0
+        @test position(skip(io, typemin(Int32))) == 0
+        @test position(skip(io, 4)) == 4
+        @test position(skip(io, -2)) == 2
+        @test position(skip(io, -2)) == 0
+        @test position(seek(io, -2)) == 0
+        @test position(seek(io, typemax(Int))) == 5
+        @test position(seek(io, typemax(Int128))) == 5
+        @test position(seek(io, typemax(Int32))) == 5
+        @test position(seek(io, typemin(Int))) == 0
+        @test position(seek(io, typemin(Int128))) == 0
+        @test position(seek(io, typemin(Int32))) == 0
+    end
+end
+
 @testset "pr #11554" begin
     io  = IOBuffer(SubString("***αhelloworldω***", 4, 16))
     io2 = IOBuffer(Vector{UInt8}(b"goodnightmoon"), read=true, write=true)

From f30aae5493ccfc05b13eb7bf83abe13e9003d5bd Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 17 Apr 2024 19:51:54 +0900
Subject: [PATCH 1288/1315] inference: remove staled `:method` handling
 (#54110)

Within `abstract_eval_statement_expr`
---
 base/compiler/abstractinterpretation.jl | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 4ab512038b54e..d76e64c84aaae 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2679,10 +2679,6 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         t = Nothing
         exct = Union{}
         effects = Effects(EFFECTS_TOTAL; effect_free=EFFECT_FREE_GLOBALLY)
-    elseif ehead === :method
-        t = Method
-        exct = Union{}
-        effects = Effects(EFFECTS_TOTAL; effect_free=EFFECT_FREE_GLOBALLY)
     elseif ehead === :thunk
         t = Any
         effects = EFFECTS_UNKNOWN

From 0f7674e22665e80c5003dc3f0af1d46d814edc9e Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Wed, 17 Apr 2024 11:44:55 -0300
Subject: [PATCH 1289/1315] Fix libasan runpath behaviour. (#54104)

This is necessary with LLVM 17 but was extracted to a separate patch
xref https://github.com/JuliaLang/julia/pull/53070
---
 cli/Makefile                | 4 ++--
 contrib/asan/Make.user.asan | 1 +
 contrib/asan/build.sh       | 2 +-
 deps/sanitizers.mk          | 2 ++
 4 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/cli/Makefile b/cli/Makefile
index 017f713446e1a..6e2696538e216 100644
--- a/cli/Makefile
+++ b/cli/Makefile
@@ -119,7 +119,7 @@ STRIP_EXPORTED_FUNCS := $(shell $(CPP_STDOUT) -I$(JULIAHOME)/src $(SRCDIR)/list_
 endif
 
 $(build_shlibdir)/libjulia.$(JL_MAJOR_MINOR_SHLIB_EXT): $(LIB_OBJS) $(SRCDIR)/list_strip_symbols.h $(BUILDDIR)/julia.expmap | $(build_shlibdir) $(build_libdir)
-	@$(call PRINT_LINK, $(CC) $(call IMPLIB_FLAGS,$@.tmp) $(LOADER_CFLAGS) -shared $(SHIPFLAGS) $(LIB_OBJS) -o $@ \
+	@$(call PRINT_LINK, $(CC) $(call IMPLIB_FLAGS,$@.tmp) $(LOADER_CFLAGS) -shared $(SHIPFLAGS) $(LIB_OBJS) $(RPATH_LIB) -o $@ \
 		$(JLIBLDFLAGS) $(LOADER_LDFLAGS) $(VERSIONSCRIPT) $(call SONAME_FLAGS,libjulia.$(JL_MAJOR_SHLIB_EXT)))
 	@$(INSTALL_NAME_CMD)libjulia.$(JL_MAJOR_SHLIB_EXT) $@
 	@$(DSYMUTIL) $@
@@ -130,7 +130,7 @@ ifeq ($(OS), WINNT)
 endif
 
 $(build_shlibdir)/libjulia-debug.$(JL_MAJOR_MINOR_SHLIB_EXT): $(LIB_DOBJS) $(SRCDIR)/list_strip_symbols.h $(BUILDDIR)/julia.expmap | $(build_shlibdir) $(build_libdir)
-	@$(call PRINT_LINK, $(CC) $(call IMPLIB_FLAGS,$@.tmp) $(LOADER_CFLAGS) -shared $(DEBUGFLAGS) $(LIB_DOBJS) -o $@ \
+	@$(call PRINT_LINK, $(CC) $(call IMPLIB_FLAGS,$@.tmp) $(LOADER_CFLAGS) -shared $(DEBUGFLAGS) $(LIB_DOBJS) $(RPATH_LIB) -o $@ \
 		$(JLIBLDFLAGS) $(LOADER_LDFLAGS) $(VERSIONSCRIPT) $(call SONAME_FLAGS,libjulia-debug.$(JL_MAJOR_SHLIB_EXT)))
 	@$(INSTALL_NAME_CMD)libjulia-debug.$(JL_MAJOR_SHLIB_EXT) $@
 	@$(DSYMUTIL) $@
diff --git a/contrib/asan/Make.user.asan b/contrib/asan/Make.user.asan
index 96ed13b54e0f9..a97631f7c8080 100644
--- a/contrib/asan/Make.user.asan
+++ b/contrib/asan/Make.user.asan
@@ -6,6 +6,7 @@ TOOLDIR=$(TOOLCHAIN)/usr/tools
 USECLANG=1
 override CC=$(TOOLDIR)/clang
 override CXX=$(TOOLDIR)/clang++
+override PATCHELF=$(TOOLDIR)/patchelf
 export ASAN_SYMBOLIZER_PATH=$(TOOLDIR)/llvm-symbolizer
 
 USE_BINARYBUILDER_LLVM=1
diff --git a/contrib/asan/build.sh b/contrib/asan/build.sh
index 77f3078b35c42..2e7f243772c81 100755
--- a/contrib/asan/build.sh
+++ b/contrib/asan/build.sh
@@ -40,7 +40,7 @@ if [ ! -d "$TOOLCHAIN" ]; then
     cp "$HERE/Make.user.tools"  "$TOOLCHAIN/Make.user"
 fi
 
-make -C "$TOOLCHAIN/deps" install-clang install-llvm-tools
+make -C "$TOOLCHAIN/deps" install-clang install-llvm-tools install-patchelf
 
 echo
 echo "Building Julia..."
diff --git a/deps/sanitizers.mk b/deps/sanitizers.mk
index 1a272321c05fa..d5bb6fce5b807 100644
--- a/deps/sanitizers.mk
+++ b/deps/sanitizers.mk
@@ -14,6 +14,8 @@ define copy_sanitizer_lib
 install-sanitizers: $$(addprefix $$(build_libdir)/, $$(notdir $$(call pathsearch_all,$(1),$$(SANITIZER_LIB_PATH)))) | $$(build_shlibdir)
 $$(addprefix $$(build_shlibdir)/,$(2)): $$(addprefix $$(SANITIZER_LIB_PATH)/,$(2)) | $$(build_shlibdir)
 	-cp $$< $$@
+	$(if $(filter $(OS), Linux), \
+		-$(PATCHELF) $(PATCHELF_SET_RPATH_ARG) '$$$$ORIGIN' $$@ , 0)
 endef
 
 ifeq ($(USECLANG),1)

From c741bd3d7e29a29dfeb4fcf2144a006669543069 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mateus=20Ara=C3=BAjo?= <maltusan@gmail.com>
Date: Thu, 18 Apr 2024 08:13:49 +0200
Subject: [PATCH 1290/1315] stdlib: faster kronecker product between hermitian
 and symmetric matrices (#53186)

The kronecker product between complex hermitian matrices is again
hermitian, so it can be computed much faster by only doing the upper (or
lower) triangular. As @andreasnoack will surely notice, this only true
for types where `conj(a*b) == conj(a)*conj(b)`, so I'm restricting the
function to act only on real and complex numbers. In the symmetric case,
however, no additional assumption is needed, so I'm letting it act on
anything.

Benchmarking showed that the code is roughly 2 times as fast as the
vanilla kronecker product, as expected. The fastest case was always the
UU case, and the slowest the LU case. The code I used is below
```julia
using LinearAlgebra
using BenchmarkTools
using Quaternions

randrmatrix(d, uplo = :U) = Hermitian(randn(Float64, d, d), uplo)
randcmatrix(d, uplo = :U) = Hermitian(randn(ComplexF64, d, d), uplo)
randsmatrix(d, uplo = :U) = Symmetric(randn(ComplexF64, d, d), uplo)
randqmatrix(d, uplo = :U) = Symmetric(randn(QuaternionF64, d, d), uplo)

dima = 69
dimb = 71
for randmatrix in [randrmatrix, randcmatrix, randsmatrix, randqmatrix]
    for auplo in [:U, :L]
        for buplo in [:U, :L]
            a = randmatrix(dima, auplo)
            b = randmatrix(dimb, buplo)
            c = kron(a,b)
            therm = @belapsed kron!($c, $a, $b)
            C = Matrix(c)
            A = Matrix(a)
            B = Matrix(b)
            told = @belapsed kron!($C, $A, $B)
            @show told/therm
        end
    end
end
```
Weirdly enough, I got this expected speedup in one of my machines, but
when running the benchmark in another I got roughly the same time. I
guess that's a bug with `BechmarkTools`, because that's not consistent
with the times I get running the functions individually, out of the
loop.

Another issue is that although I added a couple of tests, I couldn't get
them to run. Perhaps someone here can tell me what's going on? I could
run the tests from LinearAlgebra, it's just that editing the files made
no difference to what was being run. I did get hundreds of errors from
`triangular.jl`, but that's untouched by my code.

---------

Co-authored-by: Oscar Smith <oscardssmith@gmail.com>
---
 stdlib/LinearAlgebra/src/dense.jl       |   4 +-
 stdlib/LinearAlgebra/src/symmetric.jl   | 124 ++++++++++++++++++++++++
 stdlib/LinearAlgebra/src/triangular.jl  |  74 ++++++++++++++
 stdlib/LinearAlgebra/test/symmetric.jl  |  35 +++++++
 stdlib/LinearAlgebra/test/triangular.jl |   3 +
 5 files changed, 238 insertions(+), 2 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 97a64aee3e721..4ed3b8624c47b 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -491,8 +491,8 @@ julia> reshape(kron(v,w), (length(w), length(v)))
 ```
 """
 function kron(A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S}) where {T,S}
-    R = Matrix{promote_op(*,T,S)}(undef, _kronsize(A, B))
-    return kron!(R, A, B)
+    C = Matrix{promote_op(*,T,S)}(undef, _kronsize(A, B))
+    return kron!(C, A, B)
 end
 function kron(a::AbstractVector{T}, b::AbstractVector{S}) where {T,S}
     c = Vector{promote_op(*,T,S)}(undef, length(a)*length(b))
diff --git a/stdlib/LinearAlgebra/src/symmetric.jl b/stdlib/LinearAlgebra/src/symmetric.jl
index 10b996ca49e36..410140bf7e8be 100644
--- a/stdlib/LinearAlgebra/src/symmetric.jl
+++ b/stdlib/LinearAlgebra/src/symmetric.jl
@@ -525,6 +525,130 @@ for (T, trans, real) in [(:Symmetric, :transpose, :identity), (:(Hermitian{<:Uni
     end
 end
 
+function kron(A::Hermitian{T}, B::Hermitian{S}) where {T<:Union{Real,Complex},S<:Union{Real,Complex}}
+    resultuplo = A.uplo == 'U' || B.uplo == 'U' ? :U : :L
+    C = Hermitian(Matrix{promote_op(*, T, S)}(undef, _kronsize(A, B)), resultuplo)
+    return kron!(C, A, B)
+end
+
+function kron(A::Symmetric{T}, B::Symmetric{S}) where {T<:Number,S<:Number}
+    resultuplo = A.uplo == 'U' || B.uplo == 'U' ? :U : :L
+    C = Symmetric(Matrix{promote_op(*, T, S)}(undef, _kronsize(A, B)), resultuplo)
+    return kron!(C, A, B)
+end
+
+function kron!(C::Hermitian{<:Union{Real,Complex}}, A::Hermitian{<:Union{Real,Complex}}, B::Hermitian{<:Union{Real,Complex}})
+    size(C) == _kronsize(A, B) || throw(DimensionMismatch("kron!"))
+    if ((A.uplo == 'U' || B.uplo == 'U') && C.uplo != 'U') || ((A.uplo == 'L' && B.uplo == 'L') && C.uplo != 'L')
+        throw(ArgumentError("C.uplo must match A.uplo and B.uplo, got $(C.uplo) $(A.uplo) $(B.uplo)"))
+    end
+    _hermkron!(C.data, A.data, B.data, conj, real, A.uplo, B.uplo)
+    return C
+end
+
+function kron!(C::Symmetric{<:Number}, A::Symmetric{<:Number}, B::Symmetric{<:Number})
+    size(C) == _kronsize(A, B) || throw(DimensionMismatch("kron!"))
+    if ((A.uplo == 'U' || B.uplo == 'U') && C.uplo != 'U') || ((A.uplo == 'L' && B.uplo == 'L') && C.uplo != 'L')
+        throw(ArgumentError("C.uplo must match A.uplo and B.uplo, got $(C.uplo) $(A.uplo) $(B.uplo)"))
+    end
+    _hermkron!(C.data, A.data, B.data, identity, identity, A.uplo, B.uplo)
+    return C
+end
+
+function _hermkron!(C, A, B, conj::TC, real::TR, Auplo, Buplo) where {TC,TR}
+    n_A = size(A, 1)
+    n_B = size(B, 1)
+    @inbounds if Auplo == 'U' && Buplo == 'U'
+        for j = 1:n_A
+            jnB = (j - 1) * n_B
+            for i = 1:(j-1)
+                Aij = A[i, j]
+                inB = (i - 1) * n_B
+                for l = 1:n_B
+                    for k = 1:(l-1)
+                        C[inB+k, jnB+l] = Aij * B[k, l]
+                        C[inB+l, jnB+k] = Aij * conj(B[k, l])
+                    end
+                    C[inB+l, jnB+l] = Aij * real(B[l, l])
+                end
+            end
+            Ajj = real(A[j, j])
+            for l = 1:n_B
+                for k = 1:(l-1)
+                    C[jnB+k, jnB+l] = Ajj * B[k, l]
+                end
+                C[jnB+l, jnB+l] = Ajj * real(B[l, l])
+            end
+        end
+    elseif Auplo == 'U' && Buplo == 'L'
+        for j = 1:n_A
+            jnB = (j - 1) * n_B
+            for i = 1:(j-1)
+                Aij = A[i, j]
+                inB = (i - 1) * n_B
+                for l = 1:n_B
+                    C[inB+l, jnB+l] = Aij * real(B[l, l])
+                    for k = (l+1):n_B
+                        C[inB+l, jnB+k] = Aij * conj(B[k, l])
+                        C[inB+k, jnB+l] = Aij * B[k, l]
+                    end
+                end
+            end
+            Ajj = real(A[j, j])
+            for l = 1:n_B
+                C[jnB+l, jnB+l] = Ajj * real(B[l, l])
+                for k = (l+1):n_B
+                    C[jnB+l, jnB+k] = Ajj * conj(B[k, l])
+                end
+            end
+        end
+    elseif Auplo == 'L' && Buplo == 'U'
+        for j = 1:n_A
+            jnB = (j - 1) * n_B
+            Ajj = real(A[j, j])
+            for l = 1:n_B
+                for k = 1:(l-1)
+                    C[jnB+k, jnB+l] = Ajj * B[k, l]
+                end
+                C[jnB+l, jnB+l] = Ajj * real(B[l, l])
+            end
+            for i = (j+1):n_A
+                conjAij = conj(A[i, j])
+                inB = (i - 1) * n_B
+                for l = 1:n_B
+                    for k = 1:(l-1)
+                        C[jnB+k, inB+l] = conjAij * B[k, l]
+                        C[jnB+l, inB+k] = conjAij * conj(B[k, l])
+                    end
+                    C[jnB+l, inB+l] = conjAij * real(B[l, l])
+                end
+            end
+        end
+    else #if Auplo == 'L' && Buplo == 'L'
+        for j = 1:n_A
+            jnB = (j - 1) * n_B
+            Ajj = real(A[j, j])
+            for l = 1:n_B
+                C[jnB+l, jnB+l] = Ajj * real(B[l, l])
+                for k = (l+1):n_B
+                    C[jnB+k, jnB+l] = Ajj * B[k, l]
+                end
+            end
+            for i = (j+1):n_A
+                Aij = A[i, j]
+                inB = (i - 1) * n_B
+                for l = 1:n_B
+                    C[inB+l, jnB+l] = Aij * real(B[l, l])
+                    for k = (l+1):n_B
+                        C[inB+k, jnB+l] = Aij * B[k, l]
+                        C[inB+l, jnB+k] = Aij * conj(B[k, l])
+                    end
+                end
+            end
+        end
+    end
+end
+
 (-)(A::Symmetric) = Symmetric(parentof_applytri(-, A), sym_uplo(A.uplo))
 (-)(A::Hermitian) = Hermitian(parentof_applytri(-, A), sym_uplo(A.uplo))
 
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index a78e838654f37..bc6c2a64a6d7d 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -757,6 +757,80 @@ for op in (:+, :-)
     end
 end
 
+function kron(A::UpperTriangular{T}, B::UpperTriangular{S}) where {T<:Number,S<:Number}
+    C = UpperTriangular(Matrix{promote_op(*, T, S)}(undef, _kronsize(A, B)))
+    return kron!(C, A, B)
+end
+
+function kron(A::LowerTriangular{T}, B::LowerTriangular{S}) where {T<:Number,S<:Number}
+    C = LowerTriangular(Matrix{promote_op(*, T, S)}(undef, _kronsize(A, B)))
+    return kron!(C, A, B)
+end
+
+function kron!(C::UpperTriangular{<:Number}, A::UpperTriangular{<:Number}, B::UpperTriangular{<:Number})
+    size(C) == _kronsize(A, B) || throw(DimensionMismatch("kron!"))
+    _triukron!(C.data, A.data, B.data)
+    return C
+end
+
+function kron!(C::LowerTriangular{<:Number}, A::LowerTriangular{<:Number}, B::LowerTriangular{<:Number})
+    size(C) == _kronsize(A, B) || throw(DimensionMismatch("kron!"))
+    _trilkron!(C.data, A.data, B.data)
+    return C
+end
+
+function _triukron!(C, A, B)
+    n_A = size(A, 1)
+    n_B = size(B, 1)
+    @inbounds for j = 1:n_A
+        jnB = (j - 1) * n_B
+        for i = 1:(j-1)
+            Aij = A[i, j]
+            inB = (i - 1) * n_B
+            for l = 1:n_B
+                for k = 1:l
+                    C[inB+k, jnB+l] = Aij * B[k, l]
+                end
+                for k = 1:(l-1)
+                    C[inB+l, jnB+k] = zero(eltype(C))
+                end
+            end
+        end
+        Ajj = A[j, j]
+        for l = 1:n_B
+            for k = 1:l
+                C[jnB+k, jnB+l] = Ajj * B[k, l]
+            end
+        end
+    end
+end
+
+function _trilkron!(C, A, B)
+    n_A = size(A, 1)
+    n_B = size(B, 1)
+    @inbounds for j = 1:n_A
+        jnB = (j - 1) * n_B
+        Ajj = A[j, j]
+        for l = 1:n_B
+            for k = l:n_B
+                C[jnB+k, jnB+l] = Ajj * B[k, l]
+            end
+        end
+        for i = (j+1):n_A
+            Aij = A[i, j]
+            inB = (i - 1) * n_B
+            for l = 1:n_B
+                for k = l:n_B
+                    C[inB+k, jnB+l] = Aij * B[k, l]
+                end
+                for k = (l+1):n_B
+                    C[inB+l, jnB+k] = zero(eltype(C))
+                end
+            end
+        end
+    end
+end
+
 ######################
 # BlasFloat routines #
 ######################
diff --git a/stdlib/LinearAlgebra/test/symmetric.jl b/stdlib/LinearAlgebra/test/symmetric.jl
index 255e4e398b446..e2a6d2b74ff18 100644
--- a/stdlib/LinearAlgebra/test/symmetric.jl
+++ b/stdlib/LinearAlgebra/test/symmetric.jl
@@ -467,6 +467,28 @@ end
                 @test dot(symblockml, symblockml) ≈ dot(msymblockml, msymblockml)
             end
         end
+
+        @testset "kronecker product of symmetric and Hermitian matrices" begin
+            for mtype in (Symmetric, Hermitian)
+                symau = mtype(a, :U)
+                symal = mtype(a, :L)
+                msymau = Matrix(symau)
+                msymal = Matrix(symal)
+                for eltyc in (Float32, Float64, ComplexF32, ComplexF64, BigFloat, Int)
+                    creal = randn(n, n)/2
+                    cimag = randn(n, n)/2
+                    c = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex.(creal, cimag) : creal)
+                    symcu = mtype(c, :U)
+                    symcl = mtype(c, :L)
+                    msymcu = Matrix(symcu)
+                    msymcl = Matrix(symcl)
+                    @test kron(symau, symcu) ≈ kron(msymau, msymcu)
+                    @test kron(symau, symcl) ≈ kron(msymau, msymcl)
+                    @test kron(symal, symcu) ≈ kron(msymal, msymcu)
+                    @test kron(symal, symcl) ≈ kron(msymal, msymcl)
+                end
+            end
+        end
     end
 end
 
@@ -487,6 +509,7 @@ end
         @test S - S == MS - MS
         @test S*2 == 2*S == 2*MS
         @test S/2 == MS/2
+        @test kron(S,S) == kron(MS,MS)
     end
     @testset "mixed uplo" begin
         Mu = Matrix{Complex{BigFloat}}(undef,2,2)
@@ -502,6 +525,8 @@ end
             MSl = Matrix(Sl)
             @test Su + Sl == Sl + Su == MSu + MSl
             @test Su - Sl == -(Sl - Su) == MSu - MSl
+            @test kron(Su,Sl) == kron(MSu,MSl)
+            @test kron(Sl,Su) == kron(MSl,MSu)
         end
     end
 end
@@ -517,6 +542,16 @@ end
     @test dot(A, B) ≈ dot(Symmetric(A), Symmetric(B))
 end
 
+# let's make sure the analogous bug will not show up with kronecker products
+@testset "kron Hermitian quaternion #52318" begin
+    A, B = [Quaternion.(randn(3,3), randn(3, 3), randn(3, 3), randn(3,3)) |> t -> t + t' for i in 1:2]
+    @test A == Hermitian(A) && B == Hermitian(B)
+    @test kron(A, B) ≈ kron(Hermitian(A), Hermitian(B))
+    A, B = [Quaternion.(randn(3,3), randn(3, 3), randn(3, 3), randn(3,3)) |> t -> t + transpose(t) for i in 1:2]
+    @test A == Symmetric(A) && B == Symmetric(B)
+    @test kron(A, B) ≈ kron(Symmetric(A), Symmetric(B))
+end
+
 #Issue #7647: test xsyevr, xheevr, xstevr drivers.
 @testset "Eigenvalues in interval for $(typeof(Mi7647))" for Mi7647 in
         (Symmetric(diagm(0 => 1.0:3.0)),
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index daed1e9ebab3f..9c23ec92fdc74 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -359,6 +359,7 @@ debug && println("Test basic type functionality")
                 # Binary operations
                 @test A1 + A2 == M1 + M2
                 @test A1 - A2 == M1 - M2
+                @test kron(A1,A2) == kron(M1,M2)
 
                 # Triangular-Triangular multiplication and division
                 @test A1*A2 ≈ M1*M2
@@ -1014,6 +1015,7 @@ end
             @test 2\L == 2\B
             @test real(L) == real(B)
             @test imag(L) == imag(B)
+            @test kron(L,L) == kron(B,B)
             @test transpose!(MT(copy(A))) == transpose(L) broken=!(A isa Matrix)
             @test adjoint!(MT(copy(A))) == adjoint(L) broken=!(A isa Matrix)
         end
@@ -1035,6 +1037,7 @@ end
             @test 2\U == 2\B
             @test real(U) == real(B)
             @test imag(U) == imag(B)
+            @test kron(U,U) == kron(B,B)
             @test transpose!(MT(copy(A))) == transpose(U) broken=!(A isa Matrix)
             @test adjoint!(MT(copy(A))) == adjoint(U) broken=!(A isa Matrix)
         end

From 38a9725e5f795c859c1330c8b8c85e3f00fddb38 Mon Sep 17 00:00:00 2001
From: Timothy <git@tecosaur.net>
Date: Thu, 18 Apr 2024 23:58:47 +0800
Subject: [PATCH 1291/1315] Support case-changes to Annotated{String,Char}s
 (#54013)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previously, any case changes to Annotated{String,Char} types triggered
"fall back to non-annotated type" non-specialised methods. It would be
nice to keep the annotations though, and that can be done so long as we
keep track of any potential changes to the number of bytes taken by each
character on case changes. This is unusual, but can happen with some
letters (e.g. the upper case of 'ſ' is 'S').

To handle this, a helper function annotated_chartransform is introduced.
This allows for efficient uppercase/lowercase methods (about 50%
overhead in managing the annotation ranges, compared to just
transforming a String). The {upper,lower}casefirst and titlecase
transformations are much more inefficient with this style of
implementation, but not prohibitively so. If somebody has a bright idea,
or they emerge as an area deserving of more attention, the performance
characteristics can be improved.

As a bonus, a specialised textwidth method is implemented to avoid the
generic fallback, providing a ~12x performance improvement.

To check that annotated_chartransform is accurate, as are the
specialised case-transformations, a few million random collections of
strings were pre- and post-annotated and checked to be the same in a
fuzzing check performed with Supposition.jl.

    const short_str = Data.Text(Data.Characters(), max_len=20)
    const short_strs = Data.Vectors(short_str, max_size=10)
    const case_transform_fn = Data.SampledFrom((uppercase, lowercase))

    function annot_caseinvariant(f::Function, strs::Vector{String})
        annot_strs =
            map(((i, s),) -> AnnotatedString(s, [(1:ncodeunits(s), :i => i)]),
                enumerate(strs))
        f_annot_strs =
            map(((i, s),) -> AnnotatedString(s, [(1:ncodeunits(s), :i => i)]),
                enumerate(map(f, strs)))
        pre_join = Base.annotated_chartransform(join(annot_strs), f)
        post_join = join(f_annot_strs)
        pre_join == post_join
    end

    @check max_examples=1_000_000 annot_caseinvariant(case_transform_fn, short_strs)

This helped me determine that in annotated_chartransform the "- 1" was
needed with offset position calculation, and that in the "findlast"
calls that less than *or equal* was the correct equality test.
---
 base/strings/annotated.jl | 45 +++++++++++++++++++++++++++++++++
 base/strings/unicode.jl   | 52 ++++++++++++++++++++++++++++++++++++++-
 test/strings/annotated.jl | 27 ++++++++++++++++++++
 3 files changed, 123 insertions(+), 1 deletion(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index a85cdf1b08bbb..28aa092c578bd 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -399,6 +399,51 @@ Get all annotations of `chr`, in the form of a vector of annotation pairs.
 """
 annotations(c::AnnotatedChar) = c.annotations
 
+## Character transformation helper function, c.f. `unicode.jl`.
+
+"""
+    annotated_chartransform(f::Function, str::AnnotatedString, state=nothing)
+
+Transform every character in `str` with `f`, adjusting annotation regions as
+appropriate. `f` must take one of two forms, either:
+- `f(c::Char) -> Char`, or
+- `f(c::Char, state) -> (Char, state)`.
+
+This works by comparing the number of code units of each character before and
+after transforming with `f`, recording and aggregating any differences, then
+applying them to the annotation regions.
+
+Returns an `AnnotatedString{String}` (regardless of the original underling
+string type of `str`).
+"""
+function annotated_chartransform(f::Function, str::AnnotatedString, state=nothing)
+    outstr = IOBuffer()
+    annots = Tuple{UnitRange{Int}, Pair{Symbol, Any}}[]
+    bytepos = firstindex(str) - 1
+    offsets = [bytepos => 0]
+    for c in str.string
+        oldnb = ncodeunits(c)
+        bytepos += oldnb
+        if isnothing(state)
+            c = f(c)
+        else
+            c, state = f(c, state)
+        end
+        nb = write(outstr, c)
+        if nb != oldnb
+            push!(offsets, bytepos => last(last(offsets)) + nb - oldnb)
+        end
+    end
+    for annot in str.annotations
+        region, value = annot
+        start, stop = first(region), last(region)
+        start_offset = last(offsets[findlast(<=(start) ∘ first, offsets)::Int])
+        stop_offset  = last(offsets[findlast(<=(stop) ∘ first, offsets)::Int])
+        push!(annots, ((start + start_offset):(stop + stop_offset), value))
+    end
+    AnnotatedString(String(take!(outstr)), annots)
+end
+
 ## AnnotatedIOBuffer
 
 struct AnnotatedIOBuffer <: AbstractPipe
diff --git a/base/strings/unicode.jl b/base/strings/unicode.jl
index 2e04633b87487..a3b06063b98ac 100644
--- a/base/strings/unicode.jl
+++ b/base/strings/unicode.jl
@@ -4,7 +4,8 @@
 module Unicode
 
 import Base: show, ==, hash, string, Symbol, isless, length, eltype,
-             convert, isvalid, ismalformed, isoverlong, iterate
+             convert, isvalid, ismalformed, isoverlong, iterate,
+             AnnotatedString, AnnotatedChar, annotated_chartransform
 
 # whether codepoints are valid Unicode scalar values, i.e. 0-0xd7ff, 0xe000-0x10ffff
 
@@ -271,6 +272,8 @@ julia> textwidth("March")
 """
 textwidth(s::AbstractString) = mapreduce(textwidth, +, s; init=0)
 
+textwidth(s::AnnotatedString) = textwidth(s.string)
+
 """
     lowercase(c::AbstractChar)
 
@@ -290,6 +293,8 @@ julia> lowercase('Ö')
 lowercase(c::T) where {T<:AbstractChar} = isascii(c) ? ('A' <= c <= 'Z' ? c + 0x20 : c) :
     T(ccall(:utf8proc_tolower, UInt32, (UInt32,), c))
 
+lowercase(c::AnnotatedChar) = AnnotatedChar(lowercase(c.char), annotations(c))
+
 """
     uppercase(c::AbstractChar)
 
@@ -309,6 +314,8 @@ julia> uppercase('ê')
 uppercase(c::T) where {T<:AbstractChar} = isascii(c) ? ('a' <= c <= 'z' ? c - 0x20 : c) :
     T(ccall(:utf8proc_toupper, UInt32, (UInt32,), c))
 
+uppercase(c::AnnotatedChar) = AnnotatedChar(uppercase(c.char), annotations(c))
+
 """
     titlecase(c::AbstractChar)
 
@@ -332,6 +339,8 @@ julia> uppercase('dž')
 titlecase(c::T) where {T<:AbstractChar} = isascii(c) ? ('a' <= c <= 'z' ? c - 0x20 : c) :
     T(ccall(:utf8proc_totitle, UInt32, (UInt32,), c))
 
+titlecase(c::AnnotatedChar) = AnnotatedChar(titlecase(c.char), annotations(c))
+
 ############################################################################
 
 # returns UTF8PROC_CATEGORY code in 0:30 giving Unicode category
@@ -606,6 +615,7 @@ julia> uppercase("Julia")
 ```
 """
 uppercase(s::AbstractString) = map(uppercase, s)
+uppercase(s::AnnotatedString) = annotated_chartransform(uppercase, s)
 
 """
     lowercase(s::AbstractString)
@@ -621,6 +631,7 @@ julia> lowercase("STRINGS AND THINGS")
 ```
 """
 lowercase(s::AbstractString) = map(lowercase, s)
+lowercase(s::AnnotatedString) = annotated_chartransform(lowercase, s)
 
 """
     titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String
@@ -669,6 +680,23 @@ function titlecase(s::AbstractString; wordsep::Function = !isletter, strict::Boo
     return String(take!(b))
 end
 
+# TODO: improve performance characteristics, room for a ~10x improvement.
+function titlecase(s::AnnotatedString; wordsep::Function = !isletter, strict::Bool=true)
+    initial_state = (; startword = true, state = Ref{Int32}(0),
+             c0 = eltype(s)(zero(UInt32)), wordsep, strict)
+    annotated_chartransform(s, initial_state) do c, state
+        if isgraphemebreak!(state.state, state.c0, c) && state.wordsep(c)
+            state = Base.setindex(state, true, :startword)
+            cnew = c
+        else
+            cnew = state.startword ? titlecase(c) : state.strict ? lowercase(c) : c
+            state = Base.setindex(state, false, :startword)
+        end
+        state = Base.setindex(state, c, :c0)
+        cnew, state
+    end
+end
+
 """
     uppercasefirst(s::AbstractString) -> String
 
@@ -693,6 +721,17 @@ function uppercasefirst(s::AbstractString)
     string(c′, SubString(s, nextind(s, 1)))
 end
 
+# TODO: improve performance characteristics, room for a ~5x improvement.
+function uppercasefirst(s::AnnotatedString)
+    annotated_chartransform(s, true) do c, state
+        if state
+            (titlecase(c), false)
+        else
+            (c, state)
+        end
+    end
+end
+
 """
     lowercasefirst(s::AbstractString)
 
@@ -715,6 +754,17 @@ function lowercasefirst(s::AbstractString)
     string(c′, SubString(s, nextind(s, 1)))
 end
 
+# TODO: improve performance characteristics, room for a ~5x improvement.
+function lowercasefirst(s::AnnotatedString)
+    annotated_chartransform(s, true) do c, state
+        if state
+            (lowercase(c), false)
+        else
+            (c, state)
+        end
+    end
+end
+
 ############################################################################
 # iterators for grapheme segmentation
 
diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl
index fda583bf7f778..b70a2350757a2 100644
--- a/test/strings/annotated.jl
+++ b/test/strings/annotated.jl
@@ -108,6 +108,33 @@ end
     @test reverse(str2) == Base.AnnotatedString("esac", [(2:3, :label => "oomph")])
 end
 
+@testset "Unicode" begin
+    for words in (["ᲃase", "cɦɒnɡeȿ", "can", "CHⱯNGE", "Сodeunıts"],
+                  ["Сodeunıts", "ᲃase", "cɦɒnɡeȿ", "can", "CHⱯNGE"])
+        ann_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i => i)])
+                     for (i, w) in enumerate(words)]
+        ann_str = join(ann_words, '-')
+        for transform in (lowercase, uppercase, titlecase)
+            t_words = map(transform, words)
+            ann_t_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i => i)])
+                        for (i, w) in enumerate(t_words)]
+            ann_t_str = join(ann_t_words, '-')
+            t_ann_str = transform(ann_str)
+            @test String(ann_t_str) == String(t_ann_str)
+            @test Base.annotations(ann_t_str) == Base.annotations(t_ann_str)
+        end
+        for transform in (uppercasefirst, lowercasefirst)
+            t_words = vcat(transform(first(words)), words[2:end])
+            ann_t_words = [Base.AnnotatedString(w, [(1:ncodeunits(w), :i => i)])
+                        for (i, w) in enumerate(t_words)]
+            ann_t_str = join(ann_t_words, '-')
+            t_ann_str = transform(ann_str)
+            @test String(ann_t_str) == String(t_ann_str)
+            @test Base.annotations(ann_t_str) == Base.annotations(t_ann_str)
+        end
+    end
+end
+
 @testset "AnnotatedIOBuffer" begin
     aio = Base.AnnotatedIOBuffer()
     # Append-only writing

From 42b3134d9cb0351070d67183eb479b67d22f2c66 Mon Sep 17 00:00:00 2001
From: Timothy <git@tecosaur.net>
Date: Thu, 18 Apr 2024 23:59:44 +0800
Subject: [PATCH 1292/1315] Fix writing of AnnotatedChars to AnnotatedIOBuffer
 (#53941)

The AnnotatedString(::AnnotatedChar) constructor actually does not
exist. Considering that String(::Char) is not defined, and we don't try
this anywhere else, the obvious fix is to just construct the appropriate
AnnotatedString here.

We can think about more properly Char-optimised writes in the future if
it comes up.
---
 base/strings/annotated.jl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl
index 28aa092c578bd..2a331c5133f83 100644
--- a/base/strings/annotated.jl
+++ b/base/strings/annotated.jl
@@ -484,7 +484,8 @@ function write(io::AnnotatedIOBuffer, astr::Union{AnnotatedString, SubString{<:A
     write(io.io, String(astr))
 end
 
-write(io::AnnotatedIOBuffer, c::AnnotatedChar) = write(io, AnnotatedString(c))
+write(io::AnnotatedIOBuffer, c::AnnotatedChar) =
+    write(io, AnnotatedString(string(c), map(a -> (1:ncodeunits(c), a), annotations(c))))
 write(io::AnnotatedIOBuffer, x::AbstractString) = write(io.io, x)
 write(io::AnnotatedIOBuffer, s::Union{SubString{String}, String}) = write(io.io, s)
 write(io::AnnotatedIOBuffer, b::UInt8) = write(io.io, b)

From 148330e443ffb83e71cb54b0cae8c831b35ee5c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lars=20G=C3=B6ttgens?= <lars.goettgens@rwth-aachen.de>
Date: Fri, 19 Apr 2024 00:55:39 +0200
Subject: [PATCH 1293/1315] Fix typo in docs for `partialsortperm` (#54137)

---
 base/sort.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/sort.jl b/base/sort.jl
index 37b05d7c8397a..b0b650adcfcaf 100644
--- a/base/sort.jl
+++ b/base/sort.jl
@@ -1732,7 +1732,7 @@ sort(v::AbstractVector; kws...) = sort!(copymutable(v); kws...)
 ## partialsortperm: the permutation to sort the first k elements of an array ##
 
 """
-    partialsortperm(v, k; by=ientity, lt=isless, rev=false)
+    partialsortperm(v, k; by=identity, lt=isless, rev=false)
 
 Return a partial permutation `I` of the vector `v`, so that `v[I]` returns values of a fully
 sorted version of `v` at index `k`. If `k` is a range, a vector of indices is returned; if

From a67661ebc05b87cf7a441922d0706d6a492dd8a2 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Thu, 18 Apr 2024 20:17:59 -0300
Subject: [PATCH 1294/1315] add function to query GC page size (#54115)

---
 src/gc-pages.c |  5 +++++
 test/gc.jl     | 10 ++++++++++
 2 files changed, 15 insertions(+)

diff --git a/src/gc-pages.c b/src/gc-pages.c
index 696f0831762be..698cf84c3cfb6 100644
--- a/src/gc-pages.c
+++ b/src/gc-pages.c
@@ -9,6 +9,11 @@
 extern "C" {
 #endif
 
+JL_DLLEXPORT uint64_t jl_get_pg_size(void)
+{
+    return GC_PAGE_SZ;
+}
+
 // Try to allocate memory in chunks to permit faster allocation
 // and improve memory locality of the pools
 #ifdef _P64
diff --git a/test/gc.jl b/test/gc.jl
index d5990582cc00a..e9960bc907438 100644
--- a/test/gc.jl
+++ b/test/gc.jl
@@ -22,6 +22,12 @@ function run_nonzero_page_utilization_test()
     @test any(page_utilization .> 0)
 end
 
+function run_pg_size_test()
+    page_size = @ccall jl_get_pg_size()::UInt64
+    # supported page sizes: 4KB and 16KB
+    @test page_size == (1 << 12) || page_size == (1 << 14)
+end
+
 # !!! note:
 #     Since we run our tests on 32bit OS as well we confine ourselves
 #     to parameters that allocate about 512MB of objects. Max RSS is lower
@@ -31,7 +37,11 @@ end
     run_gctest("gc/linkedlist.jl")
     run_gctest("gc/objarray.jl")
     run_gctest("gc/chunks.jl")
+end
+
+@testset "GC page metrics" begin
     run_nonzero_page_utilization_test()
+    run_pg_size_test()
 end
 
 @testset "Base.GC docstrings" begin

From f8b4b792c723470e9b6cb2f6ae5b842c9eb43cc1 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 19 Apr 2024 08:50:06 +0900
Subject: [PATCH 1295/1315] inference: handle `LimitedAccuracy` in
 `handle_global_assignment!` (#54130)

`abstract_eval_statement` may return `LimitedAccuracy` so we need to
handle it before applying `widenconst`.

- fixes #54125
---
 base/compiler/abstractinterpretation.jl | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index d76e64c84aaae..e4c436c94f72e 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2845,7 +2845,7 @@ end
 
 function handle_global_assignment!(interp::AbstractInterpreter, frame::InferenceState, lhs::GlobalRef, @nospecialize(newty))
     effect_free = ALWAYS_FALSE
-    nothrow = global_assignment_nothrow(lhs.mod, lhs.name, newty)
+    nothrow = global_assignment_nothrow(lhs.mod, lhs.name, ignorelimited(newty))
     inaccessiblememonly = ALWAYS_FALSE
     if !nothrow
         sub_curr_ssaflag!(frame, IR_FLAG_NOTHROW)
@@ -3050,7 +3050,6 @@ end
         return BasicStmtChange(nothing, rt, exct)
     end
     changes = nothing
-    stmt = stmt::Expr
     hd = stmt.head
     if hd === :(=)
         (; rt, exct) = abstract_eval_statement(interp, stmt.args[2], pc_vartable, frame)

From 7f8635f11cae5f3f592afcc7b55c8e0e23589c3d Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 19 Apr 2024 13:05:35 +0900
Subject: [PATCH 1296/1315] refactor `abstract_eval_statement_expr` (#54111)

This commit divides the various expr handlings into `abstract_eval_xxx`
subroutines in order to make the logic clearer and easier to follow.
---
 base/compiler/abstractinterpretation.jl | 478 ++++++++++++------------
 base/compiler/ssair/irinterp.jl         |   6 +-
 test/compiler/inference.jl              |   7 +
 3 files changed, 258 insertions(+), 233 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index e4c436c94f72e..76908136113cf 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -2349,7 +2349,9 @@ function abstract_eval_cfunction(interp::AbstractInterpreter, e::Expr, vtypes::U
     # but some of the result is likely to be valid anyways
     # and that may help generate better codegen
     abstract_call(interp, ArgInfo(nothing, at), StmtInfo(false), sv)
-    nothing
+    rt = e.args[1]
+    isa(rt, Type) || (rt = Any)
+    return RTEffects(rt, Any, EFFECTS_UNKNOWN)
 end
 
 function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(e), vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
@@ -2383,10 +2385,9 @@ function abstract_eval_special_value(interp::AbstractInterpreter, @nospecialize(
 end
 
 function abstract_eval_value_expr(interp::AbstractInterpreter, e::Expr, sv::AbsIntState)
-    if e.head === :call
+    if e.head === :call && length(e.args) ≥ 1
         # TODO: We still have non-linearized cglobal
-        @assert e.args[1] === Core.tuple ||
-                e.args[1] === GlobalRef(Core, :tuple)
+        @assert e.args[1] === Core.tuple || e.args[1] === GlobalRef(Core, :tuple)
     else
         # Some of our tests expect us to handle invalid IR here and error later
         # - permit that for now.
@@ -2428,11 +2429,9 @@ end
 
 function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo, sv::InferenceState)
     si = StmtInfo(!call_result_unused(sv, sv.currpc))
-    (; rt, exct, effects, info) = abstract_call(interp, arginfo, si, sv)
-    sv.stmt_info[sv.currpc] = info
-    # mark this call statement as DCE-eligible
-    # TODO better to do this in a single pass based on the `info` object at the end of abstractinterpret?
-    return RTEffects(rt, exct, effects)
+    call = abstract_call(interp, arginfo, si, sv)
+    sv.stmt_info[sv.currpc] = call.info
+    return call
 end
 
 function abstract_eval_call(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
@@ -2443,257 +2442,276 @@ function abstract_eval_call(interp::AbstractInterpreter, e::Expr, vtypes::Union{
         return RTEffects(Bottom, Any, Effects())
     end
     arginfo = ArgInfo(ea, argtypes)
-    return abstract_call(interp, arginfo, sv)
-end
-
-function abstract_eval_the_exception(interp::AbstractInterpreter, sv::InferenceState)
-    return sv.handlers[sv.handler_at[sv.currpc][2]].exct
+    (; rt, exct, effects) = abstract_call(interp, arginfo, sv)
+    return RTEffects(rt, exct, effects)
 end
-abstract_eval_the_exception(::AbstractInterpreter, ::IRInterpretationState) = Any
 
-function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
-                                      sv::AbsIntState)
-    effects = Effects()
-    ehead = e.head
+function abstract_eval_new(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
+                           sv::AbsIntState)
     𝕃ᵢ = typeinf_lattice(interp)
-    ⊑ᵢ = ⊑(𝕃ᵢ)
-    exct = Any
-    if ehead === :call
-        (; rt, exct, effects) = abstract_eval_call(interp, e, vtypes, sv)
-        t = rt
-    elseif ehead === :new
-        t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
-        ut = unwrap_unionall(t)
-        exct = Union{ErrorException, TypeError}
-        if isa(ut, DataType) && !isabstracttype(ut)
-            ismutable = ismutabletype(ut)
-            fcount = datatype_fieldcount(ut)
-            nargs = length(e.args) - 1
-            has_any_uninitialized = (fcount === nothing || (fcount > nargs && (let t = t
-                    any(i::Int -> !is_undefref_fieldtype(fieldtype(t, i)), (nargs+1):fcount)
-                end)))
-            if has_any_uninitialized
-                # allocation with undefined field is inconsistent always
-                consistent = ALWAYS_FALSE
-            elseif ismutable
-                # mutable allocation isn't `:consistent`, but we still have a chance that
-                # return type information later refines the `:consistent`-cy of the method
-                consistent = CONSISTENT_IF_NOTRETURNED
-            else
-                consistent = ALWAYS_TRUE # immutable allocation is consistent
-            end
-            if isconcretedispatch(t)
-                nothrow = true
-                @assert fcount !== nothing && fcount ≥ nargs "malformed :new expression" # syntactically enforced by the front-end
-                ats = Vector{Any}(undef, nargs)
-                local anyrefine = false
-                local allconst = true
-                for i = 1:nargs
-                    at = widenslotwrapper(abstract_eval_value(interp, e.args[i+1], vtypes, sv))
-                    ft = fieldtype(t, i)
-                    nothrow && (nothrow = at ⊑ᵢ ft)
-                    at = tmeet(𝕃ᵢ, at, ft)
-                    at === Bottom && @goto always_throw
-                    if ismutable && !isconst(t, i)
-                        ats[i] = ft # can't constrain this field (as it may be modified later)
-                        continue
-                    end
-                    allconst &= isa(at, Const)
-                    if !anyrefine
-                        anyrefine = has_nontrivial_extended_info(𝕃ᵢ, at) || # extended lattice information
-                                    ⋤(𝕃ᵢ, at, ft) # just a type-level information, but more precise than the declared type
-                    end
-                    ats[i] = at
+    rt, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
+    ut = unwrap_unionall(rt)
+    exct = Union{ErrorException,TypeError}
+    if isa(ut, DataType) && !isabstracttype(ut)
+        ismutable = ismutabletype(ut)
+        fcount = datatype_fieldcount(ut)
+        nargs = length(e.args) - 1
+        has_any_uninitialized = (fcount === nothing || (fcount > nargs && (let t = rt
+                any(i::Int -> !is_undefref_fieldtype(fieldtype(t, i)), (nargs+1):fcount)
+            end)))
+        if has_any_uninitialized
+            # allocation with undefined field is inconsistent always
+            consistent = ALWAYS_FALSE
+        elseif ismutable
+            # mutable allocation isn't `:consistent`, but we still have a chance that
+            # return type information later refines the `:consistent`-cy of the method
+            consistent = CONSISTENT_IF_NOTRETURNED
+        else
+            consistent = ALWAYS_TRUE # immutable allocation is consistent
+        end
+        if isconcretedispatch(rt)
+            nothrow = true
+            @assert fcount !== nothing && fcount ≥ nargs "malformed :new expression" # syntactically enforced by the front-end
+            ats = Vector{Any}(undef, nargs)
+            local anyrefine = false
+            local allconst = true
+            for i = 1:nargs
+                at = widenslotwrapper(abstract_eval_value(interp, e.args[i+1], vtypes, sv))
+                ft = fieldtype(rt, i)
+                nothrow && (nothrow = ⊑(𝕃ᵢ, at, ft))
+                at = tmeet(𝕃ᵢ, at, ft)
+                at === Bottom && return RTEffects(Bottom, TypeError, EFFECTS_THROWS)
+                if ismutable && !isconst(rt, i)
+                    ats[i] = ft # can't constrain this field (as it may be modified later)
+                    continue
                 end
-                # For now, don't allow:
-                # - Const/PartialStruct of mutables (but still allow PartialStruct of mutables
-                #   with `const` fields if anything refined)
-                # - partially initialized Const/PartialStruct
-                if fcount == nargs
-                    if consistent === ALWAYS_TRUE && allconst
-                        argvals = Vector{Any}(undef, nargs)
-                        for j in 1:nargs
-                            argvals[j] = (ats[j]::Const).val
-                        end
-                        t = Const(ccall(:jl_new_structv, Any, (Any, Ptr{Cvoid}, UInt32), t, argvals, nargs))
-                    elseif anyrefine
-                        t = PartialStruct(t, ats)
+                allconst &= isa(at, Const)
+                if !anyrefine
+                    anyrefine = has_nontrivial_extended_info(𝕃ᵢ, at) || # extended lattice information
+                                ⋤(𝕃ᵢ, at, ft) # just a type-level information, but more precise than the declared type
+                end
+                ats[i] = at
+            end
+            # For now, don't allow:
+            # - Const/PartialStruct of mutables (but still allow PartialStruct of mutables
+            #   with `const` fields if anything refined)
+            # - partially initialized Const/PartialStruct
+            if fcount == nargs
+                if consistent === ALWAYS_TRUE && allconst
+                    argvals = Vector{Any}(undef, nargs)
+                    for j in 1:nargs
+                        argvals[j] = (ats[j]::Const).val
                     end
+                    rt = Const(ccall(:jl_new_structv, Any, (Any, Ptr{Cvoid}, UInt32), rt, argvals, nargs))
+                elseif anyrefine
+                    rt = PartialStruct(rt, ats)
                 end
-            else
-                t = refine_partial_type(t)
-                nothrow = false
             end
         else
-            consistent = ALWAYS_FALSE
+            rt = refine_partial_type(rt)
             nothrow = false
         end
-        effects = Effects(EFFECTS_TOTAL; consistent, nothrow)
-        nothrow && (exct = Union{})
-    elseif ehead === :splatnew
-        t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
-        nothrow = false # TODO: More precision
-        if length(e.args) == 2 && isconcretedispatch(t) && !ismutabletype(t)
-            at = abstract_eval_value(interp, e.args[2], vtypes, sv)
-            n = fieldcount(t)
-            if (isa(at, Const) && isa(at.val, Tuple) && n == length(at.val::Tuple) &&
-                (let t = t, at = at
-                    all(i::Int->getfield(at.val::Tuple, i) isa fieldtype(t, i), 1:n)
+    else
+        consistent = ALWAYS_FALSE
+        nothrow = false
+    end
+    nothrow && (exct = Union{})
+    effects = Effects(EFFECTS_TOTAL; consistent, nothrow)
+    return RTEffects(rt, exct, effects)
+end
+
+function abstract_eval_splatnew(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
+                                sv::AbsIntState)
+    𝕃ᵢ = typeinf_lattice(interp)
+    rt, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
+    nothrow = false
+    if length(e.args) == 2 && isconcretedispatch(rt) && !ismutabletype(rt)
+        at = abstract_eval_value(interp, e.args[2], vtypes, sv)
+        n = fieldcount(rt)
+        if (isa(at, Const) && isa(at.val, Tuple) && n == length(at.val::Tuple) &&
+            (let t = rt, at = at
+                all(i::Int -> getfield(at.val::Tuple, i) isa fieldtype(t, i), 1:n)
+            end))
+            nothrow = isexact
+            rt = Const(ccall(:jl_new_structt, Any, (Any, Any), rt, at.val))
+        elseif (isa(at, PartialStruct) && ⊑(𝕃ᵢ, at, Tuple) && n > 0 &&
+                n == length(at.fields::Vector{Any}) && !isvarargtype(at.fields[end]) &&
+                (let t = rt, at = at
+                    all(i::Int -> ⊑(𝕃ᵢ, (at.fields::Vector{Any})[i], fieldtype(t, i)), 1:n)
                 end))
-                nothrow = isexact
-                t = Const(ccall(:jl_new_structt, Any, (Any, Any), t, at.val))
-            elseif (isa(at, PartialStruct) && at ⊑ᵢ Tuple && n > 0 && n == length(at.fields::Vector{Any}) && !isvarargtype(at.fields[end]) &&
-                    (let t = t, at = at, ⊑ᵢ = ⊑ᵢ
-                        all(i::Int->(at.fields::Vector{Any})[i] ⊑ᵢ fieldtype(t, i), 1:n)
-                    end))
-                nothrow = isexact
-                t = PartialStruct(t, at.fields::Vector{Any})
+            nothrow = isexact
+            rt = PartialStruct(rt, at.fields::Vector{Any})
+        end
+    else
+        rt = refine_partial_type(rt)
+    end
+    consistent = !ismutabletype(rt) ? ALWAYS_TRUE : CONSISTENT_IF_NOTRETURNED
+    effects = Effects(EFFECTS_TOTAL; consistent, nothrow)
+    return RTEffects(rt, Any, effects)
+end
+
+function abstract_eval_new_opaque_closure(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
+                                          sv::AbsIntState)
+    𝕃ᵢ = typeinf_lattice(interp)
+    rt = Union{}
+    effects = Effects() # TODO
+    if length(e.args) >= 4
+        ea = e.args
+        argtypes = collect_argtypes(interp, ea, vtypes, sv)
+        if argtypes === nothing
+            rt = Bottom
+            effects = EFFECTS_THROWS
+        else
+            mi = frame_instance(sv)
+            rt = opaque_closure_tfunc(𝕃ᵢ, argtypes[1], argtypes[2], argtypes[3],
+                argtypes[4], argtypes[5:end], mi)
+            if isa(rt, PartialOpaque) && isa(sv, InferenceState) && !call_result_unused(sv, sv.currpc)
+                # Infer this now so that the specialization is available to
+                # optimization.
+                argtypes = most_general_argtypes(rt)
+                pushfirst!(argtypes, rt.env)
+                callinfo = abstract_call_opaque_closure(interp, rt,
+                    ArgInfo(nothing, argtypes), StmtInfo(true), sv, #=check=#false)
+                sv.stmt_info[sv.currpc] = OpaqueClosureCreateInfo(callinfo)
             end
+        end
+    end
+    return RTEffects(rt, Any, effects)
+end
+
+function abstract_eval_copyast(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
+                               sv::AbsIntState)
+    effects = EFFECTS_UNKNOWN
+    rt = abstract_eval_value(interp, e.args[1], vtypes, sv)
+    if rt isa Const && rt.val isa Expr
+        # `copyast` makes copies of Exprs
+        rt = Expr
+    end
+    return RTEffects(rt, Any, effects)
+end
+
+function abstract_eval_isdefined(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
+                                 sv::AbsIntState)
+    sym = e.args[1]
+    rt = Bool
+    effects = EFFECTS_TOTAL
+    exct = Union{}
+    isa(sym, Symbol) && (sym = GlobalRef(frame_module(sv), sym))
+    if isa(sym, SlotNumber) && vtypes !== nothing
+        vtyp = vtypes[slot_id(sym)]
+        if vtyp.typ === Bottom
+            rt = Const(false) # never assigned previously
+        elseif !vtyp.undef
+            rt = Const(true) # definitely assigned previously
+        end
+    elseif isa(sym, GlobalRef)
+        if InferenceParams(interp).assume_bindings_static
+            rt = Const(isdefined_globalref(sym))
+        elseif isdefinedconst_globalref(sym)
+            rt = Const(true)
         else
-            t = refine_partial_type(t)
+            effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE)
         end
-        consistent = !ismutabletype(t) ? ALWAYS_TRUE : CONSISTENT_IF_NOTRETURNED
-        effects = Effects(EFFECTS_TOTAL; consistent, nothrow)
-    elseif ehead === :new_opaque_closure
-        t = Union{}
-        effects = Effects() # TODO
-        merge_effects!(interp, sv, effects)
-        if length(e.args) >= 4
-            ea = e.args
-            argtypes = collect_argtypes(interp, ea, vtypes, sv)
-            if argtypes === nothing
-                t = Bottom
-            else
-                mi = frame_instance(sv)
-                t = opaque_closure_tfunc(𝕃ᵢ, argtypes[1], argtypes[2], argtypes[3],
-                    argtypes[4], argtypes[5:end], mi)
-                if isa(t, PartialOpaque) && isa(sv, InferenceState) && !call_result_unused(sv, sv.currpc)
-                    # Infer this now so that the specialization is available to
-                    # optimization.
-                    argtypes = most_general_argtypes(t)
-                    pushfirst!(argtypes, t.env)
-                    callinfo = abstract_call_opaque_closure(interp, t,
-                        ArgInfo(nothing, argtypes), StmtInfo(true), sv, #=check=#false)
-                    sv.stmt_info[sv.currpc] = OpaqueClosureCreateInfo(callinfo)
-                end
+    elseif isexpr(sym, :static_parameter)
+        n = sym.args[1]::Int
+        if 1 <= n <= length(sv.sptypes)
+            sp = sv.sptypes[n]
+            if !sp.undef
+                rt = Const(true)
+            elseif sp.typ === Bottom
+                rt = Const(false)
             end
         end
+    else
+        effects = EFFECTS_UNKNOWN
+    end
+    return RTEffects(rt, exct, effects)
+end
+
+function abstract_eval_throw_undef_if_not(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing}, sv::AbsIntState)
+    condt = abstract_eval_value(interp, e.args[2], vtypes, sv)
+    condval = maybe_extract_const_bool(condt)
+    rt = Nothing
+    exct = UndefVarError
+    effects = EFFECTS_THROWS
+    if condval isa Bool
+        if condval
+            effects = EFFECTS_TOTAL
+            exct = Union{}
+        else
+            rt = Union{}
+        end
+    elseif !hasintersect(widenconst(condt), Bool)
+        rt = Union{}
+    end
+    return RTEffects(rt, exct, effects)
+end
+
+abstract_eval_the_exception(::AbstractInterpreter, sv::InferenceState) =
+    the_exception_info(sv.handlers[sv.handler_at[sv.currpc][2]].exct)
+abstract_eval_the_exception(::AbstractInterpreter, ::IRInterpretationState) = the_exception_info(Any)
+the_exception_info(@nospecialize t) = RTEffects(t, Union{}, Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE))
+
+function abstract_eval_static_parameter(::AbstractInterpreter, e::Expr, sv::AbsIntState)
+    n = e.args[1]::Int
+    nothrow = false
+    if 1 <= n <= length(sv.sptypes)
+        sp = sv.sptypes[n]
+        rt = sp.typ
+        nothrow = !sp.undef
+    else
+        rt = Any
+    end
+    exct = nothrow ? Union{} : UndefVarError
+    effects = Effects(EFFECTS_TOTAL; nothrow)
+    return RTEffects(rt, exct, effects)
+end
+
+function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtypes::Union{VarTable,Nothing},
+                                      sv::AbsIntState)
+    ehead = e.head
+    if ehead === :call
+        return abstract_eval_call(interp, e, vtypes, sv)
+    elseif ehead === :new
+        return abstract_eval_new(interp, e, vtypes, sv)
+    elseif ehead === :splatnew
+        return abstract_eval_splatnew(interp, e, vtypes, sv)
+    elseif ehead === :new_opaque_closure
+        return abstract_eval_new_opaque_closure(interp, e, vtypes, sv)
     elseif ehead === :foreigncall
-        (; rt, exct, effects) = abstract_eval_foreigncall(interp, e, vtypes, sv)
-        t = rt
+        return abstract_eval_foreigncall(interp, e, vtypes, sv)
     elseif ehead === :cfunction
-        effects = EFFECTS_UNKNOWN
-        t = e.args[1]
-        isa(t, Type) || (t = Any)
-        abstract_eval_cfunction(interp, e, vtypes, sv)
+        return abstract_eval_cfunction(interp, e, vtypes, sv)
     elseif ehead === :method
-        t = (length(e.args) == 1) ? Any : Nothing
-        effects = EFFECTS_UNKNOWN
+        rt = (length(e.args) == 1) ? Any : Nothing
+        return RTEffects(rt, Any, EFFECTS_UNKNOWN)
     elseif ehead === :copyast
-        effects = EFFECTS_UNKNOWN
-        t = abstract_eval_value(interp, e.args[1], vtypes, sv)
-        if t isa Const && t.val isa Expr
-            # `copyast` makes copies of Exprs
-            t = Expr
-        end
+        return abstract_eval_copyast(interp, e, vtypes, sv)
     elseif ehead === :invoke || ehead === :invoke_modify
         error("type inference data-flow error: tried to double infer a function")
     elseif ehead === :isdefined
-        sym = e.args[1]
-        t = Bool
-        effects = EFFECTS_TOTAL
-        exct = Union{}
-        isa(sym, Symbol) && (sym = GlobalRef(frame_module(sv), sym))
-        if isa(sym, SlotNumber) && vtypes !== nothing
-            vtyp = vtypes[slot_id(sym)]
-            if vtyp.typ === Bottom
-                t = Const(false) # never assigned previously
-            elseif !vtyp.undef
-                t = Const(true) # definitely assigned previously
-            end
-        elseif isa(sym, GlobalRef)
-            if InferenceParams(interp).assume_bindings_static
-                t = Const(isdefined_globalref(sym))
-            elseif isdefinedconst_globalref(sym)
-                t = Const(true)
-            else
-                effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE)
-            end
-        elseif isexpr(sym, :static_parameter)
-            n = sym.args[1]::Int
-            if 1 <= n <= length(sv.sptypes)
-                sp = sv.sptypes[n]
-                if !sp.undef
-                    t = Const(true)
-                elseif sp.typ === Bottom
-                    t = Const(false)
-                end
-            end
-        else
-            effects = EFFECTS_UNKNOWN
-        end
+        return abstract_eval_isdefined(interp, e, vtypes, sv)
     elseif ehead === :throw_undef_if_not
-        condt = abstract_eval_value(interp, e.args[2], vtypes, sv)
-        condval = maybe_extract_const_bool(condt)
-        t = Nothing
-        exct = UndefVarError
-        effects = EFFECTS_THROWS
-        if condval isa Bool
-            if condval
-                effects = EFFECTS_TOTAL
-                exct = Union{}
-            else
-                t = Union{}
-            end
-        elseif !hasintersect(widenconst(condt), Bool)
-            t = Union{}
-        end
+        return abstract_eval_throw_undef_if_not(interp, e, vtypes, sv)
     elseif ehead === :boundscheck
-        t = Bool
-        exct = Union{}
-        effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE)
+        return RTEffects(Bool, Union{}, Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE))
     elseif ehead === :the_exception
-        t = abstract_eval_the_exception(interp, sv)
-        exct = Union{}
-        effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE)
+        return abstract_eval_the_exception(interp, sv)
     elseif ehead === :static_parameter
-        n = e.args[1]::Int
-        nothrow = false
-        exct = UndefVarError
-        if 1 <= n <= length(sv.sptypes)
-            sp = sv.sptypes[n]
-            t = sp.typ
-            nothrow = !sp.undef
-        else
-            t = Any
-        end
-        if nothrow
-            exct = Union{}
-        end
-        effects = Effects(EFFECTS_TOTAL; nothrow)
+        return abstract_eval_static_parameter(interp, e, sv)
     elseif ehead === :gc_preserve_begin || ehead === :aliasscope
-        t = Any
-        exct = Union{}
-        effects = Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE, effect_free=EFFECT_FREE_GLOBALLY)
-    elseif ehead === :gc_preserve_end || ehead === :leave || ehead === :pop_exception || ehead === :global || ehead === :popaliasscope
-        t = Nothing
-        exct = Union{}
-        effects = Effects(EFFECTS_TOTAL; effect_free=EFFECT_FREE_GLOBALLY)
+        return RTEffects(Any, Union{}, Effects(EFFECTS_TOTAL; consistent=ALWAYS_FALSE, effect_free=EFFECT_FREE_GLOBALLY))
+    elseif ehead === :gc_preserve_end || ehead === :leave || ehead === :pop_exception ||
+           ehead === :global || ehead === :popaliasscope
+        return RTEffects(Nothing, Union{}, Effects(EFFECTS_TOTAL; effect_free=EFFECT_FREE_GLOBALLY))
     elseif ehead === :thunk
-        t = Any
-        effects = EFFECTS_UNKNOWN
-    elseif false
-        @label always_throw
-        t = Bottom
-        effects = EFFECTS_THROWS
-    else
-        t = abstract_eval_value_expr(interp, e, sv)
-        # N.B.: abstract_eval_value_expr can modify the global effects, but
-        # we move out any arguments with effects during SSA construction later
-        # and recompute the effects.
-        effects = EFFECTS_TOTAL
+        return RTEffects(Any, Any, EFFECTS_UNKNOWN)
     end
-    return RTEffects(t, exct, effects)
+    # N.B.: abstract_eval_value_expr can modify the global effects, but
+    # we move out any arguments with effects during SSA construction later
+    # and recompute the effects.
+    rt = abstract_eval_value_expr(interp, e, sv)
+    return RTEffects(rt, Any, EFFECTS_TOTAL)
 end
 
 # refine the result of instantiation of partially-known type `t` if some invariant can be assumed
diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index f68006ed686b5..05d78e8706072 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -51,9 +51,9 @@ end
 
 function abstract_call(interp::AbstractInterpreter, arginfo::ArgInfo, irsv::IRInterpretationState)
     si = StmtInfo(true) # TODO better job here?
-    (; rt, exct, effects, info) = abstract_call(interp, arginfo, si, irsv)
-    irsv.ir.stmts[irsv.curridx][:info] = info
-    return RTEffects(rt, exct, effects)
+    call = abstract_call(interp, arginfo, si, irsv)
+    irsv.ir.stmts[irsv.curridx][:info] = call.info
+    return call
 end
 
 function kill_block!(ir::IRCode, bb::Int)
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 7bc1032828c80..358b165f1d7e8 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5600,6 +5600,13 @@ end |> only === Float64
 @test Base.infer_exception_type(c::Missing -> c ? 1 : 2) == TypeError
 @test Base.infer_exception_type(c::Any -> c ? 1 : 2) == TypeError
 
+# exception type inference for `:new`
+struct NewExctInference
+    a::Int
+    @eval NewExctInference(a) = $(Expr(:new, :NewExctInference, :a))
+end
+@test Base.infer_exception_type(NewExctInference, (Float64,)) == TypeError
+
 # semi-concrete interpretation accuracy
 # https://github.com/JuliaLang/julia/issues/50037
 @inline countvars50037(bitflags::Int, var::Int) = bitflags >> 0

From 2f9096218bf7b488dd7a2b6688365ba108a0e71f Mon Sep 17 00:00:00 2001
From: alongdate <167442392+alongdate@users.noreply.github.com>
Date: Fri, 19 Apr 2024 20:25:49 +0800
Subject: [PATCH 1297/1315] Fix some typos in comments (#54149)

Signed-off-by: alongdate <alongyear@outlook.com>
---
 contrib/generate_precompile.jl | 2 +-
 src/staticdata_utils.c         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/contrib/generate_precompile.jl b/contrib/generate_precompile.jl
index 92dde676244e4..1152e20d16842 100644
--- a/contrib/generate_precompile.jl
+++ b/contrib/generate_precompile.jl
@@ -171,7 +171,7 @@ for match = Base._methods(+, (Int, Int), -1, Base.get_world_counter())
         println(k)
     end
 
-    # interactive statup uses this
+    # interactive startup uses this
     write(IOBuffer(), "")
 
     break   # only actually need to do this once
diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c
index 9542e54182644..9c7a810b65ad9 100644
--- a/src/staticdata_utils.c
+++ b/src/staticdata_utils.c
@@ -619,7 +619,7 @@ JL_DLLEXPORT uint8_t jl_match_cache_flags(uint8_t requested_flags, uint8_t actua
         actual_flags &= ~1;
     }
 
-    // 2. Check all flags, execept opt level must be exact
+    // 2. Check all flags, except opt level must be exact
     uint8_t mask = (1 << OPT_LEVEL)-1;
     if ((actual_flags & mask) != (requested_flags & mask))
         return 0;

From 3364aa5e93bc9821a5e4e328f1c622792ff2f973 Mon Sep 17 00:00:00 2001
From: Lilith Orion Hafner <lilithhafner@gmail.com>
Date: Fri, 19 Apr 2024 16:50:57 -0500
Subject: [PATCH 1298/1315] Force specialization on number of args passed to
 anonymous function constructed by `oror` and `andand` (#54152)

These functions should only accept one argument signature so we should fully specialize.
---
 base/broadcast.jl | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/base/broadcast.jl b/base/broadcast.jl
index 30c982ae05117..1928535770f92 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -196,14 +196,18 @@ const andand = AndAnd()
 broadcasted(::AndAnd, a, b) = broadcasted((a, b) -> a && b, a, b)
 function broadcasted(::AndAnd, a, bc::Broadcasted)
     bcf = flatten(bc)
-    broadcasted((a, args...) -> a && bcf.f(args...), a, bcf.args...)
+    # Vararg type signature to specialize on args count. This is necessary for performance
+    # and innexpensive because this should only ever get called with 1+N = length(bc.args)
+    broadcasted(((a, args::Vararg{Any, N}) where {N}) -> a && bcf.f(args...), a, bcf.args...)
 end
 struct OrOr end
 const oror = OrOr()
 broadcasted(::OrOr, a, b) = broadcasted((a, b) -> a || b, a, b)
 function broadcasted(::OrOr, a, bc::Broadcasted)
     bcf = flatten(bc)
-    broadcasted((a, args...) -> a || bcf.f(args...), a, bcf.args...)
+    # Vararg type signature to specialize on args count. This is necessary for performance
+    # and innexpensive because this should only ever get called with 1+N = length(bc.args)
+    broadcasted(((a, args::Vararg{Any, N}) where {N}) -> a || bcf.f(args...), a, bcf.args...)
 end
 
 Base.convert(::Type{Broadcasted{NewStyle}}, bc::Broadcasted{<:Any,Axes,F,Args}) where {NewStyle,Axes,F,Args} =
@@ -345,6 +349,7 @@ function flatten(bc::Broadcasted)
     #          makeargs[3] = ((w, x, y, z)) -> z
     makeargs = make_makeargs(bc.args)
     f = Base.maybeconstructor(bc.f)
+    # TODO: consider specializing on args... if performance problems emerge:
     newf = (args...) -> (@inline; f(prepare_args(makeargs, args)...))
     return Broadcasted(bc.style, newf, args, bc.axes)
 end

From 074ea2a47f99e21191e262b89aa3aefea87a18d6 Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Sat, 20 Apr 2024 01:21:27 +0200
Subject: [PATCH 1299/1315] Use getPointerAddressSpace instead of
 cast<PointerType>.getAddressSpace. (#54113)

The former also handles vectors of pointers, which can occur after
vectorization:

```
#5  0x00007f5bfe94de5e in llvm::cast<llvm::PointerType, llvm::Type> (Val=<optimized out>) at llvm/Support/Casting.h:578
578	  assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");

(rr) up
#6  GCInvariantVerifier::visitAddrSpaceCastInst (this=this@entry=0x7ffd022fbf56, I=...) at julia/src/llvm-gc-invariant-verifier.cpp:66
66	    unsigned ToAS = cast<PointerType>(I.getDestTy())->getAddressSpace();

(rr) call I.dump()
%23 = addrspacecast <4 x ptr addrspace(10)> %wide.load to <4 x ptr addrspace(11)>, !dbg !43
```

Fixes aborts seen in https://github.com/JuliaLang/julia/pull/53070
---
 src/cgutils.cpp                          |  6 ++---
 src/llvm-alloc-opt.cpp                   |  5 ++--
 src/llvm-gc-invariant-verifier.cpp       | 29 ++++++++++++------------
 src/llvm-propagate-addrspaces.cpp        |  4 ++--
 test/llvmpasses/gc-invariant-verifier.ll | 13 +++++++++++
 5 files changed, 36 insertions(+), 21 deletions(-)
 create mode 100644 test/llvmpasses/gc-invariant-verifier.ll

diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index 8385b5682a0bc..344bc7c5be5b2 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -57,7 +57,7 @@ static Value *maybe_decay_untracked(jl_codectx_t &ctx, Value *V)
 static Value *decay_derived(jl_codectx_t &ctx, Value *V)
 {
     Type *T = V->getType();
-    if (cast<PointerType>(T)->getAddressSpace() == AddressSpace::Derived)
+    if (T->getPointerAddressSpace() == AddressSpace::Derived)
         return V;
     // Once llvm deletes pointer element types, we won't need it here any more either.
     Type *NewT = PointerType::getWithSamePointeeType(cast<PointerType>(T), AddressSpace::Derived);
@@ -68,7 +68,7 @@ static Value *decay_derived(jl_codectx_t &ctx, Value *V)
 static Value *maybe_decay_tracked(jl_codectx_t &ctx, Value *V)
 {
     Type *T = V->getType();
-    if (cast<PointerType>(T)->getAddressSpace() != AddressSpace::Tracked)
+    if (T->getPointerAddressSpace() != AddressSpace::Tracked)
         return V;
     Type *NewT = PointerType::getWithSamePointeeType(cast<PointerType>(T), AddressSpace::Derived);
     return ctx.builder.CreateAddrSpaceCast(V, NewT);
@@ -295,7 +295,7 @@ void jl_debugcache_t::initialize(Module *m) {
 
 static Value *emit_pointer_from_objref(jl_codectx_t &ctx, Value *V)
 {
-    unsigned AS = cast<PointerType>(V->getType())->getAddressSpace();
+    unsigned AS = V->getType()->getPointerAddressSpace();
     if (AS != AddressSpace::Tracked && AS != AddressSpace::Derived)
         return V;
     V = decay_derived(ctx, V);
diff --git a/src/llvm-alloc-opt.cpp b/src/llvm-alloc-opt.cpp
index 5df4f52aca425..08a884304747e 100644
--- a/src/llvm-alloc-opt.cpp
+++ b/src/llvm-alloc-opt.cpp
@@ -1067,10 +1067,11 @@ void Optimizer::splitOnStack(CallInst *orig_inst)
                     store_ty = T_pjlvalue;
                 }
                 else {
-                    store_ty = PointerType::getWithSamePointeeType(T_pjlvalue, cast<PointerType>(store_ty)->getAddressSpace());
+                    store_ty = PointerType::getWithSamePointeeType(
+                        T_pjlvalue, store_ty->getPointerAddressSpace());
                     store_val = builder.CreateBitCast(store_val, store_ty);
                 }
-                if (cast<PointerType>(store_ty)->getAddressSpace() != AddressSpace::Tracked)
+                if (store_ty->getPointerAddressSpace() != AddressSpace::Tracked)
                     store_val = builder.CreateAddrSpaceCast(store_val, pass.T_prjlvalue);
                 newstore = builder.CreateStore(store_val, slot.slot);
             }
diff --git a/src/llvm-gc-invariant-verifier.cpp b/src/llvm-gc-invariant-verifier.cpp
index 8c8e2e4546d04..5badbca807569 100644
--- a/src/llvm-gc-invariant-verifier.cpp
+++ b/src/llvm-gc-invariant-verifier.cpp
@@ -62,8 +62,8 @@ struct GCInvariantVerifier : public InstVisitor<GCInvariantVerifier> {
 };
 
 void GCInvariantVerifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
-    unsigned FromAS = cast<PointerType>(I.getSrcTy())->getAddressSpace();
-    unsigned ToAS = cast<PointerType>(I.getDestTy())->getAddressSpace();
+    unsigned FromAS = I.getSrcTy()->getPointerAddressSpace();
+    unsigned ToAS = I.getDestTy()->getPointerAddressSpace();
     if (FromAS == 0)
         return;
     Check(ToAS != AddressSpace::Loaded && FromAS != AddressSpace::Loaded,
@@ -78,10 +78,10 @@ void GCInvariantVerifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
 }
 
 void GCInvariantVerifier::checkStoreInst(Type *VTy, unsigned AS, Value &SI) {
-    if (VTy->isPointerTy()) {
+    if (VTy->isPtrOrPtrVectorTy()) {
         /* We currently don't obey this for arguments. That's ok - they're
            externally rooted. */
-        unsigned AS = cast<PointerType>(VTy)->getAddressSpace();
+        unsigned AS = VTy->getPointerAddressSpace();
         Check(AS != AddressSpace::CalleeRooted &&
               AS != AddressSpace::Derived,
               "Illegal store of decayed value", &SI);
@@ -107,15 +107,15 @@ void GCInvariantVerifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &SI) {
 
 void GCInvariantVerifier::visitLoadInst(LoadInst &LI) {
     Type *Ty = LI.getType();
-    if (Ty->isPointerTy()) {
-        unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
+    if (Ty->isPtrOrPtrVectorTy()) {
+        unsigned AS = Ty->getPointerAddressSpace();
         Check(AS != AddressSpace::CalleeRooted &&
               AS != AddressSpace::Derived,
               "Illegal load of gc relevant value", &LI);
     }
     Ty = LI.getPointerOperand()->getType();
-    if (Ty->isPointerTy()) {
-        unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
+    if (Ty->isPtrOrPtrVectorTy()) {
+        unsigned AS = Ty->getPointerAddressSpace();
         Check(AS != AddressSpace::CalleeRooted,
               "Illegal load of callee rooted value", &LI);
     }
@@ -129,18 +129,18 @@ void GCInvariantVerifier::visitReturnInst(ReturnInst &RI) {
     if (!RI.getReturnValue())
         return;
     Type *RTy = RI.getReturnValue()->getType();
-    if (!RTy->isPointerTy())
+    if (!RTy->isPtrOrPtrVectorTy())
         return;
-    unsigned AS = cast<PointerType>(RTy)->getAddressSpace();
+    unsigned AS = RTy->getPointerAddressSpace();
     Check(!isSpecialAS(AS) || AS == AddressSpace::Tracked,
           "Only gc tracked values may be directly returned", &RI);
 }
 
 void GCInvariantVerifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
     Type *Ty = GEP.getType();
-    if (!Ty->isPointerTy())
+    if (!Ty->isPtrOrPtrVectorTy())
         return;
-    unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
+    unsigned AS = Ty->getPointerAddressSpace();
     if (!isSpecialAS(AS))
         return;
     /* We're actually ok with GEPs here, as long as they don't feed into any
@@ -170,8 +170,9 @@ void GCInvariantVerifier::visitCallInst(CallInst &CI) {
                 continue;
             }
             Type *Ty = Arg->getType();
-            Check(Ty->isPointerTy() && cast<PointerType>(Ty)->getAddressSpace() == AddressSpace::Tracked,
-                "Invalid derived pointer in jlcall", &CI);
+            Check(Ty->isPtrOrPtrVectorTy() &&
+                      Ty->getPointerAddressSpace() == AddressSpace::Tracked,
+                  "Invalid derived pointer in jlcall", &CI);
         }
     }
 }
diff --git a/src/llvm-propagate-addrspaces.cpp b/src/llvm-propagate-addrspaces.cpp
index cc7dace28b24e..485eabefb5f8b 100644
--- a/src/llvm-propagate-addrspaces.cpp
+++ b/src/llvm-propagate-addrspaces.cpp
@@ -60,7 +60,7 @@ struct PropagateJuliaAddrspacesVisitor : public InstVisitor<PropagateJuliaAddrsp
 };
 
 static unsigned getValueAddrSpace(Value *V) {
-    return cast<PointerType>(V->getType())->getAddressSpace();
+    return V->getType()->getPointerAddressSpace();
 }
 
 static bool isSpecialAS(unsigned AS) {
@@ -139,7 +139,7 @@ Value *PropagateJuliaAddrspacesVisitor::LiftPointer(Module *M, Value *V, Instruc
                 break;
             } else {
                 // Ok, we've reached a leaf - check if it is eligible for lifting
-                if (!CurrentV->getType()->isPointerTy() ||
+                if (!CurrentV->getType()->isPtrOrPtrVectorTy() ||
                     isSpecialAS(getValueAddrSpace(CurrentV))) {
                     // If not, poison all (recursive) users of this value, to prevent
                     // looking at them again in future iterations.
diff --git a/test/llvmpasses/gc-invariant-verifier.ll b/test/llvmpasses/gc-invariant-verifier.ll
new file mode 100644
index 0000000000000..ef32521427da1
--- /dev/null
+++ b/test/llvmpasses/gc-invariant-verifier.ll
@@ -0,0 +1,13 @@
+; This file is a part of Julia. License is MIT: https://julialang.org/license
+
+; RUN: opt -enable-new-pm=1 --opaque-pointers=1 --load-pass-plugin=libjulia-codegen%shlibext -passes='function(GCInvariantVerifier)' -S %s | FileCheck %s
+
+; CHECK-LABEL: @vectorized_addrspacecast
+define ptr addrspace(10) @vectorized_addrspacecast() {
+top:
+  ret ptr addrspace(10) null
+
+vector.ph:
+  %0 = addrspacecast <4 x ptr addrspace(10)> zeroinitializer to <4 x ptr addrspace(11)>
+  unreachable
+}

From 8416647fac9c7fca8a265366f3f2ae084abb7710 Mon Sep 17 00:00:00 2001
From: Alexander Plavin <alexander@plav.in>
Date: Sat, 20 Apr 2024 01:35:22 -0400
Subject: [PATCH 1300/1315] split internal dates methods into separate
 functions (#53692)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These methods are clearly internal: not documented, and with unclear
semantics in the general case.

They lead to weird results instead of errors:
```julia
julia> using Unitful

julia> yearmonthday(1u"°")
(0.0, 12.0, 31.017453292519917)

julia> using Measurements

julia> yearmonthday(100±1000)
(1.0 ± 0.0, 4.0 ± 0.0, 10.0 ± 1000.0)
```

So, would be best to really remove them from public functions (hope
noone relies on them).
---
 stdlib/Dates/src/accessors.jl | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/stdlib/Dates/src/accessors.jl b/stdlib/Dates/src/accessors.jl
index 211b5678c90d8..ecb997c7864aa 100644
--- a/stdlib/Dates/src/accessors.jl
+++ b/stdlib/Dates/src/accessors.jl
@@ -2,46 +2,46 @@
 
 # Convert # of Rata Die days to proleptic Gregorian calendar y,m,d,w
 # Reference: https://www.researchgate.net/profile/Peter-Baum/publication/316558298_Date_Algorithms/links/5f90c3f992851c14bcdb0da6/Date-Algorithms.pdf
-function yearmonthday(days)
+function _yearmonthday(days)
     z = days + 306; h = 100z - 25; a = fld(h, 3652425); b = a - fld(a, 4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     d = c - div(153m - 457, 5); return m > 12 ? (y + 1, m - 12, d) : (y, m, d)
 end
-function year(days)
+function _year(days)
    z = days + 306; h = 100z - 25; a = fld(h, 3652425); b = a - fld(a, 4)
    y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
    return m > 12 ? y + 1 : y
 end
-function yearmonth(days)
+function _yearmonth(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     return m > 12 ? (y + 1, m - 12) : (y, m)
 end
-function month(days)
+function _month(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     return m > 12 ? m - 12 : m
 end
-function monthday(days)
+function _monthday(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     d = c - div(153m - 457, 5); return m > 12 ? (m - 12, d) : (m, d)
 end
-function day(days)
+function _day(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     return c - div(153m - 457, 5)
 end
 # https://en.wikipedia.org/wiki/Talk:ISO_week_date#Algorithms
 const WEEK_INDEX = (15, 23, 3, 11)
-function week(days)
+function _week(days)
     w = div(abs(days - 1), 7) % 20871
     c, w = divrem((w + (w >= 10435)), 5218)
     w = (w * 28 + WEEK_INDEX[c + 1]) % 1461
     return div(w, 28) + 1
 end
 
-function quarter(days)
+function _quarter(days)
     m = month(days)
     return m < 4 ? 1 : m < 7 ? 2 : m < 10 ? 3 : 4
 end
@@ -52,11 +52,11 @@ value(dt::TimeType) = dt.instant.periods.value
 value(t::Time) = t.instant.value
 days(dt::Date) = value(dt)
 days(dt::DateTime) = fld(value(dt), 86400000)
-year(dt::TimeType) = year(days(dt))
-quarter(dt::TimeType) = quarter(days(dt))
-month(dt::TimeType) = month(days(dt))
-week(dt::TimeType) = week(days(dt))
-day(dt::TimeType) = day(days(dt))
+year(dt::TimeType) = _year(days(dt))
+quarter(dt::TimeType) = _quarter(days(dt))
+month(dt::TimeType) = _month(days(dt))
+week(dt::TimeType) = _week(days(dt))
+day(dt::TimeType) = _day(days(dt))
 hour(dt::DateTime)   = mod(fld(value(dt), 3600000), 24)
 minute(dt::DateTime) = mod(fld(value(dt), 60000), 60)
 second(dt::DateTime) = mod(fld(value(dt), 1000), 60)
@@ -70,9 +70,9 @@ nanosecond(t::Time) = mod(value(t), Int64(1000))
 
 dayofmonth(dt::TimeType) = day(dt)
 
-yearmonth(dt::TimeType) = yearmonth(days(dt))
-monthday(dt::TimeType) = monthday(days(dt))
-yearmonthday(dt::TimeType) = yearmonthday(days(dt))
+yearmonth(dt::TimeType) = _yearmonth(days(dt))
+monthday(dt::TimeType) = _monthday(days(dt))
+yearmonthday(dt::TimeType) = _yearmonthday(days(dt))
 
 # Documentation for exported accessors
 for func in (:year, :month, :quarter)

From dd443f229cb1617f90c0b6867557facd1de67f04 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Sat, 20 Apr 2024 10:48:41 +0100
Subject: [PATCH 1301/1315] Revert "split internal dates methods into separate
 functions" (#54159)

Reverts JuliaLang/julia#53692, this broke tests.
---
 stdlib/Dates/src/accessors.jl | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/stdlib/Dates/src/accessors.jl b/stdlib/Dates/src/accessors.jl
index ecb997c7864aa..211b5678c90d8 100644
--- a/stdlib/Dates/src/accessors.jl
+++ b/stdlib/Dates/src/accessors.jl
@@ -2,46 +2,46 @@
 
 # Convert # of Rata Die days to proleptic Gregorian calendar y,m,d,w
 # Reference: https://www.researchgate.net/profile/Peter-Baum/publication/316558298_Date_Algorithms/links/5f90c3f992851c14bcdb0da6/Date-Algorithms.pdf
-function _yearmonthday(days)
+function yearmonthday(days)
     z = days + 306; h = 100z - 25; a = fld(h, 3652425); b = a - fld(a, 4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     d = c - div(153m - 457, 5); return m > 12 ? (y + 1, m - 12, d) : (y, m, d)
 end
-function _year(days)
+function year(days)
    z = days + 306; h = 100z - 25; a = fld(h, 3652425); b = a - fld(a, 4)
    y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
    return m > 12 ? y + 1 : y
 end
-function _yearmonth(days)
+function yearmonth(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     return m > 12 ? (y + 1, m - 12) : (y, m)
 end
-function _month(days)
+function month(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     return m > 12 ? m - 12 : m
 end
-function _monthday(days)
+function monthday(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     d = c - div(153m - 457, 5); return m > 12 ? (m - 12, d) : (m, d)
 end
-function _day(days)
+function day(days)
     z = days + 306; h = 100z - 25; a = fld(h,3652425); b = a - fld(a,4)
     y = fld(100b + h, 36525); c = b + z - 365y - fld(y, 4); m = div(5c + 456, 153)
     return c - div(153m - 457, 5)
 end
 # https://en.wikipedia.org/wiki/Talk:ISO_week_date#Algorithms
 const WEEK_INDEX = (15, 23, 3, 11)
-function _week(days)
+function week(days)
     w = div(abs(days - 1), 7) % 20871
     c, w = divrem((w + (w >= 10435)), 5218)
     w = (w * 28 + WEEK_INDEX[c + 1]) % 1461
     return div(w, 28) + 1
 end
 
-function _quarter(days)
+function quarter(days)
     m = month(days)
     return m < 4 ? 1 : m < 7 ? 2 : m < 10 ? 3 : 4
 end
@@ -52,11 +52,11 @@ value(dt::TimeType) = dt.instant.periods.value
 value(t::Time) = t.instant.value
 days(dt::Date) = value(dt)
 days(dt::DateTime) = fld(value(dt), 86400000)
-year(dt::TimeType) = _year(days(dt))
-quarter(dt::TimeType) = _quarter(days(dt))
-month(dt::TimeType) = _month(days(dt))
-week(dt::TimeType) = _week(days(dt))
-day(dt::TimeType) = _day(days(dt))
+year(dt::TimeType) = year(days(dt))
+quarter(dt::TimeType) = quarter(days(dt))
+month(dt::TimeType) = month(days(dt))
+week(dt::TimeType) = week(days(dt))
+day(dt::TimeType) = day(days(dt))
 hour(dt::DateTime)   = mod(fld(value(dt), 3600000), 24)
 minute(dt::DateTime) = mod(fld(value(dt), 60000), 60)
 second(dt::DateTime) = mod(fld(value(dt), 1000), 60)
@@ -70,9 +70,9 @@ nanosecond(t::Time) = mod(value(t), Int64(1000))
 
 dayofmonth(dt::TimeType) = day(dt)
 
-yearmonth(dt::TimeType) = _yearmonth(days(dt))
-monthday(dt::TimeType) = _monthday(days(dt))
-yearmonthday(dt::TimeType) = _yearmonthday(days(dt))
+yearmonth(dt::TimeType) = yearmonth(days(dt))
+monthday(dt::TimeType) = monthday(days(dt))
+yearmonthday(dt::TimeType) = yearmonthday(days(dt))
 
 # Documentation for exported accessors
 for func in (:year, :month, :quarter)

From fda02ac9e33e825fcca947af919ebf15d39c0605 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Sat, 20 Apr 2024 15:05:38 +0200
Subject: [PATCH 1302/1315] use correct size when creating output data from an
 IOBuffer (#54129)

PR from https://github.com/JuliaLang/julia/issues/54097.

Fixes #54097

Co-authored-by: Nathan Zimmerberg
---
 base/iobuffer.jl | 2 +-
 test/iobuffer.jl | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index 6b8d694ec03fb..f9585b0599919 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -468,7 +468,7 @@ function take!(io::IOBuffer)
         elseif io.writable
             data = view(io.data, io.offset+1:nbytes+io.offset)
         else
-            data = copyto!(StringVector(io.size), 1, io.data, io.offset + 1, nbytes)
+            data = copyto!(StringVector(nbytes), 1, io.data, io.offset + 1, nbytes)
         end
     else
         nbytes = bytesavailable(io)
diff --git a/test/iobuffer.jl b/test/iobuffer.jl
index 8c49b7ec83327..d82a68c61f780 100644
--- a/test/iobuffer.jl
+++ b/test/iobuffer.jl
@@ -383,3 +383,8 @@ end
     seek(io,0)
     @test Base.read_sub(io,v,1,1) == [1,0]
 end
+
+@testset "with offset" begin
+    b = pushfirst!([0x02], 0x01)
+    @test take!(IOBuffer(b)) == [0x01, 0x02]
+end

From 033abb4187485fb745599cad02dc54c6957e670c Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Sat, 20 Apr 2024 10:51:52 -0400
Subject: [PATCH 1303/1315] =?UTF-8?q?note=20infix=20syntax=20for=20"in"=20?=
 =?UTF-8?q?and=20"=E2=88=88"=20(#54091)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I noticed that the docstring for `in` did not mention the infix syntax
up-front, making it easier to [be confused about the argument
order](https://discourse.julialang.org/t/in-x-y-and-y-in-x-behave-differently/112965).
---
 base/operators.jl | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/base/operators.jl b/base/operators.jl
index 26274307ba05c..13d2b2fe684a2 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -1382,11 +1382,15 @@ a function equivalent to `y -> item in y`.
 
 Determine whether an item is in the given collection, in the sense that it is
 [`==`](@ref) to one of the values generated by iterating over the collection.
+Can equivalently be used with infix syntax:
+
+    item in collection
+    item ∈ collection
+
 Return a `Bool` value, except if `item` is [`missing`](@ref) or `collection`
 contains `missing` but not `item`, in which case `missing` is returned
 ([three-valued logic](https://en.wikipedia.org/wiki/Three-valued_logic),
 matching the behavior of [`any`](@ref) and [`==`](@ref)).
-
 Some collections follow a slightly different definition. For example,
 [`Set`](@ref)s check whether the item [`isequal`](@ref) to one of the elements;
 [`Dict`](@ref)s look for `key=>value` pairs, and the `key` is compared using

From a84ed8256a9fb2617526543e47cea9ec4526b7fa Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Sat, 20 Apr 2024 16:53:38 +0200
Subject: [PATCH 1304/1315] Fixup IdSet docstring (#54153)

* `IdSet{T}` has values of type `T`, not `V`
* Test the example
* Properly format the example
---
 base/idset.jl | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/base/idset.jl b/base/idset.jl
index 23f9ca009af0c..c46d49968ff73 100644
--- a/base/idset.jl
+++ b/base/idset.jl
@@ -5,14 +5,13 @@
     IdSet()
 
 IdSet{T}() constructs a set (see [`Set`](@ref)) using
-`===` as equality with values of type `V`.
+`===` as equality with values of type `T`.
 
-In the example below, the values are all `isequal` so they get overwritten.
-The `IdSet` compares by `===` so preserves the 3 different keys.
-
-Examples
-≡≡≡≡≡≡≡≡
+In the example below, the values are all `isequal` so they get overwritten in the ordinary `Set`.
+The `IdSet` compares by `===` and so preserves the 3 different values.
 
+# Examples
+```jldoctest; filter = r"\\n\\s*(1|1\\.0|true)"
 julia> Set(Any[true, 1, 1.0])
 Set{Any} with 1 element:
   1.0
@@ -22,6 +21,7 @@ IdSet{Any} with 3 elements:
   1.0
   1
   true
+```
 """
 mutable struct IdSet{K} <: AbstractSet{K}
     list::Memory{Any}

From 13155226e11fa025be5d4d3033d25c1091b35887 Mon Sep 17 00:00:00 2001
From: Peter Steinbach <p.steinbach@hzdr.de>
Date: Sat, 20 Apr 2024 16:55:18 +0200
Subject: [PATCH 1305/1315] move export statement to start of Example.jl in
 Test.jl documentation (#54040)

---
 stdlib/Test/docs/src/index.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stdlib/Test/docs/src/index.md b/stdlib/Test/docs/src/index.md
index 949c2591474a6..c1fe9e8e20c63 100644
--- a/stdlib/Test/docs/src/index.md
+++ b/stdlib/Test/docs/src/index.md
@@ -417,6 +417,8 @@ Add the following to `src/Example.jl`:
 ```julia
 module Example
 
+export greet, simple_add, type_multiply
+
 function greet()
     "Hello world!"
 end
@@ -429,8 +431,6 @@ function type_multiply(a::Float64, b::Float64)
     a * b
 end
 
-export greet, simple_add, type_multiply
-
 end
 ```
 

From 2aa55e21119403cf6ed1b8fcb2c206888c61fa28 Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Sun, 21 Apr 2024 01:25:48 +0200
Subject: [PATCH 1306/1315] require one based indexing for
 `isone(::AbstractArray)` (#54165)

Fixes #54163
---
 stdlib/LinearAlgebra/src/dense.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 4ed3b8624c47b..47839fc6fd003 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -14,6 +14,7 @@ const NRM2_CUTOFF = 32
 const ISONE_CUTOFF = 2^21 # 2M
 
 function isone(A::AbstractMatrix)
+    require_one_based_indexing(A)  # multiplication not defined yet among offset matrices
     m, n = size(A)
     m != n && return false # only square matrices can satisfy x == one(x)
     if sizeof(A) < ISONE_CUTOFF

From aad72458539946bc7f2b1d1f6092f963fed4bd8c Mon Sep 17 00:00:00 2001
From: Neven Sajko <s@purelymail.com>
Date: Sun, 21 Apr 2024 01:40:41 +0200
Subject: [PATCH 1307/1315] make `one(::AbstractMatrix)` use `similar` instead
 of `zeros` (#54162)

---
 base/abstractarray.jl | 17 +++++++++++++++++
 base/array.jl         | 15 ---------------
 test/abstractarray.jl | 17 +++++++++++++++++
 3 files changed, 34 insertions(+), 15 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index cef81d6925284..1de59d9d2ac3b 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1221,6 +1221,23 @@ zero(x::AbstractArray{T}) where {T<:Number} = fill!(similar(x, typeof(zero(T))),
 zero(x::AbstractArray{S}) where {S<:Union{Missing, Number}} = fill!(similar(x, typeof(zero(S))), zero(S))
 zero(x::AbstractArray) = map(zero, x)
 
+function _one(unit::T, mat::AbstractMatrix) where {T}
+    (rows, cols) = axes(mat)
+    (length(rows) == length(cols)) ||
+      throw(DimensionMismatch("multiplicative identity defined only for square matrices"))
+    zer = zero(unit)::T
+    require_one_based_indexing(mat)
+    I = similar(mat, T)
+    fill!(I, zer)
+    for i ∈ rows
+        I[i, i] = unit
+    end
+    I
+end
+
+one(x::AbstractMatrix{T}) where {T} = _one(one(T), x)
+oneunit(x::AbstractMatrix{T}) where {T} = _one(oneunit(T), x)
+
 ## iteration support for arrays by iterating over `eachindex` in the array ##
 # Allows fast iteration by default for both IndexLinear and IndexCartesian arrays
 
diff --git a/base/array.jl b/base/array.jl
index db20eaa5794f2..49cf0e9d03e7b 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -598,21 +598,6 @@ for (fname, felt) in ((:zeros, :zero), (:ones, :one))
     end
 end
 
-function _one(unit::T, x::AbstractMatrix) where T
-    require_one_based_indexing(x)
-    m,n = size(x)
-    m==n || throw(DimensionMismatch("multiplicative identity defined only for square matrices"))
-    # Matrix{T}(I, m, m)
-    I = zeros(T, m, m)
-    for i in 1:m
-        I[i,i] = unit
-    end
-    I
-end
-
-one(x::AbstractMatrix{T}) where {T} = _one(one(T), x)
-oneunit(x::AbstractMatrix{T}) where {T} = _one(oneunit(T), x)
-
 ## Conversions ##
 
 convert(::Type{T}, a::AbstractArray) where {T<:Array} = a isa T ? a : T(a)::T
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index feb6adaf39fdd..04d3ccc6805d2 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -2119,3 +2119,20 @@ end
         end
     end
 end
+
+@testset "one" begin
+    @test one([1 2; 3 4]) == [1 0; 0 1]
+    @test one([1 2; 3 4]) isa Matrix{Int}
+
+    struct Mat <: AbstractMatrix{Int}
+        p::Matrix{Int}
+    end
+    Base.size(m::Mat) = size(m.p)
+    Base.IndexStyle(::Type{<:Mat}) = IndexLinear()
+    Base.getindex(m::Mat, i::Int) = m.p[i]
+    Base.setindex!(m::Mat, v, i::Int) = m.p[i] = v
+    Base.similar(::Mat, ::Type{Int}, size::NTuple{2,Int}) = Mat(Matrix{Int}(undef, size))
+
+    @test one(Mat([1 2; 3 4])) == Mat([1 0; 0 1])
+    @test one(Mat([1 2; 3 4])) isa Mat
+end

From e57a7e49ad71241cc70ccdc0c1279274992f7dc9 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Sun, 21 Apr 2024 23:16:29 +0530
Subject: [PATCH 1308/1315] Forward aliasing check for `ReshapedArray`s to the
 parent (#54168)

---
 base/reshapedarray.jl |  5 +++++
 test/subarray.jl      | 16 ++++++++++++++++
 2 files changed, 21 insertions(+)

diff --git a/base/reshapedarray.jl b/base/reshapedarray.jl
index f1bcc9fe303a7..6cf2b9b482016 100644
--- a/base/reshapedarray.jl
+++ b/base/reshapedarray.jl
@@ -225,6 +225,11 @@ elsize(::Type{<:ReshapedArray{<:Any,<:Any,P}}) where {P} = elsize(P)
 
 unaliascopy(A::ReshapedArray) = typeof(A)(unaliascopy(A.parent), A.dims, A.mi)
 dataids(A::ReshapedArray) = dataids(A.parent)
+# forward the aliasing check the parent in case there are specializations
+mightalias(A::ReshapedArray, B::ReshapedArray) = mightalias(parent(A), parent(B))
+# special handling for reshaped SubArrays that dispatches to the subarray aliasing check
+mightalias(A::ReshapedArray, B::SubArray) = mightalias(parent(A), B)
+mightalias(A::SubArray, B::ReshapedArray) = mightalias(A, parent(B))
 
 @inline ind2sub_rs(ax, ::Tuple{}, i::Int) = (i,)
 @inline ind2sub_rs(ax, strds, i) = _ind2sub_rs(ax, strds, i - 1)
diff --git a/test/subarray.jl b/test/subarray.jl
index 0c29c6a784efd..106dc6c2afcdd 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -1120,3 +1120,19 @@ end
         end
     end
 end
+
+@testset "aliasing check with reshaped subarrays" begin
+    C = rand(2,1)
+    V1 = @view C[1, :]
+    V2 = @view C[2, :]
+
+    @test !Base.mightalias(V1, V2)
+    @test !Base.mightalias(V1, permutedims(V2))
+    @test !Base.mightalias(permutedims(V1), V2)
+    @test !Base.mightalias(permutedims(V1), permutedims(V2))
+
+    @test Base.mightalias(V1, V1)
+    @test Base.mightalias(V1, permutedims(V1))
+    @test Base.mightalias(permutedims(V1), V1)
+    @test Base.mightalias(permutedims(V1), permutedims(V1))
+end

From c1b3661b8f9983a767fefdf639ef2b69ed4d971b Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <kshyatt@users.noreply.github.com>
Date: Sun, 21 Apr 2024 22:03:59 -0400
Subject: [PATCH 1309/1315] More tests for irrationals (#54172)

https://coveralls.io/builds/67039158/source?filename=base%2Firrationals.jl
according to coveralls some of this isn't covered
---
 test/numbers.jl | 28 ++++++++++++++++++++++++----
 1 file changed, 24 insertions(+), 4 deletions(-)

diff --git a/test/numbers.jl b/test/numbers.jl
index 4f5893da0d091..234e999e9427e 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -1114,10 +1114,30 @@ end
 end
 
 @testset "Irrational zero and one" begin
-    @test one(pi) === true
-    @test zero(pi) === false
-    @test one(typeof(pi)) === true
-    @test zero(typeof(pi)) === false
+    for i in (π, ℯ, γ, catalan)
+        @test one(i) === true
+        @test zero(i) === false
+        @test one(typeof(i)) === true
+        @test zero(typeof(i)) === false
+    end
+end
+
+@testset "Irrational iszero, isfinite, isinteger, and isone" begin
+    for i in (π, ℯ, γ, catalan)
+        @test !iszero(i)
+        @test !isone(i)
+        @test !isinteger(i)
+        @test isfinite(i)
+    end
+end
+
+@testset "Irrational promote_type" begin
+    for T in (Float16, Float32, Float64)
+        for i in (π, ℯ, γ, catalan)
+            @test T(2.0) * i ≈ T(2.0) * T(i)
+            @test T(2.0) * i isa T
+        end
+    end
 end
 
 @testset "Irrationals compared with Irrationals" begin

From fe49d5661833e512a557913591514fcd32f7b783 Mon Sep 17 00:00:00 2001
From: Klaus Crusius <KlausC@users.noreply.github.com>
Date: Mon, 22 Apr 2024 05:47:57 +0200
Subject: [PATCH 1310/1315] power uses Float64 exponents for integers (#53967)

Improve performance of `^(::Float64, n::Integer)` in the case of `abs(n)
> 2^13`.

While `pow_body` is unreliable for `abs(n) > 2^25` this implementation
provides errors of a few ULPs, while runtime is capped to that of the
`Float64` implementation.

Fixes  #53881
See also #53886.
---
 base/math.jl             | 52 +++++++++++++++++++++++++++++++---------
 base/special/exp.jl      |  2 +-
 test/compiler/codegen.jl |  2 +-
 test/math.jl             | 19 +++++++++++++++
 4 files changed, 62 insertions(+), 13 deletions(-)

diff --git a/base/math.jl b/base/math.jl
index c9ee4b81caafa..14242ba381cde 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -1261,6 +1261,10 @@ function modf(x::T) where T<:IEEEFloat
     return (rx, ix)
 end
 
+@inline function use_power_by_squaring(n::Integer)
+    -2^12 <= n <= 3 * 2^13
+end
+
 # @constprop aggressive to help the compiler see the switch between the integer and float
 # variants for callers with constant `y`
 @constprop :aggressive function ^(x::Float64, y::Float64)
@@ -1273,24 +1277,33 @@ end
         y = sign(y)*0x1.8p62
     end
     yint = unsafe_trunc(Int64, y) # This is actually safe since julia freezes the result
-    y == yint && return @noinline x^yint
-    2*xu==0 && return abs(y)*Inf*(!(y>0)) # if x==0
-    x<0 && throw_exp_domainerror(x) # |y| is small enough that y isn't an integer
-    !isfinite(x) && return x*(y>0 || isnan(x))           # x is inf or NaN
+    yisint = y == yint
+    if yisint
+        yint == 0 && return 1.0
+        use_power_by_squaring(yint) && return @noinline pow_body(x, yint)
+    end
+    2*xu==0 && return abs(y)*Inf*(!(y>0)) # if x === +0.0 or -0.0 (Inf * false === 0.0)
+    s = 1
+    if x < 0
+        !yisint && throw_exp_domainerror(x) # y isn't an integer
+        s = ifelse(isodd(yint), -1, 1)
+    end
+    !isfinite(x) && return copysign(x,s)*(y>0 || isnan(x))           # x is inf or NaN
+    return copysign(pow_body(abs(x), y), s)
+end
+
+@assume_effects :foldable @noinline function pow_body(x::Float64, y::Float64)
+    xu = reinterpret(UInt64, x)
     if xu < (UInt64(1)<<52) # x is subnormal
         xu = reinterpret(UInt64, x * 0x1p52) # normalize x
         xu &= ~sign_mask(Float64)
         xu -= UInt64(52) << 52 # mess with the exponent
     end
-    return pow_body(xu, y)
-end
-
-@inline function pow_body(xu::UInt64, y::Float64)
     logxhi,logxlo = _log_ext(xu)
     xyhi, xylo = two_mul(logxhi,y)
     xylo = muladd(logxlo, y, xylo)
     hi = xyhi+xylo
-    return Base.Math.exp_impl(hi, xylo-(hi-xyhi), Val(:ℯ))
+    return @inline Base.Math.exp_impl(hi, xylo-(hi-xyhi), Val(:ℯ))
 end
 
 @constprop :aggressive function ^(x::T, y::T) where T <: Union{Float16, Float32}
@@ -1314,12 +1327,29 @@ end
     return T(exp2(log2(abs(widen(x))) * y))
 end
 
-# compensated power by squaring
 @constprop :aggressive @inline function ^(x::Float64, n::Integer)
+    x^clamp(n, Int64)
+end
+@constprop :aggressive @inline function ^(x::Float64, n::Int64)
     n == 0 && return one(x)
-    return pow_body(x, n)
+    if use_power_by_squaring(n)
+        return pow_body(x, n)
+    else
+        s = ifelse(x < 0 && isodd(n), -1.0, 1.0)
+        x = abs(x)
+        y = float(n)
+        if y == n
+            return copysign(pow_body(x, y), s)
+        else
+            n2 = n % 1024
+            y = float(n - n2)
+            return pow_body(x, y) * copysign(pow_body(x, n2), s)
+        end
+    end
 end
 
+# compensated power by squaring
+# this method is only reliable for -2^20 < n < 2^20 (cf. #53881 #53886)
 @assume_effects :terminates_locally @noinline function pow_body(x::Float64, n::Integer)
     y = 1.0
     xnlo = ynlo = 0.0
diff --git a/base/special/exp.jl b/base/special/exp.jl
index 8e940a4d85ad9..312197339a086 100644
--- a/base/special/exp.jl
+++ b/base/special/exp.jl
@@ -250,7 +250,7 @@ end
             twopk = (k + UInt64(53)) << 52
             return reinterpret(T, twopk + reinterpret(UInt64, small_part))*0x1p-53
         end
-        #k == 1024 && return (small_part * 2.0) * 2.0^1023
+        k == 1024 && return (small_part * 2.0) * 2.0^1023
     end
     twopk = Int64(k) << 52
     return reinterpret(T, twopk + reinterpret(Int64, small_part))
diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl
index 805e5c7acc817..3ad7c9bbb71d4 100644
--- a/test/compiler/codegen.jl
+++ b/test/compiler/codegen.jl
@@ -866,7 +866,7 @@ if Sys.ARCH === :x86_64
     foo52079() = Core.Intrinsics.have_fma(Float64)
     if foo52079() == true
         let io = IOBuffer()
-            code_native(io,^,(Float64,Float64), dump_module=false)
+            code_native(io,Base.Math.exp_impl,(Float64,Float64,Val{:ℯ}), dump_module=false)
             str = String(take!(io))
             @test !occursin("fma_emulated", str)
             @test occursin("vfmadd", str)
diff --git a/test/math.jl b/test/math.jl
index 8306345b3d45f..421c5387a522f 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -1470,6 +1470,25 @@ end
     # two cases where we have observed > 1 ULP in the past
     @test 0.0013653274095082324^-97.60372292227069 == 4.088393948750035e279
     @test 8.758520413376658e-5^70.55863059215994 == 5.052076767078296e-287
+
+    # issue #53881
+    c53881 = 2.2844135865398217e222 # check correctness within 2 ULPs
+    @test prevfloat(1.0) ^ -Int64(2)^62 ≈ c53881 atol=2eps(c53881)
+    @test 2.0 ^ typemin(Int) == 0.0
+    @test (-1.0) ^ typemin(Int) == 1.0
+    Z = Int64(2)
+    E = prevfloat(1.0)
+    @test E ^ (-Z^54) ≈ 7.38905609893065
+    @test E ^ (-Z^62) ≈ 2.2844135865231613e222
+    @test E ^ (-Z^63) == Inf
+    @test abs(E ^ (Z^62-1) * E ^ (-Z^62+1) - 1) <= eps(1.0)
+    n, x = -1065564664, 0.9999997040311492
+    @test abs(x^n - Float64(big(x)^n)) / eps(x^n) == 0 # ULPs
+    @test E ^ (big(2)^100 + 1) == 0
+    @test E ^ 6705320061009595392 == nextfloat(0.0)
+    n = Int64(1024 / log2(E))
+    @test E^n == Inf
+    @test E^float(n) == Inf
 end
 
 # Test that sqrt behaves correctly and doesn't exhibit fp80 double rounding.

From 903ffff167fd08d617fd460becd9b125f424dd0b Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <kshyatt@users.noreply.github.com>
Date: Mon, 22 Apr 2024 00:40:17 -0400
Subject: [PATCH 1311/1315] Some basic tests for untested task getproperty
 paths (#54176)

https://coveralls.io/builds/67039158/source?filename=base%2Ftask.jl#L163
a few branches here aren't covered
---
 test/channels.jl | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/channels.jl b/test/channels.jl
index 25b5185c1a336..5e81f477126cd 100644
--- a/test/channels.jl
+++ b/test/channels.jl
@@ -638,3 +638,10 @@ end
         @test n_avail(c) == 0
     end
 end
+
+@testset "Task properties" begin
+    f() = rand(2,2)
+    t = Task(f)
+    @test_throws ErrorException("Querying `scope` is disallowed. Use `current_scope` instead.") t.scope
+    @test t.state == :runnable
+end

From 8c28ac6880e8b6ccc7fe393a7630cdc2692efac7 Mon Sep 17 00:00:00 2001
From: gitboy16 <82724369+gitboy16@users.noreply.github.com>
Date: Mon, 22 Apr 2024 12:38:34 +0100
Subject: [PATCH 1312/1315] Update command line options (#54066)

Update command line option formatting.
---
 src/jloptions.c | 220 +++++++++++++++++++++++++++---------------------
 1 file changed, 123 insertions(+), 97 deletions(-)

diff --git a/src/jloptions.c b/src/jloptions.c
index 6980d4b8b235c..3a2c26165e63e 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -106,133 +106,159 @@ JL_DLLEXPORT void jl_init_options(void)
 
 static const char usage[] = "\n    julia [switches] -- [programfile] [args...]\n\n";
 static const char opts[]  =
-    "Switches (a '*' marks the default value, if applicable; settings marked '($)' may trigger package precompilation):\n\n"
-    " -v, --version              Display version information\n"
-    " -h, --help                 Print command-line options (this message)\n"
-    " --help-hidden              Print uncommon options not shown by `-h`\n\n"
+    "Switches (a '*' marks the default value, if applicable; settings marked '($)' may trigger package\n"
+    "precompilation):\n\n"
+    " Option                                        Description\n"
+    " ---------------------------------------------------------------------------------------------------\n"
+    " -v, --version                                 Display version information\n"
+    " -h, --help                                    Print command-line options (this message)\n"
+    " --help-hidden                                 Print uncommon options not shown by `-h`\n\n"
 
     // startup options
-    " --project[={<dir>|@.}]     Set <dir> as the active project/environment.\n"
-    "                            The default @. option will search through parent directories\n"
-    "                            until a Project.toml or JuliaProject.toml file is found.\n"
-    " -J, --sysimage <file>      Start up with the given system image file\n"
-    " -H, --home <dir>           Set location of `julia` executable\n"
-    " --startup-file={yes*|no}   Load `JULIA_DEPOT_PATH/config/startup.jl`; if `JULIA_DEPOT_PATH`\n"
-    "                            environment variable is unset, load `~/.julia/config/startup.jl`\n"
-    " --handle-signals={yes*|no} Enable or disable Julia's default signal handlers\n"
-    " --sysimage-native-code={yes*|no}\n"
-    "                            Use native code from system image if available\n"
-    " --compiled-modules={yes*|no|existing|strict}\n"
-    "                            Enable or disable incremental precompilation of modules\n"
-    "                            The `existing` option allows use of existing compiled modules that were\n"
-    "                            previously precompiled, but disallows creation of new precompile files.\n"
-    "                            The `strict` option is similar, but will error if no precompile file is found.\n"
-    " --pkgimages={yes*|no|existing}\n"
-    "                            Enable or disable usage of native code caching in the form of pkgimages\n"
-    "                            The `existing` option allows use of existing pkgimages but disallows creation of new ones ($)\n\n"
+    " --project[={<dir>|@.}]                        Set <dir> as the active project/environment.\n"
+    "                                               The default @. option will search through parent\n"
+    "                                               directories until a Project.toml or JuliaProject.toml\n"
+    "                                               file is found.\n"
+    " -J, --sysimage <file>                         Start up with the given system image file\n"
+    " -H, --home <dir>                              Set location of `julia` executable\n"
+    " --startup-file={yes*|no}                      Load `JULIA_DEPOT_PATH/config/startup.jl`; \n"
+    "                                               if `JULIA_DEPOT_PATH` environment variable is unset,\n"
+    "                                               load `~/.julia/config/startup.jl`\n"
+    " --handle-signals={yes*|no}                    Enable or disable Julia's default signal handlers\n"
+    " --sysimage-native-code={yes*|no}              Use native code from system image if available\n"
+    " --compiled-modules={yes*|no|existing|strict}  Enable or disable incremental precompilation of\n"
+    "                                               modules. The `existing` option allows use of existing\n"
+    "                                               compiled modules that were previously precompiled,\n"
+    "                                               but disallows creation of new precompile files.\n"
+    "                                               The `strict` option is similar, but will error if no\n"
+    "                                               precompile file is found.\n"
+    " --pkgimages={yes*|no|existing}                Enable or disable usage of native code caching in the\n"
+    "                                               form of pkgimages. The `existing` option allows use\n"
+    "                                               of existing pkgimages but disallows creation of new\n"
+    "                                               ones ($)\n\n"
 
     // actions
-    " -e, --eval <expr>          Evaluate <expr>\n"
-    " -E, --print <expr>         Evaluate <expr> and display the result\n"
-    " -m, --module <Package> [args]\n"
-    "                            Run entry point of `Package` (`@main` function) with `args'.\n"
-    " -L, --load <file>          Load <file> immediately on all processors\n\n"
+    " -e, --eval <expr>                             Evaluate <expr>\n"
+    " -E, --print <expr>                            Evaluate <expr> and display the result\n"
+    " -m, --module <Package> [args]                 Run entry point of `Package` (`@main` function) with\n"
+    "                                               `args'.\n"
+    " -L, --load <file>                             Load <file> immediately on all processors\n\n"
 
     // parallel options
-    " -t, --threads {auto|N[,auto|M]}\n"
-    "                           Enable N[+M] threads; N threads are assigned to the `default`\n"
-    "                           threadpool, and if M is specified, M threads are assigned to the\n"
-    "                           `interactive` threadpool; `auto` tries to infer a useful\n"
-    "                           default number of threads to use but the exact behavior might change\n"
-    "                           in the future. Currently sets N to the number of CPUs assigned to\n"
-    "                           this Julia process based on the OS-specific affinity assignment\n"
-    "                           interface if supported (Linux and Windows) or to the number of CPU\n"
-    "                           threads if not supported (MacOS) or if process affinity is not\n"
-    "                           configured, and sets M to 1.\n"
-    " --gcthreads=N[,M]         Use N threads for the mark phase of GC and M (0 or 1) threads for the concurrent sweeping phase of GC.\n"
-    "                           N is set to half of the number of compute threads and M is set to 0 if unspecified.\n"
-    " -p, --procs {N|auto}      Integer value N launches N additional local worker processes\n"
-    "                           `auto` launches as many workers as the number of local CPU threads (logical cores)\n"
-    " --machine-file <file>     Run processes on hosts listed in <file>\n\n"
+    " -t, --threads {auto|N[,auto|M]}               Enable N[+M] threads; N threads are assigned to the\n"
+    "                                               `default` threadpool, and if M is specified, M\n"
+    "                                               threads are assigned to the `interactive`\n"
+    "                                               threadpool; `auto` tries to infer a useful\n"
+    "                                               default number of threads to use but the exact\n"
+    "                                               behavior might change in the future. Currently sets\n"
+    "                                               N to the number of CPUs assigned to this Julia\n"
+    "                                               process based on the OS-specific affinity assignment\n"
+    "                                               interface if supported (Linux and Windows) or to the\n"
+    "                                               number of CPU threads if not supported (MacOS) or if\n"
+    "                                               process affinity is not configured, and sets M to 1.\n"
+    " --gcthreads=N[,M]                             Use N threads for the mark phase of GC and M (0 or 1)\n"
+    "                                               threads for the concurrent sweeping phase of GC.\n"
+    "                                               N is set to half of the number of compute threads and\n"
+    "                                               M is set to 0 if unspecified.\n"
+    " -p, --procs {N|auto}                          Integer value N launches N additional local worker\n"
+    "                                               processes `auto` launches as many workers as the\n"
+    "                                               number of local CPU threads (logical cores).\n"
+    " --machine-file <file>                         Run processes on hosts listed in <file>\n\n"
 
     // interactive options
-    " -i, --interactive          Interactive mode; REPL runs and `isinteractive()` is true\n"
-    " -q, --quiet                Quiet startup: no banner, suppress REPL warnings\n"
-    " --banner={yes|no|short|auto*}\n"
-    "                            Enable or disable startup banner\n"
-    " --color={yes|no|auto*}     Enable or disable color text\n"
-    " --history-file={yes*|no}   Load or save history\n\n"
+    " -i, --interactive                             Interactive mode; REPL runs and\n"
+    "                                               `isinteractive()` is true.\n"
+    " -q, --quiet                                   Quiet startup: no banner, suppress REPL warnings\n"
+    " --banner={yes|no|short|auto*}                 Enable or disable startup banner\n"
+    " --color={yes|no|auto*}                        Enable or disable color text\n"
+    " --history-file={yes*|no}                      Load or save history\n\n"
 
     // error and warning options
-    " --depwarn={yes|no*|error}  Enable or disable syntax and method deprecation warnings (`error` turns warnings into errors)\n"
-    " --warn-overwrite={yes|no*} Enable or disable method overwrite warnings\n"
-    " --warn-scope={yes*|no}     Enable or disable warning for ambiguous top-level scope\n\n"
+    " --depwarn={yes|no*|error}                     Enable or disable syntax and method deprecation\n"
+    "                                               warnings (`error` turns warnings into errors)\n"
+    " --warn-overwrite={yes|no*}                    Enable or disable method overwrite warnings\n"
+    " --warn-scope={yes*|no}                        Enable or disable warning for ambiguous top-level\n"
+    "                                               scope\n\n"
 
     // code generation options
-    " -C, --cpu-target <target>  Limit usage of CPU features up to <target>; set to `help` to see the available options\n"
-    " -O, --optimize={0|1|2*|3}  Set the optimization level (level 3 if `-O` is used without a level) ($)\n"
-    " --min-optlevel={0*|1|2|3}  Set a lower bound on the optimization level\n"
+    " -C, --cpu-target <target>                     Limit usage of CPU features up to <target>; set to\n"
+    "                                               `help` to see the available options\n"
+    " -O, --optimize={0|1|2*|3}                     Set the optimization level (level 3 if `-O` is used\n"
+    "                                               without a level) ($)\n"
+    " --min-optlevel={0*|1|2|3}                     Set a lower bound on the optimization level\n"
 #ifdef JL_DEBUG_BUILD
-        " -g, --debug-info=[{0|1|2*}] Set the level of debug info generation in the julia-debug build ($)\n"
+    " -g, --debug-info=[{0|1|2*}]                   Set the level of debug info generation in the\n"
+    "                                               julia-debug build ($)\n"
 #else
-        " -g, --debug-info=[{0|1*|2}] Set the level of debug info generation (level 2 if `-g` is used without a level) ($)\n"
+    " -g, --debug-info=[{0|1*|2}]                   Set the level of debug info generation (level 2 if\n"
+    "                                               `-g` is used without a level) ($)\n"
 #endif
-    " --inline={yes*|no}         Control whether inlining is permitted, including overriding @inline declarations\n"
-    " --check-bounds={yes|no|auto*}\n"
-    "                            Emit bounds checks always, never, or respect @inbounds declarations ($)\n"
-    " --math-mode={ieee|user*}   Always follow `ieee` floating point semantics or respect `@fastmath` declarations\n\n"
+    " --inline={yes*|no}                            Control whether inlining is permitted, including\n"
+    "                                               overriding @inline declarations\n"
+    " --check-bounds={yes|no|auto*}                 Emit bounds checks always, never, or respect\n"
+    "                                               @inbounds declarations ($)\n"
+    " --math-mode={ieee|user*}                      Always follow `ieee` floating point semantics or\n"
+    "                                               respect `@fastmath` declarations\n\n"
 #ifdef USE_POLLY
-    " --polly={yes*|no}          Enable or disable the polyhedral optimizer Polly (overrides @polly declaration)\n"
+    " --polly={yes*|no}                             Enable or disable the polyhedral optimizer Polly\n"
+    "                                               (overrides @polly declaration)\n"
 #endif
 
     // instrumentation options
-    " --code-coverage[={none*|user|all}]\n"
-    "                            Count executions of source lines (omitting setting is equivalent to `user`)\n"
-    " --code-coverage=@<path>\n"
-    "                            Count executions but only in files that fall under the given file path/directory.\n"
-    "                            The `@` prefix is required to select this option. A `@` with no path will track the\n"
-    "                            current directory.\n"
+    " --code-coverage[={none*|user|all}]            Count executions of source lines (omitting setting is\n"
+    "                                               equivalent to `user`)\n"
+    " --code-coverage=@<path>                       Count executions but only in files that fall under\n"
+    "                                               the given file path/directory. The `@` prefix is\n"
+    "                                               required to select this option. A `@` with no path\n"
+    "                                               will track the current directory.\n"
 
-    " --code-coverage=tracefile.info\n"
-    "                            Append coverage information to the LCOV tracefile (filename supports format tokens)\n"
+    " --code-coverage=tracefile.info                Append coverage information to the LCOV tracefile\n"
+    "                                               (filename supports format tokens)\n"
 // TODO: These TOKENS are defined in `runtime_ccall.cpp`. A more verbose `--help` should include that list here.
-    " --track-allocation[={none*|user|all}]\n"
-    "                            Count bytes allocated by each source line (omitting setting is equivalent to `user`)\n"
-    " --track-allocation=@<path>\n"
-    "                            Count bytes but only in files that fall under the given file path/directory.\n"
-    "                            The `@` prefix is required to select this option. A `@` with no path will track the\n"
-    "                            current directory.\n"
-    " --bug-report=KIND          Launch a bug report session. It can be used to start a REPL, run a script, or evaluate\n"
-    "                            expressions. It first tries to use BugReporting.jl installed in current environment and\n"
-    "                            fallbacks to the latest compatible BugReporting.jl if not. For more information, see\n"
-    "                            --bug-report=help.\n\n"
-    " --heap-size-hint=<size>    Forces garbage collection if memory usage is higher than the given value.\n"
-    "                            The value may be specified as a number of bytes, optionally in units of\n"
-    "                            KB, MB, GB, or TB, or as a percentage of physical memory with %.\n\n"
+    " --track-allocation[={none*|user|all}]         Count bytes allocated by each source line (omitting\n"
+    "                                               setting is equivalent to `user`)\n"
+    " --track-allocation=@<path>                    Count bytes but only in files that fall under the\n"
+    "                                               given file path/directory. The `@` prefix is required\n"
+    "                                               to select this option. A `@` with no path will track\n"
+    "                                               the current directory.\n"
+    " --bug-report=KIND                             Launch a bug report session. It can be used to start\n"
+    "                                               a REPL, run a script, or evaluate expressions. It\n"
+    "                                               first tries to use BugReporting.jl installed in\n"
+    "                                               current environment and fallbacks to the latest\n"
+    "                                               compatible BugReporting.jl if not. For more\n"
+    "                                               information, see --bug-report=help.\n\n"
+    " --heap-size-hint=<size>                       Forces garbage collection if memory usage is higher\n"
+    "                                               than the given value. The value may be specified as a\n"
+    "                                               number of bytes, optionally in units of KB, MB, GB,\n"
+    "                                               or TB, or as a percentage of physical memory with %.\n\n"
 ;
 
 static const char opts_hidden[]  =
     "Switches (a '*' marks the default value, if applicable):\n\n"
+    " Option                                        Description\n"
+    " ---------------------------------------------------------------------------------------------------\n"
     // code generation options
-    " --compile={yes*|no|all|min}\n"
-    "                          Enable or disable JIT compiler, or request exhaustive or minimal compilation\n\n"
+    " --compile={yes*|no|all|min}                   Enable or disable JIT compiler, or request exhaustive\n"
+    "                                               or minimal compilation\n\n"
 
     // compiler output options
-    " --output-o <name>        Generate an object file (including system image data)\n"
-    " --output-ji <name>       Generate a system image data file (.ji)\n"
-    " --strip-metadata         Remove docstrings and source location info from system image\n"
-    " --strip-ir               Remove IR (intermediate representation) of compiled functions\n\n"
+    " --output-o <name>                             Generate an object file (including system image data)\n"
+    " --output-ji <name>                            Generate a system image data file (.ji)\n"
+    " --strip-metadata                              Remove docstrings and source location info from\n"
+    "                                               system image\n"
+    " --strip-ir                                    Remove IR (intermediate representation) of compiled\n"
+    "                                               functions\n\n"
 
     // compiler debugging (see the devdocs for tips on using these options)
-    " --output-unopt-bc <name> Generate unoptimized LLVM bitcode (.bc)\n"
-    " --output-bc <name>       Generate LLVM bitcode (.bc)\n"
-    " --output-asm <name>      Generate an assembly file (.s)\n"
-    " --output-incremental={yes|no*}\n"
-    "                          Generate an incremental output file (rather than complete)\n"
-    " --trace-compile={stderr|name}\n"
-    "                          Print precompile statements for methods compiled during execution or save to a path\n"
-    " --image-codegen          Force generate code in imaging mode\n"
-    " --permalloc-pkgimg={yes|no*} Copy the data section of package images into memory\n"
+    " --output-unopt-bc <name>                      Generate unoptimized LLVM bitcode (.bc)\n"
+    " --output-bc <name>                            Generate LLVM bitcode (.bc)\n"
+    " --output-asm <name>                           Generate an assembly file (.s)\n"
+    " --output-incremental={yes|no*}                Generate an incremental output file (rather than\n"
+    "                                               complete)\n"
+    " --trace-compile={stderr|name}                 Print precompile statements for methods compiled\n"
+    "                                               during execution or save to a path\n"
+    " --image-codegen                               Force generate code in imaging mode\n"
+    " --permalloc-pkgimg={yes|no*}                  Copy the data section of package images into memory\n"
 ;
 
 JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)

From d6dda7c58552f0a8dfb7fb6d5441f69abdd1e99f Mon Sep 17 00:00:00 2001
From: Milan Bouchet-Valat <nalimilan@club.fr>
Date: Mon, 22 Apr 2024 14:47:08 +0200
Subject: [PATCH 1313/1315] Fix `make install` from tarballs (#54143)

This reverts part of 67b8ac0
(https://github.com/JuliaLang/julia/pull/47596#discussion_r1128658139).
That change broke `make install` from tarballs due to building docs
again, which fails as there's no git repo (and also requires Internet
access to download UnicodeData.txt.

Fixes #54037.
---
 Makefile | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 0c27216d2f9fb..6fbbe194aa615 100644
--- a/Makefile
+++ b/Makefile
@@ -61,6 +61,10 @@ $(foreach link,base $(JULIAHOME)/test,$(eval $(call symlink_target,$(link),$$(bu
 julia_flisp.boot.inc.phony: julia-deps
 	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/src julia_flisp.boot.inc.phony
 
+# Build the HTML docs (skipped if already exists, notably in tarballs)
+$(BUILDROOT)/doc/_build/html/en/index.html: $(shell find $(BUILDROOT)/base $(BUILDROOT)/doc \( -path $(BUILDROOT)/doc/_build -o -path $(BUILDROOT)/doc/deps -o -name *_constants.jl -o -name *_h.jl -o -name version_git.jl \) -prune -o -type f -print)
+	@$(MAKE) docs
+
 julia-symlink: julia-cli-$(JULIA_BUILD_MODE)
 ifeq ($(OS),WINNT)
 	echo '@"%~dp0/'"$$(echo '$(call rel_path,$(BUILDROOT),$(JULIA_EXECUTABLE))')"'" %*' | tr / '\\' > $(BUILDROOT)/julia.bat
@@ -272,7 +276,7 @@ define stringreplace
 endef
 
 
-install: $(build_depsbindir)/stringreplace docs
+install: $(build_depsbindir)/stringreplace $(BUILDROOT)/doc/_build/html/en/index.html
 	@$(MAKE) $(QUIET_MAKE) $(JULIA_BUILD_MODE)
 	@for subdir in $(bindir) $(datarootdir)/julia/stdlib/$(VERSDIR) $(docdir) $(man1dir) $(includedir)/julia $(libdir) $(private_libdir) $(sysconfdir) $(private_libexecdir); do \
 		mkdir -p $(DESTDIR)$$subdir; \
@@ -530,7 +534,7 @@ app:
 darwinframework:
 	$(MAKE) -C $(JULIAHOME)/contrib/mac/framework
 
-light-source-dist.tmp: docs
+light-source-dist.tmp: $(BUILDROOT)/doc/_build/html/en/index.html
 ifneq ($(BUILDROOT),$(JULIAHOME))
 	$(error make light-source-dist does not work in out-of-tree builds)
 endif

From 94b9a9af4fb77fc32d0cbaabd0de06dd6207eb50 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <kshyatt@users.noreply.github.com>
Date: Mon, 22 Apr 2024 09:11:50 -0400
Subject: [PATCH 1314/1315] Add tests for CompositeException (#54174)

Bunch of methods appear untested on Coveralls:
https://coveralls.io/builds/67039158/source?filename=base%2Ftask.jl#L46
---
 test/error.jl | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/test/error.jl b/test/error.jl
index 5d5000333fd30..af1474fb091cd 100644
--- a/test/error.jl
+++ b/test/error.jl
@@ -139,3 +139,24 @@ end
 using .Issue54029
 @test Base.infer_return_type(raise54029, (Any,)) === Union{}
 @test Base.infer_return_type(xs->raise54029(xs...), (Vector{Any},)) === Union{}
+
+@testset "CompositeException" begin
+    ce = CompositeException()
+    @test isempty(ce)
+    @test length(ce) == 0
+    @test eltype(ce) == Any
+    str = sprint(showerror, ce)
+    @test str == "CompositeException()\n"
+    push!(ce, ErrorException("something sad has happened"))
+    @test !isempty(ce)
+    @test length(ce) == 1
+    pushfirst!(ce, ErrorException("something sad has happened even earlier"))
+    @test length(ce) == 2
+    # test iterate
+    for ex in ce
+        @test ex isa ErrorException
+    end
+    push!(ce, ErrorException("something sad has happened yet again"))
+    str = sprint(showerror, ce)
+    @test str == "something sad has happened even earlier\n\n...and 2 more exceptions.\n"
+end

From b5bfd83a3d0ee55f27fbf18dfb9761a3f284fd99 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <kshyatt@users.noreply.github.com>
Date: Mon, 22 Apr 2024 09:12:09 -0400
Subject: [PATCH 1315/1315] Add some hyperbolic function tests for Float16
 (#54171)

For `sinh` we have an untested codepath according to Coveralls. For
others this is more fallback testing.
---
 test/math.jl | 36 +++++++++++++++++++++---------------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/test/math.jl b/test/math.jl
index 421c5387a522f..53468b76c16ae 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -1109,7 +1109,7 @@ pcnfloat(x) = prevfloat(x), x, nextfloat(x)
 import Base.Math: COSH_SMALL_X, H_SMALL_X, H_MEDIUM_X, H_LARGE_X
 
 @testset "sinh" begin
-    for T in (Float32, Float64)
+    for T in (Float16, Float32, Float64)
         @test sinh(zero(T)) === zero(T)
         @test sinh(-zero(T)) === -zero(T)
         @test sinh(nextfloat(zero(T))) === nextfloat(zero(T))
@@ -1117,15 +1117,17 @@ import Base.Math: COSH_SMALL_X, H_SMALL_X, H_MEDIUM_X, H_LARGE_X
         @test sinh(T(1000)) === T(Inf)
         @test sinh(-T(1000)) === -T(Inf)
         @test isnan_type(T, sinh(T(NaN)))
-        for x in Iterators.flatten(pcnfloat.([H_SMALL_X(T), H_MEDIUM_X(T), H_LARGE_X(T)]))
-            @test sinh(x) ≈ sinh(big(x)) rtol=eps(T)
-            @test sinh(-x) ≈ sinh(big(-x)) rtol=eps(T)
+        if T ∈ (Float32, Float64)
+            for x in Iterators.flatten(pcnfloat.([H_SMALL_X(T), H_MEDIUM_X(T), H_LARGE_X(T)]))
+                @test sinh(x) ≈ sinh(big(x)) rtol=eps(T)
+                @test sinh(-x) ≈ sinh(big(-x)) rtol=eps(T)
+            end
         end
     end
 end
 
 @testset "cosh" begin
-    for T in (Float32, Float64)
+    for T in (Float16, Float32, Float64)
         @test cosh(zero(T)) === one(T)
         @test cosh(-zero(T)) === one(T)
         @test cosh(nextfloat(zero(T))) === one(T)
@@ -1133,15 +1135,17 @@ end
         @test cosh(T(1000)) === T(Inf)
         @test cosh(-T(1000)) === T(Inf)
         @test isnan_type(T, cosh(T(NaN)))
-        for x in Iterators.flatten(pcnfloat.([COSH_SMALL_X(T), H_MEDIUM_X(T), H_LARGE_X(T)]))
-            @test cosh(x) ≈ cosh(big(x)) rtol=eps(T)
-            @test cosh(-x) ≈ cosh(big(-x)) rtol=eps(T)
+        if T ∈ (Float32, Float64)
+            for x in Iterators.flatten(pcnfloat.([COSH_SMALL_X(T), H_MEDIUM_X(T), H_LARGE_X(T)]))
+                @test cosh(x) ≈ cosh(big(x)) rtol=eps(T)
+                @test cosh(-x) ≈ cosh(big(-x)) rtol=eps(T)
+            end
         end
     end
 end
 
 @testset "tanh" begin
-    for T in (Float32, Float64)
+    for T in (Float16, Float32, Float64)
         @test tanh(zero(T)) === zero(T)
         @test tanh(-zero(T)) === -zero(T)
         @test tanh(nextfloat(zero(T))) === nextfloat(zero(T))
@@ -1149,9 +1153,11 @@ end
         @test tanh(T(1000)) === one(T)
         @test tanh(-T(1000)) === -one(T)
         @test isnan_type(T, tanh(T(NaN)))
-        for x in Iterators.flatten(pcnfloat.([H_SMALL_X(T), T(1.0), H_MEDIUM_X(T)]))
-            @test tanh(x) ≈ tanh(big(x)) rtol=eps(T)
-            @test tanh(-x) ≈ -tanh(big(x)) rtol=eps(T)
+        if T ∈ (Float32, Float64)
+            for x in Iterators.flatten(pcnfloat.([H_SMALL_X(T), T(1.0), H_MEDIUM_X(T)]))
+                @test tanh(x) ≈ tanh(big(x)) rtol=eps(T)
+                @test tanh(-x) ≈ -tanh(big(x)) rtol=eps(T)
+            end
         end
     end
     @test tanh(18.0) ≈ tanh(big(18.0)) rtol=eps(Float64)
@@ -1159,7 +1165,7 @@ end
 end
 
 @testset "asinh" begin
-    for T in (Float32, Float64)
+    for T in (Float16, Float32, Float64)
         @test asinh(zero(T)) === zero(T)
         @test asinh(-zero(T)) === -zero(T)
         @test asinh(nextfloat(zero(T))) === nextfloat(zero(T))
@@ -1173,7 +1179,7 @@ end
 end
 
 @testset "acosh" begin
-    for T in (Float32, Float64)
+    for T in (Float16, Float32, Float64)
         @test_throws DomainError acosh(T(0.1))
         @test acosh(one(T)) === zero(T)
         @test isnan_type(T, acosh(T(NaN)))
@@ -1184,7 +1190,7 @@ end
 end
 
 @testset "atanh" begin
-    for T in (Float32, Float64)
+    for T in (Float16, Float32, Float64)
         @test_throws DomainError atanh(T(1.1))
         @test atanh(zero(T)) === zero(T)
         @test atanh(-zero(T)) === -zero(T)